From 8f631da7634fc7b3d4a1cd95935d85ed01829f6d Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Wed, 8 Jul 2026 10:59:46 +0800
Subject: [PATCH 01/10] feat(kv): add Fluxon KV integration for SGLang

---
 ...06\346\210\220\350\256\276\350\256\241.md" |  381 ++
 fluxon_py/kvclient/fluxon.py                  |  898 ++++-
 fluxon_py/kvclient/kvclient_interface.py      |  148 +-
 .../src/facade/transfer_engine.rs             |   18 +-
 .../src/lib.rs                                |   53 +-
 fluxon_rs/fluxon_fs/src/agent.rs              |   19 +-
 .../src/agent_service/transfer_agent.rs       | 1662 +++++----
 fluxon_rs/fluxon_fs/src/cache_controller.rs   |    2 +-
 fluxon_rs/fluxon_fs_s3_gateway/src/lib.rs     |    5 +-
 .../fluxon_kv/src/client_kv_api/delete.rs     |  100 +-
 .../src/client_kv_api/external_api.rs         | 2110 ++++++++++-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |  791 +++-
 .../client_kv_api/local_reserve_rebalance.rs  |  308 ++
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 1407 ++++++-
 .../fluxon_kv/src/client_kv_api/msg_pack.rs   |  413 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  | 1666 ++++++++-
 .../fluxon_kv/src/client_seg_pool/mod.rs      |   19 +-
 fluxon_rs/fluxon_kv/src/config.rs             |   73 +-
 .../fluxon_kv/src/external_client_api/mod.rs  | 1776 +++++++--
 fluxon_rs/fluxon_kv/src/kv_test.rs            |   36 +-
 fluxon_rs/fluxon_kv/src/lib.rs                |   56 +-
 .../fluxon_kv/src/master_kv_router/delete.rs  |    5 +-
 .../fluxon_kv/src/master_kv_router/get.rs     |  254 +-
 .../fluxon_kv/src/master_kv_router/mod.rs     |  699 +++-
 .../src/master_kv_router/msg_pack.rs          |  477 ++-
 .../src/master_kv_router/placement.rs         |    6 +-
 .../fluxon_kv/src/master_kv_router/put.rs     | 1397 ++++++-
 .../lease_manager_test.rs                     |   82 +-
 fluxon_rs/fluxon_kv/src/memholder/lifetime.rs |   22 +-
 fluxon_rs/fluxon_kv/src/memholder/mod.rs      |  112 +-
 fluxon_rs/fluxon_kv/src/metrics.rs            |  195 +-
 fluxon_rs/fluxon_kv/src/observe_kvope.rs      |    1 +
 .../rpcresp_kvresult_convert/msg_and_error.rs |   33 +
 .../rpcresp_kvresult_convert.rs               |  251 +-
 fluxon_rs/fluxon_ops/build.rs                 |   20 +-
 fluxon_rs/fluxon_ops/src/lib.rs               |  433 ++-
 fluxon_rs/fluxon_pyo3/src/error.rs            |   25 +-
 fluxon_rs/fluxon_pyo3/src/lib.rs              | 3316 ++++++++++++++++-
 fluxon_rs/fluxon_util/src/dev_config.rs       |    2 +-
 fluxon_rs/fluxon_util/src/lib.rs              |   14 +-
 fluxon_rs/fluxon_util/src/log.rs              |   46 +-
 fluxon_rs/fluxon_util/tests/log_mgmt.rs       |   12 +-
 42 files changed, 17235 insertions(+), 2108 deletions(-)
 create mode 100644 "fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
 create mode 100644 fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs

diff --git "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md" "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
new file mode 100644
index 0000000..8a0dc6d
--- /dev/null
+++ "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
@@ -0,0 +1,381 @@
+# SGLang Fluxon KV 集成设计
+
+## 设计目标
+
+本文说明开源仓库中 SGLang HiCache 接入 Fluxon KV 的 hostless 实现设计，聚焦接口契约、状态归属和生命周期边界。本文不是通用 `FlatDict` KV API 的完整说明。
+
+当前调用链主要分为三条主线：
+
+- 写入侧：`local_fast_put_start -> SGLang native write -> local_fast_put_commit`。
+- 读取侧：`get_start -> get_transfer -> SGLang native restore -> release_views`。
+- 放弃读取侧 restore 时：`cancel_get_transfer` 释放 `get_start` 持有的资源。
+
+Fluxon 仍然按 key 保存 opaque value bytes。SGLang 负责 page key、page layout、MHA/MLA/Mamba value 内部格式、GPU KV cache index 和 native kernel 调度；Fluxon 负责 key-version 路由、put 准入与 reservation、owner-local reserve、host value 地址、holder 生命周期和跨 owner 数据面。
+
+这个集成把 SGLang 逻辑上的 L2/L3 缓存落到 Fluxon 统一管理的本机/远端 KV 层中。这样可以用同一套 owner、holder、commit/release 语义管理 KV page，减少传统 L2 host cache 与 L3 backend 分属不同系统时产生的同机重复缓存和生命周期割裂。
+
+常见部署下，一台机器启动一个 Fluxon owner；同机多个 GPU 对应的多个 SGLang worker 进程通过 external/client attach 到同一个 owner shared segment。相比一个 SGLang 进程一个后端 segment、进程间不共享后端 segment 的形态，Fluxon 把同机 host/shared memory、owner local reserve slots 和 holder 生命周期放到同一个 owner 生命周期模型里。这样多个 SGLang worker 可以通过同一个 owner segment 获得本机快速可见性和受控的本地可写内存供给，减少各进程为了各自安全边界重复持有 KV、固定预留 segment 或独立维护 pin/release 状态带来的浪费。
+
+## 范围边界
+
+| 范围 | 当前结论 |
+| --- | --- |
+| SGLang hostless 写入 | 已接入。SGLang 通过 `local_fast_put_start` 取得一批可写 host value 地址，native kernel 写入后再调用 `local_fast_put_commit` 提交。 |
+| SGLang hostless 读取 | 使用 `get_start/get_transfer/release_views`。`get_start` 先计算连续可恢复前缀，`get_transfer` 再把可恢复前缀转换成 readable `plan_ptr`。 |
+| Fluxon value layout | Fluxon 不理解 KV page 内部布局；只按 `key + value_len` 管理连续字节。 |
+| SGLang node 状态 | SGLang 的 `storage_*` 字段是调度层状态，不等同于 Fluxon master route；跨节点复用以 Fluxon commit future 成功为准。 |
+
+## 总体架构
+
+```mermaid
+flowchart LR
+    A["SGLang HiCache radix node"] --> B["HiCacheFluxon backend"]
+    B --> C["FluxonKVCacheStore"]
+    C --> D["fluxon_pyo3::KvClient"]
+    D --> E["Fluxon external / owner"]
+    E --> F["Fluxon master"]
+
+    B --> G["sgl-kernel kvcacheio"]
+    D --> H["plan_ptr blob<br/>magic/count/value_ptrs"]
+    H --> G
+    G --> I["GPU KV cache"]
+    E --> J["owner shared segment<br/>local reserve slots / MemHolder"]
+    J --> H
+```
+
+这里有两个层次：
+
+- KV 语义层：SGLang 传入 page key，Fluxon 对外保存 `key -> value`。
+- hostless 数据层：Fluxon 返回 `plan_ptr`，SGLang native kernel 根据 blob 里的 `value_ptrs[]` 直接执行 GPU/host 数据传输。
+
+从缓存物理层级看，Fluxon 把传统 L2/L3 逻辑抽象落到 local side / remote side：local side 覆盖本机 GPU KV、owner shared segment、owner local reserve slots 和 `MemHolder`；remote side 覆盖跨 owner 或跨机器的数据面。多个 SGLang worker attach 到同一个 owner segment 时，同机 KV bytes 不需要按 worker 进程重复保存在多个后端 segment 中。
+
+`plan_ptr` 只是一轮 backup 或 restore 的短生命周期 carrier。它不能作为 key、缓存地址、跨进程句柄或长期状态保存。
+
+## 公共契约
+
+本节只列 SGLang HiCache hostless 接入 Fluxon KV 时直接依赖的接口。
+
+| 接口 | 层级 | 契约 |
+| --- | --- | --- |
+| `wait_local_segments_ready()` | Fluxon + SGLang 集成 | 返回当前进程可见的 local segment mapping，供 SGLang 做 CUDA host registration。 |
+| `local_fast_put_start(keys, value_len, opts)` | SGLang hostless 写入 | 为一批等长 values 准备可写地址，返回 put `plan_ptr`。 |
+| `local_fast_put_commit(plan_ptr)` | SGLang hostless 写入 | 在 SGLang native kernel 写完 `value_ptrs[]` 后消费 put plan，把对应 slots 提交为 Fluxon KV route，返回 `KvFuture`。 |
+| `put_abort(plan_ptr)` | SGLang hostless 写入 | 在 commit 前释放 put plan、key reservation 和 local reserve slot lease。 |
+| `GetStartResult` | SGLang hostless 读取 | 描述连续命中前缀、可传输长度、atomic group 命中数和第一个 miss 位置。 |
+| `GetStartHandle` | SGLang hostless 读取 | 持有一次 get-start 结果和 backend handle；必须被 `get_transfer` 消费或被 `cancel_get_transfer` 取消。 |
+| `get_start(keys, prefix_best_effort, atomic_group_lens)` | SGLang hostless 读取 | 按 key 顺序计算连续命中的 prefix，并返回 `GetStartHandle`。 |
+| `get_transfer(handle)` | SGLang hostless 读取 | 消费 handle 的可传输前缀，执行必要 transfer，并返回 readable `plan_ptr`。 |
+| `cancel_get_transfer(handle)` | SGLang hostless 读取 | 放弃未 transfer 的 `GetStartHandle`，释放 get-start 期间持有的 owner/external 资源。 |
+| `release_views(plan_ptr)` | SGLang hostless 读取 | 释放 get-transfer 产生的 readable plan，丢弃其持有的 holder 引用。 |
+
+`PutOptionalArgs` 在 SGLang hostless 写入路径中的语义如下：
+
+| 字段 | SGLang 使用方式 |
+| --- | --- |
+| `reject_if_inflight_same_key` | 固定开启，避免同一 page key 并发写回造成重复 inflight put。 |
+| `reject_if_exist_same_key` | 固定开启，SGLang 把重复 key 当作已写回或冲突重试处理。 |
+| `write_through` | 当前配置决定提交策略；调用方显式传入时 Fluxon 必须按字段语义执行。 |
+| `lease_id` | 当前 SGLang hostless 主线不依赖 lease。 |
+
+## Key 与组件命名
+
+SGLang 传给 Fluxon 的 key 必须先经过 backend namespace 处理：
+
+```text
+storage_key = key_prefix + ":" + logical_key
+logical_key = page_hash + optional_component_suffix + config_suffix + optional_extra_backend_tag
+```
+
+规则：
+
+- page hash 是 SGLang prefix 复用和 Fluxon KV 存取的共同语义 ID。
+- `PoolName.KV` 使用默认 component；Mamba 等额外 component 通过 suffix 区分。
+- `config_suffix` 编入模型名、TP/PP 等会影响 page layout 的维度，避免不同运行配置复用同一批 physical values。
+- `extra_backend_tag` 用于同一集群内隔离实验或实例，不改变 Fluxon KV 的值格式。
+
+Fluxon 只看最终 `storage_key`。page 内部如何拆成 K/V layer、MLA tensor 或 Mamba state，由 SGLang kernel 参数解释。
+
+## Segment Registration
+
+hostless 读写依赖 SGLang 进程可访问的 Fluxon owner segment 已经完成 CUDA host registration。
+
+常见部署中，同一台机器上的多个 SGLang worker 连接同一个 Fluxon owner，并映射同一个 owner shared segment。每个 SGLang 进程仍需要在自己的 CUDA context 中完成 host registration；底层内存归属、holder 引用和回收由 owner 统一管理。
+
+```mermaid
+sequenceDiagram
+    participant S as SGLang HiCache
+    participant B as HiCacheFluxon
+    participant P as Fluxon Python store
+    participant R as fluxon_pyo3
+    participant O as owner segment mapping
+    participant C as CUDA runtime
+
+    S->>B: register_mem_pool_host / register_mem_host_pool_v2
+    B->>P: wait_local_segments_ready()
+    P->>R: wait_local_segments_ready()
+    R->>O: wait mapped range
+    O-->>R: segment_label, write_ptr, read_ptr, len, generation
+    R-->>P: segment list
+    P-->>B: dict list
+    B->>C: cudaHostRegister(write_ptr/read_ptr, len)
+```
+
+`wait_local_segments_ready()` 返回的 item 至少包含：
+
+| 字段 | 含义 |
+| --- | --- |
+| `segment_label` | owner 本地一般为 `cpu:0`；external attach owner 时为 `external_owner:0`。 |
+| `write_ptr` | 当前进程可写映射地址。 |
+| `read_ptr` | 当前进程可读映射地址，存在时也可注册。 |
+| `len` | 映射长度。 |
+| `generation` | owner 启动代际，用于拒绝过期 holder 或 mapping。 |
+| `node_id` | segment 所属 Fluxon node。 |
+
+SGLang external-client 模式要求看到 `external_owner:*` segment。注册失败时必须同步报错，不能退回到未注册 host memory 的 direct H2D path。
+
+## Plan Blob ABI
+
+`plan_ptr` 是 Fluxon 返回给 SGLang 的临时句柄，本质上是一段 plan blob 的首地址。SGLang native kernel 通过 `plan_ptr` 找到 blob，再从 blob 里读取本次 batch 对应的 value 地址表。
+
+plan blob 是 Fluxon 在 `local_fast_put_start(...)` 或 `get_transfer(...)` 时创建的一段连续 host memory，格式固定：
+
+```c
+uint64_t magic;             // 固定校验值，确认 plan_ptr 指向 Fluxon plan blob
+uint64_t count;             // value_ptrs 的数量，也就是本次 batch 的 page 数
+uint64_t value_ptrs[count]; // 每个 page 对应的 Fluxon value 起始地址
+```
+
+如果 SGLang 一次写入或恢复 10 个 page，Fluxon 会创建一个 blob，并返回一个 `plan_ptr`：
+
+```text
+plan_ptr -> blob 起始地址
+
+blob[0]  = magic
+blob[1]  = 10
+blob[2]  = value_ptr_0
+blob[3]  = value_ptr_1
+...
+blob[11] = value_ptr_9
+```
+
+`magic` 不是 KV value 地址，只是固定校验值；`value_ptr_0 ... value_ptr_9` 才是 Fluxon 为这些 page 准备的 value 起始地址。它们是当前进程可访问的绝对地址，不是偏移量。
+
+`value_len` 不写入 blob。Fluxon 只负责按 `value_len` 分配每个 value 的连续字节区间，并把起始地址放进 `value_ptrs[]`；每个 value 内部如何切成 K/V、layer、MLA 或 Mamba state，由 SGLang 调用 write/restore kernel 时显式传入 layout 参数。
+
+`plan_ptr` 只在当前进程、当前 batch 生命周期内有效。`local_fast_put_commit(plan_ptr)`、`put_abort(plan_ptr)` 或 `release_views(plan_ptr)` 后，Fluxon 会清理对应 plan，SGLang 不能继续使用这个 `plan_ptr`。
+
+## Backup 时序
+
+hostless backup 的核心约束是：Fluxon 负责 GPU KV cache 之下的本机/远端 KV 层的地址分配、route 提交和生命周期管理，但真正的 KV bytes 由 SGLang native kernel 从 GPU KV cache 写入。因此 Fluxon 不能在收到 key 后立刻发布 KV route；它必须先完成 key reservation、put id 分配和 owner-local reserve slot claim，把稳定可写的 `value_ptrs[]` 通过 `plan_ptr` 返回给 SGLang。SGLang native kernel 写完这些地址后，`local_fast_put_commit` 才能把这些 slots 提交为 resident values，并发布 Fluxon KV route。
+
+这条写路径拆成两个 Fluxon API 阶段：
+
+1. `local_fast_put_start(keys, value_len)`：只做写入准入、key reservation、put id 分配和可写 value 地址准备，返回 `plan_ptr(value_ptrs)`；此时 value bytes 还没有写完，不能作为可读 KV route 暴露。
+2. `local_fast_put_commit(plan_ptr)`：在 SGLang native kernel 完成写入后消费 put plan，提交 slot / transfer / route，并返回 `KvFuture`；只有 future 成功后，SGLang 才能把 node 标记为 `storage_backed`。
+
+写入阶段的拆分主要是为了同时满足两个约束：
+
+- 数据面效率：SGLang 不需要先把 GPU KV page 包装成通用 KV payload 再交给后端，而是直接用 kernel 写入 Fluxon 返回的 value 地址。
+- 可见性安全：`put_start` 阶段只预留地址，不发布 route；避免其它 get 读到尚未写完或尚未 commit 的 value。
+
+```mermaid
+sequenceDiagram
+    participant U as UnifiedRadixCache
+    participant B as HiCacheFluxon
+    participant F as Fluxon store
+    participant K as sgl-kernel
+    participant O as Fluxon owner
+    participant M as Fluxon master
+
+    U->>B: local_fast_put_start(missing_keys, value_len)
+    B->>F: local_fast_put_start(storage_keys, value_len, opts)
+    F->>O: claim local reserve slots / external owner offsets
+    O-->>F: plan_ptr(value_ptrs)
+    B-->>U: plan_ptr
+    U->>K: write_*_to_fluxon_values(plan_ptr, page_indices, layout ptrs)
+    K-->>U: writes queued on CUDA stream
+    U->>U: record local_ready_event
+    U->>B: local_fast_put_commit(plan_ptr) after event ready
+    B->>F: local_fast_put_commit(plan_ptr)
+    F->>O: record precommit visible / transfer_end or put_done
+    O->>M: commit route
+    F-->>B: KvFuture
+    U->>U: scheduler poll future
+```
+
+hostless backup 默认不依赖 put 前 exists 扫描。重复 key 或在途 key 由 `local_fast_put_start` 的 `reject_if_exist_same_key` 和 `reject_if_inflight_same_key` 准入语义处理；SGLang 上层按冲突错误做重试或跳过。
+
+`local_fast_put_start(keys, value_len)` 的要求：
+
+- `keys` 不能为空。
+- `value_len` 必须大于 0，且同一批 keys 共享同一个 value size。
+- SGLang 必须在 `local_fast_put_commit` 前完成 native write；写入失败时必须调用 `put_abort`。
+- `local_fast_put_commit` 只能调用一次；调用后 plan 从 registry 清理，后续只能等待返回的 `KvFuture`。
+
+commit 请求会带上 `len`、`src_offset` 和 target 信息。Fluxon 用这些字段判断本次 value 是否落在当前进程可访问的 owner segment 或 owner-local reserve slot 中；如果需要本地可见索引，`put_done` 会返回 owner 分配的 `local_cache_holder_id`。`MemoryInfo` 和 holder 生命周期在下文说明。
+
+## Restore 时序
+
+hostless restore 的核心约束是：SGLang 只能恢复有序 page keys 的连续前缀，并且不能切开一个 radix node 对应的 atomic group。Fluxon 需要先在本机/远端 KV 层里判断这批 keys 的可恢复边界，再把真正可恢复的部分转换成 SGLang kernel 可读取的 `plan_ptr(value_ptrs)`。因此 restore 被拆成 `get_start` 和 `get_transfer` 两个阶段。
+
+`get_start(keys, prefix_best_effort, atomic_group_lens)` 只做恢复规划：按 key 顺序做 local visible check / owner get start，计算 page 级连续命中前缀 `raw_prefix_hit_len`，再按 `atomic_group_lens` 向下收敛成 `transferable_len`。这个阶段回答“本次最多能恢复多少”，但不要求 SGLang 立刻分配 GPU KV pages，也不暴露 readable plan。
+
+`get_transfer(handle)` 在 SGLang 决定恢复后执行：它消费 `get_start` 返回的 handle，等待或完成必要 transfer，只 materialize `keys[..transferable_len]`，并返回持有 holder 引用的 readable `plan_ptr`。随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)`，把 Fluxon value memory 拷回 GPU KV cache。
+
+读取阶段拆成 planning 和 materialization 两步，主要是为了保证：
+
+- prefix 安全：中间 page miss 时，只恢复连续命中的完整前缀，不构造带洞的 GPU KV 状态。
+- atomic group 安全：`transferable_len` 不会切开 radix node group，避免恢复半个 node。
+- 资源效率：SGLang 在知道可恢复边界后再分配 GPU KV pages，避免先分配再发现 miss。
+- 生命周期安全：`get_transfer` 返回的 plan 持有 holder 引用，直到 `release_views(plan_ptr)` 后才释放，保证 kernel restore 期间 value 地址稳定。
+
+```mermaid
+sequenceDiagram
+    participant U as UnifiedRadixCache
+    participant B as HiCacheFluxon
+    participant F as Fluxon store
+    participant E as external client
+    participant O as Fluxon owner / external
+    participant K as sgl-kernel
+
+    U->>B: get_start(page_keys, atomic_group_lens)
+    B->>F: get_start(storage_keys, prefix_best_effort, atomic_group_lens)
+    F->>E: batch_get_start(keys)
+    E->>O: ExternalBatchGetStartReq
+    O-->>E: handle + raw_prefix_hit_len
+    E-->>F: backend handle + raw_prefix_hit_len
+    F->>F: build GetStartResult(raw_prefix_hit_len, transferable_len, ...)
+    F-->>B: GetStartHandle + GetStartResult
+    B-->>U: transferable_len / prefix_hit_groups / first_miss_index
+    alt transferable_len > 0 and caller chooses restore
+        U->>B: get_transfer(handle)
+        B->>F: get_transfer(handle)
+        F->>E: batch_get_transfer(handle, transferable keys)
+        E->>O: ExternalBatchGetTransferReq
+        O-->>E: holders / transfer results
+        E-->>F: plan_ptr(value_ptrs, holders kept alive)
+        F-->>B: plan_ptr
+        B-->>U: plan_ptr
+        U->>K: restore_*_from_fluxon_values(plan_ptr, prefix page indices, layout ptrs)
+        K-->>U: H2D queued on CUDA stream
+        U->>B: release_views(plan_ptr) after restore finalizer
+    else caller gives up restore
+        U->>B: cancel_get_transfer(handle)
+        B->>F: cancel_get_transfer(handle)
+        F->>E: cancel_batch_get_start(handle)
+    end
+```
+
+`GetStartResult` 的关键字段如下：
+
+| 字段 | 含义 |
+| --- | --- |
+| `raw_prefix_hit_len` | 按 key 顺序连续命中的 page 数，未按 atomic group 收敛。 |
+| `transferable_len` | 可以交给 `get_transfer` 的 page 数；它不会切开 atomic group。 |
+| `prefix_hit_groups` | 完整命中的 atomic group 数。 |
+| `first_miss_index` | 第一个 miss page 的 index；全部命中时为 `None`。 |
+| `first_miss_group_index` | 第一个 miss 所在 atomic group；全部命中时为 `None`。 |
+| `all_hit` | `transferable_len == len(keys)`。 |
+
+生命周期规则：
+
+- `get_start` 成功后，调用方必须二选一：`get_transfer(handle)` 或 `cancel_get_transfer(handle)`。
+- `get_transfer(handle)` 成功后，handle 已被消费；后续由 returned `plan_ptr` 和 `release_views(plan_ptr)` 管理。
+- `release_views(plan_ptr)` 必须在 native restore 完成后执行，即使 native restore 失败也要释放。
+- `get_start` 只命中部分前缀时，SGLang 只能恢复 `transferable_len` 覆盖的完整 atomic groups，不能构造半个 atomic group 的 GPU KV 状态。
+- `get_transfer` 返回 miss / KeyNotFound 时，SGLang 必须放弃本次 restore 并执行 rollback。
+
+## Fluxon 本地可见索引与生命周期
+
+Fluxon client/external 侧会维护当前进程可直接访问的 value 索引，以及 get/put plan 持有的 holder 引用。SGLang hostless 路径主要涉及下面几类状态：
+
+| 状态 | 创建入口 | 生命周期 |
+| --- | --- | --- |
+| precommit local visible | `local_fast_put_commit` 开始后，由 owner-local reserve slot 对应的 `MemoryInfo` 记录到 `precommit_local_visible_info` | 表示本次 put 的 value 已在当前进程可读，但后台 put commit 尚未最终完成；成功后转为 `get_cached_info` 中的 committed entry，失败或取消时移除。 |
+| committed local visible info | put commit 成功后，由 SGLang 进程内的 Fluxon external/client 将 `MemoryInfo` 记录到 `get_cached_info` | 保存 key、put version、`holder_id`、`offset`、`len` 和 owner node；后续 `get_start/get_transfer` 可以复用这份 `MemoryInfo` 构造 readable plan。 |
+| get-transfer holder | `get_transfer` 成功后绑定到 readable plan，并由 plan 持有引用 | `release_views(plan_ptr)` 后释放引用；plan 生命周期内 holder 保证对应 value 不被释放。 |
+
+收到 `local_cache_holder_id` 后，SGLang 进程内的 Fluxon external/client 使用 `holder_id`、`offset` 和 `len` 构造 `MemoryInfo`，并记录到自身 `get_cached_info`。`MemoryInfo` 记录当前进程访问该 value 所需的地址信息和释放动作；后续 `get_start` 命中 `get_cached_info` 时，可以直接把这份 `MemoryInfo` 纳入本次 get 结果，`get_transfer` 再把这些 value 地址写入 readable plan。底层内存的回收由 owner route、holder 引用和 owner-local reserve grant 生命周期共同约束。
+
+`precommit_local_visible_info` 只覆盖 commit 进行中的短窗口。put commit 成功并确认 holder 后，会移除 precommit entry 并记录 committed entry；如果 commit 失败，precommit entry 必须被清理，不能作为后续 storage-backed 恢复来源。
+
+## Owner 本地写入预留池
+
+Owner 本地写入预留池是 owner segment 中为 SGLang hostless put 预先划分的 writable slots。`local_fast_put_start` 从这些 slots 中为本次 put 分配地址，并把地址写入 `plan_ptr(value_ptrs)` 返回给 SGLang native kernel。此时 slot 只处于 reserved/prepared 状态，还没有绑定为 Fluxon KV 的正式 `key -> value` route。
+
+这个 pool 是共享 owner segment 上的弹性本地可写内存供给层。它让多个 SGLang worker 都能快速取得受 owner 生命周期管理的 `value_ptrs[]`，同时避免为每个 worker 固定切出长期独占的后端 segment。reserve slot 不足时可以按需求补充 grant，空闲后再按 cooldown 回收。
+
+SGLang native kernel 写完 `value_ptrs[]` 后，`local_fast_put_commit` 才把这些 slots 提交为 resident values，并完成 Fluxon KV route commit。commit 前如果 native write 失败，`put_abort(plan_ptr)` 会释放这些 reserved slots。
+
+这条路径把写入拆成两个阶段：
+
+1. `local_fast_put_start` 完成 key reservation、put id 分配和本地 slot claim，返回 `plan_ptr(value_ptrs)`。
+2. SGLang native kernel 写完 `value_ptrs[]` 后，`local_fast_put_commit` 再把这些 slot 转为 resident values，并完成 Fluxon KV 的 put 提交。
+
+这里的 `local_fast_*` 是 Python/PyO3 public hostless plan API。真正的 value bytes 由 SGLang native kernel 写入 `value_ptrs[]` 指向的地址；Fluxon 在 commit 阶段只消费 put plan、处理必要 transfer 或 direct done，并完成 route commit。
+
+对象含义：
+
+| 对象 | 含义 |
+| --- | --- |
+| grant | owner 侧一次申请的大块本地内存，当前固定为 `512 MiB`。 |
+| slot | grant 内按 `slot_size` 切分的小块；一个 slot 承载一个 Fluxon value。 |
+| slot lease | `local_fast_put_start` 为本次 batch 临时 claim 到的一组 slots；失败或 abort 时必须释放。 |
+| value pointer | slot 的起始地址，会写入 plan blob 的 `value_ptrs[]`，供 SGLang kernel 直接写入。 |
+| resident value | `local_fast_put_commit` 后由 slot 构造出的本地可读 value。 |
+| route | master/owner 确认后的 key 到 value 位置映射；route 成功后该 value 才是全局可见的 KV replica。 |
+
+slot 生命周期：
+
+```text
+Free
+  -> Prepared             // local_fast_put_start claim slot
+  -> PendingLocalVisible  // local_fast_put_commit 开始，本地 resident value 已记录为 pending visible
+  -> Committed            // put_done 成功，route 引用该 slot
+  -> Free                 // route 和 holder 引用都释放后回收
+```
+
+如果 native write 失败，调用方必须执行 `put_abort(plan_ptr)`，Prepared slots 会回到 Free。`local_fast_put_commit` 成功返回后，slot 是否能释放由 route 引用和 holder 引用共同决定；只要 master/owner route 或 `MemHolder` 仍引用该 slot，底层 grant 就不能释放。
+
+当前容量策略：
+
+| 项 | 当前实现 |
+| --- | --- |
+| grant 物理粒度 | `OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES = 512 * 1024 * 1024` |
+| 最小 slot size | `4 KiB` |
+| slot size 计算 | `max(value_len, 4 KiB).next_power_of_two()` |
+| slot 上限 | `slot_size <= 512 MiB` |
+| refill 触发 | 当前 slot class free slots 不足时登记 pending demand 并唤醒 rebalance actor。 |
+| 默认等待 | soft wait `10 ms`，hard timeout `1 s`。 |
+| shrink 单位 | 整个 grant；不做 live grant compaction。 |
+
+底层物理释放收束在 grant 级别。单个 committed slot 只是 grant 内逻辑索引，不直接拥有释放整块 mmap/registered memory 的权力。
+
+## SGLang Node Storage 状态
+
+SGLang 侧的 node metadata 不等价于 Fluxon master route 状态。当前四个字段建议按下面语义解释：
+
+| 字段 | true 的含义 | 清理时机 |
+| --- | --- | --- |
+| `storage_staged` | 该 node 有一批 Fluxon hostless backup 正在 staged 路径中。 | `KvFuture` 完成或失败后清空。 |
+| `storage_local_ready` | CUDA write 已完成，SGLang 已调用 `local_fast_put_commit`，但返回的 `KvFuture` 还未 ack；该状态只表示本次 hostless backup 已进入 Fluxon commit 流程，不表示 KV route 已经全局确认。 | async ack 结束后清空。 |
+| `storage_pending` | Fluxon `KvFuture` 还没结束。 | future 成功或失败后清空。 |
+| `storage_backed` | Fluxon 后台提交成功，KV route 已确认可作为 shared backing。 | 该 node 被删除或失效时清空。 |
+
+因此，SGLang 可以用 `storage_staged/storage_local_ready` 判断本次 hostless backup 已经推进到本地写入或 commit 阶段；但跨节点复用和长期共享必须等 `KvFuture` 成功，并以 `storage_backed` 为准。
+
+TP 场景下，每个 rank 仍有各自的 radix tree 和恢复决策。`get_start` 的结果只描述当前 rank 这批 keys 的可恢复前缀；如果一个 rank miss、另一个 rank hit，上层必须按 SGLang 的 TP restore 约束处理一致性，不能把单 rank 的部分成功当作完整 request 已恢复。
+
+## 失败处理
+
+| 场景 | 必须动作 |
+| --- | --- |
+| `local_fast_put_start` 后 native write 失败 | 调用 `put_abort(plan_ptr)`，释放 key reservation 和 local reserve slot lease。 |
+| `local_fast_put_commit` 返回 future 后后台失败 | SGLang 清理 `storage_staged/storage_pending/storage_local_ready`，必要时删除已 evicted 的 dead leaf。 |
+| `get_start` 后放弃 restore | 调用 `cancel_get_transfer(handle)`，释放 get-start 持有的 owner/external 资源。 |
+| `get_start` 只命中部分前缀 | 只允许恢复 `transferable_len` 覆盖的完整 atomic groups；后续 page 按 miss 处理。 |
+| `get_transfer` 报 key miss | SGLang rollback 当前 restore，不继续构造半个 node 的 GPU 恢复。 |
+| `get_transfer` 成功后 native restore 失败 | 先 `release_views(plan_ptr)`，再执行 SGLang rollback；此时 handle 已被消费。 |
+| CUDA host registration 失败 | direct path 同步失败，不能降级为未注册 host memory。 |
+| `plan_ptr` 类型用错 | `local_fast_put_commit`、`put_abort`、`release_views` 都按 registry entry 类型校验并 fail fast。 |
diff --git a/fluxon_py/kvclient/fluxon.py b/fluxon_py/kvclient/fluxon.py
index 1325e3d..ae9df9a 100644
--- a/fluxon_py/kvclient/fluxon.py
+++ b/fluxon_py/kvclient/fluxon.py
@@ -3,6 +3,7 @@
 This module provides a concrete implementation using the PyO3 Rust bindings.
 """
 
+from dataclasses import dataclass
 from typing import Union, Optional, Callable, Any, Dict, List, Tuple
 import ctypes
 import os
@@ -25,7 +26,7 @@
 from .kvclient_interface import KvClient
 from .kvclient_interface import KvLeaseApi, KvRpcApi, PutOptionalArgs, FlatDict
 from .backend_fallback_close import unregister_store_from_cleanup
-from .kvclient_interface import KvFuture, MemHolder
+from .kvclient_interface import GetStartHandle, GetStartResult, KvFuture, MemHolder
 from .nonzerocopy_encode import (
     DLPacked,
     INTERNAL_DLPACK_META_KEY,
@@ -138,11 +139,114 @@ def _resolve_side_transfer_worker_python() -> str:
     return sys.executable
 
 
+@dataclass(frozen=True)
+class _RegisteredBufferDescriptor:
+    ptr: int
+    size: int
+    device_kind: str = "host"
+    device_id: str = ""
+    layout: str = "raw"
+    metadata: Optional[Dict[str, Any]] = None
+
+    @property
+    def end(self) -> int:
+        return self.ptr + self.size
+
+    def contains(self, ptr: int, size: int) -> bool:
+        req_end = ptr + size
+        return ptr >= self.ptr and req_end <= self.end
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "ptr": self.ptr,
+            "size": self.size,
+            "device_kind": self.device_kind,
+            "device_id": self.device_id,
+            "layout": self.layout,
+            "metadata": dict(self.metadata or {}),
+        }
+
+
 def _map_nospace_to_storagefull(err: ApiError) -> ApiError:
     """Normalize storage-capacity errors without depending on backend internals."""
     return err
 
 
+def _get_start_prefix_hit_groups(
+    raw_prefix_hit_len: int,
+    group_lens: Tuple[int, ...],
+) -> int:
+    prefix_hit_groups = 0
+    transferable_len = 0
+    for group_len in group_lens:
+        next_transferable_len = transferable_len + group_len
+        if next_transferable_len > raw_prefix_hit_len:
+            break
+        transferable_len = next_transferable_len
+        prefix_hit_groups += 1
+    return prefix_hit_groups
+
+
+def _get_start_group_index_for_key_index(
+    group_lens: Tuple[int, ...],
+    key_index: int,
+) -> Optional[int]:
+    cursor = 0
+    for group_index, group_len in enumerate(group_lens):
+        cursor += group_len
+        if key_index < cursor:
+            return group_index
+    return None
+
+
+def _build_get_start_result_from_backend_payload(
+    payload: Dict[str, Any],
+    keys: List[str],
+    prefix_best_effort: bool,
+    normalized_group_lens: Optional[List[int]],
+) -> GetStartResult:
+    result_keys = tuple(keys)
+    group_lens = (
+        (len(result_keys),)
+        if normalized_group_lens is None
+        else tuple(normalized_group_lens)
+    )
+    raw_prefix_hit_len = int(payload["raw_prefix_hit_len"])
+    if raw_prefix_hit_len < 0 or raw_prefix_hit_len > len(result_keys):
+        raise RuntimeError(
+            "get_start returned invalid raw_prefix_hit_len: "
+            f"raw_prefix_hit_len={raw_prefix_hit_len} keys={len(result_keys)}"
+        )
+    prefix_hit_groups = _get_start_prefix_hit_groups(
+        raw_prefix_hit_len,
+        group_lens,
+    )
+    if not prefix_best_effort and prefix_hit_groups != len(group_lens):
+        transferable_len = 0
+        prefix_hit_groups = 0
+    else:
+        transferable_len = sum(group_lens[:prefix_hit_groups])
+    first_miss_index = (
+        None if raw_prefix_hit_len == len(result_keys) else raw_prefix_hit_len
+    )
+    first_miss_group_index = (
+        None
+        if first_miss_index is None
+        else _get_start_group_index_for_key_index(group_lens, first_miss_index)
+    )
+    return GetStartResult(
+        keys=result_keys,
+        raw_prefix_hit_len=raw_prefix_hit_len,
+        transferable_len=transferable_len,
+        prefix_hit_groups=prefix_hit_groups,
+        atomic_group_lens=tuple(normalized_group_lens) if normalized_group_lens is not None else None,
+        prefix_best_effort=prefix_best_effort,
+        first_miss_index=first_miss_index,
+        first_miss_group_index=first_miss_group_index,
+        all_hit=transferable_len == len(result_keys),
+    )
+
+
 def _error_to_ret_code(err: ApiError) -> int:
     if hasattr(err, "code") and callable(err.code):
         try:
@@ -299,7 +403,11 @@ def __init__(self, config: FluxonKvClientConfig):
         self._client: Optional[fluxon_pyo3.KvClient] = None
         self._config = config
         self._init_error: Optional[ApiError] = None
+        self._registered_buffer_descriptors: List[_RegisteredBufferDescriptor] = []
         cluster_name = config.fluxonkv_spec_cluster_name
+        self._batch_concurrency = 128
+        if self._batch_concurrency <= 0:
+            raise ValueError("batch_concurrency must be > 0")
         self._blocking_put_outer_total_log_window = _BlockingPutOuterTotalLogWindow(
             f"FluxonKVCacheStore[{cluster_name}]"
         )
@@ -368,11 +476,17 @@ def put(
             reject_if_inflight_same_key = (
                 bool(opts.reject_if_inflight_same_key) if opts is not None else False
             )
+            reject_if_exist_same_key = (
+                bool(opts.reject_if_exist_same_key) if opts is not None else False
+            )
+            write_through = bool(opts.write_through) if opts is not None else True
             inner_res = self._client.put(
                 key,
                 ptrs,
                 lease_id=lease_id,
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
+                reject_if_exist_same_key=reject_if_exist_same_key,
+                write_through=write_through,
             )
             if not inner_res.is_ok():
                 err = inner_res.unwrap_error()
@@ -416,11 +530,17 @@ def put_blocking(
             reject_if_inflight_same_key = (
                 bool(opts.reject_if_inflight_same_key) if opts is not None else False
             )
+            reject_if_exist_same_key = (
+                bool(opts.reject_if_exist_same_key) if opts is not None else False
+            )
+            write_through = bool(opts.write_through) if opts is not None else True
             inner_res = self._client.put_blocking(
                 key,
                 ptrs,
                 lease_id=lease_id,
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
+                reject_if_exist_same_key=reject_if_exist_same_key,
+                write_through=write_through,
             )
             if not inner_res.is_ok():
                 return Result.new_error(inner_res.unwrap_error())
@@ -448,6 +568,199 @@ def get_blocking(self, key: str) -> Result[MemHolder, ApiError]:
         except ApiError as e:
             return Result.new_error(e)
 
+    @staticmethod
+    def _normalize_batch_result_list(batch_result: Any, expected_len: int, op_name: str) -> List[Any]:
+        if isinstance(batch_result, Result):
+            if not batch_result.is_ok():
+                raise RuntimeError(f"{op_name} backend error: {batch_result.unwrap_error()}")
+            batch_result = batch_result.unwrap()
+        if not isinstance(batch_result, list):
+            raise RuntimeError(f"{op_name} returned non-list: {type(batch_result)}")
+        if len(batch_result) != expected_len:
+            raise RuntimeError(
+                f"{op_name} returned unexpected length: expected={expected_len} got={len(batch_result)}"
+            )
+        return list(batch_result)
+
+    def batch_put_blocking(
+        self,
+        keys: List[str],
+        values: List[FlatDict],
+        opts: Optional[PutOptionalArgs] = None,
+        concurrency: Optional[int] = None,
+    ) -> List[Result[OkNone, ApiError]]:
+        if len(keys) != len(values):
+            raise ValueError("batch_put_blocking requires keys and values to have the same length")
+        if len(keys) == 0:
+            return []
+        if self._client is None:
+            err = GeneralError(message="Store not initialized when batch_put_blocking(). Call setup() first.")
+            return [Result.new_error(err) for _ in keys]
+
+        lease_id: Optional[int] = opts.lease_id if opts is not None else None
+        reject_if_inflight_same_key = (
+            bool(opts.reject_if_inflight_same_key) if opts is not None else False
+        )
+        reject_if_exist_same_key = (
+            bool(opts.reject_if_exist_same_key) if opts is not None else False
+        )
+        write_through = bool(opts.write_through) if opts is not None else True
+
+        keepalive_groups: List[List[bytes]] = []
+        dlpack_groups: List[List[object]] = []
+        ptr_groups: List[List[tuple[int, int, int, int, int, Optional[int]]]] = []
+        try:
+            for value in values:
+                keepalive: List[bytes] = []
+                dlpack_capsules: List[object] = []
+                ptr_groups.append(build_flat_dict_ptrs(value, keepalive, dlpack_capsules))
+                keepalive_groups.append(keepalive)
+                dlpack_groups.append(dlpack_capsules)
+
+            inner_res = self._client.batch_put_blocking(
+                keys,
+                ptr_groups,
+                lease_id=lease_id,
+                reject_if_inflight_same_key=reject_if_inflight_same_key,
+                reject_if_exist_same_key=reject_if_exist_same_key,
+                write_through=write_through,
+                concurrency=concurrency if concurrency is not None else self._batch_concurrency,
+            )
+            if not inner_res.is_ok():
+                err = inner_res.unwrap_error()
+                return [Result.new_error(err) for _ in keys]
+
+            batch_results = self._normalize_batch_result_list(
+                inner_res.unwrap(), len(keys), "batch_put_blocking"
+            )
+            submit_out: List[Result[OkNone, ApiError]] = []
+            for idx, item in enumerate(batch_results):
+                if isinstance(item, Result):
+                    submit_out.append(item)
+                    continue
+                if item is None:
+                    submit_out.append(Result.new_ok(OkNone()))
+                    continue
+                if isinstance(item, int) and item == 0:
+                    submit_out.append(Result.new_ok(OkNone()))
+                    continue
+                if isinstance(item, int):
+                    submit_out.append(
+                        Result.new_error(
+                            GeneralError(
+                                message=(
+                                    "batch_put_blocking returned backend code "
+                                    f"{item} for key {keys[idx]!r}"
+                                )
+                            )
+                        )
+                    )
+                    continue
+                submit_out.append(
+                    Result.new_error(
+                        GeneralError(
+                            message=f"unexpected batch_put result type: {type(item)}"
+                        )
+                    )
+                )
+            return submit_out
+        except ApiError as e:
+            return [Result.new_error(e) for _ in keys]
+        except Exception as e:
+            return [Result.new_error(GeneralError(f"batch_put_blocking failed: {e}")) for _ in keys]
+        finally:
+            for keepalive in keepalive_groups:
+                keepalive.clear()
+            for dlpack_capsules in dlpack_groups:
+                dlpack_capsules.clear()
+
+    def batch_get_blocking(
+        self,
+        keys: List[str],
+        concurrency: Optional[int] = None,
+    ) -> List[Result[Union[Any, MemHolder], ApiError]]:
+        if len(keys) == 0:
+            return []
+        if self._client is None:
+            err = GeneralError(message="Store not initialized when batch_get_blocking(). Call setup() first.")
+            return [Result.new_error(err) for _ in keys]
+
+        try:
+            inner_res = self._client.batch_get_blocking(
+                keys,
+                concurrency=concurrency if concurrency is not None else self._batch_concurrency,
+            )
+            if not inner_res.is_ok():
+                err = inner_res.unwrap_error()
+                return [Result.new_error(err) for _ in keys]
+
+            batch_results = self._normalize_batch_result_list(
+                inner_res.unwrap(), len(keys), "batch_get_blocking"
+            )
+            out: List[Result[Union[Any, MemHolder], ApiError]] = []
+            for idx, item in enumerate(batch_results):
+                if isinstance(item, Result):
+                    out.append(item)
+                    continue
+                if item is None:
+                    out.append(
+                        Result.new_error(
+                            GeneralError(message=f"batch_get_blocking returned None for key {keys[idx]!r}")
+                        )
+                    )
+                    continue
+                out.append(Result.new_ok(item))
+            return out
+        except ApiError as e:
+            return [Result.new_error(e) for _ in keys]
+        except Exception as e:
+            return [Result.new_error(GeneralError(f"batch_get_blocking failed: {e}")) for _ in keys]
+
+    def put_payload_from_ptr(
+        self,
+        key: str,
+        payload_ptr: int,
+        payload_size: int,
+        opts: Optional[PutOptionalArgs] = None,
+    ) -> Result[KvFuture, ApiError]:
+        if self._client is None:
+            return Result.new_error(
+                GeneralError(
+                    message="Store not initialized when put_payload_from_ptr(). Call setup() first."
+                )
+            )
+
+        keepalive: List[bytes] = []
+        try:
+            ptrs = _build_payload_field_ptrs(payload_ptr, payload_size, keepalive)
+            lease_id: Optional[int] = opts.lease_id if opts is not None else None
+            reject_if_inflight_same_key = (
+                bool(opts.reject_if_inflight_same_key) if opts is not None else False
+            )
+            reject_if_exist_same_key = (
+                bool(opts.reject_if_exist_same_key) if opts is not None else False
+            )
+            write_through = bool(opts.write_through) if opts is not None else True
+            inner_res = self._client.put(
+                key,
+                ptrs,
+                lease_id=lease_id,
+                reject_if_inflight_same_key=reject_if_inflight_same_key,
+                reject_if_exist_same_key=reject_if_exist_same_key,
+                write_through=write_through,
+            )
+            if not inner_res.is_ok():
+                return Result.new_error(_map_nospace_to_storagefull(inner_res.unwrap_error()))
+            inner_future = inner_res.unwrap()
+            assert inner_future is not None
+            outer_future = _FluxonPutFuture(inner_future, keepalive, [])
+            keepalive = []
+            return Result.new_ok(outer_future)
+        except ApiError as e:
+            return Result.new_error(e)
+        finally:
+            keepalive.clear()
+
     def put_payload_from_ptr_blocking(
         self,
         key: str,
@@ -469,11 +782,17 @@ def put_payload_from_ptr_blocking(
             reject_if_inflight_same_key = (
                 bool(opts.reject_if_inflight_same_key) if opts is not None else False
             )
+            reject_if_exist_same_key = (
+                bool(opts.reject_if_exist_same_key) if opts is not None else False
+            )
+            write_through = bool(opts.write_through) if opts is not None else True
             inner_res = self._client.put_blocking(
                 key,
                 ptrs,
                 lease_id=lease_id,
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
+                reject_if_exist_same_key=reject_if_exist_same_key,
+                write_through=write_through,
             )
             if not inner_res.is_ok():
                 return Result.new_error(inner_res.unwrap_error())
@@ -566,17 +885,297 @@ def get_payload_into_ptr_blocking(
         del holder
         return Result.new_ok(payload_size)
 
+    def register_buffer(
+        self,
+        ptr: int,
+        size: int,
+        device_kind: str = "host",
+        device_id: str = "",
+        layout: str = "raw",
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Result[OkNone, ApiError]:
+        if self._client is None:
+            return Result.new_error(
+                GeneralError(
+                    message="Store not initialized when register_buffer(). Call setup() first."
+                )
+            )
+        if not isinstance(ptr, int):
+            return Result.new_error(
+                InvalidArgumentError(message=f"ptr must be int; got {type(ptr)}")
+            )
+        if not isinstance(size, int):
+            return Result.new_error(
+                InvalidArgumentError(message=f"size must be int; got {type(size)}")
+            )
+        if ptr < 0:
+            return Result.new_error(
+                InvalidArgumentError(message=f"ptr must be >= 0; got {ptr}")
+            )
+        if size < 0:
+            return Result.new_error(
+                InvalidArgumentError(message=f"size must be >= 0; got {size}")
+            )
+        if not isinstance(device_kind, str):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"device_kind must be str; got {type(device_kind)}"
+                )
+            )
+        if not isinstance(device_id, str):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"device_id must be str; got {type(device_id)}"
+                )
+            )
+        if not isinstance(layout, str):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"layout must be str; got {type(layout)}"
+                )
+            )
+        if metadata is not None and not isinstance(metadata, dict):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"metadata must be dict or None; got {type(metadata)}"
+                )
+            )
+        try:
+            inner_res = self._client.register_buffer(ptr, size)
+            if not inner_res.is_ok():
+                return Result.new_error(inner_res.unwrap_error())
+            _ = inner_res.unwrap()
+            self._registered_buffer_descriptors.append(
+                _RegisteredBufferDescriptor(
+                    ptr=int(ptr),
+                    size=int(size),
+                    device_kind=device_kind,
+                    device_id=device_id,
+                    layout=layout,
+                    metadata=dict(metadata or {}),
+                )
+            )
+            return Result.new_ok(OkNone())
+        except ApiError as e:
+            return Result.new_error(e)
+
+    def batch_put_from(
+        self,
+        keys: List[str],
+        payload_ptrs: List[int],
+        payload_sizes: List[int],
+        opts: Optional[PutOptionalArgs] = None,
+    ) -> List[int]:
+        if len(keys) != len(payload_ptrs) or len(keys) != len(payload_sizes):
+            raise ValueError(
+                "batch_put_from requires keys, payload_ptrs, and payload_sizes to have the same length"
+            )
+        if len(keys) == 0:
+            return []
+
+        if self._client is None:
+            code = _error_to_ret_code(
+                GeneralError(
+                    message="Store not initialized when batch_put_from(). Call setup() first."
+                )
+            )
+            return [code] * len(keys)
+
+        lease_id: Optional[int] = opts.lease_id if opts is not None else None
+        reject_if_inflight_same_key = (
+            bool(opts.reject_if_inflight_same_key) if opts is not None else False
+        )
+        reject_if_exist_same_key = (
+            bool(opts.reject_if_exist_same_key) if opts is not None else False
+        )
+        write_through = bool(opts.write_through) if opts is not None else True
+
+        try:
+            inner_res = self._client.batch_put_from(
+                keys,
+                payload_ptrs,
+                payload_sizes,
+                lease_id=lease_id,
+                reject_if_inflight_same_key=reject_if_inflight_same_key,
+                reject_if_exist_same_key=reject_if_exist_same_key,
+                write_through=write_through,
+            )
+            if inner_res.is_ok():
+                submit_results = list(inner_res.unwrap())
+                if len(submit_results) != len(keys):
+                    raise RuntimeError(
+                        "batch_put_from returned unexpected result length: "
+                        f"expected={len(keys)} got={len(submit_results)}"
+                    )
+                return [int(item) for item in submit_results]
+            err = inner_res.unwrap_error()
+            code = _error_to_ret_code(err)
+            return [code] * len(keys)
+        except ApiError as e:
+            code = _error_to_ret_code(e)
+            return [code] * len(keys)
+        except Exception as e:
+            code = _error_to_ret_code(GeneralError(f"batch_put_from failed: {e}"))
+            return [code] * len(keys)
+
     def get_size(self, key: str) -> Result[int, ApiError]:
         """Get the size of a stored value (non-blocking)."""
         return self._client.get_size(key)
 
-    def is_exist(self, key: str) -> Result[bool, ApiError]:
+    def is_exist(self, key: str, allow_local_snapshot: bool = False) -> Result[bool, ApiError]:
         """Check if a key exists in the store (non-blocking)."""
         try:
-            return self._client.is_exist(key)
+            if self._client is None:
+                return Result.new_error(
+                    GeneralError(
+                        message="Store not initialized when is_exist(). Call setup() first."
+                    )
+                )
+            return self._client.is_exist(key, allow_local_snapshot=allow_local_snapshot)
         except Exception as e:
             return Result.new_error(GeneralError(f"Existence check failed: {str(e)}"))
 
+    def batch_get_into(
+        self,
+        keys: List[str],
+        payload_ptrs: List[int],
+        payload_capacities: List[int],
+    ) -> List[int]:
+        if len(keys) != len(payload_ptrs) or len(keys) != len(payload_capacities):
+            raise ValueError(
+                "batch_get_into requires keys, payload_ptrs, and payload_capacities to have the same length"
+            )
+        if len(keys) == 0:
+            return []
+
+        if self._client is not None:
+            inner_res = self._client.batch_get_into(keys, payload_ptrs, payload_capacities)
+            if inner_res.is_ok():
+                return list(inner_res.unwrap())
+            err = inner_res.unwrap_error()
+            return [_error_to_ret_code(err)] * len(keys)
+
+        results: List[int] = []
+        for key, ptr, size in zip(keys, payload_ptrs, payload_capacities):
+            get_result = self.get_payload_into_ptr_blocking(key, ptr, size)
+            if get_result.is_ok():
+                results.append(int(get_result.unwrap()))
+            else:
+                results.append(_error_to_ret_code(get_result.unwrap_error()))
+        return results
+
+    def batch_is_exist(
+        self,
+        keys: List[str],
+        allow_local_snapshot: bool = False,
+    ) -> List[int]:
+        if len(keys) == 0:
+            return []
+
+        if self._client is None:
+            code = _error_to_ret_code(
+                GeneralError(
+                    message="Store not initialized when batch_is_exist(). Call setup() first."
+                )
+            )
+            return [code] * len(keys)
+
+        try:
+            inner_res = self._client.batch_is_exist(
+                keys,
+                allow_local_snapshot=allow_local_snapshot,
+            )
+            if not inner_res.is_ok():
+                code = _error_to_ret_code(inner_res.unwrap_error())
+                return [code] * len(keys)
+            batch_results = self._normalize_batch_result_list(
+                inner_res.unwrap(), len(keys), "batch_is_exist"
+            )
+            out: List[int] = []
+            for idx, item in enumerate(batch_results):
+                if not isinstance(item, int):
+                    raise GeneralError(
+                        message=(
+                            f"batch_is_exist returned non-int item for key {keys[idx]!r}: "
+                            f"{type(item)}"
+                        )
+                    )
+                out.append(int(item))
+            return out
+        except ApiError as e:
+            code = _error_to_ret_code(e)
+            return [code] * len(keys)
+        except Exception as e:
+            code = _error_to_ret_code(GeneralError(f"batch_is_exist failed: {e}"))
+            return [code] * len(keys)
+
+    def get_meta(self, key: str) -> Result[Dict[str, Any], ApiError]:
+        """Query key metadata and one live placement without fetching payload bytes."""
+        try:
+            inner = self._client.get_meta(key)
+            if not inner.is_ok():
+                return Result.new_error(inner.unwrap_error())
+            meta = inner.unwrap()
+            assert isinstance(meta, dict), f"get_meta returned non-dict: {type(meta)}"
+            return Result.new_ok(meta)
+        except Exception as e:
+            return Result.new_error(GeneralError(f"GetMeta failed for key '{key}': {str(e)}"))
+
+    def batch_get_meta(self, keys: List[str]) -> List[Dict[str, Any]]:
+        if len(keys) == 0:
+            return []
+
+        if self._client is not None and hasattr(self._client, "batch_get_meta"):
+            inner_res = self._client.batch_get_meta(keys)
+            if inner_res.is_ok():
+                rows = inner_res.unwrap()
+                assert isinstance(rows, list), (
+                    f"batch_get_meta returned non-list: {type(rows)}"
+                )
+                return list(rows)
+            err = inner_res.unwrap_error()
+            code = _error_to_ret_code(err)
+            return [
+                {
+                    "exists": False,
+                    "len": 0,
+                    "node_id": "",
+                    "src_addr": 0,
+                    "src_base_addr": 0,
+                    "segment_device_id": "",
+                    "segment_device_desc": "",
+                    "replica_count": 0,
+                    "transport_error": True,
+                    "error_code": -code,
+                    "error_json": str(err),
+                }
+                for _ in keys
+            ]
+
+        rows: List[Dict[str, Any]] = []
+        for key in keys:
+            meta_res = self.get_meta(key)
+            if meta_res.is_ok():
+                rows.append(meta_res.unwrap())
+            else:
+                err = meta_res.unwrap_error()
+                rows.append(
+                    {
+                        "exists": False,
+                        "len": 0,
+                        "node_id": "",
+                        "src_addr": 0,
+                        "src_base_addr": 0,
+                        "segment_device_id": "",
+                        "segment_device_desc": "",
+                        "replica_count": 0,
+                        "transport_error": True,
+                        "error_code": -_error_to_ret_code(err),
+                        "error_json": str(err),
+                    }
+                )
+        return rows
+
     def count_prefix(self, prefix: str) -> Result[int, ApiError]:
         """Count number of keys with the given prefix.
 
@@ -806,6 +1405,247 @@ def get_cluster_name(self) -> str:
             raise RuntimeError("Store not initialized")
         return str(self._client.cluster_name())
 
+    def wait_local_segments_ready(self) -> List[dict[str, Any]]:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when wait_local_segments_ready(). Call setup() first."
+            )
+        inner_res = self._client.wait_local_segments_ready()
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"wait_local_segments_ready backend error: {inner_res.unwrap_error()}"
+            )
+        inner_res = inner_res.unwrap()
+        if not isinstance(inner_res, list):
+            raise RuntimeError(
+                "wait_local_segments_ready must return a list of segment mappings"
+            )
+        out: List[dict[str, Any]] = []
+        for item in inner_res:
+            if not isinstance(item, dict):
+                raise RuntimeError(
+                    "wait_local_segments_ready segment item must be a dict"
+                )
+            out.append(dict(item))
+        return out
+
+    def local_fast_put_start(
+        self,
+        keys: List[str],
+        value_len: int,
+        opts: Optional[PutOptionalArgs] = None,
+    ) -> int:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when local_fast_put_start(). Call setup() first."
+            )
+        if len(keys) == 0:
+            raise ValueError("local_fast_put_start requires at least one key")
+        if not isinstance(value_len, int):
+            raise ValueError(f"value_len must be int; got {type(value_len)}")
+        if value_len <= 0:
+            raise ValueError(f"value_len must be > 0; got {value_len}")
+        reject_if_inflight_same_key = (
+            bool(opts.reject_if_inflight_same_key) if opts is not None else False
+        )
+        reject_if_exist_same_key = (
+            bool(opts.reject_if_exist_same_key) if opts is not None else False
+        )
+        write_through = bool(opts.write_through) if opts is not None else True
+        inner_res = self._client.local_fast_put_start(
+            keys,
+            value_len,
+            reject_if_inflight_same_key=reject_if_inflight_same_key,
+            reject_if_exist_same_key=reject_if_exist_same_key,
+            write_through=write_through,
+        )
+        if not inner_res.is_ok():
+            err = inner_res.unwrap_error()
+            if isinstance(err, Exception):
+                raise err
+            raise RuntimeError(f"local_fast_put_start backend error: {err}")
+        plan_ptr = inner_res.unwrap()
+        if not isinstance(plan_ptr, int) or plan_ptr <= 0:
+            raise RuntimeError(f"local_fast_put_start returned invalid plan_ptr: {plan_ptr!r}")
+        return int(plan_ptr)
+
+    def local_fast_put_commit(self, plan_ptr: int) -> KvFuture:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when local_fast_put_commit(). Call setup() first."
+            )
+        inner_res = self._client.local_fast_put_commit(plan_ptr)
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"local_fast_put_commit backend error: {inner_res.unwrap_error()}"
+            )
+        inner_future = inner_res.unwrap()
+        if inner_future is None:
+            raise RuntimeError("local_fast_put_commit returned empty future")
+        return _FluxonBatchRetCodeFuture(inner_future, [plan_ptr])
+
+    def put_abort(self, plan_ptr: int) -> None:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when put_abort(). Call setup() first."
+            )
+        inner_res = self._client.put_abort(plan_ptr)
+        if not inner_res.is_ok():
+            raise RuntimeError(f"put_abort backend error: {inner_res.unwrap_error()}")
+        _ = inner_res.unwrap()
+
+    def get_views(
+        self,
+        keys: List[str],
+        concurrency: Optional[int] = None,
+    ) -> int:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when get_views(). Call setup() first."
+            )
+        if len(keys) == 0:
+            raise ValueError("get_views requires at least one key")
+        inner_res = self._client.get_views(
+            keys,
+            concurrency=concurrency if concurrency is not None else self._batch_concurrency,
+        )
+        if not inner_res.is_ok():
+            raise RuntimeError(f"get_views backend error: {inner_res.unwrap_error()}")
+        plan_ptr = inner_res.unwrap()
+        if not isinstance(plan_ptr, int) or plan_ptr <= 0:
+            raise RuntimeError(f"get_views returned invalid plan_ptr: {plan_ptr!r}")
+        return int(plan_ptr)
+
+    def release_views(self, plan_ptr: int) -> None:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when release_views(). Call setup() first."
+            )
+        inner_res = self._client.release_views(plan_ptr)
+        if not inner_res.is_ok():
+            raise RuntimeError(f"release_views backend error: {inner_res.unwrap_error()}")
+        _ = inner_res.unwrap()
+
+    def get_start(
+        self,
+        keys: List[str],
+        prefix_best_effort: bool = True,
+        atomic_group_lens: Optional[List[int]] = None,
+    ) -> GetStartHandle:
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when get_start(). Call setup() first."
+            )
+        if len(keys) == 0:
+            raise ValueError("get_start requires at least one key")
+        normalized_group_lens: Optional[List[int]] = None
+        if atomic_group_lens is not None:
+            normalized_group_lens = [int(length) for length in atomic_group_lens]
+            if any(length <= 0 for length in normalized_group_lens):
+                raise ValueError("get_start atomic_group_lens entries must be > 0")
+            if sum(normalized_group_lens) != len(keys):
+                raise ValueError(
+                    "get_start atomic_group_lens must sum to keys length: "
+                    f"sum={sum(normalized_group_lens)} keys={len(keys)}"
+                )
+
+        started_at_ns = time.monotonic_ns()
+        inner_res = self._client.get_start(
+            list(keys),
+            bool(prefix_best_effort),
+            normalized_group_lens,
+            self._batch_concurrency,
+        )
+        if not inner_res.is_ok():
+            raise RuntimeError(f"get_start backend error: {inner_res.unwrap_error()}")
+        payload = inner_res.unwrap()
+        if not isinstance(payload, dict):
+            raise RuntimeError(f"get_start returned non-dict payload: {type(payload)}")
+        backend_handle = int(payload["handle"])
+        result = _build_get_start_result_from_backend_payload(
+            payload,
+            list(keys),
+            bool(prefix_best_effort),
+            normalized_group_lens,
+        )
+        logging.info(
+            "FluxonKVCacheStore get_start result: keys=%d raw_prefix_hit_len=%d "
+            "transferable_len=%d prefix_hit_groups=%d all_hit=%s "
+            "first_miss_index=%s first_miss_group_index=%s "
+            "prefix_best_effort=%s duration_ms=%.3f",
+            len(keys),
+            result.raw_prefix_hit_len,
+            result.transferable_len,
+            result.prefix_hit_groups,
+            result.all_hit,
+            result.first_miss_index,
+            result.first_miss_group_index,
+            result.prefix_best_effort,
+            (time.monotonic_ns() - started_at_ns) / 1_000_000.0,
+        )
+        return GetStartHandle(
+            keys=tuple(keys),
+            result=result,
+            created_at_ns=started_at_ns,
+            backend_token=id(self),
+            backend_handle=backend_handle,
+        )
+
+    def cancel_get_transfer(self, handle: GetStartHandle) -> None:
+        if not isinstance(handle, GetStartHandle):
+            raise TypeError(f"cancel_get_transfer requires GetStartHandle, got {type(handle)}")
+        if handle.backend_token is not None and handle.backend_token != id(self):
+            raise RuntimeError(
+                "cancel_get_transfer handle belongs to a different FluxonKVCacheStore"
+            )
+        if handle.closed:
+            return
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when cancel_get_transfer(). Call setup() first."
+            )
+        inner_res = self._client.cancel_get_transfer(int(handle.backend_handle))
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"cancel_get_transfer backend error: {inner_res.unwrap_error()}"
+            )
+        handle.closed = True
+
+    def get_transfer(
+        self,
+        handle: GetStartHandle,
+        concurrency: Optional[int] = None,
+    ) -> int:
+        if not isinstance(handle, GetStartHandle):
+            raise TypeError(f"get_transfer requires GetStartHandle, got {type(handle)}")
+        if handle.backend_token is not None and handle.backend_token != id(self):
+            raise RuntimeError("get_transfer handle belongs to a different FluxonKVCacheStore")
+        if handle.closed:
+            raise RuntimeError("get_transfer handle has been closed")
+        result = handle.result
+        if result.transferable_len == 0:
+            raise RuntimeError(
+                "get_transfer requires a non-empty transferable prefix: "
+                f"transferable_len={result.transferable_len} total={len(result.keys)} "
+                f"raw_prefix_hit_len={result.raw_prefix_hit_len} "
+                f"first_miss_index={result.first_miss_index} "
+                f"first_miss_group_index={result.first_miss_group_index}"
+            )
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when get_transfer(). Call setup() first."
+            )
+        _ = concurrency
+        inner_res = self._client.get_transfer(handle.backend_handle)
+        if not inner_res.is_ok():
+            handle.closed = True
+            raise RuntimeError(f"get_transfer backend error: {inner_res.unwrap_error()}")
+        plan_ptr = inner_res.unwrap()
+        handle.closed = True
+        if not isinstance(plan_ptr, int) or plan_ptr <= 0:
+            raise RuntimeError(f"get_transfer returned invalid plan_ptr: {plan_ptr!r}")
+        return int(plan_ptr)
+
     def get_etcd_config(self) -> List[str]:
         if self._client is None:
             raise RuntimeError("Store not initialized")
@@ -889,6 +1729,19 @@ def metrics_snapshot(self) -> MetricSnapshot:
 
         return MetricSnapshot(per_segment=normalized)
 
+    def observability_snapshot_async(self) -> KvFuture:
+        """Return a future for Fluxon locality and IO counters."""
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when observability_snapshot_async(). Call setup() first."
+            )
+        res = self._client.observability_snapshot_async()
+        if not res.is_ok():
+            raise RuntimeError(
+                f"observability_snapshot_async backend error: {res.unwrap_error()}"
+            )
+        return res.unwrap()
+
     # --- Fluxon-kv lease helpers (synchronous) ---
     def allocate_lease(self, ttl_seconds: int) -> Result[int, ApiError]:
         try:
@@ -948,7 +1801,7 @@ def __init__(self, inner_future: Any) -> None:
         self._inner = inner_future
 
     def is_waiting(self) -> bool:
-        return bool(getattr(self._inner, "is_waiting")())
+        return bool(self._inner.is_waiting())
 
     def _decode_wait_success(
         self,
@@ -985,7 +1838,7 @@ def __init__(self, inner_future: Any) -> None:
         self._inner = inner_future
 
     def is_waiting(self) -> bool:
-        return bool(getattr(self._inner, "is_waiting")())
+        return bool(self._inner.is_waiting())
 
     def wait(self) -> Result[bytes, ApiError]:
         res = self._inner.wait()
@@ -1022,7 +1875,7 @@ def __del__(self) -> None:
         self._dlpack_capsules = []
 
     def is_waiting(self) -> bool:
-        return bool(getattr(self._inner, "is_waiting")())
+        return bool(self._inner.is_waiting())
 
     def wait(self) -> Result[Union[Any, MemHolder], ApiError]:
         from ..api_error import OkNone, Result as PyResult  # type: ignore
@@ -1035,3 +1888,36 @@ def wait(self) -> Result[Union[Any, MemHolder], ApiError]:
 
         _ = res.unwrap()
         return PyResult.new_ok(OkNone())  # type: ignore
+
+
+class _FluxonBatchRetCodeFuture(KvFuture):
+    """Future wrapper for batch APIs that resolve to one integer ret-code per key."""
+
+    def __init__(self, inner_future: Any, keepalive: List[object]) -> None:
+        self._inner = inner_future
+        self._keepalive = keepalive
+
+    def __del__(self) -> None:
+        self._keepalive = []
+
+    def is_waiting(self) -> bool:
+        return bool(self._inner.is_waiting())
+
+    def wait(self) -> Result[List[int], ApiError]:
+        res = self._inner.wait()
+        self._keepalive = []
+        if not res.is_ok():
+            return Result.new_error(res.unwrap_error())
+        raw = res.unwrap()
+        if not isinstance(raw, list):
+            return Result.new_error(
+                GeneralError(message=f"batch future returned non-list payload: {type(raw)}")
+            )
+        out: List[int] = []
+        for item in raw:
+            if not isinstance(item, int):
+                return Result.new_error(
+                    GeneralError(message=f"batch future returned non-int item: {type(item)}")
+                )
+            out.append(int(item))
+        return Result.new_ok(out)
diff --git a/fluxon_py/kvclient/kvclient_interface.py b/fluxon_py/kvclient/kvclient_interface.py
index f50db0f..e126eec 100644
--- a/fluxon_py/kvclient/kvclient_interface.py
+++ b/fluxon_py/kvclient/kvclient_interface.py
@@ -21,6 +21,47 @@
 FlatDict = Dict[str, Union[int, float, bool, str, bytes, DLPacked]]
 
 
+@dataclass(frozen=True)
+class GetStartResult:
+    """
+    Result of a group-prefix best-effort get_start().
+
+    Semantics:
+    - ``keys`` is the caller-provided ordered page-key sequence.
+    - ``raw_prefix_hit_len`` is the page-level continuous hit prefix.
+    - ``transferable_len`` is rounded down to complete atomic groups and is the
+      only prefix that can be consumed by get_transfer().
+    """
+
+    keys: Tuple[str, ...]
+    raw_prefix_hit_len: int
+    transferable_len: int
+    prefix_hit_groups: int
+    atomic_group_lens: Optional[Tuple[int, ...]]
+    prefix_best_effort: bool
+    first_miss_index: Optional[int]
+    first_miss_group_index: Optional[int]
+    all_hit: bool
+
+
+@dataclass
+class GetStartHandle:
+    """
+    Opaque-ish handle returned by get_start() and consumed by get_transfer().
+
+    Callers must pass this handle to cancel_get_transfer() when abandoning it
+    without calling get_transfer(). Fluxon backends may keep strong holder
+    references alive while this handle is live.
+    """
+
+    keys: Tuple[str, ...]
+    result: GetStartResult
+    created_at_ns: int
+    backend_token: Optional[int] = None
+    backend_handle: int = 0
+    closed: bool = False
+
+
 @dataclass
 class PutOptionalArgs:
     """
@@ -29,9 +70,16 @@ class PutOptionalArgs:
     - lease_id: attach the written key to a lease on commit.
     - reject_if_inflight_same_key: ask Fluxon to fail-fast when the same key is already
       being written by another inflight put.
+    - reject_if_exist_same_key: ask Fluxon to fail-fast when the key already has a
+      committed live replica.
+    - write_through: keep synchronous remote-placement semantics when the backend
+      supports an async write-back path. Defaults to True to match SGLang
+      HiCache's default write policy.
     """
     lease_id: Optional[int] = None
     reject_if_inflight_same_key: bool = False
+    reject_if_exist_same_key: bool = False
+    write_through: bool = True
 
     def support_mooncake(self) -> Tuple[bool, List[str]]:
         """
@@ -48,6 +96,10 @@ def support_mooncake(self) -> Tuple[bool, List[str]]:
             unsupported.append("lease_id")
         if self.reject_if_inflight_same_key:
             unsupported.append("reject_if_inflight_same_key")
+        if self.reject_if_exist_same_key:
+            unsupported.append("reject_if_exist_same_key")
+        if self.write_through:
+            unsupported.append("write_through")
         return (len(unsupported) == 0, unsupported)
 
 
@@ -139,7 +191,7 @@ def put_blocking(
         _ = wait_result.unwrap()
         return Result.new_ok(OkNone())
 
-    def get_blocking(self, key: str) -> Result["MemHolder", ApiError]:
+    def get_blocking(self, key: str) -> Result[Union[Any, "MemHolder"], ApiError]:
         """Synchronously retrieve a value by key.
 
         Default implementation delegates to ``get()`` followed by
@@ -151,6 +203,100 @@ def get_blocking(self, key: str) -> Result["MemHolder", ApiError]:
             return Result.new_error(get_result.unwrap_error())
         return get_result.unwrap().wait()
 
+    def batch_put_blocking(
+        self,
+        keys: List[str],
+        values: List[FlatDict],
+        opts: Optional[PutOptionalArgs] = None,
+        concurrency: Optional[int] = None,
+    ) -> List[Result[OkNone, ApiError]]:
+        """Synchronously store a batch of key-value pairs."""
+        if len(keys) != len(values):
+            raise ValueError("batch_put_blocking requires keys and values to have the same length")
+        _ = concurrency
+        return [self.put_blocking(key, value, opts=opts) for key, value in zip(keys, values)]
+
+    def batch_get_blocking(
+        self,
+        keys: List[str],
+        concurrency: Optional[int] = None,
+    ) -> List[Result[Union[Any, "MemHolder"], ApiError]]:
+        """Synchronously retrieve a batch of keys."""
+        _ = concurrency
+        return [self.get_blocking(key) for key in keys]
+
+    def local_fast_put_start(
+        self,
+        keys: List[str],
+        value_len: int,
+        opts: Optional[PutOptionalArgs] = None,
+    ) -> int:
+        _ = keys
+        _ = value_len
+        _ = opts
+        raise NotImplementedError(
+            "local_fast_put_start is only implemented by backends with native plan_ptr support"
+        )
+
+    def local_fast_put_commit(self, plan_ptr: int) -> "KvFuture":
+        _ = plan_ptr
+        raise NotImplementedError(
+            "local_fast_put_commit is only implemented by backends with native plan_ptr support"
+        )
+
+    def put_abort(self, plan_ptr: int) -> None:
+        _ = plan_ptr
+        raise NotImplementedError(
+            "put_abort is only implemented by backends with native plan_ptr support"
+        )
+
+    def get_views(
+        self,
+        keys: List[str],
+        concurrency: Optional[int] = None,
+    ) -> int:
+        _ = keys
+        _ = concurrency
+        raise NotImplementedError(
+            "get_views is only implemented by backends with native plan_ptr support"
+        )
+
+    def release_views(self, plan_ptr: int) -> None:
+        _ = plan_ptr
+        raise NotImplementedError(
+            "release_views is only implemented by backends with native plan_ptr support"
+        )
+
+    def get_start(
+        self,
+        keys: List[str],
+        prefix_best_effort: bool = True,
+        atomic_group_lens: Optional[List[int]] = None,
+    ) -> GetStartHandle:
+        _ = keys
+        _ = prefix_best_effort
+        _ = atomic_group_lens
+        raise NotImplementedError(
+            "get_start is only implemented by backends with native prefix get support"
+        )
+
+    def get_transfer(
+        self,
+        handle: GetStartHandle,
+        concurrency: Optional[int] = None,
+    ) -> int:
+        _ = handle
+        _ = concurrency
+        raise NotImplementedError(
+            "get_transfer is only implemented by backends with native prefix get support"
+        )
+
+    def cancel_get_transfer(self, handle: GetStartHandle) -> None:
+        _ = handle
+        raise NotImplementedError(
+            "cancel_get_transfer is only implemented by backends with native prefix get support"
+        )
+
     @abstractmethod
     def get_size(self, key: str) -> Result[int, ApiError]:
         """Get the size of a stored value (non-blocking)."""
diff --git a/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs b/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs
index 878e5c6..e5353a5 100644
--- a/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs
+++ b/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs
@@ -74,12 +74,10 @@ impl ClosedLocalSegmentLeaseRegistry {
     where
         G: Send + Sync + 'static,
     {
-        let boxed = self
-            .guards
-            .lock()
-            .await
-            .remove(&handle)
-            .ok_or_else(|| format!("closed sdk local segment lease handle {handle} not found"))?;
+        let boxed =
+            self.guards.lock().await.remove(&handle).ok_or_else(|| {
+                format!("closed sdk local segment lease handle {handle} not found")
+            })?;
         boxed.downcast::<G>().map(|guard| *guard).map_err(|_| {
             format!(
                 "closed sdk local segment lease handle {handle} has unexpected runtime guard type"
@@ -461,7 +459,7 @@ impl ClientTransferEngineCore {
                 len,
                 seg_guard,
             )
-                .await
+            .await
         }
     }
 
@@ -482,7 +480,11 @@ impl ClientTransferEngineCore {
             let initial_local_segment_guard = match seg_guard {
                 Some(guard) => Some(guard),
                 None if runtime.supports_local_segment_transfer() => {
-                    let local_addr = if peer_src_or_target { target_addr } else { src_addr };
+                    let local_addr = if peer_src_or_target {
+                        target_addr
+                    } else {
+                        src_addr
+                    };
                     match runtime.ensure_local_segment_guard(local_addr, None).await {
                         Ok(guard) => Some(guard),
                         Err(_) => None,
diff --git a/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs b/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs
index 6fab54e..caad34b 100644
--- a/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs
+++ b/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs
@@ -11,9 +11,9 @@ use fluxon_commu_contract::{
     ClosedRuntimeCallRawObservedOutputView, ClosedRuntimeClusterEventStreamItem,
     ClosedRuntimeClusterManagerCall, ClosedRuntimeClusterManagerResponse,
     ClosedRuntimeClusterRdmaResolvedConfigStreamItem, ClosedRuntimeDesiredTransferPeer,
-    ClosedRuntimeDispatchRequestView,
-    ClosedRuntimeDispatchResponse, ClosedRuntimeDispatchTransportPolicy, ClosedRuntimeError,
-    ClosedRuntimeHandle, ClosedRuntimeHostCallbackHandle, ClosedRuntimeP2pCall,
+    ClosedRuntimeDispatchRequestView, ClosedRuntimeDispatchResponse,
+    ClosedRuntimeDispatchTransportPolicy, ClosedRuntimeError, ClosedRuntimeHandle,
+    ClosedRuntimeHostCallbackHandle, ClosedRuntimeP2pCall,
     ClosedRuntimeP2pCallRawObservedRequestView, ClosedRuntimeP2pResponse,
     ClosedRuntimeP2pSendResponseRawRequestView, ClosedRuntimePeerGen, ClosedRuntimeRawSlice,
     ClosedRuntimeRequest, ClosedRuntimeResponse, ClosedRuntimeTransferEngineCall,
@@ -491,11 +491,15 @@ impl WireBodyPartsOwner {
         let (raw_lengths, raw_payload) = match raw_bytes.len() {
             0 => (WireBodyRawLengths::Empty, WireBodyRawPayload::Empty),
             1 => {
-                let part = raw_bytes.into_iter().next().expect("single raw part missing");
-                let len =
-                    u32::try_from(part.len()).map_err(|_| ClosedSdkConsumerError::RuntimeDecode {
+                let part = raw_bytes
+                    .into_iter()
+                    .next()
+                    .expect("single raw part missing");
+                let len = u32::try_from(part.len()).map_err(|_| {
+                    ClosedSdkConsumerError::RuntimeDecode {
                         detail: format!("wire raw part too large for u32 length: {}", part.len()),
-                    })?;
+                    }
+                })?;
                 (
                     WireBodyRawLengths::Single([len]),
                     WireBodyRawPayload::Single(part),
@@ -849,8 +853,7 @@ fn decode_call_raw_observed_output_view(
         return Err(ClosedSdkConsumerError::RuntimeDecode {
             detail: format!(
                 "closed SDK call_raw_observed serialize_part overflow: serialize_len={} full_len={}",
-                message_view.body.serialize_part.len,
-                message_view.body.full_body.len,
+                message_view.body.serialize_part.len, message_view.body.full_body.len,
             ),
         });
     }
@@ -860,21 +863,19 @@ fn decode_call_raw_observed_output_view(
         .ok_or_else(|| ClosedSdkConsumerError::RuntimeDecode {
             detail: "closed SDK call_raw_observed raw_bytes length overflow".to_string(),
         })?;
-    let expected_full_len =
-        message_view
-            .body
-            .serialize_part
-            .len
-            .checked_add(raw_total)
-            .ok_or_else(|| ClosedSdkConsumerError::RuntimeDecode {
-                detail: "closed SDK call_raw_observed body length overflow".to_string(),
-            })?;
+    let expected_full_len = message_view
+        .body
+        .serialize_part
+        .len
+        .checked_add(raw_total)
+        .ok_or_else(|| ClosedSdkConsumerError::RuntimeDecode {
+            detail: "closed SDK call_raw_observed body length overflow".to_string(),
+        })?;
     if expected_full_len != message_view.body.full_body.len {
         return Err(ClosedSdkConsumerError::RuntimeDecode {
             detail: format!(
                 "closed SDK call_raw_observed body length mismatch: expected={} full_len={}",
-                expected_full_len,
-                message_view.body.full_body.len,
+                expected_full_len, message_view.body.full_body.len,
             ),
         });
     }
@@ -923,9 +924,7 @@ fn decode_call_raw_observed_output_view(
                 frame_recv_done_ts_us: message_view.local_observe.frame_recv_done_ts_us,
                 dispatch_enqueued_ts_us: message_view.local_observe.dispatch_enqueued_ts_us,
                 dispatch_started_ts_us: message_view.local_observe.dispatch_started_ts_us,
-                complete_pending_call_ts_us: message_view
-                    .local_observe
-                    .complete_pending_call_ts_us,
+                complete_pending_call_ts_us: message_view.local_observe.complete_pending_call_ts_us,
             },
         },
         observe: fluxon_commu_contract::ClosedRuntimeRpcCallTransportObserveTrace {
@@ -1550,8 +1549,8 @@ async fn invoke_completion_async_with_keepalive(
     ) -> i32,
 ) -> Result<(i32, Bytes), ClosedSdkConsumerError> {
     let (sender, receiver) = tokio::sync::oneshot::channel::<(i32, Bytes)>();
-    let user_data = Box::into_raw(Box::new(RuntimeCompletionState { sender, keepalive }))
-        .cast::<c_void>();
+    let user_data =
+        Box::into_raw(Box::new(RuntimeCompletionState { sender, keepalive })).cast::<c_void>();
     let submit_status = submit(user_data, Some(runtime_completion_callback));
     if submit_status != 0 {
         unsafe {
@@ -2082,7 +2081,9 @@ pub async fn p2p_call_raw_observed(
     )
     .await?;
     match status_code {
-        FLUXON_COMMU_CLOSED_RUNTIME_RESULT_OK => decode_call_raw_observed_output_view(payload.as_ref()),
+        FLUXON_COMMU_CLOSED_RUNTIME_RESULT_OK => {
+            decode_call_raw_observed_output_view(payload.as_ref())
+        }
         FLUXON_COMMU_CLOSED_RUNTIME_RESULT_ERR => {
             let error = bitcode::decode::<ClosedRuntimeError>(payload.as_ref()).map_err(
                 |decode_error| ClosedSdkConsumerError::RuntimeDecode {
diff --git a/fluxon_rs/fluxon_fs/src/agent.rs b/fluxon_rs/fluxon_fs/src/agent.rs
index a482616..45e15e7 100644
--- a/fluxon_rs/fluxon_fs/src/agent.rs
+++ b/fluxon_rs/fluxon_fs/src/agent.rs
@@ -1408,13 +1408,24 @@ impl FluxonFsAgent {
             .id
             .to_string();
         let cache_root_base = if self.kv_framework.is_external_mode() {
-            self.kv_framework
+            let shared_file_path = self
+                .kv_framework
                 .external_client_api_view()
                 .external_client_api()
                 .inner()
-                .large_file_paths()
-                .fs_disk_cache_base_dir()
-                .map_err(|err| format!("invalid external large_file_paths: {}", err))?
+                .shared_file_path();
+            if shared_file_path.is_empty() {
+                return Err("external shared_file_path is empty".to_string());
+            }
+            let cache_root = Path::new(&shared_file_path).join("fluxon_fs_disk_cache");
+            fs::create_dir_all(&cache_root).map_err(|err| {
+                format!(
+                    "invalid external shared_file_path for fluxon fs disk cache: {} ({})",
+                    cache_root.display(),
+                    err
+                )
+            })?;
+            cache_root
         } else {
             self.kv_framework
                 .client_seg_pool_view()
diff --git a/fluxon_rs/fluxon_fs/src/agent_service/transfer_agent.rs b/fluxon_rs/fluxon_fs/src/agent_service/transfer_agent.rs
index 1738ade..ca54a71 100644
--- a/fluxon_rs/fluxon_fs/src/agent_service/transfer_agent.rs
+++ b/fluxon_rs/fluxon_fs/src/agent_service/transfer_agent.rs
@@ -9,28 +9,23 @@ use std::time::{Duration, Instant};
 
 use fluxon_fs_core::config::{
     FS_AGENT_TRANSFER_STREAM_CLOSE_RPC_PATH, FS_AGENT_TRANSFER_STREAM_NEXT_RPC_PATH,
-    FS_AGENT_TRANSFER_STREAM_OPEN_RPC_PATH,
-    FS_MASTER_TRANSFER_SCHEDULER_HEARTBEAT_RPC_PATH, FS_MASTER_TRANSFER_SCHEDULER_RESULT_RPC_PATH,
-    FluxonFsTransferBatchCollectInfoWire, FluxonFsTransferBatchKind,
-    FluxonFsTransferCollectInfoKind, FluxonFsTransferDispositionWire,
-    FluxonFsTransferFailedFileReasonKindWire,
-    FluxonFsTransferReadStreamCloseWire, FluxonFsTransferReadStreamNextResultWire,
-    FluxonFsTransferReadStreamNextWire, FluxonFsTransferReadStreamOpenResultWire,
-    FluxonFsTransferReadStreamOpenWire,
-    FluxonFsTransferSkipEntryKind, FluxonFsTransferSkipEntryWire,
-    FluxonFsTransferManifestEntryWire, FluxonFsTransferManifestWire,
-    FluxonFsTransferScanMode,
-    FluxonFsTransferScanEventAckWire, FluxonFsTransferScanEventKindWire,
-    FluxonFsTransferScanEventWire, FluxonFsTransferScanLaunchResultWire,
+    FS_AGENT_TRANSFER_STREAM_OPEN_RPC_PATH, FS_MASTER_TRANSFER_SCHEDULER_HEARTBEAT_RPC_PATH,
+    FS_MASTER_TRANSFER_SCHEDULER_RESULT_RPC_PATH, FluxonFsTransferBatchCollectInfoWire,
+    FluxonFsTransferBatchKind, FluxonFsTransferCollectInfoKind, FluxonFsTransferDispositionWire,
+    FluxonFsTransferFailedFileReasonKindWire, FluxonFsTransferManifestEntryWire,
+    FluxonFsTransferManifestWire, FluxonFsTransferReadStreamCloseWire,
+    FluxonFsTransferReadStreamNextResultWire, FluxonFsTransferReadStreamNextWire,
+    FluxonFsTransferReadStreamOpenResultWire, FluxonFsTransferReadStreamOpenWire,
     FluxonFsTransferScanAssignmentWire, FluxonFsTransferScanBatchWire,
-    FluxonFsTransferScanChildUnitWire, FluxonFsTransferScanFrontier,
+    FluxonFsTransferScanChildUnitWire, FluxonFsTransferScanEventAckWire,
+    FluxonFsTransferScanEventKindWire, FluxonFsTransferScanEventWire, FluxonFsTransferScanFrontier,
     FluxonFsTransferScanFrontierDirEntry, FluxonFsTransferScanFrontierEntry,
-    FluxonFsTransferScanResultWire,
-    FluxonFsTransferSymlinkNoticeEntryWire, FluxonFsTransferWorkerCollectInfoResultWire,
-    FluxonFsTransferWorkerAssignmentWire, FluxonFsTransferWorkerFileResultWire,
-    FluxonFsTransferWorkerFailedFileResultWire,
-    FluxonFsTransferWorkerHeartbeatResultWire, FluxonFsTransferWorkerHeartbeatTelemetryWire,
-    FluxonFsTransferWorkerHeartbeatWire,
+    FluxonFsTransferScanLaunchResultWire, FluxonFsTransferScanMode, FluxonFsTransferScanResultWire,
+    FluxonFsTransferSkipEntryKind, FluxonFsTransferSkipEntryWire,
+    FluxonFsTransferSymlinkNoticeEntryWire, FluxonFsTransferWorkerAssignmentWire,
+    FluxonFsTransferWorkerCollectInfoResultWire, FluxonFsTransferWorkerFailedFileResultWire,
+    FluxonFsTransferWorkerFileResultWire, FluxonFsTransferWorkerHeartbeatResultWire,
+    FluxonFsTransferWorkerHeartbeatTelemetryWire, FluxonFsTransferWorkerHeartbeatWire,
     FluxonFsTransferWorkerLaunchResultWire, FluxonFsTransferWorkerResultAckWire,
     FluxonFsTransferWorkerResultWire, FluxonFsTransferWorkerStopReasonWire,
     transfer_collect_info_output_relpath,
@@ -39,8 +34,8 @@ use fluxon_fs_core::retry::{
     BackoffConfig, DEFAULT_WARN_INTERVAL_SECS, WarnConfig, next_backoff, should_warn,
 };
 use fluxon_kv::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError};
-use fluxon_kv::user_api::flat_dict::{FlatDict, FlatValue};
 use fluxon_kv::user_api::FluxonUserApi;
+use fluxon_kv::user_api::flat_dict::{FlatDict, FlatValue};
 use parking_lot::{Condvar, Mutex};
 
 use super::{
@@ -202,16 +197,13 @@ fn transfer_scan_session_state() -> &'static Mutex<TransferScanSessionState> {
     TRANSFER_SCAN_SESSION_STATE.get_or_init(|| Mutex::new(TransferScanSessionState::default()))
 }
 
-fn cleanup_expired_transfer_scan_sessions(
-    state: &mut TransferScanSessionState,
-    now_unix_ms: i64,
-) {
-    state
-        .root_dir_listing_sessions
-        .retain(|_, session| session.lease_expire_unix_ms <= 0 || session.lease_expire_unix_ms > now_unix_ms);
-    state
-        .subtree_streaming_sessions
-        .retain(|_, session| session.lease_expire_unix_ms <= 0 || session.lease_expire_unix_ms > now_unix_ms);
+fn cleanup_expired_transfer_scan_sessions(state: &mut TransferScanSessionState, now_unix_ms: i64) {
+    state.root_dir_listing_sessions.retain(|_, session| {
+        session.lease_expire_unix_ms <= 0 || session.lease_expire_unix_ms > now_unix_ms
+    });
+    state.subtree_streaming_sessions.retain(|_, session| {
+        session.lease_expire_unix_ms <= 0 || session.lease_expire_unix_ms > now_unix_ms
+    });
 }
 
 fn same_root_continuation_scan_unit(
@@ -301,10 +293,7 @@ fn flush_pending_root_direct_files_batch(
         return Ok(None);
     }
     let batch = build_direct_files_only_batch_from_entries_with_batch_id(
-        direct_files_only_batch_id_for_partition(
-            assignment,
-            session.next_direct_files_batch_index,
-        ),
+        direct_files_only_batch_id_for_partition(assignment, session.next_direct_files_batch_index),
         assignment,
         assignment.root_relpath.clone(),
         std::mem::take(&mut session.pending_direct_files),
@@ -313,7 +302,8 @@ fn flush_pending_root_direct_files_batch(
     )?;
     session.pending_direct_bytes = 0;
     session.next_direct_files_batch_index = session.next_direct_files_batch_index.saturating_add(1);
-    session.emitted_direct_files_batch_count = session.emitted_direct_files_batch_count.saturating_add(1);
+    session.emitted_direct_files_batch_count =
+        session.emitted_direct_files_batch_count.saturating_add(1);
     Ok(Some(batch))
 }
 
@@ -414,7 +404,8 @@ fn open_transfer_root_dir_listing_session(
     root_dir_abs: &str,
     assignment: &FluxonFsTransferScanAssignmentWire,
 ) -> Result<Option<TransferRootDirListingSession>, FlatDict> {
-    let dir_abs = safe_join_root(root_dir_abs, assignment.root_relpath.as_str()).map_err(resp_err_kverr)?;
+    let dir_abs =
+        safe_join_root(root_dir_abs, assignment.root_relpath.as_str()).map_err(resp_err_kverr)?;
     let read_dir = match retry_after_target_path_chmod(
         dir_abs.as_path(),
         "root_read_dir",
@@ -458,7 +449,10 @@ fn take_transfer_root_dir_listing_session(
     let now_unix_ms = chrono::Utc::now().timestamp_millis();
     let mut state = transfer_scan_session_state().lock();
     cleanup_expired_transfer_scan_sessions(&mut state, now_unix_ms);
-    if let Some(mut session) = state.root_dir_listing_sessions.remove(assignment.scan_unit_id.as_str()) {
+    if let Some(mut session) = state
+        .root_dir_listing_sessions
+        .remove(assignment.scan_unit_id.as_str())
+    {
         if session.job_id == assignment.job_id
             && session.scan_epoch == assignment.scan_epoch
             && session.root_relpath == assignment.root_relpath
@@ -507,7 +501,8 @@ fn open_transfer_subtree_streaming_session(
     if is_relpath_skipped(&assignment.skip_entries, assignment.root_relpath.as_str()) {
         return Ok(None);
     }
-    let dir_abs = safe_join_root(root_dir_abs, assignment.root_relpath.as_str()).map_err(resp_err_kverr)?;
+    let dir_abs =
+        safe_join_root(root_dir_abs, assignment.root_relpath.as_str()).map_err(resp_err_kverr)?;
     let root_md = retry_after_target_path_chmod(
         Path::new(root_dir_abs),
         "subtree_stream_root_symlink_metadata",
@@ -790,7 +785,8 @@ fn collect_transfer_root_dir_listing_slice(
     assignment: &FluxonFsTransferScanAssignmentWire,
     deadline: Option<TransferScanDeadline>,
 ) -> Result<TransferRootDirListingOutcome, FlatDict> {
-    let Some(mut session) = take_transfer_root_dir_listing_session(root_dir_abs, assignment)? else {
+    let Some(mut session) = take_transfer_root_dir_listing_session(root_dir_abs, assignment)?
+    else {
         return Ok(TransferRootDirListingOutcome::Finished(
             build_finished_empty_transfer_scan_result(assignment),
         ));
@@ -848,7 +844,8 @@ fn collect_transfer_root_dir_listing_slice(
         };
         scanned_entries = scanned_entries.saturating_add(1);
         let name = ent.file_name().to_string_lossy().to_string();
-        let child_relpath = normalize_child_relpath(assignment.root_relpath.as_str(), name.as_str());
+        let child_relpath =
+            normalize_child_relpath(assignment.root_relpath.as_str(), name.as_str());
         if is_relpath_skipped(&assignment.skip_entries, child_relpath.as_str()) {
             continue;
         }
@@ -899,10 +896,12 @@ fn collect_transfer_root_dir_listing_slice(
             let size = md.len().min(i64::MAX as u64) as i64;
             session.root_visible_entries = true;
             session.root_total_bytes = session.root_total_bytes.saturating_add(size);
-            session.pending_direct_files.push(FluxonFsTransferScanFrontierEntry {
-                relpath: child_relpath,
-                size,
-            });
+            session
+                .pending_direct_files
+                .push(FluxonFsTransferScanFrontierEntry {
+                    relpath: child_relpath,
+                    size,
+                });
             session.pending_direct_bytes = session.pending_direct_bytes.saturating_add(size);
             if should_flush_direct_batch(
                 assignment.batch_ready_bytes,
@@ -910,7 +909,9 @@ fn collect_transfer_root_dir_listing_slice(
                 session.pending_direct_files.len(),
                 session.pending_direct_empty_dirs.len(),
             ) {
-                if let Some(batch) = flush_pending_root_direct_files_batch(assignment, &mut session)? {
+                if let Some(batch) =
+                    flush_pending_root_direct_files_batch(assignment, &mut session)?
+                {
                     direct_files_only_batches.push(batch);
                 }
             }
@@ -933,14 +934,18 @@ fn collect_transfer_root_dir_listing_slice(
                 session.pending_direct_files.len(),
                 session.pending_direct_empty_dirs.len(),
             ) {
-                if let Some(batch) = flush_pending_root_direct_files_batch(assignment, &mut session)? {
+                if let Some(batch) =
+                    flush_pending_root_direct_files_batch(assignment, &mut session)?
+                {
                     direct_files_only_batches.push(batch);
                 }
             }
         } else {
-            session.direct_dirs.push(FluxonFsTransferScanFrontierDirEntry {
-                relpath: child_relpath,
-            });
+            session
+                .direct_dirs
+                .push(FluxonFsTransferScanFrontierDirEntry {
+                    relpath: child_relpath,
+                });
         }
     }
 }
@@ -1244,12 +1249,14 @@ impl TransferWorkerProgressWindow {
     fn record_written_bytes_and_maybe_ramp(&self, bytes: i64, now_unix_ms: i64) {
         let normalized = bytes.max(0);
         self.window_bytes.fetch_add(normalized, Ordering::SeqCst);
-        self.total_written_bytes.fetch_add(normalized, Ordering::SeqCst);
+        self.total_written_bytes
+            .fetch_add(normalized, Ordering::SeqCst);
         self.maybe_ramp(now_unix_ms);
     }
 
     fn record_materialized_empty_dir(&self) {
-        self.total_materialized_empty_dirs.fetch_add(1, Ordering::SeqCst);
+        self.total_materialized_empty_dirs
+            .fetch_add(1, Ordering::SeqCst);
     }
 
     fn total_materialized_empty_dirs(&self) -> i64 {
@@ -1298,8 +1305,9 @@ impl TransferWorkerProgressWindow {
         }
         if previous_goodput > 0 {
             let delta = current_goodput.saturating_sub(previous_goodput);
-            let improvement_percent =
-                delta.saturating_mul(100).saturating_div(previous_goodput.max(1));
+            let improvement_percent = delta
+                .saturating_mul(100)
+                .saturating_div(previous_goodput.max(1));
             if improvement_percent < self.policy.min_improvement_percent {
                 return;
             }
@@ -1335,10 +1343,8 @@ impl TransferWorkerProgressWindow {
                 .saturating_mul(1000)
                 .saturating_div(window_elapsed_ms.max(1))
         };
-        self.peak_sample_goodput_bytes_per_sec.fetch_max(
-            window_goodput_bytes_per_sec.max(0),
-            Ordering::SeqCst,
-        );
+        self.peak_sample_goodput_bytes_per_sec
+            .fetch_max(window_goodput_bytes_per_sec.max(0), Ordering::SeqCst);
         Some(TransferWorkerThroughputSample {
             window_started_unix_ms,
             window_elapsed_ms,
@@ -1448,7 +1454,8 @@ impl TransferReadStreamActorOwned {
                 data: Vec::new(),
             });
         }
-        self.fill_prefetch_queue().map_err(|err| self.cache_terminal_error(err))?;
+        self.fill_prefetch_queue()
+            .map_err(|err| self.cache_terminal_error(err))?;
         let to_take = std::cmp::min(length as usize, (self.file_size - next_offset) as usize);
         let buf = self
             .take_prefetched_bytes(to_take)
@@ -1457,7 +1464,8 @@ impl TransferReadStreamActorOwned {
         self.replay_offset = next_offset;
         self.replay_data = buf.clone();
         self.next_offset = next_offset.saturating_add(buf.len() as i64);
-        self.fill_prefetch_queue().map_err(|err| self.cache_terminal_error(err))?;
+        self.fill_prefetch_queue()
+            .map_err(|err| self.cache_terminal_error(err))?;
         Ok(FluxonFsTransferReadStreamNextResultWire {
             stream_missing: false,
             data: buf,
@@ -1598,7 +1606,11 @@ impl TransferReadStreamActorHandle {
 
 struct TransferWorkerCoordinator<ReadChunkFn, CheckpointFn>
 where
-    ReadChunkFn: Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>,
+    ReadChunkFn: Fn(
+        &FluxonFsTransferManifestEntryWire,
+        i64,
+        i64,
+    ) -> Result<Vec<u8>, TransferWorkerExecutionError>,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError>,
 {
     log_context: TransferWorkerLogContext,
@@ -1611,7 +1623,11 @@ where
 
 impl<ReadChunkFn, CheckpointFn> TransferWorkerCoordinator<ReadChunkFn, CheckpointFn>
 where
-    ReadChunkFn: Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>,
+    ReadChunkFn: Fn(
+        &FluxonFsTransferManifestEntryWire,
+        i64,
+        i64,
+    ) -> Result<Vec<u8>, TransferWorkerExecutionError>,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError>,
 {
     fn new(
@@ -1693,7 +1709,8 @@ where
     }
 
     fn progress_snapshot(&self) -> TransferWorkerProgressSnapshot {
-        self.progress.snapshot(chrono::Utc::now().timestamp_millis())
+        self.progress
+            .snapshot(chrono::Utc::now().timestamp_millis())
     }
 
     fn stop(&self) {
@@ -1737,7 +1754,8 @@ impl TransferReadStreamRegistryHandle {
                 });
             }
         }
-        let full_path = safe_join_root(root_dir_abs, open.relpath.as_str()).map_err(resp_err_kverr)?;
+        let full_path =
+            safe_join_root(root_dir_abs, open.relpath.as_str()).map_err(resp_err_kverr)?;
         let file = open_file_with_target_path_chmod_retry(&full_path, "open_stream")?;
         let md = file.metadata().map_err(resp_err_io)?;
         let file_size = md.len().min(i64::MAX as u64) as i64;
@@ -1764,12 +1782,15 @@ impl TransferReadStreamRegistryHandle {
             });
         }
         state.streams.insert(stream_id.clone(), entry);
-        state.dedup_by_worker_file.insert(dedup_key, stream_id.clone());
+        state
+            .dedup_by_worker_file
+            .insert(dedup_key, stream_id.clone());
         drop(state);
         if let Err(resp) = TransferReadStreamActorHandle::start(stream_id.as_str(), actor) {
             let mut state = self.state.lock();
             state.streams.remove(stream_id.as_str());
-            state.dedup_by_worker_file
+            state
+                .dedup_by_worker_file
                 .retain(|_, existing_stream_id| existing_stream_id != &stream_id);
             return Err(resp);
         }
@@ -1811,7 +1832,9 @@ impl TransferReadStreamRegistryHandle {
         let Some(entry) = state.streams.remove(stream_id) else {
             return;
         };
-        state.dedup_by_worker_file.retain(|_, existing_stream_id| existing_stream_id != stream_id);
+        state
+            .dedup_by_worker_file
+            .retain(|_, existing_stream_id| existing_stream_id != stream_id);
         entry.close();
     }
 }
@@ -1894,20 +1917,22 @@ fn decode_transfer_stream_open_result_payload(
         return Err(TransferWorkerRpcFailure::Fatal(resp.clone()));
     }
     Ok(FluxonFsTransferReadStreamOpenResultWire {
-        stream_id: require_str(resp, "stream_id").map_err(resp_err_kverr).map_err(
-            |err| {
+        stream_id: require_str(resp, "stream_id")
+            .map_err(resp_err_kverr)
+            .map_err(|err| {
                 invalid_transfer_rpc_response(format!(
                     "transfer read stream open response missing stream_id: err={}",
                     transfer_rpc_response_err_text(&err)
                 ))
-            },
-        )?,
-        size: require_i64(resp, "size").map_err(resp_err_kverr).map_err(|err| {
-            invalid_transfer_rpc_response(format!(
-                "transfer read stream open response missing size: err={}",
-                transfer_rpc_response_err_text(&err)
-            ))
-        })?,
+            })?,
+        size: require_i64(resp, "size")
+            .map_err(resp_err_kverr)
+            .map_err(|err| {
+                invalid_transfer_rpc_response(format!(
+                    "transfer read stream open response missing size: err={}",
+                    transfer_rpc_response_err_text(&err)
+                ))
+            })?,
     })
 }
 
@@ -1980,11 +2005,15 @@ fn is_relpath_skipped(skip_entries: &[FluxonFsTransferSkipEntryWire], relpath: &
 }
 
 fn file_name_from_relpath(relpath: &str) -> Result<&str, FlatDict> {
-    relpath.rsplit('/').next().filter(|v| !v.is_empty()).ok_or_else(|| {
-        resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
-            detail: format!("relpath must contain file name: {}", relpath),
-        }))
-    })
+    relpath
+        .rsplit('/')
+        .next()
+        .filter(|v| !v.is_empty())
+        .ok_or_else(|| {
+            resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
+                detail: format!("relpath must contain file name: {}", relpath),
+            }))
+        })
 }
 
 fn transfer_staging_dir_for_file(staging_prefix: &str, relpath: &str) -> String {
@@ -2106,8 +2135,12 @@ where
     match attempt() {
         Ok(value) => Ok(value),
         Err(initial_err) if initial_err.kind() == ErrorKind::PermissionDenied => {
-            let repair_dir =
-                repair_permission_denied_dir_for_retry(repair_anchor, op, target_path, &initial_err)?;
+            let repair_dir = repair_permission_denied_dir_for_retry(
+                repair_anchor,
+                op,
+                target_path,
+                &initial_err,
+            )?;
             attempt().map_err(|retry_err| {
                 resp_err_kverr(KvError::Api(ApiError::Unknown {
                     detail: format!(
@@ -2334,10 +2367,11 @@ fn collect_transfer_tree_with_deadline(
                         continue;
                     }
                 };
-                out.symlink_notices.push(FluxonFsTransferSymlinkNoticeEntryWire {
-                    relpath: child_rel,
-                    link_target: link_target.to_string_lossy().to_string(),
-                });
+                out.symlink_notices
+                    .push(FluxonFsTransferSymlinkNoticeEntryWire {
+                        relpath: child_rel,
+                        link_target: link_target.to_string_lossy().to_string(),
+                    });
                 continue;
             }
             if md.is_dir() {
@@ -2361,7 +2395,8 @@ fn collect_transfer_tree_with_deadline(
     }
     out.files.sort_by(|a, b| a.relpath.cmp(&b.relpath));
     out.empty_dirs.sort();
-    out.symlink_notices.sort_by(|a, b| a.relpath.cmp(&b.relpath));
+    out.symlink_notices
+        .sort_by(|a, b| a.relpath.cmp(&b.relpath));
     Ok(out)
 }
 
@@ -2574,10 +2609,8 @@ fn build_transfer_scan_events_for_result(
     event_seq_no_start: i64,
     result: FluxonFsTransferScanResultWire,
 ) -> (Vec<FluxonFsTransferScanEventWire>, bool, i64) {
-    let (child_scan_units, continue_locally) = split_same_root_continuation_from_child_scan_units(
-        assignment,
-        result.child_scan_units,
-    );
+    let (child_scan_units, continue_locally) =
+        split_same_root_continuation_from_child_scan_units(assignment, result.child_scan_units);
     if continue_locally {
         let event = build_transfer_scan_event(
             assignment,
@@ -2588,11 +2621,7 @@ fn build_transfer_scan_events_for_result(
             result.full_dir_batches,
             String::new(),
         );
-        return (
-            vec![event],
-            true,
-            event_seq_no_start.saturating_add(1),
-        );
+        return (vec![event], true, event_seq_no_start.saturating_add(1));
     }
     let mut next_event_seq_no = event_seq_no_start;
     let mut events = Vec::new();
@@ -2620,11 +2649,7 @@ fn build_transfer_scan_events_for_result(
         Vec::new(),
         String::new(),
     ));
-    (
-        events,
-        false,
-        next_event_seq_no.saturating_add(1),
-    )
+    (events, false, next_event_seq_no.saturating_add(1))
 }
 
 fn send_transfer_scan_event_once(
@@ -2637,10 +2662,7 @@ fn send_transfer_scan_event_once(
     }
     let event_json = serde_json::to_string(event)
         .map_err(|e| format!("serialize transfer scan event failed: {}", e))?;
-    let payload = FlatDict::from([(
-        "scan_event_json".to_string(),
-        FlatValue::String(event_json),
-    )]);
+    let payload = FlatDict::from([("scan_event_json".to_string(), FlatValue::String(event_json))]);
     let resp = api
         .rpc_client()
         .call(
@@ -2793,30 +2815,28 @@ fn run_transfer_scan_background_task(
     }
     let mut next_event_seq_no = 1_i64;
     loop {
-        let result = match build_transfer_scan_result_for_root_dir_abs(
-            root_dir_abs.as_str(),
-            &assignment,
-        ) {
-            Ok(v) => v,
-            Err(resp) => {
-                let failed = build_transfer_scan_event(
-                    &assignment,
-                    next_event_seq_no,
-                    FluxonFsTransferScanEventKindWire::Failed,
-                    Vec::new(),
-                    Vec::new(),
-                    Vec::new(),
-                    transfer_rpc_response_err_text(&resp),
-                );
-                let _ = send_transfer_scan_event_with_retry(
-                    api.as_ref(),
-                    master_id.as_str(),
-                    &mut assignment,
-                    &failed,
-                );
-                break;
-            }
-        };
+        let result =
+            match build_transfer_scan_result_for_root_dir_abs(root_dir_abs.as_str(), &assignment) {
+                Ok(v) => v,
+                Err(resp) => {
+                    let failed = build_transfer_scan_event(
+                        &assignment,
+                        next_event_seq_no,
+                        FluxonFsTransferScanEventKindWire::Failed,
+                        Vec::new(),
+                        Vec::new(),
+                        Vec::new(),
+                        transfer_rpc_response_err_text(&resp),
+                    );
+                    let _ = send_transfer_scan_event_with_retry(
+                        api.as_ref(),
+                        master_id.as_str(),
+                        &mut assignment,
+                        &failed,
+                    );
+                    break;
+                }
+            };
         let (events, continue_locally, next_seq_no_after_events) =
             build_transfer_scan_events_for_result(&assignment, next_event_seq_no, result);
         next_event_seq_no = next_seq_no_after_events;
@@ -2922,17 +2942,14 @@ impl TransferScanRegistryHandle {
         let assignment2 = assignment.clone();
         let thread_name = format!("fluxon_fs_transfer_scan_{}", assignment.scan_task_id);
         match thread::Builder::new().name(thread_name).spawn(move || {
-            run_transfer_scan_background_task(
-                registry,
-                api2,
-                master_id2,
-                exports2,
-                assignment2,
-            );
+            run_transfer_scan_background_task(registry, api2, master_id2, exports2, assignment2);
         }) {
             Ok(_) => Ok(FluxonFsTransferScanLaunchResultWire::started()),
             Err(err) => {
-                self.state.lock().tasks.remove(assignment.scan_task_id.as_str());
+                self.state
+                    .lock()
+                    .tasks
+                    .remove(assignment.scan_task_id.as_str());
                 Err(resp_err_kverr(KvError::Api(ApiError::Unknown {
                     detail: format!(
                         "spawn transfer scan thread failed: scan_task_id={} err={}",
@@ -3006,22 +3023,16 @@ impl TransferWorkerRegistryHandle {
         let master_id2 = master_id.to_string();
         let exports2 = exports.clone();
         let assignment2 = assignment.clone();
-        let thread_name = format!(
-            "fluxon_fs_transfer_worker_{}",
-            assignment.worker_task_id
-        );
+        let thread_name = format!("fluxon_fs_transfer_worker_{}", assignment.worker_task_id);
         match thread::Builder::new().name(thread_name).spawn(move || {
-            run_transfer_worker_background_task(
-                registry,
-                api2,
-                master_id2,
-                exports2,
-                assignment2,
-            );
+            run_transfer_worker_background_task(registry, api2, master_id2, exports2, assignment2);
         }) {
             Ok(_) => Ok(FluxonFsTransferWorkerLaunchResultWire::started()),
             Err(err) => {
-                self.state.lock().tasks.remove(assignment.worker_task_id.as_str());
+                self.state
+                    .lock()
+                    .tasks
+                    .remove(assignment.worker_task_id.as_str());
                 Err(resp_err_kverr(KvError::Api(ApiError::Unknown {
                     detail: format!(
                         "spawn transfer worker thread failed: worker_task_id={} err={}",
@@ -3298,10 +3309,7 @@ fn send_transfer_worker_result_once(
             detail: format!("serialize transfer worker result failed: {}", e),
         })))
     })?;
-    let payload = FlatDict::from([(
-        "result_json".to_string(),
-        FlatValue::String(result_json),
-    )]);
+    let payload = FlatDict::from([("result_json".to_string(), FlatValue::String(result_json))]);
     let resp = api
         .rpc_client()
         .call(
@@ -3396,7 +3404,10 @@ fn open_transfer_read_stream_via_rpc_once(
             "relpath".to_string(),
             FlatValue::String(file.relpath.clone()),
         ),
-        ("initial_offset".to_string(), FlatValue::Int64(initial_offset)),
+        (
+            "initial_offset".to_string(),
+            FlatValue::Int64(initial_offset),
+        ),
     ]);
     let resp = api
         .rpc_client()
@@ -3518,25 +3529,25 @@ impl TransferWorkerRemoteControl {
         loop {
             self.before_heartbeat_retry_attempt()?;
             let current_materialized_empty_dirs = self.progress.total_materialized_empty_dirs();
-            match self
-                .heartbeat
-                .ensure_continue(
-                    force,
-                    current_materialized_empty_dirs,
-                    |heartbeat_unix_ms, _heartbeat_detail| {
-                        let progress_snapshot =
-                            self.progress.snapshot(chrono::Utc::now().timestamp_millis());
-                        let telemetry =
-                            Some(transfer_worker_telemetry_from_progress_snapshot(&progress_snapshot));
-                        send_transfer_worker_heartbeat_once(
-                            self.api.as_ref(),
-                            self.master_id.as_str(),
-                            &self.assignment,
-                            heartbeat_unix_ms,
-                            telemetry,
-                        )
-                    },
-                ) {
+            match self.heartbeat.ensure_continue(
+                force,
+                current_materialized_empty_dirs,
+                |heartbeat_unix_ms, _heartbeat_detail| {
+                    let progress_snapshot = self
+                        .progress
+                        .snapshot(chrono::Utc::now().timestamp_millis());
+                    let telemetry = Some(transfer_worker_telemetry_from_progress_snapshot(
+                        &progress_snapshot,
+                    ));
+                    send_transfer_worker_heartbeat_once(
+                        self.api.as_ref(),
+                        self.master_id.as_str(),
+                        &self.assignment,
+                        heartbeat_unix_ms,
+                        telemetry,
+                    )
+                },
+            ) {
                 Ok(()) => return Ok(()),
                 Err(TransferWorkerHeartbeatGateError::Terminal(err)) => return Err(err),
                 Err(TransferWorkerHeartbeatGateError::Retryable {
@@ -3631,10 +3642,7 @@ impl TransferWorkerRemoteControl {
         )
     }
 
-    fn close_stream_with_retry(
-        &self,
-        stream_id: &str,
-    ) -> Result<(), TransferWorkerExecutionError> {
+    fn close_stream_with_retry(&self, stream_id: &str) -> Result<(), TransferWorkerExecutionError> {
         let api = self.api.clone();
         let assignment = self.assignment.clone();
         let op_detail = format!(
@@ -3744,9 +3752,9 @@ impl TransferWorkerRemoteControl {
         if ack.accepted {
             return Ok(());
         }
-        Err(TransferWorkerExecutionError::Stop(stop_reason_or_superseded(
-            ack.stop_reason,
-        )))
+        Err(TransferWorkerExecutionError::Stop(
+            stop_reason_or_superseded(ack.stop_reason),
+        ))
     }
 }
 
@@ -3825,10 +3833,12 @@ impl TransferWorkerHeartbeatGate {
         mut heartbeat_op: HeartbeatOp,
     ) -> Result<(), TransferWorkerHeartbeatGateError>
     where
-        HeartbeatOp: FnMut(
-            i64,
-            &'static str,
-        ) -> Result<FluxonFsTransferWorkerHeartbeatResultWire, TransferWorkerRpcFailure>,
+        HeartbeatOp:
+            FnMut(
+                i64,
+                &'static str,
+            )
+                -> Result<FluxonFsTransferWorkerHeartbeatResultWire, TransferWorkerRpcFailure>,
     {
         loop {
             let (heartbeat_unix_ms, heartbeat_detail) = {
@@ -3875,15 +3885,13 @@ impl TransferWorkerHeartbeatGate {
             state.heartbeat_inflight = false;
             let result = match heartbeat_result {
                 Ok(heartbeat_result) if heartbeat_result.continue_running => {
-                    state.last_heartbeat_completed_unix_ms =
-                        chrono::Utc::now().timestamp_millis();
+                    state.last_heartbeat_completed_unix_ms = chrono::Utc::now().timestamp_millis();
                     state.last_heartbeat_materialized_empty_dirs = current_materialized_empty_dirs;
                     state.granted_lease_expire_unix_ms = heartbeat_result.lease_expire_unix_ms;
                     Ok(())
                 }
                 Ok(heartbeat_result) => {
-                    state.last_heartbeat_completed_unix_ms =
-                        chrono::Utc::now().timestamp_millis();
+                    state.last_heartbeat_completed_unix_ms = chrono::Utc::now().timestamp_millis();
                     state.last_heartbeat_materialized_empty_dirs = current_materialized_empty_dirs;
                     let reason = stop_reason_or_superseded(heartbeat_result.stop_reason);
                     state.terminal_state =
@@ -3933,7 +3941,8 @@ fn run_transfer_worker_background_task(
     ));
     let dedup_expire_unix_ms = match control.ensure_continue(true) {
         Ok(()) => {
-            let dst_export_root = match exports.export_root_dir_abs(assignment.dst_export.as_str()) {
+            let dst_export_root = match exports.export_root_dir_abs(assignment.dst_export.as_str())
+            {
                 Ok(v) => v,
                 Err(err) => {
                     tracing::warn!(
@@ -3996,7 +4005,9 @@ fn run_transfer_worker_background_task(
                 },
                 {
                     let control = control.clone();
-                    move |file, read_offset, length| control.read_chunk_with_retry(file, read_offset, length)
+                    move |file, read_offset, length| {
+                        control.read_chunk_with_retry(file, read_offset, length)
+                    }
                 },
             ) {
                 Ok(result) => {
@@ -4004,34 +4015,38 @@ fn run_transfer_worker_background_task(
                     if let Err(resp) =
                         cleanup_transfer_worker_attempt_artifacts(&dst_root, &assignment)
                     {
-                        log_transfer_worker_cleanup_failure("before_result_submit", &assignment, &resp);
-                    }
-                    match control.submit_result_with_retry(&result) {
-                    Ok(()) => control.dedup_expire_unix_ms(),
-                    Err(TransferWorkerExecutionError::Stop(reason)) => {
-                        tracing::info!(
-                            "transfer worker result submission stopped: job_id={} batch_id={} worker_id={} worker_task_id={} reason={:?}",
-                            assignment.job_id,
-                            assignment.batch_id,
-                            assignment.worker_id,
-                            assignment.worker_task_id,
-                            reason
+                        log_transfer_worker_cleanup_failure(
+                            "before_result_submit",
+                            &assignment,
+                            &resp,
                         );
-                        control.dedup_expire_unix_ms()
                     }
-                    Err(TransferWorkerExecutionError::Fatal(resp)) => {
-                        tracing::warn!(
-                            "transfer worker result submission failed: job_id={} batch_id={} worker_id={} worker_task_id={} resp={:?}",
-                            assignment.job_id,
-                            assignment.batch_id,
-                            assignment.worker_id,
-                            assignment.worker_task_id,
-                            resp
-                        );
-                        control.dedup_expire_unix_ms()
+                    match control.submit_result_with_retry(&result) {
+                        Ok(()) => control.dedup_expire_unix_ms(),
+                        Err(TransferWorkerExecutionError::Stop(reason)) => {
+                            tracing::info!(
+                                "transfer worker result submission stopped: job_id={} batch_id={} worker_id={} worker_task_id={} reason={:?}",
+                                assignment.job_id,
+                                assignment.batch_id,
+                                assignment.worker_id,
+                                assignment.worker_task_id,
+                                reason
+                            );
+                            control.dedup_expire_unix_ms()
+                        }
+                        Err(TransferWorkerExecutionError::Fatal(resp)) => {
+                            tracing::warn!(
+                                "transfer worker result submission failed: job_id={} batch_id={} worker_id={} worker_task_id={} resp={:?}",
+                                assignment.job_id,
+                                assignment.batch_id,
+                                assignment.worker_id,
+                                assignment.worker_task_id,
+                                resp
+                            );
+                            control.dedup_expire_unix_ms()
+                        }
                     }
                 }
-                }
                 Err(TransferWorkerExecutionError::Stop(reason)) => {
                     control.close_all_streams();
                     if let Err(resp) =
@@ -4054,10 +4069,13 @@ fn run_transfer_worker_background_task(
                     if let Err(cleanup_resp) =
                         cleanup_transfer_worker_attempt_artifacts(&dst_root, &assignment)
                     {
-                        log_transfer_worker_cleanup_failure("after_fatal", &assignment, &cleanup_resp);
+                        log_transfer_worker_cleanup_failure(
+                            "after_fatal",
+                            &assignment,
+                            &cleanup_resp,
+                        );
                     }
-                    if let Some((fatal_kind, fatal_message)) =
-                        classify_transfer_worker_fatal(&resp)
+                    if let Some((fatal_kind, fatal_message)) = classify_transfer_worker_fatal(&resp)
                     {
                         match report_transfer_worker_fatal_once(
                             control.api.as_ref(),
@@ -4107,15 +4125,25 @@ fn run_transfer_worker_background_task(
             }
         }
         Err(TransferWorkerExecutionError::Stop(reason)) => {
-            let dst_export_root = exports.export_root_dir_abs(assignment.dst_export.as_str()).ok();
+            let dst_export_root = exports
+                .export_root_dir_abs(assignment.dst_export.as_str())
+                .ok();
             let dst_root = dst_export_root.and_then(|dst_export_root| {
-                safe_join_root(dst_export_root.as_str(), assignment.dst_root_relpath.as_str())
-                    .ok()
-                    .map(PathBuf::from)
+                safe_join_root(
+                    dst_export_root.as_str(),
+                    assignment.dst_root_relpath.as_str(),
+                )
+                .ok()
+                .map(PathBuf::from)
             });
             if let Some(dst_root) = dst_root {
-                if let Err(resp) = cleanup_transfer_worker_attempt_artifacts(&dst_root, &assignment) {
-                    log_transfer_worker_cleanup_failure("before_execution_stop", &assignment, &resp);
+                if let Err(resp) = cleanup_transfer_worker_attempt_artifacts(&dst_root, &assignment)
+                {
+                    log_transfer_worker_cleanup_failure(
+                        "before_execution_stop",
+                        &assignment,
+                        &resp,
+                    );
                 }
             }
             tracing::info!(
@@ -4129,11 +4157,16 @@ fn run_transfer_worker_background_task(
             control.dedup_expire_unix_ms()
         }
         Err(TransferWorkerExecutionError::Fatal(resp)) => {
-            let dst_export_root = exports.export_root_dir_abs(assignment.dst_export.as_str()).ok();
+            let dst_export_root = exports
+                .export_root_dir_abs(assignment.dst_export.as_str())
+                .ok();
             let dst_root = dst_export_root.and_then(|dst_export_root| {
-                safe_join_root(dst_export_root.as_str(), assignment.dst_root_relpath.as_str())
-                    .ok()
-                    .map(PathBuf::from)
+                safe_join_root(
+                    dst_export_root.as_str(),
+                    assignment.dst_root_relpath.as_str(),
+                )
+                .ok()
+                .map(PathBuf::from)
             });
             if let Some(dst_root) = dst_root {
                 if let Err(cleanup_resp) =
@@ -4509,7 +4542,9 @@ fn plan_transfer_subtree_batches(
             total_bytes: 0,
             root_is_empty: true,
             mergeable_empty_dir_count: 1,
-            mergeable_empty_dir_estimated_bytes: estimate_empty_dir_manifest_entry_bytes(root_relpath),
+            mergeable_empty_dir_estimated_bytes: estimate_empty_dir_manifest_entry_bytes(
+                root_relpath,
+            ),
             direct_files_only_batches: Vec::new(),
             full_dir_batches: Vec::new(),
             child_scan_units: Vec::new(),
@@ -4540,8 +4575,7 @@ fn plan_transfer_subtree_batches(
                 let child_empty_dir_count = child_plan.mergeable_empty_dir_count;
                 let child_empty_dir_estimated_bytes =
                     child_plan.mergeable_empty_dir_estimated_bytes;
-                if mergeable_empty_dir_count
-                    .saturating_add(child_empty_dir_count)
+                if mergeable_empty_dir_count.saturating_add(child_empty_dir_count)
                     > TRANSFER_MERGEABLE_EMPTY_DIR_BUDGET
                     || mergeable_empty_dir_estimated_bytes
                         .saturating_add(child_empty_dir_estimated_bytes)
@@ -4716,7 +4750,11 @@ fn build_root_direct_files_only_batch_from_entries(
 }
 
 fn sort_transfer_scan_batches(batches: &mut [FluxonFsTransferScanBatchWire]) {
-    batches.sort_by(|a, b| a.root_relpath.cmp(&b.root_relpath).then(a.batch_id.cmp(&b.batch_id)));
+    batches.sort_by(|a, b| {
+        a.root_relpath
+            .cmp(&b.root_relpath)
+            .then(a.batch_id.cmp(&b.batch_id))
+    });
 }
 
 fn build_full_dir_batch_for_mergeable_subtree(
@@ -4750,14 +4788,12 @@ fn build_transfer_scan_result_for_subtree_streaming_root_dir_abs(
     root_dir_abs: &str,
     assignment: &FluxonFsTransferScanAssignmentWire,
 ) -> Result<FluxonFsTransferScanResultWire, FlatDict> {
-    let Some(mut session) = take_transfer_subtree_streaming_session(root_dir_abs, assignment)? else {
+    let Some(mut session) = take_transfer_subtree_streaming_session(root_dir_abs, assignment)?
+    else {
         return Ok(build_finished_empty_subtree_stream_result(assignment));
     };
     loop {
-        if session
-            .dir_stack
-            .is_empty()
-        {
+        if session.dir_stack.is_empty() {
             let mut full_dir_batches = Vec::new();
             if let Some(batch) = flush_pending_subtree_stream_batch(assignment, &mut session)? {
                 full_dir_batches.push(batch);
@@ -4776,7 +4812,9 @@ fn build_transfer_scan_result_for_subtree_streaming_root_dir_abs(
                 finished: true,
             });
         }
-        if TransferScanDeadline::from_assignment(assignment).is_some_and(|deadline| deadline.reached()) {
+        if TransferScanDeadline::from_assignment(assignment)
+            .is_some_and(|deadline| deadline.reached())
+        {
             let mut full_dir_batches = Vec::new();
             if let Some(batch) = flush_pending_subtree_stream_batch(assignment, &mut session)? {
                 full_dir_batches.push(batch);
@@ -4808,7 +4846,10 @@ fn build_transfer_scan_result_for_subtree_streaming_root_dir_abs(
             if should_flush_subtree_stream_batch(
                 assignment.batch_ready_bytes,
                 session.pending_bytes,
-                session.pending_files.len().saturating_add(session.pending_symlink_notices.len()),
+                session
+                    .pending_files
+                    .len()
+                    .saturating_add(session.pending_symlink_notices.len()),
                 session.pending_empty_dirs.len(),
             ) {
                 let batch = flush_pending_subtree_stream_batch(assignment, &mut session)?.unwrap();
@@ -4865,22 +4906,30 @@ fn build_transfer_scan_result_for_subtree_streaming_root_dir_abs(
                 });
         } else if md.is_dir() {
             frame.saw_visible_child = true;
-            session.dir_stack.push(open_transfer_subtree_streaming_dir_frame(
-                child_path,
-                child_relpath,
-            )?);
+            session
+                .dir_stack
+                .push(open_transfer_subtree_streaming_dir_frame(
+                    child_path,
+                    child_relpath,
+                )?);
         } else if md.is_file() {
             frame.saw_visible_child = true;
             let size = md.len().min(i64::MAX as u64) as i64;
             session.pending_bytes = session.pending_bytes.saturating_add(size);
             session
                 .pending_files
-                .push(FluxonFsTransferScanFrontierEntry { relpath: child_relpath, size });
+                .push(FluxonFsTransferScanFrontierEntry {
+                    relpath: child_relpath,
+                    size,
+                });
         }
         if should_flush_subtree_stream_batch(
             assignment.batch_ready_bytes,
             session.pending_bytes,
-            session.pending_files.len().saturating_add(session.pending_symlink_notices.len()),
+            session
+                .pending_files
+                .len()
+                .saturating_add(session.pending_symlink_notices.len()),
             session.pending_empty_dirs.len(),
         ) {
             let batch = flush_pending_subtree_stream_batch(assignment, &mut session)?.unwrap();
@@ -4928,11 +4977,12 @@ pub(crate) fn build_transfer_scan_result_for_root_dir_abs(
         );
     }
     let deadline = TransferScanDeadline::from_assignment(assignment);
-    let root_listing = match collect_transfer_root_dir_listing_slice(root_dir_abs, assignment, deadline)? {
-        TransferRootDirListingOutcome::Complete(v) => v,
-        TransferRootDirListingOutcome::Finished(result) => return Ok(result),
-        TransferRootDirListingOutcome::Partial(result) => return Ok(result),
-    };
+    let root_listing =
+        match collect_transfer_root_dir_listing_slice(root_dir_abs, assignment, deadline)? {
+            TransferRootDirListingOutcome::Complete(v) => v,
+            TransferRootDirListingOutcome::Finished(result) => return Ok(result),
+            TransferRootDirListingOutcome::Partial(result) => return Ok(result),
+        };
     let mut direct_files = root_listing.direct_files;
     let mut direct_symlink_notices = root_listing.direct_symlink_notices;
     let mut direct_empty_dirs = root_listing.direct_empty_dirs;
@@ -4976,7 +5026,10 @@ pub(crate) fn build_transfer_scan_result_for_root_dir_abs(
         if (!direct_files.is_empty()
             || !direct_symlink_notices.is_empty()
             || !direct_empty_dirs.is_empty())
-            && !direct_files_only_disposition_covers_root(assignment, assignment.root_relpath.as_str())
+            && !direct_files_only_disposition_covers_root(
+                assignment,
+                assignment.root_relpath.as_str(),
+            )
         {
             let mut next_partition_index = root_listing.emitted_direct_files_batch_count;
             direct_files_only_batches.extend(build_partitioned_root_direct_files_only_batches(
@@ -4987,17 +5040,15 @@ pub(crate) fn build_transfer_scan_result_for_root_dir_abs(
                 direct_empty_dirs.clone(),
             )?);
         }
-        child_scan_units.extend(
-            direct_dirs[delegated_child_scan_unit_count..]
-                .iter()
-                .map(|entry| {
-                    new_child_scan_unit(
-                        entry.relpath.clone(),
-                        assignment.generation + 1,
-                        delegated_child_scan_mode(),
-                    )
-                }),
-        );
+        child_scan_units.extend(direct_dirs[delegated_child_scan_unit_count..].iter().map(
+            |entry| {
+                new_child_scan_unit(
+                    entry.relpath.clone(),
+                    assignment.generation + 1,
+                    delegated_child_scan_mode(),
+                )
+            },
+        ));
         child_scan_units.sort_by(|a, b| a.root_relpath.cmp(&b.root_relpath));
         sort_transfer_scan_batches(&mut direct_files_only_batches);
         return Ok(FluxonFsTransferScanResultWire {
@@ -5027,7 +5078,8 @@ pub(crate) fn build_transfer_scan_result_for_root_dir_abs(
     let mut root_partitioned = root_listing.emitted_direct_files_batch_count > 0
         || direct_files_only_disposition_covers_root(assignment, assignment.root_relpath.as_str());
     let mut mergeable_empty_dir_count = direct_empty_dirs.len();
-    let mut mergeable_empty_dir_estimated_bytes = estimate_empty_dir_manifest_bytes(&direct_empty_dirs);
+    let mut mergeable_empty_dir_estimated_bytes =
+        estimate_empty_dir_manifest_bytes(&direct_empty_dirs);
     for child_relpath in direct_dirs.iter().map(|entry| entry.relpath.clone()) {
         let child_plan = plan_transfer_subtree_batches(
             root_dir_abs,
@@ -5043,8 +5095,7 @@ pub(crate) fn build_transfer_scan_result_for_root_dir_abs(
                 let child_empty_dir_count = child_plan.mergeable_empty_dir_count;
                 let child_empty_dir_estimated_bytes =
                     child_plan.mergeable_empty_dir_estimated_bytes;
-                if mergeable_empty_dir_count
-                    .saturating_add(child_empty_dir_count)
+                if mergeable_empty_dir_count.saturating_add(child_empty_dir_count)
                     > TRANSFER_MERGEABLE_EMPTY_DIR_BUDGET
                     || mergeable_empty_dir_estimated_bytes
                         .saturating_add(child_empty_dir_estimated_bytes)
@@ -5083,7 +5134,10 @@ pub(crate) fn build_transfer_scan_result_for_root_dir_abs(
         if (!direct_files.is_empty()
             || !direct_symlink_notices.is_empty()
             || !mergeable_empty_child_relpaths.is_empty())
-            && !direct_files_only_disposition_covers_root(assignment, assignment.root_relpath.as_str())
+            && !direct_files_only_disposition_covers_root(
+                assignment,
+                assignment.root_relpath.as_str(),
+            )
         {
             let mut next_partition_index = root_listing.emitted_direct_files_batch_count;
             direct_empty_dirs.extend(mergeable_empty_child_relpaths);
@@ -5212,10 +5266,11 @@ fn handle_transfer_scan_assignment(
         assignment.generation,
         assignment.known_dispositions.len(),
     );
-    let result = match build_transfer_scan_result_for_root_dir_abs(root_dir_abs.as_str(), &assignment) {
-        Ok(v) => v,
-        Err(resp) => return resp,
-    };
+    let result =
+        match build_transfer_scan_result_for_root_dir_abs(root_dir_abs.as_str(), &assignment) {
+            Ok(v) => v,
+            Err(resp) => return resp,
+        };
     encode_transfer_scan_result(&result, "transfer scan result")
 }
 
@@ -5228,8 +5283,11 @@ fn prepare_transfer_file_streaming<ReadChunkFn, CheckpointFn>(
     coordinator: &TransferWorkerCoordinator<ReadChunkFn, CheckpointFn>,
 ) -> Result<PreparedTransferFile, TransferWorkerExecutionError>
 where
-    ReadChunkFn:
-        Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>,
+    ReadChunkFn: Fn(
+        &FluxonFsTransferManifestEntryWire,
+        i64,
+        i64,
+    ) -> Result<Vec<u8>, TransferWorkerExecutionError>,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError>,
 {
     let staging_relpath = transfer_staging_file_relpath(staging_prefix, file.relpath.as_str())
@@ -5239,9 +5297,12 @@ where
         .map_err(TransferWorkerExecutionError::fatal)?;
     ensure_transfer_parent_dirs(dst_root, final_relpath.as_str())
         .map_err(TransferWorkerExecutionError::fatal)?;
-    let staging_abs = safe_join_root(dst_root.to_string_lossy().as_ref(), staging_relpath.as_str())
-        .map_err(resp_err_kverr)
-        .map_err(TransferWorkerExecutionError::fatal)?;
+    let staging_abs = safe_join_root(
+        dst_root.to_string_lossy().as_ref(),
+        staging_relpath.as_str(),
+    )
+    .map_err(resp_err_kverr)
+    .map_err(TransferWorkerExecutionError::fatal)?;
     let mut dst_file = open_create_file_with_parent_dir_chmod_retry(&staging_abs)
         .map_err(TransferWorkerExecutionError::fatal)?;
     dst_file
@@ -5254,14 +5315,14 @@ where
         let remaining = file.size.saturating_sub(copied);
         let chunk = coordinator.read_chunk(file, copied, remaining.min(CHUNK_BYTES as i64))?;
         if chunk.is_empty() {
-            return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(KvError::Api(
-                ApiError::InvalidArgument {
+            return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(
+                KvError::Api(ApiError::InvalidArgument {
                     detail: format!(
                         "transfer worker source ended before expected size: relpath={} expected={} copied={}",
                         file.relpath, file.size, copied
                     ),
-                },
-            ))));
+                }),
+            )));
         }
         dst_file
             .write_all(&chunk)
@@ -5271,13 +5332,14 @@ where
         coordinator.record_written_bytes(chunk.len() as i64);
     }
     if copied != file.size {
-        return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(KvError::Api(
-            ApiError::InvalidArgument {
-            detail: format!(
-                "transfer worker size mismatch before staging completion: relpath={} expected={} actual={}",
-                file.relpath, file.size, copied
-            ),
-        }))));
+        return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(
+            KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "transfer worker size mismatch before staging completion: relpath={} expected={} actual={}",
+                    file.relpath, file.size, copied
+                ),
+            }),
+        )));
     }
     // The staged file is still invisible at this point, so one more checkpoint
     // keeps supersession able to stop the worker before any later visible
@@ -5302,48 +5364,57 @@ fn execute_transfer_single_file<ReadChunkFn, CheckpointFn>(
     coordinator: &TransferWorkerCoordinator<ReadChunkFn, CheckpointFn>,
 ) -> Result<TransferWorkerLaneOutcome, TransferWorkerExecutionError>
 where
-    ReadChunkFn:
-        Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>,
+    ReadChunkFn: Fn(
+        &FluxonFsTransferManifestEntryWire,
+        i64,
+        i64,
+    ) -> Result<Vec<u8>, TransferWorkerExecutionError>,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError>,
 {
     coordinator.checkpoint_continue()?;
-    let prepared = match prepare_transfer_file_streaming(dst_root, staging_prefix, file, coordinator) {
-        Ok(v) => v,
-        Err(TransferWorkerExecutionError::Fatal(resp)) => {
-            if let Some(failed) = classify_transfer_failed_file(file, &resp) {
-                let staging_relpath =
-                    transfer_staging_file_relpath(staging_prefix, file.relpath.as_str())
-                        .map_err(TransferWorkerExecutionError::fatal)?;
-                let staging_abs = safe_join_root(
-                    dst_root.to_string_lossy().as_ref(),
-                    staging_relpath.as_str(),
-                )
-                .map_err(resp_err_kverr)
-                .map_err(TransferWorkerExecutionError::fatal)?;
-                match fs::remove_file(&staging_abs) {
-                    Ok(()) => {}
-                    Err(err) if err.kind() == ErrorKind::NotFound => {}
-                    Err(err) => return Err(TransferWorkerExecutionError::fatal(resp_err_io(err))),
+    let prepared =
+        match prepare_transfer_file_streaming(dst_root, staging_prefix, file, coordinator) {
+            Ok(v) => v,
+            Err(TransferWorkerExecutionError::Fatal(resp)) => {
+                if let Some(failed) = classify_transfer_failed_file(file, &resp) {
+                    let staging_relpath =
+                        transfer_staging_file_relpath(staging_prefix, file.relpath.as_str())
+                            .map_err(TransferWorkerExecutionError::fatal)?;
+                    let staging_abs = safe_join_root(
+                        dst_root.to_string_lossy().as_ref(),
+                        staging_relpath.as_str(),
+                    )
+                    .map_err(resp_err_kverr)
+                    .map_err(TransferWorkerExecutionError::fatal)?;
+                    match fs::remove_file(&staging_abs) {
+                        Ok(()) => {}
+                        Err(err) if err.kind() == ErrorKind::NotFound => {}
+                        Err(err) => {
+                            return Err(TransferWorkerExecutionError::fatal(resp_err_io(err)));
+                        }
+                    }
+                    return Ok(TransferWorkerLaneOutcome::Failed(
+                        TransferWorkerLaneFailedFileResult { result: failed },
+                    ));
                 }
-                return Ok(TransferWorkerLaneOutcome::Failed(
-                    TransferWorkerLaneFailedFileResult { result: failed },
-                ));
+                return Err(TransferWorkerExecutionError::Fatal(resp));
             }
-            return Err(TransferWorkerExecutionError::Fatal(resp));
-        }
-        Err(err) => return Err(err),
-    };
+            Err(err) => return Err(err),
+        };
     coordinator.checkpoint_continue()?;
-    let result = promote_prepared_transfer_file(dst_root, PreparedTransferFile {
-        staging_relpath: prepared.staging_relpath.clone(),
-        final_relpath: prepared.final_relpath.clone(),
-        visible_size: prepared.visible_size,
-    })
+    let result = promote_prepared_transfer_file(
+        dst_root,
+        PreparedTransferFile {
+            staging_relpath: prepared.staging_relpath.clone(),
+            final_relpath: prepared.final_relpath.clone(),
+            visible_size: prepared.visible_size,
+        },
+    )
     .map_err(TransferWorkerExecutionError::fatal);
     match result {
-        Ok(result) => Ok(TransferWorkerLaneOutcome::Visible(TransferWorkerLaneFileResult {
-            result,
-        })),
+        Ok(result) => Ok(TransferWorkerLaneOutcome::Visible(
+            TransferWorkerLaneFileResult { result },
+        )),
         Err(TransferWorkerExecutionError::Fatal(resp)) => {
             if let Some(failed) = classify_transfer_failed_file(file, &resp) {
                 let staging_abs = safe_join_root(
@@ -5374,8 +5445,11 @@ fn execute_transfer_empty_dir<ReadChunkFn, CheckpointFn>(
     coordinator: &TransferWorkerCoordinator<ReadChunkFn, CheckpointFn>,
 ) -> Result<TransferWorkerLaneOutcome, TransferWorkerExecutionError>
 where
-    ReadChunkFn:
-        Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>,
+    ReadChunkFn: Fn(
+        &FluxonFsTransferManifestEntryWire,
+        i64,
+        i64,
+    ) -> Result<Vec<u8>, TransferWorkerExecutionError>,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError>,
 {
     coordinator.checkpoint_continue()?;
@@ -5393,11 +5467,14 @@ fn execute_transfer_worker_assignment_with_policy<ReadChunkFn, CheckpointFn>(
     read_chunk: ReadChunkFn,
 ) -> Result<FluxonFsTransferWorkerResultWire, TransferWorkerExecutionError>
 where
-    ReadChunkFn:
-        Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>
-            + Send
-            + Sync
-            + 'static,
+    ReadChunkFn: Fn(
+            &FluxonFsTransferManifestEntryWire,
+            i64,
+            i64,
+        ) -> Result<Vec<u8>, TransferWorkerExecutionError>
+        + Send
+        + Sync
+        + 'static,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError> + Send + Sync + 'static,
 {
     let policy = policy.normalized();
@@ -5424,11 +5501,14 @@ fn execute_transfer_worker_assignment_with_policy_and_progress<ReadChunkFn, Chec
     read_chunk: ReadChunkFn,
 ) -> Result<FluxonFsTransferWorkerResultWire, TransferWorkerExecutionError>
 where
-    ReadChunkFn:
-        Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>
-            + Send
-            + Sync
-            + 'static,
+    ReadChunkFn: Fn(
+            &FluxonFsTransferManifestEntryWire,
+            i64,
+            i64,
+        ) -> Result<Vec<u8>, TransferWorkerExecutionError>
+        + Send
+        + Sync
+        + 'static,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError> + Send + Sync + 'static,
 {
     create_dir_all_with_parent_dir_chmod_retry(dst_root)
@@ -5436,9 +5516,11 @@ where
     let manifest =
         FluxonFsTransferManifestWire::decode_from_blob(assignment.manifest_blob.as_slice())
             .map_err(|e| {
-                TransferWorkerExecutionError::fatal(resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
-                    detail: format!("decode transfer worker manifest failed: {}", e),
-                })))
+                TransferWorkerExecutionError::fatal(resp_err_kverr(KvError::Api(
+                    ApiError::InvalidArgument {
+                        detail: format!("decode transfer worker manifest failed: {}", e),
+                    },
+                )))
             })?;
     if transfer_manifest_is_empty_dirs_only_batch(&manifest, assignment.collect_infos.as_slice()) {
         // Empty-dir-only batches never generate byte-based ramp-up signals, so
@@ -5664,10 +5746,16 @@ fn promote_prepared_transfer_file(
     dst_root: &PathBuf,
     file: PreparedTransferFile,
 ) -> Result<FluxonFsTransferWorkerFileResultWire, FlatDict> {
-    let staging_abs = safe_join_root(dst_root.to_string_lossy().as_ref(), file.staging_relpath.as_str())
-        .map_err(resp_err_kverr)?;
-    let final_abs = safe_join_root(dst_root.to_string_lossy().as_ref(), file.final_relpath.as_str())
-        .map_err(resp_err_kverr)?;
+    let staging_abs = safe_join_root(
+        dst_root.to_string_lossy().as_ref(),
+        file.staging_relpath.as_str(),
+    )
+    .map_err(resp_err_kverr)?;
+    let final_abs = safe_join_root(
+        dst_root.to_string_lossy().as_ref(),
+        file.final_relpath.as_str(),
+    )
+    .map_err(resp_err_kverr)?;
     rename_with_dst_parent_dir_chmod_retry(&staging_abs, &final_abs)?;
     Ok(FluxonFsTransferWorkerFileResultWire {
         relpath: file.final_relpath.clone(),
@@ -5694,15 +5782,15 @@ fn prepare_transfer_collect_info_materialization(
                 ),
             }))
         })?;
-    let staging_relpath = transfer_collect_info_staging_relpath(
-        batch_id,
-        worker_task_id,
-        collect_info.collect_kind,
-    )?;
+    let staging_relpath =
+        transfer_collect_info_staging_relpath(batch_id, worker_task_id, collect_info.collect_kind)?;
     ensure_transfer_parent_dirs(dst_root, staging_relpath.as_str())?;
     ensure_transfer_parent_dirs(dst_root, output_relpath.as_str())?;
-    let staging_abs = safe_join_root(dst_root.to_string_lossy().as_ref(), staging_relpath.as_str())
-        .map_err(resp_err_kverr)?;
+    let staging_abs = safe_join_root(
+        dst_root.to_string_lossy().as_ref(),
+        staging_relpath.as_str(),
+    )
+    .map_err(resp_err_kverr)?;
     let mut dst_file = open_create_file_with_parent_dir_chmod_retry(&staging_abs)?;
     dst_file.set_len(0).map_err(resp_err_io)?;
     dst_file
@@ -5723,14 +5811,15 @@ fn transfer_collect_info_staging_relpath(
     worker_task_id: &str,
     collect_kind: FluxonFsTransferCollectInfoKind,
 ) -> Result<String, FlatDict> {
-    let output_relpath = transfer_collect_info_output_relpath(batch_id, collect_kind).map_err(|detail| {
-        resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
-            detail: format!(
-                "build transfer collect info output relpath failed: batch_id={} err={}",
-                batch_id, detail
-            ),
-        }))
-    })?;
+    let output_relpath =
+        transfer_collect_info_output_relpath(batch_id, collect_kind).map_err(|detail| {
+            resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "build transfer collect info output relpath failed: batch_id={} err={}",
+                    batch_id, detail
+                ),
+            }))
+        })?;
     Ok(format!("{}.{}.fluxon.part", output_relpath, worker_task_id))
 }
 
@@ -5750,9 +5839,12 @@ fn prune_empty_parent_dirs(mut current: PathBuf, root: &PathBuf) -> Result<(), F
     Ok(())
 }
 
-fn cleanup_attempt_staging_prefix(dst_root: &PathBuf, staging_prefix: &str) -> Result<(), FlatDict> {
-    let staging_abs =
-        safe_join_root(dst_root.to_string_lossy().as_ref(), staging_prefix).map_err(resp_err_kverr)?;
+fn cleanup_attempt_staging_prefix(
+    dst_root: &PathBuf,
+    staging_prefix: &str,
+) -> Result<(), FlatDict> {
+    let staging_abs = safe_join_root(dst_root.to_string_lossy().as_ref(), staging_prefix)
+        .map_err(resp_err_kverr)?;
     match fs::remove_dir_all(&staging_abs) {
         Ok(()) => {}
         Err(err) if err.kind() == ErrorKind::NotFound => return Ok(()),
@@ -5865,7 +5957,8 @@ pub(crate) fn read_transfer_chunk_from_root_dir_abs(
         return Ok(Vec::new());
     }
     let to_read = std::cmp::min(length, size - offset) as usize;
-    f.seek(SeekFrom::Start(offset as u64)).map_err(resp_err_io)?;
+    f.seek(SeekFrom::Start(offset as u64))
+        .map_err(resp_err_io)?;
     let mut buf = vec![0u8; to_read];
     f.read_exact(&mut buf).map_err(resp_err_io)?;
     Ok(buf)
@@ -5881,11 +5974,14 @@ pub(crate) fn execute_transfer_worker_assignment<ReadChunkFn, CheckpointFn>(
     read_chunk: ReadChunkFn,
 ) -> Result<FluxonFsTransferWorkerResultWire, TransferWorkerExecutionError>
 where
-    ReadChunkFn:
-        Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>
-            + Send
-            + Sync
-            + 'static,
+    ReadChunkFn: Fn(
+            &FluxonFsTransferManifestEntryWire,
+            i64,
+            i64,
+        ) -> Result<Vec<u8>, TransferWorkerExecutionError>
+        + Send
+        + Sync
+        + 'static,
     CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError> + Send + Sync + 'static,
 {
     execute_transfer_worker_assignment_with_policy(
@@ -5943,12 +6039,19 @@ pub(super) fn handle_transfer_read(exports: &AgentExportsHandle, payload: FlatDi
         Ok(v) => v,
         Err(e) => return resp_err_kverr(e),
     };
-    let buf =
-        match read_transfer_chunk_from_root_dir_abs(root_dir_abs.as_str(), relpath.as_str(), offset, length) {
-            Ok(v) => v,
-            Err(resp) => return resp,
-        };
-    resp_ok(BTreeMap::from([("data".to_string(), FlatValue::Bytes(buf))]))
+    let buf = match read_transfer_chunk_from_root_dir_abs(
+        root_dir_abs.as_str(),
+        relpath.as_str(),
+        offset,
+        length,
+    ) {
+        Ok(v) => v,
+        Err(resp) => return resp,
+    };
+    resp_ok(BTreeMap::from([(
+        "data".to_string(),
+        FlatValue::Bytes(buf),
+    )]))
 }
 
 pub(super) fn handle_transfer_stream_open(
@@ -6010,7 +6113,9 @@ pub(super) fn handle_transfer_worker(
         Err(resp) => return resp,
     };
     match registry.launch_task(api, master_id, exports, assignment) {
-        Ok(result) => encode_transfer_worker_launch_result(&result, "transfer worker launch result"),
+        Ok(result) => {
+            encode_transfer_worker_launch_result(&result, "transfer worker launch result")
+        }
         Err(resp) => resp,
     }
 }
@@ -6086,15 +6191,15 @@ mod tests {
             .collect()
     }
 
-    fn assert_all_child_scan_units_are_subtree_streaming(
-        result: &FluxonFsTransferScanResultWire,
-    ) {
-        assert!(result
-            .child_scan_units
-            .iter()
-            .all(|child| child.scan_mode == FluxonFsTransferScanMode::SubtreeStreaming));
-    }
-
+    fn assert_all_child_scan_units_are_subtree_streaming(result: &FluxonFsTransferScanResultWire) {
+        assert!(
+            result
+                .child_scan_units
+                .iter()
+                .all(|child| child.scan_mode == FluxonFsTransferScanMode::SubtreeStreaming)
+        );
+    }
+
     fn ok_bool(resp: &FlatDict) -> bool {
         matches!(resp.get("ok"), Some(FlatValue::Bool(true)))
     }
@@ -6106,10 +6211,7 @@ mod tests {
                 panic!("unexpected open result fatal decode error: {:?}", other)
             }
             Err(TransferWorkerRpcFailure::Retryable { detail }) => {
-                panic!(
-                    "unexpected open result retryable decode error: {}",
-                    detail
-                )
+                panic!("unexpected open result retryable decode error: {}", detail)
             }
         }
     }
@@ -6121,10 +6223,7 @@ mod tests {
                 panic!("unexpected next result fatal decode error: {:?}", other)
             }
             Err(TransferWorkerRpcFailure::Retryable { detail }) => {
-                panic!(
-                    "unexpected next result retryable decode error: {}",
-                    detail
-                )
+                panic!("unexpected next result retryable decode error: {}", detail)
             }
         }
     }
@@ -6140,10 +6239,7 @@ mod tests {
             .collect()
     }
 
-    fn test_worker_assignment(
-        relpath: &str,
-        size: i64,
-    ) -> FluxonFsTransferWorkerAssignmentWire {
+    fn test_worker_assignment(relpath: &str, size: i64) -> FluxonFsTransferWorkerAssignmentWire {
         FluxonFsTransferWorkerAssignmentWire {
             job_id: "job".to_string(),
             batch_id: "batch".to_string(),
@@ -6158,12 +6254,13 @@ mod tests {
             root_relpath: ".".to_string(),
             staging_prefix: ".fluxon.stage/job/batch".to_string(),
             lease_expire_unix_ms: 0,
-            manifest_blob: build_transfer_manifest_blob(vec![
-                FluxonFsTransferScanFrontierEntry {
+            manifest_blob: build_transfer_manifest_blob(
+                vec![FluxonFsTransferScanFrontierEntry {
                     relpath: relpath.to_string(),
                     size,
-                },
-            ], Vec::new())
+                }],
+                Vec::new(),
+            )
             .unwrap(),
             collect_infos: Vec::new(),
         }
@@ -6183,7 +6280,11 @@ mod tests {
         read_chunk: ReadChunkFn,
     ) -> TransferWorkerCoordinator<ReadChunkFn, CheckpointFn>
     where
-        ReadChunkFn: Fn(&FluxonFsTransferManifestEntryWire, i64, i64) -> Result<Vec<u8>, TransferWorkerExecutionError>,
+        ReadChunkFn: Fn(
+            &FluxonFsTransferManifestEntryWire,
+            i64,
+            i64,
+        ) -> Result<Vec<u8>, TransferWorkerExecutionError>,
         CheckpointFn: Fn() -> Result<(), TransferWorkerExecutionError>,
     {
         let policy = Arc::new(TransferWorkerLanePolicy::production_default());
@@ -6217,16 +6318,19 @@ mod tests {
 
     #[test]
     fn build_transfer_manifest_blob_round_trips_entries() {
-        let blob = build_transfer_manifest_blob(vec![
-            FluxonFsTransferScanFrontierEntry {
-                relpath: "a".to_string(),
-                size: 1,
-            },
-            FluxonFsTransferScanFrontierEntry {
-                relpath: "b/c".to_string(),
-                size: 2,
-            },
-        ], vec!["empty".to_string()])
+        let blob = build_transfer_manifest_blob(
+            vec![
+                FluxonFsTransferScanFrontierEntry {
+                    relpath: "a".to_string(),
+                    size: 1,
+                },
+                FluxonFsTransferScanFrontierEntry {
+                    relpath: "b/c".to_string(),
+                    size: 2,
+                },
+            ],
+            vec!["empty".to_string()],
+        )
         .unwrap();
         let manifest = FluxonFsTransferManifestWire::decode_from_blob(&blob).unwrap();
         assert_eq!(manifest.entry_count, 2);
@@ -6250,11 +6354,12 @@ mod tests {
     #[test]
     fn materialize_transfer_collect_info_writes_task_scoped_staging_then_output_file() {
         let root = TempDir::new().unwrap();
-        let collect_infos = build_symlink_collect_infos(vec![FluxonFsTransferSymlinkNoticeEntryWire {
-            relpath: "root/link-file.bin".to_string(),
-            link_target: "target/file.bin".to_string(),
-        }])
-        .unwrap();
+        let collect_infos =
+            build_symlink_collect_infos(vec![FluxonFsTransferSymlinkNoticeEntryWire {
+                relpath: "root/link-file.bin".to_string(),
+                link_target: "target/file.bin".to_string(),
+            }])
+            .unwrap();
         let prepared = prepare_transfer_collect_info_materialization(
             &root.path().to_path_buf(),
             "batch-1",
@@ -6383,7 +6488,10 @@ mod tests {
             &exports,
             FlatDict::from([
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("offset".to_string(), FlatValue::Int64(2)),
                 ("length".to_string(), FlatValue::Int64(3)),
             ]),
@@ -6398,7 +6506,10 @@ mod tests {
             &exports,
             FlatDict::from([
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("offset".to_string(), FlatValue::Int64(6)),
                 ("length".to_string(), FlatValue::Int64(1)),
             ]),
@@ -6423,7 +6534,10 @@ mod tests {
             &exports,
             FlatDict::from([
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("offset".to_string(), FlatValue::Int64(1)),
                 ("length".to_string(), FlatValue::Int64(3)),
             ]),
@@ -6446,9 +6560,15 @@ mod tests {
             &exports,
             FlatDict::from([
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("offset".to_string(), FlatValue::Int64(0)),
-                ("length".to_string(), FlatValue::Int64(CHUNK_BYTES as i64 + 1)),
+                (
+                    "length".to_string(),
+                    FlatValue::Int64(CHUNK_BYTES as i64 + 1),
+                ),
             ]),
         );
         assert!(matches!(resp.get("ok"), Some(FlatValue::Bool(false))));
@@ -6470,7 +6590,10 @@ mod tests {
                     FlatValue::String("task-0".to_string()),
                 ),
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("initial_offset".to_string(), FlatValue::Int64(0)),
             ]),
         );
@@ -6551,7 +6674,10 @@ mod tests {
                     FlatValue::String("task-1".to_string()),
                 ),
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("initial_offset".to_string(), FlatValue::Int64(0)),
             ]),
         );
@@ -6584,7 +6710,10 @@ mod tests {
                 ("length".to_string(), FlatValue::Int64(2)),
             ]),
         );
-        assert!(matches!(invalid_resp.get("ok"), Some(FlatValue::Bool(false))));
+        assert!(matches!(
+            invalid_resp.get("ok"),
+            Some(FlatValue::Bool(false))
+        ));
     }
 
     #[test]
@@ -6603,7 +6732,10 @@ mod tests {
                     FlatValue::String("task-2".to_string()),
                 ),
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("initial_offset".to_string(), FlatValue::Int64(3)),
             ]),
         );
@@ -6647,7 +6779,10 @@ mod tests {
                     FlatValue::String("task-3".to_string()),
                 ),
                 ("export".to_string(), FlatValue::String("src".to_string())),
-                ("relpath".to_string(), FlatValue::String("f.bin".to_string())),
+                (
+                    "relpath".to_string(),
+                    FlatValue::String("f.bin".to_string()),
+                ),
                 ("initial_offset".to_string(), FlatValue::Int64(3)),
             ]),
         );
@@ -6718,7 +6853,10 @@ mod tests {
         let result = decode_result_json(&resp);
         assert!(result.finished);
         assert!(result.direct_files_only_batches.is_empty());
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/child".to_string()]);
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/child".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
@@ -6781,7 +6919,8 @@ mod tests {
     }
 
     #[test]
-    fn handle_transfer_scan_assignment_groups_empty_children_into_direct_batch_without_direct_files() {
+    fn handle_transfer_scan_assignment_groups_empty_children_into_direct_batch_without_direct_files()
+     {
         let root = TempDir::new().unwrap();
         write_file(&root, "root/big/data.bin", b"12345");
         fs::create_dir_all(root.path().join("root/empty-a")).unwrap();
@@ -6814,9 +6953,10 @@ mod tests {
         assert_eq!(child_scan_unit_roots(&result), vec!["root/big".to_string()]);
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
-        let direct_manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        let direct_manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert!(direct_manifest.entries.is_empty());
         assert_eq!(
             direct_manifest.empty_dir_relpaths,
@@ -6854,16 +6994,17 @@ mod tests {
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert_eq!(result.full_dir_batches.len(), 0);
         assert_eq!(result.child_scan_units.len(), 1);
-        assert_eq!(result.child_scan_units[0].root_relpath, "root/huge".to_string());
+        assert_eq!(
+            result.child_scan_units[0].root_relpath,
+            "root/huge".to_string()
+        );
         let manifest = FluxonFsTransferManifestWire::decode_from_blob(
             &result.direct_files_only_batches[0].manifest_blob,
         )
         .unwrap();
         assert!(manifest.entries.is_empty());
         assert!(!manifest.empty_dir_relpaths.is_empty());
-        assert!(
-            manifest.empty_dir_relpaths.len() <= TRANSFER_MERGEABLE_EMPTY_DIR_BUDGET
-        );
+        assert!(manifest.empty_dir_relpaths.len() <= TRANSFER_MERGEABLE_EMPTY_DIR_BUDGET);
         assert!(
             estimate_empty_dir_manifest_bytes(&manifest.empty_dir_relpaths)
                 <= TRANSFER_MERGEABLE_EMPTY_DIR_ESTIMATED_BYTES_BUDGET
@@ -6879,10 +7020,10 @@ mod tests {
             ))
             + 1;
         for idx in 0..child_count {
-            fs::create_dir_all(root.path().join(format!(
-                "root/branch-{idx:05}/{}",
-                "x".repeat(200)
-            )))
+            fs::create_dir_all(
+                root.path()
+                    .join(format!("root/branch-{idx:05}/{}", "x".repeat(200))),
+            )
             .unwrap();
         }
         let result = build_transfer_scan_result_for_root_dir_abs(
@@ -6908,10 +7049,12 @@ mod tests {
         assert!(!result.finished);
         assert!(result.direct_files_only_batches.is_empty());
         assert!(!result.child_scan_units.is_empty());
-        assert!(result
-            .child_scan_units
-            .iter()
-            .any(|child| child.scan_mode == FluxonFsTransferScanMode::FullTree));
+        assert!(
+            result
+                .child_scan_units
+                .iter()
+                .any(|child| child.scan_mode == FluxonFsTransferScanMode::FullTree)
+        );
         assert!(result.child_scan_units.iter().all(|child| {
             child.scan_mode == FluxonFsTransferScanMode::FullTree
                 || child.scan_mode == FluxonFsTransferScanMode::SubtreeStreaming
@@ -6963,10 +7106,16 @@ mod tests {
         assert!(!continue_locally);
         assert_eq!(next_event_seq_no, 9);
         assert_eq!(events.len(), 2);
-        assert_eq!(events[0].event_kind, FluxonFsTransferScanEventKindWire::Append);
+        assert_eq!(
+            events[0].event_kind,
+            FluxonFsTransferScanEventKindWire::Append
+        );
         assert_eq!(events[0].event_seq_no, 7);
         assert_eq!(events[0].full_dir_batches.len(), 1);
-        assert_eq!(events[1].event_kind, FluxonFsTransferScanEventKindWire::Finished);
+        assert_eq!(
+            events[1].event_kind,
+            FluxonFsTransferScanEventKindWire::Finished
+        );
         assert_eq!(events[1].event_seq_no, 8);
         assert!(events[1].direct_files_only_batches.is_empty());
         assert!(events[1].child_scan_units.is_empty());
@@ -6997,17 +7146,21 @@ mod tests {
             skip_entries: Vec::new(),
         };
 
-        let first = build_transfer_scan_result_for_root_dir_abs(
-            root.path().to_str().unwrap(),
-            &assignment,
-        )
-        .unwrap();
+        let first =
+            build_transfer_scan_result_for_root_dir_abs(root.path().to_str().unwrap(), &assignment)
+                .unwrap();
         assert!(!first.finished);
         assert!(!first.direct_files_only_batches.is_empty());
         assert!(first.full_dir_batches.is_empty());
         assert_eq!(first.child_scan_units.len(), 1);
-        assert_eq!(first.child_scan_units[0].scan_unit_id, assignment.scan_unit_id);
-        assert_eq!(first.child_scan_units[0].root_relpath, assignment.root_relpath);
+        assert_eq!(
+            first.child_scan_units[0].scan_unit_id,
+            assignment.scan_unit_id
+        );
+        assert_eq!(
+            first.child_scan_units[0].root_relpath,
+            assignment.root_relpath
+        );
         assert_eq!(first.child_scan_units[0].generation, assignment.generation);
         let first_entry_count = first
             .direct_files_only_batches
@@ -7019,7 +7172,10 @@ mod tests {
                     .len()
             })
             .sum::<usize>();
-        assert_eq!(first_entry_count, TRANSFER_SCAN_ROOT_LISTING_SLICE_ENTRY_LIMIT);
+        assert_eq!(
+            first_entry_count,
+            TRANSFER_SCAN_ROOT_LISTING_SLICE_ENTRY_LIMIT
+        );
 
         let second_assignment = FluxonFsTransferScanAssignmentWire {
             scan_task_id: "task-2".to_string(),
@@ -7086,7 +7242,8 @@ mod tests {
     }
 
     #[test]
-    fn build_transfer_scan_result_root_direct_fanout_only_emits_child_scan_units_without_recursing() {
+    fn build_transfer_scan_result_root_direct_fanout_only_emits_child_scan_units_without_recursing()
+    {
         let root = TempDir::new().unwrap();
         write_file(&root, "root/direct.bin", b"abc");
         write_file(&root, "root/child/payload.bin", b"xyz");
@@ -7114,14 +7271,18 @@ mod tests {
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert_eq!(result.child_scan_units.len(), 1);
         assert!(result.full_dir_batches.is_empty());
-        assert_eq!(result.child_scan_units[0].root_relpath, "root/child".to_string());
+        assert_eq!(
+            result.child_scan_units[0].root_relpath,
+            "root/child".to_string()
+        );
         assert_eq!(
             result.child_scan_units[0].scan_mode,
             FluxonFsTransferScanMode::FullTree
         );
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7133,7 +7294,8 @@ mod tests {
     }
 
     #[test]
-    fn build_transfer_scan_result_directory_direct_fanout_only_emits_child_scan_units_without_recursing() {
+    fn build_transfer_scan_result_directory_direct_fanout_only_emits_child_scan_units_without_recursing()
+     {
         let root = TempDir::new().unwrap();
         write_file(&root, "root/child/direct.bin", b"abc");
         write_file(&root, "root/child/grand/payload.bin", b"xyz");
@@ -7161,14 +7323,18 @@ mod tests {
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert_eq!(result.child_scan_units.len(), 1);
         assert!(result.full_dir_batches.is_empty());
-        assert_eq!(result.child_scan_units[0].root_relpath, "root/child/grand".to_string());
+        assert_eq!(
+            result.child_scan_units[0].root_relpath,
+            "root/child/grand".to_string()
+        );
         assert_eq!(
             result.child_scan_units[0].scan_mode,
             FluxonFsTransferScanMode::FullTree
         );
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7206,10 +7372,14 @@ mod tests {
         .unwrap();
         assert!(result.finished);
         assert_eq!(result.direct_files_only_batches.len(), 1);
-        assert_eq!(result.direct_files_only_batches[0].root_relpath, "root/child");
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        assert_eq!(
+            result.direct_files_only_batches[0].root_relpath,
+            "root/child"
+        );
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7218,7 +7388,10 @@ mod tests {
             }]
         );
         assert!(manifest.empty_dir_relpaths.is_empty());
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/child/grand".to_string()]);
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/child/grand".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
@@ -7253,10 +7426,14 @@ mod tests {
         assert!(result.finished);
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert_eq!(result.child_scan_units.len(), 1);
-        assert_eq!(result.child_scan_units[0].root_relpath, "root/child".to_string());
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        assert_eq!(
+            result.child_scan_units[0].root_relpath,
+            "root/child".to_string()
+        );
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7330,9 +7507,10 @@ mod tests {
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert!(result.child_scan_units.is_empty());
         assert!(result.full_dir_batches.is_empty());
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7407,7 +7585,10 @@ mod tests {
         assert!(result.finished);
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert_eq!(result.child_scan_units.len(), 1);
-        assert_eq!(result.child_scan_units[0].root_relpath, "root/child-b".to_string());
+        assert_eq!(
+            result.child_scan_units[0].root_relpath,
+            "root/child-b".to_string()
+        );
         assert_eq!(
             result.child_scan_units[0].scan_mode,
             FluxonFsTransferScanMode::FullTree
@@ -7447,9 +7628,10 @@ mod tests {
         assert_eq!(result.direct_files_only_batches.len(), 1);
         assert!(result.child_scan_units.is_empty());
         assert!(result.full_dir_batches.is_empty());
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7490,9 +7672,10 @@ mod tests {
         assert!(result.direct_files_only_batches.is_empty());
         assert!(result.child_scan_units.is_empty());
         assert_eq!(result.full_dir_batches.len(), 1);
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.full_dir_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.full_dir_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert!(manifest.entries.is_empty());
         assert_eq!(manifest.empty_dir_relpaths, vec!["root".to_string()]);
     }
@@ -7533,7 +7716,8 @@ mod tests {
     }
 
     #[test]
-    fn handle_transfer_scan_assignment_does_not_reaggregate_root_when_descendant_batch_is_durable() {
+    fn handle_transfer_scan_assignment_does_not_reaggregate_root_when_descendant_batch_is_durable()
+    {
         let root = TempDir::new().unwrap();
         write_file(&root, "root/direct.bin", b"abc");
         write_file(&root, "root/big/data.bin", b"12345");
@@ -7579,21 +7763,29 @@ mod tests {
                 size: 3,
             }]
         );
-        assert!(result
-            .full_dir_batches
-            .iter()
-            .all(|batch| batch.root_relpath != "root"));
-        assert!(result
-            .full_dir_batches
-            .iter()
-            .all(|batch| batch.root_relpath != "root/big"));
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/small".to_string()]);
+        assert!(
+            result
+                .full_dir_batches
+                .iter()
+                .all(|batch| batch.root_relpath != "root")
+        );
+        assert!(
+            result
+                .full_dir_batches
+                .iter()
+                .all(|batch| batch.root_relpath != "root/big")
+        );
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/small".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
 
     #[test]
-    fn handle_transfer_scan_assignment_honors_cross_generation_descendant_full_dir_during_restart() {
+    fn handle_transfer_scan_assignment_honors_cross_generation_descendant_full_dir_during_restart()
+    {
         let root = TempDir::new().unwrap();
         write_file(&root, "root/direct.bin", b"abc");
         write_file(&root, "root/big/data.bin", b"12345");
@@ -7639,21 +7831,29 @@ mod tests {
                 size: 3,
             }]
         );
-        assert!(result
-            .full_dir_batches
-            .iter()
-            .all(|batch| batch.root_relpath != "root"));
-        assert!(result
-            .full_dir_batches
-            .iter()
-            .all(|batch| batch.root_relpath != "root/big"));
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/small".to_string()]);
+        assert!(
+            result
+                .full_dir_batches
+                .iter()
+                .all(|batch| batch.root_relpath != "root")
+        );
+        assert!(
+            result
+                .full_dir_batches
+                .iter()
+                .all(|batch| batch.root_relpath != "root/big")
+        );
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/small".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
 
     #[test]
-    fn handle_transfer_scan_assignment_replays_descendant_current_layer_when_only_partial_descendant_direct_files_batch_is_durable() {
+    fn handle_transfer_scan_assignment_replays_descendant_current_layer_when_only_partial_descendant_direct_files_batch_is_durable()
+     {
         let root = TempDir::new().unwrap();
         write_file(&root, "root/child/a.bin", b"ab");
         write_file(&root, "root/child/b.bin", b"cd");
@@ -7688,10 +7888,14 @@ mod tests {
         assert!(result.child_scan_units.is_empty());
         assert!(result.full_dir_batches.is_empty());
         assert_eq!(result.direct_files_only_batches.len(), 1);
-        assert_eq!(result.direct_files_only_batches[0].root_relpath, "root/child");
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        assert_eq!(
+            result.direct_files_only_batches[0].root_relpath,
+            "root/child"
+        );
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![
@@ -7737,7 +7941,10 @@ mod tests {
 
         assert!(result.finished);
         assert!(result.direct_files_only_batches.is_empty());
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/parent".to_string()]);
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/parent".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
@@ -7772,9 +7979,10 @@ mod tests {
 
         assert!(result.finished);
         assert_eq!(result.direct_files_only_batches.len(), 1);
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.direct_files_only_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.direct_files_only_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![FluxonFsTransferManifestEntryWire {
@@ -7782,7 +7990,10 @@ mod tests {
                 size: 10,
             }]
         );
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/child".to_string()]);
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/child".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
@@ -7820,7 +8031,10 @@ mod tests {
 
         assert!(ok_bool(&resp));
         assert!(result.finished);
-        assert_eq!(child_scan_unit_roots(&result), vec!["root/blocked".to_string()]);
+        assert_eq!(
+            child_scan_unit_roots(&result),
+            vec!["root/blocked".to_string()]
+        );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
     }
@@ -7870,7 +8084,11 @@ mod tests {
         );
         assert_eq!(
             child_scan_unit_roots(&result),
-            vec!["root/a".to_string(), "root/b".to_string(), "root/c".to_string()]
+            vec![
+                "root/a".to_string(),
+                "root/b".to_string(),
+                "root/c".to_string()
+            ]
         );
         assert_all_child_scan_units_are_subtree_streaming(&result);
         assert!(result.full_dir_batches.is_empty());
@@ -7905,7 +8123,10 @@ mod tests {
         );
         let result = decode_result_json(&resp);
         assert_eq!(result.full_dir_batches.len(), 1);
-        assert_eq!(result.full_dir_batches[0].batch_kind, FluxonFsTransferBatchKind::SubtreeSlice);
+        assert_eq!(
+            result.full_dir_batches[0].batch_kind,
+            FluxonFsTransferBatchKind::SubtreeSlice
+        );
         assert_eq!(result.full_dir_batches[0].collect_infos.len(), 1);
         assert_eq!(
             decode_symlink_notice_collect_blob(
@@ -7957,11 +8178,15 @@ mod tests {
         assert!(result.direct_files_only_batches.is_empty());
         assert!(result.child_scan_units.is_empty());
         assert_eq!(result.full_dir_batches.len(), 1);
-        assert_eq!(result.full_dir_batches[0].batch_kind, FluxonFsTransferBatchKind::SubtreeSlice);
+        assert_eq!(
+            result.full_dir_batches[0].batch_kind,
+            FluxonFsTransferBatchKind::SubtreeSlice
+        );
         assert_eq!(result.full_dir_batches[0].root_relpath, "root".to_string());
-        let manifest =
-            FluxonFsTransferManifestWire::decode_from_blob(&result.full_dir_batches[0].manifest_blob)
-                .unwrap();
+        let manifest = FluxonFsTransferManifestWire::decode_from_blob(
+            &result.full_dir_batches[0].manifest_blob,
+        )
+        .unwrap();
         assert_eq!(
             manifest.entries,
             vec![
@@ -7982,7 +8207,9 @@ mod tests {
             FluxonFsTransferCollectInfoKind::SymlinkNotice
         );
         let mut notices = decode_symlink_notice_collect_blob(
-            direct_files_only_batch.collect_infos[0].collect_blob.as_slice()
+            direct_files_only_batch.collect_infos[0]
+                .collect_blob
+                .as_slice(),
         );
         notices.sort_by(|a, b| a.relpath.cmp(&b.relpath));
         assert_eq!(
@@ -8004,16 +8231,17 @@ mod tests {
     fn prepare_transfer_file_from_chunks_promotes_staged_file_to_final_path() {
         let root = TempDir::new().unwrap();
         let dst_root = root.path().to_path_buf();
-        let coordinator = test_transfer_coordinator(
-            || Ok(()),
-            {
-                let chunks = Arc::new(Mutex::new(vec![b"ab".to_vec(), b"cde".to_vec(), Vec::new()]));
-                move |_file, _read_offset, _length| {
-                    let mut chunks = chunks.lock();
-                    Ok(chunks.remove(0))
-                }
-            },
-        );
+        let coordinator = test_transfer_coordinator(|| Ok(()), {
+            let chunks = Arc::new(Mutex::new(vec![
+                b"ab".to_vec(),
+                b"cde".to_vec(),
+                Vec::new(),
+            ]));
+            move |_file, _read_offset, _length| {
+                let mut chunks = chunks.lock();
+                Ok(chunks.remove(0))
+            }
+        });
         let prepared = prepare_transfer_file_streaming(
             &dst_root,
             ".fluxon.stage/job/batch",
@@ -8038,32 +8266,31 @@ mod tests {
             fs::read(root.path().join("dir/file.bin")).unwrap(),
             b"abcde".to_vec()
         );
-        assert!(!root
-            .path()
-            .join(".fluxon.stage/job/batch/dir/file.bin/file.bin.fluxon.part")
-            .exists());
+        assert!(
+            !root
+                .path()
+                .join(".fluxon.stage/job/batch/dir/file.bin/file.bin.fluxon.part")
+                .exists()
+        );
     }
 
     #[test]
     fn prepare_transfer_file_from_chunks_truncates_existing_staging_file() {
         let root = TempDir::new().unwrap();
         let dst_root = root.path().to_path_buf();
-        let stale_staging =
-            root.path()
-                .join(".fluxon.stage/job/batch/dir/file.bin/file.bin.fluxon.part");
+        let stale_staging = root
+            .path()
+            .join(".fluxon.stage/job/batch/dir/file.bin/file.bin.fluxon.part");
         fs::create_dir_all(stale_staging.parent().unwrap()).unwrap();
         fs::write(&stale_staging, b"stale-data").unwrap();
 
-        let coordinator = test_transfer_coordinator(
-            || Ok(()),
-            {
-                let chunks = Arc::new(Mutex::new(vec![b"xy".to_vec(), Vec::new()]));
-                move |_file, _read_offset, _length| {
-                    let mut chunks = chunks.lock();
-                    Ok(chunks.remove(0))
-                }
-            },
-        );
+        let coordinator = test_transfer_coordinator(|| Ok(()), {
+            let chunks = Arc::new(Mutex::new(vec![b"xy".to_vec(), Vec::new()]));
+            move |_file, _read_offset, _length| {
+                let mut chunks = chunks.lock();
+                Ok(chunks.remove(0))
+            }
+        });
         let prepared = prepare_transfer_file_streaming(
             &dst_root,
             ".fluxon.stage/job/batch",
@@ -8076,23 +8303,23 @@ mod tests {
         .unwrap();
         promote_prepared_transfer_file(&dst_root, prepared).unwrap();
 
-        assert_eq!(fs::read(root.path().join("dir/file.bin")).unwrap(), b"xy".to_vec());
+        assert_eq!(
+            fs::read(root.path().join("dir/file.bin")).unwrap(),
+            b"xy".to_vec()
+        );
     }
 
     #[test]
     fn prepare_transfer_file_from_chunks_rejects_size_mismatch_and_keeps_staging_file() {
         let root = TempDir::new().unwrap();
         let dst_root = root.path().to_path_buf();
-        let coordinator = test_transfer_coordinator(
-            || Ok(()),
-            {
-                let chunks = Arc::new(Mutex::new(vec![b"xy".to_vec(), Vec::new()]));
-                move |_file, _read_offset, _length| {
-                    let mut chunks = chunks.lock();
-                    Ok(chunks.remove(0))
-                }
-            },
-        );
+        let coordinator = test_transfer_coordinator(|| Ok(()), {
+            let chunks = Arc::new(Mutex::new(vec![b"xy".to_vec(), Vec::new()]));
+            move |_file, _read_offset, _length| {
+                let mut chunks = chunks.lock();
+                Ok(chunks.remove(0))
+            }
+        });
         let err = prepare_transfer_file_streaming(
             &dst_root,
             ".fluxon.stage/job/batch",
@@ -8275,15 +8502,10 @@ mod tests {
         let file_bytes = b"hello".to_vec();
         let assignment = test_worker_assignment("dir/file.bin", file_bytes.len() as i64);
 
-        let result = execute_transfer_worker_assignment(
-            &assignment,
-            &dst_root,
-            || Ok(()),
-            {
-                let file_bytes = file_bytes.clone();
-                move |_file, _read_offset, _length| Ok(file_bytes.clone())
-            },
-        )
+        let result = execute_transfer_worker_assignment(&assignment, &dst_root, || Ok(()), {
+            let file_bytes = file_bytes.clone();
+            move |_file, _read_offset, _length| Ok(file_bytes.clone())
+        })
         .unwrap();
 
         assert_eq!(result.file_results.len(), 1);
@@ -8303,7 +8525,10 @@ mod tests {
         create_dir_all_with_parent_dir_chmod_retry(&target).unwrap();
 
         assert!(target.is_dir());
-        assert_eq!(fs::metadata(&locked_parent).unwrap().permissions().mode() & 0o777, 0o777);
+        assert_eq!(
+            fs::metadata(&locked_parent).unwrap().permissions().mode() & 0o777,
+            0o777
+        );
     }
 
     #[cfg(unix)]
@@ -8318,21 +8543,19 @@ mod tests {
         let file_bytes = b"hello".to_vec();
         let assignment = test_worker_assignment("dir/file.bin", file_bytes.len() as i64);
 
-        let result = execute_transfer_worker_assignment(
-            &assignment,
-            &dst_root,
-            || Ok(()),
-            {
-                let file_bytes = file_bytes.clone();
-                move |_file, _read_offset, _length| Ok(file_bytes.clone())
-            },
-        )
+        let result = execute_transfer_worker_assignment(&assignment, &dst_root, || Ok(()), {
+            let file_bytes = file_bytes.clone();
+            move |_file, _read_offset, _length| Ok(file_bytes.clone())
+        })
         .unwrap();
 
         assert_eq!(result.file_results.len(), 1);
         assert!(dst_root.is_dir());
         assert_eq!(fs::read(dst_root.join("dir/file.bin")).unwrap(), file_bytes);
-        assert_eq!(fs::metadata(&locked_parent).unwrap().permissions().mode() & 0o777, 0o777);
+        assert_eq!(
+            fs::metadata(&locked_parent).unwrap().permissions().mode() & 0o777,
+            0o777
+        );
     }
 
     #[test]
@@ -8349,47 +8572,48 @@ mod tests {
                 let assignment = assignment.clone();
                 let heartbeat_attempts = heartbeat_attempts.clone();
                 move || {
-                retry_transfer_worker_rpc_with_backoff(
-                    &assignment,
-                    "checkpoint",
-                    "test-checkpoint",
-                    BackoffConfig {
-                        initial_secs: 0,
-                        max_secs: 0,
-                    },
-                    WarnConfig {
-                        warn_interval_secs: 0,
-                    },
-                    || {
-                        let attempt =
-                            heartbeat_attempts.fetch_add(1, Ordering::SeqCst) + 1;
-                        if attempt < 3 {
-                            return Err(TransferWorkerRpcFailure::Retryable {
-                                detail: format!(
-                                    "transient heartbeat failure attempt={}",
-                                    attempt
-                                ),
-                            });
-                        }
-                        Ok(())
-                    },
-                )
-                .map_err(TransferWorkerExecutionError::fatal)
-            }
+                    retry_transfer_worker_rpc_with_backoff(
+                        &assignment,
+                        "checkpoint",
+                        "test-checkpoint",
+                        BackoffConfig {
+                            initial_secs: 0,
+                            max_secs: 0,
+                        },
+                        WarnConfig {
+                            warn_interval_secs: 0,
+                        },
+                        || {
+                            let attempt = heartbeat_attempts.fetch_add(1, Ordering::SeqCst) + 1;
+                            if attempt < 3 {
+                                return Err(TransferWorkerRpcFailure::Retryable {
+                                    detail: format!(
+                                        "transient heartbeat failure attempt={}",
+                                        attempt
+                                    ),
+                                });
+                            }
+                            Ok(())
+                        },
+                    )
+                    .map_err(TransferWorkerExecutionError::fatal)
+                }
             },
             {
                 let file_bytes = file_bytes.clone();
                 move |file, read_offset, _length| {
-                if file.relpath != "dir/file.bin" {
-                    return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
-                        detail: format!("unexpected file relpath: {}", file.relpath),
-                    }))));
-                }
-                if read_offset == 0 {
-                    return Ok(file_bytes.clone());
+                    if file.relpath != "dir/file.bin" {
+                        return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(
+                            KvError::Api(ApiError::InvalidArgument {
+                                detail: format!("unexpected file relpath: {}", file.relpath),
+                            }),
+                        )));
+                    }
+                    if read_offset == 0 {
+                        return Ok(file_bytes.clone());
+                    }
+                    Ok(Vec::new())
                 }
-                Ok(Vec::new())
-            }
             },
         )
         .unwrap();
@@ -8409,24 +8633,20 @@ mod tests {
         let file_bytes = b"payload".to_vec();
         let assignment = test_worker_assignment("dir/file.bin", file_bytes.len() as i64);
         let read_attempts = Arc::new(AtomicUsize::new(0));
-        let result = execute_transfer_worker_assignment(
-            &assignment,
-            &dst_root,
-            || Ok(()),
-            {
-                let assignment = assignment.clone();
-                let file_bytes = file_bytes.clone();
-                let read_attempts = read_attempts.clone();
-                move |file, read_offset, _length| {
+        let result = execute_transfer_worker_assignment(&assignment, &dst_root, || Ok(()), {
+            let assignment = assignment.clone();
+            let file_bytes = file_bytes.clone();
+            let read_attempts = read_attempts.clone();
+            move |file, read_offset, _length| {
                 if file.relpath != "dir/file.bin" {
-                    return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(KvError::Api(ApiError::InvalidArgument {
-                        detail: format!("unexpected file relpath: {}", file.relpath),
-                    }))));
+                    return Err(TransferWorkerExecutionError::fatal(resp_err_kverr(
+                        KvError::Api(ApiError::InvalidArgument {
+                            detail: format!("unexpected file relpath: {}", file.relpath),
+                        }),
+                    )));
                 }
-                let op_detail = format!(
-                    "test-read relpath={} offset={}",
-                    file.relpath, read_offset
-                );
+                let op_detail =
+                    format!("test-read relpath={} offset={}", file.relpath, read_offset);
                 retry_transfer_worker_rpc_with_backoff(
                     &assignment,
                     "read_chunk",
@@ -8443,10 +8663,7 @@ mod tests {
                             let attempt = read_attempts.fetch_add(1, Ordering::SeqCst) + 1;
                             if attempt < 3 {
                                 return Err(TransferWorkerRpcFailure::Retryable {
-                                    detail: format!(
-                                        "transient read failure attempt={}",
-                                        attempt
-                                    ),
+                                    detail: format!("transient read failure attempt={}", attempt),
                                 });
                             }
                             return Ok(file_bytes.clone());
@@ -8456,8 +8673,7 @@ mod tests {
                 )
                 .map_err(TransferWorkerExecutionError::fatal)
             }
-            },
-        )
+        })
         .unwrap();
 
         assert_eq!(read_attempts.load(Ordering::SeqCst), 3);
@@ -8481,23 +8697,23 @@ mod tests {
             {
                 let checkpoint_calls = checkpoint_calls.clone();
                 move || {
-                let calls = checkpoint_calls.fetch_add(1, Ordering::SeqCst) + 1;
-                if calls >= 4 {
-                    return Err(TransferWorkerExecutionError::Stop(
-                        FluxonFsTransferWorkerStopReasonWire::Superseded,
-                    ));
+                    let calls = checkpoint_calls.fetch_add(1, Ordering::SeqCst) + 1;
+                    if calls >= 4 {
+                        return Err(TransferWorkerExecutionError::Stop(
+                            FluxonFsTransferWorkerStopReasonWire::Superseded,
+                        ));
+                    }
+                    Ok(())
                 }
-                Ok(())
-            }
             },
             {
                 let file_bytes = file_bytes.clone();
                 move |_file, read_offset, _length| {
-                if read_offset == 0 {
-                    return Ok(file_bytes.clone());
+                    if read_offset == 0 {
+                        return Ok(file_bytes.clone());
+                    }
+                    Ok(Vec::new())
                 }
-                Ok(Vec::new())
-            }
             },
         );
         assert!(matches!(
@@ -8567,12 +8783,7 @@ mod tests {
                             break;
                         }
                         if max_in_flight
-                            .compare_exchange(
-                                observed,
-                                current,
-                                Ordering::SeqCst,
-                                Ordering::SeqCst,
-                            )
+                            .compare_exchange(observed, current, Ordering::SeqCst, Ordering::SeqCst)
                             .is_ok()
                         {
                             break;
@@ -8588,8 +8799,14 @@ mod tests {
 
         assert_eq!(result.file_results.len(), 2);
         assert!(max_in_flight.load(Ordering::SeqCst) >= 2);
-        assert_eq!(fs::read(root.path().join("dir/a.bin")).unwrap(), b"xxx".to_vec());
-        assert_eq!(fs::read(root.path().join("dir/b.bin")).unwrap(), b"xxx".to_vec());
+        assert_eq!(
+            fs::read(root.path().join("dir/a.bin")).unwrap(),
+            b"xxx".to_vec()
+        );
+        assert_eq!(
+            fs::read(root.path().join("dir/b.bin")).unwrap(),
+            b"xxx".to_vec()
+        );
     }
 
     #[test]
@@ -8597,29 +8814,25 @@ mod tests {
         let root = TempDir::new().unwrap();
         let dst_root = root.path().to_path_buf();
         let file_bytes = b"hello".to_vec();
-        let collect_infos = build_symlink_collect_infos(vec![FluxonFsTransferSymlinkNoticeEntryWire {
-            relpath: "dir/link.bin".to_string(),
-            link_target: "dir/file.bin".to_string(),
-        }])
-        .unwrap();
+        let collect_infos =
+            build_symlink_collect_infos(vec![FluxonFsTransferSymlinkNoticeEntryWire {
+                relpath: "dir/link.bin".to_string(),
+                link_target: "dir/file.bin".to_string(),
+            }])
+            .unwrap();
         let assignment = FluxonFsTransferWorkerAssignmentWire {
             collect_infos: collect_infos.clone(),
             ..test_worker_assignment("dir/file.bin", file_bytes.len() as i64)
         };
-        let result = execute_transfer_worker_assignment(
-            &assignment,
-            &dst_root,
-            || Ok(()),
-            {
-                let file_bytes = file_bytes.clone();
-                move |_file, read_offset, _length| {
-                    if read_offset == 0 {
-                        return Ok(file_bytes.clone());
-                    }
-                    Ok(Vec::new())
+        let result = execute_transfer_worker_assignment(&assignment, &dst_root, || Ok(()), {
+            let file_bytes = file_bytes.clone();
+            move |_file, read_offset, _length| {
+                if read_offset == 0 {
+                    return Ok(file_bytes.clone());
                 }
-            },
-        )
+                Ok(Vec::new())
+            }
+        })
         .unwrap();
 
         assert_eq!(result.file_results.len(), 1);
@@ -8633,7 +8846,11 @@ mod tests {
             "fluxon_collect_info/batches/batch/symlinks.jsonl"
         );
         assert_eq!(
-            fs::read(root.path().join("fluxon_collect_info/batches/batch/symlinks.jsonl")).unwrap(),
+            fs::read(
+                root.path()
+                    .join("fluxon_collect_info/batches/batch/symlinks.jsonl")
+            )
+            .unwrap(),
             collect_infos[0].collect_blob
         );
     }
@@ -8643,16 +8860,19 @@ mod tests {
         let root = TempDir::new().unwrap();
         let dst_root = root.path().to_path_buf();
         let assignment = FluxonFsTransferWorkerAssignmentWire {
-            manifest_blob: build_transfer_manifest_blob(vec![
-                FluxonFsTransferScanFrontierEntry {
-                    relpath: "dir/good.bin".to_string(),
-                    size: 5,
-                },
-                FluxonFsTransferScanFrontierEntry {
-                    relpath: "dir/bad.bin".to_string(),
-                    size: 5,
-                },
-            ], Vec::new())
+            manifest_blob: build_transfer_manifest_blob(
+                vec![
+                    FluxonFsTransferScanFrontierEntry {
+                        relpath: "dir/good.bin".to_string(),
+                        size: 5,
+                    },
+                    FluxonFsTransferScanFrontierEntry {
+                        relpath: "dir/bad.bin".to_string(),
+                        size: 5,
+                    },
+                ],
+                Vec::new(),
+            )
             .unwrap(),
             ..test_worker_assignment("dir/good.bin", 5)
         };
@@ -8816,20 +9036,16 @@ mod tests {
         .unwrap();
 
         let progress_heartbeat_count = Arc::new(AtomicUsize::new(0));
-        gate.ensure_continue(
-            false,
-            TRANSFER_WORKER_HEARTBEAT_EMPTY_DIR_PROGRESS_COUNT,
-            {
-                let progress_heartbeat_count = progress_heartbeat_count.clone();
-                move |_heartbeat_unix_ms, heartbeat_detail| {
-                    assert_eq!(heartbeat_detail, "empty_dir_progress");
-                    progress_heartbeat_count.fetch_add(1, Ordering::SeqCst);
-                    Ok(FluxonFsTransferWorkerHeartbeatResultWire::continue_running(
-                        chrono::Utc::now().timestamp_millis() + 60_000,
-                    ))
-                }
-            },
-        )
+        gate.ensure_continue(false, TRANSFER_WORKER_HEARTBEAT_EMPTY_DIR_PROGRESS_COUNT, {
+            let progress_heartbeat_count = progress_heartbeat_count.clone();
+            move |_heartbeat_unix_ms, heartbeat_detail| {
+                assert_eq!(heartbeat_detail, "empty_dir_progress");
+                progress_heartbeat_count.fetch_add(1, Ordering::SeqCst);
+                Ok(FluxonFsTransferWorkerHeartbeatResultWire::continue_running(
+                    chrono::Utc::now().timestamp_millis() + 60_000,
+                ))
+            }
+        })
         .unwrap();
 
         gate.ensure_continue(
@@ -8927,20 +9143,15 @@ mod tests {
         let dst_root = root.path().to_path_buf();
         let file_bytes = b"hello".to_vec();
         let assignment = test_worker_assignment("dir/file.bin", file_bytes.len() as i64);
-        let result = execute_transfer_worker_assignment(
-            &assignment,
-            &dst_root,
-            || Ok(()),
-            {
-                let file_bytes = file_bytes.clone();
-                move |_file, read_offset, _length| {
-                    if read_offset == 0 {
-                        return Ok(file_bytes.clone());
-                    }
-                    Ok(Vec::new())
+        let result = execute_transfer_worker_assignment(&assignment, &dst_root, || Ok(()), {
+            let file_bytes = file_bytes.clone();
+            move |_file, read_offset, _length| {
+                if read_offset == 0 {
+                    return Ok(file_bytes.clone());
                 }
-            },
-        )
+                Ok(Vec::new())
+            }
+        })
         .unwrap();
 
         assert_eq!(result.file_results.len(), 1);
@@ -8948,7 +9159,10 @@ mod tests {
 
         cleanup_transfer_worker_attempt_artifacts(&dst_root, &assignment).unwrap();
 
-        assert_eq!(fs::read(root.path().join("dir/file.bin")).unwrap(), file_bytes);
+        assert_eq!(
+            fs::read(root.path().join("dir/file.bin")).unwrap(),
+            file_bytes
+        );
         assert!(!root.path().join(".fluxon.stage").exists());
     }
 
@@ -8957,11 +9171,12 @@ mod tests {
         let root = TempDir::new().unwrap();
         let dst_root = root.path().to_path_buf();
         let file_bytes = b"hello".to_vec();
-        let collect_infos = build_symlink_collect_infos(vec![FluxonFsTransferSymlinkNoticeEntryWire {
-            relpath: "root/link-file.bin".to_string(),
-            link_target: "target/file.bin".to_string(),
-        }])
-        .unwrap();
+        let collect_infos =
+            build_symlink_collect_infos(vec![FluxonFsTransferSymlinkNoticeEntryWire {
+                relpath: "root/link-file.bin".to_string(),
+                link_target: "target/file.bin".to_string(),
+            }])
+            .unwrap();
         let assignment = FluxonFsTransferWorkerAssignmentWire {
             collect_infos: collect_infos.clone(),
             ..test_worker_assignment("dir/file.bin", file_bytes.len() as i64)
@@ -8976,9 +9191,11 @@ mod tests {
         let result = execute_transfer_worker_assignment(
             &assignment,
             &dst_root,
-            || Err(TransferWorkerExecutionError::Stop(
-                FluxonFsTransferWorkerStopReasonWire::Superseded,
-            )),
+            || {
+                Err(TransferWorkerExecutionError::Stop(
+                    FluxonFsTransferWorkerStopReasonWire::Superseded,
+                ))
+            },
             {
                 let file_bytes = file_bytes.clone();
                 move |_file, read_offset, _length| {
@@ -8996,11 +9213,20 @@ mod tests {
                 FluxonFsTransferWorkerStopReasonWire::Superseded
             ))
         ));
-        assert!(root.path().join(prepared_collect.staging_relpath.as_str()).exists());
+        assert!(
+            root.path()
+                .join(prepared_collect.staging_relpath.as_str())
+                .exists()
+        );
 
         cleanup_transfer_worker_attempt_artifacts(&dst_root, &assignment).unwrap();
 
         assert!(!root.path().join(".fluxon.stage").exists());
-        assert!(!root.path().join(prepared_collect.staging_relpath.as_str()).exists());
+        assert!(
+            !root
+                .path()
+                .join(prepared_collect.staging_relpath.as_str())
+                .exists()
+        );
     }
 }
diff --git a/fluxon_rs/fluxon_fs/src/cache_controller.rs b/fluxon_rs/fluxon_fs/src/cache_controller.rs
index 8a0845c..13ce5a8 100644
--- a/fluxon_rs/fluxon_fs/src/cache_controller.rs
+++ b/fluxon_rs/fluxon_fs/src/cache_controller.rs
@@ -429,8 +429,8 @@ fn now_ms() -> i64 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::sync::mpsc;
     use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+    use std::sync::mpsc;
     use std::sync::{Condvar, Mutex};
     use tokio::time::{Duration, sleep};
 
diff --git a/fluxon_rs/fluxon_fs_s3_gateway/src/lib.rs b/fluxon_rs/fluxon_fs_s3_gateway/src/lib.rs
index 827bb23..0866432 100644
--- a/fluxon_rs/fluxon_fs_s3_gateway/src/lib.rs
+++ b/fluxon_rs/fluxon_fs_s3_gateway/src/lib.rs
@@ -5344,10 +5344,9 @@ mod tests {
     };
     use crate::transfer::encode_transfer_manifest_blob_with_empty_dirs;
     use fluxon_fs_core::config::{
-        FS_CACHE_DEFAULT_WRITE_SESSION_TARGET_INFLIGHT_BYTES_V1,
-        FS_EXPORT_DEFAULT_INLINE_BYTES_MAX_BYTES_V1,
-        FS_EXPORT_DEFAULT_METADATA_CACHE_TTL_MS_V1,
         FLUXON_FS_LOCAL_TRANSFER_CHECK_DST_EXPORT, FLUXON_FS_LOCAL_TRANSFER_CHECK_SRC_EXPORT,
+        FS_CACHE_DEFAULT_WRITE_SESSION_TARGET_INFLIGHT_BYTES_V1,
+        FS_EXPORT_DEFAULT_INLINE_BYTES_MAX_BYTES_V1, FS_EXPORT_DEFAULT_METADATA_CACHE_TTL_MS_V1,
         FluxonFsAccessModel, FluxonFsAccessUser, FluxonFsExport, FluxonFsExportRoutingMode,
         FluxonFsGlobalConfig, FluxonFsLocalTransferCheckJobSpecWire, FluxonFsRequestIdentity,
         FluxonFsS3GatewayConfig, FluxonFsS3KvMissPolicy, FluxonFsS3PermissionAccount,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
index 8e37608..63db807 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
@@ -16,21 +16,6 @@ use crate::{
 };
 use limit_thirdparty::tokio;
 
-fn remove_local_cached_info_for_delete(
-    client_inner: &ClientKvApiInner,
-    delete_item: &DeleteClientKvMetaCacheItem,
-) {
-    client_inner
-        .get_cached_info
-        .remove_if(&delete_item.key, |_, v| {
-            if v.put_time_ms == delete_item.put_time_ms {
-                v.put_version <= delete_item.put_version
-            } else {
-                v.put_time_ms <= delete_item.put_time_ms
-            }
-        });
-}
-
 impl ClientKvApiInner {
     pub async fn delete(&self, key: &str) -> KvResult<()> {
         if !self.view.register_shutdown_poller().is_running() {
@@ -64,14 +49,12 @@ impl ClientKvApiInner {
             resp.serialize_part.error_json.clone(),
         )?;
 
-        remove_local_cached_info_for_delete(
-            self,
-            &DeleteClientKvMetaCacheItem {
-                key: key.to_string(),
-                put_time_ms: resp.serialize_part.deleted_put_time_ms,
-                put_version: resp.serialize_part.deleted_put_version,
-            },
-        );
+        let delete_item = DeleteClientKvMetaCacheItem {
+            key: key.to_string(),
+            put_time_ms: resp.serialize_part.deleted_put_time_ms,
+            put_version: resp.serialize_part.deleted_put_version,
+        };
+        apply_delete_client_kv_meta_cache_item(&self.view, &delete_item).await;
 
         Ok(())
     }
@@ -99,6 +82,59 @@ pub fn spawn_owner_delete_ack_batch(
     });
 }
 
+async fn apply_delete_client_kv_meta_cache_item(
+    view: &ClientKvApiView,
+    delete_item: &DeleteClientKvMetaCacheItem,
+) {
+    let client_api = view.client_kv_api();
+    let client_inner = client_api.inner();
+
+    if let Some((_removed_key, cached_info)) =
+        client_inner
+            .get_cached_info
+            .remove_if(&delete_item.key, |_, v| {
+                let res = if v.put_time_ms == delete_item.put_time_ms {
+                    v.put_version <= delete_item.put_version
+                } else {
+                    v.put_time_ms <= delete_item.put_time_ms
+                };
+                if res {
+                    tracing::debug!("do remove local cache for key: {}", delete_item.key);
+                } else {
+                    tracing::debug!(
+                        "skip remove local cache for key: {}, request ({},{}), local ({},{})",
+                        delete_item.key,
+                        delete_item.put_time_ms,
+                        delete_item.put_version,
+                        v.put_time_ms,
+                        v.put_version
+                    );
+                }
+                res
+            })
+    {
+        client_inner.release_local_reserve_route_for_memory_info(cached_info.mem_holder.as_ref());
+    }
+    let _ = client_inner.remove_local_snapshot_if(
+        &delete_item.key,
+        delete_item.put_time_ms,
+        delete_item.put_version,
+    );
+
+    if let Err(err) = client_inner
+        .external_invalidate_delete
+        .sender()
+        .send(delete_item.clone())
+        .await
+    {
+        tracing::warn!(
+            "Failed to enqueue external weak-index invalidation for key '{}': {}",
+            delete_item.key,
+            err
+        );
+    }
+}
+
 /// 批量删除客户端 KV 元数据缓存的处理函数
 pub async fn handle_batch_delete_client_kv_meta_cache(
     view: &ClientKvApiView,
@@ -111,9 +147,6 @@ pub async fn handle_batch_delete_client_kv_meta_cache(
         req.serialize_part.delete_items.len()
     );
 
-    let client_api = view.client_kv_api();
-    let client_inner = client_api.inner();
-
     let mut deleted_count = 0u32;
 
     for delete_item in &req.serialize_part.delete_items {
@@ -124,21 +157,8 @@ pub async fn handle_batch_delete_client_kv_meta_cache(
             delete_item.put_version
         );
 
-        remove_local_cached_info_for_delete(client_inner, delete_item);
+        apply_delete_client_kv_meta_cache_item(view, delete_item).await;
         deleted_count += 1;
-
-        if let Err(err) = client_inner
-            .external_invalidate_delete
-            .sender()
-            .send(delete_item.clone())
-            .await
-        {
-            tracing::warn!(
-                "Failed to enqueue external weak-index invalidation for key '{}': {}",
-                delete_item.key,
-                err
-            );
-        }
     }
 
     tracing::debug!(
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 60986be..3cfd44d 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -1,23 +1,43 @@
 use crate::client_kv_api::msg_pack::{
-    ExternalDeleteReq, ExternalDeleteResp, ExternalGetReq, ExternalGetResp, ExternalIsExistReq,
-    ExternalIsExistResp, ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq,
-    ExternalPutRevokeResp, ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
-    ExternalPutTransferEndResp, TestPutPhaseTrace,
+    ExternalBatchGetCancelReq, ExternalBatchGetCancelResp, ExternalBatchGetItemResp,
+    ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
+    ExternalBatchGetTransferReq, ExternalBatchGetTransferResp, ExternalBatchIsExistReq,
+    ExternalBatchIsExistResp, ExternalBatchPutCommitItemResp, ExternalBatchPutCommitReq,
+    ExternalBatchPutCommitResp, ExternalBatchPutStartItemResp, ExternalBatchPutStartReq,
+    ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemResp, ExternalBatchPutTransferEndReq,
+    ExternalBatchPutTransferEndResp, ExternalDeleteReq, ExternalDeleteResp, ExternalGetReq,
+    ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp, ExternalObservabilitySnapshotReq,
+    ExternalObservabilitySnapshotResp, ExternalPutCommitReq, ExternalPutCommitResp,
+    ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq, ExternalPutStartResp,
+    ExternalPutTransferEndReq, ExternalPutTransferEndResp, TestPutPhaseTrace,
 };
-use crate::client_kv_api::{ClientKvApi, ExternalHoldingGetInfo, ExternalPendingPutCtx};
-use crate::client_seg_pool::{ResolveSideTransferLaneReq, parse_side_transfer_worker_lane_idx};
+use crate::client_kv_api::ClientKvApi;
+use crate::client_kv_api::{
+    self, ExternalGetStartDedupKey, ExternalGetStartEntry, ExternalGetStartOwnerItem,
+    ExternalGetStartPrefixResult, ExternalGetStartSharedItemResult, ExternalGetStartSharedOp,
+    ExternalGetStartSharedPhase, ExternalGetStartTransferOutput, ExternalHoldingGetInfo,
+    ExternalPendingPutCtx,
+};
+use crate::client_seg_pool::{parse_side_transfer_worker_lane_idx, ResolveSideTransferLaneReq};
 use crate::cluster_manager::NodeIDString;
 use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
-use crate::memholder::ExternalMemHolderInfo;
+use crate::master_kv_router::msg_pack::{
+    BatchPutDoneItemReq, BatchPutRevokeItemReq, BatchPutStartItemReq,
+};
 use crate::memholder::MemholderManagerTrait;
 use crate::memholder::NodeHolderKey;
+use crate::memholder::{ExternalMemHolderInfo, UserMemHolder, UserMemHolderExposeKind};
 use crate::p2p::msg_pack::MsgPack;
+use crate::rpcresp_kvresult_convert::msg_and_error::{codes_api, ApiError, KvError, KvResult, OK};
 use crate::rpcresp_kvresult_convert::FromError;
 use crate::rpcresp_kvresult_convert::ToResult;
-use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK};
 use async_trait::async_trait;
+use dashmap::mapref::entry::Entry;
+use futures::stream::{self, StreamExt};
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 use tracing;
@@ -29,6 +49,494 @@ fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
 const SIDE_TRANSFER_OWNER_RPC_TIMEOUT_SECS: u64 = 30;
 const SIDE_TRANSFER_TARGET_RESOLVE_TIMEOUT_SECS: u64 = 10;
 
+#[derive(Clone)]
+struct LocalCommittedCachePublish {
+    src_offset: u64,
+    len: u32,
+}
+
+fn local_committed_cache_publish(
+    op: &'static str,
+    key: &str,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    pending_ctx: Option<&ExternalPendingPutCtx>,
+    req_src_offset: u64,
+    req_len: u64,
+) -> KvResult<LocalCommittedCachePublish> {
+    if let Some(ctx) = pending_ctx {
+        if ctx.src_offset != req_src_offset || ctx.len != req_len {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "{op} local cache publish request mismatches pending ctx: key={} put_id=({},{}) req_src_offset={} ctx_src_offset={} req_len={} ctx_len={}",
+                    key, put_id.0, put_id.1, req_src_offset, ctx.src_offset, req_len, ctx.len
+                ),
+            }));
+        }
+    }
+    let len = u32::try_from(req_len).map_err(|_| {
+        KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "{op} local cache len does not fit u32: key={} len={}",
+                key, req_len
+            ),
+        })
+    })?;
+    Ok(LocalCommittedCachePublish {
+        src_offset: req_src_offset,
+        len,
+    })
+}
+
+pub(crate) fn normalize_external_get_start_group_lens(
+    keys_len: usize,
+    atomic_group_lens: Option<Vec<usize>>,
+) -> KvResult<Vec<usize>> {
+    match atomic_group_lens {
+        Some(group_lens) => {
+            if group_lens.is_empty() {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: "external_batch_get_start atomic_group_lens must be non-empty"
+                        .to_string(),
+                }));
+            }
+            if group_lens.iter().any(|len| *len == 0) {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: "external_batch_get_start atomic_group_lens entries must be > 0"
+                        .to_string(),
+                }));
+            }
+            let group_sum = group_lens.iter().sum::<usize>();
+            if group_sum != keys_len {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "external_batch_get_start atomic_group_lens must sum to keys length: sum={} keys={}",
+                        group_sum, keys_len
+                    ),
+                }));
+            }
+            Ok(group_lens)
+        }
+        None => Ok(vec![keys_len]),
+    }
+}
+
+fn external_get_start_error_kind_from_code(error_code: u32, error_json: &str) -> Option<String> {
+    if error_code == OK || error_code == codes_api::API_KEY_NOT_FOUND {
+        None
+    } else if error_json.is_empty() {
+        Some(format!("error_code:{}", error_code))
+    } else {
+        Some(format!("error_code:{} {}", error_code, error_json))
+    }
+}
+
+fn compute_external_get_start_raw_prefix(
+    item_codes: &[(u32, String)],
+) -> (usize, Option<usize>, Option<String>) {
+    let mut prefix_hit_len = 0usize;
+    for (idx, (error_code, error_json)) in item_codes.iter().enumerate() {
+        if *error_code == OK {
+            prefix_hit_len += 1;
+            continue;
+        }
+        return (
+            prefix_hit_len,
+            Some(idx),
+            external_get_start_error_kind_from_code(*error_code, error_json),
+        );
+    }
+    (prefix_hit_len, None, None)
+}
+
+pub(crate) fn compute_external_get_start_transfer_prefix(
+    raw_prefix_hit_len: usize,
+    group_lens: &[usize],
+    prefix_best_effort: bool,
+) -> usize {
+    let mut transferable_len = 0usize;
+    for group_len in group_lens.iter().copied() {
+        let next = transferable_len + group_len;
+        if next > raw_prefix_hit_len {
+            break;
+        }
+        transferable_len = next;
+    }
+    let requested_len = group_lens.iter().sum::<usize>();
+    if !prefix_best_effort && transferable_len != requested_len {
+        0
+    } else {
+        transferable_len
+    }
+}
+
+async fn finish_external_get_start_transfer(
+    view: crate::client_kv_api::ClientKvApiView,
+    transfer_items: Vec<ExternalGetStartOwnerItem>,
+    transfer_concurrency: usize,
+) -> KvResult<ExternalGetStartTransferOutput> {
+    let client_api = view.client_kv_api();
+    let inner = client_api.inner();
+    let refcount = inner.get_or_init_all_memholder_refcount();
+    let mut results: Vec<
+        Option<KvResult<Option<(Arc<UserMemHolder>, Option<client_kv_api::RemoteGetInfo>)>>>,
+    > = (0..transfer_items.len()).map(|_| None).collect();
+    let mut started_positions = Vec::new();
+    let mut started_keys = Vec::new();
+    let mut started_items = Vec::new();
+
+    for (idx, item) in transfer_items.into_iter().enumerate() {
+        match item {
+            ExternalGetStartOwnerItem::Local { memory_info } => {
+                let holder = Arc::new(UserMemHolder::new(
+                    memory_info,
+                    refcount.clone(),
+                    UserMemHolderExposeKind::SegPtr,
+                ));
+                results[idx] = Some(Ok(Some((holder, None))));
+            }
+            ExternalGetStartOwnerItem::Started { key, item } => {
+                started_positions.push(idx);
+                started_keys.push(key);
+                started_items.push(item);
+            }
+        }
+    }
+
+    if !started_items.is_empty() {
+        let started_results = inner
+            .batch_get_finish_started(started_keys, started_items, transfer_concurrency)
+            .await?;
+        if started_results.len() != started_positions.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external get_start transfer result length mismatch: expected={} got={}",
+                    started_positions.len(),
+                    started_results.len()
+                ),
+            }));
+        }
+        for (idx, result) in started_positions
+            .into_iter()
+            .zip(started_results.into_iter())
+        {
+            results[idx] = Some(result);
+        }
+    }
+
+    Ok(results
+        .into_iter()
+        .map(|item| {
+            item.unwrap_or_else(|| {
+                Err(KvError::Api(ApiError::Unknown {
+                    detail: "external get_start transfer result slot was not populated".to_string(),
+                }))
+            })
+        })
+        .collect())
+}
+
+fn external_get_start_error_parts(err: &KvError) -> (u32, String) {
+    (err.code(), err.to_json())
+}
+
+fn register_external_get_start_waiter(shared_op: &Arc<ExternalGetStartSharedOp>) {
+    let mut state = shared_op.state.lock();
+    state.waiter_count = state
+        .waiter_count
+        .checked_add(1)
+        .expect("external get_start shared waiter count overflow");
+}
+
+fn release_external_get_start_waiter(
+    inner: &client_kv_api::ClientKvApiInner,
+    shared_op: &Arc<ExternalGetStartSharedOp>,
+) {
+    let should_remove = {
+        let mut state = shared_op.state.lock();
+        assert!(
+            state.waiter_count > 0,
+            "external get_start shared waiter count underflow"
+        );
+        state.waiter_count -= 1;
+        state.waiter_count == 0
+    };
+    if should_remove {
+        inner
+            .external_get_start_by_key
+            .remove_if(&shared_op.dedup_key, |_, op| {
+                if !Arc::ptr_eq(op, shared_op) {
+                    return false;
+                }
+                op.state.lock().waiter_count == 0
+            });
+    }
+}
+
+fn publish_external_get_start_failed(shared_op: &Arc<ExternalGetStartSharedOp>, err: &KvError) {
+    let (error_code, error_json) = external_get_start_error_parts(err);
+    {
+        let mut state = shared_op.state.lock();
+        state.phase = ExternalGetStartSharedPhase::Failed {
+            error_code,
+            error_json,
+        };
+    }
+    shared_op.notify.notify_waiters();
+}
+
+fn publish_external_get_start_ready(
+    shared_op: &Arc<ExternalGetStartSharedOp>,
+    keys: Vec<String>,
+    transfer_result: KvResult<ExternalGetStartTransferOutput>,
+) {
+    let phase = match transfer_result {
+        Ok(transfer_results) => {
+            if transfer_results.len() != keys.len() {
+                let err = KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external shared get_start transfer result length mismatch: expected={} got={}",
+                        keys.len(),
+                        transfer_results.len()
+                    ),
+                });
+                let (error_code, error_json) = external_get_start_error_parts(&err);
+                ExternalGetStartSharedPhase::Failed {
+                    error_code,
+                    error_json,
+                }
+            } else {
+                let items = keys
+                    .iter()
+                    .zip(transfer_results.into_iter())
+                    .map(|(_key, item_result)| match item_result {
+                        Ok(Some((memholder, _))) => {
+                            ExternalGetStartSharedItemResult::Hit { memholder }
+                        }
+                        Ok(None) => ExternalGetStartSharedItemResult::Miss,
+                        Err(err) => {
+                            let (error_code, error_json) = external_get_start_error_parts(&err);
+                            ExternalGetStartSharedItemResult::Error {
+                                error_code,
+                                error_json,
+                            }
+                        }
+                    })
+                    .collect::<Vec<_>>();
+                let prefix = match {
+                    let state = shared_op.state.lock();
+                    match &state.phase {
+                        ExternalGetStartSharedPhase::Running { prefix, .. }
+                        | ExternalGetStartSharedPhase::Ready { prefix, .. } => Ok(prefix.clone()),
+                        ExternalGetStartSharedPhase::Starting
+                        | ExternalGetStartSharedPhase::Failed { .. } => Err(KvError::Api(
+                            ApiError::Unknown {
+                                detail:
+                                    "external shared get_start transfer completed before prefix was published"
+                                        .to_string(),
+                            },
+                        )),
+                    }
+                } {
+                    Ok(prefix) => prefix,
+                    Err(err) => {
+                        let (error_code, error_json) = external_get_start_error_parts(&err);
+                        let mut state = shared_op.state.lock();
+                        state.phase = ExternalGetStartSharedPhase::Failed {
+                            error_code,
+                            error_json,
+                        };
+                        shared_op.notify.notify_waiters();
+                        return;
+                    }
+                };
+                ExternalGetStartSharedPhase::Ready {
+                    prefix,
+                    keys,
+                    items,
+                }
+            }
+        }
+        Err(err) => {
+            let (error_code, error_json) = external_get_start_error_parts(&err);
+            ExternalGetStartSharedPhase::Failed {
+                error_code,
+                error_json,
+            }
+        }
+    };
+    {
+        let mut state = shared_op.state.lock();
+        state.phase = phase;
+    }
+    shared_op.notify.notify_waiters();
+}
+
+async fn wait_external_get_start_prefix(
+    shared_op: Arc<ExternalGetStartSharedOp>,
+) -> KvResult<ExternalGetStartPrefixResult> {
+    loop {
+        let notified = shared_op.notify.notified();
+        futures::pin_mut!(notified);
+        let should_wait = {
+            let state = shared_op.state.lock();
+            match &state.phase {
+                ExternalGetStartSharedPhase::Starting => {
+                    notified.as_mut().enable();
+                    true
+                }
+                ExternalGetStartSharedPhase::Running { prefix, .. }
+                | ExternalGetStartSharedPhase::Ready { prefix, .. } => {
+                    return Ok(prefix.clone());
+                }
+                ExternalGetStartSharedPhase::Failed {
+                    error_code,
+                    error_json,
+                } => return Err(KvError::from_json(*error_code, error_json)),
+            }
+        };
+        if should_wait {
+            notified.await;
+        }
+    }
+}
+
+async fn wait_external_get_start_transfer(
+    shared_op: Arc<ExternalGetStartSharedOp>,
+) -> KvResult<(Vec<String>, Vec<ExternalGetStartSharedItemResult>)> {
+    loop {
+        let notified = shared_op.notify.notified();
+        futures::pin_mut!(notified);
+        let should_wait = {
+            let state = shared_op.state.lock();
+            match &state.phase {
+                ExternalGetStartSharedPhase::Starting
+                | ExternalGetStartSharedPhase::Running { .. } => {
+                    notified.as_mut().enable();
+                    true
+                }
+                ExternalGetStartSharedPhase::Ready { keys, items, .. } => {
+                    return Ok((keys.clone(), items.clone()));
+                }
+                ExternalGetStartSharedPhase::Failed {
+                    error_code,
+                    error_json,
+                } => return Err(KvError::from_json(*error_code, error_json)),
+            }
+        };
+        if should_wait {
+            notified.await;
+        }
+    }
+}
+
+async fn prepare_external_get_start_shared_op(
+    inner: &client_kv_api::ClientKvApiInner,
+    req: &ExternalBatchGetStartReq,
+    group_lens: &[usize],
+) -> KvResult<(
+    ExternalGetStartPrefixResult,
+    Vec<String>,
+    Vec<ExternalGetStartOwnerItem>,
+)> {
+    let mut item_slots: Vec<Option<ExternalGetStartOwnerItem>> =
+        (0..req.keys.len()).map(|_| None).collect();
+    let mut missing_indices = Vec::new();
+    let mut missing_keys = Vec::new();
+
+    for (idx, key) in req.keys.iter().enumerate() {
+        if let Some(memory_info) = inner.local_visible_mem_holder(key) {
+            item_slots[idx] = Some(ExternalGetStartOwnerItem::Local { memory_info });
+        } else {
+            missing_indices.push(idx);
+            missing_keys.push(key.clone());
+        }
+    }
+
+    if !missing_keys.is_empty() {
+        let start_resp = inner.batch_get_start(missing_keys.clone()).await?;
+        if start_resp.items.len() != missing_indices.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_batch_get_start response length mismatch: expected={} got={}",
+                    missing_indices.len(),
+                    start_resp.items.len()
+                ),
+            }));
+        }
+        for ((idx, key), item) in missing_indices
+            .into_iter()
+            .zip(missing_keys.into_iter())
+            .zip(start_resp.items.into_iter())
+        {
+            item_slots[idx] = Some(ExternalGetStartOwnerItem::Started { key, item });
+        }
+    }
+
+    let items = item_slots
+        .into_iter()
+        .map(|item| {
+            item.ok_or_else(|| {
+                KvError::Api(ApiError::Unknown {
+                    detail: "external_batch_get_start item slot was not populated".to_string(),
+                })
+            })
+        })
+        .collect::<KvResult<Vec<_>>>()?;
+    let item_codes = items
+        .iter()
+        .map(|item| match item {
+            ExternalGetStartOwnerItem::Local { .. } => (OK, String::new()),
+            ExternalGetStartOwnerItem::Started { item, .. } => {
+                (item.error_code, item.error_json.clone())
+            }
+        })
+        .collect::<Vec<_>>();
+    let (raw_prefix_hit_len, first_miss_index, first_error_kind) =
+        compute_external_get_start_raw_prefix(&item_codes);
+    let transferable_len = compute_external_get_start_transfer_prefix(
+        raw_prefix_hit_len,
+        group_lens,
+        req.prefix_best_effort,
+    );
+    if let Some(error_kind) = first_error_kind.as_ref() {
+        tracing::warn!(
+            "external_batch_get_start prefix stopped on non-key-miss item: req_node_id={} raw_prefix_hit_len={} transferable_len={} first_miss_index={:?} error_kind={}",
+            req.req_node_id,
+            raw_prefix_hit_len,
+            transferable_len,
+            first_miss_index,
+            error_kind
+        );
+    }
+
+    let revoke_get_ids = items
+        .iter()
+        .skip(transferable_len)
+        .filter_map(|item| match item {
+            ExternalGetStartOwnerItem::Started { item, .. } if item.error_code == OK => {
+                Some(item.get_id)
+            }
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+    if !revoke_get_ids.is_empty() {
+        inner.batch_get_revoke(revoke_get_ids).await?;
+    }
+
+    let transfer_keys = req.keys[..transferable_len].to_vec();
+    let transfer_items = items.into_iter().take(transferable_len).collect::<Vec<_>>();
+    Ok((
+        ExternalGetStartPrefixResult {
+            raw_prefix_hit_len,
+            transferable_len,
+            first_miss_index,
+            first_error_kind,
+        },
+        transfer_keys,
+        transfer_items,
+    ))
+}
+
 impl ClientKvApi {
     fn is_side_transfer_worker(&self) -> bool {
         self.inner()
@@ -253,8 +761,15 @@ impl ClientKvApi {
         let commit_req = MsgPack {
             serialize_part: ExternalPutCommitReq {
                 key: req.key.clone(),
+                len: req.len,
+                src_offset: req.src_offset,
+                remote_target: req
+                    .peer_id
+                    .as_deref()
+                    .is_some_and(|peer| peer != owner_id.as_str()),
                 put_id: Some(put_id),
                 lease_id: req.lease_id,
+                write_through: req.write_through,
                 started_time: req.started_time,
                 test_observe_put_phases: req.test_observe_put_phases,
             },
@@ -298,22 +813,55 @@ pub trait HandlerForExternalClient {
     /// Validate external's observed owner start_time (0 means skip validation for legacy callers)
     fn validate_requester_owner_status_updated(&self, started_time: i64) -> KvResult<()>;
     async fn external_get(&self, req: ExternalGetReq) -> KvResult<ExternalGetResp>;
+    async fn external_batch_get(&self, req: ExternalBatchGetReq) -> KvResult<ExternalBatchGetResp>;
+    async fn external_batch_get_start(
+        &self,
+        req: ExternalBatchGetStartReq,
+    ) -> KvResult<ExternalBatchGetStartResp>;
+    async fn external_batch_get_transfer(
+        &self,
+        req: ExternalBatchGetTransferReq,
+    ) -> KvResult<ExternalBatchGetTransferResp>;
+    async fn external_batch_get_cancel(
+        &self,
+        req: ExternalBatchGetCancelReq,
+    ) -> KvResult<ExternalBatchGetCancelResp>;
     async fn external_put_start(&self, req: ExternalPutStartReq) -> KvResult<ExternalPutStartResp>;
+    async fn external_batch_put_start(
+        &self,
+        req: ExternalBatchPutStartReq,
+    ) -> KvResult<ExternalBatchPutStartResp>;
     // deprecated: transfer merged into external_put_transfer_end
     async fn external_put_transfer_end(
         &self,
         req: ExternalPutTransferEndReq,
     ) -> KvResult<ExternalPutTransferEndResp>;
+    async fn external_batch_put_transfer_end(
+        &self,
+        req: ExternalBatchPutTransferEndReq,
+    ) -> KvResult<ExternalBatchPutTransferEndResp>;
     async fn external_put_commit(
         &self,
         req: ExternalPutCommitReq,
     ) -> KvResult<ExternalPutCommitResp>;
+    async fn external_batch_put_commit(
+        &self,
+        req: ExternalBatchPutCommitReq,
+    ) -> KvResult<ExternalBatchPutCommitResp>;
     async fn external_put_revoke(
         &self,
         req: ExternalPutRevokeReq,
     ) -> KvResult<ExternalPutRevokeResp>;
     async fn external_delete(&self, req: ExternalDeleteReq) -> KvResult<ExternalDeleteResp>;
     async fn external_is_exist(&self, req: ExternalIsExistReq) -> KvResult<ExternalIsExistResp>;
+    async fn external_batch_is_exist(
+        &self,
+        req: ExternalBatchIsExistReq,
+    ) -> KvResult<ExternalBatchIsExistResp>;
+    async fn external_observability_snapshot(
+        &self,
+        req: ExternalObservabilitySnapshotReq,
+    ) -> KvResult<ExternalObservabilitySnapshotResp>;
 }
 
 /// Handle external get request
@@ -376,6 +924,283 @@ impl HandlerForExternalClient for ClientKvApi {
         })
     }
 
+    async fn external_batch_get(&self, req: ExternalBatchGetReq) -> KvResult<ExternalBatchGetResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported("external_batch_get"));
+        }
+        let inner = self.inner();
+
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        let batch_results = inner.batch_get(req.keys, req.transfer_concurrency).await?;
+        let mut items = Vec::with_capacity(batch_results.len());
+        for item_result in batch_results {
+            match item_result {
+                Ok(Some((memholder, _))) => {
+                    let memory_info = memholder.memory_info();
+                    inner.external_get_holding.insert(
+                        NodeHolderKey::new(req.req_node_id.clone(), memholder.holder_id()),
+                        ExternalHoldingGetInfo {
+                            key: memory_info.key.clone(),
+                            req_node_id: req.req_node_id.clone(),
+                            memory_info,
+                        },
+                    );
+                    items.push(ExternalBatchGetItemResp {
+                        error_code: OK,
+                        error_json: String::new(),
+                        external_memholder_info: Some(ExternalMemHolderInfo {
+                            offset: memholder.get_offset(),
+                            len: memholder.get_length() as u32,
+                            holder_id: memholder.holder_id(),
+                        }),
+                    });
+                }
+                Ok(None) => items.push(ExternalBatchGetItemResp {
+                    error_code:
+                        crate::rpcresp_kvresult_convert::msg_and_error::codes_api::API_KEY_NOT_FOUND,
+                    error_json: "Key not found".to_string(),
+                    external_memholder_info: None,
+                }),
+                Err(err) => items.push(ExternalBatchGetItemResp {
+                    external_memholder_info: None,
+                    ..ExternalBatchGetItemResp::from_error(&err)
+                }),
+            }
+        }
+
+        Ok(ExternalBatchGetResp {
+            items,
+            error_code: OK,
+            error_json: String::new(),
+        })
+    }
+
+    async fn external_batch_get_start(
+        &self,
+        req: ExternalBatchGetStartReq,
+    ) -> KvResult<ExternalBatchGetStartResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported("external_batch_get_start"));
+        }
+        if req.keys.is_empty() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "external_batch_get_start requires at least one key".to_string(),
+            }));
+        }
+        let inner = self.inner();
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        let group_lens =
+            normalize_external_get_start_group_lens(req.keys.len(), req.atomic_group_lens.clone())?;
+        let dedup_key = ExternalGetStartDedupKey {
+            keys: req.keys.clone(),
+            atomic_group_lens: group_lens.clone(),
+            prefix_best_effort: req.prefix_best_effort,
+        };
+        let (shared_op, is_creator) = match inner.external_get_start_by_key.entry(dedup_key.clone())
+        {
+            Entry::Occupied(entry) => {
+                let shared_op = entry.get().clone();
+                register_external_get_start_waiter(&shared_op);
+                (shared_op, false)
+            }
+            Entry::Vacant(entry) => {
+                let shared_op = Arc::new(ExternalGetStartSharedOp::new(
+                    dedup_key,
+                    req.transfer_concurrency,
+                ));
+                entry.insert(shared_op.clone());
+                (shared_op, true)
+            }
+        };
+
+        if is_creator {
+            match prepare_external_get_start_shared_op(inner, &req, &group_lens).await {
+                Ok((prefix, transfer_keys, transfer_items)) => {
+                    {
+                        let mut state = shared_op.state.lock();
+                        state.phase = ExternalGetStartSharedPhase::Running {
+                            prefix: prefix.clone(),
+                            keys: transfer_keys.clone(),
+                        };
+                    }
+                    shared_op.notify.notify_waiters();
+
+                    let transfer_shared_op = shared_op.clone();
+                    let transfer_concurrency = shared_op.transfer_concurrency;
+                    let spawn_view = inner.view.clone_view();
+                    let transfer_view = spawn_view.clone();
+                    spawn_view.spawn("external_get_start_transfer", async move {
+                        let transfer_result = finish_external_get_start_transfer(
+                            transfer_view,
+                            transfer_items,
+                            transfer_concurrency,
+                        )
+                        .await;
+                        publish_external_get_start_ready(
+                            &transfer_shared_op,
+                            transfer_keys,
+                            transfer_result,
+                        );
+                    });
+                }
+                Err(err) => {
+                    publish_external_get_start_failed(&shared_op, &err);
+                    release_external_get_start_waiter(inner, &shared_op);
+                    return Err(err);
+                }
+            }
+        }
+
+        let prefix = match wait_external_get_start_prefix(shared_op.clone()).await {
+            Ok(prefix) => prefix,
+            Err(err) => {
+                release_external_get_start_waiter(inner, &shared_op);
+                return Err(err);
+            }
+        };
+        let handle = inner
+            .next_external_get_start_handle
+            .fetch_add(1, Ordering::Relaxed);
+        inner.external_get_start_registry.insert(
+            handle,
+            Arc::new(ExternalGetStartEntry {
+                req_node_id: req.req_node_id.clone(),
+                shared_op,
+            }),
+        );
+
+        Ok(ExternalBatchGetStartResp {
+            error_code: OK,
+            error_json: String::new(),
+            handle,
+            raw_prefix_hit_len: prefix.raw_prefix_hit_len,
+        })
+    }
+
+    async fn external_batch_get_transfer(
+        &self,
+        req: ExternalBatchGetTransferReq,
+    ) -> KvResult<ExternalBatchGetTransferResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported(
+                "external_batch_get_transfer",
+            ));
+        }
+        let inner = self.inner();
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        let Some((_handle, entry)) = inner.external_get_start_registry.remove(&req.handle) else {
+            return Err(KvError::Api(ApiError::KeyNotFound {
+                key: format!("external_get_start_handle:{}", req.handle),
+            }));
+        };
+        if entry.req_node_id != req.req_node_id {
+            tracing::warn!(
+                "external_batch_get_transfer req_node_id mismatch: handle={} expected={} got={}",
+                req.handle,
+                entry.req_node_id,
+                req.req_node_id
+            );
+        }
+        let shared_op = entry.shared_op.clone();
+        let result = match wait_external_get_start_transfer(shared_op.clone()).await {
+            Ok((keys, shared_items)) => {
+                if shared_items.len() != keys.len() {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "external_batch_get_transfer shared result length mismatch: expected={} got={}",
+                            keys.len(),
+                            shared_items.len()
+                        ),
+                    }))
+                } else {
+                    let mut items = Vec::with_capacity(shared_items.len());
+                    for (key, item_result) in keys.iter().zip(shared_items.into_iter()) {
+                        match item_result {
+                            ExternalGetStartSharedItemResult::Hit { memholder } => {
+                                let memory_info = memholder.memory_info();
+                                inner.external_get_holding.insert(
+                                    NodeHolderKey::new(
+                                        req.req_node_id.clone(),
+                                        memholder.holder_id(),
+                                    ),
+                                    ExternalHoldingGetInfo {
+                                        key: memory_info.key.clone(),
+                                        req_node_id: req.req_node_id.clone(),
+                                        memory_info,
+                                    },
+                                );
+                                items.push(ExternalBatchGetItemResp {
+                                    error_code: OK,
+                                    error_json: String::new(),
+                                    external_memholder_info: Some(ExternalMemHolderInfo {
+                                        offset: memholder.get_offset(),
+                                        len: memholder.get_length() as u32,
+                                        holder_id: memholder.holder_id(),
+                                    }),
+                                });
+                            }
+                            ExternalGetStartSharedItemResult::Miss => {
+                                items.push(ExternalBatchGetItemResp {
+                                    error_code: codes_api::API_KEY_NOT_FOUND,
+                                    error_json: format!("Key not found: {}", key),
+                                    external_memholder_info: None,
+                                });
+                            }
+                            ExternalGetStartSharedItemResult::Error {
+                                error_code,
+                                error_json,
+                            } => {
+                                items.push(ExternalBatchGetItemResp {
+                                    error_code,
+                                    error_json,
+                                    external_memholder_info: None,
+                                });
+                            }
+                        }
+                    }
+                    Ok(ExternalBatchGetTransferResp {
+                        items,
+                        error_code: OK,
+                        error_json: String::new(),
+                    })
+                }
+            }
+            Err(err) => Err(err),
+        };
+        release_external_get_start_waiter(inner, &shared_op);
+        result
+    }
+
+    async fn external_batch_get_cancel(
+        &self,
+        req: ExternalBatchGetCancelReq,
+    ) -> KvResult<ExternalBatchGetCancelResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported("external_batch_get_cancel"));
+        }
+        let inner = self.inner();
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        if let Some((_handle, entry)) = inner.external_get_start_registry.remove(&req.handle) {
+            if entry.req_node_id != req.req_node_id {
+                tracing::warn!(
+                    "external_batch_get_cancel req_node_id mismatch: handle={} expected={} got={}",
+                    req.handle,
+                    entry.req_node_id,
+                    req.req_node_id
+                );
+            }
+            release_external_get_start_waiter(inner, &entry.shared_op);
+        }
+        Ok(ExternalBatchGetCancelResp {
+            error_code: OK,
+            error_json: String::new(),
+        })
+    }
+
     /// Handle external put start request: allocate with native KV op and return offsets.
     /// For remote targets, return a local staging offset (no `peer_id` exposed); owner records
     /// remote context internally and completes transfer during `external_put_transfer_end`.
@@ -396,6 +1221,8 @@ impl HandlerForExternalClient for ClientKvApi {
                 &req.key,
                 req.len as u32,
                 req.reject_if_inflight_same_key,
+                req.reject_if_exist_same_key,
+                req.write_through,
                 req.preferred_sub_cluster.as_deref(),
                 source_node_id,
             )
@@ -428,21 +1255,31 @@ impl HandlerForExternalClient for ClientKvApi {
             // Remote target: external still writes into owner's shared memory (src_offset).
             src_offset
         };
-        if !is_local_target {
-            // Stash remote context for transfer_end: peer_id, target_base_addr, target_offset(remote)
-            let remote_offset = put_start_resp.target_addr - put_start_resp.target_base_addr;
-            inner.external_pending_puts.insert(
-                (
-                    req.key.clone(),
-                    put_start_resp.put_id.0,
-                    put_start_resp.put_id.1,
-                ),
-                ExternalPendingPutCtx {
-                    peer_id: put_start_resp.node_id.clone(),
-                    target_base_addr: put_start_resp.target_base_addr,
-                    target_offset: remote_offset,
+        let remote_offset = put_start_resp.target_addr - put_start_resp.target_base_addr;
+        inner.external_pending_puts.insert(
+            (
+                req.key.clone(),
+                put_start_resp.put_id.0,
+                put_start_resp.put_id.1,
+            ),
+            ExternalPendingPutCtx {
+                peer_id: if is_local_target {
+                    None
+                } else {
+                    Some(put_start_resp.node_id.clone())
                 },
-            );
+                src_offset,
+                target_base_addr: put_start_resp.target_base_addr,
+                target_offset: if is_local_target {
+                    target_offset
+                } else {
+                    remote_offset
+                },
+                len: req.len,
+                preferred_sub_cluster: req.preferred_sub_cluster.clone(),
+            },
+        );
+        if !is_local_target {
             tracing::debug!(
                 "external_put_start stash remote ctx: key={}, put_id=({},{}) peer_id={}, target_base={:#x}, target_off={:#x}, src_off(staging)={:#x}",
                 req.key,
@@ -489,59 +1326,222 @@ impl HandlerForExternalClient for ClientKvApi {
         })
     }
 
-    /// Handle external transfer+end request - transfer data then commit
-    async fn external_put_transfer_end(
+    async fn external_batch_put_start(
         &self,
-        req: ExternalPutTransferEndReq,
-    ) -> KvResult<ExternalPutTransferEndResp> {
+        req: ExternalBatchPutStartReq,
+    ) -> KvResult<ExternalBatchPutStartResp> {
         if self.is_side_transfer_worker() {
-            return self.external_put_transfer_end_side_worker(req).await;
+            return Err(Self::side_transfer_unsupported("external_batch_put_start"));
         }
         let inner = self.inner();
-        let total_started_at = Instant::now();
 
         self.validate_requester_owner_status_updated(req.started_time)?;
 
-        // Extract put_id early so we can revoke on transfer failure
-        let Some(put_id) = req.put_id else {
-            let err = crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
-                crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                    rpc_input_json: format!("missing put_id; key={}", req.key),
-                },
-            );
-            return Ok(ExternalPutTransferEndResp::from_error(&err));
-        };
+        let start_resp = inner
+            .batch_put_start(
+                req.items
+                    .iter()
+                    .map(|item| BatchPutStartItemReq {
+                        key: item.key.clone(),
+                        len: item.len,
+                        reject_if_inflight_same_key: item.reject_if_inflight_same_key,
+                        reject_if_exist_same_key: item.reject_if_exist_same_key,
+                        write_through: item.write_through,
+                        preferred_sub_cluster: item.preferred_sub_cluster.clone(),
+                    })
+                    .collect(),
+            )
+            .await?;
+        if start_resp.items.len() != req.items.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_batch_put_start response length mismatch: expected={} got={}",
+                    req.items.len(),
+                    start_resp.items.len()
+                ),
+            }));
+        }
 
-        // Delegate transfer to owner put_transfer (offset-based) then end
-        // For remote target, ignore caller's target_offset (staging) and use stashed remote ctx.
-        let (peer_id_for_transfer, target_off_for_transfer, target_base_for_transfer) =
-            if let Some(peer) = req.peer_id.clone() {
-                // Remote path requires a stashed context; do not fallback to caller-provided target_offset
-                match inner
-                    .external_pending_puts
-                    .get(&(req.key.clone(), put_id.0, put_id.1))
-                {
-                    Some(ctx) => (
-                        Some(ctx.peer_id.clone()),
-                        ctx.target_offset,
-                        Some(ctx.target_base_addr),
-                    ),
-                    None => match req.target_base_addr {
-                        Some(target_base_addr) => {
-                            (Some(peer.into()), req.target_offset, Some(target_base_addr))
-                        }
-                        None => {
-                            let err = KvError::Unreachable(
-                                crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                                    rpc_input_json: format!(
-                                        "missing pending remote put ctx and caller target_base_addr; key={}, put_id=({},{}), peer_id={}",
-                                        req.key, put_id.0, put_id.1, peer
-                                    ),
-                                },
-                            );
-                            return Ok(ExternalPutTransferEndResp::from_error(&err));
-                        }
+        let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
+        let mut items = Vec::with_capacity(req.items.len());
+        for (req_item, start_item) in req.items.into_iter().zip(start_resp.items.into_iter()) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                start_item.error_code,
+                start_item.error_json.clone(),
+            ) {
+                items.push(ExternalBatchPutStartItemResp {
+                    put_id: None,
+                    ..ExternalBatchPutStartItemResp::from_error(&err)
+                });
+                continue;
+            }
+
+            let src_offset = start_item.src_addr - start_item.src_base_addr;
+            let is_local_target = start_item.node_id == self_node_id;
+            let target_offset = if is_local_target {
+                start_item.target_addr - start_item.target_base_addr
+            } else {
+                src_offset
+            };
+            let remote_offset = start_item.target_addr - start_item.target_base_addr;
+            inner.external_pending_puts.insert(
+                (
+                    req_item.key.clone(),
+                    start_item.put_id.0,
+                    start_item.put_id.1,
+                ),
+                ExternalPendingPutCtx {
+                    peer_id: if is_local_target {
+                        None
+                    } else {
+                        Some(start_item.node_id.clone())
                     },
+                    src_offset,
+                    target_base_addr: start_item.target_base_addr,
+                    target_offset: if is_local_target {
+                        target_offset
+                    } else {
+                        remote_offset
+                    },
+                    len: req_item.len,
+                    preferred_sub_cluster: req_item.preferred_sub_cluster.clone(),
+                },
+            );
+            items.push(ExternalBatchPutStartItemResp {
+                error_code: OK,
+                src_offset,
+                target_offset,
+                transfer_target_offset: if is_local_target {
+                    None
+                } else {
+                    Some(remote_offset)
+                },
+                peer_id: if is_local_target {
+                    None
+                } else {
+                    Some(start_item.node_id)
+                },
+                src_base_addr: start_item.src_base_addr,
+                target_base_addr: start_item.target_base_addr,
+                error_json: String::new(),
+                put_id: Some(start_item.put_id),
+            });
+        }
+
+        Ok(ExternalBatchPutStartResp {
+            items,
+            error_code: OK,
+            error_json: String::new(),
+        })
+    }
+
+    /// Handle external transfer+end request - transfer data then commit
+    async fn external_put_transfer_end(
+        &self,
+        req: ExternalPutTransferEndReq,
+    ) -> KvResult<ExternalPutTransferEndResp> {
+        if self.is_side_transfer_worker() {
+            return self.external_put_transfer_end_side_worker(req).await;
+        }
+        let inner = self.inner();
+        let total_started_at = Instant::now();
+
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        // Extract put_id early so we can revoke on transfer failure
+        let Some(put_id) = req.put_id else {
+            let err = crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
+                crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                    rpc_input_json: format!("missing put_id; key={}", req.key),
+                },
+            );
+            return Ok(ExternalPutTransferEndResp::from_error(&err));
+        };
+
+        let pending_ctx = inner
+            .external_pending_puts
+            .get(&(req.key.clone(), put_id.0, put_id.1))
+            .map(|ctx| ctx.clone());
+        let preferred_sub_cluster = pending_ctx
+            .as_ref()
+            .and_then(|ctx| ctx.preferred_sub_cluster.clone());
+        let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
+        let req_remote_target = req
+            .peer_id
+            .as_deref()
+            .is_some_and(|peer| peer != self_node_id.as_str());
+        let has_remote_append = pending_ctx
+            .as_ref()
+            .and_then(|ctx| ctx.peer_id.as_ref())
+            .is_some();
+        if pending_ctx.is_some() && req_remote_target != has_remote_append {
+            let err = KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "external_put_transfer_end peer_id mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                    req.key, put_id.0, put_id.1, req_remote_target, has_remote_append
+                ),
+            });
+            if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                tracing::warn!(
+                    "external_put_transfer_end put_revoke failed after peer_id mismatch: key={} put_id=({},{}) err={}",
+                    req.key,
+                    put_id.0,
+                    put_id.1,
+                    revoke_err
+                );
+            }
+            inner
+                .external_pending_puts
+                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+            return Ok(ExternalPutTransferEndResp::from_error(&err));
+        }
+
+        // Delegate transfer to owner put_transfer (offset-based) then end
+        // For remote target, ignore caller's target_offset (staging) and use stashed remote ctx.
+        let (peer_id_for_transfer, target_off_for_transfer, target_base_for_transfer) =
+            if let Some(peer) = req.peer_id.clone() {
+                if peer == self_node_id.as_ref() {
+                    (None, req.target_offset, None)
+                } else {
+                    match pending_ctx.as_ref() {
+                        Some(ctx) if ctx.peer_id.is_some() => (
+                            ctx.peer_id.clone(),
+                            ctx.target_offset,
+                            Some(ctx.target_base_addr),
+                        ),
+                        None => match req.target_base_addr {
+                            Some(target_base_addr) => {
+                                (Some(peer.into()), req.target_offset, Some(target_base_addr))
+                            }
+                            None => {
+                                let err = KvError::Unreachable(
+                                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                                        rpc_input_json: format!(
+                                            "missing pending remote put ctx and caller target_base_addr; key={}, put_id=({},{}), peer_id={}",
+                                            req.key, put_id.0, put_id.1, peer
+                                        ),
+                                    },
+                                );
+                                return Ok(ExternalPutTransferEndResp::from_error(&err));
+                            }
+                        },
+                        Some(_) => match req.target_base_addr {
+                            Some(target_base_addr) => {
+                                (Some(peer.into()), req.target_offset, Some(target_base_addr))
+                            }
+                            None => {
+                                let err = KvError::Unreachable(
+                                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                                        rpc_input_json: format!(
+                                            "pending local ctx conflicted with remote external_put_transfer_end; key={}, put_id=({},{}), peer_id={}",
+                                            req.key, put_id.0, put_id.1, peer
+                                        ),
+                                    },
+                                );
+                                return Ok(ExternalPutTransferEndResp::from_error(&err));
+                            }
+                        },
+                    }
                 }
             } else {
                 (None, req.target_offset, None)
@@ -561,34 +1561,54 @@ impl HandlerForExternalClient for ClientKvApi {
         );
 
         let transfer_started_at = Instant::now();
-        if let Err(e) = inner
-            .put_transfer(
-                &req.key,
-                put_id,
-                req.src_offset,
-                target_off_for_transfer,
-                req.len,
-                peer_id_for_transfer,
-                target_base_for_transfer,
-            )
-            .await
-        {
-            tracing::error!("Failed to transfer data: {}", e);
-            // On transfer failure, revoke the put to release resources
-            if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                tracing::warn!(
-                    "put_revoke also failed after transfer error: {}",
-                    revoke_err
-                );
+        let mut put_locality_recorded = false;
+        if req.write_through {
+            let transfer_result = inner
+                .put_transfer(
+                    &req.key,
+                    put_id,
+                    req.src_offset,
+                    target_off_for_transfer,
+                    req.len,
+                    peer_id_for_transfer,
+                    target_base_for_transfer,
+                )
+                .await;
+            match transfer_result {
+                Ok(breakdown) => {
+                    let breakdown_transfer_us = breakdown.submit_blocking_us
+                        + breakdown.create_xfer_req_us
+                        + breakdown.post_xfer_req_us
+                        + breakdown.poll_wait_us;
+                    inner.record_put_locality(
+                        breakdown.remote_transfer,
+                        req.len,
+                        breakdown_transfer_us,
+                    );
+                    put_locality_recorded = true;
+                }
+                Err(e) => {
+                    tracing::error!("Failed to transfer data: {}", e);
+                    // On transfer failure, revoke the put to release resources
+                    if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                        tracing::warn!(
+                            "put_revoke also failed after transfer error: {}",
+                            revoke_err
+                        );
+                    }
+                    // Cleanup pending ctx on failure
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                    return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&e));
+                }
             }
-            // Cleanup pending ctx on failure
-            inner
-                .external_pending_puts
-                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-            return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&e));
         }
 
         let put_transfer_total_us = duration_to_i64_us(transfer_started_at.elapsed());
+        if req.write_through && !put_locality_recorded {
+            inner.record_put_locality(false, req.len, 0);
+        }
 
         if inner.skip_put_end_commit_enabled() {
             inner
@@ -620,8 +1640,41 @@ impl HandlerForExternalClient for ClientKvApi {
         }
 
         let end_started_at = Instant::now();
-        let put_end_stats = match inner.put_end(&req.key, put_id, req.lease_id).await {
-            Ok(stats) => stats,
+        let publish_local_cache = !req.write_through || !req_remote_target;
+        let local_cache_publish = if publish_local_cache {
+            match local_committed_cache_publish(
+                "external_put_transfer_end",
+                &req.key,
+                put_id,
+                pending_ctx.as_ref(),
+                req.src_offset,
+                req.len,
+            ) {
+                Ok(publish) => Some(publish),
+                Err(err) => {
+                    if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                        tracing::warn!(
+                            "external_put_transfer_end put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
+                            req.key,
+                            put_id.0,
+                            put_id.1,
+                            revoke_err
+                        );
+                    }
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                    return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
+                }
+            }
+        } else {
+            None
+        };
+        let put_end = match inner
+            .put_end_with_local_cache_publish(&req.key, put_id, req.lease_id, publish_local_cache)
+            .await
+        {
+            Ok(end) => end,
             Err(e) => {
                 tracing::error!("Failed to end put operation: {}", e);
                 inner
@@ -630,12 +1683,56 @@ impl HandlerForExternalClient for ClientKvApi {
                 return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&e));
             }
         };
+        let put_end_stats = put_end.stats;
         let put_end_total_us = duration_to_i64_us(end_started_at.elapsed());
 
-        // Success; cleanup pending ctx
+        if publish_local_cache {
+            let Some(holder_id) = put_end.local_cache_holder_id else {
+                let err = KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external_put_transfer_end missing local cache holder after local commit: key={} put_id=({},{})",
+                        req.key, put_id.0, put_id.1
+                    ),
+                });
+                inner
+                    .external_pending_puts
+                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
+            };
+            let publish = local_cache_publish
+                .as_ref()
+                .expect("publish_local_cache precheck must provide local cache publish info");
+            inner
+                .install_local_committed_memory_info(
+                    &req.key,
+                    put_id,
+                    publish.src_offset,
+                    publish.len,
+                    holder_id,
+                )
+                .await?;
+        }
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+        if !req.write_through && (has_remote_append || req_remote_target) {
+            if let Err(err) = inner
+                .enqueue_write_back_remote_append(
+                    &req.key,
+                    put_id,
+                    preferred_sub_cluster.as_deref(),
+                )
+                .await
+            {
+                tracing::warn!(
+                    "write-back external_put_transfer_end enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                    req.key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
 
         Ok(ExternalPutTransferEndResp {
             error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
@@ -658,6 +1755,420 @@ impl HandlerForExternalClient for ClientKvApi {
         })
     }
 
+    async fn external_batch_put_transfer_end(
+        &self,
+        req: ExternalBatchPutTransferEndReq,
+    ) -> KvResult<ExternalBatchPutTransferEndResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported(
+                "external_batch_put_transfer_end",
+            ));
+        }
+        let inner = self.inner();
+
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        if req.items.is_empty() {
+            return Ok(ExternalBatchPutTransferEndResp {
+                items: Vec::new(),
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+
+        #[derive(Clone)]
+        struct DonePending {
+            idx: usize,
+            key: String,
+            put_id: crate::master_kv_router::put::PutIDForAKey,
+            lease_id: Option<u64>,
+            len: u64,
+            put_locality: Option<(bool, i64)>,
+            remember_local_snapshot: bool,
+            publish_local_cache: bool,
+            local_cache_publish: Option<LocalCommittedCachePublish>,
+            enqueue_write_back_append: bool,
+            preferred_sub_cluster: Option<String>,
+        }
+
+        let mut results: Vec<Option<ExternalBatchPutTransferEndItemResp>> =
+            (0..req.items.len()).map(|_| None).collect();
+        let mut done_pending = Vec::new();
+        let mut revoke_pending = Vec::new();
+        let mut transfer_futures = Vec::new();
+
+        for (idx, item) in req.items.into_iter().enumerate() {
+            let Some(put_id) = item.put_id else {
+                let err = KvError::Unreachable(
+                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                        rpc_input_json: format!(
+                            "missing put_id in external_batch_put_transfer_end; key={}",
+                            item.key
+                        ),
+                    },
+                );
+                results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                continue;
+            };
+
+            let pending_ctx = inner
+                .external_pending_puts
+                .get(&(item.key.clone(), put_id.0, put_id.1))
+                .map(|ctx| ctx.clone());
+            let preferred_sub_cluster = pending_ctx
+                .as_ref()
+                .and_then(|ctx| ctx.preferred_sub_cluster.clone());
+            let has_remote_append = pending_ctx
+                .as_ref()
+                .and_then(|ctx| ctx.peer_id.as_ref())
+                .is_some();
+            if item.peer_id.is_some() != has_remote_append {
+                let err = KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "external_batch_put_transfer_end peer_id mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                        item.key,
+                        put_id.0,
+                        put_id.1,
+                        item.peer_id.is_some(),
+                        has_remote_append
+                    ),
+                });
+                results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                revoke_pending.push(BatchPutRevokeItemReq {
+                    key: item.key.clone(),
+                    put_id,
+                });
+                inner
+                    .external_pending_puts
+                    .invalidate(&(item.key.clone(), put_id.0, put_id.1));
+                continue;
+            }
+            let remember_local_snapshot = !item.write_through || item.peer_id.is_none();
+            let publish_local_cache = remember_local_snapshot;
+            let enqueue_write_back_append = !item.write_through && item.peer_id.is_some();
+            let local_cache_publish = if publish_local_cache {
+                match local_committed_cache_publish(
+                    "external_batch_put_transfer_end",
+                    &item.key,
+                    put_id,
+                    pending_ctx.as_ref(),
+                    item.src_offset,
+                    item.len,
+                ) {
+                    Ok(publish) => Some(publish),
+                    Err(err) => {
+                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                        revoke_pending.push(BatchPutRevokeItemReq {
+                            key: item.key.clone(),
+                            put_id,
+                        });
+                        inner.external_pending_puts.invalidate(&(
+                            item.key.clone(),
+                            put_id.0,
+                            put_id.1,
+                        ));
+                        continue;
+                    }
+                }
+            } else {
+                None
+            };
+
+            let transfer_args = if let Some(peer) = item.peer_id.clone() {
+                match pending_ctx.as_ref() {
+                    Some(ctx) if ctx.peer_id.is_some() => {
+                        Ok((ctx.peer_id.clone(), ctx.target_offset, Some(ctx.target_base_addr)))
+                    }
+                    None => match item.target_base_addr {
+                        Some(target_base_addr) => {
+                            Ok((Some(peer.into()), item.target_offset, Some(target_base_addr)))
+                        }
+                        None => Err(KvError::Unreachable(
+                            crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                                rpc_input_json: format!(
+                                    "missing pending remote put ctx and caller target_base_addr in external_batch_put_transfer_end; key={}, put_id=({},{}), peer_id={}",
+                                    item.key, put_id.0, put_id.1, peer
+                                ),
+                            },
+                        )),
+                    },
+                    Some(_) => match item.target_base_addr {
+                        Some(target_base_addr) => {
+                            Ok((Some(peer.into()), item.target_offset, Some(target_base_addr)))
+                        }
+                        None => Err(KvError::Unreachable(
+                            crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                                rpc_input_json: format!(
+                                    "pending local ctx conflicted with remote external_batch_put_transfer_end; key={}, put_id=({},{}), peer_id={}",
+                                    item.key, put_id.0, put_id.1, peer
+                                ),
+                            },
+                        )),
+                    },
+                }
+            } else {
+                Ok((None, item.target_offset, None))
+            };
+            let (peer_id_for_transfer, target_off_for_transfer, target_base_for_transfer) =
+                match transfer_args {
+                    Ok(v) => v,
+                    Err(err) => {
+                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                        continue;
+                    }
+                };
+
+            if !item.write_through {
+                done_pending.push(DonePending {
+                    idx,
+                    key: item.key,
+                    put_id,
+                    lease_id: item.lease_id,
+                    len: item.len,
+                    put_locality: Some((false, 0)),
+                    remember_local_snapshot,
+                    publish_local_cache,
+                    local_cache_publish,
+                    enqueue_write_back_append,
+                    preferred_sub_cluster,
+                });
+                continue;
+            }
+
+            transfer_futures.push(async move {
+                let transfer_started_at = Instant::now();
+                let transfer_result = inner
+                    .put_transfer(
+                        &item.key,
+                        put_id,
+                        item.src_offset,
+                        target_off_for_transfer,
+                        item.len,
+                        peer_id_for_transfer,
+                        target_base_for_transfer,
+                    )
+                    .await;
+                (
+                    idx,
+                    item.key,
+                    item.len,
+                    put_id,
+                    item.lease_id,
+                    remember_local_snapshot,
+                    publish_local_cache,
+                    local_cache_publish,
+                    preferred_sub_cluster,
+                    duration_to_i64_us(transfer_started_at.elapsed()),
+                    transfer_result,
+                )
+            });
+        }
+
+        let transfer_concurrency = req.transfer_concurrency.max(1);
+        let mut transfer_stream =
+            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
+        while let Some(joined) = transfer_stream.next().await {
+            match joined {
+                (
+                    idx,
+                    key,
+                    len,
+                    put_id,
+                    lease_id,
+                    remember_local_snapshot,
+                    publish_local_cache,
+                    local_cache_publish,
+                    preferred_sub_cluster,
+                    wall_transfer_us,
+                    Ok(breakdown),
+                ) => {
+                    let breakdown_transfer_us = breakdown.submit_blocking_us
+                        + breakdown.create_xfer_req_us
+                        + breakdown.post_xfer_req_us
+                        + breakdown.poll_wait_us;
+                    let transfer_us = breakdown_transfer_us.max(wall_transfer_us);
+                    done_pending.push(DonePending {
+                        idx,
+                        key,
+                        put_id,
+                        lease_id,
+                        len,
+                        put_locality: Some((breakdown.remote_transfer, transfer_us)),
+                        remember_local_snapshot,
+                        publish_local_cache,
+                        local_cache_publish,
+                        enqueue_write_back_append: false,
+                        preferred_sub_cluster,
+                    });
+                }
+                (
+                    idx,
+                    key,
+                    _len,
+                    put_id,
+                    _lease_id,
+                    _remember_local_snapshot,
+                    _publish_local_cache,
+                    _local_cache_publish,
+                    _preferred_sub_cluster,
+                    _wall_transfer_us,
+                    Err(err),
+                ) => {
+                    results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                    revoke_pending.push(BatchPutRevokeItemReq {
+                        key: key.clone(),
+                        put_id,
+                    });
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(key, put_id.0, put_id.1));
+                }
+            }
+        }
+
+        if !revoke_pending.is_empty() {
+            if let Err(err) = inner.batch_put_revoke(revoke_pending).await {
+                tracing::warn!(
+                    "external_batch_put_transfer_end batch_put_revoke failed after transfer errors: {}",
+                    err
+                );
+            }
+        }
+
+        if inner.skip_put_end_commit_enabled() {
+            for pending in done_pending {
+                inner.external_pending_puts.invalidate(&(
+                    pending.key.clone(),
+                    pending.put_id.0,
+                    pending.put_id.1,
+                ));
+                if let Some((remote, transfer_us)) = pending.put_locality {
+                    inner.record_put_locality(remote, pending.len, transfer_us);
+                }
+                results[pending.idx] = Some(ExternalBatchPutTransferEndItemResp {
+                    error_code: OK,
+                    error_json: String::new(),
+                });
+            }
+            return Ok(ExternalBatchPutTransferEndResp {
+                items: results
+                    .into_iter()
+                    .map(|item| {
+                        item.unwrap_or_else(|| ExternalBatchPutTransferEndItemResp {
+                            error_code: OK,
+                            error_json: String::new(),
+                        })
+                    })
+                    .collect(),
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+
+        let done_resp = inner
+            .batch_put_done(
+                done_pending
+                    .iter()
+                    .map(|pending| BatchPutDoneItemReq {
+                        key: pending.key.clone(),
+                        put_id: pending.put_id,
+                        lease_id: pending.lease_id,
+                        committed_slot: None,
+                        publish_local_cache: pending.publish_local_cache,
+                    })
+                    .collect(),
+            )
+            .await?;
+        if done_resp.items.len() != done_pending.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_batch_put_transfer_end done response length mismatch: expected={} got={}",
+                    done_pending.len(),
+                    done_resp.items.len()
+                ),
+            }));
+        }
+
+        for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
+            inner.external_pending_puts.invalidate(&(
+                pending.key.clone(),
+                pending.put_id.0,
+                pending.put_id.1,
+            ));
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                done_item.error_code,
+                done_item.error_json.clone(),
+            ) {
+                results[pending.idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                continue;
+            }
+            if let Some((remote, transfer_us)) = pending.put_locality {
+                inner.record_put_locality(remote, pending.len, transfer_us);
+            }
+            if pending.publish_local_cache {
+                let Some(holder_id) = done_item.local_cache_holder_id else {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "external_batch_put_transfer_end missing local cache holder after local commit: key={} put_id=({},{})",
+                            pending.key, pending.put_id.0, pending.put_id.1
+                        ),
+                    }));
+                };
+                let publish = pending
+                    .local_cache_publish
+                    .as_ref()
+                    .expect("publish_local_cache precheck must provide local cache publish info");
+                inner
+                    .install_local_committed_memory_info(
+                        &pending.key,
+                        pending.put_id,
+                        publish.src_offset,
+                        publish.len,
+                        holder_id,
+                    )
+                    .await?;
+            } else if pending.remember_local_snapshot {
+                inner.remember_local_snapshot(&pending.key, pending.put_id);
+            }
+            if pending.enqueue_write_back_append {
+                if let Err(err) = inner
+                    .enqueue_write_back_remote_append(
+                        &pending.key,
+                        pending.put_id,
+                        pending.preferred_sub_cluster.as_deref(),
+                    )
+                    .await
+                {
+                    tracing::warn!(
+                        "external_batch_put_transfer_end write-back enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        pending.key,
+                        pending.put_id.0,
+                        pending.put_id.1,
+                        err
+                    );
+                }
+            }
+            results[pending.idx] = Some(ExternalBatchPutTransferEndItemResp {
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+
+        Ok(ExternalBatchPutTransferEndResp {
+            items: results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| ExternalBatchPutTransferEndItemResp {
+                        error_code: OK,
+                        error_json: String::new(),
+                    })
+                })
+                .collect(),
+            error_code: OK,
+            error_json: String::new(),
+        })
+    }
+
     async fn external_put_commit(
         &self,
         req: ExternalPutCommitReq,
@@ -675,10 +2186,76 @@ impl HandlerForExternalClient for ClientKvApi {
             );
             return Ok(ExternalPutCommitResp::from_error(&err));
         };
+        let pending_ctx = inner
+            .external_pending_puts
+            .get(&(req.key.clone(), put_id.0, put_id.1))
+            .map(|ctx| ctx.clone());
+        if let Some(ctx) = pending_ctx.as_ref() {
+            let has_remote_append = ctx.peer_id.is_some();
+            if req.remote_target != has_remote_append {
+                let err = KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "external_put_commit remote_target mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                        req.key, put_id.0, put_id.1, req.remote_target, has_remote_append
+                    ),
+                });
+                if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                    tracing::warn!(
+                        "external_put_commit put_revoke failed after remote_target mismatch: key={} put_id=({},{}) err={}",
+                        req.key,
+                        put_id.0,
+                        put_id.1,
+                        revoke_err
+                    );
+                }
+                inner
+                    .external_pending_puts
+                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                return Ok(ExternalPutCommitResp::from_error(&err));
+            }
+        }
+        let remember_local_snapshot = !req.write_through || !req.remote_target;
+        let enqueue_write_back_append = !req.write_through && req.remote_target;
+        let preferred_sub_cluster = pending_ctx
+            .as_ref()
+            .and_then(|ctx| ctx.preferred_sub_cluster.clone());
 
         let end_started_at = Instant::now();
-        let put_end_stats = match inner.put_end(&req.key, put_id, req.lease_id).await {
-            Ok(stats) => stats,
+        let publish_local_cache = remember_local_snapshot;
+        let local_cache_publish = if publish_local_cache {
+            match local_committed_cache_publish(
+                "external_put_commit",
+                &req.key,
+                put_id,
+                pending_ctx.as_ref(),
+                req.src_offset,
+                req.len,
+            ) {
+                Ok(publish) => Some(publish),
+                Err(err) => {
+                    if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                        tracing::warn!(
+                            "external_put_commit put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
+                            req.key,
+                            put_id.0,
+                            put_id.1,
+                            revoke_err
+                        );
+                    }
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                    return Ok(ExternalPutCommitResp::from_error(&err));
+                }
+            }
+        } else {
+            None
+        };
+        let put_end = match inner
+            .put_end_with_local_cache_publish(&req.key, put_id, req.lease_id, publish_local_cache)
+            .await
+        {
+            Ok(end) => end,
             Err(e) => {
                 inner
                     .external_pending_puts
@@ -686,10 +2263,55 @@ impl HandlerForExternalClient for ClientKvApi {
                 return Ok(ExternalPutCommitResp::from_error(&e));
             }
         };
+        let put_end_stats = put_end.stats;
         let put_end_total_us = duration_to_i64_us(end_started_at.elapsed());
+        if publish_local_cache {
+            let Some(holder_id) = put_end.local_cache_holder_id else {
+                let err = KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external_put_commit missing local cache holder after local commit: key={} put_id=({},{})",
+                        req.key, put_id.0, put_id.1
+                    ),
+                });
+                inner
+                    .external_pending_puts
+                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                return Ok(ExternalPutCommitResp::from_error(&err));
+            };
+            let publish = local_cache_publish
+                .as_ref()
+                .expect("publish_local_cache precheck must provide local cache publish info");
+            inner
+                .install_local_committed_memory_info(
+                    &req.key,
+                    put_id,
+                    publish.src_offset,
+                    publish.len,
+                    holder_id,
+                )
+                .await?;
+        }
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+        if enqueue_write_back_append {
+            if let Err(err) = inner
+                .enqueue_write_back_remote_append(
+                    &req.key,
+                    put_id,
+                    preferred_sub_cluster.as_deref(),
+                )
+                .await
+            {
+                tracing::warn!(
+                    "write-back external_put_commit enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                    req.key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
 
         Ok(ExternalPutCommitResp {
             error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
@@ -707,6 +2329,262 @@ impl HandlerForExternalClient for ClientKvApi {
         })
     }
 
+    async fn external_batch_put_commit(
+        &self,
+        req: ExternalBatchPutCommitReq,
+    ) -> KvResult<ExternalBatchPutCommitResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported("external_batch_put_commit"));
+        }
+        let inner = self.inner();
+
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        if req.items.is_empty() {
+            return Ok(ExternalBatchPutCommitResp {
+                items: Vec::new(),
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+
+        #[derive(Clone)]
+        struct DonePending {
+            idx: usize,
+            key: String,
+            put_id: crate::master_kv_router::put::PutIDForAKey,
+            lease_id: Option<u64>,
+            remember_local_snapshot: bool,
+            publish_local_cache: bool,
+            local_cache_publish: Option<LocalCommittedCachePublish>,
+            enqueue_write_back_append: bool,
+            preferred_sub_cluster: Option<String>,
+        }
+
+        let mut results: Vec<Option<ExternalBatchPutCommitItemResp>> =
+            (0..req.items.len()).map(|_| None).collect();
+        let mut done_pending = Vec::new();
+        let mut revoke_pending = Vec::new();
+
+        for (idx, item) in req.items.into_iter().enumerate() {
+            let Some(put_id) = item.put_id else {
+                let err = KvError::Unreachable(
+                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                        rpc_input_json: format!(
+                            "missing put_id in external_batch_put_commit; key={}",
+                            item.key
+                        ),
+                    },
+                );
+                results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                continue;
+            };
+            let pending_ctx = inner
+                .external_pending_puts
+                .get(&(item.key.clone(), put_id.0, put_id.1))
+                .map(|ctx| ctx.clone());
+            if let Some(ctx) = pending_ctx.as_ref() {
+                let has_remote_append = ctx.peer_id.is_some();
+                if item.remote_target != has_remote_append {
+                    let err = KvError::Api(ApiError::InvalidArgument {
+                        detail: format!(
+                            "external_batch_put_commit remote_target mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                            item.key, put_id.0, put_id.1, item.remote_target, has_remote_append
+                        ),
+                    });
+                    results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                    revoke_pending.push(BatchPutRevokeItemReq {
+                        key: item.key.clone(),
+                        put_id,
+                    });
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(item.key.clone(), put_id.0, put_id.1));
+                    continue;
+                }
+            }
+            let remember_local_snapshot = !item.write_through || !item.remote_target;
+            let publish_local_cache = remember_local_snapshot;
+            let local_cache_publish = if publish_local_cache {
+                match local_committed_cache_publish(
+                    "external_batch_put_commit",
+                    &item.key,
+                    put_id,
+                    pending_ctx.as_ref(),
+                    item.src_offset,
+                    item.len,
+                ) {
+                    Ok(publish) => Some(publish),
+                    Err(err) => {
+                        results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                        revoke_pending.push(BatchPutRevokeItemReq {
+                            key: item.key.clone(),
+                            put_id,
+                        });
+                        inner.external_pending_puts.invalidate(&(
+                            item.key.clone(),
+                            put_id.0,
+                            put_id.1,
+                        ));
+                        continue;
+                    }
+                }
+            } else {
+                None
+            };
+            let preferred_sub_cluster = pending_ctx
+                .as_ref()
+                .and_then(|ctx| ctx.preferred_sub_cluster.clone());
+            done_pending.push(DonePending {
+                idx,
+                key: item.key.clone(),
+                put_id,
+                lease_id: item.lease_id,
+                remember_local_snapshot,
+                publish_local_cache,
+                local_cache_publish,
+                enqueue_write_back_append: !item.write_through && item.remote_target,
+                preferred_sub_cluster,
+            });
+        }
+
+        if !revoke_pending.is_empty() {
+            if let Err(err) = inner.batch_put_revoke(revoke_pending).await {
+                tracing::warn!(
+                    "external_batch_put_commit batch_put_revoke failed after local cache publish precheck errors: {}",
+                    err
+                );
+            }
+        }
+
+        if inner.skip_put_end_commit_enabled() {
+            for pending in done_pending {
+                inner.external_pending_puts.invalidate(&(
+                    pending.key.clone(),
+                    pending.put_id.0,
+                    pending.put_id.1,
+                ));
+                results[pending.idx] = Some(ExternalBatchPutCommitItemResp {
+                    error_code: OK,
+                    error_json: String::new(),
+                });
+            }
+            return Ok(ExternalBatchPutCommitResp {
+                items: results
+                    .into_iter()
+                    .map(|item| {
+                        item.unwrap_or_else(|| ExternalBatchPutCommitItemResp {
+                            error_code: OK,
+                            error_json: String::new(),
+                        })
+                    })
+                    .collect(),
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+
+        let done_resp = inner
+            .batch_put_done(
+                done_pending
+                    .iter()
+                    .map(|pending| BatchPutDoneItemReq {
+                        key: pending.key.clone(),
+                        put_id: pending.put_id,
+                        lease_id: pending.lease_id,
+                        committed_slot: None,
+                        publish_local_cache: pending.publish_local_cache,
+                    })
+                    .collect(),
+            )
+            .await?;
+        if done_resp.items.len() != done_pending.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_batch_put_commit done response length mismatch: expected={} got={}",
+                    done_pending.len(),
+                    done_resp.items.len()
+                ),
+            }));
+        }
+
+        for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
+            inner.external_pending_puts.invalidate(&(
+                pending.key.clone(),
+                pending.put_id.0,
+                pending.put_id.1,
+            ));
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                done_item.error_code,
+                done_item.error_json.clone(),
+            ) {
+                results[pending.idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                continue;
+            }
+            if pending.publish_local_cache {
+                let Some(holder_id) = done_item.local_cache_holder_id else {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "external_batch_put_commit missing local cache holder after local commit: key={} put_id=({},{})",
+                            pending.key, pending.put_id.0, pending.put_id.1
+                        ),
+                    }));
+                };
+                let publish = pending
+                    .local_cache_publish
+                    .as_ref()
+                    .expect("publish_local_cache precheck must provide local cache publish info");
+                inner
+                    .install_local_committed_memory_info(
+                        &pending.key,
+                        pending.put_id,
+                        publish.src_offset,
+                        publish.len,
+                        holder_id,
+                    )
+                    .await?;
+            } else if pending.remember_local_snapshot {
+                inner.remember_local_snapshot(&pending.key, pending.put_id);
+            }
+            if pending.enqueue_write_back_append {
+                if let Err(err) = inner
+                    .enqueue_write_back_remote_append(
+                        &pending.key,
+                        pending.put_id,
+                        pending.preferred_sub_cluster.as_deref(),
+                    )
+                    .await
+                {
+                    tracing::warn!(
+                        "external_batch_put_commit write-back enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        pending.key,
+                        pending.put_id.0,
+                        pending.put_id.1,
+                        err
+                    );
+                }
+            }
+            results[pending.idx] = Some(ExternalBatchPutCommitItemResp {
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+
+        Ok(ExternalBatchPutCommitResp {
+            items: results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| ExternalBatchPutCommitItemResp {
+                        error_code: OK,
+                        error_json: String::new(),
+                    })
+                })
+                .collect(),
+            error_code: OK,
+            error_json: String::new(),
+        })
+    }
+
     async fn external_put_revoke(
         &self,
         req: ExternalPutRevokeReq,
@@ -775,4 +2653,46 @@ impl HandlerForExternalClient for ClientKvApi {
             }),
         }
     }
+
+    async fn external_batch_is_exist(
+        &self,
+        req: ExternalBatchIsExistReq,
+    ) -> KvResult<ExternalBatchIsExistResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported("external_batch_is_exist"));
+        }
+        let inner = self.inner();
+
+        self.validate_requester_owner_status_updated(req.started_time)?;
+
+        match inner
+            .batch_is_exist(req.keys, req.allow_local_snapshot)
+            .await
+        {
+            Ok(exists_list) => Ok(ExternalBatchIsExistResp {
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                exists_list,
+                error_json: String::new(),
+            }),
+            Err(e) => Ok(ExternalBatchIsExistResp {
+                exists_list: Vec::new(),
+                ..ExternalBatchIsExistResp::from_error(&e)
+            }),
+        }
+    }
+
+    async fn external_observability_snapshot(
+        &self,
+        req: ExternalObservabilitySnapshotReq,
+    ) -> KvResult<ExternalObservabilitySnapshotResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported(
+                "external_observability_snapshot",
+            ));
+        }
+        self.validate_requester_owner_status_updated(req.started_time)?;
+        Ok(ExternalObservabilitySnapshotResp::success(
+            self.inner().locality_snapshot(),
+        ))
+    }
 }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index f309dd0..88cafa3 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -1,5 +1,4 @@
-use super::ClientKvApiInner;
-use crate::client_kv_api::CachedValue;
+use super::{ClientKvApiInner, GetCachedInfo, KvMetrics};
 use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::memholder::{MemoryInfo, UserMemHolder, UserMemHolderExposeKind};
 // no StageScope; timestamps-based metrics only
@@ -12,6 +11,8 @@ use crate::observe_kvope::{
 use crate::{
     cluster_manager::NodeID,
     master_kv_router::msg_pack::{
+        BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeReq, BatchGetRevokeResp,
+        BatchGetStartItemResp, BatchGetStartReq, BatchGetStartResp, BatchIsExistReq,
         GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetMetaResp, GetRevokeReq,
         GetStartReq, GetStartResp,
     },
@@ -20,7 +21,10 @@ use crate::{
     rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK},
 };
 use chrono::Utc;
+use futures::stream::{self, StreamExt};
+use limit_thirdparty::tokio;
 use std::sync::Arc;
+use std::time::Instant;
 
 #[derive(Debug, Clone)]
 pub struct RemoteGetInfo {
@@ -47,57 +51,293 @@ impl std::fmt::Display for RemoteGetInfo {
     }
 }
 
+impl RemoteGetInfo {
+    pub fn data_len(&self) -> usize {
+        self.data_len
+    }
+
+    pub fn is_remote_transfer(&self) -> bool {
+        self.peer_is_src_or_target
+    }
+}
+
 impl ClientKvApiInner {
-    /// becaused we cached local kv metadata, so we make `MemHolder` with Arc here
-    pub async fn get(
+    pub async fn batch_get_finish_started(
         &self,
-        key: &str,
-    ) -> KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>> {
+        keys: Vec<String>,
+        start_items: Vec<BatchGetStartItemResp>,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
-                detail: "ClientKvApi is shutting down; rejecting get".to_string(),
+                detail: "ClientKvApi is shutting down; rejecting batch_get_finish_started"
+                    .to_string(),
+            }));
+        }
+        if keys.len() != start_items.len() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "batch_get_finish_started length mismatch: keys={} start_items={}",
+                    keys.len(),
+                    start_items.len()
+                ),
             }));
         }
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        #[derive(Clone)]
+        struct DonePending {
+            idx: usize,
+            key: String,
+            start_item: BatchGetStartItemResp,
+            peer_is_remote: bool,
+            transfer_us: i64,
+        }
+
+        let transfer_concurrency = transfer_concurrency.max(1);
         let metrics = self.metrics_handle();
         let client_id = self.client_id_str();
         let node_role = self.node_role();
+        let self_node_id = self.view.cluster_manager().get_self_info().id.clone();
 
-        if let Some(cached_info) = self.get_cached_info.get(key) {
-            if let CachedValue::LocalReplica(memory_info) = &cached_info.value {
-                tracing::debug!(
-                    "cache hit for key: {} with putid({},{}), directly return",
+        let mut results: Vec<
+            Option<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>,
+        > = (0..keys.len()).map(|_| None).collect();
+        let mut done_pending = Vec::new();
+        let mut revoke_get_ids = Vec::new();
+        let mut transfer_futures = Vec::new();
+
+        for (idx, (key, start_item)) in keys.into_iter().zip(start_items.into_iter()).enumerate() {
+            if start_item.error_code == codes_api::API_KEY_NOT_FOUND {
+                results[idx] = Some(Ok(None));
+                continue;
+            }
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                start_item.error_code,
+                start_item.error_json.clone(),
+            ) {
+                results[idx] = Some(Err(err));
+                continue;
+            }
+
+            let peer_id = if start_item.node_id == self_node_id {
+                None
+            } else {
+                Some(start_item.node_id.clone())
+            };
+            let peer_is_remote = peer_id.is_some();
+            let get_id = start_item.get_id;
+            let src_addr = start_item.src_addr;
+            let target_addr = start_item.target_addr;
+            let len = start_item.len;
+
+            if peer_id.is_none() && src_addr == target_addr {
+                done_pending.push(DonePending {
+                    idx,
                     key,
-                    cached_info.put_time_ms,
-                    cached_info.put_version
-                );
-                let user_mem_holder = Arc::new(UserMemHolder::new(
-                    memory_info.clone(),
-                    self.get_or_init_all_memholder_refcount(),
-                    UserMemHolderExposeKind::SegPtr,
-                ));
-                obe_get_cache_hit(
-                    &metrics,
-                    &client_id,
-                    &node_role,
+                    start_item,
+                    peer_is_remote,
+                    transfer_us: 0,
+                });
+                continue;
+            }
+
+            transfer_futures.push(async move {
+                let transfer_started_at = Instant::now();
+                let transfer_result = self
+                    .view
+                    .client_transfer_engine()
+                    .transfer_data_no_copy(peer_id, true, src_addr, target_addr, len, None)
+                    .await
+                    .map_err(|err| {
+                        KvError::Api(ApiError::Transfer {
+                            from_addr: src_addr,
+                            to_addr: target_addr,
+                            len,
+                            error: err.to_string(),
+                        })
+                    });
+                let transfer_us = transfer_started_at
+                    .elapsed()
+                    .as_micros()
+                    .min(i64::MAX as u128) as i64;
+                (
+                    idx,
                     key,
-                    memory_info.len as u64,
+                    start_item,
+                    peer_is_remote,
+                    get_id,
+                    transfer_us,
+                    transfer_result,
+                )
+            });
+        }
+
+        let mut transfer_stream =
+            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
+        while let Some(joined) = transfer_stream.next().await {
+            match joined {
+                (idx, key, start_item, peer_is_remote, _get_id, transfer_us, Ok(_breakdown)) => {
+                    done_pending.push(DonePending {
+                        idx,
+                        key,
+                        start_item,
+                        peer_is_remote,
+                        transfer_us,
+                    });
+                }
+                (idx, _key, _start_item, _peer_is_remote, get_id, _transfer_us, Err(err)) => {
+                    results[idx] = Some(Err(err));
+                    revoke_get_ids.push(get_id);
+                }
+            }
+        }
+
+        if !revoke_get_ids.is_empty() {
+            if let Err(err) = self.batch_get_revoke(revoke_get_ids).await {
+                tracing::warn!("batch_get_revoke failed after transfer errors: {}", err);
+            }
+        }
+
+        let done_resp = self
+            .batch_get_done(
+                done_pending
+                    .iter()
+                    .map(|pending| pending.start_item.get_id)
+                    .collect(),
+            )
+            .await?;
+        if done_resp.items.len() != done_pending.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_get_done response length mismatch: expected={} got={}",
+                    done_pending.len(),
+                    done_resp.items.len()
+                ),
+            }));
+        }
+        let master_node_id: NodeID = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?
+            .into();
+
+        for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                done_item.error_code,
+                done_item.error_json.clone(),
+            ) {
+                results[pending.idx] = Some(Err(err));
+                continue;
+            }
+            let expose_kind = if done_item.allocation_mode == GetAllocationMode::Temporary {
+                UserMemHolderExposeKind::OwnedCopy
+            } else {
+                UserMemHolderExposeKind::SegPtr
+            };
+            let offset = pending.start_item.target_addr - pending.start_item.target_base_addr;
+            let data_len = pending.start_item.len as usize;
+            metrics.record_l2_hit_locality(pending.peer_is_remote, data_len as u64);
+            metrics.record_get_io_locality(
+                pending.peer_is_remote,
+                data_len as u64,
+                pending.transfer_us,
+            );
+            let memory_info = Arc::new(
+                MemoryInfo::new(
+                    offset,
+                    pending.start_item.len as u32,
+                    done_item.holder_id,
+                    pending.key.clone(),
+                    master_node_id.clone(),
+                    self.view.clone(),
+                )
+                .await,
+            );
+            let get_info = RemoteGetInfo {
+                get_id: pending.start_item.get_id,
+                data_len,
+                src_addr: pending.start_item.src_addr,
+                target_addr: pending.start_item.target_addr,
+                node_id: pending.start_item.node_id.clone().into(),
+                peer_is_src_or_target: pending.peer_is_remote,
+            };
+            if done_item.allocation_mode != GetAllocationMode::Temporary {
+                self.get_cached_info.insert(
+                    pending.key.clone(),
+                    GetCachedInfo {
+                        put_time_ms: pending.start_item.put_id.0,
+                        put_version: pending.start_item.put_id.1,
+                        mem_holder: memory_info.clone(),
+                    },
                 );
-                return Ok(Some((user_mem_holder, None)));
+                self.remember_local_snapshot(&pending.key, pending.start_item.put_id);
+                metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
             }
+            let user_mem_holder = Arc::new(UserMemHolder::new(
+                memory_info,
+                self.get_or_init_all_memholder_refcount(),
+                expose_kind,
+            ));
+            results[pending.idx] = Some(Ok(Some((user_mem_holder, Some(get_info)))));
         }
 
-        let lock = self.get_remote_kv_lock.get_lock(key.to_owned());
-        let _guard = lock.lock().await;
+        Ok(results
+            .into_iter()
+            .map(|item| {
+                item.unwrap_or_else(|| {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: "batch_get_finish_started result slot was not populated"
+                            .to_string(),
+                    }))
+                })
+            })
+            .collect())
+    }
 
-        // Recheck after acquiring the miss lock so concurrent cache-fillers can collapse here
-        // without forcing every cache hit through the async lock path.
-        if let Some(cached_info) = self.get_cached_info.get(key) {
-            if let CachedValue::LocalReplica(memory_info) = &cached_info.value {
+    pub async fn batch_get(
+        &self,
+        keys: Vec<String>,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_get".to_string(),
+            }));
+        }
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        #[derive(Clone)]
+        struct DonePending {
+            idx: usize,
+            key: String,
+            start_item: crate::master_kv_router::msg_pack::BatchGetStartItemResp,
+            peer_is_remote: bool,
+            transfer_us: i64,
+        }
+
+        let transfer_concurrency = transfer_concurrency.max(1);
+        let metrics = self.metrics_handle();
+        let client_id = self.client_id_str();
+        let node_role = self.node_role();
+        let self_node_id = self.view.cluster_manager().get_self_info().id.clone();
+
+        let mut results: Vec<
+            Option<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>,
+        > = (0..keys.len()).map(|_| None).collect();
+        let mut missing_indices = Vec::new();
+        let mut missing_keys = Vec::new();
+
+        for (idx, key) in keys.iter().enumerate() {
+            if let Some(memory_info) = self.local_visible_mem_holder(key) {
                 tracing::debug!(
-                    "cache hit after miss-lock for key: {} with putid({},{}), directly return",
-                    key,
-                    cached_info.put_time_ms,
-                    cached_info.put_version
+                    "batch_get local visible hit for key: {}, directly return",
+                    key
                 );
                 let user_mem_holder = Arc::new(UserMemHolder::new(
                     memory_info.clone(),
@@ -111,8 +351,368 @@ impl ClientKvApiInner {
                     key,
                     memory_info.len as u64,
                 );
-                return Ok(Some((user_mem_holder, None)));
+                metrics.record_get_io_locality(false, memory_info.len as u64, 0);
+                results[idx] = Some(Ok(Some((user_mem_holder, None))));
+            } else {
+                obe_get_cache_miss(&metrics, &client_id, &node_role, key);
+                missing_indices.push(idx);
+                missing_keys.push(key.clone());
+            }
+        }
+
+        if missing_keys.is_empty() {
+            return Ok(results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| {
+                        Err(KvError::Api(ApiError::Unknown {
+                            detail: "batch_get result slot was not populated".to_string(),
+                        }))
+                    })
+                })
+                .collect());
+        }
+
+        let start_resp = self.batch_get_start(missing_keys.clone()).await?;
+        if start_resp.items.len() != missing_keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_get_start response length mismatch: expected={} got={}",
+                    missing_keys.len(),
+                    start_resp.items.len()
+                ),
+            }));
+        }
+
+        let mut done_pending = Vec::new();
+        let mut revoke_get_ids = Vec::new();
+        let mut transfer_futures = Vec::new();
+
+        for ((idx, key), start_item) in missing_indices
+            .into_iter()
+            .zip(missing_keys.into_iter())
+            .zip(start_resp.items.into_iter())
+        {
+            if start_item.error_code == codes_api::API_KEY_NOT_FOUND {
+                results[idx] = Some(Ok(None));
+                continue;
+            }
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                start_item.error_code,
+                start_item.error_json.clone(),
+            ) {
+                results[idx] = Some(Err(err));
+                continue;
+            }
+
+            let peer_id = if start_item.node_id == self_node_id {
+                None
+            } else {
+                Some(start_item.node_id.clone())
+            };
+            let peer_is_remote = peer_id.is_some();
+            let get_id = start_item.get_id;
+            let src_addr = start_item.src_addr;
+            let target_addr = start_item.target_addr;
+            let len = start_item.len;
+
+            if peer_id.is_none() && src_addr == target_addr {
+                done_pending.push(DonePending {
+                    idx,
+                    key,
+                    start_item,
+                    peer_is_remote,
+                    transfer_us: 0,
+                });
+                continue;
+            }
+
+            transfer_futures.push(async move {
+                let transfer_started_at = Instant::now();
+                let transfer_result = self
+                    .view
+                    .client_transfer_engine()
+                    .transfer_data_no_copy(peer_id, true, src_addr, target_addr, len, None)
+                    .await
+                    .map_err(|err| {
+                        KvError::Api(ApiError::Transfer {
+                            from_addr: src_addr,
+                            to_addr: target_addr,
+                            len,
+                            error: err.to_string(),
+                        })
+                    });
+                let transfer_us = transfer_started_at
+                    .elapsed()
+                    .as_micros()
+                    .min(i64::MAX as u128) as i64;
+                (
+                    idx,
+                    key,
+                    start_item,
+                    peer_is_remote,
+                    get_id,
+                    transfer_us,
+                    transfer_result,
+                )
+            });
+        }
+
+        let mut transfer_stream =
+            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
+        while let Some(joined) = transfer_stream.next().await {
+            match joined {
+                (idx, key, start_item, peer_is_remote, _get_id, transfer_us, Ok(_breakdown)) => {
+                    done_pending.push(DonePending {
+                        idx,
+                        key,
+                        start_item,
+                        peer_is_remote,
+                        transfer_us,
+                    });
+                }
+                (idx, _key, _start_item, _peer_is_remote, get_id, _transfer_us, Err(err)) => {
+                    results[idx] = Some(Err(err));
+                    revoke_get_ids.push(get_id);
+                }
+            }
+        }
+
+        if !revoke_get_ids.is_empty() {
+            if let Err(err) = self.batch_get_revoke(revoke_get_ids).await {
+                tracing::warn!("batch_get_revoke failed after transfer errors: {}", err);
+            }
+        }
+
+        let done_resp = self
+            .batch_get_done(
+                done_pending
+                    .iter()
+                    .map(|pending| pending.start_item.get_id)
+                    .collect(),
+            )
+            .await?;
+        if done_resp.items.len() != done_pending.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_get_done response length mismatch: expected={} got={}",
+                    done_pending.len(),
+                    done_resp.items.len()
+                ),
+            }));
+        }
+        let master_node_id: NodeID = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?
+            .into();
+
+        for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                done_item.error_code,
+                done_item.error_json.clone(),
+            ) {
+                results[pending.idx] = Some(Err(err));
+                continue;
+            }
+            let expose_kind = if done_item.allocation_mode == GetAllocationMode::Temporary {
+                UserMemHolderExposeKind::OwnedCopy
+            } else {
+                UserMemHolderExposeKind::SegPtr
+            };
+            let offset = pending.start_item.target_addr - pending.start_item.target_base_addr;
+            let data_len = pending.start_item.len as usize;
+            metrics.record_l2_hit_locality(pending.peer_is_remote, data_len as u64);
+            metrics.record_get_io_locality(
+                pending.peer_is_remote,
+                data_len as u64,
+                pending.transfer_us,
+            );
+            let memory_info = Arc::new(
+                MemoryInfo::new(
+                    offset,
+                    pending.start_item.len as u32,
+                    done_item.holder_id,
+                    pending.key.clone(),
+                    master_node_id.clone(),
+                    self.view.clone(),
+                )
+                .await,
+            );
+            let get_info = RemoteGetInfo {
+                get_id: pending.start_item.get_id,
+                data_len,
+                src_addr: pending.start_item.src_addr,
+                target_addr: pending.start_item.target_addr,
+                node_id: pending.start_item.node_id.clone().into(),
+                peer_is_src_or_target: pending.peer_is_remote,
+            };
+            if done_item.allocation_mode != GetAllocationMode::Temporary {
+                self.get_cached_info.insert(
+                    pending.key.clone(),
+                    GetCachedInfo {
+                        put_time_ms: pending.start_item.put_id.0,
+                        put_version: pending.start_item.put_id.1,
+                        mem_holder: memory_info.clone(),
+                    },
+                );
+                self.remember_local_snapshot(&pending.key, pending.start_item.put_id);
+                metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
             }
+            let user_mem_holder = Arc::new(UserMemHolder::new(
+                memory_info,
+                self.get_or_init_all_memholder_refcount(),
+                expose_kind,
+            ));
+            results[pending.idx] = Some(Ok(Some((user_mem_holder, Some(get_info)))));
+        }
+
+        Ok(results
+            .into_iter()
+            .map(|item| {
+                item.unwrap_or_else(|| {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: "batch_get result slot was not populated".to_string(),
+                    }))
+                })
+            })
+            .collect())
+    }
+
+    pub async fn batch_is_exist(
+        &self,
+        keys: Vec<String>,
+        allow_local_snapshot: bool,
+    ) -> KvResult<Vec<bool>> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_is_exist".to_string(),
+            }));
+        }
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let mut results = vec![false; keys.len()];
+        let mut missing_indices = Vec::new();
+        let mut missing_keys = Vec::new();
+        for (idx, key) in keys.iter().enumerate() {
+            if allow_local_snapshot && self.has_local_snapshot(key) {
+                results[idx] = true;
+                continue;
+            }
+            missing_indices.push(idx);
+            missing_keys.push(key.clone());
+        }
+        if missing_keys.is_empty() {
+            return Ok(results);
+        }
+
+        let req = MsgPack {
+            serialize_part: BatchIsExistReq { keys: missing_keys },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_is_exist
+            .call(self.view.p2p_module(), master_node_id.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        let resp_part = resp.serialize_part;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp_part.error_code,
+            resp_part.error_json.clone(),
+        )?;
+        if resp_part.exists_list.len() != missing_indices.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_is_exist response length mismatch: expected={} got={}",
+                    missing_indices.len(),
+                    resp_part.exists_list.len()
+                ),
+            }));
+        }
+        for (idx, exists) in missing_indices
+            .into_iter()
+            .zip(resp_part.exists_list.into_iter())
+        {
+            results[idx] = exists;
+        }
+        Ok(results)
+    }
+
+    pub async fn is_exist_with_local_snapshot(
+        &self,
+        key: &str,
+        allow_local_snapshot: bool,
+    ) -> KvResult<bool> {
+        let mut results = self
+            .batch_is_exist(vec![key.to_string()], allow_local_snapshot)
+            .await?;
+        Ok(results.pop().unwrap_or(false))
+    }
+
+    /// becaused we cached local kv metadata, so we make `MemHolder` with Arc here
+    pub async fn get(
+        &self,
+        key: &str,
+    ) -> KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting get".to_string(),
+            }));
+        }
+        let metrics = self.metrics_handle();
+        let client_id = self.client_id_str();
+        let node_role = self.node_role();
+
+        if let Some(memory_info) = self.local_visible_mem_holder(key) {
+            // exist, directly return
+            tracing::debug!("local visible cache hit for key: {}, directly return", key);
+            // Build a fresh UserMemHolder from cached MemoryInfo
+            let user_mem_holder = Arc::new(UserMemHolder::new(
+                memory_info.clone(),
+                self.get_or_init_all_memholder_refcount(),
+                UserMemHolderExposeKind::SegPtr,
+            ));
+            obe_get_cache_hit(
+                &metrics,
+                &client_id,
+                &node_role,
+                key,
+                memory_info.len as u64,
+            );
+            return Ok(Some((user_mem_holder, None)));
+        }
+
+        let lock = self.get_remote_kv_lock.get_lock(key.to_owned());
+        let _guard = lock.lock().await;
+
+        // Recheck after acquiring the miss lock so concurrent cache-fillers can collapse here
+        // without forcing every cache hit through the async lock path.
+        if let Some(memory_info) = self.local_visible_mem_holder(key) {
+            tracing::debug!(
+                "local visible cache hit after miss-lock for key: {}, directly return",
+                key
+            );
+            let user_mem_holder = Arc::new(UserMemHolder::new(
+                memory_info.clone(),
+                self.get_or_init_all_memholder_refcount(),
+                UserMemHolderExposeKind::SegPtr,
+            ));
+            obe_get_cache_hit(
+                &metrics,
+                &client_id,
+                &node_role,
+                key,
+                memory_info.len as u64,
+            );
+            return Ok(Some((user_mem_holder, None)));
         }
 
         obe_get_cache_miss(&metrics, &client_id, &node_role, key);
@@ -333,7 +933,15 @@ impl ClientKvApiInner {
         };
 
         if done_resp.allocation_mode != GetAllocationMode::Temporary {
-            self.cache_local_replica_after_get(key, put_id, memory_info.clone());
+            self.get_cached_info.insert(
+                key.to_string(),
+                GetCachedInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                    mem_holder: memory_info.clone(),
+                },
+            );
+            self.remember_local_snapshot(key, put_id);
             metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
         }
         let user_mem_holder = Arc::new(UserMemHolder::new(
@@ -347,28 +955,7 @@ impl ClientKvApiInner {
     }
 
     pub async fn is_exist(&self, key: &str) -> KvResult<bool> {
-        if !self.view.register_shutdown_poller().is_running() {
-            return Err(KvError::Api(ApiError::SystemShutdown {
-                detail: "ClientKvApi is shutting down; rejecting is_exist".to_string(),
-            }));
-        }
-        let resp = self.get_meta(key).await?;
-        if resp.error_code != OK {
-            // If error code indicates key not found, return false
-            if resp.error_code
-                == crate::rpcresp_kvresult_convert::msg_and_error::codes_api::API_KEY_NOT_FOUND
-            {
-                return Ok(false);
-            }
-            // For other errors, propagate the error
-            crate::rpcresp_kvresult_convert::try_from_code(
-                resp.error_code,
-                resp.error_json.clone(),
-            )?;
-            unreachable!("error path should have returned above");
-        }
-
-        Ok(resp.exists)
+        self.is_exist_with_local_snapshot(key, false).await
     }
 
     /// Get metadata for a key without transferring data
@@ -433,6 +1020,33 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
+    pub async fn batch_get_start(&self, keys: Vec<String>) -> KvResult<BatchGetStartResp> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_get_start".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchGetStartReq { keys },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_get_start
+            .call(self.view.p2p_module(), master_node_id.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
     /// 撤销 Get 操作，释放已分配的资源
     pub async fn get_revoke(&self, get_id: u64) -> KvResult<()> {
         let req = MsgPack {
@@ -457,6 +1071,35 @@ impl ClientKvApiInner {
         Ok(())
     }
 
+    pub async fn batch_get_revoke(&self, get_ids: Vec<u64>) -> KvResult<BatchGetRevokeResp> {
+        if get_ids.is_empty() {
+            return Ok(BatchGetRevokeResp {
+                items: Vec::new(),
+                error_code: OK,
+                error_json: String::new(),
+            });
+        }
+        let req = MsgPack {
+            serialize_part: BatchGetRevokeReq { get_ids },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_get_revoke
+            .call(self.view.p2p_module(), master_node_id.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
     /// 完成 Get 操作，清理资源
     pub async fn get_done(&self, get_id: u64) -> KvResult<GetDoneResp> {
         let req = MsgPack {
@@ -480,4 +1123,34 @@ impl ClientKvApiInner {
 
         Ok(resp.serialize_part)
     }
+
+    pub async fn batch_get_done(&self, get_ids: Vec<u64>) -> KvResult<BatchGetDoneResp> {
+        if get_ids.is_empty() {
+            return Ok(BatchGetDoneResp {
+                items: Vec::new(),
+                error_code: OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        let req = MsgPack {
+            serialize_part: BatchGetDoneReq { get_ids },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_get_done
+            .call(self.view.p2p_module(), master_node_id.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
 }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
new file mode 100644
index 0000000..016f735
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
@@ -0,0 +1,308 @@
+use super::{
+    ClientKvApiInner, ClientKvApiView, OwnerLocalReserveClassState, OwnerLocalReservePoolState,
+};
+use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
+use limit_thirdparty::tokio;
+use std::time::{Duration, Instant};
+
+const OWNER_LOCAL_RESERVE_REBALANCE_INTERVAL: Duration = Duration::from_millis(200);
+const OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN: Duration = Duration::from_secs(5);
+const OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN: Duration = Duration::from_secs(1);
+const OWNER_LOCAL_RESERVE_DEFAULT_SOFT_WAIT_TIMEOUT: Duration = Duration::from_millis(10);
+const OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT: Duration = Duration::from_secs(1);
+const OWNER_LOCAL_RESERVE_GROW_FACTOR_NUM: usize = 2;
+const OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS: usize = 0;
+
+#[derive(Debug, Clone, Copy)]
+struct RebalanceClassSnapshot {
+    slot_size: u64,
+    slots_per_grant: u32,
+    used_slots: usize,
+    grant_count: usize,
+    pending_slot_demand: usize,
+}
+
+fn owner_local_reserve_round_up_grants(bytes: u64) -> u64 {
+    let quantum = OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
+    if bytes == 0 {
+        return 0;
+    }
+    let rem = bytes % quantum;
+    if rem == 0 {
+        bytes
+    } else {
+        bytes.checked_add(quantum - rem).unwrap_or(u64::MAX)
+    }
+}
+
+fn owner_local_reserve_target_bytes(
+    slot_size: u64,
+    used_slots: usize,
+    pending_slot_demand: usize,
+) -> u64 {
+    let required_slots = used_slots.saturating_add(pending_slot_demand);
+    let required_bytes = (required_slots as u64).saturating_mul(slot_size);
+    let doubled_used = (used_slots as u64)
+        .saturating_mul(slot_size)
+        .saturating_mul(OWNER_LOCAL_RESERVE_GROW_FACTOR_NUM as u64);
+    required_bytes.max(doubled_used)
+}
+
+fn owner_local_reserve_target_grant_count(
+    slot_size: u64,
+    used_slots: usize,
+    pending_slot_demand: usize,
+) -> usize {
+    let target_bytes = owner_local_reserve_target_bytes(slot_size, used_slots, pending_slot_demand);
+    let rounded = owner_local_reserve_round_up_grants(target_bytes);
+    if rounded == 0 {
+        return 0;
+    }
+    (rounded / OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES) as usize
+}
+
+fn snapshot_rebalance_classes(pool: &OwnerLocalReservePoolState) -> Vec<RebalanceClassSnapshot> {
+    pool.classes
+        .values()
+        .map(|class_state| RebalanceClassSnapshot {
+            slot_size: class_state.slot_size,
+            slots_per_grant: class_state.slots_per_grant,
+            used_slots: class_state.used_slot_count(),
+            grant_count: class_state.grant_count(),
+            pending_slot_demand: class_state.pending_slot_demand,
+        })
+        .collect()
+}
+
+pub(crate) fn owner_local_reserve_timeout_config(inner: &ClientKvApiInner) -> (Duration, Duration) {
+    let soft_wait_timeout = inner
+        .test_spec_config
+        .owner_local_reserve_soft_wait_timeout_ms
+        .map(Duration::from_millis)
+        .unwrap_or(OWNER_LOCAL_RESERVE_DEFAULT_SOFT_WAIT_TIMEOUT);
+    let hard_timeout = inner
+        .test_spec_config
+        .owner_local_reserve_hard_timeout_ms
+        .map(Duration::from_millis)
+        .unwrap_or(OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT);
+    (soft_wait_timeout, hard_timeout)
+}
+
+async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnapshot) {
+    if snapshot.pending_slot_demand == 0 {
+        return;
+    }
+    if snapshot.slot_size > OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
+        tracing::error!(
+            "owner local reserve refill rejected oversized slot_size={} quantum={} pending_slots={}",
+            snapshot.slot_size,
+            OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
+            snapshot.pending_slot_demand
+        );
+        return;
+    }
+    let target_grants = owner_local_reserve_target_grant_count(
+        snapshot.slot_size,
+        snapshot.used_slots,
+        snapshot.pending_slot_demand,
+    );
+    if snapshot.grant_count >= target_grants {
+        return;
+    }
+    let additional_grants = target_grants - snapshot.grant_count;
+    for _ in 0..additional_grants {
+        let grant = match inner.reserve_local_grant().await {
+            Ok(grant) => grant,
+            Err(err) => {
+                tracing::warn!(
+                    "owner local reserve refill failed: slot_size={} pending_slots={} err={}",
+                    snapshot.slot_size,
+                    snapshot.pending_slot_demand,
+                    err
+                );
+                return;
+            }
+        };
+        if grant.len != OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
+            tracing::warn!(
+                "owner local reserve refill got unexpected grant size: requested={} got={}",
+                OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
+                grant.len
+            );
+            if let Err(release_err) = inner.release_local_grant(grant.grant_id).await {
+                tracing::warn!(
+                    "owner local reserve refill failed to release mismatched grant_id={} err={}",
+                    grant.grant_id,
+                    release_err
+                );
+            }
+            return;
+        }
+        let detached_grant = super::OwnerLocalReserveGrantState::new(
+            grant.grant_id,
+            grant.base_addr,
+            grant.addr,
+            grant.len,
+            snapshot.slot_size,
+            snapshot.slots_per_grant,
+        );
+        {
+            let mut pool = inner.owner_local_reserve_pool.lock();
+            let class_state = pool.classes.entry(snapshot.slot_size).or_insert_with(|| {
+                OwnerLocalReserveClassState::new(snapshot.slot_size, snapshot.slots_per_grant)
+            });
+            class_state.last_grow_at = Some(Instant::now());
+            class_state.grants.push(detached_grant);
+        }
+        inner
+            .owner_local_reserve_rebalance_notify()
+            .notify_waiters();
+    }
+}
+
+async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnapshot) {
+    let detached = {
+        let mut pool = inner.owner_local_reserve_pool.lock();
+        let Some(class_state) = pool.classes.get_mut(&snapshot.slot_size) else {
+            return;
+        };
+        if class_state.pending_slot_demand > 0 {
+            return;
+        }
+        let grow_cooldown_ok = class_state
+            .last_grow_at
+            .map(|last_grow_at| last_grow_at.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN)
+            .unwrap_or(true);
+        if !grow_cooldown_ok {
+            return;
+        }
+        let shrink_keep_grants = owner_local_reserve_target_grant_count(
+            class_state.slot_size,
+            class_state.used_slot_count(),
+            class_state.pending_slot_demand,
+        )
+        .max(OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS);
+        if class_state.grants.len() <= shrink_keep_grants {
+            return;
+        }
+        let should_detach_tail = class_state
+            .grants
+            .last()
+            .map(|grant| {
+                grant.is_fully_free()
+                    && grant
+                        .fully_free_since
+                        .map(|since| since.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN)
+                        .unwrap_or(false)
+            })
+            .unwrap_or(false);
+        if !should_detach_tail {
+            return;
+        }
+        Some(
+            class_state
+                .grants
+                .pop()
+                .expect("tail grant must exist when shrinking local reserve"),
+        )
+    };
+
+    let Some(grant) = detached else {
+        return;
+    };
+
+    if let Err(err) = inner.release_local_grant(grant.grant_id).await {
+        tracing::warn!(
+            "owner local reserve shrink failed to release grant_id={} err={}",
+            grant.grant_id,
+            err
+        );
+        let mut pool = inner.owner_local_reserve_pool.lock();
+        let class_state = pool.classes.entry(snapshot.slot_size).or_insert_with(|| {
+            OwnerLocalReserveClassState::new(snapshot.slot_size, snapshot.slots_per_grant)
+        });
+        class_state.grants.push(grant);
+    }
+}
+
+async fn owner_local_reserve_rebalance_once(view: &ClientKvApiView) {
+    let inner = view.client_kv_api().inner();
+    let snapshots = {
+        let pool = inner.owner_local_reserve_pool.lock();
+        snapshot_rebalance_classes(&pool)
+    };
+    for snapshot in snapshots {
+        try_refill_once(inner, snapshot).await;
+        try_shrink_once(inner, snapshot).await;
+    }
+}
+
+pub fn spawn_owner_local_reserve_rebalance_actor(view: ClientKvApiView) {
+    let view_task = view.clone();
+    view.spawn("owner_local_reserve_rebalance_actor", async move {
+        let shutdown_poller = view_task.register_shutdown_poller();
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        let notify = view_task
+            .client_kv_api()
+            .inner()
+            .owner_local_reserve_rebalance_notify();
+        let mut tick = tokio::time::interval(OWNER_LOCAL_RESERVE_REBALANCE_INTERVAL);
+
+        loop {
+            tokio::select! {
+                biased;
+                _ = shutdown_waiter.wait() => {
+                    tracing::info!("owner local reserve rebalance actor stopped by shutdown");
+                    return;
+                }
+                _ = tick.tick() => {}
+                _ = notify.notified() => {}
+            }
+
+            if !shutdown_poller.is_running() {
+                tracing::info!("owner local reserve rebalance actor stopped by shutdown");
+                return;
+            }
+
+            owner_local_reserve_rebalance_once(&view_task).await;
+        }
+    });
+}
+
+pub async fn wait_owner_local_reserve_ready(
+    inner: &ClientKvApiInner,
+    slot_size: u64,
+    slots_per_grant: u32,
+    key_count: usize,
+    soft_wait_timeout: Duration,
+    hard_deadline: Instant,
+) -> bool {
+    let notify = inner.owner_local_reserve_rebalance_notify();
+    let mut shutdown_waiter = inner.view.register_shutdown_waiter();
+    loop {
+        let notified = notify.notified();
+        {
+            let mut pool = inner.owner_local_reserve_pool.lock();
+            let class_state = pool
+                .classes
+                .entry(slot_size)
+                .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+            if class_state.free_slot_count() >= key_count {
+                return true;
+            }
+        }
+
+        let Some(remaining_hard) = hard_deadline.checked_duration_since(Instant::now()) else {
+            return false;
+        };
+        let wait_budget = remaining_hard.min(soft_wait_timeout);
+
+        tokio::select! {
+            _ = shutdown_waiter.wait() => return false,
+            _ = tokio::time::sleep(wait_budget) => {
+                inner.owner_local_reserve_rebalance_notify().notify_waiters();
+            }
+            _ = notified => {}
+        }
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index dec19f5..7f723f0 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -1,15 +1,25 @@
 use crate::client_kv_api::delete::handle_batch_delete_client_kv_meta_cache;
+use crate::client_kv_api::local_reserve_rebalance::spawn_owner_local_reserve_rebalance_actor;
 use crate::client_kv_api::msg_pack::{
-    ExternalDeleteAckReq, ExternalDeleteAckResp, ExternalDeleteReq, ExternalDeleteResp,
-    ExternalGetReq, ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp, ExternalPutCommitReq,
-    ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq,
-    ExternalPutStartResp, ExternalPutTransferEndReq, ExternalPutTransferEndResp, SyncKvToFileReq,
-    SyncKvToFileResp, TestPutPhaseTrace,
+    ExternalBatchGetCancelReq, ExternalBatchGetCancelResp, ExternalBatchGetReq,
+    ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
+    ExternalBatchGetTransferReq, ExternalBatchGetTransferResp, ExternalBatchIsExistReq,
+    ExternalBatchIsExistResp, ExternalBatchPutCommitReq, ExternalBatchPutCommitResp,
+    ExternalBatchPutStartReq, ExternalBatchPutStartResp, ExternalBatchPutTransferEndReq,
+    ExternalBatchPutTransferEndResp, ExternalDeleteAckReq, ExternalDeleteAckResp,
+    ExternalDeleteReq, ExternalDeleteResp, ExternalGetReq, ExternalGetResp, ExternalIsExistReq,
+    ExternalIsExistResp, ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp,
+    ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
+    ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
+    ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
 };
-use crate::cluster_manager::NodeIDString;
+use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::config::TestSpecConfig;
 use crate::master_kv_router::msg_pack::{
-    BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, DeleteClientKvMetaCacheItem,
+    BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchGetDoneReq, BatchGetRevokeReq,
+    BatchGetStartItemResp, BatchGetStartReq, BatchIsExistReq, BatchPreparePutKeysReq,
+    BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq,
+    CountPrefixReq, DeleteClientKvMetaCacheItem,
 };
 use crate::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
 use crate::memholder::{AllMemholderRefCount, MemoryInfo, UserMemHolder};
@@ -20,28 +30,37 @@ use crate::memholder::{
 use crate::{
     client_seg_pool::{ClientSegPool, ClientSegPoolAccessTrait, ResolveSideTransferLaneReq},
     client_transfer_engine::{ClientTransferEngine, ClientTransferEngineAccessTrait},
-    cluster_manager::{ClusterEvent, ClusterManager, ClusterManagerAccessTrait},
+    cluster_manager::{
+        app_logic_ext::{ClusterManagerAppLogicExt, ClusterManagerExtError},
+        ClusterEvent, ClusterManager, ClusterManagerAccessTrait,
+    },
     master_kv_router::msg_pack::{
-        DeleteReq, GetDoneReq, GetMetaReq, GetRevokeReq, GetStartReq, PutDoneReq, PutRevokeReq,
-        PutStartReq,
+        DeleteAckReq, DeleteReq, GetDoneReq, GetMetaReq, GetRevokeReq, GetStartReq,
+        MemHolderKeepAliveReq, PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq, PutDoneReq,
+        PutRevokeReq, PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq,
     },
     metric_reporter::{MetricReporter, MetricReporterAccessTrait},
-    metrics::{MetricsHandle, OperationKind, RequestStage},
+    metrics::{KvLocalitySnapshot, MetricsHandle, OperationKind, RequestStage},
     p2p::{
         msg_pack::{RPCCaller, RPCHandler},
         p2p_module::{P2pModule, P2pModuleAccessTrait},
     },
-    rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult},
+    rpcresp_kvresult_convert::msg_and_error::{ApiError, ErrorCode, KvError, KvResult},
 };
 use async_trait::async_trait;
+use crossbeam::queue::SegQueue;
 use dashmap::DashMap;
-use fluxon_framework::{LogicalModule, define_module};
+use fluxon_framework::{define_module, LogicalModule};
+use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 use fluxon_util::map_lock::AMapLock;
 use limit_thirdparty::tokio;
-use parking_lot::Mutex;
+use parking_lot::{Mutex, RwLock};
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Weak;
 use std::sync::{Arc, OnceLock};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use tracing::warn;
 
 /// Information about a memholder held by external client
@@ -52,26 +71,107 @@ pub struct ExternalHoldingGetInfo {
     pub memory_info: Arc<MemoryInfo>, // The actual memholder being held
 }
 
+#[derive(Clone, Debug, Default)]
+pub struct OwnerRuntimeObserveSnapshot {
+    pub external_get_holding_entries: u64,
+    pub external_get_holding_bytes: u64,
+    pub external_pending_put_entries: u64,
+}
+
 pub use get::RemoteGetInfo;
+pub use put::OwnerReservedPutItem;
 pub mod external_api;
+mod local_reserve_rebalance;
 pub use external_api::HandlerForExternalClient;
 pub type TestObservePutPhaseSink = Arc<Mutex<Option<TestPutPhaseTrace>>>;
+pub type ExternalGetStartTransferOutput =
+    Vec<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>;
 
-#[derive(Debug, Clone)]
-enum CachedValue {
-    MetadataOnly,
-    LocalReplica(Arc<MemoryInfo>),
+pub enum ExternalGetStartOwnerItem {
+    Local {
+        memory_info: Arc<MemoryInfo>,
+    },
+    Started {
+        key: String,
+        item: BatchGetStartItemResp,
+    },
 }
 
-impl CachedValue {
-    fn rank(&self) -> u8 {
-        match self {
-            Self::MetadataOnly => 0,
-            Self::LocalReplica(_) => 1,
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct ExternalGetStartDedupKey {
+    pub keys: Vec<String>,
+    pub atomic_group_lens: Vec<usize>,
+    pub prefix_best_effort: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct ExternalGetStartPrefixResult {
+    pub raw_prefix_hit_len: usize,
+    pub transferable_len: usize,
+    pub first_miss_index: Option<usize>,
+    pub first_error_kind: Option<String>,
+}
+
+#[derive(Clone)]
+pub enum ExternalGetStartSharedItemResult {
+    Hit {
+        memholder: Arc<UserMemHolder>,
+    },
+    Miss,
+    Error {
+        error_code: ErrorCode,
+        error_json: String,
+    },
+}
+
+pub enum ExternalGetStartSharedPhase {
+    Starting,
+    Running {
+        prefix: ExternalGetStartPrefixResult,
+        keys: Vec<String>,
+    },
+    Ready {
+        prefix: ExternalGetStartPrefixResult,
+        keys: Vec<String>,
+        items: Vec<ExternalGetStartSharedItemResult>,
+    },
+    Failed {
+        error_code: ErrorCode,
+        error_json: String,
+    },
+}
+
+pub struct ExternalGetStartSharedState {
+    pub waiter_count: usize,
+    pub phase: ExternalGetStartSharedPhase,
+}
+
+pub struct ExternalGetStartSharedOp {
+    pub dedup_key: ExternalGetStartDedupKey,
+    pub transfer_concurrency: usize,
+    pub state: Mutex<ExternalGetStartSharedState>,
+    pub notify: Arc<limit_thirdparty::tokio::sync::Notify>,
+}
+
+impl ExternalGetStartSharedOp {
+    pub fn new(dedup_key: ExternalGetStartDedupKey, transfer_concurrency: usize) -> Self {
+        Self {
+            dedup_key,
+            transfer_concurrency,
+            state: Mutex::new(ExternalGetStartSharedState {
+                waiter_count: 1,
+                phase: ExternalGetStartSharedPhase::Starting,
+            }),
+            notify: Arc::new(limit_thirdparty::tokio::sync::Notify::new()),
         }
     }
 }
 
+pub struct ExternalGetStartEntry {
+    pub req_node_id: String,
+    pub shared_op: Arc<ExternalGetStartSharedOp>,
+}
+
 /// Optional arguments for put operations
 #[derive(Clone, Debug)]
 pub enum PutOptionalArg {
@@ -79,6 +179,10 @@ pub enum PutOptionalArg {
     LeaseId(u64),
     /// Ask the master to fail-fast when the same key already has an inflight put.
     RejectIfInflightSameKey,
+    /// Ask the master to fail-fast when the key already has a committed live replica.
+    RejectIfExistSameKey,
+    /// Keep the legacy synchronous remote-placement semantics.
+    WriteThrough,
     /// Prefer placing the target allocation on a kvclient within this sub_cluster.
     PreferredSubCluster(String),
     /// Hidden test-only side-channel for collecting per-put phase timings.
@@ -98,6 +202,8 @@ impl PutOptionalArgs {
         self.0.iter().rev().find_map(|a| match a {
             PutOptionalArg::LeaseId(id) => Some(*id),
             PutOptionalArg::RejectIfInflightSameKey
+            | PutOptionalArg::RejectIfExistSameKey
+            | PutOptionalArg::WriteThrough
             | PutOptionalArg::PreferredSubCluster(_)
             | PutOptionalArg::TestObservePutPhases(_) => None,
         })
@@ -109,12 +215,26 @@ impl PutOptionalArgs {
             .any(|arg| matches!(arg, PutOptionalArg::RejectIfInflightSameKey))
     }
 
+    pub fn reject_if_exist_same_key(&self) -> bool {
+        self.0
+            .iter()
+            .any(|arg| matches!(arg, PutOptionalArg::RejectIfExistSameKey))
+    }
+
+    pub fn write_through(&self) -> bool {
+        self.0
+            .iter()
+            .any(|arg| matches!(arg, PutOptionalArg::WriteThrough))
+    }
+
     /// Get the last provided preferred_sub_cluster if any.
     pub fn preferred_sub_cluster(&self) -> Option<&str> {
         self.0.iter().rev().find_map(|a| match a {
             PutOptionalArg::PreferredSubCluster(sc) => Some(sc.as_str()),
             PutOptionalArg::LeaseId(_)
             | PutOptionalArg::RejectIfInflightSameKey
+            | PutOptionalArg::RejectIfExistSameKey
+            | PutOptionalArg::WriteThrough
             | PutOptionalArg::TestObservePutPhases(_) => None,
         })
     }
@@ -124,6 +244,8 @@ impl PutOptionalArgs {
             PutOptionalArg::TestObservePutPhases(sink) => Some(sink.clone()),
             PutOptionalArg::LeaseId(_)
             | PutOptionalArg::RejectIfInflightSameKey
+            | PutOptionalArg::RejectIfExistSameKey
+            | PutOptionalArg::WriteThrough
             | PutOptionalArg::PreferredSubCluster(_) => None,
         })
     }
@@ -274,6 +396,7 @@ pub enum KvMetrics {
         transfer_poll_wait_us: i64,
         transfer_poll_iters: i64,
         transfer_used_fast_path: bool,
+        transfer_used_nixl: bool,
         transfer_local_noop: bool,
         transfer_remote_transfer: bool,
     },
@@ -343,6 +466,104 @@ async fn handle_external_get(
     }
 }
 
+async fn handle_external_batch_get(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchGetReq>,
+) -> MsgPack<ExternalBatchGetResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.keys.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_get(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_get error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            let mut r: ExternalBatchGetResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&e);
+            r.items = Vec::new();
+            r
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
+async fn handle_external_batch_get_start(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchGetStartReq>,
+) -> MsgPack<ExternalBatchGetStartResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.keys.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_get_start(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_get_start error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            crate::rpcresp_kvresult_convert::FromError::from_error(&e)
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
+async fn handle_external_batch_get_transfer(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchGetTransferReq>,
+) -> MsgPack<ExternalBatchGetTransferResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_handle = req.handle;
+    let resp = view
+        .client_kv_api()
+        .external_batch_get_transfer(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_get_transfer error: {e}; handle={handle}",
+                handle = dbg_handle
+            );
+            let mut r: ExternalBatchGetTransferResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&e);
+            r.items = Vec::new();
+            r
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
+async fn handle_external_batch_get_cancel(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchGetCancelReq>,
+) -> MsgPack<ExternalBatchGetCancelResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_handle = req.handle;
+    let resp = view
+        .client_kv_api()
+        .external_batch_get_cancel(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_get_cancel error: {e}; handle={handle}",
+                handle = dbg_handle
+            );
+            crate::rpcresp_kvresult_convert::FromError::from_error(&e)
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_put_start(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalPutStartReq>,
@@ -375,6 +596,33 @@ async fn handle_external_put_start(
         raw_bytes: Vec::new(),
     }
 }
+
+async fn handle_external_batch_put_start(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchPutStartReq>,
+) -> MsgPack<ExternalBatchPutStartResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.items.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_put_start(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_put_start error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            let mut r: ExternalBatchPutStartResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&e);
+            r.items = Vec::new();
+            r
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_put_transfer_end(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalPutTransferEndReq>,
@@ -401,6 +649,32 @@ async fn handle_external_put_transfer_end(
     }
 }
 
+async fn handle_external_batch_put_transfer_end(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchPutTransferEndReq>,
+) -> MsgPack<ExternalBatchPutTransferEndResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.items.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_put_transfer_end(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_put_transfer_end error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            let mut r: ExternalBatchPutTransferEndResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&e);
+            r.items = Vec::new();
+            r
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_put_commit(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalPutCommitReq>,
@@ -426,6 +700,32 @@ async fn handle_external_put_commit(
     }
 }
 
+async fn handle_external_batch_put_commit(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchPutCommitReq>,
+) -> MsgPack<ExternalBatchPutCommitResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.items.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_put_commit(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_put_commit error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            let mut r: ExternalBatchPutCommitResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&e);
+            r.items = Vec::new();
+            r
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_put_revoke(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalPutRevokeReq>,
@@ -551,6 +851,51 @@ async fn handle_external_is_exist(
     }
 }
 
+async fn handle_external_batch_is_exist(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchIsExistReq>,
+) -> MsgPack<ExternalBatchIsExistResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.keys.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_is_exist(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_is_exist error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            let mut r: ExternalBatchIsExistResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&e);
+            r.exists_list = Vec::new();
+            r
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
+async fn handle_external_observability_snapshot(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalObservabilitySnapshotReq>,
+) -> MsgPack<ExternalObservabilitySnapshotResp> {
+    let req = msg.serialize_part.clone();
+    let resp = view
+        .client_kv_api()
+        .external_observability_snapshot(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!("handle_external_observability_snapshot error: {e}");
+            crate::rpcresp_kvresult_convert::FromError::from_error(&e)
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 fn write_all_at(file: &std::fs::File, mut buf: &[u8], mut offset: u64) -> std::io::Result<()> {
     use std::io::{Error, ErrorKind};
     use std::os::unix::fs::FileExt;
@@ -737,7 +1082,38 @@ pub struct ClientKvApi(ClientKvApiInner);
 pub struct GetCachedInfo {
     put_time_ms: u64,
     put_version: u32,
-    value: CachedValue,
+    mem_holder: Arc<MemoryInfo>,
+}
+
+#[derive(Debug)]
+pub struct PrecommitLocalVisibleInfo {
+    mem_holder: Arc<MemoryInfo>,
+}
+
+#[derive(Debug)]
+pub(crate) struct LocalSnapshotInfo {
+    put_time_ms: u64,
+    put_version: u32,
+}
+
+impl GetCachedInfo {
+    fn version_matches(&self, put_time_ms: u64, put_version: u32) -> bool {
+        if self.put_time_ms == put_time_ms {
+            self.put_version <= put_version
+        } else {
+            self.put_time_ms <= put_time_ms
+        }
+    }
+}
+
+impl LocalSnapshotInfo {
+    fn version_matches(&self, put_time_ms: u64, put_version: u32) -> bool {
+        if self.put_time_ms == put_time_ms {
+            self.put_version <= put_version
+        } else {
+            self.put_time_ms <= put_time_ms
+        }
+    }
 }
 
 struct ClientKvApiViewHolder {
@@ -782,6 +1158,16 @@ pub struct ClientKvApiInner {
     /// key -> value info on this node
     /// we can only remove value if it's put_time_ms and put_version match remote eviction command
     get_cached_info: DashMap<String, GetCachedInfo>,
+    /// key -> locally readable resident slot before backend put_start/put_done finishes.
+    precommit_local_visible_info: DashMap<String, PrecommitLocalVisibleInfo>,
+    /// key -> local replica version remembered from local put/get durable-replica success.
+    /// This authority is positive-only: hit means "can answer exists=true immediately when
+    /// allow_local_snapshot is enabled"; miss does not imply non-existence.
+    local_snapshot_info: DashMap<String, LocalSnapshotInfo>,
+    /// KvOwner-managed resident staging grants for hostless put_start.
+    owner_local_reserve_pool: Mutex<OwnerLocalReservePoolState>,
+    /// Wake the background reserve actor after demand/free-slot changes.
+    owner_local_reserve_rebalance_notify: Arc<limit_thirdparty::tokio::sync::Notify>,
 
     /// Shared delete actor input for owner -> external weak-index invalidation.
     pub external_invalidate_delete: EnsureMemholderMgmtDeleteHandle<DeleteClientKvMetaCacheItem>,
@@ -792,6 +1178,9 @@ pub struct ClientKvApiInner {
 
     // record external_client get_holding info (owned, flattened manager)
     pub external_get_holding: OwnerExternalMemMgr,
+    pub external_get_start_registry: DashMap<u64, Arc<ExternalGetStartEntry>>,
+    pub external_get_start_by_key: DashMap<ExternalGetStartDedupKey, Arc<ExternalGetStartSharedOp>>,
+    next_external_get_start_handle: AtomicU64,
     /// Weak handle to a shared refcount tracker for all UserMemHolder of this client.
     ///
     /// - A strong `Arc<AllMemholderRefCount>` is given to every `UserMemHolder` created by this client.
@@ -804,109 +1193,567 @@ pub struct ClientKvApiInner {
     #[cfg(test)]
     test_record: crate::client_kv_api::client_test_record::ClientTestRecord,
 
-    rpc_caller_get_start: RPCCaller<GetStartReq>,
-    rpc_caller_get_revoke: RPCCaller<GetRevokeReq>,
-    rpc_caller_get_done: RPCCaller<GetDoneReq>,
-    rpc_caller_put_start: RPCCaller<PutStartReq>,
-    rpc_caller_put_revoke: RPCCaller<PutRevokeReq>,
-    rpc_caller_put_done: RPCCaller<PutDoneReq>,
-    rpc_caller_delete: RPCCaller<DeleteReq>,
-    rpc_caller_batch_delete_ack: RPCCaller<BatchDeleteAckReq>,
-    rpc_caller_get_meta: RPCCaller<GetMetaReq>,
-    _rpc_caller_allocate_client_lease: RPCCaller<AllocateClientLeaseReq>,
-    _rpc_caller_client_lease_keepalive: RPCCaller<ClientLeaseKeepaliveReq>,
-    rpc_caller_external_put_commit: RPCCaller<ExternalPutCommitReq>,
-    rpc_caller_external_put_revoke: RPCCaller<ExternalPutRevokeReq>,
-    rpc_caller_resolve_side_transfer_lane: RPCCaller<ResolveSideTransferLaneReq>,
+    rpc_caller_get_start: RPCCaller<GetStartReq>,
+    rpc_caller_get_revoke: RPCCaller<GetRevokeReq>,
+    rpc_caller_get_done: RPCCaller<GetDoneReq>,
+    rpc_caller_batch_get_start: RPCCaller<BatchGetStartReq>,
+    rpc_caller_batch_get_revoke: RPCCaller<BatchGetRevokeReq>,
+    rpc_caller_batch_get_done: RPCCaller<BatchGetDoneReq>,
+    rpc_caller_put_start: RPCCaller<PutStartReq>,
+    rpc_caller_put_revoke: RPCCaller<PutRevokeReq>,
+    rpc_caller_put_done: RPCCaller<PutDoneReq>,
+    rpc_caller_batch_put_start: RPCCaller<BatchPutStartReq>,
+    rpc_caller_batch_put_revoke: RPCCaller<BatchPutRevokeReq>,
+    rpc_caller_batch_put_done: RPCCaller<BatchPutDoneReq>,
+    rpc_caller_batch_prepare_put_keys: RPCCaller<BatchPreparePutKeysReq>,
+    rpc_caller_batch_release_put_key_reservations: RPCCaller<BatchReleasePutKeyReservationsReq>,
+    rpc_caller_put_append_start: RPCCaller<PutAppendStartReq>,
+    rpc_caller_put_append_revoke: RPCCaller<PutAppendRevokeReq>,
+    rpc_caller_put_append_done: RPCCaller<PutAppendDoneReq>,
+    rpc_caller_reserve_local_grant: RPCCaller<ReserveLocalGrantReq>,
+    rpc_caller_release_local_grant: RPCCaller<ReleaseLocalGrantReq>,
+    rpc_caller_delete: RPCCaller<DeleteReq>,
+    rpc_caller_batch_delete_ack: RPCCaller<BatchDeleteAckReq>,
+    rpc_caller_batch_is_exist: RPCCaller<BatchIsExistReq>,
+    rpc_caller_get_meta: RPCCaller<GetMetaReq>,
+    rpc_caller_allocate_client_lease: RPCCaller<AllocateClientLeaseReq>,
+    rpc_caller_client_lease_keepalive: RPCCaller<ClientLeaseKeepaliveReq>,
+    rpc_caller_external_put_commit: RPCCaller<ExternalPutCommitReq>,
+    rpc_caller_external_put_revoke: RPCCaller<ExternalPutRevokeReq>,
+    rpc_caller_resolve_side_transfer_lane: RPCCaller<ResolveSideTransferLaneReq>,
+
+    /// Default lease id recorded for inspection/convenience, but NOT auto-applied.
+    /// Callers must explicitly pass `Some(lease_id)` to attach a put to a lease.
+    default_lease_id: parking_lot::RwLock<Option<u64>>,
+    /// External put (remote target) pending context keyed by (key, put_time_ms, put_version).
+    /// 注意：put_id (time_ms,version) 在不同 key 上并不全局唯一，因此必须携带 key 作为索引的一部分，避免碰撞。
+    /// 使用 moka::sync::SegmentedCache 并设置 30 分钟 TTL，避免异常路径未清理导致的泄漏；不设置容量上限，纯 TTL 控制。
+    external_pending_puts: moka::sync::SegmentedCache<(String, u64, u32), ExternalPendingPutCtx>,
+    write_back_append_tx: tokio::sync::ampsc::Sender<WriteBackAppendJob>,
+    write_back_append_rx: Mutex<Option<tokio::sync::ampsc::Receiver<WriteBackAppendJob>>>,
+}
+
+impl ClientKvApiInner {
+    fn view(&self) -> &ClientKvApiView {
+        &self.view
+    }
+
+    pub(crate) fn release_local_reserve_route_for_memory_info(&self, memory_info: &MemoryInfo) {
+        let Some((slot_size, grant_id, slot_index)) = memory_info.local_reserve_resident_slot_ref()
+        else {
+            return;
+        };
+        if let Err(err) =
+            self.owner_release_local_reserve_committed_slot_route(slot_size, grant_id, slot_index)
+        {
+            tracing::warn!(
+                "failed to release local reserve committed slot route: key={} slot_size={} grant_id={} slot_index={} err={}",
+                memory_info.key,
+                slot_size,
+                grant_id,
+                slot_index,
+                err
+            );
+        }
+    }
+
+    pub(crate) fn short_circuit_put_payload_path_enabled(&self) -> bool {
+        self.test_spec_config.short_circuit_put_payload_path
+    }
+
+    pub(crate) fn skip_put_end_commit_enabled(&self) -> bool {
+        self.test_spec_config.skip_put_end_commit
+    }
+
+    pub(crate) fn remember_local_snapshot(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+    ) {
+        self.local_snapshot_info.insert(
+            key.to_string(),
+            LocalSnapshotInfo {
+                put_time_ms: put_id.0,
+                put_version: put_id.1,
+            },
+        );
+    }
+
+    pub(crate) fn has_local_snapshot(&self, key: &str) -> bool {
+        self.precommit_local_visible_info.contains_key(key)
+            || self.get_cached_info.contains_key(key)
+            || self.local_snapshot_info.contains_key(key)
+    }
+
+    pub(crate) fn remove_local_snapshot_if(
+        &self,
+        key: &str,
+        put_time_ms: u64,
+        put_version: u32,
+    ) -> bool {
+        self.local_snapshot_info
+            .remove_if(key, |_, v| v.version_matches(put_time_ms, put_version))
+            .is_some()
+    }
+
+    pub(crate) fn local_visible_mem_holder(&self, key: &str) -> Option<Arc<MemoryInfo>> {
+        if let Some(info) = self.precommit_local_visible_info.get(key) {
+            return Some(info.mem_holder.clone());
+        }
+        self.get_cached_info
+            .get(key)
+            .map(|info| info.mem_holder.clone())
+    }
+
+    pub async fn build_local_reserve_resident_memory_info(
+        &self,
+        key: &str,
+        addr: u64,
+        len: u32,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> Arc<MemoryInfo> {
+        let resident_owner_node_id: NodeID = self.view.cluster_manager().get_self_info().id.into();
+        Arc::new(
+            MemoryInfo::new_local_reserve_resident(
+                addr,
+                len,
+                key.to_string(),
+                resident_owner_node_id,
+                self.view.clone(),
+                slot_size,
+                grant_id,
+                slot_index,
+            )
+            .await,
+        )
+    }
+
+    pub async fn install_local_committed_memory_info(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        offset: u64,
+        len: u32,
+        holder_id: u64,
+    ) -> KvResult<()> {
+        let master_node_id: NodeID = self.view.cluster_manager().get_self_info().id.into();
+        let memory_info = Arc::new(
+            MemoryInfo::new(
+                offset,
+                len,
+                holder_id,
+                key.to_string(),
+                master_node_id,
+                self.view.clone(),
+            )
+            .await,
+        );
+        let replaced = self.get_cached_info.insert(
+            key.to_string(),
+            GetCachedInfo {
+                put_time_ms: put_id.0,
+                put_version: put_id.1,
+                mem_holder: memory_info,
+            },
+        );
+        if let Some(previous) = replaced {
+            self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+        }
+        self.remember_local_snapshot(key, put_id);
+        Ok(())
+    }
+
+    pub fn install_precommit_local_visible_memory_info(
+        &self,
+        key: &str,
+        memory_info: Arc<MemoryInfo>,
+    ) {
+        let (slot_size, grant_id, slot_index) = memory_info
+            .local_reserve_resident_slot_ref()
+            .expect("resident memory_info must carry local reserve slot ref");
+        self.owner_mark_local_reserve_slot_pending_visible(slot_size, grant_id, slot_index)
+            .expect("marking local reserve slot pending visible must succeed");
+        self.owner_retain_local_reserve_resident_slot_holder(slot_size, grant_id, slot_index)
+            .expect("retaining local reserve resident holder must succeed");
+        let replaced = self.precommit_local_visible_info.insert(
+            key.to_string(),
+            PrecommitLocalVisibleInfo {
+                mem_holder: memory_info.clone(),
+            },
+        );
+        assert!(
+            replaced.is_none(),
+            "precommit local visible cache must not be replaced for the same key"
+        );
+    }
+
+    pub fn remove_precommit_local_reserve_resident_slot_if_same(
+        &self,
+        key: &str,
+        expected_mem_holder: &Arc<MemoryInfo>,
+    ) -> bool {
+        self.precommit_local_visible_info
+            .remove_if(key, |_, info| {
+                Arc::ptr_eq(&info.mem_holder, expected_mem_holder)
+            })
+            .is_some()
+    }
+
+    pub fn promote_precommit_local_reserve_resident_slot_if_same(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        memory_info: Arc<MemoryInfo>,
+    ) -> KvResult<()> {
+        let is_same_pending = self
+            .precommit_local_visible_info
+            .get(key)
+            .map(|info| Arc::ptr_eq(&info.mem_holder, &memory_info))
+            .unwrap_or(false);
+        if !is_same_pending {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "precommit local visible cache missing while promoting key={}",
+                    key
+                ),
+            }));
+        }
+        let (slot_size, grant_id, slot_index) = memory_info
+            .local_reserve_resident_slot_ref()
+            .expect("resident memory_info must carry local reserve slot ref");
+        self.owner_promote_local_reserve_pending_slot_to_committed(
+            slot_size, grant_id, slot_index,
+        )?;
+        let removed = self
+            .precommit_local_visible_info
+            .remove_if(key, |_, info| Arc::ptr_eq(&info.mem_holder, &memory_info))
+            .is_some();
+        if !removed {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "precommit local visible cache disappeared while promoting key={}",
+                    key
+                ),
+            }));
+        }
+        let replaced = self.get_cached_info.insert(
+            key.to_string(),
+            GetCachedInfo {
+                put_time_ms: put_id.0,
+                put_version: put_id.1,
+                mem_holder: memory_info,
+            },
+        );
+        if let Some(previous) = replaced {
+            self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+        }
+        self.remember_local_snapshot(key, put_id);
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ExternalPendingPutCtx {
+    pub peer_id: Option<NodeIDString>,
+    pub src_offset: u64,
+    pub target_base_addr: u64,
+    pub target_offset: u64,
+    pub len: u64,
+    pub preferred_sub_cluster: Option<String>,
+}
+
+#[derive(Clone)]
+pub(crate) struct WriteBackAppendJob {
+    pub key: String,
+    pub put_id: crate::master_kv_router::put::PutIDForAKey,
+    pub holder: Arc<UserMemHolder>,
+    pub preferred_sub_cluster: Option<String>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub(crate) enum OwnerLocalReserveSlotState {
+    Free,
+    Prepared,
+    PendingLocalVisible {
+        holder_ref_count: u32,
+    },
+    Committed {
+        route_live: bool,
+        holder_ref_count: u32,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnerLocalReserveSlotRef {
+    pub grant_id: u64,
+    pub slot_index: u32,
+    pub ptr: u64,
+    pub base_addr: u64,
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnerLocalReserveSlotLease {
+    pub value_len: u64,
+    pub slot_size: u64,
+    pub slots: Vec<OwnerLocalReserveSlotRef>,
+}
+
+impl OwnerLocalReserveSlotLease {
+    pub fn value_ptrs(&self) -> Vec<u64> {
+        self.slots.iter().map(|slot| slot.ptr).collect()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct OwnerLocalReserveGrantState {
+    pub grant_id: u64,
+    pub base_addr: u64,
+    pub addr: u64,
+    pub len: u64,
+    pub slot_size: u64,
+    pub slot_count: u32,
+    pub slot_states: Vec<OwnerLocalReserveSlotState>,
+    pub free_slots: Vec<u32>,
+    pub fully_free_since: Option<Instant>,
+}
+
+impl OwnerLocalReserveGrantState {
+    pub fn new(
+        grant_id: u64,
+        base_addr: u64,
+        addr: u64,
+        len: u64,
+        slot_size: u64,
+        slot_count: u32,
+    ) -> Self {
+        let mut free_slots = Vec::with_capacity(slot_count as usize);
+        for slot_index in (0..slot_count).rev() {
+            free_slots.push(slot_index);
+        }
+        Self {
+            grant_id,
+            base_addr,
+            addr,
+            len,
+            slot_size,
+            slot_count,
+            slot_states: vec![OwnerLocalReserveSlotState::Free; slot_count as usize],
+            free_slots,
+            fully_free_since: Some(Instant::now()),
+        }
+    }
+
+    pub fn claim_prepared_slot(&mut self) -> Option<OwnerLocalReserveSlotRef> {
+        let slot_index = self.free_slots.pop()?;
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        assert!(
+            matches!(*state, OwnerLocalReserveSlotState::Free),
+            "claim_prepared_slot expects a free slot"
+        );
+        *state = OwnerLocalReserveSlotState::Prepared;
+        self.fully_free_since = None;
+        Some(OwnerLocalReserveSlotRef {
+            grant_id: self.grant_id,
+            slot_index,
+            ptr: self.addr + self.slot_size * slot_index as u64,
+            base_addr: self.base_addr,
+        })
+    }
+
+    pub fn mark_prepared_slot_pending_visible(&mut self, slot_index: u32) {
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        assert!(
+            matches!(*state, OwnerLocalReserveSlotState::Prepared),
+            "mark_prepared_slot_pending_visible expects a prepared slot"
+        );
+        *state = OwnerLocalReserveSlotState::PendingLocalVisible {
+            holder_ref_count: 0,
+        };
+        self.fully_free_since = None;
+    }
+
+    pub fn promote_pending_visible_slot_to_committed(&mut self, slot_index: u32) {
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        let holder_ref_count = match *state {
+            OwnerLocalReserveSlotState::PendingLocalVisible { holder_ref_count } => {
+                holder_ref_count
+            }
+            _ => {
+                unreachable!("promote_pending_visible_slot_to_committed expects a pending slot");
+            }
+        };
+        *state = OwnerLocalReserveSlotState::Committed {
+            route_live: true,
+            holder_ref_count,
+        };
+        self.fully_free_since = None;
+    }
 
-    /// Default lease id recorded for inspection/convenience, but NOT auto-applied.
-    /// Callers must explicitly pass `Some(lease_id)` to attach a put to a lease.
-    default_lease_id: parking_lot::RwLock<Option<u64>>,
-    /// External put (remote target) pending context keyed by (key, put_time_ms, put_version).
-    /// 注意：put_id (time_ms,version) 在不同 key 上并不全局唯一，因此必须携带 key 作为索引的一部分，避免碰撞。
-    /// 使用 moka::sync::SegmentedCache 并设置 30 分钟 TTL，避免异常路径未清理导致的泄漏；不设置容量上限，纯 TTL 控制。
-    external_pending_puts: moka::sync::SegmentedCache<(String, u64, u32), ExternalPendingPutCtx>,
-}
+    pub fn release_prepared_slot(&mut self, slot_index: u32) {
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        assert!(
+            matches!(*state, OwnerLocalReserveSlotState::Prepared),
+            "release_prepared_slot expects a prepared slot"
+        );
+        *state = OwnerLocalReserveSlotState::Free;
+        self.free_slots.push(slot_index);
+        if self.is_fully_free() {
+            self.fully_free_since = Some(Instant::now());
+        }
+    }
 
-impl ClientKvApiInner {
-    fn should_replace_cached_info(
-        current: &GetCachedInfo,
-        put_time_ms: u64,
-        put_version: u32,
-        new_value_rank: u8,
-    ) -> bool {
-        if current.put_time_ms != put_time_ms {
-            return current.put_time_ms <= put_time_ms;
+    pub fn retain_resident_slot_holder(&mut self, slot_index: u32) {
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        match state {
+            OwnerLocalReserveSlotState::PendingLocalVisible { holder_ref_count }
+            | OwnerLocalReserveSlotState::Committed {
+                holder_ref_count, ..
+            } => {
+                *holder_ref_count = holder_ref_count
+                    .checked_add(1)
+                    .expect("retain_resident_slot_holder overflow");
+            }
+            _ => {
+                unreachable!("retain_resident_slot_holder expects a resident slot");
+            }
         }
-        if current.put_version != put_version {
-            return current.put_version <= put_version;
+    }
+
+    pub fn release_resident_slot_holder(&mut self, slot_index: u32) {
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        match state {
+            OwnerLocalReserveSlotState::PendingLocalVisible { holder_ref_count } => {
+                assert!(
+                    *holder_ref_count > 0,
+                    "release_resident_slot_holder expects holder_ref_count > 0"
+                );
+                *holder_ref_count -= 1;
+                if *holder_ref_count == 0 {
+                    *state = OwnerLocalReserveSlotState::Free;
+                    self.free_slots.push(slot_index);
+                    if self.is_fully_free() {
+                        self.fully_free_since = Some(Instant::now());
+                    }
+                }
+            }
+            OwnerLocalReserveSlotState::Committed {
+                route_live,
+                holder_ref_count,
+            } => {
+                *holder_ref_count = holder_ref_count
+                    .checked_sub(1)
+                    .expect("release_resident_slot_holder expects holder_ref_count > 0");
+                if !*route_live && *holder_ref_count == 0 {
+                    *state = OwnerLocalReserveSlotState::Free;
+                    self.free_slots.push(slot_index);
+                    if self.is_fully_free() {
+                        self.fully_free_since = Some(Instant::now());
+                    }
+                }
+            }
+            _ => {
+                unreachable!("release_resident_slot_holder expects a resident slot");
+            }
         }
-        current.value.rank() < new_value_rank
-    }
-
-    fn upsert_cached_info(&self, key: &str, candidate: GetCachedInfo) {
-        match self.get_cached_info.entry(key.to_string()) {
-            dashmap::mapref::entry::Entry::Occupied(mut entry) => {
-                if Self::should_replace_cached_info(
-                    entry.get(),
-                    candidate.put_time_ms,
-                    candidate.put_version,
-                    candidate.value.rank(),
-                ) {
-                    entry.insert(candidate);
+    }
+
+    pub fn release_committed_slot_route(&mut self, slot_index: u32) {
+        let state = self
+            .slot_states
+            .get_mut(slot_index as usize)
+            .expect("slot state index out of range");
+        match state {
+            OwnerLocalReserveSlotState::Committed {
+                route_live,
+                holder_ref_count,
+            } => {
+                assert!(
+                    *route_live,
+                    "release_committed_slot_route expects a live route"
+                );
+                *route_live = false;
+                if *holder_ref_count == 0 {
+                    *state = OwnerLocalReserveSlotState::Free;
+                    self.free_slots.push(slot_index);
+                    if self.is_fully_free() {
+                        self.fully_free_since = Some(Instant::now());
+                    }
                 }
             }
-            dashmap::mapref::entry::Entry::Vacant(entry) => {
-                entry.insert(candidate);
+            _ => {
+                unreachable!("release_committed_slot_route expects a committed slot");
             }
         }
     }
 
-    pub(crate) fn cache_metadata_only_after_put(
-        &self,
-        key: &str,
-        put_id: crate::master_kv_router::put::PutIDForAKey,
-    ) {
-        self.upsert_cached_info(
-            key,
-            GetCachedInfo {
-                put_time_ms: put_id.0,
-                put_version: put_id.1,
-                value: CachedValue::MetadataOnly,
-            },
-        );
+    pub fn is_fully_free(&self) -> bool {
+        self.free_slots.len() == self.slot_count as usize
     }
 
-    pub(crate) fn cache_local_replica_after_get(
-        &self,
-        key: &str,
-        put_id: crate::master_kv_router::put::PutIDForAKey,
-        memory_info: Arc<MemoryInfo>,
-    ) {
-        self.upsert_cached_info(
-            key,
-            GetCachedInfo {
-                put_time_ms: put_id.0,
-                put_version: put_id.1,
-                value: CachedValue::LocalReplica(memory_info),
-            },
-        );
+    pub fn used_slot_count(&self) -> usize {
+        self.slot_count as usize - self.free_slots.len()
     }
+}
 
-    pub(crate) fn short_circuit_put_payload_path_enabled(&self) -> bool {
-        self.test_spec_config.short_circuit_put_payload_path
+#[derive(Debug, Clone)]
+pub(crate) struct OwnerLocalReserveClassState {
+    pub slot_size: u64,
+    pub slots_per_grant: u32,
+    pub grants: Vec<OwnerLocalReserveGrantState>,
+    pub last_grow_at: Option<Instant>,
+    pub pending_slot_demand: usize,
+}
+
+impl OwnerLocalReserveClassState {
+    pub fn new(slot_size: u64, slots_per_grant: u32) -> Self {
+        Self {
+            slot_size,
+            slots_per_grant,
+            grants: Vec::new(),
+            last_grow_at: None,
+            pending_slot_demand: 0,
+        }
     }
 
-    pub(crate) fn skip_put_end_commit_enabled(&self) -> bool {
-        self.test_spec_config.skip_put_end_commit
+    pub fn free_slot_count(&self) -> usize {
+        self.grants.iter().map(|grant| grant.free_slots.len()).sum()
+    }
+
+    pub fn used_slot_count(&self) -> usize {
+        self.grants
+            .iter()
+            .map(|grant| grant.used_slot_count())
+            .sum()
+    }
+
+    pub fn grant_count(&self) -> usize {
+        self.grants.len()
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct ExternalPendingPutCtx {
-    pub peer_id: NodeIDString,
-    pub target_base_addr: u64,
-    pub target_offset: u64,
+#[derive(Debug, Default)]
+pub(crate) struct OwnerLocalReservePoolState {
+    pub classes: HashMap<u64, OwnerLocalReserveClassState>,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -1071,12 +1918,46 @@ impl MetricsSet {
     }
 }
 
+fn format_metrics_snapshot_prometheus(
+    client_id: &str,
+    timestamp_ms: i64,
+    metrics: &std::collections::HashMap<String, MetricsSet>,
+) -> String {
+    let mut result = String::new();
+
+    for (metric_name, metric_set) in metrics {
+        result.push_str(&metric_set.to_prometheus_format(metric_name, client_id));
+        result.push_str(&metric_set.to_prometheus_timeline_format(client_id));
+    }
+
+    result.push_str(&format!(
+        "kvcache_metrics_report_timestamp{{client=\"{}\"}} {}\n",
+        client_id, timestamp_ms
+    ));
+
+    result
+}
+
 impl ClientKvApiInner {
     pub fn get_holding_len(&self) -> usize {
         self.external_get_holding.total()
     }
+
+    pub fn runtime_observe_snapshot(&self) -> OwnerRuntimeObserveSnapshot {
+        let mut external_get_holding_bytes = 0u64;
+        for entry in self.external_get_holding.inner().iter() {
+            external_get_holding_bytes =
+                external_get_holding_bytes.saturating_add(entry.value().memory_info.len as u64);
+        }
+        OwnerRuntimeObserveSnapshot {
+            external_get_holding_entries: self.external_get_holding.total() as u64,
+            external_get_holding_bytes,
+            external_pending_put_entries: self.external_pending_puts.entry_count(),
+        }
+    }
+
     pub fn get_cache_len(&self) -> usize {
-        self.get_cached_info.len()
+        self.precommit_local_visible_info.len() + self.get_cached_info.len()
     }
     fn metrics_handle(&self) -> Arc<MetricsHandle> {
         self.metrics
@@ -1085,6 +1966,15 @@ impl ClientKvApiInner {
             .expect("metrics handle not initialized")
     }
 
+    pub fn locality_snapshot(&self) -> KvLocalitySnapshot {
+        self.metrics_handle().get_locality_snapshot()
+    }
+
+    pub fn record_put_locality(&self, remote: bool, bytes: u64, transfer_us: i64) {
+        self.metrics_handle()
+            .record_put_io_locality(remote, bytes, transfer_us);
+    }
+
     fn client_id_str(&self) -> String {
         self.view.cluster_manager().get_self_info().id.to_string()
     }
@@ -1506,18 +2396,84 @@ impl ClientKvApiInner {
 
         new_ref
     }
+
+    pub(crate) fn owner_local_reserve_rebalance_notify(
+        &self,
+    ) -> Arc<limit_thirdparty::tokio::sync::Notify> {
+        self.owner_local_reserve_rebalance_notify.clone()
+    }
+
+    pub(crate) fn owner_local_reserve_register_pending_demand(
+        &self,
+        slot_size: u64,
+        slots_per_grant: u32,
+        demand_slots: usize,
+    ) {
+        let mut pool = self.owner_local_reserve_pool.lock();
+        let class_state = pool
+            .classes
+            .entry(slot_size)
+            .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+        class_state.pending_slot_demand =
+            class_state.pending_slot_demand.saturating_add(demand_slots);
+    }
+
+    pub(crate) fn owner_local_reserve_consume_pending_demand(
+        &self,
+        slot_size: u64,
+        slots_per_grant: u32,
+        demand_slots: usize,
+    ) {
+        let mut pool = self.owner_local_reserve_pool.lock();
+        let class_state = pool
+            .classes
+            .entry(slot_size)
+            .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+        class_state.pending_slot_demand =
+            class_state.pending_slot_demand.saturating_sub(demand_slots);
+    }
 }
 impl ClientKvApi {
     pub fn inner(&self) -> &ClientKvApiInner {
         &self.0
     }
 
+    fn spawn_runtime_observe_reporter(&self) {
+        let view = self.0.view.clone_view();
+        let view_task = view.clone();
+        view.spawn("client_runtime_observe_reporter", async move {
+            let mut interval = tokio::time::interval(Duration::from_secs(30));
+            let mut shutdown_waiter = view_task.register_shutdown_waiter();
+            loop {
+                tokio::select! {
+                    _ = shutdown_waiter.wait() => break,
+                    _ = interval.tick() => {
+                        let snapshot = view_task.client_kv_api().inner().runtime_observe_snapshot();
+                        let metrics = view_task.metric_reporter().metrics();
+                        metrics.set_kv_holding_entries(
+                            "owner_external_get_holding",
+                            snapshot.external_get_holding_entries,
+                        );
+                        metrics.set_kv_holding_bytes(
+                            "owner_external_get_holding",
+                            snapshot.external_get_holding_bytes,
+                        );
+                        metrics.set_kv_external_pending_put_entries(
+                            snapshot.external_pending_put_entries,
+                        );
+                    }
+                }
+            }
+        });
+    }
+
     pub fn attach_view(&self, view: ClientKvApiView) {
         self.0.view.attach(view);
     }
 
     pub async fn construct(arg: ClientKvApiNewArg) -> Result<Self, KvError> {
         tracing::info!("Constructing ClientKvApi in Client mode (PreView)");
+        let (write_back_append_tx, write_back_append_rx) = tokio::sync::ampsc::channel(1024);
 
         let inner = ClientKvApiInner {
             view: ClientKvApiViewHolder::new(),
@@ -1526,6 +2482,12 @@ impl ClientKvApi {
             all_memholder_refcount: OnceLock::new(),
             get_remote_kv_lock: AMapLock::new(Duration::from_secs(60)),
             get_cached_info: DashMap::new(),
+            precommit_local_visible_info: DashMap::new(),
+            local_snapshot_info: DashMap::new(),
+            owner_local_reserve_pool: Mutex::new(OwnerLocalReservePoolState::default()),
+            owner_local_reserve_rebalance_notify: Arc::new(
+                limit_thirdparty::tokio::sync::Notify::new(),
+            ),
             external_invalidate_delete: EnsureMemholderMgmtDeleteHandle::new(
                 OwnerExternalMemMgr::DELETE_SUBMIT_QUEUE_CAPACITY,
             ),
@@ -1534,6 +2496,9 @@ impl ClientKvApi {
             ),
             owner_delete_ack_mgr: OwnerDeleteAckMemMgr::default(),
             external_get_holding: OwnerExternalMemMgr::default(),
+            external_get_start_registry: DashMap::new(),
+            external_get_start_by_key: DashMap::new(),
+            next_external_get_start_handle: AtomicU64::new(1),
             external_pending_puts: moka::sync::Cache::builder()
                 .time_to_live(Duration::from_secs(30 * 60))
                 .segments(16)
@@ -1543,18 +2508,34 @@ impl ClientKvApi {
             rpc_caller_get_start: RPCCaller::new(),
             rpc_caller_get_revoke: RPCCaller::new(),
             rpc_caller_get_done: RPCCaller::new(),
+            rpc_caller_batch_get_start: RPCCaller::new(),
+            rpc_caller_batch_get_revoke: RPCCaller::new(),
+            rpc_caller_batch_get_done: RPCCaller::new(),
             rpc_caller_put_start: RPCCaller::new(),
             rpc_caller_put_revoke: RPCCaller::new(),
             rpc_caller_put_done: RPCCaller::new(),
+            rpc_caller_batch_put_start: RPCCaller::new(),
+            rpc_caller_batch_put_revoke: RPCCaller::new(),
+            rpc_caller_batch_put_done: RPCCaller::new(),
+            rpc_caller_batch_prepare_put_keys: RPCCaller::new(),
+            rpc_caller_batch_release_put_key_reservations: RPCCaller::new(),
+            rpc_caller_put_append_start: RPCCaller::new(),
+            rpc_caller_put_append_revoke: RPCCaller::new(),
+            rpc_caller_put_append_done: RPCCaller::new(),
+            rpc_caller_reserve_local_grant: RPCCaller::new(),
+            rpc_caller_release_local_grant: RPCCaller::new(),
             rpc_caller_delete: RPCCaller::new(),
             rpc_caller_batch_delete_ack: RPCCaller::new(),
+            rpc_caller_batch_is_exist: RPCCaller::new(),
             rpc_caller_get_meta: RPCCaller::new(),
-            _rpc_caller_allocate_client_lease: RPCCaller::new(),
-            _rpc_caller_client_lease_keepalive: RPCCaller::new(),
+            rpc_caller_allocate_client_lease: RPCCaller::new(),
+            rpc_caller_client_lease_keepalive: RPCCaller::new(),
             rpc_caller_external_put_commit: RPCCaller::new(),
             rpc_caller_external_put_revoke: RPCCaller::new(),
             rpc_caller_resolve_side_transfer_lane: RPCCaller::new(),
             default_lease_id: parking_lot::RwLock::new(None),
+            write_back_append_tx,
+            write_back_append_rx: Mutex::new(Some(write_back_append_rx)),
         };
         Ok(Self(inner))
     }
@@ -1570,13 +2551,55 @@ impl ClientKvApi {
         inner.rpc_caller_get_start.regist(inner.view.p2p_module());
         inner.rpc_caller_get_revoke.regist(inner.view.p2p_module());
         inner.rpc_caller_get_done.regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_get_start
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_get_revoke
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_get_done
+            .regist(inner.view.p2p_module());
         inner.rpc_caller_put_start.regist(inner.view.p2p_module());
         inner.rpc_caller_put_revoke.regist(inner.view.p2p_module());
         inner.rpc_caller_put_done.regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_put_start
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_put_revoke
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_put_done
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_prepare_put_keys
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_release_put_key_reservations
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_put_append_start
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_put_append_revoke
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_put_append_done
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_reserve_local_grant
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_release_local_grant
+            .regist(inner.view.p2p_module());
         inner.rpc_caller_delete.regist(inner.view.p2p_module());
         inner
             .rpc_caller_batch_delete_ack
             .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_is_exist
+            .regist(inner.view.p2p_module());
         inner.rpc_caller_get_meta.regist(inner.view.p2p_module());
         inner
             .rpc_caller_external_put_commit
@@ -1592,25 +2615,84 @@ impl ClientKvApi {
         // Register master-only metric RPC callers
         crate::metrics::client::init_for_p2p_owner(inner.view.p2p_module());
         RPCCaller::<BatchDeleteAckReq>::new().regist(inner.view.p2p_module());
+        RPCCaller::<BatchIsExistReq>::new().regist(inner.view.p2p_module());
         RPCCaller::<BatchDeleteClientKvMetaCacheReq>::new().regist(inner.view.p2p_module());
+        spawn_owner_local_reserve_rebalance_actor(inner.view.clone_view());
+        self.spawn_runtime_observe_reporter();
 
         // External RPC handlers
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalGetReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
             let view = view_ext.clone();
             let view_task = view.clone();
-            let _ = view.spawn("rpc_external_get", async move {
+            view.spawn("rpc_external_get", async move {
                 let result = handle_external_get(&view_task, &msg).await;
                 let _ = resp.send_resp(result).await;
             });
             Ok(())
         });
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchGetReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_get", async move {
+                    let result = handle_external_batch_get(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchGetStartReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_get_start", async move {
+                    let result = handle_external_batch_get_start(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchGetTransferReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_get_transfer", async move {
+                    let result = handle_external_batch_get_transfer(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchGetCancelReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_get_cancel", async move {
+                    let result = handle_external_batch_get_cancel(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalPutStartReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
             let view = view_ext.clone();
             let view_task = view.clone();
-            let _ = view.spawn("rpc_external_put_start", async move {
+            view.spawn("rpc_external_put_start", async move {
                 let req = msg.serialize_part.clone();
                 tracing::info!(
                     "rpc_external_put_start received: self={} peer={} task_id={} key={} len={} started_time={}",
@@ -1644,13 +2726,27 @@ impl ClientKvApi {
             Ok(())
         });
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchPutStartReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_put_start", async move {
+                    let result = handle_external_batch_put_start(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalPutTransferEndReq>::new().regist(
             inner.view.p2p_module(),
             move |resp, msg| {
                 let view = view_ext.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_external_put_transfer_end", async move {
+                view.spawn("rpc_external_put_transfer_end", async move {
                     let result = handle_external_put_transfer_end(&view_task, &msg).await;
                     let _ = resp.send_resp(result).await;
                 });
@@ -1658,13 +2754,27 @@ impl ClientKvApi {
             },
         );
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchPutTransferEndReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_put_transfer_end", async move {
+                    let result = handle_external_batch_put_transfer_end(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalPutCommitReq>::new().regist(
             inner.view.p2p_module(),
             move |resp, msg| {
                 let view = view_ext.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_external_put_commit", async move {
+                view.spawn("rpc_external_put_commit", async move {
                     let result = handle_external_put_commit(&view_task, &msg).await;
                     let _ = resp.send_resp(result).await;
                 });
@@ -1672,13 +2782,27 @@ impl ClientKvApi {
             },
         );
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchPutCommitReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_put_commit", async move {
+                    let result = handle_external_batch_put_commit(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalPutRevokeReq>::new().regist(
             inner.view.p2p_module(),
             move |resp, msg| {
                 let view = view_ext.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_external_put_revoke", async move {
+                view.spawn("rpc_external_put_revoke", async move {
                     let result = handle_external_put_revoke(&view_task, &msg).await;
                     let _ = resp.send_resp(result).await;
                 });
@@ -1690,7 +2814,7 @@ impl ClientKvApi {
         RPCHandler::<ExternalDeleteReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
             let view = view_ext.clone();
             let view_task = view.clone();
-            let _ = view.spawn("rpc_external_delete", async move {
+            view.spawn("rpc_external_delete", async move {
                 let result = handle_external_delete(&view_task, &msg).await;
                 let _ = resp.send_resp(result).await;
             });
@@ -1703,7 +2827,7 @@ impl ClientKvApi {
             move |resp, msg| {
                 let view = view_ext.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_external_is_exist", async move {
+                view.spawn("rpc_external_is_exist", async move {
                     let result = handle_external_is_exist(&view_task, &msg).await;
                     let _ = resp.send_resp(result).await;
                 });
@@ -1711,13 +2835,41 @@ impl ClientKvApi {
             },
         );
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchIsExistReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_is_exist", async move {
+                    let result = handle_external_batch_is_exist(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalObservabilitySnapshotReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_observability_snapshot", async move {
+                    let result = handle_external_observability_snapshot(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalDeleteAckReq>::new().regist(
             inner.view.p2p_module(),
             move |resp, msg| {
                 let view = view_ext.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_external_delete_ack", async move {
+                view.spawn("rpc_external_delete_ack", async move {
                     let result = handle_external_delete_ack(&view_task, &msg).await;
                     let _ = resp.send_resp(result).await;
                 });
@@ -1731,7 +2883,7 @@ impl ClientKvApi {
         RPCHandler::<SyncKvToFileReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
             let view = view_ext.clone();
             let view_task = view.clone();
-            let _ = view.spawn("rpc_sync_kv_to_file", async move {
+            view.spawn("rpc_sync_kv_to_file", async move {
                 let result = handle_sync_kv_to_file_client(&view_task, &msg).await;
                 let _ = resp.send_resp(result).await;
             });
@@ -1746,7 +2898,7 @@ impl ClientKvApi {
                 let req_node_id = resp.node_id().clone();
                 let view = view.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_batch_delete_client_kv_meta_cache", async move {
+                view.spawn("rpc_batch_delete_client_kv_meta_cache", async move {
                     let ack =
                         handle_batch_delete_client_kv_meta_cache(&view_task, msg, req_node_id)
                             .await;
@@ -1773,11 +2925,17 @@ impl ClientKvApi {
             .expect("delete_ack_batch rx already taken, that's impossible");
         delete::spawn_owner_delete_ack_batch(inner.view.clone_view(), delete_ack_batch_rx);
 
+        if let Some(write_back_append_rx) = inner.write_back_append_rx.lock().take() {
+            put::spawn_write_back_append_actor(inner.view.clone_view(), write_back_append_rx);
+        } else {
+            tracing::warn!("write_back_append_rx already taken for ClientKvApi");
+        }
+
         // Spawn cluster listener to clean up get_holding when external_client leaves
         let view = inner.view.clone_view();
         let view2 = view.clone();
         let view_task = view2.clone();
-        let _ = view.spawn("client_cluster_listener", async move {
+        view.spawn("client_cluster_listener", async move {
             let mut listen_cluster_event = view_task.cluster_manager().listen();
             let mut shutdown_waiter = view_task.register_shutdown_waiter();
 
@@ -1917,9 +3075,8 @@ impl ClientKvApi {
         tracing::info!("------------------------------------------------------------");
     }
 
-    #[cfg(any(test, feature = "test_bins"))]
     pub fn has_cached_key(&self, key: &str) -> bool {
-        self.inner().get_cached_info.contains_key(key)
+        self.inner().has_local_snapshot(key)
     }
 
     // Removed is_client_mode(): ClientKvApi is owner-only and always constructed.
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
index 55f0970..c53c634 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
@@ -1,9 +1,9 @@
 use crate::master_kv_router::put::PutIDForAKey;
 use crate::p2p::msg_pack::{MsgPackSerializePart, RPCReq};
-use crate::rpcresp_kvresult_convert::msg_and_error::ErrorCode;
+use crate::rpcresp_kvresult_convert::msg_and_error::{ErrorCode, OK};
 use bitcode::{Decode, Encode};
 
-use crate::memholder::ExternalMemHolderInfo;
+use crate::memholder::{ExternalMemHolder, ExternalMemHolderInfo};
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct TestPutPhaseTrace {
@@ -89,6 +89,371 @@ impl MsgPackSerializePart for ExternalGetResp {
     }
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetReq {
+    pub keys: Vec<String>,
+    pub req_node_id: String,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+    pub transfer_concurrency: usize,
+}
+impl MsgPackSerializePart for ExternalBatchGetReq {
+    fn msg_id(&self) -> u32 {
+        4020
+    }
+}
+impl RPCReq for ExternalBatchGetReq {
+    type Resp = ExternalBatchGetResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetItemResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub external_memholder_info: Option<ExternalMemHolderInfo>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetResp {
+    pub items: Vec<ExternalBatchGetItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchGetResp {
+    fn msg_id(&self) -> u32 {
+        4021
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetStartReq {
+    pub keys: Vec<String>,
+    pub req_node_id: String,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+    pub prefix_best_effort: bool,
+    pub atomic_group_lens: Option<Vec<usize>>,
+    pub transfer_concurrency: usize,
+}
+impl MsgPackSerializePart for ExternalBatchGetStartReq {
+    fn msg_id(&self) -> u32 {
+        4030
+    }
+}
+impl RPCReq for ExternalBatchGetStartReq {
+    type Resp = ExternalBatchGetStartResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetStartResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub handle: u64,
+    pub raw_prefix_hit_len: usize,
+}
+impl MsgPackSerializePart for ExternalBatchGetStartResp {
+    fn msg_id(&self) -> u32 {
+        4031
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetTransferReq {
+    pub handle: u64,
+    pub req_node_id: String,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchGetTransferReq {
+    fn msg_id(&self) -> u32 {
+        4032
+    }
+}
+impl RPCReq for ExternalBatchGetTransferReq {
+    type Resp = ExternalBatchGetTransferResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetTransferResp {
+    pub items: Vec<ExternalBatchGetItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchGetTransferResp {
+    fn msg_id(&self) -> u32 {
+        4033
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetCancelReq {
+    pub handle: u64,
+    pub req_node_id: String,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchGetCancelReq {
+    fn msg_id(&self) -> u32 {
+        4034
+    }
+}
+impl RPCReq for ExternalBatchGetCancelReq {
+    type Resp = ExternalBatchGetCancelResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetCancelResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchGetCancelResp {
+    fn msg_id(&self) -> u32 {
+        4035
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutStartItemReq {
+    pub key: String,
+    pub len: u64,
+    pub reject_if_inflight_same_key: bool,
+    pub reject_if_exist_same_key: bool,
+    pub write_through: bool,
+    pub preferred_sub_cluster: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutStartReq {
+    pub items: Vec<ExternalBatchPutStartItemReq>,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchPutStartReq {
+    fn msg_id(&self) -> u32 {
+        4022
+    }
+}
+impl RPCReq for ExternalBatchPutStartReq {
+    type Resp = ExternalBatchPutStartResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutStartItemResp {
+    pub error_code: ErrorCode,
+    pub src_offset: u64,
+    pub target_offset: u64,
+    pub transfer_target_offset: Option<u64>,
+    pub peer_id: Option<String>,
+    pub src_base_addr: u64,
+    pub target_base_addr: u64,
+    pub error_json: String,
+    pub put_id: Option<PutIDForAKey>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutStartResp {
+    pub items: Vec<ExternalBatchPutStartItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchPutStartResp {
+    fn msg_id(&self) -> u32 {
+        4023
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutTransferEndItemReq {
+    pub key: String,
+    pub len: u64,
+    pub src_offset: u64,
+    pub target_offset: u64,
+    pub peer_id: Option<String>,
+    pub target_base_addr: Option<u64>,
+    pub put_id: Option<PutIDForAKey>,
+    pub write_through: bool,
+    pub lease_id: Option<u64>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutTransferEndReq {
+    pub items: Vec<ExternalBatchPutTransferEndItemReq>,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+    pub transfer_concurrency: usize,
+}
+impl MsgPackSerializePart for ExternalBatchPutTransferEndReq {
+    fn msg_id(&self) -> u32 {
+        4024
+    }
+}
+impl RPCReq for ExternalBatchPutTransferEndReq {
+    type Resp = ExternalBatchPutTransferEndResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutTransferEndItemResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutTransferEndResp {
+    pub items: Vec<ExternalBatchPutTransferEndItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchPutTransferEndResp {
+    fn msg_id(&self) -> u32 {
+        4025
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutCommitItemReq {
+    pub key: String,
+    pub len: u64,
+    pub src_offset: u64,
+    pub remote_target: bool,
+    pub put_id: Option<PutIDForAKey>,
+    pub lease_id: Option<u64>,
+    pub write_through: bool,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutCommitReq {
+    pub items: Vec<ExternalBatchPutCommitItemReq>,
+    /// Owner node_start_time observed by the caller when request starts
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchPutCommitReq {
+    fn msg_id(&self) -> u32 {
+        4026
+    }
+}
+impl RPCReq for ExternalBatchPutCommitReq {
+    type Resp = ExternalBatchPutCommitResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutCommitItemResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchPutCommitResp {
+    pub items: Vec<ExternalBatchPutCommitItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchPutCommitResp {
+    fn msg_id(&self) -> u32 {
+        4027
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalIoLocalitySnapshot {
+    pub op_count: u64,
+    pub bytes: u64,
+    pub transfer_us: u64,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalObservabilitySnapshotReq {
+    /// Owner node_start_time observed by external when request starts.
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalObservabilitySnapshotReq {
+    fn msg_id(&self) -> u32 {
+        4028
+    }
+}
+impl RPCReq for ExternalObservabilitySnapshotReq {
+    type Resp = ExternalObservabilitySnapshotResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalObservabilitySnapshotResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub l2_local_hit_pages: u64,
+    pub l2_local_hit_bytes: u64,
+    pub l2_remote_hit_pages: u64,
+    pub l2_remote_hit_bytes: u64,
+    pub put_local: ExternalIoLocalitySnapshot,
+    pub put_remote: ExternalIoLocalitySnapshot,
+    pub get_local: ExternalIoLocalitySnapshot,
+    pub get_remote: ExternalIoLocalitySnapshot,
+}
+impl ExternalObservabilitySnapshotResp {
+    pub fn success(snapshot: crate::metrics::KvLocalitySnapshot) -> Self {
+        Self {
+            error_code: OK,
+            error_json: String::new(),
+            l2_local_hit_pages: snapshot.l2_local_hit_pages,
+            l2_local_hit_bytes: snapshot.l2_local_hit_bytes,
+            l2_remote_hit_pages: snapshot.l2_remote_hit_pages,
+            l2_remote_hit_bytes: snapshot.l2_remote_hit_bytes,
+            put_local: ExternalIoLocalitySnapshot {
+                op_count: snapshot.put_local.op_count,
+                bytes: snapshot.put_local.bytes,
+                transfer_us: snapshot.put_local.transfer_us,
+            },
+            put_remote: ExternalIoLocalitySnapshot {
+                op_count: snapshot.put_remote.op_count,
+                bytes: snapshot.put_remote.bytes,
+                transfer_us: snapshot.put_remote.transfer_us,
+            },
+            get_local: ExternalIoLocalitySnapshot {
+                op_count: snapshot.get_local.op_count,
+                bytes: snapshot.get_local.bytes,
+                transfer_us: snapshot.get_local.transfer_us,
+            },
+            get_remote: ExternalIoLocalitySnapshot {
+                op_count: snapshot.get_remote.op_count,
+                bytes: snapshot.get_remote.bytes,
+                transfer_us: snapshot.get_remote.transfer_us,
+            },
+        }
+    }
+
+    pub fn into_snapshot(self) -> crate::metrics::KvLocalitySnapshot {
+        crate::metrics::KvLocalitySnapshot {
+            l2_local_hit_pages: self.l2_local_hit_pages,
+            l2_local_hit_bytes: self.l2_local_hit_bytes,
+            l2_remote_hit_pages: self.l2_remote_hit_pages,
+            l2_remote_hit_bytes: self.l2_remote_hit_bytes,
+            put_local: crate::metrics::KvIoLocalitySnapshot {
+                op_count: self.put_local.op_count,
+                bytes: self.put_local.bytes,
+                transfer_us: self.put_local.transfer_us,
+            },
+            put_remote: crate::metrics::KvIoLocalitySnapshot {
+                op_count: self.put_remote.op_count,
+                bytes: self.put_remote.bytes,
+                transfer_us: self.put_remote.transfer_us,
+            },
+            get_local: crate::metrics::KvIoLocalitySnapshot {
+                op_count: self.get_local.op_count,
+                bytes: self.get_local.bytes,
+                transfer_us: self.get_local.transfer_us,
+            },
+            get_remote: crate::metrics::KvIoLocalitySnapshot {
+                op_count: self.get_remote.op_count,
+                bytes: self.get_remote.bytes,
+                transfer_us: self.get_remote.transfer_us,
+            },
+        }
+    }
+}
+impl MsgPackSerializePart for ExternalObservabilitySnapshotResp {
+    fn msg_id(&self) -> u32 {
+        4029
+    }
+}
+
 // #[derive(Default, Debug, Clone, Encode, Decode)]
 // pub struct ExternalPutReq {
 //     pub key: String,
@@ -114,6 +479,8 @@ pub struct ExternalPutStartReq {
     pub key: String,
     pub len: u64,
     pub reject_if_inflight_same_key: bool,
+    pub reject_if_exist_same_key: bool,
+    pub write_through: bool,
     /// Prefer placing the target allocation on any kvclient within this sub_cluster.
     pub preferred_sub_cluster: Option<String>,
     /// Owner node_start_time observed by external when request starts
@@ -159,6 +526,7 @@ pub struct ExternalPutTransferEndReq {
     pub peer_id: Option<String>,
     pub target_base_addr: Option<u64>,
     pub put_id: Option<PutIDForAKey>,
+    pub write_through: bool,
     /// Optional lease to attach this key to when committing
     pub lease_id: Option<u64>,
     /// Owner node_start_time observed by external when request starts
@@ -190,8 +558,12 @@ impl MsgPackSerializePart for ExternalPutTransferEndResp {
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalPutCommitReq {
     pub key: String,
+    pub len: u64,
+    pub src_offset: u64,
+    pub remote_target: bool,
     pub put_id: Option<PutIDForAKey>,
     pub lease_id: Option<u64>,
+    pub write_through: bool,
     /// Owner node_start_time observed by the caller when request starts
     pub started_time: i64,
     pub test_observe_put_phases: bool,
@@ -297,6 +669,34 @@ impl MsgPackSerializePart for ExternalIsExistResp {
     }
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchIsExistReq {
+    pub keys: Vec<String>,
+    pub allow_local_snapshot: bool,
+    /// Owner node_start_time observed by external when request starts
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchIsExistReq {
+    fn msg_id(&self) -> u32 {
+        crate::rpcresp_kvresult_convert::msg_and_error::MsgId::ExternalBatchIsExistReq as u32
+    }
+}
+impl RPCReq for ExternalBatchIsExistReq {
+    type Resp = ExternalBatchIsExistResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchIsExistResp {
+    pub error_code: ErrorCode,
+    pub exists_list: Vec<bool>,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchIsExistResp {
+    fn msg_id(&self) -> u32 {
+        crate::rpcresp_kvresult_convert::msg_and_error::MsgId::ExternalBatchIsExistResp as u32
+    }
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalDeleteAckReq {
     pub key: String,
@@ -326,10 +726,17 @@ impl MsgPackSerializePart for ExternalDeleteAckResp {
 }
 
 // --- RPC: Owner -> External to invalidate weak-index cache for keys ---
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalInvalidateWeakIndexItem {
+    pub key: String,
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalInvalidateWeakIndexReq {
-    /// Keys whose weak cache entries should be invalidated on external client
+    /// Keys whose weak cache entries should be invalidated on external client.
+    /// Kept for compatibility with older senders; new senders should use `items`.
     pub keys: Vec<String>,
+    pub items: Vec<ExternalInvalidateWeakIndexItem>,
 }
 impl MsgPackSerializePart for ExternalInvalidateWeakIndexReq {
     fn msg_id(&self) -> u32 {
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index 374ed71..225decf 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -1,7 +1,12 @@
-use super::ClientKvApiInner;
-use crate::cluster_manager::NodeIDString;
+use super::{
+    local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
+    ClientKvApiInner, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
+    OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, WriteBackAppendJob,
+};
 use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
+use crate::cluster_manager::NodeIDString;
 use crate::master_kv_router::put::PutIDForAKey;
+use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 // no StageScope; timestamps-based metrics only
 use crate::memholder::kvclient_encode::{calc_flat_dict_encoded_len, write_flat_dict_ptrs_to_ptr};
 use crate::observe_kvope::{
@@ -9,12 +14,24 @@ use crate::observe_kvope::{
     obe_put_transfer_error,
 };
 use crate::{
-    master_kv_router::msg_pack::{PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp},
+    client_kv_api::ClientKvApiView,
+    master_kv_router::msg_pack::{
+        BatchPreparePutKeyItemReq, BatchPreparePutKeysReq, BatchPreparePutKeysResp,
+        BatchPutDoneItemReq, BatchPutDoneReq, BatchPutDoneResp, BatchPutRevokeItemReq,
+        BatchPutRevokeReq, BatchPutRevokeResp, BatchPutStartItemReq, BatchPutStartReq,
+        BatchPutStartResp, BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
+        PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq, PutAppendStartReq,
+        PutAppendStartResp, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
+        ReleaseLocalGrantReq, ReserveLocalGrantReq, ReserveLocalGrantResp,
+    },
     p2p::msg_pack::MsgPack,
+    p2p::p2p_module::RpcTransportPolicy,
     rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult},
 };
 use chrono::Utc;
 use fluxon_commu::TransferBreakdown;
+use futures::stream::{self, StreamExt};
+use limit_thirdparty::tokio;
 use std::time::Instant;
 use tracing::info;
 
@@ -22,19 +39,1016 @@ fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
     duration.as_micros().min(i64::MAX as u128) as i64
 }
 
+const OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES: u64 = 4 * 1024;
+fn owner_local_reserve_slot_size(value_len: u64) -> KvResult<u64> {
+    let normalized = value_len.max(OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES);
+    let slot_size = normalized.checked_next_power_of_two().ok_or_else(|| {
+        KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "value_len={} exceeds resident local reserve slot size range",
+                value_len
+            ),
+        })
+    })?;
+    if slot_size > OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "value_len={} requires slot_size={} larger than local reserve grant quantum={}",
+                value_len, slot_size, OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES
+            ),
+        }));
+    }
+    Ok(slot_size)
+}
+
+fn owner_local_reserve_slots_per_grant(slot_size: u64) -> u32 {
+    let slots = (OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES / slot_size).max(1);
+    slots.min(u32::MAX as u64) as u32
+}
+
+fn owner_local_reserve_install_grant(
+    pool: &mut OwnerLocalReservePoolState,
+    slot_size: u64,
+    slots_per_grant: u32,
+    grant: OwnerLocalReserveGrantState,
+) {
+    let class_state = pool
+        .classes
+        .entry(slot_size)
+        .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+    assert!(
+        class_state.slot_size == slot_size,
+        "slot_size drift detected while installing local reserve grant"
+    );
+    assert!(
+        class_state.slots_per_grant == slots_per_grant,
+        "slots_per_grant drift detected while installing local reserve grant"
+    );
+    class_state.grants.push(grant);
+}
+
+fn owner_local_reserve_try_claim(
+    pool: &mut OwnerLocalReservePoolState,
+    slot_size: u64,
+    slots_per_grant: u32,
+    value_len: u64,
+    key_count: usize,
+) -> Option<OwnerLocalReserveSlotLease> {
+    let class_state = pool
+        .classes
+        .entry(slot_size)
+        .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+    if class_state.free_slot_count() < key_count {
+        return None;
+    }
+    let mut slots = Vec::with_capacity(key_count);
+    for grant in class_state.grants.iter_mut() {
+        while slots.len() < key_count {
+            match grant.claim_prepared_slot() {
+                Some(slot) => slots.push(slot),
+                None => break,
+            }
+        }
+        if slots.len() == key_count {
+            break;
+        }
+    }
+    assert!(
+        slots.len() == key_count,
+        "free_slot_count check and claim path diverged"
+    );
+    Some(OwnerLocalReserveSlotLease {
+        value_len,
+        slot_size,
+        slots,
+    })
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnerReservedPutItem {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub src_addr: u64,
+    pub src_base_addr: u64,
+    pub target_addr: u64,
+    pub target_base_addr: u64,
+    pub value_len: u64,
+    pub lease_id: Option<u64>,
+    pub peer_node_id: Option<NodeIDString>,
+    pub write_through: bool,
+    pub remember_local_snapshot: bool,
+    pub enqueue_write_back_append: bool,
+    pub preferred_sub_cluster: Option<String>,
+}
+
 #[derive(Debug, Clone, Copy, Default)]
 pub struct PutEndStats {
     pub master_put_end_rpc_us: i64,
     pub master_put_end_server_us: i64,
 }
 
+pub struct PutEndWithLocalCachePublish {
+    pub stats: PutEndStats,
+    pub local_cache_holder_id: Option<u64>,
+}
+
 impl ClientKvApiInner {
+    pub async fn owner_claim_local_reserve_slot_lease(
+        &self,
+        value_len: u64,
+        key_count: usize,
+    ) -> KvResult<OwnerLocalReserveSlotLease> {
+        let slot_size = owner_local_reserve_slot_size(value_len)?;
+        let slots_per_grant = owner_local_reserve_slots_per_grant(slot_size);
+        let (soft_wait_timeout, hard_wait_timeout) = owner_local_reserve_timeout_config(self);
+        let hard_deadline = Instant::now()
+            .checked_add(hard_wait_timeout)
+            .ok_or_else(|| {
+                KvError::Api(ApiError::Unknown {
+                    detail: "owner local reserve hard timeout overflow".to_string(),
+                })
+            })?;
+        let mut pending_demand_registered = false;
+        let claim_result = {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let class_state = pool
+                .classes
+                .entry(slot_size)
+                .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+            if class_state.free_slot_count() >= key_count {
+                Some(owner_local_reserve_try_claim(
+                    &mut pool,
+                    slot_size,
+                    slots_per_grant,
+                    value_len,
+                    key_count,
+                ))
+            } else {
+                None
+            }
+        };
+        if let Some(Some(lease)) = claim_result {
+            return Ok(lease);
+        }
+        self.owner_local_reserve_register_pending_demand(slot_size, slots_per_grant, key_count);
+        pending_demand_registered = true;
+        self.owner_local_reserve_rebalance_notify().notify_waiters();
+        if !wait_owner_local_reserve_ready(
+            self,
+            slot_size,
+            slots_per_grant,
+            key_count,
+            soft_wait_timeout,
+            hard_deadline,
+        )
+        .await
+        {
+            let soft_wait_timeout_ms = soft_wait_timeout.as_millis();
+            let hard_wait_timeout_ms = hard_wait_timeout.as_millis();
+            if pending_demand_registered {
+                self.owner_local_reserve_consume_pending_demand(
+                    slot_size,
+                    slots_per_grant,
+                    key_count,
+                );
+            }
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "owner local reserve refill timeout: slot_size={} key_count={} soft_wait_timeout_ms={} hard_timeout_ms={}",
+                    slot_size, key_count, soft_wait_timeout_ms, hard_wait_timeout_ms
+                ),
+            }));
+        }
+        let claim_result = {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let class_state = pool
+                .classes
+                .entry(slot_size)
+                .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+            if class_state.free_slot_count() >= key_count {
+                Some(owner_local_reserve_try_claim(
+                    &mut pool,
+                    slot_size,
+                    slots_per_grant,
+                    value_len,
+                    key_count,
+                ))
+            } else {
+                None
+            }
+        };
+        if let Some(Some(lease)) = claim_result {
+            self.owner_local_reserve_consume_pending_demand(slot_size, slots_per_grant, key_count);
+            return Ok(lease);
+        }
+        self.owner_local_reserve_consume_pending_demand(slot_size, slots_per_grant, key_count);
+        Err(KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "owner local reserve ready check returned without available slots: slot_size={} key_count={}",
+                slot_size, key_count
+            ),
+        }))
+    }
+
+    pub async fn owner_release_local_reserve_slot_lease(
+        &self,
+        lease: OwnerLocalReserveSlotLease,
+    ) -> KvResult<()> {
+        {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let Some(class_state) = pool.classes.get_mut(&lease.slot_size) else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "resident local reserve class missing while releasing slot lease: slot_size={}",
+                        lease.slot_size
+                    ),
+                }));
+            };
+            for slot_ref in &lease.slots {
+                let Some(grant) = class_state
+                    .grants
+                    .iter_mut()
+                    .find(|grant| grant.grant_id == slot_ref.grant_id)
+                else {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "resident local reserve grant missing while releasing slot lease: grant_id={}",
+                            slot_ref.grant_id
+                        ),
+                    }));
+                };
+                grant.release_prepared_slot(slot_ref.slot_index);
+            }
+        }
+        self.owner_local_reserve_rebalance_notify().notify_waiters();
+        Ok(())
+    }
+
+    pub fn owner_mark_local_reserve_slot_pending_visible(
+        &self,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<()> {
+        let mut pool = self.owner_local_reserve_pool.lock();
+        let Some(class_state) = pool.classes.get_mut(&slot_size) else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "local reserve class missing while marking pending slot: slot_size={}",
+                    slot_size
+                ),
+            }));
+        };
+        let Some(grant) = class_state
+            .grants
+            .iter_mut()
+            .find(|grant| grant.grant_id == grant_id)
+        else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "local reserve grant missing while marking pending slot: grant_id={}",
+                    grant_id
+                ),
+            }));
+        };
+        grant.mark_prepared_slot_pending_visible(slot_index);
+        Ok(())
+    }
+
+    pub fn owner_promote_local_reserve_pending_slot_to_committed(
+        &self,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<()> {
+        let mut pool = self.owner_local_reserve_pool.lock();
+        let Some(class_state) = pool.classes.get_mut(&slot_size) else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "local reserve class missing while promoting pending slot: slot_size={}",
+                    slot_size
+                ),
+            }));
+        };
+        let Some(grant) = class_state
+            .grants
+            .iter_mut()
+            .find(|grant| grant.grant_id == grant_id)
+        else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "local reserve grant missing while promoting pending slot: grant_id={}",
+                    grant_id
+                ),
+            }));
+        };
+        grant.promote_pending_visible_slot_to_committed(slot_index);
+        Ok(())
+    }
+
+    pub fn owner_retain_local_reserve_resident_slot_holder(
+        &self,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<()> {
+        let mut pool = self.owner_local_reserve_pool.lock();
+        let Some(class_state) = pool.classes.get_mut(&slot_size) else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "local reserve class missing while retaining resident slot holder: slot_size={}",
+                    slot_size
+                ),
+            }));
+        };
+        let Some(grant) = class_state
+            .grants
+            .iter_mut()
+            .find(|grant| grant.grant_id == grant_id)
+        else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "local reserve grant missing while retaining resident slot holder: grant_id={}",
+                    grant_id
+                ),
+            }));
+        };
+        grant.retain_resident_slot_holder(slot_index);
+        Ok(())
+    }
+
+    pub fn owner_release_local_reserve_resident_slot_holder(
+        &self,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<()> {
+        {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let Some(class_state) = pool.classes.get_mut(&slot_size) else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "local reserve class missing while releasing resident slot holder: slot_size={}",
+                        slot_size
+                    ),
+                }));
+            };
+            let Some(grant) = class_state
+                .grants
+                .iter_mut()
+                .find(|grant| grant.grant_id == grant_id)
+            else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "local reserve grant missing while releasing resident slot holder: grant_id={}",
+                        grant_id
+                    ),
+                }));
+            };
+            grant.release_resident_slot_holder(slot_index);
+        }
+        self.owner_local_reserve_rebalance_notify().notify_waiters();
+        Ok(())
+    }
+
+    pub fn owner_release_local_reserve_committed_slot_route(
+        &self,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<()> {
+        {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let Some(class_state) = pool.classes.get_mut(&slot_size) else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "local reserve class missing while releasing committed slot route: slot_size={}",
+                        slot_size
+                    ),
+                }));
+            };
+            let Some(grant) = class_state
+                .grants
+                .iter_mut()
+                .find(|grant| grant.grant_id == grant_id)
+            else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "local reserve grant missing while releasing committed slot route: grant_id={}",
+                        grant_id
+                    ),
+                }));
+            };
+            grant.release_committed_slot_route(slot_index);
+        }
+        self.owner_local_reserve_rebalance_notify().notify_waiters();
+        Ok(())
+    }
+
+    pub async fn owner_shutdown_local_reserve_pool(&self) -> KvResult<()> {
+        let grants = {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let mut detached = Vec::new();
+            for (_slot_size, class_state) in pool.classes.drain() {
+                detached.extend(class_state.grants);
+            }
+            detached
+        };
+        let mut first_err = None;
+        for grant in grants {
+            if let Err(err) = self.release_local_grant(grant.grant_id).await {
+                if first_err.is_none() {
+                    first_err = Some(err);
+                } else {
+                    tracing::warn!(
+                        "owner_shutdown_local_reserve_pool dropped additional release error after the first one: {}",
+                        err
+                    );
+                }
+            }
+        }
+        if let Some(err) = first_err {
+            return Err(err);
+        }
+        Ok(())
+    }
+
+    pub async fn owner_batch_put_start_reserved(
+        &self,
+        start_items: Vec<BatchPutStartItemReq>,
+        lease_id: Option<u64>,
+    ) -> KvResult<Vec<OwnerReservedPutItem>> {
+        if start_items.is_empty() {
+            return Ok(Vec::new());
+        }
+        if self.short_circuit_put_payload_path_enabled() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail:
+                    "owner_batch_put_start_reserved does not support short_circuit_put_payload_path"
+                        .to_string(),
+            }));
+        }
+        let self_node_id = self.view.cluster_manager().get_self_info().id.clone();
+        let start_resp = self.batch_put_start(start_items.clone()).await?;
+        if start_resp.items.len() != start_items.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_put_start response length mismatch: expected={} got={}",
+                    start_items.len(),
+                    start_resp.items.len()
+                ),
+            }));
+        }
+
+        let mut prepared_items = Vec::with_capacity(start_items.len());
+        let mut revoke_items = Vec::with_capacity(start_items.len());
+        let mut first_error: Option<KvError> = None;
+
+        for (start_req, start_item) in start_items.into_iter().zip(start_resp.items.into_iter()) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                start_item.error_code,
+                start_item.error_json.clone(),
+            ) {
+                first_error = Some(err);
+                break;
+            }
+            let peer_node_id = if start_item.node_id == self_node_id {
+                None
+            } else {
+                Some(start_item.node_id.clone())
+            };
+            revoke_items.push(BatchPutRevokeItemReq {
+                key: start_req.key.clone(),
+                put_id: start_item.put_id,
+            });
+            prepared_items.push(OwnerReservedPutItem {
+                key: start_req.key,
+                put_id: start_item.put_id,
+                src_addr: start_item.src_addr,
+                src_base_addr: start_item.src_base_addr,
+                target_addr: start_item.target_addr,
+                target_base_addr: start_item.target_base_addr,
+                value_len: start_req.len,
+                lease_id,
+                peer_node_id: peer_node_id.clone(),
+                write_through: start_req.write_through,
+                remember_local_snapshot: !start_req.write_through || peer_node_id.is_none(),
+                enqueue_write_back_append: !start_req.write_through && peer_node_id.is_some(),
+                preferred_sub_cluster: start_req.preferred_sub_cluster,
+            });
+        }
+
+        if let Some(err) = first_error {
+            if !revoke_items.is_empty() {
+                if let Err(revoke_err) = self.batch_put_revoke(revoke_items).await {
+                    tracing::warn!(
+                        "owner_batch_put_start_reserved batch_put_revoke failed after partial reserve: {}",
+                        revoke_err
+                    );
+                }
+            }
+            return Err(err);
+        }
+
+        Ok(prepared_items)
+    }
+
+    pub async fn owner_batch_put_commit_reserved(
+        &self,
+        items: Vec<OwnerReservedPutItem>,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<()>>> {
+        if items.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        #[derive(Clone)]
+        struct DonePending {
+            idx: usize,
+            item: OwnerReservedPutItem,
+        }
+
+        let transfer_concurrency = transfer_concurrency.max(1);
+        let metrics = self.metrics_handle();
+        let mut results: Vec<Option<KvResult<()>>> = (0..items.len()).map(|_| None).collect();
+        let mut done_pending = Vec::with_capacity(items.len());
+        let mut revoke_pending = Vec::new();
+        let mut transfer_futures = Vec::new();
+
+        for (idx, item) in items.into_iter().enumerate() {
+            if !item.write_through {
+                metrics.record_put_io_locality(false, item.value_len, 0);
+                done_pending.push(DonePending { idx, item });
+                continue;
+            }
+            if item.peer_node_id.is_none() && item.src_addr == item.target_addr {
+                metrics.record_put_io_locality(false, item.value_len, 0);
+                done_pending.push(DonePending { idx, item });
+                continue;
+            }
+
+            let src_offset = item.src_addr - item.src_base_addr;
+            let target_offset = if item.peer_node_id.is_some() {
+                item.target_addr - item.target_base_addr
+            } else {
+                item.target_addr - item.src_base_addr
+            };
+            transfer_futures.push(async move {
+                let transfer_started_at = Instant::now();
+                let transfer_result = self
+                    .put_transfer(
+                        &item.key,
+                        item.put_id,
+                        src_offset,
+                        target_offset,
+                        item.value_len,
+                        item.peer_node_id.clone(),
+                        item.peer_node_id.as_ref().map(|_| item.target_base_addr),
+                    )
+                    .await;
+                (
+                    idx,
+                    item,
+                    duration_to_i64_us(transfer_started_at.elapsed()),
+                    transfer_result,
+                )
+            });
+        }
+
+        let mut transfer_stream =
+            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
+        while let Some(joined) = transfer_stream.next().await {
+            match joined {
+                (idx, item, wall_transfer_us, Ok(breakdown)) => {
+                    let breakdown_transfer_us = breakdown.submit_blocking_us
+                        + breakdown.create_xfer_req_us
+                        + breakdown.post_xfer_req_us
+                        + breakdown.poll_wait_us;
+                    let transfer_us = breakdown_transfer_us.max(wall_transfer_us);
+                    metrics.record_put_io_locality(
+                        breakdown.remote_transfer,
+                        item.value_len,
+                        transfer_us,
+                    );
+                    done_pending.push(DonePending { idx, item });
+                }
+                (idx, item, _wall_transfer_us, Err(err)) => {
+                    results[idx] = Some(Err(err));
+                    revoke_pending.push(BatchPutRevokeItemReq {
+                        key: item.key,
+                        put_id: item.put_id,
+                    });
+                }
+            }
+        }
+
+        if !revoke_pending.is_empty() {
+            if let Err(err) = self.batch_put_revoke(revoke_pending).await {
+                tracing::warn!(
+                    "owner_batch_put_commit_reserved batch_put_revoke failed after transfer errors: {}",
+                    err
+                );
+            }
+        }
+
+        if self.skip_put_end_commit_enabled() {
+            for pending in done_pending {
+                results[pending.idx] = Some(Ok(()));
+            }
+            return Ok(results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| {
+                        Err(KvError::Api(ApiError::Unknown {
+                            detail: "owner_batch_put_commit_reserved result slot was not populated"
+                                .to_string(),
+                        }))
+                    })
+                })
+                .collect());
+        }
+
+        let done_req_items = done_pending
+            .iter()
+            .map(|pending| BatchPutDoneItemReq {
+                key: pending.item.key.clone(),
+                put_id: pending.item.put_id,
+                lease_id: pending.item.lease_id,
+                committed_slot: None,
+                publish_local_cache: false,
+            })
+            .collect::<Vec<_>>();
+        let done_resp = self.batch_put_done(done_req_items).await?;
+        if done_resp.items.len() != done_pending.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_put_done response length mismatch: expected={} got={}",
+                    done_pending.len(),
+                    done_resp.items.len()
+                ),
+            }));
+        }
+
+        for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                done_item.error_code,
+                done_item.error_json.clone(),
+            ) {
+                results[pending.idx] = Some(Err(err));
+                continue;
+            }
+            if pending.item.remember_local_snapshot {
+                self.remember_local_snapshot(&pending.item.key, pending.item.put_id);
+            }
+            if pending.item.enqueue_write_back_append {
+                if let Err(err) = self
+                    .enqueue_write_back_remote_append(
+                        &pending.item.key,
+                        pending.item.put_id,
+                        pending.item.preferred_sub_cluster.as_deref(),
+                    )
+                    .await
+                {
+                    tracing::warn!(
+                        "owner_batch_put_commit_reserved write-back remote append enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        pending.item.key,
+                        pending.item.put_id.0,
+                        pending.item.put_id.1,
+                        err
+                    );
+                }
+            }
+            results[pending.idx] = Some(Ok(()));
+        }
+
+        Ok(results
+            .into_iter()
+            .map(|item| {
+                item.unwrap_or_else(|| {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: "owner_batch_put_commit_reserved result slot was not populated"
+                            .to_string(),
+                    }))
+                })
+            })
+            .collect())
+    }
+
+    pub async fn owner_batch_put_abort_reserved(
+        &self,
+        items: Vec<OwnerReservedPutItem>,
+    ) -> KvResult<()> {
+        if items.is_empty() {
+            return Ok(());
+        }
+        let revoke_items = items
+            .into_iter()
+            .map(|item| BatchPutRevokeItemReq {
+                key: item.key,
+                put_id: item.put_id,
+            })
+            .collect::<Vec<_>>();
+        self.batch_put_revoke(revoke_items).await?;
+        Ok(())
+    }
+
+    pub async unsafe fn batch_put_flat_dict_ptrs(
+        &self,
+        keys: Vec<String>,
+        ptrs_groups: Vec<Vec<(u8, usize, u32, u64, u32, Option<u32>)>>,
+        opts: crate::client_kv_api::PutOptionalArgs,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<()>>> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_put_flat_dict_ptrs"
+                    .to_string(),
+            }));
+        }
+        if keys.len() != ptrs_groups.len() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "batch_put_flat_dict_ptrs requires keys and ptrs_groups to have the same length: keys={} ptrs_groups={}",
+                    keys.len(),
+                    ptrs_groups.len()
+                ),
+            }));
+        }
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+        let transfer_concurrency = transfer_concurrency.max(1);
+        let lease_id = opts.lease_id();
+        let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
+        let reject_if_exist_same_key = opts.reject_if_exist_same_key();
+        let write_through = opts.write_through();
+        let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
+
+        let mut start_items = Vec::with_capacity(keys.len());
+        let mut payload_lens = Vec::with_capacity(keys.len());
+        for (key, ptrs) in keys.iter().zip(ptrs_groups.iter()) {
+            let payload_len = calc_flat_dict_encoded_len(ptrs)?;
+            payload_lens.push(payload_len);
+            start_items.push(BatchPutStartItemReq {
+                key: key.clone(),
+                len: payload_len,
+                reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
+                preferred_sub_cluster: preferred_sub_cluster.clone(),
+            });
+        }
+
+        let start_resp = self.batch_put_start(start_items).await?;
+        if start_resp.items.len() != keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_put_start response length mismatch: expected={} got={}",
+                    keys.len(),
+                    start_resp.items.len()
+                ),
+            }));
+        }
+
+        #[derive(Clone)]
+        struct DonePending {
+            idx: usize,
+            key: String,
+            put_id: PutIDForAKey,
+            lease_id: Option<u64>,
+            remember_local_snapshot: bool,
+            enqueue_write_back_append: bool,
+        }
+
+        let self_node_id = self.view.cluster_manager().get_self_info().id.clone();
+        let mut results: Vec<Option<KvResult<()>>> = (0..keys.len()).map(|_| None).collect();
+        let mut done_pending = Vec::new();
+        let mut revoke_pending = Vec::new();
+        let mut transfer_futures = Vec::new();
+        let short_circuit_payload = self.short_circuit_put_payload_path_enabled();
+        let skip_put_end_commit = self.skip_put_end_commit_enabled();
+
+        for (idx, (((key, ptrs), payload_len), start_item)) in keys
+            .into_iter()
+            .zip(ptrs_groups.into_iter())
+            .zip(payload_lens.into_iter())
+            .zip(start_resp.items.into_iter())
+            .enumerate()
+        {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                start_item.error_code,
+                start_item.error_json.clone(),
+            ) {
+                results[idx] = Some(Err(err));
+                continue;
+            }
+
+            let put_id = start_item.put_id;
+            let peer_id = if start_item.node_id == self_node_id {
+                None
+            } else {
+                Some(start_item.node_id.clone())
+            };
+            let remember_local_snapshot = !write_through || peer_id.is_none();
+
+            if !short_circuit_payload {
+                unsafe {
+                    write_flat_dict_ptrs_to_ptr(start_item.src_addr as *mut u8, &ptrs);
+                }
+            }
+
+            if !write_through {
+                done_pending.push(DonePending {
+                    idx,
+                    key,
+                    put_id,
+                    lease_id,
+                    remember_local_snapshot,
+                    enqueue_write_back_append: !short_circuit_payload && peer_id.is_some(),
+                });
+                continue;
+            }
+
+            if short_circuit_payload
+                || (peer_id.is_none() && start_item.src_addr == start_item.target_addr)
+            {
+                done_pending.push(DonePending {
+                    idx,
+                    key,
+                    put_id,
+                    lease_id,
+                    remember_local_snapshot,
+                    enqueue_write_back_append: false,
+                });
+                continue;
+            }
+
+            let target_base_addr_opt = peer_id.as_ref().map(|_| start_item.target_base_addr);
+            let src_offset = start_item.src_addr - start_item.src_base_addr;
+            let target_offset = start_item.target_addr - start_item.target_base_addr;
+            transfer_futures.push(async move {
+                let transfer_result = self
+                    .put_transfer(
+                        &key,
+                        put_id,
+                        src_offset,
+                        target_offset,
+                        payload_len,
+                        peer_id,
+                        target_base_addr_opt,
+                    )
+                    .await;
+                (idx, key, put_id, remember_local_snapshot, transfer_result)
+            });
+        }
+
+        let mut transfer_stream =
+            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
+        while let Some(joined) = transfer_stream.next().await {
+            match joined {
+                (idx, key, put_id, remember_local_snapshot, Ok(_breakdown)) => {
+                    done_pending.push(DonePending {
+                        idx,
+                        key,
+                        put_id,
+                        lease_id,
+                        remember_local_snapshot,
+                        enqueue_write_back_append: false,
+                    });
+                }
+                (idx, key, put_id, _remember_local_snapshot, Err(err)) => {
+                    results[idx] = Some(Err(err));
+                    revoke_pending.push(BatchPutRevokeItemReq { key, put_id });
+                }
+            }
+        }
+
+        if !revoke_pending.is_empty() {
+            if let Err(err) = self.batch_put_revoke(revoke_pending).await {
+                tracing::warn!("batch_put_revoke failed after transfer errors: {}", err);
+            }
+        }
+
+        if skip_put_end_commit {
+            for pending in done_pending {
+                results[pending.idx] = Some(Ok(()));
+            }
+            return Ok(results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| {
+                        Err(KvError::Api(ApiError::Unknown {
+                            detail: "batch_put result slot was not populated".to_string(),
+                        }))
+                    })
+                })
+                .collect());
+        }
+
+        let done_req_items = done_pending
+            .iter()
+            .map(|pending| BatchPutDoneItemReq {
+                key: pending.key.clone(),
+                put_id: pending.put_id,
+                lease_id: pending.lease_id,
+                committed_slot: None,
+                publish_local_cache: false,
+            })
+            .collect::<Vec<_>>();
+        let done_resp = self.batch_put_done(done_req_items).await?;
+        if done_resp.items.len() != done_pending.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "batch_put_done response length mismatch: expected={} got={}",
+                    done_pending.len(),
+                    done_resp.items.len()
+                ),
+            }));
+        }
+        for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                done_item.error_code,
+                done_item.error_json.clone(),
+            ) {
+                results[pending.idx] = Some(Err(err));
+                continue;
+            }
+            if pending.remember_local_snapshot {
+                self.remember_local_snapshot(&pending.key, pending.put_id);
+            }
+            if pending.enqueue_write_back_append {
+                if let Err(err) = self
+                    .enqueue_write_back_remote_append(
+                        &pending.key,
+                        pending.put_id,
+                        preferred_sub_cluster.as_deref(),
+                    )
+                    .await
+                {
+                    tracing::warn!(
+                        "batch write-back remote append enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        pending.key,
+                        pending.put_id.0,
+                        pending.put_id.1,
+                        err
+                    );
+                }
+            }
+            results[pending.idx] = Some(Ok(()));
+        }
+
+        Ok(results
+            .into_iter()
+            .map(|item| {
+                item.unwrap_or_else(|| {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: "batch_put result slot was not populated".to_string(),
+                    }))
+                })
+            })
+            .collect())
+    }
+
+    pub async fn enqueue_write_back_remote_append(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        preferred_sub_cluster: Option<&str>,
+    ) -> KvResult<()> {
+        let Some((holder, _)) = self.get(key).await? else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "write-back local commit did not produce a readable current replica: key={} put_id=({},{})",
+                    key, put_id.0, put_id.1
+                ),
+            }));
+        };
+        self.write_back_append_tx
+            .send(WriteBackAppendJob {
+                key: key.to_string(),
+                put_id,
+                holder,
+                preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
+            })
+            .await
+            .map_err(|err| {
+                KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "write-back append actor queue send failed: key={} put_id=({},{}) err={}",
+                        key, put_id.0, put_id.1, err
+                    ),
+                })
+            })
+    }
+
     async fn put_common<F>(
         &self,
         key: &str,
         payload_len: u64,
         len_for_start: u32,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         preferred_sub_cluster: Option<&str>,
         lease_id: Option<u64>,
         _test_payload_len_u32: u32,
@@ -57,6 +1071,8 @@ impl ClientKvApiInner {
                     key,
                     len_for_start,
                     reject_if_inflight_same_key,
+                    reject_if_exist_same_key,
+                    write_through,
                     preferred_sub_cluster,
                 )
                 .await
@@ -123,10 +1139,14 @@ impl ClientKvApiInner {
                 skipped_breakdown.poll_wait_us,
                 skipped_breakdown.poll_iters,
                 skipped_breakdown.used_fast_path,
+                false,
                 skipped_breakdown.local_noop,
                 skipped_breakdown.remote_transfer,
             );
             self.put_end(key, put_id, lease_id).await?;
+            if !write_through || peer_id.is_none() {
+                self.remember_local_snapshot(key, put_id);
+            }
             if let Some(tag) = info_complete_tag {
                 info!("{tag} complete key={} bytes={}", key, payload_len);
             }
@@ -150,6 +1170,31 @@ impl ClientKvApiInner {
             .await
             .unwrap()
             .allocated_addr;
+        if !write_through {
+            self.put_end(key, put_id, lease_id).await?;
+            self.remember_local_snapshot(key, put_id);
+            if peer_id.is_some() {
+                if let Err(err) = self
+                    .enqueue_write_back_remote_append(key, put_id, preferred_sub_cluster)
+                    .await
+                {
+                    tracing::warn!(
+                        "write-back remote append enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        key,
+                        put_id.0,
+                        put_id.1,
+                        err
+                    );
+                }
+            }
+            if let Some(tag) = info_complete_tag {
+                info!(
+                    "{tag} local_commit_complete key={} bytes={}",
+                    key, payload_len
+                );
+            }
+            return Ok(());
+        }
         let src_offset = abs_src - base_addr;
         let (target_offset, target_base_addr_opt) = match &peer_id {
             Some(_) => (
@@ -201,6 +1246,7 @@ impl ClientKvApiInner {
             transfer_breakdown.poll_wait_us,
             transfer_breakdown.poll_iters,
             transfer_breakdown.used_fast_path,
+            false,
             transfer_breakdown.local_noop,
             transfer_breakdown.remote_transfer,
         );
@@ -224,7 +1270,9 @@ impl ClientKvApiInner {
         }
 
         self.put_end(key, put_id, lease_id).await?;
-        self.cache_metadata_only_after_put(key, put_id);
+        if peer_id.is_none() {
+            self.remember_local_snapshot(key, put_id);
+        }
         if let Some(tag) = info_complete_tag {
             info!("{tag} complete key={} bytes={}", key, payload_len);
         }
@@ -243,6 +1291,8 @@ impl ClientKvApiInner {
     ) -> KvResult<()> {
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
+        let reject_if_exist_same_key = opts.reject_if_exist_same_key();
+        let write_through = opts.write_through();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
 
         let payload_len = calc_flat_dict_encoded_len(&ptrs)?;
@@ -251,6 +1301,8 @@ impl ClientKvApiInner {
             payload_len,
             payload_len as u32,
             reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
             preferred_sub_cluster.as_deref(),
             lease_id,
             payload_len as u32,
@@ -276,6 +1328,8 @@ impl ClientKvApiInner {
     ) -> KvResult<()> {
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
+        let reject_if_exist_same_key = opts.reject_if_exist_same_key();
+        let write_through = opts.write_through();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let payload_len = value.len() as u64;
         self.put_common(
@@ -283,6 +1337,8 @@ impl ClientKvApiInner {
             payload_len,
             value.len() as u32,
             reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
             preferred_sub_cluster.as_deref(),
             lease_id,
             value.len() as u32,
@@ -361,11 +1417,12 @@ impl ClientKvApiInner {
                 .transfer_data_no_copy(peer_id.clone(), false, abs_src, abs_target, len, None)
                 .await?;
             tracing::debug!(
-                "put_transfer breakdown: key={}, put_id=({},{}) fast_path={} local_noop={} remote_transfer={} submit_blocking_us={} create_xfer_req_us={} post_xfer_req_us={} poll_wait_us={} poll_iters={}",
+                "put_transfer breakdown: key={}, put_id=({},{}) fast_path={} nixl={} local_noop={} remote_transfer={} submit_blocking_us={} create_xfer_req_us={} post_xfer_req_us={} poll_wait_us={} poll_iters={}",
                 key,
                 put_id.0,
                 put_id.1,
                 breakdown.used_fast_path,
+                false,
                 breakdown.local_noop,
                 breakdown.remote_transfer,
                 breakdown.submit_blocking_us,
@@ -401,6 +1458,8 @@ impl ClientKvApiInner {
         key: &str,
         len: u32,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         preferred_sub_cluster: Option<&str>,
         source_node_id: Option<NodeIDString>,
     ) -> KvResult<(PutStartResp, i64)> {
@@ -409,6 +1468,8 @@ impl ClientKvApiInner {
                 key: key.to_string(),
                 len: len as u64,
                 reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                 source_node_id,
             },
@@ -458,18 +1519,88 @@ impl ClientKvApiInner {
         key: &str,
         len: u32,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         preferred_sub_cluster: Option<&str>,
     ) -> KvResult<(PutStartResp, i64)> {
         self.put_start_with_source_node(
             key,
             len,
             reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
             preferred_sub_cluster,
             None,
         )
         .await
     }
 
+    pub async fn reserve_local_grant(&self) -> KvResult<ReserveLocalGrantResp> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting reserve_local_grant".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: ReserveLocalGrantReq::default(),
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_reserve_local_grant
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn release_local_grant(&self, grant_id: u64) -> KvResult<()> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting release_local_grant".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: ReleaseLocalGrantReq { grant_id },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_release_local_grant
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(())
+    }
+
     /// 撤销 Put 操作，释放已分配的资源
     pub async fn put_revoke(&self, key: &str, put_id: PutIDForAKey) -> KvResult<()> {
         if !self.view.register_shutdown_poller().is_running() {
@@ -509,6 +1640,338 @@ impl ClientKvApiInner {
         Ok(())
     }
 
+    pub async fn put_append_start(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        len: u32,
+        preferred_sub_cluster: Option<&str>,
+    ) -> KvResult<PutAppendStartResp> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting put_append_start".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: PutAppendStartReq {
+                key: key.to_string(),
+                put_id,
+                len: len as u64,
+                preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_put_append_start
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn put_append_revoke(&self, key: &str, put_id: PutIDForAKey) -> KvResult<()> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting put_append_revoke".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: PutAppendRevokeReq {
+                key: key.to_string(),
+                put_id,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let _resp = self
+            .rpc_caller_put_append_revoke
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        Ok(())
+    }
+
+    pub async fn put_append_done(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+    ) -> KvResult<PutAppendDoneResp> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting put_append_done".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: PutAppendDoneReq {
+                key: key.to_string(),
+                put_id,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_put_append_done
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_put_start(
+        &self,
+        items: Vec<BatchPutStartItemReq>,
+    ) -> KvResult<BatchPutStartResp> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_put_start".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchPutStartReq { items },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_put_start
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_prepare_put_keys(
+        &self,
+        items: Vec<BatchPreparePutKeyItemReq>,
+    ) -> KvResult<BatchPreparePutKeysResp> {
+        if items.is_empty() {
+            return Ok(BatchPreparePutKeysResp {
+                reservation_ids: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_prepare_put_keys"
+                    .to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchPreparePutKeysReq { items },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_prepare_put_keys
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_release_put_key_reservations(
+        &self,
+        reservation_ids: Vec<u64>,
+    ) -> KvResult<BatchReleasePutKeyReservationsResp> {
+        if reservation_ids.is_empty() {
+            return Ok(BatchReleasePutKeyReservationsResp {
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail:
+                    "ClientKvApi is shutting down; rejecting batch_release_put_key_reservations"
+                        .to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchReleasePutKeyReservationsReq { reservation_ids },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_release_put_key_reservations
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_put_revoke(
+        &self,
+        items: Vec<BatchPutRevokeItemReq>,
+    ) -> KvResult<BatchPutRevokeResp> {
+        if items.is_empty() {
+            return Ok(BatchPutRevokeResp {
+                items: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_put_revoke".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchPutRevokeReq { items },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_put_revoke
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_put_done(
+        &self,
+        items: Vec<BatchPutDoneItemReq>,
+    ) -> KvResult<BatchPutDoneResp> {
+        if items.is_empty() {
+            return Ok(BatchPutDoneResp {
+                items: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_put_done".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchPutDoneReq { items },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_put_done
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
     /// 完成 Put 操作，提交数据（inner，无监控）
     pub async fn put_end_inner(
         &self,
@@ -526,6 +1989,8 @@ impl ClientKvApiInner {
                 key: key.to_string(),
                 put_id,
                 lease_id,
+                committed_slot: None,
+                publish_local_cache: false,
             },
             raw_bytes: Vec::new(),
         };
@@ -562,6 +2027,58 @@ impl ClientKvApiInner {
         })
     }
 
+    pub async fn put_end_inner_with_local_cache_publish(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        lease_id: Option<u64>,
+        publish_local_cache: bool,
+    ) -> KvResult<PutEndWithLocalCachePublish> {
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting put_end".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: PutDoneReq {
+                key: key.to_string(),
+                put_id,
+                lease_id,
+                committed_slot: None,
+                publish_local_cache,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let rpc_started_at = Instant::now();
+        let resp = self
+            .rpc_caller_put_done
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(PutEndWithLocalCachePublish {
+            stats: PutEndStats {
+                master_put_end_rpc_us: duration_to_i64_us(rpc_started_at.elapsed()),
+                master_put_end_server_us: resp.serialize_part.server_process_us,
+            },
+            local_cache_holder_id: resp.serialize_part.local_cache_holder_id,
+        })
+    }
+
     /// 完成 Put 操作，提交数据（带监控）：适配 external 路径，统一聚合 t1..t4
     pub async fn put_end(
         &self,
@@ -593,4 +2110,143 @@ impl ClientKvApiInner {
         );
         Ok(end_stats)
     }
+
+    pub async fn put_end_with_local_cache_publish(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        lease_id: Option<u64>,
+        publish_local_cache: bool,
+    ) -> KvResult<PutEndWithLocalCachePublish> {
+        let metrics = self.metrics_handle();
+        let client_id = self.client_id_str();
+        let node_role = self.node_role();
+
+        let end = match self
+            .put_end_inner_with_local_cache_publish(key, put_id, lease_id, publish_local_cache)
+            .await
+        {
+            Ok(end) => end,
+            Err(e) => {
+                crate::observe_kvope::obe_put_end_error_from_pending(
+                    &metrics, &client_id, &node_role, put_id,
+                );
+                return Err(e);
+            }
+        };
+
+        metrics.pending_put_set_end_handle(put_id, end.stats.master_put_end_server_us);
+        crate::observe_kvope::obe_put_done_success_from_pending(
+            &metrics, &client_id, &node_role, key, put_id, 0,
+        );
+        Ok(end)
+    }
+}
+
+pub fn spawn_write_back_append_actor(
+    view: ClientKvApiView,
+    mut rx: tokio::sync::ampsc::Receiver<WriteBackAppendJob>,
+) {
+    let view_task = view.clone();
+    let _ = view.spawn("write_back_append_actor", async move {
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        loop {
+            let job = tokio::select! {
+                _ = shutdown_waiter.wait() => {
+                    tracing::info!("write_back_append_actor stopping due to shutdown signal");
+                    break;
+                }
+                job = rx.recv() => {
+                    match job {
+                        Some(job) => job,
+                        None => break,
+                    }
+                }
+            };
+            let inner = view_task.client_kv_api().inner();
+            let src_offset = job.holder.memory_info().offset;
+            let len = job.holder.get_length() as u64;
+            let append_start = match inner
+                .put_append_start(
+                    &job.key,
+                    job.put_id,
+                    job.holder.get_length(),
+                    job.preferred_sub_cluster.as_deref(),
+                )
+                .await
+            {
+                Ok(resp) => resp,
+                Err(err) => {
+                    tracing::warn!(
+                        "write-back append start failed: key={} put_id=({},{}) err={}",
+                        job.key,
+                        job.put_id.0,
+                        job.put_id.1,
+                        err
+                    );
+                    continue;
+                }
+            };
+            if !append_start.scheduled {
+                tracing::debug!(
+                    "write-back append skipped because current version no longer needs remote replica: key={} put_id=({},{})",
+                    job.key,
+                    job.put_id.0,
+                    job.put_id.1
+                );
+                continue;
+            }
+            let target_offset = append_start.target_addr - append_start.target_base_addr;
+            if let Err(err) = inner
+                .put_transfer(
+                    &job.key,
+                    job.put_id,
+                    src_offset,
+                    target_offset,
+                    len,
+                    Some(append_start.node_id.clone()),
+                    Some(append_start.target_base_addr),
+                )
+                .await
+            {
+                tracing::warn!(
+                    "write-back append transfer failed: key={} put_id=({},{}) err={}",
+                    job.key,
+                    job.put_id.0,
+                    job.put_id.1,
+                    err
+                );
+                if let Err(revoke_err) = inner.put_append_revoke(&job.key, job.put_id).await {
+                    tracing::warn!(
+                        "write-back append revoke failed after transfer error: key={} put_id=({},{}) err={}",
+                        job.key,
+                        job.put_id.0,
+                        job.put_id.1,
+                        revoke_err
+                    );
+                }
+                continue;
+            }
+            match inner.put_append_done(&job.key, job.put_id).await {
+                Ok(resp) => {
+                    tracing::debug!(
+                        "write-back append done: key={} put_id=({},{}) appended={}",
+                        job.key,
+                        job.put_id.0,
+                        job.put_id.1,
+                        resp.appended
+                    );
+                }
+                Err(err) => {
+                    tracing::warn!(
+                        "write-back append done failed: key={} put_id=({},{}) err={}",
+                        job.key,
+                        job.put_id.0,
+                        job.put_id.1,
+                        err
+                    );
+                }
+            }
+        }
+    });
 }
diff --git a/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs b/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
index 1aa6954..429f6b8 100644
--- a/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
@@ -1,4 +1,3 @@
-use crate::ClientKvApiAccessTrait;
 use crate::client_kv_api::ClientKvApi;
 use crate::client_transfer_engine::{ClientTransferEngine, ClientTransferEngineAccessTrait};
 use crate::cluster_manager::ClusterManagerAccessTrait;
@@ -6,8 +5,9 @@ use crate::config::ContributeToClusterPoolSize;
 use crate::master_seg_manager::msg_pack::SegmentDeviceMemInfo;
 use crate::p2p::p2p_module::P2pModule;
 use crate::p2p::p2p_module::P2pModuleAccessTrait;
-use crate::rpcresp_kvresult_convert::FromError;
 use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+use crate::rpcresp_kvresult_convert::FromError;
+use crate::ClientKvApiAccessTrait;
 use crate::{
     cluster_manager::{ClusterManager, ClusterMember},
     master_seg_manager::msg_pack::{
@@ -19,7 +19,7 @@ use crate::{
 use async_trait::async_trait;
 use bitcode::{Decode, Encode};
 use fluxon_commu::{CpuAllocatedMem, ShareGroupOwnerRef};
-use fluxon_framework::{LogicalModule, define_module};
+use fluxon_framework::{define_module, LogicalModule};
 use fluxon_util::new_map;
 use limit_thirdparty::tokio;
 use limit_thirdparty::tokio::sync::ARwLockReadGuardOwned;
@@ -237,10 +237,7 @@ impl ClientSegPool {
         std::path::Path::new(share_mem_path).join(SIDE_TRANSFER_PEERS_DIRNAME)
     }
 
-    pub fn side_transfer_peer_file_path(
-        share_mem_path: &str,
-        side_id: &str,
-    ) -> std::path::PathBuf {
+    pub fn side_transfer_peer_file_path(share_mem_path: &str, side_id: &str) -> std::path::PathBuf {
         Self::side_transfer_peers_dir(share_mem_path).join(format!("{side_id}.json"))
     }
 
@@ -399,17 +396,13 @@ impl ClientSegPool {
                 crate::rpcresp_kvresult_convert::msg_and_error::SharedMemError::MappingFailed {
                     path: String::new(),
                     len: map_len as u64,
-                    detail: "share_mem_path is empty; explicit configuration required"
-                        .to_string(),
+                    detail: "share_mem_path is empty; explicit configuration required".to_string(),
                 },
             ));
         }
 
         let base_path = &share_mem_path;
-        tracing::info!(
-            "Using share_mem_path: {} for memory-mapped file",
-            base_path
-        );
+        tracing::info!("Using share_mem_path: {} for memory-mapped file", base_path);
         std::fs::create_dir_all(base_path).map_err(|e| {
             KvError::SharedMem(
                 crate::rpcresp_kvresult_convert::msg_and_error::SharedMemError::MappingFailed {
diff --git a/fluxon_rs/fluxon_kv/src/config.rs b/fluxon_rs/fluxon_kv/src/config.rs
index f9c7691..4c7615f 100644
--- a/fluxon_rs/fluxon_kv/src/config.rs
+++ b/fluxon_rs/fluxon_kv/src/config.rs
@@ -133,6 +133,10 @@ pub struct TestSpecConfig {
     pub short_circuit_put_payload_path: bool,
     #[serde(default)]
     pub skip_put_end_commit: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner_local_reserve_soft_wait_timeout_ms: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner_local_reserve_hard_timeout_ms: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transport_mode: Option<TestSpecTransportMode>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -171,6 +175,8 @@ impl Default for TestSpecConfig {
             prefer_local_placement: false,
             short_circuit_put_payload_path: false,
             skip_put_end_commit: false,
+            owner_local_reserve_soft_wait_timeout_ms: None,
+            owner_local_reserve_hard_timeout_ms: None,
             transport_mode: None,
             tcp_thread_reactor_shard_count: None,
             tcp_thread_bulk_lane_count: None,
@@ -297,6 +303,38 @@ fn validate_required_transfer_rpc_fast_path_ready_timeout(
     Ok(())
 }
 
+fn validate_owner_local_reserve_timeouts(test_spec_config: &TestSpecConfig) -> KvResult<()> {
+    let Some(soft_wait_timeout_ms) = test_spec_config.owner_local_reserve_soft_wait_timeout_ms
+    else {
+        return Ok(());
+    };
+    if soft_wait_timeout_ms == 0 {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: "test_spec_config.owner_local_reserve_soft_wait_timeout_ms must be > 0"
+                .to_string(),
+        }
+        .into_kverror());
+    }
+
+    if let Some(hard_timeout_ms) = test_spec_config.owner_local_reserve_hard_timeout_ms {
+        if hard_timeout_ms == 0 {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: "test_spec_config.owner_local_reserve_hard_timeout_ms must be > 0"
+                    .to_string(),
+            }
+            .into_kverror());
+        }
+        if hard_timeout_ms <= soft_wait_timeout_ms {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: "test_spec_config.owner_local_reserve_hard_timeout_ms must be greater than owner_local_reserve_soft_wait_timeout_ms".to_string(),
+            }
+            .into_kverror());
+        }
+    }
+
+    Ok(())
+}
+
 fn apply_test_spec_rdma_device_names_to_protocol(
     mut protocol: ProtocolConfig,
     normalized_rdma_device_names: Option<&Vec<String>>,
@@ -733,7 +771,7 @@ pub struct ClientConfig {
     pub pprof_duration_seconds: Option<u64>,
     pub redis_compat_listen_addr: Option<std::net::SocketAddr>,
     pub fluxonkv_spec: FluxonKvSpec,
-    pub share_mem_path: String, // Mandatory shared bundle path
+    pub share_mem_path: String,           // Mandatory shared bundle path
     pub large_file_paths: LargeFilePaths, // Mandatory large-file roots for logs and caches
     pub test_spec_config: TestSpecConfig,
 }
@@ -913,6 +951,7 @@ impl ClientConfigYaml {
         )?;
         materialize_default_test_spec_transport_mode(&mut test_spec_config);
         validate_required_transfer_rpc_fast_path_ready_timeout(&test_spec_config)?;
+        validate_owner_local_reserve_timeouts(&test_spec_config)?;
         validate_test_spec_tcp_thread_tuning(&test_spec_config)?;
 
         // Role selection contract:
@@ -1170,13 +1209,15 @@ impl ClientConfigYaml {
         } else {
             let Some(large_file_paths_yaml) = self.fluxonkv_spec.large_file_paths.as_ref() else {
                 return Err(ConfigError::InvalidClientConfig {
-                    detail: "fluxonkv_spec.large_file_paths is required for owner mode"
-                        .to_string(),
+                    detail: "fluxonkv_spec.large_file_paths is required for owner mode".to_string(),
                 }
                 .into_kverror());
             };
             LargeFilePaths {
-                paths: verify_non_empty_root_path_list(&large_file_paths_yaml.0, "large_file_paths")?,
+                paths: verify_non_empty_root_path_list(
+                    &large_file_paths_yaml.0,
+                    "large_file_paths",
+                )?,
             }
         };
 
@@ -1498,6 +1539,7 @@ impl MasterConfigYaml {
         )?;
         materialize_default_test_spec_transport_mode(&mut test_spec_config);
         validate_required_transfer_rpc_fast_path_ready_timeout(&test_spec_config)?;
+        validate_owner_local_reserve_timeouts(&test_spec_config)?;
         validate_test_spec_tcp_thread_tuning(&test_spec_config)?;
         let protocol = apply_test_spec_rdma_device_names_to_protocol(
             self.protocol.unwrap_or(ProtocolConfig {
@@ -1647,7 +1689,9 @@ fluxonkv_spec:
         .unwrap();
         let err = cfg.verify().unwrap_err();
         let text = format!("{err}");
-        assert!(text.contains("fluxonkv_spec.large_file_paths is forbidden in zero-contribution mode"));
+        assert!(
+            text.contains("fluxonkv_spec.large_file_paths is forbidden in zero-contribution mode")
+        );
     }
 
     #[test]
@@ -1667,7 +1711,9 @@ fluxonkv_spec:
         let logs_dir = large_file_paths.kv_logs_dir("test_cluster").unwrap();
         assert_eq!(
             logs_dir,
-            first_root.join("child").join("test_cluster_cluster_kv_logs")
+            first_root
+                .join("child")
+                .join("test_cluster_cluster_kv_logs")
         );
         assert!(logs_dir.exists());
 
@@ -1736,8 +1782,8 @@ test_spec_config:
     }
 
     #[test]
-    fn client_test_spec_config_implicit_transport_mode_with_rdma_device_names_defaults_to_transfer_with_rpc()
-     {
+    fn client_test_spec_config_implicit_transport_mode_with_rdma_device_names_defaults_to_transfer_with_rpc(
+    ) {
         let cfg = ClientConfigYaml::from_str(
             r#"
 instance_key: test_owner
@@ -1802,8 +1848,8 @@ test_spec_config:
     }
 
     #[test]
-    fn client_test_spec_config_rejects_transfer_rpc_fast_path_ready_timeout_without_explicit_rdma_device_names()
-     {
+    fn client_test_spec_config_rejects_transfer_rpc_fast_path_ready_timeout_without_explicit_rdma_device_names(
+    ) {
         let cfg = ClientConfigYaml::from_str(
             r#"
 instance_key: test_owner
@@ -1847,10 +1893,9 @@ test_spec_config:
         )
         .unwrap();
         let err = cfg.verify().unwrap_err();
-        assert!(
-            err.to_string()
-                .contains("test_spec_config.tcp_thread_control_lane_count must be in [1, 8]")
-        );
+        assert!(err
+            .to_string()
+            .contains("test_spec_config.tcp_thread_control_lane_count must be in [1, 8]"));
     }
 
     #[test]
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index 9cb291f..fb60035 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -1,19 +1,28 @@
-use crate::SharedJsonMeta;
+use crate::client_kv_api::external_api::{
+    compute_external_get_start_transfer_prefix, normalize_external_get_start_group_lens,
+};
 use crate::client_kv_api::msg_pack::{
-    ExternalInvalidateWeakIndexReq, ExternalInvalidateWeakIndexResp,
+    ExternalInvalidateWeakIndexItem, ExternalInvalidateWeakIndexReq,
+    ExternalInvalidateWeakIndexResp,
 };
 use crate::client_seg_pool::{ClientSegPool, SideTransferPeerFileMeta};
-use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
 use crate::rpcresp_kvresult_convert::ToResult;
+use crate::SharedJsonMeta;
 use crate::{
     client_kv_api::msg_pack::{
-        ExternalDeleteAckReq, ExternalDeleteReq, ExternalGetReq, ExternalIsExistReq,
-        ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutStartReq, ExternalPutStartResp,
-        ExternalPutTransferEndReq, ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp,
-        TestPutPhaseTrace,
+        ExternalBatchGetCancelReq, ExternalBatchGetReq, ExternalBatchGetStartReq,
+        ExternalBatchGetStartResp, ExternalBatchGetTransferReq, ExternalBatchGetTransferResp,
+        ExternalBatchIsExistReq, ExternalBatchPutCommitItemReq, ExternalBatchPutCommitReq,
+        ExternalBatchPutCommitResp, ExternalBatchPutStartItemReq, ExternalBatchPutStartReq,
+        ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemReq,
+        ExternalBatchPutTransferEndReq, ExternalBatchPutTransferEndResp, ExternalDeleteAckReq,
+        ExternalDeleteReq, ExternalGetReq, ExternalIsExistReq, ExternalObservabilitySnapshotReq,
+        ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
+        ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
+        ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
     },
     cluster_manager::{
         ClusterManager, ClusterManagerAccessTrait, IpcBandwidthAttributorHandle, NodeRole,
@@ -22,18 +31,18 @@ use crate::{
     memholder::ExternalMemHolder,
     p2p::{
         msg_pack::{MsgPack, RPCCaller, RPCHandler},
-        p2p_module::{P2pModule, P2pModuleAccessTrait},
+        p2p_module::{P2pModule, P2pModuleAccessTrait, RpcTransportPolicy},
     },
-    rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, SharedMemError},
+    rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, SharedMemError, OK},
 };
 use async_trait::async_trait;
 use core::panic;
 use dashmap::DashMap;
 use fluxon_commu::ShareGroupOwnerRef;
-use fluxon_framework::{LogicalModule, define_module};
+use fluxon_framework::{define_module, LogicalModule};
 use fluxon_observability::kv_metrics_actor::{ObserveComponent, ObserveDirection};
 use fluxon_util::semaphore_map::SemaphoreMap;
-use libc::{MAP_SHARED, PROT_READ, PROT_WRITE, mmap};
+use libc::{mmap, MAP_SHARED, PROT_READ, PROT_WRITE};
 use limit_thirdparty::tokio;
 use limit_thirdparty::tokio::sync::{ARwLock, Notify};
 use limit_thirdparty::tokio::time::sleep;
@@ -42,8 +51,8 @@ use std::{
     fs::File,
     // path::PathBuf, // 不再使用PathBuf
     sync::{
-        Arc, OnceLock, Weak,
         atomic::{AtomicUsize, Ordering},
+        Arc, OnceLock, Weak,
     },
     time::{Duration, Instant},
 };
@@ -62,9 +71,18 @@ const EXTERNAL_PUT_START_RPC_TIMEOUT_SECS: u64 = 30;
 const EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS: u64 = 30;
 const EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS: usize = 3;
 const EXTERNAL_PUT_TRACE_LOG_WINDOW_SECS: u64 = 10;
-const EXTERNAL_INIT_CONTROL_PLANE_READY_TIMEOUT_SECS: u64 = 30;
-const EXTERNAL_INIT_CONTROL_PLANE_READY_POLL_MS: u64 = 100;
-const EXTERNAL_INIT_CONTROL_PLANE_READY_CONSECUTIVE_SUCCESSES: usize = 2;
+
+#[derive(Debug, Clone)]
+pub struct ExternalClientGetStartResp {
+    pub handle: u64,
+    pub raw_prefix_hit_len: usize,
+}
+
+struct PendingExternalGetStart {
+    keys: Vec<String>,
+    transferable_len: usize,
+    first_miss_index: Option<usize>,
+}
 
 fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
     duration.as_micros().min(i64::MAX as u128) as i64
@@ -195,9 +213,9 @@ struct SharedMemoryPtr {
     /// Length of the mapping in bytes
     len: u64,
     /// Base directory of the shared-memory bundle (used to locate shared.json/mmap.file)
-    _path: String,
+    path: String,
     /// Handle to the mmap backing file. Keeping the FD open is harmless and simplifies lifecycle.
-    _file: File,
+    file: File,
     /// Metadata signature read from shared.json for change detection.
     memory_signature: SharedMetaSignature,
 }
@@ -218,8 +236,8 @@ impl SharedMemoryPtr {
             ptr_rw,
             ptr_ro,
             len,
-            _path: path,
-            _file: file,
+            path,
+            file,
             memory_signature,
         }
     }
@@ -251,8 +269,8 @@ define_module!(
 /// External Client configuration parameters
 #[derive(Clone, Debug)]
 pub struct ExternalClientApiNewArg {
-    pub share_mem_path: String,
-    pub large_file_paths: crate::config::LargeFilePaths,
+    pub shared_memory_path: String,
+    pub shared_file_path: String,
     pub expected_cluster_name: String,
     pub expected_protocol_version: String,
     pub enable_side_transfer: bool,
@@ -310,24 +328,35 @@ pub struct ExternalInner {
     initial_sub_cluster: OnceLock<Option<String>>,
     expected_cluster_name: String,
     expected_protocol_version: String,
-    external_share_mem_path: String,
-    external_large_file_paths: crate::config::LargeFilePaths,
-    _enable_side_transfer: bool,
+    external_shared_memory_path: String,
+    external_shared_file_path: String,
+    enable_side_transfer: bool,
     short_circuit_put_payload_path: bool,
     side_rr_next: AtomicUsize,
     side_transfer_put_bindings: moka::sync::SegmentedCache<(u64, u32), (String, u16)>,
     rpc_caller_external_get: RPCCaller<ExternalGetReq>,
+    rpc_caller_external_batch_get: RPCCaller<ExternalBatchGetReq>,
+    rpc_caller_external_batch_get_start: RPCCaller<ExternalBatchGetStartReq>,
+    rpc_caller_external_batch_get_transfer: RPCCaller<ExternalBatchGetTransferReq>,
+    rpc_caller_external_batch_get_cancel: RPCCaller<ExternalBatchGetCancelReq>,
     rpc_caller_external_put_commit: RPCCaller<ExternalPutCommitReq>,
+    rpc_caller_external_batch_put_commit: RPCCaller<ExternalBatchPutCommitReq>,
     rpc_caller_external_put_start: RPCCaller<ExternalPutStartReq>,
+    rpc_caller_external_batch_put_start: RPCCaller<ExternalBatchPutStartReq>,
     rpc_caller_external_put_transfer_end: RPCCaller<ExternalPutTransferEndReq>,
+    rpc_caller_external_batch_put_transfer_end: RPCCaller<ExternalBatchPutTransferEndReq>,
     rpc_caller_external_delete: RPCCaller<ExternalDeleteReq>,
     rpc_caller_external_is_exist: RPCCaller<ExternalIsExistReq>,
+    rpc_caller_external_batch_is_exist: RPCCaller<ExternalBatchIsExistReq>,
+    rpc_caller_external_observability_snapshot: RPCCaller<ExternalObservabilitySnapshotReq>,
     rpc_caller_external_delete_ack: RPCCaller<ExternalDeleteAckReq>,
+    rpc_caller_external_put_revoke: RPCCaller<ExternalPutRevokeReq>,
     /// Lease RPC callers for external mode
-    _rpc_caller_allocate_client_lease: RPCCaller<AllocateClientLeaseReq>,
-    _rpc_caller_client_lease_keepalive: RPCCaller<ClientLeaseKeepaliveReq>,
+    rpc_caller_allocate_client_lease: RPCCaller<AllocateClientLeaseReq>,
+    rpc_caller_client_lease_keepalive: RPCCaller<ClientLeaseKeepaliveReq>,
     /// key -> Weak<ExternalMemHolder> index (dashmap-based)
     key_weak_memholder_index: DashMap<String, Weak<ExternalMemHolder>>,
+    pending_external_get_start: DashMap<u64, PendingExternalGetStart>,
     /// per-key semaphore (permits=1) to ensure single inflight per key
     inflight1_per_key: SemaphoreMap<String>,
     put_trace_log_window: Mutex<ExternalPutTraceLogWindow>,
@@ -350,7 +379,7 @@ impl ExternalClientApi {
     pub async fn construct(arg: ExternalClientApiNewArg) -> Result<Self, KvError> {
         tracing::info!(
             "Constructing ExternalClientApi in ExternalClient mode (PreView): shm_dir={}",
-            arg.share_mem_path
+            arg.shared_memory_path
         );
 
         Ok(Self(ExternalInner {
@@ -361,9 +390,9 @@ impl ExternalClientApi {
             initial_sub_cluster: OnceLock::new(),
             expected_cluster_name: arg.expected_cluster_name,
             expected_protocol_version: arg.expected_protocol_version,
-            external_share_mem_path: arg.share_mem_path,
-            external_large_file_paths: arg.large_file_paths,
-            _enable_side_transfer: arg.enable_side_transfer,
+            external_shared_memory_path: arg.shared_memory_path,
+            external_shared_file_path: arg.shared_file_path,
+            enable_side_transfer: arg.enable_side_transfer,
             short_circuit_put_payload_path: arg.short_circuit_put_payload_path,
             side_rr_next: AtomicUsize::new(0),
             side_transfer_put_bindings: moka::sync::Cache::builder()
@@ -371,15 +400,28 @@ impl ExternalClientApi {
                 .segments(16)
                 .build(),
             rpc_caller_external_get: RPCCaller::<ExternalGetReq>::new(),
+            rpc_caller_external_batch_get: RPCCaller::<ExternalBatchGetReq>::new(),
+            rpc_caller_external_batch_get_start: RPCCaller::<ExternalBatchGetStartReq>::new(),
+            rpc_caller_external_batch_get_transfer: RPCCaller::<ExternalBatchGetTransferReq>::new(),
+            rpc_caller_external_batch_get_cancel: RPCCaller::<ExternalBatchGetCancelReq>::new(),
             rpc_caller_external_put_commit: RPCCaller::<ExternalPutCommitReq>::new(),
+            rpc_caller_external_batch_put_commit: RPCCaller::<ExternalBatchPutCommitReq>::new(),
             rpc_caller_external_put_start: RPCCaller::<ExternalPutStartReq>::new(),
+            rpc_caller_external_batch_put_start: RPCCaller::<ExternalBatchPutStartReq>::new(),
             rpc_caller_external_put_transfer_end: RPCCaller::<ExternalPutTransferEndReq>::new(),
+            rpc_caller_external_batch_put_transfer_end:
+                RPCCaller::<ExternalBatchPutTransferEndReq>::new(),
             rpc_caller_external_delete: RPCCaller::<ExternalDeleteReq>::new(),
             rpc_caller_external_is_exist: RPCCaller::<ExternalIsExistReq>::new(),
+            rpc_caller_external_batch_is_exist: RPCCaller::<ExternalBatchIsExistReq>::new(),
+            rpc_caller_external_observability_snapshot:
+                RPCCaller::<ExternalObservabilitySnapshotReq>::new(),
             rpc_caller_external_delete_ack: RPCCaller::<ExternalDeleteAckReq>::new(),
-            _rpc_caller_allocate_client_lease: RPCCaller::<AllocateClientLeaseReq>::new(),
-            _rpc_caller_client_lease_keepalive: RPCCaller::<ClientLeaseKeepaliveReq>::new(),
+            rpc_caller_external_put_revoke: RPCCaller::<ExternalPutRevokeReq>::new(),
+            rpc_caller_allocate_client_lease: RPCCaller::<AllocateClientLeaseReq>::new(),
+            rpc_caller_client_lease_keepalive: RPCCaller::<ClientLeaseKeepaliveReq>::new(),
             key_weak_memholder_index: DashMap::new(),
+            pending_external_get_start: DashMap::new(),
             inflight1_per_key: SemaphoreMap::new(1, std::time::Duration::from_secs(120)),
             put_trace_log_window: Mutex::new(ExternalPutTraceLogWindow::new()),
         }))
@@ -403,7 +445,8 @@ impl ExternalClientApi {
             let wait_start_ts = i64::MIN;
             let OwnerRestartPayload { meta, signature } = task_wait_owner_restart(
                 ext.view.clone_view(),
-                ext.external_share_mem_path.clone(),
+                ext.external_shared_memory_path.clone(),
+                ext.external_shared_file_path.clone(),
                 None,
                 wait_start_ts,
                 None,
@@ -413,7 +456,7 @@ impl ExternalClientApi {
             .await?;
 
             let shared_memory_ptr = ExternalInner::init_shared_memory_from_meta(
-                &ext.external_share_mem_path,
+                &ext.external_shared_memory_path,
                 &meta,
                 signature,
             )?;
@@ -449,17 +492,37 @@ impl ExternalClientApi {
         // Owner binding (current_owner) is already established by the init resource
         // `owner_shared_mem_bundle_ready`, so handler registration is safe here.
         ext.rpc_caller_external_get.regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_get
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_get_start
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_get_transfer
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_get_cancel
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_put_commit
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_put_commit
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_put_start
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_put_start
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_put_transfer_end
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_put_transfer_end
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_delete.regist(ext.view.p2p_module());
         ext.rpc_caller_external_is_exist
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_is_exist
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_observability_snapshot
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_delete_ack
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_put_revoke
+            .regist(ext.view.p2p_module());
         crate::key_prefix::init_for_p2p_owner(ext.view.p2p_module());
         crate::kvlease::init_for_p2p_owner(ext.view.p2p_module());
         crate::metrics::client::init_for_p2p_owner(ext.view.p2p_module());
@@ -470,7 +533,7 @@ impl ExternalClientApi {
             move |resp, msg| {
                 let view = view_ext.clone();
                 let view_task = view.clone();
-                let _ = view.spawn("rpc_external_invalidate_weak_index", async move {
+                view.spawn("rpc_external_invalidate_weak_index", async move {
                     let result = handle_external_invalidate_weak_index(&view_task, &msg).await;
                     let _ = resp.send_resp(result).await;
                 });
@@ -483,7 +546,7 @@ impl ExternalClientApi {
         RPCHandler::<SyncKvToFileReq>::new().regist(ext.view.p2p_module(), move |resp, msg| {
             let view = view_ext.clone();
             let view_task = view.clone();
-            let _ = view.spawn("rpc_sync_kv_to_file", async move {
+            view.spawn("rpc_sync_kv_to_file", async move {
                 let result = handle_sync_kv_to_file_external(&view_task, &msg).await;
                 let _ = resp.send_resp(result).await;
             });
@@ -507,7 +570,7 @@ impl ExternalClientApi {
         {
             let view = ext.view.clone_view();
             let view_task = view.clone();
-            let _ = view.spawn("external_owner_remap_actor", async move {
+            view.spawn("external_owner_remap_actor", async move {
                 let shutdown_poller = view_task.register_shutdown_poller();
                 let mut cluster_rx = view_task.cluster_manager().listen();
                 let mut tick = tokio::time::interval(Duration::from_millis(200));
@@ -518,14 +581,6 @@ impl ExternalClientApi {
                         break;
                     }
 
-                    let Some(view_guard) = view_task.try_upgrade() else {
-                        tracing::info!(
-                            "external owner remap actor stopped because view was dropped"
-                        );
-                        break;
-                    };
-                    let _keep_view_alive = view_guard;
-
                     if let Err(err) = view_task
                         .external_client_api()
                         .inner()
@@ -567,7 +622,7 @@ impl ExternalClientApi {
                 let owner_id_for_task = owner_id.clone();
                 let view_task = ext.view.clone_view();
                 let view_task2 = view_task.clone();
-                let _ = view_task.spawn("ipc_bandwidth_attributor", async move {
+                view_task.spawn("ipc_bandwidth_attributor", async move {
                     let mut shutdown_waiter = view_task2.register_shutdown_waiter();
                     let mut interval = tokio::time::interval(Duration::from_secs(
                         crate::metric_reporter::METRICS_FLUSH_INTERVAL_SECS,
@@ -668,110 +723,6 @@ impl ExternalClientApi {
 }
 
 impl ExternalInner {
-    async fn wait_initial_control_plane_ready(&self, phase: &'static str) -> KvResult<()> {
-        let owner_id = self.shared_storage_node_id().await.expect(
-            "ExternalClientApi expects current_owner to be Some before control-plane readiness wait",
-        );
-        self.wait_peer_send_ready(owner_id, "owner", phase).await?;
-
-        let master_node_id = self
-            .view
-            .cluster_manager()
-            .find_or_wait_master_node()
-            .await?;
-        self.wait_peer_send_ready(master_node_id, "master", phase)
-            .await
-    }
-
-    async fn wait_peer_send_ready(
-        &self,
-        logical_target: String,
-        target_role: &'static str,
-        phase: &'static str,
-    ) -> KvResult<()> {
-        let deadline =
-            Instant::now() + Duration::from_secs(EXTERNAL_INIT_CONTROL_PLANE_READY_TIMEOUT_SECS);
-        let shutdown_poller = self.view.register_shutdown_poller();
-        let mut attempts = 0u64;
-        let mut consecutive_ready = 0usize;
-        let mut last_transient_err = None;
-
-        loop {
-            if !shutdown_poller.is_running() {
-                return Err(KvError::Api(ApiError::SystemShutdown {
-                    detail: format!(
-                        "external control-plane wait stopped during {phase}: target_role={target_role} target={logical_target}"
-                    ),
-                }));
-            }
-
-            let readiness = self
-                .view
-                .p2p_module()
-                .ensure_peer_send_ready(&logical_target.clone().into())
-                .await;
-            match readiness {
-                Ok(()) => {
-                    consecutive_ready += 1;
-                    if consecutive_ready >= EXTERNAL_INIT_CONTROL_PLANE_READY_CONSECUTIVE_SUCCESSES
-                    {
-                        if attempts > 0 {
-                            tracing::info!(
-                                "external control-plane route ready: phase={} target_role={} target={} attempts={}",
-                                phase,
-                                target_role,
-                                logical_target,
-                                attempts + 1,
-                            );
-                        }
-                        return Ok(());
-                    }
-                }
-                Err(err)
-                    if matches!(
-                        err,
-                        crate::p2p::P2PError::NoConnectionReady { .. }
-                            | crate::p2p::P2PError::NodeNotFound { .. }
-                            | crate::p2p::P2PError::NodeNotConnected { .. }
-                            | crate::p2p::P2PError::NodePortNotReady { .. }
-                            | crate::p2p::P2PError::ConnectionError { .. }
-                            | crate::p2p::P2PError::SendFailed { .. }
-                            | crate::p2p::P2PError::Iceoryx2TransportNotStarted {}
-                    ) =>
-                {
-                    consecutive_ready = 0;
-                    last_transient_err = Some(err.to_string());
-                }
-                Err(err) => return Err(KvError::from(err)),
-            }
-
-            attempts += 1;
-            if attempts == 1 || attempts % 20 == 0 {
-                tracing::info!(
-                    "waiting for external control-plane route: phase={} target_role={} target={} attempts={} last_transient_err={:?}",
-                    phase,
-                    target_role,
-                    logical_target,
-                    attempts,
-                    last_transient_err,
-                );
-            }
-
-            if Instant::now() >= deadline {
-                return Err(KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "timed out waiting for external control-plane route during {phase}: target_role={target_role} target={logical_target} attempts={attempts} last_transient_err={last_transient_err:?}"
-                    ),
-                }));
-            }
-
-            sleep(Duration::from_millis(
-                EXTERNAL_INIT_CONTROL_PLANE_READY_POLL_MS,
-            ))
-            .await;
-        }
-    }
-
     fn maybe_log_external_put_trace_window(&self, sample: &TestPutPhaseTrace) {
         let maybe_window = {
             let mut guard = self.put_trace_log_window.lock();
@@ -795,11 +746,30 @@ impl ExternalInner {
         );
     }
 
-    async fn current_owner_start_time(&self) -> i64 {
+    pub async fn current_owner_start_time(&self) -> i64 {
         let g = self.current_owner.read().await;
         g.as_ref().map(|o| o.owner_start_time).unwrap_or_default()
     }
 
+    pub async fn wait_current_owner_mapped_range(&self) -> KvResult<(String, i64, u64, u64, u64)> {
+        let mut prev_owner_start_time = i64::MIN;
+        let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
+        let guard = self.current_owner.read().await;
+        let owner = guard.as_ref().ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared memory not ready".to_string()),
+            })
+        })?;
+        Ok((
+            owner.node_id.clone(),
+            owner.owner_start_time,
+            owner.shared_memory.as_ptr() as u64,
+            owner.shared_memory.as_ptr_ro() as u64,
+            owner.shared_memory.len(),
+        ))
+    }
+
     async fn current_owner_snapshot(&self) -> Option<(String, i64, SharedMetaSignature)> {
         let guard = self.current_owner.read().await;
         let owner = guard.as_ref()?;
@@ -842,11 +812,13 @@ impl ExternalInner {
             return Ok(false);
         };
 
-        let share_mem_path = self.share_mem_path();
-        let shared_meta_path = format!("{}/shared.json", share_mem_path);
+        let shared_memory_path = self.shared_memory_path();
+        let shared_file_path = self.shared_file_path();
+        let shared_meta_path = format!("{}/shared.json", shared_file_path);
         let probe = probe_owner_restart_payload(
             &self.view.clone_view(),
-            &share_mem_path,
+            &shared_memory_path,
+            &shared_file_path,
             &shared_meta_path,
             Some(&current_signature),
             i64::MIN,
@@ -865,7 +837,7 @@ impl ExternalInner {
             return Ok(false);
         }
 
-        self.finish_owner_recover(&share_mem_path, payload)
+        self.finish_owner_recover(&shared_memory_path, payload)
             .await?;
         Ok(true)
     }
@@ -890,9 +862,16 @@ impl ExternalInner {
         }
         None
     }
+
+    async fn try_get_local_complete_holder(&self, key: &str) -> Option<Arc<ExternalMemHolder>> {
+        if let Some(holder) = self.try_get_from_weak_cache(key).await {
+            return Some(holder);
+        }
+        None
+    }
     // Removed trivial helper: inline-match OwnerStartTimeMismatch directly where needed.
     /// 获取共享内存基址（以 usize 表示的地址）；未就绪时返回 NotConfigured
-    async fn base_ptr(&self) -> KvResult<usize> {
+    pub async fn base_ptr(&self) -> KvResult<usize> {
         let lock = self.current_owner.read().await;
         if let Some(o) = lock.as_ref() {
             return Ok(o.shared_memory.as_ptr() as usize);
@@ -918,7 +897,7 @@ impl ExternalInner {
         match self.base_ptr().await {
             Ok(addr) => Ok(addr),
             Err(_) => {
-                let path = self.share_mem_path();
+                let path = self.shared_memory_path();
                 let (st, addr) = self
                     .wait_owner_recover_only(&path, *prev_owner_start_time)
                     .await?;
@@ -932,10 +911,10 @@ impl ExternalInner {
 
     async fn finish_owner_recover(
         &self,
-        share_mem_path: &str,
+        shared_memory_path: &str,
         payload: OwnerRestartPayload,
     ) -> KvResult<(i64, usize)> {
-        self.remap_shared_memory_with_payload(share_mem_path, &payload)
+        self.remap_shared_memory_with_payload(shared_memory_path, &payload)
             .await?;
         self.view
             .cluster_manager()
@@ -949,18 +928,16 @@ impl ExternalInner {
             .set_self_sub_cluster(payload.meta.sub_cluster.clone())
             .await
             .map_err(KvError::from)?;
-        self.wait_initial_control_plane_ready("owner_recover")
-            .await?;
         let base_addr = self.base_ptr().await?;
         Ok((self.current_owner_start_time().await, base_addr))
     }
 
     async fn wait_owner_recover_only(
         &self,
-        share_mem_path: &str,
+        shared_memory_path: &str,
         prev_owner_start_time: i64,
     ) -> KvResult<(i64, usize)> {
-        self.wait_owner_recover(share_mem_path, prev_owner_start_time)
+        self.wait_owner_recover(shared_memory_path, prev_owner_start_time)
             .await
     }
 
@@ -968,7 +945,7 @@ impl ExternalInner {
         &self,
         prev_owner_start_time: &mut i64,
     ) -> KvResult<usize> {
-        let path = self.share_mem_path();
+        let path = self.shared_memory_path();
         let (st, addr) = self
             .wait_owner_recover_only(&path, *prev_owner_start_time)
             .await?;
@@ -984,7 +961,7 @@ impl ExternalInner {
             return match self.base_ptr().await {
                 Ok(addr) => Ok(addr),
                 Err(_) => {
-                    let path = self.share_mem_path();
+                    let path = self.shared_memory_path();
                     let (st, addr) = self
                         .wait_owner_recover_only(&path, *prev_owner_start_time)
                         .await?;
@@ -994,7 +971,7 @@ impl ExternalInner {
             };
         }
 
-        let path = self.share_mem_path();
+        let path = self.shared_memory_path();
         let (st, addr) = self
             .wait_owner_recover_only(&path, *prev_owner_start_time)
             .await?;
@@ -1006,7 +983,7 @@ impl ExternalInner {
     /// has advanced.
     async fn wait_owner_recover(
         &self,
-        _share_mem_path: &str,
+        _shared_memory_path: &str,
         prev_owner_start_time: i64,
     ) -> KvResult<(i64, usize)> {
         if let Some(res) = self
@@ -1087,11 +1064,11 @@ impl ExternalInner {
 
     async fn remap_shared_memory_with_payload(
         &self,
-        share_mem_path: &str,
+        shared_memory_path: &str,
         payload: &OwnerRestartPayload,
     ) -> KvResult<()> {
         let shared_memory = Self::init_shared_memory_from_meta(
-            share_mem_path,
+            shared_memory_path,
             &payload.meta,
             payload.signature.clone(),
         )?;
@@ -1209,11 +1186,11 @@ impl ExternalInner {
     }
 
     fn init_shared_memory_from_meta(
-        share_mem_path: &str,
+        shared_memory_path: &str,
         meta: &SharedJsonMeta,
         memory_signature: SharedMetaSignature,
     ) -> KvResult<Arc<SharedMemoryPtr>> {
-        let mmap_file_path = format!("{}/mmap.file", share_mem_path);
+        let mmap_file_path = format!("{}/mmap.file", shared_memory_path);
         Self::init_shared_memory(&mmap_file_path, meta.segment_len, memory_signature)
     }
     /// Get the shared storage node ID this client connects to
@@ -1224,12 +1201,14 @@ impl ExternalInner {
 
     /// Get the configured shared-memory base path (external mode).
     /// Non-external modes return empty string.
-    pub fn share_mem_path(&self) -> String {
-        self.external_share_mem_path.clone()
+    pub fn shared_memory_path(&self) -> String {
+        self.external_shared_memory_path.clone()
     }
 
-    pub fn large_file_paths(&self) -> &crate::config::LargeFilePaths {
-        &self.external_large_file_paths
+    /// Get the configured shared-file base path (external mode).
+    /// Non-external modes return empty string.
+    pub fn shared_file_path(&self) -> String {
+        self.external_shared_file_path.clone()
     }
 
     fn should_fallback_side_p2p_error(err: &crate::p2p::P2PError) -> bool {
@@ -1267,7 +1246,7 @@ impl ExternalInner {
         // require an extra enable flag once the owner has published ready lanes.
         let owner_id = self.shared_storage_node_id().await?;
         let owner_start_time = self.current_owner_start_time().await;
-        let peers_dir = ClientSegPool::side_transfer_peers_dir(&self.external_share_mem_path);
+        let peers_dir = ClientSegPool::side_transfer_peers_dir(&self.external_shared_file_path);
         let entries = std::fs::read_dir(&peers_dir).ok()?;
         let mut ready = Vec::new();
         for entry in entries.flatten() {
@@ -1372,10 +1351,151 @@ impl ExternalInner {
         }
     }
 
-    fn short_circuit_put_payload_path_enabled(&self) -> bool {
+    pub fn short_circuit_put_payload_path_enabled(&self) -> bool {
         self.short_circuit_put_payload_path
     }
 
+    pub async fn external_batch_put_start_rpc(
+        &self,
+        req: ExternalBatchPutStartReq,
+    ) -> KvResult<ExternalBatchPutStartResp> {
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let resp = self
+            .rpc_caller_external_batch_put_start
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                owner.into(),
+                MsgPack {
+                    serialize_part: req,
+                    raw_bytes: Vec::new(),
+                },
+                Some(Duration::from_secs(EXTERNAL_PUT_START_RPC_TIMEOUT_SECS)),
+                RpcTransportPolicy::ForceTransport,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        if resp.serialize_part.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK {
+            return Err(KvError::from_json(
+                resp.serialize_part.error_code,
+                &resp.serialize_part.error_json,
+            ));
+        }
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn external_batch_put_transfer_end_rpc(
+        &self,
+        req: ExternalBatchPutTransferEndReq,
+    ) -> KvResult<ExternalBatchPutTransferEndResp> {
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let resp = self
+            .rpc_caller_external_batch_put_transfer_end
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                owner.into(),
+                MsgPack {
+                    serialize_part: req,
+                    raw_bytes: Vec::new(),
+                },
+                Some(Duration::from_secs(
+                    EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS,
+                )),
+                RpcTransportPolicy::ForceTransport,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        if resp.serialize_part.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK {
+            return Err(KvError::from_json(
+                resp.serialize_part.error_code,
+                &resp.serialize_part.error_json,
+            ));
+        }
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn external_batch_put_commit_rpc(
+        &self,
+        req: ExternalBatchPutCommitReq,
+    ) -> KvResult<ExternalBatchPutCommitResp> {
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let resp = self
+            .rpc_caller_external_batch_put_commit
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                owner.into(),
+                MsgPack {
+                    serialize_part: req,
+                    raw_bytes: Vec::new(),
+                },
+                Some(Duration::from_secs(
+                    EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS,
+                )),
+                RpcTransportPolicy::ForceTransport,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        if resp.serialize_part.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK {
+            return Err(KvError::from_json(
+                resp.serialize_part.error_code,
+                &resp.serialize_part.error_json,
+            ));
+        }
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn external_put_revoke_rpc(
+        &self,
+        req: ExternalPutRevokeReq,
+    ) -> KvResult<ExternalPutRevokeResp> {
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let resp = self
+            .rpc_caller_external_put_revoke
+            .call(
+                self.view.p2p_module(),
+                owner.into(),
+                MsgPack {
+                    serialize_part: req,
+                    raw_bytes: Vec::new(),
+                },
+                Some(Duration::from_secs(
+                    EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS,
+                )),
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        if resp.serialize_part.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK {
+            return Err(KvError::from_json(
+                resp.serialize_part.error_code,
+                &resp.serialize_part.error_json,
+            ));
+        }
+        Ok(resp.serialize_part)
+    }
+
     async fn call_put_start_with_side_fallback(
         &self,
         owner_id: String,
@@ -1523,21 +1643,52 @@ impl ExternalInner {
             .map_err(KvError::from)
     }
 
-    /// Check if a key exists in the external storage (loop+wait)
-    pub async fn is_exist(&self, key: &str) -> KvResult<bool> {
-        tracing::debug!("External is_exist request for key: {}", key);
+    /// Check a batch of keys in the external storage (loop+wait).
+    pub async fn batch_is_exist(
+        &self,
+        keys: Vec<String>,
+        allow_local_snapshot: bool,
+    ) -> KvResult<Vec<bool>> {
+        tracing::debug!(
+            "External batch_is_exist request: batch_len={}, allow_local_snapshot={}",
+            keys.len(),
+            allow_local_snapshot
+        );
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
         let mut prev_owner_start_time = self.current_owner_start_time().await;
         let mut recover_attempts = 0usize;
         if self.base_ptr().await.is_err() {
-            let path = self.share_mem_path();
-            tracing::info!("ExternalClientApi.is_exist waiting for owner at: {}", path);
+            let path = self.shared_memory_path();
+            tracing::info!(
+                "ExternalClientApi.batch_is_exist waiting for owner at: {}",
+                path
+            );
             let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
         }
 
         loop {
+            let mut results = vec![false; keys.len()];
+            let mut missing_indices = Vec::new();
+            let mut missing_keys = Vec::new();
+            for (idx, key) in keys.iter().enumerate() {
+                if allow_local_snapshot && self.try_get_local_complete_holder(key).await.is_some() {
+                    results[idx] = true;
+                    continue;
+                }
+                missing_indices.push(idx);
+                missing_keys.push(key.clone());
+            }
+            if missing_keys.is_empty() {
+                return Ok(results);
+            }
+
             let req = MsgPack {
-                serialize_part: ExternalIsExistReq {
-                    key: key.to_string(),
+                serialize_part: ExternalBatchIsExistReq {
+                    keys: missing_keys.clone(),
+                    allow_local_snapshot,
                     started_time: self.current_owner_start_time().await,
                 },
                 raw_bytes: Vec::new(),
@@ -1550,7 +1701,7 @@ impl ExternalInner {
                 })
             })?;
             let resp = match self
-                .rpc_caller_external_is_exist
+                .rpc_caller_external_batch_is_exist
                 .call(self.view.p2p_module(), owner.into(), req, None, 0)
                 .await
             {
@@ -1562,8 +1713,8 @@ impl ExternalInner {
                     {
                         recover_attempts += 1;
                         tracing::warn!(
-                            "is_exist: transient P2P error; retrying after owner-state recovery check: key={}, attempt={}/{}, err={}",
-                            key,
+                            "batch_is_exist: transient P2P error; retrying after owner-state recovery check: batch_len={}, attempt={}/{}, err={}",
+                            keys.len(),
                             recover_attempts,
                             EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
                             err
@@ -1578,10 +1729,28 @@ impl ExternalInner {
             };
 
             match resp.serialize_part.to_result() {
-                Ok(exists) => break Ok(exists),
+                Ok(exists_list) => {
+                    if exists_list.len() != missing_indices.len() {
+                        break Err(KvError::Api(ApiError::Unknown {
+                            detail: format!(
+                                "external batch_is_exist response length mismatch: expected={} got={}",
+                                missing_indices.len(),
+                                exists_list.len()
+                            ),
+                        }));
+                    }
+                    for (idx, exists) in
+                        missing_indices.iter().copied().zip(exists_list.into_iter())
+                    {
+                        results[idx] = exists;
+                    }
+                    break Ok(results);
+                }
                 Err(e) => {
                     if matches!(&e, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
-                        tracing::warn!("is_exist: OwnerStartTimeMismatch; remapping and retrying");
+                        tracing::warn!(
+                            "batch_is_exist: OwnerStartTimeMismatch; remapping and retrying"
+                        );
                         let _ = self
                             .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
                             .await?;
@@ -1592,8 +1761,8 @@ impl ExternalInner {
                     {
                         recover_attempts += 1;
                         tracing::warn!(
-                            "is_exist: transient P2P error; retrying after owner-state recovery check: key={}, attempt={}/{}, err={}",
-                            key,
+                            "batch_is_exist: transient P2P error; retrying after owner-state recovery check: batch_len={}, attempt={}/{}, err={}",
+                            keys.len(),
                             recover_attempts,
                             EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
                             e
@@ -1603,88 +1772,725 @@ impl ExternalInner {
                             .await?;
                         continue;
                     }
-                    tracing::warn!("External is_exist failed for key: {}, error: {}", key, e);
+                    tracing::warn!(
+                        "External batch_is_exist failed for batch_len {}: {}",
+                        keys.len(),
+                        e
+                    );
                     break Err(e);
                 }
             }
         }
     }
 
-    /// External Get operation (outer): retry + wait wrapper around get_inner
-    pub async fn get(
-        &self,
-        key: &str,
-    ) -> KvResult<Option<Arc<crate::memholder::ExternalMemHolder>>> {
-        tracing::debug!("External get request for key: {}", key);
-
-        // Ensure external mode configured; if not, block until owner is ready once
+    pub async fn observability_snapshot(&self) -> KvResult<crate::metrics::KvLocalitySnapshot> {
         let mut prev_owner_start_time = self.current_owner_start_time().await;
-        if self.base_ptr().await.is_err() {
-            let path = self.share_mem_path();
+        let mut recover_attempts = 0usize;
+        if self.base_ptr_ro().await.is_err() {
+            let path = self.shared_memory_path();
             tracing::info!(
-                "ExternalClientApi.get detected unmapped shared memory; waiting at: {}",
+                "ExternalClientApi.observability_snapshot waiting for owner at: {}",
                 path
             );
             let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
         }
 
-        // 1) Fast path: try weak-index lookup first
-        if let Some(h) = self.try_get_from_weak_cache(key).await {
-            return Ok(Some(h));
-        }
-
-        // 2) Ensure only one inflight get() per key using a keyed semaphore (permits=1)
-        tracing::debug!(
-            "External get request for key: {} acquire inflight semaphore",
-            key
-        );
-        let permit = self.inflight1_per_key.acquire(key.to_string()).await;
-
-        // 3) Re-check weak cache after acquiring the per-key lock
-        if let Some(h) = self.try_get_from_weak_cache(key).await {
-            tracing::debug!(
-                "External get request for key: {} hit by other inflight",
-                key
-            );
-            drop(permit);
-            return Ok(Some(h));
-        }
-
-        let mut recover_attempts: usize = 0;
-
         loop {
-            tracing::debug!(
-                "External get request for key: {} inflight get start once",
-                key
-            );
-            match self.get_inner(key, prev_owner_start_time).await {
-                Ok(v) => {
-                    // Update weak index on success if Some
-                    if let Some(ref h) = v {
-                        // let hex= &h.bytes()[..std::cmp::min(16, h.len as usize)];
-                        // tracing::info!("external get done, key={}, partial_hex={:?}", key, hex);
-                        self.key_weak_memholder_index
-                            .insert(key.to_string(), Arc::downgrade(h));
-                    } else {
-                        tracing::debug!("external get no key={}", key);
-                    }
-                    drop(permit);
-                    break Ok(v);
-                }
-                Err(e) => {
-                    if matches!(&e, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
-                        tracing::warn!("get: OwnerStartTimeMismatch; remapping and retrying");
-                        let _ = self
-                            .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
-                            .await?;
-                        continue;
-                    }
-                    if matches!(&e, KvError::P2p(_))
-                        && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
-                    {
-                        recover_attempts += 1;
-                        tracing::warn!(
-                            "get: transient P2P error; retrying after owner-state recovery check: \
+            let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+                KvError::SharedMem(SharedMemError::NotConfigured {
+                    node_id: None,
+                    detail: Some("Shared storage node id unavailable".to_string()),
+                })
+            })?;
+            let req = MsgPack {
+                serialize_part: ExternalObservabilitySnapshotReq {
+                    started_time: self.current_owner_start_time().await,
+                },
+                raw_bytes: Vec::new(),
+            };
+            let resp = match self
+                .rpc_caller_external_observability_snapshot
+                .call(self.view.p2p_module(), owner.into(), req, None, 0)
+                .await
+            {
+                Ok(resp) => resp,
+                Err(e) => {
+                    let err = KvError::from(e);
+                    if matches!(&err, KvError::P2p(_))
+                        && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                    {
+                        recover_attempts += 1;
+                        tracing::warn!(
+                            "observability_snapshot: transient P2P error; retrying after owner-state recovery check: attempt={}/{}, err={}",
+                            recover_attempts,
+                            EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
+                            err
+                        );
+                        let _ = self
+                            .recover_after_p2p_error(&mut prev_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    return Err(err);
+                }
+            };
+            if resp.serialize_part.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK
+            {
+                let err = KvError::from_json(
+                    resp.serialize_part.error_code,
+                    &resp.serialize_part.error_json,
+                );
+                if matches!(&err, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+                    tracing::warn!(
+                        "observability_snapshot: OwnerStartTimeMismatch; remapping and retrying"
+                    );
+                    let _ = self
+                        .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
+                        .await?;
+                    continue;
+                }
+                if matches!(&err, KvError::P2p(_))
+                    && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                {
+                    recover_attempts += 1;
+                    tracing::warn!(
+                        "observability_snapshot: transient P2P error in response; retrying after owner-state recovery check: attempt={}/{}, err={}",
+                        recover_attempts,
+                        EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
+                        err
+                    );
+                    let _ = self
+                        .recover_after_p2p_error(&mut prev_owner_start_time)
+                        .await?;
+                    continue;
+                }
+                return Err(err);
+            }
+            return Ok(resp.serialize_part.into_snapshot());
+        }
+    }
+
+    pub async fn batch_get_start(
+        &self,
+        keys: Vec<String>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+        transfer_concurrency: usize,
+    ) -> KvResult<ExternalBatchGetStartResp> {
+        tracing::debug!(
+            "External batch_get_start request: batch_len={}, prefix_best_effort={}, transfer_concurrency={}",
+            keys.len(),
+            prefix_best_effort,
+            transfer_concurrency
+        );
+        if keys.is_empty() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "ExternalClientApi.batch_get_start requires at least one key".to_string(),
+            }));
+        }
+
+        let mut prev_owner_start_time = self.current_owner_start_time().await;
+        let mut recover_attempts = 0usize;
+        if self.base_ptr_ro().await.is_err() {
+            let path = self.shared_memory_path();
+            tracing::info!(
+                "ExternalClientApi.batch_get_start waiting for owner at: {}",
+                path
+            );
+            let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
+        }
+
+        loop {
+            let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+                KvError::SharedMem(SharedMemError::NotConfigured {
+                    node_id: None,
+                    detail: Some("Shared storage node id unavailable".to_string()),
+                })
+            })?;
+            let req = MsgPack {
+                serialize_part: ExternalBatchGetStartReq {
+                    keys: keys.clone(),
+                    req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
+                    started_time: self.current_owner_start_time().await,
+                    prefix_best_effort,
+                    atomic_group_lens: atomic_group_lens.clone(),
+                    transfer_concurrency,
+                },
+                raw_bytes: Vec::new(),
+            };
+            let resp = match self
+                .rpc_caller_external_batch_get_start
+                .call(self.view.p2p_module(), owner.into(), req, None, 0)
+                .await
+            {
+                Ok(resp) => resp,
+                Err(e) => {
+                    let err = KvError::from(e);
+                    if matches!(&err, KvError::P2p(_))
+                        && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                    {
+                        recover_attempts += 1;
+                        tracing::warn!(
+                            "batch_get_start: transient P2P error; retrying after owner-state recovery check: batch_len={}, attempt={}/{}, err={}",
+                            keys.len(),
+                            recover_attempts,
+                            EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
+                            err
+                        );
+                        let _ = self
+                            .recover_after_p2p_error(&mut prev_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    return Err(err);
+                }
+            };
+            if resp.serialize_part.error_code != OK {
+                let err = KvError::from_json(
+                    resp.serialize_part.error_code,
+                    &resp.serialize_part.error_json,
+                );
+                if matches!(&err, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+                    tracing::warn!(
+                        "batch_get_start: OwnerStartTimeMismatch; remapping and retrying"
+                    );
+                    let _ = self
+                        .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
+                        .await?;
+                    continue;
+                }
+                return Err(err);
+            }
+            return Ok(resp.serialize_part);
+        }
+    }
+
+    pub async fn batch_get_transfer(
+        &self,
+        handle: u64,
+        keys: Vec<String>,
+    ) -> KvResult<Vec<KvResult<Option<Arc<ExternalMemHolder>>>>> {
+        tracing::debug!(
+            "External batch_get_transfer request: handle={}, batch_len={}",
+            handle,
+            keys.len()
+        );
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let mut prev_owner_start_time = self.current_owner_start_time().await;
+        if self.base_ptr_ro().await.is_err() {
+            let path = self.shared_memory_path();
+            tracing::info!(
+                "ExternalClientApi.batch_get_transfer waiting for owner at: {}",
+                path
+            );
+            let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
+        }
+
+        let started_time = self.current_owner_start_time().await;
+        let base_ptr = self.base_ptr_ro().await.expect(
+            "ExternalClientApi.batch_get_transfer requires shared memory to be ready after ensure_owner_ready",
+        ) as u64;
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let req = MsgPack {
+            serialize_part: ExternalBatchGetTransferReq {
+                handle,
+                req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
+                started_time,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let resp: MsgPack<ExternalBatchGetTransferResp> = self
+            .rpc_caller_external_batch_get_transfer
+            .call(self.view.p2p_module(), owner.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        if resp.serialize_part.error_code != OK {
+            return Err(KvError::from_json(
+                resp.serialize_part.error_code,
+                &resp.serialize_part.error_json,
+            ));
+        }
+        if resp.serialize_part.items.len() != keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external batch_get_transfer response length mismatch: expected={} got={}",
+                    keys.len(),
+                    resp.serialize_part.items.len()
+                ),
+            }));
+        }
+
+        let bandwidth_handle = self
+            .view
+            .cluster_manager()
+            .ipc_bandwidth_attributor_handle()
+            .expect("ExternalClientApi.batch_get_transfer expects IpcBandwidthAttributor handle to be attached");
+        let mut results = Vec::with_capacity(keys.len());
+        for (key, item) in keys.into_iter().zip(resp.serialize_part.items.into_iter()) {
+            if item.error_code == OK {
+                match item.external_memholder_info {
+                    Some(info) => {
+                        if info.len > 0 {
+                            bandwidth_handle.record_tx_bytes(info.len as u64);
+                        }
+                        let holder = Arc::new(ExternalMemHolder::new(
+                            info.offset,
+                            base_ptr + info.offset,
+                            info.len,
+                            info.holder_id,
+                            key.clone(),
+                            self.view.cluster_manager().get_self_info().id.clone(),
+                            self.view.clone(),
+                            started_time,
+                        ));
+                        self.key_weak_memholder_index
+                            .insert(key, Arc::downgrade(&holder));
+                        results.push(Ok(Some(holder)));
+                    }
+                    None => results.push(Ok(None)),
+                }
+                continue;
+            }
+            if item.error_code
+                == crate::rpcresp_kvresult_convert::msg_and_error::codes_api::API_KEY_NOT_FOUND
+            {
+                results.push(Ok(None));
+                continue;
+            }
+            results.push(Err(KvError::from_json(item.error_code, &item.error_json)));
+        }
+        Ok(results)
+    }
+
+    pub async fn cancel_batch_get_start(&self, handle: u64) -> KvResult<()> {
+        tracing::debug!("External cancel_batch_get_start request: handle={}", handle);
+        let started_time = self.current_owner_start_time().await;
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let req = MsgPack {
+            serialize_part: ExternalBatchGetCancelReq {
+                handle,
+                req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
+                started_time,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let resp = self
+            .rpc_caller_external_batch_get_cancel
+            .call(self.view.p2p_module(), owner.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        if resp.serialize_part.error_code == OK {
+            return Ok(());
+        }
+        let err = KvError::from_json(
+            resp.serialize_part.error_code,
+            &resp.serialize_part.error_json,
+        );
+        if matches!(&err, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+            tracing::info!(
+                "cancel_batch_get_start: owner start_time mismatch; owner restarted, treating handle as gone"
+            );
+            return Ok(());
+        }
+        Err(err)
+    }
+
+    pub async fn get_start(
+        &self,
+        keys: Vec<String>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+        transfer_concurrency: usize,
+    ) -> KvResult<ExternalClientGetStartResp> {
+        if keys.is_empty() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "ExternalClientApi.get_start requires at least one key".to_string(),
+            }));
+        }
+        let started = self
+            .batch_get_start(
+                keys.clone(),
+                prefix_best_effort,
+                atomic_group_lens.clone(),
+                transfer_concurrency,
+            )
+            .await?;
+        if started.raw_prefix_hit_len > keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "ExternalClientApi.get_start prefix response out of range: raw_prefix_hit_len={} keys={}",
+                    started.raw_prefix_hit_len,
+                    keys.len()
+                ),
+            }));
+        }
+        let group_lens = normalize_external_get_start_group_lens(keys.len(), atomic_group_lens)?;
+        let transferable_len = compute_external_get_start_transfer_prefix(
+            started.raw_prefix_hit_len,
+            &group_lens,
+            prefix_best_effort,
+        );
+        let first_miss_index = if started.raw_prefix_hit_len < keys.len() {
+            Some(started.raw_prefix_hit_len)
+        } else {
+            None
+        };
+
+        self.pending_external_get_start.insert(
+            started.handle,
+            PendingExternalGetStart {
+                keys: keys.clone(),
+                transferable_len,
+                first_miss_index,
+            },
+        );
+
+        Ok(ExternalClientGetStartResp {
+            handle: started.handle,
+            raw_prefix_hit_len: started.raw_prefix_hit_len,
+        })
+    }
+
+    pub async fn get_transfer(
+        &self,
+        handle: u64,
+    ) -> KvResult<Vec<KvResult<Option<Arc<ExternalMemHolder>>>>> {
+        let Some((_handle, entry)) = self.pending_external_get_start.remove(&handle) else {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!("get_transfer requires a live get-start handle: {}", handle),
+            }));
+        };
+        if entry.transferable_len == 0 {
+            let _ = self.cancel_batch_get_start(handle).await;
+            let key = entry
+                .first_miss_index
+                .and_then(|idx| entry.keys.get(idx).cloned())
+                .unwrap_or_else(|| format!("external_get_start_handle:{}", handle));
+            return Err(KvError::Api(ApiError::KeyNotFound { key }));
+        }
+        if entry.transferable_len > entry.keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "get_transfer stored prefix out of range: transferable_len={} keys={}",
+                    entry.transferable_len,
+                    entry.keys.len()
+                ),
+            }));
+        }
+        self.batch_get_transfer(handle, entry.keys[..entry.transferable_len].to_vec())
+            .await
+    }
+
+    pub async fn cancel_get_transfer(&self, handle: u64) -> KvResult<()> {
+        let removed = self.pending_external_get_start.remove(&handle);
+        if removed.is_none() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "cancel_get_transfer requires a live get-start handle: {}",
+                    handle
+                ),
+            }));
+        }
+        self.cancel_batch_get_start(handle).await
+    }
+
+    pub async fn batch_get(
+        &self,
+        keys: Vec<String>,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<Option<Arc<ExternalMemHolder>>>>> {
+        tracing::debug!(
+            "External batch_get request: batch_len={}, transfer_concurrency={}",
+            keys.len(),
+            transfer_concurrency
+        );
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let mut prev_owner_start_time = self.current_owner_start_time().await;
+        let mut recover_attempts = 0usize;
+        if self.base_ptr_ro().await.is_err() {
+            let path = self.shared_memory_path();
+            tracing::info!("ExternalClientApi.batch_get waiting for owner at: {}", path);
+            let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
+        }
+
+        let mut results: Vec<Option<KvResult<Option<Arc<ExternalMemHolder>>>>> =
+            (0..keys.len()).map(|_| None).collect();
+        let mut missing_indices = Vec::new();
+        let mut missing_keys = Vec::new();
+        for (idx, key) in keys.iter().enumerate() {
+            if let Some(holder) = self.try_get_from_weak_cache(key).await {
+                results[idx] = Some(Ok(Some(holder)));
+                continue;
+            }
+            missing_indices.push(idx);
+            missing_keys.push(key.clone());
+        }
+        if missing_keys.is_empty() {
+            return Ok(results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| {
+                        Err(KvError::Api(ApiError::Unknown {
+                            detail: "external batch_get result slot was not populated".to_string(),
+                        }))
+                    })
+                })
+                .collect());
+        }
+
+        loop {
+            let started_time = self.current_owner_start_time().await;
+            let base_ptr = self.base_ptr_ro().await.expect(
+                "ExternalClientApi.batch_get requires shared memory to be ready after ensure_owner_ready",
+            ) as u64;
+            let req = MsgPack {
+                serialize_part: ExternalBatchGetReq {
+                    keys: missing_keys.clone(),
+                    req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
+                    started_time,
+                    transfer_concurrency,
+                },
+                raw_bytes: Vec::new(),
+            };
+            let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+                KvError::SharedMem(SharedMemError::NotConfigured {
+                    node_id: None,
+                    detail: Some("Shared storage node id unavailable".to_string()),
+                })
+            })?;
+            let resp = match self
+                .rpc_caller_external_batch_get
+                .call(self.view.p2p_module(), owner.into(), req, None, 0)
+                .await
+            {
+                Ok(resp) => resp,
+                Err(e) => {
+                    let err = KvError::from(e);
+                    if matches!(&err, KvError::P2p(_))
+                        && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                    {
+                        recover_attempts += 1;
+                        tracing::warn!(
+                            "batch_get: transient P2P error; retrying after owner-state recovery check: batch_len={}, attempt={}/{}, err={}",
+                            keys.len(),
+                            recover_attempts,
+                            EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
+                            err
+                        );
+                        let _ = self
+                            .recover_after_p2p_error(&mut prev_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    return Err(err);
+                }
+            };
+            if resp.serialize_part.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK
+            {
+                let err = KvError::from_json(
+                    resp.serialize_part.error_code,
+                    &resp.serialize_part.error_json,
+                );
+                if matches!(&err, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+                    tracing::warn!("batch_get: OwnerStartTimeMismatch; remapping and retrying");
+                    let _ = self
+                        .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
+                        .await?;
+                    continue;
+                }
+                if matches!(&err, KvError::P2p(_))
+                    && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                {
+                    recover_attempts += 1;
+                    tracing::warn!(
+                        "batch_get: transient P2P error; retrying after owner-state recovery check: batch_len={}, attempt={}/{}, err={}",
+                        keys.len(),
+                        recover_attempts,
+                        EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS,
+                        err
+                    );
+                    let _ = self
+                        .recover_after_p2p_error(&mut prev_owner_start_time)
+                        .await?;
+                    continue;
+                }
+                return Err(err);
+            }
+            if resp.serialize_part.items.len() != missing_indices.len() {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external batch_get response length mismatch: expected={} got={}",
+                        missing_indices.len(),
+                        resp.serialize_part.items.len()
+                    ),
+                }));
+            }
+
+            let handle = self
+                .view
+                .cluster_manager()
+                .ipc_bandwidth_attributor_handle()
+                .expect("ExternalClientApi.batch_get expects IpcBandwidthAttributor handle to be attached");
+            for (idx, item) in missing_indices
+                .iter()
+                .copied()
+                .zip(resp.serialize_part.items.into_iter())
+            {
+                if item.error_code == crate::rpcresp_kvresult_convert::msg_and_error::OK {
+                    match item.external_memholder_info {
+                        Some(info) => {
+                            if info.len > 0 {
+                                handle.record_tx_bytes(info.len as u64);
+                            }
+                            let holder = Arc::new(ExternalMemHolder::new(
+                                info.offset,
+                                base_ptr + info.offset,
+                                info.len,
+                                info.holder_id,
+                                keys[idx].clone(),
+                                self.view.cluster_manager().get_self_info().id.clone(),
+                                self.view.clone(),
+                                started_time,
+                            ));
+                            self.key_weak_memholder_index
+                                .insert(keys[idx].clone(), Arc::downgrade(&holder));
+                            results[idx] = Some(Ok(Some(holder)));
+                        }
+                        None => {
+                            results[idx] = Some(Ok(None));
+                        }
+                    }
+                    continue;
+                }
+                if item.error_code
+                    == crate::rpcresp_kvresult_convert::msg_and_error::codes_api::API_KEY_NOT_FOUND
+                {
+                    results[idx] = Some(Ok(None));
+                    continue;
+                }
+                results[idx] = Some(Err(KvError::from_json(item.error_code, &item.error_json)));
+            }
+
+            return Ok(results
+                .into_iter()
+                .map(|item| {
+                    item.unwrap_or_else(|| {
+                        Err(KvError::Api(ApiError::Unknown {
+                            detail: "external batch_get result slot was not populated".to_string(),
+                        }))
+                    })
+                })
+                .collect());
+        }
+    }
+
+    pub async fn is_exist_with_local_snapshot(
+        &self,
+        key: &str,
+        allow_local_snapshot: bool,
+    ) -> KvResult<bool> {
+        let mut results = self
+            .batch_is_exist(vec![key.to_string()], allow_local_snapshot)
+            .await?;
+        Ok(results.pop().unwrap_or(false))
+    }
+
+    /// Check if a key exists in the external storage (loop+wait)
+    pub async fn is_exist(&self, key: &str) -> KvResult<bool> {
+        self.is_exist_with_local_snapshot(key, false).await
+    }
+
+    /// External Get operation (outer): retry + wait wrapper around get_inner
+    pub async fn get(
+        &self,
+        key: &str,
+    ) -> KvResult<Option<Arc<crate::memholder::ExternalMemHolder>>> {
+        tracing::debug!("External get request for key: {}", key);
+
+        // Ensure external mode configured; if not, block until owner is ready once
+        let mut prev_owner_start_time = self.current_owner_start_time().await;
+        if self.base_ptr().await.is_err() {
+            let path = self.shared_memory_path();
+            tracing::info!(
+                "ExternalClientApi.get detected unmapped shared memory; waiting at: {}",
+                path
+            );
+            let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
+        }
+
+        // 1) Fast path: try weak-index lookup first
+        if let Some(h) = self.try_get_from_weak_cache(key).await {
+            return Ok(Some(h));
+        }
+
+        // 2) Ensure only one inflight get() per key using a keyed semaphore (permits=1)
+        tracing::debug!(
+            "External get request for key: {} acquire inflight semaphore",
+            key
+        );
+        let permit = self.inflight1_per_key.acquire(key.to_string()).await;
+
+        // 3) Re-check weak cache after acquiring the per-key lock
+        if let Some(h) = self.try_get_from_weak_cache(key).await {
+            tracing::debug!(
+                "External get request for key: {} hit by other inflight",
+                key
+            );
+            drop(permit);
+            return Ok(Some(h));
+        }
+
+        let mut recover_attempts: usize = 0;
+
+        loop {
+            tracing::debug!(
+                "External get request for key: {} inflight get start once",
+                key
+            );
+            match self.get_inner(key, prev_owner_start_time).await {
+                Ok(v) => {
+                    // Update weak index on success if Some
+                    if let Some(ref h) = v {
+                        // let hex= &h.bytes()[..std::cmp::min(16, h.len as usize)];
+                        // tracing::info!("external get done, key={}, partial_hex={:?}", key, hex);
+                        self.key_weak_memholder_index
+                            .insert(key.to_string(), Arc::downgrade(h));
+                    } else {
+                        tracing::debug!("external get no key={}", key);
+                    }
+                    drop(permit);
+                    break Ok(v);
+                }
+                Err(e) => {
+                    if matches!(&e, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+                        tracing::warn!("get: OwnerStartTimeMismatch; remapping and retrying");
+                        let _ = self
+                            .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    if matches!(&e, KvError::P2p(_))
+                        && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                    {
+                        recover_attempts += 1;
+                        tracing::warn!(
+                            "get: transient P2P error; retrying after owner-state recovery check: \
 key={}, attempt={}/{}, err={}",
                             key,
                             recover_attempts,
@@ -1803,6 +2609,8 @@ key={}, attempt={}/{}, err={}",
     ) -> KvResult<()> {
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
+        let reject_if_exist_same_key = opts.reject_if_exist_same_key();
+        let write_through = opts.write_through();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let observe_sink = opts.test_observe_put_phases();
         let observe_enabled = true;
@@ -1816,7 +2624,7 @@ key={}, attempt={}/{}, err={}",
         let mut base_addr: usize = match self.base_ptr().await {
             Ok(addr) => addr,
             Err(_) => {
-                let path = self.share_mem_path();
+                let path = self.shared_memory_path();
                 tracing::info!(
                     "ExternalClientApi.put detected unmapped shared memory; waiting for owner to be ready at path: {}",
                     path
@@ -1838,6 +2646,8 @@ key={}, attempt={}/{}, err={}",
                     base_addr,
                     lease_id,
                     reject_if_inflight_same_key,
+                    reject_if_exist_same_key,
+                    write_through,
                     preferred_sub_cluster.as_deref(),
                     observe_enabled,
                 )
@@ -1890,6 +2700,8 @@ key={}, attempt={}/{}, err={}",
     ) -> KvResult<()> {
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
+        let reject_if_exist_same_key = opts.reject_if_exist_same_key();
+        let write_through = opts.write_through();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let observe_sink = opts.test_observe_put_phases();
         let observe_enabled = true;
@@ -1905,7 +2717,7 @@ key={}, attempt={}/{}, err={}",
         let mut base_addr: usize = match self.base_ptr().await {
             Ok(addr) => addr,
             Err(_) => {
-                let path = self.share_mem_path();
+                let path = self.shared_memory_path();
                 tracing::info!(
                     "ExternalClientApi.put_flat_dict_ptrs detected unmapped shared memory; waiting for owner to be ready at path: {}",
                     path
@@ -1924,6 +2736,8 @@ key={}, attempt={}/{}, err={}",
                     base_addr,
                     lease_id,
                     reject_if_inflight_same_key,
+                    reject_if_exist_same_key,
+                    write_through,
                     preferred_sub_cluster.as_deref(),
                     observe_enabled,
                 )
@@ -1963,6 +2777,370 @@ key={}, attempt={}/{}, err={}",
         }
     }
 
+    pub async unsafe fn batch_put_flat_dict_ptrs(
+        &self,
+        keys: Vec<String>,
+        ptrs_groups: Vec<Vec<(u8, usize, u32, u64, u32, Option<u32>)>>,
+        opts: crate::client_kv_api::PutOptionalArgs,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<()>>> {
+        if keys.len() != ptrs_groups.len() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "batch_put_flat_dict_ptrs requires keys and ptrs_groups to have the same length: keys={} ptrs_groups={}",
+                    keys.len(),
+                    ptrs_groups.len()
+                ),
+            }));
+        }
+        if keys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let lease_id = opts.lease_id();
+        let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
+        let reject_if_exist_same_key = opts.reject_if_exist_same_key();
+        let write_through = opts.write_through();
+        let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
+        let mut payload_lens = Vec::with_capacity(ptrs_groups.len());
+        for ptrs in ptrs_groups.iter() {
+            payload_lens.push(crate::memholder::kvclient_encode::calc_flat_dict_encoded_len(ptrs)?);
+        }
+
+        let mut prev_owner_start_time = self.current_owner_start_time().await;
+        let mut base_addr: usize = match self.base_ptr().await {
+            Ok(addr) => addr,
+            Err(_) => {
+                let path = self.shared_memory_path();
+                tracing::info!(
+                    "ExternalClientApi.batch_put_flat_dict_ptrs waiting for owner at path: {}",
+                    path
+                );
+                self.ensure_owner_ready(&mut prev_owner_start_time).await?
+            }
+        };
+
+        loop {
+            match unsafe {
+                self.batch_put_inner_flat_dict_ptrs(
+                    &keys,
+                    &ptrs_groups,
+                    &payload_lens,
+                    prev_owner_start_time,
+                    base_addr,
+                    lease_id,
+                    reject_if_inflight_same_key,
+                    reject_if_exist_same_key,
+                    write_through,
+                    preferred_sub_cluster.as_deref(),
+                    transfer_concurrency.max(1),
+                )
+                .await
+            } {
+                Ok(results) => break Ok(results),
+                Err(e) => {
+                    if matches!(&e, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+                        tracing::warn!(
+                            "batch_put_flat_dict_ptrs: OwnerStartTimeMismatch; remapping and retrying"
+                        );
+                        base_addr = self
+                            .recover_after_owner_start_time_mismatch(&mut prev_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    if matches!(&e, KvError::P2p(_)) {
+                        tracing::warn!(
+                            "batch_put_flat_dict_ptrs: P2P error (owner/link likely offline); retrying after owner-state recovery check: {}",
+                            e
+                        );
+                        base_addr = self
+                            .recover_after_p2p_error(&mut prev_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    break Err(e);
+                }
+            }
+        }
+    }
+
+    async unsafe fn batch_put_inner_flat_dict_ptrs(
+        &self,
+        keys: &[String],
+        ptrs_groups: &[Vec<(u8, usize, u32, u64, u32, Option<u32>)>],
+        payload_lens: &[u64],
+        started_time: i64,
+        base_addr: usize,
+        lease_id: Option<u64>,
+        reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
+        preferred_sub_cluster: Option<&str>,
+        transfer_concurrency: usize,
+    ) -> KvResult<Vec<KvResult<()>>> {
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let start_req = MsgPack {
+            serialize_part: ExternalBatchPutStartReq {
+                items: keys
+                    .iter()
+                    .zip(payload_lens.iter())
+                    .map(|(key, payload_len)| ExternalBatchPutStartItemReq {
+                        key: key.clone(),
+                        len: *payload_len,
+                        reject_if_inflight_same_key,
+                        reject_if_exist_same_key,
+                        write_through,
+                        preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
+                    })
+                    .collect(),
+                started_time,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let start_resp = self
+            .rpc_caller_external_batch_put_start
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                owner.clone().into(),
+                start_req,
+                Some(Duration::from_secs(EXTERNAL_PUT_START_RPC_TIMEOUT_SECS)),
+                RpcTransportPolicy::ForceTransport,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        if start_resp.serialize_part.error_code
+            != crate::rpcresp_kvresult_convert::msg_and_error::OK
+        {
+            return Err(KvError::from_json(
+                start_resp.serialize_part.error_code,
+                &start_resp.serialize_part.error_json,
+            ));
+        }
+        if start_resp.serialize_part.items.len() != keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external batch_put_start response length mismatch: expected={} got={}",
+                    keys.len(),
+                    start_resp.serialize_part.items.len()
+                ),
+            }));
+        }
+
+        let short_circuit_payload = self.short_circuit_put_payload_path_enabled();
+        let mut results: Vec<Option<KvResult<()>>> = (0..keys.len()).map(|_| None).collect();
+        let mut commit_pending = Vec::new();
+        let mut transfer_pending = Vec::new();
+        let mut total_written_payload = 0u64;
+
+        for (idx, (((key, ptrs), payload_len), start_item)) in keys
+            .iter()
+            .zip(ptrs_groups.iter())
+            .zip(payload_lens.iter())
+            .zip(start_resp.serialize_part.items.into_iter())
+            .enumerate()
+        {
+            if start_item.error_code != crate::rpcresp_kvresult_convert::msg_and_error::OK {
+                results[idx] = Some(Err(KvError::from_json(
+                    start_item.error_code,
+                    &start_item.error_json,
+                )));
+                continue;
+            }
+            let Some(put_id) = start_item.put_id else {
+                results[idx] = Some(Err(KvError::Unreachable(
+                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                        rpc_input_json: format!(
+                            "missing put_id in external batch_put_start success response; key={}",
+                            key
+                        ),
+                    },
+                )));
+                continue;
+            };
+
+            if short_circuit_payload {
+                commit_pending.push((
+                    idx,
+                    ExternalBatchPutCommitItemReq {
+                        key: key.clone(),
+                        len: *payload_len,
+                        src_offset: start_item.src_offset,
+                        remote_target: start_item.peer_id.is_some(),
+                        put_id: Some(put_id),
+                        lease_id,
+                        write_through,
+                    },
+                ));
+                continue;
+            }
+
+            let write_ptr = (base_addr + start_item.target_offset as usize) as *mut u8;
+            unsafe {
+                crate::memholder::kvclient_encode::write_flat_dict_ptrs_to_ptr(write_ptr, ptrs);
+            }
+            total_written_payload = total_written_payload.saturating_add(*payload_len);
+            transfer_pending.push((
+                idx,
+                ExternalBatchPutTransferEndItemReq {
+                    key: key.clone(),
+                    len: *payload_len,
+                    src_offset: start_item.src_offset,
+                    target_offset: start_item
+                        .transfer_target_offset
+                        .unwrap_or(start_item.target_offset),
+                    peer_id: start_item.peer_id.clone(),
+                    target_base_addr: if start_item.peer_id.is_some() {
+                        Some(start_item.target_base_addr)
+                    } else {
+                        None
+                    },
+                    put_id: Some(put_id),
+                    write_through,
+                    lease_id,
+                },
+            ));
+        }
+
+        if total_written_payload > 0 {
+            let handle = self
+                .view
+                .cluster_manager()
+                .ipc_bandwidth_attributor_handle()
+                .expect("ExternalClientApi.batch_put_flat_dict_ptrs expects IpcBandwidthAttributor handle to be attached");
+            handle.record_rx_bytes(total_written_payload);
+        }
+
+        if short_circuit_payload {
+            if !commit_pending.is_empty() {
+                let commit_resp = self
+                    .rpc_caller_external_batch_put_commit
+                    .call_with_transport_policy(
+                        self.view.p2p_module(),
+                        owner.into(),
+                        MsgPack {
+                            serialize_part: ExternalBatchPutCommitReq {
+                                items: commit_pending
+                                    .iter()
+                                    .map(|(_, item)| item.clone())
+                                    .collect(),
+                                started_time,
+                            },
+                            raw_bytes: Vec::new(),
+                        },
+                        Some(Duration::from_secs(
+                            EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS,
+                        )),
+                        RpcTransportPolicy::ForceTransport,
+                        0,
+                    )
+                    .await
+                    .map_err(KvError::from)?;
+                if commit_resp.serialize_part.error_code
+                    != crate::rpcresp_kvresult_convert::msg_and_error::OK
+                {
+                    return Err(KvError::from_json(
+                        commit_resp.serialize_part.error_code,
+                        &commit_resp.serialize_part.error_json,
+                    ));
+                }
+                if commit_resp.serialize_part.items.len() != commit_pending.len() {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "external batch_put_commit response length mismatch: expected={} got={}",
+                            commit_pending.len(),
+                            commit_resp.serialize_part.items.len()
+                        ),
+                    }));
+                }
+                for ((idx, _), item_resp) in commit_pending
+                    .into_iter()
+                    .zip(commit_resp.serialize_part.items.into_iter())
+                {
+                    if item_resp.error_code == crate::rpcresp_kvresult_convert::msg_and_error::OK {
+                        results[idx] = Some(Ok(()));
+                    } else {
+                        results[idx] = Some(Err(KvError::from_json(
+                            item_resp.error_code,
+                            &item_resp.error_json,
+                        )));
+                    }
+                }
+            }
+        } else if !transfer_pending.is_empty() {
+            let transfer_resp = self
+                .rpc_caller_external_batch_put_transfer_end
+                .call_with_transport_policy(
+                    self.view.p2p_module(),
+                    owner.into(),
+                    MsgPack {
+                        serialize_part: ExternalBatchPutTransferEndReq {
+                            items: transfer_pending
+                                .iter()
+                                .map(|(_, item)| item.clone())
+                                .collect(),
+                            started_time,
+                            transfer_concurrency,
+                        },
+                        raw_bytes: Vec::new(),
+                    },
+                    Some(Duration::from_secs(
+                        EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS,
+                    )),
+                    RpcTransportPolicy::ForceTransport,
+                    0,
+                )
+                .await
+                .map_err(KvError::from)?;
+            if transfer_resp.serialize_part.error_code
+                != crate::rpcresp_kvresult_convert::msg_and_error::OK
+            {
+                return Err(KvError::from_json(
+                    transfer_resp.serialize_part.error_code,
+                    &transfer_resp.serialize_part.error_json,
+                ));
+            }
+            if transfer_resp.serialize_part.items.len() != transfer_pending.len() {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external batch_put_transfer_end response length mismatch: expected={} got={}",
+                        transfer_pending.len(),
+                        transfer_resp.serialize_part.items.len()
+                    ),
+                }));
+            }
+            for ((idx, _), item_resp) in transfer_pending
+                .into_iter()
+                .zip(transfer_resp.serialize_part.items.into_iter())
+            {
+                if item_resp.error_code == crate::rpcresp_kvresult_convert::msg_and_error::OK {
+                    results[idx] = Some(Ok(()));
+                } else {
+                    results[idx] = Some(Err(KvError::from_json(
+                        item_resp.error_code,
+                        &item_resp.error_json,
+                    )));
+                }
+            }
+        }
+
+        Ok(results
+            .into_iter()
+            .map(|item| {
+                item.unwrap_or_else(|| {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: "external batch_put result slot was not populated".to_string(),
+                    }))
+                })
+            })
+            .collect())
+    }
+
     async unsafe fn put_inner_flat_dict_ptrs(
         &self,
         key: &str,
@@ -1972,6 +3150,8 @@ key={}, attempt={}/{}, err={}",
         base_addr: usize,
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         preferred_sub_cluster: Option<&str>,
         observe_enabled: bool,
     ) -> KvResult<TestPutPhaseTrace> {
@@ -1981,6 +3161,8 @@ key={}, attempt={}/{}, err={}",
                 key: key.to_string(),
                 len: payload_len,
                 reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                 started_time,
                 test_observe_put_phases: true,
@@ -1995,7 +3177,7 @@ key={}, attempt={}/{}, err={}",
         })?;
         let put_start_rpc_started_at = observe_enabled.then(Instant::now);
         let (put_resp, put_start_side) = self
-            .call_put_start_with_side_fallback(owner, put_start_req)
+            .call_put_start_with_side_fallback(owner.clone(), put_start_req)
             .await?;
         if let Some(started_at) = put_start_rpc_started_at {
             trace.external_put_start_rpc_us = duration_to_i64_us(started_at.elapsed());
@@ -2012,11 +3194,19 @@ key={}, attempt={}/{}, err={}",
         self.remember_side_transfer_binding(put_start_ok.put_id, put_start_side);
 
         if self.short_circuit_put_payload_path_enabled() {
+            let remote_target = put_start_ok
+                .peer_id
+                .as_deref()
+                .is_some_and(|peer| peer != owner.as_str());
             let commit_req = MsgPack {
                 serialize_part: ExternalPutCommitReq {
                     key: key.to_string(),
+                    len: payload_len,
+                    src_offset: put_start_ok.src_offset,
+                    remote_target,
                     put_id: put_start_ok.put_id,
                     lease_id,
+                    write_through,
                     started_time,
                     test_observe_put_phases: true,
                 },
@@ -2085,6 +3275,7 @@ key={}, attempt={}/{}, err={}",
                     None
                 },
                 put_id: put_start_ok.put_id.clone(),
+                write_through,
                 lease_id,
                 started_time,
                 test_observe_put_phases: true,
@@ -2129,6 +3320,8 @@ key={}, attempt={}/{}, err={}",
         base_addr: usize,
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         preferred_sub_cluster: Option<&str>,
         observe_enabled: bool,
     ) -> KvResult<TestPutPhaseTrace> {
@@ -2139,6 +3332,8 @@ key={}, attempt={}/{}, err={}",
                 key: key.to_string(),
                 len: value.len() as u64,
                 reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                 started_time,
                 test_observe_put_phases: true,
@@ -2153,7 +3348,7 @@ key={}, attempt={}/{}, err={}",
         })?;
         let put_start_rpc_started_at = observe_enabled.then(Instant::now);
         let (put_resp, put_start_side) = self
-            .call_put_start_with_side_fallback(owner, put_start_req)
+            .call_put_start_with_side_fallback(owner.clone(), put_start_req)
             .await?;
         if let Some(started_at) = put_start_rpc_started_at {
             trace.external_put_start_rpc_us = duration_to_i64_us(started_at.elapsed());
@@ -2169,11 +3364,19 @@ key={}, attempt={}/{}, err={}",
         self.remember_side_transfer_binding(put_start_ok.put_id, put_start_side);
 
         if self.short_circuit_put_payload_path_enabled() {
+            let remote_target = put_start_ok
+                .peer_id
+                .as_deref()
+                .is_some_and(|peer| peer != owner.as_str());
             let commit_req = MsgPack {
                 serialize_part: ExternalPutCommitReq {
                     key: key.to_string(),
+                    len: value.len() as u64,
+                    src_offset: put_start_ok.src_offset,
+                    remote_target,
                     put_id: put_start_ok.put_id,
                     lease_id,
+                    write_through,
                     started_time,
                     test_observe_put_phases: true,
                 },
@@ -2256,6 +3459,7 @@ key={}, attempt={}/{}, err={}",
                     None
                 },
                 put_id: put_start_ok.put_id.clone(),
+                write_through,
                 lease_id,
                 started_time,
                 test_observe_put_phases: true,
@@ -2295,7 +3499,7 @@ key={}, attempt={}/{}, err={}",
         let mut prev_owner_start_time = self.current_owner_start_time().await;
         let mut recover_attempts = 0usize;
         if self.base_ptr().await.is_err() {
-            let path = self.share_mem_path();
+            let path = self.shared_memory_path();
             tracing::info!("ExternalClientApi.delete waiting for owner at: {}", path);
             let _ = self.ensure_owner_ready(&mut prev_owner_start_time).await?;
         }
@@ -2473,14 +3677,25 @@ async fn handle_external_invalidate_weak_index(
     let api = view.external_client_api();
     let inner = api.inner();
     let mut removed_total = 0usize;
-    for k in req.keys.iter() {
-        if let Some(_v) = inner.key_weak_memholder_index.remove(k) {
+    let items = if req.items.is_empty() {
+        req.keys
+            .iter()
+            .cloned()
+            .map(|key| ExternalInvalidateWeakIndexItem { key })
+            .collect::<Vec<_>>()
+    } else {
+        req.items.clone()
+    };
+    for item in items.iter() {
+        let key = &item.key;
+        let weak_removed = inner.key_weak_memholder_index.remove(key).is_some();
+        if weak_removed {
             removed_total += 1;
         }
     }
     tracing::debug!(
-        "External invalidated weak_index for keys: {:?} (removed {} entries)",
-        req.keys,
+        "External invalidated weak_index for items: {:?} (removed {} entries)",
+        items,
         removed_total
     );
 
@@ -2659,7 +3874,8 @@ async fn handle_sync_kv_to_file_external(
 
 async fn task_wait_owner_restart(
     view: ExternalClientApiView,
-    share_mem_path: String,
+    shared_memory_path: String,
+    shared_file_path: String,
     current_sig_snapshot: Option<SharedMetaSignature>,
     wait_start_ts: i64,
     old_owner_id: Option<String>,
@@ -2668,7 +3884,7 @@ async fn task_wait_owner_restart(
 ) -> KvResult<OwnerRestartPayload> {
     let shutdown_poller = view.register_shutdown_poller();
     let mut cluster_rx = view.cluster_manager().listen();
-    let shared_meta_path = format!("{}/shared.json", &share_mem_path);
+    let shared_meta_path = format!("{}/shared.json", &shared_file_path);
     let mut waited = 0u64;
     loop {
         if !shutdown_poller.is_running() {
@@ -2679,7 +3895,8 @@ async fn task_wait_owner_restart(
 
         match probe_owner_restart_payload(
             &view,
-            &share_mem_path,
+            &shared_memory_path,
+            &shared_file_path,
             &shared_meta_path,
             current_sig_snapshot.as_ref(),
             wait_start_ts,
@@ -2728,7 +3945,8 @@ fn read_shared_json_snapshot(
 
 async fn probe_owner_restart_payload(
     view: &ExternalClientApiView,
-    share_mem_path: &str,
+    shared_memory_path: &str,
+    shared_file_path: &str,
     shared_meta_path: &str,
     current_sig_snapshot: Option<&SharedMetaSignature>,
     wait_start_ts: i64,
@@ -2736,16 +3954,16 @@ async fn probe_owner_restart_payload(
     expected_cluster_name: &str,
     expected_protocol_version: &str,
 ) -> KvResult<OwnerRestartProbe> {
-    if !fluxon_util::fs_watch::are_files_ready(share_mem_path, &["mmap.file"]) {
+    if !fluxon_util::fs_watch::are_files_ready(shared_memory_path, &["mmap.file"]) {
         return Ok(OwnerRestartProbe::Pending(format!(
             "shared memory mmap.file not ready yet: path={}",
-            share_mem_path
+            shared_memory_path
         )));
     }
-    if !fluxon_util::fs_watch::are_files_ready(share_mem_path, &["shared.json"]) {
+    if !fluxon_util::fs_watch::are_files_ready(shared_file_path, &["shared.json"]) {
         return Ok(OwnerRestartProbe::Pending(format!(
             "shared metadata shared.json not ready yet: path={}",
-            share_mem_path
+            shared_file_path
         )));
     }
 
@@ -2768,13 +3986,13 @@ async fn probe_owner_restart_payload(
     if meta.protocol_version != expected_protocol_version {
         return Ok(OwnerRestartProbe::Pending(format!(
             "shared.json protocol_version mismatch; waiting: shm_dir='{}' shared='{}' local='{}'",
-            share_mem_path, meta.protocol_version, expected_protocol_version
+            shared_memory_path, meta.protocol_version, expected_protocol_version
         )));
     }
     if meta.cluster_name != expected_cluster_name {
         return Ok(OwnerRestartProbe::Pending(format!(
             "shared.json cluster_name mismatch; waiting: shm_dir='{}' shared='{}' local='{}'",
-            share_mem_path, meta.cluster_name, expected_cluster_name
+            shared_memory_path, meta.cluster_name, expected_cluster_name
         )));
     }
     if let Some(old_owner_id) = old_owner_id {
@@ -2844,7 +4062,7 @@ impl LogicalModule for ExternalClientApi {
     async fn shutdown(&self) -> Result<(), Self::Error> {
         // 只在ExternalClient模式下清理共享内存映射
         let ext = &self.0;
-        if ext.share_mem_path().is_empty() {
+        if ext.shared_memory_path().is_empty() {
             tracing::info!("ExternalClientApi shutdown (no shared memory path configured)");
             return Ok(());
         }
diff --git a/fluxon_rs/fluxon_kv/src/kv_test.rs b/fluxon_rs/fluxon_kv/src/kv_test.rs
index 5f0a9e2..392ccf1 100644
--- a/fluxon_rs/fluxon_kv/src/kv_test.rs
+++ b/fluxon_rs/fluxon_kv/src/kv_test.rs
@@ -11,11 +11,12 @@
 
 use crate::cluster_manager::ClusterManagerRdmaControlInit;
 use crate::config::{
-    ClientConfig, ContributeToClusterPoolSize, FluxonKvSpec, LargeFilePaths, MasterConfig, MonitoringConfig,
-    ProtocolConfig, ProtocolType, TestSpecConfig, TestSpecTransportMode, TransferEngineType,
+    ClientConfig, ContributeToClusterPoolSize, FluxonKvSpec, LargeFilePaths, MasterConfig,
+    MonitoringConfig, ProtocolConfig, ProtocolType, TestSpecConfig, TestSpecTransportMode,
+    TransferEngineType,
 };
 use crate::run_master_with_test_overrides;
-use crate::{ClientRunTestOverrides, MasterRunTestOverrides, run_client_with_test_overrides};
+use crate::{run_client_with_test_overrides, ClientRunTestOverrides, MasterRunTestOverrides};
 // external client runs via run_client when contribution is zero
 use crate::ConfigArg;
 use etcd_client::Client as EtcdClient;
@@ -518,18 +519,16 @@ async fn verify_rdma_transfer_data_link(
             );
         }
 
-        let Some(raw) = fetch_transfer_link_te_value(
-            cluster_name,
-            from_instance_key,
-            to_instance_key,
-        )
-        .await
-        .unwrap_or_else(|err| {
-            panic!(
+        let Some(raw) =
+            fetch_transfer_link_te_value(cluster_name, from_instance_key, to_instance_key)
+                .await
+                .unwrap_or_else(|err| {
+                    panic!(
                 "closed transfer_link probe failed: cluster={} from={} to={} attempt={} err={}",
                 cluster_name, from_instance_key, to_instance_key, attempt, err
             )
-        }) else {
+                })
+        else {
             if Instant::now() >= deadline {
                 panic!(
                     "closed transfer data probe timed out without transfer_link_te key: cluster={} from={} to={} key_prefix={} key={} attempt={}",
@@ -802,7 +801,6 @@ impl KvTestRoundOptions {
             kv_test_run_scope()
         )
     }
-
 }
 
 #[derive(Clone, Debug)]
@@ -842,8 +840,7 @@ fn default_client_large_file_paths(
     instance_key: &str,
     contribute_to_cluster_pool_size: &ContributeToClusterPoolSize,
 ) -> LargeFilePaths {
-    if contribute_to_cluster_pool_size.dram == 0
-        && contribute_to_cluster_pool_size.vram.is_empty()
+    if contribute_to_cluster_pool_size.dram == 0 && contribute_to_cluster_pool_size.vram.is_empty()
     {
         return LargeFilePaths { paths: Vec::new() };
     }
@@ -1381,7 +1378,10 @@ async fn key_meta_cache_check(
         }
     }
 
-    tracing::info!("🔍 Starting PUT and GET in parallel: {}", parallel_unique_key);
+    tracing::info!(
+        "🔍 Starting PUT and GET in parallel: {}",
+        parallel_unique_key
+    );
     for i in 0..10 {
         let (put_client, other_client) = if i % 2 == 0 {
             (client, client2)
@@ -1420,7 +1420,9 @@ async fn key_meta_cache_check(
         }
 
         assert!(
-            put_client.client_kv_api().has_cached_key(parallel_unique_key),
+            put_client
+                .client_kv_api()
+                .has_cached_key(parallel_unique_key),
             "put client should have immediate local cache metadata for key {} after put time {}",
             parallel_unique_key,
             i
diff --git a/fluxon_rs/fluxon_kv/src/lib.rs b/fluxon_rs/fluxon_kv/src/lib.rs
index edaa386..fe69407 100644
--- a/fluxon_rs/fluxon_kv/src/lib.rs
+++ b/fluxon_rs/fluxon_kv/src/lib.rs
@@ -30,6 +30,8 @@ pub use crate::client_seg_pool::SharedJsonMeta;
 pub use crate::cluster_manager::{ClusterEvent, ClusterMember};
 pub use fluxon_observability::types::FsMountKind;
 
+pub const OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES: u64 = 512 * 1024 * 1024;
+
 pub type MembershipEventReceiver =
     limit_thirdparty::tokio::sync::abroadcast::Receiver<ClusterEvent>;
 
@@ -56,8 +58,8 @@ use crate::external_client_api::ExternalClientApiViewTrait;
 use crate::master_kv_router::MasterKvRouterAccessTrait;
 use crate::master_kv_router::MasterKvRouterView;
 use crate::master_kv_router::MasterKvRouterViewTrait;
-use crate::master_lease_manager::MasterLeaseManager;
 use crate::master_lease_manager::master_lease_manager::MasterLeaseManagerNewArg;
+use crate::master_lease_manager::MasterLeaseManager;
 use crate::master_lease_manager::{
     MasterLeaseManagerAccessTrait, MasterLeaseManagerView, MasterLeaseManagerViewTrait,
 };
@@ -78,21 +80,21 @@ use client_seg_pool::{ClientSegPool, ClientSegPoolNewArg};
 use client_transfer_engine::ClientTransferEngine;
 use cluster_manager::{ClusterManager, ClusterManagerNewArg, ClusterManagerRdmaControlInit};
 use config::{
-    ClientConfig, ClientConfigYaml, ContributeToClusterPoolSize, FluxonKvSpec, MasterConfig,
-    MasterConfigYaml, ProtocolConfig, ProtocolType, SideTransferRole, TestSpecConfig,
-    TestSpecTransportMode, TransferEngineType, normalize_etcd_addresses,
+    normalize_etcd_addresses, ClientConfig, ClientConfigYaml, ContributeToClusterPoolSize,
+    FluxonKvSpec, MasterConfig, MasterConfigYaml, ProtocolConfig, ProtocolType, SideTransferRole,
+    TestSpecConfig, TestSpecTransportMode, TransferEngineType,
 };
 use external_client_api::{ExternalClientApi, ExternalClientApiNewArg};
 use fluxon_commu::TransferBackendActivationMode;
 use fluxon_framework::LogicalModule;
-use fluxon_framework::{AnyResult, define_framework};
+use fluxon_framework::{define_framework, AnyResult};
 use master_kv_router::{MasterKvRouter, MasterKvRouterNewArg};
 use master_seg_manager::MasterSegManager;
 use metric_reporter::{
-    META_KEY_KV_OBSERVE_BROADCAST, MetricReporter, MetricReporterAccessTrait, MetricReporterNewArg,
-    MetricReporterView, MetricReporterViewTrait, ObserveProxyCaller, ObserveProxyPicker,
     register_greptime_otlp_log_proxy_rpc, serialize_master_observe_broadcast,
-    wait_master_observe_broadcast,
+    wait_master_observe_broadcast, MetricReporter, MetricReporterAccessTrait, MetricReporterNewArg,
+    MetricReporterView, MetricReporterViewTrait, ObserveProxyCaller, ObserveProxyPicker,
+    META_KEY_KV_OBSERVE_BROADCAST,
 };
 use p2p::p2p_module::{P2pModule, P2pModuleNewArg, P2pTcpThreadTransportTuning};
 use sha2::{Digest, Sha256};
@@ -254,6 +256,16 @@ pub trait KvClientTrait {
     /// Existence check by role
     async fn kv_is_exist(&self, key: &str) -> KvResult<bool>;
 
+    /// Batch existence check by role.
+    ///
+    /// `allow_local_snapshot` only enables positive local-cache hits; misses
+    /// still fall through to the authority path.
+    async fn kv_batch_is_exist(
+        &self,
+        keys: Vec<String>,
+        allow_local_snapshot: bool,
+    ) -> KvResult<Vec<bool>>;
+
     /// Count keys by prefix via master-side radix index.
     async fn kv_count_prefix(&self, prefix: &str) -> KvResult<u64>;
 
@@ -403,6 +415,26 @@ impl KvClientTrait for Framework {
         }
     }
 
+    async fn kv_batch_is_exist(
+        &self,
+        keys: Vec<String>,
+        allow_local_snapshot: bool,
+    ) -> KvResult<Vec<bool>> {
+        if self.is_external_mode() {
+            self.external_client_api_view()
+                .external_client_api()
+                .inner()
+                .batch_is_exist(keys, allow_local_snapshot)
+                .await
+        } else {
+            self.client_kv_api_view()
+                .client_kv_api()
+                .inner()
+                .batch_is_exist(keys, allow_local_snapshot)
+                .await
+        }
+    }
+
     async fn kv_count_prefix(&self, prefix: &str) -> KvResult<u64> {
         // Delegate to key_prefix helper that talks to master.
         crate::key_prefix::count_prefix_for_framework(self, prefix).await
@@ -1989,8 +2021,8 @@ async fn run_client_impl(
                 test_spec_config: config.test_spec_config.clone(),
             },
             external_client_api_arg: ExternalClientApiNewArg {
-                share_mem_path: config.share_mem_path.clone(),
-                large_file_paths: config.large_file_paths.clone(),
+                shared_memory_path: config.share_mem_path.clone(),
+                shared_file_path: config.share_mem_path.clone(),
                 expected_cluster_name: config.cluster_name.clone(),
                 expected_protocol_version: build_version.clone(),
                 enable_side_transfer: config.test_spec_config.enable_side_transfer,
@@ -2736,8 +2768,8 @@ mod tests {
             large_file_paths: crate::config::LargeFilePaths {
                 paths: vec![owner_large_root.to_string_lossy().into_owned()],
             },
-            protocol_version:
-                fluxon_util::git_version_build_record::get_current_git_commitid().unwrap(),
+            protocol_version: fluxon_util::git_version_build_record::get_current_git_commitid()
+                .unwrap(),
             write_ts: Some(chrono::Utc::now().timestamp_micros()),
         };
         let shared_meta_json = serde_json::to_string(&shared_meta).unwrap();
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
index 12a55ee..b7d65fc 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
@@ -1,12 +1,12 @@
 use super::{
-    MasterKvRouterView,
     msg_pack::{
         BatchDeleteAckReq, BatchDeleteAckResp, BatchDeleteClientKvMetaCacheReq, DeleteAckReq,
         DeleteAckResp, DeleteClientKvMetaCacheItem, DeleteReq, DeleteResp,
     },
+    MasterKvRouterView,
 };
-use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::put::PutIDForAKey;
+use crate::master_kv_router::OneKvNodesRoutes;
 use crate::memholder::{
     EnsureMemholderMgmtDeleteActorOwned, MasterOwnerMemMgr, MemholderManagerTrait,
 };
@@ -90,6 +90,7 @@ pub fn evict_one_kv_replica_for_node(
     node_id: NodeID,
     put_id: PutIDForAKey,
 ) -> Result<(), msg_and_error::ErrorCode> {
+    let _guard = view.master_kv_router().inner().route_lifetime_lock.lock();
     let route = if let Some(route) = view.master_kv_router().inner().kv_routes.get(&key) {
         route.clone()
     } else {
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 8c17155..4a290a7 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -1,23 +1,31 @@
 use super::{
-    InflightGetInfo, KvRouteInfo, MasterKvRouterView, NodeValueReplicaDesc, OwnerHoldingGetInfo,
     msg_pack::{
-        GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetMetaResp, GetRevokeReq,
-        GetRevokeResp, GetStartReq, GetStartResp,
+        BatchGetDoneItemResp, BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeItemResp,
+        BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
+        BatchGetStartResp, BatchIsExistReq, BatchIsExistResp, GetAllocationMode, GetDoneReq,
+        GetDoneResp, GetMetaReq, GetMetaResp, GetRevokeReq, GetRevokeResp, GetStartReq,
+        GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq,
+        MemHolderReleaseResp,
     },
+    InflightGetInfo, KvRouteInfo, MasterKvRouterView, NodeValueReplicaDesc, OwnerHoldingGetInfo,
 };
-use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::put::PutIDForAKey;
+use crate::master_kv_router::OneKvNodesRoutes;
 use crate::memholder::MemholderManagerTrait;
 use crate::{
-    cluster_manager::NodeID, master_seg_manager::one_seg_allocator::Allocation,
-    p2p::msg_pack::MsgPack, rpcresp_kvresult_convert::msg_and_error,
+    cluster_manager::NodeID,
+    master_seg_manager::{one_seg_allocator::Allocation, MasterSegManagerAccessTrait},
+    p2p::msg_pack::MsgPack,
+    rpcresp_kvresult_convert::msg_and_error::{self, kv},
 };
-use rand::Rng;
+use dashmap::DashMap;
+use limit_thirdparty::tokio;
 use rand::seq::SliceRandom;
+use rand::Rng;
 use std::collections::HashSet;
 use std::{
     collections::HashMap,
-    sync::{Arc, atomic::Ordering},
+    sync::{atomic::Ordering, Arc},
 };
 
 fn update_moka_for_node(
@@ -32,7 +40,7 @@ fn update_moka_for_node(
         return;
     }
     let view_task = view.clone();
-    let _ = view.spawn("update_moka_for_node", async move {
+    view.spawn("update_moka_for_node", async move {
         if let Some(cache) = view_task
             .master_kv_router()
             .get_node_cache_controller(&node_id)
@@ -68,6 +76,14 @@ fn update_moka_for_node(
     });
 }
 
+fn one_kv_routes_has_live_replica(one_kv_nodes_routes: &OneKvNodesRoutes) -> bool {
+    one_kv_nodes_routes
+        .nodes_replicas
+        .read()
+        .values()
+        .any(|kv_info| !kv_info.tomb_tag.is_tomb())
+}
+
 pub async fn handle_get_start(
     view: MasterKvRouterView,
     req: MsgPack<GetStartReq>,
@@ -153,15 +169,17 @@ pub async fn handle_get_start(
             tombs.insert(selected_replica_key.to_owned());
             continue;
         }
-        let src_allocation = selected_replica.allocation.clone();
         let src_node_id = selected_replica.node_id.clone();
-
-        // 为get调用方分配接收内存作为传输target
-        if target_allocations.is_none() {
-            target_allocations = if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
-                allocation_mode = GetAllocationMode::ReuseReplica;
-                Some(replica_on_recv_node.allocation.clone())
-            } else {
+        let src_len = selected_replica.backing.len();
+        let src_abs_addr = selected_replica.backing.abs_addr();
+        let src_base = selected_replica.backing.base_addr();
+
+        // For committed-slot replicas on the requester node, we still allocate a
+        // normal target buffer here instead of reusing the committed slot as a
+        // MemHolder backing. That keeps the existing get-path carrier stable
+        // and avoids the old None->unwrap panic.
+        let mut allocate_request_target =
+            || -> Result<Arc<Allocation>, (u64, MsgPack<GetStartResp>)> {
                 let target_allocation = {
                     let req_node_allocators =
                         view.master_seg_manager().get_node_allocators(&req_node_id);
@@ -173,12 +191,12 @@ pub async fn handle_get_start(
                         let err = msg_and_error::KvError::Unreachable(
                             msg_and_error::UnreachableError::OwnerNoSeg { detail: "config=0 initializes as external; non-zero initializes as owner; the owner must have memory space (segment)".to_string() }
                         );
-                        return failed_resp_err(
+                        return Err(failed_resp_err(
                             err,
-                            Some((tombs, one_kv_nodes_routes.put_id)),
+                            Some((tombs.clone(), one_kv_nodes_routes.put_id)),
                             &view,
                             &req.serialize_part.key,
-                        );
+                        ));
                     }
 
                     let target_allocator =
@@ -186,7 +204,7 @@ pub async fn handle_get_start(
 
                     let mut allocated_addr: Option<Allocation> = None;
                     for attempt in 1..=3 {
-                        if let Ok(allocation) = target_allocator.allocate(src_allocation.size()) {
+                        if let Ok(allocation) = target_allocator.allocate(src_len) {
                             allocated_addr = Some(allocation);
                             break;
                         } else {
@@ -208,12 +226,12 @@ pub async fn handle_get_start(
                             total_capacity: total,
                             free_capacity: free,
                         });
-                        return failed_resp_err(
+                        return Err(failed_resp_err(
                             err,
-                            Some((tombs, one_kv_nodes_routes.put_id)),
+                            Some((tombs.clone(), one_kv_nodes_routes.put_id)),
                             &view,
                             &req.serialize_part.key,
-                        );
+                        ));
                     }
                     allocated_addr.unwrap()
                 };
@@ -222,15 +240,38 @@ pub async fn handle_get_start(
                 } else {
                     allocation_mode = GetAllocationMode::Temporary;
                 }
-                Some(Arc::new(target_allocation))
+                Ok(Arc::new(target_allocation))
             };
+
+        // 为get调用方分配接收内存作为传输target
+        if target_allocations.is_none() {
+            target_allocations = Some(
+                if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
+                    match &replica_on_recv_node.backing {
+                        super::KvReplicaBacking::Allocation(allocation) => {
+                            allocation_mode = GetAllocationMode::ReuseReplica;
+                            allocation.clone()
+                        }
+                        super::KvReplicaBacking::CommittedSlot(_) => {
+                            match allocate_request_target() {
+                                Ok(allocation) => allocation,
+                                Err(resp) => return resp,
+                            }
+                        }
+                    }
+                } else {
+                    match allocate_request_target() {
+                        Ok(allocation) => allocation,
+                        Err(resp) => return resp,
+                    }
+                },
+            );
         }
 
         let target_allocation = target_allocations.unwrap();
 
         // Convert to absolute addresses for Mooncake (requires absolute)
         // Use allocation's allocator base directly
-        let src_base = src_allocation.base_addr();
         let target_base = target_allocation.base_addr();
 
         // If we reuse existing target on requesting node, declare src=target on req node
@@ -242,7 +283,7 @@ pub async fn handle_get_start(
             } else {
                 (
                     src_node_id.clone(),
-                    src_base + src_allocation.addr(),
+                    src_abs_addr,
                     target_base + target_allocation.addr(),
                     src_base,
                     target_base,
@@ -257,7 +298,7 @@ pub async fn handle_get_start(
             target_addr: resp_target_addr,
             src_base_addr: resp_src_base,
             target_base_addr: resp_target_base,
-            len: src_allocation.size(),
+            len: src_len,
             error_code: msg_and_error::OK,
             error_json: String::new(),
             server_process_us: 0,
@@ -268,7 +309,7 @@ pub async fn handle_get_start(
             src_node_id: src_node_id.clone(),
             key: req.serialize_part.key.clone(),
             req_node_id,
-            len: src_allocation.size(),
+            len: src_len,
             allocation: target_allocation, // 存储target allocation
             route: one_kv_nodes_routes.clone(),
             allocation_mode,
@@ -411,7 +452,9 @@ pub async fn handle_get_done(
                                 inflight_info.req_node_id.clone(),
                                 KvRouteInfo {
                                     node_id: inflight_info.req_node_id,
-                                    allocation: inflight_info.allocation,
+                                    backing: super::KvReplicaBacking::Allocation(
+                                        inflight_info.allocation,
+                                    ),
                                     tomb_tag,
                                 },
                             );
@@ -490,6 +533,15 @@ pub async fn handle_get_done(
             get_id,
             holder_id
         );
+        view.master_kv_router()
+            .view()
+            .metric_reporter()
+            .metrics()
+            .inc_kv_get_done_allocation(match allocation_mode {
+                GetAllocationMode::Temporary => "temporary",
+                GetAllocationMode::ReuseReplica => "reuse_replica",
+                GetAllocationMode::DurableReplica => "durable_replica",
+            });
 
         MsgPack {
             serialize_part: GetDoneResp {
@@ -621,7 +673,7 @@ pub async fn handle_get_meta(
             if kv_info.tomb_tag.is_tomb() {
                 continue;
             }
-            let len = kv_info.allocation.size();
+            let len = kv_info.backing.len();
             return MsgPack {
                 serialize_part: GetMetaResp {
                     exists: true,
@@ -684,3 +736,143 @@ pub async fn handle_get_meta(
         }
     }
 }
+
+pub async fn handle_batch_is_exist(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchIsExistReq>,
+    _req_node_id: NodeID,
+) -> MsgPack<BatchIsExistResp> {
+    tracing::debug!(
+        "Handling BatchIsExistReq: batch_len={}",
+        req.serialize_part.keys.len()
+    );
+
+    let mut exists_list = Vec::with_capacity(req.serialize_part.keys.len());
+
+    {
+        let _guard = view.master_kv_router().inner().route_lifetime_lock.lock();
+        for key in &req.serialize_part.keys {
+            if let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) {
+                let exists = one_kv_routes_has_live_replica(&one_kv_nodes_routes);
+                exists_list.push(exists);
+            } else {
+                exists_list.push(false);
+            }
+        }
+    }
+
+    MsgPack {
+        serialize_part: BatchIsExistResp {
+            exists_list,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_get_start(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchGetStartReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchGetStartResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.keys.len());
+    for key in req.serialize_part.keys {
+        let (_get_id, resp) = handle_get_start(
+            view.clone(),
+            MsgPack {
+                serialize_part: GetStartReq { key },
+                raw_bytes: Vec::new(),
+            },
+            req_node_id.clone(),
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchGetStartItemResp {
+            get_id: part.get_id,
+            node_id: part.node_id,
+            put_id: part.put_id,
+            target_addr: part.target_addr,
+            src_addr: part.src_addr,
+            target_base_addr: part.target_base_addr,
+            src_base_addr: part.src_base_addr,
+            len: part.len,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchGetStartResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_get_revoke(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchGetRevokeReq>,
+) -> MsgPack<BatchGetRevokeResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.get_ids.len());
+    for get_id in req.serialize_part.get_ids {
+        let resp = handle_get_revoke(
+            view.clone(),
+            MsgPack {
+                serialize_part: GetRevokeReq { get_id },
+                raw_bytes: Vec::new(),
+            },
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchGetRevokeItemResp {
+            get_id,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchGetRevokeResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_get_done(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchGetDoneReq>,
+) -> MsgPack<BatchGetDoneResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.get_ids.len());
+    for get_id in req.serialize_part.get_ids {
+        let resp = handle_get_done(
+            view.clone(),
+            MsgPack {
+                serialize_part: GetDoneReq { get_id },
+                raw_bytes: Vec::new(),
+            },
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchGetDoneItemResp {
+            get_id,
+            holder_id: part.holder_id,
+            allocation_mode: part.allocation_mode,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchGetDoneResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index ee4ca2b..6fb7426 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -11,16 +11,29 @@ use self::{
     delete::handle_batch_delete_ack,
     delete::handle_delete,
     delete::handle_delete_ack,
-    get::{handle_get_done, handle_get_meta, handle_get_revoke, handle_get_start},
+    get::{
+        handle_batch_get_done, handle_batch_get_revoke, handle_batch_get_start,
+        handle_batch_is_exist, handle_get_done, handle_get_meta, handle_get_revoke,
+        handle_get_start,
+    },
     msg_pack::{
-        BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, CountPrefixReq, CountPrefixResp,
-        DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq, GetMetaReq, GetRevokeReq,
-        GetStartReq, PutDoneReq, PutRevokeReq, PutStartReq,
+        BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchGetDoneReq, BatchGetRevokeReq,
+        BatchGetStartReq, BatchIsExistReq, BatchPreparePutKeysReq, BatchPutDoneReq,
+        BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq,
+        CountPrefixResp, DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq,
+        GetMasterOnlyMetricPartReq, GetMasterOnlyMetricPartResp, GetMetaReq, GetRevokeReq,
+        GetStartReq, MemHolderKeepAliveReq, MemHolderReleaseReq, PutAppendDoneReq,
+        PutAppendRevokeReq, PutAppendStartReq, PutDoneReq, PutRevokeReq, PutStartReq,
+        ReleaseLocalGrantReq, ReserveLocalGrantReq,
     },
     placement::{PlacementDefault, PlacementPolicy},
-    put::{handle_put_done, handle_put_revoke, handle_put_start},
+    put::{
+        handle_batch_prepare_put_keys, handle_batch_put_done, handle_batch_put_revoke,
+        handle_batch_put_start, handle_batch_release_put_key_reservations, handle_put_append_done,
+        handle_put_append_revoke, handle_put_append_start, handle_put_done, handle_put_revoke,
+        handle_put_start, handle_release_local_grant, handle_reserve_local_grant,
+    },
 };
-use crate::ClientKvApiAccessTrait;
 use crate::client_kv_api::ClientKvApi;
 use crate::cluster_manager::{
     ClusterEvent, ClusterManager, ClusterManagerAccessTrait, NodeID, NodeIDString,
@@ -29,29 +42,35 @@ use crate::config::TestSpecConfig;
 use crate::master_kv_router::delete::DeleteKeyInfo;
 use crate::master_kv_router::put::PutIDForAKey;
 use crate::master_lease_manager::{MasterLeaseManager, MasterLeaseManagerAccessTrait};
+use crate::master_seg_manager::one_seg_allocator::Allocation;
 use crate::master_seg_manager::MasterSegManager;
 use crate::master_seg_manager::MasterSegManagerAccessTrait;
 use crate::master_seg_manager::NodeTombTag;
-use crate::master_seg_manager::one_seg_allocator::Allocation;
-use crate::memholder::{EnsureMemholderMgmtDeleteHandle, MasterOwnerMemMgr, MemholderManagerTrait};
+use crate::memholder::{
+    EnsureMemholderMgmtDeleteHandle, MasterOwnerMemMgr, MemholderManagerTrait, NodeHolderKey,
+};
 use crate::metric_reporter::{MetricReporter, MetricReporterAccessTrait};
 use crate::p2p::msg_pack::{MsgPack, RPCCaller, RPCHandler};
 use crate::p2p::p2p_module::{P2pModule, P2pModuleAccessTrait};
+use crate::rpcresp_kvresult_convert;
 use crate::rpcresp_kvresult_convert::msg_and_error::{KvError, OK};
-use fluxon_framework::{LogicalModule, define_module};
+use crate::ClientKvApiAccessTrait;
+use fluxon_framework::{define_module, LogicalModule};
+use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 
 use async_trait::async_trait;
 use chrono::Utc;
 use dashmap::DashMap;
-use limit_thirdparty::tokio::sync::ARwLock;
+use limit_thirdparty::tokio::sync::{abroadcast, ARwLock};
 use limit_thirdparty::tokio::{self, sync::ampsc};
 use moka::notification::RemovalCause;
 use parking_lot::Mutex;
 use parking_lot::RwLock;
-use std::collections::HashMap;
+use std::borrow::Cow;
 use std::collections::HashSet;
-use std::sync::Arc;
+use std::collections::{HashMap, VecDeque};
 use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tracing::{debug, error, info, warn};
 
@@ -69,12 +88,78 @@ pub enum PutPlacementMode {
     Remote,
 }
 
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum ReservedCapacityReason {
+    LeaseBoundKv,
+    LocalReserveGrant,
+}
+
+#[derive(Debug, Default)]
+pub struct NodeCacheReservedCapacity {
+    pub total_bytes: AtomicU64,
+    pub lease_bound_kv_bytes: AtomicU64,
+    pub local_reserve_grant_bytes: AtomicU64,
+}
+
+impl NodeCacheReservedCapacity {
+    fn apply_delta(&self, reason: ReservedCapacityReason, delta_bytes: i64) {
+        if delta_bytes >= 0 {
+            let delta = delta_bytes as u64;
+            self.total_bytes.fetch_add(delta, Ordering::Relaxed);
+            match reason {
+                ReservedCapacityReason::LeaseBoundKv => {
+                    self.lease_bound_kv_bytes
+                        .fetch_add(delta, Ordering::Relaxed);
+                }
+                ReservedCapacityReason::LocalReserveGrant => {
+                    self.local_reserve_grant_bytes
+                        .fetch_add(delta, Ordering::Relaxed);
+                }
+            }
+        } else {
+            let delta = (-delta_bytes) as u64;
+            self.total_bytes.fetch_sub(delta, Ordering::Relaxed);
+            match reason {
+                ReservedCapacityReason::LeaseBoundKv => {
+                    self.lease_bound_kv_bytes
+                        .fetch_sub(delta, Ordering::Relaxed);
+                }
+                ReservedCapacityReason::LocalReserveGrant => {
+                    self.local_reserve_grant_bytes
+                        .fetch_sub(delta, Ordering::Relaxed);
+                }
+            }
+        }
+    }
+
+    fn total_reserved_bytes(&self) -> u64 {
+        self.total_bytes.load(Ordering::Relaxed)
+    }
+}
+
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct RequesterTargetPair {
     requester_node_id: NodeIDString,
     target_node_id: NodeIDString,
 }
 
+#[derive(Clone, Debug, Default)]
+pub struct ReplicaCacheNodeObserveSnapshot {
+    pub owner_node: String,
+    pub entries: u64,
+    pub weighted_bytes: u64,
+    pub effective_capacity_bytes: u64,
+    pub reserved_capacity_bytes: u64,
+    pub base_capacity_bytes: u64,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct MasterRuntimeObserveSnapshot {
+    pub get_holding_entries: u64,
+    pub get_holding_bytes: u64,
+    pub replica_cache_nodes: Vec<ReplicaCacheNodeObserveSnapshot>,
+}
+
 impl RequesterTargetPair {
     fn new(requester_node_id: &str, target_node_id: &str) -> Self {
         Self {
@@ -88,23 +173,49 @@ impl RequesterTargetPair {
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct CommittedSlotReplica {
+    pub owner_node_id: NodeID,
+    pub grant_id: u64,
+    pub slot_index: u32,
+    pub slot_size: u64,
+    pub addr: u64,
+    pub len: u64,
+    pub base_addr: u64,
+}
+
 /// Information about a `put` operation that is currently in progress.
 pub enum InflightPutAllocation {
     /// Local fast path: the same allocation is used as both src (staging) and target (final).
     Local(Allocation),
     /// Remote path: separate allocations for src (on requester) and target (on selected node).
     Remote { src: Allocation, target: Allocation },
+    /// Local-first fast path: data is already committed in owner-local reserve slot.
+    LocalCommittedSlot(CommittedSlotReplica),
+}
+
+#[derive(Clone)]
+pub struct InflightPutCommitInfo {
+    pub node_id: NodeID,
+    pub src_target_allocation: Arc<Mutex<Option<InflightPutAllocation>>>,
 }
 
 /// Information about a `put` operation that is currently in progress.
 #[derive(Clone)]
 pub struct InflightPutInfo {
-    pub node_id: NodeID,
-    // seg_name: String,
     pub key: String,
     pub req_node_id: NodeID,
     pub len: u64,
-    pub src_target_allocation: Arc<Mutex<Option<InflightPutAllocation>>>,
+    pub commit_info: InflightPutCommitInfo,
+    pub remote_append: Option<InflightPutAppendInfo>,
+}
+
+#[derive(Clone)]
+pub struct InflightPutAppendInfo {
+    pub node_id: NodeID,
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub target_allocation: Arc<Mutex<Option<Allocation>>>,
 }
 
 /// Information about a `get` operation that is currently in progress.
@@ -137,6 +248,16 @@ pub struct OwnerHoldingGetInfo {
     pub allocation: Arc<Allocation>, // The target allocation where data was transferred
 }
 
+pub struct LocalReserveGrantInfo {
+    pub owner_node_id: NodeID,
+    pub allocation: Allocation,
+}
+
+pub struct PreparedPutKeyReservationInfo {
+    pub owner_node_id: NodeID,
+    pub key: String,
+}
+
 async fn handle_count_prefix(
     view: &MasterKvRouterView,
     msg: MsgPack<CountPrefixReq>,
@@ -194,10 +315,39 @@ pub struct NodeValueReplicaDesc {
 
 /// Information about a completed `put` operation that can be retrieved via `get`.
 /// Now supports multiple replicas per key.
+#[derive(Clone, Debug)]
+pub enum KvReplicaBacking {
+    Allocation(Arc<Allocation>),
+    CommittedSlot(CommittedSlotReplica),
+}
+
+impl KvReplicaBacking {
+    pub fn abs_addr(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.base_addr() + allocation.addr(),
+            Self::CommittedSlot(slot) => slot.addr,
+        }
+    }
+
+    pub fn base_addr(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.base_addr(),
+            Self::CommittedSlot(slot) => slot.base_addr,
+        }
+    }
+
+    pub fn len(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.size(),
+            Self::CommittedSlot(slot) => slot.len,
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct KvRouteInfo {
     pub node_id: NodeID,
-    pub allocation: Arc<Allocation>,
+    pub backing: KvReplicaBacking,
     pub tomb_tag: NodeTombTag,
 }
 
@@ -238,7 +388,7 @@ impl OneKvNodesRoutes {
         &self,
         verify_put_id: PutIDForAKey,
         tombs: HashSet<NodeID>,
-        _view: &MasterKvRouterView,
+        view: &MasterKvRouterView,
     ) -> bool {
         if self.put_id != verify_put_id {
             return false;
@@ -346,6 +496,7 @@ pub struct MasterKvRouterInner {
 
     /// (key, put_time_ms, put_version) -> inflight_put_info
     pub inflight_puts: moka::future::Cache<(String, u64, u32), InflightPutInfo>,
+    pub inflight_put_appends: moka::future::Cache<(String, u64, u32), InflightPutAppendInfo>,
     /// key -> inflight put count
     pub inflight_put_key_counts: Arc<DashMap<String, u32>>,
     pub inflight_gets: moka::future::Cache<u64, InflightGetInfo>,
@@ -359,24 +510,37 @@ pub struct MasterKvRouterInner {
     /// Counter for holder_id
     pub next_holder_id: AtomicU64,
 
+    /// Counter for local reserve grant identifiers.
+    pub next_local_reserve_grant_id: AtomicU64,
+
+    /// Counter for prepared put-key reservation identifiers.
+    pub next_prepared_put_key_reservation_id: AtomicU64,
+
     /// Latest version of key-value replicas
     pub kv_routes: DashMap<String, Arc<OneKvNodesRoutes>>,
 
-    /// Prefix-counting index derived from `kv_routes`.
-    ///
-    /// It is updated through async follow-up maintenance, so it does not guarantee
-    /// immediate strong-consistency visibility for a freshly committed put.
-    /// The generic surface is `CountPrefix` RPC; the current primary use case is
-    /// MQ capacity backpressure / prefix counting.
+    /// Serializes route-level existence checks with cache-eviction route cleanup.
+    /// This protects route metadata consistency only; it does not create MemHolders
+    /// or move payload data.
+    pub route_lifetime_lock: Mutex<()>,
+
+    /// Grants reserved for owner-local hot-path staging.
+    pub local_reserve_grants: DashMap<u64, LocalReserveGrantInfo>,
+
+    /// Prepared key reservations for owner-local hot-path staging.
+    pub prepared_put_key_reservations: DashMap<u64, PreparedPutKeyReservationInfo>,
+
+    /// Prefix-counting index for keys, used by CountPrefix RPC.
     pub prefix_index: ARwLock<PrefixRadixTree>,
 
     /// Support replicas: node_id -> key -> route_info
     pub node_kv_cache_controller:
         DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
 
-    /// Per-node total bytes reserved for leased replicas. We subtract this from
-    /// the base max capacity of each node's moka cache. Acts like a fetch_sub/add counter.
-    pub lease_reserved_bytes: DashMap<NodeIDString, Arc<AtomicU64>>,
+    /// Per-node bytes reserved out of moka usable capacity.
+    /// The reservation is reason-grouped, but `total_bytes` is the authority
+    /// used to derive the effective moka max_capacity for the node.
+    pub node_cache_reserved_capacity: DashMap<NodeIDString, Arc<NodeCacheReservedCapacity>>,
 
     /// Historical final put placement decisions by target node.
     pub put_target_decision_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
@@ -497,20 +661,29 @@ impl MasterKvRouter {
                 }
             })
             .build();
+        let inflight_put_appends = moka::future::Cache::builder()
+            .time_to_live(Duration::from_secs(60))
+            .build();
         let inner = MasterKvRouterInner {
             view: std::sync::OnceLock::new(),
             policy: policy_impl,
             test_spec_config: arg.test_spec_config,
             inflight_puts,
+            inflight_put_appends,
             inflight_put_key_counts,
             inflight_gets,
             get_holding: MasterOwnerMemMgr::default(),
             next_get_id: AtomicU64::new(0),
             next_holder_id: AtomicU64::new(0),
+            next_local_reserve_grant_id: AtomicU64::new(1),
+            next_prepared_put_key_reservation_id: AtomicU64::new(1),
             kv_routes: DashMap::new(),
+            route_lifetime_lock: Mutex::new(()),
+            local_reserve_grants: DashMap::new(),
+            prepared_put_key_reservations: DashMap::new(),
             prefix_index: ARwLock::new(PrefixRadixTree::new()),
             node_kv_cache_controller: DashMap::new(),
-            lease_reserved_bytes: DashMap::new(),
+            node_cache_reserved_capacity: DashMap::new(),
             put_target_decision_counts: DashMap::new(),
             put_requester_target_decision_counts: DashMap::new(),
             put_placement_mode_counts: DashMap::new(),
@@ -532,6 +705,7 @@ impl MasterKvRouter {
 
         self.spawn_cluster_listener();
         self.spawn_put_placement_reporter();
+        self.spawn_runtime_observe_reporter();
 
         let delete_broadcast_rx = self
             .0
@@ -587,7 +761,15 @@ impl MasterKvRouter {
         &self,
         key: &str,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
     ) -> Result<(), KvError> {
+        if reject_if_exist_same_key && self.key_has_live_replica(key) {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyAlreadyExists {
+                    key: key.to_string(),
+                },
+            ));
+        }
         let counts = &self.inner().inflight_put_key_counts;
         let mut entry = counts.entry(key.to_string()).or_insert(0);
         if reject_if_inflight_same_key && *entry > 0 {
@@ -601,6 +783,20 @@ impl MasterKvRouter {
         Ok(())
     }
 
+    pub fn key_has_live_replica(&self, key: &str) -> bool {
+        self.inner()
+            .kv_routes
+            .get(key)
+            .map(|one_kv_nodes_routes| {
+                one_kv_nodes_routes
+                    .nodes_replicas
+                    .read()
+                    .values()
+                    .any(|kv_info| !kv_info.tomb_tag.is_tomb())
+            })
+            .unwrap_or(false)
+    }
+
     pub fn release_inflight_put_key(&self, key: &str) {
         Self::release_inflight_put_key_count_map(&self.inner().inflight_put_key_counts, key);
     }
@@ -690,6 +886,92 @@ impl MasterKvRouter {
         crate::metrics::datasource::register_master_only_metric_handler(self.0.view());
 
         // --- Put Handlers ---
+        let view = self.0.view().clone();
+        RPCHandler::<ReserveLocalGrantReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_reserve_local_grant", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let (grant_id, mut ack) =
+                    handle_reserve_local_grant(view_task.clone(), msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send ReserveLocalGrantResp: {:?}", e);
+                    if grant_id != 0 {
+                        let _ = view_task
+                            .master_kv_router()
+                            .take_local_reserve_grant(grant_id);
+                    }
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<ReleaseLocalGrantReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_release_local_grant", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_release_local_grant(view_task, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send ReleaseLocalGrantResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPreparePutKeysReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_batch_prepare_put_keys", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let (reservation_ids, mut ack) =
+                    handle_batch_prepare_put_keys(view_task.clone(), msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPreparePutKeysResp: {:?}", e);
+                    for reservation_id in reservation_ids {
+                        if let Some(info) = view_task
+                            .master_kv_router()
+                            .take_prepared_put_key_reservation(reservation_id)
+                        {
+                            view_task
+                                .master_kv_router()
+                                .release_inflight_put_key(&info.key);
+                        }
+                    }
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchReleasePutKeyReservationsReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_batch_release_put_key_reservations", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack =
+                    handle_batch_release_put_key_reservations(view_task, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchReleasePutKeyReservationsResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
         let view = self.0.view().clone();
         RPCHandler::<PutStartReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
@@ -812,7 +1094,7 @@ impl MasterKvRouter {
             let view = view.clone();
             let view2 = view.clone();
             let view_task = view2.clone();
-            let _ = view.spawn("rpc_delete_ack", async move {
+            view.spawn("rpc_delete_ack", async move {
                 let ack = handle_delete_ack(view_task, msg).await;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send DeleteAckResp: {:?}", e);
@@ -826,7 +1108,7 @@ impl MasterKvRouter {
             let view = view.clone();
             let view2 = view.clone();
             let view_task = view2.clone();
-            let _ = view.spawn("rpc_batch_delete_ack", async move {
+            view.spawn("rpc_batch_delete_ack", async move {
                 let ack = handle_batch_delete_ack(view_task, msg).await;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send BatchDeleteAckResp: {:?}", e);
@@ -835,12 +1117,59 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<PutAppendStartReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_put_append_start", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_put_append_start(view_task.clone(), msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send PutAppendStartResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<PutAppendRevokeReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_put_append_revoke", async move {
+                let ack = handle_put_append_revoke(view_task, msg).await;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send PutAppendRevokeResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<PutAppendDoneReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_put_append_done", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_put_append_done(view_task, msg).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send PutAppendDoneResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
         // --- GetMeta Handler ---
         let view = self.0.view().clone();
         RPCHandler::<GetMetaReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
             let view2 = view.clone();
-            let _ = view.spawn("rpc_get_meta", async move {
+            view.spawn("rpc_get_meta", async move {
                 let ack = handle_get_meta(view2, msg, resp.node_id().clone()).await;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send GetMetaResp: {:?}", e);
@@ -848,6 +1177,107 @@ impl MasterKvRouter {
             });
             Ok(())
         });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchIsExistReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            view.spawn("rpc_batch_is_exist", async move {
+                let ack = handle_batch_is_exist(view2, msg, resp.node_id().clone()).await;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchIsExistResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPutStartReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_batch_put_start", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_put_start(view2, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPutStartResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPutRevokeReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            view.spawn("rpc_batch_put_revoke", async move {
+                let ack = handle_batch_put_revoke(view2, msg).await;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPutRevokeResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPutDoneReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            view.spawn("rpc_batch_put_done", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_put_done(view2, msg).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPutDoneResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchGetStartReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_batch_get_start", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_get_start(view2, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchGetStartResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchGetRevokeReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            view.spawn("rpc_batch_get_revoke", async move {
+                let ack = handle_batch_get_revoke(view2, msg).await;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchGetRevokeResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchGetDoneReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            view.spawn("rpc_batch_get_done", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_get_done(view2, msg).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchGetDoneResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
     }
 
     fn spawn_node_segement_registration_caller(&self) -> ampsc::Sender<ClusterEvent> {
@@ -856,7 +1286,7 @@ impl MasterKvRouter {
         let (tx, mut rx) = ampsc::channel::<ClusterEvent>(NODE_EVENT_QUEUE_CAPACITY);
         let view = self.inner().view().clone();
         let view_task = view.clone();
-        let _ = view.spawn("node_segment_registration_caller", async move {
+        view.spawn("node_segment_registration_caller", async move {
             use std::future::Future;
             use std::pin::Pin;
 
@@ -1171,7 +1601,7 @@ impl MasterKvRouter {
             > = HashMap::new();
 
             async fn send_event_with_warn(
-                _view: &MasterKvRouterView,
+                view: &MasterKvRouterView,
                 node_id: &str,
                 tx: ampsc::Sender<ClusterEvent>,
                 event: ClusterEvent,
@@ -1451,36 +1881,30 @@ impl MasterKvRouter {
         )
     }
 
-    /// Atomically adjust a node's cache capacity reservation by `delta_bytes`.
+    /// Atomically adjust a node's moka usable-capacity reservation by `delta_bytes`.
     /// Positive delta reserves capacity (fetch_sub from usable capacity),
     /// negative delta releases reservation (fetch_add back to usable capacity).
-    pub fn adjust_node_cache_capacity_for_lease(
+    pub fn adjust_node_cache_reserved_capacity(
         &self,
         node_id: &str,
+        reason: ReservedCapacityReason,
         delta_bytes: i64,
     ) -> crate::rpcresp_kvresult_convert::msg_and_error::KvResult<()> {
         if !self.replica_cache_enabled() {
             return Ok(());
         }
-        // Track per-node reserved bytes with an atomic counter
-        let reserved_counter = self
+        let reserved_capacity = self
             .inner()
-            .lease_reserved_bytes
+            .node_cache_reserved_capacity
             .entry(node_id.to_string())
-            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .or_insert_with(|| Arc::new(NodeCacheReservedCapacity::default()))
             .value()
             .clone();
 
-        // Apply delta to the counter with simple fetch ops per user's preference
-        if delta_bytes >= 0 {
-            reserved_counter.fetch_add(delta_bytes as u64, Ordering::Relaxed);
-        } else {
-            let sub = (-delta_bytes) as u64;
-            reserved_counter.fetch_sub(sub, Ordering::Relaxed);
-        }
+        reserved_capacity.apply_delta(reason, delta_bytes);
 
         // Recompute target capacity: base(=MOKA_CACHE_CAPACITY_RATIO * node_space) - reserved_total
-        let reserved_total = reserved_counter.load(Ordering::Relaxed);
+        let reserved_total = reserved_capacity.total_reserved_bytes();
         let node_space_size = self
             .inner()
             .view()
@@ -1489,12 +1913,7 @@ impl MasterKvRouter {
         if node_space_size == 0 {
             // Node not ready: this should not happen in a successful put_done path.
             // Revert the counter delta before returning error.
-            if delta_bytes >= 0 {
-                reserved_counter.fetch_sub(delta_bytes as u64, Ordering::Relaxed);
-            } else {
-                let add = (-delta_bytes) as u64;
-                reserved_counter.fetch_add(add, Ordering::Relaxed);
-            }
+            reserved_capacity.apply_delta(reason, -delta_bytes);
             return Err(
                 crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
                     crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::OwnerNoSeg {
@@ -1512,12 +1931,7 @@ impl MasterKvRouter {
         if let Some(cache) = self.get_node_cache_controller(node_id) {
             if let Err(e) = cache.set_max_capacity(new_capacity) {
                 // Revert counter and return error.
-                if delta_bytes >= 0 {
-                    reserved_counter.fetch_sub(delta_bytes as u64, Ordering::Relaxed);
-                } else {
-                    let add = (-delta_bytes) as u64;
-                    reserved_counter.fetch_add(add, Ordering::Relaxed);
-                }
+                reserved_capacity.apply_delta(reason, -delta_bytes);
                 return Err(crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
                     crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
                         rpc_input_json: format!(
@@ -1530,12 +1944,7 @@ impl MasterKvRouter {
             Ok(())
         } else {
             // Revert counter and return error.
-            if delta_bytes >= 0 {
-                reserved_counter.fetch_sub(delta_bytes as u64, Ordering::Relaxed);
-            } else {
-                let add = (-delta_bytes) as u64;
-                reserved_counter.fetch_add(add, Ordering::Relaxed);
-            }
+            reserved_capacity.apply_delta(reason, -delta_bytes);
             Err(
                 crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
                     crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::OwnerNoSeg {
@@ -1546,21 +1955,159 @@ impl MasterKvRouter {
         }
     }
 
-    // Note: no additional getters for reserved bytes; policy currently relies only on adjust calls.
-}
+    pub fn next_local_reserve_grant_id(&self) -> u64 {
+        self.inner()
+            .next_local_reserve_grant_id
+            .fetch_add(1, Ordering::Relaxed)
+    }
+
+    pub fn next_prepared_put_key_reservation_id(&self) -> u64 {
+        self.inner()
+            .next_prepared_put_key_reservation_id
+            .fetch_add(1, Ordering::Relaxed)
+    }
+
+    pub fn install_local_reserve_grant(&self, grant_id: u64, grant: LocalReserveGrantInfo) {
+        if self
+            .inner()
+            .local_reserve_grants
+            .insert(grant_id, grant)
+            .is_some()
+        {
+            panic!(
+                "duplicate local reserve grant id indicates a logic bug: grant_id={}",
+                grant_id
+            );
+        }
+    }
 
-impl MasterKvRouterView {
-    pub fn try_adjust_node_cache_capacity_for_lease(
+    pub fn take_local_reserve_grant(&self, grant_id: u64) -> Option<LocalReserveGrantInfo> {
+        self.inner()
+            .local_reserve_grants
+            .remove(&grant_id)
+            .map(|(_, grant)| grant)
+    }
+
+    pub fn install_prepared_put_key_reservation(
         &self,
-        node_id: &str,
-        delta_bytes: i64,
-    ) -> Option<crate::rpcresp_kvresult_convert::msg_and_error::KvResult<()>> {
-        let _view_guard = self.try_upgrade()?;
-        Some(
-            self.master_kv_router()
-                .adjust_node_cache_capacity_for_lease(node_id, delta_bytes),
-        )
+        reservation_id: u64,
+        info: PreparedPutKeyReservationInfo,
+    ) {
+        if self
+            .inner()
+            .prepared_put_key_reservations
+            .insert(reservation_id, info)
+            .is_some()
+        {
+            panic!(
+                "duplicate prepared put key reservation id indicates a logic bug: reservation_id={}",
+                reservation_id
+            );
+        }
+    }
+
+    pub fn take_prepared_put_key_reservation(
+        &self,
+        reservation_id: u64,
+    ) -> Option<PreparedPutKeyReservationInfo> {
+        self.inner()
+            .prepared_put_key_reservations
+            .remove(&reservation_id)
+            .map(|(_, info)| info)
+    }
+
+    pub fn runtime_observe_snapshot(&self) -> MasterRuntimeObserveSnapshot {
+        let mut get_holding_bytes = 0u64;
+        for entry in self.inner().get_holding.inner().iter() {
+            get_holding_bytes = get_holding_bytes.saturating_add(entry.value().len);
+        }
+
+        let mut replica_cache_nodes = Vec::new();
+        for entry in self.inner().node_kv_cache_controller.iter() {
+            let owner_node = entry.key().clone();
+            let cache = entry.value().clone();
+            let node_space_size = self
+                .inner()
+                .view()
+                .master_seg_manager()
+                .get_node_space_size(owner_node.as_str());
+            let base_capacity_bytes = (node_space_size as f32 * MOKA_CACHE_CAPACITY_RATIO) as u64;
+            let reserved_capacity_bytes = self
+                .inner()
+                .node_cache_reserved_capacity
+                .get(owner_node.as_str())
+                .map(|reserved| reserved.total_reserved_bytes())
+                .unwrap_or(0);
+            let effective_capacity_bytes = cache.policy().max_capacity().unwrap_or(0);
+            replica_cache_nodes.push(ReplicaCacheNodeObserveSnapshot {
+                owner_node,
+                entries: cache.entry_count(),
+                weighted_bytes: cache.weighted_size(),
+                effective_capacity_bytes,
+                reserved_capacity_bytes,
+                base_capacity_bytes,
+            });
+        }
+
+        MasterRuntimeObserveSnapshot {
+            get_holding_entries: self.inner().get_holding.total() as u64,
+            get_holding_bytes,
+            replica_cache_nodes,
+        }
     }
+
+    fn spawn_runtime_observe_reporter(&self) {
+        let view = self.0.view().clone();
+        let view_task = view.clone();
+        view.spawn("master_runtime_observe_reporter", async move {
+            let mut interval = tokio::time::interval(Duration::from_secs(30));
+            let mut shutdown_waiter = view_task.register_shutdown_waiter();
+            loop {
+                tokio::select! {
+                    _ = shutdown_waiter.wait() => break,
+                    _ = interval.tick() => {
+                        let snapshot = view_task.master_kv_router().runtime_observe_snapshot();
+                        let metrics = view_task.metric_reporter().metrics();
+                        metrics.set_kv_holding_entries(
+                            "master_get_holding",
+                            snapshot.get_holding_entries,
+                        );
+                        metrics.set_kv_holding_bytes(
+                            "master_get_holding",
+                            snapshot.get_holding_bytes,
+                        );
+                        for node in snapshot.replica_cache_nodes {
+                            metrics.set_kv_replica_cache_entries(
+                                node.owner_node.as_str(),
+                                node.entries,
+                            );
+                            metrics.set_kv_replica_cache_weighted_bytes(
+                                node.owner_node.as_str(),
+                                node.weighted_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "effective",
+                                node.effective_capacity_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "reserved",
+                                node.reserved_capacity_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "base",
+                                node.base_capacity_bytes,
+                            );
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    // Note: no additional getters for reserved bytes; policy currently relies only on adjust calls.
 }
 // moved to crate::metrics::client
 
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index 9d5eb1d..efb12c9 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -1,7 +1,7 @@
 use crate::{
     cluster_manager::NodeIDString,
     p2p::msg_pack::{MsgPackSerializePart, RPCReq},
-    rpcresp_kvresult_convert::msg_and_error::{ErrorCode, MsgId},
+    rpcresp_kvresult_convert::msg_and_error::{ErrorCode, MsgId, OK},
 };
 use bitcode::{Decode, Encode};
 use std::collections::HashMap;
@@ -103,6 +103,113 @@ impl RPCReq for GetDoneReq {
     type Resp = GetDoneResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetStartReq {
+    pub keys: Vec<String>,
+}
+impl MsgPackSerializePart for BatchGetStartReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetStartReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetStartItemResp {
+    pub get_id: u64,
+    pub node_id: NodeIDString,
+    pub put_id: PutIDForAKey,
+    pub target_addr: u64,
+    pub src_addr: u64,
+    pub target_base_addr: u64,
+    pub src_base_addr: u64,
+    pub len: u64,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetStartResp {
+    pub items: Vec<BatchGetStartItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchGetStartResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetStartResp as u32
+    }
+}
+impl RPCReq for BatchGetStartReq {
+    type Resp = BatchGetStartResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetRevokeReq {
+    pub get_ids: Vec<u64>,
+}
+impl MsgPackSerializePart for BatchGetRevokeReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetRevokeReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetRevokeItemResp {
+    pub get_id: u64,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetRevokeResp {
+    pub items: Vec<BatchGetRevokeItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for BatchGetRevokeResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetRevokeResp as u32
+    }
+}
+impl RPCReq for BatchGetRevokeReq {
+    type Resp = BatchGetRevokeResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetDoneReq {
+    pub get_ids: Vec<u64>,
+}
+impl MsgPackSerializePart for BatchGetDoneReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetDoneReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetDoneItemResp {
+    pub get_id: u64,
+    pub holder_id: u64,
+    pub allocation_mode: GetAllocationMode,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetDoneResp {
+    pub items: Vec<BatchGetDoneItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchGetDoneResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetDoneResp as u32
+    }
+}
+impl RPCReq for BatchGetDoneReq {
+    type Resp = BatchGetDoneResp;
+}
+
 // --- RPC for CountPrefix ---
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -156,6 +263,117 @@ impl RPCReq for GetMasterOnlyMetricPartReq {
     type Resp = GetMasterOnlyMetricPartResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ReserveLocalGrantReq;
+impl MsgPackSerializePart for ReserveLocalGrantReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::ReserveLocalGrantReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ReserveLocalGrantResp {
+    pub grant_id: u64,
+    pub node_id: NodeIDString,
+    pub addr: u64,
+    pub base_addr: u64,
+    pub len: u64,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for ReserveLocalGrantResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::ReserveLocalGrantResp as u32
+    }
+}
+impl RPCReq for ReserveLocalGrantReq {
+    type Resp = ReserveLocalGrantResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ReleaseLocalGrantReq {
+    pub grant_id: u64,
+}
+impl MsgPackSerializePart for ReleaseLocalGrantReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::ReleaseLocalGrantReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ReleaseLocalGrantResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for ReleaseLocalGrantResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::ReleaseLocalGrantResp as u32
+    }
+}
+impl RPCReq for ReleaseLocalGrantReq {
+    type Resp = ReleaseLocalGrantResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPreparePutKeyItemReq {
+    pub key: String,
+    pub reject_if_inflight_same_key: bool,
+    pub reject_if_exist_same_key: bool,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPreparePutKeysReq {
+    pub items: Vec<BatchPreparePutKeyItemReq>,
+}
+impl MsgPackSerializePart for BatchPreparePutKeysReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPreparePutKeysReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPreparePutKeysResp {
+    pub reservation_ids: Vec<u64>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchPreparePutKeysResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPreparePutKeysResp as u32
+    }
+}
+impl RPCReq for BatchPreparePutKeysReq {
+    type Resp = BatchPreparePutKeysResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchReleasePutKeyReservationsReq {
+    pub reservation_ids: Vec<u64>,
+}
+impl MsgPackSerializePart for BatchReleasePutKeyReservationsReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchReleasePutKeyReservationsReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchReleasePutKeyReservationsResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchReleasePutKeyReservationsResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchReleasePutKeyReservationsResp as u32
+    }
+}
+impl RPCReq for BatchReleasePutKeyReservationsReq {
+    type Resp = BatchReleasePutKeyReservationsResp;
+}
+
 // --- RPC for Put ---
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -163,6 +381,8 @@ pub struct PutStartReq {
     pub key: String,
     pub len: u64,
     pub reject_if_inflight_same_key: bool,
+    pub reject_if_exist_same_key: bool,
+    pub write_through: bool,
     /// Prefer placing the target allocation on any kvclient within this sub_cluster.
     pub preferred_sub_cluster: Option<String>,
     /// Optional source-node override for side-transfer workers that share an owner's mmap.
@@ -222,12 +442,26 @@ impl RPCReq for PutRevokeReq {
     type Resp = PutRevokeResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutDoneCommittedSlot {
+    pub grant_id: u64,
+    pub slot_index: u32,
+    pub slot_size: u64,
+    pub addr: u64,
+    pub base_addr: u64,
+    pub len: u64,
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutDoneReq {
     pub key: String,
     pub put_id: PutIDForAKey,
     /// Optional lease to attach this key to on commit
     pub lease_id: Option<u64>,
+    /// Optional local committed slot descriptor for local-first publish path.
+    pub committed_slot: Option<PutDoneCommittedSlot>,
+    /// Ask master to keep a local read holder for the committing node.
+    pub publish_local_cache: bool,
 }
 impl MsgPackSerializePart for PutDoneReq {
     fn msg_id(&self) -> u32 {
@@ -240,6 +474,8 @@ pub struct PutDoneResp {
     pub error_json: String,
     /// Server-side processing time in microseconds for this RPC handler
     pub server_process_us: i64,
+    /// Holder id for an owner-local cache view, present only when requested.
+    pub local_cache_holder_id: Option<u64>,
 }
 impl MsgPackSerializePart for PutDoneResp {
     fn msg_id(&self) -> u32 {
@@ -250,6 +486,220 @@ impl RPCReq for PutDoneReq {
     type Resp = PutDoneResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutStartItemReq {
+    pub key: String,
+    pub len: u64,
+    pub reject_if_inflight_same_key: bool,
+    pub reject_if_exist_same_key: bool,
+    pub write_through: bool,
+    pub preferred_sub_cluster: Option<String>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutStartReq {
+    pub items: Vec<BatchPutStartItemReq>,
+}
+impl MsgPackSerializePart for BatchPutStartReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutStartReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutStartItemResp {
+    pub put_id: PutIDForAKey,
+    pub node_id: NodeIDString,
+    pub target_addr: u64,
+    pub src_addr: u64,
+    pub target_base_addr: u64,
+    pub src_base_addr: u64,
+    pub len: u64,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutStartResp {
+    pub items: Vec<BatchPutStartItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchPutStartResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutStartResp as u32
+    }
+}
+impl RPCReq for BatchPutStartReq {
+    type Resp = BatchPutStartResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutRevokeItemReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutRevokeReq {
+    pub items: Vec<BatchPutRevokeItemReq>,
+}
+impl MsgPackSerializePart for BatchPutRevokeReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutRevokeReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutRevokeItemResp {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutRevokeResp {
+    pub items: Vec<BatchPutRevokeItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for BatchPutRevokeResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutRevokeResp as u32
+    }
+}
+impl RPCReq for BatchPutRevokeReq {
+    type Resp = BatchPutRevokeResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutDoneItemReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub lease_id: Option<u64>,
+    pub committed_slot: Option<PutDoneCommittedSlot>,
+    pub publish_local_cache: bool,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutDoneReq {
+    pub items: Vec<BatchPutDoneItemReq>,
+}
+impl MsgPackSerializePart for BatchPutDoneReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutDoneReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutDoneItemResp {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub local_cache_holder_id: Option<u64>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutDoneResp {
+    pub items: Vec<BatchPutDoneItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchPutDoneResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutDoneResp as u32
+    }
+}
+impl RPCReq for BatchPutDoneReq {
+    type Resp = BatchPutDoneResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutAppendStartReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub len: u64,
+    pub preferred_sub_cluster: Option<String>,
+}
+impl MsgPackSerializePart for PutAppendStartReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::PutAppendStartReq as u32
+    }
+}
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutAppendStartResp {
+    pub scheduled: bool,
+    pub node_id: NodeIDString,
+    pub target_addr: u64,
+    pub target_base_addr: u64,
+    pub len: u64,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for PutAppendStartResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::PutAppendStartResp as u32
+    }
+}
+impl RPCReq for PutAppendStartReq {
+    type Resp = PutAppendStartResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutAppendRevokeReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+}
+impl MsgPackSerializePart for PutAppendRevokeReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::PutAppendRevokeReq as u32
+    }
+}
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutAppendRevokeResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for PutAppendRevokeResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::PutAppendRevokeResp as u32
+    }
+}
+impl RPCReq for PutAppendRevokeReq {
+    type Resp = PutAppendRevokeResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutAppendDoneReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+}
+impl MsgPackSerializePart for PutAppendDoneReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::PutAppendDoneReq as u32
+    }
+}
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutAppendDoneResp {
+    pub appended: bool,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for PutAppendDoneResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::PutAppendDoneResp as u32
+    }
+}
+impl RPCReq for PutAppendDoneReq {
+    type Resp = PutAppendDoneResp;
+}
+
 // --- RPC for MemHolder KeepAlive ---
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -414,6 +864,31 @@ impl RPCReq for GetMetaReq {
     type Resp = GetMetaResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchIsExistReq {
+    pub keys: Vec<String>,
+}
+impl MsgPackSerializePart for BatchIsExistReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchIsExistReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchIsExistResp {
+    pub exists_list: Vec<bool>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for BatchIsExistResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchIsExistResp as u32
+    }
+}
+impl RPCReq for BatchIsExistReq {
+    type Resp = BatchIsExistResp;
+}
+
 // --- RPC for Batch Delete Client KV Meta Cache ---
 
 #[derive(Debug, Clone, Encode, Decode, Default)]
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
index d9f509f..d6c04bf 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
@@ -6,8 +6,8 @@ use crate::{
     rpcresp_kvresult_convert::msg_and_error::KvError,
 };
 use async_trait::async_trait;
-use rand::Rng;
 use rand::seq::SliceRandom;
+use rand::Rng;
 
 use super::MasterKvRouterView;
 
@@ -40,8 +40,8 @@ pub trait PlacementPolicy: Send + Sync {
 /// Change the type alias to switch behavior (and rebuild):
 /// - `LocalFirstPlacementPolicy` prefers local placement when possible.
 /// - `RandomPlacementPolicy` selects a random eligible target.
-// pub type PlacementDefault = LocalFirstPlacementPolicy;
-pub type PlacementDefault = RandomPlacementPolicy;
+pub type PlacementDefault = LocalFirstPlacementPolicy;
+// pub type PlacementDefault = RandomPlacementPolicy;
 
 /// A policy that prefers placing on the requesting node when possible.
 pub struct LocalFirstPlacementPolicy;
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index 70d8858..e8598e8 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -1,24 +1,41 @@
 use super::NodeValueReplicaDesc;
 use super::{
-    InflightPutAllocation, InflightPutInfo, KvRouteInfo, MasterKvRouterView, PutPlacementMode,
-    msg_pack::{PutDoneReq, PutDoneResp, PutRevokeReq, PutRevokeResp, PutStartReq, PutStartResp},
+    msg_pack::{
+        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutDoneItemResp, BatchPutDoneReq,
+        BatchPutDoneResp, BatchPutRevokeItemResp, BatchPutRevokeReq, BatchPutRevokeResp,
+        BatchPutStartItemResp, BatchPutStartReq, BatchPutStartResp,
+        BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp, PutAppendDoneReq,
+        PutAppendDoneResp, PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartReq,
+        PutAppendStartResp, PutDoneReq, PutDoneResp, PutRevokeReq, PutRevokeResp, PutStartReq,
+        PutStartResp, ReleaseLocalGrantReq, ReleaseLocalGrantResp, ReserveLocalGrantReq,
+        ReserveLocalGrantResp,
+    },
     placement::PutPlacementTarget,
+    CommittedSlotReplica, InflightPutAllocation, InflightPutAppendInfo, InflightPutCommitInfo,
+    InflightPutInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo, MasterKvRouterView,
+    OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
 };
-use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::delete::DeleteKeyInfo;
+use crate::master_kv_router::OneKvNodesRoutes;
+use crate::memholder::MemholderManagerTrait;
 use crate::{
-    cluster_manager::{META_KEY_LOCAL_IPC_ROOT, NodeID},
-    master_seg_manager::one_seg_allocator::Allocation,
+    cluster_manager::{
+        NodeID, META_KEY_LOCAL_IPC_ROOT, META_KEY_SHARED_STORAGE_NODE_ID,
+        META_KEY_SHARED_STORAGE_NODE_START_TIME,
+    },
+    master_seg_manager::{one_seg_allocator::Allocation, MasterSegManagerAccessTrait},
     p2p::msg_pack::MsgPack,
-    rpcresp_kvresult_convert::msg_and_error,
+    rpcresp_kvresult_convert::msg_and_error::{self, kv},
+    OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
 };
-use fluxon_commu::{META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME};
+use chrono::Utc;
+use limit_thirdparty::tokio;
 use parking_lot::Mutex;
 use parking_lot::RwLock;
 use rand::seq::SliceRandom;
 use std::{
-    collections::HashMap,
-    sync::{Arc, atomic::AtomicU32},
+    collections::{HashMap, HashSet},
+    sync::{atomic::AtomicU32, Arc},
 };
 
 pub type PutIDForAKey = (u64, u32);
@@ -153,16 +170,325 @@ fn validate_put_start_source_node_override(
     Ok(())
 }
 
+fn current_route_needs_remote_replica(
+    route: &OneKvNodesRoutes,
+    source_node_id: &NodeID,
+    verify_put_id: PutIDForAKey,
+) -> bool {
+    if route.put_id != verify_put_id {
+        return false;
+    }
+    route
+        .nodes_replicas
+        .read()
+        .values()
+        .all(|replica| replica.tomb_tag.is_tomb() || replica.node_id == *source_node_id)
+}
+
+fn append_current_route_replica_if_matching(
+    view: &MasterKvRouterView,
+    key: &str,
+    put_id: PutIDForAKey,
+    node_id: NodeID,
+    allocation: Allocation,
+) -> bool {
+    let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) else {
+        tracing::debug!(
+            "append_current_route_replica_if_matching skipped because route disappeared: key={} put_id=({},{})",
+            key,
+            put_id.0,
+            put_id.1
+        );
+        return false;
+    };
+    if one_kv_nodes_routes.put_id != put_id {
+        tracing::debug!(
+            "append_current_route_replica_if_matching skipped because version changed: key={} current_put_id=({},{}) append_put_id=({},{})",
+            key,
+            one_kv_nodes_routes.put_id.0,
+            one_kv_nodes_routes.put_id.1,
+            put_id.0,
+            put_id.1
+        );
+        return false;
+    }
+    let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
+        tracing::warn!(
+            "append_current_route_replica_if_matching skipped because target node tomb-tag missing: key={} put_id=({},{}) node_id={}",
+            key,
+            put_id.0,
+            put_id.1,
+            node_id
+        );
+        return false;
+    };
+    if tomb_tag.is_tomb() {
+        tracing::warn!(
+            "append_current_route_replica_if_matching skipped because target node is tomb: key={} put_id=({},{}) node_id={}",
+            key,
+            put_id.0,
+            put_id.1,
+            node_id
+        );
+        return false;
+    }
+    let alloc_cap = allocation.capcity();
+    let req_weight = if alloc_cap > u32::MAX as u64 {
+        tracing::warn!(
+            "moka weight saturation on put append: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
+            key,
+            put_id.0,
+            put_id.1,
+            alloc_cap
+        );
+        u32::MAX
+    } else {
+        alloc_cap as u32
+    };
+    let lease_id = one_kv_nodes_routes.lease_id;
+    one_kv_nodes_routes.nodes_replicas.write().insert(
+        node_id.clone(),
+        KvRouteInfo {
+            node_id: node_id.clone(),
+            backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
+            tomb_tag,
+        },
+    );
+    if lease_id.is_none() {
+        if let Some(cache) = view.master_kv_router().get_node_cache_controller(&node_id) {
+            cache.insert(
+                key.to_string(),
+                NodeValueReplicaDesc {
+                    weight_bytes: req_weight,
+                    put_id,
+                },
+            );
+        }
+    }
+    true
+}
+
+fn choose_remote_append_target(
+    view: &MasterKvRouterView,
+    source_node_id: &NodeID,
+    excluded_nodes: &HashSet<NodeID>,
+    preferred_sub_cluster: Option<&str>,
+    len: u64,
+) -> msg_and_error::KvResult<(NodeID, Allocation)> {
+    let seg_manager = view.master_seg_manager();
+    let mut last_no_space_ctx: Option<(String, String, u64, u64)> = None;
+
+    if let Some(sc) = preferred_sub_cluster {
+        let mut preferred_nodes: Vec<NodeID> = view
+            .cluster_manager()
+            .get_client_members()
+            .into_iter()
+            .filter_map(|m| (m.sub_cluster.as_deref() == Some(sc)).then_some(m.id.into()))
+            .collect();
+        preferred_nodes.retain(|node_id| {
+            node_id.as_ref() != source_node_id.as_ref() && !excluded_nodes.contains(node_id)
+        });
+        preferred_nodes.shuffle(&mut rand::thread_rng());
+        for node_id in preferred_nodes {
+            let node_allocators = seg_manager.get_node_allocators(&node_id);
+            let Some(allocator) = node_allocators.choose(&mut rand::thread_rng()).cloned() else {
+                continue;
+            };
+            let total = allocator.total_size_bytes();
+            let used = allocator.used_size_bytes();
+            let free = total.saturating_sub(used);
+            last_no_space_ctx = Some((
+                node_id.as_ref().to_string(),
+                allocator.seg_device_id.clone(),
+                total,
+                free,
+            ));
+            if let Ok(allocation) = allocator.allocate(len) {
+                return Ok((node_id, allocation));
+            }
+        }
+    }
+
+    let all_segs = seg_manager.get_all_segments_allocator();
+    let mut candidates: Vec<(
+        NodeID,
+        Arc<crate::master_seg_manager::one_seg_allocator::OneSegAllocator>,
+    )> = all_segs
+        .into_iter()
+        .filter_map(|(node_id, allocator)| {
+            let node_id: NodeID = node_id.into();
+            if node_id.as_ref() == source_node_id.as_ref() || excluded_nodes.contains(&node_id) {
+                return None;
+            }
+            Some((node_id, allocator))
+        })
+        .collect();
+    candidates.shuffle(&mut rand::thread_rng());
+    for (node_id, allocator) in candidates {
+        let total = allocator.total_size_bytes();
+        let used = allocator.used_size_bytes();
+        let free = total.saturating_sub(used);
+        last_no_space_ctx = Some((
+            node_id.as_ref().to_string(),
+            allocator.seg_device_id.clone(),
+            total,
+            free,
+        ));
+        if let Ok(allocation) = allocator.allocate(len) {
+            return Ok((node_id, allocation));
+        }
+    }
+
+    Err(
+        if let Some((node, segment, total_capacity, free_capacity)) = last_no_space_ctx {
+            msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
+                node,
+                segment,
+                total_capacity,
+                free_capacity,
+            })
+        } else {
+            msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
+                node: "unknown".to_string(),
+                segment: "unknown".to_string(),
+                total_capacity: 0,
+                free_capacity: 0,
+            })
+        },
+    )
+}
+
+fn allocate_from_node_local_segment(
+    view: &MasterKvRouterView,
+    node_id: &NodeID,
+    len: u64,
+    op_name: &str,
+) -> msg_and_error::KvResult<Allocation> {
+    let node_allocators = view.master_seg_manager().get_node_allocators(node_id);
+    if node_allocators.is_empty() {
+        tracing::warn!("No allocators found for {} node={}", op_name, node_id);
+        return Err(msg_and_error::KvError::Api(
+            msg_and_error::ApiError::RegisterSegmentFailed {
+                detail: format!(
+                    "{} node has no registered segments: node={}",
+                    op_name, node_id
+                ),
+            },
+        ));
+    }
+
+    let allocator = node_allocators.choose(&mut rand::thread_rng()).unwrap();
+    for attempt in 1..=3 {
+        if let Ok(allocation) = allocator.allocate(len) {
+            return Ok(allocation);
+        }
+        tracing::warn!(
+            "Allocation attempt {}/3 failed for {} node={} len={}",
+            attempt,
+            op_name,
+            node_id,
+            len
+        );
+    }
+
+    let total = allocator.total_size_bytes();
+    let used = allocator.used_size_bytes();
+    let free = total.saturating_sub(used);
+    Err(msg_and_error::KvError::Api(
+        msg_and_error::ApiError::NoSpace {
+            node: node_id.as_ref().to_string(),
+            segment: allocator.seg_device_id.clone(),
+            total_capacity: total,
+            free_capacity: free,
+        },
+    ))
+}
+
+fn reserve_write_back_remote_append(
+    view: &MasterKvRouterView,
+    key: &str,
+    put_id: PutIDForAKey,
+    source_node_id: &NodeID,
+    preferred_sub_cluster: Option<&str>,
+    len: u64,
+) -> msg_and_error::KvResult<InflightPutAppendInfo> {
+    let (target_node_id, target_allocation) = choose_remote_append_target(
+        view,
+        source_node_id,
+        &HashSet::new(),
+        preferred_sub_cluster,
+        len,
+    )?;
+    tracing::debug!(
+        "write-back remote append reserved: key={} put_id=({},{}) source_node_id={} target_node_id={} preferred_sub_cluster={:?} len={}",
+        key,
+        put_id.0,
+        put_id.1,
+        source_node_id,
+        target_node_id,
+        preferred_sub_cluster,
+        len
+    );
+    Ok(InflightPutAppendInfo {
+        node_id: target_node_id,
+        key: key.to_string(),
+        put_id,
+        target_allocation: Arc::new(Mutex::new(Some(target_allocation))),
+    })
+}
+
+fn try_reserve_write_back_remote_append(
+    view: &MasterKvRouterView,
+    key: &str,
+    put_id: PutIDForAKey,
+    source_node_id: &NodeID,
+    preferred_sub_cluster: Option<&str>,
+    len: u64,
+) -> msg_and_error::KvResult<Option<InflightPutAppendInfo>> {
+    match reserve_write_back_remote_append(
+        view,
+        key,
+        put_id,
+        source_node_id,
+        preferred_sub_cluster,
+        len,
+    ) {
+        Ok(reserved) => Ok(Some(reserved)),
+        Err(msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
+            node,
+            segment,
+            total_capacity,
+            free_capacity,
+        })) => {
+            tracing::info!(
+                "write-back remote append not scheduled; fallback to local-only commit: key={} put_id=({},{}) source_node_id={} preferred_sub_cluster={:?} node={} segment={} total_capacity={} free_capacity={}",
+                key,
+                put_id.0,
+                put_id.1,
+                source_node_id,
+                preferred_sub_cluster,
+                node,
+                segment,
+                total_capacity,
+                free_capacity
+            );
+            Ok(None)
+        }
+        Err(err) => Err(err),
+    }
+}
+
 pub async fn handle_put_start(
     view: MasterKvRouterView,
     req: MsgPack<PutStartReq>,
     req_node_id: NodeID,
 ) -> (PutIDForAKey, MsgPack<PutStartResp>) {
     let key = req.serialize_part.key.clone();
-    if let Err(err) = view
-        .master_kv_router()
-        .reserve_inflight_put_key(&key, req.serialize_part.reject_if_inflight_same_key)
-    {
+    if let Err(err) = view.master_kv_router().reserve_inflight_put_key(
+        &key,
+        req.serialize_part.reject_if_inflight_same_key,
+        req.serialize_part.reject_if_exist_same_key,
+    ) {
         let resp: PutStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
         return (
             (0, 0),
@@ -199,58 +525,14 @@ pub async fn handle_put_start(
 
     let inflight_put_key: (String, u64, u32) = (key.clone(), put_id.0, put_id.1);
 
-    // randomly select one src_allocator
-    let src_allocation = {
-        let src_node_allocators = view
-            .master_seg_manager()
-            .get_node_allocators(&source_node_id);
-        if src_node_allocators.is_empty() {
-            tracing::warn!(
-                "No allocators found for put_start source node: requester={} source={}",
-                req_node_id,
-                source_node_id
-            );
-            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::RegisterSegmentFailed {
-                detail: format!(
-                    "put_start source node has no registered segments: requester={} source={}",
-                    req_node_id, source_node_id
-                ),
-            });
-            let resp: PutStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
-            return (
-                (0, 0),
-                MsgPack {
-                    serialize_part: resp,
-                    raw_bytes: Vec::new(),
-                },
-            );
-        }
-
-        let src_allocator = src_node_allocators.choose(&mut rand::thread_rng()).unwrap();
-
-        let mut allocated_addr: Option<Allocation> = None;
-        for attempt in 1..=3 {
-            if let Ok(allocation) = src_allocator.allocate(req.serialize_part.len) {
-                allocated_addr = Some(allocation);
-                break;
-            } else {
-                tracing::warn!(
-                    "Allocation attempt {}/3 failed for put_id {:?}",
-                    attempt,
-                    put_id
-                );
-            }
-        }
-        if allocated_addr.is_none() {
-            let total = src_allocator.total_size_bytes();
-            let used = src_allocator.used_size_bytes();
-            let free = total.saturating_sub(used);
-            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
-                node: source_node_id.as_ref().to_string(),
-                segment: src_allocator.seg_device_id.clone(),
-                total_capacity: total,
-                free_capacity: free,
-            });
+    let src_allocation = match allocate_from_node_local_segment(
+        &view,
+        &source_node_id,
+        req.serialize_part.len,
+        "put_start source",
+    ) {
+        Ok(allocation) => allocation,
+        Err(err) => {
             let resp: PutStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
             return (
                 (0, 0),
@@ -260,25 +542,29 @@ pub async fn handle_put_start(
                 },
             );
         }
-        allocated_addr.unwrap()
     };
 
     // Keep src allocation alive across retry attempts until we have a successful target.
     let mut src_allocation = Some(src_allocation);
 
-    let finalize = |node_id: NodeID,
+    let finalize = |commit_node_id: NodeID,
+                    response_node_id: NodeID,
                     inflight_alloc: InflightPutAllocation,
+                    remote_append: Option<InflightPutAppendInfo>,
                     src_addr: u64,
                     target_addr: u64,
                     src_base_addr: u64,
                     target_base_addr: u64,
                     len: u64| {
         let info = InflightPutInfo {
-            node_id: node_id.clone(),
             key: key.clone(),
             len,
             req_node_id: req_node_id.clone(),
-            src_target_allocation: Arc::new(Mutex::new(Some(inflight_alloc))),
+            commit_info: InflightPutCommitInfo {
+                node_id: commit_node_id,
+                src_target_allocation: Arc::new(Mutex::new(Some(inflight_alloc))),
+            },
+            remote_append,
         };
 
         let view_task = view.clone();
@@ -293,7 +579,7 @@ pub async fn handle_put_start(
 
             let resp = PutStartResp {
                 put_id,
-                node_id: node_id.into(),
+                node_id: response_node_id.into(),
                 src_addr,
                 target_addr,
                 src_base_addr,
@@ -314,17 +600,22 @@ pub async fn handle_put_start(
         }
     };
 
-    let put_target = view
-        .master_kv_router()
-        .inner()
-        .policy
-        .select_put_target(
-            &view,
-            &source_node_id,
-            req.serialize_part.preferred_sub_cluster.as_deref(),
-            req.serialize_part.len,
-        )
-        .await;
+    let put_target = if req.serialize_part.write_through {
+        view.master_kv_router()
+            .inner()
+            .policy
+            .select_put_target(
+                &view,
+                &source_node_id,
+                req.serialize_part.preferred_sub_cluster.as_deref(),
+                req.serialize_part.len,
+            )
+            .await
+    } else {
+        Ok(PutPlacementTarget::Local {
+            node_id: source_node_id.clone(),
+        })
+    };
 
     match put_target {
         Ok(PutPlacementTarget::Local { node_id }) => {
@@ -362,14 +653,58 @@ pub async fn handle_put_start(
             let src = src_allocation
                 .take()
                 .expect("src_allocation must exist when finalizing local put");
+            let remote_append = if req.serialize_part.write_through {
+                None
+            } else {
+                match try_reserve_write_back_remote_append(
+                    &view,
+                    &key,
+                    put_id,
+                    &source_node_id,
+                    req.serialize_part.preferred_sub_cluster.as_deref(),
+                    req.serialize_part.len,
+                ) {
+                    Ok(reserved) => reserved,
+                    Err(err) => {
+                        let resp: PutStartResp =
+                            crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+                        return (
+                            (0, 0),
+                            MsgPack {
+                                serialize_part: resp,
+                                raw_bytes: Vec::new(),
+                            },
+                        );
+                    }
+                }
+            };
+            let (response_node_id, response_target_addr, response_target_base_addr, response_len) =
+                if let Some(remote_append) = remote_append.as_ref() {
+                    let target_allocation_guard = remote_append.target_allocation.lock();
+                    let target_allocation = target_allocation_guard
+                        .as_ref()
+                        .expect("reserved remote append allocation must exist during put_start");
+                    let target_base = target_allocation.base_addr();
+                    let target_addr = target_base + target_allocation.addr();
+                    (
+                        remote_append.node_id.clone(),
+                        target_addr,
+                        target_base,
+                        target_allocation.size(),
+                    )
+                } else {
+                    (node_id.clone(), abs, src_base, allocation_size)
+                };
             let fut = finalize(
                 node_id,
+                response_node_id,
                 InflightPutAllocation::Local(src),
+                remote_append,
                 abs,
-                abs,
-                src_base,
+                response_target_addr,
                 src_base,
-                allocation_size,
+                response_target_base_addr,
+                response_len,
             );
             let result = fut.await;
             key_reservation.disarm();
@@ -413,11 +748,13 @@ pub async fn handle_put_start(
                 .take()
                 .expect("src_allocation must exist when finalizing remote put");
             let fut = finalize(
+                node_id.clone(),
                 node_id,
                 InflightPutAllocation::Remote {
                     src,
                     target: target_allocation,
                 },
+                None,
                 src_base + src_offset,
                 target_base + target_offset,
                 src_base,
@@ -441,6 +778,249 @@ pub async fn handle_put_start(
     }
 }
 
+pub async fn handle_reserve_local_grant(
+    view: MasterKvRouterView,
+    req: MsgPack<ReserveLocalGrantReq>,
+    req_node_id: NodeID,
+) -> (u64, MsgPack<ReserveLocalGrantResp>) {
+    let _ = req;
+
+    let mut allocation = match allocate_from_node_local_segment(
+        &view,
+        &req_node_id,
+        OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
+        "reserve_local_grant",
+    ) {
+        Ok(allocation) => allocation,
+        Err(err) => {
+            let resp: ReserveLocalGrantResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            return (
+                0,
+                MsgPack {
+                    serialize_part: resp,
+                    raw_bytes: Vec::new(),
+                },
+            );
+        }
+    };
+
+    let reserved_bytes = allocation.capcity();
+    if let Err(err) = view.master_kv_router().adjust_node_cache_reserved_capacity(
+        req_node_id.as_ref(),
+        ReservedCapacityReason::LocalReserveGrant,
+        reserved_bytes as i64,
+    ) {
+        let resp: ReserveLocalGrantResp =
+            crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+        return (
+            0,
+            MsgPack {
+                serialize_part: resp,
+                raw_bytes: Vec::new(),
+            },
+        );
+    }
+
+    let view_clone = view.clone();
+    let node_id_string = req_node_id.as_ref().to_string();
+    allocation.set_on_drop(move || {
+        if let Err(e) = view_clone
+            .master_kv_router()
+            .adjust_node_cache_reserved_capacity(
+                &node_id_string,
+                ReservedCapacityReason::LocalReserveGrant,
+                -(reserved_bytes as i64),
+            )
+        {
+            tracing::warn!(
+                "Failed to restore moka capacity on local reserve grant drop: node_id={}, bytes={}, err={}",
+                node_id_string,
+                reserved_bytes,
+                e
+            );
+        }
+    });
+
+    let grant_id = view.master_kv_router().next_local_reserve_grant_id();
+    let grant_base_addr = allocation.base_addr();
+    let grant_abs_addr = grant_base_addr + allocation.addr();
+    let grant_len = allocation.capcity();
+    view.master_kv_router().install_local_reserve_grant(
+        grant_id,
+        LocalReserveGrantInfo {
+            owner_node_id: req_node_id.clone(),
+            allocation,
+        },
+    );
+
+    (
+        grant_id,
+        MsgPack {
+            serialize_part: ReserveLocalGrantResp {
+                grant_id,
+                node_id: req_node_id.into_owned(),
+                addr: grant_abs_addr,
+                base_addr: grant_base_addr,
+                len: grant_len,
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            },
+            raw_bytes: Vec::new(),
+        },
+    )
+}
+
+pub async fn handle_release_local_grant(
+    view: MasterKvRouterView,
+    req: MsgPack<ReleaseLocalGrantReq>,
+    req_node_id: NodeID,
+) -> MsgPack<ReleaseLocalGrantResp> {
+    let grant_id = req.serialize_part.grant_id;
+    let Some(grant) = view.master_kv_router().take_local_reserve_grant(grant_id) else {
+        tracing::info!(
+            "release_local_grant ignored missing grant_id={} requester_node_id={}",
+            grant_id,
+            req_node_id
+        );
+        return MsgPack {
+            serialize_part: ReleaseLocalGrantResp::default(),
+            raw_bytes: Vec::new(),
+        };
+    };
+
+    if grant.owner_node_id.as_ref() != req_node_id.as_ref() {
+        let owner_node_id = grant.owner_node_id.to_string();
+        view.master_kv_router()
+            .install_local_reserve_grant(grant_id, grant);
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: format!(
+                "release_local_grant owner mismatch: grant_id={} owner_node_id={} requester_node_id={}",
+                grant_id, owner_node_id, req_node_id
+            ),
+        });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    }
+
+    drop(grant);
+    MsgPack {
+        serialize_part: ReleaseLocalGrantResp::default(),
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_prepare_put_keys(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPreparePutKeysReq>,
+    req_node_id: NodeID,
+) -> (Vec<u64>, MsgPack<BatchPreparePutKeysResp>) {
+    let mut reservation_ids = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        if let Err(err) = view.master_kv_router().reserve_inflight_put_key(
+            &item.key,
+            item.reject_if_inflight_same_key,
+            item.reject_if_exist_same_key,
+        ) {
+            for reservation_id in reservation_ids.drain(..) {
+                if let Some(info) = view
+                    .master_kv_router()
+                    .take_prepared_put_key_reservation(reservation_id)
+                {
+                    view.master_kv_router().release_inflight_put_key(&info.key);
+                }
+            }
+            let resp: BatchPreparePutKeysResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            return (
+                Vec::new(),
+                MsgPack {
+                    serialize_part: resp,
+                    raw_bytes: Vec::new(),
+                },
+            );
+        }
+        let reservation_id = view
+            .master_kv_router()
+            .next_prepared_put_key_reservation_id();
+        view.master_kv_router()
+            .install_prepared_put_key_reservation(
+                reservation_id,
+                PreparedPutKeyReservationInfo {
+                    owner_node_id: req_node_id.clone(),
+                    key: item.key,
+                },
+            );
+        reservation_ids.push(reservation_id);
+    }
+
+    (
+        reservation_ids.clone(),
+        MsgPack {
+            serialize_part: BatchPreparePutKeysResp {
+                reservation_ids,
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            },
+            raw_bytes: Vec::new(),
+        },
+    )
+}
+
+pub async fn handle_batch_release_put_key_reservations(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchReleasePutKeyReservationsReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchReleasePutKeyReservationsResp> {
+    let mut taken = Vec::with_capacity(req.serialize_part.reservation_ids.len());
+    for reservation_id in req.serialize_part.reservation_ids {
+        let Some(info) = view
+            .master_kv_router()
+            .take_prepared_put_key_reservation(reservation_id)
+        else {
+            tracing::info!(
+                "batch_release_put_key_reservations ignored missing reservation_id={} requester_node_id={}",
+                reservation_id,
+                req_node_id
+            );
+            continue;
+        };
+        if info.owner_node_id.as_ref() != req_node_id.as_ref() {
+            let owner_node_id = info.owner_node_id.to_string();
+            view.master_kv_router()
+                .install_prepared_put_key_reservation(reservation_id, info);
+            for (restore_id, restore_info) in taken {
+                view.master_kv_router()
+                    .install_prepared_put_key_reservation(restore_id, restore_info);
+            }
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "batch_release_put_key_reservations owner mismatch: reservation_id={} owner_node_id={} requester_node_id={}",
+                    reservation_id, owner_node_id, req_node_id
+                ),
+            });
+            return MsgPack {
+                serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                raw_bytes: Vec::new(),
+            };
+        }
+        taken.push((reservation_id, info));
+    }
+
+    for (_reservation_id, info) in taken {
+        view.master_kv_router().release_inflight_put_key(&info.key);
+    }
+
+    MsgPack {
+        serialize_part: BatchReleasePutKeyReservationsResp::default(),
+        raw_bytes: Vec::new(),
+    }
+}
+
 pub async fn handle_put_revoke(
     view: MasterKvRouterView,
     req: MsgPack<PutRevokeReq>,
@@ -483,12 +1063,13 @@ pub async fn handle_put_done(
     let put_id = req.serialize_part.put_id;
     let lease_id_opt = req.serialize_part.lease_id;
     let full_put_id: (String, u64, u32) = (req.serialize_part.key.clone(), put_id.0, put_id.1);
+    let local_cache_holder_id: Option<u64>;
 
     // Remove from inflight_puts and store in completed_puts
     if let Some(InflightPutInfo {
-        node_id,
         key,
-        src_target_allocation,
+        commit_info,
+        remote_append,
         ..
     }) = view
         .master_kv_router()
@@ -498,7 +1079,8 @@ pub async fn handle_put_done(
         .await
     {
         view.master_kv_router().release_inflight_put_key(&key);
-        let Some(allocs) = src_target_allocation.lock().take() else {
+        let node_id = commit_info.node_id;
+        let Some(allocs) = commit_info.src_target_allocation.lock().take() else {
             tracing::warn!(
                 "Put operation with put_id {:?} not found for completion",
                 full_put_id
@@ -515,11 +1097,6 @@ pub async fn handle_put_done(
             };
         };
 
-        let mut target_allocation = match allocs {
-            InflightPutAllocation::Local(target) => target,
-            InflightPutAllocation::Remote { src: _src, target } => target,
-        };
-
         let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
             tracing::warn!(
                 "Put operation with put_id {:?} not found for completion",
@@ -548,7 +1125,225 @@ pub async fn handle_put_done(
             };
         }
 
-        let target_cap_bytes = target_allocation.capcity();
+        let route_committed_slot = req.serialize_part.committed_slot.clone();
+        let (target_cap_bytes, completed_info, local_cache_publish_supported) = match allocs {
+            InflightPutAllocation::Local(mut target_allocation) => {
+                if let Some(slot) = route_committed_slot {
+                    let target_cap_bytes = slot.len;
+                    if let Some(lease_id) = lease_id_opt {
+                        if let Err(e) = view
+                            .master_lease_manager()
+                            .attach_key(lease_id, key.clone(), put_id)
+                            .await
+                        {
+                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                                e.into();
+                            return MsgPack {
+                                serialize_part:
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                raw_bytes: Vec::new(),
+                            };
+                        }
+                        if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
+                            node_id.as_ref(),
+                            ReservedCapacityReason::LeaseBoundKv,
+                            target_cap_bytes as i64,
+                        ) {
+                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                                e.into();
+                            return MsgPack {
+                                serialize_part:
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                raw_bytes: Vec::new(),
+                            };
+                        }
+                    }
+                    drop(target_allocation);
+                    (
+                        target_cap_bytes,
+                        KvRouteInfo {
+                            node_id: node_id.clone(),
+                            backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                                owner_node_id: node_id.clone(),
+                                grant_id: slot.grant_id,
+                                slot_index: slot.slot_index,
+                                slot_size: slot.slot_size,
+                                addr: slot.addr,
+                                len: slot.len,
+                                base_addr: slot.base_addr,
+                            }),
+                            tomb_tag,
+                        },
+                        false,
+                    )
+                } else {
+                    let target_cap_bytes = target_allocation.capcity();
+                    if let Some(lease_id) = lease_id_opt {
+                        if let Err(e) = view
+                            .master_lease_manager()
+                            .attach_key(lease_id, key.clone(), put_id)
+                            .await
+                        {
+                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                                e.into();
+                            return MsgPack {
+                                serialize_part:
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                raw_bytes: Vec::new(),
+                            };
+                        }
+                        if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
+                            node_id.as_ref(),
+                            ReservedCapacityReason::LeaseBoundKv,
+                            target_cap_bytes as i64,
+                        ) {
+                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                                e.into();
+                            return MsgPack {
+                                serialize_part:
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                raw_bytes: Vec::new(),
+                            };
+                        }
+                        let view_clone = view.clone();
+                        let node_id_string = node_id.as_ref().to_string();
+                        target_allocation.set_on_drop(move || {
+                            if let Err(e) = view_clone
+                                .master_kv_router()
+                                .adjust_node_cache_reserved_capacity(
+                                    &node_id_string,
+                                    ReservedCapacityReason::LeaseBoundKv,
+                                    -(target_cap_bytes as i64),
+                                )
+                            {
+                                tracing::warn!(
+                                    "Failed to restore moka capacity on drop: node_id={}, bytes={}, err={}",
+                                    node_id_string,
+                                    target_cap_bytes,
+                                    e
+                                );
+                            }
+                        });
+                    }
+                    (
+                        target_cap_bytes,
+                        KvRouteInfo {
+                            node_id: node_id.clone(),
+                            backing: KvReplicaBacking::Allocation(Arc::new(target_allocation)),
+                            tomb_tag,
+                        },
+                        true,
+                    )
+                }
+            }
+            InflightPutAllocation::Remote {
+                src: _src,
+                mut target,
+            } => {
+                let target_cap_bytes = target.capcity();
+                if let Some(lease_id) = lease_id_opt {
+                    if let Err(e) = view
+                        .master_lease_manager()
+                        .attach_key(lease_id, key.clone(), put_id)
+                        .await
+                    {
+                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                            e.into();
+                        return MsgPack {
+                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                                &kv_err,
+                            ),
+                            raw_bytes: Vec::new(),
+                        };
+                    }
+                    if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
+                        node_id.as_ref(),
+                        ReservedCapacityReason::LeaseBoundKv,
+                        target_cap_bytes as i64,
+                    ) {
+                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                            e.into();
+                        return MsgPack {
+                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                                &kv_err,
+                            ),
+                            raw_bytes: Vec::new(),
+                        };
+                    }
+                    let view_clone = view.clone();
+                    let node_id_string = node_id.as_ref().to_string();
+                    target.set_on_drop(move || {
+                        if let Err(e) = view_clone
+                            .master_kv_router()
+                            .adjust_node_cache_reserved_capacity(
+                                &node_id_string,
+                                ReservedCapacityReason::LeaseBoundKv,
+                                -(target_cap_bytes as i64),
+                            )
+                        {
+                            tracing::warn!(
+                                "Failed to restore moka capacity on drop: node_id={}, bytes={}, err={}",
+                                node_id_string,
+                                target_cap_bytes,
+                                e
+                            );
+                        }
+                    });
+                }
+                (
+                    target_cap_bytes,
+                    KvRouteInfo {
+                        node_id: node_id.clone(),
+                        backing: KvReplicaBacking::Allocation(Arc::new(target)),
+                        tomb_tag,
+                    },
+                    false,
+                )
+            }
+            InflightPutAllocation::LocalCommittedSlot(slot) => {
+                let target_cap_bytes = slot.len;
+                if let Some(lease_id) = lease_id_opt {
+                    if let Err(e) = view
+                        .master_lease_manager()
+                        .attach_key(lease_id, key.clone(), put_id)
+                        .await
+                    {
+                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                            e.into();
+                        return MsgPack {
+                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                                &kv_err,
+                            ),
+                            raw_bytes: Vec::new(),
+                        };
+                    }
+                    if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
+                        node_id.as_ref(),
+                        ReservedCapacityReason::LeaseBoundKv,
+                        target_cap_bytes as i64,
+                    ) {
+                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
+                            e.into();
+                        return MsgPack {
+                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                                &kv_err,
+                            ),
+                            raw_bytes: Vec::new(),
+                        };
+                    }
+                }
+                (
+                    target_cap_bytes,
+                    KvRouteInfo {
+                        node_id: node_id.clone(),
+                        backing: KvReplicaBacking::CommittedSlot(slot),
+                        tomb_tag,
+                    },
+                    false,
+                )
+            }
+        };
+
         // NOTE on weight sizing for moka cache:
         // - moka's `weigher` returns a u32 per-entry weight while the cache's
         //   `max_capacity` and `weighted_size()` use u64. If an allocation's
@@ -562,6 +1357,54 @@ pub async fn handle_put_done(
         //   u32::MAX when `capcity()` is larger than u32::MAX. This keeps the
         //   cache accounting conservative (evicts earlier rather than later)
         //   and prevents weight=0 due to truncation.
+        local_cache_holder_id = if req.serialize_part.publish_local_cache {
+            if !local_cache_publish_supported {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "publish_local_cache requires owner-local allocation backing; key={} put_id=({},{})",
+                            key, put_id.0, put_id.1
+                        ),
+                    },
+                );
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            };
+            let KvReplicaBacking::Allocation(allocation) = &completed_info.backing else {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "publish_local_cache requires allocation backing; key={} put_id=({},{})",
+                            key, put_id.0, put_id.1
+                        ),
+                    },
+                );
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            };
+            let holder_id = view
+                .master_kv_router()
+                .inner()
+                .next_holder_id
+                .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            view.master_kv_router().inner().get_holding.insert(
+                crate::memholder::NodeHolderKey::new(node_id.to_string(), holder_id),
+                OwnerHoldingGetInfo {
+                    key: key.clone(),
+                    holding_node_id: node_id.clone(),
+                    len: allocation.size(),
+                    allocation: allocation.clone(),
+                },
+            );
+            Some(holder_id)
+        } else {
+            None
+        };
+
         let saturated_weight_u32 = if target_cap_bytes > u32::MAX as u64 {
             tracing::warn!(
                 "moka weight saturation: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
@@ -576,64 +1419,6 @@ pub async fn handle_put_done(
         };
         // Note: moka cache insertion happens after commit in a spawned task
         // using the same saturated weight; avoid unused local here.
-        // If lease is provided, attach first and fail fast on error
-        if let Some(lease_id) = lease_id_opt {
-            if let Err(e) = view
-                .master_lease_manager()
-                .attach_key(lease_id, key.clone(), put_id)
-                .await
-            {
-                let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError = e.into();
-                return MsgPack {
-                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
-                    raw_bytes: Vec::new(),
-                };
-            }
-            // Reserve cache capacity on this node for the leased allocation now (fetch_sub semantics)
-            if let Err(e) = view
-                .master_kv_router()
-                .adjust_node_cache_capacity_for_lease(node_id.as_ref(), target_cap_bytes as i64)
-            {
-                let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError = e.into();
-                return MsgPack {
-                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
-                    raw_bytes: Vec::new(),
-                };
-            }
-            // And attach an on-drop hook to restore it (fetch_add on Allocation drop)
-            let view_clone = view.clone();
-            let node_id_string = node_id.as_ref().to_string();
-            target_allocation.set_on_drop(move || {
-                match view_clone.try_adjust_node_cache_capacity_for_lease(
-                    &node_id_string,
-                    -(target_cap_bytes as i64),
-                ) {
-                    Some(Ok(())) => {}
-                    Some(Err(e)) => {
-                        tracing::warn!(
-                            "Failed to restore moka capacity on drop: node_id={}, bytes={}, err={}",
-                            node_id_string,
-                            target_cap_bytes,
-                            e
-                        );
-                    }
-                    None => {
-                        tracing::debug!(
-                            "Skipped restoring moka capacity on drop because MasterKvRouterView is gone: node_id={}, bytes={}",
-                            node_id_string,
-                            target_cap_bytes
-                        );
-                    }
-                }
-            });
-        }
-
-        let completed_info = KvRouteInfo {
-            node_id: node_id.clone(),
-            allocation: Arc::new(target_allocation),
-            tomb_tag,
-        };
-
         // Insert into kv_routes with replica support
         let mut old_one_kv_routes: Option<Arc<OneKvNodesRoutes>> = None;
         let mut inserted = false;
@@ -668,6 +1453,21 @@ pub async fn handle_put_done(
                 .insert(node_id.clone(), completed_info);
         }
 
+        if let Some(remote_append) = remote_append {
+            view.master_kv_router()
+                .inner()
+                .inflight_put_appends
+                .insert(
+                    (
+                        remote_append.key.clone(),
+                        remote_append.put_id.0,
+                        remote_append.put_id.1,
+                    ),
+                    remote_append,
+                )
+                .await;
+        }
+
         if let Some(old) = old_one_kv_routes {
             if let Err(err) = view
                 .master_kv_router()
@@ -698,10 +1498,8 @@ pub async fn handle_put_done(
                 lease_id_opt.is_none() && view.master_kv_router().replica_cache_enabled();
             // Reuse the saturated weight computed above for moka insertion
             let cap_bytes_u32 = saturated_weight_u32;
-            let _ = view.spawn("post_put_done_maintenance", async move {
-                // 1) Update the derived prefix-counting index asynchronously.
-                //    This keeps PutDone lean, but also means CountPrefix visibility
-                //    is not an immediate strong-consistency signal for this put.
+            view.spawn("post_put_done_maintenance", async move {
+                // 1) Update prefix-counting index
                 if do_prefix_index_update {
                     let inner = view_task.master_kv_router().inner();
                     let mut tree = inner.prefix_index.write().await;
@@ -761,6 +1559,295 @@ pub async fn handle_put_done(
             error_code: msg_and_error::OK,
             error_json: String::new(),
             server_process_us: 0,
+            local_cache_holder_id,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_put_start(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPutStartReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchPutStartResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        let (_put_id, resp) = handle_put_start(
+            view.clone(),
+            MsgPack {
+                serialize_part: PutStartReq {
+                    key: item.key,
+                    len: item.len,
+                    reject_if_inflight_same_key: item.reject_if_inflight_same_key,
+                    reject_if_exist_same_key: item.reject_if_exist_same_key,
+                    write_through: item.write_through,
+                    preferred_sub_cluster: item.preferred_sub_cluster,
+                    source_node_id: None,
+                },
+                raw_bytes: Vec::new(),
+            },
+            req_node_id.clone(),
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchPutStartItemResp {
+            put_id: part.put_id,
+            node_id: part.node_id,
+            target_addr: part.target_addr,
+            src_addr: part.src_addr,
+            target_base_addr: part.target_base_addr,
+            src_base_addr: part.src_base_addr,
+            len: part.len,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchPutStartResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_put_revoke(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPutRevokeReq>,
+) -> MsgPack<BatchPutRevokeResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        let key = item.key.clone();
+        let put_id = item.put_id;
+        let resp = handle_put_revoke(
+            view.clone(),
+            MsgPack {
+                serialize_part: PutRevokeReq { key, put_id },
+                raw_bytes: Vec::new(),
+            },
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchPutRevokeItemResp {
+            key: item.key,
+            put_id: item.put_id,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchPutRevokeResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_put_done(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPutDoneReq>,
+) -> MsgPack<BatchPutDoneResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        let key = item.key.clone();
+        let put_id = item.put_id;
+        let lease_id = item.lease_id;
+        let resp = handle_put_done(
+            view.clone(),
+            MsgPack {
+                serialize_part: PutDoneReq {
+                    key,
+                    put_id,
+                    lease_id,
+                    committed_slot: item.committed_slot,
+                    publish_local_cache: item.publish_local_cache,
+                },
+                raw_bytes: Vec::new(),
+            },
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchPutDoneItemResp {
+            key: item.key,
+            put_id: item.put_id,
+            error_code: part.error_code,
+            error_json: part.error_json,
+            local_cache_holder_id: part.local_cache_holder_id,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchPutDoneResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_put_append_start(
+    view: MasterKvRouterView,
+    req: MsgPack<PutAppendStartReq>,
+    req_node_id: NodeID,
+) -> MsgPack<PutAppendStartResp> {
+    let key = req.serialize_part.key.clone();
+    let put_id = req.serialize_part.put_id;
+    let current_route_still_needs_remote = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .get(&key)
+        .map(|route| current_route_needs_remote_replica(&route, &req_node_id, put_id))
+        .unwrap_or(false);
+    if !current_route_still_needs_remote {
+        let _ = view
+            .master_kv_router()
+            .inner()
+            .inflight_put_appends
+            .remove(&(key.clone(), put_id.0, put_id.1))
+            .await;
+        return MsgPack {
+            serialize_part: PutAppendStartResp {
+                scheduled: false,
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+                ..Default::default()
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+
+    let Some(inflight) = view
+        .master_kv_router()
+        .inner()
+        .inflight_put_appends
+        .get(&(key.clone(), put_id.0, put_id.1))
+        .await
+    else {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "Write-back append reservation missing: key={} put_id=({},{}) requester_node_id={}",
+                key, put_id.0, put_id.1, req_node_id
+            ),
+        });
+        let resp: PutAppendStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+        return MsgPack {
+            serialize_part: resp,
+            raw_bytes: Vec::new(),
+        };
+    };
+    let (target_base_addr, target_addr, allocation_size) = {
+        let target_allocation_guard = inflight.target_allocation.lock();
+        let Some(target_allocation): Option<&Allocation> = target_allocation_guard.as_ref() else {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "Write-back append reservation allocation missing: key={} put_id=({},{}) requester_node_id={}",
+                    key, put_id.0, put_id.1, req_node_id
+                ),
+            });
+            let resp: PutAppendStartResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            return MsgPack {
+                serialize_part: resp,
+                raw_bytes: Vec::new(),
+            };
+        };
+        let target_base_addr = target_allocation.base_addr();
+        let target_addr = target_base_addr + target_allocation.addr();
+        let allocation_size = target_allocation.size();
+        (target_base_addr, target_addr, allocation_size)
+    };
+
+    MsgPack {
+        serialize_part: PutAppendStartResp {
+            scheduled: true,
+            node_id: inflight.node_id.clone().into(),
+            target_addr,
+            target_base_addr,
+            len: allocation_size,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_put_append_revoke(
+    view: MasterKvRouterView,
+    req: MsgPack<PutAppendRevokeReq>,
+) -> MsgPack<PutAppendRevokeResp> {
+    let put_id = req.serialize_part.put_id;
+    let key = req.serialize_part.key;
+    let _ = view
+        .master_kv_router()
+        .inner()
+        .inflight_put_appends
+        .remove(&(key, put_id.0, put_id.1))
+        .await;
+    MsgPack {
+        serialize_part: PutAppendRevokeResp {
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_put_append_done(
+    view: MasterKvRouterView,
+    req: MsgPack<PutAppendDoneReq>,
+) -> MsgPack<PutAppendDoneResp> {
+    let put_id = req.serialize_part.put_id;
+    let key = req.serialize_part.key.clone();
+    let Some(inflight) = view
+        .master_kv_router()
+        .inner()
+        .inflight_put_appends
+        .remove(&(key.clone(), put_id.0, put_id.1))
+        .await
+    else {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "Put append operation not found for completion: key={} put_id=({},{})",
+                key, put_id.0, put_id.1
+            ),
+        });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    };
+    let Some(allocation) = inflight.target_allocation.lock().take() else {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "Put append target allocation already taken: key={} put_id=({},{})",
+                key, put_id.0, put_id.1
+            ),
+        });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    };
+    let appended = append_current_route_replica_if_matching(
+        &view,
+        &key,
+        inflight.put_id,
+        inflight.node_id,
+        allocation,
+    );
+    MsgPack {
+        serialize_part: PutAppendDoneResp {
+            appended,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
         },
         raw_bytes: Vec::new(),
     }
diff --git a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
index 5c20cc1..6b84528 100755
--- a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
+++ b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
@@ -22,7 +22,8 @@ async fn test1_lease_expire_removes_keys() {
     unsafe {
         std::env::set_var("FLUXON_LOG", "debug");
     }
-    let (master_fw, client_fw) = start_master_and_client("lease_master_t1", "lease_client_t1").await;
+    let (master_fw, client_fw) =
+        start_master_and_client("lease_master_t1", "lease_client_t1").await;
     let client_view = client_fw.client_kv_api_view();
     wait_master_ready(&client_view).await;
 
@@ -48,14 +49,12 @@ async fn test1_lease_expire_removes_keys() {
     tracing::info!("[test1-verify-present-during-ttl] verifying keys exist within TTL window");
     for _ in 0..3 {
         for k in &keys {
-            assert!(
-                client_view
-                    .client_kv_api()
-                    .inner()
-                    .is_exist(k)
-                    .await
-                    .unwrap()
-            );
+            assert!(client_view
+                .client_kv_api()
+                .inner()
+                .is_exist(k)
+                .await
+                .unwrap());
         }
         sleep(Duration::from_millis(500)).await;
     }
@@ -82,7 +81,8 @@ async fn test2_rebind_to_new_lease_preserves_until_new_expire() {
     unsafe {
         std::env::set_var("FLUXON_LOG", "debug");
     }
-    let (master_fw, client_fw) = start_master_and_client("lease_master_t2", "lease_client_t2").await;
+    let (master_fw, client_fw) =
+        start_master_and_client("lease_master_t2", "lease_client_t2").await;
     let client_view = client_fw.client_kv_api_view();
     wait_master_ready(&client_view).await;
 
@@ -120,14 +120,12 @@ async fn test2_rebind_to_new_lease_preserves_until_new_expire() {
     // After l1 expiry, keys should still exist due to l2
     sleep(Duration::from_secs(3)).await;
     for k in &keys {
-        assert!(
-            client_view
-                .client_kv_api()
-                .inner()
-                .is_exist(k)
-                .await
-                .unwrap()
-        );
+        assert!(client_view
+            .client_kv_api()
+            .inner()
+            .is_exist(k)
+            .await
+            .unwrap());
     }
     tracing::info!(
         "[test2-verify-still-present-after-first-expire] keys still exist after first lease expired, held by second lease"
@@ -161,7 +159,8 @@ async fn test3_keepalive() {
     unsafe {
         std::env::set_var("FLUXON_LOG", "debug");
     }
-    let (master_fw, client_fw) = start_master_and_client("lease_master_t3", "lease_client_t3").await;
+    let (master_fw, client_fw) =
+        start_master_and_client("lease_master_t3", "lease_client_t3").await;
     let client_view = client_fw.client_kv_api_view();
     wait_master_ready(&client_view).await;
 
@@ -193,14 +192,12 @@ async fn test3_keepalive() {
             .await
             .unwrap();
         for k in &keys {
-            assert!(
-                client_view
-                    .client_kv_api()
-                    .inner()
-                    .is_exist(k)
-                    .await
-                    .unwrap()
-            );
+            assert!(client_view
+                .client_kv_api()
+                .inner()
+                .is_exist(k)
+                .await
+                .unwrap());
         }
         if i % 2 == 0 {
             tracing::info!(
@@ -214,14 +211,12 @@ async fn test3_keepalive() {
     // Stop keepalive, wait beyond TTL
     sleep(Duration::from_secs(3)).await;
     for k in &keys {
-        assert!(
-            !client_view
-                .client_kv_api()
-                .inner()
-                .is_exist(k)
-                .await
-                .unwrap()
-        );
+        assert!(!client_view
+            .client_kv_api()
+            .inner()
+            .is_exist(k)
+            .await
+            .unwrap());
     }
     tracing::info!(
         "[test3-stop-keepalive-wait-verify-missing] verified keys removed after stopping keepalive and waiting past TTL"
@@ -236,7 +231,8 @@ async fn test4_delete_under_lease_then_get_fails() {
     unsafe {
         std::env::set_var("FLUXON_LOG", "debug");
     }
-    let (master_fw, client_fw) = start_master_and_client("lease_master_t4", "lease_client_t4").await;
+    let (master_fw, client_fw) =
+        start_master_and_client("lease_master_t4", "lease_client_t4").await;
     let client_view = client_fw.client_kv_api_view();
     wait_master_ready(&client_view).await;
 
@@ -263,14 +259,12 @@ async fn test4_delete_under_lease_then_get_fails() {
     }
     sleep(Duration::from_secs(2)).await;
     for k in &keys {
-        assert!(
-            !client_view
-                .client_kv_api()
-                .inner()
-                .is_exist(k)
-                .await
-                .unwrap()
-        );
+        assert!(!client_view
+            .client_kv_api()
+            .inner()
+            .is_exist(k)
+            .await
+            .unwrap());
     }
     tracing::info!(
         "[test4-delete-keys-sleep-2s-verify-missing] deleted keys and verified not exist after delay"
diff --git a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
index ad23b4d..1ea35eb 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
@@ -1,5 +1,7 @@
 use super::DeleteTargetMember;
-use crate::client_kv_api::msg_pack::ExternalInvalidateWeakIndexReq;
+use crate::client_kv_api::msg_pack::{
+    ExternalInvalidateWeakIndexItem, ExternalInvalidateWeakIndexReq,
+};
 use crate::client_kv_api::{ClientKvApiView, ClientKvApiViewTrait, ExternalHoldingGetInfo};
 use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::external_client_api::{ExternalClientApiView, ExternalClientApiViewTrait};
@@ -786,18 +788,24 @@ impl MemholderManagerTrait for OwnerExternalMemMgr {
         target: Self::DeleteTarget,
         tasks: Vec<Self::DeleteTask>,
     ) -> Result<(), String> {
-        let mut keys: Vec<String> = tasks.into_iter().map(|task| task.key).collect();
-        keys.sort();
-        keys.dedup();
-
-        if keys.is_empty() {
+        let mut items: Vec<ExternalInvalidateWeakIndexItem> = tasks
+            .into_iter()
+            .map(|task| ExternalInvalidateWeakIndexItem { key: task.key })
+            .collect();
+        items.sort_by(|a, b| a.key.cmp(&b.key));
+        items.dedup_by(|a, b| a.key == b.key);
+
+        if items.is_empty() {
             return Ok(());
         }
 
         let rpc_caller = RPCCaller::<ExternalInvalidateWeakIndexReq>::new();
         rpc_caller.regist(ctx.p2p_module());
         let req = MsgPack {
-            serialize_part: ExternalInvalidateWeakIndexReq { keys },
+            serialize_part: ExternalInvalidateWeakIndexReq {
+                keys: Vec::new(),
+                items,
+            },
             raw_bytes: Vec::new(),
         };
 
diff --git a/fluxon_rs/fluxon_kv/src/memholder/mod.rs b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
index db0ada2..37f2d81 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
@@ -24,6 +24,16 @@ use crate::{cluster_manager::NodeID, external_client_api::ExternalClientApiView}
 
 use bitcode::{Decode, Encode};
 
+#[derive(Clone, Debug)]
+pub enum MemoryInfoDropAction {
+    OwnerDeleteAck,
+    ReleaseLocalReserveResidentSlot {
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    },
+}
+
 /// Memory metadata for owner/client user holders
 #[derive(Clone)]
 pub struct MemoryInfo {
@@ -35,6 +45,7 @@ pub struct MemoryInfo {
     pub key: String,
     pub master_node_id: NodeID,
     pub view: ClientKvApiView,
+    pub drop_action: MemoryInfoDropAction,
 }
 
 impl std::fmt::Debug for MemoryInfo {
@@ -46,6 +57,7 @@ impl std::fmt::Debug for MemoryInfo {
             .field("holder_id", &self.holder_id)
             .field("key", &self.key)
             .field("master_node_id", &self.master_node_id)
+            .field("drop_action", &self.drop_action)
             .finish()
     }
 }
@@ -159,8 +171,50 @@ impl MemoryInfo {
             key,
             master_node_id,
             view,
+            drop_action: MemoryInfoDropAction::OwnerDeleteAck,
+        }
+    }
+
+    pub async fn new_local_reserve_resident(
+        addr: u64,
+        len: u32,
+        key: String,
+        master_node_id: NodeID,
+        view: ClientKvApiView,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> Self {
+        let base_addr = {
+            let base_guard = view
+                .client_seg_pool()
+                .cpu_mem_read_guard()
+                .await
+                .expect("segment cpu mem must be available when creating resident MemoryInfo");
+            base_guard.allocated_addr
+        };
+        assert!(
+            addr >= base_addr,
+            "resident local reserve addr must be within client segment: addr={:#x} base_addr={:#x}",
+            addr,
+            base_addr
+        );
+        Self {
+            offset: addr - base_addr,
+            addr,
+            len,
+            holder_id: 0,
+            key,
+            master_node_id,
+            view,
+            drop_action: MemoryInfoDropAction::ReleaseLocalReserveResidentSlot {
+                slot_size,
+                grant_id,
+                slot_index,
+            },
         }
     }
+
     pub fn bytes(&self) -> &[u8] {
         tracing::debug!(
             "MemHolder accessing memory: addr={:#x}, len={}",
@@ -169,16 +223,62 @@ impl MemoryInfo {
         );
         unsafe { std::slice::from_raw_parts(self.addr as *const u8, self.len as usize) }
     }
+
+    pub fn local_reserve_resident_slot_ref(&self) -> Option<(u64, u64, u32)> {
+        match self.drop_action {
+            MemoryInfoDropAction::ReleaseLocalReserveResidentSlot {
+                slot_size,
+                grant_id,
+                slot_index,
+            } => Some((slot_size, grant_id, slot_index)),
+            MemoryInfoDropAction::OwnerDeleteAck => None,
+        }
+    }
 }
+
 /// Represents a memory holder that keeps a reference to transferred data
 impl Drop for MemoryInfo {
     fn drop(&mut self) {
-        let ctx = OwnerDeleteAckCtx {
-            view: self.view.clone(),
-            key: self.key.clone(),
-            holder_id: self.holder_id,
-        };
-        ctx.run_drop_ack();
+        match &self.drop_action {
+            MemoryInfoDropAction::OwnerDeleteAck => {
+                let ctx = OwnerDeleteAckCtx {
+                    view: self.view.clone(),
+                    key: self.key.clone(),
+                    holder_id: self.holder_id,
+                };
+                ctx.run_drop_ack();
+            }
+            MemoryInfoDropAction::ReleaseLocalReserveResidentSlot {
+                slot_size,
+                grant_id,
+                slot_index,
+            } => {
+                let spawn_view = self.view.clone();
+                let release_view = self.view.clone();
+                let key = self.key.clone();
+                let slot_size = *slot_size;
+                let grant_id = *grant_id;
+                let slot_index = *slot_index;
+                let _ = spawn_view.spawn("resident_local_reserve_slot_release", async move {
+                    if let Err(err) = release_view
+                        .client_kv_api()
+                        .inner()
+                        .owner_release_local_reserve_resident_slot_holder(
+                            slot_size, grant_id, slot_index,
+                        )
+                    {
+                        tracing::warn!(
+                            "failed to release resident local reserve slot holder on MemoryInfo drop: key={} slot_size={} grant_id={} slot_index={} err={}",
+                            key,
+                            slot_size,
+                            grant_id,
+                            slot_index,
+                            err
+                        );
+                    }
+                });
+            }
+        }
     }
 }
 
diff --git a/fluxon_rs/fluxon_kv/src/metrics.rs b/fluxon_rs/fluxon_kv/src/metrics.rs
index 88f1b9c..4f5d88e 100644
--- a/fluxon_rs/fluxon_kv/src/metrics.rs
+++ b/fluxon_rs/fluxon_kv/src/metrics.rs
@@ -26,6 +26,8 @@ pub struct MetricsHandle {
 
     // Pending put stats captured at put_start to attribute external-owner path at put_end.
     pending_put_stats: DashMap<PutIDForAKey, PendingPutStat>,
+
+    locality_counters: KvLocalityCounters,
 }
 
 #[derive(Clone, Debug)]
@@ -43,6 +45,7 @@ pub struct PendingPutStat {
     pub transfer_poll_wait_us: i64,
     pub transfer_poll_iters: i64,
     pub transfer_used_fast_path: bool,
+    pub transfer_used_nixl: bool,
     pub transfer_local_noop: bool,
     pub transfer_remote_transfer: bool,
     pub top_emitted: bool,
@@ -54,6 +57,85 @@ pub enum OperationKind {
     Get,
 }
 
+#[derive(Clone, Debug, Default)]
+pub struct KvIoLocalitySnapshot {
+    pub op_count: u64,
+    pub bytes: u64,
+    pub transfer_us: u64,
+}
+
+impl KvIoLocalitySnapshot {
+    pub fn bandwidth_gbps(&self) -> f64 {
+        if self.transfer_us == 0 {
+            return 0.0;
+        }
+        (self.bytes as f64) / (self.transfer_us as f64 / 1_000_000.0) / 1_000_000_000.0
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct KvLocalitySnapshot {
+    pub l2_local_hit_pages: u64,
+    pub l2_local_hit_bytes: u64,
+    pub l2_remote_hit_pages: u64,
+    pub l2_remote_hit_bytes: u64,
+    pub put_local: KvIoLocalitySnapshot,
+    pub put_remote: KvIoLocalitySnapshot,
+    pub get_local: KvIoLocalitySnapshot,
+    pub get_remote: KvIoLocalitySnapshot,
+}
+
+#[derive(Default)]
+struct KvLocalityCounters {
+    l2_local_hit_pages: AtomicU64,
+    l2_local_hit_bytes: AtomicU64,
+    l2_remote_hit_pages: AtomicU64,
+    l2_remote_hit_bytes: AtomicU64,
+    put_local_ops: AtomicU64,
+    put_local_bytes: AtomicU64,
+    put_local_transfer_us: AtomicU64,
+    put_remote_ops: AtomicU64,
+    put_remote_bytes: AtomicU64,
+    put_remote_transfer_us: AtomicU64,
+    get_local_ops: AtomicU64,
+    get_local_bytes: AtomicU64,
+    get_local_transfer_us: AtomicU64,
+    get_remote_ops: AtomicU64,
+    get_remote_bytes: AtomicU64,
+    get_remote_transfer_us: AtomicU64,
+}
+
+impl KvLocalityCounters {
+    fn snapshot(&self) -> KvLocalitySnapshot {
+        KvLocalitySnapshot {
+            l2_local_hit_pages: self.l2_local_hit_pages.load(Ordering::Relaxed),
+            l2_local_hit_bytes: self.l2_local_hit_bytes.load(Ordering::Relaxed),
+            l2_remote_hit_pages: self.l2_remote_hit_pages.load(Ordering::Relaxed),
+            l2_remote_hit_bytes: self.l2_remote_hit_bytes.load(Ordering::Relaxed),
+            put_local: KvIoLocalitySnapshot {
+                op_count: self.put_local_ops.load(Ordering::Relaxed),
+                bytes: self.put_local_bytes.load(Ordering::Relaxed),
+                transfer_us: self.put_local_transfer_us.load(Ordering::Relaxed),
+            },
+            put_remote: KvIoLocalitySnapshot {
+                op_count: self.put_remote_ops.load(Ordering::Relaxed),
+                bytes: self.put_remote_bytes.load(Ordering::Relaxed),
+                transfer_us: self.put_remote_transfer_us.load(Ordering::Relaxed),
+            },
+            get_local: KvIoLocalitySnapshot {
+                op_count: self.get_local_ops.load(Ordering::Relaxed),
+                bytes: self.get_local_bytes.load(Ordering::Relaxed),
+                transfer_us: self.get_local_transfer_us.load(Ordering::Relaxed),
+            },
+            get_remote: KvIoLocalitySnapshot {
+                op_count: self.get_remote_ops.load(Ordering::Relaxed),
+                bytes: self.get_remote_bytes.load(Ordering::Relaxed),
+                transfer_us: self.get_remote_transfer_us.load(Ordering::Relaxed),
+            },
+        }
+    }
+}
+
 impl OperationKind {
     pub const fn as_label(self) -> &'static str {
         match self {
@@ -147,6 +229,7 @@ impl MetricsHandle {
             get_metrics_queue: SegQueue::new(),
             latest_metrics_snapshot: RwLock::new(HashMap::new()),
             pending_put_stats: DashMap::new(),
+            locality_counters: KvLocalityCounters::default(),
         }
     }
 
@@ -184,6 +267,78 @@ impl MetricsHandle {
         }
     }
 
+    pub fn get_locality_snapshot(&self) -> KvLocalitySnapshot {
+        self.locality_counters.snapshot()
+    }
+
+    pub fn record_l2_hit_locality(&self, remote: bool, bytes: u64) {
+        if remote {
+            self.locality_counters
+                .l2_remote_hit_pages
+                .fetch_add(1, Ordering::Relaxed);
+            self.locality_counters
+                .l2_remote_hit_bytes
+                .fetch_add(bytes, Ordering::Relaxed);
+        } else {
+            self.locality_counters
+                .l2_local_hit_pages
+                .fetch_add(1, Ordering::Relaxed);
+            self.locality_counters
+                .l2_local_hit_bytes
+                .fetch_add(bytes, Ordering::Relaxed);
+        }
+    }
+
+    pub fn record_put_io_locality(&self, remote: bool, bytes: u64, transfer_us: i64) {
+        let transfer_us = transfer_us.max(0) as u64;
+        if remote {
+            self.locality_counters
+                .put_remote_ops
+                .fetch_add(1, Ordering::Relaxed);
+            self.locality_counters
+                .put_remote_bytes
+                .fetch_add(bytes, Ordering::Relaxed);
+            self.locality_counters
+                .put_remote_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        } else {
+            self.locality_counters
+                .put_local_ops
+                .fetch_add(1, Ordering::Relaxed);
+            self.locality_counters
+                .put_local_bytes
+                .fetch_add(bytes, Ordering::Relaxed);
+            self.locality_counters
+                .put_local_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        }
+    }
+
+    pub fn record_get_io_locality(&self, remote: bool, bytes: u64, transfer_us: i64) {
+        let transfer_us = transfer_us.max(0) as u64;
+        if remote {
+            self.locality_counters
+                .get_remote_ops
+                .fetch_add(1, Ordering::Relaxed);
+            self.locality_counters
+                .get_remote_bytes
+                .fetch_add(bytes, Ordering::Relaxed);
+            self.locality_counters
+                .get_remote_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        } else {
+            self.locality_counters
+                .get_local_ops
+                .fetch_add(1, Ordering::Relaxed);
+            self.locality_counters
+                .get_local_bytes
+                .fetch_add(bytes, Ordering::Relaxed);
+            self.locality_counters
+                .get_local_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        }
+    }
+
     pub fn emit_op_end_bytes_pulse(
         &self,
         op: OperationKind,
@@ -252,6 +407,39 @@ impl MetricsHandle {
         });
     }
 
+    pub fn set_kv_holding_entries(&self, scope: &str, entries: u64) {
+        let _ = (scope, entries);
+    }
+
+    pub fn set_kv_holding_bytes(&self, scope: &str, bytes: u64) {
+        let _ = (scope, bytes);
+    }
+
+    pub fn set_kv_external_pending_put_entries(&self, entries: u64) {
+        let _ = entries;
+    }
+
+    pub fn set_kv_replica_cache_entries(&self, owner_node: &str, entries: u64) {
+        let _ = (owner_node, entries);
+    }
+
+    pub fn set_kv_replica_cache_weighted_bytes(&self, owner_node: &str, bytes: u64) {
+        let _ = (owner_node, bytes);
+    }
+
+    pub fn set_kv_replica_cache_capacity_bytes(
+        &self,
+        owner_node: &str,
+        capacity_kind: &str,
+        bytes: u64,
+    ) {
+        let _ = (owner_node, capacity_kind, bytes);
+    }
+
+    pub fn inc_kv_get_done_allocation(&self, allocation_mode: &str) {
+        let _ = allocation_mode;
+    }
+
     pub fn set_fs_mount_fs_bytes(
         &self,
         mount_kind: FsMountKind,
@@ -333,6 +521,7 @@ impl MetricsHandle {
             transfer_poll_wait_us,
             transfer_poll_iters,
             transfer_used_fast_path,
+            transfer_used_nixl,
             transfer_local_noop,
             transfer_remote_transfer,
         } = &metric
@@ -356,7 +545,7 @@ impl MetricsHandle {
 
             if let Some(seq) = sampled_debug_seq(&PUT_METRIC_SUBMIT_SEQ) {
                 tracing::debug!(
-                    "submit kv op metric seq={} kind=put put_id={} key={} whole_us={} start_us={} transfer_us={} end_us={} rpc_us={} start_handle_us={} end_handle_us={} t1_us={} t2_us={} t3_us={} t4_us={} transfer_submit_blocking_us={} transfer_create_xfer_req_us={} transfer_post_xfer_req_us={} transfer_poll_wait_us={} transfer_poll_iters={} transfer_used_fast_path={} transfer_local_noop={} transfer_remote_transfer={}",
+                    "submit kv op metric seq={} kind=put put_id={} key={} whole_us={} start_us={} transfer_us={} end_us={} rpc_us={} start_handle_us={} end_handle_us={} t1_us={} t2_us={} t3_us={} t4_us={} transfer_submit_blocking_us={} transfer_create_xfer_req_us={} transfer_post_xfer_req_us={} transfer_poll_wait_us={} transfer_poll_iters={} transfer_used_fast_path={} transfer_used_nixl={} transfer_local_noop={} transfer_remote_transfer={}",
                     seq,
                     put_id,
                     sanitize_key(key),
@@ -377,6 +566,7 @@ impl MetricsHandle {
                     transfer_poll_wait_us,
                     transfer_poll_iters,
                     transfer_used_fast_path,
+                    transfer_used_nixl,
                     transfer_local_noop,
                     transfer_remote_transfer
                 );
@@ -537,6 +727,7 @@ impl MetricsHandle {
                 transfer_poll_wait_us: 0,
                 transfer_poll_iters: 0,
                 transfer_used_fast_path: false,
+                transfer_used_nixl: false,
                 transfer_local_noop: false,
                 transfer_remote_transfer: false,
                 top_emitted: false,
@@ -580,6 +771,7 @@ impl MetricsHandle {
         transfer_poll_wait_us: i64,
         transfer_poll_iters: i64,
         transfer_used_fast_path: bool,
+        transfer_used_nixl: bool,
         transfer_local_noop: bool,
         transfer_remote_transfer: bool,
     ) {
@@ -593,6 +785,7 @@ impl MetricsHandle {
             guard.transfer_poll_wait_us = transfer_poll_wait_us;
             guard.transfer_poll_iters = transfer_poll_iters;
             guard.transfer_used_fast_path = transfer_used_fast_path;
+            guard.transfer_used_nixl = transfer_used_nixl;
             guard.transfer_local_noop = transfer_local_noop;
             guard.transfer_remote_transfer = transfer_remote_transfer;
         }
diff --git a/fluxon_rs/fluxon_kv/src/observe_kvope.rs b/fluxon_rs/fluxon_kv/src/observe_kvope.rs
index 69c724d..d67ec67 100755
--- a/fluxon_rs/fluxon_kv/src/observe_kvope.rs
+++ b/fluxon_rs/fluxon_kv/src/observe_kvope.rs
@@ -245,6 +245,7 @@ pub fn obe_put_done_success(
         transfer_poll_wait_us,
         transfer_poll_iters,
         transfer_used_fast_path,
+        transfer_used_nixl: false,
         transfer_local_noop,
         transfer_remote_transfer,
     });
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
index 42a9cbc..75fe736 100644
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
@@ -43,6 +43,34 @@ pub enum MsgId {
     CountPrefixResp = 3026,
     GetMasterOnlyMetricPartReq = 3027,
     GetMasterOnlyMetricPartResp = 3028,
+    BatchIsExistReq = 3031,
+    BatchIsExistResp = 3032,
+    PutAppendStartReq = 3033,
+    PutAppendStartResp = 3034,
+    PutAppendRevokeReq = 3035,
+    PutAppendRevokeResp = 3036,
+    PutAppendDoneReq = 3037,
+    PutAppendDoneResp = 3038,
+    BatchPutStartReq = 3039,
+    BatchPutStartResp = 3040,
+    BatchPutRevokeReq = 3041,
+    BatchPutRevokeResp = 3042,
+    BatchPutDoneReq = 3043,
+    BatchPutDoneResp = 3044,
+    BatchGetStartReq = 3045,
+    BatchGetStartResp = 3046,
+    BatchGetRevokeReq = 3047,
+    BatchGetRevokeResp = 3048,
+    BatchGetDoneReq = 3049,
+    BatchGetDoneResp = 3050,
+    ReserveLocalGrantReq = 3051,
+    ReserveLocalGrantResp = 3052,
+    ReleaseLocalGrantReq = 3053,
+    ReleaseLocalGrantResp = 3054,
+    BatchPreparePutKeysReq = 3055,
+    BatchPreparePutKeysResp = 3056,
+    BatchReleasePutKeyReservationsReq = 3057,
+    BatchReleasePutKeyReservationsResp = 3058,
     ExternalGetReq = 4001,
     ExternalGetResp = 4002,
     ExternalPutStartReq = 4003,
@@ -51,6 +79,8 @@ pub enum MsgId {
     ExternalPutTransferEndResp = 4006,
     ExternalDeleteReq = 4009,
     ExternalDeleteResp = 4010,
+    ExternalBatchIsExistReq = 4015,
+    ExternalBatchIsExistResp = 4016,
     AllocateClientLeaseReq = 5001,
     AllocateClientLeaseResp = 5002,
     ClientLeaseKeepaliveReq = 5003,
@@ -704,6 +734,9 @@ crate::define_err_group! {
         ,
         (122, KeyBeingWritten { key: String },
             msg: "Key is currently being written: key={key}")
+        ,
+        (123, KeyAlreadyExists { key: String },
+            msg: "Key already exists: key={key}")
     }
 }
 
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs
index b6eb7d6..30ee572 100755
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs
@@ -1,13 +1,23 @@
 use super::msg_and_error::OK;
-use super::msg_and_error::{ErrorCode, KvError, KvResult};
+use super::msg_and_error::{
+    ApiError, ConfigError, ErrorCode, KvError, KvResult, SharedMemError, UnreachableError,
+};
 use crate::client_kv_api::msg_pack::{
-    ExternalDeleteAckResp, ExternalDeleteResp, ExternalGetResp, ExternalIsExistResp,
-    ExternalPutCommitResp, ExternalPutRevokeResp, ExternalPutStartResp, ExternalPutTransferEndResp,
+    ExternalBatchGetCancelResp, ExternalBatchGetItemResp, ExternalBatchGetResp,
+    ExternalBatchGetStartResp, ExternalBatchGetTransferResp, ExternalBatchIsExistResp,
+    ExternalBatchPutCommitItemResp, ExternalBatchPutCommitResp, ExternalBatchPutStartItemResp,
+    ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemResp,
+    ExternalBatchPutTransferEndResp, ExternalDeleteAckResp, ExternalDeleteResp, ExternalGetResp,
+    ExternalIsExistResp, ExternalObservabilitySnapshotResp, ExternalPutCommitResp,
+    ExternalPutRevokeResp, ExternalPutStartResp, ExternalPutTransferEndResp,
 };
 use crate::master_kv_router::msg_pack::{
-    BatchDeleteAckResp, BatchDeleteClientKvMetaCacheResp, DeleteAckResp, DeleteResp, GetDoneResp,
-    GetMasterOnlyMetricPartResp, GetMetaResp, GetRevokeResp, GetStartResp, MemHolderKeepAliveResp,
-    MemHolderReleaseResp, PutDoneResp, PutRevokeResp, PutStartResp,
+    BatchDeleteAckResp, BatchDeleteClientKvMetaCacheResp, BatchIsExistResp,
+    BatchPreparePutKeysResp, BatchReleasePutKeyReservationsResp, DeleteAckResp, DeleteResp,
+    GetDoneResp, GetMasterOnlyMetricPartResp, GetMetaResp, GetRevokeResp, GetStartResp,
+    MemHolderKeepAliveResp, MemHolderReleaseResp, PutAppendDoneResp, PutAppendRevokeResp,
+    PutAppendStartResp, PutDoneResp, PutRevokeResp, PutStartResp, ReleaseLocalGrantResp,
+    ReserveLocalGrantResp,
 };
 use crate::master_seg_manager::msg_pack::RequestSegmentRegistrationResp;
 use crate::memholder::ExternalMemHolderInfo;
@@ -58,6 +68,16 @@ impl ToResult for ExternalIsExistResp {
     }
 }
 
+impl ToResult for ExternalBatchIsExistResp {
+    type Ok = Vec<bool>;
+    fn to_result(self) -> KvResult<Self::Ok> {
+        if self.error_code == OK {
+            return Ok(self.exists_list);
+        }
+        Err(KvError::from_json(self.error_code, &self.error_json))
+    }
+}
+
 /// Convert ExternalDeleteResp into KvResult<()>
 impl ToResult for ExternalDeleteResp {
     type Ok = ();
@@ -131,6 +151,16 @@ impl ToResult for ExternalDeleteAckResp {
     }
 }
 
+impl ToResult for BatchIsExistResp {
+    type Ok = Vec<bool>;
+    fn to_result(self) -> KvResult<Self::Ok> {
+        if self.error_code == OK {
+            return Ok(self.exists_list);
+        }
+        Err(KvError::from_json(self.error_code, &self.error_json))
+    }
+}
+
 /// Centralized: convert code+desc to KvError or Ok if code==Ok
 pub fn try_from_code(code: ErrorCode, json: String) -> KvResult<()> {
     if code == OK {
@@ -222,6 +252,135 @@ impl FromError for ExternalIsExistResp {
         }
     }
 }
+impl FromError for ExternalBatchIsExistResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchGetResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchGetItemResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchGetStartResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchGetTransferResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchGetCancelResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+        }
+    }
+}
+impl FromError for ExternalBatchPutStartResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchPutStartItemResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchPutTransferEndResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchPutTransferEndItemResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchPutCommitResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalBatchPutCommitItemResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ExternalObservabilitySnapshotResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
 impl FromError for ExternalDeleteAckResp {
     fn from_error(e: &KvError) -> Self {
         let code = e.code();
@@ -294,6 +453,76 @@ impl FromError for PutDoneResp {
         }
     }
 }
+impl FromError for ReserveLocalGrantResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for ReleaseLocalGrantResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for BatchPreparePutKeysResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for BatchReleasePutKeyReservationsResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for PutAppendStartResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for PutAppendRevokeResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
+impl FromError for PutAppendDoneResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
 impl FromError for MemHolderKeepAliveResp {
     fn from_error(e: &KvError) -> Self {
         let code = e.code();
@@ -354,6 +583,16 @@ impl FromError for GetMetaResp {
         }
     }
 }
+impl FromError for BatchIsExistResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
 impl FromError for BatchDeleteClientKvMetaCacheResp {
     fn from_error(e: &KvError) -> Self {
         let code = e.code();
diff --git a/fluxon_rs/fluxon_ops/build.rs b/fluxon_rs/fluxon_ops/build.rs
index 585fbfc..51e95c4 100644
--- a/fluxon_rs/fluxon_ops/build.rs
+++ b/fluxon_rs/fluxon_ops/build.rs
@@ -59,9 +59,17 @@ print(
 }
 
 fn render_log_shard_helper(repo_root: &Path) -> String {
-    let helper_path = repo_root.join("deployment").join("utils").join("log_shard.py");
-    fs::read_to_string(&helper_path)
-        .unwrap_or_else(|e| panic!("read log shard helper failed: {} ({})", helper_path.display(), e))
+    let helper_path = repo_root
+        .join("deployment")
+        .join("utils")
+        .join("log_shard.py");
+    fs::read_to_string(&helper_path).unwrap_or_else(|e| {
+        panic!(
+            "read log shard helper failed: {} ({})",
+            helper_path.display(),
+            e
+        )
+    })
 }
 
 fn main() {
@@ -87,6 +95,10 @@ fn main() {
     );
     println!(
         "cargo:rerun-if-changed={}",
-        repo_root.join("deployment").join("utils").join("log_shard.py").display()
+        repo_root
+            .join("deployment")
+            .join("utils")
+            .join("log_shard.py")
+            .display()
     );
 }
diff --git a/fluxon_rs/fluxon_ops/src/lib.rs b/fluxon_rs/fluxon_ops/src/lib.rs
index 29d9434..3adb053 100644
--- a/fluxon_rs/fluxon_ops/src/lib.rs
+++ b/fluxon_rs/fluxon_ops/src/lib.rs
@@ -80,7 +80,8 @@ const DELETE_APPLY_NO_WAIT_DELAY_SECONDS: u64 = 30;
 
 const EMBEDDED_SELECTION_SUPERVISOR_SOURCE: &str =
     include_str!(concat!(env!("OUT_DIR"), "/selection_supervisor.py"));
-const EMBEDDED_LOG_SHARD_HELPER_SOURCE: &str = include_str!(concat!(env!("OUT_DIR"), "/log_shard.py"));
+const EMBEDDED_LOG_SHARD_HELPER_SOURCE: &str =
+    include_str!(concat!(env!("OUT_DIR"), "/log_shard.py"));
 
 // Ops controller uses Fluxon user-RPC to talk to ops agents.
 // Keep the timeout as a fixed constant to avoid config surface area.
@@ -351,7 +352,10 @@ fn workload_log_latest_shard_identity(logical_path: &Path) -> anyhow::Result<Opt
     let Some(path) = resolve_readable_log_path(logical_path) else {
         return Ok(None);
     };
-    Ok(Some(workload_log_shard_identity_from_path(logical_path, &path)?))
+    Ok(Some(workload_log_shard_identity_from_path(
+        logical_path,
+        &path,
+    )?))
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
@@ -1110,7 +1114,9 @@ fn resolve_python_host_executable(python_exe: &Path) -> anyhow::Result<PathBuf>
     Ok(resolved)
 }
 
-fn ensure_embedded_selection_supervisor_runtime(workdir: &Path) -> anyhow::Result<(PathBuf, PathBuf)> {
+fn ensure_embedded_selection_supervisor_runtime(
+    workdir: &Path,
+) -> anyhow::Result<(PathBuf, PathBuf)> {
     let runtime_dir = workdir.join(OPS_SELECTION_SUPERVISOR_DIR_NAME);
     std::fs::create_dir_all(&runtime_dir).with_context(|| {
         format!(
@@ -1657,10 +1663,11 @@ fn selection_owner_supervisor(
     scope_key: Option<&str>,
     exclude_pid: Option<u32>,
 ) -> anyhow::Result<Option<LiveSelectionSupervisor>> {
-    let owners: Vec<LiveSelectionSupervisor> = live_selection_supervisors(snapshot, Some(label), scope_key)?
-        .into_iter()
-        .filter(|supervisor| exclude_pid != Some(supervisor.pid()))
-        .collect();
+    let owners: Vec<LiveSelectionSupervisor> =
+        live_selection_supervisors(snapshot, Some(label), scope_key)?
+            .into_iter()
+            .filter(|supervisor| exclude_pid != Some(supervisor.pid()))
+            .collect();
     if owners.is_empty() {
         return Ok(None);
     }
@@ -2068,7 +2075,16 @@ fn wait_for_selection_attached(
     argv: &[String],
     cwd: Option<&str>,
 ) -> anyhow::Result<SelectionSupervisorStatus> {
-    wait_for_selection_attached_for_scope(kind, name, authority, None, apply_id, owner_ts_ms, argv, cwd)
+    wait_for_selection_attached_for_scope(
+        kind,
+        name,
+        authority,
+        None,
+        apply_id,
+        owner_ts_ms,
+        argv,
+        cwd,
+    )
 }
 
 fn wait_for_selection_attached_without_present_for_scope(
@@ -2803,10 +2819,9 @@ impl SupervisorBackedWorkloads {
     fn list_workloads(&self) -> anyhow::Result<Vec<WorkloadStatusSummary>> {
         let mut out: Vec<WorkloadStatusSummary> = Vec::new();
         let snapshot = selection_supervisor_proc_snapshot()?;
-        for status in observe_all_selection_statuses_for_snapshot(
-            &snapshot,
-            Some(self.scope_key.as_str()),
-        )? {
+        for status in
+            observe_all_selection_statuses_for_snapshot(&snapshot, Some(self.scope_key.as_str()))?
+        {
             let kind = status.kind.with_context(|| {
                 format!(
                     "selection supervisor list item missing kind: label={}",
@@ -3159,7 +3174,10 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
             None => {
                 let Some(path) = resolve_readable_log_path(&logical_path) else {
                     let resp = make_err_resp(
-                        format!("log file is not available yet: logical_path={}", logical_path.display()),
+                        format!(
+                            "log file is not available yet: logical_path={}",
+                            logical_path.display()
+                        ),
                         None,
                     );
                     return Ok(serde_json::to_vec(&resp).unwrap());
@@ -3186,138 +3204,11 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
         };
 
         let file_size = meta.len();
-        let (start, end, start_cursor, end_cursor, effective_path, effective_file_size) =
-            match req.direction {
-                LogReadDirection::Forward => {
-                    if let Some(cursor) = req.cursor.as_ref() {
-                        if cursor.offset > file_size {
-                            let resp = make_err_resp(
-                                format!(
-                                    "cursor out of range: shard={} cursor={} file_size={}",
-                                    cursor.shard, cursor.offset, file_size
-                                ),
-                                Some(file_size),
-                            );
-                            return Ok(serde_json::to_vec(&resp).unwrap());
-                        }
-                        let mut effective_path = path.clone();
-                        let mut effective_shard = shard.clone();
-                        let mut effective_file_size = file_size;
-                        let mut start = cursor.offset;
-                        if cursor.offset == file_size {
-                            if let Ok(Some(next_shard)) =
-                                workload_log_next_shard(&logical_path, &cursor.shard)
-                            {
-                                let next_path = match workload_log_path_for_shard(&logical_path, &next_shard) {
-                                    Ok(v) => v,
-                                    Err(e) => {
-                                        let resp = make_err_resp(format!("{}", e), Some(file_size));
-                                        return Ok(serde_json::to_vec(&resp).unwrap());
-                                    }
-                                };
-                                match std::fs::metadata(&next_path) {
-                                    Ok(next_meta) => {
-                                        effective_file_size = next_meta.len();
-                                        effective_path = next_path;
-                                        effective_shard = next_shard;
-                                        start = 0;
-                                    }
-                                    Err(e) => {
-                                        let resp = make_err_resp(
-                                            format!(
-                                                "stat next log shard failed: path={} err={}",
-                                                next_path.display(),
-                                                e
-                                            ),
-                                            Some(file_size),
-                                        );
-                                        return Ok(serde_json::to_vec(&resp).unwrap());
-                                    }
-                                }
-                            } else if let Ok(Some(latest_shard)) =
-                                workload_log_latest_shard_identity(&logical_path)
-                            {
-                                if latest_shard != cursor.shard {
-                                    let latest_path =
-                                        match workload_log_path_for_shard(&logical_path, &latest_shard) {
-                                            Ok(v) => v,
-                                            Err(e) => {
-                                                let resp = make_err_resp(format!("{}", e), Some(file_size));
-                                                return Ok(serde_json::to_vec(&resp).unwrap());
-                                            }
-                                        };
-                                    match std::fs::metadata(&latest_path) {
-                                        Ok(latest_meta) => {
-                                            effective_file_size = latest_meta.len();
-                                            effective_path = latest_path;
-                                            effective_shard = latest_shard;
-                                            start = 0;
-                                        }
-                                        Err(e) => {
-                                            let resp = make_err_resp(
-                                                format!(
-                                                    "stat latest log shard failed: path={} err={}",
-                                                    latest_path.display(),
-                                                    e
-                                                ),
-                                                Some(file_size),
-                                            );
-                                            return Ok(serde_json::to_vec(&resp).unwrap());
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        let end = match max_bytes {
-                            Some(max_bytes) => {
-                                std::cmp::min(effective_file_size, start.saturating_add(max_bytes))
-                            }
-                            None => effective_file_size,
-                        };
-                        (
-                            start,
-                            end,
-                            Some(WorkloadLogCursor {
-                                shard: effective_shard.clone(),
-                                offset: start,
-                            }),
-                            Some(WorkloadLogCursor {
-                                shard: effective_shard.clone(),
-                                offset: end,
-                            }),
-                            effective_path,
-                            effective_file_size,
-                        )
-                    } else {
-                        let end = file_size;
-                        let start = match max_bytes {
-                            Some(max_bytes) => end.saturating_sub(max_bytes),
-                            None => 0,
-                        };
-                        (
-                            start,
-                            end,
-                            Some(WorkloadLogCursor {
-                                shard: shard.clone(),
-                                offset: start,
-                            }),
-                            Some(WorkloadLogCursor {
-                                shard: shard.clone(),
-                                offset: end,
-                            }),
-                            path.clone(),
-                            file_size,
-                        )
-                    }
-                }
-                LogReadDirection::Backward => {
-                    let Some(cursor) = req.cursor.as_ref() else {
-                        let resp = make_err_resp(
-                            "cursor is required for Backward reads".to_string(),
-                            Some(file_size),
-                        );
-                        return Ok(serde_json::to_vec(&resp).unwrap());
-                    };
+        let (start, end, start_cursor, end_cursor, effective_path, effective_file_size) = match req
+            .direction
+        {
+            LogReadDirection::Forward => {
+                if let Some(cursor) = req.cursor.as_ref() {
                     if cursor.offset > file_size {
                         let resp = make_err_resp(
                             format!(
@@ -3331,30 +3222,31 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
                     let mut effective_path = path.clone();
                     let mut effective_shard = shard.clone();
                     let mut effective_file_size = file_size;
-                    let mut end = cursor.offset;
-                    if cursor.offset == 0 {
-                        if let Ok(Some(prev_shard)) =
-                            workload_log_previous_shard(&logical_path, &cursor.shard)
+                    let mut start = cursor.offset;
+                    if cursor.offset == file_size {
+                        if let Ok(Some(next_shard)) =
+                            workload_log_next_shard(&logical_path, &cursor.shard)
                         {
-                            let prev_path = match workload_log_path_for_shard(&logical_path, &prev_shard) {
-                                Ok(v) => v,
-                                Err(e) => {
-                                    let resp = make_err_resp(format!("{}", e), Some(file_size));
-                                    return Ok(serde_json::to_vec(&resp).unwrap());
-                                }
-                            };
-                            match std::fs::metadata(&prev_path) {
-                                Ok(prev_meta) => {
-                                    effective_file_size = prev_meta.len();
-                                    effective_path = prev_path;
-                                    effective_shard = prev_shard;
-                                    end = effective_file_size;
+                            let next_path =
+                                match workload_log_path_for_shard(&logical_path, &next_shard) {
+                                    Ok(v) => v,
+                                    Err(e) => {
+                                        let resp = make_err_resp(format!("{}", e), Some(file_size));
+                                        return Ok(serde_json::to_vec(&resp).unwrap());
+                                    }
+                                };
+                            match std::fs::metadata(&next_path) {
+                                Ok(next_meta) => {
+                                    effective_file_size = next_meta.len();
+                                    effective_path = next_path;
+                                    effective_shard = next_shard;
+                                    start = 0;
                                 }
                                 Err(e) => {
                                     let resp = make_err_resp(
                                         format!(
-                                            "stat previous log shard failed: path={} err={}",
-                                            prev_path.display(),
+                                            "stat next log shard failed: path={} err={}",
+                                            next_path.display(),
                                             e
                                         ),
                                         Some(file_size),
@@ -3362,11 +3254,47 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
                                     return Ok(serde_json::to_vec(&resp).unwrap());
                                 }
                             }
+                        } else if let Ok(Some(latest_shard)) =
+                            workload_log_latest_shard_identity(&logical_path)
+                        {
+                            if latest_shard != cursor.shard {
+                                let latest_path =
+                                    match workload_log_path_for_shard(&logical_path, &latest_shard)
+                                    {
+                                        Ok(v) => v,
+                                        Err(e) => {
+                                            let resp =
+                                                make_err_resp(format!("{}", e), Some(file_size));
+                                            return Ok(serde_json::to_vec(&resp).unwrap());
+                                        }
+                                    };
+                                match std::fs::metadata(&latest_path) {
+                                    Ok(latest_meta) => {
+                                        effective_file_size = latest_meta.len();
+                                        effective_path = latest_path;
+                                        effective_shard = latest_shard;
+                                        start = 0;
+                                    }
+                                    Err(e) => {
+                                        let resp = make_err_resp(
+                                            format!(
+                                                "stat latest log shard failed: path={} err={}",
+                                                latest_path.display(),
+                                                e
+                                            ),
+                                            Some(file_size),
+                                        );
+                                        return Ok(serde_json::to_vec(&resp).unwrap());
+                                    }
+                                }
+                            }
                         }
                     }
-                    let start = match max_bytes {
-                        Some(max_bytes) => end.saturating_sub(max_bytes),
-                        None => 0,
+                    let end = match max_bytes {
+                        Some(max_bytes) => {
+                            std::cmp::min(effective_file_size, start.saturating_add(max_bytes))
+                        }
+                        None => effective_file_size,
                     };
                     (
                         start,
@@ -3382,8 +3310,103 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
                         effective_path,
                         effective_file_size,
                     )
+                } else {
+                    let end = file_size;
+                    let start = match max_bytes {
+                        Some(max_bytes) => end.saturating_sub(max_bytes),
+                        None => 0,
+                    };
+                    (
+                        start,
+                        end,
+                        Some(WorkloadLogCursor {
+                            shard: shard.clone(),
+                            offset: start,
+                        }),
+                        Some(WorkloadLogCursor {
+                            shard: shard.clone(),
+                            offset: end,
+                        }),
+                        path.clone(),
+                        file_size,
+                    )
                 }
-            };
+            }
+            LogReadDirection::Backward => {
+                let Some(cursor) = req.cursor.as_ref() else {
+                    let resp = make_err_resp(
+                        "cursor is required for Backward reads".to_string(),
+                        Some(file_size),
+                    );
+                    return Ok(serde_json::to_vec(&resp).unwrap());
+                };
+                if cursor.offset > file_size {
+                    let resp = make_err_resp(
+                        format!(
+                            "cursor out of range: shard={} cursor={} file_size={}",
+                            cursor.shard, cursor.offset, file_size
+                        ),
+                        Some(file_size),
+                    );
+                    return Ok(serde_json::to_vec(&resp).unwrap());
+                }
+                let mut effective_path = path.clone();
+                let mut effective_shard = shard.clone();
+                let mut effective_file_size = file_size;
+                let mut end = cursor.offset;
+                if cursor.offset == 0 {
+                    if let Ok(Some(prev_shard)) =
+                        workload_log_previous_shard(&logical_path, &cursor.shard)
+                    {
+                        let prev_path =
+                            match workload_log_path_for_shard(&logical_path, &prev_shard) {
+                                Ok(v) => v,
+                                Err(e) => {
+                                    let resp = make_err_resp(format!("{}", e), Some(file_size));
+                                    return Ok(serde_json::to_vec(&resp).unwrap());
+                                }
+                            };
+                        match std::fs::metadata(&prev_path) {
+                            Ok(prev_meta) => {
+                                effective_file_size = prev_meta.len();
+                                effective_path = prev_path;
+                                effective_shard = prev_shard;
+                                end = effective_file_size;
+                            }
+                            Err(e) => {
+                                let resp = make_err_resp(
+                                    format!(
+                                        "stat previous log shard failed: path={} err={}",
+                                        prev_path.display(),
+                                        e
+                                    ),
+                                    Some(file_size),
+                                );
+                                return Ok(serde_json::to_vec(&resp).unwrap());
+                            }
+                        }
+                    }
+                }
+                let start = match max_bytes {
+                    Some(max_bytes) => end.saturating_sub(max_bytes),
+                    None => 0,
+                };
+                (
+                    start,
+                    end,
+                    Some(WorkloadLogCursor {
+                        shard: effective_shard.clone(),
+                        offset: start,
+                    }),
+                    Some(WorkloadLogCursor {
+                        shard: effective_shard.clone(),
+                        offset: end,
+                    }),
+                    effective_path,
+                    effective_file_size,
+                )
+            }
+        };
 
         if end < start {
             let resp = make_err_resp(
@@ -3416,7 +3439,11 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
             Ok(v) => v,
             Err(e) => {
                 let resp = make_err_resp(
-                    format!("open log failed: path={} err={}", effective_path.display(), e),
+                    format!(
+                        "open log failed: path={} err={}",
+                        effective_path.display(),
+                        e
+                    ),
                     Some(effective_file_size),
                 );
                 return Ok(serde_json::to_vec(&resp).unwrap());
@@ -3425,7 +3452,11 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
 
         if let Err(e) = std::io::Seek::seek(&mut f, std::io::SeekFrom::Start(start)) {
             let resp = make_err_resp(
-                format!("seek log failed: path={} err={}", effective_path.display(), e),
+                format!(
+                    "seek log failed: path={} err={}",
+                    effective_path.display(),
+                    e
+                ),
                 Some(effective_file_size),
             );
             return Ok(serde_json::to_vec(&resp).unwrap());
@@ -3434,7 +3465,11 @@ impl UserRpcHandler for ReadWorkloadLogChunkHandler {
         let mut buf: Vec<u8> = vec![0; len];
         if let Err(e) = std::io::Read::read_exact(&mut f, &mut buf) {
             let resp = make_err_resp(
-                format!("read log failed: path={} err={}", effective_path.display(), e),
+                format!(
+                    "read log failed: path={} err={}",
+                    effective_path.display(),
+                    e
+                ),
                 Some(effective_file_size),
             );
             return Ok(serde_json::to_vec(&resp).unwrap());
@@ -4067,8 +4102,7 @@ fn desired_workload_matches_running(
         &desired.name,
         &desired.authority,
         Some(workloads.scope_key.as_str()),
-    )
-    else {
+    ) else {
         return false;
     };
     desired_workload_status_matches_goal(&status, desired)
@@ -14337,14 +14371,14 @@ mod tests {
         assert_eq!(scoped_b.len(), 1);
         assert_eq!(scoped_b[0].pid(), 22);
 
-        let listed_a = observe_all_selection_statuses_for_snapshot(&snapshot, Some("/tmp/scope-a"))
-            .unwrap();
+        let listed_a =
+            observe_all_selection_statuses_for_snapshot(&snapshot, Some("/tmp/scope-a")).unwrap();
         assert_eq!(listed_a.len(), 1);
         assert_eq!(listed_a[0].label, "DaemonSet/target");
         assert_eq!(listed_a[0].pid, Some(11));
 
-        let listed_b = observe_all_selection_statuses_for_snapshot(&snapshot, Some("/tmp/scope-b"))
-            .unwrap();
+        let listed_b =
+            observe_all_selection_statuses_for_snapshot(&snapshot, Some("/tmp/scope-b")).unwrap();
         assert_eq!(listed_b.len(), 1);
         assert_eq!(listed_b[0].label, "DaemonSet/target");
         assert_eq!(listed_b[0].pid, Some(22));
@@ -14548,8 +14582,8 @@ mod tests {
             zombie_infos: Vec::new(),
         };
 
-        let listed = observe_apply_runtime_statuses_for_snapshot("apply-1", &snapshot, None)
-            .unwrap();
+        let listed =
+            observe_apply_runtime_statuses_for_snapshot("apply-1", &snapshot, None).unwrap();
         assert_eq!(listed.len(), 1);
         assert_eq!(listed[0].name.as_deref(), Some("target-present"));
         assert!(listed[0].present);
@@ -14774,12 +14808,8 @@ mod tests {
             None
         ));
 
-        let delete_old = workloads.delete_generation(
-            WorkloadKind::Deployment,
-            &name,
-            &name,
-            Some("apply-1"),
-        );
+        let delete_old =
+            workloads.delete_generation(WorkloadKind::Deployment, &name, &name, Some("apply-1"));
         if !delete_old.ok {
             let err = delete_old.err.as_deref().unwrap_or_default();
             assert!(
@@ -14813,8 +14843,7 @@ mod tests {
             delete_current.ok,
             "unguarded delete should bind and retire the current visible generation: {delete_current:?}"
         );
-        wait_for_selection_absent(WorkloadKind::Deployment, &name, &name, Some("apply-2"))
-            .unwrap();
+        wait_for_selection_absent(WorkloadKind::Deployment, &name, &name, Some("apply-2")).unwrap();
     }
 
     #[test]
@@ -14826,9 +14855,12 @@ mod tests {
             python_exe.display()
         );
         let workdir = tempfile::tempdir().unwrap();
-        let runtime =
-            SelectionSupervisorRuntime::materialize(workdir.path(), workdir.path(), python_exe.as_path())
-                .unwrap();
+        let runtime = SelectionSupervisorRuntime::materialize(
+            workdir.path(),
+            workdir.path(),
+            python_exe.as_path(),
+        )
+        .unwrap();
         assert!(runtime.script_path.exists());
         assert!(
             runtime
@@ -14849,9 +14881,12 @@ mod tests {
             python_exe.display()
         );
         let workdir = tempfile::tempdir().unwrap();
-        let runtime =
-            SelectionSupervisorRuntime::materialize(workdir.path(), workdir.path(), python_exe.as_path())
-                .unwrap();
+        let runtime = SelectionSupervisorRuntime::materialize(
+            workdir.path(),
+            workdir.path(),
+            python_exe.as_path(),
+        )
+        .unwrap();
         let log_path = workdir.path().join("startup.log");
         let command = vec![
             python_exe.display().to_string(),
@@ -14876,7 +14911,9 @@ mod tests {
             "--".to_string(),
             "/bin/true".to_string(),
         ];
-        let pid = runtime.spawn_detached_command(&log_path, command.as_slice()).unwrap();
+        let pid = runtime
+            .spawn_detached_command(&log_path, command.as_slice())
+            .unwrap();
         let deadline = Instant::now() + Duration::from_secs(10);
         let expected = "owner-ts-ms must be positive";
         let mut saw_expected = false;
@@ -15164,7 +15201,9 @@ mod tests {
             }),
             max_bytes: Some(65536),
         };
-        let raw = handler.handle("n1".into(), &serde_json::to_vec(&req).unwrap()).unwrap();
+        let raw = handler
+            .handle("n1".into(), &serde_json::to_vec(&req).unwrap())
+            .unwrap();
         let resp: ReadWorkloadLogResp = serde_json::from_slice(&raw).unwrap();
         assert!(resp.ok, "{resp:?}");
         assert_eq!(resp.text.as_deref(), Some("new\n"));
@@ -15209,7 +15248,9 @@ mod tests {
             }),
             max_bytes: Some(65536),
         };
-        let raw = handler.handle("n1".into(), &serde_json::to_vec(&req).unwrap()).unwrap();
+        let raw = handler
+            .handle("n1".into(), &serde_json::to_vec(&req).unwrap())
+            .unwrap();
         let resp: ReadWorkloadLogResp = serde_json::from_slice(&raw).unwrap();
         assert!(resp.ok, "{resp:?}");
         assert_eq!(resp.text.as_deref(), Some("old\n"));
diff --git a/fluxon_rs/fluxon_pyo3/src/error.rs b/fluxon_rs/fluxon_pyo3/src/error.rs
index 97ab680..652ef0b 100644
--- a/fluxon_rs/fluxon_pyo3/src/error.rs
+++ b/fluxon_rs/fluxon_pyo3/src/error.rs
@@ -1,6 +1,6 @@
-use pyo3::PyErr;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::PyErr;
 
 use fluxon_mq::MpscError as CoreMpscError;
 // Re-export the core MPSC error type for callers who want to depend on a single error hub.
@@ -221,6 +221,23 @@ pub(crate) fn new_key_being_written_error(
     error_class.call((), Some(&kwargs)).unwrap().into()
 }
 
+pub(crate) fn new_key_already_exists_error(
+    py: Python<'_>,
+    message: &str,
+    key: Option<&str>,
+) -> PyObject {
+    let api_error_module = py.import_bound("fluxon_py.api_error").unwrap();
+    let error_class = api_error_module.getattr("KeyAlreadyExistsError").unwrap();
+
+    let kwargs = PyDict::new_bound(py);
+    kwargs.set_item("message", message).unwrap();
+    if let Some(k) = key {
+        kwargs.set_item("key", k).unwrap();
+    }
+
+    error_class.call((), Some(&kwargs)).unwrap().into()
+}
+
 pub(crate) fn new_storage_full_error(
     py: Python<'_>,
     message: &str,
@@ -352,6 +369,7 @@ pub(crate) fn new_payload_lease_not_found_error(
 /// - TransferEngine::TransferFailedForBlock -> TransferBlockFailedError（可重试）
 /// - Api::InvalidPutMasterState -> PutDoneFailedError
 /// - Api::KeyNotFound -> KeyNotFoundError（携带 key）
+/// - Api::KeyAlreadyExists -> KeyAlreadyExistsError（携带 key）
 /// - Api::KeyBeingWritten -> KeyBeingWrittenError（携带 key）
 /// - Api::NoSpace -> StorageFullError（available_space=free_capacity）
 /// - 其他 -> NetworkError（携带格式化消息）
@@ -381,6 +399,11 @@ pub(crate) fn py_error_from_kv_error(
             &format!("{}: Key not found: {}", prefix, key),
             Some(key),
         ),
+        KvError::Api(CoreApiError::KeyAlreadyExists { key }) => new_key_already_exists_error(
+            py,
+            &format!("{}: Key already exists: {}", prefix, key),
+            Some(key),
+        ),
         KvError::Api(CoreApiError::KeyBeingWritten { key }) => new_key_being_written_error(
             py,
             &format!("{}: Key is currently being written: {}", prefix, key),
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index 631f1ea..e86ef21 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -1,43 +1,62 @@
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::panic::{self, AssertUnwindSafe};
 use std::path::{Path, PathBuf};
 use std::slice;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 
 use bytes::Bytes;
 use fluxon_cli::config::MonitorConfigYaml as MonitorCliConfigYaml;
 use fluxon_fs::config::{
+    FluxonFsRequestIdentity, FluxonFsS3KvMissPolicy, FsAgentDeclaredExportWire,
     FLUXON_FS_CONTROL_SCHEMA_VERSION, FS_AGENT_DECLARED_EXPORT_JSON_KEY,
     FS_AGENT_EXPORT_PUBLISH_RPC_PATH, FS_AGENT_EXPORT_UNPUBLISH_RPC_PATH,
-    FS_MASTER_CONFIG_RPC_PATH, FluxonFsRequestIdentity, FluxonFsS3KvMissPolicy,
-    FsAgentDeclaredExportWire,
+    FS_MASTER_CONFIG_RPC_PATH,
+};
+use fluxon_kv::client_kv_api::msg_pack::{
+    ExternalBatchPutCommitItemReq, ExternalBatchPutCommitReq, ExternalBatchPutStartItemReq,
+    ExternalBatchPutStartReq, ExternalBatchPutTransferEndItemReq, ExternalBatchPutTransferEndReq,
+    ExternalPutRevokeReq,
 };
 use fluxon_kv::client_kv_api::ClientKvApiViewTrait;
-use fluxon_kv::cluster_manager::ClusterManagerViewTrait;
+use fluxon_kv::client_kv_api::{
+    ClientKvApiInner, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, OwnerReservedPutItem,
+};
+use fluxon_kv::client_seg_pool::ClientSegPoolViewTrait;
 use fluxon_kv::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
+use fluxon_kv::cluster_manager::ClusterManagerViewTrait;
 use fluxon_kv::config::{ClientConfigYaml, MasterConfigYaml};
+use fluxon_kv::external_client_api::ExternalClientApiViewTrait;
+use fluxon_kv::master_kv_router::msg_pack::{
+    BatchPreparePutKeyItemReq, BatchPutDoneItemReq, BatchPutRevokeItemReq, BatchPutStartItemReq,
+    PutDoneCommittedSlot,
+};
 use fluxon_kv::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
-use fluxon_kv::p2p::msg_pack::{MsgPack, RPCCaller, call_rpc};
+use fluxon_kv::memholder::kvclient_encode::{flat_kv_decode_borrowed, BorrowedFlatKvValueRange};
+use fluxon_kv::memholder::{
+    ExternalMemHolder as RustExternalMemHolder, MemoryInfo as RustMemoryInfo,
+    UserMemHolder as RustUserMemHolder,
+};
+use fluxon_kv::p2p::msg_pack::{call_rpc, MsgPack, RPCCaller};
 use fluxon_kv::p2p::p2p_module::P2pModuleViewTrait;
-use fluxon_kv::p2p::p2p_module::{UserRpcHandler, user_rpc_register_handler};
+use fluxon_kv::p2p::p2p_module::{user_rpc_register_handler, UserRpcHandler};
 use fluxon_kv::rpcresp_kvresult_convert::msg_and_error::{
     ApiError as CoreApiError, KvError as CoreKvError, KvResult, OK,
 };
 use fluxon_kv::user_api::FlatDict;
 use fluxon_kv::user_api::FlatValue;
 use fluxon_kv::user_api::FluxonUserApi;
+use fluxon_kv::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 use fluxon_kv::{
-    ConfigArg, Framework, KvClientTrait, KvGetResult,
     config::{ClientConfig, MasterConfig},
-    run_client, run_master,
+    run_client, run_master, ConfigArg, Framework, KvClientTrait, KvGetResult,
 };
 use fluxon_ops;
 use fluxon_proxy;
-use fluxon_util::run_async_from_sync::{SyncAsyncBridge, borrow_stable_owner};
+use fluxon_util::run_async_from_sync::{borrow_stable_owner, SyncAsyncBridge};
 use fluxon_util::{
-    FluxonCliProxyDescriptorV2, FluxonCliProxyTransportV2, fluxon_cli_proxy_desc_etcd_key_v2,
+    fluxon_cli_proxy_desc_etcd_key_v2, FluxonCliProxyDescriptorV2, FluxonCliProxyTransportV2,
 };
 use futures::Future;
 use pyo3::exceptions::{PyOSError, PyPermissionError, PyRuntimeError, PyValueError};
@@ -58,6 +77,7 @@ include!(env!("FLUXON_PYO3_TEST_PYTHON_LINK_RS"));
 mod memholder;
 pub use memholder::{ExternalMemHolder, MemHolder};
 mod flatdict_zerocopy;
+use flatdict_zerocopy::{decode_flat_dict_to_wrapped_py_object, FlatDictDataOwner};
 mod kvfuture;
 pub use kvfuture::KvFuture;
 mod error;
@@ -1930,6 +1950,451 @@ fn new_store_closed_error(py: Python, message: &str) -> PyObject {
     crate::error::new_store_closed_error(py, message)
 }
 
+#[derive(Clone, Copy, Debug)]
+struct RegisteredBufferRange {
+    start: usize,
+    end: usize,
+}
+
+impl RegisteredBufferRange {
+    fn contains(&self, ptr: usize, len: usize) -> bool {
+        if len == 0 {
+            return ptr >= self.start && ptr <= self.end;
+        }
+        let Some(req_end) = ptr.checked_add(len) else {
+            return false;
+        };
+        ptr >= self.start && req_end <= self.end
+    }
+}
+
+#[derive(Default, Debug)]
+struct RegisteredBufferRegistry {
+    ranges: Vec<RegisteredBufferRange>,
+}
+
+impl RegisteredBufferRegistry {
+    fn register(&mut self, ptr: usize, len: usize) {
+        let end = ptr.saturating_add(len);
+        self.ranges.push(RegisteredBufferRange { start: ptr, end });
+    }
+
+    fn contains(&self, ptr: usize, len: usize) -> bool {
+        self.ranges.iter().any(|range| range.contains(ptr, len))
+    }
+}
+
+const DEFAULT_PYO3_BATCH_CONCURRENCY: usize = 128;
+
+fn kv_error_to_ret_code(err: &CoreKvError) -> i32 {
+    match err {
+        CoreKvError::Config(inner) => -(inner.code() as i32),
+        CoreKvError::Api(inner) => -(inner.code() as i32),
+        CoreKvError::P2p(inner) => -(inner.code() as i32),
+        CoreKvError::SharedMem(inner) => -(inner.code() as i32),
+        CoreKvError::Unreachable(inner) => -(inner.code() as i32),
+        CoreKvError::ClusterManagerExt(inner) => -(inner.code() as i32),
+        CoreKvError::Metric(inner) => -(inner.code() as i32),
+        CoreKvError::LeaseMgr(inner) => -(inner.code() as i32),
+        CoreKvError::TransferEngine(inner) => -(inner.code() as i32),
+        CoreKvError::P2pTransfer(inner) => -(inner.code() as i32),
+    }
+}
+
+fn rpc_item_error_to_ret_code(error_code: u32, error_json: &str) -> i32 {
+    if error_code == OK {
+        0
+    } else {
+        let err = CoreKvError::from_json(error_code, error_json);
+        kv_error_to_ret_code(&err)
+    }
+}
+
+fn payload_slice_from_get_result<'a>(key: &str, get_result: &'a KvGetResult) -> KvResult<&'a [u8]> {
+    let data = match get_result {
+        KvGetResult::Owner(Some(holder)) => holder.bytes(),
+        KvGetResult::External(Some(holder)) => holder.bytes(),
+        KvGetResult::Owner(None) | KvGetResult::External(None) => {
+            return Err(CoreKvError::Api(CoreApiError::KeyNotFound {
+                key: key.to_string(),
+            }));
+        }
+    };
+
+    let entries = flat_kv_decode_borrowed(data).map_err(|detail| {
+        CoreKvError::Api(CoreApiError::Unknown {
+            detail: format!("decode flat dict for key {} failed: {}", key, detail),
+        })
+    })?;
+    for entry in entries {
+        if entry.key != "payload" {
+            continue;
+        }
+        if let BorrowedFlatKvValueRange::BytesRange { start, len } = entry.value {
+            let end = start.checked_add(len).ok_or_else(|| {
+                CoreKvError::Api(CoreApiError::Unknown {
+                    detail: format!("payload range overflow for key {}", key),
+                })
+            })?;
+            if end > data.len() {
+                return Err(CoreKvError::Api(CoreApiError::Unknown {
+                    detail: format!(
+                        "payload range out of bounds for key {}: end={} data_len={}",
+                        key,
+                        end,
+                        data.len()
+                    ),
+                }));
+            }
+            return Ok(&data[start..end]);
+        }
+        return Err(CoreKvError::Api(CoreApiError::InvalidArgument {
+            detail: format!("key {} payload field is not bytes", key),
+        }));
+    }
+
+    Err(CoreKvError::Api(CoreApiError::InvalidArgument {
+        detail: format!("key {} does not contain payload field", key),
+    }))
+}
+
+const FLUXON_PLAN_BLOB_MAGIC: u64 = 0x4658_504c_414e_5631;
+
+#[derive(Clone)]
+enum FluxonPlanRegistryEntry {
+    Put(Arc<FluxonPutPlan>),
+    Get(Arc<FluxonGetViewsPlan>),
+}
+
+enum FluxonPutPlanState {
+    Prepared(StagedPutPlanData),
+    Committing,
+}
+
+struct FluxonPutPlan {
+    blob: Box<[u64]>,
+    state: Mutex<FluxonPutPlanState>,
+}
+
+struct FluxonGetViewsPlan {
+    blob: Box<[u64]>,
+    _holders: Vec<StagedGetViewHolder>,
+}
+
+enum StagedGetViewHolder {
+    Owner { _holder: Arc<RustUserMemHolder> },
+    External { _holder: Arc<RustExternalMemHolder> },
+}
+
+fn external_get_start_result_to_py(
+    started: &fluxon_kv::external_client_api::ExternalClientGetStartResp,
+    py: Python,
+) -> PyObject {
+    let out = PyDict::new_bound(py);
+    out.set_item("handle", started.handle).expect("set handle");
+    out.set_item("raw_prefix_hit_len", started.raw_prefix_hit_len as u64)
+        .expect("set raw_prefix_hit_len");
+    out.into_py(py)
+}
+
+#[derive(Clone)]
+enum StagedPutPlanData {
+    Owner(StagedOwnerPutPlanData),
+    External(StagedExternalPutPlanData),
+}
+
+#[derive(Clone)]
+struct StagedOwnerPutPlanData {
+    keys: Vec<String>,
+    value_len: u64,
+    write_through: bool,
+    key_reservation_ids: Vec<u64>,
+    slot_lease: OwnerLocalReserveSlotLease,
+}
+
+#[derive(Clone)]
+struct StagedExternalPutPlanData {
+    keys: Vec<String>,
+    value_len: u64,
+    write_through: bool,
+    started_time: i64,
+    items: Vec<StagedExternalPutItem>,
+    short_circuit_payload: bool,
+}
+
+#[derive(Clone)]
+struct StagedExternalPutItem {
+    put_id: fluxon_kv::master_kv_router::put::PutIDForAKey,
+    src_offset: u64,
+    target_offset: u64,
+    transfer_target_offset: Option<u64>,
+    peer_id: Option<String>,
+    target_base_addr: u64,
+}
+
+#[derive(Clone)]
+struct StagedPutCommitItem {
+    idx: usize,
+    reserved_item: OwnerReservedPutItem,
+    slot_ref: OwnerLocalReserveSlotRef,
+}
+
+#[derive(Clone, Debug, Default)]
+struct FluxonIoLocalitySnapshot {
+    op_count: u64,
+    bytes: u64,
+    transfer_us: u64,
+}
+
+impl FluxonIoLocalitySnapshot {
+    fn bandwidth_gbps(&self) -> f64 {
+        if self.transfer_us == 0 {
+            return 0.0;
+        }
+        (self.bytes as f64) / (self.transfer_us as f64 / 1_000_000.0) / 1_000_000_000.0
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct FluxonLocalitySnapshot {
+    l2_local_hit_pages: u64,
+    l2_local_hit_bytes: u64,
+    l2_remote_hit_pages: u64,
+    l2_remote_hit_bytes: u64,
+    put_local: FluxonIoLocalitySnapshot,
+    put_remote: FluxonIoLocalitySnapshot,
+    get_local: FluxonIoLocalitySnapshot,
+    get_remote: FluxonIoLocalitySnapshot,
+}
+
+#[derive(Default)]
+struct FluxonLocalityCounters {
+    l2_local_hit_pages: AtomicU64,
+    l2_local_hit_bytes: AtomicU64,
+    l2_remote_hit_pages: AtomicU64,
+    l2_remote_hit_bytes: AtomicU64,
+    put_local_ops: AtomicU64,
+    put_local_bytes: AtomicU64,
+    put_local_transfer_us: AtomicU64,
+    put_remote_ops: AtomicU64,
+    put_remote_bytes: AtomicU64,
+    put_remote_transfer_us: AtomicU64,
+    get_local_ops: AtomicU64,
+    get_local_bytes: AtomicU64,
+    get_local_transfer_us: AtomicU64,
+    get_remote_ops: AtomicU64,
+    get_remote_bytes: AtomicU64,
+    get_remote_transfer_us: AtomicU64,
+}
+
+impl FluxonLocalityCounters {
+    fn snapshot(&self) -> FluxonLocalitySnapshot {
+        FluxonLocalitySnapshot {
+            l2_local_hit_pages: self.l2_local_hit_pages.load(Ordering::Relaxed),
+            l2_local_hit_bytes: self.l2_local_hit_bytes.load(Ordering::Relaxed),
+            l2_remote_hit_pages: self.l2_remote_hit_pages.load(Ordering::Relaxed),
+            l2_remote_hit_bytes: self.l2_remote_hit_bytes.load(Ordering::Relaxed),
+            put_local: FluxonIoLocalitySnapshot {
+                op_count: self.put_local_ops.load(Ordering::Relaxed),
+                bytes: self.put_local_bytes.load(Ordering::Relaxed),
+                transfer_us: self.put_local_transfer_us.load(Ordering::Relaxed),
+            },
+            put_remote: FluxonIoLocalitySnapshot {
+                op_count: self.put_remote_ops.load(Ordering::Relaxed),
+                bytes: self.put_remote_bytes.load(Ordering::Relaxed),
+                transfer_us: self.put_remote_transfer_us.load(Ordering::Relaxed),
+            },
+            get_local: FluxonIoLocalitySnapshot {
+                op_count: self.get_local_ops.load(Ordering::Relaxed),
+                bytes: self.get_local_bytes.load(Ordering::Relaxed),
+                transfer_us: self.get_local_transfer_us.load(Ordering::Relaxed),
+            },
+            get_remote: FluxonIoLocalitySnapshot {
+                op_count: self.get_remote_ops.load(Ordering::Relaxed),
+                bytes: self.get_remote_bytes.load(Ordering::Relaxed),
+                transfer_us: self.get_remote_transfer_us.load(Ordering::Relaxed),
+            },
+        }
+    }
+
+    fn record_l2_hit(&self, remote: bool, bytes: u64) {
+        if remote {
+            self.l2_remote_hit_pages.fetch_add(1, Ordering::Relaxed);
+            self.l2_remote_hit_bytes.fetch_add(bytes, Ordering::Relaxed);
+        } else {
+            self.l2_local_hit_pages.fetch_add(1, Ordering::Relaxed);
+            self.l2_local_hit_bytes.fetch_add(bytes, Ordering::Relaxed);
+        }
+    }
+
+    fn record_put(&self, remote: bool, bytes: u64, transfer_us: i64) {
+        let transfer_us = transfer_us.max(0) as u64;
+        if remote {
+            self.put_remote_ops.fetch_add(1, Ordering::Relaxed);
+            self.put_remote_bytes.fetch_add(bytes, Ordering::Relaxed);
+            self.put_remote_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        } else {
+            self.put_local_ops.fetch_add(1, Ordering::Relaxed);
+            self.put_local_bytes.fetch_add(bytes, Ordering::Relaxed);
+            self.put_local_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        }
+    }
+
+    fn record_get(&self, remote: bool, bytes: u64, transfer_us: i64) {
+        let transfer_us = transfer_us.max(0) as u64;
+        if remote {
+            self.get_remote_ops.fetch_add(1, Ordering::Relaxed);
+            self.get_remote_bytes.fetch_add(bytes, Ordering::Relaxed);
+            self.get_remote_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        } else {
+            self.get_local_ops.fetch_add(1, Ordering::Relaxed);
+            self.get_local_bytes.fetch_add(bytes, Ordering::Relaxed);
+            self.get_local_transfer_us
+                .fetch_add(transfer_us, Ordering::Relaxed);
+        }
+    }
+}
+
+fn build_plan_blob(value_ptrs: &[u64]) -> Box<[u64]> {
+    let mut words = Vec::with_capacity(2 + value_ptrs.len());
+    words.push(FLUXON_PLAN_BLOB_MAGIC);
+    words.push(value_ptrs.len() as u64);
+    words.extend_from_slice(value_ptrs);
+    words.into_boxed_slice()
+}
+
+fn plan_ptr_from_blob(blob: &[u64]) -> usize {
+    blob.as_ptr() as usize
+}
+
+fn plan_ptr_u64_to_usize(plan_ptr: u64, py: Python) -> Result<usize, PyObject> {
+    let plan_ptr_usize = usize::try_from(plan_ptr)
+        .map_err(|_| new_invalid_argument_error(py, "plan_ptr out of range"))?;
+    if plan_ptr_usize == 0 {
+        return Err(new_invalid_argument_error(py, "plan_ptr must be non-zero"));
+    }
+    Ok(plan_ptr_usize)
+}
+
+fn cleanup_plan_registry_entry(
+    registry: &Arc<RwLock<HashMap<usize, FluxonPlanRegistryEntry>>>,
+    plan_ptr: usize,
+) {
+    let mut guard = registry.write().expect("plan_registry poisoned");
+    guard.remove(&plan_ptr);
+}
+
+async fn release_staged_put_resources(
+    inner: &ClientKvApiInner,
+    key_reservation_ids: Vec<u64>,
+    slot_lease: OwnerLocalReserveSlotLease,
+) -> KvResult<()> {
+    let release_keys_result = inner
+        .batch_release_put_key_reservations(key_reservation_ids)
+        .await;
+    let release_slot_result = inner
+        .owner_release_local_reserve_slot_lease(slot_lease)
+        .await;
+    match (release_keys_result, release_slot_result) {
+        (Ok(_), Ok(_)) => Ok(()),
+        (Err(err), Ok(_)) => Err(err),
+        (Ok(_), Err(err)) => Err(err),
+        (Err(primary_err), Err(cleanup_err)) => Err(CoreKvError::Api(CoreApiError::Unknown {
+            detail: format!(
+                "release_staged_put_resources failed twice: batch_release_put_key_reservations_err={} release_local_slot_lease_err={}",
+                primary_err, cleanup_err
+            ),
+        })),
+    }
+}
+
+async fn release_put_key_reservations_only(
+    inner: &ClientKvApiInner,
+    key_reservation_ids: Vec<u64>,
+) -> KvResult<()> {
+    inner
+        .batch_release_put_key_reservations(key_reservation_ids)
+        .await
+        .map(|_| ())
+}
+
+fn staged_put_uses_direct_local_commit(item: &OwnerReservedPutItem) -> bool {
+    !item.write_through || (item.peer_node_id.is_none() && item.src_addr == item.target_addr)
+}
+
+fn combine_kv_errors(
+    context: &str,
+    primary_err: CoreKvError,
+    secondary_err: CoreKvError,
+) -> CoreKvError {
+    CoreKvError::Api(CoreApiError::Unknown {
+        detail: format!(
+            "{}: primary_err={} secondary_err={}",
+            context, primary_err, secondary_err
+        ),
+    })
+}
+
+fn remove_precommit_local_visible_infos(
+    inner: &ClientKvApiInner,
+    keys: &[String],
+    memory_infos: &[Arc<RustMemoryInfo>],
+) {
+    for (key, memory_info) in keys.iter().zip(memory_infos.iter()) {
+        let _ = inner.remove_precommit_local_reserve_resident_slot_if_same(key, memory_info);
+    }
+}
+
+fn remove_precommit_local_visible_infos_for_items(
+    inner: &ClientKvApiInner,
+    items: &[StagedPutCommitItem],
+    memory_infos: &[Arc<RustMemoryInfo>],
+) {
+    for item in items {
+        let _ = inner.remove_precommit_local_reserve_resident_slot_if_same(
+            &item.reserved_item.key,
+            &memory_infos[item.idx],
+        );
+    }
+}
+
+async fn revoke_staged_put_items(
+    inner: &ClientKvApiInner,
+    items: &[StagedPutCommitItem],
+) -> KvResult<()> {
+    if items.is_empty() {
+        return Ok(());
+    }
+    inner
+        .batch_put_revoke(
+            items
+                .iter()
+                .map(|item| BatchPutRevokeItemReq {
+                    key: item.reserved_item.key.clone(),
+                    put_id: item.reserved_item.put_id,
+                })
+                .collect(),
+        )
+        .await
+        .map(|_| ())
+}
+
+#[pyfunction]
+fn decode_flat_dict_payload(payload: Vec<u8>, py: Python<'_>) -> PyObject {
+    match decode_flat_dict_to_wrapped_py_object(py, FlatDictDataOwner::from_owned_bytes(payload)) {
+        Ok(value) => ApiResult::new_success(value).into_py_object(py),
+        Err(err) => ApiResult::<PyObject>::new_error(crate::error::py_error_from_kv_error(
+            py,
+            &err,
+            "flat dict decode failed",
+        ))
+        .into_py_object(py),
+    }
+}
+
 #[pyfunction]
 fn monitor_render_cli(config_path: String, workdir: String) -> PyResult<String> {
     let cfg_yaml = MonitorCliConfigYaml::from_file(std::path::Path::new(&config_path))
@@ -2676,6 +3141,9 @@ pub struct KvClient {
     // - Futures must not hold Arc<Runtime>; they should spawn via Handle clones only.
     runtime: Option<Runtime>,
     config: ClientConfig,
+    registered_buffers: RwLock<RegisteredBufferRegistry>,
+    plan_registry: Arc<RwLock<HashMap<usize, FluxonPlanRegistryEntry>>>,
+    locality_counters: Arc<FluxonLocalityCounters>,
 }
 
 #[pymethods]
@@ -2751,6 +3219,9 @@ impl KvClient {
                 framework: Some(framework),
                 runtime: Some(runtime),
                 config: final_config,
+                registered_buffers: RwLock::new(RegisteredBufferRegistry::default()),
+                plan_registry: Arc::new(RwLock::new(HashMap::new())),
+                locality_counters: Arc::new(FluxonLocalityCounters::default()),
             };
 
             match Py::new(py, client) {
@@ -2800,28 +3271,9 @@ impl KvClient {
         self.config.cluster_name.clone()
     }
 
-    /// Allocate a fluxon-kv lease id synchronously.
-    /// Always allocate a new lease id (no reuse by requested id).
-    /// Allocate with the provided TTL seconds (must be >= MIN_CLIENT_TTL_SECONDS).
-    #[pyo3(signature = (ttl_seconds))]
-    fn allocate_lease(&self, ttl_seconds: u64, py: Python) -> PyObject {
-        fn allocate_lease_inner(
-            client: &KvClient,
-            ttl_seconds: u64,
-            py: Python,
-        ) -> ApiResult<PyObject> {
-            // Enforce minimum TTL at the PyO3 boundary so obvious mistakes fail fast.
-            if ttl_seconds
-                < fluxon_kv::master_lease_manager::MasterLeaseManager::MIN_CLIENT_TTL_SECONDS
-            {
-                return ApiResult::new_error(new_invalid_argument_error(
-                    py,
-                    &format!(
-                        "allocate_lease(ttl_seconds) requires ttl_seconds >= {} seconds",
-                        fluxon_kv::master_lease_manager::MasterLeaseManager::MIN_CLIENT_TTL_SECONDS,
-                    ),
-                ));
-            }
+    /// Wait until the local segment mapping is ready for direct hostless access.
+    fn wait_local_segments_ready(&self, py: Python) -> PyObject {
+        fn wait_local_segments_ready_inner(client: &KvClient, py: Python) -> ApiResult<PyObject> {
             let framework = match require_kv_framework_api(client, py) {
                 Ok(v) => v,
                 Err(e) => return ApiResult::new_error(e),
@@ -2835,64 +3287,121 @@ impl KvClient {
                     ));
                 }
             };
-            // Blocking call on the client's runtime; simple and predictable for callers.
-            let r: Result<u64, String> = match py.allow_threads(|| {
+
+            if framework.is_external_mode() {
+                let framework_for_wait = framework.clone();
+                let ready_result = match py.allow_threads(|| {
+                    runtime.run_async_from_sync(async move {
+                        framework_for_wait
+                            .external_client_api_view()
+                            .external_client_api()
+                            .inner()
+                            .wait_current_owner_mapped_range()
+                            .await
+                    })
+                }) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!("runtime bridge failed: {}", e),
+                        ));
+                    }
+                };
+                return match ready_result {
+                    Ok((node_id, owner_start_time, write_ptr, read_ptr, len)) => {
+                        let item = PyDict::new_bound(py);
+                        item.set_item("segment_label", "external_owner:0")
+                            .expect("set segment_label");
+                        item.set_item("write_ptr", write_ptr)
+                            .expect("set write_ptr");
+                        item.set_item("read_ptr", read_ptr).expect("set read_ptr");
+                        item.set_item("len", len).expect("set len");
+                        item.set_item("generation", owner_start_time)
+                            .expect("set generation");
+                        item.set_item("node_id", node_id).expect("set node_id");
+                        let out = PyList::empty_bound(py);
+                        out.append(item).expect("append external owner segment");
+                        ApiResult::new_success(out.into_py(py))
+                    }
+                    Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "wait_local_segments_ready failed",
+                    )),
+                };
+            }
+
+            let self_info = framework
+                .cluster_manager_view()
+                .cluster_manager()
+                .get_self_info();
+            let framework_for_wait = framework.clone();
+            let ready_result = match py.allow_threads(|| {
                 runtime.run_async_from_sync(async move {
-                    framework
-                        .kv_allocate_lease(ttl_seconds)
+                    framework_for_wait
+                        .client_seg_pool_view()
+                        .client_seg_pool()
+                        .mapped_range()
                         .await
-                        .map_err(|e| e.to_string())
+                        .ok_or_else(|| {
+                            CoreKvError::Api(CoreApiError::Unknown {
+                                detail: "local owner segment is not mounted".to_string(),
+                            })
+                        })
                 })
             }) {
                 Ok(v) => v,
-                Err(e) => Err(format!("runtime bridge failed: {}", e)),
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
             };
-            match r {
-                Ok(id) => ApiResult::new_success(Python::with_gil(|py| id.into_py(py))),
-                Err(e) => ApiResult::new_error(Python::with_gil(|py| {
-                    new_network_error(py, &format!("Allocate lease failed: {}", e), None)
-                })),
+            match ready_result {
+                Ok((write_ptr, read_ptr, len)) => {
+                    let item = PyDict::new_bound(py);
+                    item.set_item("segment_label", "cpu:0")
+                        .expect("set segment_label");
+                    item.set_item("write_ptr", write_ptr)
+                        .expect("set write_ptr");
+                    item.set_item("read_ptr", read_ptr).expect("set read_ptr");
+                    item.set_item("len", len).expect("set len");
+                    item.set_item("generation", self_info.node_start_time)
+                        .expect("set generation");
+                    item.set_item("node_id", self_info.id).expect("set node_id");
+                    let out = PyList::empty_bound(py);
+                    out.append(item).expect("append local segment");
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "wait_local_segments_ready failed",
+                )),
             }
         }
-        allocate_lease_inner(self, ttl_seconds, py).into_py_object(py)
+
+        wait_local_segments_ready_inner(self, py).into_py_object(py)
     }
 
-    /// Keepalive a lease synchronously. Type must be specified to avoid ambiguity.
-    /// This uses the lease's existing TTL on the master.
-    #[pyo3(signature = (lease_id, lease_type))]
-    fn keepalive_lease(
-        &self,
-        lease_id: u64,
-        lease_type: &Bound<'_, PyAny>,
-        py: Python,
-    ) -> PyObject {
-        fn keepalive_lease_inner(
+    #[pyo3(signature = ())]
+    fn reserve_local_grant_blocking(&self, py: Python) -> PyObject {
+        fn reserve_local_grant_blocking_inner(
             client: &KvClient,
-            lease_id: u64,
-            lease_type: &Bound<'_, PyAny>,
             py: Python,
         ) -> ApiResult<PyObject> {
-            // Accept simple enum-like strings: "kvclient" | "etcd"
-            let lease_type_str = match lease_type.extract::<String>() {
-                Ok(s) => s.to_ascii_lowercase(),
-                Err(_) => {
-                    return ApiResult::new_error(new_invalid_argument_error(
-                        py,
-                        "lease_type must be 'kvclient' or 'etcd'",
-                    ));
-                }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
             };
-
-            if lease_type_str != "kvclient" {
+            if framework.is_external_mode() {
                 return ApiResult::new_error(new_invalid_argument_error(
                     py,
-                    "keepalive_lease(type=etcd) is not supported in fluxon_pyo3; use fluxon_mq.LeaseManagerHandle for etcd leases",
+                    "reserve_local_grant_blocking currently only supports owner mode",
                 ));
             }
-            let framework = match require_kv_framework_api(client, py) {
-                Ok(v) => v,
-                Err(e) => return ApiResult::new_error(e),
-            };
             let runtime = match client.runtime.as_ref() {
                 Some(v) => v,
                 None => {
@@ -2902,34 +3411,1514 @@ impl KvClient {
                     ));
                 }
             };
-            let r: Result<(), String> = match py.allow_threads(|| {
+            let framework_for_reserve = framework.clone();
+            let reserve_resp = match py.allow_threads(|| {
                 runtime.run_async_from_sync(async move {
-                    framework
-                        .kv_keepalive_lease(lease_id)
+                    framework_for_reserve
+                        .client_kv_api_view()
+                        .client_kv_api()
+                        .inner()
+                        .reserve_local_grant()
                         .await
-                        .map_err(|e| e.to_string())
                 })
             }) {
                 Ok(v) => v,
-                Err(e) => Err(format!("runtime bridge failed: {}", e)),
-            };
-            match r {
-                Ok(_) => {
-                    ApiResult::new_success(Python::with_gil(|py| new_none_success_instance(py)))
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
                 }
-                Err(e) => ApiResult::new_error(Python::with_gil(|py| {
-                    new_network_error(py, &format!("Keepalive lease failed: {}", e), None)
-                })),
+            };
+            match reserve_resp {
+                Ok(resp) => ApiResult::new_success(
+                    (resp.grant_id, resp.addr, resp.base_addr, resp.len).into_py(py),
+                ),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    &format!(
+                        "reserve_local_grant_blocking failed for fixed quantum={}B",
+                        OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES
+                    ),
+                )),
             }
         }
-        keepalive_lease_inner(self, lease_id, lease_type, py).into_py_object(py)
+
+        reserve_local_grant_blocking_inner(self, py).into_py_object(py)
     }
 
-    /// Put a key-value pair (non-blocking) by encoding a flat dict from raw entries.
-    ///
-    /// `ptrs` is a list of `(type_id, dict_key_ptr, dict_key_len, val_u64, val_len, extra)`:
-    /// - `dict_key_ptr/dict_key_len`: UTF-8 bytes of the dict field key.
-    /// - For scalar types (bool/int64/float64), `val_u64` stores raw bits and `val_len` is fixed.
+    #[pyo3(signature = (grant_id))]
+    fn release_local_grant_blocking(&self, grant_id: u64, py: Python) -> PyObject {
+        fn release_local_grant_blocking_inner(
+            client: &KvClient,
+            grant_id: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "release_local_grant_blocking currently only supports owner mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework_for_release = framework.clone();
+            let release_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_release
+                        .client_kv_api_view()
+                        .client_kv_api()
+                        .inner()
+                        .release_local_grant(grant_id)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match release_result {
+                Ok(()) => ApiResult::new_success(0i32.into_py(py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "release_local_grant_blocking failed",
+                )),
+            }
+        }
+
+        release_local_grant_blocking_inner(self, grant_id, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (keys, value_len, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true))]
+    fn local_fast_put_start(
+        &self,
+        keys: Vec<String>,
+        value_len: u64,
+        reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
+        py: Python,
+    ) -> PyObject {
+        fn local_fast_put_start_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            value_len: u64,
+            reject_if_inflight_same_key: bool,
+            reject_if_exist_same_key: bool,
+            write_through: bool,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "local_fast_put_start requires at least one key",
+                ));
+            }
+            if value_len == 0 {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "local_fast_put_start requires value_len > 0",
+                ));
+            }
+            if value_len > u32::MAX as u64 {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "local_fast_put_start value_len exceeds u32 limit",
+                ));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+
+            if framework.is_external_mode() {
+                let framework_for_start = framework.clone();
+                let keys_for_req = keys.clone();
+                let external_start_result = match py.allow_threads(|| {
+                    runtime.run_async_from_sync(async move {
+                        let external_api_view = framework_for_start.external_client_api_view();
+                        let inner = external_api_view.external_client_api().inner();
+                        let started_time = inner.current_owner_start_time().await;
+                        let base_addr = inner.base_ptr().await?;
+                        let short_circuit_payload = inner.short_circuit_put_payload_path_enabled();
+                        let resp = inner
+                            .external_batch_put_start_rpc(ExternalBatchPutStartReq {
+                                items: keys_for_req
+                                    .iter()
+                                    .map(|key| ExternalBatchPutStartItemReq {
+                                        key: key.clone(),
+                                        len: value_len,
+                                        reject_if_inflight_same_key,
+                                        reject_if_exist_same_key,
+                                        write_through,
+                                        preferred_sub_cluster: None,
+                                    })
+                                    .collect(),
+                                started_time,
+                            })
+                            .await?;
+                        Ok::<_, CoreKvError>((base_addr, started_time, short_circuit_payload, resp))
+                    })
+                }) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!("runtime bridge failed: {}", e),
+                        ));
+                    }
+                };
+                let (base_addr, started_time, short_circuit_payload, resp) =
+                    match external_start_result {
+                        Ok(v) => v,
+                        Err(err) => {
+                            return ApiResult::new_error(crate::error::py_error_from_kv_error(
+                                py,
+                                &err,
+                                "local_fast_put_start failed",
+                            ));
+                        }
+                    };
+                let revoke_started_puts = |started_items: Vec<(
+                    String,
+                    fluxon_kv::master_kv_router::put::PutIDForAKey,
+                )>|
+                 -> Option<CoreKvError> {
+                    if started_items.is_empty() {
+                        return None;
+                    }
+                    let framework_for_revoke = framework.clone();
+                    match py.allow_threads(|| {
+                        runtime.run_async_from_sync(async move {
+                            let external_api_view = framework_for_revoke.external_client_api_view();
+                            let inner = external_api_view.external_client_api().inner();
+                            for (key, put_id) in started_items {
+                                inner
+                                    .external_put_revoke_rpc(ExternalPutRevokeReq {
+                                        key,
+                                        put_id: Some(put_id),
+                                        started_time,
+                                    })
+                                    .await?;
+                            }
+                            Ok::<(), CoreKvError>(())
+                        })
+                    }) {
+                        Ok(Ok(())) => None,
+                        Ok(Err(err)) => Some(err),
+                        Err(err) => Some(CoreKvError::Api(CoreApiError::Unknown {
+                            detail: format!(
+                                "runtime bridge failed during external local_fast_put_start cleanup: {}",
+                                err
+                            ),
+                        })),
+                    }
+                };
+                let local_fast_put_start_error = |primary_err: CoreKvError,
+                                                  cleanup_err: Option<CoreKvError>|
+                 -> ApiResult<PyObject> {
+                    let err = match cleanup_err {
+                        Some(cleanup_err) => combine_kv_errors(
+                            "local_fast_put_start external cleanup failed",
+                            primary_err,
+                            cleanup_err,
+                        ),
+                        None => primary_err,
+                    };
+                    ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "local_fast_put_start failed",
+                    ))
+                };
+                if resp.items.len() != keys.len() {
+                    let started_items = keys
+                        .iter()
+                        .zip(resp.items.iter())
+                        .filter_map(|(key, item)| {
+                            if item.error_code == OK {
+                                item.put_id.map(|put_id| (key.clone(), put_id))
+                            } else {
+                                None
+                            }
+                        })
+                        .collect::<Vec<_>>();
+                    let err = CoreKvError::Api(CoreApiError::Unknown {
+                        detail: format!(
+                            "local_fast_put_start external response length mismatch: expected={} got={}",
+                            keys.len(),
+                            resp.items.len()
+                        ),
+                    });
+                    return local_fast_put_start_error(err, revoke_started_puts(started_items));
+                }
+                let mut value_ptrs = Vec::with_capacity(keys.len());
+                let mut items = Vec::with_capacity(keys.len());
+                let mut started_items = Vec::with_capacity(keys.len());
+                for (key, item) in keys.iter().zip(resp.items.into_iter()) {
+                    if item.error_code != OK {
+                        let err = CoreKvError::from_json(item.error_code, &item.error_json);
+                        return local_fast_put_start_error(err, revoke_started_puts(started_items));
+                    }
+                    let Some(put_id) = item.put_id else {
+                        let err = CoreKvError::Api(CoreApiError::Unknown {
+                            detail: format!(
+                                "local_fast_put_start external missing put_id in success response for key={}",
+                                key
+                            ),
+                        });
+                        return local_fast_put_start_error(err, revoke_started_puts(started_items));
+                    };
+                    started_items.push((key.clone(), put_id));
+                    let value_ptr = (base_addr as u64)
+                        .checked_add(item.target_offset)
+                        .ok_or_else(|| {
+                            CoreKvError::Api(CoreApiError::Unknown {
+                                detail: "local_fast_put_start external value ptr overflow"
+                                    .to_string(),
+                            })
+                        });
+                    let value_ptr = match value_ptr {
+                        Ok(v) => v,
+                        Err(err) => {
+                            return local_fast_put_start_error(
+                                err,
+                                revoke_started_puts(started_items),
+                            );
+                        }
+                    };
+                    value_ptrs.push(value_ptr);
+                    items.push(StagedExternalPutItem {
+                        put_id,
+                        src_offset: item.src_offset,
+                        target_offset: item.target_offset,
+                        transfer_target_offset: item.transfer_target_offset,
+                        peer_id: item.peer_id,
+                        target_base_addr: item.target_base_addr,
+                    });
+                }
+                let plan = Arc::new(FluxonPutPlan {
+                    blob: build_plan_blob(&value_ptrs),
+                    state: Mutex::new(FluxonPutPlanState::Prepared(StagedPutPlanData::External(
+                        StagedExternalPutPlanData {
+                            keys,
+                            value_len,
+                            write_through,
+                            started_time,
+                            items,
+                            short_circuit_payload,
+                        },
+                    ))),
+                });
+                let plan_ptr = plan_ptr_from_blob(plan.blob.as_ref());
+                client
+                    .plan_registry
+                    .write()
+                    .expect("plan_registry poisoned")
+                    .insert(plan_ptr, FluxonPlanRegistryEntry::Put(plan));
+                return ApiResult::new_success((plan_ptr as u64).into_py(py));
+            }
+
+            let key_count = keys.len();
+            let framework_for_start = framework.clone();
+            let prepare_items = keys
+                .iter()
+                .map(|key| BatchPreparePutKeyItemReq {
+                    key: key.clone(),
+                    reject_if_inflight_same_key,
+                    reject_if_exist_same_key,
+                })
+                .collect::<Vec<_>>();
+
+            let prepare_and_slot_lease_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    let client_kv_api_view = framework_for_start.client_kv_api_view();
+                    let inner = client_kv_api_view.client_kv_api().inner();
+                    let prepared = inner.batch_prepare_put_keys(prepare_items).await?;
+                    if prepared.reservation_ids.len() != key_count {
+                        let cleanup_result = inner
+                            .batch_release_put_key_reservations(prepared.reservation_ids.clone())
+                            .await;
+                        return match cleanup_result {
+                            Ok(_) => Err(CoreKvError::Api(CoreApiError::Unknown {
+                                detail: format!(
+                                    "local_fast_put_start reservation length mismatch: expected={} got={}",
+                                    key_count,
+                                    prepared.reservation_ids.len()
+                                ),
+                            })),
+                            Err(cleanup_err) => Err(CoreKvError::Api(CoreApiError::Unknown {
+                                detail: format!(
+                                    "local_fast_put_start reservation length mismatch and cleanup failed: expected={} got={} cleanup_err={}",
+                                    key_count,
+                                    prepared.reservation_ids.len(),
+                                    cleanup_err
+                                ),
+                            })),
+                        };
+                    }
+                    let slot_lease = match inner
+                        .owner_claim_local_reserve_slot_lease(value_len, key_count)
+                        .await
+                    {
+                        Ok(slot_lease) => slot_lease,
+                        Err(err) => {
+                            let cleanup_result = inner
+                                .batch_release_put_key_reservations(prepared.reservation_ids.clone())
+                                .await;
+                            return match cleanup_result {
+                                Ok(_) => Err(err),
+                                Err(cleanup_err) => Err(CoreKvError::Api(CoreApiError::Unknown {
+                                    detail: format!(
+                                        "local_fast_put_start reserve_local_grant failed: {} cleanup_err={}",
+                                        err, cleanup_err
+                                    ),
+                                })),
+                            };
+                        }
+                    };
+                    Ok((prepared.reservation_ids, slot_lease))
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+
+            let (key_reservation_ids, slot_lease) = match prepare_and_slot_lease_result {
+                Ok(v) => v,
+                Err(err) => {
+                    return ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "local_fast_put_start failed",
+                    ));
+                }
+            };
+
+            let value_ptrs = slot_lease.value_ptrs();
+
+            let plan = Arc::new(FluxonPutPlan {
+                blob: build_plan_blob(&value_ptrs),
+                state: Mutex::new(FluxonPutPlanState::Prepared(StagedPutPlanData::Owner(
+                    StagedOwnerPutPlanData {
+                        keys,
+                        value_len,
+                        write_through,
+                        key_reservation_ids,
+                        slot_lease,
+                    },
+                ))),
+            });
+            let plan_ptr = plan_ptr_from_blob(plan.blob.as_ref());
+            client
+                .plan_registry
+                .write()
+                .expect("plan_registry poisoned")
+                .insert(plan_ptr, FluxonPlanRegistryEntry::Put(plan));
+            ApiResult::new_success((plan_ptr as u64).into_py(py))
+        }
+
+        local_fast_put_start_inner(
+            self,
+            keys,
+            value_len,
+            reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
+            py,
+        )
+        .into_py_object(py)
+    }
+
+    #[pyo3(signature = (plan_ptr))]
+    fn local_fast_put_commit(&self, plan_ptr: u64, py: Python) -> PyObject {
+        fn local_fast_put_commit_inner(
+            client: &KvClient,
+            plan_ptr: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let plan_ptr_usize = match plan_ptr_u64_to_usize(plan_ptr, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime_handle = match client.runtime.as_ref() {
+                Some(v) => v.handle().clone(),
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let registry_entry = {
+                let guard = client.plan_registry.read().expect("plan_registry poisoned");
+                guard.get(&plan_ptr_usize).cloned()
+            };
+            let Some(FluxonPlanRegistryEntry::Put(plan)) = registry_entry else {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "local_fast_put_commit requires a live put plan_ptr",
+                ));
+            };
+            let plan_data = {
+                let mut state_guard = plan.state.lock().expect("put plan state poisoned");
+                match std::mem::replace(&mut *state_guard, FluxonPutPlanState::Committing) {
+                    FluxonPutPlanState::Prepared(data) => data,
+                    FluxonPutPlanState::Committing => {
+                        return ApiResult::new_error(new_invalid_argument_error(
+                            py,
+                            "local_fast_put_commit cannot be called twice on the same plan_ptr",
+                        ));
+                    }
+                }
+            };
+            let framework_for_commit = framework.clone();
+            let plan_registry = client.plan_registry.clone();
+            let transfer_concurrency = 128usize;
+            let future = async move {
+                let ret_codes = match plan_data {
+                    StagedPutPlanData::External(external_data) => {
+                        let external_api_view = framework_for_commit.external_client_api_view();
+                        let inner = external_api_view.external_client_api().inner();
+                        let keys = external_data.keys;
+                        let items = external_data.items;
+                        let result = if external_data.short_circuit_payload {
+                            inner
+                                .external_batch_put_commit_rpc(ExternalBatchPutCommitReq {
+                                    items: keys
+                                        .iter()
+                                        .zip(items.iter())
+                                        .map(|(key, item)| ExternalBatchPutCommitItemReq {
+                                            key: key.clone(),
+                                            len: external_data.value_len,
+                                            src_offset: item.src_offset,
+                                            remote_target: item.peer_id.is_some(),
+                                            put_id: Some(item.put_id),
+                                            lease_id: None,
+                                            write_through: external_data.write_through,
+                                        })
+                                        .collect(),
+                                    started_time: external_data.started_time,
+                                })
+                                .await
+                                .map(|resp| {
+                                    resp.items
+                                        .into_iter()
+                                        .map(|item| {
+                                            rpc_item_error_to_ret_code(
+                                                item.error_code,
+                                                &item.error_json,
+                                            )
+                                        })
+                                        .collect::<Vec<_>>()
+                                })
+                        } else {
+                            inner
+                                .external_batch_put_transfer_end_rpc(
+                                    ExternalBatchPutTransferEndReq {
+                                        items: keys
+                                            .iter()
+                                            .zip(items.iter())
+                                            .map(|(key, item)| ExternalBatchPutTransferEndItemReq {
+                                                key: key.clone(),
+                                                len: external_data.value_len,
+                                                src_offset: item.src_offset,
+                                                target_offset: item
+                                                    .transfer_target_offset
+                                                    .unwrap_or(item.target_offset),
+                                                peer_id: item.peer_id.clone(),
+                                                target_base_addr: if item.peer_id.is_some() {
+                                                    Some(item.target_base_addr)
+                                                } else {
+                                                    None
+                                                },
+                                                put_id: Some(item.put_id),
+                                                write_through: external_data.write_through,
+                                                lease_id: None,
+                                            })
+                                            .collect(),
+                                        started_time: external_data.started_time,
+                                        transfer_concurrency,
+                                    },
+                                )
+                                .await
+                                .map(|resp| {
+                                    resp.items
+                                        .into_iter()
+                                        .map(|item| {
+                                            rpc_item_error_to_ret_code(
+                                                item.error_code,
+                                                &item.error_json,
+                                            )
+                                        })
+                                        .collect::<Vec<_>>()
+                                })
+                        };
+                        match result {
+                            Ok(ret_codes) => ret_codes,
+                            Err(err) => vec![kv_error_to_ret_code(&err); keys.len()],
+                        }
+                    }
+                    StagedPutPlanData::Owner(owner_data) => {
+                        let client_kv_api_view = framework_for_commit.client_kv_api_view();
+                        let inner = client_kv_api_view.client_kv_api().inner();
+                        let start_items = owner_data
+                            .keys
+                            .iter()
+                            .map(|key| BatchPutStartItemReq {
+                                key: key.clone(),
+                                len: owner_data.value_len,
+                                reject_if_inflight_same_key: false,
+                                reject_if_exist_same_key: false,
+                                write_through: owner_data.write_through,
+                                preferred_sub_cluster: None,
+                            })
+                            .collect::<Vec<_>>();
+                        let slot_refs = owner_data.slot_lease.slots.clone();
+                        let slot_size = owner_data.slot_lease.slot_size;
+                        let value_len_usize = match usize::try_from(owner_data.value_len) {
+                            Ok(value) => value,
+                            Err(_) => {
+                                let err = CoreKvError::Api(CoreApiError::InvalidArgument {
+                                    detail:
+                                        "local_fast_put_commit value_len does not fit into usize"
+                                            .to_string(),
+                                });
+                                let _ = release_staged_put_resources(
+                                    inner,
+                                    owner_data.key_reservation_ids,
+                                    owner_data.slot_lease,
+                                )
+                                .await;
+                                return ApiResult::new_success(vec![
+                                    kv_error_to_ret_code(&err);
+                                    owner_data.keys.len()
+                                ]);
+                            }
+                        };
+                        let mut memory_infos = Vec::with_capacity(owner_data.keys.len());
+                        for (key, slot_ref) in owner_data.keys.iter().zip(slot_refs.iter()) {
+                            let memory_info = inner
+                                .build_local_reserve_resident_memory_info(
+                                    key,
+                                    slot_ref.ptr,
+                                    owner_data.value_len as u32,
+                                    slot_size,
+                                    slot_ref.grant_id,
+                                    slot_ref.slot_index,
+                                )
+                                .await;
+                            inner.install_precommit_local_visible_memory_info(
+                                key,
+                                memory_info.clone(),
+                            );
+                            memory_infos.push(memory_info);
+                        }
+                        let mut ret_codes = Vec::with_capacity(owner_data.keys.len());
+                        match inner
+                            .owner_batch_put_start_reserved(start_items, None)
+                            .await
+                        {
+                            Ok(prepared_items) if prepared_items.len() == slot_refs.len() => {
+                                let mut direct_items = Vec::new();
+                                let mut copy_items = Vec::new();
+                                for (idx, (reserved_item, slot_ref)) in prepared_items
+                                    .into_iter()
+                                    .zip(slot_refs.iter().cloned())
+                                    .enumerate()
+                                {
+                                    let item = StagedPutCommitItem {
+                                        idx,
+                                        reserved_item,
+                                        slot_ref,
+                                    };
+                                    if staged_put_uses_direct_local_commit(&item.reserved_item) {
+                                        direct_items.push(item);
+                                    } else {
+                                        copy_items.push(item);
+                                    }
+                                }
+
+                                let mut item_results: Vec<Option<i32>> =
+                                    (0..slot_refs.len()).map(|_| None).collect();
+
+                                if !copy_items.is_empty() {
+                                    let reserved_copy_items = copy_items
+                                        .iter()
+                                        .map(|item| item.reserved_item.clone())
+                                        .collect::<Vec<_>>();
+                                    for item in &copy_items {
+                                        unsafe {
+                                            std::ptr::copy_nonoverlapping(
+                                                item.slot_ref.ptr as *const u8,
+                                                item.reserved_item.src_addr as *mut u8,
+                                                value_len_usize,
+                                            );
+                                        }
+                                    }
+                                    match inner
+                                        .owner_batch_put_commit_reserved(
+                                            reserved_copy_items,
+                                            transfer_concurrency,
+                                        )
+                                        .await
+                                    {
+                                        Ok(copy_results)
+                                            if copy_results.len() == copy_items.len() =>
+                                        {
+                                            for (item, result) in
+                                                copy_items.iter().zip(copy_results.into_iter())
+                                            {
+                                                item_results[item.idx] = Some(match result {
+                                                    Ok(()) => 0,
+                                                    Err(err) => kv_error_to_ret_code(&err),
+                                                });
+                                            }
+                                        }
+                                        Ok(copy_results) => {
+                                            let err = CoreKvError::Api(CoreApiError::Unknown {
+                                                detail: format!(
+                                                    "local_fast_put_commit copy result length mismatch: expected={} got={}",
+                                                    copy_items.len(),
+                                                    copy_results.len()
+                                                ),
+                                            });
+                                            let code = kv_error_to_ret_code(&err);
+                                            for item in &copy_items {
+                                                item_results[item.idx] = Some(code);
+                                            }
+                                        }
+                                        Err(err) => {
+                                            let code = kv_error_to_ret_code(&err);
+                                            for item in &copy_items {
+                                                item_results[item.idx] = Some(code);
+                                            }
+                                        }
+                                    }
+                                    remove_precommit_local_visible_infos_for_items(
+                                        inner,
+                                        &copy_items,
+                                        &memory_infos,
+                                    );
+                                }
+
+                                if !direct_items.is_empty() {
+                                    let direct_done_req_items = direct_items
+                                        .iter()
+                                        .map(|item| BatchPutDoneItemReq {
+                                            key: item.reserved_item.key.clone(),
+                                            put_id: item.reserved_item.put_id,
+                                            lease_id: item.reserved_item.lease_id,
+                                            committed_slot: Some(PutDoneCommittedSlot {
+                                                grant_id: item.slot_ref.grant_id,
+                                                slot_index: item.slot_ref.slot_index,
+                                                slot_size,
+                                                addr: item.slot_ref.ptr,
+                                                base_addr: item.slot_ref.base_addr,
+                                                len: owner_data.value_len,
+                                            }),
+                                            publish_local_cache: false,
+                                        })
+                                        .collect::<Vec<_>>();
+                                    match inner.batch_put_done(direct_done_req_items).await {
+                                        Ok(done_resp)
+                                            if done_resp.items.len() == direct_items.len() =>
+                                        {
+                                            for (item, done_item) in
+                                                direct_items.iter().zip(done_resp.items.into_iter())
+                                            {
+                                                let result =
+                                                    fluxon_kv::rpcresp_kvresult_convert::try_from_code(
+                                                        done_item.error_code,
+                                                        done_item.error_json.clone(),
+                                                    );
+                                                if result.is_ok() {
+                                                    let promote = inner
+                                                        .promote_precommit_local_reserve_resident_slot_if_same(
+                                                            &item.reserved_item.key,
+                                                            item.reserved_item.put_id,
+                                                            memory_infos[item.idx].clone(),
+                                                        );
+                                                    if item.reserved_item.enqueue_write_back_append
+                                                    {
+                                                        if let Err(err) = inner
+                                                            .enqueue_write_back_remote_append(
+                                                                &item.reserved_item.key,
+                                                                item.reserved_item.put_id,
+                                                                item.reserved_item
+                                                                    .preferred_sub_cluster
+                                                                    .as_deref(),
+                                                            )
+                                                            .await
+                                                        {
+                                                            tracing::warn!(
+                                                                "local_fast_put_commit write-back remote append enqueue failed after direct local commit: key={} put_id=({},{}) err={}",
+                                                                item.reserved_item.key,
+                                                                item.reserved_item.put_id.0,
+                                                                item.reserved_item.put_id.1,
+                                                                err
+                                                            );
+                                                        }
+                                                    }
+                                                    inner.record_put_locality(
+                                                        false,
+                                                        owner_data.value_len,
+                                                        0,
+                                                    );
+                                                    item_results[item.idx] = Some(match promote {
+                                                        Ok(()) => 0,
+                                                        Err(err) => kv_error_to_ret_code(&err),
+                                                    });
+                                                } else if let Err(err) = result {
+                                                    item_results[item.idx] =
+                                                        Some(kv_error_to_ret_code(&err));
+                                                    let _ = inner
+                                                        .remove_precommit_local_reserve_resident_slot_if_same(
+                                                            &item.reserved_item.key,
+                                                            &memory_infos[item.idx],
+                                                        );
+                                                }
+                                            }
+                                        }
+                                        Ok(done_resp) => {
+                                            let err = CoreKvError::Api(CoreApiError::Unknown {
+                                                detail: format!(
+                                                    "local_fast_put_commit direct done response length mismatch: expected={} got={}",
+                                                    direct_items.len(),
+                                                    done_resp.items.len()
+                                                ),
+                                            });
+                                            let code = kv_error_to_ret_code(&err);
+                                            for item in &direct_items {
+                                                item_results[item.idx] = Some(code);
+                                            }
+                                            remove_precommit_local_visible_infos_for_items(
+                                                inner,
+                                                &direct_items,
+                                                &memory_infos,
+                                            );
+                                        }
+                                        Err(err) => {
+                                            let code = kv_error_to_ret_code(&err);
+                                            for item in &direct_items {
+                                                item_results[item.idx] = Some(code);
+                                            }
+                                            let _ =
+                                                revoke_staged_put_items(inner, &direct_items).await;
+                                            remove_precommit_local_visible_infos_for_items(
+                                                inner,
+                                                &direct_items,
+                                                &memory_infos,
+                                            );
+                                        }
+                                    }
+                                }
+
+                                for item in item_results {
+                                    ret_codes.push(item.unwrap_or_else(|| {
+                                        let err = CoreKvError::Api(CoreApiError::Unknown {
+                                            detail: "local_fast_put_commit result slot missing"
+                                                .to_string(),
+                                        });
+                                        kv_error_to_ret_code(&err)
+                                    }));
+                                }
+                            }
+                            Ok(prepared_items) => {
+                                let err = CoreKvError::Api(CoreApiError::Unknown {
+                                    detail: format!(
+                                        "local_fast_put_commit final reserve length mismatch: expected={} got={}",
+                                        slot_refs.len(),
+                                        prepared_items.len()
+                                    ),
+                                });
+                                let _ = inner.owner_batch_put_abort_reserved(prepared_items).await;
+                                remove_precommit_local_visible_infos(
+                                    inner,
+                                    &owner_data.keys,
+                                    &memory_infos,
+                                );
+                                ret_codes = vec![kv_error_to_ret_code(&err); owner_data.keys.len()];
+                            }
+                            Err(err) => {
+                                remove_precommit_local_visible_infos(
+                                    inner,
+                                    &owner_data.keys,
+                                    &memory_infos,
+                                );
+                                ret_codes = vec![kv_error_to_ret_code(&err); owner_data.keys.len()];
+                            }
+                        }
+                        if let Err(err) =
+                            release_put_key_reservations_only(inner, owner_data.key_reservation_ids)
+                                .await
+                        {
+                            tracing::warn!(
+                                "local_fast_put_commit key reservation cleanup failed: {}",
+                                err
+                            );
+                        }
+                        ret_codes
+                    }
+                };
+                cleanup_plan_registry_entry(&plan_registry, plan_ptr_usize);
+                ApiResult::new_success(ret_codes)
+            };
+            match KvFuture::new(future, runtime_handle, py) {
+                Ok(v) => ApiResult::new_success(v.into_any()),
+                Err(e) => ApiResult::new_error(new_general_error(
+                    py,
+                    &format!("Failed to create future: {}", e),
+                )),
+            }
+        }
+
+        local_fast_put_commit_inner(self, plan_ptr, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (plan_ptr))]
+    fn put_abort(&self, plan_ptr: u64, py: Python) -> PyObject {
+        fn put_abort_inner(client: &KvClient, plan_ptr: u64, py: Python) -> ApiResult<PyObject> {
+            let plan_ptr_usize = match plan_ptr_u64_to_usize(plan_ptr, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let removed = {
+                let mut guard = client
+                    .plan_registry
+                    .write()
+                    .expect("plan_registry poisoned");
+                guard.remove(&plan_ptr_usize)
+            };
+            let Some(FluxonPlanRegistryEntry::Put(plan)) = removed else {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "put_abort requires a live put plan_ptr",
+                ));
+            };
+            let plan_data = {
+                let mut state_guard = plan.state.lock().expect("put plan state poisoned");
+                match std::mem::replace(&mut *state_guard, FluxonPutPlanState::Committing) {
+                    FluxonPutPlanState::Prepared(data) => data,
+                    FluxonPutPlanState::Committing => {
+                        return ApiResult::new_error(new_invalid_argument_error(
+                            py,
+                            "put_abort cannot be used after local_fast_put_commit",
+                        ));
+                    }
+                }
+            };
+            let abort_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    match plan_data {
+                        StagedPutPlanData::External(external_data) => {
+                            let external_api_view = framework.external_client_api_view();
+                            let inner = external_api_view.external_client_api().inner();
+                            for (key, item) in
+                                external_data.keys.iter().zip(external_data.items.iter())
+                            {
+                                inner
+                                    .external_put_revoke_rpc(ExternalPutRevokeReq {
+                                        key: key.clone(),
+                                        put_id: Some(item.put_id),
+                                        started_time: external_data.started_time,
+                                    })
+                                    .await?;
+                            }
+                            Ok::<(), CoreKvError>(())
+                        }
+                        StagedPutPlanData::Owner(owner_data) => {
+                            let client_kv_api_view = framework.client_kv_api_view();
+                            let inner = client_kv_api_view.client_kv_api().inner();
+                            release_staged_put_resources(
+                                inner,
+                                owner_data.key_reservation_ids,
+                                owner_data.slot_lease,
+                            )
+                            .await
+                        }
+                    }
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match abort_result {
+                Ok(()) => ApiResult::new_success(0i32.into_py(py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "put_abort failed",
+                )),
+            }
+        }
+
+        put_abort_inner(self, plan_ptr, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (keys, concurrency=None))]
+    fn get_views(&self, keys: Vec<String>, concurrency: Option<usize>, py: Python) -> PyObject {
+        fn get_views_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            concurrency: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_views requires at least one key",
+                ));
+            }
+            if matches!(concurrency, Some(0)) {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "batch_concurrency must be > 0",
+                ));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let keys_for_get = keys.clone();
+            let locality_counters = client.locality_counters.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    let mut holders = Vec::with_capacity(keys_for_get.len());
+                    let mut value_ptrs = Vec::with_capacity(keys_for_get.len());
+                    for key in &keys_for_get {
+                        match framework.kv_get(key).await? {
+                            KvGetResult::Owner(Some(holder)) => {
+                                let bytes = holder.bytes().len() as u64;
+                                locality_counters.record_l2_hit(false, bytes);
+                                locality_counters.record_get(false, bytes, 0);
+                                value_ptrs.push(holder.bytes().as_ptr() as u64);
+                                holders.push(StagedGetViewHolder::Owner { _holder: holder });
+                            }
+                            KvGetResult::External(Some(holder)) => {
+                                let bytes = holder.bytes().len() as u64;
+                                locality_counters.record_l2_hit(true, bytes);
+                                locality_counters.record_get(true, bytes, 0);
+                                value_ptrs.push(holder.bytes().as_ptr() as u64);
+                                holders.push(StagedGetViewHolder::External { _holder: holder });
+                            }
+                            KvGetResult::Owner(None) | KvGetResult::External(None) => {
+                                return Err(CoreKvError::Api(CoreApiError::KeyNotFound {
+                                    key: key.clone(),
+                                }));
+                            }
+                        }
+                    }
+                    Ok::<_, CoreKvError>((value_ptrs, holders))
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            let (value_ptrs, holders) = match result {
+                Ok(v) => v,
+                Err(err) => {
+                    return ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "get_views failed",
+                    ));
+                }
+            };
+            let plan = Arc::new(FluxonGetViewsPlan {
+                blob: build_plan_blob(&value_ptrs),
+                _holders: holders,
+            });
+            let plan_ptr = plan_ptr_from_blob(plan.blob.as_ref());
+            client
+                .plan_registry
+                .write()
+                .expect("plan_registry poisoned")
+                .insert(plan_ptr, FluxonPlanRegistryEntry::Get(plan));
+            ApiResult::new_success((plan_ptr as u64).into_py(py))
+        }
+
+        get_views_inner(self, keys, concurrency, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (plan_ptr))]
+    fn release_views(&self, plan_ptr: u64, py: Python) -> PyObject {
+        fn release_views_inner(
+            client: &KvClient,
+            plan_ptr: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let plan_ptr_usize = match plan_ptr_u64_to_usize(plan_ptr, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let removed = {
+                let mut guard = client
+                    .plan_registry
+                    .write()
+                    .expect("plan_registry poisoned");
+                guard.remove(&plan_ptr_usize)
+            };
+            match removed {
+                Some(FluxonPlanRegistryEntry::Get(_plan)) => {
+                    ApiResult::new_success(0i32.into_py(py))
+                }
+                Some(FluxonPlanRegistryEntry::Put(_)) => ApiResult::new_error(
+                    new_invalid_argument_error(py, "release_views requires a get-views plan_ptr"),
+                ),
+                None => ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "release_views requires a live get-views plan_ptr",
+                )),
+            }
+        }
+
+        release_views_inner(self, plan_ptr, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (keys, prefix_best_effort=true, atomic_group_lens=None, concurrency=None))]
+    fn get_start(
+        &self,
+        keys: Vec<String>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+        concurrency: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        fn get_start_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            prefix_best_effort: bool,
+            atomic_group_lens: Option<Vec<usize>>,
+            concurrency: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_start requires at least one key",
+                ));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_start is supported only in external-client mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let batch_concurrency = match concurrency.unwrap_or(DEFAULT_PYO3_BATCH_CONCURRENCY) {
+                0 => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_concurrency must be > 0",
+                    ));
+                }
+                v => v,
+            };
+            let framework_for_start = framework.clone();
+            let started = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_start
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .get_start(
+                            keys,
+                            prefix_best_effort,
+                            atomic_group_lens,
+                            batch_concurrency,
+                        )
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match started {
+                Ok(v) => ApiResult::new_success(external_get_start_result_to_py(&v, py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "get_start failed",
+                )),
+            }
+        }
+
+        get_start_inner(
+            self,
+            keys,
+            prefix_best_effort,
+            atomic_group_lens,
+            concurrency,
+            py,
+        )
+        .into_py_object(py)
+    }
+
+    #[pyo3(signature = (handle))]
+    fn get_transfer(&self, handle: u64, py: Python) -> PyObject {
+        fn get_transfer_inner(client: &KvClient, handle: u64, py: Python) -> ApiResult<PyObject> {
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_transfer is supported only in external-client mode",
+                ));
+            }
+            let framework_for_transfer = framework.clone();
+            let transfer_results = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_transfer
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .get_transfer(handle)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            let transfer_results = match transfer_results {
+                Ok(v) => v,
+                Err(err) => {
+                    return ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "get_transfer failed",
+                    ));
+                }
+            };
+            let mut value_ptrs = Vec::with_capacity(transfer_results.len());
+            let mut holders = Vec::with_capacity(transfer_results.len());
+            for (idx, item) in transfer_results.into_iter().enumerate() {
+                match item {
+                    Ok(Some(holder)) => {
+                        value_ptrs.push(holder.bytes().as_ptr() as u64);
+                        holders.push(StagedGetViewHolder::External { _holder: holder });
+                    }
+                    Ok(None) => {
+                        return ApiResult::new_error(new_key_not_found_error(
+                            py,
+                            &format!("get_transfer external transfer missed key index {}", idx),
+                            None,
+                        ));
+                    }
+                    Err(err) => {
+                        return ApiResult::new_error(crate::error::py_error_from_kv_error(
+                            py,
+                            &err,
+                            "get_transfer external transfer item failed",
+                        ));
+                    }
+                }
+            }
+            let view_plan = Arc::new(FluxonGetViewsPlan {
+                blob: build_plan_blob(&value_ptrs),
+                _holders: holders,
+            });
+            let plan_ptr = plan_ptr_from_blob(view_plan.blob.as_ref());
+            let mut registry_guard = client
+                .plan_registry
+                .write()
+                .expect("plan_registry poisoned");
+            registry_guard.insert(plan_ptr, FluxonPlanRegistryEntry::Get(view_plan));
+            drop(registry_guard);
+            ApiResult::new_success((plan_ptr as u64).into_py(py))
+        }
+
+        get_transfer_inner(self, handle, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (handle))]
+    fn cancel_get_transfer(&self, handle: u64, py: Python) -> PyObject {
+        fn cancel_get_transfer_inner(
+            client: &KvClient,
+            handle: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "cancel_get_transfer is supported only in external-client mode",
+                ));
+            }
+            let framework_for_cancel = framework.clone();
+            let cancel_res = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_cancel
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .cancel_get_transfer(handle)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match cancel_res {
+                Ok(()) => ApiResult::new_success(0i32.into_py(py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "cancel_get_transfer failed",
+                )),
+            }
+        }
+
+        cancel_get_transfer_inner(self, handle, py).into_py_object(py)
+    }
+
+    /// Allocate a fluxon-kv lease id synchronously.
+    /// Always allocate a new lease id (no reuse by requested id).
+    /// Allocate with the provided TTL seconds (must be >= MIN_CLIENT_TTL_SECONDS).
+    #[pyo3(signature = (ttl_seconds))]
+    fn allocate_lease(&self, ttl_seconds: u64, py: Python) -> PyObject {
+        fn allocate_lease_inner(
+            client: &KvClient,
+            ttl_seconds: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            // Enforce minimum TTL at the PyO3 boundary so obvious mistakes fail fast.
+            if ttl_seconds
+                < fluxon_kv::master_lease_manager::MasterLeaseManager::MIN_CLIENT_TTL_SECONDS
+            {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    &format!(
+                        "allocate_lease(ttl_seconds) requires ttl_seconds >= {} seconds",
+                        fluxon_kv::master_lease_manager::MasterLeaseManager::MIN_CLIENT_TTL_SECONDS,
+                    ),
+                ));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            // Blocking call on the client's runtime; simple and predictable for callers.
+            let r: Result<u64, String> = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework
+                        .kv_allocate_lease(ttl_seconds)
+                        .await
+                        .map_err(|e| e.to_string())
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => Err(format!("runtime bridge failed: {}", e)),
+            };
+            match r {
+                Ok(id) => ApiResult::new_success(Python::with_gil(|py| id.into_py(py))),
+                Err(e) => ApiResult::new_error(Python::with_gil(|py| {
+                    new_network_error(py, &format!("Allocate lease failed: {}", e), None)
+                })),
+            }
+        }
+        allocate_lease_inner(self, ttl_seconds, py).into_py_object(py)
+    }
+
+    /// Keepalive a lease synchronously. Type must be specified to avoid ambiguity.
+    /// This uses the lease's existing TTL on the master.
+    #[pyo3(signature = (lease_id, lease_type))]
+    fn keepalive_lease(
+        &self,
+        lease_id: u64,
+        lease_type: &Bound<'_, PyAny>,
+        py: Python,
+    ) -> PyObject {
+        fn keepalive_lease_inner(
+            client: &KvClient,
+            lease_id: u64,
+            lease_type: &Bound<'_, PyAny>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            // Accept simple enum-like strings: "kvclient" | "etcd"
+            let lease_type_str = match lease_type.extract::<String>() {
+                Ok(s) => s.to_ascii_lowercase(),
+                Err(_) => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "lease_type must be 'kvclient' or 'etcd'",
+                    ));
+                }
+            };
+
+            if lease_type_str != "kvclient" {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "keepalive_lease(type=etcd) is not supported in fluxon_pyo3; use fluxon_mq.LeaseManagerHandle for etcd leases",
+                ));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let r: Result<(), String> = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework
+                        .kv_keepalive_lease(lease_id)
+                        .await
+                        .map_err(|e| e.to_string())
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => Err(format!("runtime bridge failed: {}", e)),
+            };
+            match r {
+                Ok(_) => {
+                    ApiResult::new_success(Python::with_gil(|py| new_none_success_instance(py)))
+                }
+                Err(e) => ApiResult::new_error(Python::with_gil(|py| {
+                    new_network_error(py, &format!("Keepalive lease failed: {}", e), None)
+                })),
+            }
+        }
+        keepalive_lease_inner(self, lease_id, lease_type, py).into_py_object(py)
+    }
+
+    /// Put a key-value pair (non-blocking) by encoding a flat dict from raw entries.
+    ///
+    /// `ptrs` is a list of `(type_id, dict_key_ptr, dict_key_len, val_u64, val_len, extra)`:
+    /// - `dict_key_ptr/dict_key_len`: UTF-8 bytes of the dict field key.
+    /// - For scalar types (bool/int64/float64), `val_u64` stores raw bits and `val_len` is fixed.
     /// - For bytes-like types (string/bytes), `val_u64` stores a pointer and `val_len` is the byte length.
     /// - `extra`: reserved for future use.
     ///
@@ -2938,13 +4927,15 @@ impl KvClient {
     /// on the caller to keep the pointed-to memory alive until the async call completes.
     ///
     /// The backend encoding/copy runs on the Rust runtime without holding the Python GIL.
-    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, callback=None))]
+    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, callback=None))]
     fn put(
         &self,
         key: &str,
         ptrs: Vec<(u8, u64, u32, u64, u32, Option<u32>)>,
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         callback: Option<PyObject>,
         py: Python,
     ) -> PyObject {
@@ -2954,6 +4945,8 @@ impl KvClient {
             ptrs: Vec<(u8, usize, u32, u64, u32, Option<u32>)>,
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
+            reject_if_exist_same_key: bool,
+            write_through: bool,
             callback: Option<PyObject>,
             py: Python,
         ) -> ApiResult<PyObject> {
@@ -2982,6 +4975,12 @@ impl KvClient {
                 if reject_if_inflight_same_key {
                     o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
                 }
+                if reject_if_exist_same_key {
+                    o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
+                }
+                if write_through {
+                    o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
+                }
                 o
             };
 
@@ -3041,6 +5040,8 @@ impl KvClient {
             ptrs_owned,
             lease_id,
             reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
             callback,
             py,
         )
@@ -3048,13 +5049,15 @@ impl KvClient {
     }
 
     /// Put a key-value pair and wait for completion before returning.
-    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false))]
+    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true))]
     fn put_blocking(
         &self,
         key: &str,
         ptrs: Vec<(u8, u64, u32, u64, u32, Option<u32>)>,
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
         py: Python,
     ) -> PyObject {
         fn put_blocking_inner(
@@ -3063,6 +5066,8 @@ impl KvClient {
             ptrs: Vec<(u8, usize, u32, u64, u32, Option<u32>)>,
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
+            reject_if_exist_same_key: bool,
+            write_through: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if ptrs.len() > (u32::MAX as usize) {
@@ -3094,6 +5099,16 @@ impl KvClient {
                     .0
                     .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
             }
+            if reject_if_exist_same_key {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
+            }
+            if write_through {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
+            }
             let result = match py.allow_threads(|| {
                 runtime.run_async_from_sync(async {
                     unsafe { framework.kv_put_ptrs(&key, ptrs, put_opts).await }
@@ -3137,10 +5152,538 @@ impl KvClient {
         }
         put_blocking_inner(
             self,
-            key_owned,
-            ptrs_owned,
+            key_owned,
+            ptrs_owned,
+            lease_id,
+            reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
+            py,
+        )
+        .into_py_object(py)
+    }
+
+    /// Put a batch of key-value pairs and wait for completion before returning.
+    ///
+    /// Each item uses the same flatdict encoding contract as `put_blocking()`.
+    #[pyo3(signature = (keys, ptrs_groups, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, concurrency=None))]
+    fn batch_put_blocking(
+        &self,
+        keys: Vec<String>,
+        ptrs_groups: Vec<Vec<(u8, u64, u32, u64, u32, Option<u32>)>>,
+        lease_id: Option<u64>,
+        reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
+        concurrency: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        fn batch_put_blocking_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            ptrs_groups: Vec<Vec<(u8, usize, u32, u64, u32, Option<u32>)>>,
+            lease_id: Option<u64>,
+            reject_if_inflight_same_key: bool,
+            reject_if_exist_same_key: bool,
+            write_through: bool,
+            concurrency: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.len() != ptrs_groups.len() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "batch_put_blocking requires keys and ptrs_groups to have the same length",
+                ));
+            }
+            if keys.is_empty() {
+                return ApiResult::new_success(Vec::<PyObject>::new().into_py(py));
+            }
+
+            let batch_concurrency = match concurrency.unwrap_or(DEFAULT_PYO3_BATCH_CONCURRENCY) {
+                0 => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_concurrency must be > 0",
+                    ));
+                }
+                v => v,
+            };
+
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework = borrow_stable_owner(&framework);
+            let keys_for_results = keys;
+
+            let mut put_opts = fluxon_kv::client_kv_api::PutOptionalArgs::new();
+            if let Some(id) = lease_id {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
+            }
+            if reject_if_inflight_same_key {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
+            }
+            if reject_if_exist_same_key {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
+            }
+            if write_through {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
+            }
+
+            if !framework.is_external_mode() {
+                let framework_for_backend = framework.clone();
+                let keys_for_backend = keys_for_results.clone();
+                let backend_result = match py.allow_threads(|| {
+                    runtime.run_async_from_sync(async move {
+                        unsafe {
+                            framework_for_backend
+                                .client_kv_api_view()
+                                .client_kv_api()
+                                .inner()
+                                .batch_put_flat_dict_ptrs(
+                                    keys_for_backend,
+                                    ptrs_groups,
+                                    put_opts,
+                                    batch_concurrency,
+                                )
+                                .await
+                        }
+                    })
+                }) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!("runtime bridge failed: {}", e),
+                        ));
+                    }
+                };
+
+                return Python::with_gil(|py| match backend_result {
+                    Ok(per_item_results) => {
+                        let out = PyList::empty_bound(py);
+                        for (key, item_result) in keys_for_results
+                            .into_iter()
+                            .zip(per_item_results.into_iter())
+                        {
+                            let item = match item_result {
+                                Ok(()) => crate::error::new_result_success(
+                                    py,
+                                    new_none_success_instance(py),
+                                ),
+                                Err(err) => crate::error::new_result_error(
+                                    py,
+                                    crate::error::py_error_from_kv_error(
+                                        py,
+                                        &err,
+                                        &format!("Put failed for key {}", key),
+                                    ),
+                                ),
+                            };
+                            out.append(item).expect("append batch_put result");
+                        }
+                        ApiResult::new_success(out.into_py(py))
+                    }
+                    Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "Batch put failed",
+                    )),
+                });
+            }
+
+            let framework_for_backend = framework.clone();
+            let keys_for_backend = keys_for_results.clone();
+            let backend_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    unsafe {
+                        framework_for_backend
+                            .external_client_api_view()
+                            .external_client_api()
+                            .inner()
+                            .batch_put_flat_dict_ptrs(
+                                keys_for_backend,
+                                ptrs_groups,
+                                put_opts,
+                                batch_concurrency,
+                            )
+                            .await
+                    }
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+
+            Python::with_gil(|py| match backend_result {
+                Ok(per_item_results) => {
+                    let out = PyList::empty_bound(py);
+                    for (key, item_result) in keys_for_results
+                        .into_iter()
+                        .zip(per_item_results.into_iter())
+                    {
+                        let item = match item_result {
+                            Ok(()) => {
+                                crate::error::new_result_success(py, new_none_success_instance(py))
+                            }
+                            Err(err) => {
+                                let err_obj = crate::error::py_error_from_kv_error(
+                                    py,
+                                    &err,
+                                    &format!("Put failed for key {}", key),
+                                );
+                                crate::error::new_result_error(py, err_obj)
+                            }
+                        };
+                        out.append(item).expect("append batch_put result");
+                    }
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "Batch put failed",
+                )),
+            })
+        }
+
+        let mut ptrs_groups_owned: Vec<Vec<(u8, usize, u32, u64, u32, Option<u32>)>> =
+            Vec::with_capacity(ptrs_groups.len());
+        for ptrs in ptrs_groups.into_iter() {
+            let mut ptrs_owned: Vec<(u8, usize, u32, u64, u32, Option<u32>)> =
+                Vec::with_capacity(ptrs.len());
+            for (type_id, dict_key_ptr, dict_key_len, val_u64, val_len, extra) in ptrs.into_iter() {
+                let dict_key_ptr_usize: usize = match usize::try_from(dict_key_ptr) {
+                    Ok(v) => v,
+                    Err(_) => {
+                        return ApiResult::<PyObject>::new_error(new_invalid_argument_error(
+                            py,
+                            "dict_key_ptr out of range",
+                        ))
+                        .into_py_object(py);
+                    }
+                };
+                ptrs_owned.push((
+                    type_id,
+                    dict_key_ptr_usize,
+                    dict_key_len,
+                    val_u64,
+                    val_len,
+                    extra,
+                ));
+            }
+            if ptrs_owned.len() > (u32::MAX as usize) {
+                return ApiResult::<PyObject>::new_error(new_invalid_argument_error(
+                    py,
+                    "flat dict too large",
+                ))
+                .into_py_object(py);
+            }
+            ptrs_groups_owned.push(ptrs_owned);
+        }
+
+        batch_put_blocking_inner(
+            self,
+            keys,
+            ptrs_groups_owned,
+            lease_id,
+            reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
+            concurrency,
+            py,
+        )
+        .into_py_object(py)
+    }
+
+    /// Register a caller-owned host buffer range used by batch zero-copy paths.
+    #[pyo3(signature = (ptr, len))]
+    fn register_buffer(&self, ptr: u64, len: u64, py: Python) -> PyObject {
+        fn register_buffer_inner(
+            client: &KvClient,
+            ptr: u64,
+            len: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let ptr_usize = match usize::try_from(ptr) {
+                Ok(v) => v,
+                Err(_) => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "register_buffer ptr out of range",
+                    ));
+                }
+            };
+            let len_usize = match usize::try_from(len) {
+                Ok(v) => v,
+                Err(_) => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "register_buffer len out of range",
+                    ));
+                }
+            };
+            if ptr_usize == 0 && len_usize > 0 {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "register_buffer ptr must be non-zero when len > 0",
+                ));
+            }
+            let mut guard = client
+                .registered_buffers
+                .write()
+                .expect("registered_buffers poisoned");
+            guard.register(ptr_usize, len_usize);
+            ApiResult::new_success(0i32.into_py(py))
+        }
+
+        register_buffer_inner(self, ptr, len, py).into_py_object(py)
+    }
+
+    /// Native blocking batch put path for payload pointers.
+    #[pyo3(signature = (keys, payload_ptrs, payload_sizes, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true))]
+    fn batch_put_from(
+        &self,
+        keys: Vec<String>,
+        payload_ptrs: Vec<u64>,
+        payload_sizes: Vec<u32>,
+        lease_id: Option<u64>,
+        reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+        write_through: bool,
+        py: Python,
+    ) -> PyObject {
+        fn batch_put_from_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            payload_ptrs: Vec<u64>,
+            payload_sizes: Vec<u32>,
+            lease_id: Option<u64>,
+            reject_if_inflight_same_key: bool,
+            reject_if_exist_same_key: bool,
+            write_through: bool,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.len() != payload_ptrs.len() || keys.len() != payload_sizes.len() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "batch_put_from requires keys, payload_ptrs, and payload_sizes to have the same length",
+                ));
+            }
+            if keys.is_empty() {
+                return ApiResult::new_success(Vec::<i32>::new().into_py(py));
+            }
+
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+
+            let registered = client
+                .registered_buffers
+                .read()
+                .expect("registered_buffers poisoned");
+            let mut payload_ptrs_usize = Vec::with_capacity(payload_ptrs.len());
+            for (&ptr, &size_u32) in payload_ptrs.iter().zip(payload_sizes.iter()) {
+                let ptr_usize = match usize::try_from(ptr) {
+                    Ok(v) => v,
+                    Err(_) => {
+                        return ApiResult::new_error(new_invalid_argument_error(
+                            py,
+                            "batch_put_from payload_ptr out of range",
+                        ));
+                    }
+                };
+                let size = size_u32 as usize;
+                if ptr_usize == 0 && size > 0 {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_put_from payload_ptr must be non-zero when payload_size > 0",
+                    ));
+                }
+                if !registered.ranges.is_empty() && !registered.contains(ptr_usize, size) {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_put_from payload range is not inside any registered buffer",
+                    ));
+                }
+                payload_ptrs_usize.push(ptr_usize);
+            }
+            drop(registered);
+
+            let framework = borrow_stable_owner(&framework);
+            let mut put_opts = fluxon_kv::client_kv_api::PutOptionalArgs::new();
+            if let Some(id) = lease_id {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
+            }
+            if reject_if_inflight_same_key {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
+            }
+            if reject_if_exist_same_key {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
+            }
+            if write_through {
+                put_opts
+                    .0
+                    .push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
+            }
+
+            let keys_for_backend = keys.clone();
+            let ptrs_groups = keys_for_backend
+                .iter()
+                .zip(payload_ptrs_usize.iter())
+                .zip(payload_sizes.iter())
+                .map(|((_key, payload_ptr), payload_size)| {
+                    vec![(
+                        5u8,
+                        b"payload".as_ptr() as usize,
+                        7u32,
+                        *payload_ptr as u64,
+                        *payload_size,
+                        None,
+                    )]
+                })
+                .collect::<Vec<_>>();
+            let batch_concurrency = DEFAULT_PYO3_BATCH_CONCURRENCY;
+
+            if !framework.is_external_mode() {
+                let framework_for_backend = framework.clone();
+                let backend_result = match py.allow_threads(|| {
+                    runtime.run_async_from_sync(async move {
+                        unsafe {
+                            framework_for_backend
+                                .client_kv_api_view()
+                                .client_kv_api()
+                                .inner()
+                                .batch_put_flat_dict_ptrs(
+                                    keys_for_backend,
+                                    ptrs_groups,
+                                    put_opts,
+                                    batch_concurrency,
+                                )
+                                .await
+                        }
+                    })
+                }) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!("runtime bridge failed: {}", e),
+                        ));
+                    }
+                };
+                return match backend_result {
+                    Ok(per_item_results) => ApiResult::new_success(
+                        per_item_results
+                            .into_iter()
+                            .map(|item| match item {
+                                Ok(()) => 0,
+                                Err(err) => kv_error_to_ret_code(&err),
+                            })
+                            .collect::<Vec<_>>()
+                            .into_py(py),
+                    ),
+                    Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "Batch put failed",
+                    )),
+                };
+            }
+
+            let framework_for_backend = framework.clone();
+            let backend_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    unsafe {
+                        framework_for_backend
+                            .external_client_api_view()
+                            .external_client_api()
+                            .inner()
+                            .batch_put_flat_dict_ptrs(
+                                keys_for_backend,
+                                ptrs_groups,
+                                put_opts,
+                                batch_concurrency,
+                            )
+                            .await
+                    }
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+
+            match backend_result {
+                Ok(per_item_results) => ApiResult::new_success(
+                    per_item_results
+                        .into_iter()
+                        .map(|item| match item {
+                            Ok(()) => 0,
+                            Err(err) => kv_error_to_ret_code(&err),
+                        })
+                        .collect::<Vec<_>>()
+                        .into_py(py),
+                ),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "Batch put failed",
+                )),
+            }
+        }
+
+        batch_put_from_inner(
+            self,
+            keys,
+            payload_ptrs,
+            payload_sizes,
             lease_id,
             reject_if_inflight_same_key,
+            reject_if_exist_same_key,
+            write_through,
             py,
         )
         .into_py_object(py)
@@ -3322,6 +5865,195 @@ impl KvClient {
         get_blocking_inner(self, key, py).into_py_object(py)
     }
 
+    /// Get a batch of keys and wait for completion before returning.
+    ///
+    /// Returns a Python list of per-item `Result` objects, aligned with
+    /// `get_blocking()` semantics.
+    #[pyo3(signature = (keys, concurrency=None))]
+    fn batch_get_blocking(
+        &self,
+        keys: Vec<String>,
+        concurrency: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        fn batch_get_blocking_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            concurrency: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_success(Vec::<PyObject>::new().into_py(py));
+            }
+
+            let batch_concurrency = match concurrency.unwrap_or(DEFAULT_PYO3_BATCH_CONCURRENCY) {
+                0 => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_concurrency must be > 0",
+                    ));
+                }
+                v => v,
+            };
+
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework = borrow_stable_owner(&framework);
+            let keys_for_results = keys;
+
+            if !framework.is_external_mode() {
+                let framework_for_backend = framework.clone();
+                let keys_for_backend = keys_for_results.clone();
+                let backend_result = match py.allow_threads(|| {
+                    runtime.run_async_from_sync(async move {
+                        framework_for_backend
+                            .client_kv_api_view()
+                            .client_kv_api()
+                            .inner()
+                            .batch_get(keys_for_backend, batch_concurrency)
+                            .await
+                    })
+                }) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!("runtime bridge failed: {}", e),
+                        ));
+                    }
+                };
+
+                return Python::with_gil(|py| match backend_result {
+                    Ok(per_item_results) => {
+                        let out = PyList::empty_bound(py);
+                        for (key, item_result) in keys_for_results
+                            .into_iter()
+                            .zip(per_item_results.into_iter())
+                        {
+                            let item = match item_result {
+                                Ok(Some((rust_holder, _remote_info))) => {
+                                    let mem_holder = MemHolder::new(rust_holder);
+                                    match mem_holder.into_py_mem_holder(py) {
+                                        ApiResult::Success(py_holder) => {
+                                            crate::error::new_result_success(py, py_holder)
+                                        }
+                                        ApiResult::Error(err) => {
+                                            crate::error::new_result_error(py, err)
+                                        }
+                                    }
+                                }
+                                Ok(None) => crate::error::new_result_error(
+                                    py,
+                                    new_key_not_found_error(
+                                        py,
+                                        &format!("Key not found: {}", key),
+                                        Some(&key),
+                                    ),
+                                ),
+                                Err(err) => crate::error::new_result_error(
+                                    py,
+                                    crate::error::py_error_from_kv_error(
+                                        py,
+                                        &err,
+                                        &format!("Get failed for key {}", key),
+                                    ),
+                                ),
+                            };
+                            out.append(item).expect("append batch_get result");
+                        }
+                        ApiResult::new_success(out.into_py(py))
+                    }
+                    Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "Batch get failed",
+                    )),
+                });
+            }
+
+            let framework_for_backend = framework.clone();
+            let keys_for_backend = keys_for_results.clone();
+            let backend_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_backend
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .batch_get(keys_for_backend, batch_concurrency)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+
+            Python::with_gil(|py| match backend_result {
+                Ok(per_item_results) => {
+                    let out = PyList::empty_bound(py);
+                    for (key, item_result) in keys_for_results
+                        .into_iter()
+                        .zip(per_item_results.into_iter())
+                    {
+                        let item = match item_result {
+                            Ok(Some(external_mem_holder)) => {
+                                let pyo3_external = ExternalMemHolder::new(external_mem_holder);
+                                match pyo3_external.into_py_mem_holder(py) {
+                                    ApiResult::Success(py_holder) => {
+                                        crate::error::new_result_success(py, py_holder)
+                                    }
+                                    ApiResult::Error(err) => {
+                                        crate::error::new_result_error(py, err)
+                                    }
+                                }
+                            }
+                            Ok(None) => crate::error::new_result_error(
+                                py,
+                                new_key_not_found_error(
+                                    py,
+                                    &format!("Key not found: {}", key),
+                                    Some(&key),
+                                ),
+                            ),
+                            Err(err) => crate::error::new_result_error(
+                                py,
+                                crate::error::py_error_from_kv_error(
+                                    py,
+                                    &err,
+                                    &format!("Get failed for key {}", key),
+                                ),
+                            ),
+                        };
+                        out.append(item).expect("append batch_get result");
+                    }
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "Batch get failed",
+                )),
+            })
+        }
+
+        batch_get_blocking_inner(self, keys, concurrency, py).into_py_object(py)
+    }
+
     /// Delete a key (synchronous from Python; only put/get use KvFuture)
     #[pyo3(signature = (key, callback=None))]
     fn delete(&self, key: String, callback: Option<PyObject>, py: Python) -> PyObject {
@@ -3416,9 +6148,84 @@ impl KvClient {
         metrics_snapshot_inner(self, py).into_py_object(py)
     }
 
+    /// Async snapshot for Fluxon KV locality and IO counters.
+    fn observability_snapshot_async(&self, py: Python) -> PyObject {
+        fn observability_snapshot_async_inner(
+            client: &KvClient,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let _framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime_handle = match client.runtime.as_ref() {
+                Some(v) => v.handle().clone(),
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let locality_counters = client.locality_counters.clone();
+            let future = async move {
+                let metrics = locality_counters.snapshot();
+                Python::with_gil(|py| {
+                    let out = PyDict::new_bound(py);
+                    out.set_item("l2_local_hit_pages", metrics.l2_local_hit_pages)
+                        .expect("set l2_local_hit_pages");
+                    out.set_item("l2_local_hit_bytes", metrics.l2_local_hit_bytes)
+                        .expect("set l2_local_hit_bytes");
+                    out.set_item("l2_remote_hit_pages", metrics.l2_remote_hit_pages)
+                        .expect("set l2_remote_hit_pages");
+                    out.set_item("l2_remote_hit_bytes", metrics.l2_remote_hit_bytes)
+                        .expect("set l2_remote_hit_bytes");
+                    let io = PyDict::new_bound(py);
+                    for (key, item) in [
+                        ("put_local", metrics.put_local.clone()),
+                        ("put_remote", metrics.put_remote.clone()),
+                        ("get_local", metrics.get_local.clone()),
+                        ("get_remote", metrics.get_remote.clone()),
+                    ] {
+                        let entry = PyDict::new_bound(py);
+                        entry
+                            .set_item("op_count", item.op_count)
+                            .expect("set op_count");
+                        entry.set_item("bytes", item.bytes).expect("set bytes");
+                        entry
+                            .set_item("transfer_us", item.transfer_us)
+                            .expect("set transfer_us");
+                        entry
+                            .set_item("bandwidth_gbps", item.bandwidth_gbps())
+                            .expect("set bandwidth_gbps");
+                        io.set_item(key, entry).expect("set io entry");
+                    }
+                    out.set_item("io", io).expect("set io");
+                    ApiResult::new_success(out.into_py(py))
+                })
+            };
+            match KvFuture::new(future, runtime_handle, py) {
+                Ok(py_future) => ApiResult::new_success(py_future.into_any()),
+                Err(e) => ApiResult::new_error(new_general_error(
+                    py,
+                    &format!("Failed to create future: {}", e),
+                )),
+            }
+        }
+
+        observability_snapshot_async_inner(self, py).into_py_object(py)
+    }
+
     /// Check if a key exists (synchronous; returns bool wrapped in Result)
-    fn is_exist(&self, key: String, py: Python) -> PyObject {
-        fn is_exist_inner(client: &KvClient, key: String, py: Python) -> ApiResult<PyObject> {
+    #[pyo3(signature = (key, allow_local_snapshot=false))]
+    fn is_exist(&self, key: String, allow_local_snapshot: bool, py: Python) -> PyObject {
+        fn is_exist_inner(
+            client: &KvClient,
+            key: String,
+            allow_local_snapshot: bool,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let _ = allow_local_snapshot;
             let framework = match require_kv_framework_api(client, py) {
                 Ok(v) => v,
                 Err(e) => return ApiResult::new_error(e),
@@ -3450,7 +6257,298 @@ impl KvClient {
                 }),
             }
         }
-        is_exist_inner(self, key, py).into_py_object(py)
+        is_exist_inner(self, key, allow_local_snapshot, py).into_py_object(py)
+    }
+
+    /// Native blocking batch get path writing payload bytes into caller-provided pointers.
+    #[pyo3(signature = (keys, payload_ptrs, payload_capacities))]
+    fn batch_get_into(
+        &self,
+        keys: Vec<String>,
+        payload_ptrs: Vec<u64>,
+        payload_capacities: Vec<u32>,
+        py: Python,
+    ) -> PyObject {
+        fn batch_get_into_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            payload_ptrs: Vec<u64>,
+            payload_capacities: Vec<u32>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.len() != payload_ptrs.len() || keys.len() != payload_capacities.len() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "batch_get_into requires keys, payload_ptrs, and payload_capacities to have the same length",
+                ));
+            }
+            if keys.is_empty() {
+                return ApiResult::new_success(Vec::<i32>::new().into_py(py));
+            }
+
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+
+            let registered = client
+                .registered_buffers
+                .read()
+                .expect("registered_buffers poisoned");
+            let mut payload_ptrs_usize = Vec::with_capacity(payload_ptrs.len());
+            for (&ptr, &cap_u32) in payload_ptrs.iter().zip(payload_capacities.iter()) {
+                let ptr_usize = match usize::try_from(ptr) {
+                    Ok(v) => v,
+                    Err(_) => {
+                        return ApiResult::new_error(new_invalid_argument_error(
+                            py,
+                            "batch_get_into payload_ptr out of range",
+                        ));
+                    }
+                };
+                if ptr_usize == 0 && cap_u32 > 0 {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_get_into payload_ptr must be non-zero when payload_capacity > 0",
+                    ));
+                }
+                let cap = cap_u32 as usize;
+                if !registered.ranges.is_empty() && !registered.contains(ptr_usize, cap) {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "batch_get_into destination range is not inside any registered buffer",
+                    ));
+                }
+                payload_ptrs_usize.push(ptr_usize);
+            }
+            drop(registered);
+
+            let framework = borrow_stable_owner(&framework);
+            let batch_concurrency = DEFAULT_PYO3_BATCH_CONCURRENCY;
+
+            if !framework.is_external_mode() {
+                let framework_for_backend = framework.clone();
+                let keys_for_backend = keys.clone();
+                let backend_result = match py.allow_threads(|| {
+                    runtime.run_async_from_sync(async move {
+                        framework_for_backend
+                            .client_kv_api_view()
+                            .client_kv_api()
+                            .inner()
+                            .batch_get(keys_for_backend, batch_concurrency)
+                            .await
+                    })
+                }) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!("runtime bridge failed: {}", e),
+                        ));
+                    }
+                };
+
+                return match backend_result {
+                    Ok(per_item_results) => {
+                        let mut out = Vec::with_capacity(per_item_results.len());
+                        for (((key, payload_ptr), payload_capacity), item_result) in keys
+                            .into_iter()
+                            .zip(payload_ptrs_usize.into_iter())
+                            .zip(payload_capacities.into_iter())
+                            .zip(per_item_results.into_iter())
+                        {
+                            let code = match item_result {
+                                Ok(Some((holder, _remote_info))) => {
+                                    let holder_result = KvGetResult::Owner(Some(holder));
+                                    let payload =
+                                        match payload_slice_from_get_result(&key, &holder_result) {
+                                            Ok(payload) => payload,
+                                            Err(err) => {
+                                                out.push(kv_error_to_ret_code(&err));
+                                                continue;
+                                            }
+                                        };
+                                    if payload.len() > payload_capacity as usize {
+                                        -(4003i32)
+                                    } else {
+                                        if !payload.is_empty() {
+                                            unsafe {
+                                                std::ptr::copy_nonoverlapping(
+                                                    payload.as_ptr(),
+                                                    payload_ptr as *mut u8,
+                                                    payload.len(),
+                                                );
+                                            }
+                                        }
+                                        payload.len() as i32
+                                    }
+                                }
+                                Ok(None) => kv_error_to_ret_code(&CoreKvError::Api(
+                                    CoreApiError::KeyNotFound { key },
+                                )),
+                                Err(err) => kv_error_to_ret_code(&err),
+                            };
+                            out.push(code);
+                        }
+                        ApiResult::new_success(out.into_py(py))
+                    }
+                    Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                        py,
+                        &err,
+                        "Batch get failed",
+                    )),
+                };
+            }
+
+            let framework_for_backend = framework.clone();
+            let keys_for_backend = keys.clone();
+            let backend_result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_backend
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .batch_get(keys_for_backend, batch_concurrency)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+
+            match backend_result {
+                Ok(per_item_results) => {
+                    let mut out = Vec::with_capacity(per_item_results.len());
+                    for (((key, payload_ptr), payload_capacity), item_result) in keys
+                        .into_iter()
+                        .zip(payload_ptrs_usize.into_iter())
+                        .zip(payload_capacities.into_iter())
+                        .zip(per_item_results.into_iter())
+                    {
+                        let code =
+                            match item_result {
+                                Ok(Some(holder)) => {
+                                    let holder_result = KvGetResult::External(Some(holder));
+                                    let payload =
+                                        match payload_slice_from_get_result(&key, &holder_result) {
+                                            Ok(payload) => payload,
+                                            Err(err) => {
+                                                out.push(kv_error_to_ret_code(&err));
+                                                continue;
+                                            }
+                                        };
+                                    if payload.len() > payload_capacity as usize {
+                                        -(4003i32)
+                                    } else {
+                                        if !payload.is_empty() {
+                                            unsafe {
+                                                std::ptr::copy_nonoverlapping(
+                                                    payload.as_ptr(),
+                                                    payload_ptr as *mut u8,
+                                                    payload.len(),
+                                                );
+                                            }
+                                        }
+                                        payload.len() as i32
+                                    }
+                                }
+                                Ok(None) => kv_error_to_ret_code(&CoreKvError::Api(
+                                    CoreApiError::KeyNotFound { key },
+                                )),
+                                Err(err) => kv_error_to_ret_code(&err),
+                            };
+                        out.push(code);
+                    }
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "Batch get failed",
+                )),
+            }
+        }
+
+        batch_get_into_inner(self, keys, payload_ptrs, payload_capacities, py).into_py_object(py)
+    }
+
+    /// Native blocking batch existence check.
+    #[pyo3(signature = (keys, allow_local_snapshot=false))]
+    fn batch_is_exist(
+        &self,
+        keys: Vec<String>,
+        allow_local_snapshot: bool,
+        py: Python,
+    ) -> PyObject {
+        fn batch_is_exist_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            allow_local_snapshot: bool,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_success(Vec::<i32>::new().into_py(py));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework = borrow_stable_owner(&framework);
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework
+                        .kv_batch_is_exist(keys, allow_local_snapshot)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match result {
+                Ok(exists_list) => {
+                    let ints = exists_list
+                        .into_iter()
+                        .map(|exists| if exists { 1i32 } else { 0i32 })
+                        .collect::<Vec<_>>();
+                    ApiResult::new_success(ints.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "Batch existence check failed",
+                )),
+            }
+        }
+
+        batch_is_exist_inner(self, keys, allow_local_snapshot, py).into_py_object(py)
     }
 
     /// Count number of keys whose name starts with the given prefix.
@@ -4164,6 +7262,7 @@ fn fluxon_pyo3(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyGeneralLease>()?;
     m.add_class::<PyLeaseBackendUid>()?;
     m.add_function(wrap_pyfunction!(run_master_blocking, m)?)?;
+    m.add_function(wrap_pyfunction!(decode_flat_dict_payload, m)?)?;
     m.add_function(wrap_pyfunction!(monitor_render_cli, m)?)?;
     m.add_function(wrap_pyfunction!(monitor_render_web, m)?)?;
     m.add_function(wrap_pyfunction!(fluxon_ops_controller_blocking, m)?)?;
@@ -4309,17 +7408,14 @@ mod tests {
             discovery.entries[0].provider_path,
             libs_dir.join("libmlx5-rdmav34.so")
         );
-        assert!(
-            discovery.outcomes.iter().any(|outcome| {
-                outcome.contains("config_ok:") && outcome.contains("driver=mlx5")
-            })
-        );
-        assert!(
-            discovery
-                .outcomes
-                .iter()
-                .any(|outcome| outcome.contains("config_parse_fail:"))
-        );
+        assert!(discovery
+            .outcomes
+            .iter()
+            .any(|outcome| { outcome.contains("config_ok:") && outcome.contains("driver=mlx5") }));
+        assert!(discovery
+            .outcomes
+            .iter()
+            .any(|outcome| outcome.contains("config_parse_fail:")));
     }
 
     #[test]
diff --git a/fluxon_rs/fluxon_util/src/dev_config.rs b/fluxon_rs/fluxon_util/src/dev_config.rs
index c860910..d3f5953 100644
--- a/fluxon_rs/fluxon_util/src/dev_config.rs
+++ b/fluxon_rs/fluxon_util/src/dev_config.rs
@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result, anyhow};
 use serde_yaml::Value;
 use std::fs;
 use std::path::{Path, PathBuf};
diff --git a/fluxon_rs/fluxon_util/src/lib.rs b/fluxon_rs/fluxon_util/src/lib.rs
index a85aed0..cde6dc7 100644
--- a/fluxon_rs/fluxon_util/src/lib.rs
+++ b/fluxon_rs/fluxon_util/src/lib.rs
@@ -37,10 +37,9 @@ pub mod limitrate;
 pub mod pyo3;
 // Re-export for stable public API: existing call sites can keep using `fluxon_util::init_log`.
 pub use log::{
-    current_daily_sharded_log_path, current_log_file_path, daily_sharded_log_path,
-    display_runtime_log_path, init_log, init_log_test, init_log_with_extra_layer,
-    latest_existing_daily_sharded_log_path, resolve_readable_log_path,
-    DEFAULT_DAILY_LOG_RETENTION_DAYS,
+    DEFAULT_DAILY_LOG_RETENTION_DAYS, current_daily_sharded_log_path, current_log_file_path,
+    daily_sharded_log_path, display_runtime_log_path, init_log, init_log_test,
+    init_log_with_extra_layer, latest_existing_daily_sharded_log_path, resolve_readable_log_path,
 };
 #[cfg(test)]
 mod test_util_test;
@@ -251,7 +250,12 @@ mod tests {
             );
             assert_logged_text(
                 &active_log_path,
-                &["debug message", "info message", "warning message", "error message"],
+                &[
+                    "debug message",
+                    "info message",
+                    "warning message",
+                    "error message",
+                ],
             );
         }
     }
diff --git a/fluxon_rs/fluxon_util/src/log.rs b/fluxon_rs/fluxon_util/src/log.rs
index fc6066f..4db4ae4 100644
--- a/fluxon_rs/fluxon_util/src/log.rs
+++ b/fluxon_rs/fluxon_util/src/log.rs
@@ -61,9 +61,7 @@ fn read_test_log_shard_window_config() -> anyhow::Result<Option<LogShardWindowCo
         return Ok(None);
     }
     let window_seconds: i64 = window_text.parse().map_err(|e| {
-        anyhow::anyhow!(
-            "{TEST_LOG_SHARD_WINDOW_SECONDS_ENV} must be a positive integer: {e}"
-        )
+        anyhow::anyhow!("{TEST_LOG_SHARD_WINDOW_SECONDS_ENV} must be a positive integer: {e}")
     })?;
     if window_seconds <= 0 {
         anyhow::bail!("{TEST_LOG_SHARD_WINDOW_SECONDS_ENV} must be > 0");
@@ -85,7 +83,9 @@ fn read_test_log_shard_window_config() -> anyhow::Result<Option<LogShardWindowCo
     }))
 }
 
-fn resolve_shard_date_from_datetime(now: chrono::DateTime<chrono::Utc>) -> anyhow::Result<chrono::NaiveDate> {
+fn resolve_shard_date_from_datetime(
+    now: chrono::DateTime<chrono::Utc>,
+) -> anyhow::Result<chrono::NaiveDate> {
     let Some(config) = read_test_log_shard_window_config()? else {
         return Ok(now.date_naive());
     };
@@ -99,8 +99,8 @@ fn resolve_shard_date_from_datetime(now: chrono::DateTime<chrono::Utc>) -> anyho
         );
     }
     let bucket_index = delta_seconds / config.window_seconds;
-    let base_date = chrono::NaiveDate::from_ymd_opt(2026, 1, 1)
-        .expect("valid hard-coded synthetic base date");
+    let base_date =
+        chrono::NaiveDate::from_ymd_opt(2026, 1, 1).expect("valid hard-coded synthetic base date");
     Ok(base_date + chrono::Days::new(bucket_index as u64))
 }
 
@@ -108,10 +108,7 @@ fn current_shard_date() -> anyhow::Result<chrono::NaiveDate> {
     resolve_shard_date_from_datetime(chrono::Utc::now())
 }
 
-fn cleanup_old_daily_sharded_logs(
-    base_path: &Path,
-    retention_days: usize,
-) -> anyhow::Result<()> {
+fn cleanup_old_daily_sharded_logs(base_path: &Path, retention_days: usize) -> anyhow::Result<()> {
     let parent = match base_path.parent() {
         Some(parent) => parent,
         None => return Ok(()),
@@ -124,7 +121,8 @@ fn cleanup_old_daily_sharded_logs(
         return Ok(());
     };
     fs::create_dir_all(parent)?;
-    let keep_since = current_shard_date()? - chrono::Days::new(retention_days.saturating_sub(1) as u64);
+    let keep_since =
+        current_shard_date()? - chrono::Days::new(retention_days.saturating_sub(1) as u64);
     let prefix = format!("{stem}.");
     for entry in std::fs::read_dir(parent)? {
         let entry = entry?;
@@ -180,10 +178,7 @@ impl DailyShardedFileWriter {
         current_daily_sharded_log_path(&self.base_path)
     }
 
-    fn rotate_if_needed(
-        &self,
-        state: &mut DailyShardedFileWriterState,
-    ) -> io::Result<()> {
+    fn rotate_if_needed(&self, state: &mut DailyShardedFileWriterState) -> io::Result<()> {
         let next_path = self
             .current_path()
             .map_err(|err| io::Error::new(io::ErrorKind::Other, err.to_string()))?;
@@ -314,20 +309,19 @@ pub fn daily_sharded_log_path(
     base_path: &Path,
     date: chrono::NaiveDate,
 ) -> anyhow::Result<PathBuf> {
-    let file_name = base_path.file_name().and_then(|v| v.to_str()).ok_or_else(|| {
-        anyhow::anyhow!(
-            "log path must end with a valid utf-8 filename: {}",
-            base_path.display()
-        )
-    })?;
+    let file_name = base_path
+        .file_name()
+        .and_then(|v| v.to_str())
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "log path must end with a valid utf-8 filename: {}",
+                base_path.display()
+            )
+        })?;
     let stem = file_name
         .strip_suffix(".log")
         .ok_or_else(|| anyhow::anyhow!("log path must end with .log: {}", base_path.display()))?;
-    Ok(base_path.with_file_name(format!(
-        "{}.{}.log",
-        stem,
-        date.format("%Y-%m-%d")
-    )))
+    Ok(base_path.with_file_name(format!("{}.{}.log", stem, date.format("%Y-%m-%d"))))
 }
 
 pub fn current_daily_sharded_log_path(base_path: &Path) -> anyhow::Result<PathBuf> {
diff --git a/fluxon_rs/fluxon_util/tests/log_mgmt.rs b/fluxon_rs/fluxon_util/tests/log_mgmt.rs
index 431c5fc..f459337 100644
--- a/fluxon_rs/fluxon_util/tests/log_mgmt.rs
+++ b/fluxon_rs/fluxon_util/tests/log_mgmt.rs
@@ -59,7 +59,10 @@ fn kv_log_shards_roll_and_cleanup_with_test_window() {
         .expect("unix epoch")
         .as_secs() as i64;
     let _window_guard = EnvVarGuard::set(TEST_LOG_SHARD_WINDOW_SECONDS_ENV, "10");
-    let _anchor_guard = EnvVarGuard::set(TEST_LOG_SHARD_ANCHOR_UNIX_SECONDS_ENV, (now - 2).to_string());
+    let _anchor_guard = EnvVarGuard::set(
+        TEST_LOG_SHARD_ANCHOR_UNIX_SECONDS_ENV,
+        (now - 2).to_string(),
+    );
 
     fluxon_util::init_log(log_path, instance_key);
     tracing::info!(target: "fluxon_util", "[kv-log-mgmt][phase=before] ts={}", now);
@@ -115,7 +118,8 @@ fn resolve_readable_log_path_ignores_plain_base_log_when_daily_shards_exist() {
     let shard_path = temp_dir.path().join("startup.2026-06-21.log");
     fs::write(&shard_path, "shard\n").expect("write shard log");
 
-    let resolved = fluxon_util::resolve_readable_log_path(&base_path).expect("resolve readable log path");
+    let resolved =
+        fluxon_util::resolve_readable_log_path(&base_path).expect("resolve readable log path");
     assert_eq!(resolved, shard_path);
 }
 
@@ -128,7 +132,7 @@ fn latest_existing_daily_sharded_log_path_skips_invalid_candidates() {
     fs::write(&invalid_shard_path, "invalid\n").expect("write invalid shard");
     fs::write(&valid_shard_path, "valid\n").expect("write valid shard");
 
-    let resolved =
-        fluxon_util::latest_existing_daily_sharded_log_path(&base_path).expect("resolve latest shard");
+    let resolved = fluxon_util::latest_existing_daily_sharded_log_path(&base_path)
+        .expect("resolve latest shard");
     assert_eq!(resolved, valid_shard_path);
 }

From 6235d414faa936713e1b82d78cfc4124eaf3fb97 Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Thu, 9 Jul 2026 19:07:56 +0800
Subject: [PATCH 02/10] async put_done

---
 ...06\346\210\220\350\256\276\350\256\241.md" |  215 ++-
 .../src/client_kv_api/external_api.rs         | 1268 +++++++++--------
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  |  159 ++-
 .../fluxon_kv/src/client_kv_api/msg_pack.rs   |    8 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  |  780 +++++-----
 .../fluxon_kv/src/client_seg_pool/mod.rs      |    6 +-
 fluxon_rs/fluxon_kv/src/config.rs             |  281 +++-
 .../external_client_test.rs                   |    4 +-
 .../fluxon_kv/src/external_client_api/mod.rs  |   40 +-
 fluxon_rs/fluxon_kv/src/kv_test.rs            |   23 +-
 fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs    |    3 +-
 fluxon_rs/fluxon_kv/src/lib.rs                |   17 +-
 .../fluxon_kv/src/master_kv_router/delete.rs  |    4 +-
 .../fluxon_kv/src/master_kv_router/get.rs     |   10 +-
 .../fluxon_kv/src/master_kv_router/mod.rs     |   61 +-
 .../src/master_kv_router/msg_pack.rs          |   14 +-
 .../src/master_kv_router/placement.rs         |  717 +++++++++-
 .../fluxon_kv/src/master_kv_router/put.rs     |  652 ++++++---
 .../lease_manager_test.rs                     |   70 +-
 .../fluxon_kv/src/memholder/memholder_test.rs |    3 +-
 fluxon_rs/fluxon_pyo3/src/error.rs            |    2 +-
 fluxon_rs/fluxon_pyo3/src/lib.rs              |  496 ++-----
 22 files changed, 3034 insertions(+), 1799 deletions(-)

diff --git "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md" "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
index 8a0dc6d..3b0c1c6 100644
--- "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
+++ "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
@@ -1,17 +1,71 @@
 # SGLang Fluxon KV 集成设计
 
-## 设计目标
+## 背景与目标
 
 本文说明开源仓库中 SGLang HiCache 接入 Fluxon KV 的 hostless 实现设计，聚焦接口契约、状态归属和生命周期边界。本文不是通用 `FlatDict` KV API 的完整说明。
 
+稳定结论：本集成的目标是把 SGLang HiCache + Mooncake 形态下分裂的 L2/L3 KV Cache 收敛到 Fluxon 统一管理的本机/远端 KV 层。Fluxon 需要同时具备两类能力：一类是 `key -> value` 的分布式缓存、路由、版本和生命周期能力；另一类是 HiCache L2 所依赖的 hostless 数据面能力，也就是让 SGLang native kernel 直接在 GPU KV cache 和 Fluxon 管理的 host value memory 之间搬运数据。
+
+关键 insights 先集中列在这里，后文围绕这些结论展开接口、状态和时序设计：
+
+- **L2/L3 分离是工程解耦选择，但会带来资源冗余和 L2 全局不可见**
+  - 因果链：HiCache L2 留在推理框架内，Mooncake L3 作为外部 backend，能降低接入复杂度；代价是同一类 KV page 被两套系统分别索引、驻留、驱逐和释放。同一批 page 可能同时驻留在本机 L2 和外部 L3，且其它 worker 或其它节点不能通过统一 route 判断本机 L2 page 是否可复用。
+  - 本设计落点：把逻辑 L2/L3 收敛到 Fluxon local side / remote side，用一套 owner、holder、route、commit/release 管理同一批 page。page key 在 Fluxon master/owner 中形成统一路由；只有 commit future 成功后，跨 worker 和跨节点复用才把该 page 视为可见。
+- **同机 worker 缺少共享内存快路径**
+  - 因果链：多个 SGLang worker 容易各自维护后端 segment、本机缓存副本和独立 pin/release 状态；同机交接也可能绕行后端协议。
+  - 本设计落点：同机 worker attach 到同一个 Fluxon owner shared segment，通过 holder 引用管理本机可见 value 的生命周期。
+- **统一 L2/L3 需要分布式 KV 能力**
+  - 因果链：Mooncake 这类分布式 KV backend 的目标仍然成立：KV Cache 需要利用远端 CPU 内存，尤其是无推理负载机器上的闲置内存，作为 shared backing。只用本进程数组或本机缓存，无法统一索引、放置和复用这些远端闲置内存。
+  - 本设计落点：Fluxon 保留 `key -> value` route、inflight 判重、commit future 和 local/remote 放置能力，把远端闲置 CPU 内存纳入 remote side，同时把本机 L2 纳入同一套 owner/holder 生命周期。
+- **保留 L2 低延迟需要 kernel 直连内存**
+  - 因果链：普通 `put/get(key, bytes)` KV 接口需要在 CPU 侧 materialize payload、查地址、组织拷贝或拆装 bytes；长上下文下如果再按 page 和 layer 展开，会形成 `page_count * layer_count` 级别的 CPU 控制面循环。
+  - 本设计落点：Fluxon 只构造 `plan_ptr(value_ptrs)`，SGLang native kernel 直接在 GPU KV cache 和 Fluxon host value memory 之间搬运 bytes。
+- **KV Cache 适合 write-back 最终一致性，最终目标是极致化这条路径**
+  - 因果链：page value 按不可变对象使用，缓存副本可丢失；写回失败只会降低命中率，不改变推理正确性。因此优化重点应放在缩短 write-back 和 restore 的热路径，而不是把每次缓存写回做成强同步持久写。
+  - 本设计落点：native write 完成后异步推进 route commit，`KvFuture` 成功前不作为跨 worker / 跨节点 shared backing；写入侧减少同步等待、CPU 循环和中间 bytes 包装，读取侧先规划 prefix，再只 materialize 可恢复前缀。
+- **需要适配 SGLang KVCache 特化接口**
+  - 因果链：SGLang KVCache restore 不是普通逐 key `get`，而是面向一批有序 page keys 的 prefix restore。它需要一次性回答“这一批最多恢复到哪里”，并且不能切开一个 radix node 对应的 atomic group。batch 化还能减少逐 key 调用、查表、锁和跨边界调度开销。
+  - 本设计落点：Fluxon hostless get 以 batch 为单位计算 `raw_prefix_hit_len`、`transferable_len` 和 `prefix_hit_groups`。`get_start` 合并存在性 / prefix 判断和可恢复前缀的数据拉取启动，返回 handle 和 prefix；`get_transfer` 再消费 handle，把可恢复前缀转换成 readable `plan_ptr(value_ptrs)`。
+
+### 核心实现思路
+
+核心实现按上面的 insight 逐条落到接口和状态边界：
+
+- **对应 L2/L3 分离带来资源冗余和 L2 全局不可见**
+  - 实现思路：把 L2/L3 从两个后端系统收敛成 Fluxon 的 local side / remote side。local side 承接本机 shared segment、reserve slots 和 holder；remote side 承接跨 owner / 跨机器 KV 数据面。
+  - 主要落点：Fluxon master/owner route、`MemHolder`、commit/release 生命周期。
+- **对应同机 worker 缺少共享内存快路径**
+  - 实现思路：一台机器运行一个 Fluxon owner，同机 SGLang worker 以 external/client attach 到同一个 owner shared segment。worker 只注册本进程 CUDA context 可见的 mapping，底层内存归属和释放由 owner 管理。
+  - 主要落点：`wait_local_segments_ready()`、owner shared segment、CUDA host registration。
+- **对应统一 L2/L3 需要分布式 KV 能力**
+  - 实现思路：继续保留类似 Mooncake 的分布式 KV 目标，用 page key 做全局命名，用 route 和 version 定位本机 owner 或远端 owner，把无推理负载机器上的闲置 CPU 内存作为可放置、可复用的 remote side backing。inflight 判重和 commit future 约束写入发布，避免远端共享副本提前可见。
+  - 主要落点：Fluxon master route、local/remote owner 放置、`local_fast_put_start` reservation、`local_fast_put_commit` 发布。
+- **对应保留 L2 低延迟需要 kernel 直连内存**
+  - 实现思路：在保留分布式 `key -> value` KV 语义的前提下，把普通 `put/get` 的数据面拆成两条 hostless 两阶段路径。Fluxon 不接管 KV page 内部 layout，只提供 key 路由、holder 生命周期和 `plan_ptr(value_ptrs)`。
+    - `plan_ptr` 协议：Fluxon 和 SGLang kernel 之间只共享一段短生命周期 plan blob。blob 里保存本次 batch 的 `value_ptrs[]`；Fluxon 负责这些地址的分配、可见性和 holder 生命周期，SGLang kernel 负责按自己的 KV layout 解释并读写这些地址。
+    - Put：`put_start -> native write -> put_commit` 构成写入闭环。`put_start` 本质上为本次 batch 分配 Fluxon 管理的 value memory，并返回 `plan_ptr(value_ptrs)`；SGLang native write kernel 直接往这些地址写入 GPU KV bytes；`put_commit` 在 kernel 写完后通知 Fluxon，把这些 slots 发布为可路由的 KV value。
+    - Get / restore：`get_start -> get_transfer -> native restore -> release_views` 构成读取闭环。`get_start` 先计算连续安全前缀；`get_transfer` 把可恢复前缀 materialize 成 readable `plan_ptr(value_ptrs)` 并持有 holder；SGLang native restore kernel 直接从这些地址恢复 GPU KV cache，完成后 `release_views` 释放 plan 引用。
+  - 主要落点：plan blob ABI、`value_ptrs[]`、`local_fast_put_start/local_fast_put_commit`、`get_start/get_transfer`、SGLang `write_*_to_fluxon_values` / `restore_*_from_fluxon_values`。
+- **对应 KV Cache 适合 write-back 最终一致性**
+  - 实现思路：KV Cache 的不可变、可丢失语义天然对应 Fluxon 的 master / owner / external 三层架构。master 管全局 route 和最终可见性，owner 管本机共享内存和 holder 生命周期，external 是 SGLang worker 的热路径接入层。
+    - Put：native write 完成后先更新 external / owner 本地可见索引并返回 `KvFuture`，后台再推进 master route commit。`KvFuture` 成功前只表示本机 write-back 进入提交流程；失败时清理本地在途状态，退化为后续 cache miss。
+    - Get / restore：优先查询 external / owner 本地热路径；本地 miss 时再进入远端 prefetch 和 restore。读取只 materialize 连续安全前缀，失败时 rollback 或按 miss 继续。
+  - 主要落点：master route、owner shared segment、external local visible index、`KvFuture`、`get_start/get_transfer/release_views`。
+- **对应适配 SGLang KVCache 特化接口**
+  - 实现思路：把 restore 查询建模成 SGLang KVCache 专用的 batch prefix planning，而不是逐 key 独立 get。
+    - Reject inflight / exist：KV page 按不可变缓存对象写回，重复 page key 不应产生第二份并发写入。`local_fast_put_start` 固定使用 `reject_if_inflight_same_key` 和 `reject_if_exist_same_key`，在分配 writable memory 前拒绝在途或已存在的同 key value，避免重复写回和未提交数据被误发布。
+    - Prefetch 对应 `get_start`：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序完成存在性 / prefix 判断，并在 owner/external 侧启动 `keys[..transferable_len]` 的 prefetch transfer，把“能恢复多少”和“开始拉取可恢复数据”合并在 start 阶段。
+    - Batch 和 group 对齐：`get_start` 按 atomic group 边界把 `raw_prefix_hit_len` 收敛成 `transferable_len`；`get_transfer` 只消费这个 handle 和 `keys[..transferable_len]` 的 prefetch 结果，并构造 batch 级 readable `plan_ptr(value_ptrs)`，保证 kernel restore 看到的是连续、完整、可回滚的 readable batch plan。
+  - 主要落点：`reject_if_inflight_same_key`、`reject_if_exist_same_key`、`GetStartResult`、`atomic_group_lens`、`raw_prefix_hit_len`、`transferable_len`、`prefix_hit_groups`、`get_start/get_transfer`。
+
+因此，本设计要统一的是 L2/L3 的对象归属、可见性和生命周期，同时保留 L2 路径的低延迟数据面。单独替换成普通远端 KV 会丢掉 HiCache L2 的 kernel 直连能力；单独保留本地数组或进程内缓存，又无法让 L2 进入全局命中、驱逐和跨节点复用链路。
+
 当前调用链主要分为三条主线：
 
 - 写入侧：`local_fast_put_start -> SGLang native write -> local_fast_put_commit`。
 - 读取侧：`get_start -> get_transfer -> SGLang native restore -> release_views`。
 - 放弃读取侧 restore 时：`cancel_get_transfer` 释放 `get_start` 持有的资源。
 
-Fluxon 仍然按 key 保存 opaque value bytes。SGLang 负责 page key、page layout、MHA/MLA/Mamba value 内部格式、GPU KV cache index 和 native kernel 调度；Fluxon 负责 key-version 路由、put 准入与 reservation、owner-local reserve、host value 地址、holder 生命周期和跨 owner 数据面。
-
 这个集成把 SGLang 逻辑上的 L2/L3 缓存落到 Fluxon 统一管理的本机/远端 KV 层中。这样可以用同一套 owner、holder、commit/release 语义管理 KV page，减少传统 L2 host cache 与 L3 backend 分属不同系统时产生的同机重复缓存和生命周期割裂。
 
 常见部署下，一台机器启动一个 Fluxon owner；同机多个 GPU 对应的多个 SGLang worker 进程通过 external/client attach 到同一个 owner shared segment。相比一个 SGLang 进程一个后端 segment、进程间不共享后端 segment 的形态，Fluxon 把同机 host/shared memory、owner local reserve slots 和 holder 生命周期放到同一个 owner 生命周期模型里。这样多个 SGLang worker 可以通过同一个 owner segment 获得本机快速可见性和受控的本地可写内存供给，减少各进程为了各自安全边界重复持有 KV、固定预留 segment 或独立维护 pin/release 状态带来的浪费。
@@ -169,15 +223,73 @@ blob[11] = value_ptr_9
 
 hostless backup 的核心约束是：Fluxon 负责 GPU KV cache 之下的本机/远端 KV 层的地址分配、route 提交和生命周期管理，但真正的 KV bytes 由 SGLang native kernel 从 GPU KV cache 写入。因此 Fluxon 不能在收到 key 后立刻发布 KV route；它必须先完成 key reservation、put id 分配和 owner-local reserve slot claim，把稳定可写的 `value_ptrs[]` 通过 `plan_ptr` 返回给 SGLang。SGLang native kernel 写完这些地址后，`local_fast_put_commit` 才能把这些 slots 提交为 resident values，并发布 Fluxon KV route。
 
-这条写路径拆成两个 Fluxon API 阶段：
+这条 backup 路径按 write-back 最终一致性设计：native write 完成后先进入本地可见和后台 commit 流程，跨 worker / 跨节点可见性以 `KvFuture` 成功为准。提交失败不会破坏推理语义，只会让对应 page 失去 shared backing；上层清理 `storage_*` 状态后按 cache miss 处理。
+
+### 弹性本地侧预分配
+
+弹性本地侧预分配对应 owner 本地写入预留池。它是在 owner shared segment 中为 SGLang hostless put 预先划分的 writable slots。`local_fast_put_start` 从这些 slots 中为本次 put 分配地址，并把地址写入 `plan_ptr(value_ptrs)` 返回给 SGLang native kernel。此时 slot 只处于 reserved/prepared 状态，还没有绑定为 Fluxon KV 的正式 `key -> value` route。
+
+这个 pool 是共享 owner segment 上的弹性本地可写内存供给层。它让多个 SGLang worker 都能快速取得受 owner 生命周期管理的 `value_ptrs[]`，同时避免为每个 worker 固定切出长期独占的后端 segment。reserve slot 不足时可以按需求补充 grant，空闲后再按 cooldown 回收。
+
+对象含义：
+
+| 对象 | 含义 |
+| --- | --- |
+| grant | owner 侧一次申请的大块本地内存，当前固定为 `512 MiB`。 |
+| slot | grant 内按 `slot_size` 切分的小块；一个 slot 承载一个 Fluxon value。 |
+| slot lease | `local_fast_put_start` 为本次 batch 临时 claim 到的一组 slots；失败或 abort 时必须释放。 |
+| value pointer | slot 的起始地址，会写入 plan blob 的 `value_ptrs[]`，供 SGLang kernel 直接写入。 |
+| resident value | `local_fast_put_commit` 后由 slot 构造出的本地可读 value。 |
+| route | master/owner 确认后的 key 到 value 位置映射；route 成功后该 value 才是全局可见的 KV replica。 |
+
+slot 生命周期：
+
+```text
+Free
+  -> Prepared             // local_fast_put_start claim slot
+  -> PendingLocalVisible  // local_fast_put_commit 开始，本地 resident value 已记录为 pending visible
+  -> Committed            // put_done 成功，route 引用该 slot
+  -> Free                 // route 和 holder 引用都释放后回收
+```
+
+如果 native write 失败，调用方必须执行 `put_abort(plan_ptr)`，Prepared slots 会回到 Free。`local_fast_put_commit` 成功返回后，slot 是否能释放由 route 引用和 holder 引用共同决定；只要 master/owner route 或 `MemHolder` 仍引用该 slot，底层 grant 就不能释放。
+
+当前容量策略：
+
+| 项 | 当前实现 |
+| --- | --- |
+| grant 物理粒度 | `OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES = 512 * 1024 * 1024` |
+| 最小 slot size | `4 KiB` |
+| slot size 计算 | `max(value_len, 4 KiB).next_power_of_two()` |
+| slot 上限 | `slot_size <= 512 MiB` |
+| refill 触发 | 当前 slot class free slots 不足时登记 pending demand 并唤醒 rebalance actor。 |
+| 默认等待 | soft wait `10 ms`，hard timeout `1 s`。 |
+| shrink 单位 | 整个 grant；不做 live grant compaction。 |
+
+底层物理释放收束在 grant 级别。单个 committed slot 只是 grant 内逻辑索引，不直接拥有释放整块 mmap/registered memory 的权力。
+
+### Fluxon put_start / put_commit 接口设计
+
+Fluxon 的 backup 解法是把普通 KV `put(key, bytes)` 拆成 `put_start -> native write -> put_commit`。这个拆分的核心是接口解耦：Fluxon 先给本次写入分配受 owner 生命周期管理的 value memory，并把地址交给 SGLang；SGLang native/CUDA kernel 负责真正把 GPU KV cache bytes 写入这些地址；kernel 写完后，SGLang 再通知 Fluxon 发布这批 value。这样普通 KV 接口里的 payload materialization、CPU 侧 bytes 拆装和逐 page/layer 拷贝组织都不会进入 backup 热路径。
 
-1. `local_fast_put_start(keys, value_len)`：只做写入准入、key reservation、put id 分配和可写 value 地址准备，返回 `plan_ptr(value_ptrs)`；此时 value bytes 还没有写完，不能作为可读 KV route 暴露。
-2. `local_fast_put_commit(plan_ptr)`：在 SGLang native kernel 完成写入后消费 put plan，提交 slot / transfer / route，并返回 `KvFuture`；只有 future 成功后，SGLang 才能把 node 标记为 `storage_backed`。
+`put_start` 不是一次可见写入，它的核心结果是内存分配和指针返回。Fluxon 为本次 batch claim owner-local reserve slots，生成 `plan_ptr(value_ptrs)`；`value_ptrs[]` 指向 Fluxon owner segment 中已经准备好的 writable value memory，SGLang kernel 可以直接写这些地址。判重、reservation 和 put id 是保护这次内存分配不被重复写入或提前发布的控制面约束；这些 value 在 `put_commit` 前不会作为可读 route 暴露。
 
-写入阶段的拆分主要是为了同时满足两个约束：
+`put_commit` 是 kernel 写完后的通知和发布点。SGLang 在 CUDA write 完成后调用它，Fluxon 消费 put plan，把对应 slots 转成 resident values，并异步推进 route commit。`KvFuture` 成功前，数据只表示本次 write-back 已进入 Fluxon commit 流程；`KvFuture` 成功后，page 才能成为跨 worker / 跨节点可复用的 shared backing。这样 `put_start -> native write -> put_commit` 就构成了 hostless put 的完整闭环。
+
+这套接口拆分直接使用上面的弹性本地侧预分配池：`put_start` 从预分配 reserve slots 中 claim 短生命周期 slot lease，热路径拿到的是已准备好的地址。
+
+| 解法层 | 做什么 | 解决的问题 |
+| --- | --- | --- |
+| `local_fast_put_start(keys, value_len)` | 从 owner-local reserve slots claim 本次 batch 的 slot lease，分配 writable value memory，并返回 `plan_ptr(value_ptrs)`；key reservation 和 put id 保护这次分配 | 在 native write 前只暴露可写地址，不发布可读 route，避免其它 get 读到尚未写完的 value |
+| SGLang native write | SGLang native kernel 根据 `plan_ptr(value_ptrs)` 把 GPU KV page 写入 Fluxon 管理的 host value memory | 避免普通 KV `put(bytes)` 路径在 CPU 侧拆装 payload 和逐 page/layer 组织拷贝 |
+| `local_fast_put_commit(plan_ptr)` | 消费 put plan，把已写完的 slots 转为 resident values，推进 transfer / route commit，并返回 `KvFuture` | 把本地写完和全局发布分开；只有 future 成功后，SGLang 才能把 node 标记为 `storage_backed` |
+| 弹性本地侧预分配 | owner shared segment 中按 slot size 管理 reserve slots；free slots 不足时按 pending demand 补充 grant，空闲后按 cooldown 回收 | 热路径直接 claim 已准备好的可写地址，避免每个 worker 固定独占 segment，也避免每次 backup 临时分配或注册 host memory |
+
+写入阶段的拆分主要是为了同时满足三个约束：
 
 - 数据面效率：SGLang 不需要先把 GPU KV page 包装成通用 KV payload 再交给后端，而是直接用 kernel 写入 Fluxon 返回的 value 地址。
 - 可见性安全：`put_start` 阶段只预留地址，不发布 route；避免其它 get 读到尚未写完或尚未 commit 的 value。
+- 容量弹性：本地侧预分配池提供短生命周期 slot lease，而不是为每个 SGLang worker 固定切出长期独占内存；容量不足时由 owner 侧 refill，空闲后按 grant 粒度回收。
 
 ```mermaid
 sequenceDiagram
@@ -215,19 +327,20 @@ hostless backup 默认不依赖 put 前 exists 扫描。重复 key 或在途 key
 
 commit 请求会带上 `len`、`src_offset` 和 target 信息。Fluxon 用这些字段判断本次 value 是否落在当前进程可访问的 owner segment 或 owner-local reserve slot 中；如果需要本地可见索引，`put_done` 会返回 owner 分配的 `local_cache_holder_id`。`MemoryInfo` 和 holder 生命周期在下文说明。
 
-## Restore 时序
+## Prefetch 与 Restore 时序
 
-hostless restore 的核心约束是：SGLang 只能恢复有序 page keys 的连续前缀，并且不能切开一个 radix node 对应的 atomic group。Fluxon 需要先在本机/远端 KV 层里判断这批 keys 的可恢复边界，再把真正可恢复的部分转换成 SGLang kernel 可读取的 `plan_ptr(value_ptrs)`。因此 restore 被拆成 `get_start` 和 `get_transfer` 两个阶段。
+hostless restore 的核心约束是：SGLang 只能恢复有序 page keys 的连续前缀，并且不能切开一个 radix node 对应的 atomic group。Fluxon 需要先在本机/远端 KV 层里判断这批 keys 的可恢复边界，再把真正可恢复的部分提前 materialize 到当前进程可读的 holder / memory view 中，最后转换成 SGLang kernel 可读取的 `plan_ptr(value_ptrs)`。
 
-`get_start(keys, prefix_best_effort, atomic_group_lens)` 只做恢复规划：按 key 顺序做 local visible check / owner get start，计算 page 级连续命中前缀 `raw_prefix_hit_len`，再按 `atomic_group_lens` 向下收敛成 `transferable_len`。这个阶段回答“本次最多能恢复多少”，但不要求 SGLang 立刻分配 GPU KV pages，也不暴露 readable plan。
+因此读取侧分成 prefetch 和 restore 两段：
 
-`get_transfer(handle)` 在 SGLang 决定恢复后执行：它消费 `get_start` 返回的 handle，等待或完成必要 transfer，只 materialize `keys[..transferable_len]`，并返回持有 holder 引用的 readable `plan_ptr`。随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)`，把 Fluxon value memory 拷回 GPU KV cache。
+- Prefetch：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序做 local visible check / owner get start，计算 page 级连续命中前缀 `raw_prefix_hit_len`，再按 `atomic_group_lens` 向下收敛成 `transferable_len`。prefix 发布后，owner/external 侧会启动后台 prefetch transfer，只处理 `keys[..transferable_len]`，并把 holder / transfer result 保存在 shared op 中。
+- Restore：SGLang 拿到 `transferable_len` 后再决定是否分配 GPU KV pages 并继续恢复。`get_transfer(handle)` 消费 `get_start` 返回的 handle，等待或取得 prefetch 结果，生成持有 holder 引用的 readable `plan_ptr`。随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)`，把 Fluxon value memory 拷回 GPU KV cache。
 
-读取阶段拆成 planning 和 materialization 两步，主要是为了保证：
+读取阶段拆成 prefetch 和 restore 两步，主要是为了保证：
 
 - prefix 安全：中间 page miss 时，只恢复连续命中的完整前缀，不构造带洞的 GPU KV 状态。
 - atomic group 安全：`transferable_len` 不会切开 radix node group，避免恢复半个 node。
-- 资源效率：SGLang 在知道可恢复边界后再分配 GPU KV pages，避免先分配再发现 miss。
+- 资源效率：SGLang 在知道可恢复边界后再分配 GPU KV pages，同时 Fluxon 可以提前 prefetch 可恢复前缀，重叠远端 materialization 和 SGLang 侧 GPU page 分配。
 - 生命周期安全：`get_transfer` 返回的 plan 持有 holder 引用，直到 `release_views(plan_ptr)` 后才释放，保证 kernel restore 期间 value 地址稳定。
 
 ```mermaid
@@ -243,17 +356,25 @@ sequenceDiagram
     B->>F: get_start(storage_keys, prefix_best_effort, atomic_group_lens)
     F->>E: batch_get_start(keys)
     E->>O: ExternalBatchGetStartReq
-    O-->>E: handle + raw_prefix_hit_len
-    E-->>F: backend handle + raw_prefix_hit_len
-    F->>F: build GetStartResult(raw_prefix_hit_len, transferable_len, ...)
-    F-->>B: GetStartHandle + GetStartResult
-    B-->>U: transferable_len / prefix_hit_groups / first_miss_index
+    O->>O: local visible check / owner get start
+    O->>O: compute raw_prefix_hit_len and transferable_len
+    par return prefix
+        O-->>E: handle + raw_prefix_hit_len
+        E-->>F: backend handle + raw_prefix_hit_len
+        F->>F: build GetStartResult(raw_prefix_hit_len, transferable_len, ...)
+        F-->>B: GetStartHandle + GetStartResult
+        B-->>U: transferable_len / prefix_hit_groups / first_miss_index
+        U->>U: allocate GPU KV pages for transferable prefix
+    and background prefetch
+        O->>O: prefetch transfer keys[..transferable_len]
+        O->>O: keep holders / transfer results in shared op
+    end
     alt transferable_len > 0 and caller chooses restore
         U->>B: get_transfer(handle)
         B->>F: get_transfer(handle)
         F->>E: batch_get_transfer(handle, transferable keys)
         E->>O: ExternalBatchGetTransferReq
-        O-->>E: holders / transfer results
+        O-->>E: prefetched holders / transfer results
         E-->>F: plan_ptr(value_ptrs, holders kept alive)
         F-->>B: plan_ptr
         B-->>U: plan_ptr
@@ -264,6 +385,8 @@ sequenceDiagram
         U->>B: cancel_get_transfer(handle)
         B->>F: cancel_get_transfer(handle)
         F->>E: cancel_batch_get_start(handle)
+        E->>O: ExternalBatchGetCancelReq
+        O->>O: release get-start handle / prefetched holders
     end
 ```
 
@@ -280,7 +403,7 @@ sequenceDiagram
 
 生命周期规则：
 
-- `get_start` 成功后，调用方必须二选一：`get_transfer(handle)` 或 `cancel_get_transfer(handle)`。
+- `get_start` 成功后，调用方必须二选一：`get_transfer(handle)` 或 `cancel_get_transfer(handle)`；放弃 restore 时必须取消 handle，释放可能已经启动的 prefetch 资源。
 - `get_transfer(handle)` 成功后，handle 已被消费；后续由 returned `plan_ptr` 和 `release_views(plan_ptr)` 管理。
 - `release_views(plan_ptr)` 必须在 native restore 完成后执行，即使 native restore 失败也要释放。
 - `get_start` 只命中部分前缀时，SGLang 只能恢复 `transferable_len` 覆盖的完整 atomic groups，不能构造半个 atomic group 的 GPU KV 状态。
@@ -300,58 +423,6 @@ Fluxon client/external 侧会维护当前进程可直接访问的 value 索引
 
 `precommit_local_visible_info` 只覆盖 commit 进行中的短窗口。put commit 成功并确认 holder 后，会移除 precommit entry 并记录 committed entry；如果 commit 失败，precommit entry 必须被清理，不能作为后续 storage-backed 恢复来源。
 
-## Owner 本地写入预留池
-
-Owner 本地写入预留池是 owner segment 中为 SGLang hostless put 预先划分的 writable slots。`local_fast_put_start` 从这些 slots 中为本次 put 分配地址，并把地址写入 `plan_ptr(value_ptrs)` 返回给 SGLang native kernel。此时 slot 只处于 reserved/prepared 状态，还没有绑定为 Fluxon KV 的正式 `key -> value` route。
-
-这个 pool 是共享 owner segment 上的弹性本地可写内存供给层。它让多个 SGLang worker 都能快速取得受 owner 生命周期管理的 `value_ptrs[]`，同时避免为每个 worker 固定切出长期独占的后端 segment。reserve slot 不足时可以按需求补充 grant，空闲后再按 cooldown 回收。
-
-SGLang native kernel 写完 `value_ptrs[]` 后，`local_fast_put_commit` 才把这些 slots 提交为 resident values，并完成 Fluxon KV route commit。commit 前如果 native write 失败，`put_abort(plan_ptr)` 会释放这些 reserved slots。
-
-这条路径把写入拆成两个阶段：
-
-1. `local_fast_put_start` 完成 key reservation、put id 分配和本地 slot claim，返回 `plan_ptr(value_ptrs)`。
-2. SGLang native kernel 写完 `value_ptrs[]` 后，`local_fast_put_commit` 再把这些 slot 转为 resident values，并完成 Fluxon KV 的 put 提交。
-
-这里的 `local_fast_*` 是 Python/PyO3 public hostless plan API。真正的 value bytes 由 SGLang native kernel 写入 `value_ptrs[]` 指向的地址；Fluxon 在 commit 阶段只消费 put plan、处理必要 transfer 或 direct done，并完成 route commit。
-
-对象含义：
-
-| 对象 | 含义 |
-| --- | --- |
-| grant | owner 侧一次申请的大块本地内存，当前固定为 `512 MiB`。 |
-| slot | grant 内按 `slot_size` 切分的小块；一个 slot 承载一个 Fluxon value。 |
-| slot lease | `local_fast_put_start` 为本次 batch 临时 claim 到的一组 slots；失败或 abort 时必须释放。 |
-| value pointer | slot 的起始地址，会写入 plan blob 的 `value_ptrs[]`，供 SGLang kernel 直接写入。 |
-| resident value | `local_fast_put_commit` 后由 slot 构造出的本地可读 value。 |
-| route | master/owner 确认后的 key 到 value 位置映射；route 成功后该 value 才是全局可见的 KV replica。 |
-
-slot 生命周期：
-
-```text
-Free
-  -> Prepared             // local_fast_put_start claim slot
-  -> PendingLocalVisible  // local_fast_put_commit 开始，本地 resident value 已记录为 pending visible
-  -> Committed            // put_done 成功，route 引用该 slot
-  -> Free                 // route 和 holder 引用都释放后回收
-```
-
-如果 native write 失败，调用方必须执行 `put_abort(plan_ptr)`，Prepared slots 会回到 Free。`local_fast_put_commit` 成功返回后，slot 是否能释放由 route 引用和 holder 引用共同决定；只要 master/owner route 或 `MemHolder` 仍引用该 slot，底层 grant 就不能释放。
-
-当前容量策略：
-
-| 项 | 当前实现 |
-| --- | --- |
-| grant 物理粒度 | `OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES = 512 * 1024 * 1024` |
-| 最小 slot size | `4 KiB` |
-| slot size 计算 | `max(value_len, 4 KiB).next_power_of_two()` |
-| slot 上限 | `slot_size <= 512 MiB` |
-| refill 触发 | 当前 slot class free slots 不足时登记 pending demand 并唤醒 rebalance actor。 |
-| 默认等待 | soft wait `10 ms`，hard timeout `1 s`。 |
-| shrink 单位 | 整个 grant；不做 live grant compaction。 |
-
-底层物理释放收束在 grant 级别。单个 committed slot 只是 grant 内逻辑索引，不直接拥有释放整块 mmap/registered memory 的权力。
-
 ## SGLang Node Storage 状态
 
 SGLang 侧的 node metadata 不等价于 Fluxon master route 状态。当前四个字段建议按下面语义解释：
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 3cfd44d..a10e354 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -1,3 +1,4 @@
+use crate::client_kv_api::ClientKvApi;
 use crate::client_kv_api::msg_pack::{
     ExternalBatchGetCancelReq, ExternalBatchGetCancelResp, ExternalBatchGetItemResp,
     ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
@@ -11,33 +12,31 @@ use crate::client_kv_api::msg_pack::{
     ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq, ExternalPutStartResp,
     ExternalPutTransferEndReq, ExternalPutTransferEndResp, TestPutPhaseTrace,
 };
-use crate::client_kv_api::ClientKvApi;
 use crate::client_kv_api::{
     self, ExternalGetStartDedupKey, ExternalGetStartEntry, ExternalGetStartOwnerItem,
     ExternalGetStartPrefixResult, ExternalGetStartSharedItemResult, ExternalGetStartSharedOp,
     ExternalGetStartSharedPhase, ExternalGetStartTransferOutput, ExternalHoldingGetInfo,
-    ExternalPendingPutCtx,
+    ExternalPendingPutCtx, ReplicaTaskTarget,
 };
-use crate::client_seg_pool::{parse_side_transfer_worker_lane_idx, ResolveSideTransferLaneReq};
+use crate::client_seg_pool::{ResolveSideTransferLaneReq, parse_side_transfer_worker_lane_idx};
 use crate::cluster_manager::NodeIDString;
 use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
 use crate::master_kv_router::msg_pack::{
-    BatchPutDoneItemReq, BatchPutRevokeItemReq, BatchPutStartItemReq,
+    BatchPutDoneItemReq, BatchPutRevokeItemReq, BatchPutStartItemReq, PutDoneCommittedSlot,
 };
 use crate::memholder::MemholderManagerTrait;
 use crate::memholder::NodeHolderKey;
 use crate::memholder::{ExternalMemHolderInfo, UserMemHolder, UserMemHolderExposeKind};
 use crate::p2p::msg_pack::MsgPack;
-use crate::rpcresp_kvresult_convert::msg_and_error::{codes_api, ApiError, KvError, KvResult, OK};
 use crate::rpcresp_kvresult_convert::FromError;
 use crate::rpcresp_kvresult_convert::ToResult;
+use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK, codes_api};
 use async_trait::async_trait;
 use dashmap::mapref::entry::Entry;
-use futures::stream::{self, StreamExt};
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 use std::time::Instant;
 use tracing;
@@ -87,6 +86,146 @@ fn local_committed_cache_publish(
     })
 }
 
+fn external_local_first_error_item(err: &KvError) -> ExternalBatchPutStartItemResp {
+    ExternalBatchPutStartItemResp {
+        put_id: None,
+        ..ExternalBatchPutStartItemResp::from_error(err)
+    }
+}
+
+fn external_local_first_release_keys(inner: &client_kv_api::ClientKvApiInner, keys: &[String]) {
+    for key in keys {
+        inner.release_external_local_first_put_key(key);
+    }
+}
+
+async fn commit_external_local_first_pending(
+    inner: &client_kv_api::ClientKvApiInner,
+    key: &str,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    ctx: &ExternalPendingPutCtx,
+    req_src_offset: u64,
+    req_len: u64,
+    op: &'static str,
+) -> KvResult<PutDoneCommittedSlot> {
+    if ctx.peer_id.is_some() {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "{op} local-first pending ctx must not carry peer_id: key={} put_id=({},{})",
+                key, put_id.0, put_id.1
+            ),
+        }));
+    }
+    if ctx.src_offset != req_src_offset || ctx.len != req_len {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "{op} local-first request mismatches pending ctx: key={} put_id=({},{}) req_src_offset={} ctx_src_offset={} req_len={} ctx_len={}",
+                key, put_id.0, put_id.1, req_src_offset, ctx.src_offset, req_len, ctx.len
+            ),
+        }));
+    }
+    let slot_ref = ctx.local_reserve_slot.as_ref().ok_or_else(|| {
+        KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "{op} pending ctx is not local-first: key={} put_id=({},{})",
+                key, put_id.0, put_id.1
+            ),
+        })
+    })?;
+    let slot_size = ctx.local_reserve_slot_size.ok_or_else(|| {
+        KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "{op} local-first pending ctx missing slot_size: key={} put_id=({},{})",
+                key, put_id.0, put_id.1
+            ),
+        })
+    })?;
+    let len = u32::try_from(req_len).map_err(|_| {
+        KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "{op} local-first len does not fit u32: key={} len={}",
+                key, req_len
+            ),
+        })
+    })?;
+    let memory_info = inner
+        .build_local_reserve_resident_memory_info(
+            key,
+            slot_ref.ptr,
+            len,
+            slot_size,
+            slot_ref.grant_id,
+            slot_ref.slot_index,
+        )
+        .await;
+    inner.install_precommit_local_visible_memory_info(key, memory_info.clone());
+    inner.promote_precommit_local_reserve_resident_slot_if_same(key, put_id, memory_info)?;
+    Ok(PutDoneCommittedSlot {
+        grant_id: slot_ref.grant_id,
+        slot_index: slot_ref.slot_index,
+        slot_size,
+        addr: slot_ref.ptr,
+        base_addr: slot_ref.base_addr,
+        len: req_len,
+    })
+}
+
+fn spawn_external_local_first_publish(
+    inner: &client_kv_api::ClientKvApiInner,
+    key: String,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    lease_id: Option<u64>,
+    committed_slot: PutDoneCommittedSlot,
+) {
+    let view = inner.view.clone_view();
+    let spawn_view = view.clone();
+    spawn_view.spawn("external_local_first_route_publish", async move {
+        let inner = view.client_kv_api().inner();
+        match inner
+            .batch_put_done(vec![BatchPutDoneItemReq {
+                key: key.clone(),
+                put_id,
+                lease_id,
+                committed_slot: Some(committed_slot),
+                publish_local_cache: false,
+            }])
+            .await
+        {
+            Ok(resp) => {
+                if let Some(item) = resp.items.into_iter().next() {
+                    if let Err(err) =
+                        crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)
+                    {
+                        tracing::warn!(
+                            "external local-first route publish failed: key={} put_id=({},{}) err={}",
+                            key,
+                            put_id.0,
+                            put_id.1,
+                            err
+                        );
+                    }
+                } else {
+                    tracing::warn!(
+                        "external local-first route publish returned empty response: key={} put_id=({},{})",
+                        key,
+                        put_id.0,
+                        put_id.1
+                    );
+                }
+            }
+            Err(err) => {
+                tracing::warn!(
+                    "external local-first route publish rpc failed: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
+    });
+}
+
 pub(crate) fn normalize_external_get_start_group_lens(
     keys_len: usize,
     atomic_group_lens: Option<Vec<usize>>,
@@ -769,7 +908,6 @@ impl ClientKvApi {
                     .is_some_and(|peer| peer != owner_id.as_str()),
                 put_id: Some(put_id),
                 lease_id: req.lease_id,
-                write_through: req.write_through,
                 started_time: req.started_time,
                 test_observe_put_phases: req.test_observe_put_phases,
             },
@@ -1222,7 +1360,7 @@ impl HandlerForExternalClient for ClientKvApi {
                 req.len as u32,
                 req.reject_if_inflight_same_key,
                 req.reject_if_exist_same_key,
-                req.write_through,
+                req.make_replica_task,
                 req.preferred_sub_cluster.as_deref(),
                 source_node_id,
             )
@@ -1256,6 +1394,16 @@ impl HandlerForExternalClient for ClientKvApi {
             src_offset
         };
         let remote_offset = put_start_resp.target_addr - put_start_resp.target_base_addr;
+        let replica_target =
+            put_start_resp
+                .replica_target
+                .as_ref()
+                .map(|target| ReplicaTaskTarget {
+                    node_id: target.node_id.clone(),
+                    target_offset: target.target_addr - target.target_base_addr,
+                    target_base_addr: target.target_base_addr,
+                    len: target.len,
+                });
         inner.external_pending_puts.insert(
             (
                 req.key.clone(),
@@ -1276,7 +1424,11 @@ impl HandlerForExternalClient for ClientKvApi {
                     remote_offset
                 },
                 len: req.len,
+                make_replica_task: req.make_replica_task && replica_target.is_some(),
                 preferred_sub_cluster: req.preferred_sub_cluster.clone(),
+                replica_target,
+                local_reserve_slot: None,
+                local_reserve_slot_size: None,
             },
         );
         if !is_local_target {
@@ -1337,94 +1489,93 @@ impl HandlerForExternalClient for ClientKvApi {
 
         self.validate_requester_owner_status_updated(req.started_time)?;
 
-        let start_resp = inner
-            .batch_put_start(
-                req.items
-                    .iter()
-                    .map(|item| BatchPutStartItemReq {
-                        key: item.key.clone(),
-                        len: item.len,
-                        reject_if_inflight_same_key: item.reject_if_inflight_same_key,
-                        reject_if_exist_same_key: item.reject_if_exist_same_key,
-                        write_through: item.write_through,
-                        preferred_sub_cluster: item.preferred_sub_cluster.clone(),
-                    })
-                    .collect(),
-            )
-            .await?;
-        if start_resp.items.len() != req.items.len() {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "external_batch_put_start response length mismatch: expected={} got={}",
-                    req.items.len(),
-                    start_resp.items.len()
-                ),
+        let Some(first_item) = req.items.first() else {
+            return Ok(ExternalBatchPutStartResp {
+                items: Vec::new(),
+                error_code: OK,
+                error_json: String::new(),
+            });
+        };
+        let value_len = first_item.len;
+        if req.items.iter().any(|item| item.len != value_len) {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "external_batch_put_start local-first requires uniform item len"
+                    .to_string(),
             }));
         }
 
-        let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
-        let mut items = Vec::with_capacity(req.items.len());
-        for (req_item, start_item) in req.items.into_iter().zip(start_resp.items.into_iter()) {
-            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
-                start_item.error_code,
-                start_item.error_json.clone(),
+        let mut reserved_keys = Vec::with_capacity(req.items.len());
+        for item in &req.items {
+            if let Err(err) = inner.reserve_external_local_first_put_key(
+                &item.key,
+                item.reject_if_inflight_same_key,
+                item.reject_if_exist_same_key,
             ) {
-                items.push(ExternalBatchPutStartItemResp {
-                    put_id: None,
-                    ..ExternalBatchPutStartItemResp::from_error(&err)
+                external_local_first_release_keys(inner, &reserved_keys);
+                let items = req
+                    .items
+                    .iter()
+                    .map(|_| external_local_first_error_item(&err))
+                    .collect();
+                return Ok(ExternalBatchPutStartResp {
+                    items,
+                    error_code: OK,
+                    error_json: String::new(),
                 });
-                continue;
             }
+            reserved_keys.push(item.key.clone());
+        }
 
-            let src_offset = start_item.src_addr - start_item.src_base_addr;
-            let is_local_target = start_item.node_id == self_node_id;
-            let target_offset = if is_local_target {
-                start_item.target_addr - start_item.target_base_addr
-            } else {
-                src_offset
-            };
-            let remote_offset = start_item.target_addr - start_item.target_base_addr;
+        let slot_lease = match inner
+            .owner_claim_local_reserve_slot_lease(value_len, req.items.len())
+            .await
+        {
+            Ok(slot_lease) => slot_lease,
+            Err(err) => {
+                external_local_first_release_keys(inner, &reserved_keys);
+                return Err(err);
+            }
+        };
+        let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
+        let mut items = Vec::with_capacity(req.items.len());
+        for (req_item, slot_ref) in req.items.into_iter().zip(slot_lease.slots.into_iter()) {
+            let put_id = inner.next_external_local_first_put_id();
+            let src_offset = slot_ref.ptr.saturating_sub(slot_ref.base_addr);
             inner.external_pending_puts.insert(
-                (
-                    req_item.key.clone(),
-                    start_item.put_id.0,
-                    start_item.put_id.1,
-                ),
+                (req_item.key.clone(), put_id.0, put_id.1),
                 ExternalPendingPutCtx {
-                    peer_id: if is_local_target {
-                        None
-                    } else {
-                        Some(start_item.node_id.clone())
-                    },
+                    peer_id: None,
                     src_offset,
-                    target_base_addr: start_item.target_base_addr,
-                    target_offset: if is_local_target {
-                        target_offset
-                    } else {
-                        remote_offset
-                    },
+                    target_base_addr: slot_ref.base_addr,
+                    target_offset: src_offset,
                     len: req_item.len,
+                    make_replica_task: req_item.make_replica_task,
                     preferred_sub_cluster: req_item.preferred_sub_cluster.clone(),
+                    replica_target: None,
+                    local_reserve_slot: Some(slot_ref.clone()),
+                    local_reserve_slot_size: Some(slot_lease.slot_size),
                 },
             );
+            tracing::debug!(
+                "external_batch_put_start local-first: key={} put_id=({},{}) node_id={} base={:#x} offset={:#x} len={}",
+                req_item.key,
+                put_id.0,
+                put_id.1,
+                self_node_id,
+                slot_ref.base_addr,
+                src_offset,
+                req_item.len
+            );
             items.push(ExternalBatchPutStartItemResp {
                 error_code: OK,
                 src_offset,
-                target_offset,
-                transfer_target_offset: if is_local_target {
-                    None
-                } else {
-                    Some(remote_offset)
-                },
-                peer_id: if is_local_target {
-                    None
-                } else {
-                    Some(start_item.node_id)
-                },
-                src_base_addr: start_item.src_base_addr,
-                target_base_addr: start_item.target_base_addr,
+                target_offset: src_offset,
+                transfer_target_offset: None,
+                peer_id: None,
+                src_base_addr: slot_ref.base_addr,
+                target_base_addr: slot_ref.base_addr,
                 error_json: String::new(),
-                put_id: Some(start_item.put_id),
+                put_id: Some(put_id),
             });
         }
 
@@ -1462,23 +1613,27 @@ impl HandlerForExternalClient for ClientKvApi {
             .external_pending_puts
             .get(&(req.key.clone(), put_id.0, put_id.1))
             .map(|ctx| ctx.clone());
-        let preferred_sub_cluster = pending_ctx
+        let replica_target = pending_ctx
+            .as_ref()
+            .and_then(|ctx| ctx.replica_target.clone());
+        let admitted_replica_task = pending_ctx
             .as_ref()
-            .and_then(|ctx| ctx.preferred_sub_cluster.clone());
+            .map(|ctx| ctx.make_replica_task)
+            .unwrap_or(false);
         let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
         let req_remote_target = req
             .peer_id
             .as_deref()
             .is_some_and(|peer| peer != self_node_id.as_str());
-        let has_remote_append = pending_ctx
+        let has_remote_target = pending_ctx
             .as_ref()
             .and_then(|ctx| ctx.peer_id.as_ref())
             .is_some();
-        if pending_ctx.is_some() && req_remote_target != has_remote_append {
+        if pending_ctx.is_some() && req_remote_target != has_remote_target {
             let err = KvError::Api(ApiError::InvalidArgument {
                 detail: format!(
                     "external_put_transfer_end peer_id mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
-                    req.key, put_id.0, put_id.1, req_remote_target, has_remote_append
+                    req.key, put_id.0, put_id.1, req_remote_target, has_remote_target
                 ),
             });
             if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
@@ -1495,120 +1650,8 @@ impl HandlerForExternalClient for ClientKvApi {
                 .invalidate(&(req.key.clone(), put_id.0, put_id.1));
             return Ok(ExternalPutTransferEndResp::from_error(&err));
         }
-
-        // Delegate transfer to owner put_transfer (offset-based) then end
-        // For remote target, ignore caller's target_offset (staging) and use stashed remote ctx.
-        let (peer_id_for_transfer, target_off_for_transfer, target_base_for_transfer) =
-            if let Some(peer) = req.peer_id.clone() {
-                if peer == self_node_id.as_ref() {
-                    (None, req.target_offset, None)
-                } else {
-                    match pending_ctx.as_ref() {
-                        Some(ctx) if ctx.peer_id.is_some() => (
-                            ctx.peer_id.clone(),
-                            ctx.target_offset,
-                            Some(ctx.target_base_addr),
-                        ),
-                        None => match req.target_base_addr {
-                            Some(target_base_addr) => {
-                                (Some(peer.into()), req.target_offset, Some(target_base_addr))
-                            }
-                            None => {
-                                let err = KvError::Unreachable(
-                                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                                        rpc_input_json: format!(
-                                            "missing pending remote put ctx and caller target_base_addr; key={}, put_id=({},{}), peer_id={}",
-                                            req.key, put_id.0, put_id.1, peer
-                                        ),
-                                    },
-                                );
-                                return Ok(ExternalPutTransferEndResp::from_error(&err));
-                            }
-                        },
-                        Some(_) => match req.target_base_addr {
-                            Some(target_base_addr) => {
-                                (Some(peer.into()), req.target_offset, Some(target_base_addr))
-                            }
-                            None => {
-                                let err = KvError::Unreachable(
-                                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                                        rpc_input_json: format!(
-                                            "pending local ctx conflicted with remote external_put_transfer_end; key={}, put_id=({},{}), peer_id={}",
-                                            req.key, put_id.0, put_id.1, peer
-                                        ),
-                                    },
-                                );
-                                return Ok(ExternalPutTransferEndResp::from_error(&err));
-                            }
-                        },
-                    }
-                }
-            } else {
-                (None, req.target_offset, None)
-            };
-        let transfer_peer_id_for_trace = peer_id_for_transfer.as_ref().map(|peer| peer.to_string());
-
-        tracing::debug!(
-            "external_put_transfer_end resolved: key={}, put_id=({},{}) src_off={:#x}, tgt_off={:#x}, len={}, peer_id={:?}, target_base={:?}",
-            req.key,
-            put_id.0,
-            put_id.1,
-            req.src_offset,
-            target_off_for_transfer,
-            req.len,
-            peer_id_for_transfer,
-            target_base_for_transfer
-        );
-
-        let transfer_started_at = Instant::now();
-        let mut put_locality_recorded = false;
-        if req.write_through {
-            let transfer_result = inner
-                .put_transfer(
-                    &req.key,
-                    put_id,
-                    req.src_offset,
-                    target_off_for_transfer,
-                    req.len,
-                    peer_id_for_transfer,
-                    target_base_for_transfer,
-                )
-                .await;
-            match transfer_result {
-                Ok(breakdown) => {
-                    let breakdown_transfer_us = breakdown.submit_blocking_us
-                        + breakdown.create_xfer_req_us
-                        + breakdown.post_xfer_req_us
-                        + breakdown.poll_wait_us;
-                    inner.record_put_locality(
-                        breakdown.remote_transfer,
-                        req.len,
-                        breakdown_transfer_us,
-                    );
-                    put_locality_recorded = true;
-                }
-                Err(e) => {
-                    tracing::error!("Failed to transfer data: {}", e);
-                    // On transfer failure, revoke the put to release resources
-                    if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                        tracing::warn!(
-                            "put_revoke also failed after transfer error: {}",
-                            revoke_err
-                        );
-                    }
-                    // Cleanup pending ctx on failure
-                    inner
-                        .external_pending_puts
-                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-                    return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&e));
-                }
-            }
-        }
-
-        let put_transfer_total_us = duration_to_i64_us(transfer_started_at.elapsed());
-        if req.write_through && !put_locality_recorded {
-            inner.record_put_locality(false, req.len, 0);
-        }
+        let put_transfer_total_us = 0;
+        let transfer_peer_id_for_trace = None;
 
         if inner.skip_put_end_commit_enabled() {
             inner
@@ -1640,35 +1683,31 @@ impl HandlerForExternalClient for ClientKvApi {
         }
 
         let end_started_at = Instant::now();
-        let publish_local_cache = !req.write_through || !req_remote_target;
-        let local_cache_publish = if publish_local_cache {
-            match local_committed_cache_publish(
-                "external_put_transfer_end",
-                &req.key,
-                put_id,
-                pending_ctx.as_ref(),
-                req.src_offset,
-                req.len,
-            ) {
-                Ok(publish) => Some(publish),
-                Err(err) => {
-                    if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                        tracing::warn!(
-                            "external_put_transfer_end put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
-                            req.key,
-                            put_id.0,
-                            put_id.1,
-                            revoke_err
-                        );
-                    }
-                    inner
-                        .external_pending_puts
-                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-                    return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
+        let publish_local_cache = true;
+        let local_cache_publish = match local_committed_cache_publish(
+            "external_put_transfer_end",
+            &req.key,
+            put_id,
+            pending_ctx.as_ref(),
+            req.src_offset,
+            req.len,
+        ) {
+            Ok(publish) => publish,
+            Err(err) => {
+                if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                    tracing::warn!(
+                        "external_put_transfer_end put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
+                        req.key,
+                        put_id.0,
+                        put_id.1,
+                        revoke_err
+                    );
                 }
+                inner
+                    .external_pending_puts
+                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
             }
-        } else {
-            None
         };
         let put_end = match inner
             .put_end_with_local_cache_publish(&req.key, put_id, req.lease_id, publish_local_cache)
@@ -1686,46 +1725,43 @@ impl HandlerForExternalClient for ClientKvApi {
         let put_end_stats = put_end.stats;
         let put_end_total_us = duration_to_i64_us(end_started_at.elapsed());
 
-        if publish_local_cache {
-            let Some(holder_id) = put_end.local_cache_holder_id else {
-                let err = KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "external_put_transfer_end missing local cache holder after local commit: key={} put_id=({},{})",
-                        req.key, put_id.0, put_id.1
-                    ),
-                });
-                inner
-                    .external_pending_puts
-                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-                return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
-            };
-            let publish = local_cache_publish
-                .as_ref()
-                .expect("publish_local_cache precheck must provide local cache publish info");
+        let Some(holder_id) = put_end.local_cache_holder_id else {
+            let err = KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_put_transfer_end missing local cache holder after local commit: key={} put_id=({},{})",
+                    req.key, put_id.0, put_id.1
+                ),
+            });
             inner
-                .install_local_committed_memory_info(
-                    &req.key,
-                    put_id,
-                    publish.src_offset,
-                    publish.len,
-                    holder_id,
-                )
-                .await?;
-        }
+                .external_pending_puts
+                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+            return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
+        };
+        inner
+            .install_local_committed_memory_info(
+                &req.key,
+                put_id,
+                local_cache_publish.src_offset,
+                local_cache_publish.len,
+                holder_id,
+            )
+            .await?;
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-        if !req.write_through && (has_remote_append || req_remote_target) {
+        if admitted_replica_task && replica_target.is_some() {
             if let Err(err) = inner
-                .enqueue_write_back_remote_append(
+                .make_replica_task(
                     &req.key,
                     put_id,
-                    preferred_sub_cluster.as_deref(),
+                    replica_target
+                        .clone()
+                        .expect("make_replica_task requires pre-reserved replica target"),
                 )
                 .await
             {
                 tracing::warn!(
-                    "write-back external_put_transfer_end enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                    "external_put_transfer_end make replica task failed after local commit: key={} put_id=({},{}) err={}",
                     req.key,
                     put_id.0,
                     put_id.1,
@@ -1784,18 +1820,15 @@ impl HandlerForExternalClient for ClientKvApi {
             lease_id: Option<u64>,
             len: u64,
             put_locality: Option<(bool, i64)>,
-            remember_local_snapshot: bool,
-            publish_local_cache: bool,
-            local_cache_publish: Option<LocalCommittedCachePublish>,
-            enqueue_write_back_append: bool,
-            preferred_sub_cluster: Option<String>,
+            local_cache_publish: LocalCommittedCachePublish,
+            make_replica_task: bool,
+            replica_target: Option<ReplicaTaskTarget>,
         }
 
         let mut results: Vec<Option<ExternalBatchPutTransferEndItemResp>> =
             (0..req.items.len()).map(|_| None).collect();
         let mut done_pending = Vec::new();
         let mut revoke_pending = Vec::new();
-        let mut transfer_futures = Vec::new();
 
         for (idx, item) in req.items.into_iter().enumerate() {
             let Some(put_id) = item.put_id else {
@@ -1815,17 +1848,77 @@ impl HandlerForExternalClient for ClientKvApi {
                 .external_pending_puts
                 .get(&(item.key.clone(), put_id.0, put_id.1))
                 .map(|ctx| ctx.clone());
-            let preferred_sub_cluster = pending_ctx
-                .as_ref()
-                .and_then(|ctx| ctx.preferred_sub_cluster.clone());
+            if let Some(ctx) = pending_ctx.as_ref() {
+                if ctx.local_reserve_slot.is_some() {
+                    if item.peer_id.is_some() {
+                        let err = KvError::Api(ApiError::InvalidArgument {
+                            detail: format!(
+                                "external_batch_put_transfer_end local-first item must be local target: key={} put_id=({},{})",
+                                item.key, put_id.0, put_id.1
+                            ),
+                        });
+                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                        inner.external_pending_puts.invalidate(&(
+                            item.key.clone(),
+                            put_id.0,
+                            put_id.1,
+                        ));
+                        inner.release_external_local_first_put_key(&item.key);
+                        continue;
+                    }
+                    match commit_external_local_first_pending(
+                        inner,
+                        &item.key,
+                        put_id,
+                        ctx,
+                        item.src_offset,
+                        item.len,
+                        "external_batch_put_transfer_end",
+                    )
+                    .await
+                    {
+                        Ok(committed_slot) => {
+                            inner.record_put_locality(false, item.len, 0);
+                            inner.external_pending_puts.invalidate(&(
+                                item.key.clone(),
+                                put_id.0,
+                                put_id.1,
+                            ));
+                            inner.release_external_local_first_put_key(&item.key);
+                            spawn_external_local_first_publish(
+                                inner,
+                                item.key.clone(),
+                                put_id,
+                                item.lease_id,
+                                committed_slot,
+                            );
+                            results[idx] = Some(ExternalBatchPutTransferEndItemResp {
+                                error_code: OK,
+                                error_json: String::new(),
+                            });
+                        }
+                        Err(err) => {
+                            inner.external_pending_puts.invalidate(&(
+                                item.key.clone(),
+                                put_id.0,
+                                put_id.1,
+                            ));
+                            inner.release_external_local_first_put_key(&item.key);
+                            results[idx] =
+                                Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                        }
+                    }
+                    continue;
+                }
+            }
             let has_remote_append = pending_ctx
                 .as_ref()
                 .and_then(|ctx| ctx.peer_id.as_ref())
                 .is_some();
-            if item.peer_id.is_some() != has_remote_append {
+            if item.peer_id.is_some() || has_remote_append {
                 let err = KvError::Api(ApiError::InvalidArgument {
                     detail: format!(
-                        "external_batch_put_transfer_end peer_id mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                        "external_batch_put_transfer_end remote primary target is no longer supported: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
                         item.key,
                         put_id.0,
                         put_id.1,
@@ -1843,193 +1936,49 @@ impl HandlerForExternalClient for ClientKvApi {
                     .invalidate(&(item.key.clone(), put_id.0, put_id.1));
                 continue;
             }
-            let remember_local_snapshot = !item.write_through || item.peer_id.is_none();
-            let publish_local_cache = remember_local_snapshot;
-            let enqueue_write_back_append = !item.write_through && item.peer_id.is_some();
-            let local_cache_publish = if publish_local_cache {
-                match local_committed_cache_publish(
-                    "external_batch_put_transfer_end",
-                    &item.key,
-                    put_id,
-                    pending_ctx.as_ref(),
-                    item.src_offset,
-                    item.len,
-                ) {
-                    Ok(publish) => Some(publish),
-                    Err(err) => {
-                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
-                        revoke_pending.push(BatchPutRevokeItemReq {
-                            key: item.key.clone(),
-                            put_id,
-                        });
-                        inner.external_pending_puts.invalidate(&(
-                            item.key.clone(),
-                            put_id.0,
-                            put_id.1,
-                        ));
-                        continue;
-                    }
-                }
-            } else {
-                None
-            };
-
-            let transfer_args = if let Some(peer) = item.peer_id.clone() {
-                match pending_ctx.as_ref() {
-                    Some(ctx) if ctx.peer_id.is_some() => {
-                        Ok((ctx.peer_id.clone(), ctx.target_offset, Some(ctx.target_base_addr)))
-                    }
-                    None => match item.target_base_addr {
-                        Some(target_base_addr) => {
-                            Ok((Some(peer.into()), item.target_offset, Some(target_base_addr)))
-                        }
-                        None => Err(KvError::Unreachable(
-                            crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                                rpc_input_json: format!(
-                                    "missing pending remote put ctx and caller target_base_addr in external_batch_put_transfer_end; key={}, put_id=({},{}), peer_id={}",
-                                    item.key, put_id.0, put_id.1, peer
-                                ),
-                            },
-                        )),
-                    },
-                    Some(_) => match item.target_base_addr {
-                        Some(target_base_addr) => {
-                            Ok((Some(peer.into()), item.target_offset, Some(target_base_addr)))
-                        }
-                        None => Err(KvError::Unreachable(
-                            crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                                rpc_input_json: format!(
-                                    "pending local ctx conflicted with remote external_batch_put_transfer_end; key={}, put_id=({},{}), peer_id={}",
-                                    item.key, put_id.0, put_id.1, peer
-                                ),
-                            },
-                        )),
-                    },
-                }
-            } else {
-                Ok((None, item.target_offset, None))
-            };
-            let (peer_id_for_transfer, target_off_for_transfer, target_base_for_transfer) =
-                match transfer_args {
-                    Ok(v) => v,
-                    Err(err) => {
-                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
-                        continue;
-                    }
-                };
-
-            if !item.write_through {
-                done_pending.push(DonePending {
-                    idx,
-                    key: item.key,
-                    put_id,
-                    lease_id: item.lease_id,
-                    len: item.len,
-                    put_locality: Some((false, 0)),
-                    remember_local_snapshot,
-                    publish_local_cache,
-                    local_cache_publish,
-                    enqueue_write_back_append,
-                    preferred_sub_cluster,
-                });
-                continue;
-            }
-
-            transfer_futures.push(async move {
-                let transfer_started_at = Instant::now();
-                let transfer_result = inner
-                    .put_transfer(
-                        &item.key,
-                        put_id,
-                        item.src_offset,
-                        target_off_for_transfer,
-                        item.len,
-                        peer_id_for_transfer,
-                        target_base_for_transfer,
-                    )
-                    .await;
-                (
-                    idx,
-                    item.key,
-                    item.len,
-                    put_id,
-                    item.lease_id,
-                    remember_local_snapshot,
-                    publish_local_cache,
-                    local_cache_publish,
-                    preferred_sub_cluster,
-                    duration_to_i64_us(transfer_started_at.elapsed()),
-                    transfer_result,
-                )
-            });
-        }
-
-        let transfer_concurrency = req.transfer_concurrency.max(1);
-        let mut transfer_stream =
-            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
-        while let Some(joined) = transfer_stream.next().await {
-            match joined {
-                (
-                    idx,
-                    key,
-                    len,
-                    put_id,
-                    lease_id,
-                    remember_local_snapshot,
-                    publish_local_cache,
-                    local_cache_publish,
-                    preferred_sub_cluster,
-                    wall_transfer_us,
-                    Ok(breakdown),
-                ) => {
-                    let breakdown_transfer_us = breakdown.submit_blocking_us
-                        + breakdown.create_xfer_req_us
-                        + breakdown.post_xfer_req_us
-                        + breakdown.poll_wait_us;
-                    let transfer_us = breakdown_transfer_us.max(wall_transfer_us);
-                    done_pending.push(DonePending {
-                        idx,
-                        key,
-                        put_id,
-                        lease_id,
-                        len,
-                        put_locality: Some((breakdown.remote_transfer, transfer_us)),
-                        remember_local_snapshot,
-                        publish_local_cache,
-                        local_cache_publish,
-                        enqueue_write_back_append: false,
-                        preferred_sub_cluster,
-                    });
-                }
-                (
-                    idx,
-                    key,
-                    _len,
-                    put_id,
-                    _lease_id,
-                    _remember_local_snapshot,
-                    _publish_local_cache,
-                    _local_cache_publish,
-                    _preferred_sub_cluster,
-                    _wall_transfer_us,
-                    Err(err),
-                ) => {
+            let local_cache_publish = match local_committed_cache_publish(
+                "external_batch_put_transfer_end",
+                &item.key,
+                put_id,
+                pending_ctx.as_ref(),
+                item.src_offset,
+                item.len,
+            ) {
+                Ok(publish) => publish,
+                Err(err) => {
                     results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
                     revoke_pending.push(BatchPutRevokeItemReq {
-                        key: key.clone(),
+                        key: item.key.clone(),
                         put_id,
                     });
                     inner
                         .external_pending_puts
-                        .invalidate(&(key, put_id.0, put_id.1));
+                        .invalidate(&(item.key.clone(), put_id.0, put_id.1));
+                    continue;
                 }
-            }
+            };
+            done_pending.push(DonePending {
+                idx,
+                key: item.key,
+                put_id,
+                lease_id: item.lease_id,
+                len: item.len,
+                put_locality: Some((false, 0)),
+                local_cache_publish,
+                make_replica_task: pending_ctx
+                    .as_ref()
+                    .map(|ctx| ctx.make_replica_task)
+                    .unwrap_or(false),
+                replica_target: pending_ctx
+                    .as_ref()
+                    .and_then(|ctx| ctx.replica_target.clone()),
+            });
         }
 
         if !revoke_pending.is_empty() {
             if let Err(err) = inner.batch_put_revoke(revoke_pending).await {
                 tracing::warn!(
-                    "external_batch_put_transfer_end batch_put_revoke failed after transfer errors: {}",
+                    "external_batch_put_transfer_end batch_put_revoke failed after precheck errors: {}",
                     err
                 );
             }
@@ -2074,7 +2023,7 @@ impl HandlerForExternalClient for ClientKvApi {
                         put_id: pending.put_id,
                         lease_id: pending.lease_id,
                         committed_slot: None,
-                        publish_local_cache: pending.publish_local_cache,
+                        publish_local_cache: true,
                     })
                     .collect(),
             )
@@ -2105,42 +2054,34 @@ impl HandlerForExternalClient for ClientKvApi {
             if let Some((remote, transfer_us)) = pending.put_locality {
                 inner.record_put_locality(remote, pending.len, transfer_us);
             }
-            if pending.publish_local_cache {
-                let Some(holder_id) = done_item.local_cache_holder_id else {
-                    return Err(KvError::Api(ApiError::Unknown {
-                        detail: format!(
-                            "external_batch_put_transfer_end missing local cache holder after local commit: key={} put_id=({},{})",
-                            pending.key, pending.put_id.0, pending.put_id.1
-                        ),
-                    }));
-                };
-                let publish = pending
-                    .local_cache_publish
-                    .as_ref()
-                    .expect("publish_local_cache precheck must provide local cache publish info");
-                inner
-                    .install_local_committed_memory_info(
-                        &pending.key,
-                        pending.put_id,
-                        publish.src_offset,
-                        publish.len,
-                        holder_id,
-                    )
-                    .await?;
-            } else if pending.remember_local_snapshot {
-                inner.remember_local_snapshot(&pending.key, pending.put_id);
-            }
-            if pending.enqueue_write_back_append {
+            let Some(holder_id) = done_item.local_cache_holder_id else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external_batch_put_transfer_end missing local cache holder after local commit: key={} put_id=({},{})",
+                        pending.key, pending.put_id.0, pending.put_id.1
+                    ),
+                }));
+            };
+            inner
+                .install_local_committed_memory_info(
+                    &pending.key,
+                    pending.put_id,
+                    pending.local_cache_publish.src_offset,
+                    pending.local_cache_publish.len,
+                    holder_id,
+                )
+                .await?;
+            if pending.make_replica_task {
+                let target = pending
+                    .replica_target
+                    .clone()
+                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = inner
-                    .enqueue_write_back_remote_append(
-                        &pending.key,
-                        pending.put_id,
-                        pending.preferred_sub_cluster.as_deref(),
-                    )
+                    .make_replica_task(&pending.key, pending.put_id, target)
                     .await
                 {
                     tracing::warn!(
-                        "external_batch_put_transfer_end write-back enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        "external_batch_put_transfer_end make replica task failed after local commit: key={} put_id=({},{}) err={}",
                         pending.key,
                         pending.put_id.0,
                         pending.put_id.1,
@@ -2190,18 +2131,53 @@ impl HandlerForExternalClient for ClientKvApi {
             .external_pending_puts
             .get(&(req.key.clone(), put_id.0, put_id.1))
             .map(|ctx| ctx.clone());
-        if let Some(ctx) = pending_ctx.as_ref() {
-            let has_remote_append = ctx.peer_id.is_some();
-            if req.remote_target != has_remote_append {
-                let err = KvError::Api(ApiError::InvalidArgument {
-                    detail: format!(
-                        "external_put_commit remote_target mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
-                        req.key, put_id.0, put_id.1, req.remote_target, has_remote_append
-                    ),
-                });
+        let has_remote_append = pending_ctx
+            .as_ref()
+            .and_then(|ctx| ctx.peer_id.as_ref())
+            .is_some();
+        if req.remote_target || has_remote_append {
+            let err = KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "external_put_commit remote primary target is no longer supported: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                    req.key, put_id.0, put_id.1, req.remote_target, has_remote_append
+                ),
+            });
+            if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
+                tracing::warn!(
+                    "external_put_commit put_revoke failed after remote primary target: key={} put_id=({},{}) err={}",
+                    req.key,
+                    put_id.0,
+                    put_id.1,
+                    revoke_err
+                );
+            }
+            inner
+                .external_pending_puts
+                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+            return Ok(ExternalPutCommitResp::from_error(&err));
+        }
+        let replica_target = pending_ctx
+            .as_ref()
+            .and_then(|ctx| ctx.replica_target.clone());
+        let admitted_replica_task = pending_ctx
+            .as_ref()
+            .map(|ctx| ctx.make_replica_task)
+            .unwrap_or(false);
+
+        let end_started_at = Instant::now();
+        let local_cache_publish = match local_committed_cache_publish(
+            "external_put_commit",
+            &req.key,
+            put_id,
+            pending_ctx.as_ref(),
+            req.src_offset,
+            req.len,
+        ) {
+            Ok(publish) => publish,
+            Err(err) => {
                 if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
                     tracing::warn!(
-                        "external_put_commit put_revoke failed after remote_target mismatch: key={} put_id=({},{}) err={}",
+                        "external_put_commit put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
                         req.key,
                         put_id.0,
                         put_id.1,
@@ -2213,46 +2189,9 @@ impl HandlerForExternalClient for ClientKvApi {
                     .invalidate(&(req.key.clone(), put_id.0, put_id.1));
                 return Ok(ExternalPutCommitResp::from_error(&err));
             }
-        }
-        let remember_local_snapshot = !req.write_through || !req.remote_target;
-        let enqueue_write_back_append = !req.write_through && req.remote_target;
-        let preferred_sub_cluster = pending_ctx
-            .as_ref()
-            .and_then(|ctx| ctx.preferred_sub_cluster.clone());
-
-        let end_started_at = Instant::now();
-        let publish_local_cache = remember_local_snapshot;
-        let local_cache_publish = if publish_local_cache {
-            match local_committed_cache_publish(
-                "external_put_commit",
-                &req.key,
-                put_id,
-                pending_ctx.as_ref(),
-                req.src_offset,
-                req.len,
-            ) {
-                Ok(publish) => Some(publish),
-                Err(err) => {
-                    if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                        tracing::warn!(
-                            "external_put_commit put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
-                            req.key,
-                            put_id.0,
-                            put_id.1,
-                            revoke_err
-                        );
-                    }
-                    inner
-                        .external_pending_puts
-                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-                    return Ok(ExternalPutCommitResp::from_error(&err));
-                }
-            }
-        } else {
-            None
         };
         let put_end = match inner
-            .put_end_with_local_cache_publish(&req.key, put_id, req.lease_id, publish_local_cache)
+            .put_end_with_local_cache_publish(&req.key, put_id, req.lease_id, true)
             .await
         {
             Ok(end) => end,
@@ -2265,46 +2204,43 @@ impl HandlerForExternalClient for ClientKvApi {
         };
         let put_end_stats = put_end.stats;
         let put_end_total_us = duration_to_i64_us(end_started_at.elapsed());
-        if publish_local_cache {
-            let Some(holder_id) = put_end.local_cache_holder_id else {
-                let err = KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "external_put_commit missing local cache holder after local commit: key={} put_id=({},{})",
-                        req.key, put_id.0, put_id.1
-                    ),
-                });
-                inner
-                    .external_pending_puts
-                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-                return Ok(ExternalPutCommitResp::from_error(&err));
-            };
-            let publish = local_cache_publish
-                .as_ref()
-                .expect("publish_local_cache precheck must provide local cache publish info");
+        let Some(holder_id) = put_end.local_cache_holder_id else {
+            let err = KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_put_commit missing local cache holder after local commit: key={} put_id=({},{})",
+                    req.key, put_id.0, put_id.1
+                ),
+            });
             inner
-                .install_local_committed_memory_info(
-                    &req.key,
-                    put_id,
-                    publish.src_offset,
-                    publish.len,
-                    holder_id,
-                )
-                .await?;
-        }
+                .external_pending_puts
+                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+            return Ok(ExternalPutCommitResp::from_error(&err));
+        };
+        inner
+            .install_local_committed_memory_info(
+                &req.key,
+                put_id,
+                local_cache_publish.src_offset,
+                local_cache_publish.len,
+                holder_id,
+            )
+            .await?;
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-        if enqueue_write_back_append {
+        if admitted_replica_task && replica_target.is_some() {
             if let Err(err) = inner
-                .enqueue_write_back_remote_append(
+                .make_replica_task(
                     &req.key,
                     put_id,
-                    preferred_sub_cluster.as_deref(),
+                    replica_target
+                        .clone()
+                        .expect("make_replica_task requires pre-reserved replica target"),
                 )
                 .await
             {
                 tracing::warn!(
-                    "write-back external_put_commit enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                    "external_put_commit make replica task failed after local commit: key={} put_id=({},{}) err={}",
                     req.key,
                     put_id.0,
                     put_id.1,
@@ -2354,11 +2290,9 @@ impl HandlerForExternalClient for ClientKvApi {
             key: String,
             put_id: crate::master_kv_router::put::PutIDForAKey,
             lease_id: Option<u64>,
-            remember_local_snapshot: bool,
-            publish_local_cache: bool,
-            local_cache_publish: Option<LocalCommittedCachePublish>,
-            enqueue_write_back_append: bool,
-            preferred_sub_cluster: Option<String>,
+            local_cache_publish: LocalCommittedCachePublish,
+            make_replica_task: bool,
+            replica_target: Option<ReplicaTaskTarget>,
         }
 
         let mut results: Vec<Option<ExternalBatchPutCommitItemResp>> =
@@ -2384,14 +2318,98 @@ impl HandlerForExternalClient for ClientKvApi {
                 .get(&(item.key.clone(), put_id.0, put_id.1))
                 .map(|ctx| ctx.clone());
             if let Some(ctx) = pending_ctx.as_ref() {
-                let has_remote_append = ctx.peer_id.is_some();
-                if item.remote_target != has_remote_append {
-                    let err = KvError::Api(ApiError::InvalidArgument {
-                        detail: format!(
-                            "external_batch_put_commit remote_target mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
-                            item.key, put_id.0, put_id.1, item.remote_target, has_remote_append
-                        ),
-                    });
+                if ctx.local_reserve_slot.is_some() {
+                    if item.remote_target {
+                        let err = KvError::Api(ApiError::InvalidArgument {
+                            detail: format!(
+                                "external_batch_put_commit local-first item must be local target: key={} put_id=({},{})",
+                                item.key, put_id.0, put_id.1
+                            ),
+                        });
+                        results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                        inner.external_pending_puts.invalidate(&(
+                            item.key.clone(),
+                            put_id.0,
+                            put_id.1,
+                        ));
+                        inner.release_external_local_first_put_key(&item.key);
+                        continue;
+                    }
+                    match commit_external_local_first_pending(
+                        inner,
+                        &item.key,
+                        put_id,
+                        ctx,
+                        item.src_offset,
+                        item.len,
+                        "external_batch_put_commit",
+                    )
+                    .await
+                    {
+                        Ok(committed_slot) => {
+                            inner.record_put_locality(false, item.len, 0);
+                            inner.external_pending_puts.invalidate(&(
+                                item.key.clone(),
+                                put_id.0,
+                                put_id.1,
+                            ));
+                            inner.release_external_local_first_put_key(&item.key);
+                            spawn_external_local_first_publish(
+                                inner,
+                                item.key.clone(),
+                                put_id,
+                                item.lease_id,
+                                committed_slot,
+                            );
+                            results[idx] = Some(ExternalBatchPutCommitItemResp {
+                                error_code: OK,
+                                error_json: String::new(),
+                            });
+                        }
+                        Err(err) => {
+                            inner.external_pending_puts.invalidate(&(
+                                item.key.clone(),
+                                put_id.0,
+                                put_id.1,
+                            ));
+                            inner.release_external_local_first_put_key(&item.key);
+                            results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                        }
+                    }
+                    continue;
+                }
+            }
+            let has_remote_append = pending_ctx
+                .as_ref()
+                .and_then(|ctx| ctx.peer_id.as_ref())
+                .is_some();
+            if item.remote_target || has_remote_append {
+                let err = KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "external_batch_put_commit remote primary target is no longer supported: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
+                        item.key, put_id.0, put_id.1, item.remote_target, has_remote_append
+                    ),
+                });
+                results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                revoke_pending.push(BatchPutRevokeItemReq {
+                    key: item.key.clone(),
+                    put_id,
+                });
+                inner
+                    .external_pending_puts
+                    .invalidate(&(item.key.clone(), put_id.0, put_id.1));
+                continue;
+            };
+            let local_cache_publish = match local_committed_cache_publish(
+                "external_batch_put_commit",
+                &item.key,
+                put_id,
+                pending_ctx.as_ref(),
+                item.src_offset,
+                item.len,
+            ) {
+                Ok(publish) => publish,
+                Err(err) => {
                     results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
                     revoke_pending.push(BatchPutRevokeItemReq {
                         key: item.key.clone(),
@@ -2402,49 +2420,20 @@ impl HandlerForExternalClient for ClientKvApi {
                         .invalidate(&(item.key.clone(), put_id.0, put_id.1));
                     continue;
                 }
-            }
-            let remember_local_snapshot = !item.write_through || !item.remote_target;
-            let publish_local_cache = remember_local_snapshot;
-            let local_cache_publish = if publish_local_cache {
-                match local_committed_cache_publish(
-                    "external_batch_put_commit",
-                    &item.key,
-                    put_id,
-                    pending_ctx.as_ref(),
-                    item.src_offset,
-                    item.len,
-                ) {
-                    Ok(publish) => Some(publish),
-                    Err(err) => {
-                        results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
-                        revoke_pending.push(BatchPutRevokeItemReq {
-                            key: item.key.clone(),
-                            put_id,
-                        });
-                        inner.external_pending_puts.invalidate(&(
-                            item.key.clone(),
-                            put_id.0,
-                            put_id.1,
-                        ));
-                        continue;
-                    }
-                }
-            } else {
-                None
             };
-            let preferred_sub_cluster = pending_ctx
-                .as_ref()
-                .and_then(|ctx| ctx.preferred_sub_cluster.clone());
             done_pending.push(DonePending {
                 idx,
                 key: item.key.clone(),
                 put_id,
                 lease_id: item.lease_id,
-                remember_local_snapshot,
-                publish_local_cache,
                 local_cache_publish,
-                enqueue_write_back_append: !item.write_through && item.remote_target,
-                preferred_sub_cluster,
+                make_replica_task: pending_ctx
+                    .as_ref()
+                    .map(|ctx| ctx.make_replica_task)
+                    .unwrap_or(false),
+                replica_target: pending_ctx
+                    .as_ref()
+                    .and_then(|ctx| ctx.replica_target.clone()),
             });
         }
 
@@ -2493,7 +2482,7 @@ impl HandlerForExternalClient for ClientKvApi {
                         put_id: pending.put_id,
                         lease_id: pending.lease_id,
                         committed_slot: None,
-                        publish_local_cache: pending.publish_local_cache,
+                        publish_local_cache: true,
                     })
                     .collect(),
             )
@@ -2521,42 +2510,34 @@ impl HandlerForExternalClient for ClientKvApi {
                 results[pending.idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
                 continue;
             }
-            if pending.publish_local_cache {
-                let Some(holder_id) = done_item.local_cache_holder_id else {
-                    return Err(KvError::Api(ApiError::Unknown {
-                        detail: format!(
-                            "external_batch_put_commit missing local cache holder after local commit: key={} put_id=({},{})",
-                            pending.key, pending.put_id.0, pending.put_id.1
-                        ),
-                    }));
-                };
-                let publish = pending
-                    .local_cache_publish
-                    .as_ref()
-                    .expect("publish_local_cache precheck must provide local cache publish info");
-                inner
-                    .install_local_committed_memory_info(
-                        &pending.key,
-                        pending.put_id,
-                        publish.src_offset,
-                        publish.len,
-                        holder_id,
-                    )
-                    .await?;
-            } else if pending.remember_local_snapshot {
-                inner.remember_local_snapshot(&pending.key, pending.put_id);
-            }
-            if pending.enqueue_write_back_append {
+            let Some(holder_id) = done_item.local_cache_holder_id else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external_batch_put_commit missing local cache holder after local commit: key={} put_id=({},{})",
+                        pending.key, pending.put_id.0, pending.put_id.1
+                    ),
+                }));
+            };
+            inner
+                .install_local_committed_memory_info(
+                    &pending.key,
+                    pending.put_id,
+                    pending.local_cache_publish.src_offset,
+                    pending.local_cache_publish.len,
+                    holder_id,
+                )
+                .await?;
+            if pending.make_replica_task {
+                let target = pending
+                    .replica_target
+                    .clone()
+                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = inner
-                    .enqueue_write_back_remote_append(
-                        &pending.key,
-                        pending.put_id,
-                        pending.preferred_sub_cluster.as_deref(),
-                    )
+                    .make_replica_task(&pending.key, pending.put_id, target)
                     .await
                 {
                     tracing::warn!(
-                        "external_batch_put_commit write-back enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        "external_batch_put_commit make replica task failed after local commit: key={} put_id=({},{}) err={}",
                         pending.key,
                         pending.put_id.0,
                         pending.put_id.1,
@@ -2602,9 +2583,32 @@ impl HandlerForExternalClient for ClientKvApi {
             );
             return Ok(ExternalPutRevokeResp::from_error(&err));
         };
+        let pending_ctx = inner
+            .external_pending_puts
+            .get(&(req.key.clone(), put_id.0, put_id.1))
+            .map(|ctx| ctx.clone());
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+        if let Some(ctx) = pending_ctx {
+            if let (Some(slot_ref), Some(slot_size)) =
+                (ctx.local_reserve_slot, ctx.local_reserve_slot_size)
+            {
+                inner.release_external_local_first_put_key(&req.key);
+                let lease = client_kv_api::OwnerLocalReserveSlotLease {
+                    value_len: ctx.len,
+                    slot_size,
+                    slots: vec![slot_ref],
+                };
+                return match inner.owner_release_local_reserve_slot_lease(lease).await {
+                    Ok(_) => Ok(ExternalPutRevokeResp {
+                        error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                        error_json: String::new(),
+                    }),
+                    Err(e) => Ok(ExternalPutRevokeResp::from_error(&e)),
+                };
+            }
+        }
         match inner.put_revoke(&req.key, put_id).await {
             Ok(_) => Ok(ExternalPutRevokeResp {
                 error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index 7f723f0..544d5e6 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -31,8 +31,8 @@ use crate::{
     client_seg_pool::{ClientSegPool, ClientSegPoolAccessTrait, ResolveSideTransferLaneReq},
     client_transfer_engine::{ClientTransferEngine, ClientTransferEngineAccessTrait},
     cluster_manager::{
-        app_logic_ext::{ClusterManagerAppLogicExt, ClusterManagerExtError},
         ClusterEvent, ClusterManager, ClusterManagerAccessTrait,
+        app_logic_ext::{ClusterManagerAppLogicExt, ClusterManagerExtError},
     },
     master_kv_router::msg_pack::{
         DeleteAckReq, DeleteReq, GetDoneReq, GetMetaReq, GetRevokeReq, GetStartReq,
@@ -50,19 +50,23 @@ use crate::{
 use async_trait::async_trait;
 use crossbeam::queue::SegQueue;
 use dashmap::DashMap;
-use fluxon_framework::{define_module, LogicalModule};
+use fluxon_framework::{LogicalModule, define_module};
 use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 use fluxon_util::map_lock::AMapLock;
 use limit_thirdparty::tokio;
 use parking_lot::{Mutex, RwLock};
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Weak;
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, OnceLock};
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tracing::warn;
 
+const REPLICA_TASK_QUEUE_CAPACITY: usize = 128;
+const OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY: usize = 4096;
+const OWNER_LOCAL_PUBLISH_MAX_INFLIGHT: usize = 64;
+
 /// Information about a memholder held by external client
 #[derive(Clone)]
 pub struct ExternalHoldingGetInfo {
@@ -79,7 +83,7 @@ pub struct OwnerRuntimeObserveSnapshot {
 }
 
 pub use get::RemoteGetInfo;
-pub use put::OwnerReservedPutItem;
+pub use put::{OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerReservedPutItem};
 pub mod external_api;
 mod local_reserve_rebalance;
 pub use external_api::HandlerForExternalClient;
@@ -181,8 +185,8 @@ pub enum PutOptionalArg {
     RejectIfInflightSameKey,
     /// Ask the master to fail-fast when the key already has a committed live replica.
     RejectIfExistSameKey,
-    /// Keep the legacy synchronous remote-placement semantics.
-    WriteThrough,
+    /// Disable asynchronous remote replica task after local commit in write-back mode.
+    SkipMakeReplicaTask,
     /// Prefer placing the target allocation on a kvclient within this sub_cluster.
     PreferredSubCluster(String),
     /// Hidden test-only side-channel for collecting per-put phase timings.
@@ -203,7 +207,7 @@ impl PutOptionalArgs {
             PutOptionalArg::LeaseId(id) => Some(*id),
             PutOptionalArg::RejectIfInflightSameKey
             | PutOptionalArg::RejectIfExistSameKey
-            | PutOptionalArg::WriteThrough
+            | PutOptionalArg::SkipMakeReplicaTask
             | PutOptionalArg::PreferredSubCluster(_)
             | PutOptionalArg::TestObservePutPhases(_) => None,
         })
@@ -221,10 +225,11 @@ impl PutOptionalArgs {
             .any(|arg| matches!(arg, PutOptionalArg::RejectIfExistSameKey))
     }
 
-    pub fn write_through(&self) -> bool {
-        self.0
+    pub fn make_replica_task(&self) -> bool {
+        !self
+            .0
             .iter()
-            .any(|arg| matches!(arg, PutOptionalArg::WriteThrough))
+            .any(|arg| matches!(arg, PutOptionalArg::SkipMakeReplicaTask))
     }
 
     /// Get the last provided preferred_sub_cluster if any.
@@ -234,7 +239,7 @@ impl PutOptionalArgs {
             PutOptionalArg::LeaseId(_)
             | PutOptionalArg::RejectIfInflightSameKey
             | PutOptionalArg::RejectIfExistSameKey
-            | PutOptionalArg::WriteThrough
+            | PutOptionalArg::SkipMakeReplicaTask
             | PutOptionalArg::TestObservePutPhases(_) => None,
         })
     }
@@ -245,7 +250,7 @@ impl PutOptionalArgs {
             PutOptionalArg::LeaseId(_)
             | PutOptionalArg::RejectIfInflightSameKey
             | PutOptionalArg::RejectIfExistSameKey
-            | PutOptionalArg::WriteThrough
+            | PutOptionalArg::SkipMakeReplicaTask
             | PutOptionalArg::PreferredSubCluster(_) => None,
         })
     }
@@ -1140,6 +1145,14 @@ impl ClientKvApiViewHolder {
     }
 }
 
+fn now_unix_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis()
+        .min(u64::MAX as u128) as u64
+}
+
 impl std::ops::Deref for ClientKvApiViewHolder {
     type Target = ClientKvApiView;
 
@@ -1168,6 +1181,10 @@ pub struct ClientKvApiInner {
     owner_local_reserve_pool: Mutex<OwnerLocalReservePoolState>,
     /// Wake the background reserve actor after demand/free-slot changes.
     owner_local_reserve_rebalance_notify: Arc<limit_thirdparty::tokio::sync::Notify>,
+    /// Owner-local write-back put ids for external local-first path.
+    external_local_first_put_id_counter: AtomicU32,
+    /// Owner-local inflight write guard for external local-first path.
+    external_local_first_inflight_key_counts: DashMap<String, u32>,
 
     /// Shared delete actor input for owner -> external weak-index invalidation.
     pub external_invalidate_delete: EnsureMemholderMgmtDeleteHandle<DeleteClientKvMetaCacheItem>,
@@ -1229,8 +1246,10 @@ pub struct ClientKvApiInner {
     /// 注意：put_id (time_ms,version) 在不同 key 上并不全局唯一，因此必须携带 key 作为索引的一部分，避免碰撞。
     /// 使用 moka::sync::SegmentedCache 并设置 30 分钟 TTL，避免异常路径未清理导致的泄漏；不设置容量上限，纯 TTL 控制。
     external_pending_puts: moka::sync::SegmentedCache<(String, u64, u32), ExternalPendingPutCtx>,
-    write_back_append_tx: tokio::sync::ampsc::Sender<WriteBackAppendJob>,
-    write_back_append_rx: Mutex<Option<tokio::sync::ampsc::Receiver<WriteBackAppendJob>>>,
+    owner_local_publish_tx: tokio::sync::ampsc::Sender<OwnerLocalPublishJob>,
+    owner_local_publish_rx: Mutex<Option<tokio::sync::ampsc::Receiver<OwnerLocalPublishJob>>>,
+    replica_task_tx: tokio::sync::ampsc::Sender<ReplicaTaskJob>,
+    replica_task_rx: Mutex<Option<tokio::sync::ampsc::Receiver<ReplicaTaskJob>>>,
 }
 
 impl ClientKvApiInner {
@@ -1265,6 +1284,73 @@ impl ClientKvApiInner {
         self.test_spec_config.skip_put_end_commit
     }
 
+    pub(crate) fn next_external_local_first_put_id(
+        &self,
+    ) -> crate::master_kv_router::put::PutIDForAKey {
+        (
+            now_unix_ms(),
+            self.external_local_first_put_id_counter
+                .fetch_add(1, Ordering::Relaxed),
+        )
+    }
+
+    pub fn next_owner_local_first_put_id(&self) -> crate::master_kv_router::put::PutIDForAKey {
+        self.next_external_local_first_put_id()
+    }
+
+    pub async fn enqueue_owner_local_publish(&self, job: OwnerLocalPublishJob) -> KvResult<()> {
+        let key_count = job.items.len();
+        let first_key = job
+            .items
+            .first()
+            .map(|item| item.key.as_str())
+            .unwrap_or("<empty>")
+            .to_string();
+        self.owner_local_publish_tx.try_send(job).map_err(|err| {
+            KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "owner local publish queue is full or closed: first_key={} key_count={} err={}",
+                    first_key, key_count, err
+                ),
+            })
+        })
+    }
+
+    pub(crate) fn reserve_external_local_first_put_key(
+        &self,
+        key: &str,
+        reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+    ) -> KvResult<()> {
+        if reject_if_exist_same_key && self.has_local_snapshot(key) {
+            return Err(KvError::Api(ApiError::KeyAlreadyExists {
+                key: key.to_string(),
+            }));
+        }
+        let mut entry = self
+            .external_local_first_inflight_key_counts
+            .entry(key.to_string())
+            .or_insert(0);
+        if reject_if_inflight_same_key && *entry > 0 {
+            return Err(KvError::Api(ApiError::KeyBeingWritten {
+                key: key.to_string(),
+            }));
+        }
+        *entry += 1;
+        Ok(())
+    }
+
+    pub(crate) fn release_external_local_first_put_key(&self, key: &str) {
+        if let Some(mut entry) = self.external_local_first_inflight_key_counts.get_mut(key) {
+            if *entry <= 1 {
+                drop(entry);
+                self.external_local_first_inflight_key_counts.remove(key);
+            } else {
+                *entry -= 1;
+            }
+        }
+    }
+
     pub(crate) fn remember_local_snapshot(
         &self,
         key: &str,
@@ -1461,14 +1547,27 @@ pub struct ExternalPendingPutCtx {
     pub target_base_addr: u64,
     pub target_offset: u64,
     pub len: u64,
+    pub make_replica_task: bool,
     pub preferred_sub_cluster: Option<String>,
+    pub replica_target: Option<ReplicaTaskTarget>,
+    pub local_reserve_slot: Option<OwnerLocalReserveSlotRef>,
+    pub local_reserve_slot_size: Option<u64>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct ReplicaTaskTarget {
+    pub node_id: String,
+    pub target_offset: u64,
+    pub target_base_addr: u64,
+    pub len: u64,
 }
 
 #[derive(Clone)]
-pub(crate) struct WriteBackAppendJob {
+pub(crate) struct ReplicaTaskJob {
     pub key: String,
     pub put_id: crate::master_kv_router::put::PutIDForAKey,
     pub holder: Arc<UserMemHolder>,
+    pub target: Option<ReplicaTaskTarget>,
     pub preferred_sub_cluster: Option<String>,
 }
 
@@ -2473,7 +2572,10 @@ impl ClientKvApi {
 
     pub async fn construct(arg: ClientKvApiNewArg) -> Result<Self, KvError> {
         tracing::info!("Constructing ClientKvApi in Client mode (PreView)");
-        let (write_back_append_tx, write_back_append_rx) = tokio::sync::ampsc::channel(1024);
+        let (replica_task_tx, replica_task_rx) =
+            tokio::sync::ampsc::channel(REPLICA_TASK_QUEUE_CAPACITY);
+        let (owner_local_publish_tx, owner_local_publish_rx) =
+            tokio::sync::ampsc::channel(OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY);
 
         let inner = ClientKvApiInner {
             view: ClientKvApiViewHolder::new(),
@@ -2488,6 +2590,8 @@ impl ClientKvApi {
             owner_local_reserve_rebalance_notify: Arc::new(
                 limit_thirdparty::tokio::sync::Notify::new(),
             ),
+            external_local_first_put_id_counter: AtomicU32::new(0),
+            external_local_first_inflight_key_counts: DashMap::new(),
             external_invalidate_delete: EnsureMemholderMgmtDeleteHandle::new(
                 OwnerExternalMemMgr::DELETE_SUBMIT_QUEUE_CAPACITY,
             ),
@@ -2534,8 +2638,10 @@ impl ClientKvApi {
             rpc_caller_external_put_revoke: RPCCaller::new(),
             rpc_caller_resolve_side_transfer_lane: RPCCaller::new(),
             default_lease_id: parking_lot::RwLock::new(None),
-            write_back_append_tx,
-            write_back_append_rx: Mutex::new(Some(write_back_append_rx)),
+            owner_local_publish_tx,
+            owner_local_publish_rx: Mutex::new(Some(owner_local_publish_rx)),
+            replica_task_tx,
+            replica_task_rx: Mutex::new(Some(replica_task_rx)),
         };
         Ok(Self(inner))
     }
@@ -2925,10 +3031,19 @@ impl ClientKvApi {
             .expect("delete_ack_batch rx already taken, that's impossible");
         delete::spawn_owner_delete_ack_batch(inner.view.clone_view(), delete_ack_batch_rx);
 
-        if let Some(write_back_append_rx) = inner.write_back_append_rx.lock().take() {
-            put::spawn_write_back_append_actor(inner.view.clone_view(), write_back_append_rx);
+        if let Some(replica_task_rx) = inner.replica_task_rx.lock().take() {
+            put::spawn_replica_task_actor(inner.view.clone_view(), replica_task_rx);
+        } else {
+            tracing::warn!("replica_task_rx already taken for ClientKvApi");
+        }
+        if let Some(owner_local_publish_rx) = inner.owner_local_publish_rx.lock().take() {
+            put::spawn_owner_local_publish_dispatcher(
+                inner.view.clone_view(),
+                owner_local_publish_rx,
+                OWNER_LOCAL_PUBLISH_MAX_INFLIGHT,
+            );
         } else {
-            tracing::warn!("write_back_append_rx already taken for ClientKvApi");
+            tracing::warn!("owner_local_publish_rx already taken for ClientKvApi");
         }
 
         // Spawn cluster listener to clean up get_holding when external_client leaves
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
index c53c634..c9c2475 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
@@ -218,7 +218,7 @@ pub struct ExternalBatchPutStartItemReq {
     pub len: u64,
     pub reject_if_inflight_same_key: bool,
     pub reject_if_exist_same_key: bool,
-    pub write_through: bool,
+    pub make_replica_task: bool,
     pub preferred_sub_cluster: Option<String>,
 }
 
@@ -271,7 +271,6 @@ pub struct ExternalBatchPutTransferEndItemReq {
     pub peer_id: Option<String>,
     pub target_base_addr: Option<u64>,
     pub put_id: Option<PutIDForAKey>,
-    pub write_through: bool,
     pub lease_id: Option<u64>,
 }
 
@@ -317,7 +316,6 @@ pub struct ExternalBatchPutCommitItemReq {
     pub remote_target: bool,
     pub put_id: Option<PutIDForAKey>,
     pub lease_id: Option<u64>,
-    pub write_through: bool,
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -480,7 +478,7 @@ pub struct ExternalPutStartReq {
     pub len: u64,
     pub reject_if_inflight_same_key: bool,
     pub reject_if_exist_same_key: bool,
-    pub write_through: bool,
+    pub make_replica_task: bool,
     /// Prefer placing the target allocation on any kvclient within this sub_cluster.
     pub preferred_sub_cluster: Option<String>,
     /// Owner node_start_time observed by external when request starts
@@ -526,7 +524,6 @@ pub struct ExternalPutTransferEndReq {
     pub peer_id: Option<String>,
     pub target_base_addr: Option<u64>,
     pub put_id: Option<PutIDForAKey>,
-    pub write_through: bool,
     /// Optional lease to attach this key to when committing
     pub lease_id: Option<u64>,
     /// Owner node_start_time observed by external when request starts
@@ -563,7 +560,6 @@ pub struct ExternalPutCommitReq {
     pub remote_target: bool,
     pub put_id: Option<PutIDForAKey>,
     pub lease_id: Option<u64>,
-    pub write_through: bool,
     /// Owner node_start_time observed by the caller when request starts
     pub started_time: i64,
     pub test_observe_put_phases: bool,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index 225decf..fd309b3 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -1,17 +1,16 @@
 use super::{
-    local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
     ClientKvApiInner, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
-    OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, WriteBackAppendJob,
+    OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, ReplicaTaskJob, ReplicaTaskTarget,
+    local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
 };
-use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
+use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 use crate::cluster_manager::NodeIDString;
+use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::master_kv_router::put::PutIDForAKey;
-use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 // no StageScope; timestamps-based metrics only
 use crate::memholder::kvclient_encode::{calc_flat_dict_encoded_len, write_flat_dict_ptrs_to_ptr};
 use crate::observe_kvope::{
     obe_put_start_error_rpc, obe_put_start_error_status, obe_put_start_success,
-    obe_put_transfer_error,
 };
 use crate::{
     client_kv_api::ClientKvApiView,
@@ -21,17 +20,18 @@ use crate::{
         BatchPutRevokeReq, BatchPutRevokeResp, BatchPutStartItemReq, BatchPutStartReq,
         BatchPutStartResp, BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
         PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq, PutAppendStartReq,
-        PutAppendStartResp, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
-        ReleaseLocalGrantReq, ReserveLocalGrantReq, ReserveLocalGrantResp,
+        PutAppendStartResp, PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq,
+        PutStartResp, ReleaseLocalGrantReq, ReserveLocalGrantReq, ReserveLocalGrantResp,
     },
+    memholder::{UserMemHolder, UserMemHolderExposeKind},
     p2p::msg_pack::MsgPack,
     p2p::p2p_module::RpcTransportPolicy,
     rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult},
 };
 use chrono::Utc;
 use fluxon_commu::TransferBreakdown;
-use futures::stream::{self, StreamExt};
 use limit_thirdparty::tokio;
+use std::sync::Arc;
 use std::time::Instant;
 use tracing::info;
 
@@ -135,12 +135,28 @@ pub struct OwnerReservedPutItem {
     pub value_len: u64,
     pub lease_id: Option<u64>,
     pub peer_node_id: Option<NodeIDString>,
-    pub write_through: bool,
     pub remember_local_snapshot: bool,
-    pub enqueue_write_back_append: bool,
+    pub make_replica_task: bool,
+    pub replica_target: Option<ReplicaTaskTarget>,
+}
+
+#[derive(Debug, Clone)]
+pub struct OwnerLocalPublishItem {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub value_len: u64,
+    pub lease_id: Option<u64>,
+    pub committed_slot: PutDoneCommittedSlot,
+    pub make_replica_task: bool,
     pub preferred_sub_cluster: Option<String>,
 }
 
+#[derive(Debug, Clone)]
+pub struct OwnerLocalPublishJob {
+    pub items: Vec<OwnerLocalPublishItem>,
+    pub key_reservation_ids: Vec<u64>,
+}
+
 #[derive(Debug, Clone, Copy, Default)]
 pub struct PutEndStats {
     pub master_put_end_rpc_us: i64,
@@ -517,6 +533,16 @@ impl ClientKvApiInner {
             } else {
                 Some(start_item.node_id.clone())
             };
+            let replica_target =
+                start_item
+                    .replica_target
+                    .as_ref()
+                    .map(|target| ReplicaTaskTarget {
+                        node_id: target.node_id.clone(),
+                        target_offset: target.target_addr - target.target_base_addr,
+                        target_base_addr: target.target_base_addr,
+                        len: target.len,
+                    });
             revoke_items.push(BatchPutRevokeItemReq {
                 key: start_req.key.clone(),
                 put_id: start_item.put_id,
@@ -531,10 +557,9 @@ impl ClientKvApiInner {
                 value_len: start_req.len,
                 lease_id,
                 peer_node_id: peer_node_id.clone(),
-                write_through: start_req.write_through,
-                remember_local_snapshot: !start_req.write_through || peer_node_id.is_none(),
-                enqueue_write_back_append: !start_req.write_through && peer_node_id.is_some(),
-                preferred_sub_cluster: start_req.preferred_sub_cluster,
+                remember_local_snapshot: true,
+                make_replica_task: start_req.make_replica_task && replica_target.is_some(),
+                replica_target,
             });
         }
 
@@ -556,7 +581,7 @@ impl ClientKvApiInner {
     pub async fn owner_batch_put_commit_reserved(
         &self,
         items: Vec<OwnerReservedPutItem>,
-        transfer_concurrency: usize,
+        _transfer_concurrency: usize,
     ) -> KvResult<Vec<KvResult<()>>> {
         if items.is_empty() {
             return Ok(Vec::new());
@@ -568,87 +593,13 @@ impl ClientKvApiInner {
             item: OwnerReservedPutItem,
         }
 
-        let transfer_concurrency = transfer_concurrency.max(1);
         let metrics = self.metrics_handle();
         let mut results: Vec<Option<KvResult<()>>> = (0..items.len()).map(|_| None).collect();
         let mut done_pending = Vec::with_capacity(items.len());
-        let mut revoke_pending = Vec::new();
-        let mut transfer_futures = Vec::new();
 
         for (idx, item) in items.into_iter().enumerate() {
-            if !item.write_through {
-                metrics.record_put_io_locality(false, item.value_len, 0);
-                done_pending.push(DonePending { idx, item });
-                continue;
-            }
-            if item.peer_node_id.is_none() && item.src_addr == item.target_addr {
-                metrics.record_put_io_locality(false, item.value_len, 0);
-                done_pending.push(DonePending { idx, item });
-                continue;
-            }
-
-            let src_offset = item.src_addr - item.src_base_addr;
-            let target_offset = if item.peer_node_id.is_some() {
-                item.target_addr - item.target_base_addr
-            } else {
-                item.target_addr - item.src_base_addr
-            };
-            transfer_futures.push(async move {
-                let transfer_started_at = Instant::now();
-                let transfer_result = self
-                    .put_transfer(
-                        &item.key,
-                        item.put_id,
-                        src_offset,
-                        target_offset,
-                        item.value_len,
-                        item.peer_node_id.clone(),
-                        item.peer_node_id.as_ref().map(|_| item.target_base_addr),
-                    )
-                    .await;
-                (
-                    idx,
-                    item,
-                    duration_to_i64_us(transfer_started_at.elapsed()),
-                    transfer_result,
-                )
-            });
-        }
-
-        let mut transfer_stream =
-            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
-        while let Some(joined) = transfer_stream.next().await {
-            match joined {
-                (idx, item, wall_transfer_us, Ok(breakdown)) => {
-                    let breakdown_transfer_us = breakdown.submit_blocking_us
-                        + breakdown.create_xfer_req_us
-                        + breakdown.post_xfer_req_us
-                        + breakdown.poll_wait_us;
-                    let transfer_us = breakdown_transfer_us.max(wall_transfer_us);
-                    metrics.record_put_io_locality(
-                        breakdown.remote_transfer,
-                        item.value_len,
-                        transfer_us,
-                    );
-                    done_pending.push(DonePending { idx, item });
-                }
-                (idx, item, _wall_transfer_us, Err(err)) => {
-                    results[idx] = Some(Err(err));
-                    revoke_pending.push(BatchPutRevokeItemReq {
-                        key: item.key,
-                        put_id: item.put_id,
-                    });
-                }
-            }
-        }
-
-        if !revoke_pending.is_empty() {
-            if let Err(err) = self.batch_put_revoke(revoke_pending).await {
-                tracing::warn!(
-                    "owner_batch_put_commit_reserved batch_put_revoke failed after transfer errors: {}",
-                    err
-                );
-            }
+            metrics.record_put_io_locality(false, item.value_len, 0);
+            done_pending.push(DonePending { idx, item });
         }
 
         if self.skip_put_end_commit_enabled() {
@@ -700,17 +651,18 @@ impl ClientKvApiInner {
             if pending.item.remember_local_snapshot {
                 self.remember_local_snapshot(&pending.item.key, pending.item.put_id);
             }
-            if pending.item.enqueue_write_back_append {
+            if pending.item.make_replica_task {
+                let target = pending
+                    .item
+                    .replica_target
+                    .clone()
+                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = self
-                    .enqueue_write_back_remote_append(
-                        &pending.item.key,
-                        pending.item.put_id,
-                        pending.item.preferred_sub_cluster.as_deref(),
-                    )
+                    .make_replica_task(&pending.item.key, pending.item.put_id, target)
                     .await
                 {
                     tracing::warn!(
-                        "owner_batch_put_commit_reserved write-back remote append enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        "owner_batch_put_commit_reserved make replica task failed after local commit: key={} put_id=({},{}) err={}",
                         pending.item.key,
                         pending.item.put_id.0,
                         pending.item.put_id.1,
@@ -757,7 +709,7 @@ impl ClientKvApiInner {
         keys: Vec<String>,
         ptrs_groups: Vec<Vec<(u8, usize, u32, u64, u32, Option<u32>)>>,
         opts: crate::client_kv_api::PutOptionalArgs,
-        transfer_concurrency: usize,
+        _transfer_concurrency: usize,
     ) -> KvResult<Vec<KvResult<()>>> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
@@ -777,11 +729,10 @@ impl ClientKvApiInner {
         if keys.is_empty() {
             return Ok(Vec::new());
         }
-        let transfer_concurrency = transfer_concurrency.max(1);
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
         let reject_if_exist_same_key = opts.reject_if_exist_same_key();
-        let write_through = opts.write_through();
+        let make_replica_task = opts.make_replica_task();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
 
         let mut start_items = Vec::with_capacity(keys.len());
@@ -794,7 +745,7 @@ impl ClientKvApiInner {
                 len: payload_len,
                 reject_if_inflight_same_key,
                 reject_if_exist_same_key,
-                write_through,
+                make_replica_task,
                 preferred_sub_cluster: preferred_sub_cluster.clone(),
             });
         }
@@ -817,14 +768,12 @@ impl ClientKvApiInner {
             put_id: PutIDForAKey,
             lease_id: Option<u64>,
             remember_local_snapshot: bool,
-            enqueue_write_back_append: bool,
+            make_replica_task: bool,
+            replica_target: Option<ReplicaTaskTarget>,
         }
 
-        let self_node_id = self.view.cluster_manager().get_self_info().id.clone();
         let mut results: Vec<Option<KvResult<()>>> = (0..keys.len()).map(|_| None).collect();
         let mut done_pending = Vec::new();
-        let mut revoke_pending = Vec::new();
-        let mut transfer_futures = Vec::new();
         let short_circuit_payload = self.short_circuit_put_payload_path_enabled();
         let skip_put_end_commit = self.skip_put_end_commit_enabled();
 
@@ -844,12 +793,17 @@ impl ClientKvApiInner {
             }
 
             let put_id = start_item.put_id;
-            let peer_id = if start_item.node_id == self_node_id {
-                None
-            } else {
-                Some(start_item.node_id.clone())
-            };
-            let remember_local_snapshot = !write_through || peer_id.is_none();
+            let remember_local_snapshot = true;
+            let replica_target =
+                start_item
+                    .replica_target
+                    .as_ref()
+                    .map(|target| ReplicaTaskTarget {
+                        node_id: target.node_id.clone(),
+                        target_offset: target.target_addr - target.target_base_addr,
+                        target_base_addr: target.target_base_addr,
+                        len: target.len,
+                    });
 
             if !short_circuit_payload {
                 unsafe {
@@ -857,78 +811,17 @@ impl ClientKvApiInner {
                 }
             }
 
-            if !write_through {
-                done_pending.push(DonePending {
-                    idx,
-                    key,
-                    put_id,
-                    lease_id,
-                    remember_local_snapshot,
-                    enqueue_write_back_append: !short_circuit_payload && peer_id.is_some(),
-                });
-                continue;
-            }
-
-            if short_circuit_payload
-                || (peer_id.is_none() && start_item.src_addr == start_item.target_addr)
-            {
-                done_pending.push(DonePending {
-                    idx,
-                    key,
-                    put_id,
-                    lease_id,
-                    remember_local_snapshot,
-                    enqueue_write_back_append: false,
-                });
-                continue;
-            }
-
-            let target_base_addr_opt = peer_id.as_ref().map(|_| start_item.target_base_addr);
-            let src_offset = start_item.src_addr - start_item.src_base_addr;
-            let target_offset = start_item.target_addr - start_item.target_base_addr;
-            transfer_futures.push(async move {
-                let transfer_result = self
-                    .put_transfer(
-                        &key,
-                        put_id,
-                        src_offset,
-                        target_offset,
-                        payload_len,
-                        peer_id,
-                        target_base_addr_opt,
-                    )
-                    .await;
-                (idx, key, put_id, remember_local_snapshot, transfer_result)
+            done_pending.push(DonePending {
+                idx,
+                key,
+                put_id,
+                lease_id,
+                remember_local_snapshot,
+                make_replica_task: make_replica_task && replica_target.is_some(),
+                replica_target,
             });
         }
 
-        let mut transfer_stream =
-            stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
-        while let Some(joined) = transfer_stream.next().await {
-            match joined {
-                (idx, key, put_id, remember_local_snapshot, Ok(_breakdown)) => {
-                    done_pending.push(DonePending {
-                        idx,
-                        key,
-                        put_id,
-                        lease_id,
-                        remember_local_snapshot,
-                        enqueue_write_back_append: false,
-                    });
-                }
-                (idx, key, put_id, _remember_local_snapshot, Err(err)) => {
-                    results[idx] = Some(Err(err));
-                    revoke_pending.push(BatchPutRevokeItemReq { key, put_id });
-                }
-            }
-        }
-
-        if !revoke_pending.is_empty() {
-            if let Err(err) = self.batch_put_revoke(revoke_pending).await {
-                tracing::warn!("batch_put_revoke failed after transfer errors: {}", err);
-            }
-        }
-
         if skip_put_end_commit {
             for pending in done_pending {
                 results[pending.idx] = Some(Ok(()));
@@ -976,17 +869,17 @@ impl ClientKvApiInner {
             if pending.remember_local_snapshot {
                 self.remember_local_snapshot(&pending.key, pending.put_id);
             }
-            if pending.enqueue_write_back_append {
+            if pending.make_replica_task {
+                let target = pending
+                    .replica_target
+                    .clone()
+                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = self
-                    .enqueue_write_back_remote_append(
-                        &pending.key,
-                        pending.put_id,
-                        preferred_sub_cluster.as_deref(),
-                    )
+                    .make_replica_task(&pending.key, pending.put_id, target)
                     .await
                 {
                     tracing::warn!(
-                        "batch write-back remote append enqueue failed after local commit: key={} put_id=({},{}) err={}",
+                        "batch make replica task failed after local commit: key={} put_id=({},{}) err={}",
                         pending.key,
                         pending.put_id.0,
                         pending.put_id.1,
@@ -1009,36 +902,90 @@ impl ClientKvApiInner {
             .collect())
     }
 
-    pub async fn enqueue_write_back_remote_append(
+    pub async fn make_replica_task(
         &self,
         key: &str,
         put_id: PutIDForAKey,
-        preferred_sub_cluster: Option<&str>,
+        target: ReplicaTaskTarget,
     ) -> KvResult<()> {
-        let Some((holder, _)) = self.get(key).await? else {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "write-back local commit did not produce a readable current replica: key={} put_id=({},{})",
-                    key, put_id.0, put_id.1
-                ),
-            }));
+        let Some(memory_info) = self.local_visible_mem_holder(key) else {
+            tracing::warn!(
+                "replica task source holder is unavailable after local commit; dropping replica task: key={} put_id=({},{})",
+                key,
+                put_id.0,
+                put_id.1
+            );
+            return Ok(());
         };
-        self.write_back_append_tx
-            .send(WriteBackAppendJob {
-                key: key.to_string(),
-                put_id,
-                holder,
-                preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
-            })
-            .await
-            .map_err(|err| {
-                KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "write-back append actor queue send failed: key={} put_id=({},{}) err={}",
-                        key, put_id.0, put_id.1, err
-                    ),
-                })
-            })
+
+        let holder = Arc::new(UserMemHolder::new(
+            memory_info,
+            self.get_or_init_all_memholder_refcount(),
+            UserMemHolderExposeKind::SegPtr,
+        ));
+
+        match self.replica_task_tx.try_send(ReplicaTaskJob {
+            key: key.to_string(),
+            put_id,
+            holder,
+            target: Some(target),
+            preferred_sub_cluster: None,
+        }) {
+            Ok(()) => Ok(()),
+            Err(err) => {
+                tracing::warn!(
+                    "replica task actor enqueue failed; dropping replica task: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+                Ok(())
+            }
+        }
+    }
+
+    pub async fn make_replica_append_task(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        preferred_sub_cluster: Option<String>,
+    ) -> KvResult<()> {
+        let Some(memory_info) = self.local_visible_mem_holder(key) else {
+            tracing::warn!(
+                "replica append task source holder is unavailable after local publish; dropping replica task: key={} put_id=({},{})",
+                key,
+                put_id.0,
+                put_id.1
+            );
+            return Ok(());
+        };
+
+        let holder = Arc::new(UserMemHolder::new(
+            memory_info,
+            self.get_or_init_all_memholder_refcount(),
+            UserMemHolderExposeKind::SegPtr,
+        ));
+
+        match self.replica_task_tx.try_send(ReplicaTaskJob {
+            key: key.to_string(),
+            put_id,
+            holder,
+            target: None,
+            preferred_sub_cluster,
+        }) {
+            Ok(()) => Ok(()),
+            Err(err) => {
+                tracing::warn!(
+                    "replica append task actor enqueue failed; dropping replica task: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+                Ok(())
+            }
+        }
     }
 
     async fn put_common<F>(
@@ -1048,7 +995,7 @@ impl ClientKvApiInner {
         len_for_start: u32,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
+        make_replica_task: bool,
         preferred_sub_cluster: Option<&str>,
         lease_id: Option<u64>,
         _test_payload_len_u32: u32,
@@ -1072,7 +1019,7 @@ impl ClientKvApiInner {
                     len_for_start,
                     reject_if_inflight_same_key,
                     reject_if_exist_same_key,
-                    write_through,
+                    make_replica_task,
                     preferred_sub_cluster,
                 )
                 .await
@@ -1101,6 +1048,15 @@ impl ClientKvApiInner {
         };
         let abs_src = resp.src_addr;
         let abs_target = resp.target_addr;
+        let replica_target = resp
+            .replica_target
+            .as_ref()
+            .map(|target| ReplicaTaskTarget {
+                node_id: target.node_id.clone(),
+                target_offset: target.target_addr - target.target_base_addr,
+                target_base_addr: target.target_base_addr,
+                len: target.len,
+            });
 
         #[cfg(test)]
         {
@@ -1144,8 +1100,26 @@ impl ClientKvApiInner {
                 skipped_breakdown.remote_transfer,
             );
             self.put_end(key, put_id, lease_id).await?;
-            if !write_through || peer_id.is_none() {
-                self.remember_local_snapshot(key, put_id);
+            self.remember_local_snapshot(key, put_id);
+            if make_replica_task && replica_target.is_some() {
+                if let Err(err) = self
+                    .make_replica_task(
+                        key,
+                        put_id,
+                        replica_target
+                            .clone()
+                            .expect("make_replica_task requires pre-reserved replica target"),
+                    )
+                    .await
+                {
+                    tracing::warn!(
+                        "make replica task failed after short-circuit local commit: key={} put_id=({},{}) err={}",
+                        key,
+                        put_id.0,
+                        put_id.1,
+                        err
+                    );
+                }
             }
             if let Some(tag) = info_complete_tag {
                 info!("{tag} complete key={} bytes={}", key, payload_len);
@@ -1170,87 +1144,20 @@ impl ClientKvApiInner {
             .await
             .unwrap()
             .allocated_addr;
-        if !write_through {
-            self.put_end(key, put_id, lease_id).await?;
-            self.remember_local_snapshot(key, put_id);
-            if peer_id.is_some() {
-                if let Err(err) = self
-                    .enqueue_write_back_remote_append(key, put_id, preferred_sub_cluster)
-                    .await
-                {
-                    tracing::warn!(
-                        "write-back remote append enqueue failed after local commit: key={} put_id=({},{}) err={}",
-                        key,
-                        put_id.0,
-                        put_id.1,
-                        err
-                    );
-                }
-            }
-            if let Some(tag) = info_complete_tag {
-                info!(
-                    "{tag} local_commit_complete key={} bytes={}",
-                    key, payload_len
-                );
-            }
-            return Ok(());
-        }
-        let src_offset = abs_src - base_addr;
-        let (target_offset, target_base_addr_opt) = match &peer_id {
-            Some(_) => (
-                abs_target - resp.target_base_addr,
-                Some(resp.target_base_addr),
-            ),
-            None => (abs_target - base_addr, None),
-        };
         if dbg_addr_summary {
             tracing::debug!(
-                "put path addr summary: key={}, put_id=({},{}) local_base={:#x}, abs_src={:#x}, src_off={:#x}, master_target_base={:#x}, abs_target={:#x}, tgt_off={:#x}, peer_id={:?}",
+                "put path addr summary: key={}, put_id=({},{}) local_base={:#x}, abs_src={:#x}, master_target_base={:#x}, abs_target={:#x}, peer_id={:?}",
                 key,
                 put_id.0,
                 put_id.1,
                 base_addr,
                 abs_src,
-                src_offset,
-                target_base_addr_opt.unwrap_or(base_addr),
+                resp.target_base_addr,
                 abs_target,
-                target_offset,
                 peer_id
             );
         }
 
-        let transfer_breakdown = match self
-            .put_transfer(
-                key,
-                put_id,
-                src_offset,
-                target_offset,
-                payload_len,
-                peer_id.clone(),
-                target_base_addr_opt,
-            )
-            .await
-        {
-            Ok(breakdown) => breakdown,
-            Err(e) => {
-                self.put_revoke(key, put_id).await?;
-                obe_put_transfer_error(&metrics, &client_id, &node_role, key, payload_len);
-                return Err(e);
-            }
-        };
-        metrics.pending_put_set_transfer_breakdown(
-            put_id,
-            transfer_breakdown.submit_blocking_us,
-            transfer_breakdown.create_xfer_req_us,
-            transfer_breakdown.post_xfer_req_us,
-            transfer_breakdown.poll_wait_us,
-            transfer_breakdown.poll_iters,
-            transfer_breakdown.used_fast_path,
-            false,
-            transfer_breakdown.local_noop,
-            transfer_breakdown.remote_transfer,
-        );
-
         if self.skip_put_end_commit_enabled() {
             let _ = metrics.pending_put_remove(&put_id);
             tracing::warn!(
@@ -1270,8 +1177,26 @@ impl ClientKvApiInner {
         }
 
         self.put_end(key, put_id, lease_id).await?;
-        if peer_id.is_none() {
-            self.remember_local_snapshot(key, put_id);
+        self.remember_local_snapshot(key, put_id);
+        if make_replica_task && replica_target.is_some() {
+            if let Err(err) = self
+                .make_replica_task(
+                    key,
+                    put_id,
+                    replica_target
+                        .clone()
+                        .expect("make_replica_task requires pre-reserved replica target"),
+                )
+                .await
+            {
+                tracing::warn!(
+                    "make replica task failed after local commit: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
         }
         if let Some(tag) = info_complete_tag {
             info!("{tag} complete key={} bytes={}", key, payload_len);
@@ -1292,7 +1217,7 @@ impl ClientKvApiInner {
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
         let reject_if_exist_same_key = opts.reject_if_exist_same_key();
-        let write_through = opts.write_through();
+        let make_replica_task = opts.make_replica_task();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
 
         let payload_len = calc_flat_dict_encoded_len(&ptrs)?;
@@ -1302,7 +1227,7 @@ impl ClientKvApiInner {
             payload_len as u32,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
+            make_replica_task,
             preferred_sub_cluster.as_deref(),
             lease_id,
             payload_len as u32,
@@ -1329,7 +1254,7 @@ impl ClientKvApiInner {
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
         let reject_if_exist_same_key = opts.reject_if_exist_same_key();
-        let write_through = opts.write_through();
+        let make_replica_task = opts.make_replica_task();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let payload_len = value.len() as u64;
         self.put_common(
@@ -1338,7 +1263,7 @@ impl ClientKvApiInner {
             value.len() as u32,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
+            make_replica_task,
             preferred_sub_cluster.as_deref(),
             lease_id,
             value.len() as u32,
@@ -1459,7 +1384,7 @@ impl ClientKvApiInner {
         len: u32,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
+        make_replica_task: bool,
         preferred_sub_cluster: Option<&str>,
         source_node_id: Option<NodeIDString>,
     ) -> KvResult<(PutStartResp, i64)> {
@@ -1469,7 +1394,7 @@ impl ClientKvApiInner {
                 len: len as u64,
                 reject_if_inflight_same_key,
                 reject_if_exist_same_key,
-                write_through,
+                make_replica_task,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                 source_node_id,
             },
@@ -1520,7 +1445,7 @@ impl ClientKvApiInner {
         len: u32,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
+        make_replica_task: bool,
         preferred_sub_cluster: Option<&str>,
     ) -> KvResult<(PutStartResp, i64)> {
         self.put_start_with_source_node(
@@ -1528,7 +1453,7 @@ impl ClientKvApiInner {
             len,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
+            make_replica_task,
             preferred_sub_cluster,
             None,
         )
@@ -2143,17 +2068,17 @@ impl ClientKvApiInner {
     }
 }
 
-pub fn spawn_write_back_append_actor(
+pub fn spawn_replica_task_actor(
     view: ClientKvApiView,
-    mut rx: tokio::sync::ampsc::Receiver<WriteBackAppendJob>,
+    mut rx: tokio::sync::ampsc::Receiver<ReplicaTaskJob>,
 ) {
     let view_task = view.clone();
-    let _ = view.spawn("write_back_append_actor", async move {
+    let _ = view.spawn("replica_task_actor", async move {
         let mut shutdown_waiter = view_task.register_shutdown_waiter();
         loop {
             let job = tokio::select! {
                 _ = shutdown_waiter.wait() => {
-                    tracing::info!("write_back_append_actor stopping due to shutdown signal");
+                    tracing::info!("replica_task_actor stopping due to shutdown signal");
                     break;
                 }
                 job = rx.recv() => {
@@ -2166,71 +2091,102 @@ pub fn spawn_write_back_append_actor(
             let inner = view_task.client_kv_api().inner();
             let src_offset = job.holder.memory_info().offset;
             let len = job.holder.get_length() as u64;
-            let append_start = match inner
-                .put_append_start(
-                    &job.key,
-                    job.put_id,
-                    job.holder.get_length(),
-                    job.preferred_sub_cluster.as_deref(),
-                )
-                .await
-            {
-                Ok(resp) => resp,
-                Err(err) => {
-                    tracing::warn!(
-                        "write-back append start failed: key={} put_id=({},{}) err={}",
+            let target = if let Some(target) = job.target.clone() {
+                target
+            } else {
+                let len_u32 = match u32::try_from(len) {
+                    Ok(len_u32) => len_u32,
+                    Err(_) => {
+                        tracing::warn!(
+                            "replica append task length does not fit u32: key={} put_id=({},{}) len={}",
+                            job.key,
+                            job.put_id.0,
+                            job.put_id.1,
+                            len
+                        );
+                        continue;
+                    }
+                };
+                let append_start = match inner
+                    .put_append_start(
+                        &job.key,
+                        job.put_id,
+                        len_u32,
+                        job.preferred_sub_cluster.as_deref(),
+                    )
+                    .await
+                {
+                    Ok(resp) => resp,
+                    Err(err) => {
+                        tracing::warn!(
+                            "replica append task start failed: key={} put_id=({},{}) err={}",
+                            job.key,
+                            job.put_id.0,
+                            job.put_id.1,
+                            err
+                        );
+                        continue;
+                    }
+                };
+                if !append_start.scheduled {
+                    tracing::debug!(
+                        "replica append task not scheduled: key={} put_id=({},{})",
                         job.key,
                         job.put_id.0,
-                        job.put_id.1,
-                        err
+                        job.put_id.1
                     );
                     continue;
                 }
+                ReplicaTaskTarget {
+                    node_id: append_start.node_id,
+                    target_offset: append_start.target_addr - append_start.target_base_addr,
+                    target_base_addr: append_start.target_base_addr,
+                    len: append_start.len,
+                }
             };
-            if !append_start.scheduled {
-                tracing::debug!(
-                    "write-back append skipped because current version no longer needs remote replica: key={} put_id=({},{})",
+            if len != target.len {
+                tracing::warn!(
+                    "replica task length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
                     job.key,
                     job.put_id.0,
-                    job.put_id.1
+                    job.put_id.1,
+                    len,
+                    target.len
+                );
+                spawn_replica_task_revoke(
+                    view_task.clone(),
+                    job.key,
+                    job.put_id,
+                    "length mismatch",
                 );
                 continue;
             }
-            let target_offset = append_start.target_addr - append_start.target_base_addr;
             if let Err(err) = inner
                 .put_transfer(
                     &job.key,
                     job.put_id,
                     src_offset,
-                    target_offset,
+                    target.target_offset,
                     len,
-                    Some(append_start.node_id.clone()),
-                    Some(append_start.target_base_addr),
+                    Some(target.node_id.clone()),
+                    Some(target.target_base_addr),
                 )
                 .await
             {
                 tracing::warn!(
-                    "write-back append transfer failed: key={} put_id=({},{}) err={}",
+                    "replica task transfer failed: key={} put_id=({},{}) err={}",
                     job.key,
                     job.put_id.0,
                     job.put_id.1,
                     err
                 );
-                if let Err(revoke_err) = inner.put_append_revoke(&job.key, job.put_id).await {
-                    tracing::warn!(
-                        "write-back append revoke failed after transfer error: key={} put_id=({},{}) err={}",
-                        job.key,
-                        job.put_id.0,
-                        job.put_id.1,
-                        revoke_err
-                    );
-                }
+                spawn_replica_task_revoke(view_task.clone(), job.key, job.put_id, "transfer error");
                 continue;
             }
             match inner.put_append_done(&job.key, job.put_id).await {
                 Ok(resp) => {
                     tracing::debug!(
-                        "write-back append done: key={} put_id=({},{}) appended={}",
+                        "replica task append done: key={} put_id=({},{}) appended={}",
                         job.key,
                         job.put_id.0,
                         job.put_id.1,
@@ -2239,7 +2195,7 @@ pub fn spawn_write_back_append_actor(
                 }
                 Err(err) => {
                     tracing::warn!(
-                        "write-back append done failed: key={} put_id=({},{}) err={}",
+                        "replica task append done failed: key={} put_id=({},{}) err={}",
                         job.key,
                         job.put_id.0,
                         job.put_id.1,
@@ -2250,3 +2206,157 @@ pub fn spawn_write_back_append_actor(
         }
     });
 }
+
+pub fn spawn_owner_local_publish_dispatcher(
+    view: ClientKvApiView,
+    mut rx: tokio::sync::ampsc::Receiver<OwnerLocalPublishJob>,
+    max_inflight: usize,
+) {
+    let view_task = view.clone();
+    let _ = view.spawn("owner_local_publish_dispatcher", async move {
+        let max_inflight = max_inflight.max(1);
+        let semaphore = Arc::new(::tokio::sync::Semaphore::new(max_inflight));
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        loop {
+            let job = tokio::select! {
+                _ = shutdown_waiter.wait() => {
+                    tracing::info!("owner_local_publish_dispatcher stopping due to shutdown signal");
+                    break;
+                }
+                job = rx.recv() => {
+                    match job {
+                        Some(job) => job,
+                        None => break,
+                    }
+                }
+            };
+            let permit = match semaphore.clone().acquire_owned().await {
+                Ok(permit) => permit,
+                Err(err) => {
+                    tracing::warn!(
+                        "owner_local_publish_dispatcher semaphore closed; dropping job key_count={} err={}",
+                        job.items.len(),
+                        err
+                    );
+                    break;
+                }
+            };
+            let spawn_view = view_task.clone();
+            let worker_view = view_task.clone();
+            spawn_view.spawn("owner_local_publish_worker", async move {
+                let _permit = permit;
+                publish_owner_local_job(worker_view, job).await;
+            });
+        }
+    });
+}
+
+async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJob) {
+    let inner = view.client_kv_api().inner();
+    if job.items.is_empty() {
+        release_owner_local_publish_reservations(inner, job.key_reservation_ids).await;
+        return;
+    }
+
+    let done_req_items = job
+        .items
+        .iter()
+        .map(|item| BatchPutDoneItemReq {
+            key: item.key.clone(),
+            put_id: item.put_id,
+            lease_id: item.lease_id,
+            committed_slot: Some(item.committed_slot.clone()),
+            publish_local_cache: false,
+        })
+        .collect::<Vec<_>>();
+
+    match inner.batch_put_done(done_req_items).await {
+        Ok(done_resp) if done_resp.items.len() == job.items.len() => {
+            for (item, done_item) in job.items.iter().zip(done_resp.items.into_iter()) {
+                if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                    done_item.error_code,
+                    done_item.error_json.clone(),
+                ) {
+                    tracing::warn!(
+                        "owner local publish failed: key={} put_id=({},{}) err={}",
+                        item.key,
+                        item.put_id.0,
+                        item.put_id.1,
+                        err
+                    );
+                    continue;
+                }
+                if item.make_replica_task {
+                    if let Err(err) = inner
+                        .make_replica_append_task(
+                            &item.key,
+                            item.put_id,
+                            item.preferred_sub_cluster.clone(),
+                        )
+                        .await
+                    {
+                        tracing::warn!(
+                            "owner local publish enqueue replica append failed: key={} put_id=({},{}) err={}",
+                            item.key,
+                            item.put_id.0,
+                            item.put_id.1,
+                            err
+                        );
+                    }
+                }
+            }
+        }
+        Ok(done_resp) => {
+            tracing::warn!(
+                "owner local publish response length mismatch: expected={} got={}",
+                job.items.len(),
+                done_resp.items.len()
+            );
+        }
+        Err(err) => {
+            tracing::warn!(
+                "owner local publish batch_put_done rpc failed: key_count={} err={}",
+                job.items.len(),
+                err
+            );
+        }
+    }
+
+    release_owner_local_publish_reservations(inner, job.key_reservation_ids).await;
+}
+
+async fn release_owner_local_publish_reservations(
+    inner: &ClientKvApiInner,
+    key_reservation_ids: Vec<u64>,
+) {
+    if let Err(err) = inner
+        .batch_release_put_key_reservations(key_reservation_ids)
+        .await
+    {
+        tracing::warn!(
+            "owner local publish key reservation cleanup failed: {}",
+            err
+        );
+    }
+}
+
+fn spawn_replica_task_revoke(
+    view: ClientKvApiView,
+    key: String,
+    put_id: PutIDForAKey,
+    reason: &'static str,
+) {
+    let _ = view.clone().spawn("replica_task_revoke", async move {
+        let inner = view.client_kv_api().inner();
+        if let Err(revoke_err) = inner.put_append_revoke(&key, put_id).await {
+            tracing::warn!(
+                "replica task append revoke failed after {}: key={} put_id=({},{}) err={}",
+                reason,
+                key,
+                put_id.0,
+                put_id.1,
+                revoke_err
+            );
+        }
+    });
+}
diff --git a/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs b/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
index 429f6b8..8c7cc78 100644
--- a/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
@@ -1,3 +1,4 @@
+use crate::ClientKvApiAccessTrait;
 use crate::client_kv_api::ClientKvApi;
 use crate::client_transfer_engine::{ClientTransferEngine, ClientTransferEngineAccessTrait};
 use crate::cluster_manager::ClusterManagerAccessTrait;
@@ -5,9 +6,8 @@ use crate::config::ContributeToClusterPoolSize;
 use crate::master_seg_manager::msg_pack::SegmentDeviceMemInfo;
 use crate::p2p::p2p_module::P2pModule;
 use crate::p2p::p2p_module::P2pModuleAccessTrait;
-use crate::rpcresp_kvresult_convert::msg_and_error::OK;
 use crate::rpcresp_kvresult_convert::FromError;
-use crate::ClientKvApiAccessTrait;
+use crate::rpcresp_kvresult_convert::msg_and_error::OK;
 use crate::{
     cluster_manager::{ClusterManager, ClusterMember},
     master_seg_manager::msg_pack::{
@@ -19,7 +19,7 @@ use crate::{
 use async_trait::async_trait;
 use bitcode::{Decode, Encode};
 use fluxon_commu::{CpuAllocatedMem, ShareGroupOwnerRef};
-use fluxon_framework::{define_module, LogicalModule};
+use fluxon_framework::{LogicalModule, define_module};
 use fluxon_util::new_map;
 use limit_thirdparty::tokio;
 use limit_thirdparty::tokio::sync::ARwLockReadGuardOwned;
diff --git a/fluxon_rs/fluxon_kv/src/config.rs b/fluxon_rs/fluxon_kv/src/config.rs
index 4c7615f..bf676ee 100644
--- a/fluxon_rs/fluxon_kv/src/config.rs
+++ b/fluxon_rs/fluxon_kv/src/config.rs
@@ -483,6 +483,193 @@ pub const DEFAULT_OTLP_LOG_FLUSH_INTERVAL_MS: u64 = 2000;
 pub const DEFAULT_OTLP_LOG_MAX_BATCH_LINES: usize = 2000;
 pub const DEFAULT_OTLP_LOG_MAX_QUEUE_LINES: usize = 20000;
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ReplicaTaskPlacementPolicyKind {
+    LocalFirst,
+    Random,
+    QueueAware,
+    WeightedRoleAware,
+    BoundedRoleQueueAware,
+    PressureRoleQueueAware,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct ReplicaTaskPlacementConfigYaml {
+    #[serde(default = "default_replica_task_placement_policy")]
+    pub policy: ReplicaTaskPlacementPolicyKind,
+    #[serde(default = "default_replica_task_active_node_roles")]
+    pub active_node_roles: Vec<String>,
+    #[serde(default = "default_replica_task_remote_only_node_roles")]
+    pub remote_only_node_roles: Vec<String>,
+    #[serde(default = "default_replica_task_restrict_to_remote_only_node_roles")]
+    pub restrict_to_remote_only_node_roles: bool,
+    #[serde(default = "default_replica_task_remote_only_shard_weight")]
+    pub remote_only_shard_weight: f64,
+    #[serde(default = "default_replica_task_role_queue_window_ms")]
+    pub role_queue_window_ms: f64,
+    #[serde(default = "default_replica_task_role_pressure_gap_ms")]
+    pub role_pressure_gap_ms: f64,
+    #[serde(default = "default_replica_task_role_fabric_guard_ms")]
+    pub role_fabric_guard_ms: f64,
+    #[serde(default = "default_replica_task_role_max_shard_imbalance")]
+    pub role_max_shard_imbalance: f64,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ReplicaTaskPlacementConfig {
+    pub policy: ReplicaTaskPlacementPolicyKind,
+    pub active_node_roles: Vec<String>,
+    pub remote_only_node_roles: Vec<String>,
+    pub restrict_to_remote_only_node_roles: bool,
+    pub remote_only_shard_weight: f64,
+    pub role_queue_window_ms: f64,
+    pub role_pressure_gap_ms: f64,
+    pub role_fabric_guard_ms: f64,
+    pub role_max_shard_imbalance: f64,
+}
+
+fn default_replica_task_placement_policy() -> ReplicaTaskPlacementPolicyKind {
+    ReplicaTaskPlacementPolicyKind::LocalFirst
+}
+
+fn default_replica_task_active_node_roles() -> Vec<String> {
+    vec!["prefill".to_string(), "decode".to_string()]
+}
+
+fn default_replica_task_remote_only_node_roles() -> Vec<String> {
+    vec!["remote_cache".to_string()]
+}
+
+fn default_replica_task_restrict_to_remote_only_node_roles() -> bool {
+    true
+}
+
+fn default_replica_task_remote_only_shard_weight() -> f64 {
+    1.02
+}
+
+fn default_replica_task_role_queue_window_ms() -> f64 {
+    1.0
+}
+
+fn default_replica_task_role_pressure_gap_ms() -> f64 {
+    0.5
+}
+
+fn default_replica_task_role_fabric_guard_ms() -> f64 {
+    50.0
+}
+
+fn default_replica_task_role_max_shard_imbalance() -> f64 {
+    1.30
+}
+
+impl Default for ReplicaTaskPlacementConfigYaml {
+    fn default() -> Self {
+        Self {
+            policy: default_replica_task_placement_policy(),
+            active_node_roles: default_replica_task_active_node_roles(),
+            remote_only_node_roles: default_replica_task_remote_only_node_roles(),
+            restrict_to_remote_only_node_roles:
+                default_replica_task_restrict_to_remote_only_node_roles(),
+            remote_only_shard_weight: default_replica_task_remote_only_shard_weight(),
+            role_queue_window_ms: default_replica_task_role_queue_window_ms(),
+            role_pressure_gap_ms: default_replica_task_role_pressure_gap_ms(),
+            role_fabric_guard_ms: default_replica_task_role_fabric_guard_ms(),
+            role_max_shard_imbalance: default_replica_task_role_max_shard_imbalance(),
+        }
+    }
+}
+
+impl Default for ReplicaTaskPlacementConfig {
+    fn default() -> Self {
+        ReplicaTaskPlacementConfigYaml::default()
+            .verify()
+            .expect("default replica_task_placement config must be valid")
+    }
+}
+
+fn normalize_role_list(raw_roles: Vec<String>, field_name: &str) -> KvResult<Vec<String>> {
+    let mut deduped = std::collections::BTreeSet::new();
+    for (idx, raw) in raw_roles.into_iter().enumerate() {
+        let trimmed = raw.trim();
+        if trimmed.is_empty() {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: format!("{field_name}[{idx}] must be a non-empty string"),
+            }
+            .into_kverror());
+        }
+        deduped.insert(trimmed.to_string());
+    }
+    if deduped.is_empty() {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: format!("{field_name} must contain at least one role"),
+        }
+        .into_kverror());
+    }
+    Ok(deduped.into_iter().collect())
+}
+
+fn verify_finite_nonnegative_f64(value: f64, field_name: &str) -> KvResult<f64> {
+    if !value.is_finite() || value < 0.0 {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: format!("{field_name} must be a finite non-negative number"),
+        }
+        .into_kverror());
+    }
+    Ok(value)
+}
+
+impl ReplicaTaskPlacementConfigYaml {
+    pub fn verify(self) -> KvResult<ReplicaTaskPlacementConfig> {
+        let remote_only_shard_weight = self.remote_only_shard_weight;
+        if !remote_only_shard_weight.is_finite() || remote_only_shard_weight <= 0.0 {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: "replica_task_placement.remote_only_shard_weight must be a finite positive number"
+                    .to_string(),
+            }
+            .into_kverror());
+        }
+        let role_max_shard_imbalance = self.role_max_shard_imbalance;
+        if !role_max_shard_imbalance.is_finite() || role_max_shard_imbalance < 1.0 {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: "replica_task_placement.role_max_shard_imbalance must be finite and >= 1.0"
+                    .to_string(),
+            }
+            .into_kverror());
+        }
+
+        Ok(ReplicaTaskPlacementConfig {
+            policy: self.policy,
+            active_node_roles: normalize_role_list(
+                self.active_node_roles,
+                "replica_task_placement.active_node_roles",
+            )?,
+            remote_only_node_roles: normalize_role_list(
+                self.remote_only_node_roles,
+                "replica_task_placement.remote_only_node_roles",
+            )?,
+            restrict_to_remote_only_node_roles: self.restrict_to_remote_only_node_roles,
+            remote_only_shard_weight,
+            role_queue_window_ms: verify_finite_nonnegative_f64(
+                self.role_queue_window_ms,
+                "replica_task_placement.role_queue_window_ms",
+            )?,
+            role_pressure_gap_ms: verify_finite_nonnegative_f64(
+                self.role_pressure_gap_ms,
+                "replica_task_placement.role_pressure_gap_ms",
+            )?,
+            role_fabric_guard_ms: verify_finite_nonnegative_f64(
+                self.role_fabric_guard_ms,
+                "replica_task_placement.role_fabric_guard_ms",
+            )?,
+            role_max_shard_imbalance,
+        })
+    }
+}
+
 fn verify_otlp_log_api(cfg: &mut GreptimeOtlpLogConfigYaml) -> KvResult<GreptimeOtlpLogConfig> {
     let endpoint = cfg.otlp_endpoint.trim();
     if endpoint.is_empty() || !endpoint.contains("://") {
@@ -578,6 +765,8 @@ pub struct MasterConfigYaml {
     pub log_dir: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub master_ui: Option<MasterUiConfigYaml>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub replica_task_placement: Option<ReplicaTaskPlacementConfigYaml>,
     #[serde(default)]
     pub test_spec_config: TestSpecConfig,
 }
@@ -597,6 +786,7 @@ pub struct MasterConfig {
     pub pprof_duration_seconds: Option<u64>,
     pub log_dir: String,
     pub master_ui: Option<MasterUiConfig>,
+    pub replica_task_placement: ReplicaTaskPlacementConfig,
     pub test_spec_config: TestSpecConfig,
 }
 
@@ -1531,6 +1721,11 @@ impl MasterConfigYaml {
             None => None,
         };
 
+        let replica_task_placement = match self.replica_task_placement {
+            Some(cfg) => cfg.verify()?,
+            None => ReplicaTaskPlacementConfig::default(),
+        };
+
         let mut test_spec_config = self.test_spec_config;
         let transport_mode_was_explicit = test_spec_config.transport_mode.is_some();
         let normalized_rdma_device_names = normalize_test_spec_rdma_device_names(
@@ -1567,6 +1762,7 @@ impl MasterConfigYaml {
             network,
             log_dir: self.log_dir,
             master_ui,
+            replica_task_placement,
             test_spec_config,
         })
     }
@@ -1782,8 +1978,8 @@ test_spec_config:
     }
 
     #[test]
-    fn client_test_spec_config_implicit_transport_mode_with_rdma_device_names_defaults_to_transfer_with_rpc(
-    ) {
+    fn client_test_spec_config_implicit_transport_mode_with_rdma_device_names_defaults_to_transfer_with_rpc()
+     {
         let cfg = ClientConfigYaml::from_str(
             r#"
 instance_key: test_owner
@@ -1848,8 +2044,8 @@ test_spec_config:
     }
 
     #[test]
-    fn client_test_spec_config_rejects_transfer_rpc_fast_path_ready_timeout_without_explicit_rdma_device_names(
-    ) {
+    fn client_test_spec_config_rejects_transfer_rpc_fast_path_ready_timeout_without_explicit_rdma_device_names()
+     {
         let cfg = ClientConfigYaml::from_str(
             r#"
 instance_key: test_owner
@@ -1893,9 +2089,10 @@ test_spec_config:
         )
         .unwrap();
         let err = cfg.verify().unwrap_err();
-        assert!(err
-            .to_string()
-            .contains("test_spec_config.tcp_thread_control_lane_count must be in [1, 8]"));
+        assert!(
+            err.to_string()
+                .contains("test_spec_config.tcp_thread_control_lane_count must be in [1, 8]")
+        );
     }
 
     #[test]
@@ -2244,6 +2441,76 @@ test_spec_config:
         assert!(verified.enable_transfer_rpc_fast_path);
     }
 
+    #[test]
+    fn master_config_accepts_replica_task_placement_policy() {
+        let cfg = MasterConfigYaml::from_str(
+            r#"
+instance_key: test_master
+cluster_name: test_cluster
+port: 18080
+etcd_endpoints: ["127.0.0.1:2379"]
+network:
+  subnet_whitelist: ["127.0.0.0/8"]
+monitoring:
+  prometheus_base_url: "http://127.0.0.1:4000/v1/prometheus"
+log_dir: /tmp/test_master_logs
+replica_task_placement:
+  policy: bounded_role_queue_aware
+  active_node_roles: [" decode ", "prefill", "decode"]
+  remote_only_node_roles: ["remote_cache", " mem_only "]
+  restrict_to_remote_only_node_roles: true
+  remote_only_shard_weight: 1.08
+  role_queue_window_ms: 2.5
+  role_pressure_gap_ms: 0.75
+  role_fabric_guard_ms: 40.0
+  role_max_shard_imbalance: 1.5
+"#,
+        )
+        .unwrap();
+        let verified = cfg.verify().unwrap();
+        assert_eq!(
+            verified.replica_task_placement.policy,
+            ReplicaTaskPlacementPolicyKind::BoundedRoleQueueAware
+        );
+        assert_eq!(
+            verified.replica_task_placement.active_node_roles,
+            vec!["decode".to_string(), "prefill".to_string()]
+        );
+        assert_eq!(
+            verified.replica_task_placement.remote_only_node_roles,
+            vec!["mem_only".to_string(), "remote_cache".to_string()]
+        );
+        assert!(
+            verified
+                .replica_task_placement
+                .restrict_to_remote_only_node_roles
+        );
+        assert_eq!(verified.replica_task_placement.role_queue_window_ms, 2.5);
+    }
+
+    #[test]
+    fn master_config_rejects_invalid_replica_task_placement_weight() {
+        let cfg = MasterConfigYaml::from_str(
+            r#"
+instance_key: test_master
+cluster_name: test_cluster
+port: 18080
+etcd_endpoints: ["127.0.0.1:2379"]
+network:
+  subnet_whitelist: ["127.0.0.0/8"]
+monitoring:
+  prometheus_base_url: "http://127.0.0.1:4000/v1/prometheus"
+log_dir: /tmp/test_master_logs
+replica_task_placement:
+  policy: weighted_role_aware
+  remote_only_shard_weight: 0.0
+"#,
+        )
+        .unwrap();
+        let err = cfg.verify().unwrap_err();
+        assert!(format!("{err}").contains("remote_only_shard_weight"));
+    }
+
     #[test]
     fn master_config_accepts_missing_port_for_auto_discovery() {
         let cfg = MasterConfigYaml::from_str(
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs b/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
index da701cd..1464285 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
@@ -3,7 +3,8 @@ use std::collections::HashMap;
 use crate::cluster_manager::NodeID;
 use crate::config::{
     ClientConfig, ContributeToClusterPoolSize, FluxonKvSpec, LargeFilePaths, MasterConfig,
-    MonitoringConfig, ProtocolConfig, ProtocolType, TestSpecConfig, TransferEngineType,
+    MonitoringConfig, ProtocolConfig, ProtocolType, ReplicaTaskPlacementConfig, TestSpecConfig,
+    TransferEngineType,
 };
 use crate::master_kv_router::MasterKvRouterView;
 use crate::{ConfigArg, run_client, run_master};
@@ -46,6 +47,7 @@ fn new_master_config(
         log_dir,
         pprof_duration_seconds: None,
         master_ui: None,
+        replica_task_placement: ReplicaTaskPlacementConfig::default(),
         test_spec_config: TestSpecConfig::default(),
     }
 }
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index fb60035..222b821 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -1,3 +1,4 @@
+use crate::SharedJsonMeta;
 use crate::client_kv_api::external_api::{
     compute_external_get_start_transfer_prefix, normalize_external_get_start_group_lens,
 };
@@ -10,7 +11,6 @@ use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
 use crate::rpcresp_kvresult_convert::ToResult;
-use crate::SharedJsonMeta;
 use crate::{
     client_kv_api::msg_pack::{
         ExternalBatchGetCancelReq, ExternalBatchGetReq, ExternalBatchGetStartReq,
@@ -33,16 +33,16 @@ use crate::{
         msg_pack::{MsgPack, RPCCaller, RPCHandler},
         p2p_module::{P2pModule, P2pModuleAccessTrait, RpcTransportPolicy},
     },
-    rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, SharedMemError, OK},
+    rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK, SharedMemError},
 };
 use async_trait::async_trait;
 use core::panic;
 use dashmap::DashMap;
 use fluxon_commu::ShareGroupOwnerRef;
-use fluxon_framework::{define_module, LogicalModule};
+use fluxon_framework::{LogicalModule, define_module};
 use fluxon_observability::kv_metrics_actor::{ObserveComponent, ObserveDirection};
 use fluxon_util::semaphore_map::SemaphoreMap;
-use libc::{mmap, MAP_SHARED, PROT_READ, PROT_WRITE};
+use libc::{MAP_SHARED, PROT_READ, PROT_WRITE, mmap};
 use limit_thirdparty::tokio;
 use limit_thirdparty::tokio::sync::{ARwLock, Notify};
 use limit_thirdparty::tokio::time::sleep;
@@ -51,8 +51,8 @@ use std::{
     fs::File,
     // path::PathBuf, // 不再使用PathBuf
     sync::{
-        atomic::{AtomicUsize, Ordering},
         Arc, OnceLock, Weak,
+        atomic::{AtomicUsize, Ordering},
     },
     time::{Duration, Instant},
 };
@@ -2610,7 +2610,7 @@ key={}, attempt={}/{}, err={}",
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
         let reject_if_exist_same_key = opts.reject_if_exist_same_key();
-        let write_through = opts.write_through();
+        let make_replica_task = opts.make_replica_task();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let observe_sink = opts.test_observe_put_phases();
         let observe_enabled = true;
@@ -2647,7 +2647,7 @@ key={}, attempt={}/{}, err={}",
                     lease_id,
                     reject_if_inflight_same_key,
                     reject_if_exist_same_key,
-                    write_through,
+                    make_replica_task,
                     preferred_sub_cluster.as_deref(),
                     observe_enabled,
                 )
@@ -2701,7 +2701,7 @@ key={}, attempt={}/{}, err={}",
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
         let reject_if_exist_same_key = opts.reject_if_exist_same_key();
-        let write_through = opts.write_through();
+        let make_replica_task = opts.make_replica_task();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let observe_sink = opts.test_observe_put_phases();
         let observe_enabled = true;
@@ -2737,7 +2737,7 @@ key={}, attempt={}/{}, err={}",
                     lease_id,
                     reject_if_inflight_same_key,
                     reject_if_exist_same_key,
-                    write_through,
+                    make_replica_task,
                     preferred_sub_cluster.as_deref(),
                     observe_enabled,
                 )
@@ -2800,7 +2800,7 @@ key={}, attempt={}/{}, err={}",
         let lease_id = opts.lease_id();
         let reject_if_inflight_same_key = opts.reject_if_inflight_same_key();
         let reject_if_exist_same_key = opts.reject_if_exist_same_key();
-        let write_through = opts.write_through();
+        let make_replica_task = opts.make_replica_task();
         let preferred_sub_cluster = opts.preferred_sub_cluster().map(|s| s.to_string());
         let mut payload_lens = Vec::with_capacity(ptrs_groups.len());
         for ptrs in ptrs_groups.iter() {
@@ -2831,7 +2831,7 @@ key={}, attempt={}/{}, err={}",
                     lease_id,
                     reject_if_inflight_same_key,
                     reject_if_exist_same_key,
-                    write_through,
+                    make_replica_task,
                     preferred_sub_cluster.as_deref(),
                     transfer_concurrency.max(1),
                 )
@@ -2874,7 +2874,7 @@ key={}, attempt={}/{}, err={}",
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
+        make_replica_task: bool,
         preferred_sub_cluster: Option<&str>,
         transfer_concurrency: usize,
     ) -> KvResult<Vec<KvResult<()>>> {
@@ -2894,7 +2894,7 @@ key={}, attempt={}/{}, err={}",
                         len: *payload_len,
                         reject_if_inflight_same_key,
                         reject_if_exist_same_key,
-                        write_through,
+                        make_replica_task,
                         preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                     })
                     .collect(),
@@ -2974,7 +2974,6 @@ key={}, attempt={}/{}, err={}",
                         remote_target: start_item.peer_id.is_some(),
                         put_id: Some(put_id),
                         lease_id,
-                        write_through,
                     },
                 ));
                 continue;
@@ -3001,7 +3000,6 @@ key={}, attempt={}/{}, err={}",
                         None
                     },
                     put_id: Some(put_id),
-                    write_through,
                     lease_id,
                 },
             ));
@@ -3151,7 +3149,7 @@ key={}, attempt={}/{}, err={}",
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
+        make_replica_task: bool,
         preferred_sub_cluster: Option<&str>,
         observe_enabled: bool,
     ) -> KvResult<TestPutPhaseTrace> {
@@ -3162,7 +3160,7 @@ key={}, attempt={}/{}, err={}",
                 len: payload_len,
                 reject_if_inflight_same_key,
                 reject_if_exist_same_key,
-                write_through,
+                make_replica_task,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                 started_time,
                 test_observe_put_phases: true,
@@ -3206,7 +3204,6 @@ key={}, attempt={}/{}, err={}",
                     remote_target,
                     put_id: put_start_ok.put_id,
                     lease_id,
-                    write_through,
                     started_time,
                     test_observe_put_phases: true,
                 },
@@ -3275,7 +3272,6 @@ key={}, attempt={}/{}, err={}",
                     None
                 },
                 put_id: put_start_ok.put_id.clone(),
-                write_through,
                 lease_id,
                 started_time,
                 test_observe_put_phases: true,
@@ -3321,7 +3317,7 @@ key={}, attempt={}/{}, err={}",
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
+        make_replica_task: bool,
         preferred_sub_cluster: Option<&str>,
         observe_enabled: bool,
     ) -> KvResult<TestPutPhaseTrace> {
@@ -3333,7 +3329,7 @@ key={}, attempt={}/{}, err={}",
                 len: value.len() as u64,
                 reject_if_inflight_same_key,
                 reject_if_exist_same_key,
-                write_through,
+                make_replica_task,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                 started_time,
                 test_observe_put_phases: true,
@@ -3376,7 +3372,6 @@ key={}, attempt={}/{}, err={}",
                     remote_target,
                     put_id: put_start_ok.put_id,
                     lease_id,
-                    write_through,
                     started_time,
                     test_observe_put_phases: true,
                 },
@@ -3459,7 +3454,6 @@ key={}, attempt={}/{}, err={}",
                     None
                 },
                 put_id: put_start_ok.put_id.clone(),
-                write_through,
                 lease_id,
                 started_time,
                 test_observe_put_phases: true,
diff --git a/fluxon_rs/fluxon_kv/src/kv_test.rs b/fluxon_rs/fluxon_kv/src/kv_test.rs
index 392ccf1..4db3a7f 100644
--- a/fluxon_rs/fluxon_kv/src/kv_test.rs
+++ b/fluxon_rs/fluxon_kv/src/kv_test.rs
@@ -12,11 +12,11 @@
 use crate::cluster_manager::ClusterManagerRdmaControlInit;
 use crate::config::{
     ClientConfig, ContributeToClusterPoolSize, FluxonKvSpec, LargeFilePaths, MasterConfig,
-    MonitoringConfig, ProtocolConfig, ProtocolType, TestSpecConfig, TestSpecTransportMode,
-    TransferEngineType,
+    MonitoringConfig, ProtocolConfig, ProtocolType, ReplicaTaskPlacementConfig, TestSpecConfig,
+    TestSpecTransportMode, TransferEngineType,
 };
 use crate::run_master_with_test_overrides;
-use crate::{run_client_with_test_overrides, ClientRunTestOverrides, MasterRunTestOverrides};
+use crate::{ClientRunTestOverrides, MasterRunTestOverrides, run_client_with_test_overrides};
 // external client runs via run_client when contribution is zero
 use crate::ConfigArg;
 use etcd_client::Client as EtcdClient;
@@ -519,16 +519,18 @@ async fn verify_rdma_transfer_data_link(
             );
         }
 
-        let Some(raw) =
-            fetch_transfer_link_te_value(cluster_name, from_instance_key, to_instance_key)
-                .await
-                .unwrap_or_else(|err| {
-                    panic!(
+        let Some(raw) = fetch_transfer_link_te_value(
+            cluster_name,
+            from_instance_key,
+            to_instance_key,
+        )
+        .await
+        .unwrap_or_else(|err| {
+            panic!(
                 "closed transfer_link probe failed: cluster={} from={} to={} attempt={} err={}",
                 cluster_name, from_instance_key, to_instance_key, attempt, err
             )
-                })
-        else {
+        }) else {
             if Instant::now() >= deadline {
                 panic!(
                     "closed transfer data probe timed out without transfer_link_te key: cluster={} from={} to={} key_prefix={} key={} attempt={}",
@@ -990,6 +992,7 @@ fn new_master_launch(
             network: None,
             log_dir,
             master_ui: None,
+            replica_task_placement: ReplicaTaskPlacementConfig::default(),
             // Keep kv_test self-describing: each round carries the intended transfer mode.
             test_spec_config: kv_test_round_test_spec_config(round.round_profile),
         },
diff --git a/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs b/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
index c74b64a..376cc8a 100644
--- a/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
+++ b/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
@@ -10,7 +10,7 @@ use crate::client_kv_api::ClientKvApiView;
 use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::config::{
     ClientConfig, ContributeToClusterPoolSize, FluxonKvSpec, MasterConfig, MonitoringConfig,
-    ProtocolConfig, ProtocolType, TestSpecConfig, TransferEngineType,
+    ProtocolConfig, ProtocolType, ReplicaTaskPlacementConfig, TestSpecConfig, TransferEngineType,
 };
 use crate::{ConfigArg, Framework, run_client, run_master};
 
@@ -93,6 +93,7 @@ fn new_master_config_with_cluster(
         log_dir,
         pprof_duration_seconds: None,
         master_ui: None,
+        replica_task_placement: ReplicaTaskPlacementConfig::default(),
         test_spec_config: TestSpecConfig::default(),
     };
     println!("fluxonkv core created master config for test: {:?}", conf);
diff --git a/fluxon_rs/fluxon_kv/src/lib.rs b/fluxon_rs/fluxon_kv/src/lib.rs
index fe69407..609dc47 100644
--- a/fluxon_rs/fluxon_kv/src/lib.rs
+++ b/fluxon_rs/fluxon_kv/src/lib.rs
@@ -58,8 +58,8 @@ use crate::external_client_api::ExternalClientApiViewTrait;
 use crate::master_kv_router::MasterKvRouterAccessTrait;
 use crate::master_kv_router::MasterKvRouterView;
 use crate::master_kv_router::MasterKvRouterViewTrait;
-use crate::master_lease_manager::master_lease_manager::MasterLeaseManagerNewArg;
 use crate::master_lease_manager::MasterLeaseManager;
+use crate::master_lease_manager::master_lease_manager::MasterLeaseManagerNewArg;
 use crate::master_lease_manager::{
     MasterLeaseManagerAccessTrait, MasterLeaseManagerView, MasterLeaseManagerViewTrait,
 };
@@ -80,21 +80,21 @@ use client_seg_pool::{ClientSegPool, ClientSegPoolNewArg};
 use client_transfer_engine::ClientTransferEngine;
 use cluster_manager::{ClusterManager, ClusterManagerNewArg, ClusterManagerRdmaControlInit};
 use config::{
-    normalize_etcd_addresses, ClientConfig, ClientConfigYaml, ContributeToClusterPoolSize,
-    FluxonKvSpec, MasterConfig, MasterConfigYaml, ProtocolConfig, ProtocolType, SideTransferRole,
-    TestSpecConfig, TestSpecTransportMode, TransferEngineType,
+    ClientConfig, ClientConfigYaml, ContributeToClusterPoolSize, FluxonKvSpec, MasterConfig,
+    MasterConfigYaml, ProtocolConfig, ProtocolType, SideTransferRole, TestSpecConfig,
+    TestSpecTransportMode, TransferEngineType, normalize_etcd_addresses,
 };
 use external_client_api::{ExternalClientApi, ExternalClientApiNewArg};
 use fluxon_commu::TransferBackendActivationMode;
 use fluxon_framework::LogicalModule;
-use fluxon_framework::{define_framework, AnyResult};
+use fluxon_framework::{AnyResult, define_framework};
 use master_kv_router::{MasterKvRouter, MasterKvRouterNewArg};
 use master_seg_manager::MasterSegManager;
 use metric_reporter::{
-    register_greptime_otlp_log_proxy_rpc, serialize_master_observe_broadcast,
-    wait_master_observe_broadcast, MetricReporter, MetricReporterAccessTrait, MetricReporterNewArg,
+    META_KEY_KV_OBSERVE_BROADCAST, MetricReporter, MetricReporterAccessTrait, MetricReporterNewArg,
     MetricReporterView, MetricReporterViewTrait, ObserveProxyCaller, ObserveProxyPicker,
-    META_KEY_KV_OBSERVE_BROADCAST,
+    register_greptime_otlp_log_proxy_rpc, serialize_master_observe_broadcast,
+    wait_master_observe_broadcast,
 };
 use p2p::p2p_module::{P2pModule, P2pModuleNewArg, P2pTcpThreadTransportTuning};
 use sha2::{Digest, Sha256};
@@ -1521,6 +1521,7 @@ async fn run_master_impl(
         master_seg_manager_arg: MasterSegManagerNewArg,
         master_kv_router_arg: MasterKvRouterNewArg {
             test_spec_config: config.test_spec_config.clone(),
+            replica_task_placement: config.replica_task_placement.clone(),
         },
         metric_reporter_arg: MetricReporterNewArg {
             test_spec_config: config.test_spec_config.clone(),
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
index b7d65fc..4a25934 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
@@ -1,12 +1,12 @@
 use super::{
+    MasterKvRouterView,
     msg_pack::{
         BatchDeleteAckReq, BatchDeleteAckResp, BatchDeleteClientKvMetaCacheReq, DeleteAckReq,
         DeleteAckResp, DeleteClientKvMetaCacheItem, DeleteReq, DeleteResp,
     },
-    MasterKvRouterView,
 };
-use crate::master_kv_router::put::PutIDForAKey;
 use crate::master_kv_router::OneKvNodesRoutes;
+use crate::master_kv_router::put::PutIDForAKey;
 use crate::memholder::{
     EnsureMemholderMgmtDeleteActorOwned, MasterOwnerMemMgr, MemholderManagerTrait,
 };
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 4a290a7..52d348e 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -1,4 +1,5 @@
 use super::{
+    InflightGetInfo, KvRouteInfo, MasterKvRouterView, NodeValueReplicaDesc, OwnerHoldingGetInfo,
     msg_pack::{
         BatchGetDoneItemResp, BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeItemResp,
         BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
@@ -7,25 +8,24 @@ use super::{
         GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq,
         MemHolderReleaseResp,
     },
-    InflightGetInfo, KvRouteInfo, MasterKvRouterView, NodeValueReplicaDesc, OwnerHoldingGetInfo,
 };
-use crate::master_kv_router::put::PutIDForAKey;
 use crate::master_kv_router::OneKvNodesRoutes;
+use crate::master_kv_router::put::PutIDForAKey;
 use crate::memholder::MemholderManagerTrait;
 use crate::{
     cluster_manager::NodeID,
-    master_seg_manager::{one_seg_allocator::Allocation, MasterSegManagerAccessTrait},
+    master_seg_manager::{MasterSegManagerAccessTrait, one_seg_allocator::Allocation},
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::{self, kv},
 };
 use dashmap::DashMap;
 use limit_thirdparty::tokio;
-use rand::seq::SliceRandom;
 use rand::Rng;
+use rand::seq::SliceRandom;
 use std::collections::HashSet;
 use std::{
     collections::HashMap,
-    sync::{atomic::Ordering, Arc},
+    sync::{Arc, atomic::Ordering},
 };
 
 fn update_moka_for_node(
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index 6fb7426..9e02cf4 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -26,7 +26,7 @@ use self::{
         PutAppendRevokeReq, PutAppendStartReq, PutDoneReq, PutRevokeReq, PutStartReq,
         ReleaseLocalGrantReq, ReserveLocalGrantReq,
     },
-    placement::{PlacementDefault, PlacementPolicy},
+    placement::{PlacementPolicy, build_placement_policy},
     put::{
         handle_batch_prepare_put_keys, handle_batch_put_done, handle_batch_put_revoke,
         handle_batch_put_start, handle_batch_release_put_key_reservations, handle_put_append_done,
@@ -34,18 +34,19 @@ use self::{
         handle_put_start, handle_release_local_grant, handle_reserve_local_grant,
     },
 };
+use crate::ClientKvApiAccessTrait;
 use crate::client_kv_api::ClientKvApi;
 use crate::cluster_manager::{
     ClusterEvent, ClusterManager, ClusterManagerAccessTrait, NodeID, NodeIDString,
 };
-use crate::config::TestSpecConfig;
+use crate::config::{ReplicaTaskPlacementConfig, TestSpecConfig};
 use crate::master_kv_router::delete::DeleteKeyInfo;
 use crate::master_kv_router::put::PutIDForAKey;
 use crate::master_lease_manager::{MasterLeaseManager, MasterLeaseManagerAccessTrait};
-use crate::master_seg_manager::one_seg_allocator::Allocation;
 use crate::master_seg_manager::MasterSegManager;
 use crate::master_seg_manager::MasterSegManagerAccessTrait;
 use crate::master_seg_manager::NodeTombTag;
+use crate::master_seg_manager::one_seg_allocator::Allocation;
 use crate::memholder::{
     EnsureMemholderMgmtDeleteHandle, MasterOwnerMemMgr, MemholderManagerTrait, NodeHolderKey,
 };
@@ -54,14 +55,13 @@ use crate::p2p::msg_pack::{MsgPack, RPCCaller, RPCHandler};
 use crate::p2p::p2p_module::{P2pModule, P2pModuleAccessTrait};
 use crate::rpcresp_kvresult_convert;
 use crate::rpcresp_kvresult_convert::msg_and_error::{KvError, OK};
-use crate::ClientKvApiAccessTrait;
-use fluxon_framework::{define_module, LogicalModule};
+use fluxon_framework::{LogicalModule, define_module};
 use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 
 use async_trait::async_trait;
 use chrono::Utc;
 use dashmap::DashMap;
-use limit_thirdparty::tokio::sync::{abroadcast, ARwLock};
+use limit_thirdparty::tokio::sync::{ARwLock, abroadcast};
 use limit_thirdparty::tokio::{self, sync::ampsc};
 use moka::notification::RemovalCause;
 use parking_lot::Mutex;
@@ -69,8 +69,8 @@ use parking_lot::RwLock;
 use std::borrow::Cow;
 use std::collections::HashSet;
 use std::collections::{HashMap, VecDeque};
-use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tracing::{debug, error, info, warn};
 
@@ -198,6 +198,7 @@ pub enum InflightPutAllocation {
 pub struct InflightPutCommitInfo {
     pub node_id: NodeID,
     pub src_target_allocation: Arc<Mutex<Option<InflightPutAllocation>>>,
+    pub replica_target: Option<InflightReplicaTaskInfo>,
 }
 
 /// Information about a `put` operation that is currently in progress.
@@ -207,11 +208,10 @@ pub struct InflightPutInfo {
     pub req_node_id: NodeID,
     pub len: u64,
     pub commit_info: InflightPutCommitInfo,
-    pub remote_append: Option<InflightPutAppendInfo>,
 }
 
 #[derive(Clone)]
-pub struct InflightPutAppendInfo {
+pub struct InflightReplicaTaskInfo {
     pub node_id: NodeID,
     pub key: String,
     pub put_id: PutIDForAKey,
@@ -305,6 +305,7 @@ define_module!(
 #[derive(Clone, Debug, Default)]
 pub struct MasterKvRouterNewArg {
     pub test_spec_config: TestSpecConfig,
+    pub replica_task_placement: ReplicaTaskPlacementConfig,
 }
 
 #[derive(Clone)]
@@ -493,10 +494,11 @@ pub struct MasterKvRouterInner {
     view: std::sync::OnceLock<MasterKvRouterView>,
     pub policy: Box<dyn PlacementPolicy>,
     test_spec_config: TestSpecConfig,
+    pub replica_task_placement: ReplicaTaskPlacementConfig,
 
     /// (key, put_time_ms, put_version) -> inflight_put_info
     pub inflight_puts: moka::future::Cache<(String, u64, u32), InflightPutInfo>,
-    pub inflight_put_appends: moka::future::Cache<(String, u64, u32), InflightPutAppendInfo>,
+    pub inflight_replica_tasks: moka::future::Cache<(String, u64, u32), InflightReplicaTaskInfo>,
     /// key -> inflight put count
     pub inflight_put_key_counts: Arc<DashMap<String, u32>>,
     pub inflight_gets: moka::future::Cache<u64, InflightGetInfo>,
@@ -551,6 +553,9 @@ pub struct MasterKvRouterInner {
     /// Historical final put placement decisions grouped by placement mode.
     pub put_placement_mode_counts: DashMap<&'static str, Arc<AtomicU64>>,
 
+    /// Historical accepted replica task reservations by target node.
+    pub replica_task_target_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
+
     /// Support replicas: key -> version_id
     recent_key_versionid_allocator: moka::sync::SegmentedCache<String, Arc<AtomicU32>>,
 
@@ -634,7 +639,7 @@ impl MasterKvRouter {
     }
 
     pub async fn construct(arg: MasterKvRouterNewArg) -> Result<Self, KvError> {
-        let policy_impl: Box<dyn PlacementPolicy> = Box::new(PlacementDefault::new());
+        let policy_impl = build_placement_policy(arg.replica_task_placement.clone());
         let inflight_put_ttl_seconds = if arg.test_spec_config.skip_put_end_commit {
             INFLIGHT_PUT_TTL_SECONDS_SKIP_PUT_END_COMMIT
         } else {
@@ -661,15 +666,16 @@ impl MasterKvRouter {
                 }
             })
             .build();
-        let inflight_put_appends = moka::future::Cache::builder()
+        let inflight_replica_tasks = moka::future::Cache::builder()
             .time_to_live(Duration::from_secs(60))
             .build();
         let inner = MasterKvRouterInner {
             view: std::sync::OnceLock::new(),
             policy: policy_impl,
             test_spec_config: arg.test_spec_config,
+            replica_task_placement: arg.replica_task_placement,
             inflight_puts,
-            inflight_put_appends,
+            inflight_replica_tasks,
             inflight_put_key_counts,
             inflight_gets,
             get_holding: MasterOwnerMemMgr::default(),
@@ -687,6 +693,7 @@ impl MasterKvRouter {
             put_target_decision_counts: DashMap::new(),
             put_requester_target_decision_counts: DashMap::new(),
             put_placement_mode_counts: DashMap::new(),
+            replica_task_target_counts: DashMap::new(),
             recent_key_versionid_allocator: moka::sync::SegmentedCache::builder(8)
                 .time_to_idle(Duration::from_secs(5))
                 .build(),
@@ -1037,9 +1044,10 @@ impl MasterKvRouter {
             let view = view.clone();
             let view2 = view.clone();
             let view_task = view2.clone();
+            let req_node_id = resp.node_id().clone();
             let _ = view.spawn("rpc_put_done", async move {
                 let t0 = Utc::now().timestamp_micros();
-                let mut ack = handle_put_done(view_task, msg).await;
+                let mut ack = handle_put_done(view_task, msg, req_node_id).await;
                 ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send PutDoneResp: {:?}", e);
@@ -1224,9 +1232,10 @@ impl MasterKvRouter {
         RPCHandler::<BatchPutDoneReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
             let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
             view.spawn("rpc_batch_put_done", async move {
                 let t0 = Utc::now().timestamp_micros();
-                let mut ack = handle_batch_put_done(view2, msg).await;
+                let mut ack = handle_batch_put_done(view2, msg, req_node_id).await;
                 ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send BatchPutDoneResp: {:?}", e);
@@ -1754,6 +1763,17 @@ impl MasterKvRouter {
         mode_counter.fetch_add(1, Ordering::Relaxed);
     }
 
+    pub fn record_replica_task_target(&self, target_node_id: &str) {
+        let target_counter = self
+            .inner()
+            .replica_task_target_counts
+            .entry(target_node_id.to_string())
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .clone();
+        target_counter.fetch_add(1, Ordering::Relaxed);
+    }
+
     fn spawn_put_placement_reporter(&self) {
         let view = self.inner().view().clone();
         let view_task = view.clone();
@@ -1791,11 +1811,20 @@ impl MasterKvRouter {
                             .collect();
                         mode_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
 
+                        let mut replica_task_target_counts: Vec<(String, u64)> = router
+                            .inner()
+                            .replica_task_target_counts
+                            .iter()
+                            .map(|entry| (entry.key().clone(), entry.value().load(Ordering::Relaxed)))
+                            .collect();
+                        replica_task_target_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+
                         info!(
-                            "put placement historical distribution | target_counts={:?} | mode_counts={:?} | requester_target_counts={:?}",
+                            "put placement historical distribution | target_counts={:?} | mode_counts={:?} | requester_target_counts={:?} | replica_task_target_counts={:?}",
                             target_counts,
                             mode_counts,
                             requester_target_counts,
+                            replica_task_target_counts,
                         );
                     }
                     _ = shutdown_waiter.wait() => {
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index efb12c9..2185436 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -382,7 +382,7 @@ pub struct PutStartReq {
     pub len: u64,
     pub reject_if_inflight_same_key: bool,
     pub reject_if_exist_same_key: bool,
-    pub write_through: bool,
+    pub make_replica_task: bool,
     /// Prefer placing the target allocation on any kvclient within this sub_cluster.
     pub preferred_sub_cluster: Option<String>,
     /// Optional source-node override for side-transfer workers that share an owner's mmap.
@@ -393,6 +393,14 @@ impl MsgPackSerializePart for PutStartReq {
         MsgId::PutStartReq as u32
     }
 }
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct PutReplicaTarget {
+    pub node_id: NodeIDString,
+    pub target_addr: u64,
+    pub target_base_addr: u64,
+    pub len: u64,
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutStartResp {
     pub put_id: PutIDForAKey,
@@ -408,6 +416,7 @@ pub struct PutStartResp {
     pub error_json: String,
     /// Server-side processing time in microseconds for this RPC handler
     pub server_process_us: i64,
+    pub replica_target: Option<PutReplicaTarget>,
 }
 impl MsgPackSerializePart for PutStartResp {
     fn msg_id(&self) -> u32 {
@@ -492,7 +501,7 @@ pub struct BatchPutStartItemReq {
     pub len: u64,
     pub reject_if_inflight_same_key: bool,
     pub reject_if_exist_same_key: bool,
-    pub write_through: bool,
+    pub make_replica_task: bool,
     pub preferred_sub_cluster: Option<String>,
 }
 
@@ -517,6 +526,7 @@ pub struct BatchPutStartItemResp {
     pub len: u64,
     pub error_code: ErrorCode,
     pub error_json: String,
+    pub replica_target: Option<PutReplicaTarget>,
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
index d6c04bf..69c5db0 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
@@ -1,13 +1,16 @@
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
+use std::sync::atomic::Ordering as AtomicOrdering;
 
 use crate::{
-    cluster_manager::NodeID,
+    cluster_manager::{ClusterMember, NodeID},
+    config::{ReplicaTaskPlacementConfig, ReplicaTaskPlacementPolicyKind},
     master_seg_manager::one_seg_allocator::{Allocation, OneSegAllocator},
     rpcresp_kvresult_convert::msg_and_error::KvError,
 };
 use async_trait::async_trait;
-use rand::seq::SliceRandom;
 use rand::Rng;
+use rand::seq::SliceRandom;
 
 use super::MasterKvRouterView;
 
@@ -17,7 +20,6 @@ pub enum PutPlacementTarget {
     /// Place remotely with a pre-allocated target allocation.
     Remote {
         node_id: NodeID,
-        allocator: Arc<OneSegAllocator>,
         allocation: Allocation,
     },
 }
@@ -33,15 +35,29 @@ pub trait PlacementPolicy: Send + Sync {
         preferred_sub_cluster: Option<&str>,
         len: u64,
     ) -> Result<PutPlacementTarget, KvError>;
+
+    /// Selects a remote-only target for replica task placement.
+    fn select_remote_target(
+        &self,
+        view: &MasterKvRouterView,
+        source_node_id: &NodeID,
+        excluded_nodes: &HashSet<NodeID>,
+        preferred_sub_cluster: Option<&str>,
+        len: u64,
+    ) -> Result<(NodeID, Allocation), KvError> {
+        choose_random_remote_target(
+            view,
+            source_node_id,
+            excluded_nodes,
+            preferred_sub_cluster,
+            len,
+        )
+    }
 }
 
-/// Compile-time switch for the master placement default.
-///
-/// Change the type alias to switch behavior (and rebuild):
-/// - `LocalFirstPlacementPolicy` prefers local placement when possible.
-/// - `RandomPlacementPolicy` selects a random eligible target.
-pub type PlacementDefault = LocalFirstPlacementPolicy;
-// pub type PlacementDefault = RandomPlacementPolicy;
+pub fn build_placement_policy(config: ReplicaTaskPlacementConfig) -> Box<dyn PlacementPolicy> {
+    Box::new(ReplicaTaskPlacementPolicy::new(config))
+}
 
 /// A policy that prefers placing on the requesting node when possible.
 pub struct LocalFirstPlacementPolicy;
@@ -116,7 +132,6 @@ impl PlacementPolicy for LocalFirstPlacementPolicy {
                     if let Ok(allocation) = allocator.allocate(len) {
                         return Ok(PutPlacementTarget::Remote {
                             node_id,
-                            allocator,
                             allocation,
                         });
                     }
@@ -149,7 +164,6 @@ impl PlacementPolicy for LocalFirstPlacementPolicy {
                 if let Ok(allocation) = allocator.allocate(len) {
                     return Ok(PutPlacementTarget::Remote {
                         node_id,
-                        allocator,
                         allocation,
                     });
                 }
@@ -259,7 +273,6 @@ impl PlacementPolicy for RandomPlacementPolicy {
                     if let Ok(allocation) = allocator.allocate(len) {
                         return Ok(PutPlacementTarget::Remote {
                             node_id,
-                            allocator,
                             allocation,
                         });
                     }
@@ -293,7 +306,6 @@ impl PlacementPolicy for RandomPlacementPolicy {
                 if let Ok(allocation) = allocator.allocate(len) {
                     return Ok(PutPlacementTarget::Remote {
                         node_id,
-                        allocator,
                         allocation,
                     });
                 }
@@ -322,3 +334,680 @@ impl PlacementPolicy for RandomPlacementPolicy {
         Err(err)
     }
 }
+
+#[derive(Clone)]
+struct PlacementCandidate {
+    node_id: NodeID,
+    allocator: Arc<OneSegAllocator>,
+    total_bytes: u64,
+    free_bytes: u64,
+    used_bytes: u64,
+    node_write_count: u64,
+    requester_target_count: u64,
+    is_remote_only_role: bool,
+    is_active_role: bool,
+    preferred_sub_cluster_match: bool,
+}
+
+impl PlacementCandidate {
+    fn queue_wait_ms(&self) -> f64 {
+        self.node_write_count as f64 + (self.requester_target_count as f64 * 0.01)
+    }
+
+    fn mem_pressure(&self) -> f64 {
+        if self.total_bytes == 0 {
+            1.0
+        } else {
+            1.0 - (self.free_bytes as f64 / self.total_bytes as f64)
+        }
+    }
+
+    fn queue_score(&self) -> f64 {
+        self.queue_wait_ms() + self.mem_pressure() * 0.001 + self.used_bytes as f64 * 1e-9
+    }
+}
+
+type NoSpaceCtx = (String, String, u64, u64);
+
+fn no_space_error(last_no_space_ctx: Option<NoSpaceCtx>) -> KvError {
+    if let Some((node, segment, total_capacity, free_capacity)) = last_no_space_ctx {
+        KvError::Api(
+            crate::rpcresp_kvresult_convert::msg_and_error::ApiError::NoSpace {
+                node,
+                segment,
+                total_capacity,
+                free_capacity,
+            },
+        )
+    } else {
+        KvError::Api(
+            crate::rpcresp_kvresult_convert::msg_and_error::ApiError::NoSpace {
+                node: "unknown".to_string(),
+                segment: "unknown".to_string(),
+                total_capacity: 0,
+                free_capacity: 0,
+            },
+        )
+    }
+}
+
+fn member_matches_roles(member: Option<&ClusterMember>, roles: &[String]) -> bool {
+    let Some(member) = member else {
+        return false;
+    };
+    let metadata_role = member.metadata.get("role").map(|v| v.as_str());
+    let metadata_node_role = member.metadata.get("node_role").map(|v| v.as_str());
+    let sub_cluster = member.sub_cluster.as_deref();
+    roles.iter().any(|role| {
+        let role = role.as_str();
+        metadata_role == Some(role) || metadata_node_role == Some(role) || sub_cluster == Some(role)
+    })
+}
+
+fn is_role_aware_policy(policy: ReplicaTaskPlacementPolicyKind) -> bool {
+    matches!(
+        policy,
+        ReplicaTaskPlacementPolicyKind::WeightedRoleAware
+            | ReplicaTaskPlacementPolicyKind::BoundedRoleQueueAware
+            | ReplicaTaskPlacementPolicyKind::PressureRoleQueueAware
+    )
+}
+
+fn filter_remote_only_candidates(candidates: &[PlacementCandidate]) -> Vec<PlacementCandidate> {
+    candidates
+        .iter()
+        .filter(|candidate| candidate.is_remote_only_role)
+        .cloned()
+        .collect()
+}
+
+fn collect_remote_candidates(
+    view: &MasterKvRouterView,
+    source_node_id: &NodeID,
+    excluded_nodes: &HashSet<NodeID>,
+    preferred_sub_cluster: Option<&str>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    let members_by_id: HashMap<String, ClusterMember> = view
+        .cluster_manager()
+        .get_client_members()
+        .into_iter()
+        .map(|member| (member.id.clone(), member))
+        .collect();
+
+    let mut candidates = Vec::new();
+    for (node_id, allocator) in view.master_seg_manager().get_all_segments_allocator() {
+        if node_id.as_ref() == source_node_id.as_ref() || excluded_nodes.contains(&node_id) {
+            continue;
+        }
+
+        let member = members_by_id.get(node_id.as_ref());
+        let preferred_sub_cluster_match = preferred_sub_cluster
+            .map(|sc| member.and_then(|m| m.sub_cluster.as_deref()) == Some(sc))
+            .unwrap_or(false);
+        if preferred_sub_cluster.is_some() && !preferred_sub_cluster_match {
+            continue;
+        }
+
+        let total = allocator.total_size_bytes();
+        let used = allocator.used_size_bytes();
+        let free = total.saturating_sub(used);
+        let node_key = node_id.as_ref().to_string();
+        let node_write_count = view
+            .master_kv_router()
+            .inner()
+            .put_target_decision_counts
+            .get(&node_key)
+            .map(|entry| entry.value().load(AtomicOrdering::Relaxed))
+            .unwrap_or(0);
+        let requester_target_count = view
+            .master_kv_router()
+            .inner()
+            .put_requester_target_decision_counts
+            .get(&super::RequesterTargetPair::new(
+                source_node_id.as_ref(),
+                node_id.as_ref(),
+            ))
+            .map(|entry| entry.value().load(AtomicOrdering::Relaxed))
+            .unwrap_or(0);
+
+        candidates.push(PlacementCandidate {
+            node_id,
+            allocator,
+            total_bytes: total,
+            free_bytes: free,
+            used_bytes: used,
+            node_write_count,
+            requester_target_count,
+            is_remote_only_role: member_matches_roles(member, &config.remote_only_node_roles),
+            is_active_role: member_matches_roles(member, &config.active_node_roles),
+            preferred_sub_cluster_match,
+        });
+    }
+    candidates
+}
+
+fn choose_candidate_pool(
+    view: &MasterKvRouterView,
+    source_node_id: &NodeID,
+    excluded_nodes: &HashSet<NodeID>,
+    preferred_sub_cluster: Option<&str>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    let global = collect_remote_candidates(view, source_node_id, excluded_nodes, None, config);
+    let global_remote_only = filter_remote_only_candidates(&global);
+    let Some(sc) = preferred_sub_cluster else {
+        if config.restrict_to_remote_only_node_roles {
+            return global_remote_only;
+        }
+        return global;
+    };
+
+    let preferred =
+        collect_remote_candidates(view, source_node_id, excluded_nodes, Some(sc), config);
+    let preferred_remote_only = filter_remote_only_candidates(&preferred);
+    if config.restrict_to_remote_only_node_roles {
+        if !preferred_remote_only.is_empty() {
+            return preferred_remote_only;
+        }
+        if !global_remote_only.is_empty() {
+            tracing::warn!(
+                "preferred_sub_cluster has no eligible remote-only kvclients; using global remote-only candidates: source_node_id={} sub_cluster={:?} remote_only_node_roles={:?}",
+                source_node_id,
+                sc,
+                config.remote_only_node_roles
+            );
+            return global_remote_only;
+        }
+        tracing::warn!(
+            "strict remote-only placement has no eligible candidates: source_node_id={} sub_cluster={:?} remote_only_node_roles={:?}",
+            source_node_id,
+            sc,
+            config.remote_only_node_roles
+        );
+        return Vec::new();
+    }
+
+    if preferred.is_empty() {
+        tracing::warn!(
+            "preferred_sub_cluster has no eligible remote kvclients: source_node_id={} sub_cluster={:?}",
+            source_node_id,
+            sc
+        );
+        return global;
+    }
+
+    if is_role_aware_policy(config.policy)
+        && !preferred
+            .iter()
+            .any(|candidate| candidate.is_remote_only_role)
+        && global.iter().any(|candidate| candidate.is_remote_only_role)
+    {
+        return global;
+    }
+
+    preferred
+}
+
+fn sort_by_queue_score(candidates: &mut [PlacementCandidate]) {
+    candidates.sort_by(|a, b| {
+        a.queue_score()
+            .total_cmp(&b.queue_score())
+            .then_with(|| {
+                b.preferred_sub_cluster_match
+                    .cmp(&a.preferred_sub_cluster_match)
+            })
+            .then_with(|| a.node_id.as_ref().cmp(b.node_id.as_ref()))
+            .then_with(|| {
+                a.allocator
+                    .seg_device_id
+                    .as_str()
+                    .cmp(b.allocator.seg_device_id.as_str())
+            })
+    });
+}
+
+fn remote_only_first(candidates: Vec<PlacementCandidate>) -> Vec<PlacementCandidate> {
+    let has_remote_only = candidates
+        .iter()
+        .any(|candidate| candidate.is_remote_only_role);
+    if !has_remote_only {
+        return candidates;
+    }
+    candidates
+        .into_iter()
+        .filter(|candidate| candidate.is_remote_only_role)
+        .collect()
+}
+
+fn order_queue_aware(mut candidates: Vec<PlacementCandidate>) -> Vec<PlacementCandidate> {
+    sort_by_queue_score(&mut candidates);
+    candidates
+}
+
+fn order_weighted_role_aware(
+    candidates: Vec<PlacementCandidate>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    let mut candidates = remote_only_first(candidates);
+    candidates.sort_by(|a, b| {
+        let a_role_weight = if a.is_remote_only_role {
+            config.remote_only_shard_weight
+        } else {
+            1.0
+        };
+        let b_role_weight = if b.is_remote_only_role {
+            config.remote_only_shard_weight
+        } else {
+            1.0
+        };
+        (a.queue_score() / a_role_weight)
+            .total_cmp(&(b.queue_score() / b_role_weight))
+            .then_with(|| b.is_remote_only_role.cmp(&a.is_remote_only_role))
+            .then_with(|| {
+                b.preferred_sub_cluster_match
+                    .cmp(&a.preferred_sub_cluster_match)
+            })
+            .then_with(|| a.node_id.as_ref().cmp(b.node_id.as_ref()))
+            .then_with(|| {
+                a.allocator
+                    .seg_device_id
+                    .as_str()
+                    .cmp(b.allocator.seg_device_id.as_str())
+            })
+    });
+    candidates
+}
+
+fn order_bounded_role_queue_aware(
+    candidates: Vec<PlacementCandidate>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    let Some(best_wait) = candidates
+        .iter()
+        .map(|candidate| candidate.queue_wait_ms())
+        .min_by(|a, b| a.total_cmp(b))
+    else {
+        return candidates;
+    };
+    let max_wait = best_wait + config.role_queue_window_ms;
+    let mut eligible: Vec<PlacementCandidate> = candidates
+        .into_iter()
+        .filter(|candidate| candidate.queue_wait_ms() <= max_wait)
+        .collect();
+    eligible = remote_only_first(eligible);
+    eligible.sort_by(|a, b| {
+        let a_weight = if a.is_remote_only_role {
+            config.remote_only_shard_weight
+        } else {
+            1.0
+        } - ((a.used_bytes as f64 / 4096.0) * 1e-6);
+        let b_weight = if b.is_remote_only_role {
+            config.remote_only_shard_weight
+        } else {
+            1.0
+        } - ((b.used_bytes as f64 / 4096.0) * 1e-6);
+        b_weight
+            .total_cmp(&a_weight)
+            .then_with(|| a.queue_score().total_cmp(&b.queue_score()))
+            .then_with(|| {
+                b.preferred_sub_cluster_match
+                    .cmp(&a.preferred_sub_cluster_match)
+            })
+            .then_with(|| a.node_id.as_ref().cmp(b.node_id.as_ref()))
+            .then_with(|| {
+                a.allocator
+                    .seg_device_id
+                    .as_str()
+                    .cmp(b.allocator.seg_device_id.as_str())
+            })
+    });
+    eligible
+}
+
+fn average_queue_wait<'a>(candidates: impl Iterator<Item = &'a PlacementCandidate>) -> Option<f64> {
+    let mut sum = 0.0;
+    let mut count = 0usize;
+    for candidate in candidates {
+        sum += candidate.queue_wait_ms();
+        count += 1;
+    }
+    (count > 0).then_some(sum / count as f64)
+}
+
+fn filter_remote_imbalance(
+    candidates: Vec<PlacementCandidate>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    let Some(min_count) = candidates
+        .iter()
+        .map(|candidate| candidate.node_write_count)
+        .min()
+    else {
+        return candidates;
+    };
+    let max_next = (min_count as f64 + 1.0) * config.role_max_shard_imbalance;
+    let filtered: Vec<PlacementCandidate> = candidates
+        .iter()
+        .filter(|candidate| candidate.node_write_count as f64 + 1.0 <= max_next)
+        .cloned()
+        .collect();
+    if filtered.is_empty() {
+        candidates
+    } else {
+        filtered
+    }
+}
+
+fn order_pressure_role_queue_aware(
+    candidates: Vec<PlacementCandidate>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    let remote_candidates: Vec<PlacementCandidate> = candidates
+        .iter()
+        .filter(|candidate| candidate.is_remote_only_role)
+        .cloned()
+        .collect();
+    if remote_candidates.is_empty() {
+        return order_queue_aware(candidates);
+    }
+
+    let active_wait = average_queue_wait(candidates.iter().filter(|candidate| {
+        candidate.is_active_role || (!candidate.is_remote_only_role && !candidate.is_active_role)
+    }));
+    let remote_wait = average_queue_wait(remote_candidates.iter());
+    if let (Some(active_wait), Some(remote_wait)) = (active_wait, remote_wait) {
+        let gap = active_wait - remote_wait;
+        let fabric_guard_ok =
+            config.role_fabric_guard_ms == 0.0 || gap <= config.role_fabric_guard_ms;
+        if gap >= config.role_pressure_gap_ms && fabric_guard_ok {
+            let mut remote_candidates = filter_remote_imbalance(remote_candidates, config);
+            sort_by_queue_score(&mut remote_candidates);
+            return remote_candidates;
+        }
+    }
+
+    order_queue_aware(candidates)
+}
+
+fn order_remote_candidates(
+    candidates: Vec<PlacementCandidate>,
+    config: &ReplicaTaskPlacementConfig,
+) -> Vec<PlacementCandidate> {
+    match config.policy {
+        ReplicaTaskPlacementPolicyKind::LocalFirst | ReplicaTaskPlacementPolicyKind::Random => {
+            let mut candidates = candidates;
+            candidates.shuffle(&mut rand::thread_rng());
+            candidates
+        }
+        ReplicaTaskPlacementPolicyKind::QueueAware => order_queue_aware(candidates),
+        ReplicaTaskPlacementPolicyKind::WeightedRoleAware => {
+            order_weighted_role_aware(candidates, config)
+        }
+        ReplicaTaskPlacementPolicyKind::BoundedRoleQueueAware => {
+            order_bounded_role_queue_aware(candidates, config)
+        }
+        ReplicaTaskPlacementPolicyKind::PressureRoleQueueAware => {
+            order_pressure_role_queue_aware(candidates, config)
+        }
+    }
+}
+
+fn try_allocate_candidates(
+    candidates: Vec<PlacementCandidate>,
+    len: u64,
+    last_no_space_ctx: &mut Option<NoSpaceCtx>,
+) -> Option<(NodeID, Arc<OneSegAllocator>, Allocation)> {
+    for candidate in candidates {
+        *last_no_space_ctx = Some((
+            candidate.node_id.as_ref().to_string(),
+            candidate.allocator.seg_device_id.clone(),
+            candidate.total_bytes,
+            candidate.free_bytes,
+        ));
+        if let Ok(allocation) = candidate.allocator.allocate(len) {
+            return Some((candidate.node_id, candidate.allocator, allocation));
+        }
+    }
+    None
+}
+
+fn choose_random_remote_target_with_allocator(
+    view: &MasterKvRouterView,
+    source_node_id: &NodeID,
+    excluded_nodes: &HashSet<NodeID>,
+    preferred_sub_cluster: Option<&str>,
+    len: u64,
+) -> Result<(NodeID, Arc<OneSegAllocator>, Allocation), KvError> {
+    let seg_manager = view.master_seg_manager();
+    let mut last_no_space_ctx: Option<NoSpaceCtx> = None;
+
+    if let Some(sc) = preferred_sub_cluster {
+        let mut preferred_nodes: Vec<NodeID> = view
+            .cluster_manager()
+            .get_client_members()
+            .into_iter()
+            .filter_map(|m| (m.sub_cluster.as_deref() == Some(sc)).then_some(m.id.into()))
+            .collect();
+        preferred_nodes.retain(|node_id| {
+            node_id.as_ref() != source_node_id.as_ref() && !excluded_nodes.contains(node_id)
+        });
+        preferred_nodes.shuffle(&mut rand::thread_rng());
+        for node_id in preferred_nodes {
+            let node_allocators = seg_manager.get_node_allocators(&node_id);
+            let Some(allocator) = node_allocators.choose(&mut rand::thread_rng()).cloned() else {
+                continue;
+            };
+            let total = allocator.total_size_bytes();
+            let used = allocator.used_size_bytes();
+            let free = total.saturating_sub(used);
+            last_no_space_ctx = Some((
+                node_id.as_ref().to_string(),
+                allocator.seg_device_id.clone(),
+                total,
+                free,
+            ));
+            if let Ok(allocation) = allocator.allocate(len) {
+                return Ok((node_id, allocator, allocation));
+            }
+        }
+    }
+
+    let all_segs = seg_manager.get_all_segments_allocator();
+    let mut candidates: Vec<(NodeID, Arc<OneSegAllocator>)> = all_segs
+        .into_iter()
+        .filter_map(|(node_id, allocator)| {
+            if node_id.as_ref() == source_node_id.as_ref() || excluded_nodes.contains(&node_id) {
+                return None;
+            }
+            Some((node_id, allocator))
+        })
+        .collect();
+    candidates.shuffle(&mut rand::thread_rng());
+    for (node_id, allocator) in candidates {
+        let total = allocator.total_size_bytes();
+        let used = allocator.used_size_bytes();
+        let free = total.saturating_sub(used);
+        last_no_space_ctx = Some((
+            node_id.as_ref().to_string(),
+            allocator.seg_device_id.clone(),
+            total,
+            free,
+        ));
+        if let Ok(allocation) = allocator.allocate(len) {
+            return Ok((node_id, allocator, allocation));
+        }
+    }
+
+    Err(no_space_error(last_no_space_ctx))
+}
+
+fn choose_random_remote_target(
+    view: &MasterKvRouterView,
+    source_node_id: &NodeID,
+    excluded_nodes: &HashSet<NodeID>,
+    preferred_sub_cluster: Option<&str>,
+    len: u64,
+) -> Result<(NodeID, Allocation), KvError> {
+    choose_random_remote_target_with_allocator(
+        view,
+        source_node_id,
+        excluded_nodes,
+        preferred_sub_cluster,
+        len,
+    )
+    .map(|(node_id, _allocator, allocation)| (node_id, allocation))
+}
+
+pub struct ReplicaTaskPlacementPolicy {
+    config: ReplicaTaskPlacementConfig,
+}
+
+impl ReplicaTaskPlacementPolicy {
+    pub fn new(config: ReplicaTaskPlacementConfig) -> Self {
+        Self { config }
+    }
+
+    fn select_remote_target_with_allocator(
+        &self,
+        view: &MasterKvRouterView,
+        source_node_id: &NodeID,
+        excluded_nodes: &HashSet<NodeID>,
+        preferred_sub_cluster: Option<&str>,
+        len: u64,
+    ) -> Result<(NodeID, Arc<OneSegAllocator>, Allocation), KvError> {
+        let mut last_no_space_ctx: Option<NoSpaceCtx> = None;
+        let candidates = choose_candidate_pool(
+            view,
+            source_node_id,
+            excluded_nodes,
+            preferred_sub_cluster,
+            &self.config,
+        );
+        let ordered = order_remote_candidates(candidates, &self.config);
+        if let Some(selected) = try_allocate_candidates(ordered, len, &mut last_no_space_ctx) {
+            return Ok(selected);
+        }
+
+        if preferred_sub_cluster.is_some() {
+            let global_candidates =
+                choose_candidate_pool(view, source_node_id, excluded_nodes, None, &self.config);
+            let ordered = order_remote_candidates(global_candidates, &self.config);
+            if let Some(selected) = try_allocate_candidates(ordered, len, &mut last_no_space_ctx) {
+                return Ok(selected);
+            }
+        }
+
+        Err(no_space_error(last_no_space_ctx))
+    }
+}
+
+#[async_trait]
+impl PlacementPolicy for ReplicaTaskPlacementPolicy {
+    async fn select_put_target(
+        &self,
+        view: &MasterKvRouterView,
+        req_node_id: &NodeID,
+        preferred_sub_cluster: Option<&str>,
+        len: u64,
+    ) -> Result<PutPlacementTarget, KvError> {
+        self.select_remote_target_with_allocator(
+            view,
+            req_node_id,
+            &HashSet::new(),
+            preferred_sub_cluster,
+            len,
+        )
+        .map(
+            |(node_id, _allocator, allocation)| PutPlacementTarget::Remote {
+                node_id,
+                allocation,
+            },
+        )
+    }
+
+    fn select_remote_target(
+        &self,
+        view: &MasterKvRouterView,
+        source_node_id: &NodeID,
+        excluded_nodes: &HashSet<NodeID>,
+        preferred_sub_cluster: Option<&str>,
+        len: u64,
+    ) -> Result<(NodeID, Allocation), KvError> {
+        self.select_remote_target_with_allocator(
+            view,
+            source_node_id,
+            excluded_nodes,
+            preferred_sub_cluster,
+            len,
+        )
+        .map(|(node_id, _allocator, allocation)| (node_id, allocation))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::{ReplicaTaskPlacementConfig, ReplicaTaskPlacementPolicyKind};
+    use crate::master_seg_manager::msg_pack::SegmentDeviceDescription;
+
+    fn test_allocator(id: &str) -> Arc<OneSegAllocator> {
+        Arc::new(
+            OneSegAllocator::new(
+                id.to_string(),
+                SegmentDeviceDescription::Cpu,
+                0,
+                1024 * 1024,
+            )
+            .unwrap(),
+        )
+    }
+
+    fn candidate(
+        node_id: &str,
+        is_remote_only_role: bool,
+        node_write_count: u64,
+    ) -> PlacementCandidate {
+        PlacementCandidate {
+            node_id: node_id.to_string().into(),
+            allocator: test_allocator(node_id),
+            total_bytes: 1024 * 1024,
+            free_bytes: 1024 * 1024,
+            used_bytes: 0,
+            node_write_count,
+            requester_target_count: 0,
+            is_remote_only_role,
+            is_active_role: !is_remote_only_role,
+            preferred_sub_cluster_match: false,
+        }
+    }
+
+    #[test]
+    fn bounded_role_queue_aware_prefers_remote_only_within_window() {
+        let mut config = ReplicaTaskPlacementConfig::default();
+        config.policy = ReplicaTaskPlacementPolicyKind::BoundedRoleQueueAware;
+        config.role_queue_window_ms = 2.0;
+        config.remote_only_shard_weight = 1.02;
+
+        let ordered = order_bounded_role_queue_aware(
+            vec![
+                candidate("active-a", false, 0),
+                candidate("remote-a", true, 1),
+            ],
+            &config,
+        );
+        assert_eq!(ordered[0].node_id.as_ref(), "remote-a");
+    }
+
+    #[test]
+    fn strict_remote_only_candidates_filter_out_active_nodes() {
+        let filtered = filter_remote_only_candidates(&[
+            candidate("prefill-a", false, 0),
+            candidate("decode-a", false, 0),
+            candidate("remote-cache-a", true, 10),
+        ]);
+
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].node_id.as_ref(), "remote-cache-a");
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index e8598e8..6849105 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -1,5 +1,9 @@
 use super::NodeValueReplicaDesc;
 use super::{
+    CommittedSlotReplica, InflightPutAllocation, InflightPutCommitInfo, InflightPutInfo,
+    InflightReplicaTaskInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo,
+    MasterKvRouterView, OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode,
+    ReservedCapacityReason,
     msg_pack::{
         BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutDoneItemResp, BatchPutDoneReq,
         BatchPutDoneResp, BatchPutRevokeItemResp, BatchPutRevokeReq, BatchPutRevokeResp,
@@ -11,22 +15,19 @@ use super::{
         ReserveLocalGrantResp,
     },
     placement::PutPlacementTarget,
-    CommittedSlotReplica, InflightPutAllocation, InflightPutAppendInfo, InflightPutCommitInfo,
-    InflightPutInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo, MasterKvRouterView,
-    OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
 };
-use crate::master_kv_router::delete::DeleteKeyInfo;
 use crate::master_kv_router::OneKvNodesRoutes;
+use crate::master_kv_router::delete::DeleteKeyInfo;
 use crate::memholder::MemholderManagerTrait;
 use crate::{
+    OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
     cluster_manager::{
-        NodeID, META_KEY_LOCAL_IPC_ROOT, META_KEY_SHARED_STORAGE_NODE_ID,
-        META_KEY_SHARED_STORAGE_NODE_START_TIME,
+        META_KEY_LOCAL_IPC_ROOT, META_KEY_SHARED_STORAGE_NODE_ID,
+        META_KEY_SHARED_STORAGE_NODE_START_TIME, NodeID,
     },
-    master_seg_manager::{one_seg_allocator::Allocation, MasterSegManagerAccessTrait},
+    master_seg_manager::{MasterSegManagerAccessTrait, one_seg_allocator::Allocation},
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::{self, kv},
-    OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
 };
 use chrono::Utc;
 use limit_thirdparty::tokio;
@@ -35,7 +36,7 @@ use parking_lot::RwLock;
 use rand::seq::SliceRandom;
 use std::{
     collections::{HashMap, HashSet},
-    sync::{atomic::AtomicU32, Arc},
+    sync::{Arc, atomic::AtomicU32},
 };
 
 pub type PutIDForAKey = (u64, u32);
@@ -268,96 +269,6 @@ fn append_current_route_replica_if_matching(
     true
 }
 
-fn choose_remote_append_target(
-    view: &MasterKvRouterView,
-    source_node_id: &NodeID,
-    excluded_nodes: &HashSet<NodeID>,
-    preferred_sub_cluster: Option<&str>,
-    len: u64,
-) -> msg_and_error::KvResult<(NodeID, Allocation)> {
-    let seg_manager = view.master_seg_manager();
-    let mut last_no_space_ctx: Option<(String, String, u64, u64)> = None;
-
-    if let Some(sc) = preferred_sub_cluster {
-        let mut preferred_nodes: Vec<NodeID> = view
-            .cluster_manager()
-            .get_client_members()
-            .into_iter()
-            .filter_map(|m| (m.sub_cluster.as_deref() == Some(sc)).then_some(m.id.into()))
-            .collect();
-        preferred_nodes.retain(|node_id| {
-            node_id.as_ref() != source_node_id.as_ref() && !excluded_nodes.contains(node_id)
-        });
-        preferred_nodes.shuffle(&mut rand::thread_rng());
-        for node_id in preferred_nodes {
-            let node_allocators = seg_manager.get_node_allocators(&node_id);
-            let Some(allocator) = node_allocators.choose(&mut rand::thread_rng()).cloned() else {
-                continue;
-            };
-            let total = allocator.total_size_bytes();
-            let used = allocator.used_size_bytes();
-            let free = total.saturating_sub(used);
-            last_no_space_ctx = Some((
-                node_id.as_ref().to_string(),
-                allocator.seg_device_id.clone(),
-                total,
-                free,
-            ));
-            if let Ok(allocation) = allocator.allocate(len) {
-                return Ok((node_id, allocation));
-            }
-        }
-    }
-
-    let all_segs = seg_manager.get_all_segments_allocator();
-    let mut candidates: Vec<(
-        NodeID,
-        Arc<crate::master_seg_manager::one_seg_allocator::OneSegAllocator>,
-    )> = all_segs
-        .into_iter()
-        .filter_map(|(node_id, allocator)| {
-            let node_id: NodeID = node_id.into();
-            if node_id.as_ref() == source_node_id.as_ref() || excluded_nodes.contains(&node_id) {
-                return None;
-            }
-            Some((node_id, allocator))
-        })
-        .collect();
-    candidates.shuffle(&mut rand::thread_rng());
-    for (node_id, allocator) in candidates {
-        let total = allocator.total_size_bytes();
-        let used = allocator.used_size_bytes();
-        let free = total.saturating_sub(used);
-        last_no_space_ctx = Some((
-            node_id.as_ref().to_string(),
-            allocator.seg_device_id.clone(),
-            total,
-            free,
-        ));
-        if let Ok(allocation) = allocator.allocate(len) {
-            return Ok((node_id, allocation));
-        }
-    }
-
-    Err(
-        if let Some((node, segment, total_capacity, free_capacity)) = last_no_space_ctx {
-            msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
-                node,
-                segment,
-                total_capacity,
-                free_capacity,
-            })
-        } else {
-            msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
-                node: "unknown".to_string(),
-                segment: "unknown".to_string(),
-                total_capacity: 0,
-                free_capacity: 0,
-            })
-        },
-    )
-}
-
 fn allocate_from_node_local_segment(
     view: &MasterKvRouterView,
     node_id: &NodeID,
@@ -404,23 +315,47 @@ fn allocate_from_node_local_segment(
     ))
 }
 
-fn reserve_write_back_remote_append(
+fn reserve_replica_task(
     view: &MasterKvRouterView,
     key: &str,
     put_id: PutIDForAKey,
     source_node_id: &NodeID,
     preferred_sub_cluster: Option<&str>,
     len: u64,
-) -> msg_and_error::KvResult<InflightPutAppendInfo> {
-    let (target_node_id, target_allocation) = choose_remote_append_target(
+) -> msg_and_error::KvResult<InflightReplicaTaskInfo> {
+    reserve_replica_task_excluding(
         view,
+        key,
+        put_id,
         source_node_id,
-        &HashSet::new(),
         preferred_sub_cluster,
         len,
-    )?;
+        &HashSet::new(),
+    )
+}
+
+fn reserve_replica_task_excluding(
+    view: &MasterKvRouterView,
+    key: &str,
+    put_id: PutIDForAKey,
+    source_node_id: &NodeID,
+    preferred_sub_cluster: Option<&str>,
+    len: u64,
+    excluded_nodes: &HashSet<NodeID>,
+) -> msg_and_error::KvResult<InflightReplicaTaskInfo> {
+    let (target_node_id, target_allocation) = view
+        .master_kv_router()
+        .inner()
+        .policy
+        .select_remote_target(
+            view,
+            source_node_id,
+            excluded_nodes,
+            preferred_sub_cluster,
+            len,
+        )?;
     tracing::debug!(
-        "write-back remote append reserved: key={} put_id=({},{}) source_node_id={} target_node_id={} preferred_sub_cluster={:?} len={}",
+        "replica task reserved: key={} put_id=({},{}) source_node_id={} target_node_id={} preferred_sub_cluster={:?} len={}",
         key,
         put_id.0,
         put_id.1,
@@ -429,7 +364,7 @@ fn reserve_write_back_remote_append(
         preferred_sub_cluster,
         len
     );
-    Ok(InflightPutAppendInfo {
+    Ok(InflightReplicaTaskInfo {
         node_id: target_node_id,
         key: key.to_string(),
         put_id,
@@ -437,44 +372,132 @@ fn reserve_write_back_remote_append(
     })
 }
 
-fn try_reserve_write_back_remote_append(
-    view: &MasterKvRouterView,
-    key: &str,
+async fn publish_completed_put_route(
+    view: MasterKvRouterView,
+    key: String,
     put_id: PutIDForAKey,
-    source_node_id: &NodeID,
-    preferred_sub_cluster: Option<&str>,
-    len: u64,
-) -> msg_and_error::KvResult<Option<InflightPutAppendInfo>> {
-    match reserve_write_back_remote_append(
-        view,
-        key,
-        put_id,
-        source_node_id,
-        preferred_sub_cluster,
-        len,
-    ) {
-        Ok(reserved) => Ok(Some(reserved)),
-        Err(msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
-            node,
-            segment,
-            total_capacity,
-            free_capacity,
-        })) => {
-            tracing::info!(
-                "write-back remote append not scheduled; fallback to local-only commit: key={} put_id=({},{}) source_node_id={} preferred_sub_cluster={:?} node={} segment={} total_capacity={} free_capacity={}",
-                key,
-                put_id.0,
-                put_id.1,
-                source_node_id,
-                preferred_sub_cluster,
-                node,
-                segment,
-                total_capacity,
-                free_capacity
-            );
-            Ok(None)
+    lease_id_opt: Option<u64>,
+    node_id: NodeID,
+    completed_info: KvRouteInfo,
+    target_cap_bytes: u64,
+    local_cache_holder_id: Option<u64>,
+) -> MsgPack<PutDoneResp> {
+    let saturated_weight_u32 = if target_cap_bytes > u32::MAX as u64 {
+        tracing::warn!(
+            "moka weight saturation: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
+            key,
+            put_id.0,
+            put_id.1,
+            target_cap_bytes
+        );
+        u32::MAX
+    } else {
+        target_cap_bytes as u32
+    };
+
+    let mut old_one_kv_routes: Option<Arc<OneKvNodesRoutes>> = None;
+    let mut inserted = false;
+    {
+        let mut one_kv_routes = view
+            .master_kv_router()
+            .inner()
+            .kv_routes
+            .entry(key.clone())
+            .or_insert_with(|| {
+                inserted = true;
+                Arc::new(OneKvNodesRoutes {
+                    put_id,
+                    lease_id: lease_id_opt,
+                    nodes_replicas: RwLock::new(HashMap::new()),
+                    get_durable_slots_used: AtomicU32::new(0),
+                })
+            });
+        if !inserted {
+            old_one_kv_routes = Some(one_kv_routes.clone());
+            *one_kv_routes = Arc::new(OneKvNodesRoutes {
+                put_id,
+                lease_id: lease_id_opt,
+                nodes_replicas: RwLock::new(HashMap::new()),
+                get_durable_slots_used: AtomicU32::new(0),
+            });
         }
-        Err(err) => Err(err),
+        one_kv_routes
+            .nodes_replicas
+            .write()
+            .insert(node_id.clone(), completed_info);
+    }
+
+    if let Some(old) = old_one_kv_routes {
+        if let Err(err) = view
+            .master_kv_router()
+            .inner()
+            .delete_broadcast
+            .sender()
+            .send(DeleteKeyInfo::Key {
+                key: key.clone(),
+                nodes_kv_route_info: old,
+            })
+            .await
+        {
+            tracing::warn!("Failed to send delete broadcast: {}", err);
+        }
+    }
+
+    {
+        let view_task = view.clone();
+        let key_for_spawn = key.clone();
+        let node_for_spawn = node_id.clone();
+        let do_prefix_index_update = view.master_kv_router().prefix_index_enabled();
+        let do_cache_insert =
+            lease_id_opt.is_none() && view.master_kv_router().replica_cache_enabled();
+        let cap_bytes_u32 = saturated_weight_u32;
+        view.spawn("post_put_done_maintenance", async move {
+            if do_prefix_index_update {
+                let inner = view_task.master_kv_router().inner();
+                let mut tree = inner.prefix_index.write().await;
+                tree.insert(&key_for_spawn);
+            }
+
+            if do_cache_insert {
+                let cache = view_task
+                    .master_kv_router()
+                    .get_node_cache_controller(&node_for_spawn);
+                if let Some(cache) = cache {
+                    let desc = NodeValueReplicaDesc {
+                        weight_bytes: cap_bytes_u32,
+                        put_id,
+                    };
+                    tracing::debug!("Inserting key: {:?} into cache", key_for_spawn);
+                    cache.insert(key_for_spawn.clone(), desc);
+                    tracing::debug!(
+                        "Inserted key: {:?} into cache, current cache size: {}",
+                        key_for_spawn,
+                        cache.weighted_size()
+                    );
+                } else {
+                    tracing::warn!(
+                        "No cache controller found for node: {}, node is not ready",
+                        node_for_spawn
+                    );
+                }
+            }
+        });
+    }
+
+    tracing::info!(
+        "Completed put operation with put_id: {:?}, key: {:?}",
+        put_id,
+        key
+    );
+
+    MsgPack {
+        serialize_part: PutDoneResp {
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+            local_cache_holder_id,
+        },
+        raw_bytes: Vec::new(),
     }
 }
 
@@ -550,12 +573,12 @@ pub async fn handle_put_start(
     let finalize = |commit_node_id: NodeID,
                     response_node_id: NodeID,
                     inflight_alloc: InflightPutAllocation,
-                    remote_append: Option<InflightPutAppendInfo>,
                     src_addr: u64,
                     target_addr: u64,
                     src_base_addr: u64,
                     target_base_addr: u64,
-                    len: u64| {
+                    len: u64,
+                    replica_target: Option<InflightReplicaTaskInfo>| {
         let info = InflightPutInfo {
             key: key.clone(),
             len,
@@ -563,8 +586,8 @@ pub async fn handle_put_start(
             commit_info: InflightPutCommitInfo {
                 node_id: commit_node_id,
                 src_target_allocation: Arc::new(Mutex::new(Some(inflight_alloc))),
+                replica_target: replica_target.clone(),
             },
-            remote_append,
         };
 
         let view_task = view.clone();
@@ -577,6 +600,19 @@ pub async fn handle_put_start(
                 .insert(inflight_put_key, info)
                 .await;
 
+            let response_replica_target = replica_target.as_ref().map(|target| {
+                let target_allocation_guard = target.target_allocation.lock();
+                let target_allocation = target_allocation_guard.as_ref().expect(
+                    "replica target allocation must exist while building put_start response",
+                );
+                super::msg_pack::PutReplicaTarget {
+                    node_id: target.node_id.clone().into(),
+                    target_addr: target_allocation.base_addr() + target_allocation.addr(),
+                    target_base_addr: target_allocation.base_addr(),
+                    len: target_allocation.size(),
+                }
+            });
+
             let resp = PutStartResp {
                 put_id,
                 node_id: response_node_id.into(),
@@ -588,6 +624,7 @@ pub async fn handle_put_start(
                 error_code: msg_and_error::OK,
                 error_json: String::new(),
                 server_process_us: 0,
+                replica_target: response_replica_target,
             };
 
             (
@@ -600,22 +637,9 @@ pub async fn handle_put_start(
         }
     };
 
-    let put_target = if req.serialize_part.write_through {
-        view.master_kv_router()
-            .inner()
-            .policy
-            .select_put_target(
-                &view,
-                &source_node_id,
-                req.serialize_part.preferred_sub_cluster.as_deref(),
-                req.serialize_part.len,
-            )
-            .await
-    } else {
-        Ok(PutPlacementTarget::Local {
-            node_id: source_node_id.clone(),
-        })
-    };
+    let put_target = Ok(PutPlacementTarget::Local {
+        node_id: source_node_id.clone(),
+    });
 
     match put_target {
         Ok(PutPlacementTarget::Local { node_id }) => {
@@ -653,10 +677,8 @@ pub async fn handle_put_start(
             let src = src_allocation
                 .take()
                 .expect("src_allocation must exist when finalizing local put");
-            let remote_append = if req.serialize_part.write_through {
-                None
-            } else {
-                match try_reserve_write_back_remote_append(
+            let replica_target = if req.serialize_part.make_replica_task {
+                match reserve_replica_task(
                     &view,
                     &key,
                     put_id,
@@ -664,47 +686,57 @@ pub async fn handle_put_start(
                     req.serialize_part.preferred_sub_cluster.as_deref(),
                     req.serialize_part.len,
                 ) {
-                    Ok(reserved) => reserved,
+                    Ok(reservation) => {
+                        view.master_kv_router()
+                            .record_replica_task_target(reservation.node_id.as_ref());
+                        Some(reservation)
+                    }
+                    Err(msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
+                        node,
+                        segment,
+                        total_capacity,
+                        free_capacity,
+                    })) => {
+                        tracing::info!(
+                            "replica task not pre-reserved; local-only commit remains valid: key={} put_id=({},{}) source_node_id={} preferred_sub_cluster={:?} node={} segment={} total_capacity={} free_capacity={}",
+                            key,
+                            put_id.0,
+                            put_id.1,
+                            source_node_id,
+                            req.serialize_part.preferred_sub_cluster,
+                            node,
+                            segment,
+                            total_capacity,
+                            free_capacity
+                        );
+                        None
+                    }
                     Err(err) => {
-                        let resp: PutStartResp =
-                            crate::rpcresp_kvresult_convert::FromError::from_error(&err);
-                        return (
-                            (0, 0),
-                            MsgPack {
-                                serialize_part: resp,
-                                raw_bytes: Vec::new(),
-                            },
+                        tracing::warn!(
+                            "replica task pre-reserve failed; local-only commit remains valid: key={} put_id=({},{}) source_node_id={} preferred_sub_cluster={:?} err={}",
+                            key,
+                            put_id.0,
+                            put_id.1,
+                            source_node_id,
+                            req.serialize_part.preferred_sub_cluster,
+                            err
                         );
+                        None
                     }
                 }
+            } else {
+                None
             };
-            let (response_node_id, response_target_addr, response_target_base_addr, response_len) =
-                if let Some(remote_append) = remote_append.as_ref() {
-                    let target_allocation_guard = remote_append.target_allocation.lock();
-                    let target_allocation = target_allocation_guard
-                        .as_ref()
-                        .expect("reserved remote append allocation must exist during put_start");
-                    let target_base = target_allocation.base_addr();
-                    let target_addr = target_base + target_allocation.addr();
-                    (
-                        remote_append.node_id.clone(),
-                        target_addr,
-                        target_base,
-                        target_allocation.size(),
-                    )
-                } else {
-                    (node_id.clone(), abs, src_base, allocation_size)
-                };
             let fut = finalize(
+                node_id.clone(),
                 node_id,
-                response_node_id,
                 InflightPutAllocation::Local(src),
-                remote_append,
                 abs,
-                response_target_addr,
+                abs,
+                src_base,
                 src_base,
-                response_target_base_addr,
-                response_len,
+                allocation_size,
+                replica_target,
             );
             let result = fut.await;
             key_reservation.disarm();
@@ -754,12 +786,12 @@ pub async fn handle_put_start(
                     src,
                     target: target_allocation,
                 },
-                None,
                 src_base + src_offset,
                 target_base + target_offset,
                 src_base,
                 target_base,
                 allocation_size,
+                None,
             );
             let result = fut.await;
             key_reservation.disarm();
@@ -1057,6 +1089,7 @@ pub async fn handle_put_revoke(
 pub async fn handle_put_done(
     view: MasterKvRouterView,
     req: MsgPack<PutDoneReq>,
+    req_node_id: NodeID,
 ) -> MsgPack<PutDoneResp> {
     tracing::debug!("Handling PutDoneReq: {:?}", req.serialize_part);
 
@@ -1067,10 +1100,7 @@ pub async fn handle_put_done(
 
     // Remove from inflight_puts and store in completed_puts
     if let Some(InflightPutInfo {
-        key,
-        commit_info,
-        remote_append,
-        ..
+        key, commit_info, ..
     }) = view
         .master_kv_router()
         .inner()
@@ -1453,17 +1483,17 @@ pub async fn handle_put_done(
                 .insert(node_id.clone(), completed_info);
         }
 
-        if let Some(remote_append) = remote_append {
+        if let Some(replica_target) = commit_info.replica_target {
             view.master_kv_router()
                 .inner()
-                .inflight_put_appends
+                .inflight_replica_tasks
                 .insert(
                     (
-                        remote_append.key.clone(),
-                        remote_append.put_id.0,
-                        remote_append.put_id.1,
+                        replica_target.key.clone(),
+                        replica_target.put_id.0,
+                        replica_target.put_id.1,
                     ),
-                    remote_append,
+                    replica_target,
                 )
                 .await;
         }
@@ -1541,6 +1571,104 @@ pub async fn handle_put_done(
             key
         );
     } else {
+        if let Some(slot) = req.serialize_part.committed_slot.clone() {
+            let key = req.serialize_part.key.clone();
+            let node_id = req_node_id;
+            let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "local-first put_done node tomb tag missing: key={} put_id=({},{}) node_id={}",
+                            key, put_id.0, put_id.1, node_id
+                        ),
+                    },
+                );
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            };
+            if tomb_tag.is_tomb() {
+                let err =
+                    msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "local-first put_done node is tomb: key={} put_id=({},{}) node_id={}",
+                            key, put_id.0, put_id.1, node_id
+                        ),
+                    });
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            }
+            if req.serialize_part.publish_local_cache {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "local-first put_done does not support publish_local_cache: key={} put_id=({},{})",
+                            key, put_id.0, put_id.1
+                        ),
+                    },
+                );
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            }
+            let target_cap_bytes = slot.len;
+            if let Some(lease_id) = lease_id_opt {
+                if let Err(e) = view
+                    .master_lease_manager()
+                    .attach_key(lease_id, key.clone(), put_id)
+                    .await
+                {
+                    let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError = e.into();
+                    return MsgPack {
+                        serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                            &kv_err,
+                        ),
+                        raw_bytes: Vec::new(),
+                    };
+                }
+                if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
+                    node_id.as_ref(),
+                    ReservedCapacityReason::LeaseBoundKv,
+                    target_cap_bytes as i64,
+                ) {
+                    let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError = e.into();
+                    return MsgPack {
+                        serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                            &kv_err,
+                        ),
+                        raw_bytes: Vec::new(),
+                    };
+                }
+            }
+            let completed_info = KvRouteInfo {
+                node_id: node_id.clone(),
+                backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                    owner_node_id: node_id.clone(),
+                    grant_id: slot.grant_id,
+                    slot_index: slot.slot_index,
+                    slot_size: slot.slot_size,
+                    addr: slot.addr,
+                    len: slot.len,
+                    base_addr: slot.base_addr,
+                }),
+                tomb_tag,
+            };
+            return publish_completed_put_route(
+                view,
+                key,
+                put_id,
+                lease_id_opt,
+                node_id,
+                completed_info,
+                target_cap_bytes,
+                None,
+            )
+            .await;
+        }
         tracing::warn!(
             "Put operation with put_id {:?} not found for completion",
             put_id
@@ -1580,7 +1708,7 @@ pub async fn handle_batch_put_start(
                     len: item.len,
                     reject_if_inflight_same_key: item.reject_if_inflight_same_key,
                     reject_if_exist_same_key: item.reject_if_exist_same_key,
-                    write_through: item.write_through,
+                    make_replica_task: item.make_replica_task,
                     preferred_sub_cluster: item.preferred_sub_cluster,
                     source_node_id: None,
                 },
@@ -1600,6 +1728,7 @@ pub async fn handle_batch_put_start(
             len: part.len,
             error_code: part.error_code,
             error_json: part.error_json,
+            replica_target: part.replica_target,
         });
     }
     MsgPack {
@@ -1650,6 +1779,7 @@ pub async fn handle_batch_put_revoke(
 pub async fn handle_batch_put_done(
     view: MasterKvRouterView,
     req: MsgPack<BatchPutDoneReq>,
+    req_node_id: NodeID,
 ) -> MsgPack<BatchPutDoneResp> {
     let mut items = Vec::with_capacity(req.serialize_part.items.len());
     for item in req.serialize_part.items {
@@ -1668,6 +1798,7 @@ pub async fn handle_batch_put_done(
                 },
                 raw_bytes: Vec::new(),
             },
+            req_node_id.clone(),
         )
         .await;
         let part = resp.serialize_part;
@@ -1697,18 +1828,21 @@ pub async fn handle_put_append_start(
 ) -> MsgPack<PutAppendStartResp> {
     let key = req.serialize_part.key.clone();
     let put_id = req.serialize_part.put_id;
-    let current_route_still_needs_remote = view
+    let route_snapshot = view
         .master_kv_router()
         .inner()
         .kv_routes
         .get(&key)
-        .map(|route| current_route_needs_remote_replica(&route, &req_node_id, put_id))
+        .map(|route| route.clone());
+    let current_route_still_needs_remote = route_snapshot
+        .as_ref()
+        .map(|route| current_route_needs_remote_replica(route, &req_node_id, put_id))
         .unwrap_or(false);
     if !current_route_still_needs_remote {
         let _ = view
             .master_kv_router()
             .inner()
-            .inflight_put_appends
+            .inflight_replica_tasks
             .remove(&(key.clone(), put_id.0, put_id.1))
             .await;
         return MsgPack {
@@ -1722,31 +1856,91 @@ pub async fn handle_put_append_start(
         };
     }
 
-    let Some(inflight) = view
+    let append_key = (key.clone(), put_id.0, put_id.1);
+    let inflight = if let Some(existing) = view
         .master_kv_router()
         .inner()
-        .inflight_put_appends
-        .get(&(key.clone(), put_id.0, put_id.1))
+        .inflight_replica_tasks
+        .get(&append_key)
         .await
-    else {
-        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
-            detail: format!(
-                "Write-back append reservation missing: key={} put_id=({},{}) requester_node_id={}",
-                key, put_id.0, put_id.1, req_node_id
-            ),
-        });
-        let resp: PutAppendStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
-        return MsgPack {
-            serialize_part: resp,
-            raw_bytes: Vec::new(),
+    {
+        existing
+    } else {
+        let excluded_nodes = route_snapshot
+            .as_ref()
+            .map(|route| {
+                route
+                    .nodes_replicas
+                    .read()
+                    .values()
+                    .filter_map(|replica| {
+                        (!replica.tomb_tag.is_tomb()).then_some(replica.node_id.clone())
+                    })
+                    .collect::<HashSet<_>>()
+            })
+            .unwrap_or_default();
+        let reservation = match reserve_replica_task_excluding(
+            &view,
+            &key,
+            put_id,
+            &req_node_id,
+            req.serialize_part.preferred_sub_cluster.as_deref(),
+            req.serialize_part.len,
+            &excluded_nodes,
+        ) {
+            Ok(reservation) => reservation,
+            Err(msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
+                node,
+                segment,
+                total_capacity,
+                free_capacity,
+            })) => {
+                tracing::info!(
+                    "replica task not scheduled; local-only commit remains valid: key={} put_id=({},{}) source_node_id={} preferred_sub_cluster={:?} node={} segment={} total_capacity={} free_capacity={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    req_node_id,
+                    req.serialize_part.preferred_sub_cluster,
+                    node,
+                    segment,
+                    total_capacity,
+                    free_capacity
+                );
+                return MsgPack {
+                    serialize_part: PutAppendStartResp {
+                        scheduled: false,
+                        error_code: msg_and_error::OK,
+                        error_json: String::new(),
+                        ..Default::default()
+                    },
+                    raw_bytes: Vec::new(),
+                };
+            }
+            Err(err) => {
+                let resp: PutAppendStartResp =
+                    crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+                return MsgPack {
+                    serialize_part: resp,
+                    raw_bytes: Vec::new(),
+                };
+            }
         };
+        view.master_kv_router()
+            .record_replica_task_target(reservation.node_id.as_ref());
+        view.master_kv_router()
+            .inner()
+            .inflight_replica_tasks
+            .insert(append_key.clone(), reservation.clone())
+            .await;
+        reservation
     };
     let (target_base_addr, target_addr, allocation_size) = {
         let target_allocation_guard = inflight.target_allocation.lock();
         let Some(target_allocation): Option<&Allocation> = target_allocation_guard.as_ref() else {
             let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
                 detail: format!(
-                    "Write-back append reservation allocation missing: key={} put_id=({},{}) requester_node_id={}",
+                    "Replica task reservation allocation missing: key={} put_id=({},{}) requester_node_id={}",
                     key, put_id.0, put_id.1, req_node_id
                 ),
             });
@@ -1787,7 +1981,7 @@ pub async fn handle_put_append_revoke(
     let _ = view
         .master_kv_router()
         .inner()
-        .inflight_put_appends
+        .inflight_replica_tasks
         .remove(&(key, put_id.0, put_id.1))
         .await;
     MsgPack {
@@ -1808,7 +2002,7 @@ pub async fn handle_put_append_done(
     let Some(inflight) = view
         .master_kv_router()
         .inner()
-        .inflight_put_appends
+        .inflight_replica_tasks
         .remove(&(key.clone(), put_id.0, put_id.1))
         .await
     else {
@@ -1826,7 +2020,7 @@ pub async fn handle_put_append_done(
     let Some(allocation) = inflight.target_allocation.lock().take() else {
         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
             detail: format!(
-                "Put append target allocation already taken: key={} put_id=({},{})",
+                "Replica task append target allocation already taken: key={} put_id=({},{})",
                 key, put_id.0, put_id.1
             ),
         });
diff --git a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
index 6b84528..5d344c9 100755
--- a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
+++ b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
@@ -49,12 +49,14 @@ async fn test1_lease_expire_removes_keys() {
     tracing::info!("[test1-verify-present-during-ttl] verifying keys exist within TTL window");
     for _ in 0..3 {
         for k in &keys {
-            assert!(client_view
-                .client_kv_api()
-                .inner()
-                .is_exist(k)
-                .await
-                .unwrap());
+            assert!(
+                client_view
+                    .client_kv_api()
+                    .inner()
+                    .is_exist(k)
+                    .await
+                    .unwrap()
+            );
         }
         sleep(Duration::from_millis(500)).await;
     }
@@ -120,12 +122,14 @@ async fn test2_rebind_to_new_lease_preserves_until_new_expire() {
     // After l1 expiry, keys should still exist due to l2
     sleep(Duration::from_secs(3)).await;
     for k in &keys {
-        assert!(client_view
-            .client_kv_api()
-            .inner()
-            .is_exist(k)
-            .await
-            .unwrap());
+        assert!(
+            client_view
+                .client_kv_api()
+                .inner()
+                .is_exist(k)
+                .await
+                .unwrap()
+        );
     }
     tracing::info!(
         "[test2-verify-still-present-after-first-expire] keys still exist after first lease expired, held by second lease"
@@ -192,12 +196,14 @@ async fn test3_keepalive() {
             .await
             .unwrap();
         for k in &keys {
-            assert!(client_view
-                .client_kv_api()
-                .inner()
-                .is_exist(k)
-                .await
-                .unwrap());
+            assert!(
+                client_view
+                    .client_kv_api()
+                    .inner()
+                    .is_exist(k)
+                    .await
+                    .unwrap()
+            );
         }
         if i % 2 == 0 {
             tracing::info!(
@@ -211,12 +217,14 @@ async fn test3_keepalive() {
     // Stop keepalive, wait beyond TTL
     sleep(Duration::from_secs(3)).await;
     for k in &keys {
-        assert!(!client_view
-            .client_kv_api()
-            .inner()
-            .is_exist(k)
-            .await
-            .unwrap());
+        assert!(
+            !client_view
+                .client_kv_api()
+                .inner()
+                .is_exist(k)
+                .await
+                .unwrap()
+        );
     }
     tracing::info!(
         "[test3-stop-keepalive-wait-verify-missing] verified keys removed after stopping keepalive and waiting past TTL"
@@ -259,12 +267,14 @@ async fn test4_delete_under_lease_then_get_fails() {
     }
     sleep(Duration::from_secs(2)).await;
     for k in &keys {
-        assert!(!client_view
-            .client_kv_api()
-            .inner()
-            .is_exist(k)
-            .await
-            .unwrap());
+        assert!(
+            !client_view
+                .client_kv_api()
+                .inner()
+                .is_exist(k)
+                .await
+                .unwrap()
+        );
     }
     tracing::info!(
         "[test4-delete-keys-sleep-2s-verify-missing] deleted keys and verified not exist after delay"
diff --git a/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs b/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
index 692a9a0..d4a6549 100644
--- a/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
@@ -15,7 +15,7 @@ use limit_thirdparty::tokio::time::sleep;
 
 use crate::config::{
     ClientConfig, ContributeToClusterPoolSize, FluxonKvSpec, MasterConfig, MonitoringConfig,
-    ProtocolConfig, ProtocolType, TestSpecConfig, TransferEngineType,
+    ProtocolConfig, ProtocolType, ReplicaTaskPlacementConfig, TestSpecConfig, TransferEngineType,
 };
 use crate::master_kv_router::MasterKvRouterView;
 use crate::master_seg_manager::one_seg_allocator::Allocation;
@@ -58,6 +58,7 @@ fn new_master_config(
         log_dir: "/tmp/fluxon_master_logs".to_string(),
         pprof_duration_seconds: None,
         master_ui: None,
+        replica_task_placement: ReplicaTaskPlacementConfig::default(),
         test_spec_config: TestSpecConfig::default(),
     }
 }
diff --git a/fluxon_rs/fluxon_pyo3/src/error.rs b/fluxon_rs/fluxon_pyo3/src/error.rs
index 652ef0b..06246dc 100644
--- a/fluxon_rs/fluxon_pyo3/src/error.rs
+++ b/fluxon_rs/fluxon_pyo3/src/error.rs
@@ -1,6 +1,6 @@
+use pyo3::PyErr;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use pyo3::PyErr;
 
 use fluxon_mq::MpscError as CoreMpscError;
 // Re-export the core MPSC error type for callers who want to depend on a single error hub.
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index e86ef21..1b89d76 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -9,54 +9,51 @@ use std::thread;
 use bytes::Bytes;
 use fluxon_cli::config::MonitorConfigYaml as MonitorCliConfigYaml;
 use fluxon_fs::config::{
-    FluxonFsRequestIdentity, FluxonFsS3KvMissPolicy, FsAgentDeclaredExportWire,
     FLUXON_FS_CONTROL_SCHEMA_VERSION, FS_AGENT_DECLARED_EXPORT_JSON_KEY,
     FS_AGENT_EXPORT_PUBLISH_RPC_PATH, FS_AGENT_EXPORT_UNPUBLISH_RPC_PATH,
-    FS_MASTER_CONFIG_RPC_PATH,
+    FS_MASTER_CONFIG_RPC_PATH, FluxonFsRequestIdentity, FluxonFsS3KvMissPolicy,
+    FsAgentDeclaredExportWire,
 };
+use fluxon_kv::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
+use fluxon_kv::client_kv_api::ClientKvApiViewTrait;
 use fluxon_kv::client_kv_api::msg_pack::{
     ExternalBatchPutCommitItemReq, ExternalBatchPutCommitReq, ExternalBatchPutStartItemReq,
     ExternalBatchPutStartReq, ExternalBatchPutTransferEndItemReq, ExternalBatchPutTransferEndReq,
     ExternalPutRevokeReq,
 };
-use fluxon_kv::client_kv_api::ClientKvApiViewTrait;
 use fluxon_kv::client_kv_api::{
-    ClientKvApiInner, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, OwnerReservedPutItem,
+    ClientKvApiInner, OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerLocalReserveSlotLease,
 };
 use fluxon_kv::client_seg_pool::ClientSegPoolViewTrait;
-use fluxon_kv::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use fluxon_kv::cluster_manager::ClusterManagerViewTrait;
+use fluxon_kv::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use fluxon_kv::config::{ClientConfigYaml, MasterConfigYaml};
 use fluxon_kv::external_client_api::ExternalClientApiViewTrait;
-use fluxon_kv::master_kv_router::msg_pack::{
-    BatchPreparePutKeyItemReq, BatchPutDoneItemReq, BatchPutRevokeItemReq, BatchPutStartItemReq,
-    PutDoneCommittedSlot,
-};
+use fluxon_kv::master_kv_router::msg_pack::{BatchPreparePutKeyItemReq, PutDoneCommittedSlot};
 use fluxon_kv::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
-use fluxon_kv::memholder::kvclient_encode::{flat_kv_decode_borrowed, BorrowedFlatKvValueRange};
+use fluxon_kv::memholder::kvclient_encode::{BorrowedFlatKvValueRange, flat_kv_decode_borrowed};
 use fluxon_kv::memholder::{
-    ExternalMemHolder as RustExternalMemHolder, MemoryInfo as RustMemoryInfo,
-    UserMemHolder as RustUserMemHolder,
+    ExternalMemHolder as RustExternalMemHolder, UserMemHolder as RustUserMemHolder,
 };
-use fluxon_kv::p2p::msg_pack::{call_rpc, MsgPack, RPCCaller};
+use fluxon_kv::p2p::msg_pack::{MsgPack, RPCCaller, call_rpc};
 use fluxon_kv::p2p::p2p_module::P2pModuleViewTrait;
-use fluxon_kv::p2p::p2p_module::{user_rpc_register_handler, UserRpcHandler};
+use fluxon_kv::p2p::p2p_module::{UserRpcHandler, user_rpc_register_handler};
 use fluxon_kv::rpcresp_kvresult_convert::msg_and_error::{
     ApiError as CoreApiError, KvError as CoreKvError, KvResult, OK,
 };
 use fluxon_kv::user_api::FlatDict;
 use fluxon_kv::user_api::FlatValue;
 use fluxon_kv::user_api::FluxonUserApi;
-use fluxon_kv::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 use fluxon_kv::{
+    ConfigArg, Framework, KvClientTrait, KvGetResult,
     config::{ClientConfig, MasterConfig},
-    run_client, run_master, ConfigArg, Framework, KvClientTrait, KvGetResult,
+    run_client, run_master,
 };
 use fluxon_ops;
 use fluxon_proxy;
-use fluxon_util::run_async_from_sync::{borrow_stable_owner, SyncAsyncBridge};
+use fluxon_util::run_async_from_sync::{SyncAsyncBridge, borrow_stable_owner};
 use fluxon_util::{
-    fluxon_cli_proxy_desc_etcd_key_v2, FluxonCliProxyDescriptorV2, FluxonCliProxyTransportV2,
+    FluxonCliProxyDescriptorV2, FluxonCliProxyTransportV2, fluxon_cli_proxy_desc_etcd_key_v2,
 };
 use futures::Future;
 use pyo3::exceptions::{PyOSError, PyPermissionError, PyRuntimeError, PyValueError};
@@ -77,7 +74,7 @@ include!(env!("FLUXON_PYO3_TEST_PYTHON_LINK_RS"));
 mod memholder;
 pub use memholder::{ExternalMemHolder, MemHolder};
 mod flatdict_zerocopy;
-use flatdict_zerocopy::{decode_flat_dict_to_wrapped_py_object, FlatDictDataOwner};
+use flatdict_zerocopy::{FlatDictDataOwner, decode_flat_dict_to_wrapped_py_object};
 mod kvfuture;
 pub use kvfuture::KvFuture;
 mod error;
@@ -2107,7 +2104,6 @@ enum StagedPutPlanData {
 struct StagedOwnerPutPlanData {
     keys: Vec<String>,
     value_len: u64,
-    write_through: bool,
     key_reservation_ids: Vec<u64>,
     slot_lease: OwnerLocalReserveSlotLease,
 }
@@ -2116,7 +2112,6 @@ struct StagedOwnerPutPlanData {
 struct StagedExternalPutPlanData {
     keys: Vec<String>,
     value_len: u64,
-    write_through: bool,
     started_time: i64,
     items: Vec<StagedExternalPutItem>,
     short_circuit_payload: bool,
@@ -2132,13 +2127,6 @@ struct StagedExternalPutItem {
     target_base_addr: u64,
 }
 
-#[derive(Clone)]
-struct StagedPutCommitItem {
-    idx: usize,
-    reserved_item: OwnerReservedPutItem,
-    slot_ref: OwnerLocalReserveSlotRef,
-}
-
 #[derive(Clone, Debug, Default)]
 struct FluxonIoLocalitySnapshot {
     op_count: u64,
@@ -2321,10 +2309,6 @@ async fn release_put_key_reservations_only(
         .map(|_| ())
 }
 
-fn staged_put_uses_direct_local_commit(item: &OwnerReservedPutItem) -> bool {
-    !item.write_through || (item.peer_node_id.is_none() && item.src_addr == item.target_addr)
-}
-
 fn combine_kv_errors(
     context: &str,
     primary_err: CoreKvError,
@@ -2338,50 +2322,6 @@ fn combine_kv_errors(
     })
 }
 
-fn remove_precommit_local_visible_infos(
-    inner: &ClientKvApiInner,
-    keys: &[String],
-    memory_infos: &[Arc<RustMemoryInfo>],
-) {
-    for (key, memory_info) in keys.iter().zip(memory_infos.iter()) {
-        let _ = inner.remove_precommit_local_reserve_resident_slot_if_same(key, memory_info);
-    }
-}
-
-fn remove_precommit_local_visible_infos_for_items(
-    inner: &ClientKvApiInner,
-    items: &[StagedPutCommitItem],
-    memory_infos: &[Arc<RustMemoryInfo>],
-) {
-    for item in items {
-        let _ = inner.remove_precommit_local_reserve_resident_slot_if_same(
-            &item.reserved_item.key,
-            &memory_infos[item.idx],
-        );
-    }
-}
-
-async fn revoke_staged_put_items(
-    inner: &ClientKvApiInner,
-    items: &[StagedPutCommitItem],
-) -> KvResult<()> {
-    if items.is_empty() {
-        return Ok(());
-    }
-    inner
-        .batch_put_revoke(
-            items
-                .iter()
-                .map(|item| BatchPutRevokeItemReq {
-                    key: item.reserved_item.key.clone(),
-                    put_id: item.reserved_item.put_id,
-                })
-                .collect(),
-        )
-        .await
-        .map(|_| ())
-}
-
 #[pyfunction]
 fn decode_flat_dict_payload(payload: Vec<u8>, py: Python<'_>) -> PyObject {
     match decode_flat_dict_to_wrapped_py_object(py, FlatDictDataOwner::from_owned_bytes(payload)) {
@@ -3506,14 +3446,13 @@ impl KvClient {
         release_local_grant_blocking_inner(self, grant_id, py).into_py_object(py)
     }
 
-    #[pyo3(signature = (keys, value_len, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true))]
+    #[pyo3(signature = (keys, value_len, reject_if_inflight_same_key=false, reject_if_exist_same_key=false))]
     fn local_fast_put_start(
         &self,
         keys: Vec<String>,
         value_len: u64,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
         py: Python,
     ) -> PyObject {
         fn local_fast_put_start_inner(
@@ -3522,7 +3461,6 @@ impl KvClient {
             value_len: u64,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
-            write_through: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if keys.is_empty() {
@@ -3556,7 +3494,6 @@ impl KvClient {
                     ));
                 }
             };
-
             if framework.is_external_mode() {
                 let framework_for_start = framework.clone();
                 let keys_for_req = keys.clone();
@@ -3576,7 +3513,7 @@ impl KvClient {
                                         len: value_len,
                                         reject_if_inflight_same_key,
                                         reject_if_exist_same_key,
-                                        write_through,
+                                        make_replica_task: true,
                                         preferred_sub_cluster: None,
                                     })
                                     .collect(),
@@ -3729,7 +3666,6 @@ impl KvClient {
                         StagedExternalPutPlanData {
                             keys,
                             value_len,
-                            write_through,
                             started_time,
                             items,
                             short_circuit_payload,
@@ -3834,7 +3770,6 @@ impl KvClient {
                     StagedOwnerPutPlanData {
                         keys,
                         value_len,
-                        write_through,
                         key_reservation_ids,
                         slot_lease,
                     },
@@ -3855,7 +3790,6 @@ impl KvClient {
             value_len,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
             py,
         )
         .into_py_object(py)
@@ -3930,7 +3864,6 @@ impl KvClient {
                                             remote_target: item.peer_id.is_some(),
                                             put_id: Some(item.put_id),
                                             lease_id: None,
-                                            write_through: external_data.write_through,
                                         })
                                         .collect(),
                                     started_time: external_data.started_time,
@@ -3968,7 +3901,6 @@ impl KvClient {
                                                     None
                                                 },
                                                 put_id: Some(item.put_id),
-                                                write_through: external_data.write_through,
                                                 lease_id: None,
                                             })
                                             .collect(),
@@ -3997,27 +3929,33 @@ impl KvClient {
                     StagedPutPlanData::Owner(owner_data) => {
                         let client_kv_api_view = framework_for_commit.client_kv_api_view();
                         let inner = client_kv_api_view.client_kv_api().inner();
-                        let start_items = owner_data
-                            .keys
-                            .iter()
-                            .map(|key| BatchPutStartItemReq {
-                                key: key.clone(),
-                                len: owner_data.value_len,
-                                reject_if_inflight_same_key: false,
-                                reject_if_exist_same_key: false,
-                                write_through: owner_data.write_through,
-                                preferred_sub_cluster: None,
-                            })
-                            .collect::<Vec<_>>();
                         let slot_refs = owner_data.slot_lease.slots.clone();
                         let slot_size = owner_data.slot_lease.slot_size;
-                        let value_len_usize = match usize::try_from(owner_data.value_len) {
+                        if slot_refs.len() != owner_data.keys.len() {
+                            let err = CoreKvError::Api(CoreApiError::Unknown {
+                                detail: format!(
+                                    "local_fast_put_commit slot/key length mismatch: keys={} slots={}",
+                                    owner_data.keys.len(),
+                                    slot_refs.len()
+                                ),
+                            });
+                            let _ = release_staged_put_resources(
+                                inner,
+                                owner_data.key_reservation_ids,
+                                owner_data.slot_lease,
+                            )
+                            .await;
+                            return ApiResult::new_success(vec![
+                                kv_error_to_ret_code(&err);
+                                owner_data.keys.len()
+                            ]);
+                        }
+                        let value_len_u32 = match u32::try_from(owner_data.value_len) {
                             Ok(value) => value,
                             Err(_) => {
                                 let err = CoreKvError::Api(CoreApiError::InvalidArgument {
-                                    detail:
-                                        "local_fast_put_commit value_len does not fit into usize"
-                                            .to_string(),
+                                    detail: "local_fast_put_commit value_len does not fit into u32"
+                                        .to_string(),
                                 });
                                 let _ = release_staged_put_resources(
                                     inner,
@@ -4031,13 +3969,14 @@ impl KvClient {
                                 ]);
                             }
                         };
-                        let mut memory_infos = Vec::with_capacity(owner_data.keys.len());
+                        let mut publish_items = Vec::with_capacity(owner_data.keys.len());
+                        let mut ret_codes = Vec::with_capacity(owner_data.keys.len());
                         for (key, slot_ref) in owner_data.keys.iter().zip(slot_refs.iter()) {
                             let memory_info = inner
                                 .build_local_reserve_resident_memory_info(
                                     key,
                                     slot_ref.ptr,
-                                    owner_data.value_len as u32,
+                                    value_len_u32,
                                     slot_size,
                                     slot_ref.grant_id,
                                     slot_ref.slot_index,
@@ -4047,249 +3986,75 @@ impl KvClient {
                                 key,
                                 memory_info.clone(),
                             );
-                            memory_infos.push(memory_info);
-                        }
-                        let mut ret_codes = Vec::with_capacity(owner_data.keys.len());
-                        match inner
-                            .owner_batch_put_start_reserved(start_items, None)
-                            .await
-                        {
-                            Ok(prepared_items) if prepared_items.len() == slot_refs.len() => {
-                                let mut direct_items = Vec::new();
-                                let mut copy_items = Vec::new();
-                                for (idx, (reserved_item, slot_ref)) in prepared_items
-                                    .into_iter()
-                                    .zip(slot_refs.iter().cloned())
-                                    .enumerate()
-                                {
-                                    let item = StagedPutCommitItem {
-                                        idx,
-                                        reserved_item,
-                                        slot_ref,
-                                    };
-                                    if staged_put_uses_direct_local_commit(&item.reserved_item) {
-                                        direct_items.push(item);
-                                    } else {
-                                        copy_items.push(item);
-                                    }
-                                }
-
-                                let mut item_results: Vec<Option<i32>> =
-                                    (0..slot_refs.len()).map(|_| None).collect();
-
-                                if !copy_items.is_empty() {
-                                    let reserved_copy_items = copy_items
-                                        .iter()
-                                        .map(|item| item.reserved_item.clone())
-                                        .collect::<Vec<_>>();
-                                    for item in &copy_items {
-                                        unsafe {
-                                            std::ptr::copy_nonoverlapping(
-                                                item.slot_ref.ptr as *const u8,
-                                                item.reserved_item.src_addr as *mut u8,
-                                                value_len_usize,
-                                            );
-                                        }
-                                    }
-                                    match inner
-                                        .owner_batch_put_commit_reserved(
-                                            reserved_copy_items,
-                                            transfer_concurrency,
-                                        )
-                                        .await
-                                    {
-                                        Ok(copy_results)
-                                            if copy_results.len() == copy_items.len() =>
-                                        {
-                                            for (item, result) in
-                                                copy_items.iter().zip(copy_results.into_iter())
-                                            {
-                                                item_results[item.idx] = Some(match result {
-                                                    Ok(()) => 0,
-                                                    Err(err) => kv_error_to_ret_code(&err),
-                                                });
-                                            }
-                                        }
-                                        Ok(copy_results) => {
-                                            let err = CoreKvError::Api(CoreApiError::Unknown {
-                                                detail: format!(
-                                                    "local_fast_put_commit copy result length mismatch: expected={} got={}",
-                                                    copy_items.len(),
-                                                    copy_results.len()
-                                                ),
-                                            });
-                                            let code = kv_error_to_ret_code(&err);
-                                            for item in &copy_items {
-                                                item_results[item.idx] = Some(code);
-                                            }
-                                        }
-                                        Err(err) => {
-                                            let code = kv_error_to_ret_code(&err);
-                                            for item in &copy_items {
-                                                item_results[item.idx] = Some(code);
-                                            }
-                                        }
-                                    }
-                                    remove_precommit_local_visible_infos_for_items(
-                                        inner,
-                                        &copy_items,
-                                        &memory_infos,
-                                    );
-                                }
-
-                                if !direct_items.is_empty() {
-                                    let direct_done_req_items = direct_items
-                                        .iter()
-                                        .map(|item| BatchPutDoneItemReq {
-                                            key: item.reserved_item.key.clone(),
-                                            put_id: item.reserved_item.put_id,
-                                            lease_id: item.reserved_item.lease_id,
-                                            committed_slot: Some(PutDoneCommittedSlot {
-                                                grant_id: item.slot_ref.grant_id,
-                                                slot_index: item.slot_ref.slot_index,
-                                                slot_size,
-                                                addr: item.slot_ref.ptr,
-                                                base_addr: item.slot_ref.base_addr,
-                                                len: owner_data.value_len,
-                                            }),
-                                            publish_local_cache: false,
-                                        })
-                                        .collect::<Vec<_>>();
-                                    match inner.batch_put_done(direct_done_req_items).await {
-                                        Ok(done_resp)
-                                            if done_resp.items.len() == direct_items.len() =>
-                                        {
-                                            for (item, done_item) in
-                                                direct_items.iter().zip(done_resp.items.into_iter())
-                                            {
-                                                let result =
-                                                    fluxon_kv::rpcresp_kvresult_convert::try_from_code(
-                                                        done_item.error_code,
-                                                        done_item.error_json.clone(),
-                                                    );
-                                                if result.is_ok() {
-                                                    let promote = inner
-                                                        .promote_precommit_local_reserve_resident_slot_if_same(
-                                                            &item.reserved_item.key,
-                                                            item.reserved_item.put_id,
-                                                            memory_infos[item.idx].clone(),
-                                                        );
-                                                    if item.reserved_item.enqueue_write_back_append
-                                                    {
-                                                        if let Err(err) = inner
-                                                            .enqueue_write_back_remote_append(
-                                                                &item.reserved_item.key,
-                                                                item.reserved_item.put_id,
-                                                                item.reserved_item
-                                                                    .preferred_sub_cluster
-                                                                    .as_deref(),
-                                                            )
-                                                            .await
-                                                        {
-                                                            tracing::warn!(
-                                                                "local_fast_put_commit write-back remote append enqueue failed after direct local commit: key={} put_id=({},{}) err={}",
-                                                                item.reserved_item.key,
-                                                                item.reserved_item.put_id.0,
-                                                                item.reserved_item.put_id.1,
-                                                                err
-                                                            );
-                                                        }
-                                                    }
-                                                    inner.record_put_locality(
-                                                        false,
-                                                        owner_data.value_len,
-                                                        0,
-                                                    );
-                                                    item_results[item.idx] = Some(match promote {
-                                                        Ok(()) => 0,
-                                                        Err(err) => kv_error_to_ret_code(&err),
-                                                    });
-                                                } else if let Err(err) = result {
-                                                    item_results[item.idx] =
-                                                        Some(kv_error_to_ret_code(&err));
-                                                    let _ = inner
-                                                        .remove_precommit_local_reserve_resident_slot_if_same(
-                                                            &item.reserved_item.key,
-                                                            &memory_infos[item.idx],
-                                                        );
-                                                }
-                                            }
-                                        }
-                                        Ok(done_resp) => {
-                                            let err = CoreKvError::Api(CoreApiError::Unknown {
-                                                detail: format!(
-                                                    "local_fast_put_commit direct done response length mismatch: expected={} got={}",
-                                                    direct_items.len(),
-                                                    done_resp.items.len()
-                                                ),
-                                            });
-                                            let code = kv_error_to_ret_code(&err);
-                                            for item in &direct_items {
-                                                item_results[item.idx] = Some(code);
-                                            }
-                                            remove_precommit_local_visible_infos_for_items(
-                                                inner,
-                                                &direct_items,
-                                                &memory_infos,
-                                            );
-                                        }
-                                        Err(err) => {
-                                            let code = kv_error_to_ret_code(&err);
-                                            for item in &direct_items {
-                                                item_results[item.idx] = Some(code);
-                                            }
-                                            let _ =
-                                                revoke_staged_put_items(inner, &direct_items).await;
-                                            remove_precommit_local_visible_infos_for_items(
-                                                inner,
-                                                &direct_items,
-                                                &memory_infos,
-                                            );
-                                        }
-                                    }
+                            let put_id = inner.next_owner_local_first_put_id();
+                            let promote = inner
+                                .promote_precommit_local_reserve_resident_slot_if_same(
+                                    key,
+                                    put_id,
+                                    memory_info.clone(),
+                                );
+                            match promote {
+                                Ok(()) => {
+                                    inner.record_put_locality(false, owner_data.value_len, 0);
+                                    publish_items.push(OwnerLocalPublishItem {
+                                        key: key.clone(),
+                                        put_id,
+                                        value_len: owner_data.value_len,
+                                        lease_id: None,
+                                        committed_slot: PutDoneCommittedSlot {
+                                            grant_id: slot_ref.grant_id,
+                                            slot_index: slot_ref.slot_index,
+                                            slot_size,
+                                            addr: slot_ref.ptr,
+                                            base_addr: slot_ref.base_addr,
+                                            len: owner_data.value_len,
+                                        },
+                                        make_replica_task: true,
+                                        preferred_sub_cluster: None,
+                                    });
+                                    ret_codes.push(0);
                                 }
-
-                                for item in item_results {
-                                    ret_codes.push(item.unwrap_or_else(|| {
-                                        let err = CoreKvError::Api(CoreApiError::Unknown {
-                                            detail: "local_fast_put_commit result slot missing"
-                                                .to_string(),
-                                        });
-                                        kv_error_to_ret_code(&err)
-                                    }));
+                                Err(err) => {
+                                    let _ = inner
+                                        .remove_precommit_local_reserve_resident_slot_if_same(
+                                            key,
+                                            &memory_info,
+                                        );
+                                    ret_codes.push(kv_error_to_ret_code(&err));
                                 }
                             }
-                            Ok(prepared_items) => {
-                                let err = CoreKvError::Api(CoreApiError::Unknown {
-                                    detail: format!(
-                                        "local_fast_put_commit final reserve length mismatch: expected={} got={}",
-                                        slot_refs.len(),
-                                        prepared_items.len()
-                                    ),
-                                });
-                                let _ = inner.owner_batch_put_abort_reserved(prepared_items).await;
-                                remove_precommit_local_visible_infos(
-                                    inner,
-                                    &owner_data.keys,
-                                    &memory_infos,
+                        }
+                        if !publish_items.is_empty() {
+                            if let Err(err) = inner
+                                .enqueue_owner_local_publish(OwnerLocalPublishJob {
+                                    items: publish_items,
+                                    key_reservation_ids: owner_data.key_reservation_ids.clone(),
+                                })
+                                .await
+                            {
+                                tracing::warn!(
+                                    "local_fast_put_commit owner local publish enqueue failed after local commit: {}",
+                                    err
                                 );
-                                ret_codes = vec![kv_error_to_ret_code(&err); owner_data.keys.len()];
-                            }
-                            Err(err) => {
-                                remove_precommit_local_visible_infos(
+                                if let Err(cleanup_err) = release_put_key_reservations_only(
                                     inner,
-                                    &owner_data.keys,
-                                    &memory_infos,
-                                );
-                                ret_codes = vec![kv_error_to_ret_code(&err); owner_data.keys.len()];
+                                    owner_data.key_reservation_ids,
+                                )
+                                .await
+                                {
+                                    tracing::warn!(
+                                        "local_fast_put_commit key reservation cleanup failed after owner local publish enqueue error: {}",
+                                        cleanup_err
+                                    );
+                                }
+                                ret_codes = vec![kv_error_to_ret_code(&err); ret_codes.len()];
                             }
-                        }
-                        if let Err(err) =
+                        } else if let Err(err) =
                             release_put_key_reservations_only(inner, owner_data.key_reservation_ids)
                                 .await
                         {
                             tracing::warn!(
-                                "local_fast_put_commit key reservation cleanup failed: {}",
+                                "local_fast_put_commit key reservation cleanup failed after partial local commit: {}",
                                 err
                             );
                         }
@@ -4927,7 +4692,7 @@ impl KvClient {
     /// on the caller to keep the pointed-to memory alive until the async call completes.
     ///
     /// The backend encoding/copy runs on the Rust runtime without holding the Python GIL.
-    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, callback=None))]
+    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, callback=None))]
     fn put(
         &self,
         key: &str,
@@ -4935,7 +4700,6 @@ impl KvClient {
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
         callback: Option<PyObject>,
         py: Python,
     ) -> PyObject {
@@ -4946,7 +4710,6 @@ impl KvClient {
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
-            write_through: bool,
             callback: Option<PyObject>,
             py: Python,
         ) -> ApiResult<PyObject> {
@@ -4978,9 +4741,6 @@ impl KvClient {
                 if reject_if_exist_same_key {
                     o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
                 }
-                if write_through {
-                    o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
-                }
                 o
             };
 
@@ -5041,7 +4801,6 @@ impl KvClient {
             lease_id,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
             callback,
             py,
         )
@@ -5049,7 +4808,7 @@ impl KvClient {
     }
 
     /// Put a key-value pair and wait for completion before returning.
-    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true))]
+    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false))]
     fn put_blocking(
         &self,
         key: &str,
@@ -5057,7 +4816,6 @@ impl KvClient {
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
         py: Python,
     ) -> PyObject {
         fn put_blocking_inner(
@@ -5067,7 +4825,6 @@ impl KvClient {
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
-            write_through: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if ptrs.len() > (u32::MAX as usize) {
@@ -5104,11 +4861,6 @@ impl KvClient {
                     .0
                     .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
             }
-            if write_through {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
-            }
             let result = match py.allow_threads(|| {
                 runtime.run_async_from_sync(async {
                     unsafe { framework.kv_put_ptrs(&key, ptrs, put_opts).await }
@@ -5157,7 +4909,6 @@ impl KvClient {
             lease_id,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
             py,
         )
         .into_py_object(py)
@@ -5166,7 +4917,7 @@ impl KvClient {
     /// Put a batch of key-value pairs and wait for completion before returning.
     ///
     /// Each item uses the same flatdict encoding contract as `put_blocking()`.
-    #[pyo3(signature = (keys, ptrs_groups, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, concurrency=None))]
+    #[pyo3(signature = (keys, ptrs_groups, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, concurrency=None))]
     fn batch_put_blocking(
         &self,
         keys: Vec<String>,
@@ -5174,7 +4925,6 @@ impl KvClient {
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
         concurrency: Option<usize>,
         py: Python,
     ) -> PyObject {
@@ -5185,7 +4935,6 @@ impl KvClient {
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
-            write_through: bool,
             concurrency: Option<usize>,
             py: Python,
         ) -> ApiResult<PyObject> {
@@ -5241,11 +4990,6 @@ impl KvClient {
                     .0
                     .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
             }
-            if write_through {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
-            }
 
             if !framework.is_external_mode() {
                 let framework_for_backend = framework.clone();
@@ -5411,7 +5155,6 @@ impl KvClient {
             lease_id,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
             concurrency,
             py,
         )
@@ -5463,7 +5206,7 @@ impl KvClient {
     }
 
     /// Native blocking batch put path for payload pointers.
-    #[pyo3(signature = (keys, payload_ptrs, payload_sizes, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true))]
+    #[pyo3(signature = (keys, payload_ptrs, payload_sizes, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false))]
     fn batch_put_from(
         &self,
         keys: Vec<String>,
@@ -5472,7 +5215,6 @@ impl KvClient {
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-        write_through: bool,
         py: Python,
     ) -> PyObject {
         fn batch_put_from_inner(
@@ -5483,7 +5225,6 @@ impl KvClient {
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
-            write_through: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if keys.len() != payload_ptrs.len() || keys.len() != payload_sizes.len() {
@@ -5559,11 +5300,6 @@ impl KvClient {
                     .0
                     .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
             }
-            if write_through {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::WriteThrough);
-            }
 
             let keys_for_backend = keys.clone();
             let ptrs_groups = keys_for_backend
@@ -5683,7 +5419,6 @@ impl KvClient {
             lease_id,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
-            write_through,
             py,
         )
         .into_py_object(py)
@@ -7408,14 +7143,17 @@ mod tests {
             discovery.entries[0].provider_path,
             libs_dir.join("libmlx5-rdmav34.so")
         );
-        assert!(discovery
-            .outcomes
-            .iter()
-            .any(|outcome| { outcome.contains("config_ok:") && outcome.contains("driver=mlx5") }));
-        assert!(discovery
-            .outcomes
-            .iter()
-            .any(|outcome| outcome.contains("config_parse_fail:")));
+        assert!(
+            discovery.outcomes.iter().any(|outcome| {
+                outcome.contains("config_ok:") && outcome.contains("driver=mlx5")
+            })
+        );
+        assert!(
+            discovery
+                .outcomes
+                .iter()
+                .any(|outcome| outcome.contains("config_parse_fail:"))
+        );
     }
 
     #[test]

From 6d4d9e36a20796fa4282887f977367442248e3d6 Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Wed, 15 Jul 2026 15:37:40 +0800
Subject: [PATCH 03/10] feat(kv): add atomic-group replicas and capacity
 reclaim

---
 .gitignore                                    |    3 +
 ...06\346\210\220\350\256\276\350\256\241.md" |  952 +++++-
 fluxon_py/config.py                           |  117 +-
 fluxon_py/kvclient/fluxon.py                  |  122 +-
 fluxon_py/kvclient/kvclient_interface.py      |   17 +
 fluxon_py/tests/test_config.py                |  103 +
 fluxon_rs/fluxon_commu/src/facade/p2p.rs      |   25 +-
 fluxon_rs/fluxon_commu_contract/src/p2p.rs    |    7 +-
 .../fluxon_commu_contract/src/p2p/rpc.rs      |   52 +
 .../fluxon_kv/src/client_kv_api/delete.rs     |   38 +-
 .../src/client_kv_api/external_api.rs         |  545 +++-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |   57 +-
 .../client_kv_api/local_reserve_rebalance.rs  |  557 +++-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 1707 ++++++++++-
 .../fluxon_kv/src/client_kv_api/msg_pack.rs   |   81 +
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  | 1255 ++++++--
 .../fluxon_kv/src/client_kv_api/reclaim.rs    |  429 +++
 fluxon_rs/fluxon_kv/src/config.rs             |  479 ++-
 .../external_client_test.rs                   |    4 +
 .../fluxon_kv/src/external_client_api/mod.rs  |  280 +-
 fluxon_rs/fluxon_kv/src/kv_test.rs            |    3 +
 fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs    |    3 +
 fluxon_rs/fluxon_kv/src/lib.rs                |   43 +
 .../master_kv_router/count_prefix_index.rs    |  101 +-
 .../fluxon_kv/src/master_kv_router/delete.rs  |   23 +-
 .../fluxon_kv/src/master_kv_router/get.rs     |  148 +-
 .../fluxon_kv/src/master_kv_router/mod.rs     | 2670 ++++++++++++++++-
 .../src/master_kv_router/msg_pack.rs          |  408 ++-
 .../src/master_kv_router/placement.rs         |    2 +-
 .../fluxon_kv/src/master_kv_router/put.rs     |  750 +++--
 .../fluxon_kv/src/master_kv_router/reclaim.rs | 1291 ++++++++
 .../src/master_kv_router/route_maintenance.rs |  349 +++
 .../src/master_kv_router/tiered_writeback.rs  |  224 ++
 .../fluxon_kv/src/memholder/memholder_test.rs |   31 +-
 fluxon_rs/fluxon_kv/src/memholder/mod.rs      |   19 +-
 fluxon_rs/fluxon_kv/src/p2p/msg_pack.rs       |    7 +-
 .../rpcresp_kvresult_convert/msg_and_error.rs |    6 +
 fluxon_rs/fluxon_kv/src/user_api/rpc.rs       |   11 +-
 fluxon_rs/fluxon_kv/src/user_rpc.rs           |   46 +-
 fluxon_rs/fluxon_pyo3/src/error.rs            |    6 +-
 fluxon_rs/fluxon_pyo3/src/lib.rs              |  543 +++-
 fluxon_rs/fluxon_util/src/log.rs              |   42 +-
 fluxon_rs/fluxon_util/src/vallocator/mod.rs   |  144 +-
 fluxon_rs/fluxon_util/src/vallocator/test.rs  |   35 +
 fluxon_rs/fluxon_util/tests/log_mgmt.rs       |    8 +
 45 files changed, 12376 insertions(+), 1367 deletions(-)
 create mode 100644 fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
 create mode 100644 fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
 create mode 100644 fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
 create mode 100644 fluxon_rs/fluxon_kv/src/master_kv_router/tiered_writeback.rs

diff --git a/.gitignore b/.gitignore
index d198634..fa0d6cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,3 +60,6 @@ bench_suite.lock
 deployment/local/
 setup_and_pack/pack_fluxonkv_pylib_env.yaml
 fluxon_rs/moka/
+fluxon_rs/*.btr
+fluxon_rs/moka.bak_non_git_*/
+build_*.rc
diff --git "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md" "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
index 3b0c1c6..475adab 100644
--- "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
+++ "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
@@ -27,6 +27,28 @@
   - 因果链：SGLang KVCache restore 不是普通逐 key `get`，而是面向一批有序 page keys 的 prefix restore。它需要一次性回答“这一批最多恢复到哪里”，并且不能切开一个 radix node 对应的 atomic group。batch 化还能减少逐 key 调用、查表、锁和跨边界调度开销。
   - 本设计落点：Fluxon hostless get 以 batch 为单位计算 `raw_prefix_hit_len`、`transferable_len` 和 `prefix_hit_groups`。`get_start` 合并存在性 / prefix 判断和可恢复前缀的数据拉取启动，返回 handle 和 prefix；`get_transfer` 再消费 handle，把可恢复前缀转换成 readable `plan_ptr(value_ptrs)`。
 
+### Mooncake 对齐实验给出的性能约束
+
+2026-07-12 的三机对齐实验使用两台 TP=2 GPU 节点和一台纯 CPU 节点，标称容量均为
+GPU0/GPU1/CPU = 128/128/256 GiB，同一批 1152 个 agent 请求中，原版 SGLang +
+Mooncake 达到 6.9192 QPS，Fluxon E15 为 3.5134 QPS。Mooncake 没有本设计的 Put
+atomic-group admission；它在本轮也没有进入驱逐区。因此该结果证明 group 完整性是 CPU
+副本可消费性的必要条件，但不是这轮端到端差距的唯一来源。
+
+| 观测 | Fluxon E15 | Mooncake 对齐轮 | 设计约束 |
+| --- | ---: | ---: | --- |
+| 总命中率 | 44.57% | 93.05% | 先对齐实际 payload 容量和驱逐水位，再比较 group 策略。 |
+| cache hit tokens | 12,794,304 | 26,713,408 | Fluxon 多重算 13,919,104 tokens，是吞吐差距主体。 |
+| 单 GPU 有效 payload 驱逐点 | 约 57.6 GiB | 本轮约 106 GiB 且未驱逐 | slot 内部碎片和过早水位不能隐藏在相同标称容量后面。 |
+| load-back 平均耗时 | 57.1 ms | 5.99 ms | 容量问题消除后，仍需优化 `kernel + layer_first` 读取路径。 |
+
+E15 的 4,718,592-byte value 被旧 slot class 扩成 8 MiB，payload 利用率 56.25%；再叠加
+旧 Moka 0.8 水位，每个 128 GiB GPU owner 只承载约 57.6 GiB payload 就开始驱逐。
+失败候选立即回插又导致 571 万次请求区间 reclaim candidates 中只有约 4.59 万次成功。
+本设计因此把 exact-fit slot、可配置水位和失败候选退避视为容量控制面的基础正确性，不能
+用新增 atomic group 掩盖这些问题。完整实验设置、计数和日志位置记录在
+`sglang_fluxon_agent_experiments.md`。
+
 ### 核心实现思路
 
 核心实现按上面的 insight 逐条落到接口和状态边界：
@@ -54,8 +76,8 @@
 - **对应适配 SGLang KVCache 特化接口**
   - 实现思路：把 restore 查询建模成 SGLang KVCache 专用的 batch prefix planning，而不是逐 key 独立 get。
     - Reject inflight / exist：KV page 按不可变缓存对象写回，重复 page key 不应产生第二份并发写入。`local_fast_put_start` 固定使用 `reject_if_inflight_same_key` 和 `reject_if_exist_same_key`，在分配 writable memory 前拒绝在途或已存在的同 key value，避免重复写回和未提交数据被误发布。
-    - Prefetch 对应 `get_start`：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序完成存在性 / prefix 判断，并在 owner/external 侧启动 `keys[..transferable_len]` 的 prefetch transfer，把“能恢复多少”和“开始拉取可恢复数据”合并在 start 阶段。
-    - Batch 和 group 对齐：`get_start` 按 atomic group 边界把 `raw_prefix_hit_len` 收敛成 `transferable_len`；`get_transfer` 只消费这个 handle 和 `keys[..transferable_len]` 的 prefetch 结果，并构造 batch 级 readable `plan_ptr(value_ptrs)`，保证 kernel restore 看到的是连续、完整、可回滚的 readable batch plan。
+    - Prefetch 对应 `get_start`：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序完成存在性 / prefix 判断。全 owner-local 批次直接返回 `InlineLocal` holder metadata；混合命中或需要远端 materialization 的批次启动 `keys[..transferable_len]` 的后台 prefetch transfer。
+    - Batch 和 group 对齐：`get_start` 按 atomic group 边界把 `raw_prefix_hit_len` 收敛成 `transferable_len`；`get_transfer` 只消费这个 handle 对应的 `InlineLocal` 或 `OwnerRpc` 有限分支，并构造 batch 级 readable `plan_ptr(value_ptrs)`，保证 kernel restore 看到的是连续、完整、可回滚的 readable batch plan。
   - 主要落点：`reject_if_inflight_same_key`、`reject_if_exist_same_key`、`GetStartResult`、`atomic_group_lens`、`raw_prefix_hit_len`、`transferable_len`、`prefix_hit_groups`、`get_start/get_transfer`。
 
 因此，本设计要统一的是 L2/L3 的对象归属、可见性和生命周期，同时保留 L2 路径的低延迟数据面。单独替换成普通远端 KV 会丢掉 HiCache L2 的 kernel 直连能力；单独保留本地数组或进程内缓存，又无法让 L2 进入全局命中、驱逐和跨节点复用链路。
@@ -130,6 +152,9 @@ flowchart LR
 | `reject_if_inflight_same_key` | 固定开启，避免同一 page key 并发写回造成重复 inflight put。 |
 | `reject_if_exist_same_key` | 固定开启，SGLang 把重复 key 当作已写回或冲突重试处理。 |
 | `write_through` | 当前配置决定提交策略；调用方显式传入时 Fluxon 必须按字段语义执行。 |
+| `make_replica_task` | owner-local write-back 成功后的 batch 级异步副本总开关。 |
+| `make_replica_task_mask` | `local_fast_put_start` 的可选逐 key 副本准入结果；长度必须与 `keys` 相同。 |
+| `atomic_group_lens` | `local_fast_put_start` 有序 key batch 的原子分组；每项必须大于 0，总和必须严格等于 `keys` 长度。组内副本准入必须一致。 |
 | `lease_id` | 当前 SGLang hostless 主线不依赖 lease。 |
 
 ## Key 与组件命名
@@ -192,6 +217,10 @@ SGLang external-client 模式要求看到 `external_owner:*` segment。注册失
 
 `plan_ptr` 是 Fluxon 返回给 SGLang 的临时句柄，本质上是一段 plan blob 的首地址。SGLang native kernel 通过 `plan_ptr` 找到 blob，再从 blob 里读取本次 batch 对应的 value 地址表。
 
+引入 plan blob 的目的不是单纯定义一个新句柄，而是把 KV 数据面的控制面展开从热路径中移走。实际测试中，如果 KV 接口用 Python dict/list 传递 page、layer 和 value 地址信息，或者用 C++ 结构体承载同等信息，调用链仍然会在 Python 层或 C++ 层按 `page_count * layer_count` 做大量遍历、校验和拷贝任务组织；长上下文场景下，这部分 CPU 控制面开销会被显著放大，直接抬高 backup / restore 延迟。
+
+因此这里需要一套足够扁平、稳定、可被 native kernel 直接消费的协议：Fluxon 只把本次 batch 已经分配或 materialize 好的 value 起始地址压成 `value_ptrs[]`，通过 `plan_ptr` 交给 SGLang kernel；kernel 再按自己的 KV layout 参数解释这些地址，并直接发起 GPU KV cache 和 Fluxon host value memory 之间的搬运。对 backup 来说，这条路径让 kernel 直接把 GPU KV bytes 写到 CPU host value memory；对 restore 来说，则从这些 host value 地址恢复回 GPU KV cache。这正是开头“hostless 数据面能力”的落点：Fluxon 管地址、路由和生命周期，SGLang kernel 管 KV layout 和真实数据搬运。
+
 plan blob 是 Fluxon 在 `local_fast_put_start(...)` 或 `get_transfer(...)` 时创建的一段连续 host memory，格式固定：
 
 ```c
@@ -225,6 +254,32 @@ hostless backup 的核心约束是：Fluxon 负责 GPU KV cache 之下的本机/
 
 这条 backup 路径按 write-back 最终一致性设计：native write 完成后先进入本地可见和后台 commit 流程，跨 worker / 跨节点可见性以 `KvFuture` 成功为准。提交失败不会破坏推理语义，只会让对应 page 失去 shared backing；上层清理 `storage_*` 状态后按 cache miss 处理。
 
+### 本地主副本与异步副本控制
+
+`write_through` 和 `make_replica_task` 是两个独立契约。`write_through` 选择同步远端放置还是 owner-local write-back；`make_replica_task` 只控制 owner-local commit 成功后是否创建异步副本任务。SGLang 的纯本地模式必须使用 `write_through=false, make_replica_task=false`，不能把关闭副本等同于开启 write-through。
+
+| 模式 | `write_through` | `make_replica_task` | 主数据 | 异步副本 |
+| --- | --- | --- | --- | --- |
+| local-only | `false` | `false` | 当前 GPU owner | 无 |
+| local + remote replica | `false` | `true` | 当前 GPU owner | 由 master 的 `replica_task_placement` 选择 |
+| write-through | `true` | 不参与异步副本决策 | master 直接选择远端 target | 无额外异步副本任务 |
+
+`PutOptionalArgs.make_replica_task` 必须贯穿 Python store、PyO3 和 Rust put request。兼容层如果只识别 `write_through` 而丢弃该字段，SGLang 即使记录 `replica_admitted=0`，Rust 仍可能按旧默认创建副本；因此启动检查必须同时确认 Python `PutOptionalArgs` 和 `fluxon_pyo3.KvClient.local_fast_put_start` 的签名都包含 `make_replica_task`。
+
+page admission 还要求 `make_replica_task_mask` 贯穿同一条链路。mask 缺省时，Fluxon 把 batch 级 `make_replica_task` 广播到所有 keys，保留 eager-all 和 local-only 的标量契约；mask 存在时，其长度必须严格等于 `keys` 长度，实际逐项决策为 `!write_through && make_replica_task && make_replica_task_mask[i]`。Python store 在调用 PyO3 前检查容器、长度和元素类型，PyO3 在任何 reserve 或 RPC 之前再次检查长度。external 模式把结果写入每个 `ExternalBatchPutStartItemReq.make_replica_task`；owner 模式把整份 mask 保存在 staged plan 中，commit 时按相同 key 顺序写入每个 `OwnerLocalPublishItem.make_replica_task`。
+
+Put 与 Get 使用同一种 `atomic_group_lens` 分区语义。SGLang hostless backup 把一个 radix node 的全部 page keys 标成一个 atomic group；副本策略只能整组 admitted 或整组 skipped。`min_replica_pages` 选择完整 group，允许为了满足最小值而超过它；`max_replica_pages_per_batch` 是硬上限，只保留能够完整装入预算的 group，不能截取 group 的前几页。ratio/score 策略先得到 group 级概率和优先级，再展开为组内全 true 或全 false 的 per-key mask。
+
+该契约做双层 fail-fast。Python store 要求 group lengths 是严格的 `list[int]`、每项大于 0、总和等于 key 数，并拒绝组内混合 mask；PyO3 在任何 owner slot reserve 或 external RPC 前重复同样校验。未传 `atomic_group_lens` 时，每个 key 视为长度 1 的独立 group，保留已有调用方的逐 key 行为。存在性过滤或冲突重试若只能留下半个 group，SGLang hostless 路径直接放弃该次 backup，不能把剩余 keys 重新声明成一个完整 group。
+
+标量降级不能用于 page admission。若一批中只有一页 admitted，把 mask 折叠为 `any(mask)` 会让整个 batch 都创建副本；逻辑 admission 日志与物理 CPU transfer 因而失配。启动自检必须同时确认 Python `PutOptionalArgs` 和 PyO3 签名包含 `make_replica_task_mask`，端到端验收则比较 SGLang admitted page 数、master CPU target 数和 GPU owner 成功 transfer 数，而不能只看 admission 日志。
+
+SGLang 的 admitted 只表示该 atomic group 通过客户端准入并为组内 pages 请求创建副本，不表示目标 owner 已经接收整组。当前 replica actor 仍逐 key 完成 transfer/append；相同 key 的并发副本可能在目标侧返回 `KeyBeingWritten`。因此 Put 原子准入消除了策略主动制造的稀疏组，但尚未把远端复制提交升级成组事务。数据面仍需检查“成功 `local_fast_put_start` 行中的 admitted 数 = 成功 transfer 数 + 可逐项对账的目标侧拒绝数”，并继续要求“成功 transfer 数 = `appended=true` 数 = master CPU target 数”。全局 admission 累计计数可能包含随后被 backend 拒绝并重试的尝试，不能直接作为已 staged page 数或物理复制分母。
+
+CPU-only 副本模式不新增第二个客户端开关。客户端仍设置 `make_replica_task=true`，master 再通过 `restrict_to_remote_only_node_roles=true` 和 `remote_only_node_roles=["remote_cache"]` 把 replica target 限定到 CPU owner。若 strict 候选为空，任务返回 NoSpace，不回退到其它 GPU owner。
+
+端到端验收以实际数据面计数为准：local-only 要求 GPU owner 的 `put_transfer success`、`replica task append done` 和 master `replica_task_target_counts` 全部为 0；CPU-only 副本要求两台 GPU owner 的 transfer/append 总数严格等于 master 的 CPU target 数，并且 GPU target 为 0。仅检查 SGLang 配置日志不足以证明副本策略已经生效。
+
 ### 弹性本地侧预分配
 
 弹性本地侧预分配对应 owner 本地写入预留池。它是在 owner shared segment 中为 SGLang hostless put 预先划分的 writable slots。`local_fast_put_start` 从这些 slots 中为本次 put 分配地址，并把地址写入 `plan_ptr(value_ptrs)` 返回给 SGLang native kernel。此时 slot 只处于 reserved/prepared 状态，还没有绑定为 Fluxon KV 的正式 `key -> value` route。
@@ -260,11 +315,51 @@ Free
 | --- | --- |
 | grant 物理粒度 | `OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES = 512 * 1024 * 1024` |
 | 最小 slot size | `4 KiB` |
-| slot size 计算 | `max(value_len, 4 KiB).next_power_of_two()` |
+| slot size 计算 | `align_up(max(value_len, 4 KiB), 4 KiB)`；按页对齐 exact-fit，不再向上取整到 2 的幂。 |
 | slot 上限 | `slot_size <= 512 MiB` |
 | refill 触发 | 当前 slot class free slots 不足时登记 pending demand 并唤醒 rebalance actor。 |
-| 默认等待 | soft wait `10 ms`，hard timeout `1 s`。 |
+| 预期容量预热 | owner 可配置 `owner_local_reserve_expected_capacity: {value_len, payload_capacity_bytes}`。启动时按 grant 内真实可用 slots 计算并申请所需 grants；SGLang 启动脚本必须等预热完成。 |
+| shrink 下限 | 配置预期容量后，rebalance 不把该 slot class 缩到 `expected_grants` 以下；业务瞬时 pending demand 仍可临时增加 grant。它不是物理上限。 |
+| 默认等待 | soft wait `10 ms`，hard timeout `10 s`。hard timeout 保护一次 refill/reclaim 事务，不用于掩盖 master 调度饥饿。 |
 | shrink 单位 | 整个 grant；不做 live grant compaction。 |
+| Moka 计费权重 | committed slot 使用 4 KiB 对齐后的实际 `slot_size`，而不是原始 `value_len`；容量驱逐因此对应真实内存占用。 |
+| Moka 容量水位 | master `replica_cache_capacity_ratio`，合法范围 `(0, 1]`，默认 `0.95`；它只决定常规冷条目选择水位，不改变 owner segment 配置容量。 |
+| 常规容量驱逐 | Moka 到达配置容量后选择冷条目，并通过 eviction listener 进入安全回收流程。Moka 只负责选择候选，不直接释放 owner backing。 |
+| 物理 NoSpace 兜底 | refill 申请不到 `512 MiB` grant 时，按 `slot_size * required_free_slots` 计算目标权重，扣除已经在途的回收权重后调用 `evict_some(additional_weight)`；随后按 route 扫描可安全释放的 slots。 |
+| 容量不变量 | `evict_some` 只驱逐一部分条目，不修改 Moka `max_capacity`，也不修改 owner 配置容量。 |
+| route 维护反压 | route 发布后的 prefix-index/Moka 更新进入容量 512 的有界队列，由单 actor 每批最多处理 512 项；队列满时 `put_done` 等待，避免 metadata/Moka 水位落后于 owner 物理分配并饿死 reserve RPC。 |
+
+Qwen3-VL-8B、TP=2、page size 64 的单 rank K/V value 是 4,718,592 bytes，正好是
+4 KiB 的整数倍。exact-fit 后一个 512 MiB grant 可以提供 113 个 slots；旧的
+`next_power_of_two` 会把每页扩成 8 MiB，一个 grant 只能提供 64 个 slots。以 128 GiB
+owner 为例，旧 `0.8` 水位叠加 56.25% slot payload 利用率后只有约 57.6 GiB 的有效 KV
+payload，会在物理 owner 仍有大量空闲时提前驱逐。exact-fit 与 0.95 水位分别解决内部碎片
+和过早驱逐；两项都不修改 owner 的 128 GiB segment 容量。
+
+预期容量的 grant 数必须计入每个 grant 尾部不能容纳完整 slot 的碎片，而不能简单用总 payload
+除以 512 MiB。计算为：
+
+```text
+slot_size = align_up(value_len, 4 KiB)
+slots_per_grant = floor(512 MiB / slot_size)
+expected_grants = ceil(payload_capacity_bytes / (slots_per_grant * slot_size))
+```
+
+Qwen3-VL 本轮 `value_len=4,718,592`、0.8 payload 目标 109,951,162,777 bytes 对应
+207 grants；可用 23,391 slots / 110,372,585,472 bytes，实际物理预留
+111,132,278,784 bytes。owner 配置容量仍为 128 GiB。配置层会拒绝非正 value/capacity/timeout、
+`hard_timeout <= soft_timeout`、value 大于 512 MiB、预热物理容量超过 owner DRAM，以及在
+master、external client 或 side worker 上设置 owner-only expected capacity。claim 超时统一
+返回 local-reserve timeout 类错误，并用 `stage=claim_turn|refill` 和完整 pool 状态区分等待
+claim 顺序与 refill/reclaim 失败。
+
+route 发布与容量记账必须保持有界距离。local-first `BatchPutDone` 可以一次发布上百个 page；
+如果每个 page 都独立 spawn prefix/Moka 维护任务，route 已提交和 owner slot 已占用的速度会
+超过 Moka 记账速度。此时即使 segment 仍有大量空闲，master 运行时也可能被任务和逐 page
+日志占满，使新的 512 MiB reserve RPC 超过 hard timeout。当前实现用一个有界批处理 actor
+统一消费 post-route 事件：一次 prefix-index write lock 覆盖整批，随后逐项推进 Moka；消费
+前校验当前 route 仍匹配 `put_id + owner replica`。容量 512 的队列同时承担反压边界，不能
+改回无界任务生成，也不能用增加 owner 容量代替该控制面约束。
 
 底层物理释放收束在 grant 级别。单个 committed slot 只是 grant 内逻辑索引，不直接拥有释放整块 mmap/registered memory 的权力。
 
@@ -300,8 +395,8 @@ sequenceDiagram
     participant O as Fluxon owner
     participant M as Fluxon master
 
-    U->>B: local_fast_put_start(missing_keys, value_len)
-    B->>F: local_fast_put_start(storage_keys, value_len, opts)
+    U->>B: local_fast_put_start(page_keys, value_len, atomic_group_lens)
+    B->>F: local_fast_put_start(storage_keys, value_len, opts(mask, groups))
     F->>O: claim local reserve slots / external owner offsets
     O-->>F: plan_ptr(value_ptrs)
     B-->>U: plan_ptr
@@ -322,6 +417,8 @@ hostless backup 默认不依赖 put 前 exists 扫描。重复 key 或在途 key
 
 - `keys` 不能为空。
 - `value_len` 必须大于 0，且同一批 keys 共享同一个 value size。
+- `atomic_group_lens` 存在时必须由正整数构成，且总和严格等于 `keys` 长度；同组的 `make_replica_task_mask` 值必须完全一致。
+- SGLang 的 radix node backup 默认使用 `[len(node_page_keys)]`。过滤已有 key 或冲突重试不能切开该组；无法保留完整组时本次 backup 失败关闭。
 - SGLang 必须在 `local_fast_put_commit` 前完成 native write；写入失败时必须调用 `put_abort`。
 - `local_fast_put_commit` 只能调用一次；调用后 plan 从 registry 清理，后续只能等待返回的 `KvFuture`。
 
@@ -331,16 +428,16 @@ commit 请求会带上 `len`、`src_offset` 和 target 信息。Fluxon 用这些
 
 hostless restore 的核心约束是：SGLang 只能恢复有序 page keys 的连续前缀，并且不能切开一个 radix node 对应的 atomic group。Fluxon 需要先在本机/远端 KV 层里判断这批 keys 的可恢复边界，再把真正可恢复的部分提前 materialize 到当前进程可读的 holder / memory view 中，最后转换成 SGLang kernel 可读取的 `plan_ptr(value_ptrs)`。
 
-因此读取侧分成 prefetch 和 restore 两段：
+因此读取侧分成 prefetch 和 restore 两段。当前实现把 start-to-transfer 计划显式限定为两个分支：
 
-- Prefetch：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序做 local visible check / owner get start，计算 page 级连续命中前缀 `raw_prefix_hit_len`，再按 `atomic_group_lens` 向下收敛成 `transferable_len`。prefix 发布后，owner/external 侧会启动后台 prefetch transfer，只处理 `keys[..transferable_len]`，并把 holder / transfer result 保存在 shared op 中。
-- Restore：SGLang 拿到 `transferable_len` 后再决定是否分配 GPU KV pages 并继续恢复。`get_transfer(handle)` 消费 `get_start` 返回的 handle，等待或取得 prefetch 结果，生成持有 holder 引用的 readable `plan_ptr`。随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)`，把 Fluxon value memory 拷回 GPU KV cache。
+- Prefetch：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序做 local visible check / owner get start，计算 page 级连续命中前缀 `raw_prefix_hit_len`，再按 `atomic_group_lens` 向下收敛成 `transferable_len`。全 owner-local 批次返回 `InlineLocal { items }`：owner 为每个导出 page 安装独立 external holding，并把 offset、len、holding ID 和 owner generation 随 start response 返回；该分支不创建 transfer registry，也不启动后台 transfer。混合命中、master fallback 或需要远端 materialization 的批次返回 `OwnerRpc`，继续由 shared op 保存后台 prefetch 的 holder / transfer result。
+- Restore：SGLang 拿到 `transferable_len` 后再决定是否分配 GPU KV pages 并继续恢复。`get_transfer(handle)` 消费 `get_start` 返回的 handle。`InlineLocal` 分支在 external 进程校验 owner generation 和 mmap 范围后直接构造 holders；`OwnerRpc` 分支等待或取得原有 prefetch 结果。两个分支最终都生成持有 holder 引用的 readable `plan_ptr`，随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)` 把 Fluxon value memory 拷回 GPU KV cache。
 
 读取阶段拆成 prefetch 和 restore 两步，主要是为了保证：
 
 - prefix 安全：中间 page miss 时，只恢复连续命中的完整前缀，不构造带洞的 GPU KV 状态。
 - atomic group 安全：`transferable_len` 不会切开 radix node group，避免恢复半个 node。
-- 资源效率：SGLang 在知道可恢复边界后再分配 GPU KV pages，同时 Fluxon 可以提前 prefetch 可恢复前缀，重叠远端 materialization 和 SGLang 侧 GPU page 分配。
+- 资源效率：SGLang 在知道可恢复边界后再分配 GPU KV pages。`OwnerRpc` 可以重叠远端 materialization 和 GPU page 分配；`InlineLocal` 省去第二次 owner transfer RPC 和无用后台任务。
 - 生命周期安全：`get_transfer` 返回的 plan 持有 holder 引用，直到 `release_views(plan_ptr)` 后才释放，保证 kernel restore 期间 value 地址稳定。
 
 ```mermaid
@@ -356,25 +453,31 @@ sequenceDiagram
     B->>F: get_start(storage_keys, prefix_best_effort, atomic_group_lens)
     F->>E: batch_get_start(keys)
     E->>O: ExternalBatchGetStartReq
-    O->>O: local visible check / owner get start
+    O->>O: local visible snapshot / owner get start
     O->>O: compute raw_prefix_hit_len and transferable_len
-    par return prefix
-        O-->>E: handle + raw_prefix_hit_len
-        E-->>F: backend handle + raw_prefix_hit_len
-        F->>F: build GetStartResult(raw_prefix_hit_len, transferable_len, ...)
-        F-->>B: GetStartHandle + GetStartResult
-        B-->>U: transferable_len / prefix_hit_groups / first_miss_index
-        U->>U: allocate GPU KV pages for transferable prefix
-    and background prefetch
-        O->>O: prefetch transfer keys[..transferable_len]
-        O->>O: keep holders / transfer results in shared op
+    alt fully owner-local
+        O->>O: allocate external holding IDs and install holdings
+        O-->>E: handle + InlineLocal(items, generation)
+        E->>E: cache inline plan by handle
+    else mixed hit or remote materialization
+        O->>O: create shared op and prefetch keys[..transferable_len]
+        O-->>E: handle + OwnerRpc
     end
+    E-->>F: backend handle + raw_prefix_hit_len
+    F->>F: build GetStartResult(raw_prefix_hit_len, transferable_len, ...)
+    F-->>B: GetStartHandle + GetStartResult
+    B-->>U: transferable_len / prefix_hit_groups / first_miss_index
+    U->>U: allocate GPU KV pages for transferable prefix
     alt transferable_len > 0 and caller chooses restore
         U->>B: get_transfer(handle)
         B->>F: get_transfer(handle)
         F->>E: batch_get_transfer(handle, transferable keys)
-        E->>O: ExternalBatchGetTransferReq
-        O-->>E: prefetched holders / transfer results
+        alt InlineLocal
+            E->>E: validate generation and mmap range, construct holders
+        else OwnerRpc
+            E->>O: ExternalBatchGetTransferReq
+            O-->>E: prefetched holders / transfer results
+        end
         E-->>F: plan_ptr(value_ptrs, holders kept alive)
         F-->>B: plan_ptr
         B-->>U: plan_ptr
@@ -385,8 +488,13 @@ sequenceDiagram
         U->>B: cancel_get_transfer(handle)
         B->>F: cancel_get_transfer(handle)
         F->>E: cancel_batch_get_start(handle)
-        E->>O: ExternalBatchGetCancelReq
-        O->>O: release get-start handle / prefetched holders
+        alt InlineLocal
+            E->>O: ExternalBatchGetCancelReq(holding IDs)
+            O->>O: release exact external holdings
+        else OwnerRpc
+            E->>O: ExternalBatchGetCancelReq
+            O->>O: release shared op / prefetched holders
+        end
     end
 ```
 
@@ -406,6 +514,7 @@ sequenceDiagram
 - `get_start` 成功后，调用方必须二选一：`get_transfer(handle)` 或 `cancel_get_transfer(handle)`；放弃 restore 时必须取消 handle，释放可能已经启动的 prefetch 资源。
 - `get_transfer(handle)` 成功后，handle 已被消费；后续由 returned `plan_ptr` 和 `release_views(plan_ptr)` 管理。
 - `release_views(plan_ptr)` 必须在 native restore 完成后执行，即使 native restore 失败也要释放。
+- `InlineLocal` holding 从 owner 返回 start response 前已经安装；`get_transfer` 把它移交给 returned plan，`cancel_get_transfer` 则携带 holding IDs 精确释放。owner 重启或 generation 不匹配时不能继续使用旧 inline plan。
 - `get_start` 只命中部分前缀时，SGLang 只能恢复 `transferable_len` 覆盖的完整 atomic groups，不能构造半个 atomic group 的 GPU KV 状态。
 - `get_transfer` 返回 miss / KeyNotFound 时，SGLang 必须放弃本次 restore 并执行 rollback。
 
@@ -417,12 +526,793 @@ Fluxon client/external 侧会维护当前进程可直接访问的 value 索引
 | --- | --- | --- |
 | precommit local visible | `local_fast_put_commit` 开始后，由 owner-local reserve slot 对应的 `MemoryInfo` 记录到 `precommit_local_visible_info` | 表示本次 put 的 value 已在当前进程可读，但后台 put commit 尚未最终完成；成功后转为 `get_cached_info` 中的 committed entry，失败或取消时移除。 |
 | committed local visible info | put commit 成功后，由 SGLang 进程内的 Fluxon external/client 将 `MemoryInfo` 记录到 `get_cached_info` | 保存 key、put version、`holder_id`、`offset`、`len` 和 owner node；后续 `get_start/get_transfer` 可以复用这份 `MemoryInfo` 构造 readable plan。 |
+| inline external holding | owner 判定整个 transferable batch 都在本地可见后，为每个导出 page 分配 external holding ID 并安装 holding | start response 到达 external 后由 handle 缓存；随后必须移交给 `get_transfer` plan 或由 cancel 携带 holding IDs 释放。holding 绑定 owner generation。 |
 | get-transfer holder | `get_transfer` 成功后绑定到 readable plan，并由 plan 持有引用 | `release_views(plan_ptr)` 后释放引用；plan 生命周期内 holder 保证对应 value 不被释放。 |
 
 收到 `local_cache_holder_id` 后，SGLang 进程内的 Fluxon external/client 使用 `holder_id`、`offset` 和 `len` 构造 `MemoryInfo`，并记录到自身 `get_cached_info`。`MemoryInfo` 记录当前进程访问该 value 所需的地址信息和释放动作；后续 `get_start` 命中 `get_cached_info` 时，可以直接把这份 `MemoryInfo` 纳入本次 get 结果，`get_transfer` 再把这些 value 地址写入 readable plan。底层内存的回收由 owner route、holder 引用和 owner-local reserve grant 生命周期共同约束。
 
+内部 `MemoryInfo.holder_id` 与 external holding ID 属于两个生命周期域。resident local-reserve page 的内部 holder ID 可以为 0；每次 external export 仍由 owner 分配非零、递增且独立的 holding ID，同一内部 backing 的并发导出也不能复用 ID。这样 cancel/delete ACK 可以按本次 export 精确对账，多个 resident page 不会因内部 ID 相同而覆盖 holding。external 在构造 inline holder 前还必须验证 response generation 与当前 mmap owner generation 一致，并验证 `offset + len` 位于 mapping 范围内。
+
 `precommit_local_visible_info` 只覆盖 commit 进行中的短窗口。put commit 成功并确认 holder 后，会移除 precommit entry 并记录 committed entry；如果 commit 失败，precommit entry 必须被清理，不能作为后续 storage-backed 恢复来源。
 
+## Local-side 主动驱逐与安全回收
+
+local-side 主动驱逐不是在 Moka eviction callback 中直接释放内存。无论候选来自常规 Moka capacity eviction，还是 owner refill 遇到物理 NoSpace 后显式调用 `evict_some`，都必须经过同一套 master/owner 安全回收协议。其外部可见不变量是：已经释放或复用的 backing 不会仍然作为一个可访问 route 提供给新的 put/get/replica；如果暂时无法证明可以安全释放，则候选保持 pending 并退避重试，队列关闭等无法继续推进的路径才把当前版本放回 Moka。
+
+### 触发与职责边界
+
+- Moka 使用 `NodeValueReplicaDesc.weight_bytes` 计费；对于 committed slot，该权重对应真实 `slot_size`。
+- Moka 只做冷条目选择。eviction listener 把 `owner_node_id + key + put_id + weight` 放入 safe reclaim queue，不直接 drop `MemHolder`，也不直接释放 slot。
+- `evict_some(requested_weight)` 的参数是“希望移除的权重”，不是目标 cache size；它沿 LRU 顺序驱逐到满足请求或没有候选为止，并返回实际驱逐权重。由于条目必须整项驱逐，返回值可以大于请求值。它不会通过临时调低再调高 `max_capacity` 来制造驱逐，因此 owner/Moka 配置容量在调用前后保持不变。
+- `eviction_reclaim_pending_weight` 记录已被 Moka 选中、但尚未完成物理回收的权重。NoSpace 兜底只对 `requested_weight - pending_weight` 调用 `evict_some`，避免对同一轮压力重复过量驱逐。
+- activity、holder 或短暂 owner Busy 导致候选无法回收时，不立即插回仍然超限的 Moka。该候选继续计入 pending weight，并以 `10 ms` 起步、最大 `1 s` 的指数退避重新进入 safe reclaim queue；route/put_id 已变化时结束 pending，不复活旧版本。这避免同一个热 key 在 eviction 与 reinsert 之间形成高频循环。
+- safe reclaim queue 满或关闭时，入口立即回滚 pending weight，并且仅在 route 仍是相同 `put_id`、owner replica 仍 live 时把条目重新插回 Moka；旧版本候选不会被复活。
+
+### 安全回收时序
+
+```mermaid
+sequenceDiagram
+    participant C as Moka cache controller
+    participant M as Fluxon master
+    participant O as Fluxon owner
+
+    C->>C: capacity eviction / evict_some 选择候选
+    C->>M: enqueue(key, put_id, owner, weight)
+    M->>M: 校验 route/version/backing
+    M->>M: try_install_reclaim(key)
+    alt put/get/replica 在途或已有 reclaim fence
+        M->>M: 保留 pending weight，指数退避后重试
+    else per-key activity 已静默
+        Note over M: fence 存在期间拒绝新的 put/get/replica
+        M->>O: Prepare(item, epoch, exact backing)
+        O->>O: 隐藏本地索引并检查 pending put / holder
+        alt Busy 或 Stale
+            O-->>M: Busy / Stale
+            M->>O: Abort（需要时）
+            M->>M: 当前版本仍有效则退避重试；旧版本结束 pending
+        else Prepared
+            O-->>M: Prepared
+            M->>O: Commit
+            O->>O: 校验并释放精确 slot/backing
+            O-->>M: Committed
+            M->>M: 删除相同 put_id 的 owner replica/route
+            M->>O: Finalize
+            O-->>M: Finalized
+            M->>M: 清除 master reclaim fence
+        end
+    end
+```
+
+Master 与 owner 两侧分别承担下面的正确性约束：
+
+| 约束 | 当前实现 |
+| --- | --- |
+| 并发线性化 | Master 为每个 key 统计 put/get/replica activity。只有三个计数都为零且没有其它 reclaim 时才能原子安装 reclaim fence；安装后新的 put/get/replica 不能取得 activity lease。replica append 在完整任务期间持有 lease，避免远端副本尚未完成时回收 local backing。 |
+| 版本隔离 | 每个候选携带 `put_id` 和 reclaim `epoch`。Master 在安装 fence 前、Prepare 后以及删除 route 前重复检查当前 route 仍是同一版本。 |
+| backing/slot 防 ABA | committed slot 必须同时匹配 owner、`grant_id`、`slot_index` 和 `slot_size`；旧驱逐请求不能释放新版本或已经复用的 slot。 |
+| 现有读者排空 | Owner Prepare 在同一个 key-control lock 下先从 `get_cached_info` 隐藏索引，阻止新本地读者；随后要求 `Arc::strong_count(mem_holder) == 1`。若已有 get/plan 持有引用，则恢复索引并返回 Busy。 |
+| 写入冲突隔离 | Owner Prepare 遇到 `local_puts`、`precommit_local_visible_info` 或 `external_pending_puts` 时返回 Busy，不会回收正在写入或尚未发布完成的 value。 |
+| 精确物理释放 | Owner Commit 持有 key-control lock，使用 `Arc::try_unwrap` 取得唯一 backing，并再次断言 slot identity 后释放 owner-side committed-slot route、resident holder 和内存引用，使该 slot 可以回到 Free。identity 不一致按内部不变量失败，而不是继续释放未知 backing；整个 grant 的 mmap/registered memory 仍按独立的 grant 生命周期回收。 |
+| route 更新顺序 | Owner Commit 释放物理 backing 后，Master 只删除相同 `put_id` 且 backing identity 相同的 replica；这个短窗口仍受 master reclaim fence 保护，对新请求不可访问。Master 更新 route 后才 Finalize owner fence。 |
+| 幂等与失败关闭 | Prepare/Commit/Abort/Finalize 都按 `item + epoch` 判定已应用状态。Prepare 或 Commit RPC 不确定时通过 Abort 查询/收敛；如果 owner 已经 Commit，则不能回滚 backing，而是继续删除 route 并 Finalize。Abort/Finalize RPC 失败会退避重试；未收敛时保留 fence，优先阻塞该 key 而不是暴露已释放内存。 |
+| 失败候选收敛 | 暂时 Busy 的当前版本保持 pending 并退避重试，不立即插回 Moka；stale route 或版本变化直接结束 pending。只有队列关闭等无法继续推进的路径，才在 route 仍匹配 `put_id` 且 owner replica live 时重新插入，避免旧条目覆盖新版本。 |
+
+从可观察状态看，回收事务允许 Owner Commit 与 Master route 删除之间短暂存在“owner slot 已回收到 allocator、可以复用，但旧 route 对象尚在”的内部状态，但对应 key 的 master reclaim fence 在整个窗口内拒绝新操作；安装 fence 之前已经取得 lease 的 get/put/replica 又必须先结束。因此调用方不会通过该 route 访问已经释放或复用的 backing。
+
+### 副本保留语义
+
+内存/并发正确性与“驱逐后是否仍有另一份可恢复数据”是两个不同契约：
+
+- `OwnerReclaimReason::Reserve` 用于物理 NoSpace 下的 route-scan 回收。它只选择存在另一份非 tomb replica 的 key，因而 local backing 释放后仍有 recoverable replica。
+- Moka eviction listener 产生的请求使用 `OwnerReclaimReason::CapacityEviction`。当前实现允许它删除最后一份 cache replica；最后一份被删除时，Master 同时删除整个 route，后续表现为正常 cache miss。这与本文前述“KV Cache 副本可丢失，miss 后重新计算”的缓存语义一致。
+- NoSpace 处理会先调用 `evict_some`，再执行 `Reserve` route-scan；其中 `evict_some` 产生的 listener 请求仍属于 `CapacityEviction`。因此不能因为后半段 route-scan 有副本检查，就推导整个 NoSpace 兜底都保证保留 remote replica。
+- 因此，当前已经保证并发访问、版本和 slot 复用安全，但没有对所有 `CapacityEviction` 保证“local 驱逐后 remote side 一定保留一份”。write-through 已成功建立 remote replica 时可以从 remote side 恢复；replica append 尚在途时 activity lease 会阻止并发回收。
+- 如果产品契约改为“任何 local-side 主动驱逐都必须可从 remote side 恢复”，则必须让 `CapacityEviction` 对 active/local owner 同样要求 `has_recoverable_replica`，并补充无远端副本、远端 tomb、replica append 并发及 RPC 故障注入测试。不能只依赖 write-through 通常会产生远端副本这一经验条件。
+- Put `atomic_group_lens` 只保证副本准入不主动切组，不能单独证明 CPU 侧整组已经完成。下一阶段的可恢复优先驱逐需要记录组内 remote append 完成状态，并让 GPU Moka / `CapacityEviction` 优先选择已有完整 CPU 副本的 group；远端只完成部分 pages 的 group 不能作为“驱逐后仍可恢复”的依据。
+
+### 当前验证证据与覆盖边界
+
+三机 SGLang 正式压力还覆盖了 expected-capacity 与常规驱逐的组合。E16a4 使用两台 TP=2
+GPU owner 和一台 CPU-only owner，标称容量保持 128/128/256 GiB；两 GPU 各预热 207 grants，
+正式请求期间各按 pending demand 增到 208 grants。1152/1152 请求成功，QPS 4.845，两侧
+Moka 稳定在 23,296 entries / 109,924,319,232 weighted bytes，owner reserve 在继续写入时
+稳定维持约 128--170 free slots；refill timeout、NoSpace、OOM、scheduler fatal 均为 0。
+master 的 replica target 只有 CPU owner，共 19,395 个，GPU 间副本为 0。这证明预热和
+shrink 下限不改变 owner 容量，也不会阻止达到水位后的常规 `evict some` 持续回收。
+
+同拓扑 E16b 把水位和 expected payload 从 0.8/102.4 GiB 提到 0.95/121.6 GiB 后，QPS
+从 4.845 提高到 5.967，总命中从 73.67% 提高到 90.28%；Mooncake 为 6.919 QPS、
+93.05% 命中。容量对齐后只剩 2.77pp 命中差，但仍有 13.76% QPS 差距。两 GPU 的
+`init_load_back` 平均总时长分别为 80.07/52.49 ms，其中 `restore_sync` 平均
+68.46/42.33 ms、radix eviction 平均 9.66/8.31 ms，而 kernel launch 记账约 0.05 ms。
+因此 expected capacity、exact-fit 和 group 完整性都不能替代数据面优化：需要继续减少
+同步点，分析 GPU0/GPU1 restore sync 不对称，并评估 `page_first_direct` 组织方式。E16b
+仍有 26/24 次 TP transferable mismatch；common-prefix retry 是独立的命中修复，不应被当成
+剩余全部性能差距的解释。
+
+E16c 的单变量结果进一步确认了这个边界。启用 TP-invariant Put atomic-group admission 和
+TP common-prefix retry 后，总命中从 90.28% 提高到 92.76%，与 Mooncake 的 93.05% 只差
+0.29pp；TP mismatch skip 从 26/24 降到 0。但 QPS 只从 5.967 提高到 6.136，仍比
+Mooncake 低 11.32%。E16c 的 GPU0/GPU1 load-back 平均总时长仍为 80.55/53.84 ms，
+`restore_sync` 仍占 69.29/43.51 ms。结论是：atomic group 是 CPU selective replica 可消费性
+与 TP 正确收敛所必需的协议信息，但在命中率已经对齐后，主要性能工作必须转向 restore
+kernel 的同步边界、GPU radix eviction 和 page/layer 搬运顺序。
+
+后续 E16f 的逐层 restore kernel 把 Fluxon QPS 提到 6.635；E16s 的 deferred
+`release_views` 和 E16t 的整批 local-visible snapshot 继续把 QPS 提到 6.808。E16u 再为
+全 owner-local get 增加 `InlineLocal` 分支，两个独立冷栈正式轮分别为 6.754/6.760 QPS，
+1152/1152 成功且各自实际备份 3,869,056 tokens。`get_transfer` mean 已从 E16t 的
+4.192/1.957 ms 降到 0.558/0.585 ms，但冷 QPS 没有继续提高；一次复用旧 owner keys 的热轮
+达到 6.894 QPS，却只实际备份 246,976 tokens，不能作为冷 A/B。
+
+E16u 冷复测把剩余 radix eviction 进一步定位到同步 write-back。GPU0/GPU1 的
+`init_load_back` mean 为 10.621/8.399 ms，其中 eviction 为 8.859/6.688 ms；阻塞
+`_wait_for_fluxon_hostless_backup` 与 `writing_check(write_back=True)` 的累计 duration 约占
+这些 eviction 累计时间的 95.7%/90.5%。parent-chain backup mean 为 6.508/4.435 ms，主要
+由 stream sync 3.735/2.322 ms 和 `local_fast_put_start` 1.988/1.366 ms 构成。因此当前性能
+边界已经从 get transfer RPC 转到 write-back 时机与批次组织。后续优化需要在不改变 owner
+128/128/256 GiB 容量、不降低连续完整前缀命中的前提下，评估有界 proactive write-back 或
+多 radix node 共用 Put plan/一次 stream sync；单纯继续减少 get 控制面 RPC 的收益不足以
+代表冷端到端收益。
+
+### Write-through parent 依赖与驱逐时补备份
+
+hostless write-through 的 `storage_backed` 也必须满足连续前缀不变量：一个 child 只有在
+parent 已经 remote-backed 后才能成为独立可恢复节点。proactive `write_backup` 遇到 parent
+尚在途时会先提交 parent，但不会自动把 child 排队到 parent ACK 之后重试。因此 child 可能
+既没有 `storage_backed`，也没有 `storage_pending`；后续 device eviction 若直接删除该 radix
+node，会丢失仍可通过一次补写保留的前缀。
+
+驱逐时的收敛顺序应为：
+
+1. 已经 `storage_backed`：直接走 `_evict_to_fluxon_storage`。
+2. 当前 node 有 `ongoing_fluxon_hostless_backup` 或 pending ACK：只等待已有操作；成功后走
+   Fluxon tombstone。
+3. 没有可恢复副本也没有 pending：调用 `write_backup(node, write_back=True)`；该调用递归
+   补齐缺失 parent，随后 `writing_check(write_back=True)` 阻塞到 ACK。
+4. ACK 后再次检查 `_fluxon_hostless_node_storage_ready`。只有确认完整 KV（及需要时 Mamba）
+   均 remote-backed 才释放 device backing；提交失败、ACK 失败或仍不可恢复时保留原来的
+   fail-closed 删除语义。
+
+E16w 只实现第 2 步，但两台 GPU 的新分支触发均为 0，排除了“主要是 ACK 尚在途”的假设。
+E16x 补齐第 3--4 步，正式轮中 GPU0/GPU1 分别产生 118/114 条 TP-rank 同步补备份提交，
+失败为 0；其中直接 leaf completion 各 88 条，parent-chain completion 为 30/26 条。
+总命中由 E16w 的 92.38% 提高到 92.73%，增加 99,520 tokens；QPS 仅从 6.8081 降到
+6.7915。每次 load-back 的 radix eviction mean 只增加 0.169/0.127 ms。这说明按需补齐
+parent chain 可以作为正确性和命中保底，不需要把所有 write-through 操作重新变成同步写。
+
+该结果也进一步限定 atomic group 的作用边界。Mooncake 没有 Fluxon Put atomic-group
+admission，仍达到 93.05% 命中和 6.9192 QPS；E16x 在命中只低 0.323pp 时仍低 1.85% QPS。
+因此 Put atomic group 是 TP 一致准入、CPU selective replica 完整组和“有完整远端副本才
+优先驱逐”的正确性信息，但不是剩余端到端差距的充分解释。Mooncake 每次 restore 平均跨
+3.20/3.26 个 radix node，E16x 为 10.15/10.08 个；Mooncake 的命中主要经过 32 GiB 本地
+HiCache L2，Fluxon hostless 的命中主要表现为 external L3。后续数据面比较必须记录每个
+request 的实际 restore bytes、来源 locality、CUDA event 等待和合并后的 batch 数，不能仅
+比较命中率或 atomic-group 数量。
+
+E16x 的分节点指标显示剩余差距集中在 GPU0：Fluxon TTFT/E2E mean 为 1.036/1.629s，
+Mooncake 为 0.865/1.522s；GPU1 的 Fluxon 1.719/2.499s 反而略快于 Mooncake 的
+1.728/2.524s。GPU0 同时承载 Fluxon master、owner、router 和 workload，因此还需把
+restore 数据面耗时与 master/owner CPU 竞争分开测量；在证据出来前，不应通过扩大 owner
+容量或改变副本语义掩盖该不对称。
+
+E16y 对该不对称做了 NUMA 定向实验。两台 GPU 都属于 NUMA node1，但 E16x 的 GPU0/GPU1
+owner backing 分别有 128.14/97.40 GiB 落在远端 NUMA0。把 owner 与 SGLang 绑定到
+NUMA1、把 master/router/workload 绑定到 NUMA0 后，两台 owner 都有约 128.25 GiB 落在
+NUMA1；备份量、命中率和 fallback 数保持相同，QPS 从 6.7915 提高到 6.8520，与 Mooncake
+只差 0.97%。因此大块 registered host backing 的 first-touch NUMA 必须成为部署契约，而
+不能依赖进程启动瞬间的随机 CPU。
+
+但 E16y 不是最终绑核方案：GPU1 layerwise completion 降低 5.20%，GPU0 却没有改善，且
+两端 `get_start` p50/p90 因 owner 与 SGLang 共用受限 CPU 集而上升。正确的后续拆分是只让
+owner 在 GPU-local NUMA 完成大块 backing first-touch，SGLang/master/router/workload 保持
+正常调度；若需要长期绑核，再为 owner data plane 与 SGLang scheduler 分配不重叠的 core
+集合。不能把“NUMA-local memory”与“所有线程绑在同一个 NUMA CPU 集”视为同一要求。
+
+E16z 完成该拆分后，在备份量和 fallback 数不变的条件下达到 6.9007 QPS，比 E16x 提高
+1.61%，与 Mooncake 只差 0.27%；完整 1152 请求 wall 仅差 0.45s。由此 owner backing 的
+GPU-local first-touch 应固化为部署步骤，而 SGLang 不应与 owner 共用同一受限 affinity。
+steady-state owner 也不一定要永久绑核：E16z 的 `get_start` p50 仍比 unrestricted E16x 高
+约 0.5--0.6 ms。更精确的生命周期是 owner 在 segment/backing 与 expected-capacity reserve
+建立期间绑定 GPU-local NUMA，完成后把全部已有线程 affinity 放宽；first-touch 页面会保持
+原 NUMA placement，控制/RPC 线程则可以重新使用其它 CPU 和 NIC-local core。
+
+E16aa 对这一两阶段生命周期做了正式 A/B。放宽后 `get_start` p50 确实从 E16z 的
+2.55/2.60 ms 降到 2.15/2.29 ms，页面仍驻留 NUMA1；但 QPS 为 6.8902，比 E16z 低
+0.15%，没有形成端到端正收益。考虑实现和运维复杂度，当前建议采用 E16z 的简单规则：
+GPU owner 整个生命周期绑定 GPU-local NUMA CPU 集，SGLang/master/router/workload 不绑核。
+E16z 6.9007 QPS 与 Mooncake 6.9192 只差 0.27%；若后续追求稳定的亚百分比收益，应先
+增加独立冷轮重复次数和 per-request CUDA/CPU tracing，而不是继续叠加 affinity 状态切换。
+
+E16ab 随后按 E16z 配置做了独立全冷栈复测。两个 GPU owner 启动后分别有
+128.151/128.143 GiB 页面位于 NUMA1，容量、副本开关、请求序列和 active source 均未变化。
+本轮 1152/1152 成功、严格 576/576，得到 6.8812 QPS、92.72% 总命中；它比 E16z 低
+0.28%，比 Mooncake 单轮低 0.55%。两次 E16z 形态冷轮均值为 6.8909 QPS，比 Mooncake
+低 0.41%。因此原先 0.27% 差值确实落在单轮波动量级，但不能据此宣称 Fluxon 已超过
+Mooncake。两轮的 `get_start`、`init_load_back`、radix eviction、restored-node 数和
+layerwise completion 高度复现，未出现新的系统瓶颈或错误。
+
+“Fluxon 有额外优化所以理应直接超过 Mooncake”并不是有效的性能推导。Put atomic group 和
+缺失 parent 补写首先是正确性/可恢复性契约；InlineLocal、batch local-visible、deferred
+`release_views` 和 layerwise kernel 则用于抵消 external owner/hostless 路径相对进程内 L2
+的 RPC、holder 和恢复组织成本。Mooncake 对齐轮有 70.55% tokens 命中进程内本地 L2，并把
+512 GiB 五个 segment 全部作为 primary capacity，285.3 GB 数据没有发生容量驱逐；E16z/E16ab
+约 62% tokens 经过 external owner，只使用两个 128 GiB GPU owner 保存 primary，256 GiB
+CPU owner 为空。因此现有优化是在不同路径上把端到端拉平，并不是在 Mooncake 相同基线上的
+额外加速项。
+
+能够形成 Fluxon 独有容量收益的下一闭环仍是“完整 CPU 副本 -> GPU 优先驱逐该完整 group ->
+CPU 成为可恢复剩余副本”。Put `atomic_group_lens` 目前只保证准入不主动切组；replica actor
+仍逐 key append，owner/Moka 也没有完整 group 的 remote-complete 状态可用于候选排序。只有
+补齐远端整组完成记账、版本失效和 recoverable-first eviction 后，CPU 256 GiB 才会从异步
+复制开销转化为 GPU eviction 后的额外命中。这比继续压缩已经只有约 2--3 ms 的 `get_start`
+或 0.7--0.8 ms 的 radix eviction 更可能带来稳定超过 Mooncake 的收益。
+
+E16ad 进一步纠正了“配置容量”和“实际参与容量”的表述。E16z/E16ab 虽然启动了
+128/128/256 GiB 三台 owner，但 `replica_task.enabled=false`；SGLang
+`external_batch_put_start` 又直接使用 requester-local reserve，因此只有两个 GPU owner 保存
+primary，CPU owner entries 为 0。CPU 的 256 GiB 在这两轮只是注册容量，不能计作实际数据
+容量。Mooncake 对齐轮则确实把五个 segment 都作为 primary 使用，两者的容量利用语义并不
+等价。
+
+E16ad 在相同物理容量和 NUMA 配置上启用 CPU-only `kv_score_only` replica，master 严格限制
+remote target role 为 `remote_cache`，GPU 间仍无副本。由于当前 PyO3 契约令
+`write_through || !make_replica_task` 都跳过 replica，本轮 HiCache 使用 write-back。最终
+GPU0/GPU1/CPU 分别保存 121.585/121.584/142.938 GiB，CPU 有 18,296 entries，master
+记录 18,336 个 CPU target 和 0 个 GPU target，证明三台 owner 均实际进入数据面。
+
+但该轮只有 6.8124 QPS、92.69% 总命中；相对 no-replica 冷复测 E16ab，QPS 低 1.00%，
+命中低 0.03pp，同时产生约 0.517 Gbps 聚合 RDMA TX。CPU 没占满 256 GiB 是 kv-score 跳过
+低分 group 的预期结果，更关键的是这 142.938 GiB 仍为重复副本。当前 GPU capacity eviction
+没有利用“完整 CPU group 已完成”的状态选择候选，所以 CPU 写入没有转化为更多可消费命中。
+
+这里必须区分两个后续实现方向：
+
+- 若维持“CPU 只存副本”，需要补齐完整组 remote append 完成、版本失效和
+  recoverable-first GPU eviction；GPU 本地 copy 被驱逐后，CPU copy 才转化为有效扩容。
+- 若要求像 Mooncake 一样把 128+128+256 GiB 全部作为独立 primary pool，需要实现
+  requester-local first、local 压力后 spill 到 CPU 的 remote-primary batch put。当前
+  external batch commit 显式拒绝 remote primary，修改 `prefer_local_placement` 不能得到
+  该语义。
+
+因此“三 owner 都有占用”已经由 E16ad 验证；“512 GiB 都是独立有效容量”尚未成立，不能把
+副本字节与 primary 字节直接相加。
+
+### 低分 KV 提前 CPU write-back 策略
+
+SGLang Fluxon HiCache 新增显式准入策略 `kv_score_low_only`。它保留 GPU requester-local
+owner 上的 primary，同时为低分 KV atomic group 提前创建 replica task；三机 CPU-only
+拓扑由 master 的 `remote_cache` target role 约束副本只落到 CPU owner。策略本身只决定
+replica task 准入，不改变 target role、owner 容量或 GPU 间副本规则。
+
+配置示例：
+
+```json
+{
+  "replica_task": {
+    "enabled": true,
+    "admission": {
+      "policy": "kv_score_low_only",
+      "score_threshold": 0.55,
+      "min_replica_pages": 0,
+      "max_replica_pages_per_batch": 512
+    }
+  }
+}
+```
+
+该策略使用包含边界的 `score <= score_threshold`。Put 仍按 `atomic_group_lens` 作整体决策，
+同一 group 的 mask 全 true 或全 false。group priority 使用 `1 - mean(group scores)`；因此触发
+`min_replica_pages` 补选或 `max_replica_pages_per_batch` 裁剪时，优先选择最低分 group，且不会
+为了填满页数预算切开 group。原 `kv_score_only` 保持 `score >= score_threshold` 和高分优先
+语义不变。
+
+物理 storage key 继续区分 TP rank，准入 identity 则保留 TP size 并去掉 TP rank；同一逻辑
+group 在所有 TP ranks 上得到一致的低分准入结果。该实现属于 proactive CPU write-back
+admission：CPU append 成功前 GPU primary 不会提前释放，成功后当前 eviction 也尚未按
+remote-complete group 排序。完整的“低分提前写回 -> GPU `evict some` 优先回收已完整备份组
+-> CPU 副本承担后续恢复”闭环仍需 remote-complete 记账、版本失效和 recoverable-first
+eviction。
+
+E16ae 已用与 E16ad 相同的 128/128/256 GiB、双 TP=2、owner-only NUMA1 和 1152 请求配置
+完成低分策略正式压力。1152/1152 成功，QPS 为 6.8073，总命中 92.72%；E16ad 高分策略为
+6.8124 QPS、92.69% 命中，差异分别为 -0.075% 和 +0.03pp。低分策略把 CPU retained usage
+从 142.938 GiB 提高到 243.188 GiB，历史 CPU targets 从 18,336 提高到 42,214，聚合 RDMA
+TX 从 0.517 提高到 1.189 Gbps，但没有得到可测的吞吐或命中收益。两 GPU 仍各保存约
+121.570 GiB primary，GPU replica target 为 0；CPU cache 已达到 95% effective capacity。
+这进一步证明 admission 选择本身不能替代 recoverable-first eviction：额外 CPU 副本在当前
+消费路径上仍主要体现为重复容量和写流量。
+
+Mooncake 对齐轮也必须按相同抽象层解释。SGLang 启动参数是
+`--hicache-write-policy write_back`，安装版 Mooncake `ReplicateConfig()` 默认
+`replica_num=1`。Mooncake master 管理 120,928 keys，每个对象 2,359,296 bytes；乘积
+285,304,946,688 bytes 与 master allocated bytes、五个 segment allocated bytes 之和完全
+相等。这证明 global store 中每个对象只有一份，五个 segment 共同承担单份对象的 placement。
+它不是“GPU segment 保留 primary，再 write-through 一份 CPU replica”。
+
+因此更严格的路径映射是：Mooncake 的 SGLang device/L2/L3 采用 write-back demotion，global
+store 的 512 GiB 提供单份对象容量；Fluxon E16ad 则在 GPU owner primary 仍存在时异步写
+CPU replica。二者都可能在层间迁移瞬间短暂同时持有数据，但稳态容量语义不同。若目标是复刻
+Mooncake 同时发挥 Fluxon 的统一管理优势，Fluxon 更合适的实现是 local owner 到 CPU owner
+的 single-copy demotion/spill：CPU commit 成功后删除 local copy，而不是长期保留两份。
+recoverable-first replica eviction 可以作为现有协议的过渡实现，但验收最终应统计单份逻辑
+字节、物理总字节和迁移后 source 删除，不能只统计 CPU entries 非零。
+
+### Master 两级 Moka 提前写回
+
+Master 新增可选的包含式两级 Moka，用 master Moka 的实际容量淘汰序列代替 Put 时的 score
+预测。这里的 T1/T2 是
+Fluxon master 的 owner route 元数据层级，不是 SGLang HiCache 的 GPU L1 / host L2：
+
+| 层级 | 容量 | 淘汰动作 | 是否释放 owner 数据 |
+| --- | --- | --- | --- |
+| T1 hot tier | `replica_writeback_tier1_capacity_ratio × owner segment` | 批量通知源 owner 发起 remote-only replica task | 否 |
+| T2 resident tier | `replica_cache_capacity_ratio × owner segment` | 进入现有 fenced owner reclaim | 是 |
+
+T1 是 T2 的热数据子集。新 route 同时进入 T2 和 T1，因此启用 T1 不会从 T2 切走容量，也不会
+改变 owner 的 `max_capacity`。经 master get 路径观察到的 T2 命中会把对应 key 重新提升到
+T1。T1 因容量发生 `Size` 淘汰时，master 按源 owner 合并请求，再通过内部
+`BatchEnqueueReplicaTaskReq` 通知 owner。
+Owner 继续复用已有的 `put_append_start -> RDMA transfer -> put_append_done` replica actor；目标仍
+由 `replica_task_placement` 选择。启用两级写回时，配置校验要求
+`restrict_to_remote_only_node_roles=true`，防止写回落到另一个 GPU owner。
+
+```mermaid
+sequenceDiagram
+    participant M as Fluxon master T1/T2
+    participant G as GPU owner
+    participant C as remote CPU owner
+
+    G->>M: publish local route
+    M->>M: insert T2 resident + T1 hot
+    M->>M: T1 Size eviction
+    M->>G: BatchEnqueueReplicaTaskReq(key, put_id)
+    G->>M: put_append_start
+    M-->>G: reserve CPU target
+    G->>C: RDMA transfer
+    G->>M: put_append_done
+    M->>M: append CPU replica route
+    Note over M,G: GPU owner source remains in T2
+    M->>G: later T2 fenced reclaim
+```
+
+Master 配置示例：
+
+```yaml
+replica_task_placement:
+  remote_only_node_roles: ["remote_cache"]
+  restrict_to_remote_only_node_roles: true
+replica_cache_capacity_ratio: 0.95
+replica_writeback_tier1_capacity_ratio: 0.75
+```
+
+`replica_writeback_tier1_capacity_ratio` 必须大于 0，且严格小于
+`replica_cache_capacity_ratio`。不配置该字段时保留原单层 resident Moka 行为。以
+128 GiB owner、T2 `0.95`、T1 `0.75` 为例，owner resident 上限仍约为 121.6 GiB；约 25.6
+GiB 的 T1/T2 容量差提供 replica 完成窗口，而不是把 owner 容量降到 96 GiB。
+Master 的周期日志同时报告 `writeback_tier1_triggered`、
+`writeback_tier1_owner_accepted` 和 `writeback_tier1_failed`。其中 accepted 只表示源 owner
+已把任务放入 replica actor，CPU route 是否完成仍以 `replica_task_target_counts` 和
+`put_append_done appended=true` 为准。
+
+当前实现仍是过渡策略，边界如下：
+
+- T1 淘汰只启动逐 key remote replica，尚未记录 SGLang radix atomic group，也没有整组完成
+  状态。
+- Owner `InlineLocal` fast path 当前不经过 master get，因此这类本地命中不会刷新 T1；当前顺序
+  是 master 可观察的 insert/get 淘汰序列，不是所有 SGLang 访问的全局 LRU。
+- CPU replica 完成后不会立即删除 GPU owner source；source 只有在后续 T2 reclaim 时释放。
+- 该策略能让写回时机跟随 master 实际热度淘汰，并为异步复制提供有界提前量；它尚未实现
+  Mooncake 式 single-copy demotion。
+- 运行该策略时，SGLang Put 侧应关闭 `kv_score_only` / `kv_score_low_only` eager admission，
+  避免同一 key 同时由 Put admission 和 T1 淘汰重复请求副本。
+
+#### E16ag 三机验收结果
+
+首轮 E16af 虽然成功解析 T1/T2 比例，但把 source eligibility 错误绑定到
+`prefill/decode` active-client role。实际 GPU storage owner 的 role 是 `sglang_owner`，因此
+两台 GPU 都没有构造 T1。E16ag 把资格修正为“已注册且非 `remote_cache` 的 owner”，从而
+允许 GPU storage owner 作为写回源，同时继续排除纯 CPU owner。
+
+E16ag 在固定 GPU0/GPU1/CPU = 128/128/256 GiB、双 TP=2、96 sessions × 12 turns、
+concurrency 16 的正式三机压力中得到 1152/1152 成功、6.8151 QPS、92.74% 总命中。两台
+GPU 的 resident weighted bytes 均为 121.570 GiB，T2 上限仍为 121.600 GiB；T1 均为
+95.977 GiB，上限为 96 GiB。因此包含式 T1 没有改变 owner 配置容量，也没有把 T2 降到
+T1 容量。
+
+CPU 最终持有 13,061 entries / 102.039 GiB，历史完成 13,090 个 replica targets，目标全部是
+`remote_cache` CPU，GPU target 为 0。流水线计数满足：
+
+```text
+T1 triggered 16525
+  = pre-dispatch stale 226
+  + owner source-missing/version-mismatch 1209
+  + owner accepted 15090
+
+owner accepted 15090
+  = target KeyBeingWritten 2000
+  + CPU replica completed 13090
+```
+
+这说明策略已经生效，版本检查也正确阻止了过期 source 被复制；同时暴露了两个明确窗口。
+第一，T1 淘汰事件入队后，source 可能先被 T2 回收，现有 holder 获取发生得太晚。第二，owner
+接单只表示任务进入 replica actor，目标侧相同 key 仍可能处于写入中。下一版应在 T1 eviction
+时为相同 `put_id` 安装短期 source pin，复制完成/失败后释放，并对 `KeyBeingWritten` 做有界、
+版本安全的重试。观测上应把 pre-dispatch stale、source missing 和 busy key 分开计数，不能只
+用 `writeback_tier1_failed` 聚合。
+
+性能上，E16ag 相对无 T1 的 E16af 提高 0.75%，但相对 no-replica E16ab 低 0.96%，相对
+Mooncake 低 1.50%。CPU 副本物理存在不等于形成额外可消费命中：当前 source 在 T2 前仍保留，
+CPU 字节主要是暂时重复容量；逐 key 成功也不能证明完整 radix group 可恢复。因此 source pin /
+busy-key retry 解决复制完成率之后，仍需记录 atomic group remote-complete，并让 T2
+recoverable-first eviction 优先选择已有完整 CPU 副本的 group，才能把 CPU 容量稳定转化为
+命中收益。
+
+### Owner-local hot Moka 提前写回
+
+当前实现把提前写回的热度观察点下沉到 storage owner。每个 GPU owner 维护一个逐 key 的
+owner-local hot Moka；本地 committed value 进入该 tier，`InlineLocal` 等 owner 本地命中会刷新
+热度。hot tier 发生 `RemovalCause::Size` 时，owner 立即 pin 当前 `put_id` 的 backing，再把该
+value 交给现有 replica actor 异步写入 remote CPU owner。Master T2 resident Moka 仍是唯一的
+物理回收决策入口。
+
+```mermaid
+sequenceDiagram
+    participant S as SGLang / external client
+    participant G as GPU storage owner
+    participant H as owner-local hot Moka
+    participant M as Fluxon master T2
+    participant C as remote CPU owner
+
+    S->>G: local commit(key, put_id)
+    G->>H: insert weak entry(key, put_id, slot_size)
+    S->>G: InlineLocal hit
+    G->>H: touch current entry
+    H->>G: Size eviction(key, put_id)
+    G->>G: key fence + version check + Arc pin
+    G->>M: put_append_start(key, put_id)
+    M-->>G: reserve remote-only target
+    G->>C: RDMA transfer
+    G->>M: put_append_done
+    M->>M: append CPU replica route
+    alt owner-hot demotion intent 且完整 TP cohort 可从同一 CPU owner 恢复
+        M->>M: Size-evict exact source cohort
+        M->>G: fenced Prepare / Commit / Finalize
+        G-->>M: release current local backing
+    else append/版本/整组检查失败或 CPU NoSpace
+        M-->>G: retain GPU source
+    end
+    G->>G: release pin and inflight dedup guard
+```
+
+Owner 配置只增加一个 canonical 参数：
+
+```yaml
+replica_writeback_hot_capacity_ratio: 0.75
+```
+
+该比例必须有限且位于 `(0, 1)`，并且只能出现在非零容量 owner 配置中。hot Moka 的
+`max_capacity` 等于该比例乘 owner DRAM；128 GiB owner 配置 `0.75` 时，逻辑 hot 水位为
+96 GiB。这个计算不修改 `contribute_to_cluster_pool_size.dram`、local-reserve grant 数量、owner
+segment 或 master T2 的 `replica_cache_capacity_ratio`。Moka value 只保存
+`Weak<MemoryInfo>`；所有 hot entries 因而不会整体 pin 住 owner backing。计费优先使用
+local-reserve 的实际 `slot_size`，普通 allocation 使用 payload length。
+
+CPU-only 目标仍由 master 的 placement 契约提供：
+
+```yaml
+replica_task_placement:
+  remote_only_node_roles: ["remote_cache"]
+  restrict_to_remote_only_node_roles: true
+replica_cache_capacity_ratio: 0.95
+# replica_writeback_tier1_capacity_ratio 不配置
+```
+
+第一版实验必须关闭 master T1 和 SGLang Put 侧的 eager replica admission，避免同一个 key 有
+多个独立提前写回触发器。owner hot tier 只决定写回时机；如果 master 没有限定
+`remote_only_node_roles`，目标仍可能由普通 placement 选到其它 owner。
+
+并发与失败处理遵守下面的不变量：
+
+| 场景 | 当前处理 |
+| --- | --- |
+| hot eviction 与 T2 reclaim 竞争 | 两者使用同一个 `owner_key_control` fence。reclaim 先取得 fence 时，hot eviction 放弃 stale source；hot eviction 先 clone `Arc` 时，reclaim 的唯一强引用检查返回 Busy，等 replica 任务释放 pin 后再重试。 |
+| 版本替换、delete、显式失效 | eviction listener 只消费 `RemovalCause::Size`。`Replaced` 和 `Explicit` 不创建 replica；reclaim/delete 按 `put_id` 条件失效 hot entry，不能删除随后安装的新版本。 |
+| 旧事件与重复事件 | listener 同时校验 `put_id` 和 `MemoryInfo` identity；dispatcher 入队前再次校验当前 owner index。`(key, put_id)` guard 覆盖排队、transfer 和 append-done 全周期。 |
+| 控制面阻塞 | Moka callback 只完成 fence 内 pin 和容量 4096 的事件队列 `try_send`，不等待 RPC/RDMA；dispatcher 再进入现有容量 128 的 replica task queue。事件队列满时计入 dispatch-failed 并立即释放 pin，避免积压事件阻止 T2 reclaim。 |
+| append start busy key | owner-hot 任务遇到 `KeyBeingWritten` 时最多尝试 3 次，重试间隔为 25/50 ms。其它错误不做这一层重试；最终失败释放 pin，保留 GPU primary，不会把失败任务解释为 CPU replica 已完成。 |
+| 可观察性 | owner 每 30 秒记录 hot capacity/weighted bytes、Size eviction、enqueued/completed/already-satisfied/failed/obsolete、dispatch-failed、inflight 以及 stale/reclaim/duplicate skip 计数。CPU 数据面完成仍以 `put_append_done appended=true` 和 master target 计数为准。 |
+
+E16ah 的第一版实现修复了 master T1 的两个直接缺口：source 在 eviction callback 内完成 pin，
+且 owner `InlineLocal` 命中能参与热度更新；当时仍是逐 key proactive replica write-back，CPU
+append 成功后不会直接删除 GPU source。后续版本把 Put atomic group 存入 route，并让 owner
+在任一 group member 被 hot Moka 淘汰时 pin、排队完整 group。Master 进一步按 canonical
+`_<tp_rank>_<tp_size>` 后缀验证所有 TP rank 的逻辑 group 边界及同一 CPU owner 上的完整副本。
+
+E16ap 在该完整性信息之上增加 single-copy demotion。只有 owner-hot 任务的内部 append 请求
+携带 demotion intent；普通 eager replica 不携带。append 成功或同版本 CPU route 已存在时，
+Master 再次验证 source 版本、atomic group、TP cohort 和共同 `remote_cache` owner，然后以
+`RemovalCause::Size` 从 resident Moka 选择该 exact cohort，复用既有两阶段 fenced reclaim。
+检查不通过、CPU NoSpace、append 失败或版本变化时保留 GPU source。该路径不新增用户侧副本
+开关，也不修改 owner segment、local-reserve grant 或 `contribute_to_cluster_pool_size.dram`。
+
+#### E16ah 三机验收结果
+
+E16ah 在固定 GPU0/GPU1/CPU = 128/128/256 GiB、96 sessions × 12 turns、concurrency 16
+的三机正式压力中得到 1152/1152 成功、6.8174 QPS 和 92.96% 总命中。两个 GPU owner 的
+T2 resident 均为 121.570 GiB，上限仍为 121.600 GiB；两个 owner-local hot Moka 上限均为
+96 GiB。CPU 终态持有 19,538 entries / 152.641 GiB。Master T1 容量为 0，SGLang eager
+replica 关闭，19,658 个历史 replica target 全部指向 CPU `remote_cache` owner。
+
+两个 GPU 的 `pending_eviction_reclaim_bytes` 终态分别为 4.500/4.406 GiB，且 workload 结束
+超过 15 分钟后仍未下降；E16ab 为 0/0，E16ag 为 0.125/0 GiB。它不改变 128 GiB owner
+配置或 121.6 GiB resident T2 上限，但代表已从 Moka 淘汰、尚未完成 owner reclaim 的权重，
+会消耗 segment headroom。高峰期 owner 拒绝原因为 active holder，终态 hot inflight 已归零，
+后续 retry 却没有再到达 owner phase。当前观测还不能区分 master key-activity fence 泄漏和
+reclaim retry 停滞，因此 local-side 物理回收尚未完全闭环。
+
+终态流水线满足：
+
+```text
+44626 Size eviction = 43762 enqueued + 864 duplicate
+43762 enqueued = 19658 completed + 24103 already-satisfied + 1 failed
+19658 completed = 19658 master CPU replica targets
+```
+
+stale、reclaim、obsolete、dispatch-failed 和 inflight 均为 0。相较 E16ag，dispatch 前 stale
+与 source-gone/version-mismatch 从 226/1,209 降为 0，最终 `KeyBeingWritten` 丢失从 2,000
+降为 1；这验证了 owner callback 内立即 pin 和有界 busy retry。唯一失败是一个 key 在三次
+append-start 尝试后仍处于 `KeyBeingWritten`；transfer 和 append-done failure 均为 0。
+
+性能上，E16ah 相对 E16ag QPS 只提高 0.034%，相对 no-replica E16ab 低 0.93%，相对
+Mooncake 低 1.47%。总命中相对 E16ag 提高 0.218 pp，与 Mooncake 只差 0.089 pp，但单轮变化
+不能全部归因于 CPU；当前 get 指标还没有按 source owner 拆分。owner-local hot Moka 已修复
+副本触发和完成窗口，仍需 atomic-group remote-complete 与 recoverable-first T2 eviction 才能
+把包含式 CPU 副本稳定转成独立有效容量和吞吐收益。
+
+在启用 group-aware 淘汰前，应先给 pending reclaim 增加 master-activity、owner-holder、
+route-changed、retry-queued 和 retry-completed 分原因计数，并保证 source pin 释放后请求最终
+reclaim 或安全回插。否则 logical T2 命中和 CPU replica 完成率提高时，物理 segment headroom
+仍可能被未终结的 reclaim 占用。
+
+#### E16ai Local-side reclaim 闭环验收
+
+E16ai 在不修改 owner 容量的前提下完成了上述 pending 闭环。修复包含三个关键生命周期约束：
+
+- completed `get_holding` 只是 holder backing 的观测状态，不再作为 master 侧 reclaim 的
+  blanket veto；真实读者由 owner Prepare 对 `MemoryInfo` 强引用进行权威检查；
+- put/get/replica activity lease 在 done、revoke、TTL 和响应发送失败等终态显式幂等释放，
+  `Drop` 只作兜底，Moka retired clone 不再延迟 activity 计数；
+- `ReuseReplica` get done 只有在相同版本、相同 Allocation identity 下才把 master route 标成
+  `owner_local_indexed`，确保后续进入 owner 两阶段 reclaim，而不是错误的 master-only 删除。
+
+Capacity eviction 对 Busy 请求最多执行 8 次有界指数退避；达到上限后，只在 route 仍是同一
+`put_id` 时把当前条目安全回插 Moka。queue 关闭路径也先结束 pending weight，再按同样的
+current-version 条件回插。pending weight 使用 checked subtraction，运行时分别暴露
+master-activity、master-holder-observed、owner-holder、owner-other、route-changed、retry
+queued/completed/restored 和 reclaim-completed 计数。
+
+固定 GPU0/GPU1/CPU = 128/128/256 GiB、GPU T2 ratio 0.95、hot ratio 0.75、96 sessions ×
+12 turns、concurrency 16 的三机正式轮中，两个 GPU pending 的最大 30 秒快照为
+1.031/1.477 GiB；workload 结束后的首个快照均为 0，并在超过 12 分钟的静默观察中保持 0。
+GPU T2 resident 仍为 121.570/121.570 GiB，上限仍为 121.600/121.600 GiB。E16ah 长期残留的
+4.500/4.406 GiB 以及两个 GPU 各 12 次 local get-target NoSpace 均消失。
+
+```text
+reclaim counter                     GPU0    GPU1   total
+master activity deferred              10       7      17
+completed holder observed           5939    5707   11646
+owner real-holder deferred          5092    4978   10070
+route changed / terminal removal    3149    2996    6145
+retry queued                        5007    4583    9590
+retry completed                      965     868    1833
+bounded-retry restored                95     402     497
+reclaim completed                   3149    2996    6145
+terminal pending bytes                 0       0       0
+```
+
+这些计数是 attempt 计数，不构成逐列相加的 unique-key 等式；唯一终态要求是 pending 请求
+最终 route removal/change 或安全回插，且 pending bytes 归零。本轮没有 pending underflow、
+safe reclaim queue full/closed 或 retry queue closed。静默期 master 仍有 71 个 completed
+`get_holding` / 335,020,032 bytes；它们是 client 仍持有的真实 backing，不是 activity lease，
+也不再阻塞其它无真实 reader 的 owner reclaim。
+
+正式结果为 1152/1152 成功、6.7585 QPS、92.9691% 总命中。CPU 保留 20,717 entries /
+161.852 GiB，20,773 个历史副本目标全部指向 CPU；owner-hot 对账严格满足：
+
+```text
+46576 Size eviction = 45204 enqueued + 35 reclaim-race skip + 1337 duplicate
+45204 enqueued = 20773 completed + 24431 already-satisfied
+20773 completed = 20773 master CPU replica targets
+```
+
+E16ai 相对 E16ah QPS 低 0.865%，总命中只高 0.008 pp；因此 reclaim 闭环解决了正确性和
+物理 headroom，但没有把包含式 CPU 副本转成性能收益。atomic-group remote-complete 与
+recoverable-first T2 eviction（或 single-copy demotion）仍是下一层容量策略，不能回退上述
+activity、holder、版本和 slot identity 安全约束。
+
+#### E16ao 手动聚合回收与 E16ap 完整组降级
+
+E16ao 修复了 resident Moka 八个 segment 各自执行硬容量淘汰的问题。resident Moka 只作为
+无界 metadata/LRU index，Master 按 owner 的 0.95 聚合有效容量显式调用 `evict_some_if`；存在
+ready CPU tier 时，GPU ordinary fallback 为 0，只允许完整 TP cohort 且已有 CPU 副本的条目
+进入两阶段 reclaim。固定三机压力得到 1152/1152 成功、6.6634 QPS、92.58% 总命中和 1,240
+次 CPU-source Get。两个 GPU 的 pending reclaim 终态为 0，recoverable selected 合计约
+34.6 GB，CPU 却保留约 200.9 GB；测量窗口只从 CPU 读取 5.85 GB。该结果证明 group、TP
+cohort、CPU Get 和物理 reclaim 均已生效，同时表明大部分 CPU 字节仍是包含式重复副本。
+
+E16ap 把 owner-hot write-back 的成功终态收敛为 exact-cohort demotion，内部状态流如下：
+
+| 阶段 | 必须满足的条件 | 失败行为 |
+| --- | --- | --- |
+| hot 触发 | Moka `RemovalCause::Size`、当前 `put_id` 和 `MemoryInfo` identity 匹配，完整 owner atomic group 可 pin | 不创建任务，GPU source 保持当前状态 |
+| remote append | target 被 `remote_only_node_roles=["remote_cache"]` 限定，append 发布同版本 CPU route | NoSpace/transfer/append 失败释放 pin，不请求 source demotion |
+| cohort 验证 | 每个 atomic-group member 当前、每个 TP rank 边界一致，所有成员在同一个 CPU owner 上 live | 本次只计 attempt，不选择任何 GPU resident entry |
+| exact selection | resident descriptor 仍是预期版本且当前 route 仍可恢复 | 跳过变化条目，不能删除随后写入的新版本 |
+| 物理回收 | Moka Size listener 安装 master activity fence，再执行 owner Prepare/Commit/Finalize | Busy 有界重试；耗尽后仅把仍为当前版本的条目安全回插 |
+
+E16ap 压测把 owner hot ratio 设为 0.95，与 master resident ratio 对齐。128 GiB GPU owner 的
+逻辑触发点为 121.6 GiB；这只改变冷数据开始异步迁移的时机，不改变 128 GiB 物理 segment。
+CPU 未满时，完整冷 cohort 写入 CPU 后释放 GPU copy；CPU 无空间时，任务不降级，GPU 仍可
+使用剩余物理 headroom。Master 每 30 秒额外报告 `owner_hot_demotion_attempts`、
+`owner_hot_demotion_cohorts` 和 `owner_hot_demotion_selected_bytes`，用于区分“复制完成”与
+“已经转化为独立二级容量”。正式三机结果需要同时满足非零 demotion、CPU-source Get、两侧
+pending 归零和 QPS 高于双 GPU no-replica 基线，不能只用 CPU retained bytes 判定策略有效。
+
+两 Fluxon 模拟压测的完整记录保存在本工作区的 `remote_cpu.md`。当前一次完整压力运行得到：
+
+```text
+Moka eviction callbacks: 11463
+safe reclaim reclaimed: 11452
+safe reclaim restored: 11
+processed eviction weight: 96158613504 bytes
+```
+
+`reclaimed + restored` 与 callback 数严格相等；11 个 Busy/未回收条目按当前版本重新插回 Moka。8 个均匀抽样 key 的 payload 长度和首尾字节均校验通过，其中 3 个已确认在 A local backing 被驱逐后通过 B -> A P2P 读取恢复。该次日志中 safe reclaim queue full/closed、NoSpace 返回调用方、panic、OOM 和 batch failure 均为 0。
+
+这次稳态压力运行由按真实 slot 权重的常规 Moka capacity eviction 提前释放内存，因此没有实际触发“申请不到 `512 MiB` grant 后调用 `evict_some`”的 NoSpace 兜底。`evict_some` 另有定向 Moka 契约测试，覆盖请求驱逐量大于/小于现有占用、Busy 条目回插后的 LRU 顺序，并断言调用前后 `max_capacity` 不变。Master activity fence 和 Moka 路径已有单元测试；Owner Prepare/Commit/Abort/Finalize 的主要证据目前来自端到端压测，后续仍应补充直接的并发与故障注入单元测试。
+
+#### E16au--E16ax 包含式写回与 local IPC 结论
+
+E16au 将 owner-hot 的成功终态改为包含式 CPU write-through：CPU route 发布成功后不立即
+demote GPU source，GPU backing 只由独立的 95% resident 压力回收。固定
+GPU0/GPU1/CPU = 128/128/256 GiB 的正式压力得到 1152/1152、6.7446 QPS、92.90% 总命中；
+CPU 保留 8,793 entries / 73.761 GB，CPU-source Get 为 4,349 / 20.521 GB，owner-hot
+demotion 与终态 pending reclaim 均为 0。包含式语义消除了主动降级争用，但仍未超过双 GPU
+baseline 或 Mooncake；提前 CPU copy 大多只是已有 GPU source 的替代恢复源。
+
+这轮有 255,972 条 iceoryx2 `FailedToDeliverSignal`。开放层调低日志等级无法控制闭源
+`libfluxon_commu_core.so` 内静态链接的独立 log-level 符号；完全关闭 local IPC 又在同机
+direct P2P 路径触发 608、`KeyBeingWritten` 终态失败和 Prefill OOM。E16ax 只把
+owner/client receiver 改为 WaitSet 后虽完成 1152/1152，QPS 降至 6.6932；warning 仍有
+232,723 条，且 96.85% 移入 SGLang 关键进程。故 local IPC 必须保留，WaitSet 和完全禁用
+两条方案均不能作为当前修复。
+
+#### E16ay Get-target 压力与 local reserve 物理容量闭环
+
+local reserve 的 expected capacity 是下限而非硬上限。Put 并发需求可使它从配置的 grant 数
+继续扩张；后续 slot 回收只让 grant 内部变空，并不会自动把这段 512 MiB 物理 allocation
+归还 master segment allocator。原 shrink actor 还只检查队尾 grant，并要求连续全空 5 秒。
+另一方面，CPU -> GPU remote Get 的 target 仍是 master 直接从请求 owner 的普通 allocator
+分配。因此系统可能同时出现：
+
+- master Get target 报 `NoSpace/free_capacity=0`；
+- owner reserve 内存在大量 free slots；
+- `pending_eviction_reclaim_bytes=0`，说明这不是 safe reclaim backlog。
+
+E16ax 的实测即为 GPU0/GPU1 18/9 次 Get-target `NoSpace`，而 reserve 最终仍有 1,085/989 个
+空闲 4,718,592-byte slot。E16au 精确重扫也有 10/26 次。该错误会在 atomic-group prefix
+计算前截断可传输前缀，使已经存在的 CPU route 不能转成额外命中。
+
+修复契约如下：
+
+| 阶段 | 规则 |
+| --- | --- |
+| 首次 batch get-start | 保留每个 item 的独立结果，只收集 `API_NO_SPACE` 索引；成功项、KeyNotFound 和其它错误不重发。 |
+| 物理让位 | owner 可同步摘除任意完全空闲的多余 grant，不受队尾和 idle cooldown 限制；必须先收到 `release_local_grant` 完成，再重试 Get。 |
+| 容量下限 | 归还后 grant 数不得低于 `max(expected_grants, ceil((used_slots + pending_slot_demand) / slots_per_grant))`；Prepared、PendingLocalVisible、Committed 或仍有 holder 的 slot 都不能释放。 |
+| 有界重试 | 每轮只替换仍为 NoSpace 的 item，最多 8 轮；不能安全归还 grant 时保留原错误和 prefix fallback。 |
+| 容量语义 | 不修改 `contribute_to_cluster_pool_size.dram`、resident/hot Moka capacity 或 expected reserve；这是把已经空闲的物理 grant 及时归还 allocator，不是缩 owner 容量。 |
+
+该路径与 `evict_some` 的职责不同：本步骤优先回收“已经完全空闲但仍被 reserve 持有”的
+grant，不产生新的 KV 淘汰；若没有这种 grant，现有 safe reclaim/NoSpace 语义继续生效，不能
+为了 Get 强行释放 live backing。新增定向测试覆盖只选 NoSpace item、非队尾 grant 与容量下限。
+
+E16ay 的固定 128/128/256 GiB 三机正式验收得到 1152/1152、6.8269 QPS 和 93.02% 总命中。
+GPU0/GPU1 分别通过 2/3 次 pressure retry 恢复 30/54 个 NoSpace item，全部首轮达到
+`no_space_after=0`，没有错误传到 SGLang。CPU-source Get 为 4,942 /
+23,319,281,664 bytes；CPU 保留 8,855 entries / 74,281,123,840 bytes；两个 GPU terminal
+pending 与 owner-hot demotion 都为 0。配置的 owner 容量、resident/hot 容量和 232-grant
+expected 下限没有改变。这证明同步归还空 grant 可以闭合 Get-target 物理 headroom，但 QPS
+仍比双 GPU baseline 低 0.79%、比 Mooncake 低 1.33%。
+
+#### E16az external local-IPC busy-poll 验收
+
+E16ay 的两个 GPU owner 仍分别产生 147,124/150,701 条 iceoryx2
+`FailedToDeliverSignal`。失败的是 owner -> SGLang external 的逐消息 event notification，
+subscriber 数据本身仍存在。E16az 保持 E16ay release 与所有容量/策略/工作负载不变，仅令 GPU
+owner 和 SGLang external receiver 使用 `iceoryx_external_busy_poll=true`。此模式直接 drain
+subscriber，发送端不会创建 notifier；owner/client 内部 receiver 原有的 busy-poll 设置不变。
+
+正式轮仍为 1152/1152、576/576，四份相关日志的 `FailedToDeliverSignal` 全部为 0，GPU owner
+日志缩到约 132/137 KB。local IPC 和 RDMA 数据路径仍存活，CPU-source Get 为 4,965 /
+23,427,809,280 bytes，CPU 保留 8,610 entries / 72,225,914,880 bytes；74 个 Get-target
+NoSpace item 全部被 E16ay 路径恢复。terminal pending、surfaced NoSpace、业务 5xx、P2P 608、
+OOM 和 scheduler exception 均为 0。
+
+性能为 6.7888 QPS、93.02% 总命中，比 E16ay 低 0.56%、比双 GPU baseline 低 1.34%。因此
+事件告警格式化不是剩余吞吐主瓶颈；持续 external polling 的 CPU contention 可能抵消省下的
+日志工作，且这一小幅差值可能包含单轮波动。设计上可把 external busy-poll 作为避免 notifier
+风暴的运行模式，但不能把它视为 CPU replica 转化为吞吐收益的容量策略。下一步仍应直接减少
+包含式重复副本的无效工作，或降低 CPU Get/replica 进入 SGLang 关键路径的等待开销。
+
+#### E16ba Hot/resident lead-window 契约
+
+包含式 owner-hot write-through 不能通过简单地把 hot capacity 提到 resident capacity 来实现
+“驱逐即 write-back”。hot eviction 只产生异步 CPU append 信号；resident eviction 则要求
+CPU 上已经存在完整、同版本、同 TP cohort 的 durable backing。两者必须保留足够的 lead
+window，否则 resident pressure 会先于 remote completion 到达。
+
+固定 resident=0.95、reserve=0.90 和 128/128/256 GiB 容量，对 hot=0.92/0.94/0.95 的三次
+正式冷启动扫描结果为：
+
+| hot | QPS | CPU placement | CPU Gets | recoverable selected | shortfall |
+| ---: | ---: | ---: | ---: | ---: | ---: |
+| 0.90 E16ay | 6.826884 | 8,860 | 4,942 | 65,729,986,560 B | 0 |
+| 0.92 | 6.824876 | 7,413 | 3,214 | 51,091,865,600 B | 0 |
+| 0.94 | 6.792892 | 5,893 | 2,108 | 41,800,433,664 B | 0 |
+| 0.95 | 6.623042 | 5,341 | 1,496 | 36,394,500,096 B | 32,925,181,564 B |
+
+四轮 overall hit 都为 93.02%，因此下降不是 cache miss 数量变化。0.92 以几乎相同 QPS
+减少 16.3% placement 和 35.0% CPU Get，证明较早触发包含冗余工作；0.94 开始变慢；0.95
+请求 69,316,116,502 bytes recoverable victim 时只有 36,394,500,096 bytes 已 CPU-complete，
+QPS 相对 0.90 下降 2.99%。三轮均无 surfaced NoSpace、terminal pending、业务错误或容量变化。
+
+因此静态 hot threshold 在该 workload 下必须比 resident 至少提前约 3--5pp。若设计目标是真正
+的 eviction-time write-back，应由 resident 的精确 victim 触发 CPU append，并为该 victim
+建立有界 completion fence；或者根据 replica queue depth、传输延迟和 resident growth rate
+动态计算 lead。不能让两个独立 Moka 同阈值后依赖调度碰巧完成。
+
+#### E16bc--E16bj SGLang 调度容量、replica pipeline 与发布门禁
+
+固定 Fluxon GPU0/GPU1/CPU owner 为 128/128/256 GiB 后，端到端吞吐的最大增益并非继续改
+Moka 水位，而是解除 SGLang scheduler 的串行与 token-pool 约束。E16bc 只把每个 TP=2 服务的
+`max_total_tokens` 从 100,000 提到 200,000，QPS 从 E16bb 的 6.773531 提到 8.645063；E16cc
+再启用默认 overlap scheduler，正式冷启动达到 10.056034 QPS。该轮 1,152/1,152 成功、两端
+各 576 请求、总命中 92.96%，GPU 初始化后仍各有约 53.51 GiB 可用显存。这里的
+`max_total_tokens` 是 SGLang GPU scheduler/KV pool 参数，不修改 Fluxon owner segment、resident
+Moka、hot Moka 或 local-reserve 的容量；配置与结果记录不能把两种“容量”混为一谈。
+
+overlap scheduler 允许 HiCache restore/prefill 的调度推进与 GPU decode 工作交叠。关闭 overlap
+时，同样的外部命中率并不表示同样的吞吐，因为 storage future、prefill admission 和 decode
+会在 scheduler step 边界上串行等待。因此正式性能对比必须同时固定
+`max_total_tokens`、`disable_overlap_schedule`、CUDA graph、并发和 workload round barrier。
+
+owner replica actor 原先全局只能有一个 append pipeline 在途，每个不同 key 都依次等待
+append-start、RDMA completion 与 append-done。`test_spec_config.replica_task_max_inflight` 将其改为
+1--64 的有界跨 key 并发，默认 1 保持兼容；全局 semaphore 限制总在途数，每个 key 另有单许可
+semaphore，所以不同 key 可以并行，同 key 的版本/任务仍严格串行。E16bh 在两个 GPU owner 设为
+16，CPU owner 保持 1；该参数改变复制流水线深度，不改变 owner 容量、placement 或原子组完整性。
+
+组合发布还必须经过目标机 ABI 预检。E16bf 的 wheel 文件名虽然声明
+`manylinux_2_28_x86_64`，其中新 closed core 实际引用了 `GLIBC_2.39`，三台正式机器因此在 master
+import 阶段 fail-fast，未发送任何 workload。发布门禁应对 wheel 内每个 bundled `.so` 检查最高
+GLIBC symbol version，并在三种目标 Python/宿主环境做 import smoke；仅检查 wheel tag 或构建成功
+不足以证明可部署。兼容性回退 E16bd 保留开放层 replica pipeline，并沿用已验证 closed core。
+
+E16bj 在真实 manylinux 2.28 builder 中重建 closed core 后，通过了 wheel 内全部 `.so` 的
+symbol-version 扫描和 Python 3.10/3.11/3.12 import smoke。正式三机冷启动保持
+GPU0/GPU1/CPU = 128/128/256 GiB、GPU pipeline=16、CPU-only placement、200k token pool 和
+overlap scheduler，得到 1,152/1,152、576/576、10.045299 QPS 和 92.99% 总命中。CPU 承担
+8,770 个 replica target 与 4,990 次 remote Get；GPU replica target、终态 replica inflight、
+replica failure 和 pending reclaim 均为 0。E16cc/E16bh/E16bj 的最低和平均 QPS 为
+10.020985/10.040772，说明 10-QPS 结果可由可部署组合版本复现。
+
+E16be closed sharding 修复要求所有正长度 transfer 的 child 都非空：按 sharding quantum 做 ceil
+division并省略空 child；只有显式零长度请求保留一个零长度 child，以维持 completion contract。
+这项约束属于通信正确性和尾延迟卫生，不能用 wheel tag 代替测试，也不能从 E16bj 相对 E16bh
+仅 +0.24% 的单轮差值推导出稳定吞吐增益。
+
 ## SGLang Node Storage 状态
 
 SGLang 侧的 node metadata 不等价于 Fluxon master route 状态。当前四个字段建议按下面语义解释：
@@ -438,6 +1328,18 @@ SGLang 侧的 node metadata 不等价于 Fluxon master route 状态。当前四
 
 TP 场景下，每个 rank 仍有各自的 radix tree 和恢复决策。`get_start` 的结果只描述当前 rank 这批 keys 的可恢复前缀；如果一个 rank miss、另一个 rank hit，上层必须按 SGLang 的 TP restore 约束处理一致性，不能把单 rank 的部分成功当作完整 request 已恢复。
 
+Put admission 的随机 identity 必须跨 TP rank 稳定。物理 storage key 保留 `_0_2`、`_1_2`
+等 rank 后缀，用于区分不同 rank 的 KV bytes；ratio/score jitter 和 atomic-group hash 则使用
+保留 TP size、去掉 TP rank 的 admission key。同一个逻辑 radix group 因而在所有 TP ranks
+上得到同一 admitted/skipped 决策，同时仍生成不同物理 keys。只约束单 rank 内 mask 不切组，
+无法满足这个跨 rank 不变量。
+
+各 rank 首次 `get_start` 的 `transferable_len` 不一致时，SGLang 先用 collective 取最小值。
+该最小值必须落在共同的 atomic-group 边界；每个 rank 取消原 handle，再以该最小完整-group
+前缀重新执行一次 `get_start`，随后再次 collective 校验长度一致。第二次仍不一致才放弃本轮
+restore。不能直接使用较长 rank 的 handle，也不应因为尾部差异把两个 rank 已共同命中的
+前缀全部作废。
+
 ## 失败处理
 
 | 场景 | 必须动作 |
diff --git a/fluxon_py/config.py b/fluxon_py/config.py
index 5861f64..74f8746 100644
--- a/fluxon_py/config.py
+++ b/fluxon_py/config.py
@@ -66,6 +66,7 @@ def _yaml_template():
   protocol_type:                       # Protocol type (('tcp'|'rdma'))
   rdma_device_names:                   # Explicit RDMA devices for protocol config (['{str}'](optional))
 pprof_duration_seconds:                # Dump pprof flamegraph after N seconds (int(optional))
+replica_writeback_hot_capacity_ratio: 0.75 # Owner-local hot working-set ratio in the open interval zero to one (float(optional))
 contribute_to_cluster_pool_size:       # Capacity contributed to cluster pool (dict(optional))
   dram: 1677721600                     # - DRAM contribution (int(multiple of 16777216))
   vram:                                # - VRAM contribution per GPU (dict(dynamic_key))
@@ -82,11 +83,17 @@ def _yaml_template():
   prefer_local_placement: false        # Prefer placing new KV writes on the requester-local owner when possible (bool(optional))
   short_circuit_put_payload_path: false # Keep large put_start allocation but skip payload memcpy + transfer (bool(optional))
   skip_put_end_commit: false           # Return success after payload transfer without put_done commit; inflight_put TTL cleanup only (bool(optional))
+  owner_local_reserve_soft_wait_timeout_ms: # Local-reserve polling interval, >0 (int(optional))
+  owner_local_reserve_hard_timeout_ms: # Local-reserve end-to-end claim timeout, > soft wait (int(optional))
+  owner_local_reserve_expected_capacity: # Owner-only local-reserve prewarm target (dict(optional))
+    value_len:                         # Canonical value payload bytes, >0 and <=512 MiB (int)
+    payload_capacity_bytes:            # Expected payload capacity to keep resident, >0 (int)
   transport_mode:                      # transfer_only|transfer_with_rpc (str(optional))
   tcp_thread_reactor_shard_count:      # tcp_thread reactor shard count, 1..16 (int(optional))
   tcp_thread_bulk_lane_count:          # tcp_thread bulk lane count, 1..8 (int(optional))
   tcp_thread_control_lane_count:       # tcp_thread control lane count, 1..8 (int(optional))
   user_rpc_sync_handler_thread_count:  # Owner-dedicated sync user-RPC worker thread count, >0 (int(optional))
+  replica_task_max_inflight:           # Concurrent replica append pipelines, 1..64; per-key order stays serialized (int(optional))
   require_transfer_rpc_fast_path_ready_timeout_seconds: # Require owner-owner transfer-rpc fast path before owner ready/shared.json publication (int(optional))
   rdma_device_names:                   # Explicit RDMA devices for benchmark/test fast-path fanout (['{str}'](optional))
   enable_side_transfer: false          # Enable TCP side-transfer fast-path (bool(optional))
@@ -135,11 +142,15 @@ def _normalize_test_spec_config(raw: Any, ctx: str) -> Dict[str, Any]:
         "prefer_local_placement",
         "short_circuit_put_payload_path",
         "skip_put_end_commit",
+        "owner_local_reserve_soft_wait_timeout_ms",
+        "owner_local_reserve_hard_timeout_ms",
+        "owner_local_reserve_expected_capacity",
         "transport_mode",
         "tcp_thread_reactor_shard_count",
         "tcp_thread_bulk_lane_count",
         "tcp_thread_control_lane_count",
         "user_rpc_sync_handler_thread_count",
+        "replica_task_max_inflight",
         "require_transfer_rpc_fast_path_ready_timeout_seconds",
         "rdma_device_names",
         "enable_side_transfer",
@@ -234,6 +245,7 @@ def _normalize_test_spec_config(raw: Any, ctx: str) -> Dict[str, Any]:
         ("tcp_thread_reactor_shard_count", 1, 16),
         ("tcp_thread_bulk_lane_count", 1, 8),
         ("tcp_thread_control_lane_count", 1, 8),
+        ("replica_task_max_inflight", 1, 64),
     ):
         value = raw.get(key)
         if value is None:
@@ -254,6 +266,50 @@ def _normalize_test_spec_config(raw: Any, ctx: str) -> Dict[str, Any]:
             raise ValueError(f"{ctx}.user_rpc_sync_handler_thread_count must be > 0")
         out["user_rpc_sync_handler_thread_count"] = user_rpc_sync_handler_thread_count
 
+    reserve_timeouts: Dict[str, int] = {}
+    for key in (
+        "owner_local_reserve_soft_wait_timeout_ms",
+        "owner_local_reserve_hard_timeout_ms",
+    ):
+        value = raw.get(key)
+        if value is None:
+            continue
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise ValueError(f"{ctx}.{key} must be an int")
+        if value <= 0:
+            raise ValueError(f"{ctx}.{key} must be > 0")
+        reserve_timeouts[key] = value
+        out[key] = value
+    soft_timeout_ms = reserve_timeouts.get("owner_local_reserve_soft_wait_timeout_ms", 10)
+    hard_timeout_ms = reserve_timeouts.get("owner_local_reserve_hard_timeout_ms", 10_000)
+    if hard_timeout_ms <= soft_timeout_ms:
+        raise ValueError(
+            f"{ctx}.owner_local_reserve_hard_timeout_ms must be greater than "
+            f"{ctx}.owner_local_reserve_soft_wait_timeout_ms"
+        )
+
+    expected_capacity = raw.get("owner_local_reserve_expected_capacity")
+    if expected_capacity is not None:
+        expected_ctx = f"{ctx}.owner_local_reserve_expected_capacity"
+        if not isinstance(expected_capacity, dict):
+            raise ValueError(f"{expected_ctx} must be a mapping")
+        unknown_expected = sorted(
+            set(expected_capacity.keys()) - {"value_len", "payload_capacity_bytes"}
+        )
+        if unknown_expected:
+            raise ValueError(f"{expected_ctx} contains unknown keys: {unknown_expected}")
+        normalized_expected: Dict[str, int] = {}
+        for key in ("value_len", "payload_capacity_bytes"):
+            value = expected_capacity.get(key)
+            if isinstance(value, bool) or not isinstance(value, int):
+                raise ValueError(f"{expected_ctx}.{key} must be an int")
+            if value <= 0:
+                raise ValueError(f"{expected_ctx}.{key} must be > 0")
+            normalized_expected[key] = value
+        if normalized_expected["value_len"] > 512 * 1024 * 1024:
+            raise ValueError(f"{expected_ctx}.value_len must be <= 536870912")
+        out["owner_local_reserve_expected_capacity"] = normalized_expected
+
     side_transfer_worker_count = raw.get("side_transfer_worker_count")
     if side_transfer_worker_count is not None:
         if isinstance(side_transfer_worker_count, bool) or not isinstance(side_transfer_worker_count, int):
@@ -348,6 +404,23 @@ def _validate_fluxonkv_contract(cfg: Dict[str, Any]) -> None:
         raise ValueError("fluxonkv_spec must be a mapping")
 
     is_zero_contribution = _is_zero_contribution_fluxonkv_config(cfg)
+    test_spec_config = cfg.get("test_spec_config") or {}
+    expected_capacity = test_spec_config.get("owner_local_reserve_expected_capacity")
+    hot_capacity_ratio = cfg.get("replica_writeback_hot_capacity_ratio")
+
+    if hot_capacity_ratio is not None:
+        if isinstance(hot_capacity_ratio, bool) or not isinstance(
+            hot_capacity_ratio, (int, float)
+        ):
+            raise ValueError(
+                "replica_writeback_hot_capacity_ratio must be a number in (0, 1)"
+            )
+        hot_capacity_ratio = float(hot_capacity_ratio)
+        if not 0.0 < hot_capacity_ratio < 1.0:
+            raise ValueError(
+                "replica_writeback_hot_capacity_ratio must be finite and in (0, 1)"
+            )
+        cfg["replica_writeback_hot_capacity_ratio"] = hot_capacity_ratio
 
     share_mem_path = spec.get("share_mem_path")
     if not isinstance(share_mem_path, str) or not share_mem_path.strip():
@@ -360,6 +433,14 @@ def _validate_fluxonkv_contract(cfg: Dict[str, Any]) -> None:
         raise ValueError("fluxonkv_spec.transfer_engine has been removed from Fluxon KV config")
 
     if is_zero_contribution:
+        if hot_capacity_ratio is not None:
+            raise ValueError(
+                "replica_writeback_hot_capacity_ratio is only valid on owner configs"
+            )
+        if expected_capacity is not None:
+            raise ValueError(
+                "test_spec_config.owner_local_reserve_expected_capacity is only valid on owner configs"
+            )
         forbidden_spec_keys = [
             "etcd_addresses",
             "redis_compat",
@@ -379,6 +460,23 @@ def _validate_fluxonkv_contract(cfg: Dict[str, Any]) -> None:
     if int(contrib["dram"]) == 0:
         raise ValueError("owner mode requires non-zero contribute_to_cluster_pool_size.dram")
 
+    if expected_capacity is not None:
+        value_len = int(expected_capacity["value_len"])
+        payload_capacity_bytes = int(expected_capacity["payload_capacity_bytes"])
+        slot_size = max(value_len, 4096)
+        slot_size = (slot_size + 4095) & ~4095
+        slots_per_grant = (512 * 1024 * 1024) // slot_size
+        value_count = (payload_capacity_bytes + value_len - 1) // value_len
+        expected_grants = (value_count + slots_per_grant - 1) // slots_per_grant
+        physical_reserve_bytes = expected_grants * 512 * 1024 * 1024
+        owner_dram_bytes = int(contrib["dram"])
+        if physical_reserve_bytes > owner_dram_bytes:
+            raise ValueError(
+                "test_spec_config.owner_local_reserve_expected_capacity requires "
+                f"{physical_reserve_bytes} physical bytes across {expected_grants} grants, "
+                f"exceeding owner dram contribution {owner_dram_bytes}"
+            )
+
     if "etcd_addresses" not in spec:
         raise ValueError("fluxonkv_spec.etcd_addresses is required for owner mode")
     etcd_addresses = spec.get("etcd_addresses")
@@ -434,6 +532,10 @@ def __init__(self, config_dict: Dict[str, Any]):
             raise ValueError(
                 "exactly one of [mooncake_spec, fluxonkv_spec] is required (and the chosen spec must not be null)"
             )
+        if "replica_writeback_hot_capacity_ratio" in plain and not has_fluxon:
+            raise ValueError(
+                "replica_writeback_hot_capacity_ratio requires fluxonkv_spec"
+            )
 
         pprof_duration_seconds = plain.get("pprof_duration_seconds")
         if pprof_duration_seconds is None:
@@ -750,8 +852,8 @@ def parse_type_recursive(type_str: str) -> Optional[Tuple[str, Dict[str, Any]]]:
                         return parsed_type_name, merged_params
                     return type_name, {"constraint": constraint}
         
-        # 6) Primitive types: str, int, bool, None
-        if type_str in ["str", "int", "bool", "None"]:
+        # 6) Primitive types: str, int, float, bool, None
+        if type_str in ["str", "int", "float", "bool", "None"]:
             return type_str, {}
         
         debug_print("type_str ", type_str, "not matched to any type")
@@ -871,7 +973,16 @@ def raise_validation_error(msg: str):
                             raise_validation_error(f"Value must be multiple of {multiple}, got {value}")
                         else:
                             return None
-    
+
+    elif type_name == "float":
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            if raise_err:
+                raise_validation_error(
+                    f"Expected float-compatible number, got {type(value).__name__}"
+                )
+            else:
+                return None
+
     elif type_name == "bool":
         if not isinstance(value, bool):
             if raise_err:
diff --git a/fluxon_py/kvclient/fluxon.py b/fluxon_py/kvclient/fluxon.py
index ae9df9a..c794c63 100644
--- a/fluxon_py/kvclient/fluxon.py
+++ b/fluxon_py/kvclient/fluxon.py
@@ -55,6 +55,63 @@
 
 _SIDE_TRANSFER_WORKER_PYTHON_ENV = "FLUXON_KV_SIDE_WORKER_PYTHON"
 _BLOCKING_PUT_OUTER_TOTAL_LOG_INTERVAL_NS = 10 * 1_000_000_000
+_MIN_EXPLICIT_RPC_TIMEOUT_MS = int(fluxon_pyo3.MIN_EXPLICIT_RPC_TIMEOUT_MS)
+
+
+def _validate_explicit_rpc_timeout_ms(timeout_ms: int) -> None:
+    if not isinstance(timeout_ms, int):
+        raise InvalidArgumentError(message=f"timeout_ms must be int; got {type(timeout_ms)}")
+    if timeout_ms < _MIN_EXPLICIT_RPC_TIMEOUT_MS:
+        raise InvalidArgumentError(
+            message=(
+                f"timeout_ms must be >= {_MIN_EXPLICIT_RPC_TIMEOUT_MS}; "
+                f"got {timeout_ms}"
+            )
+        )
+
+
+def _validate_put_atomic_groups(
+    keys: List[str],
+    atomic_group_lens: Optional[List[int]],
+    make_replica_task_mask: Optional[List[bool]],
+) -> Optional[List[int]]:
+    if atomic_group_lens is None:
+        return None
+    if not isinstance(atomic_group_lens, list):
+        raise ValueError(
+            "atomic_group_lens must be list[int] when provided; "
+            f"got {type(atomic_group_lens)}"
+        )
+    normalized_group_lens: List[int] = []
+    for index, length in enumerate(atomic_group_lens):
+        if type(length) is not int:
+            raise ValueError(
+                "atomic_group_lens items must be int; "
+                f"index={index} got={type(length)}"
+            )
+        if length <= 0:
+            raise ValueError(
+                "atomic_group_lens entries must be > 0; "
+                f"index={index} got={length}"
+            )
+        normalized_group_lens.append(length)
+    group_sum = sum(normalized_group_lens)
+    if group_sum != len(keys):
+        raise ValueError(
+            "atomic_group_lens must sum to keys length; "
+            f"sum={group_sum} keys={len(keys)}"
+        )
+    if make_replica_task_mask is not None:
+        offset = 0
+        for group_index, group_len in enumerate(normalized_group_lens):
+            group_mask = make_replica_task_mask[offset : offset + group_len]
+            if any(item != group_mask[0] for item in group_mask[1:]):
+                raise ValueError(
+                    "make_replica_task_mask must be uniform within each atomic group; "
+                    f"group_index={group_index} offset={offset} len={group_len}"
+                )
+            offset += group_len
+    return normalized_group_lens
 
 
 def _percentile_nearest_rank_ns(sorted_values: List[int], percentile: int) -> int:
@@ -480,6 +537,9 @@ def put(
                 bool(opts.reject_if_exist_same_key) if opts is not None else False
             )
             write_through = bool(opts.write_through) if opts is not None else True
+            make_replica_task = (
+                bool(opts.make_replica_task) if opts is not None else True
+            )
             inner_res = self._client.put(
                 key,
                 ptrs,
@@ -487,6 +547,7 @@ def put(
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
                 reject_if_exist_same_key=reject_if_exist_same_key,
                 write_through=write_through,
+                make_replica_task=make_replica_task,
             )
             if not inner_res.is_ok():
                 err = inner_res.unwrap_error()
@@ -534,6 +595,9 @@ def put_blocking(
                 bool(opts.reject_if_exist_same_key) if opts is not None else False
             )
             write_through = bool(opts.write_through) if opts is not None else True
+            make_replica_task = (
+                bool(opts.make_replica_task) if opts is not None else True
+            )
             inner_res = self._client.put_blocking(
                 key,
                 ptrs,
@@ -541,6 +605,7 @@ def put_blocking(
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
                 reject_if_exist_same_key=reject_if_exist_same_key,
                 write_through=write_through,
+                make_replica_task=make_replica_task,
             )
             if not inner_res.is_ok():
                 return Result.new_error(inner_res.unwrap_error())
@@ -605,6 +670,7 @@ def batch_put_blocking(
             bool(opts.reject_if_exist_same_key) if opts is not None else False
         )
         write_through = bool(opts.write_through) if opts is not None else True
+        make_replica_task = bool(opts.make_replica_task) if opts is not None else True
 
         keepalive_groups: List[List[bytes]] = []
         dlpack_groups: List[List[object]] = []
@@ -624,6 +690,7 @@ def batch_put_blocking(
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
                 reject_if_exist_same_key=reject_if_exist_same_key,
                 write_through=write_through,
+                make_replica_task=make_replica_task,
                 concurrency=concurrency if concurrency is not None else self._batch_concurrency,
             )
             if not inner_res.is_ok():
@@ -741,6 +808,9 @@ def put_payload_from_ptr(
                 bool(opts.reject_if_exist_same_key) if opts is not None else False
             )
             write_through = bool(opts.write_through) if opts is not None else True
+            make_replica_task = (
+                bool(opts.make_replica_task) if opts is not None else True
+            )
             inner_res = self._client.put(
                 key,
                 ptrs,
@@ -748,6 +818,7 @@ def put_payload_from_ptr(
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
                 reject_if_exist_same_key=reject_if_exist_same_key,
                 write_through=write_through,
+                make_replica_task=make_replica_task,
             )
             if not inner_res.is_ok():
                 return Result.new_error(_map_nospace_to_storagefull(inner_res.unwrap_error()))
@@ -786,6 +857,9 @@ def put_payload_from_ptr_blocking(
                 bool(opts.reject_if_exist_same_key) if opts is not None else False
             )
             write_through = bool(opts.write_through) if opts is not None else True
+            make_replica_task = (
+                bool(opts.make_replica_task) if opts is not None else True
+            )
             inner_res = self._client.put_blocking(
                 key,
                 ptrs,
@@ -793,6 +867,7 @@ def put_payload_from_ptr_blocking(
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
                 reject_if_exist_same_key=reject_if_exist_same_key,
                 write_through=write_through,
+                make_replica_task=make_replica_task,
             )
             if not inner_res.is_ok():
                 return Result.new_error(inner_res.unwrap_error())
@@ -989,6 +1064,7 @@ def batch_put_from(
             bool(opts.reject_if_exist_same_key) if opts is not None else False
         )
         write_through = bool(opts.write_through) if opts is not None else True
+        make_replica_task = bool(opts.make_replica_task) if opts is not None else True
 
         try:
             inner_res = self._client.batch_put_from(
@@ -999,6 +1075,7 @@ def batch_put_from(
                 reject_if_inflight_same_key=reject_if_inflight_same_key,
                 reject_if_exist_same_key=reject_if_exist_same_key,
                 write_through=write_through,
+                make_replica_task=make_replica_task,
             )
             if inner_res.is_ok():
                 submit_results = list(inner_res.unwrap())
@@ -1203,10 +1280,7 @@ def rpc_call(
         try:
             if self._client is None:
                 raise GeneralError(message="Store not initialized when rpc_call(). Call setup() first.")
-            if not isinstance(timeout_ms, int):
-                raise InvalidArgumentError(message=f"timeout_ms must be int; got {type(timeout_ms)}")
-            if timeout_ms < 10_000:
-                raise InvalidArgumentError(message=f"timeout_ms must be >= 10000; got {timeout_ms}")
+            _validate_explicit_rpc_timeout_ms(timeout_ms)
 
             encoded = encode_flat_kv_dict(payload)
             if not encoded.is_ok():
@@ -1233,10 +1307,7 @@ def rpc_call_bytes(
                 raise GeneralError(message="Store not initialized when rpc_call_bytes(). Call setup() first.")
             if not isinstance(payload, (bytes, bytearray)):
                 raise InvalidArgumentError(message=f"payload must be bytes; got {type(payload)}")
-            if not isinstance(timeout_ms, int):
-                raise InvalidArgumentError(message=f"timeout_ms must be int; got {type(timeout_ms)}")
-            if timeout_ms < 10_000:
-                raise InvalidArgumentError(message=f"timeout_ms must be >= 10000; got {timeout_ms}")
+            _validate_explicit_rpc_timeout_ms(timeout_ms)
 
             inner = self._client.rpc_call(node_id, path, bytes(payload), timeout_ms)
             if not inner.is_ok():
@@ -1328,10 +1399,7 @@ def sync_kv_to_file(
                 raise InvalidArgumentError(message=f"file_offset must be int; got {type(file_offset)}")
             if file_offset < 0:
                 raise InvalidArgumentError(message=f"file_offset must be >= 0; got {file_offset}")
-            if not isinstance(timeout_ms, int):
-                raise InvalidArgumentError(message=f"timeout_ms must be int; got {type(timeout_ms)}")
-            if timeout_ms < 10_000:
-                raise InvalidArgumentError(message=f"timeout_ms must be >= 10000; got {timeout_ms}")
+            _validate_explicit_rpc_timeout_ms(timeout_ms)
 
             return self._client.sync_kv_to_file(
                 target_instance_key,
@@ -1452,12 +1520,41 @@ def local_fast_put_start(
             bool(opts.reject_if_exist_same_key) if opts is not None else False
         )
         write_through = bool(opts.write_through) if opts is not None else True
+        make_replica_task = bool(opts.make_replica_task) if opts is not None else True
+        make_replica_task_mask: Optional[List[bool]] = None
+        if opts is not None and opts.make_replica_task_mask is not None:
+            requested_mask = opts.make_replica_task_mask
+            if not isinstance(requested_mask, list):
+                raise ValueError(
+                    "make_replica_task_mask must be list[bool] when provided; "
+                    f"got {type(requested_mask)}"
+                )
+            if len(requested_mask) != len(keys):
+                raise ValueError(
+                    "make_replica_task_mask length must match keys length; "
+                    f"keys={len(keys)} mask={len(requested_mask)}"
+                )
+            for index, item in enumerate(requested_mask):
+                if type(item) is not bool:
+                    raise ValueError(
+                        "make_replica_task_mask items must be bool; "
+                        f"index={index} got={type(item)}"
+                    )
+            make_replica_task_mask = list(requested_mask)
+        atomic_group_lens = _validate_put_atomic_groups(
+            keys,
+            opts.atomic_group_lens if opts is not None else None,
+            make_replica_task_mask,
+        )
         inner_res = self._client.local_fast_put_start(
             keys,
             value_len,
             reject_if_inflight_same_key=reject_if_inflight_same_key,
             reject_if_exist_same_key=reject_if_exist_same_key,
             write_through=write_through,
+            make_replica_task=make_replica_task,
+            make_replica_task_mask=make_replica_task_mask,
+            atomic_group_lens=atomic_group_lens,
         )
         if not inner_res.is_ok():
             err = inner_res.unwrap_error()
@@ -1609,6 +1706,7 @@ def cancel_get_transfer(self, handle: GetStartHandle) -> None:
             raise RuntimeError(
                 f"cancel_get_transfer backend error: {inner_res.unwrap_error()}"
             )
+        _ = inner_res.unwrap()
         handle.closed = True
 
     def get_transfer(
diff --git a/fluxon_py/kvclient/kvclient_interface.py b/fluxon_py/kvclient/kvclient_interface.py
index e126eec..bb248da 100644
--- a/fluxon_py/kvclient/kvclient_interface.py
+++ b/fluxon_py/kvclient/kvclient_interface.py
@@ -75,11 +75,22 @@ class PutOptionalArgs:
     - write_through: keep synchronous remote-placement semantics when the backend
       supports an async write-back path. Defaults to True to match SGLang
       HiCache's default write policy.
+    - make_replica_task: enqueue an asynchronous replica after a local write-back
+      commit. Set False for a local-only write-back.
+    - make_replica_task_mask: optional per-key replica admission decisions for
+      local_fast_put_start(). Its length must match the key batch. The scalar
+      make_replica_task remains the batch-wide gate.
+    - atomic_group_lens: optional positive lengths that partition the ordered
+      local_fast_put_start() key batch into atomic groups. Replica admission
+      must be uniform within every group.
     """
     lease_id: Optional[int] = None
     reject_if_inflight_same_key: bool = False
     reject_if_exist_same_key: bool = False
     write_through: bool = True
+    make_replica_task: bool = True
+    make_replica_task_mask: Optional[List[bool]] = None
+    atomic_group_lens: Optional[List[int]] = None
 
     def support_mooncake(self) -> Tuple[bool, List[str]]:
         """
@@ -100,6 +111,12 @@ def support_mooncake(self) -> Tuple[bool, List[str]]:
             unsupported.append("reject_if_exist_same_key")
         if self.write_through:
             unsupported.append("write_through")
+        if not self.make_replica_task:
+            unsupported.append("make_replica_task")
+        if self.make_replica_task_mask is not None:
+            unsupported.append("make_replica_task_mask")
+        if self.atomic_group_lens is not None:
+            unsupported.append("atomic_group_lens")
         return (len(unsupported) == 0, unsupported)
 
 
diff --git a/fluxon_py/tests/test_config.py b/fluxon_py/tests/test_config.py
index 6de5180..3ed2a5e 100644
--- a/fluxon_py/tests/test_config.py
+++ b/fluxon_py/tests/test_config.py
@@ -54,6 +54,7 @@ def _build_checks(selected_test_id: Optional[str]) -> List[Tuple[str, Callable[[
         ("fluxonkv_protocol_field", test_fluxonkv_protocol_field),
         ("fluxonkv_runtime_defaults_are_internal", test_fluxonkv_runtime_defaults_are_internal),
         ("fluxonkv_removed_rdma_config_keys", test_fluxonkv_removed_rdma_config_keys),
+        ("fluxonkv_owner_hot_writeback", test_fluxonkv_owner_hot_writeback),
         ("fluxonkv_test_spec_config", test_fluxonkv_test_spec_config),
         ("fluxon_pyo3_import_authority", test_fluxon_pyo3_import_authority),
     ]
@@ -444,6 +445,61 @@ def test_fluxonkv_removed_rdma_config_keys():
         print(f"❌ FAIL: test_fluxonkv_removed_rdma_config_keys - {e}")
 
 
+def test_fluxonkv_owner_hot_writeback():
+    """Validate the owner-only hot-tier ratio and preserve it in Rust YAML."""
+    try:
+        owner = _owner_fluxonkv_base_config(tag="owner_hot_writeback")
+        owner["replica_writeback_hot_capacity_ratio"] = 0.75
+        loaded = yaml.safe_load(
+            FluxonKvClientConfig(owner).to_fluxon_kv_client_config_yaml_str()
+        )
+        assert loaded["replica_writeback_hot_capacity_ratio"] == 0.75
+
+        for invalid in (0, 1, -0.1, float("nan"), True, "0.75"):
+            invalid_owner = _owner_fluxonkv_base_config(tag="owner_hot_invalid")
+            invalid_owner["replica_writeback_hot_capacity_ratio"] = invalid
+            try:
+                FluxonKvClientConfig(invalid_owner)
+                print(
+                    "❌ FAIL: test_fluxonkv_owner_hot_writeback - invalid ratio should be rejected"
+                )
+                return
+            except ValueError:
+                pass
+
+        external = {
+            "instance_key": "external_hot_invalid",
+            "replica_writeback_hot_capacity_ratio": 0.75,
+            "fluxonkv_spec": {
+                "cluster_name": "test_cluster",
+                "share_mem_path": "/tmp/kvcache_shared_memory/external_hot_invalid",
+            },
+        }
+        try:
+            FluxonKvClientConfig(external)
+            print(
+                "❌ FAIL: test_fluxonkv_owner_hot_writeback - external ratio should be rejected"
+            )
+            return
+        except ValueError:
+            pass
+
+        mooncake = config_dict()
+        mooncake["replica_writeback_hot_capacity_ratio"] = 0.75
+        try:
+            FluxonKvClientConfig(mooncake)
+            print(
+                "❌ FAIL: test_fluxonkv_owner_hot_writeback - Mooncake ratio should be rejected"
+            )
+            return
+        except ValueError:
+            pass
+
+        print("✅ PASS: test_fluxonkv_owner_hot_writeback")
+    except Exception as e:
+        print(f"❌ FAIL: test_fluxonkv_owner_hot_writeback - {e}")
+
+
 def test_fluxonkv_test_spec_config():
     """Ensure test_spec_config is accepted, normalized, and serialized."""
     try:
@@ -473,6 +529,7 @@ def test_fluxonkv_test_spec_config():
         rdma_devices["test_spec_config"]["tcp_thread_reactor_shard_count"] = 2
         rdma_devices["test_spec_config"]["tcp_thread_bulk_lane_count"] = 4
         rdma_devices["test_spec_config"]["tcp_thread_control_lane_count"] = 3
+        rdma_devices["test_spec_config"]["replica_task_max_inflight"] = 16
         rdma_devices["test_spec_config"][
             "require_transfer_rpc_fast_path_ready_timeout_seconds"
         ] = 45
@@ -487,12 +544,58 @@ def test_fluxonkv_test_spec_config():
         assert loaded["test_spec_config"]["tcp_thread_reactor_shard_count"] == 2
         assert loaded["test_spec_config"]["tcp_thread_bulk_lane_count"] == 4
         assert loaded["test_spec_config"]["tcp_thread_control_lane_count"] == 3
+        assert loaded["test_spec_config"]["replica_task_max_inflight"] == 16
         assert (
             loaded["test_spec_config"]["require_transfer_rpc_fast_path_ready_timeout_seconds"]
             == 45
         )
         assert config.protocol_rdma_device_names == "mlx5_0,mlx5_4"
 
+        expected_capacity = _owner_fluxonkv_base_config(tag="expected_capacity")
+        expected_capacity["contribute_to_cluster_pool_size"]["dram"] = 137438953472
+        expected_capacity["test_spec_config"] = {
+            "owner_local_reserve_soft_wait_timeout_ms": 10,
+            "owner_local_reserve_hard_timeout_ms": 10_000,
+            "owner_local_reserve_expected_capacity": {
+                "value_len": 4_718_592,
+                "payload_capacity_bytes": 109_951_162_777,
+            },
+        }
+        config = FluxonKvClientConfig(expected_capacity)
+        loaded = yaml.safe_load(config.to_fluxon_kv_client_config_yaml_str())
+        assert loaded["test_spec_config"]["owner_local_reserve_soft_wait_timeout_ms"] == 10
+        assert loaded["test_spec_config"]["owner_local_reserve_hard_timeout_ms"] == 10_000
+        assert loaded["test_spec_config"]["owner_local_reserve_expected_capacity"] == {
+            "value_len": 4_718_592,
+            "payload_capacity_bytes": 109_951_162_777,
+        }
+
+        invalid_reserve_timeout = copy.deepcopy(expected_capacity)
+        invalid_reserve_timeout["test_spec_config"][
+            "owner_local_reserve_hard_timeout_ms"
+        ] = 10
+        try:
+            FluxonKvClientConfig(invalid_reserve_timeout)
+            print(
+                "❌ FAIL: test_fluxonkv_test_spec_config - local-reserve hard timeout should exceed soft timeout"
+            )
+            return
+        except ValueError:
+            pass
+
+        invalid_expected_capacity = copy.deepcopy(expected_capacity)
+        invalid_expected_capacity["test_spec_config"][
+            "owner_local_reserve_expected_capacity"
+        ]["value_len"] = 0
+        try:
+            FluxonKvClientConfig(invalid_expected_capacity)
+            print(
+                "❌ FAIL: test_fluxonkv_test_spec_config - expected-capacity value_len=0 should be rejected"
+            )
+            return
+        except ValueError:
+            pass
+
         implicit_transport = copy.deepcopy(base)
         implicit_transport["test_spec_config"] = {
             "disable_observability": True,
diff --git a/fluxon_rs/fluxon_commu/src/facade/p2p.rs b/fluxon_rs/fluxon_commu/src/facade/p2p.rs
index 8bcc169..1d4306c 100644
--- a/fluxon_rs/fluxon_commu/src/facade/p2p.rs
+++ b/fluxon_rs/fluxon_commu/src/facade/p2p.rs
@@ -1297,6 +1297,8 @@ pub mod rpc {
         timeout: Option<std::time::Duration>,
         transport_policy: RpcTransportPolicy,
     ) -> P2PResult<MsgPack<REQ::Resp>> {
+        validate_explicit_rpc_timeout(timeout)?;
+
         let mut failed_count = 0;
         let shutdown_poller = p2p.module_view().register_shutdown_poller();
 
@@ -1371,6 +1373,8 @@ pub mod rpc {
         timeout: Option<std::time::Duration>,
         transport_policy: RpcTransportPolicy,
     ) -> P2PResult<RpcCallObservedOutput<REQ::Resp>> {
+        validate_explicit_rpc_timeout(timeout)?;
+
         regist_rpc_send::<REQ>(p2p);
 
         {
@@ -1381,31 +1385,12 @@ pub mod rpc {
                 .await?;
         }
 
-        let timeout_duration = match timeout {
-            Some(duration) => {
-                let min_duration = Duration::from_secs(MIN_EXPLICIT_RPC_TIMEOUT_SECS);
-                if duration < min_duration {
-                    return Err(P2pError::InvalidRpcTimeout {
-                        timeout_ms: duration.as_secs() * 1_000
-                            + u64::from(duration.subsec_millis()),
-                        min_timeout_ms: MIN_EXPLICIT_RPC_TIMEOUT_SECS * 1_000,
-                        reason: format!(
-                            "Explicit RPC timeout below {}s is forbidden.",
-                            MIN_EXPLICIT_RPC_TIMEOUT_SECS
-                        ),
-                    });
-                }
-                Some(duration)
-            }
-            None => None,
-        };
-
         let wire_encode_started_at = Instant::now();
         let msg_id = req.msg_id();
         let wire_body = req.into_wire_body()?;
         let wire_encode_us = duration_to_i64_us(wire_encode_started_at.elapsed());
         let raw_output = p2p
-            .call_raw_observed(node, msg_id, wire_body, timeout_duration, transport_policy)
+            .call_raw_observed(node, msg_id, wire_body, timeout, transport_policy)
             .await?;
         let response_local_observe = raw_output.message.local_observe;
         let resp_decode_started_at = Instant::now();
diff --git a/fluxon_rs/fluxon_commu_contract/src/p2p.rs b/fluxon_rs/fluxon_commu_contract/src/p2p.rs
index 673692b..c548ee4 100644
--- a/fluxon_rs/fluxon_commu_contract/src/p2p.rs
+++ b/fluxon_rs/fluxon_commu_contract/src/p2p.rs
@@ -9,15 +9,16 @@ pub mod surface;
 pub mod wire;
 
 pub use rpc::{
-    MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, MsgPackSerializePart, RPCReq, RpcCallObserveTrace,
-    RpcCallObservedOutput, USER_RPC_OBSERVE_TRACE_RAW_BYTES_INDEX,
+    MIN_EXPLICIT_RPC_TIMEOUT_MS, MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, MsgPackSerializePart,
+    RPCReq, RpcCallObserveTrace, RpcCallObservedOutput, USER_RPC_OBSERVE_TRACE_RAW_BYTES_INDEX,
     USER_RPC_OWNER1_OBSERVE_TRACE_RAW_BYTES_INDEX, USER_RPC_REQ_MSG_ID,
     USER_RPC_REQUEST_OWNER1_OBSERVE_TRACE_RAW_BYTES_INDEX, USER_RPC_RESP_MSG_ID,
     UserRpcBytesAsyncHandler, UserRpcBytesError, UserRpcBytesFuture, UserRpcBytesHandler,
     UserRpcObserveTrace, UserRpcOwner1ObserveTrace, UserRpcTransportPathKind,
     current_cross_process_monotonic_us, decode_user_rpc_observe_trace,
     decode_user_rpc_owner1_observe_trace, encode_user_rpc_observe_trace,
-    encode_user_rpc_owner1_observe_trace,
+    encode_user_rpc_owner1_observe_trace, validate_explicit_rpc_timeout,
+    validate_explicit_rpc_timeout_ms,
 };
 pub use surface::*;
 pub use wire::*;
diff --git a/fluxon_rs/fluxon_commu_contract/src/p2p/rpc.rs b/fluxon_rs/fluxon_commu_contract/src/p2p/rpc.rs
index b65ccd9..144034d 100644
--- a/fluxon_rs/fluxon_commu_contract/src/p2p/rpc.rs
+++ b/fluxon_rs/fluxon_commu_contract/src/p2p/rpc.rs
@@ -17,14 +17,66 @@ use prost::bytes::Bytes as ProstBytes;
 use std::fmt::Debug;
 use std::future::Future;
 use std::pin::Pin;
+use std::time::Duration;
 
 pub const MIN_EXPLICIT_RPC_TIMEOUT_SECS: u64 = 10;
+pub const MIN_EXPLICIT_RPC_TIMEOUT_MS: u64 = MIN_EXPLICIT_RPC_TIMEOUT_SECS * 1_000;
 pub const USER_RPC_REQ_MSG_ID: u32 = 7001;
 pub const USER_RPC_RESP_MSG_ID: u32 = 7002;
 pub const USER_RPC_REQUEST_OWNER1_OBSERVE_TRACE_RAW_BYTES_INDEX: usize = 1;
 pub const USER_RPC_OBSERVE_TRACE_RAW_BYTES_INDEX: usize = 1;
 pub const USER_RPC_OWNER1_OBSERVE_TRACE_RAW_BYTES_INDEX: usize = 2;
 
+pub fn validate_explicit_rpc_timeout(timeout: Option<Duration>) -> P2PResult<()> {
+    let Some(timeout) = timeout else {
+        return Ok(());
+    };
+    if timeout < Duration::from_millis(MIN_EXPLICIT_RPC_TIMEOUT_MS) {
+        return Err(P2pError::InvalidRpcTimeout {
+            timeout_ms: timeout.as_millis().min(u128::from(u64::MAX)) as u64,
+            min_timeout_ms: MIN_EXPLICIT_RPC_TIMEOUT_MS,
+            reason: format!(
+                "Explicit RPC timeout below {}s is forbidden.",
+                MIN_EXPLICIT_RPC_TIMEOUT_SECS
+            ),
+        });
+    }
+    Ok(())
+}
+
+pub fn validate_explicit_rpc_timeout_ms(timeout_ms: u64) -> P2PResult<()> {
+    validate_explicit_rpc_timeout(Some(Duration::from_millis(timeout_ms)))
+}
+
+#[cfg(test)]
+mod explicit_rpc_timeout_tests {
+    use super::*;
+
+    #[test]
+    fn accepts_default_and_minimum_explicit_timeout() {
+        assert!(validate_explicit_rpc_timeout(None).is_ok());
+        assert!(validate_explicit_rpc_timeout_ms(MIN_EXPLICIT_RPC_TIMEOUT_MS).is_ok());
+    }
+
+    #[test]
+    fn rejects_subminimum_timeout_with_typed_error() {
+        let timeout_ms = MIN_EXPLICIT_RPC_TIMEOUT_MS - 1;
+        let err = validate_explicit_rpc_timeout_ms(timeout_ms).unwrap_err();
+        assert_eq!(err.code(), 617);
+        match err {
+            P2pError::InvalidRpcTimeout {
+                timeout_ms: actual_timeout_ms,
+                min_timeout_ms,
+                ..
+            } => {
+                assert_eq!(actual_timeout_ms, timeout_ms);
+                assert_eq!(min_timeout_ms, MIN_EXPLICIT_RPC_TIMEOUT_MS);
+            }
+            other => panic!("expected InvalidRpcTimeout, got {other:?}"),
+        }
+    }
+}
+
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
 pub enum UserRpcTransportPathKind {
     #[default]
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
index 63db807..946f033 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
@@ -89,8 +89,19 @@ async fn apply_delete_client_kv_meta_cache_item(
     let client_api = view.client_kv_api();
     let client_inner = client_api.inner();
 
-    if let Some((_removed_key, cached_info)) =
-        client_inner
+    let cached_info = {
+        let controls = client_inner.owner_key_control.lock();
+        if controls
+            .get(&delete_item.key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            tracing::debug!(
+                "skip legacy local-index delete while owner reclaim fence is active: key={}",
+                delete_item.key
+            );
+            return;
+        }
+        let cached_info = client_inner
             .get_cached_info
             .remove_if(&delete_item.key, |_, v| {
                 let res = if v.put_time_ms == delete_item.put_time_ms {
@@ -112,14 +123,25 @@ async fn apply_delete_client_kv_meta_cache_item(
                 }
                 res
             })
-    {
+            .map(|(_, cached_info)| cached_info);
+        let _ = client_inner
+            .local_snapshot_info
+            .remove_if(&delete_item.key, |_, snapshot| {
+                if snapshot.put_time_ms == delete_item.put_time_ms {
+                    snapshot.put_version <= delete_item.put_version
+                } else {
+                    snapshot.put_time_ms <= delete_item.put_time_ms
+                }
+            });
+        cached_info
+    };
+    if let Some(cached_info) = cached_info {
+        client_inner.owner_hot_invalidate_version(
+            &delete_item.key,
+            (cached_info.put_time_ms, cached_info.put_version),
+        );
         client_inner.release_local_reserve_route_for_memory_info(cached_info.mem_holder.as_ref());
     }
-    let _ = client_inner.remove_local_snapshot_if(
-        &delete_item.key,
-        delete_item.put_time_ms,
-        delete_item.put_version,
-    );
 
     if let Err(err) = client_inner
         .external_invalidate_delete
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index a10e354..28ba872 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -1,11 +1,12 @@
 use crate::client_kv_api::ClientKvApi;
 use crate::client_kv_api::msg_pack::{
-    ExternalBatchGetCancelReq, ExternalBatchGetCancelResp, ExternalBatchGetItemResp,
-    ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
-    ExternalBatchGetTransferReq, ExternalBatchGetTransferResp, ExternalBatchIsExistReq,
-    ExternalBatchIsExistResp, ExternalBatchPutCommitItemResp, ExternalBatchPutCommitReq,
-    ExternalBatchPutCommitResp, ExternalBatchPutStartItemResp, ExternalBatchPutStartReq,
-    ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemResp, ExternalBatchPutTransferEndReq,
+    ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetCancelResp,
+    ExternalBatchGetItemResp, ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq,
+    ExternalBatchGetStartResp, ExternalBatchGetStartTransferPlan, ExternalBatchGetTransferReq,
+    ExternalBatchGetTransferResp, ExternalBatchIsExistReq, ExternalBatchIsExistResp,
+    ExternalBatchPutCommitItemResp, ExternalBatchPutCommitReq, ExternalBatchPutCommitResp,
+    ExternalBatchPutStartItemResp, ExternalBatchPutStartReq, ExternalBatchPutStartResp,
+    ExternalBatchPutTransferEndItemResp, ExternalBatchPutTransferEndReq,
     ExternalBatchPutTransferEndResp, ExternalDeleteReq, ExternalDeleteResp, ExternalGetReq,
     ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp, ExternalObservabilitySnapshotReq,
     ExternalObservabilitySnapshotResp, ExternalPutCommitReq, ExternalPutCommitResp,
@@ -15,8 +16,8 @@ use crate::client_kv_api::msg_pack::{
 use crate::client_kv_api::{
     self, ExternalGetStartDedupKey, ExternalGetStartEntry, ExternalGetStartOwnerItem,
     ExternalGetStartPrefixResult, ExternalGetStartSharedItemResult, ExternalGetStartSharedOp,
-    ExternalGetStartSharedPhase, ExternalGetStartTransferOutput, ExternalHoldingGetInfo,
-    ExternalPendingPutCtx, ReplicaTaskTarget,
+    ExternalGetStartSharedPhase, ExternalGetStartTransferOutput, ExternalPendingPutCtx,
+    ReplicaTaskTarget,
 };
 use crate::client_seg_pool::{ResolveSideTransferLaneReq, parse_side_transfer_worker_lane_idx};
 use crate::cluster_manager::NodeIDString;
@@ -24,11 +25,12 @@ use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
 use crate::master_kv_router::msg_pack::{
-    BatchPutDoneItemReq, BatchPutRevokeItemReq, BatchPutStartItemReq, PutDoneCommittedSlot,
+    BatchGetStartItemResp, BatchGetStartResp, BatchPutDoneItemReq, BatchPutRevokeItemReq,
+    BatchPutStartItemReq, PutDoneCommittedSlot, build_put_atomic_group_assignments,
 };
 use crate::memholder::MemholderManagerTrait;
 use crate::memholder::NodeHolderKey;
-use crate::memholder::{ExternalMemHolderInfo, UserMemHolder, UserMemHolderExposeKind};
+use crate::memholder::{UserMemHolder, UserMemHolderExposeKind};
 use crate::p2p::msg_pack::MsgPack;
 use crate::rpcresp_kvresult_convert::FromError;
 use crate::rpcresp_kvresult_convert::ToResult;
@@ -47,6 +49,7 @@ fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
 
 const SIDE_TRANSFER_OWNER_RPC_TIMEOUT_SECS: u64 = 30;
 const SIDE_TRANSFER_TARGET_RESOLVE_TIMEOUT_SECS: u64 = 10;
+const GET_TARGET_NO_SPACE_RESERVE_SHRINK_RETRY_LIMIT: usize = 8;
 
 #[derive(Clone)]
 struct LocalCommittedCachePublish {
@@ -159,7 +162,12 @@ async fn commit_external_local_first_pending(
         )
         .await;
     inner.install_precommit_local_visible_memory_info(key, memory_info.clone());
-    inner.promote_precommit_local_reserve_resident_slot_if_same(key, put_id, memory_info)?;
+    inner.promote_precommit_local_reserve_resident_slot_if_same(
+        key,
+        put_id,
+        memory_info,
+        ctx.atomic_group.as_ref(),
+    )?;
     Ok(PutDoneCommittedSlot {
         grant_id: slot_ref.grant_id,
         slot_index: slot_ref.slot_index,
@@ -176,18 +184,22 @@ fn spawn_external_local_first_publish(
     put_id: crate::master_kv_router::put::PutIDForAKey,
     lease_id: Option<u64>,
     committed_slot: PutDoneCommittedSlot,
+    make_replica_task: bool,
+    preferred_sub_cluster: Option<String>,
+    atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
 ) {
     let view = inner.view.clone_view();
     let spawn_view = view.clone();
     spawn_view.spawn("external_local_first_route_publish", async move {
         let inner = view.client_kv_api().inner();
-        match inner
+        let publish_ok = match inner
             .batch_put_done(vec![BatchPutDoneItemReq {
                 key: key.clone(),
                 put_id,
                 lease_id,
                 committed_slot: Some(committed_slot),
                 publish_local_cache: false,
+                atomic_group,
             }])
             .await
         {
@@ -203,6 +215,9 @@ fn spawn_external_local_first_publish(
                             put_id.1,
                             err
                         );
+                        false
+                    } else {
+                        true
                     }
                 } else {
                     tracing::warn!(
@@ -211,6 +226,7 @@ fn spawn_external_local_first_publish(
                         put_id.0,
                         put_id.1
                     );
+                    false
                 }
             }
             Err(err) => {
@@ -221,6 +237,21 @@ fn spawn_external_local_first_publish(
                     put_id.1,
                     err
                 );
+                false
+            }
+        };
+        if publish_ok && make_replica_task {
+            if let Err(err) = inner
+                .make_replica_append_task(&key, put_id, preferred_sub_cluster, true)
+                .await
+            {
+                tracing::warn!(
+                    "external local-first enqueue replica append failed: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
             }
         }
     });
@@ -259,6 +290,41 @@ pub(crate) fn normalize_external_get_start_group_lens(
     }
 }
 
+fn normalize_external_put_start_group_lens(
+    items_len: usize,
+    atomic_group_lens: Option<Vec<usize>>,
+) -> KvResult<Vec<usize>> {
+    let group_lens = atomic_group_lens.unwrap_or_else(|| vec![1; items_len]);
+    if items_len != 0 && group_lens.is_empty() {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: "external_batch_put_start atomic_group_lens must be non-empty".to_string(),
+        }));
+    }
+    if group_lens.iter().any(|group_len| *group_len == 0) {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: "external_batch_put_start atomic_group_lens entries must be > 0".to_string(),
+        }));
+    }
+    let sum = group_lens
+        .iter()
+        .try_fold(0usize, |sum, group_len| sum.checked_add(*group_len))
+        .ok_or_else(|| {
+            KvError::Api(ApiError::InvalidArgument {
+                detail: "external_batch_put_start atomic_group_lens sum overflowed usize"
+                    .to_string(),
+            })
+        })?;
+    if sum != items_len {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "external_batch_put_start atomic_group_lens must sum to items length: sum={} items={}",
+                sum, items_len
+            ),
+        }));
+    }
+    Ok(group_lens)
+}
+
 fn external_get_start_error_kind_from_code(error_code: u32, error_json: &str) -> Option<String> {
     if error_code == OK || error_code == codes_api::API_KEY_NOT_FOUND {
         None
@@ -308,6 +374,195 @@ pub(crate) fn compute_external_get_start_transfer_prefix(
     }
 }
 
+fn collect_external_get_start_missing<T>(
+    keys: &[String],
+    item_slots: &[Option<T>],
+) -> (Vec<usize>, Vec<String>) {
+    assert_eq!(
+        keys.len(),
+        item_slots.len(),
+        "external get_start local snapshot length must match keys"
+    );
+    keys.iter()
+        .zip(item_slots.iter())
+        .enumerate()
+        .filter_map(|(idx, (key, item))| item.is_none().then(|| (idx, key.clone())))
+        .unzip()
+}
+
+fn collect_all_local_external_get_start_infos(
+    items: &[ExternalGetStartOwnerItem],
+) -> Option<Vec<Arc<crate::memholder::MemoryInfo>>> {
+    items
+        .iter()
+        .map(|item| match item {
+            ExternalGetStartOwnerItem::Local { memory_info } => Some(memory_info.clone()),
+            ExternalGetStartOwnerItem::Started { .. } => None,
+        })
+        .collect()
+}
+
+fn collect_get_target_no_space_indices(items: &[BatchGetStartItemResp]) -> Vec<usize> {
+    items
+        .iter()
+        .enumerate()
+        .filter_map(|(idx, item)| (item.error_code == codes_api::API_NO_SPACE).then_some(idx))
+        .collect()
+}
+
+async fn batch_get_start_with_reserve_pressure_retry(
+    inner: &client_kv_api::ClientKvApiInner,
+    keys: &[String],
+) -> KvResult<BatchGetStartResp> {
+    let mut response = inner.batch_get_start(keys.to_vec()).await?;
+    if response.items.len() != keys.len() {
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "external_batch_get_start response length mismatch: expected={} got={}",
+                keys.len(),
+                response.items.len()
+            ),
+        }));
+    }
+
+    for attempt in 1..=GET_TARGET_NO_SPACE_RESERVE_SHRINK_RETRY_LIMIT {
+        let retry_indices = collect_get_target_no_space_indices(&response.items);
+        if retry_indices.is_empty() {
+            break;
+        }
+        let no_space_before = retry_indices.len();
+        if !crate::client_kv_api::local_reserve_rebalance::release_one_excess_reserve_grant_for_get_target_pressure(inner).await
+        {
+            break;
+        }
+        let retry_keys = retry_indices
+            .iter()
+            .map(|idx| keys[*idx].clone())
+            .collect::<Vec<_>>();
+        let retry_response = inner.batch_get_start(retry_keys).await?;
+        if retry_response.items.len() != retry_indices.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_batch_get_start NoSpace retry response length mismatch: expected={} got={} attempt={}",
+                    retry_indices.len(),
+                    retry_response.items.len(),
+                    attempt
+                ),
+            }));
+        }
+        response.server_process_us = response
+            .server_process_us
+            .saturating_add(retry_response.server_process_us);
+        for (idx, item) in retry_indices
+            .into_iter()
+            .zip(retry_response.items.into_iter())
+        {
+            response.items[idx] = item;
+        }
+        let no_space_after = collect_get_target_no_space_indices(&response.items).len();
+        tracing::info!(
+            "external_batch_get_start retried local Get-target NoSpace after reserve shrink: attempt={} no_space_before={} no_space_after={}",
+            attempt,
+            no_space_before,
+            no_space_after
+        );
+    }
+    Ok(response)
+}
+
+#[cfg(test)]
+mod external_get_start_batch_tests {
+    use super::{
+        collect_external_get_start_missing, collect_get_target_no_space_indices,
+        compute_external_get_start_raw_prefix, compute_external_get_start_transfer_prefix,
+        normalize_external_put_start_group_lens,
+    };
+    use crate::master_kv_router::msg_pack::BatchGetStartItemResp;
+    use crate::rpcresp_kvresult_convert::msg_and_error::{OK, codes_api};
+
+    #[test]
+    fn all_local_batch_has_no_master_fallback_and_keeps_full_atomic_prefix() {
+        let keys = vec!["a".to_string(), "b".to_string(), "c".to_string()];
+        let local_slots = vec![Some(1_u8), Some(2), Some(3)];
+
+        let (missing_indices, missing_keys) =
+            collect_external_get_start_missing(&keys, &local_slots);
+        assert!(missing_indices.is_empty());
+        assert!(missing_keys.is_empty());
+
+        let item_codes = vec![(OK, String::new()); keys.len()];
+        let (raw_prefix, first_miss, first_error) =
+            compute_external_get_start_raw_prefix(&item_codes);
+        assert_eq!(raw_prefix, keys.len());
+        assert_eq!(first_miss, None);
+        assert_eq!(first_error, None);
+        assert_eq!(
+            compute_external_get_start_transfer_prefix(raw_prefix, &[1, 2], true),
+            keys.len()
+        );
+    }
+
+    #[test]
+    fn mixed_batch_falls_back_only_for_missing_keys_and_preserves_group_boundary() {
+        let keys = vec![
+            "a".to_string(),
+            "b".to_string(),
+            "c".to_string(),
+            "d".to_string(),
+        ];
+        let local_slots = vec![Some(1_u8), Some(2), None, Some(4)];
+
+        let (missing_indices, missing_keys) =
+            collect_external_get_start_missing(&keys, &local_slots);
+        assert_eq!(missing_indices, vec![2]);
+        assert_eq!(missing_keys, vec!["c"]);
+
+        let item_codes = vec![
+            (OK, String::new()),
+            (OK, String::new()),
+            (codes_api::API_KEY_NOT_FOUND, String::new()),
+            (OK, String::new()),
+        ];
+        let (raw_prefix, first_miss, first_error) =
+            compute_external_get_start_raw_prefix(&item_codes);
+        assert_eq!(raw_prefix, 2);
+        assert_eq!(first_miss, Some(2));
+        assert_eq!(first_error, None);
+        assert_eq!(
+            compute_external_get_start_transfer_prefix(raw_prefix, &[2, 2], true),
+            2
+        );
+        assert_eq!(
+            compute_external_get_start_transfer_prefix(raw_prefix, &[2, 2], false),
+            0
+        );
+    }
+
+    #[test]
+    fn put_groups_default_per_item_and_reject_malformed_partitions() {
+        assert_eq!(
+            normalize_external_put_start_group_lens(3, None).unwrap(),
+            vec![1, 1, 1]
+        );
+        assert_eq!(
+            normalize_external_put_start_group_lens(3, Some(vec![2, 1])).unwrap(),
+            vec![2, 1]
+        );
+        assert!(normalize_external_put_start_group_lens(3, Some(vec![1, 1])).is_err());
+        assert!(normalize_external_put_start_group_lens(3, Some(vec![1, 0, 2])).is_err());
+    }
+
+    #[test]
+    fn get_target_pressure_retry_selects_only_no_space_items() {
+        let mut items = vec![BatchGetStartItemResp::default(); 4];
+        items[0].error_code = OK;
+        items[1].error_code = codes_api::API_NO_SPACE;
+        items[2].error_code = codes_api::API_KEY_NOT_FOUND;
+        items[3].error_code = codes_api::API_NO_SPACE;
+        assert_eq!(collect_get_target_no_space_indices(&items), vec![1, 3]);
+    }
+}
+
 async fn finish_external_get_start_transfer(
     view: crate::client_kv_api::ClientKvApiView,
     transfer_items: Vec<ExternalGetStartOwnerItem>,
@@ -577,31 +832,43 @@ async fn prepare_external_get_start_shared_op(
     Vec<String>,
     Vec<ExternalGetStartOwnerItem>,
 )> {
-    let mut item_slots: Vec<Option<ExternalGetStartOwnerItem>> =
-        (0..req.keys.len()).map(|_| None).collect();
-    let mut missing_indices = Vec::new();
-    let mut missing_keys = Vec::new();
-
-    for (idx, key) in req.keys.iter().enumerate() {
-        if let Some(memory_info) = inner.local_visible_mem_holder(key) {
-            item_slots[idx] = Some(ExternalGetStartOwnerItem::Local { memory_info });
-        } else {
-            missing_indices.push(idx);
-            missing_keys.push(key.clone());
-        }
+    let local_memory_infos = inner.local_visible_mem_holders(&req.keys);
+    if local_memory_infos.iter().all(Option::is_some) {
+        let key_count = req.keys.len();
+        let transfer_items = local_memory_infos
+            .into_iter()
+            .map(|memory_info| ExternalGetStartOwnerItem::Local {
+                memory_info: memory_info.expect("all local-visible entries were checked"),
+            })
+            .collect();
+        tracing::debug!(
+            key_count,
+            req_node_id = %req.req_node_id,
+            "external_batch_get_start used all-local-visible batch fast path"
+        );
+        return Ok((
+            ExternalGetStartPrefixResult {
+                raw_prefix_hit_len: key_count,
+                transferable_len: key_count,
+                first_miss_index: None,
+                first_error_kind: None,
+            },
+            req.keys.clone(),
+            transfer_items,
+        ));
     }
 
+    let mut item_slots: Vec<Option<ExternalGetStartOwnerItem>> = local_memory_infos
+        .into_iter()
+        .map(|memory_info| {
+            memory_info.map(|memory_info| ExternalGetStartOwnerItem::Local { memory_info })
+        })
+        .collect();
+    let (missing_indices, missing_keys) =
+        collect_external_get_start_missing(&req.keys, &item_slots);
+
     if !missing_keys.is_empty() {
-        let start_resp = inner.batch_get_start(missing_keys.clone()).await?;
-        if start_resp.items.len() != missing_indices.len() {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "external_batch_get_start response length mismatch: expected={} got={}",
-                    missing_indices.len(),
-                    start_resp.items.len()
-                ),
-            }));
-        }
+        let start_resp = batch_get_start_with_reserve_pressure_retry(inner, &missing_keys).await?;
         for ((idx, key), item) in missing_indices
             .into_iter()
             .zip(missing_keys.into_iter())
@@ -1037,24 +1304,8 @@ impl HandlerForExternalClient for ClientKvApi {
                 });
             }
         };
-        let memory_info = memholder.memory_info();
-        // Build holding info to record that this external client holds the memholder
-        let client_holding_info = ExternalHoldingGetInfo {
-            key: req.key.clone(),
-            req_node_id: req.req_node_id.clone(),
-            memory_info,
-        };
-
-        // Insert/update holding via owned manager
-        inner.external_get_holding.insert(
-            NodeHolderKey::new(req.req_node_id.clone(), memholder.holder_id()),
-            client_holding_info,
-        );
-        let external_memholder_info = ExternalMemHolderInfo {
-            offset: memholder.get_offset(),
-            len: memholder.get_length() as u32,
-            holder_id: memholder.holder_id(),
-        };
+        let external_memholder_info =
+            inner.install_external_get_holding(&req.req_node_id, memholder.memory_info());
         Ok(ExternalGetResp {
             external_memholder_info: Some(external_memholder_info),
             error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
@@ -1075,23 +1326,14 @@ impl HandlerForExternalClient for ClientKvApi {
         for item_result in batch_results {
             match item_result {
                 Ok(Some((memholder, _))) => {
-                    let memory_info = memholder.memory_info();
-                    inner.external_get_holding.insert(
-                        NodeHolderKey::new(req.req_node_id.clone(), memholder.holder_id()),
-                        ExternalHoldingGetInfo {
-                            key: memory_info.key.clone(),
-                            req_node_id: req.req_node_id.clone(),
-                            memory_info,
-                        },
+                    let external_memholder_info = inner.install_external_get_holding(
+                        &req.req_node_id,
+                        memholder.memory_info(),
                     );
                     items.push(ExternalBatchGetItemResp {
                         error_code: OK,
                         error_json: String::new(),
-                        external_memholder_info: Some(ExternalMemHolderInfo {
-                            offset: memholder.get_offset(),
-                            len: memholder.get_length() as u32,
-                            holder_id: memholder.holder_id(),
-                        }),
+                        external_memholder_info: Some(external_memholder_info),
                     });
                 }
                 Ok(None) => items.push(ExternalBatchGetItemResp {
@@ -1156,6 +1398,18 @@ impl HandlerForExternalClient for ClientKvApi {
         if is_creator {
             match prepare_external_get_start_shared_op(inner, &req, &group_lens).await {
                 Ok((prefix, transfer_keys, transfer_items)) => {
+                    let inline_memory_infos = (transfer_items.len() == req.keys.len())
+                        .then(|| collect_all_local_external_get_start_infos(&transfer_items))
+                        .flatten();
+                    let inline_local = inline_memory_infos.is_some();
+                    if let Some(memory_infos) = inline_memory_infos {
+                        shared_op
+                            .inline_local_memory_infos
+                            .set(memory_infos)
+                            .unwrap_or_else(|_| {
+                                panic!("external get_start inline plan initialized twice")
+                            });
+                    }
                     {
                         let mut state = shared_op.state.lock();
                         state.phase = ExternalGetStartSharedPhase::Running {
@@ -1165,23 +1419,25 @@ impl HandlerForExternalClient for ClientKvApi {
                     }
                     shared_op.notify.notify_waiters();
 
-                    let transfer_shared_op = shared_op.clone();
-                    let transfer_concurrency = shared_op.transfer_concurrency;
-                    let spawn_view = inner.view.clone_view();
-                    let transfer_view = spawn_view.clone();
-                    spawn_view.spawn("external_get_start_transfer", async move {
-                        let transfer_result = finish_external_get_start_transfer(
-                            transfer_view,
-                            transfer_items,
-                            transfer_concurrency,
-                        )
-                        .await;
-                        publish_external_get_start_ready(
-                            &transfer_shared_op,
-                            transfer_keys,
-                            transfer_result,
-                        );
-                    });
+                    if !inline_local {
+                        let transfer_shared_op = shared_op.clone();
+                        let transfer_concurrency = shared_op.transfer_concurrency;
+                        let spawn_view = inner.view.clone_view();
+                        let transfer_view = spawn_view.clone();
+                        spawn_view.spawn("external_get_start_transfer", async move {
+                            let transfer_result = finish_external_get_start_transfer(
+                                transfer_view,
+                                transfer_items,
+                                transfer_concurrency,
+                            )
+                            .await;
+                            publish_external_get_start_ready(
+                                &transfer_shared_op,
+                                transfer_keys,
+                                transfer_result,
+                            );
+                        });
+                    }
                 }
                 Err(err) => {
                     publish_external_get_start_failed(&shared_op, &err);
@@ -1201,19 +1457,41 @@ impl HandlerForExternalClient for ClientKvApi {
         let handle = inner
             .next_external_get_start_handle
             .fetch_add(1, Ordering::Relaxed);
-        inner.external_get_start_registry.insert(
-            handle,
-            Arc::new(ExternalGetStartEntry {
-                req_node_id: req.req_node_id.clone(),
-                shared_op,
-            }),
-        );
+        let transfer_plan = if let Some(memory_infos) = shared_op.inline_local_memory_infos.get() {
+            assert_eq!(
+                memory_infos.len(),
+                req.keys.len(),
+                "inline local get_start plan must cover the full request"
+            );
+            let items = memory_infos
+                .iter()
+                .map(|memory_info| ExternalBatchGetItemResp {
+                    error_code: OK,
+                    error_json: String::new(),
+                    external_memholder_info: Some(
+                        inner.install_external_get_holding(&req.req_node_id, memory_info.clone()),
+                    ),
+                })
+                .collect();
+            release_external_get_start_waiter(inner, &shared_op);
+            ExternalBatchGetStartTransferPlan::InlineLocal { items }
+        } else {
+            inner.external_get_start_registry.insert(
+                handle,
+                Arc::new(ExternalGetStartEntry {
+                    req_node_id: req.req_node_id.clone(),
+                    shared_op,
+                }),
+            );
+            ExternalBatchGetStartTransferPlan::OwnerRpc
+        };
 
         Ok(ExternalBatchGetStartResp {
             error_code: OK,
             error_json: String::new(),
             handle,
             raw_prefix_hit_len: prefix.raw_prefix_hit_len,
+            transfer_plan,
         })
     }
 
@@ -1258,26 +1536,14 @@ impl HandlerForExternalClient for ClientKvApi {
                     for (key, item_result) in keys.iter().zip(shared_items.into_iter()) {
                         match item_result {
                             ExternalGetStartSharedItemResult::Hit { memholder } => {
-                                let memory_info = memholder.memory_info();
-                                inner.external_get_holding.insert(
-                                    NodeHolderKey::new(
-                                        req.req_node_id.clone(),
-                                        memholder.holder_id(),
-                                    ),
-                                    ExternalHoldingGetInfo {
-                                        key: memory_info.key.clone(),
-                                        req_node_id: req.req_node_id.clone(),
-                                        memory_info,
-                                    },
+                                let external_memholder_info = inner.install_external_get_holding(
+                                    &req.req_node_id,
+                                    memholder.memory_info(),
                                 );
                                 items.push(ExternalBatchGetItemResp {
                                     error_code: OK,
                                     error_json: String::new(),
-                                    external_memholder_info: Some(ExternalMemHolderInfo {
-                                        offset: memholder.get_offset(),
-                                        len: memholder.get_length() as u32,
-                                        holder_id: memholder.holder_id(),
-                                    }),
+                                    external_memholder_info: Some(external_memholder_info),
                                 });
                             }
                             ExternalGetStartSharedItemResult::Miss => {
@@ -1322,16 +1588,29 @@ impl HandlerForExternalClient for ClientKvApi {
         let inner = self.inner();
         self.validate_requester_owner_status_updated(req.started_time)?;
 
-        if let Some((_handle, entry)) = inner.external_get_start_registry.remove(&req.handle) {
-            if entry.req_node_id != req.req_node_id {
-                tracing::warn!(
-                    "external_batch_get_cancel req_node_id mismatch: handle={} expected={} got={}",
-                    req.handle,
-                    entry.req_node_id,
-                    req.req_node_id
-                );
+        match req.transfer_plan {
+            ExternalBatchGetCancelPlan::OwnerRpc => {
+                if let Some((_handle, entry)) =
+                    inner.external_get_start_registry.remove(&req.handle)
+                {
+                    if entry.req_node_id != req.req_node_id {
+                        tracing::warn!(
+                            "external_batch_get_cancel req_node_id mismatch: handle={} expected={} got={}",
+                            req.handle,
+                            entry.req_node_id,
+                            req.req_node_id
+                        );
+                    }
+                    release_external_get_start_waiter(inner, &entry.shared_op);
+                }
+            }
+            ExternalBatchGetCancelPlan::InlineLocal { holder_ids } => {
+                for holder_id in holder_ids {
+                    let _ = inner
+                        .external_get_holding
+                        .remove(&NodeHolderKey::new(req.req_node_id.clone(), holder_id));
+                }
             }
-            release_external_get_start_waiter(inner, &entry.shared_op);
         }
         Ok(ExternalBatchGetCancelResp {
             error_code: OK,
@@ -1429,6 +1708,7 @@ impl HandlerForExternalClient for ClientKvApi {
                 replica_target,
                 local_reserve_slot: None,
                 local_reserve_slot_size: None,
+                atomic_group: None,
             },
         );
         if !is_local_target {
@@ -1489,6 +1769,11 @@ impl HandlerForExternalClient for ClientKvApi {
 
         self.validate_requester_owner_status_updated(req.started_time)?;
 
+        let atomic_group_lens = normalize_external_put_start_group_lens(
+            req.items.len(),
+            req.atomic_group_lens.clone(),
+        )?;
+
         let Some(first_item) = req.items.first() else {
             return Ok(ExternalBatchPutStartResp {
                 items: Vec::new(),
@@ -1537,9 +1822,28 @@ impl HandlerForExternalClient for ClientKvApi {
             }
         };
         let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
+        let put_ids = req
+            .items
+            .iter()
+            .map(|_| inner.next_external_local_first_put_id())
+            .collect::<Vec<_>>();
+        let keys_and_put_ids = req
+            .items
+            .iter()
+            .map(|item| item.key.clone())
+            .zip(put_ids.iter().copied())
+            .collect::<Vec<_>>();
+        let atomic_groups =
+            build_put_atomic_group_assignments(&keys_and_put_ids, &atomic_group_lens)
+                .map_err(|detail| KvError::Api(ApiError::InvalidArgument { detail }))?;
         let mut items = Vec::with_capacity(req.items.len());
-        for (req_item, slot_ref) in req.items.into_iter().zip(slot_lease.slots.into_iter()) {
-            let put_id = inner.next_external_local_first_put_id();
+        for (idx, (req_item, slot_ref)) in req
+            .items
+            .into_iter()
+            .zip(slot_lease.slots.into_iter())
+            .enumerate()
+        {
+            let put_id = put_ids[idx];
             let src_offset = slot_ref.ptr.saturating_sub(slot_ref.base_addr);
             inner.external_pending_puts.insert(
                 (req_item.key.clone(), put_id.0, put_id.1),
@@ -1554,6 +1858,7 @@ impl HandlerForExternalClient for ClientKvApi {
                     replica_target: None,
                     local_reserve_slot: Some(slot_ref.clone()),
                     local_reserve_slot_size: Some(slot_lease.slot_size),
+                    atomic_group: atomic_groups[idx].clone(),
                 },
             );
             tracing::debug!(
@@ -1891,6 +2196,9 @@ impl HandlerForExternalClient for ClientKvApi {
                                 put_id,
                                 item.lease_id,
                                 committed_slot,
+                                ctx.make_replica_task,
+                                ctx.preferred_sub_cluster.clone(),
+                                ctx.atomic_group.clone(),
                             );
                             results[idx] = Some(ExternalBatchPutTransferEndItemResp {
                                 error_code: OK,
@@ -2024,6 +2332,7 @@ impl HandlerForExternalClient for ClientKvApi {
                         lease_id: pending.lease_id,
                         committed_slot: None,
                         publish_local_cache: true,
+                        atomic_group: None,
                     })
                     .collect(),
             )
@@ -2360,6 +2669,9 @@ impl HandlerForExternalClient for ClientKvApi {
                                 put_id,
                                 item.lease_id,
                                 committed_slot,
+                                ctx.make_replica_task,
+                                ctx.preferred_sub_cluster.clone(),
+                                ctx.atomic_group.clone(),
                             );
                             results[idx] = Some(ExternalBatchPutCommitItemResp {
                                 error_code: OK,
@@ -2483,6 +2795,7 @@ impl HandlerForExternalClient for ClientKvApi {
                         lease_id: pending.lease_id,
                         committed_slot: None,
                         publish_local_cache: true,
+                        atomic_group: None,
                     })
                     .collect(),
             )
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 88cafa3..363c443 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -1,4 +1,4 @@
-use super::{ClientKvApiInner, GetCachedInfo, KvMetrics};
+use super::{ClientKvApiInner, KvMetrics};
 use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::memholder::{MemoryInfo, UserMemHolder, UserMemHolderExposeKind};
 // no StageScope; timestamps-based metrics only
@@ -266,16 +266,17 @@ impl ClientKvApiInner {
                 peer_is_src_or_target: pending.peer_is_remote,
             };
             if done_item.allocation_mode != GetAllocationMode::Temporary {
-                self.get_cached_info.insert(
-                    pending.key.clone(),
-                    GetCachedInfo {
-                        put_time_ms: pending.start_item.put_id.0,
-                        put_version: pending.start_item.put_id.1,
-                        mem_holder: memory_info.clone(),
-                    },
-                );
-                self.remember_local_snapshot(&pending.key, pending.start_item.put_id);
-                metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
+                if self.install_get_cached_info_if_unfenced(
+                    &pending.key,
+                    pending.start_item.put_id,
+                    memory_info.clone(),
+                ) {
+                    metrics.observe_cache_value_size(
+                        &client_id,
+                        node_role.as_str(),
+                        data_len as u64,
+                    );
+                }
             }
             let user_mem_holder = Arc::new(UserMemHolder::new(
                 memory_info,
@@ -549,16 +550,17 @@ impl ClientKvApiInner {
                 peer_is_src_or_target: pending.peer_is_remote,
             };
             if done_item.allocation_mode != GetAllocationMode::Temporary {
-                self.get_cached_info.insert(
-                    pending.key.clone(),
-                    GetCachedInfo {
-                        put_time_ms: pending.start_item.put_id.0,
-                        put_version: pending.start_item.put_id.1,
-                        mem_holder: memory_info.clone(),
-                    },
-                );
-                self.remember_local_snapshot(&pending.key, pending.start_item.put_id);
-                metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
+                if self.install_get_cached_info_if_unfenced(
+                    &pending.key,
+                    pending.start_item.put_id,
+                    memory_info.clone(),
+                ) {
+                    metrics.observe_cache_value_size(
+                        &client_id,
+                        node_role.as_str(),
+                        data_len as u64,
+                    );
+                }
             }
             let user_mem_holder = Arc::new(UserMemHolder::new(
                 memory_info,
@@ -933,16 +935,9 @@ impl ClientKvApiInner {
         };
 
         if done_resp.allocation_mode != GetAllocationMode::Temporary {
-            self.get_cached_info.insert(
-                key.to_string(),
-                GetCachedInfo {
-                    put_time_ms: put_id.0,
-                    put_version: put_id.1,
-                    mem_holder: memory_info.clone(),
-                },
-            );
-            self.remember_local_snapshot(key, put_id);
-            metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
+            if self.install_get_cached_info_if_unfenced(key, put_id, memory_info.clone()) {
+                metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
+            }
         }
         let user_mem_holder = Arc::new(UserMemHolder::new(
             memory_info,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
index 016f735..cbe5467 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
@@ -2,6 +2,7 @@ use super::{
     ClientKvApiInner, ClientKvApiView, OwnerLocalReserveClassState, OwnerLocalReservePoolState,
 };
 use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
+use crate::master_kv_router::msg_pack::ReserveLocalGrantOutcome;
 use limit_thirdparty::tokio;
 use std::time::{Duration, Instant};
 
@@ -9,56 +10,95 @@ const OWNER_LOCAL_RESERVE_REBALANCE_INTERVAL: Duration = Duration::from_millis(2
 const OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN: Duration = Duration::from_secs(5);
 const OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN: Duration = Duration::from_secs(1);
 const OWNER_LOCAL_RESERVE_DEFAULT_SOFT_WAIT_TIMEOUT: Duration = Duration::from_millis(10);
-const OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT: Duration = Duration::from_secs(1);
-const OWNER_LOCAL_RESERVE_GROW_FACTOR_NUM: usize = 2;
+const OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT: Duration = Duration::from_secs(10);
 const OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS: usize = 0;
+const OWNER_LOCAL_RESERVE_REPORT_INTERVAL: Duration = Duration::from_secs(30);
+const OWNER_LOCAL_RESERVE_FREE_SLOT_HEADROOM_GRANTS: usize = 4;
 
 #[derive(Debug, Clone, Copy)]
-struct RebalanceClassSnapshot {
+struct ExpectedCapacityLayout {
+    value_len: u64,
+    payload_capacity_bytes: u64,
     slot_size: u64,
     slots_per_grant: u32,
-    used_slots: usize,
     grant_count: usize,
-    pending_slot_demand: usize,
 }
 
-fn owner_local_reserve_round_up_grants(bytes: u64) -> u64 {
-    let quantum = OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
-    if bytes == 0 {
-        return 0;
-    }
-    let rem = bytes % quantum;
-    if rem == 0 {
-        bytes
-    } else {
-        bytes.checked_add(quantum - rem).unwrap_or(u64::MAX)
-    }
-}
-
-fn owner_local_reserve_target_bytes(
+#[derive(Debug, Clone, Copy)]
+struct RebalanceClassSnapshot {
     slot_size: u64,
+    slots_per_grant: u32,
     used_slots: usize,
+    free_slots: usize,
+    grant_count: usize,
     pending_slot_demand: usize,
-) -> u64 {
-    let required_slots = used_slots.saturating_add(pending_slot_demand);
-    let required_bytes = (required_slots as u64).saturating_mul(slot_size);
-    let doubled_used = (used_slots as u64)
-        .saturating_mul(slot_size)
-        .saturating_mul(OWNER_LOCAL_RESERVE_GROW_FACTOR_NUM as u64);
-    required_bytes.max(doubled_used)
+    expected_grant_count: usize,
 }
 
 fn owner_local_reserve_target_grant_count(
-    slot_size: u64,
+    slots_per_grant: u32,
     used_slots: usize,
     pending_slot_demand: usize,
+    expected_grant_count: usize,
 ) -> usize {
-    let target_bytes = owner_local_reserve_target_bytes(slot_size, used_slots, pending_slot_demand);
-    let rounded = owner_local_reserve_round_up_grants(target_bytes);
-    if rounded == 0 {
-        return 0;
-    }
-    (rounded / OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES) as usize
+    assert!(
+        slots_per_grant > 0,
+        "local-reserve grant must contain slots"
+    );
+    let required_slots = used_slots.saturating_add(pending_slot_demand);
+    let slots_per_grant = slots_per_grant as usize;
+    let demand_grants =
+        required_slots / slots_per_grant + usize::from(required_slots % slots_per_grant != 0);
+    demand_grants.max(expected_grant_count)
+}
+
+fn owner_local_reserve_desired_free_slots(snapshot: RebalanceClassSnapshot) -> usize {
+    let configured_headroom = if snapshot.expected_grant_count == 0 {
+        0
+    } else {
+        (snapshot.slots_per_grant as usize)
+            .saturating_mul(OWNER_LOCAL_RESERVE_FREE_SLOT_HEADROOM_GRANTS)
+    };
+    snapshot
+        .pending_slot_demand
+        .saturating_add(configured_headroom)
+}
+
+fn configured_expected_capacity(inner: &ClientKvApiInner) -> Option<ExpectedCapacityLayout> {
+    let expected = inner
+        .test_spec_config
+        .owner_local_reserve_expected_capacity
+        .as_ref()?;
+    let slot_size = crate::owner_local_reserve_slot_size_bytes(expected.value_len)
+        .expect("owner local-reserve expected capacity must be config-validated");
+    let slots_per_grant = crate::owner_local_reserve_slots_per_grant(slot_size)
+        .expect("validated local-reserve slot size must fit in a grant");
+    let grant_count = usize::try_from(
+        crate::owner_local_reserve_expected_grant_count(
+            expected.value_len,
+            expected.payload_capacity_bytes,
+        )
+        .expect("owner local-reserve expected capacity must be config-validated"),
+    )
+    .expect("owner local-reserve expected grant count must fit usize");
+    Some(ExpectedCapacityLayout {
+        value_len: expected.value_len,
+        payload_capacity_bytes: expected.payload_capacity_bytes,
+        slot_size,
+        slots_per_grant,
+        grant_count,
+    })
+}
+
+fn install_expected_capacity_class(inner: &ClientKvApiInner) -> Option<ExpectedCapacityLayout> {
+    let expected = configured_expected_capacity(inner)?;
+    let mut pool = inner.owner_local_reserve_pool.lock();
+    let class_state = pool.classes.entry(expected.slot_size).or_insert_with(|| {
+        OwnerLocalReserveClassState::new(expected.slot_size, expected.slots_per_grant)
+    });
+    assert_eq!(class_state.slots_per_grant, expected.slots_per_grant);
+    class_state.expected_grant_count = expected.grant_count;
+    Some(expected)
 }
 
 fn snapshot_rebalance_classes(pool: &OwnerLocalReservePoolState) -> Vec<RebalanceClassSnapshot> {
@@ -68,8 +108,10 @@ fn snapshot_rebalance_classes(pool: &OwnerLocalReservePoolState) -> Vec<Rebalanc
             slot_size: class_state.slot_size,
             slots_per_grant: class_state.slots_per_grant,
             used_slots: class_state.used_slot_count(),
+            free_slots: class_state.free_slot_count(),
             grant_count: class_state.grant_count(),
             pending_slot_demand: class_state.pending_slot_demand,
+            expected_grant_count: class_state.expected_grant_count,
         })
         .collect()
 }
@@ -89,9 +131,6 @@ pub(crate) fn owner_local_reserve_timeout_config(inner: &ClientKvApiInner) -> (D
 }
 
 async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnapshot) {
-    if snapshot.pending_slot_demand == 0 {
-        return;
-    }
     if snapshot.slot_size > OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
         tracing::error!(
             "owner local reserve refill rejected oversized slot_size={} quantum={} pending_slots={}",
@@ -101,48 +140,103 @@ async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
         );
         return;
     }
+    let desired_free_slots = owner_local_reserve_desired_free_slots(snapshot);
     let target_grants = owner_local_reserve_target_grant_count(
-        snapshot.slot_size,
+        snapshot.slots_per_grant,
         snapshot.used_slots,
-        snapshot.pending_slot_demand,
+        desired_free_slots,
+        snapshot.expected_grant_count,
     );
     if snapshot.grant_count >= target_grants {
         return;
     }
     let additional_grants = target_grants - snapshot.grant_count;
+    let batch_started_at = Instant::now();
+    let mut added_grants = 0usize;
+    let mut total_rpc_latency = Duration::ZERO;
+    let mut max_rpc_latency = Duration::ZERO;
     for _ in 0..additional_grants {
-        let grant = match inner.reserve_local_grant().await {
-            Ok(grant) => grant,
+        let missing_slots = desired_free_slots
+            .saturating_sub(snapshot.free_slots)
+            .max(1);
+        let required_free_slots = u32::try_from(missing_slots).unwrap_or(u32::MAX);
+        let reclaim_before_grow = snapshot.expected_grant_count != 0
+            && snapshot.grant_count >= snapshot.expected_grant_count;
+        let rpc_started_at = Instant::now();
+        let outcome = match inner
+            .reserve_local_grant(snapshot.slot_size, required_free_slots, reclaim_before_grow)
+            .await
+        {
+            Ok(outcome) => {
+                let rpc_latency = rpc_started_at.elapsed();
+                total_rpc_latency = total_rpc_latency.saturating_add(rpc_latency);
+                max_rpc_latency = max_rpc_latency.max(rpc_latency);
+                outcome
+            }
             Err(err) => {
+                let rpc_latency = rpc_started_at.elapsed();
                 tracing::warn!(
-                    "owner local reserve refill failed: slot_size={} pending_slots={} err={}",
+                    "owner local reserve refill failed: slot_size={} pending_slots={} grants={} target_grants={} expected_grants={} added_grants={} rpc_latency_ms={} err={}",
                     snapshot.slot_size,
                     snapshot.pending_slot_demand,
+                    snapshot.grant_count,
+                    target_grants,
+                    snapshot.expected_grant_count,
+                    added_grants,
+                    rpc_latency.as_millis(),
                     err
                 );
                 return;
             }
         };
-        if grant.len != OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
+        let (grant_id, base_addr, addr, len) = match outcome {
+            ReserveLocalGrantOutcome::Granted {
+                grant_id,
+                node_id: _,
+                addr,
+                base_addr,
+                len,
+            } => (grant_id, base_addr, addr, len),
+            ReserveLocalGrantOutcome::Reclaimed {
+                slot_size,
+                reclaimed_slots,
+            } => {
+                assert_eq!(slot_size, snapshot.slot_size);
+                tracing::info!(
+                    "owner local reserve reused reclaimed slots: slot_size={} reclaimed_slots={} pending_slots={}",
+                    slot_size,
+                    reclaimed_slots,
+                    snapshot.pending_slot_demand
+                );
+                inner
+                    .owner_local_reserve_rebalance_notify()
+                    .notify_waiters();
+                return;
+            }
+            ReserveLocalGrantOutcome::None => {
+                unreachable!("reserve_local_grant filters empty successful outcomes")
+            }
+        };
+        if len != OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
             tracing::warn!(
                 "owner local reserve refill got unexpected grant size: requested={} got={}",
                 OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
-                grant.len
+                len
             );
-            if let Err(release_err) = inner.release_local_grant(grant.grant_id).await {
+            if let Err(release_err) = inner.release_local_grant(grant_id).await {
                 tracing::warn!(
                     "owner local reserve refill failed to release mismatched grant_id={} err={}",
-                    grant.grant_id,
+                    grant_id,
                     release_err
                 );
             }
             return;
         }
         let detached_grant = super::OwnerLocalReserveGrantState::new(
-            grant.grant_id,
-            grant.base_addr,
-            grant.addr,
-            grant.len,
+            grant_id,
+            base_addr,
+            addr,
+            len,
             snapshot.slot_size,
             snapshot.slots_per_grant,
         );
@@ -154,60 +248,84 @@ async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
             class_state.last_grow_at = Some(Instant::now());
             class_state.grants.push(detached_grant);
         }
+        added_grants += 1;
         inner
             .owner_local_reserve_rebalance_notify()
             .notify_waiters();
     }
+    if added_grants != 0 {
+        let average_rpc_latency_ms = total_rpc_latency.as_secs_f64() * 1000.0 / added_grants as f64;
+        tracing::info!(
+            "owner local reserve refill batch completed: slot_size={} added_grants={} grants_after={} target_grants={} expected_grants={} pending_slots={} elapsed_ms={} rpc_avg_ms={:.3} rpc_max_ms={}",
+            snapshot.slot_size,
+            added_grants,
+            snapshot.grant_count.saturating_add(added_grants),
+            target_grants,
+            snapshot.expected_grant_count,
+            snapshot.pending_slot_demand,
+            batch_started_at.elapsed().as_millis(),
+            average_rpc_latency_ms,
+            max_rpc_latency.as_millis()
+        );
+    }
 }
 
-async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnapshot) {
-    let detached = {
-        let mut pool = inner.owner_local_reserve_pool.lock();
-        let Some(class_state) = pool.classes.get_mut(&snapshot.slot_size) else {
-            return;
-        };
-        if class_state.pending_slot_demand > 0 {
-            return;
-        }
+fn detach_excess_fully_free_grant(
+    class_state: &mut OwnerLocalReserveClassState,
+    get_target_pressure: bool,
+) -> Option<(usize, super::OwnerLocalReserveGrantState)> {
+    if !get_target_pressure {
         let grow_cooldown_ok = class_state
             .last_grow_at
             .map(|last_grow_at| last_grow_at.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN)
             .unwrap_or(true);
         if !grow_cooldown_ok {
-            return;
-        }
-        let shrink_keep_grants = owner_local_reserve_target_grant_count(
-            class_state.slot_size,
-            class_state.used_slot_count(),
-            class_state.pending_slot_demand,
-        )
-        .max(OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS);
-        if class_state.grants.len() <= shrink_keep_grants {
-            return;
+            return None;
         }
-        let should_detach_tail = class_state
+    }
+    let shrink_keep_grants = owner_local_reserve_target_grant_count(
+        class_state.slots_per_grant,
+        class_state.used_slot_count(),
+        class_state.pending_slot_demand,
+        class_state.expected_grant_count,
+    )
+    .max(OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS);
+    if class_state.grants.len() <= shrink_keep_grants {
+        return None;
+    }
+
+    let candidate_index = if get_target_pressure {
+        // A physical Get-target allocation can be blocked while reclaimed slots remain trapped in
+        // a detached 512-MiB reserve grant. Under explicit pressure, any fully-free excess grant is
+        // safe to return; restricting the actor to the tail would leave allocator space stranded.
+        class_state
             .grants
-            .last()
-            .map(|grant| {
-                grant.is_fully_free()
-                    && grant
-                        .fully_free_since
-                        .map(|since| since.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN)
-                        .unwrap_or(false)
-            })
-            .unwrap_or(false);
-        if !should_detach_tail {
+            .iter()
+            .rposition(super::OwnerLocalReserveGrantState::is_fully_free)
+    } else {
+        let tail_index = class_state.grants.len().checked_sub(1)?;
+        class_state.grants.get(tail_index).and_then(|grant| {
+            (grant.is_fully_free()
+                && grant
+                    .fully_free_since
+                    .map(|since| since.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN)
+                    .unwrap_or(false))
+            .then_some(tail_index)
+        })
+    }?;
+    Some((candidate_index, class_state.grants.remove(candidate_index)))
+}
+
+async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnapshot) {
+    let detached = {
+        let mut pool = inner.owner_local_reserve_pool.lock();
+        let Some(class_state) = pool.classes.get_mut(&snapshot.slot_size) else {
             return;
-        }
-        Some(
-            class_state
-                .grants
-                .pop()
-                .expect("tail grant must exist when shrinking local reserve"),
-        )
+        };
+        detach_excess_fully_free_grant(class_state, false)
     };
 
-    let Some(grant) = detached else {
+    let Some((grant_index, grant)) = detached else {
         return;
     };
 
@@ -221,7 +339,223 @@ async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
         let class_state = pool.classes.entry(snapshot.slot_size).or_insert_with(|| {
             OwnerLocalReserveClassState::new(snapshot.slot_size, snapshot.slots_per_grant)
         });
-        class_state.grants.push(grant);
+        class_state
+            .grants
+            .insert(grant_index.min(class_state.grants.len()), grant);
+    } else {
+        tracing::info!(
+            "owner local reserve released excess grant: slot_size={} grant_id={} pending_slots={}",
+            snapshot.slot_size,
+            grant.grant_id,
+            snapshot.pending_slot_demand
+        );
+    }
+}
+
+/// Return one fully-free reserve grant immediately when an ordinary local Get-target allocation
+/// reports physical NoSpace. This never shrinks below the configured/active reserve target and does
+/// not evict a live slot; it only makes already-free physical capacity visible to the master
+/// allocator without waiting for the periodic idle cooldown.
+pub(crate) async fn release_one_excess_reserve_grant_for_get_target_pressure(
+    inner: &ClientKvApiInner,
+) -> bool {
+    let detached = {
+        let mut pool = inner.owner_local_reserve_pool.lock();
+        let mut detached = None;
+        for class_state in pool.classes.values_mut() {
+            if let Some((grant_index, grant)) = detach_excess_fully_free_grant(class_state, true) {
+                detached = Some((
+                    class_state.slot_size,
+                    class_state.slots_per_grant,
+                    class_state.pending_slot_demand,
+                    grant_index,
+                    grant,
+                ));
+                break;
+            }
+        }
+        detached
+    };
+    let Some((slot_size, slots_per_grant, pending_slots, grant_index, grant)) = detached else {
+        return false;
+    };
+    let grant_id = grant.grant_id;
+
+    if let Err(err) = inner.release_local_grant(grant_id).await {
+        tracing::warn!(
+            "owner local reserve get-target pressure failed to release grant_id={} err={}",
+            grant_id,
+            err
+        );
+        let mut pool = inner.owner_local_reserve_pool.lock();
+        let class_state = pool
+            .classes
+            .entry(slot_size)
+            .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+        class_state
+            .grants
+            .insert(grant_index.min(class_state.grants.len()), grant);
+        inner
+            .owner_local_reserve_rebalance_notify()
+            .notify_waiters();
+        false
+    } else {
+        tracing::info!(
+            "owner local reserve released excess grant for get-target pressure: slot_size={} grant_id={} pending_slots={}",
+            slot_size,
+            grant_id,
+            pending_slots
+        );
+        inner
+            .owner_local_reserve_rebalance_notify()
+            .notify_waiters();
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client_kv_api::OwnerLocalReserveGrantState;
+
+    const SLOT_SIZE: u64 = 8 * 1024 * 1024;
+
+    #[test]
+    fn target_grants_cover_used_and_pending_without_double_reserving() {
+        let slots_per_grant = crate::owner_local_reserve_slots_per_grant(SLOT_SIZE).unwrap();
+        assert_eq!(
+            owner_local_reserve_target_grant_count(slots_per_grant, 128, 1, 0),
+            3
+        );
+        assert_eq!(
+            owner_local_reserve_target_grant_count(slots_per_grant, 128, 0, 0),
+            2
+        );
+        assert_eq!(
+            owner_local_reserve_target_grant_count(slots_per_grant, 0, 0, 0),
+            0
+        );
+    }
+
+    #[test]
+    fn exact_fit_target_accounts_for_unusable_grant_tail() {
+        const VALUE_LEN: u64 = 4_718_592;
+        const EXPECTED_PAYLOAD_BYTES: u64 = 109_951_162_777;
+        let slot_size = crate::owner_local_reserve_slot_size_bytes(VALUE_LEN).unwrap();
+        let slots_per_grant = crate::owner_local_reserve_slots_per_grant(slot_size).unwrap();
+        let expected_grants =
+            crate::owner_local_reserve_expected_grant_count(VALUE_LEN, EXPECTED_PAYLOAD_BYTES)
+                .unwrap();
+        assert_eq!(slot_size, VALUE_LEN);
+        assert_eq!(slots_per_grant, 113);
+        assert_eq!(expected_grants, 207);
+        assert_eq!(
+            owner_local_reserve_target_grant_count(slots_per_grant, 0, 0, expected_grants as usize,),
+            207
+        );
+    }
+
+    #[test]
+    fn default_hard_timeout_covers_pressure_reclaim_transaction() {
+        assert_eq!(
+            OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT,
+            Duration::from_secs(10)
+        );
+        assert!(
+            OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT > OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN
+        );
+    }
+
+    #[test]
+    fn configured_pool_refills_before_pending_claims_consume_headroom() {
+        let snapshot = RebalanceClassSnapshot {
+            slot_size: SLOT_SIZE,
+            slots_per_grant: 64,
+            used_slots: 64 * 228,
+            free_slots: 64 * 4,
+            grant_count: 232,
+            pending_slot_demand: 0,
+            expected_grant_count: 232,
+        };
+        assert_eq!(owner_local_reserve_desired_free_slots(snapshot), 64 * 4);
+        assert_eq!(
+            owner_local_reserve_target_grant_count(
+                snapshot.slots_per_grant,
+                snapshot.used_slots,
+                owner_local_reserve_desired_free_slots(snapshot),
+                snapshot.expected_grant_count,
+            ),
+            232
+        );
+
+        let pressured = RebalanceClassSnapshot {
+            used_slots: snapshot.used_slots + 1,
+            free_slots: snapshot.free_slots - 1,
+            ..snapshot
+        };
+        assert_eq!(
+            owner_local_reserve_target_grant_count(
+                pressured.slots_per_grant,
+                pressured.used_slots,
+                owner_local_reserve_desired_free_slots(pressured),
+                pressured.expected_grant_count,
+            ),
+            233
+        );
+    }
+
+    #[test]
+    fn get_target_pressure_can_detach_a_non_tail_fully_free_excess_grant() {
+        let mut class_state = OwnerLocalReserveClassState::new(SLOT_SIZE, 2);
+        class_state.expected_grant_count = 1;
+        for grant_id in 1..=3 {
+            class_state.grants.push(OwnerLocalReserveGrantState::new(
+                grant_id,
+                0,
+                grant_id * 1024,
+                1024,
+                SLOT_SIZE,
+                2,
+            ));
+        }
+        class_state.grants[0]
+            .claim_prepared_slot()
+            .expect("first grant must have a slot");
+        class_state.grants[2]
+            .claim_prepared_slot()
+            .expect("tail grant must have a slot");
+
+        assert!(detach_excess_fully_free_grant(&mut class_state, false).is_none());
+        let (index, grant) = detach_excess_fully_free_grant(&mut class_state, true)
+            .expect("pressure shrink must find the free middle grant");
+        assert_eq!(index, 1);
+        assert_eq!(grant.grant_id, 2);
+        assert_eq!(class_state.grants.len(), 2);
+    }
+
+    #[test]
+    fn get_target_pressure_never_shrinks_below_active_or_expected_target() {
+        let mut class_state = OwnerLocalReserveClassState::new(SLOT_SIZE, 2);
+        class_state.expected_grant_count = 2;
+        for grant_id in 1..=2 {
+            class_state.grants.push(OwnerLocalReserveGrantState::new(
+                grant_id,
+                0,
+                grant_id * 1024,
+                1024,
+                SLOT_SIZE,
+                2,
+            ));
+        }
+        assert!(detach_excess_fully_free_grant(&mut class_state, true).is_none());
+
+        class_state.expected_grant_count = 0;
+        for grant in &mut class_state.grants {
+            grant
+                .claim_prepared_slot()
+                .expect("each grant must have a slot");
+        }
+        assert!(detach_excess_fully_free_grant(&mut class_state, true).is_none());
     }
 }
 
@@ -237,9 +571,51 @@ async fn owner_local_reserve_rebalance_once(view: &ClientKvApiView) {
     }
 }
 
+fn report_owner_local_reserve_state(inner: &ClientKvApiInner) {
+    let snapshots = {
+        let pool = inner.owner_local_reserve_pool.lock();
+        snapshot_rebalance_classes(&pool)
+    };
+    for snapshot in snapshots {
+        let grant_count = u64::try_from(snapshot.grant_count).unwrap_or(u64::MAX);
+        let used_slots = u64::try_from(snapshot.used_slots).unwrap_or(u64::MAX);
+        let free_slots = u64::try_from(snapshot.free_slots).unwrap_or(u64::MAX);
+        let reserved_slots = grant_count.saturating_mul(u64::from(snapshot.slots_per_grant));
+        tracing::info!(
+            "owner local reserve state: slot_size={} used_slots={} free_slots={} pending_slots={} grants={} expected_grants={} reserved_slots={} used_slot_bytes={} usable_slot_bytes={} physical_reserved_bytes={}",
+            snapshot.slot_size,
+            snapshot.used_slots,
+            snapshot.free_slots,
+            snapshot.pending_slot_demand,
+            snapshot.grant_count,
+            snapshot.expected_grant_count,
+            reserved_slots,
+            used_slots.saturating_mul(snapshot.slot_size),
+            used_slots
+                .saturating_add(free_slots)
+                .saturating_mul(snapshot.slot_size),
+            grant_count.saturating_mul(OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES),
+        );
+    }
+}
+
 pub fn spawn_owner_local_reserve_rebalance_actor(view: ClientKvApiView) {
     let view_task = view.clone();
     view.spawn("owner_local_reserve_rebalance_actor", async move {
+        let expected = install_expected_capacity_class(view_task.client_kv_api().inner());
+        if let Some(expected) = expected {
+            tracing::info!(
+                "owner local reserve expected capacity configured: value_len={} payload_capacity_bytes={} slot_size={} slots_per_grant={} expected_grants={} physical_reserved_target_bytes={}",
+                expected.value_len,
+                expected.payload_capacity_bytes,
+                expected.slot_size,
+                expected.slots_per_grant,
+                expected.grant_count,
+                u64::try_from(expected.grant_count)
+                    .unwrap_or(u64::MAX)
+                    .saturating_mul(OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES),
+            );
+        }
         let shutdown_poller = view_task.register_shutdown_poller();
         let mut shutdown_waiter = view_task.register_shutdown_waiter();
         let notify = view_task
@@ -247,6 +623,7 @@ pub fn spawn_owner_local_reserve_rebalance_actor(view: ClientKvApiView) {
             .inner()
             .owner_local_reserve_rebalance_notify();
         let mut tick = tokio::time::interval(OWNER_LOCAL_RESERVE_REBALANCE_INTERVAL);
+        let mut last_report_at = Instant::now();
 
         loop {
             tokio::select! {
@@ -265,6 +642,10 @@ pub fn spawn_owner_local_reserve_rebalance_actor(view: ClientKvApiView) {
             }
 
             owner_local_reserve_rebalance_once(&view_task).await;
+            if last_report_at.elapsed() >= OWNER_LOCAL_RESERVE_REPORT_INTERVAL {
+                report_owner_local_reserve_state(view_task.client_kv_api().inner());
+                last_report_at = Instant::now();
+            }
         }
     });
 }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index 544d5e6..898172b 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -13,16 +13,18 @@ use crate::client_kv_api::msg_pack::{
     ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
     ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
 };
+use crate::client_kv_api::reclaim::handle_batch_owner_reclaim;
 use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::config::TestSpecConfig;
 use crate::master_kv_router::msg_pack::{
-    BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchGetDoneReq, BatchGetRevokeReq,
-    BatchGetStartItemResp, BatchGetStartReq, BatchIsExistReq, BatchPreparePutKeysReq,
-    BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq,
-    CountPrefixReq, DeleteClientKvMetaCacheItem,
+    BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
+    BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartItemResp, BatchGetStartReq, BatchIsExistReq,
+    BatchOwnerReclaimReq, BatchPreparePutKeysReq, BatchPutDoneReq, BatchPutRevokeReq,
+    BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq,
+    DeleteClientKvMetaCacheItem, GroupedBatchPutDoneReq,
 };
 use crate::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
-use crate::memholder::{AllMemholderRefCount, MemoryInfo, UserMemHolder};
+use crate::memholder::{AllMemholderRefCount, ExternalMemHolderInfo, MemoryInfo, UserMemHolder};
 use crate::memholder::{
     EnsureMemholderMgmtDeleteHandle, MemholderManagerTrait, NodeHolderKey, OwnerDeleteAckItem,
     OwnerDeleteAckMemMgr, OwnerExternalMemMgr,
@@ -49,11 +51,13 @@ use crate::{
 };
 use async_trait::async_trait;
 use crossbeam::queue::SegQueue;
-use dashmap::DashMap;
+use dashmap::{DashMap, DashSet};
 use fluxon_framework::{LogicalModule, define_module};
 use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 use fluxon_util::map_lock::AMapLock;
 use limit_thirdparty::tokio;
+use moka::notification::RemovalCause;
+use moka::ops::compute::Op as MokaComputeOp;
 use parking_lot::{Mutex, RwLock};
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -64,6 +68,10 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tracing::warn;
 
 const REPLICA_TASK_QUEUE_CAPACITY: usize = 128;
+// Queue only weak source references. This preserves a deep policy backlog without turning queued
+// write-back work into non-reclaimable owner memory; the dispatcher pins a still-current source
+// immediately before handing it to the bounded replica-task actor.
+const OWNER_HOT_EVICTION_QUEUE_CAPACITY: usize = 4096;
 const OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY: usize = 4096;
 const OWNER_LOCAL_PUBLISH_MAX_INFLIGHT: usize = 64;
 
@@ -80,12 +88,37 @@ pub struct OwnerRuntimeObserveSnapshot {
     pub external_get_holding_entries: u64,
     pub external_get_holding_bytes: u64,
     pub external_pending_put_entries: u64,
+    pub hot_cache_capacity_bytes: u64,
+    pub hot_cache_entries: u64,
+    pub hot_cache_weighted_bytes: u64,
+    pub hot_size_evictions: u64,
+    pub hot_replica_enqueued: u64,
+    pub hot_replica_completed: u64,
+    pub hot_replica_already_satisfied: u64,
+    pub hot_replica_failed: u64,
+    pub hot_replica_obsolete: u64,
+    pub hot_replica_dispatch_failed: u64,
+    pub hot_replica_inflight: u64,
+    pub hot_eviction_skipped_stale: u64,
+    pub hot_eviction_skipped_reclaim: u64,
+    pub hot_eviction_skipped_duplicate: u64,
+    pub hot_group_registry_entries: u64,
+    pub hot_group_replica_triggered: u64,
+    pub hot_group_replica_triggers: u64,
+    pub hot_group_members_enqueued: u64,
+    pub hot_group_trigger_duplicates: u64,
+    pub hot_group_trigger_incomplete: u64,
+    pub grouped_put_done_batches: u64,
+    pub grouped_put_done_items: u64,
+    pub legacy_put_done_batches: u64,
+    pub legacy_put_done_items: u64,
 }
 
 pub use get::RemoteGetInfo;
 pub use put::{OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerReservedPutItem};
 pub mod external_api;
 mod local_reserve_rebalance;
+mod reclaim;
 pub use external_api::HandlerForExternalClient;
 pub type TestObservePutPhaseSink = Arc<Mutex<Option<TestPutPhaseTrace>>>;
 pub type ExternalGetStartTransferOutput =
@@ -153,6 +186,8 @@ pub struct ExternalGetStartSharedState {
 pub struct ExternalGetStartSharedOp {
     pub dedup_key: ExternalGetStartDedupKey,
     pub transfer_concurrency: usize,
+    /// Set only when every requested page is already owner-local.
+    pub inline_local_memory_infos: OnceLock<Vec<Arc<MemoryInfo>>>,
     pub state: Mutex<ExternalGetStartSharedState>,
     pub notify: Arc<limit_thirdparty::tokio::sync::Notify>,
 }
@@ -162,6 +197,7 @@ impl ExternalGetStartSharedOp {
         Self {
             dedup_key,
             transfer_concurrency,
+            inline_local_memory_infos: OnceLock::new(),
             state: Mutex::new(ExternalGetStartSharedState {
                 waiter_count: 1,
                 phase: ExternalGetStartSharedPhase::Starting,
@@ -1079,6 +1115,8 @@ define_module!(
 #[derive(Clone, Debug)]
 pub struct ClientKvApiNewArg {
     pub test_spec_config: TestSpecConfig,
+    /// Logical hot-tier capacity only. This does not resize the owner segment.
+    pub owner_hot_cache_capacity_bytes: Option<u64>,
 }
 
 pub struct ClientKvApi(ClientKvApiInner);
@@ -1101,24 +1139,646 @@ pub(crate) struct LocalSnapshotInfo {
     put_version: u32,
 }
 
-impl GetCachedInfo {
-    fn version_matches(&self, put_time_ms: u64, put_version: u32) -> bool {
-        if self.put_time_ms == put_time_ms {
-            self.put_version <= put_version
-        } else {
-            self.put_time_ms <= put_time_ms
+#[derive(Clone)]
+struct OwnerHotCacheEntry {
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    memory_info: Weak<MemoryInfo>,
+    weight_bytes: u32,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+struct OwnerHotReplicaIdentity {
+    key: String,
+    put_time_ms: u64,
+    put_version: u32,
+}
+
+impl OwnerHotReplicaIdentity {
+    fn from_group_member(member: &crate::master_kv_router::msg_pack::PutAtomicGroupMember) -> Self {
+        Self {
+            key: member.key.clone(),
+            put_time_ms: member.put_id.0,
+            put_version: member.put_id.1,
         }
     }
 }
 
-impl LocalSnapshotInfo {
-    fn version_matches(&self, put_time_ms: u64, put_version: u32) -> bool {
-        if self.put_time_ms == put_time_ms {
-            self.put_version <= put_version
-        } else {
-            self.put_time_ms <= put_time_ms
+#[derive(Default)]
+struct OwnerHotCacheCounters {
+    size_evictions: AtomicU64,
+    replica_enqueued: AtomicU64,
+    replica_completed: AtomicU64,
+    replica_already_satisfied: AtomicU64,
+    replica_failed: AtomicU64,
+    replica_obsolete: AtomicU64,
+    replica_dispatch_failed: AtomicU64,
+    skipped_stale: AtomicU64,
+    skipped_reclaim: AtomicU64,
+    skipped_duplicate: AtomicU64,
+    group_replica_triggers: AtomicU64,
+    group_members_enqueued: AtomicU64,
+    group_trigger_duplicates: AtomicU64,
+    group_trigger_incomplete: AtomicU64,
+    grouped_put_done_batches: AtomicU64,
+    grouped_put_done_items: AtomicU64,
+    legacy_put_done_batches: AtomicU64,
+    legacy_put_done_items: AtomicU64,
+}
+
+const OWNER_HOT_REPLICA_OUTCOME_PENDING: u32 = 0;
+const OWNER_HOT_REPLICA_OUTCOME_RECORDED: u32 = 1;
+
+pub(crate) struct OwnerHotReplicaGuard {
+    identity: OwnerHotReplicaIdentity,
+    inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    counters: Arc<OwnerHotCacheCounters>,
+    group_trigger: Option<OwnerHotReplicaIdentity>,
+    group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    outcome: AtomicU32,
+}
+
+impl OwnerHotReplicaGuard {
+    fn new(
+        identity: OwnerHotReplicaIdentity,
+        inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
+        counters: Arc<OwnerHotCacheCounters>,
+        group_trigger: Option<OwnerHotReplicaIdentity>,
+        group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    ) -> Self {
+        Self {
+            identity,
+            inflight,
+            counters,
+            group_trigger,
+            group_replica_triggered,
+            outcome: AtomicU32::new(OWNER_HOT_REPLICA_OUTCOME_PENDING),
+        }
+    }
+
+    fn release_group_trigger(&self) {
+        if let Some(group_trigger) = self.group_trigger.as_ref() {
+            self.group_replica_triggered.remove(group_trigger);
+        }
+    }
+
+    pub(crate) fn mark_completed(&self) {
+        if self
+            .outcome
+            .compare_exchange(
+                OWNER_HOT_REPLICA_OUTCOME_PENDING,
+                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            )
+            .is_ok()
+        {
+            self.counters
+                .replica_completed
+                .fetch_add(1, Ordering::Relaxed);
+        }
+    }
+
+    pub(crate) fn mark_already_satisfied(&self) {
+        if self
+            .outcome
+            .compare_exchange(
+                OWNER_HOT_REPLICA_OUTCOME_PENDING,
+                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            )
+            .is_ok()
+        {
+            self.counters
+                .replica_already_satisfied
+                .fetch_add(1, Ordering::Relaxed);
+        }
+    }
+
+    pub(crate) fn mark_obsolete(&self) {
+        if self
+            .outcome
+            .compare_exchange(
+                OWNER_HOT_REPLICA_OUTCOME_PENDING,
+                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            )
+            .is_ok()
+        {
+            self.counters
+                .replica_obsolete
+                .fetch_add(1, Ordering::Relaxed);
+            self.release_group_trigger();
+        }
+    }
+
+    fn mark_dispatch_failed(&self) {
+        if self
+            .outcome
+            .compare_exchange(
+                OWNER_HOT_REPLICA_OUTCOME_PENDING,
+                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
+                Ordering::Relaxed,
+                Ordering::Relaxed,
+            )
+            .is_ok()
+        {
+            self.counters
+                .replica_dispatch_failed
+                .fetch_add(1, Ordering::Relaxed);
+            self.release_group_trigger();
+        }
+    }
+}
+
+impl Drop for OwnerHotReplicaGuard {
+    fn drop(&mut self) {
+        if self.outcome.load(Ordering::Relaxed) == OWNER_HOT_REPLICA_OUTCOME_PENDING {
+            self.counters.replica_failed.fetch_add(1, Ordering::Relaxed);
+            self.release_group_trigger();
+        }
+        self.inflight.remove(&self.identity);
+    }
+}
+
+pub(crate) struct OwnerHotEvictionEvent {
+    key: String,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    memory_info: Weak<MemoryInfo>,
+    guard: OwnerHotReplicaGuard,
+}
+
+pub(crate) struct OwnerPreparedReclaim {
+    item: crate::master_kv_router::msg_pack::OwnerReclaimItem,
+    cached_info: GetCachedInfo,
+    local_snapshot: Option<LocalSnapshotInfo>,
+}
+
+pub(crate) enum OwnerReclaimRecord {
+    Prepared(OwnerPreparedReclaim),
+    Committed(crate::master_kv_router::msg_pack::OwnerReclaimItem),
+}
+
+#[derive(Default)]
+pub(crate) struct OwnerKeyControlState {
+    local_puts: u32,
+    reclaim: Option<OwnerReclaimRecord>,
+}
+
+fn resolve_local_visible_batch<T>(
+    keys: &[String],
+    controls: &HashMap<String, OwnerKeyControlState>,
+    mut resolve_unfenced: impl FnMut(&str) -> Option<T>,
+) -> Vec<Option<T>> {
+    keys.iter()
+        .map(|key| {
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                None
+            } else {
+                resolve_unfenced(key)
+            }
+        })
+        .collect()
+}
+
+fn allocate_external_holding_id(counter: &AtomicU64) -> u64 {
+    counter
+        .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |current| {
+            current.checked_add(1)
+        })
+        .expect("external holding id space exhausted")
+}
+
+fn owner_hot_weight_bytes(memory_info: &MemoryInfo) -> u32 {
+    let bytes = memory_info
+        .local_reserve_resident_slot_ref()
+        .map(|(slot_size, _, _)| slot_size)
+        .unwrap_or(memory_info.len as u64);
+    u32::try_from(bytes).unwrap_or(u32::MAX)
+}
+
+fn clone_if_owner_hot_entry_matches<T>(
+    current_put_id: crate::master_kv_router::put::PutIDForAKey,
+    current: &Arc<T>,
+    entry_put_id: crate::master_kv_router::put::PutIDForAKey,
+    entry: &Weak<T>,
+) -> Option<Arc<T>> {
+    (current_put_id == entry_put_id && Weak::ptr_eq(entry, &Arc::downgrade(current)))
+        .then(|| current.clone())
+}
+
+fn pin_current_owner_hot_source(
+    key: &str,
+    entry: &OwnerHotCacheEntry,
+    owner_key_control: &Mutex<HashMap<String, OwnerKeyControlState>>,
+    get_cached_info: &DashMap<String, GetCachedInfo>,
+    counters: &OwnerHotCacheCounters,
+) -> Option<Arc<MemoryInfo>> {
+    let controls = owner_key_control.lock();
+    if controls
+        .get(key)
+        .is_some_and(|state| state.reclaim.is_some())
+    {
+        counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
+        return None;
+    }
+    let Some(cached) = get_cached_info.get(key) else {
+        counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+        return None;
+    };
+    let Some(pinned) = clone_if_owner_hot_entry_matches(
+        (cached.put_time_ms, cached.put_version),
+        &cached.mem_holder,
+        entry.put_id,
+        &entry.memory_info,
+    ) else {
+        counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+        return None;
+    };
+
+    // This clone is made under the same key fence used by reclaim. If reclaim
+    // wins first the source is absent/fenced; if this clone wins, reclaim sees
+    // the additional strong reference and returns Busy.
+    Some(pinned)
+}
+
+fn owner_hot_group_anchor_identity(
+    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
+) -> Option<OwnerHotReplicaIdentity> {
+    group
+        .members
+        .first()
+        .map(OwnerHotReplicaIdentity::from_group_member)
+}
+
+fn register_owner_hot_atomic_group(
+    atomic_groups: &DashMap<
+        OwnerHotReplicaIdentity,
+        Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
+    >,
+    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
+) {
+    let Some(anchor) = owner_hot_group_anchor_identity(group) else {
+        return;
+    };
+    let existing = atomic_groups
+        .get(&anchor)
+        .map(|entry| entry.value().clone());
+    let group = match existing {
+        Some(existing) if existing.as_ref() == group => existing,
+        Some(_) => {
+            tracing::warn!(
+                "owner hot atomic-group anchor reused with different membership: key={} put_id=({},{})",
+                anchor.key,
+                anchor.put_time_ms,
+                anchor.put_version
+            );
+            Arc::new(group.clone())
+        }
+        None => Arc::new(group.clone()),
+    };
+    for member in &group.members {
+        atomic_groups.insert(
+            OwnerHotReplicaIdentity::from_group_member(member),
+            group.clone(),
+        );
+    }
+}
+
+fn forget_owner_hot_atomic_group(
+    atomic_groups: &DashMap<
+        OwnerHotReplicaIdentity,
+        Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
+    >,
+    group_replica_triggered: &DashSet<OwnerHotReplicaIdentity>,
+    identity: &OwnerHotReplicaIdentity,
+) {
+    let group = atomic_groups
+        .get(identity)
+        .map(|entry| entry.value().clone());
+    let Some(group) = group else {
+        return;
+    };
+    if let Some(anchor) = owner_hot_group_anchor_identity(group.as_ref()) {
+        group_replica_triggered.remove(&anchor);
+    }
+    for member in &group.members {
+        atomic_groups.remove(&OwnerHotReplicaIdentity::from_group_member(member));
+    }
+}
+
+fn pin_current_owner_hot_group_sources(
+    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
+    owner_key_control: &Mutex<HashMap<String, OwnerKeyControlState>>,
+    get_cached_info: &DashMap<String, GetCachedInfo>,
+    counters: &OwnerHotCacheCounters,
+) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
+    let controls = owner_key_control.lock();
+    let mut sources = Vec::with_capacity(group.members.len());
+    for member in &group.members {
+        if controls
+            .get(&member.key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
+            return None;
+        }
+        let Some(cached) = get_cached_info.get(&member.key) else {
+            counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+            return None;
+        };
+        if (cached.put_time_ms, cached.put_version) != member.put_id {
+            counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+            return None;
         }
+        sources.push((
+            OwnerHotReplicaIdentity::from_group_member(member),
+            cached.mem_holder.clone(),
+        ));
     }
+    Some(sources)
+}
+
+fn owner_hot_tp_cohort_key_rows(
+    identity: &OwnerHotReplicaIdentity,
+    group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
+) -> Result<Option<Vec<Vec<String>>>, ()> {
+    let member_keys = group
+        .map(|group| {
+            group
+                .members
+                .iter()
+                .map(|member| member.key.as_str())
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_else(|| vec![identity.key.as_str()]);
+    let Some(first_key) = member_keys.first().copied() else {
+        return Err(());
+    };
+    let first_tp = crate::master_kv_router::infer_sglang_tp_key(first_key);
+    let Some(first_tp) = first_tp else {
+        return member_keys
+            .iter()
+            .all(|key| crate::master_kv_router::infer_sglang_tp_key(key).is_none())
+            .then_some(None)
+            .ok_or(());
+    };
+    let mut logical_members = Vec::with_capacity(member_keys.len());
+    for key in member_keys {
+        let Some(member_tp) = crate::master_kv_router::infer_sglang_tp_key(key) else {
+            return Err(());
+        };
+        if member_tp.rank != first_tp.rank || member_tp.size != first_tp.size {
+            return Err(());
+        }
+        logical_members.push(member_tp.logical_prefix.to_string());
+    }
+    if first_tp.size == 1 {
+        return Ok(None);
+    }
+    Ok(Some(
+        (0..first_tp.size)
+            .map(|rank| {
+                logical_members
+                    .iter()
+                    .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", first_tp.size))
+                    .collect::<Vec<_>>()
+            })
+            .collect(),
+    ))
+}
+
+fn pin_current_owner_hot_tp_cohort_sources(
+    cohort_key_rows: &[Vec<String>],
+    expect_atomic_group: bool,
+    owner_key_control: &Mutex<HashMap<String, OwnerKeyControlState>>,
+    get_cached_info: &DashMap<String, GetCachedInfo>,
+    atomic_groups: &DashMap<
+        OwnerHotReplicaIdentity,
+        Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
+    >,
+    counters: &OwnerHotCacheCounters,
+) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
+    let controls = owner_key_control.lock();
+    let mut cohort_sources = Vec::new();
+    for rank_keys in cohort_key_rows {
+        if rank_keys.is_empty() {
+            return None;
+        }
+        let mut rank_sources = Vec::with_capacity(rank_keys.len());
+        for key in rank_keys {
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
+                return None;
+            }
+            let Some(cached) = get_cached_info.get(key) else {
+                counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+                return None;
+            };
+            rank_sources.push((
+                OwnerHotReplicaIdentity {
+                    key: key.clone(),
+                    put_time_ms: cached.put_time_ms,
+                    put_version: cached.put_version,
+                },
+                cached.mem_holder.clone(),
+            ));
+        }
+
+        if expect_atomic_group {
+            let Some(rank_group) = atomic_groups
+                .get(&rank_sources[0].0)
+                .map(|entry| entry.value().clone())
+            else {
+                return None;
+            };
+            if rank_group.members.len() != rank_sources.len()
+                || rank_group.members.iter().zip(rank_sources.iter()).any(
+                    |(member, (identity, _))| {
+                        member.key != identity.key
+                            || member.put_id != (identity.put_time_ms, identity.put_version)
+                    },
+                )
+            {
+                return None;
+            }
+            for (identity, _) in &rank_sources {
+                if !atomic_groups
+                    .get(identity)
+                    .is_some_and(|entry| Arc::ptr_eq(entry.value(), &rank_group))
+                {
+                    return None;
+                }
+            }
+        } else if rank_sources.len() != 1 || atomic_groups.contains_key(&rank_sources[0].0) {
+            return None;
+        }
+        cohort_sources.extend(rank_sources);
+    }
+    Some(cohort_sources)
+}
+
+fn try_enqueue_owner_hot_replica_event(
+    identity: OwnerHotReplicaIdentity,
+    memory_info: Arc<MemoryInfo>,
+    group_trigger: Option<OwnerHotReplicaIdentity>,
+    inflight: &Arc<DashSet<OwnerHotReplicaIdentity>>,
+    group_replica_triggered: &Arc<DashSet<OwnerHotReplicaIdentity>>,
+    counters: &Arc<OwnerHotCacheCounters>,
+    eviction_tx: &tokio::sync::ampsc::Sender<OwnerHotEvictionEvent>,
+) -> bool {
+    if !inflight.insert(identity.clone()) {
+        counters.skipped_duplicate.fetch_add(1, Ordering::Relaxed);
+        return false;
+    }
+    let event = OwnerHotEvictionEvent {
+        key: identity.key.clone(),
+        put_id: (identity.put_time_ms, identity.put_version),
+        memory_info: Arc::downgrade(&memory_info),
+        guard: OwnerHotReplicaGuard::new(
+            identity,
+            inflight.clone(),
+            counters.clone(),
+            group_trigger,
+            group_replica_triggered.clone(),
+        ),
+    };
+    match eviction_tx.try_send(event) {
+        Ok(()) => {
+            counters.replica_enqueued.fetch_add(1, Ordering::Relaxed);
+            true
+        }
+        Err(err) => {
+            let event = err.into_inner();
+            tracing::warn!(
+                "owner hot-cache eviction actor is closed; replica event dropped: key={} put_id=({},{})",
+                event.key,
+                event.put_id.0,
+                event.put_id.1
+            );
+            event.guard.mark_dispatch_failed();
+            false
+        }
+    }
+}
+
+fn build_owner_hot_cache(
+    capacity_bytes: u64,
+    owner_key_control: Arc<Mutex<HashMap<String, OwnerKeyControlState>>>,
+    get_cached_info: Arc<DashMap<String, GetCachedInfo>>,
+    inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    atomic_groups: Arc<
+        DashMap<OwnerHotReplicaIdentity, Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>>,
+    >,
+    group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    counters: Arc<OwnerHotCacheCounters>,
+    eviction_tx: tokio::sync::ampsc::Sender<OwnerHotEvictionEvent>,
+) -> moka::sync::Cache<String, OwnerHotCacheEntry> {
+    assert!(
+        capacity_bytes > 0,
+        "owner hot-cache capacity must be positive"
+    );
+    moka::sync::Cache::builder()
+        .max_capacity(capacity_bytes)
+        .weigher(|_key: &String, entry: &OwnerHotCacheEntry| entry.weight_bytes)
+        .eviction_listener(move |key, entry, cause| {
+            if cause != RemovalCause::Size {
+                return;
+            }
+            counters.size_evictions.fetch_add(1, Ordering::Relaxed);
+            let Some(memory_info) = pin_current_owner_hot_source(
+                key.as_str(),
+                &entry,
+                owner_key_control.as_ref(),
+                get_cached_info.as_ref(),
+                counters.as_ref(),
+            ) else {
+                return;
+            };
+            let identity = OwnerHotReplicaIdentity {
+                key: (*key).clone(),
+                put_time_ms: entry.put_id.0,
+                put_version: entry.put_id.1,
+            };
+            let group = atomic_groups
+                .get(&identity)
+                .map(|entry| entry.value().clone());
+            let cohort_sources = match owner_hot_tp_cohort_key_rows(&identity, group.as_deref()) {
+                Ok(Some(cohort_key_rows)) => pin_current_owner_hot_tp_cohort_sources(
+                    &cohort_key_rows,
+                    group.is_some(),
+                    owner_key_control.as_ref(),
+                    get_cached_info.as_ref(),
+                    atomic_groups.as_ref(),
+                    counters.as_ref(),
+                ),
+                Ok(None) => match group.as_deref() {
+                    Some(group) => pin_current_owner_hot_group_sources(
+                        group,
+                        owner_key_control.as_ref(),
+                        get_cached_info.as_ref(),
+                        counters.as_ref(),
+                    ),
+                    None => Some(vec![(identity.clone(), memory_info)]),
+                },
+                Err(()) => None,
+            };
+            let Some(cohort_sources) = cohort_sources else {
+                counters
+                    .group_trigger_incomplete
+                    .fetch_add(1, Ordering::Relaxed);
+                return;
+            };
+            if cohort_sources.len() > 1 {
+                counters
+                    .group_replica_triggers
+                    .fetch_add(1, Ordering::Relaxed);
+                let mut enqueued = 0u64;
+                for (member_identity, member_memory_info) in cohort_sources {
+                    if try_enqueue_owner_hot_replica_event(
+                        member_identity,
+                        member_memory_info,
+                        None,
+                        &inflight,
+                        &group_replica_triggered,
+                        &counters,
+                        &eviction_tx,
+                    ) {
+                        enqueued = enqueued.saturating_add(1);
+                    }
+                }
+                counters
+                    .group_members_enqueued
+                    .fetch_add(enqueued, Ordering::Relaxed);
+                if enqueued == 0 {
+                    counters
+                        .group_trigger_duplicates
+                        .fetch_add(1, Ordering::Relaxed);
+                }
+                return;
+            }
+            let (identity, memory_info) = cohort_sources
+                .into_iter()
+                .next()
+                .expect("owner hot cohort must contain its trigger source");
+            let _ = try_enqueue_owner_hot_replica_event(
+                identity,
+                memory_info,
+                None,
+                &inflight,
+                &group_replica_triggered,
+                &counters,
+                &eviction_tx,
+            );
+        })
+        .build()
 }
 
 struct ClientKvApiViewHolder {
@@ -1170,7 +1830,7 @@ pub struct ClientKvApiInner {
     pub get_remote_kv_lock: AMapLock<String>,
     /// key -> value info on this node
     /// we can only remove value if it's put_time_ms and put_version match remote eviction command
-    get_cached_info: DashMap<String, GetCachedInfo>,
+    get_cached_info: Arc<DashMap<String, GetCachedInfo>>,
     /// key -> locally readable resident slot before backend put_start/put_done finishes.
     precommit_local_visible_info: DashMap<String, PrecommitLocalVisibleInfo>,
     /// key -> local replica version remembered from local put/get durable-replica success.
@@ -1179,12 +1839,25 @@ pub struct ClientKvApiInner {
     local_snapshot_info: DashMap<String, LocalSnapshotInfo>,
     /// KvOwner-managed resident staging grants for hostless put_start.
     owner_local_reserve_pool: Mutex<OwnerLocalReservePoolState>,
+    /// Serialize reserve claims so a later waiter cannot steal slots reclaimed for the
+    /// waiter currently assembling a lease. Tokio's mutex provides FIFO acquisition order.
+    owner_local_reserve_claim_lock: limit_thirdparty::tokio::sync::AMutex<()>,
     /// Wake the background reserve actor after demand/free-slot changes.
     owner_local_reserve_rebalance_notify: Arc<limit_thirdparty::tokio::sync::Notify>,
     /// Owner-local write-back put ids for external local-first path.
     external_local_first_put_id_counter: AtomicU32,
-    /// Owner-local inflight write guard for external local-first path.
-    external_local_first_inflight_key_counts: DashMap<String, u32>,
+    /// Atomic owner-side gate for local-first puts, local index access, and reclaim fencing.
+    owner_key_control: Arc<Mutex<HashMap<String, OwnerKeyControlState>>>,
+    /// A weak-value admission/recency tier. It never owns resident memory and
+    /// therefore cannot become a second physical-reclaim authority.
+    owner_hot_cache: Option<moka::sync::Cache<String, OwnerHotCacheEntry>>,
+    owner_hot_replica_inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    owner_hot_atomic_groups: Arc<
+        DashMap<OwnerHotReplicaIdentity, Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>>,
+    >,
+    owner_hot_group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    owner_hot_counters: Arc<OwnerHotCacheCounters>,
+    owner_hot_eviction_rx: Mutex<Option<tokio::sync::ampsc::Receiver<OwnerHotEvictionEvent>>>,
 
     /// Shared delete actor input for owner -> external weak-index invalidation.
     pub external_invalidate_delete: EnsureMemholderMgmtDeleteHandle<DeleteClientKvMetaCacheItem>,
@@ -1198,6 +1871,8 @@ pub struct ClientKvApiInner {
     pub external_get_start_registry: DashMap<u64, Arc<ExternalGetStartEntry>>,
     pub external_get_start_by_key: DashMap<ExternalGetStartDedupKey, Arc<ExternalGetStartSharedOp>>,
     next_external_get_start_handle: AtomicU64,
+    /// External holding identities are independent from upstream and resident holder ids.
+    next_external_holding_id: AtomicU64,
     /// Weak handle to a shared refcount tracker for all UserMemHolder of this client.
     ///
     /// - A strong `Arc<AllMemholderRefCount>` is given to every `UserMemHolder` created by this client.
@@ -1222,6 +1897,7 @@ pub struct ClientKvApiInner {
     rpc_caller_batch_put_start: RPCCaller<BatchPutStartReq>,
     rpc_caller_batch_put_revoke: RPCCaller<BatchPutRevokeReq>,
     rpc_caller_batch_put_done: RPCCaller<BatchPutDoneReq>,
+    rpc_caller_grouped_batch_put_done: RPCCaller<GroupedBatchPutDoneReq>,
     rpc_caller_batch_prepare_put_keys: RPCCaller<BatchPreparePutKeysReq>,
     rpc_caller_batch_release_put_key_reservations: RPCCaller<BatchReleasePutKeyReservationsReq>,
     rpc_caller_put_append_start: RPCCaller<PutAppendStartReq>,
@@ -1257,6 +1933,112 @@ impl ClientKvApiInner {
         &self.view
     }
 
+    fn owner_hot_register_atomic_group(
+        &self,
+        group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
+    ) {
+        register_owner_hot_atomic_group(self.owner_hot_atomic_groups.as_ref(), group);
+    }
+
+    fn owner_hot_forget_atomic_group_for_member(&self, identity: &OwnerHotReplicaIdentity) {
+        forget_owner_hot_atomic_group(
+            self.owner_hot_atomic_groups.as_ref(),
+            self.owner_hot_group_replica_triggered.as_ref(),
+            identity,
+        );
+    }
+
+    fn owner_hot_track_committed(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        memory_info: &Arc<MemoryInfo>,
+        atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
+    ) {
+        let Some(cache) = self.owner_hot_cache.as_ref() else {
+            return;
+        };
+        if !self.owner_hot_source_is_current(key, put_id, memory_info) {
+            return;
+        }
+        if let Some(group) = atomic_group {
+            self.owner_hot_register_atomic_group(group);
+        }
+        cache.insert(
+            key.to_string(),
+            OwnerHotCacheEntry {
+                put_id,
+                memory_info: Arc::downgrade(memory_info),
+                weight_bytes: owner_hot_weight_bytes(memory_info.as_ref()),
+            },
+        );
+        if !self.owner_hot_source_is_current(key, put_id, memory_info) {
+            self.owner_hot_invalidate_version(key, put_id);
+        }
+    }
+
+    fn owner_hot_touch_or_promote(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        memory_info: &Arc<MemoryInfo>,
+    ) {
+        let Some(cache) = self.owner_hot_cache.as_ref() else {
+            return;
+        };
+        if cache.get(key).is_some_and(|entry| {
+            entry.put_id == put_id && Weak::ptr_eq(&entry.memory_info, &Arc::downgrade(memory_info))
+        }) {
+            return;
+        }
+        self.owner_hot_track_committed(key, put_id, memory_info, None);
+    }
+
+    pub(crate) fn owner_hot_source_is_current(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        memory_info: &Arc<MemoryInfo>,
+    ) -> bool {
+        let controls = self.owner_key_control.lock();
+        if controls
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            return false;
+        }
+        self.get_cached_info.get(key).is_some_and(|cached| {
+            cached.put_time_ms == put_id.0
+                && cached.put_version == put_id.1
+                && Arc::ptr_eq(&cached.mem_holder, memory_info)
+        })
+    }
+
+    pub(crate) fn owner_hot_invalidate_version(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+    ) {
+        let Some(cache) = self.owner_hot_cache.as_ref() else {
+            return;
+        };
+        let _ = cache.entry(key.to_string()).and_compute_with(|entry| {
+            if entry
+                .as_ref()
+                .is_some_and(|entry| entry.value().put_id == put_id)
+            {
+                MokaComputeOp::Remove
+            } else {
+                MokaComputeOp::Nop
+            }
+        });
+        self.owner_hot_forget_atomic_group_for_member(&OwnerHotReplicaIdentity {
+            key: key.to_string(),
+            put_time_ms: put_id.0,
+            put_version: put_id.1,
+        });
+    }
+
     pub(crate) fn release_local_reserve_route_for_memory_info(&self, memory_info: &MemoryInfo) {
         let Some((slot_size, grant_id, slot_index)) = memory_info.local_reserve_resident_slot_ref()
         else {
@@ -1322,32 +2104,51 @@ impl ClientKvApiInner {
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
     ) -> KvResult<()> {
-        if reject_if_exist_same_key && self.has_local_snapshot(key) {
+        let mut controls = self.owner_key_control.lock();
+        if controls
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            return Err(KvError::Api(ApiError::KeyBeingWritten {
+                key: key.to_string(),
+            }));
+        }
+        if reject_if_exist_same_key
+            && (self.precommit_local_visible_info.contains_key(key)
+                || self.get_cached_info.contains_key(key)
+                || self.local_snapshot_info.contains_key(key))
+        {
             return Err(KvError::Api(ApiError::KeyAlreadyExists {
                 key: key.to_string(),
             }));
         }
-        let mut entry = self
-            .external_local_first_inflight_key_counts
-            .entry(key.to_string())
-            .or_insert(0);
-        if reject_if_inflight_same_key && *entry > 0 {
+        let state = controls.entry(key.to_string()).or_default();
+        if reject_if_inflight_same_key && state.local_puts > 0 {
             return Err(KvError::Api(ApiError::KeyBeingWritten {
                 key: key.to_string(),
             }));
         }
-        *entry += 1;
+        state.local_puts = state
+            .local_puts
+            .checked_add(1)
+            .expect("owner local-first put counter overflow");
         Ok(())
     }
 
     pub(crate) fn release_external_local_first_put_key(&self, key: &str) {
-        if let Some(mut entry) = self.external_local_first_inflight_key_counts.get_mut(key) {
-            if *entry <= 1 {
-                drop(entry);
-                self.external_local_first_inflight_key_counts.remove(key);
-            } else {
-                *entry -= 1;
-            }
+        let mut controls = self.owner_key_control.lock();
+        let remove = {
+            let state = controls
+                .get_mut(key)
+                .expect("owner local-first put state missing on release");
+            state.local_puts = state
+                .local_puts
+                .checked_sub(1)
+                .expect("owner local-first put counter underflow");
+            state.local_puts == 0 && state.reclaim.is_none()
+        };
+        if remove {
+            controls.remove(key);
         }
     }
 
@@ -1356,6 +2157,19 @@ impl ClientKvApiInner {
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
     ) {
+        let controls = self.owner_key_control.lock();
+        if controls
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            tracing::debug!(
+                "skip local snapshot publication behind owner reclaim fence: key={} put_id=({},{})",
+                key,
+                put_id.0,
+                put_id.1
+            );
+            return;
+        }
         self.local_snapshot_info.insert(
             key.to_string(),
             LocalSnapshotInfo {
@@ -1366,23 +2180,67 @@ impl ClientKvApiInner {
     }
 
     pub(crate) fn has_local_snapshot(&self, key: &str) -> bool {
+        let controls = self.owner_key_control.lock();
+        if controls
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            return false;
+        }
         self.precommit_local_visible_info.contains_key(key)
             || self.get_cached_info.contains_key(key)
             || self.local_snapshot_info.contains_key(key)
     }
 
-    pub(crate) fn remove_local_snapshot_if(
+    pub(crate) fn local_visible_mem_holder(&self, key: &str) -> Option<Arc<MemoryInfo>> {
+        let (memory_info, hot_put_id) = {
+            let controls = self.owner_key_control.lock();
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                return None;
+            }
+            let memory_info = self.local_visible_mem_holder_unfenced(key);
+            let hot_put_id = memory_info.as_ref().and_then(|memory_info| {
+                self.get_cached_info
+                    .get(key)
+                    .filter(|cached| Arc::ptr_eq(&cached.mem_holder, memory_info))
+                    .map(|cached| (cached.put_time_ms, cached.put_version))
+            });
+            (memory_info, hot_put_id)
+        };
+        if let Some(put_id) = hot_put_id {
+            self.owner_hot_touch_or_promote(
+                key,
+                put_id,
+                memory_info
+                    .as_ref()
+                    .expect("hot touch requires a local memory holder"),
+            );
+        }
+        memory_info
+    }
+
+    pub(crate) fn local_committed_mem_holder_for_put_id(
         &self,
         key: &str,
-        put_time_ms: u64,
-        put_version: u32,
-    ) -> bool {
-        self.local_snapshot_info
-            .remove_if(key, |_, v| v.version_matches(put_time_ms, put_version))
-            .is_some()
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+    ) -> Option<Arc<MemoryInfo>> {
+        let controls = self.owner_key_control.lock();
+        if controls
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+        {
+            return None;
+        }
+        self.get_cached_info.get(key).and_then(|info| {
+            (info.put_time_ms == put_id.0 && info.put_version == put_id.1)
+                .then(|| info.mem_holder.clone())
+        })
     }
 
-    pub(crate) fn local_visible_mem_holder(&self, key: &str) -> Option<Arc<MemoryInfo>> {
+    fn local_visible_mem_holder_unfenced(&self, key: &str) -> Option<Arc<MemoryInfo>> {
         if let Some(info) = self.precommit_local_visible_info.get(key) {
             return Some(info.mem_holder.clone());
         }
@@ -1391,6 +2249,66 @@ impl ClientKvApiInner {
             .map(|info| info.mem_holder.clone())
     }
 
+    pub(crate) fn local_visible_mem_holders(
+        &self,
+        keys: &[String],
+    ) -> Vec<Option<Arc<MemoryInfo>>> {
+        // A hostless get_start commonly checks hundreds of pages from one
+        // local prefix. Take one coherent reclaim-fence snapshot instead of
+        // locking owner_key_control once per page. The MemoryInfo Arcs keep
+        // any selected backing alive if reclaim begins after this snapshot.
+        let resolved = {
+            let controls = self.owner_key_control.lock();
+            resolve_local_visible_batch(keys, &controls, |key| {
+                let memory_info = self.local_visible_mem_holder_unfenced(key)?;
+                let hot_put_id = self
+                    .get_cached_info
+                    .get(key)
+                    .filter(|cached| Arc::ptr_eq(&cached.mem_holder, &memory_info))
+                    .map(|cached| (cached.put_time_ms, cached.put_version));
+                Some((memory_info, hot_put_id))
+            })
+        };
+        resolved
+            .into_iter()
+            .zip(keys)
+            .map(|(resolved, key)| {
+                let (memory_info, hot_put_id) = resolved?;
+                if let Some(put_id) = hot_put_id {
+                    self.owner_hot_touch_or_promote(key, put_id, &memory_info);
+                }
+                Some(memory_info)
+            })
+            .collect()
+    }
+
+    pub(crate) fn install_external_get_holding(
+        &self,
+        req_node_id: &str,
+        memory_info: Arc<MemoryInfo>,
+    ) -> ExternalMemHolderInfo {
+        let external_holder_id = allocate_external_holding_id(&self.next_external_holding_id);
+        let key = NodeHolderKey::new(req_node_id.to_string(), external_holder_id);
+        let external_memholder_info = ExternalMemHolderInfo {
+            offset: memory_info.offset,
+            len: memory_info.len,
+            holder_id: external_holder_id,
+        };
+        let previous = self.external_get_holding.inner().insert(
+            key,
+            ExternalHoldingGetInfo {
+                key: memory_info.key.clone(),
+                req_node_id: req_node_id.to_string(),
+                memory_info,
+            },
+        );
+        assert!(
+            previous.is_none(),
+            "fresh external holding id unexpectedly replaced a live holding"
+        );
+        external_memholder_info
+    }
+
     pub async fn build_local_reserve_resident_memory_info(
         &self,
         key: &str,
@@ -1436,26 +2354,94 @@ impl ClientKvApiInner {
             )
             .await,
         );
-        let replaced = self.get_cached_info.insert(
-            key.to_string(),
-            GetCachedInfo {
-                put_time_ms: put_id.0,
-                put_version: put_id.1,
-                mem_holder: memory_info,
-            },
-        );
-        if let Some(previous) = replaced {
-            self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+        {
+            let controls = self.owner_key_control.lock();
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                return Err(KvError::Api(ApiError::KeyBeingWritten {
+                    key: key.to_string(),
+                }));
+            }
+            let replaced = self.get_cached_info.insert(
+                key.to_string(),
+                GetCachedInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                    mem_holder: memory_info.clone(),
+                },
+            );
+            if let Some(previous) = replaced {
+                self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+            }
+            self.local_snapshot_info.insert(
+                key.to_string(),
+                LocalSnapshotInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                },
+            );
         }
-        self.remember_local_snapshot(key, put_id);
+        self.owner_hot_track_committed(key, put_id, &memory_info, None);
         Ok(())
     }
 
+    pub(crate) fn install_get_cached_info_if_unfenced(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        memory_info: Arc<MemoryInfo>,
+    ) -> bool {
+        {
+            let controls = self.owner_key_control.lock();
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                tracing::debug!(
+                    "skip get cache publication behind owner reclaim fence: key={} put_id=({},{})",
+                    key,
+                    put_id.0,
+                    put_id.1
+                );
+                return false;
+            }
+            let replaced = self.get_cached_info.insert(
+                key.to_string(),
+                GetCachedInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                    mem_holder: memory_info.clone(),
+                },
+            );
+            if let Some(previous) = replaced {
+                self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+            }
+            self.local_snapshot_info.insert(
+                key.to_string(),
+                LocalSnapshotInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                },
+            );
+        }
+        self.owner_hot_track_committed(key, put_id, &memory_info, None);
+        true
+    }
+
     pub fn install_precommit_local_visible_memory_info(
         &self,
         key: &str,
         memory_info: Arc<MemoryInfo>,
     ) {
+        let controls = self.owner_key_control.lock();
+        assert!(
+            !controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some()),
+            "precommit local index publication must not cross an owner reclaim fence"
+        );
         let (slot_size, grant_id, slot_index) = memory_info
             .local_reserve_resident_slot_ref()
             .expect("resident memory_info must carry local reserve slot ref");
@@ -1480,6 +2466,7 @@ impl ClientKvApiInner {
         key: &str,
         expected_mem_holder: &Arc<MemoryInfo>,
     ) -> bool {
+        let _controls = self.owner_key_control.lock();
         self.precommit_local_visible_info
             .remove_if(key, |_, info| {
                 Arc::ptr_eq(&info.mem_holder, expected_mem_holder)
@@ -1492,50 +2479,69 @@ impl ClientKvApiInner {
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
         memory_info: Arc<MemoryInfo>,
+        atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
     ) -> KvResult<()> {
-        let is_same_pending = self
-            .precommit_local_visible_info
-            .get(key)
-            .map(|info| Arc::ptr_eq(&info.mem_holder, &memory_info))
-            .unwrap_or(false);
-        if !is_same_pending {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "precommit local visible cache missing while promoting key={}",
-                    key
-                ),
-            }));
-        }
-        let (slot_size, grant_id, slot_index) = memory_info
-            .local_reserve_resident_slot_ref()
-            .expect("resident memory_info must carry local reserve slot ref");
-        self.owner_promote_local_reserve_pending_slot_to_committed(
-            slot_size, grant_id, slot_index,
-        )?;
-        let removed = self
-            .precommit_local_visible_info
-            .remove_if(key, |_, info| Arc::ptr_eq(&info.mem_holder, &memory_info))
-            .is_some();
-        if !removed {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "precommit local visible cache disappeared while promoting key={}",
-                    key
-                ),
-            }));
-        }
-        let replaced = self.get_cached_info.insert(
-            key.to_string(),
-            GetCachedInfo {
-                put_time_ms: put_id.0,
-                put_version: put_id.1,
-                mem_holder: memory_info,
-            },
-        );
-        if let Some(previous) = replaced {
-            self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+        {
+            let controls = self.owner_key_control.lock();
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                return Err(KvError::Api(ApiError::KeyBeingWritten {
+                    key: key.to_string(),
+                }));
+            }
+            let is_same_pending = self
+                .precommit_local_visible_info
+                .get(key)
+                .map(|info| Arc::ptr_eq(&info.mem_holder, &memory_info))
+                .unwrap_or(false);
+            if !is_same_pending {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "precommit local visible cache missing while promoting key={}",
+                        key
+                    ),
+                }));
+            }
+            let (slot_size, grant_id, slot_index) = memory_info
+                .local_reserve_resident_slot_ref()
+                .expect("resident memory_info must carry local reserve slot ref");
+            self.owner_promote_local_reserve_pending_slot_to_committed(
+                slot_size, grant_id, slot_index,
+            )?;
+            let removed = self
+                .precommit_local_visible_info
+                .remove_if(key, |_, info| Arc::ptr_eq(&info.mem_holder, &memory_info))
+                .is_some();
+            if !removed {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "precommit local visible cache disappeared while promoting key={}",
+                        key
+                    ),
+                }));
+            }
+            let replaced = self.get_cached_info.insert(
+                key.to_string(),
+                GetCachedInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                    mem_holder: memory_info.clone(),
+                },
+            );
+            if let Some(previous) = replaced {
+                self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+            }
+            self.local_snapshot_info.insert(
+                key.to_string(),
+                LocalSnapshotInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                },
+            );
         }
-        self.remember_local_snapshot(key, put_id);
+        self.owner_hot_track_committed(key, put_id, &memory_info, atomic_group);
         Ok(())
     }
 }
@@ -1552,6 +2558,7 @@ pub struct ExternalPendingPutCtx {
     pub replica_target: Option<ReplicaTaskTarget>,
     pub local_reserve_slot: Option<OwnerLocalReserveSlotRef>,
     pub local_reserve_slot_size: Option<u64>,
+    pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
 }
 
 #[derive(Debug, Clone)]
@@ -1562,13 +2569,14 @@ pub(crate) struct ReplicaTaskTarget {
     pub len: u64,
 }
 
-#[derive(Clone)]
 pub(crate) struct ReplicaTaskJob {
     pub key: String,
     pub put_id: crate::master_kv_router::put::PutIDForAKey,
     pub holder: Arc<UserMemHolder>,
     pub target: Option<ReplicaTaskTarget>,
     pub preferred_sub_cluster: Option<String>,
+    pub hot_replica_guard: Option<OwnerHotReplicaGuard>,
+    pub protect_source_on_remote_complete: bool,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -1821,6 +2829,7 @@ pub(crate) struct OwnerLocalReserveClassState {
     pub grants: Vec<OwnerLocalReserveGrantState>,
     pub last_grow_at: Option<Instant>,
     pub pending_slot_demand: usize,
+    pub expected_grant_count: usize,
 }
 
 impl OwnerLocalReserveClassState {
@@ -1831,6 +2840,7 @@ impl OwnerLocalReserveClassState {
             grants: Vec::new(),
             last_grow_at: None,
             pending_slot_demand: 0,
+            expected_grant_count: 0,
         }
     }
 
@@ -1850,6 +2860,297 @@ impl OwnerLocalReserveClassState {
     }
 }
 
+#[cfg(test)]
+mod owner_reclaim_slot_tests {
+    use super::{
+        GetCachedInfo, OwnerHotCacheCounters, OwnerHotCacheEntry, OwnerHotReplicaGuard,
+        OwnerHotReplicaIdentity, OwnerKeyControlState, OwnerLocalReserveGrantState,
+        OwnerReclaimRecord, allocate_external_holding_id, build_owner_hot_cache,
+        clone_if_owner_hot_entry_matches, forget_owner_hot_atomic_group,
+        owner_hot_tp_cohort_key_rows, register_owner_hot_atomic_group, resolve_local_visible_batch,
+    };
+    use crate::master_kv_router::msg_pack::{
+        OwnerReclaimItem, PutAtomicGroup, PutAtomicGroupMember,
+    };
+    use dashmap::{DashMap, DashSet};
+    use parking_lot::Mutex;
+    use std::collections::HashMap;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::sync::{Arc, Weak};
+
+    #[test]
+    fn external_holding_ids_are_nonzero_and_unique_for_resident_pages() {
+        let counter = AtomicU64::new(1);
+        let first = allocate_external_holding_id(&counter);
+        let second = allocate_external_holding_id(&counter);
+        assert_eq!(first, 1);
+        assert_eq!(second, 2);
+        assert_ne!(first, second);
+    }
+
+    #[test]
+    fn hot_source_pin_requires_the_same_version_and_allocation() {
+        let current = Arc::new(7u64);
+        let current_weak = Arc::downgrade(&current);
+        let other = Arc::new(7u64);
+        let other_weak = Arc::downgrade(&other);
+
+        let pinned = clone_if_owner_hot_entry_matches((10, 2), &current, (10, 2), &current_weak)
+            .expect("matching source should be pinned");
+        assert!(Arc::ptr_eq(&pinned, &current));
+        assert_eq!(Arc::strong_count(&current), 2);
+        drop(pinned);
+
+        assert!(
+            clone_if_owner_hot_entry_matches((10, 2), &current, (10, 3), &current_weak).is_none()
+        );
+        assert!(
+            clone_if_owner_hot_entry_matches((10, 2), &current, (10, 2), &other_weak).is_none()
+        );
+    }
+
+    #[test]
+    fn hot_replica_guard_keeps_dedup_until_terminal_outcome() {
+        let identity = OwnerHotReplicaIdentity {
+            key: "hot-key".to_string(),
+            put_time_ms: 10,
+            put_version: 2,
+        };
+        let inflight = Arc::new(DashSet::new());
+        assert!(inflight.insert(identity.clone()));
+        let counters = Arc::new(OwnerHotCacheCounters::default());
+        let group_replica_triggered = Arc::new(DashSet::new());
+        let guard = OwnerHotReplicaGuard::new(
+            identity.clone(),
+            inflight.clone(),
+            counters.clone(),
+            None,
+            group_replica_triggered,
+        );
+        assert!(inflight.contains(&identity));
+
+        guard.mark_completed();
+        drop(guard);
+        assert!(!inflight.contains(&identity));
+        assert_eq!(counters.replica_completed.load(Ordering::Relaxed), 1);
+        assert_eq!(counters.replica_failed.load(Ordering::Relaxed), 0);
+    }
+
+    #[test]
+    fn hot_atomic_group_registry_interns_members_and_forgets_as_one_unit() {
+        let group = PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: "group-a".to_string(),
+                    put_id: (10, 1),
+                },
+                PutAtomicGroupMember {
+                    key: "group-b".to_string(),
+                    put_id: (10, 2),
+                },
+            ],
+        };
+        let atomic_groups = DashMap::new();
+        register_owner_hot_atomic_group(&atomic_groups, &group);
+        register_owner_hot_atomic_group(&atomic_groups, &group);
+        assert_eq!(atomic_groups.len(), 2);
+
+        let first = OwnerHotReplicaIdentity::from_group_member(&group.members[0]);
+        let second = OwnerHotReplicaIdentity::from_group_member(&group.members[1]);
+        let first_group = atomic_groups.get(&first).unwrap().value().clone();
+        let second_group = atomic_groups.get(&second).unwrap().value().clone();
+        assert!(Arc::ptr_eq(&first_group, &second_group));
+
+        let triggered = DashSet::new();
+        assert!(triggered.insert(first.clone()));
+        forget_owner_hot_atomic_group(&atomic_groups, &triggered, &second);
+        assert!(atomic_groups.is_empty());
+        assert!(!triggered.contains(&first));
+    }
+
+    #[test]
+    fn owner_hot_tp_cohort_expands_the_same_group_boundary_across_ranks() {
+        let identity = OwnerHotReplicaIdentity {
+            key: "page0_model_0_2".to_string(),
+            put_time_ms: 10,
+            put_version: 1,
+        };
+        let rank0_group = PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: "page0_model_0_2".to_string(),
+                    put_id: (10, 1),
+                },
+                PutAtomicGroupMember {
+                    key: "page1_model_0_2".to_string(),
+                    put_id: (10, 2),
+                },
+            ],
+        };
+        assert_eq!(
+            owner_hot_tp_cohort_key_rows(&identity, Some(&rank0_group)),
+            Ok(Some(vec![
+                vec!["page0_model_0_2".to_string(), "page1_model_0_2".to_string(),],
+                vec!["page0_model_1_2".to_string(), "page1_model_1_2".to_string(),],
+            ]))
+        );
+
+        let mixed_rank_group = PutAtomicGroup {
+            members: vec![
+                rank0_group.members[0].clone(),
+                PutAtomicGroupMember {
+                    key: "page1_model_1_2".to_string(),
+                    put_id: (11, 2),
+                },
+            ],
+        };
+        assert_eq!(
+            owner_hot_tp_cohort_key_rows(&identity, Some(&mixed_rank_group)),
+            Err(())
+        );
+    }
+
+    #[test]
+    fn hot_group_trigger_is_persistent_on_success_and_retryable_on_failure() {
+        let member = OwnerHotReplicaIdentity {
+            key: "member".to_string(),
+            put_time_ms: 10,
+            put_version: 2,
+        };
+        let group_trigger = OwnerHotReplicaIdentity {
+            key: "anchor".to_string(),
+            put_time_ms: 10,
+            put_version: 1,
+        };
+        let inflight = Arc::new(DashSet::new());
+        let triggered = Arc::new(DashSet::new());
+        let counters = Arc::new(OwnerHotCacheCounters::default());
+
+        assert!(inflight.insert(member.clone()));
+        assert!(triggered.insert(group_trigger.clone()));
+        let failed_guard = OwnerHotReplicaGuard::new(
+            member.clone(),
+            inflight.clone(),
+            counters.clone(),
+            Some(group_trigger.clone()),
+            triggered.clone(),
+        );
+        drop(failed_guard);
+        assert!(!inflight.contains(&member));
+        assert!(!triggered.contains(&group_trigger));
+        assert_eq!(counters.replica_failed.load(Ordering::Relaxed), 1);
+
+        assert!(inflight.insert(member.clone()));
+        assert!(triggered.insert(group_trigger.clone()));
+        let completed_guard = OwnerHotReplicaGuard::new(
+            member.clone(),
+            inflight.clone(),
+            counters.clone(),
+            Some(group_trigger.clone()),
+            triggered.clone(),
+        );
+        completed_guard.mark_completed();
+        drop(completed_guard);
+        assert!(!inflight.contains(&member));
+        assert!(triggered.contains(&group_trigger));
+        assert_eq!(counters.replica_completed.load(Ordering::Relaxed), 1);
+    }
+
+    #[test]
+    fn hot_cache_only_dispatches_size_removals_and_keeps_capacity() {
+        let controls = Arc::new(Mutex::new(HashMap::new()));
+        let cached = Arc::new(DashMap::<String, GetCachedInfo>::new());
+        let inflight = Arc::new(DashSet::new());
+        let atomic_groups = Arc::new(DashMap::new());
+        let group_replica_triggered = Arc::new(DashSet::new());
+        let counters = Arc::new(OwnerHotCacheCounters::default());
+        let (tx, mut rx) = limit_thirdparty::tokio::sync::ampsc::channel(8);
+        let cache = build_owner_hot_cache(
+            10,
+            controls,
+            cached,
+            inflight,
+            atomic_groups,
+            group_replica_triggered,
+            counters.clone(),
+            tx,
+        );
+        let entry = |put_version| OwnerHotCacheEntry {
+            put_id: (10, put_version),
+            memory_info: Weak::new(),
+            weight_bytes: 6,
+        };
+
+        cache.insert("explicit".to_string(), entry(0));
+        cache.run_pending_tasks();
+        cache.invalidate("explicit");
+        cache.run_pending_tasks();
+        assert_eq!(counters.size_evictions.load(Ordering::Relaxed), 0);
+
+        cache.insert("size-a".to_string(), entry(1));
+        cache.insert("size-b".to_string(), entry(2));
+        cache.run_pending_tasks();
+        assert!(counters.size_evictions.load(Ordering::Relaxed) >= 1);
+        assert_eq!(cache.policy().max_capacity(), Some(10));
+        assert!(
+            rx.try_recv().is_err(),
+            "stale weak entries must not dispatch"
+        );
+    }
+
+    #[test]
+    fn batch_local_visibility_skips_reclaim_fenced_keys() {
+        let keys = vec![
+            "local-a".to_string(),
+            "fenced".to_string(),
+            "local-b".to_string(),
+        ];
+        let mut controls = HashMap::new();
+        controls.insert(
+            "fenced".to_string(),
+            OwnerKeyControlState {
+                local_puts: 0,
+                reclaim: Some(OwnerReclaimRecord::Committed(OwnerReclaimItem {
+                    key: "fenced".to_string(),
+                    ..OwnerReclaimItem::default()
+                })),
+            },
+        );
+        let mut resolved_keys = Vec::new();
+
+        let visible = resolve_local_visible_batch(&keys, &controls, |key| {
+            resolved_keys.push(key.to_string());
+            Some(key.to_string())
+        });
+
+        assert_eq!(
+            visible,
+            vec![
+                Some("local-a".to_string()),
+                None,
+                Some("local-b".to_string())
+            ]
+        );
+        assert_eq!(resolved_keys, vec!["local-a", "local-b"]);
+    }
+
+    #[test]
+    fn committed_slot_becomes_free_only_after_route_and_holder_are_released() {
+        let mut grant = OwnerLocalReserveGrantState::new(7, 0, 0, 16, 8, 2);
+        let slot = grant.claim_prepared_slot().expect("slot should be free");
+        grant.mark_prepared_slot_pending_visible(slot.slot_index);
+        grant.retain_resident_slot_holder(slot.slot_index);
+        grant.promote_pending_visible_slot_to_committed(slot.slot_index);
+
+        grant.release_committed_slot_route(slot.slot_index);
+        assert_eq!(grant.free_slots.len(), 1);
+
+        grant.release_resident_slot_holder(slot.slot_index);
+        assert_eq!(grant.free_slots.len(), 2);
+        assert!(grant.is_fully_free());
+    }
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct OwnerLocalReservePoolState {
     pub classes: HashMap<u64, OwnerLocalReserveClassState>,
@@ -2048,10 +3349,99 @@ impl ClientKvApiInner {
             external_get_holding_bytes =
                 external_get_holding_bytes.saturating_add(entry.value().memory_info.len as u64);
         }
+        let (hot_cache_capacity_bytes, hot_cache_entries, hot_cache_weighted_bytes) = self
+            .owner_hot_cache
+            .as_ref()
+            .map(|cache| {
+                (
+                    cache.policy().max_capacity().unwrap_or(0),
+                    cache.entry_count(),
+                    cache.weighted_size(),
+                )
+            })
+            .unwrap_or_default();
         OwnerRuntimeObserveSnapshot {
             external_get_holding_entries: self.external_get_holding.total() as u64,
             external_get_holding_bytes,
             external_pending_put_entries: self.external_pending_puts.entry_count(),
+            hot_cache_capacity_bytes,
+            hot_cache_entries,
+            hot_cache_weighted_bytes,
+            hot_size_evictions: self
+                .owner_hot_counters
+                .size_evictions
+                .load(Ordering::Relaxed),
+            hot_replica_enqueued: self
+                .owner_hot_counters
+                .replica_enqueued
+                .load(Ordering::Relaxed),
+            hot_replica_completed: self
+                .owner_hot_counters
+                .replica_completed
+                .load(Ordering::Relaxed),
+            hot_replica_already_satisfied: self
+                .owner_hot_counters
+                .replica_already_satisfied
+                .load(Ordering::Relaxed),
+            hot_replica_failed: self
+                .owner_hot_counters
+                .replica_failed
+                .load(Ordering::Relaxed),
+            hot_replica_obsolete: self
+                .owner_hot_counters
+                .replica_obsolete
+                .load(Ordering::Relaxed),
+            hot_replica_dispatch_failed: self
+                .owner_hot_counters
+                .replica_dispatch_failed
+                .load(Ordering::Relaxed),
+            hot_replica_inflight: self.owner_hot_replica_inflight.len() as u64,
+            hot_eviction_skipped_stale: self
+                .owner_hot_counters
+                .skipped_stale
+                .load(Ordering::Relaxed),
+            hot_eviction_skipped_reclaim: self
+                .owner_hot_counters
+                .skipped_reclaim
+                .load(Ordering::Relaxed),
+            hot_eviction_skipped_duplicate: self
+                .owner_hot_counters
+                .skipped_duplicate
+                .load(Ordering::Relaxed),
+            hot_group_registry_entries: self.owner_hot_atomic_groups.len() as u64,
+            hot_group_replica_triggered: self.owner_hot_group_replica_triggered.len() as u64,
+            hot_group_replica_triggers: self
+                .owner_hot_counters
+                .group_replica_triggers
+                .load(Ordering::Relaxed),
+            hot_group_members_enqueued: self
+                .owner_hot_counters
+                .group_members_enqueued
+                .load(Ordering::Relaxed),
+            hot_group_trigger_duplicates: self
+                .owner_hot_counters
+                .group_trigger_duplicates
+                .load(Ordering::Relaxed),
+            hot_group_trigger_incomplete: self
+                .owner_hot_counters
+                .group_trigger_incomplete
+                .load(Ordering::Relaxed),
+            grouped_put_done_batches: self
+                .owner_hot_counters
+                .grouped_put_done_batches
+                .load(Ordering::Relaxed),
+            grouped_put_done_items: self
+                .owner_hot_counters
+                .grouped_put_done_items
+                .load(Ordering::Relaxed),
+            legacy_put_done_batches: self
+                .owner_hot_counters
+                .legacy_put_done_batches
+                .load(Ordering::Relaxed),
+            legacy_put_done_items: self
+                .owner_hot_counters
+                .legacy_put_done_items
+                .load(Ordering::Relaxed),
         }
     }
 
@@ -2560,6 +3950,35 @@ impl ClientKvApi {
                         metrics.set_kv_external_pending_put_entries(
                             snapshot.external_pending_put_entries,
                         );
+                        if snapshot.hot_cache_capacity_bytes > 0 {
+                            tracing::info!(
+                                capacity_bytes = snapshot.hot_cache_capacity_bytes,
+                                entries = snapshot.hot_cache_entries,
+                                weighted_bytes = snapshot.hot_cache_weighted_bytes,
+                                size_evictions = snapshot.hot_size_evictions,
+                                replica_enqueued = snapshot.hot_replica_enqueued,
+                                replica_completed = snapshot.hot_replica_completed,
+                                replica_already_satisfied = snapshot.hot_replica_already_satisfied,
+                                replica_failed = snapshot.hot_replica_failed,
+                                replica_obsolete = snapshot.hot_replica_obsolete,
+                                replica_dispatch_failed = snapshot.hot_replica_dispatch_failed,
+                                replica_inflight = snapshot.hot_replica_inflight,
+                                skipped_stale = snapshot.hot_eviction_skipped_stale,
+                                skipped_reclaim = snapshot.hot_eviction_skipped_reclaim,
+                                skipped_duplicate = snapshot.hot_eviction_skipped_duplicate,
+                                group_registry_entries = snapshot.hot_group_registry_entries,
+                                group_replica_triggered = snapshot.hot_group_replica_triggered,
+                                group_replica_triggers = snapshot.hot_group_replica_triggers,
+                                group_members_enqueued = snapshot.hot_group_members_enqueued,
+                                group_trigger_duplicates = snapshot.hot_group_trigger_duplicates,
+                                group_trigger_incomplete = snapshot.hot_group_trigger_incomplete,
+                                grouped_put_done_batches = snapshot.grouped_put_done_batches,
+                                grouped_put_done_items = snapshot.grouped_put_done_items,
+                                legacy_put_done_batches = snapshot.legacy_put_done_batches,
+                                legacy_put_done_items = snapshot.legacy_put_done_items,
+                                "owner hot replica policy snapshot"
+                            );
+                        }
                     }
                 }
             }
@@ -2572,26 +3991,57 @@ impl ClientKvApi {
 
     pub async fn construct(arg: ClientKvApiNewArg) -> Result<Self, KvError> {
         tracing::info!("Constructing ClientKvApi in Client mode (PreView)");
+        let ClientKvApiNewArg {
+            test_spec_config,
+            owner_hot_cache_capacity_bytes,
+        } = arg;
         let (replica_task_tx, replica_task_rx) =
             tokio::sync::ampsc::channel(REPLICA_TASK_QUEUE_CAPACITY);
         let (owner_local_publish_tx, owner_local_publish_rx) =
             tokio::sync::ampsc::channel(OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY);
+        let (owner_hot_eviction_tx, owner_hot_eviction_rx) =
+            tokio::sync::ampsc::channel(OWNER_HOT_EVICTION_QUEUE_CAPACITY);
+        let get_cached_info = Arc::new(DashMap::new());
+        let owner_key_control = Arc::new(Mutex::new(HashMap::new()));
+        let owner_hot_replica_inflight = Arc::new(DashSet::new());
+        let owner_hot_atomic_groups = Arc::new(DashMap::new());
+        let owner_hot_group_replica_triggered = Arc::new(DashSet::new());
+        let owner_hot_counters = Arc::new(OwnerHotCacheCounters::default());
+        let owner_hot_cache = owner_hot_cache_capacity_bytes.map(|capacity_bytes| {
+            build_owner_hot_cache(
+                capacity_bytes,
+                owner_key_control.clone(),
+                get_cached_info.clone(),
+                owner_hot_replica_inflight.clone(),
+                owner_hot_atomic_groups.clone(),
+                owner_hot_group_replica_triggered.clone(),
+                owner_hot_counters.clone(),
+                owner_hot_eviction_tx,
+            )
+        });
 
         let inner = ClientKvApiInner {
             view: ClientKvApiViewHolder::new(),
-            test_spec_config: arg.test_spec_config,
+            test_spec_config,
             metrics: OnceLock::new(),
             all_memholder_refcount: OnceLock::new(),
             get_remote_kv_lock: AMapLock::new(Duration::from_secs(60)),
-            get_cached_info: DashMap::new(),
+            get_cached_info,
             precommit_local_visible_info: DashMap::new(),
             local_snapshot_info: DashMap::new(),
             owner_local_reserve_pool: Mutex::new(OwnerLocalReservePoolState::default()),
+            owner_local_reserve_claim_lock: limit_thirdparty::tokio::sync::AMutex::new(()),
             owner_local_reserve_rebalance_notify: Arc::new(
                 limit_thirdparty::tokio::sync::Notify::new(),
             ),
             external_local_first_put_id_counter: AtomicU32::new(0),
-            external_local_first_inflight_key_counts: DashMap::new(),
+            owner_key_control,
+            owner_hot_cache,
+            owner_hot_replica_inflight,
+            owner_hot_atomic_groups,
+            owner_hot_group_replica_triggered,
+            owner_hot_counters,
+            owner_hot_eviction_rx: Mutex::new(Some(owner_hot_eviction_rx)),
             external_invalidate_delete: EnsureMemholderMgmtDeleteHandle::new(
                 OwnerExternalMemMgr::DELETE_SUBMIT_QUEUE_CAPACITY,
             ),
@@ -2603,6 +4053,7 @@ impl ClientKvApi {
             external_get_start_registry: DashMap::new(),
             external_get_start_by_key: DashMap::new(),
             next_external_get_start_handle: AtomicU64::new(1),
+            next_external_holding_id: AtomicU64::new(1),
             external_pending_puts: moka::sync::Cache::builder()
                 .time_to_live(Duration::from_secs(30 * 60))
                 .segments(16)
@@ -2621,6 +4072,7 @@ impl ClientKvApi {
             rpc_caller_batch_put_start: RPCCaller::new(),
             rpc_caller_batch_put_revoke: RPCCaller::new(),
             rpc_caller_batch_put_done: RPCCaller::new(),
+            rpc_caller_grouped_batch_put_done: RPCCaller::new(),
             rpc_caller_batch_prepare_put_keys: RPCCaller::new(),
             rpc_caller_batch_release_put_key_reservations: RPCCaller::new(),
             rpc_caller_put_append_start: RPCCaller::new(),
@@ -2678,6 +4130,9 @@ impl ClientKvApi {
         inner
             .rpc_caller_batch_put_done
             .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_grouped_batch_put_done
+            .regist(inner.view.p2p_module());
         inner
             .rpc_caller_batch_prepare_put_keys
             .regist(inner.view.p2p_module());
@@ -2997,6 +4452,39 @@ impl ClientKvApi {
         });
 
         // client rpc handler register
+        let view = inner.view.clone_view();
+        RPCHandler::<BatchEnqueueReplicaTaskReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_batch_enqueue_replica_tasks", async move {
+                    let ack = put::handle_batch_enqueue_replica_tasks(&view_task, msg).await;
+                    if let Err(e) = resp.send_resp(ack).await {
+                        warn!("Failed to send BatchEnqueueReplicaTaskResp: {:?}", e);
+                    }
+                });
+                Ok(())
+            },
+        );
+
+        let view = inner.view.clone_view();
+        RPCHandler::<BatchOwnerReclaimReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let req_node_id = resp.node_id().clone();
+                let view = view.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_batch_owner_reclaim", async move {
+                    let ack = handle_batch_owner_reclaim(&view_task, msg, req_node_id).await;
+                    if let Err(e) = resp.send_resp(ack).await {
+                        warn!("Failed to send BatchOwnerReclaimResp: {:?}", e);
+                    }
+                });
+                Ok(())
+            },
+        );
+
         let view = inner.view.clone_view();
         RPCHandler::<BatchDeleteClientKvMetaCacheReq>::new().regist(
             inner.view.p2p_module(),
@@ -3032,10 +4520,27 @@ impl ClientKvApi {
         delete::spawn_owner_delete_ack_batch(inner.view.clone_view(), delete_ack_batch_rx);
 
         if let Some(replica_task_rx) = inner.replica_task_rx.lock().take() {
-            put::spawn_replica_task_actor(inner.view.clone_view(), replica_task_rx);
+            put::spawn_replica_task_actor(
+                inner.view.clone_view(),
+                replica_task_rx,
+                inner
+                    .test_spec_config
+                    .replica_task_max_inflight
+                    .unwrap_or(1) as usize,
+            );
         } else {
             tracing::warn!("replica_task_rx already taken for ClientKvApi");
         }
+        if inner.owner_hot_cache.is_some() {
+            if let Some(owner_hot_eviction_rx) = inner.owner_hot_eviction_rx.lock().take() {
+                put::spawn_owner_hot_replica_dispatcher(
+                    inner.view.clone_view(),
+                    owner_hot_eviction_rx,
+                );
+            } else {
+                tracing::warn!("owner_hot_eviction_rx already taken for ClientKvApi");
+            }
+        }
         if let Some(owner_local_publish_rx) = inner.owner_local_publish_rx.lock().take() {
             put::spawn_owner_local_publish_dispatcher(
                 inner.view.clone_view(),
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
index c9c2475..fe83d34 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
@@ -150,6 +150,7 @@ pub struct ExternalBatchGetStartResp {
     pub error_json: String,
     pub handle: u64,
     pub raw_prefix_hit_len: usize,
+    pub transfer_plan: ExternalBatchGetStartTransferPlan,
 }
 impl MsgPackSerializePart for ExternalBatchGetStartResp {
     fn msg_id(&self) -> u32 {
@@ -157,6 +158,15 @@ impl MsgPackSerializePart for ExternalBatchGetStartResp {
     }
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub enum ExternalBatchGetStartTransferPlan {
+    #[default]
+    OwnerRpc,
+    InlineLocal {
+        items: Vec<ExternalBatchGetItemResp>,
+    },
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalBatchGetTransferReq {
     pub handle: u64,
@@ -191,12 +201,22 @@ pub struct ExternalBatchGetCancelReq {
     pub req_node_id: String,
     /// Owner node_start_time observed by external when request starts
     pub started_time: i64,
+    pub transfer_plan: ExternalBatchGetCancelPlan,
 }
 impl MsgPackSerializePart for ExternalBatchGetCancelReq {
     fn msg_id(&self) -> u32 {
         4034
     }
 }
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub enum ExternalBatchGetCancelPlan {
+    #[default]
+    OwnerRpc,
+    InlineLocal {
+        holder_ids: Vec<u64>,
+    },
+}
 impl RPCReq for ExternalBatchGetCancelReq {
     type Resp = ExternalBatchGetCancelResp;
 }
@@ -212,6 +232,65 @@ impl MsgPackSerializePart for ExternalBatchGetCancelResp {
     }
 }
 
+#[cfg(test)]
+mod external_batch_get_plan_wire_tests {
+    use super::{
+        ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetItemResp,
+        ExternalBatchGetStartResp, ExternalBatchGetStartTransferPlan,
+    };
+    use crate::memholder::ExternalMemHolderInfo;
+    use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+
+    #[test]
+    fn inline_start_and_cancel_plans_round_trip() {
+        let start = ExternalBatchGetStartResp {
+            error_code: OK,
+            error_json: String::new(),
+            handle: 19,
+            raw_prefix_hit_len: 2,
+            transfer_plan: ExternalBatchGetStartTransferPlan::InlineLocal {
+                items: vec![ExternalBatchGetItemResp {
+                    error_code: OK,
+                    error_json: String::new(),
+                    external_memholder_info: Some(ExternalMemHolderInfo {
+                        offset: 4096,
+                        len: 8192,
+                        holder_id: 23,
+                    }),
+                }],
+            },
+        };
+        let decoded_start: ExternalBatchGetStartResp =
+            bitcode::decode(&bitcode::encode(&start)).expect("decode inline start plan");
+        assert_eq!(decoded_start.handle, 19);
+        assert!(matches!(
+            decoded_start.transfer_plan,
+            ExternalBatchGetStartTransferPlan::InlineLocal { items }
+                if items.len() == 1
+                    && items[0]
+                        .external_memholder_info
+                        .as_ref()
+                        .is_some_and(|info| info.holder_id == 23)
+        ));
+
+        let cancel = ExternalBatchGetCancelReq {
+            handle: 19,
+            req_node_id: "external-a".to_string(),
+            started_time: 29,
+            transfer_plan: ExternalBatchGetCancelPlan::InlineLocal {
+                holder_ids: vec![23, 24],
+            },
+        };
+        let decoded_cancel: ExternalBatchGetCancelReq =
+            bitcode::decode(&bitcode::encode(&cancel)).expect("decode inline cancel plan");
+        assert!(matches!(
+            decoded_cancel.transfer_plan,
+            ExternalBatchGetCancelPlan::InlineLocal { holder_ids }
+                if holder_ids == vec![23, 24]
+        ));
+    }
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalBatchPutStartItemReq {
     pub key: String,
@@ -225,6 +304,8 @@ pub struct ExternalBatchPutStartItemReq {
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalBatchPutStartReq {
     pub items: Vec<ExternalBatchPutStartItemReq>,
+    /// Positive lengths partitioning `items`; omitted means one group per item.
+    pub atomic_group_lens: Option<Vec<usize>>,
     /// Owner node_start_time observed by external when request starts
     pub started_time: i64,
 }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index fd309b3..1171c65 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -1,6 +1,7 @@
 use super::{
-    ClientKvApiInner, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
-    OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, ReplicaTaskJob, ReplicaTaskTarget,
+    ClientKvApiInner, OwnerHotEvictionEvent, OwnerLocalReserveClassState,
+    OwnerLocalReserveGrantState, OwnerLocalReservePoolState, OwnerLocalReserveSlotLease,
+    OwnerLocalReserveSlotRef, ReplicaTaskJob, ReplicaTaskTarget,
     local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
 };
 use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
@@ -15,13 +16,16 @@ use crate::observe_kvope::{
 use crate::{
     client_kv_api::ClientKvApiView,
     master_kv_router::msg_pack::{
-        BatchPreparePutKeyItemReq, BatchPreparePutKeysReq, BatchPreparePutKeysResp,
-        BatchPutDoneItemReq, BatchPutDoneReq, BatchPutDoneResp, BatchPutRevokeItemReq,
-        BatchPutRevokeReq, BatchPutRevokeResp, BatchPutStartItemReq, BatchPutStartReq,
-        BatchPutStartResp, BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
-        PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq, PutAppendStartReq,
-        PutAppendStartResp, PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq,
-        PutStartResp, ReleaseLocalGrantReq, ReserveLocalGrantReq, ReserveLocalGrantResp,
+        BatchEnqueueReplicaTaskReq, BatchEnqueueReplicaTaskResp, BatchPreparePutKeyItemReq,
+        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutDoneItemReq, BatchPutDoneReq,
+        BatchPutDoneResp, BatchPutRevokeItemReq, BatchPutRevokeReq, BatchPutRevokeResp,
+        BatchPutStartItemReq, BatchPutStartReq, BatchPutStartResp,
+        BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
+        EnqueueReplicaTaskItemResp, GroupedBatchPutDoneItemReq, GroupedBatchPutDoneReq,
+        GroupedBatchPutDoneResp, PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq,
+        PutAppendStartReq, PutAppendStartResp, PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq,
+        PutRevokeReq, PutStartReq, PutStartResp, ReleaseLocalGrantReq, ReserveLocalGrantOutcome,
+        ReserveLocalGrantReq,
     },
     memholder::{UserMemHolder, UserMemHolderExposeKind},
     p2p::msg_pack::MsgPack,
@@ -30,40 +34,30 @@ use crate::{
 };
 use chrono::Utc;
 use fluxon_commu::TransferBreakdown;
+use fluxon_util::semaphore_map::SemaphoreMap;
 use limit_thirdparty::tokio;
-use std::sync::Arc;
-use std::time::Instant;
+use std::sync::{Arc, atomic::Ordering};
+use std::time::{Duration, Instant};
 use tracing::info;
 
 fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
     duration.as_micros().min(i64::MAX as u128) as i64
 }
 
-const OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES: u64 = 4 * 1024;
 fn owner_local_reserve_slot_size(value_len: u64) -> KvResult<u64> {
-    let normalized = value_len.max(OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES);
-    let slot_size = normalized.checked_next_power_of_two().ok_or_else(|| {
+    crate::owner_local_reserve_slot_size_bytes(value_len).ok_or_else(|| {
         KvError::Api(ApiError::InvalidArgument {
             detail: format!(
-                "value_len={} exceeds resident local reserve slot size range",
-                value_len
+                "value_len={} cannot be represented by a resident local-reserve slot no larger than {} bytes",
+                value_len, OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES
             ),
         })
-    })?;
-    if slot_size > OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
-        return Err(KvError::Api(ApiError::InvalidArgument {
-            detail: format!(
-                "value_len={} requires slot_size={} larger than local reserve grant quantum={}",
-                value_len, slot_size, OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES
-            ),
-        }));
-    }
-    Ok(slot_size)
+    })
 }
 
 fn owner_local_reserve_slots_per_grant(slot_size: u64) -> u32 {
-    let slots = (OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES / slot_size).max(1);
-    slots.min(u32::MAX as u64) as u32
+    crate::owner_local_reserve_slots_per_grant(slot_size)
+        .expect("validated local-reserve slot size must fit in a grant")
 }
 
 fn owner_local_reserve_install_grant(
@@ -94,34 +88,319 @@ fn owner_local_reserve_try_claim(
     value_len: u64,
     key_count: usize,
 ) -> Option<OwnerLocalReserveSlotLease> {
-    let class_state = pool
+    let free_slots = pool
         .classes
         .entry(slot_size)
-        .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
-    if class_state.free_slot_count() < key_count {
+        .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant))
+        .free_slot_count();
+    if free_slots < key_count {
         return None;
     }
-    let mut slots = Vec::with_capacity(key_count);
+    let slots = owner_local_reserve_claim_available(pool, slot_size, slots_per_grant, key_count);
+    assert_eq!(
+        slots.len(),
+        key_count,
+        "free_slot_count check and claim path diverged"
+    );
+    Some(OwnerLocalReserveSlotLease {
+        value_len,
+        slot_size,
+        slots,
+    })
+}
+
+fn owner_local_reserve_claim_available(
+    pool: &mut OwnerLocalReservePoolState,
+    slot_size: u64,
+    slots_per_grant: u32,
+    max_slots: usize,
+) -> Vec<OwnerLocalReserveSlotRef> {
+    let class_state = pool
+        .classes
+        .entry(slot_size)
+        .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
+    let claim_count = class_state.free_slot_count().min(max_slots);
+    let mut slots = Vec::with_capacity(claim_count);
     for grant in class_state.grants.iter_mut() {
-        while slots.len() < key_count {
+        while slots.len() < claim_count {
             match grant.claim_prepared_slot() {
                 Some(slot) => slots.push(slot),
                 None => break,
             }
         }
-        if slots.len() == key_count {
+        if slots.len() == claim_count {
             break;
         }
     }
-    assert!(
-        slots.len() == key_count,
+    assert_eq!(
+        slots.len(),
+        claim_count,
         "free_slot_count check and claim path diverged"
     );
-    Some(OwnerLocalReserveSlotLease {
-        value_len,
-        slot_size,
-        slots,
-    })
+    slots
+}
+
+struct OwnerLocalReservePendingDemandGuard<'a> {
+    inner: &'a ClientKvApiInner,
+    slot_size: u64,
+    slots_per_grant: u32,
+    pending_slots: usize,
+}
+
+impl<'a> OwnerLocalReservePendingDemandGuard<'a> {
+    fn new(
+        inner: &'a ClientKvApiInner,
+        slot_size: u64,
+        slots_per_grant: u32,
+        pending_slots: usize,
+    ) -> Self {
+        inner.owner_local_reserve_register_pending_demand(
+            slot_size,
+            slots_per_grant,
+            pending_slots,
+        );
+        Self {
+            inner,
+            slot_size,
+            slots_per_grant,
+            pending_slots,
+        }
+    }
+
+    fn consume(&mut self) {
+        if self.pending_slots == 0 {
+            return;
+        }
+        self.inner.owner_local_reserve_consume_pending_demand(
+            self.slot_size,
+            self.slots_per_grant,
+            self.pending_slots,
+        );
+        self.pending_slots = 0;
+        self.inner
+            .owner_local_reserve_rebalance_notify()
+            .notify_waiters();
+    }
+
+    fn disarm_after_locked_consume(&mut self) {
+        assert!(
+            self.pending_slots > 0,
+            "pending-demand guard was already consumed"
+        );
+        self.pending_slots = 0;
+        self.inner
+            .owner_local_reserve_rebalance_notify()
+            .notify_waiters();
+    }
+}
+
+impl Drop for OwnerLocalReservePendingDemandGuard<'_> {
+    fn drop(&mut self) {
+        self.consume();
+    }
+}
+
+#[cfg(test)]
+mod local_reserve_claim_tests {
+    use super::{
+        OwnerLocalReserveGrantState, OwnerLocalReservePoolState,
+        owner_local_reserve_claim_available, owner_local_reserve_install_grant,
+        owner_local_reserve_slot_size, owner_local_reserve_slots_per_grant,
+    };
+    use crate::client_kv_api::{ClientKvApi, ClientKvApiNewArg};
+    use crate::config::TestSpecConfig;
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    #[test]
+    fn slot_size_uses_page_aligned_exact_fit() {
+        const SGLANG_KV_PAGE_BYTES: u64 = 4_718_592;
+
+        let slot_size = owner_local_reserve_slot_size(SGLANG_KV_PAGE_BYTES).unwrap();
+        assert_eq!(slot_size, SGLANG_KV_PAGE_BYTES);
+        assert_eq!(owner_local_reserve_slots_per_grant(slot_size), 113);
+        assert_eq!(owner_local_reserve_slot_size(4_097).unwrap(), 8_192);
+    }
+
+    #[test]
+    fn partial_claim_keeps_progress_for_large_waiters() {
+        let mut pool = OwnerLocalReservePoolState::default();
+        owner_local_reserve_install_grant(
+            &mut pool,
+            8,
+            4,
+            OwnerLocalReserveGrantState::new(1, 1000, 1000, 32, 8, 4),
+        );
+
+        let first = owner_local_reserve_claim_available(&mut pool, 8, 4, 3);
+        assert_eq!(first.len(), 3);
+        assert_eq!(pool.classes.get(&8).unwrap().free_slot_count(), 1);
+
+        let second = owner_local_reserve_claim_available(&mut pool, 8, 4, 3);
+        assert_eq!(second.len(), 1);
+        assert_eq!(pool.classes.get(&8).unwrap().free_slot_count(), 0);
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn later_waiter_cannot_steal_slot_before_current_claim_turn_completes() {
+        const SLOT_SIZE: u64 = 4 * 1024;
+        const SLOTS_PER_GRANT: u32 = 4;
+
+        let api = Arc::new(
+            ClientKvApi::construct(ClientKvApiNewArg {
+                test_spec_config: TestSpecConfig::default(),
+                owner_hot_cache_capacity_bytes: None,
+            })
+            .await
+            .expect("construct test ClientKvApi"),
+        );
+        {
+            let mut pool = api.inner().owner_local_reserve_pool.lock();
+            owner_local_reserve_install_grant(
+                &mut pool,
+                SLOT_SIZE,
+                SLOTS_PER_GRANT,
+                OwnerLocalReserveGrantState::new(
+                    1,
+                    1000,
+                    1000,
+                    SLOT_SIZE * u64::from(SLOTS_PER_GRANT),
+                    SLOT_SIZE,
+                    SLOTS_PER_GRANT,
+                ),
+            );
+        }
+
+        // Model a five-slot waiter that has made partial progress while owning the claim turn.
+        let current_claim_turn = api.inner().owner_local_reserve_claim_lock.lock().await;
+        let first_partial = {
+            let mut pool = api.inner().owner_local_reserve_pool.lock();
+            owner_local_reserve_claim_available(&mut pool, SLOT_SIZE, SLOTS_PER_GRANT, 3)
+        };
+        assert_eq!(first_partial.len(), 3);
+
+        // A later one-slot request must queue even though one slot is currently free.
+        let later_api = Arc::clone(&api);
+        let mut later_waiter = tokio::spawn(async move {
+            later_api
+                .inner()
+                .owner_claim_local_reserve_slot_lease(SLOT_SIZE, 1)
+                .await
+        });
+        assert!(
+            limit_thirdparty::tokio::time::timeout(Duration::from_millis(25), &mut later_waiter,)
+                .await
+                .is_err(),
+            "later waiter bypassed the active claim turn"
+        );
+        assert_eq!(
+            api.inner()
+                .owner_local_reserve_pool
+                .lock()
+                .classes
+                .get(&SLOT_SIZE)
+                .unwrap()
+                .free_slot_count(),
+            1,
+            "later waiter stole the current waiter's remaining free slot"
+        );
+
+        // Refill lets the current waiter reach all five slots before handing off the turn.
+        let first_remainder = {
+            let mut pool = api.inner().owner_local_reserve_pool.lock();
+            owner_local_reserve_install_grant(
+                &mut pool,
+                SLOT_SIZE,
+                SLOTS_PER_GRANT,
+                OwnerLocalReserveGrantState::new(
+                    2,
+                    2000,
+                    2000,
+                    SLOT_SIZE * u64::from(SLOTS_PER_GRANT),
+                    SLOT_SIZE,
+                    SLOTS_PER_GRANT,
+                ),
+            );
+            owner_local_reserve_claim_available(&mut pool, SLOT_SIZE, SLOTS_PER_GRANT, 2)
+        };
+        assert_eq!(first_partial.len() + first_remainder.len(), 5);
+        drop(current_claim_turn);
+
+        let later_lease =
+            limit_thirdparty::tokio::time::timeout(Duration::from_secs(1), later_waiter)
+                .await
+                .expect("later waiter did not receive the next claim turn")
+                .expect("later waiter task panicked")
+                .expect("later waiter failed to claim a free slot");
+        assert_eq!(later_lease.slots.len(), 1);
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn queued_claims_publish_aggregate_demand_and_cancel_cleanly() {
+        const SLOT_SIZE: u64 = 4 * 1024;
+        const SLOTS_PER_GRANT: u32 = 4;
+
+        let api = Arc::new(
+            ClientKvApi::construct(ClientKvApiNewArg {
+                test_spec_config: TestSpecConfig::default(),
+                owner_hot_cache_capacity_bytes: None,
+            })
+            .await
+            .expect("construct test ClientKvApi"),
+        );
+        let claim_turn = api.inner().owner_local_reserve_claim_lock.lock().await;
+
+        let first_api = Arc::clone(&api);
+        let first = tokio::spawn(async move {
+            first_api
+                .inner()
+                .owner_claim_local_reserve_slot_lease(SLOT_SIZE, 3)
+                .await
+        });
+        let second_api = Arc::clone(&api);
+        let second = tokio::spawn(async move {
+            second_api
+                .inner()
+                .owner_claim_local_reserve_slot_lease(SLOT_SIZE, 2)
+                .await
+        });
+
+        limit_thirdparty::tokio::time::timeout(Duration::from_secs(1), async {
+            loop {
+                let pending = api
+                    .inner()
+                    .owner_local_reserve_pool
+                    .lock()
+                    .classes
+                    .get(&SLOT_SIZE)
+                    .map(|class| class.pending_slot_demand)
+                    .unwrap_or_default();
+                if pending == 5 {
+                    break;
+                }
+                limit_thirdparty::tokio::task::yield_now().await;
+            }
+        })
+        .await
+        .expect("queued claims did not publish aggregate demand");
+
+        first.abort();
+        second.abort();
+        let _ = first.await;
+        let _ = second.await;
+        assert_eq!(
+            api.inner()
+                .owner_local_reserve_pool
+                .lock()
+                .classes
+                .get(&SLOT_SIZE)
+                .unwrap()
+                .pending_slot_demand,
+            0,
+            "cancelled queued claims leaked pending demand"
+        );
+        drop(claim_turn);
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -149,6 +428,7 @@ pub struct OwnerLocalPublishItem {
     pub committed_slot: PutDoneCommittedSlot,
     pub make_replica_task: bool,
     pub preferred_sub_cluster: Option<String>,
+    pub atomic_group: Option<PutAtomicGroup>,
 }
 
 #[derive(Debug, Clone)]
@@ -168,6 +448,49 @@ pub struct PutEndWithLocalCachePublish {
     pub local_cache_holder_id: Option<u64>,
 }
 
+fn owner_local_reserve_timeout_error(
+    inner: &ClientKvApiInner,
+    stage: &'static str,
+    slot_size: u64,
+    key_count: usize,
+    soft_wait_timeout: std::time::Duration,
+    hard_wait_timeout: std::time::Duration,
+    request_started_at: Instant,
+) -> KvError {
+    let (used_slots, free_slots, pending_slots, grants, expected_grants) = {
+        let pool = inner.owner_local_reserve_pool.lock();
+        pool.classes
+            .get(&slot_size)
+            .map(|class_state| {
+                (
+                    class_state.used_slot_count(),
+                    class_state.free_slot_count(),
+                    class_state.pending_slot_demand,
+                    class_state.grant_count(),
+                    class_state.expected_grant_count,
+                )
+            })
+            .unwrap_or((0, 0, 0, 0, 0))
+    };
+    KvError::Api(ApiError::Unknown {
+        detail: format!(
+            "owner local reserve refill timeout: stage={} slot_size={} key_count={} remaining_slots={} used_slots={} free_slots={} pending_slots={} grants={} expected_grants={} waited_ms={} soft_wait_timeout_ms={} hard_timeout_ms={}",
+            stage,
+            slot_size,
+            key_count,
+            key_count.saturating_sub(free_slots),
+            used_slots,
+            free_slots,
+            pending_slots,
+            grants,
+            expected_grants,
+            request_started_at.elapsed().as_millis(),
+            soft_wait_timeout.as_millis(),
+            hard_wait_timeout.as_millis()
+        ),
+    })
+}
+
 impl ClientKvApiInner {
     pub async fn owner_claim_local_reserve_slot_lease(
         &self,
@@ -177,93 +500,100 @@ impl ClientKvApiInner {
         let slot_size = owner_local_reserve_slot_size(value_len)?;
         let slots_per_grant = owner_local_reserve_slots_per_grant(slot_size);
         let (soft_wait_timeout, hard_wait_timeout) = owner_local_reserve_timeout_config(self);
-        let hard_deadline = Instant::now()
+        let request_started_at = Instant::now();
+        let hard_deadline = request_started_at
             .checked_add(hard_wait_timeout)
             .ok_or_else(|| {
                 KvError::Api(ApiError::Unknown {
                     detail: "owner local reserve hard timeout overflow".to_string(),
                 })
             })?;
-        let mut pending_demand_registered = false;
-        let claim_result = {
-            let mut pool = self.owner_local_reserve_pool.lock();
-            let class_state = pool
-                .classes
-                .entry(slot_size)
-                .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
-            if class_state.free_slot_count() >= key_count {
-                Some(owner_local_reserve_try_claim(
-                    &mut pool,
-                    slot_size,
-                    slots_per_grant,
-                    value_len,
-                    key_count,
-                ))
-            } else {
-                None
-            }
-        };
-        if let Some(Some(lease)) = claim_result {
-            return Ok(lease);
-        }
-        self.owner_local_reserve_register_pending_demand(slot_size, slots_per_grant, key_count);
-        pending_demand_registered = true;
+        // Publish demand before waiting for the FIFO turn so one refill can cover all queued
+        // claimants. The guard also removes demand if the caller is cancelled while queued.
+        let mut pending_demand =
+            OwnerLocalReservePendingDemandGuard::new(self, slot_size, slots_per_grant, key_count);
         self.owner_local_reserve_rebalance_notify().notify_waiters();
-        if !wait_owner_local_reserve_ready(
-            self,
-            slot_size,
-            slots_per_grant,
-            key_count,
-            soft_wait_timeout,
-            hard_deadline,
+
+        let Some(remaining_for_turn) = hard_deadline.checked_duration_since(Instant::now()) else {
+            return Err(owner_local_reserve_timeout_error(
+                self,
+                "claim_turn",
+                slot_size,
+                key_count,
+                soft_wait_timeout,
+                hard_wait_timeout,
+                request_started_at,
+            ));
+        };
+        let _claim_turn = match tokio::time::timeout(
+            remaining_for_turn,
+            self.owner_local_reserve_claim_lock.lock(),
         )
         .await
         {
-            let soft_wait_timeout_ms = soft_wait_timeout.as_millis();
-            let hard_wait_timeout_ms = hard_wait_timeout.as_millis();
-            if pending_demand_registered {
-                self.owner_local_reserve_consume_pending_demand(
+            Ok(claim_turn) => claim_turn,
+            Err(_) => {
+                return Err(owner_local_reserve_timeout_error(
+                    self,
+                    "claim_turn",
                     slot_size,
-                    slots_per_grant,
                     key_count,
-                );
+                    soft_wait_timeout,
+                    hard_wait_timeout,
+                    request_started_at,
+                ));
             }
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "owner local reserve refill timeout: slot_size={} key_count={} soft_wait_timeout_ms={} hard_timeout_ms={}",
-                    slot_size, key_count, soft_wait_timeout_ms, hard_wait_timeout_ms
-                ),
-            }));
-        }
-        let claim_result = {
-            let mut pool = self.owner_local_reserve_pool.lock();
-            let class_state = pool
-                .classes
-                .entry(slot_size)
-                .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
-            if class_state.free_slot_count() >= key_count {
-                Some(owner_local_reserve_try_claim(
+        };
+
+        loop {
+            let claim = {
+                let mut pool = self.owner_local_reserve_pool.lock();
+                let claim = owner_local_reserve_try_claim(
                     &mut pool,
                     slot_size,
                     slots_per_grant,
                     value_len,
                     key_count,
-                ))
-            } else {
-                None
+                );
+                if claim.is_some() {
+                    let class_state = pool
+                        .classes
+                        .get_mut(&slot_size)
+                        .expect("claimed local-reserve class must exist");
+                    class_state.pending_slot_demand = class_state
+                        .pending_slot_demand
+                        .checked_sub(key_count)
+                        .expect("claimed local-reserve demand underflow");
+                }
+                claim
+            };
+            if let Some(lease) = claim {
+                pending_demand.disarm_after_locked_consume();
+                return Ok(lease);
+            }
+            self.owner_local_reserve_rebalance_notify().notify_waiters();
+            if !wait_owner_local_reserve_ready(
+                self,
+                slot_size,
+                slots_per_grant,
+                key_count,
+                soft_wait_timeout,
+                hard_deadline,
+            )
+            .await
+            {
+                break;
             }
-        };
-        if let Some(Some(lease)) = claim_result {
-            self.owner_local_reserve_consume_pending_demand(slot_size, slots_per_grant, key_count);
-            return Ok(lease);
         }
-        self.owner_local_reserve_consume_pending_demand(slot_size, slots_per_grant, key_count);
-        Err(KvError::Api(ApiError::Unknown {
-            detail: format!(
-                "owner local reserve ready check returned without available slots: slot_size={} key_count={}",
-                slot_size, key_count
-            ),
-        }))
+        Err(owner_local_reserve_timeout_error(
+            self,
+            "refill",
+            slot_size,
+            key_count,
+            soft_wait_timeout,
+            hard_wait_timeout,
+            request_started_at,
+        ))
     }
 
     pub async fn owner_release_local_reserve_slot_lease(
@@ -627,6 +957,7 @@ impl ClientKvApiInner {
                 lease_id: pending.item.lease_id,
                 committed_slot: None,
                 publish_local_cache: false,
+                atomic_group: None,
             })
             .collect::<Vec<_>>();
         let done_resp = self.batch_put_done(done_req_items).await?;
@@ -846,6 +1177,7 @@ impl ClientKvApiInner {
                 lease_id: pending.lease_id,
                 committed_slot: None,
                 publish_local_cache: false,
+                atomic_group: None,
             })
             .collect::<Vec<_>>();
         let done_resp = self.batch_put_done(done_req_items).await?;
@@ -908,9 +1240,9 @@ impl ClientKvApiInner {
         put_id: PutIDForAKey,
         target: ReplicaTaskTarget,
     ) -> KvResult<()> {
-        let Some(memory_info) = self.local_visible_mem_holder(key) else {
+        let Some(memory_info) = self.local_committed_mem_holder_for_put_id(key, put_id) else {
             tracing::warn!(
-                "replica task source holder is unavailable after local commit; dropping replica task: key={} put_id=({},{})",
+                "replica task source holder is unavailable or version-mismatched after local commit; dropping replica task: key={} put_id=({},{})",
                 key,
                 put_id.0,
                 put_id.1
@@ -924,17 +1256,25 @@ impl ClientKvApiInner {
             UserMemHolderExposeKind::SegPtr,
         ));
 
-        match self.replica_task_tx.try_send(ReplicaTaskJob {
-            key: key.to_string(),
-            put_id,
-            holder,
-            target: Some(target),
-            preferred_sub_cluster: None,
-        }) {
+        // A full queue must apply backpressure. Dropping a promised replica task leaves a
+        // local-only committed slot that reserve reclaim cannot safely release.
+        match self
+            .replica_task_tx
+            .send(ReplicaTaskJob {
+                key: key.to_string(),
+                put_id,
+                holder,
+                target: Some(target),
+                preferred_sub_cluster: None,
+                hot_replica_guard: None,
+                protect_source_on_remote_complete: true,
+            })
+            .await
+        {
             Ok(()) => Ok(()),
             Err(err) => {
                 tracing::warn!(
-                    "replica task actor enqueue failed; dropping replica task: key={} put_id=({},{}) err={}",
+                    "replica task actor queue closed; local-only commit remains valid: key={} put_id=({},{}) err={}",
                     key,
                     put_id.0,
                     put_id.1,
@@ -950,15 +1290,16 @@ impl ClientKvApiInner {
         key: &str,
         put_id: PutIDForAKey,
         preferred_sub_cluster: Option<String>,
-    ) -> KvResult<()> {
-        let Some(memory_info) = self.local_visible_mem_holder(key) else {
+        protect_source_on_remote_complete: bool,
+    ) -> KvResult<bool> {
+        let Some(memory_info) = self.local_committed_mem_holder_for_put_id(key, put_id) else {
             tracing::warn!(
-                "replica append task source holder is unavailable after local publish; dropping replica task: key={} put_id=({},{})",
+                "replica append task source holder is unavailable or version-mismatched after local publish; dropping replica task: key={} put_id=({},{})",
                 key,
                 put_id.0,
                 put_id.1
             );
-            return Ok(());
+            return Ok(false);
         };
 
         let holder = Arc::new(UserMemHolder::new(
@@ -967,23 +1308,30 @@ impl ClientKvApiInner {
             UserMemHolderExposeKind::SegPtr,
         ));
 
-        match self.replica_task_tx.try_send(ReplicaTaskJob {
-            key: key.to_string(),
-            put_id,
-            holder,
-            target: None,
-            preferred_sub_cluster,
-        }) {
-            Ok(()) => Ok(()),
+        // Preserve append tasks under burst load for the same reclaim-safety reason above.
+        match self
+            .replica_task_tx
+            .send(ReplicaTaskJob {
+                key: key.to_string(),
+                put_id,
+                holder,
+                target: None,
+                preferred_sub_cluster,
+                hot_replica_guard: None,
+                protect_source_on_remote_complete,
+            })
+            .await
+        {
+            Ok(()) => Ok(true),
             Err(err) => {
                 tracing::warn!(
-                    "replica append task actor enqueue failed; dropping replica task: key={} put_id=({},{}) err={}",
+                    "replica append task actor queue closed; local-only commit remains valid: key={} put_id=({},{}) err={}",
                     key,
                     put_id.0,
                     put_id.1,
                     err
                 );
-                Ok(())
+                Ok(false)
             }
         }
     }
@@ -1460,14 +1808,23 @@ impl ClientKvApiInner {
         .await
     }
 
-    pub async fn reserve_local_grant(&self) -> KvResult<ReserveLocalGrantResp> {
+    pub async fn reserve_local_grant(
+        &self,
+        slot_size: u64,
+        required_free_slots: u32,
+        reclaim_before_grow: bool,
+    ) -> KvResult<ReserveLocalGrantOutcome> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
                 detail: "ClientKvApi is shutting down; rejecting reserve_local_grant".to_string(),
             }));
         }
         let req = MsgPack {
-            serialize_part: ReserveLocalGrantReq::default(),
+            serialize_part: ReserveLocalGrantReq {
+                slot_size,
+                required_free_slots,
+                reclaim_before_grow,
+            },
             raw_bytes: Vec::new(),
         };
         let master_node_id = self
@@ -1490,7 +1847,12 @@ impl ClientKvApiInner {
             resp.serialize_part.error_code,
             resp.serialize_part.error_json.clone(),
         )?;
-        Ok(resp.serialize_part)
+        match resp.serialize_part.outcome {
+            ReserveLocalGrantOutcome::None => Err(KvError::Api(ApiError::Unknown {
+                detail: "reserve_local_grant returned success without an outcome".to_string(),
+            })),
+            outcome => Ok(outcome),
+        }
     }
 
     pub async fn release_local_grant(&self, grant_id: u64) -> KvResult<()> {
@@ -1571,6 +1933,8 @@ impl ClientKvApiInner {
         put_id: PutIDForAKey,
         len: u32,
         preferred_sub_cluster: Option<&str>,
+        demote_source_on_remote_complete: bool,
+        protect_source_on_remote_complete: bool,
     ) -> KvResult<PutAppendStartResp> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
@@ -1583,6 +1947,8 @@ impl ClientKvApiInner {
                 put_id,
                 len: len as u64,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
+                demote_source_on_remote_complete,
+                protect_source_on_remote_complete,
             },
             raw_bytes: Vec::new(),
         };
@@ -1897,6 +2263,56 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
+    pub async fn grouped_batch_put_done(
+        &self,
+        items: Vec<GroupedBatchPutDoneItemReq>,
+        atomic_group_lens: Vec<usize>,
+    ) -> KvResult<GroupedBatchPutDoneResp> {
+        if items.is_empty() {
+            return Ok(GroupedBatchPutDoneResp {
+                items: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting grouped_batch_put_done"
+                    .to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: GroupedBatchPutDoneReq {
+                items,
+                atomic_group_lens,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_grouped_batch_put_done
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
     /// 完成 Put 操作，提交数据（inner，无监控）
     pub async fn put_end_inner(
         &self,
@@ -1916,6 +2332,7 @@ impl ClientKvApiInner {
                 lease_id,
                 committed_slot: None,
                 publish_local_cache: false,
+                atomic_group: None,
             },
             raw_bytes: Vec::new(),
         };
@@ -1971,6 +2388,7 @@ impl ClientKvApiInner {
                 lease_id,
                 committed_slot: None,
                 publish_local_cache,
+                atomic_group: None,
             },
             raw_bytes: Vec::new(),
         };
@@ -2068,145 +2486,402 @@ impl ClientKvApiInner {
     }
 }
 
-pub fn spawn_replica_task_actor(
+const OWNER_HOT_APPEND_START_MAX_ATTEMPTS: usize = 3;
+
+fn replica_append_demotes_source_on_remote_complete(is_owner_hot: bool) -> bool {
+    // Owner-hot eviction is an exclusive tier transition after the remote cohort is recoverable.
+    // Ordinary replica and tier-1 append tasks remain inclusive.
+    is_owner_hot
+}
+
+#[cfg(test)]
+mod owner_hot_replica_policy_tests {
+    use super::{
+        OwnerLocalPublishItem, complete_owner_local_publish_group_lens,
+        replica_append_demotes_source_on_remote_complete,
+    };
+    use crate::master_kv_router::msg_pack::{
+        PutAtomicGroup, PutAtomicGroupMember, PutDoneCommittedSlot,
+    };
+
+    #[test]
+    fn owner_hot_replication_is_exclusive_after_remote_completion() {
+        assert!(replica_append_demotes_source_on_remote_complete(true));
+        assert!(!replica_append_demotes_source_on_remote_complete(false));
+    }
+
+    fn publish_item(
+        key: &str,
+        put_id: (u64, u32),
+        atomic_group: Option<PutAtomicGroup>,
+    ) -> OwnerLocalPublishItem {
+        OwnerLocalPublishItem {
+            key: key.to_string(),
+            put_id,
+            value_len: 1,
+            lease_id: None,
+            committed_slot: PutDoneCommittedSlot::default(),
+            make_replica_task: false,
+            preferred_sub_cluster: None,
+            atomic_group,
+        }
+    }
+
+    #[test]
+    fn grouped_publish_partition_requires_a_complete_ordered_group() {
+        let group = PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: "a".to_string(),
+                    put_id: (1, 0),
+                },
+                PutAtomicGroupMember {
+                    key: "b".to_string(),
+                    put_id: (1, 1),
+                },
+                PutAtomicGroupMember {
+                    key: "c".to_string(),
+                    put_id: (1, 2),
+                },
+            ],
+        };
+        let complete = vec![
+            publish_item("a", (1, 0), Some(group.clone())),
+            publish_item("b", (1, 1), Some(group.clone())),
+            publish_item("c", (1, 2), Some(group.clone())),
+            publish_item("single", (2, 0), None),
+        ];
+        assert_eq!(
+            complete_owner_local_publish_group_lens(&complete),
+            Some(vec![3, 1])
+        );
+
+        let partial = vec![
+            publish_item("a", (1, 0), Some(group.clone())),
+            publish_item("b", (1, 1), Some(group)),
+        ];
+        assert_eq!(complete_owner_local_publish_group_lens(&partial), None);
+    }
+}
+
+async fn start_replica_append_with_retry(
+    inner: &ClientKvApiInner,
+    job: &ReplicaTaskJob,
+    len: u32,
+) -> KvResult<PutAppendStartResp> {
+    let max_attempts = if job.hot_replica_guard.is_some() {
+        OWNER_HOT_APPEND_START_MAX_ATTEMPTS
+    } else {
+        1
+    };
+    let mut attempt = 1usize;
+    loop {
+        match inner
+            .put_append_start(
+                &job.key,
+                job.put_id,
+                len,
+                job.preferred_sub_cluster.as_deref(),
+                replica_append_demotes_source_on_remote_complete(job.hot_replica_guard.is_some()),
+                job.protect_source_on_remote_complete,
+            )
+            .await
+        {
+            Ok(resp) => return Ok(resp),
+            Err(err)
+                if attempt < max_attempts
+                    && matches!(err, KvError::Api(ApiError::KeyBeingWritten { .. })) =>
+            {
+                tracing::warn!(
+                    "owner hot replica append start failed; retrying: key={} put_id=({},{}) attempt={}/{} err={}",
+                    job.key,
+                    job.put_id.0,
+                    job.put_id.1,
+                    attempt,
+                    max_attempts,
+                    err
+                );
+                let delay_ms = 25u64.saturating_mul(1u64 << (attempt - 1));
+                tokio::time::sleep(Duration::from_millis(delay_ms)).await;
+                attempt += 1;
+            }
+            Err(err) => return Err(err),
+        }
+    }
+}
+
+pub fn spawn_owner_hot_replica_dispatcher(
     view: ClientKvApiView,
-    mut rx: tokio::sync::ampsc::Receiver<ReplicaTaskJob>,
+    mut rx: tokio::sync::ampsc::Receiver<OwnerHotEvictionEvent>,
 ) {
     let view_task = view.clone();
-    let _ = view.spawn("replica_task_actor", async move {
+    let _ = view.spawn("owner_hot_replica_dispatcher", async move {
         let mut shutdown_waiter = view_task.register_shutdown_waiter();
         loop {
-            let job = tokio::select! {
+            let event = tokio::select! {
                 _ = shutdown_waiter.wait() => {
-                    tracing::info!("replica_task_actor stopping due to shutdown signal");
+                    tracing::info!("owner_hot_replica_dispatcher stopping due to shutdown signal");
                     break;
                 }
-                job = rx.recv() => {
-                    match job {
-                        Some(job) => job,
+                event = rx.recv() => {
+                    match event {
+                        Some(event) => event,
                         None => break,
                     }
                 }
             };
             let inner = view_task.client_kv_api().inner();
-            let src_offset = job.holder.memory_info().offset;
-            let len = job.holder.get_length() as u64;
-            let target = if let Some(target) = job.target.clone() {
-                target
-            } else {
-                let len_u32 = match u32::try_from(len) {
-                    Ok(len_u32) => len_u32,
-                    Err(_) => {
-                        tracing::warn!(
-                            "replica append task length does not fit u32: key={} put_id=({},{}) len={}",
-                            job.key,
-                            job.put_id.0,
-                            job.put_id.1,
-                            len
-                        );
-                        continue;
-                    }
-                };
-                let append_start = match inner
-                    .put_append_start(
-                        &job.key,
-                        job.put_id,
-                        len_u32,
-                        job.preferred_sub_cluster.as_deref(),
-                    )
-                    .await
-                {
-                    Ok(resp) => resp,
-                    Err(err) => {
-                        tracing::warn!(
-                            "replica append task start failed: key={} put_id=({},{}) err={}",
-                            job.key,
-                            job.put_id.0,
-                            job.put_id.1,
-                            err
-                        );
-                        continue;
-                    }
-                };
-                if !append_start.scheduled {
-                    tracing::debug!(
-                        "replica append task not scheduled: key={} put_id=({},{})",
-                        job.key,
-                        job.put_id.0,
-                        job.put_id.1
-                    );
-                    continue;
-                }
-                ReplicaTaskTarget {
-                    node_id: append_start.node_id,
-                    target_offset: append_start.target_addr - append_start.target_base_addr,
-                    target_base_addr: append_start.target_base_addr,
-                    len: append_start.len,
-                }
+            let Some(memory_info) = event.memory_info.upgrade() else {
+                event.guard.mark_obsolete();
+                continue;
             };
-            if len != target.len {
+            if !inner.owner_hot_source_is_current(
+                &event.key,
+                event.put_id,
+                &memory_info,
+            ) {
+                event.guard.mark_obsolete();
+                continue;
+            }
+            let holder = Arc::new(UserMemHolder::new(
+                memory_info,
+                inner.get_or_init_all_memholder_refcount(),
+                UserMemHolderExposeKind::SegPtr,
+            ));
+            let key = event.key.clone();
+            let put_id = event.put_id;
+            if let Err(err) = inner
+                .replica_task_tx
+                .send(ReplicaTaskJob {
+                    key: event.key,
+                    put_id: event.put_id,
+                    holder,
+                    target: None,
+                    preferred_sub_cluster: None,
+                    hot_replica_guard: Some(event.guard),
+                    protect_source_on_remote_complete: false,
+                })
+                .await
+            {
+                tracing::warn!(
+                    "replica task actor queue closed for owner hot eviction: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
+    });
+}
+
+async fn process_replica_task(view_task: ClientKvApiView, job: ReplicaTaskJob) {
+    let inner = view_task.client_kv_api().inner();
+    let src_offset = job.holder.memory_info().offset;
+    let len = job.holder.get_length() as u64;
+    let target = if let Some(target) = job.target.clone() {
+        target
+    } else {
+        let len_u32 = match u32::try_from(len) {
+            Ok(len_u32) => len_u32,
+            Err(_) => {
                 tracing::warn!(
-                    "replica task length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
+                    "replica append task length does not fit u32: key={} put_id=({},{}) len={}",
                     job.key,
                     job.put_id.0,
                     job.put_id.1,
-                    len,
-                    target.len
-                );
-                spawn_replica_task_revoke(
-                    view_task.clone(),
-                    job.key,
-                    job.put_id,
-                    "length mismatch",
+                    len
                 );
-                continue;
+                return;
             }
-            if let Err(err) = inner
-                .put_transfer(
-                    &job.key,
-                    job.put_id,
-                    src_offset,
-                    target.target_offset,
-                    len,
-                    Some(target.node_id.clone()),
-                    Some(target.target_base_addr),
-                )
-                .await
-            {
+        };
+        let append_start = match start_replica_append_with_retry(inner, &job, len_u32).await {
+            Ok(resp) => resp,
+            Err(err) => {
                 tracing::warn!(
-                    "replica task transfer failed: key={} put_id=({},{}) err={}",
+                    "replica append task start failed: key={} put_id=({},{}) err={}",
                     job.key,
                     job.put_id.0,
                     job.put_id.1,
                     err
                 );
-                spawn_replica_task_revoke(view_task.clone(), job.key, job.put_id, "transfer error");
-                continue;
+                return;
             }
-            match inner.put_append_done(&job.key, job.put_id).await {
-                Ok(resp) => {
-                    tracing::debug!(
-                        "replica task append done: key={} put_id=({},{}) appended={}",
-                        job.key,
-                        job.put_id.0,
-                        job.put_id.1,
-                        resp.appended
-                    );
+        };
+        if !append_start.scheduled {
+            tracing::debug!(
+                "replica append task not scheduled: key={} put_id=({},{})",
+                job.key,
+                job.put_id.0,
+                job.put_id.1
+            );
+            if let Some(guard) = job.hot_replica_guard.as_ref() {
+                guard.mark_already_satisfied();
+            }
+            return;
+        }
+        ReplicaTaskTarget {
+            node_id: append_start.node_id,
+            target_offset: append_start.target_addr - append_start.target_base_addr,
+            target_base_addr: append_start.target_base_addr,
+            len: append_start.len,
+        }
+    };
+    if len != target.len {
+        tracing::warn!(
+            "replica task length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
+            job.key,
+            job.put_id.0,
+            job.put_id.1,
+            len,
+            target.len
+        );
+        spawn_replica_task_revoke(view_task.clone(), job.key, job.put_id, "length mismatch");
+        return;
+    }
+    if let Err(err) = inner
+        .put_transfer(
+            &job.key,
+            job.put_id,
+            src_offset,
+            target.target_offset,
+            len,
+            Some(target.node_id.clone()),
+            Some(target.target_base_addr),
+        )
+        .await
+    {
+        tracing::warn!(
+            "replica task transfer failed: key={} put_id=({},{}) err={}",
+            job.key,
+            job.put_id.0,
+            job.put_id.1,
+            err
+        );
+        spawn_replica_task_revoke(view_task.clone(), job.key, job.put_id, "transfer error");
+        return;
+    }
+    // Append-done may reclaim the source synchronously. Release the transfer-only holder first so
+    // this task does not make its own reclaim look busy.
+    drop(job.holder);
+    match inner.put_append_done(&job.key, job.put_id).await {
+        Ok(resp) => {
+            tracing::debug!(
+                "replica task append done: key={} put_id=({},{}) appended={}",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                resp.appended
+            );
+            if let Some(guard) = job.hot_replica_guard.as_ref() {
+                if resp.appended {
+                    guard.mark_completed();
+                } else {
+                    guard.mark_already_satisfied();
+                }
+            }
+        }
+        Err(err) => {
+            tracing::warn!(
+                "replica task append done failed: key={} put_id=({},{}) err={}",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                err
+            );
+        }
+    }
+}
+
+pub fn spawn_replica_task_actor(
+    view: ClientKvApiView,
+    mut rx: tokio::sync::ampsc::Receiver<ReplicaTaskJob>,
+    max_inflight: usize,
+) {
+    let view_task = view.clone();
+    let _ = view.spawn("replica_task_actor", async move {
+        let max_inflight = max_inflight.max(1);
+        let semaphore = Arc::new(::tokio::sync::Semaphore::new(max_inflight));
+        let per_key = Arc::new(SemaphoreMap::new(1, Duration::from_secs(10 * 60)));
+        tracing::info!(
+            max_inflight,
+            "replica task actor started with bounded cross-key concurrency"
+        );
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        loop {
+            let job = tokio::select! {
+                _ = shutdown_waiter.wait() => {
+                    tracing::info!("replica_task_actor stopping due to shutdown signal");
+                    break;
                 }
+                job = rx.recv() => {
+                    match job {
+                        Some(job) => job,
+                        None => break,
+                    }
+                }
+            };
+            let permit = match semaphore.clone().acquire_owned().await {
+                Ok(permit) => permit,
                 Err(err) => {
                     tracing::warn!(
-                        "replica task append done failed: key={} put_id=({},{}) err={}",
-                        job.key,
-                        job.put_id.0,
-                        job.put_id.1,
+                        "replica task actor semaphore closed; dropping queued work: err={}",
                         err
                     );
+                    break;
                 }
-            }
+            };
+            let spawn_view = view_task.clone();
+            let worker_view = view_task.clone();
+            let worker_per_key = per_key.clone();
+            spawn_view.spawn("replica_task_worker", async move {
+                let _permit = permit;
+                let _key_permit = worker_per_key.acquire(job.key.clone()).await;
+                process_replica_task(worker_view, job).await;
+            });
         }
     });
 }
 
+pub async fn handle_batch_enqueue_replica_tasks(
+    view: &ClientKvApiView,
+    req: MsgPack<BatchEnqueueReplicaTaskReq>,
+) -> MsgPack<BatchEnqueueReplicaTaskResp> {
+    let inner = view.client_kv_api().inner();
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        let accepted = match inner
+            .make_replica_append_task(&item.key, item.put_id, None, false)
+            .await
+        {
+            Ok(accepted) => accepted,
+            Err(err) => {
+                tracing::warn!(
+                    "tier1 write-back enqueue failed: key={} put_id=({},{}) err={}",
+                    item.key,
+                    item.put_id.0,
+                    item.put_id.1,
+                    err
+                );
+                false
+            }
+        };
+        items.push(EnqueueReplicaTaskItemResp {
+            key: item.key,
+            put_id: item.put_id,
+            accepted,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchEnqueueReplicaTaskResp {
+            items,
+            error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
 pub fn spawn_owner_local_publish_dispatcher(
     view: ClientKvApiView,
     mut rx: tokio::sync::ampsc::Receiver<OwnerLocalPublishJob>,
@@ -2251,6 +2926,42 @@ pub fn spawn_owner_local_publish_dispatcher(
     });
 }
 
+/// Returns the linear group partition only when every multi-key group is present,
+/// contiguous, and in the caller-declared member order. A partial batch must use
+/// the legacy per-item descriptors so the V2 wire format never changes semantics.
+fn complete_owner_local_publish_group_lens(items: &[OwnerLocalPublishItem]) -> Option<Vec<usize>> {
+    let mut offset = 0usize;
+    let mut group_lens = Vec::new();
+    while offset < items.len() {
+        let item = &items[offset];
+        let Some(group) = item.atomic_group.as_ref() else {
+            group_lens.push(1);
+            offset += 1;
+            continue;
+        };
+        let group_len = group.members.len();
+        if group_len < 2 {
+            return None;
+        }
+        let end = offset.checked_add(group_len)?;
+        let group_items = items.get(offset..end)?;
+        if group_items
+            .iter()
+            .zip(group.members.iter())
+            .any(|(group_item, member)| {
+                group_item.key != member.key
+                    || group_item.put_id != member.put_id
+                    || group_item.atomic_group.as_ref() != Some(group)
+            })
+        {
+            return None;
+        }
+        group_lens.push(group_len);
+        offset = end;
+    }
+    Some(group_lens)
+}
+
 async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJob) {
     let inner = view.client_kv_api().inner();
     if job.items.is_empty() {
@@ -2258,21 +2969,58 @@ async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJo
         return;
     }
 
-    let done_req_items = job
-        .items
-        .iter()
-        .map(|item| BatchPutDoneItemReq {
-            key: item.key.clone(),
-            put_id: item.put_id,
-            lease_id: item.lease_id,
-            committed_slot: Some(item.committed_slot.clone()),
-            publish_local_cache: false,
-        })
-        .collect::<Vec<_>>();
+    let group_lens = complete_owner_local_publish_group_lens(&job.items);
+    let done_items = if let Some(atomic_group_lens) = group_lens {
+        inner
+            .owner_hot_counters
+            .grouped_put_done_batches
+            .fetch_add(1, Ordering::Relaxed);
+        inner
+            .owner_hot_counters
+            .grouped_put_done_items
+            .fetch_add(job.items.len() as u64, Ordering::Relaxed);
+        let items = job
+            .items
+            .iter()
+            .map(|item| GroupedBatchPutDoneItemReq {
+                key: item.key.clone(),
+                put_id: item.put_id,
+                lease_id: item.lease_id,
+                committed_slot: Some(item.committed_slot.clone()),
+                publish_local_cache: false,
+            })
+            .collect::<Vec<_>>();
+        inner
+            .grouped_batch_put_done(items, atomic_group_lens)
+            .await
+            .map(|resp| resp.items)
+    } else {
+        inner
+            .owner_hot_counters
+            .legacy_put_done_batches
+            .fetch_add(1, Ordering::Relaxed);
+        inner
+            .owner_hot_counters
+            .legacy_put_done_items
+            .fetch_add(job.items.len() as u64, Ordering::Relaxed);
+        let items = job
+            .items
+            .iter()
+            .map(|item| BatchPutDoneItemReq {
+                key: item.key.clone(),
+                put_id: item.put_id,
+                lease_id: item.lease_id,
+                committed_slot: Some(item.committed_slot.clone()),
+                publish_local_cache: false,
+                atomic_group: item.atomic_group.clone(),
+            })
+            .collect::<Vec<_>>();
+        inner.batch_put_done(items).await.map(|resp| resp.items)
+    };
 
-    match inner.batch_put_done(done_req_items).await {
-        Ok(done_resp) if done_resp.items.len() == job.items.len() => {
-            for (item, done_item) in job.items.iter().zip(done_resp.items.into_iter()) {
+    match done_items {
+        Ok(done_items) if done_items.len() == job.items.len() => {
+            for (item, done_item) in job.items.iter().zip(done_items.into_iter()) {
                 if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                     done_item.error_code,
                     done_item.error_json.clone(),
@@ -2292,6 +3040,7 @@ async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJo
                             &item.key,
                             item.put_id,
                             item.preferred_sub_cluster.clone(),
+                            true,
                         )
                         .await
                     {
@@ -2306,11 +3055,11 @@ async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJo
                 }
             }
         }
-        Ok(done_resp) => {
+        Ok(done_items) => {
             tracing::warn!(
                 "owner local publish response length mismatch: expected={} got={}",
                 job.items.len(),
-                done_resp.items.len()
+                done_items.len()
             );
         }
         Err(err) => {
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
new file mode 100644
index 0000000..2c33a58
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
@@ -0,0 +1,429 @@
+use super::{ClientKvApiInner, ClientKvApiView, OwnerPreparedReclaim, OwnerReclaimRecord};
+use crate::cluster_manager::{NodeID, NodeRole};
+use crate::master_kv_router::msg_pack::{
+    BatchOwnerReclaimReq, BatchOwnerReclaimResp, OwnerReclaimBacking, OwnerReclaimItem,
+    OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase,
+};
+use crate::p2p::msg_pack::MsgPack;
+use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
+use std::{collections::HashMap, sync::Arc};
+
+fn item_resp(
+    item: &OwnerReclaimItem,
+    state: OwnerReclaimItemState,
+    detail: impl Into<String>,
+) -> OwnerReclaimItemResp {
+    OwnerReclaimItemResp {
+        key: item.key.clone(),
+        epoch: item.epoch,
+        state,
+        detail: detail.into(),
+    }
+}
+
+fn record_item(record: &OwnerReclaimRecord) -> &OwnerReclaimItem {
+    match record {
+        OwnerReclaimRecord::Prepared(prepared) => &prepared.item,
+        OwnerReclaimRecord::Committed(item) => item,
+    }
+}
+
+fn memory_matches_reclaim_backing(
+    memory_info: &crate::memholder::MemoryInfo,
+    backing: &OwnerReclaimBacking,
+) -> bool {
+    match backing {
+        OwnerReclaimBacking::Allocation => memory_info.local_reserve_resident_slot_ref().is_none(),
+        OwnerReclaimBacking::UnindexedAllocation => false,
+        OwnerReclaimBacking::CommittedSlot {
+            grant_id,
+            slot_index,
+            slot_size,
+        } => memory_info.local_reserve_resident_slot_ref().is_some_and(
+            |(actual_slot_size, actual_grant_id, actual_slot_index)| {
+                actual_slot_size == *slot_size
+                    && actual_grant_id == *grant_id
+                    && actual_slot_index == *slot_index
+            },
+        ),
+    }
+}
+
+fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
+    let mut controls = inner.owner_key_control.lock();
+    if let Some(state) = controls.get(&item.key) {
+        if state.local_puts != 0 {
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner local put is inflight",
+            );
+        }
+        if let Some(record) = state.reclaim.as_ref() {
+            if record_item(record) == item {
+                return item_resp(
+                    item,
+                    match record {
+                        OwnerReclaimRecord::Prepared(_) => OwnerReclaimItemState::Prepared,
+                        OwnerReclaimRecord::Committed(_) => OwnerReclaimItemState::Committed,
+                    },
+                    "reclaim phase already applied",
+                );
+            }
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "another reclaim epoch owns the key fence",
+            );
+        }
+    }
+    if inner.precommit_local_visible_info.contains_key(&item.key) {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Busy,
+            "owner precommit local index is still visible",
+        );
+    }
+    if inner
+        .external_pending_puts
+        .iter()
+        .any(|(pending_key, _)| pending_key.0 == item.key)
+    {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Busy,
+            "owner external put context is still pending",
+        );
+    }
+
+    let Some((_key, cached_info)) = inner.get_cached_info.remove_if(&item.key, |_, cached| {
+        cached.put_time_ms == item.put_id.0
+            && cached.put_version == item.put_id.1
+            && memory_matches_reclaim_backing(cached.mem_holder.as_ref(), &item.backing)
+    }) else {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Stale,
+            "matching local backing index is absent",
+        );
+    };
+
+    // The index entry is now hidden while the same control lock keeps all new local readers out.
+    // Any reader that cloned the memory just before the fence is visible in the Arc count.
+    if Arc::strong_count(&cached_info.mem_holder) != 1 {
+        let replaced = inner.get_cached_info.insert(item.key.clone(), cached_info);
+        assert!(
+            replaced.is_none(),
+            "owner reclaim rollback must restore an empty local index slot"
+        );
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Busy,
+            "owner local memory still has active holders",
+        );
+    }
+
+    let local_snapshot = inner
+        .local_snapshot_info
+        .remove_if(&item.key, |_, snapshot| {
+            snapshot.put_time_ms == item.put_id.0 && snapshot.put_version == item.put_id.1
+        })
+        .map(|(_, snapshot)| snapshot);
+    let state = controls.entry(item.key.clone()).or_default();
+    assert!(state.reclaim.is_none() && state.local_puts == 0);
+    state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
+        item: item.clone(),
+        cached_info,
+        local_snapshot,
+    }));
+    item_resp(
+        item,
+        OwnerReclaimItemState::Prepared,
+        "owner local index fenced",
+    )
+}
+
+fn release_prepared_backing_now(inner: &ClientKvApiInner, prepared: OwnerPreparedReclaim) {
+    let mut memory_info = Arc::try_unwrap(prepared.cached_info.mem_holder).unwrap_or_else(|_| {
+        panic!(
+            "owner reclaim prepared memory unexpectedly gained a holder: key={} epoch={}",
+            prepared.item.key, prepared.item.epoch
+        )
+    });
+    match &prepared.item.backing {
+        OwnerReclaimBacking::Allocation => {
+            assert!(
+                memory_info.local_reserve_resident_slot_ref().is_none(),
+                "allocation reclaim must not carry a local-reserve slot"
+            );
+        }
+        OwnerReclaimBacking::UnindexedAllocation => {
+            unreachable!("unindexed allocations must be reclaimed entirely on the master")
+        }
+        OwnerReclaimBacking::CommittedSlot {
+            grant_id,
+            slot_index,
+            slot_size,
+        } => {
+            let (actual_slot_size, actual_grant_id, actual_slot_index) = memory_info
+                .take_local_reserve_resident_slot_ref()
+                .expect("committed-slot reclaim must carry a local-reserve slot");
+            assert_eq!(actual_slot_size, *slot_size);
+            assert_eq!(actual_grant_id, *grant_id);
+            assert_eq!(actual_slot_index, *slot_index);
+
+            inner
+                .owner_release_local_reserve_committed_slot_route(
+                    actual_slot_size,
+                    actual_grant_id,
+                    actual_slot_index,
+                )
+                .expect("owner reclaim committed route release must succeed");
+            inner
+                .owner_release_local_reserve_resident_slot_holder(
+                    actual_slot_size,
+                    actual_grant_id,
+                    actual_slot_index,
+                )
+                .expect("owner reclaim resident holder release must succeed");
+        }
+    }
+    drop(memory_info);
+}
+
+fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
+    let mut controls = inner.owner_key_control.lock();
+    let Some(state) = controls.get_mut(&item.key) else {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Stale,
+            "owner reclaim fence is absent",
+        );
+    };
+    let Some(record) = state.reclaim.take() else {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Stale,
+            "owner reclaim fence is absent",
+        );
+    };
+    let prepared = match record {
+        OwnerReclaimRecord::Prepared(prepared) if prepared.item == *item => prepared,
+        OwnerReclaimRecord::Committed(committed) if committed == *item => {
+            state.reclaim = Some(OwnerReclaimRecord::Committed(committed));
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Committed,
+                "owner reclaim commit already applied",
+            );
+        }
+        other => {
+            state.reclaim = Some(other);
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Stale,
+                "owner reclaim epoch or slot identity changed",
+            );
+        }
+    };
+
+    // Keep the owner fence installed by holding the control lock until the slot is fully free.
+    release_prepared_backing_now(inner, prepared);
+    assert!(state.reclaim.is_none() && state.local_puts == 0);
+    state.reclaim = Some(OwnerReclaimRecord::Committed(item.clone()));
+    drop(controls);
+    inner.owner_hot_invalidate_version(&item.key, item.put_id);
+    item_resp(
+        item,
+        OwnerReclaimItemState::Committed,
+        "owner committed slot released",
+    )
+}
+
+fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
+    let mut controls = inner.owner_key_control.lock();
+    let Some(state) = controls.get_mut(&item.key) else {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Aborted,
+            "owner reclaim was already absent",
+        );
+    };
+    let Some(record) = state.reclaim.take() else {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Aborted,
+            "owner reclaim was already absent",
+        );
+    };
+    match record {
+        OwnerReclaimRecord::Prepared(prepared) if prepared.item == *item => {
+            let replaced = inner
+                .get_cached_info
+                .insert(item.key.clone(), prepared.cached_info);
+            assert!(
+                replaced.is_none(),
+                "owner reclaim abort must restore an empty local index slot"
+            );
+            if let Some(snapshot) = prepared.local_snapshot {
+                let replaced = inner.local_snapshot_info.insert(item.key.clone(), snapshot);
+                assert!(
+                    replaced.is_none(),
+                    "owner reclaim abort must restore an empty local snapshot slot"
+                );
+            }
+            if state.local_puts == 0 {
+                controls.remove(&item.key);
+            }
+            item_resp(
+                item,
+                OwnerReclaimItemState::Aborted,
+                "owner local index fence rolled back",
+            )
+        }
+        OwnerReclaimRecord::Committed(committed) if committed == *item => {
+            state.reclaim = Some(OwnerReclaimRecord::Committed(committed));
+            item_resp(
+                item,
+                OwnerReclaimItemState::Committed,
+                "owner slot was already committed and cannot be restored",
+            )
+        }
+        other => {
+            state.reclaim = Some(other);
+            item_resp(
+                item,
+                OwnerReclaimItemState::Stale,
+                "owner reclaim epoch or slot identity changed",
+            )
+        }
+    }
+}
+
+fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
+    let mut controls = inner.owner_key_control.lock();
+    let Some(state) = controls.get_mut(&item.key) else {
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Finalized,
+            "owner reclaim was already finalized",
+        );
+    };
+    match state.reclaim.take() {
+        Some(OwnerReclaimRecord::Committed(committed)) if committed == *item => {
+            if state.local_puts == 0 {
+                controls.remove(&item.key);
+            }
+            item_resp(
+                item,
+                OwnerReclaimItemState::Finalized,
+                "owner reclaim fence cleared",
+            )
+        }
+        Some(other) => {
+            state.reclaim = Some(other);
+            item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner reclaim is not committed for this epoch",
+            )
+        }
+        None => item_resp(
+            item,
+            OwnerReclaimItemState::Finalized,
+            "owner reclaim was already finalized",
+        ),
+    }
+}
+
+pub async fn handle_batch_owner_reclaim(
+    view: &ClientKvApiView,
+    req: MsgPack<BatchOwnerReclaimReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchOwnerReclaimResp> {
+    let requester_is_master = view
+        .cluster_manager()
+        .get_member_info_cached(req_node_id.as_ref())
+        .is_some_and(|member| matches!(member.node_role(), NodeRole::Master));
+    if !requester_is_master {
+        let err = KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "batch owner reclaim requester is not the current master: requester={}",
+                req_node_id
+            ),
+        });
+        return MsgPack {
+            serialize_part: BatchOwnerReclaimResp {
+                items: Vec::new(),
+                error_code: err.code(),
+                error_json: err.to_json(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+    let inner = view.client_kv_api().inner();
+    let phase = req.serialize_part.phase;
+    let items = req
+        .serialize_part
+        .items
+        .iter()
+        .map(|item| match phase {
+            OwnerReclaimPhase::Prepare => prepare_one(inner, item),
+            OwnerReclaimPhase::Commit => commit_one(inner, item),
+            OwnerReclaimPhase::Abort => abort_one(inner, item),
+            OwnerReclaimPhase::Finalize => finalize_one(inner, item),
+        })
+        .collect::<Vec<_>>();
+    let prepared = items
+        .iter()
+        .filter(|item| item.state == OwnerReclaimItemState::Prepared)
+        .count();
+    let committed = items
+        .iter()
+        .filter(|item| item.state == OwnerReclaimItemState::Committed)
+        .count();
+    let finalized = items
+        .iter()
+        .filter(|item| item.state == OwnerReclaimItemState::Finalized)
+        .count();
+    let busy_or_stale = items
+        .iter()
+        .filter(|item| {
+            matches!(
+                item.state,
+                OwnerReclaimItemState::Busy | OwnerReclaimItemState::Stale
+            )
+        })
+        .count();
+    let mut rejection_reason_counts = HashMap::<String, usize>::new();
+    for item in &items {
+        if matches!(
+            item.state,
+            OwnerReclaimItemState::Busy | OwnerReclaimItemState::Stale
+        ) {
+            *rejection_reason_counts
+                .entry(item.detail.clone())
+                .or_default() += 1;
+        }
+    }
+    let mut rejection_reason_counts = rejection_reason_counts.into_iter().collect::<Vec<_>>();
+    rejection_reason_counts.sort_by(|a, b| a.0.cmp(&b.0));
+    tracing::info!(
+        "owner reclaim phase completed: phase={:?} items={} prepared={} committed={} finalized={} busy_or_stale={} rejection_reasons={:?}",
+        phase,
+        items.len(),
+        prepared,
+        committed,
+        finalized,
+        busy_or_stale,
+        rejection_reason_counts
+    );
+    MsgPack {
+        serialize_part: BatchOwnerReclaimResp {
+            items,
+            error_code: OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/config.rs b/fluxon_rs/fluxon_kv/src/config.rs
index bf676ee..8e88dc5 100644
--- a/fluxon_rs/fluxon_kv/src/config.rs
+++ b/fluxon_rs/fluxon_kv/src/config.rs
@@ -97,12 +97,21 @@ pub enum SideTransferRole {
     Worker,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct OwnerLocalReserveExpectedCapacity {
+    pub value_len: u64,
+    pub payload_capacity_bytes: u64,
+}
+
 const TEST_SPEC_TCP_THREAD_REACTOR_SHARD_COUNT_MIN: u8 = 1;
 const TEST_SPEC_TCP_THREAD_REACTOR_SHARD_COUNT_MAX: u8 = 16;
 const TEST_SPEC_TCP_THREAD_BULK_LANE_COUNT_MIN: u8 = 1;
 const TEST_SPEC_TCP_THREAD_BULK_LANE_COUNT_MAX: u8 = 8;
 const TEST_SPEC_TCP_THREAD_CONTROL_LANE_COUNT_MIN: u8 = 1;
 const TEST_SPEC_TCP_THREAD_CONTROL_LANE_COUNT_MAX: u8 = 8;
+const TEST_SPEC_REPLICA_TASK_MAX_INFLIGHT_MIN: u16 = 1;
+const TEST_SPEC_REPLICA_TASK_MAX_INFLIGHT_MAX: u16 = 64;
 
 fn default_iceoryx_owner_client_busy_poll() -> bool {
     true
@@ -137,6 +146,8 @@ pub struct TestSpecConfig {
     pub owner_local_reserve_soft_wait_timeout_ms: Option<u64>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub owner_local_reserve_hard_timeout_ms: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner_local_reserve_expected_capacity: Option<OwnerLocalReserveExpectedCapacity>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transport_mode: Option<TestSpecTransportMode>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -147,6 +158,10 @@ pub struct TestSpecConfig {
     pub tcp_thread_control_lane_count: Option<u8>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub user_rpc_sync_handler_thread_count: Option<u16>,
+    /// Maximum number of replica append pipelines in flight on an owner. Different keys may run
+    /// concurrently; each key remains strictly serialized by the replica dispatcher.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub replica_task_max_inflight: Option<u16>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub rdma_device_names: Option<Vec<String>>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -177,11 +192,13 @@ impl Default for TestSpecConfig {
             skip_put_end_commit: false,
             owner_local_reserve_soft_wait_timeout_ms: None,
             owner_local_reserve_hard_timeout_ms: None,
+            owner_local_reserve_expected_capacity: None,
             transport_mode: None,
             tcp_thread_reactor_shard_count: None,
             tcp_thread_bulk_lane_count: None,
             tcp_thread_control_lane_count: None,
             user_rpc_sync_handler_thread_count: None,
+            replica_task_max_inflight: None,
             rdma_device_names: None,
             require_transfer_rpc_fast_path_ready_timeout_seconds: None,
             enable_side_transfer: false,
@@ -304,10 +321,12 @@ fn validate_required_transfer_rpc_fast_path_ready_timeout(
 }
 
 fn validate_owner_local_reserve_timeouts(test_spec_config: &TestSpecConfig) -> KvResult<()> {
-    let Some(soft_wait_timeout_ms) = test_spec_config.owner_local_reserve_soft_wait_timeout_ms
-    else {
-        return Ok(());
-    };
+    let soft_wait_timeout_ms = test_spec_config
+        .owner_local_reserve_soft_wait_timeout_ms
+        .unwrap_or(10);
+    let hard_timeout_ms = test_spec_config
+        .owner_local_reserve_hard_timeout_ms
+        .unwrap_or(10_000);
     if soft_wait_timeout_ms == 0 {
         return Err(ConfigError::InvalidClientConfig {
             detail: "test_spec_config.owner_local_reserve_soft_wait_timeout_ms must be > 0"
@@ -315,26 +334,60 @@ fn validate_owner_local_reserve_timeouts(test_spec_config: &TestSpecConfig) -> K
         }
         .into_kverror());
     }
-
-    if let Some(hard_timeout_ms) = test_spec_config.owner_local_reserve_hard_timeout_ms {
-        if hard_timeout_ms == 0 {
-            return Err(ConfigError::InvalidClientConfig {
-                detail: "test_spec_config.owner_local_reserve_hard_timeout_ms must be > 0"
-                    .to_string(),
-            }
-            .into_kverror());
+    if hard_timeout_ms == 0 {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: "test_spec_config.owner_local_reserve_hard_timeout_ms must be > 0".to_string(),
         }
-        if hard_timeout_ms <= soft_wait_timeout_ms {
-            return Err(ConfigError::InvalidClientConfig {
-                detail: "test_spec_config.owner_local_reserve_hard_timeout_ms must be greater than owner_local_reserve_soft_wait_timeout_ms".to_string(),
-            }
-            .into_kverror());
+        .into_kverror());
+    }
+    if hard_timeout_ms <= soft_wait_timeout_ms {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: "test_spec_config.owner_local_reserve_hard_timeout_ms must be greater than owner_local_reserve_soft_wait_timeout_ms".to_string(),
         }
+        .into_kverror());
     }
 
     Ok(())
 }
 
+fn validate_owner_local_reserve_expected_capacity(
+    test_spec_config: &TestSpecConfig,
+) -> KvResult<()> {
+    let Some(expected) = &test_spec_config.owner_local_reserve_expected_capacity else {
+        return Ok(());
+    };
+    if expected.value_len == 0 {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: "test_spec_config.owner_local_reserve_expected_capacity.value_len must be > 0"
+                .to_string(),
+        }
+        .into_kverror());
+    }
+    if expected.payload_capacity_bytes == 0 {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: "test_spec_config.owner_local_reserve_expected_capacity.payload_capacity_bytes must be > 0"
+                .to_string(),
+        }
+        .into_kverror());
+    }
+    if crate::owner_local_reserve_expected_grant_count(
+        expected.value_len,
+        expected.payload_capacity_bytes,
+    )
+    .is_none()
+    {
+        return Err(ConfigError::InvalidClientConfig {
+            detail: format!(
+                "test_spec_config.owner_local_reserve_expected_capacity.value_len={} cannot be represented by a local-reserve slot no larger than {} bytes",
+                expected.value_len,
+                crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES
+            ),
+        }
+        .into_kverror());
+    }
+    Ok(())
+}
+
 fn apply_test_spec_rdma_device_names_to_protocol(
     mut protocol: ProtocolConfig,
     normalized_rdma_device_names: Option<&Vec<String>>,
@@ -391,6 +444,21 @@ fn validate_test_spec_tcp_thread_tuning(test_spec_config: &TestSpecConfig) -> Kv
             .into_kverror());
         }
     }
+    if let Some(value) = test_spec_config.replica_task_max_inflight {
+        if !(TEST_SPEC_REPLICA_TASK_MAX_INFLIGHT_MIN..=TEST_SPEC_REPLICA_TASK_MAX_INFLIGHT_MAX)
+            .contains(&value)
+        {
+            return Err(ConfigError::InvalidTestConfig {
+                detail: format!(
+                    "test_spec_config.replica_task_max_inflight must be in [{}, {}], got {}",
+                    TEST_SPEC_REPLICA_TASK_MAX_INFLIGHT_MIN,
+                    TEST_SPEC_REPLICA_TASK_MAX_INFLIGHT_MAX,
+                    value
+                ),
+            }
+            .into_kverror());
+        }
+    }
     Ok(())
 }
 
@@ -482,6 +550,11 @@ pub const DEFAULT_OTLP_LOG_TABLE_NAME: &str = "fluxon_logs";
 pub const DEFAULT_OTLP_LOG_FLUSH_INTERVAL_MS: u64 = 2000;
 pub const DEFAULT_OTLP_LOG_MAX_BATCH_LINES: usize = 2000;
 pub const DEFAULT_OTLP_LOG_MAX_QUEUE_LINES: usize = 20000;
+pub const DEFAULT_REPLICA_CACHE_CAPACITY_RATIO: f64 = 0.95;
+
+fn default_replica_cache_capacity_ratio() -> f64 {
+    DEFAULT_REPLICA_CACHE_CAPACITY_RATIO
+}
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
@@ -767,6 +840,12 @@ pub struct MasterConfigYaml {
     pub master_ui: Option<MasterUiConfigYaml>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub replica_task_placement: Option<ReplicaTaskPlacementConfigYaml>,
+    #[serde(default = "default_replica_cache_capacity_ratio")]
+    pub replica_cache_capacity_ratio: f64,
+    /// Optional inclusive hot-tier capacity. Entries evicted from this tier remain in the
+    /// resident replica cache and are proactively copied to a remote-only owner.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub replica_writeback_tier1_capacity_ratio: Option<f64>,
     #[serde(default)]
     pub test_spec_config: TestSpecConfig,
 }
@@ -787,6 +866,8 @@ pub struct MasterConfig {
     pub log_dir: String,
     pub master_ui: Option<MasterUiConfig>,
     pub replica_task_placement: ReplicaTaskPlacementConfig,
+    pub replica_cache_capacity_ratio: f64,
+    pub replica_writeback_tier1_capacity_ratio: Option<f64>,
     pub test_spec_config: TestSpecConfig,
 }
 
@@ -837,6 +918,10 @@ pub struct ClientConfigYaml {
     pub contribute_to_cluster_pool_size: Option<ContributeToClusterPoolSizeYaml>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub pprof_duration_seconds: Option<u64>,
+    /// Optional owner-local hot working-set threshold. Size eviction from this
+    /// logical tier schedules an asynchronous remote replica write-back.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub replica_writeback_hot_capacity_ratio: Option<f64>,
     pub fluxonkv_spec: FluxonKvSpecYaml,
     #[serde(default)]
     pub test_spec_config: TestSpecConfig,
@@ -959,6 +1044,7 @@ pub struct ClientConfig {
     pub contribute_to_cluster_pool_size: ContributeToClusterPoolSize,
     pub protocol: ProtocolConfig,
     pub pprof_duration_seconds: Option<u64>,
+    pub replica_writeback_hot_capacity_ratio: Option<f64>,
     pub redis_compat_listen_addr: Option<std::net::SocketAddr>,
     pub fluxonkv_spec: FluxonKvSpec,
     pub share_mem_path: String,           // Mandatory shared bundle path
@@ -1142,6 +1228,7 @@ impl ClientConfigYaml {
         materialize_default_test_spec_transport_mode(&mut test_spec_config);
         validate_required_transfer_rpc_fast_path_ready_timeout(&test_spec_config)?;
         validate_owner_local_reserve_timeouts(&test_spec_config)?;
+        validate_owner_local_reserve_expected_capacity(&test_spec_config)?;
         validate_test_spec_tcp_thread_tuning(&test_spec_config)?;
 
         // Role selection contract:
@@ -1204,6 +1291,58 @@ impl ClientConfigYaml {
             }
         }
 
+        if let Some(hot_ratio) = self.replica_writeback_hot_capacity_ratio {
+            if !hot_ratio.is_finite() || hot_ratio <= 0.0 || hot_ratio >= 1.0 {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "replica_writeback_hot_capacity_ratio must be finite and in (0, 1)"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
+            if is_external {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "replica_writeback_hot_capacity_ratio is only valid on owner configs"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
+        }
+
+        if let Some(expected) = &test_spec_config.owner_local_reserve_expected_capacity {
+            if is_external {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "test_spec_config.owner_local_reserve_expected_capacity is only valid on owner configs"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
+            let expected_grants = crate::owner_local_reserve_expected_grant_count(
+                expected.value_len,
+                expected.payload_capacity_bytes,
+            )
+            .expect("owner local-reserve expected capacity was validated");
+            let physical_reserve_bytes = expected_grants
+                .checked_mul(crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES)
+                .ok_or_else(|| {
+                    ConfigError::InvalidClientConfig {
+                        detail: "test_spec_config.owner_local_reserve_expected_capacity physical reserve size overflows u64"
+                            .to_string(),
+                    }
+                    .into_kverror()
+                })?;
+            if physical_reserve_bytes > contribute_to_cluster_pool_size.dram {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: format!(
+                        "test_spec_config.owner_local_reserve_expected_capacity requires {} physical bytes across {} grants, exceeding owner dram contribution {}",
+                        physical_reserve_bytes,
+                        expected_grants,
+                        contribute_to_cluster_pool_size.dram
+                    ),
+                }
+                .into_kverror());
+            }
+        }
+
         let is_side_transfer_worker = matches!(
             test_spec_config.side_transfer_role,
             Some(SideTransferRole::Worker)
@@ -1442,6 +1581,7 @@ impl ClientConfigYaml {
             contribute_to_cluster_pool_size,
             protocol,
             pprof_duration_seconds,
+            replica_writeback_hot_capacity_ratio: self.replica_writeback_hot_capacity_ratio,
             redis_compat_listen_addr,
             fluxonkv_spec,
             share_mem_path,
@@ -1725,6 +1865,36 @@ impl MasterConfigYaml {
             Some(cfg) => cfg.verify()?,
             None => ReplicaTaskPlacementConfig::default(),
         };
+        if !self.replica_cache_capacity_ratio.is_finite()
+            || self.replica_cache_capacity_ratio <= 0.0
+            || self.replica_cache_capacity_ratio > 1.0
+        {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: "replica_cache_capacity_ratio must be finite and in (0, 1]".to_string(),
+            }
+            .into_kverror());
+        }
+        if let Some(tier1_ratio) = self.replica_writeback_tier1_capacity_ratio {
+            if !tier1_ratio.is_finite()
+                || tier1_ratio <= 0.0
+                || tier1_ratio >= self.replica_cache_capacity_ratio
+            {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: format!(
+                        "replica_writeback_tier1_capacity_ratio must be finite, positive, and smaller than replica_cache_capacity_ratio ({})",
+                        self.replica_cache_capacity_ratio
+                    ),
+                }
+                .into_kverror());
+            }
+            if !replica_task_placement.restrict_to_remote_only_node_roles {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "replica_writeback_tier1_capacity_ratio requires replica_task_placement.restrict_to_remote_only_node_roles=true"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
+        }
 
         let mut test_spec_config = self.test_spec_config;
         let transport_mode_was_explicit = test_spec_config.transport_mode.is_some();
@@ -1735,6 +1905,17 @@ impl MasterConfigYaml {
         materialize_default_test_spec_transport_mode(&mut test_spec_config);
         validate_required_transfer_rpc_fast_path_ready_timeout(&test_spec_config)?;
         validate_owner_local_reserve_timeouts(&test_spec_config)?;
+        validate_owner_local_reserve_expected_capacity(&test_spec_config)?;
+        if test_spec_config
+            .owner_local_reserve_expected_capacity
+            .is_some()
+        {
+            return Err(ConfigError::InvalidClientConfig {
+                detail: "test_spec_config.owner_local_reserve_expected_capacity is only valid on owner configs"
+                    .to_string(),
+            }
+            .into_kverror());
+        }
         validate_test_spec_tcp_thread_tuning(&test_spec_config)?;
         let protocol = apply_test_spec_rdma_device_names_to_protocol(
             self.protocol.unwrap_or(ProtocolConfig {
@@ -1763,6 +1944,8 @@ impl MasterConfigYaml {
             log_dir: self.log_dir,
             master_ui,
             replica_task_placement,
+            replica_cache_capacity_ratio: self.replica_cache_capacity_ratio,
+            replica_writeback_tier1_capacity_ratio: self.replica_writeback_tier1_capacity_ratio,
             test_spec_config,
         })
     }
@@ -1854,6 +2037,195 @@ fluxonkv_spec:
         assert!(verified.fluxonkv_spec.enable_transfer_rpc_fast_path);
     }
 
+    #[test]
+    fn owner_replica_writeback_hot_capacity_ratio_is_owner_only_and_bounded() {
+        let owner = r#"
+instance_key: test_owner
+contribute_to_cluster_pool_size:
+  dram: 16777216
+  vram: {}
+replica_writeback_hot_capacity_ratio: RATIO
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /tmp/test_owner_hot
+  large_file_paths: [/tmp/test_owner_hot_large]
+  sub_cluster: rack-a
+"#;
+        let verified = ClientConfigYaml::from_str(&owner.replace("RATIO", "0.75"))
+            .unwrap()
+            .verify()
+            .unwrap();
+        assert_eq!(verified.replica_writeback_hot_capacity_ratio, Some(0.75));
+
+        for invalid in ["0", "1", "-0.1", ".nan"] {
+            let err = ClientConfigYaml::from_str(&owner.replace("RATIO", invalid))
+                .unwrap()
+                .verify()
+                .unwrap_err();
+            assert!(
+                err.to_string()
+                    .contains("replica_writeback_hot_capacity_ratio")
+            );
+        }
+
+        let external = r#"
+instance_key: test_external
+replica_writeback_hot_capacity_ratio: 0.75
+fluxonkv_spec:
+  cluster_name: test_cluster
+  share_mem_path: /tmp/test_external_hot
+"#;
+        let err = ClientConfigYaml::from_str(external)
+            .unwrap()
+            .verify()
+            .unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("replica_writeback_hot_capacity_ratio is only valid on owner configs")
+        );
+    }
+
+    #[test]
+    fn owner_local_reserve_expected_capacity_accepts_exact_fit_payload_target() {
+        let cfg = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_owner
+contribute_to_cluster_pool_size:
+  dram: 137438953472
+  vram: {}
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /tmp/test_owner_expected
+  large_file_paths: [/tmp/test_owner_expected_large]
+  sub_cluster: rack-a
+test_spec_config:
+  owner_local_reserve_expected_capacity:
+    value_len: 4718592
+    payload_capacity_bytes: 109951162777
+"#,
+        )
+        .unwrap();
+        let verified = cfg.verify().unwrap();
+        let expected = verified
+            .test_spec_config
+            .owner_local_reserve_expected_capacity
+            .unwrap();
+        assert_eq!(expected.value_len, 4_718_592);
+        assert_eq!(expected.payload_capacity_bytes, 109_951_162_777);
+        assert_eq!(
+            crate::owner_local_reserve_expected_grant_count(
+                expected.value_len,
+                expected.payload_capacity_bytes,
+            ),
+            Some(207)
+        );
+    }
+
+    #[test]
+    fn owner_local_reserve_expected_capacity_rejects_zero_value_len() {
+        let cfg = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_owner
+contribute_to_cluster_pool_size:
+  dram: 1073741824
+  vram: {}
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /tmp/test_owner_expected_zero
+  large_file_paths: [/tmp/test_owner_expected_zero_large]
+  sub_cluster: rack-a
+test_spec_config:
+  owner_local_reserve_expected_capacity:
+    value_len: 0
+    payload_capacity_bytes: 4096
+"#,
+        )
+        .unwrap();
+        let err = cfg.verify().unwrap_err();
+        assert!(err.to_string().contains(
+            "test_spec_config.owner_local_reserve_expected_capacity.value_len must be > 0"
+        ));
+    }
+
+    #[test]
+    fn owner_local_reserve_expected_capacity_rejects_physical_target_over_owner_capacity() {
+        let cfg = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_owner
+contribute_to_cluster_pool_size:
+  dram: 16777216
+  vram: {}
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /tmp/test_owner_expected_too_large
+  large_file_paths: [/tmp/test_owner_expected_too_large_large]
+  sub_cluster: rack-a
+test_spec_config:
+  owner_local_reserve_expected_capacity:
+    value_len: 4096
+    payload_capacity_bytes: 4096
+"#,
+        )
+        .unwrap();
+        let err = cfg.verify().unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("exceeding owner dram contribution")
+        );
+    }
+
+    #[test]
+    fn owner_local_reserve_hard_timeout_is_validated_without_soft_override() {
+        let mut cfg = TestSpecConfig {
+            owner_local_reserve_hard_timeout_ms: Some(0),
+            ..Default::default()
+        };
+        assert!(
+            validate_owner_local_reserve_timeouts(&cfg)
+                .unwrap_err()
+                .to_string()
+                .contains("owner_local_reserve_hard_timeout_ms must be > 0")
+        );
+
+        cfg.owner_local_reserve_hard_timeout_ms = Some(5);
+        assert!(
+            validate_owner_local_reserve_timeouts(&cfg)
+                .unwrap_err()
+                .to_string()
+                .contains("must be greater than owner_local_reserve_soft_wait_timeout_ms")
+        );
+
+        cfg.owner_local_reserve_hard_timeout_ms = Some(20);
+        validate_owner_local_reserve_timeouts(&cfg).unwrap();
+    }
+
+    #[test]
+    fn replica_task_max_inflight_is_strictly_bounded() {
+        for value in [1, 16, 64] {
+            let cfg = TestSpecConfig {
+                replica_task_max_inflight: Some(value),
+                ..Default::default()
+            };
+            validate_test_spec_tcp_thread_tuning(&cfg).unwrap();
+        }
+        for value in [0, 65] {
+            let cfg = TestSpecConfig {
+                replica_task_max_inflight: Some(value),
+                ..Default::default()
+            };
+            assert!(
+                validate_test_spec_tcp_thread_tuning(&cfg)
+                    .unwrap_err()
+                    .to_string()
+                    .contains("replica_task_max_inflight must be in [1, 64]")
+            );
+        }
+    }
+
     #[test]
     fn client_config_zero_contribution_allows_owner_bootstrapped_large_file_paths() {
         let cfg = ClientConfigYaml::from_str(
@@ -2486,6 +2858,79 @@ replica_task_placement:
                 .restrict_to_remote_only_node_roles
         );
         assert_eq!(verified.replica_task_placement.role_queue_window_ms, 2.5);
+        assert_eq!(
+            verified.replica_cache_capacity_ratio,
+            DEFAULT_REPLICA_CACHE_CAPACITY_RATIO
+        );
+    }
+
+    #[test]
+    fn master_config_validates_replica_cache_capacity_ratio() {
+        let base = r#"
+instance_key: test_master
+cluster_name: test_cluster
+port: 18080
+etcd_endpoints: ["127.0.0.1:2379"]
+network:
+  subnet_whitelist: ["127.0.0.0/8"]
+monitoring:
+  prometheus_base_url: "http://127.0.0.1:4000/v1/prometheus"
+log_dir: /tmp/test_master_logs
+replica_cache_capacity_ratio: RATIO
+"#;
+
+        let valid = MasterConfigYaml::from_str(&base.replace("RATIO", "0.9"))
+            .unwrap()
+            .verify()
+            .unwrap();
+        assert_eq!(valid.replica_cache_capacity_ratio, 0.9);
+
+        for invalid in ["0", "-0.1", "1.01", ".nan"] {
+            let cfg = MasterConfigYaml::from_str(&base.replace("RATIO", invalid)).unwrap();
+            let err = cfg.verify().unwrap_err();
+            assert!(format!("{err}").contains("replica_cache_capacity_ratio"));
+        }
+    }
+
+    #[test]
+    fn master_config_validates_replica_writeback_tier1_capacity_ratio() {
+        let base = r#"
+instance_key: test_master
+cluster_name: test_cluster
+port: 18080
+etcd_endpoints: ["127.0.0.1:2379"]
+network:
+  subnet_whitelist: ["127.0.0.0/8"]
+monitoring:
+  prometheus_base_url: "http://127.0.0.1:4000/v1/prometheus"
+log_dir: /tmp/test_master_logs
+replica_cache_capacity_ratio: 0.95
+replica_writeback_tier1_capacity_ratio: RATIO
+"#;
+
+        let valid = MasterConfigYaml::from_str(&base.replace("RATIO", "0.75"))
+            .unwrap()
+            .verify()
+            .unwrap();
+        assert_eq!(valid.replica_writeback_tier1_capacity_ratio, Some(0.75));
+
+        for invalid in ["0", "-0.1", "0.95", "0.96", ".nan"] {
+            let cfg = MasterConfigYaml::from_str(&base.replace("RATIO", invalid)).unwrap();
+            let err = cfg.verify().unwrap_err();
+            assert!(format!("{err}").contains("replica_writeback_tier1_capacity_ratio"));
+        }
+
+        let unrestricted = base
+            .replace("RATIO", "0.75")
+            .replace(
+                "replica_cache_capacity_ratio: 0.95",
+                "replica_cache_capacity_ratio: 0.95\nreplica_task_placement:\n  restrict_to_remote_only_node_roles: false",
+            );
+        let err = MasterConfigYaml::from_str(&unrestricted)
+            .unwrap()
+            .verify()
+            .unwrap_err();
+        assert!(format!("{err}").contains("restrict_to_remote_only_node_roles=true"));
     }
 
     #[test]
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs b/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
index 1464285..ed9863e 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
@@ -48,6 +48,8 @@ fn new_master_config(
         pprof_duration_seconds: None,
         master_ui: None,
         replica_task_placement: ReplicaTaskPlacementConfig::default(),
+        replica_cache_capacity_ratio: crate::config::DEFAULT_REPLICA_CACHE_CAPACITY_RATIO,
+        replica_writeback_tier1_capacity_ratio: None,
         test_spec_config: TestSpecConfig::default(),
     }
 }
@@ -78,6 +80,7 @@ fn new_client_config(
             rdma_device_names: None,
         },
         pprof_duration_seconds: None,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: vec![etcd.to_string()],
@@ -121,6 +124,7 @@ fn new_zero_contribution_client_config(
             rdma_device_names: None,
         },
         pprof_duration_seconds: None,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: Vec::new(),
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index 222b821..fed6a1a 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -13,11 +13,12 @@ use crate::cluster_manager::{
 use crate::rpcresp_kvresult_convert::ToResult;
 use crate::{
     client_kv_api::msg_pack::{
-        ExternalBatchGetCancelReq, ExternalBatchGetReq, ExternalBatchGetStartReq,
-        ExternalBatchGetStartResp, ExternalBatchGetTransferReq, ExternalBatchGetTransferResp,
-        ExternalBatchIsExistReq, ExternalBatchPutCommitItemReq, ExternalBatchPutCommitReq,
-        ExternalBatchPutCommitResp, ExternalBatchPutStartItemReq, ExternalBatchPutStartReq,
-        ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemReq,
+        ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetItemResp,
+        ExternalBatchGetReq, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
+        ExternalBatchGetStartTransferPlan, ExternalBatchGetTransferReq,
+        ExternalBatchGetTransferResp, ExternalBatchIsExistReq, ExternalBatchPutCommitItemReq,
+        ExternalBatchPutCommitReq, ExternalBatchPutCommitResp, ExternalBatchPutStartItemReq,
+        ExternalBatchPutStartReq, ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemReq,
         ExternalBatchPutTransferEndReq, ExternalBatchPutTransferEndResp, ExternalDeleteAckReq,
         ExternalDeleteReq, ExternalGetReq, ExternalIsExistReq, ExternalObservabilitySnapshotReq,
         ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
@@ -84,6 +85,101 @@ struct PendingExternalGetStart {
     first_miss_index: Option<usize>,
 }
 
+#[derive(Clone)]
+struct PendingInlineExternalGetStart {
+    keys: Vec<String>,
+    items: Vec<ExternalBatchGetItemResp>,
+    owner_start_time: i64,
+}
+
+fn validate_inline_external_get_start_plan(
+    keys_len: usize,
+    items: &[ExternalBatchGetItemResp],
+) -> KvResult<()> {
+    if items.len() != keys_len {
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "inline external get_start plan length mismatch: expected={} got={}",
+                keys_len,
+                items.len()
+            ),
+        }));
+    }
+    for (idx, item) in items.iter().enumerate() {
+        if item.error_code != OK || item.external_memholder_info.is_none() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "inline external get_start plan item must be a hit: index={} error_code={} has_memholder={}",
+                    idx,
+                    item.error_code,
+                    item.external_memholder_info.is_some()
+                ),
+            }));
+        }
+    }
+    Ok(())
+}
+
+fn validate_inline_external_get_owner_generation(
+    plan_owner_start_time: i64,
+    current_owner_start_time: i64,
+) -> KvResult<()> {
+    if plan_owner_start_time == current_owner_start_time {
+        return Ok(());
+    }
+    Err(KvError::Api(ApiError::OwnerStartTimeMismatch {
+        expected: current_owner_start_time,
+        got: plan_owner_start_time,
+    }))
+}
+
+#[cfg(test)]
+mod inline_external_get_start_tests {
+    use super::{
+        validate_inline_external_get_owner_generation, validate_inline_external_get_start_plan,
+    };
+    use crate::client_kv_api::msg_pack::ExternalBatchGetItemResp;
+    use crate::memholder::ExternalMemHolderInfo;
+    use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
+
+    fn inline_hit(holder_id: u64) -> ExternalBatchGetItemResp {
+        ExternalBatchGetItemResp {
+            error_code: OK,
+            error_json: String::new(),
+            external_memholder_info: Some(ExternalMemHolderInfo {
+                offset: holder_id * 4096,
+                len: 4096,
+                holder_id,
+            }),
+        }
+    }
+
+    #[test]
+    fn inline_plan_requires_one_hit_per_requested_key() {
+        let items = vec![inline_hit(1), inline_hit(2)];
+        assert!(validate_inline_external_get_start_plan(2, &items).is_ok());
+        assert!(validate_inline_external_get_start_plan(3, &items).is_err());
+
+        let mut missing = items;
+        missing[1].external_memholder_info = None;
+        assert!(validate_inline_external_get_start_plan(2, &missing).is_err());
+    }
+
+    #[test]
+    fn inline_plan_rejects_a_stale_owner_generation() {
+        assert!(validate_inline_external_get_owner_generation(17, 17).is_ok());
+        let err = validate_inline_external_get_owner_generation(17, 18)
+            .expect_err("stale inline plan must not expose an old mapping");
+        assert!(matches!(
+            err,
+            KvError::Api(ApiError::OwnerStartTimeMismatch {
+                expected: 18,
+                got: 17
+            })
+        ));
+    }
+}
+
 fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
     duration.as_micros().min(i64::MAX as u128) as i64
 }
@@ -357,6 +453,8 @@ pub struct ExternalInner {
     /// key -> Weak<ExternalMemHolder> index (dashmap-based)
     key_weak_memholder_index: DashMap<String, Weak<ExternalMemHolder>>,
     pending_external_get_start: DashMap<u64, PendingExternalGetStart>,
+    /// Fully local plans consumed without a follow-up owner transfer RPC.
+    pending_inline_external_get_start: DashMap<u64, PendingInlineExternalGetStart>,
     /// per-key semaphore (permits=1) to ensure single inflight per key
     inflight1_per_key: SemaphoreMap<String>,
     put_trace_log_window: Mutex<ExternalPutTraceLogWindow>,
@@ -422,6 +520,7 @@ impl ExternalClientApi {
             rpc_caller_client_lease_keepalive: RPCCaller::<ClientLeaseKeepaliveReq>::new(),
             key_weak_memholder_index: DashMap::new(),
             pending_external_get_start: DashMap::new(),
+            pending_inline_external_get_start: DashMap::new(),
             inflight1_per_key: SemaphoreMap::new(1, std::time::Duration::from_secs(120)),
             put_trace_log_window: Mutex::new(ExternalPutTraceLogWindow::new()),
         }))
@@ -1907,11 +2006,12 @@ impl ExternalInner {
                     detail: Some("Shared storage node id unavailable".to_string()),
                 })
             })?;
+            let started_time = self.current_owner_start_time().await;
             let req = MsgPack {
                 serialize_part: ExternalBatchGetStartReq {
                     keys: keys.clone(),
                     req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
-                    started_time: self.current_owner_start_time().await,
+                    started_time,
                     prefix_best_effort,
                     atomic_group_lens: atomic_group_lens.clone(),
                     transfer_concurrency,
@@ -1961,7 +2061,24 @@ impl ExternalInner {
                 }
                 return Err(err);
             }
-            return Ok(resp.serialize_part);
+            let response = resp.serialize_part;
+            let _ = self
+                .pending_inline_external_get_start
+                .remove(&response.handle);
+            if let ExternalBatchGetStartTransferPlan::InlineLocal { items } =
+                &response.transfer_plan
+            {
+                validate_inline_external_get_start_plan(keys.len(), items)?;
+                self.pending_inline_external_get_start.insert(
+                    response.handle,
+                    PendingInlineExternalGetStart {
+                        keys: keys.clone(),
+                        items: items.clone(),
+                        owner_start_time: started_time,
+                    },
+                );
+            }
+            return Ok(response);
         }
     }
 
@@ -1975,6 +2092,87 @@ impl ExternalInner {
             handle,
             keys.len()
         );
+        if let Some((_handle, inline_plan)) = self.pending_inline_external_get_start.remove(&handle)
+        {
+            if keys != inline_plan.keys {
+                let expected_keys = inline_plan.keys.clone();
+                self.pending_inline_external_get_start
+                    .insert(handle, inline_plan);
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "inline external batch_get_transfer keys mismatch: handle={} expected={:?} got={:?}",
+                        handle, expected_keys, keys
+                    ),
+                }));
+            }
+
+            let owner_snapshot = match self.wait_current_owner_mapped_range().await {
+                Ok(snapshot) => snapshot,
+                Err(err) => {
+                    self.pending_inline_external_get_start
+                        .insert(handle, inline_plan);
+                    return Err(err);
+                }
+            };
+            let (_, current_owner_start_time, _, base_ptr_ro, mapped_len) = owner_snapshot;
+            validate_inline_external_get_owner_generation(
+                inline_plan.owner_start_time,
+                current_owner_start_time,
+            )?;
+            validate_inline_external_get_start_plan(keys.len(), &inline_plan.items)?;
+            for (idx, item) in inline_plan.items.iter().enumerate() {
+                let info = item
+                    .external_memholder_info
+                    .as_ref()
+                    .expect("inline plan was validated above");
+                let end = info.offset.checked_add(u64::from(info.len)).ok_or_else(|| {
+                    KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "inline external get_start item range overflow: index={} offset={} len={}",
+                            idx, info.offset, info.len
+                        ),
+                    })
+                })?;
+                if end > mapped_len {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "inline external get_start item exceeds owner mapping: index={} end={} mapped_len={}",
+                            idx, end, mapped_len
+                        ),
+                    }));
+                }
+            }
+
+            let bandwidth_handle = self
+                .view
+                .cluster_manager()
+                .ipc_bandwidth_attributor_handle()
+                .expect("ExternalClientApi.batch_get_transfer expects IpcBandwidthAttributor handle to be attached");
+            let external_client_id = self.view.cluster_manager().get_self_info().id.clone();
+            let mut results = Vec::with_capacity(keys.len());
+            for (key, item) in keys.into_iter().zip(inline_plan.items.into_iter()) {
+                let info = item
+                    .external_memholder_info
+                    .expect("inline plan was validated above");
+                if info.len > 0 {
+                    bandwidth_handle.record_tx_bytes(info.len as u64);
+                }
+                let holder = Arc::new(ExternalMemHolder::new(
+                    info.offset,
+                    base_ptr_ro + info.offset,
+                    info.len,
+                    info.holder_id,
+                    key.clone(),
+                    external_client_id.clone(),
+                    self.view.clone(),
+                    inline_plan.owner_start_time,
+                ));
+                self.key_weak_memholder_index
+                    .insert(key, Arc::downgrade(&holder));
+                results.push(Ok(Some(holder)));
+            }
+            return Ok(results);
+        }
         if keys.is_empty() {
             return Ok(Vec::new());
         }
@@ -2072,26 +2270,72 @@ impl ExternalInner {
 
     pub async fn cancel_batch_get_start(&self, handle: u64) -> KvResult<()> {
         tracing::debug!("External cancel_batch_get_start request: handle={}", handle);
-        let started_time = self.current_owner_start_time().await;
-        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
-            KvError::SharedMem(SharedMemError::NotConfigured {
-                node_id: None,
-                detail: Some("Shared storage node id unavailable".to_string()),
-            })
-        })?;
+        let inline_plan = self
+            .pending_inline_external_get_start
+            .remove(&handle)
+            .map(|(_handle, plan)| plan);
+        let current_owner_start_time = self.current_owner_start_time().await;
+        if inline_plan
+            .as_ref()
+            .is_some_and(|plan| plan.owner_start_time != current_owner_start_time)
+        {
+            tracing::info!(
+                "cancel_batch_get_start: inline plan owner generation is stale; treating holdings as gone"
+            );
+            return Ok(());
+        }
+        let started_time = inline_plan
+            .as_ref()
+            .map(|plan| plan.owner_start_time)
+            .unwrap_or(current_owner_start_time);
+        let transfer_plan = match inline_plan.as_ref() {
+            Some(plan) => ExternalBatchGetCancelPlan::InlineLocal {
+                holder_ids: plan
+                    .items
+                    .iter()
+                    .filter_map(|item| {
+                        item.external_memholder_info
+                            .as_ref()
+                            .map(|info| info.holder_id)
+                    })
+                    .collect(),
+            },
+            None => ExternalBatchGetCancelPlan::OwnerRpc,
+        };
+        let owner = match self.shared_storage_node_id().await {
+            Some(owner) => owner,
+            None => {
+                if let Some(plan) = inline_plan {
+                    self.pending_inline_external_get_start.insert(handle, plan);
+                }
+                return Err(KvError::SharedMem(SharedMemError::NotConfigured {
+                    node_id: None,
+                    detail: Some("Shared storage node id unavailable".to_string()),
+                }));
+            }
+        };
         let req = MsgPack {
             serialize_part: ExternalBatchGetCancelReq {
                 handle,
                 req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
                 started_time,
+                transfer_plan,
             },
             raw_bytes: Vec::new(),
         };
-        let resp = self
+        let resp = match self
             .rpc_caller_external_batch_get_cancel
             .call(self.view.p2p_module(), owner.into(), req, None, 0)
             .await
-            .map_err(KvError::from)?;
+        {
+            Ok(resp) => resp,
+            Err(err) => {
+                if let Some(plan) = inline_plan {
+                    self.pending_inline_external_get_start.insert(handle, plan);
+                }
+                return Err(KvError::from(err));
+            }
+        };
         if resp.serialize_part.error_code == OK {
             return Ok(());
         }
@@ -2105,6 +2349,9 @@ impl ExternalInner {
             );
             return Ok(());
         }
+        if let Some(plan) = inline_plan {
+            self.pending_inline_external_get_start.insert(handle, plan);
+        }
         Err(err)
     }
 
@@ -2898,6 +3145,7 @@ key={}, attempt={}/{}, err={}",
                         preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
                     })
                     .collect(),
+                atomic_group_lens: None,
                 started_time,
             },
             raw_bytes: Vec::new(),
diff --git a/fluxon_rs/fluxon_kv/src/kv_test.rs b/fluxon_rs/fluxon_kv/src/kv_test.rs
index 4db3a7f..d8331ea 100644
--- a/fluxon_rs/fluxon_kv/src/kv_test.rs
+++ b/fluxon_rs/fluxon_kv/src/kv_test.rs
@@ -993,6 +993,8 @@ fn new_master_launch(
             log_dir,
             master_ui: None,
             replica_task_placement: ReplicaTaskPlacementConfig::default(),
+            replica_cache_capacity_ratio: crate::config::DEFAULT_REPLICA_CACHE_CAPACITY_RATIO,
+            replica_writeback_tier1_capacity_ratio: None,
             // Keep kv_test self-describing: each round carries the intended transfer mode.
             test_spec_config: kv_test_round_test_spec_config(round.round_profile),
         },
@@ -1032,6 +1034,7 @@ fn build_client_launch(
         contribute_to_cluster_pool_size: contribute_to_cluster_pool_size.clone(),
         protocol: options.protocol_config.unwrap_or_else(tcp_protocol_config),
         pprof_duration_seconds: None,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: fluxonkv_etcd_addresses,
diff --git a/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs b/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
index 376cc8a..d17dc57 100644
--- a/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
+++ b/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
@@ -94,6 +94,8 @@ fn new_master_config_with_cluster(
         pprof_duration_seconds: None,
         master_ui: None,
         replica_task_placement: ReplicaTaskPlacementConfig::default(),
+        replica_cache_capacity_ratio: crate::config::DEFAULT_REPLICA_CACHE_CAPACITY_RATIO,
+        replica_writeback_tier1_capacity_ratio: None,
         test_spec_config: TestSpecConfig::default(),
     };
     println!("fluxonkv core created master config for test: {:?}", conf);
@@ -136,6 +138,7 @@ fn new_client_config_with_cluster_and_dram(
             rdma_device_names: None,
         },
         pprof_duration_seconds: None,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: vec![etcd],
diff --git a/fluxon_rs/fluxon_kv/src/lib.rs b/fluxon_rs/fluxon_kv/src/lib.rs
index 609dc47..0842a68 100644
--- a/fluxon_rs/fluxon_kv/src/lib.rs
+++ b/fluxon_rs/fluxon_kv/src/lib.rs
@@ -31,6 +31,37 @@ pub use crate::cluster_manager::{ClusterEvent, ClusterMember};
 pub use fluxon_observability::types::FsMountKind;
 
 pub const OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES: u64 = 512 * 1024 * 1024;
+pub(crate) const OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES: u64 = 4 * 1024;
+
+pub(crate) fn owner_local_reserve_slot_size_bytes(value_len: u64) -> Option<u64> {
+    let normalized = value_len.max(OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES);
+    let alignment_mask = OWNER_LOCAL_RESERVE_MIN_SLOT_SIZE_BYTES - 1;
+    let slot_size = normalized
+        .checked_add(alignment_mask)
+        .map(|rounded| rounded & !alignment_mask)?;
+    (slot_size <= OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES).then_some(slot_size)
+}
+
+pub(crate) fn owner_local_reserve_slots_per_grant(slot_size: u64) -> Option<u32> {
+    if slot_size == 0 || slot_size > OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES {
+        return None;
+    }
+    u32::try_from(OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES / slot_size).ok()
+}
+
+pub(crate) fn owner_local_reserve_expected_grant_count(
+    value_len: u64,
+    payload_capacity_bytes: u64,
+) -> Option<u64> {
+    if value_len == 0 || payload_capacity_bytes == 0 {
+        return None;
+    }
+    let slot_size = owner_local_reserve_slot_size_bytes(value_len)?;
+    let slots_per_grant = u64::from(owner_local_reserve_slots_per_grant(slot_size)?);
+    let value_count =
+        payload_capacity_bytes / value_len + u64::from(payload_capacity_bytes % value_len != 0);
+    Some(value_count / slots_per_grant + u64::from(value_count % slots_per_grant != 0))
+}
 
 pub type MembershipEventReceiver =
     limit_thirdparty::tokio::sync::abroadcast::Receiver<ClusterEvent>;
@@ -804,6 +835,7 @@ fn build_side_transfer_worker_config(
     test_spec_config.side_transfer_role = Some(SideTransferRole::Worker);
     test_spec_config.transport_mode = None;
     test_spec_config.rdma_device_names = None;
+    test_spec_config.owner_local_reserve_expected_capacity = None;
 
     Ok(ClientConfig {
         cluster_name: owner_config.cluster_name.clone(),
@@ -818,6 +850,7 @@ fn build_side_transfer_worker_config(
             rdma_device_names: None,
         },
         pprof_duration_seconds: owner_config.pprof_duration_seconds,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: Vec::new(),
@@ -868,6 +901,7 @@ fn build_side_transfer_worker_config_yaml(
         protocol: Some(side_config.protocol),
         contribute_to_cluster_pool_size: None,
         pprof_duration_seconds: side_config.pprof_duration_seconds,
+        replica_writeback_hot_capacity_ratio: None,
         fluxonkv_spec: crate::config::FluxonKvSpecYaml {
             etcd_addresses: None,
             cluster_name: side_config.cluster_name,
@@ -1522,6 +1556,8 @@ async fn run_master_impl(
         master_kv_router_arg: MasterKvRouterNewArg {
             test_spec_config: config.test_spec_config.clone(),
             replica_task_placement: config.replica_task_placement.clone(),
+            replica_cache_capacity_ratio: config.replica_cache_capacity_ratio,
+            replica_writeback_tier1_capacity_ratio: config.replica_writeback_tier1_capacity_ratio,
         },
         metric_reporter_arg: MetricReporterNewArg {
             test_spec_config: config.test_spec_config.clone(),
@@ -2069,6 +2105,11 @@ async fn run_client_impl(
             },
             client_kv_api_arg: ClientKvApiNewArg {
                 test_spec_config: config.test_spec_config.clone(),
+                owner_hot_cache_capacity_bytes: config.replica_writeback_hot_capacity_ratio.map(
+                    |ratio| {
+                        (config.contribute_to_cluster_pool_size.dram as f64 * ratio).floor() as u64
+                    },
+                ),
             },
             client_seg_pool_arg: ClientSegPoolNewArg {
                 contribute_size: config.contribute_to_cluster_pool_size.clone(),
@@ -2488,6 +2529,7 @@ mod tests {
                 rdma_device_names: None,
             },
             pprof_duration_seconds: None,
+            replica_writeback_hot_capacity_ratio: None,
             redis_compat_listen_addr: None,
             fluxonkv_spec: FluxonKvSpec {
                 etcd_addresses: vec!["http://127.0.0.1:2379".to_string()],
@@ -2795,6 +2837,7 @@ mod tests {
                 rdma_device_names: None,
             },
             pprof_duration_seconds: None,
+            replica_writeback_hot_capacity_ratio: None,
             redis_compat_listen_addr: None,
             fluxonkv_spec: FluxonKvSpec {
                 etcd_addresses: Vec::new(),
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/count_prefix_index.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/count_prefix_index.rs
index 4c6e34a..ab7cdad 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/count_prefix_index.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/count_prefix_index.rs
@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 
+type KeyVersion = (u64, u32);
+
 /// Radix tree node used for prefix counting.
 ///
 /// Each node tracks the total number of keys in its subtree via `count`.
@@ -25,15 +27,33 @@ impl Node {
 #[derive(Default)]
 pub struct PrefixRadixTree {
     root: Node,
+    /// Current version for every logical key represented in the radix counts.
+    ///
+    /// Route publication and final-route reclaim are intentionally processed by separate async
+    /// actors. Their events can therefore be duplicated or observed out of order. Keeping the
+    /// version here makes both operations idempotent and prevents an old remove from deleting a
+    /// newer incarnation of the same key.
+    versions: HashMap<String, KeyVersion>,
 }
 
 impl PrefixRadixTree {
     pub fn new() -> Self {
-        Self { root: Node::new() }
+        Self {
+            root: Node::new(),
+            versions: HashMap::new(),
+        }
     }
 
-    /// Insert a new key. Must only be called once per logical key.
-    pub fn insert(&mut self, key: &str) {
+    /// Insert or update a key version. Returns true only when a new logical key was counted.
+    pub fn insert(&mut self, key: &str, version: KeyVersion) -> bool {
+        if let Some(current) = self.versions.get_mut(key) {
+            if *current != version {
+                *current = version;
+            }
+            return false;
+        }
+
+        self.versions.insert(key.to_string(), version);
         let bytes = key.as_bytes();
         let mut node = &mut self.root;
         node.count = node
@@ -48,25 +68,42 @@ impl PrefixRadixTree {
                 .checked_add(1)
                 .expect("PrefixRadixTree count overflow on insert (child)");
         }
+        true
     }
 
-    /// Remove an existing key. Must only be called for keys that were inserted.
-    pub fn remove(&mut self, key: &str) {
+    /// Remove exactly one key version. Missing, duplicate, or stale removes are harmless.
+    pub fn remove(&mut self, key: &str, version: KeyVersion) -> bool {
+        if !self
+            .versions
+            .get(key)
+            .is_some_and(|current| *current == version)
+        {
+            return false;
+        }
+
+        // Validate the complete path before mutating any count. This keeps the operation
+        // non-panicking even if an index built by older code was inconsistent.
+        let mut current = &self.root;
+        for &byte in key.as_bytes() {
+            let Some(child) = current.children.get(&byte) else {
+                self.versions.remove(key);
+                return false;
+            };
+            current = child;
+        }
+        self.versions.remove(key);
+
         fn remove_inner(node: &mut Node, bytes: &[u8], idx: usize) -> bool {
-            node.count = node
-                .count
-                .checked_sub(1)
-                .expect("PrefixRadixTree underflow on remove");
+            node.count = node.count.saturating_sub(1);
 
             if idx == bytes.len() {
                 return node.count == 0;
             }
 
             let b = bytes[idx];
-            let child = node
-                .children
-                .get_mut(&b)
-                .expect("PrefixRadixTree remove: missing child for existing key");
+            let Some(child) = node.children.get_mut(&b) else {
+                return node.count == 0;
+            };
             let should_prune = remove_inner(child, bytes, idx + 1);
             if should_prune {
                 node.children.remove(&b);
@@ -75,6 +112,7 @@ impl PrefixRadixTree {
         }
 
         remove_inner(&mut self.root, key.as_bytes(), 0);
+        true
     }
 
     /// Count keys whose name starts with the given prefix.
@@ -89,3 +127,40 @@ impl PrefixRadixTree {
         node.count
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::PrefixRadixTree;
+
+    #[test]
+    fn duplicate_insert_and_remove_are_idempotent() {
+        let mut tree = PrefixRadixTree::new();
+        assert!(tree.insert("prefix/key", (1, 0)));
+        assert!(!tree.insert("prefix/key", (1, 0)));
+        assert_eq!(tree.count_prefix("prefix/"), 1);
+
+        assert!(tree.remove("prefix/key", (1, 0)));
+        assert!(!tree.remove("prefix/key", (1, 0)));
+        assert_eq!(tree.count_prefix("prefix/"), 0);
+    }
+
+    #[test]
+    fn stale_remove_cannot_delete_newer_key_version() {
+        let mut tree = PrefixRadixTree::new();
+        assert!(tree.insert("prefix/key", (1, 0)));
+        assert!(!tree.insert("prefix/key", (2, 0)));
+        assert!(!tree.remove("prefix/key", (1, 0)));
+        assert_eq!(tree.count_prefix("prefix/"), 1);
+
+        assert!(tree.remove("prefix/key", (2, 0)));
+        assert_eq!(tree.count_prefix("prefix/"), 0);
+    }
+
+    #[test]
+    fn remove_before_delayed_insert_is_a_noop() {
+        let mut tree = PrefixRadixTree::new();
+        assert!(!tree.remove("prefix/key", (3, 0)));
+        assert!(tree.insert("prefix/key", (3, 0)));
+        assert_eq!(tree.count_prefix("prefix/"), 1);
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
index 4a25934..703257f 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
@@ -1,8 +1,7 @@
 use super::{
     MasterKvRouterView,
     msg_pack::{
-        BatchDeleteAckReq, BatchDeleteAckResp, BatchDeleteClientKvMetaCacheReq, DeleteAckReq,
-        DeleteAckResp, DeleteClientKvMetaCacheItem, DeleteReq, DeleteResp,
+        BatchDeleteAckReq, BatchDeleteAckResp, DeleteAckReq, DeleteAckResp, DeleteReq, DeleteResp,
     },
 };
 use crate::master_kv_router::OneKvNodesRoutes;
@@ -11,12 +10,18 @@ use crate::memholder::{
     EnsureMemholderMgmtDeleteActorOwned, MasterOwnerMemMgr, MemholderManagerTrait,
 };
 use crate::{
-    cluster_manager::NodeID,
-    p2p::msg_pack::{MsgPack, RPCCaller},
+    p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::{self, kv},
 };
 use limit_thirdparty::tokio;
-use std::{sync::Arc, time::Duration};
+use std::sync::Arc;
+
+#[cfg(any(test, feature = "test_bins"))]
+use super::msg_pack::{BatchDeleteClientKvMetaCacheReq, DeleteClientKvMetaCacheItem};
+#[cfg(any(test, feature = "test_bins"))]
+use crate::{cluster_manager::NodeID, p2p::msg_pack::RPCCaller};
+#[cfg(any(test, feature = "test_bins"))]
+use std::time::Duration;
 
 /// Remove a key from master indices and trigger client cache invalidation broadcast.
 ///
@@ -45,7 +50,7 @@ pub fn do_delete_one_kv_all_replicas(
                 if view.master_kv_router().prefix_index_enabled() {
                     let inner = view.master_kv_router().inner();
                     let mut tree = inner.prefix_index.write().await;
-                    tree.remove(&key_clone);
+                    tree.remove(&key_clone, deleted_put_id);
                 }
 
                 if let Err(err) = view
@@ -68,6 +73,8 @@ pub fn do_delete_one_kv_all_replicas(
                     if let Some(cache) = view.master_kv_router().get_node_cache_controller(node_id)
                     {
                         let _ = cache.remove(&key_clone);
+                        view.master_kv_router()
+                            .remove_node_writeback_tier1_entry(node_id, &key_clone);
                         tracing::debug!(
                             "Removed key {} from node cache controller: {}",
                             key_clone,
@@ -84,6 +91,8 @@ pub fn do_delete_one_kv_all_replicas(
     }
 }
 
+/// Test-only direct route removal. Production eviction uses the fenced owner reclaim protocol.
+#[cfg(any(test, feature = "test_bins"))]
 pub fn evict_one_kv_replica_for_node(
     view: &MasterKvRouterView,
     key: String,
@@ -145,7 +154,7 @@ pub fn evict_one_kv_replica_for_node(
             let _ = view.spawn("local_evict_remove_prefix_index", async move {
                 let inner = view_task.master_kv_router().inner();
                 let mut tree = inner.prefix_index.write().await;
-                tree.remove(&key_for_prefix);
+                tree.remove(&key_for_prefix, put_id);
             });
         }
     }
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 52d348e..5e0833e 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -1,5 +1,6 @@
 use super::{
-    InflightGetInfo, KvRouteInfo, MasterKvRouterView, NodeValueReplicaDesc, OwnerHoldingGetInfo,
+    InflightGetInfo, KvRouteInfo, MasterKeyActivityCompletionGuard, MasterKvRouterView,
+    OwnerHoldingGetInfo,
     msg_pack::{
         BatchGetDoneItemResp, BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeItemResp,
         BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
@@ -8,6 +9,7 @@ use super::{
         GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq,
         MemHolderReleaseResp,
     },
+    route_maintenance::{RoutePublishEvent, enqueue_post_route_maintenance},
 };
 use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::put::PutIDForAKey;
@@ -28,48 +30,31 @@ use std::{
     sync::{Arc, atomic::Ordering},
 };
 
-fn update_moka_for_node(
-    view: MasterKvRouterView,
-    node_id: String,
-    key: String,
-    weight: u32,
-    put_id: PutIDForAKey,
-    new_inserted: bool,
-) {
+fn touch_moka_for_node(view: MasterKvRouterView, node_id: String, key: String) {
     if !view.master_kv_router().replica_cache_enabled() {
         return;
     }
     let view_task = view.clone();
-    view.spawn("update_moka_for_node", async move {
+    view.spawn("touch_moka_for_node", async move {
         if let Some(cache) = view_task
             .master_kv_router()
             .get_node_cache_controller(&node_id)
         {
-            if new_inserted {
-                cache.insert(
-                    key.clone(),
-                    NodeValueReplicaDesc {
-                        weight_bytes: weight,
-                        put_id,
-                    },
-                );
-                tracing::debug!(
-                    "Inserted key: {:?} into node cache: {}, weight={}",
-                    key,
-                    node_id,
-                    weight
-                );
-            } else {
-                let _ = cache.get(&key);
-                tracing::debug!(
-                    "Touched key: {:?} on node cache: {} (TTL refresh)",
-                    key,
-                    node_id
-                );
+            if let Some(desc) = cache.get(&key)
+                && let Some(tier1_cache) = view_task
+                    .master_kv_router()
+                    .get_node_writeback_tier1_controller(&node_id)
+            {
+                tier1_cache.insert(key.clone(), desc);
             }
+            tracing::debug!(
+                "Touched key: {:?} on node cache: {} (TTL refresh)",
+                key,
+                node_id
+            );
         } else {
             tracing::warn!(
-                "No cache controller found for node: {} when updating moka",
+                "No cache controller found for node: {} when touching moka",
                 node_id
             );
         }
@@ -132,6 +117,14 @@ pub async fn handle_get_start(
 
     tracing::debug!("Handling GetStartReq: {:?}", req.serialize_part);
 
+    let activity_lease = match view
+        .master_kv_router()
+        .reserve_inflight_get_key(&req.serialize_part.key)
+    {
+        Ok(activity_lease) => activity_lease,
+        Err(err) => return failed_resp_err(err, None, &view, &req.serialize_part.key),
+    };
+
     let get_id = view
         .master_kv_router()
         .inner()
@@ -303,6 +296,12 @@ pub async fn handle_get_start(
             error_json: String::new(),
             server_process_us: 0,
         };
+        view.master_kv_router().record_get_source_selection(
+            req_node_id.as_ref(),
+            resp_node_id.as_ref(),
+            src_len,
+            allocation_mode,
+        );
         // 创建在途的Get操作信息
         let info = InflightGetInfo {
             put_id: one_kv_nodes_routes.put_id,
@@ -313,6 +312,7 @@ pub async fn handle_get_start(
             allocation: target_allocation, // 存储target allocation
             route: one_kv_nodes_routes.clone(),
             allocation_mode,
+            _activity_lease: activity_lease,
         };
 
         view.master_kv_router()
@@ -326,13 +326,10 @@ pub async fn handle_get_start(
         // For leased keys, there should be no moka entry; skip touching to avoid
         // unnecessary cache work.
         if one_kv_nodes_routes.lease_id.is_none() {
-            update_moka_for_node(
+            touch_moka_for_node(
                 view.clone(),
                 src_node_id.to_string(),
                 req.serialize_part.key.clone(),
-                0,
-                one_kv_nodes_routes.put_id,
-                false,
             );
         }
 
@@ -379,6 +376,8 @@ pub async fn handle_get_revoke(
         .remove(&get_id)
         .await
     {
+        let _activity_completion =
+            MasterKeyActivityCompletionGuard::new(inflight_info._activity_lease.clone());
         inflight_info.release_durable_slot_if_needed();
         tracing::info!("Revoked get operation with get_id: {}", get_id);
     } else {
@@ -409,6 +408,8 @@ pub async fn handle_get_done(
         .remove(&get_id)
         .await
     {
+        let _activity_completion =
+            MasterKeyActivityCompletionGuard::new(inflight_info._activity_lease.clone());
         let mut allocation_mode = inflight_info.allocation_mode;
         let route = inflight_info.route.clone();
         // clone req_node_id to avoid borrow/move conflict when inserting into kv_routes
@@ -441,6 +442,7 @@ pub async fn handle_get_done(
 
         if allocation_mode == GetAllocationMode::DurableReplica {
             let mut promote_committed = false;
+            let mut route_publish_event = None;
             if let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(&key) {
                 if one_kv_nodes_routes.put_id == inflight_info.put_id {
                     let mut nodes_replicas = one_kv_nodes_routes.nodes_replicas.write();
@@ -455,44 +457,18 @@ pub async fn handle_get_done(
                                     backing: super::KvReplicaBacking::Allocation(
                                         inflight_info.allocation,
                                     ),
+                                    owner_local_indexed: true,
                                     tomb_tag,
                                 },
                             );
                             promote_committed = true;
-                            // Read lease binding from route snapshot: for this put_id,
-                            // if the key is leased, we must NOT insert into moka.
-                            if one_kv_nodes_routes.lease_id.is_none() {
-                                // notify moka cache controller for requesting node after route insert
-                                // See put.rs for rationale: saturate weight to avoid u32 truncation
-                                let req_weight = if alloc_cap > u32::MAX as u64 {
-                                    tracing::warn!(
-                                        "moka weight saturation on get_done: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
-                                        key,
-                                        inflight_info.put_id.0,
-                                        inflight_info.put_id.1,
-                                        alloc_cap
-                                    );
-                                    u32::MAX
-                                } else {
-                                    alloc_cap as u32
-                                };
-                                update_moka_for_node(
-                                    view.clone(),
-                                    req_node_id.to_string(),
-                                    key.clone(),
-                                    req_weight,
-                                    inflight_info.put_id,
-                                    true,
-                                );
-                            } else {
-                                tracing::debug!(
-                                    "Skip moka insert for leased key={} put_id=({},{}) on node {}",
-                                    key,
-                                    inflight_info.put_id.0,
-                                    inflight_info.put_id.1,
-                                    req_node_id
-                                );
-                            }
+                            route_publish_event = Some(RoutePublishEvent::replica_append(
+                                key.clone(),
+                                inflight_info.put_id,
+                                one_kv_nodes_routes.lease_id,
+                                req_node_id.clone(),
+                                alloc_cap,
+                            ));
                         } else {
                             tracing::warn!(
                                 "get node is tomb, get_id: {}, put_id: {:?}",
@@ -522,10 +498,42 @@ pub async fn handle_get_done(
                     key
                 );
             }
+            if let Some(event) = route_publish_event {
+                enqueue_post_route_maintenance(&view, event).await;
+            }
             if !promote_committed {
                 allocation_mode = GetAllocationMode::Temporary;
                 route.release_get_durable_slot();
             }
+        } else if allocation_mode == GetAllocationMode::ReuseReplica {
+            let mut local_index_published = false;
+            if let Some(current_route) = view.master_kv_router().inner().kv_routes.get(&key) {
+                if current_route.put_id == inflight_info.put_id {
+                    let mut replicas = current_route.nodes_replicas.write();
+                    if let Some(replica) = replicas.get_mut(&req_node_id) {
+                        local_index_published = !replica.tomb_tag.is_tomb()
+                            && matches!(
+                                &replica.backing,
+                                super::KvReplicaBacking::Allocation(allocation)
+                                    if Arc::ptr_eq(allocation, &inflight_info.allocation)
+                            );
+                        if local_index_published {
+                            replica.owner_local_indexed = true;
+                        }
+                    }
+                }
+            }
+            if !local_index_published {
+                tracing::warn!(
+                    "Reused get allocation is no longer the current owner route; returning a temporary holder: get_id={} key={} put_id=({},{}) owner={}",
+                    get_id,
+                    key,
+                    inflight_info.put_id.0,
+                    inflight_info.put_id.1,
+                    req_node_id
+                );
+                allocation_mode = GetAllocationMode::Temporary;
+            }
         }
 
         tracing::info!(
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index 9e02cf4..c0af49e 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -3,8 +3,11 @@ mod get;
 pub mod msg_pack;
 pub mod placement;
 pub mod put;
+mod reclaim;
 
 mod count_prefix_index;
+mod route_maintenance;
+mod tiered_writeback;
 
 use self::{
     count_prefix_index::PrefixRadixTree,
@@ -17,21 +20,24 @@ use self::{
         handle_get_start,
     },
     msg_pack::{
-        BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchGetDoneReq, BatchGetRevokeReq,
-        BatchGetStartReq, BatchIsExistReq, BatchPreparePutKeysReq, BatchPutDoneReq,
-        BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq,
-        CountPrefixResp, DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq,
-        GetMasterOnlyMetricPartReq, GetMasterOnlyMetricPartResp, GetMetaReq, GetRevokeReq,
-        GetStartReq, MemHolderKeepAliveReq, MemHolderReleaseReq, PutAppendDoneReq,
-        PutAppendRevokeReq, PutAppendStartReq, PutDoneReq, PutRevokeReq, PutStartReq,
-        ReleaseLocalGrantReq, ReserveLocalGrantReq,
+        BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
+        BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartReq, BatchIsExistReq,
+        BatchOwnerReclaimReq, BatchPreparePutKeysReq, BatchPutDoneReq, BatchPutRevokeReq,
+        BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq, CountPrefixResp,
+        DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq, GetMasterOnlyMetricPartReq,
+        GetMasterOnlyMetricPartResp, GetMetaReq, GetRevokeReq, GetStartReq, GroupedBatchPutDoneReq,
+        MemHolderKeepAliveReq, MemHolderReleaseReq, OwnerReclaimBacking, OwnerReclaimItem,
+        OwnerReclaimReason, PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq,
+        PutAtomicGroup, PutDoneReq, PutRevokeReq, PutStartReq, ReleaseLocalGrantReq,
+        ReserveLocalGrantReq,
     },
     placement::{PlacementPolicy, build_placement_policy},
     put::{
         handle_batch_prepare_put_keys, handle_batch_put_done, handle_batch_put_revoke,
-        handle_batch_put_start, handle_batch_release_put_key_reservations, handle_put_append_done,
-        handle_put_append_revoke, handle_put_append_start, handle_put_done, handle_put_revoke,
-        handle_put_start, handle_release_local_grant, handle_reserve_local_grant,
+        handle_batch_put_start, handle_batch_release_put_key_reservations,
+        handle_grouped_batch_put_done, handle_put_append_done, handle_put_append_revoke,
+        handle_put_append_start, handle_put_done, handle_put_revoke, handle_put_start,
+        handle_release_local_grant, handle_reserve_local_grant,
     },
 };
 use crate::ClientKvApiAccessTrait;
@@ -57,6 +63,7 @@ use crate::rpcresp_kvresult_convert;
 use crate::rpcresp_kvresult_convert::msg_and_error::{KvError, OK};
 use fluxon_framework::{LogicalModule, define_module};
 use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
+use fluxon_util::map_lock::AMapLock;
 
 use async_trait::async_trait;
 use chrono::Utc;
@@ -70,17 +77,59 @@ use std::borrow::Cow;
 use std::collections::HashSet;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
-use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tracing::{debug, error, info, warn};
 
-// Cache capacity policy: fraction of a node's space reserved for the KV cache.
-// Keep as a single source of truth to avoid magic numbers scattered across methods.
-const MOKA_CACHE_CAPACITY_RATIO: f32 = 0.8;
 const MAX_GET_DURABLE_REPLICA_SLOTS: u32 = 2;
 const PLACEMENT_REPORT_INTERVAL_SECS: u64 = 10;
 const INFLIGHT_PUT_TTL_SECONDS: u64 = 60;
 const INFLIGHT_PUT_TTL_SECONDS_SKIP_PUT_END_COMMIT: u64 = 5;
+const EVICTION_RECLAIM_QUEUE_CAPACITY: usize = 4096;
+const POST_ROUTE_MAINTENANCE_QUEUE_CAPACITY: usize = 512;
+const TIER1_WRITEBACK_QUEUE_CAPACITY: usize = 4096;
+
+fn subtract_pending_eviction_weight(
+    pending_weight: &AtomicU64,
+    owner_node_id: &str,
+    completed_weight: u64,
+) {
+    if completed_weight == 0 {
+        return;
+    }
+    pending_weight
+        .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
+            current.checked_sub(completed_weight)
+        })
+        .unwrap_or_else(|pending| {
+            panic!(
+                "eviction reclaim pending weight underflow for owner {}: pending={} completed={}",
+                owner_node_id, pending, completed_weight
+            )
+        });
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum UnrecoverableCacheEvictionContext {
+    NormalCapacity,
+    OwnerLocalReserveNoSpace,
+}
+
+fn allow_unrecoverable_cache_eviction(
+    owner_is_remote_only: bool,
+    has_ready_remote_only_owner: bool,
+    context: UnrecoverableCacheEvictionContext,
+) -> bool {
+    // A normal active-tier eviction must preserve the remote copy whenever a remote-only tier is
+    // available. Physical local-reserve exhaustion is the liveness boundary: if that remote tier
+    // has filled and no recoverable active-tier entry remains, refusing to evict the last cached
+    // copy prevents the owner from accepting any subsequent write-back. The existing three-phase
+    // owner reclaim transaction removes the route and slot atomically, so dropping that cold cache
+    // entry is safe and a future lookup simply recomputes it.
+    context == UnrecoverableCacheEvictionContext::OwnerLocalReserveNoSpace
+        || owner_is_remote_only
+        || !has_ready_remote_only_owner
+}
 
 #[derive(Clone, Copy, Debug)]
 pub enum PutPlacementMode {
@@ -91,14 +140,12 @@ pub enum PutPlacementMode {
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum ReservedCapacityReason {
     LeaseBoundKv,
-    LocalReserveGrant,
 }
 
 #[derive(Debug, Default)]
 pub struct NodeCacheReservedCapacity {
     pub total_bytes: AtomicU64,
     pub lease_bound_kv_bytes: AtomicU64,
-    pub local_reserve_grant_bytes: AtomicU64,
 }
 
 impl NodeCacheReservedCapacity {
@@ -111,10 +158,6 @@ impl NodeCacheReservedCapacity {
                     self.lease_bound_kv_bytes
                         .fetch_add(delta, Ordering::Relaxed);
                 }
-                ReservedCapacityReason::LocalReserveGrant => {
-                    self.local_reserve_grant_bytes
-                        .fetch_add(delta, Ordering::Relaxed);
-                }
             }
         } else {
             let delta = (-delta_bytes) as u64;
@@ -124,10 +167,6 @@ impl NodeCacheReservedCapacity {
                     self.lease_bound_kv_bytes
                         .fetch_sub(delta, Ordering::Relaxed);
                 }
-                ReservedCapacityReason::LocalReserveGrant => {
-                    self.local_reserve_grant_bytes
-                        .fetch_sub(delta, Ordering::Relaxed);
-                }
             }
         }
     }
@@ -151,6 +190,37 @@ pub struct ReplicaCacheNodeObserveSnapshot {
     pub effective_capacity_bytes: u64,
     pub reserved_capacity_bytes: u64,
     pub base_capacity_bytes: u64,
+    pub pending_eviction_reclaim_bytes: u64,
+    pub writeback_tier1_entries: u64,
+    pub writeback_tier1_weighted_bytes: u64,
+    pub writeback_tier1_capacity_bytes: u64,
+    pub writeback_tier1_triggered: u64,
+    pub writeback_tier1_owner_accepted: u64,
+    pub writeback_tier1_failed: u64,
+    pub reclaim_master_activity_deferred: u64,
+    pub reclaim_master_get_holder_observed: u64,
+    pub reclaim_owner_holder_deferred: u64,
+    pub reclaim_owner_other_deferred: u64,
+    pub reclaim_route_changed: u64,
+    pub reclaim_retry_queued: u64,
+    pub reclaim_retry_completed: u64,
+    pub reclaim_retry_restored: u64,
+    pub reclaim_completed: u64,
+    pub owner_hot_demotion_attempts: u64,
+    pub owner_hot_demotion_cohorts: u64,
+    pub owner_hot_demotion_selected_bytes: u64,
+    pub owner_hot_demotion_precheck_rejected: u64,
+    pub owner_hot_demotion_partial_mismatch: u64,
+    pub recoverable_first_requested_bytes: u64,
+    pub recoverable_first_selected_bytes: u64,
+    pub recoverable_first_shortfall_bytes: u64,
+    pub recoverable_first_eligible_checks: u64,
+    pub recoverable_first_route_absent_checks: u64,
+    pub recoverable_first_version_changed_checks: u64,
+    pub recoverable_first_route_ineligible_checks: u64,
+    pub recoverable_first_cpu_route_absent_checks: u64,
+    pub recoverable_first_atomic_group_incomplete_checks: u64,
+    pub recoverable_first_tp_cohort_incomplete_checks: u64,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -208,14 +278,22 @@ pub struct InflightPutInfo {
     pub req_node_id: NodeID,
     pub len: u64,
     pub commit_info: InflightPutCommitInfo,
+    pub(crate) _activity_lease: Arc<MasterKeyActivityLease>,
 }
 
 #[derive(Clone)]
 pub struct InflightReplicaTaskInfo {
     pub node_id: NodeID,
+    pub source_node_id: NodeID,
     pub key: String,
     pub put_id: PutIDForAKey,
     pub target_allocation: Arc<Mutex<Option<Allocation>>>,
+    pub demote_source_on_remote_complete: bool,
+    /// Protect the source-owner copy only after this inclusive replica has been
+    /// published successfully.  Backend-admitted replicas set this bit; tiered
+    /// write-back and owner-hot exclusive demotion deliberately do not.
+    pub protect_source_on_remote_complete: bool,
+    pub(crate) _activity_lease: Arc<MasterKeyActivityLease>,
 }
 
 /// Information about a `get` operation that is currently in progress.
@@ -229,6 +307,7 @@ pub struct InflightGetInfo {
     pub allocation: Arc<Allocation>,
     pub route: Arc<OneKvNodesRoutes>,
     pub allocation_mode: GetAllocationMode,
+    pub(crate) _activity_lease: Arc<MasterKeyActivityLease>,
 }
 
 impl InflightGetInfo {
@@ -256,6 +335,222 @@ pub struct LocalReserveGrantInfo {
 pub struct PreparedPutKeyReservationInfo {
     pub owner_node_id: NodeID,
     pub key: String,
+    pub(crate) _activity_lease: Arc<MasterKeyActivityLease>,
+}
+
+#[derive(Default)]
+pub(crate) struct EvictionReclaimCounters {
+    pub master_activity_deferred: AtomicU64,
+    pub master_get_holder_observed: AtomicU64,
+    pub owner_holder_deferred: AtomicU64,
+    pub owner_other_deferred: AtomicU64,
+    pub route_changed: AtomicU64,
+    pub retry_queued: AtomicU64,
+    pub retry_completed: AtomicU64,
+    pub retry_restored: AtomicU64,
+    pub completed: AtomicU64,
+    pub owner_hot_demotion_attempts: AtomicU64,
+    pub owner_hot_demotion_cohorts: AtomicU64,
+    pub owner_hot_demotion_selected_bytes: AtomicU64,
+    pub owner_hot_demotion_precheck_rejected: AtomicU64,
+    pub owner_hot_demotion_partial_mismatch: AtomicU64,
+    pub recoverable_first_requested_bytes: AtomicU64,
+    pub recoverable_first_selected_bytes: AtomicU64,
+    pub recoverable_first_shortfall_bytes: AtomicU64,
+    pub recoverable_first_eligible_checks: AtomicU64,
+    pub recoverable_first_route_absent_checks: AtomicU64,
+    pub recoverable_first_version_changed_checks: AtomicU64,
+    pub recoverable_first_route_ineligible_checks: AtomicU64,
+    pub recoverable_first_cpu_route_absent_checks: AtomicU64,
+    pub recoverable_first_atomic_group_incomplete_checks: AtomicU64,
+    pub recoverable_first_tp_cohort_incomplete_checks: AtomicU64,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct MasterKeyActivitySnapshot {
+    pub puts: u32,
+    pub gets: u32,
+    pub replicas: u32,
+    pub reclaim_installed: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum MasterKeyActivityKind {
+    Put,
+    Get,
+    Replica,
+}
+
+#[derive(Default)]
+struct MasterKeyActivityState {
+    puts: u32,
+    gets: u32,
+    replicas: u32,
+    reclaim: Option<OwnerReclaimItem>,
+}
+
+#[derive(Default)]
+pub(crate) struct MasterKeyActivityTable {
+    states: Mutex<HashMap<String, MasterKeyActivityState>>,
+}
+
+pub(crate) struct MasterKeyActivityLease {
+    table: Arc<MasterKeyActivityTable>,
+    key: String,
+    kind: MasterKeyActivityKind,
+    released: AtomicBool,
+}
+
+impl MasterKeyActivityLease {
+    pub(crate) fn release_now(&self) {
+        if self
+            .released
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_ok()
+        {
+            self.table.release(&self.key, self.kind);
+        }
+    }
+}
+
+impl Drop for MasterKeyActivityLease {
+    fn drop(&mut self) {
+        self.release_now();
+    }
+}
+
+pub(crate) struct MasterKeyActivityCompletionGuard {
+    lease: Option<Arc<MasterKeyActivityLease>>,
+}
+
+impl MasterKeyActivityCompletionGuard {
+    pub(crate) fn new(lease: Arc<MasterKeyActivityLease>) -> Self {
+        Self { lease: Some(lease) }
+    }
+
+    pub(crate) fn disarm(&mut self) {
+        self.lease = None;
+    }
+}
+
+impl Drop for MasterKeyActivityCompletionGuard {
+    fn drop(&mut self) {
+        if let Some(lease) = self.lease.as_ref() {
+            lease.release_now();
+        }
+    }
+}
+
+impl MasterKeyActivityTable {
+    fn reserve(
+        self: &Arc<Self>,
+        key: &str,
+        kind: MasterKeyActivityKind,
+        reject_same_kind_if_active: bool,
+    ) -> Option<Arc<MasterKeyActivityLease>> {
+        let mut states = self.states.lock();
+        let state = states.entry(key.to_string()).or_default();
+        if state.reclaim.is_some() {
+            return None;
+        }
+        let counter = match kind {
+            MasterKeyActivityKind::Put => &mut state.puts,
+            MasterKeyActivityKind::Get => &mut state.gets,
+            MasterKeyActivityKind::Replica => &mut state.replicas,
+        };
+        if reject_same_kind_if_active && *counter > 0 {
+            return None;
+        }
+        *counter = counter
+            .checked_add(1)
+            .expect("master per-key activity counter overflow");
+        Some(Arc::new(MasterKeyActivityLease {
+            table: self.clone(),
+            key: key.to_string(),
+            kind,
+            released: AtomicBool::new(false),
+        }))
+    }
+
+    fn release(&self, key: &str, kind: MasterKeyActivityKind) {
+        let mut states = self.states.lock();
+        let remove = {
+            let state = states
+                .get_mut(key)
+                .expect("master per-key activity state missing on release");
+            let counter = match kind {
+                MasterKeyActivityKind::Put => &mut state.puts,
+                MasterKeyActivityKind::Get => &mut state.gets,
+                MasterKeyActivityKind::Replica => &mut state.replicas,
+            };
+            *counter = counter
+                .checked_sub(1)
+                .expect("master per-key activity counter underflow");
+            state.puts == 0 && state.gets == 0 && state.replicas == 0 && state.reclaim.is_none()
+        };
+        if remove {
+            states.remove(key);
+        }
+    }
+
+    pub(crate) fn try_install_reclaim(
+        &self,
+        item: &OwnerReclaimItem,
+    ) -> Result<(), MasterKeyActivitySnapshot> {
+        let mut states = self.states.lock();
+        let state = states.entry(item.key.clone()).or_default();
+        if state.puts != 0 || state.gets != 0 || state.replicas != 0 || state.reclaim.is_some() {
+            return Err(MasterKeyActivitySnapshot {
+                puts: state.puts,
+                gets: state.gets,
+                replicas: state.replicas,
+                reclaim_installed: state.reclaim.is_some(),
+            });
+        }
+        state.reclaim = Some(item.clone());
+        Ok(())
+    }
+
+    pub(crate) fn is_quiescent(&self, key: &str) -> bool {
+        let states = self.states.lock();
+        match states.get(key) {
+            None => true,
+            Some(state) => {
+                state.puts == 0 && state.gets == 0 && state.replicas == 0 && state.reclaim.is_none()
+            }
+        }
+    }
+
+    pub(crate) fn reclaim_matches(&self, item: &OwnerReclaimItem) -> bool {
+        self.states
+            .lock()
+            .get(&item.key)
+            .and_then(|state| state.reclaim.as_ref())
+            == Some(item)
+    }
+
+    pub(crate) fn clear_reclaim(&self, item: &OwnerReclaimItem) -> bool {
+        let mut states = self.states.lock();
+        let Some(state) = states.get_mut(&item.key) else {
+            return false;
+        };
+        if state.reclaim.as_ref() != Some(item) {
+            return false;
+        }
+        state.reclaim = None;
+        if state.puts == 0 && state.gets == 0 && state.replicas == 0 {
+            states.remove(&item.key);
+        }
+        true
+    }
+
+    #[cfg(test)]
+    fn has_reclaim(&self, key: &str) -> bool {
+        self.states
+            .lock()
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+    }
 }
 
 async fn handle_count_prefix(
@@ -306,9 +601,11 @@ define_module!(
 pub struct MasterKvRouterNewArg {
     pub test_spec_config: TestSpecConfig,
     pub replica_task_placement: ReplicaTaskPlacementConfig,
+    pub replica_cache_capacity_ratio: f64,
+    pub replica_writeback_tier1_capacity_ratio: Option<f64>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct NodeValueReplicaDesc {
     pub weight_bytes: u32,
     pub put_id: PutIDForAKey,
@@ -349,6 +646,10 @@ impl KvReplicaBacking {
 pub struct KvRouteInfo {
     pub node_id: NodeID,
     pub backing: KvReplicaBacking,
+    /// Whether this owner also published the route backing into its local key index.
+    /// Replica-task and remote-put targets are raw master-owned allocations and have no
+    /// owner-side key entry to fence during capacity eviction.
+    pub owner_local_indexed: bool,
     pub tomb_tag: NodeTombTag,
 }
 
@@ -379,6 +680,9 @@ pub struct OneKvNodesRoutes {
     ///   nodes must not insert leased keys into moka caches.
     pub lease_id: Option<u64>,
 
+    /// Version-scoped multi-key group supplied by the put caller.
+    pub atomic_group: Option<Arc<PutAtomicGroup>>,
+
     /// node_id -> KvRouteInfo
     pub nodes_replicas: RwLock<HashMap<NodeID, KvRouteInfo>>,
     pub get_durable_slots_used: AtomicU32,
@@ -422,6 +726,464 @@ impl OneKvNodesRoutes {
     }
 }
 
+fn route_has_live_replica_on_node(route: &OneKvNodesRoutes, node_id: &str) -> bool {
+    route
+        .nodes_replicas
+        .read()
+        .iter()
+        .any(|(candidate, replica)| candidate.as_ref() == node_id && !replica.tomb_tag.is_tomb())
+}
+
+fn route_live_remote_cache_nodes(
+    view: &MasterKvRouterView,
+    route: &OneKvNodesRoutes,
+) -> HashSet<String> {
+    route
+        .nodes_replicas
+        .read()
+        .iter()
+        .filter_map(|(node_id, replica)| {
+            if replica.tomb_tag.is_tomb() {
+                return None;
+            }
+            let member = view
+                .cluster_manager()
+                .get_member_info_cached(node_id.as_ref());
+            placement::member_matches_roles(
+                member.as_ref(),
+                &view
+                    .master_kv_router()
+                    .inner()
+                    .replica_task_placement
+                    .remote_only_node_roles,
+            )
+            .then(|| node_id.as_ref().to_string())
+        })
+        .collect()
+}
+
+const MAX_INFERRED_TP_COHORT_SIZE: usize = 256;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct InferredTpKey<'a> {
+    pub(crate) logical_prefix: &'a str,
+    pub(crate) rank: usize,
+    pub(crate) size: usize,
+}
+
+/// Decode the canonical SGLang HiCache suffix `_<tp_rank>_<tp_size>`.
+///
+/// This is deliberately strict and is only used to make owner reclaim more
+/// conservative. A key that cannot be decoded keeps the existing non-TP
+/// behavior; a decoded TP key whose peer routes are absent or inconsistent is
+/// never considered recoverable.
+pub(crate) fn infer_sglang_tp_key(key: &str) -> Option<InferredTpKey<'_>> {
+    let (before_size, raw_size) = key.rsplit_once('_')?;
+    let (logical_prefix, raw_rank) = before_size.rsplit_once('_')?;
+    if logical_prefix.is_empty()
+        || raw_rank.is_empty()
+        || raw_size.is_empty()
+        || !raw_rank.bytes().all(|byte| byte.is_ascii_digit())
+        || !raw_size.bytes().all(|byte| byte.is_ascii_digit())
+    {
+        return None;
+    }
+    let rank = raw_rank.parse::<usize>().ok()?;
+    let size = raw_size.parse::<usize>().ok()?;
+    if size == 0
+        || size > MAX_INFERRED_TP_COHORT_SIZE
+        || rank >= size
+        || raw_rank != rank.to_string()
+        || raw_size != size.to_string()
+    {
+        return None;
+    }
+    Some(InferredTpKey {
+        logical_prefix,
+        rank,
+        size,
+    })
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum RecoverableReplicaStatus {
+    Recoverable,
+    RouteAbsent,
+    VersionChanged,
+    RouteIneligible,
+    CpuRouteAbsent,
+    AtomicGroupIncomplete,
+    TpCohortIncomplete,
+}
+
+fn recoverable_cohort_weight<F>(
+    expected_entries: &HashMap<String, NodeValueReplicaDesc>,
+    mut recoverable_status: F,
+) -> Option<u64>
+where
+    F: FnMut(&str, &NodeValueReplicaDesc) -> RecoverableReplicaStatus,
+{
+    let mut expected_weight = 0u64;
+    for (key, desc) in expected_entries {
+        if recoverable_status(key, desc) != RecoverableReplicaStatus::Recoverable {
+            return None;
+        }
+        expected_weight = expected_weight.checked_add(u64::from(desc.weight_bytes))?;
+    }
+    (expected_weight != 0).then_some(expected_weight)
+}
+
+impl EvictionReclaimCounters {
+    fn record_recoverable_first_status(&self, status: RecoverableReplicaStatus) {
+        let counter = match status {
+            RecoverableReplicaStatus::Recoverable => &self.recoverable_first_eligible_checks,
+            RecoverableReplicaStatus::RouteAbsent => &self.recoverable_first_route_absent_checks,
+            RecoverableReplicaStatus::VersionChanged => {
+                &self.recoverable_first_version_changed_checks
+            }
+            RecoverableReplicaStatus::RouteIneligible => {
+                &self.recoverable_first_route_ineligible_checks
+            }
+            RecoverableReplicaStatus::CpuRouteAbsent => {
+                &self.recoverable_first_cpu_route_absent_checks
+            }
+            RecoverableReplicaStatus::AtomicGroupIncomplete => {
+                &self.recoverable_first_atomic_group_incomplete_checks
+            }
+            RecoverableReplicaStatus::TpCohortIncomplete => {
+                &self.recoverable_first_tp_cohort_incomplete_checks
+            }
+        };
+        counter.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+fn current_atomic_group_members(
+    key: &str,
+    route: &OneKvNodesRoutes,
+    desc: &NodeValueReplicaDesc,
+) -> Result<Vec<msg_pack::PutAtomicGroupMember>, RecoverableReplicaStatus> {
+    let Some(group) = route.atomic_group.as_ref() else {
+        return Ok(vec![msg_pack::PutAtomicGroupMember {
+            key: key.to_string(),
+            put_id: desc.put_id,
+        }]);
+    };
+    if !group
+        .members
+        .iter()
+        .any(|member| member.key == key && member.put_id == desc.put_id)
+    {
+        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+    }
+    Ok(group.members.clone())
+}
+
+fn current_tp_cohort_keys(
+    key: &str,
+    route: &OneKvNodesRoutes,
+    desc: &NodeValueReplicaDesc,
+) -> Result<Vec<String>, RecoverableReplicaStatus> {
+    let current_members = current_atomic_group_members(key, route, desc)?;
+    let Some(key_tp) = infer_sglang_tp_key(key) else {
+        return Ok(current_members
+            .into_iter()
+            .map(|member| member.key)
+            .collect());
+    };
+    if key_tp.size == 1 {
+        return Ok(current_members
+            .into_iter()
+            .map(|member| member.key)
+            .collect());
+    }
+
+    let mut logical_members = Vec::with_capacity(current_members.len());
+    for member in current_members {
+        let Some(member_tp) = infer_sglang_tp_key(&member.key) else {
+            return Err(RecoverableReplicaStatus::TpCohortIncomplete);
+        };
+        if member_tp.rank != key_tp.rank || member_tp.size != key_tp.size {
+            return Err(RecoverableReplicaStatus::TpCohortIncomplete);
+        }
+        logical_members.push(member_tp.logical_prefix.to_string());
+    }
+
+    let mut cohort_keys = Vec::with_capacity(logical_members.len() * key_tp.size);
+    for rank in 0..key_tp.size {
+        cohort_keys.extend(
+            logical_members
+                .iter()
+                .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", key_tp.size)),
+        );
+    }
+    Ok(cohort_keys)
+}
+
+fn intersect_remote_nodes(
+    common_remote_nodes: &mut Option<HashSet<String>>,
+    mut member_remote_nodes: HashSet<String>,
+    owner_node_id: &str,
+) -> Result<(), RecoverableReplicaStatus> {
+    member_remote_nodes.remove(owner_node_id);
+    if member_remote_nodes.is_empty() {
+        return Err(RecoverableReplicaStatus::CpuRouteAbsent);
+    }
+    match common_remote_nodes.as_mut() {
+        Some(common) => common.retain(|node_id| member_remote_nodes.contains(node_id)),
+        None => *common_remote_nodes = Some(member_remote_nodes),
+    }
+    if common_remote_nodes.as_ref().is_some_and(HashSet::is_empty) {
+        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+    }
+    Ok(())
+}
+
+fn validate_recoverable_group(
+    owner_node_id: &str,
+    expected_keys: &[String],
+    expected_put_ids: Option<&[PutIDForAKey]>,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
+    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
+) -> Result<HashSet<String>, RecoverableReplicaStatus> {
+    if expected_put_ids.is_some_and(|put_ids| put_ids.len() != expected_keys.len()) {
+        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+    }
+    let Some(first_key) = expected_keys.first() else {
+        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+    };
+    let Some(first_route) = route_lookup(first_key) else {
+        return Err(RecoverableReplicaStatus::RouteAbsent);
+    };
+
+    if expected_keys.len() == 1 {
+        if expected_put_ids.is_some_and(|put_ids| first_route.put_id != put_ids[0]) {
+            return Err(RecoverableReplicaStatus::VersionChanged);
+        }
+        if first_route.lease_id.is_some() || first_route.atomic_group.is_some() {
+            return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+        }
+        let mut common_remote_nodes = None;
+        intersect_remote_nodes(
+            &mut common_remote_nodes,
+            live_remote_nodes(&first_route),
+            owner_node_id,
+        )?;
+        return common_remote_nodes.ok_or(RecoverableReplicaStatus::CpuRouteAbsent);
+    }
+
+    let Some(group) = first_route.atomic_group.as_ref() else {
+        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+    };
+    if group.members.len() != expected_keys.len()
+        || group
+            .members
+            .iter()
+            .zip(expected_keys)
+            .any(|(member, expected_key)| member.key != *expected_key)
+        || expected_put_ids.is_some_and(|put_ids| {
+            group
+                .members
+                .iter()
+                .zip(put_ids)
+                .any(|(member, expected_put_id)| member.put_id != *expected_put_id)
+        })
+    {
+        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+    }
+
+    let mut common_remote_nodes = None;
+    for member in &group.members {
+        let Some(member_route) = route_lookup(&member.key) else {
+            return Err(RecoverableReplicaStatus::RouteAbsent);
+        };
+        if member_route.put_id != member.put_id
+            || member_route.lease_id.is_some()
+            || member_route.atomic_group.as_deref() != Some(group.as_ref())
+        {
+            return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+        }
+        intersect_remote_nodes(
+            &mut common_remote_nodes,
+            live_remote_nodes(&member_route),
+            owner_node_id,
+        )?;
+    }
+    common_remote_nodes.ok_or(RecoverableReplicaStatus::CpuRouteAbsent)
+}
+
+fn validate_current_recoverable_group(
+    owner_node_id: &str,
+    route: &OneKvNodesRoutes,
+    current_members: &[msg_pack::PutAtomicGroupMember],
+    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
+    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
+) -> Result<HashSet<String>, RecoverableReplicaStatus> {
+    if current_members.len() == 1 {
+        let mut common_remote_nodes = None;
+        intersect_remote_nodes(
+            &mut common_remote_nodes,
+            live_remote_nodes(route),
+            owner_node_id,
+        )?;
+        return common_remote_nodes.ok_or(RecoverableReplicaStatus::CpuRouteAbsent);
+    }
+    let current_keys = current_members
+        .iter()
+        .map(|member| member.key.clone())
+        .collect::<Vec<_>>();
+    let current_put_ids = current_members
+        .iter()
+        .map(|member| member.put_id)
+        .collect::<Vec<_>>();
+    validate_recoverable_group(
+        owner_node_id,
+        &current_keys,
+        Some(&current_put_ids),
+        route_lookup,
+        live_remote_nodes,
+    )
+}
+
+fn route_recoverable_replica_status_with(
+    owner_node_id: &str,
+    key: &str,
+    route: &OneKvNodesRoutes,
+    desc: &NodeValueReplicaDesc,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
+    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
+) -> RecoverableReplicaStatus {
+    if route.put_id != desc.put_id {
+        return RecoverableReplicaStatus::VersionChanged;
+    }
+    if route.lease_id.is_some() || !route_has_live_replica_on_node(route, owner_node_id) {
+        return RecoverableReplicaStatus::RouteIneligible;
+    }
+
+    let current_members = match current_atomic_group_members(key, route, desc) {
+        Ok(members) => members,
+        Err(status) => return status,
+    };
+    let Some(key_tp) = infer_sglang_tp_key(key) else {
+        return match validate_current_recoverable_group(
+            owner_node_id,
+            route,
+            &current_members,
+            route_lookup,
+            live_remote_nodes,
+        ) {
+            Ok(_) => RecoverableReplicaStatus::Recoverable,
+            Err(status) => status,
+        };
+    };
+    if key_tp.size == 1 {
+        return match validate_current_recoverable_group(
+            owner_node_id,
+            route,
+            &current_members,
+            route_lookup,
+            live_remote_nodes,
+        ) {
+            Ok(_) => RecoverableReplicaStatus::Recoverable,
+            Err(status) => status,
+        };
+    }
+
+    let mut logical_members = Vec::with_capacity(current_members.len());
+    for member in &current_members {
+        let Some(member_tp) = infer_sglang_tp_key(&member.key) else {
+            return RecoverableReplicaStatus::TpCohortIncomplete;
+        };
+        if member_tp.rank != key_tp.rank || member_tp.size != key_tp.size {
+            return RecoverableReplicaStatus::TpCohortIncomplete;
+        }
+        logical_members.push(member_tp.logical_prefix.to_string());
+    }
+
+    let mut cohort_remote_nodes: Option<HashSet<String>> = None;
+    for rank in 0..key_tp.size {
+        let peer_keys = logical_members
+            .iter()
+            .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", key_tp.size))
+            .collect::<Vec<_>>();
+        let rank_result = if rank == key_tp.rank {
+            validate_current_recoverable_group(
+                owner_node_id,
+                route,
+                &current_members,
+                route_lookup,
+                live_remote_nodes,
+            )
+        } else {
+            validate_recoverable_group(
+                owner_node_id,
+                &peer_keys,
+                None,
+                route_lookup,
+                live_remote_nodes,
+            )
+        };
+        let rank_remote_nodes = match rank_result {
+            Ok(nodes) => nodes,
+            Err(_) => return RecoverableReplicaStatus::TpCohortIncomplete,
+        };
+        match cohort_remote_nodes.as_mut() {
+            Some(common) => common.retain(|node_id| rank_remote_nodes.contains(node_id)),
+            None => cohort_remote_nodes = Some(rank_remote_nodes),
+        }
+        if cohort_remote_nodes.as_ref().is_some_and(HashSet::is_empty) {
+            return RecoverableReplicaStatus::TpCohortIncomplete;
+        }
+    }
+    if cohort_remote_nodes.is_some_and(|nodes| !nodes.is_empty()) {
+        RecoverableReplicaStatus::Recoverable
+    } else {
+        RecoverableReplicaStatus::TpCohortIncomplete
+    }
+}
+
+#[cfg(test)]
+fn route_has_recoverable_replica_with(
+    owner_node_id: &str,
+    key: &str,
+    route: &OneKvNodesRoutes,
+    desc: &NodeValueReplicaDesc,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
+    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
+) -> bool {
+    route_recoverable_replica_status_with(
+        owner_node_id,
+        key,
+        route,
+        desc,
+        route_lookup,
+        live_remote_nodes,
+    ) == RecoverableReplicaStatus::Recoverable
+}
+
+fn route_recoverable_replica_status(
+    view: &MasterKvRouterView,
+    owner_node_id: &str,
+    key: &str,
+    route: &OneKvNodesRoutes,
+    desc: &NodeValueReplicaDesc,
+) -> RecoverableReplicaStatus {
+    route_recoverable_replica_status_with(
+        owner_node_id,
+        key,
+        route,
+        desc,
+        &|member_key| {
+            view.master_kv_router()
+                .inner()
+                .kv_routes
+                .get(member_key)
+                .map(|entry| entry.clone())
+        },
+        &|member_route| route_live_remote_cache_nodes(view, member_route),
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -433,6 +1195,7 @@ mod tests {
         let routes = OneKvNodesRoutes {
             put_id: (1, 0),
             lease_id: None,
+            atomic_group: None,
             nodes_replicas: RwLock::new(HashMap::new()),
             get_durable_slots_used: AtomicU32::new(0),
         };
@@ -445,6 +1208,509 @@ mod tests {
         assert!(routes.try_reserve_get_durable_slot());
     }
 
+    #[test]
+    fn reclaim_fence_is_atomic_with_all_master_key_activity() {
+        let table = Arc::new(MasterKeyActivityTable::default());
+        let item = OwnerReclaimItem {
+            key: "k".to_string(),
+            put_id: (7, 3),
+            epoch: 11,
+            backing: OwnerReclaimBacking::CommittedSlot {
+                grant_id: 13,
+                slot_index: 17,
+                slot_size: 8 * 1024 * 1024,
+            },
+            reason: OwnerReclaimReason::Reserve,
+        };
+
+        let get_lease = table
+            .reserve("k", MasterKeyActivityKind::Get, false)
+            .expect("get activity should be admitted before reclaim");
+        assert!(!table.is_quiescent("k"));
+        assert_eq!(
+            table.try_install_reclaim(&item),
+            Err(MasterKeyActivitySnapshot {
+                puts: 0,
+                gets: 1,
+                replicas: 0,
+                reclaim_installed: false,
+            })
+        );
+        drop(get_lease);
+
+        assert!(table.is_quiescent("k"));
+        assert!(table.try_install_reclaim(&item).is_ok());
+        assert!(!table.is_quiescent("k"));
+        assert!(table.has_reclaim("k"));
+        assert!(
+            table
+                .reserve("k", MasterKeyActivityKind::Put, false)
+                .is_none()
+        );
+        assert!(
+            table
+                .reserve("k", MasterKeyActivityKind::Get, false)
+                .is_none()
+        );
+        assert!(
+            table
+                .reserve("k", MasterKeyActivityKind::Replica, false)
+                .is_none()
+        );
+
+        assert!(table.clear_reclaim(&item));
+        assert!(!table.has_reclaim("k"));
+        assert!(
+            table
+                .reserve("k", MasterKeyActivityKind::Put, true)
+                .is_some()
+        );
+    }
+
+    #[test]
+    fn explicit_activity_completion_is_idempotent_with_retired_cache_clones() {
+        let table = Arc::new(MasterKeyActivityTable::default());
+        let lease = table
+            .reserve("retired-clone", MasterKeyActivityKind::Get, false)
+            .expect("get activity should be admitted");
+        let retired_cache_clone = lease.clone();
+
+        lease.release_now();
+        lease.release_now();
+        assert!(table.is_quiescent("retired-clone"));
+
+        drop(lease);
+        drop(retired_cache_clone);
+        assert!(table.is_quiescent("retired-clone"));
+    }
+
+    fn test_route_info(node_id: &str, tomb: bool) -> KvRouteInfo {
+        let tomb_tag = NodeTombTag::new();
+        if tomb {
+            tomb_tag.set_tomb();
+        }
+        KvRouteInfo {
+            node_id: node_id.to_string().into(),
+            backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                owner_node_id: node_id.to_string().into(),
+                grant_id: 1,
+                slot_index: 0,
+                slot_size: 1024,
+                addr: 0,
+                len: 1024,
+                base_addr: 0,
+            }),
+            owner_local_indexed: true,
+            tomb_tag,
+        }
+    }
+
+    fn test_route(
+        put_id: PutIDForAKey,
+        lease_id: Option<u64>,
+        replicas: Vec<(&str, bool)>,
+    ) -> OneKvNodesRoutes {
+        OneKvNodesRoutes {
+            put_id,
+            lease_id,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(
+                replicas
+                    .into_iter()
+                    .map(|(node_id, tomb)| {
+                        (node_id.to_string().into(), test_route_info(node_id, tomb))
+                    })
+                    .collect(),
+            ),
+            get_durable_slots_used: AtomicU32::new(0),
+        }
+    }
+
+    fn test_remote_nodes(route: &OneKvNodesRoutes) -> HashSet<String> {
+        route
+            .nodes_replicas
+            .read()
+            .iter()
+            .filter_map(|(node_id, replica)| {
+                (!replica.tomb_tag.is_tomb() && node_id.as_ref().starts_with("cpu"))
+                    .then(|| node_id.as_ref().to_string())
+            })
+            .collect()
+    }
+
+    #[test]
+    fn recoverable_route_requires_live_local_and_live_remote_cache_same_version() {
+        let desc = NodeValueReplicaDesc {
+            weight_bytes: 1024,
+            put_id: (7, 3),
+        };
+        let no_lookup = |_key: &str| None;
+        let recoverable = |route: &OneKvNodesRoutes| {
+            route_has_recoverable_replica_with(
+                "gpu0",
+                "k",
+                route,
+                &desc,
+                &no_lookup,
+                &test_remote_nodes,
+            )
+        };
+
+        let cpu_copy = test_route((7, 3), None, vec![("gpu0", false), ("cpu0", false)]);
+        assert!(recoverable(&cpu_copy));
+
+        let local_only = test_route((7, 3), None, vec![("gpu0", false)]);
+        assert!(!recoverable(&local_only));
+
+        let gpu_copy = test_route((7, 3), None, vec![("gpu0", false), ("gpu1", false)]);
+        assert!(!recoverable(&gpu_copy));
+
+        let remote_tomb = test_route((7, 3), None, vec![("gpu0", false), ("cpu0", true)]);
+        assert!(!recoverable(&remote_tomb));
+
+        let local_tomb = test_route((7, 3), None, vec![("gpu0", true), ("cpu0", false)]);
+        assert!(!recoverable(&local_tomb));
+
+        let stale = test_route((8, 0), None, vec![("gpu0", false), ("cpu0", false)]);
+        assert!(!recoverable(&stale));
+
+        let leased = test_route((7, 3), Some(11), vec![("gpu0", false), ("cpu0", false)]);
+        assert!(!recoverable(&leased));
+    }
+
+    #[test]
+    fn recoverable_atomic_group_requires_one_common_remote_cache_owner() {
+        let group = Arc::new(PutAtomicGroup {
+            members: vec![
+                msg_pack::PutAtomicGroupMember {
+                    key: "k0".to_string(),
+                    put_id: (7, 0),
+                },
+                msg_pack::PutAtomicGroupMember {
+                    key: "k1".to_string(),
+                    put_id: (7, 1),
+                },
+            ],
+        });
+        let make_route = |put_id, remote_node: Option<&str>| {
+            let mut replicas = vec![("gpu0", false)];
+            if let Some(remote_node) = remote_node {
+                replicas.push((remote_node, false));
+            }
+            let mut route = test_route(put_id, None, replicas);
+            route.atomic_group = Some(group.clone());
+            Arc::new(route)
+        };
+        let desc = NodeValueReplicaDesc {
+            weight_bytes: 1024,
+            put_id: (7, 0),
+        };
+
+        let k0 = make_route((7, 0), Some("cpu0"));
+        let k1 = make_route((7, 1), Some("cpu0"));
+        let routes = HashMap::from([("k0".to_string(), k0.clone()), ("k1".to_string(), k1)]);
+        assert!(route_has_recoverable_replica_with(
+            "gpu0",
+            "k0",
+            &k0,
+            &desc,
+            &|key| routes.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+
+        let split_k1 = make_route((7, 1), Some("cpu1"));
+        let split_routes =
+            HashMap::from([("k0".to_string(), k0.clone()), ("k1".to_string(), split_k1)]);
+        assert!(!route_has_recoverable_replica_with(
+            "gpu0",
+            "k0",
+            &k0,
+            &desc,
+            &|key| split_routes.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+
+        let partial_k1 = make_route((7, 1), None);
+        let partial_routes = HashMap::from([
+            ("k0".to_string(), k0.clone()),
+            ("k1".to_string(), partial_k1),
+        ]);
+        assert!(!route_has_recoverable_replica_with(
+            "gpu0",
+            "k0",
+            &k0,
+            &desc,
+            &|key| partial_routes.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+    }
+
+    #[test]
+    fn infer_sglang_tp_key_accepts_only_canonical_suffix() {
+        assert_eq!(
+            infer_sglang_tp_key("prefix:page_model_1_2"),
+            Some(InferredTpKey {
+                logical_prefix: "prefix:page_model",
+                rank: 1,
+                size: 2,
+            })
+        );
+        assert!(infer_sglang_tp_key("prefix:page_model_2_2").is_none());
+        assert!(infer_sglang_tp_key("prefix:page_model_01_2").is_none());
+        assert!(infer_sglang_tp_key("prefix:page_model_x_2").is_none());
+        assert!(infer_sglang_tp_key("prefix:page_model_0_0").is_none());
+    }
+
+    #[test]
+    fn recoverable_atomic_group_requires_complete_tp_cohort_on_one_cpu_owner() {
+        let rank0_group = Arc::new(PutAtomicGroup {
+            members: vec![
+                msg_pack::PutAtomicGroupMember {
+                    key: "page0_model_0_2".to_string(),
+                    put_id: (10, 0),
+                },
+                msg_pack::PutAtomicGroupMember {
+                    key: "page1_model_0_2".to_string(),
+                    put_id: (10, 1),
+                },
+            ],
+        });
+        let rank1_group = Arc::new(PutAtomicGroup {
+            members: vec![
+                msg_pack::PutAtomicGroupMember {
+                    key: "page0_model_1_2".to_string(),
+                    put_id: (11, 0),
+                },
+                msg_pack::PutAtomicGroupMember {
+                    key: "page1_model_1_2".to_string(),
+                    put_id: (11, 1),
+                },
+            ],
+        });
+        let make_route = |put_id, group: Arc<PutAtomicGroup>, remote_node: Option<&str>| {
+            let mut replicas = vec![("gpu0", false)];
+            if let Some(remote_node) = remote_node {
+                replicas.push((remote_node, false));
+            }
+            let mut route = test_route(put_id, None, replicas);
+            route.atomic_group = Some(group);
+            Arc::new(route)
+        };
+        let rank0_page0 = make_route((10, 0), rank0_group.clone(), Some("cpu0"));
+        let rank0_page1 = make_route((10, 1), rank0_group.clone(), Some("cpu0"));
+        let rank1_page0 = make_route((11, 0), rank1_group.clone(), Some("cpu0"));
+        let rank1_page1 = make_route((11, 1), rank1_group.clone(), Some("cpu0"));
+        let routes = HashMap::from([
+            ("page0_model_0_2".to_string(), rank0_page0.clone()),
+            ("page1_model_0_2".to_string(), rank0_page1),
+            ("page0_model_1_2".to_string(), rank1_page0),
+            ("page1_model_1_2".to_string(), rank1_page1),
+        ]);
+        let desc = NodeValueReplicaDesc {
+            weight_bytes: 1024,
+            put_id: (10, 0),
+        };
+        assert_eq!(
+            current_tp_cohort_keys("page0_model_0_2", &rank0_page0, &desc).unwrap(),
+            vec![
+                "page0_model_0_2",
+                "page1_model_0_2",
+                "page0_model_1_2",
+                "page1_model_1_2",
+            ]
+        );
+        assert!(route_has_recoverable_replica_with(
+            "gpu0",
+            "page0_model_0_2",
+            &rank0_page0,
+            &desc,
+            &|key| routes.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+
+        let missing_peer_routes = routes
+            .iter()
+            .filter(|(key, _)| key.as_str() != "page1_model_1_2")
+            .map(|(key, route)| (key.clone(), route.clone()))
+            .collect::<HashMap<_, _>>();
+        assert_eq!(
+            route_recoverable_replica_status_with(
+                "gpu0",
+                "page0_model_0_2",
+                &rank0_page0,
+                &desc,
+                &|key| missing_peer_routes.get(key).cloned(),
+                &test_remote_nodes,
+            ),
+            RecoverableReplicaStatus::TpCohortIncomplete
+        );
+
+        let rank1_page0_cpu1 = make_route((11, 0), rank1_group.clone(), Some("cpu1"));
+        let rank1_page1_cpu1 = make_route((11, 1), rank1_group, Some("cpu1"));
+        let split_cpu_routes = routes
+            .iter()
+            .map(|(key, route)| (key.clone(), route.clone()))
+            .chain([
+                ("page0_model_1_2".to_string(), rank1_page0_cpu1),
+                ("page1_model_1_2".to_string(), rank1_page1_cpu1),
+            ])
+            .collect::<HashMap<_, _>>();
+        assert!(!route_has_recoverable_replica_with(
+            "gpu0",
+            "page0_model_0_2",
+            &rank0_page0,
+            &desc,
+            &|key| split_cpu_routes.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+    }
+
+    #[test]
+    fn recoverable_single_page_requires_all_tp_ranks() {
+        let rank0 = Arc::new(test_route(
+            (20, 0),
+            None,
+            vec![("gpu0", false), ("cpu0", false)],
+        ));
+        let rank1 = Arc::new(test_route(
+            (21, 0),
+            None,
+            vec![("gpu0", false), ("cpu0", false)],
+        ));
+        let desc = NodeValueReplicaDesc {
+            weight_bytes: 1024,
+            put_id: (20, 0),
+        };
+        let complete = HashMap::from([
+            ("page_model_0_2".to_string(), rank0.clone()),
+            ("page_model_1_2".to_string(), rank1),
+        ]);
+        assert!(route_has_recoverable_replica_with(
+            "gpu0",
+            "page_model_0_2",
+            &rank0,
+            &desc,
+            &|key| complete.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+
+        let rank0_only = HashMap::from([("page_model_0_2".to_string(), rank0.clone())]);
+        assert!(!route_has_recoverable_replica_with(
+            "gpu0",
+            "page_model_0_2",
+            &rank0,
+            &desc,
+            &|key| rank0_only.get(key).cloned(),
+            &test_remote_nodes,
+        ));
+    }
+
+    #[test]
+    fn owner_hot_demotion_rejects_the_whole_cohort_before_moka_selection() {
+        let expected_entries = HashMap::from([
+            (
+                "rank0".to_string(),
+                NodeValueReplicaDesc {
+                    weight_bytes: 1024,
+                    put_id: (30, 0),
+                },
+            ),
+            (
+                "rank1".to_string(),
+                NodeValueReplicaDesc {
+                    weight_bytes: 1024,
+                    put_id: (31, 0),
+                },
+            ),
+        ]);
+        let cache = moka::sync::SegmentedCache::builder(8)
+            .weigher(Box::new(|_key: &String, desc: &NodeValueReplicaDesc| {
+                desc.weight_bytes
+            }))
+            .build();
+        for (key, desc) in &expected_entries {
+            cache.insert(key.clone(), desc.clone());
+        }
+        cache.run_pending_tasks();
+
+        let selected_weight = recoverable_cohort_weight(&expected_entries, |key, _desc| {
+            if key == "rank0" {
+                RecoverableReplicaStatus::Recoverable
+            } else {
+                RecoverableReplicaStatus::TpCohortIncomplete
+            }
+        })
+        .map_or(0, |expected_weight| {
+            cache.evict_some_if(expected_weight, |candidate_key, candidate_desc| {
+                expected_entries.get(candidate_key).is_some_and(|expected| {
+                    expected.put_id == candidate_desc.put_id
+                        && expected.weight_bytes == candidate_desc.weight_bytes
+                })
+            })
+        });
+
+        assert_eq!(selected_weight, 0);
+        assert!(cache.get("rank0").is_some());
+        assert!(cache.get("rank1").is_some());
+    }
+
+    #[test]
+    fn unrecoverable_fallback_is_only_for_last_level_or_no_remote_tier() {
+        assert!(allow_unrecoverable_cache_eviction(
+            false,
+            false,
+            UnrecoverableCacheEvictionContext::NormalCapacity,
+        ));
+        assert!(!allow_unrecoverable_cache_eviction(
+            false,
+            true,
+            UnrecoverableCacheEvictionContext::NormalCapacity,
+        ));
+        assert!(allow_unrecoverable_cache_eviction(
+            true,
+            true,
+            UnrecoverableCacheEvictionContext::NormalCapacity,
+        ));
+        assert!(allow_unrecoverable_cache_eviction(
+            false,
+            true,
+            UnrecoverableCacheEvictionContext::OwnerLocalReserveNoSpace,
+        ));
+    }
+
+    #[test]
+    fn unbounded_segmented_metadata_cache_only_evicts_when_requested() {
+        let cache = moka::sync::SegmentedCache::builder(8)
+            .weigher(Box::new(|_key: &u64, weight: &u32| *weight))
+            .build();
+        assert_eq!(cache.policy().max_capacity(), None);
+
+        for key in 0..128 {
+            cache.insert(key, 8);
+        }
+        cache.run_pending_tasks();
+        assert_eq!(cache.weighted_size(), 1024);
+
+        let evicted = cache.evict_some_if(64, |_key, _weight| true);
+        assert!(evicted >= 64);
+        assert_eq!(cache.weighted_size(), 1024 - evicted);
+    }
+
+    #[test]
+    fn synchronous_restore_re_eviction_keeps_new_pending_weight() {
+        let weight = 8 * 1024 * 1024;
+        let pending = AtomicU64::new(weight);
+
+        // A synchronous Moka Size listener enqueues the restored entry again before the old
+        // request completes. Completing the old request must leave exactly the new request.
+        pending.fetch_add(weight, Ordering::AcqRel);
+        subtract_pending_eviction_weight(&pending, "owner", weight);
+        assert_eq!(pending.load(Ordering::Acquire), weight);
+
+        subtract_pending_eviction_weight(&pending, "owner", weight);
+        assert_eq!(pending.load(Ordering::Acquire), 0);
+    }
+
     fn new_test_member(metadata: HashMap<String, String>) -> ClusterMember {
         ClusterMember {
             id: "node-a".to_string(),
@@ -488,6 +1754,33 @@ mod tests {
             &side_worker
         ));
     }
+
+    #[test]
+    fn tier1_source_accepts_gpu_owner_role_and_rejects_remote_cache() {
+        let placement_config = ReplicaTaskPlacementConfig::default();
+
+        // This is the production GPU-owner shape: it deliberately does not match the
+        // prefill/decode roles carried by the associated zero-contribution client.
+        let gpu_owner = new_test_member(HashMap::from([
+            ("client".to_string(), "true".to_string()),
+            ("p2p_relay".to_string(), "true".to_string()),
+        ]));
+        assert!(MasterKvRouter::tier1_source_member_eligible(
+            Some(&gpu_owner),
+            &placement_config,
+        ));
+
+        let mut remote_cache = gpu_owner.clone();
+        remote_cache.sub_cluster = Some("remote_cache".to_string());
+        assert!(!MasterKvRouter::tier1_source_member_eligible(
+            Some(&remote_cache),
+            &placement_config,
+        ));
+        assert!(!MasterKvRouter::tier1_source_member_eligible(
+            None,
+            &placement_config,
+        ));
+    }
 }
 
 pub struct MasterKvRouterInner {
@@ -495,13 +1788,14 @@ pub struct MasterKvRouterInner {
     pub policy: Box<dyn PlacementPolicy>,
     test_spec_config: TestSpecConfig,
     pub replica_task_placement: ReplicaTaskPlacementConfig,
+    replica_cache_capacity_ratio: f64,
+    replica_writeback_tier1_capacity_ratio: Option<f64>,
 
     /// (key, put_time_ms, put_version) -> inflight_put_info
     pub inflight_puts: moka::future::Cache<(String, u64, u32), InflightPutInfo>,
     pub inflight_replica_tasks: moka::future::Cache<(String, u64, u32), InflightReplicaTaskInfo>,
-    /// key -> inflight put count
-    pub inflight_put_key_counts: Arc<DashMap<String, u32>>,
     pub inflight_gets: moka::future::Cache<u64, InflightGetInfo>,
+    pub(crate) key_activity: Arc<MasterKeyActivityTable>,
 
     /// Cache for holding get operations (owned, flattened by (node_id, holder_id))
     pub get_holding: MasterOwnerMemMgr,
@@ -518,9 +1812,15 @@ pub struct MasterKvRouterInner {
     /// Counter for prepared put-key reservation identifiers.
     pub next_prepared_put_key_reservation_id: AtomicU64,
 
+    /// Counter for two-sided owner reclaim epochs.
+    pub next_owner_reclaim_epoch: AtomicU64,
+
     /// Latest version of key-value replicas
     pub kv_routes: DashMap<String, Arc<OneKvNodesRoutes>>,
 
+    /// Interns recent multi-key put groups so all member routes share one descriptor.
+    put_atomic_groups: moka::sync::SegmentedCache<(String, u64, u32), Arc<PutAtomicGroup>>,
+
     /// Serializes route-level existence checks with cache-eviction route cleanup.
     /// This protects route metadata consistency only; it does not create MemHolders
     /// or move payload data.
@@ -539,11 +1839,28 @@ pub struct MasterKvRouterInner {
     pub node_kv_cache_controller:
         DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
 
+    /// Inclusive hot tier. L1 eviction starts a remote-only replica task while the owner copy
+    /// remains governed by `node_kv_cache_controller` at its unchanged resident capacity.
+    pub node_writeback_tier1_controller:
+        DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
+
     /// Per-node bytes reserved out of moka usable capacity.
     /// The reservation is reason-grouped, but `total_bytes` is the authority
     /// used to derive the effective moka max_capacity for the node.
     pub node_cache_reserved_capacity: DashMap<NodeIDString, Arc<NodeCacheReservedCapacity>>,
 
+    /// Moka weight already removed and queued for owner-side safe reclaim.
+    pub eviction_reclaim_pending_weight: DashMap<NodeIDString, Arc<AtomicU64>>,
+
+    /// Per-owner reclaim lifecycle counters. These distinguish transient holder/activity
+    /// deferrals from terminal route changes and bounded retry restoration.
+    pub(crate) eviction_reclaim_counters: DashMap<NodeIDString, Arc<EvictionReclaimCounters>>,
+
+    /// Serializes all append completions for one logical TP/atomic cohort. Without this lock,
+    /// several member completions can pass the recoverability precheck together and concurrently
+    /// select overlapping subsets from Moka.
+    owner_hot_demotion_locks: AMapLock<String>,
+
     /// Historical final put placement decisions by target node.
     pub put_target_decision_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
 
@@ -556,10 +1873,25 @@ pub struct MasterKvRouterInner {
     /// Historical accepted replica task reservations by target node.
     pub replica_task_target_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
 
+    /// Historical get source choices by requester->source pair.
+    pub get_requester_source_counts: DashMap<RequesterTargetPair, Arc<AtomicU64>>,
+    pub get_requester_source_bytes: DashMap<RequesterTargetPair, Arc<AtomicU64>>,
+    pub get_allocation_mode_counts: DashMap<&'static str, Arc<AtomicU64>>,
+
     /// Support replicas: key -> version_id
     recent_key_versionid_allocator: moka::sync::SegmentedCache<String, Arc<AtomicU32>>,
 
     pub delete_broadcast: EnsureMemholderMgmtDeleteHandle<DeleteKeyInfo>,
+    post_route_maintenance_tx: ampsc::Sender<route_maintenance::RoutePublishEvent>,
+    post_route_maintenance_rx: Mutex<Option<ampsc::Receiver<route_maintenance::RoutePublishEvent>>>,
+    eviction_reclaim_tx: ampsc::Sender<reclaim::EvictionReclaimRequest>,
+    eviction_reclaim_rx: Mutex<Option<ampsc::Receiver<reclaim::EvictionReclaimRequest>>>,
+    tier1_writeback_tx: ampsc::Sender<tiered_writeback::Tier1WritebackRequest>,
+    tier1_writeback_rx: Mutex<Option<ampsc::Receiver<tiered_writeback::Tier1WritebackRequest>>>,
+    tier1_writeback_dedupe: moka::sync::SegmentedCache<(String, u64, u32), ()>,
+    tier1_writeback_trigger_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
+    tier1_writeback_owner_accepted_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
+    tier1_writeback_failed_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
 }
 
 impl MasterKvRouterInner {
@@ -645,16 +1977,16 @@ impl MasterKvRouter {
         } else {
             INFLIGHT_PUT_TTL_SECONDS
         };
-        let inflight_put_key_counts: Arc<DashMap<String, u32>> = Arc::new(DashMap::new());
-        let inflight_put_key_counts_for_listener = inflight_put_key_counts.clone();
+        let key_activity = Arc::new(MasterKeyActivityTable::default());
         let inflight_puts = moka::future::Cache::builder()
             .time_to_live(Duration::from_secs(inflight_put_ttl_seconds))
-            .eviction_listener(move |_put_id, inflight_info: InflightPutInfo, cause| {
+            .eviction_listener(|_put_id, inflight_info: InflightPutInfo, cause| {
                 if cause == RemovalCause::Expired {
-                    MasterKvRouter::release_inflight_put_key_count_map(
-                        &inflight_put_key_counts_for_listener,
-                        &inflight_info.key,
-                    );
+                    inflight_info._activity_lease.release_now();
+                    if let Some(replica_target) = inflight_info.commit_info.replica_target.as_ref()
+                    {
+                        replica_target._activity_lease.release_now();
+                    }
                 }
             })
             .build();
@@ -663,43 +1995,81 @@ impl MasterKvRouter {
             .eviction_listener(|_get_id, inflight_info: InflightGetInfo, cause| {
                 if cause == RemovalCause::Expired {
                     inflight_info.release_durable_slot_if_needed();
+                    inflight_info._activity_lease.release_now();
                 }
             })
             .build();
         let inflight_replica_tasks = moka::future::Cache::builder()
             .time_to_live(Duration::from_secs(60))
+            .eviction_listener(|_put_id, inflight_info: InflightReplicaTaskInfo, cause| {
+                if cause == RemovalCause::Expired {
+                    inflight_info._activity_lease.release_now();
+                }
+            })
             .build();
+        let (eviction_reclaim_tx, eviction_reclaim_rx) =
+            ampsc::channel(EVICTION_RECLAIM_QUEUE_CAPACITY);
+        let (post_route_maintenance_tx, post_route_maintenance_rx) =
+            ampsc::channel(POST_ROUTE_MAINTENANCE_QUEUE_CAPACITY);
+        let (tier1_writeback_tx, tier1_writeback_rx) =
+            ampsc::channel(TIER1_WRITEBACK_QUEUE_CAPACITY);
         let inner = MasterKvRouterInner {
             view: std::sync::OnceLock::new(),
             policy: policy_impl,
             test_spec_config: arg.test_spec_config,
             replica_task_placement: arg.replica_task_placement,
+            replica_cache_capacity_ratio: arg.replica_cache_capacity_ratio,
+            replica_writeback_tier1_capacity_ratio: arg.replica_writeback_tier1_capacity_ratio,
             inflight_puts,
             inflight_replica_tasks,
-            inflight_put_key_counts,
             inflight_gets,
+            key_activity,
             get_holding: MasterOwnerMemMgr::default(),
             next_get_id: AtomicU64::new(0),
             next_holder_id: AtomicU64::new(0),
             next_local_reserve_grant_id: AtomicU64::new(1),
             next_prepared_put_key_reservation_id: AtomicU64::new(1),
+            next_owner_reclaim_epoch: AtomicU64::new(1),
             kv_routes: DashMap::new(),
+            put_atomic_groups: moka::sync::SegmentedCache::builder(8)
+                .max_capacity(262_144)
+                .time_to_idle(Duration::from_secs(30 * 60))
+                .build(),
             route_lifetime_lock: Mutex::new(()),
             local_reserve_grants: DashMap::new(),
             prepared_put_key_reservations: DashMap::new(),
             prefix_index: ARwLock::new(PrefixRadixTree::new()),
             node_kv_cache_controller: DashMap::new(),
+            node_writeback_tier1_controller: DashMap::new(),
             node_cache_reserved_capacity: DashMap::new(),
+            eviction_reclaim_pending_weight: DashMap::new(),
+            eviction_reclaim_counters: DashMap::new(),
+            owner_hot_demotion_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             put_target_decision_counts: DashMap::new(),
             put_requester_target_decision_counts: DashMap::new(),
             put_placement_mode_counts: DashMap::new(),
             replica_task_target_counts: DashMap::new(),
+            get_requester_source_counts: DashMap::new(),
+            get_requester_source_bytes: DashMap::new(),
+            get_allocation_mode_counts: DashMap::new(),
             recent_key_versionid_allocator: moka::sync::SegmentedCache::builder(8)
                 .time_to_idle(Duration::from_secs(5))
                 .build(),
             delete_broadcast: EnsureMemholderMgmtDeleteHandle::new(
                 MasterOwnerMemMgr::DELETE_SUBMIT_QUEUE_CAPACITY,
             ),
+            post_route_maintenance_tx,
+            post_route_maintenance_rx: Mutex::new(Some(post_route_maintenance_rx)),
+            eviction_reclaim_tx,
+            eviction_reclaim_rx: Mutex::new(Some(eviction_reclaim_rx)),
+            tier1_writeback_tx,
+            tier1_writeback_rx: Mutex::new(Some(tier1_writeback_rx)),
+            tier1_writeback_dedupe: moka::sync::SegmentedCache::builder(8)
+                .time_to_live(Duration::from_secs(60))
+                .build(),
+            tier1_writeback_trigger_counts: DashMap::new(),
+            tier1_writeback_owner_accepted_counts: DashMap::new(),
+            tier1_writeback_failed_counts: DashMap::new(),
         };
         Ok(Self(inner))
     }
@@ -720,6 +2090,27 @@ impl MasterKvRouter {
             .take_rx()
             .expect("delete_broadcast rx already taken, that's impossible");
         delete::spawn_delete_broadcast(view, delete_broadcast_rx);
+        if let Some(post_route_maintenance_rx) = self.0.post_route_maintenance_rx.lock().take() {
+            route_maintenance::spawn_post_route_maintenance_actor(
+                self.0.view().clone(),
+                post_route_maintenance_rx,
+            );
+        } else {
+            warn!("post_route_maintenance_rx already taken for MasterKvRouter");
+        }
+        if let Some(eviction_reclaim_rx) = self.0.eviction_reclaim_rx.lock().take() {
+            reclaim::spawn_eviction_reclaim_actor(self.0.view().clone(), eviction_reclaim_rx);
+        } else {
+            warn!("eviction_reclaim_rx already taken for MasterKvRouter");
+        }
+        if let Some(tier1_writeback_rx) = self.0.tier1_writeback_rx.lock().take() {
+            tiered_writeback::spawn_tier1_writeback_actor(
+                self.0.view().clone(),
+                tier1_writeback_rx,
+            );
+        } else {
+            warn!("tier1_writeback_rx already taken for MasterKvRouter");
+        }
         Ok(())
     }
 
@@ -731,6 +2122,86 @@ impl MasterKvRouter {
         &self.0
     }
 
+    fn replica_cache_base_capacity(&self, node_space_size: u64) -> u64 {
+        (node_space_size as f64 * self.inner().replica_cache_capacity_ratio).floor() as u64
+    }
+
+    fn replica_cache_effective_capacity(&self, node_id: &str, node_space_size: u64) -> u64 {
+        let reserved_capacity = self
+            .inner()
+            .node_cache_reserved_capacity
+            .get(node_id)
+            .map(|reserved| reserved.total_reserved_bytes())
+            .unwrap_or(0);
+        self.replica_cache_base_capacity(node_space_size)
+            .saturating_sub(reserved_capacity)
+    }
+
+    fn owner_cache_allows_unrecoverable_eviction_in_context(
+        &self,
+        owner_node_id: &str,
+        context: UnrecoverableCacheEvictionContext,
+    ) -> bool {
+        let remote_only_roles = &self.inner().replica_task_placement.remote_only_node_roles;
+        let owner = self
+            .inner()
+            .view()
+            .cluster_manager()
+            .get_member_info_cached(owner_node_id);
+        let owner_is_remote_only =
+            placement::member_matches_roles(owner.as_ref(), remote_only_roles);
+        let has_ready_remote_only_owner = self
+            .inner()
+            .view()
+            .cluster_manager()
+            .get_members()
+            .into_iter()
+            .any(|member| {
+                placement::member_matches_roles(Some(&member), remote_only_roles)
+                    && self
+                        .inner()
+                        .view()
+                        .master_seg_manager()
+                        .get_node_space_size(member.id.as_str())
+                        != 0
+            });
+        allow_unrecoverable_cache_eviction(
+            owner_is_remote_only,
+            has_ready_remote_only_owner,
+            context,
+        )
+    }
+
+    pub(crate) fn owner_cache_allows_unrecoverable_eviction(&self, owner_node_id: &str) -> bool {
+        self.owner_cache_allows_unrecoverable_eviction_in_context(
+            owner_node_id,
+            UnrecoverableCacheEvictionContext::NormalCapacity,
+        )
+    }
+
+    pub(crate) fn owner_cache_allows_unrecoverable_reserve_pressure_eviction(
+        &self,
+        owner_node_id: &str,
+    ) -> bool {
+        self.owner_cache_allows_unrecoverable_eviction_in_context(
+            owner_node_id,
+            UnrecoverableCacheEvictionContext::OwnerLocalReserveNoSpace,
+        )
+    }
+
+    fn writeback_tier1_base_capacity(&self, node_space_size: u64) -> Option<u64> {
+        self.inner()
+            .replica_writeback_tier1_capacity_ratio
+            .map(|ratio| (node_space_size as f64 * ratio).floor() as u64)
+    }
+
+    pub fn tiered_writeback_enabled(&self) -> bool {
+        self.inner()
+            .replica_writeback_tier1_capacity_ratio
+            .is_some()
+            && self.replica_cache_enabled()
+    }
+
     pub fn replica_cache_enabled(&self) -> bool {
         !self.0.test_spec_config.disable_master_replica_cache
     }
@@ -753,63 +2224,531 @@ impl MasterKvRouter {
         (put_time_ms, put_version)
     }
 
-    fn release_inflight_put_key_count_map(counts: &DashMap<String, u32>, key: &str) {
-        if let Some(mut entry) = counts.get_mut(key) {
-            if *entry <= 1 {
-                drop(entry);
-                counts.remove(key);
-            } else {
-                *entry -= 1;
+    pub(crate) fn reserve_inflight_put_key(
+        &self,
+        key: &str,
+        reject_if_inflight_same_key: bool,
+        reject_if_exist_same_key: bool,
+    ) -> Result<Arc<MasterKeyActivityLease>, KvError> {
+        if reject_if_exist_same_key && self.key_has_live_replica(key) {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyAlreadyExists {
+                    key: key.to_string(),
+                },
+            ));
+        }
+        self.inner()
+            .key_activity
+            .reserve(key, MasterKeyActivityKind::Put, reject_if_inflight_same_key)
+            .ok_or_else(|| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyBeingWritten {
+                        key: key.to_string(),
+                    },
+                )
+            })
+    }
+
+    pub(crate) fn reserve_inflight_get_key(
+        &self,
+        key: &str,
+    ) -> Result<Arc<MasterKeyActivityLease>, KvError> {
+        self.inner()
+            .key_activity
+            .reserve(key, MasterKeyActivityKind::Get, false)
+            .ok_or_else(|| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyNotFound {
+                        key: key.to_string(),
+                    },
+                )
+            })
+    }
+
+    pub(crate) fn reserve_inflight_replica_key(
+        &self,
+        key: &str,
+    ) -> Result<Arc<MasterKeyActivityLease>, KvError> {
+        self.inner()
+            .key_activity
+            .reserve(key, MasterKeyActivityKind::Replica, false)
+            .ok_or_else(|| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyBeingWritten {
+                        key: key.to_string(),
+                    },
+                )
+            })
+    }
+
+    pub fn key_has_live_replica(&self, key: &str) -> bool {
+        self.inner()
+            .kv_routes
+            .get(key)
+            .map(|one_kv_nodes_routes| {
+                one_kv_nodes_routes
+                    .nodes_replicas
+                    .read()
+                    .values()
+                    .any(|kv_info| !kv_info.tomb_tag.is_tomb())
+            })
+            .unwrap_or(false)
+    }
+
+    pub(crate) fn resolve_put_atomic_group(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        group: Option<PutAtomicGroup>,
+    ) -> Result<Option<Arc<PutAtomicGroup>>, KvError> {
+        let Some(group) = group else {
+            return Ok(None);
+        };
+        if !(2..=4096).contains(&group.members.len()) {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                    detail: format!(
+                        "put atomic group must contain 2..=4096 members; got={}",
+                        group.members.len()
+                    ),
+                },
+            ));
+        }
+        let mut keys = HashSet::with_capacity(group.members.len());
+        let mut current_member_count = 0usize;
+        for member in &group.members {
+            if member.key.is_empty() || !keys.insert(member.key.as_str()) {
+                return Err(KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                        detail: "put atomic group member keys must be non-empty and unique"
+                            .to_string(),
+                    },
+                ));
+            }
+            if member.key == key && member.put_id == put_id {
+                current_member_count += 1;
             }
         }
+        if current_member_count != 1 {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                    detail: format!(
+                        "put atomic group must contain current member exactly once: key={} put_id=({},{}) count={}",
+                        key, put_id.0, put_id.1, current_member_count
+                    ),
+                },
+            ));
+        }
+
+        let anchor = group
+            .members
+            .first()
+            .expect("validated non-empty put atomic group");
+        let cache_key = (anchor.key.clone(), anchor.put_id.0, anchor.put_id.1);
+        if let Some(existing) = self.inner().put_atomic_groups.get(&cache_key) {
+            if existing.as_ref() != &group {
+                return Err(KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                        detail: format!(
+                            "put atomic group anchor was reused with different membership: anchor_key={} anchor_put_id=({},{})",
+                            anchor.key, anchor.put_id.0, anchor.put_id.1
+                        ),
+                    },
+                ));
+            }
+            return Ok(Some(existing));
+        }
+        let group = Arc::new(group);
+        self.inner()
+            .put_atomic_groups
+            .insert(cache_key, group.clone());
+        Ok(Some(group))
+    }
+
+    pub(crate) fn next_owner_reclaim_epoch(&self) -> u64 {
+        self.inner()
+            .next_owner_reclaim_epoch
+            .fetch_add(1, Ordering::Relaxed)
+    }
+
+    fn enqueue_eviction_reclaim(
+        &self,
+        owner_node_id: NodeIDString,
+        key: String,
+        desc: NodeValueReplicaDesc,
+    ) {
+        let weight_bytes = desc.weight_bytes;
+        let pending_weight = self
+            .inner()
+            .eviction_reclaim_pending_weight
+            .entry(owner_node_id.clone())
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .clone();
+        pending_weight.fetch_add(u64::from(weight_bytes), Ordering::AcqRel);
+        let request = reclaim::EvictionReclaimRequest {
+            owner_node_id,
+            key,
+            desc,
+            retry_count: 0,
+        };
+        if let Err(err) = self.inner().eviction_reclaim_tx.try_send(request) {
+            let queue_error = err.to_string();
+            let request = err.into_inner();
+            subtract_pending_eviction_weight(
+                pending_weight.as_ref(),
+                request.owner_node_id.as_str(),
+                u64::from(weight_bytes),
+            );
+            let restored = self.restore_eviction_cache_entry_if_current(
+                request.owner_node_id.as_str(),
+                request.key,
+                request.desc,
+            );
+            warn!(
+                "safe eviction reclaim queue is full or closed: {}; restored={}",
+                queue_error, restored
+            );
+        }
+    }
+
+    pub(crate) fn eviction_reclaim_pending_weight(&self, owner_node_id: &str) -> u64 {
+        self.inner()
+            .eviction_reclaim_pending_weight
+            .get(owner_node_id)
+            .map(|weight| weight.load(Ordering::Acquire))
+            .unwrap_or(0)
+    }
+
+    pub(crate) fn eviction_reclaim_counters(
+        &self,
+        owner_node_id: &str,
+    ) -> Arc<EvictionReclaimCounters> {
+        self.inner()
+            .eviction_reclaim_counters
+            .entry(owner_node_id.to_string())
+            .or_insert_with(|| Arc::new(EvictionReclaimCounters::default()))
+            .value()
+            .clone()
+    }
+
+    pub(crate) fn complete_eviction_reclaim_weight(
+        &self,
+        owner_node_id: &str,
+        completed_weight: u64,
+    ) {
+        if completed_weight == 0 {
+            return;
+        }
+        let pending_weight = self
+            .inner()
+            .eviction_reclaim_pending_weight
+            .get(owner_node_id)
+            .unwrap_or_else(|| {
+                panic!(
+                    "eviction reclaim pending weight missing for owner {}",
+                    owner_node_id
+                )
+            });
+        subtract_pending_eviction_weight(
+            pending_weight.value().as_ref(),
+            owner_node_id,
+            completed_weight,
+        );
+    }
+
+    pub(crate) fn restore_eviction_cache_entry_if_current(
+        &self,
+        owner_node_id: &str,
+        key: String,
+        desc: NodeValueReplicaDesc,
+    ) -> bool {
+        if !self.eviction_cache_entry_is_current(owner_node_id, &key, &desc) {
+            return false;
+        }
+        self.insert_node_cache_entry(owner_node_id, key, desc)
+    }
+
+    pub(crate) fn eviction_cache_entry_is_current(
+        &self,
+        owner_node_id: &str,
+        key: &str,
+        desc: &NodeValueReplicaDesc,
+    ) -> bool {
+        self.inner().kv_routes.get(key).is_some_and(|route| {
+            route.put_id == desc.put_id
+                && route.lease_id.is_none()
+                && route
+                    .nodes_replicas
+                    .read()
+                    .iter()
+                    .any(|(node_id, replica)| {
+                        node_id.as_ref() == owner_node_id && !replica.tomb_tag.is_tomb()
+                    })
+        })
+    }
+
+    fn eviction_cache_entry_recoverable_status(
+        &self,
+        owner_node_id: &str,
+        key: &str,
+        desc: &NodeValueReplicaDesc,
+    ) -> RecoverableReplicaStatus {
+        let Some(route) = self.inner().kv_routes.get(key).map(|route| route.clone()) else {
+            return RecoverableReplicaStatus::RouteAbsent;
+        };
+        route_recoverable_replica_status(self.inner().view(), owner_node_id, key, &route, desc)
+    }
+
+    pub(crate) fn evict_recoverable_cache_weight(
+        &self,
+        owner_node_id: &str,
+        requested_weight: u64,
+    ) -> u64 {
+        self.evict_recoverable_cache_weight_excluding(
+            owner_node_id,
+            requested_weight,
+            &HashSet::new(),
+        )
+    }
+
+    pub(crate) fn evict_recoverable_cache_weight_excluding(
+        &self,
+        owner_node_id: &str,
+        requested_weight: u64,
+        excluded_keys: &HashSet<String>,
+    ) -> u64 {
+        if requested_weight == 0 {
+            return 0;
+        }
+        let Some(cache) = self.get_node_cache_controller(owner_node_id) else {
+            return 0;
+        };
+        let counters = self.eviction_reclaim_counters(owner_node_id);
+        counters
+            .recoverable_first_requested_bytes
+            .fetch_add(requested_weight, Ordering::Relaxed);
+        let selected_weight = cache.evict_some_if(requested_weight, |key, desc| {
+            if excluded_keys.contains(key) {
+                return false;
+            }
+            let status = self.eviction_cache_entry_recoverable_status(owner_node_id, key, desc);
+            counters.record_recoverable_first_status(status);
+            status == RecoverableReplicaStatus::Recoverable
+        });
+        counters
+            .recoverable_first_selected_bytes
+            .fetch_add(selected_weight, Ordering::Relaxed);
+        counters.recoverable_first_shortfall_bytes.fetch_add(
+            requested_weight.saturating_sub(selected_weight),
+            Ordering::Relaxed,
+        );
+        selected_weight
     }
 
-    pub fn reserve_inflight_put_key(
+    pub(crate) async fn demote_owner_hot_cohort_if_recoverable(
         &self,
+        owner_node_id: &str,
         key: &str,
-        reject_if_inflight_same_key: bool,
-        reject_if_exist_same_key: bool,
-    ) -> Result<(), KvError> {
-        if reject_if_exist_same_key && self.key_has_live_replica(key) {
-            return Err(KvError::Api(
-                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyAlreadyExists {
-                    key: key.to_string(),
-                },
-            ));
+        put_id: PutIDForAKey,
+    ) -> u64 {
+        let counters = self.eviction_reclaim_counters(owner_node_id);
+        counters
+            .owner_hot_demotion_attempts
+            .fetch_add(1, Ordering::Relaxed);
+
+        let Some(cache) = self.get_node_cache_controller(owner_node_id) else {
+            return 0;
+        };
+        cache.run_pending_tasks();
+        let Some(anchor_desc) = cache.get(key) else {
+            return 0;
+        };
+        if anchor_desc.put_id != put_id {
+            return 0;
         }
-        let counts = &self.inner().inflight_put_key_counts;
-        let mut entry = counts.entry(key.to_string()).or_insert(0);
-        if reject_if_inflight_same_key && *entry > 0 {
-            return Err(KvError::Api(
-                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyBeingWritten {
-                    key: key.to_string(),
-                },
-            ));
+        let Some(anchor_route) = self.inner().kv_routes.get(key).map(|route| route.clone()) else {
+            return 0;
+        };
+        let Ok(cohort_keys) = current_tp_cohort_keys(key, &anchor_route, &anchor_desc) else {
+            return 0;
+        };
+        let Some(cohort_anchor) = cohort_keys.iter().min() else {
+            return 0;
+        };
+        let cohort_lock = self
+            .inner()
+            .owner_hot_demotion_locks
+            .get_lock(format!("{owner_node_id}\0{cohort_anchor}"));
+        let _cohort_guard = cohort_lock.lock().await;
+
+        // The route and Moka state may have changed while another member completion held the
+        // cohort lock. Recompute the complete cohort under the lock before selecting anything.
+        cache.run_pending_tasks();
+        let Some(anchor_desc) = cache.get(key) else {
+            return 0;
+        };
+        if anchor_desc.put_id != put_id {
+            return 0;
+        }
+        let Some(anchor_route) = self.inner().kv_routes.get(key).map(|route| route.clone()) else {
+            return 0;
+        };
+        let Ok(locked_cohort_keys) = current_tp_cohort_keys(key, &anchor_route, &anchor_desc)
+        else {
+            return 0;
+        };
+        if locked_cohort_keys != cohort_keys {
+            counters
+                .owner_hot_demotion_precheck_rejected
+                .fetch_add(1, Ordering::Relaxed);
+            return 0;
         }
-        *entry += 1;
-        Ok(())
-    }
 
-    pub fn key_has_live_replica(&self, key: &str) -> bool {
-        self.inner()
-            .kv_routes
-            .get(key)
-            .map(|one_kv_nodes_routes| {
-                one_kv_nodes_routes
-                    .nodes_replicas
-                    .read()
-                    .values()
-                    .any(|kv_info| !kv_info.tomb_tag.is_tomb())
+        // Demotion is an all-or-nothing TP/atomic-cohort transition.  Do not
+        // silently shrink the cohort when one of its source entries has
+        // already disappeared from this owner's cache: doing so can recreate
+        // the mixed local/remote layout that made the prefix unrecoverable in
+        // E23.
+        let expected_cohort_len = locked_cohort_keys.len();
+        let expected_entries = locked_cohort_keys
+            .into_iter()
+            .map(|cohort_key| cache.get(&cohort_key).map(|desc| (cohort_key, desc)))
+            .collect::<Option<HashMap<_, _>>>();
+        let Some(expected_entries) = expected_entries else {
+            counters
+                .owner_hot_demotion_precheck_rejected
+                .fetch_add(1, Ordering::Relaxed);
+            return 0;
+        };
+        if expected_entries.len() != expected_cohort_len || expected_entries.is_empty() {
+            counters
+                .owner_hot_demotion_precheck_rejected
+                .fetch_add(1, Ordering::Relaxed);
+            return 0;
+        }
+
+        // Validate the whole TP/atomic cohort before asking Moka to select anything.  Performing
+        // this check in the eviction predicate allowed one recoverable member to be selected even
+        // when a later member was not recoverable, which turned an intended exclusive transition
+        // into a partial source demotion.
+        let Some(expected_weight) =
+            recoverable_cohort_weight(&expected_entries, |candidate_key, candidate_desc| {
+                let status = self.eviction_cache_entry_recoverable_status(
+                    owner_node_id,
+                    candidate_key,
+                    candidate_desc,
+                );
+                counters.record_recoverable_first_status(status);
+                status
             })
-            .unwrap_or(false)
+        else {
+            counters
+                .owner_hot_demotion_precheck_rejected
+                .fetch_add(1, Ordering::Relaxed);
+            return 0;
+        };
+
+        let selected_weight =
+            cache.evict_some_if(expected_weight, |candidate_key, candidate_desc| {
+                expected_entries
+                    .get(candidate_key)
+                    .is_some_and(|expected_desc| {
+                        expected_desc.put_id == candidate_desc.put_id
+                            && expected_desc.weight_bytes == candidate_desc.weight_bytes
+                    })
+            });
+        if selected_weight != expected_weight {
+            counters
+                .owner_hot_demotion_partial_mismatch
+                .fetch_add(1, Ordering::Relaxed);
+            tracing::error!(
+                "owner hot TP-cohort demotion selected a partial cohort: owner={} key={} put_id=({},{}) cohort_entries={} expected_weight={} selected_weight={}",
+                owner_node_id,
+                key,
+                put_id.0,
+                put_id.1,
+                expected_entries.len(),
+                expected_weight,
+                selected_weight
+            );
+        }
+        if selected_weight == expected_weight {
+            counters
+                .owner_hot_demotion_cohorts
+                .fetch_add(1, Ordering::Relaxed);
+            counters
+                .owner_hot_demotion_selected_bytes
+                .fetch_add(selected_weight, Ordering::Relaxed);
+            tracing::debug!(
+                "owner hot complete TP-cohort demotion selected: owner={} key={} put_id=({},{}) cohort_entries={} selected_weight={}",
+                owner_node_id,
+                key,
+                put_id.0,
+                put_id.1,
+                expected_entries.len(),
+                selected_weight
+            );
+        }
+        selected_weight
     }
 
-    pub fn release_inflight_put_key(&self, key: &str) {
-        Self::release_inflight_put_key_count_map(&self.inner().inflight_put_key_counts, key);
+    pub(crate) fn insert_node_cache_entry(
+        &self,
+        owner_node_id: &str,
+        key: String,
+        desc: NodeValueReplicaDesc,
+    ) -> bool {
+        let Some(cache) = self.get_node_cache_controller(owner_node_id) else {
+            return false;
+        };
+        cache.run_pending_tasks();
+        let existing_weight = cache
+            .get(&key)
+            .map(|existing| u64::from(existing.weight_bytes))
+            .unwrap_or(0);
+        let projected_weight = cache
+            .weighted_size()
+            .saturating_sub(existing_weight)
+            .saturating_add(u64::from(desc.weight_bytes));
+        let node_space_size = self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .get_node_space_size(owner_node_id);
+        let capacity = self.replica_cache_effective_capacity(owner_node_id, node_space_size);
+        let requested_weight = projected_weight.saturating_sub(capacity);
+        if requested_weight != 0 {
+            let recoverable_selected_weight =
+                self.evict_recoverable_cache_weight(owner_node_id, requested_weight);
+            let fallback_requested_weight =
+                requested_weight.saturating_sub(recoverable_selected_weight);
+            let fallback_selected_weight =
+                if self.owner_cache_allows_unrecoverable_eviction(owner_node_id) {
+                    cache.evict_some(fallback_requested_weight)
+                } else {
+                    0
+                };
+            tracing::debug!(
+                "recoverable-first cache admission: owner={} key={} requested_weight={} recoverable_selected_weight={} fallback_requested_weight={} fallback_selected_weight={} projected_weight={} capacity={}",
+                owner_node_id,
+                key,
+                requested_weight,
+                recoverable_selected_weight,
+                fallback_requested_weight,
+                fallback_selected_weight,
+                projected_weight,
+                capacity
+            );
+        }
+        cache.insert(key, desc);
+        true
     }
 
     fn register_rpc_callers(&self) {
         RPCCaller::<BatchDeleteClientKvMetaCacheReq>::new().regist(self.0.view().p2p_module());
+        RPCCaller::<BatchOwnerReclaimReq>::new().regist(self.0.view().p2p_module());
+        RPCCaller::<BatchEnqueueReplicaTaskReq>::new().regist(self.0.view().p2p_module());
     }
 
     fn register_rpc_handlers(&self) {
@@ -827,9 +2766,11 @@ impl MasterKvRouter {
                 let (get_id, mut ack) =
                     handle_get_start(view_task, msg, resp.node_id().clone()).await;
                 ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                let get_started = ack.serialize_part.error_code
+                    == crate::rpcresp_kvresult_convert::msg_and_error::OK;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send GetStartResp: {:?}", e);
-                    if get_id != 0 {
+                    if get_started {
                         if let Some(inflight_info) = cleanup_view
                             .master_kv_router()
                             .inner()
@@ -838,6 +2779,7 @@ impl MasterKvRouter {
                             .await
                         {
                             inflight_info.release_durable_slot_if_needed();
+                            inflight_info._activity_lease.release_now();
                         }
                     }
                 }
@@ -947,14 +2889,9 @@ impl MasterKvRouter {
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send BatchPreparePutKeysResp: {:?}", e);
                     for reservation_id in reservation_ids {
-                        if let Some(info) = view_task
+                        let _ = view_task
                             .master_kv_router()
-                            .take_prepared_put_key_reservation(reservation_id)
-                        {
-                            view_task
-                                .master_kv_router()
-                                .release_inflight_put_key(&info.key);
-                        }
+                            .take_prepared_put_key_reservation(reservation_id);
                     }
                 }
             });
@@ -1002,12 +2939,20 @@ impl MasterKvRouter {
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send PutStartResp: {:?}", e);
                     if put_id != (0, 0) {
-                        view_task
+                        if let Some(inflight_info) = view_task
                             .master_kv_router()
                             .inner()
                             .inflight_puts
                             .remove(&(key, put_id.0, put_id.1))
-                            .await;
+                            .await
+                        {
+                            inflight_info._activity_lease.release_now();
+                            if let Some(replica_target) =
+                                inflight_info.commit_info.replica_target.as_ref()
+                            {
+                                replica_target._activity_lease.release_now();
+                            }
+                        }
                     }
                 } else {
                     #[cfg(feature = "test_bins")]
@@ -1244,17 +3189,55 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<GroupedBatchPutDoneReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_grouped_batch_put_done", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_grouped_batch_put_done(view2, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send GroupedBatchPutDoneResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
         let view = self.0.view().clone();
         RPCHandler::<BatchGetStartReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
             let view2 = view.clone();
+            let cleanup_view = view.clone();
             let req_node_id = resp.node_id().clone();
             view.spawn("rpc_batch_get_start", async move {
                 let t0 = Utc::now().timestamp_micros();
                 let mut ack = handle_batch_get_start(view2, msg, req_node_id).await;
                 ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                let started_get_ids = ack
+                    .serialize_part
+                    .items
+                    .iter()
+                    .filter(|item| {
+                        item.error_code == crate::rpcresp_kvresult_convert::msg_and_error::OK
+                    })
+                    .map(|item| item.get_id)
+                    .collect::<Vec<_>>();
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send BatchGetStartResp: {:?}", e);
+                    for get_id in started_get_ids {
+                        if let Some(inflight_info) = cleanup_view
+                            .master_kv_router()
+                            .inner()
+                            .inflight_gets
+                            .remove(&get_id)
+                            .await
+                        {
+                            inflight_info.release_durable_slot_if_needed();
+                            inflight_info._activity_lease.release_now();
+                        }
+                    }
                 }
             });
             Ok(())
@@ -1774,6 +3757,47 @@ impl MasterKvRouter {
         target_counter.fetch_add(1, Ordering::Relaxed);
     }
 
+    pub(crate) fn record_get_source_selection(
+        &self,
+        requester_node_id: &str,
+        source_node_id: &str,
+        bytes: u64,
+        allocation_mode: GetAllocationMode,
+    ) {
+        let requester_source_key = RequesterTargetPair::new(requester_node_id, source_node_id);
+        let source_count = self
+            .inner()
+            .get_requester_source_counts
+            .entry(requester_source_key.clone())
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .clone();
+        source_count.fetch_add(1, Ordering::Relaxed);
+
+        let source_bytes = self
+            .inner()
+            .get_requester_source_bytes
+            .entry(requester_source_key)
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .clone();
+        source_bytes.fetch_add(bytes, Ordering::Relaxed);
+
+        let mode_key = match allocation_mode {
+            GetAllocationMode::Temporary => "temporary",
+            GetAllocationMode::ReuseReplica => "reuse_replica",
+            GetAllocationMode::DurableReplica => "durable_replica",
+        };
+        let mode_count = self
+            .inner()
+            .get_allocation_mode_counts
+            .entry(mode_key)
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .clone();
+        mode_count.fetch_add(1, Ordering::Relaxed);
+    }
+
     fn spawn_put_placement_reporter(&self) {
         let view = self.inner().view().clone();
         let view_task = view.clone();
@@ -1819,12 +3843,39 @@ impl MasterKvRouter {
                             .collect();
                         replica_task_target_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
 
+                        let mut get_source_counts: Vec<(String, u64)> = router
+                            .inner()
+                            .get_requester_source_counts
+                            .iter()
+                            .map(|entry| (entry.key().as_log_key(), entry.value().load(Ordering::Relaxed)))
+                            .collect();
+                        get_source_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+
+                        let mut get_source_bytes: Vec<(String, u64)> = router
+                            .inner()
+                            .get_requester_source_bytes
+                            .iter()
+                            .map(|entry| (entry.key().as_log_key(), entry.value().load(Ordering::Relaxed)))
+                            .collect();
+                        get_source_bytes.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+
+                        let mut get_allocation_mode_counts: Vec<(String, u64)> = router
+                            .inner()
+                            .get_allocation_mode_counts
+                            .iter()
+                            .map(|entry| (entry.key().to_string(), entry.value().load(Ordering::Relaxed)))
+                            .collect();
+                        get_allocation_mode_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+
                         info!(
-                            "put placement historical distribution | target_counts={:?} | mode_counts={:?} | requester_target_counts={:?} | replica_task_target_counts={:?}",
+                            "placement historical distribution | put_target_counts={:?} | put_mode_counts={:?} | put_requester_target_counts={:?} | replica_task_target_counts={:?} | get_requester_source_counts={:?} | get_requester_source_bytes={:?} | get_allocation_mode_counts={:?}",
                             target_counts,
                             mode_counts,
                             requester_target_counts,
                             replica_task_target_counts,
+                            get_source_counts,
+                            get_source_bytes,
+                            get_allocation_mode_counts,
                         );
                     }
                     _ = shutdown_waiter.wait() => {
@@ -1861,7 +3912,10 @@ impl MasterKvRouter {
                     let cache_node_id = node_id_owned.clone();
                     Arc::new(
                         moka::sync::SegmentedCache::builder(8)
-                            .max_capacity((node_space_size as f32 * MOKA_CACHE_CAPACITY_RATIO) as u64)
+                            // The resident cache is a metadata/LRU controller. Its aggregate
+                            // effective capacity is enforced explicitly with `evict_some_if`.
+                            // Leaving the Moka segments unbounded prevents per-segment hash skew
+                            // from performing an independent Size eviction outside that policy.
                             // Use the actual allocated/rounded size as weight to
                             // make eviction reflect real memory usage.
                             .weigher(Box::new(|_key: &String, value: &NodeValueReplicaDesc| {
@@ -1884,19 +3938,11 @@ impl MasterKvRouter {
                                                 evicted_put_id.0,
                                                 evicted_put_id.1
                                             );
-                                            if let Err(code) = crate::master_kv_router::delete::evict_one_kv_replica_for_node(
-                                                &view,
-                                                k.clone(),
-                                                cache_node_id.clone().into(),
-                                                evicted_put_id,
-                                            ) {
-                                                warn!(
-                                                    "Eviction-triggered local replica cleanup failed for key {} on node {}: {:?}",
-                                                    k,
-                                                    cache_node_id,
-                                                    code
-                                                );
-                                            }
+                                            view.master_kv_router().enqueue_eviction_reclaim(
+                                                cache_node_id.clone(),
+                                                k,
+                                                _value,
+                                            );
                                         }
                                         _ => {}
                                     }
@@ -1910,6 +3956,210 @@ impl MasterKvRouter {
         )
     }
 
+    pub fn tier1_source_node_eligible(&self, node_id: &str) -> bool {
+        if !self.tiered_writeback_enabled() {
+            return false;
+        }
+        let member = self
+            .inner()
+            .view()
+            .cluster_manager()
+            .get_member_info_cached(node_id);
+        Self::tier1_source_member_eligible(member.as_ref(), &self.inner().replica_task_placement)
+    }
+
+    fn tier1_source_member_eligible(
+        member: Option<&crate::cluster_manager::ClusterMember>,
+        placement_config: &ReplicaTaskPlacementConfig,
+    ) -> bool {
+        // Route entries are keyed by the storage owner that holds the payload. In the
+        // external-SGLang topology that owner is tagged `sglang_owner`; the separate
+        // zero-contribution SGLang client carries the `prefill`/`decode` role. Requiring
+        // the owner itself to match active_node_roles therefore disables T1 entirely.
+        //
+        // A T1 source only needs to be a known, non-remote-only owner. The caller also
+        // requires a non-zero registered segment before constructing the tier cache.
+        member.is_some()
+            && !placement::member_matches_roles(member, &placement_config.remote_only_node_roles)
+    }
+
+    pub fn get_node_writeback_tier1_controller(
+        &self,
+        node_id: &str,
+    ) -> Option<Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>> {
+        if !self.tier1_source_node_eligible(node_id) {
+            return None;
+        }
+        let node_space_size = self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .get_node_space_size(node_id);
+        let base_capacity = self.writeback_tier1_base_capacity(node_space_size)?;
+        if base_capacity == 0 {
+            return None;
+        }
+        let view = self.inner().view().clone();
+        let node_id_owned = node_id.to_string();
+        Some(
+            self.inner()
+                .node_writeback_tier1_controller
+                .entry(node_id_owned.clone())
+                .or_insert_with(move || {
+                    let cache_node_id = node_id_owned.clone();
+                    Arc::new(
+                        moka::sync::SegmentedCache::builder(8)
+                            .max_capacity(base_capacity)
+                            .weigher(Box::new(|_key: &String, value: &NodeValueReplicaDesc| {
+                                value.weight_bytes
+                            }))
+                            .eviction_listener(Box::new(
+                                move |key: Arc<String>,
+                                      value: NodeValueReplicaDesc,
+                                      cause: RemovalCause| {
+                                    if cause == RemovalCause::Size {
+                                        view.master_kv_router().enqueue_tier1_writeback(
+                                            cache_node_id.clone(),
+                                            (*key).clone(),
+                                            value,
+                                        );
+                                    }
+                                },
+                            ))
+                            .build(),
+                    )
+                })
+                .value()
+                .clone(),
+        )
+    }
+
+    pub fn remove_node_writeback_tier1_entry(&self, node_id: &str, key: &str) {
+        if let Some(cache) = self
+            .inner()
+            .node_writeback_tier1_controller
+            .get(node_id)
+            .map(|entry| entry.value().clone())
+        {
+            let _ = cache.remove(key);
+        }
+    }
+
+    pub(crate) fn tier1_writeback_entry_is_current(
+        &self,
+        source_node_id: &str,
+        key: &str,
+        desc: &NodeValueReplicaDesc,
+    ) -> bool {
+        if self.inner().inflight_replica_tasks.contains_key(&(
+            key.to_string(),
+            desc.put_id.0,
+            desc.put_id.1,
+        )) {
+            return false;
+        }
+        self.inner().kv_routes.get(key).is_some_and(|route| {
+            if route.put_id != desc.put_id || route.lease_id.is_some() {
+                return false;
+            }
+            let replicas = route.nodes_replicas.read();
+            replicas.values().any(|replica| {
+                replica.node_id.as_ref() == source_node_id && !replica.tomb_tag.is_tomb()
+            }) && replicas.values().all(|replica| {
+                replica.tomb_tag.is_tomb() || replica.node_id.as_ref() == source_node_id
+            })
+        })
+    }
+
+    fn enqueue_tier1_writeback(
+        &self,
+        source_node_id: NodeIDString,
+        key: String,
+        desc: NodeValueReplicaDesc,
+    ) {
+        if !self.tier1_writeback_entry_is_current(&source_node_id, &key, &desc) {
+            return;
+        }
+        let dedupe_key = (key.clone(), desc.put_id.0, desc.put_id.1);
+        if self
+            .inner()
+            .tier1_writeback_dedupe
+            .get(&dedupe_key)
+            .is_some()
+        {
+            return;
+        }
+        self.inner()
+            .tier1_writeback_dedupe
+            .insert(dedupe_key.clone(), ());
+        Self::increment_tier1_writeback_counter(
+            &self.inner().tier1_writeback_trigger_counts,
+            &source_node_id,
+            1,
+        );
+        let request = tiered_writeback::Tier1WritebackRequest {
+            source_node_id: source_node_id.clone(),
+            key,
+            desc,
+        };
+        if let Err(err) = self.inner().tier1_writeback_tx.try_send(request) {
+            self.inner().tier1_writeback_dedupe.remove(&dedupe_key);
+            self.record_tier1_writeback_failed(&source_node_id, 1);
+            tracing::warn!("tier1 write-back queue is full or closed: {}", err);
+        }
+    }
+
+    fn increment_tier1_writeback_counter(
+        counters: &DashMap<NodeIDString, Arc<AtomicU64>>,
+        source_node_id: &str,
+        count: u64,
+    ) {
+        if count == 0 {
+            return;
+        }
+        counters
+            .entry(source_node_id.to_string())
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .fetch_add(count, Ordering::Relaxed);
+    }
+
+    pub(crate) fn record_tier1_writeback_owner_accepted(&self, source_node_id: &str, count: u64) {
+        Self::increment_tier1_writeback_counter(
+            &self.inner().tier1_writeback_owner_accepted_counts,
+            source_node_id,
+            count,
+        );
+    }
+
+    pub(crate) fn record_tier1_writeback_failed(&self, source_node_id: &str, count: u64) {
+        Self::increment_tier1_writeback_counter(
+            &self.inner().tier1_writeback_failed_counts,
+            source_node_id,
+            count,
+        );
+    }
+
+    fn tier1_writeback_counter(
+        counters: &DashMap<NodeIDString, Arc<AtomicU64>>,
+        source_node_id: &str,
+    ) -> u64 {
+        counters
+            .get(source_node_id)
+            .map(|counter| counter.load(Ordering::Relaxed))
+            .unwrap_or(0)
+    }
+
+    pub(crate) fn finish_tier1_writeback_request(
+        &self,
+        request: tiered_writeback::Tier1WritebackRequest,
+    ) {
+        self.inner().tier1_writeback_dedupe.remove(&(
+            request.key,
+            request.desc.put_id.0,
+            request.desc.put_id.1,
+        ));
+    }
+
     /// Atomically adjust a node's moka usable-capacity reservation by `delta_bytes`.
     /// Positive delta reserves capacity (fetch_sub from usable capacity),
     /// negative delta releases reservation (fetch_add back to usable capacity).
@@ -1932,7 +4182,7 @@ impl MasterKvRouter {
 
         reserved_capacity.apply_delta(reason, delta_bytes);
 
-        // Recompute target capacity: base(=MOKA_CACHE_CAPACITY_RATIO * node_space) - reserved_total
+        // Recompute target capacity from the configured base ratio minus live reservations.
         let reserved_total = reserved_capacity.total_reserved_bytes();
         let node_space_size = self
             .inner()
@@ -1954,21 +4204,56 @@ impl MasterKvRouter {
                 ),
             );
         }
-        let base_capacity = (node_space_size as f32 * MOKA_CACHE_CAPACITY_RATIO) as u64;
+        let base_capacity = self.replica_cache_base_capacity(node_space_size);
         let new_capacity = base_capacity.saturating_sub(reserved_total);
 
         if let Some(cache) = self.get_node_cache_controller(node_id) {
-            if let Err(e) = cache.set_max_capacity(new_capacity) {
-                // Revert counter and return error.
-                reserved_capacity.apply_delta(reason, -delta_bytes);
-                return Err(crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
-                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                        rpc_input_json: format!(
-                            "moka.set_max_capacity failed: node_id={}, new_capacity={}, err={}",
-                            node_id, new_capacity, e
+            if let Some(tier1_cache) = self
+                .inner()
+                .node_writeback_tier1_controller
+                .get(node_id)
+                .map(|entry| entry.value().clone())
+            {
+                let tier1_capacity = self
+                    .writeback_tier1_base_capacity(node_space_size)
+                    .unwrap_or(0)
+                    .min(new_capacity);
+                if let Err(e) = tier1_cache.set_max_capacity(tier1_capacity) {
+                    reserved_capacity.apply_delta(reason, -delta_bytes);
+                    return Err(
+                        crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
+                            crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                                rpc_input_json: format!(
+                                    "tier1 moka.set_max_capacity failed: node_id={}, new_capacity={}, err={}",
+                                    node_id, tier1_capacity, e
+                                ),
+                            },
                         ),
-                    }
-                ));
+                    );
+                }
+            }
+            cache.run_pending_tasks();
+            let requested_weight = cache.weighted_size().saturating_sub(new_capacity);
+            let recoverable_selected_weight =
+                self.evict_recoverable_cache_weight(node_id, requested_weight);
+            let fallback_requested_weight =
+                requested_weight.saturating_sub(recoverable_selected_weight);
+            let fallback_selected_weight =
+                if self.owner_cache_allows_unrecoverable_eviction(node_id) {
+                    cache.evict_some(fallback_requested_weight)
+                } else {
+                    0
+                };
+            if requested_weight != 0 {
+                tracing::debug!(
+                    "resident cache effective-capacity adjustment: owner={} effective_capacity={} requested_weight={} recoverable_selected_weight={} fallback_requested_weight={} fallback_selected_weight={}",
+                    node_id,
+                    new_capacity,
+                    requested_weight,
+                    recoverable_selected_weight,
+                    fallback_requested_weight,
+                    fallback_selected_weight
+                );
             }
             Ok(())
         } else {
@@ -2060,21 +4345,117 @@ impl MasterKvRouter {
                 .view()
                 .master_seg_manager()
                 .get_node_space_size(owner_node.as_str());
-            let base_capacity_bytes = (node_space_size as f32 * MOKA_CACHE_CAPACITY_RATIO) as u64;
+            let base_capacity_bytes = self.replica_cache_base_capacity(node_space_size);
             let reserved_capacity_bytes = self
                 .inner()
                 .node_cache_reserved_capacity
                 .get(owner_node.as_str())
                 .map(|reserved| reserved.total_reserved_bytes())
                 .unwrap_or(0);
-            let effective_capacity_bytes = cache.policy().max_capacity().unwrap_or(0);
+            let effective_capacity_bytes =
+                self.replica_cache_effective_capacity(owner_node.as_str(), node_space_size);
+            let pending_eviction_reclaim_bytes =
+                self.eviction_reclaim_pending_weight(owner_node.as_str());
+            let reclaim_counters = self.eviction_reclaim_counters(owner_node.as_str());
+            let tier1_cache = self
+                .inner()
+                .node_writeback_tier1_controller
+                .get(owner_node.as_str())
+                .map(|entry| entry.value().clone());
             replica_cache_nodes.push(ReplicaCacheNodeObserveSnapshot {
-                owner_node,
+                owner_node: owner_node.clone(),
                 entries: cache.entry_count(),
                 weighted_bytes: cache.weighted_size(),
                 effective_capacity_bytes,
                 reserved_capacity_bytes,
                 base_capacity_bytes,
+                pending_eviction_reclaim_bytes,
+                writeback_tier1_entries: tier1_cache
+                    .as_ref()
+                    .map(|cache| cache.entry_count())
+                    .unwrap_or(0),
+                writeback_tier1_weighted_bytes: tier1_cache
+                    .as_ref()
+                    .map(|cache| cache.weighted_size())
+                    .unwrap_or(0),
+                writeback_tier1_capacity_bytes: tier1_cache
+                    .as_ref()
+                    .and_then(|cache| cache.policy().max_capacity())
+                    .unwrap_or(0),
+                writeback_tier1_triggered: Self::tier1_writeback_counter(
+                    &self.inner().tier1_writeback_trigger_counts,
+                    owner_node.as_str(),
+                ),
+                writeback_tier1_owner_accepted: Self::tier1_writeback_counter(
+                    &self.inner().tier1_writeback_owner_accepted_counts,
+                    owner_node.as_str(),
+                ),
+                writeback_tier1_failed: Self::tier1_writeback_counter(
+                    &self.inner().tier1_writeback_failed_counts,
+                    owner_node.as_str(),
+                ),
+                reclaim_master_activity_deferred: reclaim_counters
+                    .master_activity_deferred
+                    .load(Ordering::Relaxed),
+                reclaim_master_get_holder_observed: reclaim_counters
+                    .master_get_holder_observed
+                    .load(Ordering::Relaxed),
+                reclaim_owner_holder_deferred: reclaim_counters
+                    .owner_holder_deferred
+                    .load(Ordering::Relaxed),
+                reclaim_owner_other_deferred: reclaim_counters
+                    .owner_other_deferred
+                    .load(Ordering::Relaxed),
+                reclaim_route_changed: reclaim_counters.route_changed.load(Ordering::Relaxed),
+                reclaim_retry_queued: reclaim_counters.retry_queued.load(Ordering::Relaxed),
+                reclaim_retry_completed: reclaim_counters.retry_completed.load(Ordering::Relaxed),
+                reclaim_retry_restored: reclaim_counters.retry_restored.load(Ordering::Relaxed),
+                reclaim_completed: reclaim_counters.completed.load(Ordering::Relaxed),
+                owner_hot_demotion_attempts: reclaim_counters
+                    .owner_hot_demotion_attempts
+                    .load(Ordering::Relaxed),
+                owner_hot_demotion_cohorts: reclaim_counters
+                    .owner_hot_demotion_cohorts
+                    .load(Ordering::Relaxed),
+                owner_hot_demotion_selected_bytes: reclaim_counters
+                    .owner_hot_demotion_selected_bytes
+                    .load(Ordering::Relaxed),
+                owner_hot_demotion_precheck_rejected: reclaim_counters
+                    .owner_hot_demotion_precheck_rejected
+                    .load(Ordering::Relaxed),
+                owner_hot_demotion_partial_mismatch: reclaim_counters
+                    .owner_hot_demotion_partial_mismatch
+                    .load(Ordering::Relaxed),
+                recoverable_first_requested_bytes: reclaim_counters
+                    .recoverable_first_requested_bytes
+                    .load(Ordering::Relaxed),
+                recoverable_first_selected_bytes: reclaim_counters
+                    .recoverable_first_selected_bytes
+                    .load(Ordering::Relaxed),
+                recoverable_first_shortfall_bytes: reclaim_counters
+                    .recoverable_first_shortfall_bytes
+                    .load(Ordering::Relaxed),
+                recoverable_first_eligible_checks: reclaim_counters
+                    .recoverable_first_eligible_checks
+                    .load(Ordering::Relaxed),
+                recoverable_first_route_absent_checks: reclaim_counters
+                    .recoverable_first_route_absent_checks
+                    .load(Ordering::Relaxed),
+                recoverable_first_version_changed_checks: reclaim_counters
+                    .recoverable_first_version_changed_checks
+                    .load(Ordering::Relaxed),
+                recoverable_first_route_ineligible_checks: reclaim_counters
+                    .recoverable_first_route_ineligible_checks
+                    .load(Ordering::Relaxed),
+                recoverable_first_cpu_route_absent_checks: reclaim_counters
+                    .recoverable_first_cpu_route_absent_checks
+                    .load(Ordering::Relaxed),
+                recoverable_first_atomic_group_incomplete_checks: reclaim_counters
+                    .recoverable_first_atomic_group_incomplete_checks
+                    .load(Ordering::Relaxed),
+                recoverable_first_tp_cohort_incomplete_checks: reclaim_counters
+                    .recoverable_first_tp_cohort_incomplete_checks
+                    .load(Ordering::Relaxed),
             });
         }
 
@@ -2105,7 +4486,52 @@ impl MasterKvRouter {
                             "master_get_holding",
                             snapshot.get_holding_bytes,
                         );
+                        tracing::info!(
+                            "master get holding runtime: entries={} bytes={}",
+                            snapshot.get_holding_entries,
+                            snapshot.get_holding_bytes
+                        );
                         for node in snapshot.replica_cache_nodes {
+                            tracing::info!(
+                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_master_get_holder_observed={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} owner_hot_demotion_attempts={} owner_hot_demotion_cohorts={} owner_hot_demotion_selected_bytes={} owner_hot_demotion_precheck_rejected={} owner_hot_demotion_partial_mismatch={} recoverable_first_requested_bytes={} recoverable_first_selected_bytes={} recoverable_first_shortfall_bytes={} recoverable_first_eligible_checks={} recoverable_first_route_absent_checks={} recoverable_first_version_changed_checks={} recoverable_first_route_ineligible_checks={} recoverable_first_cpu_route_absent_checks={} recoverable_first_atomic_group_incomplete_checks={} recoverable_first_tp_cohort_incomplete_checks={}",
+                                node.owner_node,
+                                node.entries,
+                                node.weighted_bytes,
+                                node.effective_capacity_bytes,
+                                node.base_capacity_bytes,
+                                node.reserved_capacity_bytes,
+                                node.pending_eviction_reclaim_bytes,
+                                node.writeback_tier1_entries,
+                                node.writeback_tier1_weighted_bytes,
+                                node.writeback_tier1_capacity_bytes,
+                                node.writeback_tier1_triggered,
+                                node.writeback_tier1_owner_accepted,
+                                node.writeback_tier1_failed,
+                                node.reclaim_master_activity_deferred,
+                                node.reclaim_master_get_holder_observed,
+                                node.reclaim_owner_holder_deferred,
+                                node.reclaim_owner_other_deferred,
+                                node.reclaim_route_changed,
+                                node.reclaim_retry_queued,
+                                node.reclaim_retry_completed,
+                                node.reclaim_retry_restored,
+                                node.reclaim_completed,
+                                node.owner_hot_demotion_attempts,
+                                node.owner_hot_demotion_cohorts,
+                                node.owner_hot_demotion_selected_bytes,
+                                node.owner_hot_demotion_precheck_rejected,
+                                node.owner_hot_demotion_partial_mismatch,
+                                node.recoverable_first_requested_bytes,
+                                node.recoverable_first_selected_bytes,
+                                node.recoverable_first_shortfall_bytes,
+                                node.recoverable_first_eligible_checks,
+                                node.recoverable_first_route_absent_checks,
+                                node.recoverable_first_version_changed_checks,
+                                node.recoverable_first_route_ineligible_checks,
+                                node.recoverable_first_cpu_route_absent_checks,
+                                node.recoverable_first_atomic_group_incomplete_checks,
+                                node.recoverable_first_tp_cohort_incomplete_checks
+                            );
                             metrics.set_kv_replica_cache_entries(
                                 node.owner_node.as_str(),
                                 node.entries,
@@ -2129,6 +4555,16 @@ impl MasterKvRouter {
                                 "base",
                                 node.base_capacity_bytes,
                             );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "pending_eviction_reclaim",
+                                node.pending_eviction_reclaim_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "writeback_tier1",
+                                node.writeback_tier1_capacity_bytes,
+                            );
                         }
                     }
                 }
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index 2185436..9f7717b 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -5,6 +5,7 @@ use crate::{
 };
 use bitcode::{Decode, Encode};
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use super::put::PutIDForAKey;
 
@@ -264,20 +265,42 @@ impl RPCReq for GetMasterOnlyMetricPartReq {
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
-pub struct ReserveLocalGrantReq;
+pub struct ReserveLocalGrantReq {
+    /// Slot class that needs capacity. Zero means a raw grant request with no reclaim fallback.
+    pub slot_size: u64,
+    /// Number of slots the owner is currently short of in this class.
+    pub required_free_slots: u32,
+    /// Reclaim committed slots before growing the physical grant pool. This keeps owner-local
+    /// free-slot headroom without changing the owner's advertised capacity.
+    pub reclaim_before_grow: bool,
+}
 impl MsgPackSerializePart for ReserveLocalGrantReq {
     fn msg_id(&self) -> u32 {
         MsgId::ReserveLocalGrantReq as u32
     }
 }
 
+#[allow(unused_assignments)]
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub enum ReserveLocalGrantOutcome {
+    #[default]
+    None,
+    Granted {
+        grant_id: u64,
+        node_id: NodeIDString,
+        addr: u64,
+        base_addr: u64,
+        len: u64,
+    },
+    Reclaimed {
+        slot_size: u64,
+        reclaimed_slots: u32,
+    },
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ReserveLocalGrantResp {
-    pub grant_id: u64,
-    pub node_id: NodeIDString,
-    pub addr: u64,
-    pub base_addr: u64,
-    pub len: u64,
+    pub outcome: ReserveLocalGrantOutcome,
     pub error_code: ErrorCode,
     pub error_json: String,
     pub server_process_us: i64,
@@ -291,6 +314,134 @@ impl RPCReq for ReserveLocalGrantReq {
     type Resp = ReserveLocalGrantResp;
 }
 
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerReclaimPhase {
+    #[default]
+    Prepare,
+    Commit,
+    Abort,
+    Finalize,
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerReclaimItemState {
+    #[default]
+    Busy,
+    Prepared,
+    Committed,
+    Aborted,
+    Finalized,
+    Stale,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerReclaimBacking {
+    #[default]
+    Allocation,
+    CommittedSlot {
+        grant_id: u64,
+        slot_index: u32,
+        slot_size: u64,
+    },
+    /// A master-owned allocation with no owner-side key index. The master reclaims this
+    /// backing directly after installing its key-activity fence and never sends it to the owner.
+    UnindexedAllocation,
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerReclaimReason {
+    #[default]
+    Reserve,
+    CapacityEviction,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct OwnerReclaimItem {
+    pub key: String,
+    pub put_id: (u64, u32),
+    pub epoch: u64,
+    pub backing: OwnerReclaimBacking,
+    pub reason: OwnerReclaimReason,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchOwnerReclaimReq {
+    pub phase: OwnerReclaimPhase,
+    pub items: Vec<OwnerReclaimItem>,
+}
+
+impl MsgPackSerializePart for BatchOwnerReclaimReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchOwnerReclaimReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct OwnerReclaimItemResp {
+    pub key: String,
+    pub epoch: u64,
+    pub state: OwnerReclaimItemState,
+    pub detail: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchOwnerReclaimResp {
+    pub items: Vec<OwnerReclaimItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for BatchOwnerReclaimResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchOwnerReclaimResp as u32
+    }
+}
+
+impl RPCReq for BatchOwnerReclaimReq {
+    type Resp = BatchOwnerReclaimResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct EnqueueReplicaTaskItem {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchEnqueueReplicaTaskReq {
+    pub items: Vec<EnqueueReplicaTaskItem>,
+}
+
+impl MsgPackSerializePart for BatchEnqueueReplicaTaskReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchEnqueueReplicaTaskReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct EnqueueReplicaTaskItemResp {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub accepted: bool,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchEnqueueReplicaTaskResp {
+    pub items: Vec<EnqueueReplicaTaskItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for BatchEnqueueReplicaTaskResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchEnqueueReplicaTaskResp as u32
+    }
+}
+
+impl RPCReq for BatchEnqueueReplicaTaskReq {
+    type Resp = BatchEnqueueReplicaTaskResp;
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ReleaseLocalGrantReq {
     pub grant_id: u64,
@@ -461,6 +612,95 @@ pub struct PutDoneCommittedSlot {
     pub len: u64,
 }
 
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct PutAtomicGroupMember {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+}
+
+/// Version-scoped members of one caller-declared atomic put group.
+///
+/// Groups with one member are represented as `None` on the route. Multi-member
+/// groups let eviction require one common remote-cache owner to hold every member.
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct PutAtomicGroup {
+    pub members: Vec<PutAtomicGroupMember>,
+}
+
+pub fn build_put_atomic_group_assignments(
+    keys_and_put_ids: &[(String, PutIDForAKey)],
+    atomic_group_lens: &[usize],
+) -> Result<Vec<Option<PutAtomicGroup>>, String> {
+    build_shared_put_atomic_group_assignments(keys_and_put_ids, atomic_group_lens).map(
+        |assignments| {
+            assignments
+                .into_iter()
+                .map(|group| group.map(|group| group.as_ref().clone()))
+                .collect()
+        },
+    )
+}
+
+/// Builds one shared descriptor per multi-key group and assigns cheap `Arc`
+/// clones to its members. This is the grouped-put representation used by the
+/// V2 route-publish protocol; unlike the legacy wire representation, it is
+/// linear in the number of keys rather than the sum of squared group sizes.
+pub fn build_shared_put_atomic_group_assignments(
+    keys_and_put_ids: &[(String, PutIDForAKey)],
+    atomic_group_lens: &[usize],
+) -> Result<Vec<Option<Arc<PutAtomicGroup>>>, String> {
+    if atomic_group_lens.is_empty() && !keys_and_put_ids.is_empty() {
+        return Err("atomic_group_lens must be non-empty".to_string());
+    }
+    let mut offset = 0usize;
+    let mut assignments = Vec::with_capacity(keys_and_put_ids.len());
+    for (group_index, group_len) in atomic_group_lens.iter().copied().enumerate() {
+        if group_len == 0 {
+            return Err(format!(
+                "atomic_group_lens entries must be > 0; index={group_index}"
+            ));
+        }
+        if group_len > 4096 {
+            return Err(format!(
+                "atomic_group_lens entries must be <= 4096; index={group_index} len={group_len}"
+            ));
+        }
+        let end = offset
+            .checked_add(group_len)
+            .ok_or_else(|| "atomic_group_lens sum overflowed usize".to_string())?;
+        let members = keys_and_put_ids.get(offset..end).ok_or_else(|| {
+            format!(
+                "atomic_group_lens exceeds keys length; end={} keys={}",
+                end,
+                keys_and_put_ids.len()
+            )
+        })?;
+        if group_len == 1 {
+            assignments.push(None);
+        } else {
+            let group = Arc::new(PutAtomicGroup {
+                members: members
+                    .iter()
+                    .map(|(key, put_id)| PutAtomicGroupMember {
+                        key: key.clone(),
+                        put_id: *put_id,
+                    })
+                    .collect(),
+            });
+            assignments.extend((0..group_len).map(|_| Some(group.clone())));
+        }
+        offset = end;
+    }
+    if offset != keys_and_put_ids.len() {
+        return Err(format!(
+            "atomic_group_lens must sum to keys length; sum={} keys={}",
+            offset,
+            keys_and_put_ids.len()
+        ));
+    }
+    Ok(assignments)
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutDoneReq {
     pub key: String,
@@ -471,6 +711,8 @@ pub struct PutDoneReq {
     pub committed_slot: Option<PutDoneCommittedSlot>,
     /// Ask master to keep a local read holder for the committing node.
     pub publish_local_cache: bool,
+    /// Multi-key atomic group for this exact key version.
+    pub atomic_group: Option<PutAtomicGroup>,
 }
 impl MsgPackSerializePart for PutDoneReq {
     fn msg_id(&self) -> u32 {
@@ -591,6 +833,7 @@ pub struct BatchPutDoneItemReq {
     pub lease_id: Option<u64>,
     pub committed_slot: Option<PutDoneCommittedSlot>,
     pub publish_local_cache: bool,
+    pub atomic_group: Option<PutAtomicGroup>,
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -628,12 +871,56 @@ impl RPCReq for BatchPutDoneReq {
     type Resp = BatchPutDoneResp;
 }
 
+/// Linear-size V2 batch route publication. `atomic_group_lens` partitions the
+/// ordered items; the master reconstructs each group once from the item keys
+/// and put ids, then shares one interned descriptor across member routes.
+///
+/// The V1 `BatchPutDoneReq` remains registered unchanged for rolling and API
+/// compatibility.
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct GroupedBatchPutDoneItemReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub lease_id: Option<u64>,
+    pub committed_slot: Option<PutDoneCommittedSlot>,
+    pub publish_local_cache: bool,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct GroupedBatchPutDoneReq {
+    pub items: Vec<GroupedBatchPutDoneItemReq>,
+    pub atomic_group_lens: Vec<usize>,
+}
+impl MsgPackSerializePart for GroupedBatchPutDoneReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::GroupedBatchPutDoneReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct GroupedBatchPutDoneResp {
+    pub items: Vec<BatchPutDoneItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for GroupedBatchPutDoneResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::GroupedBatchPutDoneResp as u32
+    }
+}
+impl RPCReq for GroupedBatchPutDoneReq {
+    type Resp = GroupedBatchPutDoneResp;
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutAppendStartReq {
     pub key: String,
     pub put_id: PutIDForAKey,
     pub len: u64,
     pub preferred_sub_cluster: Option<String>,
+    pub demote_source_on_remote_complete: bool,
+    pub protect_source_on_remote_complete: bool,
 }
 impl MsgPackSerializePart for PutAppendStartReq {
     fn msg_id(&self) -> u32 {
@@ -936,3 +1223,112 @@ impl MsgPackSerializePart for BatchDeleteClientKvMetaCacheResp {
 impl RPCReq for BatchDeleteClientKvMetaCacheReq {
     type Resp = BatchDeleteClientKvMetaCacheResp;
 }
+
+#[cfg(test)]
+mod put_atomic_group_tests {
+    use super::*;
+
+    #[test]
+    fn assignments_expand_only_multi_member_groups() {
+        let keys_and_put_ids = vec![
+            ("a".to_string(), (1, 0)),
+            ("b".to_string(), (1, 1)),
+            ("c".to_string(), (1, 2)),
+        ];
+        let assignments = build_put_atomic_group_assignments(&keys_and_put_ids, &[2, 1]).unwrap();
+        assert_eq!(assignments.len(), 3);
+        assert_eq!(assignments[0], assignments[1]);
+        assert_eq!(assignments[0].as_ref().unwrap().members.len(), 2);
+        assert!(assignments[2].is_none());
+    }
+
+    #[test]
+    fn assignments_reject_invalid_partitions() {
+        let keys_and_put_ids = vec![("a".to_string(), (1, 0)), ("b".to_string(), (1, 1))];
+        assert!(build_put_atomic_group_assignments(&keys_and_put_ids, &[1]).is_err());
+        assert!(build_put_atomic_group_assignments(&keys_and_put_ids, &[0, 2]).is_err());
+    }
+
+    #[test]
+    fn batch_put_done_group_round_trips_on_wire() {
+        let group = PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: "a".to_string(),
+                    put_id: (1, 0),
+                },
+                PutAtomicGroupMember {
+                    key: "b".to_string(),
+                    put_id: (1, 1),
+                },
+            ],
+        };
+        let req = BatchPutDoneReq {
+            items: vec![BatchPutDoneItemReq {
+                key: "a".to_string(),
+                put_id: (1, 0),
+                lease_id: None,
+                committed_slot: None,
+                publish_local_cache: false,
+                atomic_group: Some(group.clone()),
+            }],
+        };
+        let decoded: BatchPutDoneReq =
+            bitcode::decode(&bitcode::encode(&req)).expect("decode atomic put group");
+        assert_eq!(decoded.items[0].atomic_group.as_ref(), Some(&group));
+    }
+
+    #[test]
+    fn grouped_batch_put_done_wire_is_linear_and_round_trips() {
+        let keys_and_put_ids = (0..128)
+            .map(|index| (format!("page-{index:03}"), (7, index)))
+            .collect::<Vec<_>>();
+        let group = PutAtomicGroup {
+            members: keys_and_put_ids
+                .iter()
+                .map(|(key, put_id)| PutAtomicGroupMember {
+                    key: key.clone(),
+                    put_id: *put_id,
+                })
+                .collect(),
+        };
+        let legacy = BatchPutDoneReq {
+            items: keys_and_put_ids
+                .iter()
+                .map(|(key, put_id)| BatchPutDoneItemReq {
+                    key: key.clone(),
+                    put_id: *put_id,
+                    lease_id: None,
+                    committed_slot: None,
+                    publish_local_cache: false,
+                    atomic_group: Some(group.clone()),
+                })
+                .collect(),
+        };
+        let grouped = GroupedBatchPutDoneReq {
+            items: keys_and_put_ids
+                .iter()
+                .map(|(key, put_id)| GroupedBatchPutDoneItemReq {
+                    key: key.clone(),
+                    put_id: *put_id,
+                    lease_id: None,
+                    committed_slot: None,
+                    publish_local_cache: false,
+                })
+                .collect(),
+            atomic_group_lens: vec![128],
+        };
+        let legacy_bytes = bitcode::encode(&legacy);
+        let grouped_bytes = bitcode::encode(&grouped);
+        assert!(
+            grouped_bytes.len() * 16 < legacy_bytes.len(),
+            "grouped={} legacy={}",
+            grouped_bytes.len(),
+            legacy_bytes.len()
+        );
+        let decoded: GroupedBatchPutDoneReq =
+            bitcode::decode(&grouped_bytes).expect("decode grouped put done");
+        assert_eq!(decoded.items.len(), 128);
+        assert_eq!(decoded.atomic_group_lens, vec![128]);
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
index 69c5db0..1880278 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
@@ -391,7 +391,7 @@ fn no_space_error(last_no_space_ctx: Option<NoSpaceCtx>) -> KvError {
     }
 }
 
-fn member_matches_roles(member: Option<&ClusterMember>, roles: &[String]) -> bool {
+pub(super) fn member_matches_roles(member: Option<&ClusterMember>, roles: &[String]) -> bool {
     let Some(member) = member else {
         return false;
     };
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index 6849105..ccdf281 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -1,20 +1,21 @@
-use super::NodeValueReplicaDesc;
 use super::{
     CommittedSlotReplica, InflightPutAllocation, InflightPutCommitInfo, InflightPutInfo,
     InflightReplicaTaskInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo,
-    MasterKvRouterView, OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode,
-    ReservedCapacityReason,
+    MasterKeyActivityCompletionGuard, MasterKvRouterView, OwnerHoldingGetInfo,
+    PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
     msg_pack::{
         BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutDoneItemResp, BatchPutDoneReq,
         BatchPutDoneResp, BatchPutRevokeItemResp, BatchPutRevokeReq, BatchPutRevokeResp,
         BatchPutStartItemResp, BatchPutStartReq, BatchPutStartResp,
-        BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp, PutAppendDoneReq,
-        PutAppendDoneResp, PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartReq,
-        PutAppendStartResp, PutDoneReq, PutDoneResp, PutRevokeReq, PutRevokeResp, PutStartReq,
-        PutStartResp, ReleaseLocalGrantReq, ReleaseLocalGrantResp, ReserveLocalGrantReq,
-        ReserveLocalGrantResp,
+        BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
+        GroupedBatchPutDoneReq, GroupedBatchPutDoneResp, PutAppendDoneReq, PutAppendDoneResp,
+        PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartReq, PutAppendStartResp,
+        PutAtomicGroup, PutDoneReq, PutDoneResp, PutRevokeReq, PutRevokeResp, PutStartReq,
+        PutStartResp, ReleaseLocalGrantReq, ReleaseLocalGrantResp, ReserveLocalGrantOutcome,
+        ReserveLocalGrantReq, ReserveLocalGrantResp, build_shared_put_atomic_group_assignments,
     },
     placement::PutPlacementTarget,
+    route_maintenance::{RoutePublishEvent, enqueue_post_route_maintenance},
 };
 use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::delete::DeleteKeyInfo;
@@ -41,36 +42,6 @@ use std::{
 
 pub type PutIDForAKey = (u64, u32);
 
-struct InflightPutKeyReservation {
-    view: MasterKvRouterView,
-    key: String,
-    active: bool,
-}
-
-impl InflightPutKeyReservation {
-    fn new(view: MasterKvRouterView, key: String) -> Self {
-        Self {
-            view,
-            key,
-            active: true,
-        }
-    }
-
-    fn disarm(&mut self) {
-        self.active = false;
-    }
-}
-
-impl Drop for InflightPutKeyReservation {
-    fn drop(&mut self) {
-        if self.active {
-            self.view
-                .master_kv_router()
-                .release_inflight_put_key(&self.key);
-        }
-    }
-}
-
 fn validate_put_start_source_node_override(
     view: &MasterKvRouterView,
     requester_node_id: &NodeID,
@@ -192,7 +163,7 @@ fn append_current_route_replica_if_matching(
     put_id: PutIDForAKey,
     node_id: NodeID,
     allocation: Allocation,
-) -> bool {
+) -> Option<RoutePublishEvent> {
     let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) else {
         tracing::debug!(
             "append_current_route_replica_if_matching skipped because route disappeared: key={} put_id=({},{})",
@@ -200,7 +171,7 @@ fn append_current_route_replica_if_matching(
             put_id.0,
             put_id.1
         );
-        return false;
+        return None;
     };
     if one_kv_nodes_routes.put_id != put_id {
         tracing::debug!(
@@ -211,7 +182,7 @@ fn append_current_route_replica_if_matching(
             put_id.0,
             put_id.1
         );
-        return false;
+        return None;
     }
     let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
         tracing::warn!(
@@ -221,7 +192,7 @@ fn append_current_route_replica_if_matching(
             put_id.1,
             node_id
         );
-        return false;
+        return None;
     };
     if tomb_tag.is_tomb() {
         tracing::warn!(
@@ -231,42 +202,26 @@ fn append_current_route_replica_if_matching(
             put_id.1,
             node_id
         );
-        return false;
+        return None;
     }
-    let alloc_cap = allocation.capcity();
-    let req_weight = if alloc_cap > u32::MAX as u64 {
-        tracing::warn!(
-            "moka weight saturation on put append: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
-            key,
-            put_id.0,
-            put_id.1,
-            alloc_cap
-        );
-        u32::MAX
-    } else {
-        alloc_cap as u32
-    };
+    let capacity_bytes = allocation.capcity();
     let lease_id = one_kv_nodes_routes.lease_id;
     one_kv_nodes_routes.nodes_replicas.write().insert(
         node_id.clone(),
         KvRouteInfo {
             node_id: node_id.clone(),
             backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
+            owner_local_indexed: false,
             tomb_tag,
         },
     );
-    if lease_id.is_none() {
-        if let Some(cache) = view.master_kv_router().get_node_cache_controller(&node_id) {
-            cache.insert(
-                key.to_string(),
-                NodeValueReplicaDesc {
-                    weight_bytes: req_weight,
-                    put_id,
-                },
-            );
-        }
-    }
-    true
+    Some(RoutePublishEvent::replica_append(
+        key.to_string(),
+        put_id,
+        lease_id,
+        node_id,
+        capacity_bytes,
+    ))
 }
 
 fn allocate_from_node_local_segment(
@@ -331,6 +286,8 @@ fn reserve_replica_task(
         preferred_sub_cluster,
         len,
         &HashSet::new(),
+        false,
+        true,
     )
 }
 
@@ -342,7 +299,10 @@ fn reserve_replica_task_excluding(
     preferred_sub_cluster: Option<&str>,
     len: u64,
     excluded_nodes: &HashSet<NodeID>,
+    demote_source_on_remote_complete: bool,
+    protect_source_on_remote_complete: bool,
 ) -> msg_and_error::KvResult<InflightReplicaTaskInfo> {
+    let activity_lease = view.master_kv_router().reserve_inflight_replica_key(key)?;
     let (target_node_id, target_allocation) = view
         .master_kv_router()
         .inner()
@@ -366,9 +326,13 @@ fn reserve_replica_task_excluding(
     );
     Ok(InflightReplicaTaskInfo {
         node_id: target_node_id,
+        source_node_id: source_node_id.clone(),
         key: key.to_string(),
         put_id,
         target_allocation: Arc::new(Mutex::new(Some(target_allocation))),
+        demote_source_on_remote_complete,
+        protect_source_on_remote_complete,
+        _activity_lease: activity_lease,
     })
 }
 
@@ -377,24 +341,12 @@ async fn publish_completed_put_route(
     key: String,
     put_id: PutIDForAKey,
     lease_id_opt: Option<u64>,
+    atomic_group: Option<Arc<super::msg_pack::PutAtomicGroup>>,
     node_id: NodeID,
     completed_info: KvRouteInfo,
     target_cap_bytes: u64,
     local_cache_holder_id: Option<u64>,
 ) -> MsgPack<PutDoneResp> {
-    let saturated_weight_u32 = if target_cap_bytes > u32::MAX as u64 {
-        tracing::warn!(
-            "moka weight saturation: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
-            key,
-            put_id.0,
-            put_id.1,
-            target_cap_bytes
-        );
-        u32::MAX
-    } else {
-        target_cap_bytes as u32
-    };
-
     let mut old_one_kv_routes: Option<Arc<OneKvNodesRoutes>> = None;
     let mut inserted = false;
     {
@@ -408,6 +360,7 @@ async fn publish_completed_put_route(
                 Arc::new(OneKvNodesRoutes {
                     put_id,
                     lease_id: lease_id_opt,
+                    atomic_group: atomic_group.clone(),
                     nodes_replicas: RwLock::new(HashMap::new()),
                     get_durable_slots_used: AtomicU32::new(0),
                 })
@@ -417,6 +370,7 @@ async fn publish_completed_put_route(
             *one_kv_routes = Arc::new(OneKvNodesRoutes {
                 put_id,
                 lease_id: lease_id_opt,
+                atomic_group: atomic_group.clone(),
                 nodes_replicas: RwLock::new(HashMap::new()),
                 get_durable_slots_used: AtomicU32::new(0),
             });
@@ -443,48 +397,19 @@ async fn publish_completed_put_route(
         }
     }
 
-    {
-        let view_task = view.clone();
-        let key_for_spawn = key.clone();
-        let node_for_spawn = node_id.clone();
-        let do_prefix_index_update = view.master_kv_router().prefix_index_enabled();
-        let do_cache_insert =
-            lease_id_opt.is_none() && view.master_kv_router().replica_cache_enabled();
-        let cap_bytes_u32 = saturated_weight_u32;
-        view.spawn("post_put_done_maintenance", async move {
-            if do_prefix_index_update {
-                let inner = view_task.master_kv_router().inner();
-                let mut tree = inner.prefix_index.write().await;
-                tree.insert(&key_for_spawn);
-            }
-
-            if do_cache_insert {
-                let cache = view_task
-                    .master_kv_router()
-                    .get_node_cache_controller(&node_for_spawn);
-                if let Some(cache) = cache {
-                    let desc = NodeValueReplicaDesc {
-                        weight_bytes: cap_bytes_u32,
-                        put_id,
-                    };
-                    tracing::debug!("Inserting key: {:?} into cache", key_for_spawn);
-                    cache.insert(key_for_spawn.clone(), desc);
-                    tracing::debug!(
-                        "Inserted key: {:?} into cache, current cache size: {}",
-                        key_for_spawn,
-                        cache.weighted_size()
-                    );
-                } else {
-                    tracing::warn!(
-                        "No cache controller found for node: {}, node is not ready",
-                        node_for_spawn
-                    );
-                }
-            }
-        });
-    }
+    enqueue_post_route_maintenance(
+        &view,
+        RoutePublishEvent::primary_put(
+            key.clone(),
+            put_id,
+            lease_id_opt,
+            node_id.clone(),
+            target_cap_bytes,
+        ),
+    )
+    .await;
 
-    tracing::info!(
+    tracing::debug!(
         "Completed put operation with put_id: {:?}, key: {:?}",
         put_id,
         key
@@ -507,21 +432,23 @@ pub async fn handle_put_start(
     req_node_id: NodeID,
 ) -> (PutIDForAKey, MsgPack<PutStartResp>) {
     let key = req.serialize_part.key.clone();
-    if let Err(err) = view.master_kv_router().reserve_inflight_put_key(
+    let activity_lease = match view.master_kv_router().reserve_inflight_put_key(
         &key,
         req.serialize_part.reject_if_inflight_same_key,
         req.serialize_part.reject_if_exist_same_key,
     ) {
-        let resp: PutStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
-        return (
-            (0, 0),
-            MsgPack {
-                serialize_part: resp,
-                raw_bytes: Vec::new(),
-            },
-        );
-    }
-    let mut key_reservation = InflightPutKeyReservation::new(view.clone(), key.clone());
+        Ok(activity_lease) => activity_lease,
+        Err(err) => {
+            let resp: PutStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            return (
+                (0, 0),
+                MsgPack {
+                    serialize_part: resp,
+                    raw_bytes: Vec::new(),
+                },
+            );
+        }
+    };
     let source_node_id = match req.serialize_part.source_node_id.as_ref() {
         Some(source_node_id) => {
             let source_node_id: NodeID = source_node_id.clone().into();
@@ -588,6 +515,7 @@ pub async fn handle_put_start(
                 src_target_allocation: Arc::new(Mutex::new(Some(inflight_alloc))),
                 replica_target: replica_target.clone(),
             },
+            _activity_lease: activity_lease.clone(),
         };
 
         let view_task = view.clone();
@@ -637,9 +565,22 @@ pub async fn handle_put_start(
         }
     };
 
-    let put_target = Ok(PutPlacementTarget::Local {
-        node_id: source_node_id.clone(),
-    });
+    let put_target = if req.serialize_part.make_replica_task {
+        Ok(PutPlacementTarget::Local {
+            node_id: source_node_id.clone(),
+        })
+    } else {
+        view.master_kv_router()
+            .inner()
+            .policy
+            .select_put_target(
+                &view,
+                &source_node_id,
+                req.serialize_part.preferred_sub_cluster.as_deref(),
+                req.serialize_part.len,
+            )
+            .await
+    };
 
     match put_target {
         Ok(PutPlacementTarget::Local { node_id }) => {
@@ -738,9 +679,7 @@ pub async fn handle_put_start(
                 allocation_size,
                 replica_target,
             );
-            let result = fut.await;
-            key_reservation.disarm();
-            return result;
+            return fut.await;
         }
         Ok(PutPlacementTarget::Remote {
             node_id,
@@ -793,9 +732,7 @@ pub async fn handle_put_start(
                 allocation_size,
                 None,
             );
-            let result = fut.await;
-            key_reservation.disarm();
-            return result;
+            return fut.await;
         }
         Err(err) => {
             let resp: PutStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
@@ -815,9 +752,42 @@ pub async fn handle_reserve_local_grant(
     req: MsgPack<ReserveLocalGrantReq>,
     req_node_id: NodeID,
 ) -> (u64, MsgPack<ReserveLocalGrantResp>) {
-    let _ = req;
-
-    let mut allocation = match allocate_from_node_local_segment(
+    if req.serialize_part.reclaim_before_grow
+        && req.serialize_part.slot_size != 0
+        && req.serialize_part.required_free_slots != 0
+    {
+        let reclaimed = crate::master_kv_router::reclaim::reclaim_owner_slots_for_reserve(
+            &view,
+            &req_node_id,
+            req.serialize_part.slot_size,
+            req.serialize_part.required_free_slots,
+        )
+        .await;
+        tracing::info!(
+            "owner reserve proactive headroom reclaim: owner={} slot_size={} requested_slots={} reclaimed={}",
+            req_node_id,
+            req.serialize_part.slot_size,
+            req.serialize_part.required_free_slots,
+            reclaimed
+        );
+        if reclaimed != 0 {
+            return (
+                0,
+                MsgPack {
+                    serialize_part: ReserveLocalGrantResp {
+                        outcome: ReserveLocalGrantOutcome::Reclaimed {
+                            slot_size: req.serialize_part.slot_size,
+                            reclaimed_slots: reclaimed,
+                        },
+                        error_code: msg_and_error::OK,
+                        ..Default::default()
+                    },
+                    raw_bytes: Vec::new(),
+                },
+            );
+        }
+    }
+    let allocation = match allocate_from_node_local_segment(
         &view,
         &req_node_id,
         OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES,
@@ -825,6 +795,85 @@ pub async fn handle_reserve_local_grant(
     ) {
         Ok(allocation) => allocation,
         Err(err) => {
+            let physical_no_space = matches!(
+                &err,
+                msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace { .. })
+            );
+            if physical_no_space
+                && req.serialize_part.slot_size != 0
+                && req.serialize_part.required_free_slots != 0
+            {
+                let requested_eviction_weight = req
+                    .serialize_part
+                    .slot_size
+                    .saturating_mul(u64::from(req.serialize_part.required_free_slots));
+                let pending_eviction_weight = view
+                    .master_kv_router()
+                    .eviction_reclaim_pending_weight(req_node_id.as_ref());
+                let additional_eviction_weight =
+                    requested_eviction_weight.saturating_sub(pending_eviction_weight);
+                if additional_eviction_weight != 0 {
+                    if let Some(cache) = view
+                        .master_kv_router()
+                        .get_node_cache_controller(req_node_id.as_ref())
+                    {
+                        let weighted_size_before = cache.weighted_size();
+                        let recoverable_evicted_weight =
+                            view.master_kv_router().evict_recoverable_cache_weight(
+                                req_node_id.as_ref(),
+                                additional_eviction_weight,
+                            );
+                        let fallback_requested_weight =
+                            additional_eviction_weight.saturating_sub(recoverable_evicted_weight);
+                        let fallback_evicted_weight = if view
+                            .master_kv_router()
+                            .owner_cache_allows_unrecoverable_reserve_pressure_eviction(
+                                req_node_id.as_ref(),
+                            ) {
+                            cache.evict_some(fallback_requested_weight)
+                        } else {
+                            0
+                        };
+                        tracing::info!(
+                            "owner reserve requested moka eviction: owner={} slot_size={} requested_slots={} requested_weight={} pending_weight_before={} recoverable_evicted_weight={} fallback_requested_weight={} fallback_evicted_weight={} shortfall_weight={} weighted_size_before={} weighted_size_after={}",
+                            req_node_id,
+                            req.serialize_part.slot_size,
+                            req.serialize_part.required_free_slots,
+                            requested_eviction_weight,
+                            pending_eviction_weight,
+                            recoverable_evicted_weight,
+                            fallback_requested_weight,
+                            fallback_evicted_weight,
+                            fallback_requested_weight.saturating_sub(fallback_evicted_weight),
+                            weighted_size_before,
+                            cache.weighted_size()
+                        );
+                    }
+                }
+                let reclaimed = crate::master_kv_router::reclaim::reclaim_owner_slots_for_reserve(
+                    &view,
+                    &req_node_id,
+                    req.serialize_part.slot_size,
+                    req.serialize_part.required_free_slots,
+                )
+                .await;
+                if reclaimed != 0 {
+                    return (
+                        0,
+                        MsgPack {
+                            serialize_part: ReserveLocalGrantResp {
+                                outcome: ReserveLocalGrantOutcome::Reclaimed {
+                                    slot_size: req.serialize_part.slot_size,
+                                    reclaimed_slots: reclaimed,
+                                },
+                                error_code: msg_and_error::OK,
+                                ..Default::default()
+                            },
+                            raw_bytes: Vec::new(),
+                        },
+                    );
+                }
+            }
             let resp: ReserveLocalGrantResp =
                 crate::rpcresp_kvresult_convert::FromError::from_error(&err);
             return (
@@ -837,43 +886,6 @@ pub async fn handle_reserve_local_grant(
         }
     };
 
-    let reserved_bytes = allocation.capcity();
-    if let Err(err) = view.master_kv_router().adjust_node_cache_reserved_capacity(
-        req_node_id.as_ref(),
-        ReservedCapacityReason::LocalReserveGrant,
-        reserved_bytes as i64,
-    ) {
-        let resp: ReserveLocalGrantResp =
-            crate::rpcresp_kvresult_convert::FromError::from_error(&err);
-        return (
-            0,
-            MsgPack {
-                serialize_part: resp,
-                raw_bytes: Vec::new(),
-            },
-        );
-    }
-
-    let view_clone = view.clone();
-    let node_id_string = req_node_id.as_ref().to_string();
-    allocation.set_on_drop(move || {
-        if let Err(e) = view_clone
-            .master_kv_router()
-            .adjust_node_cache_reserved_capacity(
-                &node_id_string,
-                ReservedCapacityReason::LocalReserveGrant,
-                -(reserved_bytes as i64),
-            )
-        {
-            tracing::warn!(
-                "Failed to restore moka capacity on local reserve grant drop: node_id={}, bytes={}, err={}",
-                node_id_string,
-                reserved_bytes,
-                e
-            );
-        }
-    });
-
     let grant_id = view.master_kv_router().next_local_reserve_grant_id();
     let grant_base_addr = allocation.base_addr();
     let grant_abs_addr = grant_base_addr + allocation.addr();
@@ -890,11 +902,13 @@ pub async fn handle_reserve_local_grant(
         grant_id,
         MsgPack {
             serialize_part: ReserveLocalGrantResp {
-                grant_id,
-                node_id: req_node_id.into_owned(),
-                addr: grant_abs_addr,
-                base_addr: grant_base_addr,
-                len: grant_len,
+                outcome: ReserveLocalGrantOutcome::Granted {
+                    grant_id,
+                    node_id: req_node_id.into_owned(),
+                    addr: grant_abs_addr,
+                    base_addr: grant_base_addr,
+                    len: grant_len,
+                },
                 error_code: msg_and_error::OK,
                 error_json: String::new(),
                 server_process_us: 0,
@@ -952,29 +966,29 @@ pub async fn handle_batch_prepare_put_keys(
 ) -> (Vec<u64>, MsgPack<BatchPreparePutKeysResp>) {
     let mut reservation_ids = Vec::with_capacity(req.serialize_part.items.len());
     for item in req.serialize_part.items {
-        if let Err(err) = view.master_kv_router().reserve_inflight_put_key(
+        let activity_lease = match view.master_kv_router().reserve_inflight_put_key(
             &item.key,
             item.reject_if_inflight_same_key,
             item.reject_if_exist_same_key,
         ) {
-            for reservation_id in reservation_ids.drain(..) {
-                if let Some(info) = view
-                    .master_kv_router()
-                    .take_prepared_put_key_reservation(reservation_id)
-                {
-                    view.master_kv_router().release_inflight_put_key(&info.key);
+            Ok(activity_lease) => activity_lease,
+            Err(err) => {
+                for reservation_id in reservation_ids.drain(..) {
+                    let _ = view
+                        .master_kv_router()
+                        .take_prepared_put_key_reservation(reservation_id);
                 }
+                let resp: BatchPreparePutKeysResp =
+                    crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+                return (
+                    Vec::new(),
+                    MsgPack {
+                        serialize_part: resp,
+                        raw_bytes: Vec::new(),
+                    },
+                );
             }
-            let resp: BatchPreparePutKeysResp =
-                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
-            return (
-                Vec::new(),
-                MsgPack {
-                    serialize_part: resp,
-                    raw_bytes: Vec::new(),
-                },
-            );
-        }
+        };
         let reservation_id = view
             .master_kv_router()
             .next_prepared_put_key_reservation_id();
@@ -984,6 +998,7 @@ pub async fn handle_batch_prepare_put_keys(
                 PreparedPutKeyReservationInfo {
                     owner_node_id: req_node_id.clone(),
                     key: item.key,
+                    _activity_lease: activity_lease,
                 },
             );
         reservation_ids.push(reservation_id);
@@ -1043,9 +1058,7 @@ pub async fn handle_batch_release_put_key_reservations(
         taken.push((reservation_id, info));
     }
 
-    for (_reservation_id, info) in taken {
-        view.master_kv_router().release_inflight_put_key(&info.key);
-    }
+    drop(taken);
 
     MsgPack {
         serialize_part: BatchReleasePutKeyReservationsResp::default(),
@@ -1070,8 +1083,13 @@ pub async fn handle_put_revoke(
         .remove(&kvrouter_key)
         .await
     {
-        view.master_kv_router()
-            .release_inflight_put_key(&inflight_info.key);
+        let _activity_completion =
+            MasterKeyActivityCompletionGuard::new(inflight_info._activity_lease.clone());
+        let _replica_activity_completion = inflight_info
+            .commit_info
+            .replica_target
+            .as_ref()
+            .map(|target| MasterKeyActivityCompletionGuard::new(target._activity_lease.clone()));
         tracing::info!("Revoked put operation with put_id: {:?}", kvrouter_key);
     } else {
         tracing::warn!(
@@ -1090,6 +1108,15 @@ pub async fn handle_put_done(
     view: MasterKvRouterView,
     req: MsgPack<PutDoneReq>,
     req_node_id: NodeID,
+) -> MsgPack<PutDoneResp> {
+    handle_put_done_with_resolved_group(view, req, req_node_id, None).await
+}
+
+async fn handle_put_done_with_resolved_group(
+    view: MasterKvRouterView,
+    req: MsgPack<PutDoneReq>,
+    req_node_id: NodeID,
+    resolved_atomic_group: Option<Arc<PutAtomicGroup>>,
 ) -> MsgPack<PutDoneResp> {
     tracing::debug!("Handling PutDoneReq: {:?}", req.serialize_part);
 
@@ -1097,10 +1124,30 @@ pub async fn handle_put_done(
     let lease_id_opt = req.serialize_part.lease_id;
     let full_put_id: (String, u64, u32) = (req.serialize_part.key.clone(), put_id.0, put_id.1);
     let local_cache_holder_id: Option<u64>;
+    let atomic_group = if let Some(group) = resolved_atomic_group {
+        Some(group)
+    } else {
+        match view.master_kv_router().resolve_put_atomic_group(
+            &req.serialize_part.key,
+            put_id,
+            req.serialize_part.atomic_group.clone(),
+        ) {
+            Ok(group) => group,
+            Err(err) => {
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            }
+        }
+    };
 
     // Remove from inflight_puts and store in completed_puts
     if let Some(InflightPutInfo {
-        key, commit_info, ..
+        key,
+        commit_info,
+        _activity_lease,
+        ..
     }) = view
         .master_kv_router()
         .inner()
@@ -1108,7 +1155,11 @@ pub async fn handle_put_done(
         .remove(&full_put_id)
         .await
     {
-        view.master_kv_router().release_inflight_put_key(&key);
+        let _activity_completion = MasterKeyActivityCompletionGuard::new(_activity_lease);
+        let mut replica_activity_completion = commit_info
+            .replica_target
+            .as_ref()
+            .map(|target| MasterKeyActivityCompletionGuard::new(target._activity_lease.clone()));
         let node_id = commit_info.node_id;
         let Some(allocs) = commit_info.src_target_allocation.lock().take() else {
             tracing::warn!(
@@ -1159,7 +1210,7 @@ pub async fn handle_put_done(
         let (target_cap_bytes, completed_info, local_cache_publish_supported) = match allocs {
             InflightPutAllocation::Local(mut target_allocation) => {
                 if let Some(slot) = route_committed_slot {
-                    let target_cap_bytes = slot.len;
+                    let target_cap_bytes = slot.slot_size;
                     if let Some(lease_id) = lease_id_opt {
                         if let Err(e) = view
                             .master_lease_manager()
@@ -1202,6 +1253,7 @@ pub async fn handle_put_done(
                                 len: slot.len,
                                 base_addr: slot.base_addr,
                             }),
+                            owner_local_indexed: true,
                             tomb_tag,
                         },
                         false,
@@ -1238,6 +1290,14 @@ pub async fn handle_put_done(
                         let view_clone = view.clone();
                         let node_id_string = node_id.as_ref().to_string();
                         target_allocation.set_on_drop(move || {
+                            // The allocation can be released while FrameworkInner itself is
+                            // being dropped.  At that point the weak module view can no longer
+                            // be upgraded and restoring the runtime Moka reservation is both
+                            // impossible and unnecessary.  Keep an upgrade guard alive for the
+                            // whole callback so dependency access cannot race the final drop.
+                            let Some(_view_guard) = view_clone.try_upgrade() else {
+                                return;
+                            };
                             if let Err(e) = view_clone
                                 .master_kv_router()
                                 .adjust_node_cache_reserved_capacity(
@@ -1260,6 +1320,7 @@ pub async fn handle_put_done(
                         KvRouteInfo {
                             node_id: node_id.clone(),
                             backing: KvReplicaBacking::Allocation(Arc::new(target_allocation)),
+                            owner_local_indexed: req.serialize_part.publish_local_cache,
                             tomb_tag,
                         },
                         true,
@@ -1303,6 +1364,11 @@ pub async fn handle_put_done(
                     let view_clone = view.clone();
                     let node_id_string = node_id.as_ref().to_string();
                     target.set_on_drop(move || {
+                        // See the equivalent local-placement callback above.  A final framework
+                        // teardown must not call back into the module currently being destroyed.
+                        let Some(_view_guard) = view_clone.try_upgrade() else {
+                            return;
+                        };
                         if let Err(e) = view_clone
                             .master_kv_router()
                             .adjust_node_cache_reserved_capacity(
@@ -1325,13 +1391,14 @@ pub async fn handle_put_done(
                     KvRouteInfo {
                         node_id: node_id.clone(),
                         backing: KvReplicaBacking::Allocation(Arc::new(target)),
+                        owner_local_indexed: false,
                         tomb_tag,
                     },
                     false,
                 )
             }
             InflightPutAllocation::LocalCommittedSlot(slot) => {
-                let target_cap_bytes = slot.len;
+                let target_cap_bytes = slot.slot_size;
                 if let Some(lease_id) = lease_id_opt {
                     if let Err(e) = view
                         .master_lease_manager()
@@ -1367,6 +1434,7 @@ pub async fn handle_put_done(
                     KvRouteInfo {
                         node_id: node_id.clone(),
                         backing: KvReplicaBacking::CommittedSlot(slot),
+                        owner_local_indexed: true,
                         tomb_tag,
                     },
                     false,
@@ -1374,19 +1442,6 @@ pub async fn handle_put_done(
             }
         };
 
-        // NOTE on weight sizing for moka cache:
-        // - moka's `weigher` returns a u32 per-entry weight while the cache's
-        //   `max_capacity` and `weighted_size()` use u64. If an allocation's
-        //   capacity exceeds u32::MAX (e.g., >= 4 GiB), a naive `as u32` cast
-        //   would truncate and could become 0 for ~exact 4 GiB multiples.
-        //   That would effectively disable size-based eviction because such
-        //   entries would contribute 0 to the cache weight and the cache would
-        //   never reach its configured capacity. This directly causes the
-        //   observed "non‑lease mode eviction not working; puts fill to full".
-        // - To make eviction robust, we saturate the per-entry weight at
-        //   u32::MAX when `capcity()` is larger than u32::MAX. This keeps the
-        //   cache accounting conservative (evicts earlier rather than later)
-        //   and prevents weight=0 due to truncation.
         local_cache_holder_id = if req.serialize_part.publish_local_cache {
             if !local_cache_publish_supported {
                 let err = msg_and_error::KvError::Api(
@@ -1435,20 +1490,6 @@ pub async fn handle_put_done(
             None
         };
 
-        let saturated_weight_u32 = if target_cap_bytes > u32::MAX as u64 {
-            tracing::warn!(
-                "moka weight saturation: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
-                key,
-                put_id.0,
-                put_id.1,
-                target_cap_bytes
-            );
-            u32::MAX
-        } else {
-            target_cap_bytes as u32
-        };
-        // Note: moka cache insertion happens after commit in a spawned task
-        // using the same saturated weight; avoid unused local here.
         // Insert into kv_routes with replica support
         let mut old_one_kv_routes: Option<Arc<OneKvNodesRoutes>> = None;
         let mut inserted = false;
@@ -1463,6 +1504,7 @@ pub async fn handle_put_done(
                     Arc::new(OneKvNodesRoutes {
                         put_id,
                         lease_id: lease_id_opt,
+                        atomic_group: atomic_group.clone(),
                         nodes_replicas: RwLock::new(HashMap::new()),
                         get_durable_slots_used: AtomicU32::new(0),
                     })
@@ -1473,6 +1515,7 @@ pub async fn handle_put_done(
                 *one_kv_routes = Arc::new(OneKvNodesRoutes {
                     put_id,
                     lease_id: lease_id_opt,
+                    atomic_group: atomic_group.clone(),
                     nodes_replicas: RwLock::new(HashMap::new()),
                     get_durable_slots_used: AtomicU32::new(0),
                 });
@@ -1496,6 +1539,10 @@ pub async fn handle_put_done(
                     replica_target,
                 )
                 .await;
+            replica_activity_completion
+                .as_mut()
+                .expect("replica target activity guard must exist")
+                .disarm();
         }
 
         if let Some(old) = old_one_kv_routes {
@@ -1514,58 +1561,21 @@ pub async fn handle_put_done(
             }
         }
 
-        // Post-commit maintenance: update prefix-count index (for CountPrefix RPC)
-        // and, if applicable, update per-node cache controller. Run both in a
-        // spawned task to keep the PutDone RPC path lean and consistent with
-        // other async cache control operations. Deletion path already removes
-        // the index entry in delete.rs (do_delete_one_kv_all_replicas).
-        {
-            let view_task = view.clone();
-            let key_for_spawn = key.clone();
-            let node_for_spawn = node_id.clone();
-            let do_prefix_index_update = view.master_kv_router().prefix_index_enabled();
-            let do_cache_insert =
-                lease_id_opt.is_none() && view.master_kv_router().replica_cache_enabled();
-            // Reuse the saturated weight computed above for moka insertion
-            let cap_bytes_u32 = saturated_weight_u32;
-            view.spawn("post_put_done_maintenance", async move {
-                // 1) Update prefix-counting index
-                if do_prefix_index_update {
-                    let inner = view_task.master_kv_router().inner();
-                    let mut tree = inner.prefix_index.write().await;
-                    tree.insert(&key_for_spawn);
-                }
-
-                // 2) Optionally update node cache controller (non-leased keys)
-                if do_cache_insert {
-                    let cache = view_task
-                        .master_kv_router()
-                        .get_node_cache_controller(&node_for_spawn);
-                    if let Some(cache) = cache {
-                        let desc = NodeValueReplicaDesc {
-                            weight_bytes: cap_bytes_u32,
-                            put_id,
-                        };
-                        tracing::debug!("Inserting key: {:?} into cache", key_for_spawn);
-                        cache.insert(key_for_spawn.clone(), desc);
-                        tracing::debug!(
-                            "Inserted key: {:?} into cache, current cache size: {}",
-                            key_for_spawn,
-                            cache.weighted_size()
-                        );
-                    } else {
-                        tracing::warn!(
-                            "No cache controller found for node: {}, node is not ready",
-                            node_for_spawn
-                        );
-                    }
-                }
-            });
-        }
+        enqueue_post_route_maintenance(
+            &view,
+            RoutePublishEvent::primary_put(
+                key.clone(),
+                put_id,
+                lease_id_opt,
+                node_id.clone(),
+                target_cap_bytes,
+            ),
+        )
+        .await;
 
         // Lease attach is handled before kv_routes insertion
 
-        tracing::info!(
+        tracing::debug!(
             "Completed put operation with put_id: {:?}, key: {:?}",
             put_id,
             key
@@ -1573,6 +1583,20 @@ pub async fn handle_put_done(
     } else {
         if let Some(slot) = req.serialize_part.committed_slot.clone() {
             let key = req.serialize_part.key.clone();
+            let _activity_lease = match view
+                .master_kv_router()
+                .reserve_inflight_put_key(&key, false, false)
+            {
+                Ok(activity_lease) => activity_lease,
+                Err(err) => {
+                    return MsgPack {
+                        serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                            &err,
+                        ),
+                        raw_bytes: Vec::new(),
+                    };
+                }
+            };
             let node_id = req_node_id;
             let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
                 let err = msg_and_error::KvError::Api(
@@ -1615,7 +1639,7 @@ pub async fn handle_put_done(
                     raw_bytes: Vec::new(),
                 };
             }
-            let target_cap_bytes = slot.len;
+            let target_cap_bytes = slot.slot_size;
             if let Some(lease_id) = lease_id_opt {
                 if let Err(e) = view
                     .master_lease_manager()
@@ -1655,6 +1679,7 @@ pub async fn handle_put_done(
                     len: slot.len,
                     base_addr: slot.base_addr,
                 }),
+                owner_local_indexed: true,
                 tomb_tag,
             };
             return publish_completed_put_route(
@@ -1662,6 +1687,7 @@ pub async fn handle_put_done(
                 key,
                 put_id,
                 lease_id_opt,
+                atomic_group,
                 node_id,
                 completed_info,
                 target_cap_bytes,
@@ -1795,6 +1821,7 @@ pub async fn handle_batch_put_done(
                     lease_id,
                     committed_slot: item.committed_slot,
                     publish_local_cache: item.publish_local_cache,
+                    atomic_group: item.atomic_group,
                 },
                 raw_bytes: Vec::new(),
             },
@@ -1821,6 +1848,115 @@ pub async fn handle_batch_put_done(
     }
 }
 
+/// V2 route publication for local-first puts. The wire carries each key once
+/// plus a compact ordered partition. The master materializes one shared group
+/// descriptor per partition and passes cheap `Arc` clones to member routes,
+/// avoiding both repeated wire descriptors and repeated group validation.
+pub async fn handle_grouped_batch_put_done(
+    view: MasterKvRouterView,
+    req: MsgPack<GroupedBatchPutDoneReq>,
+    req_node_id: NodeID,
+) -> MsgPack<GroupedBatchPutDoneResp> {
+    let GroupedBatchPutDoneReq {
+        items: request_items,
+        atomic_group_lens,
+    } = req.serialize_part;
+    let keys_and_put_ids = request_items
+        .iter()
+        .map(|item| (item.key.clone(), item.put_id))
+        .collect::<Vec<_>>();
+    let assignments =
+        match build_shared_put_atomic_group_assignments(&keys_and_put_ids, &atomic_group_lens) {
+            Ok(assignments) => assignments,
+            Err(detail) => {
+                let err = msg_and_error::ApiError::InvalidArgument { detail };
+                let (error_code, error_json) = err.to_code_and_json();
+                return MsgPack {
+                    serialize_part: GroupedBatchPutDoneResp {
+                        items: Vec::new(),
+                        error_code,
+                        error_json,
+                        server_process_us: 0,
+                    },
+                    raw_bytes: Vec::new(),
+                };
+            }
+        };
+
+    // The partition builder derives membership from these exact ordered items.
+    // Reject duplicate/empty keys once per group so every member is represented
+    // exactly once before any route becomes visible.
+    let mut offset = 0usize;
+    for group_len in atomic_group_lens.iter().copied() {
+        if group_len > 1 {
+            let mut unique = HashSet::with_capacity(group_len);
+            let end = offset + group_len;
+            if keys_and_put_ids[offset..end]
+                .iter()
+                .any(|(key, _)| key.is_empty() || !unique.insert(key.as_str()))
+            {
+                let err = msg_and_error::ApiError::InvalidArgument {
+                    detail: format!(
+                        "grouped put member keys must be non-empty and unique: offset={} len={}",
+                        offset, group_len
+                    ),
+                };
+                let (error_code, error_json) = err.to_code_and_json();
+                return MsgPack {
+                    serialize_part: GroupedBatchPutDoneResp {
+                        items: Vec::new(),
+                        error_code,
+                        error_json,
+                        server_process_us: 0,
+                    },
+                    raw_bytes: Vec::new(),
+                };
+            }
+        }
+        offset += group_len;
+    }
+
+    let mut items = Vec::with_capacity(request_items.len());
+    for (item, atomic_group) in request_items.into_iter().zip(assignments) {
+        let key = item.key.clone();
+        let put_id = item.put_id;
+        let resp = handle_put_done_with_resolved_group(
+            view.clone(),
+            MsgPack {
+                serialize_part: PutDoneReq {
+                    key,
+                    put_id,
+                    lease_id: item.lease_id,
+                    committed_slot: item.committed_slot,
+                    publish_local_cache: item.publish_local_cache,
+                    atomic_group: None,
+                },
+                raw_bytes: Vec::new(),
+            },
+            req_node_id.clone(),
+            atomic_group,
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchPutDoneItemResp {
+            key: item.key,
+            put_id: item.put_id,
+            error_code: part.error_code,
+            error_json: part.error_json,
+            local_cache_holder_id: part.local_cache_holder_id,
+        });
+    }
+    MsgPack {
+        serialize_part: GroupedBatchPutDoneResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
 pub async fn handle_put_append_start(
     view: MasterKvRouterView,
     req: MsgPack<PutAppendStartReq>,
@@ -1839,12 +1975,20 @@ pub async fn handle_put_append_start(
         .map(|route| current_route_needs_remote_replica(route, &req_node_id, put_id))
         .unwrap_or(false);
     if !current_route_still_needs_remote {
-        let _ = view
+        if let Some(inflight) = view
             .master_kv_router()
             .inner()
             .inflight_replica_tasks
             .remove(&(key.clone(), put_id.0, put_id.1))
-            .await;
+            .await
+        {
+            inflight._activity_lease.release_now();
+        }
+        if req.serialize_part.demote_source_on_remote_complete {
+            view.master_kv_router()
+                .demote_owner_hot_cohort_if_recoverable(req_node_id.as_ref(), &key, put_id)
+                .await;
+        }
         return MsgPack {
             serialize_part: PutAppendStartResp {
                 scheduled: false,
@@ -1887,6 +2031,8 @@ pub async fn handle_put_append_start(
             req.serialize_part.preferred_sub_cluster.as_deref(),
             req.serialize_part.len,
             &excluded_nodes,
+            req.serialize_part.demote_source_on_remote_complete,
+            req.serialize_part.protect_source_on_remote_complete,
         ) {
             Ok(reservation) => reservation,
             Err(msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
@@ -1978,12 +2124,15 @@ pub async fn handle_put_append_revoke(
 ) -> MsgPack<PutAppendRevokeResp> {
     let put_id = req.serialize_part.put_id;
     let key = req.serialize_part.key;
-    let _ = view
+    if let Some(inflight) = view
         .master_kv_router()
         .inner()
         .inflight_replica_tasks
         .remove(&(key, put_id.0, put_id.1))
-        .await;
+        .await
+    {
+        inflight._activity_lease.release_now();
+    }
     MsgPack {
         serialize_part: PutAppendRevokeResp {
             error_code: msg_and_error::OK,
@@ -2017,6 +2166,8 @@ pub async fn handle_put_append_done(
             raw_bytes: Vec::new(),
         };
     };
+    let _activity_completion =
+        MasterKeyActivityCompletionGuard::new(inflight._activity_lease.clone());
     let Some(allocation) = inflight.target_allocation.lock().take() else {
         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
             detail: format!(
@@ -2029,13 +2180,22 @@ pub async fn handle_put_append_done(
             raw_bytes: Vec::new(),
         };
     };
-    let appended = append_current_route_replica_if_matching(
+    let published = append_current_route_replica_if_matching(
         &view,
         &key,
         inflight.put_id,
         inflight.node_id,
         allocation,
     );
+    let appended = published.is_some();
+    if let Some(event) = published {
+        enqueue_post_route_maintenance(&view, event).await;
+    }
+    if inflight.demote_source_on_remote_complete {
+        view.master_kv_router()
+            .demote_owner_hot_cohort_if_recoverable(inflight.source_node_id.as_ref(), &key, put_id)
+            .await;
+    }
     MsgPack {
         serialize_part: PutAppendDoneResp {
             appended,
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
new file mode 100644
index 0000000..8a4223c
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
@@ -0,0 +1,1291 @@
+use super::{KvReplicaBacking, MasterKvRouterView, NodeValueReplicaDesc};
+use crate::cluster_manager::{NodeID, NodeIDString};
+use crate::master_kv_router::msg_pack::{
+    BatchOwnerReclaimReq, OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimItemResp,
+    OwnerReclaimItemState, OwnerReclaimPhase, OwnerReclaimReason,
+};
+use crate::memholder::MemholderManagerTrait;
+use crate::p2p::msg_pack::{MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, RPCCaller};
+use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+use limit_thirdparty::tokio;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::future::Future;
+use std::sync::atomic::Ordering;
+use std::time::{Duration, Instant};
+
+const OWNER_RECLAIM_RPC_TIMEOUT: Duration = Duration::from_secs(MIN_EXPLICIT_RPC_TIMEOUT_SECS);
+const OWNER_RECLAIM_MAX_BATCH: usize = 256;
+const OWNER_RECLAIM_MERGE_WINDOW: Duration = Duration::from_millis(5);
+const EVICTION_RECLAIM_RETRY_INITIAL: Duration = Duration::from_millis(100);
+const EVICTION_RECLAIM_RETRY_MAX: Duration = Duration::from_secs(1);
+const EVICTION_RECLAIM_MAX_RETRY_COUNT: u32 = 5;
+
+fn should_restore_after_retry(retry_count: u32) -> bool {
+    retry_count >= EVICTION_RECLAIM_MAX_RETRY_COUNT
+}
+
+fn eviction_reclaim_retry_delay(retry_count: u32) -> Duration {
+    let multiplier = 1u32 << retry_count.saturating_sub(1).min(16);
+    EVICTION_RECLAIM_RETRY_INITIAL
+        .saturating_mul(multiplier)
+        .min(EVICTION_RECLAIM_RETRY_MAX)
+}
+
+#[cfg(test)]
+mod timeout_contract_tests {
+    use super::*;
+    use crate::p2p::msg_pack::validate_explicit_rpc_timeout;
+
+    #[test]
+    fn owner_reclaim_timeout_satisfies_rpc_contract() {
+        validate_explicit_rpc_timeout(Some(OWNER_RECLAIM_RPC_TIMEOUT)).unwrap();
+    }
+
+    #[test]
+    fn eviction_reclaim_retry_restoration_is_bounded() {
+        assert!(!should_restore_after_retry(
+            EVICTION_RECLAIM_MAX_RETRY_COUNT - 1
+        ));
+        assert!(should_restore_after_retry(EVICTION_RECLAIM_MAX_RETRY_COUNT));
+        assert!(should_restore_after_retry(u32::MAX));
+    }
+
+    #[test]
+    fn eviction_reclaim_retry_paces_restore_view_holders() {
+        assert_eq!(eviction_reclaim_retry_delay(1), Duration::from_millis(100));
+        assert_eq!(eviction_reclaim_retry_delay(2), Duration::from_millis(200));
+        assert_eq!(eviction_reclaim_retry_delay(3), Duration::from_millis(400));
+        assert_eq!(eviction_reclaim_retry_delay(4), Duration::from_millis(800));
+        assert_eq!(
+            eviction_reclaim_retry_delay(u32::MAX),
+            Duration::from_secs(1)
+        );
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct EvictionReclaimRequest {
+    pub owner_node_id: NodeIDString,
+    pub key: String,
+    pub desc: NodeValueReplicaDesc,
+    pub retry_count: u32,
+}
+
+fn route_item(
+    view: &MasterKvRouterView,
+    owner_node_id: &NodeID,
+    key: &str,
+    expected_put_id: Option<(u64, u32)>,
+    required_slot_size: Option<u64>,
+    reason: OwnerReclaimReason,
+    epoch: u64,
+) -> Option<OwnerReclaimItem> {
+    let route = view.master_kv_router().inner().kv_routes.get(key)?.clone();
+    if expected_put_id.is_some_and(|put_id| put_id != route.put_id) || route.lease_id.is_some() {
+        return None;
+    }
+    let replicas = route.nodes_replicas.read();
+    let target = replicas.get(owner_node_id)?;
+    if target.tomb_tag.is_tomb() {
+        return None;
+    }
+    let backing = match &target.backing {
+        KvReplicaBacking::Allocation(_) if required_slot_size.is_none() => {
+            if target.owner_local_indexed {
+                OwnerReclaimBacking::Allocation
+            } else {
+                OwnerReclaimBacking::UnindexedAllocation
+            }
+        }
+        KvReplicaBacking::Allocation(_) => return None,
+        KvReplicaBacking::CommittedSlot(slot)
+            if slot.owner_node_id == *owner_node_id
+                && required_slot_size.map_or(true, |slot_size| slot.slot_size == slot_size) =>
+        {
+            OwnerReclaimBacking::CommittedSlot {
+                grant_id: slot.grant_id,
+                slot_index: slot.slot_index,
+                slot_size: slot.slot_size,
+            }
+        }
+        KvReplicaBacking::CommittedSlot(_) => return None,
+    };
+    let has_other_live_replica = replicas
+        .iter()
+        .any(|(node_id, replica)| node_id != owner_node_id && !replica.tomb_tag.is_tomb());
+    drop(replicas);
+    if reason == OwnerReclaimReason::Reserve {
+        let normally_recoverable = has_other_live_replica
+            && (view
+                .master_kv_router()
+                .owner_cache_allows_unrecoverable_eviction(owner_node_id.as_ref())
+                || {
+                    let desc = NodeValueReplicaDesc {
+                        weight_bytes: 0,
+                        put_id: route.put_id,
+                    };
+                    view.master_kv_router()
+                        .eviction_cache_entry_recoverable_status(owner_node_id.as_ref(), key, &desc)
+                        == super::RecoverableReplicaStatus::Recoverable
+                });
+        if !normally_recoverable
+            && !view
+                .master_kv_router()
+                .owner_cache_allows_unrecoverable_reserve_pressure_eviction(owner_node_id.as_ref())
+        {
+            return None;
+        }
+    }
+    Some(OwnerReclaimItem {
+        key: key.to_string(),
+        put_id: route.put_id,
+        epoch,
+        backing,
+        reason,
+    })
+}
+
+fn master_has_holder(view: &MasterKvRouterView, key: &str) -> bool {
+    view.master_kv_router()
+        .inner()
+        .get_holding
+        .inner()
+        .iter()
+        .any(|entry| entry.value().key == key)
+}
+
+fn item_still_valid(view: &MasterKvRouterView, owner: &NodeID, item: &OwnerReclaimItem) -> bool {
+    if !view
+        .master_kv_router()
+        .inner()
+        .key_activity
+        .reclaim_matches(item)
+    {
+        return false;
+    }
+    route_item(
+        view,
+        owner,
+        &item.key,
+        Some(item.put_id),
+        match &item.backing {
+            OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation => None,
+            OwnerReclaimBacking::CommittedSlot { slot_size, .. } => Some(*slot_size),
+        },
+        item.reason,
+        item.epoch,
+    )
+    .is_some_and(|current| current.backing == item.backing && current.reason == item.reason)
+}
+
+async fn call_owner_phase(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    phase: OwnerReclaimPhase,
+    items: Vec<OwnerReclaimItem>,
+) -> Result<Vec<OwnerReclaimItemResp>, String> {
+    if items.is_empty() {
+        return Ok(Vec::new());
+    }
+    debug_assert!(
+        items
+            .iter()
+            .all(|item| item.backing != OwnerReclaimBacking::UnindexedAllocation)
+    );
+    let caller = RPCCaller::<BatchOwnerReclaimReq>::new();
+    caller.regist(view.p2p_module());
+    let resp = caller
+        .call(
+            view.p2p_module(),
+            owner.clone(),
+            MsgPack {
+                serialize_part: BatchOwnerReclaimReq {
+                    phase,
+                    items: items.clone(),
+                },
+                raw_bytes: Vec::new(),
+            },
+            Some(OWNER_RECLAIM_RPC_TIMEOUT),
+            1,
+        )
+        .await
+        .map_err(|err| format!("{err:?}"))?;
+    if resp.serialize_part.error_code != OK {
+        return Err(format!(
+            "code={} error={}",
+            resp.serialize_part.error_code, resp.serialize_part.error_json
+        ));
+    }
+    if resp.serialize_part.items.len() != items.len() {
+        return Err(format!(
+            "owner reclaim response length mismatch: phase={phase:?} expected={} got={}",
+            items.len(),
+            resp.serialize_part.items.len()
+        ));
+    }
+    for (request, response) in items.iter().zip(resp.serialize_part.items.iter()) {
+        if request.key != response.key || request.epoch != response.epoch {
+            return Err(format!(
+                "owner reclaim response identity mismatch: phase={phase:?} request=({}, {}) response=({}, {})",
+                request.key, request.epoch, response.key, response.epoch
+            ));
+        }
+    }
+    Ok(resp.serialize_part.items)
+}
+
+fn clear_master_fence(view: &MasterKvRouterView, item: &OwnerReclaimItem) {
+    let cleared = view
+        .master_kv_router()
+        .inner()
+        .key_activity
+        .clear_reclaim(item);
+    if !cleared {
+        tracing::warn!(
+            "owner reclaim master fence did not match during cleanup: key={} epoch={}",
+            item.key,
+            item.epoch
+        );
+    }
+}
+
+async fn abort_prepared(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    items: Vec<OwnerReclaimItem>,
+) -> Vec<OwnerReclaimItem> {
+    if items.is_empty() {
+        return Vec::new();
+    }
+    match call_owner_phase(view, owner, OwnerReclaimPhase::Abort, items.clone()).await {
+        Ok(responses) => {
+            let mut already_committed = Vec::new();
+            for (item, response) in items.into_iter().zip(responses.into_iter()) {
+                match response.state {
+                    OwnerReclaimItemState::Committed => already_committed.push(item),
+                    OwnerReclaimItemState::Aborted
+                    | OwnerReclaimItemState::Stale
+                    | OwnerReclaimItemState::Finalized => clear_master_fence(view, &item),
+                    state => tracing::warn!(
+                        "owner reclaim abort returned unresolved state: key={} epoch={} state={:?} detail={}",
+                        item.key,
+                        item.epoch,
+                        state,
+                        response.detail
+                    ),
+                }
+            }
+            already_committed
+        }
+        Err(err) => {
+            tracing::warn!(
+                "owner reclaim abort RPC failed; retaining master fences: owner={} keys={} err={}",
+                owner,
+                items.len(),
+                err
+            );
+            spawn_abort_retry(view.clone(), owner.clone(), items);
+            Vec::new()
+        }
+    }
+}
+
+fn spawn_abort_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<OwnerReclaimItem>) {
+    if items.is_empty() {
+        return;
+    }
+    let spawn_view = view.clone();
+    let _ = spawn_view.spawn("owner_reclaim_abort_retry", async move {
+        let mut pending = items;
+        let mut committed = Vec::new();
+        let mut delay = Duration::from_millis(25);
+        for _attempt in 1..=8 {
+            tokio::time::sleep(delay).await;
+            match call_owner_phase(&view, &owner, OwnerReclaimPhase::Abort, pending.clone()).await {
+                Ok(responses) => {
+                    let mut next = Vec::new();
+                    for (item, response) in pending.into_iter().zip(responses.into_iter()) {
+                        match response.state {
+                            OwnerReclaimItemState::Committed => committed.push(item),
+                            OwnerReclaimItemState::Aborted
+                            | OwnerReclaimItemState::Stale
+                            | OwnerReclaimItemState::Finalized => clear_master_fence(&view, &item),
+                            _ => next.push(item),
+                        }
+                    }
+                    pending = next;
+                    if pending.is_empty() {
+                        break;
+                    }
+                }
+                Err(err) => tracing::warn!(
+                    "owner reclaim abort retry failed: owner={} keys={} err={}",
+                    owner,
+                    pending.len(),
+                    err
+                ),
+            }
+            delay = (delay * 2).min(Duration::from_secs(1));
+        }
+        if !committed.is_empty() {
+            let _ = finish_committed(&view, &owner, committed).await;
+        }
+        if !pending.is_empty() {
+            tracing::error!(
+                "owner reclaim abort retry exhausted; fences retained: owner={} keys={}",
+                owner,
+                pending.len()
+            );
+        }
+    });
+}
+
+fn reclaim_backing_matches(replica: &super::KvRouteInfo, expected: &OwnerReclaimBacking) -> bool {
+    match (&replica.backing, expected) {
+        (KvReplicaBacking::Allocation(_), OwnerReclaimBacking::Allocation) => {
+            replica.owner_local_indexed
+        }
+        (KvReplicaBacking::Allocation(_), OwnerReclaimBacking::UnindexedAllocation) => {
+            !replica.owner_local_indexed
+        }
+        (
+            KvReplicaBacking::CommittedSlot(slot),
+            OwnerReclaimBacking::CommittedSlot {
+                grant_id,
+                slot_index,
+                slot_size,
+            },
+        ) => {
+            slot.grant_id == *grant_id
+                && slot.slot_index == *slot_index
+                && slot.slot_size == *slot_size
+        }
+        _ => false,
+    }
+}
+
+fn remove_reclaimed_replica(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+) -> bool {
+    if !view
+        .master_kv_router()
+        .inner()
+        .key_activity
+        .reclaim_matches(item)
+    {
+        return false;
+    }
+    let _route_guard = view.master_kv_router().inner().route_lifetime_lock.lock();
+    let Some(route) = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .get(&item.key)
+        .map(|route| route.clone())
+    else {
+        return true;
+    };
+    if route.put_id != item.put_id {
+        return true;
+    }
+    let removed = {
+        let mut replicas = route.nodes_replicas.write();
+        let Some(replica) = replicas.get(owner) else {
+            return true;
+        };
+        if !reclaim_backing_matches(replica, &item.backing) {
+            // This backing is no longer advertised by the fenced route version.
+            return true;
+        }
+        replicas.remove(owner).is_some()
+    };
+    if !removed {
+        return true;
+    }
+
+    if route.nodes_replicas.read().is_empty() {
+        let route_removed = view
+            .master_kv_router()
+            .inner()
+            .kv_routes
+            .remove_if(&item.key, |_, current| current.put_id == item.put_id)
+            .is_some();
+        if route_removed && view.master_kv_router().prefix_index_enabled() {
+            let view_task = view.clone();
+            let key = item.key.clone();
+            let put_id = item.put_id;
+            let spawn_view = view.clone();
+            let _ = spawn_view.spawn("owner_reclaim_remove_prefix", async move {
+                let mut tree = view_task
+                    .master_kv_router()
+                    .inner()
+                    .prefix_index
+                    .write()
+                    .await;
+                tree.remove(&key, put_id);
+            });
+        }
+    }
+    if let Some(cache) = view
+        .master_kv_router()
+        .get_node_cache_controller(owner.as_ref())
+    {
+        let _ = cache.remove(&item.key);
+    }
+    view.master_kv_router()
+        .remove_node_writeback_tier1_entry(owner.as_ref(), &item.key);
+    true
+}
+
+fn finish_unindexed_allocations(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    items: Vec<OwnerReclaimItem>,
+) -> u32 {
+    let mut reclaimed = 0u32;
+    for item in items {
+        debug_assert_eq!(item.backing, OwnerReclaimBacking::UnindexedAllocation);
+        if remove_reclaimed_replica(view, owner, &item) {
+            clear_master_fence(view, &item);
+            reclaimed = reclaimed.saturating_add(1);
+        } else {
+            tracing::error!(
+                "unindexed allocation reclaim backing could not be removed from master route: owner={} key={} epoch={}",
+                owner,
+                item.key,
+                item.epoch
+            );
+        }
+    }
+    reclaimed
+}
+
+fn partition_reclaim_coordination(
+    items: Vec<OwnerReclaimItem>,
+) -> (Vec<OwnerReclaimItem>, Vec<OwnerReclaimItem>) {
+    items
+        .into_iter()
+        .partition(|item| item.backing == OwnerReclaimBacking::UnindexedAllocation)
+}
+
+async fn finish_committed(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    items: Vec<OwnerReclaimItem>,
+) -> u32 {
+    let mut removed = Vec::new();
+    for item in items {
+        if remove_reclaimed_replica(view, owner, &item) {
+            removed.push(item);
+        } else {
+            tracing::error!(
+                "owner reclaim backing could not be removed from master route: owner={} key={} epoch={}",
+                owner,
+                item.key,
+                item.epoch
+            );
+        }
+    }
+    if removed.is_empty() {
+        return 0;
+    }
+    match call_owner_phase(view, owner, OwnerReclaimPhase::Finalize, removed.clone()).await {
+        Ok(responses) => {
+            let mut finalized = 0u32;
+            let mut retry = Vec::new();
+            for (item, response) in removed.into_iter().zip(responses.into_iter()) {
+                if response.state == OwnerReclaimItemState::Finalized {
+                    clear_master_fence(view, &item);
+                    finalized = finalized.saturating_add(1);
+                } else {
+                    tracing::warn!(
+                        "owner reclaim finalize returned unresolved state: owner={} key={} epoch={} state={:?} detail={}",
+                        owner,
+                        item.key,
+                        item.epoch,
+                        response.state,
+                        response.detail
+                    );
+                    retry.push(item);
+                }
+            }
+            spawn_finalize_retry(view.clone(), owner.clone(), retry);
+            finalized
+        }
+        Err(err) => {
+            tracing::warn!(
+                "owner reclaim finalize RPC failed; retaining both fences: owner={} keys={} err={}",
+                owner,
+                removed.len(),
+                err
+            );
+            spawn_finalize_retry(view.clone(), owner.clone(), removed);
+            0
+        }
+    }
+}
+
+fn spawn_finalize_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<OwnerReclaimItem>) {
+    if items.is_empty() {
+        return;
+    }
+    let spawn_view = view.clone();
+    let _ = spawn_view.spawn("owner_reclaim_finalize_retry", async move {
+        let mut pending = items;
+        let mut delay = Duration::from_millis(25);
+        for _attempt in 1..=8 {
+            tokio::time::sleep(delay).await;
+            match call_owner_phase(&view, &owner, OwnerReclaimPhase::Finalize, pending.clone())
+                .await
+            {
+                Ok(responses) => {
+                    let mut next = Vec::new();
+                    for (item, response) in pending.into_iter().zip(responses.into_iter()) {
+                        if response.state == OwnerReclaimItemState::Finalized {
+                            clear_master_fence(&view, &item);
+                        } else {
+                            next.push(item);
+                        }
+                    }
+                    pending = next;
+                    if pending.is_empty() {
+                        return;
+                    }
+                }
+                Err(err) => tracing::warn!(
+                    "owner reclaim finalize retry failed: owner={} keys={} err={}",
+                    owner,
+                    pending.len(),
+                    err
+                ),
+            }
+            delay = (delay * 2).min(Duration::from_secs(1));
+        }
+        tracing::error!(
+            "owner reclaim finalize retry exhausted; fences retained: owner={} keys={}",
+            owner,
+            pending.len()
+        );
+    });
+}
+
+async fn reclaim_items(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    candidates: Vec<OwnerReclaimItem>,
+) -> u32 {
+    let counters = view
+        .master_kv_router()
+        .eviction_reclaim_counters(owner.as_ref());
+    let mut fenced = Vec::new();
+    for item in candidates {
+        if master_has_holder(view, &item.key) {
+            // A completed get holder keeps an Allocation alive after its route disappears. It is
+            // not a reclaim exclusion: owner Prepare is the authority that fences the local index
+            // and rejects reclaim only while a real MemoryInfo reader is still active.
+            counters
+                .master_get_holder_observed
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        match view
+            .master_kv_router()
+            .inner()
+            .key_activity
+            .try_install_reclaim(&item)
+        {
+            Ok(()) => {
+                if item_still_valid(view, owner, &item) {
+                    fenced.push(item);
+                } else {
+                    counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                    clear_master_fence(view, &item);
+                }
+            }
+            Err(activity) => {
+                counters
+                    .master_activity_deferred
+                    .fetch_add(1, Ordering::Relaxed);
+                tracing::trace!(
+                    "owner reclaim deferred by master activity: owner={} key={} puts={} gets={} replicas={} reclaim_installed={}",
+                    owner,
+                    item.key,
+                    activity.puts,
+                    activity.gets,
+                    activity.replicas,
+                    activity.reclaim_installed
+                );
+            }
+        }
+    }
+    if fenced.is_empty() {
+        return 0;
+    }
+
+    let (master_only, owner_coordinated) = partition_reclaim_coordination(fenced);
+    let master_reclaimed = finish_unindexed_allocations(view, owner, master_only);
+    if owner_coordinated.is_empty() {
+        counters
+            .completed
+            .fetch_add(u64::from(master_reclaimed), Ordering::Relaxed);
+        return master_reclaimed;
+    }
+
+    let prepare_responses = match call_owner_phase(
+        view,
+        owner,
+        OwnerReclaimPhase::Prepare,
+        owner_coordinated.clone(),
+    )
+    .await
+    {
+        Ok(responses) => responses,
+        Err(err) => {
+            tracing::warn!(
+                "owner reclaim prepare RPC failed; aborting batch: owner={} keys={} err={}",
+                owner,
+                owner_coordinated.len(),
+                err
+            );
+            let _ = abort_prepared(view, owner, owner_coordinated).await;
+            counters
+                .completed
+                .fetch_add(u64::from(master_reclaimed), Ordering::Relaxed);
+            return master_reclaimed;
+        }
+    };
+    let mut prepared = Vec::new();
+    let mut committed = Vec::new();
+    for (item, response) in owner_coordinated
+        .into_iter()
+        .zip(prepare_responses.into_iter())
+    {
+        match response.state {
+            OwnerReclaimItemState::Prepared => prepared.push(item),
+            OwnerReclaimItemState::Committed => committed.push(item),
+            OwnerReclaimItemState::Busy => {
+                if response.detail == "owner local memory still has active holders" {
+                    counters
+                        .owner_holder_deferred
+                        .fetch_add(1, Ordering::Relaxed);
+                } else {
+                    counters
+                        .owner_other_deferred
+                        .fetch_add(1, Ordering::Relaxed);
+                }
+                clear_master_fence(view, &item);
+            }
+            _ => {
+                counters
+                    .owner_other_deferred
+                    .fetch_add(1, Ordering::Relaxed);
+                clear_master_fence(view, &item);
+            }
+        }
+    }
+
+    let mut invalid_prepared = Vec::new();
+    prepared.retain(|item| {
+        if master_has_holder(view, &item.key) {
+            counters
+                .master_get_holder_observed
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        let valid = item_still_valid(view, owner, item);
+        if !valid {
+            counters.route_changed.fetch_add(1, Ordering::Relaxed);
+            invalid_prepared.push(item.clone());
+        }
+        valid
+    });
+    committed.extend(abort_prepared(view, owner, invalid_prepared).await);
+
+    if !prepared.is_empty() {
+        match call_owner_phase(view, owner, OwnerReclaimPhase::Commit, prepared.clone()).await {
+            Ok(responses) => {
+                let mut unresolved = Vec::new();
+                for (item, response) in prepared.into_iter().zip(responses.into_iter()) {
+                    if response.state == OwnerReclaimItemState::Committed {
+                        committed.push(item);
+                    } else {
+                        unresolved.push(item);
+                    }
+                }
+                committed.extend(abort_prepared(view, owner, unresolved).await);
+            }
+            Err(err) => {
+                tracing::warn!(
+                    "owner reclaim commit RPC failed; resolving with abort: owner={} keys={} err={}",
+                    owner,
+                    prepared.len(),
+                    err
+                );
+                committed.extend(abort_prepared(view, owner, prepared).await);
+            }
+        }
+    }
+    let reclaimed = master_reclaimed.saturating_add(finish_committed(view, owner, committed).await);
+    counters
+        .completed
+        .fetch_add(u64::from(reclaimed), Ordering::Relaxed);
+    reclaimed
+}
+
+fn collect_reserve_candidates(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    slot_size: u64,
+    limit: usize,
+) -> Vec<OwnerReclaimItem> {
+    let mut candidates = Vec::new();
+    // Moka iteration may synchronously drain cache maintenance and eviction listeners. Under
+    // pressure that made a 256-item candidate lookup take seconds. Route metadata is the
+    // reclaim authority, so snapshot its keys and validate candidates directly instead.
+    let route_keys = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .iter()
+        .map(|route| route.key().clone())
+        .collect::<Vec<_>>();
+    for key in route_keys {
+        if candidates.len() >= limit {
+            break;
+        }
+        if !view
+            .master_kv_router()
+            .inner()
+            .key_activity
+            .is_quiescent(&key)
+        {
+            continue;
+        }
+        if let Some(item) = route_item(
+            view,
+            owner,
+            &key,
+            None,
+            Some(slot_size),
+            OwnerReclaimReason::Reserve,
+            view.master_kv_router().next_owner_reclaim_epoch(),
+        ) {
+            candidates.push(item);
+        }
+    }
+    candidates
+}
+
+async fn reclaim_reserve_candidate_batches<F, Fut>(
+    candidates: Vec<OwnerReclaimItem>,
+    required_free_slots: u32,
+    mut reclaim_batch: F,
+) -> (u32, usize)
+where
+    F: FnMut(Vec<OwnerReclaimItem>) -> Fut,
+    Fut: Future<Output = u32>,
+{
+    let mut reclaimed = 0u32;
+    let mut scanned_candidates = 0usize;
+    while reclaimed < required_free_slots && scanned_candidates < candidates.len() {
+        let remaining_slots = required_free_slots.saturating_sub(reclaimed);
+        let batch_len = usize::try_from(remaining_slots)
+            .unwrap_or(usize::MAX)
+            .min(candidates.len() - scanned_candidates);
+        let batch_end = scanned_candidates + batch_len;
+        let batch = candidates[scanned_candidates..batch_end].to_vec();
+        scanned_candidates = batch_end;
+
+        let batch_size = u32::try_from(batch.len()).unwrap_or(u32::MAX);
+        let batch_reclaimed = reclaim_batch(batch).await;
+        debug_assert!(batch_reclaimed <= batch_size);
+        reclaimed = reclaimed.saturating_add(batch_reclaimed.min(batch_size));
+    }
+    (reclaimed, scanned_candidates)
+}
+
+#[cfg(test)]
+mod reserve_scan_tests {
+    use super::{
+        OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimReason, partition_reclaim_coordination,
+        reclaim_reserve_candidate_batches,
+    };
+    use std::future::ready;
+
+    fn candidate(index: u32) -> OwnerReclaimItem {
+        OwnerReclaimItem {
+            key: format!("candidate-{index}"),
+            put_id: (u64::from(index), 0),
+            epoch: u64::from(index),
+            backing: OwnerReclaimBacking::CommittedSlot {
+                grant_id: u64::from(index),
+                slot_index: index,
+                slot_size: 8 * 1024 * 1024,
+            },
+            reason: OwnerReclaimReason::Reserve,
+        }
+    }
+
+    #[test]
+    fn only_unindexed_allocations_skip_owner_coordination() {
+        let mut indexed_allocation = candidate(1);
+        indexed_allocation.backing = OwnerReclaimBacking::Allocation;
+        indexed_allocation.reason = OwnerReclaimReason::CapacityEviction;
+        let mut unindexed_allocation = candidate(2);
+        unindexed_allocation.backing = OwnerReclaimBacking::UnindexedAllocation;
+        unindexed_allocation.reason = OwnerReclaimReason::CapacityEviction;
+        let committed_slot = candidate(3);
+
+        let (master_only, owner_coordinated) = partition_reclaim_coordination(vec![
+            indexed_allocation,
+            unindexed_allocation.clone(),
+            committed_slot,
+        ]);
+
+        assert_eq!(master_only, vec![unindexed_allocation]);
+        assert_eq!(owner_coordinated.len(), 2);
+        assert!(
+            owner_coordinated
+                .iter()
+                .all(|item| item.backing != OwnerReclaimBacking::UnindexedAllocation)
+        );
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn reserve_scan_continues_after_busy_first_batch() {
+        let candidates = (0..12).map(candidate).collect::<Vec<_>>();
+        let mut batches = Vec::new();
+        let mut call_count = 0usize;
+
+        let (reclaimed, scanned_candidates) =
+            reclaim_reserve_candidate_batches(candidates, 5, |batch: Vec<OwnerReclaimItem>| {
+                call_count += 1;
+                batches.push(
+                    batch
+                        .iter()
+                        .map(|item| item.key.clone())
+                        .collect::<Vec<_>>(),
+                );
+                ready(if call_count == 1 {
+                    0
+                } else {
+                    u32::try_from(batch.len()).unwrap()
+                })
+            })
+            .await;
+
+        assert_eq!(reclaimed, 5);
+        assert_eq!(scanned_candidates, 10);
+        assert_eq!(batches.len(), 2);
+        assert_eq!(batches[0][0], "candidate-0");
+        assert_eq!(batches[0][4], "candidate-4");
+        assert_eq!(batches[1][0], "candidate-5");
+        assert_eq!(batches[1][4], "candidate-9");
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn reserve_scan_shrinks_next_batch_after_partial_reclaim() {
+        let candidates = (0..10).map(candidate).collect::<Vec<_>>();
+        let mut batch_lengths = Vec::new();
+        let mut call_count = 0usize;
+
+        let (reclaimed, scanned_candidates) =
+            reclaim_reserve_candidate_batches(candidates, 5, |batch| {
+                call_count += 1;
+                batch_lengths.push(batch.len());
+                ready(if call_count == 1 { 2 } else { 3 })
+            })
+            .await;
+
+        assert_eq!(reclaimed, 5);
+        assert_eq!(scanned_candidates, 8);
+        assert_eq!(batch_lengths, vec![5, 3]);
+    }
+}
+
+#[cfg(test)]
+mod owner_get_holding_reclaim_tests {
+    use super::{OwnerReclaimBacking, OwnerReclaimReason, reclaim_items, route_item};
+    use crate::client_kv_api::PutOptionalArgs;
+    use crate::kvcore_test_lib::{
+        integration_test_lock, start_master_and_client, stop_master_and_client,
+    };
+    use crate::memholder::{MemholderManagerTrait, NodeHolderKey};
+    use std::time::{Duration, Instant};
+
+    #[limit_thirdparty::tokio::test(flavor = "multi_thread", worker_threads = 8)]
+    async fn completed_get_holding_does_not_block_two_sided_owner_reclaim() {
+        let _test_guard = integration_test_lock().await;
+        let (master, client) =
+            start_master_and_client("reclaim_get_holding_master", "reclaim_get_holding_owner")
+                .await;
+        let key = "completed_get_holding_reclaim_key";
+        let owner_view = client.client_kv_api_view();
+        let owner_api = owner_view.client_kv_api();
+        owner_api
+            .inner()
+            .put(key, &[7u8; 4096], PutOptionalArgs::default())
+            .await
+            .expect("owner put");
+        let (holder, _get_info) = owner_api
+            .inner()
+            .get(key)
+            .await
+            .expect("owner get")
+            .expect("owner get should hit");
+
+        let owner_id = client
+            .cluster_manager_view()
+            .cluster_manager()
+            .get_self_info()
+            .id;
+        let holding_key = NodeHolderKey::new(owner_id.clone(), holder.holder_id());
+        let master_view = master.master_kv_router_view().clone();
+        assert!(
+            master_view
+                .master_kv_router()
+                .inner()
+                .get_holding
+                .inner()
+                .contains_key(&holding_key),
+            "get_done must install the Allocation lifetime holder"
+        );
+
+        assert!(
+            master_view
+                .master_kv_router()
+                .inner()
+                .key_activity
+                .is_quiescent(key),
+            "completed get must release its master key-activity lease"
+        );
+        let owner_node = owner_id.clone().into();
+        let busy_item = route_item(
+            &master_view,
+            &owner_node,
+            key,
+            None,
+            None,
+            OwnerReclaimReason::CapacityEviction,
+            master_view.master_kv_router().next_owner_reclaim_epoch(),
+        )
+        .expect("active-holder owner route should be reclaimable after the reader exits");
+        assert_eq!(
+            reclaim_items(&master_view, &owner_node, vec![busy_item]).await,
+            0,
+            "owner Prepare must reject reclaim while the user holder is live"
+        );
+
+        drop(holder);
+        limit_thirdparty::tokio::time::sleep(Duration::from_millis(50)).await;
+        assert!(
+            master_view
+                .master_kv_router()
+                .inner()
+                .get_holding
+                .inner()
+                .contains_key(&holding_key),
+            "the committed local index intentionally keeps MemoryInfo and its ACK holder alive"
+        );
+
+        let item = route_item(
+            &master_view,
+            &owner_node,
+            key,
+            None,
+            None,
+            OwnerReclaimReason::CapacityEviction,
+            master_view.master_kv_router().next_owner_reclaim_epoch(),
+        )
+        .expect("current owner route should be reclaimable");
+        assert_eq!(
+            item.backing,
+            OwnerReclaimBacking::Allocation,
+            "reuse-replica get_done must publish the owner-local index on the route"
+        );
+        assert_eq!(
+            reclaim_items(&master_view, &owner_node, vec![item]).await,
+            1
+        );
+
+        let wait_started = Instant::now();
+        while master_view
+            .master_kv_router()
+            .inner()
+            .get_holding
+            .inner()
+            .contains_key(&holding_key)
+        {
+            assert!(
+                wait_started.elapsed() < Duration::from_secs(5),
+                "owner reclaim must drop MemoryInfo and deliver its delete ACK"
+            );
+            limit_thirdparty::tokio::time::sleep(Duration::from_millis(20)).await;
+        }
+        assert!(
+            !master_view
+                .master_kv_router()
+                .inner()
+                .kv_routes
+                .contains_key(key),
+            "the reclaimed last replica route must be removed"
+        );
+
+        stop_master_and_client(master, client).await;
+    }
+}
+
+pub(crate) async fn reclaim_owner_slots_for_reserve(
+    view: &MasterKvRouterView,
+    owner_node_id: &NodeID,
+    slot_size: u64,
+    required_free_slots: u32,
+) -> u32 {
+    if slot_size == 0 || required_free_slots == 0 {
+        return 0;
+    }
+    let scan_started = Instant::now();
+    let candidates =
+        collect_reserve_candidates(view, owner_node_id, slot_size, OWNER_RECLAIM_MAX_BATCH);
+    let candidate_scan_us = scan_started.elapsed().as_micros();
+    let candidate_count = candidates.len();
+    let (reclaimed, scanned_candidate_count) =
+        reclaim_reserve_candidate_batches(candidates, required_free_slots, |batch| {
+            reclaim_items(view, owner_node_id, batch)
+        })
+        .await;
+    tracing::info!(
+        "owner reserve reclaim completed: owner={} slot_size={} requested_slots={} candidates={} scanned_candidates={} reclaimed={} candidate_scan_us={}",
+        owner_node_id,
+        slot_size,
+        required_free_slots,
+        candidate_count,
+        scanned_candidate_count,
+        reclaimed,
+        candidate_scan_us
+    );
+    reclaimed
+}
+
+fn spawn_eviction_reclaim_retry(view: MasterKvRouterView, requests: Vec<EvictionReclaimRequest>) {
+    if requests.is_empty() {
+        return;
+    }
+    let mut delayed = Vec::with_capacity(requests.len());
+    let mut restored_count = 0usize;
+    let mut restored_weight = 0u64;
+    for mut request in requests {
+        request.retry_count = request.retry_count.saturating_add(1);
+        let counters = view
+            .master_kv_router()
+            .eviction_reclaim_counters(&request.owner_node_id);
+        let weight = u64::from(request.desc.weight_bytes);
+        if !view.master_kv_router().eviction_cache_entry_is_current(
+            &request.owner_node_id,
+            &request.key,
+            &request.desc,
+        ) {
+            view.master_kv_router()
+                .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+            counters.route_changed.fetch_add(1, Ordering::Relaxed);
+            counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+            continue;
+        }
+        if should_restore_after_retry(request.retry_count) {
+            let restored = view
+                .master_kv_router()
+                .restore_eviction_cache_entry_if_current(
+                    &request.owner_node_id,
+                    request.key.clone(),
+                    request.desc.clone(),
+                );
+            if restored {
+                view.master_kv_router()
+                    .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+                counters.retry_restored.fetch_add(1, Ordering::Relaxed);
+                counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                restored_count += 1;
+                restored_weight = restored_weight.saturating_add(weight);
+                continue;
+            }
+            if !view.master_kv_router().eviction_cache_entry_is_current(
+                &request.owner_node_id,
+                &request.key,
+                &request.desc,
+            ) {
+                view.master_kv_router()
+                    .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+                counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                continue;
+            }
+        }
+        counters.retry_queued.fetch_add(1, Ordering::Relaxed);
+        delayed.push(request);
+    }
+    if restored_count != 0 {
+        tracing::info!(
+            "safe eviction reclaim restored current cache entries after bounded retry: entries={} weight_bytes={} max_retry_count={}",
+            restored_count,
+            restored_weight,
+            EVICTION_RECLAIM_MAX_RETRY_COUNT
+        );
+    }
+    if delayed.is_empty() {
+        return;
+    }
+    let max_retry_count = delayed
+        .iter()
+        .map(|request| request.retry_count)
+        .max()
+        .unwrap_or(1);
+    let retry_delay = eviction_reclaim_retry_delay(max_retry_count);
+    let spawn_view = view.clone();
+    let _ = spawn_view.spawn("eviction_reclaim_retry", async move {
+        tokio::time::sleep(retry_delay).await;
+        let tx = view.master_kv_router().inner().eviction_reclaim_tx.clone();
+        for request in delayed {
+            let weight = u64::from(request.desc.weight_bytes);
+            let counters = view
+                .master_kv_router()
+                .eviction_reclaim_counters(&request.owner_node_id);
+            if !view.master_kv_router().eviction_cache_entry_is_current(
+                &request.owner_node_id,
+                &request.key,
+                &request.desc,
+            ) {
+                view.master_kv_router()
+                    .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+                counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                continue;
+            }
+            let restore_request = request.clone();
+            if tx.send(request).await.is_err() {
+                view.master_kv_router()
+                    .complete_eviction_reclaim_weight(&restore_request.owner_node_id, weight);
+                let restored = view
+                    .master_kv_router()
+                    .restore_eviction_cache_entry_if_current(
+                        &restore_request.owner_node_id,
+                        restore_request.key,
+                        restore_request.desc,
+                    );
+                counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                if restored {
+                    counters.retry_restored.fetch_add(1, Ordering::Relaxed);
+                }
+                tracing::warn!(
+                    "safe eviction reclaim retry queue closed: owner={} restored={}",
+                    restore_request.owner_node_id,
+                    restored
+                );
+            }
+        }
+    });
+}
+
+pub(crate) fn spawn_eviction_reclaim_actor(
+    view: MasterKvRouterView,
+    mut rx: limit_thirdparty::tokio::sync::ampsc::Receiver<EvictionReclaimRequest>,
+) {
+    let view_task = view.clone();
+    let _ = view.spawn("eviction_reclaim_actor", async move {
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        loop {
+            let first = tokio::select! {
+                _ = shutdown_waiter.wait() => break,
+                request = rx.recv() => {
+                    let Some(request) = request else { break; };
+                    request
+                }
+            };
+            let mut batch = Vec::with_capacity(OWNER_RECLAIM_MAX_BATCH);
+            batch.push(first);
+            let mut merge_window = Box::pin(tokio::time::sleep(OWNER_RECLAIM_MERGE_WINDOW));
+            while batch.len() < OWNER_RECLAIM_MAX_BATCH {
+                tokio::select! {
+                    _ = &mut merge_window => break,
+                    request = rx.recv() => {
+                        let Some(request) = request else { break; };
+                        batch.push(request);
+                    }
+                }
+            }
+
+            let mut groups: HashMap<NodeIDString, Vec<EvictionReclaimRequest>> = HashMap::new();
+            for request in batch {
+                groups
+                    .entry(request.owner_node_id.clone())
+                    .or_default()
+                    .push(request);
+            }
+            for (owner_node_id, requests) in groups {
+                let owner: NodeID = owner_node_id.clone().into();
+                let counters = view_task
+                    .master_kv_router()
+                    .eviction_reclaim_counters(&owner_node_id);
+                let mut seen = HashSet::new();
+                let mut items = Vec::new();
+                let mut unique_requests = Vec::new();
+                let mut completed_weight = 0u64;
+                for request in requests {
+                    if !seen.insert((request.key.clone(), request.desc.put_id)) {
+                        completed_weight = completed_weight
+                            .saturating_add(u64::from(request.desc.weight_bytes));
+                        continue;
+                    }
+                    if let Some(item) = route_item(
+                        &view_task,
+                        &owner,
+                        &request.key,
+                        Some(request.desc.put_id),
+                        None,
+                        OwnerReclaimReason::CapacityEviction,
+                        view_task.master_kv_router().next_owner_reclaim_epoch(),
+                    ) {
+                        items.push(item);
+                    }
+                    unique_requests.push(request);
+                }
+                let candidate_count = items.len();
+                let reclaimed = reclaim_items(&view_task, &owner, items).await;
+                let mut retry_requests = Vec::new();
+                for request in unique_requests {
+                    if view_task
+                        .master_kv_router()
+                        .eviction_cache_entry_is_current(
+                            &owner_node_id,
+                            &request.key,
+                            &request.desc,
+                        )
+                    {
+                        retry_requests.push(request);
+                    } else {
+                        completed_weight = completed_weight
+                            .saturating_add(u64::from(request.desc.weight_bytes));
+                        counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                        if request.retry_count != 0 {
+                            counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                        }
+                    }
+                }
+                view_task.master_kv_router().complete_eviction_reclaim_weight(
+                    &owner_node_id,
+                    completed_weight,
+                );
+                let retry_count = retry_requests.len();
+                spawn_eviction_reclaim_retry(view_task.clone(), retry_requests);
+                tracing::trace!(
+                    "batched safe eviction reclaim completed: owner={} candidates={} reclaimed={} retry_deferred={} completed_weight={}",
+                    owner_node_id,
+                    candidate_count,
+                    reclaimed,
+                    retry_count,
+                    completed_weight
+                );
+            }
+        }
+    });
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
new file mode 100644
index 0000000..b1c0932
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
@@ -0,0 +1,349 @@
+use super::{MasterKvRouterView, NodeValueReplicaDesc, put::PutIDForAKey};
+use crate::cluster_manager::NodeID;
+use limit_thirdparty::tokio;
+use std::collections::{HashMap, HashSet};
+use std::time::Duration;
+
+const POST_ROUTE_MAINTENANCE_MAX_BATCH: usize = 512;
+const POST_ROUTE_MAINTENANCE_MERGE_WINDOW: Duration = Duration::from_millis(2);
+
+#[derive(Clone, Copy)]
+enum RoutePublishKind {
+    PrimaryPut,
+    ReplicaAppend,
+}
+
+pub(super) struct RoutePublishEvent {
+    kind: RoutePublishKind,
+    key: String,
+    put_id: PutIDForAKey,
+    lease_id: Option<u64>,
+    node_id: NodeID,
+    capacity_bytes: u64,
+}
+
+impl RoutePublishEvent {
+    pub(super) fn primary_put(
+        key: String,
+        put_id: PutIDForAKey,
+        lease_id: Option<u64>,
+        node_id: NodeID,
+        capacity_bytes: u64,
+    ) -> Self {
+        Self {
+            kind: RoutePublishKind::PrimaryPut,
+            key,
+            put_id,
+            lease_id,
+            node_id,
+            capacity_bytes,
+        }
+    }
+
+    pub(super) fn replica_append(
+        key: String,
+        put_id: PutIDForAKey,
+        lease_id: Option<u64>,
+        node_id: NodeID,
+        capacity_bytes: u64,
+    ) -> Self {
+        Self {
+            kind: RoutePublishKind::ReplicaAppend,
+            key,
+            put_id,
+            lease_id,
+            node_id,
+            capacity_bytes,
+        }
+    }
+}
+
+fn saturating_moka_weight_bytes(key: &str, put_id: PutIDForAKey, capacity_bytes: u64) -> u32 {
+    if capacity_bytes > u32::MAX as u64 {
+        tracing::warn!(
+            "moka weight saturation after route publish: key={} put_id=({},{}) cap={}B exceeds u32::MAX; weight set to u32::MAX",
+            key,
+            put_id.0,
+            put_id.1,
+            capacity_bytes
+        );
+        u32::MAX
+    } else {
+        capacity_bytes as u32
+    }
+}
+
+fn projected_batch_weight(current_weight: u64, replaced_weight: u64, incoming_weight: u64) -> u64 {
+    current_weight
+        .saturating_sub(replaced_weight)
+        .saturating_add(incoming_weight)
+}
+
+fn deduplicate_owner_events(
+    events: Vec<(usize, String, NodeValueReplicaDesc)>,
+) -> Vec<(String, NodeValueReplicaDesc)> {
+    let mut latest_by_key = HashMap::with_capacity(events.len());
+    for (sequence, key, desc) in events {
+        latest_by_key.insert(key, (sequence, desc));
+    }
+    let mut latest = latest_by_key.into_iter().collect::<Vec<_>>();
+    latest.sort_unstable_by_key(|(_, (sequence, _))| *sequence);
+    latest
+        .into_iter()
+        .map(|(key, (_, desc))| (key, desc))
+        .collect()
+}
+
+/// Applies index and cache work after route guards have been released.
+async fn apply_post_route_maintenance_batch(
+    view: &MasterKvRouterView,
+    events: Vec<RoutePublishEvent>,
+) {
+    if view.master_kv_router().prefix_index_enabled()
+        && events
+            .iter()
+            .any(|event| matches!(event.kind, RoutePublishKind::PrimaryPut))
+    {
+        let inner = view.master_kv_router().inner();
+        let mut tree = inner.prefix_index.write().await;
+        for event in &events {
+            if matches!(event.kind, RoutePublishKind::PrimaryPut) {
+                let event_is_current = inner.kv_routes.get(&event.key).is_some_and(|route| {
+                    route.put_id == event.put_id
+                        && route
+                            .nodes_replicas
+                            .read()
+                            .values()
+                            .any(|replica| !replica.tomb_tag.is_tomb())
+                });
+                if event_is_current {
+                    tree.insert(&event.key, event.put_id);
+                }
+            }
+        }
+    }
+
+    if !view.master_kv_router().replica_cache_enabled() {
+        return;
+    }
+    let mut events_by_owner = HashMap::<String, Vec<(usize, String, NodeValueReplicaDesc)>>::new();
+    for (sequence, event) in events.into_iter().enumerate() {
+        if event.lease_id.is_some() {
+            continue;
+        }
+        let weight_bytes =
+            saturating_moka_weight_bytes(&event.key, event.put_id, event.capacity_bytes);
+        let desc = NodeValueReplicaDesc {
+            weight_bytes,
+            put_id: event.put_id,
+        };
+        if !view.master_kv_router().eviction_cache_entry_is_current(
+            event.node_id.as_ref(),
+            &event.key,
+            &desc,
+        ) {
+            continue;
+        }
+        events_by_owner
+            .entry(event.node_id.as_ref().to_string())
+            .or_default()
+            .push((sequence, event.key, desc));
+    }
+
+    for (owner_node_id, owner_events) in events_by_owner {
+        let entries = deduplicate_owner_events(owner_events);
+        let Some(cache) = view
+            .master_kv_router()
+            .get_node_cache_controller(&owner_node_id)
+        else {
+            tracing::warn!(
+                "No cache controller found for node: {}, node is not ready",
+                owner_node_id
+            );
+            continue;
+        };
+
+        // Drain prior writes once, then admit this owner batch as one unit. This exposes the
+        // aggregate incoming weight to the explicit resident-capacity policy.
+        cache.run_pending_tasks();
+        let weighted_size_before = cache.weighted_size();
+        let replaced_weight = entries
+            .iter()
+            .filter_map(|(key, _)| cache.get(key))
+            .map(|existing| u64::from(existing.weight_bytes))
+            .fold(0u64, u64::saturating_add);
+        let incoming_weight = entries
+            .iter()
+            .map(|(_, desc)| u64::from(desc.weight_bytes))
+            .fold(0u64, u64::saturating_add);
+        let projected_weight =
+            projected_batch_weight(weighted_size_before, replaced_weight, incoming_weight);
+        let node_space_size = view
+            .master_seg_manager()
+            .get_node_space_size(&owner_node_id);
+        let capacity = view
+            .master_kv_router()
+            .replica_cache_effective_capacity(&owner_node_id, node_space_size);
+        let requested_weight = projected_weight.saturating_sub(capacity);
+        let incoming_keys = entries
+            .iter()
+            .map(|(key, _)| key.clone())
+            .collect::<HashSet<_>>();
+
+        let recoverable_selected_weight = view
+            .master_kv_router()
+            .evict_recoverable_cache_weight_excluding(
+                &owner_node_id,
+                requested_weight,
+                &incoming_keys,
+            );
+        let fallback_requested_weight =
+            requested_weight.saturating_sub(recoverable_selected_weight);
+        let fallback_selected_weight = if view
+            .master_kv_router()
+            .owner_cache_allows_unrecoverable_eviction(&owner_node_id)
+        {
+            cache.evict_some_if(fallback_requested_weight, |key, _desc| {
+                !incoming_keys.contains(key)
+            })
+        } else {
+            0
+        };
+        if requested_weight != 0 {
+            tracing::debug!(
+                "recoverable-first batch admission: owner={} entries={} weighted_size_before={} replaced_weight={} incoming_weight={} projected_weight={} capacity={} requested_weight={} recoverable_selected_weight={} fallback_requested_weight={} fallback_selected_weight={} shortfall_weight={}",
+                owner_node_id,
+                entries.len(),
+                weighted_size_before,
+                replaced_weight,
+                incoming_weight,
+                projected_weight,
+                capacity,
+                requested_weight,
+                recoverable_selected_weight,
+                fallback_requested_weight,
+                fallback_selected_weight,
+                fallback_requested_weight.saturating_sub(fallback_selected_weight),
+            );
+        }
+
+        let tier1_cache = view
+            .master_kv_router()
+            .get_node_writeback_tier1_controller(&owner_node_id);
+        for (key, desc) in entries {
+            tracing::debug!("Inserting key: {:?} into cache", key);
+            cache.insert(key.clone(), desc.clone());
+            if let Some(tier1_cache) = tier1_cache.as_ref() {
+                tier1_cache.insert(key.clone(), desc);
+            }
+            tracing::debug!(
+                "Inserted key: {:?} into cache, current cache size: {}",
+                key,
+                cache.weighted_size()
+            );
+        }
+    }
+}
+
+pub(super) fn spawn_post_route_maintenance_actor(
+    view: MasterKvRouterView,
+    mut rx: tokio::sync::ampsc::Receiver<RoutePublishEvent>,
+) {
+    let view_task = view.clone();
+    view.spawn("post_route_maintenance_actor", async move {
+        tracing::info!(
+            "post-route maintenance actor started: max_batch={} merge_window_ms={}",
+            POST_ROUTE_MAINTENANCE_MAX_BATCH,
+            POST_ROUTE_MAINTENANCE_MERGE_WINDOW.as_millis(),
+        );
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        loop {
+            let first = tokio::select! {
+                _ = shutdown_waiter.wait() => break,
+                event = rx.recv() => {
+                    let Some(event) = event else { break; };
+                    event
+                }
+            };
+            let mut events = Vec::with_capacity(POST_ROUTE_MAINTENANCE_MAX_BATCH);
+            events.push(first);
+            let mut merge_window =
+                Box::pin(tokio::time::sleep(POST_ROUTE_MAINTENANCE_MERGE_WINDOW));
+            while events.len() < POST_ROUTE_MAINTENANCE_MAX_BATCH {
+                tokio::select! {
+                    _ = &mut merge_window => break,
+                    event = rx.recv() => {
+                        let Some(event) = event else { break; };
+                        events.push(event);
+                    }
+                }
+            }
+            apply_post_route_maintenance_batch(&view_task, events).await;
+        }
+        tracing::info!("post-route maintenance actor stopped");
+    });
+}
+
+/// Queues index and cache work with bounded backpressure after route publication.
+pub(super) async fn enqueue_post_route_maintenance(
+    view: &MasterKvRouterView,
+    event: RoutePublishEvent,
+) {
+    let update_prefix_index = matches!(event.kind, RoutePublishKind::PrimaryPut)
+        && view.master_kv_router().prefix_index_enabled();
+    let insert_replica_cache =
+        event.lease_id.is_none() && view.master_kv_router().replica_cache_enabled();
+    if !update_prefix_index && !insert_replica_cache {
+        return;
+    }
+    view.master_kv_router()
+        .inner()
+        .post_route_maintenance_tx
+        .send(event)
+        .await
+        .expect("post-route maintenance actor stopped while master is serving requests");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{deduplicate_owner_events, projected_batch_weight, saturating_moka_weight_bytes};
+    use crate::master_kv_router::NodeValueReplicaDesc;
+
+    #[test]
+    fn moka_weight_saturates_without_truncating() {
+        assert_eq!(
+            saturating_moka_weight_bytes("key", (1, 2), u32::MAX as u64),
+            u32::MAX
+        );
+        assert_eq!(
+            saturating_moka_weight_bytes("key", (1, 2), u32::MAX as u64 + 1),
+            u32::MAX
+        );
+    }
+
+    #[test]
+    fn projected_weight_accounts_for_batch_replacements_once() {
+        assert_eq!(projected_batch_weight(90, 30, 50), 110);
+        assert_eq!(projected_batch_weight(10, 20, 5), 5);
+    }
+
+    #[test]
+    fn owner_batch_keeps_only_the_last_event_for_each_key() {
+        let desc = |weight_bytes, put_id| NodeValueReplicaDesc {
+            weight_bytes,
+            put_id,
+        };
+        let events = vec![
+            (0, "a".to_string(), desc(10, (1, 0))),
+            (1, "b".to_string(), desc(20, (1, 0))),
+            (2, "a".to_string(), desc(30, (2, 0))),
+        ];
+
+        let deduplicated = deduplicate_owner_events(events);
+        assert_eq!(deduplicated.len(), 2);
+        assert_eq!(deduplicated[0].0, "b");
+        assert_eq!(deduplicated[1].0, "a");
+        assert_eq!(deduplicated[1].1.weight_bytes, 30);
+        assert_eq!(deduplicated[1].1.put_id, (2, 0));
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/tiered_writeback.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/tiered_writeback.rs
new file mode 100644
index 0000000..97ebfd1
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/tiered_writeback.rs
@@ -0,0 +1,224 @@
+use super::{MasterKvRouterView, NodeValueReplicaDesc};
+use crate::cluster_manager::{NodeID, NodeIDString};
+use crate::master_kv_router::msg_pack::{BatchEnqueueReplicaTaskReq, EnqueueReplicaTaskItem};
+use crate::p2p::msg_pack::{MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, RPCCaller};
+use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+use limit_thirdparty::tokio;
+use std::collections::HashMap;
+use std::time::Duration;
+
+const TIER1_WRITEBACK_RPC_TIMEOUT: Duration = Duration::from_secs(MIN_EXPLICIT_RPC_TIMEOUT_SECS);
+const TIER1_WRITEBACK_MAX_BATCH: usize = 256;
+const TIER1_WRITEBACK_MERGE_WINDOW: Duration = Duration::from_millis(2);
+
+#[derive(Clone, Debug)]
+pub(crate) struct Tier1WritebackRequest {
+    pub source_node_id: NodeIDString,
+    pub key: String,
+    pub desc: NodeValueReplicaDesc,
+}
+
+async fn dispatch_owner_batch(
+    view: &MasterKvRouterView,
+    source_node_id: NodeIDString,
+    requests: Vec<Tier1WritebackRequest>,
+) {
+    let mut current = Vec::with_capacity(requests.len());
+    for request in requests {
+        if view.master_kv_router().tier1_writeback_entry_is_current(
+            &request.source_node_id,
+            &request.key,
+            &request.desc,
+        ) {
+            current.push(request);
+        } else {
+            view.master_kv_router()
+                .finish_tier1_writeback_request(request);
+        }
+    }
+    if current.is_empty() {
+        return;
+    }
+
+    let items = current
+        .iter()
+        .map(|request| EnqueueReplicaTaskItem {
+            key: request.key.clone(),
+            put_id: request.desc.put_id,
+        })
+        .collect::<Vec<_>>();
+    let caller = RPCCaller::<BatchEnqueueReplicaTaskReq>::new();
+    caller.regist(view.p2p_module());
+    let result = caller
+        .call(
+            view.p2p_module(),
+            NodeID::from(source_node_id.clone()),
+            MsgPack {
+                serialize_part: BatchEnqueueReplicaTaskReq { items },
+                raw_bytes: Vec::new(),
+            },
+            Some(TIER1_WRITEBACK_RPC_TIMEOUT),
+            1,
+        )
+        .await;
+
+    let response = match result {
+        Ok(response)
+            if response.serialize_part.error_code == OK
+                && response.serialize_part.items.len() == current.len() =>
+        {
+            response.serialize_part.items
+        }
+        Ok(response) => {
+            tracing::warn!(
+                "tier1 write-back owner response rejected: owner={} requested={} returned={} code={} error={}",
+                source_node_id,
+                current.len(),
+                response.serialize_part.items.len(),
+                response.serialize_part.error_code,
+                response.serialize_part.error_json
+            );
+            view.master_kv_router().record_tier1_writeback_failed(
+                &source_node_id,
+                u64::try_from(current.len()).unwrap_or(u64::MAX),
+            );
+            for request in current {
+                view.master_kv_router()
+                    .finish_tier1_writeback_request(request);
+            }
+            return;
+        }
+        Err(err) => {
+            tracing::warn!(
+                "tier1 write-back owner RPC failed: owner={} requested={} err={:?}",
+                source_node_id,
+                current.len(),
+                err
+            );
+            view.master_kv_router().record_tier1_writeback_failed(
+                &source_node_id,
+                u64::try_from(current.len()).unwrap_or(u64::MAX),
+            );
+            for request in current {
+                view.master_kv_router()
+                    .finish_tier1_writeback_request(request);
+            }
+            return;
+        }
+    };
+
+    let requested = current.len();
+    let mut accepted = 0usize;
+    for (request, item) in current.into_iter().zip(response.into_iter()) {
+        let identity_matches = request.key == item.key && request.desc.put_id == item.put_id;
+        if identity_matches && item.accepted {
+            accepted += 1;
+            continue;
+        }
+        view.master_kv_router()
+            .record_tier1_writeback_failed(&source_node_id, 1);
+        if !identity_matches {
+            tracing::warn!(
+                "tier1 write-back owner response identity mismatch: owner={} request_key={} request_put_id=({},{}) response_key={} response_put_id=({},{})",
+                source_node_id,
+                request.key,
+                request.desc.put_id.0,
+                request.desc.put_id.1,
+                item.key,
+                item.put_id.0,
+                item.put_id.1
+            );
+        }
+        view.master_kv_router()
+            .finish_tier1_writeback_request(request);
+    }
+    view.master_kv_router()
+        .record_tier1_writeback_owner_accepted(
+            &source_node_id,
+            u64::try_from(accepted).unwrap_or(u64::MAX),
+        );
+    tracing::debug!(
+        "tier1 write-back owner batch dispatched: owner={} requested={} accepted={}",
+        source_node_id,
+        requested,
+        accepted
+    );
+}
+
+pub(crate) fn spawn_tier1_writeback_actor(
+    view: MasterKvRouterView,
+    mut rx: tokio::sync::ampsc::Receiver<Tier1WritebackRequest>,
+) {
+    let view_task = view.clone();
+    let _ = view.spawn("tier1_writeback_actor", async move {
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        loop {
+            let first = tokio::select! {
+                _ = shutdown_waiter.wait() => break,
+                request = rx.recv() => {
+                    let Some(request) = request else { break; };
+                    request
+                }
+            };
+            let mut batch = Vec::with_capacity(TIER1_WRITEBACK_MAX_BATCH);
+            batch.push(first);
+            let mut merge_window = Box::pin(tokio::time::sleep(TIER1_WRITEBACK_MERGE_WINDOW));
+            while batch.len() < TIER1_WRITEBACK_MAX_BATCH {
+                tokio::select! {
+                    _ = &mut merge_window => break,
+                    request = rx.recv() => {
+                        let Some(request) = request else { break; };
+                        batch.push(request);
+                    }
+                }
+            }
+
+            let mut groups: HashMap<NodeIDString, Vec<Tier1WritebackRequest>> = HashMap::new();
+            for request in batch {
+                groups
+                    .entry(request.source_node_id.clone())
+                    .or_default()
+                    .push(request);
+            }
+            for (source_node_id, requests) in groups {
+                dispatch_owner_batch(&view_task, source_node_id, requests).await;
+            }
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::p2p::msg_pack::validate_explicit_rpc_timeout;
+
+    #[test]
+    fn tier1_writeback_timeout_satisfies_rpc_contract() {
+        validate_explicit_rpc_timeout(Some(TIER1_WRITEBACK_RPC_TIMEOUT)).unwrap();
+    }
+
+    #[test]
+    fn inclusive_hot_tier_does_not_reduce_resident_capacity() {
+        let build = |capacity| {
+            moka::sync::SegmentedCache::builder(1)
+                .max_capacity(capacity)
+                .weigher(Box::new(|_key: &String, weight: &u32| *weight))
+                .build()
+        };
+        let resident = build(100);
+        let tier1 = build(60);
+
+        for key in ["a", "b", "c"] {
+            resident.insert(key.to_string(), 30);
+            tier1.insert(key.to_string(), 30);
+        }
+        resident.run_pending_tasks();
+        tier1.run_pending_tasks();
+
+        assert_eq!(resident.policy().max_capacity(), Some(100));
+        assert_eq!(resident.weighted_size(), 90);
+        assert_eq!(tier1.policy().max_capacity(), Some(60));
+        assert!(tier1.weighted_size() <= 60);
+        assert!(resident.entry_count() > tier1.entry_count());
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs b/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
index d4a6549..eee9dc0 100644
--- a/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
@@ -59,6 +59,8 @@ fn new_master_config(
         pprof_duration_seconds: None,
         master_ui: None,
         replica_task_placement: ReplicaTaskPlacementConfig::default(),
+        replica_cache_capacity_ratio: crate::config::DEFAULT_REPLICA_CACHE_CAPACITY_RATIO,
+        replica_writeback_tier1_capacity_ratio: None,
         test_spec_config: TestSpecConfig::default(),
     }
 }
@@ -89,6 +91,7 @@ fn new_client_config_with_size(
             rdma_device_names: None,
         },
         pprof_duration_seconds: None,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: vec![etcd.to_string()],
@@ -124,6 +127,7 @@ fn new_zero_contribution_client_config(
             rdma_device_names: None,
         },
         pprof_duration_seconds: None,
+        replica_writeback_hot_capacity_ratio: None,
         redis_compat_listen_addr: None,
         fluxonkv_spec: FluxonKvSpec {
             etcd_addresses: Vec::new(),
@@ -242,6 +246,7 @@ pub mod test_memholder {
         new_master_config, new_zero_contribution_client_config, read_etcd, unique_cluster_name,
         wait_node_allocators, wait_weak_drop,
     };
+    use crate::memholder::{MemholderManagerTrait, NodeHolderKey};
     use crate::{ConfigArg, run_client, run_master};
     use std::time::{Duration, Instant};
     use tokio::time::sleep;
@@ -588,10 +593,16 @@ pub mod test_memholder {
             .unwrap()
             .unwrap();
         let ext_hold_holder_id = eh1.holder_id;
-        // Note: master's get_holding is keyed by the requesting node of the inner owner get
-        // for external GET, the owner performs an inner get, so the node is the owner
+        let ext_hold_owner_holder_id = owner_api
+            .inner()
+            .external_get_holding
+            .inner_map()
+            .get(&NodeHolderKey::new(external_id.clone(), ext_hold_holder_id))
+            .expect("capture ext_hold owner holding")
+            .memory_info
+            .holder_id;
         let ext_hold_weak =
-            capture_master_holding_allocation(&master_view, &owner_id, ext_hold_holder_id)
+            capture_master_holding_allocation(&master_view, &owner_id, ext_hold_owner_holder_id)
                 .expect("capture ext_hold weak");
         drop(eh2);
 
@@ -608,9 +619,19 @@ pub mod test_memholder {
             .unwrap()
             .unwrap();
         let ext_release_holder_id = er1.holder_id;
-        // Similar rationale as above: use owner_id when capturing master's holding entry
+        let ext_release_owner_holder_id = owner_api
+            .inner()
+            .external_get_holding
+            .inner_map()
+            .get(&NodeHolderKey::new(
+                external_id.clone(),
+                ext_release_holder_id,
+            ))
+            .expect("capture ext_release owner holding")
+            .memory_info
+            .holder_id;
         let ext_release_weak =
-            capture_master_holding_allocation(&master_view, &owner_id, ext_release_holder_id)
+            capture_master_holding_allocation(&master_view, &owner_id, ext_release_owner_holder_id)
                 .expect("capture ext_release weak");
         drop(er1);
         drop(er2); // drop all for release key
diff --git a/fluxon_rs/fluxon_kv/src/memholder/mod.rs b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
index 37f2d81..0cd6a6f 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
@@ -26,6 +26,7 @@ use bitcode::{Decode, Encode};
 
 #[derive(Clone, Debug)]
 pub enum MemoryInfoDropAction {
+    None,
     OwnerDeleteAck,
     ReleaseLocalReserveResidentSlot {
         slot_size: u64,
@@ -231,7 +232,22 @@ impl MemoryInfo {
                 grant_id,
                 slot_index,
             } => Some((slot_size, grant_id, slot_index)),
-            MemoryInfoDropAction::OwnerDeleteAck => None,
+            MemoryInfoDropAction::None | MemoryInfoDropAction::OwnerDeleteAck => None,
+        }
+    }
+
+    pub(crate) fn take_local_reserve_resident_slot_ref(&mut self) -> Option<(u64, u64, u32)> {
+        let action = std::mem::replace(&mut self.drop_action, MemoryInfoDropAction::None);
+        match action {
+            MemoryInfoDropAction::ReleaseLocalReserveResidentSlot {
+                slot_size,
+                grant_id,
+                slot_index,
+            } => Some((slot_size, grant_id, slot_index)),
+            other => {
+                self.drop_action = other;
+                None
+            }
         }
     }
 }
@@ -240,6 +256,7 @@ impl MemoryInfo {
 impl Drop for MemoryInfo {
     fn drop(&mut self) {
         match &self.drop_action {
+            MemoryInfoDropAction::None => {}
             MemoryInfoDropAction::OwnerDeleteAck => {
                 let ctx = OwnerDeleteAckCtx {
                     view: self.view.clone(),
diff --git a/fluxon_rs/fluxon_kv/src/p2p/msg_pack.rs b/fluxon_rs/fluxon_kv/src/p2p/msg_pack.rs
index 6f774ca..a057609 100644
--- a/fluxon_rs/fluxon_kv/src/p2p/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/p2p/msg_pack.rs
@@ -1,6 +1,7 @@
 pub use fluxon_commu::p2p::rpc::{
-    MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, MsgPackSerializePart, RPCCaller, RPCHandler, RPCReq,
-    RPCResponsor, Responser, RpcCallObserveTrace, RpcCallObservedOutput, call_rpc,
-    call_rpc_observed,
+    MIN_EXPLICIT_RPC_TIMEOUT_MS, MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, MsgPackSerializePart,
+    RPCCaller, RPCHandler, RPCReq, RPCResponsor, Responser, RpcCallObserveTrace,
+    RpcCallObservedOutput, call_rpc, call_rpc_observed, validate_explicit_rpc_timeout,
+    validate_explicit_rpc_timeout_ms,
 };
 pub use fluxon_commu::p2p::{MsgId, MsgPackHeadMeta, MsgPackRelay, TaskId, WireMessageBody};
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
index 75fe736..d771141 100644
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
@@ -71,6 +71,12 @@ pub enum MsgId {
     BatchPreparePutKeysResp = 3056,
     BatchReleasePutKeyReservationsReq = 3057,
     BatchReleasePutKeyReservationsResp = 3058,
+    BatchOwnerReclaimReq = 3059,
+    BatchOwnerReclaimResp = 3060,
+    BatchEnqueueReplicaTaskReq = 3061,
+    BatchEnqueueReplicaTaskResp = 3062,
+    GroupedBatchPutDoneReq = 3063,
+    GroupedBatchPutDoneResp = 3064,
     ExternalGetReq = 4001,
     ExternalGetResp = 4002,
     ExternalPutStartReq = 4003,
diff --git a/fluxon_rs/fluxon_kv/src/user_api/rpc.rs b/fluxon_rs/fluxon_kv/src/user_api/rpc.rs
index eff064f..dfbda39 100644
--- a/fluxon_rs/fluxon_kv/src/user_api/rpc.rs
+++ b/fluxon_rs/fluxon_kv/src/user_api/rpc.rs
@@ -44,16 +44,7 @@ pub trait UserRpcServer: Send + Sync {
 pub type UserRpcFlatDictFuture = Pin<Box<dyn Future<Output = KvResult<FlatDict>> + Send + 'static>>;
 
 pub(crate) fn validate_timeout_ms(timeout_ms: u64) -> KvResult<()> {
-    if timeout_ms < user_rpc::USER_RPC_MIN_TIMEOUT_MS {
-        return Err(KvError::Api(ApiError::InvalidArgument {
-            detail: format!(
-                "timeout_ms must be >= {} (got {})",
-                user_rpc::USER_RPC_MIN_TIMEOUT_MS,
-                timeout_ms
-            ),
-        }));
-    }
-    Ok(())
+    user_rpc::validate_timeout_ms(timeout_ms)
 }
 
 pub(crate) struct FluxonUserRpcImpl {
diff --git a/fluxon_rs/fluxon_kv/src/user_rpc.rs b/fluxon_rs/fluxon_kv/src/user_rpc.rs
index 7bff55b..e9587ac 100644
--- a/fluxon_rs/fluxon_kv/src/user_rpc.rs
+++ b/fluxon_rs/fluxon_kv/src/user_rpc.rs
@@ -2,10 +2,10 @@ use std::time::Duration;
 use std::time::Instant;
 
 use fluxon_commu::p2p::rpc::{
-    USER_RPC_OBSERVE_TRACE_RAW_BYTES_INDEX, USER_RPC_OWNER1_OBSERVE_TRACE_RAW_BYTES_INDEX,
-    UserRpcObserveTrace, UserRpcOwner1ObserveTrace, UserRpcTransportPathKind,
-    current_cross_process_monotonic_us, decode_user_rpc_observe_trace,
-    decode_user_rpc_owner1_observe_trace,
+    MIN_EXPLICIT_RPC_TIMEOUT_MS, USER_RPC_OBSERVE_TRACE_RAW_BYTES_INDEX,
+    USER_RPC_OWNER1_OBSERVE_TRACE_RAW_BYTES_INDEX, UserRpcObserveTrace, UserRpcOwner1ObserveTrace,
+    UserRpcTransportPathKind, current_cross_process_monotonic_us, decode_user_rpc_observe_trace,
+    decode_user_rpc_owner1_observe_trace, validate_explicit_rpc_timeout_ms,
 };
 use prost::bytes::Bytes;
 
@@ -15,7 +15,34 @@ use crate::p2p::p2p_module::UserRpcReq;
 use crate::rpcresp_kvresult_convert;
 use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult};
 
-pub const USER_RPC_MIN_TIMEOUT_MS: u64 = 10_000;
+pub const USER_RPC_MIN_TIMEOUT_MS: u64 = MIN_EXPLICIT_RPC_TIMEOUT_MS;
+
+pub fn validate_timeout_ms(timeout_ms: u64) -> KvResult<()> {
+    validate_explicit_rpc_timeout_ms(timeout_ms).map_err(KvError::from)
+}
+
+#[cfg(test)]
+mod timeout_validation_tests {
+    use super::*;
+    use fluxon_commu::p2p::P2pError;
+
+    #[test]
+    fn invalid_user_rpc_timeout_preserves_typed_p2p_error() {
+        let timeout_ms = USER_RPC_MIN_TIMEOUT_MS - 1;
+        let err = validate_timeout_ms(timeout_ms).unwrap_err();
+        match err {
+            KvError::P2p(P2pError::InvalidRpcTimeout {
+                timeout_ms: actual_timeout_ms,
+                min_timeout_ms,
+                ..
+            }) => {
+                assert_eq!(actual_timeout_ms, timeout_ms);
+                assert_eq!(min_timeout_ms, USER_RPC_MIN_TIMEOUT_MS);
+            }
+            other => panic!("expected typed InvalidRpcTimeout, got {other:?}"),
+        }
+    }
+}
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum UserRpcOwnerPathKind {
@@ -140,14 +167,7 @@ pub async fn user_rpc_call_observed(
     payload: Vec<u8>,
     timeout_ms: u64,
 ) -> KvResult<UserRpcCallOutput> {
-    if timeout_ms < USER_RPC_MIN_TIMEOUT_MS {
-        return Err(KvError::Api(ApiError::InvalidArgument {
-            detail: format!(
-                "timeout_ms must be >= {} (got {})",
-                USER_RPC_MIN_TIMEOUT_MS, timeout_ms
-            ),
-        }));
-    }
+    validate_timeout_ms(timeout_ms)?;
 
     let path_for_error = path.clone();
     let req = MsgPack {
diff --git a/fluxon_rs/fluxon_pyo3/src/error.rs b/fluxon_rs/fluxon_pyo3/src/error.rs
index 06246dc..3848124 100644
--- a/fluxon_rs/fluxon_pyo3/src/error.rs
+++ b/fluxon_rs/fluxon_pyo3/src/error.rs
@@ -379,7 +379,8 @@ pub(crate) fn py_error_from_kv_error(
     prefix: &str,
 ) -> PyObject {
     use fluxon_kv::rpcresp_kvresult_convert::msg_and_error::{
-        ApiError as CoreApiError, KvError, LeaseMgrError, TransferEngineError,
+        ApiError as CoreApiError, KvError, LeaseMgrError, P2pError as CoreP2pError,
+        TransferEngineError,
     };
     let msg = format!("{}: {}", prefix, e);
     match e {
@@ -412,6 +413,9 @@ pub(crate) fn py_error_from_kv_error(
         KvError::Api(CoreApiError::InvalidArgument { detail }) => {
             new_invalid_argument_error(py, &format!("{}: Invalid argument: {}", prefix, detail))
         }
+        KvError::P2p(CoreP2pError::InvalidRpcTimeout { .. }) => {
+            new_invalid_argument_error(py, &msg)
+        }
         KvError::Api(CoreApiError::FileWriteError {
             path,
             offset,
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index 1b89d76..693e873 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -29,7 +29,10 @@ use fluxon_kv::cluster_manager::ClusterManagerViewTrait;
 use fluxon_kv::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use fluxon_kv::config::{ClientConfigYaml, MasterConfigYaml};
 use fluxon_kv::external_client_api::ExternalClientApiViewTrait;
-use fluxon_kv::master_kv_router::msg_pack::{BatchPreparePutKeyItemReq, PutDoneCommittedSlot};
+use fluxon_kv::master_kv_router::msg_pack::{
+    BatchPreparePutKeyItemReq, PutDoneCommittedSlot, ReserveLocalGrantOutcome,
+    build_put_atomic_group_assignments,
+};
 use fluxon_kv::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
 use fluxon_kv::memholder::kvclient_encode::{BorrowedFlatKvValueRange, flat_kv_decode_borrowed};
 use fluxon_kv::memholder::{
@@ -2078,6 +2081,25 @@ struct FluxonGetViewsPlan {
     _holders: Vec<StagedGetViewHolder>,
 }
 
+fn defer_drop_to_runtime<T>(runtime: Option<&Runtime>, value: T)
+where
+    T: Send + 'static,
+{
+    if let Some(runtime) = runtime {
+        // Dropping a read plan can release hundreds of ExternalMemHolder
+        // instances. Each holder schedules its delete ACK, so doing the full
+        // drop on the Python scheduler thread adds milliseconds to every
+        // restore completion. The CUDA consumer has already finished before
+        // release_views is called; removing the plan from the registry makes
+        // the pointer invalid immediately, while the actual holder release can
+        // safely run on Tokio's blocking pool.
+        let _join = runtime.spawn_blocking(move || drop(value));
+    } else {
+        // A post-close caller has no runtime on which to defer cleanup.
+        drop(value);
+    }
+}
+
 enum StagedGetViewHolder {
     Owner { _holder: Arc<RustUserMemHolder> },
     External { _holder: Arc<RustExternalMemHolder> },
@@ -2106,6 +2128,8 @@ struct StagedOwnerPutPlanData {
     value_len: u64,
     key_reservation_ids: Vec<u64>,
     slot_lease: OwnerLocalReserveSlotLease,
+    make_replica_task_mask: Vec<bool>,
+    atomic_group_lens: Vec<usize>,
 }
 
 #[derive(Clone)]
@@ -3086,6 +3110,105 @@ pub struct KvClient {
     locality_counters: Arc<FluxonLocalityCounters>,
 }
 
+fn build_put_optional_args(
+    lease_id: Option<u64>,
+    reject_if_inflight_same_key: bool,
+    reject_if_exist_same_key: bool,
+    write_through: bool,
+    make_replica_task: bool,
+) -> fluxon_kv::client_kv_api::PutOptionalArgs {
+    let mut opts = fluxon_kv::client_kv_api::PutOptionalArgs::new();
+    if let Some(id) = lease_id {
+        opts.0
+            .push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
+    }
+    if reject_if_inflight_same_key {
+        opts.0
+            .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
+    }
+    if reject_if_exist_same_key {
+        opts.0
+            .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
+    }
+    if write_through || !make_replica_task {
+        opts.0
+            .push(fluxon_kv::client_kv_api::PutOptionalArg::SkipMakeReplicaTask);
+    }
+    opts
+}
+
+fn resolve_make_replica_task_mask(
+    key_count: usize,
+    write_through: bool,
+    make_replica_task: bool,
+    requested_mask: Option<Vec<bool>>,
+    atomic_group_lens: &[usize],
+) -> Result<Vec<bool>, String> {
+    let requested_mask = match requested_mask {
+        Some(mask) => {
+            if mask.len() != key_count {
+                return Err(format!(
+                    "make_replica_task_mask length must match keys length; keys={} mask={}",
+                    key_count,
+                    mask.len()
+                ));
+            }
+            mask
+        }
+        None => vec![true; key_count],
+    };
+    let mut offset = 0usize;
+    for (group_index, group_len) in atomic_group_lens.iter().copied().enumerate() {
+        let end = offset + group_len;
+        let group_mask = &requested_mask[offset..end];
+        if group_mask[1..].iter().any(|item| *item != group_mask[0]) {
+            return Err(format!(
+                "make_replica_task_mask must be uniform within each atomic group; group_index={} offset={} len={}",
+                group_index, offset, group_len
+            ));
+        }
+        offset = end;
+    }
+    let enabled = !write_through && make_replica_task;
+    Ok(requested_mask
+        .into_iter()
+        .map(|requested| enabled && requested)
+        .collect())
+}
+
+fn normalize_put_atomic_group_lens(
+    key_count: usize,
+    requested_group_lens: Option<Vec<usize>>,
+) -> Result<Vec<usize>, String> {
+    let Some(group_lens) = requested_group_lens else {
+        return Ok(vec![1; key_count]);
+    };
+    if group_lens.is_empty() {
+        return Err("atomic_group_lens must be non-empty when provided".to_string());
+    }
+    if let Some((index, _)) = group_lens
+        .iter()
+        .enumerate()
+        .find(|(_, length)| **length == 0)
+    {
+        return Err(format!(
+            "atomic_group_lens entries must be > 0; index={} got=0",
+            index
+        ));
+    }
+    let group_sum = group_lens
+        .iter()
+        .try_fold(0usize, |sum, length| sum.checked_add(*length))
+        .ok_or_else(|| "atomic_group_lens sum overflowed usize".to_string())?;
+    if group_sum != key_count {
+        return Err(format!(
+            "atomic_group_lens must sum to keys length; sum={} keys={}",
+            group_sum, key_count
+        ));
+    }
+    Ok(group_lens)
+}
+
 #[pymethods]
 impl KvClient {
     /// Create a new KV client
@@ -3358,7 +3481,7 @@ impl KvClient {
                         .client_kv_api_view()
                         .client_kv_api()
                         .inner()
-                        .reserve_local_grant()
+                        .reserve_local_grant(0, 0, false)
                         .await
                 })
             }) {
@@ -3371,9 +3494,22 @@ impl KvClient {
                 }
             };
             match reserve_resp {
-                Ok(resp) => ApiResult::new_success(
-                    (resp.grant_id, resp.addr, resp.base_addr, resp.len).into_py(py),
-                ),
+                Ok(ReserveLocalGrantOutcome::Granted {
+                    grant_id,
+                    node_id: _,
+                    addr,
+                    base_addr,
+                    len,
+                }) => ApiResult::new_success((grant_id, addr, base_addr, len).into_py(py)),
+                Ok(ReserveLocalGrantOutcome::Reclaimed { .. }) => {
+                    ApiResult::new_error(new_general_error(
+                        py,
+                        "raw reserve_local_grant request unexpectedly reclaimed class slots",
+                    ))
+                }
+                Ok(ReserveLocalGrantOutcome::None) => {
+                    unreachable!("reserve_local_grant filters empty successful outcomes")
+                }
                 Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
                     py,
                     &err,
@@ -3446,13 +3582,17 @@ impl KvClient {
         release_local_grant_blocking_inner(self, grant_id, py).into_py_object(py)
     }
 
-    #[pyo3(signature = (keys, value_len, reject_if_inflight_same_key=false, reject_if_exist_same_key=false))]
+    #[pyo3(signature = (keys, value_len, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, make_replica_task=true, make_replica_task_mask=None, atomic_group_lens=None))]
     fn local_fast_put_start(
         &self,
         keys: Vec<String>,
         value_len: u64,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
+        write_through: bool,
+        make_replica_task: bool,
+        make_replica_task_mask: Option<Vec<bool>>,
+        atomic_group_lens: Option<Vec<usize>>,
         py: Python,
     ) -> PyObject {
         fn local_fast_put_start_inner(
@@ -3461,6 +3601,10 @@ impl KvClient {
             value_len: u64,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
+            write_through: bool,
+            make_replica_task: bool,
+            make_replica_task_mask: Option<Vec<bool>>,
+            atomic_group_lens: Option<Vec<usize>>,
             py: Python,
         ) -> ApiResult<PyObject> {
             if keys.is_empty() {
@@ -3481,6 +3625,25 @@ impl KvClient {
                     "local_fast_put_start value_len exceeds u32 limit",
                 ));
             }
+            let atomic_group_lens =
+                match normalize_put_atomic_group_lens(keys.len(), atomic_group_lens) {
+                    Ok(group_lens) => group_lens,
+                    Err(detail) => {
+                        return ApiResult::new_error(new_invalid_argument_error(py, &detail));
+                    }
+                };
+            let make_replica_task_mask = match resolve_make_replica_task_mask(
+                keys.len(),
+                write_through,
+                make_replica_task,
+                make_replica_task_mask,
+                &atomic_group_lens,
+            ) {
+                Ok(mask) => mask,
+                Err(detail) => {
+                    return ApiResult::new_error(new_invalid_argument_error(py, &detail));
+                }
+            };
             let framework = match require_kv_framework_api(client, py) {
                 Ok(v) => v,
                 Err(e) => return ApiResult::new_error(e),
@@ -3497,6 +3660,8 @@ impl KvClient {
             if framework.is_external_mode() {
                 let framework_for_start = framework.clone();
                 let keys_for_req = keys.clone();
+                let make_replica_task_mask_for_req = make_replica_task_mask.clone();
+                let atomic_group_lens_for_req = atomic_group_lens.clone();
                 let external_start_result = match py.allow_threads(|| {
                     runtime.run_async_from_sync(async move {
                         let external_api_view = framework_for_start.external_client_api_view();
@@ -3508,15 +3673,17 @@ impl KvClient {
                             .external_batch_put_start_rpc(ExternalBatchPutStartReq {
                                 items: keys_for_req
                                     .iter()
-                                    .map(|key| ExternalBatchPutStartItemReq {
+                                    .zip(make_replica_task_mask_for_req.iter())
+                                    .map(|(key, make_replica_task)| ExternalBatchPutStartItemReq {
                                         key: key.clone(),
                                         len: value_len,
                                         reject_if_inflight_same_key,
                                         reject_if_exist_same_key,
-                                        make_replica_task: true,
+                                        make_replica_task: *make_replica_task,
                                         preferred_sub_cluster: None,
                                     })
                                     .collect(),
+                                atomic_group_lens: Some(atomic_group_lens_for_req),
                                 started_time,
                             })
                             .await?;
@@ -3681,6 +3848,13 @@ impl KvClient {
                 return ApiResult::new_success((plan_ptr as u64).into_py(py));
             }
 
+            if write_through {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "local_fast_put_start write_through=true requires external mode",
+                ));
+            }
+
             let key_count = keys.len();
             let framework_for_start = framework.clone();
             let prepare_items = keys
@@ -3772,6 +3946,8 @@ impl KvClient {
                         value_len,
                         key_reservation_ids,
                         slot_lease,
+                        make_replica_task_mask,
+                        atomic_group_lens,
                     },
                 ))),
             });
@@ -3790,6 +3966,10 @@ impl KvClient {
             value_len,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
+            write_through,
+            make_replica_task,
+            make_replica_task_mask,
+            atomic_group_lens,
             py,
         )
         .into_py_object(py)
@@ -3931,12 +4111,15 @@ impl KvClient {
                         let inner = client_kv_api_view.client_kv_api().inner();
                         let slot_refs = owner_data.slot_lease.slots.clone();
                         let slot_size = owner_data.slot_lease.slot_size;
-                        if slot_refs.len() != owner_data.keys.len() {
+                        if slot_refs.len() != owner_data.keys.len()
+                            || owner_data.make_replica_task_mask.len() != owner_data.keys.len()
+                        {
                             let err = CoreKvError::Api(CoreApiError::Unknown {
                                 detail: format!(
-                                    "local_fast_put_commit slot/key length mismatch: keys={} slots={}",
+                                    "local_fast_put_commit staged length mismatch: keys={} slots={} replica_mask={}",
                                     owner_data.keys.len(),
-                                    slot_refs.len()
+                                    slot_refs.len(),
+                                    owner_data.make_replica_task_mask.len()
                                 ),
                             });
                             let _ = release_staged_put_resources(
@@ -3971,7 +4154,44 @@ impl KvClient {
                         };
                         let mut publish_items = Vec::with_capacity(owner_data.keys.len());
                         let mut ret_codes = Vec::with_capacity(owner_data.keys.len());
-                        for (key, slot_ref) in owner_data.keys.iter().zip(slot_refs.iter()) {
+                        let put_ids = owner_data
+                            .keys
+                            .iter()
+                            .map(|_| inner.next_owner_local_first_put_id())
+                            .collect::<Vec<_>>();
+                        let keys_and_put_ids = owner_data
+                            .keys
+                            .iter()
+                            .cloned()
+                            .zip(put_ids.iter().copied())
+                            .collect::<Vec<_>>();
+                        let atomic_groups = match build_put_atomic_group_assignments(
+                            &keys_and_put_ids,
+                            &owner_data.atomic_group_lens,
+                        ) {
+                            Ok(groups) => groups,
+                            Err(detail) => {
+                                let err =
+                                    CoreKvError::Api(CoreApiError::InvalidArgument { detail });
+                                let _ = release_staged_put_resources(
+                                    inner,
+                                    owner_data.key_reservation_ids,
+                                    owner_data.slot_lease,
+                                )
+                                .await;
+                                return ApiResult::new_success(vec![
+                                    kv_error_to_ret_code(&err);
+                                    owner_data.keys.len()
+                                ]);
+                            }
+                        };
+                        for (idx, ((key, slot_ref), make_replica_task)) in owner_data
+                            .keys
+                            .iter()
+                            .zip(slot_refs.iter())
+                            .zip(owner_data.make_replica_task_mask.iter())
+                            .enumerate()
+                        {
                             let memory_info = inner
                                 .build_local_reserve_resident_memory_info(
                                     key,
@@ -3986,12 +4206,13 @@ impl KvClient {
                                 key,
                                 memory_info.clone(),
                             );
-                            let put_id = inner.next_owner_local_first_put_id();
+                            let put_id = put_ids[idx];
                             let promote = inner
                                 .promote_precommit_local_reserve_resident_slot_if_same(
                                     key,
                                     put_id,
                                     memory_info.clone(),
+                                    atomic_groups[idx].as_ref(),
                                 );
                             match promote {
                                 Ok(()) => {
@@ -4009,8 +4230,9 @@ impl KvClient {
                                             base_addr: slot_ref.base_addr,
                                             len: owner_data.value_len,
                                         },
-                                        make_replica_task: true,
+                                        make_replica_task: *make_replica_task,
                                         preferred_sub_cluster: None,
+                                        atomic_group: atomic_groups[idx].clone(),
                                     });
                                     ret_codes.push(0);
                                 }
@@ -4292,7 +4514,8 @@ impl KvClient {
                 guard.remove(&plan_ptr_usize)
             };
             match removed {
-                Some(FluxonPlanRegistryEntry::Get(_plan)) => {
+                Some(FluxonPlanRegistryEntry::Get(plan)) => {
+                    defer_drop_to_runtime(client.runtime.as_ref(), plan);
                     ApiResult::new_success(0i32.into_py(py))
                 }
                 Some(FluxonPlanRegistryEntry::Put(_)) => ApiResult::new_error(
@@ -4692,7 +4915,7 @@ impl KvClient {
     /// on the caller to keep the pointed-to memory alive until the async call completes.
     ///
     /// The backend encoding/copy runs on the Rust runtime without holding the Python GIL.
-    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, callback=None))]
+    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, callback=None, write_through=true, make_replica_task=true))]
     fn put(
         &self,
         key: &str,
@@ -4701,6 +4924,8 @@ impl KvClient {
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
         callback: Option<PyObject>,
+        write_through: bool,
+        make_replica_task: bool,
         py: Python,
     ) -> PyObject {
         fn put_inner(
@@ -4711,6 +4936,8 @@ impl KvClient {
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
             callback: Option<PyObject>,
+            write_through: bool,
+            make_replica_task: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if ptrs.len() > (u32::MAX as usize) {
@@ -4730,19 +4957,13 @@ impl KvClient {
                     ));
                 }
             };
-            let put_opts = {
-                let mut o = fluxon_kv::client_kv_api::PutOptionalArgs::new();
-                if let Some(id) = lease_id {
-                    o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
-                }
-                if reject_if_inflight_same_key {
-                    o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
-                }
-                if reject_if_exist_same_key {
-                    o.0.push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
-                }
-                o
-            };
+            let put_opts = build_put_optional_args(
+                lease_id,
+                reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
+                make_replica_task,
+            );
 
             let future = async move {
                 let result = unsafe { framework.kv_put_ptrs(&key, ptrs, put_opts).await };
@@ -4802,13 +5023,15 @@ impl KvClient {
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
             callback,
+            write_through,
+            make_replica_task,
             py,
         )
         .into_py_object(py)
     }
 
     /// Put a key-value pair and wait for completion before returning.
-    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false))]
+    #[pyo3(signature = (key, ptrs, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, make_replica_task=true))]
     fn put_blocking(
         &self,
         key: &str,
@@ -4816,6 +5039,8 @@ impl KvClient {
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
+        write_through: bool,
+        make_replica_task: bool,
         py: Python,
     ) -> PyObject {
         fn put_blocking_inner(
@@ -4825,6 +5050,8 @@ impl KvClient {
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
+            write_through: bool,
+            make_replica_task: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if ptrs.len() > (u32::MAX as usize) {
@@ -4845,22 +5072,13 @@ impl KvClient {
                 }
             };
             let framework = borrow_stable_owner(&framework);
-            let mut put_opts = fluxon_kv::client_kv_api::PutOptionalArgs::new();
-            if let Some(id) = lease_id {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
-            }
-            if reject_if_inflight_same_key {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
-            }
-            if reject_if_exist_same_key {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
-            }
+            let put_opts = build_put_optional_args(
+                lease_id,
+                reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
+                make_replica_task,
+            );
             let result = match py.allow_threads(|| {
                 runtime.run_async_from_sync(async {
                     unsafe { framework.kv_put_ptrs(&key, ptrs, put_opts).await }
@@ -4909,6 +5127,8 @@ impl KvClient {
             lease_id,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
+            write_through,
+            make_replica_task,
             py,
         )
         .into_py_object(py)
@@ -4917,7 +5137,7 @@ impl KvClient {
     /// Put a batch of key-value pairs and wait for completion before returning.
     ///
     /// Each item uses the same flatdict encoding contract as `put_blocking()`.
-    #[pyo3(signature = (keys, ptrs_groups, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, concurrency=None))]
+    #[pyo3(signature = (keys, ptrs_groups, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, concurrency=None, write_through=true, make_replica_task=true))]
     fn batch_put_blocking(
         &self,
         keys: Vec<String>,
@@ -4926,6 +5146,8 @@ impl KvClient {
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
         concurrency: Option<usize>,
+        write_through: bool,
+        make_replica_task: bool,
         py: Python,
     ) -> PyObject {
         fn batch_put_blocking_inner(
@@ -4936,6 +5158,8 @@ impl KvClient {
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
             concurrency: Option<usize>,
+            write_through: bool,
+            make_replica_task: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if keys.len() != ptrs_groups.len() {
@@ -4974,22 +5198,13 @@ impl KvClient {
             let framework = borrow_stable_owner(&framework);
             let keys_for_results = keys;
 
-            let mut put_opts = fluxon_kv::client_kv_api::PutOptionalArgs::new();
-            if let Some(id) = lease_id {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
-            }
-            if reject_if_inflight_same_key {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
-            }
-            if reject_if_exist_same_key {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
-            }
+            let put_opts = build_put_optional_args(
+                lease_id,
+                reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
+                make_replica_task,
+            );
 
             if !framework.is_external_mode() {
                 let framework_for_backend = framework.clone();
@@ -5156,6 +5371,8 @@ impl KvClient {
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
             concurrency,
+            write_through,
+            make_replica_task,
             py,
         )
         .into_py_object(py)
@@ -5206,7 +5423,7 @@ impl KvClient {
     }
 
     /// Native blocking batch put path for payload pointers.
-    #[pyo3(signature = (keys, payload_ptrs, payload_sizes, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false))]
+    #[pyo3(signature = (keys, payload_ptrs, payload_sizes, lease_id=None, reject_if_inflight_same_key=false, reject_if_exist_same_key=false, write_through=true, make_replica_task=true))]
     fn batch_put_from(
         &self,
         keys: Vec<String>,
@@ -5215,6 +5432,8 @@ impl KvClient {
         lease_id: Option<u64>,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
+        write_through: bool,
+        make_replica_task: bool,
         py: Python,
     ) -> PyObject {
         fn batch_put_from_inner(
@@ -5225,6 +5444,8 @@ impl KvClient {
             lease_id: Option<u64>,
             reject_if_inflight_same_key: bool,
             reject_if_exist_same_key: bool,
+            write_through: bool,
+            make_replica_task: bool,
             py: Python,
         ) -> ApiResult<PyObject> {
             if keys.len() != payload_ptrs.len() || keys.len() != payload_sizes.len() {
@@ -5284,22 +5505,13 @@ impl KvClient {
             drop(registered);
 
             let framework = borrow_stable_owner(&framework);
-            let mut put_opts = fluxon_kv::client_kv_api::PutOptionalArgs::new();
-            if let Some(id) = lease_id {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::LeaseId(id));
-            }
-            if reject_if_inflight_same_key {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfInflightSameKey);
-            }
-            if reject_if_exist_same_key {
-                put_opts
-                    .0
-                    .push(fluxon_kv::client_kv_api::PutOptionalArg::RejectIfExistSameKey);
-            }
+            let put_opts = build_put_optional_args(
+                lease_id,
+                reject_if_inflight_same_key,
+                reject_if_exist_same_key,
+                write_through,
+                make_replica_task,
+            );
 
             let keys_for_backend = keys.clone();
             let ptrs_groups = keys_for_backend
@@ -5419,6 +5631,8 @@ impl KvClient {
             lease_id,
             reject_if_inflight_same_key,
             reject_if_exist_same_key,
+            write_through,
+            make_replica_task,
             py,
         )
         .into_py_object(py)
@@ -6359,14 +6573,11 @@ impl KvClient {
             timeout_ms: u64,
             py: Python,
         ) -> ApiResult<PyObject> {
-            if timeout_ms < fluxon_kv::user_rpc::USER_RPC_MIN_TIMEOUT_MS {
-                return ApiResult::new_error(new_invalid_argument_error(
+            if let Err(err) = fluxon_kv::user_rpc::validate_timeout_ms(timeout_ms) {
+                return ApiResult::new_error(crate::error::py_error_from_kv_error(
                     py,
-                    &format!(
-                        "timeout_ms must be >= {} (got {})",
-                        fluxon_kv::user_rpc::USER_RPC_MIN_TIMEOUT_MS,
-                        timeout_ms
-                    ),
+                    &err,
+                    "Invalid RPC timeout",
                 ));
             }
 
@@ -6482,14 +6693,13 @@ impl KvClient {
             timeout_ms: u64,
             py: Python,
         ) -> ApiResult<PyObject> {
-            const MIN_TIMEOUT_MS: u64 = 10_000;
-            if timeout_ms < MIN_TIMEOUT_MS {
-                return ApiResult::new_error(new_invalid_argument_error(
+            if let Err(err) = fluxon_kv::p2p::msg_pack::validate_explicit_rpc_timeout_ms(timeout_ms)
+            {
+                let err = CoreKvError::from(err);
+                return ApiResult::new_error(crate::error::py_error_from_kv_error(
                     py,
-                    &format!(
-                        "timeout_ms must be >= {} (got {})",
-                        MIN_TIMEOUT_MS, timeout_ms
-                    ),
+                    &err,
+                    "Invalid RPC timeout",
                 ));
             }
             if target_instance_key.trim().is_empty() {
@@ -6981,6 +7191,10 @@ fn run_master_blocking(config: Option<&Bound<'_, PyAny>>, py: Python) -> PyObjec
 #[pyo3(name = "fluxon_pyo3")]
 fn fluxon_pyo3(m: &Bound<'_, PyModule>) -> PyResult<()> {
     init_dynamic_libraries()?;
+    m.add(
+        "MIN_EXPLICIT_RPC_TIMEOUT_MS",
+        fluxon_kv::p2p::msg_pack::MIN_EXPLICIT_RPC_TIMEOUT_MS,
+    )?;
     m.add_class::<KvClient>()?;
     m.add_class::<KvMaster>()?;
     m.add_class::<KvFuture>()?;
@@ -7014,18 +7228,151 @@ fn fluxon_pyo3(m: &Bound<'_, PyModule>) -> PyResult<()> {
 #[cfg(test)]
 mod tests {
     use super::{
-        bundled_driver_names_from_entries, configure_bundled_rdmav_driver_env,
+        build_put_optional_args, bundled_driver_names_from_entries,
+        configure_bundled_rdmav_driver_env, defer_drop_to_runtime,
         discover_bundled_ibverbs_driver_config,
         extract_fluxon_pyo3_libs_root_from_loaded_library_line, loaded_fluxon_pyo3_libs_roots,
-        parse_bundled_ibverbs_driver_name, sanitize_bundled_ld_library_path_entries,
+        normalize_put_atomic_group_lens, parse_bundled_ibverbs_driver_name,
+        resolve_make_replica_task_mask, sanitize_bundled_ld_library_path_entries,
         set_authoritative_bundled_ld_library_path, validate_single_fluxon_pyo3_libs_root,
     };
     use std::path::{Path, PathBuf};
-    use std::sync::{Mutex, OnceLock};
-    use std::time::{SystemTime, UNIX_EPOCH};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::{Arc, Mutex, OnceLock};
+    use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
     static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 
+    struct DropProbe(Arc<AtomicUsize>);
+
+    impl Drop for DropProbe {
+        fn drop(&mut self) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    #[test]
+    fn defer_drop_to_runtime_eventually_drops_value() {
+        let runtime = tokio::runtime::Runtime::new().unwrap();
+        let dropped = Arc::new(AtomicUsize::new(0));
+        defer_drop_to_runtime(Some(&runtime), DropProbe(dropped.clone()));
+
+        let deadline = Instant::now() + Duration::from_secs(2);
+        while dropped.load(Ordering::SeqCst) == 0 && Instant::now() < deadline {
+            std::thread::sleep(Duration::from_millis(1));
+        }
+        assert_eq!(dropped.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn defer_drop_without_runtime_is_synchronous() {
+        let dropped = Arc::new(AtomicUsize::new(0));
+        defer_drop_to_runtime(None, DropProbe(dropped.clone()));
+        assert_eq!(dropped.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn put_options_control_async_replica_task() {
+        let write_through = build_put_optional_args(None, false, false, true, true);
+        let write_back = build_put_optional_args(None, false, false, false, true);
+        let local_only = build_put_optional_args(None, false, false, false, false);
+
+        assert!(!write_through.make_replica_task());
+        assert!(write_back.make_replica_task());
+        assert!(!local_only.make_replica_task());
+    }
+
+    #[test]
+    fn local_fast_put_replica_mask_broadcasts_scalar() {
+        assert_eq!(
+            resolve_make_replica_task_mask(3, false, true, None, &[1, 1, 1]).unwrap(),
+            vec![true, true, true]
+        );
+        assert_eq!(
+            resolve_make_replica_task_mask(3, false, false, None, &[1, 1, 1]).unwrap(),
+            vec![false, false, false]
+        );
+    }
+
+    #[test]
+    fn local_fast_put_replica_mask_selects_items() {
+        assert_eq!(
+            resolve_make_replica_task_mask(
+                4,
+                false,
+                true,
+                Some(vec![true, false, true, false]),
+                &[1, 1, 1, 1],
+            )
+            .unwrap(),
+            vec![true, false, true, false]
+        );
+    }
+
+    #[test]
+    fn local_fast_put_replica_mask_respects_global_gates() {
+        let requested = Some(vec![true, false, true]);
+        assert_eq!(
+            resolve_make_replica_task_mask(3, true, true, requested.clone(), &[1, 1, 1]).unwrap(),
+            vec![false, false, false]
+        );
+        assert_eq!(
+            resolve_make_replica_task_mask(3, false, false, requested, &[1, 1, 1]).unwrap(),
+            vec![false, false, false]
+        );
+    }
+
+    #[test]
+    fn local_fast_put_replica_mask_rejects_length_mismatch() {
+        let err =
+            resolve_make_replica_task_mask(3, false, true, Some(vec![true, false]), &[1, 1, 1])
+                .unwrap_err();
+        assert_eq!(
+            err,
+            "make_replica_task_mask length must match keys length; keys=3 mask=2"
+        );
+    }
+
+    #[test]
+    fn local_fast_put_atomic_groups_accept_valid_partition() {
+        assert_eq!(
+            normalize_put_atomic_group_lens(5, Some(vec![2, 3])).unwrap(),
+            vec![2, 3]
+        );
+        assert_eq!(
+            normalize_put_atomic_group_lens(3, None).unwrap(),
+            vec![1, 1, 1]
+        );
+    }
+
+    #[test]
+    fn local_fast_put_atomic_groups_reject_zero_and_sum_mismatch() {
+        assert_eq!(
+            normalize_put_atomic_group_lens(3, Some(vec![1, 0, 2])).unwrap_err(),
+            "atomic_group_lens entries must be > 0; index=1 got=0"
+        );
+        assert_eq!(
+            normalize_put_atomic_group_lens(3, Some(vec![1, 1])).unwrap_err(),
+            "atomic_group_lens must sum to keys length; sum=2 keys=3"
+        );
+    }
+
+    #[test]
+    fn local_fast_put_replica_mask_rejects_split_atomic_group() {
+        let err = resolve_make_replica_task_mask(
+            5,
+            false,
+            true,
+            Some(vec![true, true, false, true, true]),
+            &[2, 3],
+        )
+        .unwrap_err();
+        assert_eq!(
+            err,
+            "make_replica_task_mask must be uniform within each atomic group; group_index=1 offset=2 len=3"
+        );
+    }
+
     struct EnvSnapshot {
         key: &'static str,
         value: Option<String>,
diff --git a/fluxon_rs/fluxon_util/src/log.rs b/fluxon_rs/fluxon_util/src/log.rs
index 4db4ae4..b941ed5 100644
--- a/fluxon_rs/fluxon_util/src/log.rs
+++ b/fluxon_rs/fluxon_util/src/log.rs
@@ -226,20 +226,6 @@ fn setup_global_log_guards(file_guard: WorkerGuard, console_guard: WorkerGuard)
     let _ = GLOBAL_CONSOLE_LOG_GUARD.set(console_guard);
 }
 
-fn workspace_targets_filter(
-    workspace_level: filter::LevelFilter,
-    non_workspace_default: filter::LevelFilter,
-) -> filter::Targets {
-    let mut targets = filter::Targets::new().with_default(non_workspace_default);
-    for c in generated_crates::OUR_CRATES {
-        targets = targets.with_target(*c, workspace_level);
-    }
-    for c in RDMA_DEBUG_TARGETS {
-        targets = targets.with_target(*c, workspace_level);
-    }
-    targets
-}
-
 fn third_party_log_target_overrides(
     enable_iceoryx_logs: bool,
     default_level: filter::LevelFilter,
@@ -480,11 +466,16 @@ where
             }
 
             if let Some(level) = crate_level {
-                // Use build-time generated workspace member list.
-                let our_crates: &[&str] = generated_crates::OUR_CRATES;
+                // Use build-time generated workspace members plus the explicit RDMA
+                // diagnostic targets. A bare level remains one canonical setting for
+                // console, file, and exporter layers.
+                let our_crates = generated_crates::OUR_CRATES
+                    .iter()
+                    .copied()
+                    .chain(RDMA_DEBUG_TARGETS.iter().copied());
                 let mut changed = removed_bare_debug;
                 for c in our_crates {
-                    if !existing_targets.contains(&c.to_string()) {
+                    if !existing_targets.contains(c) {
                         new_parts.push(format!("{}={}", c, level));
                         changed = true;
                     }
@@ -516,8 +507,9 @@ where
         }
     }
 
-    // File log keeps workspace crates at DEBUG; non-workspace crates default to WARN.
-    // This avoids dumping verbose dependency debug logs (e.g. h2/tower) into file output.
+    // All sinks follow the canonical RUST_LOG/FLUXON_LOG filter. Keeping a fixed DEBUG
+    // file layer here makes an `info` or `error` runtime silently continue formatting
+    // and writing high-volume debug events.
     let file_path = current_daily_log_file_path(log_path, instance_key);
     // Keep a copy for the whole process lifetime; collectors can clone it.
     if let Some(prev) = GLOBAL_LOG_FILE_PATH.get() {
@@ -542,18 +534,17 @@ where
             .map(|v| v.trim().to_ascii_lowercase()),
         Some(v) if !matches!(v.as_str(), "" | "0" | "false" | "no")
     );
-    let file_filter =
-        workspace_targets_filter(filter::LevelFilter::DEBUG, filter::LevelFilter::WARN);
+    let file_filter = EnvFilter::from_default_env();
     let file_layer = tracing_subscriber::fmt::layer()
         .with_timer(UtcSecondTimer)
         .with_writer(file_writer)
         .with_ansi(false)
-        .with_filter(file_filter.clone().or(third_party_log_target_overrides(
+        .with_filter(file_filter.or(third_party_log_target_overrides(
             enable_iceoryx_logs,
             filter::LevelFilter::WARN,
         )));
 
-    // Console logging follows user config (RUST_LOG/FLUXON_LOG); file logging ignores it.
+    // Console logging follows the same user config as file output.
     let (console_writer, console_guard) = non_blocking(io::stdout());
     let console_env_filter = EnvFilter::from_default_env();
     let console_layer = tracing_subscriber::fmt::layer()
@@ -561,9 +552,8 @@ where
         .with_filter(console_env_filter);
 
     // Register layers.
-    // `extra_layer` follows the same target filtering as file output (workspace=DEBUG, deps=WARN)
-    // to avoid exporting noisy dependency debug logs by default.
-    let extra_layer = extra_layer.with_filter(file_filter.clone().or(
+    // Exporters follow the same canonical user filter as local sinks.
+    let extra_layer = extra_layer.with_filter(EnvFilter::from_default_env().or(
         third_party_log_target_overrides(enable_iceoryx_logs, filter::LevelFilter::WARN),
     ));
     let _ = tracing_subscriber::registry()
diff --git a/fluxon_rs/fluxon_util/src/vallocator/mod.rs b/fluxon_rs/fluxon_util/src/vallocator/mod.rs
index 2f56285..14d7dfd 100644
--- a/fluxon_rs/fluxon_util/src/vallocator/mod.rs
+++ b/fluxon_rs/fluxon_util/src/vallocator/mod.rs
@@ -4,6 +4,7 @@ pub use frame::*;
 pub mod test;
 
 use parking_lot::RwLock;
+use std::collections::{BTreeMap, BTreeSet};
 
 crate::define_error_code_enum_with_from! {
     #[repr(i32)]
@@ -42,6 +43,7 @@ impl std::fmt::Display for AllocError {
 impl std::error::Error for AllocError {}
 
 pub const ORDER: usize = 64;
+const CONTIGUOUS_ALLOCATION_ALIGNMENT: u64 = 4096;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AllocRegion {
@@ -49,8 +51,138 @@ pub struct AllocRegion {
     pub size: u64,
 }
 
+#[derive(Debug)]
+struct ContiguousRangeAllocator {
+    free_by_start: BTreeMap<u64, u64>,
+    free_by_size: BTreeSet<(u64, u64)>,
+    allocated: u64,
+    total: u64,
+}
+
+impl ContiguousRangeAllocator {
+    fn new(total: u64) -> Self {
+        let mut allocator = Self {
+            free_by_start: BTreeMap::new(),
+            free_by_size: BTreeSet::new(),
+            allocated: 0,
+            total,
+        };
+        if total != 0 {
+            allocator.insert_free_range(0, total);
+        }
+        allocator
+    }
+
+    fn aligned_capacity(size: u64) -> Option<u64> {
+        size.checked_add(CONTIGUOUS_ALLOCATION_ALIGNMENT - 1)
+            .map(|value| value / CONTIGUOUS_ALLOCATION_ALIGNMENT * CONTIGUOUS_ALLOCATION_ALIGNMENT)
+    }
+
+    fn insert_free_range(&mut self, start: u64, len: u64) {
+        if len == 0 {
+            return;
+        }
+        assert!(self.free_by_start.insert(start, len).is_none());
+        assert!(self.free_by_size.insert((len, start)));
+    }
+
+    fn remove_free_range(&mut self, start: u64, len: u64) {
+        assert_eq!(self.free_by_start.remove(&start), Some(len));
+        assert!(self.free_by_size.remove(&(len, start)));
+    }
+
+    fn alloc(&mut self, requested: u64) -> Option<(u64, u64)> {
+        let capacity = Self::aligned_capacity(requested)?;
+        let (range_len, range_start) = self.free_by_size.range((capacity, 0)..).next().copied()?;
+        self.remove_free_range(range_start, range_len);
+        let remaining = range_len - capacity;
+        if remaining != 0 {
+            self.insert_free_range(range_start + capacity, remaining);
+        }
+        self.allocated = self.allocated.checked_add(capacity)?;
+        Some((range_start, capacity))
+    }
+
+    fn free(&mut self, start: u64, capacity: u64) -> Result<u64, AllocError> {
+        let end = start.checked_add(capacity).ok_or_else(|| AllocError {
+            code: AllocErrorCode::InvalidAddress,
+            message: format!("Allocation range overflows: start={start} capacity={capacity}"),
+        })?;
+        if capacity == 0
+            || capacity % CONTIGUOUS_ALLOCATION_ALIGNMENT != 0
+            || start % CONTIGUOUS_ALLOCATION_ALIGNMENT != 0
+            || end > self.total
+        {
+            return Err(AllocError {
+                code: AllocErrorCode::InvalidAddress,
+                message: format!(
+                    "Invalid aligned allocation range: start={start} capacity={capacity} total={}",
+                    self.total
+                ),
+            });
+        }
+
+        let previous = self
+            .free_by_start
+            .range(..start)
+            .next_back()
+            .map(|(&range_start, &range_len)| (range_start, range_len));
+        if previous
+            .is_some_and(|(range_start, range_len)| range_start.saturating_add(range_len) > start)
+        {
+            return Err(AllocError {
+                code: AllocErrorCode::DoubleFree,
+                message: format!(
+                    "Range overlaps previous free range: start={start} capacity={capacity}"
+                ),
+            });
+        }
+        let next = self
+            .free_by_start
+            .range(start..)
+            .next()
+            .map(|(&range_start, &range_len)| (range_start, range_len));
+        if next.is_some_and(|(range_start, _)| range_start < end) {
+            return Err(AllocError {
+                code: AllocErrorCode::DoubleFree,
+                message: format!(
+                    "Range overlaps next free range: start={start} capacity={capacity}"
+                ),
+            });
+        }
+
+        let mut merged_start = start;
+        let mut merged_len = capacity;
+        if let Some((previous_start, previous_len)) = previous
+            && previous_start + previous_len == start
+        {
+            self.remove_free_range(previous_start, previous_len);
+            merged_start = previous_start;
+            merged_len += previous_len;
+        }
+        if let Some((next_start, next_len)) = next
+            && end == next_start
+        {
+            self.remove_free_range(next_start, next_len);
+            merged_len += next_len;
+        }
+        self.insert_free_range(merged_start, merged_len);
+        self.allocated = self
+            .allocated
+            .checked_sub(capacity)
+            .ok_or_else(|| AllocError {
+                code: AllocErrorCode::DoubleFree,
+                message: format!(
+                    "Allocated byte counter underflow: allocated={} capacity={capacity}",
+                    self.allocated
+                ),
+            })?;
+        Ok(capacity)
+    }
+}
+
 pub struct VirtualAllocator {
-    inner: RwLock<FrameAllocator<ORDER>>,
+    inner: RwLock<ContiguousRangeAllocator>,
 }
 
 impl std::fmt::Debug for VirtualAllocator {
@@ -65,11 +197,8 @@ impl std::fmt::Debug for VirtualAllocator {
 
 impl VirtualAllocator {
     pub fn new(total_size: u64) -> Result<Self, AllocError> {
-        let mut allocator = FrameAllocator::<ORDER>::new();
-        allocator.add_frame(0, total_size);
-
         Ok(Self {
-            inner: RwLock::new(allocator),
+            inner: RwLock::new(ContiguousRangeAllocator::new(total_size)),
         })
     }
 
@@ -95,8 +224,7 @@ impl VirtualAllocator {
         }
 
         let mut allocator = self.inner.write();
-        let (addr_opt, actual_size) = allocator.alloc(size);
-        if let Some(addr) = addr_opt {
+        if let Some((addr, actual_size)) = allocator.alloc(size) {
             if actual_size < size {
                 return Err(AllocError {
                     code: AllocErrorCode::AllocationFailed,
@@ -127,7 +255,7 @@ impl VirtualAllocator {
         }
 
         let mut allocator = self.inner.write();
-        let freed_size = allocator.dealloc(ptr, size);
+        let freed_size = allocator.free(ptr, size)?;
         if freed_size != size {
             return Err(AllocError {
                 code: AllocErrorCode::DeallocationException,
diff --git a/fluxon_rs/fluxon_util/src/vallocator/test.rs b/fluxon_rs/fluxon_util/src/vallocator/test.rs
index 132879f..07a92b1 100644
--- a/fluxon_rs/fluxon_util/src/vallocator/test.rs
+++ b/fluxon_rs/fluxon_util/src/vallocator/test.rs
@@ -1,5 +1,40 @@
 use crate::vallocator::VirtualAllocator;
 
+#[test]
+fn virtual_allocator_keeps_sglang_pages_exact_instead_of_power_of_two_rounding() {
+    const PAGE_BYTES: u64 = 4_718_592;
+    let allocator = VirtualAllocator::new(PAGE_BYTES * 3).unwrap();
+    let first = allocator.alloc(PAGE_BYTES).unwrap();
+    let second = allocator.alloc(PAGE_BYTES).unwrap();
+    let third = allocator.alloc(PAGE_BYTES).unwrap();
+
+    assert_eq!(first.size, PAGE_BYTES);
+    assert_eq!(second.size, PAGE_BYTES);
+    assert_eq!(third.size, PAGE_BYTES);
+    assert_eq!(allocator.get_allocated_size(), PAGE_BYTES * 3);
+    assert!(allocator.alloc(PAGE_BYTES).is_err());
+
+    allocator.free(second.start_addr, second.size).unwrap();
+    allocator.free(first.start_addr, first.size).unwrap();
+    allocator.free(third.start_addr, third.size).unwrap();
+    assert_eq!(allocator.get_allocated_size(), 0);
+
+    let whole = allocator.alloc(PAGE_BYTES * 3).unwrap();
+    assert_eq!(whole.start_addr, 0);
+    assert_eq!(whole.size, PAGE_BYTES * 3);
+}
+
+#[test]
+fn virtual_allocator_rounds_only_to_transfer_page_alignment() {
+    let allocator = VirtualAllocator::new(16 * 1024).unwrap();
+    let region = allocator.alloc(4097).unwrap();
+    assert_eq!(region.start_addr, 0);
+    assert_eq!(region.size, 8192);
+    assert_eq!(allocator.get_allocated_size(), 8192);
+    allocator.free(region.start_addr, region.size).unwrap();
+    assert_eq!(allocator.get_allocated_size(), 0);
+}
+
 #[test]
 fn test_empty_frame_allocator() {
     let mut frame = crate::vallocator::frame::FrameAllocator::<32>::new();
diff --git a/fluxon_rs/fluxon_util/tests/log_mgmt.rs b/fluxon_rs/fluxon_util/tests/log_mgmt.rs
index f459337..a458c47 100644
--- a/fluxon_rs/fluxon_util/tests/log_mgmt.rs
+++ b/fluxon_rs/fluxon_util/tests/log_mgmt.rs
@@ -63,8 +63,11 @@ fn kv_log_shards_roll_and_cleanup_with_test_window() {
         TEST_LOG_SHARD_ANCHOR_UNIX_SECONDS_ENV,
         (now - 2).to_string(),
     );
+    let _rust_log_guard = EnvVarGuard::set("RUST_LOG", "info");
+    let _fluxon_log_guard = EnvVarGuard::set("FLUXON_LOG", "info");
 
     fluxon_util::init_log(log_path, instance_key);
+    tracing::debug!(target: "fluxon_util", "[kv-log-mgmt][debug-must-be-filtered]");
     tracing::info!(target: "fluxon_util", "[kv-log-mgmt][phase=before] ts={}", now);
     std::thread::sleep(Duration::from_millis(300));
     std::thread::sleep(Duration::from_secs(11));
@@ -107,6 +110,11 @@ fn kv_log_shards_roll_and_cleanup_with_test_window() {
         !shard_2_text.contains("[kv-log-mgmt][phase=before]"),
         "second shard should not contain the before marker"
     );
+    assert!(
+        !shard_1_text.contains("[kv-log-mgmt][debug-must-be-filtered]")
+            && !shard_2_text.contains("[kv-log-mgmt][debug-must-be-filtered]"),
+        "file output must honor the canonical info filter"
+    );
     assert_eq!(DEFAULT_DAILY_LOG_RETENTION_DAYS, 31);
 }
 

From ec63dc3de0cae961058303c82892e38daacd0dae Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Fri, 17 Jul 2026 20:41:37 +0800
Subject: [PATCH 04/10] backup

---
 ...00\345\214\226\345\210\206\346\236\220.md" |  469 +++
 ...06\346\210\220\350\256\276\350\256\241.md" |  458 ++-
 ...45\345\205\245\350\247\204\345\210\222.md" |  565 +++
 .../closed_sdk/lib/libfluxon_commu_core.so    |  Bin 15433576 -> 17060408 bytes
 .../fluxon_kv/src/client_kv_api/delete.rs     |   17 +-
 .../src/client_kv_api/external_api.rs         | 3028 +++++++++++-----
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |  509 ++-
 .../client_kv_api/local_reserve_rebalance.rs  |  405 ++-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 2709 ++++++++++----
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  | 1784 ++++++++--
 .../fluxon_kv/src/client_kv_api/reclaim.rs    |  175 +-
 .../fluxon_kv/src/master_kv_router/delete.rs  |   27 +-
 .../fluxon_kv/src/master_kv_router/get.rs     |  946 ++++-
 .../fluxon_kv/src/master_kv_router/mod.rs     | 3138 ++++++++++-------
 .../src/master_kv_router/msg_pack.rs          |  213 +-
 .../fluxon_kv/src/master_kv_router/put.rs     | 1147 +++---
 .../fluxon_kv/src/master_kv_router/reclaim.rs | 1701 +++++++--
 .../src/master_kv_router/route_maintenance.rs |  166 +-
 .../src/master_lease_manager/lease.rs         |    9 +
 .../lease_manager_test.rs                     |   30 +
 .../master_lease_manager.rs                   |   15 +
 .../fluxon_kv/src/master_seg_manager/mod.rs   |   96 +-
 .../master_seg_manager/one_seg_allocator.rs   |    9 +
 fluxon_rs/fluxon_kv/src/memholder/lifetime.rs |   88 +-
 fluxon_rs/fluxon_kv/src/memholder/mod.rs      |   24 +
 .../rpcresp_kvresult_convert/msg_and_error.rs |    6 +
 fluxon_rs/fluxon_pyo3/src/lib.rs              |   86 +-
 pegaflow                                      |    1 +
 scripts/preview_doc_html.py                   |  547 +++
 29 files changed, 13786 insertions(+), 4582 deletions(-)
 create mode 100644 "fluxon_doc_cn/design/sglang_fluxon_kv_PegaFlow\345\257\271\347\205\247\344\270\216Get\350\267\257\345\276\204\347\256\200\345\214\226\345\210\206\346\236\220.md"
 create mode 100644 "fluxon_doc_cn/design/teststack_2_Benchmark\347\233\221\346\216\247\345\267\245\345\205\267\351\223\276\344\270\216AIPerf\346\216\245\345\205\245\350\247\204\345\210\222.md"
 create mode 160000 pegaflow
 create mode 100755 scripts/preview_doc_html.py

diff --git "a/fluxon_doc_cn/design/sglang_fluxon_kv_PegaFlow\345\257\271\347\205\247\344\270\216Get\350\267\257\345\276\204\347\256\200\345\214\226\345\210\206\346\236\220.md" "b/fluxon_doc_cn/design/sglang_fluxon_kv_PegaFlow\345\257\271\347\205\247\344\270\216Get\350\267\257\345\276\204\347\256\200\345\214\226\345\210\206\346\236\220.md"
new file mode 100644
index 0000000..95e9aab
--- /dev/null
+++ "b/fluxon_doc_cn/design/sglang_fluxon_kv_PegaFlow\345\257\271\347\205\247\344\270\216Get\350\267\257\345\276\204\347\256\200\345\214\226\345\210\206\346\236\220.md"
@@ -0,0 +1,469 @@
+# Fluxon Batch Get / singleflight：PegaFlow 对照与路径简化分析
+
+本文评审当前工作区新增的 owner 侧 Batch Get / per-key singleflight 路径，并与 PegaFlow 的 prefix query、prefetch、lease 和批量传输实现对照。评审范围从 `ExternalBatchGetStartReq` 进入 owner 开始，到 master `BatchGetStart`、payload transfer、`BatchGetDone` / `BatchGetRevoke` 以及 external handle 消费结束。
+
+原始评审基于 2026-07-16 的 Fluxon 工作区和 PegaFlow `master` 的提交
+`939363f198a0ffded9e3f30d8af9cdd74439f16c`。2026-07-17 已按当前工作树回填实现状态；
+没有把尚未执行的性能对比写成实测结论。
+
+## 2026-07-17 实现回填（当前权威状态）
+
+| 原问题 | 当前实现 | 状态 |
+| --- | --- | --- |
+| exact-batch 与 per-key 两层 shared op | exact-batch phase/waiter/result cache 已删除；`ExternalGetStartEntry` 直接持请求自己的 `keys + Local/Interest items` | 已解决 |
+| `decision_registered` 手工归还 | `ExternalGetKeyInterest` 在 Drop 中归还 `undecided`，prefix decision 由 guard ownership 表达 | 已解决 |
+| process-wide `owner_key_control` 扫完整 batch/global states | 改为 256-shard `OwnerKeyControlTable`；local/join/leader 每个 key 独立线性化，任何同步锁均不跨 batch 或 `.await`；metrics 使用独立 Weak flight index | 已解决 |
+| 规划等待 Revoke 时取消会遗留未启动 leader | `ExternalGetPlanningLeadersGuard` 在 BatchGetStart handoff 前拥有新 leader；Drop 将仍为 `Starting` 的 op 发布为 safe miss、按 Arc identity 清 marker 并唤醒 joiner | 已解决 |
+| prepared slot 在 start/revoke 异常路径失去 owner | claim guard、同 operation identity Revoke retry 与 local slot release guard 已覆盖；响应不确定不猜测释放 | 已解决（仍需端到端故障注入） |
+| external handle 无界遗留 | handle sweeper 已接入，超时与显式 cancel 复用 plan Drop/interest release 路径 | 已解决（仍需进程死亡测试） |
+| payload 每 key 一次 transfer submission | 控制面仍批量，payload backend submission 仍需运行期计数与 benchmark 后决定是否扩展 descriptor batch API | 未解决/待测 |
+
+下文 §2～§4 保留为“2026-07-16 修复前快照”，用于解释为什么做上述改动；其中出现的
+“当前实现”均指该历史快照，不得覆盖本节和集成设计主文档的当前规约。
+
+## 原始结论（2026-07-16 修复前）
+
+**per-key singleflight 的目标应当保留，当前“两层共享操作”应当收缩。** 重叠但不完全相同的 batch 确实需要按 key 选出 local、joiner 和 leader，同时继续批量执行 master RPC。当前实现又在它外面保留了 exact-batch `ExternalGetStartSharedOp`，因此一次请求同时支付 exact-batch 去重和 per-key 去重的状态、锁、通知、结果缓存与生命周期成本。完全相同的 batch 本来就会自然 join 同一组 per-key flight；第二层去重没有形成独立的正确性边界。
+
+**当前首要风险是取消安全。** 常数级性能排在生命周期闭环之后。`decision_registered: bool`、`undecided`、`retained` 和 `waiter_count` 都依赖后续代码手工归还。future 在计数增加后的任一 `.await` 被取消时，没有 `Drop` guard 关闭这次 interest。静态控制流已经足以证明计数可能永久不归零，进而让 leader task、相同 batch、reclaim fence 或 exact-batch registry 一直等待。
+
+**结构性 overhead 已经存在，但实际延迟幅度仍需 benchmark。** 当前路径包含多份 key 向量和结果向量复制、每个新 leader key 的独立共享对象、两层 `Mutex + Notify`、通常两个后台 task、全局 owner key fence 内的线性扫描，以及每个远端 key 一次 `transfer_data_no_copy` 调用。它们在短 value、高并发、大 batch 场景更可能可见；没有 allocator、锁等待和端到端延迟数据前，不应写成“已经造成 X% 回退”。
+
+**PegaFlow 最值得学习的是所有权与生命周期的组织方式。** 它没有解决不同请求之间重叠 block 的 per-key singleflight，算法不能直接搬到 Fluxon。可借鉴的是：一次 prefix scan 直接取得 `Arc` pin、一个 ready prefix 对应一个 opaque lease、资源计数由 RAII / TTL 收口、request-level prefetch 只保留一个 task，以及数据面先汇总 descriptor 再提交。PegaFlow 当前 `QueryPrefetch` 在 probe 阶段就 pin、active prefetch 只按 `req_id` 标识、lease TTL 为 600 秒，这些都不应直接复制到 Fluxon。
+
+建议按以下顺序推进：
+
+1. **P0，先封闭生命周期**：把 decision、waiter、prepared slot 和 handle 改成 cancellation-safe guard；为 owner handle / operation 增加有界 TTL 或 generation cleanup；补齐取消与 revoke 不确定性测试。
+2. **P1，删除 exact-batch shared-op 层**：每个 external handle 直接持有一个 `BatchPlan`，其中的 item 引用 local holder 或 per-key flight。保留当前公开的 `get_start -> get_transfer | cancel` 契约。
+3. **P2，补全 master 收敛语义**：现有 `(key, requester)` RAII fence 保留，但把通用 `KeyBeingWritten`、`InvalidArgument`、`Unknown` 收敛成有限且可处理的 leader / join / already-committed / stale 结果。
+4. **P3，依据数据继续收缩**：若 per-key 对象和 wakeup 仍是热点，再把同一 leader cohort 折叠成一个 `BatchFlight`；若 suffix start / revoke 成本显著，再评估 side-effect-free probe 与 reserve 分离。
+
+## 1. 评审边界与证据等级
+
+本文沿三条轴评估当前路径，后文也按同样的轴给出验收条件：
+
+| 评估轴 | 覆盖内容 | 本文不声称的内容 |
+| --- | --- | --- |
+| 正确性与生命周期 | leader / joiner 归属、取消、revoke、prepared slot、master fence、reclaim 交互 | 不证明未检查模块的全系统回收行为 |
+| 控制面与数据面成本 | 对象、复制、锁、task、future、RPC 和 transfer 提交边界 | 不把静态计数换算成延迟或 QPS 百分比 |
+| 可验证性 | 并发测试、故障注入、metrics 和 benchmark 维度 | 不以单轮最终 QPS 代替路径级证据 |
+
+文中的判断分为三类：
+
+- **实现事实**：可由当前符号和控制流直接确认。
+- **风险推断**：由 Rust future 取消、所有权或锁作用域推导，仍需测试复现和量化影响。
+- **待测结论**：只能通过 benchmark、fault injection 或运行期 metrics 判断。
+
+PegaFlow 对照只用于提炼设计模式。它的 cache 层次、vLLM 接口和跨节点协议与 Fluxon 不同，因此本文不会从 PegaFlow 的局部实现推出 Fluxon 的全路径性能结论。
+
+## 2. 修复前 Fluxon 路径快照
+
+### 2.1 两层共享状态（已删除 exact-batch 层）
+
+修复前 owner 同时维护下列共享状态：
+
+| 层次 | 主要类型或容器 | 去重粒度 | 持有的状态 |
+| --- | --- | --- | --- |
+| external handle | `external_get_start_registry` / `ExternalGetStartEntry` | 一个返回给 external 的 handle | `req_node_id` 和 exact-batch shared op |
+| exact-batch | `external_get_start_by_key` / `ExternalGetStartSharedOp` | `keys + atomic_group_lens + prefix_best_effort` 完全相同 | `Starting/Running/Ready/Failed`、`waiter_count`、完整 dedup key、prefix、keys、items、`Mutex`、`Notify` |
+| per-key | `OwnerKeyControlState.external_get` / `ExternalGetKeySharedOp` | owner 内单个 key | `Starting/Started/Finishing/Revoking/Ready/Failed`、`undecided`、`retained`、key、`Mutex`、`Notify` |
+| master fence | `PreparedGetRequesterTable` / `PreparedGetRequesterLease` | `(key, requester)` | active `get_id` 和 RAII release |
+| prepared memory | `OwnerLocalReserveSlotState::Prepared` | 一个 local-reserve slot | 精确 grant、slot、地址和大小 |
+
+其中 master 的 `(key, requester)` fence 是这轮更新里已经落地的有效改进。它允许不同 GPU owner 同时 materialize 同一 key，同时阻止同一 requester 的两个 prepared Get 并行发布。当前不足是冲突结果仍不可 join，也不能直接取得已经提交的 canonical holder。
+
+### 2.2 修复前调用与数据流
+
+```mermaid
+flowchart TD
+    A[ExternalBatchGetStartReq] --> B{exact-batch DashMap}
+    B -->|已有| C[waiter_count + 1<br/>等待同一 ExternalGetStartSharedOp]
+    B -->|新建| D[创建 exact-batch shared op]
+    D --> E[owner_key_control 下逐 key 扫描]
+    E --> F[Local: clone MemoryInfo]
+    E --> G[Join: per-key undecided + 1]
+    E --> H[Leader: 创建 per-key shared op]
+    H --> I[一次 BatchGetStart 处理 leader keys]
+    I --> J[task 1: external_get_key_singleflight]
+    J --> K{每个 key 的 prefix interest}
+    K -->|retained > 0| L[per-key transfer + BatchGetDone]
+    K -->|retained = 0| M[BatchGetRevoke + 释放 slot]
+    L --> N[per-key Ready]
+    M --> N
+    F --> O[task 2: external_get_start_transfer]
+    G --> O
+    N --> O
+    O --> P[复制为 exact-batch Ready keys/items]
+    C --> Q[返回独立 handle]
+    P --> Q
+    Q --> R[get_transfer 再复制 Ready keys/items<br/>并安装 external holdings]
+```
+
+这里的 batch 化只覆盖部分边界：
+
+- owner 到 master 使用一次 `BatchGetStart`、一次 `BatchGetDone` 或 `BatchGetRevoke` RPC。
+- master 的 `handle_batch_get_start`、`handle_batch_get_done` 和 `handle_batch_get_revoke` 仍在进程内逐 item 调用单 key handler。
+- payload 阶段的 `batch_get_finish_started` 为每个需要传输的 key 创建一个 future；每个 future 调用一次 `transfer_data_no_copy`。该调用继续形成一次 closed-runtime transfer 请求。当前代码没有在这个边界先按 peer / transport 合并 descriptor。
+
+因此，“RPC 是 batch”不能直接推广成“payload 提交和底层 DMA 已经是一个 batch”。底层 backend 可能还有自己的优化，但不在本次已追踪到的调用链内。
+
+### 2.3 当前资源终止路径
+
+| 资源或计数 | 获得位置 | 正常终止 | 当前取消或不确定性缺口 |
+| --- | --- | --- | --- |
+| per-key `undecided` | `plan_external_get_key_items` 看到 `Starting/Started` | `decide_external_get_key_item` | 计数与 `decision_registered: bool` 分离；future Drop 不会自动 decide / abandon |
+| per-key `retained` | prefix 计算后手工增加 | leader finish / revoke 后发布 terminal | 依赖所有 `undecided` 先归零；一个丢失 decision 会阻塞整个 cohort |
+| exact-batch `waiter_count` | exact-batch 命中或创建 | transfer / cancel 末尾 `release_external_get_start_waiter` | start 或 transfer RPC future 中途取消时没有 guard |
+| external handle entry | `get_start` 返回前插入 `external_get_start_registry` | `get_transfer` 或 `cancel` remove | 容器没有 TTL；调用方进程死亡或消息丢失时没有本层兜底 |
+| prepared local slot | leader `BatchGetStart` 前 claim | Done commit，或 Revoke 成功后 release | `OwnerLocalReserveSlotLease` 没有 Drop cleanup；claim 后的 future 取消和 Revoke RPC 不确定性都可能失去释放路径 |
+| master requester fence | master 接受 prepared Get | `InflightGetInfo` Drop | 已有 RAII，且 inflight cache 有 60 秒 TTL；它不能替 owner 归还本地 `Prepared` slot |
+
+## 3. 正确性与生命周期发现
+
+### 3.1 手工 decision 不是 cancellation-safe 所有权
+
+`plan_external_get_key_items` 在 owner key fence 内先增加 `undecided`，随后调用链至少会经过 master RPC、逐 key start-code 等待和 prefix 计算。`ExternalGetStartOwnerItem::Shared` 只保存一个 `decision_registered: bool`，没有在 `Drop` 中减少计数。
+
+如果 future 在增加计数后、执行 `decide_external_get_key_item` 或 `abandon_external_get_key_decisions` 前被取消：
+
+1. `undecided` 永久保留本次 interest。
+2. `classify_external_get_key_leader` 一直等待 `undecided == 0`。
+3. `finish_external_get_key_leaders` 按 leader 顺序 await；一个 key 卡住会阻止同 cohort 后续 key 进入 finish / revoke。
+4. per-key marker 继续占用 owner key fence，reclaim 对该 key 返回 `Busy`。
+5. exact-batch creator 仍可能停在 `Starting`，相同 batch 后续全部等待同一未完成操作。
+
+这是 P0 正确性问题。修复应让“interest 存在”对应一个实际拥有 Drop 语义的 guard；bool 与计数器的约定不再承担所有权。
+
+同一问题也覆盖 prepared slot。`batch_get_start_with_local_reserve_targets` 先取得 `OwnerLocalReserveSlotLease`，再 `.await` master RPC；返回 `Err` 的显式分支会释放 lease，但 future 在 await 中被 Drop 时不会执行该分支。`OwnerLocalReserveSlotLease` 本身没有 `Drop` cleanup，所以本次 claim 的 slots 可能继续停在 `Prepared`。per-key leader task 又是在该 RPC 成功返回后才 spawn；若请求在 await 中被取消，master 可能已经接受操作，owner 却没有 executor 接管它。同步计数可以直接在 Drop 中归还；需要 RPC 的 cleanup 应由 Drop 把工作提交给一个有界、可观测的 owner cleanup actor，并由 TTL 处理 actor 或进程失效，不能依赖一个无所有者的临时 task。
+
+### 3.2 exact-batch waiter 和 handle 也存在同类缺口
+
+exact-batch 层的 `waiter_count` 同样依赖显式 release：
+
+- `external_batch_get_start` 注册 waiter 后可能在 prepare 或等待 prefix 时被取消。
+- `external_batch_get_transfer` 先从 handle registry remove，再等待 shared result；等待期间被取消后，调用方已经没有 handle 可以补发 cancel，函数尾部的 waiter release 也不会执行。
+- terminal exact-batch op 只有在 `waiter_count == 0` 时才从 `external_get_start_by_key` 删除。
+
+因此这一层不仅增加常数成本，也增加了一个独立的泄漏和永久等待面。删除该层会直接减少一种必须证明正确的生命周期。
+
+### 3.3 exact-batch 的收益有限，参数归属也不清晰
+
+exact-batch 层并非完全没有收益。它能让 100% 相同的并发请求只计算一次 prefix、只注册一次 per-key decision，并共享聚合后的 result vector。删除它以后，每个 handle 都需要构造自己的轻量 `BatchPlan`，因此必须把 100% identical workload 纳入 benchmark。
+
+这项收益没有形成独立的正确性边界：真正避免重复 slot、master Start 和 payload transfer 的仍是 per-key flight。exact-batch 层为节省重复 plan 工作，引入了第二套 phase、waiter、result cache 和 cleanup 协议。对当前重点覆盖的“前缀大量重叠但 batch 长度或 atomic groups 不完全相同”场景，它又无法命中。
+
+当前参数归属也暴露了这层抽象的歧义：`ExternalGetStartDedupKey` 不包含 `transfer_concurrency`，`ExternalGetStartSharedOp` 却保存第一个 creator 的值。相同 batch 使用不同 `transfer_concurrency` 时，后来的显式参数不会决定共享工作的并发度。per-key sharing 本身也意味着 shared keys 服从各自 leader cohort 的并发策略。这里需要保留一个规范契约：优先把 transfer concurrency 变成 owner / transport 的统一策略；如果仍保留请求参数，文档必须明确它只影响本请求新建的 leader cohort，不能维持未说明的 first-creator-wins 行为。
+
+### 3.4 Revoke 不确定性没有 owner 侧闭环
+
+当 suffix key 无人 retain 时，leader 进入 `Revoking`。`BatchGetRevoke` 成功后，代码才释放精确 prepared target。RPC 返回错误时，当前实现发布 per-key `Failed` 并清除 marker，但没有保存可重试的 `get_id` 和 target，也没有为 owner `Prepared` slot 建立 TTL。
+
+master 的 `InflightGetInfo` 过期后会 Drop `PreparedGetRequesterLease`，所以 master fence 最迟可以重新开放。owner 本地 slot 是否最终返回 `Free`，无法从当前路径证明：释放它所需的精确 target 已经随 terminal op 丢失。更安全的状态应保留 `Revoking { get_id, target, next_retry }`，直到满足下列有限终态之一：
+
+- master 明确确认 Revoke，owner 释放 slot；
+- master 返回 Done 已胜出，owner 按 canonical committed backing 收敛；
+- master operation TTL 明确过期，owner 核对 generation 后释放 slot；
+- owner generation 结束，整个 pool 随进程生命周期销毁。
+
+在终态前清除 per-key marker 会把“master 是否仍在执行”和“owner slot 是否仍被占用”重新变成两个失去关联的状态。
+
+### 3.5 master 防重已经部分完成，收敛语义仍缺失
+
+当前 `PreparedGetRequesterTable` 已正确使用 `(key, requester)` 作为 identity，并通过 `PreparedGetRequesterLease::Drop` 释放。这一部分应保留。
+
+仍需收敛的分支包括：
+
+| 场景 | 当前行为 | 需要的有限结果 |
+| --- | --- | --- |
+| 同 requester 已有 prepared Get | `KeyBeingWritten` | `Join { operation_id, immutable_start_item }`，或明确可重试的 transient 结果 |
+| requester 已有同版本 live replica | `InvalidArgument: cannot replace a live replica` | `AlreadyCommitted`，释放新 slot 后取得 canonical local holder |
+| GetDone 时同版本 route 已被另一个操作发布 | `Unknown: could not publish current route` | `AlreadyCommitted`，输家不覆盖 backing |
+| GetDone 的 `put_id` 已落后 | 依赖通用错误路径 | `Stale`，revoke / release 后重新 probe |
+
+owner singleflight 可以是主要的快速路径，但不能成为唯一能解释冲突的正确性边界。master 已经维护唯一性 fence，下一步应返回可枚举、可测试的结果，避免 owner 从错误字符串猜测状态。
+
+## 4. 修复前控制面与数据面成本
+
+下表只描述当前源码可以确认的成本。最后一列中的性能影响仍需测量。
+
+| 成本维度 | 当前实现事实 | 随什么增长 | 判断 |
+| --- | --- | --- | --- |
+| key 所有权复制 | exact-batch DashMap key 和 `ExternalGetStartSharedOp.dedup_key` 各自拥有完整 key 向量；transfer prefix 又被构造并在 `Running` / task 间复制；每个 per-key op 还拥有自己的 `String` | batch key 数和 key 长度 | 明确存在，可通过删除 exact-batch 层减少；延迟占比待测 |
+| 共享对象 | 每个新 leader key 有一个 `Arc<ExternalGetKeySharedOp>`、`Mutex`、独立 `Arc<Notify>` 和 terminal result；每个 exact batch 再有一套 shared op | leader key 数和并发 batch 数 | 对短 value / 高并发更敏感，实际 allocator 成本待测 |
+| 全局 fence | `owner_key_control` 在同一临界区内先扫描 revoking keys，再逐 key 做 local / join / leader 规划，并穿插 per-key state lock 和索引查询 | required key 数及并发请求数 | 可能形成 p99 lock contention；需要 lock-wait histogram |
+| per-key lock / wakeup | start publish、decision、classification、terminal publish 和每个 waiter 都访问 per-key state；exact-batch 又有第二层 lock / notify | joiner 数和状态变化次数 | 两层 wakeup 没有独立语义，优先删除外层 |
+| task | 非全 local 的 creator 通常生成 `external_get_key_singleflight` 和 `external_get_start_transfer` 两个 task | creator batch 数 | 第二个 task 只聚合 per-key terminal 到 exact-batch terminal，可删除 |
+| waiter future | `finish_external_get_start_transfer` 对 transferable items 建立 `join_all` future；revoke 等待也按 key 建 future | transferable / revoking key 数 | 调度与 wakeup 成本明确，幅度待测 |
+| result materialize | per-key `Ready` 保存结果；聚合 task 再构造 exact-batch `Ready`；每个 handle transfer 再 clone `keys/items` | transferable key 数和相同 batch waiter 数 | exact-batch result cache 造成额外向量与 `Arc` refcount 流量 |
+| payload 提交 | `batch_get_finish_started` 为每个远端 key 调用一次 `transfer_data_no_copy`；每次继续形成独立 closed-runtime transfer request | 远端 hit key 数 | 控制面 RPC 已 batch，transfer 提交尚未在该边界合并 |
+| master batch handler | `BatchGetStart/Done/Revoke` handler 在 master 内逐 item await 单 key handler | leader / terminal key 数 | 网络 RPC 数受控，master 本地调度仍为 O(keys) |
+| suffix speculation | 所有 leader 先 Start，prefix 计算后再按 `retained` 选择 Finish 或 Revoke | raw hit 之后的 leader suffix | 避免 probe RPC，但增加 slot claim、master work 和 revoke；需和 probe/reserve 实测比较 |
+
+当前优先级更高的风险依次是取消后不终止、全局 fence 临界区、双层状态 wakeup 和逐 key transfer submission。key clone 也明确存在，但不应先为它引入新的缓存或兼容层。
+
+## 5. PegaFlow 可以借鉴的设计模式
+
+PegaFlow 对照源码固定在提交 `939363f198a0ffded9e3f30d8af9cdd74439f16c`：
+
+| PegaFlow 模式 | 实现证据 | 对 Fluxon 的启发 |
+| --- | --- | --- |
+| 一次 prefix scan 取得稳定引用 | [`ReadCache::get_prefix_blocks`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/storage/read_cache.rs#L35-L50) 在一个 cache mutex 下按序扫描并 clone `Arc<SealedBlock>` | Fluxon 的 local branch 已在 owner fence 下 clone `MemoryInfo`；让 `BatchPlan` 直接拥有这些 pin 即可，无需再包装 exact-batch state |
+| 一个 ready prefix 对应一个 opaque lease | [`QueryLeaseManager`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/lease.rs#L42-L184) 让 lease 持有整个 `Vec<Arc<SealedBlock>>`，支持 consume、release、consumer count 和 sweep | Fluxon handle 应拥有整批 plan / lease，并在 transfer 或 cancel 时一次消费；进程死亡由 TTL 收口 |
+| request-level prefetch state | [`PrefetchState`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/storage/prefetch.rs#L79-L155) 用一个 `HashMap<req_id, JoinHandle>` 和一个 mutex 管理后台任务 | per-key singleflight 只保留跨请求去重真正需要的状态；请求级聚合不要再复制一套 phase machine |
+| probe 与 commit 分离 | [`vllm-request-state-machine.md`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/docs/vllm-request-state-machine.md#L318-L461) 明确提出 `QueryPrefetch -> ReserveLoadBlocks -> Load -> ReleaseReservation -> TTL` | Fluxon 可用 side-effect-free probe 先确定 prefix，再只 reserve transferable prefix；是否值得多一次 RPC 必须 benchmark |
+| 取消安全的资源 guard | [`TransferLockGuard`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/backing/transfer_lock_guard.rs#L13-L70) 和 [`SsdPrefetchReservation`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/storage/prefetch.rs#L141-L155) 都在 `Drop` 中归还资源 | `undecided`、waiter、slot 和 master operation retry ownership 都应由 guard 表达 |
+| descriptor-first 的批量数据面 | [`transfer`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/transfer/mod.rs#L1-L16) 与 [`gpu_worker`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/src/gpu_worker.rs#L350-L496) 先收集所有 layer / segment descriptor，再交给一次 backend batch 并同步一次 | Fluxon 应统计并减少实际 transfer submission，而不只统计 BatchGet RPC 数 |
+| 路径契约测试和 metrics | [`prefix_semantics`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/tests/prefix_semantics.rs)、[`prefetch_lease`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/pegaflow-core/tests/prefetch_lease.rs) 和 [`test_connector_fault_tolerance`](https://github.com/novitalabs/pegaflow/blob/939363f198a0ffded9e3f30d8af9cdd74439f16c/python/tests/test_connector_fault_tolerance.py) 分别覆盖 prefix、lease consumer、失败与 cleanup | Fluxon 需要把 overlap、取消和资源归零作为 merge gate，纯 prefix helper 不足以覆盖生命周期 |
+
+### 5.1 不应照搬的部分
+
+- **PegaFlow 没有跨请求 per-block singleflight**：active prefetch 按 `req_id` 组织；两个不同请求的重叠 block 仍不共享同一个 per-block future。
+- **当前 probe 仍有副作用**：`QueryPrefetch` 已经 pin ready blocks。PegaFlow 自己的设计文档也把 probe / reserve 分离列为未来协议。
+- **`req_id` 不是完整 identity**：同一请求在 preemption 或调度重试后可能对应不同 hash slice；PegaFlow 文档建议加入 `digest(block_hashes)`。
+- **600 秒 lease TTL 不适合直接复制**：Fluxon prepared local-reserve slot 是稀缺资源，TTL 应由 slot 容量、最大合法 transfer 时长和故障恢复目标决定。
+- **语义边界不同**：PegaFlow 的简单 prefix cache scan 不承担 Fluxon 的 atomic group、master route、owner reclaim fence 和跨 requester 唯一性。
+
+## 6. 建议的收缩设计
+
+### 6.1 第一阶段：handle 直接持有 `BatchPlan`
+
+第一阶段保留现有 per-key shared op，先删除 exact-batch shared op。内部结构可以收敛为：
+
+```rust
+struct ExternalGetBatchPlan {
+    req_node_id: String,
+    keys: Vec<String>,
+    prefix: ExternalGetStartPrefixResult,
+    items: Vec<ExternalGetPlanItem>,
+}
+
+enum ExternalGetPlanItem {
+    Local(Arc<MemoryInfo>),
+    Shared(ExternalGetInterest),
+}
+```
+
+这只是内部设计草图，名称应在实现时与仓库现有命名统一。关键契约是：
+
+- `ExternalGetInterest` 由 RAII guard 表达。创建时注册一次 prefix decision；prefix 计算会把它消费成 abandon 或 plan 持有的 result interest。未决定就 Drop 时自动 abandon；进入 `Finishing` 后的 Drop 只释放 waiter，不回滚已经提交的数据面终态。
+- `external_get_start_registry` 直接持有 `BatchPlan`，不再间接持有 `ExternalGetStartSharedOp`。
+- `get_transfer` 消费 plan 并等待其中的 per-key terminal；`cancel` Drop plan。两个入口共享同一条释放路径。
+- 完全相同的两个 batch 仍会在 per-key registry 中 join 相同 flight，因此不会重复 Start / transfer。
+- leader cohort 的现有后台 task 已经负责 transfer 和 Done。删除 `external_get_start_transfer` 聚合 task 不会失去 start 与 GPU allocation 的重叠，只会删除第二次等待和结果 materialize。
+- handle registry 需要 TTL / generation cleanup。TTL 回调与显式 cancel 必须调用同一个幂等终止函数。
+
+可以删除的重复 surface 包括：
+
+- `ExternalGetStartDedupKey`
+- `ExternalGetStartSharedOp`、`ExternalGetStartSharedState`、`ExternalGetStartSharedPhase`
+- `external_get_start_by_key`
+- `register_external_get_start_waiter`、`release_external_get_start_waiter`
+- `wait_external_get_start_prefix`、`wait_external_get_start_transfer`
+- `publish_external_get_start_ready` 及第二份 batch terminal result
+- `external_get_start_transfer` 聚合 task
+
+`ExternalGetStartSharedItemResult` 此后只属于 per-key terminal，应改成唯一且明确的 `ExternalGetKeyResult`，避免名字继续暗示 exact-batch sharing。
+
+```mermaid
+flowchart LR
+    A[ExternalBatchGetStartReq] --> B[owner fence 下构造 BatchPlan]
+    B --> C[Local<br/>Arc MemoryInfo]
+    B --> D[Join<br/>KeyInterest guard]
+    B --> E[Leader cohort]
+    E --> F[一次 BatchGetStart]
+    F --> G[一个 cohort task<br/>transfer + Done/Revoke]
+    G --> H[per-key terminal]
+    C --> I[handle registry<br/>BatchPlan + TTL]
+    D --> I
+    H --> I
+    I -->|get_transfer| J[消费 plan，安装 holdings]
+    I -->|cancel / TTL| K[幂等 Drop plan]
+```
+
+### 6.2 第二阶段：有数据再折叠成 `BatchFlight`
+
+删除 exact-batch 层后，如果 metrics 证明 per-key `Arc + Mutex + Notify` 仍是热点，可以让同一次扫描产生的 leader keys 共用一个 `BatchFlight`：
+
+- key registry 保存 `(Weak<BatchFlight>, slot_index, generation)`。
+- `BatchFlight` 持有一个 slots 数组、一个 mutex、一个 notify 和一个 cohort task。
+- joiner 只保存 `Arc<BatchFlight> + slot_index + InterestGuard`。
+- 每个 slot 有独立 outcome 和 interest count，但同步原语属于整个 cohort。
+- registry 删除必须同时校验 key、flight identity、slot 和 generation，旧 waiter 的 Drop 不能删除后来创建的 flight。
+
+这一步能把同步对象从 O(leader keys) 降到 O(leader cohorts)，代价是一个 notify 可能唤醒同 cohort 的无关 slot waiter。应先测 per-key 对象和 wakeup 是否真的占主导，再决定是否接受该 trade-off。不要在删除重复层之前再叠加第三套 batch state machine。
+
+### 6.3 master 返回可收敛的有限结果
+
+master 的 prepared Get start 应返回一个可穷举结果集合。下面只描述分支语义，不是当前已存在的 Rust 类型：
+
+```text
+Leader { start_item }
+Join { operation_id, immutable_start_item }
+AlreadyCommitted { put_id, backing_identity }
+Stale
+```
+
+具体 wire 类型需要单独设计，但分支必须保持有限：
+
+- `Leader` 获得本次 prepared target 的唯一提交权。
+- `Join` 返回足够重建原 operation 的 immutable start 信息。owner 仍只能选出一个 transfer executor，其他 waiter 观察同一终态。
+- `AlreadyCommitted` 返回 version 和 backing identity，让 owner 释放候选 slot，并在 reclaim fence 下取得 canonical local holder。
+- `Stale` 终止旧 operation，重新读取当前 route / version。
+
+master fence 的 RAII lease 和 60 秒兜底可以继续保留，但 owner slot 的终止不能只依赖 master cache Drop。
+
+### 6.4 probe / reserve 作为可选协议，不先假设它更快
+
+当前 speculative Start 的优点是少一次网络往返，并能尽早开始远端 materialization；成本是 raw prefix 之后的 key 也 claim slot、进入 master、再走 Revoke，还需要 `undecided/retained/Revoking` 协调多个 batch 的 prefix interest。
+
+可选的两阶段协议为：
+
+1. `BatchGetProbe(keys)`：只返回每个 key 的 local / route 可用性和 version，不占 prepared slot。
+2. owner 按原始顺序和 atomic groups 算出 `transferable_len`。
+3. `BatchGetReserve(keys[..transferable_len], versions)`：全量成功或返回 stale / retry，不留下部分 reservation。
+4. transfer 消费 reservation；cancel / failure / TTL 释放 reservation。
+
+该协议能删除大部分 suffix revoke 和 decision accounting，但多一次 RPC，并引入 probe 与 reserve 之间的 eviction / version race。正确处理方式是 reserve 时原子复核，把 race 降级为 cache miss / retry。是否采用，应比较：
+
+- 当前 speculative Start + suffix Revoke；
+- probe + reserve；
+- 不同 batch 长度、miss 位置、overlap ratio 和 RTT 下的端到端结果。
+
+### 6.5 保留 batch 语义，并把 batch 延伸到 transfer submission
+
+无论控制面采用 per-key op 还是 `BatchFlight`，都应维持：
+
+1. owner 以逐 key/shard 短 fence 完成 required batch 的 local / join / leader 分类；不得用
+   process-wide lock 取得整批快照，也不得让任何同步锁跨 `.await`；
+2. leader keys 压缩成一次 `BatchGetStart`；
+3. terminal 使用一次 `BatchGetDone` 或 `BatchGetRevoke` 收敛；
+4. 结果按原 index scatter，再计算 raw prefix 和 atomic-group prefix；
+5. payload descriptor 先按 peer、方向和 transport 能力分组，再调用 batch transfer surface。
+
+PegaFlow 的 descriptor-first 做法适合借鉴到第 5 步。Fluxon 至少应新增 `transfer_submissions`、`descriptors_per_submission` 和 `bytes_per_submission`，先确认当前每 key 调用是否真的成为瓶颈，再设计 batch transfer API。
+
+## 7. 迁移顺序
+
+| 阶段 | 改动 | 完成判据 |
+| --- | --- | --- |
+| P0 生命周期 | 引入 decision / waiter / prepared operation guard；统一显式 cancel、future Drop、TTL cleanup；保留 revoke retry identity | fault injection 取消任一 await 后，active handle、interest、marker 和 prepared slot 都回到基线 |
+| P1 删除重复层 | handle 改持 `BatchPlan`；删除 exact-batch map、phase、notify、waiter 和聚合 task | identical / overlapping batch 的 leader Start 数不增加；公开 API 不变 |
+| P2 master 收敛 | wire 层增加有限 outcome；owner 实现 join、already-committed 和 stale 分支 | 同 requester 冲突不再暴露通用 `KeyBeingWritten` / `InvalidArgument` / `Unknown` |
+| P3 数据驱动优化 | 测量并选择 `BatchFlight`、probe/reserve、batch transfer submission | 每个新增机制都有对应热点证据和独立回退对照 |
+
+截至 2026-07-17，P0 的 Interest/planning leader/prepared-slot guard、P1 exact-batch 删除、
+P2 的 `(key, requester)` fence 与 overlap/ABA 防线已进入当前工作树并通过定向单元测试；
+P2 的完整有限 outcome 仍需故障注入确认。P3 的
+payload descriptor batch 仍未实现，必须由部署后的 submission metrics/QPS 决定，不能仅凭
+静态结构继续加层。
+
+P0 与 P1 可以先在现有 per-key 实现上完成。不要为了等待理想的 `BatchFlight` 一次性重写而继续保留已知的取消缺口。
+
+## 8. 测试、观测与验收门槛
+
+### 8.1 必须补齐的测试
+
+最新更新已经增加三类有价值的 unit test：两个非完全相同 batch 复用同一 per-key marker、旧 marker cleanup 不删除新 generation，以及 master `(key, requester)` fence 的同 owner / 跨 owner 与 ABA 行为。它们验证了同步注册和 identity 规则，但没有启动真实 RPC / transfer / cancel 生命周期。下列测试仍需直接运行 async 流程，显式检查 exit code / timeout 和资源终态：
+
+| 场景 | 必须断言 |
+| --- | --- |
+| overlap：`[a,b,c]` 与 `[b,c,d]` | `b/c` 对同 owner 各只有一个 leader Start 和一份 committed backing；两个 batch 各自 prefix 正确 |
+| identical batch | 删除 exact-batch 层后仍只产生一组 per-key leader；两个 handle 可独立 transfer / cancel |
+| duplicate key：`[a,a,b]` | `a` 只有一个 flight；两个原 index 都得到一致结果；interest 不下溢或泄漏 |
+| atomic-group suffix | group 不被切开；suffix local pin、join interest 和 leader prepared slot 全部释放 |
+| task cancellation matrix | 在注册 decision、Start 前后、等待 prefix、等待 result、handle remove 后逐点 abort；后续同 key 请求可在 deadline 内完成 |
+| Revoke 响应丢失 | owner 保留 retry identity；master TTL / terminal query 后 slot 最终回到 `Free`，不会直接清 marker 丢状态 |
+| Done / Revoke race | 只有一个终态释放资源；Done 胜出时 Revoke 不释放 committed slot |
+| reclaim race | Local、Starting、Finishing、Revoking 和 terminal 各阶段与 reclaim 并发，不出现地址复用或永久 `Busy` |
+| master requester fence | 同 requester 第二个 Get 返回 join / already；不同 requester 可以同时成为 leader |
+| stale version | 旧 `put_id` 不覆盖新 route；候选 slot 被回收并重新 probe |
+| owner / external generation change | 旧 handle、旧 flight 和旧 cleanup 不能删除或消费新 generation 状态 |
+
+### 8.2 必须暴露的路径 metrics
+
+| 类别 | 指标 |
+| --- | --- |
+| 分类 | `required_keys`、`local_pinned`、`inflight_joined`、`leader_started`、`duplicate_indices` |
+| 去重收益 | `get_start_avoided`、`transfer_avoided`、`identical_batch_joined` |
+| 生命周期 | active handles / flights / interests / prepared slots、各自 age、cancel / TTL / Drop cleanup 次数 |
+| suffix | local pin drop、join interest drop、leader revoke、revoke retry、revoke unknown |
+| master 收敛 | leader、join、already-committed、stale、TTL expired，按结果分别计数 |
+| 等待与锁 | owner fence wait / hold、join wait、flight lifetime 的 histogram |
+| 数据面 | BatchGet RPC items、transfer submissions、descriptors / bytes per submission、Done / Revoke batch size |
+
+所有 gauge 都必须能在 workload 结束后的有界时间内回到基线。只增加累计 counter 无法发现永久挂住的 handle、interest 或 prepared slot。
+
+### 8.3 benchmark 矩阵
+
+至少比较三个实现：变更前的 batch path、当前双层 shared-op path、删除 exact-batch 层后的 `BatchPlan` path。输入矩阵应覆盖：
+
+- key 数：`1 / 16 / 64 / 256`；
+- overlap ratio：`0% / 50% / 90% / 100%`；
+- first miss：首部、中部、尾部和 all-hit；
+- 并发：单请求、同 owner 多请求、多个 requester owner；
+- value / page 大小：控制面占主导的小 value，以及数据面占主导的实际 KV page；
+- local / same-host / remote transport；
+- fault-free、cancel storm 和 Revoke 响应延迟 / 丢失。
+
+采集 `get_start` p50 / p99、完整 transfer p50 / p99、CPU、allocation bytes / count、task spawn、lock wait、RPC items、transfer submission 和最终 slot / handle gauge。验收时先检查语义计数和资源归零，再比较延迟；最终 QPS 只能作为补充结果。
+
+## 9. Fluxon 证据索引
+
+| 事实 | 当前代码位置 |
+| --- | --- |
+| per-key flight 与 request plan 类型 | `fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs`：`ExternalGetKeySharedOp`、`ExternalGetKeyInterest`、`ExternalGetStartEntry` |
+| per-key 规划和 RAII decision | `fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs`：`plan_external_get_key_items`、`ExternalGetKeyInterest::decide/Drop` |
+| leader finish / revoke | 同文件：`classify_external_get_key_leader`、`finish_external_get_key_leaders` |
+| request plan handle（无 exact-batch shared-op） | 同文件：`external_batch_get_start`、`finish_external_get_start_transfer`、`external_batch_get_transfer` |
+| per-key payload transfer submission | `fluxon_rs/fluxon_kv/src/client_kv_api/get.rs`：`batch_get_finish_started` |
+| transfer closed-runtime 边界 | `fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs`：`transfer_data_no_copy` |
+| external Get 与 reclaim fence | `fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs`：`prepare_one` |
+| master requester fence 与 TTL | `fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs`：`PreparedGetRequesterTable`、`PreparedGetRequesterLease`、`inflight_gets` |
+| master 冲突和 batch handler | `fluxon_rs/fluxon_kv/src/master_kv_router/get.rs`：`handle_get_start`、`handle_get_done`、`handle_batch_get_start` |
+| 已有 overlap / ABA unit tests | `external_get_start_batch_tests::overlapping_nonidentical_batches_share_each_key_but_keep_leaders_batched`、`old_singleflight_cleanup_cannot_remove_new_generation`、`prepared_get_singleflight_is_same_owner_only_and_aba_safe` |
+| 原设计要求 | `fluxon_doc_cn/design/sglang_fluxon_kv集成设计.md`：`Batch Get 的逐 key 交集、pin 与 singleflight` |
+
+## 10. 决策记录
+
+- **接受** owner 侧 per-key overlap 去重和 master 侧 `(key, requester)` 防御性唯一性。
+- **接受** BatchGetStart / transfer / Done 在数据流上的 cohort 概念。
+- **拒绝** exact-batch shared op 与 per-key shared op 长期并存。
+- **拒绝** 用 bool 和手工 counter 表达跨 `.await` 的资源所有权。
+- **暂缓** `BatchFlight` 和 probe/reserve 协议，直到 P0 / P1 完成且 metrics 指向对应热点。
+- **要求** 在把该路径视为完成前，补齐取消、overlap、Revoke 不确定性、reclaim race、master 收敛测试和资源归零观测。
+
+## 11. 2026-07-16 实现跟进
+
+本分析提出的 P0/P1 已进入工作区实现：
+
+- 删除 `ExternalGetStartDedupKey`、`ExternalGetStartSharedOp`、
+  `external_get_start_by_key`、request-level waiter/phase/result cache 和
+  `external_get_start_transfer` 聚合 task；handle 直接拥有自己的 keys/items plan。
+- `ExternalGetKeyInterest` 以 RAII 表达 prefix decision；未决定的 request future 被取消时，
+  Drop 自动减少 `undecided`。leader cohort 在第一个 master RPC await 前交给注册后台 task，
+  因而请求取消不会丢失 Start/Finish/Revoke executor。
+- prepared slot claim 使用 Drop cleanup guard；明确接受的 slots 才逐项 disarm。external
+  handle 增加 360 秒 TTL 和统一 Drop 回收，覆盖当前对齐 workload 的 300 秒合法请求窗口。
+- `Revoking` 保存完整 start item；BatchGetRevoke 的 transport、响应长度和 identity 不确定性
+  保留 marker/slot 并重试，只有明确 Revoke 成功才释放 target。transfer/install 失败的
+  cleanup 也在独立注册 task 中持有 get ids 和 targets，调用方取消不再丢失清理 ownership。
+- overlap/ABA 测试之外新增了 pending Interest Drop 和真实 task abort 测试；当前仍需用真实 RPC
+  fault injection 覆盖 Done response 丢失、owner generation 切换和完整 transfer cancellation matrix。
+- BatchGetDone 不再固定重试三次后遗留 pending-visible slot，而是使用同一组 get ids 幂等重试，
+  严格校验响应长度和逐项 identity，直到明确终态或 owner shutdown。BatchGetStart 没有响应的
+  未知提交点会将 prepared slots 隔离 65 秒，覆盖 master 60 秒 inflight TTL；已知 get ids 的
+  异常响应则移交独立 Revoke cleanup。
+- owner 周期快照增加 active handle、per-key flight 阶段、undecided/retained interest 和
+  Free/Prepared/Pending/Committed local-reserve slot 计数，用于三机 workload 后资源归零验收。
+
+这次跟进没有宣称 payload 已成为单次底层 DMA batch。控制面 cohort 仍是一次
+BatchGetStart/Done/Revoke，但 `transfer_data_no_copy` 的 descriptor-first 合并仍属于后续 P3，
+必须由 submission metrics 和 benchmark 决定接口形态。
+
+2026-07-17 使用宝宝盘 `CARGO_TARGET_DIR` 和单并发构建做了最新工作树回归。
+Clippy 在仅放行仓库既有 `uninit_vec` 的前提下强制
+`-D clippy::await_holding_lock` 通过；master-router、owner-hot、local-reserve、
+member-left 和 `test_memholder_pin` 分别为 `28/28`、`9/9`、`8/8`、`5/5`、`1/1`。
+`fluxon_kv --lib` 全量为 `176 passed, 0 failed`，旧的 `test_memholder_pin` 失败已不再复现。
+上述结果不替代真实 RPC fault injection 和三机生命周期验证；尤其仍需主动丢弃
+Start/Done/Revoke 响应并检查快照临时态回到基线。
diff --git "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md" "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
index 475adab..9c38aa5 100644
--- "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
+++ "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
@@ -27,6 +27,50 @@
   - 因果链：SGLang KVCache restore 不是普通逐 key `get`，而是面向一批有序 page keys 的 prefix restore。它需要一次性回答“这一批最多恢复到哪里”，并且不能切开一个 radix node 对应的 atomic group。batch 化还能减少逐 key 调用、查表、锁和跨边界调度开销。
   - 本设计落点：Fluxon hostless get 以 batch 为单位计算 `raw_prefix_hit_len`、`transferable_len` 和 `prefix_hit_groups`。`get_start` 合并存在性 / prefix 判断和可恢复前缀的数据拉取启动，返回 handle 和 prefix；`get_transfer` 再消费 handle，把可恢复前缀转换成 readable `plan_ptr(value_ptrs)`。
 
+### 关键设计倾向与强制规约
+
+本文使用 `MUST`、`MUST NOT`、`SHOULD` 和 `MAY` 区分正确性规约与性能倾向：
+
+- `MUST / MUST NOT` 是内存、版本、可见性或批量语义的硬不变量；即使某个实现能得到更高
+  QPS，违反它也不得验收。
+- `SHOULD` 是默认性能方向；偏离时必须给出可重复的对照实验和没有破坏硬不变量的证据。
+- `MAY` 表示在不改变外部契约时可替换的内部策略。
+
+设计取舍的优先级固定为：首先保证 backing/version/holder 正确性，其次保证本地快路径
+不被全局控制面阻塞，再次保证 batch/atomic/TP 语义，最后才是单轮命中率或 QPS。
+关键规约如下：
+
+| ID | 级别 | 规约 | 验收含义 |
+| --- | --- | --- | --- |
+| V1 | MUST | native write 和 stream 可见性完成后，Put slot 必须立即进入 `local-read-ready` / `precommit_local_visible_info`。同 owner local read 不等待 master PutDone。 | 在人为延迟 master RPC 时，同 owner Get 仍能命中并取得 holder。 |
+| V2 | MUST NOT | `local-read-ready` 不得被解释为 global committed。master route 成功前，其它 owner 不得通过全局 route 观察该 value。 | local 与 remote 可见性分别故障注入，不出现未完成 route 的跨 owner 读。 |
+| V3 | MUST | `Committed(route_live=true)` 和 owner-hot admission 必须等 master route/maintenance 成功；这个门禁不得反向阻塞 V1 的 local read。 | hot Moka 中每个条目都可与相同 `put_id + backing identity` 的 live route 对账。 |
+| G1 | MUST | required batch `R` 必须与可 pin 的 local-visible `L` 和可共享 inflight Get `F` 完整分流：`LocalJoin=R∩L`、`InflightJoin=R∩F`、`Leader=R-(L∪F)`。每个 key 独立线性化，不要求用一把锁取得整批快照。 | 重叠但不完全相同的 batch 不会对共享 key 重复申请 slot 或传输，同时大 batch 不会阻塞无关 key。 |
+| G2 | MUST | 任何 leader GetStart/payload transfer 之前，`LocalJoin` 必须已持有 `MemoryInfo` holder pin，`InflightJoin` 必须已持有 shared-op waiter/pin，`Leader` 必须已原子安装 marker。 | pin 与 hot demotion/reclaim 并发时，kernel 看到的地址不会提前回收或复用。 |
+| G3 | MUST NOT | 不得用“snapshot inflight set，稍后批量 insert”实现与非；必须逐 key 使用原子 entry/CAS 确定 leader 和 joiner。 | 并发两批均只有一个 leader，registry 清理不发生 ABA 删新操作。 |
+| G4 | MUST | leader 子集的压缩响应必须先按原 index 重组成与 `R` 等长结果，然后才能按原 `atomic_group_lens` 计算 `raw_prefix_hit_len/transferable_len`。 | 不会因压缩 leader 而改变 prefix 顺序，也不恢复半个 radix node。 |
+| G5 | MUST | `transferable_len` 之后的 local pin、join waiter 和 leader prepared Get 必须立即释放/revoke；不得保留到 TTL。 | suffix holder、master inflight 和 prepared slots 在每轮结束后可精确对账归零。 |
+| G6 | MUST | owner 侧按 key singleflight；master 侧的防御性唯一性粒度为 `(key, requester_owner)`，不是全局 key。 | 同 owner 不重复 materialize；不同 GPU owner 仍可同时拉取同一 key。 |
+| G7 | MUST | per-key shared Get 必须至少有 `Starting/Started/Ready/Failed-or-Revoked` 阶段，所有 waiter 观察同一终态并共享同一 canonical `MemoryInfo`。 | 重叠 batch 测试中 master GetStart、DMA 和 committed local route 均只出现一份。 |
+| G8 | MUST / SHOULD | per-key singleflight 只是 leader/joiner 的线性化粒度，不得把控制面降级为逐 key RPC。同一 required batch 的 leader 必须压缩成一次 BatchGetStart，GetDone/Revoke 也必须批量收敛（MUST）。payload 当前仍逐 key调用 `transfer_data_no_copy`；应按 peer/transport 汇总 descriptor 后批量提交，或至少在有界 time-window 内并行聚合（SHOULD，尚未实现）。 | Start/Done/Revoke 次数按 batch 而不是 leader key 数增长；另外单独统计 payload submission，未实现 descriptor batch 前不得宣称数据面已完全 batch 化。 |
+| G9 | SHOULD | 同时到达的多个 required batches 中，已经判定为 leader 且具有兼容 value geometry/transport 的 keys 应进入短 time-window micro-batch；窗口必须有界，不能为凑 batch 无界延迟 local hit 或 prefix 响应。 | 同时并发压力下 batch size 提升，但 p50/p90 GetStart 不因等待窗口显著恶化。 |
+| G10 | MUST NOT | owner Get 规划、hot pin 和 runtime metrics 不得持 process-wide key-control mutex 遍历 batch/cohort；key-control 只能是短 O(1) 的逐 key/shard 临界区，禁止跨 `.await`、RPC、RDMA。规划取消必须用 RAII 清理尚未 BatchGetStart 的 leader marker。 | 大 batch 与无关 key 并发前进；取消任一 await 后没有永久 `Starting` marker、undecided 或 prepared slot。 |
+| A1 | MUST | atomic group/TP cohort 可以逐项 local-ready，但只有完整 group 才能对 restore 发布命中；同一 cohort 先全部 promotion，再统一 owner-hot admission。 | 任一 rank/member 失败时不暴露半组 GPU KV 状态，首个成员不会提前 hot eviction。 |
+| A2 | MUST | local-first Put 的同一 batch 必须由一个 publish job 持有全部 reservation/pending fence；PutDone 不确定或部分 promotion 时只用同一 identity 整批 roll-forward。声明不完整的 atomic group 禁止退化为逐 key 发布。 | 注入丢响应、取消和局部 promotion 后，所有成员最终一致发布，且不存在半组 hot admission 或提前释放 slot。 |
+| S1 | MUST | KV 驱逐和复用单位是单个 slot/key/version；`512 MiB` grant 只是物理容器，不是驱逐、恢复或等待单位。 | 一个 grant 中部分冷 slot 可独立降级、回收并被后续 Put/Get 复用。 |
+| S2 | MUST | slot 只有在 `route_live == false && holder_ref_count == 0` 时才能回到 Free；route 释放和 holder 释放的任意先后顺序都不得提前复用。 | 故障注入覆盖 route-first/holder-first，不出现 use-after-free 或重复 free-list entry。 |
+| S3 | MUST | owner 容量驱逐与 remote replica 解耦。owner 提交完整、精确的 atomic/TP source cohort；master 只验证并删除该 owner source，不选择 victim，也不要求 CPU route 已存在。最后一份 cache route 允许删除，后续正常 miss/recompute。 | 有 CPU 时只删 GPU source；无 CPU 时 route 消失；remote write 失败只损失后续命中率，不否决 owner 回收。 |
+| S4 | MUST | Moka 已发出的 size eviction 必须进入有界、可重试的 exact source-eviction ownership。cohort 元数据暂不完整时保留同一 selected identity 重试，不能静默丢弃、降级成单 key 删除或重新进入 append。 | `size_evictions` 可与 selected/handoff/committed/restored/obsolete/retry 对账；只有物理 Free 或安全恢复 hot 才结清 selected debt。 |
+| S5 | MUST NOT | `evict_some`、hot ratio、slot 循环或 grant shrink 不得修改 owner 配置容量。GPU0/GPU1/CPU 实验容量仍为 `128/128/256 GiB`。 | 调优前后 `contribute_to_cluster_pool_size`、Moka max capacity 和 expected-grant 契约可对账。 |
+| T1 | MUST | Put/Get/replica/demotion 的结果不确定时必须使用同一 operation ID 重试幂等终态，不得猜测失败并释放可能已发布的 backing。 | 响应丢失/重放后 route、holder、slot 和 quota token 都只提交或归还一次。 |
+| T2 | MUST | 相同 `put_id` 的 live-local/GetDone 竞争是可收敛状态，不得作为 `InvalidArgument/Unknown` 永久失败；输家释放新 slot 并复用 canonical holder。不同 `put_id` 才是 stale。 | `cannot replace a live replica` / `could not publish current route` 从可见错误归零，且不会覆盖当前 backing。 |
+| P1 | SHOULD | local hit 和 local-ready Put 快路径不同步等待 master/RDMA；跨边界工作按 batch/time-window 合并，避免逐 key `start-transfer-end`。 | 进行 master/RDMA 延迟注入时 local-only 路径延迟和 QPS 不应同比例恶化。 |
+| P2 | MUST | 实验必须同时记录 QPS、L1/L2/L3/总命中、local/inflight/leader 分流、CPU source Get、replica/demotion、slot free/used 与业务错误。 | 不得只使用 QPS 或逻辑 admission 声称容量收益、去重或 CPU 已生效。 |
+| P3 | MUST | 与 Mooncake 的容量对齐按“进程内 HiCache L2 + 外部 storage”总和计算；GPU 侧 external segment 必须扣除 L2，CPU 无 L2 保留完整 256 GiB。 | 两方总容量均为精确 512 GiB，开跑前 allocated=0，不用重复计入 L2 的基线做对比。 |
+
+上述规约是后续代码、并发测试和三机压测的验收清单。历史兼容路径可以保留，但不得
+以 fallback 名义跳过 V1/G2/G4/S2/T1 这些正确性门禁。
+
 ### Mooncake 对齐实验给出的性能约束
 
 2026-07-12 的三机对齐实验使用两台 TP=2 GPU 节点和一台纯 CPU 节点，标称容量均为
@@ -70,7 +114,7 @@ E15 的 4,718,592-byte value 被旧 slot class 扩成 8 MiB，payload 利用率
   - 主要落点：plan blob ABI、`value_ptrs[]`、`local_fast_put_start/local_fast_put_commit`、`get_start/get_transfer`、SGLang `write_*_to_fluxon_values` / `restore_*_from_fluxon_values`。
 - **对应 KV Cache 适合 write-back 最终一致性**
   - 实现思路：KV Cache 的不可变、可丢失语义天然对应 Fluxon 的 master / owner / external 三层架构。master 管全局 route 和最终可见性，owner 管本机共享内存和 holder 生命周期，external 是 SGLang worker 的热路径接入层。
-    - Put：native write 完成后先更新 external / owner 本地可见索引并返回 `KvFuture`，后台再推进 master route commit。`KvFuture` 成功前只表示本机 write-back 进入提交流程；失败时清理本地在途状态，退化为后续 cache miss。
+    - Put：native write 完成后先更新 external / owner 本地可见索引并返回 `KvFuture`，后台再推进 master route commit。`KvFuture` 成功前只表示本机 write-back 进入提交流程；响应不确定或可能已发布时必须保留 local-visible/fence 并以同一 identity 整批 roll-forward。只有明确证明 master 从未发布且操作已经终止的 abort 才能清理本地在途状态并退化为后续 cache miss。
     - Get / restore：优先查询 external / owner 本地热路径；本地 miss 时再进入远端 prefetch 和 restore。读取只 materialize 连续安全前缀，失败时 rollback 或按 miss 继续。
   - 主要落点：master route、owner shared segment、external local visible index、`KvFuture`、`get_start/get_transfer/release_views`。
 - **对应适配 SGLang KVCache 特化接口**
@@ -252,7 +296,7 @@ blob[11] = value_ptr_9
 
 hostless backup 的核心约束是：Fluxon 负责 GPU KV cache 之下的本机/远端 KV 层的地址分配、route 提交和生命周期管理，但真正的 KV bytes 由 SGLang native kernel 从 GPU KV cache 写入。因此 Fluxon 不能在收到 key 后立刻发布 KV route；它必须先完成 key reservation、put id 分配和 owner-local reserve slot claim，把稳定可写的 `value_ptrs[]` 通过 `plan_ptr` 返回给 SGLang。SGLang native kernel 写完这些地址后，`local_fast_put_commit` 才能把这些 slots 提交为 resident values，并发布 Fluxon KV route。
 
-这条 backup 路径按 write-back 最终一致性设计：native write 完成后先进入本地可见和后台 commit 流程，跨 worker / 跨节点可见性以 `KvFuture` 成功为准。提交失败不会破坏推理语义，只会让对应 page 失去 shared backing；上层清理 `storage_*` 状态后按 cache miss 处理。
+这条 backup 路径按 write-back 最终一致性设计：native write 完成后先进入本地可见和后台 commit 流程，跨 worker / 跨节点可见性以 `KvFuture` 成功为准。`KvFuture` 返回失败时，上层不得把 page 标成全局 `storage_backed`，后续可按 cache miss 处理；但 Fluxon 内部若处于响应不确定或可能已发布状态，仍必须保留 local-visible/fence 并以同一 identity roll-forward，不能把“上层不采用”误解为可以立即释放 backing。
 
 ### 本地主副本与异步副本控制
 
@@ -319,15 +363,15 @@ Free
 | slot 上限 | `slot_size <= 512 MiB` |
 | refill 触发 | 当前 slot class free slots 不足时登记 pending demand 并唤醒 rebalance actor。 |
 | 预期容量预热 | owner 可配置 `owner_local_reserve_expected_capacity: {value_len, payload_capacity_bytes}`。启动时按 grant 内真实可用 slots 计算并申请所需 grants；SGLang 启动脚本必须等预热完成。 |
-| shrink 下限 | 配置预期容量后，rebalance 不把该 slot class 缩到 `expected_grants` 以下；业务瞬时 pending demand 仍可临时增加 grant。它不是物理上限。 |
-| 默认等待 | soft wait `10 ms`，hard timeout `10 s`。hard timeout 保护一次 refill/reclaim 事务，不用于掩盖 master 调度饥饿。 |
+| expected capacity | 配置预期容量后，`expected_grant_count` 同时是预热目标和物理 grant 硬上限；业务压力只能触发 owner writeback/reclaim，不能把 owner 容量扩到该上限之外。只有未配置 expected capacity 的动态模式可继续按 demand 申请 grant。 |
+| 默认等待 | soft wait `10 ms`，hard timeout `30 s`。hard timeout 覆盖一次有界 replica/reclaim 背压事务，不用于掩盖 master 调度饥饿，也不替代 terminal/pending 对账。 |
 | shrink 单位 | 整个 grant；不做 live grant compaction。 |
 | Moka 计费权重 | committed slot 使用 4 KiB 对齐后的实际 `slot_size`，而不是原始 `value_len`；容量驱逐因此对应真实内存占用。 |
-| Moka 容量水位 | master `replica_cache_capacity_ratio`，合法范围 `(0, 1]`，默认 `0.95`；它只决定常规冷条目选择水位，不改变 owner segment 配置容量。 |
-| 常规容量驱逐 | Moka 到达配置容量后选择冷条目，并通过 eviction listener 进入安全回收流程。Moka 只负责选择候选，不直接释放 owner backing。 |
-| 物理 NoSpace 兜底 | refill 申请不到 `512 MiB` grant 时，按 `slot_size * required_free_slots` 计算目标权重，扣除已经在途的回收权重后调用 `evict_some(additional_weight)`；随后按 route 扫描可安全释放的 slots。 |
+| Moka 容量水位 | owner `replica_writeback_hot_capacity_ratio` 控制 local hot/writeback 窗口；master `replica_cache_capacity_ratio` 只约束 `Allocation && !owner_local_indexed && lease_id.is_none()` 域。两者都不改变 owner segment 或 expected grants。 |
+| 常规容量驱逐 | owner hot Moka 的 Size 事件只转移“写回任务 ownership”，不直接释放 backing；master 的环 B Moka Size 事件进入 unindexed Allocation reclaim。两个环分别闭合。 |
+| 物理 NoSpace 兜底 | owner pressure actor 根据 free-slot 缺口减去 selection debt，只在这一处调用无谓词 `evict_some`（单次 ≤256 MiB、≥200 ms 间隔）启动 writeback。旧 route 全表扫描已删除；remote write 失败不进入 master drop/reclaim。 |
 | 容量不变量 | `evict_some` 只驱逐一部分条目，不修改 Moka `max_capacity`，也不修改 owner 配置容量。 |
-| route 维护反压 | route 发布后的 prefix-index/Moka 更新进入容量 512 的有界队列，由单 actor 每批最多处理 512 项；队列满时 `put_done` 等待，避免 metadata/Moka 水位落后于 owner 物理分配并饿死 reserve RPC。 |
+| route 维护反压 | route 发布后的 prefix-index/Moka 更新使用既有有界 actor；队列满时 `put_done` 等待，避免 metadata/Moka 水位落后于物理分配。它不负责 owner slot-pressure victim 扫描。 |
 
 Qwen3-VL-8B、TP=2、page size 64 的单 rank K/V value 是 4,718,592 bytes，正好是
 4 KiB 的整数倍。exact-fit 后一个 512 MiB grant 可以提供 113 个 slots；旧的
@@ -517,6 +561,133 @@ sequenceDiagram
 - `InlineLocal` holding 从 owner 返回 start response 前已经安装；`get_transfer` 把它移交给 returned plan，`cancel_get_transfer` 则携带 holding IDs 精确释放。owner 重启或 generation 不匹配时不能继续使用旧 inline plan。
 - `get_start` 只命中部分前缀时，SGLang 只能恢复 `transferable_len` 覆盖的完整 atomic groups，不能构造半个 atomic group 的 GPU KV 状态。
 - `get_transfer` 返回 miss / KeyNotFound 时，SGLang 必须放弃本次 restore 并执行 rollback。
+- owner 必须为未被 `get_transfer/cancel_get_transfer` 消费的 handle 设置有界 TTL；TTL 回收与
+  显式 cancel 走同一条 plan Drop 路径，不能永久 pin local holder 或 per-key result。
+
+### Batch Get 的逐 key 交集、pin 与 singleflight
+
+hostless restore 的 batch 通常不会完全相同。多个会话或同一会话的不同轮次会共享
+大量前缀 page keys，但各自的 batch 长度、后缀和 `atomic_group_lens` 不同。因此以
+`keys + atomic_group_lens + prefix_best_effort` 整个结构作为去重 key，只能合并完全相同的
+batch；它不能阻止两个重叠 batch 对同一 page 重复申请 prepared slot、重复发起 Get
+和重复 DMA。
+
+读路径必须在 owner 侧按单 key 分流，同时保留原 batch 的顺序和 group 边界。对一个有序
+required batch `R`，定义：
+
+```text
+L = 通过 owner reclaim fence 后可以立即取得 holder 的 local-visible keys
+F = 当前 owner 上已有可共享 Get 操作的 inflight keys
+
+LocalJoin    = R ∩ L
+InflightJoin = R ∩ F
+Leader       = R - (L ∪ F)
+```
+
+这里的“逐 key”只指 singleflight registry 的判定和线性化粒度，不指 RPC 粒度。
+owner 逐 key 完成 `R` 的完整分流后，必须把全部 `Leader` 按原 index 压缩成
+`leader_keys[] + prepared_targets[] + original_indices[]`，通过一次 BatchGetStart 发布；全部终态
+使用 BatchGetDone/Revoke 收敛，最后才按 `original_indices[]` scatter 回 `R`。当前 payload
+backend 仍对每个 key 调用一次 `transfer_data_no_copy`，因此只能表述为“控制面已 batch、数据面
+descriptor batch 待实现”，不能表述成已按 peer/transport 成批提交。后续应直接按 peer/transport
+汇总 descriptor，或使用有界 time-window 聚合兼容传输；不得为了 per-key future 在循环中逐个
+执行完整的 `GetStart -> transfer -> GetDone`。
+
+`L` 只包含能在当前 owner generation 内取得稳定 `MemoryInfo` 的
+`precommit_local_visible_info` 和 `get_cached_info`。只有 master route、只有
+`local_snapshot_info`、已进入 reclaim fence，或只存在 hidden pending 但还没有可共享
+future 的 key，都不得当作 local hit。`pending_local_get_info` 属于 `F` 的生命周期，
+不应通过把未发布 bytes 提前放入 `L` 来规避竞争。
+
+一次 batch 的必须时序如下：
+
+1. owner 使用 256-shard key-control table 逐 key选择 local / join / leader；每次只持一个
+   key 所属 shard 的短临界区，禁止持锁遍历 `R`，也禁止任何锁跨 `.await`。
+2. `LocalJoin` 在离开该 key fence 前 clone 对应的 `Arc<MemoryInfo>`，以 resident holder 引用 pin
+   住 backing。即使 route 随后被 hot demotion，该 slot 也要等本次 holder 释放后才能
+   变成 Free。
+3. `InflightJoin` 在离开 registry 前取得逐 key `Interest` guard；该 guard 必须能观察
+   同一个终态，不得另外申请 slot 或发起 DMA。prefix decision 由 guard 的所有权表达，
+   request future 在任一 `.await` 被取消时，`Drop` 必须自动归还 `undecided`，不得依赖
+   `decision_registered: bool` 和尾部手工减计数。
+4. `Leader` 使用逐 key 原子 entry 操作先安装 shared op，再加入本轮压缩后的
+   master BatchGetStart。不能先对 inflight set 做一次普通 snapshot，稍后再批量
+   insert；否则两个 batch 仍可以同时观察到空集并都成为 leader。
+   若规划在 BatchGetStart handoff 前取消，`ExternalGetPlanningLeadersGuard` 必须把本轮新建且
+   仍为 `Starting` 的 op 发布为安全 miss、按 Arc identity 清 marker 并唤醒 joiner；此时尚无
+   prepared target/master operation，所以不得发 Revoke，也不得留下孤儿 marker。
+5. 只有 `LocalJoin` 和 `InflightJoin` 已经取得 pin，且所有 `Leader` 都已发布
+   inflight marker 后，才能对 leader 子集发起 master GetStart 和后续 payload transfer。
+6. leader 的压缩响应必须按原 index 放回与 `R` 等长的 result slots，local、joiner
+   和 leader 的状态全部拼回后，才可计算 `raw_prefix_hit_len`。不得在压缩后的
+   leader 列表上计算 prefix。
+7. `transferable_len` 仍使用原始 `atomic_group_lens` 向下收敛。一个 group 可以同时
+   包含 local、joiner 和 leader，但只有所有成员均可读时才能对上层发布完整命中。
+8. 超出 `transferable_len` 的后缀必须立即释放 local pin、减少 inflight waiter，并对
+   已 start 的 leader 执行 revoke。未发布的 prepared slot 必须返回 Free，不能因为该
+   key 不在连续前缀内就保留到 TTL。
+9. 保留前缀的 local holder、joined future 和 leader future 一直存活到 `get_transfer`
+   成功移交给 readable plan，或 `cancel_get_transfer` 明确取消。
+
+请求级不得再叠加 exact-batch shared-op 状态机。每个 external handle 直接持有自己的
+`BatchPlan(keys + Local/Interest items)`；完全相同和部分重叠的 batch 都自然在 per-key
+registry 合流。leader 子集在进入第一个网络 `.await` 前移交给一个注册到 owner task
+registry 的 cohort task，该 task 独立完成 `BatchGetStart -> transfer -> BatchGetDone/Revoke`。
+因此 external Start RPC 被取消只会 Drop 本请求的 Interest，不会让已经安装的 leader 失去
+executor。该收缩同时删除 request 级的第二套 phase/Mutex/Notify、waiter_count、完整 key
+向量结果缓存和纯聚合后台 task，但不改变公开的 start/transfer/cancel API。
+
+prepared local-reserve claim 也必须由 guard 持有。BatchGetStart 明确接受的 target 逐项从
+guard disarm 并转交 per-key flight。已经收到响应、但响应长度或 target identity 异常时，
+所有已返回 `get_id` 的成功项必须先移交注册 Revoke cleanup，只有明确未接受的 slots 才能
+立即返回 Free。若 BatchGetStart transport 失败且完全没有响应，owner 不知道 master 是否已经
+接受，也没有 `get_id` 可以 revoke；这类 slots 不得立即复用，当前实现隔离 65 秒，覆盖 master
+60 秒 inflight Get TTL 后再尝试释放。该 TTL 隔离是未知提交点的安全兜底，不替代后续带
+request identity 的 terminal query 协议。
+
+`Revoking` 状态必须保留完整 `get_id + prepared_target`；RPC 超时、响应丢失或长度/identity
+不匹配时保留 marker 和 slot 并重试，只有 master 明确确认 Revoke 后才释放 slot。若 Done
+已胜出，则 Revoke 失败方不得释放已经 committed 的 slot。BatchGetDone 同样必须携带原始
+`get_id` 集合幂等重试，并逐项校验响应 identity；不能在固定三次重试后把
+pending-visible slot 遗留为无 owner 状态。owner shutdown 是唯一允许停止该重试的进程级终态。
+
+per-key shared op 至少要区分下列阶段：
+
+| 阶段 | 对 prefix / 资源的含义 |
+| --- | --- |
+| `Starting` | leader marker 已经对后续 batch 可见，但 master 尚未接受；joiner 只能等待，不能把它计为命中。 |
+| `Started` | master 已返回成功的 `put_id/get_id` 和精确 target；可用于计算连续 prefix，但 bytes 还不得暴露给 kernel。 |
+| `Finishing` | 至少一个 Interest 保留该 key；唯一 cohort executor 正在 transfer/GetDone，后续请求只能 join。 |
+| `Revoking { item }` | 无 Interest 保留该 key；`item` 持有 get_id 和精确 target，直到 Revoke 明确终止并释放 slot。 |
+| `Ready` | transfer、幂等 GetDone 和 local promotion 已完成；所有 waiter 共享同一个 `Arc<MemoryInfo>`。 |
+| `Failed/Revoked` | 终态错误对所有 waiter 一致可见；leader 只释放一次 prepared slot 和 master inflight。 |
+
+shared op 的 registry 清理必须同时比对 key 和 op identity/generation，只删除当前这一个
+terminal op。旧 waiter 的延迟 drop 不能删除同 key 随后创建的新 op，这与现有
+`key + Arc::ptr_eq` 的 generation 清理原则相同。同一 required batch 内即使出现
+重复 key，也只能有一个 leader/shared op；原始的多个 index 分别持有结果引用。
+
+owner 侧 singleflight 是主去重边界，master 仍需要防御性地保证一个 requester 不发布两个
+local committed targets。master 防重粒度必须是 `(key, requester_owner)`，不是全局
+`key`；GPU0 和 GPU1 同时把同一 key materialize 到各自 owner 是合法的，不应被串行化。
+prepared Get 从 master GetStart 接受到 GetDone/Revoke/TTL 终态期间占有该
+`(key, requester_owner)`。
+
+master 已经看到 requester 上有相同版本 live replica，或 GetDone 时另一个操作已经
+发布同版本 route，都属于可收敛竞争，不得使用 `InvalidArgument/Unknown` 当作永久
+失败。master 应返回可区分的 busy/already-exists 终态：owner 释放本次多申请的
+prepared slot，在 reclaim fence 下重新获取 canonical local holder；正在 demotion 的 key 则等待
+route 移除后从 remote replica 重试。相同 `put_id` 的 GetDone 竞争必须幂等收敛到唯一
+local route，输家不覆盖 canonical backing；不同 `put_id` 才是 stale Get，必须 revoke。
+
+该路径至少要暴露 `required/local_pinned/inflight_joined/leader_started`、被省略的
+GetStart/DMA 数、suffix local-pin/waiter/revoke 数、join 等待时间以及 conflict retry 数。
+当前 owner 周期快照已暴露 active handles、per-key flights 的 Starting/Finishing/Revoking、
+`undecided/retained` interest，以及 local-reserve 的 Free/Prepared/Pending/Committed slot 数；
+workload 结束后这些临时态必须在有界时间内回到基线。
+`prepared local-reserve Get target cannot replace a live replica` 和
+`prepared local-reserve Get target could not publish current route` 应该从可见错误中归零；
+仅看最终 QPS 不能证明重叠 batch 已经正确去重。
 
 ## Fluxon 本地可见索引与生命周期
 
@@ -524,77 +695,111 @@ Fluxon client/external 侧会维护当前进程可直接访问的 value 索引
 
 | 状态 | 创建入口 | 生命周期 |
 | --- | --- | --- |
-| precommit local visible | `local_fast_put_commit` 开始后，由 owner-local reserve slot 对应的 `MemoryInfo` 记录到 `precommit_local_visible_info` | 表示本次 put 的 value 已在当前进程可读，但后台 put commit 尚未最终完成；成功后转为 `get_cached_info` 中的 committed entry，失败或取消时移除。 |
+| precommit local visible | `local_fast_put_commit` 开始后，由 owner-local reserve slot 对应的 `MemoryInfo` 记录到 `precommit_local_visible_info` | 表示 value 已在当前进程可读但 global publish 尚未收敛；成功后转为 committed entry。响应不确定/局部失败时保留并 roll-forward，只有证明从未发布的显式 abort 才移除。 |
 | committed local visible info | put commit 成功后，由 SGLang 进程内的 Fluxon external/client 将 `MemoryInfo` 记录到 `get_cached_info` | 保存 key、put version、`holder_id`、`offset`、`len` 和 owner node；后续 `get_start/get_transfer` 可以复用这份 `MemoryInfo` 构造 readable plan。 |
 | inline external holding | owner 判定整个 transferable batch 都在本地可见后，为每个导出 page 分配 external holding ID 并安装 holding | start response 到达 external 后由 handle 缓存；随后必须移交给 `get_transfer` plan 或由 cancel 携带 holding IDs 释放。holding 绑定 owner generation。 |
 | get-transfer holder | `get_transfer` 成功后绑定到 readable plan，并由 plan 持有引用 | `release_views(plan_ptr)` 后释放引用；plan 生命周期内 holder 保证对应 value 不被释放。 |
 
+Put 的本地可见性和全局发布是两个独立的线性化点，不得把两者合并成
+“等 master 后才能本地读”：
+
+| 线性化点 | 条件 | 立即允许的操作 |
+| --- | --- | --- |
+| `local-read-ready` | native kernel 已把 bytes 写入 local-reserve slot，且对应 CUDA stream 可见性已满足；client 将唯一 `MemoryInfo` 安装到 `precommit_local_visible_info` | 同 owner 的 `local_visible_mem_holder(s)` 立即可以命中、pin 并读取该 slot，不等待 master PutDone。 |
+| `global-route-ready` | master PutDone 已按 key/version 发布 route，并完成必要的 route maintenance | 该 slot 才进入 `Committed(route_live=true)`，可被其它 owner 通过全局 route 发现，并可进入 owner-hot Moka 参与后续分级。 |
+
+因此延后的只是 global committed 和 hot admission，不是 local read。之所以不在
+`local-read-ready` 时立即加入 owner-hot Moka，是因为 Size eviction 可能马上启动
+replica/demotion/reclaim；此时 master route 还未发布，会使回收协议无法用同一
+`put_id + backing identity` 证明对象归属。precommit entry 本身持有 resident holder，已经
+足以保证本地读期间地址稳定，不需要依赖 hot Moka。
+
+同一 atomic/TP cohort 可以逐项进入 `local-read-ready`，但 batch Get 仍必须在原
+`atomic_group_lens` 边界上判定可恢复前缀；这保留了“本地已写页立即可复用”，
+又不会向 SGLang 恢复半个 radix node。master 发布不确定或部分成功时保留 local-visible
+entry/fence 并整批 roll-forward；只有明确从未发布的 abort 才能移除 precommit。已经取得的
+local-read holder 仍可安全完成当前读，最后一个 holder 释放后才能回收 slot。
+
 收到 `local_cache_holder_id` 后，SGLang 进程内的 Fluxon external/client 使用 `holder_id`、`offset` 和 `len` 构造 `MemoryInfo`，并记录到自身 `get_cached_info`。`MemoryInfo` 记录当前进程访问该 value 所需的地址信息和释放动作；后续 `get_start` 命中 `get_cached_info` 时，可以直接把这份 `MemoryInfo` 纳入本次 get 结果，`get_transfer` 再把这些 value 地址写入 readable plan。底层内存的回收由 owner route、holder 引用和 owner-local reserve grant 生命周期共同约束。
 
 内部 `MemoryInfo.holder_id` 与 external holding ID 属于两个生命周期域。resident local-reserve page 的内部 holder ID 可以为 0；每次 external export 仍由 owner 分配非零、递增且独立的 holding ID，同一内部 backing 的并发导出也不能复用 ID。这样 cancel/delete ACK 可以按本次 export 精确对账，多个 resident page 不会因内部 ID 相同而覆盖 holding。external 在构造 inline holder 前还必须验证 response generation 与当前 mmap owner generation 一致，并验证 `offset + len` 位于 mapping 范围内。
 
-`precommit_local_visible_info` 只覆盖 commit 进行中的短窗口。put commit 成功并确认 holder 后，会移除 precommit entry 并记录 committed entry；如果 commit 失败，precommit entry 必须被清理，不能作为后续 storage-backed 恢复来源。
+`precommit_local_visible_info` 覆盖 local-ready 到 global route/promotion 完成之间的窗口。
+put commit 成功后会原子转入 committed index；PutDone 响应不确定或局部失败时 publish job
+必须继续持有 precommit/fence 并以同一 identity roll-forward，不能清理可能已被 master 发布的
+backing。只有明确证明 master 从未发布且操作已终止的 abort 路径才可移除 precommit。
 
 ## Local-side 主动驱逐与安全回收
 
-local-side 主动驱逐不是在 Moka eviction callback 中直接释放内存。无论候选来自常规 Moka capacity eviction，还是 owner refill 遇到物理 NoSpace 后显式调用 `evict_some`，都必须经过同一套 master/owner 安全回收协议。其外部可见不变量是：已经释放或复用的 backing 不会仍然作为一个可访问 route 提供给新的 put/get/replica；如果暂时无法证明可以安全释放，则候选保持 pending 并退避重试，队列关闭等无法继续推进的路径才把当前版本放回 Moka。
+local-side 主动驱逐分成“owner 选择冷 source”和“master/owner 安全删除该 source”两个
+阶段。owner hot Moka 的 Size removal 或 pressure actor 的 `evict_some` 只完成候选选择；
+dispatcher 随后提交完整、精确的 atomic/TP source cohort。该容量事务不查询 CPU replica，
+也不等待 remote append：有其它 replica 时只删当前 owner source，没有其它 replica 时允许
+删除最后一份 cache route，后续 Get 正常 miss/recompute。proactive remote replica 是独立的
+命中率优化，失败只代表少一份可命中的 CPU copy，不拥有 owner 容量释放的否决权。
 
 ### 触发与职责边界
 
-- Moka 使用 `NodeValueReplicaDesc.weight_bytes` 计费；对于 committed slot，该权重对应真实 `slot_size`。
-- Moka 只做冷条目选择。eviction listener 把 `owner_node_id + key + put_id + weight` 放入 safe reclaim queue，不直接 drop `MemHolder`，也不直接释放 slot。
-- `evict_some(requested_weight)` 的参数是“希望移除的权重”，不是目标 cache size；它沿 LRU 顺序驱逐到满足请求或没有候选为止，并返回实际驱逐权重。由于条目必须整项驱逐，返回值可以大于请求值。它不会通过临时调低再调高 `max_capacity` 来制造驱逐，因此 owner/Moka 配置容量在调用前后保持不变。
-- `eviction_reclaim_pending_weight` 记录已被 Moka 选中、但尚未完成物理回收的权重。NoSpace 兜底只对 `requested_weight - pending_weight` 调用 `evict_some`，避免对同一轮压力重复过量驱逐。
-- activity、holder 或短暂 owner Busy 导致候选无法回收时，不立即插回仍然超限的 Moka。该候选继续计入 pending weight，并以 `10 ms` 起步、最大 `1 s` 的指数退避重新进入 safe reclaim queue；route/put_id 已变化时结束 pending，不复活旧版本。这避免同一个热 key 在 eviction 与 reinsert 之间形成高频循环。
-- safe reclaim queue 满或关闭时，入口立即回滚 pending weight，并且仅在 route 仍是相同 `put_id`、owner replica 仍 live 时把条目重新插回 Moka；旧版本候选不会被复活。
+- owner hot Moka 以 committed slot 的真实 `slot_size` 计费，value 只保存
+  `Weak<MemoryInfo>`，不因热度索引额外 pin backing。
+- synchronous eviction callback 只发送 `(key, put_id, Weak, weight)` 到 lossless metadata
+  channel；callback 不取 key-control、不查 index、不展开 cohort、不 RPC/RDMA。
+- async dispatcher 从当前 local index point-pin `Arc`，在锁外展开完整 atomic/TP cohort，
+  构造 `OwnerSourceEvictionMember { key, put_id, backing }`；不使用 cohort-wide 同步锁。
+- `evict_some(requested_weight)` 是 owner slot-pressure actor 的唯一生产调用点；参数是本轮
+  希望选择的字节数，不是新容量。单次 ≤256 MiB、最短间隔 200 ms，调用前后
+  `max_capacity`、owner 配置容量和 expected grants 均不变。
+- `selection_debt_bytes` 覆盖已离开 hot window、仍由 source-delete/retry 状态机拥有的字节。
+  pressure actor 只选择 `free-slot deficit - selection debt`，避免重复超选。
+- `BatchEvictOwnerSourceReq/Resp` 使用 Msg ID `3069/3070`。RPC 不可达、activity Busy、
+  partial overlap 或 actor 暂不可用都按同一 exact identity 有界重试，不重新 append；
+  physical Free、stale/obsolete 或安全恢复 hot 是 selected debt 的唯一终态。
+- active size class 为 `0` 时是尚未分配的正常 idle，pressure actor 静默等待；当前只支持
+  `1` 个 active class；`>1` 时停止选择并限频报错，不能用全局 Moka 在多 class 中猜 victim。
 
 ### 安全回收时序
 
 ```mermaid
 sequenceDiagram
-    participant C as Moka cache controller
+    participant H as owner hot Moka
+    participant O as GPU owner dispatcher
     participant M as Fluxon master
-    participant O as Fluxon owner
-
-    C->>C: capacity eviction / evict_some 选择候选
-    C->>M: enqueue(key, put_id, owner, weight)
-    M->>M: 校验 route/version/backing
-    M->>M: try_install_reclaim(key)
-    alt put/get/replica 在途或已有 reclaim fence
-        M->>M: 保留 pending weight，指数退避后重试
-    else per-key activity 已静默
-        Note over M: fence 存在期间拒绝新的 put/get/replica
-        M->>O: Prepare(item, epoch, exact backing)
-        O->>O: 隐藏本地索引并检查 pending put / holder
-        alt Busy 或 Stale
-            O-->>M: Busy / Stale
-            M->>O: Abort（需要时）
-            M->>M: 当前版本仍有效则退避重试；旧版本结束 pending
-        else Prepared
-            O-->>M: Prepared
-            M->>O: Commit
-            O->>O: 校验并释放精确 slot/backing
-            O-->>M: Committed
-            M->>M: 删除相同 put_id 的 owner replica/route
-            M->>O: Finalize
-            O-->>M: Finalized
-            M->>M: 清除 master reclaim fence
-        end
+    participant R as existing local reader
+
+    H->>O: Size event(key, put_id, Weak, weight)
+    O->>O: point-pin current source / expand exact cohort
+    O->>M: BatchEvictOwnerSource(exact cohort)
+    M->>M: validate caller generation, closure and backing
+    M->>M: install all master activity fences
+    M->>O: cohort Prepare
+    alt reader already holds source
+        O-->>M: Busy; restore visible index
+        R-->>O: holder released
+        M->>M: bounded retry of the same identity
     end
+    O-->>M: all Prepared
+    M->>O: cohort Commit
+    O->>O: Prepared -> Releasing under key shard
+    O->>O: unlock key; release route+holder in one pool update
+    O->>O: Releasing -> Committed
+    M->>M: remove exact owner routes; last route may disappear
+    M->>O: cohort Finalize
 ```
 
 Master 与 owner 两侧分别承担下面的正确性约束：
 
 | 约束 | 当前实现 |
 | --- | --- |
-| 并发线性化 | Master 为每个 key 统计 put/get/replica activity。只有三个计数都为零且没有其它 reclaim 时才能原子安装 reclaim fence；安装后新的 put/get/replica 不能取得 activity lease。replica append 在完整任务期间持有 lease，避免远端副本尚未完成时回收 local backing。 |
+| 并发线性化 | Master 为每个 key 统计 put/get/replica activity。只有三个计数都为零且没有其它 reclaim 时才能原子安装 reclaim fence；安装后新的 put/get/replica 不能取得 activity lease。已经取得 source holder 的读或 replica transfer 必须先排空，但 transfer 是否成功不改变容量事务义务。 |
 | 版本隔离 | 每个候选携带 `put_id` 和 reclaim `epoch`。Master 在安装 fence 前、Prepare 后以及删除 route 前重复检查当前 route 仍是同一版本。 |
 | backing/slot 防 ABA | committed slot 必须同时匹配 owner、`grant_id`、`slot_index` 和 `slot_size`；旧驱逐请求不能释放新版本或已经复用的 slot。 |
-| 现有读者排空 | Owner Prepare 在同一个 key-control lock 下先从 `get_cached_info` 隐藏索引，阻止新本地读者；随后要求 `Arc::strong_count(mem_holder) == 1`。若已有 get/plan 持有引用，则恢复索引并返回 Busy。 |
+| 现有读者排空 | Owner Prepare 只持该 key 所属的短 sharded key-control fence，先从 local index 隐藏 backing，再要求唯一 holder。若已有 get/plan/transfer pin，则恢复索引并返回 Busy。 |
 | 写入冲突隔离 | Owner Prepare 遇到 `local_puts`、`precommit_local_visible_info` 或 `external_pending_puts` 时返回 Busy，不会回收正在写入或尚未发布完成的 value。 |
-| 精确物理释放 | Owner Commit 持有 key-control lock，使用 `Arc::try_unwrap` 取得唯一 backing，并再次断言 slot identity 后释放 owner-side committed-slot route、resident holder 和内存引用，使该 slot 可以回到 Free。identity 不一致按内部不变量失败，而不是继续释放未知 backing；整个 grant 的 mmap/registered memory 仍按独立的 grant 生命周期回收。 |
+| 精确物理释放 | Owner Commit 在 key-shard 内只切换 `Prepared -> Releasing`，随即释放 key 锁；之后在一次 slot-pool 临界区同时释放 committed route ref 与 resident holder，再回到 key shard 标记 `Committed`。这避免 key-shard mutex 嵌套 slot-pool mutex，也不暴露两次 pool update 间的中间状态。 |
 | route 更新顺序 | Owner Commit 释放物理 backing 后，Master 只删除相同 `put_id` 且 backing identity 相同的 replica；这个短窗口仍受 master reclaim fence 保护，对新请求不可访问。Master 更新 route 后才 Finalize owner fence。 |
-| 幂等与失败关闭 | Prepare/Commit/Abort/Finalize 都按 `item + epoch` 判定已应用状态。Prepare 或 Commit RPC 不确定时通过 Abort 查询/收敛；如果 owner 已经 Commit，则不能回滚 backing，而是继续删除 route 并 Finalize。Abort/Finalize RPC 失败会退避重试；未收敛时保留 fence，优先阻塞该 key 而不是暴露已释放内存。 |
+| cohort 事务 | owner exact source deletion 和 master allocation capacity reclaim 都以一个 cohort request 进入 lossless queue。全组 master fence 与 Prepare 要么全部取得、要么全部撤销；一旦任一 Commit 已成功，只允许 roll-forward 完成其余成员。 |
+| 幂等与失败关闭 | Prepare/Commit/Abort/Finalize 都按 `item + epoch` 判定已应用状态。RPC 不确定时重放同一 identity；已经 Commit 的 backing 不可回滚。未收敛时保留 fence，优先阻塞该 key 而不是暴露已释放内存。 |
+| partial/replay 判定 | 全部 source 已不存在是 `Completed`；部分不存在只有在完整 exact identity 已在 reclaim registry 中时才是 `AlreadyInProgress`。无对应在途事务返回 `Stale`，部分 overlap 返回 `RetryableBusy`，不能把残缺 cohort 当作新事务接受。 |
 | 失败候选收敛 | 暂时 Busy 的当前版本保持 pending 并退避重试，不立即插回 Moka；stale route 或版本变化直接结束 pending。只有队列关闭等无法继续推进的路径，才在 route 仍匹配 `put_id` 且 owner replica live 时重新插入，避免旧条目覆盖新版本。 |
 
 从可观察状态看，回收事务允许 Owner Commit 与 Master route 删除之间短暂存在“owner slot 已回收到 allocator、可以复用，但旧 route 对象尚在”的内部状态，但对应 key 的 master reclaim fence 在整个窗口内拒绝新操作；安装 fence 之前已经取得 lease 的 get/put/replica 又必须先结束。因此调用方不会通过该 route 访问已经释放或复用的 backing。
@@ -603,15 +808,50 @@ Master 与 owner 两侧分别承担下面的正确性约束：
 
 内存/并发正确性与“驱逐后是否仍有另一份可恢复数据”是两个不同契约：
 
-- `OwnerReclaimReason::Reserve` 用于物理 NoSpace 下的 route-scan 回收。它只选择存在另一份非 tomb replica 的 key，因而 local backing 释放后仍有 recoverable replica。
-- Moka eviction listener 产生的请求使用 `OwnerReclaimReason::CapacityEviction`。当前实现允许它删除最后一份 cache replica；最后一份被删除时，Master 同时删除整个 route，后续表现为正常 cache miss。这与本文前述“KV Cache 副本可丢失，miss 后重新计算”的缓存语义一致。
-- NoSpace 处理会先调用 `evict_some`，再执行 `Reserve` route-scan；其中 `evict_some` 产生的 listener 请求仍属于 `CapacityEviction`。因此不能因为后半段 route-scan 有副本检查，就推导整个 NoSpace 兜底都保证保留 remote replica。
-- 因此，当前已经保证并发访问、版本和 slot 复用安全，但没有对所有 `CapacityEviction` 保证“local 驱逐后 remote side 一定保留一份”。write-through 已成功建立 remote replica 时可以从 remote side 恢复；replica append 尚在途时 activity lease 会阻止并发回收。
-- 如果产品契约改为“任何 local-side 主动驱逐都必须可从 remote side 恢复”，则必须让 `CapacityEviction` 对 active/local owner 同样要求 `has_recoverable_replica`，并补充无远端副本、远端 tomb、replica append 并发及 RPC 故障注入测试。不能只依赖 write-through 通常会产生远端副本这一经验条件。
-- Put `atomic_group_lens` 只保证副本准入不主动切组，不能单独证明 CPU 侧整组已经完成。下一阶段的可恢复优先驱逐需要记录组内 remote append 完成状态，并让 GPU Moka / `CapacityEviction` 优先选择已有完整 CPU 副本的 group；远端只完成部分 pages 的 group 不能作为“驱逐后仍可恢复”的依据。
+- **环 A（owner-indexed source）**：hot removal/`evict_some` 只是 owner 的 victim selection。
+  owner 把完整 exact cohort 交给 master 做 source route fence/delete；不要求 CPU 副本。
+  有其它 replica 时只删除该 source，没有其它 replica 时允许最后 route 消失。RPC/Busy 暂时
+  失败时 source 保持可读并按同一 identity 重试；remote write 失败不进入容量失败补偿。
+- **环 B（master-only/unindexed Allocation）**：master 有界 Moka 的原生 Size eviction 可以删除最后
+  一份 cache route，后续正常 miss/recompute；这是 cache 容量语义，与环 A 的结果一致，
+  但 victim authority 与 backing 释放位置不同。该分类只取决于 backing/index/lease
+  语义，不取决于 CPU/GPU 或 active/remote-only 节点角色；当前默认置换策略为
+  Moka TinyLFU，正确性不依赖具体 victim 顺序。
+- 旧 `OwnerReclaimReason::Reserve` route 全表扫描、`reclaim_before_grow` 和 master 侧手动
+  `evict_some` 均已删除。NoSpace 只返回明确可重试结果；owner pressure actor 等待真实 Free
+  slot，不通过增大 grant 数绕过 configured capacity。
+- `atomic_group_lens`/Put group 是 source cohort 描述；master 在 source deletion 当下验证
+  请求集合与当前 atomic/TP closure 完全一致。它不从单 key补全 cohort，也不要求共同 CPU
+  owner；任一 member stale 时整组不 Commit。
 
 ### 当前验证证据与覆盖边界
 
+2026-07-17 对当前 Fluxon 工作树完成 direct source-delete 本机回归。使用
+`CARGO_TARGET_DIR=/tmp/fluxon_target_direct`、`-j 4` 和 closed-sdk runtime，最新代码
+`cargo test -p fluxon_kv --lib --no-run` 通过；exact source cohort 定向测试 `7/7`，owner
+slot/reclaim 定向测试 `19/19`，`fluxon_kv --lib` 全量为
+`171 passed, 0 failed`（193.19s）。覆盖有/无 CPU replica、最后 route 删除、stale backing、
+partial replay-only、cohort fence all-or-nothing、retry exactly-once、`Releasing` 和
+route+holder 单次 pool update。全量测试还修复了 `0 active class` 被误判后每 10ms 报错的
+idle actor 空转。本机回归本身不替代 release 三机部署、真实 RDMA 与 E44 自然冷跑，后者
+按下一段独立验收。
+
+上述独立验收已在 2026-07-17 的 E44 r9 完成。三机容量保持
+GPU0/GPU1/CPU=`128/128/256 GiB`，两 GPU 各固定 `232` grants、`26,216` slots；
+S96×T24、concurrency 24、session-stream、无预热自然冷跑为 `2304/2304` 成功，QPS
+`5.609336`，L1/L2/L3/总命中率 `5.4060%/0%/54.6878%/60.0939%`。CPU owner 被选为
+唯一 proactive replica target（`77,384` 个），并实际为两个 GPU requester 提供
+`183,923` 个 key、`808.26 GiB` Get source 数据。
+
+容量闭环终态为：GPU0/GPU1 direct source commit `130,540/145,888`，dispatch failure
+均为 0；Free slots `466/488`，Prepared/Pending 均为 0；active flights、retry entries、
+selected 和 selection debt 全为 0；grant 数始终等于 expected `232`。业务错误、refill
+timeout、P2P、panic、OOM 和 scheduler exception 均为 0。日志中的 recoverable
+`not_ready` 只对应最后一份 route 已按容量策略删除后的正常 miss/recompute；所有真正提交的
+prefetch 均以非零 prefix 成功，没有 TP prepare reject 或 transport error。该结果证明环 A
+的 direct source-delete 正确性和容量收敛，不证明 selective CPU replica 已达到 Mooncake 的
+命中率；后者仍是独立性能策略，不能反向成为 Free 的前置条件。
+
 三机 SGLang 正式压力还覆盖了 expected-capacity 与常规驱逐的组合。E16a4 使用两台 TP=2
 GPU owner 和一台 CPU-only owner，标称容量保持 128/128/256 GiB；两 GPU 各预热 207 grants，
 正式请求期间各按 pending demand 增到 208 grants。1152/1152 请求成功，QPS 4.845，两侧
@@ -952,9 +1192,10 @@ recoverable-first eviction 优先选择已有完整 CPU 副本的 group，才能
 
 当前实现把提前写回的热度观察点下沉到 storage owner。每个 GPU owner 维护一个逐 key 的
 owner-local hot Moka；本地 committed value 进入该 tier，`InlineLocal` 等 owner 本地命中会刷新
-热度。hot tier 发生 `RemovalCause::Size` 时，owner 立即 pin 当前 `put_id` 的 backing，再把该
-value 交给现有 replica actor 异步写入 remote CPU owner。Master T2 resident Moka 仍是唯一的
-物理回收决策入口。
+热度。hot tier 发生 `RemovalCause::Size` 时，callback 只把 key/put_id/Weak/weight 交给
+lossless metadata channel；离开 Moka housekeeper 后，异步 dispatcher 才逐 key point-check、
+pin 当前 backing、展开 cohort，并交给 replica actor 写入 remote CPU owner。Master 仍负责
+remote route 成功后的 cohort demotion/reclaim 仲裁。
 
 ```mermaid
 sequenceDiagram
@@ -969,7 +1210,7 @@ sequenceDiagram
     S->>G: InlineLocal hit
     G->>H: touch current entry
     H->>G: Size eviction(key, put_id)
-    G->>G: key fence + version check + Arc pin
+    G->>G: async dispatcher: DashMap point-check + Arc pin
     G->>M: put_append_start(key, put_id)
     M-->>G: reserve remote-only target
     G->>C: RDMA transfer
@@ -1016,10 +1257,10 @@ replica_cache_capacity_ratio: 0.95
 
 | 场景 | 当前处理 |
 | --- | --- |
-| hot eviction 与 T2 reclaim 竞争 | 两者使用同一个 `owner_key_control` fence。reclaim 先取得 fence 时，hot eviction 放弃 stale source；hot eviction 先 clone `Arc` 时，reclaim 的唯一强引用检查返回 Busy，等 replica 任务释放 pin 后再重试。 |
+| hot eviction 与 T2 reclaim 竞争 | owner-hot pin 不取全局 `owner_key_control`。dispatcher 在 DashMap shard read guard 内校验 current identity 并 clone `Arc`；pin 先发生时 reclaim remove 后的唯一强引用检查返回 Busy，Prepare 先发生时 dispatcher 看到 index 缺失且 live Weak，按 `RetryableReclaimFence` 退避，绝不从 Prepared 升级 Weak。 |
 | 版本替换、delete、显式失效 | eviction listener 只消费 `RemovalCause::Size`。`Replaced` 和 `Explicit` 不创建 replica；reclaim/delete 按 `put_id` 条件失效 hot entry，不能删除随后安装的新版本。 |
-| 旧事件与重复事件 | listener 同时校验 `put_id` 和 `MemoryInfo` identity；dispatcher 入队前再次校验当前 owner index。`(key, put_id)` guard 覆盖排队、transfer 和 append-done 全周期。 |
-| 控制面阻塞 | Moka callback 只完成 fence 内 pin 和容量 4096 的事件队列 `try_send`，不等待 RPC/RDMA；dispatcher 再进入现有容量 128 的 replica task queue。事件队列满时计入 dispatch-failed 并立即释放 pin，避免积压事件阻止 T2 reclaim。 |
+| 旧事件与重复事件 | listener 携带 eviction entry 的 `put_id + Weak identity`；dispatcher 以当前 owner index 再校验。`(key, put_id)` guard 覆盖排队、transfer 和 append-done 全周期。 |
+| 控制面阻塞 | Moka callback 只向 lossless 轻量 metadata channel 发送事件，不点查 index、不展开 cohort、不 pin、不等待 RPC/RDMA。dispatcher 完成 point-pin 后再进入容量 128 的 replica task queue；RetryableCold 按 owner committed identity 去重并退避。 |
 | append start busy key | owner-hot 任务遇到 `KeyBeingWritten` 时最多尝试 3 次，重试间隔为 25/50 ms。其它错误不做这一层重试；最终失败释放 pin，保留 GPU primary，不会把失败任务解释为 CPU replica 已完成。 |
 | 可观察性 | owner 每 30 秒记录 hot capacity/weighted bytes、Size eviction、enqueued/completed/already-satisfied/failed/obsolete、dispatch-failed、inflight 以及 stale/reclaim/duplicate skip 计数。CPU 数据面完成仍以 `put_append_done appended=true` 和 master target 计数为准。 |
 
@@ -1190,9 +1431,14 @@ owner/client receiver 改为 WaitSet 后虽完成 1152/1152，QPS 降至 6.6932
 
 #### E16ay Get-target 压力与 local reserve 物理容量闭环
 
-local reserve 的 expected capacity 是下限而非硬上限。Put 并发需求可使它从配置的 grant 数
-继续扩张；后续 slot 回收只让 grant 内部变空，并不会自动把这段 512 MiB 物理 allocation
-归还 master segment allocator。原 shrink actor 还只检查队尾 grant，并要求连续全空 5 秒。
+> 本节记录 E16ay 当时的历史实现，不是当前容量规约。后续修复已经把 configured
+> `expected_grant_count` 改为硬上限，并删除 route 全表扫描；当前行为以本章开头规约表和
+> “Local-side 主动驱逐与安全回收”章节为准。
+
+E16ay 当时 local reserve 的 expected capacity 是下限而非硬上限。Put 并发需求会使它从配置的
+grant 数继续扩张；后续 slot 回收只让 grant 内部变空，并不会自动把这段 512 MiB 物理
+allocation 归还 master segment allocator。原 shrink actor 还只检查队尾 grant，并要求连续全空
+5 秒。
 另一方面，CPU -> GPU remote Get 的 target 仍是 master 直接从请求 owner 的普通 allocator
 分配。因此系统可能同时出现：
 
@@ -1226,6 +1472,80 @@ pending 与 owner-hot demotion 都为 0。配置的 owner 容量、resident/hot
 expected 下限没有改变。这证明同步归还空 grant 可以闭合 Get-target 物理 headroom，但 QPS
 仍比双 GPU baseline 低 0.79%、比 Mooncake 低 1.33%。
 
+#### 单 KV slot 分级循环（取代整 grant Get-target 让位）
+
+E16ay 的整 grant 让位只是在旧 Get target 仍从 master 普通 allocator 分配时的兼容方案，
+不是最终的缓存分级语义。`512 MiB` grant 只是 local-reserve 的物理容器，不应成为 KV
+驱逐或恢复的最小单位。多个 grant 中的所有 committed KV slot 已由同一个 owner-hot Moka
+按 key、版本和实际 slot weight 统一管理；因此正确闭环是逐 KV slot 循环：
+
+```text
+任意 grant 的 Committed slot
+  -> 跑出 owner hot window
+  -> owner 展开完整 exact atomic/TP source cohort
+  -> BatchEvictOwnerSource
+  -> master activity fence + owner holder drain
+  -> owner route 引用与 resident holder 一次 pool update 归还
+  -> master 删除 exact source route
+  -> 该 slot 立即 Free
+  -> 后续 remote Get 直接 claim 这个 Free slot
+```
+
+CPU proactive replica 可以在这条路径之前、期间或完全不发生；它只改变删除 source 后还能否
+remote hit，不是释放 slot 的前置条件。
+
+这条路径不等待同一 grant 的其它 slot 释放，也不排空或归还整个 grant。普通 idle shrink
+仍可在 grant 已经自然全空且高于保留下限时回收物理 allocation，但它不参与 Get 的正确性
+或前进性。
+
+Moka size eviction 是冷候选 ownership transfer，不能被当作可丢失通知。如果触发 key 的
+atomic/TP cohort 元数据暂不完整，owner 保留同一个 selected identity，在有界 retry actor 中
+等待当前 route/metadata 可构造完整 cohort；不能退化成逐 key source delete，也不能重新进入
+replica append。RPC/Busy/partial overlap 时 GPU route/holder 保持 live，并且事件必须以
+handoff、committed、restored、obsolete 或 retry 状态可对账，不能让 slot 永久留在 hot cache
+之外。
+
+remote Get 的 local-side target 使用与 hostless Put 相同的全 pool slot allocator；allocator
+可以从任意 grant 取一个匹配 `slot_size` 的 Free slot。没有 Free slot 时，复用现有 Moka
+候选与 owner 两阶段 fence，逐 KV reclaim 所需数量的 slot，而不是选择某个 grant drain。
+slot 状态机和失败契约如下：
+
+| 阶段 | 约束 |
+| --- | --- |
+| GetStart | client 先 claim `Free -> Prepared`，把精确的 `grant_id/slot_index/slot_size/address` 交给 master；master 校验 owner 和 grant 几何，不能改用另一个 target。 |
+| transfer 完成 | `Prepared -> Pending`，唯一 resident `MemoryInfo` 放入 hidden pending-get 表；此时 bytes 不得通过 local-visible index 暴露。 |
+| GetDone 成功 | master 以 key/version/owner CAS 发布 committed-slot route，并确保 resident Moka entry 已可见；client 再把同一 `MemoryInfo` 原子移入 committed index、`Pending -> Committed`，并加入 owner-hot Moka。 |
+| transfer/GetDone 明确失败 | revoke master inflight，移除 hidden pending；最后一个 `MemoryInfo` holder 归还后单 slot 回到 Free。 |
+| GetDone 响应丢失 | 保留 hidden pending，用同一 `get_id` 重试幂等终态；不能猜测失败并释放可能已经被 master 发布的 slot。 |
+| 并发或旧版本 | 同 key+owner 只能有一个 live committed route；CAS 输家不覆盖现有 backing。delete/reclaim 按 put id 清理 hidden pending，避免 master 已发布而 client 尚未 promote 的窗口泄漏。 |
+| owner source eviction | 完整 exact cohort 可直接请求删除当前 owner source，不依赖 CPU route；最后一份 cache route 也可删除。master fence 与 holder drain 完成前 slot 不得复用。 |
+
+hostless Put 也必须经过同一发布门禁。`local_fast_put_commit` 先把写完的 slot 置为
+`PendingLocalVisible`，只允许当前 owner 本地读取；master PutDone 已发布 route 并同步完成
+resident Moka admission 后，client 才执行 `PendingLocalVisible -> Committed(route_live=true)`。
+同一 batch 的成功成员要先全部完成 promotion，再统一加入 owner-hot Moka，避免第一个成员刚
+admit 就被容量淘汰，而其 route 或 atomic/TP cohort 仍未完整发布。PutDone 明确失败或响应
+结果不确定时都保留 pending/fence，并使用同一操作身份重试；不能释放可能已经被 master
+发布的 backing，也不能把部分 item 的错误当作整批可回滚。
+
+发布生命周期必须以 batch/job 为单位持有，而不是每个 key 各自 fire-and-forget。一个
+`OwnerLocalPublishJob` 持有整批 master key reservations；external local-first 路径还持有
+整批 `ExternalPendingPutCtx` 和 owner reclaim fences。PutDone 响应不确定、响应长度/identity
+不一致或任一 item 未达终态时，job 保留全部状态并以 25ms～1s 退避重试。全部 master route
+成功后才开始 local promotion；若取消或局部错误发生在 promotion 中间，下一轮接受已经
+promoted 的成员并继续其余成员，只向前收敛。所有 promotion 完成后才统一 owner-hot
+admission。只要任一 item 声明 atomic group，而 job 未包含连续、同序的完整成员，就禁止
+退化到逐 key PutDone；不得用“部分成功”换取半组可见性。
+
+`Committed` slot 的可复用条件仍是 `route_live == false && holder_ref_count == 0`；释放 route
+与释放 holder 各执行一次，任意先后顺序都不能提前复用。Get 使用 local-reserve slot 不占旧的
+master 普通-allocation durable quota；旧 quota token 则必须绑定普通 route 生命周期，在
+revoke、失败、替换或删除时恰好归还一次。
+
+容量语义保持不变：GPU owner 仍是配置的 `128 GiB`，CPU owner 仍是 `256 GiB`；该改造
+不调整 `contribute_to_cluster_pool_size.dram`、resident/hot Moka capacity 或 expected grant
+数量，只让完成 exact source deletion 的单个 KV slot 立即回到同一 size class 的 Free list。
+
 #### E16az external local-IPC busy-poll 验收
 
 E16ay 的两个 GPU owner 仍分别产生 147,124/150,701 条 iceoryx2
@@ -1340,6 +1660,14 @@ Put admission 的随机 identity 必须跨 TP rank 稳定。物理 storage key 
 restore。不能直接使用较长 rank 的 handle，也不应因为尾部差异把两个 rank 已共同命中的
 前缀全部作废。
 
+`get_start` 长度一致只完成了 intent 协商，不能作为 restore 的最终提交点。每个 rank 在
+`get_transfer` 返回可用 plan 后必须再进入一次 TP commit gate；只有所有 rank 都成功，plan
+才可进入 ready-prefetch、radix node 和 layerwise restore。任一 rank 超时、P2P 失败或 plan
+缺失时，所有 rank 统一取消 handle、释放已成功 rank 的 views，并把本轮 restored-token 数置为
+0，按共同 cache miss 重算。这个门禁必须位于任何 rank 发布 restored prefix 之前，禁止一侧
+restore、另一侧 recompute。异步 CUDA descriptor submission 的错误也必须在消费 prefix 前对
+所有 rank 可见；已经修改临时 node/slot 的实现必须全 rank 回滚后才能继续调度。
+
 ## 失败处理
 
 | 场景 | 必须动作 |
@@ -1348,7 +1676,7 @@ restore。不能直接使用较长 rank 的 handle，也不应因为尾部差异
 | `local_fast_put_commit` 返回 future 后后台失败 | SGLang 清理 `storage_staged/storage_pending/storage_local_ready`，必要时删除已 evicted 的 dead leaf。 |
 | `get_start` 后放弃 restore | 调用 `cancel_get_transfer(handle)`，释放 get-start 持有的 owner/external 资源。 |
 | `get_start` 只命中部分前缀 | 只允许恢复 `transferable_len` 覆盖的完整 atomic groups；后续 page 按 miss 处理。 |
-| `get_transfer` 报 key miss | SGLang rollback 当前 restore，不继续构造半个 node 的 GPU 恢复。 |
+| 任一 TP rank 的 `get_transfer` 失败或 plan 缺失 | TP commit gate 在所有 rank 上拒绝发布；释放成功 rank 的 views，统一按 0-token miss 重算。 |
 | `get_transfer` 成功后 native restore 失败 | 先 `release_views(plan_ptr)`，再执行 SGLang rollback；此时 handle 已被消费。 |
 | CUDA host registration 失败 | direct path 同步失败，不能降级为未注册 host memory。 |
 | `plan_ptr` 类型用错 | `local_fast_put_commit`、`put_abort`、`release_views` 都按 registry entry 类型校验并 fail fast。 |
diff --git "a/fluxon_doc_cn/design/teststack_2_Benchmark\347\233\221\346\216\247\345\267\245\345\205\267\351\223\276\344\270\216AIPerf\346\216\245\345\205\245\350\247\204\345\210\222.md" "b/fluxon_doc_cn/design/teststack_2_Benchmark\347\233\221\346\216\247\345\267\245\345\205\267\351\223\276\344\270\216AIPerf\346\216\245\345\205\245\350\247\204\345\210\222.md"
new file mode 100644
index 0000000..37cb6c6
--- /dev/null
+++ "b/fluxon_doc_cn/design/teststack_2_Benchmark\347\233\221\346\216\247\345\267\245\345\205\267\351\223\276\344\270\216AIPerf\346\216\245\345\205\245\350\247\204\345\210\222.md"
@@ -0,0 +1,565 @@
+# Benchmark 监控工具链与 AIPerf 接入规划
+
+> 状态：设计阶段  
+> 调研基线：2026-07-10  
+> AIPerf 基线：[`ActivePeter/aiperf:teleai`](https://github.com/ActivePeter/aiperf/tree/teleai)，提交 [`d72160e20957013d6608afcc88ed24100cb27dc5`](https://github.com/ActivePeter/aiperf/commit/d72160e20957013d6608afcc88ed24100cb27dc5)
+
+相关文档：[TestStack 架构与 CI 测试流程](./teststack_1_当前架构与CI测试流程.md)、[本地文件日志与 Greptime OTLP 导出链路](./log_1_本地文件日志与Greptime_OTLP导出链路.md)。AIPerf 能力判断依据固定提交下的 [architecture](https://github.com/ActivePeter/aiperf/blob/d72160e20957013d6608afcc88ed24100cb27dc5/docs/architecture.md)、[API endpoints](https://github.com/ActivePeter/aiperf/blob/d72160e20957013d6608afcc88ed24100cb27dc5/docs/reference/api-endpoints.md)、[server metrics](https://github.com/ActivePeter/aiperf/blob/d72160e20957013d6608afcc88ed24100cb27dc5/docs/server-metrics/server-metrics.md) 和 [profile exports](https://github.com/ActivePeter/aiperf/blob/d72160e20957013d6608afcc88ed24100cb27dc5/docs/tutorials/working-with-profile-exports.md)。
+
+## 1. 结论
+
+Fluxon 当前已经具备 benchmark 编排、终态结果、服务指标、日志和常驻 UI，但这些能力仍分布在不同链路中。现有链路适合 KV、MQ、RPC 和 FS benchmark，缺少生成式 AI 请求的 TTFT、ITL、token throughput、goodput、trace replay 等负载和指标语义。
+
+规划采用以下边界：
+
+- **AIPerf 只负责生成式 AI 负载和请求侧统计**：新增显式的 `AIPERF` test stack mode，首期支持单个 load generator 对 OpenAI-compatible SGLang endpoint 发压。
+- **`test_runner` 继续负责 case 生命周期**：suite 编译、资源准备、启动、超时、取消、终态、历史记录、UI 和对外 API 都由 `test_runner` 管理。
+- **Greptime 继续负责连续时序指标与日志**：Fluxon 服务指标、日志和已有监控链路不迁移到 AIPerf。AIPerf 的请求结果以 run artifact 为事实来源。
+- **AIPerf UI 和 API 不成为新的公共入口**：AIPerf 以 `runtime.ui: none` 运行；其 loopback API 只供同机适配器读取，`test_runner` UI 通过现有 ops 接口展示标准化后的进度和结果。
+- **现有 distributed benchmark coordinator 保持原路径**：KV、MQ、RPC、FS 的 `benchmark_result.json` 语义不由这次接入改写。`AIPERF` 是现有有限模式集合中的新分支。
+- **依赖必须固定到提交和构建产物哈希**：`teleai` 是未保护的可变分支，运行时不能直接按分支头安装。
+
+首期不启用 AIPerf sweep、AIPerf multi-run、AIPerf OTel 导出和 GPU telemetry。case 矩阵仍由 TestStack 的 `scene × scale × profile` 决定，避免形成嵌套调度和重复监控通道。
+
+## 2. 目标与非目标
+
+### 2.1 目标
+
+1. 把生成式 AI benchmark 收敛进 `start testbed -> testrunner` 两步模型。
+2. 复用 AIPerf 已有的请求生成、warmup、并发或请求速率控制、请求级记录和聚合统计。
+3. run artifact 和请求链路统一使用 `case_id + run_index`；连续服务指标通过 `cluster/instance + run time window` 与 run 关联。
+4. 让常驻 `test_runner` UI 同时展示实时进度、终态摘要、artifact 和 Greptime 时间窗口。
+5. 保证离线安装、固定依赖、固定随机种子和明确的失败状态。
+
+### 2.2 非目标
+
+- 不用 AIPerf 替换 `distributed_benchmark_coordinator.py`。
+- 不把 AIPerf FastAPI、TUI 或 plot dashboard 暴露为 TestStack 公共服务。
+- 不在 Fluxon 内重写 TTFT、ITL、token throughput 等 AIPerf 已提供的算法。
+- 不允许 suite 同时传入自由格式 AIPerf YAML、任意 CLI 参数和环境变量覆盖。
+- 首期不支持多 load generator、AIPerf Kubernetes service mode、真实用户 prompt、鉴权 endpoint 和自动性能回归判定。
+
+## 3. 当前工具链分析
+
+### 3.1 当前数据流
+
+```mermaid
+flowchart LR
+    A[ci_test_list.yaml] --> B[test_runner.py]
+    B --> C[resolved_case.yaml]
+    B --> D[distributed benchmark coordinator]
+    D --> E[benchmark nodes]
+    E --> F[benchmark_result.json]
+    F --> B
+    B --> G[summary.yaml + case_runs.yaml]
+
+    H[Fluxon processes] --> I[Prometheus remote write]
+    I --> J[Greptime]
+    H --> K[local logs / OTLP logs]
+    K --> J
+
+    G --> L[test_runner UI]
+    J --> L
+    M[ops interfaces] --> L
+```
+
+当前各层职责如下。
+
+| 层 | 当前实现 | 已有能力 | 当前边界 |
+| --- | --- | --- | --- |
+| suite 与 case 编译 | `test_runner.py` | `scene × scale × profile`、`resolved_case`、run 目录 | 没有生成式 AI workload branch |
+| testbed 生命周期 | `start_test_bed.py`、controller、ops | 启动共享服务、apply、进程状态和日志 | 不执行单个 benchmark case |
+| benchmark 执行 | coordinator + nodes | KV、MQ、RPC、FS 的分布式同步和聚合 | 指标模型面向 operation、bytes 和内部 phase |
+| 终态 | `benchmark_result.json`、`summary.yaml`、`case_runs.yaml` | 强制等待结果、校验节点完成、记录 run outcome | UI 主要展示原始摘要，缺少通用指标视图 |
+| 连续监控 | Prometheus-compatible remote write、Greptime | 服务指标、部分 transport 指标、日志 | 与 run artifact 的关联字段尚未统一 |
+| 常驻 UI | `test_runner_ui.py` | suite/run 状态、日志、GitOps、ops log | 当前没有 benchmark 曲线和统一结果 API |
+
+### 3.2 当前链路已经稳定的部分
+
+- `case_runs.yaml` 是 suite workdir 内执行状态的单一事实来源。
+- `summary.yaml` 是单次 run 的终态摘要，runner 会在执行前写入可诊断的占位结果。
+- TestStack benchmark 通过 `benchmark_result.json` 完成终态握手。runner 会校验每轮 `completion.status`、节点数量和 operation 数量。
+- UI 是常驻服务，run 结束后仍能读取历史、日志和 ops 状态。
+- Fluxon 指标使用 Prometheus-compatible 协议进入 Greptime，服务日志同时保留本地文件和 OTLP 路径。
+
+### 3.3 主要缺口
+
+| 缺口 | 影响 | 本设计的处理 |
+| --- | --- | --- |
+| 缺少生成式 AI 请求语义 | 现有 operation latency 无法表达 TTFT、ITL、token throughput 和多轮会话 | 使用 AIPerf 计算并保留原始 metric tag 与单位 |
+| 进度、终态和时序指标分散 | UI 需要分别读状态文件、原始 JSON、日志和 Greptime | 在现有 `/api/run_state` 下增加有界的 `benchmark` 分支 |
+| run 关联字段未贯穿 | 很难把请求突刺与服务指标、日志对齐 | 固定 artifact 关联键，并保存 cluster/instance 与 benchmark 时间窗口 |
+| 当前 UI 缺少 benchmark 图表 | 只能查看 JSON 和日志 | UI 读取标准化摘要、timeslice 和 server metrics artifact |
+| 多节点 percentile 聚合口径有限 | 当前 distributed benchmark 的 p50/p95/p99 是按成功 operation 数加权的节点 percentile，不能作为全量样本 percentile 使用 | AIPerf 路径保留请求级 JSONL，并由 AIPerf 计算请求总体 percentile |
+| 工具能力容易重复 | AIPerf 也有 UI、API、server metrics、OTel 和 GPU telemetry | 用明确的所有权表限制每条链路 |
+
+上表中的 percentile 结论只描述当前 coordinator 的节点聚合实现，不扩展为其他 benchmark 或整个监控系统的结论。
+
+## 4. AIPerf `teleai` 分支评估
+
+### 4.1 可直接复用的能力
+
+| 能力 | `teleai` 快照行为 | Fluxon 用法 |
+| --- | --- | --- |
+| Python 版本 | `requires-python = ">=3.10,<3.14"` | 满足 Fluxon 的 Python `>=3.10` 要求 |
+| 许可证 | Apache-2.0 | 构建产物保留许可证与 attribution |
+| endpoint | OpenAI chat/completions 等 | 首期只开放 OpenAI-compatible chat streaming |
+| 负载控制 | concurrency、request rate、warmup、ramp、trace replay | 首期开放 fixed concurrency 和 fixed request rate 两个有限分支 |
+| 请求指标 | TTFT、ITL、request latency、request/token throughput、error 等 | 直接采用 AIPerf metric tag 和单位，不在适配层重算 |
+| artifact | summary JSON/CSV、请求级 JSONL、`inputs.json`、timeslice | summary JSON 和请求级 JSONL 为首期必需产物 |
+| server metrics | 自动发现或显式抓取 Prometheus `/metrics`，当前默认每 333 ms 采样 | 首期只抓取 runner 解析出的单个 SGLang metrics endpoint |
+| 实时 API | `/api/run`、`/api/progress`、`/api/metrics`、`/api/results`、`/metrics` | 只绑定 loopback，由同机适配器读取 |
+| UI | dashboard、simple、none | 固定 `none`，避免出现第二套 UI 归属和入口 |
+| OTel | 可流式导出 metrics 和 timing | 首期关闭，待 Greptime OTLP metrics 契约单独评审 |
+
+### 4.2 依赖快照结论
+
+截至 2026-07-10：
+
+- `teleai` 指向提交 `d72160e20957013d6608afcc88ed24100cb27dc5`。
+- GitHub compare 显示该提交下 [`main...teleai`](https://github.com/ActivePeter/aiperf/compare/main...teleai) 为 `identical`。
+- 仓库中没有可识别的 TeleAI 专属配置、插件或 patch。
+- `teleai` 分支未启用 branch protection。
+
+因此，“使用 `teleai` 分支”在工程上必须落实为下面四项记录：
+
+1. source repo：`https://github.com/ActivePeter/aiperf`
+2. requested branch：`teleai`
+3. resolved commit：`d72160e20957013d6608afcc88ed24100cb27dc5`
+4. wheel 与 wheelhouse manifest 的 SHA-256
+
+实现前还需要业务方确认：当前意图是否就是采用这份与 fork `main` 相同的快照；如果预期存在 TeleAI 定制能力，应先明确对应提交或差异清单。
+
+### 4.3 不能直接沿用的默认行为
+
+- **不能按 branch head 在线安装**：testbed 运行期间不访问 PyPI 或 GitHub。
+- **不能使用环境变量替换普通参数**：suite 编译器生成完整 AIPerf YAML，启动命令只传 `--config`。
+- **不能使用 AIPerf sweep 或 multi-run 展开 case**：TestStack 已拥有 case 空间和 run history。
+- **不能依赖 AIPerf 默认 UI**：非 TTY 与 TTY 下必须都固定为 `none`。
+- **不能依赖 server metrics 自动发现**：显式写入 SGLang `/metrics` URL，并关闭 Kubernetes discovery。
+- **不能直接公开 AIPerf API port**：API 只监听 `127.0.0.1`，端口由 testbed port allocator 分配。
+
+## 5. 目标架构
+
+### 5.1 核心角色
+
+| 角色 | 责任 | 不负责什么 |
+| --- | --- | --- |
+| `start_test_bed.py` | 准备 SGLang、Greptime、controller、ops 和常驻 runner UI | 不启动单次 AIPerf run |
+| `test_runner.py` | 编译 `AIPERF` case、分配资源、驱动 prepare/execute/finalize、写终态 | 不计算 TTFT 或 ITL |
+| AIPerf adapter | 在 load generator 上启动 AIPerf、轮询 loopback API、原子写进度、校验 artifact、生成终态 | 不拥有 suite、历史或公共 API |
+| AIPerf | 发请求并计算请求侧指标 | 不拥有 testbed 和长期监控 |
+| SGLang endpoint | 被测服务，暴露 OpenAI-compatible API 和 `/metrics` | 不决定 benchmark 成败 |
+| Greptime | 保存 Fluxon 连续指标与日志 | 首期不保存 AIPerf 请求级记录 |
+| `test_runner` UI | 组合 run 状态、AIPerf 摘要、artifact、ops log 和 Greptime 时间窗口 | 不直接连接公开的 AIPerf 服务 |
+
+实现代码按现有 runner 分层落位：
+
+| 模块 | 计划改动 |
+| --- | --- |
+| `test_runner.py` | 增加 `AIPERF` suite schema、case 编译和有界 dispatch，不承载子进程细节 |
+| `test_runner_runtime_backend.py` | 增加 `AIPERF` prepare、execute、finalize 和终态读取 |
+| `aiperf_adapter.py` | 唯一的直接进程入口，负责 AIPerf 子进程、loopback API、timeout 和结果发布 |
+| `aiperf_contract.py` | generated config、progress 和 result 的强类型模型与 validator，不提供第二个执行入口 |
+| 现有 runner UI 代码 | 在 `/api/run_state` 与 run 页面增加 `AIPERF` 显式分支 |
+
+### 5.2 数据流
+
+```mermaid
+flowchart LR
+    A[suite] --> B[test_runner compile]
+    B --> C[resolved_case.yaml]
+    B --> D[aiperf.generated.yaml]
+    B --> E[ops apply on load generator]
+    E --> F[AIPerf adapter]
+    F --> G[aiperf profile]
+    G --> H[SGLang OpenAI endpoint]
+    H --> G
+
+    G --> I[AIPerf artifacts]
+    G --> J[loopback API]
+    J --> F
+    F --> K[aiperf_progress.json]
+    F --> L[benchmark_result.json]
+    L --> B
+    B --> M[summary.yaml + case_runs.yaml]
+
+    H --> N[SGLang /metrics]
+    N --> G
+    O[Fluxon services] --> P[Greptime metrics + logs]
+
+    Q[test_runner UI/API] --> M
+    Q --> K
+    Q --> I
+    Q --> P
+    Q --> R[ops status + logs]
+```
+
+AIPerf adapter 是单次 case 的直接进程入口，生命周期与该 case 一致。它不作为 testbed 常驻服务运行。
+
+### 5.3 所有权与事实来源
+
+| 数据 | 事实来源 | 保留周期 | UI 读取方式 |
+| --- | --- | --- | --- |
+| suite/case 状态 | `case_runs.yaml` | suite workdir 生命周期 | runner 本地读取 |
+| run 终态 | `summary.yaml` | run artifact 生命周期 | runner 本地读取 |
+| AIPerf 请求摘要 | `aiperf/profile_export_aiperf.json` | run artifact 生命周期 | runner 结果适配器 |
+| AIPerf 请求级记录 | `aiperf/profile_export.jsonl` | run artifact 生命周期 | 按需下载或离线分析 |
+| AIPerf 实时进度 | `aiperf_progress.json` | case 运行期间，终态后保留最后快照 | 通过 ops 文件读取接口 |
+| SGLang run-window 指标 | `aiperf/server_metrics_export.jsonl` | run artifact 生命周期 | runner 图表适配器 |
+| Fluxon 连续指标 | Greptime Prometheus-compatible API | Greptime retention | runner monitor 查询接口 |
+| 服务与进程日志 | 本地 daily shard、Greptime `fluxon_logs`、run log | 各自既有 retention | 现有 log/ops log API |
+
+首期不把 AIPerf summary 再复制到 Greptime。这样可以避免 artifact、OTel 和 Prometheus 三条通道同时保存同一组请求指标。若后续需要跨 run 长期聚合，应单独设计一个由 runner 控制的离线导入协议。
+
+## 6. 配置与编译模型
+
+### 6.1 suite 只增加一个有限模式
+
+目标 suite 结构采用 `scene.test_stack.mode: AIPERF`。各层仍保持现有分工：
+
+| 层 | `AIPERF` 分支内容 |
+| --- | --- |
+| scene | model、endpoint type、streaming、dataset、warmup、profiling phase、随机种子 |
+| scale | load generator target、SGLang endpoint instance、资源规模 |
+| profile | AIPerf artifact set、adapter deploy 模板、SGLang runtime 组合 |
+| resolved case | 具体 URL、metrics URL、run_dir、loopback API port、完整 source manifest |
+
+下面是提议中的 suite 片段，只用于说明字段归属，当前代码还不能执行：
+
+```yaml
+scenes:
+  sglang_chat_concurrency:
+    test_stack:
+      mode: AIPERF
+      aiperf:
+        model: example-model
+        endpoint_type: chat
+        streaming: true
+        random_seed: 42
+        dataset:
+          type: synthetic
+          entries: 512
+          input_tokens: 1024
+          output_tokens: 256
+        warmup:
+          concurrency: 8
+          requests: 32
+        profiling:
+          type: concurrency
+          concurrency: 32
+          requests: 512
+```
+
+Fluxon 只接受上述有界字段，不接受 `extra_args`、任意 AIPerf config fragment 或环境变量模板。需要新增 workload 能力时，先把它加入明确的 schema 分支和 contract test。
+
+### 6.2 生成单一 AIPerf 配置
+
+runner 根据 `resolved_case` 生成 `aiperf/aiperf.generated.yaml`。该文件是编译产物，用户不直接维护。Fluxon suite 统一使用 `snake_case`；生成器在 AIPerf 边界按该提交自带 JSON Schema 输出 `camelCase` alias，不在同一份配置中混用两种拼写。
+
+```yaml
+schemaVersion: "2.0"
+randomSeed: 42
+
+benchmark:
+  model: example-model
+  endpoint:
+    url: http://sglang-host:30000/v1/chat/completions
+    type: chat
+    streaming: true
+    headers:
+      X-Fluxon-Case-ID: sglang_chat_concurrency__n1__teleai
+      X-Fluxon-Run-Index: "1"
+  dataset:
+    type: synthetic
+    entries: 512
+    prompts: {isl: 1024, osl: 256}
+  warmup:
+    type: concurrency
+    concurrency: 8
+    requests: 32
+  profiling:
+    type: concurrency
+    concurrency: 32
+    requests: 512
+  artifacts:
+    dir: /testbed/run/results/example/run_1/aiperf
+    summary: [json]
+    records: [jsonl]
+    raw: false
+    trace: false
+    sliceDuration: 5
+  serverMetrics:
+    enabled: true
+    urls:
+      - http://sglang-host:30000/metrics
+    formats: [json, jsonl]
+    discovery:
+      mode: disabled
+  gpuTelemetry:
+    enabled: false
+  runtime:
+    ui: none
+    apiHost: 127.0.0.1
+    apiPort: 19081
+```
+
+启动命令固定为：
+
+```bash
+aiperf profile --config /testbed/run/results/example/run_1/aiperf/aiperf.generated.yaml
+```
+
+`testbed_aiperf_api_port` 由现有 testbed port allocator 派生并写入 resolved case，不增加用户侧端口配置项。
+
+### 6.3 依赖交付
+
+构建阶段完成以下动作：
+
+1. 从固定 commit 构建 AIPerf wheel。
+2. 解析并下载目标平台的完整 dependency wheelhouse。
+3. 生成包含文件名、版本、许可证和 SHA-256 的 manifest。
+4. 把 wheelhouse 作为 profile 所选 artifact set 的一部分发布。
+5. load generator 在隔离 venv 中离线安装，禁止运行时访问 package index。
+
+`resolved_case.yaml` 和 `benchmark_result.json` 都要记录 source repo、requested branch、resolved commit、AIPerf package version 与 wheelhouse manifest SHA-256。
+
+## 7. 执行与终态契约
+
+### 7.1 执行时序
+
+```mermaid
+sequenceDiagram
+    participant R as test_runner
+    participant O as ops/deployer
+    participant A as AIPerf adapter
+    participant P as aiperf profile
+    participant S as SGLang
+
+    R->>O: apply adapter workload
+    O->>A: start generated config
+    A->>P: spawn direct process
+    P->>S: warmup requests
+    P->>S: profiling requests
+    loop every 1 second while running
+        A->>P: GET loopback /api/progress and /api/metrics
+        A->>A: atomic replace aiperf_progress.json
+    end
+    P-->>A: exit code + artifacts
+    A->>A: validate and write benchmark_result.json
+    R->>O: read terminal result
+    R->>R: validate, write summary, finalize apply
+```
+
+### 7.2 `benchmark_result.json`
+
+`AIPERF` 使用独立的强类型 payload，runner 根据已编译的 mode 选择专用 validator。建议最小结构如下：
+
+```json
+{
+  "schema_version": 1,
+  "result_kind": "AIPERF",
+  "case_id": "sglang_chat_concurrency__n1__teleai",
+  "run_index": 1,
+  "completion": {
+    "status": "SUCCESS",
+    "exit_code": 0,
+    "error": null
+  },
+  "source": {
+    "repo": "https://github.com/ActivePeter/aiperf",
+    "requested_branch": "teleai",
+    "resolved_commit": "d72160e20957013d6608afcc88ed24100cb27dc5",
+    "package_version": "<resolved-version>",
+    "wheelhouse_manifest_sha256": "<sha256>"
+  },
+  "timing": {
+    "started_at_unix_ns": 0,
+    "finished_at_unix_ns": 0
+  },
+  "summary": {
+    "request_count": 0,
+    "error_request_count": 0,
+    "metrics": {}
+  },
+  "artifacts": []
+}
+```
+
+`metrics` 中保留 AIPerf 的 canonical tag、统计字段和单位。适配器不把 `time_to_first_token` 改名为另一套 Fluxon 私有名称。
+
+### 7.3 完成状态
+
+完成状态使用有限枚举：
+
+| 状态 | 含义 | runner outcome |
+| --- | --- | --- |
+| `SUCCESS` | 进程退出码为 0，必需 artifact 可解析，至少有一个成功请求 | `SUCCESS` |
+| `START_FAILED` | venv、配置校验或子进程启动失败 | `FAILED` |
+| `PROCESS_FAILED` | AIPerf 非零退出 | `FAILED` |
+| `RESULT_INVALID` | summary 缺失、schema 不符或计数不满足不变量 | `FAILED` |
+| `TIMEOUT` | 超过 case deadline，adapter 已终止子进程 | `FAILED` |
+| `CANCELLED` | runner 或 operator 发出取消 | `FAILED` |
+
+首期不把普通请求错误率直接转换为 case 失败。请求错误会进入 summary；后续性能门禁必须使用单独、显式、可版本化的 acceptance policy。
+
+### 7.4 不变量
+
+- `case_id`、`run_index` 必须与 `resolved_case.yaml` 完全一致。
+- `resolved_commit` 和 wheelhouse manifest hash 必须与 staged artifact manifest 一致。
+- `finished_at_unix_ns >= started_at_unix_ns`。
+- `SUCCESS` 要求 AIPerf exit code 为 0、summary JSON 可解析、`request_count > 0`，并且 `request_count - error_request_count > 0`。
+- 所有 artifact path 必须位于当前 run_dir 内，并记录 size 与 SHA-256。
+- adapter 只能用临时文件加原子 rename 发布进度和终态，runner 不读取半写文件。
+- timeout 或 cancel 后必须等待 AIPerf 进程组退出，再写终态。
+
+## 8. 监控与 UI 设计
+
+### 8.1 指标分域
+
+| 域 | 代表指标 | 来源 | 首期展示 |
+| --- | --- | --- | --- |
+| 生命周期 | status、phase、completed/total requests、elapsed | adapter progress | run 状态卡 |
+| 请求体验 | TTFT、ITL、request latency、error rate | AIPerf summary/timeslice | percentile 表与时间曲线 |
+| 吞吐 | request throughput、input/output token throughput | AIPerf | 摘要与时间曲线；goodput 随阶段 3 的显式 SLO 配置加入 |
+| SUT | queue depth、KV cache usage、running/waiting requests | AIPerf server metrics artifact | 与请求曲线共享时间轴 |
+| Fluxon 基础设施 | transport、KV、MQ、FS 和服务指标 | Greptime | 按 run 时间窗口查询 |
+| 日志 | adapter、AIPerf、SGLang、Fluxon 服务日志 | ops、本地日志、Greptime | 复用现有日志查看器 |
+
+请求级 `x_request_id` 和 `x_correlation_id` 只进入 record/log，不作为 Greptime 时序标签，避免高基数。
+
+### 8.2 关联字段
+
+| 字段 | artifact | 请求 header | Greptime 查询标签 | 说明 |
+| --- | --- | --- | --- | --- |
+| `case_id` | 必需 | `X-Fluxon-Case-ID` | 不要求 | 逻辑 case，由 runner 关联到查询窗口 |
+| `run_index` | 必需 | `X-Fluxon-Run-Index` | 不要求 | 同一 case 的第 N 次运行 |
+| `cluster_name` | 必需 | 可选 | 必需 | testbed 集群 |
+| `instance_key` | 必需 | 无 | 必需 | SUT 与 Fluxon 服务实例 |
+| `model` | 必需 | 请求 body 已包含 | 可选 | 模型身份 |
+| `endpoint_type` | 必需 | 无 | 可选 | 首期固定为 `chat` |
+| `case_key` | 必需 | 无 | 不使用 | 配置快照 hash，不进入时序标签 |
+| source commit/hash | 必需 | 无 | 不使用 | 保存在 provenance 中 |
+
+长生命周期服务不能随每个 case 动态改写 Prometheus label。runner 应在 resolved case 和终态中保存 `cluster_name`、相关 `instance_key`、`started_at_unix_ns` 与 `finished_at_unix_ns`，再用这组条件查询 Greptime。`case_id` 和 `run_index` 只需要出现在 run artifact、AIPerf 请求 header 及可选的 run marker 日志中。
+
+跨 AIPerf 请求时间和 Greptime 时序数据做叠图前，testbed preflight 必须检查 load generator 与 SUT 时钟。首期允许的最大时钟偏差应固定为 1 秒，超过阈值时 case 在启动前失败。
+
+### 8.3 runner API 与页面
+
+扩展现有 `/api/run_state`，增加一个按 mode 判别的 `benchmark` 对象：
+
+```json
+{
+  "benchmark": {
+    "kind": "AIPERF",
+    "status": "RUNNING",
+    "progress": {},
+    "summary": null,
+    "artifacts": [],
+    "monitor_window": {
+      "start_unix_ns": 0,
+      "end_unix_ns": null
+    }
+  }
+}
+```
+
+不新增平行的 AIPerf UI service。run 页面增加以下区域：
+
+1. workload 与 provenance
+2. warmup/profiling 进度
+3. TTFT、ITL、latency、throughput 和 error 摘要
+4. timeslice 与 SGLang server metrics 曲线
+5. Greptime 同时间窗口入口
+6. artifact 与 ops log 列表
+
+UI 服务重启后，历史页只依赖 run artifact 和 Greptime，不能依赖已经退出的 AIPerf API。
+
+## 9. 可复现性、性能边界与安全
+
+### 9.1 可复现性
+
+- 每个 scene 必须显式给出 `random_seed`、warmup、stop condition、ISL、OSL 和 streaming。
+- endpoint URL 从已解析的 SGLang instance 派生，不允许在 scene 中另写自由 URL。
+- load generator 与 SUT 首期必须位于不同 target，避免 generator CPU、网络和 SUT 资源相互竞争。
+- 记录 AIPerf commit、wheelhouse hash、Python 版本、SGLang image/commit、模型、tokenizer 和完整 generated config。
+- server metrics 始终使用相同的显式采样配置。AIPerf 当前 333 ms 采样行为本身也属于对比条件。
+- raw response 默认不保存；请求级 metrics JSONL 必须保存，以便复核 percentile 和异常请求。
+
+### 9.2 性能结论边界
+
+AIPerf 给出的请求指标覆盖 load generator 到 SGLang HTTP endpoint 的请求路径。它包含客户端排队、网络和服务端处理的组合影响，不能单独证明 Fluxon 某个内部模块的耗时。
+
+SGLang `/metrics` 与 Greptime 指标用于解释同一运行窗口内的服务状态。两者采样频率、时钟和标签不同，叠图只提供时间相关性，不自动证明因果关系。
+
+### 9.3 安全与数据保留
+
+- AIPerf API 只监听 loopback。
+- generated config、result 和 artifact path 都要经过 run_dir containment 校验。
+- 首期只使用 synthetic dataset，不接入真实用户 prompt。
+- `raw: false`、`trace: false` 为固定默认值。
+- endpoint headers 在 result 和日志中必须经过 AIPerf 现有 redaction，再由 adapter 二次校验。
+- 后续鉴权方案必须使用专门的 secret 注入路径，不能把 token 写入 suite、generated config 或普通环境变量。
+
+## 10. 实施阶段
+
+### 阶段 0：依赖与样例固化
+
+- 确认 `teleai` 快照就是目标版本，或取得明确的 TeleAI patch commit。
+- 构建离线 wheelhouse、license 清单和 SHA-256 manifest。
+- 用固定 SGLang mock/fixture 验证 AIPerf summary、records、server metrics 和 loopback API schema。
+- 保存一份脱敏 golden artifact，作为 adapter contract test 输入。
+
+### 阶段 1：终态 MVP
+
+- 在 suite schema 中加入 `AIPERF` mode 和有限 workload 字段。
+- 增加 case 编译、testbed port 分配、generated YAML 和 isolated venv prepare。
+- 增加 AIPerf adapter 的 direct-process 启动、timeout、cancel、artifact 校验和终态写入。
+- 增加专用 result validator，并把小型摘要写入 `summary.yaml`。
+- UI 先展示终态摘要、artifact 和日志。
+
+### 阶段 2：实时监控
+
+- adapter 每秒读取 loopback `/api/progress` 和 `/api/metrics`，原子更新进度快照。
+- 扩展现有 `/api/run_state` 和 run 页面，不新增服务。
+- 增加 timeslice 与 SGLang server metrics 图表。
+- 用 run 时间窗口和关联字段查询 Greptime。
+
+### 阶段 3：对比与门禁
+
+- 由 `test_runner` 管理重复 run 和基线选择，禁止打开 AIPerf multi-run 形成第二层历史。
+- 定义版本化 acceptance policy，明确 metric、stat、方向、阈值和缺失值行为。
+- 对 percentile 门禁优先读取请求级记录的 pooled 统计，不使用节点 percentile 的平均值。
+- 增加跨 run 对比页和机器可读的 evaluation 结果。
+
+## 11. 测试计划
+
+| 测试 | 执行模型 | 成功条件 |
+| --- | --- | --- |
+| config compile | contract test | suite 字段唯一映射到 generated YAML，未知字段快速失败 |
+| dependency provenance | contract test | commit、package version 和 wheelhouse hash 一致 |
+| happy path | 直接启动 adapter 进程 + mock OpenAI endpoint | exit 0、终态 `SUCCESS`、必需 artifact 存在 |
+| request failure | 直接启动 adapter 进程 + 失败响应 endpoint | 错误计数保留，至少一个成功请求时完成 |
+| invalid result | 直接启动 adapter 进程并注入损坏 artifact | `RESULT_INVALID`，runner case 失败 |
+| timeout | 直接启动 adapter 进程 + 挂起 endpoint | 整个进程组退出，终态 `TIMEOUT` |
+| cancel | 运行中发送 runner cancel | 终态 `CANCELLED`，没有残留 AIPerf 进程 |
+| API isolation | process test | API 只监听 loopback，testbed 外无法访问 |
+| UI restart | 启动常驻 UI，完成 run 后重启 UI | 历史摘要和图表仍能从 artifact 恢复 |
+| clock preflight | process test | 偏差超过 1 秒时在发压前失败 |
+| offline install | clean testbed process | 无外网条件下从 wheelhouse 完成安装和运行 |
+
+进程生命周期测试按独立脚本或进程直接运行，并显式检查 exit code 与残留进程。不要为了统一外观再套一层 pytest 入口。
+
+## 12. 验收条件
+
+首期完成必须同时满足：
+
+1. 用户仍只执行 `start testbed` 和 `testrunner`。
+2. suite 只有一个 `AIPERF` 配置入口，运行时只消费生成的单一 YAML。
+3. testbed 无外网时可以安装并运行固定 AIPerf 快照。
+4. runner 能区分启动失败、进程失败、结果损坏、超时和取消。
+5. UI 不公开 AIPerf API，run 结束和 UI 重启后仍能展示结果。
+6. TTFT、ITL、latency、throughput 和 error 指标可追溯到 AIPerf artifact，不经二次重算。
+7. AIPerf 请求窗口可以和 SGLang server metrics、Fluxon Greptime 指标及日志按 `case_id + run_index + time range` 对齐。
+8. 现有 KV、MQ、RPC、FS benchmark 路径和结果校验保持不变。
diff --git a/fluxon_release/closed_sdk/lib/libfluxon_commu_core.so b/fluxon_release/closed_sdk/lib/libfluxon_commu_core.so
index 0d1a1d3449bba46486f9296723538b5cde4e3bd1..ce9458d043159b8d39c17dc474a0b9a71c89a0cd 100755
GIT binary patch
delta 6083184
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%0A|Gq@~a7n7WRJ&)N8NXVp
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%0D|tbMOX)a*u4{0
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%0Da9%G)t6a9-0CKV>
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%0Dg@<Kk}^Z`7^Y+S$x5>H%X>QZL$Z>noBtlQ
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%0A3vD-%=WpyOA
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
z%0A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

delta 5335447
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%0AZy||C9!4+oOUURc~sp7bB&Vt*p?Ve
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%0Aqe(cI3G
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%0DPhOX}QH3lBbqX2yi^6d`w~AWq6_(G;3`f{M^S
zarY_jj1YHoqYxCX$ik=P{~*ZBe5bE$62U&EHjPzLd{zlV2Uo$8qaAoni+ij!ejhCY
zYtT&|<&K1>5UlGy0QMDt(Ht19CQ|iWL8R)8zr~9-k7z8-fPiT*D#4$({U6KpT@M9>
zcJLPfkLTNx!9jIPoWT)WQ6l6S+DswN!Me<J6I8B^SWKJT5Wf{Et0nbLl%%>=s4Eya
z^C_F;7J*c=%lQ-;B<zFt#risvGsm2>Hkvp~<wSkCzs!8VF+0V0TWqgB-jBEG_`GK<
zI;sh*s7mfn%5P<-oIdEjP?2n-9nB|<kg3nu2>1UvP*Z<m?OerMXiEDW%ZCPqrj?;{
zq0-m>C|p%cbZ*fL6kI;rR4^A-6cObY`wt58l8JE|)gLnz=b}59v&y;nY@Sjr4b_aA
zreG`6f=B(51z5$@g!JBOTj(X-fFk?Lu-YqkP5}*5o92~<0WOQuP8Dg1m1&7ajoTEF
zmQtCPf(fFeWmcwTg4B~mxva{xETd*UL>t=3u1w3um0~nNh2t6wgQ6TpZ2lPLfb$G`
z7Xf$N<bj<Gf6uNiLN3Er)x2VzBo_$MA+I3I#?Hd3?-l!1Qcc0u*lTQAb@~jNabban
z`yA3rh5Kv(RY*&t=5Ne>Tvf)r{j5HtynG515-8~*U+4#{2slz4->^^W-2K<?JuP)?
zjOau}WhbyG$b$|PRIE2sWLBf1TA@xgD(-}u1|_Odu|!F$M#VWwS~V)BU@+gO;#&wk
zP?4{-FZ6Jo`&o5*O(84yALebflICvG%ieCmWz!MK0Jhp|@#B(MJS~Pkl|?B@(Jzde
zTJv=LhkroWEU3kM|FF7#kr*Z+G8D%|-!5<iycDEzL6HV;S$NGAP{(C!E%~-D<GiF?
z=yIaJ<^U8}b^80j<X!WYg-Veq^V3`GSrmPVny$hO>;PkqKd>)s#3SCZ@Z7ceAJVg6
zqDZSo&-xQYS~YrlDQVT{X|1GHqvv5R>Q>`Q9i|T$lK=dU)pm*n5@mM;dWle)#&@h=
zE}teURU7Du%3xJPEMWYHh}kP?)ew8B7v-uUwqub<tA^Onxkv+IfBwrNnneJKG8||C
z!`6o;#`sh>sG5%u0IIR-GkB8znm*h&_bX*`SL?ylPeg@kJqT4Wt43NEC9PTy-swc$
zYCZTKT=PDwjwXGOf3)r}G8~e=7i?%4t|Bqj6<lo8q~ou-NVNDuZW=eOI!mvEbS<xw
zR@k^gV(5G;q{W=~icVUpsD;&eioucCPhYdcOz7hB26#iNxS9p#D;5;PDHHy1X37Mf
z?e{2nj<F;>vyf3?VJ>_uw{#B{$qq=aLL4GL(Nb<9P0ZEtO%IZMoA=E{#{p}TMa6+}
zPgqoehM#s~lMv}&ARTwAfb*(=2sL=tQts^@EOH&H<)VqaAL0I;h{fxVX-%X%vY849
zI4UbD;B(_4z?}@nF^3CJgGx@3(x7~OBsnA~RH*63q@jnUz>O+2v}y0e7|JK>c(x=r
zkcQx6z9jog-_60+xg?Km@Ee&Ph5314Lm?8Iq~w?92|AJ!qC6C5lkqRfj>5)!Z1@1z
zZmv!XOcut?cZcW|dhO}71iN+wM}#8@Z>_6G<!|UeqahnbaV@XhL;4oo72ef(5Co(e
zufGM9N_$Z;5YB#-6-snjXDvslLrG#3?W0f)$m$7*%IKHXT!ppM@P1jJ(!Y25Wkto(
z?5!wNNK>>(T%BUbbsz)nsFud4F~XUs$v*!OP1`{?D=NFDJVSbkHThgk7A_p`i5Lb=
zmOn48Dc6?fkJj-wnk?@{HnM};u+a+2&EHV{VCY<QKhQ>QDXGR{WAt312hXvQ?@5ct
zV<m1YM@VDvQD7^_)SCN>YD|E}s^C0+))v(GS#P4o7R*UP&G_;|YHaPB?C#zE+<&ef
zGIrSVVmrCD)2FCt)C`6O6I^%0PHy98nT4S%%m_@ge3DYo(PUm$B9Le=C)OEXeP(`y
zNl;;%jsVF_M&3-Fj&HD+eM8<W?n!g3+J<F&l<c%&gjeqWuz*#pFECGeBf&w6&5L7M
z*ReYRfm5CVWd*JFf#`dH%3wHR=X#awY}70_Es7sLr@mf<#v-s-qSN4R*rZJIb0X7u
zA9AbM3fD<GfZR@4Xba|hG)^IR0t#1^GFhjNC^==Esbqgs$t}-5EV<QD?xRUU1~$o|
zWvT#SQfLOZs)Z?B&Gv<ZQ0oNX4KULQjXKVzN#6hI2f%TuwV04KjG?cG=(v-!T-PTF
zCz$hJsdB6kt62`UydF~mp>dnL!?E;qQo>O81^**lCP6n;;X*8WE-g)^g~$6`S{wRz
z%E)3*e)?RRy}ec;!=Wdbo`0Q7^YlQ%@%&zZE4XnX(iNhV{+br-x&#Wrd^I{7#=~>9
z+^$9~ltVjPM<j=8#&>_8C+=kG_@^#%6RACB$u<``D!_Ft20w}z1CO1*r}p}1>K4_K
zYx~uCOnq^M*fnY#@wci+WUD9Ek|{!HS{HPEN-a4=)k)%OYRO-_s~%A`vR|tz5Nacn
z+d5$SR(dh`R#&;D+73x1Hn8wPjK~Pgbyqpo^Ux@>RBxzZa_;<Z5?owva&7gW52%IX
z5O5}=Jn;9lVE4<=dt%w?2vtUlKZNgNQM<=YPVnk3Y9vsN_XOS6-_vSar4EDDRBDjD
z_~YNx)RJ4a;>_`U+g}--pYBtGyC4Ql4c-XNX=y!DXMxv3=J(#{DLIbBHtWB!o(=v7
zTo0<zxVZ8~%(LrAA_?3OK;CaX${nidNI5~@1o>H&4T6=p%dx692uyUBy={tOq)t!4
z3B2K?g#NW2{!KM5!rG{mC0Y-e&J<*)KZRXN2k_Dg{%24%llW#2d5hcQGOBPH)>~B*
zyktyPZ>wp@;s1`wYG&UIxfL6PH*Tdhw(o_Bmr^uwnBj3R?teRNytFPEdyTotzLE`O
z%snr8MU62-1PwB0@6<?LF-g{V%h7QGBC#3`9FRmb=zH%FR`@3>qMLMGfh+EsZjS-R
zI;a6;v5Su!B-!C3#s^Y;GK7HaBlmX8yGtDy0g(j}i@%D9^^xmJ3oxB3*KKZE(|qz2
z<y9yNN@}MjdrPfR?jv70-hKNW0<{d1tcn)IpT4rMl>nPKHmj-haFCAM`pID~KMYcM
zK!a+^Oic8H1nGx-A;=O;`SWgnIJ{@6<j(_5CASPzAQ^9cSTfrmC0kXL3^0`(`yVBv
zo~I#Va{v|%0di!_(g7GF$X=hjBzqCDd6PPKhM9K`v(-$NT>^8@4UoI5no9gmfZVV~
zQOw=8n8V(Iav!S`ARlLw68vm;{Y8LEK(rNsa!={s{-#b`H%*C#$giTGLYSx^d8E_}
zC6@=uK2j_`_6Nz{(p^7i{_T~xP>&b=z%79li~)3wnp;TX4ZevB<FUbVptQIj`W4g8
zN1BKar$PAm2p>y=<$#*8C|TyE;`6&T)u;mc@u2(3?y8#oxXZ7}?$V==blj%49N~NH
zBk;zqd>aHjK~P&ee@5PM1X?$_f)^UnYUA+2C;ER8ff))D>``A-3X$WbE%-<Yk%Of!
zJ_@Gp1N(k}X$A_d50TeN4`{Bhi*c3a^}&{8s2nbRjE@C)A+3RHABD|pH^t6YBu*zn
zM39V4!Jqd!Zs-krB}`6~9zf=G36rz^ms}x=PlvRC6^p;-)TNEBFxVKEhYGo<MW+lu
z+wzi^;DyD#VC#g-O{J`%*fx8WR>!GHFHuT_%>~->POsAHO3yGmC%%Fw?<_t7B4kf5
z&1GuO2+?QW62)9)M#x!GTa=^g$*dwVclm^KX|?&BDKng<cd*XhM957Xj`vj9+5HkE
zNXt5MW7ph|m6Sg&66C|c75>}(Ninu4saPT+7|St8)HE6x%3)u)j@(ZbHbm^0_^;>z
z5QP()<1#Jh=`Dq8?`ZSXqFi`H9J=cGxVmy)O<KUF72M!<ds&Rt4^VbuXHN<Puck)I
zpVs^ylC(1adAExE9?*SW_2dXu?ZKig?`6m`wUrYKBgWK@V`m-zmO-*;TY~xP$#v~l
zV|icR&ZrqVSjYWjy@&l&N^nA;6cXk(&GF{y`m&#@*&qe()~+Bwz|p+)<v1-e4J?mq
zWgs!8_DS`Sa?z0q_2p2hCq7D0vvEcXz{5_`c*qj4irMB&406aS9etii+7tQkCE_oR
z^jzHHt|B4jJk+OF>cHw&<oBb+qD{)1f{pM7vTw{eNEAS>uq>6GpEP(@2>7wz2>7=s
zV$KQRxsnEQ7|DsOQV}lS`FJdU*Z@6^k+@?+xr5j9U#a4C$RP8I#6sGJax<&n(?R<R
zwQ9}1RO$9XCGChf6LIfPE6^TcC&ru@5KE0QhO2mXI@}(6XSwkM!RhMwHccz|rh+JK
zg+`4;dU*?Yq0w+f4!r|w)YJj=@&H8tL&)`rlKmYno+Av8WCKGi_M+sJh#Y(?+bo7l
zE{Y?Pi9&s-P^EQH%o7(QqQNo-awuBP)QlmfD{OoSel?5K&!(uML7E`&Z*g*p^csTB
zX-TqQ_a|UHS`|YC0<VfdP95GB0BZY@NGGV{luV*~v?)BZz=n)Hqape%A?t$z=6FOk
zl6~C$6~oi{i^Dc2*IVkM5TSGJNGu=F2&3UIEjpUuVOwQbl{Av0RShKmTO&Ecvp#Af
zm^j4}_qDuI$y<cjjnC5YmW}1m=!F=f@};0hic~KoCI6jD#)}O1498n3l==B*!e|c(
z)rzMWiW|#e;o*`6F5a^oAB$5Om)o{PZ*P}-2_*o9F0SMLpW$X0Y?sDz8+APa#2r9P
z)>Bjyu$4F1s)-zcQy51}WBDX}QqosVp!NOI5Gve6j`Vrdk;dw}A>qu2%0{~(*~5Kp
zG$>td`Qut2Jhw6`!&Qodpc)h-x3DUKROZ`OWVqM;x}E}WiqMuX4KshD?rD(^+X8>9
z$j)!X$aSR8d+4}BQ#r=jUKD)Zo9G}UWK*c?P901-v0(>g9_60?5X~D+!E<h?XyUm~
zaIA;A<btwzQUj8@s!{mUo5>%!uK1C%3Mi|R>ZQ$OKbNfPliXsk$zh*kwiUF|v_cCO
zKpd*U#}r6xE(fVbnpJS=WU6rd6t%h)j4`jd+#|9ltz026fa-q4ZV<b66D3+9qY7nV
zFlF~&A7z_dF;|s<+eP?IJbm{hXksE-t@Kt>d)ScMTFCxZMQt%E{ab&lY3?A3zBJ4^
zjVp|>Mco$afu_&Yqjb}{m^__Pn4q-)G`iK4#sT7q{P)Ri6#xB;NHaUo^L(T-B>PWL
zg|DGiOh^Q7Pu561QMUQ^<aVmvJ*r6OzJzoS`dL@hal<dsySx?pXjMC9s9kgrFjVG;
z;}zCmajYC{HKG+dqmGlkRH5yJ60mYYK|c2}u6ujZ7Kbh3;K?|Rk10n+xVN%HWwS-~
zYIH88aGWPCwr?Ok&=e|JC_4SpaODScwt_i(Dj`<oEAayW3hT`~0@mAwQwbx~Z;w%D
z??U~UI$JUzJxG;cCQ_yEB24?#UqvV#nIY<or8<?e&t%QTXEau|#(|3XjCS<zpJ$Sq
zsE<+$>$(tW@*oK@2Cd{g>3ouo|E5U~k=AA)5Hw-5Cj#;l9Hf~@4suWTk_I9<-aXyh
zHa!XAhA#T#=U%6IdWK{uNK86HV25<BL_DhA#+j-_7%C^?d?bbsT3jXcNQ719iB_u?
zS8b3)jPdzl8V?cshPQ+v>1vGc4YTjq0h}4DxUrlEZAx=nG$*SDf0-zEZ14t+E0Ypi
zYr_oXxL=vL{b?!Tauu281c63Nk{eng4y5+_mPFD&ld$XmtQBb6GTt-h62>1(CAA?d
z3YH&uSdIGV=E3IGu-%Sg#62psfyr2MI>Ftx1~fbcs=(dVInG;(?S>-*tz}P#^@j+L
z1)YEg7ALLc1ecFQN-|O^h@Yw69I1*&&|4chQZ@K3pV}raOv*vR*{K^mq~7@GbSTEh
zAue8NcFsXqYRB5hfeyp)h0qoVe*k~nMvm~oZG&__?JMAm2XWsCU6BOoKB`Ge-ncE~
zwVTBIw3QR;Za+X(m!+B0r!vL@Ayh;O(s$m$igcRlr%W;9{H`@42K!<B;Tn!Zb(3^S
zf{{lwX(8a&Mg~poz;<%5>eDw$k7mc3dZfh%^{7FYSfxj+_S1S2X3fNGLk$cd0h)_6
zc>16^Dy3)O@se~EthuqrOMK~H;-<(IEkEF<IY=UI`g5Q8j01@>k0g6Z<Nk2qqmIBR
z*z6<190NZ0QLq??;t2nS7O2iLkK1E$aJ2;j!u->H!VY1e2|wp*z{Omv4EN6uP>A-o
zca>ZUI^(TW{BAEbvm&*6Go+5TCd;{2KQxELxt^U9AgyYyNGs=jBvF&UeJ^GQ&r6YI
zNrl|!DRNZQFU^$P0OXn@4v5ORW;}CL@DG-bm`MG<!}_UvV0wa`O&h`Lo(5<B@QZ%U
z8Usk#FW{QAqKVjp2ZCe5Ft*in@>}WvW(Se>)z1zld)*}rf$%};v!y?~AoQSvoanR|
za>ZmUw{H()eo;UF+!!!SZwxUYQh0TYaLF|k4ZR6L9<J$9!F`~V5SdEE?OHF>j10-A
zGei>u4ISe#HJy!`-yoT>M8;o*b0Q2+S}UA$Y8MfB2XaW1^u(y7@kKC1r3=yKGBm+W
zk)b}}ZVCbWi+ZW3SEaB6c~)(!ueO6~$vi7p>I7r)6weBCnfx8KF%+WRG>I40PWP7H
zcpxq_O&+gOXJSu1xxf7u$PY4P`?o=mYP#%StJ6-Z*Br#J<Z5*%xv_N0#Z2vGu5(c^
zy1s)-pK5J}Q6-Q4h7kinZ1Q3)a$G7L10F_AtRtFqu1Kf>x@IC=L*5$B|Li13dbJZE
z8xqL(6vfuC^dRqvbN<siK7EWW?~@_Nw(SQ?Ed`fnV__~v2~idM=m$K7aXO2q&SS-8
z&qJKgTfZ&*Pe|5)bU8zA+4x4({{?9bAdv_^z6^#$8XoS3azJD@)JJlr+|I3Z8xdur
zNL+)zLc2e1-Of`L1tOn|bN2}W=sso+<4T%6)hP3_w~N`lj5iTGRKRrx#P=yv{997E
zs-cdTB~Q8Txs_Uf1o8NOsq8Ltfn?tR?x{(meWVBVAuqbh!7ho_t-Wn23JPB~B@_aj
z$72yxwiFW&OAE+%{^Xa027G&0d8BK@Z>c3OBv!FwR5!VyW??<hC;w<7Xk^+}D6gaA
z$A;tt)~m_^xH<|Gt=UX)=7Ol^7~@{GZX3KU|5ilvQ&>_$*<8ZM7~^_hcaz~|kIGfm
zpzDn5!<{LwXdJ}EOT&+?;D*UO7~>&~vB$>seN=Uo1H}uoH+Z_&6`0}z&FhBLHW<y`
zMvY~xZsFVwT>_Csg5<kz2s;wuRm~`d%hn!pU8`xBVZ1axxw&)=eH5O$L#BQ?qvrc{
zGJDFMrLHKsrYH1zJ$w{5!o1|6<`dt-20oiCIWp+inwTm{M$H?@R|t`V+6pZ%<kB+O
zSbehOy1pki5Q^JSNQptrPq4@dhDbGP{JJWG`IDxKpM17x6uOTU)q0^?)%YdeOz^Y}
zSDaqIhbvC61K~P8dy(GHHk`OtvBZ1Hqa<xJoNnwTyW0<4PwjWce8<}NP>hGy@0K)m
zDz`P3gGQ)F8YHl{?B6xEI>)Vmu~yw-Fay*k(P21`B>`6PQ5HD?5bU`19PP}4Zm%x)
z!#ZL_U50u|bukD0T!sdR-hqxRZv;m_m=}Z-n-A5ScnWp-thXH2Xm10B8g<uEC)`lM
zsBywy^O37O?0_`^l!!QdIN4D-eCW{!@{Blb-`50SEfk5;)sjAPGZl2tr9N_KE$AvL
zlPt<aqYOe-TcpQ1L$yFa6^rR*6^!xhD~H=&4pOj=;{%q(d35SxUT8D&gk_sQF;L2}
z6&k1D6;#jEqgw$*m_!9AL#?s3gi)U+=AD5V))#BaZ)=;FbzW_y?DaJtGHYU!^cX3@
zRMH{PR8otQJiFPa4W$xjoq<=9!z_b&!Ik8u_^0$ra$Wae0kKSPG@7wLY|DOfqPp*D
zLaBWt!E?kA+W7R(r7~#Y8m-b(q~#7Unp&kdm#zdNqBL8sFP(<Q+TSWY&|y}fg6PGS
zXx?(@6!%&)J(QGPNP!C(GL;7&i}9~fR6ouNOO>|AVlu;T1kiHP6!U8)afyp7rS55W
zWtI$VTQy69+JR|_h`*N*^g|8JiKq;4@c`i0ECAv61F(kQ0kQH^Qo5JVBY%uu{&8^u
z?&<F#Qv$&?sE##&a3J~(C!qs@<02sc1OBVxHJE?{Wvv7`$&U_{M+F@)i8;**!omor
zLseM?i_AfCl;jIRQn@+d|HicDTD6=i&8b!iMrPi}8R^nJU$|YT4fn5g+*iTI9feKH
zxu|dZd8n|a+Hfzau?pp`-AnRohhjvIC0_|k7}w~l5f$NS*n3RbjGcybqh=K3dliC1
zip_+8C3=07CocRZPz`g|Y$$+{_D+I-t(nl=X31jVoerhxqbN;v4yu_eO<w#l7}*Kg
zLh3#;S+5DpK4j$Vcz7egNR=)>Y3=JA5l0<a^g2iM>xZR;{}v!wg})%MiAxN}7VyrW
zBzUNnVrziz<e)RC>M1IPDnmr=%(~qFQL>-gxo0`mEu1eQDFcSeL6$z8JxUJsZe=p)
zuPvcQPeNZ*8e4fov4Z!y=%l>tPzTnfxkDeZyzX8I3>pgM@yHX~3d7_8uTTNS8BlO9
z4E~x)^I@`A&DvH(SIoa3vOHC&Ll%g7u;+WkEE$G&Utch_Ym4mn+I<1~Sq?|Lzu+Tc
zING&dOxQnyR)8ZEf2-Qf9xg{(EnEokFmE_QYwDrK>ET$T&=_QllszPiKqsE~IKf*w
z?XKhXMqopw#2u6@9G8_=I4GM=KebFR8iPw=>KDKHA5M6TkUKcHL<z{sJV-giU3Vv5
z+!niSE~tNZgdBuP|MWFVI*ybRr1cunOgrxz&?E5vdXo2d5-bu=#rt~>wya=<BO_%m
zD;Ep~531A0M|uN;JIN)^SIT#A<xif+y7GpjWVPQr$X_TC;Vq970(L2QjgHpb3IX$F
z3=RyL01KU_^p^pOg<ramNV5?YtGJ2hWu(J-?<V{<sz5iPWF;H4`AY_T7x!K9@yCd8
zr>Yu?Td019yQNz3J<YW<o93RQ>=fo(_60RI6XMx4e@jPWSHTYO9*oAe*n?VFka~4%
zuU=CNNEYrm3j(IKc#-45qX)EeRZXp>AT*+uf>0L}Ph3>sA!Xa^_@Oa!J1Oc}4zD>@
z?&Nd*sWMj{EuaQ3LCaJPdFj@Eo|d?;7`tUb-C?l8(G*3FCR|iDvAGgPYz&P<2Bt8q
zw9ND-k_Cq0<yg6{YUwYEk@t<-WaQ1qhwvzjQ!8COIv+y6NGk`ruD}<ZmQV&}ZENM!
zo?W4aX`xkwjpXnf5WBd|Hvq*d(p)JG9us?0+SH>F6<$A2lLogCu>Xe2s2T%aayY4p
zceb-&B(aS^TR60hfUTl)Ad%R@Y4SX$${&^V+zI_RUC%S13!252OC3P1U?OE#<Q}91
zNz{O1>X9wAS}6sJ+vEiX5)@p_RhW!x=f?-86ei;To)K^&MfEY>An|zipX5YKC+_k#
zIZ!&PQclk{zmLxRKfbO5E~?}C!#%L$fpByL^srF`D~jk5KtMUf8q{cPF*X$M-KnvG
z0i%d0n#kIF?;3kS>?X!&qA`|O()17u#%PR2@Bf{B@3^A>pP!G%+d8wev$M0ayR$gU
z=PIv$BsAa{h)XJyF=Q@5Q(}&?w2{j>eyz4O`qWlWy7gEu={tdM_1q1B)3V2U=~}Jp
zy*E+|hR&fn(*s!hH%VcRwb;lvNq*I9QCCyVEb@n0BdT^rn0mhGO;QtK79_**KADY#
zCm`U%KAHZ)C4AKEn;9f*!$(Bl%zDxmxvMy}oseF|fprn5`g-Am2sU{(fg6fpEA#tZ
z1NdE672A`>7*F;lacA`^$ndA5f#oVR!OeV}CCisD)`etus$3UR0M;om1hgma!J7<9
zpQ9Wd!xdD}CRdNsHHgt;xJ!LkOKphdN@yELNx|$bC7Ed!!^Oi9OzGv=WoqYZV8VD^
z)7riTgs~Iy(vU9xEVBvZRna5JtH{qXJNdV*PTVC1LH6M;*&q5gvg~U@Igq=1z4O(8
zBX^KsbA73DZdzAMx`O+*OmEQxyniW^`sYYKfnN`qE)y*MZPLe1nMU;Em^Miv?AqI;
z#({na5_O-=q|CRVTUj#*);Lpijk2*G0dLuyMZNCM<802Io<<z>bqI4Y<K2^=$7<N>
z|0Xb<twP_EG$b5ACrgaP$aKYHfXPXvN1ymj)cGe?v#n$OJ9S*Cf;tK(O)zd5PKFt2
z-cZ)AO>+oo%Es;{7dCmKF2d<X9@ugFL|wLU*4e-!C+Ru~6Y()+k}h4?4;gi7k}lAx
z-xrWT&nD^A^;KXe@<J1UWmHQ3FJKH?<O8rQYgeTA?%x)QR|@WKWEo4_!Pz9fCK%U$
zN?%9RIfOy=TD6hkh?=95`o;zHzi+%UOj4+hOy`}3i3PeX|6Pn<OP{cvlc9ckIblMd
ztZU%=Sdb)Tdla)|;xkCl%NUhcAfydQT8%S5QL`Fe4J_A7E<PST)3XkL$EaA-qeE)6
zJ`XWZ=b*Nr7fE`;4;9UA|Fx13TboCS%|W6aoR#A;8#Z+T9;iLqIO;9hQy^9|@4m*T
z96_7uUyjV)5AK1zUyRF4a9a%FghIoNZC=3*2KHmvuAc2Y;>u>%1c9)8qnCXMg;cVg
zQ$9h?huSE92=Wo{F3ly>zQ8<ZW^~`!hJp)3<3!)szQPWSZ0<^I%LiJG3L_Xp*|_<0
zD)SX)CQhuK*}71{2N`c?WA6OV0e8jd;|@N&b8vFx2tH!yV-Y^+YLo9Y2Oyuz&!9Tc
z!*2WwR;`zMTHAY7(ZHMae|qWqURqsvp3TvznzVudCIfXECOElq&xT6$?L3VTYKa6%
z!FQde>n_YQ>Dh&(9JMe49~?C;KHQRXe1%ASL?q_~2(I`@OU?-r9zj%(#fS3Sw|a+y
z!*@X?m`m^J*~;V`FDECEhpq6L=qa>Cw^I{>b;y^T3p-sbL=YYr`$OLX!?zl-EU^FO
zm7cBnTvspXLs|nA9KMG7NTX_xo}zEeg~+uSx&Hhdg4hKshB~=elnnYys$N+9M$h`?
z>U>kyL1xQ^sN3#&NOR+MY3jB*jxbqPkk?M-yoPkF`|(>jL6)MrD!!P1P8Kb2P1XzE
zw*YI#X0JMLf04x4)hSf66tfPi$j*$aTCn5|9azJe`cZ!V!T%u>7r2uka83GHZQ)RI
z1n71b9NFd1_AQwBU52mUYn}_&-Y01&R|`4U#yiLrUC}PVKSRoqjvN`*Ig%;I!q2)S
z_`iI`>llU{S=Kp>w~=Gmp@QxTkd5<X#k5Q}=Pirgm{QoCyiox{91`|@p$n@$ViL8a
z2b4X|pqj%4kwI9rKqqKK3Ko=uq)6!$IE?7zz;Qp;Hkuha>z(?@6DhPVo_q^XuQXYg
z;76+-D*|A~;RFbv3}2r}NmHJDskd4<7ctFD-LPt@h{T)@4>=!e=L(5rp9akvhe9yX
z@GGA{nEr%G!m@I**rNKOi{>3^=_#DLhSzU$I{1cfxCSgxZZ0qP8Ol{^KzwGilnsFv
zLS+?4{4A?4-xV^KH09-etje=4Ju(~AT=4?v%93EfER5obFZ686ES<lblkM!00L7L3
zEq>`_soiZH)=h-n(DBr&^eP7SWR|X-;%5a5FVNM)hUk{-Al7MD&G5iE<0#7nObliQ
z?XG!o#*yE)u5l1HsrU}QjkiH>N+zS+WX!E#f84pgeI^NauCH0kQL>2)h>Q)dQy9MO
z+Fzz}kD-;RY{%WWb_yutv_|pzy}Zu*R00+>SliK`6m@uXA&&cuU+Bw!EiHYt6(~*z
zUy287T?2|a8%X)0ZSvJJ=c5BMDck-bW{~fB^I=*a4KS$|AfA-l=@9ymVpapVzPzlS
zq$kRJf^<oknLSKi1?hTxKdzhaU)F3^*;M3)-Z(`2g)r_%Jxe*!-!Jtki74(O3U3JD
zzBvweN=__1&`IzX@gq=ydhdv-1c`QMW7nWG3HxU{X@hFOTwRjmT()tpu4k>nkSWvs
zp{|4%Ukzl{i!l4ILgNEV`gya_MLL!LH)FAjj$5_4XS|0NrI;@2-7r|VZFz1HTT!G_
zheuUV&)zXkLr$FD!hB$9NKsU&ol&D`gf_x$`vtv&Hl{uK>I3pd@a4r3T2Eod1wAv4
z&}#i#BON|vQ$~|7Qq?!z#+se@w|b&yyXNWq60%Hs^USfJmo#%^W)b`kks$B+Bo}lr
zh5THTh@S&N4Vi)PSxcC?&ezq4zvesBz>(ZvvqG7>nlcs!_zg0!)cHF9u<tOs;j(K2
z-p5Ji9+k;sGyKX1VY|+_I~pyQUY`2xR442ZZjAL4_G-tnu2Fr$g!PyKex0xLYf%_G
zbRfy_g&48q+&J9?$$u48rMs=^#^YO|qJe;o$4~>@F&lB~&u7}M;i0GghO_WVka7v?
zXr(Ls@s_7j81`nc*fG-D<u`@OFd^5Ss2w28`2{oMSGu}xryo+kT!T<F))@`82)?(!
z)O8Cx@c-2q2k~ZI<8@4^yvC_FF}qCE`gk5Hmn2q=OlvKRr7zH(wK^9SRIEGYZ(#xK
zTGJjM#(ru+Yut&xp)Y2-p2EfRdNv_@L!i%Dy{xWSvUPy1?<eRFOxIs%g?vw$u7S_q
zGej2%2%CHjAsTtU;%}vV)m7$vEa-NIuC4_Unm=rqk%W!rbb*&o%2*IeiS^k#+*<Kx
zhBmv<IdP)IA$TJr?=3M1+&#NuN1cB};x9Tk7#bC5oqsho|F`@yENP*_<dY}u{L^t~
z5*-}11*731V+wJX^YhPmeagHfT7>g=V*P1@zA&V7Hyp25?nCv;edh|hnsQ$$*pYh~
zO26xv%gMWUIZC9EUq{Kkchqob@AvLyG!)Jzj%BX*Gg>HjKF~Xq8K~mImPfi8SoixG
zY9Sn^<%#z*5`=M3>5t#f@acX61Ep;0Td*F7Pt5}S7G2+gugt~kK^!Lcfju7sh!D9T
zN6Ltt`4otR8-Ykpf`mx$a4f*e`;bTKeQ#(H0*BKy3PwN!18RfQapTOGQNL5{PkINu
z*XOEGPCtw~xu+)-n*JCR!656OjNZXG!9mZ*<e3~N(;?2_!V6;OSQZM%1K{yLdbVk)
zZme+QcRedC%ka*aah2wQA!=88-d!I`j^p7K9FR;Z|Jx8iQ1syPB0=rVR|WhH8w{-8
z7+BhZPe~6{=FLO>=&uFiEd9S2mWPi;59anD!#Aoc=2+e<lrR5|bRoc``T#-@O^R0N
zTa%lAI7~(Wd*Wc~j~--r3&WrcjDL_(AII`mrs4SOgN(YueQbM`KFEj_TGuudmuL70
zxlo(^%QMs;KfFTi(5s_Ua^EVHc~Oua)E0BCQ=s$VXbb#)^90BUYL9YybqWHo1~0Q=
zrYidveNCM)iu$}TcD<H5BTEVJ<r%(V-G9LFqDQNm@%RLod`MJ1eua~@W&iOK$vmYA
zN*Gq?>iMjrIVu07Wm_&e|A|SJ^sAojT%q&!)=SB}>Bgkfka)wf(f(A=(jR673x_Z3
znbS&Lv+OS}lc-0h7;CKt6o^5mK_mtrqkAzm;Mc5F(72DoVTs&_$q**!l{KQdSM*uQ
zXPwmM0U3nOpx%IxMCCX^snEw!H{kjdu0f~}NAE8XG4+kHHE&MXc7xNAJsr2&!{@<s
zNqFYcv$g!?o|70Ie|N@V$45Xv2>Q^BM;UR#C>U(cKg#g0zn4$>bRVRw8VFB>ej*XN
zduJlFGd9c?uY#318&g>1;|!mMzk}j*3UuU3sojGIP`kBHAP=p!{vC=}>)OC0{q?c9
z6|!2F(&Y4-H>R@td~7&R8*8S3GH)P_c>b;ge~RhFL(G(`bqP*a24G<RyIL2d6t<yc
zPpRaSESRy^=o<I)+xP}=qLtO>(cuPkv2tIcMffOl{V1hi3Zg4as=ZKUh~G=8X^7;5
zUwVF#9Ny3Ii$jwnr|W}qF(Epx)A<XF+l^&G>vR#y{9nO_Nhk_+<IhxVz^}#qfLa2a
z!>-l&;+f<>eJ#b;d~PoOG)5}k@9td`e*sZ~o~V`j9yx`V;Vp7%5L6*T^+Uj`6qpuN
zW2|6>RKiM<VF|77>RH!yI34xxI%Zg>3+YlA8_oOi6>L#7FwOywvV|BJ)YC?3fJE>d
z*W?^s0J!XXIY)*h0e|U4ys!^Ly=<MXaqYGrQJ1SRtxBef^*V?I=Zl%RD6t+}%oRpV
zyz6xya0#u8!pk46a1_>YgDx=K1M)?B0Mk4X(1QaYJY<5)6TEan-}HRP^=wda%tmy=
z>*%p;&PLpgeE`|BY=f@1(~Z7hj8_|U<f7e_3{OED(Hk$Yc#cDU^u`5GOFgTmn(MjV
zTB=8R4q~TlmDC&UQ2hKxU7*kj#UDw<gRP3+nPM&;E*Br@PsLlKIMMHsM8B0uL>*r&
zB#6Qrh<=x4`ngE-8_ILM#M*>%kR&X7Cg(6pIrKcoRTzf8*`#ai(<g%{oN!;FFzF$=
z4>OGVi3(P8vo2^zq4WLW(h%a4Al$}c5^OmVqX3g|N9$oQA4zysgO7sCSU?kNeJ;gW
z4T5CQJoX{IgeUby#33}?@?^@vmSb7%Eqx+{jW_h{&Ssr|c5etcZULdUCyj$!x;jLa
zLWV%s&%lxc3S#VBaJotLnKbaGH$jujOGtI32S~qMj1YXuz5bJnVv?iPjBnk@>&_kH
zi(b_9yGXKmKO>stME<iB++8c!z$R|dO>uvYfpv`37<no!1mD%zs%xeQ+Q8ax1y=;+
z)M6iR)vb0fzk{5OEID)U>zT(kEE+u9jAaA2!FV(bf_?5bU9$##qosLUV;oqnphZbC
zt<JaoMx@hAr^kYzyxrfXTjV|p)A6y5mTH|~t@(1hZivti?DA^6u4{uITA6G68M05J
z7&ew6P^8+hj3|c08@of7R;?uo)@i4r*}UM-JQAr|lj?9Obdh?}1CG>ElWG&ixJoh9
zB9n?ChWni<p&asS@*v^Qm-H-Xr>=ReRhK0F_i0yHLqFb$%Rn0-CKm3*w%}dp$j5f-
zJcUmYb8V-tg@*>2@Kz#7ixG}rKEl&iX#<^lreWZTtF&!}F556!uF}>QuAdgz)m7T?
zn*VMk5GLca>LyluwYFZ3?+}5x&IRj{wyU+7cq!y?92BS3+5q1rFlrJTjs{PdpTaG4
zspv|I*v~`!gyQhA%yEr2RG5iXWYaa;=FQq}r^*gz!9nVo+!5p^m8&O*8u24yleYl2
zlnNB+`OzEm*^sYwmxO5Gx&7LZ2Ca8XgX~fV;>l*P?$9vwqk+0mN*NbP9(`Po5S-ZI
zJg^4(Sk3E0{Mp^L+A1~op*`h8aQ6z!l&5R8>W~?TD5KG3Ql&yBaBC-A2Mz;v3T}bu
zs0Foa?A7JEA4?^YZo0`=40$L51^&`HZBzGvpTR#t2+9n+_qLwZS+8wc`zE)sh{Hg^
zpr&J4m-X6^)Qm$?H=jz)=LyCLQvc(#$o%}U^D&%sJ!Q3&pU7*tZ~PG{IJ5;F!7@A3
zhR!}+c&+`kh8db{9FIKgn|;`W{c0E5ykD2@8I0*1j-_@2H>`Cr#$h|&4?f+GVpp+J
zp<>0IP;B#lU1FmbNqoV(J-l+k`};YfWXpt;|3Ei7i%|q~_!d3eazN+Hq7LYS`gGr=
zchJlnrLLVYbFx}Vdf@cA=nqgo1?_^)`8&w_2_N%!OsbHJdV1~K6V4eE)Of9wB!;RC
zPhb*|ohK|nYDqxa3x{{=*~0_62EwczdZs$4i+5K)LX&dO(m7M!p0D=m*~o*si0qm>
z^$u8X@`nUqEy0_`q=P-jS{@+laFDJNNSJ<a@6bDZ?O1*h|4V`FoiIXnIHZI0xGwOj
zWl|kPrg9J507L)E%VpdLTZ32<aPi61CE-ZpT~ZA+hEpDxPVPR>=pkgR)w9+wG9rZ#
zd~801gJ(ai(X+RQbZ_chZ#>qa9OrFg58wlSWiVu2j_AAvFX-ouj_4w4yhx;)??Ufp
zrR%j`PEqj~Q#aRZX9}CNHCUCSx|r-Oji{*hYtHD)dEhRX13h#mcO~#p&?vr_K<soD
zPMH+s&=mga#zJ7D^+%zEB7vgnt-|A;mLgxH2wvVpx`ofsCTY<-?V&4q9Kvg3tn?^O
z-PGTR1;xt@y)bH}o((R+LDg3HsQxdO6DoWhD$&)C_vpxZDySiNN_wC6&wG_rKB6WQ
zf^ibi;uMYN6ooO#1~>~krt@pn=9t8;|9$`~(!S*6+<zVQVY&Y*3{|5ZB}V;Gj++22
zA06f_q|N^uA{r;1K>D%AbaBF8oAhk&F<oQDQU$wv43`)Ot|P)>agv&UFE#&xF&_yH
zN_9;_{)Xrvp;ihSf^D48)1l>`!i8%o5Cu(fL4B*98A^3w!byCrE!9P~ytI)Rf;i9m
zAsTL5BC7$aslvI>N#Z_dcvt}8vX^V{!oYD|So;iK{*LjbhMNBy#>mhjn>myA%JHtN
z^vv5(FwP5LNkexZO0ZeSVQo1mkDXt@r#KV4O3w}+N5eO7(6cvyp;)e9p(k|BJw4Y@
z!;h$mN94ATM4J8twzEPZ6W5;5HFf`Y36~mDlQFf;JEv#&PUs@s57;H7Bcb6*U4Z9I
zBoI9@JbJE|s4?wSBivl;<1Vy5rDs_ubsj>{dOe$QQWujkk?d=d`3VKCP+wp?>DyED
z`y<V|_cgZa!%TZp423u)QZztmRyr%q!@U<6!FRt*k5h0ux&lUiFO5d1zfRBcPU*s;
zS1Pci$WxyK4Pbq6(+|vjS;sH}4h0;jb}|#KUP<ja!n4R^s=89ajHjT%MjX&HpVPWf
z&zXyC$>fTDEN{eqeKWzsy}w=BJ#@sh(>ia@=13q);pnx)T59+;=n6AArF?%o&bg%q
z=N8Bl$_K0Jc?gbQPV1Tnho7ec+-!&9GpH*;w}$PAZf;0}iR}!oLpC@dk>p;CHA!yl
zv5=(IGMOa5uhz3uXF!rA5=pprmitm5k~rCtWYBU#{D_*e$Rs(7<5(NLG!eqMpY`mz
zmnPIRnc0%$?nzFP3NMX^dtJM<eJ7#oduzPopA}QhoFt{Is7*wYVOaN7o*nE5hnZ;O
zYKQ=gCVTo6fZP4g>6&+bM6*>TeUf-xcZ~Pj5Pg0?n(e51hn4Q_mFTt}1uU$zc(;Xa
zFBZ#mTLbat^bP1X&xVy0L^r{fZuOQ*bR%w)>Gt6~1snDaSg92x{-STdO4SzF(rqO;
z!OTjxzp_mmcU)$ruaO|rEoX(9ZZazkI{IExb;elu=v%PTHV7sQsjBkgcZ?fa6RGAQ
z4R^ZzHFayP#{@&8YbX*dB<Zu$LXv$8Ws(eDu4f77A<haUk{H1!7+vpUrQi4%z|)f!
zR`N2JVi9K{r=h?68=whO&9`lOI=U2Oajgq>T5gxt09-JzuEysB#LHCCEHhK(9Of;1
zZmM_qy(FrMv9a_!kSOz%HHpqrH)6DX+LB1r6=^uk>#b4M8Uqc8NYoSw%<Y2Cr}lQ4
zI#8Cfi@CCddm=uXx<bTKJ^SnePBG+yM7XDGNP=fyN#@{fmlGHtPy$o)9~<v{u3)7;
zn)<>(Xg&9QG$HQ2(L-Q;l*2$#;0)FhSjT-e0g1y8@&x-CrW*uuTnWaIL-}#JpHZqE
ziD@+Am*&)nGbez#yfgH@&ac*WC^poRMMz~EzSq^Qy;W`r=F&gD(zDCo>)O};a<QcG
zRY{nsS65}F$8-TgR-uA*xTuSEe*-=y3~~OJ&#NIwm~|2R(%u*KZ2v`_+IJDCUapet
zqE@r&=ZE#|`9)o%Q#N>m4cxWCy)IeHhU|ZDA88lqS)WUAO*05OUwH$zLJ=Jh+JU~!
z@4Q1k-dQL$Ham(MI~=R4$_-AI;|t~<w@qqqD`c=RcazN)=Kf;7p8ep9siQf#T>k^c
z`wWS>$&-zRxkp=19lO6I5*$&Jvv!#Z_rFlE34V~1XTF1x*iX}R@K>{K89NNUSkA4(
zuw(7vWe-(D1u$3J<y4sa+a@16)uifxtTN}<VzBa6$@C25a`W+?_fqj^Fz2Nobul4P
zB}6Inyi!2o7)%n{l<1~Hn#3cKm%$^Au}C8xDT}bC*{uy0nzbq70wEYK`C*Z{w?NO1
zU&e@r$>Sj^aL=44A!+821xWC{0%g(>I$Fmoy0E~%&~N3wWN~&SHu1JrzOJGl=3RkF
z;5pbary$MS_r~t`w(TU+|G1)S9daEATXV%{Bs9@FpKxlO07Z&a_KI+g%AJAPjs-QS
zT*fs$rf0)`(rpjBx(^A|<=oXKPIC~wa5}0r5iS4TA<hl7HY%J6RlcdlFCLXZvByX`
zmV+T!LK(0aM_5{3V5yh6N78vuhY}t;NQ<#DyVBke$Eh`e4uT5<d1-m^sGgm>3Y^Aa
zva-ghHU$2AaSERy<Ah4!9SFp=#_3yxD{<=AR>J9%CWKQLaN2uu`WftWEXcbOr!hyc
zZn*}WJSoA7PTMio-;2|Q>3Vi6MibP2B4nO5IwKIapc5;h<J_3gd4k@tM`yrwT@!Ce
zG2F|<M0G5vT_sM>59!(J>%eI#_`@2f7N9iYlxp91-ShNp@(rAm8PlYTLrGV3n@RNy
z#sSGhLsgqp<q&Vy=-x!Q65Wyn3EgoG3EctvU}C$W3k`(a!HGUh632qD0Fb-U0NMfz
zW!}H+&Xtvk?D2KopfG>RWJSI`2mT*aFMlqf+UZH7N>oMgxr{2nU?UuSZjEYRgey_4
z8zZ6mB7{)Ai*93_l+dq0O32Y;K@dJNuFqjGSp5r;67z#Kel5@=?<eInGbtNZ;`eM*
zC4OA4m1CN=#_uM=mH4%fl1ZuNr2HDByrt`1@5pLM&4MJ?l>9{3IHhaVIHg-64nR%C
zY0t)(AF-lk#}8`VS>|n>pYI<S+O*Na_ohBacS;#=K}}hGTc`1yWl7hENog~X_H?h-
zCmUykG5PdF4ryHnpMK_BELeRlt4eEcB?cUSxOqJfIv~jLhw-Mi!N4o<Kn3L^aE1#V
z3wGlveR;|&ng!D_=SwN&vBZto3zSX>vZ6b>YQhyviA(P2g4NMnk-cw>zWSCglXL13
zRYstwWjwIEcXS4~@l&bI?bOn76CY?Yo%U+|*`@7TZ@&}MDNV1&&LTGJHdPYjTPP)a
z@9MM>-%ddb8qwCTo4`?(s1R>eP9Gr=std}1P{H9fk%)C~kPUr?Ium`aVW4sPjN!p=
zFd(P?s`Ku;o|{ij9-{NVn4MtfgO5jmF4vezG>~f$xPG38*d8X8UMj(HN|e)bC=Gj>
z8Bmbs?$dfl^`nTIsDg|dnx5bvQbUYYG9*rl2qKz!qbBoy9*g`<*GCwEE-(B|=U4R#
zgflVF4~Yft?8I-nx_+lXU<<+MIUh70eU^ts!0X?1DP9AtGH}WuQH{h)i3J{P%<npv
zVU2kA$~Gx!8xQ=`Rv`Lp#pveriRZy(2wM1Oh}_Kkq|<x|pFvPn%;bTQpKr09r!@E_
z?hET^*9x6q)H;fgNMJGstv8e4%maySBI<Gype73m{?JXUdLC1N_0Xxt>hIFJ`&PkV
zs~kVYmF$v@8905Hwuk3JaHX7X9zQCi(fAo9an4}Qx72#u@e}Gu?O%qOjkmuA56(f*
z(th|6#Q>~F>i#ESb;vez>wEE(YLwC$2g6_|?66zwC;Wy5nae$0n3uahwerno>%l=Y
zeEL0I$GR`(5zcCL%Go4R&+z`zc-%_id(`Kl4DGq63-^mbM_9Ujp44!SNtKHX=_xrL
zIOU)V_4*aE&zwu&0gQnh;pQAe@9W?^A7XRreO<73xG4+GT>&A>o7;*9i}pYtzOPef
z$DyL~kFf6#`DkvVR_@^tN<+o5Qd)T^GLV}eeqf+3Cxn8sxFa5;TF=iAxI%&#p)St;
z&38(DU(=VU@*D;Vt1~Qc$e+Uc7<FkL>T%Q>k{ib^p~3Kh5A{j;wYDC+ZPa<y&4yxW
zZmcqIEhkBdlyMX?x|iwV!X_AyCqKqYaMZRcrEd)tSt?=r5}I3?u3`3t0$|B`gU+^L
zTzI@8LVbY=n-eO42gf65;fwJyW#*wQN!G3#EL7_&rx_?M4TpH8wDLBf&Y_h++AM9h
z>XAWUd3&^Vgmwjb7V|*o@AKS?D0BzLD~nK-^xo1v+J3?gOlg-M;1<<%ED0b~n+x}6
zqaAy-Dxo!E7Vg!4;5Ey-!Lp>hJx`L9Vcn1@O(v1jVLmeBy`lyWqhX7q%dsXN><x=|
z`+eFb4gaHdK>Yc0`<OI)n8n{+N`v@wfJuwQpKuiI=<`tLU;V0z+EEJ2XZAx~H`mu=
zF}Mr)bPls4RP$dS>OQFZ4U;;Q9)wfoZI(KerhJpCJ@Ujo(j`W8L`idpa>l~Zmu^<&
zc$Z3L&d=4e@`xB;_WdKBOST&_NiF3s`pTVq^Ch)aiya`|)<1Z#J%X0bok$%B_Ptb$
zOqr0@+`uI@yuX~bhtj&@DJn=O^lLe;gq=K8!8;c#XG|rckOggKRm06*VG}5?c}nn`
zD#=4vW7KJBOdND4O07XfBp+5j)^!sU=t@2tjGALL8#H;M3-miV-g*r1?N~k=_|4I?
zAy0H#ufA3p%(KD%LhIR}K61QEm<un6Fdeqagt^LtkqBA{W1bCu!!V`UpavJL5@F1<
z!5K=!Z15O@kY)p6<v2YXQ-M9+<8IW>EwE@>IJ>B<bF{Bb_-3MAxRq_VZ?bLpbw}H<
zpT;&E(?$+wqjMY_ipmP&Y%?6Tt6)nf+w@6oZNug9w&9WOZNr`I^83l~vh!pF%I#VZ
zV+U|#jBSOXAJ~Rp$J&N#wzdtwwrk*dDSx)?Q?01%wH?NOb}fo&XIo*YUAWv1;CZ_S
z_$AnuU&1MpZJzCm%9hv_xS3>IpuB}`_<U#Ea9`UlqeGQ2*pHSr!Lg|BTeivBmtQ=~
zA(~6++3l?}wE5G=K0{sW^i5aZNq?JZ1z?fmI{<E5r?<IhUp`w^Vx3|5ul5;K%dOKJ
z-+Cu~s&#txNAINfw@x2^-!45HGSxam@4xIam{fJG(}!PuC;jaxD+&z1_)hw5>-4f~
zw&~gEqY~>3DQ@qOaJhAQ*=^ejP=2a)dj7i<>~Ec(VoRZHVv_dO8HQJR2Z6fQ>1D=u
z5O_P%iUOZ4dnf(2b$az1*6G=tOG~UX^nRC#mRqMETx?wdFF(~fz3d$(Q}wq_&$k{0
z+0rm*Z=IpK%exe?PG98vPWsysRum|^`3{1&t<$SpA&@PP!xHNZW$!Z4a_jVzpWXp5
z)h6BV9R&MZr(dtAED!lFQ@}dI@OS&Tu626#A1f;`mw!9liUQwUuu3oM+|5={jT~qR
z1AbB2;a-*q3cns?8xBpi4Ue>wlr@LiruXe)8=f@SHeBAnGEDOyrrWg22p%rCtDwA}
zZTjI4ZNum7M0Jc^i~Cx&n9sI7%;ov~ix%6p@Vs3GBkd?;-=Zyj%@vYpFDeVQr%-R(
z^qb}ea`-5)#cnbww<Fo4KDHISwnMP*C${N_EhOd$-Lyk+i%h}F`M<9{3GFcUTWt%V
z{4?8dXVErXP-GY0XdAwHkcTbvzuytt3^6&j;hMW_!y`A_hL<d~4WD0U8;%)e8!q^i
z!dCNt-!E)4Y|-0>M=rJvA0B5L4qam#o;2Jx{Cc8oxNjlC*_CGPqOzE!wiybh*@j2X
zvkULD4Hs;&4TtWw4R>B(8(uQm*I}f!)?04Z1%A1<1wx0|hPUL~hC?&$!rN@Ztf)<a
zzv5$@^LedH6E?!4+~q%AbHx`}1Kx#8!Jdc+`#Z^7Xp4`d|LGc6?**$YtQc5CKlx7=
z6a{M<KZ9^62Q1C^bS~%8D(oL)eP>eQU69?<9KLbkFZwI`>skLd0GOPsXFJ~Lnpc4>
zti+)X8@nyZOLz`rF$a1B9|3Ox^aV_<co7t9oi1+yRLYDKhm}CZ&n2KI1p>Ma*=>Pl
z9ZB+6U?;icEr1%aGFF-Z6quIexJf`4Ad&-}h>s~I04;{;#iT02a(IUcKmh@nt%15v
zlYkCZ5Kt|$+XB6`8l+vWUr<*}6K3XMZSzM`b7x)+b0eCzL>vd{o1<TFOKe=d6|5j8
zRV3E4%0H8WqELNF4wkr<W`3P5K@=Pb;-k6t5F@MW{S~mGPIUyxM%lO}_PsV-0WiEX
zZ%&ormExndLTpgu4i=5@%z<B4(O`%tn{rWGy-5yrg$>w`$ViJW-D)ZU*kWWi-;#7h
zU-s6s?-hV|Z3?cz31agqK(ewgrz4WLaRfdJ1vK)DLV}rtb>=Za42nY4$ZXw60j5=g
z*8MF(i$!)@vX&k|Uw(*7%uWD0VKU4HP5_ERm3<k4NDj0HJ{~y%XoJ}VGzbQeKxY7z
zGFt;(Gf4va>^}l}tH2)U$|V>LU3=--9A`lFo&@{8v)EjL`Z;M&Pn02U#)q~FAfA~;
z5KCtPy()k>`5mIhPm~~j`I;b3L3Z0_u5<-$u_^kv3IHDX3|7OcXeQ7s$q^)${REM`
znVs;lttx;H%_pD(@_}7d00jhOwr=L{6C|L`UlGs%WVZoY+zI>xn_yZsz|5GSXDg}!
z=4XVv4AU8r9Oi@ZFke;&%qlYprUUj7J5&cuDYG@qTrxADKQF%|m`7*W!DIuLqd&3f
zy1hDpzJv|HR2@KpXo-WD)X;T^<UnWPBeMp8uK$97u7sFcQ3F5$0hz6V)`xL{fQtVR
z(0<5n(@=)~^jD<oS?!tty3n9!AJ+s>UXR?;L_~6+P4ID{CV+N?ursMN*a<Y%1W-T#
zS*(Gcgqe<jy1yWxZy=^@fu`3IR|-ygJ$qJ5Z0-#6V@ZxA33iDX^1nhP6ysx{ix^e|
ziRE?iv?Amqa}gT_w-lwSr~ge=kAdXE0RjA44hV2Tu7x0XL5nu(AS!F4MZl<%UwR^v
zx2P>Xj@CwtdO;dNm_y7ysf`u^h8@3L<|Z`=^JfIs1=(#|<hloBge|SV5<rv3LR2aN
zR7dqxm4$hh4D<#*0$c&~1q2L)Iiyk-R{)hVTa!_QJ&eeB@+kq`hU~UL)8imlJ42Ye
z0;q8eNarSoD*&7i#U+T~t<1s4csEG76%a@!)gt^#QtqgmSiK2g*hxA6F%sBO6$G{y
zvddDg!c9z80DDyLQKi2rWX)(j>rqDxsewAkTiX$c)7&~@lln=p3lQS$3DqzSqRph5
zgkKB#aAicp8m7<3b%6YVOpKbx+U8XNx+KR{9@dED4d{fAZSJ7hP{=C`Ye>*LkF`Nj
zfP&1{6#E^EQ3BljF#!%hb_+<%xqMhd5~X<nX2vKC8V|@W)XoX!j0g_z!AJ~g72s8Y
zw8D^vaO<E#4`HouN2**b{RrOWhXn5^gpv(Brn#f_S9HXXRsrD45g0HkumzATagf<!
z9U?i<S@_8G1km-6Rv6NdpDR286cCWvx{>v<+9IH0IRWj5?6yGpkWRpm_5#p_!!e}2
z0F>%6Q#KKi9B31KT<`+Wju2NE(vY7fF8~DuJIbCMCINMSKtSI>D%k)nzJP|t>)B{;
zz>FS-In5g|vFxkl|35#KVSbB`a38?D2PuOsY{<`#eE?I+Y~9eopGq*lHWJKb$Zi9Z
z4WL=~1I)TU0D5gG<}_c36Ci39C({wf+c^Rsg}#9K1%wqQU5L+PzJLh;cAAASRD#+4
zKEaGdc3YS^JD`~D)#zChKe1gEUfzlQ5Rl~VZ}@}^&u7ZDbjJivH;oU&aAdo=NwpSo
zbBUiAR0CC$f0&5~pY{_2{asOlI&#20g4GG4&H{^ZK+7PJeEk6kMN4vIK+}iV0s1dg
z0<;GbwZI>MP%i<Rh45Z~018400+jV90qO%;Xa%VB9z+*(z1ji9E`!k<0q8nZQK`Em
zB2r=(d|U`1c7cQhyFf^r0zgJoZ>PJQ93(+>|AQdDfo!utB;_|~JAgv+jV7HidJwv!
zE`ScEdgN*6&w*xs!AE!?@e5=y_yzLq<3IqFGTZRWKndvAzY)-7$ZiXi^GiGMOCa&f
z0Psr?fCAIX33fUnC5FLAVGuD4WE&U;Qtwz0fC7Tu1S<@XfOh|tfW{)bEzrBKb^Z!S
ztcYL$oqz>Kb})dVP$hXo5Xphoz{jIt0Bry<2rUhAJFp&rN|~)&x~9Jb^w}K(dJBTk
z7O149wSksa4^X|a%D7VxP(QY!@9BOr)Xn(N)(6xxkZ;h`AP%$Z1FDqS8ftt$3F?=(
z3F;JNw}VO|9dhe&eE>c15u~OX;uXNTc>M$syqTTwu}uwtLm>zu&LMX1r~weQ+lklT
z`$_<t-y(nk$ZiYpZab)Htsu`s05GF3BxVR&`4Q^DSm8@3XGC(K5Bfl+Hvmu)gplbF
z@f{ifsFc~dmAQQ+pqFnF(4!EAwm`X>2JLTq0|0&5TbAj-)FRUn$$`$oM`l9+T@T>~
znGR{oWjY|(%k<t7Q1J!<?T75PK=~kr)T-SGKo@3U2sA=VsUCAn6A{UQHo?b*MgZCo
zk`RLw!r0VE49W%sWVUYU$qyx<?$-(E8wfKSpvn1f;Ufo*2q$Qg9se<f3~6PZ0ZvNo
z(o=1C-#$It6!M47h#ZQIrSmpx@Uqa;cHv{TVZZNf!%OV)Z~4JCJ?5Mx%#Dc!2P_d}
z3M)Tp8{T4PWLRQ{px=+S`Cory8$Nv4Hr)A4Wmq;Q9;%GsrZ0P|MuDB#WQ$#k`<B|4
zziHJ%Zmc|Nn_f@}Pc|klDY4CP{;X|y$wk|6%@elao2P8UhwTuYWY>W6W(t~(i8uG#
zR?yjwq$BP6u-vZ2HEqNEdXwdPjiDQO6o*_}UM;D-Y7~U4M*83exLXq0#d5xTc57n(
zmvLv3k{xp<bW|8HVGfIfR0zXZS+=q|zvtzA`dXU9p*VDvwDXT=Oyl$p?G*ZN@yHVn
zJ~;o5V|?YeWltp*G=AzTp|Rj6do+MWQJMvdhZs}#Se(;1n$cJzqY+|{MuEl#jrjMY
z(Nad^`IYyeQK7Y<k@_Aq8ky1P8oo+KWBSi_)F|&@gT@*h8nmOvp&}3ukJ3ldVTKY4
z82dM5mo9ek6Lz`DUUQG5(@KJnB;TC<2ala~)3a3<y7<?ci!?g)d*^Zqo&}5$-NVk|
z3yvu;ZQGFjkdXswA_1a+ad`ul^Bn*^b(H}*z6<DaR~gVn(24*B5}>H2qI<1s9ME5w
z@^M`=y{R}-a5PushRk*tzfG4bx|1$d)bvMG6dZ|)yzvFcc2Y%}NU^)nSSe%F2AS<D
zY9LqCysBK$hd-3y@Ziamf|8BYssr_<b8#9(<76_F1B=vVSi5!?QfkY!_wMpe?H#+|
zjQ0;+0-7O-nmhiIx$>P<`L%jd<pU56l@vOFrSjrtVrOBji(L1#w0G(rohFl@3(~0a
z6&FE*UCl)IQ8V#nQt6<!U|uM6S@~lcjyXAhg+DpC^R7(9O^1ID;Vv<XoiT;fi?W8B
zoL`~br#$|v0FO@BuApFnhZ}}b$lfe+TM<RK!$T_2?dIKbHlUZrquuHlE$$>cSKotN
z`M(~*#D~8)=p7xQcj%3w+j0srR7QuaLIoBZLQZor-MKKl&%-G8Q*(6u9}#*M-$Lvt
zEWyX@7GeXZ#TU@Dee^W|Dg=`YJcySI<b}%xV({^>C9<{sPA-t`09~PbazSA7^qcy+
zSSjG_VR#bUjofvHD*;0-c$?HD7fed-YZ~B6o?vr;d1d~FxP&d8+<DcpvPhlef?PTj
zmt1g|E@esuE&WFK$1Rr<)0v-ZZ*RZew1_CE0^dT_v;{*k$w$W((A8`oD4l7py*mms
zp(r!g-mUATwUe}jtKU)=mO_nS1C+gk8qJ0R4!;H{jT*+`@XyU&xVS?8Q3`4&7j%VJ
z2~hiEXh0j4y;}(-F*v}a?CtKqF-EE`l2_-8>MWSD$Y^n#a1|Qprf9KHC`r<@Hf_YP
zT5~}jTEE;m2O5rTBYOIr#uv`sLxHiB=4ZZ&>!f+qDosE<W`P{a@8+ZNR_fy{!tPRI
z`DV|jb<*kz*-iCqCO%v}r&I?8agZ1MIrMaz1KU?8P2<%bgRoo?b(3EOrISp!p7IJz
z;NqU<m3lYzy*C)X0gD}mLCm529LB9&Xb&Q3O!PQQn70S5tTET%?(twvJK-8EQh`G>
zL3InmLu1>Z5tUmo{C?5f<op}PW&sLT7$de-z%2SrjHsc%HQR}CEh>5t2oBKO*!;h@
z+;8(uIT9Baa;i#$``T$j;RF)Mwbuwu6W2i)nBXijvYS+ySYZJNe~*w)4z!g{9pd~Q
zd70Sju3!(^iGB+Ftr{za(%%-bV!i4wPEn0_yF)LH6=Q{&SS~dks0j|h>w|64iuW|)
zHz0j0Rt)3Fw-<xxZ+Lq#Ip!=E_$T26DadiWiij6vtRII3F0NB<k<uu#n(^`9(qXXm
zCkb{DlGw^&nx?Md7>|{0i3U5%m^9hf_Pv;#2m#~{Vmk%?j_d$(;_tQ&Vi!S!sln7i
z3=Z<=Qv;`KHRG7a5?HSj1lAErc<XbdrjhGfXycgTBpU7j4^PmDab8~@r)*QeMHVX1
z0{D_fOcGp>3)ls))^TE}Pas`TN`QYj`6<X2V0j#uOVP7Qabg2icg(fri#S2xEs7YS
zaiD_jixX3Q>e`ju%}ahHm(2dUJueB)5JsVTdPTB>MA%=ON|uA`Twq(J%Y;8p=^*?;
zIh_-}R)s`?J;$hN%aLT=G;3J{mnqT71+4S~F~GHHhE=z;#q#UX2V#V8O@%{3L6|xr
z-<W&%ZSKn&`Y4WivnG1hGG46jzBCr7@5XsqxycDN(Mj>5#v27uuCiDOFSZsV`((UW
zPf*6fA7H!~TI*K`FB)}GC6EMx31X9mTM$!ut0>5L1-_Oj!^5N0n5!7jW@G07495w>
zE7|AU=I>`@MO_7ZlmPa@s0>X6``~Y8BG@OVGi(NlV4sgV6Am)_WW%`+!TazC!HYvu
zQE^8xLgA@kksUF=dMX@P$!Lwga03>+Tcb6;LTp<-do@}U=;hZ|YRkyOC04GAahI{9
z*jP}a+(%<HP2lY3?`>^a=OnR-LaAWmlSFOUgcK_TZpvpU#Y2QZKO|ZA9xTI2z{W$t
zf|AAfAP-_JJUm+H6mG)5RGBjm^Sfz(sA29+7W)NxM8i|W7^G7xA!k0?EVZ%6L8zUW
ze2P=VAYoZG2PSx=X$JS6pNjXSvJ=$Fkf|A<Oe%S3>!H>d$9!7NAs+((9wyW@=|Mwy
zs3I2|cpepTbgK@%^Q4rQcE$BA$VALoVQ3u~bAbG)dhc^J*m{pNwXoX{OqL>c@U2Fz
zXrWGRb8ku<=Ez1gRTc&u@`W$Wj-ABTL51N{@LgWdM%vQ#1{!3)RaLNMoy63t@=VMs
zI*HAL;M*#>AXOci+~)d}PSUJVa6qp3s1GWR?<_`FDGbl1?`fSO-~1G8O=t0MD|d%0
zQ(>(~A6-lpeXA4(xOpS%lT@*px-k5@*I#h|aKAj1$OmE@8{vMJbO@So8i7)YS~1i9
z&4YB7?!m5TMgPD$Qj<FsIz`ZRRk59=-A_FMN0}xLRMb&0U78rusb4b;iLW7*%)TNj
zK%tcUw<cBdrZVR^H-3RHxVrq|F76E}r#o>Pww$mZ3xZ(kDzJ3gTqXN8O?(!+u{$02
zIY9A;u%k)(-6iy8|9zzNwM?Wx%EXGYn{VNLMsiSH{1lUw7hagh0?aKP^Lxl{;!Y(N
zTh`o}fV*`A8uX5iuMKU_l{=+Zy5ZVOYCbN<;Q1k_3EcSF^2fcv3wzYS>#T7`p^`I5
zBYxVLdmizqt!IbR#r9s^cM+Uetfs8t;H}WEV$)hJ!x0TN;`vSpk2zjxK8?IkFSO9$
z;w*=fP*jftfLJ-9Q5PFq^o!6s*l+eq3ufE8igktSUNAUz6@7%go_hA6tJt|t63xhk
zQ-a8W9Mq-*{(6?wO^g!4T0%8frg;b|6q(;mtmjwZ3CD8zPs-J)1)pe=3o`kM;TpK0
zgQ_le6GMav$$IurH!;2OHlRv<@Me1nAB7kX$d`oj6nh`BxJM6JiZ^4ri_L2N*hFgC
zd?ZLM+q0XutmMnemK|=+TQ;hprDf-oyk#APaVqqacbbpT%>%|+@3iDP_i2u_G%CXv
z4kNtNqJ;07$u1=JBIl3ZY4wC6eEj2`)=2mSAN73Fl7&H0Ft+v-b-~)LmDt0(1ap_L
zZ;e=Z$%Nim#DaQ>^=m~nlCXce1=wHoPxEf%v6Ew8cU~p-epo`FU%pez*u$GdBNzF4
z>&{+cVBk-6q|4AX5@rrj*VGn%k`8IYuU+FwFgF-6dx=S|NmwPN6i(4Vw3t+f&@G7{
zqN5@r<&N?~PZxbCHV_`8z`+kiwQv?6cRv(^g*8y0oifD!5%Ym8^}%nOD%*yh33HQT
zze6nCx<P<S(@wE(TC-ZaL!|cUkjUEmg73cC#@n}iPG$SB5TW*^*0Z#4V+~ktebeIV
z^>EcYB*3!|?s*SUSJf8opcO-E{u8-%;poNReABwC_G7lg4FhTEz(-IB`n8i^T7>UX
z@Ds$dz3-jrC_3LSEkx*tk3)WG{<ViX5guGEZjQJ={L&f-&7AZsDs;0?Kr66W%GoLy
zD98h5mj~b-Xf*<SZJR#8NsG|UHSwUB=#kxmMv^p5LdTwiAx>nA*gypGMw)qf$CplY
zX}WVueyXqrvh_8E9K{%><&yk76}c(Hn$nmy<s}A$lX|Ff3`neZ?w^;6zdxUw_OHq0
z;GmC4F6iDUxuA1o>Tq(hbjG-1&nx7=Z~S>0{k>ysy5KDYZv}3<RFmDRCAOkd|8oJ3
zyZkDz$z|Am<2t#-o3E(EKSslP!u(?(X)RhvgjMtv8>&Jk5n>5yZ!>0Vb5k8y*hiw;
z`&0{R`|)HrEu~Zi;XRB}hkYd8bDH`&zPj}j!`k0o`jRFEW5>c*Fm{bnSJULYfiKjX
zoZOSu-o`0YUvX3xd?vxFW`^ZKbsXs@`uX>qgLZPYE(V#Ao}i8-c(<k@$FqLo%6=73
zJEQkpw5y2)d#J0$9XJR8$G}n`!yfc7756p{nnD$k`ie&3ia5F({Q0$1_~3@h!Y3_-
z$3x4j=r8u_y}cQc^d)I#{<uxEf(Oeeh|4vq105)}Mi3FaQjc0Q`4x9ycbLYx#5LZ=
zIf$fA+qarXzY=0)#m6GN6gqd?gDtm@#WZ}HzScAE0b(0C=iRjeRqoSRJL@9@6&lNs
zl3dV+`|LZ6g*IHpt;7t*eRUK>Crci5XV=yOH2JKAa^j5__fV2Th#G)8zRo7gL#ldM
z^4UD~Fp!HVMmYu~=g(GWu}cHQ;D9gHP@Nh=bs}emfuus=GSPCf+t1U&+CLDoCAta@
zDGh|};fXV@Ee#aAqY)i;!&lru@gt!$7>R?#^d5=-i4Hlht1I)S!kt>#8QfYo`>rl@
zj#~CkJ6(VbaP&foxt$}iXeR$jt{e;J|CZ|6%|W8Cup=*vy&Qy9U6*=#7Cl%D_q<<=
zmg7&73-+j2Qk&p~$s<Z&lLm`D0}EpnO9}l`op^22aq-nu_8)ig7T|y?p9~iLg~st{
z+Yo5GBQbw{Gz635e(d5*7$RoWER6MC!pmdva&w6IWBtH?MPTYYU^`(-o*Nuf3$XlC
z&UnC^5b$IXF6w+D`uiqBSs?t6P`ugaw#)ultplqvRBTbN$wYI16wX$YC5<{K3q%+@
zO-h)+a=L!t%`y&6fUm4T%wI#rX6_dkL6h)7?qiMc1FvX6{kx%<*FO(}b~#j>*rq3_
zkzDW*l-S(Y3VmOi)zfK6;EvY=n!#Y@=|~zPcdl!IFK~Wov0+m@EAc71x5_^v`{q-z
zE?Rz>QOmb=)U&@n6(juo8)E?Yg1O6^at@asJi$d(%>FUMM876OYodCBWPEsC(zyRv
zM2!DE&5xC9Zc-ul=L{1Q9fhjTMRsnuI9bSeE3%{!XvL?0i)`2kF<9|RWCbI{q2R6H
zO?viX1g1Fy^yelc#U^2zD%6Z0l?#sNom1vrA<`8(Z`nxArVbI5GnQ84aUbV{Lr03L
zriCtv`IIb;pm~_Osb`?xQ^_Vg$vlekmcZ0<YNXgu_)MS09*-2`1G@WQQ2c^359Ex4
z%#!3VBMU5Te7e<<rHv9hDmFT@;!#*+-G3@F<0!0H22^9-nPN|cXEin^Q}h;8(C}tu
ziovQV@Q>N$z2r511=?JiDFzBhUG)2Z%M=$o3NOPjb&e663K8gyU1PwI^Zydrg)w4W
z_j{O3%ha&u0Q0}{-Wf=Emm4WA*N|dv?%$ZKsJZ)J(QtM?%9G5^^<`-8z$`TPmoZta
zAWMuF_CXK&AqzN*&qVexOZ>Gy{D!YKQy1)xshJooSvg}m=XvL!aV(%>tf)#WbUFID
z1#mE*5S4l9Qm)lJNd`PyA|xbF4kxHf*yYw30khRJrJ(ko6bIH_Cx#05GPBq;9q=lJ
zc5_xI&H!f~nMR!15jMQuqL?czY=kXaQ5;{rE-5#J8p|0Ydb9C*F*ZR%(xGsxx&j?m
zHsfz{x+@1JA^`dJB%3Nb-bNA-0VJ<-AtjLVh^K65qh~Mm;(VbF_CX2_;)RxV>ggRe
zIx468z_nva{uScIy!9M!=M`Lnkuw8jo&bmt|KxwN;-Vv)J5G#iaNH3H=5b`es?N&1
z&Jfh81#8tWkr}*;ISS`X@tls>OmWDOH5o4^2(_UojvX&1epKlE5ri3WIjwmPb1CM$
zD(4+0!0RJG-(?0;%uEoEl@l?+7gC{7Jju)irUEcQoe5xq&|z7u-2^edyR!?}>@_^n
zf@8h`8SLhz4ZKTTb|A$JAr~4TK_Gv^DD)LiGD8?f5Pl>GBR|bznn_}Oy+rg&S*(=#
zo5hvQ${Q<j%f7`parc?%n-Tm*gmlNkdS|)lP^OVknmqL#lmrQ-K}a#9G!<GSrpm2A
zr!$W>qvJCR=v@8`=!_UDp%ah*;Z+ta&wMR7lvoE8f)Df-c=l$Z7?S-XrhNF+#2OAB
z+>O6{Ld&=#yer|I$D|qzHMz|5wKR7gkT~eWDOAI+Sh|2T)9=#cvz(_mYbU?cf-ch7
zZH^Rk3p#{JMD2q@uz@*y^E7ia_T`}&o|DjwhM!2ysP0$;NL&O}S$2*X%}z}c+d+ob
zS*T~ulf}k$s)S1QMM?tX{v@cqlSLm@q00|bTk!F>Q6l4FBgWt8$ryj<2WPRBvoZeG
zRfC>BS^PqnjK$Q*DdJ@e#9wgm3TN`L07;oDM%Gyi?k198=Y*8k7GFBDf~n#+ikBs<
zSGL$nQCh<0WQ#Ga;_sp>F-OoK>%yxz&bbHNuR%~bJsKTQHeS*{#_<d*VdOSti=K*7
z$NgS8;s**vR|nSjb8(>H`ir>#*yrLyM<Muz$hPN+VZvY6MRqGs{6yIOT4agSVS9SC
zpN*Xk8~*p#MCSN~SPG(aE!6Kn^Mx4X=(LsCp;Liaujk5r|C#W#fkOG!aW3b|K89Wn
zx?dXePH#1p2(=F>=H7Zxm#E7ND)S~t{aic-d^}SORTVn7S8G6)JoQV7_z}N=#H)}b
zEc`HwU7RVl^(=HQ8%@=rgZHS5xG&pb|A{OxUyS!(>gZ5*5->?K8_0)EY&J4uB^rW*
z<@xBBiWefQI!kQtKjRANC=zSJzL1*#DmlMQn}65XeyJlHI7>`K>qlX3+%ik-j8A`j
zzQ(6h>I|6<3eDGSbb+{AdF5|()ad7&20LLSZ8}?2H7j%}9?2W6+3Uzv(mTEqSCNNu
z5NiTYH8bge@u)Pq5KMZuyTnO7SG`27-$_INrxEW^c7a6M!$<*TqaJY>0Wyp~rDAl)
zjMFJ85|VEDI5P}q2}T>Xq)@Eof9oFr;vUPP^AbHlc~HjrG7X%Qg<^=})K2!GP@L3g
z?q8Ue&n6-nvqbPSX%M#s7ov?|(v0Cm={nG{3g?JEtqWuQdBo#D-tg(EXn0wQB$~QS
zC(KAh>qnf)J%_e9mWKmoTbxh6HAiflJ^eljG>m7DtN5VVw9M-%nVwF;ef{qhoP_^=
z`VLhxC92#(ikaUodr5R3D5=P&c#@g!+qJ2DK-0WODnCsy!Dt;To-4Wwhtspz*12N5
z=Yr=VTqtui%bcZpI^jfQ_J%Q}Hbq)Nt0hC*C-t(*2HHQVSf8a7p_l*elEuU#F}}n1
z#5<wLOdMO47mCHfN6_)R0Euklh-{D0p_Ic>$}xcF*c<>SZbjk<!R0rR4VouLw#RCR
z>krb@Iu9MmP3+zO5FHMHG7e>lTtRd0W63rBHg;KISv`yMe3#}yyX**a!qa)8yVL3%
zU|Vgz_|*0Cd1<Kd-RAYlN>=?#F;Y1ENM!B46n)$-J_B1+iu}f@N;dRMaZu>&s^|n-
z<+Xg3lIn2C74XTjr|l$73B+lVU9T3-lz%C<R@B?f!oI@B?Vm=GE&fUj7ZT5l?Ax!P
zG4`zrmy-)bU+2OACmd&tS%CG(Em&>(ED)PH&Atc`QM3ReVpAtcz$<f~fU1iz%Ydb-
z;()VjvFNK<<jBH`VbnH474K3kCSg!do`O@J#bO`f=d&VvSqzi>7JR6g80Y%)(f?2y
zo?Ag4W1nb8W?<rxx+jg`Mu;5;#FkKt<kJs$3S%R%?y^vv>b{HQ`yO=#2{1BwWWN;I
z-GyS)*unrh8>ieC@0x(o8dsQR!XX!B?r%hxf*3x46}2U19YF)Qay`^}G)7|TB51$=
zcFba<7m4xO%b4dAqh7?(8zIxlDSnv<&6QZ>r+=u~u_O8u6P@yqm}n$uQ3h|lrbO~U
z5g=t*(TB3Ef+qWRk?2hm6_1#Th~UMdzuWzX*8LinsAOr2#Ut=Zz7iY6$|XRj3c4<8
z33w%Y6fjI)0?vM(ki~RMFcV%Z6WM_!VoTI}G=l(bfNJ`33F>tP?iPL-5w9eLQJr0O
z>;=dCtHIoE)*=OVGim)c4g6cShR9SHTiA&V3l~j@A!jj&nbetLjv^*G{|Fag==E`*
zwLmaWy^y%9F!t4q6#P+n_rR*La@M%<Ky)bYlAOPk_Z2(0RCI0C4wX?k-g|}4>mI*=
zal$+s#kN1jt7%A?<SvG9$Oj^;y-aN6<oO9qe{GkE-JOmN!PmTHV%^&PP5{wk7<G7S
z6)T0K%fv*_zkU<#ndc5hu=jE?GW67O<ev)G!86m4w%jg5Y#2>!IAi`>Q&|yO4e5ZT
zj<{UBtcY}E$t%R@nn#|>xub5fUl)q*Z21ak#dUra*`F)K7Q)TDBJ*E~QCm>~HeD%(
zIsGsYIA*UD{TlRvqLExc+p`-H$3dDGUo|Oy0Nm*u$MS0>mODdG{N_qAt@iml=0ZMH
zQR`JOq&gy3|5aiWVb2q+Ojkj*NX5sqRpREL6_2eNLqp%V%vTB37V;L9c?`;|7K>}I
zx@E5PNq<y2a1D&IhahIAuMuN}$@n<AMjR@*<0EXX7~#427t4GkHQ;VP6w6vG77MK&
zimduNu|xI0!ENx<Q7+<z4>8RB;zuQzRSqK3a&n|-omhxB?rxPlHL?2Z#S{2e(RcZJ
zaYYq*Yq4m9XcSIij8EDqhWf7WO|=w38sNk>el06^R=QC<C+xWo0&GIY;ta}|gV_vc
z$nk5H@zN$_TzgMsOEx3p7avl_tb3Gk1b!_U_q%5HPIL_N`jbY@S?%;k1`o&;+8i@B
zA4O(Mld)zmG}|z`cT3L`7%I5bfnQ4n<hXvT2*>q5AQoFA<9i~v&+IgRukVSw&ua6Z
zYxCb~^Y3F&;_ZZeBKvQv*j4!Oh{)2niJfXU+l5|%$-)T_bsdIg*sGr>t6i8@t<&x6
zqC?ys$Hb^dWuMTjD4Fz-?et-Y$u>jOu6n$_O0WGKNsw$EJ$g_p+y8Ej9@#pW>vr+9
zyVq?IZ<2w(WmkAR{)C}myEw${E+kRe>$kL>21&d7n8^C=5I0t5r6M;k9%t#>ML*Vf
zr>J!D=!V9%+bR0`zUW#a<)4oEsr(ThYXqN5K8857{Woo)b@^R}=5WIrTDPNM&Ru}k
zy5wDGd%DQbLW}Xmu?xXKBxnXShC`!ANP?2-4I>(2CHtPTc|Ft9>J-_=znxK&Jw<$W
zk@Redw^7|4q6<gJ^6_>Yth2P;ik+wSp!qSHd1M-0rNIj|$}>41@APHiAdD)$ImA=$
zDYygbe^T;MNcl~wua8I#kax9P%#ivdHI4eD6^0(MItC;w?Umj>cIsx*z{txFRAXb#
z2Q_73L})<3W*0x>qQV;v<F45fvKC}b%!lc|*>hnNhHq(dJx3nvWY<JPcf$l*s9HQ?
zj6;b#N31H5On#h$x*yUU48$$<64B;t#8x95>35_7FYP`a?)D7y{>K=vCG5kIU}1Q9
zSCl36P7iXsc1YshAin<m{9o9LMyIP>KloaSWr)5upQ4?2imZv4K3dQN^;&(>hg8jk
zGw+mwacrJncTZOFB*Cd>subf|*2u)-t|xfb3^hjtN)fedm?Kg!7>Zcwh;((Uml$(e
zyqcW<H#i`*V04B)IyIjTbbySFAme|+2s%otSqc4cjd#i|k+toc-axTIWV(#>5aHGi
z=tCLl9||Kkxw5}A(mS}=G*tq$@zVbUv<Rymdq5x>>qG!z*UOL!w{u7tiYfm;pp1+E
z6Hv<KcLCkPl9K~^v{nWbyG>-X`le?n_Pq~K@sRX%;g<^{yO^8q<8=unv_TyQY=&U%
zYRXLy6eg|_S#TcO@a-1Z{)VLY5<X)}*5H%$Xa&R`?}Clr{ZE7!fp9j}6FXr6EKz2)
znKGN@KB$@YK8)GUq3IC;Q~!o)%g1VA%d+{MxzI#U|7KD>Tp_ZjVPm|Knw=zW<P7ix
zuBY*OAh>!r;_~mqUV`TiD)3DY{uN-!gS{lzsBg6S6~?bOTXE|+Fh=iB(}x8td1irE
z#Rgt=z`Olvy0_n)RaBoI3<rmGwfWPzoXJ|95SiPs^sE{M%{ZgGmfgnl$bG$Pj4+3P
zlENwG@OL~cG-`H?-5-`-&kKqQ#*T6J2i6B$=+N!x^rphziz4eVD!s1Te>;#3f)8ZC
zV<_t}(bMQt4c*Aw<4$%+Jk)jv2J&@KEJmjf68`yKWSTMQp+XAUFnUb-M4?CIF;+e%
zy{^z4AGNaZQ3oI4S?RvP!*RwMOWR(?EIK!8dPaI#4|R~d&wmHKH*H+H%KaF8D`Paf
zmN{T#$`iU~N_vFb?QJr8TsX{x&cKC3@_H+B*942Los#~Ekb4=zVQTt>n#16YnOE09
z76nP>hyXdFfjPoMituqZM|2<zD((CdkA}27^*>qk`nh*mH1iT?(FTgeGKXG3W54Z>
zA=T@>49bVXLU7;zkVg4u--Q!^o?JY~&_J<BhBIZAc_eiI{{baK?foBs+MIb8&;^Wl
zKIU#Q8B+L4xkXdo3n)vUUa$R+5TJaHpfkv-Q)mDVAy#u#=Cy`ArGbWdvvQ!hY^-EP
z47L4Gy?AerUuo6b(BIi}efmdk?lv_$V_i7NkRBoQ0Cry*(nr@A*+^!BSJFV~WDY;&
z;r5NqVI%Yw+GKTAx;iKu(`IX7Y|bUlx0!c2-`=}t%eODkr^L6uSK-^3Gn$JH*U(u+
z-k%4clKc-cZ$dBFi?-NrMK-ZNW|yyIDlc0q_ve=U_mY_d8g}%50_qK6U=QfgIrQGg
z05o3)q+KGi%@e?&k?)10>75?py2g4qDt?nY=)@AM4w}9Y`1Vd8BMAGYxw_`V`ZARw
z<<WQE9MMpY*ldodD@C~En<HqdmS{Nvdcyyp<#3SNzKL&6i|o)RXkwAv#D0Vu&D1sX
zl<%9Vxomt6^_9!Ub}K8{5wh{#ZIP{-mhS1X&|WkSSs;tX)+otEWBy!OG=3E%i$)P2
zTr_sW2N#W-&T$qizQ$Rs;T>BR3;a?Rjix}Ec-Eq^ce>iG(Q@m)_z}7SA1w2Wt@@%T
zYMD43dQ%SwZLT*Rt;?&k(wmk_F&4dPk~zYxH}x?`$a>SJ^iZcwEnrZ1vMGI+lM{Wd
z-JCwh{@`5c<eo{w0syWtrDsTX;eIHg*sC<_#UaOlKJ?<Asriw~X9cXNF<r$&J$7z>
z7^KLLcZDBUoNuXiXeCd=6x1XiMfhtd8xbX+95F?6Ys5HrSR*8DwI&n>Ye**-LszZG
zPdVTW%D#KGQOO-+|1i=^lSz-2Jrc5<yia}As3*1XBRa4iFuq1AzFVF{6pUm$IUtuK
z_`}*48+?5JTnlt^Pel_VmKlS_epa!ek<)ik$hfrFFvF=UeKll;&xI{ti5s>ugQHWm
zNJQ;iXwWoV*cA8=cAA##c+PZJxi2@$h2&yEBzEPba}b3t^N@vkEi#-CUVkI9Ultj{
z8vX&5MAk^L;F^k|L2CE(QbQy^LjuhOYt>?rHC=3ICXCDz*^tGCPlZKb)bAG?f`y(l
zMfTTXLv+B2xfoQqqrlCO+PxyF+|q__X(@KIml!g9ZUw&KhPJy{d5}@%8aIAiJV@3f
zLl+?c^0vlOgRijhbCES%YKRcV<0E6KAy257CbBzA4ObN(hOqt140Q#Dlxxcj74GWo
z=ps7Y!P|iK@Lr6d<%TAW?_<8V?z?QDgk~x8RsbrRn3@mi9KLF27K>P6n62nmpB-6Y
z2v#($&+e=+tWi0&<jfH731*NMDw@;cezww3%~6pV%vP;3oE2s-7um?whKAX#8dy<2
zIiF7C#x{%K6}0xKv~7i9n3esBV~^HoT`WZ8B}Aggwr0G@Lt;P)W*OO(c1x+hhV#^W
zlqwm^ZZ1RWS8fj3=wA-=n3Uy|CCfp|qN56=9LuB}t1USg<w%!6yskp_wU$5$*gWQe
zb9;DTmkXu%5wdD2?+PBX3CU&Ib)=|79>pliL5gY4WB#0tn8#R|a*isY-ohbCioA|U
z8M7ds^$^9Lw8Ylnu?bY=HcM<R9y^EfGQ{Fc4{!d9T7;zc9_$dUH8d9f-YT-rYYjtc
zjKeAU5coev_~2SYya3ZAGp#lF2x`RmtuwUl_FxN^rIKfWBWl{8HyVGg?Z7dW6={r(
zDNAT;pgyhM%HE)TSZ1RbjTTt#c%k^-xK!d|QZ2y>W$ik{$HG%g?^V_tdJ5lwf%~sF
z_&ELK2Q$K?^@ctHh0d{bDim8II5a~oP|o-kRi_rlX5ysYydPQy2q73byMAct;ad$n
z3+1=zNe##~Ta5!S6s&lej7LZ}7#azwPFZZ^21Bgy3v`+-8!&V(Z^HQAfB|}OoXCFF
zc5BEQZZx<#6$L>6wA*O7Az<T?`D`)_7v}GR)oqg@(9ip*=rHY-!?%lL49%%YrNAZ%
zj(-=f7TK{)hK8QKs*?DU5}<@deFJya2Vg?lWVk6j7e#hsvmr8J#Fvuksfkw!_Ha(a
z{yiZ%F4yF!_rtG3-w5(Au;_(kK$$uLGwqqgWJf&8Iwb)=hD2DYCx|R<iy^LIOQg~^
z@nF~xA<n!Z&gj*n7|5nh1&3V`G^w6W7TLZnhJo465M!{J;qruGl1X(I^X)Noky$Ey
zOzI#F{vga7z)I=rJP2b}>E>`o<El%AF`4=g#|EjK)zs3^T<%lYb-B>Mc9L_-8k$z1
z-o<ek<t|4Rtaz(|_70;O;#r}shOxpj%$I$(8CnTL@bSxDgPQH%X3#npwj7OZ<LcWD
z0YYuay~f)OLC%FPZbvjMZM(r2`_A3c$(lV|O()XO#fzV!i>GWi)Du*1#<11f4e<dh
zioy2Pp=ny}5>3Je3|uNeX;ADiwCGUi{EOPcTDT#goS}fs#q-MTkP&ny71jI<y)ySU
zV9`s;d|%=ObS=XULojeTbx2~jb08#e`KSW8Y}o-^?!O+xF73cb8jESbbEo0MAx-Mx
z92QNQWB>;$fqWjp4YQ$3ZF}M^>3!4_Pq-MSo^V9jcX}d%%31Zq87$3y*lBPVjLWmw
z{hfv)VG1;(iMtHZ!Uy=+yUP$GIN{^jF2jIs)kkw?;Bey6IO^b)eA01VA8aNJ&PCk-
zu9%kVIdP)cJPW)ZN#<vP=R=~b+s#Sx_nP+BBk=GdY)J7Dxa;K@X#~bW3GVo{A;t3(
z2um);<&7g8+2~e?ioP}^t9DFAAMOMQ$l1XP-gk%4cY6%=!X_Z8d@|z4^Z4N)Bn^VT
z=<qTXR9K`W@{}$pk-o=Jw{--SXomP(|BV6Zy(m~8!S8u+BM4p&Gjf<(lD;%5a7S(u
zFxg`W^;AQM+F|K7TV(h47~0ppQ~)fm5OdIUX);~|Bb2R27~TjVLO<ARm@G`iM_k)j
zZ^5sC^Z6j*Eo5HYK10LdSD-DSWVwzPzi({O1=102*N;f?l~VJ_8Hid!%OYyK&H~bH
zamvyz>%4cfHkbv**k>3hoX8hh%l(D~VG=$j?>Dq+ugfBV9SuQ&M?3#97Std;&9I2f
z=41HpaQ-`(|MtVLt?pH^p9XBePdI1y!2!cg;akr)?D+vh51*RDMO-ph=8XUg<J?o;
zZtU3L3DzvE8xI=#Kng_Q*xT`g29>tZ#RCRU^ZqnU?9`Wev(c9jBmZ&(ka>T4p9<4E
zjywj@an(lQoHr<hC}@x_Up*be1|Bv<D4SEK)RSu1P$9Abhd7)<UYT^DZ`W1{PA4gs
z&IV5EpRiU{!U?vA^SnZa^A)<F?5=dWARTZ_5}a06aO%i#YD#eYY~bwiux=0C#-PKs
zmF?*z!|DDUsyKgc925!0X0F}Is&Zb?r7BX)WE3&$5*gP?$UUU}rpi;lPuwxV9W6EZ
z3HzT&E$PsUAjBXu3C!64_z>ERLMBxYOd2$}rXjJcK2j*h1S!W#o}<}rk!2n+cwuYv
z43BU{#9S%DgGW5Z^ttPZp%Fy;H;-V7J7NfkZUcilVdxIVfDn-nBwwiWKPi&;Si)DR
z50!ezQA6LR;ZUiqW#DN@elFAcqh8Wq`LR}Msq@2poX$LINOs>h$F@)!boZ1J!~gO1
z9bi!%-QU0kMd`w_bQT0r5d;NA0f9wjQBV{MHmtFWu&@`63K%qs1fwQ8nwV%zV($%O
z@4ZHiCiWP05ep`^*!KIKxfgaZ@Bhp51n<tAIWu$Sv^mo}3p3_nK2owaU<XmO6jxfl
zHg}lOkb4r|iysl;6HSeRIpxS})$?HnsXs4BhgPpuS8rLA_;dBY_MEM-U|@HC4%SX#
z!<Nc}j=;<p0c?7|HIDVKO2fJH(RlWLuP(wj{c{?;wS4zu3jU?WRrKPj+FSVu3T~gy
z%j5V8srnBz;MLXJ^>@Tbf4&cs0Y_k4u}>G_uxdI+dLE!s%0eDvt@a^u8#R+lPeXcg
z=@hUb-y^f$K^hHfk~hbOZ0<f7m)uGTQwLkZq@?=Fyf;4l4{`V&ewjFPmrJc1TdQ?l
zfnMUn>ks8|orKAg?Ezi$u4S=7K#7-0Bz-Vl0r{!$m)S2yVn1C4L9~`3W}8BMCqZoC
z5Q=pOuOHB91b_H*mk;O$wi}rR-6=1zkO9ShG^Ai}epzf!Jt0k!#CG~TY$K@H%4Iip
z3(pCGKde2d!}*Z{L^lrVrdoy@_TXUVA)R**M|_df<3=&Kczw5D?D-{D6|iz9$!(Eb
z?IP;!E)cuW>4S?O_CWRS0W5-X_*;Eg@3x_*CyqppaLoI<S2DI6EP9YTze_J~!TrbF
z`B}ZZ9TT2QTt%Cja!O%q6JpeEb)hotQXh<;zq41U`=cV-G(^Ea{Bf)>hjqf>pGCmW
z+`N~M=O@dg!MTfWnhbtR8;nj{^Il#S_s6qN@hPD~m!e!&V%{qxVt5}~41<4qU+>xd
zy+J-7lU&l#I=Q5mV`VI<h%kw0l~|`WD6HUVe{)2a5Rh6Q995?H`yN)iKH-F4F;yn~
z_Z)KRN~qBzx=?4|cSMeQ(B#II>G-3%)^*APi!-qrJ>{q_fiG$tg*iLk8{629={{9X
z8kB1WcY4cy^btNBrX6+~bM#~3F<mQXA26)xOX=HT#P1x_H5Z!wHJ&*i*ZDh_Ppb{l
z6%d-^a8;ux<d*L~u4`;AtQ?Wc9-PqWgzO%<Y~V?qyQ5|66duXUhM%Tyg<V23PwMWs
z%}mFjV<IpUz2xEaBNzop?;QM|`re#o5G`n1FXi*C8T4<N)p)qRD^KZCg)7~$2j>(#
zwiDWCtkr2<rl9HfjIq-?wQJ(_@f`J16v2XI$wRs#DYyLTX`P>W#`OYpL4)qgE24R%
zJ;<4Cj5NL`EggB-NibOM#)^F!wN!EO2C(vYPZTB-HE(L+_1m(@x`@V&JPU_>144Q;
z&+2@G16$y#0om@hEhb&YPleo}e@BupSw-l}?CxD3&wf3tODr5OLR&CdfWMT)Gw}v7
z$G9b&|E8<qxmD<pBk6M$dWQ=w2cuXKKBYuzv_TP##L6s(?b8Bspay473s?#O$nI-1
z;x4;sH^+m)t)_4?ea$oXW=J#Yrae(I5}@T0=%*5BG=Y}<xfl1261NhNtQ}N5<rLV8
zpWHFM=mgVUn;dL+Kc@>3uEDYKI<M<4oP~_!oYxHzM&aYP^Sai;gYmh{@q#Wq?rkBd
z0W3F54`Azq3uyRW>Hq0K193}VSw$Rw8Bo~KgTJPpR(q^N-*)PS6B@6uTwEQ%!W{ui
z(LOn5hp1`&R0w9-kCaF%2utAnA=IxtZCFf$UVg&(E^vk#^lI%fKLuU%2fsDDf<t8*
zhphcLH)VJ3XlFCl?N?pA5S^0Co;T>F65Q~ibnfNXWZLiKIBy?7yb_zwe<VYm;I|$v
zj>o8Q_p$3!s6z9LIz`h)U_;rbeR~eCnHyoe0Ao<pLB727q;l#N<UD;M*wzj0mf6-D
z!GON#u<)S(d-<Jusd`@PFDr`GSI1+LYp%l)yMd5bY+peR>Y_7mpRctyJDTXm8`Jj*
zRn&e8snU2lQ>U5wXrVpPnr}V`)0YIfGS^GGWV`R46Hz0|HP}#ipEbX%3ugab*4YZb
zPjh6;FX^_`-&4SEV%a=lJe&0!qHlYwo!DoWb;W`*-;r7WrkhZI;S>%rJz0hr*~+PW
z#c#SE=E8-Jx$MIgU4-xrJ|eH`!iC}Z7<E+_AW-x&{&8B0;5HH-)8n)u%}+fw8Q!Co
z0XRIiJHQ&p4<VpIB@|k)3!{Iac~zeK4NUbUt-ag%nLOin{?Fuq49Y$1f!xVY(h{9@
zQf>kLgN!W7`1MIzva`FC;V)-2pp4L`X+r{Ch7+US(hqyEhaY~|l&Rms6|!-dv7IxP
zo#zvrNZR%^?Gwv`hrlsDRcW2vE}b85maqd(7tvS$5{-j0>30ZEIbYKSxGx+}1NC<{
z2H7mWCgd;+TGj5lF5Fyr5|0Vd4PA>aeG-VlCX)`qdDY;#^lNv(LKta^hSGF!rxb<=
zlL6xqjO!smX}C`$L8X+&+9zO!aYOe**Ef&~#63(AT?I*Zl94bdQsSl3GokhNnjut%
zhrOmsN%R~h55gLuebCTNH+7o}|AhpR-Y!Bhf+5(QGsz+32Rq{^m!1;OKxo-yyT|P+
zzTG4E3=Ci<dV|}1NSQfG6HlTI4rGs#wM})4^^4uH)onh&W&LrrP9bf8qtqgfBqfLH
z<GO`trGErJuyUk95n)WH{^>7KI&SOnGNuzv_3&-+q?e3=x}qQb?^^@EWP<N{`Jium
z1HWAjia#-ifE!3{<A9q>c%Suu+#zv0jBFA&P04GR!{NI-BWzLk5Z$ClzdL^P+n8?%
z{B@|Q%46B1Q(AccdX_YKf7)W>y&T^NjHQEsQ0`aHj%WKur}%~~Faa4Yfi#dnV(?48
zkm*=L_k{Fx+;x(S&52`DRE3u~uG^3{;HrmTDRk~}CpwOn1KOalgmS}rgCqUlk2+8q
zX9yetccl7IVrg8(j&IHJa~cYv809a)giy|x_buU)B!}$+#J2wf6Ui=wIM>H!>l9jY
z`GtgrF9~ddQq+`nh9?(!9kF#ZO&OJKwv$X3&mRm$S2U@WSspZZ=T?BKlAyu?#g~0~
zcMXa*94^9K7pN&d1Zx+0MuKZn4HvPKLQtBL-*MvrV0l@bMy8>acS@n4B{*6BX$V}=
z4-<{d6h)xJMdOgP;DnA`dzz?eMLVR?Q5Ph#S(zzVqd)+KmvJ*G^On;*vZqw$4(U4_
z0mDD+PG(9o;lU_a%Ymrp%U_N46iQ|KBMJ2c-ln}Ib|a`vr-3O=gq&iz9(N$EW|y{7
zna@x0GF=|?dY+Kt+Bh)9tBGT8-q*0|{u0m97Bs}kt2Cubhwa#^7wLNs;EGY;m##ol
zjkzI58F}gvXPy@)WiG4OKqM_b$hW2;91*!o0{EJPV+P2%t1=NFpllC{SVYc~K*DQ4
zplEOpwZ?F;8lu6i&Zt;v)w~8oQnB#czKF?Xr$(jt6n={)R5xxszJb_FLi__Yj&O3O
z<|0t11Mj#>=4+F^7aw!1<zFTo3x@p^`_?~VSiea?R#?`VBGxHbnE}Vnh%n{Y3mL?*
z%_NR(2B<+2)DM6%<=9mmE=1zkP{74XaEof-Y8bWvpfbbm8cTg~m-hC3%(2Q0nJWs<
z8OgJZ(<RdD1m}tdQ#i*?L!!j7ZiuUMj-6>zW{gzk$Z=k#8-9WNLZ}Sq*xtisjy0HQ
zqNkO_9FeEFLb95FopbCJBuX562NO|VPYIA#58Z01%*$iEp1l>ko=hr399vjK6N=))
zwK$e5oh0aTS?Q#4?sX`2(i9&c{@QVehR|h!#{6%?pPCX|EV@O0eV_B~-2JEqx5_z4
z++k2mXp>8~%1J;463|*12&RJ;(7<%*rcjv@)Cw62mQDf+H3j-*J8`g;S_XoFm4NDT
zppTqfsr?Sy>q&Rzd6U>mcjXn%!;sWmmX{h$eQr;vAg&H500uoyLsRN<5)SHR`WzbZ
zB|JK6cA$3+JgMpNpVUwcOrKU%=xC`6Ah)pi7&dUW=>kHRCaN%N!iLDwNsU2u>wfIk
zrsM$Ur&r0y{XW8UR+?R*^S5Z~%I2tJ8wqVO6Fon5l~PdQqszWX&lC%28glcyqbPZ)
zrIQBfmoJlC|8^W*W1y=xBh((W1nXuo)Cz&Wwu%>RZ{g5Z6gKxgkM<M}h3B%WL34Z~
z@3iJEb>u*H5CCW|0L}`RYTSH<8oL<Y9A5gs-|DSiU#ELoKE4UQ8u)d3kno{rF8lYP
zZoKdXKE_n))It(IHdg9B6;5J`yJvoSW6ve<u&57DFZ1pXtJVESIxiuuZ7!R;JJMAs
zkHie4D9$B9#hda?B%B*uOR7Z?>b%rM{m|=D|Hp8AJ(0-=lT|&^O;p~!M3tPW<qnXi
zT=ZBMX~U3N9T`cBhzqY%7E-S@!T~cP;*R;Z>dr-kzx+9XHrNiRwN(J@!iplt`Jl|Z
zNR;`ycyv$Yx7~7$lifqcSVQ(xok|$iEtlD~iE|T@@sag<il@1QG|ZOx&4>A6nl#K&
zr_&@7dHpI4a~X#D{4OwP>8?3odHt}(QkUOdpx)ibgi;=kK~-3v=?^sh7Nv&?P4F>$
zQF^fYZC47+^V4UvuFxLE$cKenzUm6ir)qMVa)d54LzSjE#6NnMq3>9%Ygb?4o35CU
z>N1>Jks;dAF%MX2AP=9HTzhuA9QS?!<m@wDaL`-geAMuE4Yk#vPXrXUe-1=jYwQHy
zap6}q+5%Ha^Zqf;?CFl&ct;eZ0>jTyfwatA_VjOEQaxAx(=0Q0{sxWG0-TZXQx8w!
zPApDZc8l@#+!re~X2V%3wFpy7Bl#VzW2VO@X$j!<N{c)!wqhfj{MIVgTc<QdODPaa
z{}m;d)Cu3OiN?0@Y?y5T>O-PFFyBEL3iiM{#?CqeV?#Ty8J_G`EU?zvIyaX`YsML>
zItM-wP6fDRWC*7_=d$1zx~0M<%;;w;GL*uD#@Gn|Lg#DW0=us3Yf5PY|12Ah-d~7~
z%VlpA8I9sy;P6*AFeondl^DG=*BX0Fb+|?3mHzxGgau2}amN$t8q-PY^e!YCsfyZL
zCgls`U`q~^uFiC`g}74D(<iBY+xygT%kBLMVfB)UWoiF7yTg7|G;qalPJIAZ%Xsm)
zuzH%>VB7JV!0H&m(q8MD3E4ws*<~6oyB<EDa>!Tuc_*m$$uPLamST_Q(qD3h)=eHq
z*j}?)5qYgFl5*J`>jHPHJDAJ#W6$bpJrxJ=Nj+F}oNyFF2@>b*{}&aS4XLgW8V$+<
z6-G(G{v6mAz_lujf1?W$$}nr*xiiNru%iUK@0ck8x&Dxqr{2=iz%G27;VO(l8LFT`
z7rD@I6as_x%EiQcVTzXnoS~GmNh%`C5nTVq#w<+nv*>`4UzpNJNtx)uouhjUbPR#Z
zm8H3i+NQOP`bjGZYyrS<wgs^xmVG!!A*{gkbLQckP@zt+EP-iLlWg7o0_PG|FAiP@
z;PQ~A<z;$UMCY>pZDU&7{c?nm{Rp*7R9pH^7c4aC3n_i4YaRR)+yF&N3RYh^QPL_c
zIlMREvAD@g6_I4HrN?tR`WGZZl_ZWr$SkEamtI}Yi%uz>WSv}m%o@wxBZHs{txx21
z7wRYGvg{Et0ls(DQUM}M^TYok^Mcr<NJSE8Sld2rgIVGN-n^w`pDcASM9gn+oO6Sh
zEu>zHhp1nJpr_f!U()@Ae?X*5zofSa*qczztf^%MkQ#$N;<`QVVl7Y=8w_~}^`tgI
zK**qLn3xYp>iV&R6l_0a0%F&MDlzC|my=&`OaC(<uwMZR-pEaoow<E7r?cgW6RBqN
z9mI4O3yOQ!l`JjF<MJ#JVz@rHzk|OI>MGkc6M+K#-szUi{B(||@Y)-jXHMsMHE>6L
zm09~HAXj64ORoh$>gk*aAsQdkPUi$EMnNeIKbANF`BJ1#Z<uDu_MgsaVR3RAyJRl<
z3(Jw<ekMm{f6WVl&UY9y?9PEcPCApLZgvrB6;`u$<CdfU!;ckfX|8HkF`JiI4Q0IT
zOisAXZ^f2omDvVG780JF$?>hX7729!+5<N0bdI0PA5giqTa;bQLIu&s#cUrD>mfoV
z2E||aOU8r^62u5$!XNcnRy(|zwb>_k!H5E-%R*3vSa`x-Dl!DXPztvNv8!+dQ<4^z
zVu0{HKC;f|_z9ol!!S3_)o(ETnNFp7E#06N9j29`*_}!!w^Z@<Y=a^ZU|TK4D8U*Z
zPc6j}!uJq`K31YiI0TJ6*-G^A$b=6^)vn)Nn<H^M<EltM;i5lS$x2Lh2u8j^q3BF~
zAd??fN4#nA;Wy@3S5ydbp1G`XUGbDK(LI;FtSfe~4|fOJvPp=QLI+%C$=0H`@Bx{l
zti^EqlgO-i!D&p|aiz5wqG4`G`--RahoUqNki&GkR*G{_F2TTxf|yYf451$<V#JDg
zsz0!K*AtaKVW^=JXJ5=Du%pEj$&IFde%OIvYWI3#!@5`Sg=$!QUD1twT~7>f`x+_O
ziI@b^n^<Oy*!e$lP74{Wa`Bj!__dJSFPD8jt|Ur;8^)a0#5t=}uod7Q73ZF##r{0v
zQMPL%4~3l?j3teql9X;uyh+9EYD~F#wqV{UeCbbp$}ZZ7!NSW3n0{NJABc~IH*$i7
zaC{uSk&_@qw#WWNJJC~6;$#1UIHl(&)W(l0tPD3O?m@=-+KGWqXST`?6K{n6=4>|S
zW{z*&@1$fl=%*xCH#g7!)t;Rb*k5*{%1Z-KgQ5kr9B!q<Un5DtmnwU)nXoifwm4m(
zi@C*V5iBv&!7WsFEfij@QcLZ{Fd?9Y?ETfl$87%$Pm3yBHdh@RC>(~W%Xz*=A*{v6
zw{;6VY-E@F_GXM(wu9(zzY|}0I0wQiNz&o;hF(q3jnvZC7+iy58^Vq?+dms4%D&`q
zx~K3a3?BF4^pHj;!#HOV*SxAP-C%1#32?#DL=|TbGpcINmV{6Tcoet;uZR!fHv@3+
zXG?;=-76et<E~HyzS!K)W0a|P8WR-{t0dn6s3ZUj0MHG&oh1CVmHIlAA!dx-MBNDj
zNVWH^aw5WZk_r11%T=mD!#usA+6n&PMow2!fHe$?(HL|ur=_LS4$M8+y`0Yl7K&2$
zbCM%Ehw`T3g1Y_*vgcmQo84ypk+J#AK{hr4^<-nCc94yYPo=fg2ImdbhWDiMYTDr7
z%Y09ys|35I*irjUdZ;iN>V^BqWSxEbLTga-KU+^l$JQ!}<~x3v)zbyuNo|eX&I8*A
zTtr{NG6?5fdnNe@(du0Gg^TE^nh&jKR1mthTsa&kk#CL}H+0=G7ct4Z-8!nRF<?KM
z2I_k}_#k;Q{a|#6ah=*hG^vI6*HW4D(30a7Vz|%)jLl~%ZSYZGo#$y$A@k~U^px}J
zb$pD8OY*RhJrGA=VDYZt)rV^c*QK^HuWsz0<m%pPdS`ehg_Z%hL(viD^a0;ItdARk
z_g}<B`_a5ekLn`vy~ah>gE=&DOYJtv=GYvdb6EU{xL{!-jCg?(D#TfD%hq3u33P1;
zAk#%Pw8IfVS4PCO6#jtcZ8tK`J!mhOurihyR&uNJ+Sj<#Kg#_1&nk3gfScITVK=^T
zwhA64?$3jRxx`Hj5meANe119*<k^@jdV0(9ujbIr0Bz(E4D|ke2{VLL45#n07*C-&
zKDvE~c2l_oneGIGkAaXfl1NIst)yN$PRML2V1!uc*f<~7!$VB-S_uEppqPihB)rA-
zNT<>O&RKyLpP!J~(83F6Y$jxeTDGB-poy72HcET}HOhc+o{+O5EIaV_kATF04?Mjg
zFob2<a)SH<`n`7hJ;jdoJMz3R(*3HOI1dY$zO{h`QMNx*k&6*D+Hk{iySiGaa@pfY
zah|N~WSq0miWr7wjND&!k-23oFVzdBWPi2FOKj`v&r@wFwMN81zIbo(GokMu1v}y`
zMqtI>ye@pqf$wo$-fCFsR3EXiP>7ESK4PlS93O5|GQBMD?|mP!kFd=TM?Y4#@)Q_8
z2KkCniXJ3IwLCO6+PKbF>>>PvraL;9dN#SNqWSVNC_(IX*g}gM<mk3ZDc!Xa-?Fc}
z!xHV#s8B8g<(8;K+&>GAdrT#EvbWg@8(g+)Au#BD->|NQnI6IxaA1s|*v)z0Qli<a
z<}{Q);xAE7btAo_(5_A{tMC(h3x8SVvP6F%yo3=N<1YsI&9{<<XxkDhy95Jfq><#A
z%(<Kp;HV;R3XiQ36RmBJImoli37(EGz(i<`8CU9Q7`gEyl3EMvp#@frNSY|Lz(?T7
zq~<YZrf~f{cp;h>>zk|Kbrv7WCPz3CF=Jwu;P0s=iV$i)c}DSyQWwD)>~U=Uy4DT8
zqs(8L@d2I&6abhLASMgJ&NA;E1QUYyT$~~}=l=|2P}u~V`kLi3k3g}peSMDMIV6jl
zJe9S!t?;W;E_1k0s$@R}iVuWQ(3CfQ@|sxS-(MPukqt7xrAjs6v1-k?AV_o#z5L-L
zk6dSio|X0+Nmmhe!z{*{1~-iQHtDLY=StzTaXpudk5d~W-9vhlXNPXD_=bBJl}$`E
zu{YPmH|nDcn6>Mma!v+`9=0O^ian@MO5ozEAaSt6+eMUe4{AoDnQBy0taER;ceO%G
z@VquQ7Naa}e}HLw)L4uQNREZAFWW{|ncAS`U8++($$$fJTZyYDnuy_wv6vfG-!LJa
z2Jv^yW%HYe4Ta~vxolSxF;aL3KjWV!VoTLoR|5WS0<AiN7BQ)1Kl5)e5F(ctsg6w{
zTm?`mIZa`a{))~m|Ej6zWiE73<g(4d;v!*{3nEs{#4qcV#d^Q4GO)YN#GXQrX75;Z
z2ujWcis2z*qR<&1YeU3n-2UMF3Sf^z#3Erv1I!RZd1BX>NZb@E76Q-77x-?~Tuc$P
z81CuKML#6=pv1M!#ZJNpbm!mZ;y~-N*k#YF;A^n>=Av5Yj^v-iIBW!x+37H`qwpu}
zx*{A6DaS{AxY$T&)c7466^^OWD5T5|$BbY-L~RqL{1Wtz{YEJt>`_Cw7=t^=kNgc(
z(JjOsf;kdjwh+_&LtAp1&4lJ9n&G{VZAJJ_E<TF+Z|uTnC@`|6*hOe(2d-=>VvCV?
zeM)@UQd}?Kp;xvdLTp#3EJRU-#L5WqD?zlud9g@Q>2iV?)pS&gk%Lk7V`m~oN0mdP
zkB9b%fRwU5gGkFv{hBRpBDx6-q;_isBmQGxE=y@8`UroZCF5F&9RziKOzc`=W)%gA
zsoNTKIRbyDMQgFYFdQFqTZ_J7?dxH#(HA0)_#jZ9$9j+c^>T$-1u4FYQK-oz<JNKo
zyWJXf-L=kTE>U6!&u`%^@$27@7L5Q`LF??e3S{~<KPy;Xl=y|`^SU(v!)1VY0<Z*t
zXB*J1v~DgN+Xj=jG<>XR1M}{I_Fry;*5)_MUC>r^Y1~+eZlign9n44sa1SC@%J~Hm
zt`NZr8~idT1V}_oThXUQUxU`HVhC4#SBT%KASbfJ^k_+*@VrtTlndc7TU_C7wH0>>
z>%bVDqQTCWVIG!6L(OkTL;j5x<AfNbM8}BfsoT*Td1m&b3&&kK##n)_3xpMx_r2Dv
zG7;~-N)XjUtm2vdEul0J(;fyvx)vjL7Ye~5VX>mCWu56T;GJScFN@Eu*vMFMV3T`X
zZy_S7nR<*{mcxHwlha`Abi&p~XkKH$vnp0>Xc_(m)Q7SiD7e`Io^iaWWc}NLAGA>S
zQ`(8c1t%omZ%0Pb9GlDI#LSQ$<}^B6;%Q?GbRr(o*`>j^Jg;s=xn;ZN*kQaHe6V3>
z;vhCwDEoIDD!F3DD+w3ywkOMZo8uwuMM_S*7#`By?Ei;0f^ucFj_+;Qxp=Xe^S>B1
zGGfWeSi>A_P=rIi?Gr>-Cu=}g{0P><v%`*{T?@7}0h8=y1}*EEAja7&M8V2d@YW#U
zOA^rC*2vkPAiCI2C?e%M1fD(A@$Cd00^SXsUVDb}@Pn3hP>UmlIOzS2YSBd)iIih%
zF<cYz0f-wK6fyREplg>?B9k=pxlzQ427OQ=)#U_G?CZi`qp_aDHjYjT^vb`h{m2Ws
zcT)>8;GNXP*rKEj5jwutvQ3F%n6ESOPZ-QirH_ftfpSL;18-^<v=<wCHz}a{ob9MS
zJNz})$KA3qNr`qj@3bZyvVUrvzi{%kmVJ9NB|<2z(i*)q#i%N&Gi|02(uTHVtq{H`
z&TK7M{jFtvJBVA-n}Zh(iYEArHc^jh14^a8LE$PTku_a|BqECQWWw_vvI*Fu#mSI&
zp8j@{Y3v2_xsGBd%gx2$+Vvg9_JIZXs@a{ET>AM^$R~CV;TQ>jTcgZQ2Y_;Al4xsT
zbKw;=`GG#c?i~wF#;C7+rDa`{#aLk^KE6zbTJM05&B-uEhL>9QI$7*%v+Si*sDbS}
zHlUOEn{eQTmbK~(5C7jvEgRlhOc$b&vb!^E(WB>DW|IOmC-4!PBBs_m0LjIbK9;#`
zS_<a(@klREfk1fT<9Z6jYx6(grBq19G<@)~gYmH-Rg4k*@xdEq06kx)ihjzLc|;>`
zDD>JxS2ZrFO`X!ewYb%a&F#C|O&Es~G<^u|&J#gOe%ysSQE^D3vG_9Al(3SkalVU~
zFT8-TcIqmsT>sQkb*CZF#_AvyVObdomMx!YvG4a#lET#kUo?QD0d0h1Rb9nS%AH^m
zdYX$nAy_Dx6mL*8g6`~=CMw~i&$|TkmX#((dR<V!aVpJKk&_jNP_dirJ|_^wKF63A
zEWOcu5250zmf3gXWiMYuPH;Cd-mBy(8c>=WMP*x~Y?xejB0<dP22<vPVkLj(1S_ka
z{I@;*p;SG)iyk)0Z0fE#R0F0H-NmLti#IaESKUvsbABUrbH{jsS_V-DDI6c9cv}3c
zWqZ1du|eH=P7LLk%uFbZUmRzV*NE20&OQ7WZ*dJt@(?bZ(X!b?l6;*voRRQ8$RfNK
zAjb6EgxJ=y(_>KhnRlu)i_c1`>(dNBxnyJi4yj#LGTlzX<=g48mfcSm{oNitl5oXv
zT#bNBo;iiRNQo8}J<_tw9%69N7=V%Jd7kC(qv*GcqpH6n(XVMZ*9bjCU)2eniGX1&
zqiV(ycXh`@{XFd<dK6Yxa>8nAGBwyy3hjjgX*Frs1(ti8r)AWnWk5YiX@hFg24Q26
zls2*^4Li%~as!c=U6Y2W^DYwUQY?G)gb204%xHU0xChzL=5>3)89n<@%bN5Oe-#Gb
z*0K-1Ftu1$p=Ggm2P+ko@L^!N+@LSyL(0jJ(yAdHJiUijP$T(EDZDNbhUYamCMVF}
z^}WT(P1J*}Khn&q3%qBw$a5X6!O1g2&ogV0XN=UvTI6xK@n7=1z0T8Wk>`PwR*O78
zV*EhvTIA{dTq4h-3^7Rf9hRI-uI0N2B)hNrx-d;2(ZPBCdH6of-V-mpqLZcLo@v?W
zKA_$fD8n!Mh)ume2bIBlAOrU(jx~Xo_lgr_EI=;y5rgW!xep}E&Do}fG48@2_hllx
zaYxRS$Rd<Wa$ihZKL<=sU(wTE55cN%;cnH>P`cmr75fz$?){fucO}}?qSuT+{!6c1
zDXkX021;qQ=;eueKc?3?=rT-USzbS}q5XU`qJl2WHz>Y=hX1*rIHd6LU;k~`1!*v9
zHB9&We;YPfN~_hdR4J`i!|MI}--hiWMT&-f-d}7SRe(lRT;%jG#sG7zV7izz`!q*T
zixoS)z?fI|6TJ%mmc+6aFaCCom#Ec+Pp|T{TB15!N~_g{?owK<F4({3Woz-`L8xhT
z!FK|wo}=GzcGK@2MyhA!KUxrZ8U8}2E**eLSsgf36$9YTUxUQ)FqFkzEe{3EU#hK>
zeD6<qJD~=}W7slcOnKLe7dLRnDHE5KotHCF-Q`76b!UcBb>+yYjw#Q{gyL8Qj^CRJ
zyA6|vEmlzdeUM^55T3!RJ6hIdpy(&OfcK*vD2{LJe24m0Oj|6tc8JnUJw!iv-NP|X
zm5p$l8_L%kBzk+Cg_M(Z^ciAm9eK1OevmjuNQPqi-cRc(1mk13pVmY8?RzOusl0y+
z23-Zr@=;Z^{34QA=$e>DEZSeI5=w5t&4}#aDU88~{ZM?Q;^P~Ct#936KvuY0u(>^2
zDFg?k-l30IH?^!NAx0tG!iRN3ZDX&ka42z%+nQ$gbk+L|3Ljv%S;k0sSpA2H%yQJL
zx3F1(S|8!o4HOE{#@1f~Q6v{)Nn6%60Bu(<mSd~kk?~QJ<4|bFP;rHD1LmjOib!Xn
z@Vb_b4Ace*J@K(@nAkN`fCLdfp$*)_V4Svqfx@s>YVhYHbXTuwneQiJyl?~F*N{)d
zK|Ztk)0pPL0AUdle@$%|f+V*;5j!f5g8OTS^Pc~qWzoY$4`B&DGKOQ(aS&vjocY2M
zD2ti}i^>)z{MC<-@hIfej^><)|3mgtxTeW<Bop0C14l-l7QKU@6Cb4Xqt>>Pib5P3
zlQguRE3s#D%JfjUBe!OnR=o{i*a|GF*dB;$Cb;~DL9EbvuutBt^z?!IK-<PNu!4M{
zJq}16lgkPaoH=k=%bsmZbz$pQ#noXCJ0SFyy;pK++H~i<o5DNPWiL9E0M86|PwFjU
z4C4?@IYfKZQt68=%CMf%BSoKv|Ma15+<;j#CAahz8XghSA6oH&O&%%6G@eG5ujCMQ
zeH2a;Q*Wp8vSVtMg~zoB>%C5UV5Xz;;u_8UILc7~r#Gdv<vvW?&5~ynIAR5Dx0W4R
zl%x^r>B0QpBzgBV2MlS2QLt~AU{`Ae?6bQCHx`MN?$~@UWm1DKV2(izO2&3)V!wn8
z>QpcQjGdaZU~E#m#tVLv7_{RKI(x{iAnp#lh{Up8=OHjux|0C|baQNyk7F930Y!V&
z@%-jRE!#R;40UcG<2YE3#kEu{e!&1<9-9;ta`mzacuOFy48nX6_LM}xkp`r?MpxiU
z9wVxhcY9Gw&%i+8Rt5a6)@DUx!~)^vB`q_bk?AH}!-v<5OqH+$A8|7>y@W;h$Q&z9
zs3-O$1cUz4vRh-t5X*S{WZA2dl&;%;LA|vC-wn4x=ll@X)mcb^8c81~wz1p@6T&tv
z>FU~a`&Js>Tlyz|NgTYO2jMM3KCWBEUn3z|)yzz9q4iEJb1cbJIb0|2hjuyQavgM$
zUHCV}&3&7!EbTa!SJ30t9ZSo?l0-KATy6_m!#dE?R1*(4+cc8%(y7|XC}6A*4_(VU
zXd=Flm$b;3@FlIi@1=6BcsUiczVCQ(pl}~L_`=?wUA^JUL7p_2Q8-LfQxLECkOndZ
zp+5z`ed~C!P)LTa@_9sFTLIn^U+5O@!`Up!7C#jxLX-50MAo_LELUXp$$>e$3%xsa
zyr}T#hdjB8JZ#XeMt}O0mYwfV>dDULh)N-7o0ctUrfq7|7m`_tTR8kN0^V9tX%j^W
z_E^J5LY!7?Ej)pmCB(w;vmlaIbn#)(>|B~9W#nL@j3NMYNQ+3P4L%-e#Xy_4TYyi6
zc|1Y|*l^+fJAM;kow^cX-$Jb$6ff{sj!17#!fvC@S{AiAse@1#eIly5J_G<2`m_rb
z8pgp%1Luk(+srh^*OMSE*ndGvCx(<2@s9%e)$$sQ1g?J#fj&@IQ}e`8^}EADKz8w$
z^IgYzd$e@widWYvm8w%Ak9XH}1M3)oQHz{8$a{D>M*g4~PWGt;A7MK>GWS%1tMJM1
zS~g23rU@Pxh3^ZdD?5y>S@nB)Qo__RMcO-1nuwKw{dtaDNz%*~6O@zW36<@tf{N02
z@qsDB0M&uLY9orxY#wx`R$hR4KyW9bNM&(UYqA2ic!No7#plxvQe{JU88RuxX2U~D
zJ2JYZ#R)B&eq?k9`uEY!$d*pubt3#TU}mairbwBpurU@yI4fTqAe0~1vZ~pc9fa}t
zm^ncl<}xUmN_Ilyadr)VxpVTL!r9RUZ7q&zS^tUHY?Fr%x?du)&oS!qBuD-6*61&m
z^yggR!>~81+Hb*NVy6VaXdFJ%zzc$lcPh@c-scCje8J3z?e7-jA?$)PVEd`)X4@Dr
zc*OvC02%hF80T~&iBgV1f7W#EQ?Z*x<uvwew%Ew^?UC9}2coI^BM^%@2t}>ONAe`G
zdE-kR3CCWjT09<!zt|v>L$(Ck>zKYAnboMn+ILk65hym-u0Y}81>ET0AZW9Ld~l0U
z1XHAgTK4xOv5gRpkI>1Yx5Av`ue?O~@8Pc`C>&YdVF{Uc|HB*wIg4;Y(S0z>M*d^<
z0WI4$8ThjB@eKHywd+9bZOrlc<8O^N!;W$6-D%ECPr@ua5GC49L2T*o{aQ9|il_`f
z-kyqXh9QBG#9t!|)F8pT<J2)4nx?DJI@(7)_b180UNA4cPUF0vAf51`Q&66y3L^T9
z+qqZzWR9Nf6c6}~>Y8c+B5WAd)r<b6s8jGj(8_py39lvvNn|A#Cz|@f7-7fZt9Zei
z1z5Ma{zS`y3&qwx%Mhp`hWS%XeK`$%Y}yN!b}-3Z$jz+J#vX*%ux=SwTESl}lM3bX
zLIY|QLR)2XU{Ks$E_b=pGD&m!g~%lpyrcmt-B_J8l4(WaT;G1k05!ln&p7W;3wtMg
z#5<SvNyDw&y^ltC5+WQPP(%2dfSm?#aJo(vTM1X-z08~{dV8*jrykCQIWQ<n@z+=}
zxSx2@r5fKmXiQ*%5$d~}e`RA|DbP5427F3<Xg&kJ2XTb&!db$13V%)TEm)WlYuOrD
zm{Xfo&bIiV4&<N!bi-$26J;f}6Uw*ZA>I}-7G$bo(N)NUd!w3)(A6)CO>|WnTP&eD
z*N*D_1&-p!t}E`N!r-Ij)<w}~c}^PHyHLW_S_m$KVUi}V*mC(doblD#jX~^Du^8+g
z$x-?eN|U%$d#n<NO%q260u<QdX)wjz(4cmONnXNcD8tz4VjsuMT~y(&nOwMj*&&%m
z$2Lf<UiVhqLwBYeNbwZxcVVhIT^wI$@lJ59BTJjLRUu4;pCW!Ph7U;PiNIqFpteO4
z5pGsAHwDS1mH}i19H!G=O8yAcoNqAsdcrI33A;f8RJLme<VS!14i;mU@SNzAT9#dq
zq;fnDm#e0+!R1=Ev>+*7DEdXq@@I&N^*%d6Lpd2;J2V4x)eo>6&t`~?(^|GAf_w8^
zCH~3^OnQzOcU_kiQgl!sgK?|v&~;kPM?(egVLShdHz;1h(-<{VY^Qv&sycHG{5}jC
zGJink-kGA(GrtX0Irum=s2~5^6MrQEiT^Xs%>s?TeIdrx@lrXaP$tXOY|h1mM#A^V
z{yk*vEw?B_V>tTXaZQ^gmI$8PwQRuTah}3^)ca-@Rt^uGmj!ku`~e4>5ehaoU0cs#
z1~|ClTTaZ=P-pDfxwufatW+G+JFXSg&;*G_X6z05*BI%t_y(s78F8fs^EAzY+c-2C
zv7e8#LGkle^uG8|Jc$Esd^ZHX-2~6?c#^7_F$bDylf(;KBdNmgq2Ntf70yr9-bi=h
zAFaG&K-dcRj?U^-Y@t}}DlgY9Qh865H<rZS{2r@<94N0W7u!T%>Hj#2NqE}cNTo0W
zC2#ME>}P?0`DqBGy18!Vt>xPj{vC?>MPIBd9n!Lby^-Bj$RkEL(vq6E0itNENE*7O
zv&F6!XR;-0dILQ&opZyQo<z^j9gm3>X5l0D+sw$&)h!6u*DykObQXV)7N5W{a9jE%
zvOcch{Fh=k;o?Ru3z!4vVJ$vRT}ki|l<Q3Ary*yP8VD1<!~kb#6>RMs(Z^5yCG-O(
zrla>uPDM8AFa|?xfv0kg*wm(VIJL$PKyWR-%~V;=Y=huM`?-jDcFU3@6N5L@?iLDk
zfzO3*HDc%HiqXQu^;%Z8IMcmOS;(b%SU6a_I5Sb0j>NwgXT~~qST7N=gAGKybeA=o
z^8is4{a6|M>vjLZeh-~%@Riu6&MM?p2C*L|r8rw4ZTMGWRQ>g#)Z&Fuw=73YRWxc1
z7#gG2*oj-|iHoq11Fdni*b<Wuu58Ak1iSl{*j&|?mkj_!&3?t=I6Ce~XSm9)$dVHC
zjbz$9eW8npgKmXTl_y|1YD9u9wI9(#p;`;xsden@ENn@|*U&Xrp=<d1<_|y{I$!ii
zdJYvz>P+4h*R;kz{%Va>&E00Qe{AZ8cY!lUZ8(ZdJdp>5`{jIbj-R)L>}c^bVjcqU
z1b~rwAO^=G-7Hqi!K>-`;K8eL_~`pE#;bl8Xfk@f7;?6;QL3MNrRD$JLHPVWd$>T1
zNjyust+ZH$SQmHOan->t`e9J?hpzj_VSKS8A_Bu5E?JHJ--vYg*(fGPw@mv#5#1!^
z0B31=0faCG0V(KqgJL9f`4uL1a0zQl1n}UAF8C|O0hfYh=d=LJ_E;z`5zJR=S)Cs;
zW9uJSAu+`PZ1Vph(^D8WT;{esWSEL5P!3*!MZ-m6lI8fu;FD)RWHu#TOyRaVmzIP7
z^4ZlBF@bf7#_xmnuxv5awb2*IAg22Qz6>$lVORssbj_-n?qCp*&HhGg?))Xb42p?>
zFmg}PzDQ+@7ez$VY6Bj)_mI{M0|FaeJ^9YVJ^`p#`Ao&^GA(oeR`hnyDw7EHJvg3P
zRfktl1&!bJTQRi#cnEWCrtHbB<RokTUnrp|o)l)5=PMg?oUwuvQrpPAguOI(8sRRy
zfy{Y3jqnfL1{+z~0(UoHtkF%rPF}l;LvR!V7K@Eq%;MtsO8+L1di@v1)S#e|HL_-n
z=#kL<1M|d>p`?DH<>$<l!Cy!WU&;~aP*l>i=NF45%Dd3(oX!WT+5S!dxnSAf!PE_f
z+;VsP4W?MM^{u&z`_DHpgQ6`U1Ej(*O_Z*mjjcCCzFxq9<v3)rwB?yG4)ABe+|o?L
zWvP~R{$32K_i%~S^B6XGag4I>5L2K%$g334tl~*3ArEI;C#m$fWY~b<Hce4@8x{eE
zDx2DnDjNg4VkAg)umwwe3$<+Qkb<cG9LgC`roQ)<QW{uKjxP?T1{=~T03e5g41sIN
zwKc|tsE_+6NpFK+^`~kNq7co2e@zGz+W(+sKLo~kIR*Y8wM+*PiPE>1h}zJH8-a`m
zA8FR4UvnD$0m8d}gy;-1jqRto%+e<@&4s3r!(X4o1Pb0D+nXmb5yJf?S{D8^rm=FD
z)c*?HTw6;^oj(xym9Pl2yx|8UQ-n^lFqb<RIn1Wt_f-1>z30^TY|h!$3L9w~ydf}s
zzLvE=6d7P^3kV`;e_zO%`G^8n*ZT9Nl(tC0n+&izTt%pU#OB)jK9qJIyvddxiu4pl
zeFwMfP-F`s0w0_VitnV-p8!%KgX(Z39X@?j1dBFo)ADXX5R{r7?<NjfEq<Q#mCS<;
zFt?=0j^7K2BQ<ooH#K2AEQTrN$Roe~lb9_m##}P}XK`$=5GY6v@5SL^8$N=snTriw
z3L^cFslhcJ_|bG~unfY<&mwyjYFW$WVl%(T1yUvVJgJg%umvAg!qSdnUh9MTQ^nql
zmKKmKpM4qLk+MPTi(=sS<kCXN<kEaM{X=XRp*E{Ix@NV|Q6xg2;On$)5!9Qp79?li
zi}PvF3(kc}GV#*+;0|sUi)44WJ&M(GhpUc8s=Qo~N+CdOSx8HrZpaHuEgO#QfgzSt
zFj!t*-I6^wV1D$!M+-Y`R*LOauYV)}{;m%mD#BTE(&xpiV0%;s#UvP#)c9DX;sBtC
z??<^4q0(1!iDYRf<9vm2Uz<juPKzcpyC$neiN1fjQL)o7I;K6Z*6)8gSW60P7siE{
zrNQ@wQn}B0xonhURfjT?gRU*$>c?og&?Y=pg;XND0?-oAZhV>)U^C}a&KHjQed+Ah
z)1>jjazyF6RV8KGbbv;owTKr#Ygwl?qL15OuGGG>Kby9XOHI)lv16xDNECFyUK8ID
zF0C6+y`>+CvdB#?-J3?!vwDcy5v96ul+m?NV(Za|7&i+Lj8Ad4e*Mvy-tLm>C4@m~
zj9)8`R^}?GQ3DW0F%pgV;&yRfuw|eRl#Ii)yf(sOh+5}qc|n2}A6>_2l|uGn8x~&`
z=OIKRW$m=Q#$JwJaX!gNDIGc}b^2d<ZBxs#aMePHSw8qAd$hKb!|HiNtX)M=)cRgu
z*|0h7F-@O34+?2|9yZ2?3>5)cHa#y+a6{s)^<oE~G|bSzd~Q6%J&iPc@gX;9*(i3l
zsayW&hf*(rVGRA6^z#%l=fc!E#drx1W;(KGFQT1U^RZfMn?+;6a=7hgFcfmuvQoGD
z7*slP6-NrX>oAq-(j18e13V>r<<)@5QwM4r{sid{?&-~uJUzeZ1YMdNMvG{Un4CrN
zMYMi~z_G}nt8v(zjbd`|V)zh{V5pCg`lPF9fww`?75bz)ttF))CK)ZKO+6&tNOy}~
zDVDe{%!%6J0RZDLu_}vfU%#I*_W&zsN|W3)rTHpNX*~Y#jhh*ch4sTl{us*r$1~yu
zK(S3d;#}A{pN#s##bV6qah^5m-E8VXq7)uB-jguDn5s4CBOR$)U)U34wGth&cVu?(
zE99lO@cZ&Wf;dg-E@Dr4DRD5yXTfId9gF`SQO;j7-Rea;$g;!F$@T_SYdbdYvt$P)
zt^mPb+~Z)mCyPdu&dJu1wdm*e)TC@!5T-JZZ)yQoCdEA7qaHjNa<SVZ=yGA!=(=O@
zn+70W8Qa8ipDXzIK;LnV1qXmX>O0O$s4B%awtnMO!Wn#o_8aGK$wjehb!m)nK`>*@
z*OYoF&kJ1S7u!;mpMP7!1pBvPYuq2n@?`lT3@M*1pT`Hk*kbc6Y1AxGkOrA9w&?Yn
zq_&^f5VEUK?$!JHjW#CxV}e{5BO8-75HfzT#oRIfbHE^$ys1Mt_7q^pb5Zy!aqWU~
zv0VduWSNd44u?)0*A!A$G!9Z1HgQ}hucjryQktuR1UDuLZX-*u2SETjUAb!}s^@M`
zt<z{M?L*Q)%RM78DC65C1+uFjlA8FA!B5hdiS?+*A+Qmq)x$Xm${yfsO?f*Zx5hlS
z^vk^9=51y`KuX&ONV`L9l5t`W8@aZipOh-?3gM}UEq@2<Jp4rrQCtQ~)%LH0F$as8
zljkOAFpEyw37850fm!~!mMxl-7v$KV8~I(dwZNdD0LK2EqJLDXbY9R=Z;r3p*vr9`
z$++%|Ycy?{4gW!YsD4|44Qo0#FWj<^BY3atE^)S?oQ^S^o7Y)5F%5CRd3pVWw@@Ts
z>=u12ms!EFTEAO#tKS(X4yV9%A@w~kPhpcZ4H_yQ`T_~vzRFX0b%mXR#15*xsxt^v
zxV7MwJ)*LnB{aT4@c}fU0&O!Vqkyb*JxXopo3}7?GQMF$8ugGE^Q<Ke#SRb{L3#Wo
z?X?HnM_WTz+@7p$<YCX1!Yh3y0F9$XVza<6*3~tax68U_p~)J%-bTypYnKZR@H|?<
zn(rA_zjdV+eZm~!6wCpMNAV%t40TJtJ3?y6VSyU59+|akVdsxU#>XEXMco-V!D0K1
zc#IR>=^uhS{o_mbMe$+#3Hg;R9JVKoq^wrRQkNDEl4D~tMroO9pP18pmj##1grhSO
zP>Rz*e@Lo+DY9@=%v{sz*-~*_P;<MfRQ04N{aBC=a$*gS2zwa}d5OupfrS1mk|pNh
zFi6Zxaa?<+Z;E)Kk@_|hK<}xC7P3t}V_Xs{z9<2=V0!056hQA6V<S4Z5P}Q`Y?M9>
za3n>G&8b<R!?4JfD9s}_NU$r?vQIr?`w1K1)$lOe8g**Cf_pXw{c1BR^EGroAElz?
zU<-iVEX3}e_t3C!>Ekv&+={SCXAeH2>Ej!G@U`F1z}-0OOoyh-@+b&FUpR~a@9T?$
z*pl+wr&^YlT;$0rJCr&L9je3aj}MBrK@H)+)51(NOoZIS_%w;YQHI@Ul|M3u&zbM2
z$rG*)K!r0_D;w+`AZd&R9|)odwvWZz#y7E{TLzL1XY{*#-m;%|WrheBC-dIAF#WDf
z_qcvOZ=q%%Ro=&G1QH8{W>ggwF^0mYLI%j5U3gE3cfmFoSqrC`3de=lo#gozZuJ9p
zXWCd#FDHWMif|GXp&>6;c6rSQVOYD~YZt+aXT*7UPU28eV1syqijbie4g^$GRZM#?
zjRcVfhzwJRD1ulxv1@xTJ^V-1G!hWmrVv*%0WorCX?NjMP??Wx)zooLR^Pg#uk6;e
zvED*BGL9Y<o7wk$OTB6jqr+`j+Ju5I)kF+kX?|n!OyCzJg>jp#!9`AVRn>}#S{6S;
ztE^`Xl7t;hrU}^C0jRde!Q@0QZ(uMb0c-*H`t1l}%faL>4qGOWQ!m>ATxS_SQ#;Z+
z28l4kFwU)eU`=R(JoUSkFHQY?_U8jF*xB*l-3D&>Ok#py10GU%o*{YYAy+aa;C-*D
zgR5W>Y8w1e*`Dwmc-cqaN@YFI!CX^C19{nG)3OUrivFR$V%7l0H2T{RHoPu?R4QeQ
zQbrbmDopD!F3_eBxpWZ{If8>`L3sK?6uvu&2xI{KO<sR4bUV#1oO(fV6Q+)@sO@1e
zF%GB1Adf7tc)vqO@zx71=vpJQ+6`cX!eT=(1XKEez!!tFH5NL_hgEJFi(|(B!|2Ax
z#dZ|d=V3QTT&$Nxj+U*6iw*Ve4UW>34#ei`Yk6w8fw+140~AXbA_>`u5(6Y;7zU|2
zc)@2CTx`O*>JCPu4GJ|NXl~X5-J!Xe*KuMfs3X-2>P~%h&PX1%v~!WWqrGYTtX)5>
z)0`2#qJ8@rs{*-=5w<#%0fepK{1TnMe@=*J!p77PByD<(uP_BFTRT0bwX!7#@CJaf
zW@0q?-m0~|K(@noMtAe<3iD#*%i6&E&mx5WFGxjmBd^;zG#FSWb)wT-d_)5Op%I}0
z4m*eAQsV(S^BfLvEgpe&t#e|KOS6xCfFFinFW5P;xnf@_II7l`qyflsJe=9W@;HnD
zkDxn`fR9I-Xv7)#{Ej&M3I)FOyck?K_1SJ|ns2&8cK2Y~KB6MS;HW>>7)AVW13Qoz
z6bbkXg4V9^3l8tk87~Y7F=YUlkp#FS@{A$HY-eNimZTKF_ej4BrG)VPwc`UH|As2T
zM5nhK3KtQ{YC(f)AODswH$C2|)@7%|&sP7YRltNExL%U|GBVY-k0tcwJ{9oFcO5VO
z3`{~-bPHqwN{->8)Ot6vfGge+VQ{O**Rv1~FGP-IKuSpjHqiACfZMSb60pzFh^5zO
z2#k$NRWx33vJ*52PVQsls2XK)>o3MaQ*uzh`;Cp+E(#};{TR-ieiPj+djXow8kOoN
zw1IY6KPuI~&;`>GTwaTZjv+pciODFYAzi>t6=DZA<h%9_*)x&CZ^%aUhM$NSkX+gu
zOP-LjBjY3)P(0mDvwNiBZeRV10E{zy-KSG17dO|&uDh0Hrmq@ilYjxE3-Pya0E7~;
z1V9)R$7MK#@V-L^3DuD&H1->iVH|tT)eA<X`g93}ESpmKD0qZZxn2#GTcSpyG6?R*
zKRJyNLWW*2Em{ipJ%3sB@!pIft|sm5KTJuhe{I8TeuI;n4-gjeo7k+*z_B1wQ?_YT
zs;|&?EaKiHQyUiUhC(pC-+V28*P>h78oE``BnaJX^VpPbr~E+`xRuW2@N&9c_#Jd}
z87ld?wgAQgGB`}q;5DrGs4+dA%?4f;9l{G>o=p4a3QvlY#<zwv#Xu^PX5{Z#Yzcbr
z-29_r$KXP7viKY`lI7u5Q?dlSlF4%SXf;{B9c?6w2-kV)Z(_s#ulsz=Q1_8ii!fph
zVHyGh5hl0NlrUC)AWS!06h)SS6UGKj(RUfV;EL#3-w&yHoDF~3;MfW74XAv5ls71z
zgHI%n;)>YXa{iG{X62<<#0c{`k(k+4kDud6EqicP3=O_DLaMuYg=yUfd?b!^M=D%L
zun+0%_}_tW`XL~k^gAK!Fx-exHC#fN@$?f3VcY{#gcrOdgiVl&v4%wk!k&CEdy*!Z
z`iQ*L<dSpzJ@gmc<$0xl`}l<cA$$##slX1LU8`W)Yhr7QhcC+4ToZB2_Ci>hTh~RM
z#nTt%y>5tVi}pXA%OW+Jf&+o2c{sp?+wB?~6h{Z5p$&1P=65_B7u|0~3V#1w1CD(N
zNaBx@vu>|Pxz!0VC_2E5ytyT&x?BB8t$qq4@R4A$sygZg!pn3m`}ejuvF^$7T)VTm
z&DSZJ%35t{yW=*MT!wUbBaSaKL!5mf1*W`Ou7x}PGV_H0KdF*yqXHp}K5%5F<d96i
zwcEgMX%jryy+1`oukQGXbD&Uc#ug2qlSa3Pmf(5mvdGR)=yF>t^%>&cJ3HwPChkNI
zZl}eqsQ-r@V7E1~%C^U-hy%hf@YZmHa0blHH&q~4DOa-!ocyJks6i3i8HvS*GcZeo
zy7NAI2E5-??H`^a%{Vb|JB%;4tUXOwQvz_auHDKJFQD&I0_cSgyv>5sLNRJD;iqF+
z?7+9HLc1rz9AXSB+F&7sUfu}Dzi5N)8KMur{!|eqg=**>AO6aMJwU1*5NV4_@uNY>
zB`=d<v-`Jr%f9+c3=1r?>iU$rVIBS}pB!nXpUA6^4oK5XdKQA6*0STlYHv+*Sg?`<
zGTgKic?XRz`V2cIbwq{64;n6Y1l#QU^WJQD(t`JrUMuNnNW#ML%2-b!<!Bb`+)Ul9
z&10}w_^%bXpUr?7Ze4r^^S;GmV=f4KA7Pr31Jo(%dgW!~(6aOQ#I_Da??H!2FhVc&
z%nds>ZiK2EvAFx9W1}*wT~Ddz_SA}4^@k*4?y!?+DK6xO00e@h4mRvSceR(pu4}|P
zKSSq89@EnMV#j8#p19b&32w%L>3HKo-!Qi&_eraad5BKJzB+OKu^Whu2M@%U(DfW@
zTEKbm0t$U8|J+ZER%SKf5K*apz({;|e~33kCO;6bTTFP*`s&4DLMu!a4(P={g>JpI
zY<UI3a?ce~SWao#+jR9A_2a$2UQlw+UJP;xjBR(HUvO-G7*bwlb?^Xn@N51AiTu>X
zjJB8~JrqaUrl1g*NWb_B<YwzbF~u<jUpN~9oh8o&!lKm44O>RPHQ;E9g~N2*XG$$!
zttTEKR@bcqS9@ZU!r~~km+NAfAh2|?k)<o{p<idC)Sg1+zAW}AN*yZ9>I1XbMy>QK
zv-<F$8c!Y`8-&{s7)c3SA9;jpS>z+J1)dFC^8nNGHfmo7r%u>z^d%md!4(b)Y!Kbq
zM(r(3!DR7|HfqlXcz9$~EN3khSZnZWuvS&eb#8Uj@N3iFEY_&4Iy5{j11PZbj7!bU
z_ars3DTj%(x=f|UJ4|nd%!<RvK_x@5q)0DLdTfTlpqHL1k(pc?r;*-Dx_1}7+uatu
zd%s8OUEyMkO$D}6ljn~YhFaoR0C16vdLk9IEjvWDeF4veYWs?6!xI!7B29u=$RS3{
z5HaBM3ThO5;*=5|!lOZZdy#w9oLc(zUrJMr`))|Z3gr+jfBS+I6VALkML`gjM610(
z%lvzY{Y9%40&AgVSEJS5c%RD(`;^|`vuP}h7{+gPwIrADr(H-Lt@$>FQ<l_G%1cm|
ztE2qgk~;Es1t(RsAdy8sn@aN9_aODt1!0-er=m~LkH1pO${=J$k%fJ$)}O`4us5@O
zJmQEkYL$DLmH%H7Yw*{&2Es*w>Uo02&?d2J?@)U<B{Ujg<hsc3h)He5D@=A1h8ww{
z)eDIWyoC0<vRFb-b!f=l9)#H|pkk}U%tP<eZ|m@D)e28ybJUlB`ktUZAsLfl`*vzK
z%MG_N;7!|Mz`xv?#WwZ^JBRkrvWe}~zW!ygpYEp~d%-uQk)4MjtGt8(pTv``rr=!I
zGtpQ1)p;Vs6sWmcgkV+e)SZN7Kh$HfacW<T)NgmRY;c^qiR1iRcx%Y1eONuHkRp7u
zZ{pOsAW`5Q6B31E3kfdv^xLOpjpEh5o(_2uiRj8;dc#uY*o!w&eo#C*&}T;$Q~j(B
zb$HzkW49PH1n~P$d$nv=yjmqpL|F4?yxP^z3<byz#nW?Onhu;~^ow5^Zg;ReYe7)&
zW}!oYBc<fe3O{0Cyro9lKA|VB-!f_81wM#@DpWB(LG3FXg;AfIp!R{>1`m-&3~Oq3
zmd`L^2NKjC!oS<4777c~5MofPyZe?|UAW0HChWGP8j4?AI?S*EUaZBv!j`EbH3q93
z9?4R*+Qol@ZD*Nh(e$VUx#`%UN6+n**_q4ey_a@{=QD{oxBojXp-H>RieAEQLIiot
zUy4ug%H7aiG`2q@*z@M4=&$(c2{#`lzewg|5FYeIBfGU%ySLKr#Kg1Y4IZsmRn&XS
z5jya~Z6vOp{t~rRESE%m-A+R53$#VA#FU7llf)aN;RYLdqm~DlK^$Ll31*wzzp@bJ
zb%cF8s25o_42O*G>7Y&)w#VY&V@Gvno1S~$U@+Qau;`r&>b8b{LLJ5?NzD)bPHH};
zWU4M?{lEgg*eSKNquM))VG2h=_6ez;8kLuORpN&z;)i%&nW%V0gsLdB`*Twkd(lxH
zD`-1IeJ81B;PEoo9k66c7#R^0qB}`^#IISj<YPnf>QjjkchbPUS+OyTg=y4@-r=O^
zZ=tU=DyyYYi7Y2lH3wtP(WqU8n~_?!N~4B-hzu%6)I+28ZrvMxBQ?2{Gkx{@f=@<D
zeBek;cB2P1WrEPv_;x>T$YK%6>So^UlTl|dN@{Rn4Ok1W0MZSZAc=OnmQ6`U2X<oW
z@?EmJX>gfc@!l5I9r%LV_iDBp{TaQ4Dmii8Dyn;SbbS_c>ZFbk25PWNypy_(kRGaK
z(>kfg#FWKu*$Q=yxW4H#gX?IZOXK*{vxx}&Q@4JQ(qvH%y#!GX?hHZsa$OeFbXG?T
zen~hH)mh!8Y1CqxoaI@?^M9`$818Uof2_e^W~Ot&Ot&p}qHz<CKK@hop|g6aussld
zsX<)dr!2O3Gm-fdc+I55a_KF+f20AJ%5yr)ISS(95Q&Qmc}}>TlL@A;crE2v@f>BA
zcK*zK?`W0=>7{8JR=o7}w?RKT8x)_(i7@+N`koU=f!xwhIY5Fi0$J6kLaMr}+e7I+
z`PD?F^aVlSfBdltp}cgpzi{~zMAXvNK~O0_Op%6xBz@&y)kfg`D#-{4ixaVP)jU5D
zD&?;W62|KH(y+Nd0xsw^gb0Ix*CIb$IO_pb)kE!4I6j<{u5vRy)sdl@{;R{ZEZzpI
zPh>2dZ+?^7HFYDJU;FjQt&}4_kl1~gG^{J7G-+5<=qaZZdQH%->11OUy5EJqDPe!N
zT<0NtzEbLhL!cTQ8!FZH42ysTJ=Ol9KMmzh9p@Js1H5Qirh(E!bOruyyYs}hJxBp6
z{`eDQIolI*_s5DX_PD1yTo4nmtkp~H8Chm^{~RYvUNrf&pBNPF0;R6ECXsx`9Ve^$
z8z@bhZnT4J<n&Ve2e`K&>Qx++yq@XQJKU<-98JB0B$(Bi>v083FSWNt_7FC8MQ3N%
z{=B<(=cs9tZeDe#dc;;OmpiM82L{|)N*K0cM`6F-&{3!1PEb$l!sV!T1j_90o|bf!
z8wtFsvn=p#gq$pl5-7=Z7jBOO%AbIex->vy*iP$+{kI|vK<s}Ui4}=5#HSL(>$L<i
zPlo73-q|3YWAzd_)#T73A8r~U!8F8BkuJ%Qz|r^Qg;{Eyd|#K_yNJ_ILg5)zJ}at|
zPp@VtVY+xbL+#yQ1IUM2m`0vPPQZewLm#!9tM?#kXWmYu!#&^>v_fnjXoYb<WwA|n
zS2t^GkLhf6Vd`mD$v=CrhWb$tu?=cuHuWPCe~hibY<zzobq_(~u4T%;P+41}u(_<S
zI?TV!Y6&J|@?;lB>`u7x8b->^Yq|z^HS|^cCr^<k=4jzQP1%gcG!XPmX;*lWicKqM
z_S1tVyNY#cnj`kW#0>T+3XVfcK0qbYWp(%lc)_tB*mU8tEY`fAIyA9$3@2^{!p3~;
zRJ=!48LN%-Z-x+yOn>r6E8b&>YIUt>Z4b}Fghb4wz@Vt?7EWYg5D=!MgUguNxbo+@
zG$nXq?_?u*2;&lX0uQVHfr+RK0Y?NF6z?F0Qh3iAn6N4dG$b_5QcA*75ot)K*ljX;
z0|RNbp~HCa2<%Ww$!!huSl2^Y*bmq#sB)Ox`n|c(ia33Iza#bKFzsHf)Y<{xwLB-j
z(#7jXo2Im)`XA`eloS7y16<aWa$x$a>Ol0zzm3sBNW`h+61Km7zO%DCb;2aFyeSzs
z+SJbv5SBq&>}>K?!g$z-Fq`})t^e6hHQwkz>~jTw<$6C3sDJz$r<+qlG<DHz-VZ$9
zP;$T!_zE*V<GAqIb}fhJDoC1Ka#>UI58@OK+dF1JfVb=ek6YR1hc#G1tX(##2TkE|
zD$6YlyXBt@3U;JtnP?@dbQ0dx-sYfXpV{U&^zcQwnwzSy?T_pbO5G0DvVFGsNrHU?
zcusctxWL>~%R=n(n*`o$O`~vWrMb?Ec8z>OBh=um9q>lU+o_uYbdp_uZlQfTy_J{-
zH>wh^bj2?DDGNX6`cwO2=kXr_#200;-|-*$$f?B2bL?#X(;9gWHkDD8LEt_k_Q4*U
zi}iCExB{12RA7`U?JI379ROCTpg&k;KUS$sX5;Mh{rp`4kE`A@EWjED{l+acP~V^o
zm=b?^#B-y4{$$+mcvewmC~x7A-^W~$u#B3zrL*Zk;Dl_4c!Im>OmH3JlgyPvmlE7%
zxJjl1X2zDLa>x%(fV6PVpKb0K^F2YXPXeSAKbaFNA#(tTzasxDa~tJi0x1FeK+Cx1
ze^I9_aJ?OJyDRfu%!T1~u*l|?-_AYo8v<hxQ`0(W5o^DjRLF)3x#ug)g-<MTYmP^L
zCtJ6LRA^QL3IVx?1XqvXJUMa;Aot2|?bvJq!F>-aAUCt9GjHbEx`1uroj=Rm#qnzb
z`7GA7ezr7`gRQqBl)m{B%v~+!5m;WdDH!U$t>Sgh767RA%Xc*w+P}+TrT+Q7?H_(g
zCHl9KN2SW2Ll&3=^0S82%2sc3Boe$RBghfp#E(f(6(AKdJVl{EUg&iWThs`2dr`^@
z{a3hHQ8I7*?Dr_74a(0pw|`i|n}SdUXOODK`324e4JiT(XINgYat+p&Pi>N)VD9sW
z6>%zJ5gN=Y^^XopJHzuBEiT4mcV$zQp6y4a@p_kBx=|Btc}{SCy18&wz%_l%^8J-I
zP@nWzB9@9X<{Oua7lh=OIS=%u;&9aE;;$NM%a?}a*D)6gp69Stq4}Xrj+oc9f}Vcq
z_?Z;{$oz^pUIW>xj&v?)P6)jTp_>t501!6Mw=@@u{?1`5!tz6dj~Q~RyG01CCrbzi
z%_W4LRHnq2P<noZ(!T~}RW-`@wNM_PEu;LBqx7kTvL&_BolwRYTd4xdmb{fufHHzw
z`L-5H>%9{72bFP@UbRq0Vj!}Vgc5;mnUZyUwdHdo^9P!%*8W?A3B%ZKqSUsIrPv%G
zi7X$;Oa+xU4&+NOc_6)3zA`P}Nsd3MOHdv`{5GgN)0xV`xXN|E^w5_7&?Z03+~L%V
z91~uKn6yRj3!MnuuLfM{t}QQ$&bKlbmfX)_Gh^~Yo8JGYrcN586$lKILN1(6y&vU*
z-dB%0<4io;flwNmxRDaAj|CHlK73Y#3B8XglMqcSCPY~cOvxxQbvt5eJHm#zLp4(?
zfGsXR(cDY_)D+t++^s;(`fMtv#rb%Y{oaPk;*t}&Y%6DN`QU{7{^r81$2n}jI^V-p
zTS%4nw>PaEq^wfs53Exb^6j0c2G%n%KSCH<Ph0*)V!pk39g9aG;~ciMJ%^~g1qiDS
zfY?%3TOQMaAi6)~5NRDbMD$HSZ0iUJp^movQAdJUrYDF68V*o;9RQzb0FZ8}Enlo5
zfWPl^6dRK{#I-*Fq38sNA1$=yDV+#HeUC#7>dYa6e+R^o&VcyGOk4i0GeOL|%OM<7
zImDzZfY7A^BGHgjzBZL0{=CB>_IKeBr!E5`uqz<GdY@C?zbiqsxXmH5(>R3ZB|uzG
z1H|38Ipwz92;#Gw975HdLyY+q5YxK@qUD>M^4;AD;@9gO;(R)X*mWKdkv#xW{5q$6
zY!8C)zs4bodU6PxbAY(l6A%|)=9GK&0)&tDcY=`CPo_S)jQ|0U#b6(bRc}Q2G`;g<
zTr|f31JkZ2+6~v}SB^$}JuW9-$u{)P_vuz<^>{-oC_iak0B}F=z+2jQPWCvwmXwme
z5oQ8IVSTFC-RCqJh6i&h2kwl<TvLV(nUE-QcN}+8yb|x$9L-^cds73QskCXvL}c{J
z$Zyy;{b&wC39i6|Ju{98FOQk$xx$Nj{)U1-TLbtrA76&oHLG+%>QU3wlHcl^X$&@a
zMvFSicN${y9{WdMG8l*d%3&8X@`D?+dky@s2L>Br`}k4ltYe>i7vIMC!Zi}em6pk-
zK6;HN61mE(`cKlb#6J1ywm1KhX!QL^6kFCOzeRIQJ=YO=+G8eM7W>0?q7A$|PMDt_
zbHenzBNJxpi5w>M&A*zk>b2AvT4~W=Y9x1Nl4)wYtJR&MW=K<&*tr?hl}Uf*Ft2|3
zjbmOzGa0+`X1Ek$2i4~g-Zv?dWdDhD9LK1o#UO}xR&{Q~p3d9s!2dX!VdqT^Z=6CT
z@lwD1c$XaqCEm#RQ|h-Ha7nxo*PrvofHe|tWYAqrSmxL&@kSbcauO&iISG#5lt~Z>
zW~=6nIsVlw5D#!1$UP|Y29=h0L&~T)ki+ix2X7oY@IQHD*h`t5Ez#|PK{7d8nWp|*
z!y9IZ3fJ&Pr(Q(Rh}$`A=m7A>dZ=t8K{pOVXO|AhcL`XCFZfl+H44*yJWE+auww|h
zUmXBp+Oc0I7%2b<lN;gS!W5S&5p0!2Fl(r0BG_h$U}pF!5v)QY*!60H9WfHD3Z_k>
zOBKunonV#;Mx{+ND)xb3nMAOC|C?aXC4$|?>16#mpK5}crv7`Xn*XSyMuPR=1iJ}>
z4J3lWGMNx;2oY>xzKiWbe1Txdt;K0!*GesI{~uk~0T;#b{khu%8yyZQQq)7SprB$$
z!3v6sF&2ykJN7$8cg_Y17J^t}8Ka3c8cSjqRIE|4M2(un7GpHFMby|^)cb$m>>Zr`
z^7r%c*nQLAyf$y%%oZbUDI(?^ljY{#vks_83nQ5bq$&MuNE@9jkQV;EinPn<3XpbZ
zi;A>!coj&y1JMNuwD_tOX)i#w#Z(5buZkNQ2=*TLTaiYk?GyGO!KWXPwqXB%BCXz2
z6={jJfiz2~6=_cP(38h(NONdzhcy4s2x+=&CcdB_kTwPKvIJ@A$r$Xpen46Zo^Z22
zQdOk+x<LgOV`~;RAj<cbqrKTa6<fZfAAqgPeQnrE>o2esxYo*(IO_>){r;nsC&kfE
z$m`!B#DJ|Cm#x^k1DY+yma`2hG01Mw-^{o1q^OJpxtg#62~`FFTN(NPi7mrpD^Gd?
zTU%^A`SKq-=$@m+*z&W(R@p?t*7GYSzGeWhH3~ws1Y5>F80?J!;K?3%LVP4rOL&rO
zmSTj>M3klPK=35nYem>qE5dpgBW$3Gur(^elA$&TVVhKhVO^?{*YA*igs_V?gn?dd
z2wPdqdh~5~AZ(8nVN_ZrFEwEU5~>U$gzfonggsJGqX5y$3Y$)N`Opr!r@)3V8fY<3
zmhC7Ib_oa@L<ob(wL@4hLf9Ze7@mMIq?RCTB?LeT!Vq2OJD3o*+lsKuR)l>~jIhBf
z!d9sWqwP9E*aj70uZs}|=|>3r&4w_LtPNo|plDRQC@RA8tO%ph_6Zx1P-O@qEbqS&
z_CQ6=3HY&;(Y{uGd|6}%-BZkuG|&=+B?yH54ulOMghAxmA*?4MYzQF?Pe2$_OAvMl
zjg=q_J4C)Igs@yI!Y*17mQ;+e6cu4BRD=;J5W>D!5f)R7Fi1W^*aaKHK(aQ38H*__
zLPgjvE5fL>iZC@{0}`qXC4}wzZ-m`fQL~aL%u>OIutGa%35C%>OAyvhAnaElY$ze@
z-bV=QK?oZP0oDUgKp0X#lKLe^#tnP^Yzi0rfMIg1ci2u9dnbNXu{W!`4ST-~6WBZR
zjf%Z_J_38w*Q(f?g;yc|r$Z6~d-cy*v9}2HYr~#HxD81R+2P~bVZ|PmR<WlhBq3q^
zaA2?Qj{n5oZ}(I@v6jHzKR#CMt+R&?Jz(R{8%cK9+uN3~_uY9De>NQ03&IMdgxo^9
zVXzS+fW6Xq!i`2`Vb0_8L*vT3$3Pet6I&SK`{WUj|GwK*bnQN`qKkF4q3f>^0$ux;
zs^|(6=0fziH7dGjVJy%!4ssCas&dwfuIZp&8@eLsBMrh{cSm-7USgXST~yjWAsz`c
zMgm=xxBVx&j^0tx6{82bf<3J0T5JzZI$}dtOa(i1ZEQ{GTKEfW<xxPFE0$v==yLxY
zgN+#lbiM9E==z%s)BiDM4}oQh5m$t5ww<G3%wFE2B98r{BCa87P;Il|(E@Rkmsq(}
zHD;q$S-I3^%tk>T0&#bLwj!=I2-k)<V<j7YB7`v;yT!((#m20fPzDJFqk*_voBtDW
znYXO`NXBe)n^@~+5B2-WhPXqm><~AsB_ZzfGbY~B2*jO*5H3O7xy~4Dx)BSV-FQL(
zBN?b79uNy1EYb*FIgSqojNv<sa=LTu85KtwDhB&C3VUpA7OUu4g4G3t*oWmRdT6mB
z=<37o0zF$!TG8XW-ITY%Bu~=B_PwEwX&xF<%G!7*(jNL80gdY7jd}ygLrb@|F*Ksc
zQzkxmtX!k{ra$dR^kc{3^^QB$8+}c6FD(MxqEAEKPd$)=saB%9#k8?Lc?^Fw7EHBd
zBeJ8#hNskVzwTh8jlQXZHli1(gO3r?IQqphb?^=GDhB`Jf*Aa|0_)%%L2NeKNQNv`
zc_$3n@yURVR@$J__6a99n7Gq8(8ih#|4AFIuB&*Q1;L=y28W78u#Y|T%2pd5S7Lvp
zSb|q?Mws+IVd5F%KpS)5IVhoxc?lTop>bd;h9`W@MD;5ezwKM0voEAo9K!ms--W}0
z_Y$)1X5F{wH$FBwOnvKcYH5>kE`ZW4@U@})iV#tFFD|Pf@??js*A{&yTt3+EFz#J~
z`9X{$Rs`!!yrR=oJ<o|*S)QB6%guckwx=eikZopnX&ZdA=f=y1vX{T7DjZkgNYaP#
za$wX@^|XMpp-d_IUiMZRBPhkCkrl2X5p09o{A+oMvRq4}eg7`+#?HP08mTih|A$?D
zzm^8wGV!IkeK$$>)|j|5L2fAhfQO8{zT2f&t4+M&?!I9aE8Kj7IJkX=6fsvj4J!37
zG&m5=ZDB4BeCqDL<^2|}HUYt#&zT$!K1PbwbJpgviErE8H^4I)$rLG&f=xhdA;vcx
z#jo$~TgmVa%Es!SZe?IGyEL>F*GC)x>VZuWTzPlF#E(vr>q;-6Ki*D~>xVoCsgmo$
zyEP&1!>`otYy8?q%U2GFu9jxq=28RJeBE+O0ZDB;+U+Qz7bCZ|19Gw5w+CYbJz#76
zFWdu00yn24_M4)bE)^liGIl@qLUq#!a7#3n3kg|IV$-K|bVv=2%Q)N-ITO^JImjtK
z*_pH#W*$1WNX?vXPSA|2guER{@u+#H+4Am%YC+av$STU>T-<MX%sA>R#6ZSzo%Pug
z>Vy@q$+4rp`KSgIFWQSXDFf$!PQ8pO7fEe9YVOdWT*d+@Vy+8)F&%XLs<@J}Sng9L
zp%d&X>8)0h7a=NXi8oXdj6b;FJ;9fkck1X7op2T-&*`K=ZCVOZK$Q=00f+v1{gTey
z?jkyK7$9`!%T}T@rvc=HoH|yKuH3V>Jrxbv2C!N!^Qg8cliOLe-Hpm@?VC^`jbVj_
z&PUiVQo<*L=OH}YE!XYvO@vM8Z*)b$Y;O;sxNAdHm0d3q8y1#O_wP!GBe5i&+zHtc
za$ARbig<FYhVd7N68o((mBf=Hdm0)*?Z0*twV#5Jyg`ox>dlSQh+vA)t!w_Xfm*lP
zQ3Knf)CM2~)dn>74Tuh9Qv)5_Q?1Tl#%a!5Zek2iTeNf73&KpJQavo8?a>Or<7r}H
z!CIkF1f|)<)-_UpLLs!7W^I$`S`2E=N*WY0)S}`lEmNg0i7!iv?^C-RW8Y;rLP{r5
zUfpXjX11v6ekTn(*40`Wj0kf)iDy1@s(h&J^lt=jVp|^Zh4{qhI(mH!fy6+Bwqr`b
zU{ME*HOFOh4H5M`x*B2VZ)?DFBS@Y((`26!>zfmUe+8l&JP)U=>3}rC{4+5m#AoNu
zjQ`}_<CAy4Pu@F!@;=r6oku)Q_WdFOltwNEXSD2=n-Z7tUXvP<@m`x+1DGqdn^fCz
zs11vL0MLPf#TK-Q)41ibR&KdQ+%`QO(5z!I>F>3%ZVQj&D*-pqQw%dF4y3&1adKl_
zUwXRvIC--axX#4CdXik*tMUpEPwt_}3q`FU)o}m$b`#%%>mqp3ljH=QzAXwgd72!c
zD@#v3pC$*V)vZOk>~|>K!gFXKf#MU09o^%y=vy~g-iE>(YVga3aLQS36A@1IH{xZv
z(9_XPh}d%U=KwnphDvbF7sg(gP8~)C$Ua?U{{_OfXrvW1Mu7VELKQ_lKW-5PMvBxG
zR3Q3)5)(yYB`O*6A00;VJ|aglOoQ&vlB@Q=4nqVH6-CwQ#};le)R#h}Fx&zMErn9M
zD>M7kJ=m=br3D1LL+i$UuoMWyYboC1`zAy~^HCXYixt1q@vG8tNWid~{PaxOzr`r5
zuxZ|FA-7v@TwKN*n)f&AyjR;<GVdyVe>(5qe`Dfdv*Zf82dywiakJzksT?=)+CvBF
z`JP$wAZgBGsQoOtjg$k0J1k3nDJ3j|2k}e!g_Q8EiGPtT2kC~lK-tOJa=313ES@%J
z%fqy({@j1I{Hv}ML7vQ(Yw4n5@KiZRKB(>bmfy~it9cxU22IGiRanNCW^o%lpFwlv
z@>28T(BE_9VY>d!QDWU3xt{LJW_Y?jM-J8n5KJ>y_AB#QC{f6BIOZ$QmFwuzC`-~@
zxq(iJ#?!*Nau3}%^z?YH+*8+$o;uExTj}c1)8ct@l&-KTo_?7pH%RLfKvkuH2QZtR
z#mm3&cE@G?iT6E~D6u^f3s=-6nk910iGJ%(;Ccj}1+bboN8~+-vV~*q@}3oW*AuuG
zz#_co07-2e?#F_6cwt*n14YY;Ci{wNu7JG?!$rynLup&P|N2q8`zg)i<5JZ`sg~5r
zs~XfJyHdwQsj9&2<N2~rnFAHYfLEBf+gGx0nP`#P7OxRsA$5vKJ%MeVPL%rImok5k
zS0latCYrgs+{EX9B?qLP5U)QiN2@-fRh)5A1OLQOR*AaSQ1Ywl)G0cfW8X8QC|?O%
zM}-${84|K~ij5GF5x5>G@_c|ly>L77*e9nU&@Ngp(wkEw3qDDw<d>okhp2d}NKU0V
z!04)?R2eGO+Yan5z+X}BHUQiDP*GI!$F~62wgWdPE8qhuyRRMmj}SuIkCa_w2R<sm
z^^ckO%?0x8nw>llZj%h;?kACPjP`)zEx)9CcgR^sw=a;b_^#tyONXqxMfdpq9Jz8O
z-ycDj*+61pP&J~TM71QDxsRbTl|!}p^@Vc2c7apgvPE)?M)zi;376l0gYOOh0Ri=H
zu^iT5)_w#rPCZU$urO4Yp!2q`P^#aEodM1)$k4+}1&+u+fsD$pI{pQh+iTmu<?FfJ
zT^p|BnkDj7L-m=&HTw(>u;*!)k9vV+Ra`b=OT|*6;sR6Nx+SugMtU~g#B<`4L-qLV
z+ZwX%;xmrYEocw2|3QE*zxYqHTKsu@a<DZ2dlPT7R8EmTWWoqvDle8MyN}}SmdRCh
zrK7;KG3}G9=dD;KKhsE_a5XOaR$k?`7^}8}5F|GHy%rMUm&-M!QoBZRwp^|dcETUw
zZP*MgEqWR?R!5QbD%$Aa5)A+sTcnxzzU6X+q(GPdvs@04PQjhwvO?aj3yMI~M^?y{
zrR(KJ@xm2IONT4H)Ji!+YIhbxTPd&5ovVdR5v%0#x&nG?ze*0R<6IZpdD&}d{h0s^
zQA2xaErRKVxq)z=X^?~H$t-`MFgx63iixjYCCk!+$=D2DEf3R_sxpZr<r?0sOL8rq
zzecVqotkLkch<=BwO_sE>^nIlVA}-B@||J5a9Zp$B*Se=N1>~IaN<5|<)lgvml5Uc
z*h(wfi~?pq^cyham2a={`D^6_X~j+xzp++sCgm=J=wFA2ad<Gj9ULHa$3yx$Iiz$>
zXyY`@nFnu}8x=3zT56rHL}ucBzn70nSu*^Y>*ec}!`^(b#Aa9|x9Jsx2Xr?KTKic_
z{K3SlZjcS$ksD!1*~p0O6a^E}cY|C_GK@zg(+2r>DV0O<Y(%7B2RwYaQJyS?cO1pb
zZj%3&4vocRZIYv;(*HQ+RsBH@Mr79*%>R$_TIqnvl=tLEIYcWh8*Sp=TjdyO$zr#>
z?px)Xn#k`0Txd0o(7U*t9ZSSU3HD&&UsM`%9BRnfvDFH5a0cw+g17v1O0plHwq2ef
z?VM)f<#xz7{I>>^MWRyD9_)uW9Kc014$A!pPI-<y<-fHa55J_j`N6PKopj|6f1N8=
zs_r?h>_?Zo!i4%BIdPf7Ra#e}&ir(8_+GupTjj~wJ$^Jpn!Lg4%q>@?;#rx3-5|??
z{DoE8<<&^Cp`BlkMB#-Z@c@J}==$rCD7znJ)c{gr6a;}#h3g&p)~S=crLVJ0yxDF!
zAZlV3_4buA@$LtFO%_f-+~fN-X+!9fqR|jjG**G5tVXzM3Ae7z{~C5Lib^$5#}B*Z
zAlC~8D0|17%C<$~<=t|U>$3T1tw~ve-B@D6b!M`^G;x-R_rgQ1m(5ThNYKc#B`~!<
zM>`Z+cmM~|=*u{wQ3^>=5|%qb0@P17l%az@I8KMU&hL>cSN8?7;<EP{me5p9OmlK5
z+#yEkj`|W{U;2tF?<wvI585kt(N=rQ$L^JD1l5NGD~uJ}vSYcB!-5b=nl31C=KJ=_
zu|A{!P>r<+VXW;lY(>q=Tke%Fcdzr)F?10pls7IWQ|&wPyIlM(!7myu?!Vx(9mkyc
zH~F%!U&ANl^?Eiq_V|oAG^R!8CmB+d`CIv!d^udY3TgR1U#?s2yXhp1|E5J4%tQPU
z24rdFb1yO}$&{=f`@xc)|AaSdJJH{RzONjYz0=S`V5bXe$=nAgL?9ma?vwrfd;CRa
z=3}+GXSV9xm5`UbvoYDH#(KoQqg$~BGrUOt7si1EEqd)D8r-{uB<%AUR$<DyAaC47
zg-P$<-^8~Xll8p+etDX-+X>hEn3DZ!{P2?6@wDm?;pf`}iYmx(2M8AKKT26gvT&a-
zF!34(WIrjTpDC~H0lBQkCtw7vMw)8fGCLx#&{3BmT812yJ4mnlnt0wpIkw8qz9xqb
z2n~$SIhc-qCS*NQ&LgJTUa@V1b&KnAs+JvsyhPGlrt?mR<ao&&l`K0XSNFNshX%Am
z_2yYs=$eZBk3$$&ZXXkWb4Y$D9l!t!56j(ZjO<OhqknP}%vS!PV79RPDzlMTw=!Gw
z0NBbu$#v7x<`UohX(c>O-oKWjC`6FiK`qL^aDK)X=nP_3!<44hWr1y>5TcariP_z6
zqLpu|b6n1Ta_=j@M|`jhK0e(DD8=BuQl3u(g=Q5|NOu|3kBb84n!4l9`#B%eAazqo
zNg{&rrn#Xi^H+lUm9c-*><FN3j#v76JEZ3eJ3!<sjS|YH9{kk!WPkmN%aq@TDk-dw
z<2wiypJU2feMGLJk)9h(c|RYOt7<&|p7^osyLy@H3gmfOb|G(ZfgGgKuKzAC_qZ%+
zq{`Lb=j}ToCu^kLP#?jk<Y3RmGDJZj-5yXnK4(fp#dS6AGL`FSuXg8|r{u7*VMr$_
zaiR{-Jtg<irqtnQCnN{($e-oGUQtl12OFYyR*&8p2&aud%bm+!8K;&qM{>v0V2xIT
zOuWfyIlyO%NO+}8xd34_Q1H(Vu+50m@@VHbshCQ^Z9IbCJ1u7i^)H4vU@{8N;|gVX
z%`yr1b78m4J0lyahagWu#uXChz^T|EUTYxS3keULX6N4^5x?~yzkWsz(2h0mf6vJN
z`cj7ox7Vm#;k5@;@rw)-uYOh@Ej59z`{pckUG~l=dB2^N^*X6&l!-sMARqDyfe~<!
zWRrEsyQiA?!C&QXz31H^BDESjq+Tz5Zpt(MCb!Z`CwhXRF3Q#2^4DV&pS_~SA~0#(
zJ^8arNefl4DMiJ<Cog-Q6m`A%v?%|7*P9OqmaI49I}nmTU2hHtH0yBIY(p=8ZdbBi
zxBg{&2cCIJ?xY(;PnRyqX;Q~YCZ2Q|k(zgbJbPnd3KHI2mTO5}Cye6NufU}9x#28K
zIwrJq)ZvqD#3<dx=JrB^QHZWGtxbH?6*;m>6#5>QooNusa6RBU-hBpNk$0apuO}9_
z$F5-MIJX8ILlv*el`E#72kKxpCW9Ubg;XgSy7Z1a*nr_dSLMWj;Dz8b90N)Q_L08h
zwfN&W_XUP^?keoT+4NL&RSwmTc$4S(hulxn_I%67U6*G{TVqVza$VMIQwq4xUveKw
z>1X2dUvi*!$!fm%FS(P%C&0`7m)ulmc!XNQZpbGpH9h>nlJOpv)m+h$Gmx3~$QqPt
z;+{9<D&DQesFs!JH%<M&ZB0DkCM>H4%}ku##7h3S&nRyETfQ#!X=>t~Z^=>Gf-QNo
zZpm>P=~`n1-`$o6NTZsYc%wV=;<A4>qKUnytlhw`+>vMLx-00>pu1RtAG_DyA#d4T
z`JqNKG=R~j$c?4r>z?oviriM$`wp^s70Q!ze)P1UP>#?YzKsIM3+4CPy1qAQCR@?@
z6*9%t5Dd^OEEeU5UcwYJLekI#q+{i*#3jAu!_I@%Js-+BQeYee&qIXB`sJcZ%0zQ)
zXNx`FmiOV2d`gm@w}4=JDzDPGrGOO4TsVP=QU+|yoA_MrsnH(ao_Fa55YXjBygJMi
zI6#ZfK&(XLbh%sri5p$)$A%j?=4)h!;kFdbQZMsqhhI6ph`9J0f+avx;b3N#H?JSx
z$b)CTmS<}oaE~`~o_68Xyi;%FpR`iQ(|37u-^oigy3yx=qVNwm5g1h0#QS}aebeUt
zN&|B_x>YEh$=g(=L&LNxow8M7#{7d#V0#PiOdSBPik;!;`9F>X!R`PAe4Hs>+Vm7J
z@(+~qHRau`<{cy;Rgqlyjew*@FB70~l<7+~Q<i{8l!>X3=DAc+XUa1ekc6zJxKs*}
zM`*CANUBds?bXbl0&+A7kVc<mb`wb(C@DxyN-M7D=q_sGQ6$o&Pl|02Nn@#)0u!8?
zN6UW*=zc12p#*wNK-*H@eO9Qgs~2`s3pFWel`SdWI*dG#W}?bwlvI`_pkENwSOOg@
zpm%xz+7r;i{`e`X%g?_{DjzT<){gqj%OQEGI&4FAHZ3x-no@&U)1s9uppGB%5x4nK
zmMS7k$Ib+z<6goj7A#U72PKPKaFP_oAF_&40VIlthE;Y=nSyewVG-jXRicTv&@hu!
z5sA4P7AZXhPv6%tfB%%1?=6KHLXNm3LgmI<EtUwF%39X3>dFSHX-yG8iiDS<rWXCO
zPSg)X%!<qwW!Vb8K+6o$qAAXNua-6U$(T(>bEaV)=-=x0OjI6mH;Kik=@_vUNP{fr
zypE(aw~60P;&&~6QEjp1oDMrxIW*asc#Nte8+f0gG^k(kAEvf)NNt5|q3`d%2j8WW
zQB8Jc%E5ea=x3th1o7KO+tI{-xt46;?<M9TP04<e=b>X3O@*UPFfAF_A96@-Mb6of
zgq&o!kivHcBSO2T6YC~@*2I)I-HDaac{OYKv9i6`&cs)hWvje5Zcvr2s%Ic^p9Grn
zx|L%MwbG-?aGSZXaP4&yKjgv!+8$m?BI0Wj5s(_|Noq{F{T>E_kR-xDAkm{_rBOZs
zOwV6N+37k_RU0V@xB1G4$^M2LB9o9eh1;H!B0q~h;(9au+O{8fvMUQo`z=CM;|q8G
zhZ>(7UZTc}^fbwzs&N+|s~V?EThrfY-4?bo1Y_3#wkQdy`v)Pb2I!{7X--&f;08>#
zn^tadQcGi8PIfwqaEmKz=Cb9Rkq!q3;#GN(^DeKQ8*|d=W*va!``n%7NZI}-e%l?a
zP_wFukG|cuJg@G-dRNu2!c|t;vkhTrDgnzJ3ZRP1cAQZz!J%DNt4Jq2r{bA!_Fys6
zsG@iLi3jtR<ccO<+LHz8uI@wq)je4a-7<Pg@?`aN-_z54PZsaxS(O$L1rF#f=m;??
z@h1MzlYLb-6l_SV?g%Y6b-+?*xfheY@)~`tay!MsneNSMwhe1eyF!_UFj(htIhh8E
z`J?v`fgZ=g?^LUWhJf9fg>zJ^g;s~OYNuQl{k1Y!qIk2ql2bU=x85v3Qj*~0@Md#$
z%l4wb)AX!z#o)!NZE^zyLDZl&u+u>A*zSelQ=n(b(&io}Ud@M%(XHHrk}G^zc^#*x
zy*?~d`|W;y(}x|<t<3{uO?g&T*OQ*kmS=Tz-t?sNWk<DvZ}}--mLc_ZGVw$|rq|}p
z;zRsc&q~XncHmY@p$WFSm23k!gkdY~Q}``E7B3}2=+yRS`zpuIB$v=T7%mTmz&Q_<
zU~jk#g~j0-zzp8)XeZP*C^B3$uJAJjuo_YmohdIhfPJRX&Do9)o~pnuN#(RA{#_ue
zt9_A{cO{VdX{5alCjKIb?UpPSBi|a#%;oF;`3|SI)o-}%2bNL2<EzUfc}xfkl7hUT
zX+zjbY10QI*HvU|wO(ELriyH#H1fSMuSF$RMk7@`{f>96%o<Cdr##8auFOtq8#0W4
zcOcc3r869)2XW5VqAyh&h@rFoyJ0Y5tFi1x+~njD<ATSh8_?_7RoLCK{r!o({!#kN
zd{R}`yvkHuTo^y~s7iqMFytu6L0l6d!V2J<#cgTJ%fWeEm2Hu{-x>LWFczlm{C(d3
zFqW>>)%Xte#@1l^GCo<P!ghmn`qluuzjuTV(qhC!!$fxQ9I3MuJ!+k>E7oKPyP{X7
zYFALA)vhRfV{|Aiz*O1W6+cjg+i1>nqGQsjt*-#VOI`628ZKU3#S3#xL+0sf=67k7
z88nR@5`vIZ3B@MQB5)_FwU+>6BhQ+&dL|{+qa@l#wSn7<68mccT>X<0Mp0rlCAlFf
zA<KIN4traxdp?D#yQ_m7uF1U8E{oS;l=qUDM6rX|Sk$mn2k7Avs6jxRQQl2}CZNXR
zYK@{h)2PJUPt!gZX-+6tG#+CeCtkZFYtax|QVkaGN)5dCP`8GNiV#>+0gyJdGm7m|
z(XG@O)b}7NS<4>YOTgDr4LE&MlK+8#Kaxy5E1cDL-A_0iB}Bt#1`|IM&LVv-dZ`3>
z(Fi-Cu}CY2H1Arhc8&Q+EBqbQf|I|bZiN_w$R)9+IG=*aup5a`+)!$xYB68$Zf{_P
zz*%>k*p_6FvhXZlS_?9~8?v0N#cG85mQyW>*JMddEDI;yc1#hzmRXq;{&C_3{aEf-
zo3+up9O3<HGehmF?f$hClD{06Syd9b;<7Uy<DCL-24V$GOD#*HZ&43?si=~P@2t(L
zrmd3DciJb%En{k-0->E?5LlFY3-WQv6&ib`>=_Nc+S;}!`|oqy>PBkcwkLb)!F#w_
zGU8AX<-sm(N)g8GB`W^2A}QBP;`cm$1)6pWA<TP5FyHY09)v&?MT(7!-KM_)KyY%A
z7RmRh^ZIn?rxg**Pg<Dh%=05y^R(?F;8ny`wf>@dZ?*bj<O<PRJJA{5nM0^R_2P(?
z%qdt8=&^tbmr_GT#>El^8LKE?dj3lKBb+(w@t_o88VfQ6Fg<^DaoRk{EChd^<Y|%2
zzrk1-pLXcWoKN=Ds1O=`iumm>etY59KEj2ci)3M~c0M#hgvq7Tn@RC*tr`$%kOilV
z*b2K1FJ$xVJp_b`FtZuR9hZY^TWE<*`7HW1FO9ru9rlH!e`w@O>#(scSIEGPBrbSS
z%PT*=Aj-2s6smq1AQZOsY%X>7&mb{X__ba0l3173Xc+mx=n$Kp7NQ;37^<MgN_<l;
z&TZ5oJlAF;#q){5ZX@tNZMI=0YJEl_BlF@N_>Q_PBXE3?(V>IpJ;?#zgeDMV<H}Lj
zaeeOdMkd~+9-A2Xbh(hOohAtB`WW&sF6VPYsRP*Q!N_($HX?+K$|NUHY+eYc*HVwQ
zmF75O^CAisdY$`5J~@gFl=3I-<F}(&HEAv$-0QOn<zoK9kXvG-Bmny0K@<PJ8RbY5
zi(3aL!M8yd^S-qth7gW-6Gr}hq+(>pY{JO50fZ5b-{NZ(A}`q8Jv?u##_o-79Nk)<
z)zHp;#s93&{A=FnOO;XhMov`n)i?~xrN#;x>*ogd*xhZ>o)BgDuocv5<p%6pzlXS%
zjwU2Do0@ln;wzyQ5!DchND{jy?Jv*_1RAlg(GJRk0-mt!!(YVqRJ?C233%ek4OzI~
z*|(Oa+HsYzgBk`AgQXK~f>r<Xt%a}4>DWs8>8_DK%;^}Z9o2`2%;{KF8U#SQIUPTf
z64#dIE9P|cYcRXe=umVJf_d#XG$8%$$s^TI9OH-xWH=J8bCGb162inxUM>aOY);1t
zts9{*jnXfRMk)CcdI5MHcf74TayrBvhi3icl4l3{SgFE)rdzZwi*MfCcpmQ;N~)CN
z%%C3wBcRz4DCZyuD9R0QK=`RFP~x1%%+GI}2K~x7+K{5|?6K;=4>e{jG}E}$gsqpV
z!FJo+gjI|<lSbFUwnR)pT_V0jrRGZwNT;3wcioTMUUZ1!OECr?K*fjRc;uyNdgnt>
zA0#r}XXfMcz)e|8jhPQ@%63WlP^J~4VO+1Cf@suc(J;K1dz<*wXy&hP1Z72aWlhhg
z1K*i6cx;e1V_!Ot84!<y)V&-h;4dFPGwGxjh2}SBL!9gN7bz}H@t5zMl~h?b2tm92
zk6B3(xUA;V+78@3E2*h&Yd-)Jvy$SZ)QS7}vaF;8og<ED^P;Szpi(wIPmX2zlExPs
z0WDaZb3tFV=Ck<A$FyJu-OD9-TH1m|Ip(+wSkr<3)`B(E#Za<)OV&a<#rEMiG^^~Z
z!<lWu*=|TGj7Tb)XFb0@uO;g()ke0*E!jA!6pXTzR&1Jci{9$!+TkyM*@`vQwZl1W
zUcWUvp~XSyHjrnU@%wn6Hf*+Z0X*`s4QsE{VPbgGwydFZ$t)s9{#-n3rA^(JH)CGX
zzZ$oRlh6}{SlX`9kC~U$QYtgXmOOmI$H_MqCOws|YE1n1MM+WRK3B(&{WS-!Uz}vn
zdCkF7^x`DkZ|0J*qyxWQ`@2RGrEXoE6sh}yp+k2TCxz)SLJRlcNxsFHRV(&1@z5ox
z_%pTQW%#RBd?dT1;<}4F@YKag4R!9691`(e9cdh@>l*Q0HSzFKy&)@;x(Br$ZXHE@
z#_O8n^l`^^2JA!v@pqN#!}sw;E0ZuKwmc=sQp2OtS0(k7J{z`=|G6q@ShYJi9xU)h
zm0)XERC3M+EGavWi*l=nTFXV*ve=gku>tMN8GEx<6<%j*9q`rbaaiMy1<Ot{^w>*c
z7xC<;jr?41Hdcy!WaMr7u!^<yID<^I6nC61Wd|!m0Vpf$Y8{F;S#K>%R_4<y_ExK5
zHA3Ru{U~WhaFX|EEZKt*Wqqg*i><I}j@s&2TdRqCw~AKl{A}cbeL<0bKQQt|eOYkC
z37i1_q}3iumpW)>v$fS8N-KIrtJmHc9r#>1$=91fMN+dTMpCm@{&i1g@!CI(yh&1Q
z14;X*k&jD?{UYY`K_eX^(Zoeu2XE2Wx?+ULa;XX+1<HqzY6y$8M4m)A8|)%s(u#|+
zvarr+blHgeSt9y@mGX*=d|p4+UVAu}|JjcvNv;4i>dz_$s0?SjQaA=elQ36WY1|in
z^!_YH_kE;`!=gXqEAwmpnX?2r&Wrl9(3ph#r5p;!z#T$e2!R18ER6%tv99SwQ1zm?
z(#mhxP^O{I9tK%e9MKN`OB}$uON%bO<{JmFAEb4cjXY@}tJcx~8EOcn8mu?j_oln-
zd(-iUEqBOL?`$DsM!&Z?1Ub1AV(%JDu8vTzOLFQEk5yqQ`p(w5foz2~r%Rq`5cAUN
z*a$GltRXBar0;K3OSDOt68dT!N(V6>sD93EnwlfLR>dEEYs6Z*hfwE#8AOU_4+cl$
zf;oV&N(5y6rQ{+(#b91Y3X9c93lt+CIFyA+%HKvlcPLxpJ?<j41m`)Z5@!MMEe|ZA
zn+#*Io;l$kjy=NF@Ph~25W|~2ZW_vW3}b<Q-`zy9{pb??OBV(nDo|Sg%?pRI%2LWr
zBX=9l8sL(jdZ>ga3}>zNw{F08f<Ik2u_zWuF<*A&>xQ#xm2(uJ^&Qk?DlSW&r;=Yj
z@riX|9s1nJpAJXG4GtK&?+BJEox6ttj9~imCt#7q?kmnKklyQ=k>`(Kemb@vG#xR5
z`SYhESZK|z$SZ0Tx&C>IG0<v#AuM09HUO2tg2JI&=lw?BawMx>?H^2EVIQQY)=J14
zXuzi@9>V^xYY%9~xvQr}zIY_Mw_u-<?;FX^Ipst@I*f6DHHv*%U8!brKr_?lVs!*p
z)p@*<XNXL9(fn;#!wK2p+p59UF`A|Md=F%xTKn-geQe}^jK;jh?=^BKBMbL!giIwl
z;<9nUA+8Ph$H?0o;Vrqi$H>h_Hd(5&>p6d8WDTU6*NwcciPe(4z{3N{-F*8hd<iDF
zil*Y>r3saH!$ZX}EZC#oRrCO>zQ@$XMvqc``IDoKyd^iJr;K5r)u~g(<e*%@7wQX>
z-&rh?f1tN<aO~o$&sm_0!dEC(3`Doaf*Kx-VeQJ+lgXqB?>ke&W5%**X-ldXPan&|
zrQ_hQtz%h8#o3?{w{nFyPy<3~AIDo<$GH-9mBs|)6BU^BCu5mkrLTU5nS$>mZ3GsO
zukgK^pK_if!W#24ubB#CKM*p8fFcw@IjwQ9<xI%JHXw2qCvF<+<sh2HPAHgUZYrzd
zd+-vh!cwT8uJomxm(h%J{uDox$^yK8>jiTd!YEF8i}h?#B=YfX9a{R-!3E)n@am1i
zYPm@UrpTutXL5ACQ2|Z*xYp$0|EdS^?IaAU^XXB(WgwMs_nOxw%+EMhrT%?zCgp03
zTs97LaOjedb&^cSfj^)kVLBE|EmaX78poo&M*nSeIGBjGtee86u%>Vy&+0Wbc7tfn
zIGXr{_46B)2VdPiCKe?S9%yemMuQ1edUvPZwFLv%?5gzfEK$>xpC8Wxr5V3tD#o*T
z@1<Qw;&Wn}aZdRB8W<NB_8m3yjxr1KF8#X^hpG~={C=f;-p#7P(q%S4+Vi3;zbms$
zsqAk?K9aF8uS<WS!xSECW%$uR%6i5|NiT!lxSyGY_31)WiPb-%wT~;!aCVhGDA0>^
z4CoXyxtErJ=r=6(t;mT1_~Aq_tyhp`k|6{af}H~AW~4<}QY+wNsu55M2f%sgaZ0X{
zuP}oQ*IzL5U(Bp!>;4xYD14Dv@*#ju02NLW8YTM6ne818;9HjtN^C<g0b>0u_5r@m
zU>~gU_|0SWy`?g!bJPUZL)v`a$WKmSVZj;asek_{zkWst-Vcr`nO<6Sxld%ZylVXk
zgb;;VXRzQlsAMAZDSKx#O6TaObRNk~6PaI?uMXMG-HXlY+=Yv(%cE-B+-;r6!gWPM
z;4Hj3k@b}-fZ<wBVwH8{2{ddH+b;F^#mGHYHw};);~{!7Ya<Qa^PJC^jJ0W1Ow+l^
zu$*5HLhjd-QPm}Ssy2lMdQ`z^twI&UIRswsJ_UvUdh?vGoWiP<*?a~ahIEMIkw1Rs
zTP{)D(1+s(XCTt2u+B}s?&<|}w4&vIreVF9L~*aM<2<R1NQlFF^RtfD$W2OzN{3YW
zdV`TqNrOZS0b;kLfvonz?9r#Q+NB~+L(`PG$5**d@s{+k#rmhShSGKv_?8~Z=RW6`
z)8W$n`y2{PWwF|VZh1YXvRWEx#ttLTn#Q7}phHG}cpBSY=Hx9<4PtdPyka^e{O>1>
zd|U12dTBo%_GU1A_ze$#X0Q>`Gw9TWOg31WF!VX!m5I!$YazBXS--S-_dq-i=$He!
zbN!)03h(@DeRHO_s&DA}7g#oNIXI<4=!k$vB1uDcR}0ic9~?v&&_CLz+Eze71`u0#
zM%<QaS0>c1OtxBPZ(2#APE_b?DugMCfqcQizq0_%5cNcdwIw5_dM?pebbxr-4@$Il
zExJ*EN-l@w!mcP_16LB@g~(XgOsywofLJaM9VeE{Q0x|cl>#G=ox!|@_yUNpSMEY?
z9p%PhMch~^#vc7HmC~9~O$t;Cc{W2n%J58Nm`sI_|7V5^BE!3DumEPTR^H<v+6p&<
zYG{EAIbc-&n9jXs!mE-F3D$fjt5CP|4;lxXKQKgTxdJSdtut76FMXA1Uqfwti5e{W
z29Rht;fjKDX0j0Nl+}DIDv;Jg;{Ae$h?}s^ifW)GD?eban?bOVb)5@~4hh9kU!|3S
z%QSpy?Fs%oY8LbMu5pyOWNbtF^xTaiPaNw6&-I?ge4AK~7#-3lnjKP0$7R>0)w***
zOD2SBbnARf<HXWdj=G49wxmi(f_=Gl78}x{>n{)`^)UdeY<);3AK5*mD#`B28E6QB
zm#YAChTRH!+@wCz*C^)Uktb!b;POBGKwX49we3uRc6zLXuFPUFns9zDi?x$loW&C4
zOE@(bgBcoq$)d{VZc<CBAInu^&HIBdrhmz*N^BEY_e)l{{e6h4qUCWpQ^4%-Fo`3-
z1xg}5_zuIp5N<E4fTdwr^a&?zG7mHAtNb|&Gqgygd<9t$p3QvIR(yvFCqX9(VS5CY
zgxk20L;#8K7*k`(R$Eye4SZ)9%`hqyZP7PY3(;WJZr2qCV|z-5ff`^<7LCuzgYw4&
zJCy)SE9MG-k`B_eAQ@kD&R)jjQo3wr7?A=Yb#N9<OKH({2eSF0;HqN5yO-clbm${)
za9@su9R1@M@`PQ+@w9nJv?*}P2*YoS4IxnAeOIb&4~Zq6n~n@P4KSO9>g4W-z4>}J
zTcz=+16^n(QY=zV18eQ)u<FvKWk$~CU<WcD;&1aDHeNb+(8#OK1-lqv5_g%4DLx2l
zUpbe>!p8l2C2ZV#b6MveP4`hB9lIhvfUfSP4|>dO0`hXpbsP$}yj$*xoX(bvw_3N1
zKtSWNqgx8-V_ZN1Q-!Wsc2VIq0FP6@fYGftC~w|8_IZV{Xc{_w8X#x3YLwyyl;To5
zdgS8yuv`t%BYBPa>@#U5x|=?qje^f8bqcO<n9n9?n{VTzzhc9rx?V2)+E=WCQ%?A_
zZ_)7&U%@WE<mtj2E?_NCKtZfo+5%QZvK)r-v49N&ED^Bs3mMY}ZsGG6q7n}e7ye-(
zRT7=N43&f|V)dn5cNd<th~@Y!c6^Nx2iW52us9sx!^m+QJ^@EC7O_g5&?5v46=UZa
zrUhQU8*t-&a*y|UO0nMK-S3);ontD@ikYRjb)Ju0%$i0GXz>4FW|%c0kx=%UN&{s*
zfHG5qk^K5%Xu(HVBlvL^>fC2133!lc*L?UzISatp^j~9a!#V39?b``S%2}9e{BcOq
zP{>@1-W4|L6J%^XY=rPio`?L0ueQ<`=nRx|L+du8{}PlSD!{j!e#GNnLS;ZG78c-b
z6;vLAUoOI~S;8u(Y1OKRs#TTk{c%;>IZFJBVTfInOsegbh(GNNVMcdMe~!8fT6${=
z+v5QoYy}@dCIQ}y2dK2hSf1m%O%MQ7s4wys))l7@%SP{hOG%Yrzr0_<0=mxbMVe?a
z_@t;E*|#uHqQiO;Y#PDp<25phUVmLpq#tb%FN2YWmrkPa9;AqScpoQG#*M3C?0(Ir
zOVhR+`HQbH1#R&Vv6R)*BA$KlQr1SlHJg;r2>Ngq6kky)PK<*V4==^;R%%JoPQyxI
zg2IXq9wx1Vy*Ik_{=ytcB3ydE(H^)TK(Q=B3FVv-nr?bJ9)<pxKLZ7D$+TH5&@M+e
z5=lZgOg|#9Le(zo;N_4$IjyHdYMHp4$uY`os-$&Kz>-u@m|_;7B!IrK#;Al~)|Ks}
zDCZaW-$U%dRjNb6&>5|j7`%h$ktZC7Zy`VqDrns*4V#fZgf#Su%knKqzu|xbRTzhU
zNu80!qK|T8YjmZ3b;3*L{tb)J-DnFQY4r_jqT5DK8Q-udubug5#8}cu!VzQM&)+bv
zkv4K8AG91M+vndIdG>Oau4~j9rQBAqHeRJRU>9TRG1{OP=36Nkd?_oiF_M(Y7p*{<
zdTH-?{tDKu)v|o-bYf{w>qHo>T`EzO$0QP43k~N0OUSATbpJUEL&GG;&?F-ubs&8<
z!+O48!z$i&CH(f5bH>H1z<qx$|CcAOV)|aCw!x%r^xkc{8l(I=*XXdn1*$wqKUT$_
zjnA?Q#eNFw8W<bU-rbXgPLIH2Q}vP5dqwq;)VmWN`QcS;k+cqGf6{8!MN0qnU%q8E
z^O3&aV&o@Q!|k_e0{2?Odh2e-Aam*(7NyIlrytj_5ZxwvI=_bbm+|O9RDJ{!`1u+Z
znkEtVYY1sM(P`BwsSr$zmoegH5+(vKKenWl(RdNNrhqIHkp0B)M`(bk!QlXn(xQJ1
zHCMP9k91-eTNyPe)-NART73M6@-MJUN~5%uBFz)E7frM;qr!WlOwj;)_$-nCZ{V@0
zy*)fez^haKy7ure0pCvf1ISFpcBHLi_^!(>k@{k>kyl#FTDX=bsnrt0!8Zl-jC{;m
z7T)#@Y^uUHVsM^$f|m;m@FsZLN)nB~fpv3HWcdfPE*w>_l+^2QErsa<dIihZyK7lc
z+HN(u@S0i!IS*P-LgA_Ed+|YIi?Y0G@oxCo91=M&bgTw%h_WqBh1iZGL@3RtXt0fZ
z1=R?SpBSU$EYnb29uc~Fh^4eLENwExi5~(I(GA2>ir*^urFlZH(<i#CrG1sH6CoH{
zy2GsXu*!=Qs7TpkCa?#bVKogT$O>WQTcul!(klud3PV4`&`$~(I6WSjGj31^Xn+4q
zm3(}JPM?P&h)%#SZVLXM8PXbpZw^xJR=IL+x8M=g$|AVU%KB#-(WAacRZ^&AWf8;L
ztSriC(SNhh&dM4+6Ig<U*PsdswTjf@N0-YpOf)XQ-|;;Q)a`Bx9{KHiR=fQDHl#53
z8PZW<?CzGL+Cf-_`mYCjwWe$n*RxqtnH;$JHo(2ztqDNwHZXsQeQo524)-h1r)*$h
z{c;>1AWTRY6No=|RzE3IAL}d_T-EQRn<WMpE+s<7Xq|w<;QIB1YEqO2JU%DWkbzDh
z{Wk4ls-I5?C(&1GBeuehR36C_HZs2^&8rYvGOhQih~;LcVI`H!acpT#TQ6R5F$!he
zs;0HAGLo;{$m&&!SO-G)g(Ec~XVVg-A##xZU<(7n&*f?(wD@u(8>?$cPa`)mLxm<Q
z-&kVYa$nfcMIY7)iM#;)JJ-m6+{C6zuCP}ke_)p-Da**6e`FET%0)(=TxUXg-t9+r
zT(T@Q@{rA}QsDMAM)JUBx{B>#iV%iS#_1urE0Cq{X6#=6{;iR(-VC2)@7+fJ_hweT
zOOE3VL`)XjYq^lAK<@V2A0c-Mpg`Vi0R?i$Vhu*t>?{?Y3b@r~t3h(I?-uL<eik&6
z@85!T<If=@`89etjfa1?Fu&k)A%y1HV)LHHTb^DH2|T&{hD>$0!ryTO4+FO%zOMU9
zculvmP8Fkx%b-V+@jdj0<YI4@kUcyiKI0hN3E|0UWTtLo?WHoX?niB7eoi^z&!zyF
zvyF9ZJRcKtuojxIDv@gBUm|2>(tzC^Z$%3Y5`@Q7>LaO*EqLVm?W~^U1?lr7?MpA-
zcRTaaX_vy`PL7fae|$}SQoGY6A$tJ2BToMQJQ*$T+Kx@0!Juf59jvRAiwPaNgVjxo
zxk21J0oEZ|XH{RqI%@$F4T9WNq$FEYM#6VeSX#X`VqXOk|IJ9JVh={VoQImg%d{xr
zgV+QwhIPw6g;Y|JKxgzoHTCzB)OKl<e1?+AC4m}Zg#+Z)On`H(U|=+Qi~ye|@Cv)!
zUIN^ebkr=n+^qz-8NfxUsxl*NTlBxJ0Hi;8IIvwK+Upu!*oFo(7Bv^eQwna%pqrd>
zqJ2drJt-l=zDRVQC~*^$Rs>?PD{)sOoY-vS|LkOS!#^Y46;K3`WOGhnz3aFgeeEg)
z6+ZuWFD{!tIr4a$k$2if9y}<nCA+Yj@CJ+gf?WtP{~Ztacd<&9RzlRr+I%Ly%6!;=
zc0QBR%DG{@RxWISii^=I;>P=d$SnFV@Qe28f(&X-X<}bXX{F}JwfHK-hoRb>iDAkZ
z(mxYp$pr$5I}mRLEn|cU>sy|ruU1t5ZY?$P62G=xLw+HbHIWYPg7Z6%H7ey}^+6}*
zVd2*r&@b~?P?&(Wa&X9QYlLGSw*(ze!9Lv)h^1(afu`eMOda`U&*iZiuJ2#N^L#_O
z>Px=mBiyumMEMw97U&Hf`%X`tne*MJ25I)(c|;F6-C5+J=_ljdTK)7%#KzX$EToF}
zXjOFNV?OX<Fh>NL;xpyyQhFE4L-?G>w(FDT8@;M-f`d$azU%28wa`pzAUk>i;8uC_
zgg7)}4-4^g){{^X3+4o(wFI&^UG9dB<c;@2oWRoJOZTwq(F)d@c6x*2yiw&(0t(Sq
z(b|*{^V!iG0k<~Qiki~wMN>_@|Enpzt*Hl~sNs8AB`FwWId3oXZ|VOPYRRyD0v0Gw
zsz@mB0#k{iq@wTtL38>I3^<Yq)xq+GM^(PxEmEez+I+Z|RW#(zCqv_v;^bx9^2Bvd
zxJj#{Z(Oz$^!nMZh(f57&uT^BYr4PC2Pa|jpaJ(t;Z{wXiH>8-8i8E5!729Z6Fx7W
zMR%FI>=`B;<_GzwfJCc<_IPPg6BdV2ecMt<R4=mjvE^*LpR4ak(J!&JQ<><*`oUfz
zsE~b7JP)QD`G9@Q=#&#GzeAMGm3?fQH2;UPyw84?TxZTSvNG-|cRQ%oMn`wJ{M3D#
zU#*}f0G0F?xBBmgw?-QKoL4vijhI5*e1HY&9i|%{aP!YYu@`=~Rn~o_&#dQs>H(&&
z;R7y(?=dX3UL0=WSc!SZ)#?!BcH5l7Kd^2U)}jaC^3ES_<hKv7Ds}p25)teZDk=eg
zN$!c=uXvGw<zqq)?k5n?yB2-jOoa6vgnQ}RA7K9;WZi2X5&Q4(_tWlb9HAAo8Fj;z
zCIzm&gdD`%ia5D3L$PK)$b!pWhM5fVJsC{re3@VL{)-<`?OJdTsFn*TsCF|%94X|j
zDm)EvE7k650IKbAnAI%5&qbx$7zCPG8O3Eu#gTm3VUX%@m_UaPvua&B&4aMiQ8l=5
z$8F|Y3<@my<oA!7C(|3v|16+r{uInlYW}ne-vPL_`SbN{&0lu@-{yBh$BX7?R#Kby
z89o=Hv@$-K91N;`1Ye;=Z-l90Im|-cSAJPC4NAFj8b0#6F;E)&B?1Ybwh0XHLdjE)
zHbmd)Rx4}B0&c6L1<4ucQq(v^)Oa52lI1_KFy9YEs@92BhNi->hqobesgYm*iB)nv
ziqs+;+dE!V89#i~bz=o-DQqxm&1V7<$s#{h)}AhT@)6e0DJQ(lNT~ngM_4c4!=a>}
zv0RGXjgAr7;1({WavE=Pl(qC7{GX{Ortrl_St9DWJskBsILe0LS*GWtW2{9&H7H23
z-ZPHkdtr7XEwcbdP8M3R8ab;#-NMMBz-_U_hzhCO-eE6giK8gP-2;VR+lRkD#+nU^
zeMQ`-3XC61tNSp)#R8*T4zS^_s&=XXK_7ESd=;V05t2!N!w*9GVQDGByd7wyuawhP
zXeOY-ZLzX|HSlx%?iCoE)*oa+BQmf!0OxT5>n8<FGV;%lvry?7HnS!jXVub5P5toE
z`IS=ehZJTa)F1&7h=&zbRJEEV!fPEp5uB)6w4mU=$OH;r{>w)cEG~A=j%ET13bt%i
zDVRP2OR}#a$omT<TGt9XUI%m>c7jF5Nlrw^IAa@!RfW(JDmyz~^-~kzek1`3Xfl=!
zsf0m1rw|lI4J|5i9H#`2<f~4==$JJNn<^*RIN0IKar8*-wd6MQGKdAe_Qa-@ow8a%
ze3>2n;0!_0>+B6`uQ#gj-vGDr-MR?$m!D+8e(T`wB6f#;MW58f6BL3=y6;H-%SpsX
zB+WGP4<}iDbYL@1L=|^H!MvaYpNXc5-P)&!a<Zdq+B&doz1o4jD%`uI121c%12a#d
z1G&<Fbzok3wF8kuXMnDnf#Y!vWAr5K79aq7i>P(_KXAhq)wc?Rc#+fv&YB88Ltwee
z8h*HUcYWGajM+*?HeSF6{|&-)3^4tDzN!T=UC}Nff~cFy=n%AEj75K*OwAg0*%`9a
z$K`;n=<C5Ey9=@-Vg?srAhS@{M}DSWehX_f^H5{A>A0W3Qb?Z!Bo>1f+cg`vAyl#G
z1EH(|%1{-CHr0#xAr1?A+DLJjkJzEptbC2->8c=kq_Gzy#45IUFt}UbIvj7N018%F
z8+M+LKaJCfPqVSndz$TRuB#<h02KnT0tmuHfHPs7k^Y1up>&+3BzoH;o8W&bUptTq
zmoXRPfr6fQhJ}Sa$27!ey^6~oRXVj=eAWZp`V4uxpJbMhCMagn&-}{BZ=8YRUC;|l
z(X%YfV-_-%q*p?E>$5PS>mz;WSt#ab+0SvNAIh}!6eB-)mibrx6&hOHE^7T2-#@}=
z_<gc!*o0d4LQKF;UHl6>>3j=I6%w8yieE$i`!6i4;_*o$-(I@r6&{d5kOFXsVEgP9
z-S?U`!^nfqF~7834S;0{2DrMJ2nS@z2BJx=LOJ|?FMSYPtv?e5XnKAC5dQGlHtYH$
zXUA(G1Gfbr!sV;D9B)Jt-&1Bgy;V<pcEFBi3~h>(j?ehObI-9lPQU%+Os8URZtv*D
zHRrJa{(d4>>gQQA>Cx_2yx)1YQ98WtId{E)q@@$Eqel-D@sMx<o{&Cx7<z#<#x_OO
zK9KwyF0j_pMG(Q03#?BKmtS$xE?bAV=0mC7;<9cffSzH6L=WnXV7Bs@Rm>Om6qP#{
zocV-b*{~*IDW&LEs<4Dcx5gEzo659@A?zezZd(#CxlL>}i}096P@_aCnzwr`Joq;j
zTxSL&+PSB6^Fttmn3IIjt|HITH-xjzSeup@XhgrbhJkI>cwYM!*WVIiu;y^b9f@;{
zyv{|IfS|dAo)}l=MV4Rv&qb&l!%_EK(G0dI`Vt5PY}<#$j>_2{SW7?dRi39`!qLZw
zaYoKBv1(uRvM)VLlwQ>b<Cy@;0K-}tLDVx$?5wox0k-dpC?wG0N6GC)vVoEz9iGFG
z3%HDJ-Y^$0-Y<N*SN#j{jS&(W4_DFi(+e8<4=@8uhCX;+Ou9wmw(wB##h5((GOMYL
zsm(WEX7y@b?S<NR0lAScp}|XAZ{W0qZUhTJTo4uBs|E56#tYwinFUmZ57?qSdcGGb
z6NRv|i=0J87X8l|_U$5?^9oD!(z%gzn`FRgrB?`bR7O1a<U6jgO;Rm*+xlH)K503Q
zYkp9LBCY<*cnB%iFhv!Ln4vRbrV;Gf%HT#~6#Bx^WLM&nyC~sQQeqiO2%atx1zW*F
zG?a$V2t$?NcC>x4fWN%TQp)>$@yYZe*H51#-u4exvHJ4QF+c>qjUwT$t^;ljQ87OJ
zDb?2%3D!WcKUfRrVTq_7cSUNE$X%~NJ?tBRK)`FPt;<gj-@x#rh=?VjZ}`k>Y>d>T
zgOR_x#ww;=nlQrQKqXRLInj%jx5Ks)mQYs-7@-1J0|*0jv~_e;PmJ<)Q}hIcsqUGJ
zLoOkR78!`HB0WMW(_c;Z6$B^JeR2I7=8Eu<{h0bcE)7-cNY3#aw+DUIzHHzd$fDoz
zIpoxo4$~jH%_8-Sk&A#4O!$Q2eQa=nBl&R2cSR=;h0cN6xh~cZl@g46|D8dhLHBc=
zDGC+W9i@5+K}#Hn_!ETel^SJSe0NY=r<}keoxy({?hcBOMuU~o?+yx<291P+@a`b9
z6uJ5pzu9!E7mvI*D60DM5$fpTlo2jA_V*m7vj5eGG@_%Bs=~fYyuoTaKWwi~$aJLf
z>>JGA?O>^q2)lqzhFfh-sgZo=4K|=rU_6n$Q+!sp(zv$OT~jz394m%xQHJ(ctH1ex
zs{eW7C!~H8aTTpsJm(W`vKj%w!&T&tM&1%ev=Yco)=}EL{5kjdn^l07v+F&El5O3*
zrz3i>a^iE*`4V6964jilETAy6R%1;>%bQFAccj3exQs&)Fr)GUVdbR%&8pVkRWt$<
zCY%mrVc`jOpi5sz)%Hmy<I9zxumfGDJ{rL<{>_@U9=40nnrc9_MT1cgShRk^X9mW>
zj1R@5)r_wRb{F$)px(MWuB{+^mE@rO5|6z5EmpH}BPtYGQs_M9LlpW0Fyu^A3x(iu
zU`hFSD!>00>)vj+t133)l+ANtYSTFxED)-LvGMI;HJ;^LkT4_=<Q@77n=1vbQ*oKQ
z2n?^flZ+w{_&)mFX5|AK7=hAq>T-d)WzmNcM3DTv+pH;~4(`^#`S06onOk!1D@#n~
zLlH>O6u^mhSP$0?W+3DaOe=^1EV^#qVPSRl2a%=YVt}g$8}U&>(qYdLXgQ!>1~;r7
z3O#qGWdQ;{nkFNV|1O(|w%#G^IR7romfGxjl^1`H&D2P#SZn{PuqN7|(%iie`_#Yn
zMtn#iT!M8WJQfzR7GRO*ZNMVe3R!~mO@AY=ai7(I-r7mPUiXC#>rc;{@3Zp$-G46w
zT#dUKYq@BD>U$Pg>#zH80@T6`i5W?wWlK&}L2IaLN3kjduH&*E;Z$2()-j7dx;aAm
zide^>*%#H&z(f>F^(YZ1i5C5au10>g2oAo!sYYJ<0ShWSz8UerYwSvJQxVhi)(=>H
zpEqP6U4wHOks8iwq(&7Sf}Q_>O?S)*t@mA39`KOG^o@Mw37+UhYZ}MNPti>qf6(D~
z@JF>xAMr;!KqDVw9iS0#a7YRiDRBs_1{97i#A?dA5OMYbh3$RFT1kCwjNqC_(58)V
zjo^WgVC%F5q$xeL!owGjSRcP-{UP`(wvK#>`Gc@(g{@;}Y$Xpe=3RJ%vjd^>`w<Sx
z-|0l4z!(U$4>+G1o&!P=-kUSyjlAp=W^l;~tgx~w@Ep3RIcBKI6V@%XuFyH(7}7zH
z_#CubCT+6P_B4ynD8PN4(f*V*_X)Oy7QXf5|2|=rV151A48Y1yS*OU)dJ4K<ulvZu
zKo{ggxJFp?_aP+<{c$}7K;RNAV%I!njXM{52&#22EvVM4B}V&*Y8OXi)Rjx>8QcZ+
zEJNUk{lWBj$V#_za8RP!TF;nYs3SNWL!aIO8Dk4t8R}^YTi_8BgP4uA#EcTwb|aoK
z|7uR*8V7;PLIeRKVf;`G1bS8I#SOlyW;I=ftlsjB`D*Xf;U}N5dR62O=*Lpv2p<Yl
zOAwyu9#@YJIfD^e{7TvP$7^2sIS#{`VKb@qy(+KPckl`c?hPr{rmQjRevdstJ0i$M
z2>O8}C+Vb~!)s4I_c?3e{-Hb7q<Y&FzkfXW#pf)jX2U3r129yCuTi^vQe_~L$X0a}
z4gNC(M)nI<;q!(GMk*2Omito7kJ2|1`OucH@}f2>%Y3Mw(O8KADwPA(G^29GN3Ctu
zW$J$RkdO7wyccXh+Ld>Z^{A+{^2_8BS=oNDovb`yqGA69DM^<SKuTIdkMyEB$pMAi
z%jwWz$O!iC0l|E!OmS%9KJ}4g{3`M2P!JO_Bo5bbm5$_NUb4pC4zO_D%Gql>Iyv={
zHFC@e+~bFjNxWnR=XO!59{&3x=C;-=*3{$v;}H(Aq=*|na~tjW;PD7P@fF+Vk`o&A
zbyW;1oHqouH+s#UXn)G#HQ%siRjOM@8=~|WPX}GGJ^<tWhH;Q)5DKB~C^)*`Fn`wz
zByU=a*dz|QxBCsNTJ2t0LH@29LH=|9CEUSvY?au&zDm}$BOu4#vOw2Pn6|=cqKXQr
zqV8K(u~(0pu!lXNl!{zRR&28&9I<35DsRy*L1&5+Heqtb(kMHE!c5)bvY9P*H0(3g
zPGG;%-1bMQ!H6Dx%O*O<MyiOqash~H@GlGUbbB}g21}-hD#I*1elUU$`Ijy8+KXvC
z$UrmJt@h90L({)wo0Co9H04rUR+rM)_16@pLL{jSOu4Z*ZB8S#vR#a_v5l*UWAaR<
zVuBY_ltKQ~_e?_!*tA66<M{tIs4`7YvsdM2t&knG7onVXr@ROwEy)NwGpH4;d@NO@
zm0uY7{KZYYn*TI_8u&~3>KqMv5|&jE0Qgn6k3L%9BEl3|arjKVJPb$OV&Mya&+2)9
zUlW+i*=cosL$}t4oGtT#wQ|Y{pIiqd)8zwh0h-^K=X_wHWj#Bpc>bv)-}eE>D2iZl
zU;Ds9kojyRGHWd?-qQ@}Lc6$SX*lkRXKPp9+rsKO*9BbVE=>#mt%U`8m$gEAC`-WV
zBzCrT;AfE%dIiLy=KUU5XwWEw&(bK%^cLgG1mYbW7P*@{S6f!$xrG!3-G$L1M|R(X
zp*ln!dK~Mvt&_Xk^xnen7Z~ntTJ)v4ne=(m<3&H4$N6Qp2VrFtU<Cvx1lH5=-6mue
zD!b0}B%Be});z$UYRpxoy0DrnXw7~BGrNH}d{MKNID)~XLg&xX^2p_L{rFI=xo!`4
zkYQmb$OT$mrKE-+)DY!pM@%*O#3FPJhJd2uN);Wo+6csW!c4${`u$Z2!-aIKI!FLU
zW#ADP6MwEXH`KZx<Xhd%er3YRAi#FHFYjDAp*$ZVnbTYsLjx8r648xcV0YuWWUknF
zn}gs_-&Z5ZsLFcsF@N^M#24;H&xA!)w*}sEMR^C5@1!&PR&XI$12C+}QHolK5$t<<
zn2~4b%oVFuQd_9@QncXtNedThK>O81zyq?M(U~jzO=>`lB5E_oqBeXz08`oq$z>eP
zL5-$YgfK{g0YF#j9xrN1rT|Tk@&NWRE!&SmffNHT5wM0uzok23CLGN^`VUQ@77%bj
zWK<nh(S6>fd4=Gi0scX438@xk)Cr=Y9;l|+Eq%z*91X#`tE`D@oy-R3HdR!4as4>t
zMI9$|V|V4IO|U{*6x|%bCpno%yUvGNEW|xMsIOa!k-u>=S8ciOz4!pjkIw`;u0K){
z?rs%`-Kwbq@lhqrf7bPnmPbVb6W*{72b41RfzZy%A`>TETMbNgwv_pyZ{!q6MX~v2
zw=XbhFf85D=8C;`L(3IavPw#KrEqc?A%ZkmZWjZ+ffK^byQ74JyD&vmK@peTmRvD0
zDFrb`jU{v!IL}`B;JkVnb2CRoh~mP41!c^Or8V<k<<%@}uC0;!jeV8Zr<{4GMyk^q
z!qUauNV<Nj4Dak>t}pHK#|E{FxrG!_37&8lb5m(gGb49(HN!y^ZLEZGCA*q?NX`J}
zyPET&zjRUgcr{2eE*qC*2-3W(e6>|r-`g$vFc?bqJa`Ds0l|a8rFg7yqBjqjI@gJx
zbTdbK{1j*Jz3i1}<mKGWRkVNn#Ou1FlM(3KXm@jS?VN3brKC+zQfJ-Fe*BKR+0Ekw
z$fd;L(Z7?CJ9?OdCFX}%au0J`$qB;K<YD&3@}rsshbcVFCnQ&BizH8TfIhJ?sD2$C
zD!xvZnGPpMTHsKQrx_9Ffet|!_c>2<qV!!OBd_dbZUt-o*5s;ugcneD|C}dZ>t%i=
zJ-+10S9qI)opM5*E1<+tZ*v^%-e!}8-J2Hxke}Y%!_Wl`6_@>u;W6PVd#6xo<gaX;
zkTVfxZ)g+BxkzvBsJjVm%vZ%u_4a^>p8`Y{PI^YP+cF9MULSKv;?hTgb~Sed?cV=O
zrCnbu?Y8qri5#1-s1Sj-B9ymUwpg}!P?dvi7V@uf=S}i4N2K|ywN|_>YMu5;t*88e
zDtCKZcwQ*+NJ+J`YNOiyZ>gtU!Ej_1H$l51B)X2;0eq0cnv#Khq+^$$p9L|nn#b@O
z<;^}d+m}&|WL;rdh-P?fS`!08G4C^wH%2LXP6GQcWk)Vpeq?!b<&X-vgsE_W(3wa6
z$1<+H`!(NM-W(S6pdRY6RWig{No`bO(fffNUY0kv2y6<bFPefQ3Z&gtw+|zsW>gyg
z=E=MIn!^n(L^Wi+o;&I35Syzhv7#xbuTuE4Ctv4lZrc6tx@v<I%B#FT<ta>mT~S|D
zEJ&@WtJU7{#YYf@RgK!nuzu3gI%29$ha?*AgPqjVi!HHJ*#7$p!-K;<vZ@o6HZBN~
z$;F4&aW8;!rJS8%eU7kp9O9&P=1bMoCOx9Ocnv(-@Ui}>id3U$r6)R2B2@SxKQsIU
z;eDz_bB({bj#TF6YhK^qTtDz}(`V2&6jGEE6}eCiKTg5diY)r;u3#d6bIZU(*k>X2
z3KwV8c!eC66roI6rXWk9zqz`!Ez-z+0?ci^Q(*kjP<L;q%?H(J;Kl%R{opEKako6|
zn+?X7XT}YoN^pio+&`mlQP-GvEWjMB@tyT2*Z^%MQabvC?FO(+Wq27Ym}|xkxhGg=
zIx<1O4yL@Ye@h)`0A%2jcP}Dk^0gwMQ0yu?N{!VZ3{)4DxV?=79~x*5OZ&Nz6-oog
zn#s{WT0J(GjBLlYwGrkSA-Je>*2Tdpa_lOdZ7WVqm8Pbsj)LK;BN%lg7<8(C3Q0y(
zS=(CWEL4dOd(yyPDHrRi+M(7$9OADOWUlQtww8*#BU=c04m>%?oZ#gS>2?q?vknK+
z#VFT96dnvR`{<6BgMgV|XR3cVr6LF{kcLmn2l)3nR!*oMS5$@X$6-}mJR2dw=D|{x
z_~$$;*c{X@_9i~VRZY~q7sQ^>=wYgF-1LVCqtB+>Daeq5p@gfYVZ6`@z?1|W@7B|5
zz@2g!MGg>kO=I4ZU~_X#>}*KLgCr2FcAEjVI<3mEwE_Wvn?S{9EyThnwhWSB2`8f!
z7z=S(SCs>Go^w-0v#)L}hRy$a-@~^W)rETsArEPE!azw>>I6akI(5jpV};;q`XGK5
z1=H>#&LS?`y8j`Lf|FCrq95FpERt8s43xxH77fGOx~M5W5VyLzYPCGwL|D6qE)+Ky
z?1*BZNq1!}G(VX(XGEqvWU`)_681kIRLNY$yI&BE4ELJ}^c7h2>*H`@xRTkw-vF^D
zhU>Zdr&&zUpo9(h5JXFf*82mdhES)hAG<-FE5&U80g*~qQ_~yys$N|-wX*2fMj834
zxg)$n8eqnSrXJx#j_qUFju*zXcZkhuEoD0%!xQgN+1y<V-`2Xy<{(_}?a7Z<HZKMl
ze><4SI8(@Jybj)k7$v-tzQb#6YbxXpUZWapAb|nPL74mt#c;9rpfmEd2J?BTV^t&n
zH_9C7R|_UKtxr4zwZJA9-g93hN7gr&=LMnWfmO<m6(P6Nf5I2V)!S9sP+Wd+YYYYg
zK0;KM<6mQpJh6(|C#_o@#2N{EK{Xmch={{d8d=9Y+DnXCM7w7@PDKrH@lPLCT(Q|h
zb&KKRdn_~y8M34Hc)ONbTc7`rvF`wj@_7D-dqGh^KsY)A3W^E{DmFmCdMGN`6??CD
z7_scD5sX+6PqD5ww%8jnDuTVl5=%737JG>vL8Gzv`+sKN0}hk#@A>C>BJXXPot>SX
znVp^8^`m3|Bzzq*prF7-HzD8RT>jOx7PiIvs;rKbBBk(J)mVs>?)8fIuEsni=Z`OO
zZ6g~ZEv}iuA6J90%u<=kEb}y#3H|Vr_YGnLq}&=fKoP_``mTZ+Ht!+%itCc?L7Nr(
z9C_Q?tWve6mPDH#0YN0k{KQd{bT=fKGu}yvi}dOY4%k4Ovan4~Rc9@|c9TJjQexs^
zUE^p-u0k$=T{v?cx3j(%k3ZVYR!W5#*`WrDM%6}TP<2ra)~4}2e;Ud+v>I|$G?CEg
z-+0g#1D(`TmqI|3g$rH8x&T{_&bTe2CiAN@94fltQ3YZlg@K9f?}Ezthw%^03!{z?
zsLASAb)tf^P%yO<UN^;9nUh2r^!0VItggx2+#f<fm8|<TO71x1KCj6tOEbUd_>tN$
zDYN}jc>Q1)$yJatF_;Z>x`9QL7*I$DY$w&hDf3`fMVkIu$K6BNgkTRaZ@~gM!c*(g
z`z)jvfD9_d9RN!dnXTyh#@dj~AuK@3`=sNKLRf0G_E_2!oU=vM8k)>AxLz3Y#k>nN
zs*j*LCx<eB>BC1IUl+<6RX+!ltU!ZWq(mB|R>zhN=m6}@sv6b3QO~9py7mp~h16p6
zB%gAx_|aM{L8^y=a|&a-C0CnQ{B#&=DmCy&h(tKklpE=V;UO_D&em5h65q`z8POH#
zkS3-B7W8R&Re>)JXCc;~A$>JG=Wcx$em9)CO6OtDzek4OG;mUZr41?}5I7UvHJ_0F
zp}5PaHmfRyz0+}BZPvuWnc$cP-O#HHKU|ynNe^M=KcHg!@L^Yn#Y^pgZdZI%^8zUj
z(Vb2LEG{M|EkskG9}WgUp<sQOc@CHGpQ^*wOP$@ZNT|yqDnII>7%WiB5zZ?W5p@?p
z$XI~oyz-TfpQ_86NqgNul?WE0(%AAA5v;#7Ke9aE8o`>WmY3%*B3M<At*+*R3yM_;
zu0^gwaCMYo@G+wvy3nj&1-_*o3vnSj5`HhSyo8Q3yjqF~%_sF(Q~&5=WZ4u6*8KsF
zpl=c18`UvR5N-7_nt$10<F-Egtdh&})CO!qm!GkYC}{Lf#N7GA!DSddZojc0<f%w_
z4(F3$>u4lQMFK)$Xu{0>n?7H|x-1y}jL-mYrV*5vh>sTzkx}(9Fb!FywDIHYfRr#`
zB5ExAic*GQ<j%%u5$y~I#-kNFG%4V@5xgjJ%ZWLFlOdQCA27Ow<KZ(;Jk`o{-9=f3
zT9v4lKKkG<!g{-TSXgfd=nr}C6F~@*1-Isn&Y}?UVlYPwHsVDKRH}Ax1Rx)wb&D^4
zT8N)Jm1T@*nz#dZV}c=THDXmO<l?rhf<^#|T?0&m{*74khRr_WV)e%;ZCaVbd?0Q9
zAN-y#w7fDn277CMuMu<ibq0@%nx^yzRti}Nal;iW?jFgiIyZJFeGH*kumQ>tH_w2D
zlOmaGRdsR3BxEQ>Qbmz0h*E-ETI@PFIVp2QQ2nMgKN`szNsa(#jAYRsGaQv%Vjl$E
z+JG*wkn<tcIz_P<|1eYbVf5Be2wEr&CW+F?uq3$lP~%Dt|2UYn5%r1Rk77gIWF#uZ
zH=?#tz0+6V$Nw3($eE``vq&d3m4FR3Fq`b7cD^`Z6wT^8oU34hMvWRQd6~vgfOD}n
zsMnYUd-Ovt#eSlrJ!lP~h<wA^4}3yn7ATFVguNa5_++2L&opMfE&i}a1rc#XWeMi<
zH#ArF2c&>*hGSpI;(2VifkZ+^nnTDuh4ovq-XZHbEQYo8xV4Aar=3gbObQmrj$x6A
z-*8(6+{GT9<S^xLG=@F88(7|&?O~Jsh@H6IA{9GyR<M)F|4B5~WcjQ>dY1JL{7Y5_
z$F*Bo*6T#svl}fHf1^Y5BQ*6bP$A2Ds;T58CkuQ0oIpi$?Z;yQ-zAp$J0+O1I}1Qf
zkenIID!E3Ok{cjdGv!zq3>Hu19f)O~aEerE6~%AHvZTtnyA>%TaMN4+xzb7}Bj6OF
zs<&P~4@;nSaS$_wvqtdLI2INBsWXk;u7DgdjTT{m3vH&Jc9{Ab?$#NE3Ag+&ornji
zI}1zon{lkV^cafKrU~ofXg{CgK}?4Z?;d%_bxl}ZDIVGDo3JFu-PvZ@L5JV*vQ1fi
zX*+adTvOKBao`NIY<FaDXbStOBC>B$_UY+n*%J@F%Wc|>b+dH#bB0176>M5v?8Us_
z(VSJTbLOEAl5Dwf$b=gWPkQ3;9|W79CUb$<0>Cv|?UfOl4b7TmeX>0+@NU7XI4!IQ
zr3D3s+IR5GIp8&D!GhsATL0HmBOlg+HN^K|`rg!n`3B-e<z|Y7OjyvWMISLkPm*(i
ziH7ohUGCEstej;TeaLYG>V0a-e55J&b=+IS4oWkjbZ%+bJy=zr9z8YY9*<`cmQofb
z@TXSHBkUyjm>f&#G-A{Q{g)o!@Whx{qk1N0#vzimCUsa@jUd6+Y=SfkQ}I}9_ENg?
zsXWh1U>e^o5T!+~8L_J&mO_hB7q<~Z$N05@k3G^o#X`K~O)Hx)Vgq8)@Y9AyjCX9q
zYJ}>oqe3G=nG9j}D7|ex-MqKQZ|H~$h93rC6}z<!b9cH6DO1=&@pKw&r$YZ-1}N`!
zlx#~fAPCksh1G#|s5!&SQQWI7Bt}PD1P!!hBc<am@KCme4{hg8=yv;dtdfJ1h4M^0
zv8iFfIo_xpYwcX$hzqqQA0r@Q@T$Q8pq(A58!YVY?N~tC(kD7RB?94hD4nQgA;jQR
zO00)ZT)<_XK9bVuc{#;DrV+I2N{Qt}J@p^NVs!8dTT^g#<8Nzae`@bPq^s1s%9aE{
zeS^1w3ezYGDwk5j01UG!4XHTH`w1}j0Bfw3t}8G#CYbnZf+@WaF#DRp^d*=Ca)24g
zU;z@wqeVe~0a7PGE}#`0zmUkhBW%n-oTy;}VQU8B5)zH-)dZrv0O5LF$NiI7wY05e
zN_sS`sOk<%G<9g4sM?&WQUriPIbvHZ#~?WhmMHzM3+IpFj~=iE`od!gLf9g~sQwu?
z3V9ggV6haqJQq3TsOSzV+V$^VBIR8Rq<l{)qfic&A5(&!5^(7RB|M^p!<3Lq3GjbR
zOxtHH^fNb3ma4#i6$FBC6k{%dM*`b3zuJe4#KCV3zfK@Ml2=|RJxm!}<svz34Fb~|
z28<I;5`#^PH+)=s*0%c{*m?!q1ZPB{5^bSC#VO9vuV<W8mb6Spz$%b~@*Jja5`=+%
z!(TkO4IxypNPIpom%@EJuo|8d-s>!yhd&jV;9d~Cb0n+=m%nwqe+O1ma`nQlWCs?T
zb_r&eI9F&gQb=?d-t2?Tb6()?RnBB*><<V+0@)j3RAkB_c(|0vUPKL0@(f^L*pIVg
zrex(7ZnDRQ7+&L~O2N0NXKE#pK!i1WV@xCBonl11oiIntk*JJdcCskk<8m$I5Zh5S
z<7W=Hh9}eLkZ}YJQYyWzXQ(^WS{w%-@fDO=d#x-?wS%bKr+f6w(!((o0Tq?g0^BLJ
z?2k?&-o;qxjp6zVMEPcp1VX70U_<4{9kU=DQiG`dcVt)u<^lqaqd&!9nfJnexu{I#
z3{<Ws4&2j^YxE<mspT8qt`iFiYV%fM5nLE`Tmdcat&Al)Wr`}avu6C6uk6G;>)#-K
z1t5Zqdz!p~VgA<8c05tB0ouo*c=2yA{w*<U1|cxDD^p8dnpWULx?<h2A8Ws?uB>WI
z>)%O^+%Zh~7AHn<6djEwi%m|`cfqg;$k0d6+hVfJiwYIQVcKN#KHZ>vt78FqPoCf{
z-G8kUg0x`<Bo(X;*!1L$rO3z^37PK=w`}nE3t8z24Ikn0_#$VZqsbY#$W-0CfvA2w
z$P}1sc8C!@3G2@4_@7=@&H{G$b4(-E7!S>qr~nIxjCN4RBJ_C66CKY$F=_X2I-cL1
zMX64x`Md7yI|t8K5H3Bj&Vg04egSNxWai_WgU*qz3c|o>PG$sz;cq#?VfH#?@t>1f
zQ>(V=uz~D)um-NDZYe`RVI|ZXZ25o2LbZDjHacL(2f(+-A~SU)*!qjkB2JMdpeuw0
z7E~?DAbgyl41b~f`sTl`FLXSnCzi=>7j(R9PgcLuQ_SUp);LU_S_S82KcfZ#5=v{P
zHO^$e>*j%7+Ar{c;_Z%Kb-5RNvd)&3o1Z5H_oa(AzZeGHEv@caKwrl9hHX*iyp9j;
z&BCP*&vbl6Z<u$N@o|(sa`5q(KC<v(*9RYi@DbhzwOZgKsSmLH`H_wf>w~@btU?`6
zj8Avvn<@Ddtb}7!V+SOTfj(y9!@e)8TxsCnI*Tkw6CwO;t|(+2k1l~$fYGKeL+DIM
z>W2C}t1p}G_}x>b1X-bm=yx{!Zhz+Qn?$LQiSLkFA}{F|UP!cng))G7NT=`V_@sXL
zm|CFYOZ%~qdaogC!MyJ<hfAH<8go;pIEdr3#@Y}|+Q(;g#?6|De}@&oKlfvy?sG}F
z(=k>0FTG%pXlpr4&Zhm*y>a*$(x26-;*Vkl=S1h~frH@#F03sa!FV^8x^VBA4L{f)
z&ZM+AroPNC{NH`K3P+RZi|t(<j~c)_)<}T5G{Fl)D~9Fg%LrL;0azIvZqr?;g<}!r
ziOHQm01m^Pzc7dcSgbS>A2a}x1|RJP!e!!%kMRRp<pv)L%!XveMe`wP`B?cSaR1{e
z4xmErh_TSWGU2}(wg1;x{0XuM{5@{#c<3PJAKsiwLm~tjMnhL*+`v`<O<am#0<{m_
zRV>1B!$_F*1?S_^>_Kd}R1U-N_aNqBHLw$GMccuwTCfb03e*1rs9@<Z^#>4F1HQUO
zMDax-)8-lk`V#O#uffb)@-*o9w}Y97=XQ)Yb!0JSmEnC?Yk^T8!>^m1c+Oz>@A_WU
z@k6Vb+Wz`I1=~c!xGhfn-fC8*g$L+^S5Oe{(N%Dsh%85F&|DOyAjTlv{x+K^G{!q#
zFZNvwjSD`PIyDyx^P%q$*qVLNt3GR3lh!vL5e>0VR0485Jo3;)%JDoKh$1tN#U}Fa
zg2k3WfS7Nx*ZH91Rzq1g=aa<grXGgBF{F31vfw|CWtI5sq0G){o=JMmK>y*7{6ojL
z3}p*k4xGk%4TAplab?}6AB1&Vhhgwg>`O-!R`m>VwJim#ElVH4XAJ{M&!PughOrLP
zmwFYr<#0Apa(k%DO&`t@EwQxhJ|%@;9>JR8Q&r!G`;5fqjQ>(d(`OkBPekb;P0LSZ
zEv@!x@wIX!gmt5{I(~U1^AG3+lS_ERC_;$5VFTNWF~tx+2df*^A*XfRQwx6Xis6l+
zk2?4$vmGB5@R3O=1(-G4>Ek#)F5x3`B^ZpDH4)@15ghc(sDAKL$?IAwkA4}|ZkM6e
zwm|Z=1f)bA1m3!vCV`i&1ILv6qRZW*V>Xt~=V7`YvhXWjXAOctznH>$yIA2w10MRw
z5ROt1(f$D&!JCa@1J!5#)LCR+Q5I8~C+Pxnr~SIzgQJ*@N_7HG{n41dvu^0PZ7RAl
z7$0Hu(F7lz=)(seGJU+mK(53`rAwF^Ak;=I_Yh=ulz13+3N#X)0J)~)cT!oVwBV|a
z4<Eyl9Ilbgk9-YE8|FXc;X43o1FZPxV<0;VF~D|X@!<<aF?$Cn&<<Iev5;W9L6c!)
zS-9FC)(fs+MvFtlVBI#vH2%nQ#<E&cn+v+!`(s%}OX<|Ra{TQ$w$tIKnQ${?*&V@J
zWX4?Z!qSN>AnfKWT1E_m=0u=qi_Z>w4j;KIA;w&T61dnHySer~Q7<7Y3Y#^<Ax!>8
zExR5EfI42&3$sW~<||);y`#QmAr6fJ45mhW<~7{U3wxsXc;?Ibx6GekVeG7`drv-R
z5~4>A$Pg?ee%JAu6W~JE;G^9H=4B<{(BW}{39J#{I03tz+h3LAP7|5zaB*5O-s|;6
zcz>8dc+bFsxisE`P{M@w1k_XT&cyft??BtU|3te7U=^Wl{HFx%H!58>!g#SX5;j4N
zG*&gR*#&5Utl2~0M2*jyhCpnirr{}vsU7I#SQbv-8r9!mc*mr%2<aDmY)fO~LTpaL
zj=-h=m{vC&W?1>cpg^#6d-T@q=)Ev29>L#`l+J>rms_#Vkq#|#{)&!oN@uMc3%(;F
zG$V;=e;^Z7kS3#?<@FalbTY)j&dwEio5{>GTyNcfN{BG1-cgJC<pCQZYXBWCkA+>a
zOHLsG8#jXvFg$0}flOaK8PjOg&pLi^GV@ip`x#Q!H+_G=5lnWAR5h;f1-HGJ3`1qq
zIUTS19X2L9_*LK|=tCd<lJESEHE}(>L5DRV9shH5$cXnQejkZpEk6aIS8mqjhE0JV
z2*PMJg63vtuvmO1_?qO>@b8M`(wZ(sa><&$AeTJ3ZYs7q({|~2_Ed7&KhW`?rn2g)
z938(sm1(5To)viYX)ITAd9LFRrUA>n`*hrGIy*0QY49@FFrCe@l*a7FJk7)oZ^CYL
zZfU$!7v~|tyhinWOtM{>tY;Yn{%wNS$89DXSo?4qv5*~1=UD+7npb-JbK{BnR!D+@
ziljnsnz)BSA-n}}6tZq6t6lLd+_>aT)MCEF)3@6Zn^H5eX|;Hpj@Qp(q0&lpV@MX;
zCmlHmO3q?_-enq4)RserqC~MXPwt!?fHee9=KW@|NH+&K_Xy}wm`=1~*g!MX`Wd{m
zyJoRrQs_D?`SmPR)n*t^(zAXb>$9OczE=<SbK40)qGuhE)(dIzvsu-O(Qri(FiWzv
zhgw&L^LFxVrk8H-&~c|Ztfy*r3{RQEyrfYFAamw0UyqjO6d5I$2)L!7^G0?2aveW0
zhy7G%%6_nR$OlY@BY#^HNhrTfCj6~^&;D1%{>yZHYc~6_W=p6^gTEgZ|C15357k$X
z5*#TZM7gRUkP?i(V9*(JS>=c(+tAV#AxW=7TkdlQkrV}t7J<?*vYyblj1(7o%}Hln
z;~TKmow=-GjZ`X+ePoM6^pD94SGK6Uy{Y`}Q7GSJ9*Yjp+kgB({<B%arqSp#M6YP*
z?}{m99sDtpubsz&ogAAgUNtg>jOs2+bo}l-)~;4$6H~HK18)~AlkKX%VjC%skP7Ps
zBK6`=u#x7&D0JMf<J0FeU%b{5@F9|Kna`TljgB*iU!MSh#xxd&ivJ1C4$!JBU;!BP
zDeohB!U7iDV0Mf-knP+ING9k_=9)msA>$~qg<fpSr-6HN7BII4dTZ&u;!MmTIfCY?
zvk)eaq7|@&4OUhru#_prl^Yi@*WqA7i-J}Htm(2aP*LF}>t*l$6K<{vT?Ov#MGCqC
zZXUS74BZz35rOWGA9Xx^A@lM^w1WvO*`qXurZIDW7s+!Mf*gg7&B@W!1Ygj!Qfc^I
zO5nQyzSkm5SiSX}w+h-{!5{xNl6P6ef|JUWg1>g58M!A_DusV8IM+n()Ev-h1O0|A
z8cVFEP}%z9n@IlqBGxP|%tUTVN4&H-*aDwYU@Mn^y|V*gD~jLNk?obB5EJzWy!lV+
zr$m~M>V^eH)F%_=JG8^U=gc*7Ji*<9$z(PfT}cHh%+rmsH9{qp?#<oTk^C8F%{r;0
z%m?A+d@~}Q_crTIYSA<~wH-weH354B94O}1)Llxg!@$F+9tYVvV==2qyF;)4vujeR
zu5~xHDHtolyiJFU8bSgI#;S>S3q0v}$uzMo$+n~HkC1;PB^nT+y-UU}`;{4|=<PQp
zYIu(Y%-gCRI?uIBn5)lXFSEWnWK1E7DkPi@ow0febHPMbzl!AfOIYxb^`;I8luyG;
zS1b&?&EXW&%oQS2(5zq}?39Bf{2*v|4{c>(7;av{A>*!)!J@<WV0pA%%Hna%Pg(+v
zxMC@^>>S7@!%~L#Shm1AS_Vrmafq<VFdXVY9R%mHWzcW^55C}Mm%$owiK@sgzh^Eg
z`>ot^IrBm<8lP^&{g*R0&#|S3{_i=2;~m3!+_c5pFK6|z!%~r>-Py|#3f*tBj-Ol3
z+Do1Cb-eNl?EatF1iCa_?%`XI3_lV~zb>DT+=smy(P|JORJS&I=sOY!tzLm+3~lzC
z5c<+kL8$Uuy5$u^q!>q-W?&`yZ6Rco{o-ely#Dtr)VHvqIfEY2E3B4Cl6Sc)P|f(B
z4S~_HeF0E?@jVNc9_gWqS0aw2{$5z=D`DWW8*liYmFyd71hi|-RcxNh*Nq=qg(bzp
z?K=K(Ep|^w;-kiD#2e*oFs+osks?;gKd(`m6f0#%-=dZBBb{lbJf53Y%FkhX5z{0Z
zW{*-<%3fg*#{aca-iTIw*D!bIPCH6FrJA48DeK~K5c{+)Zunv=pwhZH{06Po95S3v
zz}xSJe?Z_)U1@*T_Y`=4I?)Y>_OoF585VkgGB?(+N@~4z-=mELVTG8~M_5IG=PRsb
zm8_mSp-|XbmZ_@Z!uPFZ(b94-l^{ndKC1k{0s>wy1!!v$zf(?%9WKH0!|h=m{C1q;
zB$m&>8tMnuAv`OoIeM=yn~c$id7?<izCWTmZW%?A{nJj^_aI{-9M$?P*70XQFu!tR
zK%s(Yl;9J8U|zh=I#w;@S)u?nyt_H5pGh#^LUqNHXyHe)<{h-b^mR;ANmi<S-_5*A
zBB~S)$F?TVUdP<I^?Ft<$VVv{SE}Gkh)Ha201HqGn;SI&w&QwM(|;X|E<w=(+;U<1
zI*l&`)nWmIz(9WSLsu8RYdxDS<--JQzJYa?-eYjT-@ry!DEt8^_XnpIB;z0Mf25vT
z>VwSs8(D4ln&1|*Cr>bJenzz`awl(O?V4I))Rl(UW53m?{<KFlr?6Md7=RoHY;k#7
zNqQecHA=??v`9a@N5>O3F>hXL6SJ3A;aAKi1ndvS$M{VU5Ytv*HG_`|e;xylH-+W!
z0mk{Cn^-N?j7{8iGYj^ahsBA4MBVa5y{~~U#EYP4@6DJl{qZr8K3d>o$!0cCY606z
zxCzGofO)uuMONs8)ptP`Sj`9zgKikM1*ZvSV*C$mVIK7><tnr5FlcXJ+ZFFx3K-6?
zb%PBpsi9?PUj-ysg%!P^Qll*R@wT$5l4`AvFWid7+2u8G*lxwH&IWw^(|m+8m$t#t
zKM}vYwy`8B2p_s_%-wU$N}a_|mZs<D?eS$2@<4j^HWpZC(2}AqGcxmOG8O0q>Yu>M
zxa|=CV&5~X$OY3jQ^((L!zzEoYKWHYEVx|sYMQUu3g)ZB!O#=7Guv_%Olj^)+Fx2`
z8+ixa`Co3BDx^^1qUj1cl(=Z<7i`;wCi+farQ?n}n6D~ii{h||LxONvOoi<!92R*C
zOb&~Jl~@_=U^N`9FePxwIrtru2h#BI4mhsX;3GN*$4my{gXOTm3XM?!+)Z2h%cfzW
zki&XZnDsq|QF)d3G-RXek1VM|2&L^3!!rzNV}4}arJuoCzx{}~mbEQ$;6Z&3y3eRS
z2`%cr6N|zJKq+A-o2xQf2@z~JX1R&t@tIHgr?o7=t2t6=*mH;rV!M*?m>2*jrXD>P
zPRt5e^a#<sCR-^fMDtU-BGG)Tr%5z-nrafw=Y*9;qIr04lW4Y|`ro2?Dq0bux%P_E
zqPa5Wj&NCa1f5AVr~L}yC`5B9m*o<y#IVO<DCdo9QXsg4L~c{+M37N^0}NPL4}WRl
zkEBF{|4^)A5&n1Dl+wrGKq+{VBo`^T5J&vGMf|%C|B9OnC|EkT*=}~*QkwZt#{+ZW
zu<8l7W2;<-XW6fpeaR<})p_&p_Og|3S@(5ft!V`fks#qAT`Y-p_jSBM9!snkV9MMM
zVr#PO?UBATkJYJo2fkcdpvofM`qVvL?wvf=Nfn)PM`vMZ^?IMNpitPE(Y-05Atl5q
zfog3jA&3&jhy?7?(MY!Q+GoriwV$airCykBy-%?E{O|!xoo{t;YaC#WUF{NRxxYZ{
z62OAEfXyk7<|BBEgX}vg)lziHlmB^;{UuF>j{oft>mm)GqvOGcSqLnExY4ixdLL%E
zPsIM!H~8LqnEAop`EoXrUp&m*d{28QmP9u8$8dw~a5yQ|U|k{c-QlY!dxV8n>^&RK
zpebKeWBh3htA9lNMav_svG>(DvTA0TaI-o^(J>kzxKcwV&Ji|P8Zca!YkQQrT1sA@
zU*rZHV-Ho*EQkl&6Kq$-KyYf|vhW+tan4F_|LX{#cku*ktL}vK(tgingLJ&^Np{ZF
z_HUdOL7W6`tOpad$t=LuCe*UqDFm!+e*1ziJjFISv~8tPX0k=WzPCmrKYR=_XUJ*x
zM*4m{*!34SqTJOB7>*wwp(9s*VOJ|2>I+XLPUcU<S<TGbhLnhR{LmRDtGCP~42fZf
zVD%0p+YbhkZO^ieQj3=_`1`Z$l{9!GB+NP10|(;T4n%JI^GtS5iKJ0;!A&C+tE^Y2
z*B!y{oM&65)89h+{E9)^kp`pnS60{U`Jbh`bPrdPt%a-c$VKKRwMx_Fwz<IUDexz@
zAE5WS$i_?i0p!L-Hq-fPeYgh67o@j;5=QPsD;u8uGgEW@Z>)y;K*rZ}l#+G)>~E~M
z6rX{8mrE=jtniaJj(J@YPOn}Uy!nw!aK?XI2LpKP5}fh7Y+xC^y98&v8-0acWeudc
z1F?bjJFAk|0SmD3(**{a4*HCMbip{{ysNci9<45vvnu1t5RdH_t|^L_9U`LkjOvbE
z6iG!cD?_cj7>s{@ha-8K40q3E=IpRHl-P@Ur-lV>!RuURp`K?lUI-JJ1V065^%0F*
zXQ(Rj3745?JzPApS6SGM7da6-C2D<nK$r*)S7JkjJ9A8DG!Nsx(;c*Y<}yog{g#=V
zAJ{#I<Axy;`U<NLLY+V;@z5)RP@~S72$daHM5vS2MTDwBUxH9S^iv2W4VtUtbFZ>s
zb#B_%L-M&3X6;oLg9bbhYvg*3#lk*4e#RTP;iNf?5KO3Np=ieE2CEr7I{-9623Z5J
zbtNn6+^&EiQErwHDq_RH@VQQTe)Jlv?Yub{r*S+nG>6>q59SLbb=m9id=49nu3cx<
z9j4VNrgL&Q8oGWLbY7BfPG=mbQRv+Mixc<1$2{SAnV+TD&?Y*!F_MA0Kfs-K+D$RI
z@VvBF#+XtK{x?8r<8^i%ogIugvr~VF&Q?6FbT*yh)AiQTKv?PQP5)AzO|n!vJ4BQ-
z?`-Sv@;vnh`qUFLaOn*(T<?F3<X3Jm|M)te2r<*WB0x;ginMq@A`~@lmb1wBAkNiC
z{8YV_MZp^JjrTK<L6lZVYdr_xVs9e;>%>Q;pCmD<pOlYi*>==VoTx#nkf28OoRt87
z3efU#UWUNW2|}QhT|SP6&@YZ(rjk>k+zY;^lFBMLA`pm}@`h60cT@%5B0zURUAnun
z1hZ>7k^JpV7FDCtXQiVwpNcROoNj1qF4m8Juj4&$u|T_u-zXE{{%s7)>{~3rp+?nW
zPB79a9Jz&nt!5MdlM_C_cM|j&A{ZkhK#WQ;XIgKss`&X$+%dvLHHDhWEX0w<HVSu8
zs^RPvaWg6L5W&I`g(1kz;)8E9KdV1)0mrP{EX=__kZ`num8yP&I5qyuZC1@Qa>9S&
z`0AY#x4k2{bzNX7e7^snjH1FzMfeyJ6nrSvaO^Ug?0HA57u#)DWQuU2=p+6_Z+P|{
z=GI$pszKah7=juFbzdv~mUJ;@83BG`G^{^uQy>J1pAlgudK8Tnl|snA37U|Ip45Js
zyKue^fiY0)F01bvsw*v^U`l!+Z{l6%<9r|h^PCvjG|%T_HL>+B;v6ehDIV0v;45W%
z2eSVp*zGsP)7v+r)bw8SRw0;$iS5aJF{*!Sr4Wo#4cjgOVNCBzeC|C~+x6ne(#S%Z
z9vrFT*YB~)6~YICt8E2{D^O<T?z7>peqWVG=j>5_=6%@Se~!@6l`vzv7PJSU_}pgO
z)$T`;R(i1*YgBI=q2qtuhZea!5gR-Y;H7Dcl=ug%T7~`n(WVj**B6<S9^iDwPs4Tm
zAu`pOuzV<7>iUzslK0|s{T|W=4X*a%JO5-2sx(oPJh~&EneI%=3zu==JPiWTFKaSi
z8$?0-N6e>;5~<3=9>FJc3Y%c#9<f7}8mCYV#19LbAZzr6tPa=6<nY7kq;^<aKgLK8
z!)Si{m_;_zTUT7KXi%6B5r<w7@q5q)4DMzjrG>NDgo+{R99Yf{G(mJ(<|P46xrD-S
z)SG{L%z8<U24lJ#Sl8HAK41{6RMAgFhW#V9LAOi;PI#Ui07xd)J=fAA-_g8CbJ}+9
z2{S1CF!v9^3kx;{tg&a?LDZEyhVLKeVU%W!B?CMI)i5-D3b3@?m*d2D6|jKXdg~W!
zm2M0H_>%<+4~gg~^rR1Z-UN^^<0;ADdIk(s{x3GP|LS4F(#|*ykYrjI=r3s32m0aj
zVG=yT%rLvNH+Pd#0&!&#zZjZ}^R}@<G@%`#%16d2L)_*UdUxgoKVsF_o&Wt8mc(-h
zVDJ3l3O8vSKKu$<TH2VQO8aX>`@*U%dGrlP*pJZC{Gkiu6eGtvYhy|KjUFrQD@wYk
z{kT~0-><YM3jwat;7K%!SRfz-(90ZPQw+3qBQuC<6GUP45amRVp2q;<B!ZYlk1k{p
zZ-Ajd*6%07(0#%Rq;I}M?9@{h<Z<=fKjMZJoDhci96|S`Ah0I9GtAMatV+2m7-C$S
zn~3nBr!2hkP^d;yF$R>zn+c|0&+$uC+X<t^{%-_;tj<)1FGb}1ZSW{?;w}DWZ{v5|
zBhFX?md9LBSfkWkHmA__EbAj%l?4?=)x{q`68)E+kQK2Q83|d@OW^LE_KdA@$2#Jx
zlX&h%_1kZBJoY*EnXRJXZ+p)CJS<VnEUHeEC7j0dQSOK5aA>ZLg8BO#bK<*JFL}s6
zaKUcsujAT(*pzl_d+IFk_Sm<C08IVVW2R%Jbk7+!nUPzVBf35;9iLgnFG~ZBM94BM
zVJMOv!+=e*7}&?LFPN`?#8*Iz&Z;Uv-FjkI=mo2+9=3^y4N-CuPfo^XUNw9<fO(LM
ztd`EV^S~~4Jr%T0<7EhhynMNpXB6mB|FFck4evi*Ebl>3u2F$oC{PmNNe5T_UcwJF
z3ZvWhCBpC=!RCWsBDkSrYs7lKWJ@aLOabBcVh}OD#_%`!7!Pm>u1ZAQ+!P&e@`}Y*
zm`jr$>^0t~K7o2mUa>~r^_(D6?3HR%K9<&H8XVh`v4SCa5dvPfqdAfYj-I_pkp*30
zx&CEA#+<rNe~46lDxIOT=?g9Qnl-Ez+?{%Yfa@E?LxUg+6nUBjnMnLH#xu*>ZoQ7r
zdCffBpRB`5Zr(na4!Etg@KQ0i@x!m#P}kwe#SPVwcoEBe5U}vhvhE6(WXv1pmKN-Y
zHJV<1)fz6?zUTrRguNli_B0D{OpgvgMawbHxI?QSPVczmSEFVDPN`)IJKz$*c2uZh
zdbDM6p=cC(4bLVDIipZ03e})OF6q&?k*q+%OAyw-DTUOjWzq`Ep_DbyZg31TYd10=
z22MF(MW?q<22v#J9pm=S1#09SzAG&0=uA-#)7`Ld|311n&|Q_fuOL(jTmAh7){^L^
zJBYp5L~K72H{zyPXcFr+^OPY7)1>L6yF4U$tWFb+iD1>Uy$B2I*UwAfB>g9x<YGAb
z=vE4t#1b%56)@Y)z?A<QOjBAITf3OSX{f;QFM-n-aEiu$9u~zI`)XO%v+#xEO_^|X
zy1rw+X}$5=V4Y`TffFU1KgjGgtVB)bOT33+RCgOk+(mb?!dk!t#Sl9b-Sk`hD!~&p
zoOuPI^7&99RGidctq5`ep3J<AOIe)PH-OHASLAaH-}R0)b@&-dun4RNW_FqPEHHSk
zS>m6VpL8&xE`|z6ZTn%u8GkP5jUTuoXvnz+yvuu7;BjU(7WRPk^Pc&XD`D!K_pD8&
zG+<3ZztiEhC^?=iG=eu`DZD-)M510D9dGyn`#jeGWWxvMQ|nY8m`lnGN33x_*w%_~
zAHwbsZ688*L6+PR7u8Ozt>Z60u&}V9r7FP?MIWu`T5E?4x|~&$g?Fr|qNwGKS{**J
zs;wn-wSbNc&|^Tj>G%#|`vsHh0JU#I0_NcS!GMSMF&M`RtwmRW0RhDE^A|?-mT(<E
z{*iTd+l-Y;9F9UjP(a}V$NRVi98x{}6YHn7>;Nbw&qk)^6x|3QE}3{h(*_VRC9JR&
z0G!a^N>dRG#4*aBdLwnNnM6f#i1AIxDHw<G5p)tSbxrCHKl5kiVs-UW9&YdXjIgl1
z^ktbF>C9VyW{!b#@zVq;3jWI)1RXLn%%Evbvh}SYh03RYW|b<pEh>t)d6N{=Boav_
z?3>LGe`d9-&Fltt$2ApSQftI#zQ!pN4FA`mS(Tu2JicIWvwki3Fux$crhZc$Px->M
z*m3^-0g(W^Rqyb00o||$IdlQbO0)Bbc|;hzrz27kA9Dn3NRdA<swjOP(lz2iT!?tG
zSYV&nzwWM>K;y{`lTHQo_W#^0k3pX$b|>&N?M8D;ER<&VMhMu&;rv@8_S1%S#4d-C
zjj2~YgmgT{nl3wX73_Nl)2{eJ+x8IrbfsbtKno%|8oJD~T{uKWv}G^d!Wpu6WkY=o
zQ5=Q{OhH#~AMOg}oCodl7G7w)DLPTN@Pu5y%AqV<ajXATfQRK5emckUxkHXEVvLn)
zUAn^Tvy|P_7J#%gNLzm;&9lf%`uqlfkUqGs&^i~Nnk@BR{1Fc{t;B~RW``nvkk6I;
z#guQl#-l@)^<4Y}fLib;j}-;1$Kem1T5E>hWxmife4fg4EoIm0F-RBIfZ>nr`;3`)
z3im5wtOFhs>Z(XF2+kvSA!9ao55%2b?aJ2YVVk>ugU`g@G21tH_mTWY>v*n84zNm_
zfTe2e;;pVcJ0-r16n=g<udt<it$3Jp1?OQp;$UXR31O5*|8R+j_6ANcl2hG5)`G3b
zDV9FMfFmq02T7I!i?}<*So~^TpXY25SUkU=<JGnTi&dkrv1cXMtf;rY=28dURBT-v
zxfD*z&kCGE8~2A3r6A9Q)Q<{MwJs1+ea9<EH7BGva_BN^ypWZ7WXe74ud6K|;AJJ>
zRfD{({<)8@m{o(OMwLvYLD`W0&ox=lf_8X!FJjVzmUP+A<M+b><6gcE@t3%+wua84
z8^$aaS9N|~;aL^=30QU6;QqeGD$>glK~zN_Q5nC$-hTL#Z_OQhCb*@oYYMJ_F2`k}
zW@l2MB1$*?RKT&m`ax-$mSdvngVl?gE?xeBQoiih<!66YKCP&4dZohKuPgNWszOou
zo=W-0UzZR4ALT=o^5ecLpQip2^xr-BY)O=}9&93ZagWazm)B&)7z5LqLm>I4gC1W|
zEK8}+-zgLmmMIO^?Be=Fu^uI(t5+&?`MSYgr7Dz^@2Ql3Y-*qw!O-IJ+|fq%2poO5
zgdLhcj3;)8MH1K{0KdQvGw-#u;B8SfZ48#0{~ye7z(SDb<kv0FuJ+%g)GOude_g&;
zarwB;9Y77fzRy;dfHx)R&NT{jgOCJt$Ke-oFaGe`ySjU%t;5Rn{{!8p0*bZU+pl@I
z>VKnqKq>$D>+-XU%WLomf<D5t8wv`~gfZ|Xh+Z;ramwS3&c!<#A|P=7Q2O^kUGscQ
zuSMnMFwgz%pBWJ)=w~@5nshxTtZ=Kmj@0p1<z;{A9{elX@^XaFCUVnaX%TmV1bod-
z=D^U{i9tRM@OF3n<P#RKRD?=e1+ztyC5in?<vQJip_I~8dHDj@qfUUW&;)|c|5c=y
zWHkh<i&v4pcK2c1h<h_TVkI;xx}|HdhU!f@h9%q`!`XU@H89|3!lNz97}Xm5TeMc@
zt8C@KHr3)w<B|)7R2r8MT9bW+%MmQPk)}L=K=@%1*Aq^#xJ@0rq`|%5>adfm2k#sB
z@0#uYqh=wN)I9F$d}sGhCgqrLoN%rOtIMbk!@oTHX;f|1A{)M-&d8doCWtk78WkS8
z&<3jZN#P^Skq2e-X<CDt!sc!Wj}M*h&OAn7M#Dg&1!{W4$Vz4OA$C=<$F*R}uuiU9
zFolYbwiLfW#aAxv;HGM<;~U#et)=R%<D<rOb>@kaTiUsI#6Xemo_Lht4uVCctQ`0%
zw>AX&Qvg8!P(kkRp$EI0fetMqIv7B~q6ZaiHhowpw~sNUiWZgRISz77DK7?L-VSmV
zhxsT)O+PrCCoWlYbd>8^ZNHA`b)@^qAgMCSJ?TEuTaxf$n>^A_x{Dr!CXcLK)+F(G
zj?-YDiny26ob%GVVbf@T1fIY~=|1T(p7mxnR@zx}h`KlnUj34(g7-Vb-2X`LxENM_
zcEl8);Ag1+){&2Q!W78DUQ}YuNiMN|h7WHXEwY+6fHmT(T>D_o-JP&7p}wd^8%8+j
zOWF{&3V-e-<Nkt>QT`y(j#J&+*K)@EETJb1tb=5-nbhhXqxxl(0<!5rg*-VG<?x!z
z^fqYcS>YqP#7iB2<Z%&~JQg081ym=ie*?VU8q4jhqXTQ+nDc*DXr@%?g9<}Lh00r|
z{ht+HK{%{+mP4iFX*T@$>&P0?BBWTl$YH@Br`jM){8cIDg^7s;V|*mdny3K7;{7xP
z-@y;k(?zb5wpG-4UHJH49r@4*HqAoN1CL0wMrACY!0#I4xm1@n`rXRJcxFhLO)dUc
z{e09fY>kU>S}Bzkrv9paCBww5{{=v9q~ktnxsJo~eT4Efz(K51D;?hv*e=XkACfhx
zDsNU(?x<>rFstm5E_{1U+1sw6sh_{(W4W@(aYubA9y2|s!hqVUDK`A~<ft0bl?K?S
zbr=vHI^};&^~?q|@J7S+JZkxvMw#k<ZnCFTzA^;T4;{UvtzNjDBPq()b*7iXCBsDF
zj-oIOv1~WFwUk#MGcD~KPiZ+moHXg4QW`!&HR(Q5Z+x`Xr29!x_!xx`2M;U?vi98-
zBtK9|$5(06-K;vG+kB;m>?&o}L_c+7)zXoAn3e=97;9ymQFY-y@#)Ue8mv!zJb>b#
zSk5BZi+A#noutl49_k_cN_ME07N1^2np49B=wyVBU+|FqJ<rfebn>xlXqtrlCxrSG
z`r$J6=DJ0LC%IKxifo!%NB0mpw!+{ss@LORlbmvF9W~7NJ6t8Afe#JGO%JDbqj#fl
z1uT>qTn<;=G2xc9j%p-TpKZ&pw2rD&e{radg?LUE^SA*uIUNbq#E#w6#FAzLxZ-{_
zi3fwrJ4c@EB?n1A`k3TPP$<radCBhX5u%na)hZT>H0QbR=?;EUNEps;EbR~~El)C&
zyOm_q+I7t?YH}9L;F8KXlHJE!4w1@&!r9)kuOnzG@QXlU0eNLol#evT+r$jzT@_|<
zF{qVtr+y-!JE1ZFDkrdAEeM`M?Q0`fpXty+1^0m9*hyzPc-w`WIQGL%aBP{*QT3#p
zI5-q5$(5>%t4Vofg$^%c47}!vm01arid0L~j`gWnr?doqj_EBVurJ1(Bye?AJq53d
zXav!BP$VUAiY2hY>gfl5aamVa=@>YJ>N%~4>xjl>&yQ4ZRV<7IUpZK+4w7np<tm<1
zn3CTC`4A69V^ufYo=<ja>{9u1E#zm7b}v~fcYw|*UMio!bhaE8<*&jVuuY2za2bK}
znkf_9iypgQQ0^n%L>U(4;f2XTh-BvwA~JxKbbzP$$*rV6zzyN&W1Jn2!(O4HE+{J2
zM61R{O_B0C=y<&jG2K1<Kj4g68DdjUL0A`*HLCYuq_6wSvUIvV4iSxy>aOzp!2PWT
zxJV~3oibUJpOv&719YHgl)LS8a6@4uqxx6)<?r^4a%(t{63W3Z2Vo9RTlxeWr2~$J
zNciCfootGw8VQsY+X(yVC{?6DpQ}=Q{nf$fH93%4D)D8u(1k(C#=vcUP*7OcVIe&7
z8&_43jz4`8<HhyA#5haq!9*oSL<YEs`h0UMHE;sb-ZVM=CPsNk$NX{HdSX<4dnU5`
zBU{)m0djSz5YpgY$9n2om#~P$L$(?^FYbbe?GiOd9;x!JAQOPe9%SM@&EnYwu6`aM
zgR284RKV;G43s;S@kAM<`%R7-pn}~xZE{pM$=>G!&pyA|M+$*|C+GZTf1h&15x}(X
zX2P^J<aG(uY`&^0CU{+69Y0f5u3zD=O;qN0NMmIjGopf}!;p+~{j=1(V>P*LrAElZ
zZIJjE>ifhLat8_MwNVqegl!+@sX~SQx4Sp6+epBUfsX`1kHvX9Yj9I_5G2$e!>hvT
z2<c#puCxh~dr1XVabocDd{=%vNcNC^-Sn2<4U+x*7GME@%@o7K4Fu{u=2Qvp0>kX*
zvs_dV3Rk8^)%QyirG`?eBKxaD?3)voV=BS{fivpdr)i95%nDx`d%VOr0-6I%0N?uU
z6D_SQ3$K~OhOdR@R(hI78WVuxU=UdE9%!n}%&7X#zpf{Q@-SJ8o8pQ0;K<m~*oi0B
zkP}=IMTtgKqIeK_P7OKS;imw!i#-T901Da-vk-I0el8Mel<uv|!;Kgw0oJ+$1lX8P
zQSGJARZJ4>cBd#W`!iLDb6{L}qBL*OX=HsBW|Kp(Tu*9;f|_8tTiKVD#Srm#<)dP%
zZ^I9Q{&_8-{TP#{$ls*N@=Z^(u@EF0_Xyijo1%QGxOvkc7eKs&IQLF81#xba^g@Wi
zMg69Rl>=1qaMUq=kFQl%eB)287!57ZifK0Fgvd>$)tC)$LgaAivK!6`gv#-fKT@35
zM0rUPK7Ksh-%W~(LyT=Gl<8SN@M5SOD_w-ht58dBAhktGd@b2a3d4setc6&dTub(i
zO<0XxudE5mRl!E}pER^tqZ`nSx{LH!;b27+Ez+s`J}8cd(;z~Nq`}=<atCON!4ep;
zVVI2Aybx>pUKS?f=t#&O6~6xpliN#O!PGI~vY!-zkAC5DHRL)`?woKrDR!5S4v)Nd
z!~e-<25t$-(huFmJdwtfBQ`2Hk9&g5rZ&wEzuI!Nw9*+$ptc<5Zv}9L!Rh-}iAq({
z_bnD5o-owA(pA$SLv6w!@TdhaxLsSWV~aNg@LlMLj`5pyCIs@hI&w8B82mcCj@;4q
zGHfQgUIv1X|58T|sQ6_$k-`9dS2R_4SVX(p(g+(1{%3^&HB_*+=0>y&4;}u$Y_<X@
zM;h&h0#X$L$%3aep5$UjYO@$@_Mnk%RGv6AK4_#j{Z0B3>0YxIikO9DP>_|k3Eqfh
z=B{nXl$0__KGI_k7zSmM+}+Q5pk^58QM7D;u-uEZMFGi4Qh$`{7?4~`3dcvv;HZGA
z<*B&4S#j(JyDNydTuSOH9eEZDqTOB2BAG<LNu?UqRU9D4nr?4kw}eP_4E_chsS7om
zyQ|!xhAu|AIyOTcb1BWkZnUf=?ZkSn$-DtoRbcmF^9DrF-_`R5RCjd~Y*;WBzR42a
zfB-)pLF>+hk590eJRXtg{oIu%mg(h(Qk()iH}+-JKuHJt$FfJ1GcWXvj`c%v8i`??
z5bX$=NwTrXG<bMbG2>LDj68f|J2%OIe%)y(yL-G|MCI=Unu{pK##!|x%H1k92mQFY
zc0f&)TF1LJl0(bsL!93~F&35w%EqWVK>6xBpxm%p$EMN@7YLw8xmLx_E~1l$^$UxI
zK>A-%)W2XV9B?IOsIzma?wOiA(zS{gGGM%P#nP+~t@c9kJQb|kkZ<0i=A^=y#vVZ^
z5s#~*#DD3g`)LfnINNaJ{wU9|*A)psWc(DP$|2)h6aus$tPaC)Wm9VHHhL`_J|WlM
zpbrj0K=HJFQBkUjFe;s*yj9NSxsywdGygjv#j6@1k)3RZgH<FtGUgMlw2*iuBPTS_
z^Aiz%-mjbl;s`dLkVuG!nGk>Y8i;#)C&hcsL5cq!(qflJ4=Ow$Fa^#8$5Mrhr&1pb
zi^@?kAHsK|(El_a788W8Ip^@M$sT2qAq*VTpd`FPqd)u=HN@qb!&i+$1@iRMUBen6
z0}X{GG$cC(q7{1^6B?LA>v&{>$TsM?BlWzlspmsp0<Ph7*EU|I!4~U6LA=C~liXDm
zOq1z&h0-`HoZb%Eg41me4v1CTqcw1Pt2s0pbt@^H&U4}*m<Pa!aj?qrvs;ZqCjEMh
zTW)OWF8Ltqo?)$rPhV00t>MSnRDT)7Y{_WidaEX~D=luta`Q*1A6jmD%?YD6-x^{>
zo$6Glct9NOql2Z5b~qlhs$+otWV@1vvlT&sEJaWt%X~bz;}0FZ)$c-xvgS^eLBLcr
zzt}=72wd#&+T<NLAfdquB_87+?dsLrLP5wli#kyN$zF`mqGqtmTiKfI^18N4!3-1>
z<n9v|jadJX&wpcVIvnn$QI%IX->r_y-bAwE=VnBO3&#hvq(Yf7(O%NxGT1VTi4OI-
zDj1?SR-QLfn~+8mTRaoOaJe9gyg-qVhh}4dJzJCgA1>_wnxG~wA4CaS^X`PCZW9~r
z=B**9m~pFSQnzM8ZkLP=zp#IRtLlYTq0Oi#T4iY3J<*DxsU@m-P?h4LxzGYj_^Nqt
zctHyo6aCxS^5B-RJbZ0%hN~sqTut9v^W`mN?*?ZLT8o0lVrvlL6^H{ev_C2K2@Rf^
z=9&oWLQPf|n-azLyrn!!vi(!b2WaHx(r|bSwrb?{(oxv=o#N$;vhyEkg~qrWFOQZy
z9%y;zR<LHKRfl42C4ZKtVRbRLwS2+B_MX<PtI&4|@;GVgT`m7BK~9zSz%uUJM!qWD
z4Ak++w(<k%O#ocT?U3S)kB{x-edYJu1O!El9!`|CQsbLi9-ah?Vm+KEqmtxv(iPZQ
zaqZ>JohJXGwa8Yy>1TGqnT~i`ILm*!QwjyKvy_P)dws+f6vC#AYK!8^r{ZE8%JP<0
z?0}^s0a`yO3Fku*{g~phe3nD_Vbk=B>)rDh6!-<Z;Wbp(w0vvzq+06X`3Qh|)Fx|^
zW8ogN(P|m(Athhc@+U2${hYGPm?97a@7I6?@X<uONgBYYuZi|67onnwPx2|TlbovB
z_zOSLNp353{iO`g-JKq+g1@49XF0k;2?Ggk&h9M#U^QTVyhUz<F7hNxRrm6IZ&%q@
zm0UjedRKY2Wt#ORu)=1nz(nkVJ|by{*#DSLe=;BE<6Hn@pKx~rjN|*3@YX%S9+RnP
zRi)^Zx&JPjOGS^A6#ckeK<!9>ilIWySfs%#LS+|GStWKGAryM+Uu!F&I8a^@QH9Nr
zhZ|b(28v<*dx{an55vR^dR6*pL2pqtdimCPi-Wij0<p<cl#CW8n0^%X69k~L31}FA
zRwkgCkFiYZh<mk?2r3p`)d7=_OO|Uj-TjwYqveVly`#X^WV#TieBLIy<x#3z3bAHG
zm=z?;Ax)c`16m^P6({U<r2y#_K&kYnm_FqM)hhu|w;lj=xxfsg>cxPJ--+IuF!E6V
zbt?sk0_X9{xlzkc6QF_Sfbwt%NTKJPQh>IBoY)83M}LYjB5uGzC;)2M6M$YD%rJ^C
z2IN}`P_zPQXemInkBG(X7cJjJfTo%Qx{h1Z6^wRFHt*WGEdrxw^rsjj1yC;l^5`Yk
zXzFebXhbofCZz!NQ2-4t1&EjtG54Rfd|EHLnd>jlwRGoYYOu+GI{G^dsB%1IUwl2Q
zNyy`IE46A~tG66lWzHxp$mp#V9FQ_pyiJUB#~>rIWGd#S_m+RPZ0)vD^x(=&`U9z(
zk4XCB*=6%lYf)I8Se1DG$p%sMx%g93RKfDr2Q6RPSB~;H_>{1GQ~b^c#0&yGHa^wz
zlmSg#y)mD{OaQI-)l?>wBY+1zgxk`;pX@cD&$r4{=}NjlADzCgXbx?dsAR;53_Q6>
z0k3<3E~Zhk0F@DNSp1Bz05s7ZI#xkN3^l}6x};Vt0H3ew2M>Uk)|?>Oxp(`?4=mGC
zr;Bd(!yn<!6{kTIc_TFD+_#WU@f0kDzG#a2aw({!FR}NUp{jC~D$QjZvRl^R8h-jK
z%StaO1{~d6x~8amM{s>AWCw3DP_Ak9_g#=<)Iiyzc15K;9ZaJ^_<oweE(d?iv7@Lr
zf!)40TE2gvT)o{`K=>CDN3rB3B$g^|6#=cP0FC$xC}foav?+kr9VFMNsJ9+bttcK*
zAK^ksrVNrRSLi;>oRWOiAh}T0raadVmM6Bx4NmB&y|?&7Y(oOENPf3{WzJy_r--6&
z#h;R*LOH6dywdWHL$I3mc&z1<hRBtGO=w^V)tB7@Hrt2DUd=C!6_hNT0s6lAzKFg)
zN~-cGI)-jMu}?a10sCAGAUGMOFsO*J1ggSN+1+X^D)Aaa<+>H?J<_7c9mBN2=&I0q
zxhX^C>y~N1qXqOY^;?8siWx-bh2r*7kP2>A`3KCRqM<fTqV-DY?depBx~P;^1oU0Z
z;)34=O3EF=Mcn0Exul=7{vh7oAFxW4>&Q<HmmPhMk5;&9o=A*-xU8txw#eYGhsz;t
z8<wtznJ~jZGfaVGNLC;evBbF*qF2|&pAtNk$zJw3X7dO+%t0UW;RJ+`lgZrUy+_Fj
zs{2}gapgicn(9H+fd(M(RzIZ!v0&kj*FoK|k+RyV%QrwSexzKzlH9*oU?m#1T~q|t
zKqM;mMfOO!zty>kFd5#Cl-F3MJzXNOdr5yFcPXGbZZEMbLdsx_7K{)SC#@ZER4LjQ
zl}m~$<X%Wc<HS5HBDYZVmwgmuX}&eNVn%J~`b`gkTVN5<Ch8QjTM8i2%Xtymk7?1f
z=oGn@)w9bqNm68wU}vSUNh>~EEV@v!A4TpKbpbXHx^T2m%Xg>9HR30tZqWddp>ghk
z*?_G=6Ob1sa1#}9Q|V7JIA!9r1Gu13a<HvFq{UH;mOZR6zGDQo>HfN<3{^OW%8!OB
z2t)PBOX)pXBtQHP1Tr5h2Fa!SG%Sw|TSgK~jgo8lpX*gTY8r#zX=T**BC*K)&yD>?
z{zWDA+pFdFV`Mk!)M+iRHb&02(}(n*Q4fo*kgd7e++$;4{WV^5oK_LAb`f-jm<t?s
z$QCKMT}{j#N|_{50?blIAcd^TT)**hGfOL*UC@J?ylp<JpS65Cljou(RfcG(^-tQ|
z09meXS*QLHn#v=n6~vB<X=qeeMq)xHINdza9*GJErcaPxN$+yBeB4CDGj=_y<$R)m
z{vusKk3?48Z{_WwYYq~eU^5i6MM|k|AjPy$xLY%+lGU0K;A~ZJlFCxLa9GRBh9voR
z(_5!jPzC~#uo3r85GV9NFee3>lN@SsSs{0&KKaJN{g8CcW)v~s@ZLz;grr`SM5jm#
zGVl));zAMev?EQf-FwJb0;qnNMiE8``ZcQKu7E0F1gKRp3r^dY%z{y-=F#%~g7%7H
zegXw4TzXh#bQS*Ro&`VmqF3u^Mc^2k)Kr>$NSoU^G)cB>WrZHM$(&?^HA&_ls1T+&
ztbvj}l+Hmi;tbb%5JMjmry2^cAuCU)CH1v$hg%%<7c(RJoR+uxP7bbdX|zDU9kNX5
zZ^fcPEQywZ1vHtL3Pu7=@)V|oC3#6dZr1YIVM*Pj%lojP3rpH21>$3Ac+z001DNy3
zjit_ryus)rPzJyKYbUvu^VwT8_$e9k0N;(jX)RKNjOrZF$?VLE(7MfTYx&Czc`PD2
zk4&h?wNvF7kC;5*k%drVjf6`R5RNQvcHXo>%TG*|7vMy#W|Wrqo+ejy(h15>q$dGk
zDzSB1zGxbjvVHU3^4rtoYW``vA*b+W9J(5PYch!qypUZ?lfI|4yy|p0!ufBlpvf>~
zX)+(-E{5}3uAMH2wK#B4VIB=ek65R|IfZo|b;+lLRRw;^fL5#8(&8W;Cd1Xr<moQ<
zll3g{MoIo~x*Y7@P-&#+I8!4o=RqXfLO-6paH|Wq3v6N&y!a{&fG|EmuFaUB)aX17
z`4c80ufzr=uks8zQ(AUH%a_-~Fnx=U{CY|4r2ad#d_<<4nLKE}f;*-uPEiq{-M=W<
z>pKbT3)i77+H&th9;tU*mCVB}gk++mKTS#7kW|t%aYo`yxs_GhKA3yo&y=TFHrHEk
zvQ&7UEK=8erR7**!cof;PAR}UbWo&zWmsJplF<{2Cf?HaAk&~(a;VkGJV^b;v*e(J
zW%w$dxezXQ41byY8b?uD2yn%++f5n@*D8oVJzyCq>s(rKp%!jS{Z-5D^m1@Qm489}
z#ssldX^7DZ#E!{inUp|O!e;^TB^V@wAa2?FHI5(XY9`?NTT&?;e@0h<<5}^i1fmjx
z35XK_@snPzo>1>!5T}|T_ACuCQGwX^D~QFtE(3_8X3Lcj79VM(1Fp1w&__JTRWOE%
z##*^RuUy*E(AUJlg?1R1N(|#7PKpZw)g!J~T<?OaiI9y}g(@WqBP-IdZoOg>e~$Z#
zJ#aZm=eSOB9Vvji&k0^(j@;C0Lo%49(;WGbrEPW>qN=^iczEZ1=gMmD*fW@=$A~2q
ztrF2&De-6=N+hC0HwP*)PcV(R$WAC9>!eRgw@Az%+@*9&Q!M7I98(73V;hC%lmms)
zUSo@Rt_d>u!MSo+m651i$Vr3?9R@O4pZTc3h6xri8rj@wo?O4K^S@f@cT{Pmk<tno
zfiwl`bQXO)kH$m~qzBO73+Bn82}^$Z8d1X$1;pWmVvZpYd7T7^dH_K@=qR>};`Wjq
zDY$wlAXb=<8RH9xJa)e9>e-?+gct?FnK3{jWxlMIo<ZQvm@n5%*tqj+B;FoYkodKA
zDI`vH6i74#2y-NG2bO}wctAAHmp#)id6+ZM-q9rt)TdY)794B^7P2WUQ;Llmu2$G+
zZWK0->39I%_ts>MgTg#%3|vr9TIwPG*<p_Z#Q0A{mMoWFz^&Kt>8|NtcaFvqZvdc@
z<M*U~NO41*<}8raX(xw~&=nE!brqs)1BMBBYqp52WY-EM*yAyz?v&&1kirpu{-#61
z0_^4$z(t9#Cu2(=;Sb`#wK!7%Hw&(}TxRB4q@x7<_lq4@NI&Ii`9H65d}jJ@9cxPY
z7{1-Vb&Rf58`_RmmftlZF+bvT=??SsUYla2;Eh^-Y>^x(X?JV6C6_gl^A0Uf;BpJs
z?i)y1PO#BPkq9Rghlx%u)bfp7ZUzf3bda#I#v$b$mzPMxcWHUe>?VHv{Ypf79a^j9
zrxwd0!5w=NKd8qKQj7vWTrPe9%S$y~bUVa!3I+}l1e>D9k?bb8Eu}s-?r&x{>Ew`%
zFQdBoi6WK1YKeTVeA*9$Rmi(}F#DFuXQfT3*J2sm!oJ$K{O~flk~9f+#l2<dz|U*`
z)q&b`wLE&c+(?=V+fZIEhlgKZi9-75&%=oi)iwJ=hd0EC8PzF*da2}2NKoEA*5EYN
zN-aOEZ{lh7rVg--T_yW?T*en}*FS1bUB%uCTOsdvvRI8l(1%p-Bgpm59BuCB6|%3T
zba<EvU0+xq0^LD`Nojgt(nATa1iDqX33My-k1J&dcX>Gt>{qA_Ty8=wC(MMJ^BjD^
zcsT^rin%srl^iAQov-CPR>|QNy&?Vz+b8IMa)c>^Yt)eb0_iT-e?fW!FpoGHd(^1D
zFbfXm)pAv713vn!mesZ;dK)pntL1#vi(x!!ja*v_g;E@~My?~BnyKX**2r^IZ-(*)
zYmpF6*3ViwOgf*b<*V0XLuQnBKL2~I>|eeOF15mLq+`Jw1QsSc)7Fk5SX^{9+Ofcy
zhr6e_mBsyNhO(&8^#?gXy6ctC(|(Y@v)Y1D=0C2(N+uRbzUu(Y+e-mfI7MWX|LAD~
zzMdz|>fl_KfdAo{&!?`Fear7H%Df{oxu1JlS!n@s&j6H^f{$nTNJ}Uxb{ltt!crj>
z1YxS4*bj`8`5=#cbV7R8#5@xpe{90Xl;e&RH5FT2KH=-~A5WReZ!T3H!pe^V!>Veg
z{+8;m;qB%&sq(eg{_uKvV2$;C1?OJq3eK$}IJeD4f=I{ppfmi)gvJT$2AHVrHoy;g
zwyl_v&$}oy5?SlEm*!myzG?%QBxtdg-`OC$hyD(83_bmV8m1N|kZ90H-&Qg{Q--n_
z=m%yF+$e|oylEp^`KF|mU$@abP6vh-{BE1%;nESmeBQQg@&(nP?A)A9a&1ei&{(MQ
zGT(OFYUw$LghU+l=7p&84pXKJ6@JIyvhlMq_w1x@Lo8LZwY*+>w;|GPr+mITy<51|
zF9A@xSJJyxw>p5K!sY4RIyLAREinJq0|-()wNc$@mB2hw$(UG@;g5`xS<)vld5Cn}
z15A*ZyrbwU3XwR#y;Ndu`rIaxrF0Pty=SM~(7$_A(eFtK#ni2{)||T8JhpT4VCheF
zKL4wGa-eF(XYQ1o9HCnNncH+p4sw2SlqzD;LrbW#M)iKK<xRUJ`zP#mQ6LKDU8Xka
z(yN%ChI2vr#)2xeU?3ae1Z)ku*k!t?Py*>B#;kCOBAL>6$z!AqF8R6dcFA6rsseki
z-Xjn6`^#szh2d5p+3?2;$K!_h$)K6#7(8l7TM@5p`O-adM7f1jY6eR2YkTA*)##19
zX0H4}s)U4~y_o+^Fd{wof`KljLVE3$>s2_qh~(Ad!fNC=S-kM#aA*E<uk38KrwZzn
z&y!=TS58$_Rjc)g9;L^`_bYep!eg5b9P)GU4`M|}Yx(FrxxRE1AKUWexZw2*#pJ;v
z&2X$T(ZsY=#Y$V<-P4R>mn-IT&wRP6e-8(e1#mPJ>=%dQ)HOAxVx%f(qgda3xusMW
zE53_H*;%@>0D383R=XTrAeu5%a8(>E2rzc!|1{p{oYnyEPeUsehKLo`eu1%JsSbh5
zHQ_iSeWk3t91YC}B9US<ixQP?8a`iFY@~H+64-N)TOwV>h$#^(bYRdhcdL~}=8+uB
zjMHO0@up5tJfFBvcJiCk)5^3@-3#)Dh-M0N5tWj*@@@O%Y90nKW05K_gXyGX+vQ9s
z$>x2I$Y9hIE&t_+T-AGdmX?k*X3*Ui!eCUC18x|CCbl~&NBcJwB~n{yrhK*@4P7}J
z#!|@(j`r)deArQ(_;3Tn#YZ7pFF`$|-CU@aYW@Vz&CP|C`J1D1l`fZr8KoZ340F~G
zy+8=|T#yilSSeNswCq7LEqYNrO>O&IF?2%9`tPPRh#dpm57rb_T8t@8LO7#Rj>+>a
z?ak>5IrJ(XXVRLK9P;W?hm5y~SQ`QtF-B>F{_x2x-no}Uhq%s0_3ljI^Iyjlu@7z*
zSTYDUr^%*Fu1LmiL?pqRdRpVq{DnrJBnjIu_M2jo^E*?M$4P^1@_Dyu$zcx8ndL3w
zzO)D<z8nWRv3Oc?qHD)g-1AJL%rpjYz`ci&@MT(ZsB{V+wWcR~c-Mvg(_}Ws9>=%v
zyFxG^wiLlafy+lx7|rzLP{(1h3e!6f@D*kA`I_m;RfB@{3X4yyQ0znWGw9kWyg3+&
zcnSfgs!4{eE0fPRcTNtFDrJA>lY1oBl^)Oe%=h+4j!g5|N#ILlPxToD_^5CrZL~~1
zQ|N~InQE=zAS7C~a^@1Pz#S6J*Ic5hP@$=)Py)5-VobV?X7>|lCO<g^(!}%jr{x|}
zsC7R7@wD8z>}4xJOO*Ji-(+<;9J9x%_|e0)Jopz`r*is>ulPm&PSsP-{m;mqRAuyh
z{26(;)EDOPqcd`K^*I$*7NMG=dtt^K)gM=AdB9l&Obng@m-|^cOck}5uQ@AEb$t#0
z)>nhGbUF;qbF#0)Di`YDNs?3x@yUmuliSo@&>ySM97PT_Xk;P>4M{RkF3d!qE1Rb_
zw}RF<CwqEpEQ-q-4PGcKAb&C3bp~X=^Rio-db=_LFj0ga`T0B0>XdRS0&8J+XbDFN
z@SkogU2X-HTUELo(f()SFfpP<@cx_!%*W6OiGvnJAgSn56m3MKUsN`q%C`DfSyEEE
zufWcMFnNAnc6V;}RmK2hc>O8|+J0gXp|}d+ci1!jY^kT0ZmPnxhsu<87Qo}VXl8P%
zwDC(GznYaCq=Fz{Ju^ANchD?24RNo4HXBaEuWnON!RGNFFxlI|s~;((ItiKmF^fh!
z@*jU}?Hr;WQeUAv(lAC}XqJc(&2}<r;1cnY&F@~2r%Mr^^Z2lfav!UsRUt&qUzCqY
zP3LKI7yKrdwY0Lli(3v?UXrKU86LHO^^t1*9DjM(@A6-&+S9rBW$bpX@<P1^mt`MS
z*xTGLm*p{*Zix`Ah0gk>!Zgaj!^4El@Ts{EuE?z{rDw~vxnbAjL`%v0bsnE`U5=2B
zcYDS||Bx&5Th|c_lBE1PuIhe^zxo4P4n1Gy@g_Iq2vw&)IJ+U&P;I)&*WHkZsP0VX
z4mafqs(HQmtebLO>E=Iq{Mb!-O&NX2m}H2O;kV>CDQFzl61Sl43&v{s-?wlgBOf0=
zx8)O3-m^UJcvEguHKE~%fUq%j>CQ?lDsY$ySG$`}6bP0{W3;^69ob8@cpx8pNA_1m
zT;WUZ$d#od9iH)ncjQqqJ>4Nau^~u)P<lpi75?HiWb}Rj`Jb$P((o277!i(@XsvLk
zqy~i1GnY07l{Myt_O9%%YH^v*xQlq}W9^^u{deWyiX+|=W2^ssHw-t#7}i^$;D@_%
zvQ<Ad=-%y~?CtsX+Y-1M;bQ?@!#xQl=iI}o1#cK5`|csk?)^7fe*2!>LpARbkGhXt
z(S}d*_@Mi8Gxg@TqLC{2bBMOY4EMl0{Lp=DTfBqE`Oba$|Izgwa8c&Y-|Rk%VnI+?
zItYq1djYYaU<F0&{p=lgv0)>Rf?`8l#Tt8WXE{CfTorr4a(b4t-gzf_mR+%c1-tux
zC(nZD|M%X<Tk@n#lF4LdGMOZmq$>y%|1T+|`0$*A7W3>6e9c4n`?t<H$UFU))I)ml
z^dSHBKj7m$0*()pv^<Bt<|$v1ez8wcYB;%jKvL3OQ0Nuf8I$&zsG}OPje3YCX%JZP
zFv&Zp*&F1SgnNi~LPa9$eg0fv^PMRgu%LyRdqLLobq|wVi`!D})9;ivJp#RWJi<zQ
zp!uM&!K0)SDvjG`^e6f;)@3zJ2l<G{ShBu;a**$Mj2`}pz(oq|Mc^3%#TMeqGxHvP
z`7xZ@#~`xG6GZOKL*!^){YjEXv4s@wAi~-)6t0B}0T0k7HAKFuEJkMalO$Kolix90
z4nBb{aq{s&{?8NOV-*5wQ&L#*fsauv^$oxB7+7qE*q){&Z>>MYHpN@F2Z(Y2tXdfW
zGnkTs8XCua8|G;{NQ*BdpOxsHIR_`v1a5^vrwDF;d32EHnUX40PkV%HTPd4C`_Drf
z@rccKFjtYd7IcUM_roFW@#2N{#>05t#EfCrLlVWCfw&e3%s1o6i6;Vw%}I6YKa5wD
z;yTX`ScGl#hbeQ~n(mBr>=_8<8daGR>++DNNtM;E9eLNMNo}QS@$jE{npD4P-Y^AV
zRL=JW)`cmCvS7qpv`$H+kzl(hCuxM#>%W71Y7PYBjT8J%4(vpBasqdKmh?pZ;>42Y
zN$tFUY7X{`w*u`zE9mh`e>VgYg;BliPOg8B4!Jgm#`ip_mij>!zxX_<t5;exYKKyW
z1VtnfA6@ij8j-~tzewsSm1~y3SG`CYRqKy?M2e?{=3ss-st9e8BWBa~r<hGtt7+IP
zL9cWirqOmD`7)_iwfap-Dy;NBjtn#bdf>`vv9Pe#M$J8R9EB}fho%X9?aQP9pDwL&
zF-D|@x)Hhnz%fjp%z`Z(1`YCuFO%x3=O5wTxuEVd;CelBlP0R&kMbM2NxQuRqrSt#
zjzT=VG~L}wc<|=O@{&qP4<Zxzr99X`?%h4O<Q16e1Vq$*g>wh(BNK2hz4?;pq-{bm
z5T^cBl27&fIwDLwWPv6}(rdjDRn`-E?o%F%JSjSVI;Rs@U}Y+F2!*OHDpCj~9;_=;
zVuDgaxvV+bG;s^JeVr7fZo7q7f1OmPT1;bQbP7;+e#HM5bv}(jv#*nC`Is9e;M7wu
zyBNbHNd0~OZeT#xMcW^ZVBdP36jGsV%m2gl_xGi$a9TOv^yhP+xaylEPt7t7IuZLO
z$=BOvxH2W9m2O{HtIWzs)013ePJ5G7KKc44i=|E4XLACn7Y6MnCq+ODy>=+Ba0Bg#
z&Cvs5Kg3{fkz#Dj!znY}ic>I^gGeZu?_m1c(yj%PA`6ltDd`VN`t$*sM}6yBF51)s
zHJf?h+a&KY;S{86esG><L;~;d7N^lFM?gro<yS08&dK%qC@M-?HYRe2b(KgIXgXUB
zFdGz&`Hf<N;V(Rb%A7*aac5_uTj3N-6t5T4Bs0z4h_=F%RSRHoNCXAGsUJnJ?cyH!
zNrR+bw=t6uP@mb)&H3<v&BsD4_+8Ryb$cUU^)4w*z2pQBdJhv{@A?V6{re=X+GRZ-
z`W{D5T@kVLJx$<De(`<M=+X)GXxv_!mJI)b3#UKB_SU){oP9qe1*jK9@i`wLXzeoj
z<_}3#)K8D`>xh^3geUMXAClrLj=fH!az@PPoG?ta*n48Cb;ch^U>C>+KKo-*6Lt0;
z{>MkS1-s}Ic!^I*x74Ng@&}(lsC$m^(x1WWCx=<v8Maz!XI(^0_?%QxeSZ~S^*JfB
z<mFJMom~g>C!ZlEHijnfQeTq7e1{_;h8`P=QS{V(;%??cTg4d0Ay>aI(3HN^N#J|F
zBn7opU&Z(@M51tLf!G-EF&ZbzNuTj0*M3hT67PurL*FO6h=IpOv+3S{=$GGDNG*4i
z<qf|k`Fc3^Q|Q|lGqm3lg}B{JA0eaoxUZP`HU1WusfRyN;>It9-Q_(H%QJH@UL`7M
z(7X=?K-2nu1KOn!=okX}<!h3Aoxv-J*?%&>QI;KDODHp@IF0AWYYODsNIO7#o#<*Q
zg51iI<n1#SH#(V%S?7*h!31%mzW2C%kWaT@gZx1)ur~`9Ai13snvc9$gy!k8PSXo#
zP<U-C&5M}36ys;nY6c0KCt9a?8->>2Q=ypU3a#heAX@)>U{PAnu-am6bvScGmvmjt
zj$S-~O|MudMCqH@kt{8cM|aSD0kaav96Lc#Eu~@}m4|pq=xW3P=zL%z!?5~4iZ>iF
zox^$*tw=bvv{SLtD#`a$p0SUbHB?D8F*#OCY*5F8-LT9N*QH{^03I9g-=RC(_WYFa
z-JNY%vA0C?$+mk2^B|{~vIfC@kI1OJcV{Q+_8SPlcnzyA&FqfNH4W?I^1Ll9Dr5z*
z9`M2)bbqzQw9>Hhk{iTGd0XZ$EsMp5h%Fm0z3YYz0bABPxi|Wo0~SZ#H3scg&2XEX
z;t0${fGm5yuptVIm_=K<4XG!jOMn<!{v?6MtsnL2qar?X>fwi6UR}g77f=m+*74S5
z9O|G)>jflQ6e@S8K-X!Cm7qnt0F4lrhDAB-Zeuf6tf0nSJ^)gDNw<!@?uzm`7H!Ag
z2|#-r{C?wQq>T8E>sYr=2}fE1JW+1eOuJ*!zQ?fP3XW)TB@Db_9h7uIxk&GvFWK-a
zo*g~;=5ZavB%7lL`Mq%+{T%Ne0hy<dam-m|^%|^U$NpB?Dz?!p8F6@_uTq0!f&5KI
z+;S-)SmN{N$Mxu3FBqdHj-=Qms~zwzI39-oov1M!L{h}4hK+%4bSxI>b2pYigN5r(
z4h|wH7s#m{Qa54@VP<L!$D)+&t-YmNkQ!^Zx7Om0uis8pLy=fo(b%u_#r|tl!zNzR
zFiSi?vEt`y!**kYax~M=k1a3UvC1X@YTCWDEK}oVYQRTTisuhD86#wD{NM(*al&vn
zy(uPc&IOuwbUgM-6`&5XBj^J4pj>z0n=U^=+b2Me`0H<2E$msNa{Z_Ssi!BvH3$&B
zOCH1Q-qG5pZW`(Z0&sXfBRai7w7AyJeql*Me=PPLAV7UR(Z^`)gJKtgoW~6IRlmmb
z-Cdhhi%g6ah0P&o5nY{Dfmn*cR)3Uuve;<V4ukzpz;~EVuYj2?U`XGr^N~ERPr2uq
zM7Ufs)-ce&8;-6eWCj|4<#F9r>X6U8^s>0B(x3e`yy3FAOsR9A#6K>JI~=nlfI5BK
zJVaC&kq&JM^Pt_wc$=eiy*xMrw8k6=*oZ{L;W#PeHXLc-m>{?n=-AW|AadM!*(XD_
z?lu(#@=d;H2!|!X@T@e;RhRTmyl<y4N2fWMvV!qgAEor~n!r;#g;fmeO$zE+3341A
z#U|_7rnCizN+W(Kaf4(CT^2bE>D;GFn1@sb8taEnVMl*zj#+2D3KDGPUT160WdKCV
zF8-y%k4#+k_^~{^y;NVKzGk(Ul~@()kwkwxx?4#N5Xw!6MVq;(a{_nj5>~0(MX0qf
zg1DJaVFZfi=vfn}s(@jwC05Sj^2)B&5vM$NC78nam_l}P&(x!<L_=!2cJcrnhfi^4
zu^P88kS$l7SzBqRPXe!?WpgAS1b)@B7|8?6pf6gMFWvD<;Q21>m2}rXf#<j~AI&_H
zp!RMoRI{IiQwukySAST?e{*AhYJ4eXjytQVY5g9d6Ygxc)Zm|dp6I~>d^@xRFQ%2>
zG5WC%$s=GuAlOynQ=~K>e%pgJ(yV`n(jK0yPRxaTJgYcBGbLJe&XOISzV{q-Tk~7&
z_c`oOC6{90peHha%TloQhFd%Df|iyz4#%*rZ4V>2C#$MC4RHJ%0BdR>w8V?`(%gHC
zsD56oy=Fay_It6$np6sX@Itl*6sqaXswPj)C913ug!URDMv0G8pcbW?b@o(^6B5lY
zVFai3m9Uf;B3wnz4}nOzffObCXpwyyikpvrpWXD5YKf<m%}7xOo$!^63DOv`^ARhy
zniNP;0@4ZsKVGB=ITKM!fSE?oeZMc@C<>IM3R)B?pb`aMV>HawMYMGX(~8Dzr7KVe
z>kvRkq$>`cN?k)<P?OyQ;e_tPTn3FSO*xknq?;k%=d3DnCR0-84@nEkP^r@aNLnkB
zl+yx5>zOICtfMTG_!J-J<nJc>GL>R_{{SykWG)_;z-yFe9?2o%^C9@R+4uhg{+0md
zN5H-WQ@j6f3-*aDs|m_qA`84)4H1t;tf>-WPk)QOB4S5V-d}=;evgNL1d5DQVqrlE
zML~!-DUupeu?asU%@aves8p{Xk`hHyu{Jnf=ga0*yxSanvady(*c`-~b|xdna+xk`
z+B^$PjJUwXoB8}dUlv@+R0kQ-SNdmwz|3QUhy!{nWyqd!1#``GsS~g1$M&iZMDoXe
ztb=-Bq_KVl)>tKVbWGrKMdl^NdL<ZFRAePpQlJAoRQwqpnXKxig^BW^KU*Z-eG<=E
zB^Ice@H*PYxVaMZQ%hf<FI@;^3!E~rmMN-s1w|$B5kXM9zBU@p*99@JpkqRc<05xV
z0<2f!=QhP3JR^p#&{>vjL_^Ihk-#4Xu^N8&s(@pr<BezPY5HM*TIf)ACEE$;a$&*j
zjE23ythNNRihi~JgO-o=y#i0kNNZ^NwrB^!c+xb4ZI_Bcoy!YhtIHRA4rYV=1d!~Y
z)GQc*QHky6X8`(3WfoBL@F(nYZXop0ffLGlh`0ezFRliwSsIN*qayLB4ZLYC6i+bP
zR$<Lm($r!JyiHY>B3Wz`_?4=xyR-p;D%IE_r((5%C>!5GzPY-7g7HH&)>`F0OCm*M
zJtV@hXf#@E`eCabOTu0?pqjRmu+dk8>7;`z;`xgjY?xFDoV-U(RzWq8PpZk<NtYX<
zvYKp}lwJ`=`fXvJk{*HCwODXi*k@emc2>Dc5K=Y-Y9x-#Dpv`jHx{iM@ST;q3H1U4
znceW$^jmdquEoNo^was=zcve$ey)(f<7%@;(oh5(ozgv}RtU72+}pR9p;Faipp!pq
zv&|Co13lGYzf04<>UpbBwj-!mH3|1qf5ujw&cB_*bb7xR@7`Dbo?<4}PT)Ra%-^|3
zO<HeQM=&kRqAgn-Dts6VklKCG^W-pg-F2N0k^5dpSec@Z!s11v_WVXXkFSen4uI@i
zRF~b7`hC*#gm4zB{&}2nQ#ixRYh^y_`H6b$lob6zZ=6}5xvHgV@AQ0KLl!Aj_9<<A
z*pQi2QjHBI_~k~-)iulK9aO5lWW}Hctt|zt^!I$nzcgZNq{xy9d`)9^&%NVQP!f`f
zOb(J)=21GeVH%%k<dN*M+AU0tiCz*gj?s!ltUN4QKQ*{)Q|6W&{g_JIzk3u9QnKCs
znAWO`1T5<&tbM*7SJC3YL($?_RDijWB5A~q+V~PiKe;1v9wKvw5WB^)NHhydnQ84_
zHB>Sv*%e3;5oxsIF5il4o3XO~f0TvFfwgO4A(}O&+z)D87zcZ?Mf(<G+Nv3=EsZY=
zWxE-xB1I#xs~Phs({Vp?F)^e=k?U47=2Pb#wZvS4N;dQ((R#+b1jCfm5+PdX@?X&$
zNF>ofQP-mY9^9NohHqG%50qPRz26R+CMJJ4{25K|_%Q1M1&1qrX{Kz&uN7V|AHJ?R
zYb;&-75uO{tDOAU0S%al0l_UBN;U$zoA_YUwk2%LXGMGMl%&Fz2tHX6=`m^lrexkh
zZkxo?F@~d9AlaC<S0c^p_28(pGj8LX)(KbvJbJ3ONy!|AkyVWipe6T6K!z>61#_3;
zz(s#<0i?MhaIXc^I=F=@9U>-T$~?%WmaM9Dx=aGE-ICR=Ker6c!Kp+gDVZtsM_IZ%
z!l%^a?kOQr#Ac=9o;w>gVMYLo3*>8CGWSNOf<z0WvSw_cMwo3;&Z5<0u2{4~@N31l
z=;f_Aur^qF8yBN87Sk46{;nm9^mtpETBvLbWhr$WpvJB$$J<A<*jkt0VYIivyl2ra
z@+QD@#qTWfJ5~J3_yrHK!|<EhZE@t6qnW4l;HjQJk7jGsBdhSaG0daobu0n0QrA;M
zk$ElEkte#i7Ex+iIZrjvf<Wg*NKpY8Y_^$eF^vvoBL|F~c!<EPH@=KvB~&hp-so-8
z&NRfO9Bn`$SPf&3T?PN!)+|;UZPN2ztyxq+HIv?^O?qGqC?N&)kv*yP=TBgarxnHs
z<-c;J1b(_T3oLp6i5?m73eQdcwl(zVxli;wDwc(~^g{x80;#VBlip+>&ZoqplQo{`
zjca0=y{fYBW6Bj#`L3AU9(Tp$u6<mY+$2Y=lRGy@&u_J1bz0PPqw%>5Ay1>RxAA*R
zP8~d{R3!GLX=gdG(X8Sac=)23s^26M#6vV<m}pgX<OXja$6S&Z<F!bTDIRME*3_aK
z9j?>g|8fHHY^5s=+ppqxJAP4R4xD+#RHT-fvd$ApZ={h)gtvKS4Wj=0t~6XC5>aAo
z<JLJMpAZ=$-%^w?l{l}ihKwRMC3ABj5Ft@kIS~*MY1YB)27J3F7@ga)0F|^J966#L
z^HG&trXe2n&a|uyAJm>LcKHaoNZ%jr!2lkB0Py~SGXziv=BYkmXRO)*_9OM{e~iOB
zGFz2;&j;h^PAo~K_6^`KIx}B&LN<5o!h%X3w$O-LO!79~qzfCYcHRcR3pT~+L`le@
zaCFuxaJ!dF;ElSnwk3yrRSE?D%z0N9EZu#s=cl@|S`L;k7~F!%cW5iubYlj;0YxKy
zwqlm_enCB4Xiw-i*uw_ejrrqcG(Au-On8YKGAE!nrrN6r-|-X$Jf>%kq{!88mUKt|
zRI9jmcjlpe`$mmoI?7{yBjCO+4F}`ytZ}<xpA||SMl(5mFO|kA<=FHp{`5X>4YI1f
zGp&4GOz{IMa5}<+J195!Y^tc2rl2EL+v$y(k7&=j@!CDWx8_2C4(q|fTsnVJ>ga5X
zA&9^l7WZeAf`4=mHc#3OncA`^t1o?O@WME)CsS*rgnT_u>%)#aZGf0Mw)-1y8$iAL
zsV`gQ{Q7sA3X05(CK=!3uHI<h53*Y7@j%a;4`9LNj{XHCj>JKC+>HbgO7^Raovl4I
zO?HubwzKu*%D40MHc|PfRf(|lp9W%&`F^YFCtHv<tb^kqTy0dtdDmZBdzYW}LndEq
zrdVV;Jt&?p{H1kd@||owgp(p|2_T-wMGWmXM#TM0E2Q1{#7C6)Xlh3jH!CI`FXG^E
zc>9?2&M+0A%};YN(oKEUg#NJ6%2pxnuz|(Q&6K|w@-F~~Xn`LTrro=CrW36`;lQb-
zn)ZW@5)1bHM_7qMAg@LdKfH^?Z$>?s0FLjCi*>4j!7PgCb5It`?~C)2?qAaLM*HF-
zoK9c}k41jNPj}>)yDzRoyVCc*b(hj{!Rx=GyNbJ=ooV<LG}g(YO~nMVT5#-4#V&*U
z!16VDBsFR%k_v2h#_YkE#ZE6ieBYuOV8>;LG7o9p?|NQsC|jA_-;XqQVb(Lg%N0%s
zFmOezKinMH)pio8u!(MX{jGgOO7LX6ThKmW=<r3f&IL~>()^<)L(C(W>H6<V1HBTc
zfyI!jSSj1V%$7^l@`IUirIRoJuD9t1SHEV8qaQ41F{xR(v1xRu@rh~KiFcOV7)u%4
zt44=3*CR9RcyzJeDb!UYWfr9X9b5HO+X9+e8PKj<=1vCL*v?*0J^gsfp@_RTom5CY
zTLn#_gP~7M)lpTqB7Scmcf2a#;Aq>WeG40hvT%vZSQ5`V)?W6G=p202%C2hCsDRD`
zaWd`@#gn~?USVo?9tj3*&5iMV6r11_NNF%V{8a>Zjz<(6E!9!0r-DL2Pq|mZy!hRC
z=B)X=1rzN}JZs=?^NXV5W&^Va$$>z)e?7UU=h4HNtO=)#=Z3ROn(><vTBc*`rS{iA
zczPC~Ub>bK*0Xz(>%Y*wr%rI?eG*s?X$<J{a02U6ejBC$DI5e^tVhbw5YiWJ2zJ6c
zcm(s6{=O)3*XA=vux0Kt#vfN=V)7pgLOv@ZdVkRKdLvnXr}mW4?OTHRy`KLvlAY^5
zZk57x2)OA^SuBajM1L0AEl8~J22-Nt=yW>Wi0iAZ#;wvK4jv(*g}rFL;xeKaj?kLh
z!R?<rPM)CEgs(&2O{3U+w~Bv4Wgh^1D@=sig1P>up3fi6+;QG(t+(=^p$Q3~cxfta
zT4`(Dq2^(kDYBn71BP;yf;hsgU<kxC;QPW^Q$*pnw~H2@Nrf*f&@)#M&l-D;s3GE)
z74gaVvinH<T(SCGUrp&<kS-qnEQmfLqVHiAn`bJ3@_!>D&{jDBLoeaoq8;@BQ&UHt
zLtuFdw115R%?{9VI)0aMMkLJppl^taR)t^vcge>@^3|&-=k<S6*NN1Q7~zLwSiLeF
zin8^sbLUrjUOAD~l(O^myiX#lP^LB|HWtLb8*%dznU~rxo$pL!-pS>jDLNBgs8fio
z6pb{T_pd@qM`abWs#c|zDcORos?`M3hh%UW40%n^7PJ=p!ZMtd>W*r_;4P-${>0$V
z=2R;1jxf!Hs3i5w5ioMf;8H+{gBD1Q%F_6YYV1sJu_nsVi4qFMoBnJ2-U1TC&JNfH
zd@OKw`7CtS>CY2O<<zri_W=g7^Q)86TpF~66e9bxuV6zWzb~E&dP(C9@-)5Ekg`?S
z!U_Foj`s%y%<=58%*zS7r_Hemq>ExTfnLpet>+Hom|MwBM+E1%xip^F9LL-PI$SQ`
z831f&YPv_^8aaIl;tf=&Z262F$NV%aR$>w?9>+RqI#THQICeOo;$dXj-?T^SdrhJv
zp8gqIH`>7Znsjr}{U8zSham4ek(K8!#<R{+TBe@2n80N9UlsW239NJdQcDC4UlcU_
zb+I5ZX#9dr8zO9%QAAgy=9INYy;@3957DEJ6IqSqgU^%!!ws4_)d}HvqG1Bu7ik6b
z#Sc3=9(Y|&$&=$sAdrXB+Rsu5!A=kYmV4QV$Vwdvq={i4)r(Nj6D2L$&iE~qBg(Th
z7Huw83&-3V0lx)Ertty0_J~cZ5uMh}E-R9*$Je@}PX&^t=sLe2<O&>xlUS`%AJ^uI
zmnGDRZTUL8elAkKzx8|xQrxfOnDf!Ks3S(I8=c+}LX?InVPhV@p9HhsyT9~Y)nlTQ
zGz_K=7si5<y%)vXq`p^;Ee0(`5OlK(z@1-Cd18q4dWB6QT#Jc_Y6EmmDY&OUMFvt;
zvYI*yjpjm6>^~IVwbwD4?z`=RMb9zEZv^$?xzbms=rp&i6gwnPR}U<#5Ra?slwMM9
zTulT~^$i&95A$pWVrtDnLbfuCbt$`+c#qD%??JI4M(ewFW<4JwvrsRC?KmCD5Fqfq
zx=q?+hnW>HEn{J^hb8-f%)CANfPItK{cFNedShq+v@f_|4WPf2SrzxZxxha5*M`zg
z8=S6`SEXu${_9MF0nF_mJs&ZNd26mLMv06`tfPA#IG;r;Jw%670MsfbR$w*vc@m3N
zH(ShGO=eB}4YqMEK>#h@!3(VyPptZ|@M#jqU~yCKUOnGEnUz=nbDCeB%!X;Yu0R!y
zl9@rRn$9mJv+8lV_o3t-CK5U(=m>p7)l<RYK}QbL4wj_7h%-<WvN7Qt%0^a0@T?N_
zMR11_bVP7Ig1l7<V2^#y@1!uVYPa@aUO@OR6^mw^G$)Iwqu`x)!Cs2?EfK5eic?s#
zmdhaKh&UVxS$z+odaT^1O4JB6XlzKdVU7R+8}EdItcS!k2$_=$ayd*h@WvfFmaiRn
z-71Laf(k&i{aWrDz8r`AAAIrM3cgAjP7o7%X&UR!gQv1Ud)1O?8?lvc+LNBodrgHY
z!{UYwQM^dv;Mf$W4^xG1WUzg<3`j6e1rlaW;Vn|xHrJn?eul}3Vek{tpREGD=XU9N
z@oB8H`^a51(6j&f9vKxL>G{}cteX9<g$332Nz3QEr!jZe@rWuIWwFN|n`SmmW;}Zu
zb9Qc9G*KXB|3q##o%y#vcSXSjBxwPK*sgRSWK6R@+#K3<0O5m12^K;(F-o;|q7<BS
z`^Mrh&QKBuBT1q;nra^9lcuwZ8p|SdcjI(6MLm8x51heb?f;!$(ByeD^Lfe))=F~&
zt>S;oU^~_AC-F%$S@n?UKZw<4MxqkaLnpDZ+__)jBy*UVjRb7Hm&K-{E;q&7BMRJ@
zX4tQYk4bN2onbqva{F1VdetkbG{ZX445K>%5E=<qP|l#lPN0X{Qh<2O$}mGbA2tj2
z*uSsp`HoqvzGIn7-`cXRoW;U-r@_|pA5_Bm_LH@xe!ob`%+d5$4zH8OLe$k#dEYcP
zTnaA8QMMq5Zw`Nv##|)3(-_^^%wKyR?A06%M^>mti(#|GYlzS>B4;zt<oWxMq=mDZ
z)wN>S4SXNKH?rzQ*7DGe=y|gKu!fnH-S-G-I?0_chp0&r`P1kl1FS-^(ozpC+8`*0
zIUSIEb~YtnMc$mI_&gv!`;$sl=a{M{@*bu6ZqdFcWvW6^5RWOwv1rV7XxpXIS(wN0
z16VY>3fjnpsxOoaP>iW5?&wWt?ydV`!kLLbTC_)$bn|D_Vy;C4M?2jlI-CF`Cjs}D
z7C=xa(v;(Xp3*b*c(wyV<rpr&c76-qonvPvBO#T?luUQvPIFilwP6B}n!~&zIdT-x
zQf)xUakFOZG6B`#B|%Zj9U4{&>t>T!E+vzc78TZ9n3N`!179_Vd56}gdTNpkI-3)c
z(}YTiw*Ce4b54I~Hg`mC%~QTL<lcDxat?<3<vBgKGqAu?XU+kJtx(c<*<={siEQ>i
z0RZ^i03H-=tHu{(Do+|8MQ5dw<Pzfk_ZSlQzuhL5unWIMWfm<Uajya-;h*B|Tx4tr
zTo+w(U;i73fb92*O@sgbNW19jY26&NBEx|l?bRs|igb^IRWL@P8#pL!ELsWlHhmk{
zQV#oDz&YQ($8=1t3UgTp_qy{Gj&lxWgnSfk10lEc+%T67aW~ldz_q5pYi8yvAQwle
zOKNd*(LCnkS^`p<rtV3^$E4Fx+0L2^&`svCO63i<8|;;f7NAvxjzPS_fYR{nW!VjS
zK4TsWuFy-SX$;p|)E{k_CN?4I`?mPDT{1nMU!4bgc+$*x{+t4n5h#(tTKd(2-a*b4
zHDEe%m`0BCG^hnv|IRq0=c6)UA&&zqSeL<^Dr5ucLh7xDu}YD8{WFBrD+&4520?x^
zgEf=l59qn~d{$2yw_eY?&u1Y(!aVp!6(XS$2|Po@LfHCN&S%~(4EhZrAzvV&I&e^N
z4uD;r&#L$tY#mA|IDm&t=)H6W2hboo(Obc6t)6==V3nma6X9I682Z-Nsqs8}F>{q3
zPP6vcgut2wtgiISSv|kAfK`w_oYeEL3s`Lcci-R&?1=*xp{CA-9KI8+Fq^N@^9~DH
zH>nl!?_9{5M|=b`JccK`3RI2-U`qlcgJGprFfwAczz7NdPD+r3e?0_w^+hbyBfPl9
z5+z_9AwbcF!~P`nOc~jH@*+0g=hkXL1a9Pds3=tqGlwcf^9)-R!}|>Oah0Ig628K}
z5zVt%s33YVtL$sA<;A}tYzX3oGAR&d@_MCK@D(@Cim#c;R($EFSn)Lq0pP28=}9OF
zp$rc~aP0O=FqaL-^gMnE3rLp#CDmNH7t#EH{EgEUv;HBQ3(Ff|@@)m93qU;i#kqoc
zn3r2WN)jhAg5yRB)9fke?Zn0--h;V0z$%TD#v<iskrHj#;lCB#beO&kiRN9OMULd>
z*!#u9AJ)RfVG}juh@XYj>R><^mqN_l<|e9Yjn8=#=(GJVgxQFx;^QHWoFSr($XFLC
z1w0;`$;hkELX4Hi(=cI~ff$EU=F|Adnat;M79uq~s^^&;yK(jiJmsvnwBv}Lw_eJE
zdId}1w5|n6AtbcLQZnZ+p~V-D`Ix)la;0*x5LgDn68e1&bym}Gq2n)UB&?PNpEL1U
zaP<7jQs$fd8SM1fNN6!fl?CJ?s4&Fegei*R3rtaams3}@r^gYWxQ$DgD6wD(Kw*ov
z?+)r58St>|YMP;}Fh4~QzkPJky0H50+4fl~K4Ka3(tMc+vYWRI3(nst^kf+ec9}g*
zA-RzUy@4$3^H{X=VRZ~x&SpyGmqCME&PMrFgmA-JC$dCzy0gE-^e#dL-fq<r`y~Tb
zlNHRU#?#K9RxrN~DR7>HK!Vr&ZQ4r7H5W$#ywGt*Z*#yOwU9~i7zM0rfoRfNNI{2<
z4TwFBDR^qCn3yyhw<5?BR<clcL+B72nk<QQZQ~;U6ar<?j(Jy)A706-I9;BibS08z
z&q#}Q<zhYmw30P$u;(-?CQ=a<Q@~nr6woCqK1Xv?sW`QeNB)8!AG?ax#oA=`QibzC
zDGOcRTG6#>`;w~a3#<1cJ-@Pw#W?>BDTJ<1FeQDl;^6*GUUfB-lbf!^yt;_190c1Y
zB6B~1nDR776pz#r^u3p+ry-*1D4GPu%>*sNSA4XBo=JCbK)OU^iD|JE$vI&KaeG9Z
zKXMh!4nna-d*~?54hKaAQYOq+Oo6&<SeP_(zn+g=!+fL`$DtywVb1RFhJ&7{11~;(
zwJ5TlMzY-vesm4<^E)zv7WG3xheFEtu1i!GjoF6R6!8ng>ssup-9%50rC@8{O6>`x
z))Y`X#TQV!VIg%;dvinqwNqjNwNn^Q9h-_!`;qAiwciM%dXIsie$Xof-Sfq3S!IoB
zG=}f=T9#67HEmpedmM7vWj*h*jx8@8D+UW|cvHDQ`R8?zo=wBw@ha=t^kxk%!h)b!
znp9&?kh@T>pdXy?5lHnsh8~i2*Gfry(Ro2hxgcQ>t;b|k{&qd9p?3Jd12?eX1{<+{
zGzWt1kr3}o`yb_^Pdt{sIaa44gE+Jm1LX?WxC=37>oy*M(l@Xnnye8B<!@lo0lkL+
z3pn67GO;8{i;<>DFzkO<s__Km9k`K=4#*n(L*7R)_J5am*;wTLypb(QF8O2LVC2Q_
zD2%x_s@<xb*%qy34Txzt_Gzr5BXAjdwGUK{D57c0L40T9TOl{XkVX3nc&39F5i#*Z
z)hhr49}UGvHE>#dbWM!6akglu5O{Kjjm9^;grNge+KlyS-9b>*(*P_7=L>OJ1C80j
zKfsSC@V1+oi@NwA&NnlEm-_<|7nV~_WI8Oy%Cxg9zq%QEgbM4_d<4{QE^&`7%qLuf
zF+|3wtmd?de$TY8s~U#QY5o&HcY?ZKS0^g_2lJ;WmEi)aEzGU<z(b&bzTYf3pF#75
zG*0maH10WvdZ=AFG@fT}VeVDVttvv$zfV;NdVr{^&5u<r*$UInuHhJ<N?X}J|JSoo
zbbr$h-&qH{nHu&)uY)jayP0bC<X^V30g`UEo)7q$C8>|)@q0hBW$Jz1dD1pkQMw0|
zuHD84yCe)E49^ncCZeDC@Py{%wH+=YZ_zg);M!wH%}ofnSCy4*IZTRK7zdlgC^Gt0
z$pw?Biyg&+0!rpHO6HWzaNt40gOvu>&Xm!O<R`#V!2ysV1)w={W9R`QLtMAkiDzwR
zP3k`U4G0cGRn{pclc|-Y#5Tkc7*GMphl=__QDKK5Z@hz*cWpt81@lNb6Hr3zGQOGv
zOT-S=ewex>4o`bvDk?-uby&2jUkio>aP3U}JE66;EZSBeXcD!BuzUopo)}cx=&Ni^
z7G)Y;RR%L4ggWGSP|vIHWUfw|u{=H&35Pi=H*9nmiuO*psW}gTm*7t3UfOOc>MpqD
zYwb=}P2(~cJ-N1%O?0UQHby!~Hd=YmPc*fQQP2DR!d7eE4n!_#7po=>U!~`Dc0tXV
zy9a5zm}^xp;8URMxNm`M3m8?X?Uqu4gumR80J3Qp8?LEA;GB1}y6#g_QP>c=r-${x
zqqr#5#4PXmz}>8aQy6fi7$p^L<`1kP&hKV^PU;^LmLuWIZdNaP$y5?v*su{Y)Am+(
zWf^3`XKdO=|6C<H+Zz2|d}{OP6J7U(zD^z}_hTLS<X>65#=k!r`s`PBQa!mn-@S)L
zN!y{SyxGIzq73$??0OinIsPW#ik4P_apQJp5k1ZSJw+QrcZOLFX5iPtr&3_nIa$wB
z_d<BA?~5At?1eLQD+)c`%OW-TeGsa)k5!URoPq?|$9&Z9+wgJwSWoHGWIeyW54>ft
z3xB^4O6FEX1pdZusb9TcvY&-D-M<}{$zxSfiTEi{eD+$$Xbt2tNE)MYwVxOxZv+o2
zK^mjg2=a;hnV+`b2Rz`X@fVwGT``j^+6h><?b^@kY5NvQ0>vXK1W8}^!*y>~Ja;i-
zb8zrty|JE=WvJYr03zYm4gD9Mc*0BQ#tuDyaDY7tbR80n%arNXSc|s&dbE<>#<OO}
zvVH-Hszm=F9(9gYz-bKYjvLwEFjiO+2Fj!_P4kDF6=6H1#`oB!T$o!E^t{a>Y+`g+
zq34?pv18Iu#0<$~6+AXXgW*4=p|Vz-Et>K<L(ey4vPPv0_A$4u!_23=@8#@i2>re4
z_jM>G<Z*iLd6+d)|JjoFJPhxopz(UX<uF^M{#C;xj<8OWXZ<|B=m@LXu=qG4`ewL#
z4GpJ_arC3(GGEaTve}>?zXX3@2j#+nmqhFu9A*8aR`v4uprfo#m)c_q6zs!9U4TYd
z1~mBwwHZhfpY}Uzw!r5c{~&9w8X`J$aF9|-il`IjOGLwkZ;YP5Jj!ZFH<svmg<~wP
zOqIK&VrJgPWHDv@#wQ<R&3$Svp^9;u4X%v^8>EM_MJrzb!2M$^p!AtBG@h^>m|C~w
zPRCgXX~-D8ap-Y&TjjI^0=VdgaI-Dg7COo1IhCXYn(bC5wtlmozdgx@xJ_uOOj4zb
z%9gCDL4*TOJO!)|`M~#`VlSmTP&7B6#<JdZzMf~FhHt~RjiAlb%rnGbTftPT2wD#N
zi<xT(9SBbYVZIgp@2uDJCTH0E;y*(!#HMBQZKvUO^JJc$J7zIANrr``au)NJb|9v8
z7W-K}v>VUQ0+;QI9WuAG%&W$38sF4R6Tm6nTJI4ub-4Z&$_qAdvQmSANz|CxjpDcM
z<O9#L4nYCHsCfgt!yKkHM!H2?X*q2&P*yREp}b>hvrf<dJ<Fo}Hg}_WLmMx+dRNGx
zqVuNDG+0c}u`0m^+kf@S1hEkV6<WdXd%}9JK@&WVscC*x<tNX<KJx+M>+3n@+xVAw
zg}Ab*wM0$IlykL0v`)E+KHo!Brd<7Df>eF@$V03opMIWIE!#xsCz&G!mUkY|<H*lh
z=HgZ=@qb}!=T)9}9txN3c3$EFtE-;Vh&Q>wf+RH<{p7fAuI2j*;%YinFes>}3^y%4
z+(He83NU;d-*ADA40+g@u%sx5H!{e}i{=;p9Hc)OffW3)Xlp^v37{FH0U-T*pw0zA
zSNzP!{LcEQFSO*>e`nRz=QncOi)^#{L@3{Rk&Tgd490HECH8Oi*E6Z6n!<A(<UiDO
zXe;FP|DG&s2I+Z?Kfu}jg7f&?KUn34PJ<Mz3&sGfJ1SV0hbZIdrZ75#8(|$TN<_Gn
z1)eYiFjM|u-IBM=03{h;LhUFrkLrUc&F?@>MI$Rw<b%S<ZUP&Q6nUvIl3>7(8H~n!
z0FkhAu4zT*nT3nk8;pW^9Yy0@fM74_axxu?EIk(qX-J5nW0Z-w2;o}>N`GcRI-UDM
zIzX;!QV4QAfoy9{5la~05G4*#2{Lp;Yo8oRI%QwM{31q)kJl@~H;`&`G`WswaXRI<
zQ}W-6q5L(e5BW$0gfk-M7z&vmQjFDA;zfPRXh#_@6^XtjqUTfY{YrUTG#Ka7K)dFR
zO3dphiqWssC*#`PB4rby+u-F}<jk2|P)%PE*97o#;*~~|#I|T}leX85xCD&Rit~nE
zfE`c88-JJ3NhEw-frNm9%v<ZBE;nr}%3ZD?auG#pZ$k9-yNadfVDN_dS6LIu4}qIk
zSsm$Vs-D|lV=bh02z0py)}Met+BK}(CoR<Tlh;_|G8>3H{R3u!Q(A~~_>=iK8NnZD
zkIT+n52jzN$rga?{D~FNf~k5w=uhTX#^u~si}}8w&h1EC^e6Kzle-v@Tm_^_h&%Zw
zYgxu~I^s@>xFE#2UdNGv&EOzW*O_a%hx5hqi6&4suw)vzlE+_X{$;uhL!oP6Yw$+{
zvtM}~4G)^4=a;XeEB8{sjBg;Y1c81xFkSD~;0tcBs$~X2<usQTZ5j<Jf9VGES9@0B
zuWztAWsVF%T0PN@l1K}^$r7aYP}MfyWFZxQstQ$MBMM?IXWpdz%}Nc&G#87wUN#3T
z{Pj&1>U?oB(65D=hnk#1P3}L7H@wAsl9y8oHZVjAF-nu~a&j~kyh1qa3L%@mii{r$
z12JSS1r3|R*HBaqs!S27#_BM65%SxlJu$}#o;nS4j@kxK8Twm@u+OnnM>dw@kVj%A
z-_Dd)jo=}U{Mzr+AFE$GHEKs?N))l=##dE=TL>>A?;Wpjn>9}U)WX^Z^9KNcM*^mt
zMSBLnMXRp__iu8zoYWpG9e~^PL%J=}Q!>poca=6wfJ?2ZPZ+g9#DY(g-OMznE@gZw
zGLjQ?+;NJnD>91Ml+2uOP)JWOwMro<A~q|P76Dc_pQ+IpOK*I`4lNp8)&LL4J1neB
zhD_{NNGVg58GQ5|)-d_SiLaI)q;~5S)RrouI%*3kV5Tq;S-CK>212HFoN|T~MiQ4a
zt%Q9Ej=mxm4HR&)QiG5Qv;?nmj800XkX1klulg6WOXe%7D<Uo>Q^+p`TS9_=oJ@&D
zrJAWOnXrD4WfInZLO{+2+0jySg4kO-EVhMAw)F@|Awh5cY{cp^1KUs7Y)>yuf2QF>
zxPl!2i}{pIXiRG5lY_ou@FPb;Z~TjO^$2f-&1|8WR65nGs7V9Qz5fjcbZ@2A2_`xT
zIs%+vTtgu8VhrP9S-^@IZj8}5;hvR|hby|6mxpB{5>wAY(1}F4u9?y^Rx9Zt=aCLK
zop8D`oA&Aye;>L|U0kM)jZGZ9eqw6XJ&$+3%lxE()p|bhF52M&Tk6kuS#z&^@KA_^
ze;3e7MLTjsp)cJ(SS6JF2W<%WXoS4GhXo0-+vgUoZ5kn>8BUc%{sV6m&6YgQkkP5v
z1Og=*nvWM4OgGl%@oh+ussR-BHQ8|hbtkK!J0jPdCAioEqRuY1-q%Dene5<_454Rz
zZu8N20&4pePVt4CKR*NK4*PAF!!qfx|D2({CG{gt-_JvAbb3Uhh|RTVb5_wlN@6nN
z`XUZ406y3w6L&bkPXuyzOg(tSDPA`ALyF@}e(y)qyrl6}<N4BmS+)8{8M;en@=F54
zBMV>AxCJ{mbkU8<CQTd+969%jTCRYXCHI)K<NKlL7h!|$axK+5kNe+awLJ1^LlavL
zsi)iF0^uU=w|Jl79@Ca~?E<119Btb5&S>HD??IjngDBX4kF_qf{e3=kXq?3e$>*iB
zVUBn(RL>)_Su^`j&*+R2?W+G8oX_WG<7C=Uq!}qK?`=WaEtIpn&(=zZ+w1xE`^>9O
z;D(k!i?&PhFq@+l1RV=~)DTfaN$5-oHAKQIC?+`jf|8%^GoM<e3W|Vq&aZC?D-Gb3
zDaek<n~1b%H=<NdD_mlOa;+cWwCu6T)~b+YQbD<s6iL+}a<(Yf4ds;07f?cw*pM}?
zoB<As6ML`{VUvX7qD|oqFq2_a%y>hyH3`D)+enZLnCabC8Uz+(YP1P~)Y7N0?7Y|0
ze1BUW-W<<;fL+qEP4l?Ve>jz+UTmG2!$&LB>e&VpI0ge{rRm49X&+<L@=T9Guzc>>
z6`qyLlg4}&LW6WD8dEV3d(lk9GmwSOXv8#@JVafpA>gwQ*^>G}Jpeg<=6fm#7o};@
zY1y>n>Ig#L$rR6XH!OrbRf?YLOB*220++SH;^ZM~P<KTV@cK|-sNnLAGH~|?CO+gD
z3#`QBC=>49xS0a9DD!pXBQ`|RcGvU29zn@i0i9j*m{q8iq*Uo^Z3bA8?SQ`tv#?2{
z8TA6l0UnR0P&440+BjCvyFG@&p&Oy+>5o}?rx36qb15>rr`;n1wZ}v~Kk}G)hI@@b
z8|eNJ(M*TkrIZ^&dgTh1LRtR;)1X$?PcAxm-0=zQLzSw+Ak+8>3vzO<t?W95A9MlE
zz>1*mCp|$QGQIQo#wYBe`tEe&XcMca(mbw#Lc7dthWed5ultm>QfCh0sZUuO$$z+>
z|M`^l)#$1tOWhn~8R5o{<-l|^Smw8La9;1sD813+84FZNdoh8UJ%_C?VWi$T>NzW?
zlJ2<V@fj~zD>pBYXVJwe&fUTP0u0^sg892;gDU<{>KLRpyFaT|qh`d3VE%@lMaxR7
zscz(^K=DaZ8W`V^-xPnK@<Ch*yBVV4-Pcsl<8qk`zi@w6IaNn~<RvD0Sqx&a2eU#N
zHB|r~2RRl2yno|&fIa^w;Fu;jm-=8<Rlt;US*+)@N#uZLJq&~W?(jof1=gP--+#F<
z1cp23@xVMFXW>jePyBCIJ2g@^=P`f(ayl_{(<{?eoZ6A!VM3gO`x%y@G7o2YtD~TI
zzhc{b7Bi(XU#l^NFk`LnV<Z-J4`;=dkEFhRLr1j05;!>yJ)5d}<nbo2SrfI}RzBl3
zd)sB$G!Ww>_)uB2y(y^1C4<78+>X9RE8FGMylGwVq8$N_7%x7ifD+B*Z(*KBKcDdf
z!X?5FH(lDyufAd49r8(kmN6<8ZPQW25hL(x?uiJ>N_$xd!iWK-Q?xi2e@zoNV<Au<
zA^6-Qy8wDvP=KlTW*+&L)hzKlFa_liT13)Y_>%SMtLIDKf@9P~AnPp)ch2vFdioS?
z(wt4aTs{j9REeUWFwv|{APPVeypXwI5KRp?@&5U+n0CS9WPUztSSvZ(NT&^Gm!Ok9
z)InObS-+dn_ZI6nT>0Ec=<JH+mVD+B^mlJML{t<1*AhDx6#>VBN2*2bw6P{~>tlJ;
zJLclC3b{$^{U@QY+eGjt?<79z9jje>>pd#H0IBc+-+jBDH^20bmDkMj!u-sA$HLnt
z;^-gkLeo8OMAgUXufev>P~uqA{LhK#IsR9y$+tyv=$>;;MAu0LrRlR9(H5<5eLcVW
zqMbX>c+VWA9Y5vs4e!}PO$Sd@R{sN=QnGA)vU$BToiESNd|+QoyF*(suZ$wcoDDom
zo#t#0E202tzr&qc_>qls9vrUFCe<O%;8%jIOZvnXOGoPJjpaVGa%$;HSG_UtEBmUF
zw$#=y4w7q2!-nb?_m;OgJ?x8xyBlzAHTcQkI-V-Iiqv^<JYVP2Ps{tL<l;dt7wts%
z1sV*YCw}{1{VP#Z&*!S-8d6v%9Bfg^6(vV32%o6rHJXVoXzpw^qPCR8Z9Qt)Q@W$m
z^FP#bUuks>J+CRrzew5+FiT5vbLkR#5TcPoq_wcGch$((H5;5zzPhdKs<}*|R<?40
z>OVfpR`!+}Rnr^i+sYkOlDUeWKQ1OukP;B+S6m(-*;UaS&lZ>KsGRb;p`SLsR%;$E
z#p<g!mMJ06Rk_y)CdzNs73s5pTPq$O^w#s=O3LM>_dz(1T2j_YS5FM%ElSD5DqM;I
z!qfL|C3lY0tO-Qo1>>9z)?u17n_n#@x0U4nut=4b&s21#9miCQ<S@Oln1gRReUI}w
zKfzVeUiNp^!!SYMXefn&#~-L^YA**!0|NA1XD?6E94m(IKev|yU2k{%zr0P?6Xww}
z@?@!XOSp=bk$t2P1TK}4J<FDEDO!C6CQi_A@2|u7hca?i>5mqA9_%2WmF`y5^Vbe?
zxO&P;V^v4FkxJ@U0Zh59yjeQn2ctkaS>G|*k6<)|rz%Ka>9eh77fq09%C-7wJNzRB
zecIYvqZLjW`q!U|JfV}bG$E)k-ft`q+?JC=O01|!i&SiN^SrtPou!*#=6+6c7tJ~q
zddr;TP)%usjQgDAw<@Wk5BjE+TT6>4KIb2`@~;}duPtqiyIkM^C5<>|$1~hzS6AC+
zq;~Edii7fm(iB?Nu8Yj)N8RN$QgU@Y@9QDI)yNL0;C@mEC-vH8#sp8fy;@W09p245
z<t>M6>?vgNmY=t_tE)^*yC`%Pm-9K|Sm{zgrpIr^Y0}2k{?BRB>tSFjXHyqoo0*!B
zDUR&FtH$e=m-T8>b-ua0oUYzp+F09H?yFKie9ssA$ye1`clgi>atn3b4dd<#@(7i5
zq#pJG{N?phZeu+^>o3=nc3jKlQYFleHDzGEtRy#;>LF%aCAm)T3T0@3l(XtID1wj-
zwtr(~OrOf^#n4$rw3V4PY((xhR%T`h{czkmR$?RznAg10a2XAdo4T%R0J>AmX2^hH
zgJC=rib4MXIZSfCn#)%N$kiLG?Z0n{m0B`s<y$~4hS1bwN>xfb3&>(_DLpR{C|8oI
zMd$OHftZ9Ft6_g4Q1&m|84Ka)v>gS+=dzs73Y5KrT&-ZO)K<m{_Iql(P!dxiP_Cff
z>BaK`We>H=m)i%))g-@``Mgn(>``iERX`^f+wJA~fFQZGrqwf0z@8vED*0zGuwoq^
za8(Sr#4&N+pCY>=(qX@X+*wxK8X_`nNME#%w-M*uE2?N>qkllW^_+W(Bg%UI0I(?m
zEQUz3*NV|e7mpYXPp*T67kEhfhlGw4f3rxu*bt1M*y9vyi1^tw3@uF+%2~up@p03W
zkf`%_Q%2Fom-<qI%FIC-+P}RbNH${ee^ho0vL~BIf1kueQdNL8cT*~w@_;fkWHz@@
zVn&FV5|pQo67yWdbfr8Ml$gIo%%diVaa3Yd5-CQtDbH6J+(bj8lMNAS5${FuPbePG
zXsIdZHY$6gFsC8nj)-1J(MJ(Yhw6M4D251wNW0~MwDmuxjS^`+soabo(~?(-#5Ghf
z{>Q{ABCR47jQcUofRV>t6I8C&k7=VsT22(wTz*W85NXw^+($<n8<+2T;U^OJLV=xD
zS&o(bL$Iu<Ec;0|2)wH-d%I*qrja6%T^pJdSu&vtL-`1)0%~6wtmi$e$Uc=T{;q<j
zhDDoMkH`VeNOb#Rd@DnpO&EQfLl9L216L=az{V<alaMliD!89HRxBP+q(JzYLdv41
z+Gr`RA^^v7tSWDiq98i=SCwl@_6R(!Dtnc2!N!Jpvf%xd!}Z*`njGX7c?QjJrmOI*
z@Q4|hw$<mIs>yMUFYJ3ORsw>5PbyFB_ppCA?24GOeNf|a0c$MSvqd`szsfihBvLHB
zL;3w`a-gQ!R@gF1SC{=ge}bjbj5WKB@+zRP((Z;xG&QZpTUVDo0*eo}voYtP>lW=r
zFmTZ*IE@yxjV7?^zd?3<PIcMKsZOx4BSr#%Vq~rOg=bcm1Cz@I2;P629Oy)gNozCJ
zxv0X2!kw*_KbmN!XSjRCDpg>uF_T#mhEdcGk8<%_O0-0r<R(69^6d8!+UHMX*}*I(
zljR+6YQPgy6#ho1^L{nt7Ou^`D6H(+Tb=lQO;>#Q(He5c{tZe}A|#o4jJUkOGnA^+
zieCruTSELw__dmo#kh2ILOEiQhg@I{@v>+ifN$UoK7Na4tKy{QCyGthYIXjkuJ;u-
z`U9It*<N2q&sWuy8%le7J?D38%DKf1m8uobvG8lP<U!Jr3VLJx+H$T+s#QOqR}F>6
zxX~BPKU6*^op90{eZu5Es?y_qh!V-(G&abXR#&dCb_x!HQnefCv?_2XAmVS<lUF%U
zd^HR$hK?qLUKZ|1QPWLF@;@pmyafCZ8iGK7a@X?}4doizVD|#Rffdm|hT|`w{_KWw
zZMD0KYa`@JJv;ak=3pzyN|{fxJ=$<!E#1a*0sC_zKIMRr`H5x4S9JOT(iBXUVWYMd
z6UiwD7E)=&iY!o@c7QLAko^P4e9O6rvY7wDd-gDWp@VqN4!>4gN_GVFBBxuBQ0|S;
zzILfRu8|xNSfR+u#1J}nY7^0WU(gLnptWKp^7*xnuV^G!mS(u*^Ye}59h$Q@0B2%j
zxo64uuXP~%m!{o!_`i+i_GMS$o1AwP2)4ba@W@D68#H7J`twba*V+8N!GLnZ4D(9I
zCq>Ft)UPGJJyLEVNm@AYM9Td%@BT!6-J|63&Y$y8AI67TCXQ)jLQX%70z13q36-OX
zTv-!Lnd>%@{ahE7hw^a*u$5hTA?<<!aTu|Q>?=j&>5L1S$eY#fhap^vo0YZRC5y|+
zaBsq9N4>FqbGe^NDhJi}w-)kdr}<#8MVCLpr1Q1}m$dPP!+lHHE9k^@W#zM#baF$e
zZp8n>=f0;p{$ESEhTnatJ#;x6b)PP4qj_J@Ib7NS9$Y6{?yTu^1syU(%N6}Lo(6RS
zjS6-ZERaWsg1?(k`>#gJmo=Thqj}u1xfOU;j66*<?GKcXYlY<yr_iugSPre`8LecW
za^s$3xPZ=Cuv5jRS8_1xjK^EaT~yNkCpzvPE2l`c5m*^3cb9HG*75hT@*O8nXJEm`
z*NRk&cCV-2_^^%KOXZ&aP={gMR1WFg&=u?4ity0$9&KfRDej?;Pic$A(Mx$4&uuFY
zm;7w?ymvd<N7bB9YA3gs{_sW*+Q~;N>dVn0=nED>w6le)crippG5^R_&-b*K1DsE5
zl|>NIgIENy9G&r5d%2pr@?R<vYdGMI<ySVE;}B%~a&U7ShhVJBK@x=*pOrf}j5qHj
z2THS4dgF*r@?n+qK?Tca7YuB-d>!x8MXrU*J9WlIU1U5mQT-@zxUQ>QOS9?-Lbtlg
zG188|b-ZFX`L;UGiGS%PM`@ZIMpBdRavh)j4>8e!;p0|&kt5jup|z;rqHXY(jxXvi
zH<SDwpBw+~E*}Jsxvk^8r+icze@kcV_LJ<QQvdRdkL)FHRd>2%^yn?GQ>iz;=STX;
zm(&$@^ErLxX6nN`jo13hwN!pf`zVu4AtOi*fs?|u*RnpmQh&L;`?YERYx32<qT{{#
zWAZsY;OYIrBU?T)p6xHsS4oMNb-d?5u;5K$&-wC!^0hJ})u_mjnL#(+EPB9`2FW8d
zyLO?+&j-m3G>Z^2Rv9cWQrB!a(T*5>OxkrUu7XGn044|nrfY9VQtyql#u0W*33+dM
z-cYCl(b>SlFge$~)p4@;D`u)9SHmT=GOmr6H%XcyTTp3Cg51bWdrN0yz7CzRsK#w`
zOUKtF$ZpAjnFPoF=AmJrcH4QG#N!tU<Cj&xes%%HQ-3JF>n0)-6g_jy2GUnUzY_O}
z7%V<!Avrot+<ZA{HKmTH{EaBT5<5i1s=n&rWe`NLL4*Z&%`JL?yiVWpc3MRc!U)0_
zXkb<djYRD6FNh^AR`C*0fTxNiTPkqzhoqq*X*QMmRU{>odxBDI)e)-a@(rXd5oy@E
zDhhV7NZ&>2<9-0!UnJEbus#1*(H<h*nbI44pWaKUyQIj_iC}wvpFv4~dYIaF{WH=(
zK{r&IWr*+;#k{H5!y?fd5xx1dj?W({yOt;|3O~NC<G<49GmJ6hA5yQ<=RWbd8L4^n
zxk!8lAhql$xn`*zGoV!BLA+OQbiB<d*)wPk7#X=GpE2)(9zZ9vL4?F)P1~TAna`ma
zu%IJ%#wfXBne$MM&A7WAagz~uVwCJ%=IAxV-4$^i5%+8qH1EUz>3D<DSfDOPpx0>G
zqwS_y$TbLX;W7ikX{|_1kRBhA6d{=38YRg*5E-pk06sBYC;^S5;0i#|wA*iZ)@V60
z+-0Pq1YbezCilNd&#;<r<-Y)Pm#D5RU|O`L6v(6t9?#{C#-QO*SCI$jJ&<}6@_5)7
z*++9`05szCF|uEu>`h4ZK&rK=YiZtY_k$K(Mt~jpO7x<zVcE!PN=JH1=FiBWxY(UT
z$h7&jiVPlG5e73!hbn6tVC1C|VP!geA9zZH*>MH}qY`DeHWgP=FBCsrp`79>iI>aJ
z6vZuI5tIVlq$hr7;kW33-S+%QJ4~j&cT}LLC#G|^`OQQ*(xU|ih(OX-fmOZEM$q))
zI<GNSjtMw*3g8C_ZTCPff!`y3cZlE3;&*K>*vnYi*C8~U*n+|jqpqnGUA8PD6<zkF
zsaHSJWm_Wu`>}EZsYIpc#;|d6u*!4szdEQMmP99^dJr0dgjIIZzdB>mc=?dzbl|b>
zJ59CS3mtFC<TcL4epNJ8La~s1`V%_iM<)NQlImU588=Uo2dEr!h(}@gw}Q`_9%pm6
zWO=x{yNORvmOHifL?WTa6Vj1xK0_XH^BEeU*r_^Pvi<SavnQB_bn6+$ow#`>T_I{J
z`G?UzMQ*5aY<OCSjZivWe8&6-GVrL2<F%e6t`})U{J+5K??|&~*FYawI|YhCjq5so
zc8Xlx>Fb|Li@yGY35i3=VaQQpsvO+%V<wH3a#>$W<}j*VxZsQ=`ZGLI!52bAqD8bJ
zV>&cO1(Fl3RPKbM$V$KSiBo0IhO>~El{%b&q-5#}VTrEDn9H~*jv~!HgeINzAB}z@
zeuX#1m8o(!X~$h1uZ+WQft#-BtjCUlNbB*Jv`jFMnfRvt!hv`3ae_}d9Pi>h6qyO%
z2Ra&Y5O5l*AfJRwao+q$s$5=UvjD;@J5{c%o*%*Or$ITt`%>99AltDa^m0Q*nao8o
zp`0TcJ37DUc#mmvuyp>)TRvl&JXdo!1904?%iZmJ{z4T#BC>Z}#3xUe+s0XTQWTu)
z1rXcgSlyCBNn5*Q%CW(8gu(Z`HQG*mhA!!=Xbc(PC{!~QwrJ%YI_^0`4pDbK%3IC=
zf9nTDVaW`+o2J}6wBXeYImx;24w@NIRMA$URhK`bGp5XxH7Y53yUsXs78Dxk;_tdG
zm1oOpX&KO3ZH}Dg6bdRUs_tDv!i725XW0A~EYWkIXb*|BD%uKe%7y$d-1OL_;}HgI
zG0Z%t<0B2&Mi};1$LAX4U7E48(Zr~^(5Z8=olhuGFrqY-bZVuO74GYd)8|6DmC9x5
z_@jB)Z@6$q$E#-0QWN~KV}`t0b7LleeaV1=eV#&Y^PymO<&EddF4E=A(BtOIwN+Bo
zI#j&?`wdxZLDUQ7p;Au-5*Nw`osL~XcWrzNHR`T6bjHX<a%)wCsMSP#Juf1?9mc|{
zQNPAC5yv>xF#ZW<r!@Bv<-rjn*ymR3c-CU5+V#VR@z5pmFzMf;I=*g+Tv27=XO=)^
zoeSNlESE1<EDwpM>^Hazu5UU2J?{Bc-IAr)ZkTXc;Wsptg5OjJcEguqyCGqPj`v$C
zkJp4xLhtV`l^08?ham@hH20JSA<(lq0xc2Py-e0h^TrJ0=a#`Btwzk-W%32dewmJ+
zTrP*IwGPG)%c03i>o^EurEHMOB5-u2JWEr5B0#rV1+9DQ1gMuOtK^3&Y3L#yAF>95
z;??VCeAOEHp60+<N?a>1RM#{&BHc49ChZ3F%-w==p?jk7rsP9H_bj-Av<B2<lc(`5
zZ?-{RE4@dro@|g`ReV2P(LIUii|C$SSZ~vsjiPzm)3S%rWt03#rD-q%4b*Ny1A`GV
zw%#JwRcZd!BXY)8xsmtnl~7;aLGu;2b`@1pkFM15`&*%;K1vZv>Y@~(q_&x&D5+GB
zRY~2J0T}B5qiAtG0iJ_M=%w?Ak<#<}6wSGaY2u>=l9eh!8U@Pd#C<5!4P|gouSi7p
zHpv62uq%OU^nFrok+KS4&Hmq~xDTK*|E)ku$?sDv{V8P_mC1$ut)Lb+QD6@hxKkur
zh3I4~h$#EXBJmwk3Cc9ezP(6vM-i>3=tV`M{Y7;CNkmU75?x6|-=k=l>(CS(3E6?<
zz7la~DpgRCAbGU<G4Y5<+;S3X-Zt5-#6$7<csVpod?ud~pMwbOGi(=q2lg@s4|j<z
zN7|Ji)AowAs#I>DNK;xeO+=5QBCCo->qWHX1fpjkT9_8i6CFW&(c9&)Qa-T|lyJ4#
ze@MsEw#yZym~A@#%XZnN%+Ljpvmqz~KW8Lf+b(yMF8{3KK|5f`S%*NE9kO4UO>xLI
z7o-6N^q`JUM;u(T5cfjFr5^+-ku}r28{Z1j6m#i2Q=e#ld57$-et48W-66+ROAAxf
z&f`F%>DgLE?d%JxFtx>p006K51H{k%JphKWQ+8I*+|S4Fl!G-pf}vn;+$jfCIyoG9
zFMw3P8Bs~Zr#~qU6<f5a9SXnP2_?Nh;tG6G$*t3lbWMBQpacEHgsddlUYe>*;kAB|
zt0phrLVDr9NTWNDk%l?kmr68)|2ipxw^6Cp@abrJ3B2Os>fN-$9Ro#^p13AoKZls~
z$u)$o29F9rjLK>eX?0Vb6GS@RI3sm%r1*^&zXS0blNKP1$0Sos&QCr-BZa~%@JaUA
zT5Cu*eP>#}nrn8+O<cpEWmA)`d}~sWY075aYnL1w&~zR!^pj9bXYHrTrix!#{Eid9
zBlqi!mv_l{hV|4^ozd%8IaF18!v+i`^viChbvt>lJ#x6VPhm{2ouHyYxWa9(j&Iu|
z$Aol0NLo-HlqPVJOdC?3T$++b^@^f|MkVg_p0b>K@0C5(51a7%du0#p?d4SN4P`Pv
z#(`g~A@*Pmu~%-^rsevA`kU_{b#prbz|DN*gyBf)=1Y^j?0a<+TZLs&3PUEUrKT)J
zAyb{@{NrAEl6ufOK5?J?P;HrL?DLzPp;E`a=Xv|(nd)XOc#=^brJmo^_}nNrSG9}>
zZ4{_E(Qs!{WEd`Z2AM$J8E#FssyoTm{+GJrGf~GU9)!B{VK(1%P;Q{EGM7I%D31s(
z_1jwu>F_QwC!T0p8|oah-Vu!E&jMpXs|6V?GVr8B*pQ8awA_D4uI*Ne62*v=pjB0w
z_k^!T+jU%(Dc6?{g3mO{lmp6yry<cF?|I@`KTPh?neutqz>iIOYT;3b<$h8JNY71&
z<xpwQ&1c4c4$G}1DRkFc9&#Lt_2$JoWBcQBw#q4U4W#;RjEhx;=(t74o1KKgyHva)
z)=AC?u|7IUXMB4S*ptFiFm`94KK0Ci4e*Q{<TZ2x+5*cB+M-{JktyOc2>+7Oo1FQZ
zGqSVGiB2tHXTh642kB}7P&Rx4*XX!UmfSWx8NF8I7x)CI*OjP{PVnBtSdh1US`cnC
zrcA!yTKj4}`j`ck%PV#m|2<3g3b*|M%qk);0t0Lng2@IqEed7=z?44=+wYCm!+4Xk
za*%W=S;zHf<pA8~U`%ikOb0F+p$1=t0tjK&izBk*b=-JXZYkv(Fhb|#0QI9CJoua(
zTQ6`DRQx(hpQz2)7@?R7MSCex%y)Mp=gDBy=i~;-r3^?K14q%E1pJV$z79Mv$J3&%
zw+em2HM!p|v;?P*g@C4&kexV8g=3arBrtUB0+4FBr&lRLP<mRSyru#_LMcX((91Jy
zf-s@hZ3n-BH|8CCVqvF{hTE<1`~CQ4oR>ZP43*aET&$A75Zca%@Pu=6gd{ZM;!qv`
z{k&Y>$;X-iw@{I=90^~}%i)!erBiFj`82w~30(C0o#~&2N+aHurqxk1NVwhGfAZxi
z7v#7=gY8dq=sw@Vle%NQm5Q;YSg;&fKSakJ68dY6C4VO~?W9&vy<9KK4caeX3_dOH
z0#n=^i(Ug5K=>lEsfD*GaHjTBT+4zx0QV_DU&Jm`f^_J1GJ<@=McG(xG<MadoDm#^
zoElO$=(z5ZTvv)&m&-R_lB3lR-|^f_m_65L!Z`c~X6o&PTt4#;`KQ1O?ONif8`MtV
z*%rf3H;_6^-$OGHV?sg#7tR7+$;<MZ3Qcj>H3>tgE1_9#R?dVh1t{+ilwX#cwf|>6
zb+bNFtlgxbIE@HBY?-y2W1$eB7uSFsTy+?N;1MNA-CVB(shcwidws9S+KvX>Rc^G)
zMYlsr4l@HGGU3a99xIR{zU;6?Axp#t5er}T+1qvEdZQ1-U(+MfX}zLc8o7z^ckYT@
zIm*2Ot-Iz}&tAhRj{1aeg(urDXsIMCJb8||V1SYx1<SVY*kTy3b5(99*`(?C%&T&%
z(gyqPCvg>+fXMUu&UNCsSLKpr?c51v1w=BZua1|xCbvNDJ171}?kfVp1-VNjcltFs
z%(HeXI&c6Dr2kT)(<C$YGcia`^K|^~HQ7C6%@Qkuw?p;;f5qDh1QS-DeIuT$)cNv%
z%KdE(wm%;a=Us2ezOJEnUH%U(|J7T^kNhd0^la0KupkCsA&h9SRZO&1V|9G_b=gl{
zb|pV@9Sh@9|BtTk42bIZ-UcopNEKLmF9K2o0YL=;MFsaN_FgbHbT^g=R_=lk3nIou
z;~3Lyu_PKbF}7H+#}aE|H?|me#g5(RzR#I^my+NA^#jh%ojG&nv^jI8O-GRN4{YJO
z2czxqXHh#ead8iCA{xmxNY44QDALzjRhJxp4uD^I5L--fk?B}1&R4<2?h1O016D=N
z+}8{wuED&}Y?!!%XvRcD=FS%-M~}vueopzG?Zo#Pk4jAQW&MiP)|6k#^N-LTa7^I7
zIbYPRxJN3DGx9u@e4P_p-qhS5J$b$?E*s=KLvXDp<kj#kcOZ5xM{@B?+7o+M39xJ)
ziL4|Hm&l?ROW7R!?u6fP=p(xENz{w3d=ka*AL&WPo`_`Lf!q&ZCtEA^x>3Dy`NpcP
zm}28FAwnALLXm$;_$&%!!7?dvIr;oCk6?uAP-_KAVHv%P8(*1SF4A6e)wb5)?#+uu
zu8S`g#kn7pwDeALJNlkQ-yH_g_x2ZyB10X>%dg-F?T7lyfa;WNL?stqENbaSW6LIU
zypgQ5aUe}@qpj+65r-dtQ~|Hj(5DucisGH-;*-gc=zB6Y<x)`-Rad2a4Z8PJWl*l{
z_@$y?%b)4zlS@TD?)qu}#r$LX7JM0A$&zVU54&6xnl>JVXvo<2?^a{!QM|NWo(%t3
z-qgPVdD-Q~Hj1CzUMad5*~(&c<>jJDR(QV_Thdam6oq7_?Z$}L2sE;+AchrSss7jp
zRzw&c&9I(J@=<_G<gXi5Q((?<1y&`<$B(4QW5u#7Soyuv5_q1vQiR=rt=j<(&H(HP
z<YbP9bPHE8KT00*m_=MInr8WLI?ArO3O~m!oOxd>3b6ROjJ3LkV8R$^(D-Xb4}=kj
z*bMorXo~Q(hn8LYtEiLf{*U2M=mAmjqWaB6fa!XXuP^~623#)+jUGVKVGr>y7)y6j
zVcF$(T&;|1b+_2lcu@trwf=fhL?cgp<Yt;58vhB|cdi$OCscMPCT3x1h5Dz!N!`1p
zF$jV;p)n40vX#eyIBpDkgr*o(eY$B``VFjmrVnLfZ(ws>E=<JQ8%2YJ!}wx*v#7Cc
zrzCl?KaM%R+T@uRjRAw6xJZE)?o|33dY}k<5$zJeonJEw(3hLY#{&fn$@56cP7RR&
zs|Ulll2oK2$b_HIh7!hUG5p8ua)f(sVyfv?pk;sEEQ%~{_k62q3%55e(5&i1`@e}r
z`c{54A&3sGiorAJr8HYQj1keP(4Rh|YpoFXz{3uzYFJ^u>D#F9GsK)G4|U?^GRku%
zAm~2B6F1E8?cQgeZ3XhbqTYyxHNNTsw%}G#sQbla5)s*|DpK;`V}u!R6^%*S0xs@F
zA1#&f^N()m8o3GKm=MBA#U^kn;aMvQO=iK7yp2WDE5o(h*557~ZjL()T686s64wKx
z9Jm%?BXeyDSw{>>3pf=Abb?L21GjzbI4zrVrzqCF^*Bfb!B!>`=t2~}ow$Sj%bGka
zZ{I;^FynKPB0I3mkO6GFn+kjy6F&Hf-|3Jlj&U>^!xAh8qRJFLCeiTz9g=L)-J;Oo
zzGLdQ1y{X2vWPG@07-xIXSVxpQ2^Y4=2%XzIno9Ok{d8}S3Ng?kJaUAJ$NqMfRIJ9
zU4I6Y;0B~3UvUGDCIf+{`Xc|Jy&*Kh%?rH<h%f+wHsA_=QsemfByJQNqsOMzbK|va
zi@s>I#lvzIXebJa?K=QM(GypA$t7zCmeqL9*YLf3W7@NwWYuFal^Sm-@=*1FK%4Fa
zBwFEqGDzpwh9ZB*C*_#gEaZ6;;h7&b6vc$U*Pyr$86i-E$gE$5QdK!dRdf-0Le9ET
zzkCYwyN4;oHVqac7q@baF$ZEKxa0I2=gJ=K-TNekXJ7_#>=u7(-D*5Qdar0f#EFkc
zu;0-clrt0mV=As2Rl^}`;AO#Swr_E3*UZaUX3VBGvO)vNAi(*yiYcU}0x}fx(X0&Q
zeX*Gw96t7lWQat%fWTqp+7vdgswmujR+1dwTuaQs7#W9q#M`6iRYez_x{o5+GU`{}
z+X`PCp7{Nupm4kKgyl1w(G<&L=}qZ|h1xoAN^|4<Eok@ZevxnA?d?$*1D|saMlR2s
z@*adMf2(BB1Q}J15u949-#5y5;)z}=Rbh2?wVV+Fok>U}ENO;8SEe>;2Q7P0)YYYV
zJ|Xy0Kg&=vrks9I<ZXFA0<qVJ4~lf=LSB}ZjeUghbaIw<oAYyo;MwuVh(F(NgCXp7
zQNXsQ&x_p5nfp`ZEzi_$i+x&@Z7%f6&~BSjU8FG=^sNyHeunycTl4z(SdfNb_6s;!
zRpr`kMK6l9=EC2tw5;kSO8wf()JliffH<zDb{kqjrLYzVs=R?E{A9Lv+r>9UUCf15
z$yh%67Yl*Cj%{P3{>6%LA`<14a6w`NB_1E$#!mfP6l8beD2~YC;TuEn6E^<eA`iRo
zO&O_A@jyH>=9n_t$r-{3)b0BYK(dgSMu}h~zJ7;YQtyA;#`Yn{?&@y}*neKgP<EO!
z9?2OEmzXl#*^}xlR~G15Y-ROcUjPW|_W;!eiLvhiJQj&hk#M#*)tCwOBe|)3k8RP1
zJfQ1NMudslyk*hGqK+05ZP{dFQKW_1maQ}vJ+-*-`g10Aw6L@J{I(QneuFufOVJiT
zH(;&Ir6`M84OqUpG{j=%D|XymYHxmpxmZXs7BR1I#zpFB(aV}Gv5<l+60F&;7SaTZ
z)-PF{AVmvHFzO8!q=OD;x{|J5*9V>3ibIrfmeK$ivsqZ+ubI>Irb*FOt0stO)S1(?
zh9?iBWyy14%qC2djaejxVawC*BcP%fvpxan;B`yM(@WKWjG0JJK`T#A=RxHrxr}1Y
zR#Jq}!+R8KWhKQId-lX|IvryPr2VVgbx@gvJfPAC!0VvWjAn-AY0Y>pP$`3vpxa|}
z2ts+9cP%RYfJ%0meJH(sZSx^%cG*pn=0{nZkc+5`T}2}~J3qT(Ug&mSMZUkk$ZHfE
z|3RiJQ`<>)89)KRxGRD!RfvA}Ko_<mHk;jQAx#dPW|?!7ZME}Oo&J=g0Q$2U%TeR4
zB{#cos9)&88aO8lkdcmz?225NFjWhGLfuV9eLQdN7Fh%sEma#U!m$U@6-PQL1-hzM
zIgeriHj;|HvX(-G@t&iYe*-CANb0U--5N;kaA)zfn{{xZZOFhS_iK124J5ZFnEG>E
z@-Zq9HU05Dr=mSv*)#`yQ_$M)3+6s-0Ond-{$EJsJ8>kkg)om%Y_tv9H+036$3{wT
z@+BGkofw$udfd&JWf|}Sn;E?|{+4?HX?u8yB~!JmfvprMs6;JmVk<>QpNz$>fHFL^
zG1ex>c#s~x#>Ej7UBr(0J{YfUKplQWP=yKV$F|b7;%gnjjeK}&^!x-~#K2zN45yh%
zGDnvDRfh^e$O9EZF$Jk3VFHybPkWDf7pKWg*m|N#HSwW5?H`IC$P@S#Uc@Gh*YpK%
z<lVskGuU4ZC08#WbCZD8l`qL&k^X*evh*kU=VDxKLv;9<fMB0Jz~f4>$ugy0!Og7F
z%sg5!5}*3<PnMIh1JzDyC%ARQ)=4|5Meyln=x`UB^T|he*TP+{I*AHnmk_KWlMp?%
zmpp}8U`AhiDK1%)qcx*bz1bLwG9Ei^YA7G=U4M+`DmbA{6UlG_V!*A$eL;qR5+DZ?
zW-nC;7n*2U7YC_LY`=IKcU~AWiPY3Gya2cZ<Q|q?tU3;%d<AvlTQ~;8Wvg_M+<Ye=
zMH4cX&tZ$`^l(pbQJ%Lvc95ESZ3rWrkD&Fv&S+DaTnz4y^;Jg+>#Jdyhd4^jahv$U
znexyWh@o-+wKiz=E>{UW2OEO0vZIt>@$)=Z<tPOvecBvt&=eLo7+|U4rM_g|J0tGV
zBzK0c${dfMWEZ`DBkx4$O&DQ2f|InNr4eY>y^@ZB9^9E6K<3HWYN3jIl5`*4G&xC5
zWge0&+*$g;!uwbDhqE+62&;a^IyQol?zEFFZzT0|e*(^9Cx_yt^20#0dSe~h1)N$L
zq-D`a#IOC|LTSK`Bj7?hig^QWOeuTFUwiL|YK1ORwqS%VRJuq<-G_Fr-w5u!d({&=
zbzCJs!8uUN_PR>VT&o}sRgUpjKmmTq-IW|Ivvia45=E0E1@{Wn<MS=6gpqVd8+WCW
z+FS(L$-h&aCZnI0Epe07?QA>2b=w__-tjK(rIg~0FNU$?`2U4<8<1+aGbf-wlA@d>
z0>&fBB2-d4Yp6sh;`<X+Qs3rg{-|3aD;nVdTWPhvV-1!`Kb|LiOwl3k$9?XrWftyI
z|6-O7EivHH1$paX3^2l*>K(|sJTy$hAdS^=!%+NRm7~Z-oW500c&+H4v%b-7XeT6O
zUFB9It`b#(AqbvimluTQBR&o2a>={5<dVfGsQ_};pS^|4yr}+Y<ktGU?6JG#ms??F
zbr!Xiu;Pr5WUCZ3A5vI*MTVDbmEIyo!mZL%OgPCZWg%ZIPr6O9lM1U{jv(6r4=Gk~
znN!UwJiz7;p5?O*9+Iz6EsSC(JfwIBUKA@5MwJBruc4>p10w$!1R_UyO3^m+NC7k8
z!VmV8nhGP}=Y8slF~uerL4QxFPx04f)yBF3z|v6K;EcxapEC8r!fAGAd4$PBjJr-R
zlpttJo{O>X(g$)c0#O>h2u3~tdD)U(#YuaD3%go^|I@&)Y|Wo3*=)X-<lgMnOdwJA
zRp>ZAdf=S^DoR!O@1#36fIy7fN#_8Js>q>QcHT?Mw7%8~QZS4yuUhNI;=Lsggwrj2
z<(X*&??uwxGc_{3NZCvt;R*NITS^sj;Nkx0Ep@lXSwDZ!tAUTy$)=3x)fPeh0X|YI
zcmD>|@&L4qC_1s+sOmOE%QpB(&4orSwd@}sDOq^*D4zxTO76leV?Jx)3wLN562p9@
zEa%xofi0oSINGN`eDg!YU0Lf5-R$fpD?uc8c+od~;n&?w(K2U0&c0K=KquZ$>L!dw
z<}5#{b+~5+x_Xb~Zsrx5PI+cQC%HZ4e>iIE)!J=Ueo|j^;kOLzr3;XP1p8Di(*#J-
zJ_BJiDWEovR#$MTxoqaKq5~`SQ-IW3IEct>b%3<cy>%}bkXVi#>=?Hp{gbdv7AScO
z{t;TXBT$+o3>ctg2|-dzN8^03j*JFQW(?M{X+hEmK{KqH{T(FzhC{<zwlNsex(?kq
z87$?hF3{-K4~^%{IP{8}$xa9`H4BkOIYrVKMR({ylw&Y31RiMR#`c7Oz{YsYy+U9K
zw;<6rRO)My{*rwYD)kxiA{F*L1JqT_(R@&ao1>YK6zD5#&xLpNN@7MFlDp(2#jcmj
zNit5ec#<{<I+ad@8zWYPH9h1CzQts_d$8VN(x*aJ<a1UPCedPA3uk#T4S}nq&4*+I
z706|c-wg7By_O|4mga^gH6?m~6}pVRfn^zD`Kr(*_>nW?pbcRAxq`*F8%te<%2+K+
z4woW}hhcaS%hreXfz;DmKeUKXagcnj1y-M9t3*wh;vd=l`~p$bItuw4d9CGX6L>BZ
z@?%)%(n@MM11&q1Zo+pQhUkv(P|N}E>E<Ll#tff&ass;^E_pZjc}z8UbC7-NA$bYa
zw-swsTAfeUrb*B+x&<a}Gerq#859>OfT3ihE75?yMF;HEi-4z?7Ncc5Bcvq33W=u?
zQVZc|G&Vj(N<N*sg9y~BCz*a((P_G0VRbAF+br+_ljC`zq%q{)n}UQ%4fo5m#wI1S
z$7yYDi(Pq<5Zyq)z7Q#O5Y9(wSx^%xTv(5Ux``Aj4EM*vauX?7$U_cm0!PaeiR)D6
zAzUBZC?pOdkr0J4#TfAVM8Pj<uf}<fDClGdeA*O6IvLi~5ez#MCG{3gL}HQ~4dt5L
zQOk0prF3Bgaz2fg{KLb1L5;HOReCy~+65%3fAcvP_#hNMA1$>PE<!svCO;yP6C*Ws
zEl7koN02y^BaHhCp}plXP`6_cE2~(k*fl=^C9-Qvn8AjzSZS>NVrzt7a9>gE+O0<B
z(o{-u`S@x+1Rpm86YHHFhF;BQ1DZ;D*R}BU_U6@s$bbRr9VdMVGuYe~eLNN?4T7Kt
zTh*=_@BLLKJ~5ey4`o-IYnd1inhyyD7viOn!pjit;$~8C;8a(r_&mUuBdUZfB0b2g
znu_a0QLRlgDb^*LGBV-TuKb8Bt{=SFkEwP_6!LK=x+>R@kNkZ>5OC~Q$6a+aaC@h*
zgUzI79`A$Eh9`HK_$_u^`j$6i4hd4Mg?ScBOOS#s-lel439uS!jCJerLGVW6T7uLh
z@&TaM+<><hozgFiN0f}TU%3{K1}nWTp2a0f?p`DCF}r*hf5Bbf_Yi62UHy|4AoSow
z>BH6$fL8PQ+(G%X2A=`TKnqFuA9sg&<`_>FG|H(MjDW6DAGPlpzF)7p$4*5^f&GpJ
z!ij%Sk{XKFL~!EH%+LmZaN%VfnS^M(I(RV0cuJmDh!qnMVZul>5hN7Ls;ll8Rp(HS
zFrRV28RZHZp-dpk=zsX_87obanuN3me8Ww23c+u=ER}Pqfo1KA^8`s!gwNXmS)Vxp
zRyPGzCh=NPaa!iqTxt@vRVlCxeAN#@0l1pbe@?}xY2;yHPd-tvT~juyxfGHWctEDe
z_GO$RG9$l)LBb-EVH1~*3K&a5pYwRZ4gTJ%o&3@zL~XW{mYr@c`DKoDLMP-M)>(CH
zOv(hBKXXXYrhJ@^1qJn~srW=uYV5da3Ja7h`M6DkcZaqK(Pj9eznyMw#+;+1z@d}i
zk!F-Wz*`0QW<#Bb*@u$}rn?f!TIua#Nf_kNH{YqipQV+XXh43WNl<Q~DhbNeZ)qAb
z3^QN8&H6^NG)!31x|(%Jk=h4E)VjOVx5!F12RJDnxZ$;i{g@(U#aj50U7-h32;=_r
z#xN1fM!!6otm$=qi*I<iuoPc0waeJ8)>z@On)3;4({6S5e(OeIMl|D~v$8Q^AS$PI
zz7OkPp?dL8zS*8=R5Gfr_z;R_@?$Fe+PVxpSe0G&7VjZF`jMiZ4fxnfQ)<5TrC*|!
zJ@`%SZ&l&<2$5*#qiSF8?U}L<I0S{V%dv~21KfItGBn1<uixM;3^<d|HsAg}y3u!#
zBZIjK)VDB!%Z{ppg{ep!I;sw}stCJ@{XdP)sRM)y@MfHksog9mRJAu-{BKW{4dOr*
z4pUFdpsWvoZ3YcndQRPfZ91m53aCg^@!9n!m=I8iq7@ttg9m0P=t)~ZeR)pp=UokE
zk<VR;{Mxr4H{AoKv45z&1$IgX-~I-OZ^)Btmtqp0>9n<jbDdF_LQ4R^9r<Aj(3kaq
zx)9La1k^?W>erQkGL)id!FTu{EV1G<{M`21#V6DrITdMdu{H%?2mxp6#2yqfRA5R&
zHPmvAb-aX~QX-1F8ILcua}q9cc_-AZgmqA0-S6rUVH$j^Rllp7Hps!`{BTJydvikV
z9i4KU%<W}9ny2m3bJ<8mo+2AVJTSb}Z0+BaCZ$?HoxV8%cwb@wICw(cR2YTCixX=9
zK7DQxtTz~E(5b6;IjjN5Q(#SZuLDbd1EG8NjQiO&!nR;tt+2V9B;+mJB=Mx$2f}8z
z7&}r<s(n)iq{=LuT2I(ws73e=p5)gAhJiaZK}&dE4#wm8tn#F~sk1jY;9&xvfhdFV
zq`HM*iA1YY>OctK-9=iKcS;@LGaT~_5|tgGZ4NFOQ>1#tc-&RE^px61XaJa-dbf!c
zI(uoE;gq^%uZpyQMZ~?JHZu3pi8nT=4-tH@@PCCU3W%75Xl6^fxy`(}bfvX6cOXPl
zPNTJmV{&Wl$9kd*on@fq{|C@t>qusG3mGULx~U`X%l`&YyE6c~_^1rD_!?MkSb|a{
zXSgwoB-0kaVIVLEAxRV<gob%aiO=u@CBFTPO6*WdY{y5#WJOj*8O8=)f+-~;h#t-G
zrB+sD!xR1=%X9s^|3er$!ijr#hFhNApJA$S7M5piirm41dcrW}Haf^HkNBHnc|M2y
z8Qe^a|0Dn|-dQldI}-QLa>h6RRJJ@mTasm%|6%+uAA<1%XRh}adLNO23d>Y*#LlTR
zVS7d|AW~>s%f#Zg#}XX{<5LzWw&yfvV<b=;kY8(iDsBQ-ZhHz2E4F918*uF;*S_@0
z|B6jr+mopPt#5lC-2hN-d+r>PffmOS(Er$;egKYmUz&`x4RN>}&5{f(k~#bsAq*^y
zDJ8fynyPSEu}1HC3B9b8Gye~3v_O8a=+E}jsu)*a8qzQlS$(>kMooF%_93xFz7ZW>
z5~4AfVw}M+v$}(n=~-bFRa<l>e_g1;N<SZp+d)!wsc<-n_Or`da6{|@SDGmN6rDgD
zKl4wRv|%`!et?)y7e`=az+v+=8bN7c0PA^t>25M|r>Rreuxu&Pb?i*~tV~EM9BisG
z&DgSROli9u$Y(bv<;QkrjX=#NXr@+@(cn=Y+R3OpPW;I&k;6uc*eF=qCCFF~lCfNb
z9hj|hB>#++uxS5_)Q24@MmjIFgaF|(HrZ2fm{=;KNUQEZ{ffbaV(<Mjipk$N1I1Me
zv%Zqqd6q|pzLKrNOh;13kL53?`InC|E%57zxtujR+O?w;?9lfDnf2q1xtG97E~!I>
z$1s*_E@5=(_fEs^TvA7c&GWa19h2Z7&>gu()vj=IQsDp%g{{h_6Fl7-VTycN9Vdii
zu`vI#IswZWlfITkfbYcHhJJ_@F+-t*k7f_{V!vNj+X#a(d|kY(4skYLPMzl)lN|aH
zH|(y!MYy#$pT%5J$NEJ&!nLQ%Vq0P!f4?#xjpHsnFl5bD=)vSG>Ilb*w2z>nc!=Am
zdeR&rpet(s;#_>)>4}CjjeJ4(x_-=Da@+cNQEz3pO14iu=|<n__vb)_a>`ERlwFXA
zt?aT3m~UeyP@X}PSbLG)q}~}w;!HslT)Xh~KN?VGJ&!_l!jwFMgs{92EGr6SQ5V#<
zLcSRy0T<M*u&u4j37C^k(t7MA`t~@^He6Jv3O3M#kr&lTj*o$q;RHkm_ith{`Ta$8
zNb-}*G|W0=TtSa3tPJP#@e7Md$^n}l_cWMB!5hV4QZrO;hq^d@h02y-W1oVb;N`YZ
zoXR}?bBr5RP4JW4*FHz_!_TNX4XasGVqqnT8ePbE6lKW)-8Y-a^#cmwo&@|=76GoP
z<I$T&$F!{RRds3t%?)!Ze(^-tvz)dbf)|OqT(ise;r*aD8nbq#e;4{?ZztUFuNd7~
zaa7Abzp9RNONR7-iu@%-EY%xTFT%C#(p7a>aoi=|apOha@rW~W$8D63ztU63`E=>`
z_Zl<9G=i*J3ZbNdY#4svK`b|OIV4qf7_Qwj>dny@Y=^*uNAW7)EAQs9(LdY6{a#$i
zO<i@zCwN3c7X0m!YwARFQ}-L9W7pKQ3DN_}(_N*xNX|KeAlP5(5G3=EyzrO0x7$fn
zMmvTnr1$hfdIg-aHrLhBEi2FS?tB6Uf{&+9%H0W6x-$nd#9s#E{`UufV)&5DK{)EK
zy{--_9xm74BG<3@PyHCwuZo8@%%cyG(>_Swu$Lzxc^Jlvu4RI;Dv8%C2<>B39kT&5
zAv)MUbLuTx|BAPFkdnK3^3zb6n1%Rt*r6?mspa`o;STn^p^gcjy8#lEgRMG5T>#Qg
zL59=Tf>8VHa+=gnZNgUFP)D}?1fo<YI|CO05f9eFzVbVDXl+M>GBkZ&`7!aJ0-rEH
z#NV1ltsW8y+>?WFMSDn?1X)c-azsyQuFEQjP*!<fHpy)uj)Wi#Y|%@~6Lval+3;Qn
z4@~j4XN!ADP25i)22ldc5G#Z2fJj1u58#ktbJ3L<dP$h?SY6q#{0`_X#W?2C5b!0e
zCjuN;wdvPe3TiX-EN5i1vz(E)j}apm@lC!8FC%V&7o#(`V&RVObT=a)%K-#gM%8|-
z=j`q+HOYT@hQnzu!};WY;q1CeBHj)wb~2oKFTomGj^XOAqhEOO(})6iyD(7Z75N>R
zhdY2*D><*?&{}REDWdq7=irq;Hpx2>(Q!Kf77+EzC=<5`td%o~NBnAV8@>BFGcy3@
zbgFVyPNzFVyY(WhI66XQ-N=mm8)gpueo^R2&<C5K@8Sf}2cR&iU9vY?g1yw|>WIB9
zPz+a~;V<8Ep(h<m+gORk!@g3S5Dkw@(^pDsWa-3*n5yYHW&avghY|4`Wl#sCSfA#E
z`|}iMz}DYL;BP6kKYd*>3$)0&^0~$gYn*e-4&m}F)UGtBgJYM5Li(^Z&%$1|0O-Pz
zUu69^77=m=yE?NNmUovUH+V00y4_W`6}s9W;C)w}>bU~gLtwEgH5yDPd(Lqjh(Keo
zULBUiPI4SaK;5A2gOAk3amZgarmOigFtG^rv7CvjMS68WScr_@(uOto4c;Q-$EFc}
z)A3;etCWdm+^uDLy*gR=#Q`lF)Xf|9K)-;OLNs@*t8t?B`kf;b_B%(Y`Qf?<1zxK|
zwCbm|MBD4bi53zQB;(Z0wgx8;gk?zObEk5K;zR8$()pe`399t<E-mYLj{+7}F-Y#b
zr!KM?1c!xmm3_LlYbZP7KHr(Y7y-5QfwmS^saFeca-XrV`|2?NHX&L_7C&xfle3$M
zgnz|_xCq^<cqcrJ`|5Cj?vCW5`|1?O8?a}Fv0PWbg9*5NU+t4_ILdpy{V4DC&Hd;#
z2G2M}ST<jRq82NP3V*bWAm~hrss@n62kP+R88VQwGLVJ;0iq@#Ua+u_4pCdG8E{SZ
zG={@rRCR&;)hICFn>_-zFPjwj=|lW_j$d4XcVTiyBiFhb1^$*R@G1`kR<ArzM--Pe
z1QUWVbXgG-_~E<~G^4)>9U~?7lJiMrZRmZF+T(k<sL8Wor=QEFS-XtuH(eck(^7$l
zEo=H!Kh|hB-Ymz}#eTAOtEyV#c+a-FMW>=D>Go4wItpmie_u$Fun0xqi{Njq*UV!T
zl@HZT!LI6UTK4RrIwJ{hN6nIbL)xXf3#KLWu(e=d2-SkY`;~8aT-j-MKfZXAHgO7M
z`4Iv<Kf+C-DL@p3b<5M0X>`>=_<_qFVaD5aT|Ns+`94-y@>0VdJyLrKZWcI1@mL)T
z1lDa;41Cwe>M)f*lwEf0FkoV2Fsdx!tCc?nl*3k9whm=lb`E%knFdTF2m-GLdm(6$
zmrH*SWh|N8#oB2`I*>Vx>mCFHg33_(w7rwG%;t&OPjG@DMLbc5TWlE2x(<`PEN`8L
zcRPJfKX-fOkVu6?@tS<L;E6i1X(eRFFa<K`v~@xrHh$RiJ=Sdy(%3AlH7{t4<D2H@
znPt5!L8M`8^VylFY8A72suqP57?9pi)iLPfpe;%tPuefGcPUH-dyJ~*267QF@0+=S
zEr=4`gjr}4)%{T68IDo%QP8?t-P8_i`Gv&A!GM@it#)_oWkELOy<r~CH{_7RpmNc&
z(bek4gF7GK3g&l!E7-(cvVxhs8uxSP%oh++$ca&<hs$Q@MoO&u1w$f9doq3;Zfj|7
zh(&^9dE6X2*qNX2Sb+J&qiS_%@$vn<5pTH>VNd-=7M@iUa6u(kz_+`hfKAY-QMCjr
z=7bv{Bb4ScWaUD8&5?r6jxC^mMq<WF*ch>m$It>_6wfeEzjq~cYm6gyf5FE@ZdEw`
z(9mZ|YScyVycFNz%FK~Ja}PwXUMssh6wKGZN1Ut53&-710&hyyEf<1vWJ3FoCB<on
zPu#a&oG+1_ZrO~*tLF$`Oh)8s>~n+|T`y_ayyxnU!ao9B<mc)n*VeBzToAG0tbo>T
zte<OG&<k}GsxRK8#ZeNe2uT%^XJ2qX^}$9hd-Fn_Ts#e}5l0_G(l|$3VtR#)L=5a|
z%Tfdf-rx&OrN_;|8X`zFZ7*j+$Gx1>ziyYAFitV0ZBKy-y*LL00ot&h8?QSUBg+nD
zlsq?w<>_EaI=dGi#4@(&rP{7thz#;08D#lR8KkoUvg#x;kAtlI8z9XfB3zDsqF-M4
zWmFYAXcxaytAvpl{XAc({rb;dEE_{3W*uM^*2QhA8Y%2_*6&zlW=2^EBoJ>#yUM&d
zi^4bwC|4mKj?;gFlEj-M8sg1ne8L|5S7bn9LVwh5JMc;!W!_;mWHqaNayAO$x$zg^
z1%x7x_63x1nct65oqGw7X!}VYOq=y@RnO3UT70KnU0t{v!jj&o!-Qt=dIr8x=fe~7
zTaQisZ`6Z@<99VI`mK6?u*=UhLobCI8sL}#GtBq?dJQuC!!>24Ee>_PRR<T}*vXl+
z5u}9Mk+P+}rmQ^%CUxO7oJo}*^U57DcGt4qTw!}4*p3C;wD~f`YcfQ~t@R=H0z_pF
z5p_dj7H6QS49Ct7KMfRoz&R}ptE66dtqZ<sduSiUn2f5kaHTf<tL{;3w+u{c1BVbK
zteFtJ_*Uk?du-LLYK>``{PAb=a$F5YuXZ8=gP8^~Y1*e|W~Eo;n<k0!`eUe*fw7K8
zurZGE@bu3J;^b+VS4@5Iw|019CGYrTHhvxUqrFpSKxOW))v~wm)G5M_)0%C~->ZYo
zh17pFtiMqm*vac(jahjgndw$fi0Qb{9IcWL;z4&XeNqD&*hmzxSPUfxzn<zxJ7W}~
zOojKDfsM7+vfqqY8(D#cum?tUd{Bke!PWAhxPwTCf5q7|e{(9uVi3^Iu+n~>E*=n`
z-qbKFbCC|rE%{C{+#i^WUidxI^n0PX7#ZihfyCxxAZ$2H7?xe<!I4YVz`E=&+H#pK
zzvWILlZCJ<_szwK<YQa75PbpZfe^L)vA$Y<b`V0;moIpa1sub77!!=DL{wH=h@k_<
z%9Z!Xl^blTUpX0-NnUW8$o?`a<Izf4r{BYi;?5A_P>^yG7jl&N*l>nR%N7jb$1TLZ
zT0I67k{0L3T*di7tUpJYEwHW%7mM^>3(3Hrj4V(bYXe20ll7IjqXA|Jfr&@@9_6xt
zkQL~I^+1xM(|IHyI|0C`+Je8_Ygr(OH0=ypiOXpOv4!97yTE+hGKwA5*wSm?YM~i8
zGcgE*@!RoQ=4&Y?2%k5^W?oA%y8W0d8tO>tT`n9}v&YMv<t~j4j?%(Mm@({sBfocS
zYZnYASYiprQVewU#O)3gA&j#mL35b58y>_MYcWc=w=kc5Wi7T9d~a!(#!3tj-u$Cs
z6;@(u*bI!f*%iA&e*=nSl=@(k2*#N^pma0YMF|?JWe=^yAR!FwbFmiVg&iHuS$k_S
z)bgWUrWPiArnK<g4Gp_xEhhS`rYS;JXg(;Qr5k$lh`@Om<DO|)d;>871p9Fee6<E*
zb0ph-tBB~f24Y9y_;wAmv=M`aG1VFtX(I*%m2M|Atqy%ClZU*)1{`DVj>V$bC>s&0
zQSk0Qu@Tb*Ge9_HBYFuZ(9tRz5kp*3)nF_f*@^*K>x?qZ$<}l#kLALFV_2l7@}w6Y
z-W~kHE+xc^5Ak^Mj7r$V^?W-8NZYgnJ7p`XT(dh6#c|;RR-1vI*ACF*C7KXk%+F_D
z4aJP0C`_9S?_e(}mcAET7C{QgTH2R`$f*c}a!+k2#uZms<!kD2egQa$AZQT^K^oiD
zjU#`EPZVP1aqjLIMoD_|kl9IzCIb1dNa|-Cj?1=^W8I|+-d0uZWPBfU+F3bnN4y72
zievxUir&J}3XXIPn_vge@7)y*n`<XVg?ao!wCAVcMe=VSW|!T=P)5plLlzOgftX6!
ziGE&b?__)?K;Jvz=%mc@*^e~L*<N&aJ)b2vFAJ#E^sOLQ3wsFY+IjhGq`lZ)xNup+
zHrb0UgdZMi*nNAkwXou64U2IQn_EUcv@>HP9mI%$&oR={BK#)mMR`ibFM{HE-@?S_
zDHhF3q=CY8Oo<#F#bgNA*Gm-P8t5px`X$0;s2WA=xCwSp{I(+PbU)&T3#><lqnPPC
z=mfD7hhwoXSU=<-%s}Y_9te8J6iDwJMRI`;_oaIIXe!xB^b<1fYglh5F*<S`_9+m6
z$Ixp1`UBX}!52x$!F8k{o)>=?=Nvq-^-f~r!S-voF}<>y8`DM0$R5h)=oB~S%vRuB
z%m?MwCs4luS$)+6j8J3*@0*O^Z6vraR7U#y5l$ByRh`jDyt5cQynHop<g(mIs}=v#
zNEb9hj<A^m_7bEPVImC0r)a#dNc*G@_0}9AWNOs~eK2qb5K{sE<*re~wxg-y5B9^*
zs&U^1f?V9M0x7{OeZSerPf&8`-c<eeMaaQ?HLkYg0-{+Z_Sw*U)l<%=Q9J@Y)6bER
z-+^?<1eaL!bRTl#;Y1)9hHu66u_~DU;3i3&#-s}&Q0yxhbow!e>I_B;1eQDCZQcL?
z_Emll0C+DAf9uv8hI-^BM577~0*kuQAfV%AC*yDJ5<xFo%64WK8;Olza9(2t`C%i`
zS6Bh5c5o5noyOb-f)A@!ls(6bzc5;zTtvU(f>oR`ZC7#byL|)3)P$;9Zy}!0n9MhD
z3>s(*vx7T@w|rn;i3?M~V?F?mM*>KbM?(Xa!)x>i5v)SESkxDw-*T>u{zqL2{Q>yE
z-5ZQj_=lH&9=nitkaTGw6vtJ}Deg%j${(;hi!AxRk|*%`+gjqh@|Nr}-_SX<Tvm}b
zbS1~V*-DPP&)0QvkNH`_ox*HpM*-ww)z=heI|18Twy#WIdbF^V<4$pTT3rB=8D-!R
z@SohJAz}FeLUlmxhO0<%fpb{xb#oJwgc<8KOmq`dgeBKBY_^-&1O{}-klL}q4fAXs
zDcA}jgJEu`eB;CF6y#x8E$i{W!)h;lGOfeMBkV@DwWFM;1Q4!#iw<J}%9*woc+z27
z+Fszy;#8uI@W+gN=IAA+Mc8AyX}Aa^$O2-{We=s#rXd8<w~XqP9X6_Rp_$867?t~O
z)Ubb4Vzltlc@0y!qg%!c8rH>KbQi|#$H?X`#t6;7*RU_jq|R=4z67cH;;0QK2RJ&D
zxK+d6mSI~_45oe`c!;6))-cU{vF-U84g1VPY>(-}{;t^l<^dbk@`;AM^ALkAuBEUb
zPtnUV=LcBf)}9d4pGxxCKu<9(<Q`0<ArOu~NH=C+opEUea0ls*bwPOAQ}lE1hk*tX
zF{w7dGV&`7!H+#fAHf{Zh!{ePlN#393-IqDhe8oei3}IXAS{RC(vK9{t+i^0$<Wqa
z1Zs{|(am0B3astsT(UnuywI>`UgA7tSnv!tWR!c0{T&aJw-^AUZd8@uLm_Xmaq&U8
z1Q@Uv64ffK7JV*TJ>r34TFZV=q!jOz?L++{?np*q$&A!%h{?3}K?3qFbS4yH6bo5`
zwhUw@p<z{B6_dgH@&m=&5DXi+@&ebt8bidp9gB4glcKs{jG(CaRJou@Li8=CleQZ5
z7JSX)rG9ia=|c~cf=$QY+NlZopo@J)Ogodd%tbuFSDYgZ`BTI8_(GDl-mzn^Kap|;
z-y<5P_7i<uJ}4q3&9uorl1Z_8GpF8_PK`1>#fqe%Wqjqs(yXAH9FVD)mQN9;EE?~1
z7?79yiK_nJ{NMG<qeB6rkqJbhm{V?@y#u_Ue>6cUXo(9{?t;SkXceVtKf29fGXZNY
zmf%g&`8n8j;V)|3;?O$^JAB6pi&^s{_;3sS#gOEvC7hXW7-y#IXT(e#oKrYiy$1HG
zD<A((pGP~hQ6DQksC>^~^c`@K@yg*#cxC;<`jwZVvJyxr+>OdLfrOFt%bPl(N`w}Z
zP#8@@@q){WA6obzKn(5Id@S!6#d>}?M{MVN8a?%6Fld?B9ef|`MyO{l3ShEcw^#=h
zqhY2vi#R<BpK7D!Hvk{}MKqMz28tbB`~FD-2@GY`cYFoW>yCzv2o%Qz{kaHB*%a8?
zYllBZ)%GgcdCTJ_XFoQ|Jr9I@OxmYmB|#$gIaz(w1D8+*iMz5AU^dG0vjG%`)?fj$
z%jI#C*K|BWOnFI@)nx!o56hN6sD`)kl1~z`Y>vwVZfn?g!D6Uz0DjPkV6mOE@Uw=N
zdWYf2QH3AwpJhQI;sosB^2dqnFG56L?_xMAAZh6n@-S*P4BC7KBXTN4^cMmO^V#DN
zF|l{v0kDD2-;(1dQE4n!wj*U6bYJGmP_T#}`oWi}bMtW)=ny7%c%0)7d8!!ufIp^`
z$(TtPtT;a{F-4vhDtbG5oI&0TK1aQZ`OC^sF{XthaDd?$2qA;vXg*&Smpnz*&M)Uy
zqnuAa)@?&|+NOhDxu|X%CU$NA(<JcO6MO1@CtG}ghas}5xITN7EDbcp6#pSoUe_ON
zO)UQrWwFkNzb21@EeqoVpX+oj`y)*JNH~97!*UvnEx@<D62%u?+E^SYeEo-py=e@8
zxpb9=wF<{vXx0xJHe{((Dy%_(NFUDO9M>sznns8oK7-&~7#3obqJc!2r3S#{Z|#JG
zc@bjchQrY@&|nsRe~Jo-YXxT_91{V?j6z3GMu=X{stEGw<sBIgUt%aJYa&Jn560%R
zEltEkuh>0k<1jQnd&X-->6^gNV*pu@fpBFcMx(XYHSCi}(bKtScr6&Kr6w>j3Yey2
zNDB)929@_?mnDS?>&}X>IA1exKmAL?+BFfwEIw<@v`sL=ZT!Lnum2bst<bM_LDr)~
zxsPxJbxEqm%Tjd{TelGCfI`_v!GON{R>L|(fx??mmj}{!MTvCx(3`0;Ef+_N;l(rI
z-Wa~&Lr+JDTWzT9N96HWY7i=OhGfp4D~lBb6k;{MR2D1KhJ{{B0cJhdFDPNeCK$AG
zZqULA{u2)W-bIaBX4%2al4rF6Q?@!<Y!n$T!=5O^E}m5%_M<NVEgRQUU(~Q0(V|=L
zIRHfFECGTq`}vVb0mln-2uGDC0PINyGI$d67cTA<X{)fk%cvqZmTJyHdBZ<4*>>_T
zJzxUVF=C6xzm10cBLK7MkUaiPRYu3tfT#a~K87KObt!G_5k-#vB)J^;icJDWy*>{m
zl4w|U;1y}Nb12L!+Z!c@FsE42w$C+`fY0xTinwl1u1@ZjjsEf&5(dlA90UMu=#B<w
zoN2+n`@6<2f#koxNg{3g8(}5{Nb$G+P|C)|ib3$0x=zN?hFEc+-HyW`9K)I_ytDVQ
zqEGRm*_?-qW^*21n_i#J6^zrW>^ix<c^kOf%gF7G#-Jp-y|UYmFejGa$H8nUJ8Nw8
zUwkOrgENVQ;jgfHwYbUK=Q4X{vL!2|DDRxtm|=&8(gQDjb8tG^)2skv-(CI9@$A|P
z$wyeVOv3^uF7jdSD<zr)e~vq@x~-JDAen*Wnw3&hi*p)wai!EBSsM!#!=PTpcQ{Nj
z{hq!`O0#IqSmi1yQ&@NuahdO=GGXtp7?Hn|nh6c(YuKUhq!i)Q5zXS&(jbfX+gRRe
zDNN{4p<#1YOB03jut(-=a9-y7c^VeB2B&h`9<gKM8mXl)>n9B>TO*}JyzR>u8p%lV
zH4|t3>+^KgCig&PR}t$L2m~0`pl8lIG_1i|DWuWIl~4*Vl3v;~k#!n|Z><#BX6kg#
zo*eK6D)#*}V$Y(`5(u7Rywg7gLp92hE^Zz3AUJeU5QlT=l!mQdD@7GM$Z!V8aC-hP
zoU;o|g8+bhw;DkDk^;$t!sqn67{4)z!MX>j3#nHomjA$YfBqpy`Ouz!pq)smNFlmS
zHh^_mC#l>fErXbw7HVlmp}(_*O<9N2NiV<9u+tK5SwFN+^0v6vo83hDc=r)CYqJU|
z5B>q-^1T<SI0_ECS9e|b?r=8#$JT+7kRSbKM94|^UPqJg-Tsx-;~M_fiXd&oSkP3Y
zEo#YQvBjyWNaA!0VZ5+7u~>*WRn6AKiG{+Aoz*NL9@CeNn7*XMi$7Q%g}=h4#)*MW
zU5P$jXsshczvK66=H5&!wtzRnnqly|@Czienb<`rMItIeOb7&PvdYJ0V^lhUebL$F
zv{AG`Bt6FsN-ZiiOqU?G#q2LL82d!F*4uH(_k~wDgyV~8$E5~iE9NUR0M40bM<|ef
z+KZ8n!hJOnGm03Xm^tDd6yc*I9yBz5oXLNd@SixsM*o+wj6`(y{D6GcH&IM%RAE&Z
zL~Y{Mn!j*oImY2{62(Z1JsNg2QH-VkUnh!<bFOWzHm2G;&2&=ciRjQ&_)FPV%Q(;@
zbXV1K44-SwF*ZRJ47Mmp1C^&d7x@m`d2k6AlsG>LA?4*4tJyb6oH>!B6m5QzB+`DR
z>U`yQcyqB3zemWwQ+ii@4IvF93k0h_mev8LfDi^;S&7c3^(y4!z<GSw6AhdYIbVsd
zh4i)TE%7lB1|Cr(xG;tl{L%t!W*d80!{U;~g!C^baXlP8iR<Cp@v<IL=M+86n+<4)
zyns~Pk4gb3!(_lQs@@&auocN-Z1-3hh$I7f@zMVPsh)*O6&$<YzCtpE`(dABJRp@L
zQYk9uz&{iLa7c<6G}?0vfpRbuqH{ikLq*!;3GES#!q(bl_zlzHAQ$<EiulPz#-Rv&
zU);oiW}WQjl$y%E{xILHYGZ9(bJVTEGS8EPbcjbxADTV@iX4X-;ZH=b1KAbI`J-^k
z4@WdW&aYzwcXu*HsEE?~J;#Xb*Y(XqNIe5l98ZhkZ>@T=xGhoyPA<$Hj#WY=Enm)o
z)-Cv8yeC_}MG9~9H>67}yHzy{$K&x3*Z~c@v_%R`yi>sWw55RaX&|^wvnrEIvY}KN
z&ag%V@1$xL_VA)+%rBCE()6Ri9kU$+9F>}3dVN1KBQN!T2N9kp@u?O=zFboB3*V&|
zKMaSPTZnnW;)B)9&_Wz64BJ%A)GftGOmtdf(P2tUG0yGWW_dDr9Ngn;(4WCp>~4v(
zp}&8`(f$e|0bUIR{cFQ!>|<a$64c5rI|szD>aaw^8nr@HI~>&`T8Y8E{KoR?3n7-M
z{?#bCI&A{R&045V=MHP4X<_gYDVkRCquf!9v)%g0-JBah-7LTd-nrA;_`>|(LvS(Q
zcBwOz?NcOsZI^mFb=_%4Ta|bqIR=@Vx8Y*pliMX)l6#w{XsB_!6z3*wlsmoO)alf{
z8rF7))Hu0t9LG9q9LL&EBlF5M15PVJx8((PZ-6lTz(xK#49>D0Qczz%xw2NSd~J07
z%6E#X)7;zK`8g_6R2i=UQPKk`Jd6QbL^^c{ANaP}UA)9_fcM@h1^2)`|FR}mxhTTm
zso&L8$>S3s{f7rZN6dczM9>90O7XX*<Yy>JVsp%w=(&ZWG65ObtJ8`*WARwKIot{p
zi*GQZJZUAy+bxA>RkZ|z>uv~Rs_2)xY78gM1SlRDT0{)3BgR@C^^PP0u3-PnL79UQ
zN=;rwXxIXRV~6kkqf-vZ;=Jtp8ocm&PY)TdFMSBFnfN4cZa$sL5i=izy{4(6#;*T*
z;8TXn;dW`5Hcj+tIr2k}Pjd(+@adgjAD^a@f)9C#77MwTIE%c*lW?u}rHO$7t-8zl
zKEazB9=NW)9@S9h%m6KO-wn6wgKY@Vr2gp1dhV72ic>&9M4A^-r1{^Sl&;xh(cTS1
z;1WJ5$(W<%vyxOT$JI{Dam^Z8A6Ltw8eGY6{0aA|>>h%-Wo3slY2*7>fS*<N#^l?M
zfUvOY-IA)s!AhB+(QE4v^ifxtpy6KBuSWQ^Ad|<<5qWqYk1Y33psTG#(RDCJo4py(
zNaaBEOT<9OwHDi^?cl~&5gqvZ5FH%Gv@66-n%MKue=-kM=-YZy12G8f!0(~(PCyA@
znX$mV<PfKo_ro<0d!<MVEEUe)ixb(Wroy4xE46G_VPz9p<7*U<hY*24IyAgwJNAX*
z4opmvd0t;2h(IejGZ?%>mSJLc*xI_v5`V2&W^!u}Hlk7rA6Aj%M~5r7wy!&5r6vFD
z^45GAZx+0)(n`1&&#{HeskAo;D3%8*jU0ubWBvlygc_&ix;&Je79pqek<KW<{PsyD
zj-?no<}>GgQh2uts|f(bT@V~TNXOLAa17c?-h*sZo?*P}f+9v$%l*_iw%6lgB{XbU
zfpX9jETw^FhO?O6VZS|M%w_v<`%Y3m7ZgiKGlaV5PzXxRT7_|vA|`n3tO8ZP;pSmE
zs{XZ4@=rXyOSYjYt7Kt-4Sk0Zj&wdrMVt!2hq^;W7I^izwKz&xIa9+1q>GJvUtVp8
z^4J)I(<NBzv%}cJ?bT19JP&v;M@MN+@3d8*!z459KrsW(2g|WIE0@MHTlql~Ix>uC
zg1a~NNu?tc@g8#UI$aEQULHxL6+<)N9)uEUqcRY@o|&D`I%bHm!imL*8X?C?%E<>@
zT&#tAA%-JhwK_xW-r-j$2TV*p9kw0F%?yV6v}@RXj)$_~Taf|%9fUFDfvzOM7}2k{
zm&tI!g~+fEp``_^%e&4agu}m7vmNg`j}qoCuV!KIJNFTcTdG;f`_8_?=?xn8?fcHz
z!l7l=?B4s%!98Anz*%$V1I`+kJd+ONF+Q|CdV<CbAqXIwc2X|5RxW7%pMsevSQ~fD
zGj{GJ9R3+-7(0u?ns2K=x5*6+F%02NZ63m#3LY#=f!vVz5ouZmJJmzPF2k_qxUbH<
zr<fyjgGb+~r#MbX$HcU<Cx+rzSoXNkQw(n!CxbHr6A0Ckz9!70IOea$kyt@YKrQUb
znFVv-OKdDmLG50>#E`}-f02!h9emlEi8OXr<HvQqwIh-A@mCs_dsK>c8FKj^zboqc
z4zpuRTj_5NvSt-WrD?DRmveEy^f9T0{WowpM&K%ihxRz(-|d*B74~4hx$hWmnh5()
z!z_+Vv~^)aXJx$ZbR2gKT);$j$#Il8IRie`aVgFIJ;^el_}c+W@Cj*q@n?XWji3bW
zO0uC##|v@K0c{Ul=dlffaGw7F{(4&sI5_QX_?XXr2hj1Qw2T2naMdi3W)Bn}{QMQJ
zodHi~P%mMezQnI1r~q{)!_T+V$;)+4rRN9`>-)Q8-(d=e<FIxBr*w;cGNnzM=`yu|
zk|e{7f1#iIM85S1n=NKmkjS<Nd|cHw0jt)(OJfteLj4F)IzkN`=K`8h<wi4vIY5!l
z*b{0)rz69STah@}@7$BPsK*_nC@I2qV8#~!&-1>jtN{XyhJGWM4E|P}lzhT{(P^V<
z@d^yDpjg^F{&O~dVmJo@`@}ymsw#EZ?r{<~B$c4nqm#J2q!c-JrzAhmEI2~6e4krY
zjES!)46kd(GEPYz`6_&s+3*8~C0esSx0uF@-|<)3W#+73kO49y#FA}R(1Z#ji1rS{
zH=T?6j+g#cE{#iMl*^p|!e^RFFK$5MR|1Q%_mt%21FJ~(+Y@_Y0tpaeQtxSPB@0u;
z>QlISWaw}AnD1#RG$Qpk2x_Lj5aCj+kJy+O`X6p<ZobL9DhQj$^sT#Dn^lGAle<~7
z{L@m5U9Htz@cFWt{tdA!1--Hg$iddJ(^4+tw$-B&neQ1X56SsRPCp|J!r?L@Tg(1F
zBQ<gS1|3km#i6S;%=fJ16S}51SMu|{xvWg;QC};^jwA-KcwMfmZFBS%myDz0q_a|R
z<B+DZLVgLare=&DlqTD_#g?2R3qg^yQXgp2aV!P+o|EG2m%tMsmC*}OnLg(vjj&^r
zh8;dfSG){E#ODvG8H%rKrzl?6Kco@(9cB7`>JMDKv;jl-n?Iyj_xn%?0%mVP*G?QM
znQUY3G_#mFFD+KF?tkJ=l@)6>xEEeZu)K=LA(-WPDHXt0v{iujIWM^gEvIPMhv%iN
z^tSMfX&+p^ST@ZjzH*L0ddzQskR6UMF;L=ihTkCdb<BRdcpUl-GrmY<kIzezBL$rd
z%Xrwwaydqj3sPXaw%s_1KkCLw+&@>gqq5m^_yFbK0wm-J%Gm2J?+9JNFjE6<GWhb*
zwZkX`b1z8Uid#~+X&F91e{kOfhGIhiw+HbU8%fuS@JrrU`4P|eQu66N8#(_fN6uWy
z{}ZsdZk|8_de^rzCbSKZNI?P*m@k0>;FN{x60jD_0?;lTjp5&MwZyX=bkTJ`l5tFV
zzx@u5)kVp-%d!GgiiMG@io_q%MH>Bg!lG3TMg}U`hZgc1HOPYCYy`kjY@iQpW}Y7J
z2%1$T;}9~`2wU*+mp#!JyT$pU6iv?lo=57%cM+^>&JCmf=DS~@f5-8mj*8&$sx(|U
zG7+mHm!y_pdu6)9_Li3=Y%}niemaqjxh%P3SXg{4k(FJRS~|Vvz#s9ouxpZroxLoj
z;QPhac%9>lv`Cmf08zs$QjGA$3JuFhZtck)UXga8L`oVC0A59joBcGb{WX+$jRBCC
zn14-5_Bk>ZSl4$L;;&#i)ah{|yKzmL?%Z}fcu8D}zk=OEOEql#Uy{GG-(2KURETnK
zAQbrRUs6zKe>E4VPHHYti?i$N>_7cb2j}W=X$xNp+lrCZ&=BlZe*aj8-z)fUqiQ^0
zI$oE8x^3*pVgA*T!+hDHKFmo36HC-4m>mdaE665Y43icK3}8}8^cgQ>RK3SceEN0C
zqxf$~5DDf(G>BuE*k<&%ENREl1g6@kRMi78=JB68`q>Wh_B%i#&doz>ncpB2H;kyZ
z*U5~gOdsC-fE+?y<qZhRuz8`71QaW?kD12}$;qxg748SR!mWtEA*nJZ20_SDP(YT>
zNBZHEfgSw^tLPpcl4#t!qFA`2Gs(g!ne&hte}(;cP4Y;1gpm}Rja_JsJFt9QAPI4V
z-WH%JME~gvlFDhQjFB6El?mkyDPJfUi{RO%;>K*qP00<S`C*D8niV&tIK)L_jwZ7G
zHzisNPCSsvs%}axoR$Ct_{l}H2vVJJi$pVN5)N38yCp3Yf_iG0^=&CiX!WIrCEk`g
z3-_|}+05HG{kR6^Lw}osMoDLrv`qE4G+&tB9g_Svihl_S_~UP>AB1?9K9MEdk%}{)
zjsh$75Jp%x9Pj>2X5k@ZP*+n9XMl~{<j=I;qB{05$`?aSdHH#tVVt`o1?3)V%Vp|y
zTP{=HZR#4nMcq+__MVafB^X1gO%-Irl+llXZjm#LDqjE{`i~S;+)oBtCIkH-vo6q3
z0=gd}Xo69lkBoM*=Q0vSIet1)s;}fyScrwlk${flmNP39T^nB06Xn}8F1-9(u|XE!
zj(~=}0svLj6XIK)K|jOjXM4zE0lvyp7@T#%s7vQ@RfFqflK)ZV3v^J|q79ed5`a+T
zR~jSB?;&n0Gq;%+YWSS@!D7u|v#LBCnn9eS%AyKlc?dA7I^%y?lJDxhy&=iCeYYmV
zmNNX2K^w0`vcj;U1puIAwLlgD!SdW7xKlUpN<N7ThSN!Hqb%B<<>PQ6932E-=S8CZ
zNFV=*MB4{2>Kfd<Z6mrnRiw@CmIwoV8>3>y@Cf#qUYacgzBDp%`w0IL%@Aj*63Bd$
zU!-4%59GhUeL(Q;PymA7PBMlC!@ksl&MteLUGC(x)fPlt)(*rfcRL2U?WW|=#80x#
z-_x`(Ov*JWS=|1wyhGcO)D57ykY8)a42<nKWZ_D`9oAX+&mj<*%yFRTRord_H_j;t
z7#*l>70V#m<>|(->s<+K3FHOcszu~R6rjk61pNn*-#aUa)Ggm7wx+y!{qn_OUz;k(
zArjB*a>O2ReQFl4#ynyN_NIaE81X~PfoX+01HH(F)L<SpH!I(4r>*JxACUKwY3<Dl
zf>8>Bm^4%_wF;%UQQK*SqDIwvUM|bLFbvm;X<%@ZGUS3^)f8;N`+ErsqA1Jj8dZD1
zAtkbQ0JBH13frZLB>dLyilitR$OQsYc5|mS2XO@N!l^Z8eGl+RUq-$do>0hJ8GvoZ
z6-mc3sUK+;$b!gh<-cMULA!yJbcEiVa9D&)wlrT1DmFmmfIwc20|uaG^@!%s=YNQ{
z1p^+)5eR_SGdR(_0lt=K!{FqWObeBX7K&2Ua;Zd)1V#ddXsILNA(l)Fld0Ai1y9Qb
zqiYJ*5UmklDn#o%?Y~6hV$~bA!X#ECW~bnKD8G$iQ{ijZN@96?=XD^ZMPaxD{cl-l
zZw&haCc+pN1*2&Uy9U9pEltaJU358anj!S<0Kgi<9`ycC3D69zdn=YV7t0buv&;U`
zdtZBRgt>84!fUPwuhDH}GY;C2TF8Ez>EjDHo}{<u4Wze~lQqovP>NGs^OL0vyUYqg
zyWnt(UVYnvr9G9h12S;K98HR_IU;G}3#_g||5JG67PshRY1j{saC7a_ks5aGkrdIG
zO@3{};}~?Hf{T4`3<dx3#*0Q{>F}|X(asi>ruou=ngYJuRtAkmJ}g~4$Cdkwixqz{
zR!?Yq;zP|2oK26VX5A~o^zBt>aad>u&|LCLMl+AlMBvY@EllQ&!{`CrRPtzBEqsrm
z3zK`Qfit5?Ba|AvV_l4@TWvHf>50@zupFV`&ua*S3K3y@f_rH<4wrLOws2L5l!ku@
zr*q`EfPaslNGYm+z5h$jZZ{NicEBbX6FK$O^~pIQQz7Sa%%?axzbULw&Ov;pQ*UxJ
z1EeQ%7CR67zsVUvWCl4?;M^<j_ty!s`<--$P!GU|x<Ux!P|uj+_a^gtIe>E}yX<K;
zuAD2Mgbmt93{`_2tm**410(B(MhI8?phN41o^>5OG~bLIlH@Kms<QYwuAcAl0XAN@
zNcR+4ATj1iD{tZNKr8lXo3t?D*$_-hrmyo5E+f%-Z<0^SE~o`@&;Ir=JTg}?El<Cx
z06i)HmG4@~!Y&2+e*YHr>il^0id(wH?zzqEx}h?0>*LAKSekoofDi$&;|u$^vJzt}
zXGaSKb~n_;e&&)FQjpU^%wXztn{9dlj929;7?&Y2<~1-*3{Wu6LJr5c2@)J*`#c%r
z0XJ(gK3&K$ruAz5qTVvbsrYVGHKw6c#`t}!R>Bv95tw}`MTKhy%cyHcQE8+8=NnY|
zYs^dPa?Omzy#jursKqI2i^PwQ3Vkg66!Z=bQqcPz2|};!yg@R0SFhKiw?HN+t()uJ
zddcYR!gs7k!fwgvDJDq2YP>?rCV<Fk8Mm~1BPRuF57goVN6Bj_(vE?e&*!K5SPaD4
zL3R(7P>O_6v&=^rfe$xR{aglWaC2h)4rRQ-Mb3ZaYS@%FQd8@%U|Fk9u<6yQp~4Ex
z=FA7Ax-$J61Ok4te8%3rk$gS+51<Yi^*>xAgg=Lq&&kP_d35r(u84`wFc{fEk4{6q
zcK1hXrU-DIRu`~kV+M`3=&wKzXw)a85hhRsv-wqm8K}XmcHF;X<7|=5m#Gf0n{1`Z
zWtLLx{1ph0%*1!-b_+}@_Xw%pf-e%h<CaKlG>%XS_xmEwYMbirbgnP&daXr!CuInw
zeTiP)!bp_j^>UHm1dGR)o2kD3F1*^|8D8?xbwuCyGH<#RtV3kJ<h|6v7CDHn!VO@7
z(nszV85)+ks)vtoCL8vpYifYc#%x&vzP&^R%TN%wD*!T#K;v0&1^)|3a6I-R!SP>%
z1mW*JA463C1BYiEB@YG0K>z1O;yla-tE^6Ux4?Ym!Tod}R&gxdRaiY<5tS~}JJ@@c
zLP<$w2cQOCfP$rxY4>@Fu3aSZ4!4cq5dXbUn|_S6B7xa6j-=@0zWV&3F34$kFKCG}
z<{_%Z;^u$o>D?Nc1b;s2)RnCaEYGz}9V+BZ!_=!)YJyOXIoJXlotM?@R_F|S(%>T>
zpOHvX<!{e(;=r-4LmUfTlwhlY39!&5N1eim1$Qiv3`|s#tTe8?);kzwqv|F8)~s%M
zO!XF8wpKWCHCg6F$j)TBv88`fW2L-8hFSNF7l+LYap9?zH|`(sYn$#Jxw{it1MK6N
zH<6o#(#pcW=nzoV#kw6N;x7<%A6WmvRh#`N=mNYBw~gl=+JH=>iVdwrD$Y_jvvC7t
zfO3c1=I~NBC}k3c8jZha!2+gt@Da9RsNx#W*|;cEMt=P{0=yWJF`12Q+`;iGVOwWx
zH9I&yR`?M^XKkf<ASjVHnpbkKt+dHX*F`Aks$qh)F3v9#PCOO+^en-i20LBbPb|Y&
zqwF7DuqW7Bm*D*kh8HUP@C=o`2<vO=0DBBrLJt&_hZ`gYEfak#98IGQtjzdlKd6MO
zNNCbKc-z4<BT&u&#VQ-<LL5#L%s*g@xlw!EKsU6(I*goR*(=uM)r3R~^pZ=^H1tH4
zAdmh?5|Fp2sO}vYMp-Rx*yxT4$2!50aL}oQpO83Yt7{|t0-M;dq0UEONJKQ$`P!eX
ztI=H=>Y53or)b#VRUJG$e@i5p`!xa)XnGmD;#YpIVf1HgOGDjIVW6l0Z-+!PJ6#LA
z*9kD6Dx)d~rgNg5F4&^<Q?}Gj*Vy@Y!tEstqDewe+ksRCYK2sNk$B$$mdLW9LMu1q
za9aJ_5t~W-r+V9Ul)D*s0<>CY4_YCChxuR<Ijx-6iy6+tP^g}z4RiqOECFJIgDxTB
zWR48O|2S2(;Z<cr1TTZfa;=SFUa)~D9du1RQz82Yp#9kf+C)|>5X{+8=V#fWA!Z%%
zj=D5QYd|H^ppbsWd{*SBYa#4~@jG4BS0${Wgrlybdp}q~Q>hmf{~8a^XoL!EbJKK{
z&{QcM;z5OG9N@>%LPp9u-v1~e+pdp^ubXl~r#8^--*ZzN3*!qk>_u*BQ=fD$CNK4;
zexu?$U@ncSpYfOcMQ3MSq7c^sv-cj&Re~oHW5rbO@VD*JTKR-*x}n@TyL?)goxsSf
zzcK6<KH&XHlaY3QJHgMTcYP;u89bX$cO|(Cdvi1_uO!{ue}zKa{YMCa^)QOHB!jmT
z*hm*-aiyHKZKP|Gu(AAK+(vvLf^3=VaJipqUM~stxcqj<EVrcC#*7=LBe=F8V_m9W
z?8tQLR|||GFiAHlG+lM2wi#a0WJa<Yykuv-?Bg!11a%3+MzcU&(v;PQ3Bv`j#!X#x
zse)}gg)mPr(;&jM`XlTALzrLj0S?5G8Ov!H;-iKcfSH;MHB*|5YOXZt*j#RM>mh1#
zSr2T-b=AcSp=e2Vppck<uDg$gg~@?xtH}L&B))8*^R~mhf{?y(5OV+66>^URjwd3P
z#pOQG4T=<s!ZJK0=KleB<|cTUWN<xNj|7L;MuB&L;JE=F5`fpu1W%>QjiLxsc6r-;
zt`oR-X<9yR|B2*z**p*D*r#CyY&d+fr7GQow!Q0qqzd?W1>P2z97jwZoF_Ax?We}3
z!`#Bm;%_bQ7O;#xVjqhK)oke=90vXtZUlF}uIv#5>_=x1(nkHxeL&iJubAL*zuH)Z
z)qgFFaV-ppS)PY3J?c+LiR?FFE|NpD2S|8SPI+$}Tt=8=D?Sra)&%XCht9{YlCU~U
z^JJWW^w6aV9nvA*&0ux*w*ul7F;OA#>Uw(W)NxvHwCWF9(wct22KqvP`cNUV;~dT#
zgllSXVy8WIzVHj@2Lr-WPhB6O33RuUm(Ii9rmZD-sCYsphe!Cibg8dor!lqRO17=N
zqGU^<nbgwLJ%sU94AZqO5$;~P4mSK#3G98kw=U6v|H?u^E-k0GWTv?8N`+yQBO^4+
z*N5u=l{Mu6<`i60Rx5Lg!@H@OO)&3HKDrq~!}AX8kl(~ayoIni0Nok<Zh~6q*9zV7
zpBN!DMPjo5#7;riTau*wJejt%g7A^q<-e97&8-WzHnh~Rt-iXx!f+&(f8X3k=zv6C
zz{H5KXJY;STlR#rpjc*G@ZYF<3MrQSbUlQXEpVLNwcICiW(y5oMWr{3adXwroA4j4
zz_t*}e_e|-F5S05+$i4<*k%V#>>=2o-dKNKm=FQG#r$<09e+LRK!$k<An1$Vu-xK7
z-oj9L9`*scZZ12h|9xRMjH>SVOUCqcw-1|H%(G;F^iORftcGh9-~Ge*&hzkQblLr?
zf3o-8Zm_e2kl}}-P?`H&M*X_&1ZrUi4y1ebOk;ruXb*qbgKSwrL&y;<uWK9`7+l)c
z{X;KRb<BUe9|?2u5TAq!co2RYa{VG6z&t=xow-&zK;4`H$f)Y2cor|VQL8r~KGy?v
zr47Eo2rQP}VBa5{mLOb6g5CQl)lC=&Qfv#-iPl@mk2}J;W~8|$+rXTUIMOy7cU86R
zh)PENH~5STjM`BTWTEYzQS#oRAgIQFbbAe~;6H|JizN+1?`B~H0z!5CM^jz4AXw+&
zJv^GrGfsT8M-X{%;9A)cUHuBXErNBC&07KxPR;@fK>W$={VA@~y1>lxi4po{H?Zgc
z4cz$);kF9qSvHCxx+bby&tG6cLg19a8ZD@j4Q>q%(ZwX9G-+_XkCtH6h|D9iX>Cka
zXKxPF(gd_J1Y+|^0v1a`bWMeUNO*_pLS34}=OLAxwS`a^2Y#@;8H19Ao{_jZAyoHs
z_hMLF?5W0Iv`K_K*#=SeVC+Ygvj~5@uEBu}{h5Gtl0O`tkz=W#qDFqLreic6pYClD
zfjt;ux|HCbsLnaK$BIsu6bD)sB5L;*&PxQ|WD3Xpqp>c<g_oOxa<x+o?mM#>4a>ID
zHMM|r)w<4zyK$84d9@d?z>2?px-s0D&D7@Clv(rkFe%5Tq;fx(%=%jF3|Ed@v8Eu|
z4cAUSehS5!aUj0+fWU}t3fFZG-b8b;ILOWs{ee2^ZAhD3$OQ?xEd-yYIAxfS8|o?^
z#H%$G#eH%rHkN>B`qZDQnUI(pF6@leu&#eDbaTQ-{mac5H?Wj(9X2>`=AfYT9jI0I
zsOoNZd4lPomIga*WUAx-Hi#cB)_u2;y8B7%`rXZf|CSM{OZ2UTCwU-y`jPFZXLx(3
z?mf^@<>z7#VF5_|>Bpn|ea1qkiQ#*Htjkc@V-IYi`)p9dG%9catMPq#!G`q;)^Tom
zoszvaPG)8TqOve_2LIbeW4#h}ong5R=O|qhi(BJaD*kV>6>G;Z85x9-w_29KZX2kp
zsTd+^ISZ!TaGvTHnp&T+o4Eg2SHaGM)@P!09+vZ>pa$d9I=IKK015flO-@y=hJ*2u
zG-l&^YU&HjfNKRZE?T$7>kbVdoCaMv4etD4n(IG~*69T6CRjaQlj<Yrp<>^zNevVZ
zA(1|Nkgu>Bi8C>}Dem7B=npYA)b@hpGcQ&*SC|XMiA`$fBWRIu9EwC|Byzq_4QLP@
zL8HkI7Vt}IAn8};FRAVp(4UgbRF!ZZiGAOv1`C^!INVe>$7L<GGKvgGjaiFpo||Ob
z*yMlkxJ}GH{3gY3gz^hY_NFv4u`JNg`S1U-jNOO>jtv`Qhx-=v@qU<s>`5eEZvl?$
z!wAReY%CBKW+9h*^<$9WlZjqPjQ=IoS4c)8qnU1w=W4?85vFo=X+gq!qZz2_9tuxu
z_8?E;Z3s5~%pMddTttFXa|aT85_D7kA7R%47S++UfeVTX0>V;65EK*(3My6*P*G5j
zHFk+z!Cf_?Vu|Grc9Ec1$Jl!>SW#54_il_e_UIB~qDB*=#{J(j_bx0XpMRb_cz4Q~
z)8@>XnKLtG))9nMbX%U;Fy77M-K|f!vtF4oDdX}52@*?h$ye8p52$v(ilXCoP3a;l
zi4N;HV|rm5J^0lip#_+qQ~~E3#n+Z*;Ulb3d{yVe*-HP7Q~U3>^?&e@jpF^JK$KY0
zD86Pz3xF-~f(<R+^kyr#ydkm&)6^q7>wv#hhI+g6dZo923|7*n{GLj~LyYlaii_F~
ziKX_oKa6pT5l|*WgsnFE*mK1a;EokvMPW~@AwFyeG;>bU4io$+?s|Ktqg9a70fPNe
z1!$Ded<PX!ZvZj}LBdFFh?#c_sP_8C@%5w(9~>Bxr};YQe3Z5iu2vRVj&@k1@rAyF
z-Q)XU_BP1igA<|Doo1qhQ8NM_1p2GCksR8|P}!u1*bfa|8D)`M85RoTpc}>t1VG@S
z$%lpugI}Y%(cml^I75&Q(3Uu|vec~is|fOwx&m@?PDnkeUuEE#6VgiZ#K+esLmN1X
zBGpmEWS(Dz#aBe^=c{>s+@X2=p{h0i(PKKGyg(y@Vksup?lF*Z5lDTd!4h8c_*(Aw
zKj}qp`Lu#seGY@E4m^*V$X{CzLM~q&6z?o`_@w8FE#m{NeN9Q#%8IIg8ET5EE~tvA
z4gz2{NJU`9u&F$^@?f|gkPs$wzBI}Ti<GpyXm~k#C9;Wh!4qR_GucmChmXjnVeTPm
zo?ty*s52bE{ss*tM`6uK(v1P5$j0?UF=FNJWso%HHXd<4K@F%X4j<r7B)F(9(do<<
zN@gP}!S~Z3+kABz>%<qrUCShD1`C(gn;-3fng3E~*tSsFqZ|OkAFe56ay1kLCE!~j
zXjdUYU6&RSq;=e0%gSRg-yVi##R0dil`W7Iq=*fL9{8XYd%I8%1@-TiV0zT5x$IjG
zA2{#>og+$Il3je=#ROt1u}#%}_<DmC@^CZSXT37u`+m^Ve8OeXypE*;tUu_*7SVl}
zSfEMzwHoV6#H2glQv)ZE0UNz2T&^NjyrrU7(_KZ+5g&wJoi|Wks?-9N2oAb|VLApu
zN~<FPxeGuFc0Bb=XeBE*Ea`;HZ6(@E^o)=jdDl~&n-Pnt<*%!os|bipjsQOo!D=h~
zEK|tOY+l6AM=j%8*i~>fb+G~q9(kgT#^W{QMYu$wC>?5`DHe$PsPd%dUxFtUeeM4u
zHUG=-ZV{pI5JufxOIyJryov-C&5)sB@fvd|h0I2%qIR=IK5@+|e(wT#6h7KSr}7Y^
zXFvaDlm+kX6Bk~N>;QDu-4Oqguk?uvX<&g0`Bw-UQqlQwn+Obeal3k-@Pne0ZMePF
z%7Qy>#nSp~SX*!3xLML+I9}~q$r0thMW4@~3|QD)!g%qwZ=4s)tpHQq184&zng0;s
zgx3`<-L*s>u335lbFP$7Jamyc?N1m9>RmtNQNZDNA49VS=w=RB%R+J3UZoO*9$=V+
zW9h`e&GU(Y^N~aTZ`a5!kv!@`Xn)uHPVhY3ftcuEC~4H3bHadjA=JZqJMy^0$f25Y
z3-E;igN5%5MqYR1P(P<5^NQPM?0H=b^|y|{4sLe87+PC0I%1yNT8@);;^X$k(B4uU
zK6>ukQpF{}QIY-Fxg;P}1A}gCYi{L$Q!6*Nx!5@<1)NX-_k`YvtWG)kZRCgUnMB3!
z-v3sEN73>e-#BD|Tc@Ycds%|)c5}?}1h5!6O-ir_CKHBwN@4gY+i`@i^K0CNW4>8#
z39m+Y;|ADUhjK|8KBVJ_G7e{;wfReh6z#mgo7Y#u>+mOS<slU^2rpeF;8jRbpLTM6
zdy(#kbTQ*{ydLUf{plijbh4eiTl!oUR9%Pr@(3TLZ-j=GT~(GSHyT#C@b)*5(ej)%
z-rWfGckPIbT%RH_p|uE9Y7{3&OX;vcZ*GLvken*QiQgFFTxw4lXwMja;8du8X%hbZ
zS^IeM=s4GEgONe-2RlPwJaMHvte9X}D2$9?*y>q;R(DmmASZm#yB>tPDx>7~;PDZd
zHBp7`WfoNqr4{FKAAL$it23%;a<)}X)8D0qX{zK}S`luo617sJH&=I{yo{0PY=0Sk
zsrc5&wYec~(iqgd8ofEe3jd1Lu85e;?yjZKTh(>5CR_1-F+vl4VZpwM+5D9c@`%ct
zGl+yd7@v|x!{;spvF;26(V&C894j@O^P$-<?m|tQ+rZ1c2U&c!R-k+?&yS8xuVi(?
zntwBQbTti<OGsjcHO?}81xZW;?;6~PB!;;tl8~H`mAJlJpw%>00_R{t2)A?giUcfS
zWCS~hm?U7F3MkjscMEdB2iD=7g;J5JbL=D|=r%CnV|CuDlN=+xfSJkcBv(P2;X`$v
z-AV2&4MN(a%%Lv4YG>KcKF|tW!b4n!2~z;HQ)f9qil{J{Gvs+(gNXqL-D!;J>55e-
zD(6Dw4tJJ=T&|+aBPtPpi<q~l3lty_Ndn`)A%CF&wI&x=fGjFD5xra#du=K<ep0bw
zi=IISLykcPQ@aWobbksNoOuQr{D!fy#?O$!j?aphv%{7r|BU|7;fUHF`XZx*6xvgz
z?vMfl2`<keh05hsDIEJp&-Zti1Fd9L3g5!bA}M@}9b4)LyX;kD8<?c9Qw9{@9&(Ta
zKClXb0;+=*<QwH~1+Pj>D1OF=nD$)4M~`1ZE0x^=?~1ks;6YvOA^Tf9<buM#d&rf`
zeSKG$?FhriNM1Do<9FS=dLEr1`?|IJnY=!+2wb=qp1&fJrzXh3R)Zt?o&-1}i!eAo
zPLQ3W0wO;d>8(YK>Mh;Hu+Tx3Bf{D5z<+3gMV@kkpiGk&PfLD8@UIb{6fd5)4PWG0
z$>*aoye3Z|B72}xk+6Bhs$M?UQx60E1z*c6rAYWGrB?T9UIs1-fwHvbajSdb`iujr
zO!of$FPW_VThD*&37L!oH(#&rRYMw4Mzv8cC=DBR`<!Z{!p5nxx%ggze-WY}*;vD7
z2}P=Hl8qHXyWC3-s_-qLeb83OMm18Yzl2hRLF|1f)4E?m2RYxy5M9VsCFG9BcN$u)
z+)8AqA$UBi>W+9TI32-#<WXhE5>zMHB7~nbgRuWpg}o3TG<yu0NCR;CNG*A&v?tWf
zv?nwG8Rp(;k!Mpy-DdWBpcfndZXbVASf4P4T8o0oQq~@{8+wI0ydzCHM4=yunfgP|
zFZ7kGm-*$5o)}RO%KI)0b?ed3ywDNk37wcS-bcdG8gdH0eF^Vi(g_kh`Z(4QP=+k)
zq|wykU>kE`7x`c#3-o+QKe@4+DCLY&s>9GR8mr*-zvhSf$(1yk1Ams7+>VE#|Fs_`
z0lz-f^Q><1ZW87){AJhpAj$15yt)2zopL{dr{vXCgH`;#KlWLD)v~pEqt{>$wGWLc
zDGtDzzQ{7I2&akHUxxiDg!C#{PrhnKx_8IY#RqJ3bx6c~mBj{afep5XR@jA#o-#fN
zhf(3F1wnPOtN9C9S!`~;0b_@yQ<8_Y1>MZcDXFR-Jm`XY*eiw!C9Wg-x5QfL$WpjD
zZ-88_T2r+bZ5c^8E<go5*?_-AeMuSp*)&go$N*#&d0d#%ltNmGqNxMr`BJ_smL!|U
zMN2F0>v`WqxpAd?uS9K35PihXP5y|xGzWcQn04bF&%C@vQ%*@Y`X7Ix=ZBle`Pea3
zA^u$%jy_|VB)fV{e4(UlM+#yOEJ(nqU^^mHPKJo!oFCA2{5+C6RR6tL&nY%NEY$2n
z&sCrOD~x%xFX9`5A&r_ml}runG#00h1~Q*Pa<YUOET2C}9^yMxosXUxCd$LIn{$K8
zziNSA_?w<Tx)$o{==WRkKE{LA4DhY{QsGScm<Y8~vS?GMyp25bPAP=p^Sq6l6^6p^
z*9@p{^-|9-uNmMKf`WwjmT$zQDJGpcVqeVNQ1i61b}$d=INXo1qX<Eo2mKuGUExQ_
zyZEXi*AA84t$tOowm<o+84}#`(oko<YH)lz%6~aHKF6j2{dWO>7#Qm1HXh#)G0xr>
z9*kA=XNWTVKgIArMD8lx`9-e`^}C12mF?F;rNt2bW-uiE&6Cx2tzfWOySOSgEs=GC
z`)-SMwN_}ijCQv|Wx>w3`DTcb7WDZX>TZ><=I$+-tD4vEE<s05em6kpOa)AcnyhK^
zH*!^J^G0iat@&_&*Mo-Q;{v7_8w`4W?Hd>ihL88($Ug2mV(m(pe%LAeEpnq@MZ~#U
zJp-2t1DCvEG>TT>KRr-{R$D-DRqB$`q>dO7Awk#qu1?`D{EBzCvXV18QgTwLU*k}u
z|Hp>V&3gpPXc#q!u<4EQp-9k*bxuCeE6O+TIn~}1O(qH>KzMZeAuYbut-ICe5I-i%
ziBc+ti|~WJJZzI_o<k@hjIN?>G<Hfqp9A|Q50?kJXNaMn0)z{NE&L3ArCVGrtDp7!
zQ@6N^Wl@NH3IW3{tcLZT4H%V=^%xo;T>)!;?J=~Hl!cFS2}6CP41Cl{7+OV<b)S3s
zX4cngd@}Nt_w*j_d+|jo{`Ekju=QKPX~C_Lay6;TBRzk;FV2PkJ{z;xlW<R_SVj2O
zdyk=t_6sXUr%!ng6%jrMPM98|ABYadNDhnbu2^hb_=0*_Ek?UYAK<WurN}-~Zwz6M
zQiNN87hE7Rs$qYKq0D5ln~Cvh6^#x!1m}a&D^uhkr~ZVa0oJi_2J$Ecp*R`-pGQ}K
zZ4Y!ii?>=v!Rd8-qNm*pH$G;R>?&2B{0Gk*CHwfCd`#keVQ>+EKEEz5&IoM8ScYNs
zEzogv1^)XeIMkt!)gBc;TCU~#;gQ;-V)_vx^--Tz#~sT=xVl~w`eQ3NK|A@jxXALX
zp8LLS<|+Mi6>@*uOvCFQ8Bn&-y{jM@(LRS@h-nB>16K~uP;AQHz65&(GR;*DxCM=o
zz3Nv73PocD1P6D3uu^s~)gZh4&HkS#(s3%JK}u#9QKQ^U2qVUL$uNG>AAH@RUV+kl
zbQ(;aT)5#-FOP7~NwlMbomjeh6iW}9Xx%HSQnWM|`B3Q!bNdi}<1rEx;fF2s=_Bg;
zzC+JL)Nugy0UWnz6C^qSyaYN)qPYb}Ct}73w=zYTIR+$G^wncLpnxGqqyI2)Q5}2K
z;l%KE^`FWvd&f7*3Q&cHs@JlpHzAS=<IgjD$IX#KVBIFo*y85qDg4pD4EK6bfm5*I
zqN6O@+|kV~0}5W~C6k=oaRtw7^pA0J?Z!C}C^#wNYo4!H#L-Iti55T<ehSQ{gwx3e
zTB3S)LmlqEvs8vV&taHHQI|6Ir1tY+=Zh$QG!Blt4y3ft?d9j)LM3IMC^>;j7LKVH
zM^Y!mhdCMH)x~5S_Dh8{aN!EP<;xS|D|_u+jcr<}@<#j%nF+narULX~A-enB@v>iw
zZ;(Yxt@|;2VAZ;KsSeKywZ@>qrNLz7mVZqM&p>emo8T|vLQ+Cq-JSyj9Aa?5@lx!z
z)5Q!%|MTd{lNt`yc<)9ZC1P8My0uZO7zsfG;-*WdbM*Z0*&{q-X}+Vxf#MFC6J|K!
zr8{7rmV=%FggcNkmUbrB5!zd%fPY{nLs+&<AnOUCPn7XE_Z?+is+5Ub5o6?37-Mv^
zhiYaQ$uK#cP*Mpn#K(@vFvPQSbxGpwZM_=Ljt>zXe)u-Eg?M&=pgv0R?Al-8TBRRa
z1*8nEt}5E`Yj@(<j~LH{jfP_)%bGfQ2lN!2popU_bXr|6G+driat9~{KF?exyL#Tc
ziH<$ij9`_~&Om7ZlWR(@YRM)OOP0ja@ht`2vI3pA7|V>B-|)9c6pFt9LuGYLuLc@J
zC=_TMuoGM-TIX~lTE3-fCeu+A<63s95~I*$JFJ(``w3*^)68QO3RPEhHw4Dc-x6g(
zCzM6l3}4khtVWdDyNfwS7;U1{-a9zjjIP_#!ojKZiNwPD8pVsT20%cQbh-um@*Wrh
z+n*cI(f8h_BqW=zmqQ1kVi|kIy>htp=bfI<n}p7`@+Un%I!Uf5ZMg)3C&{sr^QY3h
z_GCHS)e^(O5p*kyT>2vpOfG`^F=?{w<FR$OGQ>Fv8wS0@$s4@x_=BG3OqSz(-*1dU
zWA>*vCPBD1N%)5jv^c1DepWt!Ve`^};1JIr1d|MdI~QB&DE1(3aq>1}<Pzi!-tZ;z
zUc!VNKR2M3RQH~qzdAPnamyE=-{%Lkt{Q)n4r|%e%Sr@JDSi<L%YnGagR~3|c^PW9
zEp5R^pC1tJItJ#t1o?JwRW6(#;N#(&^<U)Izpm%j7Y4NRO<pg^Z@ylT|8QM#^7%f6
z{JQgLR79IkzY<+G8o@moA@fmJIsD~6f3LZYW^%_rdj&ezg>#YT18l`Epiy%M_DuU{
zuX9zTqhi1;TIB&~Oq8LJq`nI~z{`C&BC;ayJVSQX;FnPoi=nZo4<u$T`fK9|DFSyS
zBzr9T&LQ}ynK6R74Qdls(`uWZhrZufH!6HTB>p@uU3M(kU)Ue8De)>gEtHP4O<5B~
zT)w-8r1Utatl%z2xz{`N;#6KL60qRYCd@;+umv7jn=l_I3)nxQY69^k@GZQe!`!X5
z>UpE+FdvWg=-8s`l<XaRRq0J`9#g3$2Xv0$qs0nf{#&C(6KUzxBpy0T?pDb<IRb*$
z3|~z`!81;{bM}Vl)8y49|JKb<ir%E>w`R%Dt=TMVJe2o)H^16*E);jk!Mq7bicO=}
zXVRYMtO7OQGEN<ChNJ#_w*aXb^eyx|ImI!SI9(c!GTyhqU-$wUvR3nU0G%?_1g=Ul
z$+6z=dfs`q+#qDy3Q``;#g)kN1YDzLGh`@k7|Wr%WxzyqzWl+sF$IjG*H_PBjLn@b
z*QnujS`oH=yM3m-Ss<<eS8M%(0ia0M*^YDML6(vo6n1>3JXl(BP0#Z)<$+eYC%AU5
zoFKj4iBVv#Tu0gj=j`EJ*;`t<Q@?1QT-{~jGBECpwI478$)N4mlX~84o?Okd*-mQx
zHN7lmn;%C<mKF5M0mOuP0P)KeJzqXgb`Q961q9Fwv1*At`n_HpnbsUyicUjt+XC)S
z^W?6fXImFi6NQ4UX1;GV6DK62(`x$_?4v0h@c<_oEDEmSdVXk05uKU*>Z_RH9_7{v
zzTkp~^=3oQ!XsFMd>wO$z1W84=~{NQOR(}T;kO;}7e*^6HpBk;_lmOE1{;IV;n_Fz
z%Yxd$FV*6iC|<BKCSweO0`1E|qEyW>kBlajE^~~eN9X?cSr*ix<Nh`1j|Uy^ryhEY
ztyPc`zhV#TErMTWS-y&N$f`T4iBPIlY60=177F0jnG{!1e42S(M`V%zKDO09V<C2b
zTm*Ip5NQZSKoA(|y4grXTU&h3LOH;yr5*oiq3rKG4`z>!9HKFCTh0?q_RmHn_$7UW
zwZgC+D%$-9R;VCY$Z72wk&cTWAhbG%kbaeX0wV3KQbmcAYlbQSY8c;=dc?r%gide#
zHAjc~VAevpmQ`IlerXY~S%XUE*u25~Utm+t92@z5AvSwfn_<(OJf=cyZlfEK-yu+I
zhbn|kdJDp46rkaLQT#25O(q96we9#34s3R#k~ucC8X>UpR6r}dnT>9)^5(=UGi=%)
zG{?pOg)PJ;0aXZ_rICcqG(dxv;crQ7w2=w5tXkOd?TdlUaa1zLrb2;=4fTaWNv(iY
zRk69T(hQqk@WP6C^Zv3KHiJ=xu-O_x*enDzgsI_gNo-by0-Gp1zWjS&a~+k;v8jRu
z6TzEi3TTBlJ79)XY@V(#!{(c8b8KwQu^Eplgw3IF!e%|Pu<(Ju|A|c_JD#xw*gQcc
zb8PBifkt4{4xP1-H@Wa*Rc!uPZibD#-y9ovrHZ0A>8k5{p*dl*4_R2U!{3tFWHkeC
zLhbm(rNHJ5Dw$)`0&bMRCIOwZ5Sz<zQ&nsvb8KesGsh-CsiI)BRP}7{g%LKVkOk|7
zza_Cb+7#G$+wq~xfQ?lNY`((Ur@&?~hO|O#9{gB{jq@@y-mD<wSJ<Z-D^(P1wxSA2
zsvwlGxrr>?#EHKpvGHjIY@F?Q&*i|T0!T3DO+WZp0-N#Y&9M0mW?kh?)um?G?AT+D
zO|())!R8RE5H=s15jH;~3jq=MTM`?g#jrPVD}YTEkYJ9@2)NS%oAh&L*nEcHs$x@r
zi5WJzyUnrbrc_a|xqvE!O*w(hJ7i&B9)C+>BY5Lt$HP_vn|dI@9Gl7T^#nFcaS48*
zq{<gz)AD;WY%cFI$7YaHMZxACh5^FHvnlb$Mqpz^fs)ufY79w%H-W2wO$)SRj?KKM
zDmGism|^1$&?;{_E;hsFL6$i-W0fijHU-xeY-%+jY&5_F5qJNA&8t<g#r5sD*J@z%
z71}Y!W({Trf;WfY1Qqh84nV8e^yg;S{I=5^o0&=#1sfXYh&Rm|6E^-p6bH@mw<K>w
zpK`O~_G^GmKeS_x&2D(F0-Fn`%&=(=&?+_~7nx!6d51YRi<K%0HZ;x=HtiY_HX%UN
zsHuy;C9%1>2E1u%$NwR0Mxc^8Hpj6}DX_VB(hQsS7+_RvrYtnWrhGAMHYrsUY-pS#
zY!Vt0Hc>znSAgPgNo+F1pf^?R_{+7xW-=<7V{;u#YXX~s6K2@-!T_UUGk<{@Hs0IK
zd2>LiqF_Vg9APs!gs|xhL~+?Q{+7fhYn>e6F#$tysFlOiO>oO_k*6gVEqt&Ha1(Q}
zb@KE&VVRhVO*=a3XhBCj(~5yI)M}J<@X-Qiyn1a*<?)U9Cz}Z~Fg=Upb9Z-i;Rn~t
z?#y$J9`H(A#!QiIEmC@6^~^SQMzRmB|Jo9AwP?!;iCBWNkh@{?6PLq;)JaRSFbuC$
z3R4!`5`lS<*Ks1*VX98?>TyOEV@iI4@Ik|_&P)PjchUV2+~^4eFg^GIX}SIu7D32~
z+)W;40Rf{HbM6So+Ayy^v1I}v7cm6$IKho=7<~WD4R6ff1viGyHsgkcDEpt>*fy;M
zH`--<nHveW|AQO7W`G-y-HNyohpB8aZXCuaV&aAcO2d;!_XjuH0ReEs8fhkO49_aY
zjbCml+&CUg+}H-l|K`Sh3~>MEMtjVT1UHs{XU2^nQT9K%aeqn)Zj4X=GB?tH{10x-
zo(67A@+#uS#M~0x_!air#El@7#?_qY@ZiRHAOLPOK$?jgtI?UwbfY4*h$V+Nb%`7I
z0l64AUajq2UCPMP^R`=LZ>x1!Dc#W9(<&V+4C~stbD#CS?YQU0-VM8gu2f~s)gq-9
zdJ=Scuiqd#jzzoYSpP<W=rfWj0O7lnxK^+qCPdL#slAO7hMa}KgYIKdr_PvlwJ~eP
z*V^;+FGk+?(IyT5u(5YHt66%!cYW`D)#uMg=n}33X?GY6DC+*|xI$8NAdyrL8BlUT
z$jj||{>wHHvPRFxZ3ZD}=7b#D3_@o9KZM*v0W(5=Jyw#Cia@9YAsc5FH3LFUnFv|3
z1%%8HgzT@DsnD_YU?CmaqY53HY7!mukYS=DZmXWp+6g*V>UqU&pksPb19m)N8|aw+
z|IpD41<dG(%_~XAI3QGlj?!k$RFU#bWHj9lGN$Qyr%k>0SDUSnQ7*fXjI1LH8MXmL
z#+&^`WNgQ}O3mFMV>wm{cYutk=45=_0WzliKV&RL0W&hT9WF`6-Hd;cku*hZX4TH#
zRitba8FzPrjLCZbb_>WzSI8K=w~!3SLkby#{E3XOkYSRB{RTZhzZYaI!ScZ_kTJ=e
zjHSCk#-#s;jE||s$gs;PNk&s3R6-hOQq^XTZUh+zOk|AP4Kk3mV0-WVQJ8^K=eV$|
zkc?#PT~L2NTZPEjjf_M!bmfm2x(io}(KXK<JyKmwH0;&$-r2HS+aGt+G7O$z!_CO^
z&<SF(w5Q%tk!MTgsS>6>7&gUw2Gq!iM>b+SZYvsVfX0;V^WcHL)wgcaTco{1n<+KL
z8xdQ#!89H&TwNA(@^CahD0pDyfX*@qfOWtw;RuX_ku!JDs2!8mt4~~-JP7|LV<bM%
zHHq&G9yrtE5=LvFYVh(kUqz-pkgU9T?}pz@B)?$hRw5Mbsf7CMK@;@Y^E3hZOpdZ0
zi^B_eSf$xSEaV=I?;^F;B=Md{<Ne#u!hopINoX0$J;x<-8HcEj!MF%4PCqo3zWd{w
zP$}m_?0yH^3ojpki;S$YDeZF}h_#<U*@LzKG1?ke5wpNxUJNm@ZBC~ufSBh5Jx@6g
z#Fn@u@k{4{m>vVJ8Dirf2*jw4;o(Ao*e3dJiEl!zz?%@e38`ahhQB2ddvykg)frFO
z(VKzT%p$}dVO%YS80Eov5r};pr{}HC0<mA5llbzpK&&kWO*6zk-V%sW9Yfv%ftZ25
ztKypwyWmBL?Soc8sqnWXVvgtHD>ZZ+N7*%@N_jp-h#iM7UkowIGa>fVw|d_191z><
zBt%)cHRa;TER0a9;=VAfRFI<_!&)-vI9p8LrSVP3?W{z|eGe5vNI3qIZuL1LyH@eu
z2iFz>>1ns<W-Om*T)!Lu_wLLH>O3zDWBz!@7ax%;1&>94C549G?)6(t<K!dJeX_<9
z$nzUO5GAN8&~JyH|9nKQTwyG-W7GEf1z{kC#&;i)#9edc8dfoOJTg~~(Y_f&)$OQy
zGVoQauY+6#KQ05L*q+<#N0)8nP#NKE=Aa(@gbTxItrGeyHgEQg!Pb{kj0Ybe^{mM4
z^JFJU-iR&wJh_wR7A!!4qtfvS3f3Ah$j!==y&Atm>$pu7H}BRZXBGoIwPo;L2Q~tB
zkYOseis>nrO3)`!0&Fm>Jj|Uuy1N8!Mr|tQZdlm^6<|dE@*rM6hKzC8U;Mp^ziPKR
zDp$kRr4wr5l)zCrQj6CUaZV;W9owew@dTg_nBjK65jayqXMfG#L}-hw81+qrDyl!#
zR7s1@XcL6Js<@#D5vg=LzLHg35}&<kL><X)nVt{69q-ekJ7$jg<>8A1_<9@zDGq!j
z-l$a`TNr*san$Z$B^zlf;G;tT_>vi5mVgzE{Lv^xk0yL0mc7Fq02k-F#bnE2+7L9B
z-$|4h)tBzU#J%o_0MM+)tWmsfN*me^)9Q)3!cI0i1ejICZ=1E}vA3mMd}s65s+V9Z
zZU%>Y_+(%U61&$n%2)P29>bfZ+s?x_Rj2mvp3w7A$7P>(S8{~OFTm~iuL?@RIfI;H
zrWmb8V%hzSA;xW=5g4?y9re1{2_=XZ7tLTUNw@f+oG;4Zl;?4|vgdNF%bIUng^)Io
z{k?C&``(C0@W%=Hd**Vk2=hTJi!kpvKwxe|*$U!cfrloI^nsqkUQJbc^qB$|?2e0T
z1;sV)7(@nQIgO$L-a)lU$Gl|f*G9uB4e8p>btZFD1Ar7&6L-Y5u|>FsBM342?=3lt
zy4pX?n|<gEf4jfktZ2(?#>aSt8O*V!-LC^WvHMkd2>KUxzi5XM+xIE7^`(~BuauaG
z68V*(hidX2C3%BdQF-@3t5hrkKR_vE!PH`OjTX#e$zoATu@8e4EXs>g)+I}|RZ69(
zrEt&zupW#QxE3|pCP`5A4N4V^G*QYx>feK+ED91#DM)yO1nm5sQsI>m@aB|+XRWkq
z)GN3lxF4<RN|rjVz`CQBqFqFzrllxFn~oxs0g*p{#CZ6xMSG^JSGS95A<2Y7M#uvE
zLjUejtEB~>9o@l$O~c3pU*<oqUQK)Du-^eaWbI&7QSMoNPoHKNzWR(JV>A_*s27nc
z`<-(E9aL{osU{DJ^hPs$gxP*4UU0|hfwtHq#iL|EX}KtEM;h~|g5+C)IbQu1JHU|#
zh(ZCU1#A{@b}zBDdG(Ckt*Z;PJ1+t(RPFyZ=rg)j%22Yl*qo#+0p!9r)D0@3J)3|J
zN=LKBqk%qP>Q&f*ya2SO!We|PA3G~o>3t{~Oq_I*U?iMS1_1iTL<>HwsRL3)#GxUD
zwkgr*3&WItiZ8l#6}2gnEQTvL?{0FUUN;XJ*m6GKd$v{kT%LKp_coX0-AecD=12uv
zz^#MNtvxR{l%8M6=V|BVD0{eJ@Vji$V+>L{zjt09<hR+@Xw0&lJ|z`MVBN1TO-Bt=
zXVLI8zOi9EK5}RBxjnWxbH`sh+BzJE!vqi!1Y$=LF0{EISFU)!JBkbUwlJy?QHRrq
zBkJ({1-UId3)><Vy$d2SpcdGPQ5Dd$;Bn{9M8idKI5vP!K11j7L_|1bBMK`xr&4(f
z8jA^A;q=~wHd1+iQQiUNOSnFWhT!ur;&O=dV8W@3a#U^7UzG`GW|{*m7!0eNZVULM
z#*&?j>1x9pUXm-<Z`92w4EESjZ76+asbVavFId(epajc$5KJ?cRa^~U>EGO$KMdSC
za!GE(ZcqMi?i@wTUJ34K0E(y`Xh+<MhY>g9P9~Kv&YhoUDdj^%`N}9?f;)&g2s8y9
z)afTo&)orvQ7OC%IC8LAC*)a|<<@OCtofUWg~5KFvk9U=oZuj8sXla_ej~gHIxE!n
z!j+F=&=^^cQ0|HKesdHM#Bh1&IjI?z8kSud+C%C!8^K&xh9*j*5Gv8{>d=I$z569u
z<X8hHT{?~_R~{^gIRxx^F3f80Q9S|WOctz9Z=xh507)<oq4))J5rKbl%JHm$VQwBj
zV~Y8oHjD=awQVkq#!PB>P}{1dG6J7_A2jkML2bRQ1{~ozL2cVf8;9w+ZE#z!gkhMx
z#Wopl>o6I<m$Bdg+yK{J)Rack7b{3nf-hyMzoeZAKBw$SmmdY5Jv3}9y^lO&+AXgE
zC<O%=-{6}RhJtX%8?s9k_jO<$Zf}pEcdVk}q**ykquct)<BNd3U!c!!eM9!PtP-$T
zDHucr8!H9ps|69^T4TPRPyazKa45kyo_Z6lES|4aPNvFZmC75`%E?B}-*ffZ`)|tA
zENv7gGUAr(X7%$--u)ILcmp%_*^_U{+bu0&X?_4OTmD5%Vj$kcJO6=+pm&o>#{Zz#
zBSW9P=&oGV(yIO{e(0X;XN7qtjzzh4pGdk#6YKy|JO@YkYYsKYl?eO2laT#3Eh&f1
zPhCm1pX62-qIuCr@p#0s=L%TBp`O*_^Io%C0J!$PJm2HnCpHL3ewN}Cjl+U@Fb`<$
zgQ5Qu8=jHc!BYyvtddS=_0?cTs^B4l=@H6^9)M^Ldb0`xR@knN0-0~(1u`qUkai+l
zMQ3AgGjyKJRnV#UPcd{N9>^6f*YT}Cf%x$Vm8me^wflHeqyHk__?2kyaC_0-%g*M+
z|JBQ^wd3C@t?54%Yi-p%*~99_2A=Q$&0&T*=|xA^?wCXV4_?PB&Dkl<g%xYAjd^n|
zR9@$NEY{qs2QoeH?2Bt)Tp!9q*f?R@jRn(U(mvt#6AZDK6p9DDU8bH(!SmZGeztfy
zi#R(ePEe|i6O?xEWa4ZsA?TQ%=wb*MApv6%01gnmSD1RqVa^!zT$;ziG~I)BL^?ez
z5Qo&$bz9=u-&Xh{Lq^j)L)-fF16K)u*o*Q*(##DJhT7zs?JEQSr=f%Sf|~6omahe4
zou2{#xQP{uU6pIKuN{>?oF-<6U<Gk^(rWS0bioqXaMSZguU9FO(EUwKbestx(Vg~)
zS}cq@p+WtzT)FvA9rYG438S2W5-ekE+8e|9@IQ_Dff$<UW!kl(58GVEQQpESUU}rf
zFup->!S=_Pedb`iq@99?C|fk;n%NHAgwA%0K7%*y!UY`qg`{X0(w>1y-0F#3r_ws8
zUICkS-C-t;;V~I`j<C~dKc?L@y!na8K9M^}Z7>I1^+c}GXwiGRz+bcAPNGF_5DH_i
zHkyXvu$+8ih&6mJV*F*yzzXt;XyrcB+xtk%Lf`VLPvzP*GPb@mrX9<&oO%w==71D<
zVpce=N957-J4qtRt2(y8$3B%SReS}B5_L@|J-u19GE;pMg9+u1r#KBVt5y=f`4mxF
z*RaY_>KVd#|NIJvI-lXrk7M}g^-K<w=Hg@aGr1}2^cCStQ^~Xk2EP5B5dnUaPTFEI
zf^5#Tb1A=rnw`&xn!iO5jq)~E!EGcrj-g$KS=j2rkI~VjtD3j)40APt6_(g`F7QBB
zf|B*RDC;@)fQ3`ogq8-xf>~@!@Cef?u~;Bd?vl3#y{z|+l%^7#ts)LWTY@6Acq$}h
zCeDw|iO>#_u4(oBbA;AQn$$zjy(6^^2949|Eg<Snzy?qD!oVfsze0rrmp9`eT!}}V
zX-NReFb6rNN1T_64Qq#~-qdL_Y*Iv4W0ma<+JNmjk=m+K-GC(iC{o+d;~S_z{yK;}
zGa6I*X*2AEL~SM90og*UX`5mH8%{ZyfIq=10txdgrPK|PWdgpZHEArS0-(aS4XD7p
zk<`@(7*48=1&J2gFm@20L;iitCTZQ^h4Lmy7{C}c*(((F`yRODUlKVs<&aZ?<UIs9
z!~Qj$WKM4)9*ESaSlOZ`Nd8e|nXtMPWrkIK-nON-ytKEPf=&3Zm`Uc(LtBJRX<!BU
z&qQ^^8Y-P~+BCxEC1!0@VvvGwLs8-^wg7Im)W%Ai<Mg~*E3J?89D6e{t+ZcDXKuga
zn_6jurL_?5{Z`txNf|b+P^kndhoQG1rKZ5QN#tHjLCw<z3Xd@*AZqMHu8ErG<~(j!
zoX3;>l6XdxHcZMHq34&Pw4T!2;d)*WrN!wZo6>aVulNh#e?!O6{7WNxM0yiM_KD_y
zoUb(hROH%R5xJ)3`=EKwT5GFUO2jR!BwXy8edkA(hknq6uxE4<VqUeuZsN(S?_g^4
zV*x5E_!&*97Ifid+h~0q=VF|t&XkFohIO@#yctp@$0V%Wx6yh_ZLq14+D2Q^LEj(s
z%fSl<ClYbk`_=G~nyMN0v7ZIbCYBAHr{L_ZXiXgyd<=M=OKKG&X@9x3@=Z972oX3o
zlWHgHc|x?-BP_#a$3N)g#Tn$L$Y%j^z@SK#K?~<9jaiCZo6-N^fN-?dO={3OiNEfk
ztsXUR7;xSNnn`8);kh563BBqMFnG90>7LX4@K#QK6f&vMwZcLVK2f1TixDpzqix{Y
zp(iyBM^iYTfP+J(8SnvOw0J$zrU5P$+Y_U$jZX=ms~g5T^S@%W{!*XL80p$-d$}7s
zQT<ka*l)1*Grg|-6|P(pWjD3eHnWd}%Nv{ShnE)-2h6j|X<ekTo%FnPJ8hKYbNwBU
zZ>ROIX$v?7<y0AZenpQBJtMpt8y;LCEmZ{>8DQiq+Gzu%Qmys;Tsv)$RDTFgv$fN9
zkt$w$$2-Sr>va4ZCOm(K=)^Yf{{9!w>1iWK=pJ%R-J8LCC!>>~bcmxO%cPO7!l987
zEwwJCBT&uT3o?k+Hg-tBbSeKAvIkJQL@jR|2dzr%uIJt3pl5IT==nsXRHy-GF_X~W
zgl2IVz9)v{IBk^(nzH4eeWOSxRG5{p)$d6(dz9`mZ5P=Eu~rE-bi+xov8b^Ya>PxC
zSXOpuuk{HU1trhFDbn=xIUX{{D-7@_XqerC4DnF(YEi-mwR*SLx&~x~o%)Mfs;stj
z;xDw6_W^2zHzPB`GDW5pW)sWXYu#L<Cl&D@gChCF1Gl{6=i6&TrPD3+yi7dCn9;Eq
zQRB7VF&Q@L@BYPd>Vx3jaO9X+ehTyx%R>~FcM(}8mS1TCmS@JpzVxk_#CODNYe`!N
z!Oo$jav5QF-V*Xl=VJFstBqhYBlUQ{0*kku@|XW14B8?TDAv(N%4j_msixKs!>Pk6
z$a?g7ok%vdytgsgavD)E!~_Hiyy+K`NcvxUC|x|7V!I(wP{nhBr`LugaKAZdq0ZJ&
z&=mIJ55jX@rk;P)YP&LhXS5GRI4bl{IbxC%B($P;1h(&{G?$cEm`O5Gu~!rn1%yA_
z3}vz`^T#W&d!9`M?3EMI>U)8P*IGez%cAA{kv-uI34=R`^nqXNKynIGOi2A9iKwbk
z5w=%=1^@(Js)hdouXR@bUy4@doS~*ZVfNGRE3Iev*bs0i!+u7H@WC^ifFT(R1g^P?
z8y*&=x;fpOQc2DFP<TMfRIDEM%GZCT4X`sd2QT2tjCr!xh)YhiK^}V$NuGa&Sc5&1
zWYrh<F-&O7t8~;h?3pqW-cSw1VkA?=6H&o0VIK;*;1edRpuH%sgjyJMQHs7&hcj$T
z2G~mqSk%bxsC<%Ti4YdgptmvdeI2#6Yutm`fB|!uRt9DA>4tD~sFy|nffU4+!Je1x
zr1dF33;tJreU!qv1*A3Zq^(l32c=0O?G{Y5dHpe%VwlW;A!it$+DRM4Y|&&vn0T5`
zl%3$`V|X@N*uH{lYHd;%LtPKlPFLQA0m14^Kxu6ijS@rLeQ(s8`YZ(}Xb<}xph`;s
ziGGMpx=U~;3)^=b24Wf*<21Iw63?HDzn{dqr*Jn#o7={jIiMnC2~tREPacv3dJ*M|
zyhk{oj%^0I*cD58^+9f6mto(&LK{+qHqLE$&_}t4*Su!H8xpXMtMNQG4SNR}_P3lw
zk*gKj@QokkwbJoR`*_?ZxqjL2F5y^1hUTSH8$Rn3uJ7)EjNDIhQ^~I>`qd{~1$FY`
zKHlyhy2=C}-~J<4^BsDTjzT=3VaYZ&J=rlI6FRfmK2SaSkK9XouG44xewJHV`km=Z
zBNUFgq~IEf^8^3A=iY0mo~Ie*O467{dcMghA1ke%L0g#2zLDx2vgW?d%(cup9Q4Cp
zNI?!?-Fl!i&vRrp0l?%P;sXr7o~5-Qyb|~u-p-CmZ{wKXvlv!9!V;j$AGPMM2^32I
zPf(TqKTwWV0JUS&N8B6MK~r`#Zg>Bmuws$<MYJ9ftlzS6%25NfaO3*_1T_JfUj&sU
zvB6R>Hc-8-Sq<rCJ^i8!t!mlgiMWS`d8hXAiPp^DUXR<_@#I2m`gq5JnT2e$_YD*2
zh3sqXnEwvusYu%p%w$bO@3&s~m}$x`I{5`ehamHdh#s|J8>RIp_HlhF<|)m<$K|uF
zJS81IHk4x3tA?K-054)mmLCwd=$LOTh79d|zbXZEnjcirIsPSdkojeFN&}R)^hput
z>0@7jwG5eGgq3LvSP%AC^T=`#=g}{Kx`@m#g6dO-jgrP-0&u$w3zuvH^*r-bs~V+A
zoTu{k@wR1I6=@YdhLvSC8;#5>1`YDNCx#bI)0!9_=o(6~`C=Vc!l+y=3w*!XZOtc@
z2fn#q!1p_3ei7eQ<p8SAPHWyl0;nTj0CgCdUj&tGr-BmQ{!5^KJ^cTGim(T$+1u1^
zkJA6Me^vVbKslBtP}{BfF&7Yc=nJ4?k@-ae9}%eEwyM28=L?`FAoGi$vK*LR8dnYH
z6dlp)f5b<`hgP+Onk+cDkB@g`e)dBT5)h@=&noKmICokMIJD+{iH;V5p61AwN|O%k
z<FlPupnr!0C9BZ0=|zS@S>Ar+1p0C}tMp}mi9Te0nZ63ds!i6suMN1q{|lhDA@hr%
zQk@B_EsD($SHl0V(d7QV{|A)TMFGVv%K$5s{-0`P_y2+N(EyaZLBT2!SFQg~P@%~D
zB7v_oB&t0oQQ>BFv*M8Me~QYLwUw+eZwho{!BTEz+*;(u21<!vV*=>L>Pmh{`RK-K
zOF!@0$7{N?%F+pZ#JV$YX$?Mxx-(x%#>ZTDR)uxnMNNK=P4DlRKc|E$S#-qKGn^64
zT2DBxX-^L-=W!q6*d(?PVAc@%0Vf>$501)JY~r=Z-Ze1UP_8->zvI1%|32eg_`7o?
zU!&_)v35iUK$&(gr4?Q*kYY1xC*UE}z1tG8WQ(Ql7`&~V5qM-nLuGZ2AJ`okz@CxE
zRQ&QDbB%^Kg?B2?bS-Sj^myM`#AYPpP7D{!@{1}YW{UDFF=sJhj%}56hji?Ggmmx#
z@%>#EMO(fxKEdzwicuCU$4xcR{>`cY6TH-l)Eo+KB&+RTO-W>wh;=(9(Md@hO^JA&
zR!RKiE2_7r#L}k37fRwpN~FjN0rNT%wb4_KS!2PE(dPdMWMi4>4^NtcJuYlVQ?s&&
z!XOSjghOnih<>k(FaG;?Oij%5OMhMbw*%O0%1<+U{;<B$KckU32WholEns4C$`JDc
ziJ942Pxh^)RDgM_W!!2no?nSAD_10g%<N1r7HuirPt@~!-Y|@}qx9LOE3-5!$!`Fz
zu<~WErJ(+LKBEfru63m<xR!QTEdT!nJuti1$LL?SlX=7ZY8BQ=3JB5j>Qz}y?`GZf
z*d-Vhk#-|8^&iVoHL&x6FgAFgcwV`qK6_YI*2B{6##ymy@3IA}_DW<+888ANNq(%K
z^_C?qEV5hsvtKNwsl5cQ9z3=>(^)rKjEsZT**PnzUV@%atI4WL1F(#~l|FVf!?smT
z<}O{p`sA-QS(w{B^pm3Nh>ZSwqKVfQ*%7taSWD?sH^HV#{8nwot3W}O2PiW_+Sy`F
z-9IeSoJMl5GB0;?v8#nkUrb>pJS&i$l(g}BzIs?xOP*7QjkC^dk9%DPB}dJX{=o|B
zhvcXYQYU<@9Uiqs+K3g4zH#H6dHrBENpi%m>|i$6wh)}Q9=m0B%S=#xcC6&a>Y@g0
zzf?X(&kr_Wt0jH3p7#u4p{A(;UlqcRNJ(vQ<4i-=T`Gr<!wp$iX;*7KcWuPt&6R;C
zH)02+rBQlbyD>|X9Pn|VF`FliYo#LDrwJQWgj=7qsHU!y8{iD|(U~oM5JqP9VpLXI
z)D>UrzlB80BYq{9`X25Xf*CT?KE7&JRFKmr$Rw9G-Ng#SqF~&2)QmOIjA>yJd_B=&
znEh;g;a|-n{F_}fJ<8p(N#tJwa=Z71kdrH65=&+?329>Q{<n${ZMi%GOml2R<hAm{
zGI1#LtcbGYAI@2Bz9p!JErziOyYD{gVE3X8ekj0)gt17g@Oyk`7#n20aC8d`?%AA$
z2Rx~!Vl7PaggO98+d`Mop3)}80B^5?n=EEWxmj1XMMTr`=B!`cKp3R_$*?-Gy|H*0
zHrZh+U5|>ln*s2MEwB|~Jp$@Mc(ZlFSw*{be=7)uE(JoJ!dZ|s=#Iqg=S0=uS>ddT
zyWYQ$g}-BiD^NjZ>KvXtC#pFQh+yAKhq5K!Dl=-Zv>jc1cV<*AOKA?09?gv!CjI<I
z$FH|w1FT#j@p)0<r82^t{SO%V#Fi{odWhAv)cH}~QZ7DL&yRAGLjTfbH*3ZASbBT^
zCgjldcgUfskZ=QM5hj9#!dE(O*P8iAGx1TkHS-D^`%)C1^cxCS6NP`Q0HG;M44U0Y
z2GK%v?VXTbUa%3f8(gVY5fk6mEZ7I-NpSb(@5O{xY?MYA>NrRu@iY?o-PX)oL!~Hc
z!SJ!Xk~N>Q?AtK!5Nc2=tSZ?l`3cB3Q%f-}-3ltS!n{u#hQ;TQ*~UOVw+;M&JHPAr
zgEp*-G!_DC6wSVq@@wn)>1Y-fv$-}}XeFj)m{K0cwT{2(a13IaBi2IjzeReKWAw2{
zKCxw9DL1ubguM7C&?27}Ak8Wb{!PbYW7rk{m;&MoB9;MZxjoUPX^15FD_CO3Z$)WS
zXUHSO)v*8TGLRb5+5#OvJX5Z#k;(Nac^e2n+K!E`;b;&73eSgt@V+E;@_w+mJLTJ2
zShW)9A%^6t3)JB6mF|2@EGzGp?Otr1LUiGFJ_xXh1$%1#qT}yknV)s<=dCQbR~&05
zoy^zqggAIbYw<B54u#s{<7OP|Eg1|t-l#nrAWg!@iuT}h1AG*;XH1j&Okh^^IWSYk
zhCz-9dW*-rcm(cNT^`Tsx|C6L<J>IBve15BT@*Dv;L%f2+u`Rzy0)Q*;MCu@HG}U7
zoda2`0Z`^qey+1z^cIImRO(ea*u}403H^dcb(V}j>$v0Ms4CuVp8#ZkyT#F#$Bd6-
zn+@@^b(s1s?Ifjp<)Msraa1R15I#08j!Kd~Khtri@6pe`!^f2Gqf#UdK0bUO)k8Y)
zRL8q6iCP+Lcqnj8e_Tl6)pBINNRa~$5;~EzoMsXHXLQ;xhWn%T@%o)uO-E~m=*H9c
zD%XuGw=eeTJZ^y0_@*U4(|KH+Wcb07yLA~?OX?S(=TTk8g_SSTb#dq;t21llaq1yy
z+LP$C&xN;POfCg$ow=wBi;yb0>3Pd8Y@_u&9Sq=aU06lyw}bFy*Ok?Bx{0sED2IE;
z5*_YoZc}n}S60bdd=2W#0<AfveczR}wbs$si>_>%^{XU&C3j=BYhJ}yVk?JxUN4l7
z_a_1D)5A9o$)}BfI3!=C%wd|lRQ_}~R?GSVeZA|(YFclnud3Zy2kSxfHMTq6J?cbX
z%eu2Y?%NXuS`Qy5Mmi*)*g{b3n;?xR^<edCQ)VlNhi@r4tPA~$bQpFe(c$4)G<<4Z
zqC@i0s~B|x?;#MIpX$NtSf8V>zk0Bs9yjro=umKtMyGGZ_b|}@@DyO(qr|^KK*1aO
z6*vpof1v%d8v*g$4x|+f@e4wkkUmPq-%v51iuzYZ0-uxse)XcS-3iR!T7$3bdkJip
zrFH5M+zRw)-pY!tZzqcQG%WkTDn#YOzGT?TNE9nUzaZRGBxyQ|Bs^>ce;$YGX$UFY
zW*2KiJy}hug@ZoZs~59|kEq|r!}~JVhBmN8farXSnh|>~XlDBhYR2aBkJJoOe-tLE
z_j{emRprUO0q(fHK6`m@w$f6%I!J)?YViICb2#&U7I5|;(F{(jKh2TD(r9L1_DqVX
zs^??+F+a(&w4Sf%$6T#{y$U;WpdUt+`xsg8^#g}iQIcin)gJxZ{0Pt`+|vGz=pZH1
zZb7X}rk#MZP%<t1wK-C%rR|U9q%CiCe0_fwSaI?_w3z0CUA0kNTcy3hS%Xtx+{G)v
z=-2*irrWCzI*WqX$h4cn;e8J084(kI>v;MA)<~-7t>>o(u)Ip{Gey_$t}E>N?NJXl
ztQBrpSv3$1&cgV7Y9Om4O)977qpz%tv%0L~QHiXVw7IOFZ%AZESd-}j$hf3JAj67e
zW13R_a}k9wrKCV_;b4r%Kr23Kz7f1rr<A7hmr9mzXDa^zyaB%o%QI!py1ZlsPg8~S
zB`PT8hn6f~K=PtF?vi5Vqj5qby)~wh5$>3SMW9xW2$6qenkTVh1$_Qppjf`e|C9gd
z!oM0wdov|mJWUsN4Vk$jyxrfsJg`L&)=w>}sKMC&c1R+lib*_97uj$WhDuaHgWO8T
zYS-KG;aBt?I)6kMjYe33W?o(-%EbEN{>Ee*p@sow5m>mnP{&r-d3Pm~Gt9mk{^e!$
zY_Z+AE|hZ5W-|WeJM?Uol-p|`?=YBo2QSB=5$d`>3JbwVOEc_~kr<nX=Y25odSle+
zkXkrSX0IB|j#)}uzZL-8Lg>H?s?5UvUJ;xjcLW^T^fQCg1*wXzX8YK;Ic6EY6c-H&
zOY|Zpy)y#6;PBKq9^K@I!}J~s)N!X(gMd4QZvCr^WoHdz!In<7o}e*Wgg`JV?hAOS
z<8PALq%fybRJQ=zOZLB=G`U8CP>?j_Cah7p==637n`(#X{WFFSgUlT}o;933ayi^y
zaMJ6f@^9cW{F}XQ1RG)L(lAbB`8QYo4Rpo7*)>yGPs=9%94&14E<U5_xFy*8!Kg{N
zR<hOn0p>19gku{&Y13UDPjYONAT@oBuI$*RYT-0$QLkQe`~sirEK(=<4YEjS6pbs_
z@i?TzR9A8*aFQq{y&<-_jJoVSy?PzDWIK<Dj&7Taj;=&>1(MQage_7sb{1v0C>isV
zjNgu+hH^^fBe@M3VFQ$mxS|?Ql#J<0Ml5AChpoW9w?B~V!@3_~qIHRKlvkUwP^BOa
zd2ULjRn&}v*g^%`=fk4T%A$-3REJ{F-YZ$licsr|EahMV?HQtNLz~^Wl{dy%epF5J
zg}%X1_P_wM>ZN+|j)v+eP=E_P=|Tle9}I3Qg>^H`=|dZY-~Mi<=jf5w&{ptu^)_d-
zekROq$LLAFM!?OAraKyKHXKRh9mcUbeg|_vL4WH>(Uxb8kD}8X7Fa7?7l9!ZRO@c|
zuFgBYb{wlNeRWvJFO6eft!F_y@i_G*U<zdo8!vuNdq=8L0PrWowjgakIvTZ5)rW>j
zy$M@5{$`^z?oE}t1R%`wN$2`}yVS*B^Rcwp&2Hz4?Fu>ph55x#I{rfHQpM_{j+e9U
z5>e`4F52`~UdURN3$?TE;!`6Kr?HHht{4)~EpRFuRV@tKUNns={27U#nc00Nut>{r
zL?n1ML|Nr9+PuC(f^rKezH+3iDs|6{u-F^|d%D=@EnLb+6IolkCldTeOrv{zz1NuC
zP-assrKRwR4>LBWq7!b<!h|_CE#G090pUyqF4SK=_4|z315;TCOKAl><AamfHqWm6
z$=<*V?}F}a?!jQuJ#{j3w@Wc19nJjO6|=l`lUe^7)8hYt`I_LTH59<q#iX5zN&5j_
zJaEpVNtk+WCVan+2TfrC&d(krBLEyxGbUh0GI$ExDs9-C$UUaAbpHTcz)jXHdfN3-
zM?iPl9>I{bJ<xTkXw>w=uzqeTYh-nJZ?@GmR@$;&hK;30VPQAasM%fAaBZrvP>Z-+
z7|#5Us0_k`|1|hD+sB(tXI>E*HdUOIdKet+y9~u?IuUZF$|7uN1URqxa~Bz*=Q!j*
zV3sRj3<lf=%@<E+KCHoUXu+^(ghQe6RlBHh`{-<N5<NgveUeL|i&&D`kAkhSAza`P
zoAwX1UN5p+`2|H|pBVQ8BBnp@D#}z*P81OXaq-Vxq|kE95K$Vl(WNK@-EJuQ;qMG{
zOvCV1=$Mu87`(9M;(&(tY9y60Y8om@kgFkqy00g72{FL|QmN5Rto>48#9tViBa?cE
zYe(uG7N{lOcfw_=;(Qh^EnfB$Nj0@lcn!$GoW>hwFuzh6{#sn&#QS8h0qz0h;o#C3
zjY<Y;;LX(AI(|QcHISC!!+ACfbesw@sKFmP(2NQyrk%~IwQPMKjTElUzyduLz#OIy
z05|AV%o(6f0KKT7BR*AC3d>Rpw&UNsb?M=}8KZ7qpQ8LoXnD0ctgCZ4Wds#v+<Kzp
znR8eN)^3MToMk(pYL$_XO9(F)M@EMZuOLSaBiNY?fGVv%BBc$bs7HdS4Fr%NMVQ%Q
zXD?su1h#5`$0#lMk4pl7Kw3c*B8VOkW7OdE8M7fXD8?Km5zl8u?S27%wc_7+bn$f>
z8gD-AVy?01>*28u86lT<*8_~FDE@3nb>1$1sw}a0Mt=Y6;g$R+oIyLLr5Sg_G-Qw*
z;@Xqo8$rnA>M7IP%>0GUhy}!b27J>(Hp@PT-0ZV-M95J2GY?<HI#%mpN@{G#gLT2!
zYHcyfBN{g>i2oRR!^%0B)GuOzJsW|D{Jro^5MT6CXCZ?Atr7J-^(6T#X<rux{%_eP
zy3tBpM~iMWXe)JPI#QuT9NB_V#L|aG%}*zRPzEMVa9dh%R?{y6(iMlND6)TKhFIz}
zG>awD{E?-&`k9;!0$Dw9Y~>%$8rel-@F2UE+zxgvVllSAn!nfaU5i<iv|_7{|Gk)n
zqPSOvo;Up-o12R_V7cLY*3s@d*-6yf5`%iBmasjN=W$rwC0GX^v|h(=En!vNTdW5{
z#*?v4o{oY?jnz@CC>dV%*~cp^Wz{NKBiCU+OhBkrN^J^B3BU|T1KS{_<1Ue<?Ar#z
z*69#i59Jq!>4bTndYWkL30wU;+!olby?zF`FgZTLU^HK+<Ce>qm(%{E;C5RuJNP9w
zoPwIy=XIB{`0^`mBRNq-2=>RS&v(mMb!M|s@cRRH1i<fd8;IWv{1!ujRhIYJj7q+M
zFH9&-5*r%gVi|1V=63@mft6PtiVTM!F$IH_J&k;ni%okfR%`#E=u{ehaO5M0&_5HC
zcAtzUj#>usddpdl2GIndwJ6dVb6|>SJc?g9O<`@BzaL+snSSU``CA40bzkWC(dEpw
z*@Jb77IY6)*b#i-3WtYK3TK$i_V}qx2ywFVS5g{`Q0RvaYL`2WLEC8sYsDCVl8X=k
z2?QB7PeY$WM~s9khHEeIw*UyAicVMVjm8lZ+fmghxQZBrBblgN;A+%VKtU>|W*Ayb
zC++*)P&SIR@9hoJz6gtA*Eo+Qjvlb!KdfNgq)i8~e7lm>)qH-7-hf~xpVYBF7NdNi
z4bP_Q`N)+lqBd?(Xk1@(P&6GwWysQYi!}aN@H#d<0R27NsXk;FqODY)KU~Q|B=;Y5
z+-;RmU?c9Q`TZhu<HJ_5snY7TI{xP>R>vXhkPd-xf8xYRhK(PJ)L+dONh4S2_{G&M
z7<%7%s#?us4I3v}uF>&DYf#M*Vl-8oirZvvtYKf<WO&tTRG&9k%i2fGI{-mBL+l9N
z!@G|d`AMR$AvrR9rz0TLXZV3!tarj6gL9wX0_r1*2R_#E<7-*f4mVZ`%{;qSXl9v}
z#VtYb8dPcsCYqpFP@~rsC<5$X7-jM)G+KZ?_(;bau47d@_g27mQox>CQ5@`%)u?nF
z97ZK*)sM(FY658Z->xJI&||WZu-ODU5}<diV;;=^kwWQE<U~TdL1#aF0#1Da=Mwr~
zL1+BzB!1@7&(=`Z&dXJ0#WMUP46OyhNQ^K`972he6qNFoiLq)IvU3%;$n^;6cWfGO
zy`E{LZ?kp0*Lv)P2VT<g$?KtA*Dvb$PwQEG&D=0j$MF|Qw@2ZxViF@Zko0W!Gb}l8
zfJs~jr6$vMF%+il*#-!HHhi_d8(C}V<uV=LvXMoic#@3b6eKQfV)dlbi*>y5CRWws
zF-K206GaXTO}6YTMtMQEo=#K?U%bI=`J7EyZc5`izJC*IYIh$djhfrr6wQ6w#70P$
z7wP!$%`8-^zDLKiHp8T*Amzel=Ht;}5qj&CkJ6~hWcpIk2z9e`?LKb31uJ9aQ7(83
z!y|V#Z*ZDU;5T*)bM{Qz1qQ}Y|I7qtIR;S?3)0^&)bR~lu+{T<myX}r!aU0doQG&v
z2qW|Ij*eSxWmR+w77I;GTP8HI#bU)q5+v0|{=Nj2hT*rckr=@Zr*N+fcI)!f0SU$n
zR<VC&vWlmLNz8;v%O3+>#p?f7G99PsX8KK5yzXXJiErMDZPnxjI(}s<3yHl7?<Swd
zSLn^xi%1<;P=8qg5^&4{HqNMdiBU2C7lCsQbc#A#oKV3w(7=}XLP3NO!~N23W16lr
z)H3COfMQ}T@dcI3T}XOJ!ET5YeE^OHqRl%<#2GuZS>R25LSdod`Vy>@Qx~}-aQb)^
zqu(}GO?tCa$6p;|uKeRR<|3WKuL|2)Q>o7>9gpA6YI*k{_Xj{yfxqDt{?dD1UZ+SU
z-B4!ncIM?-x*_T5YYgy4O#%KEO-OKm^>#KC;?<1R^A<Z;kX>1HMN*%7Ay6NA2TPVd
z!+^Zr!CFdvAlybfS$z~Yj8?T_@=g{bmD#T2mv=IEWDGH7eBQ|_Ngpuedu6dOyAc?W
z2x{B<fSQ=a*14XCoah#hDet9G_B8K_FjQ{4kNfOm9yS^F9;5WU`7Rb-e&q>>Vn0}p
zr}S=M5poyvjk233)W;Hx!VsG?SFt#bs_y6)pavcBE7Y9`cSUzr0gN)DK5*a1U+)4x
zyTZ4y-OajHPT3;R5toFE!Er4O)0LqnSm3&@<7_wcWaE%VN_a$QTC3}dYFrnpK_lx~
zd_h@po)}qa$552c;Y})33(`=iMZz4_JYgoZ5{pS<vb`vi)Zzeoi^;`x7}cHlg0+L=
zXty9X+D(~(JBm>=iSn>Nym2!ognO84k3_H-jTdO}2LrR6-zd}VBq@Y;`UJl|7?KAW
zRwP45JTRL<d7~yssU?6J`VS|rJv7t`B7M;yOR;FH_OMZqZ5WO&Rou(4&5GVn(u}LS
z*O)ri)&kc`@`4S_gHPGZ5~T9?b^P&OSht~bbiC$1)(ll&BF<aC54&SCXX$wMJ{Y!s
zvx*ruc)H}P4M4d+_F-<LLAjdyp*aH&Ds6=YLUTs$heMf=rsL1{vrzB7@c2me$I_w`
zd2SGTPA2*RZo)^I=Gn~0^}$S(Ap=*5JVrb=_q$<mi+wyL8`f>bOdVgH%>t~KLiqe)
zW(zm|ESr&+p70G$#$+>Z&kt+C`4-fO@Ed0WxVX!xEUJbaK<vqAxQKlZz|O5Y41Jj<
zY{o#053>#+WXdjGQB;yQ6m^zj=LnLjt4SHCG}v5M!*F*6so3N~J9iH$G2$XKG@fd*
zc#JGwH=&1ZR}@-2;sCijpmP9x!CD8Izx3;L9q)LMg|JxAlD|VSe79$kwpD~JC}#L{
z<ODnsL^QmhXgA)cgi#~I*AQRA@Oi3P%TQ3snkTAAYPxHo!rLhd-xRIIdZ>m_h8rOa
zVP}B@KcVA3In1q0=QKiT41PxBV6P+v&QbpyNU04zGIL<^o?sxpl*4MZxeuR$6gJ2(
zYlLF&*1%|CR*k<<ev`Be7?B~ZzYGH)Hd5>F0!Xb#i?Yc87Ji5&LD<{$h`c$(LY)_)
zpO9J~scus1u8LYaABI}X@cxD$hFbqLL&tLti$S}qPQT~~Ya_jztmAEuK&!7z{x7Y*
zhDfIAN3eauQ10jv4AR%t9<;?DT3srajgj&u>3C``25EP=i+Q;iqz5A9ZY~Dt7L!yR
zE;dNpHQmRZ^S~fuDp;1s>Nba8kcc(XbSxRP!rtz*0%$|<(a0I4=n!;AVbvxt1M{Pa
zLsyZR6M#QLpXUL_cEFI{!y|c^2Ys%x52}Fc2EefwCt)OyLZ4?(5&Ar3hS2BGDT+Q5
zBvqgDr=d~`eiz!_yfTVDF90NE-0oSH^clKL{}t-<0@7z%!N;;Od=hm851?awm@A~B
zDEzU_N3oqWkbx~nSxE4yrD*JgqR$;Bk@C!^K4?CWKOsMY{A66hM2dBcxw8crQD{V`
ziI1Ya${DW-YI^BH?fpl<*6c|obFGZxf1Op8_c9WV8b>r}8pVkXhU&69ieDB8y~2Dz
znDhK6pn!BUonPF>T%{LF#He0V%E5=%acFnvEFJH0oYiU@51dIrM6;oXUQzH0a9VH?
z8~&;aE?Nuirzp7JL`A_r`H+G?heu%4Jc6fi<v8nay9VPS9h%@T?@aV^caO<njSa@D
zpdIdHfZ|RX`k6-a6AUZ2URPb}^PMMHExhcO^%AQe8D25(>+$C&Fb8r1n%*Z_1p3X}
zzG|(}C)q@4HN^7gNty$39lakR{8T?vk=CbJy)uVo;#ot?%_f~<2{sx2qjA*l@hJpr
z`N}#z`ZR<a1c!6uX-229yF1tCrOvRJ@~3D(4~6l;%=3tj_dLVgdv4s0w4Op;hQM1-
zI~9@o4o75LT0^o^Y33}JKq6)i5tkomCJ4PPOM=9le1hUInASi>%79f)DD6XRO~X&T
zdYWncr+p?c8Dam7C#>_(9mFz;H?`bFVDl8~=5}YXZu#AK0e=z`@Xw=y`5MbF6H#Nb
zkU!ubo{wLDiu!5L9@50lXy|lHSlC!W&<Hj8BnpY-L-+t9Ed(N!fJi|j{2VWS+T&;c
zf&h3G>%Jv5MJIzBe)Sj%(X@SzS>hoiLK!o{oW3P=H7CXu&UglWuS4CZcripQtznl#
z_#M}PYk?iYOyFabKgSw3O@xJ{XGJL6@O=Vw6Zh_QFi)I{M06HIY(-MVhGbC{A0qV}
zlzj4N9Y1moM($pQj(<AG>beJ?2W?`4ejo@UQ0C|^2vBZ$p0%uz5%Sia=I9asJwbo*
zydF)^Q(xEPJI_Noqk-p(^DG?7SsQVcVuIe{0%8=ejn(nf7oePvGK*%~oe*CsU1aS`
z7mOsMU5ZCqFLLL}7uh(}AB5wmsJ}pR8l&UWFQKZ>oT91=5OaCr5^FEj8lmGZml<y5
z@bb5-&zoLm(Gl}#P=5;RBIe0oW2u^id<+SNv-Q17u9*7{-hkqDA$d_ea6e}2ms!;w
zH&TR7ogFK5>Rd{3oeCa<O5tD_DhVhS)aY?VV=tm`!FW^7Z}5`xe>0(zwGZRo6;_pX
zQQ)^z;4dfvfA44l2YHyFO!*E8(-cMIC@hdIzXOTOlu|}bW2hog>If{<*}9F1EYe!a
zYXAr$k6Gs9<x5iQUq({@I*D#2rt(z*9QSn6Pnycdj!?B4Q>d|6CJ|HlMrMiqDN&uu
z?;kD{dk`S1Q+fM&r1P<91<H+mc7AkFoURDseXcTF_aUGvCKm+If2sL1@E5n=!{JE1
z$~t@Af}eqUinf=<-47s|_5t!%!+2k1;Z7M9NXf^bn7XCUBd$TqkAI`%6R%;y<O0_#
z=nmE<(W+q>T_X)mcTYX=ikcG!@++L?7PD&i>#Ppcy+NrjsC)H?Lfwz%*W<&kL)~Wr
zkB!$!-9v_SM3m@twpel+4t2f3YDrb$0q?zm)rz1YI_~fT`wpeDJK(aBAJ}}U?=URh
z+(fC7@MQ+vM5$CgypEefk;hrr=Re<M?IR!4X#U2eIa?uY5+QD@QhKadcOtbm>BvDi
zqWN`9A|Jm)$5Vb}zTK)06`JfmTxhb#P-rr47*f`srwl`tW@dW)6}2hWurtEEQM6!;
z33>!Uw}8$F)w2Thmw?`J%Mby5WwL;77-9~+EI~Kd;yY83uvF2zmnbSg4WJHKsKv7}
zm+gCtc}OGhG4U32V-Y9_Um2x@f_^K0mZP7fplkF+3VM0Bs-PKWi3cfBRZu&<P|)1L
zg$mjq(;!+)rTZj>c8(e>wlFRL(}F(Op;}@I3v-(__vit?fV2_Dbxv%dF1CXIF!(mB
zU%|T^>7p$P6~+-}-G(xLl>|oJMl{?;jImJ0n(kJI3KfwiOBSPiG4c8tQQRZ$u&98H
zkQ1Nl0mgq?+>q>Bq=I4EC-wNlJG3N<=H2cJi~Fe^u4}jp6<n=@Cvcb5a@aGe$YNG+
zr_T<$$EsLL70@X<-)CVkvPTgBjw%)TuKR4V)EAgG{0a3&vZ8t~5E`ER6FUF{Tklgn
z9{7MoHD5ymsvi`ORzrtE5Tuq?#nkdGj^wMBaRS^)v0P52!?E9x^?+6B{Ct2=n|p(V
z+T0&tt~RZcP@@5qQib43?a^H$uvSk{vS5^&VMCxpR7B2VDWUp9c*(;Q&;u0E+lzs|
zl872dz;qSD$_e;=nNZIN+k=vXV=Yqj??oBxAH#YRdH3Lpsz&uHKB-(YH7ga>)vQtY
zWB^qLpp2TQ%b`P^@Uw;Z`2+oog31o=N7Vi<mZdnRz6C)@>|&NUnG!vf1zTkoeP;hc
zjSa*Ur$}QlAsjVEXzW6eLc5{3yb=GU77Rg@$vhqJ^oT{eyTJ^rx*LlCF~y8pA$R*D
z7Up{0id6UTT=)uwv3>~Qe9Y)B-r5N0ul1M(Is2kV(CjP*rIkg8HN5Z7Sag{27)Jxj
z!`*%Sn6;3G_rvDo6Gm5X7+b2wb?_7R6@D)?{l58xB}z5mur_~+na=ocLG4TkBqQYg
z{}J~dU{PJ)-Z0DoL<I+gp;rX~5dj4hq$&s~*mcB$V4K0%MWeBBj%XASTa4QpO-zg}
z21~@Ku|&maH1?Kg#6Af2Zld%4);=>7lY8&`z5n|>pU>lP&e?6Xz1G@mx0fxL=2l)x
zgAo9xd;|!Mg^AFzKi$gn?)>`zE;6S;3V4xOSs-GKnY7jeQG)stA7|B@h_~}3GBi&P
zmq}-GcL#j4vhq}3>CbC&SkUb}r_QIykdyVt@O6#MYCF8iVZ^$!%yrB(%*iyx115do
ztW`LIWqbM?RL@-;4`QZQ{RIhJd^;~NRE5^bGrI$)fR7i*U2}?;2MJ~Gx1+J+NUEkb
zThL^VJu|zLrvjNG6R^$r4nl#=MVaEgP=fWjlb0)aAf9*T4lJ9PiGF`KuPL(I#v7=d
zaW}7<urLF$`@5WT)8Y&Xm3Q;T^t#>~lW%1B43lqw;rS;yCg}xXK5$^<$u}I$x4R5k
z^s24MZJg9q&ddgRxQw+J4{CMC8|T*Mr!Cm_dwFRM+<{EF4JYhPj9;yF@W~7Na&CzO
zIJa#3)$HIE{gHnz8sfbA3GQF{7e-!zUb^i!XpPC`@<*@~i0rSF`7)x4FN5&Ji%zGa
z7kI;+4Y_vU4cud!b$Rvt-e(v%cMT6XsU0I3?v{_lt8q4M8|3SnF3&&k6e^?B^;Z|j
zT!W%N-$v%y%D2R`Pmy5orq`IoIhlF&!~(s&W^qAg`W|?CU=}yfEGQIn)7{PEesji}
ziF$H003lZ8EIOJA5`N@5hBrgi?k+z;8$hwln1S!r2b(#lQPCKSIA7=AdJx6<u|a9H
ztO85@F#kL;V<`LHBCfeGYjO@Nvxtk$+cJPSg`s5mFi?fgYn%bG;UQ9Jo&$f<STyQu
znS!PuX9dIOAA1uyT%io{vYEeZ0T0t44EV4K%+jmg4Iy$EJ}u>+<{%GOJ*DkZ6ri7O
z;VT71b9J3Khen!Dxr#BSXkTroIaA|n240z_GOxL-AD;9oTjbWO>f^V%6D(lyht+DA
zqM*r^*bY*NHB0=^??W=-cD}<j_F=WVFmwg_z+ttW**YS>?yx%4?4xc&v8=~zxV@S6
z^xi{R_z`uW;4=yFt0U_9ZUyi3N*h6G)6qs5kmeJw4B+9pd%Bxz-|1QChRJqbSR~_x
zi#~l)3-hpk1VQ2DT2Sz~+-~gOIV_<R?Ot34$D|bPwkBpzELD3554#Ly%SzRu!fp&w
zPL`^@1&eWr)t9P+eT!oH{6#3{8k9;SkiNVt33*YBKTqic74*ZSyfz_wq0nho_9$+D
zPbtI!+=bn3h@%trUA&0Mo1YQImLQiw_==CJuL-NKykiS~Q9BEbJLj;?zo^v^I3=x}
zL->i#;mlvi;rBiCCWpBlQ@aMdgR#WHG1}BZVsd-f9P9gB#&9T^d=?qjrCER9Z79n+
zrj8T>(UDgkQ|}YTren;1T-_hX*Lb}qlzvA___MrrPKl2Ru;%a<s+q`_zj*zs{zxeA
znZxG&s_t8_9fg1~A8U%x@~`TBP+8d~!`RLf>Q>%G=DsF|h#9)VMF;e@LYy~bMw;QF
z?#qQwSc8*lf1%fzcP#Rx+C%ZpSe9{8-L0Mk!9kS+^&sI%b(paB>N{3>67>J}Gwika
zO`U*P+?eMO*4k%QO+>}OQH>PiaXNcoXs8>;fIp})nkR*@g%8zXwvQE*eX)-XToJwM
z8A2oHe^WPdjUX499{~VZPZO2-!5F%c;E3%hh@RM=#&~M)=2qxJbWfBY#n4`(Ha>HJ
z(fwZjhNG^zhBp{pw&0}NRj@<h&8O6@%`P8KfOwx$#|ybBFIeDd^&AVwWYGTtJ8(uF
z$|_H*>zjEeK@|Twt)?lV+gQtY@S@s|wLhcouh{sGeRD?LEALDar&L3ToO}pjF1*dX
zK3M<;b9jfoe#eiK?C51;vWM39l@Fy&W<}<69{q!OzatsM8;ukr@vcH2K%};yKnDK|
z3F2q%=Ojb<7tHl}%sx4*_7o}-hq9Gt)iLgyJ_6~Qfz))?&}I0D=na=p5?A0N?DO)h
z+Q)tQJY;!@B+7D2?lAKnQWh<;v^uBm1zcxBs5!3RoKwFMMvi>OzC5ocZ>8gF%=MpF
zBg$sJuJRu!6!Me#tmh)dh=PBi%zs%l%*XH~BN}CiAaBqGNMLZ=p=`i4^tO)4L)rYR
z>UMQbl8!hnu=y9&{`KxAa4P$~GJqvqRC|PN;vaD^4$X}a!LgKIw+?~U@)ICsV!_uw
zmJqB&T>oH&zo6mIFX5SAREH^6zGH<K)y?Xu<Z652JFpFP`aPbS`Jl#``R`c0OKJ+b
z9D8ACKl_q8To^ethb_CLZmL-HjvcwA_Oit+Ep@LHF4pD+@k80mOHf{`5-`<sSsjTA
zzJG40VDe@3w#o0<ip%Qt_<rhH4okTL$cDdT)2^sz3K_$nF^k{Toj~V5vB2ene)fi+
zNoRc+DMmW)LZ_jA=KY5Evkg4SNauNRp!2HV(RKDl4`nvjL1!lroao%W&mhow!fRe?
z=iPra)n9IEB~pw{U52AdO|9ngWiIg~V^gbQ(bUvG)c(%b+sFnMvAZ;%EHbd961@|K
zvVDK3W0VEtPYS#Wchy}?_Liwt%=4<+%B8NM{x+0Yb!ewQRh)DcIM}x_;GhGA2?vjD
z**PYOg*!OE3paCim(P|7QF0rxjH_x@FiwlVU5$fxzKlcQbB_3Qo@B(~a5S0<y9TlJ
zk1~j*S)74frC9(w{~0f}@zy`c)k4;Q3y@+YS0W4xk?X2V<MBMn*wo`TXv+3akgH?l
zzmY3FRwh^X7jQ$$<K-$M|JiOnO(Yaqd)8=ooFuoqR4!yztKDAI?#(|z&5v6fsQE0$
zfTD_;dhm*)c;@CmP&~rL+qwiPMif7Tnk5v^%1y20Nk$acM4_pluLH&9t^N(g9%z?K
zL}Dh|jo?+d@4CSy!rSFAtRGcfPT#A9;YB3soKptyPemBOKLp7pVGu?@!MogmtxDMS
zj>X<kduFQvUiqd<S>?6C!Fte&hssFh`NGbj_L=uld%3sa$UPGdLd=`%ltVD&=na;a
z<I*CoHhXfZiD|{_Kop7XyP<Z>D{@c52OdP<EBD5ktsuhX5^|HW?fQtfyq?#)+>qlX
z<!FTz%JGw2Z!ex>q9MmtjCsq~8tU+W!RuJebM!Lg$buVR-XI!DREgJ1p5;Ez5@yIk
zhf|hYAcb<=<~iI&<lxXMfx&{C>ZXFC1BQY(LArTeG1|PT_ULzHc#g?-cuk2u6Z2c+
z@bOuoV)+;NF$Q6vR?ncG4;0jTu5hhOs0G70sTCML6C+2K6L{t;;ivb#1qSXz7c01>
zZl~PU2V8on<Eddt?R>Bk^;(x2bwn8Icp>M~!}(4rG|Jh<2*`xzZMB~e+j1yNy$w-#
zosq-l-&XevD2l1W9rX=zU!2(ncCUQ@J+uXVy+(G2^r~@iF75BA`@s`ievO##gXzr4
zcho_G)s!5z>5e)<SkPi9dvr&=N+|pG9h-kwtyX;Tj_K~IBP_r8F2UrPGH(Wp(W!&1
z$OoW!ziz?wcWl5twS!P6bSRs6Pu*H@OU}WlPCeah)@C>$kvh0(CxT$kjawNCHv8~X
zlo$Jm+#@jm6e?_?PVJ`{^p5S;smJsxGQY<=v%!Ja@(vmP(G_AttxJ2_Q;Okko%4uz
z6aAxP>lB0B)wJso3ff8K>M+k!LDWa*`dsFUjGu2f*QZR@YVE>?vh(HC#d@HN-B%As
z(8>yngbMGg-CT+=bfx+qLei=`s$~c&K6qc9DC9L8$}B6?Zl1+0<QC}QWHJq2)SQj1
zzjlDU?JCg1`))a`ph7)f_#zQYR4dgPgnYkB^&Da6CpjhMmFj3y`=Xec=ZQ<B5Z{<_
z09()|oX=sA57quYMeYZYg6XpABM+7NlSn2F#~yA&6nW-DbtmD;gdBG9p}LU}HYA7r
z^-%q^_0cgHEwrR=Vt$omF{a5mYGf(m7^Ep^5LjOE2c_)gjw^N?Vcrh)`94<12~Pe)
zndY(j2iq*ap(aC9lp_xeRhF7hUjt4DJ%Ov)xlIlm{Y34Z_(xmN9|yg-k?UFvo^aQ-
z0o6)xSRx8-m@lvWP~_qm7@P{pIVXR@8NpH5p^ch^32m|L_z6Z!-;v^bs?O*)&X0!%
zhBf1%fm;Efx53NaC*NTc5(pe=tIryqQ?;}yqF>&SHofYnHXt0uYY7r^&~>gpa9ith
zm`1BH=lWFLU$DW$YFE+8<3%qy@P*9lDf7(6$b15n#xSN=4jb}J-CW3SpTjKN#I3>$
zj95B6SGN@Q<KeNJs1m-#!_w#KX2R=M@IBo{zxuzm0%-O1s`f~E^Bj!%5-IcC#istb
zNFktTHH_{a4w#{_+oK~iM7q+0kKJYf1I&CJc&GNw8x=@WW{;6r_zC|+3TVaPOB&?O
zrs{MV)%_e)iL-OCq#``6MO*on2}HE?zVUw4SO>Ed{m*oOKW(aTudY#&Ypej-<Qm~5
zp*37rv(!*ybd60+@{u~qNDvmQ<$2CmXz+>;_A>$(oMG}Ts^$<6$0ff0#@-Dv9KG*n
zUFr8h$C~N1O?b_lF7~d2C@ruH{jN%>or5VafA46T#^S&3;U+9hLj<O4w5R{5G>SpI
z(#0Jnss(hfLACDjFH8AWO7q<oIFGAcoJ&CeXwaYlyE&Q-p@-`@`SVX&C{uB{=5RC-
z6fYhaeZI~5rqJIM$wCVhCJ_O2MKKmSq!!k}BF5Z0*hJ@qeN_a&)t?D~QXt2N+-&vo
z?hcB3F)ZO&_h6yd04ziq-`kFLk&>;P!Uo7N_v1y{8;ju9qOZbpgu-~Jhkns^?3DF)
z@wV}lRj>Q>Ak{t^gkfHZaUrI0tZRcF9=36EY7?Xy2Ku67ZwHH_@Ewis>Dfxh-c7I`
zU^bp{bB*l}P1tXay(jy{0`<anDMkdka0K+a=mXS5lg<VNOqOg2_Z9{<!IV^EF}=~A
z{gnDmC*nBh(>-2%ugLYTqHvf(rf}RP5^19Fx~vZ=Y_zWly}D!1$6vbJm@`8Bf@=x+
z^5$-yGIyUlp)+MI@HA`a3530~<LrX>ILS1-wU6L9nO<8qaF|u0r<iAHGQJ@Uu^M56
z_zltSjbBATkW|M&ZZP@=P0UyP@gbva`pxt*jg;B+cb^(;^7tLrn>efBO;$qCs>@>Q
z_-S7;qF(hE_Sk)WGetB4)J?=d;m}(J+ww=WufsVgpM75F64f!(15lWkG;u8zbK0;c
zd%LSx$ox!mzmdpT5kre;D4v4|Kq3Woz<b=7fFuHB?OsI0-2KFsHpB6Ri3W%xuIt1v
zTXQfW%<(k(9G%a|DOxY3XfoCsM#I?L$Qa=%xZuJ1=Y+=fpSMFpL3-5=ct#0PF-}2U
zsaXCY8}tX=JNQx5)aQGsfxHeiah4YaEVz*1V`G9MX+@K<W=*e~n}zV@lM4y1HW#1|
za0!vTb1MW&Zj>gul`t<dhi%X#PZAp9!B?9c99`DBM!q)S5en@BiF8V`XZeRl6C`x}
z20>DPH$n0O%0O=4D<?U|PJ<e1s3RUhvS})I7R*~C6!IX!t;Jm~hu3uxKW;}{_)u!$
zwBD(O6S8#cXb^zvJ@6fKZ@gNAk}duyxt;YGltWjNKP?%a9P8f%UkFcH00Kala!W8N
zj0muYmh@2C?*l-CKZhrK*p$iWm~i9LCJfR2K(V>qSNKZ##-fgjbQluYj|;<-{erYL
zvma^+&iG*hu{~L!(h3`r24josTIR5TW}=tlxDtZAKk{IsC4P<b*dZ>18!KAmuocJC
z!i2!4H6&S87kZ3nd1WURJ(NU+aFSp%u>}U|Aqb541&NL7{@R?XTm?JWElBirPU4w^
zk-1vP4I&UEwh~qWw`^6kJ^M3Av_&<85Jq_(BsQ-5E{Li*1ykwOT=cE~@ekByc47{W
z*y_?;Y>ceeUm;}BXj(wsaXf1hvTj6H+Xp)+>m|si5vO9)m;lR=RQ*ZamR(QSje4V-
z3%;NO)T4^|)gSFBbi(I^`lG!(&$W;#+?dy4jXG*VjT5w5c8((I^z)zQ+wkZUJ=Rq9
zPA&RgB(Yoh!xJWib@r$9t`|PDS0YWP{^5z9Ru06$7b)|f<{h^eg$f>3+)F8JN!_zy
z%E7yJs&^&*5K8Ue)0uB493CMGQ?q@tD5pcjY@uZ+hu)s0go@#I_d;Z#TWzC4-YA3<
zDMCe8)sIL>!J)9w1x|g-?O=h3VFyCRMa>#gQUSJG&U`T5GxgwIvyMe!6F3|YYlIww
zsbsW|uI*MRi)k&yAX`(|5W@w(f9ZO>d#-0z2jiLvX3el>qI|3i>v=HF#q&sGl!Hl2
zNh=&@LjlM*QVFR=)3Ez)Yak-jKcw5UEgRx2*!`qJdm+nSmaoWeT-l`YwqxxfzX^Jk
z1I!XvWCGO~!gDm`Il|CNg(s$wVsqG@mZC@FTi+ArCt;Fml8bM??2e0pb=%)PXMeX8
zqg&>Z)sipwK8C(UU3d&H+qYKPDm>5Me9O+P=<T3b+kj;YJ?z=(qSQJKKW!j)1P5N!
z1Vx!Rr?-~^z2!k=oGU9j9%m<<Xjr4~cx-Ga7g@B0Ae|CZ6H-_KuR0rADnQAebv7i?
z-xEiMh1q;ZSxew+80EO^>y1&A8XY0}aKe+~4KEJ_PSDc26imR9ta+gb2v_U=Oe`fw
zHtM|%Q7u|r^J|<#U56%enAn3I=o;-JbVNL^GD38++O?UQ{t5;IIc-{rakeA)7d5^Z
zfr+;tZEppQP<@zO)}r3gX7pvr(%vz>HFzQ@ywEqQ1*@w;hkUtdyWU7;y=pCq8#Y9W
zZA@^JRAC*?Ye!7en1j(u;|B}9>MVwc8^;#=u_>*^KxY*y(W~^Z7d6>Vy=1|;geJnY
z0C>u|gReVnplsKn>_5!b#c6blyp240F_Osu(1zXa@GH`a^2luJth&CyUTW^AIifE)
z;W#WIr6}wGM+r;i{Q-IYp?F9V?z%}Bp!faAm*f54l(|7Jv|I+3)f4%NFFqWM1|L8f
z4+Xm~+*ufOSHTvxjqw%6`C%GQ+TbW;;Nju5Xg3GcM&%3FgRfPy=n$zB$$m=kHw_na
zQF@1{r+U_9U$~=i3EtS~6UluQ_{&|yvJ=TpBnkj3gt|oP9oUyX*g+M6)qf|GyEWq=
z>UH7Y5+OZdY^odLy4>K4=~Z?x&L_5}w(_{Lj<OyKC!(70<or03+(sa*UKP}Z*{<#3
zsJPm&x=*?8H*}CZUN8p*tL!He_lG;SxTDuXCCQ>;q4(W_VIo8i%r-iLgZG=6fI<0s
zeJ&(rniXQuF`~O~rWFtaQV$`AM2DB(5M*VryvBkvqMoupVnk12m=6fjz7W?r#)>w$
zDNQEqVib^FgK;z66v)zi+{~7W#@IpN8|T)ZG#*u};<>89L4Yg(4gZT!PkyhhE!1t%
z?Yy72aTWH~$zejA*vz}Aj$G-?uL;&sFz6o;oQ=K{=h3kAL;nSf+Xk!;F>OR{y?etY
zji?sA?(W(uzy838v4M(4P*Wquy3*fK&OO@OJog5mh1>arQsm2AM;4l$WG9^Q#%f*L
zSbN28Z)V%PhlB7HKEy96a1@GNuwrcF*d##|a#)>FV>`J93o^WMUlF_kFk;orTaX~8
zs-L;@P62Xgb(i2AR=8s^9ZV2+P4MjyeS_-SWcVf>q6O+;8#czEC=qzgmsIy0WT>VE
zvssjxuJFuZ0~Tev(ciA`+c*V&4|ktmB44d`R^k(pqH;~mP6Fjt)>ia%A3~|Hkz}xN
zm*62x;_Q?60iScl7Qm3sVS*L-T{ZObxX&s3O4k<EVH61MRSgp=eXJPm>HUKTm%Eh0
zWGCG9>y=U%kN;|atak|Mt1lx%Ts&%8yntM6YmYd4cFLo7J>eFN#%N8nPl^?lHag+f
zfQkHSjGTBc(d&{{Q^Ub<wW=HDodG?BHdcMy5ixJCw>ZUdO`;fYGXpfN;pk%2aWp(W
z{<awj=zxjJowMRWZ4}E5!baHm!u_qecX}A<6)luIleLr-fuy#Dd07TE_pKQqO%lfh
z|FMeZ+e;HlXC<H%?`r;t7Zb}4AW5&<*sLa$OT^TsLQ^-KNSHU)MX<)hU-a-8gmx0g
zdI=}-&;}2Rjjn9rFWntn7P$h-eD2ws&_xaW37W<Z+pd3};3C|0#Aduy(G^!J71{|s
zp@2A_9{fDP%C99%11+rR2-`=Z1~qW{nhaaYN`kEg62LGqS?nMzhghFXhGiXx2M%2?
zJlLj)E<z+8nx}~Ff-@dErHHr<%^B_BL3z$O$E0vi88F9sP}3Z?CPj2KvxY~?Ry%*<
zplH{CV<AjN{z|Iqu8M<e&)ic*JFk8;Dk$838O2HX;!~tU^bCh79?L=Gtjz=)41)4f
z#iojnta)u#Yn`}k>Bb@4#%w1RJGp#IBLKNDVfp$Z`jeMlRqUU$L^I9NWdf3kBVQ~d
ztY^b$=~dJ53*19Gh)rq^K(p}fJP*pY@1fFm8Q|wpoj*z$1~Y6xx9H<`&yZX*qVcO2
zoRaR*&h`D4QvJ3tNpL}rg*(}XZLO)4JH6N90wU3^V=#1}e1KWzAuy&|Z97l`5Ljmr
zp)HImTngi498HBDs3FPJjY87ImVy+O!-l4b&xJV<fd1*?Hr%>-`bcK9u(WkfiLx}a
zg{d$IR7^aYxl33Nv!*|q`JM1OJcoV%OXg2zT)h`}MLnkYbhoQGU6_J_$w%G9%{7j*
z_3AFR5EfzJ(6hVPMTo=0`tIU1VITbcfF5F+FbWS7dx)Y?3HSW39^$Vx$vXO2W((nF
z2#ojSBzyMbvCRE~72YNv&r}QBf-wl9V|8`MGfxR8n`4*JubESXPI!nsk-1h_AB3$r
zCo;bf>fk{<nYm2(2wtGuZ<$+#5;)bo=&j!}j|f+r=9FwYm6^!z9PJNi2f_uK*<YL@
z-15(1W|?BC;DU#fnE-nk{D)2h#Pz~MxB+hli0^7ZyCfT=*y@W_nc3oT;WliZFc3Y2
z;i1bwah%|dhth%K3=2cJsLLR6p&&p--X0|O6gI)IL=P4Nt4UWfda&qcTK$f5;>69u
zQb<kbp`e!v4`+vpAs?RfXrmFgDeiY<hc)82iZjRA2(6eXte8;Ac4);CVbXhT$;ceh
z$yCUEr)34h#BPf0U)Z%_VsjxOw~{sZNL(XC{H<kMKN1fKqtS7{oFm$^!r@}L;PaQ3
z9U3mGExwvS&Txs>2=OOVp^j5dN!dtIFcnN4b4u=x5(k?K%h3nZ$B2ImE9`Sh(#DFJ
zra}}n&v)a*J;D?y>yL892mUACYI$h*aO%N(7)aUYp{wB}LcQwO<63mPd%AWbsRNmm
zh~vdgroxZPoRa1ri?*i1Hw|)1+D;T(nF=3S=X^V5l4vSut#V58J`sIPg@pRpQ9W6l
zC6v^|`rRqw_n}G84DHagQ;O_~+Ka}<;tt7;l?<iEM5qxHW;0d%$R#uaS5F>FEt-&(
zTGT5(z2F5bVS2&eI_C)X`BX8<`E0m}2`&ru0;IHi5N_{7I<<38ID0l#3{ez>Gv8_A
z=ZdFcZ0|JDNpU%hU7RMiw_gy(i>08u@(Wt->!yXVkUX)KA}OpSCr_NH5I*W($<+B`
zQ`TU*I78@mN6S8+F76jz_vN2=3YTtanavFGg>e0*mRZgecQu%sK?lwqOgUH{nOfM7
z9heQpUOp2tGWmv<4gXYpDtua|W!baDZbB#?cFq#j!lmn|Wwsb0e1V75*<y~cyjLar
zVYc{{Q1qvk^(heF2n(-iS+6-_iqIYs0YUgnDDGa#Ru_uD2vh&ivSD+@-GYC&O6FH2
z{w(};MO#u?BwCpYm6x^buX*B9;m6LEY{`7_dtvn@ElXK|Zqu(*C406&Tq|_CsAbC*
ziVuX$3lPIaVn0FujJILW{$3=0BuqVz`acsRg#<jT`%LU5=+0@G{xfv3ZRfNl;fuxk
zri$SntnKGwm?FZ1P5fNU6M}x%vbUd$o~;^hlojHNbc#S7Rr=51D}R*!n0x|<mA2_N
zO4}q8-DIR!`vN#geTg{SRPcYKW&4>Z312_dvUW>Fo$%uWEo;6EU&8UQZJEe~6_whO
zwB=&5Y0$#+vV38w`E?S4Ld5s6x9)3_E4{9MO6?X7tPpP~gmyYD3%iv0Tu8g8Wr3G7
zmkZzD1%pVN{c$<-jPMJX{{5BAwao|qRzr9V!zlX$M&a%Eg)F@16J%$*<nfoHo28Fa
zsiBaZFQw2Pd)!@@$az1D<h_cOof_QQel5s^1uF5hGPgIjLg@xYm9w->Vtc2iD~G_O
zP=`S}<|}f2U|TQT*0PP8VC*wbK4E7z!L-NX;mIb^HNwAyD1N!-b=^fVAxqn#erq?>
zg&C8dR-j5Wq}<mEJkYC-EZ4HOo5e;}r+3QS@@kE+$>`0ZN27K0g&NkGEs|q~m95C6
zT?A$Z?Rj89XH{Sxk*DS?hz(lYZBEtuj$4MjHHLOJFEfMels{`t_In}SaCXzT$F!`=
z%gkeqZh>F0sUHlyeSaXLz0!@30A$z4Cb)F05RfZgx$_-Vm97KsNu}hrNQOsyq-KM3
zvOEs<PsaMdkKu-55-9g<?erx!>&6PSq4i%+bRMmWZ>m_RWzn|lf>l1W82ZBlol8a+
zivdFQA@JM5kG!?ok^|dCFH@UJ+=)y+fqjT98|?88=z+FpwfuNsk7~-08L#CWP$-}*
zCC0(!Vj;<Z^3c!)|8O5h?-UzR{1WpeB~#No+qEwMr;St2*Z}z(hCR;H(%pnpXwa!d
z^fhx`5NpD+r=|M}zZDE&+4<?sg;m8`wtHH7BeMn07-g4DOCKcEoil{B&r5G%_S^}d
zrsSo&V)neF7kOSMp;e~u5;cn5T2^07Z;^975S_cod=0`v@>)6NOdMGSxp6;<aX_u<
z+Hs?eQ?-juYcU~_tF1AoTn9&UVmXl|UBqYO&1;}HeCiG1-8#zvt+++YE{W+LW*<8O
zv^Qe<B=5R~?M#a8<pbV|!rS6)w=c@?rym@x0o1eSrF%4>T?8>BF`9sD3AMLhN)Hx1
ze$=ujQo7V2Y!2#BDR;g`<noLbr`@Gb9gO`Yd^&-mf>lWEcKa`px^(hGq)wpLYNY%=
zMC#>?AuM697+il7M%9*>ot|lG%F4uamDyf<Ah#nweTvybu#|<(NcXlIF}pTmbxw1{
zJlU)n=}zEJAO;)g&d|>rXQT(`wM6GlC^0K%h^!@)2<7wf7kqk-arXy&l3e~vl<xle
zAxdolMKwyUAEIQQPr{0&VN8>s?qC1>1|w#-*>y49!R*(DK<t~D>3z-eW&ts?Pl4E~
zPirIA>Nf*o>QB?%fS3})6dVKswoLmpJve8;4$?~Im|gi0kqa1F{1*b(2;NL>fh$I<
z)rh!%h)9AY3tWAh^+psP%P7>b1qwN{(m(aAnAy&xT;!|W!jI0VjYRed0}?^A)2&pK
zC}#xE8KZV2biBd6PP4(M`P+aFd?NG(z=I_@z^yw%NJb{@<dC^9b@%``W&UDHF|2(^
z_=WIO&Y-g%sybB~D&t+M$T~8U^bqFB(U<zqjOCc4U#0ml?VNN6p>5s}Ce29?6Y8(i
zva|wpFNG3Vjx0zY>w(L-5pV)H2_@#(UBj1`%d4r}GvHyqM{Yq^s%4&Y(%l;usbcSk
zp>~>GM{`bS?z=zf11$+DvOYc?Odl{O-BY+Y74$tMhI>KdhdwB8%~z&{>!sRMTn58{
z&g<Drk01+n?O=wz8>-k%r=IS&#}B4~j*-bYTz(BX&`)Pvz+ZIq=7_}WRq^PO1xIL!
z#}!)Q@d;nA9P`$W(tJ*8S;xZkV82D*69>}30YFLQ&%jKIk^D!9phfNui1vS32u+%N
zM9U5orZ-lusi-38sOeCu9IJLy40N<wi^}JwHxd4-|CIGOBA!!hhJRO-?ge>HMIZ$G
zUXE*7Zc%!mFycEc`>H5C!fbIpko;;<`e5%p)3`<p;w#6(bMaPFqcs4rL6k&6gF0`B
z>Go#Dby4!bJd~`Q%1fp`BO-(^z+26dO#wWSlMSAq?wgYjwF7K>AQEH5)}XnMDL)Xl
zYR%pL;D;S)2^t~F$(ozr`~$hF(%eHP8ah(gYGX$#mOE0QC7@1PkUq%HWlC*0cN~)8
zv~hXDnOTTQ3%zRQQ7yZ_09yOm1_R#Fbx=dtLg3vWHNXa3c+By3n_RoToj)7!zPu2Y
zPiZXP+XBU%7NyUz-k1v<jE0k$E=spE+h~r&(nYYU-%YArTk=7<Hka=n^44-cNN+&t
zpQV3nUu0enQwB0^b8%0-`JnMbSmkHwO>NIi<lw4#1@4zIT2f}TbqYJOmlJn&RS&j)
zin^<b`wuO3dz?&M_wCCO)rdB%5f78aJh?tmZ7XQGZ!zq=7rOSN#prtPztJ+=&(m93
z9{z^>HiYRzeiKt03FFX_iuQ{Tcsf$lM|!DGm5$O>HauutbpkhG#c!f}>%(IqHr&S~
zWkXl|VD13N2Q8jK{;pw$>d|<R27ZsD1Nmg8Xb6)rk5U~4-y$t*`Y6>)_#NP+KT35I
zR;<V92ww(=Oof1Kh9^f0P3ps`t~g?NdA|xTI56;NMFaeV9xFC|oS-ajFrEU7x?|(W
z{nP8Zs<x9GNQHl+{I{^n0?MVfi^Wc#5<4hvc4Tg+#dUC<Ob|dgdRh!{ulx;zH!MUd
z<LJ|cB6JP8h&Nr=*Ub8iI7XOur-DgmFrYegvXZ%-6&EPPa<=8H7@#=PlU+G0HtAnv
zeuyR!`DPMR<*bpQ9k{MWjQWG6lqo#LI)+ED<tyhmz+RIEkCY2F;z_Mj<gEdNAfK$?
zInl4~))8c2aX~sO^Xu-x{yezBru!$0!Tg^9DjJ&yFYSZI&hQlLT%;J+ZN7#_O^sdU
zGy3KkJjvMDuyJV2`n>2Tn2Z?0TAdfe6`yI@$n#>WR^Rr579EJStF)BPgBOljfe19N
zNa3QZoY@evS8gV!EaNHT_G;PH^Wp|~_3>&F8;Ofkq(N%k-e>Hq3m|cMSp{>rD2_5)
zy+mumR$LO@>#XZR>@8!VpDeeJirGIJ{h>(JecTY^H8?2}c-@G5jldI$F?Z!W$&@Ds
zpP=d`423U>o_Y09EsY(HLQrVv&@GL6@LnGg*>p(*5O~b2@HMQHy9`F?p8N_mZx9RJ
z*Vilb6)}3%+?8Z<j#jkb8;~&Jmu@niFY?Pm5d^wF=ff4MzeP@s`tM|7XMyPHw79!0
zu+i4kH=3X_!(i(4C9%8k<Izgi<g%D$*S_2op6A)z`gC*3CB5q5JT0r-KcFkSe_6Cs
z%wNIumqp(eCg42*NSioyzh0}*hyFp65nG`T<g+e~M`~d-eEu_V{SWqJ!dLdbyYY-(
zlY)Isy7n4*0QJ5f{e7gHP@e$HTCOdbe?<&4RV;hTj{Ghz_G>(p+QN8{UmY}lE~i3j
z!9{MEb7A1o8z22#$;3ZISI2^d$PB;6l23@%MSupI5;2l`b#OqS)zMjUO<uas`>^sq
z#N}<ayTJc1QvD3^=A%FO;V@5JpH%dLQmL*gjaM~h0XT`7_D}}(c2#ufcluL&2u4oq
zRis&RVDeJ;87>&au`apIX#@IDx)QmN#?ghjI7z%@5b=htU>=bH#v3(P2u@5TL@w7M
zBK!=2L7@3`VUda@T@ynD$2r=PiPsQvQ}{h(t*(oo3v2dOvQyVZcgNO6A7G4=w0)rN
zzKrVJ*lt=rVT^Uj#HUnrql#P>RXV_hbuSaoE5a*TzzuPy;-~i54=na=esTyG^GGeI
zA>YCiv5v~e?2r>Is}tOzM~B@MUF)x&0|Io#N&g`7f}5g~_HPj%B8he!%Oemw`Pg63
z0P{Mz7}sx&$G66m1@xiqT%2xqbyxb!a?7Eei-JTEGX+uPAqfA0PPMruHgQ_FSMJ@0
z)5b`F7F^NU+-03^i4(0N&Q(y|I3pup%g){seVy*?shOWET;x~YV#?d%#~ogFm6?;J
zv%*E%5U>Irf*O|SUwjUyKLF-vW$7x3tAH-igrI9a{~yqGvFy~k<%uCsn??N~x<%n3
zgW4ew67vS1(u#bY`CHJhJVUsCAQ9f0{;)saZuItYLO(&YzY9*X%g0f>1=y4f$EpPB
zh^6!$GKBqY*~!U$pZvazR|4l}H&#AFO=Iool1xN#?}#nTruIRV_wI<DnzX@Fm9qh!
z>IV*i)_60VGx#ZgnY&oa`rZ}$V|!vfn;I5H-d-6K`&7#oo(XpsUVeq~>s`?qH&mId
z3+IMGM{7fhtPlPXgN5_=M1SEy#t_!wo*1hTwQSBkM3}#xt7UuciMSXlLyH||;VsRw
zdjqy}XTztMy-?$+`?>He;S507c`n>DO1(yFBE2;^zPycc=15+-EX8DK&&`D88HbN)
zMVq|vN4Ya!KG)7Vk}B$4E~YrW;F7;5mlxgP(}nBEtnpel>U?;t@T!NF6`v1pZ8p3Y
z3N*VfItz8iAWV5*940hWYuOL?#h@GoJOk(%9F1HTQ%%YlA+&!9imHVjW@z^GM$Lwq
z^VBR55eZjdG!jb9d`uJeBGH6L9tpgFL`2z;z5z>GOY`X(DJ+>T<gnqOsx0{I6=Fw+
z(*7hYGM2c?JM<V<11!_B%@yKh;Wgk*yA<xhzNr)&_8E~2al`ihpx4_lk$70SQ=5|i
z&NSCG|D7Timnek$jv=v!=9`g$(Krr+O)<sQHB)>N@tf;IXMN+ld}J`u1uBaNE_G8A
znC%0xsSpVc#Xb;wc>dfUeHmvX?V)w#x@cIc()@A)pY-*29og0gqO(8DG{{t%n*TR8
zb*!W%`_%CPMs@}~SX-X^i7qXcJ$-<1twnF<|4^hO2S!-p6t9P3l3)(5Y`q#DVtE#L
zmFAlW?8Xn{?bw5dB96BVce{^}&m)Al_9A2$hzA^b`SYr9cyXc&1W;%Zzy(kXL?D12
z&p`mEJi^k1WnG7`FCIYvCu-TBkHiQJff|%+A@U(#V$}Fp48{;M*P=?w(+UUU9JpC!
zM318IbBNIne~d=^f&+8$fR?gX%A&p=7@?&%XVB8V$7o62We6*KjFvvuGOs6MX;jCa
zK%5lle(cahi@jD*Cks!;XJT*}D9Gu8u)VHn)JyDnp20sVZLoA|yaS7PDt5GPJO-u`
zOVQG2>T`pcP27kk!sF3eR`OI#&s)EM`tJQgbOYKtjNbh64o3~{D-ApMJ%c-><>R;*
ztGkrqz*A%-XGVcZ<!>=GMZuU}RMn#aU^LFCjcLwbMHtG8D7?1fuV*MV5U>9Hb)Xj|
z<B-Uh@}5+<JH29_Ip%l%`t<-UJ9;g=Q60il_p}3hjF*_5qad?K!Cb(L{phcB?;dZ{
zm%qYW#i(*R>i{BDL%8CS0HPc3w1@M+_vfOYWj9n&EgmDDV`k-E2e#?YaA&(6z2qL4
z*b$Z`8*7A6X8UuoWzNOdFZ30?^s4vMxR8?Eo(o2vc4)359Y54Bx2DSdRzWX^)i_Rm
z5AUS8R>n^1hx!3MX&D6<{!G}?(tIa+hk?;u@4`C25LMBZFypnbob_lM?86wej<cru
z?-2ew0KYZu8DE0+Tew4wDMfbRh4_^f`Hs}rr$5}LFB$n#oNOxm`Y|S3UWv0!h4=|t
z_VF9BZ(x!6(oGcaz<zn~;ou|ODN&^Q?(|^%!Qt+DRkzVZpX<7_4J+BZH=?hw5f8p^
z;cSmSvz>K*E4t*3!?_9k;B1uqHU+APR!^+c)CMyipC2oCDv_t66QsG&{y5r8=}e|2
zY<`L<3@U=%Hfc1%n*pXmHYpH}_4=)GMX;sbH;L7*5LMs?T{cRaR~^fj3m9*_wXanI
zk##CiXEwDU@&>5(iM_E}B#Tyz=*vDJs}TUSWUTTa(X<Lcs_)*%ku@sBhf)1%zqf*y
zRn;KUlcDmBQ-*8)61%&7XTbxuGu{Cv=wt+M=3}J<48GUuW=#3F=pY~mTW_B++xf5>
z{T9wIbTsbO_+k=z&m6sKXaPbsstniqqfvE5F``KLFiMrt%GDuCj|Fv}*y5v{5e|t<
zDH;b~_?6D%JDkJz4vXG5q2@=b3_mE<zcGEy56Nookm06W1ZO#E#%+Fl);?p(aEFXW
z!q8r@<qjF6g_baTW{w%{qCWo^P#u9%(5w2OLnjm*P7t5toWLY|8nRucK-MYX#$nFR
zL|y?|;rh(dGE=?SMA2Q#HaKR)DlW8QWBl^%**nJ!>+F$9r1GrWrSeIj9qq`%_3%kC
zoM?3-8JNaGfYx>-J%amJ;Y+9Cc!$=Bvj@|}R7`WZydanFXDHv=P=0Q*mVM-u;hOjI
zHW|WFn78ND!%Mu-!+k4yP#+J)PrPy`W^f<rR@3(^>h!Qst#yxmp#clceB_}5KQzU+
z2WjdlKBIMZq)9sHRfXfI>(1oAdH6Myw$v?Zf(!wA)v$3|E92J`-6~&Z>zrZldaAoT
zdDIz@=~a=ucuV|ZPW$r%QoR3qgSh-rB`(vkVxz*%D3!!t%EbH|W+VxZW^38#h8clz
zSGs}lQ;eds9rm(fHBMDW3`9QG5fn)D0mE{?EdScbteJh0YX|PwnxSRCH_ULwPP=ce
zgtE5{Gx`Vz+G?5FF2g5pYFo~zZtXdv4#mriaxxJ5k3>LD$02TmV$iG7rVt%EA<P=n
z6!RWX2A?d$kU_q$=oG}42p^Psl&l{Vz)@Y}o18yJKHPQ(>8uTubkc=4*0YAr8Fq~|
zU1g%(yFo-d1D%Bh0r;)%(O7&VNS<vkz%L=C_&G8vcVYqB8`E5`{5OhR99|#3pby1J
zDQ=@zRko!XU*qi36o~S~MCH!WaDN)KgYXNIi;#d3`W8WIB&5Y@**QUKY_=~N{@`0d
z3h<QhRP8Spjt3&+Eh`#>F<8So6tkCRl8-QS)iai3CIt&KViBh@ll+Cc_)=;nWj0%y
zNThP<L;@94$X~u24+EBD12c0}_v7_#HLfx3VlKJ0-33MwRuhr*53I)ZuEy$A{J&xK
zBp%3^OD>A9Z?og(QiS*6s9G4b>q06xCBGE$EBJ=f`fHiDh19O;8iX<+F)pR~OTjLo
z*wji<(Tbyaagf%eSg2^qhfrhSeAw2(`v0{SlBdJXSi)`!6g{xJz+aTPT6Wn&a?g8(
zF$I__*T-%Bi))<!WGRnFkm013c*-A0!SoSI@WptwuBrG1nc#oZ(&EC{w8Ej5L($e*
zxUNK`MJQN{NI_tIQ7;fFig<rSuPTovD(MnRlWOw5ejLX(5<R63JbQ26V`zS&X(Twm
zrH&NfF?ArYIx5gia>Xa97_nmPg#j3D)zdXy`;5J)BLyis++;qM5S)leXl+X=C@(XC
z2=Yq@PLQtrr7uF3<bBHwA957{)9Tw=IMTQ^mG1uqj!n{VUm)Q)u(yn3BPvo;ya`A5
zo(4exij!iDDB_a$YWZG)&){g+)SqB2=${BI&FB_OSMZgtP)oh>UXO29KFHSo<v~TR
zMa3uU72}ift$h}V@nx$TqJ#ZAT~Z4s^sWf!g75+zJY|=$=9K&cLP~+aa_fQ`6P7<?
z%j!xkh2mCPcB-!A9dbL4$kHj5ljRbBxq%*yQ=hVUH>ms_-Joiso?;#=;vM=tBzFr;
z-hxyk0lcYyHwOVWbT<&-uwG>zO#~>D$2iplXoAncEFI`LzWf<n2HF%D`|~=BUx};W
zvs*)99xOJUaV*ys(vHy0bqto^<wDvm5=5n<*i>F?Cr6p(Kv_z`>$JiIqRv=SkNnc+
z1h^YUmHmI8p7)<t@E?}X`;RgB&j85#&q??n0g(5<z{CFpfV}?=A^Hyh$opTB;{SI5
z^8R<a(f>05dH+lO`2P)ngkJ0`zl`>FKG35zZ-m>c!E}LNMpBn!t+`Ki0ou}VP5U-@
zllv{9$oGZd2M&5W?vL@yD;kW)9$wh<2I0`L7~(xVPZsquOt(=nv9f1bfr_r*GVAAA
z5yG1gEo=WgtC9Wr5cq{r@CRh`w%$~Ca~+%VJWG?8ffQ^!fPc5choT+3$x7kIDSS>V
zfCn@gws4$H#VUFIe3e?94maSxQ;Yw%>3Ib||GQrOzpdauET4xc^8cRzguos6{{#R#
z-B9w%{xck6!y^D#%hVc<26#yE0Nn1QMbrhebWQt`<(%O&nqCXa=y9T)Vq#6<>=`~H
ze+>_J!&(jaJn)Ma^TK-7%Vt{E)lRav@#Mm>mw(pP>!@Jk?Ice@7o=s(PCC?R;GReN
zgo4t73+qjD2cgaB=_C}mU`Rf!tYyy%HpO0Yah`3)KXXuu!smO$qe1K0?+{b_-d=Jv
z>x3~fd(tD-K{(t=%Wm0A&Ds>1yM9J74g>r};dXMNu`UEG?y*cOk}>7?+hf5ZoQQbw
zj%h-{BX&^P$3aL$O@mZ$)*Iqsz$nR0`7B-TGwn{1Z-$MYD#<(VK?|9VSv0$+HPSJQ
z8eR(WAb1}MUp%egYo9foT5#|<f-)to>&cWXmMOX1S*D~vQId*dms3;fUASUKw-tw~
zq!n$q;i1dz6ih;RkY#P?U@6!KVraXe!*nxWK*OFm&|u}{Bj({MIk)OS6iviASViui
zbR&-T!y=NR@E5L}hU43j_UPf0m9VQbWWYd-9}z&#+}I(a(P}x@az~kHSwu8~%aAV{
z`F3vXpjBoDP-n-%w>V>QSd5khZR!x%q{k2ig6*#pc47T9;wj`AW5uf%IJYLG9nL4c
zflya47EEpG(5BHRE*zXlhktJ<8u5ZZHg)ie`HEa-9JuuhMc1*T!!D%|NA=-lH^>5V
zP3P%|Vo{<E|CoZQBwY2Q?Vx3Gn>(~^-1vW}LO{lNw#rdePJSqKWaO_k2Vb1)*P8!N
zTo35+UvvGPc`dH*SN((Q&wPzs|FZ3W$#pY71J^qM8unyE2Nxmq*dx|pV+W_!>o7Do
zvVB;mYPR2T<a8bq_it?9(8a*^`Esr~cK^<euE@vP-U(nD+1?1y1UX5~d<Po1PD^)d
zas5a$1J|=5uAJ+`95^%q4gbBJW}OXOU)27;=lWQl{%>6G-QK`;yZ@nzXGt>GeXk_R
zTn{)}gX`rVVI5HQ$O8wO*3WiV%-_of)X#1z2yO4Ox%IO{gab|Qvi<e5oqdePRNn2H
zUkQEi7md|6`^ZC;#L{iJLau&xYqRyMu(qYORdy4hL65gA+ba7jmuznu5nH4d^s>ar
z$Huh$HIK7(@YXVS>ugv59V!GwFpT08qOWX7magmchslta!}M1TF_?`PViXSoARMi{
zB){<AVo46@4rkKl*pL8)>w=2}=-I#e0{W5Hi5pmkheZUvwXE#$OqDNGyLp+JoE6iu
z#=GiU+^EXh4Oz3iC7<v%|I*4VL(v+od|%zl8%&{9wUYkNR(h0GwXz>sc`NH<{)x+T
z;UBnc{<Es+P!#>qTMFpdp{ghh9%f5rLJUrmEA%%I2a$1e(NH0x(MF85)fGNPP_zo{
z_J*uAi1Vg8>n>#FV1F6?Pp}^-{sH#5YgJ$mK+yw@K-ZLiDLS~L5$Gxa?^hSKs0m;n
zLn}1^yj`93M9&(yc>ObLr)pdl8L~DfnYfGl_+*i)0^o3Ut-X7qE9D<f!9HRWHu{UX
z&Q7?8g=U;qKsBTmsl5yX?Q5yb)JJk~`pJ(5;^RlB7BN~XVo3cyl?D4qs-y*SYCELL
z3%>XueR?WYIX(zqy=XR$58ZKu`w(8013t%Beb$Zd$O?QUAG`f$>(vMoa>tY%@R7V*
z_O16Gwt8}JOr>G1>$uTr0q;`|J`@nipm@$IT)=_U(U{^C3BID3io#%K?<;u;6HVT;
zR=!fW5RZpZzLKwSnS2~y$-nDV95$X(n9rvi3-U(;8uV9wnM`3YskO-=XsLAyZwXPZ
zr@Ay=pdEa%cCGnJf?8|tp)PEiNb!OXf+pRYAcpuR0@}2Rl#w<h0eYioS{KAFuzWlR
zvER0c{o;$3e`ybHlw+a{U-<4@{_#hIG0OYOA8A)A|44Ikjr}B_fRhLvmSdR(6_Mdb
z&8?|stV^k>4@*Y-Nw-X`t2HEXJS#vF9rr?=CUAFQAF3y7fwOSZvBV|-5uibiTISYN
zYOc6>fu%K-0`pWrf$TM8E7^-jx_<tVis6X7R%B}4rbM1o&ZN17id_`?$It?_g=c}o
zS^#Tx`v|WnZOkLSh{q0|I@p$ARK%lGF?}uT;v6Sg7n|;;aN|*NqKzqg*;H~=UT-pl
z&%)cFhC@w;Ft<P{+3Z--BRwm2OmSvnprp*3sUjU+C$&Hg9i0pvJpeF~BjttRl>y`o
z%zIR<H7o)N(Y+mKijcit)hLAw3|9ZV(%qv^*gvb3KcT4ZIV6kpxz&%gLtQoEfccfZ
zS%YShwb?xnsCLh05`y$W#lN_*xMtGq)bR<jPJng~&$5VzDz_eWfz(M4PzxH*$>6*B
zBDAT*Cj1noZ9B_dMC5WBxRI~fTCbXg@UTsg6cnhBudeRCIj`=}`G2YIdxW&LK~ikf
zixERiLSc%wGzOYQs$?I`5zwNVp<y-o!<TfP4w4$D_IHCTVqDfrW02OQP%z3g4>mLn
zVITvAuNY&R|2R&by7a=B6S=~*fTsKxK+f`-OO8#;<79Yi7aI3Lp{^*zrZ$(H^Va=q
z{*Vvyry5b#tESq5tDS2BI`CiXs2p1x(3aJ8M52z=eRT<FRj}lwzTSx3G1cs*7{iai
zSA;6t)TS04rhrTCvHTIv>^{hvCzj`T)|z0@5hA|@LjL#1qwqdUUc(_wcg+ZvqU`<z
zqxU;iCrm)XnP90^t3+@}juTL-UKNISI)SegQ(X0{?zoIV;DKbdbO$*Y#h46<3z32v
zV-@EJ89z`u=J^>C3030&c%7I-Mt9tWQ1|>0$xn!A1iKp|?QK$I9zIeof#FTe!ppqG
z?@@9IFWe)CFsrgYyLNoIV{C`*=#z!hEDc`$tx!@6{6L=@P?*NgC-51vrE^2>>aLHl
z@Z(Uab^BbzwfBn<?0q6f&x#y7oOIKVdro(EQxfJ@a4m?EI;0zRz9mo*3Yr*bcqI{Q
zN?S<nI<N2o(`{-7RSNK>npkc;s4~?BxzL@hNfFE2;lDa2aO&0DM$~%_9+BiPX(<(W
z2*9_T*1hHec?-m#4GI$Z)_}_2wuFM*Zmne}T1vhaMZQ1U-PN;KEu|zui$POdnB)-1
ze5tF^8mA*c1dTz}*yy(4sy<R8pB8f;7Nb%ohDj}i-#1mTAHt+4Av{c5@-$4cHx)cu
zYFXU~DYM4r;n5Ko^*-28!F1NseOPIPBnp3qV&bBeG*j5OzJi@;C4DNKL|~{-Yl#Uh
z@$kGg?2x4^R?0+59(JoihH7@m*0oC{M)A9mfIz!NX*)}k3VR3@U!&R2Ma%LdrB;p4
zf}QC&sXrH-xQO^v!cU}?3{=598VxM3MM`c$ejP3QJ5p+lJ?LIhQkt-<Ip)5jK(4>O
zsbGtvq!^()zJ&G~?o#qFN^&rDSlUu+vZqF62!I8((K454sfkatISJ8V@&t#|s?ouu
zWrkBE<PjHT-Q+Q5Y;d&n367F@#BM}O?!r9OZW<$HDMp*IK{3)8p^F1He8osHwzGi(
z2N=|crbi#}jfHp6O2BHdSjnxKKj%}0MTJ>~q5>@9>jOh{p{|(V1-~Y(BPkgK+{u2H
z^_Bb;UskZ)u~KB6P>KV1KW20LNKUL_ob*O;4$!g&@sc;F5E3sfu)u|177&rrcqzFt
zYeXWAJAe=S)8hC3wEVq)EjI!S>Jy}p=D9GdU`Ze!#l6Q>!16n0em46QgZlUmmjH%W
zuPRV#*}McP-D-@fY&h$##USQhg4D$Bx{@p=mL;LYGvz4r{mLOFUTviWQ`<JpYRdHm
z2;10pPztx+Y1qnkQjqsr*vd2v;dh}V#5fTB&kK)+{?{M*@3)h>3;UxmI!grWLomu5
zfCq~r_h13oN{Lc8;f#m2<YJ;U%TzcDWs}ujiWV&0wQO~Jsh_aHP0QZ5$K>mDH*JY;
zvh=N~(Ax{sO(}q439DdlQly=@q#Jv6Q>8M$hR*1d5*9qs6294<h;-!oq1$5ARxO6}
z5Zn5(13bJhUTWBl4pOjFzin6rjip-tq)`wBr4Wry<NSpAcZ5ecs|8@{D2)>WfX&5@
zQfDC#ZjXPO)WM>KBNWDEmfbhTRj|d!C23Me??Vpwc!iFuaKyo3=DSIq^B4yA8NY$3
zDbl4L7DYil-rmu(e(9+BCt!OvT?)2d3%7(!gpDpV>N#uBNop*NQ(*&fC+Rnfuk2Cp
zJa#!<3a}oBXE~o~<Z~9=S#oUhN<cCl&3aqGjnV3QFh<QdTkIoAyWk$3CmJ@nvy>31
zvy&BX>(9CCM4ni0B7lhOy6s-i^yOQ5K}#PkyVqIr5B?klj1<zD<YTII3|y|X0^CbO
zV06*-qe4q~p{<Rvp0JD5)mp_1QR=zkdTeDE;CH2=40ni*;nU?VlAD#~V(K$bA@ETA
z3u3|6A@eI(y?#=Z1*luqWd`<>-YP)5Y2A2_S<?*}j}%p~<K3iI^%{fZNuhtFd7ozD
zpVJ+fcX#RL2hJ?7x#wI%Z`?}stJNEq*`aszl%gz+Lw|O<r<5#=pHsnHdP(04eH%iP
z_mcJsW(8b>y0CB5&?)A&+LA`SrC3v;S)WI2P=>T9P~8CD?LP9?dh1o&$fRuLio&pd
z-g1(x+so#l_j&aJ8cCm4unv8s*1}f}v?Vk9NKH(INw6DR`bvRSTYfqCGiMmUzhU(u
z_{Zua^wXb{M(mF|?@TvjO{iZZt0EJ6C!ijBR3^HhJkiO#21pLV$fjBrIY9CjI^d!I
z0O&lWRKdgn(mLV2rIrO`N%=xqo&ob?S<+ac97;SkTVh$A>u61|DQ@wh3PtE2TxV(j
zE1d-o$Vso-=L(R>N2DEm%AMw&R%=b7730HF3d39Cu}~F`U+yR&9(Ys3!UsxTmijNW
zCc3XyY-jxkO09&~Q!Cg!-{Fnej{^aGPYZ*!sKlG8=Nte;HfRx0|Ih|C0h_%CLlMPY
z)3Er#l5-V>vj$6{!k$qTC5s13ai+o<Xt;|*qyVAllM1F73bTDpp)Kh!RI)J@o(`{I
z{WVg#Fb#b(RVyVo`CEZ0<_lN}mK%rz*DPucnRwsVs}?pu&`m2f5!PJRu<Kf>SN&=m
zi+EIylwq~~iiS^wcbp8-_$Egh*6`%L!59F|@VShhrL?jB?cQMKJxrS1BkKt*_M76<
zTldoWB}VWFCBYGzZpn>-3rrCfvd>0TwVDxn-`mt3Km3eg3{0n9<#$oT9uJdxxMjW8
za8p)1iMr)-)L0EB%lZfkslY*7^65vCm8sdrMc6C9WVqBUsmR<ZoP0yfDF9M<`3LV}
zQ6gUDA&L3MmU1eE1>o~nEFtF+mz{8h+XENssN&CQSe+44grI>|jvpZ<HnM!LF)1I2
z9B{}$-UNQrw?U0#5c*|ZoE9+xp3b)@d3l7?N$7=#fRR#!XVMD|KQ7221(xYGn&fUM
zSHDe>#GZ_s?<UlH0XBRd>n+@Uu3-m9O3wCC4?t85UNI<riE%ul+Yr8oBOxpUhiqro
zqoiQ71LMJ&cuXb;DJVs=3cdl)K``L*813lHQsmA(9Qms02F12!l+-llt+g!pT_E_q
zA^39^lHe<6I>1C!U$%*Ekd1^w)gb(G?FzU3yr!hiXvxzw@ck<ddRy+Sw4$k(4Zy<e
z>uzc&@&bf8`1mppuy-9JMcLYdj0UQKp_|OH9DfX4t$n9}^%$wS-3#=R^4W+`h9WkC
zf<<pMOfgpSw`z1omd4#<fpf%I$xk`|I;1fGa}gL=kGnp&WcXNVoT&h6vzz0jv$ndo
zhL*VVG+m)(M{*%Ai%)1+MXnU6a42L><E6CL2cB^h23G^S<xdWN!|E?R_!k`b1cYcS
zknWJCf~_1cEw<<f4q})wU{|~|>pTH$f8_Ist(hS86>dPgzn_4fx?y$&YyYv7+>kxd
zAj%Uy8|U>S*pqz)r$Md$Sjw{NSpa47dM1{@UcsJVjMk26Si_0%*1mekq9;lo0n;D8
zmoJegHQog)YC+%f4g6vdyu<V5ah7P%IDew#W7cyxNVI99<ZRZOo_?7q`I%YM)3b?^
zufyE?Bq4Mw``ZjzJkEZEwC0l}ACHZAs&XTLG9-VFkFwi6dXnTEZ1+-QvfmHl#n}iR
zzC(Sq4Y?Z@ErAv9uC#@ch^KJJO+2z)lW^<+1DRx33_S>4DA-u&t{E?syoEw5yihYd
zmV|vGJyi(rp&kRKO0mKN^sZr3rL}%I{=9iG@5<y(qVN7qJG+4mhK-AT*7LgUe%7$C
zY0~Ltvn$akwP)B~H4*Oy+ebNd+Bg~i(?fv&W2<lMSz?}KADs9Y#eAul4C__MI7jd=
zIB>wK=lLoGqwvUP<-z{cUon{dohP*o>{J2Xq#|ef%m*|(mXh08uS$KSG5HDIO7=u~
z)auWdnvxt5CQ|rh*<e;AVIVNwRLj1Tq{86A4{B5EZ|c-U;y^$I2*TD?QOg;ROfy}Y
zA^cbd^)OwES4{huh2%@VQRDJsKpIuq4pPoIb|1|nu60*qQsE_2g>b~(=(^feg0IQu
z=VMwm_OXU-&6iT^Z@i8&u$1>7X_)y8sk!yBEYil?ffNla;%A@(zx_qShRlG%{PLNG
zeK7-LJLyjiYcdl_Uq95ajx(h=2N(1r8ek6_K*f7Jq~d^n%}gm7I{KNbtdz-j$Lrp#
zc+Teo^6N}P>M#5?eBU%#Wv753#Cehiy~=5~h6R5rEweojoc2MoXuzRYjRYcBK80>x
zc~!&e&yuza(;!a=XGzP<ZsJ5KmN{Dri7zrwbC%-?7_gbYK28Qhj^*EWl)od+5Po2?
z-0no)E^YZQq>=ul5)J!pwv-~w`(4A<9G>egjKst0j1KNXCp=^nz?Er=hp7dUD{9BS
zXO5cz)%yKwp?aRTH^aw(>a|a5S|=l_nw=U}Rv>jX8wV@RdVMN2V(K|kf?#z;!&c0J
zFjc~?-{=vc>Tv!tQT;U?kOQErO)&N^Z@mrHdxA^`Nl&E?LUMLn?v=tZF6l~$T=_4M
z^tic_GizBW4Tpto<4{elI(-QNnOf&m)zr$JD1*MBCbiP!0PCO~8g{!-@{VG+&^O!x
zgdEr1Pmcz8e9)Hw579VxAb{9^l*40<$8YgS@bqu=7*bWPMu)?J;n0gUqQe+-W1M+k
z!}iSuWu~G*MUfQSIeG`|vFRNeW^_p{%(O|-pG=9Y7;leDhWWS^lg<HD=K`7&*W<vu
ztEmTXn`2`m)n2m~W8A;19G#^|N^(!x22gRL0%HAxeYB~OC$LkSJR-d+76$1_ku=`j
zVLKRMdWQl7T58-sDfBj1UAo~T>#_WK@RK*5)Ufa7NlwD`^9DKEj|VPCtMS0)Xfhs}
z&4<@nH)%T?I$sJAE+%eg%jTo_W;`64FEwtt?ho`>8@ZPgf3Z~^UkvwQ(0K07@Ol`c
z+@`I)zk~i5J+Xsk*^Vq^fmBEM;g*I)Es#1n50;ZCURU6Qi0(^XRVO5Wxd8E>GiTwH
zE|B^+9CMbCck?N~$1`k%A?h-Cl0O@<Q1W(nFeFk$q7hUMX@EZ6NdqJz-zH=cE}zk`
zQwuQ$F2=*Fg;Ijk;ck>+%MIB4ss)-{S#((>IoL&9GwMguso4B}Tf-(Tl5#AD9pKiu
z%cR9_R<FBK6*tRJ1vcV;CI$Emx(cm8C4dm_tpsuquJI}!hvV*8i_4mC`+p{x3a6m5
zvKC8SglKI&wtcabra0MznSKsqzD`q*rG74@3%#J;mVGXHH))}%2jRb`>jOd)jx9P<
zyKa!6YR~~e+2@i&))q(r#Gj5Xon#C8^E2EKaGQ34;7%j&f`$rt=+m_vOn_?#S^(VK
z6Y#Ao%sFe*3R<S{^-%A*e;BYy!+I@|Qf>QpA_$T}B;ziT;w6&3Tkj31!7x`e1F~Ed
z(aAgn@RnfZtn-n<%z;U5{Mwu+oq?Tnxqc}H&oKW59a0M*bgWa?HEbf2CJ6I3K){(4
zD0GS5&ODbwAWwd)VcnKW&GMT3%A3?pNHazb^}b*IR+BQ=(vwoCRPL+`OSNDg)QG&R
zN3|FFx5loXci#~*iA3S*{3eu1&hP#~{*yev9TlK0Hm_jyjI^*>Ci%CVv1>3~F^n~E
zM@IHmR8thxm49-N=Wp(f@dkZw#^0=?9>Pw2v`q5NyI0)SqzhE|;gZ27@Wgt;QX?!j
zv4&c$<~j*%O?Y3Y;k_vQ`EIl~^H_>9>1j$)SIoR)*V47k|AL>_o+|u;=n?b?HEwhI
zuBrgxxBsUq{Pezkey>Sjwr1)udpF3s-naWD`u&a^=^C91bE(S_<Gh|!!HSnl!F7_r
zpEU1ZSm={Q4(#vc(p#Z9w9=aulB-~Y2gj9?uNh&sIL65`?Wl&1b;jh}O3B_TM1B*|
z!*FBCt^|84`NItQ06V`@^0d8E$|a&NwibJphd`+qj^C9(<JdBPz9XhS(*67Debe`7
zaIz`2P+TlERg`L2^eQYz>V$`kRZ?7v6_v|BY>A1@8u7@X3+PO6S|PFc8z76t+|81=
z;WBC)lUzk#8l1vkh9jtJA4I40UG7WrzY2rv6-PA8>I*4b;cCW4eIa?d7WukvxTCM|
zs9FRe_aEH_7c;i;3n|HT0a0P)VFML7jE4c^YRN<BfQSC8CGUn!kX!|$>_`(SgcpZ2
zY};xnOxTBq^3{^NMN!b#-y#TSwMObHB;#Y&8Yp#lJQTYpxeM>$*KS;c*yBY!oLM6^
zb}RlFHA{z1gSr5$Z~5%za1RZ8-<a3yHY!2?tA-_f-NRM5fd{%f$8|rtBq{Xy?MO*X
zf^x1xj)`ANCBle<(EeXZk?x@fjd1@<$d`E?4)*}Se}4^t55H=YX7e?4Z&f$I94QmU
z)K18eMmf%lsV6<h?dKIbRpqJ~L#{4hwboD|yXC(Bwt(?O@UQK#ufDLI6PFyi0tLS6
z#7!EL{K;O5Tz9;C>2B<PNLf;<vZUx$4_0Zg6KAZ4umf!0zAx3g{`yrgn+TblhMZsD
zm+CB3Zq%?g>m)DV)FU$0mc<g)@=u~8sixw$c1NOHdg|^aGSK-j>;_w_YIqUvWb&Gz
zq#?vrc6*F_!+kiYUMe+#XT+`1f=d8qZ@7a{vKM?8<6JzJ^MbE*+hVB6l_zR8hFjO$
zr8_B*b!2jqvtWydgBH_N!kaxBHq8THuHoVMw}_kV#>0ber3B3BUd2}4mg}X(&ewMT
zld-Z~9vB%NWb-|gKb?vL(DbU^_cSc#O7}+A(lfrd+EUj8Pi*0*(T?e+aA+XdUNX9d
zEmfAfM#w-1atu38js>o^5jfT5+kQ^MPa^T_--g>LWHIXHkOsN#4S%Xll>_i~I8~I_
zG)vlyb#;dYr_wj0sPu_rwQ0h<j&=7GuKl24yOwuvE~J5^Rfm8FG==h`qTP7W=nsk-
zMJe~%GxqC7gb8-;f>GNj`8mzqC6~Jz`9TaNWRvu(umO($`%Rcq=#GaTo23>O9wl%c
zO<A^->c-Y@mKv+B?BrCcHFJVF7ApM)pz_jd@xV)u{NaPr0r&tKe^^==9qs@(w(87r
zl6tJLO4|pgpDzAsiU)r2j~TiUUHo$x+K6BLlTF187ytZ(v!;k9--Hu6=R;4`lxG-E
z_IOq5&YIhTZPui=wu}bf<wZEfQi}$C!l-cKA>w2_R+Eq-{dJp$T`h*9-hziW#gePl
z>@^$@uBchrx>QWL1dUvRj;{DNwO4hNJ3d@&so1Jv<HN-y`dhg>Jj|vAHNc>ajH1HZ
za78jV2JeeCY{NE~C#M4%c66H*fvUe-jH-q0(#5KPsu-K(r1)M|rT#_V6Ycm?nRqOf
z$+hAkIoO+AB=oJeBurVHN@}^&XQ*!A4ym*90|JryKLM|flS6ESCbno;pV%Z9s|EOq
zn&f^J|15fl;E5!DfkT^q>G3K!D5Mr#f(bd|5~m)|*!ep{#`^mP$E#rIDPxD`lrfAO
zdXPEmeYBHeGsb{tq8)5@AWsdbF+CeTf|T>z1ps@n@93V6ft15Ibw^McY;uS<K!)E)
zBgN1=(3w~~giFF+=GuciU2xltVz(Kr3n=po5^J_$bOBc4JICH;7b4b!P*<FFjE_?^
z)%7oinTfmLY}|uhJ+Mo1wkYyFGY>HCx53`N=ewjx;bWwP{2#`y11hTH>$5wcs30IL
z(gajcL_sXr3#cefMG-3+EW5-GmPBKLefunkDAuvXph?su7ObmiEU|Y@V#UN7UBrSK
zE9!o~nfI36Rq{XI@f^83<<4*J+?ly^XWq;nZBN7mv6$I=wC6}SSeX3^F!R*~ky)Vi
zMyyi~V%HSF+%4FEqGmjvP$?#7T3<u2JUd!ipzVn2kD7}lo%U)^5(<OVd7rjU<zqo*
zqc9h>ah)vc0eKMhI!V;;>M~K^L%-#1l0OnMLOMPP4+If0EK21Rg~ZX>d-K@bo4q}s
zYL9EH6F<b>Y9FN{6+tA#V$y!_V=7IHjq)ZZL9j_X;(M4R$jB${?CrN$eoGA$5p5}F
zHZtkjD<{;6&MGy0vGxfzDZ_esD`&vV64uMV+6-xQ`nnE-JQ#xo9$e~z;@<us&kcWp
z_-<BvmH*KnSh?d<<a5qAk#^`lkxxYYgg9E#y1RQ7Q^+i2^FM%2H5^2{129**fJk9P
zAczICrg)QzAo5tqKi^|TI2ffK2XTvq{0QP@mni?L!uPB?W%`y9ALUPaA(9EFYEwi;
zOQ+uqx$o)b_^1G)MC74vQEsGott|4>ARM|z`P*(-n`*Ok^5|eRZRSigZP?_|u|B~F
z#A^`#@!3Ozy3V*ap=H;cF*wK*;>A)Rbz=3sYfuVT#WFjFw=0)Z)|ym$p}3!lq=Q%y
z6XoUH3&|}TfO5<Mh~}^yK`>3I_n3`n<&7bKBEp(M3`Fx&p41>2IXvI^2va-YX7I9h
zNSETuZKEU}w>^_73_2*B>w9N2+MK(Ilp@a}#RlsXE_ta68=78_>p{01)>a@-zk}au
zNK|!t{;<}boW(ER!oPrce;Cb}1p+Nxoo3XGvL~td6>$W?Q6P9T*9MW&Kgy3NK)me~
z<!66$HIvHrTQoCqty?9S5U?SBU7boFvV1E+oDD+q$slgBe0@M99M$@D377I^GM|g7
zc8oUH&Q(g0XOUuqb&6*&=yrjb?RnU7RN>g#ojyH^dTm1ZJA{*L5I)C13<uGU5nVu}
zfM^tmEWpjbK|%TW5Mb|Y_>@fZLIp%ywkfRDu&%&=X_c&`J3)NY3LSn4i1*DvOaxId
z3Pci!O`*{H#vne7imFW<K&(6tE93r3XcZ$4f_T7)6(Af>fS3ScZUPc_1JRF#1c4ab
z3?WJo`$5>=Sb=)x$K!>9TPL(t$*vW!Sy;+k5Sh)9as-IBClS&KL}&|y_=3n{A#awW
z&o)5F?;!G6)J70nqN7yQ`4pJV#IKsCkT3;A7e=%KF&c!E+j1tWy|bD0v$rp!w@+f|
zd$KH*?m4CPsd9dq)Z>}?aG`KSb$34ASwB!1jKT0j;Rx@*fK}E8-!PaKc#BCg7%}a^
z0Nsn(DP^=Txro_)(2Ws+4s0A_HoeQ=*g#pcp^Iy~o>(Qq6v9^;2Pe4lyzC7YobkH}
z=kGyjgskJqMo4GO6-HHM{BNGfX~}7L)27i>8hi#8bAJ$B8POa>8VF}M%5{UC!-(fE
z?kH#*SMqErv<=Zd=a#18N+#UR0?y;6GjMwoxb0kHaVmX&MjHX!`)c=wwE0=>9CCL_
zDm`)*uCBcx{LgEv*HAFGOt$VSvdGYL_Oc&FRr5JWa*mC`NZall%&9*Ypu4cwQ@&!q
zV29E4LAh>p{W)!L)lyj2MQeD6bB1_tp2NP$EFeH39zN^;s|=DQl~FT%F_OT2wez}U
z6HZexd8I<wCaWuK^miW0MY6vC1%l0k4o4R;*02>Ywa}*xqpDY3ix3Ox=GV^iR7hi=
z-(a42e1d80>ub@!qrh=<W2{~3f#B7y0%Fw#t&jbqg}nFW(v<Oluuz7u2?U3*1kq&>
z6cLy^CL)SYzeynY^xK>f7qvca9uhAL2MDaGh&$~)l#nf7O<e@B#i&t{Js?((j`Ff!
zwLmVPn*s=xOaTzAd=dqM&-x)Cc(INkR{XB@sr)2Y>I^93;P2RNZ-?$z=~bkkhYz|g
zGrb?VFfm`o$Ss?SvgtNz0;aDcw@38wc492drke$D^!-1yT5@^>_PhSn{zle~!yx=8
zb|LO=OQoGI;Y7get*QF3%i4hoLi1DgxmUEF3T4L`^p~sJW2F9=R660BwjVh^8dKmk
z?MC7cVu4ZX`su?SdDl@&;m}kXP^eu``i)D~pDWZ(Q<6pq>h`zxHhBqFjc?-U+&U22
zo7!Q74o;<po7y(Y7Fo2;Ev-g*VK$w2OM9LiAB6$;wziQ|@fVW54JFd&Z+W-1v&f}n
zbizB@L*(RaY-Zijeo4;3#^`rfyMi<V@#?Pj4vGIhRbO~d+g3pw)~4#c?`tP1$O25R
zOCKO|<9Dh0DF&^tLV5Qqy0S>Sn+(>%EBa8|o7jWc@=&|gzgH$o#?5*d-pk}_>4~73
z#o7$=p(nNr9%=WI2mN5HKGOa~_M+`ZJ=VS=zhNL$Khfrp#vook(f+G+9Yu?uYLAoW
zNvU*a3A{I}K~#FCo$cqE#0z_a(ZRB?GJ`1pnRY(;H9nPgc&^<{8hn+ifAL(qT}dv-
zVNvr^`-})^)NfyD+mi?oH(%krSGU+yeWTaf<qFa>4fE+6Z7%sP3Q~QmeLyy0q=<co
zgKE=rQuRN*(|Re$;JK;vSgH0~awt1huX(Rss!(3g(2pOm{;Ur*J@b*NKyE4xGHNwM
z1A?i5gSi7^s!OZ#y^0<+YFjG1O<yehuDsrQ=byrU1$p<^L%KvM{6LD;Sc?&1FIjTq
zA#N}cek3!7rP8&wLNTFGl3Y7s4H<C#A#GYgSVv-qz!g<NSU`NQJ*4Rsk=+T};$biB
zBMB*~^oqUEnN-Zc?8F{`X<A7bN^-tHcd8^rkth&%Dhb`lzk^a~lgdInvK_>P$^!0z
zXqKvPUPVBK|A<W0_i_*xD9HNXAF@-YJISp6nB%IVfUt`X=@(AIF5=WLRqx>})KZX#
zeK1G52n8er#5)(EBYDsp9lM$^j2O;7q!(R<4z#G6(2G1kn?|?_^T_@)Ja`c~*ejK$
zx(N@+<wP8BPzjkN5yYP=A)I)FaBvsCB5TuO_cx1mqs!fen&h|ORQ<2+Lb9T+e;ej?
zRyFN3%yi$SXHTd~j$<o?@W<F|wq(|PgohBRY(0qTJcRkA+SpX8@)UxVzt*9Vo<e_;
zg$}pcQ<y}mg7EYbPLd9zQ}zFN2~`xNDZ1JVZ(%l31g7ez`v^4@tnbp*HG~`F=i%6l
z^c9v9O|4YDr=O6hXnM8@2Xwo28K7e^9MA)Vu;Z)jf%wy5mSZ~(lK2a4mE8q;(_hF{
z*6`7%*A&teWTkJa{$4F%vVt7wl&Vh&5U|T#>Yb_=1BD+I&7DJdK>^`q1y$<E3kpVv
z<Y49d8C8O<%Sx#$M0yvG#ZidqI7`%ty^+)97Tb2jo}1mslvMq`x<ZJ8w1$p63KBXi
zgH^O?Jt3JahKekzC#)o|2By+R!O*}T-BaoHV4=k2x)&RTpTy`s)C7-sj6Q|+1sypy
z0G3t*Xo=b_m3oB;4anb6pqLOeU;&8HA;Qh3j{|uv6rp9cxZj%Bq9Q^};wr9XRfVNf
zqM9i?kD<Fmg(c)lUrZJag?N%?|ABtj5KXra3RpNb>I>2z1b>qyVOrD`G8*a_JUwb6
z-kq0&cTSJmMndpwL`Kvd5)CcnsfT1n?IhC@Q}tfjs4N9})<X{8BSdW{LHIRR7u7;p
zIaS}Xx$vcexHd`E|Ik7hs~|4j<dn;2M*T)wc7>reE2@pMLaM$&Yhk`3e0p_W*M)v%
zb^SVo*L4{};@M>+P>rc>mUYFbQPKvQTfY%)(iVL^B^JJ!woud@@_}|}haR#i1{QNW
zVI%n%je}C{g%9LomsEYd2q92GE_X(MiiDnaH)`}@9fTMKscoA|r*;%Blixe0(xgtp
zUDD~jM&CM07_Dfrz>(woQB{U-PHm3w7lfGFVt!>ye6qi@@#>()EKN=_zbADu7~yEn
z2n69%>#6)#NUzE)L3kfth+{JT&{kc9nkvsmC_{H7rEFZ6d}3XM=j6BcssFFnPV!#<
zQr**)VJ!Etlagp5JTluJ(Kr}~oeEqS_?w}5(tGxSQH=HoGdcNZOZ;RxzjU)hGj`U@
zIKct71wTLK*(8;|(f6t|Y(qVEsA)nQZWMcm!z<W`+t&&2G%UQ3|0t}6@C(w%2DrOe
z$|5;#4NWD3C1~YV7%bJ$H*tNaRS#uN&H(E^1>Ea@0R|Flz>Q6SgDe4~bQ9pWmVjNX
z083e9z)fVpD>z`(1%UCt)y$T;w^w-NqE7)Q{x85lVhy;F32<FYz$o1W_>CoCXDh%`
z78!738Srur7<B<){Qo)NtWN>={9k~9#2Rpz32+@tz$o1W__ZZqCo8~G78x))0JC9(
zmT|zS3jpJPYrwl8;fbFD?(x3>1Bo@@h9<y)mVi;Z3GgdRz*VgPOIc*Vn7ue)$^oM;
z0F3{w0q+3dX`cd4_+Nm5#2Rp@32=ZVV3ckG{L&JzqZME&iwwA-40tIAjJg0Y{<j9q
zba>&XfV=-Mz(8URIK%`P<ED9(K<OsH|5^feumUV)kpYLwfR}K<s0#q&e`~<o0XXAR
zz}@~AU?8yu+`t4FGprdfN;d(1VF|d36<{fg3>Xs`SBb?OFzN!p_}>~ZQ;DxX1>E(2
z0R|Fl!1YalYgz(E=_bI>EdgV$vKWV@EHdB*GT=oVFzN!pR%QmqVLq&l{S<Kg{{jpo
z)_{Xefc-52qjVGCXO@5~Spk-^$bjq1fERMWs0#q&e`^UBK*F;>1swOk00W6N;Cd#&
zewKhyx(RTJC186iz)}_&FlIHb5(_wB)CGX?zct_ky~34W+0(i)LVdRmD8w2|kO_;g
zB^EF?VR>qarJ@xUDT|B+6Bfsk%dr3^u;70yEG4~!aOF5)iDg(&h&7hFCM-29v4F7&
z%M(j16|AsGS!67ji#V3~91CCq3;wspk_0RZfF+J$K_S*y>X@+jSYiQV6PCx8SnRB@
zNLgeom}WSZc^nI10t^1P!jg$`M)@VM#4{`?#2QPW35&NS7BDtpd1Q&j)(VT1MaF^|
zgk#C!SO61P@c-vnh5<`gh6ROKV+k-}!Ggp*oPn_kOR*&uVueM@B4feiz_HBbSO61P
z@V_M%eXh{qilS@TCSbNxbk?b8-E$nlYMav_0=BN*inn;0f*(=BQ5l>rKV}R(2LzIf
zitm+Ye_@Y1fhRPN!D09T$MIg9BDR6^Fmx)@rk}LMGC;u1rWN5ReHRnq)ed@&Xv^~-
zCf{OavT&%vP^NoXG^OQ|>a=~tk^tXY2>4{@##|9BjoUA2U<(~NOfP(lIbEX?$e8Rd
zZ@3qAR*dfW8*bCCg}qobk!{FFcx*%~eujWKs-3?O9+3?sl^VYgqCE#fz@H?Oy>lrQ
zW9t)7q??x_sPWaH{{B5Y$(JImC6$y|S`QW$DEkoFXo%2?v{b;KI7F!JGg9^32+y>W
z*c)EmXm<5Id-yWznBk7o1G;Gl9106m&uP1%LIW_2xCe%5LxnNqm{CJ-4;9?&IR+0y
zE51fEqk%5eV?Q3^hf@{y&nyoN`~Jg(hAv4)jpeh7Y&MV%;=I2D*8Ct&?T?zz>R0Ah
zM20j)Y^Mr2A;)eb!$Y;O*3IJs&w$<gvMn^QWv7L@zSl^ng<Rf$mc)#WmaNydgB#pu
zXQ*@prAF!Jsih@Z-j~8pWWYNOjUO&F^R0!|$$x9W(yFn?N!zy?da7z{9pVP!Mb+3)
za`%mf1~|pW`!9y&{b@Uv)sr163mYk1^#2~_F0L8PjBj}#+uqpxal*Iav*n%9nXfgp
z<|rY8bObSMln_<D6vpN!Ou4S}6CIwf;96tnK@PvvNGCex!PK)l4-$g_<hMT2p-&ql
zxF{;shM84_OKOdD-@6zu`ombkkKBHtp~uDweOzb3q+xyg$^_Q84?#z<36&=F3iCjV
z^AppE#W#Me(_kYc3g3U>LQ(#m5<h1uof16_=iiPrp;?8s5G~reBu(g|QbQs5$yoN`
zI$t4{+NIL?ba=gPoY&Cr(}j^P^PmH~6n?Ba2=RX71gg4^cDK$t6)W}A<AmO1z&W(T
zcw}{CX`uYj{+mYCdUT(>@xqe&eIR&#kd=SF62pGkvqX5H$Ea$BpJoNpr%Zs~#_A->
zBq7x$5Q*fP<3#F#j~Y6Al2C`7JE5UlCkX=ra?w`i_+X~?IPvQ$pPqe!mt&r5u#GIZ
zlV->gGg+A7eh$qee>#BExO@Z|`awhQO@{O5>*E?~|BY~u<dtaX({F_4VPB!a<N_di
zXVwS)TlDpgX=v{$LNj86?DMAx?Oo2HNzK{6EY;APQv`o9?Wl$-rwWUzyvEdQ8Y1(i
z3K1^*U?rL}^hP&%HWe909??*@X+jH^1amwD@(?{@;55O95X4WNCJbr38S|^T_Idaf
zon0Y1yE{Ht$E~x6@Ta@I`S=UU#?Uxj=t}$!YiP=Jcwn#mrlA|AL&oiZ@#1vBOL<B|
zA5UjxAiyC*s8RhCQ`3*}()M)G5NNY}2qpuJo*vTB+zeqfaXO+|nkjg>pJb`;WB0yA
z5#C}#(oCoTdS<4O*!Ar}4NmIAkugQSxh6WNqel#%khq6%_+efY_I~V(cVJI23~~G*
z_rVh~hAAzIx0zU8$P}iLh6gn?K`V?R2M=iQAgZv41cOKtgt{ab&@u$UUx{W~BM7xf
z3<8eH0R}<vYiW0=th^#8fVC_#9jiEA?I|sasv*v-yG)1?I-x_icfbDc>Wn~j!Q%7k
z96D-M9qH_j{(?@Jp|qF)ust?YNFYZpYv}fwLI8P;3FP`rp%HH8?>?rI-g%bbuOOW+
zX=sz#h#ig2(tozl6tQPURicY#3;(oOTmXGAcC;_5fp6BMbGEbZQ@Eg~@Ce-o{4Sb~
zkMk@m$EMHxETPD&HKc>D{sP$imJ*$HUmigNAjR!-;PBgbRYQyC2;O8hh{(0yRwp8e
z9<Mvstd(*V1@i~?ZlMSq(Zv^x?2{hm*ut^4miv)z_dqY2nJt7?>(+0p6@Uort!2aa
zz8DSJajwvagk90lw=X(-`&GMQVw)+moyu-2!~uNl3u7GII#+1u?9<nh9iEpjnJdIA
z$cY^q+I}8fzbDUVXu3-$FFJdk(5Pa^-dm;H8s`alUaM}sXSYT9vl`=u2UCp)?$gk3
z<_qDrFaOZU7fBZWp`mByqwc?gcsL*3Wf0__oU_$~*31=ZRxRjd2|}NcE4V7V-bQv2
z_gl^6lEB9#>;nPZ$8?`xppdwSi+hym!#8|`0Oc`sD&&}wOmO&|Kv8P`LZJq!xJN@T
zEEL?7Z?4n(3x%$>3XG66FLtsgO;{uZR+-g<RgXyvhsYKQ{%&XXGZ9KP<E$`S(jAL1
z7``sn(5s7t;HvKuEU{DP#X@XN;o5s+v<_0SaawZ7{)F@~3_k4r4QnvC7aJAQv`u5&
z=={Y(1>%GmX4zt)fy1qHtgM@cFfgPS77ISLO3s%JcbM{qu>Jv2dtg-N-CXfAOr)e9
z-ngm+GC_(L(C(&7gpMsk7%P_4P`{CMquu!KTTP!fdKld0z(EMK)Mb2mn7>50uBf~1
z0xN1?z(EK?9&f>Z6+#(Te_r~>U!g%%2y)Fvzh=SsE`VQFGjyYdKB9uJa%~QESSI+m
zx8Vt-k8<TSE=bdE8PX)=&_T<DZng>WsPuv#`gv9_!~n`mF)XhrVXuie%+#xd*L63c
z)mbF_D%hyfV}9Tanb>|Fpp>Ev2b<BVs|8QbA7M(cn7?AJtBLVwwJ_f0;%^c!$P>JX
zUJ@p~xmu{A{7Hio#a-%FU4xO7ef1i~?!}6rY<In0h8z~n!uqn)YgOdFu4XZ&kM0K@
z#*u%)qg6W=$lGF+hlEFrv1p4va^P45TDAonSMt^f4+9>`&7Nj%h${%<BI3v+F(<Kx
zaQSLI3q~7oW%zQvhK^k(cqkpisp5N~e$z?E<Xnc!crTO*W`CD5ApV9!a^O!0EL$AW
z+@$sq#FkA7f$e=<{^29>YeP8FNVD3lAB1%^LlGR4-I*^voMueI@E@Z)hUEurg2QOA
zA`Kl}JvON3KSuz-`XriVjWLjw{3rxf$O&1y0hYJ#I$^oz2TXCFW|0cMuuf=*q<h!j
zGwSWu3keF++=I}*8-z5UPM4oaD~_%(y6_$W6BWj%V}`vK?$di41WE>9enzMNB+Rqj
z07=qkFH_taw0-(;D3%u23Yn1FZsR}B;K!%y3~uaR@Qxi(w*X5*wiA){Cwux%_nS+j
z$Hf!yZC>!^q5Q+_Fwj*u52b^BVpR=xokmx7Mt9<$WF}x}i_W^vtT8VhDjOvajjF(l
z8oJgeHjemxtDz-6u^sGk+P1jUm^QBwdj@3c?Z(vJH+E&n0(2_awM+-?4e!~_x2y{q
z?!0Gr2;MZDYG<iV^n!2f*JP6cONC8>SMy&afDr)r;b$3akqr(6uzOOv#IU;)aDl;E
zD6R|{4cP`0#!A1~AfkX-d(1C3ntWWYp)UThdt8Scmxn3-#kf)R4k`Zfj}0bvNKv_F
zY^cjU+)NykGw~L03B%>RPxUc1W4}^(55$})z4+*iO&&Jwoq&i8mxHhb_+`hKn&B;>
zKJpWW6WFKT4-5w?nW}m;U(({ytt_j`KbF}lj1TT{k2TK`)W+02#-dDcN2T|#lPc{G
zdhNQQwCgs(+ocn<lUEnwGphbRt)Y{*3BF|0Nex}GP3S^?SpqY7n{e304m!#EB3}u7
z2Lo{Tb|HvtT&$sYx5I8q-Sd>%?+~7lbr>Pv?hxuX$lY01i>3jr66<ZHO7t~+klX8M
zGgFUB*eUGr%HIJ6$&Qj1^Yfy0N8j+mdhFFu-(5lruR$!{x+|IHt(3Y+<4D2FkMvUA
zq)DXDb{Kp?Nu7M0xAPp9-Uo9p537|Fht9NRDf*qZR?<f0>({hl?W9PuW2=UaubouS
z?e%M}R@WM{#n)lhY%uFM)PwouLM?&-In*&MzI>?pwUbVexmz@JN<fk?83|%lKvHYZ
zkS*mw<pbhg;Rs3CjPWiw$;-FNX3Jq`wB@jq0MUQ94+kW!Y|_wM`-DII6`L5$iC5V&
zH<vAQv!k=8-I53Hdzg;?sF~Ed*1C<K7j3a*W*EZu3-ORuyIjah*e@LR9{bB@dCJbW
za0%u8%!>Z3F||-AE}?ELzI+Ms{Fy(MoBtVB96Wz0i!VQazF$%vdH(|}!{3A;B_@h#
z{z)x}(*_N#<QZG1+aNXtVzg*hk2S0RZjBB5a?GeY24y+mjn2aL+^8C~7wNFF3&z_l
zEEtz*+N19@SQg2yEvN$09VGQREO=H)MeCV#G2*b0iZ=tv)DZo~!$N0;vfzdO-y=e?
zf&@Z6?i|CB6kpeEbj@+0H8Cu}^6$9dMLJHiq3@3i5g99oqM+B(diYTux=?kT7}<_c
zqv|jA(;jAwsx^d%Ap~=DUp5w|6hGo42^$M-o_;hIcf!X|+gL66@WM_e8tflqjKo;O
z&Y&Brlpv8GUeZG%=@K!payHz1^f3^hOu^DHJOmpiqz<*2kQyMJdDeml;noRZAnG{!
zs}OyMlL8*kZT3Vz>6GxRg3N-o+2V|lPyTe=MvKn~Exa%0VhNNz)*~i+EQ~0eDS5&!
z@%At%CfU$-XN7hlONU}m$Gso<D}lxz)%}`>pxo6gq$(a<X~f>0#HH|P)Su1@-lOat
zaKlj&-d1D^&YvYPJphcauM^iH&{Wm^4^dTo-&FxA<*MQWb?z_315=QgQB|9z=e1sd
z#H`juHCV0xK)+x;Ub-gY99va|ho^_=zd0w|R8(JN(NO1?nVUcDf)Ir#uU?J`(HC66
zqN~l_S^Ul4in&8=_B%oPcn%Yq#csoL!;pgNUYZY9+yPR539pVcV=TS*(MT_DTIk`T
zM8h*!zgK6l_N{{l;KF=Qx2xZ2z-$H3<6Ce1&t_?TMB9XWisaEVc$o`w%E}DIq{3#M
zD@N5yZr|gZ$One7J4`FsEk5oyrK(R?u`<5=fgxkzAOFVMPt_N{aR&+hN8{&T7HTOA
z>eD|j3tb%+En?W%J#qd6=)AA{d3ufEAuzPutfwfLIw@BKuYkE|?wn+HKWB~RQzJo#
z=OPHFE!v6<wBxA^^eXM-7}thQiIKgHs;C^4pgY3c0oHB`yz^%fz_juT<h{)4A+2~-
zXiQ3}M&IVD;D;kn=w*Yh2{EL`Xbt`Ono!^SCUlZXv|%-CjBKpqTxL7UT#A=y^zqjj
zmzeo7m+-MNm-F)^E`HAc!DUhvnM>g!jXwDX<I*xm<}whrH^*{duEfQu>gQaX|Av!d
z#>XPs>TjVv*}FiapZYhPhU9!{5zW0RtT5f6RbsaWH<{cLT#5R95$%5q$K~eE*XVz_
zCE)$Wd9yXN-W_2e!7bP{>yD609%aLAdPfMejhqTo@KB-X?K^H3Gp&q<-|SiYZ=|1g
z_`tY&O52At`>xQF^qH&C-?}TDz;VnO8v4sW!fJvmn`!)gxN*N8rlD`{3js=-tJL>_
z;N>w@Cspr^t!4GlS_u!}QmRv0q@VmixT+x6!J$_X*7W{MHS|i6(7Ni{OeyDc1#-gE
z{SfKhpB3q29tw>W<O<SHFBVeB-y^VyDTdSC1C?QoYGcEy@DPn-9<ykgM_e#@QDmgw
zdc<`j%XJ$46OXtr6huE&v-AmkQ|vm|v?oHk9dx{CJne22JZLxXIKPfh-{)gYv<+a-
zIm$DqIEBr@&Dezcm&F~UqY=!?{}nmRC9@GE<tg;>`oBeV$y4DvIhvu-k1G*yn$>Qy
zhHiU?(`UH+l(u*-<d7|MHT1-DAt=n}(ns81+RVy9Z7P4m*HS@m-sEFNB4SK|+UEY2
zUsq{>bY2L36yzKje*dp9kp%SCQ16#QEmx;=?CR;)hU2ebLaMgT(6G;jUcx=GprlAY
z=A}?cLCzr4H?M>)4aak3xK*@?`F)(mDl|@44!&^O_Xe+ewJaL<iKh#LPRT2rCM2hk
zUGp*a3vvZkVc)z>_560QB8`ToFIbVjf@On9dqsY6wUl>?sM}lNEjfwoY5sAoNC!w|
zlYbm8fP?7#U!c{G-73;Af5%R49!H}6r8ot-aVqNdUTEo%GKMMcYeW9id?QVH52sVb
z;v%~2y%0xwjMwPzzZV1ri65n*BR|3gcm(;ce-y@&KQJc58(|+T+fTnT3bj0ZMoK~*
z^~kdI*l=eAf|-Ry^qNt)NbYpeEZL;%Lw*CJiV9s5(zA<(wpHjFkSR$TI!d9d<2&M_
zB<XPvS+$cVTUML#Q|NGa&R<3Jl0w&oc#P5L{gk>MaMPv2>?8;}0M-jC=o->TL>Eb}
zAUMoc*Q|XvjRbJ@151ERj!Eop>d2(XUWw7#N6VlL{1v;GF>smW@HyA;4nqFX7QCZJ
zYV=QSb^R4&Bsyw*1ziWSPbzKz$%WjXR?xL<HFu~~(v5qTC24Z4%9+i}VOL?t=cHm{
ze_(J#orYA@btZGa#L!bw7mKr?gE1P|qmTj=(zcQ=nN0Zt25%)@OYfU0QXviRSQa9!
zb93v*`8f>yvj|J->CQGzVnsU5FRn8kTv@k@>;|X222c~BKUQ1~WHm|fi>pZr&lgd#
zita7hg*051o)554CFd4#epSD{UW6(BQ1qdqmhst5sISW?4;tvGb0=?yX!PwIb!!!5
zV@r7dhR#)0f^!W{l3n1TaMFExKDud~r>*WR29%tpaqY;S6pj8|(>T3?Wc0(1M6<Y1
z^6F#}{lZsQTR+!Dr&9P8hr<lYdLEyJ*Wa#6pHG_y38+P0vp9D$^F$H75Tpy#f2^kS
zRq#6(sK1-euj;@*%3ycRu0Wl<bnbMho6d{qf$rk8IbQk|ZaP>ct$Q)4vg!CstBpI(
zeb*6=C_sPKT^FK|=Z>WwI#06wcoFsS&^0Hw`)KsNJ#=aXd7Gf2`#p93N?^O?sjEpw
zo+_fYUb<G~Rgy*@>7^@B1n%ipUTNlPNv#>tDz2XGiz5)#=vHwJ$?imr{<~IjKPr53
z<5|~z^9fja+cm;h=R+cn6zL(uZxm(U^zw>m_R6C5@z=FhSX?}uQd2ip*>)YhSW}lq
zUUb#aPPKHW$U1aUm)bg&<z7-rwf@y<m)g3=xLsMJZyuoQq^R053gf!&$O)#*GuG0q
zK;1|(X@3zeJQ?djo$BbiD)ZOq2i4JGsO;KNLr2urd0YA7bL;8?h@n8jMz7b^ov|!2
zKS)=D%-_Zvc)ca&HgP|Y+z1V=*fy?iHBE#xob5V<ZXwApC0N(eF%+wJmyYa)wV2SM
zbX~A6i$smo(8l$30gZddl{qai;FR>_K7i;f1HO%%=*=Etx0PKQxP$k%1lYm9(82BE
z!pIK|G<0u$U2WFH3G;O7iVv2zW6Kyib%-v8fTs5IQKKM#jlSW0UAk?h<m#9lKa|2z
zkr1-J9{qmG5?Aj8gWU|tbj&GW<K5RWW?MLOcv5)vSqt0Y6hQ`_1JO98op_>gdg>@5
zh-x)Se$?-&u9D}Q5WLaZDZmM)=!5_#KFP9q^mYgxymRpj=M>AY@YtLXp-HM!y~2Xe
z*b)TM507-syoNX69PK$rY1(8Qdp0oAu8(z|U78_2E_=eqTXEUFJ{nk5K>0ZwdBRQ~
zOW2`vn5=L-N!RHj%d`3%AI*EBt7y@l`A>8$tCRVkp|e4dMWrVMms{z9!JMfBt904i
z&gJ-Z&SxwqAjpEH0WPF+<ajaYKje7fnXYm5huNR8eSjc|ZHwnRcV)M_G$DGV%B^`_
z_&BlLycL7>n}N-_fl>^qS{Huo=Q>a2^E#}ke`($eoxS-B|NIxau<8zTJ}ajZf-K-q
z!~4kPz}EzF_;ySp*!_N~gG$Z*jF*TY3tn$(m&@yR?f($P!B=Rs7c)O&TY?}9w!><b
z%eHGR&epoooJS@F+8!5?fASk$md~9Y=y+=ERvK09o0s)h{JPdoLo>%D)uGGBB{_R+
z@IW#j-d|<^D6Ro5je~1`Tv9_jJ|HX|n^cGB!1v@^UA9jy>(CP4$CzT|o({gV+H$_l
zJbI(oe#Y{rScxS!vJ&3t>JR}OTaHZ1^6AjMjN^ArEjhMqV~Nz>y&Sd!Vl0u;ytiPS
z$wZKrl<iZ}wTyAsCYFpJw34Cjaw~^trDzMNCF4-}3~=1@L8tTCfEh%tyj^2Uj^AMp
zhfte&jBzc8<Dt$HN2}30@2jN#ru9^WQP<9+b7Qu|=TF?jCBpiC5bl=q*U+U#UHwM&
zeN1y-1lzo9Yg?PIUYjCQe2$%p<;BgN75B48tc<E~dzAQYg-@-{0mz1xH8#fn@Maut
z8nS<6<K{$&S{m=eUc`6?Ci<F}$p>JfVVUfYAS{#DSLX#S+z%nF?)asrr^*+6%3B~W
z$rHWF#gO+)_KWUuyF=I}q0@|G_<|rNr*{M<IktDWMh@O01*gctbL8M<Ja}m)Dj~<D
zg}kSJ3bA_g-g1&*Qj&w_ByHrFSSjX~Ii?mek4EMi_Hq(;DTzN^R5Jf34c^l=jQ^hv
zB*1srhDOfP6myaSIp%~ElWC60L*}O}^GrF(VkyZ%bCOYV%r{cZEptpyWNxbjxE6Af
z&QcP8V3fi6B1t-uG`E$LRFjgVn3FuLFTs9;S_5{bIp#wB_w)eEyh~1UL`rhdoMe?8
z^RpCl%N!#hvm+6!M}5hYO#BAC{jqx?1M4Y;4nt^!Ikb%w+Kq|N99jpgh7++K`KHEu
zx`c?0D&JpIW^AP8c5@GO_ckkEoE!Ji-1XwhS0BINqpA5ll<$|^Zk}Y4mquULR#e!T
zhx@QfqQAexU!}&bS<~&iW>1Ib?<;@vJ4o0AGCa9K(<+HR$_qE>Job0n4Z4y2U3`O{
zswDa;$KRmEmBc`0{0&;IGX4hMpe@<okA*aa{k>91XR*Keg>*Cfn^j0JvA;tK>3jCK
zbs?=?1%KTNX)OEu_&QBze~(?K%h=!VuH%(8{GEg?arU>zb?WGVzrojOQ}&l!rvvbp
z+_+XsLml$G=(i4HW#!Im^d}ZO?;5?p{-$1|ui4*-Yt+|K3=HwS#_GJET_TBlp7MC(
zv3q*CwO>@F?t2TjK(0Q`QB;uj1akof0jxBND)AE-U2xjvBfqZ<m+<}5j9Y`?QDh^<
z;=D^)?D1yU;&(<L{|Ur7Mr4C{#E8)#D!YijBpyV4M$`up&xpz(Ml+%)TtnwE;sl5-
zj93ri0wZREcm^UvjVT2)Jp-`qJ=?#T#k|QD7&@5~Y?KmwX`P_9Il($90qd_89F*n+
zc~XL9WeIRN2~xP-6k~2Rz&Z#*&j`#*^eQ8!gLun`fgrqGL9_wUni1Y0k{R)?3AO+j
zaSg<3M(hT0fDshLEmtwL8k=}5*DY{r_`8YAN!`{iP<ZLW!DvQWTu_+z6mM3T+%Nef
zlKTV(R%A0qJbNEcdZx0e91s+ZhYG^r>+M)^C~Yt@xfW>$qQ}T&Z~q9MWUh2id6slV
zKYCb<9K4J!I55$*W>@(qJB|~5+%}*x`->+@ZFqO=4rT{OCgZY6Od|NsnVqBg#AxPg
z_rwHv2KZqr?058hp|*+GsbF)$D$XqtdyVkdyfQ?nq#<mE6r3gp*HgWx8c&QH(<;8F
z3q8f=q$7wko?=))el~NGWi#JHbXGP8nRVQ-0-<K1(p-<hjhqfwW+K8)>o@k0IL<G5
zi8X!qR##X^KUcb$>jiYgsG3c%spTd1uQsItCh~1DIr3X%qp)_V;w}1<<&GK}>MaJ_
zk8+e;;55ZsJZd$wr@V=7k@2rB8`CiH;w!(M?;{|+5G`S2T8$C>S9lu#<2VXNX#pOO
zwTawqi~sSdBYZ1;MmR?HN{UPxQ86(-N0kLukv$VeRKT(6rpU!Ehuo<gYLgI|IKmdR
zBUrF7Eepe*awr<bQ+tF-$6`@lraC3>qJx|K&fyK?w^Obg!tT%w`HlzGxbPkORU;k0
z(Bk(>8FWWG6id67Mh9g4h5%NWt5ld<FgFG!SrlY$0xX^&TR4e=P&IgNz^~d%Zd(N2
z_X1l;hu{4aX}pZ6V`ErR`}kud1$Im##>+<4fNIz#i@`5xn=C{1!V@LVz**;~2*g1j
zEKxtE@yn`Pf_x~E>|DTkiDVnlJ0y}VXP0x57sTc>l<S2W71(18z=flC)hxuBHw{C_
zU>H>gZBZnU;R)Md5PVU_)8|R)?{gu^$iWm@=Gkg!(WvCwB;~G}p7#}7ktR@_?xT}c
z8BOfK4R)ArCUd9C67pbJxP%tI;1c@r9+MDwVpz8jQpeE{Qq}{reExEVe7-4@k7^<e
zdM=)S%fvGsd9Z~z0<|ALIwFJ7DWJPa!3iLnNMr;^4~b*~{4k2=V*<P*kxYQcImyJ-
zWR`UIGLs#Lh^O`llT>*6J2Ogbc(K6agn`7v+Vtj!Xiw#BHGTIXI?&efEflNv$LM+_
zzY65@F<Rx2&yqtvHZ$O1&G#2;+Wx{4UGf(L$YBQ!eUBjj0az#*Rl{qu;-&^f;N(es
z)}8pQqOMtQa79Wb_(*GtapcI$`!u_z=+|)^3@2t=<Kk_0hcu`N=x_r^=H<eRaxAnW
zqnKu2UL~c)12N%>-`NG{ju*afV?!U;6g~P>FPG6phw>Pm-f3pE?jmP&6pWai?#v#x
zi{L9RqiSSj%pA4ECS=n`HQn}Ww{W7qsiqHq?N%pa;|DxOhc&QsjP9dyVmi=y8Hb=I
z*dM@=%ZgH|SSy5|y1@Cbc+CWVCvtZ`2wP^KTS;Ss2dtE60_c(rj?6hLC$wc^!@0-e
z$4uinxd9^{(>Q;w+C8D##ctRQ#!<#-JX}{0jlO`Ln!nZb`~BSlGE^)c3zWyuKY2IU
z*^t{F&jY&Rd3MXd!X``%Hw}Mi*}CIbL|KgxY&SeQ`#=j|!;P$fRR5mZrcLI=%E*ID
z;r_t_#&T|vy~4CkfY>8r>?>AXe4fwVvQ7y`?I4QIPgn<P+wZ2-ftcf1?m$-%`#Kd_
zP|GxY;4k+g>`~6GVl~RB0<etZy{KOmHpm?BnzN4CxlsS05oKeITU&`{edX=&vcB@S
zM6$ken3KG`H;`&{&JJnb%?^2gLrt3minU0FehBRwC??yc0T|sKD25XEmugxRDE>+|
ze^Aq(>WBx(gnf_c$hu+{IRWBzT`@u#?n3w17rnfeS716I1{gT|aP4WX20w;EUvKS7
zu1+E_4$TS@Lq<)yhKA0@7{-QT$k}PvsDMte5WJp8*z94F%feapkw%EVs?&^Wn2?x|
z*lGojTwPVOL!x3lFT)ht9rHP>5KB|gmknRpIJStVA+M>ae?76TGSFFqm}O@LG5r*W
zI4HyfF$_~KttW;m*E{hH&8k>skl!CK;f33E-^!Fp43NYbe&r-**8WUuxxP!48eG62
zdfFZ<fjGMbi$|6Hs!~;bv9Z^WgyERWUnyWLxb=`@7uvir9b8|m*=Fzw&dax6Sr?UF
zbCJ7IZH2}r-?1o;$q$_urefJ+FZqsAP2G42WsULvIA{1>u&JhdZE$|Qf#?-j;fC7g
z)z$Q>W*P5e%X^6}t8k88ZAaQBMD(X48;GrIbyi9u%;g#`24u3o<|-Tym#UEX?iepI
z`ai0$56zozUvv*$jkUI_@KY40nTx;@MPmnsqQ75ng@x?!)G`drxv~HquQzQ>t27jS
zYE_d;H`Xm*fPZ3idl4cAD3hvC&rmVMYn=^ay7<!uIbX9eO$i0R)T6vMuK&TW9{8;e
z1;3vw(<6*usnKA;uMD5qM8>!82<PWnr+j?V(c5Agf}gPx9orE663XZIHdNx*-bLc)
z8(2QSKi)&y4(!H$|JjlD(Z>~R^fk4(;jcQ>B}}ZIVf%6je|_}EZH%W)xUTJI<_?bd
zm9h?|Dt$Ht7wv<n^&CV+5DE~|D~e;EV@V*rq9}DsL(<qM#$tD)ss=Mzr1LnegBk|b
zkp^MaL^cQ;F~v%QFniKd_5<aOPOh6V;9&$GQ9am*>hHx7hu_Dm*%(pZ{w^79K^DX5
ziUCNEks^$Z0+=CSv|%`H2t~6n+Em9Y$iwM$j1w46F*N>;7b#$fFq>_^M6zMD#rG1;
zY>wFy$;Q#qoa6;vMIqcb7M&gP(*?C`xm}`-){828<0bT*2EPoU-PemAbo-d(PPR1w
zkd}@~4k9NFYFcM(@_6MlHC;J2xlP8zy^oDL9KZ%g<;1U@c8LKeICIC6JE+u9TWz%B
zgz*;Z4_IKa2VL>3#%rcx+(#!50j%PP*i*_P#DEt3XZV_fT-B-uNU9MOpCfV+$z#dT
zw@?jlQY2;G!68UvC_5Lq`J9@jrzN|^y!wyA+FKV^S1RmG?eYsNdZVW2(vsaX{)^qM
zcUIU>9N^fOZE1~)^$PeD`<yp;!}DNqe=E5-{ugi2%)1WQg^!Y$_uNrF^H5;TN>8re
zX3}dYzofsceGG3#;C5{o5f{>!{uV&L%tnOtbn>oV*i7P2Coc^b8#@1ZiS-`X@c6P+
zbpZo!`*5rvo9RE$$>CzFG1|vWZymS29|Fy`D}4l`3Uv+JUmq%rBVE6vU*V}?Xa4vT
zysbT@<aedy_vGX$a`FHqH^X69!|NU;MB{M-SY~$n{(%D4Y$k3bSN>Ad3(dq9k^d?r
z!;o8}5lo-_k?@?XTNqn!$vS2?LhsJIV+)Ax$9=qA8qddc64P94l95?1oBrjnd9};T
zrjf*E_PnxD3&qQN`RZS_&2BzS>5e2YH?w2>V>Z^nyvFOj*O^3B?;bJ(6fT-Tgk65f
z!rJ<+9|EcM;1)sK=SYBKV;Exip$q>OVlCS(cOit%EyOvI4Qwpx?$7Fpy4h8b^(O-L
zd{)5gxi`lGU<(=Gt`}<R(o%FM(+bu4U=Rv2?7EtEY$f(h8T=7F5&XDR%Q(0GSL#II
z%(^Y&VeQ*p+AawM_I|kY9$ua?yPWbaJySE=nJr(GbV1Q7RSIO{i3&D?7CyVoE5Bk4
zt8dd1{=?3|etc)c=25(R1npuwF!LX9(Oq~T|IXmQ+uHNQ<B-^_Jv6PgDAd0Gmeqwn
z&K=K84Q><g5l0$_PCYl!L(^Bd_83;DF|RZe+!j5r$dx%#MLgIVBS;q91i&-3Z1mw6
z#lf!G(e^RMLlc|FWCLp3_|Xja{U>TVxs5oiV|O5vn>~PcBvsCRx!KX`*Z$$vS!fY-
z3_<2fNDbdsOlc7RMrssHVBvjsaeU+dW?ipWfPLid$>?n|K<}q&y0NXOQF}p1a?wx!
z;N{HzhZTLEE8!1V902a)JO<Z~FJ4qFq<CyWA<_~=Crn4&|F9dzestFJX!tU79MAs+
zUHrP8*p^H>tftM!CD-ujdy-p1{DdZUN?a<l=0o>27^^F2+PGxT(7SLMvGHf6hK)Zn
zUNTo)`Rscz_RZUa{qEn?^fhC@?1UBj9$1h`?Ay!itJjv<7pfWiqv(dx-psA`Vgr)@
zSWTTG#10MOT1$P033KLlF3e#!%7mF^7G~@tHJuhA{?z}gR(P!zzCe~^>o%U_kHWGX
z-?JPTT_MVe#gJ=OGW)KDr*6A7jA@Z7=MEbg;qky@i$#{w)n`VEI3V>Ku>IIU{I*Ih
zw1w_Nm2pRlkJ1JGo4M*!I*L9DauqAtj85W<s?RY}$nkJ`=rg0lY6|juk(w^)EPhKG
zg9z^;-X(3YF7l2R*H>MOE@DnkFGP!>IOZCk*pQMKQR8~|J}it2XjcAVFg`8XtEN+9
z#1z-GPa<*))bweL7)@$moM;s*o+jO~K(UV#eFCncS&IGm2f_OpE1bz@A&$_mvsamZ
zeetiFM#qW%fse2PDkd;o*c!*#kOX6j9W)E+&swWG<iZYPQ^ncQuJl&4=nJ586J(&Z
zp_2z@JCy<LxLZxz!~<wP7SNUv7xZenB_2QrUQz4c#fzO41KijEqqDlrKtjv-8CBmN
zHRG2;vRMejzwi>nAAr$IdXb64{!50f>I28h%5I`}tJSP;^SF(2+`ZoU?CLKmkjjDQ
z5%@{JTAG|5@01fBS`Z4gxeMd4(}dbI`>!R_$*gBadLudAC-BBOCN$YM;9>Y@CcYR#
z589N(ghnBjGNCQWpW%v+M4gstX!O8z_K?K0-Jx{e!1N3p`i`RbCgkF@;HtMU#1wtN
z5kaHsN34)z2c>%l+`Pz?*)icZpT?j4&Xg4+i##uH-Noup8%^)-T4~Z5H6#*?jDgA-
zHG=~rN5#!MYUV?fdZQBaDLZCxJ&_?if+#+Yl?+O+14wO_;soFq>8r?J+tsw-i}WdO
z572`6PO|7vV2WWUo!4P@ib+ZL&G_p)ht=&ShgI>S1j|{5wPgnc6A4*JyQrr74vc|c
zonjcHF^w`Wxf(S+*3ni`lner0G4}$SJ=iWPz`+RPkGVVTnh@Z?#CoTeRHIY3)HcC#
zm7EQaF(<Mr9qqxYv;}dWv?FyMoZiqbC(v~<4lfN(Z{zTu*)n*}CIC6;+`;MN$P=uK
z6hqS6k)*9^+F?j~ooYFO4;N}|CYpxJfhX1Un<43gt43lCQ`DcgPz4y-MMKj4o3}p8
zMX~V)7sa%5)-B|?4Wj4@{CGy|I5K~Ossd+;nnnyw_f9$#z7;zJZ;Bd%CnRv{ER%qA
z>zw;5SppGGyIwK@g!@YZsPVT&lSaIk>hIB=)nADy>;dEtO%K3lUej?T^V-n#IEVb-
zSTE@49GBxTj6S<I&6Rc>mfp`T^CoNFk45zXDJJV*oTI=Ll|L-KcDwY`yiRwn^E#bA
zV_m0?`3#xVy#CBD&Ym(i209#Ljr%udSQmAAt+s3M(*%8*FQ9uGRcg2eFzVoc)&=<l
zB)nr4z;k9@Sp_;FO47-`VrP6F@I%Ljv~@pmBx=(X<S+fizU1~PHLcKJ3_{q(4tS2G
zKOBqG5jMQPc*u0#AZ!57J}j~!oic!Bukmk0Ls~pQ>_gU`P}8VnF~~Eg#^{KKHpR6x
zW{qJ$Hn`K7$(Y<~BHgiM@%yrqax%|=_GLVGv};J~4+762$I5tyv@3__8z*{f5P04`
z3g};0@XY^0OmgTVYouT2e52kaMZ`^?zn#Z)F<9(LMuV6$7(O$H(`veRu(&t;?|o1s
z$~G@Cu6Z<iWjGqVm5*rHGMK?`3Se@LHq7_kW-LlWGFWaHcz+oJZ}FggYWj8vcHxGc
z#k4dOn>`i3Q`6l;#Xm^DgK9c&m^hz&_bt3zYLqOXz=>)xi0JpIX`Whi^U2%8rqG*)
z%m~(0BhFj)HR_z1-ar}ljDA#$xTU1V{-zCSq(*G%niG=ih}TAQYSg<NhLuQoEsuuu
zuaW7)m0uOp=uzomqygrODWlR`)jzk3DV@rG{}7w~L43|0_$vy`X<HQ`_?iV%RM{3!
zZmKwrJVy)JeJM6{-GEu`z}0}VDd@y1HSO}HILfu&ClN7-IQFI3m0ZMZ>ONcyC(A)}
z8!md1q~&TlVz^k}tL}2OO-YPyZjB(UbQLk$<FMzshW<^r3>Uq<pD$ye_Q?xjIFAd^
zFM;p+GBy2YxLB9ugK!!lret(Q%Duj*3471bx#$J@xHP*ls7BStpD;AYv$GWPh=s7(
zZF>Q$@eE8}PF46vHtbafkNqqaKP`t*(x`GTKx#hyKoRT>H;H7x^=ZvoC-Rh9i38~+
zBOs@R&^j)sXw04mJZhB5=}Xjk{Yc2^<PqzLB2=NyD99-tjq}wg$f+fW&7&ZvmrK<2
z)F`pO_wgmNoD8U;rJSZepw6R3FYkp&zyt*Y8Go6eZh^u^B{)Ql#$kY-AV!ZCQ^?cB
zST~M_!IHPmEE0wj+e|Eki6lwSL{j&6HFX|?l)EwWSycX+tyKB9%~|E|V(5VlMia(}
z0;vTf_0kwI%=OA4RC1C_S?yn=c#pB-NY{R!L`+7+(y?MUVzX0CAB+{-kV8Avbj3Ka
z51p1KiWRf(8jVF4Y;e9z?5j^n7uPESW~?y-XGIuQ<5>s;-f9~I?tmUwf4o>DXw_C3
zIGeR9@)g}p!_CGF_DSF{pHWO3kEW~kE0k(HRQv>b{Q>3^md!y!uA0`JfToN2Bw{!s
z)=fauJ=>zDuO^`B_J9bTC^k?wzDbiOioFtUtOhT8w8ehL5N|-?H^%dvwu`nfsA^2o
zWlHDD)0ma+&1Pu~hz>J<DzWq{(FZf^{yGiyHNO&PDM_1+7;q+u2STI+w^qm8nYQp9
z^EUVbq(Xf5SN3=^G$$~+c0)a#EbdZ}v9r`PVTxExe%hd>?WT&~5Zjp;`lgCsm<IRE
z9dSN&N?>EKP15z?hxKmq8Vnv-MW!&f-k0q2LZd2Vftn7PCN}6@fF!1Ma|)xFr|a5Q
z3+EFo3~8O-@rfr-8-ex2=CAmAVn&AK%HdmDrsd{%2=(4Hv3ACu@_46|%lp)0Gw*PT
z_n*_t;r$LWZuGe51+Q7B0Dp!J>l?cf<&=fsfAh<$$RLZtPEO<%**K!L&97*2$V=X!
zGu0+*GdyV1MURZ#<<&-8ZUM!Q%4*XoAemugeh2j|xKKeSKz<QYu?gkX(GGR|6~0nn
z=@gL0a<DdO{k04r4B3@Z_PeViIN+ej-7S$`UQHj{q_)X2WL<}aIcdN^c5CobecS-@
zOjOfB`na@OyD>?YqOM>X!x-=apc-L5-~s<|j+*9Xia{BABtaa+%MgHyK#nb&C5fU!
z;VZ^-*;Se*H55)enD;fm*r>LN+|S%eMKyR?vLn?VJWlT_k8_d*=Lm4lfNekLwB*jP
zVr>W3QH@>|9g{`G9kh(^gmU?Q++;>vG>#*#F|{?onVQ>*`G#N6!^h(J+yJ^uD^|@Y
zm*w|nmYo7{p_R0E{H-XpZ(oRJl2p)*%jMv2iy|WV9Z*cNEtuyxk5|R+mz_*7B7bNc
zOqz^q>yK7)3|kd}KZ|*)$lZgHR&MEke^%4Od*a%+S-V#1@oObMAuIz&g=X#Rfk30`
zcs8`+u<qb{-5W2bSvsE3an~aFE7sKeR+Ut=gB8uZOuz*HCF@%`cH=invI}CNT+Yxw
zyAL-T@wCh_8J*50T5Sq+0GsegX7VRG0bH~W!$7&5-~Un`=b2{CodSk26inxC36fx=
zQQqD(Uf$`+pOq)TLim+AG>SH$Wf@>+zE|ES$F5|1d6oO7TnM&i2;tqO!gSw!R+#%w
zY8oku9=*!tT(w-z%l<Zt?e17!jl$2X@iT_@P2ikSF6XsBmnXIc7M#D9I9~*3X+X1X
zm6jWz->GKlphs^jPdF_z$}Q>eU*<Ygl}h^O>(8WfX+4_4ma7<M9QnjTv}HMbSYsMC
zPG$%V3;%Tt7fK{&Si?%0L~yhi({kxS@5FXtTNXy3p<&?_z=LCB_@Z|yyO(5Q7w}rK
z+!V#mS4C%CGeq{r`AVO}eoCjUG|MM3uo}LB#j7&T`0CbVJ1_N2Y~tM2A17OI%7)=L
zj7ln{hi8kulvTG<&nz*BeK;G>-Uvp%MQmhcIUeSsEac!IR`n{Si{>DQ<5pTU2RR(e
z$x)YD<T#U9N;`TcCX%HNTj_Go#JbL-9IW$5we7joR3%=}mLBHXwk?a|^9E{ru_v!>
zU$V3cuWo?r*ed1MSF=RI;>PN`FG0p~tg?({Rpn2x<as4_j9#%=%EZnF8g6uykfcEF
z*>XfxM8s!3GaQuTaNHn#njFXAvlh9B!s>e`_9GiAZKbok69ZJ*N;1Yp=7lFdS7RmK
z_OfV}_ub7UW?&3s(r0rGEAf^b$4c~;<4ihmq`O?=Y<s!H!T1JQYR%6|JmhIn;*D<R
z62D+-XHnuoIgXVWCC9-@$Lr|UMK1BnigJmO70W9zbDo$+&Wy({`8+YC@~ZL7{qWk*
z^ehdYFM74PMX~+s7?br1i@-;qqq9z9waK00c8j@%%C7K#Z74azO1)_~;m(ZaZ9j6C
z$C}fzUbJN4wyM<7r1wbopT@z((0Y)^R~^_2#2*c1cy+{v4sY7Kc9k^5F+L{{K%4e%
zNSckqo?Nb2&-DnFS1c`JxfAMLIu=ghy~mQ-Aet{gio>kv`*I?b9*>Ca;k|2R%wGcV
zctKRP8U%9*GLKKe0*ph05V(9X3q;5U77~w;^9bRqxTP$l6<gr2m%DRRGZC>r0fIHE
z3iXKcLsSP3W|#kqg(=@BpThH^^!~^z?T%+yf?Aa(+30R=I7FIt*s4mIa@-qN9w(iZ
zf~)R<;n;6BHpR`6UJ46gVcS?(ZSLWerI^P;Tu>2A#t3H)lN<!qU=8vkcw#FEF=jQB
zy!<82dXFKi$ExYz=Di=1tz)p}ZqeH__T>WZ?&3|{Xg(NX^Nj~d`*FTf(1C?K6+aoU
z60}iehX}s5+M!}Ur&DYvFBaXr4@!!W@4|4b$g{*j^A?N4$@bA|>aavKWSkhq;9tej
z-bok&EzWiVf<vwuRdfzV<-&s`RN+$4WhoU$wGA|$t49P!b=sBvT!Q5<Zyd<eUO54}
z!B*){k1~voHx0*~7|5+ydf^t>rD6<uF;Y#>EER+Nc#8W4X#fUAG^%!wge?m@l`C!B
zQR+&?k)$0`YpEE-be3skS!#laeN?QKF=n2ubJJiHah>}CAzbH1vJj?o!Lzx}4M2pf
zbNO2l#dNNEHCBm}i|`Z1u`0oow;}S%P6?}W$BtkUy=i#hC@EIQHUY{Bu&5sxUZK+z
z`!dC1K`It>mj$t79jqT-=AG)MVKZ_XRm)a^zv&Qo-ZD{3Rt{IwfaPM%xcPI@$J_yC
zH3%GL=Kbww&|TT#NJ#2q7Q@DT!vInQwPfrMIWV@rthCeye1Y4dcfGo`DMo^vK%cR9
zjeJ>++f*WrxQGiDVtm$z=tKY5Vx_QDO~YFD_NkE*7>aa=my=?j1lo^{f#YND8ui0l
z_AW7hRO`G-^sv1p!tQLaO7!fTIvel7!Aa91MrTw`gvpo8_HgZ-r@~n$8KD+CpOqI$
z)(=|(z3jt{h0FV3ePGRIwc%NSh5omzuzU7G4aHd{wj?*Pa<>0gY~YYTOB&&9D#67a
z0h8VKs18^LeTy$b8qcCrzZJdPUxFu^*R;&)g>_<geu260g5JFFm3zxfAJcMCJ6}yN
ze+yUFgPH23tHs7u=L};7P7Mf(m^~^WjMlu{+KcvIExK072^m-d4C7aeqsU)F)%4D4
zaj3(0GgzlWYD36wx&W`{dQC?NYpZh=SX=F8J;$U1{z)-j8LPF>Q+6g4roKH}!9g}V
z#!H8D*{O2*a4r!U<M82++vAUP?xjH5{VUQj$8%{e93SkIu5{E|wTQX$m=obgq{1C<
z@j2f|6Py-uwp#)g@`>Wi$L;%>P86%9-~^<ImB<K?4JDEt?{SkzcDm>7BhG@I?)jUO
zyv|ro><D0x<FmuN4pGx;y<-B%$2LP~%ib~lY=1*Sy0mvp12W<pH9gupW)kV5!&X6`
zm^nn~`k0>W6XWT%YXXE(c6cXi6+c{qwj1=#(!MdO>J@X!tmp9OJ$Mt|Zh_N-k^N)b
z0(Z<|XIqNk8!VF$1C#(0hab<up{y^|RNXhGwqi2P>KjwT?W?&myZEeO?28M#z<rHq
zLEjkfD(xiZdz!POiG5?-h|L^q2ltI>+I2Eht+@ex!8JPTHv53XA1l1VY{rQntz!oj
z;LkWvW@qzHJmRqsLU&**pmhlx_>E>J-d|>6m-BnkQw0Y>kpo-%m@B?!60dkH=g%Dp
z;o(yL6$~4zIC(u=y%c{HQqt#h%rg3`J1;83lvMTIY_&~(#bO-WEfej(U-J^awa7MG
z%C?0e<R!$;#+s&oOf9lALrok1C{AyLUMP)5vMw4{?qVaMQ8g6vm%M}JZ<zV+F@Ng4
z8#<MCKumRyN7JRw(8k7cQxe-c&g;;VgQuV;hprO?GxorK!YxjamfdL970{vNe$Zzc
z?+3r$m-<23(KVy0En-+h`eUaMs$kg}?!cJfogo>W0avWE{)_=<uiPVUf|=YSPI0m~
zKV!c|3T8cGu|%>SF<By6j~FD8tVeW|NY*2QILURe?7Ulib|4*~ra|j*3_iLUKjJpT
zmLMVBxgH<MY=+%<dp&%j3#O`R?+xO5lF{n%(x1er=3l4qV{S}|l}<Arp?|ZZZe06v
z9Dg1iVclEg^K2c))4X3q4==+ErV65bGA{f=EZ2taemH~V^s`vqV?IU>^cX+ZW1tXn
z?%U&}+_S86kCk%AnsSp+^xk?ui<AVQKOg>Ctf{=3F6EpqT9vDb;pNuwmCJPv6fpDl
zw<vO|oUxX5#>!I0jbYG323U1c3-u+%@W_>+^_8<8(OH$bF`AdTu&tbxjMS>>qhG`Z
zzL`vOi}B$cHjbrn)X?Z(Nlo8E&6%2J&`FY-K6tyublq)2w%wtV%t<p5FDu(^28nyY
zY^HnT#~S?Tci3>CkgW^s7RgZ=|5)C>Z+#z%JvupVTw$loCPioM2*^ac8dVBFW6d?2
zp4lj3Bfag}r=j|4o5V0B*#`7cTg2C18zumL5Zo$G^(3!T*BNjzx6OJKN_*#Ho>cW$
z(}nrsBIMp#9I6lADjF2z&NMYuZ5QwQK4KPfb~2ojt&;;%oM!yXzoEl*%s3X*9lJ(5
z#8spNRB-1G%)NKNh8uW?c#uTExLv<ftPh^{4?^jco#J`&F%hTRcZsRKs|G=b3Zr#z
z+BgZ3uZ+e<g^i5+BjVywpSKg>oY#x3N$tWCIts7*kwn<2DSJdenlhnJ6{k9*(aCim
z6%&0hG*3|L&+0{Q1=-g_O^bJnv82y6IoB+heaIC`dV^T7N9-}6+Sl;Fu>&SMig(I`
zO@tw7K#8$v2_$P&1y6xlIRiqKTloY?LpY0{$m1&`zARr27Cw-NKZho_Ef9mrv=P`b
zD-eAu4T9-sROKOjeu0>%QsSprX!6WY4G1%|@OwsI7ht>b9|+KEuUISWV0RQQ@%v{o
z%E`t799;k8B*w5-$8`wIwlb=;!x`tplht(8Ui8%z{4B0gT%p*uSXpcWmtwd*<q2KA
zSM+wMk9cNY7Uw=QF1<KORV9LNTwq@uCgeYR#pW3&zGMt5qsV9!nZj<I8W#=Aj6LLT
zD<}Ser@0UH=G9*nkO|3@#2B5V^8k~KsyTC6eo=~uHrh{=9u6t|Lh2EFi?#s!k6`d=
zBGpY?e}h!`3=gq5afJUduwTeXtZy6H9|OBFBQd=5n}@t#o*V%Ko;!YEF4!1`1n|YV
z(+nfFZtyfS4$UP8U|tPB%adbq5sh=}{*p^)r&lTcCNr_IXQssK;wXui9R09%DLtB*
z7*xHZoELm>3{T2iTD6qgY7-l`eO1J9ydG(VBc-;C;{zNHDE?2LiutD)%sps78-s&u
zDIE_Mp0gwt&eklR)hea?wTbT4lTCRopm%aCrNzkG*-6TqIozuF$+hI--C6M#Vz_5u
zXsyN2#;KGJ6@Y{CNXKYvkt%>=vj7~U%E>#-uap)dZ)ZO#Z(nO1Sv6%Gb>Qi-#PRQg
z&v7I>m(oNXaIEK%jwe#B>f}<hl&;nR$JBE2ijd`Lmbaml*MviE%H{s0)Ll&Ut6q9v
zD%Y|pJE}@)yofq%=8=xCHCE+%_{(+JiKerxgHGmUsZxa=rSu4Rc{Y=H`B~Q?58`r~
zfjU$vC-0)_rL@fq;Mo5US1G;P3P+HijN>S*Z%Z7DcyjADErx3E058wZ60ZX?4p|=g
zzNOSS1FBs~&TA=;i$0~a-Av%vcaP&pvc^%zSH^Le&Gr_$wSXtL#_<!{WfypPc9MA2
zkYy|5*j%HODrTWwoaMZhI8L~g(&n>}_wZegLmVc_L(Ut5yuz%+fa-I2^i<Z(%ev=t
z^p9U>CC0T4kn$e2uERVZxeoQw6VW}DG7HP@*~+1mM$Ja?JMZw~-R0ut0l*JZ%AJj-
zoWrB7tGx|s@aycvh8-fLygi0mHRaFVy!eT6mg4g)htF0tV`x^Qhufx}5jOmaBEuQ?
zC&oqxv7;A8(<dkTlb+}E>9nlGx+Dn1dPaOamrpM;;!hBzARK=_mk(d{M_e54T-1d=
zd(p|Aj-8WOkz^u4_c=(}8^mM~jtwkQHlm8`#2Q42xU($L)wB8ZH6u2IsF@8y1Q7?K
zYX7t50;1p1$ZMTcQVC&5@f}NA0mMm`^u`%;(ypcSS)(1UbY)gzC9>^IKCLkqNoRxT
z0;1X=i==pXl3mAm@QheT*&as{PKh(g^tuN9np0wyg2eVy(~vWwm+y?#SUjW{RipVN
z2L~hEb88UP6@EZWZ|XB*r|PHsV$Ol@!}~g$f$We{_P?EkVbQ&fni|f4`R3XNefn9k
zpMw0{TW0>xN{RVd4P(HWSNl$4UZ9bg*Y7PcpK^sUS0kmwJokdw)3snQRud5z`{nZq
zJpt+E1+fG9rx8x2UKHzAn<?Fl`XxIGf{(a2B7FQsoUND!3uxO#aTf_l#wn1*v>KIg
z1$r>93myhT=6BK4?Oh`CL18Y&$Mt-GH$*I_`+pZ}J9%H?)r9jwuIBHeU)YCVp!Zlt
zhOy)2SZ>>$IU)r_pf~h*%RDJlVcfx;f{#1x!_>6>A7ZF$L(IwtG8uk0fng^Rwa)xQ
zY^L1xkna8iFk4VOk@0g|H|6r4R57@(iU>V%((+HyFC)4?@Wt~prIHl`9~VptXRg#Z
ziPIC&>}V}pP+>rA>)ay(7#s(uz#Eri*Q!73KjtHycfwH{_^@z7RpwUDlG}?O;8q>c
z#nsq<pj7ffy0!CJe`j8mzDsSeB0n|CEyMYbEx2K7y6K+FpO85^y9u*;ZnGCsWP}S5
z%pAFQerMu5gO)V=Z`rpV+DGgN6#sY|OF~0y?MGv#bgYL=gfCnEvKUpfD_P!v%ifuN
zP#c}&6yEN&<hjD>>a!s@M0rUJbN@Y*=@Ik2GPd~iRcgG0m$1lN*%vF2OX4M$yD$*h
z+9RL0#<vk_{qL8>O}O&88=S}?Gh8b+@4`U8p)MzeyV5OJMMq`HEV}=y=tCM~q4?KT
zG1~U{&uwjJy=!8)ZRkc&L#~No<kS-bU2;tfcK<b4E#2+Jtv+-bqw4o~oD{kyHf_E#
zo*8F3=uEp+D4%(r4lqL24WATXV{RkLBagmt8f&*E7S>zDb#bQZ7*|)mdA*-yGOBi9
z9Z+~(463px6J4q^?%%*Nw`!s2S$7EwsD*Ea2e1MkgfWxzIKOeqjH+K8yyb;rO%e`b
zTp>ELBZw7+xNYPAD0>gMD39lV9C!dhK|nZqIhqv|R1_5iR1_2iTLc9KJ?y>52I@UT
z#7i(yR*i`oV@xrMu|;F-8cU2VCTi@l9AY<i<Ne;V`y6+G`F{R?U&--2`^?Vn&dkot
z&bGUqu`q@{9mWGu#s5Nk!Ah%NiIsODndYoy&KI>)UER=+ch^VFl&-oiE0^`Vrj4{p
zDPzA~)Ot#9spplnah1mQ%4LR&T9r?9D-uc^R<b}51c+zhW&Nn{ao<LhOIp9E{C4ET
z^AlYAnF(A%GO_xKe&Nv#2EL@IydG&6E~TT!u-TVTTCHSJTHwzh904Z+7(47Th$Id0
zTQPIVPF~VRB&_QuVmFX6+83{j+IPPVIubeyzh);i6gAOx!sco$J20q5_p02lZJ}fm
zE^EWB-d<s2FJq5U;R0eXNh5fHnE<S1-7lC&?}&gy5D`5`t&RP$Qt#deF%;|2Xm0^}
z_ri|x5M0OWy?O6GlUliV4{F2-X~LE@v4eT{o(Oc*u4w(^BC6LF{f@&MFb3u{i`HLK
z64#g#?eumS#ECq+l+OkDY*3BugPjRiuw<`S3+xBHq8(FLXR~sS2)QBr7W?Kd^-WbG
zuOdH-%eyNdjznD5`n1Fy@vy~hup(ky(@K3@|6!#*9(9tVfda#}j-XsN=c=~3w@K(|
z^Sj<-Ivr?u4qY8%ovRSRUeGw^B6t_w{?m)-o(nrEGT1g-k-<_78MzEjZT?Of{QhgB
z44&-rP8potL5S6<gVkm5`{6<cyL3=w@ZW9%SO%~`H3q_iGZ^q|lELEZS~ss35DIf^
zQQQaFaJ2n2w!){an%(~=s)p6Pzu2wo+N>JMs1_K=HlAs%YLbZlsfY_MiPOcZ+Hq+a
z+?`8{p$nv?@Vc^!zN{{m<o>PosrMS4i$tNz0U-*o{G||1N{U93K^26aL!|v%n-%;Z
z48S<8)a)ehG`;sx^ZTZl+Ahw^qYEMn0IY8Y$X8zH-_Q;W`!@Zlxc%f$bOPR$pxuxE
zjvUxbHTQ+&^Z{0GAk1cy@nJ3tOkU|4+w4QIXX`^udJYkr=_$03R21uj^dwy;2wVy+
z14_Z5Tjx0ISrD+MVA!p5?0O5~r~WsgxPv+kWV4&JYo0eZ5md64k4$poa*ZXU(LiE6
zh6iMugQ+%yYT{_IkDxUcIhW&t4$(<4DNE2Gj`cnw&iyoc!vQ%q+_!<^`a?hbvyBG6
zs{!*n&=)3g6{g5JyN4g^dP|E%^r2-ZeAwh$+TNBQvR`j${p)`0M@289eyS{D!Uk`$
zQe>^Np&qfm9ZrSwZEbJqgT}erhThgnR+1&2Mwj6rE)OT<Ob`kNz%XH0$-5dx?aOkl
zdgzayq`sf<2yIuK>#wtU`!hUr6tu^NO0ZcwmHMw%iB>8Lt4@k<e<|N6pi1{H(RmIq
z>(G!FuToE6#E}?OJ|4L&?5;Lk3iixpnRl@+{47$wy{ldAccs-W9JuvVXj5IN#StIm
zL;Ou&&|0!6`Fy%p-9T7^q@v|wOFJ$vbqAqw0)7&4VxkCx)P~jg<{r$`*?24!zNc+n
zYb6+>Oz5z^`#<%NW<?_`dSBbnXQ4OZKs{a<42h9&<MH1uTwW88v}@Q>n)0oi<7pCS
zRKZ!VerwA<x~~oP`8W{LfdC^^lj+(4PegT^=Cb4WwIKtrS$P7;!~;Bq9Z4y>T;{5-
zZ#>OuHgAjkZIX1_kdrjrG!b_$<*FcV?8QqwQz$Ye>BJUhTp=2Z)u|7(ZXQcCn25;4
zIMJY*36_#G7LFexlH}Ynm$3)hM!^@Ts2-d|LppL2o#ZbU$csCODtAI$>VdXFvyv8Q
zb0!1=D5$wZ^)YkG5h=xeQ9LZxkL)g-$|S{Q8w{16@DMip!VEU?p|+=VDGIcHsP&V6
z#={*v#C`@xlHyM*k(JXaoFtUq461J$qkKPJ7H+Tr74)}<3klXkCiOLEunv#3(N4uV
zW{LZ!v!X{@Zz&GKLf%2>(gsG>{F2EfP2XfIbvQ5dUW3XNzqAJX>LY~g2SO5hKi1|*
z1&wmq_Q%>E9eQ>{x5F-+37a<<*vu!|Ky<Y?-!|U1`ib^eOG(uVuFg~K);9m7=VEsE
z0pG|#?N?*JL-A6vg9{#*JXG255Us!S;YNt=gR+i%%fm#UT(<Fz)&s|{BPKc#=H<I*
z+A$rifUdkTGzAFK)dJV-QSZA4<xQJYw#1=5h5PAJVdKW1$8{+Q*MgN&!xjO6tH|u<
z+F97+uybx>_V;sb3kRLw#+i-L=b{?UZp=boV9j+MG&t*pc94{b5f*kg__8Z6wEjWQ
z>c&HsRK+bSwm8V)M8wz<q~KJUq+Ay8Qae}`hyFy=8L%GyJ0`bvu{LWOZ(H_K>t-eW
z0WshBTDx8P0RxaxZ?wUIF`v+s`$2L^<+KWd)Ggd-DBovL)m3p)bdo{<|N4zKGw2{m
zpSs+K=#Xr{MIUaQ4(ln|-k_Qc;&)&2zN=fQTC{%Xx77L`==m@*EC1EXX#1p@jakFD
z+Bmd5X9{oog=tFL_aXoHZ_###G_$q`f2HPa9~)88_NaQi?URv$fGCU{%icD)r;{%B
zc`aqrUFg65L2Tc)!3EaMFFZ7`<vZ5|U;v<4P;?Vdy@Yh)(1^8E$KL2hT!k-QDF<W2
z-H9?R&lDT(Hr8y+?vGhZ8}4k7$~WAtY>8ecHr(Z+C-Mz<D}t$-j-^exMUHG-*?${n
zhXRxhchUYN=hTJQ^dF~gv~4ncc^nP20)C1TH@DO8>p?x^xqjIis-6~~#O@}s<L=FE
z>;<JAcc0lPJMPw^(^lGXH#kw*arapuuh)7I3!}zPVWM8f9d~1FL6vvyxNG4{m9#@=
zeAkY<lZ}8)*>R`sOie@0D|Xy{F;TQ=epB-uci&@i5;aL)O-&kuZ&l4_v9*jHcd=(~
z=CT9Ua>rUwk0i{0eSxm7vXO^L>*3SQwvpS`QAwbc;RG%x^~4SrC+%|!)_veOk2<>8
zZ*Sz9_TPnKi15lr&a7?Q3=A8<_un0Bm&-J^vO3QqfD^_AoC0C?HK@$6(<q@liYwi<
zUU>Wn2Wmsoh!}Lm9N&I8hW8m&J!D10_{y&*s52*qaR*zS@q!kwnwW9duNziA5iOps
zBwAd-x2m*Iw&HdBJ6CMQJB&)aV=G=-B=OyBE1pw=vK24Ek2kLe7>?%o)UVt;S1YO~
zng>tLY%AVH590cIC?UQT?|s-FV?(-*MMI$NqF@3r%EGT=a_sayQiK|BxPn^ahEF7{
zB{k)^$m7~ua3o^;H>9q580H)=wL8-EvT9CXj>WEqFdNuE2+HEBJK8tS#@3Y8F3k~v
zBCWI>pNni74$Eb$YRZ8wuj*s$4MRk_6>1gkQd%9^+lgU&Kd6cGOyLr}(%|G#*(dpI
z&_D}57>-0gzl<(kQz#8E%b>c74vd-<4$ZaDH<<;Wt|wT@ohuHT5dwx(tRyL2IjE%<
z&o)(L6E7q1LWU}T)u6^fhd^K4f+W75;xEB?F>$rH#6e!^;tS2iN6)+gTN^{eI>--Q
zePAwjTfisSmCxz12_cWoj&eO|?{f{i>?k*rCcyD=t1ZX2(Aj*`M-0Wr!fMeqPP(XP
zyU5|_6*3fS{hn&@C~lXct9=V`()?j~6(7`=6Rom+*l)Gvwq7fpNR|-kGPyw!h+>51
zvdAYRU8NXA*xESBVN%yRn5c7->xT9+0BhlXy3I~LO<uivq6+)SKqY>U6sY?H?DG~U
zIoxjtDnJ+csgjKoV*ugTHynojH#o_iq*-`Kc9t9Ey|6{c8Ua4k3nA()gi656pK)9~
zy7*Lxhg}T+V4)(3R-N{TAqe7hGPnalLvG(w=-j5YgwUJ(plp3V+|*rOn{QX*JUs@j
z%X?;dbFO7~hIFPdlHU5Xtwq^a9GyM5L*J^A=3KBKSTrYCA{BrTK|6HYa{N7w@m8#h
z?3d?Vi|UDaZ(!3WwncwI_>Rwnlb^4jd&(9E!zn3CDCJR3Ib7H0`a;IdHRa`X+P>Ka
zh-f$FgH8~3By;e63V2_DW6LXq#-M78Uq#9=uO+O+RTo+9c>v)!>O$WjwaA9TtWMh;
zx8)#CTt}|wG84YAsV8|fP<m2Osi`N`eIj~N%2=PuJ?R{D2l(_dkeD_Iu_wGZ0Kfi+
z$>>QPEA^y{Fe9c;05{-j9XZ(jz6)`3C*R7kL$Gpdo7`<)u5yxP9**n$3OJ49#c*^B
zj2B}OJ9FB4Sl8V!_m!2?+;X%EgG3LWioxS(I2q8*S_4>$bOWNYV({n~<^|2C3>jDY
zQ3xo7qPQs(=S{&10i9!OE%IR5Q9j|+u@SSnIyQCuFq)1JQO-ouIp%#&!>NjsvmT~V
zA6yW!l4o&r`w>IY0F~@3&GsC~+N$Knd3uOuSr}>~A92!RPdyPS1hv9ZBJc*ujJ$w3
zDyxYvnBf;OAe;7U%o_dxxY6+2{VO&6ER|RkyO*b;;StcO)bPC`{TrlH!w2w*A7i_%
zd3AZaRqF4kCB0~Egt5u0<_L4rd1LbkNkyYoU6o`KKC{-Y-fC>^dmf^-($DY}m$}P9
zjqF^g3;AQreHfYOrZBYoj2}r#EFY1@uFoPO%xjAslJ0VdYP&Nk3_r~N;|*pPzp6dt
zSSjwlhGl!m&HP+={^<yT0hup<8I2ccXfhb39&(`P69hs@+Nt{#*_7c8(tZo!(lQU(
z&t;eL^&;w2WV0E`9-eYQj{+a_PN1ev4jkI`fP!sHnETd#LU*XwCI|=fF(xhmXm(G7
z#Sw4pCnR*W#E~gcwfHyK{_8mI;+}@h^OWljD8TAsT4U;%i-)dQWNQbEG)~1OHb1=4
zkm1$Eo<gs}1%iks<K+eduKM|7(S2~;9~sOul<+<!xK`><t07h_r_WYZ?JsJR_I<8@
z{1FI;>lnObwYnF_xr>jlVh8Y-jd(Gcvaw!ru%iqAFdZMre6947Q$l|9rpg3~jQjbE
ziZYtrK8efdz2!uoRQ_>03^8iim%psT3-?aPdduzI@7l-XlTc(kg3)kX`PV#`9r2bQ
zOZE=AY?qHb#-2e_Vus_bhPCjO+edZ5>n=~gnxfayND{lyej@7ONE;7x)4AOr+lqbV
z`YyLX5R*mCNAhi7xv{G*^y&TUAf(^t_>)o;K1Hu#_5I`^M_uS1@nIPLus(kBSJDu_
z+!B9zrqvi1mgg@gTi<}SD_PpwGr$?RX(UYAn`?f4EFrxi7yuJ31<2vjjlVUlS%4fT
z&2NyqZBl^jZ0Xw473Mq*U`n9;gm*4mqLzo`je4fBD9;lCz<fw54)LXwQDRdq<uIs{
zDWxBXJC&~nzYaxBu>}%rB+izIx{kfvxL22DPhQ<3{&AN(&))P7viq9MUTcVn@ePsI
zFuY<MlCwO<L#k(s{rQ1%)7k_7)mW6Nczv3<=d!DTvX{#lus`yza<~-spaP5*QKZx9
zI+ZE1$#PONVz!{kKgd%aj59b?!j39Zpg)iRQ-}fLI+4D~k_C2sAA7ja6|{d%9FkHb
z>|1#w#Wr#qII{ubB&&Fv2Ac2@)%4>r>B!gBgc(gEmT*G|%dys}1z@2SO*uHSc<cZr
zvpy9ad{Q3@j|@#J36|ZYQfugfV7YN%p0(&sCuGD*X%&}<wIw(B1q;1vI+q*R;9$9}
ztuC}~BA&kumb=;?#}EOhdb;J7gveo@SHX0I0C3wn$1Xpcgv&0Ex#qGCA#w}%&K!0D
zU<|4P{+o|qR@y+0Y_7Apb_j(RscEx5j-L9ptS?%*33HZF{VYXix(Yh%zy=eGgsqka
z)lryhRYN&S>g$rrx;B&_MSNumieo|zc^s!5B#E)yWXWL<Jk|gec7!67Ni{>f>k;(S
z=tgiVee7|5$(0$dY+EDQ*;VBTNr^xiiqwAZmdh?Ql6OZ2KO~<L-bj)ThniAN$RHS0
zwJvM$8|r{;l%Qn$8BIPKCI?7oE@{}^FgeKomIGN}?6t&-EcEK#)X^2-egF;&mxHBP
zJ1jwO24J-(Nf=gZ^A1-Jwh<-Uq5e450NNv|ne5L>!{xBV()$qfAklL~eLklYXOTi>
z;P6_cIMsrdBz3;kG6``<7aj=X9^oOVpTNd)XK8QkTsFF~tah}8j)BkzU~GY;PaDgP
zC8#F$YhyW5GBnC9X(9(i`sI;;(1uUbJ%k(4foLMs65nugFbIho1Mn*hR9X``GE!%g
zu$P!zA8QJU$;Zq3fXP%TUDS@(<ndy1nX`BkI2;~=x$P!$6A1)k#jn1~VTlnkYhs5U
zldMZ5E??TsxeNpZUysbvR!j0Ej9l&ojaMrYdTG1_A&HcOy+_ul%wTI829Uvf$s#W;
zs?UCil>11V?r4}pQ@NY#99uxgn^@%yii~P1_X$m_A=rr_gCoJ1v2zXD%rWj_SBIAR
zN*`DWu1do(k_c}mdrBvubHKyS^<L>s?4wc)Dm|rCV&5NV!n$Fl-nCp_k`QAWzwA49
zYFMc+d(})1k!nMH1Dnh0+CAZPKtf3MT!kE^HkX@9pCB@#Z4SP5f_FZxwd@;X&<}pU
zI_q9N7p&`yZ_w&?#Ja}#H8*{jp>>XuyMu>0KUMCi-H3;@x*+PpQ^CXR3LbWaE&4bL
z!>C)R%HAmS(xy=D#$IZ>L-214=U>`w@NY{c{>{9uVb@!Lf1m!VVPoEO^u*~Zxz;Sc
zrCh^xF}nNi`X=6lgA#pP%3A624Gp{2Qf}+|vjrfcO%T07m!{Ejuh8|D72NAWFlOBQ
z8}eb|p1b{RzQ5|=8x1=eEeA<M5%qr%4IVmL=CYctz{BXjO+2Ks5HqBdN<4Ifd7R!#
z_LfpHoLJIIPI5|tD&&fOMu=J;*NBaKUg}o6J9=Is)^C7?{*YIf)?nc&gNAi%4Hn93
z&O-lTUrwmbz-TBq@`L8#8xA<f*u<b3iC+@~2P^j&;Hrf)5Lhf=P-9bLeS`#Vfgd#9
zYp>?o1}@ulH70)G%v!dQ-CW|z1nK~e+8)A8$#uPvj5%`f0M0yqg&%4N4Z_gZR4U7E
zBS$v#xu1jZi-zAOP-8y4Y+d-!yOiYj@+Jw4Uu(QUd~WhL$9Vi<2inMW>tc_88s=?2
zy_Z8b7sR-s-gIIC4o%A9$0p(A0&;$ff9UIxXLuM#F`moT#M*0or!DjVF6=#}!P;qH
zKL>z{<k0nJP*0v6r*UH6IyUS&(MZ7=YURQmRHx7ZQ;bnfZcqgso$)6H!zJe(v}-eg
z4h#eYup2P6L!CVLSGrp-Mvl(2Mx~86JRIa$!WWiPGySIVx2Sx9dIrt`FuUOaSS#P~
zfc7s1dFVC=TRe9_E~3dn)G;lg2fyLL4=5;YA*I2)CXcPbf8OwrR1{|jWndW{u!etZ
zk7H_dSO<xmDZ!%^52(@MryMECuO>gJAZjj8bX<<z{4At)sybyVKBx5@j#FA}mi;X%
zl}Jgb6jd}$N!wV)D|H&q2nIw;P+%qgVc1D^$Zji#H;V&kk}i{uzmIx?jrEA!|B5ET
z_b9tg^bdcl=W_B<0m+bK2PCpRZRNm#Gc*{Vdmy_4bERoni;_6mBRTgPmygl6iMM9*
z(fc<pAA;Q-1<*GN5Cs!Bn<F@oGS<qDlfyz+@`~|Q3x3^s?V?5@2_mD$8){dVYG-*M
z)60Dz^crec<;rNba&$^~vnv)5SEb1-dEv3^kc1|0#cn1vc@_tV+9Y<;cfcQ39J?&Y
zAN>1YExvh$xA^|eDlI<yt67T=37|3ssG`NC97t*L)p)sKvpL|7Q9|D9#CvfnPx8yx
z(wko(XJ6E!tGxYN@Q1}F$f1qL;fcg^-z_c)`{8|~>gL_pq%bguD^8GoL)Cya-pl>_
zC=!LJdsIbTRC81q<ZXsOtoy~$UheH~zLUIZ`!f56e$1PNy?=D$jT&*YRZ0T(R$^^E
z(3RfIVJG%w2DSZ;e}PY&f;a>YAK<}(<stbb0y@?A{A<<Vfa6x4jEIQ17iWj^`ZZ-T
z-HVfdnOAuyilTdQ@_gX+R!qp7+Fo4|P5YZz#}!f7C5|Hke}p2cg)+<(Q2=#%QbcC>
zsH4Y0A1fVQC^@ICN%niMNoZ5zeV{CIa{(3Z)PxuoHIF1=4~+%ug=QoKeIUI?1VwRW
zLor)v3<{TQN^tXqcWDTH4Y$P*`uz!W-B06c=U+43d>_%bO~>hX@q;Q59K}f!z|4zP
z0NBcz!`*zzpoR8?=YT@sh@09-g`B*(#Lf3AeUspZ8$!eXtO|kPbqnwH|Kz|{dBX5w
z2)UiV)WQp4h)9$pYZqO5YoOTxX!Wabvd1LKF;c7B8n!+WA+7mvL60ZObz>jFT&5Jx
z#14x|G=YwJP%&?x45vP+C?-T-e<+#YI`F7qu|P>vT_M{%uD=K&UJBEQxIX5GL|nfw
zY`7^J`Oiy@i0ePkH$@|*10otZED9FEJg&b5)(oxs<1sZco^*pQwhXf(`j0wQi|cQP
zn~Z)f6mJ@?txqb%-cT%y$v$T=q?^f)2xm~RB!}ZY23Luw#Urb|fSnp4BCDP8hFDW4
z1kHJ5)e$^5wPo!Kr7b_?ncA{-pAuQMfK@ba%h1!jErpM$El()uu8Uoc0IR-T$7+$)
zk$0;Qn8Gt{oOssvMOJVAG7>M;9`p7-JoAqB@(|MIhg7z|K(L#?xZtINYK({GQuivM
zxj+t4^p;mOjK9pni=sS5Z0P}E3=$yw`HPA`%wtP@uIT4vK3CL@gZzjg6<YtcCiQ*Q
z_*>b=xuPcUQjK#(X)Mj1ZS5>~ue}BxgoaS?0mdKHFc-_U@zO`vG%US~9AfSHN@KwS
z!{@uQPrAtNQX8c2=_dQR9>cIAsR+YM{jh-~xji3g*u^gJaMLkLdEQ0#bMT}NtZH`%
z)x~amO!VYUhHryj@|xFfHh(#T7gKAB&FP$ftU8@5eLqnBd!<v)e#8KS7SI-Ts-IMp
z8sW6<c#522>GH`FDt~84eSF43gfmKur(M>tQQa^!k}z*{b?Xl*R&2S}O{#}vYH*!x
zL?!B}?+u{##v{P`pquO?wS&v;m@50ZTaijrh3z+Q5L)isBGFql{}M9e<{8|P;#s!E
zhjd{F3wC09s>%Uh;EyW)%++=C-L1}Rm|h;<#Ok$%jhmG2%F<?ca_H>_LXoQ;)1OMO
zD>@^*SaHqR>$!P$R!}Lr>CSrZaWzoU3DLCT7%O(B$BR+>+yiz9DH}ppLsdfK)60Gq
ze>2s?As;D(`eYX7iciMJ4Y#_eVV0ROt}HbnF5dYs`fAYI;w$cDF4wTQ?s9~!E_}K#
zf;p4A%ZXCMzclRU?s5<kzq@tEz;1SzdrIprXxQxHQEn`?2ciR$E-2JH&<};o=pjc)
z`4}y4=phGsxzV?|`(azJ=$)OxGoo@If-CDGH*<4FR1Q=A_%#U%i|8qPdi)OU4MoJq
zAGU_jEzkfUWjqTwGr_|OBfo?%d-+IvPioku?lA$OD_}3EnR$JwA;T~bspyyr5%q2>
z*oB^QfLqZ%48@#Gs8ux~C4v96@sUOz*RV#t<goW*VVDTpr3}LM3mG!iUi=!zOJ)q&
zG4lUpNc(eD7~-Ku3gI3L+!a;(+?M&A{-lBBUKV*W-9vhDO2Yzr%bs2~yaEqkZcXIj
zW|)mVFis`a_#J`u1LGP?gMT&?r|=Fxiy~&EQ}qW^Zl0;SIQ1P-gKcaQr}DV-2WL|n
z*rdphA$0U_=soYrZnZo(9!ubXCw6vlkkua=w)yPfLG+i4QrI7Z<K50up$2_}K2)eH
zOd{C@bsuPr1?Y75eEY>q!_I2htUj_&)AoNpHsAtE3PFMvm_2|2Pga<14=i9I<R%3Y
zPbi-*vBkwa-M{b;{B&0p-g(2l0GOJ<4wV2*2e7W0Rl)v(uTB#9UE(XmsM-&$7}X+-
z8+U{RZ9)WfDK~VfXx^pxx@AM?cu;s!x?ESXRF|{Q(`9wW=o@@&Oa)Fr^~*yLs}@O>
z8_@PV&{CJZN16&%)OUbtpi12BP`wiQhe7M4UaF8EVYNv-?0OR!A0upl5jB2I{3mz#
z?BGCY0>t*qKL!t!YU6>k!S~O>ac<kuQK)kEy$HdR>%<4v#DAK9@HTiJCb19o+=(7#
zLMz1T>Xx`Ddtl(r-_NeG)hbUH1!GRn4F+Qm(Eq;Jmi6<QR^MvePeNw($26=-KiRXv
z(;igtm22j8=E!>{6$Rwy*;!1g1IK^JVw}S8O^jc3jbqfr^U&McJ(I4{@{#hts?@5w
z+)m3Cax2wDPr1}juICWVOAVq@i<$aJ&j1OXnEkk{XJcs{w0VWD^`8$-P6Ym;J5_Tz
zw2Y~=!NrTShxpb}pRO#O&gG(saS-3^{5Ws_ATI0A^-Vbr@-xkGu=ob){?4;DY3RZx
zA<eD+(Xeh=Shq0dgoaJcLhvda4?D6DYmU33VGpz9CJ_foMrZGzXDy^;7N&Qpp0;UJ
z&xe<ZN_X&EQ4$+4D6VzOew0fW`(;nEzVD%4d@7&Lrb;SmlT_3bQyb9$Ax!g9X<xZw
zjP~@G8(TFlWDonxjie(W6(q==9Z+{y)j*%St^aKvOB*2jB~0O}(4haN8&zW?3|fT<
z+=%5Dtl%Vlau;+zIdhx4egl6|^Ov%72+?(l3+?beQV~(g|EW2eWi>Gs4UNDPx`RQL
zg>U7tSU>~hfGH2=K`;efJblFRNS+9qdt}Q2HEnrC9>T0K^}=NLzLU43JVF!o0uQtI
zQ!Vgbp~e1K&#{`mAlQy1!uctXP+91c@fbQ0jh1w!X3oI}h*4>_+)8>4xxSk%M>+ZM
zPd4}@x=QhH>23}XUXy`O%aOw{5i)uMCeY^O$YY$I9HpM5M5gxRD$xO7N7(Z;+7!Wi
zSDg~PQ-8hHh0pWC>a*;Da*)?Rq|;6w!7rnwxN-3w`>9E4fYk6PSk|$~l|5{d>g;6A
zkv!M;0unNk8$wgbijO!8gFUHt3{Jg1q8RMUy<>bF+i;Z!Lp;AT46*HdF)gg)p{`hV
z)6^L0N2sDzp>e()mL3*zQ<iKt1Fcj9XKAfb=pOVBXSm@0@o)Ky;JzJ{C+GeWr2ZH8
zXW$!gzZdLcHSQ0fkKj~G$k7Xp9N-m-x?pMvuoeA4VMj!+?BTJd9K{#47wdN@YKd6<
z%Uv4QKUWTRI71(e&QYLiKhG{3U?+(C1{`!j^KerzN+f|W#yuV3xv05t$;eCck()&2
zr&bwF64M^$A~HK3ojG){92U_2ih%#S6Tu&cbv3Uq7IO^-^kcZ6YY2Kj`ZZx6#G$)Z
zgMK(zZtk$>AeS`?J|Nyh!Y2}x4*hWNa1Ut>+8X~b&RfccuRq(Rt(%mLhs%8@`brJ)
z@NeIVP3v^+NU>tY%pp*V@nb^2iEeF993a|F@FY8U1ORGo2MwxiNT<rxKt5&AZwPI@
z)4WA2Z73>eY9W~@&#tW`AK?CVDBSLU_M?#2v7S-q;X!k&I1j!ck=*%rPV!w8CO1uT
z{{S#5(<)KS;UAAnm3jk5z%MaAQcFB^f7`~hzAvDv%#Pdhj0Sy12Q!()U}&tb6~>me
zhhtJ}`2!8>H(YM%Kk$Jl<cs#iqXn>Xm0D0bTy7xMLavL$5#+yxfnDTpajp(0_ljI<
z<YMX(a*%c1&2hM?2v5=s0F4-dGMeCl`cS5`0-fEi!rQ~qSs0<3^ihSTN?9$WuR@0z
zRIQLibO=Ot%qt>nZK@*1UAv<^yyQ=bZ54iUH;9rF0*`OrHA+g|BWmIhu}7fFPe8r*
zjKmDyv)#D6V5Hp0O^qZt;c%f%*jaI}Z|XViMjqV+PpZO&)AtN4ZC8|sGz9ss{v6fM
z3V*rZfmBa->PmC>W9`rtea3ZcAL)xrabV+S?TYH5#y3)N2ji%m4KPQha)d5b-|FOH
z1x1_DJ2hOY4Iw^1TK2If!^N&OPExu436GXA*8>J)h&sPCJu;Zm=T1+un26i*+9y%h
z;G?6W=@=FEMCYFX$Jp&cTqDWvQw{rK3|RAGr-r3&Opmw1--R2~-R<uskm+0jp(@>&
z?$Z~7O?5pQODoSXXV^0x7_&hEY@o$Av=Ix0u#4;-P9Ou^7l4ECR0--N^nspCDtw)y
z%LDNM&}<!=;__XbYa`8<qAAONyN7Pbw~k`Q6q`GZ%K{b8^TtnDKG8R|uES413C7hz
zNo;RPoO|daNCnlQ)g!9IbN#g#s>3nZBJ3E$ub}D5`!S8JAAb+oJbgbVRPqD9SNCI@
zOSg7Fk{`s>_xNcCM_e`;3u#OY!GiRs3kF*Oi1XHGxhCEXCYIXTx($^Ra+FGlXJb}R
z_OsfqVIQuZ+>HK`yu0Lb(C7Lst%*^j7o9(w-9T!D?=hdv_Lgen;rs--Yv`^YiI!rd
zYAT$<F-B9Tou+u0E?)@uYu*nU_R&PyGjwq)sz)BolX*@QR$-iuft%}Y$A$Lnw~Y6x
z{GZ(57FbPmHg!8V{`f}ZtH;r~09~;mv>_5rSQUh3<Goj1Scge+eYca*REHhEm_xIN
zHDkxApKLWZ`ig(i0$b9{QxQM<1%0k&Ovi8?ps4UmEeX#r2&5=-UA@R1otbtriY(@!
z(<tUr5h7xHMvZSMz1o5S)~NB`(j`2M@#@vldC?Y-w`kKzbcmEz&n9}X$ecu1X&gRt
ztI!t@*Kkgp)D92vC50YR+IkJ!J$ihiq-GjcW6bz&J|{{<4X;E|4UfPIRCpuo<h1@#
zUYqe9ekLtyZI5o@jGNC9W!hM(VJ8!du%dR{WDm(<nTF-Wjq+qyH^e!39EVR#kR-ef
zE`lOzoIi9xQ!-?hhtIa9qPPdmsW`F|rs5u2jSUFQrOa^biaMdcOi?El#pC}z^$~T6
z=x4Y}gUyHc6XL9FHZjX1>1yedwHh{dNK8od&L4;r?Vb6Uk1RSBk2%h@R2~MG&8WO9
z2nv{}DkL}lNldO30HNa@p-pDjc-2Oc$D8M|MjjGamftDAvow68h8^#eA0oBK!{t0M
zqb?p?lJdPJdptBw%J-AXK$~t!`D*D99>(FpX?3Z_qUfiqV3R@BX^DodOv?ALzJ$iJ
z6<*WaCD%1z*qF&GsS7gPP0IJNT8FS{a=sh$OU`#yhe1K66m2?(?8Jq5NH;x$5%Jha
zAV9;UtMKmglJgr%ZN3!P945f2CLVlp*<fHUQ%gO)$<0@C(+B-2!JPcvoH^bdm4L|T
z2qIQG%mTKr;1`BI-fgU#0~~6T8=U<%#?uPoboEq>yLvM|nP0|i)QohYu>MK{ChM#;
z?otVYQp0A!B}zuV&u7VjPNB$0{bN!Sz5<x-wbH1<z2JO9S7K;0!BfBBFQNT900K)B
zU}MY~2)2wpk?s@pJ#Q(6=5RA~2l%YSv7YhI4q5VH==^cH%&&c%cY|<<0~EGF_2vZ6
zfx+nIL!B@fJ!g)U6k2hf+*f)9;@-=XgWSG{O~8_?+BnJx0aIs#>LNm8!TEB6ln;=F
z<4RoF3EQ>y!;ceRiry2l*9+EwWbeyxxMElU<e7|H8_4f+BoMxXF%lrSLJ+yoV(iPo
zRdulbbUGa^Oi@E+Cl~&KS(>lbQ5<+ih|>-%tG3X8aqDk(FJJZuTnV>;hJrXG0rx*W
z(+@olj=I6$LVXRY)(hdM&X$9tH^c2GhA)T7rW)M{BVzsrlVjfOcnd`Xf@x)Y<7!y!
zXU@|{dE|Bdj`Ka<B0taCYLexC1R!-pVbsW`>>Et2(^3ow2ECuJ@_xkp9eN`WV^>VH
zq#FiC3@(n`Qz<e564XFnx2uq`BpsB1E>HE@o*cp-4}d&RL+E8VlOohbGxtSU*R*G%
zO;S;JyZx2Wfr|oxD)z9FziNS1->c^5?|E8c584ZaRRP2eqkq(h#TkD!uuWUMe^uqZ
zqkZM?TWu@97yO^^dCoS2t01U~uw#`1>sCc*Rk^@Jbt=E#va9_5mHB%f&K<O^QovVL
z3g~E_0r1bNe0Q(%{Z^IlgKer*!0fyK3m|M!1;B)m#qZ9n-)zxN(-ie#-dV!GIYLQ(
zgB$TF>gjkxNBW$9a|~~f+4Ne6M}+1%;EATFeeoUgISGyx9F})aQF9T*MjKs}{aT1U
z_6uXq(Y46D7Zn?)atom*Fj+lnYsEb7*{`S%JF<o}r%ek=D1So2kJk9Z=N<<_u2Hu6
zL@srz!pAU%b})v}Dwv~fj`5(W*HZjq#H#U<2TqF}>$QA=6F&%uW(IJ#7@ZqX`l5eB
zD=o~*$W=|EaPl{H#dIy2<y^kC!tVaBPQ*@jiuIEE%>j;1v1*rMSVz+YUqg6$eo3(&
zQqo)vYnc?QwvU1?7M3+_p6rpb7#bUUXGnQD?<hr6`CjD*b0`&SC=4oV;M+|flr@pd
z$z?>39t@v~XF#iYo}cEhi&xScJ8pt&ol=N(w>D*)bJ+cPa;Vf`5uDvi-+Fc*T=8xB
zW+HrhyK=SAj{2V0pc?%Qsv<Zv<nmL6^lgzyPj>p>uL#vRBa~F*U;r6Z*_&Zf3lZAR
z!dPWlq1>>}VVG3&m1o)8O0K2%bQ}R!T~uiys?=gW28lO57FEg$toYWcYL!OAFjJK}
z!sn@|QU(%5l|I4~Y3r6DRHZ-wVG}xjP29)X1@q<5h94k)Qg)1s(d&u0<L@c9Ov12M
z+AfcQjptSjt&3#efXIA8)de7x*1wT63BnIxIe(|eIKEv)ZNh$U8#lDc;nKIhY<H1t
zYdd8jnH+ZNO@^B@kp55sc6d_`TT$n0zYwI*&Yy##6+xG%6%X`BgQyjo!ENqMMJ$lL
zUE4uc#DY~j)E;+%f#6vS<Y-63N+UtP->4Km>w3Da?bKpkxYLADs>m%BFoQNKyhf=w
z*Ok~A55JQFoccg2^)&o1^aW>~?C;tiCfB^oXPXeT(4kD93Vdbj&B~M(eIz&;duoNT
zQY+Rg1>)F!<rpCc6i8F)y|}+((7#br!M7kUm@dVyD10<bsd?eH#=;v_;I3TwmmeyH
zU;F(3D177vQMd+wNn#v$;m^Qe#FX*N#zu7awVHuZTtxQ_N!DrDorvz=OJ^5AtRuS*
zk)-(=w)d}Pu85_9c&K(E=E|COceg)YXza{;isepL$DcC$g>r=F-yhPbb|N$!j+}&v
z#!^OXbNCJcn}vv`bVhHSxlqn%CV$)-8V|jkcIT<d0r~wYRrHE}T_f6hy|4UB1hv0j
z7H6@m3HYyn*07Y>e=Ilj&4F8k?Tlsp;Q#^R+m|uo%prX#AW}b;<6Uex#1(ySU*iaL
z<;QZ6)v>26q<Qy7?%_JB-~?#Rp3uVFW9#vahS_`~2M@i1BRa?%qb)+UY2hDgCQd*0
zT1fTftAlz$IgD5VNP5*LH00GS8zSn{da1F-^BRZ`-Nc7sFN_r()1Z_+Y~Ec}tCNo@
zmQnhN+}A-D?wo{^V2Z*srf8V^B6+swJ(*Zbr&ggJyt-h)IT=%{i{u6#A<&1(h5U5&
zcv_o;W$2D+VOWd0NNz2SIHX}=i{-A;pi4Py#$q|cbsN;pZklmZ_EM&TEBeKVspd`s
zP0{3d;VLR&zqqe7OkE<^3y2zzUdvC1Na8~%zLh`8pn3{Th)YdaZN0{w<(-YU$@{4Q
z+UCc%#K>MD*(rtVLh`{p=!t#naA6_#YRu!Wv0G;nH8+c|v^RCyXULexGtvR}235va
zG#xZ?Du4MEnxTA@*jry4hrNUFSTSFlQu{z60V=-b)t=OYKEhZ(Mz=0cRIE$3{>*8T
ze&Dqdcmw&%B*Ng1b43LPS~if63hL!mHk{e<`l7Q!C_nL_E;|!&h!Nvg8LIbAD!fVK
znS|a6y>Nj$+r3Ek^3Xt8R^>`D_9bwxe22IM=Ss6{3Rj*(x0rL~qpuaNtO41pb0u%J
z!j(y5sPeSlzA{&$FxsummDh9sgDY0wR^rODX;rwg1EG*gTv-YUs^E$PR9AJbbc0SI
zuGHmGE;<dtj4Ms)qlqi7Cl#)=6L<wzwh$1waubQ1feKd+es1K-F>sSq#Thr^%Flp9
zkQ%>6u9#Rd`|c783_<7y6f6}X0VoA|ICrc=_(EKgR45_Gb65;NWSKnH`{zAG_K|Q&
zeuXTcn54q{DTQVFa9j3hnXHoDTZMSQ%dR0_siRO&%olf1c4UZ&J{OGB{q<u#Sk|X<
z&DJ`bCu@nubgYan_Rdry@WhY^eyrBUC1kKfc*vmo1f~(B?T-SXFTY1L?NixXlkh9t
zfEG9a<O`}bpQvg~Nn$?`xhYP+aav%zt3V(Yo^7PTBTUXUL1BGa9ir43fM6~Hza~Ec
zbHiMhY(|HvDz#U!*Mdv!YdASvYJ-isq|@@sQhNnr$#uz7P^G%mp7>mm+JnQ1xz(js
zhPkgSwO#W5Luz}hsU)=>Cs&c$nh0A}lG-xZ#|o*<qzR>Jy5#e3kP4}t3|m`Gm&~D$
zCaE2Sl}lWGd@S$^skI@zklHALp+c9amKmkiM{r6X>`c6H1e`%t1HX#YR&nNCLfsJB
zHt`8Q%F02p4JxkAJvk`WKd<#{j2i|y%uljBWw@3!cMr@2R_*DcM(Ow>-xKr57rC~B
zR)rc=+eeEPz8qq-fN)%uV^J2sCro+rLXq48$&|4U&zLVVn$TbSfTJ(YTPeV3eK3y9
ztP1w;0uDA`fuc=X*hf+o%1RU&qSV!uL)ESdwN~JIyCTP;e1fs1d1&fJe88qaQ{}!D
zkiC^s?K!^PkV>rgH$m+bP#ZoFEpX&eORGXn6HtW;6ebDLf(aao#z;|kCl&F~X{!^K
z;>}$MZWOs4CC7yx2Q~jF30q-lWVQ#&+BlQT_WYIVW4$yFarrBMrTVH9x?wd4H}6Gl
zlPC<NQ(1HSi1TR;s!gjFKgw`d{}uGIDv-(qG*bYr=~@j_dlOKnRV>Fc!(07Rvqx1?
zX=hL$;^jFiP&r?aULmKWqE>xOP-j*OT=lA#IK%|CRDqhg_;yuXho)DQI6#5glv1ts
zznh>!6{w~AiQ<*&^{ol2e1)i2Ty<QBO;8&JRGv+BsB9C|6za)*%#DSM*a}h@LtX2y
zLN3&uKQoCwAEA$fV#`1zDqj%^9uQL@Lzn}$au^5lp+`q*5K|DS8oJ{XcBcd=xQsxm
zx*S)fzMuVGyj#q<S{&Z8D!hIemu_9uCIFbq>W;E1hVo2(JvF?UVL7S|x0^Oo?3qa|
ziTxEx*jez$JbDZNoC8Fi0U{Vh4gQpjNeK*?0RIfM_^-Vb%y|tCt;pdhY^D(k^UW03
zhMJS6dLR#`QT4RM7{}9fqW4KaBI0`D{Zf_pM9{$e`}d#a^r@7f`n)p0%qs6UjqlZ`
zTkiN^MW1eZw0`eFgJGAR%`WZlmNw=CVSy?AQ>4?>^=ih`cIm-$)6{h$AYmW$i|v&0
zNA(h>`H0m^&NTsxqTsMDnT6O%IxnlwtpZb7Rur~HS>8%n>6Oab2}ml-0cDxXOZ6h}
zc#9&fry&c=`S5FZ>uh?WHKHvO@x*VdGPR<qf_Y92nt-p4Z@702WL_}Jz5NS}QQ({G
zN~%<|>wM&b6;l6^-y8WkkzMv-3gW8&7w%~*1R|bVzE?E+%wmB&z7q0D3i5-t|4HI+
zy+nI$TLV@hthE}?yu~eScxol2kF|o9?SS-MEpDh_bld?zVjAwlLe=-&Np;U-NFx7?
zq~q_eMAeTi5>=-Wmx->Ulu~}SG3OY9c~t|>h!>+D-2aq|G2+YO{XNkSD&BYT_q>3L
zgu0?*RJ?y!<^5Te_x_?ERKOpqc*hyMxE^|<&BUuQP$PdHPSW*>j@&c*rNMy8ICa=(
z7VysFQ9WaZ=GXpbhDz`quK)jouU?_v)oN6!fCK-#1sonEHnw3QvakWR8Ld2wX4~vz
zcjL$U6(5W8(hQ+n!CNu=K>fvtD*Fmh<$ovp`KIE61ui&s_drDI&V6BA)ZM~eS<QH8
zwuYVhPWBkOZnh98Wu-S3Gbk&)aTpLj(J9p=ZE5<Sb_;3SzwlksmJ3+Y4_mCvI*PGk
z#g|dBv~^hSpQox}VP2mxDn(fs@)c#_e-lqsrcxnVCo7hoW7B=UhFvL3RfYTj7%I&Q
zrM;^M-Eo7?Al1`)s=!u7=L}Tx|6uv<{L3gm>71DQO8&|^r;d_;;D6-rjQol|Z*?wD
z(5tfU-iK6bL7o4=@XECYyW;<aN6b7Wdu6>eUdg`C;@u7S))f^HN<Jc5!BAPD2PqiF
za|}jK^|}a7Ex4bm9!3FD;|!|tt1rHygYJo?o;fLU?(~Yy0(DRxNr^#~G?}!ZnZ8pN
znULAR=s2ZldYW0j3v~ql-G_6lWR}gK>N5)q1~$lH9qQwoa-k8Gun|EdGE^BK3c{Kf
zhI`^>3c_|VtT!`MIGp8Ks<-Ptgc8le&3!RBd1-?j5ctpq^h&E#ybMIpi+_9!uLZHE
z4Mo_tVn0g5-abq9i%q~svu4b%o;^UR$C$V4F$l}hnR`fMU!?lEUYUows8OUc=P;!h
zJ48z55I;LYR=H81&ER#JyfBAZZj?Ry1jFItBl>c0>M9t2FT|M7tU^CHSHsZ>I7s5y
zzf_^w3ush09ls`Pt`NzJD&}db*fPYPIgug=X=NfEoX#s|Yfhx(5ekuJ<D*%fjyhG#
zJ^&C@rwwnYPD^PP%c$sB+7Gfvr%<>p=CSIZ!E>4)h(WVc3Zu=i_ap4_sI|!gKAgrY
zx3@5dt^YyxPM-*GS5VEDD>aJIJ8!E*H_Pf+N`Qsxc<VLQ@#K7>+fn?Q=vMMHRqdJr
zH^!WuHxS_Nxk(Q8n_RmZD{6^~#ekhFpQidsx?zH12?yV=M6ue{v#tgN)#k}7s?8<H
zv#B1i?JVt4s$W)IAF5;qJP-3ptw&%s(XK0RJVL$3nJq*(k-?0Xd5)-ZWqsv_a?u+u
zeVD`MZ<c-fF}T`QY3W*-mLb)#Y@aG>Z_jK01cHX0Q~0gihWy8=zIpG_w-K;&yAPX0
zQBs=Fg-iXd9rTG0ih=-c)__kO(16PBP<<4Q23-4)cW1N1v4nULCM=g6Vr*5Sv127K
zt0W+;t7ASfMKmhlC9%YwH%h`Uu_OLrs;Uc{i&i+BTG0e@PK;<LggB)z+s>@+M{1$&
zNq{y9a(|S7y6-N^VewnB9rWs84I8jkcF&tq9o9jqP38-#O-J+};V6h@3$-aE$6XMi
z+vna@Cm~*`Q(c`zqcY5<Y^NDvNSHzOF~VEQsc2Da#__@E?oVh47wddJ0`*A=VK-i;
zy4L)3GXJ*q6DX%wscwDypzRpKsl~>QO02C?Xj=6`t;`Bli9(x*Li5i>uq!W9J!{qy
z<#jZc_X`be{y&wsXJWNRj)&WCY@|GvH)I7VGhOV%Kb7*P^IF=#5b*Zpwfyh$s)W`;
z7a>+`A^<JTs63B8@qc{pRpmPt4QgY|QNkS3q#XKySj~c!pii)<hLVapgS9v@{c=CU
zHIr7|vqyHz`;ODWW;Pm1<7WqOocAKT-pcTP0swY+D9NGYpdBhOR9Rb)#c}XG;`^S(
zKq?&ja^$qOz#0e=ek6I~*!QjEeDd7yXd(&qk+C(q#SU6QmY^t(jt9avr&VxH5_V$O
zhQ%)W;i2j%B0GA`aUd(V*-hy<brmyo5MZp6?@m-Whj=$c0ZR`u`DGB53M$zr2V2h^
ztVF{CUpB861q$@0Lp*tOYQ#JZ)9l09V&64?#X299)$OLv6tSfUQ=F=!PX+udArwhi
zWMH#vJg7$}bzmL<=eM9jNruqby)m8HXt7&h)9U4RG?n}12UyK^K=ulJ(X3ka#(Gs0
zH{1yJ`HX52uX`r22qT!bI<~1MuxABIp`ELPG0%!Z5d&bZ2jq~bo70Vj7G9+gnI{_k
zsHv#0+C-j@OeG95mat6$GmG~5no4M31e;kMth)*90p=w+k=j=Wo9a<f-z@<1J_sHj
zoOYY@Fz|GwsH7PW517z)Frr<efSFaYo(XMDfE_$2hgkOn7+aOl-L>S9Y+rk=3F1er
zb@4caS?D(ruUPv-a#)iO+$(C;12&CBf+Qt$3?#+Bilm(Hu1L!Kh-xD6p$X3$EOsFx
zXws^KMVr9(!T9jvD)j}kIOFG|xz-!LKqvzWWApC1v71>ijivn}Hy<_?Nm#g(hBbug
zDGlBx?Y)nK95Aaz)BQV}yuumov(oW>D87%a`hB_hJ~mm$CxvNt%1+N_zM{>UOQ=jr
zAkStl(%9Yst2~(XVH^=1fgm_d!R6myZ!oJh8^voqtw_|G0_MEdtGb%i8f%uo!aknH
zXsKEL5hDK%B|lAE@ccRE`C+cu>ciNXHFYEgo`<o0EePuu9FNE$dE|j7|3U}xKnuap
zPUoZIUr0eMquDL2@*0WAJm!d%<&w+3`dbN21B9<}aMri@8dLVFCH=_hz+?~*VUdwO
zd#RXo^t?wF94jW^n1n&SnHV^@IIoHt{<)Coz}4_|iAPj-j35G$8n#0n&D3xZW&<G*
z)mC^t%#X8~L~-O0RD6f8LXgmY;5q2VL(+Be1!3ff`8k0o?V6(FaAL)_E<|-x1xc+(
zxTZztHJ?wm6pl6mzk1XN=lWdBMOAfvZSRq_h}y^#9X}h6GHGrk;YU)ODTROXV~A`M
zdi74|J>0ryicWO|O-$&4bBG-9QjBZ~J@C+M7Nw>Q$DVbY@kpd)ba{Y;Va#8s@xn^u
zs)zmv_ou`yExg$S4OK-1shc1(to|D$p{_psEqpYQRTs6lKh@lE;#~}mv)$5y{4pQ}
z3I8)lz2}&mQY#6ua>TilyJCx;$FK5yr%gkJBujVJW5WUt9{g2K3+;u(!GledODSr$
z>m<a=<oq=qiUqXC<+;+jAsY7Gae1a^*bsqehMojuFdRP7CKmsjoLK9`U@ABCWM`CH
z{F^*eqO$U@fA1YKh?>S%!uYkcpa6f=9+|hV%Mjka1hS3(s%~D%QQ5qKRn80oA~6Le
z4sbaKo?#Y>4se-C^H#<KTuvsD@2dqHv4pwwgzV<4|BZNU(~pXAO57{Vq9JrC0E<~#
zZa;OS6k3Z%>*b+NtkDtSw&>@bd~GP)JNKG2_od}T_o5jg)>!hKg7rhz8)CigY7l0i
zL8^&R=aE#7NhO@CnY6R|=WmcCkff#vhyB6L^>jmnNNlYnUO=LW9qj5!_)9}T7|4Bs
z7OjNXSExvR2ktM4&e2=|y_qY3XcCfZl>HpY<UbiF@dh<OKNXXBX~RGmvq?PXP9_TC
zC<@%QCntJs&jk>SZFJHvxE?u&(Cch$h-Ifv$v&3-*}YRZ;w>~m!)l(Ew_0Ygy{F|R
z(&}^#%RGbSgFnV$iP@Yn9@3#4EEYc_PqvzLo!S2`tJ^mlLe^Xx@&dD~bX!z3m68tR
z-;NMwJ{z*XID%NXDC8l4QUH{`8^LDO=Qr$0$LMwB?{Y_JT3Zd<^1B@7FahF&m<jrx
z-j(?$WVkcwtXxNm%hoW@vvQETH;ET?`tWO&XnoQ%$B&HyK+hoqMO!1Nt<eKTTQ@6-
z@syYp$`jX#T4QP7@V;*iU3J@NZ)jKDT2Hu#DY|tbD_u~@BEPP&ILPm;{G(+C`}7a_
z1L;C9^r=6wG0n2ShQ0TvJiAlWkh_MtJ2|}7r0GP4cp?L-li`B|89)+#Gog`EHrEuw
zSwO>rL`TA)9{kVA9@0m-8Ww#HTd%jY*05>kaE9buJghq>hji0s8cCCcJ^B?pcC+9O
z;95QqSKoR$)W0rv`V87Dwg#OWw|U1Z%TuU1dM^N!H%15tM#=xYtd`s}!P@gUSoaYu
z3DGs-(s~0<`#CSGtY1KNvBL8>sI*&8tgkySd-**cCMI0#LjnBTko)XodvWELG|Y=V
zKQA|^yI`CELGwG{m{t%%4MJ?q6@;jd#(JH>0n{BY$PJ~74tLpv3v#rT<v4coFWD`j
zkqN9r2u`&lqQTX9AW%j_U08@xH(HZZgjH@NP--qv*i|-A!>s<2dt|1M6&bLrjc$83
zugFYIMMXN`lTt#BB^Z_BnM&x<fVZo+^o|ldP(tZnvcJ{kF}%W(o#r;X{g)gNaH&4e
zwc=g5zCgDLy(qWwO34(m=}BU!rd0%JU1ub+_b<vmzCB3{*OM3~>(&b~#7Xs#!MqkI
z_M*Jbs>fUQVVjJ3{_e1>#PuZz4bU33li>c22<*c!s2WA#c-V+#9#*aTu&yx~Q>;$C
zWrt!i0vfE%q?T(#&MAErhn?^S+xX`QlEi~I_H`kMwPQ0ptWNZ2^<p!Ut?o8s<6|?z
zt#0;at70>nT5asj&c<d0doI9$j|Ar8ALbpAR&4J?R}62P;p(+K{T<C+hD6rjDw>;0
z&0Qm!`@LxHMBdyJO>u(3RWvvCEo&Q>@kPy)&KisOdFw(R)?}k1mU&vu>B+3)Gg?cZ
zZ@SA8;xhu;g=L7g9j@B8)mf&teHbM4&>jGh*hHK3P_KUMi+D74Tm-uppAl*`z6Wzl
zKx5nXU`YuX!78sFqOrryps^JOD(!FCD{ojlH-|GK;V^(B)DAIvHPFTvZ)|uWPtH!P
zmN)!?6~|c!=}ZIfcaa)2s5<8YH*J@(A;#k#7H1p#oo%rpBYrp@|M`hOX5;a^cud3N
zF7X)e<eXu%T0BP}d7gMw<8hRDbjD*3{)lQs+5Juw*cn1J=as|~pEQ!BsE(b$s)~9V
zRL@eO7j8g79BYih><w9i%apJq^=*>Mc_QTi;}4u7Uj#dtPS)?{?PUiwKmvswu2}cL
zT|k|U6B3!!pj$}7&2YH?y04Om^vZo-a~f$ZVyq_3pgYU*Q6cUN{|hygtlLUdq>2_p
zq*IDQ*M@7@&<5QGWsd888-DJ@kg+LP{Fa_lIFiPX;pLqBBSX}5)haZM-?t%P2A1bz
z4V#8+QYODJ@+W`ZMYCJdst#PYK{DXEn_>)b`1)vAy@uT)J?;5dmE#!lZuoi2!y)Jp
z>-@O1$Yv6fjVB2%Xip>ypO;KYeu1Y5x!=CglrQQ@H~Qu{5{c|aTv}+oPCbNw`FbSx
zFK3Jc4J&Wc;E^>^$^;-WmU6KjFXdbkFJ;_GUP>KNN_$btP9%y_Sa(rM7g5TuWB;R+
zhqvME1z@-WXHOjoXD?naf0<%(T@Y<5!gipF{hJhhQq~WBhawc$<1js%xgKdvOs)ru
zD8tFG#~MI*%H#%ND;kiLsg?w0gD=?Wh3npa&!NG|SBMXpA9UMxfQD@^lhdSNWOcZM
z^AP^6Pgd{CkaUO$JF#hiC+m4f4pQ}rd16SOdq@pQ#KtjPl%hY_`U#tlPa$co$?z#=
zPY+4bceB3%)ptdI>lk^xC;MW)a8J#I=3y^75LLwxV-ko7pZnf$VxV8!M9xQ-IL^oS
zx<HQAwG#Z=J0O7!`v=3o$AtIzA*LVw8iV6Rl~Yc=0h-nmVR7PcwE+b0FTChzv!b_j
z<wbWDMbE+)h*0;oyy%k7#-dY@Kt=yD)Kv6|V`fG71t=BWjoAL~qOT6ka7)qf;%qXg
zIJl%<WQOSMz^Pyo)}M)?V0{7PrT`fOda9lr$V>-1<#=_JFmAxf><$p=`o{PfJcM94
z5Y$_RxtoM?h}ba7g5vjjP-oWAl5xMDg{>{v2H=vGr{Q?3d$O<Bq_IQ?jO@WV?0kpC
zQx-0<G%B+v)aE<N)MuHOIiYHqv1Vnio@XrcF0|b-ryO6egG#p-Wj;U;F_w9CLTuw^
zTR{zD$J|23O&1;vK|uF!9mRKPP2wz!%H!W0=a8vOm>3(HmyIXlojbl`cxk}+u3GmO
zqn?V6)`8=QipC%L2!=k7lXPy!jRDb69oWD%hJY_Tn*Z3+Y3pe?e?cN&9sJQ!K5X}L
z^XUz}%b6V78yQU<8^bb|HaVkS?|TW<L2X)K831W<HJ*dC!Y8Uv{E9$=i;@scJdH<!
zdNm=1L(LEI!EOaCi5e!B%&Bo?U_bWj<P2}C4-=UlMY!Z9q6l=tEr-Z%U@ZsRGbO_}
zygo`6LZY+LejyO5O$fhsBaN3rTT2W2;=H?%FFmCv9WV^pv^3c3IL1eW(hn#rH%d*Y
z=f#^)-&j=*wVes|tqcWqPb2DZ1@+8>RZ+)3lIvQ}PX=p;Kf(suBg1o;`el}Tt%S{%
zI0IZC_#9i=PCUXEs<~CZ{Phf9RF84KlCwXKuzQTN#q9-%hxHKpcJgJGk5t-D!`42=
z37)G0H0;)61dav`<0W`l?|llOCQsx(Ub7I%PmH`l78{Jf0kKqa<YRnZ@kIX3dca*g
zjr&J#W1W8;Po@9JUQOm=kSZn_p-7>5eR_d*<aTt0jU|WSObq!P++n~YD}I^PPqK{1
z80V=RC|wG{nvY8#cuLm?E0u|VLYSY*Dl0X-wf6l3Jtvly8p@keoghA&Lss%)o(F46
zp2@z}SI+=k{S2sFF`De~O#Va~g^|>SXYxkxgMFzhiHnzr*YR8@>06iDvW>w#z1i;P
z@&Ks?#$kakWPj;ju&CV&xxT|45P_n8t#_?Au*omvM(sB#DH2j>noq&051xr*T%2$k
z5NLq(gl%*f{ak1vTc-~SP)%AM4|5#`Tg$oy_4i``zL1+Hgeur3{k-0gsJ$^U08s`~
z40;Wrb4k?Rn+T03l1@!02j;mx8L&7<1LaWH8v9ai<vMo&=`k#W-wsm*!as@8u$?dE
z3~Sc}6zBCy?q|I@9#2zW$thC(0Xb~d8`+&*dL`Gew!06a>0imwl0*L-7W`UHbvTKz
zFRk>yPM@x|>EOmbel2@j<=e9LujO`D%WJU5ujM@HFINql_y$9)Zdn|mhjnw3iIaw@
zKGMu+(ESZUljk$d3)@}}fR_J4JnO1(9KyedK@SuF9@a_p?dyN#9v(HDlH~DyMbO*u
z#31&1zi{UARz7Ssr~&)ytvpA%-320HkY`ynp2DsgWH0MMr;-0(JT+;7?rtuIzafyr
z#qbuUd?1GE!xds^gU7{*1?keZ=9<MT3j%@`duc4bwsg`uK!WMMqpv~FLs~9qbf-e?
z45g|6+%7dNepAq=*0V$stf&q_*e%=NvS5Lg8#aMj76f|ck*H#@hf5o{r~)B&*?C}?
zW>pYmo%<_l+r_FNP|{;0GRCT4q0}Ks!z8I-v)@wgb78cPvXgWRLLMTk5Z78?+OpZb
zN`u%lsi1qFV<d(wTj=Hvbj`BvZwv-L0zhr_kg{?I?tbH~NkA;YaRGr`5;Ys5`eg~Y
z&op5dXhIFBSq%u2Rr+=}0p|rco<C|F_Y_6VcGM0)P6gkwt+woU>w<cnW<Y5{M-R`y
z)of(-#dmDYgole`|IreQU26Q`E~ID(u+fEDi6s4+v5@)JI0g+Gp`A@Z-N3u>_NX(&
zY+MiDiZ(>)7mmZ7FYcU{?f@&aDF_Q*p@2Oo<zUn$IX)-ChwB1<fi^g2Q_#Y?MHKo#
z9ovHUlI}KEFe6K%)-W-UG7SY<eM8Drhx#JUZdcMuMw2jH(bopFLG_|7^*mup*~1nE
zlN+^YE=GWA(DA2WvQB)AfPH@$iq%9(5Mr1(gZ|!Twy<S^oAdyKjjvl4w5YQcV;1^g
zyMYh-$YPxwlBu)K@qswy49)bEf^#0S8ACJutxv!=qa;^5ve5dHnGf0ap_vn;J#Z|V
z49iTk)kWDl!_S^JEHlpfCk%X8&KI5CgI3`w3HuP!Q(C>9sG_44Fz0~V@087L7$Gs2
zhnYSsKCQsPx^x}XT*Rc<dSN$vkVeU*$aqxSSn?fXe?StP`B1!}owodsqYM79xszf8
zeM{p|(A)#*M(50AEHSdVnpO~M{aplL?YkFDliu%^!@Bn<@T;-(66EWUHQReM%g6pt
zYti@e*r{h(9+C%u_Uf}dtYZPhEcGy41@PDddlZCA>$@rle!B<+uO&8GpA{mtvDL8U
zJqmoK4){!2YYeB)84|mq&+=tYdlWSAY!O^x*5GhpMFE+$BWFuli=G90r1wsivX?yz
zVp4v=#nD2CCqaovSUG7Epjyki;|Ig(W|bApb&LkMf_WtDT=N|j3dReM=(5l-$Lit$
ztzPKxYinsrdKY*~H#&<-`q#XGO1=bBN#JOhO8TN0?{G<L;FOcz1));CwWVxo?}7yP
zCyj)xMVDH_Eph-S#{0m>Jkh&Am6mNqvc^3rTq+F&=<3wG;&r%I5LyTZ!i2gR1oIij
z(NK0DQJIht_(Z*Ea0?9ju<anaOMez9rH0~=<o61`kv>6`@Y8_)>sV=@f?D1;VNj^T
zR1R6x2%)0-mM9k0pzfb3Wd!4#m-GUENeww0lU`8Y!4dSQj-2%+M9uld2aSUN2ofoE
zkz#I9I}SomghhP|1^Fl)I&*t{$Pa917;}Cp2RO7-@_oD-m_}z5)UP=hPX<*Q%ty)F
ztWfJ<f<KZ`AWMx6gV@HmS+PE&JCRrm>e2u`o5-{DchLU`+jBI_SNikyAXeXy73$+u
z6;dAyu%usb*B2{YofRZagHNI}WHs?x+3_7XkC88O7N4bve+MnD(LcmJvMQK<0ALm;
z^l#@G>8;2luF2x;hgj-0r%M-q+W)A;_LVZbtb!4e{hLAT56k|In!JX8ZEoK_fgRxD
zH%i#Io23=vcNC8-!m9r$Tw#VYb*%dPNXb?jw#%x2h|je4RqCz(`lPXimTR+un%?x)
zSd>~u-YdJ#S!|=)N}f9i!0Tx9wl6vF+7NyKwJyrC9mKG^)L$jFeL08?lluE~8M@jQ
zycUfrOM!iYL%(iIB_xY0BUzF_+7m$;Ug9EN6gK+47{pFU{XHd{)wb-8)Zbrv<AbY<
zto!Sv%t&m9zxTmLsTeRW_df_=qiy=zNq>Ni@7whE@vL7A-VT8QQ=}i84zURH?I1S#
z{s%t3i@(Iz=Jb{Lie}M2bg96Wket02vfQOl7TB`D{r$X|^Vw88cJ=-T?OBWOvb?22
zFP!LR+uuv-9jIZSo%<k}%^g?}9vTDIK!!!%gw2Esf%-_dozfTnUpgF!W&uKmeOOwJ
z{t*sZPa*riFNF+;4MP7|f>=a_b;(|n5$3kYA02Iw!-q+hkFdE7E@VTXSh*&nexMbe
za2b`?Cd(h8cu;Z2Ck<fu?df7L#~XNLWot45Lz)H&m4P@`RPBGV0jF}mEhhY73u3UK
z<zX0W{8dJ;TK*^svzFiaA*=4I3?J(S^tA4)j2HbHqcbJRM<xv_Bg+Ry`X~uK$|vK^
zRe9@BJ``^?l(!b;eew2hJ(0D3c?#a{DR188ZSi&<Z_KbZgGpZn+-6I^&hT{`^N3f`
zH%pAloN+=`Lw4lrjMjB^Hn+3HfDs2@@hM*?0lTj*=_1S~V>5OG*5I3ru)HhYadZ@v
zliU;REyo!RG=_x6ga))Z=5Hd%+K0Tf4S!c6NFn%GxVO|&dxUPUqZqc5wb(4{NRf47
z<*eP16<eTx|0bhR&M55$tU7qoweW2+)T?t@0{Q@E>IS!gCFMb-$kVudR|Of+*$k^l
zOewsRQuqkx1Bwqr@qt@wk%fO+gij(cx@cKjtA~Tw%Ao}+rw4VpH1UgWN8BI84h$`5
zEnN=6KHXsjG15mZv0!;vK^q%g_(!)rS>VoPIPHE|ft!~uv{_mNDx{%#jHp@Hh!T$b
zcB4Dz>|Ew1#e2gB{k+VB-5*xaP<0FG5TG@!NO>TZjvYCk8Wujhpf2!kyQSbAF`VP=
zmukZM)m4u7&!3HWhoTE{yoZJZ?^~n;@6G56yzSsC+l(lPz-8-aZ+f!UBMMr0>B5J1
zBa|b_sgBxmg`@oLCnL%!s7k`FWr1$TIzmRlvUnQyCxPXyfnoBlWeo!l0~qDpZ&^`J
zGk5cF1<p(!SrBfki_Lm+&A@t&EO_6V6I#8$L?yXHSkFz&EOIz9nwFYRv^j;pY|Nz0
zK!=@5$^lAQJ}EQZVX8=R%*Wr7$(aouu8$I#?%*$LF*&mXww3T8Md_uqXlWD9>@L5Q
zR^R&kPCR*BPHSM5vV#SUDLC0^EqWo>U);afzut?Hg*)1R1BX6{bSQoc{ohDueq#$p
zN#3<!o5mK@%WGX3;{Dywcis6x3{gjYD<SPqpIV4d#TB2(#n(S6wuMB)d4LzR0cR7G
zIdQPqt-*vr^<^`~*EgtgC_Kxza?jn5-gc#{{_D;#;tjFg943y8yGYkBq-5M^zZA*k
z`~%$U<z2-9cTo|U@mcs}@*z17^2ZglQq65loa3%cuMnrmXZjydbJp$ew6;<)4UZyA
z+*#=Of+?OW!_5KtOo;y1U8RO?o5vS4vaIu|m$Ci4k#BXjY~0N>RqMTK-l`1|6|EW>
zW^5HIIpqtoY0vd1=20cLd!UjP>N<aNrknLYwIL)+CTAu%v>z(?-35Qy&B>V!tk>t@
zsm>J0f?D|&P2ZBHWHxrVHAFz)$6q#QN@k=(p-6FDNGZDsW`zQ?mQuD)Dri(|u*kF*
ze_4~MnSKtXO3IIvl0G%FrDZYOb2DwQ^{w2e2G;OanveCAJUk`eN^2|~hf6W-R$5bt
z`)EDH{fAp=oh46e4Kv(IONjVgf+oY_{YAVpUD5l>Vtj?9*-DZ<l1%M?Sd{5$t*wRj
zJ1oeI^oaMws+mS)Eoh<PZy3Sh#A!PX>$M;=$e|=x)ckY&Wpfr})^|9q5h)k&mu;n#
z+6s(2!Q7#g9SY1og7Md7PI0KAq&QK^DqUuK>vMzfq}OGJ=3P^v0)e~&Pn1<1swcJ-
z({<9Wp=4du59rbg$Q6U?59On9Kcco)`na8c#KM6|X&Y;mcY}`XM&IjIZr~??D#RL+
zbMg`Or1~4}%j*Jg8dW5yGT;adR@Qx(8RcXy<QM>!OfP8b^4J4HSa^E}EgaK7+6)0t
zonA28Ww??|p;r9>O1?I|Aj!p3Nv36DdRt0vJ)<Dg{L;0DA3`!G))1TtW{p0|Om+Ae
z!bm!78VTj0qa{JLl!Td-u<4`B0S-H|1;{@9WxvfVXi`f__?i-y94o0vs7(nU7elfi
z4iI@>;4eE|oEhkm?uOQfRBrtgD^1D5%%-)?8;^Ou_=TBj>lDB<x4eQdY5B83?30C=
z;gaU^AT}YdAj$3g^Fd%6U+6$<AapikZEv#^c?I6;&d0bhXw`)DJFWTyRJ<~4?}U*h
z9}Y`09K)deg0R6It0KB&Bb<UHibbaZ^8##gAsYg>&1UQ(@>*#&UuV;+mGD8}=tQkJ
z$_w4!_#K66(0zEJbuYXc1V<W!<FOShDzKnJ)h`$-#sIqDWcrtb;BbDE>FvG@uoP>!
zGu=EWEC}OU2ZZS`8-&>j1<wi7{Nf<CdNv62&C@D`iMPJZ46{KP?<2g9_TlfS;}uII
zVS2-9?=c62aj%N#d#MUxGT$>1CjMg+VM1D(2s7p|FZ7eJcNE&(SZLjEU%ZnrjRGqO
zV+S?~!VCv25oX8xl?e0j^JUGXmuE3FTAaC3T7MpXe@SKw>A0O{+dyqWU(1+?jbfpO
znj9PqZf){PMM4Dl*Y_Z==B@^2)$~+^CIF*^q$Qcnq;LKl#AYqYY?CMXSJbQY36WcM
z-Y>^uH{!AuyXXh@49Ur}Uszx$v70!X?9~1Rz>We;;q(-daUN2jl9a@OB5{HVEDb3}
zyF%L%=wuxhy)^Ux@%0^GQ61gi!d(;<1cgO<b5TS@Fk(lsgB8?h#Jz~S_HOJYf^F|b
zBzDFcyGEme(TKg5XcD`Ly+v`cVT<+E{eClZciCO}e?ED_?A$YFX3m^8XIi*0<f5MF
zmuP<#`aAW>|6MY4b7*{aEAJ6vOnulgN`R74A6<NZgmqC{m3Pr*H_L&Kda`+$wqE*c
zUrPh!7p!O7kz?Jnkv#j18IUdKX?f;QWEOX(4bS|}42ioykYg?ArT7CzxGHGs(-9z5
zB1v1NEni10OO+nouT8hEP^*m5>aS#m)68f!GU@8r0CqKK##ue-G|Ny!a6G3cf34D1
zuHpR-4@3b)d}8JUc8Sv$cEwELQ!X6d^c!^tGd>lNL$e?pDTf(#e8V_(>Qk+eU}gX+
zlrjHIQwurpuzRo8*755_`vxY=9cj&k+>4vLK^vg@M0M=Q<<Pc{&PXM$)rNSVd8Nk=
zgLRr!=qhzx!FWzTQn-s*h9<&tNN|gd+IqsQ3wqLFwxN^f`^UVs188e8gidol6p*~x
zXzjp*thL{TTCpqNVuE{Lsie@5pRf+Df8IK+ns{d$eER9_v3-26(1>yiCB~+9T%M`Y
zn<;U5rb=&QB$sC>z1aN+Sj~4sN~n42TXW6tp6SWmpV4{a>jH%Ae$uKv^9y-r#+y6S
z@qGb#nT^hbbCkxCP(Fha;<{7+OpkpzgB|i5p7`Jhr!$S-&<)vp-9b&0+W!wdPK?WB
z<!R#Wrrxgx8&lzfBtFrT;8ofH^#?lk7_!7+)~<^CS`5}Qm3gq%(A0+?4e_cfG!-|;
z&|G*3;i$AiTV1FQHrqDG(4ynoM|K0#@U0yw3vn`vb`+$H_1wouCIpp0vTG1;K3JX5
zPBvIW=Nf!GE7;et{=WjUbgsd-{@v-t1LI%4cwqYPWwm4lmQYKirIt01m4R9CLK&Ej
zx&pg_`S8ZBGe5T}?#!h<teOQSRkIlU%{x;8)l^@pEv&G&A_gKJ!(>vEM|>bW@TvnF
zh&F@h;%o*!Vqtid*00WrQYFa!MkTW(xzBs4CvFQM_svf#a{t})66L=71KvlA+#h~b
zK++e0`IhFh{-pSGvf0Qz6>={3f1~XqKd*@OrNaUqDjM*$*uSWh5~A`mH7P|}Ej08B
zesLe5h$c}Nl5!$-RxG?f>16>qzR(aBi32H`;xTNzi#6t0Mcx?fd^GPI!>!;&B&Je|
zw=k|iPoftY+IsrZ3apWCe^EewTx9SK%=(R?S?gW`nxy9pjpNCOB+Vs7<9PlQ`P(z)
zQHB1l7Kw@cS5H3W7;1VBxocO0P*gw~6WZ*W6GHj)o9cw)J2+3c+0@53J7qp)^;I(c
z%P5DVP)rfuy`v}j#Gny+KQAD+k?{ObftFVLxzNcPizh@sCVMNTgnAF*MUDIWSQ8zK
z35?=TK7!(77K7r4Zx>UX+FTprw0l-S-YjMmKN4I_ahG3t(_L+vj^P5sUU<wY-sZlZ
zq%8r(AK$X0$JD0<<lqueyytd?W|T__Xo5K!$DDhd;;W7kg9|8LudKz?{tsSljb)&C
z<C}IhTzXtUhAd+gPYf)k_`+OPpT4|JeVpPwjGW@<?$}T~?}nZ{S_X>80A+>cp!n%>
zjN(tqSSVhqfK$9NFKV2fRuaYcy#>YBFE{jX$RVBFQv8LG!U7Vwg3*@v7t{9sR@TUY
zWo;VCX}ht2(>4G-pS8k}<hl2nUC)z^1?2e((6$Cg)55s~G%p@9G>-jlk-6^R<`IX;
zF87oh6+E0QYUk>8_y#LMTkorOHRKi)khv=vZNq$vX*=Q<*6gNbZ0h5*jeWpr`^ya*
z+Rlb!Sbh~~>k5>$k?>q!n$h-@V4>~JdyKZ8-n^)BfR<`M8bgKpTeS*vy|b^de-m>(
zdcMS%JO{J4qE&|MigDK2JAOoV_G--a&OheRbeF#|g=QD5Hngj_=q1mlH<cN`WYZ~N
zm|UMsTw{nUTRcHOyvESfqag)F0L7UdkTFJ4;7V%^%hQ*>Fn^$@1B~gju^Pa(E#QI<
zx0y=V=%UdK#9Lqs6v+cfsTNH1@TM`=7N`sdYGncPr9kc-Y@zPcTQIX@8(N^KLuh=G
zWz(nw9H@>3$ddw{1Q40H&d{~Oy`m<i_OiS_H1Fm*!$@}EWYu1+TJ_BxF!Y|i+WM7U
z9|6oRQZXEY<GfEBQN976&o01U61PtqZO%xb8RM-o;%LT>ecD<szDk);n)7_0cBadw
z`W(x4{3Yr80rR7hlS6a%?$?GSPJDn?*hL9uLOzsm!kF6I9pnUTel6vQPWHqM(zO~b
z5rSV<5tc5P0%;Ct>o{AuZ0^RC+7WHRe{SVFWd50$`FV6r`r<Q!<*gv_`>13dr2k{P
zW3LyGn?I)nIpmT5{hZRQ#kuR?c&r!W1~x4W53Ubn*Zbq=UvSLm(zR<>8VGxbkBU(@
zh1LGs+TSPf;X{2jrZhP2SWm`Ay#CLcARQ~SrHI&8_=T>t!5=d0b)v8LpQv%V{e$3i
ztIMjrDN)}R{6)ptsor4j4tXQ(=gyUnWrkNy$-v%Ry16~u$p?4mQnxG~mS)U<4S)c<
zy<pI>trIRJj6B=(l?ey@`R<fze!VU*F*oLRw$_8(%a8tdakAs9G~#nu8|;+rT7+a)
z`31hDXVv7^_`MmwT^}s=ZSX1$HO|(Yr-O4!rD2Ddvt!raW1Y>zS9<!*n;mX$w%c;V
zc^qcpbAK^}HfaueDcd9uAw&oQ4MEWoPt2wNj}grJ#2iUFqxBC9|5QwK7a#%6|N98E
z*|D<<Su^h52hHc5(fXvXIb9Ob&8PVAgaGaUc1I)De6cjE#{t%?EqBe$qA_TzgM5cR
zebuZ4JdypoY_jM-Y%Ijh>TbKrR>Qc=10pnSCjOML8S(mduoSMRKBA5KW&`V29~$DR
zc?ey=7Rga8D`3Vqv`qo6@C&E{IpKoPSu*m7HY{QofaxTs08~iAyC5%F3#~7*x5x~?
zG5<eGKweRg0@}}j!Xk>g=CRwf+JFYgL`9)cBp^;OevxH|wBhL&=rqxG?{)F~7gR8X
zjl%>-k(aNj9QxTp<t}`r_M<*N_%z06MdfptqoOA3!N-ZLqv&nqA|_uDIgI;rRz6OL
zENtPp!df4@i~Vsuf<JT%N2uRDhO6Wq97*rG`&9dc-kYU3=@xBL?11Nt*3F?oL4vJR
zA(g|koLcXMlMLI}hxFJnSIScCJg5-`vHF!xhs^r$+LSGNc8?%}f*HrP4L!?YER>t5
z*&YQ~pa0TGuJd3jgngc+k&x4g9&NwSE`wD^P?0N5MK3#c-5$oL0vk&za-2`uSGpy6
z;u}6zR(sK@vN^v_?-N$zeQ|#eK4krU{}feZ$8N?i^w$~4$?ZIYkI#R{|BvpHRj0tS
zr9mb$D>>byWowQCCUDfO-Hc~XJY#sz-C%ex;t$)_8<B?;<=KAt4xa4<t!u|w7M?x7
zBPG1rmJ<NTc3Q6kR%kq`AMcg1(~sxNL=(4P4Zfa@p4sWb`|!({F6?xg>%xj*R5M`e
zGp4P1OYN$OiP#@RS(NH?us{*^1z>;BAg0v9+Ogin{>BNk4}ZwNzZyc)M^G>N|JWb&
zwFumQ2mG8v4k5G*Qa`<B76H2x!zMm})*|pVK3&`s3&MH81cb{i2&vO#B~!UyBP1CI
zm(=QdjFHwv+oO>7hLas>&nOud({l}hZ?ox%ePT!Mn~41|awneR<W3Jd#mPN9;VaX_
z^hO)Z&CGg(>XH7K#asVgiMCtp@EY(!vEDI-g>JR|egBH>@7nj%Z8K8#+Wy{)d5Sf{
z=DTfwhaR#0JqS9$8ou0F+uv(0+y1WI1?+8IAY!xiZ`>w_kqxJ}Si=Lr`hs~Fs;HD<
zfMlvDkux9BH2`eC8@Wc0Exkz|{x^OGVYBLJ=nl9_Y&jiVO;@BqB=XyVl#ui(pcY-(
zJKNfp^znGXWZFUNc9_Cm?Xvz&y|3)pTrmFLieM#ESQk`Q+zmXY_R)?I-|w>qFokVC
zp-;CeVG481vjw<lM=1mgZQ<eG71zic6ipjMSCC9$$2MAjMuX;Gw9YVv&Dt1go8frK
z_V=qI>)&``tdXbxemziEL0HEW)?tVBXR1Im@(l*8E3Vs!bw!umhP~FyQRjDKtL<+`
zX;^fWH+`_n3xvm>W;6;OCN2=ij}5o<#9>h5U}5kX%(Bv(YCPMc0NyzCE;X7y0q<=b
zy}Zaow1XOZ`+J|^LpP!Y^+i)``bJjmF{DH^1id)wM<(@FI^E710*_|qv(aO4mw$&+
zV}{`Y4m^Z=6wdQrgRVhc)RmZ3k8+D!Vph7dvR$$a7`#JP-Qp%2&YSU~$saHXWOZ~W
z58?3<J-M>iP_x}$6nLV>n;X0q_GCaXZcIgX3Ft>3M)ve3rAB*DM*L}M5xeqq1L^<<
zhB;V^lJwP%h0WL^IX)E+J6|N<XP6&2AEO8U#(mJI!VBYI@vMPh+&<<6*P$R;EfTPE
zY&3rot{kX}=L{nMVdD}{JJ}Ey;?+-_ehO+nEOISIQu8UNi{n8(xwhXBTuF$hHo^SZ
zpmFELr{tHj+F<&fJu`jxthS;XB!_lpT~i86t+{iuT9tbWW?@2|o^>5jCi$E;)bRia
zcEFI~*XaOjxp8F^TPbXb>2mP#*uc`+HT_qkA$9IFP4)u=7O$vTcQL+H&LKlnq3?b@
zX@1C1t@466O06F-wXlZ5*0_C%c&NDMmzBWS**m$F<32rE;+-5s|L*lpt{wn6h0$U+
z_K3=ZL6#$Hc=ByWqOa=car7m1M`El{_S{pFvm-IW^*HoqLRKfdWOjOVEXjDjqz>uu
z(^Nn5`T3GEq{R_KXzA>*RzIQ6!AA`9(tqB=yZpYPWqsXsGhNZSV|<7#llmNNuywmZ
zi?1!*nwu5_H|h#Aa5vAGEvB8*SoDzfO0k&Oih+MzWz4(?mBC^jVc#sbu9V(<i`5#s
z9iBfTfH%0|@f`Xc6G!ESz-fQ#$%&(eal+k=|B|N143TZ`LF*`2hu}r#PS{0)E=_Jg
zyVUP@U}rNbj##!r{1JBckascS`F}t|AH%kmiMb51H;FrL@C^F2!3ulecN}|8eTqE;
zR+PLrotPoi!7P5%nZ)mfrn~gScqXw!>3XN1n_`}kpqjJ1aBYmCZ0Q_6vAcW1kRcq$
z<XL|bJCslDM8N!{p=;@%PuhT&Gw<0+J7t(GBwW>#)wA#j;p<a|>B7nV|B?y68}<vs
zf7O%vrwt@#y*dp6#UM6ija#&xp5IcxoZhR{!4Py8DvnNSEbK(3BR}o0#HkLYvjeIx
z1a~|-o7e*By9@4_@}tis&UFx4Zqt)v=M$rAR@{am%#Le#l~&Ld`~f;=$Ms}CTd|+T
zi09@9U*K2=&IQ(u7a7)Ir1PWSE}7@xxEV;_Es2SQu?3QemnqJLu!aohGWK&O`)Q4H
z)m4sj(`?|ZcAeo&Lpp!Nb=uP78?Yq%{p#qN^Ds=ny7xTAdKub_VZFhAo?t(%vEIGR
zu@=g}+W&8cbrsV2d4DIOrE9TPb~Q1k{Thbz<DV3#Co~Mh>Gv1?>BN3o;k3WiOl4y_
zF{#YEh(+F!$J0o`MQu$F;G|QCv;@Qs2Ea``@@E=3eNtPc%|7;JHs70y`2}@DVfJs}
z=rh0$;47cfQ}JoGn|-D83s0<2DMuyQMcriXC2j56XsUTSuxAeSZ)>`<tbl)ZQgi|L
z&!8FEu_8yV#UJwKk~XZ`0(_>^f$8{;>428cI&7z~R8_`b)+Tv+QY7dGLLKx8pKRAE
zXVS><qJdsy?`5rvkV<=YS=%tAnbNbxv`6R}jqK5$v4iEVE&fc)2~YO&N})4>smE90
zBi^yJ%sP@1l6^I-?L4}Zk5ZTvTs^`%u!!Rz_(KB!+2A{136PW&-9ap1YPxf&GfNw>
zTYkD^H@3RLecUuXdY#F(e8%AmCXB~foA2>6E|kuf;Jf0IA4|K~P4SK#c+*iz2rJ;l
z3>ba9HQTx#2h>xHA^sn24Pn#aG&1ZT9K_g$MCLzQSy=l=8u7fUO>WnTb`dciw#);v
zxpA_&>|qR%{D+w#Dj=U<9K;sQufi7u9i5@zzz{R=5#yD2Rog^peJG8*ysAy|y>yUc
zX8Vvbm$L;=44)Rm*Yg^}HSve}_dFD(14f-ZbmquM7Q(J=so5R*&33b|ltiZ?#He{U
za&h}1rInQ>0iVza&u=KKOuUB7ViT`JTg_%f#n3sGN=I!J-$f{K45szW3+@1wx9qqN
z`Arlx7p8}IW+#u?ao38!x3K#@{V5ps1!Y{?ps?ZwIo4qfsugExk+aewr9sV0Y!KgV
zz@8?W`qbz^&Ry4fsZ8s@k%eVa6NQKjJz0O(&@k%Gd^$a2wJy}eV|cKE8#C^4=p?qJ
zCm@3z7(uRaT1aWK!Z|g>uj3(*3ro@&Xb7EhMANSyI$$rQa-g8z7(IFKoEqj=M90(`
z(zpU(bg3|&A1JuKL{G%BskH(#>>(-68W!NTcf<%`?pQtfr!0;YRI~>+9%_$Bcg1oz
zS1@mZo*&`d&$`1}Z&W4Zk-_CsPYVND=8<~kQ=^1;llA24zlMh4Tjtmi0JdwiUGI(G
z29_pg%BP0ZYPJ?;IvD+C!DGBsOwGqkY^{64Pr=l{H7d$!Pj@7VuM3VLY|YUV|0|N8
zFlUmU{Op2b2=V*u>GC|$OqU5)q)?#-inzF@1_}2@=}DApYPItDqv)bPJ$n$J^RMVF
z>|dlOlU#8c!2cIa6)L1|7m~i$lS36!s|h(E|8R}yMNAb^OILQsxZJZo3;-3nZ#-7_
z|B<{J(h)a0RRPF0<wO9@q5mLS_wuMv@7H9opR*Y~`GJ=%rAw2hd2OqZIc_-clDI%m
zGOkL#g6A?lJr^+0ot7}RxP(pUYMea4bkysb6sSsF4)()Y7IqH6jf^M|LtI+S=dSVs
z4;%&<T4)F_-yL>Nnaz{K*R@rJWhiyJ&@eM<SAx}0{cPsdyF>YC(W49&UiI)UO_tx#
zhWH)I=agnz#muX-T3UFu?C*p1?C|3w^3!cG$S=(v-WUa7%CSFljvYK#Pqa6+wR~Rg
zDgpEU7U08m_*^yw&7y}Y50D@3h=E?y?4gZG6m;%Uu|?%s7LKKz;vD;5TplTZSM(v%
zZ)x*XJ`Di-$0aF}w0LHS3!l--ju5zkdypL!jE_7^6YXUwq}C;vA8Vc+yxNv$4+L9y
zb`6qb%VlY(&@@}&*${A5!z+@;>(?E2{WWI9qg81q#Bj&idh*j1DM%PKNKYc~YO4u}
zNIbqG1q&VV$@On3TiCW5yzw^<t=u1=C&~Xv)r9aN3Y)HcAUb(p|CswVpLQ6|_|(t8
zdw>;-QYz7ZV9`+<!5qo=wO+!*|2bJ5S_!@?iNcLcg)cYEV|+QR{FT$3C9|P+7)ypP
z_?jiJ$ebm^%7G<syfTEl7B03nk?bO#4iB`=T|Pf;#CDT9J;TjQ%N}T3I)1K9j=YA~
z-fsmu`4EQlSRXyv|HklBh2cw;z=ZK?L+r<v3$%3|geV!l^jpIZ!r6rg*}OBT%bj$h
zzI@(7`0~Nev@6q_<WL!8`k5=-J=9U@kom&c;$o4heFI$c;5JhPK{{j`oEi71J-;eK
zjj^%IQ44%c4)2aNH8|(57TH(fN#Uzd_;g;uXIf`A&hN1Te}7egt-!uMVyWOS4j&BT
zi3)aq1s_N&Sa8+?zXHE;>0}6p-%t!+N$GS5MTkzPoh>5go@<8+hu7;#(;{sGPJjyi
z;5KI$X&Vdsrs_%Viy;BRG9;cBX+wpvNW^?JL^!Q>r1x*dztGn8s<1r`t=g|C1*dfn
z4T+o7U8d>D>=)V&sy}9dA8x(SCaR{;RK!bdyl`=S8X5W$Tc_rK1AgE3$uPlJy&fzA
zyB3YXp!V%Nu(Z#LYa(J4Uul054)oBIqpu(bUDl<MTd%d1RX(**w#;j7b+@il^rf2Z
z!U^UFFmZ*wiF=e-P565)ucJ&(3>aNdkwa5)wo~Y-Cp%w51?upbqA49tKbIwcM2SsF
zgEv}tRhO1HIMLyaHdQ!=_Yt<e(Jm}o8!9zpKiWouqQ#NqrpXW?6sYq^;eT5HTH_>J
zW#BePQ3lSSJ<f^uu3%9Ht&t>k-r~6Jt%=w&`Bobw?CYf`f4<fF3td<7208mi<(Y6+
zJcMNIAz{L|0IdB^`%Y*#2a4dm_7`DhH$A!jUK=L-1(Hys<V?wKobxCbw>!YYe5%!x
zMjx~q|7-{JY=dHisJBM{LBh*|8A$IsIF>f)u@i9!6T`@!585<g@Hi-_k6Pbqb>Y@x
zDn#EB-p>ZYcpR6WKZ!S~C!?=4KZ_0&shBBNj;xOXQ^HzK)W^Zx{M+|i%?GVF@5Vt7
z2MC8rT}#6GqL13hD!a#WFlP>CsU)0Mf`is~4SJGf&<2qTpR^TKt25Brd#fcM()g3M
zj*F*KxX-(-CbHZ~(zrK93J)Y2m_lhuCoR3jCgk}iZLjo58FEO2xH$d4hi#1Lu!%~D
zM&mYf9Fy4A*tw{#^c7fD3s@2d!(>VQUb4bQb%xROvl&};4u<`X>gyJ;bkxe^_^JiY
zk;6p;&cl^Po|VQ?57gLfn;G2=Hd5*}7F59Gg*+;-lYTQp{YG=LTf@Co|7Z_s?D|_#
zjMCK~0mp72%2xki4d<a?j8HI+89)wo6?+LGL{Dyi*0zBr=-VBdpvD)>D*WI!<r$h(
z795bceJU|jxCuMfZ2tDjB+95Q?LERce;1E7m3y<*>W&kV)J<&Q@y8mfA)s{k(4OKQ
zHXw;KX?v);PsZ?OnzTJt?<XN;G-=xj0~e){dk&&nbwL9WA6`x}3a#3~W;%$~{TnQ#
zh_LN|-qT2T{TesI*P^?6M>rCP9uV<+uy7k3#QMU)1qzy~fFK_o#Asnwdp)V?D2DsA
zSzwRmw@^sSDMymm7H;0+0b+Gk&=@F!?T(`8IOP_Jc9kXz#_7<8u2N3>Q_gwxE`w$}
zu^k^bGvGwiGBl-dIMlyM-Ee}fLb#ZrD1-~#qt%qMD1@>|l94KLM9;NDtaKQ??f{zX
z7Dz><gYqD5LQLlF&j<WUz%!fPC+V?kO4RX~-%Ofo-=V@Fg)Ue+gd(W|-=L3^_@~ek
z3jB}3;x{CFBnc$`Lqt~+-CPVH+e(W=gkM4DfHGo;Fy(44X;uba@gE)Goza|g&vHpd
z8By)~#9*;*2xFi%+=ETK=|o;m(^e)Y%ZNSd^&QCi6Y~r-Dm;h-i)=Ua!C*G}(IYJi
z2Glbi*~GQWgbCP(*-MNJaYSLNNIE~ZD3Xl`WfpocLPP>=#4s_^<+lMG%n4xRQzgk?
zb!9xP{JmJwgH$MsBmbAa2TQF=6T7)MDWKmL0`wOTDWZHeq)h6HD1dtfJfztzS5M^K
z8bR61nVB);|DXptWcOE5uV94ROz!fke>BkvGP{w3LQ;;Vf;oIk5t&;~93(i-(v#2S
z#CXV0hqjQP7UjiOs{i#x(^fn8_7d**#X*2cQ2ED@un3TwvvC6GK)e02U@I(Z^fob;
zgt>@GzEj5Aw9M?T%-vB$=D3KymAlw}rv})#a%~Yg>>_%#iM0L5&iwqkjH(dUB?4gh
z35w%#sWY7#TY3fq#(H*i8}C`^G0^{o2Xo4c!DOqesCLPY`@PLQ(-Suu10X*(ms$#X
zb1!@7u@>1}3UI_<ODD-JZ>gNifCpPGn>WZRZ>g2nN+yoD1;8B+1cV6eu7aC)qk`B$
z^>hdZ@vntaqG}~g`7V+|$Wk|0_)jy_$dO7=6D`z`@6SHcSRoMt>b|p=nz%O-RU}Qd
zN|is#T^#CAW^x=F-o}ZfEtWLG$cB1Sp^{k3D}6c@8eDRKYT2~g_*bPoQ;wHdQ&7P!
zPp>346244RYH5v6<a#BsvG7wPJ@N4nqrApUvoC+FB7j5>G1+lS200%fjZ`h`052lU
zQ(PqMg}%HMD6Q$_YRa`}kNuipFf|m&-}qB_mno3X{cRP<qTz}Hsm(o#N6#CXr^J6E
zNw%rQbfG&un`kdFNQjNc5gad3<JCIdzI6*Lpmnop_x?!H=kNCtRSv>VsLNxO#Vsz+
z>QZUCipWkv5b3>-_zSV16Pxwsd5cbg|6Ij%;yRo5;w(PKh*EAY8>_BydUDBI)Wn88
z2h3u{<)F?p{Rfw0<QU4qe0&pd7Y+TywZ^|^oJgdPI8Qj$T~7}C;7t5{Q2uijsj_gj
zzn;AFfja2joy+<5s}^-o8rO#xJ_B--ItyU%D}0FPD|%G%RABpXSaYSu83Z~8*FZD|
z^pVw26;peInTq|28Qpjtm;Zr+hzx^Yu>~oUI;UT;U*RWq^?G5TMBT4RLzr$4l@FXt
zLCZJ$fm6Rt14`!VI@1(f-4HU+A49TmQd&+sf`x)8u}qoKupNc1N|SjnwHores+1Hu
z0X_}&eXoKll&H=SQd-AiHT8kRd~54Ts{rwoFd_=ux@v;+3nox}l~sS1#(2JLLn7T&
zU98MU;dt%>_hVp6wXFeLSXps{chu68nNea@;njGK>8cYjosJTlk<1{`UA5pRn7$Q3
zVyb|rg2<O3k(9jyLcj-p5kP(5Q6#2@R71#kkxQC}h(R%dT3e3Y1vS8eIR2btopHEb
z3F17vPm?609ce`_hlr8Fj7|#U>gvE17QuHn#_&cRaYUnfg#zY7M}7W}p`w$6a1ZL_
zZU-`un5u}aT)b<Tc{W_bc{U9+0?+yh^N;6}Yz+)pdJIBD8aM{4Zsn458t9AV12H<x
z0j_X}Ilwa;eracAuEyG#tJ5H^tv}p-Hn&)A@U;(zfkhXiJXPJsKP@a8mu+!<k3u$?
z>)TENTgJiYAfE>h8TVyz*LM^Ei(TKF-`cR~#<skUcYlCI%f?6=k8?=j^l*yxT$*{m
zsnx`u-YvBdI<tdmHX0ol7m*9qMD@TbqSaUG2^#yzX2&ucjEKppVia7gA^j<2Lkpyy
zLn_l)_=&|e22e<MxrlTM7uD(S*TQC+8v}J)%GfQ(T%8+7qReeiStFqvA&mPaGvq`3
zM8m={;epe;%^I>Yg`97J+{YoKVGIGeEWsL-deX)L7SMV42@_bKNu64<hoq*xkpirE
z$fds@40Cdt-204KN^W&AtbBItt{O0eu2_8|wZ3Q@3WM7y?s75`%w3K|!eR*FF5jQU
zt$oVxHtup>9oWO7acN8g1Y_7(c*3N9gW^vjpk>-8o3)H7$*g5I*MOG!W=I-omSR>j
z-+X{7{y|YQb?Qo8d`~psYGwq8YBj~a9ject8Y#Ls2t|R4erYv`VXCZZ_bwOr&(wqj
zPH&+nswnXr;lx1eT28!0EpCcdsU56nm1GW6S=Ak%sai=^&G&#t39KcGs(ag!O0Ojn
zAr*?VK|^VsaOZX|IUFqp)mqWsR*%GXRrH7_*CP@x<W}^^5PCOvg&1*E4I$o2_bIM3
zopMs?;`ZsDhP%$yNML*7B{b}(bT9rjns+w_-5cK&XMt*qpM?Qkk@!a3Cam;>Xn!My
z36DS(Y6Yv%!7zT<g%00Qte}~ayq40Th*i`PHU6iL17^k76YnZ1X1%j0SDARPtRtoc
z&una^e5TkbpQM%u%QS^K%)#8HK`eAl5WuOf8GgW`YmWb5(KU$xW4h*IBMuhI!7RF_
z`DCtZKEl;6)-}so+vu7orSO#f&^6QIB~7_*NSV~}P+;6MJyBQen!dCnwd)ptkxA>J
z?`?c$YNR27Q*9w3z|6C3KE~pS9;aE^hMzh7hlMsiHq#g<hFgHS+ZuYZ6dPxCbzAIo
zsfvp2m1&CKdKLDm@Cfr;KTg!Dv7x9&0337mByD@urTS)<bx(c8F<**=MN~;d3;3+R
z@3Hb(gByr-J-!U2GD@ek+zlAp0QVI&5POvU*qmy?*$8ikB#1#ItASWgwG4SAtfAP>
ze~XqDQzo#%@b@^!8W%p!HRW$<DSdVjUb`W7)>y3W)j!1!*7&Uv9NRP=9^7nL%TJBP
z`u>GI?0^)67ajq$Qyl!&>J|0m$2iP-``LpUy8@{2jWX+f7$;VDJQzlz6C|B#b8}e!
zu}#G3!lVSmg%YJTLe!;Pvbw1lQ0pMPY3ulRw^oXn-rzIbpO0I_G#g3stSKB+Z`k4C
z@z7Im)p{~79ufSZ-RxR!?D+s~K0&)TKUz=zix+PRYg%DFYb5DtnW;t#|8s$!dNahE
zOlmH=3(efoyXK-MFl8h9;>C_~?AK&4HrlCqfxmcV(?d_r1E%)XJ%G8ah-N&UY2Y6m
z)Y0uYBO|PURT<=S@3e50GN+AeAr5GGr>2#h9<!6v&9PQaf;-sKSbrFI5?;VNzS9DN
zI|1dX;GW)Q5!}Gx5L|j`8#Z$REN}+mT&-G)9xjmz>}0@_86Bl)Rm=Kdp|fFHf6}Cl
z>_QH=6r)^nB00u_t$_0FBt`h|Mhd$Tp(0G`<@kT`iYc}zU`jdDw?e#)%+gIgR94RS
zDk67UiIsg<G_m<^b{tmX``s1dU`NCQl*#R170i>{$q{B5(nTmT)B*{M3}JHnVJJ6u
zBY&Zj+qub7U9aao>G<<&7L{3Fl^O`{w-L3fn|07z{{*q8>Ia&dlpwYce(H#+Sb`W(
zw#iM5;#r6tS=JC!(P~|!8Ny3Put6f?6k9tmC@&{tmmA=wJ0aQ-A*Y(2yi7y@s1g4d
zQ0B&UpcpKWpmeQ9NKk<_+ls-$U+v9hN8vl!+E#4tnBA3B{8ma*J$VDW)vBGCA>=l~
zCZKPnbiwIlE@|5y0-=tv6^O0SDa`*}%LT%ObE1mfdVnO!X)lfvCTXxD*#QF4qbyb=
zJ0KqG-IiDHY&`f6ns==f`SfLG68Wuz7$AH^8?ST_HGVr*=bD~0qjbx_&{0E97Z^=y
z4`)5`>?no{@jG(Kyd@-5s8R(XpN`@jVJh?)WGI?^8H_0Rm)f$%_nk7zjNvnYfHVA%
zg^c07$evE3SZ`Q}6~h<VF?@sS7KVosG@j|rxqTYM9Ng|hhC7SSWLT0|KBPR*P`>ZE
z#=`e`I`BOY=ft8wOswof_R|9UP$2kVFfUMn7hqb}7(**Sc(@Rn0d}jd>P-zWMsPBs
zI~5f8)YTA!H9e&W&uFA@r&P4H0Pw)@mt?V5`qXczidJH;At0miz#y}axf#-rsA@8d
z)+B4NPzsh~0h<mmfK0Rop^Gq7mR@u=BNI6?oL5p0D~3!TvB#TYJ8glh%i%B@>R!cg
zBlb|~G_J9Lxp6RT$5*%b3TzU<60%g9_6_d3&Ah@Pg8|t##;UVaoQ>(p)}X&|&~Si$
ztZfBagMwDGhMdYFqXGHJ8j?*PJ||mM-<?C&2jl~5$Z8blrEb=sH92T!fZnqPWy4a~
z!wRXuA-e$b>Q|75dK8i9uA+L#c6z$iJhs8KzHhCo%LT7vc)J40dTS&>6!Mn=R@Kb}
zB*Nx&h2RH!oOG1GBo&eEUB#ioZ8(o1--^j_E4)iVC651AY$Ke2|H$IyzaYUT00tyN
z(xld97cHm0L`$eI78|e8fvQ0`QG4jtACtO;zn(1bCiYO(s|p5ZvGJ>6NPX8G?!&dF
z6d3Cn=J>Z_?R)=4bzN`iqj2oCj_m(VtnNpe*nt|u{>){ea(A-&B0|Ewym3oq54aHi
z_K*tFb$<Zq<Q`&O!SO#G`K^Z-?zJ+`9%)Sq^ty-GPI&&#iS+Ix=~d$w!*}>OMVugX
ziPRH$pje#@?JK1Uy`h=5^%Q+-{RWL-?Lc&ZE@Are7}u98f41n$8Ay`1JrRnChTqU#
z3w>GPqmE3_ihlmahW3pa`@7OZ2eSGU(Fl2-*x;fSM+?;>^!Xh{v4w-s=#7qsxPyY-
zjg>Q?W&fkz0JP~{5T9yO9&PXXPDjJuL3P}X-kSimOYs?Kyqo@`K0_^wp|p;J7tV0P
z?Qv6rNUL6Aa=qsjtyJh<I~BUe$3}&=?aWoEBPJ3o4xWX=RB_&zZ&94lT`Y<dL}YRB
z;3f*#j~tBgl5smu+ER5n5KvH;A;i5bLLXcF!ALA3{-Zm`eS02sX6Rt(%siw_>ZQ=7
z#ZCj&nM=}}gApwvMVXYc|G^e!C3l{S6jgH7tRdMVIkA9k;$T$A4GgtH$W+n@3)nOc
zMs?gHus!NcXAHlGo$pPw!1d&C!GOEY;W!u*<WLJ(9S%md+eK?I7RdP2+}sCO4n|em
zDQhqqD@Zq9w!jt8-e<Rt2iz`eIJUrFGsTSV5C?;qR<E@NV|_T;)=JAvM8(iDR8uan
zhSVrz?$Nx6bkmDNOE-wY9OgWaIT-a~SS7qj_wugkiD&V{dgM-Zv5}*zqIfDI!4%I^
z_{$F6#9HL>FsZWJr)=wZ1D>X%>vNNsTA@0K&Yj?lqHN>7&_U-an|06#ntI<?Y%NTQ
z#{9XT=&L$%5Tc(xLV7QRJ=Bqu{s^))sg*{i_7^=>(gA!+{u?*{o`HLFpg%$fe?}?g
z+~~K81K{S5Ezpr>1H>xAclgH2t=>;@4iKBG_W8o$Ix#@(sQREqs`5Z_m{1geVBRPx
zy}8pma}2%k8q9)8-N(aLrTouVQ7ON3mC|vkMWuYhl0-{LbCN4-%afcz@EiXsjm`Rl
z#327)p6J*<Bf1B~dZEqrObw-t9(&P7*TLdGVGDFR7Sl3?@#skRA!3N%=ybSexRcag
zp)4%akp)9=pYZ5eC>-yE8aKkFyE{aj<{KEoH3>w+T9Ygot2krxhl(k}VgaYThKjzv
z`tmkf<4p^$HMU@m!?Z@Mz$JU;42#yd-qNBqdI5~Co&_5nIaqxT#+|I56dAOJ2cU|z
z#*Y=uTBE*FNS+R@F@Ay+Q6U8>le%Rkv?(YaJ5VP`VX8;2fWJ0D8dWI)q^3LU4uh+(
z-*{@%S|oL%<S*1NQ$T(|BHiP#69X_ZfY{pa>H}^+7B(sTLRJn7ttR#KTRLRm#&N2m
z=~ud&ahK#&s_-64o>Xb*s}@)X9o#uhfy*qQ2+W|3c2Xq{(8R3P*cUp3#a)}Z5${Qo
zS{QyqN1`W5UOp8{C~dsABiEE8${~WL6xM_$Nw}mux#UVR07(u{lA?ryn>z9msC_z?
z0BQ`Oa6yx$7$Fi->WVid57KY4R9`g=fg`eJvedcKDq=&oYmF7U%~El?H5h!rhHkUo
zd`&l#`u24@q8UABl8HY^evRF}=&<*(umKaDk7aE|XFjzjGqDBpHNrI5!SZ0PMRZOh
zNiO_=?QH!%Lvp7`fibP_b8$ICM-c1M&KL|j61O^jO(bJp9(p);ij*&`zojE>)1?r<
zBN!PjFo!7y3@@LvAGxa|hIDXK2$i-A@er8HpLFC>x^z$wD(dqWW=M{X!j}p-YBNom
z;XPfgm=pwFz#e=$^KlTiu$7+bMWSYE>ynu*#Nc4zy$-kNwZg)5zC+>SkG2cbXH7bC
zWV)0hTqwgP<8_6_NOYeeX;h*Bo=%@3wR5@t7F2~*ju;Oa_<M#FUg>#hYn#dCASXE@
zy^<3Zu}cXvFHUenjW`>ICqGT<Mj-y^h=j}&h^IlGnjJuU`Sw?!#pwnN2gpDAJiX~O
z)A*!xGv!_d_Re<Zb)1>GL|dSx&xqkk0OkF#M<(_6LG*~%3Hmhe%!_U_$)1^#M_3+!
z6SF-dsq{Frs|u!6Mg{m4ObsUPVDK{P$UKtl?J^3W>`Js>ALxkMAdM6P;rC@4q?!@C
z`r=d(4!cDsWYK!FP;cQY7He_(B^(2dldQ1+PUk*8BzFyxcUpGM(DRjnYzS@NUHTcO
zwdUE{wE#MV-lh=ibDUms;u`X-J{G@d({LM6Fni<-Z)D*Gl>ecRn9Z0mf1}ibMmu#!
zE#FB}fVu$+!*Cj_QC7pv^CtBH_=dA2DYoLn*R(GtW9%5SvwdDd%)!7w`2waAxce6l
zp}#D3P-U6$T*Bu(v8_N8du1uXe`#fkd8e}8iH+IVXVwgwCv*dNGB8sb(l5Il)!iK7
zUOHV<AeI6mAq)3`Q>JEDpG2sT%8u>-e-s$_Re=w%Tqv-|5uEoTQ}R^Rr?ooIk^(9_
z0|~$NfwhMo<x|m*jb};ogmZuB$oW}PEw2@7yVe_Pz-$tAmJ})IU+757EU8gYfIX1X
zf%R*lF-I$*{Yro7$cZc|%6pTiJ<56%ZXC(jDK;dnW=m?v(3?a%Tk7Tb(u*9JE#(N!
zRQmjG*^--sP+86;1AdhJYk7ar+4%o?r4)_h1{y)*IA&Nh&ZBf_oE<+(ql76>b)@<n
z?1|N0(2;g?B#m#)iuR4!w=&m+oyG6TJTF8-UO&;1opUfJDuCwRK3Ccz1pTffY4fBo
zp+9KEqWX6se8y`c`tU%R2m~{-o7c7tXQ2}2NgDrg!vM2JnFeG4hW^9wtSyb<ahNZ8
z32LnqN!~41A#w91U9eN3j>dNR4w&h7p8t7J|ImCy^}Rmm$hG-WWXMV**D6H=Empf_
z1gtjSJa_uNjz{%7D`0Cln3?m8N5i?{o(RA(3lJ_G{02OX_3aKW+a7VuUj{&5IWCkm
zW&cLXq&|!(POXJfJ+FghDH*xZ-9s-Cfw_fBn7j}&p??iDZ1;s1O=0&1grYnrJ2%qB
zLUD8nm}|-+2*t<$=pi+Zk=-n#@KnR4TqsycCKRyXl!%Y53xuKxN`bOp73jtb+&}@6
zlp}ctTt%%^(28+}agfs#WGX<?H+}`OlP&he?y|0yMlqCX$9`2{Ixn!;x&V#gC<R)5
zRiHC3kd6YFzbK@z(hr_rl?dS_dRSLsRp8&n_WgXp7B^$Ru`WO-Q%akDH5Z5ki*prp
zh?gjDU7|*DiK!?-4iV^=&)^>RJUYik^-Bl(@il>d@jj>{(qibB*3Nc}U>uzTpd-tn
zU$)%Wkxz@EUrv^>15%pzd=cbngcIMF+w&0kZHW}+)!81}m;pF)c!`wk*wcr2EQMn6
ztxrZTg<_fYR+sO(O!9Q-cw?%0Hh|}i??Q)QL(MMuHiai4r#RmRkKQ`m@a7dHf;u=W
zxw>iny+z&BK#~k!E=>{gZ|lg5<xn?^j_GiNBlhc`6zqCpd@~PiYrg{BjRf?h71B82
zBZ$Kk%PQbD4oO2No3NXz>^IH$9MzGipQLc%<mlY|9zRLW4#GFDbfnKp=~toO9v$&n
zC4~j(-WLlJogBzO%3Yhw9h}I>iY=><DXZX(?YXWa&sRyl0W;u@S@tThCRFm{^Mf;w
zb$mNb7wQ$le_7kpqG{d(M%hmD1Hg*6)09?VyKz`EBOAy10x7oBL;;#@rx{!TVPooM
z>@|-5WD3+x!!?qo(oaa4)H3v;<)GTj^L715)*7jyW4(#w)EcReFz`9Zu~wQST>4E%
zwyc##3tP~qD(j^0YjkG{47-srKQ+#(%-0b*e@Brv#;4+F1(rAtuaj!1z8KM%qIFVr
zRiB+YdI^h!Hz<mb*JwTRylGyCiDHnd3C+t|kKsG9Lr3<mm-4zzq`ENEUxTxU^=>?5
zPq@ObiT!mQb5;y5F&vrqo9!M0p-~=W9ZzQ_v;=%HfX3yNqen^9J`53_50!7Ax}+&$
zU9T@pTx@)g*H?68`4p_`m%oRmVDC^{;Vu#l)5Qe;h!4Gh$lCY#jlKqFtSy1*D*P-B
zNjmX>a|iV?_CkA<f@?w{HUq-e_h<{1NVgc#ZQ$t60u*E~yz>I|Wc^r*H6=sL654Fl
z5n~3n$1Qqi*8t<%nE<Le6$|D!V1u<&#YX;WdmyC^0TlG$Laez=-G;f)La`cgohFv?
zUi{V`>4q7Q5pU{1bW&Y->;x}+nmAMy{5@ibFQ$nLoL4{8(Va)`<j!x{cr<K_R9$cy
zoJ%5Ri2gAJ;7@DGo&xq~l0At__W9lx$^MNc$<(HDE3$tEy3ih${mBf(6C*JAt}{iA
z@1)oEZOepWfj@Dc`x8h0(&dkxDfV*^5}@7g7{p(MX`6H;Tf#PhGg}n7KTjQs$awT=
zg5prP+c*@3xe!$e+XPa&1E!whP`rn>qW>^Br78DD$yg5>AE!7Jhxdv)VZa$3IVWRl
zQ|*g7B5sHCFdh<8CKD@*4rjQ`CAYJP^oH^l=b;9`*p`5ur#YC4gHdUwtYg%a<Icm)
zYjCWVi_xmMztIFpa|GG6T&&{au9Qn_3z1&+tE6$Mj}#uxgs4O2&R3FalFz?NQ6T{j
z=@ZjVgI-cP(#d*e0b9aowug4lIBgnfzeDP%alDLCqmeb`%->Ro2phG>pdH*l6WEg^
z$+&ws-$U+3s_&HU39~SxcKuD-;C<~cs^Qq&=#g<qX|%koNv-)?NAlFNFM0Tzq^Y*-
z1oi#j8K1PK<hWyOfx80f?;H4y$Jeh=Mbr}E_qp>Rm1milDN;$@I(R=Pb>!weNadvq
zXb9WUXP~Kx^C6adjdo0;F#OSRVE8Hd(um4OuRywBX%%s#H8&cMk9`+Fx?Fx@(iI*s
z03^ZuC*_eHI^%$`fUUm}9J&f7qW?k&+4TZDAf?XxW6VO<dL<LGC~wgo)HoPGT)vu;
zv5T;~Z&wC{Y}O(O*$E8-Yo8X03xs|kV9Y*gb;pURxh86%cRIk7rlE~6rN3iX3NIjS
zQvdRYt-!UQQ&DP4y}7_G>TD6XiAa(Rf|bsSu<mb(7*w`sEsqsMkmNa1<xqtL@&DTO
z&e-vLCU$9#BzXnSwHXfT@~18q1qWfoCAc0-#9v%CFQu$ZcdK5-q66Kn`f3Fez{+LN
zPUC}mxn$B((Z_MMj^r%G&eYJ3Ai`2b*b)Fj|3TQIt`)0LYGCOnZeUkMDZ*E2nW$?t
zcOUcS=_`rY&_2=5oliMtWpydhjK)u2*om1{m}lfJgNRlK0?LaM8e2s4?Ek)){rfHe
zV<LKUF9(a{U=|T=Pw^ozrve}o(G{m`M6|wAPHqGd9e+g9#HJyIN9LdziVdXA8Rl?|
zYGUR;iJ5N_GCyHf{R?IB3rD2Ns$80SdPEBG?!N|-l(j`e!*kTYVG{4uh<*(_ip}2p
za&%<KQK_B~vrI=e9F^L2Sqs~mkj?KcrZaa;^quM*dk87SwTUzukbsN=H8tV<dh3dK
z+89z$>M17jnfHsYET&O{a2&@!tRsirQYs6HyLBY>m{fCc*%E44an!Dc_Qf?gT}`5)
zH2wgC=i4ZjPQ%Fel32~tpOjp4h*EPp$=C6BFK6&0`k9DHWIJUZ;8h}Qfg6Aj*}+rc
zEN=1L4o(3Y#4=Oh=@Gm3E%Pj<z)1slE$rK2QfD6mDst2<McqcAjgYr!Rw?5^>3RyD
zJEJQ)<9(1uQFvsO?qtWy$GAyo=mN$}2>KW|$2paHq9qp=v<M+(Pe@4>{=JP0MB;%C
z6TzKOGbf~wHvYR9ym3f9>m`DIbFJ8B`qS~8Tk<YaSIB(LK3&(K8b92)>hlM3?t~Q8
zd)#A4H2~;{uieK9kd%NR55li}Gy)Fu+%zRZGyssBay?n85$M#L8H_RmDP_>71j-%X
zDYxqHIRJh*DJ3*5*iS`oG(_X+VO^=>P#TM4P5m7mLMZJbqGE`nv9D~baF6tTtaZ)T
zkuL|tK-FsM625fY>_L1_Nipgkl*b^en_@u+i_eOq(_yMkN5K4<x5PwY5L$5Ml+-Zl
z>0a8t$^1wXjXkn}b<kYkpavEhG&bc<9kb32ok-kmtP-SN<tlG3qZ_8s^y}$<&{4{P
z|1v-7$l}|0LD2M%9i(w6z^sl>Z~j$BKHtU*f^+R5Db7!QVIf-G!3%<Eb97|f9h?gY
zv4=Cxp+MX3h|RrwZ_%00`qQ4Uh8uV4a_PzG)57j=bICt<#VA!hXdCkBk`z%lF^n>y
z`8B`TJ^6ODFsX}X+Y!PTR*&?&EQQvph@rD~-ZnvtGF$QnW*Bb3r{)%0au-Q{jQR(-
zPweP_uZ22(j5_JEJ%tYH(4V_^a9Z>ed{1_cdi!i0IeQ;_=OrZAIqKQ?#LiJa#r%$)
zqYlo}@pIJuKzurfBkUZtF$lwAf8IZ9o{paP_w#?)5MRwl{VC1pKQQn1(_j>Kj=D<F
zSLdjG;4HH9{SV-J;(Y(G@*Yp2-*L46k9|6Rj(Xc}l(#$D@9_)wYxI#&@+;0u;pMBr
zs#qQE4^vg9#Xg*u#x{-{$X5tB1IDiIZ8tKEOY;nNgF|`d-)Qp71u4{T<0m`9(vK-L
zRK}UK?BW^RoDb$F{S)lrjbF4jtl9|9@{o&CEzPx$C19Ry1_lxFA4$3)sY%~EqFdRQ
zGkHDD_{sl4_N9%%C`y7a!6c0z%6Qd>WL%QksQMyiM^E{u)Rp?#P~%Ce9W_kq&(rNl
zVf-eF^Jx%Nx;3BXQ(H@Y9)(ZKHni~R^9E)<&Dx;w=}>SLJMQoG-mcTeKYN(@v@D<*
zpB|bHgLef!&mtrkpDtam@af0B3ZF(zQ}}fBOlv+h(2=p{(<QRPr&VYqq69uYblA+N
zF<xKsX|=TqpT646_;jpr4cdmC^M8~3HGhUsZvo!!$SUB^IoG7{va!FKeeLLqsZ|A9
zrtlhKxus6_qEG93m7^?mtSg#!j=!AhFd2lnE(HjyPcR5PIFGOV-QK)ah+tfo8VHg6
zo0l^!UDO5NlW$-W-~9))_6AlL4<F}cOB?X5a5uSa6l;)2U?=r=OBMabp0|ZoHg-&A
zD{#jJsdX;7dQ)oFIO`|2HueK}(4-!_*>>zJphIlzhj1O07GoLvR!H(kdf&kn&ATN9
z3V&my*kkmgj`9}yHAu#4*Dz`r=%zb5y{9Gs&jn0DV7f(WkZ-h6bOT6j#iE$MznF?Z
z!8y@ib-D_=%U;xVK`nRBiG6eKNL__^j7#yWy7Qq0XdQ={F0#C;Tc&~&f2W?ks#_XP
z+v>ZxWaPpc9XWUx`x$dF%JKKG*!91SUk~ofC46w3`C)Jm-NWEIfi`?1b-vGdZ?gMw
z+j<`2deAEa9<Xwq+ken>j!)Wdaql>XiWj{|JM+2mC3!*)K509|BXk`lZ!!4ZUvwny
zY1?NWp=<3vplNZ>+K#NyF`G66?$#IM>qSq<{%37hr2o-B6}aQNE^3VD01pPUPRBLr
z0lyEsIq0`6e>_imVv(-Ylb(Rn@Gn2$3j;Q(H`7n?hn!LJAZ-nv|AoqV5(VJ=GrjP$
zFb_Y2H~{S(j<Zt$JnkJgrN2)qe*X>#xAN8~DnL44K5tt?sJ{qeS|GLbd$~|os&FT*
zgyPsst7C4;HJGxq1yUW4H2`=rfX;2{?Ah2e5ifBMk6!B4cLF|8ml*yx*6obV&%;{a
zjq}YQp9MMq&<QhdjP_v1@e{J}Vk}#3j6+#^g}FB^>ufBIvQ$W?sOkJ*05F);I{Y6K
z`RGg7pKxk5#(vKuSdbq&bDg=Hacb<crB*tVS`|ni9(^57$92E*ey`%^RPiN)jnslX
zuv2+dV3)RrP%0MW>QJ)<i8A4?m;`%xV-o;VXGeK1c@jLf$U<sClsTh~1NCPs1sILP
ze^wSG2Cbxb$242yni}Xe$iA>K4JFClLaC)n?uJzOW2u)a_B*7q9>aK?>SRNRhs2H$
zCUqS8VM7JusLI6e37ni>%WW0NyS0F{G9HOlED9tFN&d|8AMn+fle2ZSj(mKA*t6F?
zJ4zZ|TA+DJSK-nm0y_06BGslLP=HTiJgy+I`6(`oxeia}ucx>yrr|oojOYu;!v^c<
z3&+)jox`~C2%tl0+|>qyVsAXIjnwfMj=QwQSF`b;@bn*?9MdN73VY#rq)BCUSqxq{
z7KQ$^nep&*1b2%?IGyXWT(KSNmVB*VdS`L<vfTyhrPB+jmodxC>Lva~TTlO1&`Fpe
zMAJWRt?)J?T@E*e`3%$H1b0RmxvH=jSg*a1+6oi4^<odh2YiS_yD2N+LXE>{a(VM}
z=dMi^5Y-`okf|@Fz_OqFa2{F2ACAAZRWU$%3c((Z-;#+njh9kQVKlzcm*-V)8sl60
zS5ma_T|XU3e}&lOn=Oj*`G{|Y3Do!m@JHiYPq#BZh~gM0)XgPTUrUDtLsTv)d@VI@
zU#}V>F!?l)YkoAoGI~&075~Gnw3yOa`y#Jk&=@-n<MybfuZ5keBgyU24TFyS`9=y6
z@-g@?-oQ;7ft-5(Nppm=Faod}2ZVlTf96~4$GBe_%}!%W`)p2Qwm{Pc!ZHV^de>^|
z3V@mvfWD=saKbidjS?(Qm3JyDixWCSM`pgm>g%hGoJQX7>j775gk`L+2iO6RiM{f^
z3IwC7>V*nC!CrYEsO0QH4pV&G#u=|2gF?i5#JmO2x%8Fyq<Nghlvm!bOyiisD5e|l
zrEu2|0#$$i&Zj(9irh^ygsJl9qD+GiV4xm9D-5(G7VRsMfr1neRWE>W23n!z3^b23
z&;g~BDuF^U25Jv0-t!|Es4KoP23lAL-?n@N1HBg!QvL|yT-~5B&`<bQ*uaW`9#1TR
zfj-yDCDT5Eff|P8k`G-BekARGQb_w{q4r$lOu2|&h-y-QnPtmGIUob$q6p4K#)=j$
z`U^?UMd@%+!au{SN!3HC1g6#(svu{^XKAjG0kShL@=jH_sO#%(rovudb5Wh%3Ky*|
zi_S&baZwr+LkV1T<+&9XX)aHqJ9rR7aA_4o&(Rllvg4m+aGe?d$bh8$bM=2)6#hw8
za#kb9ntzV$<NPxLtjG9gM5Yb@9027hCRdbO^jZ#A-}|%$?DGfcSR7r08rs;zlgua*
z{ZuDplwVsU#t7~cb%Z#`vpa3?M%iObH`>AT5F0!lk;-yf(wtxn40Q+jmlY|xQg3Il
zOouUuH{ot2o9|b^EWf@G8wel9V>RK07%KePMMpedB51rGIn7^+@v6sqgn11w#b&Di
z&LGVD$4fCV<~8KUT76_e>#~6#2Zsbx?px(71Amkyt#(QFe}&We`f(WYSK>us3bcEV
z*Wx_&+xZwXy5AlTCh*AV2qSC(-F2mYBlZx+j?s~kZxD+8K}Tl45v#exjN!DL`WB;d
z=#5yT`p3~cr!8_YDu}Q`Gd>BW1B8X=KELs)u|NDNkN-rCDseh!+vq>BnacpB;O_r`
zDxr)V?minSc<nPVF5ETcl0D5V*{7E%l3g8Iwq(hkqkyQ2s+uLcW=9*zt_cXtUMi~=
zPzWa3H@{aT`}kr-vNiM@lWe(@BH0P}M$46s!Z#bqo;aig$#&H!l0D1UTC$&Deqd`K
ztR(x#$+iPr6_l`+?D2wSfJG#^WV?+}B>Q<+MY4AcS0vjVL}!xyGdjWSL)T{|OZM^3
zie!&0U4mr4m{p==_q}T^*?r(e{eLC926%}{wl^TDJPvqnmh5|=AkB$Ej<sYbZ{?C*
z7VO6*dlGm7ffdCvbWqBzcm_;*H;DE~q)h6bAf&Zu$Ja>hqjC<W2ODan#tH8ni-@sC
zYSnrb5_P3!K69J7glgB-OuPDx!x&gCZ|#_(i~+%C2$?t44Xq+mKMMb)>&Tjl^3T4_
zN7C5?Yd4Ip@zN$V8p~Q)6R;tmk{lmdY9Q}j(&H^`MeFCy+=-9JZ<9J=f^}QzdYtHJ
z3M92W<W8DEh=_G#c0mI&hIqmo<2MtHp=)jVSZk~AAgsp(9P4b8$WXOh!}|^BY*}oR
zHt<$89m^KmnuP4?%Uf0Y5pPxMM&7Eo1+-OnF<5S1a?5g6GaJ!W!M5M0646UOA$$*w
z7*<*S-ly+F3fBoOET%M<+Pup0L7^&oKhj(N-qq&;g%d_`Tb;3`M`cpRM-Fjmd8#41
zEwDZQk~%)}U6=P~c+UC#$O-n97YjGh*nPfog75*Br?j8kTUB#7di-Z~If6v_$qiH|
zhv8?h38XS9^pooe{_&|KH9+=OIe0*RoBGQ`g%=I5hT|_sgz1}NE=g70PE7_BINe{I
z0V*2XRig8bmYM-jqNU&@$)S$0gP{R(1L0m11>MPtKsPZ!ZY%^g(vdv@a&`ZdCMBb5
zPC>r}$ekT;_9UGH<zbF44am_zIo-L-_iQOVn7o`!Jcu?(mi&7(E*VKPXbEBpl0%zJ
z?@4uwsW6l==g|JP3c`ub-{^d#Keh;fIlDh^$c`$$b{p>02x-zQSWXik!X82AU=u40
zE?*ujoXtppMM8%6SW~VdZ{k-%=0c5(ukgAv@Q3aOZrrHkW@;*+nf@Vigpit|BZ(n0
zZf+c|%Re0=S8@<4Hq?>Zp>mb5Kk~Pl3jN?L(0;@*uOgO=V0MQ;c;^eBlvJ%E>xBJ{
zbtJ2b98~AxK9u=hS@BziR?&Z$v)mrdHBkopIh(zw%k5Uu8FIUdJT9zLck|9YI2Zk}
z)Q3_@U>XcPukB=c)HYEgcdB@^KhI`oSo+cI>oj`>c#1-^+uuslY`mj4GwCmpN)x?6
z4`wYb2hud&r1tKI0mwYoVW!D##&|T7&E63fK!gMLq<u?2-Z2XQPzht@!fCm9h*w{T
zS5-MOY@h<O=Whl>m0$&el|?5uE(;)|C`n>8vIiMeRaRH=SKx<mc<NkGS{P?90^&;8
z%MZlARF%V2clD5r%T?uWE)%=*W}LYKC0Vzc9O1qkDU;fODU)JnM^uyRyBy!m#qUr2
zB|EFhXI*AN5b5*qx^2k$F<f3Kd_MrvUtMl4EP}@}sJfi0QuXEnsaLH?L+YCdxs8AG
z81M@Xf?x{)l{3m@@C%HaRUl?gggmN$wE>*Q<<NHerHT`TFiWMuCS_;7+fBlfG=|Pu
z0c0Cw0QeCoC}8_6ghM!FL-0NzA1b3+UO{=DRyLxB+*!CDf&H&F<SIUwYkl1=V^aZe
z4v{z_Fb!5REK;uNKd1ya+RBTL038-7*B0tT>d4wiIn?J}R0$|`6z+DU9OoD^odndB
zlN^igli@YxbYTO$@0T^@?DQrzODMOg6x#{MxXEbGO>f$BP0$=(K28UGXR8UureTn&
zCfLd~!S8p9HNh67U%RE_nsB^c59%O6K1a#Dh1TtLq<1YjC`J>*<$pi@Xmt!g6Intl
z=a_I2?DksnCSg9PAV$k!LdvGCWM;IitC*-O9#>-m1$-YZrwLD^;9$i7(0|KTe!SU~
zs3Ske$ae(SUfA<pTVCuvr7tT=*YT-d=2HFNUKJ@?N__B)J?S3yv5l2%=Y3+bJ-HXJ
zkur#J<o{6Pxo;rERg`SX4aSNzyH*{!ulIZSf)*jplDH7J=#EWmb!6Yb+pW2zME!0N
z*e(<X0$Uz159-K~Aqy3l2d69o+dziEdNP4M*bO@|V&%xdHVPQwU{q)9Hvm;tlX^5@
zCdI;d)%g|zgEP?n<Z+nRmpqS^gI#i3@g@|Ugs}S7l_OksBZW%=AomFJCDnzXKG?*?
z@+tn3g>~iCUX`^V0#w0yN;vRGDdT_d(dBma<P9!<TRHUWp8);2o}B4*GQ}Qx-8(=p
zuP+Bw9M=`wU%*0e$4thtH2X|_$o)?(z$p#n)UvITDY@Hg!pX=KIg|t%NLAwAQ1(#W
zOG0O=HI&<W{Src%W;A^On{F?L-0XP+JW@k>OEaJEXw{Q7NvxIh+dF)tPmCsUVXld~
z+oSMzkm&QMi?s!CR5AWZ(Tr{+FAx^_>PWf9a&?cwAnUq}A723?a|h0*#WdBCv5n;@
zukkhzv_=C3+S?fJ!oPkx@}{vI?orAH$XJm=)QXcEIbQ5fhQ!HT9G~qcN8;pVLVc*c
zUQOgp9-aX<6^Fe*3BRUtSd%`DshGYke8>2qV}h-i7Iad?bON>*!C==vS1hLfNRuf|
z<*`B@oQ!u(<sjk5U~DCgmjgW>`q@<X_BpC+8!y)sYBtj4PmGt_Itb^Xy-qcgS2Xvo
zOqW0sGKIpkXal7-0?*iq$Qm@*7jsiYeh^MQLBD2=#*3I)UFkwUXCI@_lCAk0n#<)J
zga;jTWJe2mr*I2&8q`wO2xpf=d|S$DpO0OXairp!1Xaz&b@(Q7sHHqLqEB52>Mpu{
z9!5A1=X5A`enVR9<u=Nw8vlNbUJPm_8`74?DPqY~A6<yGF{F!PxllaZ#pTl6RHv~J
zynHaLNxhfJ4Zrjj#f^{0;L~#UX=N)NNop-ex`Zoe#sdwJTgx?ri|TO1P0fhGnMNIo
zK52{#2vBZYGOlEL(poMryltr?Bc>Bi;@U>8sB&xxZqI7O@AGKr5~<*s{2MUOXd_2d
z>WGv{UB4yudS{>+a4iqFf$WZ6%%yQM{t{J!{F4`H$E7iv_L`p0HOh}bm)!~S2$u)T
zIQ0H(K-Wo>4+v}9fMpZq?Lzn3P@rugk#*y#L}GU_xlmmWBY(ApW;xds%^TTH?%)^b
z&Kbwue4dU<z`%bo3mi=5c9p$IQ9C(Ds9a7*<o0rP-x_Xq;Km8}x6w_M1NbJ&?NH=z
z+spNRwpFkLq<BBvL&Mv2kedjd$^&5sIovza9?m!sK!w#vOq}dVZmlO3$+He}pyRxe
z#I>W`MK!xOq8)KHa3kOk9pSxiZmuKGI?4yVVqEO%Gp64`Wk)*6nr4S;aLZU16f~(f
z)w313X7Fv9WjxO}xh*(YEOO(JhGir{k=j;daFQG)l&^uMx+I8Rp&QoKlH@?&QswPy
z?s!`v$(eYZQ!&812uYTwIRA%=u+?=g8Mc{3kPFFjKcQ6_EFX84!-ZKOaNo|5penPr
zlG&Z*U}3Q<<|W9fy(bH<ZU~E|&0yQ#DYHQP{nm<$7)EY3%jY5%u}noiZy~-UsEaIq
z8y;?D5q+q?oE^KHG6Y0~F%&z-z4Rv4u`^f>SF@G=W1x@gTY)k+csM}Gg)Xu>eS|d{
zda%UU@+&m^-!L@E)}ZW^w9i+d^Eha{H7Gmn{rrY~<N8rh@9fw**0Ai1_A$VcAG*rJ
zgH}Z`je%~~$Ec&%zk=oYGtaRUsQkBbR(v<8A+vW*k80Z}m6u^$_M2_AC>2UEWAA?4
z;``K9_R<%9D|>{jQJ`OKu$cWe{h?y$ozN!rpRqcA{ZHd=vPbZ@3ha6gOEs{&@%O$!
z3kN*|pu@YtK|fvxGKwpKs*;1<<Y<>&8s41JC`3MXgW<oro~n?eP%SY0@X!NDhwieU
ziz<`r1Q+}zqr1ziDmH3FHGnd`@w<xNhkYk!xb&aR0h>+%;P&t2VHKkrS^>KM1HkAW
za)*jLzTw%_>>Gdm8`(ehkjJ{b57m{z1<7f6_<I@|`72m1B1LXg&Mk&Q&(?hBKt}q>
z8WNcTh4XVXI&(fnZWHvd6cv}ReSg=>5c{%a$h;g<j|}Z85Ad8=uedc-dvpf`DeNhC
z@camDv_rH(^vl~z_|jG@j}vZu=uM7m;mWH`;#bue<1cRGhkd69>WD^!C;!WrufZtB
zOBaA~s3_NVkNwmefnB=0@w@h!>oj*sUZkw{t6xGnqaK9{pOCweauwp3DtkM2jwAl5
z@b2A%sdpbpW~aib-U!9~A{8!v`v1PJ+qn7MHX8P3b}o^wBZGh7Yw-!=e|}t%HD)gU
zoocp<Y+Nlxk$uB`htrsq(R+#LWPdBtCAj$Y$Tw-2owtGgPD_KIA6AO{`Ik|twV&Vj
zQwdF-dlodxOOuZXlRot(qkF@B?=o&{{_@^3uJT;_xi?v-L)O|Kwvs<}a;UJ&8&eyd
zyh11)rOThEmqT&iC*}vc`pCiFXE=x1`u5E-i+%fgq)A^W#nxVMGyBTbD{iP3XW;<j
z`ZH+AvcB?^ZleOM-1pMmAb(fT6FlI;B#uwRXWI*UH#L{64LMxU;fnw9Es8E>MKi)6
zkNw~slvTib0E}$xC)aFo-jf#$E-u&#1*vcFnMvz09?7NgZXA?7Mt#(-v{7^#g~xCJ
zLso@hBYb3kS*_}%frzx~j|q8M1#gc<w5I-Ygj)@yOlma>@Ce$A^L1;G@&gda%B+G?
z)dtAj+LAtW5gBXr)RG@Y4PYbV=96H_*Z4v26EBbEP{r>J3Lt9JucQJKP=K5ofbrV#
ztT%Z&Ko0UMYY%4(qCg=7<!XYq5_T*Plp}mr>Px8o*AsyIaiH8#a4G6d{un3+deyLp
zGd80@rh#%j$GXi({Xue971KO(2g$X)I_vDP8V4K)^wmLfSmTZEY$p#r|7KFp_qUaW
z2ugoC-HnEhfFC`1Etdr(dm~9Nt?NQ&50-s}FR<gA2FroMtv9{N86><Sd)rsq{1__z
zG8pdk1VBd(ktYdHG`jpPL*y9_LZ2!+^35=Lov{9KZ*qN@EDFDYat(*en$X)QSGX22
zCY;7U$wE!+HbwKI>!}yLNyczFq;}6!fJ>tQ^mr>qi~fVndK3;Wr`CZA2F>RtUOPp_
zFJs5Wbq$C<Oso=|THbu{9UIttV&-eT<XYWBNBWJBr+KTOKWLzd8Jv3Uz^d4kSmdkA
z87XU2>wLjUI0NrPnr;!xk#-~HaF>{JoWrMPffLh_Q??c62TBxoq&yy%B29aC$3&vO
zmpiK1(fEw-S?;e-k^9Axn>0$M54~P~g4~;<WSfUxSB;j_@h$5yzJ-mEv)tQDl-cWg
zS)xzw@7l(c&JNpCc*m6A=3U!tNBpSz2;kR0v=xN|j_{#Awyohe#}SRqj@unc_w-z3
zn!v5R62OX{z?$V)fKuBg$cbewJAZQ~%9Bxj)I)rkhO}e9xjB>M>d2b<09myr$+#yO
zi^y|%=F5MPd1#W{!`b4u2Tzu30$ikDx=fa5c?4z94wQ9c9Z;P6yMnf@`$tz@Df+@J
zf_~V)?SorYoV24Iop7MrNvnx;!uB9f49|;1liL`}E3n9=F~Uz%D9(pKz^Na<x}A?|
zBONkvb-Ms{?Hj#eCEm8rUh52_0efLQ|KJ(vHARl{$##mRyOp!(DNzSE>Ho2H9dJ<{
zO&snWb_9f@34#KOA_^*s<rEYZ1QokRk$1LOV#kV#3h3L1XY8vn8e0;3iBaq&_8K+O
zsENJZiM_YvzW?kyiuvL%Irh!Y?wg&Rot>SX-S-p32w!St1AFnk4TlFv0TACC4Tt-c
zGdoWkT?y|>qPTwNh~MftaMwetar7cGmG7IMT0?s7(2KXoP$FuYjXz_@!e%&Im73#{
zT?<Db^AOc!Oo=4cZ^|=KKO~EXrjWhwGn8tP;S<Hy4Uu+Xz0ToirYp>C9jQcj<UnIW
zf{ShxfaAvpRj=L^wb*YE2#JM;#CH$xMbP*RuOObH4nYBe-gBe}Eyo81Bs@lTZ2RPa
z9*8G7186e-?gT73w!=VQq`xCr2i)up^93hN7J?rIABasU@`ZOeQ+o9DmD)GDoqKJv
zlI@sLl)4x&>Y2-S7sQ}7uS5hy)yJRg69`_xm+d^xkYz&OzY7Wf%cS*~9iN?y&wK$b
zY%KMF;@_h@sI(}D??ZdEkI(!?FUq|}hZcRILnnS~suHCC%Yb&4$W&@d%`ZXAWGdD5
z4+%6dQ!(mWQ)*qN(n89_dg4{4vcSEZ1jXnLYV09<Ymu=eOTnGLB~tnF3MNBM+|dF;
zoZ^Q34JUL~@Nw}N^|VVpK(XY9IEe`bV4I=dZ}<RDwh|%rd1K<uvN63kg7^%|Rz~X8
z0KEHlwh~maUO4&(HN}W&1~D9>#{8QMBcVYnPlM0z%>@%~pHMov?}O2ysVfw~OFEZ;
zp)d_3PKQPgoUR19cl#H{b1a)WPX|UNU}R5MmP%7zns{YJX)e`AVu+%wl;#HX;vP&n
z6R@N_I1F+G8PKoPKw3tl&9jlUKt(I6WIg4fs^V8N`d1o9yNBucvL{PDxJkv9&W*FC
z+-0h=9Jh;|G4Z$=PzYB~oA~!Ll(Ulc&O<)htYntYJVgb64qgpEBk^q(RzwuWSU&kJ
z_n4`4llDI{@nJI+e`#p=Gd^pk(vrsgm6^&F_lIvypLNkxn~5L!S_$^({WqD)b_OCG
z%HRw3|NS+Bp}L(wb7v{z^?gbh9dcLAQgn{erDG<(X0}pS7xOmv)@&uvQA$5*;`+JD
zEXi`j#Q9tpYDo`Fyhc>>@=^^X%JyzvzP#%Lq8n#BC;-trK4)vZ=ryOVOMCK7^OPXz
z!hI9JI8Rw5J(+%w51+3@N>>k=a=)LioN<&&{bJ&yxDqXW?SGqZ<_gzebbu5jE>s%m
zcT<WjRJOJ3`2_9rAraL2_swhQ2b!B_gIBHDQ_RVuA-FJAOCs3|NjgIk;o>G5Pf~=#
zh%UWyvll62bh^!h_&<vkZ?6^)9%3=O^(IVV;*l#>r<U93jqq=k@1z5etzW-YF6nbV
z;u|a*8rAjov50yuT0skuVW(yAbIjRGl=;&9c|G}vr7&b1fT7*VQWS3vrs{1=mAcZ-
zzfAneQsrF6Omw*Q3+w@DQK2-%Y=&_JY!0Byc1_R}94{3k$QV<W)P!?AKhkGTv+#$8
z6=m+jQ6H4;yB}ps{;R@Js_>P#)7yDoxl{*y^@lyQ87iL00Q?%kbAArKNpHwO45-ae
z{|?|s1io<t@NI@0Cxtd%CLTt-5D$Z@QqB?NSQlxy!v$n3L8fbvmI4xs0@hI)q_u$5
zBuH<!3=(hcOmr~;A4_GEfSC_|8cHv5B=o3!u*Oo71)JgP+sG-eRb5(C5k*y$)FAIg
z=|j%}dFxtOX(<6-{~X7Ctv8FnUsj=)y*>f-697ZMo)C~b1j*GPxdJjAJwAH55)jkn
zp^5I(X`OvHEv}Wh&i5e7VHY@w24FgRe#PXFS6#FPNc)Inu@oadN5H(ef>E&?{+gHg
zB-y9sN*AdeAe~o0mkbAF(h4P@tjnV}Hft{-c5#5MTLE`h$@6dEX+c0Ol#u1Cb8l>U
zHF4|@xp^y;%Fd;||F%uu9ZRQ6(}MW9mji-$>`G-~^%@ovS{EvQE8&+8JaxrSf#4gx
z{<h_{z=w@3CjM}x(!1oQt~94EdSJ@!yoxqke|Nc^JLr352fiB}K79uam8w5NCsq30
zl$-sda#g3_@bICH4-XkpK?*u=;#q5zSn0+&6F<II@iQF%U=xwl_K;@OyYZYU_x)Ps
zqNB9$7gO%}^-7eZwDgQAx8z2pfuno3%NS#u(FXgJ^ZW)lvq@RvF~x_3-ae<0K6Bk_
z$}PTG@zhB*cS6<w1OvOv2@_BLN%58%Au;GDrDkv`bRls))MB}$bFl70#R$no_vCj@
z-uMLWrgrr3zHnT_476+}%&7v?3H|c$C*_KBRgh&f1mTy=xpP|;pOBBXo*0Zh=w!eD
zj_35v;HcvOVOpMrCydr5_`{c%9_k)YyhChf44H#?!+(96n8*CAgy~=31^UpRmFw<p
zFMtQhg*<owD&%d-aB1<>d;IrpP~o+pJOAFMM0h^EK~#?%8=rX;c0P=Ko1x4e%&yy&
zb^58d8#&~@*sct8l;pXv=XPMLr9S%j%?_nb`SHI{!RDk((_Eg#+e(arVfoZ%xC#~3
ze5cYdV$bQjn9`H9GkJlS?-Cuf6Oy55;kDsfoby=Pg~2=dQWM|2Q~6TLzIu=Q?t*AP
z*=yplyD-ac`V&*vE~r(1%mw9kE48K6112878(z?DS515%C8XmfK4Z61v)(OeEKPsf
zFSdfbjQS0fg32|tozOqeX$NUw5dd~f9IG@hG3CBMy^a;W`v>gDWE~9*`^x8M;g+-+
zR{aE~>{Y&yHibRr%l2ZV-2j2d_bQS8<<Af&YGc70pZzAyB|ay;gcz&{83l^xJ|#4x
z>;{Zy8G51HQ_-{gFt<Vve<!BcdE$PVef5OElvxhUy1<<KnnM52tVi8u<23Og|1KWf
z-crt1<cLE8I`J5XJeSheWuj?EtP)g-^)?=?*YLyl?o$FwH~9l42H6b7VMkc@DV58X
z1;F~9P!Yeur10CX1eU#d39udl_B~*&_A60kmk`WHz<L2@-mkQDKeyWiE7}L@5?1t6
zi;odYv<Lg)18cF{#7zejpUOW~d1TA`!e$tVE+K7^{kX{Sff6{X0ZM?o>;NJw%AGXv
zDQ=BDq?}!#<DgQ(@JmBdA?u-&@fCXfij@=(_$krP$sAI%Ru~_4Q0eZuX06F#AM~qs
z;6W^Gj$$lt`6<z>|DHR<YJ>j^9L1;#6q`ZaDfo9<%kV4A7>*1G#J_49MCjPe&lhgo
zf)<MR(V}5>1EOvYbOW59H#a8+JDI~hBf~iRMNy^MJ4}4Rmc*LfhhqGIf^*LbC@}62
z6l7=_zZPZ$QwBS<FCxD!c#F+YK|mi^D!kJn_lBikeR^#&6b+wzx=kbZ1BWoq<59$}
z>$;wT;c>c6>-w%gk~G*C+a)ZKd5)s|nrJFN_n1&ZF!tZZXMXT@nNB+s7@uAjp+82A
z>=9Qc$V>QUox|{#9~s#r*wg<OzCvCRZ=w^rT6nyn${ubT*`rgL)t;IscQgKSIju+4
zGPUiHh6I@ph*!T^c-=?5u8hm{^;C`7sr>JF-S=aAL`kl|x;C~)`!de<_ZsNE4acFT
z!bJ!ez3iwGU4PXa;uJiRZ!macchL9PE%Musw#-Jsy0l7pZEc3B|A8@SSsr&g2E(nx
ze`Gdse#c{uDLzur924(xO!57qn82bd0Avg#e2P3a6@CljH`hgn?s$X_4Mi(3=Wi`w
zwC3x#B>tuKRkJAKb@<_bEu{E4P|-C`_sK?E9cj*a{+2Nt^Tflba*-$E+3{|NEKat!
zTK1Ej=o&bH)0{*GNO00f2r48&CKB>@@nViE(HZ*L|Iebp_XR9Uuo-U8`hSd#EAs>s
zM^%kKCSi5#kcVaJ&i_FC{>@vB+ken>`iy#$-QPujZ3YJX0rV{=Ji&?}k6?*i7J+iZ
zX820fMr^%_b``MI;hJD;g}ef`cK@jeTgmlgG39A&T~k|#FeV?GN97Zch`V3^e`Dm2
z1<i#-{PG_dJ%7yO=TAT)=Ke?K4c)s1Cm|5MzlJ(G34v%KkcjfYqLg3#Q&9fST0nW!
zmLinX>fZ9_pBm+vwTSY;n8OQ&TDW#lf4i$<r0atzx<yF$KV)bJL-9`eKq5Y>Ny2_q
zM*k)!<P=ND84at!x$CcZeQ*7gc*o<mn>1ks?iAx8Zb2UZcvA7}Q&J#!@OZ}$w%gDk
z@$46i+k!lsmA>0qq=5O}TN_=x7}&c0Kcl)IZC1iD?<+g{2xR5;+DG-;3>&UN>r-wU
zxCz)<d<Wv1iKm}Z0(2K1@^4Qme$rvHiSH)BoQM3cQ;P4PThJU(f}1R0Q7Ybwi<P#c
zzwG8lAW;+~R;|Wd4YN}rX1OAmu3FRTiRHX8N5hRR#J#@_^Ui6-5NXn~9y};`;ht?I
zEin#-cMT-R=eTT!AH=ZX43yB1r<INp+iv1d4=)dKGCTd)7BS0blqe^&(O5Z*_d26=
zmQJJk-Di}9xWdlsH>*Q@<|EhmoMPyT)~Abh1$7VmXz4*C8#jq$9(L`HFWYLs2Q}aE
z__MIV_Bnpy!_O-IO%rYi7PY)zK=CS!X@O5{g3qcE#v=xQpoUni5HVd0ei)Qz6%X%k
zPyGiCD>vowPiK|-rG}E3V)mDV!+4Wl6;G+=&nDjWSLKwBnRv)K<p*ha)pz{tIi;p<
z|3_{+hjn#p*gOr+D-Ax^!jsP{K{a7H;QlkAeMK-}0(&#%Zy~6ilFY`^@2kPQ30ZZp
zI{t+J9T>(hoL8EbF^6n_M;YOp013Q+n6@w&0C5+TnH3=DXkXjk1S1T$3x?C$)nbZ$
zb^+f0!JAFo_cx`lUkK*i*eRdrbuQU+FdoT;fZH;{^{998Z_08hev^qe`CW<CWt(!R
z{tj=1e>rHB%#Wo<9LYO^L6?wIGd3r+L;@>@)0G=ceE&tIt1i>TeJ){L(sT>_3YV1D
zW!IAULC!DP3|{L^{M;oav}{@-?AAIHFZPF0vvi?I;G@-lD0M<2j!?lybkmo=Uzh_v
zVp)iiz?x$WJVDt-e<+7_Q%pSdvhs^dA%f;%b$yT?rZ*mhbT)aA9_oIE#0vvFT70Y5
zW@ye$eEfs-DpF#*dwkV{^wZK;JD=r_w4_Hn>c2aQQosJGT#ynMJ>yvq)03p1VP60C
zFkRM%oIqZeYp|x@Y<kA8<fS*3I(=`-^?j6H#ZhYZEqdc|dNt{vm8RU`kJGVo8_?<=
zpY|lZmG}A|!1Fyc8wtZYKBp0my*AkhOY%v2u=lY4%9W5C{4_nXN%67NyIH|wNs3`!
zlk$fF;Bck9c(jPes7BRjNq{@{FyoSQg0Nt$j5hH$&(b~l$y*3{UcSi0?>|ki+NAXu
zt;z%BfGMo9#pTbcTvzqKs=P7^PP*I5`0^fGo{7+(bHa<079726wNOwK@XkBW(qpCL
zE${Iv&%ux&$Z5yt>20N*DEq_n^x)tX-w8dR6P5-(e82KD=D;9^F9bdO<axTE)E-5g
zU!<?C5VA>oU7%25KMQu)->9ZxLH{DXbzp-uYF8l>;stNu6en-q-q!bc)0gQ@rPY7F
z;L~5Gzsh)@3(Nc-0umrml++<`LO2j^($fgB>0?YfOY4P6SyZ#JiFk0s;=%d`bz8IO
z=M#SH2Lz%mDOX=$C+Gmm+MXr294rnyrI<^$ie3>lPotVA;0ZVAv|L5z`5F9Ly8}X1
z&?SjTI=Eyd;g2v7@Yhljm0BAhWiu=Vx_H?h!2!#YD=&EL>-30{-9>GkRzb2~r<a$W
z&NcCcuhYY%gGd~GogQtNHWx2SElR5&%DTTv4-K7-9>AFf{Mv~i!2l6{z$PN7i!G-w
zzu>*!phlW2X1_^qq<8VavgNr&i4PqFi|=T&Nc>+*Yzu64r`dYR3Q=KFPM=_J3OO7+
zmB+qK_w)@1cAh6@b1h%=7~W(_Imm~<O|M-hT9mGYT$rurtV*c<=gk;+pR7t9_ilT%
zp)Bvj;t50tFUQLAq4K@{@+P1>dZ@&Dv>ify6?OS&Pt9FuY4h+AkIhqByO;eI7Jmtp
zvs?T>tTgfEc?iL~w)pdmQOLNEr__y38%#@<^&-j{gU%Us(tznti~)F<V33oi9XwV%
z8mb)a$zvWVxl;C5CjQ}((oa8Z1BmPMSg}YEgG{{b6F3w6Zam_Lo+xqd^B3aX;Y1Wl
zqebD%ps1fBV%4&(kwdJDTU@X|T&rjEA6)UU1rNOaQ>BXMoz{<S3GgF`Rn{OebmC!k
zef?C4@iZ6BGl;wwGfn*7QzcpNb^ZkctWFP)ly0AU!3RH6+J&7(uUJcgJ1$w}plTqQ
z3#jc6is-Eb@~-uSHncud>PSOj?*~3tVuHV2@yzBDiVuCeRK;ad`G+u)AUMgS8*;)w
zehI(Sb7gnQy~}~=ib!R?W!pMm-s^>OpzPSK_8!I2{jDY*@lt7Sa0#Lf778>ub`T>8
zZ@q}wRDB6w-QvC`e)pxaHS+aL&>Ja~ViMvza)Mm4W`cvbZU_x2ylyByM>tnAzJb5t
zl~TQt(ubr2Bv3z2*81;NztW;x74aBltg9(LK|ORSVPO*M4dPxa9i)oWOnlmFCC>W-
zRto?3qP|eFw_htsQiW45c;p+UicfHF8eNTnyg#_Gn=dUi@!@Y2Uzc`}Z5OxZ)US0(
z%)fb~7)yTNi^}YuW#TvAC|)gELq>$#onD9g$$|S5<Q;BzA0(G*Nva`JBr(^}nmyjU
zdl~*5Z8pxq;(k)=@X%7Fh$CGsH&49aL*FW0;-`%SA9bj==*SpOK>9);1YnnDy>9#p
zpfPVqMLvjpgChoJJpcI~8{~Kx2g9}OJ0&RN<sMR(8@>_h^1gU*KwY#$5eNlZeHUdv
z836?_Dj()8VB=9F&y){4e3<Z#5?<?k*k%E1Pk8kOO!G+7(7}0O72rzy1JMqLeZ*$m
z+(95$4M}rh>{nrjyi=m2@1~k~iT6rqc-mAnViYv1wLgBK{jA5eze4&fe;<S5Js}kD
z97uc0d)Vk<C_CXj96+_QQFf(}jV8$4{9f^{nneY^5(Ru9hC)+Aj4fXQ4!&8B3G{zv
zoA~qhN>vFG#Qi@gF=fYOp)OkK*$i2L4f>$?mOXY9b!`#_dH^=}gJLXST_<*8t+W%2
z%8xc1FZ8VeV4n8@HC~3uczsl|LzA&u#4U691zz50q6Gb(9C>21<1?4dE@^4hZHHjJ
z9{z|8$t@XhOny|VxYs=L!bSpPmmN#MkrzDTlTxAFMh8;q3$c<bST4(-5Y!pI6f&Fp
zNogb1V|RIpzZE~9Z>@Dv9(!MvNCxKxCp%NSN_97J<KG~0!NiArz~9Pfebf>Zz4JFb
zSoM%Mw9zsHPx%K?R{Op%@q_;;ak?K(ytqwyCS`Yn9<?b?r5uxK{v#Hozqbe_-5uFL
z-Ssy-!;$@^U$YR9R2}<8YUukA-xp$4%XJ~c2^Wl5&tnGwH~MG6Sd^HTbT-Gt$4P90
z^rg>3{!U^Q^gnSF_SLf}{gnksb<neBQrR)EG4(7|??stM^ej@}lrlf)S-AcnrNW$8
zoc_vuq((ZiDiwMGR=AwRQq&vr?zDsCxF$x&4ky%gnXvCVv0C~Tl=3ac+UXrBHMAIu
z)&D*Zsh^9ndiuSTdRhzwrBN!hI1A5suz{+wLYbi6tKwlo4ryo+V`6-^j<Qc8+q%B7
zX4JzaZM-7D9e`+^53n{GXbaV5xStN-WB`G7TcFLL(nB=JIRWvdf<36d4EuW=1-v(5
zHYd0p{BSM3{t<?pwT1xqp~x4bw2i<~gpIG%2sMDEx3Pz)qym8*ieO*-nXrGPO0330
z>>7lfVVFg5Ty9779u}C_p(U*ciePRKR2(Dl8Vzx=K<q?Cc@e}cf!LV9lLc7oE~CJn
zPUQy_!LAJK44YvX!P^%>cM<6C8NdkBENI=kHPnpT1V)@g0r>m@0*6s0&H&RE2(Ij-
zLs4eq8Ik8gdDyl<5sjW9;sx(a0B2kka1DLBK%YWyI0W!#Rb`62zLfW)$it@BX9%?f
z!YZnC+J7Rr34|c3p>IAye1_TBRKUNYf^7=m_+qO7zg7UQR{*xRtKNQUbA2jO{@;1!
zMc!U2XKPr<rbqjz$PWaz6akmKDBw?Jth-CGwUs_RUq{D@t!Lo*CkMIhRGLR?^FErw
z$;aHV9JD}bR=Yv#VVDK_;?Bm&c6E&XW^DLc22a=FMjz~N2>Ab%KkN38&o0fXN)Lyc
z_}<dYNAjF(;#W$u>J^Wb)I0P$mRSl~o=#A14a6&VDR>ZG=WeY{xs}VXV>;>URwn+e
zEc26;&Zb-!7lwWQK?x@A;mYb3Gl$4+v6GkV$~sB5fhNA%mGzgtiZ^k0H>OC-m-pmL
z-B=a<nYq|QI^o7bbkel(m^0iNbFYNyv}jbwE@YTJSaoUc*q(fk2lET<cpd&xST|jv
zcVP(Ij%n&R8FUt^<Ce`#3k)oxVp>1w5Nt$?+?;O_`b$_a-GtKajMYOs1KXhw`Wkx3
z*^>oTF0(|lfwjGH4Uud<@l4&0jbqFvojuv4Qs-dwBr(hcIzIfbD0iMxg%#)TJlQDy
zbu;Q4?!~<Hzf)?47Ym76{N@S#Xe*;()6tcgM8Pg{0)nqewBaGOKy4r`kmeP3Ek4J8
zQ7l%pUTlmM5Npbnz1bIz(l1TWUp@@qv_qnTFPkNu?evgu@nxA(d}9-@SDppx4!+^t
z%Ci({bgGH(EYJL<%FCYeE9F^|Zmfw{@ng9mONT$TB}_TyAfyTN-o|l|o}6OZW`^kJ
zZ(-9){>&uB^fYm|P{d_aLL%Fr1tXr!u_-!tlRxV$eV1bI+%gSKd}IYSPMX!gl>4*-
z^LLac!=iKvWIZIe`lj3=fecZ#dy+BHS7bj*P3xI*jg=TaIy|roQo*dJUW$|+=PnIp
z4;{TcQa)QUi><@eeN4IERbzTb$=U_W>@YS*st$@8R%ea8Lb?NAtS`imSc>lKW#Tid
zv&z!(>L#9Boi*_3azl$7it*C~h30Q;*M^~zNLHQK4QJ)04sA@i9mAQoqi)?BKBNYU
zTdJ9Ic@0(zAvRJ^e!3=WAa#CxmzRuS)ue=~CSEs!1^S%%Q>&W#lw?q=`f?Ra`w<Y`
z;e8(Rr4cM#x`HutHUg704~26i0z@U-OMXsNnJT7S5asSD)j%EXYO!eDiZ{7AwOBPr
z=~xJ6+uH1)Bq1@O4x1|VwA|&6QJ|+?FvZZY1nJ&`yL@~U-h3$tkvCDSMm4k3%MP@|
zip8BaY&KugNdDZ4X;I0P>sXgv!=`yf6TelD)seiiZ*lKvR<GpV9tdl}akqH>bxvo`
zVz?!@b~6N5N3#pQ$|zdo;L=gZ_D&H`gO@m1QkTEUmFu$_I$ed+d{#r|@4czzLt6rb
ze>DOLsK6{7a<sIHd&rM8WE&-)+NRvmjaYM?G#j0^uQBuP*L5h>?A&&u*b`liKVpnS
zaP6@v69b`1Ym$=~qg<x8k%J{84p5(eLkAF4DgqU&#tv~N-lz!+kY*>Dc+Vy*P^#Pr
zJC04z`ON`Y+l0kPyCB|=o3JQpDiR?vEL93bVtNd#7T7RRXkKd?!m1M3vHW2aAcoOd
zaOivtt6A|;E4;c1$c9o!1bvztd^WrAh|v#nr!_F~im@z28lC)xC&aQaX)GjVOf2hN
zLsv@+%LqmFmcFoR^X4ETF@fHBn7j@nS|Ofbf>=a8fch=b6!cH1Z{lH1nOS-i4aam-
z7FF_7JekXHpn=~vWi@rL#^CGXP|4+xKff8PCta?G&B11@n=}E5usA?4LV4dfrj)cn
zE!hn3Tfl;jV-=*!NO(18A%^~S$tfZW1O4aRb<iS9k=3p_>szv}C=!9k{mt1|(!u5s
z%NC%khPx@ZT?^*q=y~7Y<iL(J!X4kev4$1{c4aja|EeYHE^Tu|v~x?=wDK@FlSAvA
zDhZI2$%0c)EanhWT!%Hqg+157ZA`pYJd2QgQK)Y`G}1v=NKQNk!#pJN;#sIWYm6Bs
z5Ea<nA{AR;3QJ&>9i<2tcq>{lYqPkr!t8w7O9)%#;X>F_``d*LLS+{=4-fR>QTlk7
zaI;XQHp3qQ0B+#{folztM+6jHBGmIosOMLStdi%YCe&3&sH?hvnP<yGgw7%4QT&ce
z67p<@7UDMsz)eZ4weH+;j$49bOKt$!uofGea^qVQu@x%9@7jj>I7+@49Oky{JI}FU
zH2=J{bgd5=*nuI1rD;P`ZqsBIrIVtrKFS^6o~1ZSol3mrS39sO(n=^3eMk1leSIyk
zB)X6#agaZ$6DI4V$|l~u6Xbl40S)QIT1qFOWv+E%-&F_=q4fsc<TrYXql0zeWAa;c
zk0K&FMVa_FoiR*KLIGXt%w|ZLb<mkzSR?5Z6wtaZEXYv)^H3dZU>`=-oi1#dR1pcc
zF3g=T>dHbq?^n_qbu<Evs*J;BHbeQ^CjNU@mLavPgqgP+RPeXGZ{^PI#{NPx15CLi
zda&z`?nzbAsLh3qx{JQ(-IFcxNE=8UiK!gpjqYwUNP1JQM=EQilRlL+@eU>yRiaNd
zZ5xQsGGQUpu>mISJtj6sf4e?X?R&8SK2dR+j=PLE2pxx;x8Z_@BLBS?R%pYbf%tQ8
zwnr-STIM7BU;$=+CG!`3*lg+jhF5%AUrdf>e-qdB!#JM^_Ezi1!YfB%AXpFJs9RcP
zoVl#{`MgKm#-azWnAne1YIN;|jCSPvc0dMPc2zy;-s&uI?FEdXtRFP3PDGNToQ%KN
zT753_Kl`y>lFJt_c+8h9wSp4_nOL%nJXp}j2f&(LHwE%9K;HW$t0XN!;`W!Uh1Bu6
zoEz4k{qE?#1k~>D3N-srih^*I8_4Fmzx6|g7!&k^2s#MDj)5>AR<`KL{RTm@y5D=m
z(+05%(tU_V!dK|SiWq&<zG4CKo6zH#f0uH}9zh+1y?_I#gBqo^!l_EX%Hr`RfkE_f
zffhAj3AJ^ez`_M}c`|?e6<Z*!fv{A5H!@o1Y~lw7Gw)&(z}38dIN;OVS6UC?$HC~N
zzEF{=t6F;b9C{^V!*O>gnY(Fa;1`HS%F?&}3w*T{pSo*7BmO*`^5n`-@cz7iNOfNe
zK$y``R=&wwD=H%5g_LClFGD@(Ao)=#LHug*81;)F8YhZHTjmKY`s|hHpdkKWC~M?8
zr8ITU?#-wOYfk84L1?R&|3&DdWVo$|v9VHY?hAf>7#lAIqpt45*&V4LWIJ{Qi~yGh
zG9NaA1^bjRd}b$!(Tv;3{Y-qr2$n3RuD!cpBnz+K_CB@5E@#IDp-#IkS~Jdx$Eeeb
zi1!od?Df20La`Zc-IaO2k*tYiD-N4*Bn#`j=ANA+RHm>yUo;Od(w)vhEAZVK9LlrU
zu_!tKlKj^~O_C>z$NXNdfR|KFV@)&a7e~K*{UTozlT6|);~N?4U?hu*VlDxvidvjc
z#q>m+s?Y(O(eJnrH;2yaYvb%JCV{*jSgq~_md!8*<?ygsJd~<{E@9PiBbxCkF21ov
z8M+}muO^;lfzXN`1MMhh2*vOR28#&7YAi60W9$cvf)UuY7-pSOEJ&(_#Hdl=*fS@X
zsH0d#_q0U#(Xe}F{Qzk}%%mrRd2U=A9x7ddzVIB)>Xt3xgLWSgk})5!FGjNpVSbO%
z!Z)JC0Q4~V!f-QG)(Vn1_QY;wV6xQXH7iGB(RW#o*?u$&DJw&ut))b5k3FE8#;~Ze
zDUVQFJyF|Qz?zR?Ou8h&j2Xj*yRUWE>c=P~Ik)T@oyR+kWr-z|kb$Yp9p>g(tO;-E
z;Ex{5<dVN<l4Y>3oQX${V|67X-~-38IB99i7ktY&*0$3lO!9^Mo1fkJKjl$>yaT((
z*e-Y3K7F+-35K&vCFtSa_PB<lnQH*Wyfo4qQ3K#Vn)%_aoZD$U``!_|^*4>-+?LLQ
z0?ba9-S5!z;?odOGdF4C3kL<R<1hA?%ws38kb(DK%lIbpG1mn8rUD$AZ!G%iudoZ~
z)Ev%E?U;(>GCdYVxomeD*9J4j_T%Puw#*MYm&_nQ<8zEyKmhv8W~hbf5+_iy+%<SZ
zz~jv=BhUb2HOv&}Ca{Lm``SHu*@?{4V|6qwIz>37a3nkDM)%~=6ERV2LPDO%YU{wb
z`4d@<GVPopRjsm5xMXj{Eo#@YyrsQ=%lsj5{hg5Y-?4`2K&d{7RqN3LL)+R8hpo{*
z@{m@bVKlh#xhy?b#GDJk9-l;AdKeQUouny;nb;bw<#^X4`Cb7*0a|JC5Cu{BX%Y*S
zPJWX4wMkg@{aIQI+Y9XYNk%jv^`5X5mrNvym|lkF+sWuV2R<x=h3U8Xfh*r-umSq6
zNadE9%=$ZeCpRFzkS2nzfx``h6*k8cna`NQ+DIdw$+_32unCUIW~Tu;MS6&Mj!1*=
zTSDErY;WmWq?<^)B;+&^UDOGKn!4z&2D5h$3j!f)GFhu|w{Uv9a8)539!T^Mh`^8o
zbV(4>IGKPuuF<8xM)u@^S<F+qghc%;R$uo~=4n|h#{U^<k(|uQC@ogkxVd>ZJz%V0
z^q<dSH8Yll3airzd_>si{ko_dO7$j?>|viBu0ppYgVhh4Q;+xsYdwNPa{1qQGkSv}
zNWM_G#?s=!OwxeUW8&c^a)d4l5Rb!==TbUPmxs~CGqPD_eU~xoY<x{N8zjww`QkN=
z)s%W7kuZ%_PppYy@!xI8))UwD!AG^O-8jw>Jsp}K_t|zd^>lqFBDywyDWGX`&xZc|
z+BD{?pJ)J|KTcy!^sOk>csi@952w_i>8wJxyc*P?ZFhu-T^A4WVp=pZ@vs;<Rx#C@
zjbj9)DzdE`X|$P*<|ryXhH$>sAn5|)1ev@&ot6u+kGMf${i>ayK8A3GT7GoK(t;gE
zOb0$guG1u=E94#f8a6|@vN%<vkgCRX|3G1(b(Z8l!XTl7bCF5_6Y{+$KzD%1$LBN)
z6rfV^=JY^(Ue^&@xr`;&9Ws(!d&jiGZYWGQ?j_)jV)baRr>c1E$dBl@3h=68^dDx>
z+*MG?Gse8VUyUH%UUwwkUdC_1u0^1V4Fpp;@Uf-J8gwu_#b)J?44upLc331pcNws@
zC^9HkXgcbtk)Y6BHN3Ru2LT&8?GM21gCl8seO%3@vZ#h1Lm;jgn&Rsy_z(@Q!GZMN
z3)7&u0X&IDt@A4YDBYjN%P;`eRqKiGzp^$u7{~K+K&!zGwC>J<4F2hg)V&;R5FDmd
z;0!n&nm3{rK81-Q&j89m%1~!8-;8C|sEfb3E(Bz*cnB{hB;HdzOh%4%5quF42fcul
zMYeUi2Kl8bmF__}qcq570eJ{9wf5E^{UQh_nsC}_kd6X!lyE9F(Li4akOv`!Ymj&W
zS%JB>xfy<fXq(J`G_%l*i<qS$6VU}S5se5+8n8LdVhUg}Hbcs70gEqy#X~wYSaJa@
z8M_V|tZM-bs_{7_0rklRFd6YD?@^yQ-O%6i$VkKUfJ43_9)cm?dnRo2GRI}UdnOC=
zyk3Py!yXY200#wy8Rp%Tb6?G5Upwk%zvJ1nu%wfY%KY#wEDd)ak$KtKtTE=<(G#)s
zpUpgtqw0MoSysFZ64X{eAz3|LHOac7!RrBTm#lK0=-E}XS!BbS0VFbMWLwgaaipO8
zqI@84lrE60Pyr|+SvP`ua@RSKtj98!=dha1{(gpDIg8J$CL!ux^ADy4!V3b+ZyzKc
z;)|g=i-sy4`T7xvFr9=qR{KoPhNE)sg*k9+d-XprJH%@K3UA!|CJF{$mvi&xvJQ??
zzx%Ks<})wPRV08pyGx*Q@dBGchYsPJJ`MMk{D71*A1=m8A7s8}KCA9NV1Z_Y#MqBH
zr2ZoFS&LYCE-hew`qmElCBM8U^Oyy28lHJC^Dh>#<I;-#G7sVGn@VOUX$-y6A-?{3
zm#p96eM3MFOcZZWfMMPu5<Wc6+^Yme+DG<-k{bUXYWyz&xSjv8G_uMsWOX}k^)ABy
zz<mBMsZhZGjx@3j>jj`AjcnY&i;>;ipD>cJ>w_zK(Qh+?C(~QZ&IA2>@^(3J546QX
z#IlghcUR_o-t^pkqUnt?BA^DXjYMdY({K3Z`%bKk9rAEdv6E+feTSW}A;bX)r&P+L
z5E<NFV0P+7Pw?tG<k2bGVe~}TpypvY=QNg{40s|t0#uQag+p!>N+r%6Ln*d}M-bdv
zU&Dlx_=OgoGnfe3omRunyNR%k$XpQL%gr$k0o=~JVb0)P_BW8-HlF{*yJ)`x-f3E~
zr2rI>-G6+0^5@^c?-%3OlP8Dw!gpl8V^uOP-h~8LhZcstmxXWU;f2QG;iM6N!wgPl
z*(EXpN{Jk&dLxT8ilRc%s6oIk(xwU|B00w90*dh%42h*SmDS+kfZN*?R|ajmz8GzK
z?NOvn1>^CC@4wpgL;#Ak>3bj1CO_Uiht=({@D7?1MeYV6p(~IAd202~$jhSq9Ah5=
z1$pjJwM1T;22TRqPTqpjAn)n7tZu^_?nTHe5Z4p<IEGzaXySTV0E&p~*WPxPPeG!9
z<*xm1gU<1^bTT`gpMjf-uP<SpGEOurDt+YuFO)t5Jrzh_5Iq%0Ul=|8pY%1urd@&b
z5l_I0n&f~g6h6`+;6zCQeFm)+A!)2AuCd}doLzQSY%c*;Tv&>paxC{>tjO~!V1*`q
z9|WLCPi^rOn$wFrFJ>;%JFh~1g!<hCJG{USl0X;17UTO+lE56e7Y=_1Khd-v&$#tF
z7FJ~}b#Ve@5g$RufP(?{KrRwNB)q(3p31!8GFGYfCOCd+NXF9^I~2UrQm(Dfy3(Fr
zj<)!hi3>Oc7GuLT!B7#)upbe9L*~bpVfj2~2RuH@Se8^8iL~WxDCVI}OR%r99COpe
z#JjxK3ZU<UnjWx%CDCdSad3RsN){4nOnw8Ct+<#bOA5NmACO^vr$=M<3@w;FvBmM5
zMMgi==8?<Vd-1&|8<xlz^#>M-pOx+YD?vUt08dk~W}i*sk4_2LXOsA44ffe2J}*z;
zeKv{5gS8;9Kb!+2`{Nddna{wPQGN;LeUrgy%hk(I;1)mX0HD}*IQhJQMw~nwr8V*O
zC9D%yu^Q5=@gI2k?^&Rq58iGa1Pvkzxx;~FokgLYhRg3{-sO8%F@t0a8vG2@8mzlF
zZjdDE4!b-2`c9NM1_DI+&0vGI8fvo{Cccw}b}Eaf*rUzsI9l~cL3t$wk?2g)WI5Xl
z{u`^uOOf-i66N#}Ids|})FpdLUIy|9KN9&LMSgR8$>oS;wf=(WEY#^H>I}2zEJO&G
zH9*|kXMBN;cg$2W<b7W#$g~++Uz8p4d{D^dKn*j@cSY79k#+k|8Ec}}?7j#hu^RAN
zD<Ay>TdBX(35JsYkMKG*|Gj{(cBY1*qyN?S=Z^n>-|x|2pY{D}4fa{z_p$tc-+N;S
z!hq{<N#)mnWJ%Ka-(()XnuXQM`V9<!d5;**?tlz-)Gn7U+5UhExt_HfI4%OG?;V+|
zt65_y7>QG>S)*#N$)Wt2z0v_jYTg*JU-7_l>6W8IULAOEZp%D!4c7K^k?64o%aAXT
zPzdtsyxlhW0_M$`HO#ww@!NtDTHVB025xhNfZZhupWc!etYxi({<ufpfP-K;4pfUA
z^DViE2Z$Dl!`89@{qPr1zH`^IuF~v{GJmp`RS%td;d3z`Ax4Ts<5h^cIODhEoXnf9
zW0jgm;NCqPIo(g(GX{x=!B9wG)6q<CXfolA7}-w5S;XgvT5!CH?muaK4qU*ptHn*2
zYU^0Adre^33_j?Hg3DR>&2=Es?Ky~))??XRc7x1^uV;~=AI^PF<U<TAd%qNpMZ>Q$
zKe--69w<dbw%;d++$tXKfkT2wY=CG)=Cu_>=4+j5qGz|C1(5;ho$KhG4J@SO55R&w
zi^tRrEWmZeQwV>)pDZb7E1w<og-5yF7BGI-0sM$>G@V)}^Pe}ccG4ImN^E4+Gve0~
zDNanzpQ2z+(!pl<QzpV^^KXC3Vr1p}Q%1cMqdqG~gK5)K&SmkgB#NAMUiZfx_~4RA
z=?kmgdElSe-2?zi-}(7F1akP}!Icci7`v$^Ovy5EygJv@_2gUbtgS9ZL+ET98Qu1>
z7>j<~KJ`IUH^C6Jyo2cN2_=ZDZy@`47%CnxLU_+jEV#z_)`FSfq2)#=S`gv<q{e0$
zIfyCztEf2g&6^O!G2k(}`P3#jMW(Ki`QMvZdT8*O&%4<Jo;7<1;rdX!c4%@+=F2uS
z|5gFTiJ&RF1VQD*gNHUyj%Hq#?C<wY5|rhI7LMdmp`x#Eo<v{!+YFYgGB3Ub3$+W0
zMCzWaMM*_8dCV3Tp+A=gV$-%D;%+6Sc5Yz}^rI;Cb_<Kq$5N`{PjI`GrPQRKSfz}P
zPDI_(9fG=+;vrHf9pfCqyDa2b@0M^NZcY}Ea>%w`&>)QkL?)aA8l<{_Jh=hLMuK4J
zPf=hg4)mIOgvg74TT~bD1B5<Vt6)8@$g>&B66O#M@{NFei@85>D{C)h{0PQwWnD7*
z*27G0-hP0D3@S&qbOeBwu$x7>v|w2XJJ$N&qkqiXCu54#5X0<<$*}%urJ0XdTSJV2
zRA`7gJK{5^&k;)ju|BGFK>ul&SL$l-jv;HhNR_u%iFebn0}XL=-8X#G&&*)lq2){#
z1&I9V_9|uxIt!`#T0@KxG!SA>RN=Ud8Ki!zWbU(#)iK!ih_`qb)7~=HW_Y|u=DoJD
zTT=a%a&C+5Y^I}U$*L4Bg$l^Wn2a{U;jj#LK`sj}(|9Gssb9S1QXJ+x-yJN(ZIsj#
zQP|nDumg_h>n;d@N#4PZ2e02CW5wAcSa!)i1jgG8BcY4Lv}s@VmWHX(XeVps=7|jZ
zS{pmQn=i_o?_^<>c6|qPhHdLw7PqWqzi~mJs{?KxevDWMINkBF?-Me=yOTAD9&!Q_
zFb%BO?6}p*8jS=350|2utXKl;Tq5>p3s*<$1Guk?zWn`WnRng=J16j<%%|^S+oa8y
z5}NF01N9wZ(XtJ@5!rEmzsxV~X7xh%ytm~ogT({mB|c|c1Sq0|`sLzt_C_NuHcxDZ
z5x|bx!-BlxPQekd7jzV9)#VE^AG(KmORv9`d2-*r9(?H@wovK}H%a}ytb$i_4BpSm
z!0T`YDs0GJgx$SfEa$3wnO-M7StRGq-p`&pN|koWx!DI<BfV6*-=o~aN7!YZbR2E@
z?l=qSW_J3gdA@4ak6Z#(z5N{wm+dh{z1-uV2%#~*MNWK9ec{uyT-KCxf05-hMPx<W
zmk{0VLKXO*VD&0(evpFkIwQEN5Pw{dOrrzOvUqlOdy&FNpFnuQcA0NDfjHu{12TVk
zf`#BNueFG-(N;Bjm(1qE-g9d47L(ISh7e)r>Te5)nFSk~)^)BLmYc}RC+7TZ5Hso|
zi;GUYPsGqd1((b{qtSy0ay86(re%z!jC>L&qgRl(;8_ZPev-xNw#mHCDVCJ6YMbmp
z4xSofNI69{D?;Wu&DF5;_5ZQ(g4W>gkdx2C@|QHK7i)#GL{>i4HE&_M1*62k#a&Jd
z@wV<n5x1R!B%iulv?(--?M*57v`ABg;wW^S^t7h%;iu7*t(c`xv!B7_FJkkl$GrSn
zn7K|HU&?&S8NuXvn1b`kje)UBOg^AtjT2e<<UYNw^|&{`b_StOCGMnf+Zk-!B|J{y
z70$9azbzPf#ZZ#geg9~NwhiVY&K+P5nsk<VA!7E30Bpi6g!g2-VI10Rawqqgd@>;m
z8%1%a3}F9DPRj_5=-gM>p_-h&zo1b)PAk+(WaU$R>6*r5;uH7y74z}ITXw>Aj|Ab(
z{AO$h<@?{!0Kidma9Z33fNef$E&P_hGNaexTntE|mF%hsQ)x|%aPM>2ovp`Y9)Au&
zlhge^@c!r61${*cKJUionZH-;_Rk86NVAK3Wj^9Ot1bO8UFNILvnt_cWA~@TC|W2I
zUw*=!hgJp45@O|K{KZt*PGEHSL*}2(v&a;)(|q{3wZVgaZK+A>`6vI!u&N@*ITtzk
z-JA~1McrIZEA*|%%4eAE3c6Xnz`9flx=wOdIIuU<G*LLP`&d%A^c&X8^KYl{2EVa5
z-Fg|{GG<k3{{18Pc|cr&Y`pTA8aDT$*04}og#Do9v=lkxF3P!=P{>jGdZWDHB8#jv
z_gkX02W+~W+WCq#xlplo{6Xd&F0y2!;}3*4@*Uxvi_d9jSG*4~$L1Xn+C8mm0{g>e
zI0wNL-PW3Y61LHoJ7s?JBDPA$WWt2KgfO!{FvY_zVV5W2d)R!J;5n^{#8}EIgT&%X
z@WLLQD)XI}*b&{JcYN|6uqZC9l=;O!5ba``BJ&ED+1Swgdmq3yMZl!c1W~6tX+8;U
zX3n2HS%%E_U1mmU%?g?SbD33i&R&6*2vcP4Tt{B94)f;;S0GQ{y~n2~{$Ld)-xYGM
z`3h_ASZm27ng-umva2~d;A|vK$8Ij!|7e3E;u<=P>JhDtynss$=gHjdPj()gIyVu(
zRUj_8C<hNxqq`(71sl?fi0mArr+~tjcIJpCCrpF?bBD+j8`9>}5R$0Bu)tdR`{zQE
zuaE57f5x9$c7Gm&PUf5cVqQA1?ZjU!UYfg9=F6vd_K+qZ5q6CQOP!Ete~nf43SNt0
zQ#eBl@A-}`GXMG-dhK|+%-aoU6~wPzV_PJjB{H9R9kb^o%%xRtu!>dMFC{y>FjToI
z2CqHFa;q@2VOI<R^6(q1YV8**A*-eS5<_ecT7?z<bkMvn2#OftAqSBA=ueR=-y}(%
z3Pa<}4K}#lz{SY=o<<NmbTr$7v7y6C(6Y{N9Yo+zeoSXM;pZ3)-1wa8!PYRU3W*{G
z#-jkd7+6f@+=OfF?Kd*td=pWL_n~`A-eRq#1xR$e1%64$T6K#>1-pYgHiI*M^XTnV
zVV*<@sIMIm1xvZDR{r-b*ep{P$-MGyR;l8uHK5?&O?|w%&SY`*ReX+!6pLF#RZYVZ
zWx#C~T-pndw71v=fQ7eN^|Ch?qLqnPXgTf=*oE7yZs@mw(K})M#A94y{JCVkyNq?z
zyuzpqaeZpU9qiH@cR^HA@32~Bc8}4F#ST6&sg~Sf70SK;BL&7{=4Nn_?sdNUM+!f4
z2Ta&7;2wW*hgtMqhf(<YUDiooawk&t?y;u&p*xV8cn^_cN9W7@);$=s3l>}X`+Hc(
zy!Zuq;rH1{eb-#1R^7)!rW&Pg-)A-SB`D?b0Gom@wj<T}0rM;=U!rw`3ihWwz_4F7
zT;^jQuz-w>=LoJXZH>#t!{SV|+iaY1k#c6@!MdOpnr}9?I!}-Z1j*7M{RK{`b%2b}
zAe9BqJM@`V)*v1Nrv;U2qd{~6@;l*FZ$u!hg0Q7!lmvV)!9$9GA7SVr6a_jg*23Il
zmx)J}uwFz`VX^b2)sQ9f&Q3+%rGMvzirRmIcAIa3R=O|;TFt^%O6%c1O}DZ}RllKT
z?^e)BmTKi``J0R>Qn*6G+#&4d-ODIz|J?WZEHRW-5X$Kv!sWAnxy&OTvTU5~c%63L
z#&<u2D{9FsnU~6AU2rBKfq-A;v5u1UYpBFL))<%@M*^sO#EwdT&4kbC5gRG>JfFv7
zA7i2^{uOlcW7r<|2Fd)J$Jp{(uo?Zh>oKd~zG@IrNvjlgJ&C=r%)?pxyvOW_^lFC8
zw?0AepsoKs{_F{2Xog4M<29Zl%2=I^UVqNK+~V%pVi5vG#pz)D8h3u=DNEK5CDHx5
zm|BI$JY%x7r|&(!@)@E?x}$<u&se{(lV6jaIO;4-SGb|$MiK@UHn#t<bZh!~jaE0U
z#;zp0SDv#RDLU#N|MCS|*9y&C@)ShGd|qULt5!r$Lfh>nJ0Ru2T=08^m{1oa7QRBz
ze)(xue)koQ`2CX&x6^Bk95-Cqe)cs>luARQ{oY`fYFrmLUA|%Oq-GuN@vq*pCOY$b
zzTqvLWN(x2<(7EI4mj$q#KzO_*>LI0DROSi2RdHU1k+UiPpqx<c#_O_eL^6^IwU@Q
zV)LYV(BO0bW<#YF6EOfKHC*~)$ph}DSA%)Cf7s8l8Cj6CCgmOMCR17^3=Rbfz33_k
z3dMC6x(pYo9f$J*Y7&8G;{LSAFJ#`vhJk)*4X8R7p!)KSHY~|v)8+a7)CB!ss~bAZ
z->ROJs*H!d;i#rbo5#ugt)tqYnAv|^3dE<LPVFH10%+E$)gWjudjPmsr?!z6jm7@6
zqz*EKjU}IAX9zOMb_9$=ON@cfl+<MD=oovWCUMcI%dsml=~{bZPsY9@jP@+UQ2KX!
z>Zt$Oo=zQQUd>5usvo`z?HT5z{wnny1&3oXv}M#vfFNNfrNlHiN{gd0zmJspZ^cDp
zmUIE#?j_VNQUd@7mk^C{C*YD2YAb2)2&}?Os6p<01j+s$@qIXmzr_Xe8CX)S;uDoj
z+Py8v-+vP=wTIw7fUw9VRX@ogS>_of)sWg<2i?Q8v|D&O5X^Qo^9#Y4oUIY~Yx&0W
zo-GMcu1Ldtq8A)*c8~vog5C%A-M5j!S~uStLBjtr-O4>msj>Pg%Njc5b}Oa+;OJ%S
z27a-l6uut~H;XvJ@V>9iJ<F(D-GA%+xnt}Qllfm|)VamXQ4QOpwWFNXEz+dHnBL2(
zb0ybq_xS#@>QJd{=X*TTMIDgbYpfM&XsZL6DPTiaQb%nD2^e{82{w#i4Kx@zNolM{
zSgLA(csr8NV}?Oi{?J9;<lg-ovIejf7`uav0n43{_xO5Ob&2%nP?;yWsi9rXPHp}M
z=e12?ajAo5h{LklyYVy2N*LieMlPVRtm;Da$pZHQS+KY=0JmFKZ5KfzPP?fwKJS*2
z=|tO)Ik?l%9t>k>@Iwj@DW^8p`}~mNz`va~z*q0=3s`nJHP(MHX73VMGh}BKrzUP4
zhAtCY&9Z)om?8ZaxT`*T<3hZ{-(9VZ)!~Sbc(rH&)Jiy!WA?8LYdH1G1V1Six=C?Y
zgF|MG(7do%R#W(zeIdGbwC0K(i#2q(Pd)ym?f`FYbywY_QcF_!-|lLh4vM;&hdLOF
z{X;AC<aQ5rpA^v#bF4w7ThMg`+-OjDNsS;3gFMx?(m)l#<eq9M#_f@K<mP!|Ob+NH
z^Tu9ky<+C@C<3N?se7csy=C6OTm3;g+)L(nywxyi0TOOLs)wOoAO%<z-L3l`Sq*&D
ziXo;Up9@>$M6wQxqCS8En(U(n>jujF2NVgt*Z=b(M<x^$DfG{mKm(rosEwp?CYjgp
zRfDR3#OTAVc{odqB?-c^XKHJpx^J-t>Lpg2#?T)q=K|O~(N}GvkGZ|p#t-<aRi)Bs
z@FQQfe970h)<RX@7$$Sq@~T%I8b@Nb$!n$kX=XEQ8Ak4{{GFUpfntp_LxwEiLi~9s
z*}c4)pzDvulvig+yCA($erjO(Ur9^*qsN8%eQNRI55-p=Gk`G6PYsf~A+f+uRSai`
z5S7Qp?=Rwa&k&i{_E#@T9TQ|;x`NtRT8ZJAR6(up8IVGnwF@K<qO|)sY1TR)bbN6I
zwS{!32fTC@)b3JWB$@`Os(utcxJo+yq*SUq=D|R<CzSZ6#^_?lifW2f_MMKKDyrl3
zH>U#+y3?0G3{ai9Qzdn!^r@>T5yAhgq}D*O<&99xB}h%J^v`RZL&9EAK>sFN%VRlR
z)HIEAaNx6o)G+;-@u+owkoudS*(u_o7zj!1mKJVs1x0Z&`<lfv-x#d=OFo$E&IYSN
z)e=oK7VrrwAkZb*vjn2^?|o=6%m`knJ<cg!55X}ZYJhYyCxshB)S5bo)sPTq_+L87
z{9cG!Dave2gl&Zbg_*RdyG4q072I3ap2Fc~Trh|1JMZS8%WP!gVI3@>MwL~6&y|<f
z(qUiNV(36&i_Hdv53Q_vmL7wY&0y*)JIvy<DytP5JRAc}R=BUz5Zlb&F0Rc=xVSY7
zjAzXv;1PWJK(roBM|4Yl)QS7HrepD7sjLPBTpO=xD-mH}P7F;zyt$^X4DGYP!OB(C
z#L&4+Q&*@FAIyVBxcW5#gu1vzf8k(oZah1MFRG#r(xK~$g{sx0)9tOicBuM25;)Hg
zs<wbiT7EB|7N{hOO9CyeIfidlHK2SBCT`N455VR^I-Db>f{wJRYFy)_>Hnf*uKEAz
zs5wJ}#gIOO<%azwP<Lx)3V%~oZLLEGHLs>dCYX({=2Hiq#SBWllLj}Qbq1VP=#Up8
z=VyD)dh}b~4*)05q)wY3BRZ|IcnHPN+h0u$Xk6jKT3cS#yejCp_?%HC$Z^piKBp5b
zM)-HvKwBJb7BBkp^?4wQ9X&hXE&$vwO!cmD94VXOCyefY1-_Fw<_EsFgr0V8H4-f8
z6{d!RrM2(mvlQL?0+_hn%mu5b)nRIdfC{5Emi_{Gyt!F?Le50|Z40q5STaz@y)ZSj
z@!Kqot=<%Y5eSKCoI`*(ifFz`e@Tj33AT!W`8Z;$xctVc<BSxZSY559>i~13I%e=W
zZDei;R|D#sjg#gQe_f$aiNB*r`dez!|2yi(#VAI>$YbJR3Pd`uVqQR=KaXhD$x8}E
zJ=4S0$Odu05>smQEV{S#`3-&XQy!7@CXktllL0MdFzDnkH10*Xx<mSq1mAQGwHe$b
z7qF*PFdurL2qyDOvp<{6-w>a2jGF}%llgv_UnG+EHTXin?UVVo33x-ZnrZ`&=~FcJ
zfm>Sq_u1(we0ELM-KYOF$`Jx6HZGGWw8hz%rSQEqA&M~3%0#H4e$SxflX6D7V)G--
zNYRNnbx;EONv;W{mmHxc_?1o+7@>p_4U9lL#>X1K*cPG2OFy=f7euOo5$myRu^B3B
zBPp9UL##K!c}TBLA*Sma2&TWrNWxXhn9h<T)krC*mCUmu)lg|H=7mj>s;^h=Q^a=v
zFFt3x1HT!mHkZCUdWVPBg5j2kUizz+I#C*gDY!>%%#g1R-{FgEt1F}j;CoCRHB~p|
z9baBY?P6Tt0(H3z1&gqG^q@`(UH8;NeDmof9$v<}WE7*Hq~Oa5IB8``z&Bo>f$Jc1
zj*Mw7N)3*x-3HUzHR=kpF#|%2NCy)jrvPCWG4j%aY=(gL1$#^wc{{togA}D!l+Fan
z{HG|jm2Uo9{!f$|kZ~h3#R1<L8HH>8_Vgg0c}5A&+^9<R#$qnU{7!4Xqs?65{W)gY
zcyuic=^}t7{|3zXHy|B={Nh84q<bG-8~k})?f+dg7Jym&KwTC0zkCTvdr((xZdiy>
zz%K2oKpbGlB2OT822*ovJvB%-?=A0FPpzSkBjknk)LQx)lsa2ajn?ZZRVo^5k|X_)
z>JqJX)&~%5OSD>BpF}WAG|Wz4N>!_`Ch4#CMQVI~Rn{-1)b;vmJ$+kB`7}VyMoP79
zp!U|^?}OC#25No%PD;IOpw`vTrBrxBwOWQ#2C?!%O~Kc9ljvc57xA!CJe)y}b#NUt
z#%!D|Al;E|?XE$7#IS<uB%A~d@_HgcI6>-ZkW7ISLZw19$a#U|PLK?D4Kzl8OjOKK
zgY*@Ur=0<LT3fvSlz<os=b8rDDIli^=adHFf<zy}*{MOY1>{G<`B8&(7m(LA0GXem
zff58LlaMksNQQt6C&+LOGFU+NQ?XP)^6!~xEWq)E7+(ZjMSy1$cBEFm^<?5q20;Qe
zNW;k~82~v`S!V*_W9ZMI^1$l)0{LYp<h-o)Sx$h+sZZ5hp&YaEn&`q~gnLYboDvWN
z;cU|&<3y>IgtJnEd?_H(^Kfjv8r47DKBhwtVx{H)0`UEaR&s9B#%hS8?$5V;Koj+_
z#4#yH#Hi1ubz}2#gJV^_qoE3943m^$Ec~^Dgcc|jBXeU@b&?bbyL4YuwXH7uEq7_A
zp4C6?4vD+fOzk9f{`n5CAE!na-`Yrah_CpJH);8mXYR~6b+)54_@_I(QVX@2em_(o
z-`!=351-mXeI;F5b%&2@sV*>VYmG8=ho=}|G`beUl*Q<(Bz4Yw%M;?&Zqma|clh`5
z7%Q>SsDynnrF^a~K^@>IRor-o4{4<)NQ3Ljxw~4a4Rn%n^*w)^1VbpZhRlOoBX8)Q
z_k37u^@~bZ!|^IuW(V*`TcFY1O)k?DF|=_LD0yQZwT5B(C#KahZPd_e{o$vlE)-@O
zEKyg{mCmyVRR?%R{)f^+Zq#+)J=<Wll-?_a&uD{1S|l91ZPY~l`ySv?#kT4=T}_#P
z+g7a+d^HRmb{8+)ELn#JXd#_#{T!&*H(}0(l?mPXq^(-9<;2>+ya*IpsKz9)S3B@_
zhctvljjSg-?4}3%))~C-C7Pg3@cjHjPHTp1^ASD&!e*#i60(r2#z;qZz2}RP)d=a&
zYBE2atcJuau7&Dff)MTUy|jwBd8=-L5=WJ_8r$OusNU1!rUP8+t<~G61h$mhsXZhc
zS~{zpTHftB^mrjTIYyc9X{UNitBcG0k9OecLLk0vr`D}C6o{W~MBx0cWE9l9WNq~)
zi{cnsAbeLi`Vfc;QroMurRq-D<ZiDHlis`GjB5uqL;4XswRBLs!5R}mJ)%qXF4LEI
zQFj_c#v)R`BVIkYwamwNR0DOoO#W?0HAX-5GCJ&LN430EvPTO4r=uFzv>KT4qo;!w
zDVr98(;i??VSDb>FXV+w)?k|2aUT#xO2ESgK7W+t+^kOOPma>)I&yCPE^28>k}Jx&
zEx%AR9m`A~L|<1N>YRhW+_iDP^108us{<XIM^?sLS-FBPs0xb<gcNn^p&t%KYF&GR
z4o2ntEUpTKeJkF3<6~;>vJ~}KN3SzZ1@54UE~Lv~N3e2o?zB|Z%`xzv?-R^?>w|AX
zXo_y+JVs~Wo}qL6X48J&xxdQlD#y4*%Sq_7f<uL{+fN`zhzF<eP+F4Ze}5s$HZMwO
zn646}6tOItrkV9RmFM<SXGtmEGH=xz(&vkWxwraHeX~=&wP=m#DST{f4%|c-ctQO^
zyUX?#MWZK%A}b-Mu?U+8f;1iOqlW9&jo>f)s1*%n=c669AxJhljJvnT(W6!S!j#&Y
zn8G{u#Srv`L%Xlq2EuW5b^a@{`e~rOaw9w@j{P7UM;pq#Vm~!PmpGhv=%-e5GCQYq
zsLrSMQ$zI?ajTIwu)|uV@W1-0aW#C<V{|5gTtX8{fcl)R7A(vWi4D~Z9af6y(Ts%Q
zpt{YMYMqv){7|SDkTH&7!XFa-OD<f;K(u>Lk%5dpn_mUQY6H1Iz&_Xv+n=ZM6JM%5
zbiLo=bB=1X6h7+?@714Ng5LRh^+131lQe7Uo!tEcR98o71JoW3dDj)Lav`1DF#ZKq
zEl|$76wZWyQ)L9X|EB7E(0@|(;&CcB4^mCK)VKWEAk`?1alw@G72Lv=k(lxoRN~E?
zJABhuYW?DkJWxf&cl=gu)q_ie)jY!`G!-nP_S;#ur>@MUA!<8a%3I!fh}u#r?u-z#
zA?ni<voWs+X~%6Ch*<}O+Ri?X$W?1|5eH&4q);vwxh~o7upe$62(J*d>K##TqCKY}
zMJ9LBTt(*-X!<T)1zLZodQjhX23CYyhN*R>y`|s=9;UXI1|!j6IGW>!M9y%vV^wEg
z84Bu%^(q)gf9W265vlvuGBx%gJ_?G~!1(gPF8ByIopvKpXM{RR`Ur)&euSDTEkdH~
zNcEn}doQB+rTBg9C39Vx8fWNP9Gy}bb>ul)4}&l8HX*Bfn%YDv1x2_dO>Hl2D~1~_
z($vmU4<r&tsgGTLHc(X?#qVl^%v+9D`%3ThSW}F~8f60#A4aR41J`HM;$i{%0THU=
zR~5fm_|<k7$F%d{Sz}Z;ePSr)twm$hz50Dskosb*T3Me(sjRVT7kzz7-59I((Qm1Y
zRLgPdYRSCeJ%2Gyoho@xy2HneN8j};Cg&a;uf{q`>V!MoX#zZv=k#)JmkDZ+qf{>a
z4xcztZ6|ex<~%=9^>dU`2jAh(CaK4yixRd+GSuo)V@H`=Gt`07c?V2mlhr}eoe!z}
z@MN_PPI-N<C(*F_Wx?4g>LY3DAF2HBDQYcgL;v@@)>L(LrMnJb>*11EdS>~<kBh53
z^#$4;B`20aAn;VYIdA2AJ}(ot!~M6Z{9vY9C2r4Ke2*(f+&FgLjfN5QFZzYHrMw}#
zjgYp>?ph4y1lD3%EbF{F-#<>i`=%MZdY0N<cW)ABS!$aSEg+VL7(bcc$bu{DpRcUk
zF&l}$kO<0FyXam_<P);hP%q0H3%TIQ8%5O}z+cPnZ!EdHv(<8r`hFo`{P}5Wh9Rx2
z7)4_XDfz-*=6$ED{iG`|Q~BBHXwG^hK2BHb)Jpl7>R>fOX5-mc!LAtjSUtn9K=*32
zx8b{p{|XSe4+%3Vm?s_1r}7L%ov3Syb)2Hsl*YVB<q-_}HVKLDO!bi#E`HC)Ff}^h
z^>cj236T_+K@k`pA%bnRN6Yy<++fdC-?H<51z&OK1m`c$mzMb(rv9p5kPz*_PpE2L
z*N``<B3f)CH7aM+WIFlbS!SYQ4@epPER{#*s9w?p49mnE=p8>ma&lBPwM#gS=_{q+
z*64`A-@gVu`re=qOBuV1hYgS%Jk%8r4#>$1!(%;B?)h~*`r*-A<W2>uII!&_az}z2
zX)~}8&wG-}_soD@`ZW^XW<XjZA)8@qeuPF`ZwAXf|4HRn%wW(;K=d=!%I+72kc08q
z(Pm@ek+NA1;gK6>!VORt7{h0x@WV%`eD6#(P&$UhO-elal**;A)d>ILkBDDyV~^^C
zb(TG`4sdK~)odP&YM$*+tS%kLI1f0G=<8(mpYpLHZ+svz+{qmN7Dnx`1Bn%b&Hg6_
zVVrMoR&<s<OA~iaLov%<fL(<PFsp_(KOTj36j(1JEuOt2=8a9pagY+&HYww>Jt<g^
zIDB{b8xJPpYYhHg*pi4inCK@(qlQhWLErsYlmnkYpfZ6e{NpUOX4$6@Jd!SKhI}_r
z=9iHfF$)tDxp^kRo=VCIOUOJDAzpb|hc3!I0Iy9_a2fLC$e7|!Z4KgCv(<(AiAPZR
zfnQMh@d_!t$sDy-=;Ks}IG62T1v^<&;d&u24LFRefoR*hiKj(7TC)+_r2e7AW**5t
z1i^oAXdehCcHcq*XB|rP3osjx!W6-IV^7U{R-L?OJH-qW-UmL%Q->1$rEj5U66dPb
z^h*xsw{oa|3SWFMu}1t5bQ7Ev5phr%b*wi~oZ`*gH2>R`FRAX{P}Ag@Gmz)=tsP?<
z{zB}g3yfH(@QsHPy~-onUjPE^MFvrktw5!38XZoo>}z)FF&?afIYqIRmuR%m(TTU9
zFz`sCkN3(~7}JyQIubKsV7-E>f+=w&mA5;R=<hn|LMkXp^Axt?09z`bbR@B&H1TjM
ze{wX@S90~T@PPShL|=2r)_%f3!`aOuu}#bHI`S6_;Tc{=>&o|_F5iiqU~Y|Xlz<yp
zQSNMB3AA;D%NpGogYKjwymlv@v(q6kQhZFdPWhAt?>p7-ul*3>GQ`fDej0P0!dGcC
zL_+TNfxQ3m^&MbQ9o^r!7ePb>gry@OO;i*MD!K^70w^l>zKaoSG=ieW1{iGYg@{HO
zjY&j}Q8bAfI~v7GYzg+R*y18aF~%C>e!nyKZX@si%kyNt%$zyr%$d`s+_`S5GSW+2
zGhO0OYL$B%bw_2^k12KRlR|A<zaB3&aLOm>7*Wv;uF$%KF%$(`p#oAYEkv3({9la~
zdwQ>j8&fc?t9!^_<iDVOB&;y_e@q#_!VY#g!v=5bBN~>(v>vX%x{?w-Ye^qDO3HnX
z6|k!s_8HSQADUnLyHqkXi^IUnX>9Txw5Tzh8FYh_BJCf}wWIcAUL~CwgwXr}J-jms
zO<Mb}D20r+ZHo35Dm_N9J}rkf^L_jXLb@*t>4qevr=v(nI;Rvib|v=NQePPRzwesV
z|B<QG{~o9?ZQvBJZ7a1O@N%B(G#u?%1+TUC{0nw_6*_#rosRvxO53+jzOT#2|M4FO
zs9UoC$gq|A(}nsYc1+;s+Tbgw2Oj9n`-YUVC-I(*I*8sBeFgjpZX?*poSw~v_=g%+
z{gu{Bc*ln09Z0Qz>-^|QtTW<PbVN9^m{1_DoF(<M^$){QvjO4E)C+oRDW$AONY>K_
z8hnz;asCN#mwO2Tjv^g>?>BfVi65g&Upn5#ha~cC3iZlj?y-#bN}78#;NimI0-#_k
zSr|M+$M7v?X$xjhaUkzlEIPUT7j&#?Y?6;~-*p7*9-Gu$xOZQ}27IlJ#aUe?u;2s8
zuob*tS%;%^T;PRnRsCe%jaVyv@RWPzUBhQ=uuV{nkKzzfClGqqf)=^yot((tuC!?5
zFwCwaCR3;_L84<7N1u=c1a!E!J?P~eo9JQo_2L9EMjw3Vs>X2t%YO;nLkN@!6gS`m
zHsT+N0HHP`@C=#^0_ONx`NX6aBR4xyi`q{SJ`-~9mKZsjiw_MA!Qr~dv(6o@IJ?AX
z@E@gQd557fykGlJiPmY&q}ED9e`0uR=_@QLqmtaiCIJwmJBa>q?0Q)K{8{iqptBS!
zOPQ3^DC_51fE(pnm{994d~+#3Qgyn$Rf#pQSAIhz^gzJr$4m4(%iLpDjU<vF@*`bP
zRZ<_%Rg;qP6X9PEW3d{Ia-QHTH%e!;Fnl-iJr_abZR$jR<fT*Xt+Fsy_fX178l@Q5
z7vG<@;a`!wahb$$ECT=6!6&##PK@9kh&EP6q+)%rcnEMtZWlzgCutSR(sCl^yyTwb
zOXKhruS>pLVk2SFD^DKaq&OMlTXmA6IqtTD-;SlB7hO*wIQ68*QEiqa)cU|j%K_x2
zLD)7y?do$BUsw$m4%6>hBzNY5hgm-D=;{NPs}EjZNx%QzuL)7zFx%DV0@d}?)9>6<
zH6fCVw86qyRTcZJNSmapxDF`g`9CxkAGVnA6#c>MS%u9GJL``0^#b~`#dCo_($@<v
z<FRn9wrTB=FtCEcXLDO9Bb{k%kkBXLb)jUsajM4v1&jV`Zh~KI<x8x0(47VOkz2<}
zZ|%TEV;+wS{dQ~E7PJ?>LO{LsY;NNa_84EvFna@d5W;VQXm}@?--|WpriL}Go*UcM
z?iy0f09vgx0Qhi#fSV|HMl6Gz_*&j0-5>Br6v3JgCC}}F3gbmH)z9a)S1xy~$^Wu`
zGXIMnnfPx!){_4nJ7xawV!p)rzpb<6|67WL2KMmrQ0(j+y)N;elzioX^FI#bLi~S*
z;3V@OzEt9W+F;^eg9>xy=wfBXl7nM<3A-=ji{rsDJ}wOUk33NKXwYW8;d(0n4akO5
z0pSo8;~^yCq1TpC-okR6=XN+086;Svq<mhnyYToDst!eZw?A`9!r}uglmg_>PSHhF
zgA;LoIn-bG-6bg=z8^?j{qYc7$=dvPM}GydB-M)bY&`^6hMD<I4iY!8AF_jg@U__e
zBp^Y0g`KBfOLuEnz~3Fch1S~;&Qc2eBKzznn9fcd$RQ!;C=MRo!8K7^CH5L|^7TL-
z2Tx5*RDZAaQDm2}wb^QS;n6P4F0x}>+xYXQr*=WaIEb<iVUBtxq13H+tHs5(dH{83
z0V<{bB)5sd!Ju%vy|?siQJa{uMr~nc<gWkcXYHjn*^!ePqRso=XtO+L!T|Tx$Q6z7
zM~$w6CBN@@+vVF5BqAdb#xQDhq1p5s8g|z;-b>k+I5}|Fe8A}i$;}wcE|^i$SSrHK
zv41D3y{#`UF^uJda(OII;en6k59N}u-uE$$rPT{QmIXAH^D&~NF*i|<PkK}s$1-Az
zHnc@gw8ro!=v0^AV4gA6gSK+%{@>1tl)un_**)_=rM=%KJJI2VTeMxBufd0*(Pz5P
z%5WvZyrY}g_5mu_9+juBz9Dt0Qc61Iq<iO5O9G6O0fCOJbsYeSr|ZeY(=kjm9sOdh
zWYy6fyQgE(ZoU14?!RO5H*K&B%hq>vatZ=fYLtOS1kQ@|9UBU-e#2^nzN5G6)!)EW
z?ww(kj}BP@T{f}K(pILsDNbwH-mm&K7rw{Lk)unV7hlg~zBFsp{m`3uD8%em((%F%
z9aRb-{q{#~)6g4dIa1wzo*?UWfgIR@fSVf}4W(AqKWaM)GtX*Pe4+9ZhM(0i=Y;-B
zp$i`LpA>luA*i{l@^P^RI!lYOViD^i#|z>a4XZU=<-&e<_%YV$40TkmTiBC0OM_Ru
z<I%g9OAG#|Cw!nu#VWR91$q8yiSAf*l+*2v2Tr#oYCyMPgVRJ8U%a*D15l<LlC)WG
z!m@3fwuSY`XIOy0zfBtxtf<yl^~ADD8s-kfN0Y@>HIBEfJf&ebH>L*$_q}ZC6&t}y
zEswWd#iU@#c5SHQyoUAMl<vXGw`=RW{8nz+?xzPD_I$fGQph~1Vf#v^`YMiV*wvD$
zp+Y!xpzhb{jf8@ynmz1iZPQx9y)q3uzC&9i#Nc7vPVH(O-rKkt%4xR?i)Qz3>)420
z+8~?26R^AytoqyZP~jEOZQq3jzb$xpze|g=-_dEsXcD^{Cq&L+TGzHHoeB##q0noO
zc6ME4q<F5X=jg{`)}?n-VEz=pHl1#lU$YS~&U<lCR)xY(_G(8v;)@{P1K3&C38pVf
z?<!=Y>x<U$CK}YT?d#I}305fFxDSgU7Y=LK#eLcyPWjQ|2DEiIj0cPPF8!FWy;Q?&
zHl+6#t|Rv!u_4_Xgg^QYSTZ-HcNd-<(y;yewe8`D_N+&t-S_E-geM0z?DY5Pu_)ZS
zj#%87{%v?|B!t)z(J5czRaUb>-7vf6pt_(rAJnraEeGctq{5bi+7F)G^&kfI1RvB!
zZF(NFY!c3!$kE*$^eug=J~$QKTfZs2i*WXUhFw3XjT3V5(C`pe`^MrS_K?;~(O@VW
zen{(~cr%1eKZNbM5BoK&_>lG^uYEkU;8wqE`QYDPe(>+qU<E7MobJjzOSR*LMu7I;
zlJ2T#J(#U7#X9x=5)FG&itT}HJcJ&`3Um^f`191%kWO3Rfhd@t$R194I6uCD_l}Wf
z!IK$o&v0B|BalHL()aiUsztBmV>tw-(C75jhOL(TjIyCH8GM7>(2$?=bX?FzG9)am
z?gI=hVPhH!MPGY*s*?E}!O@gI_QH!D!8vlL+ZyJ6RGX{-YvYgN^h(w(4cl~7+qdUC
z3M3oB9hT5By(d3AfpaGvChf&nD!Oh%_`@O1;}V2n)B<>A(H>N~>6M#cHu1-_$x%pB
z=~IXa^U4;3CtbH#DN^)mFGUjU|Kdz#IaO`BM{6+Bs~5lTeZ$I+X@`W?XudNBk{gdm
zha(a&J%c(UgE_ACwhq1l_cHl7c0KAsd75ua_w-wj&KNI<*<-0d6y7c!$64Gg#CJfu
z;}iGkbsO}n0oJ)($^s?;%F%wT(tQVT@<bpJi9qEBF0Nj%`L!poXMPu1-H8+082c+b
zA&Is)=nBJkD$_O;rlY21nby^QPbB%=wa1YEvg9&tH@h*sAQ^yb%CxQPpWmUeG7Iq)
zWzeU*9UA8StJcdVKX@90-F5s`8&O-z75v|HbW^O>u(<E~dkZ7iBbV%>^7D>aFGaEz
zZHSmBW(Ou=Rs4!Gn-z#ZeX8S|GSAgwXehGFJ4jj(-zfZbZB30@9I*^Rlqr^<)CT<L
zQ=A1qO>k5E1U-Ke<IVC<#kdHU5gklna3?|oq0MVWXs2V20$vE4f0vkuTH9D$y4ttF
zWvCTJf)D`7)fK0-LxVs5*>cqS0+~VQq&t1Gk?LtqYdg3IH9%j$Znk|i-Bs`b#L?5*
zmPtBfeN{LvRSmr|Q)~&(X;eZCx=|M-9la4j>>dXwPQ>BYJRB4EMNiXxowr+Z7ja5b
zmO)#2%IMXw1CUbR`*LI|3pB{ZiuR?CvbDQNFmKqYrc>II91H4Xde&b1E8;18Zac+W
zIS-G7V@L~Ps587R<pbN!YD0yyKWf;}{c+wcxBe)>=$k`)W_be`#kIlnprkpa|K_~0
zp3xH1--YL4C?UUTJ2#M%7(-h0U;@7Ryn3*k&;xjp@_IQpm+^K3UR=QSi-sNgP209%
zBEG*Z3N+Qb&lBrg5FGzpwLaMT3r*q5B=?ZV`H(ecA|;sPLe@04TXB?_I<hC6kgY{U
z0jvIJvXA2rU>+BQ5{&Y4m7aOOpB$k0LBl$|pBz$ei`280XoPP?{;q9ly}um%*Dlwl
z*t2GYX&#()0ZS{_eqR6Q&F02acn+`f%-D>*l5^S#Hg&14U{BFGt!*vg-%T2}`8?h=
zxw45`n29VFIo&bjbQ?5m@v-#gLg5$Y%AE0q#Lf?4M7eOUL7DfYT+oiJB@A1nVd|*(
zu1+qCc%Nt`T(`0FYdy>RD#=@@K(+ggQ61`USqR^;n){A4I4jMKQEr_VQ5oZ9Ntm@r
z3Q95_#AVzEsBp(S@K$xxE1O6VCvwKqo;OLgaVWMTu3o~P^!*S#`CirrIvv0hzO)2K
zCEHZ;Wo<jb7hR*Np4W%(q|WpLSPc=BUe=}{%4-+H+k{-f=G-2*mg*~%gYJX7ysB;2
zGzOstvmbvln$@`y6FEUda1vaYUO5)OhAcVa-)Zpy>onLm8ILQ+4d*^P8qR&<K=j^)
zptSPeY5f%IG%RhbD#)+33{N7=3bf=9dR-VDAE{*Mn&lL*_EOmwW-XJZfY!$gu)rKJ
zGRDQZ+cK%YCmIo#+qP?1%ysQd;Yks)ni$o<`d=0STRy)CUl-GfwTM*(2&t&-d;`JV
z1rPp(6O^p@hStp`Ism5}b7-{SG|F_%@hAJMuBxkN{u+tKEq|g>2KzV2pnPO}qGFAP
z&AzE^;;sKy0_zPhbJ3G$DZQz63wU=FAILPEaZeEGGqX59@s8-_JG?|Cdwo-TNO<}U
zve{eO5aBo;?%mS17M9?_<2JUed*Wf}ZLP0o_&3;xIMFSgySL98(%fb~F^-o8Zfi%{
z+M@)@#(okq{XFR#ucS@4d^!8DOauE7caXyWdAC|mUlnc4#5-C$Vej2)#_njDaBvHv
zTZJ|>`0t8peN{8PG7n}8q<o?_rmQpeM=7|2rtW-2HJe+3BmW=!5Q!uJngjr!2;)-<
zW0`DyYB)qwC{g_+N$sXLH9Y}?mi0Q~E;g*&!OSLiiuV#$&(;)<&2;yjH(LT9$-#RN
zxY5wD=zbT$|GQP#;=4y%e5)kb!(N1XOR*(v@;&UWpI-^dW>4`Kw&LN<JvtMNhuHgC
zfB!Bkxh-H_;*Ks2TdyR-#hzx8uC~n_Wt)hkjy%0~Qf?asddNM!Hv}MgdiQ_8A+=oX
zK|CzjNWv$DNPD2|+vQ#%se0#e+!@e?%Hwe48TnR%I6IafmBNkU+u<CVW$)hxISbPQ
zv-fY}54aJOfbH^;??1#U-poQ+@I$Si`xVfmcPES}J+Q<CcloSEjGqtysD%%;VJ)J+
zmxgix##6e&z;Qmzoe0;Fw}j8HkQi^|4l@|}waPtgD@tl|`+^&*k=y>1Neb-w4=VSj
zlO=F}&Iv8kkXON#G#CaF$R;-u$g&L>lmeFW2i~rkwOqrNI%Fz^kMVHaF7qQ{^miJj
zeWdkn8V|1qR!`*Aaw0Bsj*g>InJ0(!C?yQeXaMDpa8SVunK1vp#Anc#|9%L=>smF7
z)M-B!9KMukzJzOOWuF;kUpxz4z*^8-_^ekt<bQ3hRx|HPZIJUXF2wOhxG;nLBv;}U
zpQt?mtkgz%O<M{kMH_POUcA$;=%-$J8FrNTSUXD?kElR^!iEB@=1ft!3O1<ntkU{h
zA9aS1e;J|jurI^-Rdv9pM&Oz%MyTAQHc$axcb^1DhRyEm*~wNJSVx{cSl9F}_ASdg
zCzERGbt8a6uZ#zjfxC+D=QVV)OlC?qOUcaS#d0#!cd;}Y_nfHp88|wVIbmEPo?r&m
zWr@5<7>0)r@hUIti#^}UtAr0IlK#C#DV)K>?0T7A_Hr<_0>Z*SwT<ducO=Zm;2Wjo
zmx}c6?o9v$O^ProX$0af^5I%{)7_B|E2bcBG`yQ0=@W-|V~8v<W|3ukIv_OvPVFHK
zg$4W~HS0!&*YBps`n=2I%`9ItKtOt&28g!z(vyWR@-!^>UV2ma6oA%b<qV?8uxDD&
zdW#*1_bFd<9nF5G9araoh}42|wd!Zu9>RE0!#?ez8YKvLxY$M2&+|tu&_Ol-wWpSk
zzA}x5({pV*&$IAIRjxJda}OL=?EQ3aAxw)@<9>P*VIoTAId^gmc$h1VPbA0Z2YjaS
zksL|Ia~!MM2-R{HG8+5!?^T5<7p_gvb;pxsR=pQ0KI1PO_M1bV&0>*t!b)hQA|qUQ
zhba*us=u+P0ns;jVoMjQ+yw;?gulRn_yH)Qn*{TLh&%`<7)yot+|Ornp-do}Tm5?2
zMpY|(<v^;mWNaZSA(NU5x`UY1_jYz9%K)^*H<R!?rmmUCFa1;%?zD9+_{cw$&F9D^
zn3Y9e>(|J^C<+n^??KO6*`Snj%%3N=M~$pE0sz_A1W@E2(R=~=Y?j2vh&seZJU|Qv
z7EwRL*I8S`!q!R_=D1l?*l~)tuk7va*;3;(@b{+igMC%>Qhh4eEJW`1Qu~qb;RUEJ
z%UJ~%Cxx3jXl3wgg~^kAoeM3Ar4>oUmcX2|e~$O|m92T14N;o|2W&yD$Z4t%rDET{
zLhiG7zJ|4UJStWQ2KkXOlRVhtPf{HeC>`=z8)`RkIf;7=Jn_lLqZ%oT!5Vq(#M*?p
zH7dynQXZzawys@_#DzUfU!=%EHuXn(cel^Ekg)|eJZ?msI!-eJ7K0SL;thgx#^)N=
z`mHwFzYU<`PAt5DG2<39M=;NtAe(}>+F(WI8@A^yobc&+SY~>w4Koyk&YlM%Ftn!A
zB~cw!5Mw_=lT2ME7L(s$Ib<<8TvBh3pSXG}ndh5PPWHccg^pvDtF&tsd-hK2CWONN
z>inbi8S*RgOHu?>&IJ(Z#xA+Y!fq;L^W0R6s4oM^m;%GhE65f*MHbM@M#_0?n_+Su
z+jpd#$NK#<R1$C?$K*hmj9Sk9jSt3dsD{;lkFiV0(y*;hN5v_!<)IteL3B`LVyxa{
z=-$J-;+jY}<iuyA0$rf;G;-JU#bEI$>Ky%;-^qUd!mU~I5_i(qW(iqX6SzBS(3dw*
zp@E4LQ}33?$n(k<;DP3q4KB-sUVR`!75V5{!HZD?TrnB5H1~rOG;HPvtl7<<fiq?U
z;~NV5;aCoQ(0cnT(F$@mz<1#Dql5|Y9WC_AH}Ki7KWO6{9Q>CkY=Y-D7zaz%BTxm+
zkpq<-9=^EP&s*qVh*QUA%W>)lJgl}woRag%iuc9(75-wQ`XzYKE5Cz(CuLocEcO&^
zXKPjziQeu*$f?)Jsk%Z{xX<1LDc0&Hx_AsUOP*FBi69w1{HGXG-&$f&%h4zSj#y(h
z6wCeML0N&m1)yHJ7=(;nDh<pG794?nWi7FVaBHT9odP1~-7_WBHoQf3u7>^odQ>Z6
z{rBdY-LI3R**!W*n%(VZ$tJNwrRHuAitPs&evb}V_>a^39PreE?(c}NHUQx!T&fUn
zyL?E&q}FV6>N0H8`9P9aFuV^T$~nq&=9~$VWqQ9Q6tz()1*~d8j1i_`=v!Hf&7Hc;
zkO(b*Q!MSzq`6IZ_dM4Qvw$ottzx4XX8wpL!@6fXUa%r-@uT`)0LCkTm^Vv~<pGv$
z=32VO?4^=xJOsIsdNy1q%Wd6jYMY0Nxw%@iZJ)%nvYs#zO51#5Ohb08wwUa56;2O3
z;`l|kPUP5O>6Qzn{1rx(PyMDL>9G+p^~;cY(Hk`;v{HXlnq(v@GBnKI7J!pwz(X(p
z3s|vog0J%;%Wn8Dk-A|!SMJ8+ITEFhfIzQoHorzUB7U0SrGR}MxIMIey}t?MXbwpU
zJ4SWHZgm&(qBImS|GT3S6;m)vt^>BVPLZ(cU;LM?qS-1p#boofz;2(J`3sMr&!o0<
z&=wH`iX%_p3hYE5>){O1VVj-kDYzg!+|{l3%sQ0LO`*Lp`@@md_2bRVgJwdp2(@E)
znZ<46t)()H8>juGvcX1tIDmKqg9dZ6xNUsNTret5WvO*VZx`RGmV$PGb6Hkb>>Jj;
z^6wgXliLuEtFaM3E>J%Yo#&m&OyiXno%whiFOzIt?u^Z7US`pmzfyUbMQ3hHWfq<J
z3Zq=JGrdR;(3uVPqPt5)x@Bj|;hgv~>06B3ANFEOmU=QrVZr7{V|kecn}3YrWfp9n
zm&z>IJSde}usI8ARg=x;eEM~i9j_+_*8lrcIF3g=NqdW6^{O5i>xD8jvS6&0G@urY
zUH<sLj2)56EExMqDzjj00(7z_V-3k4=Nx619K^=$?o0w>=V9G?<pU^*Sp<^Sk)I9V
z2rM*U3wm&O{&=6P{%BmY2koWNw&=l4#CpJ4i1t^h%%TT7r80{iq|M`PQ;aH@f{$Fl
zp`ix>d@4Nd7k*Yi=l_(9ur4|Q|A=4iAFJz&k<l|gwbYTZwCWg^B)0zVz57WuKvjz*
zCp2mzcS5c!il*3f?*?C4)m*P6MKlW^ICFCchdim0&fLhANYthukT`7qCvoV33S*?J
za1=YZ-FrgiXP_@82TC(gC-HNIS8cY_NsPqQ@Nh58;P}LE0=!(bv)D#xjfV_pv1h=2
z?n8EbhW$3WwjeA)+@FnSc|GI!cr2zliz5{y$Frq#)jmRJ6r}h~Zya1b+fp)CFgHU6
zB8~skbZi7S5QhtF9JYR3L~mgx9-6y|{!aP9!;`QN>tbM<_41$IOL#LD37U%-EO@|G
zUU3meC|1^DZC%9>AvO&Q6Ru*aZ<LPu8;J0S*VFN9KtRV3;GO5F;4w#N*qOSi?HfHJ
z&>hpcBd7E-JImjCT2MmnKM6Tya7O!vYgmXfwS5B)Hw18|)sWc6*};y`Ml8nTD7aoX
zF%NU0=a=HVopzCq=I^)S_UJSUTUCv-+bc%nkbUFqS&CE~u?)+O=t%C!0OU=!mA`*4
z3`KVbXXl`OX_SM%u#@6q)kEU*5<;95`AT(I9R;FK+!10Nfr&B-4S>x1N{eCsb*6L>
z8X>!NJSVy{YY*{}u<v7}a3Ryf6!_QEQ;clz(|tm|5`oH~H-$N>R>G{o8n(hyTpaj2
zq6&`R;g<(%y0wVYE4xRDMK=DjVzFLgv=E9cd}%9{m;JI)fXENG?+TUL;3albEZxlh
z^b);1Ufv~Aci`DA8D)3;Gw0jpE})K7u+7J2w-(AY@B*}ylQI>r=mli<uq~-5rk4^}
zpV(-Zpf_L_OEd}ec0qTv((ArJHRi~0$A)f5kywpL>?1bu+Nzesq`y;BOl)g(e0K%l
zhWSFAelpzT|G;4z%U6tP@{7h&tA9k8HcUq*VASNjoy*X%V*4rH!JpND9|w3#D<}kL
zui^=wSs#tS@+M8}D3z>gWoG?Dx%Cf4eN}J0@?&^LR9a$*Mx}gfYBRHp`RQ<}-<@ug
zd>TtFp<p<qdq+3^N6B{t@JdH})S5;HGsW%DGuS{!KL{p9MzrKsO#wpB0yCQ^fA&Rg
zY%wqMz#ty-6Prakqm5Z_q%G8oko1_ivPHPf6#tP5KfXykUi^f{5c67pe`r-argU7Z
zejdTKs%Z?gYJoqrDxjF1^%uQ7mAsW6lNl55lAZXEkB@d4iwR)OO{?Spv6GOQ49o#y
zN1Occ+tEOJK0rK<XBT?@rjb}G#1Doe3lwpyAs*%jiai~hULyvTNJAt7+a|;ZD;GuA
z9MG5THOwmrE_C1^>>LM)5q^P#Fme$zstx}$aFYRD6eI@vMqMTBfyf@<x$tY=9efJW
zBehGtfhaZVcezJuOeji7{X?qxk${!l>E!l9p>$S&>K<ppHQk;V-_WU=;w`)mKP%Cr
zAKp+47Mr{Lj8cMI_YB9od+L>s;j1=yrZ#S74t=37dJu}$et0+P2fliW^{M?5!QFka
zx)CD!yXRb{E=&Rp_O$S8a1f>QVj2mv`e2H9DyfaoG0`l~ReB~$8d`aY+FpP=BS)Q*
zqi!ec>W*!hP;p1r9i&BgSqi@(OS~S$B&Z56rk;?BNSU|D^P-~{3D1vG#fh9mYgxOt
zpxh)<zMPPql^_`WeI31W6*xgA;Y2IV^<hK!NGw0sjO%x_ssNYX9B~v7o5rAeQhb!n
z7RctH6I(iTvxkrmQS|xH(WChkUI^OKm8%rJH7FwHw_Y&kM4ruri3@~9ogOn?nAlPf
zAu69HVq2jv9tJcKlLP?|-!%~%yIxI}#MSsbb+ZAI8d~paB5o9Xq0ri<VuEnKH;!vG
zMe9{~sNW3nwF4d|H4|Glu<0$e9#~GTV>Ottl+KRtYCi~8g4w}1U8mX1X-@nMVMBB5
zDQCs|2sUs4tHQ-0PCxhL%Ci_<!o3kau#h@=y3#2hrG^+deg+h6?qO`+e%w>Tx;7Ul
z+f*lU(IjhkDuqi)8g{<9*mA^LUT7hjFHl4-;PzSWDNLt)-t*DJDW3<;kV`)0#EapI
zB=w_<26WdwaMWcDuUP_S(=y}zoq~W5>M1ds1$`^ZjE@yAg6j({#Ljk?hmk&&!?*ZF
zh)spQLvV5`LTv24=nRP^o!5SXUo(AS5kJ5iLLqNNz#FdVF7f;9^nZtvhi3qO(vrfn
z45;}ZfYSC|H^cTF!hqTK9o#ty<mM^j=me%pP&$g~5v`EaE#swgsMNTc1vSWSB{mV(
z^_THv_nq$G(qBT;m^WxZ4RDmA?{sekp#E)z3!jgiBmzGSu7N7KHI%MS0<xFZVvv6y
z_^(89I={BcHBroT;>n*J>W;;0*!|XGT)pgg2pyJK{wwD35pAH*w(*bI-ZoI^{pjVB
zHc-jW@emvd+^zAD5ebE^(@kP=a2YZ35xKa671>w;9%LD4@#z45#`q4H;wukF5~POr
zPEf-$@KzSWh-fRe_gK#BGA-();6l^%E=UgAVvx3Wkud3x|93Q<+KEcRHVy}UyNcdy
zQ$+82LT$u@b4@edg^oZlv7PAC_zdL3Z`d>$yPb@42yo&k3dR9$jrtWdphmwC2QA~~
z9}o@UxBj{_>@z(&-mUr15K;{SlTk?;a_ATlD2C5BxuvuN@ji+aY@)OmdkMOa5Qf`}
zvBChb%U7gJ-fJBcC=H7eL+!qXSHd<Cx$r2lk@A|1cIHt+I|`NLj<*%1`X~_2e~JRa
zO^}8@3J8^*WrW(tqv{ErP&~c^Fb?lS7ze^*t?B@bt3Hw#jXFXY15rsB%R7i#p?fUS
z{m8D~LNh$nABBhdc!+w`&tDOPgzQnjAo_RSqkeAmZ+4st_dVlb`=fq=RM1u>E^>(}
zCA491Y^MGft&YcB0?y#63jB`igwqSr;P(>RZ~=7aj&<E=WN6V~*QXb;>(&bydNkM_
z5+kwu_8{TC5C2B&I*oz=Jiu)yAZ(1LTmUP8nIoLF7Hj+}4Xf+~gg4=Qus;cR$NTTu
zNkX{q7ecrmm4q-kPV`Z@V~ApCh&mdE2$)Sngwn8B8loP2h~T}XAyP>QXC5Ggqfki*
zBii<ktkr=Z5o>t313~C@&Vb;NE+<Bj5rT=0E~enVp4~kZ<0aTN#;)U`7(bUsp%S`1
z`w87zI4qnjAO%A9@@X7#7X|L(NP)nRi93{reMH<LY(jzHWQTl23dCu@*3B&8+@X@V
zD~LjOU7$c80pTX3JbXZu9b|-(0-<<(XJ8x-%Z38M(D{h0ijo+N+D8}zQArrfFZA?L
zG{6vd2F7viWEL+0hiQo0Vu-r{p$|M0h8T{DvpA%^gz)ViLU<pxMF^d`B4sP@D(w&o
ziD;|tDtZXJTVYwfE2fy!<SMVHk!UVXZBMtY#UPh%pO~MSjPMRXIEm)ML2tfvjfMC~
z4GZihHWr59p;tFC*gnx4Y1GFEF~F7CO?0mpN(Hfa^{uPMiap<^auHHsrL;%c@>&}>
z24E+bT02k5)O~jo$F=~LQ!B%+NPh)lZ@t4Y%>?U~u$0OvUTnbO7%#u$je!LDOoDN{
z7bu;;Ft&!bN8p_IuAZ*!r{WkJ_PDEv>6WJyJfiyYC6Of1#s|(k!DAfc2bV^1S31rX
z!6BM(h&G@?Ul;ou4&k48v7!6@oy6x^_!5&(CK<=Bf?=k^j?}B-JB3F4`50@0HXIRF
z1hA=po2Fl4>qA&yuu5E%>4f9E06w}ZK0z1{-1WbT_Z=`2FtkE)5`KlQ;F0GXn74!1
zW*}MRiGU_ml7k%SChde3<6kn0wL6G65dbFMFxgRJBM52I7l}}(Um?RgiO~4S*0MTX
z9|Z$PX<~P%)0{X`r|Ix_GrL3M_qCGLX~@rnxHBrbey)SY!>Rn%9S9dg)P6mH@Fj3?
z{q!0QgecAJ0feepLf96*Z(k1}oY_)B=((K`3aI4zxf3>t#HxN05GJ(1dPfov?g9>u
zkndGB$6i$u5Wa`c!Cn>I)7vB<jEayDUfW6tkD`(gM)VXj6|cez7pXlJH^Q0sB6Wab
zZ#cfKuJ#pHg@aHp@w2+qf1)NSnB+({YzrIi1qL=XlSQNiP0oO1!zdo#8ypOWlY$My
zCvq79ACFd1KN7k?RB{=S4cowmdjsRRrm~DK0f)(ko4|&XfzYQTA#{Ta;xZb7e2_->
z?G{3KA5MqMh}?8-xamGX*ceT@j8*_MN66iD7~FIpAiN2;0yhmeMlx#T*;GQfZ!;lW
zk4hly7yIf&t!WML&Sr-{HO#kjj91vLMwI2?ovI(;c%gIiOQ+pF5pP|q>Z(bdq*N`f
zINsguQhiFD%<mZPTo<xj8`0ZEnAirHQ(rO4x*QIPZC}&dt;uCOj#T&U9m(K#7ZW!{
zsK@8a@oS>NvioQFD9DfWLtn3kV#BH*^r0)dXBv)AQ5@ADoy}`U7#6}!j_(hJI0=I#
z>5bn+==-6Pq*wX}Gz{+NV1Hm-8G?1A0l-)rfr4YK`)rhh0;Mwt0AW&FLfDNw>;NFl
zm4iswMndR<N+2xk4h~_q9|njmy&sZ0gV&@rMB3Afl@}041Z!CLfnt;pfQN+x#U4Tq
zXj~j92HE@&M3&C79*=StmIUEM*&q=95qNN12%<|EBsOw;94z%jyMYL2ppxfz*;k-h
zAJpvILFmffKv_7!Ai=xB_vBGJWH2yJY)u%)z|^^Hib0iRllUEBY>i4To4t_DziN_p
zZ$%?nG!KD-<7+Yw){N3sLx8Ut`~eP}Aslegj1QFX*{vshFJRjwnzP{Vy;>5@ahT`-
z5>0e~BpQcW0T2Y8PWnvu?FLpbP>d5sff^T5p1(;*ll?WU{V=eQ4~#hE2H!wJQl3J4
z>e7U@#6o{mLP#uTBo@B>G^}bEa^NL?63CsR|K`9E!^PH(;s5|9Q)v9$Fn;6s_!*|i
z!Hs}u!Emur)Bqqz5cg-pgUcga)zH-Pma!$~`Y0!^0@1>tE$|l~hGWPEH`K7+BcOf9
zftQQ8y9Ofmh4qg>|LQfT{@K9wRE|LZ5@qHqzoq_N2$zP8XMug*s97g9FnXXZ$G8Bf
zIYu}v2ZayJUk!|B;7>5og6koS!FDol#orLdFHs2&`z45e*;#e0xI+l7z)p3s%C~u$
zl3K2UQ-v$Id!jR3!3~p{a#vu8($<$BOQ*)SAQj=e`(Ge4AsN_kI@Rz&c()>6DQvXD
zNd6q(Rj>s|1nKrz_D{3ECXQ0^7gzLxj#C<0d%2>WlWK~maLG%`9;^>~q3Db1bWdR|
zifmL<0)^Rl$UHK^ty9Tr8Y1J7#C`z9$a>JoR-oKp9=DDtC*DMWn>tj$oE&2P6>jD`
zmnyy5G<R+2rN{Sw(N2MOxcfZJ+-qU_nN||nO86Lw#)gu}E`m26h96V4ar%mYLji19
zG?J2dIGCp&WBA4)4~Q8Bg}8(UeE4`0j|{qa6o$_S4h_)(uIkz-D8vw?EX2awm4x*^
zoD+smO5*=gv*xKl*ceSY!WF>G5%TDOepRLd;mr_2cp0vUBlPr;5bk4ya6KvsVRhi9
z4kU@Z(PEJBw-U!tIz)R!UV}owR-JTvW3ftwGcHa5N8)s_J=sJZ{P0xeXMk}r0VU1K
zPsg~~**M{CKMX@dR@w(IFLp%WQjHNk>TN0{vdiG>0GTpIT<Z4^ycBTaT+?=1;o_KH
zuQ092Z#$uKtp~Nh8KL=9j}^o+mA5d&6`AN*vAf`d>}B;>v0cM^NH2(uMre$53usMa
z4Pw=r3@>5ZD?OWZ1jmK{{98@Oh5au4Ee-LG<<#gKcsNrd5==$so*&gizAvw5S6Q*R
zqwz|IyA32-Ezt~bD2zitM1)hRAI~Z2<E$+D($tTXl#J2BA!iNKjmPrALOdM)XR>bt
zX9>}sWhThdBghi#0bun6v4__|NRql$9}woe#ab19B4$|!qnh1G$?y{tPSO#7$NP>_
zi`GlIJ7Te?RpZ<yqVOOVn51z7LcMZ`BO>H!6~3i_I_5ZalF~kin&KkI7dQ2+#neeb
z&OHk(sUq1rqYAd}*ao}yL(Zt02}|lDoK3=Em>4`<J)_bHw;b?l;jYb%T=zOieAHP&
zd`N>=xN>mx;IXJ6HS#yG!_}yd48HaYd9KHkll71^bg)i#N2?5HoQdZ-wmUA7)2Xeh
z91R7y-1t0_q|H;dg|Y*micLM0K%!UbeJsb5)}4xacJ)xy!{OO;DmSN$dKg)=RdrTy
zAudGdgzBhc@pnA(2+11EY|I5uNK(?orNWN7=;)kD-ogqz)a^GVph2Rq<&wydU}>o*
z786FiNY>EN51Ld-cWlA&kzafMdrWgyk}hU?9Mcl5pJ49hv|=&8o+7sDJB!z*qLzGR
z+#vX2NGB;j3-_+;bvIk`qntE7a);aVz(=wKd?c%so2Xv-unt6+b2JuGmRGtu+F;G9
z{}lgbrW#m`jWk?;=MpEk;U{Wv;y+a^5*{FLJ~|cdtB;-RZ5n2X^@Ld{4$lz7>^}fy
z6>c{D0$yokhUo7%doiIK?M_}ugI{x`d^|G5B>}&<ag8{U)6%dlw||kj;=z2!ZVGiI
z4)gIgIm}@eu9RZQ2P54DTXZIN+@@iaF7vmYw~gE6;Z~dXIRbsw&1{eTfT5Ts!mr&P
zx2dl`>PT#(7ZPW^;k|0|lsrL9R9NF>*l`)&!YhPXdUeKovb7|jLkrAVlTu{=>neZi
zt6{K;j2YrL*oa>B2qyICI_#mjfZ5g!Rdn5_3W@G-PORXD%G-MB;Wv7=^@b|QZ7pg{
z)&SlhKLz$RXNvLGU*{C-S(}@xFhPSwf<7A~U4&Ywn|@OjuE;57Y14bUh3u;(VP1tB
zQ>wi6%IEMZFt8Ij6Aed_o_!81&a=c8P6zOW_k#c-FT^I#68i{3EiB8=g7d$Lczyax
zoR<)f9MLqX4*xB_fw1Y0nmG=hqGZixiwy&&+<^sRHvJVm5Lt7Y!J0Y$D&YBKw%Eje
z>^!2^2SAvc-a;%mh+gv>B#t83@*5<I@j$l@G#2H6dn4Oi!qSP!oEWQ&M%*QYH<7IB
z<`Xr~D7+3mk(_uIn(39};lm6oXl(1Ycuz`=HqQ~e`i-_CrI4<80mpDF5xT@bp&WQ=
z^Df+%dU0xC3&2$2ors+@-2u$Jqsi9NwEMih<kUB35tZermlE`?@$Q21nwrg;3lb~P
zgPJ5}K9NW`gGBROkN^ykcp$k!GZG4!#Pv)faSZjGgj4^_7Pwe$_SZhFOaIJ7;WhH@
zg8rF}P*w+Jd-`V%5I#fMyn;!tEO0<(kVEu)uz{Cwb$N3!?iZ7mhmp(6LY3#;e~3eA
z-}FasbdA7*2u#&;c}o|2veWDMHQ5C7&xVOcqm1j+bBr^ONFC=`j1o%=i1w)Uj&0wg
zb`v(dQ%lR7`FI%mSmjgq(|2mPTHc@Xp_#$f|M<aJ-VV+5tLJkS9N|QlZhuTQ3mTRg
zAUwOGW(j!ku)oilB{Mdj7OqqSY~HZU2%#w+b`HyIA`E=1W_O2Wx^&fb!mCIEjho>(
zW*@n)I1h6LV*dz^7c)~p6eQ};WVrUs-%4-JkURJRZF}ZEt9rz`#}s<|RJ@UtDq<Fm
zg%=u`NhG#N?Qfmd5IwNY5!VQ{kel1ARY%($eoc+AG{chCs(q|ecN;7`0~IwaeB^62
z>oy-2KKU~U|M^;V69t?o8Mw{GS73DpyLwU;Y)j7W-x;!@=b?h|PlQgAp&x@s<b%@8
zVCY9?09mI6Vhfigc+x9p0>WSoNSzjl69p?c%x4QkH~ZJq3F0o?A+}r|tLXlbIoIH}
zE_(JE@A4AEWjLTs?<SM4&OQ|B?s@!o(k&?v+vtP8K!C=uQgy{bc#^<ZYSv~E4F44{
z(3`gl;Yi0XLN1#=jmQmy7u72V;8$u?JvpOczdDw2^LH4RVL43NWZz|r5~KmTHvC-4
z><Ft2KY6=OuiX1sU1MotAX4F4&SO1=p)d<y=dq1~m568bg24)bON{SdTapNb^fMNV
zA*~+6LP+XEGl<_VXn>_d{F=s}2VujNH2pBK<8NaBcwNok#C8|2O9-l_5`s%`?owCN
z@>AO>UZ`1derj-o7ZS`24l@!kILp*vtjh5@8N>bpC?(F-K2x(Bxk%#cK0^<&Tdm@6
zTJ`$e9O%|l$eDCLXSTn<U;Xjd*;Qd1ecn-0ZJt~00}OR(?G)ljM7S_@hUP&yfm*F*
z`?X?|&_mS{s3Sm4K)eI;><=q>kJRjD+ga`Fr4zdKaG8$Cm5ZLLnp@X(gHfD+stOkV
z1@rHos@e!A@X+#^s<HcO^a5N|PRHB)Ce#JYKTnKx`Z|qpErf5Bl&$b){Bi}7{4qx&
zlZ5N=ue**!rq-?c6XMBzq}x)?`qWQ#vzOk~&<Edtpk`f;Mh4aU8UWPOC!fL&YK_fw
zbNlLnRB{R>@azBL+wS~S#<56J_@r}C_%6pHlYOcYMa(qbxF0FGtS`h~ZVLf%Fak2=
zi4~~eVtB-$HcP~Cp$gV~>`uJD;E$3;OT<P2|5S0`h5M)P=*re11mNA57Vyj1<H4`t
z2$0KU*=4v-BKB&b3Ijqbq{y%87hryuP=%<wCKW5Bz|7}&e1-I}nw>0wYP^SE#R@6h
zZ1I{@tdPpF@Y*MY?kFm0Xv$})BW+<Ncty&I-Tpn^gMD=_$xWyWB$=NSG^+QoQj$?5
zT5%O?egq}RCGi2{sUEs~WKbm3+8pV#w-_Tc@sR0nyA?M^QK^;^u%@@;VwK3x$x}6%
zKzz8O372EVGBHg^f{W<)r8qI*7F-13jT}!ve(<<8@m8p?@^%EvOJ70~gQ0d@632D2
zB=}m&A8NL5IV4dJlEhjH27*f>k#q1`S2>oDUx4Q%NhF_$bQ7A}V>bM+s<i@5>wi%B
zM*bo3F#(`3q(m{xDN&r^p?i$CHi*Bz9EA!fO#ER=8KH~wb3Xo1ZGJ8X#c2;?8a5aM
zCt^0SAkwAV)E<h5YH8-tAI&Ug9z`Ei9@c~HVLb;vsG0~LpwPvIVlY(n=C4puSG_6*
z&y1d<Li=|X5&*D9uky8)w3)Vn@2lBqM%%!Mn#8s~^*<)eoK}hhg-(FvDXpIjIr)D;
z#@@qSQTJqaFW#%cZrZMRe+BYEegi~Lhges|VY8)^unC7H7S@d-;phEjDLKP3(sx7u
zmX?ubpOR8JXZ0zmT{qq?0&5(8&*FVtw;zCyGoS5!hLka;d~*QxIlJE0Ag_jUPY!-e
z1UJD!8m62q`77kL5y#bR##ds7kchn2a0^Db{ZrT*ZTNf(_t$5&*w8tDB(<LbCumr{
zahk}pucleZz9wc45>}ztJk$DlVy2(Ns5@jQNTGgCf$7|ynAu!NgTKrAT5RhX^*`TI
zIPCp`{r0ukvCHb))HKH*m&5Q`tpof%{Q(C7Q^n^Ca-0z6$2eZB9reF4eFRKBzY#mM
z_WeIGZ6Py;13Eee4k$^l?1(_1S4KWnvyyMbuFn6eske{dGm!`27jH-(AMByHC69XQ
zt(v2LAl|o@ntl2$tWkGU%{1Fn+X?F1vNiIJlSL@@Un2(9-2_jBE7S1HszXv6y6S+8
zv~uwXqB#ZSu$79OjHcED6wrFd`595dfg5VpV}3@cunZ5qKbhigUGU(wp2bzicnZT%
z^uzp&#y$}@fJmG=I7u9p(sRLsj1KZuV*ZC<8)*}!bay(101RPf!&U31-vEN8UE;BR
zi1<8aK}G<~DCZzR^A}{q2<=fgd9B#BVHzS2uzFzC%5naD3Y<uirTxVbm(8a_NeeT)
ztyf^!SwPq@Zy^(*Db88t!@91+-s(K~z~2^TxZAq}psFRNyeL@PJJsL+Z_08p63cz0
z>{&IG#1Mk<k&`RF54=Oop00y%$6ZykB|oROR{*<Vjklg)i_)U?kZoi5HodYDekIwC
zyC%uD&JaTS*CQ_5(n(XA2(yq%|2b)jmoNeklRf))b8@{xYPX{tT}+C4mEq1>j_m3p
zJVzgCw^nievXsFeK|yRGJ||uNyP6&PbV^sDXs?>tPM*@syZ2s+nr0ADON8?@WtiJG
zh>3$-F7R{(3EMbbyOYp7UmTZ(!-H?-Wr0+N^~BS1*}S9t(-*YwdG)-6yL2Go-V6Yf
z%VpJyG=Kj~T#gB1yhnmK!#_cc#s7mE<D_%MFntC2+3KfpG1iwZLN?p`$G9>-{V03I
zNj1M<qJ18U>1dp6aE7}9gHIAwz3%t`qPi6sgNdq~yX{qX4RGYGcO+nug4UR062$#<
zTfDr?{QQEN?cOMkQIy|jo%X3c?T+`Sg)f9hes9Gi$jLI}%-;#sp*wtjKdR<e7h3n+
zNos|AD;g9YmE_<C9D1b{yc??y9^2CTbowJb3l16EOz3x>hg(-RE@Z4{%qJ*M%zaYz
zhx~@QGGTmm1%}wPOk0afR<G;Rk1%$GLpSxYfVDiQ9dA4P90e`h7w8@xW_{;%lodNX
zbW&r%@0^-F89E6c+r@+Zut|6|upEoe!zMM7f=|kg2_3Bi+^Y3#&5a439@cmwL;s-<
z5h|?U>OoSNISF4f4)@;)+l!bvsfRZv60kUb*fHM3evlC*+i}Sb006kZ8_hKMeBJUz
zQGR*ltKXy;=5pmXNm8N7rX|$m5Aho7TR%Z)lcVB;+0_s6VSXb1B(_HNCboLQWt#d=
zYE!f%qiKtiXQ8DczW&D*#6A&kF5~T^&hRHxD!rS*OB3|UaJY_lOEP?egU{hht!B57
zj)q-YZk6swcu^H(cnDWts@b3dwDI`evQ3@;v}t=*%~lm;ggQMT#ep}2rs1Y>Om)i(
zG6FiR{_-(@liNwR6i=4q;*Wy?T+5aX1<)xjzSh$pG#Su!Jq~Z!bZJI}_1nKNyuJ5N
z|3cV!8rrusqlYjA51p1}3|GKa{IE@IXx%CaG40?oxU)S=@nO}uSW!ivE0$#_?XMtE
z(|M0ODCqNLhSKK_!Urr1+iIm5l6ldaO(}Zi2L$oB?V`Kga!3&iTWApX%XGJ>BT}!3
ztIg+dxllg8!$SA;2%h05L%K=1m%0ZHR|0SQ5q_bb+qNU&E`v!|%$XA6^)0vE*Se?O
zEwdf0ot7U+b#vRt`KrSQlvu(6*&f@~(w(8->_ZyycSn3{?Uz*hwt%FY9frY~lBdc!
z%5(QKN{NyFz>kR_D$Vr<REnlg3T^SruhgB{?R7rKUhARNbtu*T-&bCK^#k<#)$~bS
zoV!bn#_1{#q0{q@uH;u<##O2y4{%WBN^C$D6YIg@kTcyO!$D|N?g}_k>7+zrtt}#q
z97~eDqC<sW%CIQq6+KMQ;DN7<{*%%>R#`@7pw|sepf+6)40r;W9iQD@*nC3G&c<g4
z2|0MUorS0|1`o~&*<L~-9-1d)`wC%r=#`M|FWBHA9S@H8p>5*+3h;!T+8?2wyKveF
zVq$ANXSoUeN)T9Z!d4KGfjuEquaGGwCuX~{vvU@>@(fhmaTTp;zbF<`pl1YLDA(4*
z>cY7T!YRqiO3ZE|%*JpLu6jF;LD~>NYbXhG{%o6v*B<yYxh+-fefdFO<*!$kUgY~c
zUJFr8lKQDD^?D`zICi1%izAv&2^m7dcR;*ovwMT)-$`&b9IhI1jK$WA4YQ}K>=N~7
zbxlV<V&CmohYOwIvLRDfrrWRfj5(e9U++szOy2i7)Sbj0*M%5p3dANY!s>R`q?Wc-
zBOhTjAK|UBiQYc*2%bB~*>H~fjOd>EV{p@Tc>4EHp56~TwP8ZF%G1X~0;6wb#u8W?
z8LSS0wXarn@!3n6xHvT#5QEJjHf;dJ%9*{p_zadH#sMPD93p`r#+8VDg~z3`0#(nO
z<Xqc61)asmR3`cgYf)jdUu;(YR2+3{XSu9R)eEPz2#72t%bU@dLM38#e1x>oj<=HN
zj&yf4ja@Xw-Oem`*e{0EHHn2q97&`p`VZ^D$9GrObn!l9DH8+?E|Z=FAY5J3yZ%A*
zDLmrX;wj_m%t0X*sIWYBy2#i0yrtWXy~dn>!G*tm2&S|<9j1`;kB?)hLrI7&CWcIJ
zx2MjN_rH%KB2v4+?-4pl!EAWDYJ?F!$;mOUTF+fCQF`#L)S_A0w^EC(oruyZv@lAd
zM$@i4rKUIUN=>~F-Ibd5=1rr_o3a$`6mP`=HJgin8)Tfa?C$a_5~lm|e5=6;dA_wf
znwTg$1AR}4hz^I;!;2u)z`GL?6#L}_xAKtaA_aW;vf{io06BJdLSL`_=5jX)jHF&r
zDs~jE!3ofYn@?#8pHY<MIMbDwu;DUYZIvNQIxL<PZeZ?l=CC+G5DuwX&=GN{5Q36<
zN5r(O3wFb$E8JVcOisX0e{ViG1vuOE;&GH!Nn_xp@wS+KBmGFoeS_P`$2hmc9p$#j
za_G`}+$&#&Cd7+Ac<O3Pe7S!?Y3o3Po%rqRP7jcIn)-$~RP<UsMQFSklMc_X^Bh~2
z$_xK=p~aYj!fn}2YAt6s-l!u6;F>mk8wID-oT_#k2RWH;eb1$@P)GKwjKaoN?Pafr
zfy=vwPnzLQ6Q;(k{qjV#W`A(YY__}SpVY(=^jel$0AQtKZBIYzhc^-Br>^bULD>4G
zy6|#pfYT3u>T~7<CD)#2x2@K8p)!-TyqxMOeEcQWNl%F3bz6N&ajf=KoLTLELL9Hc
zW-v}9;8P~?=3gQ?Ozu#O;U6NYjp-PDRbvWP^-z|;ze3?K^$`e%UrF^Asw;=FTI+i@
zwfhUxhROzjqNJ=L8(${c3!9d!+14wm4V90ULZ$Qfr{QWlxJkMazUxdK+gt{fC<bpo
zT}=&1`9=C_bzBIo$gW3TN#CewgwIn{u9s?T{~m^#dF!YP(eGZ+AFh<AOs<-QNZPVA
zZee_TzEoPBsCS$;9t(+Z#prOA8t0j?%JlrZp5D#Bgff5yz4HAs@VkIiLwOi(mPcb8
zQy2#p72MYMw?=x@^`tmm8HXpJ0+dNXaK7Qd6l8pm!;SBIE*2^~{LQAH5<6x!{fijO
zFXCJ_<bU`h5x|PziJT&k;~y&uX~ka?jLYey$nYk|QhN^OOn7DXUwBo3Qc<JBdR$0n
zZ1SQdF>wp^CMIA918BQAZa`fBe)xbi-g9CRr$txm{#U?P!fBl8t@nkRO+78DtlwTn
z(T>yNV`0ro%rno3q1IhDz#-tm12=Z}3{JLvoChsAD>f3M@$k`Ev9)#QOK3CmtQa42
zKvY}x6g$y1JLm&G)2O??nw(D=y+F$4S%OZ+9dt%*WjM6Jad%EBs&KX4xr;!eKP$S~
zt$9YGIeARY8vZ7FWL<trf7bbiOX?*5V>OTb_#6O6_;+4X`8CF71bym;%J%cJX@IIq
zOvuf^cLd~$DZJtU0Y_L=4B-`>sfD{mg;gESjrMCbbGm@-lHvzCebpen5&?tV{!MHs
zRKv~ce-rz4-W*PnUyem8<hT5HF@6mTP!<C~Z}KGMzDUe{@3?#68~P*Pp~nUEf5q=&
ziuLRBczXN0_(0IWFe=K$W`fmPEP9?3w^>J@Lmj>W=gzL56MMNVUt=lVR0yr(dC@Ct
ze|ePIErPkY>nS0(4ZKWrw<?lm8uX)*e;mh9RoPkk!b|33s^7MfOFNza(HX#U>(6+>
zGSpTLk&8z2B0s=XbxSZ{Q-P8%uNX_P&5ac(ug%M!A&ghKnV0{_%iBTgxS$7CK+t{l
z%7a*NXn6sG{ss?yFNi$?HDM&^L^u*m%J^?Iel66UrPLkW&vyI*wN;6SHGB6;^i{wC
zh5eEGsmsfs)mDeHt*xvMW<&5WK}4m^f51g;oUdlT{*mh2bWkCN&7QuZV3<7(*o2)F
zB$R)K66GtqX;`T>j<;PB(`~DAKxdm1E4iEMBaG7xW7qDcs@RK5Vymnf+ld;~U8d%U
z=><)W!V>a#1`&!9szhi3IV|}BQ9|z3g#6JJv<bm)MdFrpkf89+;PRTBg=R>cO%5T>
zhU|hIj2f4a`;Z;GmpaMzlh27iM~T1ok7WM7yr0@C>-ARR&&kN&l0E<750wV~is${G
z`~eE|;YKYb_b5=}?^zJ>cWp;a{(`QGlWeQ9!C!>4#9y61hB43AVl?~vs@O7X2IlLB
ztQr{kbA;?I<wunU{=$Ihf6I@cKp*kNlD|Q4s5G*Z1G)U58y50gv2%29+uSU$w+WvJ
z*FlXQK#d+ljg&u<;NZICf&CH7I79D2jmk3B?6Z4NqZtJ?iPhdE5p!rn#9nVhy`)Bk
zH=srKnIJRHO_IW|_vKN#a06PzwvZIujl^0&jy0r!N`n*<=l-8k02D4Q{GujfkA_K%
zE%7JDW<n<{q`-DoruMceo<m|_`|hUt3cK&gVu;*qDTcF{RC6&rnk|cg<=3R9+$~WH
z_akcV7-54oRosFcn$9-UhQ)WywPDXDOKs>45!R4{nKq1{^?%BNYlCNAP0serk~rJy
zOPsCxp{5*C??79(%mjb_vbGMc7{-P?hqkt<fVQ^VXvyF2=-dCzU*%{2fBsf!Yw~CN
zxx`-!AL7pwT46a(4=Tj@wr%cEHaMRxeVXdRI#s9ovNd<bX)cQq#Sc*!mKD|?lk{^>
zaZ5#q8Ca_qM!O5ui?Nn}4{J0Fy$F3;F(%yi#QwI$)6rooTh`$L^#ArS_V%9msY@j0
z$cM7=(FYmb*)3RSxDRxXrm5M=`=W1Cwx}li#|Ov*@5u)qgJ~T2`(i)a#A%>YA+UFE
zLFX3a`T%q;A&)b6*ONBO?s`#%?5^7_tVw6XAc@XdccQZgGXw*jg1=JJZBI`H9fLcp
zbJN@%4q8jpOz!X*c(fcqsx%my9T5F*cSBIPa$|l?&aOC0ob`4i&Z00RmIHX~53#o}
zeu|n+*NFj&>%;K&AY|}z4RM77rLwH^H)7}J5oEnFUCpjOf~*H2a9BFFX_F;Nf4UN-
zE9*@%@Yg}scIlA8RRz0V30Ys0>8!wH)SOQE_cERMG?~t81OQ7qFUL!C@?D6|42+gR
z*4dSyQ#@JLohs0|YS10zau&LSg%?S8J~ikL9JwW(uKgrB;SGq6JI2XCr{Xc`&ZnT$
z9{srqI#-}ORirzZ%N?>Z$!*elHM?E~xh<NcW^cez({^y}mULdGOLWdU5uH7dyn)WP
zhpGK-CV~ty3LfcqUzSsfX<t!)OeuxKI<BKWiixs{UV%rpBvX5dL}rpBkr@QR8^{#>
zDQ4MzbE&2c4}2<)bGf~eI%Klp=|!>)7fg_BxJfrSX-i5Mhf9=hIuNB3UvrhiOqfMH
z6Bi5pFAih*Pg9$*N6*Ae&vuw<ng_Mt!5682AWONIs`RZKXVCXI!$usH6BBTQ<FT{U
zY+JSH<<_bmQSq^uMAHsmHH{IPm-s8#yK5Mu3*2vFj8@bbqi+mjG}bUi@VAy-T7i8`
z3fgDu@-bRv5?<_I2q34&5FOb;Up>bO$qsrD5-9U@;u#pVv~Tlt!VZZ3w|z_L#J(9d
zIUAcMan{?8IE%t?)v)guVsG2=qa`_TT`ia8@DlS(b6w5<N|wXMR9Oy#;D&3+K_gN7
z)0U`RDKyE!|0SiRqd>=yP^|pjJfWC@M94g$aD)tN$iXb32m_-3Lk>KlxRz0qv$6z<
zv&lBZ*$|Aer5wI{1v%t?4E`c)Bx73m8xQnItdKSxvN8phADNnc^%_Q7Hd4*@zJ}4x
zfZMec#OOqcoI`CQ_xektAPV1zi)~ZS)-)y_5XT`6GB+lxLfM$SQsjVG4)>b%76EaL
zKzNgv;jqP91jJko7>BdrULfR*>}`}tbj(NaM@-(hw<%N0BRC_iCgU%0Ln3LigMu@T
zuFGzq@E>>qhto9~=UyNalWcRw-LN#mBYDIK*$eyuZ)ho@<^3f>bF7Ham?cIpQ1Bj>
zxoS8%gvi^0y!1)*hazt<(hqa5_RCT^@?IGxyEVAc8f13iE2PvPUp;0_N?S<S;MS`D
zg+_W010BOeY16N=M)HZ$#>GU<G*OCyEG#wBe4;dD=>MgW(nQG)e%ew1Gm<6F*8EGH
z<s$X7)W~DcQd4Z-lvxV=6PM0NV$5ZI1M4JQ)-MN3vTm_uLQPVuzL7}9y(dylF<Pd%
zX~Bx}ynePr2AgSqNSUnp4>4Ue*ZjHpvgWfvvgXH+uSsiHoJ8x^JEB#VYZCajSE;GC
zjZf6<P!4hu^A34q5r=mua-iIys<AbR3|S))nfI26e1efO>kumt^8Edi;L{Rvy97yJ
zfPST`*W`mf_c*`v8Bug7_Jf4Hrje^QV^tzwS@-xbtAo=p`PD1iVba5A+E}5`E64L;
zy`#JKh6o*{1QLtK5!QKuzQw5oXdQ$_Bw82jzU5!SPiuGXz@BCe>~D)X_6f&~*cqP*
z9pzxBhY*50x{e%oFvm?{u-rPYnP3GctGCY62!*imk+t)N);~Pqj&w&hRv<9cCu`^7
z3u67S17efsnw7PQQ>s2<q~wdZi?t2)x4dHV7F2}u4t7CqVAMo9Gob5!_yf0*b+0zz
zUo0}r33Ac}50wr>%!Lk^<Y5avA)aRdRIeO~x&m59V#{sveEgH(KFvk`K8uTluGxmj
zp)%z*B=U`t$W5%an{7^F{2+<MwU=Dvl(CY?ZSz|Bel?P+j3WPMhEe2ofZeJ7Xjk^7
zZJvAE$KP`j!wwszv3Qn5f`;e7K#4#zPQVQWV0a|>3efO>oI<rGz40nG>%;)4WSYZh
zca~Tu&poz{L}o*&k<58y1}0%y%Y-uirk<#g5u3D>?`{^=fgVM1g2qk_y>9H(#sOGt
zs{@hcZs7fScgRR6R3=3I88$%b&*>LLX4mH=FrH3%jSlo*g~(vuogt-qlNnfp0PoIM
zc6shG_rK#*`kScC`^>yMJNip>0y!NA&@t~04uaU_`3ThrEsk~b8igH2@ZsyLtw@0+
z9f$#jGTe<zr@|BPA|yWC4Dg|K^P0q4p^9%+L`YY(L3RIK&-wZEpt0Ahk=~%<<|<zC
z=l7_PbovP5xuZQ6)7iwjc^<>p_QO(M4DC{LRWA7is*DR6{z49qLcYrG#;b4)05OHm
z{9KmmWJXhffR?h$pOZ*SP-pBau3Q@(<hyDF$-+2j@Ah%2(rDPiB(v=?XqD?YmqULs
zvcCxV5@`p4?e9y^xCoq6P=bQ2gZ5B~w}^gb*f&eAi<*t?3!hjI*b^n}B?pYyG0in%
z_m;7X)x`fanp1F<$gT(MLoBhEd}CC&vOa27O4y6na^Ag6*yGKx&+a4fUiFNyUxLGw
zu=_i}MmHm(n(@A6q7l0XuyY&Dae$4!E8-+R*>CK?N+fLt@tjGPNT@i85Ri~<G{RwY
zfFCDeGSQ?6ok^!>Boh_%VTeTFREd$mYouu=>kN}gta?hl$e{@l{7hQ?yg+}+>zfEf
zNg|Sz_+oF_Xin9K(d<~myAfof(#L{IPH(9rFa9Jdx8RhGn#Ae(JA&Rm9tlkJPR=s(
zIY9<`vm8NBkmzOXGxloj6!TtP=q1tX%;|;yhhDiO#^@dQ;zsRl`rUg&=o;5c9;4Py
z7^Ch|@YuiCNKA)Wx?zlbWKwxgsB6>V#N{!{b{ril3_y(9?3Cx_RoYW+6+8dWX`NvC
zb!5v&JP1JjZKpi{tjq*L3EiFxz+7Fzykm{6t#IU>uQkKkr+>pG{AiDn30E+|jXNW#
zPKiH&VMsV<V!#s#JXL|R_1Doo9SrMt#TkBt07D_(83qtpc(zLwaX$f-rh&nW$D_Rz
z2q`}}=MAx5gB*w5cFl_uIwaxvW6<azyVfY;J9fN0_+$_KN$!U%I;fs>FsIpLLhJ@d
zEsG_#F_0pFyl;><#IN@_N^l_#Fp-dZ8-U#)21&zQdf;ed_-HRyKVWp-gnED^T4fgC
zzjZZ&pYASE$BO+O-3cF}uGclMB<db;;D*(A>XfG-z~#SpL9covsbUc=M)wdZ5~W@V
z*T&$KsB2!IfYFI&{Ykc!`t$1}!uT_M7#+n68;zIf;pzq}^TGrH7`g<H4i3G6F(5&3
zR$iq@taRcH8>69-l@x!l;)3Q+l#qpHG-T1(Oco)XjhzcjFqef7ASGFtgWvwh2!12p
zjDay;G6R1Q=Z)dPObj#v|L$<6I=4K(A=69<rT_sp%$=ktL{cXOGYnFa2{6%|k~P+X
zNa{a4Bua&FWb&AodgOU2;P>XZ=c&Ah!!ytUemZ$F5U2SK7Xe%xrDhl0^V$ll@lekr
z&!>L>IAf3cbW^jo9(f@`0xC5gc^--3nEa9uj+L~>?8Ly@vsh!3C(sQVg=3@;8@Ui3
z>3TmP)}p`ySeuUkOnXHk&`9{pn;sa2$sf}wm|<*d!q~d2X%y_^0VofG8T8W_BmJr_
zW`pnw^8pe~ulq#5J)D&#d3d**o<ttGUCCaoQW`qc)`YNi7jyCel*pSyKkZ~95A883
z;TVNX{vIa}&tXX({_dt1kxwD=cv00z-h{AqXLIrZl*yYxKaDn#hmIJ@FD(5a_5Lm=
zpJqm$n`2;4(D#NpPDY-_4g`%36dHddn`3|m2X});hXq`MHV{VcUP@<ChhFR2R}jWV
zSj~hvO7;Zr^u&kkNsYe5n%k4g$X#HZsV{XCd;lqR#vJ^1M<e(R=zy^^Cp;uscDh5P
z8`G5Dph*$~@LNxOi2-CsC3Uc3Vi0DC31eWa1p|PT7%&IF-ND2Fw7|%~^hc63JKg3C
zO!^N4-N8UZVgM;lNqZYJ222<OV=Nc|q{M(Z`0XeY1JDB_17lvx4BX-j(45{<0&s*+
z{D=XhC?(rqV@3&>Fa~zAU;vO31Lokj+nX4GY8e^WJzgGyo1B49{=)#=<r9BmU?>>S
zVWru~fC*z@v;_lzlo&7vzunHn0JO)*z==O(3Ebce&{Bh?1meL!05O1^rX-Eu2_^-&
z5EI5gl^Fx^K7f=MFbBWg*2Dm`$H;)q1DS#AoB;%4nE}=!e6+U$-ttMKyp?|bNO4Na
z%?996q!HhP4rb&NZ(+VEkv9ilV*>vgx??22sH-#p`m02~5<%4DPMw1CnhGNok6EXn
zJP+a9scJSPD6f%gEub2ML}o3fIAg{n=tiO`(uh1yyNMm?Xv1$<D&HQI=Phh&qh`Mc
z<+Tugf{NA(&hzi+J@PJQ<nx0fFii&rA*3z-*%{Ore<tO=!yAt<pUPe6B~EK?O}>lM
zxrn@FxP~H1&4veK8R75NY9<EfMGSr}yR&+j>QD}cOv3?}8zQ%$b<}ys65uXOIoHG}
zo^!dXkaI-?Jq|a(PWY-pRk)l&15;kQnz@AJg@(L?94Oe7Tqdb}hbWDAm+)&!srY<1
zB?JQMQ|mFVNXJyMJ6iu3lGn3U6U<gfFpn>7!ttAggq*jv9Ou(<+nl!w#|1li_o836
zCs_>w!<Ct}Sj6x+ccyHd*NjaL&2w^|q{XUIe*d5pFrin*V0;Tg^L!(hs7ZWXf;=F*
zS%D-woV?+Jn+v6{yeSDTtd~h}3)-sLz0kaAO;+R*#^wBYI!Br+8!);Z2B#|vaQA4O
z0&JY8Y;veAm)O`Sqr|?3T1yhcC4PKS1x@c@KdH2FUXV{Rq(c&Ox=0dxhmeZv{qRe2
zDhz{|oIg~u=3#jr2|vNl#x9;1<P=nEahD+H#r=aCkT#WJVnIS%biqt$Ck#ScCkbs?
zTN2vepjFw2wd|ed!+Ib1)Ri3!%X4vTy_9;G5#&$Nr2Yw35ti35veR%$VvRu|EI^VN
z0HA8kU{IBZC5c__VUk!IC~fN|dFrgG1!nkq9VeZf6Xb{!Z19rwh|31Ek+~${cp=mc
z8f;Rx+%{ZzE!!D|HwH$@C-hZq<(wUuih-#r1b<_ppreo$O7h#a7}>oq%9vBrJhu+@
zIfd7{-_DU(_aas!WyS9pzD#92Z$=jzC+1$_C!RjE)a#afSIJVE=DCLM{gyg0CkU5$
zJjHFf*lxjDJ*fVn_UJjkAr=?YArV{MG_QyEz8ARWX?Rd9Nil(rhL@xPuU?rM4)bl6
z7wu6W!Hf3-OAbA)rs17&Omm#EO+2t!USwo?Iq^6Qf!|~%1qr#9$2(K!npfjo__khN
zLEj9+p~T^Iu*}!#b2_6LIT%Io0e{aUK|1_}e^^7CSzaE<$C1sphp1~D!z>yV9cF7-
z3NIfO-7st2G_)O6Pn%Hdoc?Y?PASf3S<@-d@j!-CppU)=1)KuKT@dKvs^)YARE8KU
zL39NVm41+bT&$IfKPA@C5GNeaFhy!;La&sde$A5cBWnOyhnirovN;z=WT^Ta%C#oc
zKN6HmhH~LhPs2H{CX%nSIIgyUs+wx(X%@P=8O^JP8A?#FUc#3z<HH9dz}uRd_;yK9
zWviu*;wk_@&8!JERf76|e0>L4l*jWw+<PD@2na`S;-OeT5D-L9;m&dxM6j1T#MrQ7
z!5F)O1$p07V_ADoY_TSaz4ycxjft^gO!N?q8jU^P|1<j@aGLM$@AJsL@9ez0v$M0a
zv$M0itF2fF*92AvjzvRA9Nvj_PhEGr!Xy0-?W!;IJcoYhlt&E{J6mu6fs}jLss^Mc
ztS0>S&Pkqw+b70T6Zu-n#DoPIVHhyi=QWq&B7m^33>=n$49Z8X^on@jqklG{Z2q=V
zD4(Q-Y*zDZ%7i7Ua+>GhOJE`5are=WYs;e)w2av2uo5)L9DUv+Tz~MCBI(>9jB%VQ
zXA-6N{41BYod2n6Hy+`fyochPIlbC3TwHxVk=6A6n%c^LMnI;=_1E}TSwf=jFlQp(
zSM=8e)+2JMH=rA6IFB_9Al#d2l8N*K5OgG9w<^2eACi6^@O>mfC5bSQutg7|j)3R9
zN612zx0q*tVl62@muDy?RZ4}Q!Hw|0{4ah78GjV;OP-MMf1F*cOs$Vx^IBAMmY1zj
zS6Rf1xk9zrk*!g=%kO>gj$(%r_?K)=O*Oz}UHvhqC2owI<Bu}tPlOpXKvUnE!K(>8
zgTwKtY>xq&Fe~^^89Wa^Z0-O}ush?$=g8pR1U@=IQ@b7q%e>U{;xy+_Kk%|XFV3Ng
zT&gFP>M>9gW6fvIYR;|WjZkWrftotCkWU%e*T)kJ<9?DW7%Z1K8NhwMEM$Pjvwfuw
z$(^yM0n;X^s;Cl2Ffmo?f-$=_B4VL}c)J9iSXj}_V|bRD;hZ^P*?5CMwC6uA)rkh@
zL7Li=dO>d^$Mg~kod&`OD$}3K8c8dX_+5|iGg-o>)g|1I1fd}>(7|2KcGb8tK_F=@
zt@jDCgN%FySZKbHgv@ph()g-&kT($i1e?;1&tXSm#hpT%FJG|SI5A$aeK^}1CpHuI
zV3z$PP7L#((-I#^{Ei#*kD+GTgq8%Zn2&^-S%XGm9Y-mweI0Ca$ZRBLME`@?HVxq|
zPtkDFpcD6U9YQR)-M-1ZvUe=1%T}Bkz(MRoBa~kEix+G`JW8K4j9rKqTMBbA%k@eS
z>-zV>{JE_3RUs9n&kr%P9tmQMqZAQP8>P=r5I<8a7unqev5xx^G#^p%@HkO%6`mFU
z#$vG7Kr4732d{&n#|^>s#-L!|s29v3QH&1_8S>h)-F|xB9Mm!Y$f#a4u0MMIhN|sE
z)xM--H4;QsP^Kj;k~>CZ&I}Bype-}V%;qMFDemVmVI?~Jju9P7xL!&VLB|p+_~B7b
z9$dei4shZ-#fTT|=O$o8`XE-Vso1hw21f0&qR%H&(ZT*|8Ag#V=B$8<aytf?+0v$*
zCpSaEldDa^lk+00p#e|2!{#PhHXWuy=fl;|Ln8*)scQv~<={SPGA$M1@VH@Ja(UAi
zJ#4K;?CJW@ucElyerD$0OpF%B=Dc7nn~5zIp~IQj46^eZrc~#fiD6ZDVz!3<`dtX9
z`4<?@pA!I7>^z8RM_O~yzkU-dq!19S4x|zRE$nO}^3&;-cgZEV4`{IOwA!29Ocq;L
z^QoZYFCR0rPlCs4+Rzs)F$r`G8P298iOJP|$7HFDd6^o{ysEnZ!yd8SK_KZZkQ6&+
zGEFiV)Ql29nrS}~G6u8vFOtRJ2Gy+KOb*t=y;(NgRm7}YNv!mF8HwLE7hAcW^Qxfn
zke8W7Ye8eD!7tcAEohuDobAwp#+`gBEX!786Pd<ofPu#80idz24m7$?WkYnJu^J_S
z#>~A$qaO3?^*S-Q8O@Ig9Ld3CXO+=t30vZ0YqMe36jWHY9vjSHSi<vN^Ycu$&Nn?Q
zdL%m9VH#zvhGkW_ktxC;E43gBCV;v%G+x0S8dz0Ff?)b;*!Iz1H)b(@>HdvY)Iy0o
zBpk=i%pHNwf=<(T57Af?o=Gfad|Yk_CWQf+EZ;9(FQj8qc+oH2nCgb!X-mKc_<f0h
z8ZrS#TUHQY3`7!Uig_op$(XeLYHS#h!g^`O_@#Lu*oBmrJmCp3w;3)|_V;e0>?V>b
zY+c&x^jd$qHI1xx`qO0ieY`sgn;ct-wcO7uX>b`&le^z>tB5<Kq?OoID5(YaSSv9@
z>G0zp78dM~>|H;R$4<9UXT#QT;9t4a9!MG)GsEOPDaijYIxx(xv*;~pt;HPSK3H+I
zwb(@16OQ%v)}psy0wlsQIoL-%MBc@E;Cmwd8?+T{CUg^)l%w$s2p_-)9Tol97(gjr
zbXrADrCy)={62!X*Fue{6n1O#nHDZ~K|svIO1)}L8sC|QGt9n-xJuM`Rqk)H&|Xt_
zz8?`TQ$!V5RECCSd{5`|B}^nWY1ve^YH=Q>OI>(<u5pRh)I*0wznz1UVaE+80x0)G
z@f_){$|^D_h0S*A74Ca0nlis*j`(ha&B;f68H{Q$b@>0N!4|~Y@ESDj@@Wk={qetQ
z@ILClHTbI^uR-If<uw@1y+fKG(4SF*D3pvExDx?3HJIXQQ-hT$VjUlzH{$Mgd|H7^
zPQ5aHYUTWo3S=NUqgCZzp>2PJ87zx*dJkgjF{oUy)n!UKQEj*nO0%*TCrXLjK-8bZ
zJ|?P@2N(aj>$>@B`|&LAn0IdnJzQGK4f?#lA;q#me}W3KG3e8)BL}NNzdJ26(q4Fp
z8Dw-j-1bLpajC6X+jV5~#<bln&8eYF4j!3fniw>xRRvIoN7vnF^_7o~8VCkvLcEgq
zzy_f9rSOzM-Zqxp%+ewHytkEdbCL@kV;rhc1~}Iv#-$RTDj&`5c1q`DuRkr&m!&$6
zxg)u-T5{oN;1oA&Y!?%E3xBuUSH3Vx$=0TcAz^nhI{+KYq|@bWr%#HWc@KLLqdI4L
zyMN75@0kDD0-pu-rQM%per_Mxu%4X5@g4T1dw1B+)H~@<ll=l+^fLFCk0t}u|2RLq
zlM>4K;fY6fEnN(1^{{z4@BtpJ{OAaN1i5tom>+HLlB`;C^`%`<OQ+oKbU;NDhnO^2
zkBJ##pi^}`jZ&6=%j`R328Goo`_QJ6E1f^d??SP)lHR3t2o+&Hn{8zhN})q$UFC-i
zwB3phnQ_W3cq;m(LuR0T{cvmbqtBM^j6VDSt9}xe?7C*Y@vc|f`bmX0mF=o_nYFqn
zsIZrmyUoy;cBP$AKV@!Lw09GSKqQSC0e-A$^GPEey&?0XUuiDz9dgHT`B;=7OP#Wz
z%UnFNOYJg)T?fj*R?3DBy$SfCU1psy4aOr|2046MfEopGDR8mpsCUd6>tT!*C3VYe
zW-shk!;jWI)2m|Jb<wKsne*)f>}pzTx<gUA6aRk(lQ!Z1dGw5;IjNZ$_QJdxnas1h
z_)4`n<Ud^LH>U{8o0aXo#|8f<jW|}6)j6|?y|a5>BWU+gF249>>$_w|IR83Th7{wM
z6?e(3FYF0KWJ}jfuc{S1N28`^{#^BNKv~|{GM_1)2^?G_(+<Pvs<urgxaHzPr(8@h
z(F@^4YY$p~?kUz49F&<%k%fmb{+X;n7M#A+=X+&|{)&v3Y+{y}C_M7R*>_oDKj%C@
z+19wS6c$`WFEOIl8a(L>VNF=icuBNk%mTcEJT|$P*mKfB49|xfqc`!}sBy+2Tn-rI
zUGr(rA1x9dBohSxCSxD+vYt>Q?n!m<I8%NM!Q&A5(G8F7`6KjXOJz#qN~0*c&RjZ!
zGHQ@=y0sIP)3%_$8=igWd5=BI{9J4p^&U+_o-kS%CUrD;40*6E=8j8faBYSzQ$aSD
z<RhPpW4!yQX=^48+5C^b;0dl%uZJU;dW*qAwU<UVyf@tDK0a75>n#o!#NbRO^bwOZ
zZ@%E`9_Ag3Hdw5?`%x+!dU|iv9mBDk`I;5Q1e8yTp4>-F_LBlj-rlgJ!iN!F>IX{&
z8}Al@4s-83cB7A2Q<(U|$n5)y$$`K7^R}K|wl$CZ^R$p)Q9X6Wf^A<>Eo_A0HNCI6
zLE-hPD5{^h&ffJB#*FeTm*%s3{lzHFTmWey0#QrW!n`L#2cntD8)=?3Qm)jo`NXns
z(Jw0K#u8w9wrF&J0yD9KRRyq+4rOEMc+pcMdyp+g3f|jZF`ofqt<W?GjJ{y7+KC%P
z`a(ofU~w2gj9U4i-VQxufatAo4})y;9AWHQREKM3vYCS*oBJLc*~vlTRCP;mv@{r_
z=Q4P{;q-@|EQO1m##2QMLBzV5Y|voQ&;N@#Q2JH%g>a_m3w+`4G4~}1H>p+)7U#GR
zM)B67(9Vvb*xx@ytSxvxGO|HKFz1On^*dWRMC>ihQe`rSp<?|8BVDK#cTx-csGUj$
zWJ$UEq}I8sFKhwJs=&#-(ZmO0xk@Z+sJJ+K9*hXR<%qtZQfZdHps9M4+M=2bi#_>(
zjiB9u8BN**z4$bnZJFpLG<|4fx?y5$g@$62hlyu|n{GH8EJyqxc;w$@sl&y2VO!iY
z?M6klE%;Gia0Q2j!0JloT(&k0verSBC`X8)LgxoYR%e9R$R39f&l0EE-(oNGFuh;k
z1Ydgu%W0OZVaunB)r8m}>@}Y*MkaK^i9}ykkA56|1Dyez_pt=!N<C{7PBeW2`8il#
z2OQa9QRPE8sScNL>kMq$Wq%sk>f~fEHgpCu?Tfef3&m!v>ol>tYG+q&{rmuv>yU)@
z$C+0y2sWQ4#s=C~BK?CSnr4#ZH9?D4NFFD=5t}|+Y-c};b)GJE65c?gf!HKrD>8UC
zT~yax>45sIL8e6JEU@PjGJ}1w%cejKQrxqp&kk>sW{90ttvhqlvS4^wNgGlXM(7MN
z)_tK;Chh(-BJGkVG{Gz}o;gkzaRWiOcdW~Fv7@jU*>i%@@EIqlxnM(3U2yOdf)0CS
zvV<98pzuqvEk&#F#wmKxfm38Rq?{s`%9*UqEKt-)AyYIxk0{Ei&MBHEI8A!TUge45
zj=A=qw5_MN+_vo5J?0UHmX}-eqVs>K>O+!S(VF9L+tSt&ZxyZi6|4)`vYQ8%6S&6_
zdj&+a=3R@Cw`TMdBGBLM<JL@1kfte)zhRZktd0XPKN7?5!QcNw3<o%t5k9QSe+XB?
zz_lSf;HE9%f8MYqykR>|_-EPWgm=YAX)%HDDgVlZU!F*W??>PNj~F^G65CaZe`iU?
zg>1|)U2G?Oi3Z?pABk*u+Xuf#t;&S43i$m=+pl!BwtdlcTQVo(%`yklcsi9+SlqXq
z!pHWRY~Wn9z1KUL!hYk4!gNR*q;Z-ed$-)JJH7pcpD$1p@sqiiqUj+Ra?@`^clm^<
z7NqGan%?k>EootRt7!TWZ8&{}z02uaWHGYC^T5HQuVwn&#}a+-P<LAny3H5oE63!%
zvoI%p@>U@Yz4t>>asbO+AP#f9^b)kUA(iCCvQm;$gdP~(kX)CIUMTv6RQq7G67LE5
z|AhFB=o?!Xib2AWE1c}QLLMGKaeCcLtvInIJ<ExG2_BN2z(?uJac?bjY=40Rj`Lcq
z^<V`|^s7H$blI?uu@Qp_qUS!mkZYEPBt#j3f!1-XLLWGd3APoCH$)WIQtymbE%n?+
zFlIsaKdDA=C99UYY|DH*ym7f`-GWyo%UE8OA#aTA;bPKKf6LU}A4$|*Qs5YiPRV|(
zao6N@g|L+^T_T=U{#p-=_vw_}$MeVqBhHLEaRh4(bTav5=uMng(<ynGa@7#vM0HM{
zBg_Xwj(1M(<$I>VTkiUqlS5gL1=ZFjWh*+N?YebI?x+kNjL&v-NggauCu>genUw$b
zxrL4?p>sr1q)8#L$@B%k;oz-nMz~;eho?wgaxmh9x8}yL2{ktpM`+9eb{VFhjM+Lx
zV#OTHk?Zq(bEAPwzET<4T+8tVW#JDfMKYumx-dC}0S=BUKO33nO0i~ThbeT2JSKQW
zNh`(0it@$D;?-hZckS-yI0gOC1}aGkdl4VT{MW#+8TajT)?$qq+4#3zJe`6D+DeDa
z_(_otC7>*-f%M@yEIF|0cCzIv;OR0PmzqNLY+fS<m6vsC4WbzfG48xyBi0c5;~`|N
zn4DPp7&0jxT7_)6w8g;7Q}P843juIX888hByL2WXWc_h8XN)3C*NP#k0r<XjRz+Wv
zt9fay*i+GR0%YTGb9}<h16+R%C4rvqnm->@!r&Haa*MnH9!o;`BU$7Z<VUi|zr!Ot
zv0l?asPU_jy<D&9<tsV-Fb4Xf5GxO_1=kr%kULgjYR4mRd4tBc_Wr7LM$M>^DTU4C
zMHU0Op<Ggj5#6ceuyScQFa}31trr6njeD?+=<fA}B_&3-WxW{KO45vhTLj}clsbtJ
zLLV)qS7i%_>VdO59-#`d2Qc0IT`J{z$6U3at)Y!mir?rxeVf%lpMj4|uSalj`XFMQ
z<S-vVW_+WsnephaVze4I4Ct{0*Oh3)!XhlYR9LQ{(qV9DUH*9#+3C2*v4uJ*wXl)C
zFw+TR-}N~$$PLz}EXP=uM|ZsZMjtb952W6jt*XO!aUWyVdqX{7lybX$X}^>_i~XoH
zecnm86wAd_3Fb0{Z(nlVvOY%ik`WD3`jq7<mxl6(e-mrRhQ8H%DZjdmIb`-mF~~2W
zhaH^~^#QKXOXWQkxxjv3^-izTB$t45k|r*iREf(w%%S0M`lC^q!>Jx;@Ay-Mq{@va
z=N2YZ7c45@yGFPj(@!?nwLNO)S?r49S&Wmj=<`Vy?@#h9{voh6i^avr!g?50>qgeY
zsMz*Ruu^A1u72Jmu5e36F>vlr1{vnZcVAi-9&G9>_}n$Jm7B##M@jSe#0?9(vRTX!
z5-=py{#I-TU?&0&`c`b&Mu{S5szCv;sZiZ+qi~M*cy(DA?4Nhg%L?NuIu>Utk4v)7
zZ7%>^R_NH`mzejC%x2N6+Iv^cv0^N}V`Kqa#9An9%yAT^-y*j3sEyC)_)h1t0}~Hj
zW2?4c>hc>5rCVFX7^ii&jdszGOXFCt{fI`I3~>BbF*2wfz=&7pN7kpC-?S!~v{v~x
z?rEYkd(}R`A)z*>k&b(1&gx0px6NO+ZOV>pMQMqzj4UWUrGfHBFr+$ao9L~a?uV!3
z_9;Qidk=~&%#@xI+(2^3^p|Bh9lq;@b7Ro(qagBdeukp}T*$YVh7dY9NOI_q&UUm<
z@vL`nsVv7)_$2#Vl4F-#d`Ta<rAqKTTfN;8F!cR1Qff7xf0M|ja4*v2Wga`tvLG%i
zTU&5(bB&h8E&Na{7q<pSjCSm=!^?fEY5C`O%wHMNmEr2>km9dgiEo)}#}xlbU)`5G
zYY3=GvsM6<b)?xVDll%3TmkAVwcC|-zybqxWO9<D^J2-@;gPS*2FfLVGq01kwNB`K
zz_Hfp{XJQhqDWjwjM#^cDV2p0(C969h;>~XkYwNCYbX1zqXNa>Eb{dYydgK+5QD8Q
zA|LDa9b#a#<Pca<x=Z6+IBdB(1Zk+qI8YvEmSQ=7aZgIOA|v~-L(B@69Gd!+6OE{b
zG95aaLsQw5;hR0!oSmXW+`z0@yOPe(m$=sGzR~L1IP3#9Tb2I`3=~}XUk41j-7^H-
zJ-1WTI!F$;z3Vdf??k`o$s%$=TrqMP{bzYD6kcP^#YxU(R2SrsLt<z6PE7TAf!-%;
zX*m+-54^j=1;&niCq|&||9Z)laDy1_7%A6XR=3u=zbKUJPM(5Ykm~O-F8BGvST<(|
zIUh=mtlRhEVqpo=|M^~QBWUy+nRXWjRd+lL-Gzw6-&=2F%Xf)>!k_4HcONzJb1sG@
zL7ge8E8JVfyTsZ)|CCbW8q{O-(=g99Kv85_RC9hevf$mA#Rg#}-gvk8rx1yU8b#t+
z;oMatdt4-bR%!fI60%~Je6p_x%Ne)Up>hb=g7aaI8(G#Kv6ayI4<p;SN7VYCy@DcO
zW9rS7n!(lmC2$~7IEn^izT;jo*?kBQFo!lD>_}aEJ-}V}iXlGp`RhdB+79R7;+(x$
zMVfoo$S&*^r@8g|iL#f~hRYSJrcC$=)5m>cU6rJ9-+jYU>eG+^v))<2(zb|6>dUg$
zN-5J?X=mSAN}K2<T<l2}u|=ghV`QQG#U4UD4A05?ML(|*?TJDIbaMqs=$_m6i<8_Z
zpv!Wpfc=Awsi=L@0kAM`tC4j-ASSg6LzgdjfDtLR;34j9IS4zY8W$2iNd55(S@krO
zgAwr<+^LzGXMEgwV6m~{1L81Y!uk8G{Xw`ymRvBhz(Zo&)HY<v;*%xqh{Aj*O%k|@
zMO>WxMmAbX!37?ShXqpWdBBw&>EvD63r6n3#ltqT-G{_bwd7FUSr$|1#yD{bN#p_b
zQ#3MZnskKIZG!Q3NQ?(&QPm2}YF12&C$M7L0kg|tu_-XS*kBe+mh%j$z+AP_$che&
zT4Dc>Mz-n%+yYDS5O72cP>uSvoWHTy2@E|~1wMkdM?`g)|0bhd>w-Sbl&R7LCE_P5
zFvr78q2@S>ackibF+w<t0!|$f8`oG4p)1*ir4KsrGz2&Qp#k{fFvpJve#lYus$=Vo
zY{*gcp<U<!vyO^ag$v&pS+8TFr*Il(+L&Wvs<7&qk)1v!?iJoQ-pKNfi)z(BFgZ%y
zc<a(AoP>)TFB#bZBq;+(MIJsb`c<NvpWkA<cQ_%YMQjAkXnom*iji7x{VwH<Q9fN9
zHP#o#!hseKsdRH35~RQ{ameG<X}RfJr;v|tG8zc02Pe=2gU%b7?@6&|@PQwVaFV;`
zQ_L#aRz4|tC-DE24{rMF`mhdTC&haWK8Ko2DIA&wD+S&z2&ulH#G)F!)@au<-;&!G
zlZsxXoggC?)$Rl6+o#0P&_q`R`e1X0ow-YYG&co%(!a_20s$k8t^usE$EU;&?vMJB
zFrZiQ&#U3{jML&Iw?9tEq{p@*($TexPm3{)&tm-I3WJX+9yI*q9Z(lj#;*CN@s|XV
zCLWN>gN8=(8N24^iEs*@5l;xI`;5%vEL`^i`=D0}52#;rRNke(gsGBRhzQ@djsMKm
zAlCXKCYZAadk8nK8QJ)=Vx;%16-GPSy#76RLUWqUX~*ufqi4lDq3by#Ykf|P5fahl
z6V5?A{qV5-oT#q+{HScpgs}_5G&RD`;+5CI+$9o(qG!75sAs-`)+u-VGPfVF)$Iq!
zTE`zm<0Q$U2IAJs=MoDrD|OxNkV|XHyU$1&mb|wL*Ss$%F0N41jzgbXRMj4k5$&4a
zUxvp6UN+O9;l&$E@v=1!`#gu9LI9o8Mux&5aEZu8F9ckViycKDg=Y`e=0{N@96SMe
z|502JbC7IBaHJ6NVTCz34K*E&2#4q!i|W`iK85uqZjoXD9QP~1d(-~B7$uB_=9_k2
z92RLN6V8eP=|X5WgdK)|4z(l2@s=e*<zh4oy&#4QUt!2<djb3IyW?Tn1@SZG`?xz6
zHoVus043>8_H5+r0AbxhH1$Pbbv$WgpIw9#$`6p`7qKUx_6{T4b5RV8t+dT(2l1hD
zgxt93Bc<sn1^>9_cfvdN8>4%D<c&rJ($G~aUlL=pB!>m<%G*O<7@&5Y(O=2iWEWg{
zHf@puDB5H;hoVg;{!aDdU*yNhX(N#)x63kXm0c#Y<(I?&2gzml>pJYvCDAvcFBH7K
zKvXZ{JaO4JOl}$Q8w(RO!Quvw9*wr&wFgsP7GnkHBSzNbGS+AsE;cgbWpTe^c=sZ|
zpTxHIf^n^p4ZI>|L$2&n%j@Af<0x7Ra@7=mE}J^6rA|_)@#0X_;V~MG<cdf16>2_U
z%3UT`M8L}=A~jW=P7_275H5YSG9U}j2M5c9NAbxbTk<ZuN@cl9J)C>6K375aw@?8~
zuZm5Tw~ERd^B}Cew^zlmqy+$#G<l12Ct!u5%K27~IpjaDgF^GwV|ZqoTSgi`RJD$D
z$Itg135!+`fSx~N*(fpXZ#L~`u||)E-N{f_tt_-fTMQY(cq?hLF+;~m;4rRehOK;w
zvt%c}p`ta7c*+=SN>w^#c87dUrjn;*Vu-iDCTf%y;$cl`uVGotez%eBzJ_7uGUWLF
zH8Ih3{w|VzdE7K_tI2v@6vG=k&}uth&)eLHRu{|fFKz*Bj6df207Hy0b*!*6xPF}T
zi+Dsas5@)_tGFg*CRIptyE9d<1(sz3`469)qrUCs<iD-SQD_&|=5Op<NpngmXyt}q
z%od=_{h%&2*F|sVJ+Y*O^C1TqK(el5YFYLAOZNSB#O}QQ{UxjY8>DRLP9sbC4J(1^
zc<BF|sIAmHhQ5MX|C@NR113xee=OHv5s-aI+F|k$R%oyj$RConm_s3HNf>!a(k!wD
zn*unOG|6T12ZS5^bVK~Q@_8&iKyTcF9d=VJ4iad}@x59$9BA@}7jko9KzIWMHt`m=
zg5r0{Eio|BQ^qAv6wPX~Qz1ZI`HO=>MK)Q!I?I}tLoeBKnxm=*dv;4y0f#x=7902?
zA4*<@WPQPW^#=NtRELEgEd90^NW~4a{+e!!>*+oIj;ISdw*vwI0~@oa8>8Y=3rDHL
zG4f)9r3s&l3G|{nhzI@UTO%vJBdVR9B5j($tyrw*T<di_T?FJ(7r)G{SwCNvRV-F6
z_oC$#!!+6Xosmh!h=%m&!F~fEV8e8nAGj+QLcuRRaI~m~oF$XHrv%&KuGq4w2QlS7
z4NJ>e)?HEKTmk6Ym2JE$hE;D?pJXt6KUtDip(wtK5ifqbapCV`FxJsReivgR|0zyD
zgpG2F-u{fGI3@2W#2NwU2qeb%zu-MdXq?BNK#^R0@WZD3F4j^1+Z|1T&}VF_XbB)3
zW@Z`FMaHZ{m=}OqTLzDn!E62?T)3I`c|(Mf_h8eZT{><S#n2sePYhB6xh&f;95v2M
z{=N&|KtQ+-=1A5(*pjUPki*h%lQ2qg=Kx@HDU){<nLN73Y3mITP=3N2GC74GcIBQJ
z+L&X)D-K6h94}6_oP#0)cySRI`CH&S{$1RC`SW8gpds=PQSGtw2M9*qiJa0ek@+7;
z-RH?x2lnvjYA7TZXtEQS8B)efM9c4bTS3`1po41)nX(SZ6O<jGJlr^E9Pl@#;AnFD
z<PHNJdCYf%HAXh2U#6#Xg+d{}!XKh{%InvZnM1YeBolY{1rkSSl#ZKe<Qq@;eu6zR
z(ph&I$-fNAjU&OLX#u4%`B}QZ^3q)}Xyvo?(3Jf<%6*Cs51P|7S9Uz;{v<Wdor_rW
zhnzID0-&Q*tCoJ^OYDS^qRQXt^#&9r5@Fm$scJa-6JKJL1EfT_FR?H8CANhxG2O<O
zxL65aVwohDyAsQ?B<s51Hj2*}09WFQztg>xBj%%}#=T4rOmzjD`8^I+hhot@>JyW}
z0?>m!M3wY~V_+BMxLLyHAGcN62xcgx9VUm8sDT`|;fFoDFM3wJ2(Fcx>YQmMcfhos
z|A1-lwpB2#cC!km<=y*)X(OxvVp{RyPnfm<O8wkF>GeYTbL&%P+K5q~Fs%)+R4>zm
z>q=qQ6r4S1#WLP_mVH^yo4NhLo6MK#zRGQ1$-D`g^yXvMyqHTBOF|}3QFYhdl|kH|
zm*_ZhINmLKv<b(Hm_g{g(2x1p2a|eRNwtJ^hox2lk&o`LQqm0~uSPrI{zvG%iu5^_
zu&J>AD*$qcu092eFOtKnTOflABYfc@wW%GksiCRNY!b+=ck8fcuhKmNUvH6HBME(U
z$s#bh-~r8P!!4@&li(3~o$e8kj)G}sM&7aNWg#$hptCpZuk_dHHJU$PL!<gDvrf&2
z%EDG|8&RYp*M)wRxz3ib#Sj}y*xHNqx9=QVx@l-#m6PfjFpJWzfM1rd<qJQ>i28Y*
zX8?Ktt}xh6f6rq=Tv2z*Bk6GWP~q(qBkOy(dxUTf4+{==j}{i<;Vd9k`c0wE&TWkJ
zohxc8(CKn_u836ZH?psHu4qWV*YTc$;Xp>y7hERcm*V#S-5n)rc7IZ0d3x0<h)oF#
z{4||~Ji_oMX`aNwI+enlraQ4NkHp?y?Q77m(-hUHr~ow8rAK0YIGqpWVa!xKhIu<@
zK~jbvAnAZC$jXTOC{`?K#E6g(Oyn@Y;Rc6r`6?&uBMI+e37df4ON)ItlVLo3>K+S>
z?8hp75}bpn-0!xMK-w+LYuZp)G9NRKzr>j}pKJk7RVDa~h@n$?z8Lv=dp-!F_MD72
zxSOAdG0MHjnmv6Yda(&luw>@G+{nIpg0T2sml@feCt?$?zXPd|o8Nv?xukp$a^)){
zGvqgouUWv6Mgj?x&_y7VCxs|;)fCl^8eqE{5U)*Z8egXYNA#uK$`qT7t{2MC;Xw2S
zy5p>-@g5fgsPMg;ZO~cq{^>D+OF5&k8Siv>2`$7{FrK&+rD+$VSOUS(v};MfH_s=>
zM)^}#>mg-jda!&kVUjgaE-ZP8k#6D0C-z`yIBy7!Qvrk<qV%-9UU5T|-lBR0BMDd3
z-~yYMqY`loO+rfEX&P4_O+a&BJ#T0)m@vJm^IQz6blgw2Hzzw~sFYPNL2WK}%7_yp
zx7=r!oib_&e=kC-1upHTSp1HqSI!8lJ!}!Lp82rvf1GK=EwB~MZZfj^*PACe0|z?=
zH*nU=*V%5mfFk&Hwp$qHCv=_dXgtt$w(*}a-myQu&Xz_5)X<rW9R`ILn9tBACQI1c
z0`LS!x;$^%SJ<`?(+5LS54JfZC)rcB`!{)0`SZV_@{=H-C-@Du^~Zt>>KZxi{UEs&
zH!|B?zzSTRXFCWp&$H^GK1m_-<xJanQKqq9%b8m1Z0@+=9lNn7C06(vVqX2VSlj!G
zitrAuvlUJffb`dx0X$l5WXE5NgKJD!&FgIb*^{sj!#!jxE>PtQLNuWPTJ!`oC~jyR
zmqiY?Nb5yC4ZlEDCYCmD=7*&XyOhIRILKdQb>PmLCp&N(>_T#CVG|7H3fKGzKtpcf
zxF;@(7MdDb?}=M98m?VeGCtU$zmqizNIG4_sJwzUWk)V-^JM+@i{9byF({F#`y;%4
zq=#F05b2T7%C@9~hjf3rVlI5;9UG~lzoxGWM?zR%j`GADEnR=~zJl-Ugc6yFMBB?-
zd2{hg^ZK8GyvUd4At(9LJUqyk=FKtMT$(rMbexX@5V{t}EgxFnHbcfQ@M?=>eu3AM
z+17>~bh~+yYPQ_458bF9S65o4#VtI?Pn8J8c^tw9v1>k+5++mcYu9l|t*Q<1S=l|_
z)+>Jg9f9WPa3oW&KnEb!dB;qDXDQo2XOs_y;&sdUAlCg1;|@iZUQH>mjH;(E2!J=T
z0lM^lQixX9H~c3jAR#3GXY}MX3Q(6i@aPUi(ZR&x&hOs_8QGs7#1vsS<|EM-v5wa)
zNp7Ows@Zl@mSYivTP+~H3%9jp6n6Lj10T_1_-rZyM$od@b+<|`^Bg~l=dV&n*{K7E
zJCC(^I1uCA#XhZDP+er(q2mph4rC`|R2^n333EQ(7vAEd!4&(#vm}kP6n7pswL(SR
zAMUgO*Ll}$_nuCxxL5j+BrMd0TE-dfu?h*pAQojW1quDo?=$Qr|7z(2Kr?)zITqCx
z_zlL|OPy;y%El*{)Qd0>`{BreRObzJ51d|Fral5%^-@IQG04|Tdnveb?P<j*q+keU
zKMHA!a`;gsTvSL8h2taOYZjztLVMUK{|eIF==%e)*3tNZ>$DPN!o74&!LX7pxHQMA
zz+HFes}uN?)@3es;IqR@X{5)j8Kt<t<%AvJJjQVeCJ`+iq!8bChschzPWnJ@(Nov}
zs*Nj*Y@&mdWPgYqc91eAv7Zy{tU()yclibbPicQ3OHT;-)pESTaip2ZU-hH$nu6CE
z{IxN?CgODre?3RY_3+x5zwW2k0KC@aug-*wyK^<0`Rl*AB&K>P8J=HIZodD3yK{D4
z1<jJnqQ7W1*HN8wh?e+M3Vy|fI%o(mxrA0MtTDm-!!0;PQ}VBR`QQUfX*O2k&~Psu
zrI31F=m)?njj$poQ7OG1<0>ARhYE7|_z-YBORgk&Dk_z*E|sM4NsnLP+Vj)->X}GW
z@S6sgLb%~F<$q^$K|eKlyxLJQiXWPYdHb>cs2dJV93dxic`@(0j~dbJUSCLF?Q|cy
z7ARfDAotM%q>~u7btEy2M*?qUsK13yQjPlapa{s};-DmnI>0?1)&pGN51R0~ES4CS
zf7=Eptdo=)RueE1%j2*TNi6dm;I=9_i7Dv8{WN)uIE5c}$Vu|5oIR1G@?1Y-(Jd!w
zsJ#$9*vQhVNKJ)fW8kHzB8`a3?E{DGyQ;3!$d%9K>Id}bl5Zf4q{_)<ly8-Gm%e+E
zZ-c6m!6SK6DP53AvdDXUGHj|9RV6Rqr+Yq@#q5V9Ufp2^oUba?vLC=+RF#q^jkstl
zi&HQda#_qSA>^Mhj&oV;#$RjZ;FV<YbN=c{uOy2d`0Lk%OtR?7Ul-CV$)W>)eE?m;
zWpO%x{S~hyi}hqKn^*tNWl@4r0a+YrmSs_2A&bBEhN<W*scL5fv!nrPTk3#yAy9`u
zpWzR+@3%#=M0#R)@OP0yyq=*&2|+$E=79PPIBRaoGF&82uP*nvV3Kfi!K8Qu^Y3h&
zi_~(GdJ@_b0_j#Rklm4!Mb(l2O_OtlKvuH~WHsEa)e9AbKt{`n@)}3SyRty?AQK;}
zK)T8pB#5z;juF_|js)_h38hj?<0>k*ho5;lB1or40j%F@l2I6h1-b*(Br!Z-oGfcM
zKdh(2b|7Tkcaf}x^~O)X3cboEXJ}NFi@qSS^UX3cldE({i0Wr#?cAhV!Y|N;W89=>
z4Gv|3MbmENx)H@8I0O*ZQORofb5Xr9LT)I2a)eyEXbVRa;-f#^q$ZPQoU@ghh0vMU
z<0EOd{6SLl0455qJ%UmK7UsF90X-BB?pjpiK|7a`JdPPS2(Kg~B7faVACkVBz+Wv;
z&aPD_A5c?Bosb)ar%U{)7F+2qRT0(>H{x_eDIjphSuQn0?#WUUQXw@zWrARLskRVO
zXk@O{r8@2}W|59UZ07;>WMpQ(%2KLJwLU*6gG*INlm7%0Z_z{o<n2@obq-_%P8oCl
zZT>n&A-8@gLDBjr4Imviq~;<Yi)tAEJD{v6@YS5kE?1X4KWi<+DC7D!<YSy#yjzbJ
zibO(1+sVW6$H%aYLWiorpi$F9s-cGBNh$a+sxH=U;259w$*RpAi>f+IiHyfh0)%>9
zjBLJ#)L0<f^^%8FCv-CLm+S|G#Q&22pJ3C$qLJ+w*xi#&itFnnOzUi9iJp>17y^BD
zF0OBQHSHML-1_RxdWyx_?kOeJK)*>T_?PxG{GRt;T1KN4hF|U&Ak6M$WOFWe46F%S
zJ~b;|KnHzP&n%oT(zJbFelW;@b7*5Y<DjAO3um0U3wOrhd=Vg&gTpeqBa`w;)}@v`
zd?wWgK}oypv0kgEfDZU$<xr-Z2{=PX_Q1vIi%Eo3IjzVcM1j4uwuIGCkp>2Ik%Bvi
zLQyh2?yw;XPU5K0yb~b^V#2kC<+BdijPgANGm0Nn6ZTy<s!-)JY7iuMPvaZrkD|)F
zvTusG+tPf8N{{>HBp2tq0J6+B8NR-`P_!uMe;lDh$CA{(wFUU)MhE6o`hxPKM0%Z}
zEFHQbOFF3}p#DA%pz2F;dyZ4Fni&8=eQdxRP>;!_|Joa#EPhnUL;(KJqe`xv=K1%z
zz{8|!Z>J2&5l!ya|8-Q!S{dIH`2Xvuk`r?BtrMIB5kwyyRZ_ERnw+o*33OJ8XY~d$
zAVJ35N5&rxD+vvIcdCM|rvXJZon+JrGU~U4iqlH!Ro@I$RQM#Xw@c5@QDGccqOP7R
z!#BzBvs;0W^GbrMx0K;6WcXr&<G_+y^<6kzW~t!_XKCUs&eCNtJyF71`HOrqL~&wC
z!|K~k@{*%|<Xr3B3nk;olJMHOfS1WcEU-cRF&Xs|sK&s!8%_Q3nI(?~bJ_Sm&n)re
z-^;{Zk%{ZYO9`8bHxL&h=e#ouMDR09?BPp;w3VM(@+A=duQN-+IuY(i5;ye(uiG_V
zb(d@3QY}a#XiD*)GfO(j$ctp;jf5<pS&~6cs=O1QoLQ3PFEtP%+8No12d$XU0mEd^
zAgQijzs{tH5Iuee8yxk8JrYWA0xb-9nz;r@4F$h6BkOdjmB^l5Zso<A2T0yRCKOPw
zK*{4{xBuioU{`4iWBz`t^#WGLc>dlo9Y4(<=j-ASlT|@dj8O8Kk@dUWs!&-Kb{fkH
zlIjSN9gJ*l@TZwaJ!~~jnA^t4{witZ>*3HA1IB)Cr|M~2VBhu#hYFEG1*c(%&<c@i
z`3*y<)=3EYCdfleE}1h!v6CW13Nv&a^Bi@|2V0>EKR)m1=bzCAwA>`cwLQQEX9xs`
z+QE(MB%AY&MvxZ>Q7<+MjK+tg8d922t<rrqw}uoU+;+sniVk)Ay&1@{`Jpw|Sulp{
zUNCZ@H6LBYIR7Q6v8aX*=cBA_w&Hf^Q4LcNUXuW$);!elKFpR!rHG+<K9*xqdiC=3
zG?evhMTY>7FHja4b*D>deB1$C>~)=<5$`C4#iU_+zGZqwTd&_}u9#PTicZ-yKBT4;
z3Lk3t2PJA9k=)LSrPY+Oghm4}qSch@+fQP*Yf8Z$4=}5wBH|xX5jDP~BHYvx6|puI
zMYL5*ZN1t6>3<ZlT`kpikRs-N>&b4aC9QC(Km6WdQeEf8n3+(fCFb=O)+I~|Q*QqP
z?$0?Une@+)?|D;3H@^%0KFPOy1YuFNq~U@NrrNq%QU~A1eJR6NX3YblvNk4lR<U4i
z(=w73^)9mx(=zG`{rh4Ocv?n?{Y|#IwiFsz!}{6q`}A3lT-#9<#>1?PW{S)oSkA1B
z+QRZaMz&;DMooq55A5))j3AFLn2J!5>;I&0=Z+%AP=y_(2#<O9EbNwAN*1ocB<D5W
z*jujgn?I~I7LJTGvSD?k1Ta$9n%b%k82OMUQ2%YKGKRM*XZZidTUC%z1Nr$9-sysj
zc7BIoaetIw1p|v`aAuEe3EaS$8G8TV{}UH2J_B6rah`RUkx@@r2upd&jErD~^Le&r
zMn-5rdX~(JRd<OMvoI7_4E1b#eJR033Y)slljQ834#oXbU+OK0J&mkKgcNGulTD0}
zY6k0iQYH_~^NJ~x3BznNq3&j-_qn!=-j!sP+w!WsZfFSS)++D*=pEd(#3z0BBY+Oq
zQf-#3De~>%-IO|3ru77AIoyu6D7ix9DyZjkO89x7a(h9FJB|?z>z#GULV$@yr^9g*
zYi=`nZDTS3@VySvgnA8xZc0IPcskk9+W|H^8Sh(I*CCp4Wx#TTsOJySWD4h?2m6M0
z(+LKo)f<Wv)ZQL@YbokHRHL`Ayl@W96}FEyvh~9>H5GrKU_atFNYw*1L8ir&>5(3Y
zwJ$5-yA#l_(F1#U1>S{mN3*8ro5W3jOd={Oh2~7{=C2&G8DnjO)Nbl#zI}@^=O2u~
z!GdBk^FXqL%JCjI`6z(1*;ra4!~jXok0j2`zZww@4(%w9xvAX(s+}ga2YWCH?&5eO
z+n?IaPxu87=7v&d#TN)@jgjgGSFXcH^Dn=o{5q<mD5xTd^B(7`_A;_B+jgrfM0dl|
zN84^ujX!ji>yY*vjOX&kr7`QH*i=0xpeY3}V5C#|KIS`{Sa7UV>IZp}H|m{5->Yyj
z_J#vd9fwh5bR6PQ;-p53woz<KoHSGT0qzFpM$)!wbud_xvdw|t(fmC-+ekWJ)oVZY
z&y2(ky-*>m<E6en-|Pb*hGsyB%K&E%@R_i=CkslD0zEhK@z7#^^E2`P9(09kFyCe<
zEV}-d#eXH%ap-_ar0wqEd}v<2&2UO%$s-JHEK}bc^{DVza-YXlQi~8}>we)!QMNnX
zcHymjn_-w@9Upi64`SSr_X~%^)TSAnJN^*E+|13`utZ56n9*KVQLC>I$%W*$DQCKM
z|M2}pDNQl+7F(#1>N;e6Lcbc?ozs8!E72niZ70)z2h+Y!=pO}k*w8OV+S1<%Z=k;k
zThLVUskL%7r+?4Ba{5nF<9tN_ja@7!QL5?tS39`^%`Q^~!l9I`W52w+kcbz$o_I?e
zeCs#>_ap9~fPUxHCpQE4QHD(YB=n<CsP`n@TfzPM^=+yDr=BhK%~x{jyY4BczAtHo
zkEkE_9jD&U1Z#)J#M>8$`ZLCI>M<^UqxH96$;9T8CeZ`UceoLHK9^{VYBQ<{YFzVO
z5CVmr1ZP*^L>2cW+I_ZFex%)J^YF-?uh4c<D%-xZu+){>8ZP})@nzm|2>BiJb2ckU
zTBO_;0{!8;N;^t%>@&73S?VF&g06qOO8a!uSKHxJ>IM6ach^Hifkky5GT>UZv;#Ra
zp}JRWLzf7Fe*{b;P~LH9lso1wTLDf)=suS`IHV777oE8|vMlwpL5w6sxFfGw5%KNP
z?`3zS_my+RmV-#CkV+aBvQ}vQ6rV4ZnIpi~wq?#z$et~8_AV)B&I<XFn3IP`nK>`?
zR_0XeqOV}iy{)V;Nn*<1e9O4Av$f2f^9Cz-rhfZBxN{IKYQr7VW|=#VT!72D(|VK4
zohP8(>J&agioF4{{D?b2gb41OvLb>zh2S9BAl}DM5qGvA<zw#TtkL=?JF+(xCa%#o
zPkfgCF@Fk3!;<g_vhb{5Sk50&ekA@3$0KuCtL-HG-r^mbcq+YqwI(ep*mHUlV{5e&
z!Z+M1v6R*%m6C-ZaPwlk((+x|L0PnY0cu5OWKGv;a~%tH?<^(j*s5eH&6!+?2q}Y~
zzpIhCf33YdX)JtwC4)YZwp}TlpF^$EHXT(iZG!DA5JDRvYW@wto#0}V!9;==53PXe
z<RnZ_#<ZgB01xt(nXypvF{>xN`&#DpT5I0mbvD|Ac)jWvv3eE~Dp-wGTbs!NotS1l
zANKh?C;&Nr#ce(wZQ@r#)D=B^a&x;qo}h&L5cIAsS^Cp9$^bk1SaK-+3O_c7mzC5c
zQ?vN7Hc05)1WS8=X`{XNEua~t%jWs?g9eCxX^wxnk<Cn%_AB=egh5g1i8jJssSkja
zJ^X!v4+_xs^^2d!zY71#`W06x<{i&BTG+*>&=rfa@n!fkt%tpk?1z%BPV{0O|JHW(
zOPb3+jD~%}i#vqn0Xy@)XZY~c-`Y&&qJH$@bFIQ&Xzybz8q!{xZ12%-A2F^m8nMFb
z^i<H*^&A)j&4(adI~>Ui4qH@k7O_aB?n`CZH;~-TN?n+6Q)OgVl)5QGS3KNy)J3p-
z2i;LcQ6bCdCV3QfchtFqNDm_$T1huT5ipCup6q2M-6i3^JK|KFbfXmqXA*RSaNG@x
ztCe*<?Efn2+Fi=FS2#Z|I@SXralS3L6NwF)+qNw?0hwE-)YMa7M<#TPua(dSHH~ch
zZS7R$+od41(H(7=u%oJxW!}*a6_W5!{HHdAJ-MSjq}VovrS}F!$BVTOg`So1*<Ed}
zB7U+AZSp&y4=Nd1_&x1t#i5A={U8i=#K`i8cCSJ)K}O5@6KFe?2-dz2w1ROQT2yjh
zTgzUdDPc$ZOWlMu3T!$tYjcIMU%q8iCM@<~ug%&mLVtT>k^T6^)$CcnfzmJ`{)@Lo
zNL;H>^@15gN_y`qs`}anB$SBAEm`deFY^KQ1~e=JmV7ZO93l--Z2gUe43%~(US4Ov
z4wd#R_AX%yhDl#5sxM(pbEGd6ix;z9IZ~d&b1_RCE{#_#T*USamvR-si&%pZ(hY@{
zG3SxeBSpuBMQ=w+Uc`D<Jy#l_SpA4i$d#rmQsy&<(b7;wx1U(<Xemq)TDxf3Xz7H#
z+sy?;-zjt&dB)71I)AOIO!kXKRoT_Zs-4hIQ1)8<7H9UK(2i7g$56s9|B7&$fRkDm
z?-;yNEeq#UF1hGIa<hhvm4X#6VDkrUjCXo}F4dL!kKBnCoPkI`$r|g&94y)dWzQ|h
zHQA!gP>!9Ak``LD4g7lc<6rskAABWuqSdGI;T?-MU%Aor*0P|#uAyIHUyj&<{}3YY
zH0Mukv@G~eSD?HkA;%<pU7X*xJ{&Qd{}3XSvz__bN#r=&UbkL3JrTVtQK1v;h31b8
zEJ@JK3HcE!j4G&}O%<#b^sxlP%d@=*`l6K+_Er~ZXDNr<A&Z`Sv_*ol(VaJzBEJLL
zT?)nHc||*>OU>*Rfe(wG&5+y$W#V#FcxA@oCal+S?XVDWnOw>rQ>l~-?*A#}QX%;H
z-oSdD)HYBx?ab?8?1Z0!2T)0+yHSNBi&z}{?WERCd2A^%|Ldf-tMb|e)V<9qZKO{}
zLdFK!j{F;$mv;2ooKxB<%BqB?I<1ZNn@$Ll%lZy79%p64T^lVWT4sMjie__9Yr808
z#{>P*X>Eef2EvnE&bF7)IYT>sk8GQs(HfNb<AAs9j5gN)Jt0UgfmS?np_?~+hivz}
zXT45qBbo16Z6D=I2K*^!wM%?<WN`eS(&c=~foC@EM7}ZSwBISO5#GadTD5SYiiNrV
zplu<{sA4JV`h&KOeP-Qu{L|0U<WDIe*?esqin{+AOvYuGa(X>$dL>HVP3fm7o%Zd^
zz0-VjzT7Cj<ET-DD!d0TJWtL2!oX^r*G^WB8x2CfK93&qHWyE|E@-DKbLeUN1?@d$
z!6-bji`uKoUi)5K*sx35>B6?E#-i2J7T2&>3L}sj_>=a4@Iz%|(aoQ<-uBA95?XH6
z%*AV!Q->jS#Z~PY<?f+)8u+tzk+24OYwN7VJz1Y?+QGtA2kee2T->v$;V)WG`$;b&
z-&jhqKD_mV0aAflj8{9E?-DQu=hfQ+e<WZKHYC~tiwKA%#9?K?13Y-&?24UwB>(+~
z5fd_y`tel)d><F0;GD~K+CnqLbfq*%Q9O`cSSd|W7zeV9RnS>?1{7UfB~`XpT+L>`
zt;RV!ZL?XgHPRf#{{BVJ*GT^MilDEV+d8SILeq~8Uni|n3_8d>zLqv9p7kj@__Z|1
zUg<f7^u)@cs$koOdNNt2v2}l<G5RHF#NiE+pQ6~ne*9G%?)_^b7m4eQ=?6=T=rVnm
zLYS&v*S1qO#MdnIy0)+KjXyYj`nq<SGU*uFEB!a^ZK2sw1B<?){mt)aJkR4;BWoVA
zmicTEvI)D1q4~?6_;|)mZA@Tw8PlU2llO{c3?kO>J-d8M+l;AhX$LFEW#Wrzx3mje
z?ug@g?~E<W8+MzWxyeF&ahbN<$U9I!8z)zDZ7-^(^weNuDACyBwnYk5{AOUT^>h*5
zV|ZRJHLO`Wp~_npfYy)&EgDruTdkrJ3fayrQjc)|&*RAXGV^Fx&K}IUzvmN)z0^&U
z_j2-Y%mT6R>*-psFSklH0up05#rGP@6g$ZZW$=7ZypK(&uWQSMZBj>t!y49Yn>1C`
zYm7|#-b^BW?PCKU44+<VRFC;@m#Vw{0+|I-lY?kb47C{8tykJ1%J$PS_@}+rz7oFJ
zi&p5kxI?qyadCF8;VxtOk1CJ<1mZFY0K*pWpNJLwCvH9e(QL=h^A<3+i}1j%ztLV1
z-1ZoXw!PIF?3I^CqUl}VYr6<utKP6dT^6q|a{E`?-acro_0svDx)8kw?%T2&%Z<gm
zC11rQ1M{z@3-_B_m$RZf|B;u8!R&j5V79TEu9I?84hq>_P1jf1D+W9acGX=~c1yz3
zD_7l3VZaVU(KR<+EBh9EYVmxg@E<uJnX8p%f~&y@WwLhbEVF8e%+4Vlh`cVp6FVoP
zt>8P~FL^6|G_dRcX!|Q4rJ<A-FSQ$$&FSgcOKnZ%23!Wpd|qk0hNR+&diJ^u%EVM`
zTSxK*F}H(KUBx*AYkE*>DJ<P$VEG57QPoyi_+sdvH@n)I%>_k{holzv!cUtGtnFdx
z8|98ln9{sDEY<cn^vfM&pI^2o^oywt?O5~?N#(U-qXB_~<k~4%#>Eh(xHgFyj!3lw
zq`+5ID5QQ_*=Nm{(RMPIVETIH5iFj3xN2bTUvvqqI`l`98Hf13Xx6(&B#(%rM;me>
zDh40u>KeMz2jMasWYMBGl50veyL4bRj!Fjm!))SFDdDpp47Bu*Pz{iTSPtyPB`x7*
z9%{YT{!}V)X!{Mr$NsTBR1h6&EpOCD48=*%mZ*zRjSl8b*^Ykr0DWsRq=5!#>UxWa
zgad5KF)5?w+B=+^&%Z_2qcC>to7!6$>B)Qf$UCkV+U-%IuAX0h5YN&`KLrnD!7xvP
zU^ueqCc1bw{J5l3W_JSmwkEm;-UkCY`a=2vI?t@eq>b#uacPF~v<7ICo9aT?#uHL|
zRdR1x5EiFUHS>OzJEz-8DL`?|z-~wA>UgW<>}my2uH)5RA>cbFph`iJy7u<t+0m0y
zwo=H0&b$?=tLvxYXfCz<t=KZP+s5OA8Vz(S6oFHj`)Mi4uO3HmY3f&o$H_c74tQ0g
zV2{<Ef*f~8>7x7^aTJ%<zGawPCtVu5(XudFw?(-v85P<Qt&8=G=NK+}pE5*lX<Ysi
zSz4lX{gkh$;|*vCV{jrzahdI1hRJOVAHv+zP`63>wmC5S#pu)u?G;udR;OaCV{}0Z
zmn-aOj4o1f>nHY%ez*KYi7^WE#iGu!I=w=OTy9{i8|l0i`RCcbM!L6x&oTomir0;C
zUcS^|x6cQZCtH4DlgEw^WyS>Es!74si2|1>_cB7b#j<w<+E(!oT1Ha+%adHHm1A(5
zg%L(EqSt_NL&kXIR+fho$yhF79Fj5i${6R$F-XeH9Y$=NWGPuDqc9m|Lpch0;my&M
z$yga9SH_rLjzK{NW>>=KN*J=);bso(B1=@Rh9s&ddTPa#p3e_#{LJjLP@TJCw}EAb
z>gxFY%(HfR=}Hxm?J&sNq~U0l)uFl`$|M{gvaqHuTiGH3%`>>BE-K^*$91_|t>P0|
z;QHr)u6rNYop7CwS!(JsmF?p3Q7^SFCh!c$b}7NR$Ytfoon+WB6tzRG+oDKo#O7R;
zng$->I4*Z_<Z(GF7r*{Pfx0(LH$X8fj!=DA(^@)p;Cqhf5@?IhrEu*K;7_Op{8O=n
z@5MgU($x-#m+`w+waK5$;_bm3+3;)94&^=?H(u7(g)3GZXCdLbSVh8#qR!zulf97e
zm4Q8|qstP0o@-!j>gwVr-Eg9OT;5l*$&O3Z)B#|}hgV!)cFRb=*dlSEG7{2tLMk&M
z2c^kvc|4Zda?A0L+wx<LXy=AiZ)tIY=YcKI@zA#0!>ki}kDm?fKy`Q?z6imX-q-`4
zhsZgw6FqbzguSy3?2V7E27Be9JE#nIL}mAQ>I}jdlYx1wbVj9q0KOTc(%ll`B?If~
zrE4KP6%A~qmu{!BM+(NXPTr7+ZS^tVI_j+(s8CI5CDVMpKGA%9Ki6oxf0tbB6_egG
z*L%`+MgAuC@SZft+k2P6_KaOPisAY_U|@s)kU~^PrptpzF%%OP`LV)pKEDyJ11Uf#
z+F)Qu{*Z<WjSj&y`BU2FI)A;4oDJj699)e(`BVBq`SLclh#tBx)lu|a$4c%?$@V*0
zy$4dF@L=r+mOP+^FPriJVNqY<ZCLL`zU<lqteYgQW!215s!)9sp#58@*a)*!U$J!!
zTV<9y2;J6vV4M2@*R@1ytWd6DZAzqeig`=e(h{kuB6l^r4!F=}v!O`!P^xOL_;C#j
zErl&MdJP*>D%JD4yxN9NgA+JKQL9W-r1LJiR0<!$r0sX&Awn1d_u>9RJF|T!$iy8y
zVa2Lpc~Uh>y5A8=C*&lj@+5xt#1E82o2l?sL3xrNeYKsEOmfo9@+37SEkM$w($V<F
z^JW<lTvJUzLTM)8b;~~>$DX+_!4dEmw;r69iRNXrC3qy@XUgFLgdaz61oFnsEr$ma
zJP>eVM3%mgwYZZW!yZ48Y9_z8hr9GW(s2tEMB3^`=CQ?hDd{dxnqHPfM#CH2xLPus
z!-v9V%6N*I&oBl2ev(QE7hwOXXM3{`PbJ6tIm_gRpedAjTqW5H`duK2?DB67D3alC
znPGS2ne>Zd+GDo(Z|Q~iux}u=6{{z(;xIqmYGCW0OEm@67y~=^T*^?`f58G@NK1vL
z+YD^~3+b5aj74&RIS^-ab-1qok!~uKIyUg76sRn@2uUq`DMc!JuVMRN!k4vkl!4j5
zkpfuCE2+EU%hl}bSAd=wX@$nT26Xl+Hv2W8w?}a3*!1D3lxx*ItQRVBYfy+hSvz2N
z)!%Rh7wI7~Ip6Cc0ITr=JWoaLa2vdm>%gO7h48N8)TAHYNJHI56O<GbK|2GQ@>ZHI
zxC}S2pWaI8ith86`kiF_tmdyI0|(S|fXOp4pG8Tfu_)ieHi@gct(1ggGU6WmV)GSO
zmGe--kH}Eb;VV|}y%guVZmtdI8oXx1-b)Ruz5C~br9_3^Zc(jTZD8BpOEn^XB-niv
zk2n<cGdiQgN{{*OOC*uhTU4FpBxd?Y$_@t)LKLGQ!W6369Z02#r4IOz)<F5!moVCx
z-Cr^3U#UjJ&U0i+=z;)quXl7A=o9l|cM_VsRU|YM@Yi;<#pX9b7s&qoSGuogd>30h
zq<fRDPJeAF{i5F-?AvjjISSmMD9qp`hEG@Iz9&^N?MQBwlG|vKJ*X-g;3O92^|0S@
z0tW6QIXg(EXBCVE1QP*f9*x|QGwoT;vaV8;oz{F@0(K$ma9CG;K{u00a9L|u@X&P0
zy^Sd6@+(R(|NQp{3v2Fd>dT@OrasE2$03-D6s8D8mwa|wVX7xQ%r>xp6sAOlrV)!4
zOv#EW)7dBi2^u7<5ln3qbEdJs2ync=fdwc5@S4W5l>npwu#f=D^4aeMxY*CY+#CQ1
z&1VJ&06GCMivSz)*fj#&=xbm~M*t%8Sh^zsy#Sc#XwoZ2&tPX9O>+b0nMmd_I;0f*
zLZe<fA1>f;PaJ1pxs^;2LSi2S`?`|plrX%vfem#sZC3Q2#{4UrepZV481ClUo9ehe
z$g|<Wh=;6x6;t0y9gfMeNm<I;cyD9$9ji8uxJ|R81H3>U_Gn&8sYj`uq_`<ZY`&G1
zD5b8IQ->Y3N%bJU_oUQma_Uw&b&{MlZS6NFBe`@S^4(<nB_APbQBpf3^|wvJ?bvqa
zs+2?>uz_t-ASFFbuy(-LwuEvm{WFsEh52eWyQ-;o$|hX8TVl^UTDz~nB)MDg(2v=a
zB=@&iB$X^9^5t}5nRz9yOtxxcPnb$goK53>Re+Vo0jo61it0wF7ap)n&ZeLmUQ?(Y
z#;dc<>PH`72R$(x6x6+1K?hh=NwBkAT}<Z{Nk6gME~Z!BwF{w(KRG*nKZ<%(%@ipd
zGZ<K)tI43i0?Ig7({kbFJa`S<O#9s<C&;bsM4fx@JxF}phvWR&{Qy%43w1ZGP<&gP
z9dkD=Q<xsGtm?>WG-PRRbyI-QpqqhhuWs6<DEgK4_b|l>1IHTJau3ru;U)|ze@|00
z&$ZJG@-lWx!A(9mB*JbQ;)z_6yBOFCpa@Sp!}=Om;Kwdq(RE;{D$^{%Ycl)>DpO0Z
z343MHhyu&^aZ`72eVDG#uHuTcue?lyggYG#3%yN)YPf&#)>5K_af|k?y$33q>{b%U
z1bk`ssJF35^fuM87vd)v*d8BK58>`C1M~7VwGh4<Z(v4WQy=dplfgcD=^Njm?J$&G
zoMB+U`kF$8-!lyCUtd#<a#@DKj+OkXo6Ao6nKByB{N9E@ZY#&u*~laNf=CE$Q#tuw
zNTpNqec0XWx<1OY<ayoVhCZhrVbcoReq~SmO*2wzU4zUNa&h|svQTmwbXiA!G6c<z
zls<^3Z$`Q`iI`>f{{=}j`ry32DF${pz%)r=y2g?MO=?B<HP$cCR1aLHPof_apZG_0
zkzW$KJJICl2c7z%GzzL*Mk18$V6XZ3H7=XAtLDh`E+RU-ZjknWWlnpBm048+KC!48
z;x8OjAwi}~!jbjyEP2*c6>|zU`6%8WDGCiX`PsKR^5sVY%NGValFZY3wLdKtN@3~W
z#M_lRwJmsI)%mi*$AYUGq+3+R&kSs8h^e>Ym4-bCF|8H`Pc^W@8m42;MHmifL~8vL
zBswV4G?2ZCXi<X=xTK3@)oYqU6p3CewkC9^T|YLlrm2n)r#G-oHBFlo2^UyrwJ9=m
z@&L?|iG`#|i9aBa95)GQ$<#tk<JJcDjoQ>u`Ri&73pdrK`GV;1hK&p}#R^8K|4m`0
zPQtC026ne_i#PMFW$G!68fIYQYMGk2rJ+{b2BC0}>;4<rsamEe4<$iqs!Pzt{?JJS
z*x_rs4DTI~EQr(Pj&X8uKcz?FtKqfLS?=l#>_csgJ@8d0hnqSJM)c1m;ieR!@(=^N
zA8uMGj6uJgRL7Ja8aSB7hfzIosRG*1R@w`jVz<KXFAVHi9h1M$(_#N3H4mxkx~5vf
zSIO|P)ipH~+TvkqUDGpRKoW<9u!Z$Zo<b<zw$wB2PhYmm+B?88US0F=-d6c9jYow>
z*rxM2{xPJ}UYNMq?I?~6a!H>;@a)X%y*IKw^-bAT3~)v13%^%SRxtY_T_{V9FjcLx
zB};B@&1u#v!ql{y<pkt^HSZehatv&9gsD}X%>--9Vd*5kG_jORFdsQt-d*B=?iY#f
z5_6I*jWmS?J0q=S{>$9J(qR_WBygteL+WQwPOv+Xrf~NP@Kfp$(@(OTfhHdo)xhLf
z_d=%JR}v`Y`dL!tcg*g^)K}gOrM~hH{>rPBvLiam^owHOHufUQ^ul{xHkzWs!sgS$
z1dwQnh5?{WG_Z(<rk;vbO_`~oX^CKfAzCj6T77GGxy&;}WaFdg1OKL&ny`kkrmq!Y
z4(xiYDM)Gj3WEDC)-+jhc^#V&2c=xn)qoo?q1x9pGO+V;rhV0>?T#gn{EFjnvc4&0
z3mQSXe}L-#v5~2JrB-pE&2o*oJ7N0RD&F)%rR-^qu!f~&J_*Pz4VpbA0l8I*HL&ai
z(^kdw4$P;qNh37xgxParQ=YJKApClbP0ieM(0<%m!Yfz>{U;*PR9o<AXkc9uO-+?&
zqoH?`3KrF1dlF3#h2OfvjA>$;?Grp7eTK$&>ZBXMVA4bP95=GmrlvWuGr#FpcBfxN
zIuz&&%oUS&+e5xI^JLLng-_%@S4hiL!T8cmV>;{72fW$mOmdgvu(9aA#x&2~<<cB$
z|1@tDHnQo>O)HdUa%Ufmfdbd1*)aUV_be;P6fNASXJGS_Oe;gLx5fB`LEM5vVxa!9
z6YhI8P2TAAWhaZOF8I+Y*_0(*{2b#`vPoZQd`FObqcZE3Y%&NnWM~vys5SWr7djYl
zeWGb%<xaf}cGwQ)reM)yT6nN_+e}WZgU*y7JZo=YCY`C*q~)E_K%A`=yp1MlBn@ju
z@C{k_*{=C>c&8ZlKd^-|>}(JZY(Ct$=8po~a9z;<_~0j_HG5~cLx#3M>;GQcz>c<r
zJgly5SbwMmd_`MpSs_F40LWRkzZELBILyGVwK6pl((&Nh+H|@8$eA{+#9Nv8#W`qx
z`hJ6@bcEcR^?=8m^(LQoX9(H`P+7U5r9Eu(;7Vp4;nb49ESX_b0<|}95xIo%?>DfK
zdQ(65!X;KQ;<1?#Ee!0T-V|G{+9oIsIyL}DM4$odr<j)2>9Y~AP!6ly37n913`v>!
zOG00cA}p%EIzrK=n5HU9HnQ9{ro^x<_zVQK%zvCa+&VS$g9PC7mNY((S4Wv=ZDd#5
zm?G-U(?K$B@@y`3FxV9iR^#vwuE|ybXl^R!L<eVwvXI!NL9N^1170CswbD#n|Bmm<
zvc>`&5%+jQIRX9@a%GfJNI`O&booX$_cK#XL$TICXQH|;IMO2IX-eMv%C7T{=ARkm
zmty%5-ruj7Eu&(SX|$m%x{?+;xJA}{{~RaHcc(pRzU%l~5i8`DYI?0$H;+|mYx>}o
zpZf7E5VIIxuq`Ofq!#K18Cc6SQ#VDB7h9EP+VKDAy6%9clIIV3u>dMH^s1r=iYQ_Q
z0UMy8*u4Z5zxHlO#I7iM7UTsRYww;|v7BP>^{i((dv8(fdUnn4Gy4)q^nU&kmz~+2
z+1Z)d+1Y*X36YS0i&o-w`@sz{G*INJj4vx$tz`JpH+ojKwOCQ!ARTHF(ORrRDb>{0
zVuWzTGlk7<Ev}TM{>vJ+5hKb6L}Jm8N79=7Nd^))#zp@C_NMV!KG!``*qk<EjI2%_
z>cEw~Xe0Uwsi?JYD=w8S+Q~Mz6>FB?TpzszVA=ZbUi!JGuoCUWWRJ>_=F<Wmw&D?f
zB0*7SEMoOR?ZiZ3i(3lY+fJ+%ILeJig|}Z9Ceh%CFN#F0s=#>>vv>(MP+i-LzNPB|
zwTb=qmF!JGlk%)fd#uM_TvJ$Zc?3VX?Zq~-iuKsD_To`l=elfj2QkEcM;$YXHD1gL
zJBZ(fg^4Mwu%p;Uh;E4MC!NF$;Rqrv)YN5PJBh9>`bY6Vq9u|Gm}Ij+f(LOW63`{N
zn2&H8w7m(@V(E<g56l|~x>9}<eS~*TDQxs_VwkWAh5X+{g^*{e>50Oi>|vfPa%5{8
z7G0@HFpE=)<9qv-mqG-Rn-n5AJ%eG>?(d6QvT6?EiIk5|0ixaCBXba1TIp{Rh|({+
z%|U#ddJrHMTe(SH)>|dENzgD@a98dt-C<NlvpY|nbRtj_4*E`$x)PN}I5DB`GZ*lw
zs5IcjJ%!0q#No30jEznaD|+rh+d@~|sz*a(n+!6Tm5l955i2=;gW!zyJmD8Pmj@TM
z@$e>|$e)Onk(6Qzv7uWi+1T+dWMiAr5J_bG7UyAdSWIW}fo$r8g1|1KgSC6d2IgiK
zpM}h!LGcVMCUq673h&BbTDoGt6jAO6J1|gGuvcBNzw?9(9GEKZFVm+Qg<S^yr&&^j
z;mPjy6_sp#H&G+Ib%h1|PYjp22eS_UgW?^j!q)x|+mG903eNvelv}&+sQn+LTR`ES
zcL(Wqr8#ML7T!Z_Cd{%i(x1^o>?LGJ8|mK&lIZu>{Y<|To6$@3l(oLdHuMtf$fg9c
z$Gx!KYf~MOMQ<_JCZRG`<PDG+JJUyuWTpFvj!vo`q&9fMVHcnMBRBI{NFTAeoK?aq
zpVL#UV*55wqBmhWTi-_<?vz{9f*(NbyphLh_Z6Ep+cXu^?a9@lJ%S|T>@B5PokJi4
z*M#~e5J>7bOv5HB3on3tn#X}Y5jc!U5PeCa17-HpSgU@bpKRYWntR`xB`Zp^&ONIm
zMi0-SPgq5>9$t%Py&8UtXC1dP3X=Pa1FU5kTDEV1Xb_gT-=YcCcs#9Y5hIWWbi!8x
z5V9o>5-Yn-{egG-LA_{|z@9L1>RbIkZnxOfL86zC;h(}*4-(UbkKomRuvlQ5<VS;j
zrN1?a-5V^PmG|se$13-IV;6ROi0B{-^k%O$q6d3BMBG-cO)S6bkseHu<tMgHEglpW
z*Gyp}(!^}p2M<<SBgV-#c(B&=|HJZ9%dHx*fvlVd{n1WV*I3zAi^}@}62>;ISXH*}
zD0`qqeC!JM?l@FDC)C2UKNu>;I)8%Pcr0WbXHL}=Rwo_mHt&Oq^-34($&)^)tk@p4
zScC0M6NA{dbi{FY{8CuhFww_hvJx6H^~o-5PObF+JDtZm4->06sLX4tpf;Cks~c;%
zF1<dL$IcBC0~|^jYw6wp`u(T!a)*nrWE)%y-V7J*t?kSBkYBZTXi_mg*50uhJD9#o
zQBZNDSWY(XMSF=f&vQkc%riV)fG*&+TCbz`=|17_Ak<eRzyt{}#Mpu}YX?B#0HEv4
z`}y|-YCE8|x3QM9b%$zWP}`umhniOUlT;my>Ji3jo~+wSwJxajHrDd-E<!Eab9H__
z<~>Gq6b3teVPRv$TDAuqB?U<y&IXMUn*`XVlV9Y9k{=+YFz}ec!`4U(!y_&XNMRSp
zh;gCIhXO5tqs0O3=@N{P(jCApKo9YFh3asg9>Jr5XcIqH9Oo7YKw&>%752mr#Zka^
zNN2alih)jj{fqJ?R@h?d*Q8Tk!#y0&O5hQ(H};Zs<&nXD8!2TsYRw?)@<l^~!X3Y+
z$4*(!)WKER^l{=j*}c?)&KY7QYqxnGzpjeaz}Wop(54!NDt30f*iF{?6{|4;d4pEv
zQ`m_K;)yb|?Ih_`OoKZ+pCk5R@`>UAnfG><Hc?zIJF%6yPC|Tq)h30tnuO4L#uF7A
zG)dei%Q??Ne@EoMuXIX5-`~Z>)<OyU6lOa`^c7sHU`sd!+xB%2Rjl0<vCcSr{KCG<
z#ELPnX#1cNhmC(ymJ)v+G5(n<{dv^*=Md@7W5z!-_@8Bu)1N_#^ZdUO*NnhT67DnO
zp9iEr3ypuCccs5O9v~L(qWBJ1qBa4>{HKaKA?bmtV9QjojkPdW{)Lsw5_bu05nUb0
zLOArzHibD)7kdly5kHNYF18GewdG;R!1$?!_+(bO|5#40C{oz#>0)_z+y8<t0yH=q
zj$-v473-9Z6lOORX8aT3##UvECj{MX6&oUo!9p7p7K!4fFvo^cWRY5w((u_1{ipCD
za;}sE=O6@SR(jd?JT^v$iQb3rY3RfVTYCe&AoZ1gNl)gNBlbwB*Bxq|%GLTd_~XxO
zA&E{}=S!fb9CR3<r)#;!^H+8d0exr>z@<Z+73HuW&k@JSR&-}AW{Bn8#-VK?eF46#
zu}@lG`gLa$XNZ-Z4w@?WRP?8gtb1_H5BBGppYUCB_oa!4cG&dM>OOreX?{8y;zNpM
zk$adS9+Hh}$qvsHzqxfTWufX=hhRV8=$~1T>({Gz6Zvd0L6(1kwVI8zbC5#{do^3k
zxBvaKM93W~pm$7V8|H}jWItB0oLsS)?DtR1ae?T<p67~_%CV6=1tGuQ(Mmsf1slgi
zyjS|83QoY9-F=_!J?GKJTFiZ}=p;Ntv{G%Z*wk^Y%;e>Xn<mhk%(<AwR+m(4(_FEh
zAfUk0a>6`umC)n6imjU``r=E|()#Z&`S*uw@(OOu69cWC_C=TgJjc5sFONAbz^G#1
zv(5{|7DA7&=wX34uI7tcCPeOZ8?VX3nvQ@SlgH0`wMB5=QH3>mEM=kC#OB-E&pfB~
zn#G3WK>fEdqMd!mw`LN$--+E^D2{H{qXVYB1y>6j4APhq=4$bprmP9ULpc1Yb<ynm
z>r*<Sp5E4ux1m`h^S(%&Bs<xG1ujNRk=KDWTMVCQZEAo!e>5wx9VN}c$7kRZr@ofh
z;XZM;O45weYSN7DR-_r5tdM73EMAkXjAiqeh#%zZ>1NEm22EU8-cqrPyXzN~*|8q2
zzxa618ZhI#OsuBZd`jwmDR|^@#(n*5?6H=?%jLaLv2n`~X7~vy?9(!FkL{4>Kt{l0
z)t2pBF5Z^C&Si^Nh;H)96|uqFxk8*H3mwjqSBiCnMbA`h+Dh@VY{P!mZIu`!WIk1~
zm8--lvIA#W=pRtgQ+gHqVLi7k%l`u|w!sb7cC{E&5}wuS>0)+fX5;Sc+iKBHC<`UA
z%@dnDpTM*fMGzQ4>K7I3ohObI!oP8hKxVT>3~+w?#u9DXXBCTDgWT7I!zwmrjaXlZ
zKq1yK!HpHpZrqCbuSNQ2^dS|?Tnkur6f9s4toAxFC%#!B*viI+(SEzOqJ3<JK{m7{
zoOXVc<kHEX;?GUSKVM6KZZ`gD1#<^<3;tx~){7mThZzBsWCdV20fw&^YX)tJB)=Y5
z$p7<s&;L_w;Qy7~j{nGK|G@w3Z`L@7IoQsvT2N_&Sl3$C@E%LuD7JO@O%FaP+^qri
zNQ8tBZxn|J_x@Ee>rG;1);S;Ppz&C|#C%k{O4S{OKOd`@YLj@@{oT|5P?g``Kqi|-
zKleR=7Qa={s7S2<9ljYSoE>+o*ugE>+uNgXce99_)4Pl{A9kwP=Pe>r&i9neG>oSX
z^|xlgh11oIxkdFnQFN5*>FP#eZF23%!boSE8>pVHZgelg=jJ?TMjm^%Rcs;eeFOJ|
z#xEDcZFgLkG&Me!rT-~zX*Rnd?C=@4&w9@Y#4|TmWNsq}bdH03O(07A%!rmY2L4Zn
zbD%X;deAm;Qov_w;DkE#^3+!PpRz>=)?q~Y>kXO9b}`H;2;wqrK&XChL)KxtSTpP)
z<_PuFg2=Q-Z^#-AZCN+~52sqf>JiNHU}&a<LDcTjGIF6|amKrn=T&qK2p!t!0~<@b
zlg_`9uZTlCq&V=4*Dn+x_Vua40(KzLUFyEdJdwcHkp(c;syh+HY}u+}NjtF-__T@T
z?!=LX9zv+TOWf%gc}XJGi9~q3KH{b&hs0FYyvp2Qwo0Dh!<OzAL+OF5^Si}BdDk*<
z5TAF8(Xu1wS^Yg?J=xUrZ0H^_O4j^5`*ROY@>||wulI-=VP3w9jql#CJe#r?XDYt<
z>)u|`RZv`0u~(}b`z6MHIBq?Zg5d-gNtc48dmdSn=$j4rkQ#kRCJf(wl-W;;g&02I
zUD8s63YHC&lk!;4eWIUJKW9@%Jc6!*`rLhDC5NM^=c#D&c<(0W6`bBDcC_}rwqAuV
zyjRCZ-f=uO%prDaS6mjxmv2bqozJn@1K38LJ<HA?5F_mU&YB5nZ7t?<P)t*PbuiK6
zdG05fMk7crs^@&1qk1xe14Z?GuUkO%WCV*W>z8EavAYMwZskVRfO<NB9fQLEmWs7H
zBnE^eQr$ghA!3A^a1psE8lO@R(s!*1;B*eWbW_C^91@3lT}Ok$2)c%HyfD-lACbG#
z&#1|&9TvSS-!QHleB6&~OUsgP5~*5gP%tQD`0bTbFyyf4Xf50A%`%UOZ^H5p-84KM
z4N}+`Crx@`Kg9+~8vX(D%NAP5--cNM+^;+;`n%R$Es0SNYv*g!Gkw!TH}R+w_QKUq
zs@SKa;u2vDLdE&V#PjyMj!W1S-|3r%vJuC{Q}Q4yC}8{vv8HUo5hk9*8T-N$Vr`q?
zBj5SKKoGlo23f^7C!m=Z4oe7$Cy{R)!v9doE*@uvC&kIO)0Trz!#{~rU$eifHF0Ov
zOSQGZr-sDet*^1{lVSjCdJ3(E9b}VFiOI62C)l-9Vx(-?Am(;j%o6(jrDCg2i&Ye*
zOOX!XdMkL8zSMLxJ&$!eBf7CKr$uMQ)skj#9G+O|7n$Jo&H%n#ZU*P-(nW#?EBcr>
z<r?N^YFa=|Bh2Carrh13dF;*^G0;_E4)P<ae+<QTQalCGgq;=3D87|2Bg=2!4MN-2
zXT|CcrvchURb(yIhvpUJoE7b5Lg$4lw*0&pQ)<_~&xWTxtXadq#nuJ&|Atb?TknOp
zjy;Y;ob`LmrmRi{Hu-|MZrn;tnWc>CreTwPkZ5E_%rS>@33(E9g#^8A4&{t~Qv*6l
zg7!9tauMAIlwWP>R0K-F%y97>CKzQmtNx%51{f!e3q6lOl-*PnHA5>-FPlKLJqa)e
zaiONE^H|wS;)sOWelR>aRKTFP@t4Z94XI0d>qVfaVAr5H0MJvq)?ze69tei`11?=M
zTneQ+cL~>8mZ42y1X*mD5p@#`Mz8ee;bbk`bwN0}e5WMp*XU5cp`v8BkLr`%o;yi)
zdlJ9JM+2KKV<F#Y`w5#f@j{Iec(}1}jPXVyx8Js)K=!-jFzmwo#0#$+4nL)0v#*H$
zHR9(;G?S4M=C^2{=@sY+9nfp=>J~l7{xOkWM%Ac5#r{sib^9+@#B3q^Gy=)1Fzdgz
zNuB74@%G-V?=|tFEIE}mypAK)x-anpvDE8WaW-yXIoA<h#?Dl+eb<qJT%FH8QpNQd
zDi(MH6*2j&%MDa$P%)h<u5DyTsiF)j-rW#u%ia|*@8ONTS=>!zGItlS?l%zxha;M~
zc~kT%ee{ZoRuy-4V0hyS!gU?Gy(J#;bk;!vQ}X>0BsQH=K!*^tz7N+g*vy36VxIiX
zCTM$&YtZ(@O=csx;>w=f7H^H)`dm^j@~8Y^b^RYbi#2wIIh5<y6hOJgZZrqs@hL0)
zKmw7%b}$EVg>6G1QrKK`P=J+{zm>iY!AN6Un8SEt%DZPC>wZ`KJ?Wwo)b3vpF(`)b
zBaJP7=fn;IUFV?A0P#yOMmS$1PB;Ue$>C8_Q`Y~Q_#4yR6P-Pp14ycSj8vER=>T2P
z3ofL(zLi^SAc>JQe{&~|{ivT2N*X(AFKO&h{PJV`-237I+2|ka(0y^0<F*3RMu5J5
z)@nb()Cbtq<g8OM_CQQ1(_|feI_RVRk|Sc5L65{Xtl>kklq{|Ti+d>cukvgy9)}F9
zftUghDj5_lwt$8m1sD$T$0=+y@^g4CyYWyAvGrXm^|sN0IXn_;R2fwcqg~HO>%WTx
z#V>LmK!rY)Kr=X~1azw3Be7S^bNe6sl@88DpBltxpnl+s3u{aRZ|*_^f2E%gOamVP
zD>f*4;TNXb1fL9F`dFM`E%ckD!nG`KwpG@oF`K9tePkh@*$Tb*w)*jN9}R_LIW8R|
zPU(b13E8b-Gqm=nYYwvzt{-_S`YZA>B}M(j*Iiug{G#u9j(vU#F)mr9Vt#VmOt1C~
zcVS*&9Gy$xGQ!1Y;&PYhl}7!B4e0-}r6_bEt5FjB(M5&g8u^c#u+`?z#R%&>mhoKd
zV7-c6c`gnXnq^4LS1H}330w0*tc4e|+<qZ;!GD`yiC(PJOEJ#+54`_hOhl6xFA<C_
zmLRFG#ANG5R8ExnwP1!<VrS`3FE;!&Kno?bhi2vEH)6c?Qa106I9$lWSX|zU<rPov
zN;YUkHVC7z(#zZAu@-N|AjK(jP<a9!Z=J`cycGi#Tg^e-!Dj<>h+54t2XWg>2FUPM
z3{wm;2l0fiodj}Ys&}G?BGMf0P6Ur7^QLZWDZ%Z{;XE)LZ-PG}_+>m-MvE063x`LV
z;KA<!Z*bcT&V9qjR=j@&8~9#yQz*^bhY<bkCiuqp$jCPYe3v)sX}#CBLdNDj66vx=
z^V#!%#Sn)@^UQQ0$m$2H{6W0$;C%~?=;|jms-2Wq;PFxPmkVvvR4nqVxOCi)?>Nlk
zpO}j{dBu!BK7Qxs@Q3v<HE>ba%%PmSe-i-plAtN(P%ic>1pQ8g@l_{tC^4hoNzgl1
zR^tfV*Bs0Rw}8M0rN#&UF=LDC!5D%X!;T5&P_95-32F>Gj$Srv%S9dwD0ku!oM@_X
zx=5`0N(3V>{?NQr&X65}$cxW12XQ5O9dC5v4a`AYD=)|AvHIV|k!3$X$`3#S7fF_5
zhyGo3F8dKxQ+bsys_uOkhq<GQJTmUcnw%E}6SqIIAwO^qR%wPbzr)GKYkWf#4d2w)
ziF{MrW#pTZ@N0PvcHoCt##&}|pPe;`A7t(sbB^f-dW@KF5jVtV;o7Z1VFxA>t#y?Z
z9s?vY2f!PT{NL(3jAK)*@s&vjQN>nU>qeBGxI#tOaSpKYZ*eQFxlA{+%+={=28Q~)
z`;O;_9dvzIvY_iBKXDYEXNRDxW<8ZX7IX)Nz*ZmGTDh*J^%VA5`Y*nOE=ibyRxdv`
z_F`L0=;~NcW`!km?eJx_n3DXzIVE*XWQ}XF8zps_LbJsx)~%E-M>srL#om|FJrK?y
z;=Nv4*T^|%rfC6^1{E|PTW1?xbs@9|+SuqC2zR@y*b*DvETLbvibdG!KFX{nu~0i*
zXW6oeEZa^OVf&UmFnRrF?6jTEOW2mBDtKn6n=2dFct0r<PK~8Y;iKw6&(=Un&<dT0
zlr?dXj;2xxL>X&<4&n7uQY)S(Z3+;7*5*i2J=e=>R8P;^951Tp$6pGnr-aSq*dhS$
z=sP}*$TzE#it2gb@QCVZv%0RRo~!AZ+Ig&zy>3X$X$P<_B_im{DT*eNDWfpqAv972
zbH>4v5ya1$-eVlb2!Z1%2``-E8FZ>#2VGsKN8gR-Qu)9&D7GO$Ywn=Ss13}*HWXqc
z;iqYhhg=T&g{W>i@!?SS!rFL6A!0aF{2_pgR*$~3zsrbj^`zq|HdfNc(!}BNr=;{B
z_16t}qmkl>NJ_sCzvfCGgVSF}U6i#f`W(|a>Hd+e9*!H^x-M={CR?aIzkD|ejNWwC
z`73gMlgK!L1>-|!--j_r7byMYQ7RVZq8lWXM69~ZMVD{iW2A&U7c$Vly34vMbf@Ga
zw?ffFU3FEg$Kq)@T{QliOaBdKS6y|Dt<#ye8&o-+sp-F=?3kM_*?Kf{a|diFQ@Nv3
z%Qi{>mGIzyDLr5%8n(tmmxTX5dZ57o7VoJGmo4*WV?1^Bt<%^JPhE_#a<r=8tEX<h
zwTx*HM(cJ8Ha7=LN%kRZTw%5c>$ka%oqe6bW^5n2%%=P6?v4xJC~2qrF0Ldq@MW&2
zy)Z85&k`$1r`>n?V^;O)1fq02K%I(O1rSI@pfCya?*>zcl?fC>AbMU0t!5N~xJwNL
zXx!5;zyfU9I#V-l4Yt$_%L9Q<6*c3;UR40-hy-d;1mX+QB?1{O^5J?@hkP~KNg$&|
z?kQ^JH;#B*3>Y^_T~Qmp%=}LEWRe9%^?X$vMD=8n4U6hIXC0`X(nm{*>iIw$QaxGZ
zU<17>5{ChjL@QOuV^7QLQk(n@gZc(ea7Hk?$Qp(~X!@t;0lLRQq6tK=g|xnadTB43
zF4ePc3SCe3wt~*Z9o<<5_WXz=>;m(xsPnBgyuYLdLDYZdKaxf5eohv(Y7|-268xH5
z6k=UAq@wP=Y~-GTc7Zy%wOhNPzece7(fICXC0!NaeKX{<D(RZb>qNq*^D~j}m2~5T
zps_gGsI1#*H@Y_%Krm9~?02?t4x-F1LAt#%YbWMYMdu~ov=nv}Sw&Yx=H|kBSJ6ew
zYP+($D!O&$W{%{yDDKDMaBK|TU=yrsCY0@|VrzqSy@c5#Rm?d=7v-2T#JB`-1OG4#
zem_K4S&%nUv8)hXJz+<z@jUEyh;E`#zrTw0tg7>K%2_F?i$A|1tKaE{jAT_^d8b}Q
z^~jo8=_jH7FRHIsRL`flHR^v<)zy}L`d>lqYPzP@vd!IC^)WaHm35OwJM%c(6RPtO
z4)=k}3Dxy%ba9yl#XYV@<vChZ&nd2?dQzT0i|RSW>8^P!v$}3w!VzdfW6UKSA`ILZ
zIPe29Ie}=Jp;rL$i&`8`552h^1u%<i)^w>I%bz29(qzQ5YhgO~YG_@UPWZ^~Iuu5u
zRM;CoO>2B09roAv2LdjOYuhx>miJ_>7mEtF$MhV<kwHalY$C5MKT3+{9*VOyq#6>t
zNa~kI>eun46vgQ7kot{4LxVztU!*EoP7U2NS)2TV(KU76)*dc>pmJtU{9t{@7V(e4
zDz-UXS5?TbhXassT^HHd2o_UIH&-}4M8$5@((ShORZ8;Tcz`X9&|Q|Tma}2Cb-wc6
zv!G}5YU?J-bhVjZ9bKr<yA!@(TL&KBzcy644!mxA*0q7oon5Yjkfc2;TUWPH79g^{
zb#--x{T+}4t*aX@)Eb~-ntHmnj*l_X#;eD;znRfj#jezYIZO{%F`>S$mb_^=F56gV
z&Gl!h`nun1?M}gr3_>UupS8Z?Qp^KgS@n<2{2?0}j@fpZPud~9YnMNSsjqL7#}o~8
zwH2!ykzY1~&;iz<(s?Ykfi6g~aGqH!?nt))RIV<be*LonMz*Jhid}4=YZTzt4ynOt
z%nnF>nTs6)AycP2s6UU=c?Gp2brodti>;AC85p6fVjJ38lH<MtmeUYn(Hlr>V?$jh
zVR0`Nvx(NV5aLnOF<Lj+<FN{JW%hUx28OvBj>zjyG$b;ynu^)Q=)#4DD8$C-?)QI#
zxhNVD*ZM1RI!*3TF{rQ&IJ{>L=ff%hoIh7F8%J|RO}Q`@5{RCwSpG|^@$x(-#_E=o
z-2&Y|$qnOZXBDg8NS7G28CB$RvC;2LBjtxxn@Acr37Z~{!K;{ny|Ixl0}qr}Z;YjW
z3;V6HF2rp(=F)h)WPCgFV{|8-B6(3(fy^RWLLz3vz^H!QmhVj6PxJ{t-U6*r%dZDq
z*p5&N&e8S^S;Tut5?844YwnO^@FmPSP3pw7??^Tg49@n`4_7|CDv}J0Zlun{XmEJB
zWl?Q<hpH!vi=-mG26F<6%q_P`dfWV4PYh4*qkXKsLrME8a%3o`cc6}|QOERS?AX`T
z@k!L7i~S3E$37^omWtHzbQIa$+$OW-b(=$XhO;KV!M{Uykjat0*)z2fLKBSe-d{Ar
zQwY3@$Ci^jvq^)P8twmUT!%@1G%h>DXdommC>qxYsYv9zpvXqeY%)*KfBDYbW;K~D
z*udj%oP~EY&u{x*!>S7D@_x0Fyw1ReATJu$HmOMc&PS0s&2Ew}4~fIDj?Qk<NZ0_)
zx1H0ZZ?&gMX5)L_P#Ry8<21fdh_ZNm^ok!o#2JvtuTxinqENFTzGOv1ye1Wim3=5m
zL+tdG4{?qRyBj{jFRlJ-gwvrX<|C|@TQow2RHSad%rT8HtFbh~#xj^J4X{N*bF%>^
zHjoCm@-PihZ1eK~i#{gl90a;q!s~cL>7h25a(pwXf{F#aZ{Q_V@KLeXsX2ZTu@wlX
zvGftlvUtg^14n%3E#>x{IE`<R7T)xO-(J$QLz}i~yoDi^aerw~gsX6+yo#k}M7z}T
z=WTbDSMg8t%mhB|ETlg5Z68r+|52ZHh}a$qpww4#t>_vhv#WiscnxpwKdd|v5Ce|z
zfrO$DOqze|MQV}}G0+!Ho>xGV*_r*?yJbbI%s)tJx-OUdqd^0qUbKq&?$Cr(wgVC=
ze*ay>h(X`>05KAUDKl3Pd}nldL|<W4L);&rk7C~Oj*D?<NYXIq)Av)0)Rrn1y;Bn=
z|D1yv)9lnl2bS-S15&sUa$tnm{42h>kX1^OJP(9+L?P^0t*#K5mhcpxvO7jODo6vn
zz)p~o1?r~=<QaEqDhbD%;v_mx?aoqnY05djY;4)^Y)70L@6tpFiz8KR=Ppc0DJ;TQ
zcWEjMNeH%V7plt(o4TnAD(}{WSPQZSD%O6FW~tD%J{HbB8s?ZCb;{?Oq0k9aIuQ;9
zLFUrM>gIy1%|rHLu{v0YLT{e?H1WdQx+?Z<+q4?aQ3+H3NjUhj1ZEUpvxzG3hWOX)
z(@YZrfKhv?x*@)T``8PWBll}Yq1=<oUze&A1cy2*7Pm}Y5tXkzQK>$l=_pLcGJooT
zrl&nVpNGmqM<XN5uvFbtI1edIUe253d!WhY<?6OVGAc_Q(gc^R5P{YE3ahh19Vp}^
zJ!D;1sQrb@wNz}v3Uvj+Ekwog2;>LQc>?tS=-nYrqmtP^f$r$7!C}pDp$$TVlB?7e
zS(PK2Fkuvy&y*t?FPrSB2d-ep7GJ;EJuN|26I>qA;L8d=9Z}6}j%xM`)3J`9`a>N9
zC2XZYrS;xvOR9#El04D>d&bH_7n;8OSr@j3NxD#DV5H@gMqwqg)P;92;RGmFGSo%?
z;}Q$YQ+o=BAa3YI`C2b(Ted#~H<6GfugLYz4a`{Dks(ly5wAF|X(9})u42!QYg!52
zVI7fc)Rly{p@_s!XnqrNQ8;));}@<Cg^a_oRKkdfhXZsxQTa3$;}y`Br)|KJIixHg
z%=x4yw4^gN9KqJ_pBC+Pwi@{tdBtNH9g$1JI=kZpExvdD0`jtxno&Ys1R?(G)GqP_
zs;cvsCQ<mis){{7Fs-hTi^9RbG*yKEVG>^arK!~LAl!!3T?%#g^b~#&vPNRuVA42r
z`$;8v8sUjS(XBdI`Gh#jplAs*X?;rLTXR)K)G5I|-nwUM$W7ILQY~(ku<_3!z^TM>
ze!y~;ozfHt--2;v=(MJ-P$?Nv?`a6H48@jbG?BubRw~x$jHXSJ1BUx_HD~I3J<b%r
z7Hpc-mfRPp$U!#70jPvw0tRs4_9_74KJq@8-@P-MR^B&j(2((gsqx3BfFb?#D9MlZ
zSi1`EUO%hxl0OQ5Z(#k;YC48C{|Wa?BxKYV-_F4Ya_d_9xh639yZLHw`T9}tVh-mt
zA%aJciiK`c2Rc8kVyRcx;7`)eX?h96;qvdCgOYfo(BQnLi?F*AP82t*z3nT3OME*Q
zsWJVC3gD+;v%0(tz{2zBxgiSZ*^T*cQQJD>nvjJHlwnJ_sZqL%5CXJzThvu$fxJ^M
zht+|_y=In2uNwfZjY?Wb_RPdh$8HA2O85dg{FPQZ`$?Ng&uFz91w^i^*bcyP*l$$_
zP|uAnXrk@y0HgGmv(%VvE*a@rX)QDZpLWcHqSHc=$+gI!FI+`#AKt~dVx7OBX=a<t
zD>G2Z{695tm6bs(y|SH`(9K1~Znci|^NMzn*sRVGJ%Cv3X>-Ekh6%S|dIz)Cc5xq#
zg^30fxsvEq!al{g%w}BDC<D_fT1xAGQDo%iYfBE+U&AF$eP`#NPz5YHT(DJv(fzWf
zM&hRc3>)t~v8rjb81sH^07&Dmuu;;m!sUG2&?y|0<JWwdB=tEzAScWQZSXy|*sh1!
zJ+?yOR0)663Yd<z#!=jL80q6w-f|FkVN^VJC>6kC2T$K;{*n-6oal2n(_(UXxPR$R
zbq^WV!;-ty^@M-@R4k|TSdS8|>w`LbQ!33%Q3FL1qRld5`W@_^HnE$oU^yHEbmi_?
zuS#A0B%J)EV6NzM6g;LdeU1A4O?<w4K_^#1g+>T!Je?XE8+AY<yb1#yv*dHryvzBb
zuk2C&G}vwNPuR$F)5^<yRc!IOX_d+l47~ikWEH+zb@!?!TE1BgE30r#Q(r!rO4fVT
z9`Xq&6^y;636%xsc~J|4-o3^{1P*oZsb~9%C*Zacvc{Fh=blUOv^L^5FBSXehGwu}
zk3#%Sjlb~RQ^oq<)HD|UKw<MuO$WOqPpPZD)gLmaTbhf)U=J0Wa!?&CUuzHEvk$2&
zv#8seVBv*3PGWCs;>#^}$Gm54r4(;sy~iwPM_q+54#2CoH7#sLU<HDQg=?sKM^jVy
z;D&_G9Zi660fk9-G~I+jC}gBh^J1^P8_1o*&<Q`##l<@}satl>yMZ$cy{oYkynq{d
zSJOba<*H&M?`kRt1t=`Ns|m0#WL(+cMvNim-D$2eCvbj59V+YajlJ2|-QT^|H+-)R
zf*rt-I{;bIv4Z4#no-t*^}kBirCwZ9hn?@~yKbZK)S5w`wD~RG`ZPb$tM>2zDy^R4
z4ORxc$Ue`Wbljl#1Qgc9!}DHvgpig_`$;J%0g8hi^eC?%SEHOCwY|z6`*Q@*jqAq+
z*nfJ5x+lDDFT!YMIFaSfvg*g#^g2Nh%68(FwSe%oNun_el@g7qC~+FIz--}IgQB~H
zc`UOp-3X;&cALEl4?-U+tcf3DcE%`pyg<D6UczLXS0uT!2@f?D<t2g1);`qux<8yn
zay*MA#$3a(Wxe|ljyM7HSniRgPKZ724Kfe=lfCawm&mo{O{35h-|EG$y<Y|xL0ou3
z-K_j#N0rsF#(k{{2jK(g4oUbHc>{b?y>tRTMu&H2O!@b!ft5a~ZX*Oc;yH%ikrn*}
zV*_Hm)y!WEE;lMJLeZNXuEh@JvOy{N(N@;d4n;o4ptNEE-J+cxU9Bav%AG+&%<zXx
zFRN`XvsbaNQE|au`=Q<>HG6=~$Ie%}ztk<{j`WE|!xK###qRSz$7BIewO)EnO0}8K
z=^cW*`BEF&?m5m?GE=eaN^`al;sB5;42nL_mF$&X<Ky%Z^EYTe-I$HHzN5e2_BjsV
zPOHP^>!>v8w7Qb(wX&Fw<Bf;&)=SZeelWofo>te8*Qe64ry75`E0sLYsQt>dD1`n<
z8R;q5sl}a9H>%p$$D~L+ytCoD<LW>iXQsjGu+mE!=ZO~E&ZukHHEZ+SP&mY(xa|!e
ziEeGYQIRzDRpAph?X)_;wRxGJxw_jL9QYS%yj_N5lZ=(v2I3>U_~kFhO)k`g$lv6_
zo(4CJ^Ati}D06#{b@Oq2Az9^{>D1;1Tv@UB;r`C4I|!k6Dpv2jx~A~i7B`B|s{@3~
zC>Ul$y9#?ySa)9SB`ika<au>e$?U)$FQHCl{#O4c7;Nyg%nO9vQ78moP=^X-P-yWI
zp@%b6W&KOdAfbL~6{~hp?I*aS5dBJ%B!9gOv1HCGjp!==cxTw>58-eR${(t)Pzt%q
zt7?DN;}V>3z7k5Ieyv$1G%AT}O_$YCHDx79k)G)PHy(D8wc;wm0leBvi%;@C(Kr15
zOMe$jsMy3en&|;eN^pl4gvo#d*E+>#?KX3Vm4Fuek2)yuq8qJ+$E6)01oi+6OhQ&k
z)2w1o_;*<q8~aw%PM9E9F~^{$UR8R?VSSmlG|h=wTiu~*WPx=Pvvxb6Y&60+J*4LG
z4qLW&f{JOcU?+42g=z0Jslpa#75jcgU8iK2fC!)wt5L4C!dZbb4Ql9E_!T_FlLVwT
z?=_7*N;#9R9sfyiYh*}syw{}L4|gK9NaMc)U^wCbYO2?+&;P82U$i7Uw8^vr&wVLh
zSQunbcosumO+Xbs-dhT7^RB7=<VP1^zIOksNf743eU$p3sV2BX8|r+}w6t-9A2BE#
zQNQ@Q+TC-b74dA){}^v+<?wLlud7cBC!iHeZm4GqJ1b&SdQ)9T`1nJ~Qa@=FeqaE$
z;?Hg6SSGzWfsA<*1ZYq+z?QM=$~ZUAd5>ZLnY(Ect+ZtTuZxntK@%9p(NEZl^g?fM
zK51qP=e{f1+*|4pVHpa?ZmDC1RhYIfpEX{>WE2kMM!R`kmdw+FWMK`1qCF6rf6)Xw
zMvdhj-pGbtOlLW_)qbVQO4TfNWt^+$l!yPtQE(%0^v@TKulJ5IWOmD8%m&3mGU=ko
zhT^7|Y9FW4mcf?;R$(4|?SBu+Aja`sPU|J6tS0Zu`{zz_zG8no`>T?btrzVsj6mT>
zT%@PG;x0twW%ox^6l$SL{eGQ7@J8WOeuPIEtFKaz$)m9_rGC?tFBgoGLE&O&^d(F0
zs++rw{DPrnH4fvtZyTRI3VGVc2)wNCsomfP+T4ah``%MWc+a39%((7Eo2@(6gwgf8
zriHNfvy$zVn&sX?<@I~&81Lqv!9|uP$Y?C1{Ee1UpD=3QS0@X%KPlPN`|1$4O`m>c
z#T)V5?jIVDGFL|s?}ti5xH;_geRUm=4W(d4F5un0h<7}o!{AzC9>AB`pxZ7FkVQ#E
z&3MO#E&)feN|1;Zyek8m7tfOv@#Jic4Yh}|CuHx>;5s=U8hmDJZ27YL9`mo!mDbln
ziOu*u(k<!UD^d#nEo8*rh!5yYsI*=N1p1;ubM#M@7HjJUv>_IvhSO*&1I4t$`#Yxl
zIDOGu?8=tH;<%Q)Lj35T+QZAogDmf({?IULz8+4pcmxnj>LV<9*3IEf*(3Gu0z>5F
z|5%;i)&h|eI5q!-DPK(R{>P?5SGg+p?KC$w4&QYbUSTibC}@KM7Vb0+cqU4P!z_pK
z7(VTuOj}JzH{w^VP=xP6CDTT54H@{<J4IqL1dfEM_7u?cErJIk<+o&qiPRjFEcaCc
zux|=lAK?@n-#0-UHZBY}g>|v?!*LeL+>0t>5GxuhksYI`suq@wr<1_~;x!}0I2%I&
zHYj=^mM!dOP<Tr~OVV)wLb?38ay2yuYKCzNcbT+p)#HDB@*BTJY|JT;rv8kv(qigA
z8O`y4hURW9P>ScywDqYq;<ZV3#&q%Wi=2znoC}xuOxAK`yK+L4GfJL2mj4f69+~;s
zosl#voOkbI(LJ_dxgFx#De5AMupH#e+e-Gigw{{^vrx&hI>h-3g;;_kOKQFRn<CW1
z$V~Y4d9XA5HY8RZALB!4IIN^L&grF^MspP_LQxJg=6aI1tQ_t^_vz76aDT02`5ohG
zmYVej-^|N!VCoHVZo<)5N>=rKoV&0Vg$<>&RcwwS#Kfg@tQ@U6#rf4NDPbdK$dEM1
zplEC~omoSO;uzo;%a8V%VWqWU!uyv-4|xrRLHQA$@`)Qv9&$FSxQ85#0z9Or-AhSi
zn+C5k<l1P<mz#!yL81Mjlwz%nD;UTLC2MJ;Z7J+{p=8l7lfp}ajiPb%L?s_ba}>(j
zVjR7`(>PM0ws&48`G<i5kj;nj0KqMpaQGmi<pXr{VX$)_yVn#B!`xvS3g+>tyMvu(
zGwcH)LjTQ=*{d(pT$^2x%o*wVF5K+^77ZM7I>Vr}zc`)cz$cRZ1`^43K;hQEDJ9O;
zYkRYBY~aQrJBT~RFjeC#{`UvH!Xs^V+Sqc>22i6*P+s0B#tUxht)-hvhRSd^rGsEI
zw#0e)7zLZg+oqsx@fdsM<ZkE}F5H9Oh7O4KWh={QlfCn>2x0xiFPJ};X+tYNalEuY
zmaa`vaq+^pr%I+Os}1%#_f#5;A3(*u8r}EixC9vx3kfmWh^XuLE26_!>>0jVj^Z_Z
z8Xv`#H^wD-7nG2=a6%6T#W$=@#RO?xUk7S>CHq=V8|+zKFX4{s`!hA>r-^oxJyfz6
z&!fFq_FvJ?vSTl#z4S_B)c&mx5qON{$(XNk_=t$CX9GC$O*UB`LJpR)d-@d~<07AM
zZ&0^r!Gk08zr*Wdit1u;|KJ9%i!Z8+#{;`kU2;)fGGY~}u2WH6CxfCBrVD;AwWu!D
zpeTdQG#2sDK5&D5UMCpD*H|6xCk;n-E+Km#nW%og-cp>?;31AWz;F(JQL<j2ur=^|
ztYlL@sV@jyZYWvj&p4C#0jb2!nd;^m$;0;DrO~VLq;)=RIrG1%J$?S9*effO9>Cx%
zr6W?KKM>ARyy2uBQ6)F!^-t@D_B0<vP|+X|{f1#V<Wju(fCDY0ctDbbg%o>S<#-lS
zOqS{_q!=mHSxE5{Ci7=0t|t$crD3b=vfP{-KC+ZoD1ut`SGA|SHMnE3AC)fUpH9R(
z+n|8Etp1vhmvlWlg&k>_R8`{xVj*mPkA8(<OTSaHCtuaUJ~!S<)^FT9-%P^t_mPY0
z;9DgN{id#5s?~jTvdWrmo*U^QRKG9DUojBN1-43N@;~)W$yR>D`OS@cN_P62+RHxb
z16n%ssOSp}gT1iJs>!Y@w3WxThcRQU7V@ljjn`So^Va2G<#|%7vykUDsm?;4YWT39
z<rxU`fkLveuG$La3h#owN1VOawC1>KyNruN-Or4LNRws3*ttu;GPYZ)vtVqsRA<3h
zcf{>KGv-DK3@|p`O&e6_D(v&=1wIS6pa5n|s+2#_ALkudsOn0L;NHZ(-s6%a<F*iO
zjVru?#Rx7-VS<IK9+c`VMzBGuvlu~N828U3@Im$iBM9z8Vbtcm(mUckQprsT7=%Ib
z9WK7u8}dA_yEdX>@4J>--4W4$VU@(JaFf#*>TPlukw2kUg*9{k+ZHhion_BinpU!T
zZ3;L-ac3O#%oa9p9=~}I5MNLYFap8r_B|4>zFmpe(f}02B}+ZD^<6J?q53`0oMP_b
z%g@Ww;)UrjC@&$cVn9!tzpQY|AoPhxhD~}rh6m7H41rf}VwLmMh6;b6FhfZ575+u=
zbiq?QIMn$jHO$PwY;(_3D?YO@gR|Nf0_Ax_bj`;RzN0igL($H;+y!_ZT4l<2#>$by
zGD@Tc+EW#FVzkMwDtm%gAYYF4au`Z3Dtk92EewkDR}o>9NUJM@FZC#yHd1z7$>x+y
z3#)(K4Cw}GO7?Dkp(&qERE%E-rpM=q<T@1zW6m=YQWLn_sJH~-+chk-KD5xnf(gkF
zNX4>}7TV;%^aiqXN@o9emK%HTqkSTb06$%9(t?DRDA@REBOC|)MxA%Ux@bC7j_wxM
zTy{mt7Wkoi9eAVe?{xaL`}5tfvH~&0ABcv3B*a$#fjGop8y&pps-@0l!#kO_EBzpR
zel}tV-2RV}t+7k<3heX~emw9^QLbc?=|F9{rk}^S@}Mmptzgc04%pPOlFw>=zzbX9
z1_3e_zZkX;fJQB<TBJqD3&Xq7z<oP%4V7AAW^gy~j(*;slKNV6pnc&Zb3M(WP$)rm
zS;_3mLoj~Ejs|!5Re~{nIyH2Hw=(;RtrYY1iwjf?+x7E+A8k{z>*ckzgl3nN%&~$t
z%+DE(`BQO)zP}8tE3i{5Xe;<sX-`9N#sY0nl*O;Pnjm!PAJ@378V(0R%|uv)l~wM5
zxQ0QMP(zB{fqxQaH{Bq|y~p#Y%-($-e-P|CE^n~g1LAxg?p~1e84)2eMCX-kVnuDJ
z^K#S@-h~hNtZx#&wuOc4@_@L?)%uvDA3ldMR5mCUV9lfXbHESGL8ABv)Yl_W>+hy%
zOM~bP9QvdgX=?`Y%ECN*RFIv8w*Hk^OBQmBM{Ek4W76bZYeS6=W8ov$_j+Jly^;<7
zMy&6^W+>OX3qF4<S?eDS+(Tu&65a9KC)b%*G*s{&jV{auMmh2WqvD#{)gdR6J*tns
zOAqES8mE+#HYr)dadF<l<6BDBx3cy(hnW}|MluB*8x${2E7|zL=?aH|s5QBbgwK%R
zn1hL4LL&@R5u_bl^88uOVDhv-6~Z<QY<ZBjM(6Ro(t^Q3s3Ha3*NP{`ijVXu8_v_W
zM>b+fd&!AUg$tI%x&w2kr>DyK>$>noN4W7JW8?fC<mj)6*{-LQZ0Xpz7~xNBVOLbq
zHn!P*izL4ZLwi+48zR(%L-PsN26^>vNg{5|p)K%REUO%r?59nTVc6?}VF%+7>k+@_
zl71EFT_a+H5Foxn07Zz=|ACkR1X-Iae3o6pjK1k=BC&7?eix2;$av)2$t!&i(MGwZ
zaZn0@%yWG)<hlNW(o_XK-Cq*DJ1u@?jJr4>hExNh;iQDv>OT;NRMYksMx0c##Q|wv
zf(nH_0coD{l2fp)&A$;@(ajZ&&9lVdSU?pET^Cu2H7K9vFYLq~HZ-ECm#_eZa@|oF
zgTnmsX?~?tCoq#9GB%@KZG{kx+Iv)}j6z0iq(ZPqp>&0`An%6=QtY>9md3(?mt2&v
zpG@g7eD3Lz7xpOAt81Bj-rWbdR1}ES(Ed0YRZNSrJ;#m3ps(JDwW^rrB~P1V<k@us
zAV2Xu_?VLE!?de~vT(kwS4TJt`A3zkPheVQVG;@#YG_-9h94z48T7Makh~5tDEh+#
zl3~Z==cn#UqfM)t+8CiM+~v%g+Em|NO=&V$!mk+=i}71LZ{!(sza&Q395H!&evn@F
z&0&dLELvjz!?j(64;Pf|VCRks9|C1*>LROYKd}*<6C8NmgzT}{Q{CLJWPc7$_h++$
z(^5<Q#`lGHne8rhgnZ5+%!}i?XlLOALWhKqw2`HzVn>%a)d)X&&;+jp_?if9knj#J
zkCK<30{}Bp)HW`rc5APaoo|}u#m=hJ-GsWUk$JD07Hroaidonc55vO|`J|=0*(Fd#
zIVAB>A=cK`5e#q(yyM{qV4mQfmY;`f@DU;0>41pV5Mfn<n-F(E$sFovagz&$x+vJ$
z|AD^zaX@*VA3jxkv5Lm<Q6Csf61Inb!zY~aTjcjm>8*Cza7twkMpqT&d!S)Y(>z)G
zgVCOTN4J87Ne8s?7$85_j0Qsv5GQicn|CAGzb(myZCn#wl09ph<swVP>u&dTcd6Hg
z$5@Hnt2SH-o?;COSNK5kM_B@O7{)PzIYuoIDfGjIVz|C_b+x{352A_PGw@F4s(|;7
z&x`XC)GH9r%!_MSIczxPB+ZY8Zc}0*D||mTzg7v8$2wqp4CKS}kfrF0zRS&z^J(7=
zI25*?L{_f&V$4vyyZMemQ57T$J&?bZfFwFKK6OG9@YzpV0GBl+-m-vD%v%o2QE0p=
z&}&#9`|1-Ap}|H|vsB}KFeWQEDYG^dwLBxGMB#gVWTevJ9`PbKc*`ZW8o!#`_i}9W
zl+?T3()=}!BBIrRUrdyix1|dpkP(Or7dHUiKA4bvd(eHb2R&t!lISW>%jtgEh0T2=
z=(@t&8Waxj_pKa2w}XUjPIngK5E}f027DsmEiLILyJNTrCx1kOY-#knBoJgX!R@{b
zxkPr`P9xd*DC~^_+3oOsSWe(4qbq^z2haevIoa@?64}i9M0OzXEy?E8%kq}Z!t^%;
z*}NS_DOaG5Oj2%-T0YwPDELH!YzH_}gCZIJl1n)kG=ObR_F{oVwn9B3TNe11WM6w@
zv@?}#Uo^<Z7jPlhDnZ;EMf~q}Bhl+9jEMo!4{)Of#cOy@h&UjO<C>GyY?nwLu0td@
z0Naw}kUeqUvWrUQ8w-+pM0L1jQnOTdFuKpmNOTTr`AA2ia4Qx>bK!*XnGyKcC9V+g
zKcE3@bF$9cB(mLW6WJu-Taw*$4tZ6bl8tQyvQz#v&Z|HjndUVDwVbRc3Q>(gwl<tI
zayUnf^O_DCKh5h_7&xhu5J6;Lz(ZS-b?Dy1TP7;m?ZzM*wADD;6@QwI_VN}Z*<C0s
zY67zVz-42%b;vkcR|(sEv~9OYWLJa}*=*ojk{z-p&ds&NT=)Tt8)KST@b$~WS~&{~
z;ljH&)z*_+(eki)Nh{ajk^quB@O><82Oig?zRzO`Fev`QZ!rbNjRd~@M^lWd^k%5S
zx3ro<Cis7I7iPN+u_G7cd=&OJ!-%%S-@`!Q%wK&=gMn<O@nbbF&a{Vbl17wSgQyM!
zelb11(_acfB7Ex-2a<XD*ajNXYL==%9c4I5cG(`al7XP$6A!W-_7mA;EROjGkj(`R
zV4IV@h^Uh0uR<7+Eem{0vJQVjTj9p`#e;18M%w@4Hq>Dd;3NHagOTKQ6viZg<OjGq
zm<Pl=t|T<IcK$CT)ohSR9u6gv8-Q;~GC3BmU<wSRIY{c)8-?2)v^mK+sF92Vg<H)*
zG8bMB#sS~Uh5HZs|4F#c>m`!is}ad0;9HX9#_>ChqXkG#S!WckKpmNc8-ZHMI8ca6
z1lii~i7*cG%p}}&(D+HXTh~ftg{nmM1)P~BS#BJYU>u1c8?@Fa+!Y|eM|ydUk>oBE
z7A1k?Kk#r+Nw{4SZVlIUzl^l)8j0kJU?Q0fd~=f0#i2YU>)#R)@cujr*B-d$ShOkf
z--vmKk2~8Etkp$}=u+@fThaTz3_()2M~Hj4ME*h{yA{}b3@2t#+=UyxQwnomNy0W)
zx9+PYl3Rm_y+yz`Cv3$s+G)LIa5tgJAba%>IDpb1+ZK%OvoeyMgj!Cv9||v$LH2hz
zG2DxSgO0Y*_(dH94Pcv-6%ag;mba};WTSv@LDm#1z3*zg1i1hK8@~iO7F$Vb_@NRt
zybJ%w!fe3eVN6<UnzU7z{qHcu6`-)s%1M&U<&~z1Lt#-HnmD*HOdR}bs~^x6R|(sk
z#kPp0h|-EcK5@XeV37?;fK`k`7}6GGPayW;6Vez_V9|sOMJ<<%5{2(=K{g%U8DR+A
zE}xL?paE=ivhS8lWE)o`vekfZN%s6jEE{7Gg|q|NKFf_0@?ZrQu{2r*YB||2%MgXM
z2U%BmXG9@zhcqEIJ4o2(WM?gt$UZ1fWY55hS&|Lg5A_=j2iqQGOQT;d<V-MIB;;*N
zjb!Jeu(t!qZijn=lZDUaLjC|6z&0lvzEmQc89-zQ0^gGCCUUZHU0phYY~B(j+wTkY
ztH3)ls$YB5^3m2u!KV|*c7Th6lZ8v{>W9(hg2qqkcX6>qwt_#AEem{0vOEeI0VmrD
zWaAfOv>mnKC6}1V_}@iFs@G8%^BbssfOCSMh1+e_N$X!jLN*_(W|2hnurCqa0CY>D
z{#)V{LdOZ%UTleLDiok2(s<YTKqNg3=FMF27tdk6KG@GqxI9P6VqQmk3ONg<eT*;y
zh1*K4x1dDfyHZ=zX^hV*oTiVeYrG8WiuzcU)+NNS0IO@3#+~xJCxPH^M0kRFqE`p)
zOj)4Rbv^uLbIlL$o@ekRf$v`#6808v8q`Agzv4mRkW<z>T(&^TB4oXr%I4#iTvV%C
z4qk+L1)kW{J3lH%2>CJv(sl=$pMXi81wM*&>*zeAxYwevp)<sN489CU<#5FN1x#{D
z3EN!Wjps?M&GICIV}M`G8ZF@bU|WM6XBUv&fzd^G#w5=-quLXdT(z2`P_`?m_JZTX
z!8Y9Qoz9qKQ20rqA25k%xCasS0lFp8rKh4@Z7R)F@@sRx>_F>CPeFyLKHXL8Ugm^5
zHQEAqiA+oKp*RnD_gc8)IPeg1E{lfqZKhx5aEU;7j+;cdMX47WRcflXr=ZJKvJ<J=
z+Cqn1<(xM$K2Et(qseZ?bLu~&M}iFcGpd`mg{L@2Lb&Z}x$@vL+ud&3aq@p>!_nSJ
z#TAJQvz2UFV6=CWt*9bB5zqvLjV>E$7f29^yV4mAthA2t#%RwCX^O$v@7bFwO5$sI
za7Sy?HdSV2x@$u`hAL?6UEvVT$3rV$%>8J0+KJr#JJQwR5@JG?Sw5HLT#T(GEC%>m
zwe@%0U8oZSywcB|Z0ez%DtOI=KO8;KOZYxR$-YcWFYmO{GHHGg5ez?l$%7W!+x1qk
z0d3Q4>?dPLPZ#inz-hQ1_U2r4D3kTl_U{<&L<Fm#vUr={5u%8n`ZY0o96l&$(9<0v
z1iiEocY~R^#~-{a#Anw!V7y7cDhJ}qJRE~S*O;RJnvK-Si8%kN#SnwybhaezKOKqS
zVz@N(5n`GST#c;c;EN`S*%~})jC&3%kcvv)7vUy+)IoTABb35?6!^1*RP8oU$0_60
zgm?5Kl957I8WhXmLtkE6-^L#>V!pitk&A{iGbcy0lA66Kf%Xx*`)Iv{$1n&|3a_rB
z#Ad#|r5;fWhrZfG0iP{qUHfV)3V)+;>PoDq5IGIeRZ(iA+SxcKVbK7jy83EE0|pF$
z&LE#L8?KYGTSG7h#{08it2Vj_=%)=<bSp<(wg6Hwm$;d59*(hv>E6rM=|~ZcU*jgs
zL!ssV2(K!mrc1n@Dr?Sb4p-#NXe(`bOd?De!4p@B(^wD4A$#SIklGDKJA8y_q1oKC
z<o?>FLXRvZdsjwNv*aC6*q6Z^>5h*hD(&x~@B!oPR#p>YHyqGHUmVZDL9zk3Z8m3`
z)bS%b>i8U#4yhCT7O56HAJWuahW0!^*%SqypR9(0=lCoi8?;v)=Bq<SKJFK7Kp5C>
zpteD&u35x~oc-++=j=UaDwidH6A$b(OrP=&b03cD5^$|IF2woS*#ezz#m+}Xi9uRF
z?=UnWmCCRs#`?kQ70a2$4AKq|Uc*7=57N5YJ+UE_zp>H7A>RH7H;?w+X_=9p?kQ;q
z^hKZr7D*qHFT}aax`Xw>U@;#gidcL!`6m|FzmZsU0hy4?asIZzCJvu5C2M~<&d)mo
zEr`SOrHTA5IAJpma~yj6wq0Op>DA#QOs81VBgqO{58=1;J@8tM_{>pZR$4#fIf6mq
zKKAFG>vn7ktQ~uM2)kfZK90T12M)#JS6CBYHiWaKd@LOqS(3<vS2;37Td8JqZeAbt
zyGjweE71Tpjo)IXX%>rI>Q;D4{!CZdLD*s8nJ%}&fzo(e@D3u-RFbK~mAE>x$;hf+
zi3@Zx%H&E(B61KO9(Ul?+Bo6X?|eVwQWD3w&e-j=bJA3_TlhP;_eWX|OM)g%8(g7a
zqC}z;Z~g|}-k>PNZ!wQJiF+OyX%9RcY)J1#_;Wmt<uuyLHq*vSLWpGD7Dl?Yl$j%S
z2CPtkbTUWz3tAfp-CsWsN{A=kHo?H*k8o2FI5eRFC5U;upXlb$6{k#GanfMd6rCxd
z>g48jEXiZ(%g9i<>y-#A*2cA6B^iRNk*@6`=>N^G?W(v=;4Pn~<53**VclKbWws2)
z)9X+~qVNUI=(1b8p0?nKE})(2{)pwAU8}J3H~MQ~xRUj7Zx?81428<ba9zu~_gGig
zUBe{Ko>|i%F2Ol-<MclgK~Iej=z+VxO^!q)dpn?I(NpGTiyOyI9j0yR`o}n!M_94<
z!`=K@<Dg8#aD~(kp5@4$IDa7qHEzST<paEcjWvbe{;abVrc((o;e^T=6bbl6CYH61
ziE?(<aergb*Rdk@0sw-|4%ZG5Qs5%r4c86`cmYp9v(VJA5*XFt+>6Cz6fn<<!h<ay
zfhejEHYS4~#?>tO0QO??d<s-b+mX>&en%pTa>ZhX?Fihr{Ucm+?7)#Nk}tDHON1YM
zC&FjoDa{FE^?4N6P^gXm0!Cpiu}7g>^gwq!M;cwGmVOjBWC#7nayTHtbwEEfr`4mb
zNq$_z4g!tF<_HpaE&IkUZZhm!);x&~myJRU{Up{W!iX{d+e&)+36H=zBxDV9*FW1X
z<)bE`9&ZVOjEb2<;Knnj?XhPW4T<E9G)klbMr4vmdsIqW78HEOKq4J571*-Ck#mXU
zg7Q8(Tq;gST{Nyb6}}SDvcNAUN^xJ9KGx514v@_BhtBIBMf*C{#?+cs6Z-2$SV^#=
z@t~?Anpp%@Ve4UEQ0uI*u&*V?i1XFwm1b5VP5=3^T0Bz&OuqWt8!@~72WHI6I9#+g
z-$Lx^z_$=p=68@L;=(5y*&cYU;*s@|mgA{k^_O0~lAecL*Hv1F9mTFvyL8?z6<*Kp
zRh+lWz1Hw9=5b~oB3Ao-`2jSbj57HZJzE;teEE?GUWMZ`9nG^%ui`4&r7DdIG`J_b
z^D1tzkdC;q_3OAUb_xXUbb4|WUi12Rt*`r^AE=APlgxRRtTw+#gy*@MSi66@ReEpp
zOFSwtL0iA+ZY>C9W%}bhksr~Ng&(CqV5jg1@9YO>I>@ci#ibIz{dZUYqpogG(AEo&
z`hUARMa}>rp7Rtq0=(@{1y_s*KPD<!^Gt11N1uOb1f_VTHGZML$0OWj*cWltn5g+l
zHST6=L*$!}!=vJhsP%+0Kx{ElTUofDhK+CkG&lL(QSb0(@z>EF!a7u~pQsJ;&Pc;d
zWobGkW_3@c2bk(7We+MHpIvQ82YA3C{nDB{cme~1&wz#MkENl58BO9mgg0vV;7Qs5
zILnLefto!@8!b#h<+(}ProIQT>Y-P6e)>2OE#dOqrQ@;<1I=T~#NV}eHa#7Idq5SH
zmvD9nR#V4FZ+XW)pA5`rK$@rB2$D@(#4Q;}u>G!ev+E6PdOju}70X)n@b_;rM3Ul4
zg>-3X`Wq5kI;IKH8AUTo9dK{~kJfTB?Is6fgZM74s!$Ki^3)-AKa$BOqfly!wvz2&
z%!@(M7r*Rvr5>&<`+Z#LkbIE&DOLJ>kfi33uZdzM;2SCOOi%(m?-cU9hzvNzr|6$k
z^g<1sjE4;Wcbp1>esHt+o+y6J2zDL(3&DlP*y8z1BKXgkVuDk(2_0AT<IWU|b{~E3
zYY>|cE;#^)f*q=BOLcI%Dr4RF!$EXNPHTD}G$oIl%sZ}69T#m~S!&0m7-0Z-+uSbN
zg`M;5WGjSs!`%ry!C5y2^|+hoU^EibyJ7xKrTz^1IWLIOad5E3{qafRk9Mvm{kM1q
zAt}iiPU%vN4-k}1BITe*J3FLEJpS{X`aFP@;9RGq5LtgE`_?JR)26=^VdI)u*x%Fo
zmD-IF9fp^Uaf_-V57`f+IH(*LBy{bkWY3iYy@ePQ>{J8&1s@bbRRhb*CFgLXUjuo!
z{6c)U<3>LZ_a-QjT%JGU0*5n}W;l1mz+k9;Y7$gGY{bCk-nM<gT$aWkc7!L19%}0u
z?dVG)Fo50GZ9yLl_CKC+N&XSnRlX=5qa0i>E|6XQ5m&{p1^y(m6`m5=vT%y#;=_B_
zcBWSi?Twkmi?^k#mv#wwwg;E31vne3l`dNHT3oGu0ax%vr}YVZ)Xy^34n&w`dF(R^
z3teQ6)?JvZgL3Ae&DB1ZZB9`9XmM2Zp_h`)%h6VLSP!EkUjel;C<?IiKcAxwsIRIf
zJwM~1Z;g^=(^6g08D1R1-OHhY?+o+@g_`;jUEym&W@y9YM|WZNTJ28P$$G-|?M_dm
z{~ONKs)QD>;e|7`zVf$^RvOs8nQ#xoLhzu$7`)2@3)<b8T7@0!0e=yLS0<vO^(?Kz
zdkK~?x=u>leo1fXsj^hOP6M%3jagbZn|2T)UIt=pP=6y7&*TC7^?!%wtaft_H)4B6
z?mK;;@k%F{z@Cve#(GMbqNTGC1y06J>cHOg%I?^2(X4KKXt`R)%*l^;b8XAHD$Nav
z7%Gj}x&@*rdKFXWwn%}!Z=hg<XKU?h1Cw@GUhw~9+Qw*ddP9i|7xZpW{D9Xs*O?f&
z!SsPaq5q?yjH;`@+4&t_-loCFt4HBNgF)LkVGo2(|1yl4t850%{g6Jese{y}kABT>
z81MMQbJ^zhkuI@MzxBgxVKe1IOh63JamLF1jK+wE&Zzzp@Mzd&9uQ+6)FvBZOI1lh
zGB}dIR7olHKhJ+ONJ)xO7`=z*eQF^`3$o2Q4)I!HM+~y5lh?XAEsl|dnSPIOQsJE0
z>v02XlnOE22el`-ojkzH`yjMSvdU4gN`p2kDZ3XQMX$EGF~-*FQNvnHcpd5C-AO{j
zqq3u72(6Y8EuPTozK(3-{izG@C>a=?%rW$hfH8MOt0vxaC5%467-Ehwg)sW;%ED9c
zU5rC~J$|5Li5B1Q8xq)^i35Cud!3ameV(>zIomrlmiKV-+!ww6J*|4c(9Wb6!-6Om
z>>i&L7be~Ho%%I?>T%o$MAMkbX>K;fiHNX63ABarjs@LzhY}ilpCP}=U6UjPxF#-y
zy)nSpdMKf#eRp6KZ*t%>r=<1qe6Hf@0BNgRoOIb6YfQRSjFN)AYNev2nRs=RxW5KJ
zT*S;z37bi6jBUNKcJqXd0V@FMhK{!#VcwRdPD}F?Y*onNPfPQ1{_`g<bZMxuuL^yo
zzMM*u3r1fbZV(@L;s04`SX4E~>}mrWUd1;-dztKky-Y}ok}0K7!)*mV?)hJS+4usn
z(@~Jpk$e4Gdky~0TuP?S@R$i=_PaLm9>S?wSc+`o*97P~!9wT9XGh)NOy7i7_#N(O
zwXZ460nfHV)$Hx~&Rgi%2`<Vu-nXWBjqhSI@p4IPEo`6O+-ZA9GUqhF42l#i9>o;l
zSdy1${k(>TE3GCT&~`}3P7jmbSxb*3;~lXPN;YkYRt$*j2u2tf(QV?4oIY5@$U*3p
zi4l26iIM6Ju9_HeH!|X`?>$Xo#1AlBo5HG7G`(!;Qly;&Ybx2HrP|8@d)phSIplL{
zNe7CkHG+njs7=BKjD{Vy=N}Wb;$iO?CsA7pm_aeEr}?nioAb53ScBzSXCXHX&V0F6
zAshp7Py6^dwrROGE}(NeBL|x{a1LJVE8^fjb`B;E0^1omNV#m{pm@B)M@t;U0A^4G
zWA!K&JiA*i-p{LP^`FJQ1Gh@?zPcKm7crm=d1w-Q*Y%u@g?o$Gm;og+v2h9JK!T`l
zcj;F)dN-2Tcy*E3xCS3wEOsu3!j+K2<7)6Js~`tg2n16e$5K~84jX8rMGRQ2;|xUY
zDPo`|bkoGZ(AGvdtiSLp1EupM266y1C`NX(kVDuXS`T4CRV7ROL%SrPZ!*Y{zVBJX
z$$j2cMD8VakS209k|lCg`}}PpS3L192PJZefFXa36#(O<=zYj)=vey@T#{U^eH3u3
zrEz3od7RY1okgVn2lX?NTGi4xvYY3ACDjK>C2|x80K<c>aNNZ+oVx~gb+pRQ6I>c=
z8`6j1qW&7#)pP`<T)uby;9Pj`DB{8qDrn-O9imx2!C7ZbTomismH$ax3<eCjYM5j3
z1ShX0>khKy!hctcWZl7->a}FuiAFATt2h^@w-<47uuU-+@<byS4bGUjC>DFi@e&t)
zfWf+9ro~(gQ9#)PEC0*|#Xi`jR>2XGB3=x5-rUGV^h(af=xs$@sG)`?S^U}D$VK6)
zU%5DbOyc4kU<Sobm})T>uh&Bsmjf-iaNkuIkBb--C4!VJcmrgyFu};htL2=Fs(%)7
z5diHpanS>tGCm^<{xWe<JR?sANnDHr4BJ0gYB3kd9+1VPik4jX@1oBd;a&QbFe4t2
zMIz#Mt`|#|aV~CdDdOU9D6WYMmv|!=El!%aD4vmm%@P;Y0mGgU=32}}PCjH2QNfZ6
z_g#8iQ!prc1|pQohb+D|Gjh>tDd%GP<{~b}Lvc-99BF3c;_Gn}7iO~PEOBuMFdTKj
zii^46?&s?!xSxLl@HEC|xSx_0`8>q2A)DcT7Bw|8@Om+4pxUM)2FgQcO$_vGDlrhY
z@Yt^m1dWs!$N&rn8?fzSBV{pLAcsl*mU8glb(h=6w(>|NZ-E>Vo0w)}ku)0{i`e)Z
zN^4@nrHN@aj+)pgo{c9)Ur`+}%*Ou_b{$|*9Pb-Az%D2r#X`{o>|*bV{Zx!tb7wa;
zY!UUaD=3yAnkBYL)Fc|Cv3JGZdpGuq-9?Bc_7?u{H?zC9hv)DAJbB`>JLQ{qzVgmD
zvwJY^Y&fji1RTPGaO!#!aOem?26&sBvY^d2bI3mp6#*g_askG#(F7O<eN_e6(on%6
z^Wc{P9J2@<&fyuhPhi(N9G-8+mj|vC!};eeHa~+$FeYJ(t(4&!#Ob)jW@|jX0nz=<
zrgJda9mfP8$LGC+aChP%dd-AbUpIUl0=|34d@keLRho>M%`_R~D>!ZGMWCQu{SOGi
z>zG_^NNqosbFLIpN8>@3u@?M*UFr@E_%>`}Cf?n{F5YSQ-=xED4!GLz1@*DPM;n{y
zBV!O7KQJXPy8JOK^37q_0Gk(9T`9OvFP1KezyK(1@dP8@y%iYT!-}w233D0GC@c#y
zX0f~F&BpkOxTXcj#Qh}10=N*n5Gjfj6EjP~gt;Ie;DUu9^)w-p$Kt)*2IZ(7ca!?+
z%Ea;?u?B>A-29Q|K$@`_6~V_Oe=Xk0g#?DYzB6}5qiqs+IT!;M_!(wqTdJ*+si9h-
z0V-tV<0%^YILC)_A1OBBSb1-xse{ZF41V=Hv6LWlk<j<`#BiGLqv2F;O>5My@JRMS
z5fe?=W(%pk3VvJ+#fM|+ZsL$8J(Am87l3j+V{p8Y#G71R5$|LmzGkt_7HrsuCF}a~
z<}!xT^|0P5ZuXDyQhM*cmwF!!AEX(A1||6+4&`;M9h~?7{GP6Ve+8aR9N@Gp;|Hkn
zn(gTS*>_knS2ve+!y<#aFI=y#82pcWsQcvrO-l?%?68H@`-qtFRV~VYU)Sj({A3Fa
z`g~bs(EjLD+JR2<p;JESk#&?occ~+KUA>!nJrcqP-PpxN8!^4P$VXiIfAwGYj;{YZ
ziW0l1{WmL$1<X$LUk7Vo-v6@NqW_-BwMG9oc2WPY;qW*o(kuw?M8JZ&B2s;I>^*KM
zed9YtV|&oRtCdj(KE4S2#V%M+Tn~865Li!IEhyt$Zau+=a81@zi1%F{ed`qs`Gobm
zplM?fpPbM1#4EZ%TNF)eUs~yVLE%m;?`{k_rMoid4>c9g(`t&2E9|5}H;1#zu4##x
zqxitrV0rV^fuB3C>wl2~dLoz|H^dVG*sk4;u^+&yoO_P4=vMI@0}3c2^xQ!rjD?r8
zkKOJ$h=OoAt|L4;2jRJjKDn<Ll&1;U1Y*a9_}~w9-$Ux&RZ;gEs=C(@82q@M1XvDd
zp{YBE{UhR`^B!F<>4vSsei0;&_gDly&e)3{z0o7rwK3I2mqof)7hSH~MqM5+s)L<*
z@559V`D&jb`aWfEG0InAN}sj;I<Z0f&}Rg4y1dW%)kL2I<Ex22&!$qJ=|yyXY9=Pb
zb#atiAozZDwg;cq4V!);h=2}OMd;^?G|7I5&;{uPF2WHkk>OYZdQ}w?eB4SB7$Je)
z!X{>FE^Q3fbj}e^(YsXDrL{w};fT*S;(XcxbS)v_z`K5rGy(avez&WLzRUBz&4ulg
ztPP$PmVEFl5%`^Vzy5-5<TA?B$P*D4gq|0Io>TXGtw^XJwUu>KdXLYq^xka?jeJyq
zlisz^cpU*;^qws=hQKB2Lu1e4Uxda91*ix@<9J^!G$JzkD8By(L=rCPS)Weq>Oq9Y
z;%bEuRM3US>mf>L{0Vsz9va_b@lT;K{#qs8h+Jwjjm4)Cg~q!6daFff)Ic?>8Z{p)
zgRg4T8a=MDs6x2LBJgl&QwwtP$@lRau@8svX{y!8qVNg!g;*8KnFD+)3aMIdBB}cL
zDY_*>^iITY=M&mfugYqOp2LAo!>1Dq;6&nKOz63eN_Vx8b|8KFHc07j$VTcf3Fv+4
zI7@PE`Ui`VFXuBd%UA`jPMJ?L?cZE1^AVq*yl3+-mExn!9>tLu!s0iC1dhc+Z#xzR
zR<VD=%;ikAP+T{6?a&UVH7nsni0mNuKAnZ^Um3u{tC;h9g3zUR#%Cp8uJs%EuOLfu
z!wocyvLJC;#*Ril7=7raB{?6=4y<XMBk2$VYM?xcJ)77sk;m&^o!IH4K=Lf5gQ|dR
zR1iQG4pb!gemzO>Lm|6q2v2weix}rU-aVx^M#U3u=Afd-kNL6ddJH{2M?RmcN~iLo
z%YpR;1(T(9)a44GmwoOgW@>tyTkGEmWiEDBCxWWCcR1aI2;mSR;W$Jns){fbDI`*#
z-U9^-lXtEq5iUW&9bI8b)og0D{MzuNkLvoiC^qAx_T4F8C)Vl&`fiQH7a#t1WRSQk
z{7sM{`RN+!J16gZGGexlYH87S0M>5K(NEA1U5&Pl5Xty_PtS`;e-hotBkdJ&0Im?}
z9NzmG!HDEQ-g^!BA2r%)K10*C`B=C)?|r@AZdGj?j)=m0-;qbrwsp~+<{i{^{-2;k
z@;9q#=rORRY@MrY=QNTFqGu<w{``Or`9;8uRDB6T3h(?$Zmg3|(K@NMx=uo`3fr+(
zR3w<ViX>RzrT3dE+eyq6p5rstghB{?B!K5=4ELt@91l#Y=U9|CyXRPoV8i8loy+by
zLjEMrQN9F9>l{ZfG{YUo4!A5w$MJ2rIbV)o5IWU!#JCA|C%0Wm1E~WNhaUsZpUrb5
zW(wAP8d;LB!g=nP0;k5Bmm!>Rng7YziS0N8EFU7f$60f0@Hv$=R}tJ!p1guY_${9v
zOTMYYS1TDvkbJf8|MYsKu2%MQc++4T=>GS!(BjWX>v1FM7cSJePn2MJ^1|iR_f`N2
zA7Xcz>Vmu2|LXktE}b5!>+P2aC4B6)a&%&Y&tdG9&^c$#3qi3IJsLbw&@K7=U(|m_
z9{t!=J(`%QEty&%J@Zu%x}MO<aYxbTU{#KOp5Sxm0YaCS3J6D#{DLh9^b)*F{<w@}
zFhT}B1X%5>PHYTFg6KW_5;<kBu4~nawL<{n5X|=gpZgnKOGs#P{NE$@MQ&ukZ9%%^
z^1N?z?k_BPV&+whMDV$WYWGfzdG|@31pY|VkTEA93~>pLx+7eX1iO&T<PwA_67<WX
zNYHsHjXn<6<v4m-9sPBrbH0lG=N-E4RW7|AA&GbY)_`6wp!-Z@F?shLO9%jZ*A`q(
zPX3d+Uz#&}_Zpkct#zLrd~dxUQ`zi&!~@=UY4kn*BKi(e`%Xf#kHGKvy<leYo+Z@x
z)f``duX?b$AQWQg**w@}I6l1xGZj-k*d6!m9_%USsA*Zos%~}<)^nlYKGRWL=faj0
zRb1EycpOI;cBS}={GMQTst1c|C}^HM>kk^mI1oDgfS#vn$RcqzG4nZn<$_lJOE4*3
zTle8R7Z2l*z3b&Z(d>FG>yCM*hc(s8x-B-BufO?Yme<yENUwQKp3jvJLZ6}t$E(fL
zSA(B5C*8)oUSjo&FGaZEMS#mVR5mXaP<*&-tLomBu0oob!`v&=Ro5%Fu+Ut%N=NP-
zhas>fT?XzY9eW#)Kf;3$#XUb{dVlU~F6#mAl`)y;7ef0A9wu*HL_<9X%y`k%#;E=j
z-`2-@Lnykd*=(%Qdn+M`JIQzm>gYAOJqnnUTb4}!mzPXLZM>@r+Gby;Q!?!Cik4wv
zi})cYpw&SecIt3PwDN4RvI$mmxyYC6oWL~!iXq^N(brSq3K9!v{LI#WRu*s#aFv7;
zW#(&u>)B3RwV7cKH_*kZYd~uOuIy;tf*(-Ox(8L_5FAH7_*f^TV=99=sc<1ng{Nt9
z%x?tOB(-dRsxRRB-VMu+nP%UbFkg;VT|9G!7U?Wr#R28gqlG{r@bbp*vvBS5(8fJ&
zs3TrGH!67bTJ8j|@`!o@uNwM#DqiuRINX}+eX_FtH-MMCAK?6a19+{YE3RHs=<4GQ
z0M;2-cED!Bd=<cExhQ~*j#L1<55l7Yc1(~T*?%DcR!J=zK=lP+flzPKuUcF8DTw`3
z-#KCrv#daD9e9#c#1^S;bqivy82PtD91$D1UPWxF6U1&)tl$QjQ(sR*tdfG*)Av@k
z{T6B17N8^FA`OFq3k{=-mbXd6aAgOqE)us2U=9DX3JoiTtS;BE*<dv)V50=Xk&pdC
zfZhA7ls#To1MJLaE7!32O$uJW;+ZoIn~TbLV+>p<8(wPaA3q!ogPf`j+dNnY7haPJ
zru=#|#xECMX2(lJ&$O(v#!D1iIAB2zH5Cu`{TmWKEz9`ut(6@}vzZDV;r@l^@cF{F
zZ$Y3%3tL0+4_4-V*A{FX$%`~bw=;*M%v;%)%KUcER@iV3xc9qbGZ{maG9|GWz}wkZ
z0A+r<YxDEOM!^^q+kM9tVmxD@3BxHowb)>#SYbmr%20QO#_=*Fk?5@`6&ZXN5?y^~
zW!>-E!g8&9XLU*M2KU9X!pwdxa4rOA`I2xmBh*YkemTxmQvSmmlU)jB@Zu)8kG7F8
z9rrPaEaTl;n7<0#A8$ngoQ%PMpWU^UC{mnSvTr@qR%^_v)rpn6XRBQG6(~n~2XeJZ
z2XVYUC!IkW**y7MygY}7FAG8<hs`5>@#byULfdoi*-E&Nduw%JpTo?>nsvri1{M#B
zyf!anh~UR|&81q)OgfRRc*I*?j{uZzz=uS$jI`wn%L8b^_ie_!scRI?n}BR_gZnoB
zCd1#8s?|j?y{fsWp)y5v{=E=Ig~l}LuhTVz%7B&DxliND*I#T`G%Zrjz<i5ZZ(?+{
zASI8K<={iPo-KT7WqBUJFq=|TobDP|&7cL!`-oob*9S1n?YOcVW(MMhVwlf?5qJGp
zkd3_>99Px@j7PQ0Fu{K05wi)g6t(C`sxBNEz~+vuZy_~MwxpQkBv3X&Z5${q{uQ(q
z<yBmNWo_J5`{~9Fw9@|qvAAq=4p$dM76I3zzPf5ETx&QVNW+U6FRZNgBf#ZLPHVs;
z__15?DZ=w_qN~%7fL9W(?0D@&s#d{k-)jZ0zmUewc^bq5F-67e4d-!ba?_s(uO4dA
zW>j6^74=%d>%m4vor>V0GrW9IJIi<rRK=-wMdCFU?#T?=z(f1!1`fQoFBRIg(1~`H
zMNkrOUGA-`rNT9ydkDZ)=b4oalmXYH^?+u+47k?N6%Uk&boE&VTvlA!;YzNo!Ikn-
zfoo)Cyu$7V^+JSJ;W~nAGDu&E;EGU-`cZWOS5YW8=V6<{jySW(pn&8=z3%@@aIFDV
zae#~c6l(ShTcqZ)4<VY0VSDz{4I5yMS)xSANzUN<2T?`TOZ`q)Plc<VD<23x{hDcI
zE1v)^whGW#2bin6ccUu~R~5RdlL5GL<H`<K6u7pcU2R?{aMeI&m50ecu#Qymnucq_
z>&gtm>&0`W?9~VjuUpRrUj6#4RPb7jhtBZ&6ScF9-_yQ_cHEw_1giJa^lP>@^w&Lf
zLkDEd7hBodu^{@)iGuC=s3NvZUrj}<t5~mLLGZ-NZe#+n5vzd?SFpNt#S!zNtHJ*O
zv2+K-ihyn_hy_1WP{@H4>heEek63!DfOW(*0k&*90k-d{QuHrmJQW37{Zvt~#^``6
z*jP%3I#ICUs10wA{E;3omuw2wUK{r1ZjNZ>{#{Y9f<HTfYdm6!P_SwGdMaFjVsVB~
z#mH7x_!-~|{|nG?1$zpbBH%hiSF4`^uKBpKE7(oM3I(panF<ESkpJWgRtf7>6)!(r
z6JGs(AiO53Wn-wmFv!7Ba5Bi6uR$g`UUeuCIl-$6YU40CZ3Q?en6ffbd8>yu@V~k^
z0=9FZ0@$XXoB&oH;Y0vt(brP}i~m65OvA^KAA#w=0AQmKWQn&{GtdRpD?Ar2Xtenv
zS)1Fo5Yr+(W;4OK70hNmQ7{{g<8K_Z`-o90X2)<%t@uwR%qpp61E{{hED$OV%zXQy
z0}k0glq_@t*~4^#Y#qpr9x|+sRHLM<7<c*?z%s??=XP>LEor`$-HtX_sXxyS+C+8r
z{pOWgEmB`i1&yisYR?B&w)mwj#C_!wU^Su**4znnwWy7`L~bjtXuv=9WT)Ghixsbg
zzcZ$C4lxq6I~}K|0K_<10j*a_Y`3??lJYbHRmOC2K4v4XsSUTu1X@wGtbyu#^7=V(
z5AUQN)y|JVNO|@j3WC=u-$)3KR#)Ty@zwa>j|strpe=R;@wOm8^)oS(zIDgpD|S!=
zVyVRuztKNi+4pM}m9Ia`j-STKG7)41>>c&hRQzVDN$*d0t!&k6DBZFJK<)Z#M9sl;
z#hqFsx~lsIRvLgSyOp*?4pY&%=tl~8)p5LUR8KfHglkpdrt<Y<ntXX8VfXx@Qj{pT
zqHs4K3M1`no3G%t3J;xW+!EAA)&&&Cju)~Q8elmUz-DU$pWD$9ujca*1Ue%K%(3Hj
zTh+H+2r>e%ruu3sUR~A1_Ng=kfw#8sN-Md`v7dK(^3MmHciL>~ftj-(d2+u+W5&L&
z;hvREYh(_tWa0H1n}V^V!KcCB%8XaEnIe^1STt<DiCT2P9VeVHKTU_2BdWg1pqB9C
z@9F`os!ls>tyGP~2{u&CcxMZ*I$x>ktyaC3=}gv_H$<=a6z20gLfY^qN>zVV+R41C
zgS3lpSlKtR<`Vgo`u;fig!&U=%|+YTn~c7rTj4~?xzJ8}RlXvl{6Alj?c(6cPcuHi
z`2dEc#i1vqxs8oM8GL8}AZDQ1lGlZ#807slG%G#{tyKR-tsaf6XZI=QDqTNef!M%t
zfi^~4pv}QkvhN4uNk`A*rGDPsC5t|iF^n(B90prg={gt(_NeQM>_se2(fQGBnrC0S
zSw>mNMapNN0BN*7lDFOyt?Ng+0Z;izV<^3O{S$ekx?F;OT!N!VCv!*;fuIjUw@78)
z!((#y96`Yr&V^lUV)h9LMWrm`Glwk&p4w*nKH7XE@`Dx#6_04Evkc5E5((o>{^pr;
zO!WEZsH8XYn8~nw&rkR~{=2JIR{fK$o*@+%qi_*9;;PjJg2@mHrMX~qO@ggLoXW6J
zi%J1ia<#y8ifC^>!OOIvs|ufOL1hA=V?wTD(R#U*<s<r~3Cc2-ziwrtKijI7JA>#{
zaUU|9kx@y5Ou^~Rfg5+~ud#=mfl2s$o2nqC`T$4uZhW>?HZ;ZBxWIq5BB3P_#A!lC
zjiKqDr4}5Gn(3>#W1eu^im!g#isbcHgJ3hXGU`8@sbK_)<NO`cDs~^FIv_3JmC%OM
zr?qZ4V4>H3w6gLqZB^<|w>uy$;59`=6)1S?s{vKMh-Tbv0ELd2hBjFUcpt!J*^!rc
zb(t=nzqFZh;ey6?w+$=y$`%-cKb2^A6yZ{dcBjZe5H_1|qAo8*yJFxcYP56X3+FVs
z?I?n0kXp7K)fdsuf_q;?yZfp_mZrGuB-#~6tt?|ECFwPaWsi1R{-KzUhC*B`NAQl%
zfJ-Ta3`C+GJT2PQK`<5Ih3TuQ;LYSz2jE3rwzAHyab?`!`~u7hcfz7)H(l{)H=C~h
zag7TL?T;&aw8JSpHQFuWW)ASC;bb1?S1%Br)o^zi*MxuA2m&usEgMet1-~i_6(&v^
ze+bN)TkuD)bZ6o2<uw9qHyE28FfH6AW{T9{BLrVD?3k81w1h<~slhRm?0BiEL1V3|
zh^C@ueTSNgww?K#k0i_3<f0WXPkBxLNQRD~4gQ{;PqP^dg~8S6w}Fm4{h(wDCjnxf
zDZB!QPXSBI6po-WJX08fGCWf_Q7NNk3WKSPnkl?~$;!IA$AuWnE5)=-;c3J^DpuGq
z4P|(y@FpCukVs?-$59cUDXf7aJX7d($w{U#9V66b3f)jm$rM%x^V2egPY|!5PV{5U
zm`#x>^hE*8^A#miIEh-aX9^dnHU7o9y4_)MRjOdc{Pjd(HNKuslcx?N<%z{I9Um|P
zPCQX~^MaZv+=(k)qVOVu9nDKoUdt1;G>NyXanKtJ8zoWr5QGfh_C~WjQRoLp#I^7?
z&foDw;RQg1^VuloMC~SKu2*U4!F#Iy^l7HkJUF@0Q<bH*PVY23&BR0swe!_i)9e(U
z6{Eqgbe#n&%>g@ImI9l+o+A#dl&%CTrK`F*VW$DOvfF7(O2mpiwP;KQcXHKnvX8S;
z#6Hzbr}D)$Sm_W#`Z)mQMXz9+P-UeTR8}gftP~HOnduVL1}nvufm6J+RN-uG;2oMc
z;?;aISo}P&((!gX)$rPdfFtno)K^pS>I#3#@j7)HtTY$!8bR3bRAF5WFCV%ZoEvzh
zV>ouaieT-b;1$g69eyoGK_xYTaHHbYQG_0O*<iwJ-+2YEzpzoL;I;a^f>&b|ud#UO
z46os+4UY5aD|l)8)k_<AlSYns1xy0l>;t?eIKgWM!i>P{O+#HZ6|Y;|M?k+8o<t@(
zFYszQ1K4o=%12jRzwRgF>esx$Ydfy&cx51Es^Inftg19P9>-JBh%hQ%VItbdBL)&)
zDQeM?R9%FDaZqmx1APmj18#sVDIM!%o!tnvk&6EC6}%GERZnGY;8h#w1`c~nkB2=r
zz^-jY9bnqBrwf9V0PInuuAU0m8oqo1V1te$7o9&Yyi$wHG;;g0XZjUqONl>^P^rh*
zdk4^b+4ByLg`$DB?5WNxI&kauR7)&-+Mpg^_RLf2Y0I8Vmz{O^?69aB36gQb%36BG
zg;%YmRMnO}qn%crtyIObCk0hW+VF?me>65}%N`T2>L6`{!+hCOJbzK80jzrh&;Zsw
zMcTeRB;=vB)N!51j+9qi(iT4TK(_SDfgkY*$Rp}v4WKN13Zo3pjh*5PpCYBED(zyN
ziPWyc%BQAU|2dA)t!r$q+^sDL!q=BRRq&L8$K-ybsI(oJW&HW%SC>Aw4r<eL{TTXI
zmOiO;o922e-Lx-#hFlb($&a`0iq`dGZG)$LtU0k<QI<ZpUXuhlxCCEY`uvihSj;(W
zi;~6grBAcNC#b4~2K0VdmydeR2@JMVH(gOR{!$&C#=}zjk5%$1L!5Y)n@}cUC{y*-
zR6{8Ty2d?m<{>NFSrDG3;~036Cj}9?iqRGKEH6jns+A8s%W+)UJxgsQe-+OXiCN|0
zC_EQ_XYq}#tjB$zs+<NHfoqzuBfV+D?f`FI^eDon;#p1|Q#^|a9dOUGfMTi>&oUde
z@m9=BN5t&;6gAQ(Y6Cx9%Mq`dqj}b|eEs20@LG+)DDWDgucqSlnY$4<mR$#+*@b{t
z-*Lc(=by^a701g!SL2Pq>)Kd7UU`uGRq*mYs(|nor`@(O<e$JyRlJ&VmYOEd`;PEh
z&z%y297EVt@LG68;8mjvI^cK>q?qaiuU@E)?^%PT=`~C_4U(Ydh^uPDW;Gnq${4}X
zDi@h(a{^a4#6<y@Szk|uYaRDTfb08xR#wvwaODJDU@?ABud^ClOX=#QAK)5`E4zBp
zDnfzl0QnDE{jI>UA-;g|p@fB^U+)lgNx#fJ2(RzdvdyW!h+N-5y(x0VTvqWaMoDES
zco|VU%a{hPrN>KWkuGZNGH7F;Qq2*w?KXu=_H_bTS%gLbSv7q%6|(W_5~j``><b0}
zvPWQ~Y<>VBTSHe|!xHK0a{wT-;>r$LGN`=*S;_$gvXMAC#P<aeYgNRK;F=Kg?M8@2
zs73v#x<ITb6r9KU%@Y+3%K%GvhS>f6gxDIeEj?nIMQV6mIHL|cu8JdGNy8M2?Ck`v
zPp8ysVftz+UcbKLBf-z$?6R^2MS#~<xLSeNc)H?vwWF(YMS)i-T-ovJj1_}|SC4%P
zUd?cFC}uM(5*$OtYaU+|r^$~x6J9QA(Z^YcQv$Edy$W8F;}yJi;-NFVHti+6#)EA+
z#mgJXDV{=Kq7A%HB}crhv5J26bb{9@gcPA)zWQn^UW1Wm<{tm%b}Kts40z2O3T!?U
zgMM|TD~?xXy6PGTymH~nj#nA17!<rB_9%Gy;ba^?|A&N^idSEe{F1j?39oazm7=NG
z=~VFAwOhffcdUX}G9Eg^D-pGE{!ji2UfOxd;o87EL^$GA>U%4z_Zr6<20FoOAp(lP
z%Tr%X#p@r0b&l6+9J>4%1ibowPk7OJ$#QfhJU(5`3<h4;2J7+qh|Nj`FPB{k2#-Hn
z$%U2mKrB)5swU!!JoQ_`Ytc@n=rpP>^lQdWfme+x=zx3t&UokyuXd=7?<a#KIp|lm
z^OB+3u*1tcqIF}S;_(kUb6?*eo(Q<EmebW!;rgBPfV3=Qw=GuIyg1-`Hw@75^OAe%
zYGP|_3*v&jPqF-L!!=uQ=s^5!*ReH7bt;%`+^zue3-X}c?HdqLRM2DuEo!Dl2Li3F
zTDB(D7ogRHj`xf<`^H0wIcE9r%o%1LsEkiPgQw^*)4aZ#xOxN1EC%miRzG<CnYQUV
zqf`@DwT(>>Rz%HbW%M<b#MSK$d?+}^y2&wdHNKTdTvg*P$9}}^@@b@r_z|~R0GcPR
z9>cFVB(A1X8J@U`L>ZpA`bjCHC9Wc<jGDN5vf0X7g(7iPPbsD)u5O(Y#R?l3%J9Th
zCbxh45w{ssgeR`dD8dt0L7OoX*^jur#|U+atAePeB(9o)_GoFK4<{9(-3AO?NnBC(
z4qt2CswA#vQA_s3)he}y+Z(Gm;@0~ds($r|TT?tG^_ka()F%O%4ty^LK=I5~=0-Jh
zbrM&)%+-SvVtG)O*YZUzP2}Tv1Uta1so?WU=IV7CH5-IxdFCp-zoLjwUs*-w>OL?+
z^h7be=4sJWiv|}EWrYG6OX?H|{6DFWm7RGA@7B?Ycl(5y6xEJ|>#C{d+KMlNV6J)B
zA$pdCxgLShi)b*DuDEyWMOWoY!MoMOmEBT1zr;92=Bfwgf)li6I8Vf*=V`m4&cih!
z{pcG)+C?q;7@<gwo;Y(%Y@^1UJ_<lPDNZ@zXPYn`h@Q8y;U&DA#%HH!!+sp98#d6Y
z-AnOq7kW5>Yb|1pfa_;{Jr%Cj5BWgwHNn+ZmR=fgSuml*XR8_LVzFObc&-@b%tJ1A
z-Y+i1gg@<w<pU2_5G%+{9+dVyP84z9)(fFV^=)PmcI2O<2(pdq6?A{WcCP~2Z#Z;3
z(Lc_&COY80Z7`lWL#z)f<0H~H91(+W%XT8Xsy6o25{{T<^iVLH?M%hGA>IhgV)XS?
z%(9Sj#pGiRuo7#4a=^?V5nr4LPs5Uxt61(WxFQv4RfM_TL`X=+-*(t`gN`e(9ayVC
zu>$9c#7ck?3hGJ#QH`20w;<TQQ_D7|`XVHJvsP$Y%p-(sj$1K2bcUM|wXqTalhIqI
z78CHMhPpO4Xb3C~aYSx=H-&k$bE0fz5p)D_9re{z;7-H0aNz1J$4a0AfLqoTaA9p;
z%|I92G#k;?=L#^*09@G-O9mZR5KCFDAT|;wi}*qSAzTIQ2(Ae*Uo!y~p%(R{>H@H$
zP<3vawk`@_85zz2yT6LNGEf;kVB-8%{5}<|ap$Zq%X7wI+cx|6U@C$BXOvy;Z9{b0
zL|+;J5?RLfI}{l117%dqgS+&~ROS}CU(`hHn3EpSFG1r*;yc$peDgN(wg7J_)DNH0
z3*;|z?+?I^>%>F*(6;ztZSJ!2WFTIx!S_(&kQ$3PW%l>&M5!^Lva%_ma%d&y2?zK1
zLA3Ztm7fp7LeBX>4#2f&1EH6^`9K<Dy7_!wz=(7MxrqqiFc1T!OTHM$Tm(ODAQemS
zfkdKh-9SF3D+B3+<t_~*yaitir^)l1&_Fh?5Cai=zloXn2@+(MzCVM5|CQr>;$yf+
zvU7}_dp~4(c{etBdwEBhf*W`hXzh*v<={!PL(8B;r7%~a*tLt{;|tlQjBh;#svF;S
z?(e&p@a1XD6n$C;JKd<BeTW|TpfS#09IG5xDXbPX@2^BwZ@Jx`5B%fC$rpII<=y>`
zb9#&Rm@DUSMGQ-CB;GF%y3d!gX>#SpG~iato$6wQI)$01zBYw_bk|KGeQAUDd1$LL
z#C8~~ZirnFlpLp!){9?Ep%GDDo5IE6d<r8Rr*Q0JWeOke7gHF20)d}&v2Y_AQI)^+
zQ#dg*Le1c0AYeGx#tohILqT~yl!M%S(!iTj9fs1GD}mjt>KNUwIU7qM<XkWoZdP}M
zS&=L{Z5)Ghf!wSfAo)YuSn4<@v1xKZLmEnD%(1pLjH6?!gUCQK`uu9MU+4W6o#2b`
zSP0I|g#^cB=;oj^!kjtDQO&ZDH2rcK3f!`?u<CI^hLJeM#T_Epg5nTM9Kkhrhz&@_
zh^1DAim6M0r`S;->Edl2bke1$(jDQ-4(U1oU!8Q_)_p0Rn^WluAvL1{8|w`nNjwy*
zLv=j79N7iyy~Z47c#I?wL0k3|XXDsVjU=(F{RzG2M`+Yz9{V65xAqKVT1o!C8@|)Y
ze@B)7AlGC<7clGO@61DKHgqpJMHfUvmA_RatGL5l$T0H00yHRw0(ATlTyvo7bD)=~
zK<jlHNz$+A^tU?U=`~)V8eDftc+7%c_%+m(U8jwcZdhwLQH(;cT2=Ju!oobW=`>Dq
z37tl^iGYtk&X@Jj>3UqJ|8UUhNcAH^8ArZ461}6L&l-r4aAl^EU_SIC;Q?AVlG<(;
zolQa^*sMB|a~>jAplzKVjln59F%l#egmogm(u4%m<s(__Fp}rMLFf-+q_EDmx+$O+
ziG|=?&q;91g<f!QgY4EB@6@prz(Jv~I%J&)2HZLkE)}H-JA!MjG<CSrEV3(2f~Mez
zeO$r!>jhk-DL7YT5)csU1w@elLO{x5ec{Cmz-(1)Pv>P7tH(jXalDetiqNMiIIg*@
zwYjXn+hz4uziyI&&;=Qsa3Ke$P2Zak=yF9S;Q_N=cm#F_1$R5|T*1N3RMDe9|3_Si
zWYMd|ZB;F{3AG42F2cGTP>ZX@Z#uP58N^fMiaCRj;V$*ZYkt`Dbq3LR0ibeZ5R18X
zV|WpmB;D|8B8+FBoAIcgeQv-Yo?WyubA2#~9rMw=ok3jKC>TT@ED+#6IhsL;1Druj
zL<rOvL@)e7)3&Jwjra6IrwqbQ0uh~^&)@;Q`q@b!w*w6E0>-Kv;!Pq%dKZ;==F9PA
z8RvokVFCr4El@xhwj+c1cte@NKFE`hVV7<pSc^QrI*n*EfYZN*65*~`_CSQ`4ZF=g
z@qOTn^?T(@|D>&Jo5|aLKKQ_FDuT_^{XYX{m9x_q5jnC&xG`arD=}Q%C^vEaaEv0~
zQgT3VWJD?Oh1S23)o2h`wn8PftBTZ>eMX-w5i>doTwR?}r0H3}K64c}WT0B_GZ!@q
zt{|7LMk8+wmC$&6-UQV*BatOM+Qv>gk4E3-;A1(&l@AiN!=Q9y>4F%WT`3d(&Ndc4
zl!7>B650qJZPYbo$$Ag*NpTZCM{!O1=2w+utoVx+KLtatRK;s7^(G>va~+!%t&><|
zshhzOdB=_57IYFv@p;t+4?5N206nkefd!hTV=okH=cr=?;iGx*xP-h74}&`dZ;*3W
zp;4GHReBwJu6{f62BM|&p)A%%bo$U52Y(Yc3xMAcv!EMFOT<~dxzsWKi!8vGV{ykC
zO?7yS-g1XWvgjP%033tkL%Fy?ad_JWi;#0wrlFKzP8{BC#7yq+uEHJa9p0$bUw3#_
z=3vqt9o|pe9x%LMOqp(Yr4W3x>(*dY&ptpnyfhr4vNVOmTM0YSna9CZ!aP2LbF1b-
z2k7ANs(2#wss65VJ3%$%B^7D7yXR)}cPfF5Rtdns9g4YBY@<`YSe1h{;%0#%{f)8d
zhI9k*FZ+<PvYS5Fzn^euWLYzq%Uk$zzBP_urxJjsf?vq<B1qcxz(f^LV<-cW^ydVi
zK~tT88bfKst$+lCq<R7QR66>mc+j@&m}eP(!ct3Bs?Q#*VjU2Gw>WyoWkuvtWG&cK
zPz`xr1uiS*ha0xt^K?Os<&qX}uai{sJXN@oL(+o~StseKU%!Mh7GCg6Nhh7KOWN%@
zi)aK%WjI!zH){(rp>mb#f>_AY%9E&zXTb?+xT?0>8G#W}I3X(``cS9YZe^~-5dQ$i
zp%eckLaN?&jsKpg=}h>^uxJ%#=eGL<j+NVPd*rCd4H;_+1|cVvqj4<xiQBGlr~6cb
z7$w$?PR8NZLN^Us0?GuI$rW=G2BaIuE@B}1klpK`vth)6acJ&z=tu5@vL&EyoKwcp
zWR>DhOADGHk10#zn3Lk@PWP!V+qM*oOeaHebr=fDb9Y*T8zH7-BgUi~%1%T^{ZQ%{
zzdPV;EH*62)G2Y<A%=psb?)>!jtKH8X^d<yUsjY7TtFUOhK4d*(z(-#ncAeZM8xK%
zP~aQg9NfX23BkE>lHeGDUT}oV>|P}eLVjrqLt)CQ=!46PW$6`UzW6Cf#7Wf>!f=h*
zmPeE(aZ`S@I~Y6ah}e+98R}-8@brNrAw0KN5+0+_3y&zNN8Nbuh*Q>XgKev#_i&Cn
zf`C9BsbWGstdw9a^5{|=^_e=<)l9}Wh}{Hv{KdLDskKZ-7&lW$y#?ayq~3#om>u$a
zPQ8!qkX`QQpP(&{nT%Vf^qGui`1AltUbd`YFY>sOB>B7<*)tg$Uu}ti&G~8*ij2Cm
zom1w1!B_v7Ohv#~7bjt=zu>DMx&C9U(=lk>SZB}sa;&Ksm4kW-zS{htl|79HUoEJ1
zRe-v(^VJh`L_q!y?ne#CBXC@_<~H!vrB*g%o4IHhVkRkH?r<8rDOqp!iJ6gn0e%}h
zbu?|3IZZHaDxc`VHElaL2aLlE-=rHy8$|W&a~9{+Tjjt~E~0H*Q9~@Ua9pLX|0yP>
z!rniHa9&{~T&d}NVkW~v?QhTC!8I5126kCU$j*yf>U4{~cE;u0#5EssHU#iGIa~6X
zbd15$v}|~DU+jwXXtj1A3H^|dGjGRf3dBg&hPUFHVDt<nNrN#DYB1AQ-Zv2N(6JL6
zUQDp68ltVdH*u{ei2<=*VnlTZ8y>dbsSUe>hG{mO!98cTmG=N7<~ZON{}6ze+AiY1
zoXbSRDDi{Nh9_ofeC!5dANQP#8|ehs_}C_{!X!8_*9(pqpIs%MZFdUwUc2a@UD<|a
zAQAnJDySnQDyWy(D&oEDS%RaEX%nbxii_YT6t}^bipv!gQksFYPRcfj;Mt{oz0H}F
zIVcm_krWq4BZcBF5;(^16#-oKD$W&msuRW45_LDkBF~v#=;758b(^@x61>1!CwNPQ
zY(*~`1oQ2wVSAj3?T)pbsuu~FTrWr#T|^y#gqzTd-^F-ZZWmEp&K1J-Vv5j<j_u47
zGk;JQ^B%`}yX};B8tLn@_>aHzNY}7Jd443e4x@X;h55$fitOcQyvdmn#O-Sej^7uz
z#D%vS4tJOF3%-*Mw`Skgqo0RGcgNIk)pZagN9~S2MW}X1*VNsIs%m%Va7Eo+y{C0|
zX@Zsgjqdyo!YfgCClejIWBZ@YGqPv1HhSe9rEcC#gAPVo<AUAu)=^u&S6j3^pMJMo
z3?v6yUSy36FZ~*fhFbnSN#C-z0g;#)%{|v;sLu;)oL`|o;o$U3yT(7`d`r=5W`BcA
z0-C&S4mNh+Mev&zK$(A3>J>woLD$TMeb>fQ?KC+s1Cj)CNb`)hvW1=E8X7tR+q>7y
zf$>#QNIP2MEq{aBRA*i>n%4wSS;Pr?u^>XOj7QvaPT!BETNZ!evpWjli%}Ex>da@w
zqAEcjK^)XsiO|goUFUQ@E%Gf5yoY1)g{{tU;b9lxz6iV<33~9j7N}ny-G;nt_dan&
z444C<RsqUvw0VyPi*gL=p~3!L;zFV-QG>tZWn_m2g;x2iAKsy}xG)Y?esY+qR?#(y
zzfzm~1Y8k%%in0?&mCiB1-n9t6XC*0{A2+Bg%WGs^?~mFKiz%M26s*woSde0_i!}O
zqV6uh)HzxcoOBnX>hBgPq^`SdFi&-KbWNjc0cIw!48|3WuEuq(yQ=7JST}T6Lg}uI
zv+gt#^>FOYnTf8fpmvvlE9x$1y4Ky4QSb=eVWPv~vS@T;$2*LUn`quq>e8es0(4K=
z9PECwn%d}MTv4O_pK6UB83|KBqw$-O7@|gZjng-3f7LcxJ#{@BibHR9E&@b&S)14(
zM~(lOOE)+vJrn$G3NgXWyp%n8xy?qUKn7DsTV3dd?6D<T^~>hMjd^Wh&ioSxEqQf&
z;uEJ4VyG@m5_{NvP@9I+=NX0*f-9_aM_Adz9&vT^=e8Hifoa<J1Up3!hAZ9PABC~1
zFPwPG3nvS+Z|p~AUmh7RZuYyl)ba#8<(6M{CoKOZxBT2FgRS7P3O#i6{6^@yPOZq>
zbAY^n1O36RMw^oaWlsDbYI8C-4p#FWCOUD4n3Lo&`Z-AvzPS6kjox|C9Cw<{5PTE9
zgDXB&QJw5Ra7F0sIIlH))MjOO&~WoD;2AX8yMdtH9LW{)p~#q8-t1fv99!`q*4Q+P
zj{}M5Q8b3gvT9epxT3BCuW4NsL02<+#f9g~rF2yQT?xtUD*6a}cw9vXR#Ka4fGcV$
zm#j6_cQ{V!^^OboZx7x<Qg^}h*`>zMHR@uM3Wy(?Uf&yl)G4nvT@Y8)bnY8k(`*>d
zQuc`pFF6IN6>56sNPW`^AgY6nLDI3pU2|dgmm0{&6_8ys(WdaQPlw_wl6~M|?_r%m
z9`?xyeVYQ|QR=7Q4r7XS%0kpbfV|m6*MxJYD(VO#a7809U(`m>1igLNH!i$cW$Fzh
zsO`|3N)yxxHHz-k35`)Fln#){v0-XQO>spX{dP|4XaSDA=j|649+-rb2X*vQoR*_f
zL-z<I{&?ta49}zw-4CX#p?eV!=b`&G{0tqI)k60iD#JtfH^YQouf2@kMd)5N#L7PP
zL+E~k@$%4pX(+@fseCWPTYj1(Y`B^?*>Ldhy3l<Ak1#y^+T>;}bZ7lW23!hGLi-^A
zF)>#W*0}0>K-qK?LrH6OV(6NO?)jBfz+!Plfcf9m0GskX+;x9)*T_~7U}NEa>}u;&
zYpdgkJJ;GSrPP)y;fh)=eN1aPb+DB^N6XEZBIi#nuK{58mcKOPDbNj!MV)m=GmZ#V
zyYj>pb(Q~=)>R&KwQvB;_&sv+)Ril`(u*#uihOj7b>2YOTNllgD=DUY!cJ$J4YINx
z1LMM5S5=y;i&=Ccxi$+%DBJ&-1=8A;5vu$NxFY$NU)AKFI}omP5DYvKNp_MyIac4H
zl4Di%w=Z&FTz{*;!|3(*BH|F+b<Z5&20Xa>K7^xiP~XW^B=3E55#wN?y@B}EMMZlT
z41nznhW0+f_$S^s2gMJ9G<M~^tpuR3Jfytd^L5I5P>nu?k#|>k=d)i(c>{)EB<hbD
z2<1Jdn)z!ehHk<g%{)5jqpLz{!h!^1fp)bW+uzE{ejgV;xIZP*f!NURH9N<mS7ib1
zcn@D;0fF#AdKS=aq%#&UsxOrS3mAz>N;qo{ZgL7PMFo|||2({+L;NpEwM6_69Z1E~
zWRJgrw21$cVzARU1o8hwAFbF?pdZmQE+C$6QGZJYU}X02-(`ew9qzdZ{ij&}>cf9M
zJmucwHQ2rq{!gF`en}dW$oJSBIsYYSnoecyoIgKk5L^i9?0^teXCrY%W3U|7bhbl3
zD{C7ITG<Fa(hRgjM|LAoT)GxPLLK{a7D0As-XulwCfn?6V`*P2a~ldjH5(~!>TUsG
z)pe(jt}1i>7AY{k^1E3=9mqyp(LieL)dq5<kCmN6%K?Y6rl*!q19*GO@Ka8h%rqpf
zIFrd+Ty6TEf>CZelgWXm7Y&0WdA&k3{kea(riDdlT>lc%O}bfe#`Oo3R6C5s6^-Sc
zozHaWjY$~}lxRzrPl`i_PF-S-HNqt>)Zibcz(3}U2GTSfhYz;Jg<Il~Fs6pb$2c9y
zauxdy&<c#?J0-C|Z@8#|iLOb#o}e4?og?!eSC)0xT-JAk((^UDGd}ViLMeLor|s&D
z>7f4o^gV-DCA5<KN*(4*I@%S0-~&(i-2>>GIq9nSQSWXC?eod@wUQzX<JMT&%T`h;
z_e#|xTv+foQtbx)ds*?D0L_z|#+Z*r;^Z$E5(yjR0iu$7n}S<SdEhmfW`q(=5$5D_
zcQC{#vhk>yReP^kmc<r+BXu(DnP_G2zd_3_Zd7q$VXdVQ_X>2?vb7W%{porYxCP_u
zCmmh(<VI6j#)3;>o_RnJqLQ8=m5Wt6cN=oS{I1+<3~>Dulgz)HoKyasPu%Q)o6483
zT1&-C?m!N$dD4~UNw1qHeX@n($8(VpZm<Va;llq1OmN0^ww2|MmZAciqBMG(@{g?y
zepwGC_rP1CFLZx@mX+C}rT_9b#1fIFXjayeEJC=A#0+tr@xjZs(ptlzPIx1*t&|#=
zyOY(WmFs^|NyBrl_s+O%$5_a=sGU^EaP_QfYHB-ar(1sg<4Bj(gpSfru3q|^jq$2M
zutf?q<X>-K4J?wMd$+#<To;Sv@8<8uMp&f!hR4+nY@0<2HFzbuu{#zi#Bc-BxLc*p
zhFg=MC<FiUVe5=@J>tzt?M>eJMN|Ltgm}Ip_c~&(JYL=Dh`-vKa_%Y0(SKkiEZ|5p
zYLhpGF%5X&;*!x-`J)*95se>sn5uZ&vEK4_d=)IC3irL3dO5d;t4o8#&+a2bwiQN`
zjlGu0!+l##VehSyclatEDbnOTXoui@`DO`x_pK@9m#^UeUO@?{<H903Nr{2i=6OOk
zkHYjqdotfT@S64xPrbH!oT0;{oh09`OOK<{*5_G9cO>p<d3zKE%*l0U;=XxiGyDMj
z4AWG)l{CYY0DHs8Cv6DjfBry!CM`6jh}$hw&>KqqEdK0Y8fMVAvsA|LFs&mS)>&#4
zD1lvM<eYNcYf6wGq)6SxTW*l*iXX6_YGuVXOQqPS&Qg$Z(lf5q(+&91*plcRp%QDM
zh%QpF=ghhTzP*ygI(CuT2Id8^j7sWlip8reP_Ml*^pmR|NIKd((nXqXs1t2v?Yc^R
z4F|he*{-fqlwsUA_>@UEDa?=vN?oNJCVb=^PiE;RwJ7%F8>ruuESs@;|F_iG4xz`;
z^><hW?CmB+mmQBH=9&0%9u_IIz<-A#a*c`v^ezt2jsyr?@r~Sji6^Vw9m7A;%9Azd
zDfy(1!(XmG9#}l@B_#JyL3}z0O17hi6lB;GWo0*eNHyL6TIlJ*8g!R}bCS=HpSJW&
zMg4lNRm)*1sjqq%DJ=f}$Oq&;xc+QbMBp=X6j`$tR<`*&sf^EQK)=@?%_;cwK_>Cv
z@1(s&G9PoOUwwrC5K!Mm7);NLuGz$`QUH6{OR8OAyeKurUTPSX`ju}qt~Mo5HkQVZ
zf8|9L+}Q6y^#Z&XHWN@Sr&079>&8a)mMR-6w#F;Oy`>U{c3rUrwOgv`{kEyD+<`G}
ztXLnEn}KO+*9X4t+(DS^s6J9H!;|)IY)c=hykWb=jXmlk)pajG&%*mkZ4DO^-BQQ(
zmHb={LqU7y^^-;$ru+a793xdX>;$!oijkVTVbCl_nq%nM7~hra51SA0_Fx_ROYIC7
znz^yn{iSf<^iytpDBhS?Gac9aAbWN*u=Oufd=2@20%I5;4Kmal;?9N+ka`%}eQRYG
z2S{ea`g<NMXrL5eXx|XueHkdF8!S!SSok1#kq?dC*pxw1@e=tE4q&tJ$zaNT``R59
zUIwC12+ker&Q1)HUK@5da$^SuOO*pFw70svnQV%MD&mJ$PQJ~`O5SC%;V-<L(%i~?
zzL!c^pSI&=?f_(znJ&t}JD`kDbIj2w-0||x;Z<rf|Gnn*?o*rLL;G+VTTn5*6P`vT
z{mIq2Nkycrgl5Y<Lfx43y<{pi6s63`FmjsWDK~79QOTQ4Kj4q%iANBo>ZUiol9k~N
zx5K)0fpN{~VP$28K%4(Cxv^G5q~iWt+G5nT2bo6M!p!?K4Co{(IW(dtz8f<{s%d!D
z-O3IQ!IYM<da_qTq;h3vcZXQP7^69PvS~fW@!Xu1GcFegE(=OWBL0lqa;4$uAyx{n
z8Pf=E#gB?F(u(r{wN5Ecwkj7t>*CU+;v24}XkEV7&yB5#m4Xe;W`eE7N&(*O^sP@F
z##=9r^)9g5g;`y6O!5sj=$jmI#<9t2X!6B5D8U~ytSoLQJWC*k_sdYJis3Po{T%MZ
zk1gS*O{uN7Hl1CXU<@6|efFTC(=?Efzlzd#FfLbHHIx<;Tb@dXQ|WVfLZ#_nIS8dQ
zy!ViqbI*l$0lE@kb+2yYMxNt%$9R`Lo$(ky!UJVY{}z4hO~BuK$RXi1<S5*1nC<2c
zx>=5H!X#XH>-f?r-K1SryvJltx}0Ua*c&%;=x!XO8*fkp{v9IxiG?rT_$i5v3q+YI
zj~{1cr5{4B3y&6D<<c$5)Lc*seDz{eN;%eexKzAhb@9Bu{dw6g7=I^JEh-+F?2ii2
zqxwQra^YFVw;-C!hf8JMkCg<Y+Mg~JW3Pux{)WH6KD=#GnQ|Lu8eGypaF+>I1nojK
zx#$esbmb?I_)R_?Ic6AGj1A7ICsuC1*`#9eA;(=@(u<-PUVR|dAYQf0#66xTJ-W_u
zEn<Jf+xeJ`#>eqTF7`)UtIr)nt&{xGL#!I~4Q`=FN&L|X@hH8>O#qBCd+2Rl5v`KP
znMUCSL~xi6aZ-=+e_iD>kUj?mvy3%GJ@JM{^Q^PBLak;lBbbOw)M@9*?#D@$3;hNT
z15<&ire|^pFTsJ99wAjRO$Zj=aT{8bCq9Hc^HD$%l6(Jg_gTS`DOKGpcnQB`O2tqM
zwBUshl8_-ilgqbvb7`>EHGLzO={c6JUL&Q#&3vM9d$Vi$T7LU5mIG)Q?(Yu%cD0q)
zwBIKZQye6oao1=osM*om`c@V@QVQ%bq6!~_HXCa%!d550u@ywebTcOjlJp%61}=$v
z1rGl-SuM7i7kh`{$!^_6u?JL<JCk!q+0&6yKuP0$j;`LX4C~>Bj<Rg|sPJ>D9+_m|
zZlUBU5Hyk@pBeI6=uulhNE~tHRibfounytJgkwiZGXhgaarSmT9XP1$?KPkPdz*p{
z?T}59Z{;ql6!x|gSw&)Rhfo0QtugKk_7-LGB|qVU;exu=nH|bp=ShWpJcbFf<}dD-
z$P2PIeKgq0@B2HlZKI_|hUU<q|3*u`ZdjFbW>$ZU6ckyXlV4-AhnlTc>3|t-i8IR-
zC0vv!QIDd;J9jNggx5rr$PW_F%FmEm7DHGg-iED=?LELt79sbj@RBxA2G6n5ctfsA
zRyK7kcw0(6ymUWSYLu&O1Ul-2FW0i?Go)gMF75DT(s5D|L&p)GZ1gxOve*R_aL(TD
zwzaa$<D}MQ`=JP*7m^d~tt4oUe6N6DZ-kM`-oBaQ$=Zwu9_uS8>}?kQa`kxz_oAm@
z)37`~Hv#eP*YY4#6W|)y1W(ptA?W4pa-OMe;)%Bv>+D!*%Xg51-Y~y{{YHhiiOy*@
z=wm}C%YvRa9PP`lCrDmC2eB&Blef;_At{_7{aa++aqc-&Z)vmfXDfiT6V0;BpF!S=
zPXc+16s64eQdOx`6iP)Utu{T!G;vJuuiUGE8|xV}+9zM1QiRkvQ>0wEE2z;Vshq)3
z5d?J-m|G}}tpD#)>3mm9s)d$yabq<TQD{U2o+W~|-CGK3_G2PK`<-fTY;Pj4+*r$v
z{gWtFbFWFy!Y5134Kv2Mv*DAaBZiY;zjdZaBMkRI-?mJ_f;tFy<SAfn@ZXiEN-2ip
zVfY=SG>j^3s+8N%?w~u%oGP^os9W02B|U*7*WQG!^g^bnq{s5NwcMFyniOLg*TkJ2
zoF;Y8<yH%W-tZCn6ERt;#Jc_<c^QH)c(5TqAQ*UrTG{j;q?-ocl5VVj5@_4Da5r`|
zNeXFr3c(gFVlCTRC=VrR@k_SKU;A>=Uq_X{mgk|rw&Sl9xYVemNAlc(?yU55u)3~c
zZmf7RV7OAv%A%8@!l}53O_m}8Cs*SfE`=PO*W}XgIL{Lvdqo*5+mkF6HWbR~#%?4_
zrV61bthcqs*=+6CaM)TQjb5_f#z-v;bsAaO*cn&}x69$i7S520`}M6#ysWIrR?<$(
z?xEDB8Bz_yU*J35GeKZ7YJ0LOGo^5Y6?eMLlzj6Y;|m}<8t`8SH#QN4;%kM$Ar~?y
zH#XG}WR0`0$;wKJK9eKo*n&mT4N@}~@_XA_AdaAXFqQY3@&N;<r~Cu%rdZ4q+%PX-
zR@oo$udMalzk{eAf#Y!QHa26XRG=2;X-h-1Ny6_wgSx9$FAv-7AW4Z9Zp^jQXrHjT
zL*PMg*g6r9e8+pY<cvy=^=^e<rz#;>Ye8VJ^hdyRB@+9IKT1VIw^1ni#+(!d#e?+G
z@;Xn13a_XnT#Fmuc)GC=N%F=1e}<7faRRjs9Oz#;7{x(jG8S+<F1#9cEa=%YtclV)
z0xCT{yH^1>8)UnAnr@b*n>o><LeI9*O+VaJ>Dl8pSd686>h4^o8x&6jKTDlM{A?mt
zCPdE~VfQ_~*b`3A*6!rOZ9S_wnI-j6b;rDPsWhvYA{CEnAxgBhm#B{t8CHy}f_PNj
z{>Vg+>Iq@V@n;!xLz0ZLt&*OZlZ%>I!WuY_E;&`IX4+TX->?%g;8TheZazLlVP(ye
z4iSjNK;_M`xOol^Kz}ocO72u|($wUmJBP&`_Vfp-1pDzPDMx%iXca1^KNL@Roh)M;
zahK*WLN=`i(V?0kQ1<(ga$dTh%<qTT??=e5R^k3!em|G}ex!Vp?sw+*UqB_P*PE=+
zEXmg}y)Hf+GfV1T@Z3&8*XCkkz~WGfomsiw*Q-#}%$>y3h%9ue=E)AulFIrVu7gtq
zH;ATf!y_Cpg2!~5Ema9wW+1g1XNr+m6K5QNrwTUY?B&0Xuy1Eel?-L-V6S?%6cPHa
zHYW5Cx>QP0Fp@i0cXQd~nm(ON5{Rbn&XxiSG^{MRTOz;xswHwMbEG1q-3F=*n=Z*s
zHV^e*GRt__k7T4jB4t<5MwnQEO`KZ&Ky!Dy3GBs96o`=Toa6;mjy8%)bZMyLXxx|7
z0zs^JqrqNCASj)AW_g9R#~$JE={(JuMmjo1Y*Ah~$iOYWbou_=;yD{5i<gODQ|!pM
zi`dxP7WQ<S_grau;4Dx-q|+*&CjYCX(-cDX_(z41?fFq5WW_*ibcAdf?yH0hJG&Yo
z`)!0EWCi<ma3Ew;o>gFH3f3>ecD5Xvn>~Lf<uJG|?Z`ULlNuFSRTpUUG@1u!msjdI
zQy|ZwRmNm+rgm!{a%hV;bF*D>Of%bgHSkG)#&c*%MUg|R&ZIVhWou|$ETA!HMoFw?
z6fU*_?JZ*nyd90m)ch><F^s@+cJa?rc;KNzsFiFp#YEM%nJivY8q*I7V2&+W#sXkO
zkA9Xqwd=Z(3()6?CO}(6uJjg#TwGcueJ18X9GrU}L<Q2gm87<4wTHQXds7TaVs`zP
z%$zh|?$Xhd&HhDdY}n$1kHVx%eujfpt?bn=QoFKEe1wA!R+Dmw$#U#d4?r%OR%u<?
z7=_mTSkN<d@q8j@r{RzEjIIy75hrJ@!43J!W;2&=hoBfBXJZRkS)qlXdT~7!s<+Eq
zA&FBLf+SY`hzZg+IU5XuH#zHTd~bypK>Jk+^;t|+{h^G?9Mo)LWr4p*%PL%3&C$HO
zPebzz@!=y1iHqcfc9)6%l|Q|5Wt_zQmzQuM(>oRE#(aL4%H>#ynM*&Do86fN(z>U(
zLga>O1?!{WA`~=u6#}#UT?%wxmISi)FX)~jp|BeZS_B5uHW0~?MIdsn^laK9<lhpH
zx}@G*B;{~56aYJXv{*_oJUZjT`u~CaTYI?gC4V4G7JvzR`UetlxpVUbToJZt38>u0
zXb-k#iPXw4DW4nryhJkjE|^6QY?tX6Vw#eL+g3u!!g=|EKK+R-+_@6&Z10~^S3}NX
zRu;5WY8Z5K8KxXA2p{|y<-G&m294l62{6Go+;d`oZ7C9SK6%{Opk-iqTXMUx6U(IH
zfyY2&d44G#x}apxK^!P2cd4a2%l#MF+xT2=%xyWi+P?vut5L!QT<x96w_$OKF8nZy
z(aWV0fg41b1W_hcl$p%ST+VN0KP{L1!^WaaI;HDKV2$P=J2<AYn6wCaJ@_&atTvgs
zVewxOtZKaAE)!|J9I#NOHFwaDJfH%Zl18wG!Mrqrb-6vx6|DfJ{OO4+>$XBNmHxvY
zU1IqbO<IH`Ujw3)X8fTf`3mO-r7S>u?yL@zT7`pUAu<qaa}XXJtyCpd`0h2i@I{+&
z3br6uwh{2V4=Yk>Wdz6OBUJrJZNfb|==1mKu598;shH1H1QUci)vD$1|HY~BmB`^O
zFnO|zE2R<zcbi1G*=6D|Of4tao#7o;fI+LI3LZ1d<<0HR+O3kJ;|rjyd1jxhof~v%
z(6vFg2Hm?JBqkS2785J4N_VA19iL}gx8z+WF~>9VU?8n^<q}aYqaMk;k7UPa=wEr4
zsGfjpS6dLOi|KDg)kTUfUdhoVmmo3f=8xwFURQ#F3l3PYG&H0WT%Vo;dcf7CH_3MM
zc|qKapqn}lc!O>h!A+F|<}QO9xwRXS*fpUZ-a|ye0k4lF4)|xZ;DGML0dM1f5bpeM
zT)1l+HSco-uH)`%sddA_;!&La(Ral$#;&N<Ry^utf7FZ~H55{kf5-QMOXDo*8mWSN
z=gg%%J6F|kJ;cgxtwCb$K|3(ERw%~T$h$Z#ms_{R&Gz=2`yjqttF3`mT?>~y2W!-U
zYmu1iO~pLaV#MMaO3<$;-s!i{JKiR_#?o}ZAirN9_rdY(Pb1{K^wgI>4YA*klwUzp
z({IA8vW&UJeN`yV$XJeb$OF#_wz3lIr1k}>{wZkPGYE^#EUb}#SSOV(;1(>xC_hxy
zYVndRc5t0k%HWOX&(>k})g{Q2`K*^p`i>4#m|m--N9liK3bTxBE8u5s)=Q=HE=G=y
z$6lGOVbj)2#oR0_*s}HDcQ*s^BM0lj?^Xn2p6L_z3XnY7<}J+m9VA0*XOX^$*dPUz
zd1(|$xL^70rR6zLu!98rEs}6Tkzaa%Y*4QI3NBJMNd6tVe6VOt?`PPuo#|bLz;awk
zJ<}VxR$+P~&324Ryfg`>$J1=wsa2fK8stgw56`heN9*oD61h*9j@Ip?+Lc=iS{HJ-
zC8u?{&B?_2pMj%Oa`Ug>h|~R4j!tpKZj@#RmTJV=+=+FtzHDr6!cf8HI&~PTu({0*
z9oQV5-cs4z1TuZj4QA%6YIV9Z`d@Xy?UbF-qJLMw`?#ABM}MByk?q|CO4ksIAShiZ
z-x(cen!qXDiE^CM;q!!y8(`!r%>c_4v9d9nIhza4x{TlN+bmhab`=(E4m+YNuqfXf
zjnJSli3XTTPC`!kvJI<N__3;6q{)U0Z!K)s7U_G#lLlCUY{f#q2JU>j70NfRDN+Vo
zrB23Ub9mq9mTP_Q_P4SpTam#qK5}KbQ&D(-4Nq1+6(PL98;c-kK`8TcD#+R5*B0&;
z&ne{WTt3WJ)CED#2so9T{m??$F@5sNL+qGZwt-F+E(NEdr&IeWHAU&ODr|ob<ZiCK
zw6Ja4v2l75Q>xoIE%;JtCSnJr?%DujeKYCd_<H?Lu%N6L7M8LTo1`ybWqR_Jgc4_V
zN~sn6C5}Mw5)FZT<c5FrQZi^1HsSdB>ZJA+SF!zB{h1i|a?)3~5^n6)E;y)Dz{h7d
zl4wuemF>@2Pj%(G7I$NlcB5Q4%5B??rSScMpjfwdOH~ciKe;mF9wgMPE^e&p9;vQ-
zDS9?-kJQ1Cu)>9<?ZNbQ#6_;X(jG%Oc+nGkrJ07;>s?r<eNsI`7kHxu`=m%iDL?#<
z<UT3M5SnRW1NLM3TyMLxANNb`f)_k<#pW;EojGZaDHwJ|rygQC8G0n&{s0p@AoVx=
zTg06WJ^%{UCCkE29zeFZ+wUH%z(L7q==;QyTI!$_<7&vrbY*i6N!<+7aq;?)RJ`!7
zpfNn|w+|uvfkWrHv!;-=;$f_UUx&K07KcH$>SnmIhDTr^sUIyY_6UYG6BqN3NQG-#
zT+&B^G<kV92&OH~eE=6*nhkJj4yR4peY8-_rbq~G)>`ncD)=kQIO@5DJv)M3zA8r1
z_s=vf{fde`#2UY5TAc48J^)`PQAvB{>hUVciXoTdk7Vh{qf$`t1X|coB7nA1siZ<u
zc%_=BT-ny6lF88GgN5BXDiz5&v+jY6%lNDuTfZ5kcu)@f{Khe<i1%ga6m`WV%T+|b
z|5!i6!uKCbPgTnBmamOR3|fkDkP9N^)0EKbq$|5~42&uKy+sv<OilK>=*qm0OBD@e
zJUv<C<5H=D%{*1c#K+|ArR-sjs{(B~E>!|!nweo>e;=3H8-9eZr@U9;As+Bo18KBe
zM<6u)EB8RR-A_oNh2;|<MP<JrMdwervfoZ18AcjkcS;X#RhwgBRf6#(fgOFpc*ecL
zoM&e|{pe<P#?zK=>KV^OENgU(2fq?UH{QEcR~b(m>~v)ri-5FJ*6RUnO70PxlI8?1
zT=X2x<m<v<!Fb9sb`qPC4+LGyoUJ{-2D{|6=eT%u-u`G0JyK{-G}HqmD-XWueG;^1
z)>%P&im{fb;LF+=tgP=TaG%aqz+aZa5S5S}P53sgikmk3O%D17>^bZ?B~|vx1Km(c
zN77sm!~^%!Qt>`pW1%N;oWq<1DOAdEzqEiJp;d^q9*^+d9D4z-hhwNfO<q8<KjL+}
z)1&w3Da&XpXl2Q#u|&*r#n&iKORWnmogx?y4m08TV=S5d&q$RD3~&{U2QKBUyk!y?
zPv<kx##lV(jAxgNC);#JD(`#2MaOvV@<wu^(AzUoX|Io`iSfYSk_kWkkwu&Z=~*|O
zwLS~dQ`yDJCZCle`n#Zo^d~5yjF;<wuaB;@bXkMjS;jDL4h9xJW^|A-QeUveTb#ne
zW+a#gN`CTEc@Xz4d^1w`l@^aJ#Dj|Dfd4=S><C*FRL{Tjnj3-(DO<sh#_H*ig(l}<
zE|m@`27drV6O^eSI;F9hsZc%2CS!k+Ga_#CnQ_F3e9Feq<F?4nfhLG-7q{N^IdrtB
z29=o*AvPbwa)bJyeV*;2m9bnA43=ggJ)W4+h5WSi#lf-j((i#?O`IG3mjZ{BjT>#m
zLW*xaCbd<#k&N|=F4Hv>_f>9GjXZ!0#K6{L|5{3>t5SeNrYm~W7n!b8F&$a*--s$B
zpiSrh#vUXV%{;SJ@B%VhgGO=Fw9U{=ujeNVYkGlmq4sycg$7-~sl-nR2DHnFBxHIH
z1a|sqF@+0F#6tb@1!;-F=bD9$yNF$)h!R%z_#y($gsT=-;1WXO0R;c5m!wWr^N--&
z`A*lmGl1!)`+Yr+)%mC^J49{dDD27POJGIcUQt+4pZ6Bl_A*$}<I5uIM<}dlIZ}D@
z-&?*+S)D24$<AL!ER49U(3yf)h|UawPtntv9PlX7S3zfrU9zxYS3x2CLY4GXw~HRB
z=dV(->sOeczEV{z%Q=;b&ac=>_GDMf3l`S+Ix<s@sH#5{N5Sw0@+sr4OM8sHVmUqo
zCu{gvURhY{8<Jm%smM#)GXy*(Y|b+NaE^vP&eTKh=<ddnZXhcab`^+@QnFI!M;4ZL
z1KW!q&#DEF8{C-hO=P8h0gz2^f)<T$1?n^KCVYp>Z4j=T0O;?#uI%(pWTnnW;aQGb
z*j~&mj<x<R>4f2m8%`VFmJ$ssX1TCsw}DO(+_`xh@%PR<3ky$^W*h!KZK3_e5{9z1
z-P!##sa@fw=fQ?3u5%Vd|0_xP;rh1>Ecy<3P>Fj6w(E}6-H_|9g$3S~%t4pqL<Xv)
zLk21Wu^Iaurz~vBUFp7|&{<c?Ks91(@4@A7J>$xb-;;`0I}Q%QHyRT#wd4aVoE{BR
z{z`!UW*K`ce=P_1#BZA-T!h>QbqX!)&T8EUb!v6ml~sBGG>+b~upSS<(f`6l!UJTk
zY_~W&T8}vdJNh8l(Pr-7e)-$N&OE^Gp5?88JX-$oKUenRffVxni8F9*Jo#i1n{j-1
zuMjV|%S8Gs=jf&KqC03#Hop|p9!cfBrX&JDk$j58N8pfZN*{_lL>{QJLX~(sL)N;o
zgol!;Y{E^50l&=CKuAc{r-W1upr|CI-kk=2@)E~bSnLJKTykN$g&ey#964!Rj1ZN>
znd^-@ruz7b0LG-`q{g1kHZaaj4=c+RF3`4~2ywJRCPzlINYg_9%HOPUWs4tyVfBTp
z*XN|Z+3L#9Kf?a?K-q)2KbA_BoF=QmfTI)rLWfQqHwxf#09nlrk2&4CaN59TJjSN&
zZNwI$TXpt6hNOI(QAtj1T?2l_w;7ci9dHB8m(Q)ugmjab*J@`itfDLxiVw$gP_BO)
za$5~)2U``C>&-u~yzEJ)bU3FkDAz^0nVoX&rJH)n^%Sca2g-GeZq&3Vnf73>2|fU{
znkZK>N;16_Nv18|ap884&>YE1cmhx^bMuw-W7IS2wh<+)_7Y7W0U63QRTGcu*&mgm
zM+)g8-;b?{rxv!~Go^z2?`zat)1HSG_C8%IS^p$*Jn3V>a}*Nrjud&TA8xkDb~A)Z
z5@q5gDOKp@YhXQ|NR{LJLw9gDy}Nj-5UY0LF1fsDIjkKtsy?3MjYa$Y9&&!VPx&f*
zZ^M2+T7J_O_r3W2JofuN<lA)r66`3;_!6|2dTqrDW?-2y;emzK%m4*5#Rv-K&e>C6
zIOSh5q;dtG-iMpPE(=`QTe)T*P_Qc*SY1BHD%vX(L95Pv4^}x76s#Qz@?;hzop$m@
zen6p-nV?`}*ONZ&GW|d>eLs|~&jbalFqoaqlqz{{x`!#h$ZoHfd|9!7B)`xEx^W0a
z6>y0X$oFq?Dkk<9m;GyDKjuyeD0kwT;9ZF*on;*NFXoVHX}V2Ey@YNbJ8ogW|AWL+
zt3ATLD54~F(=#oec<PJ%n7YLnEyoOVpjpQ-Ect<q5-QE&c3%m<?ux|Ipm&3G4C@Y!
zwc`_4`|+-QRNLfZ;4X)IJI$WAf-$OeD}gHB0$V1;=YB_YEB=MW;f<iiII)xRR9YMO
z)RR*$Y514as}XijIQ1%wqZ|Cp{%EY-bkxfY_f_guUPrw?6ji9#!H<Ye@MOxVue)=<
zpk7^Dc4Qx(fqLbD7DYY>^+IxlQ?H57LA^eA;wI`bL^IKUZ(G=w=bU;yJOJu-<GIu-
zaK>#xy&~|#_D?J>dm{rh+E4%!-Sh>h*OHwUmiYqIYabSs-~J2gl^=IF^=gaVp{4(V
zdi`eM-7OoWbvGM<A^p0~SGN!|R&eT7-0hPGv%CcJdc0j>UaxOh*nyW|UL&_tIM`*1
zRhZWgB``aG{PHF9>Xsk7dan>l_ia;{*ChPq>XY>lL!#Bh9-3JEI^I7Pw(m8V*P2w$
zysEh6P>9#ltsbcj-teRQ4;<?p&VUe<!}9qW@w%}^Azl|?hI-;P5V?TNx6*Cng|-}>
z8+|o&j$H<GdI#e52FEff3_9xMyNx0c_K=StZx`?$#B1IT;OVaruWiRHY{+{MuYp>@
znkcvo1r51&SlH$FAYR4@kgJclG9>JCWkDZ+PuoMTtknk)uhA7KAN7HVm!~_s@BwM4
zUU0B;K1#z4P2yZw?oTMa7n)V$6VgyKFe76>Ny&z(>n$wTXDQ6PRWT2j#9gLEfHjxb
z<lSy;Ls&Z>*7mbh#+bDURE$<V^sW?EkB{YB`weW?XQ{X0%|!!y{~76tD+ets`ah{@
z;mgr9n`7-;fU%r_rLDEF_5Vp%JYR2s!S`fCmPtWubrw=%vo^T0f3l?F`IdrmqH*)g
zV#Ala%q^PI*)ZjqVeXie4~CrUUD-(2lrr@u?E_>#;f$7-cO&GW8k=H~fNB)Mca6Z$
z@HC@{m$yNEl6VZGQ64tihk)*yQrLtRYNG`Qrh=`%GS^k6(i2>k*jJlhH=w;Q*w^E0
zb{&?dH*;WLMJ|iE=V!6Jrc4E9f_>G%udshas?#l{u%Y2ku5684im80Ny=VzcD}l%j
zm{vn#TBGoX!n97V2h%F3zHiIYo=eS34m$N!u5}GWUIaR?J9@6wa(%X8aIQ6%mlmcd
z*Jz4}rgANsFm9yyR}M@8r81-x^Qi_;ujg8UzbIU*_DR9D3VwUifolaL-Bt1BARogl
zth*F?wFK{iaeB4(1gBSp@n%<AmT|@jNC=Jv?c%c~C#FD2!pL2cK9Vr>uUu5Qt(D7z
z8(MhEr-i3XOdNR0-cW9&PpiU61>-u1<&Oj7LQ)aG1q-kA1?5^yHzN>a^!s`<=%$`>
z?L3bg_I*9%aOj4eaV2B-2d@HvuoL65662~Yj&@CILc)0&r&~1_G7?c$Pq_kl5o4IW
zgwJsRMU=}R9_6t=dUp(u6v{<DKg)RgoI<%WXRDMe8D6Grj+BxO{gFFL9}jB7S;06E
zsi|~lpn6By@EeMw`RTQ?-Msk@H$z#CwK#*eFGq@Jd^M;Nk)WQUV0v}@i|-+byFw#h
zR)vB!;P-Rd@Ar^z(ES|z{_`um6;b{m-7moJU$x)wA+MtQS7287ZEtZuy)|o+GsR?R
zdDOxN<xFW^;6)2Tz39Ll4lZKRdMam1xdJ<n2<nAw^;_A~4C<9TS4t(rKDce3{mOep
zp<X3WP@`VNGO~;o6#6SyN(HZ`vvt&~W_zMu{yE5A<PWU{|C(?Z^RMS$E$K#f{<RkE
zYUjI#B56SUD}L@SJ^yNU2^0Di{xy3wo>9u{%RuA5*v`n>H~4~)RXnR_WR*MU7+DdV
z`M_}HbtiR{j3TwXrk>afJlHxrB?~#7osvC!?Z(Z%+(ht42Nt#*G@HQh(S%r7i;H>|
z#`fh&kpk;Jq}bsxq2reXtP-}gh=6s<g+(kUU@=&A>Im2ioKH{*n0{X{J<G&-*AF~?
zX>Uw!ye;V1&vbiczH_6nFL*0&N*O~``Hn14zLZ9WH%Bb2O}-Rgw~Go3o0Tsm$e3A|
z`;=F0G^@S4-@=aMOQF{zFD?ZO%gmP&6*z9cU|})%ra6|nd(T0YmE?^prn_VQl<9`m
zzggJ*{3(46l~-9<lvhfWA#<UHE$~VSGrZhuVTZg@LJW`bZkz0t(xO<WUoBrbU>}3B
zt-VvCEB&)j1f~>)TzTU>v}_qI$Q5xWb+hl{3lFS92AN`L!!FcNZJ|Q3@)k(JmR}rv
zjGkiUgGb|ZDOGIwl~@2nE0|K#-7mvKzvb6$J~CYeQz+AQ)Uk!CluIJQ^$Lj-?r=6|
zdsnjMFCbinQp)($rK-A2*QGNSHmOj`1*5qd$341*hI?JGq5;N~P8F_I<&W+**B+fA
zH=T&i=%m|vC7jW}@~82LjMzH&em7Tu#pBAs<F2fzZ%Sp)nLrt?ZA0(><LkNuqB@>G
zckfUv2nr`4?NCreP!O>J0%AE7BP!gTy<?BqYd}S!h^J59(>2E4lW6Roy~h?cmS{{&
zj3p{aqQ)Mh-tRN}4mdR5AAcP0&Cc%3&d$!x&X$LLEnCnk6RV5OT)Wt#`T_MQP=x}t
z)vM}afX2rSj+c*z*jQ+{M#a)R#QK8Q1{M3<LyXn*t%kHy9%5%9@-j$xigknvcxdA(
zek-`bJAUOUP7{1#q9%KZ(L%>PSa<Xi6V!+t{OcutE>x0iYlLmLXxPRYVi#fhA{BdI
z15U)+H3IYY7KaGePYG<6H=L!G>rL#Qx0vX?Gtto@2@~E@7mTWI)g~`6SrUE3ek$Q7
zNyRq$BF`i|l=Bm7Hk^wQle-0&8lXQM2%P9dSr+0g*}OLJ7Ditee@v9H)R&z5zM%Cl
z0_)}{z7WFlRjji=y3K~wh;;d*exKptYk!fi7H+UxEu`>B>1tu(Y90^k1ABvbSe6nG
z8^De2U}j=g6d+s~1Ci;(!0<m{(#TIbLM;hDDUtl7J$SMCNj)U^Np7WQI@uFvQ7^oO
z$GKl8`U}-i&Tl%gre_e!q2rJl_QxStZZR>B0I``c0Qg-3(0X5PaAY$B#IR7|TWEt0
zOwqpdjo`mHumyK<B%F7WlL&CZ>Z70#Al7MieF5w;KMuLL1f6?0{>A8IPSyStdgBM5
zW|P6~jIdQ~O;IOU;Fb5ODSEjchXR+B{t~`EO0U_1H&Ez*kl+bpit`W&gI`$^>vyTx
zky`z|s#K$p8O}i&s7`t|Z4?5S^ER7U-CANJ!MI5Ydevx3;|pJ7Orh$dp7g(<?r0TT
zR7(uX+BOP91YcvMW~FrcU$6vVxMRFk$C5jywCEIxY7_fOdEQSy^FTjU+_BD>>wI(&
zvh|k$es~ZvoPc5AfqP?vY+LQU3F=84+D<~Y+W~<6NyugdC_M>T1M5;&?H}+!$Q}EK
z)*P=WYmQaxaOS+CON>Z4^nV<L?AUU1ZJxBNc}ddhuOS{f1DUTREh$Z!MM<_ZkYx0&
z+7a7LtYMHCs<}D3c)2kvNc0qZzs9n9kXWx_og46{ngZ8$mM?=uT@Cx2xMO4ka`}IT
zBaMYs1P2z;bEB43t}S}G{Y0&<oP2yj`I`KqW=(60H3!bXW|l%{&H*dMSxL<_h?10Z
zj#H6j)s8Pk;QHK#5H4{qt9xk@&s&d@=JTX@7_h^&MPK3iMofKci+!s4)=^w9>_9@P
zTVT#o>OieGt#V{z>WGo<RW{Nb!tQWmYoPGMjgLN694l9<!{3phVRyKZTkbz2*bE$l
z6h7TxVtdEW53e1)0Zsei@y6w=;X;)hZ|sAhz=~k8M%(P=if4tLPhc#{!ev&XsdT(i
z(bVjDXg%BU#v{O0@#Br;y;-$`=9w1N75)0$pTR3ZO1}~b1%9>A)jmAk_|I0whvJ=_
z%k)*_Vl=zcjiV77E{T58xLvT-Lpj};6TwAkZzk@1Yv*erYzE|?)Vx;*$H18?Io+tI
zq+^gF9ayMQhny|VZj*AlQ5P=Oam#_RKimhr+dL9qG-S7M@mx7`(Aw{zqoEPvR-ph>
zh2JB@)`EVRiq&Z-1`A;q9a-mwVz_X2nxiGBp{PeVW^>t*o*{5@D-t$$bC!vz8;NZL
zvk3z_qugDB_5NLuJ^2Dz6)~i^I@Wv_>A*%b5?czJ;m2%mB)*S7ha;+m!^kgdwlt9J
zs7uam{O)OlAGm5){*83dTff(5|6AT=)@<rFW^L{p!1^~@qE}tB-e;;PF_v9yE{^u>
z8I7V07%BGXl+3#$BOD61sM&(%VjOD`C5|rtJQ*lEuqmt<BD{@Lvsz8Xu0r^F70YTW
z20NOguFMeFrlw*W;SPrV7fr<=Vc#;ih0Vmq+Uan+3Zsce1BJ%?*QnCqW|))c)~VS1
zW*A#4BiHxM#KS`82sJY|7k8C^gQFETvfG5!xLn~~wAicqq%Ta$F(SS{mG7%bhifz{
zM)cOSdx2ub7zno~irpR~h6;Y4VZs<Ay15QsM-~=a(5dOaS*2o{Sg{t^?vg36&{(mf
z&~-6FaexVtC~j@6*xvOXQ?fLrEaF);v&M=I!{)-7fjpDzl-RoIz~d|Nhx(v;Hoh<b
zPQozVs|C0@m1|;s`>b~pR()q;i&}^QS>Jt*UexsPG~n9~x9=cGZG6*${^JaWa&G;%
z<#=;F3<ewyk&58#B_MQv4i=G;^2R&qasJCWDbL`_*OE>y`baoC0BRlaS28;AN)*74
zMHI5ead6+)z#W<zCuX1(F~f@!I|z#xnpj-C*rNXmNDFRgaxP-%AkGKqM3hvdvx7cK
zvUYG7SB0c%0+LnxH#FC_L0}pH1z+`mP1&W|ic5-G1)7RkDC%O>#;rpyh!^W=&&X6k
z?(rT7<e9R}DyB;iV;eR&MY{$5a+$dad=n9F;Jr?&>3&mpluv&}Lva`WTF&eaY{O3M
z87KtECbl~Px^;Oeyn+O=R(zvlCWmPUlsseU%7lWmI%T3&O-p_M?Hc=uR=TLqeT{zi
z=y9Y2KI?fL_W{MX6oVswwWh(-!@1yOb6B|<5nw6oD-QB)_y~Q=>^lW-dUKR3e{=T0
zKlVwY7!>~ZUy%+en6&vIJq4i-SQ>ryiHUX_yGtE2e!%)kOR-*LT|07JrgL&H-xCME
zStt+WPU8*adh$2t0r<zsg|)De8-jF@TTSNVe~}YeN@kL~&s+>~LHoDRZ%&@QENIV#
z7_rdZdlIG9nn1sQ<&?!>4g4ni)sKT->hsET|F4`i=;An&gWV-m+%v}AUv!sr!HH!m
zb|W>Xu4){+eSCn2a1nN5ek;*4FsB-|#z^>}_5y)VU7Ry;oFn_b75eCX(Zv34CD!pg
zAd*-9s-QBmmS#eeg|`;{%9+FFj>UZQgh6btMvkiO#acedP$KycIb^q5i;_@bGA>_g
zBQ|#moKJPyp<~;+i{9)?8?jo2#~A+f(~s-1asOJnTgSo>%o@4&^7C&6m2ho>5_K@|
zr)7+Svr}-=f$(`JD)=``&DnkCLN%q{UCK1cI;E|+LzpyC&C2P;=7MZCu|&PtutIM$
zry8!|R5gW5GSzIMUaTF}cQTzs+3%nMsUUiuew=RprD4sGsgU}l3Xy7xX`5Bs5WkSk
z6FsQ>JYLP#CxOcIJWR5aK;<x+9tAi!*{Hmks%BB`#L&3?6FHTOI1gEnMbCt!P}zzK
zll(VUCMx;xHW91DZ)vqk+rnogwM9Fzop5pv9LLsTP2W{>{=e2pX^+<UVk~acX%9Yk
z!iv^P2A^5EoX^?V?#bI=A1bc20d3kZ_;P${8<+^t4FIsr2SNxY59q{lc12=&1jdt6
zW~mL1BttqCaDB`84xk!1+r)Ns0M*B{IMuD?Y|;stq-Ktvpbh>W%cV1oe3M=DJpK4q
zJX0Iohp>p$O(!CC8sh|(((wzK^!Wr-hK$0-k&d7;^K;CsI)X|^n12$lvyIA}32L^k
zBif+-7*6FPmWm5p=$VidD)AE(Dox81m6|ZqR;>?yOREKXt|_3mcchw~OaZ+gXPTJM
z3G`OX<n&g0+35W;PR-Iff!>$c1p&><K%BIoH$6{3z7o$=D{-7cZ?+@R8x0F?)egsR
z8G0#4lBoZ^9fUSd{YFeyXDdx!XIl3EYV!D!em)bE?(W``gVkLJDJEj&d^pmbMNh9Z
z4bhClbg7gYH!jRZ@LW0wx_1%V3*%-e6n#?Qj{bL-k9S}zyKp<<L)lJr5!(u9rYqT8
z*G?~!O=MfYGkL0!`stgL8linC^|-RfBaJ@jkdT&;%IzCgSr$U5dHWsspx6X#Y%_^E
z>;ufdpq_>mjx_O0;V7my%P;1Ks^JBmyO<wI{}&iU51+a429xu~;Bfa89PYM`jq6}e
zrxC}eKNxIuDZjls)5NA<%CF&_$r1HHOd-VPHpC_UfVlfoep^Dc0+IfEU(VOj|Jcj<
zfx>4d2R3S-=;w9}PdK@I3*#sair@D|v})ny{4h0~rcu2_cXs`9euzIIL5HRHtF7o|
zMGdH{6<4k{%0%UYgKEJWEpnoC7o{umvHUzvc0q~Y>0`<=1U@BdDEMR6=-E}&hmW1g
zb&trCT6MrD0f^A9cdN1Vw0|~%kKT8*okMCn)wJlx{J;j3CvV3QO3ZmVF0W_>22>1R
zTn9dEhadYuR8?EJ3%^Z)CsrXkfQ20u%L`|Rs##DsF;n=tA5363gr#0jh9}=mTq;Bi
zgA>>t!J2x2Z0e5a_sdCeAiJYsVlXp9!{{LIVEcwS*OL^k2Pqs-7aS73e7a(^1Zp3k
z4kpxCThk;FD(fL83C|~**v0eHy@cy{u=WtW&{dB0K&oF)%qK<xxT#-jFP7C)EGKlt
z+rGnaBg63U>tT$3<?(Q_r|4hp9tLDIAUUYifRDO6GF2~N?wo-7tnA_~EW$%VFELC=
z#{-%)R;Z1KZM_gceK+1tCN2*L@|L1;s-OifimKXMbaPoeoC7x!@IZexmxJ(dt%-H$
zEv5+#QNX(1qRwm3E8bwY$~M?P<4nx;m{`mI3S0p+84p6_ymZN#g44J~^Q~F|rjG3G
zw5SneDVBCc^#=rHq&1612D|=hcbP7^5Bls=u2!ve7!@ig;U;JgrmW~^32Rfm1%^@c
zNgvT)^8#Iz1@w(`tI-SNC#lx^7pq}C3Sje!3uRk>OGsCbH8E9>7&lh$W<tDn4B=V}
zLO8BF$Az76?I%VE{|<L#t@=Tn{m1Ye?re5H(JSuD;Rq+@{#kTCDX$!6Zez9jAx~)b
z$yJv#SJhT%-{-_Ydzipd^ChxdV>A6KUIPkT$_XZcIrWElCyYjL{i@`_CXCChuK9fw
z`sRXhnf|)K(Zt__g0au2s9vybrA2Y?QFkKBvtn&*%T3M;yN5!a_7`KStsiACQ;ruu
z05$R+<;cbkK#d|t*=n?B0BW>9<Kr69;96Rv+Zl?OBAyZ(-Vk*u8@NDo#rOzy1`KIX
zoKMwp9Q9SfcYm+8-QwvwJd@5k-bfQztKpeO;pdU)sNx8BwtaY}zw?@r)V48!1y7%>
zwz5y}tZGmNTk=bM!0h6&p^I&7K<7T3PGbYmF*X3Vloe%cc#<yG^-D~HHs=nf<G0!q
z`EaOnZ$l>#tF>x9F&s7-BnDJlP!@g<gVxYN=xBY)!gm7xCBYk%g=YhPj^OVXlqtV6
z;O_{2zAQWd@cM%RUs@La1iIXt;KRzo4+Aa|ym?vpJiw0vo>ieNyeG7S!gzGoMv}Qz
zU`3jUVX7D!SS*O^Vi`t5Z5i&PFH;6S(JYf;L)i@fqTz|cE}o%wtH8=1kr-b#$61V^
zIYYo}>$31KcuC`oM7GLDg?N@l9<CsVBxRq#KEnZJ>-6XRGIfdvZtih@HLhogS?PJa
zr@fM3ewG)94Xg0Yr~|9J;-a)z{Yjc<X%nuc6<=Q43zG+B$S3rmk;BQ5OheV7ub3#-
zFSaW1x8i@#-=RtR5f@i2xRtLJOarlh?N)xKX3Ldg(4he)_SLQYS?a+iOT*jwAu3JI
z8O-7O+{yRUo`Y@7b4WPV#tF6;OgQKKj3o1&{6>|p3<8fBE+c2bBAmaI?;&g*gdwW`
z3^xyaChEg{1*eg(>fL;Q*8#{!HgIPF^}=`uOZ?q@UsY8PR4L&gK4VM9C!MfA{Ud)+
zy{u#cBLGF<KTbgqSSPxUS6VN+Mc|wx<7Qj6ZD*Pm-OCRgmH|6SF{@x`8m79_UsD&R
zTPQRx*?Un3TnqLa0{kw!Pn$bgv)`y)vS$K{yTB|Q`UIEnVfI0bm3%{UUhE3K96&d`
zIv?QVlX1Q6saAoW3$cGSKSa3kV;XyZKfii|{GTul&c!_s^eJY1bB-=(Fh?!5K?f&8
zoysRe?K5y4?)sn7nCgE1=q_f*xL0-@P5{^7Fnezq4tr8v@?v{(C^!toWQ90PQsAut
zSC&(q{h=xB<o*08;fpIawo;%qAG6iX1})3hfNPwsCT#M9{Az+8Ma+MYpHw{=Emq{8
zb7rhJl(E4ca<e;O7W?Qye&ej`7J99Q#-rYsjt!_q-xX_LsT+h(QPHrQl>0+c?vF{i
zFKPHRho!!ts<*b?5%L=v6Lmj@0_|Fdt}j8|S8*un9zR>D`xXW6l8Xde<^8@x<+m5)
z2Z!vtM0HLM)F-1A5b<z6V*{XVl5vGJlF&BJ!>*<=O<{hla2K7TRbjrlO<q~z_c#&f
zfeLZl@vP7N0h=|T+Zgz$1<om4v?^u7`z)C7c$gpQ-tOWDOmw}N#(F)>ukMratCBL9
zZVf(7MJVU#ojZad@nL>_Ast=v=)?RK!fABU{zdss>O4#%y&juLI*bZyzd{c=gu@UH
zMOF7=3QVAh)M<_u<u{0r*-4Gk2JR>|%IElMSfTzMZ4Gv8xr;(ns0S|SsEu@`9yy1R
zTDSp?XWJ_t{%8JY!l3?OV)7g>%b7p(2dLb74@P)+B1qXn(XU3DEb))><J7`mO|bI&
zBtKlp??t;D^T!B(_A*)O{hi-QC3to;S+btyt5llYePD0qv;2rCv*SAKO(oMBPgg+c
z!B-$|(IEgDD=OW&0ji_i3P^WGV?$PlNE3VbEPtZ#20RUXo}VYIO*64)&+{7!9<5C*
z_(i@?-Nge-Hl;Kz@NVdcZ#i4F*)|}ej)S3qR_!lcO>D%A{MN#qRPg#DKhEd%RT{1D
z3?PyHieG!{X>om-e@G=%k1(-IukwQ`yu3oVxB8hZ)>ruxG{X2ECN}A9el0;Cisg&9
z`N3X6KM;mXFZ*(ovHup5;cMK<cC<LZ%lF3dCCAaTX~P4qpFqFrAyBQgamSz=Fd&{*
z?Vp`VwY8s}PXlL%+wqsv=P(8!umZ?tKzPZPjQ9DGD$U#7knaX-{)(EP$B?d!>!i1y
zAGfSS-g*Z(Ot?gSY}2IN2bjT~%5q#dSc>-#-%QrDy_5b_qAS-VuT!{LhE&P99+DQG
zlKcWng~7jtq0B6wCFQ;+@3)}q_wQLbl{8Izzc#i!sNN>$_D59nl|J`o!HFN<voBTB
zP8VOE^dLERic>;fn{ehTNcrrETB<4x3o<c{AZ-!$1|m=@NcBFtl>CVx`3ob?zPD7<
zNGX~RFEY<?l4_{R*)&$HAngdN>ql(Bm70Qk(GhEORX)>a8!34(_49S%#lh5!ic)B3
z%3+c>cgB2+zKNu;rY}IavUmF`8g-+N0tktScw?t4N<opI;wdGeOG4+NaNr!*_m7}A
z>~Ts*15H0ciy(G`yNx?tB`K=0@ep<URJ1m%QZQQflY<I?8>FTn;>!Waf$@5!TR0~l
zOk;VKq&h-NJjCBHxi?w4k+aiiKk=9x=(&$Z%!ECNh@otB>PqOPV1p*Dc76atZI7be
zeVRhYgS>mt@4Y5vH5B80%{X@-G?q0eyB7U+X!s$<#e0k0lN(c-(2st@!al(00=u3L
zU0&;pgmisD%;DA6X%k%?#;UvH&Je65+{F54!OPz3toTAe_v0edZ4?6owtA!E=C$$U
zb0~MxpX^hfXgw#io;4`n8$Eub=wBxTXyk7kIYd3|>kjs`i+%C|0k*ho?O0n}_AUAX
zc^k>dRjSPJi?%vTbZGaqpTHhCOQ}NF7@O<gxr*fPTnpK_>p%J+T>s1}QhiN0JdxsP
z?m2(V5qSi0e6$j!@$D3CKd~t##k=UDuex{$J)!24U8I`A#d<InE>d-GOFf0T1_!80
zUhPq(;<1y7=ktApjh-eJ@I2aEn1hG7=h0d}XMOf@S3Z>+?5Sklv!61rhBZK~Y{91(
zKk)ZQC&U8oHB<NtKGN)e@mCt|(sYF@_tsVN6DA|usBtDY7G70ybxlQH65`r@ipy3^
zCe#;Xc#P|6Q-zGrR_IuX{@ZCFpXqHq8RK3F2*+);WF1pS)UMQ#AWBDBl-R*jjiM;B
zRoRt_vL!IFn&j?nGCJ~|Rc`nsoKw=UR}*b9nd=yU4p#%)7ChXlCizr<vWG$eWsq`^
z=D%L@(hh;@Q*HJFr&QkYZc?qV2rXAdS9?_?L!zjn8&YjAQ0L>U>iX4g;eWd;YMFr2
zur;}@y;_Q;9#9Ip2F^1>nRy^+b7Q-p2dm~T?GsK%*<wGc+P2uwzm06MpObjtv7gHQ
z!TNv1ewKPtLs0CeHBfo%r*0#T`cdr1i%@y&=L7~-9{bsd2V3kX-vg;U_LBf$Y3#=z
zZ#?$%uAwdV^AjF;>}MD3gk9|CP<31EXC@GM>?a)$JoeKV4?Ons65}b4{hY@`Nj!`_
z^_29&zTSuqdP!-58fgo?B%N22?f(_lITLOR>#PZ<uKICU=Sn<{j}9#US<FDeAJ{yy
z65XRieCr0J0M>#U+o;Jj94{WW<%!E~7ntR{U&6%Zxu1n0GcCnq|3>rms`q4FgSJ+q
zGH1fL;vkBvw-g!F49Y|so$4p$qO52bfduX!@gLq#e`sl9gS{pHtP)*=E<DL2O8d=J
zeC0WM)g^p|CHoX+4KaZjbG(<(K;-!L8yX*O@5A{<#kdc1F*#sHSc+IfL40OI#5Otw
zvE_$|*T0C&q9PvxvnbB4gzvuKq_*2ia4#-FRa}C`#?uc9Vuei#Pgq1(NL{b;0Z)S!
z#6CpHXh&&Srjjt*MvBkrXvkt8me5;4%%T#i+m+B+fp4%CfVB;U1p_aj)a1erKJk&T
zPzuE2h0^Lin2Tefl!JWVET&P^cM6qcj=IU;oMRb=cv>jUs){GRP>S>vd`L2d_xu07
zP+Ho}G10lsCpz!p8@%I(25i%tgWwj^o39XZvzy+mpgQEmB3=V1rZ*4a^Ud_a%woQh
zFboNL{(TYWA>fiZ`AL2?K3z&}FgH*Mx8mkDng^PlCoF}J;3qW^HbdDb`$?hIUhYeC
zNN}k-j{>JIuFkLarLjGJQjpNQI?SY>G*S2i!^*|aKJjMb{iU&P+xK$x99l4Z<}%U|
z@9dqw6f2Cbj6SK81_?SmY|z0USzaC<u@2r@YJK?OI%!<LR+Y$f9^Avd?A{nK@Ivu+
zeV%VpRd@?m@V=1}>0u?u+N<MOi}_0+^22c<>6MHhxM|EBy9RMId{)R{VrK)SsWsMr
zMV(f}*zi%PqfbrgS51EjVv4UNg=+YalTk}*EYxm?2uCgHgkTj+mW)8@k*bf`F_k85
z%CUV?l5m$<{m{|SL^mc;V_Y=1vu6K;_&^MxXrf&liYAKTo;bcK05_cGfT2qILZsVT
z>d7pyaHzJ_$bGd$EtMSDlqRC_XrpaX8XFleRTqvdPGkOcq^838I@r-uM_P?gz-~;=
zN-h#egi8lz&Q2(!FF}BUnYA1WX4dGH>9AIT&jsAZ#Gq_2(J@#G3<=1$F`>^(hTjQx
zh?9CYDCWq+`5d`<ei~aAEXDS02Pd#_B&{5p9WP)esjwut%&LTmBv^Vgz6?uW5N2NN
zj~oh?_G1Vnx%`GZqyawwxQ!)o23TrRR|;&|Y{3U|(c1tDH%ZywRR)V)Y(SGfZ*Jgg
z-rJRld$$E(wXW1wh{qJ-L0u`P=8#rA?344n4!q&K5uQnThpt15VLV)OA7L#Lu2<_2
zX|)ig$3!wjiVyfD5V}V$DGX3KSarP_pRh9H0yG|n-Pys!+Sij}12yo__@|sOURbru
zG1T!LQKM^9Fa!6vIv#&(WSi<qO-+y$_G*>N3g1*FQ9D6k3lUMb>+^%K*&Bix$)OO~
zZtzY5yUvd~#Tt41od=w%?7;LtCR7S+(P-WW0!y?3N}8{;4e*h$y3R{u%R{AJLdL&F
zW(}2UI+`69Y&EgkVN#t~1o!P(Gb(D-i9^BK;6#PBwhFu%;I_8h`5D@BP8e9bKlcOH
zUf2L7tZB>&#z(AGGN-XW!=z->pRfdlnWRVv)X{Xz<T7hDULm}$STL{?-b_W?uu1?Z
zIPBL_;c%=1_Xga?;XhNsp;#Xr-pVV>q4qHcq*8oH(f#)}jE^{UoSVj;)|Wa8cl{9}
zY9K`j8yv9Lyn)oLLSzQnr5q^Kz6S7HeraH0j^WZpA<o}qxgIWgsf8&ojO=+ssijcG
z2WO2Vr9#{YWnw{%q`!n2S`*VoNi{W>Cq_D0qNAj-Dq)}(cGWeOE?02C9L}oU9&cji
zCNNr3kjawTRPtA8rcwu*&`g>uoKc%B<(f<JDq(p|6HAJg`U@HGZ?{BCSA<`@O_rP(
zDNrRu>)^x1N_x#rw3g*{tTaod8HhPD+ZrpmGZrU>_jx=e(xGqzl(hq*LT1OC%Zhba
z<udDmGGxu@Q>F#ZC?iu34n+%m5C4nQcdr6(1-PvRmVOF$>%_wjHk(|w1)TMhZFX=%
zRvMcf4?8%Zipg?3UOJ){hWu%?e4Z#}s@!H*MaU@_<=R3{I!MT)wbVy=@xo}C+*<lo
zEzG-RWL@<bqpm$QvM=c2kjlh<)=Ra8g?LaWNz2^+s$9019CrvhN%~%R{KUwnwUYv}
zo>`3!35Q|G9STq3<JTB<ywa!*vN6L&-E#Wivv`HG|KKSTc*+o@Q25R^3goQASAz@x
zR4~3vrMzuzd3)bM%3kH{zQj{#-b|&ozl)U1NP)47ZN`gr3&W|e_EMPdn3`BD_%3&5
zAhxa{m_zX}{-y9d$A5k`vhnSu#+bZjHgaU!+Dq4kXO1Q|H(6@tH7Fch?Nm_BGQU(N
z*{rSF$kB2$S&CB$>ER9*-6zr+l@M7A=VLoc-fjJRlP{z-WFWFM3KGB~nu?UbcE3Bq
zQ;2;#c5JGIst~4#y}7kM<?tDXMn$M995=_HQ+$#lg=W?2PK7x?8&95><JzHwks26&
zNXrX8_nXn7@H8r<H!Bs>qk_CzX2*gkB7mDj;aP&lJB3EOaa4j*A$-}{frO6h%*eD;
zRzyC*+veh|PJ?;geoEd3BW-zsWz`1!cizz@d3n~ZO4iC{vfhVw*e>Jb)wo$;WPLkH
zHQF34Kz%4k?6SL6V8m=LsaWT3Tm<jHIYcmiNLdl={?+J!)q`-<0IWNE_dpjp+DX!8
zo$AW7F(q4{53*$-ThU0!<vKDz_MV@jwbpQMg1}u-D&LyP$F82Js2znP)FR}9(4s}W
zH?p8b5ps<^ZQ=xLD+Jx@3@&E09xv8<!^j4AmU;>sP}|d;rOyNgpHJTfUG>igMwZ=0
zsxL?wQFeBb0;;ep8hl)W`*Cl}VHZ~yshu$BrICfFO7(<hc<7Z1U(o{((^91b;R+1n
ziBzesumKNGQl;j?b|`RIniN*O`3oc1{k>q$c>8#bB_mBLPz5$ZRZAyU7s^2!5a;yd
zZG+$vmh!>SRHGE*c5ZZ<gG*i9IElKzm37`UI?eLEQCg=G*1j}a#&ngQsDujVjV!%8
zh_8KSWNW&^bg#n0_#RT0kOlMnx`(t~I15v;xu<krQ2l9Si+V{>!kHo?yU>e9(Xf5z
z)$BztDb}sqD=3JaoqGD-$XfT7jKW0-aYb*bW%(Tsp(#%t7PXq~&ffNxYHJ>JK*QJW
zBbkKi4~=YkABg99A=v06g$SqcaIp_WKL`)ueWk!^1=rEW_*72p1avH1rTPw>_eJ^s
z{}|bkzLK{v<S!$;*;i^M?0aowLH(pqArZ}%+D~d*^`8fdM3aV);~a_fP5q=AAr}Y?
zhbN<8_^)&l8rRSlG_;V@f={4x)aR%bU!Z%^PpY5_mY&)RKkN;%W1%f)23oze0eU?$
zS^@@0T9wcXgqjVM=C~alpfm-|Qm83b4M=0x21*k(``cnr>YOg6tArk4cK;x$y+&vQ
zu~Zx^^>Pb*RNU#%eNpEFP?afzrAw{{TSYo3_eUT`?p?uT=`lnSRD$y%BkMO54Yc_W
zBU>_5x*%-A!?0mew#K_93Vk|E`c-Ii*T^mnm)f~MipQSXoM>{=AOjSnhXOVjA^B+1
zlYrcDgcL6PhK4E1kXo}-Bc#j1mAyu`^i!#p?mPr%-`E2mE0UN=m!0TykFmb37J0Cj
zpGwg}{~Jb2qmke)#O%0ZAEXSMMFC>WIiHGTL-Cy?GG(yT(|9GX?S^H^kY)*E(ZxVp
z6uf>mvdmGa*6r&?mNiE5_C5|>NW!HBN|4Gq31M!&=ep>qk^MOeafXP~P?lJGgXK?<
zdN3RJjif#W*YN5CZCWvqUL*drDc3EYy5t#}y;9*7FvNFIVLLP)3o7l>U_Nivj)Bdy
zhd<k?K}ZU_k@<%-aJi%!Z8>+eq^lBq6gscsMj;5WeWNiGTl<rdJsXV}XakI5o?~E4
zS^?5!jMTRA8*ues^{RQq$isCFO{Bj*kiJ!09luJ%kX;-jHSvr(L&{7ZJa(7!!2!nL
zmIeX8u`p8&ZW>w2SSb*WZ;K&Vuo)|P`@FtwbfC*xioN>>R;{^^H{@86EqFXoo3&vF
z(ZxlTKq_5yRu0%<(78x~_TpRLz6TC`)wP%{*!ik-eI6YBOb&&obnssz_mq|?@N~d!
zo{~O>j5Kbiq!jEb$7F}K8YgLeqFci%!+K-6!1fh8ykI<bZrM7GHOry7ITU2qI4L;G
zf_BS2PHW%wP%rEozZMN0uRD{Ud&8^6_Bzc*V<rCcXS3r{Ebx}p<r?INx?Bt?Q<o(q
z)x6lRITUrtMgJ$Sk3tK8=Z83#RAvGQv2EwS@??L^k^E~uPoyf$4dj?5wU`^Ym2#S$
zUnHinP7@^`;n62)?DlwAE)QtB>jWtxt9$b@6^OCDa;709ssPGxC<;OCjAe0~{s%7Q
zqg?~s!@z$%XTZ^!7H*0gvMq^jw`0}1sC?7XJpy$BMlFkiNhYZMo7YP1y%hKrz-=u#
z8Xg#XJwa+xb70H=x8CV3ZT0TmA&q5_0Q7*&pD4Ae-ii8WZLGJ~L?5k;vaun=YGj2I
z5xTj6o>X;`)ZWA4kdYRIC)@4KNJpjFm`PI2h$hfoecnz*cWJNNb=1A^K7OoP3HGYY
zmX0n>k?rIpX`oQ|fRWXoEO}_Mn*o$GS*j)U*=}SbCrdRO3KywJ<tkYo9<M^3?FcWj
z?R)CFnm`W6Hz?7W*21+uK3VE4{B#l>eTozyNEoYPrbs=60~d_!%PFYK0I2TqDN+X^
zbf=NIO$D`bJB^lRQ>CFQq1hcHTmKnG#h;Sjv(ukpWb5<D$Xqg|I;P!i({L^078U9E
zF+7uw_o2z6tK%BmYYNQ<VQe$_e>o7}h(iO#PNkf$a5f95vu&t!lnbvz+NQC2nUYWK
zmV|Q<IMnBzpdv_YW5Ye7;MM`|Md1255bhMEyvoHmq(QEZf3-=oRLqjjYPu|53p4oR
zOKdjO4!lRA?~wZ_;Z$oXn)E-SekAN^2iK%itv#`)8qckD9dZZauqDsZkY}-LWM|;x
zqhON1_Wd6pG~~T7By~rUa27+~XEP-)1eJWc7OOWRI8m6#L%j$4l<C{QkaY55TXHD0
zy8;FT>f7a&S$_!NHtjAX3WYPJM#6-sG^WczAZt;)Vu-T7g$*w3jiPXN=q@-5&VE-p
z=>Td(f74uY&LS!2hRe+9G)$TuT}*a-eM^Gf?f7qvGJF-#R3I<*Du;rvw{W6}FWTV_
z_(8yJe6g@dl>>X31IC6nvN4t$r!ZD!6-K|p>nIDM7HHLi&n17zMQyaB{|iz<KeH_T
z!3up-G5yCFAc+1Z1s-2Ye@-am!pZlHw2`0M!e*f5Q${Aul9I~@Z2}*EXjnk5<O>G2
zV8T}tE;<dNfPrD2Wd!gwi7GF)HHSg~OELBm14|Tm7~nPmR0#nChS>=ImT!nXB(q^o
zbg^k{3q4c-<iczzS*VDv=$k7AfcRKUL`#U{W-cOr-J=Zg7i1puVz+ZBi1)>qOT_Of
z@FjrTh@0zz_<~#zKNoHzelOZa`~o0Eyxb2bQ2TOBmn->!ezPui^s7=Y+wGWEy$pTa
zj!5(ya46{4zOT@~tH3<~x6$t$TugsK0~`IXo7?D1fDrwr@^R3oJKkVd6JQGlXvwZF
zQdB+18J=KK2)?;Jb0f4B$@knTc>=ut(|J;WW@v4Y_$yE9Ug1xk@CdVjPIDzc%`!^Z
zG*{9wX|ANz46wb1WYyn5?gMVyesP`*=YhaIDA=m~eVy{A2PanTCEHs8PiwymEN1?x
zL>b(Oen1hgvvTFKtQ>zf^OW+o6f>@<Dcp-4>)^Q_Px*`Yk_eZaOK*^rsay%TmnU6O
zI#AA2gk}pLDk(;uvKPMY=Vs{0F$@7$&FDvYc&I!N!*LHhM9+f(9tWHm^Q3XYvi(N(
zW}bARb_`4#RgGMGtG2%FZ7Z+Lle3iOdwaE!J(@51S8ltV<N+hNd#RCmiJ1I#-iKL|
zDAj2+n_SAW!^gc}6sK=sG&y}8QC8{lj<TI*r6~0lK7-GzULe)<82lXtaA>AbIzN1S
z4va6rsB#TheHTcBJkRanJQVmex1U^Mx#-pcsh?AGay0WshO>ZtM8|sNOO-upLTNuN
zcK7#~ujSLw_yaFCn%&8l8n|Rzl(Mfhr8RN~rjw*$L4RYArq#g)`rLQ8f$-SJrOi5P
zWLqVaHfaejtvPd*rKX<AyOq+GHu-?lJ~E2kcF?}q9q_Y1WU}oUTd`F)*@{hBh+->4
z!)WERN8=BQUAYhfn0&w{fZGcp0KY{LKtIUj!?It(pm71r{@Nyh)r%m2<J@1i7Pv(z
z0=TsZgZ>pX_NYN4JcWrnjLe@&VIF#*b;!#M?hu{nIj&-oITMqwnNX6@#gaG6WRlib
zMb1n1aTCo%mu*mi;a3H%8&RRH;1+LXQgG@4k(4V@nF2-Xafg{zyAd#a?Kv;eiN1tg
z5kM!a_8UZ;0Mc>KgkU;srTX$?4!*p~IS6e!6^TVanu@lfX-+Yb(tQ^-K!;cw8cC{|
z3Ov5hBrXPDzs|QKM|`2A(|~=%SKewnL>phfFZr0SN~djnEkz>nwG@r5@TJs=_|oxp
z=H{S7e9dV{e2oR3vH<pl)UW2(P<%S9i!BIS(8vh~N_q<Kl8Gk}sQyA~)il+YN0;6;
zKy)dLcjJdpM7p#98~uNxg)X$o{0MvHQCcN~Q$ZIfrn3J(s2ne*;-gThUrGgfX`|8>
ztZ^#g|BDJZDyFjUKd2llrsAzo2`i<tvxJI;TnMU5ga1VZ92Ha9`yW(bQWS~RP^g5K
zQX%zKB*w5r$f?x-UsS+RF%>k?N9}T?n2MJ|rCuo&m{S{-I>l7NKB8jDST3p6pW55b
zcw~Ep0ECZ6q{BX6YU7|<W_$B0>T{oBX;q&$(MgXFds>6wz}Q(|I+a{Dee4J6?AA)D
zo})Q-OZh<Nx=M=B3_g!JQR`Jwoh;Hw+Wnx%_J`ccwACS@I^TcrLoiL2ZtpAE6tFzk
zh^-EU{~@{5pUSdRyy<N0Y{0SUta8YIZ8|%7cCA(KsO&m>vP$Ada_3&frkT}J7q765
z#?nP+yG={jN1&j-%>(LMLS2Soy<~m54C=)<(NyYiLT$80O7*P#KTw$s^Vd1RJVBUK
z*Z+5+Oq|J&BqbAO>RKtq=LsB!|02)3dVJ;hx|L?5Nt3MS3;z98#oRaHWX;HRMrG?u
z_f2AT;Y)zWZW3#y`JyBm3P#i>b73TPS56Sn8A6h&J})cWs$KsTjS11oxv%xFu4g2W
zHn%^a`OjTg->)?)yRg2-1K)*pH|V2XSQC*(yRbZaz*``5wFx+-`bk^Z*2C%W1X|X5
zOfTX-H?ps`PxlrA@Q`vd-{0GsqhxeJMtqwKy{%+p4STX)3UbO?gRYS`rYZZh;X+^5
ze1lX;=(xtn^c$og1Z`t;)NJ$yshe;bgAPCI)3I|-dG>IF<mJ48TV)*hxm63h{#-Xo
zp@A!TKZC-zMQ@nks;6B*J24e5!*ZXE61MinHgpJN=8aOI=Jj_rg;(|<+}a3ozpOV}
zV!x8Qs>=0(X)fBsQYOhho{a*i5`J6l3#7KRT>M(9tI~9Sg}ct)eS?tsOVl7?lN6#&
zz%+~GHp!oI_WzdJ&A~ElljNh)Y<U6n3|;%?LO+Zfn|1AV0upzBOGVXuUR+eU`L?1i
z<tara`A|`j-zY_G-6CC3Y0m!*^cmZvJYnQ_2*+%fLaJ}~BDAIGEB2MQq-;mHS9AX{
z@T(k#n>cbjT#p@+pE_N%T--ry^?p>$R_D#7Y_XJG(j=k%5~JnZE-6$cj2&fU|Lz9p
zb%v2mut-fb%ZiY1y9MigbEX@ac8`=$VUZj0Fm1Kb(tD3oU8T8JSWLDF;=jdYZ|#-3
zt2C|!NQ>Jq4Hkmd8`;<UrI5;=u9RK90#y(#xAsc|Rhn}5ft7Sn$`HoLMt0z!6jGsF
z6~cP5)M$BpQ1Vu368^9esoxKyaB}Xg!lQhv{76;0%TGt1xg2=yvRl)va2%%irIH~Z
zaN1#Mjxc(JkvShhCF;yEvWz3rwTh)kmXxDXp(-k`BE@0XLHjTmm}8U6)9WJsT8f))
zx0_I({b#Uc!g1-LkTvQ_L(EsS9Rv&wo_xrzkq!OF-Zdp5ximq=6SUh2f-!^C2#(Hl
zawv|Xh_iqv=l+nKd(x^+2Na+N8Zyh+B4Oa~u}$!9)h0m-NNh<jb+s`_O3pnEz-SZz
zY+gWZKudY&=4slf&)qHVr={6~u*aIpR(y}{ZLy|W_IxiztK$maraByo23KJHPGLib
zBHAJSCjs>e(CHz7ZU8<eU`quU4ImEQPBpTI7o<+Yg2|Z1T#$mI3cHdGusMjOzT0Jh
zsq@r)w+by>d9FQ=q!AaS7pmb~-k|)tO8MVCuyL}TfaDT^y`Kq4oa`cCxB~neKt#tU
zp>I>9{VbA-ya*W&R&5bEr<COmUXyc=aG_qCfR1=c@(-^(^gp@n*^jt|iGD-e8Zjc;
zOti9Z`j&yFP5*1(^f7~x@0<2n2{ba>PyV4&exXsa<a`)&y(~ovlX@U3av%zul4crN
z@5_>>=Qxhry9_Qldi;uwS|eu?yCqj_IP@^u?=@E(!i$%sZpC}^!>>qPg-WRG+$&N{
z@bhjEg-dCEZ6c{<UZV1GPx6KJ_^NPcEDT=3vWEp`Kln!}Meu=HnewAlFQi3hpl2V4
z8}WO=K12?vJsZBFy7_$0*9P!gyf*No<X3V1c;K7E+ICm7*FQ=Iq0Kl<-LGPQ*p{&x
z2R8kxq>FntmIVEvAn_#?6NUk%R7B{<<P9OzTA5EG$RS!t3}-o6gZ7O>)kVI$dl@)R
z_zFjzv+(f#aGbwaPcTZ%ZGJ(eG6=1>`BJV)HPm<3v*FjU%%n5HaJ3xo-eJfz8r$)K
z&EwdZL>W(GnqE}Xs&z$HfapZ~DbzfiYCe3uGBFAS4(Z6-=S1W_M5)w$(NB`QU>acK
zX*F7ycxo{XZAC?k9DOpOmneg66Fu#j!nx)lRL3&snx~;Key%wWZNtwsXBmsnHQPp#
z_s@unf*DlRndlcZU!!x)qirq-oofyqrD$~s$93np@eXNlIbQ2kuW*>&WhMnjuy)?Z
z)WqU(&D2GOg&QYh6U)e-Ou?!OC8ND1<A!uf<(7sncenudjL-b7+P|h5E$x1ja#WRH
zbTB$3&fXODD-v;hSNeq2{T((Zr-RYb@^`7cs=U-zgRXIuZTk!J-2u0xZ@s&<MYV^G
z4Rp;&Rz1=WOAYkQ;Nk3+ZH+AKwsc7NxgFvex1|xnkak8(uRGGWYGDu3T<&3O&`dn2
zf_et90r#Y#!pk;B%cXnLPb#-RJ_Uz*1PyH*PK7G(e<1ztaXAhRJM0B$y-XVRBPc<5
zhvJNETY<DwD36E1h0-s=jFyO#Jj6P6YdrAs*F40awl~3OsZu1#YE8xF8VAezzoZGO
zEdTZhA)Qbx(%!RtWLWzfj8qgrFx=gdx}K*x_XKz!cA_~%K!5HdOr=NK93`zQ()794
z_E9`K0zCbUw4zZ;c!la=)mqvC(i`S2R3Y-}R}cwy=s;<IPzP_7lzRcu?bm>pP{Ft&
zQc1Avu~|sKkq7imZY51;IIo?k7&55XYu61c9*-rz>Q`YL4-r+q*`K$@WTg2%k^GyQ
zK#G<j_{9!)@1VPkwQBQ_0UNXMTjWVoq~i4BlwRGc9X8a+#y*jB$qu&M7eTNfk5YZ$
z2Jzfs__gJw^~8b^NTqHUbb}P!1*xU|h8sM~ttV2Js&bTxy3NeMX(*DJTg`0AHb0db
z#qBxCt2g&&R4)KY_{64>5B9_!)}ISPZYky8xlZMu8)RQT1}5DzX|}4I+4pHPOa#7t
zF2&<{6P_*4pG)7Wgr{AMY~4#Kyx!q1B#+pO*GRbPk(`7%_HX|B3|i<?sigNTdL>Qs
zXca{Y_%=hY`dvTlY6jm!5guh^>=oj3o5GEj<FBMHYT?_42-&^C`HHCeMz*X*Z_gmQ
zHjwXx<mWTZu`Wk=1$SKLYCsiqO@SBpMmo^pk3&3Z`z0jdraL6Xb>v*WR}!{SLLHt^
zTS-V$5_FUh%oCiEpon?eztRG=&^^S++}}%KLN*v`^<Ekx9Igv1`W`I448s!td+Ctw
z&OT1}!ugU??zRKn>^pBG&hW7;>y5NCwy}bB_8hPpa#}8gWsdErB%GlHg^8C*_N_uL
z&BB#(58-q@<1VYbOD(v91&bgz5~c^jMhNm$p<A$#jnK$TgoAaAmWqyYm`aGMX=KgI
z$>#-gqLEcBFK=```yD9YBV$A~YDYr{%dzsZlS(*??tR`#UZE09$TG4b%01(YHL;5F
zIN_@RBlD{ye<3&r7%lrM$ssCXwztvppt7u2W#xUt>uoqx!gyi~x<VrqUrkA>L`hS4
zWv{nXI-s_}VZcHZE?hU0E8~n@6r120I<a8=2}MJD9V89aCsTtcCcX>2QCGM&0<!6I
zYu?>URt22}(Kpx|{?H9&;pB{KcRr(M7pur^beYjGI9WhVHji=raQxrqVPuV6<Ss&`
zXt)h7as%P#=0<kNMeZd`#Dl-9?B%(0KXI}g&1Kat#&0n{EX7rB)WEelr+ug?C~(Ws
z-5T_^8DYgcbkXPe>$9ieU>e-*DY}B;BUJ3cu7!02_W<D#nS<i{C6H+?V5OZsU0hUE
z9wdY{GqRyo<wUm!O_c$)$v$Ex04gG~BUR;E!Zu*suPQgIIu016Q+ApbgjbUrSFDd>
zlg(j2_^Me(HMyH`wuzCQuO_$h&u&5`J}9`dhe|w%0jZQa&+P{K?;2y1iyP=$8Y}e6
zbL_v{5d9}^a#Kfh&<rm%3v-9WDgb$&J9xV5hW%RZa<f_+(C>-HtKCH7c54#h4g8i;
z!bMG5IU4ij-X3a}qLn)d&l(xoTCH5a^07ur=4!~yZfa#e;Z`f`EY`}Mg+$nn)avqd
zVScKSU9T>O3Sy*@mG^-1cE!VjQH$JIClA?IbEqMFuhAZIi0~S=Wrc?v6STJ>6>BZ1
zu#<Rt2F1i!j^9$AQ2Rxma&s`{;HhSDo=^`paxe4*Q<ox?+yOhl)DNC=m~blrOnJ%&
z-NUz2fi)8Bi((hO<e@HKC-OCPUkp^&RyD*lu!dasgHxt#S`8q+0Uz)H39%(1{_`J*
z;ofp%P5O3B6^DAusV=okv*fKrmh;|nUAvjzA|JV>PmRS5a2T~!U@*4kk)EQn+}G#+
zgcVqrl3qS?ko!^evpk1WiN&kMw^pDi<|EfC_N{MK9G&QU)P-gO9d*g7zj2_~cIvgH
zJ4}lllLDD_JLk@>MvfUK{87co5*v+aBYcU6P(Qi0X31s<ZFi$FwKaXvQ5W?XmF$93
zF|IoBa~CIJpPzMSH~i#fL34v(Ed-lM@GMwJXUZ`s_S{4QZj1g*4lYxjAK|ueYmOVd
zw!@DQcj-AQ0pwS?=-9lTqp}>a<>N0S`{UAQAyq_BD}0B!G^TLLM%J#^DDS}aOUZmW
zZ{3V}lG)J<|7ZuP)1i704;CSvL8KCk$n5A=A-EQ)$eZ@q@D?Bk*P4$G#WyBR4Rk6P
zty3ljbG|0l#v+MNL0$Wf!hJ76cd@M3s_&?n%IE4qDG)P!{uKl;x9_OY!XX2EtbU_f
z2tgH%tYyDZwX2zf_7xdzJI=785C&`fOHH|Nm8vi>h21#w*OK6?^c$sXQgaDsKJ**T
z{N}IAGXGmeh_3@Th}(6@JQ)?oH;#}wzW*qn)TFiW#9kLR;OlbQ5M+j@&bM^l|AcCd
z%Ei0venAqy3MZn-4gCYXzogC=eU&;FY@j+{MiQcFu7Pqs?<MO3<pyqh&`S<qMC{w<
ziC%X!vIl|kFz@CcBy@9x^`yN-xW?$h;F;A~c90w{+{VDRJ4lWZR^uTeSPo#-Ys>S5
z+4#uYhT3u)bylY3acy~&O8=wG$Dph0O2(jSHBt8n#f2mWtlB+Q0r9totS1QVa=eFp
za1&yUY-6zO-|Tz<;G}jmb6Jd*rK&r?T$E^HHh?6Te^*o0@1Zi>TUb<AUM;BM5Ui^!
zH+0(-ipsyn)WTNzs}4r?u&zAJt;q)oMkEXlkv|b``WxBa5V?u477x!t<V64VYiVQ1
z6&zDgkMoVVQB(&k!E4&<aCS*_f!A=BR!<(3HE{v2{iM|;wcqVmT6^LETbZkr)?R_M
zBM8+#7x}E(yQH&~ig+EfV*(w<dL1G>WnjXkL{{x6DzvyaIu(Qj(q#}h2^>_PONNBy
z0T{_;#R`&3E)q)oKh`G{nz0>*hHJ*)x)2U+lCTM9_B#V>5(dq97+f}?;yZ()8ETtm
zTnU3_EbuY1a`mAZo$)XvT-LFH_2s#0@2}aj`f|%kgFaO`WKRu@SC2iw5+1K|vvg@7
zw^Hes&E<kxzN|!0H@r#(rEJ-lUZGS_3S=ZfNKoG*pH=IGG3WPi*}vr?<fTei$A#)t
z>6=Sd!8~!L5p1CE6_Da{KSF;YyxjmQlV%nlA-e~K=YgyKn(2DgY3nUL-EE7zLIq4Q
ziYgbsX_v4`5psRReD8`n%ccl<sai;`Ze;Bn$<GsfXY*Rs{sOh?&8^m5Z?p&%lzkG8
z60Z9%sEdUT)ZpnXj(T@-3F;o8Dr`7W+J|ghp<Ad+*vMJH_D0FDXtAs3>MVan$-~q_
zOf@6x-c<f0!FQ&@#=?@a?|OX11}%eujckPtxde3&P}#)`v)w&(l=dMTZtK}M&E)14
zx1gut9OcT{I`+7kTwNIHX=F~#<+H+@zYOeZbNMUvg;{J`wA>af9{*ftITtODQ43M-
zFs&_QgYdQzc7nB#9~Td1PcF|6R)hb2adNkyX|T=u+?c>*bJU0#I)seUOFaQ>l0wV3
z0O}V%%|0$%d|+U`ug^Z_Uy8x|KlypnvYZ^oRl|m(4d-BIzl!m#)mBa8h8K#Td1Tz}
zlZhHt(Txu>GF?k~w7U5^CbyJBtNd7=YPsJD-LK$?6T8$#_GX1G<yOL=^4Oo9DC=C8
z&ZhqLIfQ0Yq&|uAQDICuBMWRL#|z<j7=#C}*0Tt&L3QAjgk3nN>_{s)R$z|CMXlwK
zN<(3N;TsMs{L#vyTFWEqJ=G|x-STtFAF8#_pDuQZe|b{H>$neLf8WHo8g+ZVM=z!2
z-q1QE#otlWn<v|%rq@3t?Ak`gipUzq+Q3`8BpBJrHuBK$0YYh&Q#4Q#Tpf$*Q+G+g
zEBR?(%p_j2-N@GB_K3D}bK#8|)5Er?z<G!`*&KA?J}Pjzt^B!X3<1zL=Vqg?l~f($
zQ-&V(exSnSO^<y0RJ`K*?;+nky*y0UiU7zb&mdx%7$8b>^AY{Xp@kmat;g8u=*vW%
zYHWqPDX@_13Jh#@lAPu7eG`h7Jt(?wm*|4TrtL6+bAY*L?c};a2dD6E@Y#HH17*s$
z-HOY#OJ)!_lVvrqd+p%O7X58tKJDco^*4=KBK`-50u!-0*oxl^t~VfR)`E;_#B?_}
zXV@ozU&RGU<yX#CTJFwTrDi4xv)&t+n3_rF2^KGNXO`5=G{FflzBE-UEi=&hJXu`2
zhR!DoUP@|OX0UL}8Ovix^BP5I*~by*_`M(ufeMbdGZT0R(lW!{GvF>+wL|e+DmHep
zTV{}^$w+czyWy6*bHAVn^OX34_Tkt=7t}pdC#?9z!1heft6BXXFP#F8B{P`9M-5o`
zCvt>lKWfQ#b<eCTlzVHy^#qx2ttSFx`_@sSa-Byf8*^6ek3Spm(JQOgy)t)M#3bvv
zvF;trTeiYNlCWZsw?ppZq6e&9+#+uu@m~XP_*+v+hG#34se!Je9Ol**7<LP=ig1<t
z{GyjYxWh9|>Nhqy;yOQF<u^7l9-9L3+#H@+Uzi3TuXl>v#<#(*l$K3BoCkTa@s@XY
zt5*A~fgMXh*I56Lf&HB#*Jyp_1}dVnYR_O8;=UKZU$ubd&P5fVA`1ABYsp|uGvU;K
zl<KUVybAkR;;}u*V{#2)=naDsQccFgZ=GWNtB0U)()Z@TvuXoTmZIgI<ZsoFTC$AJ
za_=g!&EbQX_tU1Uf{5nqx6a@$@0Ee2)XQ{dx-POdy7w!klr0mflrLbuz$m}poqtyd
z&55fDY&dzqDOC<kUWrtT1g1*`DRa|OQq!9<b1F#Pcwr-TF%_h?yiiD4#}lbS7_N^=
z<=Jp<0Ouo8^WxaWG?4nOaVe=wjajS#r0PAlk(y?ZwJFwT3aO6ch*UF}#E(hcu;J7L
zjvcAe1NyjMuRNv~mC~X9s<c%eY*XCaHdW3>l@dP`#ZruNl=`PwHp?g{2<M&}*!M=c
z1@7pdK2(Rx3gk)Xs{$V9nq;G}4VK`(Nv7j?pAONnfUa_s&;qcoUFFllm?s7n*iBAv
zT=9v*d$&=<dn<?k;{E<(1*b7^Y{STrZnC>3ydQYI-c9aS<(G(3HZMf5`0ilyK{Ga?
zJJ|g7k%8^+PP5~vh3Pu>rn@}c(d-+D$6-C>uEIqO$ftV9;ebg4b?j{qxu4J&u)aOz
z)5*jBR4DHsLENo-Yxobzwzc6f;MmqNK9cG;y~;?ndHqs$>(^(udV$@xjhRPpup3ik
zVBLFDgdysAKOOtBw>%WA<>0YmAK4@{d}v?;`^b#|`@64>E$@Q>#JWNQd)h}n)#OHj
z!fw5x#I6=y>tjW**l@}Nr+C@rNng2M^#JrRIx0eUVdY}N_0p=n0M9L=pX?K0c3f7o
z76v(fkT0s*`Y>Ql4aAX0tOKCKpD?gb`^nz1l~A@muLq9N=iv-7cP4q{^qX_wgaV@U
zH%*U^2REh9B2>Z2A3k(qzb71(ll>?<6Bc^278Cl*SF`>YN)tT_!be=TYG0ykmr4<5
za9!^>$D&)wxwo<P3X?#6?pdog0UF}6J2ddAiz`l+KXvKqJb!uv?8SIF*0-1jDwOV0
zH#sl`djswp;En|2`KjI|^e7fO^hf`R1LWvammZEik(1!Q7xe*W^%agqoJn^v9!Ynp
ze_HR-@)G_#w*m(4WR*ucZ^Jl1Hd-}kl@;No0kVHU*mXsWuq9lEzrhc{rB21y;~-`o
zK2YASs&U)UP?=H`)yzF|3S%uKVRk+QD0`bO2Ujlbq?BclJVK@Ek%q)ogXKX^#UTuf
z>kxUTI?L?X#+#Z)Inn~ZwbwFgA#HqrnrH9iUs=Z2>S)k1$G%PFgL#j14Ccz}$Ml;#
z!4t(JQywMwfE}E2R}xkz3708Bi8gfP3EFT#FroIPLBgz!=5OEOrIdH>0S%YWws|;^
zR!(q9;BBsEu}|@ivF|z0`K~ze1W(jD@{%lgu`j6=Rt_>o$bJJ3Jw+~>gYN^E&~W&$
zZW)j=KdYj4nROmuY@7B+IL_|S(GHSuUhF@S1bu>eGCVojw!K1u-v(T-TqrUQ5@Orh
zY}VFDrW@#-fA34Y<E#-~%13969t})o0iVkCy|3QFkQah*1BOsUql#~dt3d?}{Z#gG
zD+jGTtOEtx>~Z;H1N-7rIX<iZ_oU8fjyssHV;IDM24-@8M2w>-SDBpQ?%>0yC>)sk
zJ&FyV^5KhX@f04T4__4T@p9h}Ss`At378*WESCOm4JLeau~_j^CUg3#i;FM<9hYCc
zrGp>NFWxF&PH`*aP>xkww}?7Q@q(r8gAE4`!3UL3;hu9iL$^=m*Ybg%RN@7daXhHS
z_;p=Qdko5TT@NjW53lPwZBdMtXLlm0eh88x6EB$DE5k7=z7We+&O~JA*M4>TxSXc8
za%Oj<az+>Oa&)hwtE+*_*JuCUtvD0jKkQaW`g7C@gj!rnzC64K-acQlK6cc=mxp~;
z9#wK|?Mj6&L93Q(=Au1G>FS>h%3iW5dy?X{KPgt>7ZV|$cz~AXp3N8pU)usPWsKZf
zuwFB;#be|;&97dAD@_|zibL!80s%l|R;r-@rH!%Q><%<(8fg+4O{?}KD)SHWXZ1i|
zEM?|{%`g)&*FpEl7*gClaC?Cj`O!V(url4_HlXMppK>U=M^6lP)IBZ%o}3qC06Z!C
zL^zy52QZ+|i|>=1m*JG0+X!1_mYk+;oT5smDSYwZ(V9=qlv^w(MN&YN-(u-FjfElT
zyLPyb@UB}bdpcGQsd5ByCOR;0vTEP`Y+xbdWFO&^s|J=dPHr6FJ0KOxo=q#6I3?@o
zhu3E=S=mSMju7nOS{k-;9F~-H#|+GWyqr~`1?I0<_rT0)!+5zt*r6+mEUTog!tMCj
zCO{!0Pd#?kgX60DJOo7#kwkER4H{dRAnP4hrIIyInLx39I9h8b$SZ<7U8b(+gG`Q9
z!j;N6VV7oQSs4oT`rJEMp8VFphE0^a3yXd?umw})80I)hj;j>>t-w8C@wS0=oFx0Y
zPwPyIG4!^5!?9_T<X<%-^spR#CPPtRIW6L3xwoqRx(h_Q2X5CjJN6A#XnTToZ;@!@
zTqm^$Mq+GEsPT<~`A(Hb2^ZiugMrch3%<e7TYM<iCFcwV8Z@JFFm~KG220J)<Vk`s
z>9~O{pC%6;RIU?jylt~l^*GxWp9%!DZ8nM_Ann(wOu&|;H0Icm0MaKGkC3i_qtjfT
z4bQ+hRtIWTpccWo)avkn8wyVu*of(}PFH>d5Hb-UM@Q#ooB}{+*FjiO_!0^fVe@nu
zlPEm=JYDv!v3xz`fF)!qz4$;K#5ilcfw|6*Yg9j$L{i;^@fW=Xzly79iJt*~Q<%9Q
zpG5s!{z}-h%D^n2%eRGdCk^b&S@H^@^IijsosC7q&wl`=+44H=p&g1o^N<uD#fQUg
zOSy7@{xqq2_PZA@GixCxNOvyKJdK849d8E5ChuzU*I@n{o1eu;;stG$k(iJ$#ef9f
z=E^Z1sc?)Ec!###rGo>41y`UYb7X(v{W1d^HAmhq3_(|~ohLWyXm&JV>x?qaX<TOI
zqcPEu5nr<(=f(nxj$E5V(UDtY*r$#>0C05VDu6?ghBbns#VuH`Wry<Q>g6+bq6xB3
zuusggx9~DCm2FGNaBHx#H4S`NhS8f_1!57LyMK;f+n{j&s7C`Dj{<kLPG#Sk<q(gx
z{9G+KXn|-9_3DXO??mUEI#&*<_voO(p)iHd$2S#A>`h8>op2DZ7X*YlT|*@7(p=fC
z)>e1haQ)z}QVq<-QH`+0fP?C>hNwn)vmEU0yj5wlWcWLaNe^j>0NXcq!JlqthB&iZ
z+G-Wn>c48$#0D)}tAtj(R*_Y9kQ=8|rYY>iV>4!9lMWb|-#mGw@WUB|D(1;KSy>o{
zi_W4)JgCooso&$!NtC-oG{=ZPMSDqIHc~U09lv{}sLNLV8ry9WSC<LMM~)jI!N11f
z^B-B~l+8L}Qdkzyw5etC&a>t9By~hnkrC<4GvcOhFnU8Fcq)MiVtWq)@H|KCE`*e@
zw+<s6`6W;2s^mz%028}|r^MP)Ceo3q$K<v+=$V@+*B;b;AB3Q6Frf||$k3sq=>zGg
z1s2WW{il%kA56B_#NBhNwhr=;r!yg%ho;G_Q8zDmut?zW-hgA94vHulso6?V{<rGi
zCop<C@h<o~cDS4~uuTi(#e(OT2G%xTo+X^b;D0G!PIF5?j`1@Xh&E5`{aFKRCc(tl
zyklTy2}XMpx*4_&`MWiQp((1u7hw4GrQab~RT;tjw!lb{<(5J_*p7v=oTxvri$<3R
z1(ll+e=olyLw14=Hfi-o?+ScG$5}UC$^wpREl9wXIh5t+#+2navXH6QEtEB?s)LW%
zY6ArLLZ=NZYLQ%DGcgoeJ_t|3siOwV;zhDSC49ONVHYMx3K`oCtj=QC$C_i6@j#@e
zrtu&-uMuK>KhHC;UW?`N!tBFbOARdS3)w62lWjCGwBaX(Typ9`(eNc&j0+gf$1Fi7
z^#UXrE!0O(Us=Y@0_eH+^85CL!IJw0Lfcv6V8)Yh5!n$4HwpInI{p`ZsjOd-z^&RT
z%OKEx(9MTY=nu9Xq=N%(!^>X;wCy0BN<bQ3o)EA;azjUD01@Ndj6$%`tX<fIMiDCp
zHr`11CMECaM#z`11u6>(P3J)EQmxvR;JajSsYSr?(367(mby%i5R7=3y-aS_{K_UM
zAYzHw&#oMvqPrl`8~$AgGLiUyfESZwtsJO)P;U>f*-p4~w?_?et9lZ66rZ{lMy+}T
zmcf6y9E{7)hG8pP@ysNfUqG<iu>qzYb~6)aYOuW63LFZHZGx{s7W*AYz|{SX5HYra
z^hwU^1Ahy8v2wYAtynH=1wA})%W~OYlRFeX)i2BCdcuS7ROYloj;Y#|a>0Z+pm5C5
zwisC23c04>3lCxP3OPW?Jz}sdUxCG@8YaJn4u!8lEB8pkDLQ3DLU%sx3!QtrQV!B=
zq^F=&c$!U5pU~3~dYV8_?dWOcDmhN`2|e9iCD*Nc3qBY1?qI9-DtEtd+VdQL0QblF
z1JrCE2D-jsIc}9V!QJJdx5Tf|EUV@Ant?tjYRzh>eh58XT`dpSZ1u)d>otg`Yd09!
zj5XM{(F9`NxJLFfwFymiC|H$?p~Ka&GoJbF4yZU@BW<tKNXW3eEBSvpa3lT4EdrEt
zkdo8WhDswka{f~<mHDleef%!h15TKNa}&>0`Yi?La6R0XxK>`TZn9_%I?X3AhA4FO
z8}dOyFDbS&6<>xf96)#2nVnthrefnDwh-!bAHrQ*fDXPv9xA+8gLwP~xp$bf8l})?
z!=&8r;&-Wv2HXA*!GA8I(I5khQgEymVzu=*$~B`~AxrC-)^X7!aUJaJ`4Ztzw>@HY
zemowz@{HgQ5dVPl29~!`_HO>kMT0~9%)iD~-~?`=I3f@Z0^o4Fy^o3zq22rr)3jR~
zVUsdf8Z1@6lIyC3hD+f|eJw9=O`n2ZGauzeAd2+G3In_Owd~pMrH+g{hmBbQgd(f<
z$`)?^il?!GSs;gL>;YhYJdGWHw0IiJo_y6MT(yGz{aw0mwQ?wnW=jTSQhYwP@*6oy
zb9lMI0awt)_^>6HlB)~3=rx(c#F~`{08U+Xr$0p4cWI1ASOOrp6j_JEF~J4DVl1QN
znMlS*FTS-G0H4Q&3mH-6VbSpMC|7p#hqj(d`Cr3b<K^d28Vb1TXDdIYA0Q|no4Lk#
z7QDme5K3N$WUF@m=Cb8u%8XrOCd_oor@LgFZk6ux*m?iU`WW^yE<VDG_7Gl}m_IDY
zvSG9Atg3H6_4_Di_ZN0Kd*MaNS$>P`qO#j_!*pBa>K-qj5potj<3W^(nDaA$*!1)?
zf6MT#*i08%O6((2Q=Zz9%EXI8>cO_Mq%7i$mOt6=Rlc=T9&gW!rO$48tg1}-i@9Er
zeck@Vy+F7{y;u(6c(=Ijk=v@h!gfHJ&O@e%ab=?aRKo5NzIbTK*e5qrdECHIXG?!Q
z73oeq-NABXKc(iuakQmwgxVITGS`E0sK=B0AIan|fE1aGJ}9?VYvj9l-+x$U&GP3U
zdq=1beYqYBUU#@tzZZrE*5Lf-NNmA%3r27x>Hi+yAqSv)<Q<XyYqumA7D_@e{L+X8
zcj&O~i)(c%k*-ulg2*l&0bk)D`axTT5g)v*8XlEfs5Li!$Gh&7j89-4$2P$z^v!+8
z;ky)kZeZ5qa*cBJByg0<s#Z&LW0fWjs}QyAOND_i77+uq(;kjXLD79>BfV6fc=!xy
zrCLDYy^Irb0}nHZaej0qx-*C9k7_(D!1B`xl2e0U6@DHHzsxW&=hL!}e`G#5c)<Gu
zWU`Ba{BACjuklzI$>trAeL`mw7-Go)GKmFN&Z(dlZV04KG)y3-(vYOA7K^9lFprTp
zK4NA#K*UTVi_;moxmr`<I^NrS4{;2TA^z{>4npND1H17(M#d+LA)xPN-@uF3l^}xh
zPeD>ef8mJmyt0)?XSKxtA8FSe5Y_Sg;oc#LRN?5oD=MI(SU|9XqM+U(_7=NFQBe~M
z7$i!Ngj3&JV`6ME#u7^`sIfpawwTxwjV)>tlOx2Q*rML=GyC2Z)O`Q>`3Jt+ot>SX
znVp?&vnQ8S+J^k42gLVW1uv3{&4QpUY=Wg6vS?g@=iMJ`>oEPU$o_swl`8l$P%8+I
zy#)k#^vVhWR)Ehe`PNo*Z=o6L=jni&3Md7)&6(P`>32oyxg`fxp*N=jRN|_KE^@5|
zIL=szBN<-b+%L!zFTAY^#hBRm`CkdNN!=qC3w`ys^t<m|)>vA}a~{<sfQ^ek5A}cE
z+ot9w2DJP5z{xx)N_xp94DLf<bKUNb*EG35*?L)v2Yk4OB+}}*zgJqdO%dGIeqk<t
zgpB$QPLeOkVU=6^d1@A*N;rL?$U5)^?@2Ci<*@HhZq4uwt5pRsqZpEEHgc<;azD?S
z0-k*hNu)M$4_4AsiM%dD(=75J9~u0Rh^Xi9kS?X7>o~OY_1^d~NG>`YV>RsYOt*_T
zsTx)O+{iO=nv8xQ@vZ&)-QMQk*%z0ztea^5N#K4*@=U+84USkY$h9nXa&*(4KC6v>
zqY0k5B^LKgD6>n$nssJr2t8rqfNkUI9xyd{&KYY%RR-c3y!X8>;MsOt9M6+-*rLSZ
zM#7QVIjkzN_+EVdH_@Rmg$KOz?{r?J#1@4KHhwUcC3e~-T*hrIny+DxXJEe^_DhT6
zcEZg39QOB>CE*_VP}76)z^+WFoabWY?&^|x!hr$siCY$@cr2d*h$IU{Vqp$znpCWf
zZ1RYd2CE5p7l2@VEHH-(z;IgIKftb!-s)BNk94|qw{~g{JCRfzCM=kTxpz{rk8o>7
z4!iX8lCIG{{UPx%dA31yA!;$DxXCGm*{Jy&#LsM1>?g#H%VDFhEy3;%EWM%tA%?8>
zEbq})PnWzRcv1<sYQl}07jL5t*OoLDwoT7rUe_^G7y+yBcI)Dxq<J+f5x$vb&$tM#
zOkaJ*%6c^#c}7jIx5@p>#9vD<BWLNaB?%DPDy*bh3#}i7ww+`a_Ny$j5H7Q{T@XZB
zd5(BLD^3VUYa?v4p2m+HZIM}PS~V?!z&Pl<zBxeCDFIJNahYN6vQ3-AdZ@D63TG$g
zux)O5LiRINmX}B6l-h#JoteW<sj@`jaZU~!C1kznu@1fH;Ao3b+JPGeA!|}-+j}H9
zIl>sGgal?KyUpmBZ>h5y2=BcK3p#phnEwO}$LXa?{HqAkr$0a;W(AXTSlcmM1DR2s
z)u@xL&LTpp)u_3neOZK8k>Xkp-4p{8+DlVxcV%l25$(K3<gmh<FygMz&eJ!Sggf_~
zonwPzh>@^&Q*)%>A;86XIjlK8?7J)?hxs8}Y5dH$jnOdTrYui*XJ&am8BX#v8ZwZF
zn=i1R=s@^uktesBvOwqJB++XHs=E4$KqtH>3se9DxIjA(vk25L%37dr^nOL4`W}iv
zzZ_#N(3KNv3p5E#fIuZxwj$5@<7>+^7~M&hXN|QyAC9Xn&-bS&@*F!_k!N@G*4N2%
z=Xh&*-sthNJWo+dtuDDADgQ0cM}u<M${NV?4m9a*4dj`C;ZBz4K_rEM^THH#W-UJK
zqcJL43AEF-R|R@;pe)b^$TMm@VEJ&51AkvD(4jb1`&xnia{d*8cAqB;^j8oAf&Lpe
zz#`A5!PfHZ*!>lG=A|q0Tr}KTo`s`o%hLzlmv_+JT@`_j8d+PQ#t9~Y-n16z`4P1R
z`X<152kkmc5olv{;nxXN9BD1ks`Qryx`k3|33NG9{#&3Iaxt9WgFsI~mE7(_pzauo
zWr40hQtEvOv^RS3RD9Um!&kNvXynCL1-hq?EYP~h!=(st47;%S`&xmf;q2&Z1^V^r
zR|ML4jx5kaAcptQIyn}JUcyOQi^+}X@`^-zwpS!Nd7!mKhYYPP(Z^^qm*~=tibT7>
zak4hK*G8Endd*s*yD&0ao7^4%;}UI%L6@6cXY}>gNi=_mwM197e_5g*P)aR{&PK|A
zOSGa_4!iyc65Rq_ihm4=-oqd$OSAw<Lmoq-%?9VNCHS!a1H-zNMD5PKD$x&n$`Y+U
zOA<W?j$zV-zps^ODE1a!E78>_UXiHt43cQP3bb&6{+?wK=w4dZH;<v}v{wY0&{h#>
zuRhiSO@)tP?fm?N7IT5lNKphD-LJMl4-Pd6^rE#uB@Elv0&M~?E>K4d#$2Gc(1~9s
zP#v5a%NRPh?aKn4NGY`hIuI%UEl`%3BfWq;KY%7>zkoc?ykU~(U?dg3fIL0==CB?3
zus;gt&q|&*PrfS8x4OylJdQl0W;+;$r}^;rweqyZDbUx-^PR)5$n#d7+(U~%3>WB;
z42wXQIa>?#x7M!+)V+lw(55}D1sVb$#9E-c(PS>r+$2Sy_V7Tgd+3V(CV`%_7U(n#
z+tvbg0T>tPpIM4Pze68>oj?=eu2}>+w8hH;&7zcA0!>EBe+zVaXAG2TvAZx4sx(P0
zhC6Q?WRhq*B&}473Bm((;~(&0zYboZl|;We@~TApc9JE!9(f3t3XZ`;#oyOT^oGNK
zNOahNS0wt~I9Z~@dn*$Ctb;|OZ_^=ja~D0_{1u7bi&G?8znis0ZP3lFCAt(%<`PY6
zsz~$?jL6m!Ezp@H`kl2za|q1J&AkmdafzPDP$c>VI`Qiys)4^|k!V`{%My*Flv)xE
zM9P0lv`;EVN=HaE3!YuMBP6QNHAyrWNtKR}=($Wx(C}eDA8w&ZqFF}6+R9fY+Nzx_
z(Guig-v=BsY9`=sEs0XxBl&$x3Vnom#pO^~^?IUCa~WMcLy32R=(a$S0W0~Up6J!v
zVK+%xGv)-Q?G3n3-vd51znwAxX;@1E&-iwY2|-Ja0CNzVnnrw`$2!KsP}Ia<iuXDJ
z0Gh3jJxC;L$&IAhdbyM68yO4CnPmg$0r9|P6|{(v_!vo;TiwJjOmk;6!pXhw0ovf7
zmJnId;UvVBs5Q4YMd2!SN2&B(SnhCh7Cj4^a%^_TkCS3pJv{a}Fo!=pR)yt09=0n%
z2CP&7%@2>AdKvHzaN{0d1pw*YF*AZIa(aP+Kz?_u;HXjaz6k>!9^+O0E<>JIAaNW4
zv;lC03D87SfehG~s_J7^l_;m{6a=_=BO{1-8Nsv^88VYF;NdYdv18=)CC6m8;L?nY
z;nx6Si)E{pq!ZmAP$ub|*vX|6Lj}tczr-&{=ktbfHhUe}X(!Rg2bS%%;=vVZF--Mm
zKQ{NfrJl^eRrJsls%YO6PktiIN48uHFKEWQivGz@;KGnD5nFCHMxL>f9-IPWuoF(t
zl4A?puF-Vbg6EITc9gSl-odU#KeoVC42v3X!QMy4o=%6|C>n{SmtX<t<N(hASS@4Z
z_F(!e!j-V(W40){iMwM=r_9nz&QSEWvcwLD(HA0<U+!`&)k{3<-ntDaE;Ajc*^!vT
z+-=vT3VMu46M7U!2!0sB&h(w@$v&`Mrx8++T-l>Iu<`dqCS8k|u!p)xA2{aVL5;Jr
z-Z9#+wmx6*!d5?=)O)t;0^I@tgLjc3cVz>G*Wb03b^V9^l=@d;1m*QN#E538zXy_e
z{Xe5m^7?02Q2nDizg)l0RR4I4jlBLwfI%!Je{=nnp5jQ?Bj}^(>inkXYK>BRFxZgW
z4XyvYJ9a@eVzlsmbGhPvgJ7uT<>6;Lspj81$~DskQ7kJPrlB(dA0`U0JxI&Ix@GCO
zko2P2J~pn!0oWC&&cq+MDJW>vT<|5^QV5;K#WRw}r9^9f%!8}X<&n@#;m2N#KNf!c
zjA4fJ<4xEu&JX7uMAai%C#~dh6Kiywu4k~GoFDrD1Nyzq{NVNf+045BlMR&m(-M^W
zX*{yje>+~Oe-7LuUVq@1RKGnmv$j6`gK#FiekTl(y#AA^RR2Rw?fRc4Sl55JlTv?A
zjK5qTE_Jc4|3wp}{`WCW;`KM)O7(kV%&A@fh`LJs0T@|%{Z~?`{yLtu>vzQ9Xz35l
z)0Fy$HdgBY6BJq6?}B8`|4-ny@cNTCQ~lA&FV~-saNfNAjo=LN`u~EbjP<Shwd?n5
zVqO12FQxvxSf&1_9jxmQLNc#^Gt2_7zxyVtza@Hg?e-VLbo2V#Vhrc?KZD<jz|L;w
z`d7B-5^vj3-tWw5C=c47ZNxG<Up<$G6`OM(Hjr~Wn{(OL5V5H+4C;C_L~In?47!Ed
z4CgiwHT%)WYuPCl9}4JSz}yj`Vx!pY&=!L3&7qTDhBmz~tnMP%uzhh^LBie`oP_OM
z>cQ^DWx2U6iII!{wtl62y(fM|vA6efr~pnh#G8Z9Vj=hmCR!<BVz|?<&^?%bdRg`m
z3-##l(`^f+LHh>nuu@7pL0ytK2Z7<`P_H7&619n_&Zr3noORpiIP#FDSPxwgox@f|
zwhPdViI(B_e9l=pkNUa|3;Df^w+cq3uP&>x-~!l^aM53#1Z%`@G)dRQT!@nCiAE{K
zK$v1fW|kHBa6jgd7ogoYw)2Sn+eL=n*AYjVN}JKqCoCP$bV#rIUCj>&@z7Sr$f;2|
ztXaRTD5q{fPmTC!-AW^?lG=Gi&Q(yfQnrrskYm*J#~6vdFZ`9aP*M+ObXP^@un!Jq
z1knFIU$pUwEr@(&6J$J+K%-&bXV%*=SfEag6r*tg<D8={8y_jAc>fsz%1b-Mn8k$i
z94+9YS4E0(DP=3UgV%ir96b4y&pQBjt#@DuSjgLjaD+&y(YU(VyEahcS&MhO<YECB
zCz8-}nna21f}>wk!IWO8v}|U);cFdR7$wF>guvrRe<1}}i_@>fnZUKwetTq??DO>~
zF<j6`<ghx?V!ZdD@K*`nfWfkRwAd`=`6rz4{a>01zaRE8;dhbp8p1O$2pxzPgCZtr
zp^1V*RZ*-=)xT?qs+&zs@^EX`KU?S+hLb=?+xiPp_#lZy*8}dC&U-%&l_io63?>(W
zO`4t6Pk0Zm_II<h!aS2<d+%l#UGTsUZGajz<1zRObF$I|H-PM`v#vqbZy_?4=Bwf8
zlY^5%H>;s;&KadS@`>LnfTSyzO@Iczyf;Q(eq;?>E+H8EGH^7dEb*&laD0soMBmW1
zutDUeV>cMLZ5|p9|AUi$o;YR;TWr*vx5FXyIa%Qm*)--uLZflag><WM74c#$fGi!5
zxz$beQngeL<IhD0qnmv(gCRx|sw*$@B#zrWxhLX~fe*ixR<IQGT)UhVz<guHIG5$W
zH{u>2*sup^CSA?)WfLi*i6vt=GB(AEzID7)Agi$~;ZU&$`#DzhaQXJ8xwM<9v`-_k
zk;}DPvLgw!`!S|-wBs6y9%03n5=Ary7ajJoa{l=IV`U>TZ*UPDD2r&h9hiiqn$>iA
zr!-#{MtZ4E7KZLs==Mm;ESZ91UUv-de`4J|c_ot?i{S&)Hqi9x99Rplk~m}v8;pY+
zaH3CaBww6Q5SB3RR?o+OnedO@_R?%5ZMWG=pGb~D?Y6MfpAPqp3`Z3vPyMFEJ#`$o
z0m~E5;1_x7j+jUNy!Bn*0ugrZwT^mvX**-&2gp^r=&O`IMJ)=Y+hw#Bye^`YA|+W-
zx&r>`OOygXPA{@|SAXK}D?k?`@7mDcy{@%X?rsyYOQeQq$Ne2}N=p}dG!Z;OOK-m7
zl|D3U`{%vcfH<+0@CYAE@sV};b1JitKTeQ-R2{)XH<cx3h`jw*k!#ITo=cOAzi6zV
zd$<zh%MlAr2I}<iOmAQK6UN9?@@*o=)~!WnWfRf66*_`3G9DwQG4eea2}{p0MS4y`
z+-U??+=-FMl1V#JE91qmH-}c6)wdmb(aZcQk%Ln!I5gmBEgYsgreku1P`>}bX{(*j
z<!R*-m*3v#82~bkk-c9a-f3haY)h>Y>~x26&j9on1k%PhYmA%?Ggk{jIxx~Rz@4(r
zk;4`F-2Np1R+%7%Cl5uhfN?>C$SJ6%7njKNmd?z^CF&5|{*&_!bCE%o<l={9d=7z;
z#G69z?wWd*YB9_;6{CbEJ~?bmQ?aq|!W%cTnu-(w`L8E7>`+s&uP_5?mI%nLn~A>8
zY4F9l6IZ?zqcTN6R%fG8?C$c6UDhY5+*W2JIXFS>v6+umiTaB@{d4jD8E!33^`KEd
zW89+|%INqLMw5f}5t*$5A3QAdU5S=xY5^4^kHSK0#=se;#_a)&Wn!J0h$ch>W>TW)
zCG>ctV^6jsCUiVL)+LI;4P72l=-NkyAe2Hx5RCk$@rC!#`50A98hSTT3=kH0<}lY5
zVsQPDp0!1RC6?3{;(novPma_Qb-LPO)xV|KFKRCsLp9*A0v+x%^jbnSwZ#Z*;W>PZ
ztu4idb@rkIU}}E7rFhi$7UV8VbU@lbnobX-^#XFyDwD(uzRxl4ygqwtEAa%LAIxF1
zTZ>xZkSo?NTZ<t9*&vuko^t-a@HK;>oai`<$vA3vYa<>CtRgRp>yV{JbHs&;yKO`d
zTS4!fQ&A^bw6zt=oN}0Bir8LA$46F**hT0Z08L2|TL)CtBV9mrLNdx3#_y-PXO<mY
zfG%$^wr6)z#D>u`2?EUcb|De56Z2Xuc+u?ET%X+3Nvf`~LW6p^KHE<02n{scv0)YM
z#7%(-j{k#JR+uV&B=mf$V?k+RVqh9f$$z(NQks}k>wMkm_F|arOToN$brc)e+AEq+
z5#LE1S*ys(&Z3ho57}L@wTqZyiwM@N`~&fX$5|&VjnajF<qXJJh-E^#=;vPiv(9v$
z9MgA0ooj4qxftp`6E^y&-~d)(h2_Oe4C*J!#rE3MckoyhU54!P0gY{Az$x4mutW-g
ze&GpAlqH__o=ffxe|TYc6s<R1Go&I3=jNa?76!8+dhw>mAK;@kfd%yy0+(H>MWFvx
zR<sBNmcx{p3G{edCNPR!UL*!IyLn3|FJKNRBP!>REu=7jFVX1*6hzd>0x}dQKKE^m
z*h4M22hWM#7$Fng4EaV)ATlgOlg*g4Sd3Q>nUP>q@#$hQ%GP@WSV`wi9IWm<Nk8LB
zxFzCu!k~*fwoMeh+r9zQY2DCgR3Rd>%_K{Siyc0DNlbhp%=aQSo!<c?k8asTrk2oj
z*MF^=zG#}<bU&6Yi9YqG{;4#*ri7aA3<v&gN%U`c4P2~=!x;-w*H<_(_o>W@Gc&=7
zgOcdo@G}{XPA2&nd_!eMtU@-9<Ri<%h;oUEA*unRSQryORXgPqHB4Mp_uhP}-veqk
zb*b1=J#-k3@oiZO-@lhX;_56Fn*^4;Me1?QsPTao(V@N34i=-wLOv9?MfZolV7;LK
zfT*G~N0nd^_~ja7H+m2dKmJf`)NR4(7e+*AN>}IiOmp4U*{v-uUTp`Q>#j;TLTB^f
z514`gS-XBv*z*sq7}|F-nlN#h7@<y}FSZPm?3s0P*vVyL6k-77jt^#!mWiPnJLJMc
ziG0^QJ9+w#jy3*BO!j)Js_k8(iVEZvek4W~97JCADje~%KK2xL6a2>mo5keHK!Nam
z>au))5T0W4pNGj`(0oeS&=7dN)ldOs#8RWmG;5HdOzlGc;TiSijINdpdpV;~(maw&
zKQh{K*Ib7i<kSnYrjc-4*+ICbk*6a2W3h{^hiKH*Ivv*7K8I~sE_O-%>LfV6k6&6>
z=Z_|)#}m^hV04$6?)9cM)01FL_=w7_M4bmZmhg!fq+SXj*83B&p}Grw&HY4dq#ir~
zQr-567$)SYa@hG##OO9<$=yc>+oTyU$n~fu|BX5j#LRV`8nYohx;~YH`97V%IpX(@
znIm`Z=~&VVv4c?kLdWK;5Mu*N@9AvPik{V-+8lo!^RvxnM1{ia$O^HUs@X*L?+USb
zK_W~9Kldt2i&}sitJk@-8qAfYMHjU?U67?k7qx~|a%uTdwtP`*FvfOdtQya0^F@Xt
zE$J@LSRiLq7Me3=%Nb2K7m&10^Fiv6d<b$T)?`Uuhw?~XU%=K{IwP!7#r2h9Tie9c
zIaF{M`b+l)S3BXR6RxF(P}n#4(J=^YY}DLFpFemS4N^vgcfshMtHo4x&RB3kTrKw3
zG{zUy>(*>DU17I%%x;a?RF!{}wOS)a$6Xn1Enz~ZNEo#3h8a#r;74T?X*C9TKUgD1
zsr&SSboZ<gL)0}W&aSS(W?0lM9drLw433<74J_Xxn?MAqb8szs4~r?)hwz6OFv+O7
z|4heppNb6-2Jz&uU{>_07@?U)bd+hNS!Pnl{iS33J{41hu}^gD`KMx{*QMilHJ~<$
zcWQJjeXSTMtUIn_qt}Yb-t)&$Jy`UC=qBym$_3sVnfum?*#)_eL0c{;k=22488u&B
z;_8q&Q&xvbP>0cHWObMUsTb|#>X1y?gwv>b2l|JM!y`G#ZIPj<!yXuKWNef(etp}V
zv63=M4zbeD#2Dv`<4Ev_AU+y|+z$5ebjT<%CKwH8yRs{viE(j5r}oA@?97OCS2yQQ
z%6Ae4>BOyVJD9qI=@zLkf3Cy(B4UZU?hBO-JGxHnp<ah)^D2Bl7eBI9<<4Nc){9>V
z3GiD-ZV-c2UAD0K8^jJy^^fTI^^XmsFkqbDAchDdF}^+7AP#hw9I<+ay%1uZ!Pge6
zjiWY-Tl|jvfB~ogt<!-bqh>Jlwg$YIj>V(+O=3`HlZj|;7|H-7abSXcw=97Y<K@Km
zNQ7_p8_<LR=3yS8Spb35U;|KNoYEWDb?C%m;IBHiY?Ii?z0MaeAjy6F0+8YOmoJR$
zdH>JD+0#v8%dBzuNkg@KgADli5=(b@y|~jx0r!lC-9O2TMW-<rr~Vc*g4kaFZ_J=H
zPWWr-b?~tYzYyP3y%SR5v|0SpR{gUPZ?Am4MN9~&KFuY14zz>FZ$a|`cQglM-VGgd
z-6{qb3>rpg(@7=h%B4CYvjmgfYlhB9m)&gc|M&TY#9fH8fRpEk%KY!gW7f1lB{=*j
z^n3;0wDSAIU({xShxj6M8C3LG$Y)nuukltL*2%9YTt}bbuP2B@iK+rvAxksK5td(1
z_~0*4Yk55(<gl)G7%Q3^WN#BQy_cddV_h=Iye^r9NFrb9*!FE=PH-$`qNUw_2VF&n
z-0*D<PEjpYvzRZ%AxWFarvlK)n`R(GNc9W8xM&zmM4r7(5;=*#7E&RR$}h$CDNRw@
z)vZg2X;l+pz_6;hkc2|3DNv&)eYs@zOfdJg+gE`}S*P7Db_l(}``$HL6phD-V>|}7
zxz48;Iq)jB=E8n`x*gM-wpVrR-|b@3KwFdt#Rtrz9Re`lg7;M`;R+H^`vDY(UThw3
zu6?_lu~yEQZOI@vn4I|?Vy8BP@oibFoqvog1sYcIy`^ChGKSyAnNj<q6ed_Z#kPV^
zwT@-&6#dkXazOuto#J#M`?8J)kj{>{Y;7e;D8@)Pq=DS~fCjn0j5Xu@gWJC3i*m*`
zOUC!eP`Jp0wbkfQ5d~`#7Vg%ujl0B#!eD$n?!F{Ubx6ma?Gh&oM_@woD#W;YODfQ-
z5oqlPkh!r!Y!#3VN0_FrEBlee->bHkwX|CtA-F=RM(-9wg_^xsjNUCq#vR%V9N1_+
zWPlG1&wB158$PC7Gu)&5vOu<{FCklle6pk0cZ=-<+mjzw!e#AdlJ)dnkaMTrAiv!n
z%-pYC(6QV-VxzWOFX(LglM0n14_ql6W#&pTvXC)d&d9Q4j7J7vAEft0Li`B~y4~hy
z=r$ezG%UIS#YQx5GCwVTeZdy?Tpb*v{t6ATer%-ouPFA?V<Yz4;a=_)6NRI{>-b|M
z9*xe+$TP1h$k$wF{$GjynLWNlhVuA`A2f$p(Y_C{qS5cvlcMlfmYgXB4ZmKy<s{W=
zebVFRFFH9|OBXl={56fWFjD;Nho1|&BO%_LLx`7xttOw6$6)zEXBC450|Pbql8!(R
z!@hG4@#u2Pb}3cN!UvBo*Ke1Mcr1t3nxMDZCO4=XLyv~Ne-`7|u>Dy0SbL7wqG9Xy
zi{9;<AU&hxubS$N(mFKV@=C9|E~J+=FXa9T#DI6-&&iam(Gn$PV6(-dKt-ejViPBq
ziz-n22S>x&JZ~E+Ts+IG@nTaCh<;5s|5Ur0`sw5D%F9T+iuq^dDlYV<DyqOQSSpJD
zxTiam$TU5%3i0^Q9v!=XKwK;g#s`n}n0-bk$9i<8B4wKIhM4tEb;jDv;95FBd924a
z=wjn5#mtylWcsjfW%&1=y!?NtClT@mJX)h>9sZium_m+~2Y4rKCTQgeB6`*a+Yk|(
z@ht6$wxP`Nvq4U*@L0J<xb}sPJw4Gj%<GZCjiY-C%Z|Go_{&APb;;YBZoz}eJ>sj~
z>v2~ReQHlP(`q+4h*oRJ0nbQ7xqVK&p4h}@uNyaTSnC`M-GvdnTLs&$ItBEv*!BTc
z=CaAhyK)AV3^Ft501TvJl_q@+9Pi+_#gKNv5CkiFwbFv3tBk_Yf}$N2QO+9NB^;{S
zIOL79fmS$9WN<Rx8)zou;CB`rlMcb47f^zE^UY$=FC4Ux(osgEwxDT+Qeeg*v4vj>
z%q>Q!4!LHl)e{_kBOO*N^|08v^=9h5FjYt(Q#HU$O0k?VUCzj|WQ<1!m)_|!+SRIW
zb?n|hZ9Lfgv)WkU5{8PMXSFGT-^zV)btdW1LW~iX{(?saj)-aMZ_lGQb~++<6gHlK
zVLl?p300SL?7$H*EWQ!)GALYT#+bjCLc*4*Ve1p17KZV?ZiIL$+QunyJIa^d9&WT@
zeUFMQ5qEDdKE<PAhL8gf{l-yDCd<0QAr+2cc*(+O5`Rqecdmwm#218<C@=Sz*j%{#
z6W*ymCax0H$9U)UWL=Jnv4SI#^N)+E{sl+nZh9)62-pKV4Xu%Py4dOCVrcV&?ZHS>
zceQM!!sOxD0t#d6PK_p2U*(z$r3%Ba5qW|Zuaj+(gIU%IF;KIOkd$f8<d~)L*%2L^
zdqQj}Y=Z6j>V()vNI}XI0FUhf<5YbO>js!!^g@aB5{iptH*u3Z)4+Ts`8|=(G&=HJ
z1XL-NW&2$kucniwny<g%+OR{;_)BN5e?2nFD+<3Ad#hCI$FLv26ARkLjN!{FGlYCS
z_Dc+Ckm*zvs(jFiyl`i7vuIUtM|=AD0v?cSJub5Ni{enhf2EEsxrmkDpD-p<xC8`M
zG)WsPK)4lTk6FO!i(+zU0f(5{KBMTF-IP?g`%rN{Kjoaw_)*82T*4Ys{}no>y(C8X
zd&=-Brb#ETWtQB-o-4+t#h1iRxh^?mYc%_NqKzS-9nXhR*TicDKKKPL(zLiN`S-TO
zBj=QC+AXr{0%#sFQ3;|q|5Iz#mVLwc%i=J>?-LypFJqJ941Adbm*F1RRO;A;%V^1r
z-PG2p?Gb{Ax8!ql7Tyv*4z!1S6R)5p+T}Xd{|X!zH()5ZB5H)u*J0nUh@G^KT2A_&
zEHmln54?u-Us`k0Tle6kcL20C=|!upNiSC(MtE~g5SmU8Bg`A<fm!9MIYK$+M^^^q
z1w;mbaC1y{A44QEs4w11p{{U2v0T<KBxKFaF};wGusX=}LP9aF5b_riLSUzr7ZPq_
zF_gcM(5w}wIUU4;-D%xrnoTbx+*?8VBfpTadnXMg@1fw@L3tsuf8=0`7@_lnq1t@C
zl&%<u^^v_8zhoj&Z8BVU2jyYGuJJ6~7WN;U_puNNR_`60H`6m3jmRu{T1_GRaIy@?
zx31_|#*n<Af`pcwuFfC`boJ>b)8(e9!JXyc480$U!3oDvO?wl@$X(ls$OZ7PDFV+3
zEJsmD?&<;ffbL!I3T!+ACWxbH9G!A=-8D7BiTH}=hIoq{Ve=X)O>#3h>*OZcwV@{6
z!NP^bw95LYyaUl2cSQL+5N-DX1_2q~XbmIB-+^fI2W%U?10gQcncjhDI4j5U4#e^=
zb?oh7c|%?1qHg6Kh|aLi{2ho7nsZisO2n7heV1NaMBP6EE97?|!nUEX{0_t&m|VOA
z;jdeDaW!UW=7%8sP#PVW9}mnSufX~th{#?t0|vrunngMUiR3@#CQ<v_BMZa+*5P>(
zu%8ET$MNFuylzhMAEP_KJ?U2F^ai_kakdBR@J3!=&q~;PR8@_`9uV)}n8w1aZ+#;#
zJms6FyiJ#goH9HAF16cK^dV6ui#J5EaRZH!nOjJ>LBQcYA}=iY27ab0Z&*yo2I;=I
z^a`_S)U3c?id%=Z1P8-vWRX|9tOYe-9<sPSEUXs8@u-M#2Ew6;1@AdK!pW>TM(a(6
zQ~$7bQbF&i4NwuDlw_EQBOHaZBGfkdzUjNs8v0iNGj(S=f?G=kjR(%hGEDUjs4*_F
z!ryOh>$<C(dfsu@d53ABfNgVFfHe--w`K9X<sWqBEf0a!CL>|$aJfurIqpt=f!fOu
z-4CX=eT~>KqWqARSQht?#ZuawT9uD1Ss5$Wbn;}M)`&yVw&l~X9ru?Q@3aVAmo##3
zGiYSzzr-2B9GJGMzpxa0eX)+&-x8Ywd`v!0c(usHqdK?5lu&UamSzuP{n(~@9tMfD
z!a1XDrnW)MlYGPzvU@aDfjx9f?B!$+Ye@L7B>;cuZE=gB-JoOVZqp!Zw_%C`>UIaG
zO&Wg<KJCN4Cl(Lk6L-HOh7`1E#90!LAq&b-Hw`R79EeyxM*O=7@V(?UNV=zc$dGpi
z?*NzlRJ|TZ_*k_2bAU_$Ms)3jhlXv)S5D^?59gya0+1SJeov`KGfIAN-8DWUH?{D&
z%C-10va6d>XbY?zuF<i-?}#~`mk8Zl<RF#|$6xnz9UF944Cok^N@MCgn1Gr=M$Ha5
z@ML6~VG%OzNM~4?2KYiDL~l{DJ_Ctz*2lcXb5CPzx+{7`Ri;ok1i|nPp8Y6`{1A>R
zAyCpp(%R7wKWcq?S4<L4?8g9gPmD@9zK(naYK(nXXnPt0q3kDZFTr1B#Y*1p;=c1o
z>)_?x6C+#)G$9S?%t2Fu>)<_cGK_KFq#V}bzSzoXAi5C=uedRUH}k$YMd$&`bML;`
zN!VPbW33*D%^<}V6LTu^9*DuVP75n!_%~t!|MB1A0pSE#w=KN4Kb!FnmS5aXtY)YF
z5yuKM(So)QaX{qGDjl2gP;6p12SZ>cOWU07$tE`KXIJn!e1_`bi2s8d6fk_vZLy({
z#e2<EBvRy9H}o1>$=@5nRb)$Rt|ALs$-Txj9Ly*Mo_v#%K=_8+$I0wnukO$BJc3%Z
zJwXa^g!Zh8$3Rfkb6(g}#Unn(Ncc#6zaVoJkbHq0RF|4WlJ+BAWl%$|34k55k`g$*
zEuaM?eMc^0JcdwhgD)<9e<h3RPNR1cs(bPxf|4Ez-IBG!o2#d$eM__oLdz_<jV)44
zVrrs5!+xY1H4L+;8gCk&#7=lW@fI=yIB|23!M9S$IKPEFg2{_sX%zD$jW7w0Ud3bh
z_$m0Pek^uOxfVrga2%EZx&l>mwGPR33FADe))2#jG#S%Y4!(?!`Ac@{*tjR6U%mM}
zF%OAY{(2%#ff~_8REMWxQ>R7HPHtl&$;Lb-8-wY1)l-}XxKXTQb^hgQG-i}+3@Up5
zD>~ac9Z+;n3P+)_&%|%k|6n*{-RrgUWtq>h5Y?k<HLH3qz9WQU<m~(cyAxmF<Lwus
zzsm*8K&#*2oc$P1>zWs0*nnRHxSIUbl&i_MgxYGdst6@!TC0io*Rq;q0S)*FH5q{v
zlbQ@6HTe)S!bOrLIu>da#ez36G*$1AwPaX4NvJI;v1FwsrAv`8mlKu?A(56m!Y^4B
zZsCh-NwSjF)tr^ei$p5v?q)5qm$l@LI5a9j(UO%IZfYW-4A+o~dC?yH^h&s8Sc*8L
zTuIt-+E(q+i6f;D;gh90u|#Sp<l+BaQft9!vrc><HT1U!sU-JFhQwAdDG1{59Y!4l
zZ^1f3lC2aFusevfW;IXz7=JCk54?a$w$fX|%y)EbLe{z{U$n~b@G80w7V~`yXC&G1
zfnpY}(DFegMJ2^XmIV&2A8b=j!Bs=h6Z88R&(++|ERDgXqud%e!U)j*5Bye@)KUcs
zj;bVtbhlfHOQ;-$pCFY8X|r|gGeL@V?Jer)sur*1DDJ*<kOzWv21S0xB@O=jidvd4
z%$=!YBkfRR@nTC6dlSfZJ82vu!!L9TX5n?Dtd#qDi0>j~k${cx{d`vAT3mtO)Uc2v
zsp!w^c`k+<tafhzv>zly&>!rDds9aW)1CL^diZTau7`g$upZH*nJCd5T9|N)V;D*G
z9po}jz7NQnd?iCisBb8Q_yBdZy%bh3SVpatQSYyXI+#%Jhbk%<?v&&A0@x)e${|1!
zjWem+e8^!C@)deR`l;c{)-eKYb5z<=s${k1299UN;S)|zvM*2}!UGW1Xz{Zb{~19)
zJHg356iuzY!;RS=a13hVk+|6^@hm0!b1fa`L449IjWN%AXG>((FjDi;5IU7Vh7V^q
z(G(hWg`J<lUOPz1KKY-?P983);LHiyM#tQTAa{j>l;GCZn-n(+Fv=>^bq8s<Lns(T
z$|s#D2xOz{N=}-k=Vigh7tV;0H8u!WWV!BqTvv*XE=v^Z1;e*Ou`XO?bJL9HNoPaw
zrq1JEgW$0w>Td_J+jXTDDpVfjNIILCmWypVN2yG>m#<?F9i_&C?fb~ACuImfM)qct
z>q#>JwL1rqS?WnkgrQS)>|G~7<t@~)T~3k?3b~?gFz(Swz0+)Ibn6V>BhHFZ^DSmL
zB(iW4E1HtTHBuvI!>7Pe@il<&4l#20kGAXBr_NI7$X}gh+ZfJu@=2I%8%>Vqs;MZ{
z6k3Tw9LuElknpRlmd^mpk^Kv&u-eHAsu$IjY@*E*b;Y_!p{WDpx_ZiW?R}{(KdNgZ
zRM1pcbqNwqny_rgWN4v_<WsN|Dn(6QgdEv=D!LpEggC+oVrq0yz#;r+Q~KE%+H@ua
zEhGhmbM+6Lm6`-3?z2j~PKg1i9A#%XaSdD>YSzH_K9Du=us@BG2<elbM<x<SJ???b
znm4dmj5UuGS1DDPgO9nc7;Z=6<3m>|!K=L+sa+!sr?o8QbysPc-~u6=EhWPGn=EC#
ztaq-sNW=ARqni{PQx^EQKzfJ6a<4I#hAZ4y&ix~Zy>NrEMD;D*xv`ALk$sNkJ$D$(
zGjHmcSAAH%U*EM@K3vI@L5A0tei0^?V&C0EqPb8@9FON^i#()4;l_B3+MX!;V4kJy
zDBRBFAiX`MVNlY4Y=hZePbocR7>%vF6l2wRlPtI;wXEj57OUA7^Tp}}#nKozVy>!z
z)$Ck{YiOGQuAu|`t*vIA2`FJ@HP63;-=}2t90o|U)%*qyM0J%y$O53Q0P2EMb{zF#
zKw^r~xEAUU#-oIl)f`NyM?>eJ9?bwry{?Az++;PqplPI+k*GfH2se$U5#V3gY|8TE
zD$BE6@kv&*#E+DA4G?jw`8EH!gnp9MZ02jRntiq+k*sErRbqQel&$7vHP=}OU{H=L
z+?xM-tEod%xYdkYs$-YDU^Q=If=N?jSj|7N$1hvW(@e+Wyrp>eFC0jH8DNx!b?HU{
zR&MN^a7*ta0C?EKDv+1g0Dy%v9Bf?Yt!6`S7WlG9-cldo_71H5-Y94<^c)Ri_e()z
z6upKEc3fjF`$(DiJ=65Nov-vpBllujA(-NjP`N-LYbGDqV@ih`UI6mngFz}wy#6eR
zo${5kUAlv~>IrbbZ~_2Roc+HRgl6@#<<iaa=F+vnf7WwqpV25$4s*k2bAQgpukT55
zN{%Kxq`5-jXR;HR!I7?p5nt{n`DAS&z&HRJHM1~`kW@Xmz-g*imk^XCFV;Zw5T!kN
zGCqu&0Q7q}>o^AHNhXNqcL)Tm#_ezDq1s=HP51{$Y1Ql-cp@}sBg0}iraUNEsV44k
zK$gXLup#~uNg$vLLhkuX@lNjO$s~bR0A@%1rRl<pt=O6iklG7F-@qsmAQ9K^;94K&
z`nLhnH2fZF`rS7WX5nlhcB2BNM0ZDW7}C*1&f|HHgIH{k)Y0YnA|yL=c6_~B$7Tmf
zp;?a4<H1#DV|~u!t@zKH$H#`Fgqg?7-ome?);x}1E%Ue<odLnVfb>=ncs!T@Pw|Qx
zt(JMb9lzw+(RzG=wH@3Q9*5xr4%ae;$GzQZ^SBh+pbZ9(*8(Z=I3I@G%;Oo@V5J$-
zBpc#!KV-ei<CE<X%`g}|u9_?JxZ1eF$h<?q<IS5C9=i`Q^LRy?!ejqX2~#0EPt)(u
zLZx?vg|jdghDlA`k4{4ydzpBg_ID6_Gfe8~^2Pf|mU%oGYuB8|dmnQiZ*k!~9)ka@
zc|2n<N|<@vH6Oo3YaU-;Zp~vAkS2$N$F2k@^Z3g0|KRZhCxypn@d15@6UOyez)x#E
zZiAWrr{UnS4oHc|k)>8Vj`5Ot9P(@hc<hKQD;^i-z3a(5Bc!*T-iNUw4IcUL3S-5x
z2x)+=@clgOtwc&qgbC2hhEY;0VJK2YMoHfa5At-Zd9)N8>b%UduG1Clq`s4C=pwB)
z*6hVIh#0L3qoppwK)|1fmSP4q+z++BTs;aJXT3Von7fmjJkTFj6IkOf&xX6(<a_dr
zXOoZtNAe`PnW8+o23MtFM;}qcwjm2oUBpPMoMMaQrU=MjA56$=UD2|E6lW_8LNmrR
zM0=iN>anaL+H<c!$IdsD&Iq$7=-7r>DK2!eXlYL;r9J6}@APQTE}VZKg##DE=J_*C
zBPm|EhSsGwk~*mLyIENyDMv^{!kGlgr)d-hFQWG$RF>wgQ1Q$1)o8<m`$X+k(q*e7
z^msA6vGj>kk2x~sQ2-*!V=L^MNIelE9R&A{1Le-sb?m)3P;QHqBXOX-3`TufJSbmN
z{yNI9E|e+%W|%^`T>>b-gLWh(NbOW>w-e<-j3r1dg&d?3`O$4g$>i6AT~x?-lW$fV
z9B!|$T<miz%xk17+{sc3^Lo3M1-AMn$n22UV=KqyHS{QJ?DiFRiq;o}kW;?;n;>>|
zT;3Sft}QHmd|te;X@ri=9G}-Z_S-+GmuYrC?`0Z3ua1SVv7C(*1agFU&0CCji}Ex$
z+_>|XAofL~)UYC=xfEurIuDeIQXA)zKZ(OrU~lN$N_nE>16b9KpbEf_vsI}#GryM7
z%zD!e)RIDsKxUx(KL=IpZ%IIZZ)6QyNkt)pe<xfS=vU?qPRmoAmvBLtp5kmZdl0E5
zp5n|zCxWp5^C`|+ua(Y6asFCqG>YTeFk1NEuaypIEd|1wMWReq*qjE5dj?XOQn}2J
z{Dsp~=ouNMbK=uVrzIKgaT|2a(CQ{NARN9uKg82oYUTYAMg<U=UOG6YumEmueXJZ$
z$K7B~i#Nwx4F}-AX_?eUq9tT!lv&nB3a`6v0MYUm){~C3k%H?*|3+21Poe(E&u;X+
z2GN=}gRRbPbn2?3w>t~HKIE&!wVv+WlA#>uSUFTV&N1*RSCGJaW(DarwDxfh{AP)j
zVxp?Ij$ZDJ5|$c`tW&oo;V~zNpvlV9oip@Qo6+F*3z7L0mIX&K@R#pD@MkBd1N!A#
zk=ZFyd-cy(;%%6eA|<8&o(zQaqUMOjFl43jQ<$#Bq)kZ1v8rzXP%{-d^2P44NDaY8
zRXS1!@mN0Twm34mn0d96VpabxVjbE^VM5kmoYHD11qhSUuq3TX_7-yRv8tWq8~+qK
zLS2#SoVExzSNWY?rQ&>evQ+7hZGnCY-piY)V}G`j{Oa9JMM6KL<}PL&uBlRJT_+T^
zJi*y^2q|uv{JLc$&~CW^0tLZb4%xJjslP_7n)xQNDj$F4O$~kmscWio0;v%`_z5IO
z)JcW>cp)_hPqmTKq^T;O3v61N)J&*1P{%f<Vdd-R0XlXu4NGDENjT${CUvVf0lGxy
za{tv8EcC%<ub50qz!jxQ6uxzaArgxUlwWq0NSY2iYwpACrPivjv+QJhsgba+KTaFA
z$7JxWWXuXXNZo{3q%7<pg?bFWLM1cCS#@bv*#XOMt6?IacaZ#WX9$}t`!JuDU#Q}&
zXn=Omv8V%Z(`)La9i&{NW*i_7#t<MK(ZM>14COj+lZsVU7kjcv9VJ8q?2GZaqtwi=
z%sD*e9EQlilga039e^UZBvJ4d2i9{bc8KgcNk<xI{ME}QtyeZWr7OO&aRLMrX6Owz
zRYP!n!>2BJ<hgMA9Dsy9?j)spUKyj4uT*F8;TLqZ(y`3WQhdXurW~9;z`%^d7p;h$
zrh~ma6{n2d0smQNDKmO(7buJpgH~=*E~O}uov5YQwCJK^zFnkN?S}P1RvvByXF@bd
zn3ua`mZB}V*p0fNj_s336O4vl*fgqXWYoNkVTJAwQ?9`|mg&1l-nmWy;;Tyecwh;)
zQ{V<-W<Y~yYZ;vI$|ynp&n;g^{xPJ|MPr|zNVF=H!||GQX|(xuLAEkoN>t51#xA5|
z^t-ClF~<xkw)qyF&Zc{5L<HR-$|$+H_c7WBJp9PTxMp09F<HP?cxFj;r-VwZ%%S8M
zlq|?b$(m-=A!}cThO82iMGA{3thlUXaKWpw)S8ha%wy?H@Pm5D@bg4&cVyIZ1uSoF
zrqBJ$0egKJcpDPuv<sng;6Mt{Gmoy)5f1@&>L8sAQnc?QjNgBCm4bzB2|DJ|O-gji
zKqJVhyYU13iL7qu82Zk*<k1Z?wimNi==vbj;5i;=kgfn+__vded1gx8T{ae(GTkY2
zVkR<2BXeCQO6qVsRW4bNGVQv<FS*!J$69oU16};Kb!LUwUFv6>c&k4MJ#8Vhm_{JF
zrnC`9O=;d+wu3*lw3lG`&909c>sUmVloK(GisD9x>9M${!<3?}Q4~*GoH_}U{7DwP
z7X}yZr!1+Ps_r!wnJs-171{&C1D#^AoM3c8QrgkZrW+U1w<uhlErkm+(Dz+?N?yVp
z%+_LhN)26F!+=-6%US-Yp^gpdDTO6&xPY+-^K&#mdD}Pf@U`Kwd_jrva^e9bA`*0W
z6vbP|_*{vi6;!mhRndN?qB&MYNAaRRWTNO#Kn4qiqAtBq^x1h!t%9kjkrI_!-FVU2
zRCF#cdcT2=jp!vs=B&0Vy8f_2@LH>)yO0R?07YvWrk8yju@dF2?`~AJL5>@@b_Ylb
z7{V~PUhgIOc>UGw74}~229kTjoaYR|-KE}=SHX7>7cJPi7Qchiq{Rz3mPn{>&1A*5
zEDT2%8G-vSkhPLD0g={f#^L0El7#-0P5mj?@Br7bl);Zb=`%HAwBcHaRhlwT#QG!6
zjgOK_-!b$JvEf4Yi~&{D0n<-X2W*NuU@x@NI8{Owo1m3KRIXL*1Fh6UxZ`MK*R_&g
z?=m}wtJJMwg&*Sv*C8|lZ+mrIh2dw{v9g}VqNgg?qV?3o(&QkXdKXrEBA?jJ6Xo<e
zNKcpF<^1g^6tBBZ3J=(KwHGu#GXghZDCz<3=@$}one(Bmz1Tt>Mvsc_I##KZ;sgu=
z?7mKl5RRaG`{qc&^%wR67Y{-ig_SfkcbbMp_#DY!7!_#42Ky}3G{b4TH^}7x8xAKN
z-)ei;b!)wRdV0sO_V@}+!1xO$VT7dy*KTr&4{U3Wl;u;5Q5W0R_2lhHda2B)vBgZ6
z-8h@<SrOYuO0`ub>}L~lC2tRh#xIPecwe;WiA%mKnPL0=jO9w<>aK^-$^*GlQ`O0x
z?0&8^RJa$SV>x{#t!mgVwyCf5fhyq`OYSG73xi=l^xN{i*eCrYPoXJ(?d%6f;qUf3
zR?|-kQ)QiGuKlGB!lDki+Jq0)4@cOt{?cG|O?x6LZM_%s7$CU|l_(HBKx&SMWY_&@
zC9vlh%pkBSSf;QN*fpd=VBL8t1hxbt4_1`sos!cNkxl~3EZG-PDNAK<3`#&q$K;>O
zT@io-KeNH0^fLM3DEghtE)9S&X?wmGdoVys5;9<Qn+%k;47>&pt=jP^&6Dl?aj@H@
zQAH1N*&77T$JU<}feR7O2?P%1sUXk+LmLrzjIM^4CTAdB(Wv|?@VfON$=~<F53)wZ
zkVXZNZeh{VdHuy+(om`KKp1M9>P#wLW;gJh6#+>y0XMLaXGOqWgxEkuU-48B&=n33
z5#T5jum<T00eve$z~ezuY(QNL0ShAx#3+S^(Lc#FI1mjpA9ETOp0%Q36w<(inA$X?
z$uy`;G`xiYlW1r~7)q1>#IlG&LqB-d?D$|QHazK^xm%fNF!!t_u(}Wu%lde{mtC2&
zc%c`2G*W6f(5C~)D#a5=V9m#8Ol09M%XFlHtZdo@v-I{Uh;@bP8}d}JrsNHotPH|X
znq1#P)?65Bwr2=flYZ7L8xvWwc-EcgtP#3Ef8&QreyaLMSmsbEOUQu#`pHm?YKsrC
znxRs*u)ZxE+F?>|?C)R8=T22qaq@f?T;qILJiJyNfVX*a)A0ftrDo&l-DcSEA0{;r
znqp|XHB4$F>}ZWeu;J2I!ub|BhA><Tk1n%o;t#435C1M#Y_hgxiGv&{yv!0VLj<Vw
z*0E-9NKJ(T6d(PD)G|16AQ%?@fTmM-(o1(l@R#`jPZvoHr@vwc-jGHJRd6k%Mo9gI
z;rJNZSMp$NgydHDyK=Hv*G6J%c7)_xaESlhFKbuv14y>o?Y_}ijH6l(_#Y;24~O_j
zfmjXwtG<mh`ULSi{s+Vs4)K-(F$tZl`XtY>yZWt3ny}sDK^>%71!%K0<6VpB#R-V*
zBc2R#p1|CPv@AtVFG9MaWxe)5oHIsBX~L9~z1Y5ylCN;;bT77I?XUnL^^B}cb$X+t
z*UV-M`$%oruu(AMJzMISG)mGHJZS;0J-b6n!Y|cTHO23v_|5m7zwL`(N6<R{Yd`%u
zD>rZ3`^2%~vX&KR{f*`&&|0jFWhP+>Fmgt$;E=5p$U6Y4PNf{YXm=g2Igge!7|)81
zTk+%sqz;~3D6`^;Ytbgsh0^40JQXaNgh7E=^0A!$A<`9=oY(=DoE<GC1T;8drQwwX
zsC0hA3DWQw=;~Cu;~51d>Ny5;!V4SO(J@k#YRg7;XN(lu?uX`R$oGHoh8+8jmVWAI
zgO$DzaPm&R0&oJU2j&Ac;-|qq;Rma|77}w(;l*W*l~SDh014mi{@u{LE?YKM$`oFp
z8&r>##tQ{GxS%vn8sHoc=U4&y!k$%)laif(2N%Kk^pe|#L-wrRcnm=jT>iB2*dcD(
zM90d;OC9QY0*Ky*cc|&jGRI4S?D2TXHFRfVQ))nsH}`4rhMB?W1}~%@4sfGi$4rod
zTBme=bzt3#A)4k%m%b!-<Zv3=gdIltf$SqvW95NtRyl5LVEu|%9iCS)#PnWmbOqi*
ztPi+Ol+sfFcBjVB<Lo>Tth|1z%$u-D`XkT2W{BifxS|T{DF@w0ET1S%_F9b$a@X>m
zmDLg~;kxUX&m<|>cf>ZLE(^2!my2dkl5$mXVEtsQBp#b2EmeP97ZZaw^02f4rs?yf
zM(Ts^NU6$`{4`DE#_ruh=sv}4hA+I_&65VI;PeB>cJ(F9dRUz)D2@~q_ha3sNN(z2
zXCx1u0vwHG9DbV#hZ>$b$5B2-@~u-AxylXm;w@98q1ga4A48@nHdc2seVwt!gXK7T
zemD;&jj?(+0*K%f;o(Gi!>b-1PIRE#iB5Erjn>a7?w1!qm3ELppw2VF-mjc+K7a0d
z@5ZYj9=NdlD7|IcQHoUZH!p8mVf9=P9>5x39$y!Ea)2dvgRRljkK(XK!!&|bj?(8#
z@pT*40_$`Hze#7j%wSf5`{3aj4JXraeWbLdDN3K)%TfB~VSaHaUka<oF+DPD-H18j
zqy=r83iZI|$Z1kT6{Znq7PL)h;wazQ`W-KU+V3qy&qHJQBzb)UnTjVHND#kbZGpJ7
zb($2W-tZYr!ue@Zq<e-vXDiKOi;kumz8=7wrem?o%N}!t=~9qqVtwQn9gR1Os(Rc2
zHhj9&MAc>hTRdHAq>8}^HeCvJ8dis6GJLrnq}~P+)xQ3${tPMHKSs_Nf($q*N!B{b
zvS&zvLT9vT(hSL86^&jzL+VfePkdVnW_90^mZ|&NB75Ci@cg56?D$(!OxQSky2o~>
z=68yBq{*oI!_;t`2Yg}FGzXl=+fqMOBuBGLU10+Z4Q2vEgpPHa31!Cr8)iy-)iEz@
zZP@5pXim6}EuAGL(Es1gk|G<AR})`v;eyZ0=v#-QJuopb)laycn+)R>I9m!)54J-!
zX|pANw=h|yT760_4oCj@*;1(bjtcpD<hvrDW2hO8d!kKoTV^(dvVw}=K(;DO$6m~q
znztIehRSPU(u|rO_-oy_Q*A6u5!t+lEO7(YvYFY24tLqOIZ{-evc`Mt(A(G?sh27g
zzWN*pmSyqFP@Zn#=m|AWG^3*;Z{K0f3#8^gZL?&`8?C0Ay%JETtmcIUFs>mcHLpQC
z4|UNv4@C;~oo%aD;DNBa1yXkvCK2rlr2thhh7gJjc`Epondm+wQ73RhDNB<uyIENX
zTZMw$R{6|@t-A6U^4T#L#wLgxo5li(()}HnnIIX-*cF^dFkIZsRF-FH>KPO17xe{1
z;(P}}ZPSx2en$#d1?t%Dccf_g|HeB~aNU#HrWMy^?@0dYkU-2=uCbi~0XF!ehGl<3
z*jr=xun@|I6iI=q0Ni*f!Za^{%#S6Lcd;U=IpwD<$?}utNv`gIA!P3^H(QO6c>wX3
zLD(dM@t0w|EHLHsa6Sq!$L2{5=>MVZCit-HTiQ9P8v_`R2~P;{bykWE{Mee6L_~J6
z6zJji(pou<C56S3ugZ^8A7oz&i2jI`Rk?IRV90BrX-@=KF5NKDztFPh#ZquMFJawa
zAmx{B0f~if!*v%UYxk}csq$5tSNJZP=PNg_&PQeztbA7rY=-1o%mXeSA)t#xdg*k`
zxN&Xrhc4F4hnC!ZSL&o{Ih(bdFKtkjPGrB%m&UmM#ClQK2#3=M8*zp8V*M9LfxbnP
z8r!Hwy8c`BAkDR)Q!4D(X$nQO{4J(mAjNsivf+k_zokgQ7qsXk=N4c_SmKJMk`gJX
zAoo-9asGr6=C?j*mYxnT-T_l}N1CcXGW1xwf_r%mgy1;3Lrt|&(;%Ann|Y*w<SJyA
zrVYU~uh&*`zwn6N*J;M<<}IuLkzertMezSDU-18K!T*ndmddro|G^@;f>$1leNPG=
zT29ZsrkA#$=@#w>W9WttX5Ck7<@fRY-}w`TSMu4AQmJW^el&uXW!u6zfpTFJA2U_i
z+2gT=U+O8W{BF6Vei(xo8x8N3&r(mLuMPLgb#<SALAv$<27ZV8<-xwUXyC<OO7fDI
zdv@ym^62_I-=Z)Qm=z-A_%DVFj@V4w_5jzJn>^Pt{r&R5`fqXocme=;YA81W`2X<?
zPp}tJh{IQ-%X7?jwJ=9h!Br2-y;RS%EbT$LU;U~X);0fHSE)I!H4tZ(G>^zE`|2?*
z(Ug7VgMix^CBI>n-Y~mXp%tb=!oz>H?Dzwa+kyj_$jvnYcx?H%Ho0WlLjDE=ew=Pi
z#v|NFks0u!4dO8T4UF$|029WoCIJ5mOiTVJ10ri-?qVt^eDYM`z>R6vRSPD7xPDLn
z2M3ndDs&JRDLB1xUY0^3*v1FjQt_X{w!XCr%`_Df&OXtyTmL{9npyxY2|)i3goXTs
zhsZyZZ%yihI;L8?J~5NJRKsiCjsKKd%W4(cVk#um0oFYa!P?Foz{J|oCIF9vkN-nh
zH}Qg~MO*Dn1q2sbc6bCjSJeVIWM`uD1iVE>sS0UHr|heh_)np8V68$0rb5EI*srX9
z1UkJqfQil|6F~iTz-p}muEFe}kKU_7_qe>+R@m!?&C)03Y3d%)@HN7omdB~<z5U$C
zbWh9MsxPO3H1TP910lze?rM~`7mg>WnA@{*FCjir$AbSYZ>gS^fP(%0E%y_CYOZ6`
zk>nVJqzvq&WY=Ls{w?<u3XyS&V2{KD*6~?+fDnbG2G7cq)b+3+z(zbPAE4gY4qx9q
zD~}Lj9pL}i>b;oid3kvAE=bQPxl;2B4$k^u%mGKfscDNpBg-jJq-SQ?+6AzTm_Qo>
z0Ge5Hv*r)6wcgKv6&Wj9lrR{-wY8}kj7zcJ<XxV@`q5?=eT0yL3U@v)Z{XenkhEU>
z?t&HYfF>ayEDEl0c~L&gR&cBbN8MQ7LcKl|)E_mLH&+jx3Kj*s>zfH}jYct1A1qX=
zbz&cVjykxJ%0}F#_Y#UR4gJ$ypCq(FC6V>@1Np}YTYUrJT><x@>gzi-Yi(}WEDt_g
zGmn#ad3360M%fqCFd}R`2Ze*q8+K16H_XA1byRLxG|C$_p&q!2=An<MBO_*`ZS_&^
z?*f<x@AE~}w#xdvZC({SReFfOUmctRQ|r^zw*yS#-#F1E{+TU7Iv4*#qgEFGm}o`(
zJ{np4j$Y6klC{BBmUX44tORurM9CSa+2DU+t4AZ9bfE4?N}qdpw;gkRR_-mhAe}41
z#zfS{6`>n_aYgu+47^zp{%CII*GWv8|Cb`{1E@t2(w?KMaz$8CCG%@K${RI#&N}u!
zR7~9;;Iby1=Z5``A!-hB%MAd$vy5=i@3a-(w!!4b5!`a|2DgSe>Km!Q$6YbD$Wb4s
z-k3mCJ3_5uVLShF)OYY*4uzq$Prd-2j-jC=y-;tDnOb^1eKU1W(x-xYdT(JDrf45h
zk_{!Drlb)_`je8jgdi!@2}zzvYU8AD7BmP+#PgNhhMMqm<cBb&TSzd@3d}JIie;vO
z!%POuRf5?UEaSP04YikGLIKmnS>G&V9Kp;z>_bP~%xFwa`5u$Exz75a$bnvflEbz5
zrI%EtSKYv=*XC97!UNt-LCBUziYPBR>-(!)HUYC*x#(Ngeb(4oQga{5k_s_g!%L)e
zG`RvZZJeoto^nZj1aS7Fi$2D~8=%xRMolM4^#m9^dmnvJMH5#&dhMUE-(R@tTc}Ii
zz(3w=(}qJ<c-*<E+8;NLdAD8pK+C(W(T{gqZ<T{iJfUx??$!|1*xBj_sB0SFi+9_R
z_jwCCHlL0p#UKqp=fbq|Kl^Pa2Q~HEGxy}yIT+%0$$Dsy^4QN(VI^Iq54W$0;h5!)
zI}*^;ad%Co2ClSKjMC2@`h~Va!+*4Ff<~XJK1gdM+cf$n>e++PykF_7e-voec)`@1
zzl~wsOW$6|@KUjBUV4qN4KtNbywJo)8Wg<frS}(dk@Uz*-&)-!66F%T(dx?)_!7OL
z%>8fiR{O9Yy!D~Yrz73ebm~+v!ltuu+!lA2Z86Cu6QJEqwm9(2U*@K7Q<{$QXgXnG
z<<HAQ?Qy+~a4U@`cwpHzfj9n{wgUZdBielz?e?Q~*D<%duesf!=62%|cDdc|O1qz6
zN=NOk`w02~g@(QQ*$Z}hCDP@_hnO25Y;L@vR^yRwYCH}8|Euu;wQBqy=EiSQ8jtd5
zJYi89A7tHlf~Urh=8b=Z#s}&HZPf!tVI}K&kbbl<^@^5t3)cIE^tqz7K`3=>4dC>D
zM#(?vCC{mwBH;KDOyvPp9IXFPc=(%^g@#}-`U)QdLiEku=KV&>Wi<RSg3cbMVnK27
zT+fOfA^MxP>O;d(&GIlk6RzLTvX<fcQR-iY$w`Bx2z|P6^17A<876tLp%MDHf_c|L
zf`CJ%HZ@!MUV;AwP7{tr*i`$xP&N?i$caQ~wO~rTcb-G4De*RT2YB%-aw0E|cw2Jf
zQ8|$pKW<9=k`kF~q`rm!scXctYlh&VwPz5RW3wTV`g`i$L*y1@v$auro#6K~X82M1
z6k+ZUT9y*6_YEHL1E+=8;Af;&e_|u{2;y-90zlKE^%I4-t6FA=)^~Bg3BFT(iGzrL
zsHGw`Mjv3S9zW0|qQB25BD!$KjQCX%?FE!wLx^bFB}GJS@WDl-z9frC+g}k;NG#fM
zxu2;WBO0L{{eIH2{f*F$s_&I{to`0xUG>ZDC;<>}$HWUtJ0c+#YDa#q(hgY>Je!ar
zc=thF&*Pv7g<t@Sha$Adk*goXh9p1}#-Fp+gotyf+FBF7I?idStqGsWiM2IBFDKU4
zgjrU_&6+UEs<>GbdQqaR2@?^ggIaX3_p6#v*%TaH*W1KFyXN5F-qTt(usJvwdQ{<{
z-O>N%VD%A&gQrd@94tO1*Y{(#iGv|6^}Yfw2(f*MdY^U%oG?eQ$fCz}^Sfr0Rb<m1
zGTqX>pK#o8(vsICWA4!zm_zcs7jpI&$Yvfb^qIC;E(9)h^J<v7SuKFo2VYiLPlLr~
ztj`SQJi@x0<`O)riH!9svaPWC3L{ZV+m`wO^&9jxfWA7?*DU&qps$bVOHE(<T2hln
z)M^rUAIwd%<Wc3^Z?LNT3uK!rACd$IYHK{g*_0>gHR=oB;A?#nT%IA6c0EadP8j;F
zmhEb#*ZMZaO&jWwA#|1ii&3|+uw?kI3UJ}A^>2C~+5{osFky@w;Q*Em5s5Zw*-zc{
zja4VK>_TgOe)O?7_$J;>t-QcRn`1aNSG&+}8?|grroOQw6p9YZ?YyXE8`|jooIdYL
z;++Re1&eaJ4Jc2=X%nd}2p@(0Z|2(;gx_t1uk5xU{2r8v6aIDVYX~2Bz(jcO^{*1%
zZoQVJXMu3&8Yet=C=tH;#{VLG>gQVKkqyF+$b@$~uVsGiKzLFYE5cLTf$-A}Q2V5I
zp!^ZhQPK{S7gAbfJ5WCNutIsSnAcE#Yp;p&U)R1$`Kh&9_IYc4BVouPg>=I}BE9L)
z|BG}rN=*Sr>xo~>wEuWk%ie1b+K+XxqJ3+7&^{yz^<Qrf+UI|TuP5z6yBnp&cL43~
zRSNCDM7)Of*%c<*r>uUJ_Q9(a+V37zXrIxKX#W~!m@kOFR$rE^QfQAnDAPUycHwC!
z(4L!WMSDnR(0(@z^=Eem?cTfbHKsFYUrA{zJA?LB`xV+JBLKuJs_wkQM7yx!Rod@-
zqR?KrPodqR57FKW*8RU}k3cET_nlwKwEu(NHZ}va8`@gYUY-Hk3xiRAWd>+pN0eO5
z0PXRV=GGOoC+t;dR|UO>_T^hmv@ibXRoV+aQfPPEqtL#zH_`qJ29y7$eaA9|_D;KH
z+KZ2A*`-X-KBJX|cBwl^cMCxE@!dgs%We3|=nm2={qa@U9i&(7Qb=EfJDRVsy)hya
z%N8bl>8qr>E>%chxl<uMCYwl~eENTp-jOM!|F}aYUGt5Wb<GCp4lOLCvy}z<c=eSQ
z7^^<b);Cct(y|}2^_|u4`~ixBdg`aE?dj{op89Z=UR!aXr@oi1`lKh4JbUZEQGK9g
zmwW5Ss0*6|LAqAo)N9#RtxfeKoEbF-QGb*2%C-7%br<@o(CUNL-4pS3Nvro$r%~Et
ztv*KGoxUP;`bc5s8ZFDzVe(LY8x_sh>0?!8+KL@I{U}?tt>%TXBDjw}QKc%;viS@2
zp=^3zeSP(VgR6|p-C>a*`)PsROI;@($g2A4!_;lP@#RyZkMwoe2;P?Mi})PFe|p)b
zh$I{~Gkk>*dMvUZCNXu&w5(@8y-%H*g=oT9wz5RupPlH3NkDx>!C-?2=rh>L>-u0e
zt-t=N{c%?;zm<K;x?k6~WU2l2-t1zj{%!UBby~zUpN>VPElczfY{)=;bM-MFjD$-E
zg5+YYRHn~jL4))ks3+G4UE2ofebx12<83OwAEcjbD|kXpPL=C56}dz7?XhgOL;3mT
zQ2IG!yYka%xc-nzUFHV7=SJu!sAg$dzNla2iHUkbWhR<732qOL-M_U9!(c;6zlUud
z1ws~}K!stH{%c$H*Dff#d5r!Wb*r|3nY&8goNXMd5A$}#ZDxMh<EQ{P0VDby!@lpp
z^54dS0`)^9iVgZm@5h$^s-IbLaJ=4VtD351m2X0*%Qrv-E8G_OvS)AVy){lMoL(vE
z0OwX_xncJSurX$$zCn;MgS31eKUGLWscUg3covw28a0OLS~hW_euR2K9aQzxL~w1g
zw!(FiKHpYtpri$P`h)5b%}qoXOh(NqM}c|uWPLZ)BrPjn4H>yi(brLbP6Kz3)%tdV
zIFYA^I(5QfHJXsLqO2EF7WuFhQ}mD2?>+)%NVqX`owmrQ;@VXGa$EJ?wP;V_G^nQM
z=lI$*O`oDkd>U7~QTGl3QPnKWZ=XVc0;lVv{N3@!oOSE+@xU@#_H?4wM*6U|kMQ#}
zE!+B;K9OynuD36k>c$WGEQrA&pGa^VF_*rC{ykBV1d|ix++LL1f#;rDjNHp|Zjzjv
zX(@Ye8*=x{xldd<W-m+G#Z-2Mocm19EpW3G-bsb$%Gvwn>`T$+iu+LE;gpMzDM6sE
zU0sg9WgtN0Am;O^=cEz{-R(Y)li{<F5XUhpN^pG5D(Kfdxf7NyiD3Ia*E_Sy8G1+c
zed71`GxQ;y=DY;76+Jey<VN)`HS&bX&9Diu{8|U?9pZJci`9wz2$fPxG7zw>pX(97
z=Ph6!NtpY+rT14qTCHTbd}}b_3ZdMUl)H^`55A=jFSzvSDq|*YP2*Ane|_wy>Zm^n
zUZamfYia(#Wm;N-_Ek_nDbw7km6Jy~%jFz9Vj`76Z^Em-lv5<<^tY5jPBL<8#sk%W
z=19lt1{g?5{g5=w0*QDpo|N1H$-_AyQpg&fT(1vvA7KGR`BMwD%(!0f<1%#$YQ_3A
z^eYd8+U>WI)`Qa4^0aP9>$XAP$i<V=_JcZHl0jOJnR=g~haYNbHJmy!miufBUc+r|
zs&V28Fqc2nvUxN0J6r<Bq1*$W=8Lq>v-IIEHDi%xhn|gYjWKLGrR}9Otj!{=0%_Ma
zV!(_e|B&~gB#?V;mOie*_xoNLs{=V$2MmeUwQr}aPCP3H7~b5ZZ_;$je2Zx}j0M2F
z%dW-tXjwIuf#fCJ?Y3q^lmP(7X6w7B?uMUP%>Y6bU^bVYgO<(b92v-XwU)icbmMol
z3$T4F7vwd=Eb>vcU+BYi@5)PrK@PNz;vknZGiwGM$c&;Fc9Xr+u{NBVVR}21Z)`3`
zQG%pXsD@7lqH<Ch1Syxa?BhB50O4a8uCM0k8`hr)>%rqYA(pAcDPyM}j0tCc1sGTd
z?*S=k1^O;Nzttfcz87iT=NSH)=MsFJue8UQ^Fsl~`C(e7F2p$Bi(JGWg&5~AklT8^
z5aawXZN=?E8s|U039H!g9gOpXm2p1X4hUuxVVoa37xcUcvl{19D6g^z<apE9A4M?C
zfpzfpe}sK^K$OSxH{2bH3Igg0C@5XP1}b(GtcRlF9d>Lnwy3f9avCv;c>3HEy@$lE
ziLsYxf>EQ`OEhZKSYwR}VoNlZSnmDI?sNA%l<)8T2li%WXJ%(-XLk45XP?sP$n!n~
zi%dr_4Wv?PI`VvbWDb_+f5yc_Qg%A>e4o_pztSnspNH)1PG4H<YcxGsp0BGrBw%zZ
zDgKfR`1~^uDL(EczG=u({N<^NA2?I|e3}?`%|PC{)SE}<H!w2KJ5zC9k&Wa%y;G&-
z8P*lLJ9p4%A=8oUzn_m}pLP2KOZHn!i|S;55NWJnve!%N7NFS@E*OwbE<o<;LK**N
z@UUmKAtpcXZ{*Yt8MjePJl@&`k95)dZg<|*cFDF|tYclZ{~-IZ{6BvYCH$-jsoD71
z%~jiMyo_ijT90USJ?}t3i6uz=9a!q$R>BfE;b$n0WdB6h1=#G$66N_tw?KF&%X&;Z
zaCoXTb2YNgt*?>hudghU=I5<In)myL()^)wFh0`!5{;%+s`T%2G-=3G7+*>5uD1&1
z!P!e;<lZY_<lhY3$S0geZsSPqI}NGQw=0m`O_!mT=Smo;WvYba-Z^{8N^6*_ZYRNi
zS!K=9F8Y+Io2qlq0^=*Ik=qm0xqXZXFmii>435%i3BpqPr8P+DDJRf|b8D^lTy;NB
zfbJ}j|2YXImdGP77iz$s#i-7L(BVFEBEObUuqARLKMXKS<lnbtiM**f{tlQ~^qt>!
zcI5C^UtoC1IsD^ohOJCkp2M>~1y;`CuDq^Zsk?{j$~pWHuY2o_vu+yIm2>z}jx}E;
zG@m@opvrO%|B|EEDwTt%vO0&mUt_wtJOu-u!#iM%6v*K(lL07@!^LsM<nXe$9yk)}
zUb45_dTWrbEhwd^_0}r7@dRtX9!a(Y!6-ME{o$dbMs31c37a#PV?#sp#urZU`aGhS
zQ~VSnM6ULiyf#=%o7aN6V8RaO3A^WOG|ic?Q+uK@a>CwS0MnQ-a>D-2fnf<dh%j=(
z4s&2wb}j)7OW5J{0B4|=J>-O4U7<vJ{*%Czuxl_vKz{8ZC+u1ZArf{Lz${_Mw}Moj
zup1AP6SgnGc*3p#7$xkeKU)IE6ZSRaR&}QQuPzeGRhG>Te3mM$+GzFDev881jY!z{
zo1orfmPYRmO_io^LUP_kFnsq1$zum#TM0IsV0bzQ*i67!!hW;RF;-lmZpF<=*pdaA
z6p!aX<}tLO8q)~XjG_J>!V|X7r0z<f&aDdqY0GA7pspO1e%oyApqrJ6Qq?V1-zpJ9
z7(1L&DV%|mi6(4@HKgl`Zaf7)y|M!7@5<nU3K$mrA1QbMsyb8f=eUVnPQhOdmQ(O>
z#GU*tNWsl9?&TERluO_#xZPIdyxQ}j%jm60!MiS#4l4#x3eLh`X9_;I6-(`JuOL_H
zwpn8|byKDK+pODk+4E2{Z=1EUrcP>hiS5=7uDX+Z5Xup|T4yiYVV$DU)Jm27c0owu
zK=^#~UDixpIb2X9{kF?`Qd2Wk`uayaOFR2J7{C3|8dE91BlH~Si`<gw5q8{F&N6!m
z-|{DGHJw1E&ws+8lrEqo5Nrm)_Woq8uA57xM?WDw|CpF6xz-UI>4K?OI%Ok0S5M8J
zmTjHtstbqw?037Z=^9P7RB6^;R6N(4M($oL+i#o!i~POTYWfBTDat0YHQ;Ux!rY&y
zgH^SC*61qQ>O8nAxwsAj5MKjEV-2_u!Qem+7%kj~S?#BkR50`zld8nz;67_a<cMg_
zBv;Nga)j<mU{EKZ?YY*ep!WL3I$Jk?D~x9Q#d=A%12?QnBlla+=x%RDDdB+iC!OgR
z2>b5<b~E1oh%7WX2iYkEPxErDr?i`qriLA~4%2<P3#e-cfeK2Md=6O;=qK+f)WkBA
zAn*Pm<jgC_z|sA%HM)LC7}s-mK|RYbaH}u_pNzCCO$LDTynz0BO-oCCk66R97aX?k
z)#$>1fZ+DWtoyWX&2dVitynQT=(sh@Rrl={AoiWGHqiKEbhZ?yW{)~)b#v9dCivu2
z*3Y%SR8Gx)bc!Au4cZJ?>C@Ju+W1C{Nh7Ju8MH-@qfG`eT-RkVR3CN*fxGi?lop+_
zc6Q=^9OS_57=}{q->l8d`+jEG<J@^?`WfE~nm<Lz!TNAI$9_Xtp7(s?fj!5uGdXs#
zQnwM+{efc>Ikt~d_j*%c7jtYYjx~2zDu19LJ%OX$I66eBypk$+C#<}7o%;jR+<eTL
z_fE%wB#ubrwd>e$0O*mY)9-vb@VrM(XrQ(0u(O!iK1_z+XPmVL>kd(A>sf1%c@T+4
zRqoHb>w=RNzYzbwJtt$Z+(487CVvXRZjK5JJeR-&0AA>z#{Dh?!+i&O5itH`vwj3>
z3Xr6bB@@hyqagaFPP#?})8iIPKz~$7LjY!X_u>s0k1(LU=FpcKSsFVQ2$lP?n0**Y
zhreFq#b}Zk4K_5^5KR+Cv$7zKbo!jNbkq#O;|L4l;8c!hV-kSerJjhh^b#rV%ES!Q
zeh!(bH42r^TbGwzu1CF6m^0e--(cJwJ&!CjoL~~;H59N{fK_iou(Ax+5J@mUklmDo
zQBM-q!Iks=W)do+LaX1cQ9j?-;bDOVkx$6iXZ&sr2x~#4_Zew+3-F=VGGoc%CWI*W
z|BeGWPpG85fOt7(AWF3^;0c_*1-4Z$SR-^b2sG}3H7sOWELjZSDEomj!B2_Ie$KW>
z&_LRA!5ZinPjm=Vx8WMO26sHOZ-ZlDh`P@%Slg8y@F~>d%RxWDtZD13NuOV|R@Y+w
zDJ{E5i$jd~y%()P`pN!WV8#v-I2L(|&U8M%h<uX;N0-7bVUT;KO1&;&$@lIP$p7w=
zb(C%{mHhv(25LM~vm5?lE$OOTE+8DXylnkhQ#w`pc-h)lH+VZ3^uJ=Q<vXVa?45xd
z%#@`|cS5eaVhz*9Q0ccT2-=Nzp!9@FH3{Z%)f%O1NTo(skyHj%O_lmzMUuGq8H6vp
zilkC1HT&dM>u^`yLlQosySO0x=ymH4t{OM&wU-owrEmVk2Jg8h7+hHW)zCfM1ZKDY
zL_Q4o3Z)_LVz^Ik1UDt^?dGoS1=jI5u@-si4ls6`uE4@P#+JY#B$i|@xMSzyruA!`
zeF0Kg@GWb&tL~3XDA4Y<^`N#?7*bFfv5Pd|4jzc!S&X=8z5^q=rb@mZVrq8jyR;#>
zd>-g&J2V^Hp~%zkO_KiuM9-FWp(_?kvHBhJDLb@QHbHxvpxf*R*l%9%k}7R`fc<8R
z3+%c=s_i4Tl)N9(^VdZXSK}eXy)#KieZ;QP&kwDWDm|T7+a>RFwt{@9bitC<SUtAS
zwT8NCAJj<A9-U`R)#$p-gkspwtRwZUC^pHi|Csu=b|%;+KCvFteYg7^9?kiQjigpj
zk*6lNhfaf^TJPw>GC-32%z9R5#Vwkgr2BJgRlk8rAMKFIwuIraF_c(+3|KHOdQOJ$
zqr;r;|5!Iw8a{(JIN35htRXo!>yc29N@xDDhS&P!C9adB{Xe-!<c!^(fpL#4^%B7_
z6>fmm2feU1);u#wX)oYK4HCiSc_21zSHG}E%HUw>@e8ZF?nHu&%l3Y0wYcgI%tT98
z|BJNv#FTyQU+Y3woo*ID!(UscYHMQ7^60fS+5BP=O9Lg>BPjFr(`Jmxyk3YPNMO4-
z_Wbw2@&wkgJh1T`o6WJm5|-B;MRjSajJlIJc8OBA9MyH@*r^<AUZhm6N0sj(3ZZgS
zj_#pU{-YeQM+qw@u>Eibg!7-4K{{W!X+1!)hDhWDw(*?_X$JthVpi^mHlgaJn^f;D
zp1219CZ)c`c=|U4B`lQvq_5t>4-eAMZEq3VBq}9_iTFwa>4Zi=3cAQr3NqR2u@?R0
zbxsU2+gQSUL39@V<pP)<z~m1DxSs>edb<UIagnpWKfnwULy#7L3|0uuSULF<ygJ}R
z7$qPj3F5!gl^Ux5LZOC+j}ZYV$+cpadY0MgI-cDb)X%OLU*NXE7WiL@f+ykeA}H{D
zw|*S3u}|{qqN#TMNGFN(`ai2z+m1luI-@)fhBYuOZqdZJ03dhBJ?uM<gWa)}UkKHK
zQ0o|~T%}a0!#nHhvV-!`O;K7RAAo@V{vFa?9Km?{tpixi_twz%I)cq)5?vAR^W*d8
zux?NUe-@97!F9UjM~zZYoe0&ERX*aEDlL6)t?ko}f}_JR+&~~*e~)Nzw<$^=-&>;s
zjsk|S6^*HI@V-|5pc3v1!q)*VmQ0meez2O%C7OUO?VpmYOu9vM@gHd69M-}OzDx%k
z-D?E`+CA-H*-E>oh`+g~8-K*nwWs+H@xGx~dMYX;4Sh{WSrB?PxFprb=LF_aR_n#N
zIj#IFM8_!`t0@IHRv(n$Z94~!xqttOJz%6(f6hW$eis|3BR*O~-94ZM<ydK<c}Jv_
z^U)gZIi?~l+=k;X+9X;2PWSU_{fw@_lzZ3Zv=sAVc!eq<1cY{V=8|>+pjWnv>5VE%
zzR4J*Qo0?1{GLhLYe({3+VG=&iJLe|SB(mj#X!wn(~nsqqI3KpgwVCF;?J7fCZ2gq
zeu>%#HDWE_a192NP$2WZnFC}Atr(^|N2OX?v9j(ORp>yaGXxv16{B=lsPwf~4A++U
z*TggLI0}{TwPJP6O;dK1PDJLN3*p&cyNS&;n(HP?x^;CUeK6!%zWs6*SR}fOp}PCy
zP-6LZ?t5+$7TsIKg5e5xF{+B?CXen)zAfX(w_|Rar2FpT*SZy-K-L$fMC9A?{n6%4
zrNx8V^>0m-Z%626euf}@yNnp8`NNcrRD04@*OX42(r)DUlgo-4&F>~@s<#-VyW<W8
zS(2SRyik&ThchM8eQz;J+vX3G<l`gyX{)19!$<6+`~6c0Sm*-*=UH<7t<q1QA+L@t
zoLB2kL|)xeP7HI^e)YnXeX+dQMWcJs1*%|kxK1|mDmF@g?FVMx`HIK2tDc|%eqs+@
z1)QspPWy>>bO-tXxx-&Pr_IEh^FTJ1_E!?CR<`5xLg8GxDG-jh5Qj)Bh+)|QmBmi3
zx*eS$Yh-}9sZ#BJ#pTp}sKRsVyOZ4Ng>vd&3|ug$o;$~KY9nopqb#WgdtCmHo`}BA
zJy#LzkX#cqM`X<O_Z-t-#`tAVtRf<hcI%3El?oCYXb!<w{<TWd)gbY;ZW)1*UIV1(
z!D3%+7qCH&4U)!$h&9Za16jISIo+8oTVZrN5^XZa4kav4v=4F-?Bqn-iDL&Sb=|41
zoM^o{wx&{dBh{4?ZF!D0S5qpVMrd#(+KZnuwf>&w6#O|=Rwvr7eHcl{F(BcIcIh3E
zs1t3A^8ge|v^U?ZQa$ICmW7G|x?O-t`$930EL38N_Fbsxr|UsKeZ#~EU2Q6{M0<gB
zLcm6lK^hCc1rc(h^-(ZLv}FkM1<_gbBMV^u#$aTL_RUn86-%qv2uz9gEx-(Nf*_P=
z?Fu0!+8qR^MC$^+?9l8=f;bXwC5JS|Bps;Y6Kyp7kP>b5bBdUS6RiiZ&O}?%Nx~AX
z&w~@{M0*<(L36n1SLG;+y-Iewk9`$6t!@O(kKy9#vLAC`msplo-#s-+pGJtGWzP_7
zFw26c09yiB`(*^1$6#MSg`!2%ss<Ns=T%@76G5R)s}IWo)t;f!z>v~vy}N&c#*tQ+
zg8*Nv@|uGOi(EzZ@{&c*DIk#sRTHBEdP7jL`F8l9CTUYO(G;}88}e4F^KFgI;A>&|
zHW4AHN~9QKP6O5dC%5jnK@GW;>)MC1SN`LI&FX~%FaI;OPN1r2A4{#XcJkD^LFRy&
z{cUN@-J!VkHc||AUxrgMN`8%r5~Dpepv32<Fqv`Y*Goq@M>cyBR`dM&0|BAop)}HP
zGw2KCSGJk@yf^aE%P28Mv)d#^M2p*W$30=ptI=X*O|~ifRkVoB)T_-AM;&K7{Ie}J
z#7P>>PLou!HU^^c5yl&KREJC7)E2AiLK}kim)hb<%?~ENt$Mo~MC8VZF_qq5fTI-I
zRy|GlI<aCk-D)cJjuoru)^|tAOt3`++ZZcW*JV-ZYAo{bv12B_ty+gV9^0zX+Vt%v
z3Hz#3vhUXsU0rqcp+)wiy5ek&X0wSlSN)}V^~G|!yLX{1+hKib1UI(BTD39d2GtJh
zuNrXGHxQ$%=(ody=#V!E4t()j*RjL;-!_xfy8$K&-!}pyw!=E%4DSTCITA}uXoof0
zyp1!-m6^!X;~@lw6R;iDwJzx8uOy#etjSXQhGLv<SzVYhy`gwXceoBpy&H*VbpPP;
z9@=R2m0C9zSL&M7hhXfsc9t47K?E$*1j(aI6J+J@O|<3OS^BeyI9a>@go*ZDQ=|<|
zp=?$o5S?fWqVJH^58)(L$9Qp+zJJ|9CJ6ihQEUhHQF}<C9oUBTHt=>JQZQr4?FeLG
z=MHRp#}2F;Y?l|0UsCfHVtDrSX5vp8U84q&-yl)ktJ{MwK4rg36gRu-_S6AzT}x!c
zm8NX$zkcbeD_Iwyp{>QwweeT6_-rj=>vcjbVE?rdkLaHE!OHr=X=_92zqV+~HzvOK
zI_NQ!W_z!n{EgBKgV@=LJC^Uj9eR#Zl_as5`AjpGm+o{$Z0F0*FK<I<dGB>0$8I7l
z&!~}yfR*=NtsMKEQnww|mG@qa96M5}`}iQR^4@C~jx`TeDwn0o^4@Djj;^az-cFU(
zd#_mynC3!z=*BbZpL;-}-g`~o2ta|o*O1?NK6UQB_G~9s(!Dv45izNq7_7TMCG5TW
zo7pvK7X3uh0CAC48@NVbHyB#+3)$?)E;0t;1?RVcVOy{j9TgZji@*awz0yIAZ|)I{
zwqVx+#<yTc6Nt88*E`6}c71OG(iZGyCtW)N$y>0;9HjVq5y1az3-<CFsLa=Z7m*_o
zEop&Ta0_-P(eN$U?J|vY^qkcvY7rs$-s=L6V51e8DtEJpjKTL_N1rrFPupX5+!cjV
z$>Q>|TfafQ(kyFk!r0rDjI24GU|B55O#$paVAYce=EY!1$k7G&UbErKdH=ASR09>*
z-s|pc9xzyV8B4xCqJtO^W+KuDjP%5D@S$d^_g?D~<(3X&qV6M={^@|AI{OhyfgMGE
zZNzbt)TkpsO$o&IUKjjCrn;4TqXDH2#9HF$Y<qngNNn%51JNOX-G)!(cDL{>HWQ)w
zR!6a2*|B)<LEd|f1dQ#y_UR;6*IvN1neDx9UV)U{Net3wtl$E_u1^AIA4P{^@AY;k
zF-G?n99^oABG%Q2CMhXJ+^qZlA>_YJ!LrY4%J%ClR&~|gKfcPI-NXoxF1<XkX{lHO
zT1=8}7jb~D9YUKlql;KuI~Wmrdl#{Su0DZIbP*$~m3G9v<B8r)(2P8OLmysTa6a_&
zt_Nb@uE=cmIw&>nD%RAMAO^#_ilN&2YtXc=Vq@LvClGwLD^`S=rtJ4!#Su7(0bR1O
z7u!UmnP-wV_C#~m?C0snPkPl;^z;6)77x3)usLsjAR=Y$Nn%A^z8>6@CW#^bdp2+j
zvk{9ksRlZ3JK`oJjqN1{SI)@<8m~q8@znG+|6G7wzdq9>ZR;hj)}8hO>FtkVJ85Q>
zME~sUG||UZm%0zuI^A3R*;OZbK*Nl_qOV4GdXGH#rC<7srFH*;Ncy!u{Gz58w0YGZ
zS@$j4TICaQsP0mE1met35P4^sq(h&Gmvt>8u+m#TK>XHKSJ?;1)&s>6?$b%T^swF1
z)Fsvk>GnWzHjdbo#0S_U;iR>Zv}TaFL+20b>~4d_ZFsVV@9RjVhl(e3*P4Rn%ouD^
zJ{>By^xbs!13Rebew=Tf;yi8l-_S6_XW}B=lB+0P{|t7YXv%gUCMID;X$Q|P!^PDa
z%~+H4=5sMpm$nhj!5qa;YC2L3)E#q0n|h<<^UV^)!ns{efmh~8F<85PA}lyk)N2J4
zj*k>WwAGi$jW1aOYW5g~#*Z;&3!|u`M-s?&3^c!2muo&oGtwj_j>Yr9t_Q&rhirU3
zog>J244{Q$#Y7@HKNdR-hjP#lICpc^RoD6zl)pY+^w8+$e9ODUPts0;*M7GSKPyiX
zqjlHb)RG-!!vgxi2)`kh__NS3{1Et0pCMK*JD$*V1hd1OC*!J1vwDf;Yc2j<<uq~%
zpUGh9?4n)A?lDH<(D8_Elf=g6$8fZ~4LCW9_ZIV}zoR20@lVRK6y#bBnSdwHb(HXL
zBA@|#mSgWlII;5xo5QgJ$8I4kPp#1+uxmJW496~VV$FIFLZ@@|c#h6cSl1%fgE+Q6
z$C{j#_2;a>;$kzl@0$qSc9&$DZ?6pLJb8YY50Y@1q&7&Fa1skAiK30gYea*qvJedU
z!Q5F>0HDWX4#21>CaKdD(N|Yu4SMRcDcD$AxDq9CidawAl}e|kU}{^BN{^?Y+e=c(
ze=1=2S8!N>)NQKhY2J;WhD`n#&XBnvjI>YA$jw`Ok4&#G6%Nhu_y92Ul6D^SSc+f3
z3@(7ln+wb=j+ySju(j}6VDdjhg+Ib%Rt&tGz$SwkCvhEcwq{*Ta7xiR05i%(1c?UZ
zCLoMvIzjwc;?ch?P<sF{^nS=uB;T?u`9?7_-oi=GG0?Cwe%bYIUz_OU4JGI*UUQ<!
zu5f7D&cqugqe14&QrxX9lQeUhSh>~D1Ut=OKV`A1&H?sEe?;=hjO)@usJ(>Z0%wBL
zt!ZMuw%uHlbY{9(vtG}kU^$#+?rsuisYF*Fz}Y;g9#Lr-Rjg!^YRwRX%9bG51SU}n
zSlSE(nX&uiVW^$<CDyew#Hc90y~v4tK4P&I)cFI>tK`jP9LCs8(vultw9kh*s^GMn
z4zxs?#X3HF)Zp<19%dF3bbs$gX`5N}4_J(#22%?1VV}KZL`vxUh~h7^7!pzzEU@K}
z+ouF&Tmz?f+HW@<gN&Rh21K1pCk^Ogj+?z;xJ#@zw1vpW68VUkVr9PtPV#Sv{30Vi
zu-Jqv)WiU7)(DeyV5S&dZrBJ|Yd%8`S<F<GM*g+lPbxo43@J4@`-43{5$bbT*I8n;
z*JB;2`NvnZ>^=9DNm?`uN!TR-u{LLxcuLdHBrW(ttQ+*_k4O}_&~nxhTCX{-5+eOm
za${+P-TFeT9o!MIgiUA&Jd0Jim7Am`33Y+Ott*Uu3cmD=JJrCxkIX(EUyJ=;?5)dW
z_90sZ75h6l<3pC;;7aVj0*Yof2}{Hntsk`4&Jj=Rp7^44VUBn}7fmJGmnaRch*FQa
zD1EC(DPSH-cPgNCi%M0fv?c?kUgc35IA1)d>Bg1RCDO5+#Fd}xam^$(P+S7VW@KWb
zKaNVvsMM88dr&erM2Th)xF|i9J`j-{);;ePi|<soQZd-2*wN&i-!Cp&HvzAPbL`Dx
zusDw_V{?E-Vv<Y?#9CFaBY-(Or0iyHu|M7}hsAP$B6HQ&J@H0MFD!t)0;#mtg4Xx+
zLTS)Kl%%pKMJ<9IOtKxOub1tBMFh3wH=(Gun4ih|YzJ2AC%`r$m1a<B9F>*{Vr=Ll
za%=vLx0KvN-*W}$|4Ryv1B$(s&y=(*gwKRpq2w<XlwMe&+J6gB`bk8o0hK0y1tmMm
zO4j_gppr8d{9j7;1C}e<f=W!uFe))6o6l4!Ic6<avhm-fWEfD2lJWDQ#@HoLas)l9
zZfS!;?PY}qtS;z1yE4E&O@cLSRGK1*vEe&tUgxmJU#qyF%}+^?4JiJsiu<@5dPSQ>
zKCVOQLKY+?$&xOtC@3jxu0v7@DltjHQ&o~uQGte1z+;kB0w`Hhzi-69b!DzYK$oR>
zrqSsMCP$N(Vy|Nmm9mzKA(g*r4@QpnhrQ-BK$rz9TwmYblznNb=;x|4Q~ke}iN~~E
zhM1&1%Q2(x`3TkDEEj{#-Y6l}g=vs0`Bdj5CPeIh;fr|;^|vcfd?xcbf*aPOmUya<
zS|zAf0~YK|Kmp<b2w(b!45a9%dbK%;sr9P?+?(Ni>jeCFNh+0b3?Fexah+I03LY}K
zyrvZ%LiJl$-lu&l3gWMGmp&wm%$dN!<*NaVxf|-@X(;|8;@DP-FLguyKoj4r#6o{l
zE?O423MM*4rKYPezkSsP)mLH0d$Wxxd-5t#bk+5z3SMi(v)Wn%Owye-VzMsyKImiD
z!X}shVy(-6pW?8I@TF{%r5v@JP~0YQLu8v!eOTZOp}0*d0R_kfKn$7F=n9A2zD}bg
zu*qn5W)y2nu<u~kTaov1(dYTKSdmm|Zjx43ZRYQzY0gbyyi2BNI+}wkTxmu|sDv7L
z-v@u$AV~RE{JV7J^Y559ebrFvwG{5%_Z}KH^gEbj0+r@{2d~+fSio!QJG@3rG-V(C
zj=W|OxJY-_iAQxM?Em4yyzg<+bJ%UvXKoXW5}FqG#%ZE!vt$$9zr|1*LU9wB2goL(
z`l#hgC~l%pfdV8D5bid0dpRw{U!&)4a|5j<x4AK#ER<Bm={Ds0-I*!jm(#+!<Gt6$
zvJa&-=7!t+CmX-RIk-YYfbsDiFhYpKUuL-H>#^RN3eBb28^o~6TjIHSSSNYS8HgDX
zn;$KS$D(k9*iYB^G^`V`5!2h5H*2|M8#an-U3Iev_-vE-o9@|LnC#$Ycva$c@buXt
z)-!*K5}NA$!rA!VeW>yAzg}aATmLw1nLbUn<sy#SOek*4DAb`LsJ{)E>{b7E0Uvt8
z-YQJ?DyHm;M&JUkS}~YxCLP%Vuc{s=dzDul)wz}1_X-&&X|N2wUysaE4K?t99e)K3
zugj9}HZibt<Z<p+t7=IfSHhWwT}8`!Z$s$|Doxvlk@iyqleBspM%s!7rtF`$(MStM
zHL24M7-i8*7$x`zvAyo@B~)NTEej<yX7dwg+dEH`+n&ZzlL^J!{;Ip|M^qoR77~j4
z(RH8zSqzA5lnp6PM^X<pBN|9XF@C~~!iE|?PtS+i;o96|%3mO(eCW@?`mX`TyKMdG
z?<M@@_wx!n5qPfPBfiqST?jmtFQQE>@YJCa3p|7B$bqM09aDCxAITi&sR9c;E08H!
z;IW=_SfedUXhpAFr!`!#h+x6E3`a#0id*A5lWYyDk6Q7B;?|fC6d)}Dk*(1kSwfD+
zYHPTnWn>N4-ikFAM$6V1Ltk%43_f&*tg$(bgDV&Sw(IAo(cg6ZW#b3NxFYTTSqvyW
zZy$FPmoRDJE;z@pzoB)^P3}^Oxk<&EvYULYVao2YhwL&7)wr8H%X7F%i(egvd2@<2
z(c_-eFgqv^&@K4;IO^(Mr(wEwlnq1mVTPxK;)ZDg6d*4FkquL-O|gdgA&ML3hi-~t
zn&X@3EFy=7bHj{1L5As#=_!G+G9;5UK@EKM3V*qq#OxPC$^$b9x(<lIe|&%H-SOpi
z>H7m>jo?T`7M22xAi?*WHbFBlpV<V)wYppGrbs{R$AgX@p(bfmju<3$JRp|wEsyGO
zPmFrynHSByM;#Eu%HwP1Bq|s>lBl1LaZ&Ysfq;OacbEXWss#du-AR#N9)JMf5GJ5z
z`Ljof_s^-Q?R+y~dk*-9aK3klKln}to%AqAtnVAl_(t7keCc8t@U4D3MXGlYd@l#d
zd>0)dzLVjY3g71k!8eHWT}}MKw-M;1YKOoV2<V%4lkufX=D;`qW{NcK5co<}P15s2
zV$JfM4in!-Mm67ae*FWb4u{2x<*Rb$M(9Y)A02YoJ;7hLdm>06=9@p67y?7gvOiO#
z!-pZpP=%=<9^lUDb6vmz*ApYQD5jTY9zi>*a8W+g9*Ej-5Tde=pdCO!K#v=|9oXfB
zfL=FJB;8R6C>dyyW*!x58V=+T;|-lq+hKR*wsCy;EEl^0Ng1!`e%*|Rd*~OQ?FVw1
z7f3c_4g(MFR)lA6btr&IuY8?JCorT3UQdx)9E0?em1VcOc}y%5Jo^BtFakqFX&c;%
z-87x?E;lShI@L-D(>#cm?tJ-K1xeRhsNlB`iIQT32kI)daKI_1wNRymrRIX*^LFV-
zSE0QInbW7e5E_6A&YSHEUqtPwbt8yswG-NDzif&~(OL)z?BDeNs+W?JMAB+dy}vpO
z?X{Ph@OlB;oBXeO30Qr3Bt&`4!~8YLekOPCm=Aa|x><<P)<$L5w5H{yUYmuAx?Thy
zzgY<J|C3E9?721fk)eDMQXN;Gr<@WyYW%Pla7wJDdrG%4{(efV5pwhM57<^@-@Cnl
zA{naJUaH%=9o5CTH!0{>F;%;&kx82Ps~G0pc_h6_iam*BOZc41c*wfxS8-~kW2j5H
zy4fD88<|9P)1fu0%MITbfQDBvq2U7?$_-Cw_<uBfm5KF^2UR;_6548iro;_9doONK
zpqd~FXRy67L~oLUUpA?%ZHGehmre9l=!+P*E&LYr(Q_A=w41d1q%GVB-9LX!MCtk_
zTs6*`Y1?4(^*mF7f-gSUnfw_Hbmu_xN|n|TXf|Dq+~+VEim;V{&DTo7e|%N3+yvms
zYR9sP_jbf;9R7;;)6_RfpZ}LqsYVP$;C^W)Lm4joa{hX-u_2Rv%o9gI(Y_tsg&-*>
zRXC&d#VknZA}rNf`(l%;t599rz8-eAx(ao)6;ZHu6?_BIFhNMp9P6HpyV&WY2hBTJ
z2Dv9&YCiUb%~D&#H*Iy{(%l6AfGKqusR5)ZMA}#;{ftQ4bQ9WW{Xn`1q}unG5p3!v
zRMlQX;Y>H&`njtP8Z~;4P{l_?30FDaM!(V>6iX{gq1}aAS`#Qo_Yo>cL%Iu5LFI`E
z78$T}Ik{GTZI;#LR=xr$S{WJfqAG0YPIxb7*1hzx#N6f8;769d+o^o83i`m_9e3zH
zgAL|g5DhV{VqvgZhe<wpTOj+A(d*nfKP<;S%3c~K_-2M1JAeuAkA(?)2%&+0$B>zK
z<`8<$tMQrnD{&kt(c#|bP9{cq&>kI)u<D=ENV+K2(2k8^Bdmh7`=aRI`Bz+tnUwK3
z|ABmYr`|C1Io078cao0<LkQVq^bYcaUJ2?DB^2)Xixs5vDWB=Je_~qKr&N<*spdhU
zr0x_oIHIR8U3ax2O5gVs;<RsSVVkt4uuL0^bTXqC{Gd7@n|r|zUSW!Irx*O7DW*8^
zgCKNnq}mTo`_Pa}!;l*fQtN*BL64e@v>!-^5NW*Z2T4RKr3p#emo-e%xiho;wO3HE
zrwRBzOU*;xz*gxkwAPLWaPudv{Uvj6p@g;*e(gB`SE-4@jRQicwj>JYdJ9#3?pKE(
z%if0QNV3XPFIyiWNV}^#TC>VjS!+Wfv5!zwI|v21PP{e(g&lo_2<-<<?wmGh|Hz*?
z1Z~0RHmh97WhN0cD~M67r}92ulrv{vL76SM@YH87{XjnKZjvn5#4g%8V1NIb800^A
z6LXr|<Q0n3yp1wR-iL(HsuwW5g46h+0dN|xIa6`fVg4fQ_anm6Os3y;F~xh|M(XT!
zSjF%GF6CSodzbITpp7_Gj)LsdyQRyZ)!(L8);=z6;-B6<Rhqo!b?&td#OMeDBActO
zx&h|X7;F$=a)kO5yuBFkEkYoGGVf7@Sh=1!WE4Q${!^^4{TP8WXY0PIs0}Y=k~aJ>
ztFpEv3Mn_ms=@c&x%7X(r@FTgsgwjM$Nm#SfbS3;nWCjPGbuJU>B|qPIy|B~)ihWt
zy{?akH1h;*F7^WGzf(;^>c7rSU<{+d5Zhn)OO0Zma42cWY-q?F<!%p;E1bloRi6nh
zJw{_v$Um-w^&ovt#3MzX%C1_s9Jgo<!<g{GEY~nhsH?pihA}Zr2=Um3sVSLJM>PGH
zHTA7&1;l{yfKRK%<i1BA6Z+zJ)Xx3&3bqqj_Bq&k)FvjGQ~eB?y@I69!-Qz<Tg+)0
z|BIMX5`!=>;QV(00{$Q#8<ZO$^MCm*@xO^!tF|Nf=NugrQwlZIpAD+dc-nKnL?zjK
zVnzrx&95=dEHLXxa7nT2uhufT95A>!zZ^RnR>hkX<1{@E^RIsr4!NxyWDB6*K=ipf
zCw*dJdcxWDbr?N;h$yj3VyY=A<Fw>4L1^Bke@o8ZKPjWFd%mY3;~GLH6idqJ>)s)w
z0j__*Ry;m3pv;pnCLBFH5x1)18yy3Y-PCq)$&Q&QTy`y`IIj0(p;C!QnBL-JBQaDy
z#mgy^g*1)JJ8A1=VPK#uV2*p)dnfiu?Au#q9VuptaH2#2W|#S2NUJpQRiv${T|A_I
zp<TS)Z(#0;ihk0p({qBnchN884Bg7*{36#;Q-yAtC9kEEQ-y&c4=@S+pF;RhNSOxu
z@Ym9YX`nCh|EG_cE~J&P#4og;!!yX~!q57Xm7wJTwMAOFxY$N^iO`O%j;{@_7BT|_
zq>cQ6Np#-l3EY0aH+L+%el7y|%+I^j_v=~`6afsuzVV8yD$&{4PdYfJOKmL$rj$3c
zBeY|{F=Kd_jDQx+og7!fzZH&+5UIg2Li&147jHlJ62-9Xg*hLwb>jwDH5#gp0^`YV
zW@iNagIThyYA1NI!Z;5BR$;tbR}AAam;tI7KOY0eBZ={-E|~$VnmQSOz@kWDEFm;A
z8w}DG!}DiMxSTfd9@ZsX*Wh!oY%~l;Fk*%+>$(k#ABAO7q*_-$O)-3jVIro|HE6vM
z7VPqm5x01^VFy3PS3qFEM`ZluNuoXc?%zgf;Ci8IwH$o-o?Om*35A9KU?rvV9ZQyr
zRo_d$HeMU0d2N)e`{F8UZzIn?TQB&9E?G>q%mr$(j&M}1_gaeHAcVV?<BOe7Hwb!P
z3}=c{0jR6U!em$2AXEvVfh2!Et%N;%`zvF?I0J8VtZvd?!D(M^z?!HWGS)_{iF^vo
zxobIc5BCgtCAIlq)cSTKYWbL?zyH6r<b}cem#CGxNl4as%j<%f-v3J&LTP~oQD$4r
zldvF))p)7bL)8h4^-!pv7umy}`#~UEK7;`r%c1Q*$HkNaRvnSs$kaAa%Mn@DG2jJs
zthWU^mX&o}RrdeTF=vY~i6~e8AOuKVw+bsXSr4UGTZMRyr%8(2CPZqQKa=`y6T$;L
zxPCqhNxydpDoU^6DqFq;TJRjgu>>+`JmeKn1yoZaFS<8jI|O2K!36%X9RlawmnQ6h
zKuk24z?Dy=TRR|-%{T11)=UyO6%k1-Fz5$ix(1U2u*ueZ`IppvCpfs9Bx$D*p*fH%
z9oPvDY|dcM-H|~YmiiUoVB5tOZ8aW4<FH-A0DnX)m7-3!fyzO@CDzgA;sWtYrxK$z
zC2>mlx5U_H0Latq`t%vRa+sO%&$wY6+4V0GrKmew%_G^heATkqylGT0R$e9KmDegz
z|F4zTw`jR@<uwt~*~;trkHT*nH+kXZiUmNQY@vn*)0zd@LS6dLmR+Z5eUmvBORiVr
z5;0+LPr^qBu^LXxMXO(C3+;%Kt-A6Ns6dGo*Q;^ypft#o*B^p%{BEJGMk_D6MxekJ
zUF}g|i>`3gWs9!zTH>NCx;${_j1=BosG&WgQ7^mF5xv+XXLd2muEAi-mR+Ade_zb9
ztL&Ti&Sh7fXLu~hmR<c|fwp^uq}r}9ma^)a@sz(+^XdyWfiAS_n&-+_T~$7zT7_0!
zHiQvAvTS>WfHIM!vZdz92N<r^_6l7zE|_oa6<T+4p{Ce#f1gGDybs|(@zOy8Vi?VQ
zJlJ&9+a4Z<EMdqrV@}x)BJo{X=X8dzvMb!j33M#B0>Rz6u+WvJX0pYW|3j26?-S~4
z>_)!U8vV>DZT$sZ|IsMj_yt{$|7@i-tp*g!9E(*J@A@FQLp|=ILtE`f<okdyzF(+R
z`2()M%N&a})~j&|==pv!;ru%wJhmS`0z$UT@<*Z80a|8-YYExmfRLnlZ&a<aEck_0
zRuDn4$O@zXw8knI`W`}*HCBz=IC^kZtg8Lz9oj*wtcxhHRo1sCuvONlD6myl6BL}r
zXdn5A^*>u>P0KIjA#9cP2mA($DYnY`4+blKl@*B;Z9XV;)%<6aE*}(v{J)!8+#;(1
z&{$-J1^kBuS<D(M5m8EzQVt291-(TR;R%~uNIX6yr_sH~_S4iz0<LpI$6Y%lREZpi
zZ?flmDalQL*o}OmWr}mjf+_LDOGYW^u+Ugr2O+NaVIif$8_s;U9nS-ZxtA6U4;~i$
zBlgf2v1cEqXP>$B;tLI|t&_<cvk?FA$}Rrl3-m{XN*;Hk`L<b4XeLD*!3s9$hEdwy
zVnT%uLoxZ`2?n2+B^G}7v4{-8_fk+DAlmvk4lyw#X1L5p_ZPq5^Zg_e_W%)8&P6lh
zM$iu8wCnJai${d64PP78!PSwH<>>*YBv_{1dO{Y~GBcE7F;tJ>#MYn_kusn66RPSi
zQKSj(-@JUKW-I}|&b>L2M4v$XbTF09{n>Vq=9Q6eI<|k)G(rC_H(qH*`x5r12yENG
zq?YvCF`<^`Uq)L|8n=H*C8^eNA*kF-UZL#-VjhbMg4FLgCi*XB%8M&Zm87RC%DLl-
zax{#HbU_PI_ur{C1s9?(&l?LbM7IG%3(<<Nb8n9$7N^ictgi8wWr=eqgeBVJXN}U3
zlSrHY7^S->vCH*6t`x{FbxNq>T3(OQd*C*@ogMSD>$m7k*^Pe{@MW9$)5h$7P76m}
zwQ>Hdq&>e0Lo`o}QrKCcm9EuJJRTZ;R_LpFY?RKN6+*P}XxTq!!CLwODF1UpV_gp_
zbvq~2E9Hv8i<FOHxcHpVK%bA6!3j<cCw+Il!*>f|O(~(`k_ytxbHZfZfxf6X`n=Fw
z_x?wecAXanl@GxT?!av<5o9&@d@yF${9P#Ls(aEKG%YU(7QcWBbkt{DSW4bMANg^c
zez_+|)7%Tf0L??A)ZrpD{RIJU%tav*w=w~>;-XMV_mVW-cTs3oN`#-;^$RdT)m{=B
z>K}4Vdk!H@TLH&3z3thePK`%!R(icZ;=oL{aKUF+rKcb$gUPaczBl_2tzEzDfzf66
zOlg*Pi}F>cUV~C-_l3d4?H4piiS)FXVQhOAWm~c+TMrf6_BT1(mW*x9;@O^pe;3kr
zB8E#LZKvH=v~6;ov)ws}v|Wx7P>i;Xi?V(AxCq<Fe<^I+|H0XYGPa(@v)xD$t)OkY
z6=j>Iu=RQ;Yx~teTJge}2DJ#R-WS{rbFPnTi7x|dlPxuR;gaQEqf?Ma#)V-w_MyR2
z^G3U>cvds0mbCka#K<7sZB)Q2+BuC=FTaWHsw)Vo#(bmn=M|xnZ|i49m&AQ^I#xa+
zi>2&U#Er67g~dUSKEAgn*^lgDQwGbjupE$~_wjw+<jlC<IY#NwRbfU<8n*nBGd{)5
zwHXg{7oF#}X*+;S9*cz+u9U@J#qfv?lUr2A+4ciR5g4uFs82O_jMD3CLbTV^PpHyB
zEW_k=%5@=D*TfIAje*yN>OmeTC1>2r$44e!=i2)dZQgURb_Tue*RdyIi4zW^#<}al
z=h_nckx*|4Q5EYj>HtvVgSfm7EuUuI5R!dHVJx%8vv^zj1uSzz_@FgDK;cgzFhYdy
z(piWMx||nHJVciWVhqghOB#$L&!({-bW>;)dja0Zo~cd49l-~mXgkdLYg`jU#s$0&
zlm|oqqB1mIckPXp=lq*O!w^e&<bPGbCLIRG#&)LerXe$-UvlOUd=Ucg;+8pQl>WLY
zjPy+E!&W++OzL+F+6%dA?W3O?rC)AA`!V-q?SEjAO40r<(iLgHF^#le3@p>$dv&Y6
zwa(mS&gPZ=jCJ(5u<l88r}8n3)Wm%=0ozZ1n3;M$HD+7x2$8O39`+=6B?LaU^Y5sH
zdNuBl4PK+FAp>SeI`~v)X!N&N`j?=v>#M**YBQjDI}w2E-4p8TzxWmM=_{OgUKPad
zeTczS-+WIP@3FoIN#PB*{Us#%ytpT~n_0*LfA0C0a4B)b*c1p^bcqHq+i1flHL#Mr
ziTMU~Vlq0>kJ!8Cj=jwd(WE;WA{=3oI~^?1uO{d*>Ixg8E9_I)5RdYV*&ptcAtrVu
zM*Yz~e0O{enA|9qi46m^Fq7z9WA-l(iAi=UF<Fhq;YNpCA-;zF8sjn!-#Kj>X2|$A
zDdQ6MCZJy;^I64l7s6kA<Oz9Ym7&IZHsz6EsImBJF<cg57FL)`=zYc|RC@SG*jt3v
zI<)Fav8}3z#ujeX#(T!>_{Y?$1}W64;9JxxX5T-GWzrRGEzIQ69oY8?vu{UcUnq^;
z$7e$Q8pmkThuB!aGzXzy;YM}2%^DRg?RzF1t5wiG^!-@7zS(K8qO0SN;}iqAIDKQ5
z`@`)_Tb%acTdWgoP0DL0U%~W$fi0k7PqG8X(UfG;>eK7;IO?~+*4e!29O3TDqvbeW
zM2Gn^4#noo`Q2+t4h~#XK*c*^`qG1Oj)XQ1X#-a8agw|iuPSd-$4j<=viIw!sEv8E
zebsu@l82pP_JIUUe(bm-eU|x6NsSa^!Dpinv|nyN?$Q@zu{pHYbr_5IeinQrowk=O
zwwiT26(wMt&#5?*q$|pA>AA($HtK#m8jFaZg*K3vU~-{oNx7!qLYuF44kjy87TN+D
zf80bfO5`nEL3~X|`_HZDy7MO3lLtsYCMyb~A1{;Pdzdu-W*>>fWc)C5;&a4E4@Qp`
z+8Vl9+`8+kO4SzG;&gvVQ4q7p7HG1#eb5%+Ia-Q#$*<}VTEnvlL2MT~(8Gk*f@eYK
zBoZq3{kcW9ism1ZK{CK&zQOgp{SLkWt)(g%aFqmi?BS!f=c`nL7`y@U^92Z9>p7+f
z)j$T}RQT#3qpH@eFt17s!m02zSC_+PF#El$lMJU}NaQgFDJb%`!i-;=<#}1fth_9;
zqCzF}Dy^all&Ly6C7K<rOi+oWucA>a53-i4ZLv#b3w)vxRLAj`Q|o@L?y#H=Ak;t7
zL$MsEws`g_s35i9sL~LZ(lF6qv#LzA+zyM1nWs#(ue;N7I446QcQ6RI9KFv(&A6B6
zRE#n-Aa$G)%?W;fGFeNfQQT#b4OBM4c^<~BkI5-g_K(gC!bLi%6wArHj4I1H?Caa3
zmf2x4S$_{zD{<8g6M3Nsv*RjeIOxQv+7~n|TKR7-wVNwO4JTU|3pLVg@ob}Nr9-oy
z6!Xi9ZBi*#TV~dvh%KU3ws4G<fl4RIj+>@*lG!g@X7->+E3c_q>F|rCh4i<0E>fvq
zLFToom$Q>(k!u))+oHNmb+&UY7qdLp<yIa6$YC;v`^+>tnaMpqmO%<S+4LfcjaDh<
z7<d6`PF~b+28-FVA_H+|A+l!wDz=and!(`jJ>aCijAzQK$4IP7eTVl{P<YAemsIgG
zJIGFLcMcMH^zKl#GE^2BP(-A+N@N+CYV`vrFL}U~QF`3ZAyG&6G4oI>_tHC65Ot98
z_{CZ&+rq9gY*kt02&KnK3s`56s>dC}vWeo>6hc5{uCMZI2eWrdkISR?naUQGWszGH
zX0l>yRJ<G_lNImhJ?_~?Ws5+w%xsa8P-Ky_Rkm>S_>rDY_mM^Z%plx*9D!`ELM8K>
zs-kkZ^|QaIlg!MpaxZ;UiF6Fh5XG=^C;6)k>*%ERibz?p1eHjK#a?tQtbVSUfw=xG
zA)-(8${?Y51c;Anj5xwdBc{Jv{h2ED9b<f&Vt!fuu`2V|bb<Y8C|yumNm>B%hpLqk
zawlaJ>G2t=9(RoKiAo^Gg&)Lgq%++p+2$(ma5GIbC^wQwmHrO*`9X0-dGvl)j4L+3
zS9rk9Q>pK;*p~_~*)OIT&D0~@{EpbaMTumx$8I$ddrlQ3+u~sdXJ5+9t}_Uya!g0o
z7ol2Kkjl)=|MlI%`p;GA@9=(;VpzE^+o=re$b<1pyptnAeO0`3OwAVE<`T^?zwG^z
zDtA?pTN$kQwcMBfD!+Dg(yw<4tKUjR<%lZ&iYv;BmFv#(KR20Ug5+6*tc1#A9T{$)
zqL|F=N0ms2!**<6xRY8i2$x79(99Bv(o1rWH&FGGV~lSsqS(0z#V=@`L%c>SPA2mj
zrgB(ESMHR}f86Xe|BtGn)Ier7-9hH0icnEG<^=bYVJVNK+bSxD$fP2?{s0y7KR1SB
z^bS;Fl<e0%R3XaY*9R1f$;0vomBk#2t>j~zhPdpoLU<vI(fn7H;pBK%Lgm+v(Ys0!
zDTml4Dv=KF@2vE=Ow~r!<BmrD?VPxo-Q`}&S9!mq$Iss^?AO;-ws5rameNXD<V95=
zbL5dZDNa|EN78hHm}T=j23)2x#%0BNc2Z0hB>Tm!PEKZWCtY9=-j$9(w)aM1^<Rc6
zytu<+{`)}*7_$5PrwSO3q?FapDN^q7Oa|d19rL5#6<f&apH|tzkq2ig5!Ng_#zfVe
z#$k&aiemB@zob&k5ibrZB4xw=tP<()p6f-ZE-;9h>+fLpUKzczVV|o;ufwoAi%@;9
zqH=_&{syPTWL{kuq(CQ`J)^D{?xi1@s}wZslp=mTQsvi<P6~GVwYwu+tK6DE6r!rB
zc+va|pmV{69mC>TLYeEzeR--Fs`83RxhqSnL^`@MREa9GVwL$wGP7-knzClCltCgh
zYofA+!?5#}NFY1xTva4+WVq)=)PJO!sykfK+*l!#ovf~k%rRMfUqrDND#aY$GxTcV
zt~{q2mX6?awUx>*V1JnZ3<L2VcZj^Ih?L#uj7p><`1Dt7Ase<wF}4`dQYDf}?9U(u
zZ<>GkIr8`oMKd{)omVO5Xyw}?%$~^1h!^!6Ia#6-FJxZzRq-NBrW$Fc?I*qllAUZQ
zgK%3!%4FIrg$<jnqH-wKMX`k}vYpBn)ns136i^@g57;zO=}%5T`gcuoDkd{)&mdf}
z2$`x~3n!Hv72_F%Q#pdqnzl|Vxhri90xHbE{2ZhAxDqgAk^58u!{OJ*S{G)vhe5bV
z$Ij4tWsJ*iy;>D79K0;8+5A_%gr22h=2%c|R`iz@TkX&v>N~RK7ey4CpyK6l*sDq-
z$rhCV&!}4Iu*LTZGg;&^6*EU9h*79y!-lD-9O3$+LM3<7aVHh_zZ@pZDMGf>Nv5n@
zf|MSYMa~E)8aodq7VacNF;p8{Df?eCvlXfV=TNMlGAw2N1Bzj`y}47QOtqFlxL-KN
zNX0^mA^(?VAWr5m*>QzTX0}H~<rpIY3YFYRJ}N2)FN2~OJ$^ukH&PVy<pBf7sM>nl
z`?)JmJ5$!#YHFJwHcB(s+3IO`FEC2k>ujAWe!d+K#>g*~d(C@oH%bBD+tQOR;>m&<
zhbI>Y0m@&IUyHr;Gv1v}@p&3DyLhw5YTp*3$1_VS(KnE4f846?JfRR8>;?ctk7swr
zuv2aHgyafzA<!y-@RsiZ^+N(f#+!_Tv+roJ{XZU&NUFMOP=IbAm71>_G{-}Ent+EE
z=Z-b)pxJ7asvd6|;JQ^hm_N|p{A`Q5LF~!o4S?vhQH|OK&(yM0W~nB;_&5&=Wj4p*
z`z1z~*>CJ#a{}q<iQa@~K$&>A<aUr@_6ZGtIAQS&$9oTk%u<FqC%w|wvCg4~7I<=j
z$B1q<8y*fsaBhXCmB(>u0N9}O+*Y!f+A6Fc0f*4y4m~<>dX)5h-pC5lw!!PlN!>Qu
zymhUn<JrZqjkc&#-6cGFz`OR|lGTvZu;R+iMOw9Bvr)?5Xsg!jlcKmz0Fi-L*5o$F
z#Sq@Phd%IAfAayvQ|f*4^Qn|gwgByVJj5Eg$yP0T9y7qWav8&Pu{rrQ?fU7bj4rJ*
zWAc4)=>ad&^XI`|8Ks;}wvZ}Hf6!Bzyk5A;TLB5S&9;WRt7mbFyXj_|pKdn7snmV5
zt!n)>fH~g0O0@rxo-@8q!mFd+<LVkLajihLhk1R*Esm=Q=p^E@WwR}?C4Umb&Ip=P
z@T~5Di;FutYrq<=ddZBIq<SBmHNexeR+$YGXWJvjH-k4HaKSF6UB7XaQS#hk^D94c
z0jn{7U+c_f)Tn1xqttMVt(q$yi*2zjtaI#p&at#13r_;QV{>{P#v{uUYM<zJc)!c3
zZ<^%MyG8VPD`=~&R%F>7Mi)9Z7;VUSk%TK^^qxQB2_!r0uiOT@dY@66u+<i0R?LOQ
z&;wlzsdih9E<Fw_zbhRq_<PFN^xKr_o7pV(I=i7e_M}~(Hizr$#vWGUy`AGw6^9P)
z!F_*)`_dCk=K)@5Ync7m@0Aq3&DJJ7UA7&2FzAP7u0N)3CLJHa8y><oTYGa6(uT#5
z8Zw@H{p5u)yqG2cmbiKNH|M0mtMxwyONBEmJkkp$Bj(G`*bO*=Z;2ZRsy!4a?cpY1
z6lDdD?+d(n56yY(;dP56py|dQN&)up^2OmBD)<)}#Rv!|JjGyp_=V!|<&$bPaM?q7
z!5+S|I06kZpxLNB{Hua^DQ8?-1>Np87y(ztrDb~bC{Z2fRK~gW$A4+$__Sb;WEql5
zkY(f3x_h{Dh^IIH+a{z%dyH}8m8RgoRDVKRs}k~K$(a+tydF}olr<qO(POqumq~Q@
zC!|H`o_>sWk;+X3kA5<465$LJ(`tD{$dFnD`C?*PoiaKm#`8S>O9zPL7KgY!B*<H0
z^H$4MaV1FYNoiHe$bdKaFLj@k)*w;twFI<z56w~R;cMZcMS3-k@HFkShtDpEm!4;)
z;ZsDIX-Xao(qetb5oL8yk~?JlhSMAP$jkReDRn_wh({Y)#g3%V7YouNJ-(1Nnok=2
zM3DV5<QPF7El7)UC_RP%eNNaWmC^8K9l(ESwI!{kZXT6#EotFqJ?0d9f|>XiOoL-~
z{o3!0E^~6c(!V3HCGLSja?7s&Qbr0K`KSPLC_^S^JRhI3qfCBBB!n*rU#(#CT7oL$
zAja;TlR@Jnca+MH0O3|xWDh;}QQ4vLcQ|ppFfGnYu`fTZ@O&X$<46LxVW?DnQCcUD
zyRN*Ir|@6;auJ;Gs0=wnke!Rt`g)X>A>{~CMSv4Lcj2|(;J?(JAYElhAA*Pi+#*4S
z7zlDgNDKCDMat6JMWyWVHAb5?txlorVGkEqsr>_Y9;7v{plO18G%}Lu_)lsWE+g~w
zX_6vsa~~GuX7ThuG5BOs`F0g$qEUw9x-dR1j5{(Pb4-h8WuTJrJl}5*J)=t8&9HR1
z;+v!V>3+eWD0v@Dt5x^6c&hYi7`=@BhE_V3noAid@Fg0C6L%x<3;n$|hsiiVE;{;P
zT6pyLD5W6dmjxatmT&EMoFGU`lwW;woLQ1`Ds8P4!I-Ae0f<0<%#xEWaibbD&OMk^
z&ounoQ(6)(rTO_`a)LnIkex<Q$8jm;R9ZlI3~MK6wc$W@V)cQudQB5doJqhx$$Bcy
z-~7+w;y6+NSmMq$g+Lx+*G^aWhCG^25T1wF*~Q@x6P`!N0mb2$G{yW~j<GF^Be)a~
z20R>u7Kd-5D4;D4Ka=Y7aC2{3F%78GbO;D|j6Pf(!I37w^DMNsAU?B=_XhZoX1pi;
z(~bAAhktFw0mAT>ztG<im^`URA5IgVNvj$cj%1B9&jxzsL3sn$fP4+^c*P)r<_eAR
zia|s96@&NF=zRE@G^2J!mQl((XAA0f!JnM~l~0D-^_7o+=d8otm|tRw3$LKt4ea6j
zrqDsVV+sau76L?5K`S`meWCSg6>;$LNF1F=_aKR_j>L6tf@!DooM?f8k-)~UCGHrR
zml8OlIan+06{PLIr`6RCt)C)2_&u#gg`V~Kxa~)0{)WK+2y^mST4>t=46`7Ng++{4
z{wyUf7o0&h5LiB5NlM~whNbbU%b_+O$pVxg0eb$s%|HAwBj;}4bT4yzf%seE=5u}-
z_{ZGde~wU`+taj7xR4fGcPit=$9$u78rL-q3=|m3I0ZJY$N0K%zIOPb^zuSlc(q$7
z(U`wpmyP)wyO|iA8d8n<RyYfpa4{{V!f+6=Q;<BSSv;rKO_4@E8(LA?b1}_BYm0-C
zE~YgOo*YMX3&N<m6x8_MUR)+*!AMi%Qf!f(E1Ivt@nDlxAY#YU(oulXy3(SiA>tjT
z$FRgKRtakW)^WKbrntDw#4lH`^eW^)I5>=@%f7Hkyl2119S|HR91XsfxDL*WG~#p9
zk(}g;{;Z;uamiLL<RB+Lu$yc~QmD&v+bhHsq#Y%{@%5j_>2fi?I30zV+;Y|Msm4pT
z%G%V?M(OM|TQe!?4_h5`#YU{5rDMq(+{%+REQ`Z}Aa*~^0POnR6EJuDsa2TIymSV}
zeMEN~vO0gnusW|<cNM6UUbN0uUS|!jbKOy=jUp(;S*cYRrnK?Xd5zJ$#vxWCHOxy^
zD+JWappg1?O{icFnMr=>7EGiWcUT@`$NP4Vp=mtq{K1Un5Tz&f+I8@FuyCXa%%o?T
z-D#0AUJuF(1t?#SGs5#|)nJMH1sDivT3Co_Oe2!wWXPR^`kFh(EoNxyHk$b6Zkg!p
z<3%pg{!6xs{*6a6XV~Q=q=A`xB+Nx>a>Z6Tyadq9ZLnCw3q}o*V6llXhwAM0h8Vm4
z+n<cm)GM}F^Zoj)gRa(M9rOteg@T<r7Y*W_%5A-iS6I(0B(VyLt$To4;O*%SpX2T6
zK}X6IH?&M}wr2!=+@&~guk<-<;Mc5Uox|kYP#3A!Ra=n%oe>QEY*zus!+>5)==B`E
zzaY8}&}RrelA~WVaCkkXmfW`?_;lJepzCw=Q74+_C%HL5Hz)Lm;Y_yeZM57ddIXg_
z7wAcZKElx>3Zgp#z2h2&lrWqPsq5y4b(!I>S7(M_4A(7W_zaBALZfLXuk$^xGpT5u
zE=B8@d7ZJmPMV{RSs6{iMJu)Em74QP364riohPG;DCf)Tl;L&4iq`pAU5Dgj<ld{p
ztZ+G+S;4(%r8(+Kyv{aWXDzSuxONfCb#~U_E<1x)7{e=EU={oopA7}M5+Cs5@8z`W
z+SSo1(&v}c{BVa#ij;9VZJzdBtrV%km9)<7eQQ$CSP<qy>L3r$)C!~hd_C5b4Qyc0
z<dz0+;%<heWNFw1znOJ}qB)W!PYcraD{0NN`=e5%zptdFRQffNb7pBcV;Rph7SCNZ
zQ{eWPCA!z(`0XSSlKHcexY%5BMbG(8$>foVyBU@wH`>W0?*>#kH%nU$h-8%byixfH
zDjPC9C~V!BNTbR#744y{?=8>L-RP7J3z98<0zcY+P^?CK7i@#!AloN=PJt=2f)BWL
zpa_v!FP6p8Q5YPKw&RUci)Y>HARM5ZWpF)Vzm0@l1wz?WQ(n!5H$#mSymzNVOf^G0
zw{1)<x4ul@J8WJo)9Sw(%7eFCL*l~HGp$OG*~8xsqcQ9DX%z(ZATpi|zr*1z?nb-p
zA)`6qCpr89TzU^TBk?iY!*_6moe*@2z)|6A4*!<m^d!LnpT*%j2u@MP0UxTOSM%x2
z;Xe>PJ<oE`HzK&%;+7s*s0G15I1@>sJ`H4!%KG%-M%Jh47zw;jX+n^=o6-jB(lO+m
zMY>dZ>lc$37jJx#yS}G^jvB+3$DpDiLl;K-r|z^k@cPLu{F%`uJ;!U#8bnM3-bETk
zr1X;c0_0Dc&(O=ThK!qbefvp9snuOuRP_U036dVx58I1|jI^*Au-??aB+B?iA>8N7
zuFSVbcE>hs)?Hh8i;=}t=%uPqpI6YK0tM9W;G1k|6&7;<qLKLCEHp~?ySB={<%;3+
zv0q6k_MR=IXHFL;^?0|!OlT7nmn<*D4Bir+Pp*iUs)EP{k-<P=ZTgx4=`|z({bB*6
zhLa`i`W91+(w2L+s@i^Ca4p1rTSecwJ*nBesUciwKWggxd$utDrUS@oaXnez;UZx^
zi<>YEH*oxA3$5kC(EGxMuvsOHy0V|qrKx5-?tzR8quxQvjbRJJ-0^-c(tOm>Zu<nU
z(f(!g*Ve`6#Oc4F3cf?mRH-qfhoXu$m9^g$?axmzz<fc}NAv;%y2p-JTbc3^su~AP
ztj3tGQ2u=E@(SA7c-ArQzAd8me=(#AzWjjN@?3UXf7Y-w>&Yp(ad_Jv40VxC-nT`?
ze#R(xCFU@t`a0XTFqShUoATz}sOTbvKCnfZy;(Ih+hEzn)ul^zzFBLeNpg&fSNiX4
zzQLXjq;qeCyBVqB>0v1hmoD2goqMmv?Q}Pep2Yk<?o%Uc==Cn#HOQlrEu8oOd$?fN
zhi0OA8Mlci8vz!#Bw2*aBbf7eSc@96m=PuJ&V;KR;Qn<NJEdfpnQY=V?OS7Z=tJ97
zSM!Qoqs#bUq|FcXVhftcOpt{XW7n_gV{|#@HVqW67>VQYKRst$#o6)aL8=+w8I{)8
zq1UedSxTAP&BO>8v&n2TLf->u`HtBtb6HSn<>K-}0Bs~^_M-gk_;ljtmA-?S%55T^
zQN-lItxEMVN?r48wY4R&VwjhQaXqz@%Bb?V9^6wI*DX3RGgj{mf4Pxo3#uMdOoaed
zh1VTfg`+8`Q0<W|NUQH{l-fPQ<2C&#yt{%z^*J56Oo}D+Itj&+(LEHI$(%(TvH1Ow
zEyTB>T!HnxtYlb^l2Vy`TS%D)9hkr;oj~0%-xjVt+W~K}<l7>BzwJ;|j?lfNv@+jT
z$=s7y>yK&$;}3Oh-r~1-p$!)pVGd%~KhL6G49tt5)Vqv-62%f%2i%i0cFFD-SDN#S
zjpn{W{+77=Yw{KNBbfY3(|Skkj9q5AUVIEwKtG<C!&9i9U4M2qlens&#DmENBz~RD
z8s3spGrW^aT&+m#Sx}-wU<k~LlkoZ)1tj+25=+VwDF|R2EJc=RU=bxQl1uCq#U&C^
zfi~vh2?w>2)rM(!wfK%5NuvI%aNb11+RgeWU$8drC#a*2CGJ*x-bPtsc6-*w{<2lM
z#MMe0ClxO-fg81*TB3d$1k$56w(JQ~E%IM6?)$K;N1$Shh->{_q)Sh15dr;skdkrV
zuolY{Y(bw})<yDtYKzcT?O~J>p4uvE*Db}1aZhc*=DXd=3iK@y+DD+79GvHuFlr_?
zTVPddJ8I)Nn$N`zZ^s%K!&FEOb5Gp;ozl7(>J(OqQ^)V)mh4W<=%r=5K7JOnVp)Z~
zIj)Y1zbEIP9Z6lr_^YgUp1MHIe`N>OQyW5^{BO=={4Wy(y+kHL3(h6+USc-{TH@9x
zu|}+6LJW%;RpM@yprK5VTpf<V>%|LP+yEwS7psOFZXuEHzvn!&1=i|&heb$##J4WI
z*m!pQj`I{ON9T>E_(mHw)5sQ0#~P(F&ut+sy%^#6K#btH#?)}V9;+QWXkIfTXbLP~
z=H6z!U(AkgMGU>t2k>~=;Ji^9_1sp){99L}%MRDroabKKJ=cJEydgOw&K0x?^J;4F
z4+7qwqkp@?RwKIaS;Rto7HS=H8v}X@@x!=~+Oy-2gH$vAlf1bwA`nJ~@Jhdq4xb&r
zk&s?<e1OXv#0g@W$rOR?87W_ipkgHk9`DK8;K|ve4MQ1+^m(X^E=t3D&h7uU1+?DW
zmUT{B#RIBCU@W#Y$IfIa=106rO0&VU0E7E?{AapIcP3=q0%Y+mJRteo=HGP^Lydcp
zM=Ap`SSC#cDc+i=7v~+T24LGUtgL3dTy=K**JqijX_W&t7vL(2%Kz8`%s1LFHUEil
zI%*j-L{7A;%uLg}c$E>^(tmb*Ghzbm#<xWml#8M$ohCAxUl@&7`bIpn=jv}}knt7d
zH$0iuvN$JL?d5OaG|o3VIb))GY|gxrI7NYx8-tSu7`eSMbmNy{wP)9Vv^sLFbZ0~R
z2&u#in@`o9q^;w~LL|+uX*!UD6oSuSWEr#Tzp%}5)vh)grTs5$-L%~>srCEUmeO8_
z@x!JvScAwjknU8pxJCcTG5y%jxG!2VtN10+xJ(TjMN=39Q0$R7uArD^ly?4W3)9Z&
zjJs{5FM_21{<W3SHt1!P++W!m)T?Pw$+5&8ZNa!*XiMA{hY8G63NTEcYLv#l0>khd
zF48xzY)hKPw<Q*s`BKD6fQC&^Y8k+Q=yg1iF<jY(tCzxO@L-GfFTf;v*lSzufJdWg
zgiH$?g?Gu9QxOv;kYK%=YLtEgMf<sJRBC42Cd<g?*mA9aIo!BBgDkJGIgU@pJm-zA
zMc{v}{};ocYcA5FH@3)-v;?Ml(Engn1+1>VvDNR=p(8y7KrZ9`^V?N&D@;Op|2$~U
zxNHd`uSE_9ly4=__}Vy$hlcHlDtl=5$JSWyI~ehN)V+Vj8l^`$4YLiiy*%6~4c>4$
zhk-g9aXtv&%!rz4l-9kq1(k^)0FIV?G~-gH$4x4Qe~lePX4_of%go<%Z#`cI(I+ur
zoXbtg`#)Q7&FYYwH0zi*l);gn<cwFi<)$5*tcS8(!sh%;L)Q+tAL&1vUvy<XHOte>
zlkNIk@uRGe8dg%?ug!rnj^QpPJa1PaphZ=pcdJSNyjtVgD__-L?M$zkCs@;h>h>ZO
zyeWoOT@C4Ff!wHP6bOcg1vN$Zdj&{RX0{7?CVgS<F&g@nHLa%h(-fn0cxjfQ{8elo
z&`KwU*d#z&P7A5ZvaHHM?c!NiG+G_Wv_zr>ULGf2*jkqQuW46NJ7)xLds&uMqkNmf
zd}_9kc7RXAQ8+R{y!(N7>ZU5JjE69BE1NR@hgTKD|5L1+8UKiD*az9}iY59e=R*v1
zsD3AQg!bFnxM+x-0O{a{v`Q7fp)E)p>U#8Knd<0|l(H(Va=qk0ZYV!8R1l&O8s*ki
z21XJvhMv^Xlhz^ZBX}v}jnaYTS=F_7lW+yksx;r|tS01fFhWwsUm&5IM(D!KlY_Yd
zv8&W741?HhdxBJJ1q|4@32WegD|rJOk^v2}0qtX<bnN9X^x6r-jMDk9zKr_}%^>9$
zJyt8vUuBoKtTMgmNeyN>p3!=mKCm5*?8@XLo`>*{?{HwqsCPJ4(($c=I~-Eb%B)&-
zSAd7(!SV;jq~<UN3cSyL1;&#QOWcoKz#jaQ?$mA<ZeEH~3fg(I0(;1`$if5^e8|Le
zt7BhAQG7n?$cp#HX$Dffl0)%ATQe(dMHHu8k|`biF{w&?XKZS+`z7r9h#?r8N}|M!
zl)d}k*4>af(VK0*)uVNtlY)-xwT<`JzH4oi9=DAT@`-`BvExu|w4Oo^2sFg|YIEBd
zr3QxhAoC@}73EF=72j5{t(tEN+gN1JK+gG7v)mq)qxRmBH|4M=nTREE5A1`^L@&_;
zljnvEM!$j6Uz6$Sc@*2A@<}q9l?o1n%A1#G7&UW)38)Wix-mAic}cr&s*SF@i;Gwj
zdzbuzi4p^Vqcd58{2Nb$Rllq2e=7*kzrsX^6X4*ddOH-CU#!XM5c)mS3$1-R5QLU^
zGk)9kcV?(#=&ChYonkvU2&ZvEPewQrgpTVYGA0(}AG9{BS>y~nCE;I(pnJ!|a5QiX
zUCu!c#C(E<Iv?cAFV|+(En%tI`L~sJ>A>2o`M#S-4o2C#2kKFVQ+D5G^{L*h7ez_h
z*RsU@T#pUjhD~@TW`oyHUV6?z%oF04`&FI9u=-?g8Yp;lY1h-fr;;avz5~}8*y?g{
zeOs4tJ=wGvuKV$XgmLwbC#?QkFDKW7pQ*Xt{w^z`;&jF-jn?{Dg)qmRnt+qE>$1YN
zI|pEsaa~qo^@-T1;<q1J;{K__L?4nHWT0r|E;lF}F=+d`EI)lIrkMW6vRpLQ0DFew
zuAX&S0lxo_uj_z|>UjRZI}{ZJm7{k-Kt(~tj#4b3sCSmwIPAvWH5!fB#eyXo=bi;i
zH2RCZqOtehyT%qv4zc%s|L^X;Ye@cnKFK}y&CbrwPTSe?K6e(JYy7~Lb8aiq#~E!b
zeJmmxx>OM7&h%3H=qeg|08glJ?mW|Cv->-@5`D~yVI<r1aax_`<h%-fJlF~M@~lE1
zCnHT|>Z1d%;BvaAV6ROdkD?>Ik4|FH-a4E6c;ZLV$EaeRL?7G#W79{rJGTW?FJ74%
zl{czOjB8FF|I>%5qDsOn*2PmmU^Hj2I|^{WO2T#slPOp6um|?2y0-JI*1jXthuC8!
zkmjz)Rs4?O>^l}{_=ToIshyxKCj@;?jJ_$4jOwG^aYf_*^nPWXSY^m=n|lk**9{d!
z+E|6OfoO&5{>ezI$VqF1g6~K}-vwzMIBCu{q`kEzt&kussF;bgZYI)LWk%ZF|DQC(
zU7TxM-56=B8EF+bX^T+6Nz++z4ILMxrE}6Wfcc9jmeJDLH@2iD@-bIeFKQyKtBEvL
znUQwq|0fNB5hv}lD<f?UBQ1)P_5cN(v<_CJq2q!y9VcxbVE(FX8c=*m!g@e6YH)ql
z6fuzo^<)ED#)(yCq}{fV1~J1u^L3J^4TCH=_A3QqHf`32M+Q%4Q3RIP@C6bWJ9zX6
zcoF<sgSTL8b=U&%^V7`W*VuHSK=3V0K$<h~u@-Q?HKIW96o!2n1COzQSN~7!?-(QV
zHnsC5m#uo|$a_=G6d72YUSJdRSre`;Q+!Fs>ddy((f?<iU91<sZUtEh7VzZ%1mDP-
z_=kbNoMNWv0}J~Lq^Jhd?@HVB;cb^%z*kv;b05wE9PWl=UAWtCR+x?TJ)ZpHZallD
zaQlc&Y(}gY;As=kM+RHaM_8e^1;4`wI7c6zaX!;b{55z(E8_X;rX}K9R)~?piCfC_
zKg(qeeyl@9mZ9TBo@EJ6+fdQA`3<0!MY&GNv?@m*+%U#MM0G17jA18g!<d@`uH-4_
zSwxl<+rklXK$r_aEic)oC(V+SN&(Gzn(t0~EP6)d>M&ukg^Ayk;wLTX*qk!9>-~Z<
z!?|u&NARem;Wjhv6w3&yfLgFACBR{@igs>F3G`^LvWJg&Z+Lu-&E+m3VCNS%?el2n
z?$sJMmz&%U%shtkvtdGEdt~Rgr&N~0T4Q>%Lm%$hf>(`0Ra>$)?9ls4MKFlPzs}Q0
z=|%17{8Q>JA!9`^-(h~#`VF@1enl32eGz*a^Na%BT8Uk7@2)Uf?!u5%Jli#}VLEI<
z%9JxHQ;cl0{#)F?2Va!1n@#;Kq3KKbNVa$HM9P#yxPmUPP{J+-fXN8|s6x@o&FQzZ
zT^p)+@1oCijZFPL4SmH2yRW89`8uQ=vr1yQY^ND9pX^jo5FbmPayWUKUud2qZyDbQ
z$08Iy&46<Nm73FvGhKg>ypd#ZtJhFXDaPp~%D-p<ieSRxFE516W4ks#6oM(_Df+P2
zRjs*&8Ea<WLDDXSVgtMvPInbIe<3NvzruhJ?8P5t9ip4ls40Cbs&_8NjQUZNX`|ip
zwppTrF;%(+g*mrloccDTEWTiGR2PSN7hJHgX&IQReOk*;+F7wVZP}x*Au%BfitQFr
zx-0U}j334!rEzowJhyO|GvW)}#>QUl+$kfro0FtQ{dRlxane`JmQSF5zY7{RdPYOY
z1w;t5tm5}tkO9Q|mA*9tKdj^Z7^`?+%wIAwWDq&5G6{|qK~=sj89VhW+i)x=dY|6Q
zUJ8vu>T$n5Ncnccfc<)ZHegW1AeO7>!9JlCgz2bJ-L@WI@#|slI`Ln$!nV=$%;cLv
z9EW{rM*H{cV`|3)aMcMYFM=d|duu}IaEOC4Gkp!w#W2PdW}1b>3Cp#xEd}^$Cej!c
z4(Q7{{C<ksAJF?tZ^~ga)d78M<6Y%g9RbYmG^~tZF=2e|P|(o}xz?2Nhv3aX>0fMz
z2L=`&mqC@3tZjVTC^l!I{nTl3L&`PJ`Fud%$X;6fsTn07(w9$L@5`zEP_|%d2e!m`
zD!uH1;Ay9do4Cgxnz7NC^AV$g__)WO5Z;5|E84R6+#$WYy|n6?9sPS)AF1w&T1NF5
zOc8SLF*>ti$9-r<VMp}kn_ckcWR#9zWXug6!(U@LRSBTyB6Y)8AXpFw1DwXjqbu7Z
z9#@N3QHKCGi*#|1GC`P@9MSuw{V0&`b`VC)En#~k@G2<F0VP9(!)|<2WL%IFv-s-X
z@6Cv+Lm1h|QPHGf2zrRtn&2&#yCB70NA<Dci%&2kGX+9#RwA)UZ50~g(X3-ATBjjL
z^^sDCYM|?=KBV|Kz#pj>THX#>kqFqawN2IZ@TfjBX`3hKLJfPf)s3<c{4=PrS^U@;
z#^avHZw0}aOiXTy82p&t-8teoqpKt=KAVgm({~8c<?+pNJ?w_MB3;Z>gynl+8xCR^
z+PrN>&5rBC{MUPM0_-?ujBCo2y9&F8HNz!{$Mv3G0isn$)+!UUQApDXYkypy>{0JE
zE9OZQEcbA)H!!g|1)R|PXPieWl5K!4@fS0Wrkq|<1Fll>c0(Jn@k_Q!>xHrovvnyA
zDsV%_(%UCKL}4Uc%AqBQ;FDLZ_bka*4M=fubfg%wH0<)=D@B-U=CRXoLsIzqRaZ6d
zp|_DC;p<CT78XY|&Bx-HP|o6OtXE?FDmE3KXNprNKMFjlFX`H)KC5xZu=xlJF|qOY
zq~5p0(u17W)$NAp5Mz#f-HiI2)R${J-JLgmxwKF<FE&GrP^^NMaS?h}BQwc<gMA*3
z!SUqvNGGn*MztK$99KDJN`fEf*zj5QdD4rM`ZCh{C_C~#rB8?~$?s`q8AogtEydf6
zVQo(NhqdUXv^XKPIgLN1kB|Hx&kzgnmI6HeE4X6|?hEiI3_RWnJg+3j-XY{W?3)@l
zr&g!+@wKjAW5K$>K2CsF{~kQ0F|v>jh>hA<?ft@?`+Bu6BPGi*?+bpcQnWk5kfNP;
zMz1czUSv7m&G&u^dyn8M8Sh$u17~WT(bvb_k&pWZ(8Hl^1O0k-Gsky2geYh_*&L?O
z-NA7cDj#{t1gtAR81jx&5mo91EAl^4k!9BWCjtO0-pAj$9K;U=pVgP?i3gUxD}&b>
zEFpB|*b7YG@tti`PK<elb+-!;?Rgwk>?Hh5U`OcS@7-G!#$Yo=3R6QLY=fid*D2m%
zy*Zs&sRc=+y7F!D)dgj>I69XOD5QW3dLJ(Y$>?YS$4cC)bn^+d!s9IP97BK6!;_rH
zF3-CFPj*rdZ|`pZiRi@}y-z6Tk|1ay>M#Q%5VaSGG8m$7wPYW!8vjL5$G5h4$_qS(
z=bWIt&uq|LTv7O2zX|^j8cnj+hMZlUIXS}xnvnv{Vibyg;lr>0!Jv*wJ$yn@D;4Py
z#^_Xm$Vnh7CJ<FLA&Oj4{XY;L!BUo$h$EjjG%mb+7DofjVAZ})QD`Nu9d9gbCH}$)
zWbz-EIryRRL*s(|W-;#tbuk%ni(J6q->o~LymS}Y)xeATra{}BxspEm$S`q>H-%X|
zW`ptF^7_pw>!N;Z(|g4@R4WVA?+i-p1zCZx$Hw*C<C7`%?x$wExGB+EIBC`;eQ61}
zXxk-yRcT*Bb9#PBUpBC)Xr<98rhK4<8KfYEl(R`VlY3cTS*j7yocdkXm#samD5t4w
zlLDYMNr)}kbR;(%J>lOf$EWJJug0a)a8{Rqp=y}GusyW^439zaZftn4%iWLv@tQGM
zW2y|xRppAlZ1uxMc<aRrsymg{WxUDjDw>9^MU;R=RMeh#MPDJXgQ(rOaRDud!Xw_l
zq7RmwF#9QdRUhb3<`LcPz0#d(U)2{2i1SA5iRA9B&g`hJv+LxJ=pjx9W~ukS21mPH
z)z_9*KeVIeSM^OoD>-p0>-C8gq4sxdeTA&0`kKC6;QhiJ^7xnV?|HupKpn2>qXXv(
zpkI3lA7wK@Z2`3In!awuESDzUZ1+<t-$@xEs%Un9S7pj!qdKoHlBU=7fzlh0Ugx?#
zylIW$5fE^UJD*VSSU?f8iFHMkhYL3l`uz&_vT)BF>Di$on6T0ygf0l*3y;Hc@^yVk
zEzj)>`Im8dsMZL{{k$UBk%q{E9g%{2ZhfEOdT)51!{Varcwvs$$nA#SJq*<Gr6<;M
zGTUICI<0C-)@Zab4^wS68jm`lBN0Eu(9bvYA^wvcIWtpJK$5MaY>Eu(^oSoK=^q9c
zDBv0-e+Tynv<KhR*YrQ8;;16N2bl?w;S6M;0CD&pq&h&(-qg3pMHOxyVoaFZ&yzUL
z^7$*U5!rwa9hI2i<K#b!C&nMr@T~(Z-NmPv^<PDq4)#^{v{vg`;(ZnNp6xEi*=yy!
zr&y4hWegis&AJ9@j-*wU0{&@6Q;y)I*j_evkeiOF_+Jm0@H2*H{G^z43=bV{>D6h^
zxoJNEK$b)C;v2E8j)rx@gc}hdJ1d2+!m#xnb8hH23?d>z&qu5ct0`i?Ql{Jx#qUjv
zsQl%z#j(5cU^1$0E_dwpg1KYg2>>whAtEY}*ysnihhoQiheb!?iFx)kyoYC>h)e^R
zXYJW7W|)V>=X#`irj%s|2JZsa7*;gcnm4#`dm2LI6UpOW6@l}g--<Qv_y)|yg%j}p
zM;W)-F7uo2EX1~>yWd(zRPOq~Lj6<*n-vwqi~L{VFE|hhe}VcO{?26=eyEnQby&wg
z@x-W~euq;(6f?X3mwH>~uH(oZ8#3fzuK5hW=n`h;?z^M+4)eXo$P-R7@F^$AaF-Kw
z><MS55kK?|pc#k38Bp+jIFgJDI>Me~s%~DSdIer#wUJLK!rmfQwq`Vth$9D<q}+}B
zj7*-C%YDh4-GCpFlw+i`v%x+htWvLM5@nl}qkZpNm#ut(AwgF#gO44+tH&)y5jJT5
z`GO&f8pr`+`-v9H;fL<NYaJ|At=F7l?&)h(p8wE-p#+!CxF1mj44+`hfuRNmh>gtS
zH2%%Z`=Wbr41d5E?!Tw6T6ya~77Q(Tt8wE{1PobF6kuq{0b;dy2U#tSA5MeX8~zc!
z>S$Tj=Q$eBY)@|wCW;y;g)z)0#F~|~p<Ak_cSH8#MJ@LKMm7m1x_dm$JFFCMUJUR+
zPDAWnj5#E3n3gX%k3}ISd}-d^hr|D4fN9CGG>tUmW;62Mm&Q(a_s8S3Vsm_`eHm>7
z{9P7*|AN+PR=5e&I1|HWJnUo&U$@PQt#9DnjmBGRD`8&MrB=<U;{$zUSZN5mNgP)Q
zaeQ%`Q#&1hfn!tgL$@pR_3<k6U&ID!aiXyb<Hr&=_WyB}Y?#Kyz8t4SaAp3#Y-D0T
z+~DmD$6sh?G=8Y*L%ny6p_rN!EcVFZT8a5kWC?7<oR)mlxcil4B$VQW+zQAK5wvZM
zyB~rz+*yGL6scgFd>4~|4ZYIc{V?jrur8SF8pE;>Y}mG<aqZ;odk|8957;<^P+Y`s
zP86(Qz3BQ#AFe9Z8<~ss0F}~^xm^87@8>;{jTM_E!{Zv&9iq+pD~?9~>d8+n?zqlI
z)aqztL{VlzAU}NpU^yB&+ZlwJ634Lf<Lf%`W04JQpn3xehKeuo$A|_rTx6^oI9h}?
z;9}d$4Oh~_D|h1*3l0C0%SJ7(5+BI0fB9cgDh?1^4wx~9$52Q`ucifO^o%P&yO{Yg
z8S}VQZp;Za@)`5d#dyDXcJc+PWT_u8Nu1_>0zTj+d+btWX0rV^KIPL2VBuW3LFQe}
zh-IX}*ELf5$`Xh?*|OA0nBy@hV2pX8@Mfuiuc^SB&G$fSc#|Dfc0WXMU~WX$^X|BG
z<5*HdGsMAPtL+bo!kbv{C4jV95fCj1_{5X~qtA9vaDrbJE|}mb0sm)yg7-7{cuduK
z55>B18<uGU(TIE;OFaY!`9>i`avBfT%(S{#@<1dP=r1C<pO7CMQL0TKUCq^p6f66V
z#jP%DYC@h>kM(gl4E3=vi=>d8flyw0%U@S-C!$-vPr*%@vB(u51w4hA72E1PPcpIN
z)v-%N9Vc$2T81L;I2&{*L2g%bB_;2en8d@{A>3Rbfr$*}!17kIPv;)%t4nW6VXttW
zKHbyg6UQHoHimh`nuLkQ<mt=!96^cz-;Yb`VSE1%gpKy)=>uxbP~LmBx8)#Gs<^)h
zGB*mhM_pg&U{~95sBg;nBN_zFSfMZ!`qhEFpXkHtJbcaBQH>cjwg^AR(y`SbS}e;l
z698FOF;MlBYiz`kDBM{VYY$KK-i>Dn9Q5dW94+(VNEA4JG2!TnkinwIY^wW2?<qw|
z_=emQ{UEU}GvKM-U0UMMoF+fjcQM_X6I4%jS7&|KFAqKX^^EoFCGXcsE<Na%)j^2W
zEKK412SmU81x<ceP5r`jb<{J~FM%V{go7-+X_*g4ABpp3?G*(_*NA-m;+=@L$G5Sb
z>2<bOq46%SwZqwz=laeWEY1{Kpp2m*d%<_z+?mOXeq><|LVXxp|9zKP(<0^I_d>|7
z8)WzWbIypY2N)cYE%?pSjh!IVCJ)dwLv$pGVG{|`W6Y0c`FFCyzx%lbzh2;faK9k@
zY5DQbbKrdXa><OoC(zG=UE`MXp9f_an%GmI)_mtw6Kq@sl}MQFaWHAeyqEfl{oZnt
zFrj2K5a_mxinBizb_4g#;838;!PAT>so16o-AqP-g8~6Ps2AD>1tpXM^8_YHDHy;u
z54f?)!vR+IN;8VT*~YzSW6npH^7#8q3E9K7bTYW3d;<sulGCNmPgj-vblpFdkFF42
zB{kGcSBz3%rYl}4u%)ZfWreQZoc}JV_?y#}1b?5Ou2{x(HUT&BYlwo=%r7ZFU5UJk
z6<u1Tz)V+1rNEZ1UY8WQrv1YP)TIyp=5%$zR6RdktuE%HYm0)@OjqfX`S{hDSFxgN
zpi*F_Ym8E0OV`wk3SF!3ak{4CZ$?+>c$W9KjAQcn1Ng4^Cok8@RarJF%W*H@Y3Sgz
zdd{y$mPH&h#N{)7>G0sRP)}F%QMp_SZi`Rx)bE3u&l{4~(s{Umb{xZ?I}S;Ube5Eo
zVyxshlz4VWV*9{nG>6pC8Yb&mjtB3exyy$$W2K>hx-~qlx$`Yi&*dSjS8D_?*%;0-
zXBPQ;4@WiT=x~=(z0l#xrrmK2*Dyah*lWc*E%G4C#lCxdJPkVISe(6G?<e~@yprh@
zprj7)OfUT8YLfqFEtU0`o0gi6`6}D;+>zmqMy0_|X_~+6>;Ls%Zd{(Qq?pK>L@TcJ
zP>|U0Bh~c6UNL_;O8p5F6dNS>p5R-`9nLNCsj?Bt4Pe#)v(pb^!!vX<wuQj{)A!hY
z6zmzZkgkZ|YM+cH*)iNosMyi(5dKj=Y`b9Teyj(Yw;pR18U~m;QXMp~XB;l*$~SW#
z#qupHfU$@@@QC+r-1qHI2}EC}4GE>guI)-nMh~nW2Fm`0-)Q-o4t=YX=}{+3y#Z>k
z?75CrW8b_(9#9`-_1xIaoUSR;ezD`}GNbx8%;8vG>mjjaC+^;{*CGR@=0yxsFlU(*
z*F4L#g2!_sR6L*^c#B1mY&WY4+^`Dg?j!=g?VMPoerlqIviqR)N3E4FW?yoq&ApfQ
zmq!2B288H_ab+D|Y3WIyr4?g;SzN#dg#7!8FM$jjsXgb^Dcx%rw>msL8^z4_kWd77
z2}rv&DAFmU$u2f#N>+<47k;|IG*`VAmG)pOqn%M*(+3b)ahd#uOG~^!Bpu6;!r__L
z5$nI#V(ph^FK_Ez@&}Icj^U5F*pwjHJ)m%>&R(6lnaM{;6f$y;3wJ7$v4&YCMjS`W
zMyu$M#RV*Yj>3%2L@-~F1#R1|bE12q0fp#yUYzK9{Dq4fUV!MACv1tfhr(jPddfj8
zv(ikbP7&T;k)B~qH<@F-<C0ATc@G>I0*Eg(+rrAzwGd7vPY=&vCefw?e-0|B1Ae>>
zQyvj3%ILrk*LVkt0Kd|Kc~CvPcyN`yaM^I2cVIStthv4vDq-rt5Sr!GDcpMzrn;;L
zPiKGEgBIy!RY$JC9%Z*kk5vuDQ_j^E>3;T6_O7fBHeAOX&)XDpJTn;?Wjkmp=3?)L
zUbR|(;aR!?n)EA0U6dM#DK*W~%e3?QQr6CO;uh37lH_EU*9zuVHMC8_v_iEUzkV)j
zH)IexF$fBku$|*&A4Yv=7(0OR$2hcm-cZ0h4jm5o%8nj?N7*H~ZfmNl<l>4)I@c^c
z(A9907dB8;a=eE}`qnJHY^XwnA_Xp&&*a1Zpg(jg`iFE+mwTA^GOonTSZJJ;b2lZu
zh<&w_m@M*MTU3ViPbhBq2`DbRiozIn@R^O`Qpdx%Q?AWnOQK}bMV`P2LlMkcOZ<h-
zrsIc}9!~T280Uy~zRTOui?Xs`ScDat1cB!5A&y2Z(D*VmG38|MjFJVS(I_e1X(f`!
z?{`A;ffvwx7x#I|_OFcpDCVm@${_y77-mc+O#z?UGf&G>3BtzJ7eMzFAhue=XPmDd
zbD#_X6(*o=D^TW%@o51ifTkSd?Tt`?7#lgNRUF8c-AV_{^ba`yJ^c$&mVplB9>~{$
zHrB090u+E$2L+J11C_0Tx(gtqg2_yOaciIxM>(eX3J|B?n=NYO<}zMbcYynnttq85
zHbOO(10a(y=eCB4x1QKvJjZd5Q*fJ8a05ANWwvS>)$vC$r0V9VV)>||NZ#}lXl|M~
zl40U;S&m0ZW3&-a?-VFAOB}6%stcf(3Xqv4cMU>1c(Q2W5l;4W1;{+4J2}v-1hTIn
zS4-}FmAmvnMlhT19tKs)JU)ioCAO_xObdHI;nVnD93iH=3B~#3V*+Ym_C2P8?2GLO
zIk>`f2_B_;hynIgkUN!lpate@mMkq+ge%J4s-Mn6O`24cJ*D_ZTKch~oRH9xe<B*O
z2aAd#nAMI)>@uUC2!L1sa{V%=_Bf}crC41x1z6d|alc?i`ImC@l-(gf6B{Ec=nAUv
z&IKEOqGeAfQx1+cM9XP`bcwg|PN`yZZX*p<*a-{&I!`$-mhEMl&(CdifNfG_fjY*>
z5fNQgJX10L7`Ri#o~0uMr;^7Wy^A7a*huIyPgustJ|2~R;uF{oDboreD*+jDd2kX8
zx*H>Vx(~g>W|u5Yp-gXcTimB&mE;hIy7#DJCE2H8yNjIWxu=v-9E%2&Q4HdC)G~^{
zicy@hhv^(fF&fE96KOQ75*Uzkfg|f&5CcXPQy7pf(7f7hW<Um#kR}GiSC)NL!(fmp
zy)qYz>&u$c=*n_w>2nF}M64n=gsA+8vKN(Qbr8Y5<}SmuqRF&=PK~luYgrV-h97Kj
ztR!ms7hwUMQQcCh?~h}KOTpk&*Zo0_vubZc0<85O0rJAFIjyfEcSjR(OL?<?#rV+(
zBtOr%7N&$)xf$LaSc1K-vGQQc@Vix&gH^9#2`RR!+)H|^YM!&Ks$9fg%0>ERT{U@&
z@B9lQIv%b_=!DQQjMOa0vFquV>atITx7c~W4x_TwJBZ)cQ=F9p4NO{EhQ_m1;Q`8o
z;D966P|^}S=w@}fn!^n(xz~_?X!tAt!Z_wCtOacFGPf{doxsdCwgGbqfw||u1z^6S
z!WPsTvbMsBUCr$H^)T%0>uy*Oh}AYr8C!Z&|AAs9<cqE;M^sa-W$o~dp=<y|=;Zhe
zvdf;M%_j@g2YA!`Jb@hsWoAv;D{?DlYofC00D`)$1?(s@C~&LnTfNZ>`c<ry!#uLs
zf22AL(ank~y^R(5*UV+ByZ&kbps!~Rv3D-#@k0qi;=+2Z#}k_yZ38rxDUC>b0<ZNl
zrAeaUYjJnC)dr-Q99L`xehS!tH1U>o;K0%s^M?9_a+<`-#}nKlg_Vy?6oIfR9GS~m
z6w<o$*nWiI?)$ib>A2X(WQAyyK;$J59XiN+*nuHp`<OCb{|6!w>g)!%vOGQhZ)=KY
ziT4}WdvPmlmxA6eW$(QqNVx6Q_PsG|*%u(JVcvPqPA$2?qh&G*r`+Emd<|AVcCv7t
zErayJED4=<V-_wR7Hcn-!}o0F3t#c71)G~87`m9|)p#+U*gDrNCcjwcauRa<Wk2uv
zQoOZZ=i+af|L%bWWuzhaYPe}oY2W^|@bYW7urUz%y&?yguZ#N`MOZj|!Ewf(7pVWn
z56$V&EyR~u!vES)#MjOJczq#|GdW8ClufLas4@E(ng0Dzh;cXYzg&L6U-WtHq)0zD
z-?9}zOEf`l53$p0E2B)vP#capb~uWFt13t7Qk&sot7qO@U;M||V{0vLbM6j;OiJU<
z>4>Vlkrnwjdcc(?j8hzYdoO3~J^XN`DZ3X>Olgh)8cO4eWwCrToB7L@;WD0TAs&MP
zWei&cA8zRo<e5i1BCIh2En>LNtW`v+=5?Bvmsu=g9UTeyYXZKx0&k98_FKb4=rWM)
zePOy|uRe$76MLgKpV%+tXxPM_iHg<4{#Pb2wiA0>f`1eQlvD^XuhS&h5HN+tCCDe-
zH4?B*Ilw0!X7+SUlq*RNAGP#bqTF6u{y|Hx6XniQT|Bf&k{jj!t~^_pC>iid%hxR|
z>k@oDqu!&JqWt^y44a&{Shw)*{9WR^L2Cy)YE(}StrNSS`<f-YFzzgpvs#h)%v97W
z!GGsAk6xVDvoS*qPz;o>sV93kzP*p*urC0|@_aaA1dc`P6dYTSPO!*G_gOsgJCVP&
zO0dr51y%{^i>q0EtAzBg3WPcFyHqJKCo(rE1p{mn(toW}5}D6;a>3t)zj=an4ij`s
zB9k`cBzhHDg=oX5-u75aB^t=1itfc#Q4nG;eKVp4vcD>`oV{Jn_6G8AQqenexO^wi
zX-2IZ;nlSSyc*s}{@tOR|1AFM#0+#HYnS5lw}eIj_YM}gC+uLdY53F^H5xRLL+#5A
zp3Q4Co>@Q*wkIoL2b<{`ij72#-<ryWB!}5UXpvT4<9UBD^Q?CazTMdVE=QI{;90R3
z=c<;Yo$nJ%y4}VYgNiZu<QneTLvXRSx!gIt=2YI|uqmR&7r@T~*7zOl%vQn<7BLy*
z$B4u~Bz}<g?A20COSwgz?X{2_h;Z4@f7B=VkN-vf6ZSX%iF(L?VxRG!xcB&ZUC-6c
z@f#lK`p3kJQtLh1ob{g))9j_{{c*VIOJZs<^$Llvke8U$jGDGah<J%HvrlXJgT3Fe
zKB9wm>8yi~pIA#1y^xa1y8B#3vKIIH*x|Y-gu_PlOROGMP$i8}y<Ln6NUe5q8HXKO
z>e5ag$9``YN{XThj!FAf)wbE$<y>zsm$rA<rlo#`lLo04BJV*%bn<<Nty((nlr&5g
zhvQ##F<oBiumuUcB1!F}ZI|tGQi>*(vX|n!*-?jLNm?oOl3mW`VoBv4f_HZo<i2ge
z$i4HAHMwGBW_6JRB#+Zt+W%)_f2q%TJF2`oaiH|!oE@!Poj5_-zuYdT!kR>!&iUha
zJ4#ubI8uth!_l>gKTE5Z*-^c9i8^UPIsyV!cU-8wE^)lHeku0fuTR`9JzrusZ$sil
z>Bl8@l(`{swsdi^U5?+z#CrD9^lUrovMF)2w0gZAJ=m1ENBVTkj#g|=+$#OL&@M-}
zC2^I5G<mfhIprk&R%&r8(T%GOST~pro<(lyS+(5_dj+$HBTV4TJ`0w1OwSrGWr9z`
z27=eiw3Izi?(eWvOLre82GR37Xe@9sawzu`OOZ5K&U09-r49EIhe|6KDWxNapfp=c
z5%&{^Nfj0<rEi9!bdi>pK1kdl4Vtf%ZukkM3$(OoxI9eys28O<kt1X;`=WR6a)q7y
zOEYTxGqm!MBhK6P`B`q`AZw|wA#tec{5;TEcci?}fwVdHqvYcD4*n@r;upEEG-Iw^
zPDEbf?+$)W{F)maKC8yMU-pRgDAEh(73w0$8e+M+=LRi38=f`VVVoV!IFvX<x=|1J
zu-nh}Am77@#XUFI6I{%TWoRxRQj~Mv=|o7tdMyQ?P8=hxo{SBxr!g>P@ep<<ak6U3
zB#;<CUcRr|F%eJU6XfGXW3KRyJsi}GK24B)B(KkQ)bCv4WU2cRZO+n(a<IMRGv1E;
zE+lHnW3t>w8h1#W^Y?{BPkU)r9Bwh`H`arkFD1^9<T2Q3bt&<<bUMS1dR|VHrMCOE
zv~H?=Qku3;n=@*fJlH<tbWdy~O*X2#?O+Z9Y0XigPKNEQu(DCDu`c|b6$Tj9wX6$g
zutMxZEn_Ogz3VW3hDX%}KLW}!emLQ+$#>e`i%R{n<eKh&zY9^@5T=OQ;1gQfl_if*
zz3&aS)R+NTo2aEuGvvYS_oG)*Fuk84|D|d_4zIV)lywf{F?*UNH!r%l3Ac6~Qk&6$
zS+Fm!b^~I@Ecv#>I4J&XIg$Ntnk}z)I9Zvx{3@pv-8-A}`$#f&Y5od98itF|avuLG
z_izZf5iNRAGKBTw%LZ%Vzzk;J+e8nk4&?Lt+r%HGCxh)M>0RQVQe8Z}c$XL|^{9yZ
z=-wx`O>nL#@YD-pcq**7#=}Bp8=icCLFUJ*c7<-hqfy-*0^P|c=|{<ZkR6@$Ntz^0
z8)!!@eUnB>&Um=!n{-a9F~E-g@JpH~ZG@$*;GZ;2DvgI-{z>bk5NK21fTU&8>Av`8
zPGHg|Y5QmxnLxly?PEu+f|5q5+DCv(35)xwa~=mJ)wD0~6fOvk_hJN>U1?1)-?{kX
z8aAS1Kp#%tE|%2}GmybqEYAo|j^q3vP@6gRM~aV8(#M7qdjamTL{5=z>9y2(iJa+C
zGFG(ovj=Ob>k5W8-frGf`H_@9OiKgLrF)V6GP#|UJ5)>Q%j7Ag!WL`o_GZFuDVe+7
ze`x8`GI@~00Bugc-(?4T>C#|r&fw*82ZvHM7Xa2^fxQ5W_3#h*t3w|xJy<EfcIb`4
zTP1%`4eqD4o3~E(q38dT8%ss|X({ecxsG(auQq4&pYjm<Qa<x+F>P9;&2d~Km$xrk
zs<+k-cg3epdC3txTJn=Rr`K9p<&aUP0Vdxpx{N{c=9y95bcoh2cPswJR5k?flBZnZ
zTYuTyyb^oIc4T1vU{Z4yzo<O{vIp#e2&7Iz>nxPm!#ZPBzZuG0eO#;n{G&bqF@kte
z8h}XTXSw`YzZpJEA{xgrU!(fMV7#d<kTC9Hle9n*jM}(Vc&Tj*bMP|H1#MK~ugl{#
zJ0=)6N6Tqbu_mD%sJU^XR*=QxaPBGAp$H30eKyEJ?wNRIVav5bmJ13<GpucRc-&al
z3CBt7EU8F0I1W-iHy6ROHPLw4>7YNY+aw1UKfEd&!1!(sKHN56OQ(mm^_Ff=&{FQO
zwq;6eogmt9<ZaZ0kVS8ny`_<3w3ND8_ACCm1q*6<qT)J~>3QgKFR1}4&)zJTb`DZ1
z4{%&)q<ufN^^*)4TDrsP^{~`yV5+wnmWI{y&KfToy`{>(Xwz|v>?b7yNd_K@A8T%I
z{0~SyZ@iQV$<uKHNnCy;^R~*Ri;qZTLc%jKjyO0QvsL!gj2aDFiF_>MjuYli>^<_F
zj=OvX8{_f3WS{tIA4{0#;g(p)Lk#C%OPn-7R>_nw-7r-PpNebGq%yFI8@I{{(qA34
z^meOU*=r3O9gN!-2kY*^>cwx9L;F-uV3hHdWf!f;h+$<JX;41?iN6RMJA#%o5L-rL
z4?Iux5i}xhckI4b(1<iw>_&e5smuF6FveodyrYsL8$JaT@=L;=VK8&I$yHVUu<%qm
zM{e4*#VC-7?!+_vUcgzil^`XEF(?8B$8oTXy#%vj5Apj)UH<-)2~taJD?v@uLBT1R
zXog*-<!?6zw(h88Z<p6NdE$j3KQM>bF=fgXqk4}{OD}UU@0)^$GTY^p65TQci?-UC
zR;XW;Y!|Fr&=>@+*e-Vn-1jp8j!xhi4<nR?5j)&8U<+DM=^b*Js4U0*y96u1u2^S&
zo2bj2{|PE17?sr(W}Kg-C3a(o)Nr(xX6=w0m3llvaKMc8d~<rbL-q}9&u{T`8LW)D
z4VoYmnt8v#u{gIYEiJ*IPhL6yUl&+yWp)0`&su7~Q;sTCdw9MkN^5DsPDXcB%3uBv
z#Xg~o?zxS*m~~lcLpPfP;Y2x9jnQ55>`2Zq)2(M4e$tZXE;-a;tcK!t$zkf_OaQXf
zNwpwc5T@!zwH@SgCz$G0TU0en|FXd9UN(s1xy|h&!k-LdL^?iXM>`c+2;QN5xl%bq
z?dZ0{pNzX?ANP^jtQA-Th&R7-FJzXYmNU`mXWQF_2X|uw2jSoPd4bq_z@6Stzrw63
zPH)Ly?JBe?B${n))oiWp`I;@O6ht$V#uT+D;v+_6JbL=uqI{&(o~e-XzY&6zav5xh
zLCV=r)*a^)3=oxTz(p~p(26wML6iqK>yG`|K~#kojdSu5RZ}T26E%WKr$W?<h53j|
zg>&a-YsYXwRIQmzC_vPmkKYr;c6eLeZ+7Vq>)-(cHfFC}#xW}@baEkDy;p8r)RHoo
zw@<F@m=#8o3Q_favaXip4YHcJwXL<~_^QZqy4FJ$lY7Xp%I&P1ft5NWt9{oq-!t*1
z>)d@sStfh@p&;{~P#SPZ_HM0==J)$ZUR7iEji;O3&<G5u3O`~W33IAe>86SZUh}1!
zXv|BEugW<Ic3|;KO-M?y#=<VSVfg<oZW))PE#`3<#qCukr2zIyy`+~I1}B(QevNyp
zX<F)aSgsaZslM<i<~K#BY1tjDDx9kBmNMRGKcq?W_`{kM<5_lxBkXdRe9@n-9F{{>
z+UnQ>oc&7Up&HZ$)AW(=H2%IvW6f&>`~rxa&K5D}9T}Q{j&yj7jx0#AbmS)&OGhql
z%GZ$tN&)LgbkBSpc{oK&H;%~F+z%w>>&Se(QNPm!LJG=U@TZicSdO_@6(py>(|D_l
zofMKYT2`?oxn3tmay-TXr(|%x0FumBj=o}3CVO_XtXaHFRGP#M2Qd2i22O}o#dxz=
zwfMnCtdgfyV>w9*KPHzCAH;P)+%>}v*jvOE=|<%4kRttTcoRZDACs#(48pAAm>lkT
z@bv;jdu!qLZNTZpmw7&_J$1n7(N9V15C*UJbzX02Ap8=)1LmkJK2rFM%CI+X-{u9z
z;0*-B(ESy|r{T_;U7gYiD3r}hrCM4yf;}Ji<GjOe##qwOl>v*Tj8!N?O>g`KIrn8W
zq&L!fXI$>Z`BT8zCEL%R{Ko1FUAc(pA2^QkNdQaD=F^o|3%_GIcqP;i6Hg48owEDP
zExD|D0cmbs^Oy}{8vR{vmpY!rbgjRZPMnnMh4dGknf!urW*~gDupY!NFhx3=hli(R
zKZl?v)bx}bB`r<W(&$ri1KZ7m=T2dD_2)c#b4rev42=Z{wj!gejL(U+z~@lr-oh?w
zZ1{{}w>q#_2XM$M23BM|vN}^1&{QPHA+sD`kOkj(TYPN&r6cU$m^yYt>C0(3vRp;L
zV)qT3t;ZI|GdO;!0vkiH@Go|MtJtt(xN|m}G-u@0z|l21P){=uGK40eApqKWMmAjx
zbN7rqOLI!3wwTdn2Pd)H1fddc^KiqiLYMF;))d>YhbRiiK|UK6oz6DqoyFwfL=D!C
zx;`M39Z_YWB(V7#ZfUBi9tI&plXpuKq3VhA%;b4n6RBDliKlwEHHWLrL7bR306p4T
zogqQeMSR|^@fjdzpG<Dq2KI)RWA<WasEl%oyQ8Ti1v_DepExPXy(g26g9Dgjs>&kc
zX|MvMor6!7#s1mart<NV*~VPNt@xfm?6qn(?X6?4s)|?H=2wBN$%`JSFdmfQR`T_@
z7dY3IgT*c2VCo0u&~3h^raqqqdxR^3j)0!z<S9+>7(O7|npf7S4uU&3m)|kmW5uP6
z>LMu4Go9ph#s(9n+p5P*f}g?HTHA_v9B_IdH?{vn#s_j$`_EMMp`4=%`~kC`mk;IL
zW$*Iuk1$c-eA;_L;a`bZ(N8DA*Oe!->DnW?Yev;7e9$(An+I)PA22d2wuUXDHpjr2
zK7uhn@;a;y7U3D<*eivdQRY{iXPrw4o;iVMry0-63Z9h}tqzWGHZ!f`R4pC-SN3<_
z{)qK^8R8fgE)1Mh!#xSa@v-MJ7xT_=;8-@r8K9ZC!jED`4)mZu?rR!K74dnM7xy*g
zy*ie$uE0-W8~#2DiK+5HGgX?=4tcT%n(UH2V@zYuiOqI1Qm4nVx@LD?u3jHzCT`(m
z(}+U4j=tjCF$~80jL=*r<K`G_)~0rz8T~aPr-b@U>)Al?%~Xy_e0xq-Y$E`ei^KZW
z=NRfSnZ>ct)|i$lk%=)Z5i=mm@EgN6LA0#@hG(()yK@_@osTs@=K<CL_zH(y*&pr_
zTB2N&hU|<59tMs!<jGNmvf}#IKWn7>dGgd!75`!V^oGl^^mEJ;4z#EqfHprts*bPy
zM(>&wRHXy37xabD^5}g*UkE*w1RN7~O={tQdC2vra!}#l@3OetZr(Fw@FqpUAq6~>
zH4b}9(tv0304W_#v1#^LANu-Cjx3ZF7Mh6q<)6zF18(-^+GQGy6yxb3B~r5bV=J@K
z(4hpKeJ-oZZ@<03nB4nCb)K#O7m%0H36GJDH%4_PaF`I7z9{OKfEKFUsjKx()ACD&
z_}6c3HkCmwm%NbU9n!S)&kH%c+MHVq*)LEf8|DgY|Ea9mOINOI4S~S*r94}DjpV`7
zsbk!83@>H9eVH|fphVNKdn6b6PFRUI_z-G0<ZG<5U<rM-^v7#?RmtpRYkX`_a)QpM
zjI}S6<=?Xwda?3CN)n!f@SGF<PM&S=&`L`O-^(%OTQRMV>*dALL31HAJl`{z|2dKW
zY3T@-2pV>Cw{@8DA23)aOS9<VgIqdeK_v{u*rP$Xze4ObH>#^gYuPuJhNohYDhN`?
zy$HVxiC?zc6E!Tm({W8jJSbwzJ?zUAu!sE4ufKm{V}*Pg-Ww`%e68819vD8$wMqe%
z?6qY7QTETM{HZ+JaS4Cbl)2#-Uz_5uxg4W%WBTQ4Oc(B(&bVcl7Uy`7PKX`BZWPLL
zxg5fb1V7`Z1N)U-RdJ96Q3<&QK*v2u<V&hyo{D?KeRu7&5;I{-KFYHprry=S@`mpl
zWjWxFNmVcwC%(w(4jP;&_$rt8X~x;_REn{`5^{>J#axS-c4B|!y0*45>iqr{3fcc0
z6Rx&UG>byA8BfM~i1L5Tc;L;CG>k_+qG2+6VRxjk^(8IlC`^Pd?3hoM%j1&Fe2F!8
zf5rnBDd4{*L2P<H{!oVX;Ye=FGRm248UK4Rrp%^U7qfN!(FfDtwr7L08rll72oo*A
zz3w=a!Zx@c8|80~6gza`6j>95!`?Q=5?3X(3z2$7X{p=Zc2QDIJp8t|U5r!+564kb
z_DXq6kfvNe`MVp&C#)}~NEU5iHj|mvh*UIbGOPbNBiQoANIS#Z$2uVF<Wqw2r`cfk
zg*@4!<WmA4UntZb)%@M68jY2?fWzcmBFFg+D_v<M>{gjm41rsF);fz#gMG}_<zkdI
zR;X>E`R<L%;yvS>xU#-8gaLu~PfB5Rc1|XqZ5?6`w~gWEt#3wr0IZGO&@iU29W6>0
z9Dx;;Li2+h&Un+nKlJY59|D-};CKlnWsWx+iI$<sEP*BNh{iYW@kNm4SP;ZD(f$W_
zvRR?JQgNX!xY@0P#w-f+3eT@tcOuk3Wy&R_;YJjXd5U`^xdCXc)!GfI!FQylOnHVN
z7&`(1nC}k8T$tg0h3AKtd|w7!VNoM8@VJE1F!^s<S$KZ1_aT%wnfSnbQJX-1C0R@N
z@VfP<>)(v*+Xqf8S;KUH2UbLc5yBOTb1}0*PLNUNT0cfy<PUq)4IN-NZ-S&=fUvq!
z64nbJh-j~+wodZ{L){ro(}c}p3-*YMf%+3x5DYz)c9+n;=iSua5{x;wZh%l2|J<lP
z9EO>W)BLcEuO3`0j}&8bI>%}VrI>MJ=oI5N1lpI^9Je=ONaD^4XuW_A=FsSw0-6F)
z1@I36*k1s;<pT_28qE)2P`@Jc%Qy!?Pg%%4;Mf8qEh#eJ!@HQLkT3B;iDp8+>Z6d(
z7MWkV#)0Mqa&Hc1MC?LNT;HMxM1Jm-Z>OblMdt@bCWeX;?I_ZSh6`ZX_gC)KYk-X%
z&htGbhfpnL6`davw^l7IdmDDuB~N^@%*a(Ai_8vE3z_AqVJn%f)l|r=dRY#a*?~pP
zGFt~q9K5KGhucJiaEuF=kBE#REiQr^6;7+IInhCI!V~PJ{>A18*9e6y7a&J(VMi2B
ze1b^j=fsRQ3MZC_*m9!EwSqYDM?HlTT|*R3xVjg_i5lJ(PFyNgFeetFyZi!l)i%zF
zJSQ_JmNZg0@h_r0#))c&87Icrk^SkurLdGf-$nYVxptn*eB}6|JZlEzRCk%b*Pb0-
zo`9)~1*kO~Vvs9`dS5Ldr;Y3U<MyuBmJwmH__WEp;!OM<@39}Nd-FzsEtog3kJZN_
zxGFFd?E{#CLQ&_^aIySj_3P?rX~gGwL51({<*_Jr%x+OZs`JW7v$I>2l_K%lKCQL~
zUCM6ZL$`-64J>svj)x|Oa8$tU?ht457wOjo11-Ktukq6W$g&gOx?2b!xyAqH0`Xus
z0XwXFL2i!od#l>kRxH12B{sHG?$>#tDkD-`RN~t_|B~-&2`|uKH)}Q;vP1iBq=l(=
zIs;G7eY%w5!A9elU3?J&cd4GGd$)9fb=H3P2Jbl`bOSeVvGZP)0V`o9nE_#2qi}-I
zsNUzv1PtrY90*f>lp4C^elyadn`uG5f&a2-YKz#=2_qTJUN>5Zx!`fycS7gyq}JN4
z!e`n4rR>|fK;M0j@_`$kEyy;q^^sMy;dfn#)VQXW(*91X=&j8U$q<hMFfGUHBK9DQ
z;oVKY+|dPi{PQqBUN;8nb}KE>%b|+a4i=hqg7u0=oQADSvZ>fzoi~lYm9|mJ2JFd;
zlgmpz1B~?P;^cDGN4~Y;P1oo7cw<!0cF)HcL$ycWjHJ6XIjG`h$p79Ts5+l@Vr3P6
z8y7CSPI!Y*82h6Zortt^EfMdA$8mV1HJ2v$l>)12$?x)HU&-E2OEoV~4)rK`KYy>{
z^`P|bowRUiQB`cbxjZ>gYT>S>@^?`ZiHFCRCkIIt@XF=N<Sc0hQdWzuOx`FRD5)jw
z)yd(KlZTf2hw40N@dKTsS0fqYbdP<IOAPyvP;3c}^2P>{tCM~G3eU&eb?hx09&nER
zLuipy1VW|#C(T2(;x;;*aBWO51znr0lXh0t(wJ+LeWXdXv^1p<jR@-nJ|NSv!5)!@
zbHY~pgdBV1PKFoysRQyd!x18QtAHylf+DC{VT!1+mWBVwdVJlyz*v96gCVbxJ7L$X
z7@RT3&wCg@;pvdOrlRY&QFH;@l@htCudL%v6Q1jQRU;&z{QbEuMslm9rK`_%@v5Qz
zP!!)6y5wdXi!-qqiY2{W{H`6Ny1xf6sb_M+OqkE1qek_jl3KfW6Syn2AByv{yTli(
z&F?R(5xl+7)sQ|$V@c!%g!fc2EtPtyD=)1;iG!4xApMMnj})OUF|VPa))Fy|Sx6=k
zIPt+G;?@DPL>%Ccltz?D>oe1e(T}fmK2n#8TAJ`mcR?BrTi*7yZnnoG2j*D*Wy@Ft
z_&#of<{HK$I5f?j+~4ThNy8As4t%5Yc8Jx|DQ60IjzJ{I*gJL|+_ce|%0+%cbjwN_
zp#%e!u*Dvulo!IXQ&avmOn3?wtBq>EI4!ksp-|P=ujR2|;6gFZ!<CB1)&kXb7Yg!P
zjvG)Js)Z;qswcr-DKnRIk91+Gk*wzbe9~J>3!gTnr6tpSRIXW&<$?d|+#QsXLN}*F
z;&w5+;a8+aA)(+a==?jKr&I(m`wcozRR&<l-k|f93}v-+);GP3wDO6-Sj-3SHn1M#
zKEw7eU6{12u$JokrH4u5o{Q>*B3Kix>9#=^ubz)6qJ9h){%Bzp#;nMuJAUbhrByHw
zEB(`JNq;?7+Krx?ZJZa7?p=F91Ut^0`<TnfB-j?~VGTgH`LIR`MIW%!JglwoNMl=0
zY9kd!(7Yia-A8)tj9m-?>D8t6;aYMEOrIq=gVPHF(|1eDLHW*z^bm(R*_08K?kDXi
z3Vjbs_ln*I!<HL{G#U%i+4c*jlb87v7oWJ}e`05?5Qv)RAQ0L-O)%Z|N^dE(MbMZY
zjD|xY86B(BPsMsY6eG+;q^}wy?E4Pm1clT%*9CXjc+Omb5q_zLKkj`_Xj}_)n$35(
ziy8kG6>@K+CA${O!7L%akGXZ9&Ctv~=KPI(c9i>=yGDFlAis|pe;%}RA2YKcSI}z$
z*uZ^^Uy);9HP%ihIzPOjIDoC3Om9R%+{x_E?>3l|SvVdN#+^(s=(2J$&GSPWq8aF{
z1G*$nzXE*B(BCaSW`k<SQou4N<8Xa5eZ+6|)pu=pv-oO0-e6zNmwb#dv_1o_a36CK
zF}Stp^{#B|V|H&ci{3Ik3LjH9Q1LOrD#gc)`zODT={N?2c08<$a0pOb%-}B?;bKzo
zz+FsJyy7lq9c(^#G5>th2p1FaO=IO^in353zl&*t%nWxiN7>r~Tuhgj5GuGBPw5D{
zYw<8QeH9P$2X-Lz41kB33NHM=9_HQ?A<*2zL{|3^LhZjWpMxp?H)Pw^!F)U-#Qk1b
z=3uxLYs`?fEs@^bweG*=*<t6_s!HnWc%;8dq?eWo-w=kVaN<bxE7p<rpMafO@<u~}
zCDZ+-Ro4|;^5|!9nA@;saJIus!iF`#J8l)nvUht+riT|P{!U0=Ds`-z?jhZ|CTbV<
z2Sn}_iS8J5b=9t=^4qYt6SxiYq}ip?*E@{QrbPGj8m;<2Fw@%ukGO}q$O+epC*akw
zrc>Q6_a^L>QSDpWR;D(i>)f18MEV+D%JEOLOg;Xe$($`jOi@ma{*C&qnb&HPmo)Z@
z($Bp=p)X_A>7LS%_ZnKDP7e$CJA-is&8FbOhRQBM_sip{wPSK+wGSTYwmLniO}~dM
z_5xW57hu~o#n?Q<WZMv8!b{=Y=_{rhe23T;ZuU@WcyREWG50-epuoQBA2ar4c%&aZ
z(t~2(Jy5U%_06LBP-8{-Wj?%yp+HKjJ<`2>>=4Yx?8_Udgi9jo#l83+HFVn}-B0x^
zI!7haDOg&8SS-XdeTDQik{k5ZG}J3S%D1?IWg<;oF`MbZyU~K#Ob7jnz+;1b{g|h)
zM!7FO8;yML&z>Ok3*YnbLDUgW8B#46F>bOCF~)I|J-mdF?qk0)ryRkY@@^r+(}S&Z
zK*&dOaW2hja;LoOg2^clLKonaOG%kZQK6dyF=QsMoF`;b@yd~a5ndTEidS}3yz<fW
zCa;WlwqE&(MtJ4UmqhhK5v&Q5S1yuYqJyR>UO98J;+1clRoad2Z}Q46)?V4$R*VDC
zdmFF3#4N_G@ThoY7n4_hsZqQ#+_Uh?V72hdpuBxhda$G!X>!ZYHNq`F`UPG1&Mn_5
zaJ*}7wH|M&EnK^B%LvnjTRwqdL*V6r!RBLp@TO^u>w-PpEl*``IhwiUtzwK@px4YT
z^Pw%rDtvsTYb~8Rp$zSvo~EJID@BD?qsTP0Med8C{htW9Y5;~0Z8KJl8>{VzNdgVJ
zGSb!K3d+Yl@UFW75$~V}8v4zki<F9=QtG{7@BTLE64l-9^N*<WSj9#)%GIrtCXC9a
z&$+r<(xaoIZrd;2vyBMjaL0t}gb4_cl`ko<3v2MX6-PeQ@3=ZNhsaxd!N*?8Q1=o6
zSZ%#|sDtsyhdSt@iYZvkQ!yif;mFHiS~-hj+?K1M;5=PDsXts~k38K>=`@TqAO3FW
zBp?2mf!TEXiOx^@`Cn!DX&5+JCSO!G?`na=|9Q<fD|MHA9JI9isV-Q0c0_dF>rxjW
zOTx^{TJhHx;lhz2WtC8bV$wyEP@J$6Lg6zGLeaej1^K*NBZT6%o3-Ne^|^g-b!All
zTtMB&Z*@(i-3OXd&__%OHScsPRgX>>wKnf`0n%ve@?w!F7fPH!L9ZtIN#ky4sKa}m
zCtZ4{bC;Y2u&3&;j;Md`BivqTqlQA?>#9p$e{;yPQt$n|B~KS`0OdMkfKsQ_4yAhr
zoe!OOudCqxL1T)?<5@f&WJns3P0k;57p12|v+17?5Rt2U1rF83bTm}!qt2%mVkE@l
z<Ka_`>YGls;xHK9=bE1)#NqHvvpD>TN1F9fm*#+==GjM`zf|L%hR)xb>?NJqBO37?
zrNhEGu0Ywvzl_YLhD*4NRJjE~_@oPQ=mj(IN#`LoyQ`V^Zla$mvoEL$dN(mx>it<m
ze}B@=kq*0QY0zigMqih+w$czUV)Q}FzbVqNuVH%Ypcx-E7UN$rpA57`;Iu6s#=jbb
zp?U)OsRo=BGEkaECQy{~D6o)Ohf^aU2wN~z#a1mBf-uVo8=4cSO|i5{Ow5Kj?!hl5
zCeo7NcCZ_4iR~IV$hzpnHq2)2td4C7snepqT+)z~M9ZBYb`TYJV>2;rPNJ@=t@l8=
zZ#@c;jGkJGuSf3Es*4(GU5_3}3GXyir#>|=qB)9Qvy13xV7ts9y1R+Wt3DqA(Qcb5
zn2I)lv%EK}>Ac3|L3i7dO4YIzIGEai8mnUO0R4gn6y`GuewR`B!e3Cx=I8j#PuO{A
z>Z>#_dewk(q`{{(w5B12OEqRPbe^j9Er97|Ln<#7ex;$HWU4Ifm|<zDaCyAXJ*Xo4
zfXq_#tu1*<o6l%yc`}ue5;>e_q3z89(rsQqraOI0raG$VWX$K|Q^;84GK>%=J1_ic
zS9?mPS&gW#<T_n6JW+#&eH&9~orlkuM8C^*fDJ=v@kwK2tA2D)gj0hZ6o{^Nj1|K9
z+O@yqB0SSCjcJ$^^GrkU8dIR;3f_99lAm;Ks%WQaGqlqo1lISDr<$Cxsf1H@)nH8S
zHla<<y^bS};a`=B2&GOtQEk&H4ef3UL<16GeVfuQX@ngD{ATE{-B}H-3e|=BolilB
zdwvl)pY32X`-ecuWiLjoQx%<us{dS!O0b49rI9d{Yc%8&)Bqt9UkzZ2!p6q%=6~4b
zaR*N#IQnxp`IHIGWdz+Z4C#fnckwlC4!ecHF6OW)2&DFfAt_fEd6eQ845C5^D&*;C
z=_ibI?LAbgw5+_y?P-fC5}5L8BO~-dL+g-<mKNb*z<6?}Kle}xmE%tIVecMl?tJxM
zfjJxqs4ech_boh^O~vjQj6GQLBKN(<YEgAVmB~T0p*ckqOBEX6k6*gqoVJ&YxyinL
zj8&W>Od!LWAJWj;7WCTr33hNZB|8)k$Tcmgw`wb!iTk#qGCtF;vpQJuK^;@F33Znr
z(B!mlMeg>lE)O+!<HdWdKJB7`n{eY-%WdDQk#Va@jq0>UZ<~y1N(t>udK6R-!ZD^b
zHB>pWDdWl36zOyAiXe9Ymi8=7$GzOEp|Rz4kLXPsij<5yp)75oN8Ltqe4eUWi9mHZ
z3UW5*u7>8eg(5xt#j35s+Y=x)tE@Gt?rz9xJ4jYP0q9w%9)nq7Ql*#@*4;OJ!MX!&
zX-7t>6DCXB+S6z0^Uq4_=j)*LvuV(#m|H@dR&rDC3wg5k{F`53P+3OpqcT?+V9}=B
z{uqZC9kl5eIHNyxP=faRHFQb`wKz0FX=r{N8oC>UZoayyA=gT}LDaMf6{Ah*G(o!k
z0!5W|Jt?IrMbX&~s90h<q_r}#Ol`q2kB-1OxokF7?@0S3KSYI}JEHr)gAc(~pjdOO
zqWk;4SF8<dO^Q`=JcbF16-K{zqAqa(*EDts+eDC(yC~lzAooswjU&BT<H{S*MQB{~
z(W^qtJ=@yqNoxixH0}x41YEwiC3HXuLe|pLdpLwcxqfe`g5YqQd>U9=c`+R?tabSm
z2@ULuum~FHQT(Kgrf?ky3_(1~EXsKIe~L0T_!&aURPRJ<HYGO>@ny3stT{7Ot}F>$
zR22L<PN?WIz!}xkA3;UU_fud(^P&qS7sJO}ncD5fFC}%QX<q%H$?#?DyKsMH;%qhF
zGvd8jlT#v_D%z8}I~EAL<2%W$R-KBdRjE65Q^oGZP%P+90n+%lCeXYesgl$ICOD`E
zr5CxdoT=k<tXiCp%nYN`jWWwn?;cc2)f+D;w+A)x-qx2TR<K~gmQxr3Y=Ww-1Q~1A
zlaf`jyI31NDa>UQo5>=@t^o`_js9b|QaN{f(inSb*Z+`7SxzA#ZSV%k@{YapVKjWJ
zDDqkwI#*j4A+>`4y3iYKpYD|plC|9fz;t#1si{dHijr>psi9x`P=r^*{J@5X6(Fp!
z6cY!(cWVWO6=$T03~3*>@}ufY&!mulH1xJFZTG0#BVS{NTjkNx!G08yQ1_&UEh8}>
z_!KyBNEDJ|t+jh@qw`E_b;1X_rCYT2jSd4+ra!bc^Mr;L_lJgcU$3G4{VBlL<;VPu
zt}bWd#ff<E!r_D_Cu{)4+Dm`k){t%>&6M2!(9rXN1U`YWK7;V!6Oc{X)!<0GL9|Tr
zLR4oQM02D{tHIDjU0`+AZ$p<LaHFoGy46v_{=p~KUBKcwzFsyxl$DEkZutOk=-V3d
zCdVP9^FMG{(c|13xH{W9pr3_+C1VKrNEa_dTh_uw_5&<ag*^?-YQ-t|HW6C15Um>3
za{zlM2`)1A6giRWIx1G&PpQ=hwes3g;DpIu6u*v~JlQEyMU(Fz5|}FkhB~Yx&)^=w
znO6a)Yc8`l2U*ZKbTXRR&zpISs1M5OL2K8MTD6NH)LVv9duO$Rr(1pC@f}7XrRok4
zYFP~>Ms@Hd4RU1z!ZZD;?=bQ!hL099)#`&^nmdfXI)5%FN-koT4lVkL+NmzD1;0N3
zM0)4k18{seY6Y+NoHjPf^rM-PnKe{%=c4sfk(pgoQS7P12x=HuM#qL9usC4K^s6J-
z&t&{|Fve=FJ;`M=!|BNgDyQ1I8t8q0rd3kg`5HR%GnMwf-~Ri`hHQ*7*_Y1@mh9mU
z%Z#K-VM7XlV~vytC`>cU&RlR5;p4242p`ujfZ-iUA%1oRR5a`i1Zi=Obgz7-FG-`2
zYYz*A*DE)Q_DJPmS6)VC#!)-Z%n+JYHBCj$exddmA#Dqw^p=0N5pDCy@%a3c<K$h!
zNA~3Tyh_Jxwe7@NMcX<GAL-Z3qHT6~e(jn8Q-m9BAq04!uN5*oN%P^}vPMJshA+|3
z`q8BJb81rnSqJ^lzxobjADx*<AsIAK8hcJdeI}$eqq|*TBa4n9Pq)SkG;B?c4Hp(~
zw_!fsDbq_za>=IDF*HT0i#YV!7%D9tU!<XLV<=3z?w(DvWlS;thPQ1zmd1N0W--%?
zWv}UcQYMt{f1NSPFXodM8OKuV>SuDSoM$vt*IMu7y(Z_0C9c%rkon78=I<TV(2Q~9
z6FdsFnHrv|F4PcUB^cOz4)zDYj*p}A&J`7~41kgSc+9@uZ4(t6u#%eN$=_Rj)T~`o
zN0_zCc!X<LIaQIV5a`9@p;%>=sy|ml)j|^}#H(dzp;)OXF{-N`;UOvC_b`EK6!Q^k
zGzz~oVFL9IS(FO&x3Pg9vj>OQuA>{dLGfHB2MD+hZh$K>k?O0q#X!#6O(d<<6Gn9%
zilix9F~gWhom4$1gPg2$RF(oJQ4N&?`!o6gc~Y&KnMLTINf?j%Lz_}|CJaN+WK7nE
zy8~IoWU5|x4V+8v-?%~KAR@;ZSsI!>86oNXAspIMb*>ZuwO3G7d6S0TOr~flLc9~0
zT-pNw>0YK&Ba}e$M(s>b>F*gD8ktE!(#F98RiS@NqNRJnIi1a<Xur#=xyZB0ha2RI
z1-5rFQiiQKaYepUXqoCxJv{B7f-vsvVGSiur7Y>EfdXCowQd$|YKQ7JsV1-W47D+L
zBVHgIx6@Xe=EGib-_=bd7oH?owCNn4snIkVR<r9m$YPF?&V|{41rgtJ1HBtK-o!a9
z^EM=!UC$nYbbJsyV$o`VATVH>EBZST9pbYqrGuhk{7em1oKB%Z*8`BJXaGv{dNU~2
zeZ~d>)$&&j4W3RBDs2b`VexbfLf5q#IyjvcNm~wRs7n@+ug6&7%z~I+y<mJ`rx*+)
zfB0r3^$fUR89s5w4DxB&b+bu*V1I)QY8(g1`x(cXz#RAyZk0x{`uGpwmPpwpV~ChW
z>B}pQjn%x_8#UvN>cOxtr#rx<sb^BD;4gm)&{P4+{L;q05beUihwuTgDKn{j(0T>T
zSk4M#BEwkHsJ`(Rl94khOcgR361-<7^sATx-yZN3Hj6^MV}B6(6@?O`+Vd~;N;%ir
zaTXM;xKNxl{L=DSblf?xq$qihPXW+~+0<0!$fm+4XH$FW2Lu$6zf!tt;7ByceN|ER
z1YhM(u5&0n(4(F(nK+qZ<FJ}KVRTD5GKUpOqvuehD(qKaT|I}=B=uMg6`e~#-XTff
zS2pMhV>G$L+P6YOKhC9!0oxM4hhq-wSs^sCna{nLqlz0kjtLw;w#)WvwsD>C9Dam}
zpVJXlr~{<0aRHbNlNg%8bhmtF0M-1B0#&6|&@0_<bV7Q%Lqlcf(cX+M@!ykR$W~c&
z?9cqNQRH{wv3}z@lGo4{>-caQvx_V~j1nH}R;)$G_T$;)u?9fen8)ft)KzM;Ohadh
z0;8%<=9-mZ>Kaq5Ms*9IaH0fe`s%5V^l+Sprs^roHS6OdW9|)LWx?wgT=X)Js?wOw
znT6<+o*GD(wrMCyhO0`SsG*)ROk?)PMZ#4LgrD3d!<}7*VNIM*zj@afQh?7|l7fMT
z&l*(yK(>{;>YmSCW&L5&H~69W4p0T*t}d@r+|>ZoX3DiM(Cn@p8JKWa^8v=)RcQrm
zFu=IGN_@OXRIDi~ijaow|ER_0bZBj0x`+{rU{I78adbyu-Vd%A)vsYh5F?gT^&JRN
z=Uyy8!PqYVZIoPuP$)S?Xjwc;aEr)V>scFV7D3VMg<AE&Z_eCBwA<df7QQ^fqQ+A1
zaOzXH7%`%H(l=wy&c!s;-X(QD4-#?yYGQjwD$x$X)ZV33qsZbujK$^|87os&M;U!t
zN=<x|V%eZ8lQDKqfT=|tHo~_^+mmAGw`CNfQez69vvV13w3jvv;B&7?k2jU_)ik_%
zx5!BAmSYN)@*5WZmQ$0!PWgct`ZU0?dEEwl5V8-Z_5D{MMm#f+&$@yGS#k~1crzwH
z`s;5&m1Xi(QT5_?$cft@m~wf*%-FBQl<Q)}{I$-%22p2MV#-zd*L+hh9}K*;N^M%9
zs8km*<x=5G*K9KyOFJ4uVcaUMg1sL#n@_pCi`a3!Y&VQgygdCCx|deSPr>3>puqlr
zV9UE%nw*&bv8mTOSSC!p#?s?Iskj5CjWgf$@urc9x}pl&6tKC>YRtr%-dn_GVml?L
z<w&%wq2HvSLCPd-12|<!Fn}vHlu1}TNMipm35)71{1#@}(?eOg@LRuD1J5uC8|J@Z
zx@rD(Dc}5S^jt(Kn086~7b^3wG{7=VTH~TP6><HJ;R%ba#QbY4U~T7L&PA14?NE!#
ztV0}lewx4&%t|oZ3Y4B<YA|*km6ERE!7{O$+5rN3WF7pIq*Q6)j4Dy<DI_?mn$Vmu
zl;EO91kRRxhd9AHU_I35c?8#$RQ%GG^^{Xmi<pHc%V98)R~+{v1a1ROa-Q-^Kz4cn
z$c=3>L+NS~6{m!aR8`e#2-r1pBeIjeP<57_e1Y0LgaDg?rCxUp?c7K!C7&r8>b41a
z{f+IJzS-vW(@@6p`iatw(oLz;4)Q3<6d{U@-7IR_0NeZ)Z6+U;dJvl1xtV1o5g3>f
zsFvp9?7JfT-%LxTUpi`N*%pM9T|ziQPt}e`5VL=`P^6ptL_V_0I{AAQEp3Zb?~Tp6
z5-OKR!J_?Qto<6OlDp74J-M%whG;ADbNvOJXQ9In84P!kKlA`wj9V#MrCSL)D{rGO
z(nGz5D&^1z$stgoqs@KLk-VLP>+BpW9N1DGp{&TV)wa0b6m5Gf9N0{Ei?$8MGp*bX
zZ7U2{AGCu4i#+TmR$)t%cIITY%H@o|(q8C4Xm8XGBxp0nAX&eIJ{K7X)L4TEDnePZ
zt|}#0P4lO_vd)cMcfvufOw&-Co$yP~J7{RkP6*+x3yWykPTDPPoui@7yU_jGoi#LV
z7ll@hyMgYXQq=1jC}sbkUMbC)dI>dP8pd7;4O<-!-jrC;)Q9elsaKc^?WP~4oKX;N
zWFDn)6EJ0D4~M6VT%>cyQ9>m)e4UT=!QHTg6Y=WtZYp2Axbi9;uWa)Cmq&^^VR*qj
zl0t`}TWz={<oUl&Q?iU*>p(w6mhn2uELq0m%^;9G<zGs{)#VG?_uor?o=M?CziOex
zs1Aev39Z_28Zld6Koq+p6s8Y;Y3^RS>KuGulzhB|lArcbN7dV|;KI#)G{xELXYQ8<
zz%LbLDSIDkdX7S9&3^J$-An};m{&Cte-2@PVqVq6_qn^Uq61hCV*um_69q%j>llmQ
zDD6DdW#0h`S3P8t+q?q^C{}4T^wU9#^gUH7Uq!>?tIXRVdL#R`x=^V;?DanfDcZYT
zen{5DPykc8LsUz8)*R8xA&T(6Su#Jyk5@p)3*ckxW4jMgjB4FJ5c28}J#wl&m5ZJm
zy&OfQ=<X$IMu|tLn#XIm{8&m{MpHA7kUC+^V5TPz*!IjNkS;9bXV|KWagw4cMxiR&
zLKant#WR(-LY<`B@CzwNA<ny6YpC~8OkEzi=5JJW35_m13T5dqNRxByC^^|n^(Jem
zsSfMhxyR_Xv;v$waU9`W#^FWu;y6u}<|B^#<phnCPPIVt{saY9{`D*vFji5DSr{Gm
z4@z-6N%$O$8g4R1xzLCtZ*Zr{Ng5o~wI3|g7A1E-?z3(Bp&~}+?nzQhKaEDx=LYf(
zB>~RdPUq)B&JlU7tYG#ywE@PbN67e<Dt@@HfK>w)$-aU8bRyYDS*Pg#82b*eD39lV
z;63aJD2EiKC<q8B2&Y(35L8g$uy@7Yd#`6#M2yC=FK^VCVyv-8jIq~5V~-`#SdwV4
z8#P9adjHStzW3f8knivB^T@sL?C$LB?Ck99?Cic}lNYL~H=b}zpaBbNvgqRZ_?Z$k
zqQD)P$?vyeDk0*2Kffr=rdv7{yVgIF+bj_>TJ{WPrUOGnjpc!pjXDFHuE0x-oZF9S
z<eb9rwa!co!>3-^3u2s<!*Bk}GtAAg+<Xifvgxu;VCcA=WBqmQXlXh59Q#^oJ2;bt
zpU3LS*hq|%-nxQ#F+{2`_X`l>!On$xnACc+Q|RQ*7g)M3xGhj^y1=$chnr-w?iX2@
zXRxkNi30eP5KoFUsXL~`A1<;u?@dynOoVps_sHjS31h>Y1Pyu#9`cC7`3lM))BQ+3
zU0`ICV|y;K8oIqpLB_pH>{clwv<)<~b$IMExj7c9tKi9TF=9!uEdIPecoOVZ&aL{0
z$;B7BaPQ&>`w??#Jo<)KM?Z=Y6Z}u8X3CYuvt@Nu%7OV_VI8C$y))U^E0|^$r-*5$
z1RHsh>3!dt(;?Vn@PRB<4;5THrV__KJIR8i7!-VYg^iasOvub1c9peoly-sD-(AB9
zI=f>PyK{|wEPV#a#t7=muK&zDrAx``F#7fYc!d*>+!(eQMt5V29Y!t6sKZDajEQR>
z28eH+{x(aX`|z6HzY3n2_0xu{BgnglkkNs+wGp(1vI(0l3E8Y8=*R9NZ)M~yGJ?u2
zRa1Yz1!;%rrmr@lzze8o$ZX@|ln<F;oTpKjLCP@IqI-B9uJV_)#ki@?9-%O6e1ip)
zJKjyys3)9*Z@_8(w6qvOf8L}KbOEDwF<ZP~VI6km23srTLBnmCyD&k@fEo1H+=W5a
z8h6daw-M0hG1ah$8jxA|sN+GjFmB$$D$><@ne4Mfd`@84yoKeZHFz`4Ti9N|-$1O^
zpAX1zI6#L|&3YHi{CjV*Sob<zV1eOi{M;Kv%80?4`R1FfxubLzC_f}5R%T<DFC1PX
zvl9qt!A3L!>a5hnROvcejpQ0^+=_)>0gJMzgNV3gkk>-zFvEtRIV%?WNeOj0aWy0f
z5ARki%&buz+yY(os%UhL1OHRAPx5`0f{{=(4+C*C#sI_?=ixfpiN7(Qi2K(RGan-<
zIdor4_Du*v2hoVLNHXj9khqBNY_N|OES$rVe`nz(zG;spL{byt*{ZqVPFtdD?!uaE
zdjYE$jCw^2TzeI1!IuO1FdK88HJZ1ulC&?zmdSJQhQ>5v9p@~ppkH5$x9B?`twpc9
zz!~uei>(saP7pcr3K7`_hMrYzs@>oIF1p`)klOucQIdE6!8SJCzY(%th{KJc(0KQE
zh_<CH0B^ke<0CmynO+)Ext%gu{XfzDyITvQO8i7bJ%dzmj_C@(vA<gt;@C3OLmZ21
zhhwu7D?~qzzHT{^n+gFD{4+w@3(@xngaT^H!oPPlZK*ttH!J@NYH(8j)oY~2VVeKw
zKKR!&Q;@p-0+IR&M6MA3X0tvIK=yKDA+lrp{wLY@Aryk_r=5$CJsXl>L-xuDTeAD&
z%}VzCP)_zIFt*eIcC9To8y|vf#|%Mst8+wl1IU>z+59Swbgm!7RUE%!cv>@1JSRWJ
zIF|AhccI4SD4@?7oj}K5>!;;Rj!T_&k`A?|MW0nqF+NGlWc41ifRfeDDs-cUIAXXX
z5Q+*%3|ryy9e%>_e#=a8&y=q21888JFbtN=c;E*N=OU3@u~&YiMjV39uw0ALwHE4m
zIc`j=>d5k6ry4CcVd?(;z^?B}jg{86$Ye90vXHu$P7}iYV7^_W?QX+O!Q6)nFH*Dl
zQ5~;>9)Epc0kOIFeUl)dqW4lUw)k1Qv}_!X{vAu7AVY3d=~eYiR{AeiM|xcU1Dk2c
zohP;Ip2^D9$=xb#Xr9TYJ!iM2@{q5dFPNeaYbH8s;z=T@H%SJV<@S<oEz!4WA(7Hy
zXmZ_wD|jjfr&-822oWtL`)xbg3DJ<MwnAjUn^lN9`f(u|Tv`*N^<b0#D+tkrBtcu?
zaiXnkTU&Oiy5p-?Y+?y#<g-(9Uv~UY+3(cCLUs>`Xd$v+f}u9DUoOCw?92X~>;`Ok
z!(1=@-@cseQYAIAo2H<5U$a>6VTpq514oE#tX^#Oa$Q#94M<*_P>AH@_9|}==Paxk
z+}uK>8S+(#$Ys!rHbic&VoT&$yn(kWk;}a~k?Ua=ssr?HQ>>8QvRI$;jRle24-t_m
z&>q^=FH!%p+q#Im7zG~h*h^iXs(8B7AlZWjyk}WnD`7-gDWcgZz^t#8naSk$tZGOT
z9}tHn>lzGbgq@^hKPdP#@PnASFqHU(yv-VBvODkL;s4iLm0xR#w*~Eyot;{kG*rsP
zYGuI(MC{$HpP8R(X3mbfSLGudmbaF3%S>gVaG^L~xs$&9zHE?6V9pP8ls_vI{u{q#
zUqUqCkB)LJDJ(8C|AV9K?^q`MCQrF`BOQ(vxq);9)A52Y7qww~Bzbw6r@!*lj=!d}
z4mu!|4bZ<jd7@OVWhN`@ET_94LyxJ04Obd;M`sUomM2Nk5LTpzGxrj*pZjBQ)tYG@
zMq5G&IbJfk!x=#jweXPWo?3}LT$Y3o#FFw?Qj{BJ%92RC?P{Agwv?RSvPC^eNiMA1
z<eb?-Iw*w1>93u}wsH-1-j)NKH*9v$Z8-n%x?O#JCSG@_uMV_D7wWtdugs;iJgH(k
zH6cnQw5J56v|K%O<pSUf4Zh5Os@&v1dd7cT*5Ky_A~g%}%Pz2_(0sQta)zVs$xZZB
zud;G0k4|+!=St8=7dofW%SVoEaXER2bO);mb2+&t>r+k+mS%yg3(LtPBrgGOC+&$v
zO!2lwrz`h2>;I{X1tjMl|D%dlc4NfUmX|AgA1OAuEs{r<m&2v*r7;f5qw75JuySQm
z4;JSt&y<>!Qo(Oaa&QJKu{tTWbFL$e3>>5p_jn!7U4^Ygta1m;rn_ti?gj}i*g)`_
zfcMh!<9;=Vf+Yl}yV+tjI9(i4Ffn%(d$4m+GuQ9Ii~`@Eap(p?W^QmN<R?{S-Q4A}
z(!NkE;N9gNk}(e6uL`o4Z)_Y{e<ygg1<ikfjU9o~IDm=_Z7Rsyq=9uaS&52r{W=j~
z0dnF_5F)W4{%2T<I545N2UiCehla;idDy_Le*-ZeS5dAVI;FZ8nVhnD*Tu2bgX?JY
zZ$OWk^<UsGpD54Qsn5!I$cJ>JenbbK^^hNX^~8K@Kj?97$xD!RNiRoBuN^a4Nl&?x
zu3<$K=;JAWD!F4omZ&73molnm=KowtmK=4{U*QW+x4q<6(&-OIs7ZNincCm;QTO~r
zI(zIb*RS&4Kht4v3bymf8Jp!vDg>u%pQPke`R=`uCHu(zrB-;@;v=ssQ_m%gG(f_!
zbk@UHt}89_%Vc@Ja%HLcJ0siUi)tjygXJpA-cqH6Ocq*MZYgE|YsANo<yfgT9=@(D
z`%6)HI9FNrlU(uetTOb%g||lBBQKBEZ9?nw*H)3^9i`f^DewBp-K0~Px|;gS(<Nh6
zCi~uB?ryvn$W?V~v;I*q#J32OrbTjX?K=B+Iwp~Q{9)vniLfP#&D%N>3)KKQK<fXG
zkv$B6Ec@f(e1PmFc~~GnzB00r$?K}Jrh)QG({eb7NO_(|^t!n9Zr~J1rV*0a<0*YC
zNKHaiyF)<+CB-7Cg>4c_;!Z(I@<vjCZ4zR29SXdVlmhh=fNn|2Zkp-pHao}-&#vxG
z6IfPNIZ3zSBzpbpN^+Rgwh|<wsyw<;^$-%&<5d4OLUQkWNOc;Q>as|>{}q60I+0%B
z`2*4)18CMiM6b=RCa;$g@K7sAt|OJi!+;>UcJ&2%A;OCZ<#L=Bg56VaW(A3GJ{XFV
zqxicx|4@+Z<EZQP9jLk)EZ>#B9rm7`s4i!DzVfq`Vr<i!^*O-ZFhuqV`RW;6=mDQE
z#y2J|x-qBXu=m=;#c$x*SOH7@5ZNSoVGNr?<n!+B+yzCUG~B1-vNATKjy#C92$TEh
zPTYmO?+BASNG~26S-Bc=jI<vQO=`%Cr5bp+Ttgl%?RjKm&BO7~3=iMZ!%q*5EIa}a
zz3{M#9-cigGS^5vOvA&BNEswXbJ^c@CY?2?DL0ZfmCa;RYRWm1OCUDSYso?GPdv4W
z2(6rtvC+7e+(sHyU}Vc{$x%`W9zMO;$%p+`Oa4Uqh~}p#jFcFR%#~4cq!ja~k^LAY
ze=iNVXJjl|-lQwD2mEYSTYj$dz>#OxFb4g7umpN0Mvjmsl*iUWjC|bWa6?F47Hvv#
z`FS#Ml{qb^Pf#fy%m5KHV5%if^DJCzp4PJbfu2Q{6Si0?Qg5%<vK$s!F4|_n2?>XS
zImluXHLVtTmfGf_>p=^8S<pP3hH8GYO^3E|C}^Ukcc=6oG#RLr^7){umfi^I8;g_=
za?&#RAwxIY43(&Y-v+?XHq9W<llpsPvQl+0DK^GKR2{j6^t>X(tB$-*O2I=&UAcD1
zX(u6GwEb9cC12?5^0P_cUsoW3e~!QX7PG7#NwI8KU3pard?)no8GJ@KE6GoHay=B-
z#5mc-(Q8FHTggw!LHwp!ABKuo*OP0NuXPjGC}lsxjkxXpK;i54WTUR?U+>MVW_@|1
z)KH(9f4#mu(5a06ORlb4eUZ*G;^p>I$6t&ru5VIxb|zl_v`lUQ7s@xEr{|ArB!A~9
zUB|Q#n;?&qKK9LI2m2=lN#R$G?56~|j;W2XUZRA#lB~Wah}Wj-Yo>T@roNKAz?f;S
zzK-CpE-CaHs&B=AoI9(DYee3`>gzV~Iz)Xv<Vo)x4v_(M9*<<)L?exTnuw0Ma@m+4
z)&y$5<h`#xnD6)3v9rA}d4H57r%DaWWwPr@a)%PXyf-@BKf+EAPU<5~!07ulS?*l5
zB7j(#b;FI3j+qYMK_>`fQ04b#m?FMSVaeQeC}QZKJH{h9v#A^?<y<tfF-<W@Q}A#r
zuB#98ADXm`wQDB(NVyk`Y*aJ3hLnkiPn*eWqra{srhrUxqCzh_6qM+oD)Yxbh>^yV
z_!RK4J;d+)u%vFfNuOg7|GPUWM)G|Q?UW+-@p}iNRi&Ij`fT49P|7XvWY*t7S1wAC
zt4N3Ouq8#_AnEbYITbqXmP006oGRC@*-O=+uZf1CYlU`RJCcO;BQzL?V(?eHwJ-l!
zs+{boE42b-#I=<Fl)i3>^+TH6ztYk-_%ODO8AumZhM=}JX;9NmP75{tJ-Ur7gX~`l
z%q=uE{gnH~nnAhVNt4HvI*8!|hxGSsWR_f&nbPHt-6}p3<)>2v8+~eK7y2fj(tUFX
zs`_b$+)?`Gdt-hJqnxdi>OC>$&mElnv7_z}L_FmWX(#7Py09f6_hveped@N6b?YQQ
zGJUy+n2Z6%ze-u4ONQUKAFyNi*B&K|Nw>WL#FP6;NNOpPe$Yw<QqoyUiV{ivw4@M9
z+DS=zk>sQ$(e=^=GLlU9-{KLKRo!i&gR9-CRE!QIA*rEOj91o+l8%X_efgGB;e@d{
zC2bH%?X)C6N{XPQMItFuL+Ed!G<T#u9EX}5v@%r*{-z1wq)9_HxEI0i5S+~Its2ps
zvL6Ue=C+%bpEq<n!O7fq8fnMTye6w0&1~xE<V04gtL*ES`ou`~G3jhNJy1}3F(mj7
zYQ(pPo)}qTS6MH4;-OPld1tKGuR;{uC}*{gg>voEo#eIYW4ep7G5*^6XOeMHA@l1b
zJ!{uZHtPyzLKHf7mw%GhG<eTy^^gZunsu+J<W@p;+j>B9Ywr=&t+z_<)B1%Zw+<BQ
zUp?dr(x#_IHY7{lDwY1($ozWBS9MRnhKRoD2@81TH^%(lz2r)g^zjX2{?xv*&QW(7
zF+6NeKe>%=3_acGhsoLhk}<zjf4PKYdbGjP$$XM)9BUPgVOkP>gRdZnl2p-1){^*#
z`ASogDjLVNBp)jEB*rQl$F!s%O1gw36BmuFuPj7x`TPzETr~P=1w5$07X&BK_<g-4
zKd&Q);3OJ4EkB>pM-!Yx<BXQypYU`6obJKSO3h~Ne$R|yjR(tt^~>GT1ca-&AE#>q
z@)ssSbrt4Tpql~sN5Es&|199lxIM|h&JC6)g<L-)dXg);dpMv&K0-eu2~H_wM#wDw
zVpbl}C25^5n1W1vyCz*L6Lt;7uo_(BK&wG7=9amr3^R65Dl5G`ZDf(d<ews1PX1ti
z7(k0?$4fMoq~vskum7Y3k>NU~V?h{l6p!T8DJZ1ja{a28e?dJWa9|B_V)+!b<zwEK
zy&{P<=$6!)l^r36MLffY;7NOREch@@?9S9_Neu}=PP5(zf2|{cWsQ*U=>8p!1~nZi
zU(x-w2_}O7D7nAq3Q%iZ`S3e!!>_}V90j>=wpMT}flk(vVg0rs2?f>tKHP1K!|g3j
z8riR-U|8?DVPri<%a^5R$Bp@Q$B=0MtU&M^kCii|;h!7X;<0j^6pM$`W3isQ_Zhym
zJ5KH?&BVi0dho-;opJJGsS((5VZ7`qU4|w5U_2ZIe|~CYUK8Yl{=uJOn9koCpd*6b
zH=Um!h$mvggo4f^(YRL=WTrbv2U?<kUKAz`I%H(~C(1WWPnMHJ?hEolckHb|tleG>
zf-j<!4O?te`CwX#)Q5v0nxEMwaVeibNwiAaY@5XOY&S}xRa#ryB#fCrn5UFR%d};-
zX@Nva2$ER6$?$k=KWk(MCS%RG0uMh=maCK+cb1EG8aqEFsUPbzMNSMi@sF2NlXFK2
z0Y2V{`h6>88x8^dwa(P%r^po?b)9>IA@`=rcci~P-m_EF<WU`OpRm(++zUMhb-_F7
zI{O@7FCwDyWJ(ThPfg2y06RbyvOvLYn5qFQXy~EJ0%8F$q2sL2UL#v(k|#^f=Z&nw
zba`vJ-rtgWYA#rcpljxqEB9r!XJCD`dJzOenIR9A{$6fmWoF82%gnsNy@GWnrssb<
zQ{L|+t%ej#oFnH-e!GmU^j!HjDeMO$doovU>VE$Kt~iJ42WmLaXPtn5VV)c!Em>^D
zHX?+q86NgGPio8F&x3d2+P6klcfR~m7uXYQsFf`*c1?#u$5q8{$w8T}?(k<F{<~Qv
z<~C)nD|?xZHQM?fVx&HEWX4}G+<zRtsI1gxD-7TT@*>mWIYPUY+RIh)!wOdAI_9F7
z<4Or@?mQ)_^KODx%7yy;8zgbv+D(IVY^w-P({79g=i)kt;G|ofQ?&$+XecF+a!u6W
zeAU&C;G|rCn{6SNEAM!~Nx61R$!3l|nYCD_g>tChLy{?>c%IRmx~T^gPX|1i_2>7)
zT3v|6&U!qYTqrk@dgGy7E<8nt_ral)E7y)n-YkS;J(V@~6xwKBBuV8+e7N1LAB?|N
zZG<a*7s(fNU0S0*?k<x5^=*jniEEBS*wa4|IV6eSmS#hi$)VEE^RSd%CMWBDTM5N=
zYnklB<}b#8DRU4?XSw{X)P21%|A!^A?5Mk*4y=8b%8x3Z#wVj~u|gPGpJg!42h38j
zjg$qpsnQ;ZE=N@EOJlz83c0hR#5Nk)1SWr`iy=Cz$Z}f6><NOGp<;dfhcgE56j@Fx
zo!d%C%;FXKN#0_5a9IJ5VNK|?H?q98;sUKCw~DsvP;z^o+}dy8HX7i^NI6lcK|xq+
zaNdb?K4Y7a1uF1#Mc^Sxkx#``g8HMJDU`EnTN?d;7IY3EJ|}M_J~zT&E1&u88MpC;
z_n<!MaJbQglv`!W5gKTQP=FvEhKbZ7mmUD}Pq^b-!gMEg(eJ0M7^&EyDJRhE>CMp`
z=go6@dKhR{Ck^oS?)#s3=+pElWFcoIih!IHfv26oV<J2s8szzSvHu`P{WQG|q6mTL
zS}#t}-SNC#t^h6{Hv50zaf|J1N6)@PoSp#!%~*lvQvgM~^#4iFvzOpAN?96~CJ?>u
z$?0(xh-ztw)~@)kmSz2IkLbohPSJdUX!$tau!8`y1E|vLKk;Oyw6Y^;h`{3|@B|Ay
zM#57QHF_=oPkNFD_ynPlrD5;z*+%*TPZn?3H)A<Hw*Vv#{SQ3bUZGt!coqsgaRN_M
zfoC}3DUY09%l?a=+ppySpSNRBt#%zaP0T5?PDT~1?fRbiyn!3`<1dUX{tev4UGT7^
zbY2Mi<c(Y>ax(ma6a<XuYlA2M#FI<A1$2vDTYLqOU;2%a<v^EV|BR9Q;f)*-U6mK%
zw^1AR51{L}TpAWFf^S!UhB;+7t|4cRZ{><?*jw2%{QIF)ohaK|l&w-+*-%ur6{j>>
zeBGZ{aCj6k6{lMg_k00*)Z6<<t^rH3F^cITakL=*>$}0orvJ7(^~9JU`1Pl)=Cgk?
zmOGqHEeKIjHvQd6Wz%nKR5oqG17}mqcVN@$!B#f)>&Ho2JFi$ag~2l0@(yeo#fylh
zx`-kRix$BrJwc%joBZB`O<p!-clPDg4K1$h1l;}6<2~5)z7NmjKB71_9bQ$4P49o>
zY%1MVW7FAB?AR2b3@?^VO*_0dH*|KLvjq1I!GTj7)vx*h`{JKfDznTVz^qCGt<2id
zn-lie>|&WUb|sf7Pd33Udqy7^U=@x|qTIEj<;;4&m3ADvh_c~*Y|5H@@jAaPuI#Z-
zxL|oL56_$2B3)$cIkY&gxq~Hk!j*oTbFEV+jca~+c3ks$Fr-+nEpMv|*GyEN?wA)V
zwZsD#u1$`4bs`7%v+}D%PfmN&nZ@$!hdd)rVdO<bSKvj2aDAP{i$oMHg0HNCLL1?l
z=9K3dzNfF1&22<km*UELp|XQcd91~%9=w9>gNkEQPny?k$Ka}8Ih!`L*Vr@+8d<$b
zmXE>ugsA8kyxU4;(?wYwgP-7mv#E;?Z2GRZl}+utbCQ;uie-~G!>U0CHud5~1e@M>
z<3*+vEn?Om0fjbfs_6_im9i=Og(%ytxUvIQ7};=Vu<3DEUV-C);@GsEW)oXBJ^qEW
z=}jArO$V0RvuQ#9V%cOcs%)x?ioY%aX?lny17}m&l3-KWo>n$})rFIEcS^Br8n_J0
zgOXs=jx4K0q>Cay7A<1dSHKix!={@h!KRKjWnXmW)qP!D**!~*%)b=a6fZKh>RTL}
z9Ki!SHpO4#Y)WmVv8ntLJ2nOU(x+H9%}EogYJpHyqfmXf(s|KRBRqgv-6FepxAN&t
zM^1R$q+<EBZ;7g<qRZrYMmzIzLZ;S;a{fij;X4wb(}r0&C>y@1o0ZYcL|KR8%9cfq
znEt%jA7%1pw#e<ksr#%~aU5&4xDdy3FLRFNWoR7hzQ~SaJ~aqY(eZaVRTZowSS@lj
zm4gQ^ScA(!ur_tEGOSs9PSTw5#WJk)M@DwG90aR1FCuvLxE(Jtq-YVdeg`PD;Z-9S
z@alDEE3cM{vgyT@?YPLuOfC?tU)%Bu{_0U2n?B1e#HL>_ayH#>sj+EGjy;<u5u&1O
z3U02lsRAnI7S;7!l})~`VAH=Ht!!G+hLd!8OtEb0w9v?=xq?lf^CE&x@uJASqDA0~
zTWH6oC$3;qicQ(yTl4Bx6<2nBj*-=J1Dhg6ro?W=vFWb`h1e8%p0lZ5s>Y@d^EEb|
zuaFlrlu}?o2Jo}*um!`2qX6JAJU;#lz<M=DLJGc}n*u<-3dl?YcRK=bLIuFFl187H
zcDbwq5Y0}eDWG)K{H@e<mT<kJN13NxiFTJec=z+ltK@`r>AH$}4Tq)_B4tC1LZp1J
z=FmvFssc1p?x_Hcl)qJgJt^iCl@wP&iX%w*08+|s1pj6nn-3fHD06eqt3B*g^Fl<G
zR@<iWr$Ei25%rG>(1<Egm?(X*MEP5Ys?~+_ClK#v-Sa%l1#Box)q`gL7gePSQ&p)j
zRn=91#wvpfuxC}{<|?a<ojFyBc;{3lthb?R#E)G)Dv!g8J@|{y>F=4LkTUIdC<^77
z?g?RQT8QlXDnMiAYZag|v!vQmjhUV*KqEU?1=y2atC>o6<4&CHXuN~$N>1yHtV1OT
zTXG>%I;m(hQoIV25~2b$QtGGxjg+P;z@8LiQ<an+9XTnj@V=!2NcjqWJg;I%$y3p2
zq{OMjYFufq0yI+Es{oCZzAC_;l;O!LDW(pbl#zH}R1tDdj&VD=ub)(iKW|io8c`k9
z92!ymRe(m+I2E7~HAe;56ZKJ&O4O(AIZ;dSKFk9|eOZ{O&P@stRj)8n6Vx0UQS(%Q
zM$`%wpb@oJ1=tg{wTVj9!FHUe?RY1#H*NdEN>wI(Wj4DZK22eWMK*+h`6LpBcep!^
ze{Aw_XQM+WeDHQUREmR5eixCyjGCV!`FQ>%w)rie#D?N^gTj2DknS)vC7XW>?%Znf
z%(`4?OV!dxerdbi=7ZS1z5<y=zR_z#z)D`y`4n&x!Q{o`1i0H0z_Q$xM5oiAu~st`
zkHmJ3C=ad$Pl0DaM^6d(@{f6!FNb1kFic9}GuVT7K_IRzzW0TUQT*y3Y+=qYve)iP
zlvA=mXF40Np)-^g1z!ymGp$|0v(uqVPD+lb<(l{ut|dJ9#Jm)opmzj&XM=p)q|V>z
z`@-TqWyT{?<tf?tZrl|5KA^K7T1|v^#7z}0UP{OA_+I@tf_}6m8M7A>(Gur#Dl`+V
z@@dXn)nt$$4#EBSY@6DuTP7nezqO2=l<emz*&q1+jak1BcEwRIrLO;mX1u(jHqNg6
zFcY?oyp@i|T<4!vMuHH0P=sbpe6<!HeNdnm7?uqvhJs(F86CDcStzhHogMO4{A*O1
zB3O)B+RzKtr@^ZNNopH};eg2D-K`-cxz6#ev3pV4M~QQ41HY_~(oz}*3vh{#5?{Ry
zGGyO6aESb~wU;|M%zCYJo%09r6kgjy2=g%Oldz6?>7&$i|D4=80B_^qv<^mg$hC7N
z>C_mQqrOUK|94584W4Qv;)sozDjN?^F|rfBilOX!k?G_9)$u9M%8EzepeX_?h0&Px
zE8#HSiAzK*wIsJ!YdJF7$l6s_63Uhr2wv93H@XRdbbhjt<yThPl+A0x>+jvqg1XCO
z3o?N`2d*3|YC}7Ldg#tkV6fx;M?7d!9D?R8l-d~`9=5@i$1{mZHVF^fBB4H(rG*nN
zPy&uqZLlU#%>`iy8hcn8Uo@JDT}53#AFl{hNe5D=yvQ?Kr_p|kSNJIbHExU-ojL-Y
zdb2M{L{}1$wj{i_%=)nz)C%X240LJ>KP6I{Gsnm#`Js1>Mz+gO$*A@gR$>}<e`WM)
z>Z}hqFx?YR)bdc?uwP~yS+Kv-(kTN0KK@FA|6h$c=Zw5EbyyEjdv5mxY;O81ZOcv*
znHnM!iwaOY$|Ov{mK@#E=EN>c&GwYG4L7p>0ZNEdI$9Z^1o~fJ0)g5Wv<EBz4fX73
zsD&+!^8w0`D*YSry3=~2q1nHY%($sF*Bp=Ni9jX8|6M%KvX`=0w2p<m!{Z=Wfr`KT
zEx1ysi4^mI_@7K8dljg(t<p)9z0<P@`T&&dUscI8J!;6&Z|qeh%g(Wu7SfO(VAlUe
z-V{_a0d2t*nMMR=wZje4JhdPaQFm~1o~V<Kw2m;twJUoCP2G_FVN0{#FqJx=%M;;o
z!CnZZ)J7EcRE*DRO7)U2Xi#Jy<$SHNXb8RBD!BRBR#<4S#2h@Sx2+w<wpCNSynjj&
zI#7Ih(w7fr=h9B_Q{O?d^a(ojT{Wd+`BXwHu8+Dq$jEvHDVeQvoxe}e0X&;;?mz%<
z*XPW6k|lT#r}J#ydbN)}9}OfFGD!cX&w5|db$Jp_3`)e2EVKS7bb~HfiPqJ{ZK$kX
zuo78$%OI2xscpv4<34^aAD0cJ8QIKWCAP}rdc4YHs!~WqmRj4cQATztSm_;;>zv$J
zkjeFbuA!?a^LLLTWvXGQok%L>$d<UbtjMNR$F9)5mZBpLOe7BQju^o^^b94SAJ$GZ
zvc1R|kuVSdiRVFk3Od1WPdzc?K^}In2BWxj@Gf2vqSUS444Y#!j=4bw({hId;giVX
zlb0vZpU}vB)4549Tpb}wi2wX%4){{9>zsJhop`Vm{-)&Myk(jraBoH@IS!ob>x4T!
z4uvTGQa4OCQInJa<`k-UIp;=Z#p_t$KBZ#hsiCy3JcTp_tx#$1!{IdDSH6Ju3Ccnj
z8tZa?F4be;_S^@J={~~9GWRQ$SZ=6NL!S>gobv6XVJKkwh(lQPPz2<LD%DZV{Dx{Z
z&xaIOO~hJjHRJ2>YSve@R8tT7fLGHu4Aq<i9M!Cd(yFP5YQ79pVtjI)zi2?c$?XmL
zVk*tiXoSlU_E#7_Bbpl-_a)UcgpN-eW*K-r6W!H%$~PSb=1RmlvZGk5{fehY>2lOl
zKuB8;G~btMpkw1}D7Ac+pd9F6wKO{34aQK#Xkv$IDE{?tC6mP!e<E4uu$O|763tgh
zMyX3t`FW)BV;mf8_#UsR7(+S1SDIj+4_8u(d_-|XxZ<U&l?Y|M5KmG7bnm)wrEbvi
z7~YK7F4aXi3u!iPImD^LK4*xLIYlT<oW7sMnnfs8of3^~P=pefl<U0yGhx#3KF6%U
zm+8(QtI#aa`D<;C{Y58gY$3#-4>q#95lVF3`uC8Dcn$uP*(mX6pfrpXg<BO@xIPM}
zM=JHb@BU6>;2cJmbqt96J=R1jL6NzUyX)$BpOI}c9;oQ6)37YLZGt%QbB%bUg;~G4
z4+7CpMEW!ZK{GX#tSaHrocKCw{Q;@jw^g1zABdRpno6L1dGr}|OBNrudy=rzUsI`3
zWk(b*S&vEz)nPF}CZc5dT1pM~g<StwO4dQi)LM$4PeV~s>S!%Vu~8*ZY(_05!l@BF
zezg>%v>QV07zHggtQN0oe+R)~8zKz@jI4E(5+i-o1MzrYE%9WlqZD_icq7{$rA&%%
zl?a_u7a`HZHSHr>5l0Dr_{Oj$0fV|A20;*HI{XVErx{^*l;YW9MR$6+RdDYXW(3Z3
zyW^Y_uvW-EgRlCgX20TRI-LU=h$$g}?j8+=H3H^2hXTmHk5;BhyD`(I)>c}Sb&KSU
z8qgkNYjtgW*!5gr9B`=(&NiSLR|b)~g?>!J8|m=u6NtAMW@P5tN~5y<B6#67kAoc8
zXR**Tp(xxVM)7h_$7D#oMFt7ZUV)eMW0WyYi>I*<F-mjE3_hjADj8*6!a0UoZBaeP
zaIQD1k5vMl>KWPfSmpDw)obt^uUcDj6!b#0he3%idoqltOuTQYJsT+>42oCTehtCb
z8i+N(Bo|mm39DZ9I*D#M2!d5~`z<yHH|b^zVI%4&kue8@Nl$d8rH-LR99IpSgJ^F#
zxDJ1doW?U4eDQ|$+8@_L@R@3l%s~Ga@Q`3NlU4kQT__tDV_d{f92E{Mq~%6dsY@6l
zKjWY(dw~c8$B_eF(g^L#_&I?sk($|NkPEtRh9Mja&Rl0bff8E}DuL(ibp-6QYJg#j
z7mF7x9AtEwMn*Sn^~4U{Tj^1`C%JQ~#nWHs9=7f0XLI9}+CB!OLwfEyQh=#B%ncSK
zpULhO;9{GuaY}H|cWoT#BW`o<qMBDn9O-`X$)#v2$>d*CM#!DP$kxUwDWR_2sBoX4
zP}0g#Xl(g7()*Yw(bT-^yaRvz9Ua(nA;hN(#3G`e5~aTd5LEVz0HLx2%=%{Ca5AZ$
z5*yl~E9v<mDn{t-_FU^s;TZ1(bBu0xEEvD&Ze)MdQ)>Eo00fM``)e2%ccn={EGyZX
z{8Y~t(`N8FJ7va6irPh2mg<t&-5l&62cGh4UDOmv5(nKXczK27>SkYiE@EO?Twn1q
z`GC9NTw#3Q)h&W=JqO(?Sj_QFvcsny^fv2HW7V88<0z*s`<6!D5R|3RQY{5vum>nD
zyZ=80i5y?J9lpgH!pWpmv|<{<%0&^D<_P~O`0FyY_j(`O_TsE`1Er?48*7on4U{<l
zjn#M`)Jzv@GL#H_uY(XGD1zZ#q3|0jfu=zsQ+jP00f=l!+_MfD)Lb>uGkoFGmrJvy
z#kgUk4iePRpF&N34w-%Ej;nKE9#ax@r4h?Ju)pBsPek-~Bw)m!LcV@ALoFRo%ln+>
zrBZUn!;m^@4&DV3uvHN(t9^n;L-}$D#=mpVDi9ucR&*ehdsf!RkShq1JQ^7^aIibb
z)B+q?z;DLLm>yJARVw+lxKfD#2uelaZ;>A=QwGCQAc9f}!q1A~X@RDg{=CKirBe#K
zlL(3MCLQ^SBWlR8lQ)Tow(%w%nZ^-&9ksR=!#}4aDsLW%PU)?ik>dEh$$T3+=6y|=
zKy<(;h0a)?Fb6-0H9`^1Ith;vxyqb-@mice<<;NW3rozBRi9K_u*mr#A))v_3z7{$
zg0dcef^`8l@FfB+xgo!a&P7=YOcV)ugh+VT1T{Scd<VfPu+Wk}RlqwCoFWu0@Mr<=
zLvZ0F6L`FB@~e1Eyt$4dp)VDnD|{`8?xXwBf>;<;b}hI7xYqx0DB`nxx%!|8;%d1C
zDUKJ+chJ)f37ei{gWRn~5gU#gDj*dSXEOQ<krOOEY1Y4rQbleVdP!vi%J<-;7<7b`
zY*;SLEd;QDa?(Le4m1#PwtjpIfpWM#fvr%?q%ssWd_YHn?7z_rRTcoe51=jC-B1Q(
zD?Wv&PP9-xnrNX&WKPRQ6z{j#LO^IC0v1Gsn{4WuCJ5+G80ee_$1qR;*AZ2s&p=gM
z0W4)#S7QNmCm;n-^WrrCw55MF@PPj7-YWfc{)95>XVwx<Uol-28g^%RcJ9RenR+?b
z<r>FB!;TI{CGN3QsBaAi6*O3(VV7z3I&T&fD1w4YS`X_TRSKp9A#906SSnj7ld4n(
z^K$W10D@BS1}kA;Wbh1zhJq;iVF68`eZT0%srdiYDnq@98@zezMsOeX<{E^)7$0@*
zNyRnK(!l{?Lc&azF|ZwYtlicfLIMf<;WuqKp)XSfa3&hGm!gSzx5Wye$u6hA0D2Nm
zp{!86i~wd*amyGAj{Y0GwC(nRygkleRVpO5>5-z>9oUE@C0zQsxe)<`N?h49zFfJs
zY6_e5PLfi?APc}`;3+ztb#2R;5@)AslN}sZcw|P#Jf%9-KAgnKh`-^<`>-E>i`>F9
z7+P}FE*@ts)@HS=|JjG^b}}rGx7F>(bZDr`oQ~#TznYxgrGc1_CxFTlXx1U9bsg=1
zOh;~vhW&agTX4f*xT=7v5iS~YD0mT!LV>T)!JPL19RvuU05m)#7^z>tHj8Y72t={u
z0ObkLN&=By0BEiNts@ZWXMjc%NDy@#U=XzdOrp7%Fq`$4YN$kgM1@E@pira8Qd|#%
z)y!?kW}hI=R}o^oc?gdX9YI)f4I@wrqxJ>3#hz4O<>Qr1d?+r&_;sp>DU#=QUPruj
zZF<-;8{|d6z))=~n0(y3gRgvXat$v-HRr+=`go4;EtrXg*zbVL0Z_v~^vcVT*Vi$G
z+D!W+WQHCUt3KdoM;qi-DyA*xshe^QJ%ylrga)!F=MbezE4Sj>!bUV#Y6YL+e8e>?
zv^x<BCOqQ3&7%d{l1=S$+B2Q)zme%BoyWti=1LX*z_<O!in=Z$Az+~5>5@1Sb*Y<<
zi&;X75?9J%XtC)j%0U0Uo_yf+P87Bw_kMV(D}56T$Wp0_A*P?mbS<HnOyNfI+*5mO
zMiZTeN>v&LO~AS+8YbTnTv{Qf?A5$6S5pXd3Z06a=Tnt1eI7V1{2*8zXNI8%3eL}B
z<y$B>b>~7L1kYM1dawKi@YW%=lKb`?@8Vi6oGK~kIgeFo3ExcmY?jzk>FD&u9QH{|
zCD|!`KD*OWNea)6tUi-`HCUmbH%3<E4Q|s2ZL#>esl(0sI5<CzX-ZX37fQ?3Cs(BI
z!)A_IAKk*}zyc!|RCLL8NeHAinf0O3@FJxtwW^${z%hmv#ki~`$Ef#$OZrhfM|z}!
zhLoimSwK1vv=s<q8y6wT*9O6BLDfVn0zV+gBLvsoIR#ycQt){TD+T@nftMA*T6lXZ
zWB@@gfnXNVXwQ@|8wAZo6aI12nh*g5IfUT88>isQhD8u;1CijWJ{de1K*{hwS`qAQ
z4*AU0uLQ)bpWB$f-14KBiQ?rHQuv9Tfp~{h(Fk#I1p)9g23ST&M0o<(jF7Uf>IiYe
z10Nyuz(<I#8rLipT+>$!!T^~8@3J;PR%9w3T|ELZ<~1|0LN%hvz=6VK#T@p&Dxa+m
zLoM@3I1xpl0T-1cGA!0MY?O8Zqy(+D9b~<0ns;y;7n)9l+H2U0tG$k#C5EY0IdLQL
z!@6G@;S*X9wHK!<QgRyKUk?jX8_drp4yxqckvs@)>GXFH7;CMV9rE2$$%Nr%4t@=v
zpE-DAux+x%dV*ODF1kU*jN&Zjjoa6gTNvwj8;h|p8j~B)-hkrP6CvXW(gk-8ns_hW
zu^LcM{KRCQfT<sw{91w9qQE&dzqW0DK+BKjn}a`vuTI_c7sYej(Nl;0z{1`hD^eVv
zn}5UmWxVgDYbR1nw4D4GT>|LB_qHa@JpsH#S+$<OU<1^8exCq7qMY1?M>y9B;8X%?
zcFxBFm}ITUgsf8qbO~jp^Q_!>8UP@SA5EM#BNgKGrgR~3I#h*=ldC`GPkWC2;m=Dn
zhG3BZibWj+a1k#-j&*Q|Ntud!*TGb^)}G(|IXlt`XekwZ20&YS+yy<|3)2%U=+Txg
zm|#j8Ys3s9DpUh%A}1{VTp4aab>(l7VLXGOA>JTrsWmV!t}1B^luls7FtDwX*#DPO
z)DD|~x%(<0$`Ua5S_LFn0_I9`;?ii-ojma<oMnlWE2k!nu#1%QEG-m58)Fqth8J>?
z1?{z$4u&M|u`JK@<KbJeXb4T*;G-xB7X`N2(5Y)N?yO^te0FQPrg_#sfO*~=d>+g+
z2k(HaTC;E;hqb&OI>?$x<pU}jJt`+q!B6Vb-}J!3ITk<J<WZSd(1urFu&aP@oWCo3
zRK{w`94vLGzmZ`@aCr5Mc0J8aY{*Irc+fB#XSP>DVycw2c44|N$yWRWwF_U@z+2=#
zykQs}tju{=7eKbLJ=QVa8C)6ItYbh5msReUFqG&@>dv`|DoSvYqoYyzc5k5yrUPJ`
z|0=KCxwe|$BBJ^k#pgE}wuu5&)dE_~Ppje!7#4{971aEit_ifwZ_$smw*`p}=9#%}
z8{UO0$Icu}T9BzojL>tE9((Nwj&S`oJj<%TNT1cx+rRsx(=7r=>Hewq@538g-)BAY
zA|1$esL<fOtVEUqbs)QpN~9Yf>4|$Z-WZG0$j+ba<Kwv_g}jzHBt)BW(8lQa#;bjI
z4_8_{W;CJI`>bODnp4|mp6j>Rrpx2Kxo-NnB#mhs-PF_5rpwuy5sJTauJh^9zU<ft
zrMhS9I5HJ59L@TxFurIKJPPSNbbYQ*5HMM$&!=a|4`?Vw$a4);6&iZv9F}BTaD>qd
zt4b=#t#wUJ(cl;{Qt@i|Wd$UYVSgQ4#u(xWSOauHEp5=>XaIII;Y+&g1)R_+V%vu9
z8ZhfO>5c5zNF^?O%^Nzln#?`j*ClQOt#=6q4Ta*e)-*J-kWosP#y(ns?Auf@0X5vi
zDodEYIFKull-XVkk`h32c$5<5??w*Q9x3VB<1<rFHt$G7CN29l8kyJw8w(EkZljfG
zM?YJQf(auf`)x{2qm-O+rOd&L{jn)DM#1G6urtPwQBr#S`bsn;g?6x^WqC-HbN+C#
z$Jvp3B91FnN*VxGzi{BK9UV*Eq_#FeT{rBhhb4jY{aK)kcBn>}^;<lk*~cm=&10<f
z7={THx7HVfA_gcZ+I_<OB*$%z^RfMZ4IMNc7`spt*|xDtu;c;iuZ>kgs#gLP6m|t}
zwhbBq4>O`f%Aref5FMsBr(g$|7d%es<-XPh2?XO;d_ApcWb!!0-)Z?v_U$;uH__Eh
z)VPd^5kv)$ue_AnuAks@FFw#>U(kHMt@b?5$n@itXr~id%&{!4;qN|P@$|pV*Y%b>
zGofesMjWKgtdDR<ryl*JlC%+&d_5l9Y|~z_^Y~4E{+?5^q_&_0V{kUFMI~kzT-u1K
zaCm6SNedc-UJ1aQ2OojjeI&ZxFPLG15?^(sz|`VDFvZlt3H%94?Vwk#@Yr`U>(62*
zN{z{oIg!6oLV{WU4fanTOi+BPWMcKN#$<?Q6?_H11MQJcLzcjaijUr#I|yzS4BW!^
zM`xq!u<Ad*Oo^91En{SB2F%sFZp9Rb-r^w{;iV8cHBqTAtwvA%HBo6O8C&sii#UWp
zw00CB5N!G+#lt%{_|-sb%tPY8oKJIpMlc!=t&n2Xn1}0=5c9ABaI7%o_i6ayp%uSk
z;pQ`$hgM8-Q1N!0%<=l!;2rpu<5jL&@P@~zcy~?)-ot<c@3nUtUT5HaK3R!^8k5Zu
z3z?$SLD)p(0BhL9gf|@JFdRP-q}H#ETWSs{fo#hZ#TDh=e~{R?14@nL9C1SB&c7P=
zSI}j)Lps6XS&G@%G3D@+QYq5-D08sE***gz#HJ$H!3Be)<y57yv;&c5xl@&dX6GJ@
zv5w6@Lz&l{qDqnY5eq*{(B%dA=_qE0pDRzpfC;5f*NmX8$DH8GC2#}7bS07{OjD|c
z)we-7_8*S0%Oh;=*&}Qig|*@|CC2IIBX($-5>Q1FSqHx<lJ!(ABYQth@pI;;E(<WB
z9c9su1}4QI>B<?|Xp<5sl>vmAl#uY753LRIe#Pr=5>7vA(1oQ*H!;NSn-o7OSjWll
z7H+U9IpS|#GTuzvl7&hdQ1avHN<{e02R2oS0t0FkS5+jcnvR{M*)|0ZzT`DDE3Uw7
z6iAu@?o@xkCd^O*;#!K#J6{z;jvK}n`bMW-6>}d~wBXKb%MhCZZj}aa9?k%_`m{E(
zYBQB4;dSo|%HcpVjC#QdY5ZQ`wu=O=8-d8dnToG8!x5)+XDV&Ol>%$Y%g=eq@BS>N
zq!Ny6ZDuJooSGJ}PP3E%|3M=2#h1lou7%9<ETvYNZ}!s+9_;6&V;5#Az5%7M5)lr#
zpGZrpez_w6L++|M;1-G5N~03O_r@}3Lk>!ytz%{@5z-@HBU`$pYoxSGLX6sMC8c5*
zRw$ZEOn^!pagWuUgIbhlydBwX#XQU1UY6;r2MlG_^Ya$COC|u}aC4N1iYqD?!t?80
zc6g3bx$d`^1)+PhfcnesVzQ*!@##~JzG89ccZI6xtJlD~kGsxBSdA#CluNJD91fVF
zE$Jdh<UPEhtB>acSoyStTK_ZK07SNCQff#<@JrGX@F&0$dgsio^&QXCh^qy71372;
zkIPT^VJ{}72AZPC88_=#N2-^s2CHJ}x7cPa{eu&V+pMK)>(Dvc3b%n1F~#tPfZFy?
zbpf12K+V1HE`YlUNZWPY__FDpBQLKI)Uw(N{!;*NO8{!yM;8IKU65WzDpnC~{zAKL
z{Vg@j8SuBT^Cbs|#>BoL4h$h1E^;hH1SYH_XG)c3c*C6*ai|yM59B{Cp(I7&r3Q!i
z?L{ucZM00}ESjKo4Fzo=jv!%TYUSVr)NC<9AC%=D92X)c*H9j$!G540He+I{x9MUf
zjwjCE1||Q^_YiZ-sI{yxtR9#LPpNTykuec90A~aAhS=lLfrmCb$G5OBKyTV^VTn$3
z-Ca85@Er*<6-jN*@gN6DYqT#VCpMb*fr|sJAz&V|5!s5b$pN`+c0`Xlq8F&Y;k!Qz
z-lDYWhUz#0=sN*2fG*2^!g>L!XOnBW0R2t4=xQ$%oJk<-uEty>p*wX?n_2r4F&yux
zGu1tYKSY)zoGF$)hJ8E-B$if3uCR*L)e>7Az1*X+M2p^PkQ{UHW7scN5$E<lou#Ts
zX<uL!g|k#;3g_6iK&dM=eUrf+EKoW~4_{|c_)Jw+?#uX6Y*>yG>75(D^<N3*i->cn
z|A3G9Y3nR;F7K-1(yAP#rhX<s=z%ehNIu5U?dkWSR?06#{9bOP6Hr)!Z*uQ*6#Krk
zpfCc(goR4@(4znW#cvNa6pf)e)YfXjBMrz^Su}X$#=jYbqfveUh~hA|D-?(EiJfC$
zF^{}4-Gs9cSqewWm{77%<joKcx>eAYBWq-bOn9E`13HrJJd<`y#n<o2x!}CuVOmQ*
zu(joW;v13$wZS%P%L}5wBw`E{fwp>gx6RL<<tmkfrz4ML$gbeU4C$Poh8cLn@M>2A
zeyHe0inpmXtqY4R8!barbplL%Ky~u*S$i8_3!QyO)EDC+9R*$%8lR9s3{i~sTz#K^
zQN7Ke+iU_JtL|I<mXAB*Ra=K;wg8@|oZ24j7y)#)%h^K!6Dg;rxmyU}Y65CX+5jNm
zf<^2vKW-I=Wc0@F`+~WajQZSvL}$QFwR3P-Ma~BsXMFDmX{_tc!L_UK1UhAd54O>!
zJG6%kl(f1+mJg){dzxtQfin}Vduiz0e@RJg=j;0K{+6)+M%s?H<GxdO@J15dmQ6au
zT_HM5?B4aE1j=OAAAUiCT4=A%!t!lz1k1H;@8fT6*>m<aXL()7g(gzL-vY?lqjF~-
zihw)y3kq?^{S{YR*l79*#YMCXe1ww(&MQQr)?=o=0@{eGw+MT1rT~6MSuGMB+&}=g
z5>WHrRu{m{1mrGm@<zG~;Ccemmadp<(PuOmY3#V}Cb7E$pPk88?iNu2H7o);`ZP*d
z1Bwjiz%n#9{m(+p4f>lm*L+fCOM75JK4(>EL~srqeD7YWY-s~TmbRKuPao7{)y+`m
z76N|<CQMnUux}JVBeZwyM=6dUcx$3~YlOWk@{3uH=M%GBQzF1J%Q@KOw?^q^rm%e{
z2Um{y5^bWuXqZothe$GVBQKy=({ih{#eof23SUqk=NiI^pj?;qE$}Xt{eEz8R0N(f
zVfiH^9TvlK5esK)F<2YMZHK6(N=SoMUZm!`QXGBTpaAZFTJV$v&UqtMz+Erc1MNt2
zC3!Glz)T5B#^O5=YmlW%3#UU@+0CU&K()Jf_<YfBg^hU~pn3;3`WWeRYi#@6MxIiY
z3Px6cnGzme_o}euv6M565~Vv{DW-H?AFKhEDWP5~-7!94bw2vo*6O4^TUy8aKg|&9
z_*&RavaI7bJ<4FQ%dw941HB`cV;z4Ep{LuHE3}Tkcvs>lCRVKA%k6O))@A(RTf8;S
z2P|vjSzhXLyUPkJx5EI3)Xu+4UBQ>}-8_v<S;3d_Z~qWz*)@T8b-ESr{hJ)G&pr#@
zO_fx<F${PU0SDgi|IqNxfpc#Z<I8w2;9bY~GXCo{>oWfJuN>u*Z!IYIf)u`tuPO6o
z{M6sYGCrv6UXK03?;7@T9`=R?EXu{Q66W`l1L3qgWET2>OGU4L;9S2dE7hg(HH|Cs
zlrX1i7g>0o;_JWa2B%}z1<{3k5o0+C+6%4do2S%}j$^s}aUP=Q7hPb7@|0-*=hu0u
zeP$v}UFTX#<-<?srYKQv9^^hl$M?z2!^#pw@`c9KJJb%b&{*&{4fOaH0AZmq4sQ^u
zuKdTP7k<P-BMWv46#RcIH0%un4?EL=G=Y8kF8Bnk1Bz=3K7meoiMnkj(1EC3o$F}J
zt>zQ1&F2tQTc&smV0i*+%M6_WmLs4R5%=^lFCIrgOVC*GF96z3280J%Z_{n?$96$t
zs{K&Rm8z~%-Snynv5IHsCdBwiZsNZ|Q;IbqoXGWPZ{ov*AZ^ZBu=IsJ3kCoWvA_g!
zPD05>P$RVHP(!#Nw-M@p7=dovL)q0?1-U;wvdir%a!09+v&=sF4v<eCYx_MF=hvz6
z$_`R-Tt*3~X>XXAfq->`05_w|>T(azr2^WWpz6E`=u`ncfo55l4rqS??MhI!(*SKn
zP;1-9028|6i(AwcraOBrv6uRd_f>LlQh9Zo7v(G1mv4?#l>g&qp{^WkDSnuW^Aml%
zwU^MtR;i?LBN&P>p<d7-Wp;LaCs!wUo6fCLDwltKl|~-l)3{Q_$esp$=_Mt>?YU%U
zUN!G32#ul<H#FN;)zVreV0@>_(lxj=hOY*aj#eafEJ(g6sUn$LQXn}qzc7+#t8o~n
z^xX`0WqH>%(t&~uHgQGQI?}I|jQLJ$l<|)KgMQ*_;cT3ZTCfBH)pEh%5V>oN^zFS2
zHcjr@z|`Qn=A$^o7x#L1Kn_kuZy%sPIDZRp>WtS8u*MFOGb7bC=`|FsleOSHQSi_&
z#OZ%jkH;th+ytNs$pXZ(Oit{O*gmmcVp|rM*ELj{awmiJ&g;5E8t-AuAMk}T+R?w%
z1>TAw2GI)c*|N-uXG$B{#!tG|HHBZ(kjs2=s=t5Lp7<F8>}1JER)>Cw0Io$|E4>{A
za4~=?y-fkJ3IsaPYH{GKyo@Nrik;ncFCRih9$%~U@DIQ$HsvG^dlK95pZrx5$P9p|
z&biBRmh_cUJu=rhu#s>tWnpLyImcW1qK0T?C~Z<$j;uvPp!k{ab><A5d{SCeY(Wb&
zTck^lF_(3iKfXK5(Oe2E2F-Mc6i4&w1HR2&u5&fX0o<NfuJgU}2Y=Gq+Vx!qo4j6$
zthf>jF1tE@Kf=CSPlQKqXdq@zBK+l#yvC!Ub~TFdt8bk}jTLIW2QIoD_(NLua~#FO
z8ocfXCCDl92<x^%3D$@4()!Vt&=0~C$im?Gu0rQPua(40vR9_s%0KLtHG4bPY}bri
z#?EZHaN1#O$a!*o!PNkMBnE&%Dj-T-*gL<0$D4X10m6IPpXkN_=H$IH>!)D%h7aTW
z|7Ni6yXJ-tQWwLnb_8$_i)H<2b@7a%7KkNeLIKU6F0uF#`kz(<HZC52I1LNwf0mFh
zdzdr~A1&pJ&_DjPVBpK9J;Ylsz2`!TVBm^M><Oaf<x!FviVMhbh_$9FiHLAW=C?Zd
z9}>1>0QeBi1&<V&NgoHl3n&YvZ8>{{K6VJh3nM&t(2DR57eTHW3*f6M9^cA)MG5Ri
z^r{q^Y!EK7B9v_rlBcKx{64BHf!|v39D?b4Aq`%jp@sZJtjC$I`Ur?N8fRH;{Da&V
z?qUkyQX72fhV5uafLds)QPPx^W;Vim<w957S}}_UizfEyM%&lZ!&=pFx{|>*hqbC@
zn7k5^k@wPbrnx=bZF4xm-sqWK-QMV7nOm^)`3IE8ge^*Fz%s-PScFj~)ybE<1IXFP
zg^nHCqI9m@`7DXa!k}$@nY@di&*wsM=VAt{vsDT9`c1GFYjr3e+T?~n%m9#$-l_z8
zjliC1TFz#19$myyI=fKn=B-LS=^xAv1zVNMQs_?^tmHPOt@P$^jD~HBPqjN-s=J>d
z8`0SxKlJHkQgjFE;tx*m|D3@-*{0N}X!=X&k1Xm;Y)m<y*vqbMgM)pM7^}3*%8k)>
zqYc-NaYgb@RV4f#R*Mn43i^XZU!AF!JU~a%cKGqiT+Lupw=3xtCp{}v&*5*`uiLR9
z@bD-{_)Cb;Om+yjL91|tULjb;(%0B#2Tce47Qrk1E!(zD(N}!HmvPBh*{O|){+12h
z0pwi-a^K>pCH2pdr!%-L66S9fy^|Y1;udFK*lEtZCio%d(KQAKXe^oab+2YPJgk7>
z=yys}$d|xJ*Rl_t9<r}5)%TX7Uu3ZAJC(W>|9MUxKXXCzF=WpZ@$mTWRP?^Q66YNH
zv5B1i`Emw=E!XVC3BcRv=KP&F{q9#D*URrz8amC(XO(s-e*RkybC#X`*M?=5qrRix
zX0W!qlo6(DyTvH)n38>)*ph{g+*M24DRE9%AUYVUVds@9d;*5ppNBZ|7R4doj1fs&
z-<B^W*u)0dO}tP?Ea@Aif`rzwj^8L%r3E)22j3{o!hZfnQ$7X{QB|q8XouLcwAek@
z;q`s=jZ!0Qu1)sC2RUWq-xSF{AK4r4R$`sPzF}i`D*>hqk#$(nta?mE+jLM47T1?%
z$`8MRuCQ6noctBKMm1t#tuDMs0&KWJP^%3)PC$1ORQ1y#uPIA_HxSrra<?F;)nGo3
zRE*BplcXc=Xi<s!FV3m<ayu%ndZ&Q3tUx+~pw>0R-xutV_93L{xy}bq2&|g(FhgLq
zR{zm#^7J`hQ8NZWGP!CB<{7R1xtQI~SG-Kui8~%kQXEh5=+25ng}Ou0lSs%lEC&NQ
zxu7+JK;o1_2vL;lJVmXC98-u(IjgqO?`sqyXB`T83q0ot4|&x9Dj`5uZ<qk1wgC3x
zJg+W^vQbX}bX$O&2}E56&=~<*Mj#5f0%$LRth*m!NCIKAk6Srq)_ZcotgRPr@*G#3
z-_Ym$VlN>B2)F9n1^TX{#_pQ|Ro#z(Hsh6A&IcMu%24TIRC@mq$O7L^fweYh^a4#)
zLT+7bnat=G8{s)JllNX}mG}TcMYeLsGb&@N6IQFB9-`v7(S)F?#}dSCv`6ZVR1i1j
zn3W?OsdOfzE3G)K!t<@j`B2TNt@VESkymfc7%4K&R5NOB$?ZI&MI&bJReVx*{X$KO
zoP1isw#hwyN)x`VMDyje+%JPv5A^)Ypq~r?+@;S`HuH_@)ZBcYAt!R`4;gI7UL{qH
zVBqeur{AmYGV=$%{ldduCZEV)eZGUc><KjHXWzlAw%Qe+H2F?x0C(BygWRtbf{2$U
zp;nhx?zdb6U0@dflks_mxaH%ceQ;_04LHQ4?Gdm~*vDbdGT7OD+*Nksfa)qMx1YP<
z28CGhezS+;y|>(gcl=)*Z=&911xLB;u!gb~e1Bi<=U%cu_Dk&ge(oikSl#L+JC@I}
z?OkfYHWyUDOGfcAsVG8mE(uqW3R+hk(hxU+6UHj{ZLl3+)|W@9;E7q&!EZ+xI0(_x
zV)@wZ1BiCG0{#B)0i|mF6T3wq7%YgkL0RZFv;NpoFdN?8ti5z^0{V-8f#%*Zl0)3J
z$)mvb9M51K4k|I>6*h}$f%fpzfeR*ig};bG)lZhCx>qZp_1_#+8c2PxAbxRBiBBA|
zNh?YAGG;oO(Z)eR(lgCyOTOXw90%EW>n!-%KgnPt4=HsbzP<~(uz-2r&vpSLOzRX1
zNpvHs5fr)a&kT0ykdhF8eiui3;He-}T?>lC-OJ(j+2cS)->hRPM^kbrijkf)Ym;Rj
zR(zzNz`mh}l?-X*kqma=u+mNngA95eQQAjGZJ=h&4oaZo_xN1yPF~sdCt78*gW_m~
zkN;4oHQ@VQbwpX>G;BSKI;w<KU9f}a-}tEb{Amxdd_1azG<v(vuA17S*to~V7kdfE
z(+SDp{!v`}#GRA3kD?V9(Tev+m2~O1gBdLSn9@YrkFoXfF(o~E|5pNilxW4@+c;I(
zDpmYGrBG`t^6zIbx8ur$Xb<~hX`)!|wW0$H7b}lq-yT;CPFvQpXUCPWx~I1CY98Dd
zttgy-VL^t&{Re1*Rhos#K7Ciq%GIOLb@VZlbzm$6Dd;?OJ~y9Wpd+G;xIGj)=HnAe
zV&V^93fY6yCkK_IY~(taRbAXBlYoAEvW1g!Jm1FIZ;6W92}$xesl+8_7K^5g4Vtk6
zjYn~4>H|&gNhQ45ANY(Q(O^%_>R>B1r3IQtp9fj5-Qk`Z3rRm<RDC$9M4Cnxi!0oU
zD><ku)s=$wuEkvi^qh(IPXC&>ck%9G+S~MAhQoduAH*$gs$)CExvmZXLA9ZYD81=S
zbub-6KQwVqJ>*w~yadW;7i9lJ##<K(3UOGG-?EDoy&r3y{FcM38K0qF|K*bA?0!ac
zo45vy4t(H_Mo8tMAC&m;Pd^ik0`Z1lHgSSezp+sc32KF({*l2#Pa&49sZD|DqQEJM
z%BkAPQlKdc%siz;L_b+$tszVl=(a0J{n}!YVg<ivuv@2;8i`A-#gY+HDtPMr>psEX
zjv#l>Mow;J*J5g)3N$TFE7hxw7MWh3A}%fqT7%Xn?&)b|WGpf+J*^l@gGm$twpU^o
zPGhz7qdK=Hnr$P%egl{y!1iSD2ry3(0cH;V_*dKcf@S@Pz5YYHXw4)JSiL<-)4Aac
zKp=eeXznHX>NJ$a$dFFnp1)lpd!}%RI9oF;Ei&fT4k{z=ow@M?5gET3Akcb{zeP^t
z84UGM1!jsm_~BPXT;ksL|GahvPJ6`Z^TSGp6X1<afED4jSX<`c>)&x>Y0^mmRr}5y
zd;&n*Sg2T}!dUuf8)y|<4^eo43Fh~$YJyE8q}qPQJd`i2aroxW*qx%a*hVtcIzdc}
zZvqfn>&tu4;K+YmO5%t8zGH4+<!#(^Ui{_`bwrgQ&Mnaor;hV}=q6Y;ZX{>f!BN;t
zy>M3X_S``hcF}&=R@N92^Eb6k?T0hGx$#E;0%g1TTjUs?!SDs%&<`~UX_<1yK+^{J
z=7H4yG)hrFoWgm>_hGgU=X6!&c&(uvnqk=(QANO5G}MZB=jEez-DxuTAGhtg!RQgl
z;6xy|?nJd0z+eJuJ5h-OSdD;M&qWAe1Oc_3s7e6Zio={^TpVtH4VG21-HIB%o5VrP
zFm8x`GTqF8$7|<a`n%lDi3N>j4t|?&D<)cu(P`Mruus4OaTCuaWD}RWnDr;|43n#1
zYkP_+%7Z1N*%?~-7&uTw`ECNiQX2&GR0P90f=;#wrkiw5V;zs0gL@+nnL~y42A4gz
zB^RDHx+TW6;|R%|^I>8JcmWlUUkr_uZ`7fYiwqh#csp=wBx98FO7-Zmes<XwARCtJ
zJVqu{)L<%H!@XUo!NtZ<1xW!HaYKZ0i&d7d@V<(#3=m}b0Dp^oLa1^Li|__nUWy+!
z{UUq`vtcgS%d+h#PC&!NR-oHql0oaOCQtAQp}hfW%Yzp|3V{6@&}u9F;E4iw6D2Jx
zdc<W2-~!4Sr0yh|gN*{Z*A8iY0Bv_e*8>sQE^QKQ*Vg_Y?-U}ax>D^oL*qFM`5>%1
zm=D5CRIP1>nryw{y=c?LeiU+<P(xd)kyaIvBUxO*S|djmqvthWt~~+2ZYFX$0p6$?
z%=f@>76epqs78~Qc4F!`tl)|guzXvFcW@HWSmvIRL%7acOqg>GM@T#5y7b47xYK~f
zQW2GhhKPW*XEuoPI3<Qv0?`zKX!$|txt^DC*5Y(=h}5t*8!TZ0OQgUOD6j+*mcM>N
z*jv?N(OA@_x@R3vg$0*x9O3Qx6F(L%5tDeR7mczew2xD?m+ZOzm<tJU-DLPuAY>Xs
zaS~HQ_#Cd%q6jt5S^j>|V<Y(kfyc&kRvFS~<2qmmxR91uFNCx*_R58F7`shX4h@mR
z#%=cN4!iPe@XaX*`Jd}VdCLgX*Ac~Moy5KbR}s&}XsE7^26dktS7%x3Nu+w*)%xKL
z8A}!A8aALgHg2~b0(y*~R<~QKfDR+5I!OUTjDTJwsMRr4ML>rV)asEbNl<c>m;|}w
zkc@U+_)4@(8@yRtRkrw2c@>PhzTckVpsIHe?aLc$2;YLZJ$})SZQP!Y6byMyD4NeU
zZtvwGB>0NJz39!Lr*PmNn_fW~r>njL9|V0{LGksTw+Yjh{<EJm91aFRs~@1fF0;NK
zb|`CBgsa-P34V);imZ#>juMY5;xxnZjTx+rhf-ZvE)$zG<2~UFZU)dwPo)aWuBen}
zvptkf(z#0+?6!vz;=P~70@mR!>4nzeEI_ZA%2pX|Hc!V_bREW=V2%~xNV&P52zq_R
zo}k4yGuTx<2>NP0C#W8)?Wy#aB)p;Gp1Ol0L7rnJkT-o@2J^3^)X=?119|C{lmyBD
zf=Y|a4}z9%Eeg|;b#<ms(3e(y^K2jWonbLR=!@fcgTDC@Kdfd)#oPPt5$fu~wk|20
zs28c;!Aos0Rer=ZSC+suRbVndgsPbKO7^YvKk+2l;Mt5Kpy=5boFW&2=Oe=N<bUD0
z-C6O_o&64kckHB8^Vq(S)-iOh6>AYMtkxDg`?8NZDLx*j_$O-85WAO+%{1)Dehv@+
z{!U6`kMS#LZDNyRM2cHyrEm3d*|Z=>idlc-dWOU7Lt}GO&Bsz^9q*W4@9x;m;M_;M
zK;S2xm8#Y1qAk&|X0DR*$kk8(9L&!C6JNH4|H$Gs<irlz3u0e)2C?org@}D7sl?W}
zpjK=l*6Df%>(&LtUR_p**sZ@{^S%p+y)sWDw&5?f#0FT1eY(R!ECY2!Y+XLk^|#lk
z#6Cs8TZrWsXncbdy9+dqae&PQ8kg3ji7RHV;elVEK@a=_jT3vgSp9-`e#ML<t#-64
zW^RA8GPE{fQ|<Lu$c>f6+fPYKgX3_u9DJ)ccm_jTfyoy@wy~QMh%gK;SoZch-T4s}
zgz|P2_u&8=ibsE{Qak|<oML+56i?0P6i@mzjbHik*+W}`w{=%)NkdO(u;p1wfG%J+
zy799ficdhfd1CEc3i9yx8R~?tK>^qwf>to=o3GAb2|W~#D*j9OLiiAhAuVxFHWZP%
zY`^;hdloU=%d5*_@)uy-rSKEF-Ht+j=X|49<2G`xwVKYThMn%ARBJS6F-JSdg7ynS
z%Qu|$Ex9(R97OR6pe=rWd7@1}W;HSBo>|}JBv$b~mC9Z#522Y93z2B6Hpn#2Qff<k
z;XI-in>Oqs(&^f2c$U19P!ah>Fw%6Glbt)wv69#1$3k3KwvuY7O!*FDe~7RUw}yPg
ziFZL83-hG*_b7pw)_{~bug18g<V*=#5jnh6ll2FSvZ(z3r0c+JD_!eOgKg7#f^8QU
z@tX5_QS^ol+vJmiRtwuMm*Z?Zyi#S`dbogzZTkBM1l#H*fNd62k-7C!{1T&f3RZ~-
z2@9*V_=8)s1Wf_p!Nbu(5OjXQDt#rC9MN8%WU%4Al&UpzowMKhaBfk~pK>|PyHG&$
z$XNCt^G;xI_^-C9o|5Z<40f%T(#U1YCq(c~v%cv*q}~2X_V!r6Ur_wI5$){?<C<mm
z#`S0y;A)!ITQLTFwUAfRd<Pmp-Xc3e9fYPo?ya0iKa|6Bt=+EWvSHwC@|fFxo$pX-
z&cPrB1fiwSrc0n_G?uOCtAt3wKn((_vb4TRWWd`69RDZVH2gNh<-pMlme*JLs#UDW
z<!#MnL&a;F!fdICEybzWCTmnUW4zfejSyhl4?{c`_>c5c+6HvX=2U#xQXCb5@POCp
zuk25sKA-36Yt3atMKY?eqhfjqPK5{4sAvU|)_B3zyvg*a40{jvreUdV4qmmcFpVPy
zD7Ax+EThg%3ktA&DC~j?h_c*!a(h`Ci>ltrOS+2(uI1=~Yq?9<@WXWfC*Daf`;@-}
zB2~R?%MS$e^2&Z&TBx$WRDf2QgQYTOOJ(%HD=Q-^E4hrTRG*r+|Ff>F$%8^-atXCM
zBaGa{X9ORBFe7vnyKV1y2E!Pnp$!cH<THYyv{;ka&j^JV|Ht6Nv$hZ#?tJrjZz<<v
zY~DAI4{$$(-V&emCe_^;imysad?jhZ(hSzzGa=A~;lte`ndF!gMzDd?=zNiL#OBV5
zzm|&?>~yF}@&Q=#mlyeusQI;Z;^F_uU$BuI**hq|H#`%TV;=e?wgpxU!Bs40IA??t
z@^fA+UI7TKn=+b^L=NE@3?`(3bsYett5~Y`p?Tu}_I-__(qcUqDKJFwO33#`&9I3<
zJ4c;tzn)`m*Oa)RM+y?MkEdo|PMLGjb@mk$GwZiv0N~=Tl<X%sONlvY$TdW+FUer+
znlev%wIhQC{*3$P$A6x|QhvsrYa7XCf!UvZvf!T>Ek<R<;hZ0&)0Z>YzM&i2JMGS3
zK}T{rOP&DCIFd8Mzs=$_;l80e=5P&q%hk4mfNPMi<A(Fx3|8WX@+JLlzM%}4{@RO;
z){ll%lxAV9$NsAP9e!yUkt)7X5OPAqreGI=&NN{~^BoQCwm~UoeeVSbYPqQdH1gU=
zvmLHuKuaz8enzN2k5{a=0AV?)X8mY*<`NG`$igpC<`QVuLp!k@H<iv#z*YX15?Jys
z);ss7zGvsJZ15=kC)ibR=Km4)CEzt4-~UP88-zrH+-zhKH)KPCSV~9;61g|_UG4iC
zB$iSM5=4ZkWyt%cLeZ+VsMtj*weO|XZ^c%L*lX9izt5SutEB&bpFZ;5Gv}N+b7tnu
znKN5MOaZ#y%F(Dc(ASJxIlihn^!4?voK4a>%x!KDnd8d(7v@w`ZEgT~av|n5v*~LM
zzM^{KON*fucPNk5xD?;U;c)JfaR1l~j;weS#W)PB_hYSsstR}XVOmvU&u*vn_Hugl
zJt_n%h90q*iD7JMSd3deJWFxG0FA=s0~L}hQQ>jDhr?p3yjw*Mp%nT18!<(iR3zTc
z@wG)I+{TIfm8j<*@LNh+gmuf?In7)vfD=UvdxcnxT7GwOYWY3SwrEaCQ}yb-2-+B%
zQa3EK47rmNU^hR3Exdykv<D1-xRVpu<nAiMnt>JF$>^CUi{=IsW61T%hC29|R>s2R
zZcb53_G9rl0u9xC<LPZ(#{cx{FJT)pey(uLIsH1OnQ@ujqtL>WM#N<%V};F0`Z^f>
zLul_ok!>bvaVTH+-N4^5;_JTZ4L?!?!Z|p>8W#t0rs8sv^w-X5GgY{R<z9}Hl#NN?
z{Chd=9Y5kazTwUjyvyNYK=%8+oFh{6A2DUTpQEWXlc9>rVKegX1a{_rPTlH{$O%io
zJiP*W{%^KYIQDuH5dQfgfmQn}=dgX2)AYMu?AO0?G_^166rzYy!daY+s!A(xPX8T+
z2!9M?QcZ^W@OzLGqdJ*`uaOUOd{VOPkKZx*E9(BA@_2xDPCUdCv7u8K=4og0gj<M?
zq&~opw_=Yc*8?)&W*{t&%-e?F!?CMY$TR%r>tnXbwRFw?nd;-b>{#4fW?z(3qoyO0
z3=Ng`Vo-+r&}>16*~RnKkhOJDPJPuO`bsWBkIA90RUoZbIESW1#_hxvmqK4zPP+`i
zzj&X0MNKX%qB+srDar|T?tx^!R{$H3cV=V6D9-V4yT6J|tU3{ChiUVQUcD7wC39|+
z>*=^-9W~lpMK+q%dN%MOPV3Y|N6mPcvt9L&foqGBoJhwZj=Ww2#^5hYFUirmHV;tX
zWljjFCQ`gVR6@%AlAIvN^Y|L>oaFQ?LA)O2G;qx3kO={+2-53O&U<NpEroS|oKvq-
zMbTcm;4fSJ7`sVgkaFg6j*l_rkpog*KF$gAEAr<#;>sT63s-}3-;GpiZwg_>Jjv0x
zt`}GVGYu(2DP`spY)|Rxudstpa9I-{GxH0d<V>-1m@)&~XVo^-6Y>W<&$(~wm^Yn%
zSDlKkmYv_}Z)^#z6gWj|lW{?>-Z42LfBS1(bWzzZNkAq|Bs3N#jc|2@B{uD~WiIb>
zzLch7n9hEeQ(ZO43kGicyBsf78~Qr;E=S{BZJ974LtJ@ZU->>~xJT`&G@|kK=b4%)
za!mvA7S#+mqVIG3YwpP6!(?3`A<9*maADk?4f|2urX;YV?{jKYtMiqp&Z*T*W0Ba}
z>w&Dx+}i81M-H|dFShoo-OJkA%M$;|88#%#enkpBvqx|2WJP!;k^t&W1IXJ%ZJ=-H
z)oB~3M<wA%;d>bYrP^p}hSB4zZy;8BL6R;u)9FzrN|F)l<LqL81)t7UqFnH~7oV)@
zzd0=&r@>N~rUR+}=D1bdHl7NF{WF*YZs;BAnwSm_LmU^!+CHZX(4DmNK%2LrcVJC_
ze1+dE@!Vy*mj*DTRRg5Nfu4nPQW0A5hTb&;8o=aHNf45WXgPtGq;Y>y5=`z|Xs~&I
zeFCe$v3J)>@6*UxQP0O8mbI~Wb=64v+Oo0t+rA0-icLS2JfxWBE|^R<HvqbnOu?^)
zhF>uyBk`+_;aB65KKSKr_!U^9#V;qrFRzl8`1NisGSGk9o2fQpoMt)S^{%d7GnNb4
zf}eGPi-VWk)+Vsi-}P=*C(FM4HDTp2;_<+3D}j7x4z(DLtOj!Mrrseb2WAJ`=wQ3k
zyJG)FNpqSpV|NZsn{kENe6v!nkKy@U=wqdnO?enqj_$BcJC)p!NShi-vn@y!LAu<U
zbUa97=d!C1V$iuNie8uTw=Uyj9L92&;^=?yx&n4mjwaJ}3!{DbWxcv+5qb#TJv0He
z84tA?&oPpVgd0dO*i|CoNxP9G4*l859(I~3Y`>j6xa!Cyv?C??4=uDqTZwlhvwD);
zr`AvyROcX+J*gJ%qK5x^h(<)-V7XKAkCMPPOL7fg^@s!;UB*jo#$!CZ1H2=7geO9`
zN0o&9za)8&om7;Wz}A$Lzpiowe9c^XuTEeI<z*i!aR{c-<>g@2WJg7xpIcszwX5O|
z(afkntW0399prH7$APG>igE+h4hQtwffZ#pX$st~=@sQB!CQuth59-dqp2^VDC79g
zCG^wf2#Iu<go8%}{NF2r*Sp#9*DA?=4St<1EJJMxmZ1{ACJT2X6-@;?*?(t%&F%%a
zk!)Zk83(wACa{!Ba=6PDJ93g%qI8%a#-L@UMvU_*msK}(*jYW(luPX4mYQH=x^={2
zuU7UW=GO>mv6*dR$q2Y`AFLu?dVz0xb_nV@b8-|~WzuKb%o$DNumXWe!q}nUdhZeI
zYL}Y8-Z{#C<=fbDTgm*6M^LtBhX5h%(#p=&Q>?NzZL#AmA+<thwQBwp^r%x#a&PI*
ztOPb}q}<zf3Oh1VuH!XJ=w!QoRjI-kR7T;$Mj^UVS^iSRnGJN7o4Wq-IdzShv^8##
z<~wMwXi_g0em<=lyXfD>g<Wu#f2e$Q0QhFLsXz}XCWo?T_P9}Py^FltuG?hRr;1!7
z*liMS9dj|<RmPcIeMdo<TSaI8Sp_Zc$uwy>EG4mNi0fPu6dUMBO^LCY;}NxRnGZkx
zAg^=!hg;zFi?KB&C9$qFb7BH(SXEB0u=~R*vDfU`vc#}TX%oqsMFjMR?n0I)?vW}@
zv|;y_CpNa5p1}U7Ci}Pzeoy&pGmyVYlNjV&T;<_jEA=wmk>}WYsLd$SWxUP!U6%>_
zQnC`xva9UtoIZx66dM&+_r{hySGi_m?=<V7;71gVT0vI~1<pyPq2M*<e}<vpCQSwR
zyUF!gFHgCe!wS@|p*^bQz(I|YgqiY#?Y8N~&D7g=!c2*H)fHF)F$%>&YnG$XZOm{e
z>(0o!IWjSfLjLBg%Nw$eDt`=3gRd~S$w7mvO*ZFQzbDVLj#Zv^raY(3vCh-QBG1v2
zOnG+3r=hrw@kzyvD)-_`awt~1qm=8>K*+jMDF^o8IrhRE0c6ibDH}qKqLiD^u`Np(
zjk+_IQbv6nN;wCgh8#!Wljm5z7ILIgUUZlJ)eXi3ljru!-_En5UGR@O8~|3{L!RNY
z@Pn);`wKh!R+pLJQj%@eI`TZ^TFw(;CXKb9-ksOJd(^Ibdc6?S0T#eg%(ZB~#&+;w
zf=SFf_%w)l5})RFU_W~Xo$W~Ul;foM$(UJt%Avh#Ocs9B*q4?acz8CSJmI3+X_!kU
zx?oelTI=>~IzKh0E1jRxEwD@`g`}p$xjIg=bn5*4R!@@N$^YR+@dHvF6Ij2RtLv-Z
zQaAbZfRxc(I(A3ji<v*Vhg+hR-7>j6i8bT~<+AFI>;}B=YRH}4D*+Ml3+y}T7yUV1
zdu6!MiQBfGBcP-pZ`igu6B1bRg?_!I;jqm$UoHyp;%*aOFM4LF9MP5heB|hISgY-V
zOh)*~?WCS?0eASwUeagyIOijWNl?Se>EnVSN?~VUh55<}(!6nqVED?RQcryB@Rhfz
z8V?P&$sg<|m$S7?N@AmH$}1%MF$v7hUrw`|63Z6&%U7lEU_}SilIu%T@UgU(Tu0L4
z<3KIBndCAmA^%M+xw|d0IUJ8{x&+AGr2ZqYSuXq=FLo>dH%tcO*Z%_Kb8dI=U>D3>
z(f1F?MlGL0Z5L6&g4%Kk$Opuo)#v|ENB+T9@?QWmA0#hwuQUNRk_QpY!|WRP$`yj;
z=F-u@39MbP+)w%}Dj|PEu-w&FrRfcA{u3gnxu*?8c%wX=$hI^E!~X~e^%{vVP^j!H
zC18Nw7b*u!HSzIRsN7!anU=u9>dL=KANoV|dU8kA(H>CDfO>Ls6fGh#8b!;iFLw>8
z@;NGV_VF9wY*C*_3vt<%)4!4E=$VdKi%|dG9fJ6T$#t4G=}nd(O>+Y_9yepeX5nr*
z5W_C0$I+~Kx#l8Luz1#t22%J_m{%@~LUvz<$#qqex`EHOFxkIcR^(>{{WT0t<yzka
z)*xI?cJOXN-o&@i$c}K?Q?=}mRhXcJ%k5jl;)}aiwASILR~Pny*vOjBz!h!gSMuE|
zss$wM2Y}T#TLZM3{7wzzs;C5vwFB?;aAz|c%E@k(hFLmT80qxtys<cT*GO(6o#=%P
z_KoD-(u0VE{I`u{jct#M{V6}Er5#}yhPdJZsnhr+)2~bw-pS~ui6ZM5OI|4dLfFeb
zw5zb0y+}}TWH7>I1nCIxM&jw*h6!v^V|lV_MFMnE+*t0fvZ1f|CUUZ~wy{a|K?J<e
zM6T}tRc8x^-@!YC(x(hFF_gnm)lKC@Rh||UsZHfcJ`Wp_KKr57!8d!we{{qT!y;zB
zOEcLE%^|X|F`8=FXYxAR3Okdj+Ef}g=uVGn>~V8BPny~ZGshNkXVsbZ=*bgX%WC$%
zh3sRuygl=Zl-pEU)7RuRLjBF)SB{TFpX%8&fvt)}yAFpP`ZZGSp#B4u#@l^tMkuz!
zB2YF7O+KQf93;&OO~@bAQeI>$Eoqv-p0$#Ds;<S5GNNQH1e_d(rji>ax0U?03G99p
zn)<n*1XeX#&bB+<oUM<RYXPfGePEr7mfO^R*#RX+<Ae8h+)mr<ubFDoLRl1VMtb$7
z4p^aREjLoVID<wuzO`IKb(y{vx0Zceci>B}&Vjt<mXu%6TF$ps4T^$TGh*c7b{{&i
zyD{=9saN|1w!N*~SyJIcYA1J;cD74k-P_3%?Qow-;xDWQyVp+s)ozkMJJ?>HpnBc{
zJ+XeQ%xtBWZ4%h2IC+y)6*eWggFHuaYMsE|caR%O*P|2i!{X)Xw$e>_yj!$#x^$%#
z0<AhZT3UjSX*xO5zhf&Zr||pCH|kPTgga;-*94*>qv(8(1i6`Qz^+KR<-budGK@w#
zw^-iI8>RA_q4*qQX=DPM(ot@s8WI5+4|SAXZS8J0WLG-LL3TSDvX7nQ7SieF2`sX+
zyxHz}1NN}9T(?|S-M@XHc<(N9l=SUq=ww~w+R`k1WOPAiiowURE^<pr!iTD>93ow7
zhTh&)uI1h&3|?nAk9`(xK7|QjfL?t!4k7NYK<@*rtzBW-L-6rOS6OMas3|pLbS3KZ
zJx>B3_v9Xl1yH<uT!bD`^b`lK38?~3YZTq7$F_8n>o{fXqw1UtR2oYQyUFztPj%@o
zcbC@qB(Ra)<*Z60_7Y0x_88Mw_K-WFHSPC8p?dU?TT5dbW2gD|k*?w08zU^3IVFl3
zlXG0=tXM-^iUi!W*T!N{L=-@o?JL=X-ma(IR5~4j<0;9#s<FcJ{ajquM+j%(<sO4e
z9Cjcs6xtl`iHrvyh>MYYfbUSTv%mUXBV=Gb<iZI~t=YLY@Q-@{|LlccZJj3r&1A(9
zo!}$#gt}-2`+C95zJSGfRiSe)RVy5PWt|;5YpPFZNRr<wI<mX;n7pI6>|fd3{`uHe
z*jt`m?q&#L7%f<Me_4~C*+(8_E4g?kus40>Id*d^=g;UT53-f=yf9PwTz0Q~0+n36
zgbxYvXtt{U@^+_9+ez8WT8jE8=r3nV#Q~U?4v>dSom>-G{s8%hl$TpqVFq#xF=F^-
zuamJne5<Gsu(-@GD;V@XJyb}4N}%e}^+{EDlJR&_FOKk_Xyh9)o5=&BI1076DxH08
z_USn&v=75I6YRl2c_OsC(;3?BKS*vRjR?WHvq7?2)iDIo%7psE>afB=a+Uh=j$~xB
zf>4@D*u#sn>dmD@F7BXL;+@90EzqvXq4FCn4-Q+{6uv{|kU+jP;Oqj=x_AMUL?FHT
zbF`-;VThC)X7#VoEq4x<*GPS#=Wavf+HMPx8@V38e@~h`j<J?kPxcVmukyh`xDV4M
zO;Z4V&Oz)_pU<P2eux~SIvNPMb7In(*Dpd6oo&acaMFRKKiUSS!4p3>1Yk_dQonOT
zY_=w_@IGlE76yjOu9es(%4;@yAyx*5QXlVusqj!av}(Va2r8q)*_1e9NYddKYcfpk
z;9B(!4Ng29M;@qN{jddgOAJHM;TJ#P92+Lb^jh@VfTLHBZb5U1WZ$^CKYL&skw@|t
z><x3aNy6Feh#nviS-9-5EolWv8-k$ALl1gA!mx%&5Oz^Sgb?=u!{t!JvBB)&@|4=+
z?QtypM_Y<`F9%iJ+!IkHk}l&3@Q3-*G&FKOf>11UggjAI>;ndCN64Or3vyRFBBmN(
z<$g2Sv%G-dE>kAgu+!k&3X`K<DxytdJ|4(-7x-1i*Z@>bQW(ZQniunNuQHi31cB5%
zM#9(j+Js`6mC1pUO*t)dUnP4>srYEJN)GUPTaG4NxRG5v)P$L?jv`M-!F$Ro#BEys
z#tK%+HKkgp-jtuGxufl2Y>lavz%H#>;m*8P%eBLhMole{3_k*MGcg1R>mS9fKMb$G
z=t~XPlQqJs(`q?FRjUT{uxYg%pxRGgmsiWtb&GdXU!ofUUHTr=(voM!hq#QRMbDpD
zz)g)kDhFeLQ_BSQMULFNPBVKdiE!KanM!TOJ6*;zT+mwyEqG4>oGQ2K$mo5J+)%~n
zD_oX)Nqzki*dkf(=X2Z^^l&~?Ns-`F!2c#`rs>tu4hi|?6uGXgoiB#V!c>p?ksIx(
zX-9oV6%zT_gBrHeS2jFgJsE#21J<%#0-KpD``ckW$jg<z8~O-s+*m`}pm-|P9Nk&5
z3w-$IOMSpxTTA~Sn?2i>I!RjpUsJM+j$?xD-s@QCj@0_<Z_1pKU0m6AUf?P>-UC}f
z!ov~BR<EuRjeuYJ>*>MaH(><%@?#aWwppyL#_fHb1e*iY3k(wqguR#4Phfjl+wRhY
zcRJ>>s;$3If*LG`IIfDdJ*vO0ZH~))ozteHzs6>I*9T6gRc*UTH{R;lx2xKYkjCSq
z%IdZgq<`M%*xc1^lcaQfykFh6j}(ZHo;hvh29K+984vsuZ*!OqTR_XcWd3-=-$&wz
z^}O)cu^A7G7OjC!j(;NuRr3&9{cg2ctE?bCWlE5TV0h#M7>YtGFa}iU5L%j|APzPq
zW}|A?zFXtLrfO3vyH7=%jy`Bz_DZnPiZ-Q(^zfyQz0#&=R5xAFioA6x&80Me`sz}A
zq#^j2sRL3)d|cC|43NJ2TgRFtqzsj!@$q#+N(brX3mq#-NJ&v&tIUh~&0AAZ1FItf
z*)gTMYLbj{{rRn2&(&3wD`SO)ozM6CPJUtQv+#91)HAcLP)}q$|2dBTq;3}WJ$X=(
zk6)e9vmxKh(=pABVy$+?RacF6gy8*m#YNcdTgf6e%b|`g$R)F51;qH1B3SB^)s2|$
z>)F-WzfV?|XU8_voGM`0OYkY#EPvI|S%~DZl#ikagcRk%ywM<P50GB{6cuJUxKjjm
z#}+wTN`sfsW~=<AUFC%QpSH@rwvIFIfDp!`!U>!5Z0(GG)mCno9m*Rg5q_8AW@8fJ
zz3(Zq{`PWQ8+<3?JHK#;ywujtA%RWaDTjwTK%T6~-yf4U?r99#_`rW&<3G*9V0hUn
zr$8$o9)V@|U2>+&!3>glBifH4*!yf3*IQk}sI^;OSncTo!uZXdV~7sR3fwxnhL*Q5
z+oB8Kwlj6%$q#iFTEN+oc99cRH?#h$4;LO<6>N7`$NII8tXKQaqOv-%KENNtg1Im(
zdynj|I&Fi>+_Oh+nX=qnjCY8b9`b@tXd{T#L(OZ*CCiGu35vsX&z?RYOF(WD#G6BA
z2*_H3(A}i^fKdd={46%JH9|~Lw2(9biF|*$zR+mF;QG|VG4K;;NS2|m{?sioE;Prw
z*Y}_@#JiT@lda8{BP#ZAH0ixCU(R;=V<D9sr|%}?${jYbN{TuKk+}15*e$S=CsABZ
zn;Gv?JW5YTiy;~A3!31KS{HYw7~^4vhoA0;TWXB(X|n<1Wla$-!#gWKmr5sobxL$5
ze$E6qQqGhC^V=r}mAB(nk8>agWUVHzGD=OS2DqifGlg!v)Xr&3VF^+4;~#_Y-2Fj$
zjplz&)|km^1Li##8(=>E7nrpU$=a&V@nwz&ydn7PLvnTB0^ZelKp?`W3RO5_<uu+z
zVTIv;I(7g^^(!Ev(*PW!on6`mItQsV&S|r$F4d2rZp+0V?311Yuh{;u-1PH~Z}oca
zP8%+5foUvij=itC^v6jv;>NscYM9KSFU+)oPd6f(bHeP7FWleJt0Vu!8$XyEd(bSV
zvdM$Ody)w(=de7;6&(hPH{7n0y7cOT@(IlOi0mHN4zJFXbbwP%xwW>=ZJnOpCAwAg
zA{CS9gd=i|+Ft-dK58&nQOZw9(W|$>FqwM?&0@r|O^dte$%sRCcfa{jXEBR0`OV8C
zJ*sU%64tei2PKMP()4We`F?(OA9bdQRTXC-QNHU_4D%{J4QllsmE#$VrG>eA*7-s|
zf4hG%LSQx|`M%P#ix>LU_WD<pV9l&D=0Zp1yau6@;LgK!nnn|i=Cns;U~DEXpw(sk
z6L<8UO0OP+D&<ZdY6V-ATyT8&Cpl6I_(#VQT)uQ;H-3`4$N0TPo56J#d&yx&98a6^
zzNqhAVPUZZgUPwG3)(^u54JnKcw>dl$J4rZ*~DXV3)gHXYFP(0sbGX1!syu7b>a~m
z#}7L8JamG)>x=g~8{_nzd*HX>fs{Lr={y{s@Z)mzX4&X8mJS3w#{l#cvImE;8I20q
ztHho+BDj@&t>vL!{n-s2yM3uyHAxG8@^Lu<K}Fj?QG-v9%RMyki%ff?qNtgv$>TK6
zmS?}y;n5p*;YhBhG#Ktj`p>ea$+9o_I7RD87E?Hk`ToGB?lZEez_27W5~xOt#tMIy
zlcgn)rq>C1fM>-2aN#*LLSaF^nHK&fPKrO(v5P0<PEwkC0;_dWj&?}=gNC8gRTJ2_
zlX469=5IvJXHK)M`Rx3Hlk!Dd)sg3DIm=JUvwSYU1RfOP7n^=F=?jW(dSDuX<-y2;
z8z_6&X?cMZ3ZLS@X*nvO_-`S&OVRw7V&JWxY{^~(zArkB@su{-)Ug(4<o0#<B~cgo
zMj|_gDz)BmwY%mgJ%@q|Rn(MC#;v|MdlXoVV&g?%Z!FM0h0LofbdHevPt&tY6*||H
zzJf=?+xx9zJ?rGqIiR}p3sLL=lS|39XOvvSR;qAC$9zZ2sZ#o79a}eA-dJt@2c6Z-
zw1t$w`i_wwde1+rvxyt?rfICiH)|g#K&Ouza}8VF#+}u%!DHpalIo(4)fy*HmKI;o
z<*yzmZ?dcQ{cEtxHcxb0f7Io7Pn0XzN)t}%*uaVMJ!!!S9cw>HE|mT~rOOYVEMJtW
zy?AO(weXED-)X8mz*gFOT$ev#n*822rR#}!aqBmQ%MmMYcwT2yO!~nbpd->^Gk)cV
zuV}ZIJEfiDX_3GE5B&{q)&j-gh=vy;bvshUdNxU`S6{sVV2&V}B}h*F43a>A^y-hd
zQqaV4$B@%G0Qs&|gBV-SAz`@SL=$|yIuo2qy2WNGnzw>oMUcSfhoVa&Ewda<h#~L{
zJUPM#^z4!vu^A<RO!$KfU3450Alw3S>C0O>HhP8};g$<!9VVd-W&jg})=2wthOBX`
zeoHifN{=w8(9Iosbtm+dr!(Y6ZkI4j93~Mt9a@-PefUouYc^AE=y34~y)1kBiH;@D
zlv`A41Jsi0di7iY4$hPVq-sFCH&YJw|LcFk6gM6~?b?r%dEsC40D#Ap<P<6Sh>q?2
z5|iH!`1s$K2yt%PuVXc5VN$zrzb?P+EZNph`tzWU#ie5F!mzz4TdEwWo_d3qTP`qZ
zKI(VOVp8SrIuE?gleQf}QbVqixxZ0=jQm0*Y^8)cJYlp*xb!Qhs6h#$8apGwH2mb}
z&6X$GN&9!}m^uwn?W+)?YnnVj@&e??G}&L$0rGpAyhT0t3g`6nfQgg#8mwfxygU5P
zWuEkUKav^<v95BlK8S=@lpt~+jRYDV=fSAd*rUs@G+!>Tm3kw$^9$sj(zn}nEHFdv
zBdyy76Ph6pk?w87lqCb|cipASueMNjx0Tjy)v>yn@_xzbf{s1Rly|zk-Hi+uBWI}M
z?pYX#EsNworP1ef`B_==d0XieDEcqKnwQrm6l)1Wq+WnHWy}4gLEq`v_-w>|vbX5+
zSvHo~r260L^7EF;oo!PF{mcutWvfa4+b7W~8X=pa<2-2)CC%Vvo`McX(I$2JHo$^~
zG=H54LZjLYD#LaVL!@`&Rbf5f#Znu(d!3v<o36M5)`j~OA7V4h#b)LwE|aq)S|emT
z&d6<?%nb~nJ!c_nMKg%GoRile0=(m#TuW8+Xpl|*^>ea^Eg;X%%l%ZE0;r|a1uQ{K
zyos;P7i5jJVPibId_n%aic@=8UtE*C+Dc+3k{@+ZwzF0F6H&WM@?ur?5iq=QNp`U{
zKN0@yvV2<gH4@n2D{{E1Zd*(+{=Op5Q^lY)vM;Z~Nf^8?o*lX>kFC3FT|Bl~!ani0
zy#v1E`q&E{(SNBF{h+%G5#E1$4YWP3fws!pc((GId{gz{AVA5#%5_w?uHq~2S0p;;
z#k0a+<#Bec0$IoFa<u9?nkQR+9ZAxfcy{%=JW~}ypl&w+>icy(TYf_xqgsmw$)w+~
zKyofO-iF=k+C|Me{RZ6amymGrH{jk<;+f0ua-QnUMSynyE;o`?0O{_^?#%9{+|&Io
zu2(?Ft@zG+%iDRdXns@PVE4d*x&I+Ys^0E}zIy#3@3d1Lr3P8~7FKuuVezc_E%|}n
z7hX(LD1YO&4@t4u-O)>niKvGz<6U(3qUUb;|0|S-+uEJ7XKn9bOHSY!AZ09Ksc$3H
zY&IaO8OtHNe&JX(+kXcuSSwE>1LwQwzL%GAL3OIXPXYAxT{%WN4bc6&a`$p}4N=Fx
zvx)cQ5Y?r|sHzF~uynZtP?mR3Zm#P73nadEPp)L^_F}1JWesIiS+qUnfvmNAR?PZ8
zkQYhl8SL=`G@^#t@yxXdi&%fxms!6ed4=79s_gF~S>s@`GR&_S3rRabkyI?Vvuphq
zJ6J4tm39J9^&ui@Kj1_AQ0^lAgpaik!IWjivtJ&{Ljr2nmGy>mDyB66tjt$3w|nXx
zol4~UoJ-S3XbQVP!@hiku)~kw_wEt;J#YMvQM>M$@htnXJj(a)g_dO;mQ7`hcHV<a
zWg=RTU>;8}rXR+~;wK=Ro)OQ^KaoGTn^=X_eJcC$lul2PGGPH2K9#RX+krd$ncT!~
zdm&r%OpcJK)n0!lM_0TzkNh{MpXbFh|L1anv<(UOpUd^61Nd-z0VdDW<5`ava*|zx
z+wANMu*c2l>?x(ZMN0j@<w?>OK~%dEZ7D}TS+oy;Ykvc!L0UXhzm!)>XmV`ZOF)_d
z^5mtQ<a%0zIzNLRhLRnJ2;05~%9K~KY*+FdtM(ci{}zCeud#}=2Or<O#=1~GK8jw;
z%Q+<F4Mwe)+41by8+jyGXT7)R5W%VOY}i|Qf}^<_&_441k<(RwQx-x0%G*_GU!s*p
z4^DJt&;FG|t7OlzRJdIlZ1_jHwQAEQ;7|T2zjWAejqDFqXQEyns|q7Vg?d?|s*d_t
zQ9(JSY7X2L*OZ?<COyW`o(Y4Yh2cmP3OPg-u+vs)pc?rFGG6k>NHzP{R+*quk-ih{
zlm=3R>G5oXowCAi&Q;bzQkJUPQqm<!(Ma2;#<RDQ67M}~nx&XGzvOM-<d_dsDH_#G
zQrZHQ5)se@0>upp-KMpDrN56sq3>2cC=^UJjTh-lbnK2wIUpTbsbhKeN)7iNIXau@
zLliVOPpV?p>DU$AaO%-zs?G+>17S8vqrz{}17&{LrS~)3U$1gXE!BnUXxP!^lyt9c
zS;EKpSlQaije^R`DRotIH={FGDX-kNQ%!;%^ItnCJ#4G&ofr>|!3v+C&7Xrab@`uH
zQbyT&CZiZMM-xXE#hzaKAyhH992Gy`4I6YebMcUst#i6PH_}*w=8vb*=K4hJpm0()
zdrtbU3?2gkWOtmDQC^RsGn(+=a3S$G?zdmKUdM)2R+?2AKAww)fGCOPvOveSS60?l
z*)@*96elI{=ks;>gPoOBTbw#5I^@Y^#-`fHSB#EFssqMSKjViDt1cw}BSuqR6f4Vq
zp9T5}fnM8;em8?24Yof!Cf<g}dEpouvYeRCQ+6W72*m6wMX&BH5^^jOusR`t>BNVt
z(ZnZMq>SO{*9|qG1`u-3<G_<V82s66%s6b1cF1bs6{|l9nVJzVv~Z~5Jn7(e8U*T;
zW$$l>8`X1?lCtb8m{asbu|t5Lk2Vz!&++_9DJzj8#(Nf4Rq=1|;u~tts@YoGU-X6G
zWJiKwrK>`bUni`0j)oY3J^~{F?Gwk+swx30pAD$ytyL9wsbF+GJ6TofscvUP5?Z5h
zz~=6(VKv3yqyBo)QhL#u;(<XZ8qAp&2**`ZVw-OtW#Dcm+&vg;a8;1=GGkiNQQ9;z
z`}jo=^K;WQBEZq9rg*7-Uk70-yDGI)QaL(5s6}P?4Iy|0CS#9*(=ZdKx!C@}FXHBK
zoe4gsn<YHL1pj-GCEVKt{{Rgc_>e4EZ)Lk&l~|9zAr3XdSSoENezOLS%#4g@)zr#j
zk0Dm6{Nm9p`^HG!r&jt}TUS3f#j|p`ydaz54V|6$s6VbjG26Q-ku_3>8(JGxX-KN&
zJOnn`O<Cz>w$iaD+q*z#6mCkTzpRrx?Bee*#_8@#y?Xl=z&2SfKEOBCVQ8ed$@g)H
zn`EHrP;5u99^VJC5_bg;>GjdA^iaZ`ZaVP5F?JWb6nAHxE2g+tFWN(}%rO-RShCP8
z2I?x&LkX6CnyX{E9!h}w_w!3<+!ChqHxJ~{v$u}D^-z*jc@<#)aK0j!yTpEp$`IAV
zT&Q7wqS97FOT|3Anu6>G;6~|_(fYgQEJa}AS)$@<tyY(biaN!NmTh9uaU^GP+nmN(
znA35OC$jkObie;kI@VGR^r42exKA<&Ga*=}vx^f^?#~oMxy7dG)Jclk!Y4w#Pf}b%
z&7xzoCPkjPYOvs1mTC(BlcM9mvIX&*thj2+%%kJ9GAT?lbc`)Couy7zB0L`C&`_aH
z9Ed@b`iowjE9-2M?=h-8i>mrWTb;^eY0eVoDE^<-6;)=s@l6qWw*~cakqt~znyBrC
zh#Lo(L_CnAV_TAxrqYeCbnHQr5=eV-l9hJqcB^@5^!-h!|E$)rG094>$Cg#XG(?eU
zh{f&|GK8c1$Fr@;O8TdJRHCLRaqiVd!ot(W@b|EeCHqWnN!}EtgWJv#l!#|B?qn2G
z@*b|Bl~a}Wp51wpk?w%G&e%Xoel^^Ztz~inC9n9;WWQ-hj`+{yR7$=!?7x^7QgZTt
zCPz(2vid)h^QJ=~yM|gaHz{Q07a;9!m1bG0ft37eh$X3Ia={nS=2txVQ*AQ886b`L
zPtsIMzBc&3I2TfK@_!~r%|x>LKa)GnQU*Dj>yB41D-&24sRXGSg~CKQwN&C%Z$jV#
z_Gt;nNi{bZz&~3lpQ&8F!dHzbWwd1sAv;RZN%JS@SYebh&n`>HMn)?&)ct_!yyp}i
z*;^QEi>DUVJ&AU8w6a6BB^zJ5*2>UQf)%t@zEOR-1j!@XC{3i{o#WZsHcE`@(qe#$
z+bDt3u}+vd#waaSiwSh8x>B3Xj8Q76c65UOp4dpMX1Os+h{}Uf&&Gg9amRR8uC3Bu
zwJZyu&TRo&4p3%WB~kT$5kUI3%0S!f{DJM11l#JPGpXk#X?lg9Dybe9^g?)cS@!dE
z@$6K4Wt?TXqhggzRopzN=|ZgHWNVkMV}Hge<7k$m>!6IHzxeIO&Ua86*kRDJi&u`S
z7R*PMC*z?7clw&4RW7J(!Gk5}l#{A{>G<+YfQ$#*$Fr^p${f{{G=P3fK;osj_*&l)
ziI>{Ovp+i`v1ATFLpvd{9evgBjKnE1@%f`VE9dQ0Q&J#X^KQxnTh->7_}tcA`OQ{U
zn?5spDidv0xzmGe_ViXx+N%DV2H=@K%4l0v<0<%T)=xQatJ;{1&r1CX)nPLDrw&jq
zwo)~wsO+EA$Fl5CM#Lk2g^&L9fgR5F>GV+^AII^*_bFioikld$Kjdk3Y{@_+R^>SX
z>~0QJ`l(VT;;Z=}rJgjVVLTf<NExT9L7-Wqlpt1aurkbUtd5PtU+141kUy=$wkGwM
zL}1(=tOPlK(a;3!-MBWCH$-Xc+|mr}N|@t@D6O5(g_|%lDfh!el;f(EWAQa_sN$<y
zI38b{hAKb0mkWd7!h437jNS~v_qRuccbM{0bz}_j8xB3+s29(^9j^3I#Sjns5lS=F
z!_oL^Jpzf<kvMY%5+@P<?<3&wzNSQ!s!@KEkxCm|)r?W%x7KZ4XgoFsez1%TVMd!@
zI7&HVt8yC&wC!V*?^Vihe0@GvNlv&EL^B+^2_gJ)Y{qYTbzBs$jnjY|{C-T>kf>MJ
zM+y}73sPvQ6Kn0=TUdH~G<EhHr;Jo(4+Hl_<CG_=8AD01@yZ6f0Xh~iLAmFCvo@*j
zId-sMi69cQTZ1F$;-z#^H6y~|Ug(>PYsa&tUdlGrkAnefQ(al8IzI$o=%w`}?|^t_
zS3_xPd}uwYhB8H^qU8NGlopa3lHb(;MH8Z(@2xbHx@h9rpo5#;n7)Bhk^RqG`LfDa
z{)QPJFWc^>7!-Zr*w_pL&1D}{PX){k@=yDsJF4#X2k@pJcstdM&-bdSw6Il8`y8-7
z{>t#MP#@08pudDhTz~EWilx2q%e>kf18$h?Jo8uLRag3fzEv$0=YdZ=ORS}It2h-P
zwDt`AK3_|@QE^3I{`*_+c(y~M+*LL20}>XX3^K()SJqa(P+jW{@T}TsD*Ed2Y;SF4
zsH!1>{OUlFV*!e<qx6yL;N!bGN_SP4UP!YIRDMv^=qdPp#-0T#^=tm@$;*M-=C#w`
z)4Fmow~q=^2B~g#2i1lkC?mupp4|&luBd+Q2GD_ErG<mqor;~NDPl{P&Z)*)cnoo1
zHA0ldRa&bJ>gF@)p&?k$3qk+f*cD0+4OOPts<w3olZ|zi7Ulh`5tBvi-x`WHTQo`M
zz?|zLS`xYxS1GNp2eUrE6Hw#pD?h4ccEpz|48k0&8qeB<DTh_(62Q_vT=B70_0}P^
zP6MT(>if#D=>?THtEmO}vacE_-m0})r0$|rAIsEY)yQ}xJZcE0e>leHhcr^w+N$h2
z0Cq7#nV#}ZMRQ4FGm7=<pZw4-@bHieEnedyb^F=CFxEX59+3>-SPL?3#%-)o33xXn
zGTI@BPZsbNR&dyjz5?!{5ed{I;{Y;8ISU)3<~zng&SzIgxUzmtlv+|mrFb@{iE>*N
z77O@@rf3lX730}gO_jH*6Kw%n+)QcW(5gIFxaJ~Tx*D~1Aa{-fJ6}#)fxT#^q^fGR
z1KyO+(7sYCpe25$<f>-J0Mxm;GTbwZll~c-@w;Aqs+^@b7n`G(tx*wY#Cx=4TaJ2R
z9i#=~L!*g)NeiV;`HkfW0T=hYlik>r7D|q4a2upej6}ycWFOBaI%KI?ex%}O5zY-u
zQEE#GHFT_ZiZYbX#R^iCB=5xPI-CJc@{Vm*GU)=XjpN?Ezj#ybQC-J6rz(#JUkm1u
zniL6{Vra%w1xX+>`!wc5Wrj^O!x~s7!@?Oi(HPS0+kBGF@@6Z8J+thaMj7Kn8HF_e
z#zqx;RYy-&eU9SW?pQRr2K<u0o<V3lxb_g+m0HGTwlnTC$^!-;IP`_43g-KL%GWg8
z%+xuG+AT|++=;TnW?j0S3Hdl()p@eba}=-Yk~yEVfrfmH2DfmIQeu1nWUf*R?_SK;
zda}236^-kORzf_?FvZ5m33YTVEKRAQ$+AD((O9mmh^H7O`6e6@jU$uZ^NE%vrYSo^
zllhq(lE=VfRBat@E1^vu#yeeTM8xJY7wqFmS3=x3yHGc}RrFygvpA=VQ>W=lr0ZX|
zsN$e8eoPCSo(~6L{-3V+s9aj2xk&SrR<092#fbw>k9kUSUw>l?u7L>PdhnoVK2F&o
z5COZkW1bRL^-+nIVxJxk$v84^?;i=aQ|Buo%zHj;#jh>!v*moHPSp`sXqyNQw4s{k
z4-Mqb>1kpr<@7Ihl4Kl>Jz7kMy*~T{>!qKsL`vCsV7%1=go=(e2l3|%l$!0PAu%?i
z4FaHTT(CNfqS}uVAP<1(7EznxmpuFx5eIm3J0Q#hwV8bb1N%VsXn~@3fBvBqLk;ET
zk)hP-nT6-4MM;yvXR{R_8H6Pf{Bj;1FQsnchl{C<B+luZgnauxv&?=V$f$H0wm(Dh
z(Y(Z?(>w>~^z#DU(<+ybc+QH@1DR%_QoUoA2|Y~#I=>&Nc(ovu`O8;Us#%DvOS~ZZ
zjM8blnxT}77b;EKgqKbX;WD@3I;9I>OLicHY!5uH&@Lb~EA$E8#S$WhWh$QToA@(X
zR$@GAimV1^DmaYwK+C?)RJ^4s_&A)Y{Ng_LZ7KbiBlO%w%7KPo(++;?+Ma{NlIbYY
ztkP+{n}9GgO9@VKzi(1&me5XXq!s(%ZUvC~mL|Q|n2IC{Oj{a@*9g?NbUwgZg3;h)
zM5Swai<1QEDKo00v2A_<wk&F~;@x<)In|iB8i~b21o0Q8lNS>0vc*cMkJCL-8p%05
zgO`SGg%Zu}#a%7?-(n>|a~h9R8yeCxw11THLxg25U43P&rGzDlhkG`Deo`(^%J0i1
zN_F@Cr4xfGar+V!q&L2t_t3G-2>L7;h+M;3IL|vR^jxVl?GXsV?6Q?mU*ck*4Z&yZ
z5Y@a`+h-*XkT$vzkaXEfeW}wOElbIU!Rr1JBCo}ldlP(pBJDN8|211_?tcI8Qi&xE
zkr=pC=_Yl$4Q5LfkM8Hfcz!rLiIBNvhpmC9uMLU|6N+of85+&eK=6vq=*le)b%o;E
z*oFv!*EK*MkCrOl0b}v?gHLgDx-BZp{t?F)?cYJ@<PM2b?<-|`rG4RGmSvxdKWyh$
zN?iR2&>Bm|xzEC(9bkBW0td*2G7Mg(`1#GbWe_>JHsE>0(_}qQ6YJ5-l-hnROjvY}
z$}lUeG{V}kOmS6>rLSL>!E(pbSMf4sNXk9Zm7&p-P$0KQV)0hm0+(g~^C!v0ud%=m
z_|{M1Q-GiPzWEeiBxZk-2+%5kiYH;ODi%FYj45d0yyvp*PZ^iqurtdQZ<FWFo-J3}
zR379mhBY`M{oQmddWGUzrB^|q&0&g?bDt`_zK#uFp+p6@i>d{QF`(+zCD>L9pCOPA
z8}XPw|1$Xr?BWV#ysASe%H4XUl2ND1lMdi@lCQYfat|%W275htK=A`_GkW#4k6QL(
zrP8Lo*%!+G#MNnA_Y+qK90Hy9l!wD{7-}@{*nLSFe?D(}b;g)dt+B&-QyCvr6N2Nl
zQE_1Gum(I&&P_#Wsk}G(VmzkN6DtFS4AtmJee5k$yqzVi0lw8I4WYZ+H)CAatWp}*
z>vxV=J4L(FpKcnzxQs%+#a6Gb1y}T>L~CHhZ?I;lS9gGAPG6<8^)5ckX*#J((d@8C
z=yVkp1D6p>#skCF;+4N?S@>$@wfCYkoN{nAK^bMvt*c7MVsey@-hKk5y#d8Spa+tU
z?Z{Cgyw9KJT+Y@NTr5yl0L4yLw7$ax%Bgyvpk(}vSFC_EPF6ZfVdZt~h^$0a4tS4e
z@^Ixh)=GYY*>qBr#@>micqVIH1P2RIo7iCsprSPJt|?HyFO5=Ui`7p>QA@wv)bb6l
zHQT+TgFQ3pfb}<cBD)xV8-fBj=!PAnI6wk4y`t3gQ<>2Q0garwxGxywYUn^tD~60*
z)am8=sMB7#N`y233eV0}YE}2VqqT`fcs#4Ue(u}q&hw{ni{<1`P568+gxz(Lm!~fY
zD_+4Ad#Uy6FKl$o`)eiAySG5u{LueX6hEL$B^3P$&gI{rQd~~xwd@k1Y!E1`oJ*mM
z1xm;orI&Y@KxuQKR7P*miSpJc9=(l?n4<Tzsp=UTA`W!HIDA=`Y!CuZ2)S3_ZwzMH
zf5BmNKNEl+w0(|t+ZOVr?uaxb?ym)yUfmM2m@0WnPieg~f)#mKkUt*;1$~u=iE8b8
z9oVHj#kJD;<GhRuQ2_P~04e)lEi1oP36L&c*0TEa(X<i{9IaLQORes9V0+gpVU^At
z<3#b5K~(T9h_e3CvWn}JAn6A*m&WUqI4SuK$E_K@x;&L7P4f${qX=6;`pl6y(6e?~
zX_`DF8T#R|4_bD0oif#b(`_<Bi!?ik4CG=PNkr$Lc+QJK&U1FF_CX7aAla599i;Md
zNBQU&`$lOdX>J<|dG;u$a(6Noa`AgDb6Bsml(rTcP`V2goe9MqD5>iaUalihs<FH4
z74J&B3OK8mBmmb}@;fc_-vCz2Zy8v%5GbuH8BspI)w0!u;%!9v`3UC{VM3V?6qk)a
z+4!e{OM*bLHKDk?)qXpFqhc$K`(FpP@LMIM(#J!b%f|8sWkeRd7RrE)H7esVqB14!
zu=*It@XVY!;VKg7S2h%^SI@erWmUezdeyBzNbkSy_k${FTkf~$n5M0O0ypNO)}|yD
zyJJ66pGB`WG6|uC`q=mSX+l*>aKp*de@zrrRYhLBa&Hyg8Be|bEK+Nj$CKgN`T)D<
zD3IyOAtoMBA_=p^9kNd~6!D7u2_S4dxxs(cUCt3Ae#S2t`<u=P&C&x(ZTDd?!!S6|
zv@r{VhfQWX7n-2hB|Fg{RkEW#;D=W@u^4cSKcc<iZ%YBlCeiK3Dey#b`!Ob<xcwLk
zGK&Zd)AK;pJ&@n*V=khQ$QhTl^w$R*#QW9s%8)5VuigX@9hO)+j`T3&A4`tV!a^jQ
zv%o_>b;a{RlL1GDpKeiK59?`0$J#Z25aI6cq@#Z1GJE%~MQV%K0TBGxCin$KHNzj~
zbA6*%3T6!yVjy?H%!g-WenqIqZvhsM4SfMgu%O9rnu|gT;#Voe-142GU(aaqW|NsA
zVkg$Gr;Otij+$nWX{$e%$)5AVbyEACP&?6k`CONV^mXpME-jy~qRQc~5*^{i5)EVl
z_@IF-0tgKxk^idOpCd#>i9Fikk9d_xqvr*;Xdq^3Y2J?|=`5!uK9CHXP7EHjeI1Y+
z-X(d1$dx{z-Z|2R>9tn-MLbjc`n+_v4Udg*RQ24`q!O5UH8DxyelpIt5|`q$kR{8$
zTME?dhqBY5If7pj@HXEC8Xv?J@O=V)tR@)IRmVpBwF3SJ!Re5w5uPF7vk5L<V0n|m
zGngn67E?kc3xeJj1eT1V1$+tN^9>;eL4yQ5Y1StNr~<gj^+cNy4?T_X4zfwHeD9_l
z@e>L;iHBMKK;uEP=s{4vDJ6rTCkSfNbi_2IqUBZiO|(2}GVo*dYTr{r%@O<kOobxy
z`GV<Ef<k90gbnaSYpxfO46c)J2(G3#WKREL;Cg`QG0GXp8wjq!1QnVkrZog~GePO;
zM3GfF%d7%$^^(Xd(2$qurM3Y)FR_A}xJ~hw`n=S#72A}+A<i&U2p6hiMcB{}ZKhu>
z5poNp9c4)1w};v{=9$K5nnI07`BRck|LAFofIy%Yh<^NHXT5sfQ{D-pEL`h6yG~vy
z>#9?`H{Gup@ry5hL%RXbp<VF2M^z(Q9)N!cV7f&u>H|&+;AR5y2^Ep=6u=}>jG?|^
zR0VJr0R?6XP!|ZO8uUEpY2tS>@iVF_V2ByX(APkjAb>rHp9!;>01hXhu~q{#0{Di2
zqWOc|`IHuoBP(JH%50YWJt_sjG@~LOir+H`$;9uP08X;Xq(A^`5hgu^!ArAQ0P9=j
zu~Gm>`=%JmJWl}nRj6$|69V}r3gA~TO=f=m1klS0v%LWJB}`KlG!VeHS1e7sw*U?%
zag3cqA5cL+pAx;PjDOQ>>v&iMeb~(OPXXLg-crz00@&8TR1|!-0DeW}CT*+{z|O`Z
z!8oCy3oTGh;wKB>SS$L00=UOYrg#CAt$>XMaHCa`Y6{@X8pa}}Q1*@jS{w9SoPSR6
zg7328_doy(h}2Y^%K~`F3V28WGp&H%3E(`d8d`QDh3E8?axyi`SproBR4&eV@%tJf
znYvPM0laJ~2^Azp07qK^>kHs;069Bf@!O7&Bs?f4pcMr)){68MJ(->rAz1+n1@Ht6
zhglJ41n`X&aE}1)B%rBU*9zcL03l9_K47T;*i$AZ#m*GK4_5p}2w(%kG%2Es06JTd
zM+)F<tDFM`a1db{8+l4VH31z=P~*@N@bNe=__suF%BffYy{wpC6+j;=;1L0=V+H(P
z06naLDJulDsTDL;02u*Ic5RFRp7b)*V_)&x(@God1aK@Ud1W^izpGfWuPJ~ebBejy
zISS|%LN%%<;LS0vh--Ml*Kk%1&Fqc=2uaLC!#M%WCvua@_6p!EEAnpyunA!{G@&jQ
z&>Vu|Xp0bkI)K)vED*C|JAUnl2UjnWmn+=C2_T~R0zhyF2k>8Ymve-O#`p#Qt}Xts
z&-N%aQ&zu3kv^R-eB!g_5-nZ7g2pfCr?^uV<g(J>Z}H4x1IMylR-*%?aYODF@BJN4
zGJAf|WdEP6oXUuUJQw=`7d~-H_8c)dC80ntx*z%gUywt@$y5<^odK`%iUOFNWb)9E
z(W|4zxdwSOG`-*tK^{AAo;~!lrRN1Ac2M3~5gKY{SxzDN!&<h>@$$IAwN`rez%J$^
zn#0fvSy8?c>f(ZF3WexGVUX0D5!%u0Rq9lq4HGLuJ1^(Hb#$ITo@P&3PNO|RHheEa
zJJq-HNv~(=(9WIvTK3~!rG@uTTR6(v4{&d+qdyrysk{#;qXbH|(kNj-89^v60wtt0
z%Jq9%R<KX$?7eO?&*<IzQW=c`O1=F`RF}2_<=k5f6f$0Vwc|aS^x<wsdVB}>x6Y&s
z(}&VU>XB~=J4?OuENK`RdbKkmUdEN!g8hoSYBnk4=6-C{xQ=*Z(*w%f>Q&G$qccuK
zXSMrh?%N8^^HoB1_0Y1|;wiaq?9l<m-*>|%F7sDsC=0xvM802`A^I{JYYue}Dlu)d
z?1S8d6B!GK^3^0-THue7+h1}Q@Ls6;8iG~i>oQo~#)`w9gGv|Q&EN6-w!SI@DG^9@
z4k_Jyn+l}(9}pw^RH%OowJhfl!kp*6<(ziCEQ8ZmK(arqv`CpGkfO>$YEr1RIoXCT
zrL!sSjF2QvX$@1*OlMjQ$Ked8NvBLbdKvY}ET<LtBYHI1Ad4PdUsb9{vx_6O?xWBN
z^#Q2|>E90U@XfQxPeSC^U}4OOBo2Q~+j$R`g4DlwAb0Wb>wWqhVt)A5X+O0FvT&XD
z_i;-pIL>F>O@0x^z%)tjk#8^tG7!u!10UIEYD;{Jz;=jhXj`S#VaJ(r12<s;nn9M+
z8&{(`=ulAfUgzrgLk2~yw=1oWPSZwvxeb0mO?@aewut^G$&%E4+QKv6uK?R0Q|=)+
z1T*Vr4$D}oB+8%@{v`Eu7t(|4%2?YM`a5WV&edSg4AVh<zzh@@z~)xK;Q(4bDP0Ar
zn9be#S?J2qCfp$W;oSyhU9SqJrin})&|AtwO261o>lqMo!fX*A;L=qTtrtKLV2qkK
zn@RY?DhH19@<2eK%y<e*?X%lG<qv8miF@haF27r5CK>}TcyDLxg5RoQS@8Hh)@6K+
zRFv`fabp<`Mf_%$p@;{G+)%_0aBD#ixql$2$%}aNBL`*@&@j2hfDWKp8@%<j`qk8W
zSYAJ^o0l5~0DZuBm+9X=XliDBo}SY35v2@7U(^Tew=Qt0&gjpJz*}Eq2!htv41Yvt
zB>62KbUH#o$GKLInNxHDkJB5*=bobGn?F4!)M9j_)#LGsJ3S^&O-<Z*W7w<{U}G6b
zL-%9@pEP%^0h#py%b+v7Zi}*-%SRY|t~|?$s>?iA9!c$%{O&<$WYBb)RTI++U;qJ4
zUQQDMj3=PUCH5CUSE>^erjr2r5Kv&!T=^~P8ae$)TBDqc#BVk6Gu81GGtz#OCwEu?
zUqfay<|Y9wN12!~mkS^xpi!FvDZ8|MuB;_`ljNfXs>Y~@KH_(ELNf7dD}Yt4G6@sF
zW9R{9ufMtgULc?;k8%Q7(Zx7devOKS4(g17^&?xw6>(bt8(8r>D}eV$TVm!5;D^eV
znXD7Q9}iht)GPtCqtck?%F_gN3FTxe;}8K{VZ}5-0H<1I-%J4S6S>J8X#}tVk(=f~
z&I0({2o!VW_doE`b5xU#?hBx!5tXatq5$@=lIef|Hn#$96u@>?MOrF=%hBjXW$?N3
zOaVPXU4a_lSn<276~CSWIFLw9#c3^opIZUz3Sfv8&_e)glQ^a#N<WCX@)F9))GVLu
z;M!OZAQ$IP@jIE2OkL@e08XMzO#F5WU_~q78UZW^AZNEk{9fk>O7mR#3jr-6sEOY&
z0sO`a*hv6~6VRlH<^ss9fVBm%ixqhl0SpHa;$W_9D*zj;NFQzII*_e^*9Gu00Zoed
zNdUK7VQv+`ngleJW|aWil6H)ZJSAYRfZ7q%G*=!kfbFev>Mel#D_Js)5x~P%!1@As
z(hBG$fP1ZgDfR+-!wULr8!vqm%HCuFZwlZDVDfrABYy9*l5vj!Is(X%Hj3XrSg~I!
zfF!fUTzRH|P9}av^#qI%z`Ws>)~1U9CKFRrcaIdno>t-n3SgWSc{KsNPUH<u_4sis
zFY{+aZ<;F?16X>loOnj55m0o{?9{k}2u{t90Ktg92V)GsGaca6{BTC`Oj$=!fKsbO
zMh6nJ8FHpK5V4pZ|0Ea$f<c+n<DXu0exI!9=mRJ?X&zz`FBTKjCWd_<`hf2@S|e1&
zP9`$}_fZ}|ImX#j>RBbCs`7+pG`Ed=O>g|EWhc)nHLH%YhHn7;{aMAQYBOtiGT_1I
z6t8|x*6_GLwRCrGFrKTy=5DA!o1ww;LSt#sO?~^ZRi56!&G?zWrOY>%8Xj>lOV0An
zDOaTh8?<cddF79~tM_%V*`JD0j4m<4m0Z*Lu<taQz)@!KV1TjYmwG|zB!#ZmvMU#G
z$nW_#nD$;&;ykzRHDF^S1V&49X8DO1l^RvW;Y{&<`bKk02))kT+kpU~C4BxWkXnK>
zfGftQd3jJ1E7cC*3az}WL^Z)l>E|9$HC=j(xo#MJ(F#Q0Iead+@~XvL&d)Fl^*ewf
z-&I<Ic*C=@i2s_+iH}_=gLw0PEqioV@s&0$MVap@^~+%w8Mv_2?AES+5q$;e)5~R$
z`hj%nJ*A=Xn8=QMim!c^cYJ{@yLwN_sakG*2Ta?;&>oHZHCXC>C8E-|-w?bQfs1Tb
za9;_oT@}VR<5~FSH_tOph)vl6dRQbpM-Vxm<F4koi513#xNZV~rk;MrS914$(}8WT
zFecn*y&)wr_M}R~?QK@XpU=7OLBu{*7~|%6@dj7^G+N1K1N~dM)?nn8&RtIb>b|k8
zVZyk0f0b*>x0EJbp?~Xs{Rsy5n8h+~d1Qr2#H4j3pT(=OvzG{OnVKSsWO_BW@EOM+
zY``}Tyz0)D`23jp$uR*9X97)|#b<<dH-QrGB?h6q+AMEPF3mE%KM<d+i0wShDflw>
zKvw!?Oh69@d_j@+3evH?XxJs80Mq30bBh&ba_J2hiAQ&%4Q#z=Q%y!A4e1)^YqfYL
z0uQty3)Z7Z(b#9z%{yqzQi_y0zB^~~CU*0ZMLRJ*WIgpqJW5=w#QMeyq}F92xd3T?
zvEplan4MNeaiP#@eL&o5-dKuplSii&TK1q=Y2N~GRXh}}9WfUz^%t!M`i;?0sAc2~
zF3<jpLY^>++C&-pOWoaCHu|Abr>40(^WXpqjGN7IN?;1ikA3+kDCSO}rTp+aMOpaH
zz`X@reSy?|cwL%iOHUv3>Ku?Ks^3(d+cHg)CA#g?cY(>W(#kSk00$i(^3lc?TedEo
z=qCIt+L1<6EC3tK3<%-Y0qfsKmYIHA3)of&xMqzI&^TnOE1Lvl1tm(&&~FF<;a`e9
zq>iFOMY;fl@b8FK)Y2keKjMArAN*lXkCd7XP8{Y+=|yddw)_vz{$yU*7QN0=*Dx-x
zC%D#FOI>OiCj0t;L#s+*OigqPnDw>UsD3OVSt8;Af)Ee!3r1CDXy<?KnCB@ifXRLU
zY0MiyT^=j*EYE=EJyv#kTZw@iY+c@5+=QKdHqOfn=;?vo@il4}Vnj$Ua8COc{T1zC
z8<`Nas)4k7Y$U~Q^lER|%AHS?=;+mT#A}XWv~=ufFxK`BpU~Wi9#zST_<9O&h{-7;
zQpcB$0}Tyv$aXDj^i*jY?N=t7{g2IT0tB1mv&vxeaGREGeX4}C+g-aXX%Z~h>`Ug-
zD5L$wU9G0oY@<li!OQ2FQa2^KOkOu1nM8`w^rJFTytDg!kuU5_M3~4Ssw_cYVdy)=
z?@fWW5{Wtx)F<l+p3q^$izF^z$dlSsz1=i{(R-Ug;|6{00ewbM#_t$Dr}d@xo3N$q
znc}IM`jndDbH$_fg*AaTnT=-C<@)Nbi+DXQSONxc98MZ;&~^M-%i^CaHS4z*dHI2u
zt08(XdET^#t1=DISu-l^uYia!KSVQhj+V*KanSK&7B(_IM_j()1LRr!T&W%OrACzA
z1M;t$%;opp1hZouNguEUQRf#*a8R%XdRu}1`dle=N1$gC`t@37?k^^B?w_44g}!gI
zmi<ZSX%^^f1iC|M^x;4c{~PGx7U)`m-e3fpn6>QHfSyL^fBKt+c{h;@^M*VUYxIKe
zwd^{fXIh|d6zG#@l;S=P=)o_6-qZrUt3dzvbSds$K>w1^@7FX7WAmTrCpT%?MMD3|
z0)1;Dmpzzb`qr{10ln5MptrI>?<3GNN()mH=u=)Pp{*YJnS_ba#8A`rL(_JhBcN#J
z5l<)ZJiC_G*PidR?Di|Aev0-5^@LkRLu=Buwgh-ZmgdT8Y@Ypy_J_u0;A&lr(6lI$
zWuNqrER|vJD@A#o_spv&)--;-izMSFEbN<~S69Hh<naCymo>{TI<xjlahqo2@5$4K
z3CuuKwJBbJ_`fb|I2KzT;GEJftQoz=<vX5&k^^(+840c+*WxCY1P*YUam6++mx(+2
z*e`mnUX@%o`t{GYNp76f9|J0q0WasA9st{5A>7K<fw&5qEUODC6!yWsd4RALO<A8e
zO63%dFX=apKdu86w;0b=yxFi+gFzqH4niV>`S^&5&mp=Tx_B$1TNphekpZklbS5u2
zm#69`Ls1rtLfJE(8jQwV3~^A%f^Gn|&72h&mo+6cHj6!Yqc}+wW@_1+H_Cz*_V5mA
z;26hsYrm<8s>8VLm{t+7yL>*epId+hCokvuzamZyF;?G(DLL>~sW<E!Z_!@h@lyi=
zaTE&u`Aw6X6Y<?xUc^aLOx?)17BvBm0iIbaUW>`BUcDMsB9;X|&V3u_Jijv*Igr&u
z$|~WVQa8K`&&s5_Ai-CnCJwv%sp?8FGurY_sp<FE7@mLk`@(33MemI;EBJe0J$|P&
zXt-QpO*Ugu0D(+v-}Pi#ck^o5k3Itp-NH-S)3vP2dnG*Fp@vn3))ah>{!+G7cQNMg
zey>FJJ2IL}<$8}ae#c6tbU5`fnKLzwGRJC~(()lSBb?RcRYNnYxq>!`XsP7Ud)t^x
z)E+r>`k>SgcdBkBSb!kvcD!uC9<0-{9YnSjJ9aG^=+C3LoPV4wn`}PFT>b%>&YEnP
zAanbV-0FZVk;oo<TIFUh$aFuIo!iN^u#7~OWlgqWBp1^ESlMJFKo<5d$m&{?wH0I`
zp9>G=(-u@7WZC~J;kq*(mO}Doj@{}|IqK!<bdgrTe@2`f!6gZy0j!KhnURMX>qn)2
z<BnD=BSr|aVQ9;T(89{3)qr;LM<qD?sk@~(5#<H#)x@$(acYg0oky18ORUMh9nK}K
zQc$*}qd-<q53>5!WbFmn^CM-GIe=_2kzH`J67s<?p4+|uAlvk{mOarcq2ZIP$rcK-
zWB*aH+OM@M;&aFJ`c+Mt@vwu15z4+|GD2yZ^`upxbV8jym?F?=*7eg+F4*O9rL0p%
zF6zoQH@uauOz!2)+#|XOCiBLZV&VxVvxv$6T+0%XT{ejrac2mZ<oD8&Y*L^dFljrk
zOeS?Km`oB(&Vq?}|I*+r7)@?Nuo`NY8`#RGOji3ZndPw;to|5Ns!(TTEjweETix&6
zU@mfxKTL+GIn-<zyOsj0oRk~nu>m7d>Ol=%;)eSg{c#MAHp08#XYHljX3dihi6JOO
z95x(9yi7xo7uezP?U^(L>3^B~*4ughYCcps*<Ys-NXiZAyRoW;W-+A}BhbaSqQ2qm
z$7n*0HUIE}fKtt`7{rAS+gGb>RrScxvS?LqVE0;OW}quGgAo=PR23QcA%jn9;kVT|
z6RgUu*FCRFS+bvgQ<m)a&YNXlGLXyOu{7%*U>$9r8<FBxChMp&S@$usHusc)=qXhu
z3He4sUylaxJm2gsRh(Uz3P&HI_*L;NUOVW7?3I14clR%FGJ<r^y#rI-tbbir`3|2m
zmv5BF>$Ch)d4;XQ-kow#-5ck!Sl29*b#n{WfA#0Z@F~rDE7P)v<xt^Yl*xMit1_iN
zYaz8@eSc4Bslj?g`P^D5K>}rSH;PN}p*z~#V;-**+l6Sn--jLK2F*ph{G5w?08QRN
zgdGjWZnhUhd+FF%u|MwkLHx1g2BE2M%<W)vxFz6tAOj99PVt}*y75k!49ECQQEVYj
zyW_-8C)i%!3b|@+tTXxW4d4<E&lbnj<~|xouaCPxo{p3`x1We9^rDzT_|0&{sM}y+
zGWrPZM<G9w4(RLE9jD@4RfSx)h9|Co$mqj^$;UYq$)P)z>`NR)^;Mw$iLj5j4&!Gh
z)~RByEBjxCTu1NI{dlq0xtI))F+8^v0kv`txqh`~nHi2LlVMu}!_OUZT|=_$dt<K|
z<rRhY+(@whb*HJejO;%w*D}Q+w^ptDvrY0|u2h!1TO7H(eSW<pY6~?N@k3uO_O%~M
z@tua4t+2}B1tnvkgsEo!L(AmflJocTZX<YZF3qzdWX-CW>l47^fzEs8!?C~uh4YF6
z3O0x%wR_-D@{_c9@Tp>MoL^2KF5!!-qCL4p@11~pGnnoE%e1UnrQ9A;<TNe&s#0!!
z)tNjkPN#b&xVdIIT~8s6T<16b;USb~sOhJbay?bMy>j%-(J|M@7+DW<%yp|>8=-1y
z7T<$Ciu;n91GH}$ml`rz%f>q9Mn~Uru;|Y`E`>_6pN{)fi3Dam;$AP&4F;h-pzrXw
zlyO|6rGO`nxh-P`mdWP5!7LM-VS<gSEH=SQwYV~s**fK_S-MlMTl90pQz(CKz)VtQ
zTCjWFlS}oRwhXBbWNX<UPB6wZ%4DN9v#}VXmS7r3S<)CaS}^}&U>VHoXQSg&Xo^Rd
z68l<2#ZT~7V2c)zhIAVn7XhF<Rt13NRnCo-Vn%3LN#)#L?lmuoiV@d7(%BWgIyq6x
z`Z(u)7WB59kS7rGRO`VDJ7<8YOZpj_&F_n~?2vPAgP>ds^u66Vy4^NYS1_Wd0NukS
zw^2}(1$tkBzNCLC?*2eecFAoReb1hRq0l*^+coG5UCycU2mwVcMHF}AdFsqVqsWs^
zN^e6btk@;D`X~3TR>}32Zq3CUp-QetNaqWdx}alFdUfJ>nwlE6T~?WjuIrR_2L1=%
za+y&j*Dd5Rc4AVck&-G139cEY6@2@pvE1htY1!#2xlti=EC_PDa*;P~hnmo^tq2B#
zAfjq+(`a8aL5!vw<we6p+%S<Zm0Tm(ETEC?Q#Qq!TDGlfZj+F2C9|MEb>aDL*;)p{
zd=R))%WW7EXF)Jj5R5O2AP5BGiJ-*JoI^Q5FrX}gGYhrsED>Z`5Pa8}i`1+vf^i@S
zcFhfI*T8~6CkUjn2&yiG-J?^*HavoxA&KWS5%tHZM_h(V^?oD?8+~0-?^jWwq*c)e
z=(-cUem>fw-aV#{N4>ZG#aQp2YSjDZw&uc4>%?Vm+edU(t7?qIeO7(cxy?e}*_a7j
z1wrlIW$6F61#l77sP~m-0*iVt7$n$Gy~`bWzWQBduo(z8P25oLK4vx%%>==&&1DdL
zoR5RdZm5+4y|BF0qHiYf9LjGggCGwCZ-`*91;LksU`U%XRM8p)-Q7W;vLNsk1g$of
zk;A=tTDHqQH!Nh+N3%%BbzG#i-<Ls<0fNdNxt{GzhY;z^{oF?*$(iv$uepv&q`K}z
z3naZL?uY}rNi<eX8-V0_lWCB{X?%P)_!k#4dgS^xtRpg91|8seP*eY+2+`woSYmR2
z_fcCb{(xX2E{un9J>rq;7IEb`GP7`k^pnioH~%9_1P{yL1^FS*bmTePGq)P^_RMwc
zwNT4TI@sp__`2@EsEX&G<Pt!_5!$7YgcQ;s1QNng6G$LH!W|OnC3K`$rMIIhF-Ad=
zN81wwr3*?gLMYOtSr8PYmxQheiVFAp%+9;JcgcN!|0MV3P21TvJ3G72jV;?jGW@U;
zNd-lHAvFWRq5)tqPa~q9TM^}1MC=G$Yt@UJQYI?;rAf+4an~{q%|Tcy_vy@=9@u?C
z%=64H%3>;_pe{uIImTJ475};`)#U%wQpHsj<=R_VQd@WRmjOv~W-IE%%x7zu*Ky1I
zH9PYqVBVuVGq387`H!=~9JcZ(x`jWo+KPU~FO;E-M$EQ<+?C;je-{Od@OB@!;r>8-
zCXSY%PJ~^FKedDV!@+XtXs20Pxn&vtFPkO4O#w@!E*;GR4y<(};2t)1HU*0ii<<6&
zl-+6Cu)8LwxaT2idd_6(-@e7pEe&ll$EitA3Tzq&9|e$Ny%HG1K#9p`fRWf&k%5&6
zvzi?<^S>NPA575lcIaIIwaM6PArd(T*Q9CfN28HQ-mE)sGG`#!dVYv#KGaKE3OBaU
z-T($2Lq!#kNWB(DF@&ptG&A}pTC1Us3dlCY59kU&Qx(w1jNSji0JK#B*ts)DO~mk>
z1AvnBV@{x@k9_q$f5Hyw7czS^-`J0OYrei8-ck-zpiD1J-(}A&HN3zUFs}JujPf3K
z3@;j!Z^u<VT9c0eKTZC654&|NoHCVy*D%jmsf@-vKXxVapmv@e2EBdfJ30mQ0M;g^
zes+_`GVmo~I?}i+0qER{(I{Ah6|^`q?5#xSNGH35dVz#wlAs=K#vyD5E_ade6$7O%
zjyAQNfqq2p(E42fwQV93d@LySj8W7%G^M`U#nC7<8ZS8DYSK_rg9dHcVB=ZhYyvtI
z_Ae&!0y+W&`Z)zAN@~MMDG>#p1Po`_xX?{&JwAuAVx&1Cx%3FAj8p?GK8&9qB&Ml9
z4VS3~^W;;)7kC1@ZUbn6ukVb1i$<9vEKkW5aXDz_tQ@S<G^HJb&yr~y&_nQbmiAw?
z3$Xv5fR4Jp!@#Cg1cwQ}XJ8WozUDaExsRb)MDM7yH4N-TKu1IP2taM6b--JgFpmtN
zt+RWbWJ{H4`0^mb>2F*MP#T05^<n~yB~4h^aWq4x1~J8i-Njo73o9;cIt#-@MdXg5
z=q_qeYflU+u9to&wRdbR6^CKc7QG5pYm1&c#g)Q&rAIu%><0@(h}XiS%GCl95k2N8
z?Wq4%nEPxI=K8lWH=)9CLx-o|oX&WKH5H9v1qE}fr2NrWp3*rngl*)lwo${pj%sf{
z4Fu;Yo!>h{3CEI5a`=onEGf>Rp`F7t7Y-|3IP~e9Rwbo9a~M*bLtzJ1hXfZ6Z<OTV
z#T*(H=djq$;kQ28Qh2&>$gVDW8@-#$`EmS8p1#5<m8pz+`M`<EXu)|QQL~$Pj_aB^
z`*0b#oz@>whg;P}J>O;NlGKbwq*RX*Q8k7$V8mXuDw=E4cTIs=Rc49AZ1#~vEPnC*
zjwsP=X!KyRy(ZbNo(jM;f{z5DPqt72_Gv`lUIo~v5q)13V4p_xqg4Q=5qy;vJS+h4
zG%{PhDlv`B-AC%`=i;r~X(VJR6t_<!j@xer&d;WifV1;_U;^}k8&be^$7pJZc!LMY
z888Db)X06}x5E!p-KzQ+ari7*qU?drvt*-DarS0bJbPDim#1%<eJqEpE6|*?cWKVk
zoW41<T-w?-dl%<G)ayOw@1kyB4%hL2Z@Z2m>KZD{Ic_~_58`}dD=>EsQNI9)A?BF3
zTH>W3L5Y7DRBVVz%2u0h3h{IdTT4OiHE_N>yy`0r%~#))`$*=pUL-d7S}xbbGmt7D
z7_zGd4w1!hb9gm8R)kr`HkIwKJ(-Z38{K$9UVf7aZpxoV0|(ob;-s^W;R^IaNQa#L
zcd2nH<kVMC<DJn_?A?`tN)=efKcpG${U)mtei@H7U#y6*{FEw{xL`+U0)zwPZQBe>
z$3u(U5TqRAx^+Z*Z&<018Ey_Fo8c1N^;pIXoL{V#f0J)zEw5m6<UNT}Ynh6txpik2
z8fGPQDc5So#}DE}Lh@PSqt1S#zzDP7a)6L%*F`=hjFbq*+APEaLX>lHA|gyTOWN*#
zT)Tr$>DCZ6Dr_A`MWZyUe7znVl&l&eQP-ifS(#cxM0kI=8=#c{HQTGEbfGuPq+{Ok
z8MofKcU90t8nDBsFb-$S*aL;{V!dCXrf4`IL(60$uly0AUguz9rhG5T&&=1yttF`R
zG1aWiK12Wy(-_5)I*JmK?jy3fv8D+3Zit>iiW`*MHHCkT1^2lnKzrlH#!}Bo8IFjT
zUC*~c9ThL)Youz>yE1yyIwjD<fIcx^)UI*oo|C&Lqwif_Lbu~@nU%AI{-FkaeIu#N
z+LGvFfF4szG;bE=MAumUb(3=iS%aD6m$b)|F=k~=Ekp>n7CBWs(@@Inx~znXp8(w}
z0V?Kb&?hi@kCG}j1$s9^_tBt-GkTYj=yws_+yeCGUlux*Inh8WbE%{<^GD-Yu}<!A
zt;038T3-V<Qq>mqz5DM(C3mka>U#I1U-N5=j^StPOMcUKIL4Ay)RAd%Xfu2~%B*<T
z5fLumNJ^|D8XBX#Fc718rD6S8xZ2Sk^;=O4d6Zjb_{gktmDfKb&5Edl(JO5s?Ud5F
zghU!3sENH=N>ub2dJJcP;=9B*nj_Tl&`+ir(q|hGeb^V32DN1Npv~}43vjXL5w%2G
z4&@QuMhuN^cTA>S7(zDZ8NUajq)E5^oEv|%h0-KZBzD^UCi?NrBbiuaBhr@MyXRqi
zva20M(vHpkySv|qvuMQ0Z_S7Qe+L$N*zK=r_HbUg^{f|-XLF<=nBmGTr65sM^F3cr
zTJ%SyI==gmB&z6?5#~inqHg22T=9F{qFS93l}UQS5Q*TiQ?sMip7{(|tn!JgGQx3g
z{AderucCu|#jW0z?em+;+9as)Fj=aRxWrDrdAKB}AzG5>F!|b^E~Qv-Q_<H2`8*~s
zZ6|-D4U?0<D9QiA9yv5_;YwcXX30X$3nmyJxTwx-UyF-m<HX$_CbgpWCfR<(Y_H_F
zXm#v{a)GqkUzb~}!zMGBoR%4qJb}q4xsvz0p`;{(yc?5uw3F+ChhgAO7D3JYTnYZZ
z?kolk;Br@mD#$Ox8PmL%B$bJ>bBo%DP%IAilTVV7JEfddsFS==IyJWk9nKgw&8(EG
zCqe@M>r2zf)k5>lMVgKZ|1hnds1|T^unhB+-Ay6kqVHfEWC)tDyHHQmjlV5bqZE>S
zqX%m+0~$DDJoXL3Z-<zbAL@yu_*@Oa>O`sX!#-{ZhJc{95n<R^5YRDslF*z9uA?z)
zB=9s}8U*u=BGB+mzBTxCr<qrNo}erOi{BVUQik;!8IoLG1S*igDR)Km$J5D*a$m%_
zs*Y5t^g<U2C^In7Dc>AyR_fLl&EkW>$*xs>rWxu^tA8Pyv<jKQTD|D%(CQUBJ=QWA
zbauYJXzIP;ON@e*8elwJProu7VBayawp8a!094;<9aK@rusZ|I%2y3UTxt6$u4@fM
z_4es+qcRbetwfhw9-}%Ve_uxM(PAbMCpl6gj+;rhncECXYZ<ej{r4ct6vsUo<$07D
zv;nHfO`Bm25xn=kLWbZ?o0tTt+td1PqOAAd#7y2$^opPLo0CA)k_5{>)Y#U(%hL}8
z#zqKnM`;L}F~M7l+z@z!;A0{<df6%Adc2g-#T~&H18@&75e(K4%w~d5+^Liaf_9CC
zF{g}^K(n7vH`Uqq^vvczHR;M_ALEDq6a;>|3~#H@gqVqK6}3j@E7ux}s^0PIVdYni
zMVopVm+1YRsEcTFXz)2TWr0r1lUWO+`T$D#uIKPyZ3MynF=jLoEp<&Anw29>#6(@0
z$@nrtikRNIOPZXA<_MCBZy~JXst>0SejMdL*bEOauOU_S@4kK?904G=aCU)p_TLr#
z-p!M9m;Uk>_Uf;iit5k#g|w3?Va5q@Qnlp^G?kO7DwWdLtn^657C<9LI=+V6Z)W-~
zijdOUz=Osd%!^c%J+uQa7q#u{BT}0xGUAtAbV}M0%aTGg4b3iTN*}Wl(p1!rZ>}Ne
z$poJ6REq?`I3g&z;FRFa1XJd_Da(o8$Oa^W`5J-^F;b;JwC%>O(r6IGHUmKe4MBS*
z2zDnS00c9L;L6W5s0=3u+V}#?AI$PcKX9Yc{$6I~mu8}7<Q7Ky@?Ao*HxKk{wHn?6
zUUV9^ff|6Zz24e0O$T?313)k%P1H&M?Yx5^BdQ*ec0~&+-GG~XALw@@O6vE0t{eT<
z^fW6^(nPIfg^|Xsa#X*4Y1j+#ab(y0go^hZrzdZU8bYDp8l_#jNT_%13(mAD96&RZ
zyiHfWFM}gjG*ewWPm!gQc<Xd5l`ZMQ-}~NbwAhpBqD|7op9t5{mF8EM3VW(~rfJ3c
zQTrUT(z3beq031!E32A|7+nht-KUz16kQ4yK)x+RgP=A)GRFe6VVIy_q~usVzq+!r
zl`!a{dLZ4jg-ETg;}=zAu@}m`*YsT`5UKTYq&tqFwh%3X#{b~L@Pi1+a9L-SVK(qu
zXNVcPX>ip~W{6?ETQ{Wsn#b0n*)46)NbtqA*3+GRJ@>KAPz{KvvArv}&*Nhqn4@{y
zu0vz{7A>;IL;T*YOPw!Yzt9T9$u-xymLkY<Ql^p2iBijYBTTBc{T);{Ee|=HS1r#M
zh(#7fVZ<QGGaFD!7VjDsN%7u%QFk;Hb!e_{{9}{{d*yUXKQE{8?d2w1j7Q|P;M&bb
zW+khYXjHYVt2U9WO}*LhCYQGoRdrXon3dhFM6-GeWrB!9?Tyu>+WTkOvxH0NJ`9w#
zT8r@dgBbM?4i`~h+9kEBfxk3b#Uor=a<rOO%dE_5EfP(?%4|TpRGFDFC+aw8Q3bE+
zP^ZC|Egy|Phf0lV%ynnTrC7PY1j9PLT^JfCFwyWi?ueRzC?^v{9<D@zO!TUvy7YCa
zvdf*!%3dN`DHHwdsvCEQNcG-_WlPrcG!RwI5_N)FxDxeXqHY$o-G%~ha+auVyd_ip
z?963o$6=Q;IJKg&%e7!B`0Nao$7dbQ%CjsH7c|O+hw)v;TmO!Vmj%4n+lWSWd|dHD
z87~txU$P+AJK!F!HX=4?^LH*C@K{x;#NoLr^IYJSH;H<d#&vO5_iHvoByAjN#-l?#
zaTQiQMdOh--pU(uN?h5qK7$qzGMu!188t9{0sd)^{Ig?#ZN54sgJzlSN-*s1WVneL
zj&?Al(=X|Ao0hhF3|A@s<r<z+(n`0hnOv86sIe)dq)xT9kg=&i`IPW|b3!owjZ;9-
zxc@1{rbOv>5xRkxCKi}Qy_$~#rM*rmgdii$_VIl?LasBWczcecV0GcBWy)i-2&me5
z8BK716^=Yf=IV-l1$&TH32!R`bo!xYrEyykR<k=Z&TuleNBk(3>tuXssWQ8*h_?7L
zet9RpCIEOA!B83eleZ5b0_Z;pjUwL=kj}n10+5$qhbq3ffZWNt?^4!v(h1VFKZZED
z>x8?ITI2g-6A-1u*34Mg7Bi3~Yz}PhfiPmWGaCJ9v5d{WM^do;W8d2|jEU1kqc!-)
z8Gmwd{B$jTu`uNbiCoS?S1sPV!ChCfp{o{Y4An%VD<RHVtQ}B^)TV_I8$k_yDl;U0
znP3D+2M0geDATm7L$uJ~cGbgPjU^dAOrzq<mY>E9bq<Eb8tPk4h8lj#jCR6Q_p1%m
zQF)!&bS70_4sB?6l%Gbk8Gem~E_qWa05mqLkInENJdl^|L>=AVE%CjEY!R9<qmG>Q
zaCiz!987#M6Y%XTeN$>M_8?07e(Hotm+p)7*{@9Fx?%7xE4Ammmh#^!^Rq>8i!ugj
z=QdIcHTTTE%st%}QufoLE9p{EQ)GQmehH%5J{y~n8JN+QBg&&}Q9S`E%g*z+#)VZR
z+rKAL;fk^C*4C^veM5wnPtve49#Mw8A%ZP+n6TvxH-vwhNgs-mK%X}`#B#BzQ<cky
z*{o>IxNZ@8n&O>y{<*T$=mU!z#>>DMwoJOzGBD|RQ90&p(Qux9SP5<q?WQpk4|hzO
zOYJa(l6G4;RuZG(QM0&qOKLi`i(<xlcZ`cnRBWtZJ(TV3MR;&KMBQi{`t*o4z`<+p
zC+&rQ=T`ARfYssU>W8lNkXLZFg*m3DvaQgreBL_5!ZYcj1bmTCh7pW!SCU4mq^be8
z5_#Ej^8+E0oDL!=<d5kbP6Q9o$#7yy7<N<*P2oN)=pd?Cl!cmB2uXKSoHcampjtyT
zf>90O6Pk{maK54xzPFTSWn^!POWVLHdqetmK8rLA-z(1WMe8^x$2rXLvOBA0f#We9
zMO%udp@~D6W*WZ92bEzRQQ-;9p$ke~q8<N{MI5NYi(;5VVH0OjFBcRms!5~R&lO}*
zYq?{)OtPiUTXeRHj9d6D(D0pGpagXi!6_DI@urU(Yh_3l;NVd-kvTNhaHw6Nj0Oiw
z9CJvT=B8{9GpTGSl}AwobGX^qS+)xYij}QZtkdY<`^mC>KGhA|MUw4n#P%c(Ad%JI
z*YKTjK&jRlnoVXFf4O7POtPS$WYOEq!KmR-qqt^^W1N~*XSN0I*cKvebWBHMOHqib
z*_B4l692GYIYpYCDlZFn+8v7pk_D{gQS>eTplt7II852kid3*S{d-tK*e8K;%(jU;
zwv8oQn*Q#O@z21_Mk8=-4d=-H%G54$1db2qB`u<<#!}33=v!{8;k#B?40aI_x&}?L
zw(SDfQQwrul%5A%#}p4Gu`AY38?a))nP&>urjgFnb;DLU_0LjA1)jv@sE}FJ>_MOQ
zoFs2H=$A@MJ=#Y|MWb?TE^NiZnSgQBf3OpgCU+BL@FXpm{G7c=ocG98j&~K2md4=0
z8N6~IQQcWM6+=@YeJG0NLBDrv%0{98_CwcEXnO-^We(X_tST;6cNV38Ia$N?-!5*q
zQW)goFaeM1Cj5tY(XjI^&Tg`Xoe#5n=&qBU%%C<$4d&=<YI9yifAZAxqP|nvO?#E!
zyNTeiHNH}>3GSN6@C<y2s=Ej-zeq#aX0Ot*yQtnN-=~8-I4u*#jkTH0N27`t52bsG
ziG_E$5MuYX>lDN~RnxHkVUKbO;#!<4D|PzX7Ey9^Tp*dDRF1;!<vFpy=q%jWJxa|U
z=vE_{(NuSZOO}kNXWBLD$&C7G82RrhR;6<zoK;$Zx%YC%{XAlZ$8zLIXJ>Dd+X|uH
zlD)iDCUw_ta-ZQ;%Fc`Z?pUz5N6f!|O<Lgus$DZj(9B{pOlXdagmMta|5v^>Y^sOC
za~ywinptU^BdQs8H{!nc+FtZMyRWFs$idd}l@AccSe+xH-rQ!T^2~|yfJM=}FH9g|
zQ)#b!VbtGJ)UO7xK_5cr-xr1WA*A>2O(1Lr;>$}RbZ^;Mc*XmosJGb+m5@Ghzr6Fg
zaX4;<?kPs;<{|d_X;0CzR-iw1!MmBcS8RsWSPkN%@HqHmGi<4B_DJ#an;Y*-MnIJ0
z!^YTD?<K-5ujixJNyiWonhF#hr6B|NFwK!lV$`UK_^q=XGO%LI91ou&7srV@RbhP_
zlEjJ0lty9mn}g-KEEvwh<2r|m=roA6l|#3I3Qfoyc`El@Wpgi4$^R)ZNGuj>_R9i%
zj_pt`^b+Zz%SusQEmW^x&|e?NTdMffRljD4+4mOJgT{tqs5+eAf`^kk(%yRC_fQdI
zdW#^hN;{Mp{Y6#fi{7G2@CzSiS3%B^`j5b_ZSFOsfM8rb-&=(1N>?!}fA<y<L3^7?
zwJENoh6uy)v#{1YrEVYbdb4COf(hWTeGN%id}BP$T`twk-59ma#R6r>|Ksu@ItrU!
z-KHGqBih8Q_a<#R5=_4b<Cj!rJdK*DbW+h~SPRAK^c8_#hIf^$z9QJOq0)DN2v%nF
z6;+e+eG=8<*A-A|84g2J(@CxiB?B<-Jy>OYDg~#2!NP0DR<?*&KUhTQTrBd`uEs!M
zC-nn%wu(I%*bN)FVjKRBV5L1$aPNhj<Cn<Js8%MM+2`KZEbt5o{NBq&;9$GJrA@GC
zB7t*M?0WqnaF{E0vK_l#69|-k$!U3t(p6wJ$)a|!k1O?=F{&xfp#7idFOs}I`-(O5
z9{^doo-UeAvSYVL$nu+VsM4bQ|Ij|KtE?22#Z<5euI|dBg`LF%gc3Il5DEU~B<eA0
zr{^l(or<Gy1B9{7q%G9d<o*VY{mwp^wn*Ctje|W%Pkj~GLbe`?htiOu#zSjD)`&Mn
zy4R!4%FMxN`6u5Lh7f!tS{}uk6Gd$W&E&9+$o191MF|@$0!q(9(Ds<FoYE8zO5#8q
zeqE>M&;@x92}t82<-)1_^7a{O$;ZY!R5sRSh6hk)QY(<wBAK)n`3Ess3SW|r&dnAx
zm=|rOjso>p(0>$IZ7}D)q(^1$VBC;jI8bVzFOO3>wEz5-)P6UFN$qt58km*jLBgop
zR~wlk?=%h2eTE-%2ceShY+^h7Fi05ijr3JIPvyZN5$F5qOUWb7!J`-Ue;N%It-L}d
zMI9jj>gB0yA1va1fBa7(Z^Asx0zWe1dix=wVN}0a7(?^*Phu%}<+B_AXuzV9?5AVD
zHp8L{W~J{C#EE}LpPD{IgeDxE4(D)!&2R$Uh7bDkID@kw`=aDH^C@9;!ngiFa(svg
z)6K<?dqc$Qx(D%QrO8lHSGN;CsGvcDmXBCpKHON`7hEw^)JWVqpGN(CQH$l6XIwmz
zhS1>@tXLQ|A22y1{9Kyq$mh}w44W^8;+)k7uxHRPq}2{uuQV7Yk|It2NCQNIoT_&;
zwYoBx<<(ZFPc|#>4TD-~WpIvW7%HMq4IDHYCZfG&tW&BDN2+Mw7m~xE5inuT;Rv{e
z*TwCQ!yzmU#L95dUFTccto%7#Sn7TS%V7GDH)ADu^Yj%CWoPb-dV+r*X&xTq;%Gu0
zAZNHrsJYKai1>0-5dx78?652x<s5<G<nuL(-zc=`3L|AZdh;c>v=!V7ru`*#+BXb3
zrH@2{O0z_>(siUrYxsUFEP|d|!JIdM7S5Q;hSVn`VG_p<2l_E)wK?G8F;?y%&A`vX
z4<~sj2M;d`(51$rx<-oXULSrz;%lM*wfoOS@}TEZ^7ljSl55n#fxJ<oUbk8Bkc)0$
z9Gxe-TWZo&*}$em$Oe{!e^deC`zhLKGeni8;32mnQU_Nyyo(pqlB7z*C!!@yv>C?2
zME{NwA-*jM@CH(R0Eiqdn(B{4tHmm8UyjueSwSE)sV84h`0-bx%TCvd(Wu=EsNIXB
z#XVhPFSGLP7||tMc}fLZ81+O-*U!VeLv3U+bi$=PwahzH-V$$m)<hP7JfUd!Fwii8
zfdOgBKqtM;@ZT$w^4;5Fo!8n~%J{J&zU`D*9@2^Fh?O=Kj;XduaW=!Z7`&wOu^P+{
zd?GE=trgYaoTxbBPvfczPseKN(O40u^T&^%aU#Zh#6&dv7UM+osuNzBkSH|(&AZ8f
zs6OL-sk-~v41dG-`*fVxsQc=rNqK#|hzjZc8ZBdvq+^g{$D^|>h5o&_!3rr0wc>yH
zl*Mv}APQLchzf|{8b*s9o!F6yvl+fdQ@K4}#MGTxoIueKwCV03=!=$V&PzS?pGirb
zfJNcaY8YQ8h}J&&sg=S!l}!`SwLAiGeeMLLio7HJP+m){d?=gT&2Fk5G(yLz{dZst
z=KG1FenzyDU{2I>s!N!zA;t!?jen=1D6z~b?+rJc9z<iVn}`kNt<rU5(Pth=(L1}k
zA@~>s-jhJkT|+RA3G&<#GzLM>Ng_VLTSE}W1fO+5fBJNi@Yh|9GAp|#i3!nj?n~J{
zWTFqZPkX~u3*Q2$9Vd$hx+TH54rj8crkjW#n<tB!u<7++Pvy#F5t{Usp^e9VUv$bi
zjPv{OfMEW^(Xww=^T*{42wtMSEtGq0Hp6#lz_q4`c-`r$%(LM}tgxx&W}~GP2Ecit
z9`<+{^{`)R%50oD;6OZ@6-~r)#Idy4G6lK37o@-(d6LBpsmSGB4G`8gM}LXMzl8A;
z!5GUL#gxIdl@+Fnh<b->L+t-P%0k~popC@eXUE3jsyCbAt?KHDic7=fiHf*g!)TWH
ztMJ@X(sfS_?P%cmw5qS2YAjP(-cYHANU9E?a<hdo0KpRHCVGiPXrC&uGRN=#D-{jv
z>5q=I?_ALeQ?tR)uca)eBM+JaauBG@p9bUoRhepwjW=9!NIe1&jCbdPG~ObKU~G+d
z5Yh^=r18RT*7|>qrzB1nQAzVWc;6V;kbpYj$4!*0oly4$tcKwO`8Wfj!g2m+K{TR0
z`Jw9rJe9fA#mKNF3N-=hf>adrs?B%M$8-OI0)O>DE3RY_NfG%z0i8Id)PdI1fp(G5
z23T-By->P{Ir2Qa4)4KZGhWK!hPrvUnvQ-PW5rnu*0%-nt>I2ZGR)Yha5UHuv+|!s
z#H0@eFIqffe$Ani>p65+n{nY^1mzsnQMaXp_3k9pgM|Jw5dPW568bnLBw$S|!`}8Y
z2xW%C+?q28?+??SL74uxiLA1UfR1BQLjcsCK~V4(-LVo$(H?U;XnAJh6M1ck9^Nb7
zW6!K6=+Vs7LlBE``>a-h&V(zM!G!zjFR8$g^-=Z@z5-apz-EN0w{!i8fngd<-1vWh
zp{G$wrvmF4s3&?_R7kBp0Z?12!yrManpP-Qs)v74p=3YekF@?d*tGzC9kS#XADU`3
z2($~U!NB(k)uBNZ2EIo?axA1;w&&6SBMC^WI|;nUzytz1Om!YWZ2@#cEwTjD{fd<!
zp?C?hi<Mv{s>Ern=`8FZ0Ug4IFz_k?9lCa8;7tNjQL(p)+G@toFA3@>K}`U)%67$D
zSo_EF#dMwZl&#IfvT`kBX;sS?gIo=M73xcM@j==BXmV(<AK6s^Xaj*}7vRJU@=)@P
zzXBVQI%y=?45g(Qygg35sFWali+R-{UetI2>J5+uXmbdSIs{;5Mte#ie+D&TP&83i
zV^9o(5($JD5D``;5G$1eFqFEk=i(D*oSXYY?LMW5hzts%D}R<j@8O-Rv?pz<gjB&x
zxCS<e&-80~(EcUkb*SX|%8EH6&L=<mkBXkk={X{@;(2(gn27MnZN9{LzLM?NH>lNY
z%ujO*#+AdXIQuJ%H)TjGx$8v9L)eRfjtD=|z=RPsI&}dJM+0cvIP}LikU_l}ymTQ!
zW@XA;5fZei914SRjS>Lxwc!97cxHeHuJf(bJ;Hkn6jsj96}`i*`9i5<bL6pNI5;56
zz=<){<!Lfs>F|z-!CvY0wmb;;f&FV;m80L*#=MgQZvYOG>Ph?_fa@vzx(Db6`QgVq
zqD|$pBtXk_%!f+oy9f|Zxgyzo+{g`^G&`Fe<>A|v>t0<~@WiCNTdw<^@_uFEYLKS*
z+Iu<N;5$zwRL+4j>LTNCzVh8XQaoXZDG+uVjyrtvjoU6uiL)EJNaVohBm*m6>2W#m
z%Dsw}mpS(jo8cUmbFFhllvhN)G9p(*8;Tkbwc&6XHgH3mA-poOd0^GR940N?n6F)k
zB9r@Cu1KtrJpheF8Wt6r79mTp7OhZ?-T6<z>Q}#}KPsltdm=Wz*84Qx$Q6*W^(Coz
z+m7_F*zR;WMC|h36A9@*<v9p4qRd2!3C!o!1BN2XYW(F_$tJa#8#Y!H;>CNSM*L7G
z8{=Fi7<Sf8yu1wv+U9}4Uqg_@1a(r~NO)e!tgIx0L+?2hHU9RCRO!CS4Z&w1c$Oz(
z;>TzR-e-be-4VP2f>!T~XdmvOEB17+-D$iJH4UF*pCM)hlTavULu+o!;naV~MoU!y
zPMgS+`#$TaBLF)M744Hi^^KGDvQgj$v5lDEA4jbY)CIkUB>DYI;)a%yEvB&9d)jKZ
zPxScO7e1bM@VXAXUY>y#c~vT+E*krw{p8h4lB4wL`zE_%;F{s$jnI+SJycfYi;R%b
z_e>sHo>$xEPOl&jtY~ghn!n=%F~?JPt`NQDLy=JtCgDUs85FpW;o<U!V!!S!Jr3Z^
z7rS(}J0_*;0?|`9${XJmd9Wr_Iln-R@gBc$iA`zqk%+OF@hdC0sOTQn<MO(Y^j+}s
zpgM-3%-nm0weY@ZCAM7T03hQPL#W5+9+n4wWC;G1%`ig8Hu`3ctBr8u*USgmh-j#n
zEMslxbG!$4ltiRWDvv)B?|Y$dPWxEo#BaqKSZ&zGGvCXWbN6*_Ir4U`aCH>=xGYvw
z3q@Rf9}U42COGAeAPodv7K%{IysIW$s5MXCyfgC%Db@q|ulh!>vOM<Cpp#^yFVY**
zA7g-rGiAec;5ZFyPv&ucxUnk8?CyIvnkn@E;U6cS(QKT)3o&(IAW!UZ0t__U;&P4=
zQ@G}1ao<W(pSv%Kr{?Py*6Tb=r-A+fS}9dbzR!~sZsZjlpIa~tkY8#rM<L^?Id)3a
z>>>Lq3r<yf7v-%_gfSuz%UU{ug}$*+hRx&#Y3bi+cK4al9V687PefGZ3ReKg+ZM%J
z_J#}e!uAQ`3g>?_DK!^~c3#yj%9KSSxN+!NSyyw_<+7}+K5AXvK;-Rci!wg<r(<Q=
zM}9LNS;JTnK-QV*%DF`%Eqc`%NuMg|7s|J^f}Mz#sB-Ctz?o4Ik-F1Zc6L`pt$^{D
zO&+-O+G|{Q^*i)^z|eELA`}r3`Ruf07~PH=PanA+MrEtqc9t?L*MO({_mWBRUM%W)
z4Vb1hUW`er7ZWZ~3DaoqtDsU<2i4fcB08Y|B~^4^RWv4PpGQ-bEsG)ghD?Fhw{|u|
z#E6`tSNoWir(mMH^{Yt<ULq2_I!;yEECFFA6LwSyi|bq#g!xMluzWg2*+BSrzmsJw
zXzRX=>(JpJEfE26XAw?8DDQpfpzie0b>xL<uTvFZXAV_?W4Z{^BrFwy#sGkep2|%Q
zeph%KiOsnMXxmdeqKVtnxim(Pnxafz3WWk$p-pD@3jM0XIU(SA?Vqe%TPji`7oC&^
z*x~ISzbo*YEfd4M{+Og}Tn7GkPDuQ%Kk{r<+(2s)sC&Fjr2Aq?>v6xG%}@`WzR7aY
z#P^N~fMlED5eD>`%SCMIBjiuy9#+y7;UC=l1$l~B3pY=89lA2$OkG<p!XnN`!GL=y
zg5U`+E`Kj=FcfBjr|dR65nBltqN-P<Nl6hR%J086kX8d*W)OlL1!ewJQ6=FQ04c;U
zCW`*s3X3LDsNqM<EH=Yw{B@2pw5H!8L@oaVZMc_al1mULWu5=Yq*%6yAjQ`zD(miC
zF)0yN5#M<RMhH4*;yrE%8secpX#nA=u>J%Ze&A$~r-|<FgB$H6fZT;dd55<C<vF&e
z+|aOx%bwXx%4b#)UA~is+lleYd8??7k0kwYk=dky&8DNWS}MkKHM+2Q3j-(}jmsT|
z!&1t*uGl2F^xUMFKNT_Mzow-N?Cv!YcE^W9J{2wf|IQ>PIpocCBsUel?Smgo%B4?5
zTG--mrJQdhis~dyRJ&$Rj0%lc;G9lAs(984(IWhjyy;tCt|<-6z)s)Q07J2g{xzbU
zw^xWhVIvu<zB``DKpL=8M1)NE0g7^7#B5x*;59aqqNWHr*T)X^%9Wyu*P2$!&XvNf
zd-1(VDfO9XuRHbBr1bbqq=pRmo`#B7*cnE0uE&9JG@VRcN)!Ud7|^x>H4z_8Rr9^E
zj{#kc%MZzNdbMJEVle=ZT~)mAzb2*rDr8<N=S<4rRiZ^$8ODxRv8DCPsMx3fF)1fk
ziE&|L4@#CPE#0te1f*W8aS)^5S(74Gi>A5-p7;{RY7yW&s0CUw^0G&HniqX8s`{7x
zoolT7TiTwYBz`XHM|_jPtrbJz!l=P0rfjg8r$LeL^K%<a9q)cFqAO>g0RVH#U<^T&
zBy7Tq19+heJY!Psel9-riW#L${6eJqzS=K!UYw2)P{9|XN|^$z;0GeVO{w^Ms{mcn
zW0Ugy3-MOaa6}z3yyeL5DR(NmQvdudO_{j{$3_O8GAT>ehy>q7X<Qg9n#%X|<{kW)
z?>(@pKH?D<Ys{!cHr&FuRs?vr&V*j^YjI9xFO1P~tr+Qba)feZtq2c0yHD!X6MAvS
z)U1vcJ~Ju0b)uH;^huLacb!NJ>K7=rGds1TBfy0}HdXT0iFW?8no>WyTDWus4F_}n
zBR4S(Yq)j7;N7tmba-t&mI`mCv2D?5v6(InJM%c%Q680^8Z}rwC%yUvTHShK(hbC1
zv2MKx>kySeLw1#!nVu)<>%}xE$ThLg-k~HIJH0e8V1)7c6^n2JWTORc-y@5-Y%>N1
zzOBH1=4mS0b?^oe67VhL7s=MFVVXTud3}Qj4sFBq0Y^&ER|Ne#8$_hnpF@=Og!*W=
z6ji@6{<(_U{)b7qL8yy|D5W-vq#9Eh^_`|AP+MRv4;RB5os|47<@b(R{<<%VOv<E<
zBDTVuBCg(_hAzVAw_)8a8%3b^kruG-DZH=!9~Lv@4asqKw6yO2Z`rzOG(m1bg{cO<
zaug%(CK$Nu-zH_$CK1$OYPxn#ge|bIO_30ve+Ov{j85TG71O9XEE}Kgl%>A3(P1FF
zkFgKS;7gm3sNo4wiMO!R;Rjbg@Jsj!T?Q$wzZ6NKO_+Gq?h?daApYb_5z+Y0z+%FE
zkPL1Yer<;oJ}$*!N4xMf=u=O=6yc5EFHXM!Q5!q`J52wmNeTM4pl`ETgnQK;s0`nX
z+O5T?WBp2?K7C|TRs*&1#W#zo`WNCec2PfUm#Qu*DQXGmUu_n3D*ttxYq#|vs@)l=
zeh(#Wi>TqB0wPDXa$<1iAvt~4(sje2@Z}a*`4vW;@3$cJyXg&{G|Ql-J{zF?w?zae
zFPHaV>NhqfC5o-e`#v;z+&2UH$#o}T#{o*4uaG_VIurJCM_3tzNe`*(W@gTPKCY*{
zcX^S9$v^$M{EocLARHzogM_1J{<&2e<lr|E&hIkF3BsP2yzPMr7XjVE_E61RCgtT<
zBCvdbhWV8KO7*X0YUZ48nJdN=V{hhaZRDn)Q4dVY+h2>i!IqnB=(7W~gFmmt3&7L+
zaw>Y%-LDa;_<-sQQ)E|~3(jGrw;99%?opVZRy%u?+;!elK(Dq%ZQ&_lCb8+X70V1u
zfk~OMRn$p3Hjx+i_$(o&!f;eEaUsT%L9fHu)68YI2&`@13BPTth_4gckXpb1G8_`D
z(2FJZs{Jf(2H4oUx6SYjO{4KPtS{1Fw%*%Bx-ROtNm;c`B!+ZqT&#<arrMx}vbm4)
zc$-K{`*@42mFxx%`*FNYorXJM07`mT)CN0ZSOP&C<c&}=2+#LEP5UT)wu_d&<(bRc
zx|r~`Y)8*Ojh=sUy9o8#-dpLt1J|{@+AhL;7j2fpo<Nvl-5~<PI~AHdzJV<~iYPag
zxI;k)_hyo|o^Lpl)v%N4uHH2%yLO<n9_hv0AMb#xocpEZ9_~QP1X{bDB1E?v-sZ@i
zqNP_+Pi6Z~96!zXDcVJCXin5|Dc5*#lcbGS%@9tDE;74nhS>;3RM~|AePB<e;V#iK
zx<2D~tWRWW4S|H}RV8_L8(!!xG==V1ah~2K5_DdB(W-ZeCSC(_l*YS7{je4rrO>NJ
z`loi%aFx6a$UodI5+hUhPzym5lZx_?UO4!<%_i41!;ENg*LMqlug`lZAMT-Ciao+F
za^VKa`G(3_7DuC7XEc;_AUBwb5eN>*ElfSgO}MWvovz`ruqXkw@(Un1(~zOoyKDhI
zeo|8N$Q$dWkW>Fd$m*LW<>?-gR6g(`4>M>zKEt~!b@z&xrahRpW<4&tLqW<(3P*1>
zBPWRzrrabsiP3zG`3-yPLw1>zMSDex*U4^N;`@71;@#_{GJT6PRLwc%hDiz8CxYTW
zMa&H)J_6qAin0Jd3oF#(9!2dMAA5xl(sQ2(48I!>Bh)7&px3|<SVGATz=n8DRbb;j
z5g&PZtyJJVx&T$CqeQ9#h=eFF_Cf1GU6lskh@=K4#_w8(@i7v*bUZ!QMMd_Yx1-nE
zx+tH5IP&HiDJ=DW5PyEnr2O%Xi1V7&MG4t2vLjnFzUTkIe+~E_?8nx69JJiLA1RHW
z)KE_B$L(2f)qnx6N~27;OM@t%xF(YY;7`#J`6`EBIa|^ufN6k|EvYu~pe2OOknBL@
z3K&gDvI6j(V~_iNk&@~nMHzAc*P)!p4#WKcHp6e|g&!RdjdUyV<IDjp$WnebDfbUx
zPa*VYQtoQuh%T-pJZ==C`v+G{QJNNr$nbX($!;>tl!Uk@ZEI)(lvv62dDNsz0%Aw_
zG9~(*EqWXxH7@I0+Ebt1%uC&l_lJiqFF3Ts%I$b#PONOEg=0IDQ``&POG}+5uSRs;
z(f<r%lVst`ED{Q1n1zRAaqpIv1xxpwz{vphJyhwR#z^V4rmCb1JCXG1E~Ml>IuZiD
z!xC8vt;dux6;;X_lCm-=Ddy%<)`51Kv(ZwTWn(ledZZ&s`x3p@wXE_ppqe9*+dQ?g
zf`Rk%N+U4Szn04k<#RCsTUxZKX5X)>y~AZg&?mLF+z|^qXQ5H$y1Gk>PsJkiIeRN_
zjQJcTE|{|%T#B}%w)1^D;wx2q!Zq;k8Qx++tjC@T8u)I8k0m~3HSm=T&j;Lo52q9z
zoy#xk5&>_BGkgrgn-Sbs!>F4EpEpk#Kb_%egwOk@46niPvG_ohS^x{bsE8MiOn3X<
zd0ISK)p>#7DOlOLM|))(8N)c5fNW~)#-0FByYYGvZ?W^Z=Zx0O2nI)dt!_SA4ii1?
zV#<Aj_dw65ToGf=H=M2Ms)4sg7<MajNCoF@g}<?|FI8b|aR}S~l@#Vgv@&8#AmX~l
z>yBN1!~2YxZybk@YN-}F20?$KNuaEoVG#R4TiPsT=x+p7cc}qA&d?ZA6)PSp7ocA=
z^iRU2yHOare5=K!1XWnEGpE^H-1bm{XIoTr9VL2h0mQW@bFEKMb@Lq1)(m|D<Jr?H
z08JvO(+2xMgPO6df~=yAq>=O8FZ`|$ukP1ExepU3RT*$9MCEC)_b~Ras?zpbkPYdq
zw398>CPaR9O4Ar9iNO$PFWvwW<SgC{S3w~xsFEs3H6wDXHmlb8Y=BFxr4xC+F@cym
ztrPFU)MC8ITK%SKMSJXWzhaK$>Ku&hn;+PIz-m^nms-e!$7g?scb=~&E4jU=v;Dth
zFPDuEjEmgMEcu4aIM+r#lk`<vjxBmRnj{J#fjlIjn+*X_+s!7{ke2QKoyM|c*n?lH
zmiZnsoV~Or$Oq0xf#Nci=;OlR_1W7>%5h}$%!_l(Y{|6Rah=)Z-2-Y~&BRz&rCYiP
zu%bet^aKK`mbXRcGVpWgYVR&M;m*Ky1Ptt;+CI8BL&p--k<`%!Ky9JBfjgR0las{?
z{n;iew0+lylRD1CxT-rF>Pvf|IbT6VL)orU1!w@!cLZ`KbzA~ABz<$jDamGtm100R
zop@0xLHH5#dS<r<Ko)=~sbdzws0INW&S<*{q$YKAW6*s9sYxBJ7_@}=Q>Or7GJ#}#
z#rPL6q0|ty_{14^7;aQ6{2=jBlR92~iBX1=I%K1pdtz+W*)KfD)r3}?VHkVYwnd*u
zdm$hZJ6d1?fLgns1qpTI<4$YH4ihM4J39<Dml@4Gb|Lbjw0_b?A2JqfF@5%?f0|s9
zZs3o*;1=YBdr!nGrOJ1R9}d54Qa)aglc2k`5zFuIL}uk~M@cssUy}RQJ_T)*GvDEx
zcPE!fH+J_+goEr0pfuHC{_qDx1Nwf}#$V@yfMnz;QLFM%3T<imB(zcbo)W<gpY-EJ
zb|2{YQ)%8@91LrOG5;3s_}}_o<sZ}igvn!zCwk0iN^$8aKVps<?Bj2<?8zLvjsf@J
zx}2*1Re?)>=Fm1;KU2wGkrP~R2(?r!6!=P=Fw`p4d0Pd>(fU7;YKE5egXMDm9765~
z#Nv2ezb{P6re8#0jn*`R!A4oRw}4^K^T;~F<wgLMRv-C3TQZd^r(wT6inQP4|JZ&F
zDco)kcUsO-H08o9gYNk;lhSu(PQBm*C<ZC-m!(yn!yq%xh|r+Y(Od!!R;VSY2%s`P
zWJyHen-?hodv(-&xfUBPH)TW=-abBq(0ggD9iD_NX`p+!)}#zQD_%F`9AdruklqN^
z_#AG929+PWBq;RsCsOl$FC2kDPQ|tv79y-AvvkTHH7TLzM1tYu!D4KZh)r0vB|*kN
zdvV2QgZV`rS3Dv&#_G(zbxHR3PBZ(!K4?s7+dVU}?3zJUCA+52p$w&O=#l_agep_6
zyh!zVExBrNaBcwQUicit@<*)?<3|f+Y1)?**G(0tJ9`A7(6A*TW#)axyZFkhy7T-o
zhg>UgG&3IrgYJ9X2iwCOAD{bttY22%G!L1sfI9}M9iaZUx1@L>_W0}*n{!vc&0*@=
za&EgHL48(#7yo!}qxiCBSO4r28r@tcH{R5jSI;LAx#oKptMKd`ZvOp(>cnUzpncwr
zzQe%MkpSAK_~`E$*l)ITg11HQW8esj3v>-bml0D$A5aiXm>)5)HUS+I$}|SnC!pSr
zIaq^P+YamiAcnw$$nuj`nF<mNfvXS7A<*JTvNUX1Wp_ow9BToHuL64Kz$m9)bVE*k
zz*Q<R@IR83WZsUNW4=CG%5ZbhO7F+8n%3eLcXhbl$?$A<$?!aK?A-b%e#IG*(OlDX
zR->9r7Jw5mJX&~^$i!H<fZDQLBENN^n7T4+J2TJnH=LWj_K8W!{z=r<)y7yh^CwZ+
z(r|+br#;H~&CR7MK*kK(H}w<BZhDYL`XP8?&aH=Ax1|!43I<R^y#6MgU#F=X^fc5>
zvIR&I^l<1zcWZPd^gd{O+vm$(cO#nqsfXGc)>5aB$rz|{$0>C1C|ZR-ps9kYX(F|u
zj47PHOjDYj7oh=(Qmh%hI`=vWfLQ&5R{_ehgA;=+RS1H)MBm^uQjRXN&No(K$+KJ}
zOTqMIwDZ_sf@tb)xx>m~V~3PLwNF%U@YQ}0@?RA3R5c!TE6@}XSe=mP{xG(FW`2r)
zrsDgv@b!I85oq)_ASw|*i)!Ul53o_gLH<TFrR~om;`M52Y`uo6_0sU}*OzQP6iKyS
zHd&8`NdFI|^?r<E>xI+YVIPApVaC|^vj~Z^yJFdS&1{C&hzcZ~$ede{>G%4<Zmw|?
z=>zN!g?>>N-~%A8$UeYND@@Al3nKINEQC{B=I$+W`w;ULwFA_yPaPlDpOo8^FO^&O
zyBo*Aa@6h^Jo^Sal@~>=fjf2=V;)+Z`EqXubDwMU;XQ6cK1cp#1EGeEek?TEozR~!
zTS#vtrp-5Qy@lDk9mDuqbPe_v$^w@L?Cwpq6E1rTn}fO5UA%?eD$t#`@MInK?M{nY
zUP}>AUXc^<=EWvlrefYgqg`wahqtgIh4Hd!>VkEB!q6h^ooIcYwDiy?Zd`~_m~YsH
zxP#C&TnJ-T6padGOVJjHJ&5_gir_(C{Yug5dQn+3k5WXRc4*7MmpZv83j>(3Lof|D
zcfbLcTm$?g!1hdFf>6#x>!lEZ)eC)CPTdrf%bmQYnR(;E%V%;`w6gnOcMrDoRt<n&
zV0hym6#yL@w}-*=Ar3MZzvTUBd#UTl;X0PTz*rRw-Hxv9C>E(5uE}gP^mEc=J&4tV
zR?V7>B*ylv$!Wr#HHn@RefKOq%|Oq__Rb}dRnaFX&SQT~JeqS4A+EU_8#tFmqTe2A
z4|E53euc(9%B0KUE!~i1Cgss(5&OoV#*S^m;)DDEXsR9LJ0Wz3<VCqlllwF)7g>%c
zP?-m4D3W(8+6;ZMk2wCCXlQvDAZNtbT~rsy;+D=v((}R?Bu=Kyc{m9fBl?q!6Ku!f
z`x)T@c@)}kfkfK#Z__BVM8Ashd>wd%vWKJ=UH~4#yT!Cv_noInseN4}TN*RzzMZT_
zqFs%*nSTYz-=C2-+mSSSm>92&#Cz;7%k-%O&#6assYg$^T3Ty7^THzI2J{&E4wGi9
zq?vX-4qz7m<&+sT`hJYm!j7cTLt#8msYesWOLpKn^%(V^V!46pz0_)n^5+d<HT+x!
zO)1|HyaNMCA}nSz%-C*H*4z|*{2GK&CpFV)$E7FHC+AP-7N9GQx3tUd{SdJ<nK$75
zBmI(Vrrq02%Jf^Jx-P!u5@q!*5vB9SkMC|FZ}3{i66G=IqW$;52I!<7`>BF#hEjOG
z&->{r<WF?__}ikU?&?-m*0%^nv8)aBi)7VWK;bD23fJo)2c;8z?Kr(tdPn&skM!K<
zNS?*LYB-v&52}ogd-k@NTlpgPF%M9<RbD`bZ-T<rA9P0~dmpU?6zd%%3E7%2*?I1c
zXzQu7VZSH5P=r;aP#Vc;Syy#`mFz;?>pH$7vyD*l3dPTrzrzrv<=y|VNf}#&Q@;Bu
z#Cc@(FZaIL^SbT2Jl3_JRKN{>J2Bf8iJx>S&6X%1-xI?vMp{fm(%d?#qz<|N&b3Vp
z%)P31o{TfdT03;`UYN%ZxfgpJ{@RQFIy>O};`mkU_^%GR#don<rZWA$sF;-hp~-_j
z_)E!qbSNALy`qB<E5M<OplP%_EZwJsfqUt-(Y6_>M)y(Ae=kBZ(tVNOeaa7Z349=0
zd#BQ`{tra;uza6e_jtmqzz5rMuaN815Vf=BcO2CC{DFwKJe?w^gu0-TtMc?+t6(Sf
zklIc(F*>t=<QsXwBej!1VH<24so!F>w;7HgOo!>U7NOafOF8u2_#8SNV%(I^^8$Ql
z<2)91N%DXm<b<><ql#+lDvIu*qxmEpM>{<Oq|jAPq1g~>_g1Ls^~ojI>ME7o`Vhy6
z1NHcI{Gn(Wxnr^{-p@bqNeh=0gehpsyS$Xd$0AT^{YX^M-9}<r_eUZT$4ssjvgHz?
zcRce5C`GJ_rB^)p+NA7!B(gyAYaUOuM6!L76nlJ@#-*`mK1>El!egYBc4MSX-fs9-
zLkV|zvTmy%i^#~A6D7wf?vM{5PPofkA}@L(B5SW?+|KTB2NEs~0lB|ow(Ha5Fb@Ab
z5h;f3W#|R@*;pdu<bgRC#|xgnV^UT=5v{^5PmrRMs<57MRBzd;=e=?Z5($47wJi5G
zQ@8+EFOEgd;6qq8{Tn&j&>v0&BX44E!Pqldxkv7oO5evX9AS^8bE&B%n{)f4vAtaZ
zpTU>`N@tA5+21H$rRhR59~8pzFH33rNGbJ2#qa%HSiIU_RZ{*CZG2P5OXa^q-j=f9
z4^gF>4c*<oRtSa?nYKf;FS!<jb>Vkcl*50BZnz`h^;=Z`bE4Kl3DoDJagxhVl~gXe
zu3sYC;He1kin*c;eky8tA1wpPi=T?CzUHwKw^c<uZuw2f?E6zRtlVT4+1R+SG&zH~
z{pXU!q}=)wU+5V{#IHRQgTvatEr|mv&_BwdgRSkUt^o+K&3`6hb<<Xvls(TxZLf}Z
zlzY!a58vtXt}?yO4<fUl<MM>G4H#peiyBQ=BLGoU3X?JItrwu)<wh-*)@q_y&J0os
z3Dl+N)i#;xp}tC=fqmEKA}~5e#W@F`UA`m46)>I6;7hOae7u3``<G~<d$iJ|Wc`K9
zCwAk<^uI({Wo0EWFuLB2boevMmcNkK_LUFHeCjU|g0IW}0forg1#In^<vAk??knHG
zEE~|b(=Z2pRUUWl)czY^m&^aa<bn29jw}?u+XF7YjG*B%q^+o7imLa(EI;;dF$sOM
z?Pc!HSb7+bkCG;SU(Y6%&AFj;4{U~fM6;^CKpw{*pPH1GFGP>9>Wux3D>gM=o1t(G
zLV7PmYQ2V^av|r1Qz7TzrHA?j`TYnqp!l?3nY@I4($v8&G_9hNTk5DSP{0h!!G<BA
zE9~}x%|=r|INcQW9FVNMogNS<56(PTtgf}T!Q?;AS(>S<ffd55e?)xv(h;&;x!-HX
z9D97VHv${%E1VZ5W!BuKwRDS?n3M(oiui^F^syavg|zw-+lf|4kB3WsmEG~%_PNS0
zrY3w}H}TZ|OB^etc^FxEg>-K@o2hX%?Sg_=NcBD05H2gEG!^J>g|uao8c(e|*`)mT
zAEFXLuub`wu*7@Aq~>kZd~ugZX}i_XMn+1H!quK>U2LpMBOhAm)ex;#Tu0|}%t6sl
zm(zL%^BE@NK}I@KZY%%@COYatv!;Fz{>e|ISv~=)*+)u#B8_emC`29F8%N1l-apI0
zkyk47Y_Y_34*t1~<&C1qZn2dLEj&K`;5FyUqr%^xSFxb+*`jA-SHTwjCi<av3<U=|
zqoa*&t#_(0X`T#46*yEt_tKv6zlvpfaTSV%qPFccC1@lfm{ts-BO)hGjgXE}@MiPS
zNZWc7Za;iDHaY9yZ7&#n)M7F|T#YQ;r<R{E!y{1f8`M0)vW-n0=$IjTYFskfw$mIz
zO1!|Wx`Oiv(viW`L}cLWGYl8S%Hr7e%QvL`i^|Y!u5W#bfMGcgisezjviwvK=NspD
z)rJvYOp(9=wY5>uTL5aeXX0K__4?dKM{#C0VAM*Pq=qJsktD~i+~>@*4FNG)(&qyq
zem+AlC1@p0VPI!Mb)3o`$UrXw+V`uY-(cX&{{VCZc2gMmihvICSO&Hxa*Ea_OYxN$
zTFOPz%gO3$7@zv|@S9uep3R2Ec?MR)qdl#0(H&)h>DFANSjC~8(@;UNwnX)F#rn6F
zWGUZV&JNT~z>kO%S(RJPR8g>1;T?sUicCI&``$ZvMZF|&4-KB0d#T4!wkG0m&K<@?
zFKdQw;y#ly!OL2+dgMSkNVJx0aJo!VFTr2cv$<(C?L6XTZRx2?o@Y|Zd0T^Y0r(N;
zZ9SoTd$URT)7v^DXBWl+d<JPg)pzP$c%5*LI|8<!wg&ML1R0%4?YD@qyph`itP%3z
zLj*o>Sx_DY>TIvUn1!dSxDG$~9FUK7V5=Qqfx{eSyvDVHf3x-zvK1$!<<Rl~zhOh;
zpnkG2^-*W!HiW0|+T<)rJO;X{rL2Q2L7=u7_QKPK9uvz+ZEr7iXj^Hg)X9c3hsO%1
zRW7EE{nDN)z><MMKkLEV<IWA-PUMKk<vx?=C-2$}%YipLCCY1@33}gM2)&hlrLC32
zU+*hb{gL_=R1Hkur7?OXOlF^ywoZ!d4o42QJcim;ZTTmqzBrCJVz@{wV~zFB02`%8
z8EcB}w>>6hX&GxvUBXB#?#o!4B!1CbN?P;}ORA8*i*^qv>2SniG6Aj#-;;<z8G}DA
z9vop(+P-E@4r{?wUA&06Bi-_X0JPdB%3y~1^fhaIa3yro^xUIZ>+;9go`5l$^4&k7
z&F$B$^~2WolCt+4;&q1$mk|mgKxM6_u%?Vu?*%KEMxuC0ZZqhBw7RUdXV{^hlG7(1
zZuEH<%fE16Yp1Z+8EK^AMqFheE%dcE4f{Pua;jx>gS6ullk&T-wQ<;DMv8EU)DuW;
z$^oevBSpW#u7*qLyn(c;oV8xic0FZ^eTq5XS#3NHJSk^wUgN}blp5WhzeAMG27LKW
ztVf>r%&c6bJN-pYQ_9;oDWbQA>K?$OouaqKghuv|rC3GesGr32U6j>CwOaJCN!hQr
z#_3{)n3N*DbyM4f?h<#{OU>%f9`^p@Be@QcX)t_d>i)+zLzS`iip6D8S$^;OVd6u@
zhCV^X-Yk#iv8kJ68RCxRTOXMeqaQ4t%}7;VxshuC(no~!w5#OwOIwY<W>;?40+aHX
zkQOmgkN@0o>H#Ek1t2wIB-1`ONU!Fbly!u3xr-Dx;$JsND}hw1B9JVMG<=d9qzoYS
zC!|P5dd(fDyB}i5m5{#eEX7^>#|@|VfD~E@NP`*aPj^TOK$=WQzKqn%9n!fEOv;5y
z)^1@Rcaq|^e&|MAS0J^kY)!1FFHJ4-FL)02_-vmWivxn-ykjQ)nEu|&*S1z=MUL6O
z>QVT*w&*xC7hCkw_gvl=1b-P&1IrRybcJ>Fw=r6ev$4bJgHtxoDQ!!scCpC`xflxJ
zO`_8n_x(XWK<Yp9Xby{BE1wch;R!=}9-h$hKEOZay(-qoDzto{6}uyC0bYti8d%_i
z*rK!FroVfz#MEd|!pHL>=ImyE^jHe`1pnC0q(nT;Jx&KG0_W;x(h!eGj-f4)=HA@R
zse4s1eA0%h97ns)kyI6WVBSqb0K8ngxa5tpd;=&Tl(6}ClA16{f<ix(PoX9*@(}r?
zABBHP6Mehr#J*od!Dqr&;=5TM**3#mtYT<NcbLG{=YzNzR~82}7)pjn987=z8Lu@5
zsUM!17lsl<Jt8%bBDNdO6eh(bpCK~c$6Ukm_@Q*mj?Se@pcFFX9b(-Jl<IP=O9v`!
zW$qiH)d`@=Oad(3%E&aFeB%}-UsIC&7Tj>j5m}WBWjVreqF>_xOwnP+E$f)!<||Jo
z4Gn0324{=*7({<>peZ@)R$CZSL|YgvzCY+og?S(gQ>vsk)k&K?ZDD{~qA*OpW=;uP
z+?wtz3_1=frFdbyiWMe2(3)(yjazHs^Ok*w8sYUlw5T9I(lDg2^m(~m-bU2`sU=AT
zQh7U41|#Jge*l8rhefW{#{Sg9(twP;@Y47u3pS478b@2T){-j%<%d9Pjp*NJ5@R??
z^j&i}PX>=!41fb_meEnaSy@VA%o~BaD)>PTsHK`jq5WW|16sC-tgf$)S8g59N*EHT
zwX*X|E5PF|G%G+?ZJ!}a%~`k5Hm_BMbtt*lI6eL;;?aiEW()wf=>8a?Y|-Dm`~RVP
zc#kV*i(VqfwSV&ne*}7^3wtHJa=R)a6X@O35%jkwhOv?u@e*Szf=IUL-+<?WAwPj*
zD`R)Cl><@jLaWR}%WzqVk>g)b)f&;PKbjnFh8&9zs$l1vJXb8JeV)nch2MiAub{0Q
z#7|LE#MF+X&@?;K)c!7Fk>SDCloo>+WwH}xHc-?Ua{N0KL&RE<cA3F2^^ZSjIxxIF
z8x_pq>V|XR!3A3*>wNd>6Y$**Yf7Kwd24T+iCJ{kzE+WAcPu&S>Q3I1U~5CmK3UiB
z#xYt~yF*$g{63v{hfcSV>c;r{vP~r6pG;NZ5}-X|o21LoQt2H#rFR<Y-2vr(1FW*s
zI}F7k6Q8O;r(rHs!rBjg4ZmOBV^|SdD~7&9G`<G$ckeaBpFN(SjQ%=3JZ3pclR5X&
z*tE=pH@(gIwR%9YxG65{=b)PbN@uUvYlde`l&$lBuAh~2gUta$;Jn$Q7h~M9MVFna
zt$sufu)OmcXF#DtURC#S^yTP1y=a}An?kp2mBJfz<p4E%-_hUwbEv;N8xx(y=$uw%
z`0<w#{{`7pJ3d_Op{|Kn0l_IM9iklB@R0dL6+0VM1F?UoZ0yTj!ve|1UZX3#va4G5
zTt|iVFZV&F=kK=b&^VQ9m4=V+d%`~X#%_hENqdHR^gagubJsZl*`n7lFq|;u+LXvY
zVqg*2*@r4y^fU%OB_Ly3fI66=?}4e5+?Aj2kq~>5c619Tk|T>Lx;6v9BYqCdAO>C{
zU^&^jAj6x1!-=Pww{44loMS>5A>SC`)CZ`)qHX|uaa&dABtJjFvy<O;2HtfMvVwt&
z36rKwS(-cst|p+vI^!95^|nP7GLQi&%Mr(*G#*L%1_MjG@JnIfKg+b3u?#$SODm)j
z1DpJ(Z89&>1W>vQ#1qx3hEWO`I)I=KoBhbZp)O4KGw^*E@#`44M`g;|FJxe8B6nEB
z!oZ_;AdWS_<U=*64jXl1;PsnY`ZNZ{yXX|pzzQxve+CA-6v>l;Lx`soB=07C&|TVO
z8K6>~%lsVY!tWRZjV|hZ&A_@YK*2x{7vMYw{_Dc??e5YiG7cc9qgnQ1)JXtJbzbM^
zHiTsF%F&G&*qVemOcuq!t2eYjKL%a`P_nailck+NNIHb^7<!MP-?)&TXW&E^U;zW0
z5YSPt8yGm;1-OWTu`c8@8CVKHsDryH$1q^B3uz7mN4o%9GjI(79fqjOz&S3Mp$vSE
z!Odx%G7S8gFzt=p68*F*cL;(~ctqOh3Iju2B%NU3hb~OFG4Nv-;HL~+?gD&|f%z^#
z%Q%K^a)I_?U^x=+7}rb;OaZ3Uu?ata;G$y;1FzeW{Q3DE7xtbEB%LjL9L?@Q7iox0
z;%7Hc^aTcPSG1$eAqKV~rjDs$69a3xsI!=Xy<Es=GjJo3TO9Q`lA(S?Z+Cg4y8-Cu
z>zpU0tD>3c23(aB-K>c`U(!;BY-3p2k>*QvqSN5lWBj)q`0};|5RB0hD2bJ`8(Aii
z-@vYp^)hUppD<>ebah@mldjGN=nwbzD=G#x9Cmfgxffhr9do|ndx%SKPreQwmH<D!
zJ$@{c&}`}KOaYJ_ph1Aa*-2YU$;u_19mmm#q#tHC^YmMYeOrAOsfDpK{qxKCJ#+RS
zrDf}Q)JeJqa6aJ{$TMn32qmw|Nw|eC=x6_WA7*;KlE?=cc@9c}av+%s%VuRwj5RQ2
zE*90~v*OE9<f3xgc;GW^r?UHMyqPXt*2mYtG53bkVcm#Lsefav5gBV3VUHa_<F1aF
zj24$0g4|fRtWe8%S9+^ECQxnOu^FaKRGm}h$q$Qyq7MUZ--g-*c8DL$Csc$Ah<U#L
z!XkW`(;90H3i@^!IJ?`2QqIL%-_w=tU{ZR<Swk9ZMJ40oF>vf5e*D|?5J<~8R1+TL
z=W7ZUQxnXxm4c-TZ~p!X_BV0rKhEm!T?0*3IT>fIpY{{>?y<8!3N@G|>AdM;kwuT4
zW?I=ynyKL>)l8`{^a1QfL*Sr^CMB(gH7Xn#FnPnHGH1Tjom|?)es?}DKbFY|tFYTQ
zr-rq0s1I|xqUS(Qg{<6bYH;?{1l&kc!}><3(o_mta;pSNFQ8=Aw8m90)}^S%(M|rP
z6=5J$?+t@03u{`dw+O|;2}K(Q;74P~B)n?5@{r3$tCpfvDQ*TX|5jHmn$m3=Z&LmN
zBQM0D!s4xMx^!pkoSUp%8pV9=*C2%<TH#j#o56k+<-LEik7V0-i|x_(g$P5ri@qxb
z@m7DGKO&&N#9Jf6PozklHe6wy;?j4$OBUyC>-=%p<gR6H7^}5H8g;zu2%5-7o_n|O
zVO{i{eEoFX<Ta_5wYs+q=d7q@P0}@KV^V&qWu2rOG}@$OCs+f#KhMIZs%P@N%F2Nn
zua{BYNwAg=&QI`fi{4~A50fDu{~DPt9Ko*nYXX$b3D(5OTk_Ts{j2MdXv*|?2Uvn{
z$Cme<eu2oZXKicq(99dMTT~+R125cWu#BOOF#{#?*x9GHwU1ZWSW+A>1NW3c9!F*#
z!fP@bRj(Bl=%TXn_=d{LABon;jBtsG%txES2Z00H_<gg8mV)ij+q4G3(7{7NoZk+g
zvbgyy#cNzMRQF%F536gEHN~<E_XQT-e6iSee=F8m_eN0bKxamF)*Wo%bDuVrZ6GV6
z2Q>~FA7B#uYW3VG67TH(J+8`f=1NBB{@2hgu|-5<aA8gYRYvLvyu+ulD2*gnsa)4;
z=vt3npbR;MREAa)9HU-;d~;6!<r%{CJUnnd@AT%qW;=n-{g}pcITRZIBx!l|&d71_
zDyq@GI-;}jwGi>LMXy3o(-!@5q^o&Ah3IB1pmvIDt!Bk08;PG9-K-BWsBkZUXuT|-
z5`G#^2*wvQ66EV&;h$198TCSA;p}43O*-jv5<@!H!>RM-0^8>bZi&yFdm_`X<uUu2
z@hh43LMt<ptwGV%A;CUQ?v$6x8=nl5LKPy;*DuFEWj|1}KJP81y4kO%NkiJIJt@kz
z>O!j9ZPlElI)Zgdcs=Vo{#M}Th0HWJLB`y;eKKFeG!^NF^{my)e{z{>*BpiKOdP^k
z_OKrIG-?hoDSD$dsnT<`CAPZ#34O>6O-~8mygb<QBV=n9r%gzIxj3a}op0=dR^{|S
z_A&79ivT*@iZu+ZMwkvi`6CA21v@9^GzR`oKot|->0pM=15+uvD?b;K5Ql5l!inT`
zooX}i1o3lV1~Kp#0y>;5Zw3w}o(^~HaZ5gq8K%((i&H?U5B{vGbCRDQ;n~S=I|FaK
z2wB0vMTF^a+w&Os837&E8PCAqevVaFhXWa)Q0&3EIAx%Z3%?Wwc5=atW#F0fS|ODf
z7@ZBr(i>xfH15j`S-SJYlN?K49TqaQA3+^9`;mczU6}4?;9XkrIuu>Uz+HBxQqn>O
z`VhIp8Wsi~aRBA&aHs~=VWUnAy!w-tK8=AjTy%<OV0jmyKLdkYisZ?_LBx{<QFP=%
z3u%)jfJ)6T^K*;~zhewcc2VbR1}3@y1p{B9XE_T#kAW{-c)s0&qa*zY>S&g|7<B@G
zQk~cNIg^kaovslBTRKaEf<!U!H<IkIqaOo*p^i=++tyr`b{rw;97!hk7`oSm^gIK{
zy8sIq*oc6RdfmXlp)SBh42*UmpUFUP07)H7^cV(AbRo@Q;7Au>YX*K!K!+jfGH{j)
zW+(&y{6TAoG7S8QFddED@-&@01VQ!oUUG$jRb3>VU|_xr(`^h~-~#-VflFP0?=djX
z1vt*a&<!roJ`5~N;vM6fiGhuQDeJKbKfmvyV+;eY+L8SEd5#NvPX<bzEskdQAWa&g
z74dVJ=K=#OywG;{Lk!F$rq0DF18cgdvzURq|JIVvX5e}ve+?cW7iT0x^+fMnoB~*4
zajH~Eu^!a*&%p_zQcVp?QHnLhQU`%Jx=Pma8)i4hlqsh<T4~9+t&G>}_5Cr!@-EPe
z?_tV({T2M<-AT%XO5bHKlHsFyu!!sKq}=0qkO^14B@|^>9b0qCoK$NHz984;-2mnG
zxNc#|C#KVmyF5Mg&1lIb)4qqHNi5FJlE)d~zy$X4Py(7-JA1zit0-fdTE|+P#ZWz~
z*^M|B9+jyb&@)qIEL@&HDvvh^N_Xl<Mbzwlt#0fZ3&%Qylkz0hGFg6~W-66h{2ZHM
zq$J~gFT$VENGF5wt6OUoIG*BE-~+sY0^9o*Qy{9C0!l$M>#*p9n3R(Wu&37TFm1qm
zjmLrWJ7A4uGu**$q)cQ*>Uf&9qs{~A7HiV1@8S~^QyY0G$?4XJ$WgJ<@7?^Xd*?o>
z56&Z{Tf>I$0|GqKz&=olo%;j?^<~?T2}PN-D$DnoNUecZ-?Y^lhL&J6=&@+e{Z{>w
zSf8oT_Ic*qf;2ztQF56R@!>MSkU5p;HLf!_oavpVcs94zXtE?mYBm;vWrn&V$tPT0
z9(99Lc)vRKMjK*tHcg%gdg6D`@XvFT@@8{ue_a$@y6>7>H~Ajv%z4IUq;bz~Va?GS
zdXZ`6UY5^6WoCx8GMe3`oIu4p!&*CRfjoSv7Z<6-YGRRHX6K$J<&6w$b={1fS;~YA
zYbXd?fpAHNHLSib6aM0k@ErOUve`YcWG?c=87@diAVvQg*gTSK^k;hnDivB<V>57I
z%Sip%OlMw=)2mA}d{mMtooY=7+uV3C_9Dikaf%8ioSKuROlc`~YYwKOr8TT$X=XF@
zf}28}LbRDO?TN)p9F&3=KkYR2YQw!Aj<l|TlFKfoLMv;HfI5u2+=+Sus~a@AR@Uml
zecQ0<-#{H>dEO5nupT!CDo*N=rF_uJ8Xs0RQWkH7R<DL?1)uG1QZBYao{%@Nb*-(*
zb@KJAli4&dp3xE^Y2!=Ml4+WQ`pwqXnCP#tT6eZN${}k91v$gpG0G`hT3ds45r{jS
zX^nOHPvMgFrtioMNPkS<C1VA=E??Zur1)i8mkcgADXo;y&0(eP<G?vTwYH=)Or;l;
znu&_y7k8N=nO;<vFXHG0(x~!{kMK@9Ft+Fp$=XE=Hr=KSjZJ<NMD``y&%niqR~H~G
z*$&F51aFC8-2H>p{WAcSp;^{Q%K%6yzGRcDLJOja>Z(vaZ|>uGb{*ZmJw@VtN|OML
ziH^bjQ5}w7reVERIuHB#_Eq4+Lejyf8g$5vc3lQGsY^n5Sz4!-L*Sx&?^g-Injibz
zXw$anwg{;@M{gO-`Z*^y+0fN#gm+FzBi!gBjW9+&C2YeJj5*|cX@vFwDto33jkNT4
zV+8HG^~qhSaRdm8ty`NWK@)egU_OcBS@7v`Y6<#h_{Xy#xmMa)(8%j%$H&(28fCIa
zi;leYKcYo)?{o6EV6ItSzC*&u3tf;%t<6X^?WmLJsSIpEK!<}jh=D^0=x}P=Gq5g-
z?8HoEU<v`9-hCWHe<bUW<UoE-CVmd*O6Np!IzQAzpko!{=fM1hfl&l>xJgGCxSfCw
zhiY>j_U?zG%udahGHP?XA>QNXMug<xH;#dcE<*Y+@cJ=eIvj5k10NF5VV(L6j5}`M
z`;1{g7c>;-s;wdevt9W8S6i0Z;DULVfk7@peqi9gXTa03y!?iN;Zz!QHFb5nmZ6)7
z-ciPn8MyVRR`cl$TysaO=nw|#RHj^w9T}KS<PK{zW1yeCNW8kOsX=wv$iTpwF7zG@
z9P6Uf{RC-}ZZ5!|892bDNCz4CH5xrvhFsllWausG3e*6X^Ya)Ne(y4HI*~ex^A-cA
zxBz=HFv|s)$-oSk8cI&!z0XY~$<ZvUG3p@zr8?#L`C~$Ibh;N9-O%*slMsi=ZZR;<
z1$dT$Q2<JI2l%<*2q>L<pX(V~%7ye31|B3-hmaWzoI^l|A%-z<y9=;014p}%r!%k}
zfKUg~r6dL%b|DR6;BFUSX$C$apu-S<#7je*cES9Ofz1f$Q2aOp!>EY%MsA7T%FzGg
z>&gRTJl=nH-wkm@60&k9o6DUGafbwv-HjvepxU@^f+(uBiKE2YigQ%i_oa0db+&>O
zQAg;3(w1tK-ic^wDXMCJpJ(3p-Q7gLzx<J%cjhzCJoC)VGtWFT@4N<zbuKUMa^#pQ
zB^An%*G{<;&66X)trGc?9QkvVNV6RIRh39fvK;%cN~}SS97x4G^;#V{axsv+9sg;@
zD}J>KkH5%~%@D~!U&+rGtB^k_M-tC&d!M`I*p)<26;CXaBQO2nKHL|`k*kTQI$g(3
zkt1hSVJBOToLeP(H#zbz%HGP^j`4DAHsyCNFM|;I{PHrZpFLhUJ_&Db^|Lp{dz!vh
z`PH6O+MugT#y741UP*U2*x7#e*w~`aWVb86j&_I+KP)^wp6;4(w*YW#)VIIAA-;#a
zW|>UP%k`enQaz^c!tWjW@p5i{&jgc#1_kKeLnT;A(4aQLu1uWO?{9A!_K?3K>)qyc
zEHLGd1gJ0l9_y9KZuhsh*0#h!wgFg%ydp#U4}K1s)(c0_kJIK@MI^nQz*i!<*dW9j
z*`a?MM&cq6NNy+-cz4iq1a9;s0;KjUj^Q8An1mO4V+Z2J2xM)07%#)Zs?a>2)xxvV
z(5@UQ7o4b+I~<w24z$OG4UjXZ4t%cMke-?B+mJy9!DB=wbA${^F!YF)&GcU;<M$L@
z6tpA=RVuuO(zlgDe7!>lg=p_5v5-Obgy^|=yA}!7m!rTwnZ(s(*a2dmGRWR6tc47$
zU-LN@?qh4}{XzD`u$y@M7PM~Uq4}$}#5O=QgY79jY@QooDpQw19g}Cv8N{;ZGITbB
z`5Og4d*ChFwBxkLUJ;Cy7B+g$y@@I;8f=fzt;37n>}lAbpdqw}LU*F@m1+}!=`12%
zWgm_6rZ)Zb6tW^|laba7KW3mu(k07i+46dcw552n{PmA$CnvXWCVzueS>HyE&1B)(
z_T<>B$7yua#d=r?8)>lgw6@`|$JPWf%wYP#6LI-<lR-)B-E4bQ*kimB3^^R@|D32!
z7&F=OCWD$XzahXC$++Tv&*26G*SGngKsKIm?Pc7X&*MCR+dc$4v_IhOT@*R<dC0pN
z=oihwTEb9!v%xm+0t3mP-u$v9zaZz@R6Q3hxgt@uGJ!gD;UsJ&Uc)HP!YCdNuT3gU
z`Y8AgT?3kBJsKPoE0|oHKyk;&dQQG%<Q9A|p1>aa5N$WV$&}#n?YLU_k3FF04$mJY
z3bJ8-0og$%1wZbG=hX>EzhWY%>TZ{_++p^(R(m-Y*q;PPlX>oxR}qEPRww=x*IQ<D
zpj^NQC1CT?Fnd&ZKTgo?_`j>lw2Ha)Y;coS12TxxX!)Q$a^lcNB##Pv9Zx9neh)5#
zOrGYQMZ`Ng2FE6LMhHt^&oxNLKJd@-zS#eB(7yBqd$U#}L0erpM(_es5_oa3caKtW
zaT*Rt_L7Smk4Sdw;b43yJquUT54Zcf9c?LMm&!&5H`GG;$wzo?DT6vtZQ@pJ2{<%u
zLqCmWRU0k>gY*2Wn;Pdkocx@}r$<n4`JBhs6m&c1krc*PT#L|=_-ASFDd$CRA0}=+
zo266px-CNsg58eMq_yG)L$diX0l1YQt+U0T&!-#=#w`8<B{oI%Kf-pWk=St*w$2-5
zM_4BOBcB#XrAZ1NE!jhK<%k@M0|&{!d+{-oi+6!42OynaJ)cO(b||Omf97B9%CAg)
z24If`%Q~$IsIHf(TAogpy)*npX!QlN;pAw>H5=3sC%`*HQYThM%bCto-N;Rqc6cSE
zrJS&C;>;wYQ)<v0V$(nFMm+(W_zrz?7x&RfEAj;81kMFcGWjrm_|pAPqs_mU)5e(}
zqArJ7?r3|U@U%xJvyQe;t0AwE*Nw3UjZ>Wp+^;bbbdJV=H%IJ2G?Z&N6jgr{0G>iu
zDsfcx?ERTB)zVq%>>;5-U@IIIA7c;m=J$SZck#=Z;rJIfe{6%7=MTOa9dwNPB(%2o
z;i|rE<@2_a4x!7R*}CB+!50(%_ObS^xQxIrPc}1hNbPy@hW{~##0ZBF9fDB(RFR#P
z%Q0DUCfm1dgIVa1l*wKjXKxYCZ}#v$_0oUj%1u#n{n8pvc=}@Py@tvcYsD^b4>?F;
z`kr8C-i{4%!tw;%`ZK}a24ARsb9w;A-sBkK>nHyDqxZoVtCT>7fkXdpN4bRh5pXA=
z^6Jf{9w1db!JerP;<@zwJIkE{wpUjBO!>>S%i*OVd3}4(U0yi<&A*Y_hA;6vmwW=D
zpzotQdQQrfg=L^A6rI|0s1lJ#6Dy65xnPRWspyAi$SNV%K4%Ly&tyzFyv4qT=%()6
z&;%mn3^)$BGa$QRs=c8809w%1Z@^>LBzrR<$_H&Q$=<f^^GOHl{Z~@rWc21vT{2nb
zWP1-ES1w*Ab?chy35wFm_9)#id(mZnnQTuMCZPSpr`THx@Azf1{!{Ed1$}dTW@HN5
zpTAh>J!_=gI{fI2+G{e~;!VyL(*lH(@p!3kD$M2lW|^$*RD1KbJIiFbW<zRkOm=m`
zuldW2-v5sH4{~<&bWYA6<PJ`?4{SHNy|Wk5`mGY;<Tsca@R^`IAEWCA)77+iMO**4
zM?N){I?e81RcblY>><iGa`UIz<KtgED>G;SgIy=d43Z-I;0P(O7s$4UMgmQT-dYRB
z<}|xCSa}Q4O}7~fFTmPI?=Q%;C;hMVNl53Pt@<7^{Uz5Pt3N`EEU;VaJ@gFcixr0H
z_GS&c!s?Ul4!q{%O3Rt<)_D2T?a>zgjv~KRU<GZNRo$ObH@nC^DBmV}xed)Ye4{5Q
zh~K#2u}d{5$lP&z8_xp2Wp#Sh`m6ttdeu5?;tadN;Ns~AsOD-k$aKh^VQ(bV@WLfE
zGwiM8b6&pl?Lpdh_}s<}`*F2<Qde!Rbk!>N?=+z!S9Ev|RxjSG@<QYNy#t;2!A$#D
z|N0G4CJbDR-(PwbK5^)iYG5Gd*&7Q9txarwo;|zIa-3D5+h2^d+Oc_hpQKK(C?-pO
z{Cy1dgGDjf{4u%BBkBs?hu@c{Gy{D}g+3Rf`1T(|2X&ccw+feaxHxf^eVSaK)R*nu
zb$hpgsiiOD;LRgJ9;h085&LEPAYrWX%yMT#U=N72d^H5N#{NTKd_;eU>EV;v_Ws(j
zMI@QQ>fFSwMx5C~O%k1_1l9Wt^$+eliC=F2U&M`tkBwGF_r1Wn?T!O(x8~Y+XktC^
z;kfRhiIBv`7<y;jp`QU=dBT8Ra-5EOIP|qKP~V$p57T;NvQOvPFK8WRw((W_K;f-J
z>)C@>?J?SCW)}RKeTY!l1e<TKp~ufPfCKdS^PAm!{Jz)hjS1`O4SYV{jq%@nzI|S8
zmj<JHTiol7*YBW+sp`M|DjPSxuBG(;-<?%o(fYZn%Y#Ff+rH;B=eaWXtCHD*%F8#^
zRuh~fb|jV!E@ls7`DQ6_EChOXU0`kA^*8gE&6WFjVD=_qyVlwcuM{@n3$v<M>wbZy
zv5VSR_3k@XX0eA4xLOBGZfpF0&Df%((tAGpyv@fmJ!U<iOP&V6k3r`f+Z~nfDB>UT
z&^Mw6^^67zQ|=>&ew{BQLf3E6Mc|mXIzKhD_WAb4F&kr%-3pVQ?$r{TqL^y;YPG_|
zR_jo|P@(5PX7+ZzJu<v>6Pdj_d`t11;}+WD9f<~%j?Uz!3<+T0FR(XYf92a7L>KHt
zi;#0;9%ki=$1q?4v21ptA7m@&&ILg4Em6=d3B6ZFH*}$Qsputy9!4sgXjfputr#n#
ze|B*)Qbk`P^zNeyS|W6qj1F|6gH&`7n2%-$6!c(1e}PwT!S_wk$@itf3g06Mopew^
z*CVu5M*rYKFHzCE2;HYxL7%~{Lq%5^{h15hSw=UCZmqIR8zU8e(@A=p=V%x3uR#hE
zDGNdNrb@OIq4&w?D|RQ#yH)h-gr2Cfd>c!Nig7Y}oeMomMPDTJ*D885p~GeLn=W*)
ziVj=^^dBlG*@XTQ$11@0;Z06XJ|C#?J%Z4>y^1(|2)$fJk8`1ys_31B?y*NfpM`R&
z=q971T<9(;`aYqPRrG6we!_1%^c?O&KOCTN(rGc!6FyLAw<h#{8J!Ckj?%T?Q_+hF
zeR!9GrVWCM@iMxL3q4vzUm$elZUw!C&=E2^%7qS5(E+am?XAjW2%*2i<>!!Kk_&yg
zzruG8p)aeg<4b6pj5fUG<hxKszf0)0I}}dJU|Lmlm(l%Q=u{Q`C!w#Y5}Z%ye{jPk
zIC*`8llG&23MU<x0NrN0LOYqz2W0eO7kUrS)0fzBK0+1V9hgKF6J(&|0*+D1enw;m
z?o-IVO=yFRZskIUs_2GGf&T411wE9|SF!v9%R}FEvV5hl!tzUmp0ZUz`w{vL8U2|H
zy-Y>#AoP8;Va`G4R;0`5H7<0TivEMp>r}oignkNN8aNrZ-pR@1EQON}g+K?qt#HzY
z&<ADo78iQ2ie5<QWvXWV4H~;*qKx)tPTFHt^rwVw`;J2U9YROS=#4IPn2Odf1KO-|
zGK|pIuyFytSGdq$^ilYJk<hu@6x#I(y+THJb)l^)dOM--sq#MG1n3?zdZi29RYl(;
z^iZ|?<rDf}>>PlT2Wy?R{JXcpNqZ~MyCj8^wuF9PMt581MDJ743kcmvt>y2Hfu1Cz
zUv#0zspwA#Jx3ijTL~Q{qYGV}gafTvj;>u(W#R<_evOScu$<)re%VW5dH8aWU8ABK
z5V}Z4m#uNKyj(?ZBea*ORPf_QKxfG41FN0rZYugNp$Dm*wSdsiu$cl*(p;Q8>8Wti
z&Ia^Gbx5`&^anE9%Z1*rq6-L}rs}i1upTNV%jknHzVT|eYzBNx=pHKVZG?`N(Z9R+
zj!@AJ-T+#scGls9zK%^C@IBpy{wh<U{Q{wnsuJ`k^hz1s+J&~M=&gj-Z&oDuNes|N
z8C|@}DZ%b4`gcOVxk*7UAhd&45jM|lF7!WUg_E``fG$xvX;0`wGCIYDKA@uW34PSA
z(7uN)jEX5T`qoM(Clgfkc|!lWQ9*Afbc~EX;X)f!bp0ZrJF5NUMM8f=YfGp=7y7D6
z;d>aNJE*nP6MB`5j-_uB$R^zzK(8!9*IuYH@o5x*CK)){1x#1T{zhaUsNz^iXb%~E
z(S?3$RG4V966ip+VLA}H7;bK`e8`19sG==|o}`Z5KO%viDx=4^&=XbkIYJ-Uq6lvX
zp<`wAr4`N!MyhDPRm6$fFfS4MTX>|viI0o+wG4&tp@g=o`m7<LSIg)NF4`+p^xK3!
zs-i!`!l=S5qmy0e9xD0{p?_5+xQNgi87;lx<on+q3Ma{{f$pugPDer?#<~rBk8`2l
zSJCqc{ez1BGXm&oGP<P;JxN8E5qh`UMcyTJBN_dh&B;lWiuPRt^ad53L+BgWXapyx
zUFfgV6~2cMx|`Zr0|>oFMwhtIMJjp=q2Ey3@<KS!nKHVD3!R~&D+wK})^ahSwK96T
z3;nEn0E=9Ut{tmRVx0(hg!~P-+<LjQf*%0Lmo=}g1=;&*XT1-9e?_j0p6x<UR?%k(
zy-uy*PC_@9(LG$~Xcg_V4(P3FqmLl;cibo8+1G`>-c8{oo6sHA4i!k~wKBS{3%ycB
zZzgntioO^MbWa&Qjy~BSk94DozD?*AD&MaYT9DDNyU>oV3MZ`?(D^Fu6ha@xA{Y|<
ze3_H>Ar<{9(1z3MAbS9(d}SV>S6t9s75WjNo!(Vjd=Ek60X^n|HtQ<;@UWrY(P*6s
z$AJE2l@a*+ncsTcs(9NI_hGNMCw43Ll-&_Emyo|OA3VafKeC?tvKtp%p&PoE;kcGW
z=l;y3_4aPsCua8Zdi!W~yTB298Kd7l)06w=D$loJUAoefN^zUk-)0=7TSPqI7_=ic
zwc2yhFRpYdw5t$>`cSE=Lj>142-T^U{_M&{RQI_(V;>U>8y6Rj*k%<~x$IZ17PWt`
zn!W%&g|YGBD%);8x`lVz;WRrw0|DRA!wvS1eLo4z^e`2krA=hm>(m*zU-bp}ZVGSm
zud5!xESYu;Ga1g;`YaOho1TO{BDg9NQ1xDm9eK@7Cw~=^zUgUA4*SK-7QAJT*WW>X
z)KB2xZf0B$fBRoEJM)%3Qi#{$PQJI`X#6)ilhxm7j}p!Wz%9Me-YIHC4RUed!sE&<
zynrB3=~eiP>Ct!maUyVQH`=p>y+4`Ry^Z$fLIDEdo9qXLZ{YIyVw1hKr7o&Yo~#!N
z+`al^iyX1b{;4XY1Kw4IT>bg>t*ZD{kd%9))UI9ix!GU94{@INb;N#juPT9|x2rzi
z{-Nq~2Ypq76Tf#)XSeM3&`d9wpY6}g3cwNIW*GLzY17Q1Z}!yeQBlcTPuT$U#qfL3
zK^}A1JV{<c<Cspv^Y+E5f^W<$L$qfK3!)%X(cUcb=LNLQ=Y6O)ZMAw1#t(-chX)2F
z)cnEBZi)7&zzrCMrou8);TL$30}d)<;dOkW>^2;Vl08_sg+^{G+0!f=|3&+w8Sc!l
z-V9N-s@5_JZR{@A>QZ|GHRYau`9@Xzs+v{P>%+VpYjJCaes`*7Sn#;&^9C%3+zXgd
zZ7|g@uZmw#jp2UZR!!f6Ma@umf|oH&+@GTwR4eeCs_8?kb<9_;yQi~Tn%)6H8alyj
zM6=^&yDHs?-P@mL2=4?Ebayhea9E-jwJ0tYknc@CIWmC7A4oGqJ$!^F!oGxa6TRvk
zdfoBrY5vgn1A@>i9kKanHN13LMUSzpITM2$uBuD>^!%hj^4OYupFUz_K(V28V~)n)
z|B#pQpBwf3HFCqD-Tt9kqW$)FRGGzGbE%4p_9X6w=lfg!ptSy&I&pPUmFA#5Tx(lp
zzscgo-_dZyra?zLU*u6YTjZO-`d~EZ&wJ8ti$7gVH7uOJ3&Rj2AKxHFN2liWyJ2A{
zF8|>!h9H)z1id$LVtnf+_ccC-X5z>FEC>ujndC_H&Hva%xVOz7U}?!SVdMM=mW#40
zxC1l}Sd8W=o<He`#gt=1F{)`(g5L-Yy_n{>YP4lyMospXfgxb%D9m^&lM)L~Eu{zC
z4IIYn%F~r<8VkQBNMTv9L;n-n7~G+;UQBz*?L-BWw%Z$d+fsDjp2JzE*!R9U=U`X1
z+l|76N9N-29d^A&SNl*S57zcw`v~FAUuO2!yY@y2lQ2y9Rt!JDg**72&#+3NQ8KFx
zBiwOVcdMRx?z9&PSK;wqztbKgoO@tqCwAJKG~M*Tj7jHVQfb9PST}`V;*;O#C-Rpg
zIC=htbpST5e0SOZ)lIXmcQC)**ziohZ)RP0;{}gk1g7k^&laRVIn4m}Y`48mz`Q?Y
zHTB6%cQsYS4DVrD>I!K3dw9nr6e#Mgu6Z=8@L${o@F`B<&D>*;vD99L6N-l(JM<r7
zXm`@)P1>)Ko&SHVg!8|#abe1B1UzQ><CSkr0>(nmZ}4m^)PIYgvz{O0zqYasD4s-!
z6PhU#io&Uva`;}<{&&9!pp7yJ7b@T)g5QkR6rVQ`W2A`~Utn0aGLyyb#myFdo*5zL
z=@_2QeM+B0HQm}3``EdA?QLq+<G@Rg%xv#odvm;RlphzsZtk_mM}O4=W}&<R_63<_
zxJbk;Ki`#NiTmt9i4CBHyZapa7jNL;b9<gWUvBJSw(4kWWjcsg);$c19+bRW;mK^R
z`!~DvNp1iu+GnrZ*-!++w&b*bjrh?=t)h8~AF*hQ5>LPgM<q7GE&%BekX|{9NVf)Q
z&xr`K>-+F|yeWA&03t&-|Hw5CeMc<qrK%bY$2$%C?MW$hWNP@*9v!MtwyDk%g9u~d
zOfj$EEKPdKSz35pW(hXT2y7+3vESa*;wd8<$%r4@IK>nSBUE9!0Q`e#Ox4McXM#V{
z0{A2av^C_IjkA8qHz``Fp&IR)D7bj}TQlRZbE<Bx@dGQt&buwQR+$}1U#6ZI8YQ&E
zbUo(8&^SShz}gc-lY|T3o7s89)V9N_pc{c84Gw(;+vgl=Mu0;bB0x~fFJ8`<Zwf!B
zqcXPSI#1B4V!ffU-5G`Cl=NXd{WnZcRnoKgtDXEN!28qr5v%$D(h(~%V7R*d{!^K+
zd_;KguSqo=&_4^!+;=ZpgVsHTzdH1vo;R~$@7sF@eO77qI8L8SR^F7rL4c!(s@%>-
zZ0r=!XVde^%Mb;1S$=)8`&j2CQ9*@QxM92q)`3!*YTeAes+6gHp6Fc+XQj;e%LrFv
z=>(#vOrI)c$^+-p2lnB@uV>9H@sQmhoJOGkA$x4##<R#`#qB1&7C-b^TtKT(YuH7Y
z>qUp`fx2x|(dTy`vL~3&Ps3be)t$ts`u&m7qaq1I%(U>Sc80;Bp9ND?(TgzCeaIFg
z+g(SV2^`UYVUGgF^UGD5m6=&=vAwOIubKzR4*gE(;3>t}ApZz_*^2FP!bdRejupek
z`}r#~yIyQh4D9DH;|7|=rHA=k<I|m3Nt^=yq7K_TK#lZn6u?Ftw)^8e_0O@gDT?+?
zX}^?@uAzVN(X|{IXu#t(j4YHO9=5me+l)n-i~Wu;?Y}*24{VcthJ=Y3k`Ai{l6V$b
z@IIn4+|19O=cdVIaMSFFy){_qsj!d=7P6Lb7N$SoESL)A0S*?%q1sE2*dv4wzzY}n
z@<||Z_6V*ze+R@AfuBdliaqFjs$N_Az{nzw+S|9adH0K<s=9wx6k3JqZF-#-I`KX)
zG-Ii=&>U27#Zh~R|HqgTD^|Oat+;Pw$B){R!)@Nh(JEQn@|fkoD6emN_l^!=ekJz6
zeybOA`tSeA=|7n0l<UqXXn*U*n8V1`(~6J(;8ziv18XAaDBOeWNf}ao4t<7uP0ry_
zPxYQxf-^^DSYz#by)%xv|77-HeOIS8VBeM4{rmheflBZWL3vm(eEJ6!i?!qN<{<CT
zw?2n~A%B&XZ)10Y70%58ewS1{o+|6{XPz2<$IQ|`v`5yek1{H8<<Tj&`SkKo;kO^<
zvMpCgtz$hAJ%*nk0)s0vsk-`)QSPZCJpa9rKL@MN74q{d{5dt>A<PsCAD^Oz_?0uR
z_XXp}r*UTW7^YS9m20Nw#-5ECj@e_H1Y-Ql?}F2+7rXEQcg?Uu$duwoFSr%5>!F!V
zK4wp>VT<cL4|d3wWA>HaX{6r4{>o8n9Yw6@1T2#G2WW~*PT1#aLd$=mF%Ao^FcYWM
z%F3^epgJxBRhZyeC+&^=4h_>_9elhUlmQH|^>Ovtl9TrK!tx#(cIqSyrR48C*zJ?h
zB3%*V{Sg8Y2qb<)Hq;FdHuxiZPwy)AWBWd`hcy@np}I%Iwk^K(k^L<}J&ASJ9x9~X
z#i%?B)$`>SX#RXdnt$=dvv%(qLg@iByZNcTn_$k+6vuvMe@zqh%2f}KMWsHAcS0BS
zw9ad1w3Rf0!G<R02Yy<WnAzzI&?O-~HSEC!d#oT_^<beF?Li$+95wTt0p$9#lHM-~
zq}r0N;%z1EAFd1gXCrOAnzrPqndO3jFbRR>2w3_k=<PB(7wBwahbXmD(yTmfbv^`)
z<Q;0Vzmhzes9Q^9tGVQ{oXl$w^|{QZnF!cckB2D>^-iDd^!Q4yI*Yjk9eL;o`tv1w
zK=|n|<>&|8D_8QEXON|l^r@M>e90ajw&RM7Im|Ju+d)e!M5lg<?_6E7hiG%JunU*a
ztTjOQ572GfTFKL0rd!VQ$aJS)mw9X|Cy_&6Zh-QLVAkbxSjD1A!*V}II}AQ-X42>O
zKy#<Va-KC@BC8GP(h3XaFNnEW^HJMWSL}exJa#;!m&0S_qSt<HX4=d4ro#6|4U4}F
z8~XGfOlz0z9W3LDNeNl=X(y-9TEu_K%I9XSbs#pIHXRDB<M~fn`6xLypDF+>|0yf)
zCC8p477MM{_)l4RTf{215l!W|mjLtlBmU{r2ZyLqd0zW8!_s1CNn=`g7N1zfyA^OJ
z{mBi)ioa12r+Lg0ub?OWI84KOUa?ORuG})S53k^wGfS$b_}&%!0!{eNOL9~F$lJff
z%dPGrRv1NJ0==uVrug)i_B>6SpDxJgFu5giu%D*1#K-&P6xmt3dIwM8{b=6>HuWmF
z7+7g$%dX<ijPEYVO|w_-tWB^QkcnUs^nt6@Fx*nn8s%`;sLAi}oU`U4ItyRMP@_HJ
zKtYR+L=Gd8&PBSCX2>}*5S<t$N4KSudZ$kCEQ!j<%xS{Y9QtlDJ`nLVD$l9$%`chR
z3)k$elK#5LTit_p5(}-q{HLsZwwbs34!PCId?2+q0<rk?(=~g`xUQdZbqS6uuNW7W
z1;SwVLVG!4`@(oFLMy{ulRs}e=OZ(F>B6KqodGUVcJl5zJsb12Jym%0wz+u6*Y>l5
zVE@!yJpG3Kx*+tmn~QsYZ~rQ`?&A<Q4Vzd~Y%F}K*RY{AMT2nJL&ILHDaJIKhwlJE
z=St|QCfo5jbeN&=JBL1IEw|`+I2WC}44DGQ;FMmk!foY^IQB7qux|6c?Z+H7#Rwrh
zNW&t%#5m#iKn?5bB{nvl4kY}ZOEPfXFMep8UqKQ}I=O#3^hfr=^=Uiq+nAHYH%#T?
zFE69wsS7*w4R@K@NiQ)-*aGHnfNtO%J?G;v(BPRjhb{KtW9ZmgVtZ}bIyShL7%7|%
z(6D*6M1!Yk4W!AWT4Gp(*&Cmm3S?>CU3I{R@qa>XF+=!xtGT#WZPDx_d^y$3HUx<;
z2;0V(i~kN1JNgJY^UTF<n~I(~;nG(gtV<l~zGsn{jffN5v|s$!8gR|ua7ru>>_OGJ
zS)NOg)(l@`^9(Oz`?Iq(ryQ|)bKE(>8ue0~*to^O>(u2+=F~t&Tgg)VK*AoUNpKG#
zHN+K>(zeAuE%js3@nW?0;V5Q|7sEYmai`1t*ra&0?dD}>_C~yzsGUEGmBx$y+IC0T
zSMg$RZT4N(C_#+W{`Chl(eDq}*yIE;R=A&QW@{4AJw6{{X2%o6812xJ>?fpXTa9FO
z67gGiBx^~(KaXHT==b;tmQTNI1lyh{Mh3qB8|OP0y~ycj!{Q5Xza&EHZD+aHRbCeO
zCW(gbb?;H<o9|_^%@0JSZXENY=1+5c(aSo2yvh1<ZqKIAj3<8=cvrYyej|s&bJ6HI
z&@~XvTM$EDlGsAK@h;nv1cnAqW#^MnwSITm9eS=a71svh+3PNA(^5>(UVVv;YbiFb
z=WY*Ri72&1Kf#Llq#rxeQXCQ4d5Ww1YiGh%%SV~${c`WTHv?YfR*>{(2u!5FP6TYN
z!~o&mI5XScN{sP)b25x5bZnYcZ7Eky`>}6ZiK+fsZ-CgQYNaQ(76Y{p{$S?TVq@(m
z)7Z?`VzUN=2R<*feXYe%!MDK7E+U7pb*#Dgc5CqqPvN`n7$P0S=7LurGrQXXW95Yj
zW>%-8n4~Se$U1jKinTZFwT@zI?Wfm@w{#R|X|$dbSWt=>s;xPRwM`KX?Kbt4)$BH|
z##iI5M)W$atapu<)%bFrQj+RsDU9z4qaIWQ69Riu#1L)&@$3^Kn>?OXq=;d{@jNrD
z)fov*_OeEuMML{NnQ}SBvZl{*o6}b-NgL&)eQrtDUNkdHXAHGLnP#@Rv*;h(g@b4H
z#GpupZdLXEQUEWayx`h$Ivf)v`ChK{`(`uKbrIXN34W0)?JSz(3avT(r>y+bA8D*w
zOL<#cFY%wU@<WKl{0YmE<#rLbxg7~+hEy>~d+-kHm@4LLM~q>|@Z9mjFu9KJAiv2v
zs2zF&ElapQTaYcMEtS(!DUBBcT{mcynfawboMlEVnA6b6Kb`SlnQ3B3heM;~M)0R>
zwslL<2+%ELlWkN|o}dH_oNT0$t*4~UAI&5X(vBX@j)Jn~<y|tJcYsFGWZQu)ZuT7<
zDsxuIlh!TeNxTR@Uc{`KMA{Ym&nO}_YdB)hxnh5oV>3X!oW~OJa-VlOHi-@FDmDoG
z5VA+khC~mItgvby#qzs~E$a<E18c>(wZTfeintyq<+Bg`*biOBR)aHUtAn$$#0BH6
z!)+r|;Z=G0f@y37FQ>cF*58Qz*i>|ATqnASM<y6;^WYqiO}c+_Fg&_J-nS4~(oJlF
zi*T!sKe`-MnU9SHWw+1@4*ki&Dkl#8XG8daPvrdwO*v(xnf=*KykOb=8kW0wKidI;
ztXCVFQDmkZxlfH;K#_gr$a8As6p9=yN9L=<vng`8LQ{?GhDek3^-?^Wn!kRSqT8SH
zVO`S2kVe;YP@AIalhA33bqX4jP=31DICwFZH<*OlL78Lh(4izq2``vn;GIkt!_1wB
z^7QdMeO?aKTZ?y<8451?k~x&Y7TaW>688n-cF07y55I)WB<Sw#B_6Cv4>3af*L7y<
zA$AIQiKHp-n?vtI=fiw0-*TO8?12HX2p8^tzj11auE!7z!th8bSc~^>ANCNVv@y8d
zHv_u<Mm9^sZ}3-U&R;ps1-nm1-H|Up1Je;h=X2Fs9@S)06`#ovA2krJVdzE9EA(eq
zhG9zF5^XO2cbNE@PTTcu_GymT-M8*XYaIAkbQXxnc?}~#^ilWciDr!u{cAry=RuzZ
z)Z`^G->D=0*@6+GUhwV+t73#0>o*)+x$}Z|Uq^_Iv~5b*V<c-GDJ){77_1dea4Bfd
zq_80)#VGye6kf$_>Lj*#i4gaS<$kPaBn*NHDeQxh$l5i9eM`R~DNGoJ-v^yovr%G8
zZD}X=B0ay^i7lqz8J*Z}`pxXbu8b1nwH=Q!VYC<<_@E;%!bshS+odn?{gNV<IvUlz
zn)Y0Ei*rYdbp`qLll*bw*k-PJRquDLJG<v52Ypz2BjJtq=wQ9m{e{^G><dc|69yxY
zJ6?<t5)t@ZDu`}ayFHY4!6~dyNNEhK=!f&_$e%T3exSA;R`5%@=p)XwBgH;5hqlWa
z7_IZh8&Ccs$XjOmcL8!tl0pP40(FzqBZLVE#3!eR2$=}<q?o1%tXwiLM5u$n^5k@b
ze|cN82i}8njuh@z&h3;QsBLRzwI_-RHLXC9y^|Q99xjYUY~Og0G$Jr9K0P`l3d!Ik
z2W;gUn?B2{qp(vOfcN6l4Z^Q&%<K|nIgh}ziDIjItJ@$878|H(`Q5rKAt60fn1ICI
z3F*;7Hv|?<61xfiCY#w&in)rwt%USOwf7`DJEm_Un0XxuNr|959)Ug-Fe5O90xb}j
znuS0;1ddD=6NGPDo7p#s>CsV#T5~x|Tnj<Yy%DHZ|9z8Cf8cpb4M!k#bh=(hN8o9j
z^stavqVOM8_68u=j6(0WGPB!l!TNaweosmdt+BHeiJ3{`Kp1gEIA{vuj0;aC^42~F
zHR5y`U22t%*9?K<0t`Zc3-F(oX6D-t^lu<wZVmdy2;{a-57EEb611q-jQ4S)liz}x
z44BO=08T|<r7=CEc9aY*|DiU!(*m-8ngoj~4v4Q1NQy%NhY|3}6`MC)mL$`qHC)Bd
zutj9Oa4AL#45lROJS-h&HgRwGbmS#@1;r6y;VHZ%4ZhCd9Ivx}iBm9ZCo1y2fxs&r
zFeHv4u%Sb`p~i+pv~v;LcP5*ore>rE2_ukrvc`P9U_xMiIAY=u(D<c<2tEiL4oC0)
zEdeF38XF>9M8Mc7-Qcx5f%k4Kkx1}}<t;jeaMYp$5ug@LN(Sz~S~QH}7gpx;D(rx%
z<*Y(#2M~-`2!4hDC-?yZoZ#B{|0ehv#j6A#ySLS?6c@p!adLJn*Jq}ZZ0qttHOvv~
zj|BJO$~Yf!5L{;n?&CNvxctr_g*aYW8v?{z<SZl_ttIrvnbCSMm44iY>tMicb%9K}
zAdqE7b3`D(d$R_Cvw31G;gc4!suH#$u(J>P$r1$irK0DIK%mP6#B@X80mXz7W)^b&
z+8hMakaQk_sTA0S!16R;79((g0xuzOjRNfvct)5I1VXza@NY9S>wrMW&1T@g;8dw>
z{|&2{jU}YwH)5qdFkp5A88RDo`Emq!-6tbJbvF!<^XAK@+^~w>P(7|OkG|%6yHlVR
zXx`T}2=KmE(bUXdjKzG6U+QWhdz*3|NOSQnQS)zy>bqhFBL>^cK&Bbfqnl?D(pqv)
zmbM2?HEz;wNvXCHT0)f{XDf^lw-<8mMNZ*|CT8{}1wKTe&RnsDU_+q8TrpBVp$W37
z8sq)PR5n(4_a<O80m7>sh5%LB$CI$u5{X!~9^A(Y$_fI6n~jxLE<=E~@^%DxD;FX_
z^H9R5#ylgRhpY#0QGWLx*d57LdSFgZD0zQ{UcCp6c+K*Wt-R<N+tV{WM);_aGW+d9
zfOBa@pl+{pgKj+FjCXxCDGmWXmh=eFSc?2BmKbu)FwVj7EfT;A=Ge%Tz%Y)QnMhM(
zeZbopH4l}kXiF?a>lmvSmLcG`rBjG*GQey^@9bcqH==wSSVMG)6t(y1^kAVrqWC2F
zAjZt5KY>2^3W3cd&>0USaDoCG5J)>WK16sGfqzCo`3yziSPvw1LV(Zpu?SFYBRyky
z1)d+xccPUF<UB+7i#D?-uZh8R_sOxcrsawYDO_w*5Fpvq9S8{Om_@b#yPJ?6;N222
z&K}JYAX~vx&GvJYqG8V<KpM8*mMAwgz5zm-7HP7kML^cH2*{ci0a?=`AZyx4Ocbkf
zplJ~(8k`*>>_=d3cgSG{0trnZhv^6miolr2LLjMSMu^Z70b3Jbd=c17m_H3>_8G-o
zLf|gN96-RkX?ldN$bj}}9y}~qn1QImD5MQQV0#qMEfH8-029^=ffEKK-HtG`8wMnu
zL%@NUhC3r5qJmSY@)~Sd#YlYV1zp83o<=D^Y2%SC8-ZyH#ON+932iM&CGV8=U>5zj
z4Of3THCs*{UoG`vI7ZF_F~RqAI46=ts|V}BoLX#iLV82Nj^w5b#n3tyB-5u<$y%og
zREva(3t<AbK_HTpXCMMxi#`c6v*8ocqa(iv<0Suw(mn*(X266Z1ZWi3n?ZP62|S-r
zEPq2aq=z-gK%D!CC1b8=k=RVAja<hT!N>D!sM5j8Le1+IgChwMqzr^t5a_j7Z0hb7
z@SOyUHXI4Om)BJD{u%<^vRLelm#F!48yrHcKW`t*0*(*x;Rw(G7g7*7IvIg51h~ob
zB-qUUos5cofk5<>^hPyz1#>I3SZZ<LBTeUn3@fPL;c_)u2V!BE?rUuNk+J<1pVx=t
zHYaRpZfI=8w<ftyVp<LNuC6R=?&XH-;;q;$8+kySt*JR`{TirJv`TbAV9;pX#!6dY
zZ$XA8+h9Xa+)z^ZU3pvx^Lt-x82sBa6Rq#zsbfVzD5;KMG-^^zL4%A^IlUXwJ)r!R
z^vg&`t~kURoUso5q)w`{fYF4kfX@Vim^G##szJi5?(-C9zWCDnVh62qlM3@K7GqlN
zs6$!jWn({JJelDx*CH)5Z{x*7q|!E8J~3>Iy_Vz0#uZ~hby;A`i?MLB3#_zQj1oT9
z;<Pm=HoQXX*us)rn!U&qgEjI}otZ@(76XE}@igdHx22P^T=Z>JkSfH~#fDL%f+oV>
zb)Y{Q6%6S)rXl$c=EKDR=fOTKkSe<J_5J+uJf;UGXVr^9!r_r=uu&_9$!>slYGeyo
zu+fbRVw!%YcR2~htEugX@+f3+>OuI%_Z<-fo8)0B1?e|3*#;S8-+TE8IjRAoQkAIQ
zdUo%K80piT7GBN;5j+PSVNUrf+HoZUTszK1;91PLV6PW^6(!E+VZ_SwFao@ndm=!+
zyzS3Ed_3e(3ssp>KScsfV^zE`BnXGz<ZoteY*S-B|84+Be{oibWv)h;*8%Fd*XA&G
z<hZ!e{o1ACqA-h5BTUBH?wfE+Q(=67xwvM8rBExpk5$m>NXs8WDV8WpqAcOfU;2v<
zP+sTvy*yHzayUP7g->H+E_6wN-HNe{)S0J7c@+1EwcOSSF=z%95X5>mwoK4norHuV
zjV<T3!eyAhi<?=Z1s&$@T@>i;14Yuz5-3bU(w%0Olz@5vnq0n%;W!f-Di7?`=9W1c
zVI!<Y)Gd^;Pen$Wq-ccYC&2^8;Ovo>SZzHsvyZei)ZJTz(~5^jS`5O*X5a-$x_2l_
zGjMazsG8rQYD(u+YZM&_;a7`e^`4Jgh>5W}ZuZ|MH)$x-@)%2$F!8C0of%_^7e?sK
z?BN(oPvP=46H6a!c~K}t!)+UDITn_^pb-?Zeq?PNRcL_WhnuCfRACy5aN3LlnPpE*
zZ0jgXT=2;6<wLDIG_wYGFZ?sj=g=AGvU>%n*qu?9r2&^b;9>8XR!Cb+xPpTp+<yAZ
zgsYV-ZH4-<HqMN;oCs~3&r3}6a+Vm6e5ym|ir81^_}Ii6M_U@#z;UeJP`R70z&lvd
z&|LiC6>+#GAZk7*(4vNuKoE2qZkS#+BUl*v$i#Ymi7BEL0(oDGks&^hRB>0mi;<?e
zEQ={b|Bz~Ra~PJ8hKjA|*0Kci=bH>6Na|^wX@KHtLI*OEdfCR(hsD=kFLSVxk-aj5
z0dP6GTwRis^}S7|Lsh0F$<)rP1-dogok{%26kfv?SNCgB>b@bbd&q;TMYUIodhZ$l
zZ*R!!Qx5=FQ7{x}j<_(^IY$V2@*F`5MgP-7hXV?Qw1=utK7Yt=+!Z71??I9~qp7%(
z@}Ah{|8W_OMkQT2(C2gSiE+AVFF<~q?}^bmua^-zcTeo7`y2k};+lVmZ)kLnvJv^_
zpJGCjpK@tmuFPodmTN3rNd2n(b7vHeq;v}`KZ$3Y&;3&j(Vd)$d_MQZMg|6hh~~LC
zG>OU92M0FrmIqWlx>fl+LJhnxHjBRDPcxLy;vYfRWLqKO#~m0?z%BR1#OP%TkS0X{
z?^OeSGXucC?u#vq9XW7Ty2*Azp7Z245T2Ivc{Lu<Ip9cU1lQNe(E*6gcZ<GIZdyBC
z@@KC-5JSA2i*nyhQ#0D@X;||~s}f%o%m_3U(w6~^h4=9Wi>K<;t~`wHm?)2Q>`H&{
zP5Y?S<idr)9xUx%Zh+T-snp=99xUfCF(RVZWIl^}p{tU|!$5QF=deJyCpY&dv;QRq
z1~rsH?fAyLb!HYom~M-r{n*97M1$_eB*@_YUt$NHNTH;MVj`UX?K}Cgu@A-ex;Tn_
z`=J;WlJOng;Z|~sWau`_a&B%t6o(_%@DxAR^^w@MOX^({ETA5#rsh4`kyHHjJb7+~
zTM4sml$@H2)bTuZoSd4&Q+0Pu?9?L+<{Q78*zHGHdzAiea{4%meIJVlG)b<mN#)b$
z^>Xg}OshH8C-+?Uu|9XbYj=%;cFDc;J0A4jcwj}VCdC#9J`tle$}yyUl@s+1QgK|a
z@V*nd9?vq;_K%pNQ4E^mq6J;AYHC4SEkflXkA2TX|Iox=sBiczru{pU&0;iJ2V>HP
zQL_CL6K+d{_F9g>KhMNa-3Q~4Da0Wr3hfcq+kvQ&6gAa>Ez*PvCOWW%*y(2zD?yU*
z-p3|(9f629KIXk|4s~%_tGkVb66k=ndZ|TlHyHyP?u5L9D0kd7_e~!Rlk{G~hsCDi
zE0f0T*J{U~WsT}cWBm=;<WH~ttNZw7QXMI%A?{Ob?nhtL!_En9I^uT6ThvYJNJ+X+
z2ZCQ+U8%8dGldfBN>SR9bF6<|sh6$=#k@mle+)wCVqGa)w{-wQ&Alaqu7E;)yrl$P
zZwf8&mbxdpny-p|L9PdfzSh_1JhtPdkSp&HNf%7)p|{jgD8WS5x}G#ih(%yaJt-#e
z*;SKA#UR-r%i?|%bgzo5CiWdtg^v*M^g-Y)1X}n=kqu@8?<!k1U2}Y-S~Z1J@0yAy
zH<V0TZN?E+94L*CvYAOvv%!q}K_Gdj3wtmx2KlkHASqru{0N&KB!z0b9ASU_CHi|S
z8|Y-^h96=3f}~jOqr)uWp%|R#mUIc%1z|MpLwAy2jKJ)noHU{%C@5flupf&Imfq;w
z3)-e~t;sfD9v_|Qk>PO;mrepbijWuSI35#5G4GfP&h9{rY`ya$9I*mYP|ms#=^JGb
z+zOEz>K+==E>A+FmcqGnCYBH?1vX0A!@FLf$vP+zw6CeO*Pf&JyxRLT&;i+O#I!LX
z#%z9u=HYu)MXS8m&>x?<`N~AA6@1v`GBBwhXlT?lpw_j`!@()+JpJj=7r$p>mqMjD
zo!A-7Xu_n}(0Zlv0NX-^+g6kE=Bn*s`Q-DgYnT+TYeCq&FsY}mX97Z}!=!|iBk6oY
zIgs}rYZLxcR{pjeOA^86^I`r|R&GPAdw1|CP7Ig&XuB3E`<fU_|3D?@U`@0I_JWN!
z7a!v@57NvnD?{tSa$-&0LUZU}+;3th4N{o)_x<da0bS$Le)f!h5A0{5ky2>KHT$XY
z=g}RrRbGj48w|YE(?|J8piaVD_SG{cHZxKhXlxCmtg;w=04F=q<74UZ2p(nq+K?Vg
za4gLzx4v^m`S(`UHi8upCAHAyw1@CgqohFL+oL8nEDD1*lA<h8QiLv^Or|YSQn%*f
zcF4e*nT-RbSR<8{7pIb>T?b6J<5{&KeWN8DK0jt+t)iu*`Z=e-&@m@}eNUO#%h6IZ
z-x$QZ<WEcVURc!}H_7`-vyM}F|Glp?1R%bz)DZ#fD;X#kwv|G)C=<I%2KwdxvJwQa
zsTA4Z7)+_^drGCrC=Y<!F;Z}qn*-N%>%|ke^T`hgzP$STLzC=$x`6<9KAk||ap_ot
z*TxSyd93Ydn+CCb!8IHKzTiqnfEHXKvB1Fr;aqU3J5$~OaF^%Z60pO!X%LXNX-bH+
zyjy@cBHVNe;y~tk@7(|nb_tbN1i6NGP7ki@D<{gfZt4$R0-K<NLB!lYNn3YL|0KNn
zpCgStL;2`^SQL=^9=&5{W64ls8IsUirTbpwaa>4!k;sMA9s#}v4dn!Y<2x%y6p`FO
zfQ#e|0^F6l^+;8bI9;jBk-%N4ydc2+j05yZ137$V7Wq{D!E?5AyAe#cle0J%%G^5P
zj`+IB&wWFG9hN!i@#W$FA;S-mK;^oQYeR{VF2E|l%bU-TP+f_b9&dZ%08>*;g+K3L
z6-}iUT6Ty9G?O}L=j~wqn@OD`I_}_Vp3h}fR(i6_t$1HEsimg+>8N|np_I>dfYfWZ
zkdpnT9Ia}+W0gUGu}(nTht&c5S^!Xk03WxIq7!SPLb9W0{v2p@nB-6z3pOb#9!L7n
z!p`{X#U>UOC$*^A5dd1#&~Yi<Xi^B1<D^D`Ba3-HJ%+Q3*o}>3`Zi$4;-t`;YM<d;
zeANyapTtRRefn>7AMHiOxu;%Pt$D%KRb4Zn^Q`Tf4OEtV*7koKwSDstDz92*E(Pk)
zKi*~HXE+7vG6IQG^Tu7bI2<^8IUa@r=GT}SbYOzqXgDU})J+e!nb`hBsUf~K_Tw{O
z_GzLtruvntEHz1@12Q*i`mvEo(op}@&oLQrN|kF=PUOL{&m_CA`ywC@4g|RSIt&4>
zK^%J(4f5??rMJ_@ffliRSZzjt=PX3vc<I<+O5qv%Ai(|JaR~4oMjr(D4&xon-hAM2
z7ycd-d!^pEkUDat;wpfmZGwpZHTb7<u-cHf>VPAV;T$C)z&Q#+fY;?;%-zIN$W6@e
zaBow0;yY1~@E(mygFCDM<TO?yz&AhUBCw|=Hcp2tG=we)cww7Vi(l@|ckDK??Cx-o
ze}@3~=6{I5O{sr~U`OBx`S)K%fbV>~h``?z(}`k)VIe{|0`1cg^A!DISUMcq-yyK`
z{dOTjDFTd=><GLToDmY5zl&Gk9$DM8LF~mVpjiEoLXbuk0&>VgK!9tzr#lsy^Rp2<
z6=ih>v5@h9E2|xHmTJnXtrXbqr{-kq;64kkGhT$Uka?(nu;VnE$u)qWYV&bqM=|XZ
z+e!YlceGSa!(c;+PQ#3BCp8TD@Uk-Ut%I7txHItG2xx={D@|;5JE^H|4gh?S6S8k5
zL46i?fgOcK4$L*^LA;vp1*zU`Cxr@gk*8jJDO9&54&yw&y_BGxwwJxsUJA@keotP@
zZzSzvJ3)tM)a)Z6XChl5CrL!z%GS#WhyF?tXK*ZX(O#u{(%~W#y9nyKpIe~3%JxzV
zVM>v_?2hjsg+wde4T`{6aHk2p!dz`9zW_3{e#%aBe8nQyEQn>|)Qw*2{_YXa$~s8h
zg~-LIMn`FB?S@U9ClB)rrux_Q1*fX?i%Wsf2|rm(#hIy6nMV7{3g+Kc>f${ll9meH
z_R0FPbk)=VtfgB0=Buow<U^^kEg$%@-&ReH(0MGz*F$_)<8W2lDufbNPmR`HUxCn|
z)l*XgUtUC02JI8@bKBg{KN4|l&+4hMy7m;hx_WA-R<3p@#p!-nj%FK&zVCW&JW}CY
z-`9HE#Coim+E%!@#l-U0OigY)4Mr_rI;>YQYhiL>>43Ah(2+b>CcxjWnHpBJIlwd<
z6kRL`)NV4#d;70oia@XPowHz^pXa-{wizX(k#Q@j2>rHn&Vok5o>!ny=PVc&le@z`
zy*7k}w+Cl6P~O)1-J$RDj)^7CU4XC5Ba3P7g2fH@z~bcJ8KJAVeIXPG89MH#xeFqN
z!E>P}URm&ye?Ay<TRA!Ojltce3`yTZT)?{#c0JaumsJuS-`sEKZZfQx*U9UEn-u$&
z91E9@y4c}IH0!Q4vF1i8#_;nR_mQSZTs`)<bfXD7ezw?<b{k3I$zzq8L<JZD*lUy;
z)md_aq?iwGJc<oV#Bo~P;w0u^)<Q9~>6xt=e1GUGW8p^*JzE3;*}T^y62>-PCgGKd
z0>r{;Hr&!oIIz=H9QL9`rxEHTGS+2;rC}RStb~zg^*b^l90UcSu!Tg(vo|7nx01<U
zT<v6J-5^V<5c;l(bsJ>au3PmFzBKatAWN|B!4rh)4z@J+`x2qC=|10_9P9Iq{u)Ia
z2U|jQJT!i=B~HgE?#;m#vu*-~ejRLCth@I&Lb=(N7R@dpG`73XH(|fZfybvo?CH%v
zeR9t_?!!q#iPQAg34b=*(p>imh5pL6G}FCDq39u&zPj-gnlr>=&<&u_#vzu2f$u%$
zY~B2RY?@E*shvc{yFKFAxS^JoEhw?O&&>xEoid1?(tM^}9P4xQ911@34tzePm&W=`
zi~Hsga-11ziPxQ{(4(Q2#GzjzG}fo`bEJFE<>6_l`^__;^$kV-jS5u$Nl$UhkbEEI
zpW6<K=l3A4a&k-}Fv&S`M!2AERuD8c0uiiW807ULg$@kE4uKw_;%|mo_G^U1CXB5Z
zZVApP*+}ij_Y%>5>GOC;cmt6<>b67Ql1J%B@u*+vty{cB{<F1O4`r#V#ZE%vW)ril
z7H74&_JHa%EjC~NjZ>bJ^Y3#(P4lez7YBIz&@Y4*+YkZPY>gP9JB2)~*BUWM_sgFM
zO<W@;=%OiZir)cCLz%#rS0I#W7m)L*_XR{1w_Gc}t<|-SM*ser;T-F6=H4xhFY{`x
zM5L_k_`K4R$9j(9v3Pey?yNt(?p`%0oYeK$7&K#0jae_gqI>TyIQenC_`WbJQXUCx
z-<x91rvI*WFK|g79|wmK={649FQx&N`w|A!mJO!jO)ptQjgS+;$%M5oU+qp|#tcs3
zZA7|Jh{5=B>Ef|Phc=20G`hdTQ0-@1MBIw9Nvs*tc9lYikL_C1kww)LENhdvtnRAY
zvhX+Hm;JIy+*tQ^1;u>h`6qsh->{2qG&*Alh@KP0&=yNq$n<3S44uklISi3*x}rN`
zY5h~|D~TUybQwV^N4GYMHG>x0+&LON*`*G)h);C&17&cyf7Wt$T+}3RUR0d;wiv1L
zt3!>2H;ix#3|?|hE-<l??}#%y`dBGPr8hLuon^$)Ra6>H$rb9*2`H$JyW61r>1wCW
zWWHO)a{qUJ;IatYE&s+X!f$ciZQ?5$|Ayc5q}XuzH}2srByHF(j?g4myzVUaEP_Td
z$j|mH{K27bJEnS>XC70T-JygN-xaYt`O`Ffd3L9`z;9ZAk|dvOp1~72A6CIG(b8)0
zA}8(E2v)7qmXX!TCq7*5V5Pgn@xnU`Gg$N8VjKT|rYN#{KV~VEKivKUO~tczi&>hE
z5eqo+8aO%7tMDn`L&F%KjxQEh6_n%t>MGtUu)l7PI8GQ-kijPIK^Y&Sad>;EW$fy2
zDt>>DI9QYZwdKFcX#QgLGLHO#GSr@ltKxlpJ?)>yc=-6?h7Zg;Mkz1|AG#K>nPJ5)
zz+<h?l7pxXZV#yemu#d-YS8T#T&zBa?m_D7xQ(}HF#zyI`Qk>A(?~PgG7|ass|vrT
zcg>rim;8K455D<ln!K0RNB>Xj)HPH%X~|$G-+DJb+XDl)Qn&d0Ebm3%_^d4@$0HnP
zc;_pn4d`K^hjk?xlWCa!D!+9NMe6%x2QIub-l30%$~+MWR`@H`4t>c26ALv<je6q~
zZ`k{ktE2H*azw7qPhU|j&e{4p7CzDXETrqn!2fX`i@N;_YXC(qvQj*KFRGNPCw^sO
zMP^B#Wb@qm0ad9xeKW*!ogY4XfiSA7+zbNO0X-rv5a|W;GuT&VDPAa@VPZ8irEp8}
zaFSDs2a3a;32({Oi=*mYz@=*UjE*|9>hRqFhu(h~Uwf9fzPlRMQTTj!UF6&vAvdPY
z^K0z5I-5<Y=b116qn@EDB9BHz&%#V_R@9oZ<VzDP&6Gmx+q|c~FE<+A#`b>G7men7
zYDcJGel3F?U;9$LP&nPhI`@<UhTi>xDp9}}@;-|@@-}ia(&=jkHvNM6G^l>%=41H>
zePKgd@vR4&d|h054E7C-*6uN0sJYjyT3DGm^!En9qUtF{SS}2Z1#sv$5`gq7HUz%O
zta4U@IzV}V(Zgeh#%IxI)MB`i*8vIhE-X0Pd@?wFzRi2^ScoEJRTWXhBOZO(3vKB=
z>p?7bCVNS-5!dHYMR-@HFK{44@_G829Gl9Hn_dg-g4HGO5ILkdjSjt#3sU%S;3@QR
zPaZ(y+pmz^Jl>QWzZ=QzCyY!CdUmguG$AP3%<GNav`m8J)q)4Yp?`0biOuLO#cAUP
zu+6>Em8L+URm?zcXcziMUwR&%U%@kOTZ1dUQot|Ixe@f7WEzixqkhqEc@4R&3zQ`O
zP!~y<{mSzyN!~BMQoX~uoMw=F6ZWi^G%V;xqr&SCCbvSSj8u62t)I+mT)(Qkdd~bG
zyuRR0=GPJKyrwBhoYzm0M7*}X%?HQa>b&CP&u$)JI@ysQ*QcRo4BI>`FF|vheLgHN
zGH@fNMo6f9V+9d;eGZ7o&5-|r)JRx28h(bOOa0lg4<z4KZGoMMPt?p)t_;(EHIDk(
zFu3W_XNSz@wXcT<WkaS6TBxAS6n)5DsBS9cZaEe5HGobn%yJG%MY?l$(ZwDdl2Ubx
zDAcYP`r=uxiA^Y$ItW3FOl(`R6kE@)fI20nFPx#k!u;!EslU+9j6I#h(mO(}*G%lI
z!`MgLg;M>GNTY>2Q!(uwk@}2%b|)73@MT0;Hn^)5Kkk=qe3}6T9Im`(>s$T-z7|$l
z-}$(W9?{kDjh<I=BMFUDM;2AMJoIO(ObzrnSz_ys^lC2n<-k#Yq*tea4G<08NaKYo
zSMsKi1J0p8{u1PIq*s%M!`u_&<wVO%Ea~+;z2%<CQO~LWq5)j^qwZv-mVdSn*Us^o
zVfm~KjGh`$hh&GOtmTi7Uc&&d15P=G!HNd`ek?#{hyHW2?v%8SO4=Dpi+AWhkkhDg
zzA0P_`6^<5hY)nL2+vV&!`W-9`r03<>K0^kpO5(99k3udtraPNQ{0F=3*)H#>LWfN
zO$DdvP&R!d%ZqdaPCno?%mJ`X2T|&xgJ2!#&=+ET{J3~PBTFFcNQ~J|ymwil`YMw^
z)1fa-<MH3{hs>dfzeJaDQXl*ox`u{1f5=7_>UHaXAZ{0cnnV98*``jH6n*yYaZhU+
zRF!vd9%(T$=F%LusCy<uk9l}x(Irgu$svAMo#*XX>Oze<_WPqab&5Q=_HI5{QtpS!
zIi1}|Gn~d)D2u+^r9twA(bY!H6xcq_QFCt^=NLWgrs58B#J(`k#HP>6Zosk%GU_&b
z1^KBOuY6C{7>ycoxBsPM(yKLW$@Xq#j^cjDrP-Q*j?<}EjH#vvaMru??D-Am!!mXM
z-c7^lrsC;cW_Q!HxCRaDQ->sI?G#gPMt`T$X566CUciWV7Z)@1oBdJ^yeZuUM|c+Z
zo84L%HO^H0VZYh+G&Qu)qtG$8_6!a8x5d4>#2=$9F8xOmSZsV};Op-l`lq)o?&a5c
zN|zrn(EaueHG~eEoZ(UVGn!x`0=x;n<Ey2&d%#cU`{!hR@5|Znl#qGD@2%n<m=lPC
z%*uVPKW8@L#;x<;$9f!1L57Mh&#LYoP$!l44~>p9wL-^%GONiud<}=*_hpku_NnsC
zwV1=F4!YrZR7bTH*`+g*f2aCAqNw#ZPa-zIcYYaMzoQ+sK8pP<J<9Ea;eH+6DdbG(
z(@Q%T)B1!yq4eALS;xTUFAa9D81J<`5k*>k<2Cn+L9mz3N}>LNNOe={Tve|tgQv25
zkcmZ<N#PC3260cVvyYQkE2~UuqRC@(%cS-Z9dKC6Xw}8^)Re=-)y%$Ow3h6EV+-Fg
z?9u_P^m&;yQ8+&k2RYuKl4+VZQ0{!6d_~>i16pd(BrV&{hmJ-nwzKSz3<Mby4dE2b
zOecIHe#IR9a=eLMJ}0GEHjO9U3k_Z#olaPcT8y4)=;6-E`3DRL;!m}PpdxPOQ(Ip%
z7SI(CbfDnW2`?f}CE&njcS=<>6x~8oS<9jS0wgK2Dj~mhoYKwmvtLqm_F;At&r1=)
zFFoP!J}(7C*gT_tuYru*bWIL<Y~b9c;v2X?Cz{x!^U~-Bn{kQ@=MOwcXk?YF#5^<g
zV<|nnFRT&L`S@NfqOV}#gj&I=jE5e;eEu=^px^FeVs}24nhIUe2MYW;`|Gd4E|9H$
z`JG72!d)@zej<gWJVskqws+{uK?=gEjK@E&^&({2;rwA07GISOa7&_$BKaE1lW()q
zdA;;42Z1_`=WSQ0#zlb8($SVY;s!<tnQD&MnJ_9`gB-6vPJKDd552^_j`t=r&7`~l
z;RJ+`liww{^Oi)JZhcPoDH_~Gg4Al&uRrM^clUI5Yf0a>HEgl{lhNbCmi9IFb!2fV
z;KmYJ3NCa}RXfIg;}TAAa(&_q297zIa4^g^%>eCCzN`mE`Jm6F9zr?Rq2gy!ca0DU
z!T)kWGSyqYJ<>xv*5{v-@M~cawz<Z_#%%OOshRMw1vb?$O3nSQVS(bDMKYl{*~!Ko
z^zl)>smhM>85g-~#Ol(;B&v+BcUjvxV!xQEC}`hHQU}czmU&5vf}Y-#gqqI0Bu#8!
zxj@+`pbVFKxpzrQ(0s-WpG%R!wzvu1>tQ&Kj`6AtA6tY;60T}GZ?lRG`&=^DDgKP|
zZ+?M1JGXxC(nw=;O*XN;A;u~u+HcVA&dDZs7_S(sGbt~E<<H92$urE8K5|<=`IIRC
z1Q4HLaxY6Eb^nHOJ9ezG{0Pz*yDT*pYQ$r(T$Z|OTjBiC6)2VyEdB~Maw8K^68c^{
z{;9g#<#Soy73^Ph!q|WNiquNjgEh_9SEOiRDFTiwQiQgpi5b4YTaB-R>9gHq>U)fp
zFVrR~ewfLSZn38ZunAvCu~9>)=kifr&!G=$Nl!P+k9<rVzl}6fbNAv>^$prWW4TXs
z7hf>3YhOrvTD&{}31omA&*yrh9wZ1KeO_B4TlmXS{=yikqqs&U=ADol(oIL|<$7CW
zqa4Qx;Lv}JXKrR;MOPm7L^g=VoF_i|U`}#%3E7M;?J%r)gWzfg(e!T}Y;)=`{|2kD
z+#v4(Mku#^e!v>}T<WlxasOcCqYKKm&s2<B#rAo-F^`vRpZHY7J8hqHau(V4>4+>e
z?B|^$#>QaQaOi2Wsm9*AtJod7H`By^>pC;MA?EAuo$K+&N3R1zbS`xUn|D=e<JIvO
zdD>v#jY|z=pI?=NwAx?TovTuM7nBPT_7qygm=^x4ozZ{<GY*y_>0t+2Luocc`6|3V
zN3HhcEbnJX;{B|2J~ri6UxGRC+k7d!?jJF7k1GU<1z4nT-|fRPJkosp(i3qA(sS9c
z43=(@(z3rBN{-6AaJ|t!Ks)HUw6p0mG^VojEVLG`ov-X(ky(eD%s-0MXAM)~Ag{Eu
zJ$yA4W3fVn-TXc%zzKl<j)(31AqZbp{LUgx(51J53dziuikfczldRXX{4&UQ&;__Y
ze}Ll1bFf;C81<rw=?ZXMuz4qB99STI6rgX1W~a%H?+bp^v+(co86ilFUm!ILdJ2n?
zYwv}9d5dC!i-vlL&N_X86eN6{W@5Gll0lo$nJ)|2-8Z^45I#%C*~tach#Iz(h*;>8
zw1tvcIG<`_Z!DDh=<Z&_=GpfPrMAN9P9_$z2xE0*cN~siBz3er{oPfG9(=uwNvRLU
zJyjxEjW`Ztx}q_j_Gu0Z6-k(6jmJoq_{)b|Vee%~O7)DLLL@w6KW;}Wx?D+H5er|@
zF&+!I!bVsOD5B1ywQ|DN?Iu=xu@s@Vd5?IFTrA6D@+k#(-u`ItV4WAkl<7AxgY932
z72uF=sM%s^Z>?$DsQ(_Bge|_;C4;`%d0Nlu8xP3vIQ|-P!>mU==e;f^Cp;jr;xc?R
zw9*$aOQZ3JXIHG`$WMA<%=E5IsWj7trOa;^#Cib2KCw^=s9D+1p<mw1#2PG-I@GI~
zLjB^^m^tOMDk0cmOQh7C2CyjU-Wrqb*g23Z|HGen_x$Lhn_#FM2&VH^H^I!D2cd-W
z7zpJc1}6shB*b|kj(mm?z|}I0fPa=q;lk>E87y=u1h4^3+iNMdgWFQmPFO01G(YzM
z4JjL~2Q{<gUb8XSgzjF^1NsUbx%WFHtgHzzHJ9SV;iV5TjBYKJ0-{p@<FcvjsETN&
zmK*(V0prjw&NQ*$LMg7^7(7;diNgU7y%})>3#AhlLsuF@i)p$|D_kq#2ldYU%&p$!
zDmB@L&q3W+Z*i-;&q9(2>N<tTqW-OO<bGEm#}7n2mjP}lodZGG@Q$`y$5`~8!NbV9
zEXFkp&-y4m!?UxA{eUi_>lA|l<!_Z@d@xVZoXtn40W(a7RqF8K6<Frr^UfzuK6%Z3
zmefHbg3-*)RT%w4W+;}&g3&K9$I}40!Q;cc5s#K9894N*O>s=aD)p*w^W5{Q><)zs
z)N}W@)Qy)*!NP#v8En{cseL`8L`>wx%z=Lj19QuA%z-P~LeVdmIvB2t)LIW<uA-pD
z5>_jftI>$Nc=Qbzs8Kd4-lD^#QyExUztXo7{uR2`_ij1eL075cPgb}R^XE<X$ip4S
zn1HcL#L@}Uz)l2z{1Q6mY`5uXgqd^bU|9ey_3>4a!}+L+^2YAwHcIbM`}Q?_NUdTu
zf7@Dv_w;O1f={}ejED5a(U2`tm=E$9m768TA`9#A2HxIY+R{yJHR=FU7qN!A9$+IE
z*6t}BvAkKn1xl&1uKKj*cicbzb(+60#viMNH>9L`N&Zkr?{R6r0nO*PLJIJCwLK(}
zf-h5p7ieYX^M(}St4((C(AgV2j9ei#&3d;1pxC;pB}4P)<$Ay~V4G(sFT=Fp&Im60
z<Fn=64`>{G-5nE<y7H5c9{f|D_ZyZ*Z)G<Wx;2n3V82EnPgCqVo+%$1$j3X+Ojgmb
zty1$~EH5e52dUL2U1r#m5vqmwj&H?rT;L;CN~ywD%seByObKKYCye$c)2MKz)VS6i
z3_FMZ7c2;ltdyekO<T)U&mSa44<eE5p46MYLbcx5%vmM%79J-l1jm3fC%AJW2qO0U
zDiGWa1?kXlgT^C*nH4akh|R(SL~te&mCb)R)p1uMZ`*lZ`5is-{M4m#fJ0wd2a<JP
zJ0E~)%)UMLVhrnDl2%JNiB&?4DN?8K1<ESn@_r)!A?y{GEXW^uA~_%^8N^iDH5{?e
zprGaBgUt78MjK%dI5%C*h-t7SNoKV%r{xD)*x3wyxuK>7cW4S1P+zClByhJP|K0nj
z<aJ$mlVat{?(KNlplL2=>F%B-JW9zD#k16<EY4Lln3dK_{cE<bi_ZjjX;_C!YnZls
z1`ApzO>J-neUiT_qga;1A>E-rj1JY-F|j#6j1FtwI1F+n*PPMzVN5<cTlpEqlXh$m
zv9}#ljk0U7j-iyVYs;lv|JE9=Q3@FYRpwsEzg<l1sOOkaZEdBHvXJV9Y*h*w{vH*Q
z(aBi|%ULf)8=3||@L1}?4+ode!}6vu@e1+!8~^gmntC{~>pdob9bGR4bO|cvGw%Cc
zG2_kx{|>z$I*wx4dEwkjJ$kxXesDLHw5g-J=%|O51}+cQ2I4h^H>DvF7n`AWzEHsE
zc>EO3Ixpmwi(QRwd?Id4Fsm0iruO*dKyn{`6?ktKJkuKh_^$A-(arKkShLdlY|k!Y
zVtogy?jkTtvq{zE=sQ&mb+oNPV+?G9!kjCmA~Y!!Xl>BNxmztX2ptxdsr~nBaCe$0
zufgT!NtvFu<P{g|vC=$gT5v29dRZ-x!5WTdf#?cu>V?C&G0l=Xg<OP5kM+O%Cq<kk
zNwcI4hF}1CSziVL*le3HBtfHqKlnlcRLo=}0?bXqFE`?3_ySsf1=Gz>gx>qIv|m`*
z+{6aVmi`u~O>&o*8vA&rz#+5vd|ofuQ+_EKY}*o(IR`zT9D*?aZyxpdctb~rej?<I
z5-S%VD(RuqQQ0w`E8(Q``!x7!bDde}Nsr3yTUV2nPunpeNUyBK2a=(-Tw|%IIH#|)
zRwImqo`2j=YMd}!NA}BpPQz!>ORzg!C8t3<RP>aih-45J>Am|)VfFlwi8@Ud_60q0
zbh5t`(apaDJc%_ieMTeje|%jBTvW&N=k9@`fPipRDGCURC@3lx6m0iUK#W)-D%iV%
zVu=lmq9UGRV=Xb>dz!=^TSSdfV@-@nG%>N)L_I`f*F<CP|DAmg?m&NkKOeb$TW4oy
zXJ%(-cd?Mev?@7F<8O#{*v=_<U<*)iT|}96U)Dyd#HpjKn;S5fu5>rX_8g1}SW*lP
z2t!4!whqVlF?_2XYe3&Y1QqT@N0nyX0?e+`05#bO$@@UyILQLMu8W}zs{&vpN;L*L
z{7yvO%dBe##<nWe7_1dQ@~Oti+7G32#EqmpK-_8YPYdGMW1Q&LebkXILD%IqM^DHM
zX4XB0?CG&+W^~gnTX-jfDG4hLB#i)75a%iD;ZDq*l2I0P=0l6Q-oscwtg6CXe>9fE
z(77I9z^fsfv97nkQ0%gJ=5UR0CKL*H;mlD&e*{VjXAaT+WyeyM%uEw@VlcKZnb}Yn
zj%D<XB{Thnbi0J2r87g_?V>?zr);6I(bUHj-RhITS}mPf*Y^#^GBN*&SdbcQUy@`&
z^A8~jZ2D4Eu^EB2OJ{n8Ee-+v>!Bs7n9iZ^&*<BrYu|)>uHf_+>b<sfX0O)sKPm5x
z9Wr*9|96M^;BI1mgW%GyNb{w!Ee%FL&*5zq44S2%I0oIvI3aXI9on6EDZ)c9FuS&b
z&v?c9NVw;-@NGl_tDk0!s$z(6{-wyw2BaCYnqLO{A-)7BKo6cD9M-IxLp1j@3MP>k
z;atFUcs{<=ar8$;)%qIeM*gxP#O6?UB!I30h|FV4C}sqYnSvMv0xF7Esq8^NeT{Lh
zd0xm0KKR=z)%}A-Ms{u^4DATH7}+@p;Qjt3{9dN^!x=MX1OLLP&VFg>fGDxWG<)Zd
z`+zENM$-^`W<95(j*UP?u+pN5*N|Ue_I#elJMXA55h%Q2`efxY+A83)615P$egsxk
zt~#+DJ#w0R-)TtJ^4ntmf7}-`>U*=UCKe)Kx|tcq1i=G}L;Nwl&Upet#6FHOf*!jT
z8O9AcUR0R2ilWR^FsllhX~Nqq<CyT9H-~%#lq47?;T*Hm+z2XxEA`7;dtOsvXU9ux
zCFCFHgts5hD1eD7tEUc-U5N!vtU3qdhw0NIbS_ruoiD2AYz*UNMIqhA0-Eq<-4;-g
zMOgS@&XTZzGwFilV8;wJPX@F=RLG7jNcM7$#(@Sv!cE_quSBNtjH}J;3zF*yK5s=9
zQIMP>ocdQ}xdq9%U<stWrXbn3>7sw>sQ?hK>EC}j^_zlMkeI81wk<G`J*7-z-Ec<L
zSSLIcxy{zKC%rlV6rWs9C3ghDyf)I<*yR{#T)_t9OEa?WjWpJ2pn-Y|z5XHyz!ZxG
zusC~KhD~-n&W;bKEzOuj!?fYb&Sko@m9GERBZ0LXWef;jUt%_&<Y%Kv-=9JRllg<H
z@AI#LKdAbClP4luKFS!?-250XL>%N4*B3BBy~j$IOmwMyGa#9dU1!iqX?wG-rIO?1
z>{%>R81L_L+SLMYmHSvO*B@<ckTVul(iZ1WAW+no%kSe*mI0BbeA7E1e$ILRE7SI+
zT!%oZGFhym71l-ofK|jhO0mNOG-a(6|I#o43nz<Ke9J}Eie(pt)SoV)My>{0k6@Wr
z+@loZUA{RL;txrxYQ;B8;sZ5~Y*tQoq!tpiT;*-n7|SIZ-p0JzT9v9*oQP*V$gm}Q
z2sqk*SgrP2pTJ_q8e6-I4@H}ynENK^w?wTQ3qh@IvnG4OlicXv&0zQNHz!QvIl++-
zYsmK*Ey@jhg6RYzKjHY9j<C{n63(meIq?;qkT}_1)R4v-2O}BHVwVH7e`D6|d?2!%
zLrEcSRN6Y>BP4VhXAJ7o9k@&=@IXyCpy(3+@{|V78V0An!8Ez|1k>9Dru37bCOn+v
z)X+NCdn*7iJ7BMfI?5dppmoQdu1hlbIOO}WamMhPZTvYoAR{3xZt*g6QKr$|F$@8)
zCnS<im}v}73v^KMadQ#4(q2)V{f{O)aP~ji><D!B%^vD3p7lEke=rbQV*X>;7e$Tp
z-YIz3DYGMdA`pwIH6!65P(c534^sdeF_>oSGI12~`&F>|9LqF@*O`itILLOEsQJ!(
zGofGxMrnq9$xdYFbU)86fw^QE>)LvJ3*v5>WgHyzdgXgclnzB%C}P-#^Jt2>oCPaM
zJ~FarS;j`fF03*U<;7yh8-r{g97a`x#~WvKEeIm~tflvba5k5JL}G&B<3s*2TS-ae
zA09}7eJxCj&YNm4TxQ0H3;%G(2e;`49&bu_L45MpNi*9s$k?q76e`PA4;2~KyXV_C
z4<bKE^?ds_d?=^ZhYvQEoo|2V(0b-DV=ut~Zh3kb7QyGiKYfQAo4J*OD;&-M4pk95
z+dF{`9&R)WDF{>@fn%H}-iWOJ2xA-J`8P#u)Cl9qv|gA4(3zkf&;kb!0yg6&5-}fM
z{N16cl-4b+t)|rFDSV3tiOrBmd~R+YsU7N$<Op>UmW4=c;=-EaG6}4;oZ*)ELoZxy
z^m7sj-O3G}FR!qeML1FGg&Pat6QUS@_f}0{w^kdyYY)5(wq<2TX$*N{F{1<@RN3l_
zTcTn{`Suprs$xd*2N7{IiX-$rGNb$p=~QM$sj*aR0pX|1?8q8pcuETtCL_u!C8L!Q
zrPrm3V3ZkAa%R&c8bM;O67MwGeyxh6UvH`+Y41%%B-Q1GTxvojePZmb)g&+}q;0Kk
zT{Q|zTleuhR+MsnybMag`}pyjE0y^1QOs*Ac6<&h(4@7-SU(%3joY&b?la)c7V<3P
z#vM_Y6*sPdnpAGQL)_S$z%3CshSXG{ZO&_|jhb+S%a*}`T2SM|2W@?s;dEPfQuoVw
zcFr!0I<cT#xzzY4&J`Qy`xh2y3QJnSaAoz4hdW@U8GA#~W<YvrB_pbU>jAc0&^&IA
zp!8(x^i5T*(o5R5f=SM*!jd<YzDr??wNBpx>zdVf(T}h^UBY`y>tM<HPh`$UW8*5j
z&A7!Tm$^RIdkJ@-(KMjIX#{2%jrFSC#ZuC&yNPxFmquei<GMUE<iG)fn2U}<Zxx!@
zJ(F;<7WpkLl3JCUnq5naneH#4QJ|JL+WkLEqj`wrjgCa%nuJE@VoIBJxsFPsIVaJ=
zq1+0M3ec};AiB?>Mq^0~mK%T2D2YpYbD>~LoTzza4jBw3z><MByep<Jge<mBFL?uJ
zg|Z0jA{3UaakWI?TQRVLOO`W+51~nsfz{~^G3Bqn1A0tDf8~rpm=Cq_$yZ743TFTg
zS=M@RhF{KAoRacxYtFEIcbS0|Bc>QwFO_qKMG%dOffb1423EjQ&Kb0v{VOoE`Guuy
z0B6{AQQ-{Ll#EuK;ndlRV3cu&M^g#6m#P6Zl{rK9t}^rLMU^wuMfEfwMZ8dMHPyWO
zx2Tv`|5j3+ky?gUSoFCADL1bIdEC5;{0dS2W1){bz@9>s2+a7Lh!X4&L<tV75GBuC
zfj$P|xi|u6_Y_W)$Zy>&ZmiKvsHOcyWd2`(C|{NlC7>*u30Op`M2Wz)FNi3?xImOu
zltzc2L<^OP5_eZ{qMXc$68S4MTFwI7a}s%1CEaqi5(^v;$z#O=XT1>F$&FxvSPxM<
zOD9n~)9tL=DPw^zey+d*4}rfcEU@TPV{__pi%*RqHC2G`O{9v>K_24Dfau&n?PCiE
zbQ9)aP|8`L|3Gyp2l6tBC}Zg)8c*454DcO-#xXH^Vv&cfGOWe9LC~yQaZY3lHX9cQ
z;(a)>wZw+z^0n)Ehw`=SPK>3q1ApL9c#f6O&FZ3m`|#{#w5K~8HECevqZ&=~AgBom
z&PX%s{(&qkr&8|qOGhqAf8{)NfeV|pH``Ymaf+SWVsvxNxDD*kTJQ_dz~e2(K+Pv?
z$ARn!*5*WZP*AH0RAr9~fP^UY-RcfFE7kQosZ>`8smrUofDRtnit5g=Szl*I2+goo
za@}V1?f~@~8BC+bQ_Xq5t2LJ?`N}gCWWoOfDSMAVOWroaN?C;J-(sG~woelqwmptR
zeS6QoJPP;m)nzPrE816z^|vkt^l*di+dozC4xSa+m2Jjw?aSlLemm&ko8v5gyD?0=
z>^K{R-;fcgy<{x6H^H;Q0gHr^f%t;A-EUL{;$C45vyX`l>>gnV=dfE1MO|<wgsFE$
znbf--=hdtXOts`M7<(Wo&$B0`*&aiWALBMUTw#JVzD1u(#-M^OVI@y_#z80yOCY3-
zg{r{M-$7LO@*c09RuNIv@<cZCLm=wtdk{7KMj4`#t&5c*$`5>kkK@9hMCPyqh&p*x
zL6qUBf~Y}9*_s_dR14H@LDUt@E)`KXe^GmX3d)h`&+G<vSgMsF$^&6S)X=ensNAxw
z!>G7|sL{W0L?tfAs)4T~S|ROyh-!kuIQjuG_+CT>mQnr{O!aeHMbES-)L7bJqf2&J
zqJiISjZR}v3JM+XaXZY2jrJ31fkhUgE>|fY`;<`C0=Y>Cet(c0<b!yK)<oj$>q<cl
zSbg1H@X8zJiUa@qK^a&Is~xVpmzKroaFsFC;lOiZ`AAv-1XCjbhejQFFMt>^1wf3r
zHGrhzRRZu4Da7vr2pcMx5x0SjdCH=88Qq0pSle@0@0Y_W?nRixI-0`@UJQm!=eB7%
zOp2KuXciT9Pc%#jJT)hnm<z`QR=5-f=1lbuV}+J7XkuLt8-%E~l^|<wXvVZZEwY+>
zjG;*rpf{GTf}I^~(lUB<yQOt=J(Oj~|JU5qLuJjSAVkfXU~N*H`|W#?9Yu4Y$6zs|
z=6?98LUW2!Xi;*RQz*;5Xmr<xHDE;-jln~HISFhS?A)dUrDaD`B#b+D;lIH4w3QFZ
zJfenz*jYRlyYM#X9ndtHTnG>+lDh;33RL9OuO6XNIcIg$fSvap8)JR7S}ohTbbN$x
z1?Gg&myChcZl;i=J*`V%D=rxW9D9$TRq7lxgZ;oGm$3Hh56w_>*%*;C7M#b~AzCxP
z13U^0c5G@Hw6@N(zrmOQ+V-f-3flFE1!R6a7SPUtzDhm=i<Njg#B+%8Tr0fD>4{T=
z)9_FQY!TrB3j=u<a8M{Q*dvazpl5i@nL^|jGTlbc{LUpuhb4jbOUQ9Sga>^XL1U90
zV%B{MtDbr?{T}?FUgJ^KD@H#d<v5%st{B$|+mDIt))ix5^(|QF@RMdW*|#lHJnWMR
zDb27VtasHI)S(c&BBeoQ-A3pFW}S?`>Jm22)DcQQ$w)6#8prny)3TvN(le0BLT=pR
zdDYmaUXAg@KphK3&9~-TaM`NjT-?cJsPowGhB{~4bxWb8eYVqw_+_uI8vWesPl6|E
zb96>I(}<^c?~5$#nlaFELsy>HZYzFS>NR6K+es8!ea#r$CSfv4;aaTnQbS5ayvpjF
zN3UG&gNAKWl27OU4R(8|{uryAtx81pFV%0O)^AU>hFv!X<`iWkZzS?2<UcP1=c0*M
zJm)M;TSL?JWm&N5$3Z(KF^>jdAC^`&B{z6BJ73BcRk5Z;YE1^Ero4%27G6^p5;<R9
zsHCo{keaHt(~H`{Qo^QW3bGM$@jn^Z&34+Kq+sh?{4(boz*Yf;dfYGu=QJc}8lqTP
zr#9bHutjEpeYi)$rsO9gEQ4KR%Gm@FRv4I}WS+BtXK7l4AfqfC?hKwdaoE0^RLgv&
zmZczp1Gt<+ttAI%Rbe7itLdUtGh%|8hgajHCbm`*Z&XNpdsi8Px=QVfvaM!iGVp*|
zIkIzwSt+A!%*qZt_Hlo(Mo40smVt!bg4hN~D4Uis<ZPsvBAup(5RMkAW=^MLa|7{7
zlMxRH^DGsnCxn^P$k(0NZ#Rumer@hxdKLk~yziaoEaH&Hu1=si)*5^1LAQ*{v{i!G
zzFWr7A=|#;yzsB_W&Oa>%ng7T{n#Z|=*I%39}9UbxXTsj=HP`>(S<39E8~R(NK7Ds
zPUrFrPEY567p5;r@~D;=OibqL-<{Zym~9P(-G9K=e%lyS?T(%xTL->(<Tma%iOe7`
zvD?NNuLcJJ+pOdJ(6H48G8FO1Ka4AK40cXgWk7=^(o3oUItrCpvBU-njvaU`fPM`l
z2jSj>kWvu)tdj-zaaPF2)eIc>F&uYJ4`&C$*$!Y3l@seIZC^VFyyL>zS@60=yK_nj
zIR?AwnN|?(MjRlTk2b6z`kZnW#17=KfM|pYQJxat*$N`amh#~rSrMXzvx5T5P^{)r
zXoDYyqys`uAHM9w?*3_P?AL%a_*usvqc3SV`I!9-i<5mF3Fq~((r$Xk__*4I4)hrX
zb*JH7W1hB}Kl|#gF?8^beVjO+j4A6Ch(l6(b*FuWUa5leFpovAu7km=f^rMu6ym5w
zV710>Fwq9l$+}$7M%+DksNH_niJjd#x}mWDy2uvYGx{~Hjbhl(Qszot5;X17-&HX%
z#S~4$3YDOBn)R9+lyUQ(ag;Wz7E3Z2Lq)G*4*rLu-vxg~yZ3=Vj>iK0PEgWS@YCS%
zbkJn<w%weg3Uxtz+KF|G>eHZJ?Q2l6=)kla$)w(<?`aHY9Y4!44J@CFr#`r0S)Ev7
ztYyF9L)9dmSz>Hh^YgE)s9P}?+?1LI2zM@sEKw8Zt@|E}w2Bw$VZl~(-`K*o?GPBz
zWA8(>_Ce-;_l>oMW(dr>ZwwJ?Ah5GhTb=OocaeR2-xwzRfWU+M<oX}6^#F|E?xn_Q
zuJ0UWC^nWF|Fmlm^RSc6foJGPBJs(~oIAuiAQCHF@WqNUcE=OrJj-pZ#c@xKCpA`=
zG8el%H~ymu-EFe2vd4ZJl-Rk5#L|n_gsS>e9Qo4NL>uwpUF22{v;crNdwK2#h{Qu}
zQ0T1zz>N!qe;eCtBTD|TE>p0FmpO<?jO6voWs2V5@X|`CfL1(3L4PEr41Zrr#v6XZ
z?fNF5@AezxXkq9Hk#+mmm|R<TLa|p2=|pNs*WW6(h5=(o{za`9kH4qA$Nyq1oqLy!
z<w&SWNpEo;rwsxhy~S91ARxWPd5{t)PCvahdWZga44i!kCIdD<T@nihc_rojnLRkk
zFg6Ar^ZULyX)bk!sh|V%FEwUq;MMk@5ohE=u6%ydTzuz0qmM=~tP@vgrFM>m*9kiZ
zuoN0vxFSVL1aZ{(?4)^xEVUHQo)N#gA=T8>9`&VlcM9p8F__%U?og@>P6P47v?FpF
zbhyrMHR=Fmv7n7uFbOkT_jD216RD17-C0^Q&psYzh3>MNYA7{5{Xng$@z{53`q)xa
z#(QdFkG;F<yc=!dqhQtzJ-{b!9likk=KzdgK3zQ==U?I=z#*ysF~+eTPEGO|RR55Q
z_5Z$6vHm*(9P679;8-_c8vIYJPmwBP{jr@CmXi&xn}4FUcH&eVLO4J&jBkV)R%1KS
zz`gV0x!xSly#pR6Ie&YIoG6gVR1XIqu`3@x`(8l82s0HGHE=7t%WHunG^*&3|4+iN
zcOEBI+ZyZwo2K>os4id|`?MY?RqBTouDzx0nyW>&t%?*L)&ZwrOL43v@eJ_7kH?y_
z6jv8hLM%9H*_14*D!KQK+en#i;D%nXQ!vFk{G&QV13q+zX{sg&ZOR?7R>1(IejHN{
zU*Ry)WUNq6nL}PcF}9w-HbtAp)N=3r^?T;VS$oM(J1(0&vX{Jt=SN|(s3t|mT*B~@
zo3UAU3e%M1&$8a=i!~tB*6ei&a2<rd3vM>xw~|a>DY6OGq?qs#C=J7dX@4uLJ}TxH
zTx*R(TYP1K15ICx?DuNY7_Vv<I-xltY_NAMfN-7;D%2X-eXC2&8-GlkZ1(Yt@}1q$
z$$VmTMk$=l{NZ;LhWkg{AzD%3VvMySJ6>I?({gT0?8(6!y6ot>Kk6YrhCkH3y&K#=
z#~!f+Y;WW)8xI!fAoUQMuMpW32Wg$QX;<d$D2>q;bz$=zrC4pRF6<QjdUat{oTPTH
z%Q0Z_^B)rMfpE`QCl-I`Bsprd%S1M;hBU+ucU3)cXXk22evbZii1c2WJjTOo=yeS+
zft!0o*4$aDUu8GgX{o@Z*L^+M3}?wzn2VGp&eA}?+MLmnBghRuMIH}pN?foTm>upa
zbCJT_=6ntu8B#Qu1H4z!w?)>)MG9_@_cwvs@X`_47|g=M0MvRkVZ8}HrHm#n;y7Mf
zCH^4D3=q;$Ail{TyF_HWT%_=R&398pxEZ8^+hPSOv$`n(CJ)YH4hFA;3IQ*nMVO^?
zg3qINv+e=xBKRQjjn$Q(9xS4zt5i!U+9I+KT_xt<_h+JqIjV-vNn#Jowp2DBNUc#*
zN^EvuC-u0gO(&v-gTW>=a{xP6Hl_qjIwb7ss3cIa1GG?q@d<q?tSKdXG(%bI!^J>D
z&`y!L)HLdFKiE1)rgM|pYVG6kwD%BqVe<}=jd7C#Y<G14q=jyhXUo+H5rA>j1=w*!
z{Gz{r#O`A?DMd}{ZAtQ8hsD_~l<(73&6KHTnqtY+TusVVlW2LRRvn-w6{<-q@r%7b
zo3Fj_2Zwpr_krg0fxFbrzupH#Cv-UrP*X^$aR0y@iNtxM0;ntQ(lG6YZmhme@@YN1
z7Ui82yph8{JvbA{+x%f5`m&rC#cpB&rU*{h3{Pw|I=HuTQ$cUAhR@-#q?7bQ(sq%Z
z)=42k2m((L@c6Ku74mUl2FQPU9*#~PQUl@ZZ6fRIA@%h5CEh9%><!4&t1MHXlF6Ux
zJf#?q4%RubABvm@e^sl?+sdo+W?MX^<{k&)tm-6k!0mZuIUj?((6B%2=!H5PzMHdk
zp~#kbNgsHSn5#q|wNQ9g;C#2@8s5?<jct4zkirZfkU|tfguY01P-rPbJq9V%SCg!%
zgcjaN@}}}XQTeKBrVO?GaQu>00hyk~Dpgxk35_?Bt|N&B_)4BFzE?9@6Gb&8Q?Z(4
zRIA=-sk-;cPHdd7G*bvYBNjjQmAYw!?m%P*KWUQC2R6oU{G_qM2=uw3KX}yhZ^hzK
z{!&L<+tK~NxAxSLR@wgC7ol!J(gfSy6uMkTYRcXQNj|oA^!cEU6vWyDOL?{*rr~o&
zkmSp52TMI||Ljv_E^Zwnwa~b-O{x`(3%V#wz`1p$1=^{waE3~aw5{5)_My@$?ag}Z
zdZ^?j_<tg@e?p~NIrr8>OZbg<G4`)W8gHjF`?)Ac!Vi&orYZ_P%R$a9$eEydo7Cb_
zlC%C1a5s-~VRD3(cEVRw`BzM$=0ZXXbAq!T{KIZQS$snN+fqOB>onN;Q5;(yCe;%z
ztimo$m{cn;hUfc<4uL~agvAUmH?Jj&A_RU(x)!dE8-{oZHV|f>^`!d3uh0!T)RRUC
z!&ZyMJL*YL6+5G<AM1nvg(L8wzSK#$4N2NGTnf@2@5uUuOLK%~h`1Fl#R<<C$grN|
z&KlKh<tqGuufztDzq{6ZnOXHqfyp1X_f<%l*#K~kL11$ODM-*Ga27Gmd>J7HCS|eU
zVDLp^n;;9!69MtG*6Z#?vL*J5iYf$4|FN&mu?QN3MMx?RKU=3lS?_SXX-cgWB>yju
zANDw8Sd{QXGaD9McUXk*D`cytZ)<lpyzVgXwxe+JG9mv#>D`2aDx_KH#1W5g0;mJ_
z_`|7V)(S;RpYtH#zW&S_IQVT%SRTQ}b;^Y09fe2BMYeLn^3eDb%dMv|uV)vcNZM;r
z4{hPox%jj7V3o2X9E9wiT%qD3m(Rxw-9f*Z-k&UVjyj_1Tk+}r=<={geQZ4;C`)9m
zT|aNs`hy~1{w|(RcPZUluGo>%6Q4@Yem})-+eFxuntm1=sOoL})Vnz(cN|7tAM3?#
zT<>kyXy2#Sli~vs>p(~(b}ke0ucCM=ibH|mw`GjZgjKV8o)-(h(YtzjFQ}`k6G-L5
z566#KcMES|m4l@`%@9&>!x>k*o=++`L~JafU@vj8ME(E(Z|TY`kv(rL1#7cYm`@YQ
z&!<NU$rNlC;7-@`(6fzvpst%@Q&_hqlE2pA&9a(E?%Jv;Y#zS7PJ!>?rs~JYMwhXo
zb`&+8>&m{N+!}Xwt%>BTUEY<wM(x^(P`IL{ApH@DF)9TjrBYm@xNd6MjelZN@k+w+
zNr2;%0LKpi$HNp_4&P-{nj4!P4bWdWu}#rZh*u3aUg>bkZ#XoC@*84D+;nF9nn|@;
z)uxh8o0-h~n@V0j7VSpSUg^dGIN8n17g<VEskSgEUo6gUDz(+%@@%Hm(AjJJQp~S@
zm|v)!BsAYX?YC59KFuY(LWn>-1)LEWP5~3NlEoDG7J<DKSdG9n3QR!2HU@!21i~p0
zg1`p|jQp<<tz5-o0<BQjc`GBJ%a+_$BE_=EJ=+m^Pl?PZi)>3dA5!G3lP<P2mbA^w
zHEeT;jJhpdFTNQgEwC$l3NJEV8symGX&|g}<8<d91lkm@i<h$STG>ua=p@O9MYNX&
zJGOePWcc+yGOTScIS9f+NOb;Q+Wdv0`d-@k&5*bBUfRt~qVir^&Pd`x|Kq*110Zk<
zSj^ZNT=Wmr@7P6psu7xf!2y^n+(guZBq>Z==@$CpBV8rDefF=c!Vx!KEFRWPiq$w2
zO4RE8_6FN#EN5U&E%$DD91J`ScGCPE#7ph!khV8Ikm?GJB$3&7mqKlStcECh2rW8=
zGS5D4bqdEE(t6dqaYm@X<-9YuyYy5zx=v&hQ^A{`7m3P?YiahVmA|-_j<k!ZQi!cH
zMNvaNpRRnj(l&;7;|@UTRR*Zx*mvW0EdxGrOeifrHq`u)BC_7ly-YatV4i`M!a-uc
zhv*Ncl3BMbPb@y)Lu#XerDI<zn7&sp>7$(RMn#Y$bfm0caIj0sS`sYe2&w3urUzKD
zlw!*&H5aQJAHE1iHond?ouxF~7!ZRrDgz(<wXQ_UH%v{RETw8_skB*L^VC6<S?7qn
z79s%nF1@8=UONFUJUikv*-L4~C(;eFDW;$>R@z$%>$PeU)sLI5#C&(Gf>uvO-?%k^
zuW8Ba6Yc^ZBTs>QFmYRQ@8t_yh;(dYC(`cN5EQcZDt!x%IPycu<kfh3S<`i_n%+>C
zjqD?}k8%cHzXlUfw(BSZj?T%{Upn|gjZIe?<3@{bJB#dkA1T~+cQ}NOQ<|jj*E<_{
zb2-dMA_Min(uNqWU8n;8m3m!nr_rbtOHeP<bK1NE5*I$?NVMdOMn?lE8xqGMk?l;A
z+#Gu&R8E*jjAPx|pJ~!JO&umsJBj&&g9Al_?KMsYhTu3dgoVOu062~R#)?3&Gqz-=
zSp0imX`IG(av0!G=r47tHUIune)1vjO11|F1m~DJuksurvK{>;|HjEm4kA1^B?qt+
z#_@4wI7#bQrcqFcu_iSIAuIMAi_)cr!b}LisC3EQb29Kz`FxJUbg262(g5u^4|X_R
zYUU7HLM3y7Ks^7jy`Km3$dIzC7$Vwt0UaAMq*&qgP-tNp(qioqU)Fzs<mKNCQ>NrD
z7$)`DRfQckgS%#36Xab!K<eUpElZWwe1c5=2#!Dlq(JY5?TKVQN1`>!v_W#cfzqei
z9zN{*fs()HZ<!Sdkq!urm?E<O21<d#%yuHHJxB_&oe~6Gii4zhA!xM777oHX%Wbd-
z7i(#{uzZlnnhcgkp(hRWiW=64{W=(?oQnfR_Gqxw&uhv+bR!vC`qnhmWu(Xk50RpT
zM##2uh}1dY_5fPr4F*jX)CxwACw44NO)?ClcLIOzh?+G+rH(!`DHF!yr`t;_xZuUX
z8E&W)DMSwdLmw(N12`Hgw76fEj{S)UVRMGa{Dw)9U>!3$Af@{-si&uJ21v02=Y(>J
zx(a<W$&>s+dt}_>n_1-1Io(>ZET`4LfJ|S(I~`UMCp=lNL7-<qX0UL%KOCmSTp!^Z
z1Xc%R`Upk@iUTqOg&7E34#*63?%uzwX?lymhN;f$4cei}VDDkweEV6qXkj=UK9`YF
z@0`BKQ3gD{<WU9{*S##JxX-Y5wl0pjcaE|cnifolWjMqzzEZmC;Ws<SUW=PS4bxmq
zqy^&`e+(Vt_Ye!F#StxfsEy-Uy<hv5K?195+?}qTIXe(T<79Ik44|Mn6~rl(9MupO
zvINN%cnx;fo&?(*2*cDMRA8C&qxE;x5i5f-(kpzy?q2yDE+KxnWcTj=K=q<9#Ybe)
z*Ja-<ZvL3@g3tfbs$KT3sjrO@+4TG|jdb4cQ>yX&j+84bpDD84W2A|~Cm%vL8Y^w6
zw+(`VR$y_Z9bscM>#hyP{PO~?4iTF&>n0NC1IO*kx_19c$DGDVog%zNVsc=?NpSkN
zn&fcp@7Y^H;^&t@?0n;*ICq@%Eu^1ceoNT-^;uGD`p~xk&E$`lItx!yVb2^dMdlnz
zMN5X*pU0E!UxQf=er<@o$UmQsqt9|`G3a5V(Y-(tkROLLu@&$MYWW+<$rE@ouwAw>
zx?v|NSQnt2^oof(G7El;pb_T|M|o+7ImG7_$3qrZ+mI|=e`aP&Y8xVi?G*U5d-#y<
zWi-<_UOhSt2w$0k0k_T(%^muP<4n^BX7v11O8*ngKV~;hFpQ@Ap6;32JR|G*gVGYX
z91h~SD7|KRx<8tF@@e;4ZdK71_@k-Uc@p69$cqh=r=16eb*8J73UIXr1|?a{|09tM
zzfi_MZU#%gJA@RLvZj#NW>)=K=UB`B7t4L!S?6<#4q5O!El@g*ih@_gYEYDY`MR^0
zu;L#xJN>$I8_T<uk7rBsbYForb3-X4Wd;{SgL1%C=Sb0>2Qe+I^#ZcRr-0L5m;*+c
z+7PDkJgJ@TM!U)t7(j^w^Q35xyJ^<Ko{NNOV9;Chz`MsqKsMw_b=`-q0on?(8w8Sy
zM0*aV)HSUBTq)c;6e%5W>NJ&-<0#og$u4Wy*tt?KZSm^jQ*))ATDRxGXK9V7D?pH#
z{}XQS>Mr8F1u0qB(nVxf^Pw}&?jqV0)$QxfB5x13WBv=Ef2SdB$-n(V0-GRBBwfiS
zTW1lsq(j8v_z-esEs$F2E_Oz){EJET9wp_sfi7eUI0JRz+Xa%lLsf)SQCfU+frO`$
z!^c3{E|fZJlSQ_1p)|+N5b;+V9g8wZe<AoLR>y)DN%LD34#n=FExLp^!^v8LJ2ay!
zGCw@Ahw}@6!`&V%%Xto2Rbk*yi3lt9{JnQ~tg`I>4i76HccFKf_2ZS1I98t1p(0D$
zdC7{UrC<`0{+oZQw|QXX(89`-tiqJTBvUxnSYwdosza>c-&nEaK97j_6qXFmIxUWE
zuQ9W#?NksK8?b1jhiwLhh!;2Sh|nRdmaU8#jS)rc`Qzi@Eb4>Q*0o>8B`Lg`;J-m^
zU{00F-$pEzZ_LZH$d_Gx+;$}svqLi~v+LXwYsfG20&1tAvP$JAauU|{9|)sa{$uuK
zL7s>3PZacymtFmGqL4UyTDkDK|L~pS&T8}N$7nt$e1I`5V`t`&&fTnslrYcrO%?MP
zT|5x`*C-4|LFYiyv9ahh-zqOJ=C`SMZ9^&~zeRkK#inBVb8u7Z^x{A#JzlQ=Zv~7o
z|If?yPt!Z`mr1VUk(LPS8WcY7QY1xb+O~T8ziKI=MUKJg<NoEf{2cyHEy^<pAAH7F
z!cKkgt2~3Sc>~2<vD<}T^%;cuuUDwgAe>E8s)P#$ZaDL)2Sgd1)*}+Q;#)F!GQ}3L
zTo1YFn7&Xj)e_k_r}R9xuuc`l-H{}bRjrXeNyzbpoxVo;2w{}3Sp1+ydKHaZeN30b
zQ!JwKDCWJLOZq$^QwL*&OL~$Jh`<e(^ku?rFOmK1nqG@7aZUFVKKBxfce<v}*7%s>
zDprvTNeV{pJf|K@X*aA9o8gvzMsV;DS#tYf{%oXsx{q*HCl=3hPxsg4^y&^)K!$w0
z3Id58NxKU;aTXW|UG)*7(dk5F!9{Nea5||{uGay`#a%!Qv6H^z6012fAEMiPar0Ya
zq>{~7(RZnnc#N|)B8zy%vA*90=b!=I!4FV|v>s~+E<}O1W}*4LNL3-krW0B$O;ai)
zg~F^Gh6+m)ATk>wAN*C5@Y&M3#ZHs~yZEuOJj0Dde0t+^>?r^oYS1}T>yaGd!D!Rj
zq15vb!OBgZnA~PvKg`I}9_jHO-bg=0&GIyGecS_$wA!BO9dZswBCWg}Puq$pi#7u(
zgqeWra1cv8<L=HfZALjMHmNm+k+8tm!q~k8Wsp2>1syIJusXZOxgc1L2W`at1Dg+t
z9yn+K9O%SA@f3T`q&n5B#DMq}*N(uIQiRZ}E9_${rC^^UjcB5`cj0Hbapqzgczy$d
zIFiM!lH40EMLMxJ!h@xA(-BLcp4nl&%D__pELHwRvRJfA3e!3Ax`nbkV}X=Dej<xq
zC3!Zu*-)w0r9!o*5lhwjRH&Bau9BL%O>PM+5ELr+1dC(et%BHIgGuDLT8d724mLsR
zh8J&;KUM%s|4cn%XCGJJJyphE8Pw5!T<cS;8qV0Y!PuCpen}kjNi1nVg{!47;X$Iv
zzFsYbc&75|+eemTDiUXtI>FYD>taLdA@PuC)fqGyh&yUr5ns+a73}CyVa6KCOLu-6
znk=wJPjz1vJ%tV4hn}g3CG?!$W{q`rv+4REPb5_y#_fn>PyCWRBHh*MDh}d*V2D&*
za)s(R+e-Na>(g)_Y)8!6<QcIO8Hol0t@>xytx=1YZncI6CyPFjT8D-820n;pInAII
zyw!sI6}vmz8>-CnEjqmeZ{Sp=0x#+ld}dQeGyny+Qu7zo)KH|BnGG`6N}*nBkx;Rn
zQZE35qd`0RyC-EKmHJYV@X~l?uS{FEROm|zPM4C81)054pl$cApoU->On9m?%2IvA
z6EOaFtG|L+!gP4W>RINel5fZ+Bvv3Dkj)CjS!5=yes_E-1$hoYG)B1s2|mO;AQG(8
z>^=3=sZb9KTqnguT@9m3Do>N4&=@LB^4*ki_VF0z?4RV}x&mL+hdY}H-%!EWj&+i|
zV<w`pEXu`D<2t%^lBd^@$(6}^jYm2DBWff6y9jbnD^Ek^mVV=$t|T?_n}vB=`qH%P
z-U@yN`0M7@xZ%(DhJ|vxC=<U1F1CQ1KHU(di?8T52&c%ux2I@B;f#N(wXg81E<D$8
z;dji{x&V+gGfu6XMSqVdB0lepfT&D&5@)xyan7TgI?-j0f{t-?-Fw68SZp@#6sOmC
zx^*I969UO==?9Hp;RY$dHDr<E-%bAFa3X4e{mBiIyVKtWYK!0NI-@DOwL$WBZAbGN
z>z^?0qrDZf-{CVUB*zia*$I%K;LsK)5f1PspoOHur*QcxZIC_Gta}9ZYvoG9bIn$B
zZ6{X}QAx#htxD@Sz@<SYIK_d>QAg8R2Y#L-wl3h~7eXY$-=rWh*wJ*Nnbsyg_qnFD
zt+h7_--qgBsba9Dia!^YRiV}}yBT})ndIYJj098b`zy>PbcCh?&WieGB|00L{#Df#
zFk$5xYkSm=6<k{}Q*(q}?wjQw@<}ZaM%g<EUZy)R7^9P>G3$wi_kxl^bjdV7j&Wm!
zB`e&pHu?DumOm?U7C2q*ilSJWPqQ}#{KwiB<#ew*wJa*ebQrrXxzmGfZ6<n)cr%^<
z%Ynvm_)n4TE6R!J*Q*JXl|2C1tgD5ULNqRy=wdqu9_GinZM|=>J&vltgdRJkn3Nx<
zVeR<l_t|(TOxXOkKNJpPGwZ@^6$u2%_|_W$8O*vLF`a8}lIjO%V2CkMhzRUWzk*%S
z<V%yNYaNlK&|ijcQC)QFApFM*e2XF-ch&*j;i8aBMl1zS`4&wUK819QuT|7e&}guE
zU#lnr*%#l2S6{P4H}=D3DI4EH*>|rk(mY`jWb~~qQd8IMp6Fy}^fBroJXgY2xU$f#
zl2~Ic$g0E%7&7Yyw#7+Z|DxJm_wDB0{Gtu-W^ephcXPN6N))2UTn@AZHz+CMcsdpJ
z5_D+FxJFw1&5{zBK;ebb2B%WDN?u*fI%NErH*}^Ax!5`9?Zy`_^RU&FY(fb5Jr>(Z
zxm!#|0QXOVyh}ZyIS#@n*Q@SAZM8M)!aIm8b(<6()e)`Jwd^{YV6+KB=$#J@mMF(%
zEur@{q>+UX*^X@z;dt~7I#ek|x()DGaGd|iQgiMUdw9IxU<2;tc(dl)rCvgE0v7Sx
zrS`&(fA#FbcBwv!#$Q+Q?fs=R7T;fAQ@_`JDNPXCK?>@2NDW+PyP?0s%JBWR(3O3#
zLrSVK2H=!La5OY-1+T>&QeaO0mmJ?yT5^2X!w)WVQi-b7zk0<(pJUspCQ9!t!!~+s
zYI11>_H8bfIPxk_K&>Lo<|2!N*+~fTqQAJJ=nI}}oto=BzL1M0?v$#B7PU}uKM?_}
z(l94V;r*>^hEE0eW}P+;6tYta3l9Js<Y)PaShb>Z4YpUX{$M3x{dXj&8tU1dQazw4
z;R@EfJEcg+Ha-f*haw|uxl76x8g_(d_b#|$82;9?*SjR5YTwH$R@?5DI^p}9OX~O9
z-BK6ttIlZuTY!bj>L6@N{^k9;-W)rUd!*W3qqlN|1~umheb7uHU@sM=fBp@We$ELP
z<@eS=`Q8{OEcg@xzWSR&z!!O?V^L|=9?3`d5oJ6Ibne#B>Is^4TO=9xNFFhNH6<Lu
zh3_w(f>cM`zyn3U)E{?~IV2cn*hgJ46%N9}>I%rbD*(b(%Z)_#*B;4F*k1!4c3(-+
z{`HZ8_`<*yghHGuL9R~tt0FSvD?((%{tGxr@RiikaRZ2-*u$CSK;-$aq^ZK9c!<Eg
z*jst|T+f#5<%paECwa~ue%~wo<!$2#pf+&C#iHht9lVd)XxJ`_;px+FBS&0f6OK3?
zez+5xia4hiKpZPW+>PoeA6JGrqD8x36k1%vD`lV{qD5z9i9e~wET_js@nRHjU82&{
zflWl<WU-RBO&)FIE1A0^1oHD~T!va)(HaBbeWSSFXQXL90HJW~JY<2AACArZeNr9a
zL3K>+eNv3yswITR*;wM@7#;pvxB!Xp$o+8EN&8RF`tFy!hqwI?_u6Tmfo&*T4E;;)
z^anljy^{XNh;z?A7D!CxCq$R(;MIo}suGP&&Kss;MAOhcDx@|qA+cP|=pOg-q-J7G
znE6M-G0v}jTb~wA)o9w_bm~>CG*KKct6wJ!m0q-l5h@8?f0mnLZ^MgwqIle<)_y_7
z_SB_(ltsZ?C)=aol}ZI!<^d@-Y%wTA#71BeT&l$U7iQfe%)NNN<l=wOG+zIzBeF>c
z;XU^E0qH{gwuYp=+$O_9UO2|<Fs3yk;Dpf~44f?Yr?^^$&T?aJ4<|*l`fO2|BI$Ba
zY7_RCd!?2iLanac@~lAK^8L74SXY%b+NwgMN5MtkZS=T<(x|(E8inR={6^|33~_)n
z<TuhX|9LW&(R=Z%!mlRr*T2MiC!Oc+g+~h{_X?yGuRkQ&YK4CH^lbAHDbnNeOWb1+
zhhD1v!oKP-d)SVTNIpVm1f0H=23K=yKr|K+B(kaBO0zunV<uE8)2S*p!H!BE9uZZc
zewHtmIEsCc7JF3cl5_r3nqRsXVX7qrH$PSZO?Lwo?^lwv^~;kMQ&KY^TD>52-Xq++
zS%hyo>pjo~iJzd{ET!D(dgbMMp&acamzC>^awYpQof7*fWkXT6<d`zQo}nB#AKr+9
z_5#rUz_(fVnex#Lz~Giw<)a=xc+UCCw>NcydvWO|*@|qyG09E1X(zJD$E4aZ2kkID
z3UXW?o1G`RSg?Vc-H>4U=B%I)QGnKTb1wMU*<+G_=plq~N|p#tJws#hbmpr#gVTgh
zf^C@YxO71f9kKCxTnd4Z82XvWyiZ6?;T`nvG*{OBgp@Dz236cRAvKA#o*{9VS+gJD
zs+lSvimcTbl(I{~_%V<CH>RywtldeerPgK$n|V_5*Y#P$N6s|_olXa_fHPNv)H*4-
z`$j2AXM@X={4l>2mG10M^WD9Vta?ua&&Fbj_4cRvG1Z-e2=jh6Q(alxpXYlBKcnK_
zKhHlc^tqvDO}~>aYH##s&fiNh!b8we%X9NvI$HXIr&J5Sm-=elGQdy|=Yq`D3zGkK
z6`A=oXxQy4Zo2<Ln$ci4pgK%klh1wlSwJJ8HAZLRV>pCCNqm4uUeU7?KS)uXt2_k7
zslE`Dic8cV=s{bm$iD|4GtvTbzys8%^Qt?^^qDk*Ly@2euj05f1mq6P4Qn7pXBEgn
zmsB7H%3%fM8c5yu0(sz~3S`gwm4WPlm~tSS+bcl+4E(4-9#`Ep&P*d9_aZ@+u!U`x
zhiSDUJJ5D{pOBm2m12JDU}(!fX1U_p!J!tcC**eoGCqY8zUspKV?yKwJxjkh|ERMi
zhcf)?LtTj>ZW!T+iHn1=y%O@@l@sL;b#)5nDdQG_n)yRr%e<k6(L-G_0#*-oP54u<
zJk-@tCVo}Eyv1_QtXqsIl0r8oTQ9g35DItnsZ-;$7fEs`$7bDO%!ea8`nc;d&?YAQ
zIV2t0#s~Khl-!@r>`3tbh1gqp6P$$|MpWq*e#J|U{BH7MMA00+F^Q}@>N@8ruBxZV
z(}*<d_F$S5vsQf}G5@^ia!-RU7=ZBY#Qo%kjRH76hp8_by4YjaKK#!>q{f~EI)J;y
zz1(qM+j&XX*&gwHa|<LZ=3h$6{~L~xoP4i>|3Px|%bv+mpv*yF3S2ERUCbdJFyAZ#
z1v6*id1+r*8K)_C7ntAy<`*&slg5&{TygNdttbxIOR20leAe#0io+sAlj5*fsGvAZ
zMl|8*%WT5YDkPRG4$S3usfp)@=k(yDodOj@C2j)^gf{cDp7r@1o20Ji^lZ`ZlD`m!
zm@j{qn)~cM%P;6P9hyM(ZPZ#=Xwe0!S+z+#Is-J`_JS1Zk$lryj`4xM@<h)@*OUXa
z_%+m&ed;}-_TR(F^N>K0|2Do%@}EtRCpMXm-h-)lJ;p<;Zk*GUjgndS$79fGL3`yD
zRx(e69vgwlP3bKA`%oGmHF|zgw?jwdkIh!kM|yVTqU0-Fx(@2>EPMJQBelCDi+Z>k
zt5M7NFqcc{)r{-bz2XE_{jr`UU6KL>6RI0`Nz!?rg;XRvWE^O&OrycMK_rtD&ykR9
zky9Kqix35YWxAeOahAma?o;+9^KiILHJx$iRetO$ook0@YHESQ$zJNa5Us>-@7nS<
zRsYXu)T|t~!rb8*S>wx6O-C2r;ww`IT4X7gB_Bsa$m3s5;0>;bgb^Ax=`zG$)xQ*o
z>;DC2T?yhVh$2*lkF$mt1b;>H!7G6-IQoD&wdoxAQSlY&k193CA|D(SuS#pQQLR|)
zH7q4Am+IM!Yf?91E&}JSNrBE^k0!)__6AIr%w|Q`rF`v#3|4R*4oR!-<MrO_ILZ))
zK%*N{pliQTlw1Fra_0iq@Lakfd264=uxU4>FsEuf`Pn~|3<j4vvk{g!Tjtxb4yiK}
zgwPT_D@>hP2XQfoD^8u+L)d82vsr~>+*weMnZZtDOhi(6RPo>l;3&1n%rGGrtH>Or
zdAm}YVm>q_p=F*gmGT|zF*DNL1?xauWR1Vp1T>mM@bz3fcD$3^TMI3bH`Z7$2RhzW
z+iEu)bzC1kv!SicD`Lw{(o%%MclC-LvJ(PihYSu!_DWpT3sFQu!-vtFnFC~SdsfCD
z@Ja1fT`ZpahcsJLRYg>>%N^+hjW8ZUf5=^Fs89`opYBTggybqB%fBZL6iT3O{dG_J
zNEm~_NR!l8sDZ%uCh1T;1BRXy=i>?A-W9qS+$VvARlmgr-w+V@Oxgi_w0D$9CEE6l
z*qZwomYW(jD|LqtJ9{5z+)^P&561y<s>1L9EWx2vnk-EHQP1*9rMfyzIt^|q+QPe_
z)FQW|9x0W23(-(Jd>=@Cgtk9mf<KUExpl{ISnrsZVy-zpl+v`ng|Tl#X1KBG52YCY
zmB%4yoau}gIjz&bj&NTvOcP;;ttJ-#@=!|Bctk*XA}-@fUZyxdg+o-P7WG)uN77eb
z<FmM2EBLpgG9BXgV1d~Y`i1tfG(_96HXHF+TB>!e!`?oYlD#xHXiUkx2Y!XcIe+=~
z0a(qTCsK3mFLl``PvCd{>V&@d$P>692`gXdnfa;IQybcr^?D{HYrhcL7tf?6LSOW^
z)pMy+$QE$mlJhtdcNm(7LIBW&s8`t-deYsOp!(0BOD!A41wzU>^?%h7)6nh<{3vH>
zXg34LsP>_V6Idaon|0s)qG!%8q(rT25bO6sYU)tuDAJ=~l=)N7*1nK@YP|gx4a?jZ
zefbY4M=zwV4Pq`^y62py-0i`;7=VNlx-3G4=@r0_dnxGzJ&N{ziDP442+Vs4SHi`>
z-4Tk(K;Y3!sd-SR+CV?tWzGUnQ;X|3bL*y7^ZW{`?TIBEbG<j*!{rEChhEaDJCR8w
zWahY6Qp?s|%oL3^N6Y8n!G@XOkvI__0q_$Fn#C931u<O9-LarkEt)Dt*jK}A@SKYu
zJ*sDSUP-~t!_iFXEilW9&mt`Rfc$Uyvk28F2X0Fr0r_l^sBwQw4Lrod?}&%r&MHha
z>L3QM0uxm^^ajMgD=ikO#cEHiTnq~|L=pVEy3s5v`bXN_bJs9VneCsclxfz@{~4Gt
z#I8~jYFZM;@dTaeDQJR_^XNy)sJqC&q3=L2UPTn?Q$?>~L%O$3&jMddt80ERl&^iO
z)7sbIG#X#*%xmdn&gmh%?e$N}+cxqlV|OYEvL#`jlCV-qaJ3|iMFNJ)UR{q4+l#Rt
zkFmz<dh{v<k#?&KYMhw=GvKX-!g&4d2Ymo%Mp$OtFg>}-Et01EWFm?Q*A&hl`7c~>
z_iWL#?*B^bYWfVe?nN}dnC)Ask(>8Lu#hmCRy4O@V}tV0>8<ohqwzoJZ64!M`_Rhj
z#s2-)gN^pFa05ef{Z9&yKXL#x;)_K=X%+lQ%6|Ze6CYtR(yc?&zE>FNNsETSOaF0N
zk*Q4*Ap>UoCxx`xg&5jX9Ow-V560;Gm|EpJ@C>{vMk4r57wYZLNU{hUb&c?!wAiB~
zCcC8}PVB#YuLzVHdjJV&50ZM<Hc0C2W+}MF<<8a;o!vA`wNiT{AHAfEZLRFODYSHf
z`rNdb)MvXr4~dYh-qZbIlU{jG*995MHMEfEt=0h24GMBskFUN1aOKMZ4xId*e#KYv
zBDXA}feu6i<}+B~RNo2!durs5YTx+^xGhi&XyqP{rRc|TC@+~?knOQXZs1-h5?ZE$
zYAk4Bky;s=POJ-ZA@hiM4eP0uuO`<y2|VDq*E=?aYDln5S`OdK6NHN!rn|or`pu>`
zdTJ-^cOo{3UHoIYf}E8;2>GnLhD<4lDwXM|eF5HJfG4k$SkMDoXrPIv@8+(9sKopU
zp#Mjvv7M|3McI0{l^<!hd9!#sxufvYF+Iz-lWWz`gHmwaY#i9Hsg*a|Z6`PJ8G8&6
zSM<$B=QF-IVJ@m7chzo-Vcn|8^;|E5>k~cI??4@L|5eWl5M9ftMn7&((U*UzfX}m4
z07Qf*`?jjwCZY$}EZVlGwxtX3HKY6RN}~`(^49c|hXu5w9;|`A+)(!#Y}|6p5Onxt
z1IBNhz1&wTIkO+_<p!>4$U<OkiKq5gfG<|BCf93RTaC`*(P?0bmSHY@$EGu_7v?!m
z-gvUDZ5QgDbQVbbb?j_4d75^BFH5Q}#|tM9!M<HxuJ5qw5ZX0Ftd;@L$?9@P?UN?V
z$pLusrvv~rwk-kF`zJlqBf80-T=#ipissS&KUo7*zBuiH6NKa|U~uZu0}!o`U6@|u
zK2Efk4cYaY%*7GVobzA?N4brVe-JAZM>)h{z(Im0WS|ky{O2eqXhR%Wf)mhl<7)+)
zMzI8q_ZdB#>m=8!{h1p5qBTX|01vaEM_~?Uo#b{-hS>S*_*96(4-2RvUlMFL>)D$c
za@~M}R#bE%SP+ie<8S2(;+*Bv!qYGH#ZE4=i?-(Cn2IFY!A4mK_W#V9|8PcEx>wJp
zU%=Y(Gy-ccNZ$3gW3s<@DYya&gzP)b%a($LUb25|GR7bw{{oKi;i5C#Ap;t%yo3D*
z@hm8EXGDIr1%K9-Jnok3S*e#CjGJCuyk#%fKS8wIUka_j2?(6Ag}3adT?SRfTka~1
z`AW}ju1nXk!``x;V+_W)e3qZ}mIDP_rf1K*<sE+c(165zfvz$F3rNF4Gq&d?5>Xo=
zZyC?)UZmz-74lBrp%*FdK2Qyd^G*tk?68}28P((8ojm@rw6jx|cIJ=}BwOEego}1-
z$#rUV-mD=$Xx7~VeiS9q7SQ0%hLc#$*OK$JtJ*Q0pByFl@6xjbKe@HnJc-7475;LK
z@aFFXN9P?F7e6_m$;O=k18&{iL{Jx^$gF#@jzpVT_ZtugS@bx;oMfZiBY-9M#dXl*
z{A69N3>2hs+tHYaXf^U$$cG*Amum_0k@beZ>?zdPsb~NA%f60}cPM4zP=*Bt$PF8L
zpe<|Jg{syg)8lw^4Ojq3T3goF3jnk0tv>E7ZmhnlFdAQL0_1=kbmjf|qmW>!g43lx
z2jHG*Y*a;3jsp&G41}JCK0^dR-)+qyT{qK5E}&5E1divkd)9-Ch{&B8W0PG|+{ao3
z%JDc^P`K=bxi~ja_RuyQyNwU6=}^PUt<ZUqp&*>|B+Ie=wh%ek@jCJZ&ljVy|Ah^|
z1!moC;^w5{N^A5iIY^$B^a6udk_<_SqTSBX_)R#4F$xk3rrC?LALYUVi)(m4MW%X6
zrUpDyGBUxIX`QLyQ`ky_<;IOC5j}WfFA8kLtb2^Vq;^2+4T)BaN)H>*xL!bliUHLL
zBe~E8(2*0y;Ldg|t#8&0+iduLvol@i_yuo3r4~1gj)<o!e+;LpilH%4ReagHVn-f%
zVKf>mGO=G)Jl5#0i(S~Fepxwo2B#r#QUCMYjQTZfz!OW}Vza@lI|0S3bN?*g;PiH+
zj5=NXi7$Lc;K$m*;M_v$GK-qo)vek}nYuO-1w%sRdUc>Bm1|aYum~aIeO-?r`x8lA
z;<^mTf(ap{`)C~dACT4BvGo>Zm<A&oTR0$VywLD>J<|-#Y9p-3*Rys5v+C9~gw!7;
zTIR=ENssFlmJg^g3(8|j9}asb@SKu?S%J;3wB@j;p5d^+{h=c4Neh6zBu=Mwj3_)6
z{f74b9Tr!EvTCIcqn+iyOByMAFH=z%J>a`*J;7A?xtKWTy)OviUo}#+$$rFi%Pgw7
z{z{*Fhf<&0AqnQ1$h0}wA#b|D&y`I}n={JJ;1`YH5B23<!tD)s$hq&FFvM-E1rLO9
zxq&bjakIkZi)Chpvhu0E<>mkMab>;{D8E!LFW(Pwa)jJXa7En92zh;Zd1FI402puO
z?OJ@ip}brxYz2X)Mae&xA7O4R2O`5}oojKA#`1ct;D|}_CR)Bxmf>bodAxA+Gd;5#
zKBtk}6v(2(bOc>h@>hPOXRMh#+U*~Zrgefh5<HsANrJRe&xSUan+hXV>We>ZF8gYN
zpUuTU1Ss5<>H@c=7_6sb_Z_6!Hx<0~S`1j61BAoBF|wa$doMz2#240FkQ;nk0J`z$
z^=B>QhHmvhk%up0-%EuqVUnKRZ6S~L*^Jp}op5?0SOEEF-(f!vpX149x0D+RAFR-`
zuUZ099|UT&mV=93TgkDS_WfsDz@^Hu{ZBCjZqR-L_s({r4^p6Ua_Y})uS1ke<*VTL
zlOPJ0w3gi+iruLb(t17J3g24x0^S=txEBA|TK-PsaH=LH?gXH)0X8k7#CFwOi@#|j
zKh${aa-qaez|1W|0MvCPPEN(tzFWn$*gIanqH!EvgYtc_mT0f2y*vPkt8871hqjj=
zX&kCLQsR@<)Iv(TsUF%XF#dFuLtVddpoA}wpt2%m1HJ(1v;i-SL*Va@a-(|4LF7LB
z7`L3>Q<qNxym&PvS{Cz#r<!_&<&)@Z|BkO<2oO+F^tvd9y)A-<br?Ofmrycawe0O0
zJu|>*_k5}cW<+guu!;V9xset$wOB9Lb~1#Fd`r4tMEB9qzP{1R9}0iXgNg6AWu7cj
zl$~t9)PZ&03Y!`bxnUm3#(Spc_SD(y%o>%%oGNVR59^|A=ciPiMLg~j7G(c(JKsuG
zhBhS@qz5Jzj0+>D^Y(Zn3`e*^>i^4ObQ=X2-->b{VcT34#;gRnmNwm;El!Z@1a!wF
zAPCo2B?t{g6(Pina2KTPXfN8t`(HNv^?4lQ6>RvACg|Dxi;|!3I7+k_@iRBmsuQ+~
z3$s-t{wn0Weo^vB2}Dlf-kDVhkUlG{0a5OLz}^sC7s6mhH<fOO#zc3mVKwGiZafE<
zRIM|=&e5~zE^=+(FXt$=n(Zn|ZJ4Q*t$`oMSJYLYP4+=yzBLeo0N)x2L@n<cd#WRu
zwgy@}!OX0rlUzp>Ei)TdYS;2o-18H#iS_lJ8mf&N!=jc?@)S1C0D&dSUfy5X5(?HW
zvqphxNJX-3Fs|QMN=l=Zl3pkokc5&UyrlDcN~R>qGqp9oW@nS+dV<5p;BZM`bq{92
zCYvnR(XKnd+9u1s!e&JDOO_i4P6Q2#I2aOWI;JIPwk;u=`~rWK>B<`UPxTKPHjQ#s
z<$5Nb5&mwZ{+-jP>~XT(P<v=U3+xJ6vo9B-wr^_>cE>i;Tibs>%k3(AHy@R&VC!oQ
zHT78`HG&aR58~2hiYcy`6s2h~rshguxT#?=JKI%uPxL|r7(}TL{c$8#LD{rr+5Vx&
z(PkZ63GI%g=zV+=nYH6hH9%7pm|J9u><j*N!xIl{rpN=TxPfPvZesC|+j>Vw=KxB>
z`uV5{GbSnjt*Pbb(1i+ilkX!@qFVwOMmaU&KA#*tv+X9gseW`O_3x4C=@FLLO%4o*
z8ID@5U#%;iLRC)-B$AnMh!r4{`#-}fWtswxc(|MFA+()_$&;|YmT)!?$~XePJ273v
z*<Z&%uGwTqBpP^#Dm(iHYxn^M`T!^-=>vIqbk`YBLQ=7?2cjs$J#12y+(I!tL1N&X
zmH<6Ru}69APy_Uw599`3kER2jcD&d<(`E=8x;UZ^QX{%!MO8dq&r-U}orRGItnDs`
z3MmlA9Ligm>jb566f(&!RSwiOf4c<ZTpMa#+1WeO@r`V154pA$U0d5j4sHX&qG3A!
z?-K6N!#O}=L36r2u&oGpjI@n}`U#u^)GWt2iomTDbsSEWy@hBH^OaP&cC<YwQ`NEF
z38EyDD`fwuWEYP{;6qwqO$(5RQMta2_D>}OSI^Io>p2M_xSrQWjpZ*ssdQ@EAhDL{
zo-lGMCQ+&!<kA79sTa%ND7|23d&mL8#Nm4Ow1*t(*&fl*FQ6e>Xpr=a+}hphRxw2E
z=?B(*=I7oWod<nnZEt}b?<qGF<_^=dTRml+XAPv5O~QDU0ro+nQ!m-uqYbFYavFl;
z=LgVH>t0w*G6XV_DU@Vg{;^8ghJq$(#_auPiF*2)?dT=9$eA|Ox<*1rJbw>Vp!}8g
za=RigmMYvr*M;jx+_I>aI5!#SL2AP6dw=86NzO%-=RrLyv;jIb>oy=Wt$M1!+L!%R
z8q<8Z*;B}w3^~(Vj`Hk6RRPm${syq+Z%7rgbLn!Fv*wsN<nZV+&Q*TZz|}s$Z}!X9
z-NGhWqt{ZLOXzZEz0NHaXT8LS;|MWu);qY80{@@09xmI&dGV@vR`0tGL!BQvt^PRx
z`ilC--dcR{H}=@@!A70t5}P^L=%KmDYR~Ta%szvti=>n>4YMNr6g!qC)2?U8D_eFy
zP44D>YpBL%qb9pn)Dc{{jXA5HFj&x=rS_FmweDTm=DuL)kCy7$cYU#Y4>?=XS5DHt
zY{z2y$>VaWICJ~|%Qdk7H{&yX8bo1fFDRJL?E|6S=$cScAWzDmq}E6h9eJtmRw5~w
zCv~JG+*ji?5WjT3F1iNK;zXr`c$PZI;_LuBIB2nC9M(Uj;iar@e>o&13uXAy5|YN=
zw3|+&gW_5}qj?eXu_^{wW`8+A(~lMQm)m-*g^d*5_U1i)i6aS7-<w(_vOCBkm_YPZ
z(`BPJFOF?Wm&e6?T7`Gy8bPacq<W?b<<n{$%JD_z9eIRdB`AxBfRkm&b^LwsG&_kv
zdsE@xiqP<SLV#((Hpoc?d9*E$vOO7ci#mo7zo)if;m8fc6`j%WDjyb{sxbZBojDJX
z)3i%t*ysUrJ*~bwV*}(|?TI$bd!U@5-5txO4U~K3Tv5RKfxuEmC1nhdwgPwrYEKHh
zKX#O=^rtaWOQ#~qrz-Ey>Sg8q@uZ}5B(*`DSvMS$yfg*FnvPGzZm$xIGwk?ou6z%|
z_o0|pe88?@vXq7(Q%|MA87s;gJW5H`6AOZIk<Hw`3dUv*gc*B~9A6h{QCBFf)Q$Eh
z5TO0jKvVVSIAw5!aOq<5f59FPlKq+>@4Ls8KJG))*lZgAkPzJ$62~$df%3S)a+qcg
z8!=d(qiq|D+f~2@83;UZi2SK`QGIq~h&)64s1<8FRE`u@e5hyRhssU0D_XNnL*;aB
za0^y_nB1#-q8&$7>!sy5{+8r%H2T}pOxJJdK3Y=V-_I$D$a;~Mm#VS29Ki)hB7*7O
zU(faolUr!UvA>4N9u6j)_r{qDaHId2^KjY6b6QW%CrqPCs8>C}CzYukH(U<$UJeT+
zp30qowPGZYuP!2oLWa#6E|1lMq@N6z-E$5TAEyj_iHBK&bDW66>2avnF<_|2l%*|Y
zfh##$<i>+aMg9R_CBPC)ODtYljt>;-jz%Qjbq6Q4Ae~qs#2ZW}!{uP_R9HaaGmPnM
z4QpM9yKhGT)}bn_ImEpy!unvy|Ah6U9`A>BKQHpiRPCM>tY`4ZFm>ShU4r#Gw6p&O
zt9vlPnhXwO4eMQqJk2P;I#`9ZEn2Ar>(;^l6V?`~?}zmxUgVYO`#V;!E-X=C-GfN@
z24+`=mDX_V{E7aqLZIn4<~3T@YyG0xfYGu}`*|BSWwhL1+p`I~I9kq)>HiO>%e4jN
zba}dr-R}A~h)A|E91vBG{3VizE+_Yfugn<Pv)*U)k~E)uX%qs7{o@Y;iPk>W=!3y~
z42&li;xMDe$}zT2-UQjOzGLNDwl^p=eXJa9yNyD7#>%&Z^tO7oa-96N&@EZddS+rO
z#tnjlK&G6fjo!*$XUaW=2YPJZX34!Z@oa0BjN=H<SL=<JTWg1PVZ+AD&9#dfG2?i7
zl=ewu<}^X}5*9;w44VM{=&+S_p8zqI*MM!BfZ1;LW{tAtopB9*!vTRg51r?9=Qo#h
z2<FR9=e!Q|N!%Bvjs!5wXr2syLwnH97~|4|X5GCMbZnyR?>`h-Xoo9y=qrxAo^yaa
zh23811N*~7xna(l=RC=GRykf*f;p8Yqm=6tJ{l>r%SU4dB{hLpNoV|qBg^QQymUv(
zq6oo0lm%zTbhmP84SWMu_ue#4P`pa+VbbE4IuK|2a1*f)R&A0TEKC;lEOHW<SqB6L
zO_D<$d_+|95l%6U(6bej<N%M28zE0ghT`0WSa2{n7j>E1v(uC0Ky960*@H>4clbKJ
z!hjZEUc&uNoCl#2I1!8+L5sQ(_-iquL{64{J8f!?0(gUKVk5jjj?)G>M&I<rW8S5^
z_(`CnEoPGg%pmkDJSXr0Lw9>@$HI7hDhv)T&0&C=EGIbCoX=?v`iZG(KD#$r?&p!w
z36m}kfU5Q?(Bi{h%3`|q`CdpX-y;B`6!U?4Rp(x0TQWrs(hgt1_D+%G>qiX0qJ;)t
z^+9MFhtXdRb7}&%PO(hGMiY@hl>vHI`y;uN_Cy{V@sV6Br?@Rm^8ZTrs=f+%otyH_
z&!Fg+rMtmo)EW)QS<(YFB8svMK^A_yB-~Zd53?>Be=&}90lm%X)ve6BG%E2Y!Jt^*
zzdnZ{>VXeSp8*;=-KwY3={9x1uPbyKM2jfmbm<oqmI52io(&2^NkkMLkph>+u#t|K
zF;(s_%uEFvo+|GUCVZ?f&YmV`YP9yr?Cx|qqV>6k81K5OolPvj3*uNP60x}87e@}j
znnd#t&U2PvNJPWIVCB6Y+~;G;Nnu@Q$gPEL+1QDiA&1tuHxlbEWZ5Br%vQ5wGvo;E
zzlrSW40)*A9_(f~7taaiw<Q~#?%W5f7&TKKD-6QKyE;>zt392=2IqjU9T>-s=g1?p
z>+)EmT=^s6IBcd{a^<>0+HigG`CQpU<GBm^ErCeOZPBoYUxaOn9nLf#qp#Nz^=#nB
za$n7-?C{6X{7$yQTIgeWan&<jfcm#K%y+KbhJ7_#4%J2uWY=ed<$OGd9hob8vL<t6
zrX9GF<?fIhu{U$%#)5M+CRv`GCM*d<C-dZ|+J)&<CX{WO3toIZg9`p8ID?>9&XZ$=
z;0S&3uk&PAjo?yO&+g5aJ8QmXjq_zDyy>E6XY%D4!ZZXD7r<t?)053uAm7lQb!Ytx
z<fFoQG!e8={y{UAJz6NAwEdzw?j6~0Ko=UsV6keDXKR02#4;AiA6A)NAA_c2nRlmn
zu-_KR?KS6__hLC&d!i<(lC@agV%bfoH5?mei?Kq;jAn-xL(T76ligShhPg_|h7^K>
zgs1D-!a@*!bvJgt5VoJ<{`#UN@;J>ymbpZZ)V9$xd5PT0qYb7}K_}&&h|kFd%d9((
zv}a4?eZs6aHf;M+d5qR|H1k^~577RX#&Va*Bel1)*n?%VC=|x)S@Y%c2~7rjyBrJP
zdG)|(SIAM?ulKM<X4yw*j)=?^@{XKZK^UJCI0%Y~O_S+)dwie6H+|fr4=vUQm>lX<
zdQb;Z9dLXMQIzF4W$Dh3ldWom;8PeXP?ehd5as@W_EMDEizs(rd`BILZ*g)G?mJvp
z1Uc2!Q_s#8$-}fS@)R-{&OiooZI~VyVoeKJ;A+{A1+A1jXirolHPesHT`9W@K0xNS
z)pA2k7`sY8)!3Vr&?S~Rvi~FOJHVnmp8vUfL9tL2j^2xkih>;#Mdc1qRIqokYt)D>
zYD@$pnjoTB;%e;gzL;2}F%dP^*kg%Zqp_D9V(*pveP-X|?$mt$|2%o*z1co9J3Bi&
zJ3Dlt99AkEQ?_swTh2h8jSJ=Bn&T|+2e^#>R$8rN{tu|5Y)>?^0J8?Jgh%ObXlYh%
z5o(!IR@5TtFpuR$@*-{E6xMVxEGk^WIn`o$t@P}XphF;QwM;IfdCmGSkvk%2ID&l5
z@8rQwEs;GnquJdha-iR$AoQg8Dj_0Eoz3Q1ZH$@B!k5Zjq@Oh=mbp}3B}or$DlO%h
z2~h>l@i}sUXvO|g28@lt{U>-yr2`Y#@?~;(M#5^;i~8~~GmX=cURY5@xtR)`z0r8Q
zXk5^^W<&gLPrq{zXvUoBVmSblubF{FTE{3r#+o7HaeP?~zu#O|bBs3^<K+@E><T9$
zmsLO;y^wJV>NgAM-7)w*$K2j{s(L-K%5bXM!YZ4n(1Ys&L|JmE&@1{)oy1uzwf@Zw
z%kO^ld+sg#ZlPvqPXK3dA{FqWDw3#*qr}@Kkop8U0OTNQYB)Y0fm;!eDLjFdS^@W;
z$B{6Mt&nxB-wMdUH1$`q%i~-)$GPtv=u##81wL6rS?*)M=McV@$*>FN<16vtZq#H-
zbV+!H6B;ngX&J(^wgF~cS<aLOLy5`Y@<`|E5bU{TVVxJmin-iZdvrW8y*Hbv$T8A)
z?g^|w!ST};Z@2&`a%;^77Mm|O^3E!xm0@SS57p;R5DByMvB|2Mz+6|#?jFk_q^#;Q
z2mnI>(i*Om+e?*Gp?|KF3#6}W;F$ME$c5>p6WH({<z#8}8#}iBM>$ezfscDX$}_b6
z-?A@%f_SO`m2u@y@@#4UyJ9wMq3mCVypV9;A7e{fCHrZvv9DLjwY8AEzpR4Xs)P}i
z*ymPa4Tjv>hcs!myipo|Q?Pb0yRcgBrfnI|>a2l>QsZuH&KkL?CWoC`BOld<f~(iU
zSXfjcfo)$a`x4;qwQ_jvl@)B26mSlrj)szy{F=;JE>m~DfUlHAQ9<N36pUUcH|($#
zST8hRvn~-#<p4S;#F)?_=2Mo_LW~V1Mm()bM04&u%Ke&HOBG{-tHYqVPVVTv0aFAw
zXtNsNc>!7*DRefjD71wQc0JVXk#=w+T8}xs-(+C5eul(2;EZ+gXStrV4xRJaAotg<
zA4b&gA*DHj_cq9BnsqF0qx^+btWRKDH^N_Pr_=mjpqW2^$YOqxM@Su>n#llrE84o#
z7(V~M$h9?Hn8PNyv-ZS2)@u_^7E&&<E1Tq>v@2V(?|#JsKffU}{wnt<{ap&=Nv+l_
z`l{^4di^F>)|_Y4ev?Br{n+Z?<SH4b95K}AFt1o=W@ibYp;jSYGYr4S(Qizv1~k$9
z0V$em6#(H>;s$b<1;Bfd$@~)UDHnXEtEe<%_oWsfcbYxfS4&fMe*rgLHp>B04d7(L
zX1TuPj#YZoX8Dn{5G%#X0{N}f9#70ETjY-RDI1~Gyx$^Mkun^xSJ{ePO}pm?mcLbQ
zVn1*L(*E5FE}mzfz}&XUO|=*M61t;U);6rg^NI~@%{IBc<^eNplZQ)*K<0?w<(1OU
zn0#K_p#<!}dut81!%CNbn`LjuKIqHa?APt`678iMto;r-L)+~HJF`P>Xy0fpnyR={
z9%a9O4ZgnHiDjmG4!f}vVqh_-Uv3vp{Ma2c?M^^an{*LTP;Yk0o;3=3LuR)EQfTy}
ze1Hx=k|w%@QusVe$g=R3J0|?;UGjQ~*VD7C-OwX${Kk&%mW|pij%@QDxw+;Ud%Z^<
zBDJfVzy|z*d3(Gf{DS^~o^tkImb4dLH~hnld*uxQVCux2tS}?`A}qbIJ*n{(@f;r{
z;^uwOUdkb;!alI;RSo3JemS?o!%M}c!b|89?0qI(S1|bc{qkaIwb8&@AApl&kA7rO
z&6pt;IWn_8ATw(xK-t8@a%{o*1M*iI={l&l?2ufWWgh~z_ut0sI4sxnnV9xpg~tL~
zfWkWvsT^<hH9CS>19Gl7B3Glo$B)PhJf{^G<JLcRNKMDJA!IElZFpoc`}!!9(=yQs
z1y_!O%+k{;dRFJSTu<9~1sir;Zs)Ec`B6#?|C|t(I^P6#>bP80t4Sy*J}#HnXl}4_
zC*+@`3gE8IC*(;|9@?ybQm&)jbAk;&DX-CjiF{7U&9#{)S+7&zs#^ZIdvQvR_jzxy
zsBkV*Yk;7t8h7ixf!#a>kA-EI46Ms(e1u?F$4<-JwQmh9=Zx$xHP%7>J|kDD{}y+w
zK%+w#4t0{^vZaj`gdz~m@!b>bu+LPt9YjCkEMt3C_N-h<^NvNIh1lP6)4;wxD<^Bc
zTeGugAwtrjSS6g3H%Wh@>+jEj%`cocu)y<jqIUnEY{+@A`44}xdFN$C`|KcVcmd|n
zzQ@?&3v!s(GY`^%Nr|EThGi+6$}U`xcX+d3aR{YDN1eyw-C%W@!z1#y3~c@1V5X+&
z?61G&R-rA+fUR3TCl0?_WUwnNjku-6`A<x^Svdnw6c-s->_s_SJ8cF#bW#4n{TU%r
zrP3)urI8S$UtE%heVX#v3BE6vu&M&3-Tsj~xIeX)RVf^f9Dn>HSD_sD{*k{gA9@|l
z{!M63l$a)KfJZ5;EK4!*S6v244hFG7S0F$OT-m`ZSglr7V&PY1gXS?Cb`^ec-d8aI
z(rB&na_Qdy&9=(RFW%rc1%bB;$cdE269_O1$o7;a6u+&tbfGNWRS+R3in0u#-#{$w
z2aT0*?}C-RhIO^@vVrZqCRfjRh&<n&BY7corclDJ%X#&;P`tb;$LYnE92&~;Ep!)i
ziN|;GyZj&YdwW<MNNkqTug?R%5OzuG%9&UAv6>WpG*hAoX8dWet5BGM=g<X|@~wMd
zU|(LBYwGNCgr(w{r^Tu>0ZBWrL)nHU>i%`vv&;!JK;8t=Ec5t}o-FK!JRmh}x+vyu
zEw&J^K^D%T&~dr3rPS0H9+pZcQtB8r)tD{HUa+S2yl-F^Z-8VwrU+}%JDu5DL@~aD
z@ah+p_D5;lW}+Y=xU>|j`Bv02*$r9gbj6(Y^*v;Lf)iI{8K^eY$=c8*N<E{dzMLv5
zNT&)&H8JUSWKi;EHMzFhl~E;Kfs+BHE>KgmrisG#C9RuulPUE}bHi%tor>nZnRNXq
zwTGJe_cvmYUe=oRl-k6>E`xeqRV}>QTDUSL2dRaZsD=M=H)F`8D?_PTH8n#`-DyoN
zA}+dRFYs|f9dU}a=3|t4Ku!H+YACg@t7T38nUa4}lf%`j`&+A?O{vq7y2}yh6Phgy
zJeL3*s}|{_ws*aP1r5EZNM|+m%w&NEH*1A)8I&BOCa+WJyM&Teb7Kgl`l_k3)YJ@X
zsy(H?$FvX(0?qa!e%}|8Ft(4HJJp)|98IRbkc!}alyRT<%*dnft!klPRXXGni9-c{
z$W&;Nn(C$YzB8o;iPS7g{aQ^Ok|o%q(A6^Xft1=?O>L#79<in-Qff0PLy&1_ra;Vl
zqJvs>RZ0$}!Uu8L4y_TNFg4pbYc`3py(4p#O}493L|1xS8~dja+0F{9mJmh1-p22x
z^B^5EAX(_q6|-d7ehLZeC;{+1D_kM?Z-AS0eMl5er@C@umrNEdJ#a$5)d@A4S{jB_
zyqZB7`-sm-`s^e=8&cE1!v2h_%7A7R#;H{`QaQ(+#uh5D8$nfth(Zr8;L}rl-lWg+
zYMIh%nQO#tYMJMFO}6lX(8ae=#+&#=Kd-3hFR*4jN*VWSF#q(?FKDoY1QL_V6C@l#
z|L6y!AO8sBxo!;#6D;&!z-EYgb)GI}W3@8@#}SY=LUC8{YouCi42nTJqmqSp0B)z2
z91fI`t5=5Z3_)X6Xrjn0n%+TR9DdRK+~`c1q2c{RzzQnR4|&mA^b6wt1}5DMN_#FC
zMVBcGpeN%9cunP=rx}7+@#QVVI{dEz=7K-eGRMF!)Jr`TS+BxkO6rLs;6fD`1|Uqw
zCY>(<vs9o<NzPIL7L7uuzc$zR90V`w1He5DS?CKl3DOpji%xoq8G(MDBv33shXh^#
z*+meX73emXK-Lk2&KetMih+cqNi)}J|243>g>pM*|Fh`QJqQdO0YIz$zEDokWU|YJ
z*cta@ZwlpLXbOIJ<;s5Eb)n=xLf=igCNJpf{Qg9&<d1+_9831TD<_AJgd$Q{nl9DQ
zx=NTCL><_LcLkqQn3p}+*Brkq2UXg98X5Zv=A4TZb5*M9R|osMNL-FXUiTs#9<?}a
zVEv2aPJuVNB5>1YP2o($e1PPFPGwszi~U`M;~mpTR`Z@5<%9=}3ulSGhCVZ}VfSFr
zTsD%;x(Brh+9VV!-$3GG41jFQ#(UjNCVduN!~#V0<05-{Pp;}-nika>h~{C^^@k>A
z()EJY6@6cJr)m=J%K;vP(5=GObazKZh)`{Au!;BOVCfN*uw}@k9g)s<-G{bt!@wTg
zhruu%34sq}pGu+8XgK;-VG9h(T!H9NIlv2Rh>=DiZ|?_Chq2LpAO|>ai9*sP(WT3e
z4eXZ(azpKP)cZh=D3^;@Hj8fJxjH0-Jd{JF-hUZb;zK#Y*|)RF)H?f45v~BZA~EBk
z9IL$s9p<4tq}<oX)lxklVIT8IZlICb&_{Bh&Ij<qZPYW+Q&^<FE5v{v$-&Nxu^lK}
z2GoJ74?)#OxJmOFd-_NYk!Bq;Ft5jQmC*jjP<)hiV8X&*nhKT`1*@ZAKV+;zbH9oh
z>&pigs*2nNk;qL5!DUovT$>)tO|(}GY*sOx)*9iX{1drKDHKo6E@FAbvQByqO|sn+
zU^wikflYZLS9QMH9#y;)Rh)qa_4^aqr`)&I!DKB=x}O2K_C&6vMJdOpa$UDUN6?kA
zi0)U|QE+EdWJq}`2RYZFgyu*v=_&v=>8V`9<<*}+8(h{dK(_$x*bcJ#r2k`J=by?^
znvTrz8E$U%`qRLYp2<}@)kf~ZW(bfC0+2E?8Pe01WsX#ZHce`q(9sIZ!y*Ig2-a(4
z0^3^{lOtc@9B4AQu#J7j!Dn(kO>b8GOm1C;*5$#7m}An_r*(cQ$(ii^R%@D&8)q&W
z*y!hSC+ACtkjDhA1ow^ZqSMb|g>#HxonBzd-)7@q$c-W&A4Kz*5gUL$<Kil4*b(_H
zkm&^R7Y+Ul#<=zZ8?ZW6Sk;$u*NE(PNIL{1nkD({8$cFfvkxI&+YiZ()db->u<c&^
z61&w426o}4>>v6UEkR$2(ak`PA{qdBql<|tW`>@5y^_0X7O_#U<f@Gv4<Nq>qPmc@
znMfO<t?-`!;}tD2=}u#b!J#z%HP>@rtw*rdG<N=#oLu4hQKVwV^bvWxLn_vJjnlxo
zty$OCusNK=F6y=HTQ!cd?KSCkLsr8;MiN`?8cvQs!zcw#fNvvQHeSo&nk44_2DkHE
zMzh{;P~BMr%X)(yEdHK)BR8!ycP}dVoBCXa_FtJ;+r|2DiI^k=zi^=tMuqxs<!Hw<
z)M6lhrN4!jyAzc}fA8NS@W0ra{`6L^q-NTRU+3P+f%cv~%{KO!xqpCyG<y^A7E@XC
zU3M1=_GUKXUTh6I)itl=w=bjeTUgLgQOkF7cg-NS@||3*{pmgE)^!Y%dTgLfTj1Am
z7=IUIrzswbUx0s!oza%7v0M*z7xhuA^)0R5O=gp><4_~+y<FPsEQuKsn^gOWe^4t{
zj3~(0-tTb$afgk254&KKWOm}c9OCiIZUhsG1E#HRD@{+S62YSqR4%c+nNNYS{JSBo
zPO)4oVkfEGodlkN+&nOLVQu{SsH!a|MOB`aPkvI<41nNP0~W)?6aW4Jse7y#7SF4!
zh6$c=-FG3-rAdy|++<(UZx{StV3NDouT7n8V$V!6%kbWbcE3WqG}IZS;z5{;9~tzc
ziTTGU`Y{AMZkW*a<I^BMJCF>zD?Yb^YfQRL;@@@nmk=u!o}ezUV3a~cHIXz2{|>ad
z1<T56cxTwD`)YVAk7bMOK5={-x}5FR@X^{AOIQOfpHTfRjP^;0UE%0bkXXm1Ag<oP
zm_1|Qv3iH}zf4fUm|a9d=3nDvKbBfXagW>IPw3_LFXBt|@@Sfk!B9fH2MHx);Zr1q
zp)4%il!V@1*=`UHCg=XZ;wo{a!MOe+>!C-;s%putF#)04oO=?lYDC8{Q^>;sO?UHE
zRfcaMdY$aKPefe+h!Gu)mpb4J?kW9R(*bvD@YaX!DJk~6o2EHiW6zs=^oB?G$Buy2
zmN3bIkJ0}21DoK$hYZ<vgGPIYs%(2p9rz$`G$A~uESJzR)-`DY4R_I9^Y+A(RtrLd
zsh=2I28~Tc!#kQuK*PSRDjK$faaxt)+ZrbH5m^`9x1hlvS%HR?56x&;0!BsvTNM#i
zynu*mxL^Lafi*47y&@a{P-o<tR231mTM{Dt!CxODBC|A4*EW91o|NXTwXru@Ge_P@
zTlYO%=*VknX0xM?+%KcU2Jqh*@E?Xx{97F}qVT5r+q@ZyrYs5ITXU8&lm!d0ja|r@
zvV3XHa_0m_Fxl*^;%Id7P&=BCNF9xaRV9yHwQ*mX4JyMC+-jczCl+H|lBOJ_8}sA@
za`P#hSeE+-WFeYlk*|xZ<Pu@8`UxV)t<iaXv8l+x2;*m29-#S-oh{4j4M^)vh;=%3
z7ii3NxKtDms@~X%JM&=5`#%vC;9QZ}i2PKh?1cm7Rb!w#D)+&Bgt|;=;4ZtdWfOBr
z+(}4-nr>`lpgxBqhw4R<UXFK^#_ct*L*@7oX%p10I^}sPgzB{NJjo*$&JilV{hOHm
zKy^G#`kvh`&(nN=UP0U)Pw}ujAaIPhn@K(}Y=wcPIq_*)!yIOG;+v&T%MEOWGY^*n
zel)Pd&U|Qt4J*~6K`0rQoHNuBv0)JvTx?>MWz_k7xG~*qaxuA<jA?|_ARJaMgOcpR
zy``r64D34>UNyKmvZ8mv)B!koeuaPF=8*<PAp0&(*)gcoE<8_~z0|-4y7E}xV601t
zjqJl*rtNwM3aUN!GU;NFVW%r^ARWite(lN|OS_gBSc3{YN#eKT+444vJlUcOyn-$_
za;dye7zcj>87O>sig9tlo(kMUBRRpmd$A(lCZ)&*#@u+QB>!w+JKXqK=>{~2y6(J9
zz{xF81Ibg=Ubu;xJ0RZnYqADNa_8gR*FyXXuO?ta1U=cb+Q6#o_;=dDo!Mp`57uro
zu)lS@WybYY;L<~)BeCD6h`D^=hGi~4#Y8P!t)^aRFXm{MYnJJJmQrVk)a_w37^5$w
zeBu^-(SMnVG4Ww3E?IYQ+$RugoY4sbhLlYam-&tZ&SVd+i>G=vQZACfiMd;-23&Ig
z4Kv`9OO_r6=pr)mtyFtZnR?(Qvebb}Ob&bHfu*+|JiUC^t0XV59;Or+*f>vKttzlp
zcpjO>#4~sE9CUM1XpciPG*8GB;|g}vlQ$~21Z-6_27%!Y8CXRxUTLr&x<TDfH2RdL
zE@p)-r|NL2tARL<s6}fMf$%;Ul?}oD4Ae_%6a3Q5EzXLiqBw;!PL0DC=9yCr&7qeN
zYbCe%mV5ER(m#uF1m(>Q&GtgiC<>y6g9HWpZ6o_QW+OR?3CIwd08pe|6LER1BKlHt
zFC8bj`!^Zb9B-ZyFlrMG@v2daod8YU)%B^_c?YOj1ibO#Tcv7?3~aj(50t#;8Q2vc
zOpf<+4eX5%_m|df!I6nCuPSW-B*B*lNj<k13O@7YjWklzg;2@-z@oEPVqfIP2T512
zg5mvnXoVr0sb@f$=;vtg@-TmtJp?Mv^5+SXGd5&@`}2CzZ@&S_0X)WY0wK8(%voPV
zCgtvMgpP#J7kLKOH-LB5jvT>u1aPmie_^U(4{3C<$3=SXDP8#iGcAA*Fa5$)j9u+5
zmU?-eyA+Bko)ySv`aj7B>2(mmB;*bjji;#nj^tepG+bddgSfYIkENnUiv1L`+rT;n
z@qmbHYk_!(LNzlDBhJ`ATqPeNKgf6hXILf81wLIuyE2pUW)vaz*shNkoD)HOgU>zE
zPH`4Pj7>a|h5;hxuW{Z+_Cql5rOjGj@FtkYYuwvxq6ePeQ=UACARqy|n0BE&MQX`$
zRvOA1YS$Xr^-#><i$5~^Fuq?~do?=}#+$m;DlmNDu>0puLxF!dFKh3n0}t%lfF{i@
z((5q!8%FTj($85?wj+3|w=YCFLSOuXd=1b=b3P~JyBNX0ZJzTz@%1i8N}_bcS0IQv
zoN1JR3<5+TS}>x^)Qx}=_ol<3u*1N3RbE+Yh>v4cxxZ!(E2_!^Jfr}i6?q(uT_e=5
zbYox;3#`T~yY7UlL?OPReqonn?94h<<3YYxXuTj9kYmgara~o_4K}+PmWMXm4Qy*Q
z9w0>mPZv?7nL>Ss<o}h1I92?cfq%gWRF)`VY#XLlL{i^a@oF)-+#@ZHeond08db*(
zc!&jPaCKBX>30LmrjMSGwyUf2@KmmHz=1I0fDJ&lZQUtXip^s@aIM$`<djo`M*uH7
zGSq^(qTo0bED;4kk$jwX>>{=>lE-L$p0hKNm|hbO8(5PXe2G+u33sIiZ>4=YkyWe7
zXK2I6u&p(Dm~<Zc)U}#CPK&;VMDbQ$%SdKmRtZ7%J$ZXVHZ(`-)F}Rk7Asa#G-mlE
z%<>`8n2xQ#H!wMxe_0`Y1P+g5#Njc9bP<z3vKEiX=-f~&0SN~ofK@B}QE-1zdl6PH
zws{?~d`v!ISw7ZNYF#yTZhcYKZJ%ZN$fHzxlYpTFY?x%O1TUC$r56(`A)$CLC0s=e
zjz!2?i=C~-1GQLHU)16a15ldQi@{=S$o*B=V4TW8^3ZF%ku2jqTown^=03sx0ka|c
zFpjV0pqBe4-8;;1t5!&1f4^yd-u6{K@p?_UY;29x$8jQO|3F0j_;H+xfRZpd;``y%
zDe>+Q(k$*ZP@l-XW<6l$cZbaN(bTc-?}`_y^|kq+K9bWctsbvxuYDO{$7a^!4ek5C
z!q?GyV8Z55l<wE#QCdjj!1~<BLxR-X0mdx}@`7<Mz*J~kAJ+&seqmsr*XPv-E>IhK
z>uvUsy-MokF%&9tN1zkvg%~UlPtXEDX^?**FRn+ZY1RvGf;`>L^{qi3D`NBJH{ia~
zMu_8p20YZSXcVwtfk>vZBlZCsexo@lPcX2a4Y+q%Yf+Y2*et3HGnhkpvg?fNDt>|A
zBxw(Lp%qo}yw-qM$(R=%YPW3~x@o$WnA0RN$AI9pabEDd*3?2mQ#FA?<YwcJY4$Zz
zH=$%W_{*4>_=eVrLSF!+yWAxJ(j}RAus3*w{HJXmHll!FIW8`n@v^NhttWUr$Nf**
z?di}=V!t}G5;b_K=AbG3*aVu$@i_Bc9>eR$&M$fY^pm^Tt#;F<^MBvPu00>7;f6e<
z5~?5)^!BtxuV|v=0%h2RV)M=BJ{fG|VcdznFbfvUhTKbc+k>u9qB|vd$DBppwLj%m
z(M(da4n|g&M%=5+*pjR)su2%F6qmQ-_n8VhHsYZgsroktHnA~p<1tqtrivwsRZnr<
zPTXpaAD2s9Z@JZc;VX>YN>$rlh^xu2f0As(o#WE#$6#ae;bL~Ot?ZUzJY4)Acau*6
ziUNa;hv~z5H+dU=5{4?e6O+D^Kb+s6T!GEmg|+FwufUFnjKI8Qdpp3$+JAw86~*$9
zSQV%~FJ-+28zI=<WE|;6t#<#QRm=5U_pPjD6D-%W4QzN59_BJzrKLT}h?%{-39nlQ
zKykBkui$j2RFTPKTv2hhDQ|vLUQ3$u1GN99ytWoP(b7p%gI%`fsr8gW7ED&QJ5|;N
z>x9smn1-<pHe$6AIJr=PdiTe2-~`Xmnd@+f<9aQ~{*`u69aoW|G%{G0pM7=d5$naH
z_u&!ie#=vRXHoym+x`y-3el7vmRggwZN}rH7ZRUhKT~BZZ5fK7{Xv|I#}a0tW6ib;
z{ek`w(l``q;q}ne7_F%xGd1Jk+L;Cx7nbVDVw-ahrz96K$+M6f6Dh4Z*OebP977nG
zXmmjmo7|i?l>VNAJy&yn$?NF?5Ongs3&>0Tq)^qkx$v2RZEV2<%6z{m9%5z}HjWos
zU_G4y6rO47C!NKzwu3%4<0Cbmdwcu<-X=Dx>O?4Wr)7wQZ)QAipv^I`ZSg$RC#Qr|
znEK7aLhW`2qET4NFg;$z^Jod_to6LMe%|k=tCh7bPnFfj3RZ&NG(8_s4XG;0Nm)>z
z3*PsXC}uKlFK0W?LA6JE?(c>IAE2HDOpt-orTdy8_H^l9C$WEu+29m8sZ>9x7UtXc
z6|%69S#RGPb2qS)1|FczHn7JA-n1;GqEY>kV%9oU4h+g6Ic<BzzU&k#uU@e~aHyEg
zKrZ*>k8>RX0>mBr=3r5Adp#5%bbH;;9=!UWckDxdv12vc!Gh@Y9W>HJVEJ1E8`&$*
zoqd<c>(P(hiM*Zfx9Ct)FgeU1#s_!<g|==3u^15FQ+xrbcp5aBBq&7qJ3k4EW&(Ig
z^q~qq#0~l~_$W@|_57x(ROwTisL~1?Yn4xkv(gfXp86k%&ir2q8(MO2?NppIO_?81
zx;u(?-wS%R<UXZx!_(m|#avtQozlvF26nO)uNIOegr}=@GJ%Uy1Hnb^f{Rv6#A2Du
zqohhGkebW`TnYD}P9+EGt}8ZZ8Ogkg-*Y%J!G}&e#vZ1NqQsov$;TAY^>YVd#_mn#
zee6-LJDZvFQ`5-H->4&ww5KXO!Qy5<ELo30TUeM(#_B7<QI}g|W3>>pT;H09YVr4U
zYaT*>(HsBrQRccbB}~DfHb52tpKxVL8y<j2d-t%TM?k@|1JI|5ZFs77GWLmWcxC$g
zvJJ1Kb#Y;VZFv~|uCS!7f544Qb+EOx)KfnQK`U+kLrZfl6X($oGQn)Q!fNe^8C7`Z
zm{>VV>{<Kqljih$Qywb)ccx|dY(pwU$VJ&ua6gsXYoycAq@K0oO|;#rusZFr6|Vxo
zvi3YzS^$N)W(U4ZYSYzFaIyn0t*LNt4D`(Gdr4E?2Pfw^U4bTD*pYXWCga1<iJz9F
z&Iab!nb(&_LS60DnTJTp_?Xz4Zwo#c2HEI~E{Ruu-z4JQxCY6vD(nUa7+255+8i7?
z-JN~bg;%H>?Ix7wH%p;3y9o~IJP8BNb+TI~RA%fU#oKaS2LM-=Kz$qLeW`0zTI48C
zflC)IBE{UP3@S^8cH=5E&SqQSK?Us^fz`@mizIX%<UMgYz;2tXIVHSXH`I&3fn7Ob
zx<z(<41Vt1l{bQB;6>jHx^jaSIwghmc1D1Sv1LTypQSJJOibGio2E2O$eP`_U-_|U
zfnowBQBvn_yso_+CL+7`ZEAf?lqp@oBFDP%Bp=Er=%@;DEBz@p7Z32ujqHKvtBX9X
z32@bf<?nM><5Tuocb=dfW1ui8ZmtA3&c@R$BrUdLqkFD9Z%`3rBUb<RIWfaX%*H(2
zk>?Rww|#6;FJ8?lH}aN|_JaP$I-^Ucdx7^0_Oh3~_-k(k5|6akIO~QZ&ZMh>)uc=s
z_bX@Z5%6{4XOD(yG!$V|E#b@#dp_VyJ$@2re*Kg>GYB)OWPykZ)_YYMNzHv4j%g|_
zKsHkjZ$U0?UxPhJ<B`&Ykz(*3?99^kKCDe29_UsX)zFB?J)uVWOr{a%ApkpKF_ooT
z`ni!$J7A<D7SqghOmm9G6x5eT1;wXR$$yRW9#hFln48uiie)jqFE;>T&**ALZsg_m
zsAg|p{*^Q})xetf<8jWPJ))8wuoQ{>8#J*Ij!{XbW5)GA7PISR(`!iipNkIbSmko*
zo>Cito0Urs3T*$m+G+lfD#!)P+cs?{0^>+mRu;41wsJM;!f^AbDKd^U3E;_XWiQVh
zhz1(@r3X~W{;#PQv}T%Pgmg$ne?^QC2^p;d8BbxB9o54BdK=n0w+%|xJWkAR1%XXE
zMac}CKafw-K2TWZKpr6#4aL#!Kwd-IhL6hwu@&pBFqc8t`g{gJ<RIQKB629vlI$E4
z?@?z4Or(8JZ~SXJF6vy~AfDt|l>8rUV;TmjYT1l7=z09Ux+#89pV{`@wyrpgb1<)6
zB_dI9QIOzS+J*+<bjSc0OoFjL3T4_Aw<Cc``~L2s_Y*{JRnPSR_foVMaIZRiQ~2dM
zaKo6-!$R~}ktJ1eG5)y{bBye26ha6#m5Hv#`sNDjq}x_#Rh)-FpC;1uxl7n+h5Zta
zVoP>S1<Qx<0UBvg3S1S2@~P6*wg#3rl(%!r^*?k;u-e9!K)}PHe5F(~5hstscpvHJ
zSOa@Ej8`l38zcz)9q==1IBX`72?qAVa2~9SzC%s<ic}r`Re9mWa9%578&++YbH`Q^
z1}^M*F&T#;M>$;Ub1YJ&C0<bM4{r$9<{p8+zeFd1K7N~O%!Nd;MLcxX&w0&=$WQCM
z2qyTb&Z}7EsZMtMbM9EyLsV#o3g_2OZx|tyuJB>E+J0I^2XhskwV$co%DF||8aujV
zi0NN7_bing>y`kV<$l$?N<C|D)dMFA;)xJwa9JPcis)xmE<?V$mH4SobWF}2>T2A(
zkrj>LwaU%HgNY<h3q~1Om2@8BA>X9dW<WGrs|BZK)*hV#z0^lz&(78!JycR!7+8xs
zqYYAbd<+}OE7^CufrX${vmYz>BRQA-WJ*)<uv_fNV*#+b&{7xvxmfCAt4|9w8zjSf
z079a~CVw+){w8YvcT+9-tDEz)pi$gkJ7NQCI*O+_Ign(IDRP-gM;Gj`!;5^_=21Kt
z3*6ooK+@$=yty>CH!NtQc|Er}K>4oS$Y{2S9>vIqj^^97Q`fVIF*w`_>1AMJ$ME)2
zhtPTK2z`9f)4+nqav!NHKAMc>jU;IRc3NY3aErEA^1wUdx_XfD6e2PZGOLmfqXN^7
zJ+Zv0Cecmihy%VTW70VwlghK##`5}A2K1*gZz-r#<s^EJuK!@{uv81Jy2HYKvR5N;
zJo*JsvVXP$T1C{__$q#mXp@*X>M~X812(tPjh*;{H;WqDj}&Xfhk2X0=e|TPDdQ5e
z-4U~-?;y0W!)6Z$H@_E<-_6GHwQi<MR9_+Fkwp!eKc2@{YueY+&&Z_gvtl#YXyB(^
z{R=XD@OYkL-(e}bx~KPw>RyVutM4vS)pv%7sv#riPvE0Kt17Xe)%XcK#`h9%u`A6=
zqR|+YIAB_#VSSc<9?4!$;9I1j{`1(cU-D`w`g<c3z5OL`Aq|6?R&63k)fOL#6JZk9
zfbf$ha<9*dJCTffX`EC@o3e*S!-YI-wD%Kes2NmS1(7$r$2Ky#L8gh9{Qf{$l8<m4
z#Cf8z5%Sady(GegJT$&NpJ!_(V<(h;-r>Jbq9fWKWSa7?@+5?``R@RNO6HDVP~R5B
z<7&>84b!~6r>0<l=GY}x@=^S&pykuu{jhSG!k>~*4fltj{xC<%@JU|UjxZCSZ0zB>
zuj7Zh1beh3X|t^vE~U=*F{L{|#iz=zea-hcj~-719TVnd0x=6&dONOT`zG-Y(z|g6
z=9|ImAkK732G5lIYGCh>!T*%TB^%iCOg>M#2BBPkG9Ms~$H%hC{IawF%38)Z+$cFj
z8rWx3c(Jq=0)1!}l<#KhhcA1ag|p>K)v&>v%9}{J&~T<t<#VK0>4t*9X}p}q<1WUC
zy}u(|dn~JX&%N_!^3Ow@|HcZJeF3-%QWtPo?plr^V?c6}DoI%0Ox{=<cZVIH$%E1L
z<vo%;hcqYDML`EKg?EdwMPSMES1{R;q3?U(;sflakcp72jJb7}91j2q9r}(UJ>BN9
zfZ0_Ic3pwaOt6dj<xJlO1`)V3!&DzE_rc4V`FQ);tUcPkoH-L<@c>p=u?faP?Mjn+
z9Kgh%KmSQHW+4(Sld*kVX0dimuq7l{m=oP8vr9aAjh2{-(YwDbJ%!b1(X>qHL5v=g
z-=v#QO3Mc^x=Pd^mX^oEJfhHBt5*@)#eoKh_Cp@`bzTOw1IhrFlO@$L*XW&vGW!qb
zsdh;AD31rVRqB0GJQ}6w<q0q03R7Yi7nC!FyCYF0A}ao<-B(!Ud(Vc6=o<75QY@m-
z7R#K?yGUOl3Ht$e_HZ_@<lEGoKI;%+XhLTj42h_9;bl~XMYT}dM6DYMxFu>GOP|9V
zIIe{nCFX_e_4Xf38WCg8qYkWF6k~2Fv8UN2S`uUKZf!X5P>i|bwdsrjoM3k30uH<D
z4HRR}w`<3F#JnHJmaB~FlBQ(1+KsJB(q_s*FJpCNEb@b*joJKZffw<Dj7Gx&2px3=
z5y9xneb6)rZN~Fl%KuR?x~sJa_P>JB^+AdM4o3GQ%GnMNIIknB|0o!pOFW!0C>Y(P
z7OK##w*Ny3Y1Vw#Rt7T(%{K)ZEwkNbH>BF@Nb^k!7UTFp^Bo?j;-V)Wbry>1nXk>7
zualble`>z(p~_br!b3w%0XC}d-HcCE-_GV5>*NKA_CK~6XJb|ohfdy095}Qcgp6(g
z{#7Xx$9Q{>;3$+VQM%#yg&n%bAh>5TUPl_&45FKH51(Gm)OyzcLG>J}L^WiQOhI(k
z1w6I;B{2hECLzQvmZwl0;$c%^UA;kX1hIi+$Mhd_grcsMQrC9j#j4sAYEa)eirKz2
z)u;oU1<*kIZvW7#q^mLnrirR(7XCnS$SU*$FY)_WO>~O<i_FaZP^^tE$VEb`_a0jk
zi{TffE#yCHq+`$#%P!)Jq?-8nX%SC`CV6M4#9lAr-zVfc`0bSJOed0ZGlCFq2D_Q+
zIKs~!5tR&MGhBCYwv(JQ*cB1;^>!{Z={}N4HyyaxRRw)A>u@31TAW?X*J}%>v#Cq?
z6SuRN%DZS9nllV<gH>iJ&(U_yF7RB&4``&e9>Du@-aMn_w;=geb(mBoa9<f55fATZ
z`r8<eo%FYk8D1TpwDdbnEg=+J-F$+;GgWsxjl5NaTVywgLqgU*L?Rw5oPZCZcH^aK
z#Hny=H9p2&z`_=eP&1%*L8z@-!AECgCcwpk?p~mvn(fL|oZS8(I@S+~W_XIR5-KuZ
z6lkTw@sI)T;!j0ZI_usoiX?`kXJhfYizQ2mPe}^Gd?Hb8<Zm>hpK2QKU$-a@$1T8~
zrJdeLDhhz1&0t_#WFAs)4gkXRll_Pkseg@o3W#IZpb!Gqihq~kU)yyQN?w60r$eU|
z4GpZG!n56SiMMPh6poeVl)^_!6(DB~`Fv-OS0QGkCiEbr;sJ7mnT#f+l5Q<F-}(no
zxZ&D19Kr)YAi!BYi%*0thy(!E&_2IX?^+>;wMQ_qtmOSASFF<qSMp9$L45-Y`jI#E
zc+-uV5^)JeVA7VX>ghl79+D$6{q-YOpmp^Otm;p^q2HsfmfQm{HLUfMa+UcL?=3yA
zYhX8iLYW`%5xa^v^uFB1Ql=f|qqPjnTgCNwocFhO71_mAP^$EmVRc!}lS<`=|5XuU
za`tN8%6>e`ux9mtbYq{d`@9r;y_#37n*<nXqZ7>f_3WS3JqbVq&7esDS(_3vHEs>Z
zTfh#-9^<Cy8a^7~&O74s$r>K*x3w*p@CB@i<U$uj=V~sS3&{s750j?pTJGugq5-HE
z1r9UMubFXhI9SVjVq$mLAh9EBc^j!wby!T-aW9YMn9x>NeoPMp#z0!jb-Z5au&Dv+
zrS%i247b;_!mf#r^xbrO-JvIv3-~%7tMOjD%49kaA6CU=QOxOJ%J}`Ng4gT$9~#LU
z>gmo6{8aGvH}6e_mC2PaH}?5nA=9p>K&Dkk#ZZEP)r}i@r3y|J40iB^EN?f~A7{tC
zi{NNiFWHT~-N?P%9z)a@UPk_;>~q=2U~Nn?uu8x17B#+n;ZHKMI_e`ozci>Ek;qD&
z7Xo++w9CR2oDv}PF3PZ9c$jlD55V$7;~sz={)M-UdyI7pw|I&!Bd!Q!8Dg6sY<8fO
zrf3f;k8LX~!3bs&h6&&Sh?@!_cZ%xRw`GMHSo=*d#-0y1u*^+7*rintW+Kvxg7BUK
zIBmlw?(Tk}u9y_+7;%-#VMHO$%Qo>4_g_}#(GCdVSI`aepEwEev-1G=EQcbNRVV6K
z9s>sX+h{2G{8v8OUV4h=Zf)U5weKFYU$$~QoDe?vCQf6v@+jY9SiK5&!Sx0hOUgmG
zEHlUCJ7TVE<GyaCt9{5Z%WB~U{x&`e9FrnT?5}M+se5BA#n4oQu9k@5Kx~q=>L5HV
zRv^jBLju>%03n{JaPp?z;nab^JIRGOlkS_+w!}Si-AvqRzjM#%L7wO;iCyrAajW2u
zGX@KPWcwpEo>H?<6X`2}vycDITSp(dCrJM#vQi8#oKJ$A_Jtz%U-%T-@^J`(!tdZ@
zW75rS3Xl5jJk&Y2JYXvI`vUg$cHXLKV{im~Xo&h{nhNS4I3TIS&(@Q8z((BYV<vuY
z6+#ymiTEdc46O7H5I@upPPzCfH*+$CApBM9VNMO%!F}DmFyA1)t%U#iDvWA7cyRrv
zi%Bwo@Xd89;VU+w<^`_L(o);tK%Bd#=udDw$Yt4UFte=iM?Gd)k$=T3E6T)TeE%gY
zu1N;=a3^Giq0)zxzk;oySym`Z%(5cK+bk;{dE3%i$cmmw6S89asQ;&|Schb@tavy7
zKV`-3`DR%$#Mdk<*50<t3jIdG3(-w1yl}_eEGv2z>uqGk&lhZEMKfn0z(!V-!7_1f
zA7sU!HwD9d6>E_dhe1=TtT+w4m}SKRtSCZO%$5LCxn&?=LRK_$vd9W&=oBBwirmI#
zS#b~2Ovs9UDx^eKoT*@7(gCnbWj7d54?tEd8gG>qO+(?7eE_ne3iuccsFh`Qoiob{
z?L4!rNChL4tO$mDasHKils|;^*&-~i9pEPEIhKbT2O;{;Jk+z=hj>kC6fij85bx;m
zLyTqFb8)dQtfH8M4om-G6uWibT<n{Q=3=YsTZ#n&4JGUG?mzi1sUt@8%@ID=w`o1f
zByQdQTF!P!h21jhC|@9zM|DSz^4=a*>soRyD{HMT?ik-M{pAYt^l><~{!^%D)sFMc
zAy3iK=)>4ef8XrI0qxjUs-(%mQ`y+0;T<mIlm6nVes;B~R-yEbb+m1t)PVHAc%0i}
zOgCF)r;fjY?fr|7%xKVswuEHQNKv=Kwp!(ySI~G#*&)SlY(3J{APHOJ#nYk)Qi1T>
z(dhBHssaUI;*?|+zH`VLf~=$hRh&*L&^s^Nz75Q4pE#w`M=`mp_7yV>CyJK%F_i&g
zlLvMTWUo$eckj$^#msWS;yNbGMJ&bC!jNxSpWo&^jZQO%>PFokRlP0kld1~<QmYPp
zIHgR%$Wt)bROr^5@|nYe_rwno7QEolX=slQ>YnP+8Qe*@Sq?Uqv)sq?9H{hxofN|J
zGfxA{J<HQ^Cbs0?y*RV3Yrr42?Hb3sALn>WsRD%4(sMkfdOjGR4mm*OmIC*}?Y=FT
zqwsej*2#%6`v$NFmX^-*N>Vi~9PiKbuGPjp1|ce85gD*l2#&VZAUHzAvY=={jNI6c
zfZ(lK$gd6Od0bF`f&y8;enaF~iW&QnO1Ate|4fSoQ;cgf=G({PYKiG&9@p2m#JDQq
zk2<cAe`8!5!INTKQ=!3pI<A^n7C#!-KljYzDreHG<LdmtJTCnrF|L|bEaS?89K^Wl
z0s^N_%=Qx(F|K%mVqEhwXk3#Z4?h}L)FnPlTJ8WF;U(_xnO6n_6MCcgN67dvh^f<;
z_;_jKT|H~_4<Fqo2Q$eg7p?2yXn$9rklqb)#|lm3%k}@|8X+RGJN}UGyrXIo5%V!I
zrvt^WdjzDoT;@xqs~7cb!)4x1Y6$W>T;WZ;WBdqB2Z;Ptt>nK668E?QxB07Y^lbbU
z-l<ECyTD0%b#g`t68jOP8IVzy2`oJewO}dfjlj}?`68h<C8+!9C?tqyi>?BOw}vq2
zN>_O`?^a+p>#iEZ7(-*d|60#JyUKli|9UO%(i;OOeyGG_SH;9!sI4*cOeKd;d1hOA
z3(wsDNAS#i{2`v1EiHuP73}gHvf)#9S%xk5N9>Y(+srN#Uz*wF;2kr&{5DsNcUh1H
z5zk%-MC1d4=mgGKYi@vDekCZ_#eO`o%Y#y%u*>cne5zY%EktG<P;K5}EGq+j@g{HP
zwh6Onm(AY46%y9o<dxjM{3xL!5^mq*|I}=B3q4fHyHnlaM-aqIC8rAUBnTW>E8o(y
zN4I#=z==1g?_Y(b86#R?1Ds^irP|X5w-x?13tune`sPTg0o6+dLJ5TUFpgiNDr7+_
zR7h{U<p5J)C8`ud_ZUk<x3h=xT)LYN+j^UG*AwkX@b&!@u@3#u;F}G*!)y92EY#aQ
zNpz{cJ287t;-1${k$UKfOAn{5xyX_EFZZ`!PG1-9@Yb%SZE7fIso{k2ziW6jqojuO
z^tIw&zQ?8EJlZuOGy?E$TsMP_H1hiP+wbe`Sd&t1J?&F5C)vm?!#t&Wuk`G?k$Zc0
zdqe^ClkuMTu0$)bZef1874pFWldl4;6vko148a`P-WKLq4}rR{5cSWyS5kij#FJXT
zGq|hFUGCSYrg(Drr7<I&Fg64XiHU;69{0|SjeaEi!%Jg7k=7b%wsHsOws(2B$Dl;9
z?vxL+tY`xODOhxu57TJJR$*oC@wQcZT+-umn7R<BlNA!a0X?z6>VEei*6mq@g;;ep
zxW^lK)-jluvM5WP(Eu@x16Iig_jrG|H&}RWd326RUohZ4*K0DIV9+PiMKaBCTLz4|
z2u#6Dq)T(BCbgh@$=VN#jW4kxMA?xG$mI-U3yBy!%RJSDXL!L-Ylf1RRt#*2B^e4n
z#1kdVL4x@nEv?Bc;vqEh@|c0PCP3xAp0$6-!|az#4MDKDhde8;$uy#u)A0&WZE_vz
zyOElCV`mSL7<-muDDFtqR?UJZsZ%Y;J;!{P()E;{HGRarx?X-llPI<T)na5XD}wmy
zbUOp46qZEl<JD!DFBRa)202H<7<P-V>Z=DI?w=9ai=hbFk~YqcZFs~3+$KHya2y`*
zz?F~q*X@>`7u8#Pbom6jxYzO)x8?lE6ut(lxJ8-zq8_PZSB=g?sM%MbqD8^o@R-Lt
zr(^kX*}NNwsWb(c(mvt$`}F(^Lh?LZbE$Sb$ORgZrK$!d1{NV)UU!*#3aN#-kwO-U
zm){6n405&L!W{w>3E`7O!WU&N32$#x`*sN9z#mA?$Mvk)Gw#{oA1u$P7zf2JQ*m3^
zRESUpRPnv9METe<mhyi<rdiR(@}BW=8gJ(K9G7YWkLg*|b6oYh4wbvpa~>1@;5|kj
z9~OtP1+Vi5(Vcvq)r||@`t1OQ&4ukH8dzBi6`Kr51-qZ)uuhtMM9+@DfQw;UC=$jO
zyk5I|)|%R_5jBk||DQGaW7$K;oxc<v?_J8$@mtqzI}R;A{Utx+@A#)!1`8X}c;SZy
zT!U7G>vK>V`n=*gpF874RrMV#Rc*gUI0VDwz2Y4LGNF2?^fM5)`q@uT)EvSkgItG2
zUlToF^Op8K=qu$lH`tdke+95DuX&h8$1cC-o}OI}f!>=1y$@38a_T^JXc*<*@F-oO
zI`%|haqLfG>?6v=vy?a7y}BKQ8%Dc&qUfU5N~VKXY)7lw&BgtdA(jm|O<h;apcq0`
z_RXz`#X++h!L1;8#YfA__@E;O9AL!(^dvLGQA@!RV*OBNXIYxK;jLB0q<8`#2nYg5
zBS477PQ2qaV2M#4gfQtn%sE?sRtEy%g3SQw`WPy1&rWy?_3S+#>g~4SJq|4M5CInY
zn8_t;1@$P`Ve!xGdNKEq{(<6D^q$wtaKn-z=6uPKfk_txVVjg=evudJBJ}m)hY{T;
z2vwMK0rUp)5NchE`xr5ZU04ZJPnvQIk0X6hvi7GXccY{z@)V8-%Zqta?fvy?uZ}^Z
zdQ;5nwXg>*KI&Bkl=`UdUZC_xy(+?k$mms_dm(JJi8qeS$M2+^1od>WERHasw^2=2
zQx!M_Ix(^prn8hXiZ0{q2)dG@bJv1LX~?)_iqxV22%(Qk#Q;vyD7%}m=YG^-UvuhE
zq!ww#<<yTl`x<hY$|oU*g_XWfS3qfh`=XHVxf12;z4jAAi?gD?U+TYqpbT}N3q~k%
z%}dN_L}56<*A9Euv0$y@(Wx1vW73rUjzvETvWU&-*-G$-EFn;cAZ^(L7@X&SQ10=5
zpvm<Enol~fXMbxHgZ9{Z(MD`87An!kCTknPwr!~F)9KTyZl2S#F<PZzjg{v<rBFpI
z4<F$=1KA2I6pKg@Y3GIs66s7WN=Vck$)6Iav4CDR&gg6<!G|OAG3WRUIc!96iX?~-
zW(;9dBv2t{)qhjr^)m=p31n!$+LjDmK!)q91&Ye{!5XNNfkitgKFyDvq4ApMh)M#V
zz5jy*8YFx~f|+OZ?65sZ@bxNDzqI73o>g^Ff+Nb<R&2)mAD@)Jc^Y_kP#Q+AJpCVd
zM-?CA9oY&Wi<yyjZitHZcUH6`^*_)qpg?<v|A}^Uj?a+87VV{!8s&2R!)}u^PON?v
z%Pyr<^@>?Z$Vc1-h&sqSgvhvv?fzpuJ5ox?(#HP8QcEjtQW^k*N-M$5j-I4}#fPcq
zz~$%)CKR(yP!W@I>V)C#Ll9@fZ+lH+JjLa1vpzN-rI5goz)m_U?(8xuh1d0G1b9(e
z3Ds`;k@-3*sZy6mdN#rl4ef)@@@YeDpx9X(`svq?8=8qyXlND^sG)XMqeV65=L{gC
zCP73k0nC;V*qW3*p=YhjC|((T1_~-He`TS<F=#j+Q2_-G3g}g%XDWGtWMU%2c8@p3
z4+^bG{I>C)@f=P#cWC*h1**Ef&4qH)Ie72}z14fBBQ7vR;Dx0r_ZkR?mElleL@Wt$
z43+&atwUbXr=ky=baQs-*>F!~h&1pCWQM2GsBz>lT3DT;U$>x!KEof<TdM5zM^ku`
z_ZLD->`;K=It=C7$`-W#UDGK;?DL0W<!|kw^sqmNy4X4orE0`jLc?qr8}Mv7UZjTL
zo=6b&D)$LMEDB;!|CPG1oZisvM_|Ep>i9Wz2fWd23*up67+1ss+6kIMwwE$UdiSbD
z!Ba0q(n>X6wqUP)lrZV%=Pg)}uhL2S93K;Wm9&hTLW|!|=7}1+&<QAh58$B+UMjpR
zf^c0f@(@=;OAK-10DUUfL<$i}h6*%{fPu;QCoVa=e^{b8RL8rnXFuGaJoyJj$gUDW
z)#3sJNS7GIy7(zor7xegU{n2+6shU676ljllt7JC_i2lQH~va@jqcY$G)$fGF_1#-
z!9;TaW{W_@Cu7TR5IbFxVxA?t818^2U7rx`={P_8-y*-(ntzjHUL_-HKak}lk}&;9
zW5x~ub{nxnf|a%9KGaeX%NT~<nx6K1js3tu;2nlhf+c3(EdpaW+&~XR?Kndd2}}x7
zYFF)rr2&;1*Bi*$5B4HZ#276wX)-PZ(4?CJTo4bq9&74e9@(Kmnf)%72P>l_d7qvI
z9&GF@W#J>WxRKX@A?T9W`Uq_Wtzr5DM9r+!i=`HpnZ)dua2i`bAjEDPZo5O(YX74x
z)8z@zvjkjh9S2V@xSs9%NavmJx^k4XX|9Q-doP~h61^MB9bJZ@eJPo>6JjGIzFf~5
zS6Eq7_sd-DI_|X2ndDlu*|N~Hs4%68hw}p!Epaq=zz3MPm#{m_LRw_5LlwJ<0%<A9
zZ~*K==u4xOo-R`6>h9*!`33H>AjTyY=7(X5SJb*a*eH{^dNBHe4RY++zGBunpc%}%
zY4@qM8$0U@PDshuv-;sm&4z7I3TQGeZEh=$g`%3%l>CHUQ|R_6IC~2+VxW7YcY_LK
z-&!87_+{iewLyidDvCbhCa{CQse<Tv5M4>ELOqYN-uksO_Z&6Wr3DzCm3a2D8>WqQ
z*29AfjQ3d|bl<WK$RT=k20dO<n2Ycg9A$x|jD8?u6VU@TAzMwjiLq~^OFSh7Myha5
zaMG_!;9XUCS%Ul6z?-S?41yzwpe28V3U6wLXIK&{s0nMRL$voUY2dXidO8lH`2c=h
zg}3>*;lnDtH|6)WsRxf9(1=$M+&ZufQ}{wkAQFW?JSwtupepH#TS*tjsYN#sJj@2(
zTZLDpDk(})N&W;Cu9(MYf!9>w6DhwLCmDhoo@&C|G$hy}*R(=(=mHg}W7ELDD!iOc
zMWUX+RQM^X$2vw+c!3HJp$^%?m#v5q4XmY#$cLb01mCI!9H@Yw4SWRPB?na}A{1X=
zx3#!|WpBwr?1<T83Xfi)XQiqtF=;)q@L(<-MZQFrq*sYk{*V%<9^L{`jNkEpz{uT%
za=64_EyCnX0E2?vU0h4MM8t;$kw^=|5&m`b((FQ<nA-#J?5ptlHtD=zv0YYG@v93l
zL<PO9^JIRuI>Vt6{Cdh-+&W1hX&zNoLR-gd6{%i(pSZXtI6iTy04aXJJ`B&CVW;L-
zl8CNBe^QgQB1uz{^g)$r&Bkxn!T@olx{_FanlBmCdN|F*UpA`w_%Qp;9q{!-^YQRb
zaSH7n!p<}w-@x9El3iPjZ!WF=VJ_>~VtlCAzNK@qShR55LJMPJwp5g-n*Q0fd0n4K
zU;eFUXTR@Sr+jU1wSh+X%XIU*hS~Qc+i2|kuC>s>=^i0$%>1qm>^FD?*v((qwU)FP
zGPmx+t`Xv+0_*Bk+Dy#(Vck=un+1B-A*_2%X(K+;2Q?1Mm|pP7YA_BUS`7|1u&PGc
zPe|fWYygt>`)}LIBCI|iIU+BCT4cqUNIywga_jEB2@NJZ7qd`JM*vAXv3$k3r@NQm
zY`c6tTAw*e%Ku+WNL+oTs&+1n_!}~7>XiRnK{nJ^ngwhEe_KRka?WVi<VLk|Es$2d
z@z-&%(m?T-y5OTGeKf#FTl(<A$A|`skM#DMp3T5V>=jsI;N0QZ{D6H_%_3Zow5@56
zO`;R-Qht!Apo*Iflm>7{IS41Tpco}s3ccQf#m6W?fK38y2w+|pueHDx&VLKP0Y;)P
zwaj&|23Z!1R5?b8Kt>mQo<PQo7PFv0y@Lq{D?kPcA?keg9k`MpBJ6T#8#;goo53)t
z0=ybvmvV6~o9UHZ%rZEioA1sS?qbA+=EK<LnB_%oP^R}{tR=um0BQAes6*Pu!$0({
zACNX4t6XM7B~ZG3MbG4h%Cf*#E9RQS{c(DQtZ)JhA0My+yB4nmV>s~AWeIhZV2>SF
zXxtBq;`Gt?Tjjb}$EZV)HmQzMrBT~l^d#3Q4_RoGILmxv(w$mL!x5&|tH!Bt+94}?
z&sx;IggsW_wOp@MMLP>x!0%131baTa+yeI52Sx4ZMc2EDn!9MI3ld8k(EFJ)^en=l
z1jPJ?T;`^5Z2EGEO;f8eQ>m$MqN%B2yGwYOSQyuVGYyKD1`Te5OYD*arF~HOCBSX2
zZtNw}DsZPBL0BuSL!lA{P0YyJ>&-J#gAbaKhKtDak$!d%Aexb$H7zsJ6#nLzZ3o(m
zEyw5B8Q~m&?tG^tDR^btAr1~e<C2u%z{M9WoB|xa_(4yhtAKAD0Xw{cYfnLv5?ZQ6
z1SKi{`do+K;N1hK{9R;zqibj<C@x)c#GB;YzMABiC!?UrI90G#3r-tqskSnz9gb=z
zrzmc$V@t)&>(<}Y0kM-n&PvE>ZY{H=5~&S*$9`_9be1+}<LIQ7;-~HWf>my%RJAX+
z2qK_kE2W*JL(=M2N-E-FziXwW)ID(?TAO$-+oX$MAQ&ar1{AG==GcG&7U<dJWW~>Z
z*FsdfB3W_s3lhob*15#&Kj5hKlMR8`iDbpI_HFoOCFS5EOlvyyNQ$}QlGPfVfGehZ
zyM(}(!9q`L40e(*H*R7+t(C>Dy}E|jHFGH_53^HjyYASM9cV2k^4><c*o{xg^Bi_e
zZIs3!QzyXsv{8b?emSd>Nu9an=VPjm0E@%l3KF3akXi;gSGG|qq0k+8qn<>ei00-(
z>gIp(_b6ndE*`WGqlFt(u8ES1k=?f~+IV%w%;UmV(2lbIhU_Xo5aHS)XIfh&&|~Tp
zr2Ps}18+anf;h4cK1ll>X<_teY9SoXP1FpjG|9Nb_Kh<tGPid%22MC=Pil0g1$)<4
zL1YMrMS%IGpbsxk+x8)K9<_rytnIWx&ORxkPz`*7j{-CLe}imu;h|>j>T9@ie!!!J
z`9d=47N7ylRx#~nD1tkNo7<$AkGPXL*DNeMebAK!0INQ_ILK**yOl*f5zQ7WQ(|_8
zh<e(9U@dX}DPRH=PN4cY^TwW$1Sd*XBoG|lE?Pk*#2=u8qJvftg(M*1x~~$6l=Vok
zm6dUJWK!tVjBZ52s!)Y3O;y?hi5uag^&(Z7<zFB8NY>m=${yjGWZK_4`*Xxi!0`>F
zr175zOm3%CvY$5>oPM;O(oLE_86vK|l7g27zih9xYm#z;5Co}8n^3GBc>+geKZLGP
zq2)h>exIjjWjiQ7jT_9NmG?&LoI$RI7gfA3`Af`7oN&TCB6LjMC;`Gi0dfY&JnzjC
zDheK1LPE_zHuG8r33UgnoK->@;a2@05-PvWN7Vlh38k@C3%S$XQY|rhPgHA_P-l))
z2TCNA2XdNwn%7aOp>=-Dc6U^|NXjHV^X&u)r7vPJogkrJ&jN}Eby7M=8YJ!Pqy$KZ
zAk43JQaWi0SiR0l1F0T<kL;|p2JxOn!+EN+QaP^WQA=wWt}+AM*aHI97hpI!mMnHN
z04HmR7ulRZE6lAL=y)z_soF&e2)}p4wiW|&yOg5`+99eEbKL`wwK=j5@1l63?MnE}
zMyZURU+V3)LabowK(G~F5TtXeiMni>K9M6hBKkw<HbA$Mm}@39S8<q)pbw{weR4^a
zxR{jF)3tB~<|vlF1AmG+D6TNKT&&KGTwETgYOG696QF9m$I50_HN1>Lbk`KK;Z*?5
zh8swN2EV+UGRm)SI})Xv%a?ApC6T0I#0C71lZ+?bLhK4^bXVSM>>ooI7u4*jJkZ!@
zbb_!A?ya1WMtrGfuX-y(?I+;Cj15Xt0{pH{(A%}lZCpFK-}|K8&Qfy36SL)~$y7aC
zk*0*ZFGUV?Lx6?C;eeEjX^MXti>RO9M+xnoorT$lCxBe(G~5d(niJfi!iW_K8<$Ja
zQVKnQD3`4Hz!oF{c7V-nBcZ{V@%d^rg&Qw_!nlKgkiZSh6|d*(*`z*7wcuQb=zXe%
zV=z?bM*V2JgTr?+45q;eeYBqa*++?#bYpNX)JKVzdcnlgtgqr5yj!R(V<3JGV7h(W
zXtz~*_H|#yPa2IH7WajK9{0VT?e43DS8Mw{4gCVt72{$L9NS=EXs-NN3;_K+JoXf&
ze1jAa#<d?NLys(d!O(sRUeJZd7R%_bRF(!Vw_~gNEBVsq-7Q$^0L5KOh|;jZ1C;Si
z7T2(|+n{MS?OS@S7{P=ql2X%oIkZlg&JcJ4f%7SzX&h2TfB<Lm=Ad8LAZF=Vz(A#q
zwBReK<^z>4f&+IEw`Q5272Y1^3S5(Gb0+$V$P&x2I~@e1+=Z-aJxJLr4Qp@5+y*P-
z%cqV2V<B!+p(`%svB64c#fCdt*ttYxg#{70TpfIOv|vXEE3>4@$#w<3hA2}sQqfF1
zcIz{k6D#HFS%sm>5vj_y7VPR!Y!UWW*06U&l|`WrFtQMV;*7pyXdv-nU96!wy1<wN
z>9B2>k|eE~g}x0}(gS90u^j?RTKiucOfYY_(nRVz9Xr9{%JwFUK$~3@<xnUYc)}7y
z2JhglXBZm5Kj^q)dWfA%g}5Mm-X9@8U7xy)a5#x?_Sfgi9%*f=9h*BsS=#U|R=HiZ
ztd-4OWUfrY`xYqv76xx~P1n><S3vjUvtVetQcsidwt+fCbeZC+QtThZQ@}gp&c>9v
zAZTsl);ai7o#sX&e28XJ4ArszMCRooDi=&MbAh0J_j&(?vfJZniv1eq1;UWafOsrE
zIcIwqZqO@vQWhrWrcp{%RO(brwkhO5pBsBqm?NAzZG!B9?+5-Q=FSTnj2g^_y=Q~<
z%xyG^uWD>puyV9ATT|xPZ)8}1xkz6SH&&^lDYN)j`hDOBNbN7c$pKh8y~io7$}C51
zcxG-PtoP%TJ5u%+a6cFiMroS??}713LoM8)!X_wRg}?L1o7Z5@E`llR9&e@2-5}~p
z3ScH(#qN5xe}b~K$B6!9K5@FSM)Y?t{(RKm%sv?0E1(a9Yp!PgP0c+2)6DHD^ARy+
zjNSBX*OyAPePbBh*t0K{j&3b_p%%-Wsrx3$-;VW|s2GO#{aHwAlP;Siz`?ArOz;N!
ziH?r=4y;1<Lo?r%CY6BrE*t48->t<a8{AR@EHYR9Bo-X6ehL=sf$yg-8KjZn(VEP!
z6!*3hU5iGTbkaw)FT$!TYOg73KY)7TthHCR)?VJG_D3*ou~A<sZDU7IL~#fW;x^+>
zteJ&9#8MRd3R!^Vp{oRzlkw*xESKr6XT@JBtz%9?sVb@?&MS7(3_+wef`q6LLIfVD
zBZ#XlWYIS;OMk8OmKI{Z-uYUoE%{>Y@tdU7YglzU`jovF?osNVI?mXouMM-iOa-r?
zH(!N8MtnXD<a5GrlkO?DJ2NIJH6(3cJGNtz;_2)~i4^}5M_@?2F$vOkQy)84K11<$
z-a8bDFGXS^66<Fu^`!&j!N3_xpo@ZeL}(!yX}s#jmSrfFyhfOTnFM?Tr;MUh1i$<a
zE)p3^kW_!XetxDB?&V_6^@uQ97518<dhpLeuGmZ^sQLMEYQ>_CIY_1T+voKxtl##a
zEE&nwFpp1h^V6hTjy;1dFEz-4buUx#3_sV?!a+OKPvRh1{Up)zEk4<$Or^V2j7b+W
zSqTZ>Gs$Liu3)1>%;ooLmW{oEmZ`E$n&=D)30k-S(K$j8_3@}q!%k0DYK0x^As8bL
zIUp{ADI?a`(q>t4y(_iBPE6_Q9q?o<(ebMB8=#7sYWR|d88%HFW=S-h?OkznX<w>w
zieDP?TP!Uf-wBTTBZ)#9R;Sz@{zz)!cX<qny3r}Px!i>!#>TYH9SFCj$YWiQWAqfI
zjmv1{u-1oD6t#+E${?zEKU!3gh$>QStGM48Iof9_ZKCEPhfNhF5jby!6F*A0g6v4z
zNO_XuwT(?O;om-0(FI@{(W+e{uU%;H?Iwd09E=k)aG!5gdtbj}1ArWyebB)QOfy9m
z`%HHjh?<?B>sEUya!|>7&j@Wn;DnOq>-=Z)Gg0-)EX6(WU#xGRv@d6h_K!?5x9|Ty
z+CSUP+<t`z{nhrTJ*D>3F<+xjP7h~wrYU|ww??A(WZlFe0nWh3-ujqanHfp$KFDM_
zT|?y6#9SDRb9H4qgEN;-!<6}Aq@K;LvocmYN6+?5Q^HyJw@OIH{d7^c>lX5@pvrIH
zL2x=9G7lfmv~{K&l28^@(`2;hPYXv&m?WG9_3Wp&%bDn9MzSef-vvkM*#`hZuyA}6
zZvTEf3+IFfigaWhQ)^_Iu?eMXUlpDBu)=a`g>Y6v`&9Y|l*awMOqHSMf2TCD|Dq!X
z*ZezWW>9}<P2f*hJ}1Tzb48i?vqSs6rlN9~XuJPN3S;isO0|gG4rFsJ|6QVHkLkKF
zhN6=w<C29%-p*X^LOU?!;B2KUX2AsdK9~&#4g4IaKoA+kdz|QKc0MQv7;1?^%MGaI
z`sNzmrlOR7y3(|~b<>P~q>Rb0C$&en4^LMRGd8jvWqUAPX^C$weK*Nb>N@5|9!x>U
zomoy~eu6UutIf1vCvqSd?xu=SOi$FDG+h_Wfqsom%*k+7`xRbcn4VRdp(IELhr)C>
zLkZBL^}OjyUHhgeYH7YLH9tdbp1w<(Z)0u#vrn6^UNPnW*E~uQzZRywVl`$cO{IfF
z(2bc&K*&HG&(iVjXjHKc=O(bYZ%T&FTcgDCh;tD#uJ^;f^?#qwh8oP)^}hdUT|bc!
z>n-KP>)E}8*q{o#Ay|Zd00D{f`H6bwpBU>Yjo0g0f=67iBbY}$5k28F)LZ%;lkcBA
zC8@E?AeHla8*QbwIy+$bfKl^wQZ@w*z%yi{Y+LvOi|dN)IIqfc<7pQ3G6zHxE3z>8
z<bY{x23)XwwsKKZV&6>Hw2TKge31xpTx^@q-7pi>d1bbX_k;m8s%!oj?S%?#W!L=e
z(wxurY(TgCO6EH}dEN5E%BOs-?jzD~&N8vx-SS~=4uABwbHT%I`MWie4qE0fJ@Svm
zeyfLh`(fcg(nE5veT#l!yx487IL?O_HMN)Uf88Fo9CR{X?>rZe#XS_E&S9%)sb|}J
z=BH@C)idW_`Ik_CVK5$?>y@8c{(Hzz+Qi(xg2r3*&L1tU$6C6lcYdm*ZK`LwwEQMo
zXvZDX@++fQryxVY<g|Pbjk5#rQkaOoK#l!c&+_}^ht==gTr7cM)5Q{aHd|c+qjpv!
z*3lhn0$ryWc4|-#I-u|t7z>~keyyM1H{aX6Hgd!8N#5HuIBeTN+eoBjpo2vq;9gua
z$=-{@hv&4}TLD915gd*V6Z7I~n0O>2l9V5u;@u*xDhNKhY9c|SjLYDvO{$B)&kg#4
zCHRL+LQ)|gyc6-SmC~ef2&);}-#4Ew0H48SHK|{I7pYkXJ?qskpA2ZhfQjqUhx_FZ
zcF7H2wayt{Nd~-{wR@}!TfS~!9c1c-8>%AHjQ;skB!`B2R&hXnn$!+@;@R~BBV3$^
z5bwfZaR3icch$3X1M;h**lQnivBv}Q8)&gF$oY9-OtpEjgks&sEI68|KIFYR0Rt+^
zd{I;3Xk7U=>8?Rzn>8>$qSIhez^U$3L6c&XBelfUOp_}yC~+F(G1suZEq*^j4G`ma
zdUG&-eIaN(9NJs<{<zHN8kkR}#<R~i4D?ET(^$~^AS#8*llD>F>8QJCu$aesREvmP
zE>nLN2BO%r|Hs&OfJJq5e*?Q%X$q?#NE7TR7VIdvtAe6p?}{-Y##m6X#0GW|QLJN)
zZSS@Bf-x2>vBsLBQDaS6L#)x*-T&{*+}*vqY~Jt7^F;2RIc?6gGiTaVn*LnESc1dX
z&~)hMl7Ge@V_IM??>&70aN<u*r^Cmt54&;#-Ek1WMtomSUo;n5wmD68f$ME*OztGS
z-T@fAk$`EUasdJ=Lk7@on577_1_nA{V(KgKd9|r#s)&_liX{cBpr%p)QiTinnQDp#
zNwi5OB`>v;cTVh>hF+*f4{#mO#3VPiV4yTp(++Mz(8Gx#krR-6tPJxdF@IA9z^TF&
z{77tmLO;Pfr^RcgS3p^}$3eY>KEvbPbE0ZB@M4dLZOFi)>~x$g`|Zlas$QXx`tSp9
zF25s2)4K2Qz=-h;x$P4sbK9TI6y;h>Dc5H)WFuB<QhVRx2ij0pXM-@(ZF*QEC6gha
z@KK+#Ud&V)HGl^0azBuES|m~R@05@og8kDjw13*2;fz$=rY7Yp)aUGq!-vEX+<T|=
zTGxV`>SjX=c|L=sR@yi9F?jVFERE7GrLP|cOSOZBCi5XU4nuGP4Z)3+A-Hc{^q{-H
z+K^j>`xo`u?P4R!vP(mxdV#}GcWh&-S`to`R+nP573zWers@)n(Qb9X=VEoKe$df&
z_Je(6MbeJizzB<y`WMfMO2Bu4cPbm7ZEP9zPg}K|+)majrOuUV$;#`Sm8&wO74<c^
zL8=KUnRN&GzkR9|@_${e73Kf#FsWfVO-Cwn>;vG{OS}V><GHOaw5^jSb*%I`!VFke
z-RU}GiW0ymlaO`I^c0R}frsf~H~euob?nBrrb%I)R--^sLJ#XvFE6(Hr&Gh9deUF<
zl$ECeOOE1UkV_ZlS@4p8S5Sc7u(!H@OU+$!B-JmdF6u_)$XfJoY@9lsYPm8o@Q8-V
z49n9Efhc-sQ;TgifxxF0oq%C0EbG*wIw6SJNo&rc(A45W4PemJ!h0kz)GW9ow4oNP
zrubo{33cd5iTtqRQTQfD2;Vd5`)my<(JQeKhkBZ58-uIWfw(=LGnhi(3WHYk{Z+Ox
z!TTSSw4Dy4Bz^f!&s<!lHi>W>Rjy#9smbqVGymaPkZM{T<;tFpk~VAa<FG9IdbG4j
ztHX=Md2Pl>xPN(Hd<)ibtW*o_eCF>h*sQTqb#0R<sB>Vf6kOrrNVHtkl28O?jHM~M
zgUBPgKH45iE|=-ExV$%GrN^$i@M^s4zc?ISe+8sqm9%*a_I{k??{NZNkHsfrq2r|%
zmCF7NWzn?VMg<j&Hf_2CZTT;+f`O)zm0d+zdT+LNb7#CsHeQ;qEw=}{*P9^i(3UOj
z>cSpQkis<0gIh4qi4xPKG-<&$Oyqf}jco|OPDCF5tb{yxPLe_*#|{;Fz^pj7ou|k{
zH01%?=8B12cs9=KFiEQCrkfJUb5UckH5cc>du1kaaYUVq{7k8l=3Ivs>_eusN4ru3
zmG(}SnrVNzg-di^O_sb}eN$T^2;hQn!jVjFj*o2-U7IRJXuSPfu(+vGU$^ZI*qW(Q
zd2RbJsCsOw)Vb0%lp7Wo92;FqE8ggOpz)&79oMra)1*djawRr)n)IWa3ql#wrE=vv
z|7bRYa;nl?y{SXTQ79s5XkgQ)OHqbFm8j!|Bcq%F+Z>9n`v`_m9?}1kPRV4%1C)l|
zoaR<=NGLpJ3V$RH@!dE8H|*c(QgD(f1nU#i9;LUS?jzZhh@S-wZCt{@rQoVrHyKrx
z7(ta&{2E5w><AtTZyrwB9>7v&NPZpwn{|5NQ`^p*0sEFnYQYZAfPHVhMd7E<l$vW>
zUWa`T&Xh{K`mRBTptf&=1T03)f_)Q9Bkr69`<iMC`z{NFeP?D#?JAYM>(st$;<<g7
zA?gKVxiw|)vtZv-!K}e-*f*{j^U8*O7hNoD-{d$>@>NsTA{+MI9A<CdzskXwC++Ne
zw6VQ?>5dcAI+L((xjnG&{%qK{aygZKQ%qUdm8Z6Ee{doD9)q0~`?geg9NBGe-^acz
zbdKbg0Wh}F0w4BGw%wRmEtKDwI3<M|iR#A0U8PiezP<BkALf34G!E-N%p7+)0242G
zEFctHE<gC9&(Co`QVwu&&AEX84tNF<(kX$~&@BWP1i?mvs~PPR@am5Es{}mM5k6hO
zH;_VNBexJdM8K~Do?$1ri%7WH1)KihY+DtI6>u#HQ0E|0z#qc`c8Yom_z)5-&U*>L
zFH5(8k*A)<4m-M+(*0sU2H#pA+)tRfluf3twGUYuNKGBJ*$FOy_i>cERKS~&RNA#-
zF=wWLf5hHAyIc(foa}$mF(FwHq>uo$-5LmZQ-Z4ngbMi4vVg10tC)aacZ5GhC4$@~
zfM?hdTo(y792LqJ@a~R`HVXK2f~)PEE8xM7e8viR6<Y=}M8Twpgg9cP&T)c(zc1sE
zvuFViaK!f)@EeZ!E&~3oBixjMQidreb#f@1%L3li5q?0x%Q(W<2>4wRpe~wO0{$z(
z)fP$<@YoDTlXe#gtsNP~3HUvNtD8V&0mp?U_LlPz@bixNuf2JOUl2YNwe63-D-uc)
zfw~CJ2>5#<P<IkL1-y-;fTaSy%Tb|B0q;!swo2-5jvVNX4UqGtDv>LDQ7cS}2qm`{
zZh>wK2jCtGx?{Hi00(>N*{`RKm6CQUsA;tQhnpiOCaVJ-zVY0LBzoAvpSLyD!w&Be
zKY;5y)-JkAj`!2~Qsu~7JspG>aDYnq+nz#rMw%1hXOp?`mmqQ~yvctE=UqOcxmo;e
zifnMfq_{m7a8KzhaMGt~Nzv=aVanZ%RVe$lUt%<Q-%G2~zpYWZZIcOmj@1OmOFT0w
zj<-u#II=azrJxEa7`brSVtQ?Cm`>*w#NvA*9UF@JJ+~B}ce2&3H-*-!$c>2kgEd%X
z6U}F*{2<fJGBluNq7%e%^Ajt}CPGDXWWE>uJG=aUtGnKp_s1cMx}qh)0FR4X)Lk-s
zP}znRh|d{#a^}bd;c9LUTY*O*wyahUcS4I-18#Z1Yd`s_agxup%4)A2G1QckQbKh<
zn3s<csCdP^r%gvb%sOw(d*TnlF;E2?s}*a(emp5v^4dfyi%8PNxEAcIXL3!qN-bEU
z@1!_QZFlT>_)bd7C<#Z8;sU)ksw0kcn-D*uT&EO9a`h4AEyyCAG{iJPh`OsBQC4lt
zn*8@h=!2(y#VzGY*{S|mwrPAC{zo>Eyw;8hv3z;6gi}&@z#$)!Vu%<>JA2Z2r<CLQ
z=OHY{PCX^n*CxCO!W{XGR3+dubRkyS8J%eoiP;FKmz<Uw20Ze1!loz@&;MYo%zB@Z
ze6(Z#QFv(<qmdsxE%gs5>5MF%@N8sDo-1TQdr)H%4%3td|7DVWakVMmVwM%a_MMS>
z*H}@823p#hkKCjXCX{sXa-v&j;%XC;{mi1<Mo-LB&Prd@4Kk{WMg4?&f^$1pJJEvG
zJtfr(*y`a#;I#u5n>Ki=$O`D<;l!qqpk_YjVbotsI^px`iJjsD=_eJCW_n3%!Z{D4
zzANE`td>35jK>OD(0a6e=SKa)R~WS<VmpP5`n0$cAqL`VGwS$97TuN>Z^7~|NMB@l
ztg$z$<>A0mSR+_UEC={4NpO8`zK`FxkPl^;#76(+uFx|lMhlx9L;wmJ0XSU%FA$~`
zm<C{Sf*GgRcsKeJ648y8YmX+G0q<G3b?8RUel&2OE@mB(i%||dYYU#GJgsL<04y(n
zDTK+Z6-h59fCV0E%zs?Cp4A9bjPby{Er3-z5>$+LfSwi5KmuB|-z$Lr1QbI%FjouU
z3s}eooDCqlsI*H`tfo?VY$r~O3-EY20$maseMwjJX+K?(3|b9>v#k7O$-m^QRW!Z0
zSG@%uy73u2sU~8D*?w;9x0DUt-GV@mr;1p|{u@F)0+9uJk|-PmtZ8a)O}A<-ShFiq
z1SpuV8yk2<YObjoh(Pld$se#7z|LKf5;e!lwP0ngN_9N4F{z?(;LR1_(B-OBNwcPE
z3zl(Jiu8|05^fa;rTOL@OuGmzozM<lm7@KkX%N#@#lN<$nnnL4HT3v0iN<6clUY!^
z1snB~)LxseMN2vJlQhh>8;-^OEH$jstBry>r55GHBf@(>f@nz%pN)!WQgKW_@BL@s
zJ_Hl>x}T*UVj*S8HObGl7}H&ox<>Ab#D)0}F(XBd`!<dyf94bFdF7~IXj^+OD4H~g
z08(}cRu8giqsOQUl&yt()Yw=-#1-NX+i|925qH5GMPdc&>8|+D@Fa{mG}y)^9{b%L
z1MY+b@*1oI?uCh^*zW66%@A_md92RqSPRDm%xWIO(4c0vwUr&S*omdERFi5oEo(nE
zE&TtBb8vNqGq!w|kF)2xYeFejV>hz$2RYXNts{4@NXxD88`N69Z)vAx)P%xXhJ|+i
z-^^{J`Rn7B(cI5rG|#;u1);h=-rIuh!e@<US4GbjO2frKWw<!)B6>D>lZJ?~{G?ru
z=biiL%HG|O8ff>@SN)q(^>zX1KN4`j)`w!Q9{+&V)O@^baXNA8pYO4J^OZOD42$(B
zteB%oQM5V?kA;NTIS%juuyFK`fnB*RHPnC$dvsIk8jxxZ<DIUZ7EkU$cJEtKV{I~h
zt+*vs57_tK;1ZubDULQshLSp!=~VX}*B0#VEvZB8AINIhMmhQ9PIQ`9M-6X4egUs0
zJ38UmAE60TFS^la+5i#W#|AdwS1Hc3Kc~B6+O=Sw8C6{v?&2=Ra5c|6G2Dg^PE<a6
z$6~le^u-PL=B>(bD<A()!^Qer4c9!Vu;KbXHLzVbVYufooaY@FuH}0tT3otqF<dl#
zal<Ws<IHeJKN^JLxU=EZaEVb)3^%7hF<d-3Dd+>{&m+TK-X*to!z)HX_oU{uCZGRV
z^YY=Bf<^VOqqO*=P3@|Ga(XFN^STrs0yp=6v?dq9ti1!X40~pmN0y>S9u}(oe{oB>
zFXd@Rb%z}TA0TjhCI(&p18G5#oS24B(4wwAkeU}QfU}U4b(eK$zu1@6{4=>!^?X3+
zkU{=SzN%m<HiuRX__>2^3g~6_Jmqx@h&Z6>FC>J!VaQShRC#0(aI=`BfSrJlfSq^&
zl<fLC%PL@%0{R^w(V^bm-ZR)QCu(bq4|?vX@-M^ClScOa8{A9p==mHkvdMLMO4%1-
zF09nfo}oc?8t7dLe#cC)IX=*kv0~4UWc={L059zMU|l=6qUu9X*i((8XGKIAH=CvQ
zX2gUiCuZ$GVJ-(_(b^t1Lx|Se*Yar-Rzx03!KG`qaOr-+^xAcy*}EieBF6kkJgqj|
zWPp?XA5W{X&{J#Lx?%P(?9`ed`b%f%tF3lds|O3=%_)FrVsUGRT0PW0<?X4~A6&)T
zQ@{OT5N}Vdz{i9FsiJoIbP8_P9a&MEg3gm&elV?1r<#w^T&JEKsG2HUW>&btH9O76
z9I36X9<OQBhjPeLAA@Du$VX_zYCF(_In(_-G^$NZEUj{f5t<JR{$m@+-NQ?(y4^9b
ztyMbI)V*H-r=id({m{o!{fc)l2chJ#W`M0kuqrhl+;Fdc`TEdf6#c}<Qk8O-Y`9x2
zxME<=%YQ7zxM}5XaM|BHm0D_~4+hr!nN+#V2znS0weVa9xl()4)@hkDFY}qy%T1f#
z8Tfbpk%pl2ZTmus@%rQ)EC=k}6HpL%OZ|mZ-7SL%%#pj%ZQD$uxWRek1{?oC2c~j^
zPvf`E=__#yEOTP)fiG`zplpYER{)tE@cd0&f(`nw2x|2?_X8D?&|`>%a+f&`sc@Mu
zRi!4O@|eATA&;3dz%pM+mFheqgq+?uc7RTT)5IPG2yL!dFvTvS=5T}<AEcp)dE*c3
zdDR%E`vwyqlue3lJfa1KorC)N1wF&1eUZI%G@Fmax6MX`5%*fEu5o!|V8dQZ`jCUK
zk(Y*pF(;qCfKT<XKE?0u!{Hh)3=CIZOCvOizZqD|H&T--JuB<Q;c+_HgN+g;elv*E
zBW<%zS`LuBGWk7Qz_z@RB0~>70CT#XCaK}w(b~kUmOl6&52aTtn4&muZ=|s58Zadb
zV0&cDR-CNHZ8(=JaSM!jKzWXt2OzTE55HLKTPd_kH|j8_p6pIp7Y`?j-FMuFY?C%B
zjw;NcU(iX;cq`S_RDFqC&#F!GV^`ivx^f@UE0Mq4ZZuWD259G&HM=G6q#$kPQjmqd
zlNxKXUKm*4cT&}Iy+HwS*bHfP8&NLpuA@s__fBe~ZMGRC&)!Lq(HH*_yn{y(?_ydT
zZ@xQF=r>mAxA_{VTE2&VgW$Pv{pP=ieoYk~bJK~(STt~pek}hz6ui64qTt!*1{VAQ
z3a)(aOu@N7TNKPdNQ3SAAVpU70w!g???_^v;AUgaqfGto8Xzqb6~Sf6M=4Ts^qGNG
z{wUSd<lv*{M=7FoD(Vw4*gt|8tikM!`E=&fpf(R(nW6KfM9no+o7~Qma9lO&y2+L0
zb)M7(_Xrup+^9mANfDmqpHjWR<Y@44bd@jeuB}3gdl^UyIQE3Hasrj)j;SqGNJ7&R
zTJL*nYx$b#I?99i*H))3)39EDLjK@M-88?z|Kjto-Ge8Ec&?|OmzX>s1|~!AudS(p
z&$;BPu~MD#5w@o1ew&(WY*m2J^nCny(>qjw5Mr9%=S?pbf0U*NyA^JFxmS(VT5Spi
ziMSysorhcxD1hjMEO>{QGySOm;*t<#NdREK0zjNG3HP4lc>W%$XJKa(ecL?YDM=CP
zplqjKxiT-1B;ukp=~e}0$BS;*J}4U}GJH7PmSO1@&+u%3kl~%Bd4_v)gqYiRxr|@&
zM`XAM&C(0?HBWyq)^622#392S6o56uagG^oZ^>|y$gr+2GW^AlIH*q_aW}jBmC!*u
zSRw_#FP2(X#<wUsGx*=LkXQ7bnfQZ7>f2uF>Q)p`hu8M1x>`_Im-~2&Ul1BE?z_26
z|Hh#9+bRxWBu`583;LbXzJ-s3U<f)idyL##i~Rz@*&JDc^LTXI9z(V5c+p=})&9q}
zV<lGF`yv`9kCkdcVeM7uDxI{SjeZSsVn@%WpjJ_eHhRyPiOkYGs(~`Os&fOjLEVWX
zU;+Y5WGM}R?9k6R9y0SAc<0Z4Hdguc_z&a>DO~n*JokgY2;#ApQz3i+!*!ZtMFca)
z{ryoIo)O4Y%N(wd*~$De50WNbGuGCgJfO(bn6JY3zh+FS@%LdTY$jiKqB`4eVe=y~
zB-J(EU~~Dpv5r@*a#Uq8DB)To^bw_gF%AvrcFhTw?0pt4n~5KB$@m>5mh~mZvpP!M
z!6qHLvk1P`Q|~<N_|}d85v&GyD7%7lVvhf;b`;v4MS<qToFt$%w$%VY)skn-1*Br2
zFBM4bKsC_kp2|>SW8;aQ7am2t-kjk~zqAAXCV=U7k}e5g3<0eHuY&^E$POq8V0An4
z+zbJ&LQt#t@c^RcqqBJ`)@);9k&X<EAWI_y7LP`E<vZc2WTNJ%@$39ZcZs@xqTp+(
zVj*L?wQ77?Nyk-5Eq@^U+HN-e>?i1=UTu4Hnyle|k91VSe-iK|1Q!~Kb<M*9-kRX*
z<v&TlC4yTP+cN0hq#Tj(1ts9*0aO)?MgguWM)wlX47q9-pe{y^syla56r}sNq`jI+
zv|zrA;OeD3e-6)ZZ%GNl^g^nOq7A{-tD2@$+zby;9j)q<_Ll{Gkt3f20=}8>)#h0v
z;BJIpG((l$St6m)`cTXJ>q4P40Z%RNuw2_+z?(ZN8YkcZj)E%-_)i44WQ^P2M<jST
z3V4m$f`aes?jZQCfPXCJ06!z(4^g31tDWY^odRBo;Ff|X%PsxRfTdU*t)>KZ&B_!6
zogCo<1w4`9>LN=P@cmaE1UC@yX@sw?iJ<~su~=}1{qBTfBH<_zSWHBkK1KC{qAwf;
zTo>?5m&>a!Y{H_SfS)IPwW1pZd=bHUhBK6^o+}atI}(f)@EJuNOr0X&Ev<|cJ_!P@
zcT^}^z=spQ+7cQ5B4L<gf{TEkCAiuWrW4!}udg`3FAI1&;j7E|fPh~t;*fzg0-ljZ
zjMU9zmPlAfaNCl(IWkSa*E_<y3-|&@c$|P=C%C%ZR~GPOf)~M70BdjKBN74}E%Ev|
z&#?!=#Wj?oS>6@!B91vbBj77YfZ7r}1$?s*tjNuvW`G2-t7-E^`>yzc9WGFZ2p(fE
zI@Gr=0)CP3)uk0H;3FMdaHN1wx{|@IU^9ZJNND3o@bVZp!utyjf`1k8Xh%iA6Y!Fb
ze6|VrP79w5OJBcOB)B*-nkeAsFGEpvOZrT}tAFpHP+I}t>WCjB;F}!a8Ik2h!emNN
z*Ee^-)q~G+lnn--+ocN+K0S{pgHIwcQCH^td~UYK8i(4yk>GG}_GgfXqq$)3;h1db
za7HF_9x*O91pyo=fc<RQ2e6X>-al`(34l!nu!9|D6#%hzcsijv-xC&d6dE9Ndb`ZQ
zUzl=O_!rYKOu?PcePE=uv6eW-^34NdWWZ&rukb??$PZ2C6)(p#{1V*UR}bLkN?YOO
z%{Sq)r}?K0tle+MYMNCe%Cq5&m0@$<7)usOL!Y{3H|vlt`v$xwBRKLZw;3FEjg`Y$
zv=^4vzu#hEc;Gt&tMt3Eg<JkkK_2Cd{L4*t<gOO-z(?ra5|2`S!he~33j>zeO-qiM
z&8);9c#J##dnekg+Gxj4N6PW+xt=tz+kY6lYQxVV?_uTT2)Cy@gkG`doiOUR!H!WW
zQj;_KaNNM||7mRFX5J>q2ZLcDt8A9-$m2*YPF@}4drZcPUcE}7mWquTnV8o9X)^W;
z7<kqRtCNx)t0trvXI1%_f#p3kHr5(I#{PY1jBu;1=#+8B38S?}J4T&IMb4;MzJaaz
z%b4J1*dnsD>$DT{C+qFVr;}QoeE3lup(!wi1SEc^CR3(VO95nZ0qWW+l7H-P%uB8x
zF|eY48*6C8D3KS&lg&c(rzf58=)2A$dfVSdA8j6K!Wlh3Y+#T6Mq#|bmCjT}vraf6
zU%l3j{1$QJ<YhsA=8>_cSFF3WFh0TZiTh(?&ww$<ov_-n#*WoF;>=mOA2P5TkBybJ
z`=J3V@&ttuuIMz(PA8=a&R=a|#G8$t7;$UX{MNvBJ~4I-*lH(VAuDE2mPzVxvcU%p
zY~)j854RLaSmMGlwfYKq$*=9Ct|e}qJm(t&>-Y@S@{p_568HWz<jr_yEbkgnGT#ZW
z&sW;<y0c2*6>vU}Cd?G-pn3OhG+*=~#}C6S-fmJT?@>Ok7fQA{>V)x-6?Tk6EQ~cJ
z^9<~)n^b|l`p4MN=lxnSHO37w?jw$Xd##tafNK=#k3K3I+xM3&rx1KP=HQ6K`|z>J
zbm27mk9>_3#8$sB7WbO-vALxc?m~EW{|n<7?POAwGn?jOV|HR$VP>~Zfm!-XW0H0*
z(VTo~jPUtXrPjei7EXuFkfW$|d}(1$I^xv$Ut_Y*+SRsfm9@|}ET^Jx?1X;Acc98%
z6p_!Zje~>KS8iJerpH3$^33Ozv9C7nTZ=Y&%C(}+6joT96(>Qs@0IajskVvgg&T_X
zWWMGDOjn%b-1OSmAmG9`q6o#dEv25VI0#X1UmNRdSAsn|R#o<6(eI5q|4F;lb)%!$
zyS2WLZN%}ev1^qufZfiij|ZGc30+K8?t`&`_WLDjDVps&4XoB%V~ZO5S2*ES!5Odq
zi!8jJ5m&3mfj{h^aR_Fm|1zn^rmbG430q;Jh<C>I0e|jyqMCl8h21`4Y-Ja~wyO=`
zBMk6<FU*B*FqDO!mb5j_Eq9`IS!ZGzF0hFCodjCNXijf4F#iw6HZ{&Jb;7IOJ|`-t
z&$sZ>+VlEjtAV}wfWATZQZyDERc&<Bz@k1Hrv#YyIAPT**TU)oF}11{uw#ol_YFku
z(<t{X&Bllt_n8xAYdVwAVV*_82a;u#pt-Zzut@4u<Cn!wIJMmEMAvC^Eu8%9IF<T$
z6FG)TaW9k1=Ebk1$pQ6tIpMJ&$HGHPdResz_+z6wzsFI7&{-V=3+f6ZY6LjbGIggD
z3A5%{B-AB+tr9e4Hu63(rG{pqlN_h*aKdYQwuM(y(%Z%>bc2B%)ksyn+B~rqblOjb
z4X-qkYe3#MC#-yDTUbperdC#ApG)LDZ;d#BEZfF{Xi?y?+hKrfMPYyi^PMPtXR8xQ
zu2~jI+eoHWl4hO}%RWV<jy|)oltP`FKTPZb7VJt1DI_A0vI1x_#)F7iqO0?v@gQ1^
z2fg;89ltCh&DPf3qR_;&er%%|KC>{*?7ejPr5NBwPldSmL`oU*>7Y_#!)A*T#~;}k
z?wC=Sp&J;o4n?F6J~=tIOlYk1!7BPnPU!n$mltIsf|V&Qb<nojWD)$y-!{Qn(+dk;
zw;P1pi%V^_1w>;mjx1DBsgSYJ!fAPdjnm9&g*n~W1x}+&NNs$+#KYB=a=5oap|AV?
zFB`qP6Z$5g$Gvja1~+E`_(hbI(zN9)JR)LLJbF(pti!0CW^>-nl9H!uu^;QwMvOS@
zMe`6FtvVs<?I{IDOp!$8vYQV*lnI!GoANP98W_uV6&TBi=}b3>VWFk4>$u@6byGeh
znsP1(S*-vmSUUonr`S`S<QH(r=tRQpOz?5_#R=b>DGEo;u$2au=7sY55)ZHn+Mm`t
zq4l-W%9Aa$vsM^bH*cw$*X{?ftC&VyJBt-VZz&pQGaKQo;VwTZm_6{8`~&u^bHdd-
z!=lkN;!k-jk-D6^Jok*`7A(_8^3$G!I&7&AvbSW0Ma8>ooiKBoWMQ_8*b+0%!es`Q
zR7#?YTt~DQ>S!lVv#=>x<AhC>i5518h#_b5^-=?iFD(UnUB7G1=?BbJ2bGp;moY8G
z(!{Y;wC}W3EEkS|@@?DUiiy(L`+RD(6A9rHED{*W;u5}M2A1k8bts3~HO@`r;#A?e
zDrGzgnzAdtFhZZH7VS5D?S%K)aTeZVNebuPa|zB;`q6b0?(J|sk;+8dXR?LO=~YhH
zxLesQ9j~w{J8m&{h-E$E1<f~_-#3k!0xmZ~rBJp^$IHA{8^K?*bA~H>qLXw1n^!tv
zU*s!`mg7kfX<4+-A}mK|f69IhlPckj6sfvbuUl4QXJW?sXBjC;Q)`of)hjDq^hvnc
z+_HbctSgBe?yDe$u^4|zSHBzvJicw9irR0qI~Z_=hJ>tt6SLkYWe=s!dJ>LePWG3|
zMffgvqVKpB1a#ImO=E=qVeCkdR4nA&d|r7Uv?^SLf#4yU>4%9H+qYWgMA#RjEXMJ-
zW3G9dYhb?zNOT3pJzN39%kk-W3$LC_o$y+kZsApJv|3S(CwN^gCsp=pblqy?ewYy#
z3*_Z^yoKP;dIh5GHfBy(vym3o9;7hJP}m^x@m$(hAckF7){J{#9INwZimqZiXIb8l
z(K012z{?e#T7WfQ1C}@uK7E8mcwNe&Rk)_iT(}}ZJP)q80*Bkk2Uneou5H|6C%g^}
zxA1C1S+enp$}zCr<)sQ<{eH6AXc}h556VkzPzK-Quy~zdH1ZaUoN!&6X5m_fbhUAP
zosFs-jIACy?hoS&n<fG(ik7aygX%)<whNsI7&gozAeb^>6W{^?cS88l^1pD}hMVBc
zC=0Iv3!Ly;JJiCfE~#zh<yU4l)n_r4qsxoSi~%1s_?F234cul!%r!m6D{Z~gd?&nj
z46*QzAdRiOHAS)v?3Xa9o0s;A)x1?OyKWjTb=F*6Wyo6`F8R3nY`COq=!0hShF&k@
ztCgaSpDm9zZrN4CL!}fceU}YIRBOSLa}jVA>lp}j_Q7f{)`B+?P()z?Oc1~kcECCS
z^7y9+f1aJg!=G)hG^eA1ss-XX6GUV;rWKKkXg+wpoWuqFI9nZPy(@t3gefA`z&tO2
z+wCy-3*hB>YUS5*U`EVEf?Ai7=Lpn%0$Q^)MgR{JP%N84(kBAA%nsNVK)#JjwU+!i
zpRWzqrous9i&4AeYs2G_*9MlY8!Cb$f*{<HU^o$2@LA?UY}fgYm$=v|*A5jD+jX7;
zgxxD!VHWJj`jjKYyah|_h^Pn@c1|OQ`(Ykjc=L+SBCw26u{?r$2$pVwWsqR`<7KL4
zF@prlB|u?4i-0BO!i8C`A(j%S5L(s{EO!G0E$6^`(9$4S-Z;v&EJ7@AEX01kH`|=?
zj9v_$Iu*~axni;F1kd+#InTYQ?ohL};5iy7g69`bdFB((>6}F9=_PnR2MBr&7Ca*a
z&x3fg4A%Su$_t*qY;~q*@)GcTd6Co*JSXwo#x@r`Z{=`37jcA`s)A=%3(t&1XFU0i
zv?oigJJR^?d6=Fl8-PUmx3=F{rp$>6hNOcyMS=}G12Cr8HuL1-{fbS1yN&XsKiW|q
z=E!HOX=9J33|gW&@^|>jHgt*@t$CB|7nDnBU+$%UWAN>Ok(T5agmz$#`~el#9JvZz
zpFKuCGgd5ux;YMee*R|07T!x7w)`lYg8u#r2%j!Bw)KX`WVa{C!hsMthyOtMZLB~r
z_$-1~WY1z5-OUo&g)rVNGq#N2ZqvwwwhjMCA58a4CS>>Oo-q9;UB>r0T~k>w2AH2M
zH+CooKNU4yz4y`5ak6~DwFTjpTmh~N$Qc_MXW^OvuE}byH%9|=)CzC~=6`YJ+nSM%
z#xGWemUw*b=b;8L#bh4D&ae_Dg9BxkUj<>#C?H^?)qf&*5CZ3blC|ToW|gsGMk*@b
zLu}J@!9{^tAI!Q`j30K_Z(|GO+x5r_ZrMDam~|3e9lvfK7r+M&MRm}{fZzz7Z{;Uc
zE-9$v60^PoDu3n$s85F&T=*S?mV+)up$sl=FJLXcHpXk_VH16CFF7D!HbYg%ja%Q@
zA<vm-VBdai4DbLRHrAVt`OujOu6{)jsMW8yqOkf0*Ev=H=3r9)C1zDN_2((54(jg&
zs+~rs(d@YT(^o@%{1EE5M#V3zeiB@-cdMa3@JRj1-lTr$8mzi}IVH>`uge-^zN=ea
zpS-f`jI~`YuOG4G^+4#C0fg!6jhkKFK6J{fB^j$&uLMkyjqNpyzk(|!8$UtwtM?@e
zy4(h16U_|hb7e<=Up9Dy(ci<r7|pho6-W>zyN$Kd6d44X)*C@H-9oc+BWO%TR5bY;
zjcYW&jmE*1O~&uE20Q}Ks&6)C7s-iT_&LZAZ#Is_w~oFWZ!z|Cn_^&Wi?K8PeYC|`
zMLTLN`qgq<jeRsx2b!~STX6$<!gxa-+iDDV#ht?jc4!-xw=xZ^$aZ5(ZP;jFCvOM#
zt9{Mc&h18>rtDXSyffR4bzG6l_MbqE>rUfZd~fWJ?~OZ+&5BGU%RXhb#x3`2A6s`M
zoSYob2YaZicRz_gba8Sn>Zo!>?z0qwO95RWR6<~WBQTd2#yp*Z_|-1sr*0Fl{IJVd
znf~70g$KIOn<ixMjfe(Qy8P2OA^T871N`8%1otXXI&R!C0c2W*+gz~U7mw!MF}dPk
z0PQXA@nNpbJ!8qcVd2h046Ogrc7Ckr9^)>pk%B*m_86xkpC$VupDp$pv+zBk559lg
zYy8{|B_F#FPfDRQzu0G7r~PCo4ClQc?`AaK-kc5IkG-ayh8x(N{l;%Wr|AW{wt2`3
z3UW`Lak%E`7gz#5V0?<iIz5nB{u^Txw{!yw@$DKAaeNTB;qWcoh8^*TY<L&VT(MzB
zcLQ7cjd2)J6hCN;X`YT8PyG&=d}8|NSCPp!FOf;x6`r(JAt$CLICKBb9QjXI^+<vy
z(K2?pw%XADI^2=+RIcilY+$`x#n#BEJ;d4R4wcu{xIcH(-fo2IaMP??_>Of{d0k@L
z$i-ChifudiIuC@3>b(q}U8p$S2Y+F87?mqXUUudQ;gq1>B=f6)cO|%*(RTuVg9NDY
zw+Z+~NBCj^??Q0(UYLm)B4LIj!Dj+qumqm9@Jz*Ko3;YJoAA{;#bN|}<>wBHmKX3q
z!dLHiatEAtb!1p>!<hgKw6Y}|gqhWs;q>evoPYOrj@smR;$|!9D0QQNKO#6^tg`Ix
z5^ygYAI1J-MZ)dH4%tmn2#Ar|ZV3YZHwxTNK(v4lA-KA{`~`f5BitoJBp4hMOsHL`
zDNP*}x-8&D9Ptkb_!@$%?Yu_7YdG?mCE(XGh(K+kG?DQ5Gr-k3?k?b)39imroPeKp
z#IG#ivmEh#1pEsHZo2~JHA)#dp1a7Q2<{4aJ4g5#0k7x?->L8+0qTq`74U3=+bo19
zGBZU&fup7a1^o4=4vdlod>-Men?M5r-$wXq%Y_Q~SC06_2%eGSzRpp=(`0UmZyXt2
z7x2vlS2y~60e?eqwL%*Oyq_bVTmg3@g}l{eIToGblYBh&q3Lg6LB}w@78zz>4Uf@j
z0}R4F@X`2diXP*f5{|du9hH`tGbWV67uYwBLr|OH$XU}mBMsMFS<>bX#mU)Y#<E&N
zUkpg?PZ&pe+q!gd!YTPUc8#p>hogbVAzH>Tw(K}Wf5eFX4Sh64toavwG-?Si&?;vn
z<TSC#sj5!vrohFMVy9;qSo8^Fp!QgAMFsoovoD`O*2DW6*oPCwDD8+5K&o-l*t3|`
z>B&6_1qbwjqj3@nrhW-^PC~CEldyD3A0H7V4fqZU7WvXa!MZjD{~Dx9vsbWw2G$C`
zgMyQLI#tl;l(BmC<TW&ul38;iWBXF4S^n46G^|Ed!7mJqTl(=K*9*Vcz*EN1gx`>y
z+-XoTw64*3U>A#I?z;#S-*FJGaC5)XCk)@6%(|20j7~m@LtQri9*-7V2VQoW<mZCa
zB7Y)CA-}wk{{?<QegRj*vmJi1%BLYe0?F|mp+HiOZr_~p_{K+j4ov16cw01ZbE<*O
z{-=$VBh$a85khrQ(*q7r-IcW9>*nI3rZWnv`b^L}uB7J$B#ARY)EB7E1P#XA0Mjk|
zGeHLIxl29+;d@s(2tUCAD&bdGDZ*zt5#Cq`_xvy6TPgp}g!`O@@E0o`gb#2OUfLqu
zr0A*6`S{+vUbID$)13dE^B=-5L%8;G4;1H}o9%;`|2d<t*Ty=uGRF_T&VU1%_G|k9
z){zoU)wL!hSrX<@LW(V+v?bvb5-P^q60VQsDmb2@t=$W<&F754VKs+~Wk(;|Te$U0
z1X?ti3>S8|udHiWygbFy47e(R&f<<n&DZ^7Q@D+DDNA}n%AE7YfWR&IIv9<5fwJ&7
z-?g;>oI2vh&~~>NquBSz+JRcuJTDoe7^68Q{9N0b(A$zQffCYe3E`H6{Ya?T!Ioee
z?bH~}sUWy9nhh&tj8?_0#+VQPoEzhpz(U5**rfDwE=8ssa$|gpum5R`23;-2czpp`
zJ5$q|XL*!jjM^8G@JF;YVX!4(FePN#5^7r#WF%DVZ%cTc?$j6^yIG9Uen=r>bSq*t
z##+oSxG@3>*9>2qlrNo2*-ts-#yF3!|1`#BW9PDqsEN{R?C7CGX<HiZ`2Mk*ft9>$
zY#!YQdEk$*r}a94S>ugPyg_Dx2A=OABE?1LamvJKdAxy5ylf12!+5jyvax(=PJPF8
z?e<(u!!uDk5p=s`?BqXrp%a<Lt_Ifl3S{=Sm$|tkm)Qd}klBbxRWb*~8F0rAWcJ2s
z<|~lNsqdIJ{A!cAbAi+XixZDR@buaOX_n?KRvD%*l)9D5iK-Fj39kI;W>oD?uI$l5
zX}s323&yg+i=+hH4_*Ve^M12Ps^gW9K*&S$2kaElO~+LD?IJ0p?iiukNugRFMK#O4
z?>Vs)62a6LH=4j_E|_W7)dpqT#Zpw)=aT`zg>k0}JozoM6C!*}k2{&o-uu%dv<cZ5
zD@`H3xGXimtYcqLux38~wPM!AVFH>;&$%%d>WoH`<+_}8saS@JymZ-<#jQ_0t_lAX
z%Y#d#9L*FIXpx@NDhK35w!P%(Qc%Hm!woo@O|v}Neuhgz+`Ad_o-?V4tIdT79kIR)
zE3-`U@_3pCL3qZ%=h|E|i(V#$Yj*cH<aJplEp>J41wU-LbTH-w0;La^!Av|8cs}8H
zy9L(g69({oHn6s7aQg-3ha<Q(6Pv=#dOyvd{ksB3kz0+&ndFtyAkB!rSnXLUed4P5
z03Yw|D(SkWHp=*?uceIY{^$-1e63Fs;29QNdZeK~5^;u`m&qvK^`po!je_}~V821r
zt*P{WbA)dTHehRNcg_4n13R)cmEIQ^j*E8r(*aesrS^pJimvx$v$mxsA!&OlCF$>N
zsZ%vwYGQqKt<>MGGt{6*1^V`-*b6q5;H-S}_6Fv;Bb6Q%Nc2&tI_yZTubGB+%wH8S
z7^oiWN=<KWc~xM08)!^rja#O{N_kZv8gA#49jR4X`*Q-%&p?2RUju*CuL{(t35p-6
z#}^zv8t~its=#YBJ>^w_!|+N!*_j%VuvyO=(yM8l-$wjV^UJRRn~IkN7K4@gC4m^A
znsp(mR1Z6V+eN%fkWmj_tLh~IEy6w4mjp_X2<0V#?IT2B@U-oHfX0YO&`Sb)dQzRX
ze@WmH&~2Ed2oo;}WC0V`{tA5RsC*imDkAUnlE6?E)I^hTs?T4Xr%KQXNr?2@-Ld~C
zZm;8a?9bE_&mL&j|9!{))5B7NCLUcWzhXauzW5dUM-ou-h=n^|vA?}KqDkRHq<KXP
z22$Co@7O=u$}R|P^-*alg5R<KLo={f?%3~G4UG65``#dfDC>hdmOJ*%Re_=0vA-1G
z);sp~E!A>VckGudfrnn`j{U>UsHNbJ{W+v$)}8;pV}DJgR4vjqlX~mU7#wiBBVva!
zJ{*uv_l)wMGbSXnIeQu@RZ7(H6#FCX6~E+5Oy!W|^s3KgL!pGd2MMPor6MH9XE;cX
zc9h&N<9|p_9mFN~1Q(~0f1!z2A<3bYq>33uV$oKttHo3EizQ@fF*S_Q$MKlY=g^}d
z62DvHHxKD`H%C^jMAqbJRRmfJSN9%Ye#Pq$5j-elV^&09^;EEEUTfBUN?6rS;HE5#
zOsW^?06KGH+~W}fTye^o@vUTB;nq!@D?CyVUz?;TJPyAt3iqsNRk(*hdkQqmDPi2i
zP{BdrdIIY&1xqNrh_LJw)(Es|3L1qp&`dcqo5FJ&J6CvpQ=Z$R7KJzCw?*OEkyeGX
z1X_xn!heN3D4Z&=dfF*`lCbO)t|QR)P87Kp3V+R+afNfMpfZ-4;7}PuIY8A6YEDop
zqr_9}n?b$Ld1b7MB&U^e6HT%URYrb;L1T1Ok>6s3zzqhC)Ny0#I_L(2pvsh10mX@%
zgz7qCC@)MLia>|4==LB(U>xsJ3O!!ehY<J+6B=OH*2}CfOx&sf1pdNA4tfxDN`+pS
zm`E7>g^3ElP_y7Y+=KeI9`1NJQ0K<T4Fa1w@8E_J0(Edja-xdScS1e6wHJIUHQUgd
zct5NjxLV#13j<=)8vNM_H~y`>9~O!pQh7hDi9HMc_C=={8;{b!Ws_=(w=Y77pWrbQ
z-{5h6{DuTidlo6tQlyp<i#c_qaJD5{DjU)tKNGU_J_)Dw{vxR7`>-QcuCY8bI0d&L
z-HVo<gqUjcMj#$vqak<NIW!i$ACE=ayMEY0Q%kB<;YDrk`Xyx#j=)QSkG!X4(;$aY
zKLOY0A&4>ui2B-6&9dt_;^_il{g&Q9aA}FetlH8!&#Z6kmR(q~j*Y4#`DzzI1yZ|V
zNMBOMLE{vm@fUrB#x<F5UFkx|-!=bR?aQTHnYpf1r$TsDtJ*1C?JPy@?n3QxK<pAD
zMU}l;g}VWEYS%;JvKZ-d(UJSfkH-jEPYTk!u4rKM>PcbRt#mADZ#}7x_EHqo*VUI=
zxQ*Dxde@ikyB*oa;u=Wj+}3qr9u1`)nvmLtynziRcUMi>T86x|M$!dWw@X)8vnG-;
zYAu`|@)@7)m<u=V1o_mXpU|xAj_Ec)wrMo)27F?nL-$Yvs~L;(E=I?Jy2naAwE9ZW
zVP7nCSSPXfvC<Z|-*>W2O{ELkil1U8vHDJ?KU>gDir4I_X2|=wnbgu%Gq9>5FC?B+
zd3u&TZY~*XJm;gw9aHm7R#i^Z>KRn236NS9?$zq0!QEVRWVyb$cj;C^BUG&J{jK|=
z_%q&5{gexwY_~Uk2wPxoo1N-|E8LQ*+#j=}ZT8S&iLSq5ah5+tkNXY%3~Z`Fs*&L!
zQMJDGt&XoR-AEDLC44j(5l24bi&FQi%=E<iQt42tDYo^cN@3{D)dAd`;wXU}_h#XM
zt0TdqGDN~lB2b5p`v`ayB2Y7GA>i8_@uLKMts`6~;FSrkj(vY9#ue(3;YjeiNca-3
z1KX`HT@di;gs;xQJ^>#F3)m^TO28iz+!obG*ABSq)NqD-dvL_KKf0eVvwD5$hC3hV
z@D@UA2W{d6_uC;3QY#C1K1mhbkyst`5%9T=d|qduFi|jl9TV;f_&pM!w%Zv2KT2@5
zfSm#!=cv$90q@}m&lK>o8IB19MZyt0gKTI2WC8yr*dfOa1big%QQJ9Gz_&Z{DJI~X
z2_G4-E%Q7r!Yy%(1gLX-UBD+g3eFes<&O9p1-zFdey)Hwv4>-sXRJu@a?~_Mz%M2^
zSRz5dWk-0lfcGZ>>Z0)%@V*3BTgZjrSmrrmuaP;@gldO6alX6*qss#R3E``ozySfz
zBz(2y)(Ci#BmOJ_A4T{XYE9Eb!W>6N-35Fi!PT8aoPd8%aJ52}1-!N+A0Gk#iQr17
z0`D8QCcM@f*p5W0iuOey`uJOkQh7uOuDo|)9}}fo5s~PB6S97xkt4f59s<VrJ(~}5
z!;{76I{}!TT1)kU&!Z;>T0z&O><oHcH65<g7@t}<u_96#I2&3^9gB#LQ;0iI&L(d1
zJ4M{$0F^iz<gMc136RTB9hh8PV~*)m-1WCYoNcpB5)MUZ!mx&wB$d<jt&26RBq^{-
z61=j8pVG~Nv_%RlRs(GdLR&+vi3dgEU|Zrm43JNgq>6oS`>Xo?#Ho0!m#+cg@yV>`
zrZ+efQxNL_HS3ncdo8Hw05)yKIidobj^ZnGoV@2=mflwSN<*%})3(UKfDo+zwL=Du
z)W-T>J7fUC75faN*>v<kWJpO=GLUXdd=ji=pkvwpk%1mNoMxbP17{iVz?K&K42;{!
z{MsuS$b7h%9w<C|2dBO_NwYQQ5S;3=S?W`9P$HO}!As8#Oiz4VTrwv_XkA7HBpg5(
zjsC-9IG#Ih8`yy*8Bu*&MIqv|7uTtpbslh%>$-aHZ=;=d)_dAXz!I{0M--bys|(ly
zOS#JNY}TD7BJM8TFuEX~YI)Sq|D)a#w0z_X={aWI;U>7+lVyZgAFC4)mt^7Daf_Ms
z7?;RzYO{hOE-^?FVYka)e^!>A-Xg^zXXAf0FpsTLv_}GF1r$MCx*QS2gssw-nlD;m
zd(l?-Mi<`d+1ssBJ)n2Ih4^v3Bwv=WO?vAw0$wfAELaMfcH5<c8f`NJdp4za8TL*4
zKGj*<9eDk4b7^dyIkiI?2J*JQDCBK-O2<8?qvhcYNkm%PtR@kx|Hpm-Y<2xXMOl+w
zQex?um<v3-0t4~(6ZtyZld)aWXs>1!DVT=01MyH}Jp&8eEroS?;mz$<s{^-Nqhw(>
zOR%@ZE4|CZchvalQO{c*pnr_;CSp;Dfl6Ms80e4h%;twtJn~uZqn^#*E%mA!iW%O+
zf&5L;$QTh;YX^+@Q!TZw4-K3RnARqyhPR}Y8Lc#Qk5ne3UVF^zu_PL+!-rY78kGQn
z(Hz}v{Nxe1KM;JzoRQ+tC-7va_o#Nf*vz_>fb!Q~@n)TmTY7y0`<P^O(*@P2r>cm5
zC=f?wo8k%R=YoSr#Hf-Aiyn<K&>>|X;s-RaC5)C~O`|Z96f`mGJTZMX>x$yv0_yo_
z@!JP?z!w`8$|ad~L8JiUcfW=4u2IOphMha)^4?iMwdpL9tULMb4(n`$C`6xF-Mvy*
z&GC{3ma~^XAbaRXrR;C-r2`-3Cw%6~eD_JXtukhMKTp<ZpVY|P1g`LRdD!;*((rco
zNexhKPXC~g{;*HV)C_;7XI=M8)x5LoBOp2L(Wvqm_+H`OI$kl?@0V(6x);F(BjZ~5
zvK2d0OR|^yr95!?`3j=hdC~&S<R^O8@&FjDK#5uy6h$g$u<(FX-#sTbf0`$|bU>Qo
z^A84~hs#klYTY#Jj?}<*xNoFjp9{f&)<(S`XfB}hzLCO`GK=wwcsP+)#ESTnkab^q
zlXU45RKu!>#bRiop!h)Idxdl0zf*|ge$*)9SOFa0gJZI<;Fv5pW+kXORwIswVQz)v
zJ1sbLMw6*^6V>i8aLu}z)Ld|JDR9iX-BAWM<RIRfWvGl4Aua;s_)~@m)a7@O45~hy
ziW*r#XZ#H2Kcnd<9^%u@#7|y6x6QhL(D)0Y0UV(M-X>rmmmgA;Y@yrQ${JM9Dxt)i
zGf>?<BKEkB>d%)4-V#w)v+j5~{B<j!z;i(h{3Gi4pQdv-cu`PS1^9*l6$mX9|Ih{7
zGhx?)Qg~btEEG^WH#M42oLhPcs={%mT>wqHnO-`Is=R-8S||nRLrq_T9Yv-)WmC<L
z1q(BdrBQF03By@myWQ~E1I0<N-EMPrWmnD9W@<E;Lna+a4X)R*7F4%AciRaG)K&s#
z6GwLp`Ml?~i*~c`4a$qMZX~dHwf`0E<}b?j(8BX*d<1>!YYo1{i?VQyorSym793Mv
zl&wS^fhyWvV^|S&h(tY?bm<hA`Oz&s%=-3g-E#&Wm#%QlOxIexGwbBa)Fr6n($)<X
zJdRYy4Vo#D^4$-i!`J;bGzdghcNQq`M+i!w{I%(rEl|E5HCYu)vOPvS?u<~VL3s>@
zT%o^FH|-Tth3_#PPsn<mb!_TA4XUE6D|8E4lNzLb=7O(gYf`7%@7alSldEQwLk^t9
zmrKFs7?mHyQxmiVjxRjW(=#k0wEW5QAi{8ME-+~FZPslO7`B-4MeqmKJB1JV##pzs
zVpUR@$pUS$g2oS4==yOqF^c<W<bYPa1=jmGn^JtfUqR7}--z8vAiYwMgx8Irz{mTf
zJddC7(=IWjcusGABX&tn6YB;LD*RSh4o>Wkq)blC?8-b|`hd(yCulM@l|dOe-crk>
z5_k_RyA&?xhJzV16-Kw+4K6P09?BWJ$3eA%Hp&Iw3d{q-3Q8-mM1kk8vIftm`5v;+
z6$QXET3cZ4akRz_!a8A5NZ{_N#3LoG6kO|psqGw>8zo;W$7U>p)+nx7&4h)i9Ju86
z9FJ#BFdQNfn<<Evb6vWM0#P7+`-E4Ko(hsRKI5uL%>;Xw_-^rC<GaLnrpL5c&>~}C
zofy*6QZiglY;%C9WXz$wWQZY3rlKer0L7W1O*FZ2EE#dCOX4J=w8wKUu~z{C&mh6m
zAb7rw<UBhOPde2V;fy6e5_AXa2$nu`O%XY)U-k(ymfg;oUoKm>QS=dvus?^IPu5++
zL_Kl;>}nyZ#EVv{N){@tM1>ZGkZKS@E6#R2Di-GP*99w&GjN|_6@S!y^o`BTk(d5~
zYb|<v{`)ApJ8Mpg$`xX5w8Jd4wvJP5A#eHtH+=GD8tMB|uR4r`_lmyn?H7bz*BrSA
zP0k#-7~PwVoKKV<H}(sHpK6W_3?#hY|5bA!jFj+ZxG<S8rg9!_pE+VEXK#Y;p;N7U
zLu%{&Ua#szVXoYZ-TgcOM7F0<J;SB-MK`o{d#`8aq8ozfFMpJQ=#Ka!S&8M`G3(yH
z!)4VNA(JMm!=1Dic%iqS2NJC;mz0nzYU{s4U8!0^u2Cc>YQ!C=)3<~?Bk1m1>awrH
z@ajWNVtd4rl5(o{)f<ovDk)dNTNm|jV>s{<J>BIY&0+$dym3Y?5T2HlJ7}i9(KCaG
z+_8ksvTTiqoPbjx_isUm#~yM^P3~(wtM4ht+xAdoddiU*MP1+}okx~&#5{c{d}9>Q
zVK@t_LpUo-qR!yB(f8sEk>$A2;h#_>x@#Ksd7a@3>aYamxY1)A#>LZ5K;<Vf;6d>i
z@Fo;^fji`|2rs#oX4oq|>+U6&52#PI59f_e+F>_D@?0<3zfmyA;4zwpj#U>1^;n`J
zp7|FQk<O}`BYkhED@iW9>m^sxu6hYG^UZgayk$SnQ`Tnj3eGz1Yhr!8WnZs9Pg@g?
zA%QmKg}HxQsA(Ruq0Lm#YHlgw>e%iztIDB+;#>UMl6geyQ>r0<KI7&5|9C!wpRl;9
zXZ-n$7xOW3EA)IuW+^!|^n_L41r$Ig3AU<0O(?&V+&pX?wnI4dNmrL!bqgx4Y%*(7
z8m6&vykAT)&4|*nZ-&cvR#96iNGmdv36mpCY`xw&5RWZk<mg#jj2za!e(eup*yZ^A
zF_KnziDZlq4J(nIX<lXZU{Z521o$V=RpJz*@!bC`6hkP}`pQ*3k6U%nT9ixnMY%<v
zv?g3EDzpw8eY;S(wOeM*G~&IY+z)}iPNXg26N<YQvZK99r=FrVx%tV_8I8u`)tG0n
zK?0`ps{TBj;CK_l5nh7e#|p#m*LQV!xT!Gw9Kq)oh94h;0boLckG<4wt=KU?l+`Ry
z6?Ak^X)2M#Isk_fu(AWN2LUm<*yYFophF$<&$n9rUy4|g)p9W}W}S3$4}bp}R0j<7
z>VUG7FV3u6@lelB>f}llj-f$6JdTW|SHQk$^rq^r2Q$SU8cbXV^(+&D_}YE5Zo~yW
z_5l5xUP|d6&>--v`ZP>x^=0G++C<C>>7booWbA^+p=flT!=q?eckhTl6i+Iu><PSo
zmAV<W)~!`pcBzb9R&)EYo;C*t1s;7&eeE5Scba_<V{pNv6SQqRt|oD$m|sq0c?iL_
z?F*E}oT%blWK4pP{P+<n2j4dSBa)SE<A3;yZR2YRq--1C1w_7Wye`FU|JSy0zH>T)
z+f%h|yAB7ac1}01q3oRQuAr(nFL#GD*rgAWoNiuTDg4>O+qUmMO7X*z-oKc6;C<3i
zI4di1@aBcTR4(Ar-{8rM7#9L1^N@Ou=X$ye=#{@*OS}3=pbMKEB3G(n*8TZ2b>N30
z@~JN8xWAr*EIZsF(;M7ucOTxub*STTRb?4xGR7YSXMUUN(*W5=d-|{<$Q{qT{;X%w
z<>bZ)emu!W$5u`bc5Awwc=`DkI8k@gH+HOkIb>rM_LH6k2g=xm=YAizI!p|d>jVV;
z<%Gw<19m*V|5o7<YS#Jvh-#JN9yQyR-<dar4FbTkWsn>l(B+{Mo-gw3cotE3hQy{v
z_+Tp;`ctqSoTXy>0c;=c#R!gsPO5|%6%nHYtf&e0<+q5|$Ni^d+u?u|D!-ri+X)UQ
zQ&S<vn015DdcbJvES1zj6wl3ZAEtuMP_6{}`A-OR55^s`owf>rIe-)r_<Wz8z@}6n
zBoKu;<BFbr6D-H01X5-im^m1Qxnq;ywd@Zkyvo`0YE1<LUe!y_yG-?uU!27+eeCxg
zd-ks}gxwC2D}sAhoNOr`it?TJyA!T8_S$I}M@6G(IO~$0<%P<l^-n%4)NiQ9#p}OO
zhv9xBQjCjYF$vRA*Y8y0qSzWg@BysGU6li27?1Z@``A=Cd;FNd^Dqo~GIUa$i|Uqy
z>fuO;vn4!-=f^2hkx((rmT=%T3X-~O`=_?nl4!m&{wTeUXg`Z7JKH*V_6J|S8T?`W
zLTEqO6t3o6iaSZ+o59QB>%TUGr&N#!lyimK@8Fg{#;lP}7++rYsXrUCvPsEiCjoIl
z+QpGxnOq0VHRtlzkh1<s%=(C^<s-ezQGYa)BQ*In>ngw0vt|);<J!+rKgj<)MPq>U
zn>aR`^9hBr#$eW=OpF98goGA?F7CnbK+T7{dgj_PJEZK*yQJ4EQ#H`ooEdCZsx5cb
zHoAu_&#o=c3%Yp+XsWH6xC0@T?m#$y0`7WD9eJo{2VhvE%u9mWCcE9%vyjtG0yWq0
zL9>;5hi(_j@g{(1w(_PQ#9QV%2?#~xz|qRl4ZQ;ezMf$W)ue*Su^BjLZbrBtACW9_
zrZGI=*I!X1;E)}_!VVpz9(CXH=4o<1_B7oFxf0<TaSWRBy`VKg<1EA#LKsSj>p;FO
z#MNxTE%ody*E;7%(PU>NBfNS-k82S7hPKU~RGC&KYbNCkAmh{_CM9xN^2wMA?4Npa
zc;KCzYECwLlgk@jUydo=D!jRica=F2ap(`deLO3NH)mt&%g40&H<6Pj4dhQkdg80~
z0PQyku4l}56LJnk@E|@O<;4Ey`<M0Xa09uq)`!sFH;}*A{D_8rzM<SnGYKDIjpQSm
z@>sgO-$)+gyAXk=BQ$eL$i||DSy!z<&jvS^>-r`+B>eW5p6zKYM`~W|)w7$8<u)1_
zA61&jO*NxXEQ6ZJ)hps{20BoJv2l97_cWTHp?Ce}S}2<1w1|PCcfbFP9cm&6g#4+1
zixK$rv<M&k4d4`>3nlbXFPg~Bv?JH!tA4E9K=a|KK5s;<9PH|rRE8~R3O!<f)U$(4
z<pv>d55XOiUL%YSx9TU9Yr$DW!hZ~+aQcxy^{iAgxr=7*4|qALnH*L1k3T7R{K|CX
zg$Vh|o#%?BB?R$__6jyfBkL%Py!>WzQ&)7bb4D1LCSGnBkof~;g${VoC4!2!uSmyk
zE#b)ptj5>;c)7Y}$G3WxA1{|HeYLD8%49cQlzYlH&-*)G_Hoq)T?utrqL)7j-+viA
z2WU50i}DP&lUM@6^%$r0Y?@xKt4#wQJEWKY()@c;&o&w4Pc-xK;nhMu?N;dtyVgRk
z)&*g&AvXKZ!CD3E-}a)g|5H&Mqxnv#X%VmKC$iBU;;5J=aWsd#MX$8vt?Y7<H$S$a
zrR=ZSwqMVVx0G9GYh8d^C0og#`A)c|s!6Daes}b2YAbn-=E^xeTXDN#0Be>YM`>o^
z*RTXRLen1~O91h$0{6;V1wnZ1S3UbVL9VAUoz*k%M7f-1{RTa&o+x+KwBDf4o1Q2q
zxVqK+EALWkxwc!^9QUkL%aHEoJ!OZ;P21D<nZ8Gbt;#ftgJ+tfIc9pXHPZ{NnQkll
zhi%)TciHJ$>+I8b@11R3yr(_F6cHQn_=YdD?$t#-yW3Wt=a%zF-tcyEm}|zM-(6g$
z9*Q8tyLnIZ;GT^5Y09|I%jWt3TX89xuR3X``Kj9unk&V1k)t_ip1A<yDo#h@zU(;>
zPg(z#at-b0xt2V1OGd$c*ot<PEJwR$^nCE2+6}wQwL8<lkaju8?X=r}%ei((IGTfY
zY0$(`yKZwW+I`*;+CAE=&zsUwZttcY|C0+I?wqn+$NuUpm(=`ec44nO%e8gKWi<9w
z^4qAtq87jOG={-0a{Y`+hmmyeFH&8xvXRuwasPl59F|T=vGVaFcKIl{?mQp=a5RT}
zNORQrpo)|=Cn6J(u$FS9cFt@|hH7_3hQd*E+jf<!Htcf>%0;0?qP84#Ik&tq7Lz4_
zZWLfeZ?CHjnnY0JKcY9Qgx0^atL*3Je-d5OK+4!<R9$2mLq6-<O%4iiLGPE4T}Qb;
zWPCBavFvt`Vi#uJ@81Gx?U^mUC39l;YN<Q?8vTE*ZgQe#96G3p-Q?Mt3+O{ibeCI|
zUVji0npmxx4)}oXa&@;y7uo#oa{DrVNT+`D)5g~R^4<wO`?tFs>{0m~b(qs26onSr
zL$0h@bW6|L^pLOno`vE^y92H`E&adOvwA({-X0~E!d1Xtgmn$E7vbxka&YNlZ{uCO
zOHGT|0Bmm`_lIxd*~Omn5Z_%GS&t^zSR|g;vv$4YndOh7pGKpeg(QqOvtnSG_^gw(
zeKO~so;~j+$7$TQ=~+x~d8u#6aWHWK#*s{*n{|2UTkiIjLo^o_>X};~d7)eV6^!-4
zXjXKqp4}V%g>Tu0AW6W&<5<4dUYsxb_95)Pa`mRTpzx_TN`6`dAHZ^AzL-fq?V$)4
z4Jrg~IdMTlHS3zq2M>ZOojRqOnjd0=`^p=^<BunHJQ~apJpAo=^vJd6L8+$R-x80n
z*!h0)=iVch>uIO6ftIOLm+M)43g#M;p7l?WeKoIl>)DtTxxn8jvXjiS!#5tlZF#v%
z&&KtaLozgLQU0HqbtmS+kI5>MnANoyHcj}rK75an^(c9qN2m<Ux*Kb#q8ueN9wCF8
zb!P}tl?F!a3yS?`H=0(C=fdalG;7$3KNQ4BJ5q*IpIn5hLOUo50+g)`X<VN!T%j~<
z5;>x_dKGT<%JU!~*sOCohBRz|KqMp0G~fz00u?vw3i1`8(&)FmaB(rv!^w@7>e-M_
z<mkFP3J3yk_#@Mcq?h~y*7_SCRK^2sMj2?<-Cieb*K5{Jk(|JjtB~LXEX%KhIzbQs
z$!1+$n|yzivT520Q~<CPcIGs&b5n34nj)OWB_Dm(09ohpI-2%mD=jBwfE*Lp4ebJc
ze8EM85PAPr;~UiS>%HjF!<_@<;Eo}?_;f7f84RneYw`uI?JyE8Z6flO6Z3kfn6o_<
zNGK*CqhVxmB(=|JpeFmNtk*u;5$eJ||5TPVm-k`Z{Y(zf?8Qg5&*Z6Pn?eWGeO}Pd
zth<UleD|4LtL(oAka&p3B|eJ7lg9xaBzmUG;hI&m^{jTP+*#8SA6cpLIL~KWL`M=I
zh4~Hh`CP7+(*Hc=nbw`A=i`-U<@rkV+zqgGPJ~+AMwk-t_#%R?27dkb$3Lm%7;ut`
zd>Ed;9QTIXQ1t+`^Ur>s6v&>=8s^7#d@hG;e;RA)pC5iM>q-w@49SW-v9ckKOI3M9
zhEpBXYQO=i6DqA9#fyVleRzuf36+YM>9n)wCrEO7LS-3+Knk5u;ir$@Zb2TL9G9B4
zm6vFHu;j<3=Ha*HFwb9e$bS5|)KGyokSk?b^=>_zR}I^mb{m03`cWOCeVS%n1Yy}7
z=J6M3@BbEPH1kIz$`aH5IGjNKLaysod^~kpe5D}gh@Rd5LayBMD_B{9b))voW75v<
z72LIpR>)4|(7zJgD|O8Tf4Vdfjm;cc4Z|mH{6rsRj}f|NHZC5dw1u2UpOp?6OZLS3
z1+5_j-|y+)STuMC7AIqZi{wPT&&I@$zcp&yU^hR*qS=>nz1B5&Q^NGQ3vcgekO^7s
zLK6<S!zlPKGa;)ewl2`oZqH5+<1Lpb^PN#Q(dXG@inmL#V`&NY>%I9>4)pg$WkIb?
z=2h7T%)sN(MzqH2gAs{rISw_p|6sX_|9xcC@tM+vgtu<6T-Pa=>~zpR9xT_^PW?*Z
zq6x{>v*aQ2X#dhq#O95(5G<sILSi*F=OJD&RIXFB1FDOu?ix03sNB`RloRUnBP`Te
zV=UB>bM>tCFu7b4n*~yHRnevK3;3$b=HEpfBhQ8RRIbxRHOmA*iDJJ7jwOnHK%(YQ
zemarmL>ci5z1|%D$1@jyL=<}tl9ed-k~2a4@{=9}Qli)wj7k*yx3jz(SPD_rZ7g<|
zpYSO5t=~vTRTR5`15{D$x4*^n%SSSvl3qYnN3mUmb~+?EjbbNJFKFK>@a0mKvCcqY
z465ficX57^8>_<<m9h9L#&Ee_xtv(n=Gb0kdDvEoZ1x2YwthIKv-?hqG87l((-4n}
zS9}yo4&mwAS|2LS{^RkkOS2KOPUD}gXWd4~@!AFJ!612-9KrGd4>)wn3771l7A|Fn
zTevhB2`(WR29ih0Rg1PZp)y6SV3SA64+5gTbHbzE5DSl4!z?^br-MiCEIqrEE|=5R
zT?<V<q$4Z6PC8*wb+CoOeo}{LW!We&I5Jbuc8!uN24t>Ay+P9x7AP((a0)>7bQGH2
z&qP)$15Gb@rmE>FhWz-o#SXJa!wv`Vvk<RigM<p<j0gKYEethXX2AcPAXi|qW8@A2
zXID9)ef)(TZ7`XGl+mP4=Qa!}y&j!UBK1N!vGX6moaswgqp@<BHk>r;Hx_nzlkdbX
zX9fz!wY8nU#22^AyRooK?`bgXI60Wr`U)9p<Bay8wNPZr8mHX^?6TXZqV{Gl;&B}E
zlX#^1%@+34S8_*fk(HvLB3S!z;2d?-iB|7ZEn3Z@jC0PXfvw4%!nLXska5Hb*<;EA
zudg>KTOg~Vxj$LYa>mOM0rD~@b{z_!DBt%)VID7s__v#^DqrP2s~UvI>v_)!P};QA
z39o0L3h7Gu##$I^=4JBo{aot<G8R2q4ykbe8uba{-Ks#)IlfzUbu7e<ltb9oiE_!J
zp0`n;PjlIkiE^)irp$@#$ph?UFC_c%%6fB>Dl<xDowLM}nG2JUnNj#zsIpG_#E#*)
z&lHB5(v$S8Plo)tcHv@6W<LCE%gopP3umUwXr7rMRxwldDw=x}nHf2kHO`a=X?HJD
znADy2qm9YUl)_BXN1=X;?rZcUxPuLel9x#6WZ6So&B7@B!w)t_<(x2jl+K1vmIrDl
zEwt#LtfI*3S6Fmhx}tyMDbRoXFVMg59F{yq?ylXjKw%OVpwj<(-@;6Wv%javZM4;i
zpz%~WTKo5W3u#xC{F{9WlWu1_rphVW1Pej<?yI&ec5*^cVgw7FDOY6Urpc|f3v(@U
zK3uVp9qL_JP8U{ex;$9>V4j6w-z6J?hZ6#c9hi<hr4Rw~6v3*^Kv9HR=)<31w9$L_
zDlG8+Ft&55+=*QxvI%o7V%w?6X7(&h)|7?Jl*ed~<yZ(7Ua-met4CpisqDr~d4$%F
z2vB9Bwb$k-q~Y-@S*N-eCS5j!J)R@C_c0~8@J2$<&(*h3*IcU-+}sKEo57&6bbvuJ
z8<8cq)UM99=v`bzex_St;r-eBEY#HZvxVLfY|d;L>L~rBUL<_}Ia|KBcP&gm`Ae=m
ztDX(A5DQt&XJ>6>Rh^LC8>G@&Yh<&tq4mrxi`G3<<U6|*mYT@?=E(iE1+y$#ubKn#
z+vz819p<mndR6Db^l9wT9J#mF%R*3dtV&>j6N1YFRr>z3maWK<6SV0wE%I)kv1NBv
zr^52;u}X905bZo7XgwFT<JTDqsZT2v>GvJc1#X)w`@1rBYOdT@TgQsF>a<NlQwy5g
zqf|D0o;*c|3e%4&&$Nhq?o_yUny&DVIDE=RIH3cnwwJ%5Me`-)1;f&;O|HC3yNR9@
zy|6$Isar}#voyJIc4~cQ=_uVtP)Avcq&1t5e1%(hgsuC|CihzV!aO#!J@e&G+H87!
zl!S&=P!Zg9QUt!N^#VCVdxjnv<pg6-+9c$)D=Z<Ic`lR(xk=O6R}19^r33Nc5XHt0
zz(UwxXZms~JF!q6tBsrt<*AqVNz{`K5rIRNOqq%S!w=@$#9T`%EM{|m(R|;;*{BmN
z)HTbgs5?2KF413Av7(l<{)^=}?fwi)>CHN76Mm<ST6lccPkcUZ8pTYD(SqaGTkKN&
zn2jddjz$oiWs8=`6WszQGhZgxcdMP9m&D|$uA0bkdUkcGoYuF*yBsWEV8J^b6AJ7k
zs+^ELA!01wPGr_C{tAv47Jh$!t03)-pg0t*gW}-j9n%GZXCI0P1yCXRL?PLYB!rdL
zETd^WS4>RfF=e~IOs-t!s|3m*hjl|(P?^TF(B*Pf?YRjsNxS884c{I3D)5Xy;K^&c
z=R!)Dw_L7LEGMdYZ!CTmXS5+yV;-Ytub0civ=_z$;mZ|rb*)TaD^|$0is1UNUYLJh
zT_Kw^jYeYubEVwH<J|o~tR@dDe-(dO@G5z(mT&Xkxk_&C@z*_(_8foNM{8Q{*K&mR
z?ijE=@U@JK&HE#|y&4Ya(~;P%n6g?Pp!p?5&rYqDD{K1_==o~-3r##geb)eVY6L*D
z*U0s>#YTh0$u)9s&4hk>R$(m?T`95sTHycoe}sK^KorOOH^&}|Qtl9rE=2*UiUq}j
zToDBYd#~8A$KGNA1q<RSCecZv#>(v)jhdnuHHsx_ED=p?(O41_kD$h0lIXpkXZ8*b
z_4|AO;Mkq=?94OIJZ+wt8E9bpHXt%{^h6~6xxuu~rP8=X*zQJCU1i)904UywHmn+8
zU^O<O4G+ho^q@^>!!P~eI@<&QnUwTk6THsVpkg)LjN*aF%iWBXwY>L`cX~65kLw2?
zT9GM6`S&;^4K6Z`6n^S!V5f@!p${cJFEZuSs8~5?IVM#4wvU0G++vDSCXJ;MTTGEP
z(;$_6EgJuo29_e4k_BHBStNo<tQ><P`$W@Z;l18yh6F#^%h5>cC7FVRUa1B)Loy9&
z@qI6-mHdc=8;Hd-x_z;|!p(sYPm5+3^1lU<;XqCL#bN=?>SO}svBgwdc&`^=Z!y(Z
zz@xIoG(x!0)7rv5qvRI8FT@~e%IE0m7bB6h>2uReA*YA6MJ|-YTQn-g+M-L{tG4Li
z)~YQ!j{LV<)MbRNMLFGhi~L#hZ6=K)W<uv}riSkQ6Dz3x<}5i_gl*o2kfYNH6&at;
zvQ7tU#Pc>&H_sm?Vu^v=HwTpXv1kU*#8Sr>rYXve!|}oGUzmCe7sn#N>$~?fENHvQ
z+5g93^2`nT6VtFFhLqE|cDt!<{hnhfaL}U4I|F!hViZofLmWt_3FL1jbDgiLaDVIX
zm|Wj%H?^*2bW2UeM0&B^6e<X93@mU5h->~B=<ho)^>S_-L2qB`Lh7VXA=vk(Xwwe;
z;go8uJq)Nz$BBjb#2q+P&itTaUtKP05Ij)s=R3V36tG|oVxQgC<~<7=@`m>;e(I`t
z#b7os?)}=ejtwT?uf^>BJ9;dm&I({n3IKdFbbXfq6sh=Hm4INa11tT~w2a0nGjT#M
zVVoWT0ErV4-J=)V``1{>aDDBdU<?NJuOa%@PpZ<l&Bs*i>dXmYq5b~PzO`{c1TsL?
zSqFR*sK!=Q6^m8Cg#cWq852T7y8qws99Df}(#L(8MZlh^@{%w|((+%W;?NL_=A+SX
z3@P@gMoz*)`8TEo-Y-T~jWEU1hH)bJ+Aa+7hL#3af0s!Tstq@=E4xfVHF{h(VnqRs
zU$xs*taRFpUIhGJ6e>IbSG}>@^g%UaLVhxEed+fief5@Ta(ezv)}_-*PuAd0XOCDl
zbppZa6R_$-(xdk^S*jpufHf%vN!GEOsSl`TtbMjM;OS=ShYFcsOKguRT2*irS4?WA
zqFdGpvd5H^XmpzM51`vZCl?V_!+W0yF9yVn({Nl;NYY+QiK$k1RM7+Q_mpqpj5!pI
zr}qw;qJn=g01Dz7U)lltUWSo65NvnCVN*R;_N~d+uMk%iz6EknJph_`%#@%sM_EA%
z4?s)Vdrh=u`T_#PzT9UDWmoqC!e_Xp@GS`W5jF_VB5e>}>%c1Z@z~Al&pCwVej+X)
ze5>-#a9d>yHH7!5x{miK<oVk@%Iat9(boNF&yTow@GX#Q!)zcUY#@dDTC4+pXKJN3
zI=NwUN(I(;uz80~-fYu%0Co|#555KLP+c3a`qWKopU^bfz?vU0g;XE27KU)g&MfnQ
zX)YjddtwK<Sca@T2*^`$@!(sK=hm@7K0^&A$W1OJ5ripWGgQS(!%8uTSy)V8C=ccp
z?DDB-_enWT-y7&Sb<mXTw+Oc!zV(Top|(%lpl<NS-)UuFi%U!fjP1ck23A@Ezu4j#
z@2EUE#8&wxwUjD{nOj=hms)^DOi<nPhZT*QUI*`Yu)A401Q#I!hAW#xVgMrYj~-}k
z*&$GGKJ{2}#1s`3{wBmGl@L`6Gvs*J_o*W2SnG@M;J3hj86-C}oZUN&5MmQ`m0%0{
z76uk~#MBU7jeWqo8p`sHnEZSZ8T=NMo3*Pz`Ih?3q4a2OVE#u<VKo;r9eC7pb5?tn
zig!Q_`WsY!)YQTkA-!(_d=OX#;8q$70_f8&k#Gk5W#w;^l~Y9dB6z*k_ZW)6DeoAH
za4V<;<rL~G4Mo)KW))Dza+9C{0g-Rg$HOkR>7qRbI&6+R2P@lY<tfeqayt{0D+mRg
zNIq$bprd0Zy2^CMT?6wu4)wI-Bxvv}PMCtj4iw57d?Y-r!T#tvY_`RGh@l+IO8if3
z$#GLNmC@;k@`_eX8_OOZFnM}LfgH#dER<<@9o;BMaP=xXxXb+B2{)`hXO0<_P*n>#
z=QKKf-O1M1xhG62rP2mAY|8S==6>t@PO$mx=M$#pXzrZ9Dw{i-H<vZ|0noZlur^YC
zWLYJ&FhFAye=r3oN}2HoQxecsf^89Je*n5xjkndPW>;f@4{FpuY4TS1vXqmiL|n}1
zR#x#z)k33;lcgEx3p)wb`zYO(NZ3&~F;;$frgwnDs#Ac{mie4AwZ?Z7%m&u?6u#?X
zs}MG8X=R0Lns@fQkexYYGNHQ99Vn5fQT^Un>-WM26xdbwlB;u5icBDRlqVIJpEl)C
zP+;&Mh)@0z`t|RrX!+V7O)=587gPN_IT+KJG!acELMi1vT*?VXhBAgd`q6Yyx%w!y
zv0Z0PVbv$&iL|NCHQIWyCudC|!k%CdVW}y_v#=wyN?(BBi|bGepdybiMc|4F41Pta
zNhb`!!-Z1QVDEt$1`32(UV!Cr$k9M>C&O<BmVV9@*x2aw!5lf(gwrh~EQKVJ7*)0n
z;ZvkHiQP<VP~$Ja9$S45GV-E3o_;<D<}yCUu<E>Ng7R`3ba={n(_vv%Cd9%|rj?NF
z`w{so&qYDCupM+8g4UT7VX(nZ4D^ZgF#At9twkcM_A_|ncvpO)<<F+5fzD9~e!`wL
zYFA(dM1=K;JgrTbE8#asE->c(cX#MlJ$(&P0rnlbQp?t%9WHqK7hm&EjYQxfq1L)F
z2TIp>Ne0&9f~j8etQ3k<DX&h47Wncb4&Ep^i3ArEq*?-*Iu`TZ1Ele6#t?7?KEyfM
z&!@vkl*v6B`IZ_xG~LHfPs`DffMN;%rEV1kcKzX^z`7wAchWi=L4obRpo+#>v`NL)
zDt2S$gpg3;tyo{L(3$PmEv?Ge<k3EUP3c1~`q1y;gespa3E1xA*Mu_Ene^Ktrb>3a
zvbTTOJZb<AzCmMNXlV^H;c^a$-I#C@Zy4dr_{X*nPxA9~!iUhF#D2PgRl1GMt4G%O
zWTU5+@RAVvUDCk*JA7kZ_0)pI)Pf1lmhcNudhKl@5Eu6S9`8%&rSS*uAJIO$g6VK_
zU>{!5JInWKTv1-W)R0X(-QPWscXoAeYQ%6nSNRUxIeMU1U>(X6cr(w`f3pOg6Pn$K
zO60;kvV?yDs;vT}8}=JzK~#kKBLgvR`}Y|wIWyD_QyeL300&@Phd0N3F>wV{Yy=Wm
zqx}CZ$PTe+UW5XF1qL;bIKnv?vk;WMt%bp%U{;t#b5+jteULf;$G=c6?D?~?sF8mI
zNXI_ifn^V7kzsL+j@mfJD~T1AD(kG4>zI$AFpvC43oRN=dqNi(KKyKm$4MAeTjYFg
z==gHvd~?_g?>I#{m`d0p=L78{=Ru(r)Oo~y?Y~1kzV=^h4)IO9+qKU5+AU|Z(qBxG
z;ca*syS4XjJi%`5eaIYn?LED>wW$5t`=|lX1F(Y(S?>(UxdzGy0^i<2R(RDEk^NOm
z5cxY|ayGQ0so>NOP<c#_gm=#2=?G(ty)`Chkz6d3x62ljv&4t`Xm>X8Fu7D;YpLp>
zaU5YxrK-f_G?a@ynJwc?j>&1wff3^=&b(%Faa3xJU~=QHBXGV)0|Wc~x+&OpNLg{=
zlcHEh?9|pesEW^Gd&R<L80DI`O#k`Y(Qt9~tlSrgla#9Bc8(Nz7V?|POBslg#fiU}
z4l0DAKm*%<+myf>+=i~;-T)2`{cVK5evtrRV{V%|3cm;N5}!ppid$hxE0~M*;NMcC
z{!uM5K*KHTh#$MpLG<PPVbb(F)g%P1QtI;mIg*uYN!*hNB&hVq@mg4Qw@(**haX30
zx%mb^K>S$21hpmnC}_Fz3+TelANu=+|1`Ohk<|hWFtYVX0wa5bPlG~U;2#Tmn&y}N
zG=h`F+l-9IV_<iRd_u$lQ~(VuA}F9?8V??l;qE5WuokZ}r>bZfn3#RbIA?3-Rl%uJ
z^UtA*Kibp{Kyg(njKj+Ec21Z7RG4vc$P!p~<rG6_cOGly<%`6Mef|}@e}0E4$9Ml^
z#K^mU>cyZO@qk&|?A=h<4BM0VSiyVR^n!$XZU*+?jwvo|Q5r%h3*yrb{TY&$`=cXv
zSb*Q#?@H>~8g{4I)I6dNCIFB0B-j_?WOu@MTZzwz;AhrhV<qd~^I^qilZTKOhg~YD
zDO~n4u<B)|$<VUY*d&l$W=c}FXoztsDKq&ftH1VlU{}jbjg>z<$5XApObvt>Pn;$2
zm#Isbs@)sSYYYBv-@NN^n0!lB@?aH~sQUT{kLnrNxpgbO+4xzTsxixs$<>0UVmcu{
z)tEFEU&RzzIbP>*AeK+ajVPT`ZVJs_R*!RC^L2?kNNCGXSlXdGa_lwv=i~XA0V7bX
zoZ?*x3x}g=#RIVs=F2#rinNFIsEugJW)LHqJp9tM<fn7dSt7mR?&Ak8ecsUEklQLu
zF||`_0faCPA8H&>wObp2(bNUlbVFJq8{B4<C-b}uCGj_B#6RDK3-Fesfla$>+A!SM
zhA@<freXlkVgQc<xIKpYgTDjRRGl33OZpLfjv6RtOZa2@n*eg(01yE4arQk^yzs)+
zz;@g-1!SKGahI#@;gt}%)0VaJApDU2^j;*wd2u3CTPP>iq<%=ENYmA>GJ&=<5wgPN
z0))L5C_s3v!!ul~s5RJ%U(im?Rgmg=Xt;v|+`IST7%%fMu-*5u_%}TaT<gkxc+t))
z4D8i?Q~hu*{Hk)Ab1`pn8dkdh<4HnYRG#3sW~r)SiB<CI20`^IWI0h?q8%L!%=N&>
z4K#J$dHg}?15;}3QD_aR6s=2+T~*!!j@*NBRbpw;NeF$kuFXSJJ@-DNiBs`yT61CO
z*Z97uzK{_Lh4uR)t?=7xJ-heNl-_b5v=&0B%f>gRbHyn&^X^LcSX%z2%AL{Js1|U@
zz?vK@YU;N=5=0OEc_iu26I@Ufd~rGw*^x)4X3EI>m~}g!n4<hrYGSAgQXn{AC{+u)
z%btsRR8adEhW(9t?|^gX9%`?6wK<aYKT)Js_NG??CQPk?Lkl092K&8=ct^F+s@105
zwN?8N1b*#_X^G#X@OM;eLggyIHm2NGZE<x2yYtjEO8wtjdn{r2N`KEA;JKq3#wPdZ
zNIMOd-Q3<c$jca)p5_jG#C;z|Y(M<9rNqK&?dbamN1(J#<v9oI0s$U7`-TL@41r$o
z2awkS52^W=xZd}RMKjqM`!dvz#%ell1dpuT{)tT>7R_=b5pCaCZQn4NFpUXm0KPW~
zLsFKEJuvoCfwZ=gF{5kO+5y9&_Yw06pA{CBi$yab+Q9yPX-a5<6OMl+%?-N~?@e(|
zvz#f*1h4p70Xb72P-!JL2Y~mw<40Glz!nMEmA(HlB?#>z4Xp4V(~Aa6p_io@Q&7ci
z@HJ|t;%fyjy0wM@kgx@Tv|D)dptD|9Vsr7oSY>(!OZMfzrn;UFp!*+;2XyOJki`%{
z4gNEIEQDh)PX1>a=y@AzxBX_3*=T#qSEflp)dvy+5jthjbf+@h9wu)NBKV^qHC~zO
z3O@!J*uz(*kf1S7uu&NS_|9B~4yVKIaPk2fXVLi9#V22zGE%fo;7E03j?|mOsZS|Y
zcvK)#R4$lGIN1fgr2Dz$BOEY}7EMnLwxGT?wHLaCV;7#q6zJCVu^y-Pm50DaM^ZBj
zgv@o!&QTVy!U8`7TVpW=r+m4RR%7`QOEa9U%dsh7hIBy8O61{4yf6|5Gx1xoqQ?!L
zMA{Hw3I8}5#M60iU+?x06kL10(@)ksl;{T6JQkw=&@7D!r%-@z1)}8ezn@_%qSbaH
z!^sLS5!M0I4j$mOa*8-X>F`jGRb8)6-YZ{=YT^FBdgh@JwZf5F*h<lHL6}lW`5R{S
z_hN+#(My<s^pcJXYRBz)Ksav|W?uIp^&uaFM9kfGBa_yQ&DNx3STxI;VVD$R?d*;y
zW6{ibPOXv|v{gspX3)nk31C$-D7}`|44Nfp!VIdkXvQn~ys=q9h26LnL^Ejt9!W~v
z`+%Bu3H>EBz--5a`93RN;UTY0HT97B=0X&+txdH_j#sF8cI}I5IXj{v+uB_7&%3aA
z+MrXg@Tr<>RG#cXgHCGo6kg%E`REGr?P$T~1hJ9u>3u!>Ll9$w$K1zZ7HCyBWaAJ+
zFm3zUjPs)!bxLwn;ee0u<Umcnia!3_e5H`LO-9$MtWG|T(8K%m=oBZ^N6|8+7@+JO
zjPblxKUEX?++F4*?NG@&@U&~0l)7|dwl4_VqWS$b#?xbKvS*AJ27<748V3Yh_mklu
z8@``R$q$x-ZK)e%3IE95z#8}M6yZ7s;Hgdfmcxs6XjQUz_y$lIftV>Dvua*}9E)aF
z5RLOx{K}@~11GV&PzrsrT{SVtb5U)B13z7IDmGYwJa&MhW>gb(LO+z)Urmg1Z2(1@
z<XQGIeCJ^`(N9woDXGV406`*L9A-AcHuLJDChZ$<;$*YKRC`+^*SzHcsaeO(gYklW
zz5jvMpmg9u`8%9TnWLbFWfVl<{O76O<*={I0;#Q@kAM_)-*H~SAA%;RM<4QydlvI4
zBlTz(O38h>xx9CVBea|bg}nnEU99JE-EgsI>ZoqfoJJD$ArSQ|hZ)i)(^+inWQ<$1
zrw04jS%h2D?dPr7UhOQ>6<eLsRI6%;p?-b6&?#^~7_^9mA>IcDeC-Bg*}uOOMSAfB
z^0pxZIZjt7XIc$0R`~0Qo)y&)hjerTYbtvm5(7B4?mm2kPL_$Zk<yqn&XcgF5xYRm
zjpC@<Uti{Z&uNF{4o|Sg577~N*$7p;M@=yz{NWN(e0kb?RG=KNslZ@*`5D`I{R~jK
z*4Gpp3p&X5d9Gq)EpNyPqM0nzwaziMi<qZq&sMsKi9$OF^HLWvM)1SK!>27h+2Id6
z1$y48F4t<7UqQ%B`@uLL;T{Zy9cwy;39BGM=mS1utVQ=Nwnua!D{&Q*t7|CJIDxI$
z{Z*9r9}w~Oq8GGxz8Z9UH!;F{%iDRYkT=gwtgWAhJQ~Vli)>xsM*(#2);YBxxL_8x
zdMRmU7fgnneKw^LuC;=meVh*7Y4cZ!rQ8LBzJ6%$mcmOX9MIw}M*9B<F(Y%W{xrkv
zRSw?CGnf%M-;E0srlH0L)bQzm8id8w3#)eWrn^`o1U}NUO)9aCP$U@GUn-GK2>Eog
zfoarY13XsKt5}*^3{$$hK~0&c7JZc7S3oaI)nZF!-eo+UQi}<~(tCO)c!;S@50!&V
zZec>}zENPbt;Dm{mWu7qRvO5Gl3xA^5x_J|h<P564#zQtKlTuVmAf3FEbsFWI|?o^
zLtJZ#E!s!qk{m=lid6<4P{@69x2DGvq<l=9^21cjnO@(g*Ui|0h*?=Vi&*LUEV`30
z?t83SZOB?8B*Nn{!c**z$&`H5z??T`HFiG-(NR_kYPV=s)iJQNjak7>5^ECGyRA$m
zmw;0c{?SH7U+eL|pZ!kE0-b}t260oq$f7ZzCaxUxVUxW?pNR9|$&hixZG6ptKuxA0
zIg>*Sq8M2=`}To+kDzM0t9*~(keUYh9>K$}^!y${oPuwh>dNMOiy1=7EB%{y2Hx}$
z8)J>V-AyQ(e!gOvPzSW`<R>O0(fbAx+xy`xz+d!iq@T#>zrtVaBpiLIXWjh8CV~+U
zOZ>%?IKX-Pe#nXdF~fBrcrm#px6d?MioXgFBNYjU!$E{bw|>cl1jLphpeH^5FLS{v
z5(X52hm-U?xVYu}G-p^eIl+cvRc+B*(UAQC64?T_A*)mCU5VGur^Jtt$i++^G~O~t
zP?1HG=8MyygT#8-zguvaqtQ*<nxp?#l8pWtR`jP`0nVH9%0YhvR5I#fuO|%iJe-4E
z7caVF3+0>gyzv4i)(a4Dxg(@5_d3Xj5nIe7op2x+ZpfQ}NmK5_kLl(;Wd8+;HH2Q6
zQ_jI+m|zC0Y!EE^)Qp%$BdA7cmRX$DO>InCbj1bim(CG3-o^RBKUwk?I(j*<4tuhK
zn>K<dus=uG3mh2o;@>F*<PX6rC#swyJiQnWm@Tbp*Y&waTe8bwS^w`_^Y}T!9<SgZ
z<Jacx{0~q39N~^&-}Yy*w6LDV()uDuf?u0A3nX9VAmM;cP~PmkM0OEJh|;}+0~h`U
zbgRGjx1Rxr`+L_xwR@MpcR7`?`g<esTybmOPZ+Pt&)D6X_xaZbemZe>Mj0sz*h?2k
zZOp&%KX1*W!}$tSs@*jpoo=FasRdpqG1TEeNb1lg%TpEbk3h8@cb=3;SU}vBw&PcN
z%K_~HHm_go0d4qWUdd}!sv`T5<u@d(M}qZA3&4m5jJFasa$<Isk`8j>ger;U=Xmw5
zlt`KhZ`Va6;vSkqj#gh`8gjvEV%9a2Rdx?+K~4R$q_UHiNCyX&jewO@!9Uif?Y2K6
zvoKQJ{KhHBQDRr2FJ^v)L)PcW-9kH`>+}ufJFL1_l-S4d_c+!eS{&yK9&VF614#0~
zdm)!9jTU1a%k}Jav^b(hueJelTbO&>4(*h9%VOg<<_0;ZDj+gHKCLgl5hIRK2<MOK
zSw@_gR-@WzqWuRi^u_DqM6E(mSX|N!ET-ZF&*BG(VwA$>j%Fb(#9l&=^LqAv3o*>`
zHl$+<QSV;K-nr`hpoQ35$UCQJ9a@UvRA^F5(NHDmvZSRL;p!escm-W0{HJG+T8dFl
zRyD2WBtz|oNA>VlbP7pVJWS2+pyujqg?p6cv=Tc+=>C#<{wwn4MdB7FNb-GTSMi8G
z&WtWT)w74K#0LJ?4(j>(T$_S%*n5AEPWugnqf~Q5&srpjorO<t>6tM}3{04HixmAA
zKy_rrtQc?vTBZYc#E~Led1wRQ?w*FK*OSDSJ}#(A?4;k2s)9bgwb(!ya8b{Ov=)==
z4~2NbzUkh?)?E47f*v3zI#nHBy!Z0QD35bhxqPZc<80Bhv#rHgm#CXyudOYbbMP8f
zOBU;D{=Gr1oaKC6fK$MM91))!*R$5i&<}F&gDvz)788>V$L03?p2?T1$w!H6Ff?sY
z01Wb5?kXaI+0w$xSu}qEDmt$2$7!48G@jhKnlUc=64>a)#*;@2M@#g~&}4F3VHO^)
zX~hWT`-7n6?`|?VLeRoeYM>LRIkvmSM4i~p@vDaHKb=?rd0DXDz?SO8WY;uDS(1G+
z0JSdZ#Sy}L5U)Ce*jl*oou19d12luK>!3K{5{%-@263gr^%Cr35`WM8qSDM1@r5!5
z$_ER*_I@44+KMNX##@CJHng3%$Z@{9_-;EfU(uo-?4+`_vbMbAHVH1x{vc?}kwBJ3
zGw%X&{{rHm0-*P1yj?@E91bjap~odOVqgy=uj6(&m<zkrs7ktq?Zyk2Z&BkTTm4^u
z#9M%@tmDRui{~+yp=T_B+?zl*UNq)%v>7lK(q24~{SB;|vM1zEHYP0wVCYFCFmrj!
zM3`hGF#m%ABj17X2v6EwIB*0l{qhV79zaWx07K1Mb{!JrvMVX#&!}+(R1iN8@_qI%
z2qzk!s?9&8`a1~k0Yv}g)_w`uPtQr}+SHIo7{Ub|#0cRb90}Vyh|$7PJY4M{`n8;a
zlI2)QK~VetFmgoU(u<M!XWju3T1EygTs=_1P@+5vKXjWji2J#Dxfg4YF8Yk<iH4BR
z%7H4qgwv{AXVG||hDGBd*OQyH9aKr>3aQ*fywF9^Wxr9m-|<T=K+}EA7pWZP+VyV4
zzD^*EyCs<7%s9`LI~Tau<UtL%UTu|uohY5t309kDu?vgM5Hs<(eYXo+ks%I*&RG}X
z)wj>hiFQALW|VE^I%n=<JqtWPCm_t@Cee;t+W<}n)%|5Uu-zE5{2Sswtl`{Fo;7-&
zq$Wn9;`H-#>O^?fLd$W*$39G4tJdjk9#})xI(K)WHm|>l$=y+0ElfJ8XX84FEkOEX
zK9otH9qc61B_1(huIx!CF%*vpL9Wcdv)Ekq2|&X2$hWG`0goNhS)>yvr+#3qx~sD|
zPYBwnXU)5a^;HR=65Aad8&+70<aZHIJNi^(y}F9^Q1v5hG3R%4tm-P}2(7p4nO`?l
z?SYABt9od;waBP$;u36zuV-*&FS?2E>xO_$m-PiXr;y4Y3mu8*w;9nl6w#1lTHJj>
zW;?PuvupurU-r;e{=d6=_H}nLw0GVWj_7Z_IHK#|U**jn%I&Dq67*n$@zW6`e1M4o
z%B_c@<<o6Bhpr)~4<;OMO)j9v_7Fq6xyaD9GW5Zo_RtHyK$XKFU>l6S1pOso0D2aR
za!`NVM&cT|6b}9b;PpL3zwE~l%G6&8#jO{8td(n~p(d6>P_4WN06nTjuS@B*EvD#X
z<YEjt_a`;49C6Q@fp&>4C@~P9M%`MMIRncE2rC1-eS!!tEkB!Xkai8z?N&@3!&jcV
zQ?*PeYNU?KSA76Rc}GYW+if3Ru;f|Zz%D^c30T(Q7kzvPG}E%q)yuL-f}1l(#yp+f
z^1U?`w|>Oatsl)X730l2sX*SdDYa<CaqY)QvH(NOWt`eA<_&2??FFb>sU^UZA}j09
zx7n2SR|g?wy7dyprW?Tz?UeK*cQ6!~>0?p}PLE6II_Zv8l=M4GtV;T#5}Jm6ps@ab
zlyuz%NXe~z#Hq@gKiib_1K)GiS^L)A)>~{!dO6Ibs!IAn(0_%VVCM{=b>9hRi;{#9
zNA+w)qgMVd^MNL;+jNis?84ci6oljj^cVeInx#;`LVwo7{i5wJ;+i$5qD634*O?oY
z(EK~jAphjuxp2&&RFt0u3&i?-rmkSxNV5Xg65;0CHUwkSPlOwXRj-S}g$7V;B46WL
z`B#Vatncfhuv!-n6W@4lj^Jh0D9hB{=QgNjjN7*ts88uWH&tkd!iC-E)<I$_CGP1y
zx4UrSke<ye9OuRA_Lv*yW;{eFfb0009`d+*kGYY;dT^m^<oPwEyxb$c)THmwU0!Yq
zmD}HAZoF4K^lOVI8o!m4AcwB3J_~eNO_}+dWm6_G0Au+sOQr!8AWH_VJh2JSi{pyg
zyF<UL90wd!GnRL)UomxU?A)Hhl>^pZd^L7%u-m2s)?PeHM(f`DZ9@Y!#CYXJDDCIV
zwolZ(ViY7Db^lFz_}{kAsv%-C#eSAJL`)GFl$o3%;$+7yf3c@S#3c9M_M@_KpB6YV
zzvsuaL&YX&ylFie|Nc<1jp7G(aHtsN5sP9pM6;7<II~Xc*~_6~u<w8S<m7ao-1Ic?
zCo9VF!^Fn;=CEP-=9qnYwr!YL&vBGHyD&^_;P|nbRU0lQ`Jda1Z}VWI{yMAS05UxC
z8NNMWxTsScXX}RJ+vzAq-(J&_zP%7K>B?|1I5N<hJeDVul#{=03I71JX*Z5J&x`6c
zzMv!t*`Hr=67mCCPf5Qa3AXshHv)+IKjH-v)*ugZbv6F6zUMcGYSMsxG%~Yt2x$WG
zTP{w`q5033U|OdZOhZhY#;>5_eAu;e#kX#`C|deft^CCmwMN)#k$dlDXRpAoK$+oV
zF4AuTo-6xB&3N##C^WX8Aa@O}!Gy8bsWVBDNJ7`{9jDGDbV4HfbOCQH>7SyICO%Nt
z(5K$iC-M{mRF#{&PC%U4mUQ0>fhTx-Z-j_OnEd_L5X6clUGQfDJc<Axjlh!bSR?#?
zhoZ5y;>iZ0D<`+!<U7E}XknLR8PeRTc)NNyS?u{Nwm#P6?RWCnJD`5J0I<%+;{4H7
zORZ3apbc<KMVgv`6FK$5tq2WFflA!MK2rvB>HBwp*`H?vvk7Cv8z;o9*Rv;)rby@B
zueA>5mS4VRVNs@70R0Pl#0V&x7=_O6Kl%=M2Xk%k7UL{n4zH1V9Xgx8CTyqN!O$LW
zcRJAuOHHnK-zKbKjLFl{#oF-eN8a%valY+CpXb{e-sm%|%}4Y8`(ewOwf`fh$^9=s
z{0=as^K4*>L1l9Plh^8*u2zw!IyobMF2*-$=D)y0|Lw1t5NnzNJRIx_S8=SVso#o2
z?*RExjt%61MKZ{G*zE;R{co%FEGf<uh0yGuyV&7?=m`UVxda2B6NiC6Fja2x3Z%S6
zPJOd0z%Q%{{!@Uj&-d0G@5~z*<mf$FhV;q7cR-pu*9K`g5fccr9uAB93FhP{G+@7w
z!j9;gXXX~*EUaw<zP01aP8EoaFOY%f9(V`vg>!7cI}wQy)eDzC*0a=jQ@Z=jXIk_a
z&~XVE%-@aiCcRMdg`VAsH+`ty`&?@~)(Pj#qEipg3=3sj8=BObvTf9`8|LQq`Jw=s
zFIZhvXNglB7ke;MpQ8Q3SH*fZyl+v2)g>`ugt$K73G@T9M7?5ZDWwf9Qs1LxsMEXk
z#W5pA!BJQRwY%YH@mt4IJ-a(v3=b_RDn!xmxi#3CJ3eQJC7P#xRcI+MfyeO!J^S*%
zJYUv+j2Q2DR?lXS5r1e2Z$NoSc>v4?Xm=S7Q@yxqr=Vo$U_b1ZEebUMGuS}HvX9jx
zmc0`hZ2hae1uzya{Nuu+U*{#e8fzbV;sPd>(Bg#)3xAQ<)DitMjuVGDp3$>eV<!f(
z8!z&L>OTGks5fd}{H?XAm@79EXGwaE6pO|T;cC;^dga?RwgGD}oF9%XS|}XFL#q%m
zI2@wMPIIe^bVBo~FlyhfudSNf%JmEA($5AX3@mlPL>#yt=dsv@-5)Pz!yFr)Wi`hf
zc0uEQ#m%wrp+dDEI58kB_bY0qTjG5!y5#ijJsSP)6&HA(TR>W|Y>s`r8mwG18WoEM
zP7H||K{_tXG0T^B=GgpdGW!0hL(RL5EZKQAa3U6A;`$Fauz*1m*9foX>)GBx6K8o<
zM+b1Od)d!u6ryn~nq$zG(lRFoWzXBm+tu_gZ`av!xm`AQ!P#73MF&Jc7$7{+CWS5G
zt1v%sQ6coQJlGJ!K^~;xmG$RzqUjAVFqwE*+HH7pc>EQ&s|lxF5l%rp`fG>YA=+wT
zs?Foz{UVC^BZRti7J2rP3|ccQR4%}}Qc~lg26j}rAjP#D`YX|NOVnT*rv;+~cTmPW
zrv<HRP0azaEN9_n!o9t?are0c>oR1bPc36o%^?Pdin}luz?1lo(}Mo)SvxUegZPNW
zz}qpb+Jcbm+h1_Zd{V|S(;olqN3792U?u_G!IeM^kIS*%4^ks+%&=i&yo`+<X2J$-
zQO1n~n1>u2WYZ8b4%4CmkkJ>mT!pp$E0nF;gp3|Rgp6e5y@`ySLnmUFRMK|ri?}j$
zVh7hqG=icSIv8Dtv4>aYcrwGViG93wZl{5NT^56;q~$-cXvRaA+&OGw-PYmTc=vv}
z!@IW$|LnUrIh)!k4}6GK3m9MtZ?%$!-5oFnPZ#T^!`!s>;}txA<nLIyl}aqfFPUXv
zaL#7<6VL{Wc}XC3W(u;1SgRO8)dyLPAn_xrJ`?)c|HlYg@i{~VU#W<vC%#f~9Yp!A
zm5LwdKw;!76)vPu+FyAXaN}cp<=Y<1*3k5Q62RL+(`N&a9GZ@5?^5uCse~;weU{x)
z#ZZh-#RNKHw^Y%hpH*G|wU9VF)b(xO(!-7axm2-g%ecU7^D4bV6`Kt+q_g(famCbH
z5Ttwi%EI;BP4djvZdkI&sXAglb6+@4aqN8r%<&~+X%RZ!72m{hjQAkFcIBAUA4pb|
zms(c@RJ)z1Tq{Q$?|_TN@pz=O`OZd&g<Q>1O4>$Al{iE2_B_$I-Z#9CYC#Fco$rZn
zSn@#irQ1{_s}_7u#9&Nv#`fJo^F&Sm?nq57a2mz`xwWT%%}-1XKoeWz*`i6DP9x@&
zCg(@fKVxUC4{Msyqu>;Yf3!5*{KQ^Bc1Tqj&ZS0`rWUwW$2Pmtd18=oF##+5^F*)g
zI~xiucJ0}TAWl_YOFl=FHsJ-5SOOb}LW)ImvRLnse<bIzq72bo<WHH05;j|eho_V-
zBiwC7Ip8k;nA1=cP?YCj603IqYmNppp&8uOn~1(uk=~)|Qc6j#Sl8becc~Wz3b+*}
ztgy%jo2DBzkMY7@<%$cj#r}B{Jm=?$!PSf!J*98Y6QgT=1LlK*Zb(4oRaEA$JaMa#
z3>p6M0<6eq&d{?P3&i@u@f~`mUWf$?WB5n6AWaLBUQO3C{X(&+@MIIj=tA*Vp-Hx$
z^;;y?6?(#bHg6G7mh=fU5}eo2{PZ<qU2v})vuLQl=n-yu06QxG2{QK>axI!YNbgL0
zP^!bHNc?!b2l(;4#iD1c#XCraIE=W}1?N>CmGrTv71i!`k;mFaI<`^}J9c{77122e
zvZ`DsSsyXZKkQfHP6$NCZXm}EWRxY`#7AMW++WYx*X23beNeytO8>}w(8;?t1M!8r
zgUGE|=E8+~v5PQv;dLPuE#Vn+t8!O|&gM@+Njnv2u57FB{OEm6_H_EL9Ek7tH8+=1
z&;;7zq2@tLx;>D|D1oDIm%`{pTVU836V7!Ea@ec3=7j$;5#K5VJ?k0}HNBvjRp1nh
z7tE}LFKK3BVih>~QwqMGhl=v8k8JZAgvo`>)3f3=qQN^FNPi=y#Ag|XdaXDpdzbO8
zyp2dAY4gY(T4Uh?%T%FZ32wbKCcXHK(5TsX71~pCe9EHn0SB&}(i{OOuf+N$U6c7d
zHUFYT^Y3i?GV-RPf?yIqU^ndkTCtVz&r&^$`%Fyo-n*2OjkzX1ZP7egBXfV2^O@K}
z7>z;{OcRi7EwtRte)&npen_U&tVRL2o&1`avT1k>UgcFa?)$qz8hRT{Q<5_KUF|_o
znC&`I<Jk=C*FKi>EbOEg>%_pQkymI~kI6HemL_orV;0InN0AW>k@h~??7}9_?WS=*
zzl3^YG1sB5AObr(%_|*A6;umKj$MO=*+^6;s~KpvN2Wcu<lVtRt~h}FS(!i1Bd^Y5
zx(P4QOJuxcTR^wOMLN0IcZ%1n0vF8x&G$FI465o9EfXCY+4C~Gt!m>`|1k)|nACnX
z$UxO5$%kGGv>}$8bVHer4U5ig;@%2nRUQU48X9_8i&JRCC63?dS)-WTutp0(EeD9a
zffS1-1fz=(*3^76#kmEjcFzt|T61yB;UkFW@~v!e>kje4&r|hmUrcV@Fw6#QKX|Mf
zUp-4T;Y6D()!%LfxBTI$nNWHkFPdd|VTB)z2`|3$<wq)o-THKK;e7oig<r)iLFnq2
z!a_R+!Y{SVvl|@t;Efe-_4>5L=rz!BX{g?6N5HRk?Fhn)+>YWsqDm20IjXcanOUU+
zd#~D6{0=X2#gW6-*Hy?yncQ}}gLFc^6MgJnwcm*WDOLh$W;e3H*752jpDGECA6jTp
ztt>$j$RM@Ahqej)V@-is^_^JX_r3o16PDC3M30rdr)PhDC&s?H1RiogG`LmvkK9NT
z4v0bhAn*4f?wtFxj7i74lS@i7_%sNKPIIwno&k~e)gT<g>%g$7Ov_4Dy?6GpYOY4$
zs2y@LOBGqWI$^f#fS6gg09(E%YaXfkIOXH1VM&&%eyM6ziBYLNLW#3!NBG!-i1J!N
zJH3}56l*JI(9_O?qF*g5dxt&>wbSjE5v{&@Pz>-tk0-P<_*8{`cz2eS2dPWMI&XGf
zTOu~Ex9=ngwhK_PD%%b;<Yb2^rYg0Ir-#b8X6sADUX`P^>X10T;k>2%a~FTW=Q21$
ztqWm|DYi_`xKNo<6B*>hJ0uQFd<{HV&)6A;yYuLH{eZrxhhV5I%qWTy(4-c$#9kVK
zOB-%XoSUg<O%IDbh0J;S;^l|MG)3b6<J5A~G-4ZP!QeGpdBRGbaGVl8<q3I6sO(!-
zVX^wCcvs=o`8HAR_}VY{_>7OE_hR)ixLT8Aj&fB1PVmXp>;fnKbqWUHs$l~>LV%5w
ztOCsFRGU)lKfoRw7kjDP0K}m3P{x9ncpTNTo+rfc>@olZ|K(-|_wqt+x`m<SUM&#V
z5L_M0bF&8%6Q=Fa#|}7Pd1h}8@*vVIn$J<4c;r7%mfA(ULhPsJ-g$Ar7mS=^%o0A2
z8g7%Rm5r+g%>WaJO$h4}%z}SFaOfYMvF`AL7^S*(m^fb>Whw4P`u?z%eei=g!Lu*)
zg@Xjvy1C%d0zK256q!)i2}|%N#rD-bsjZ;DiD6v=SimVUv}WWX08+bo9MZD3rx1O&
zrK6s$IwdysEQBPr2NszJ#qE?BEVM=m#c6S-_mUwM(g@!~xZ5C3HG>Ci^kJQ!Z`61x
zj#$En4X-+!tImr}YYsffKick~mTAw6ql6>raI>Em8+mSrKs!iCJU~dqMku%m9-bEi
zgiMrB{UkPvel~!x%~!0k?v3x7r^x6wFZ~<dY0Wg?z^WWg_(}Bj^&%}jU!XI|lM)XQ
z3ATsi0&(-)+aNYut~1Z|mvc*h65FZ9eJ9gI1ZZO7cUl(lvly=V1c}z+=X)R?VlrUm
z?PoF4JKc#q*fdLwaf#V9+v3u)gV|?4i(R_7p<1~o<*H$11oM(^o%d^TP*`1bfM^NP
zhX17JmsvE;c^^4Nk!rM2NkZ(odG9^y;AV^qcd2MEh+gnYEt?z6`dkoGbWN4?b+=xC
z$=O~*OT!<qAP)XY%n+HN-I{YrF?1`~Czny%K8`&I{V}{3#D+EZ&*3W!XXXSm|BK?7
z4yrMH4)|7>hy#u^yayPAI1Ej^5WxF27S|FOHKXx{ywyOE4Rm_`{Z#7IqJDZ-dQof`
z{NZR>QTe@`x^o62UO5|yHbX9niO&ClmUu5SFNuvkUrwz`i!0{nnduUAxh3uN?9i-v
z8W!7rrZaQAEP8uRp|UxS6(r<}vN4y%fV7BqG}f0>jl*B`8*s#`MsdQu)*IqqeUM1*
z0M&$zg_H^^qqSPTS&_E2bOvWzepw8z)%q`Le&kFtwd&v(Bvo=*4AQjbcWU7tf_yR#
z=u9}T#d`Mmve-tIv8R&9blGF&F;OEqeyj4BVJK<OWA^u;_PmS7{53-6F)hlf@EB~G
z1e?LRX$uBFgG{cnM3RV3!<?tf<?_$6zpjWuuEw|zI+P%|Ag*7Eo_YNuexu&MTkD_)
zhiMWC;y<`s%P#*S);BDJ0*b352!b6wfUv$t@rnkc&$YY1F|4%X0{13#gLChy*s`j{
zS$I|SZ5jsb@1-A*Jm;(brgFp}V9fpyg+hGnm+&AEv(se!EB^7CxJ&VdPEdN4W=6t7
z?7k|yDh41}s;Q#`t8q<i?&3cbLyaJr_OL87u8DraKq&g7u89pIjZSs=$K|uBk0f&)
zf_*Jd6vV-88)c=)!t2<$lT8@~$`hdZHB&LuDJGLl5K`BDE#c-Ay~Fd%&_|SXVFyf<
zHe@I|efybBODV9ex*g^p;>Sz6%-|jNJ@Qt)d2iNhV$`t8ia!yLBdgASB557+Up~LG
zz=CrK6%MLShmL?r-4MNkPMp#^=yENurq4i-61H<?rWb^78wVmPh})H;XCK@UhiCU#
zU1-teU&_BADO7pWpwyLLm3b<3vxabB7Vtn#h$bHP-$U2E+q~CwpVL%q*si_!vJ0ke
z9*~J>XtMy`_RR8A`BUo!j&*>>{BsS@H@~9#@G!zxnm^F0)*e%}d8EyIHnj^_W7!Nh
zckqyKJ-~pEw%qB$@_rNBS(gk7+wSyr90zGeJ02Eh%Em}ozf5@&Y`tYa32@4SG0C^3
z-oc!UbT;m`=$l=MA)ae)f!uD$&D}$X+&Dm4r4ZB{YCF|FLHUi5U$B_+8=lWCQ>gSO
z^Z8rvD)@GwT}8QfXMoPrh?T<~@o8I(OF?7){A@9ek?YYJoSbF3uKq(j5otq}yyG2q
z`IsG$QsHq^-k3nFB>A&3nui^*zpeyZ<NF+;y?npnm5jYV#i=0RKUT}+rKOk=80-8P
z5m4y32_%cs!xAkT$H{tD`;HhY^i0G$+8uF~a0Y|^%N;R4VlWsH{6*bU5r~3gI^y_^
zD16@m8dZIKF!-E%Gd;^Ui(xfJwGY7St)_am+bo7#$7a28ZJWTINieh&H?TNojV`sr
zc(Jw&`&<NdD?MAZd~F+#70?YTugi(SuwGlf_JHsehV|ESaTiYV(zBI!#Ua8Mz2FVM
zD=t;`{0LEr?LSysZx9~R^2^HpLckLDoXO{H%FRX4zAN&}Ho(($kcO4(q+14J1oDsY
zy%s!72u|-WdQ#dA^Q%ktghNt@4iAV$ZlyVc>1|9{J_;tZ6F}nJljim#1n%!LW|HtB
z+V{>K(WS0qq8%IQ*?+EM8fZQ!Byo>hGS%g~EA&2A`nMR{=Eo6SOK)h>IvhX*G_btz
z4OR-qlaIp`a4o3q{`K4Q?OOtR&^{3Rxqn<&UYQ5)nl?($wmcAHlo5c=E<X@EDQ{%q
zDdwT5*JN)d9;Z22M=qXf(X1Vbu+fL&R_|V$=wqBCP6><ThIAk#uHlgwrCdE6046*V
zBbt?vW`3z8$zs86;DKoct<wtHg4-qZLy5f<-fijZn^!WWUil>O?p{cQhR}7BmYsPd
zc6Ij(t!U+=EI4K!iviX8cL9?QWQSCJy_H%#vxzlwy>Z%V(x<~Xa*l2Ua(p>*9zxn9
z<H=CUaEn0(*05ahkCqHn)=R_pH-Sn2Sd7<v+gTp&8s{<Gwu!guiJ0PbKUi)C3><km
z<k)aM>+?jM;FVSFjT}94etjY)H}SOP;0Cc_#6X9I`KA|)4U0!-xA1iha;R0eWI9*Q
z0oM7c7}26=2=B+)^%ed24;BFFI~82u6!I+La{#xpGSOw{FVnn2J655~7dYlvl~)^t
zo~poB9Jfgcb&CIZDlSzh$1M3@<j6PZM?>q5AJIUQ|4wquc_DW5$Q%^xa3C6}PR~DS
z(R|$jf!){EMmsAWgJR~b)iUpw;#@%+r)T%CtqpD;@wdD-+4^+V>4bh2;N+ruP?fFB
z74K!f|5&gmQx+7YtpHUaw)f)B|BCArb=_8L9WwGe#-|-`n@AH`)vH9O@@T6?T4%VK
z*Y(E@rL|s(i<I>m*C7YbXN#**Qy*BJW=B+Z@$oXxEm26l0xxvZJM5vuWm5B%VF&4f
zvmqQc14h%>QA&@?2t{PO;%^F?RpZ05at`wqdLdsrqBG4X1KV+$1B;GQb3tX$Gqa;K
z#os&xg$kO4(J9sLR(1ocd7fU+rU}w8k0HIRKsa04mZ&c-7o>27&}6Wlc{)iE`VWIZ
z|D!CLt?5u@n^d;W08T)Q-g%n|6>6t(-GgBSYD4hYRemH-STj7bSx!<vrD-mP{}(4I
z%=0>QU(N{+5IBqGN6cc6YEqNf9mxO*252d%I$~`g+k5iue2B2hK^=2#flaI?wG>j5
z_3WT=oFT{&Rmm*rimF&g07@$<6+B2?T}l$f){rtEb@FG|#BuJCvs=qGP9L=YSXN;b
zIf^f{2^WU>_!ZJ@P{H%~roWJdRNvCrF-gyQRNs<9|4)BEx{3M#wW2tqg2Gs#vot}t
z+a7!PYDi;4=d_o<ec?MQcMzDZY^_WgH)~2bI=FUh2-eBMT%^v9(knL2MT%@R7s00x
z80MxBC*`Nf^h5w>6kZ5%xAqgfQzVBg_7XuBcu!wi%@}?^sKip-)n~ewLNNJ2&-9(%
z+V8spOl-}iH<&v0y3|by_AZn+6wsa>AJy)fV55yQFrJ!G=^@!7s?wSREUntJ@Qlnv
zWP;;m;Eju=GJdyb?qOISSi?twNV&jWUYw5bgMH&rZb;2N46RfyVoB#P@+*p94k1_~
z)pFQYVlxgwO*i^DEvhJ@L=nEC5bLLBr$(g*^?JOdvT?`pjBn@5fM4Rxw#P`<RoAT>
z<`JeBIact8eG!$IBZdh^(J7#E7~_QzUapCD43FjbWN7T>HB5Px)WQ*}$u^Y~PXBc+
zl6({TG^1HIOKpy%-qgU=;g|#Dqe;X&_q$;DESg3rMpQh14`>q0glb7EG=<3dvU{=@
zI~&xyrtr9{o=q6hDlB^q(rG1uZvk{eNT!-Y*wvLFSj-oSIb}iTtLzV_EGYiN+uM2G
z@!rG!{Z0D*AMbtg&~VKAV0-r!|9~9=<qvY#{j|+C*S+k@-~D0L_ns?l@2qsmg7D}?
z(A>&S;S11Ury%;_DNf_j!B&v@2611m$oi(~S#ZIEz~F|SWcqeM5&Pwf-^pr&Z*UMB
z{Cn?KZm*jVa$2IxvH4o&`s?R`>|nuyYSpHPVT4`Sx&Qijsi7%<RZ;BbVl7)&ORAlX
zlyV^rQ9gX7ek1fenu8~I5t6@YL-fI2#eKB+KDqg=KCg#l<>ULlsmEdWpfks{&ip?X
z1s7{!x5$P+)j*6<UHieRawS`MYAT-<U!juidO%L_E4<`wYB_*_@FwSu0oikLmk1`|
z2iBs_$lyi0*cau5&7vv@o6JRH!q4qM7}&T0S-;8KzA@kfRKRHf2YL}}mF7=F2`(L;
zXVLtrCuJSc;`ulFd0WDJLnE-CN8EK%xU+8^cYmr+D8!)}sd`qjv#*zC9zF{B9g3_2
zU(mNTb0NfjJiRl`?}JA6D|DQ`vynuLBWqguv>x(yb|)m!1X}m?Qocop50@jj3?(i>
zA_6PWSl*)bU-qq=ROSkJDoA@ikE$WY3ZestwJ0VQ^21u9P`W}n<5-)nuD}}Gsgd@)
zZ8HfA!BoS?y)pL?UNx#yhGRU;#ZjFC>3^5kEq!AK#lO|ZbR^LnUh`#D$;8x+`*m?_
z0E$1}DnK}fhk1?r`9(B%3&6)nA^_%{ODl95_P|G)nC)4mFv?&@6q3p}5^Wd2NewN*
zEw!Kr&W3}M@JD@n(7g0{B&Fw1hGzP=ISAnGxeJZ0=H)z$Bhk1eymd``8X}x$qd=GW
z6$OIcDqz38bg==1A#X2TNssp1OFd`|Ag1_;9PCpuBIE)f=T15px90B{Vv*g{V3Rmo
z<7H~pAvVZQ>LEN(VRhI~ic*htv2P$T+^;&2gJw{X3!89gaX;@bF@}6$u98JRi$y@+
zR~>w^<Mo_w*HU+)INk1z#rKR!S~+7)WyS_%5VNOwUI}S66)#YRamuT~BLL&^J)+dh
zUl64pZiVI*+M`5Eb45l;wvnFgaiX%~1k2Bm*S6E}^ldrk7=hMQISuas2;a8B^)ABs
z<tkXEhtBSpONCwO+S*K1N6Ih`h1T$0&<7pVRevC#=KgY0LaVxa5E#E@v||h$^Zi?S
zGRr3uwH_D=BFLWGs9#!mL2#W+T6~RY+xj%S#Wragnea}<o^1tT@$t<~#xYc>1=-GJ
zj!=xt2Dsrk@(Rrc!e>=&DMDBXsXuXQZ%@{FUOU&wVSX|WX9EZ#?BO$!K~)K)dVWtY
zZ~10mx)$g&+}m)AZ@;)|{{_$(+gV#`YPX=uN~R5rb&P_Q@re{i|1*N5zCw6w1>1hL
zRk(LiBxokYHqw03d=RN;mqsKv7W(7CZDg{avlfNQJ^<`4VuGg-j${DwXJdmUAJ>QV
z<PPYzz)y5@s1(l*21}8C5_P8(3IZI${P!q+IU~zCneHpxuB&IOPo_5!iURDg5u6L<
zg(#{UubzY|_Ps;jE~M90rU418#5~E5J-Cpr7Q6sqUej?J-~asO%BMy8_HJk#GAh~4
z5?y?ah$@3u%Ny@Bcv&cHEjA%kYNqT_#}2p?^K;B_2@L_@)ZAIl4pUlVCytty?Gi|Z
zNi$|6(6?qCXia+;d$I58WT=ylfJxYb7${s;HMI?w1Y40_-W+GhB=E__b8zML4U1+A
zD4;wTqne;+J?lupE+%Te9_28_bLvO~YthyL%@qiBG*nh(*v`qFyd6Uj6@E84fEiCF
zdkUr+c8K)Nt0CiJEU(*Bu1nOR_R0tm#-e6LlZ9~9Bm{=KSt~u=Odq__xGMIkcF9>?
z3r7rHY?u@#gyDhI#r8EYAY5H^2Gx_gs72Mc)y3a{S{mF&0H0+$v(}>N7mnI|$<G-Z
zllCWg3m!^6%gjmkTJ=G<YE7O9Ko2&6orbIgOq4W}UxWbtu!-9FH8L=_xXDF+a)S-b
z=K=@g-_!^YRDLQiKM3XRsS5p)UHsjN6+^ayfi!CdyP-!&MzTxqINmp3^V!#IT}VdL
z2x#ABXQ=@=JC{$F1CX$|WKiadJSE);%O(+0h%i{KXF;JEON3ZhT2~_^t$P`mWZ8UF
z$2lU9sV_q_g0e%<!M^Ak-BbweD}h65z#+8<m!yF1u8^^E3A@icMYlNGr#z)twpk(O
z4)Cs(t1OzjD2{amxe^XxiZnk&4xzwr1EEYnjtylC*s}we)Q_7e*b048xG*^wYfbaE
z_y~RQaR1j<f!@I~_6pY9%TGw3)9vc1U~Q)xCj$}CS3DHplLr!fgiArt`cJp(=ZOED
zsop%@&et17F=^sy0B1geHP{zseSJN1Khv&jNNxIr#hkE?S{DqV{l);Xol#O<Aqs@5
z8!a_pg+HgOTr*Kgo@wO{On0Q6CLo!E!4}`o>|4q?GwU1;0DT%M*tymd!@aKrR^@t7
zqmKnbQbvQU*WuxEv=rjImKt*qV$Y)a7QdB~uhjQ*-&&;JKRf0OHIg5({JjqDofxTA
zO<qff@;EMX6bvG8G&_Un2uv(8h!V#l{T&9;0<b*7M9~`h_;LuMH!-1&l?Hh7T>mP$
zY-g+#VbAvq2W2c5R>I9ZZ_(#IKC{3MX_Q*7CcxnkT{2$chh;1jvg&~pmrV-j16E{p
z|Il#`2*XM%sKzPI3w14;DDZlk-(8@JBl8Un;jypWcEhKn$Jy;&J9!O`b3?L!+PGSP
zPjj>tWGV>Ze+I)sd4JeA*a2Z5XQ4n~r6^%^Q_>%l%Tg5&;MQO_pZ4x9ym+c(&7Sp+
z7rw{Ck_J*2VIm%`H;`V{sxeOMP>z|LWF8CcR`W|ku*!JJS169qGv|g<17}8P$iZ83
zLur}^dyI`!*h46D^yak?-oGm&kd<!F@D2FwAId{448L|~3+8T`aW44&Umkk4>*l16
zagTHksz_`HQ+Wtr>+aA1NE;n$S8YmtxypD{dAKVhG%g02WW!f11kw_F(=pW47o_02
z;We4RmO*d6-bnK8atu}<x!_-L<_Cig;S+j%x?GD?{@uY=TV?-Cq;|)pKynS9mtxIZ
zPkC6&m=T7h*xebv4d+k-#RL#>sL2P(jgV<pZ)C@ngr`KZIBlY*u(8zJYuG~@!VZ>l
zZYF@$slLvr!>*er`2-!T4pOMV*=CNj19HJ_P-i{MCh21L;6ikmw{|G&Xjf}Wvoxc%
zMlx#TlufFa?S_2r_29eLfFk86!q_peXpS*A{#uMzzW&T1Pq%jbTs0ILjq`mVglq`w
zXU*G1c^z@aoSawQobbHf4$pW029gAp_f1AEVRkhH*d|D|eLp131f$BEGjwNy<csYj
zU5oVWOae3{HJEr7B4|rLfQIxSL27L10)s%icx)I5v<-f&E1bgRYG@kmD>Nn@xakMp
z4x+=U*EkBz2aU!N)7N=0Bu?FUtYcYCrKbKRvq|;6o}T{*!4Kxc@avarU`?->t!2BL
zN?~qYM-YOVxDiIuSm@paFZOR!sirU<qvhO8s@;J>_#hG~jkYnum<mWM=&9zyxTzW$
z78MLDbM6YVPLEpOrpj+9MDdwo88~?`&i92zF`=2{9ep32rAn<)%pNhcH6ZtH2xdQ@
z9gCjm*v@8BjPhSPjrm41sg5Q;igb5PtE>tOMd7VyWBk4dk6BSjxSj<;R0*<BHlA|t
zLZUpTgN}`ws7OfdtVF4?(v_apCQ1#J4I=P#o}Rv<wCc_Aluu8s=xI1TO>8b@tC!Ii
zjzfT0o$RYxNd3d~^|(1vW2lyV6p!#vUK;V?B!3bFOe$InDW!@_t+a*I5t}&Ll<HaC
zmeMex2uoK>T1w6R`ashu8^$AAaXv~v@>DN^u!a!4)=~<Hj&nl7PK)Lh2pF7kHSOQ`
zQj~v~UeFRMrz$TJ>%j<>?wIRR9NJ2XRtQlw^{iu()D^^b_>5jYF=0=V6sYPA`EENX
zA<vfcEJ>;(D50|jw3a%#ABOxXi>07L%_7)7Gg?bQ?#mpJHkzmPL)zxnuvUJ1u489f
zODUnwK^zy82Xb5}@y~u|iPv2nYn&|A89TW)AH|ykDn{`Y&01qpuAFhBGUGN)_xxdD
z@iY|@Q6!%iaeIOyK=(NOqff+JPxM+@j!8(2@fyBu(NsfE4kb%I!eY#-tI1NF?^ymJ
zIso9)yEx_q_6mxvgYP&*D@6)Z@X$dk)eijzBu^8+v$+L|l_!9WVtPR)@!zH>mammU
z>P<#5;)wx(k39rD(^AFFBn!||tz;B@z!WldQn=6zB)eEAC3G#uV3HuOzKE(n)IcAQ
z33lGy2k<w5U||aY-(WQmb~As#6ZXsUogJzLbS@d@yF&;ZT%qU&=}ez7m0o(9^a6HE
zUdbLx-Ah|=QdKFX0PrUtorE*=PnGhZ>?&OBR&9CrP4v<Sekw0$PX@`ycLB9%5d3SE
zlS%GMW<;N6ZHjI|oT+n3%pin?u3-lkvS<dv1|opQgueI&Uz&tLZN79ymKc$HAMkcw
z$2!n09V<6T$=-SN9V0xQ_TRx-v2CQft}7g5p4bJ2*xA62zLDEx`UvU^!ifPa%y*b0
z_};csS}iyZ4rI|R{zJzUKH5+gU%O*)Z~`cTXs246#lym?XBdZLQ|Fxn<fO+*E`RBm
zdy3RfE!IQBjdMcyf|36N9UGn^HS}NRtarfls_Br0eYtQt5<x(*nT}dJQ>1!A1|EJ%
zk^F^tJUma48VO@w=vZu9sat3gm^UA_*<o<Nu`)Wl<A%A}eCll|^1u;t+6@w>I>4Hl
zKPpJw9bKgoo9B^Qq{UX)9qn-RWNqje?WE@8HYkvt%dg&m!UY7+iZ?r94wgg3s7*{5
zX$1yc+gdUunyX@A(4r>*AiM>rTCPEeE_f~#%cWTU8|F(u08#GWIn<;pBz-D`cgP<Z
zzK*}>Sj|*?`WCh9jZdf0LJdAWzzXw!eA<Mn^y#KmKTV90KHY$S+ONu|)tA~e6<Px;
zX_wlCdHMhVl`PJtMs9E?ys4iIGYErwAh_$vFs<h?48Jw5jF0F*C{J6S3>y@wyax*9
zVT_P7)#-E-bb8%ff|CzPSJ~M@3*fEjZiQ#UklVv+4H?Mc-3A#|z!TvtCwSR&2;L}H
zdw3x}!~KP>WjdDRGrYF{-s_;gyn9oVK|yLFIv84*C;`a-rh^n6GY$FqX5cp-R>}ZU
z@OJuh-Z-usNPH^qQ!Q`+j2s(VbE$7~V^k=w%V_{nB<8VL;w|^WLIT`=wnT)Hpb+70
z?rdt`NaR(FZDyU}8ljh2$7ZBUQNq{1>R6lb;o<cPekBc0-cn&c_EO$Yaeo$7zYM2D
zMfC?6>qq$wy~4p;G(&#TfzM2l57oW*NXI5+NEz8*{HAj#n*{2_M5E(%7Qh58dmrxr
zk29cX(E*3!!cw>fI2F}LKuravrg(FzJ!H+|FX_l4Hu=r_)Sk~U<o3+MdY6HYqNJcb
zM6%Zz>-+iDy=-k`9s7@b@leOU>WDUu0|T>fV+u*NceQa1;8e7+9u(TjHqNtV@iw}W
zu8THKnMrLN2r{bLMjpt8^IOvknnC4cb2~}xJlBEkrR5$2_mo2-{)Ut2gtlK;wljnj
zKH7>yo&|fTydhx2k$;Id<|=<_3C*Islm?xq`Gsn{3d{<;q@oIq|Kb_cm`Q+U(U9P)
zY!dlkY5Pf5f7=?B?ANH4TF}v%&FU;gRgECr*;$(6r3F~>Yta!|oKyNh>3&h%JtEr#
zK~~XVKkzqegF9ZdYw(r(_6?paSCJe1CwLe&IAS_ASdG5GWrp9%2E*lIw+ffV_o(!g
z$9&#h_G=eurVs?Xu1{C#GvSY}+Twq@N?jDfmKVC>j@_kx3gO5fy5em;q^E*VfMT2b
zNRNe;P%l62D+OdU%YZIH_-%?wUKY;fs%A72u|JYhJmr+d?Wq_))Y%u!qnwvCqm7!@
zJO>p06oSC9pA;U}#e*wCf2N^|(P;<%r5ZotSMwc^^}_$o>R5+<QrC`G)x6{cxn!5O
zOD;SMv_+=o|5#oNKM>>L_!`|%CL4KZ&qw^xqH)F7%lk>Kgq8p5Sag5Lqf9&u>JO7P
z1rP7{mr{gR|LE9?{!+c_<ukC=8ZQs}ORa@vcxX64iV-sLFld0}?J|Z2LJtd+l-B{0
zm!SPg$JhX=kxxss2Mj9_49jjrU~LbO>b?;tsvanLRi&f&jR~WKt6)Fe<&*8$O6y^k
zC(gxD^u>}FI;_)=EsU>$WZ7}U{phtKti`6G7??Nt8R^d78h5G|JBD|fhTfIMN(Mng
zJ$6x7=}-6F46-D0+dq=NX?l)c${-&kbZSN*t(!bDGo>~$rGMH!0fC-ISAoF>ib*Tz
zMe`QN+aVj1&a40|b~aNA@E$=x&pZRrDsKJ3QX66MzYel*$r-f{gn)YZ+6f2r6l%--
z!BU#A1rI+Cmiz=G9{w5(Z&MZ?JcdZVBRc$nyE2V))n<RI6LtPmx;*oE<(fMO6^3He
zCMC(~Ad9BITne&hg86|GB%52FL-`-^RYZ$9J&T&$6s0Vhc>FT$h~yaI+uJ%86ePt8
zOYm@S2o?kuyu?Kp<o|O*%ETvIHNw5$b?nrR1V5K^zso2M9ln%>hJ5ZRe2pBw0C0V%
z)GmG)ec%H)P_RW3zm=G=^YQMJTaBsp189_dyc3V=Dt)}&k76Fc#~X|KGS{o{@kVj*
zp2)B{EXjYg>4X(bO&N@T(|bqcMqU_7%{d6MQrQqr0B`wt+f|3{$9=qepin^X;y&JF
z!`!A3Btfe9c!SQNVO4y*+r9^OhQr5us1&FqAMesvIyNf{KHjufs4n|>pF!XJq|Mx*
z?3?J||M2mCPD}tk-mk#)(fO*M=>g23X=?LF{3u2Ec()?LgnYcYC~ncrkt=Z@Zx;{_
zk^aoVgo2^Sv7wCnc)c8-T8H?j8#>v=`z;=pwb&BqeM3fGd8WP5PC@yt>ZvHt>f-(D
z9Ofo>@is$E^_5or9IspFd(M?szTVJHY%bnD@JW-4_tt$K+kT~0*AT9^Sj;O2QRA{9
zFWwj*IeY}Vik-Lg@k^cTEnS23cX&&8y`**{d}JUWbPVI0K-HtA`oaNF3;f2dt3AC2
zRLjm{?_cmt*osEo%38R+5AM|g1n%>@_TY*`#z<!r^%g-b0*4$~;kYBkPSda@iI2be
zQLH!?^0JP3je`o74W_LfCw2F@2}On48Q+fp`y;t%oK)ABzx@pZqVoGPuaaH25N5LL
z7Sonm+OjXz4o7(_ljN@3KXu%7n+}b|s>{FIbqlV<UAJJi#8s*;?mmY0K@BwY;jUX&
zI9`hM>E4inQ?s#*N}D)o-=<p^B(Zr}J%WqxkC&!7Dr5c$a$qATNrRQgUgGJ@Bq>_?
zF+Ke|N$M(q{Mh=wU)1rAdkfIVNRk1Glcg+2UbOQ+qnjv8yCEZWnl#LPB%UUJ%$1(+
ze$%mk{u$j;*(@46*P8!3dWs_3f{{2#Y}RV<F{q|6l2mz{kcN4riga2NNg5D^`SCS7
zZzwjHD7fGLPe&fgg*EFRso#@RQ;!=u!wSTNk_hYsFi&etj8+CaB@-aijYF~0amO5X
z2-BeO)o5Q~!jC$(_34&Io^>I1<mecxi^F*#l$O349Vob>#F&|qze^{(;D*AP(g_bQ
z5Cv~L@8b5GI#%|}mraET^nc^~Qkn<ppw`WU81?|<|M$MsKO2t4nzo$~#w6hj@)K%q
zM3EN44fQqW(Gs))QUb>K#h<M0;!52KywN!&$9eZbQ@qT{Q}W>ZXV}k#D%)Npj?-tU
z1%ud~SECyUtz)#sey>OW>8KiBk4Rqz^zs;NZpE19*<T<LekI5aSUtV@%lq<6-AJon
zeh41mD?n=5aR3L1vM;I8M$LMZ=k1z)jOuG7{!W)(qP(1RAp%7ZC5n?*<b*J58J?D$
zEhnC+C{>>)I2}Z(^7g3(fe00FnoloD*u{hA`}9mFUb=BO_|Sjf^Kb7W5Oh)klFBFv
z#pUV+yd-=F$fK*NVfmdv0d7aKgd8~GQfankVPaVokjxw@%yCbC@xmObTp@I;t1X@~
zUvgDsr-K)A4B}YnA1#{UhdC6ZW@#P5ELIY_Aq8#wIh11>3!L)%HM}FF(x@rt8E4B&
z$SVQzy!xkX!ai<8E%+5<ZqHxrk9>nkmBuW&(tO`?Oav=2!Zo=7)Xe8nKUTwOOfzNw
zKuo)z^Q1-!;k`pTHoB%hf;Ctu<tQ^0h>~qweN1@lFnBh=0zqcjiD%KIYzMn>rfn8u
zPEdcW6nP(RPcY-W>SGY@T|)i7V_u`PCp+k*+C@@mSYy$u3S3Cfk3~4}`6;vE=m4dr
zT2Cqc07~nEMN*=$e65a^EP^9&?Lqi#7D>^uzB^<xKSn$`|GL?Hkqp-7=ABwX$fuCE
zl?Y++izV-B#)KxD4q90HVu{YwaK<yX&v<AY+1$m_`@-x4I`;2kcu#xbAtYal^Q?D(
zkC}OTGC>>+<Y9+Uz7(t2$Bg+>(~y0jWWJ9ix8xNLgiuVsnp&_=f~^7n?b;3a((n1w
zC?WDY9qY72O4nT3FN2F}P2fDwp!r~(JC{f;6?@p-B~lm~IC?#*c^60{g=hO97z(6x
zPjR1I?RhJzb_>YCzT?lv`PPE|V!t-|6uhJ6QYlVILe0)GbG=x{rBa;`rL}r@UcEJ{
zSE7YGstT84#5b`cC@d`Bt7GP+P`9)2;9-<PoWW-^^8YTs!%i-h0)!AGcS+w=8#hMD
zjq2Qz8r9;YJygbzdHB|*bb}Fr_t7$f*Lm43vA@L|v~aUP@~s8c!M;1YpmVfehVH!D
zW9`neW$4b)J@SXW00X<_Kz46*r*xSVD5y8<*x$>bcn?P9c^{68tku+7Z((zMTb8Vy
zm!snw<&K{%wszcvhjYu(@eNfvo{41Mac!~u{lY~0{`<%6zyH>$2HZkl<!`glZI{FK
z|IHOsJud2M5GW<w{Syqi^>VnLw|Gw7Um#rh<#7AFF#YLrxRZFWyBsce15_xw94`B-
zuQ8{wBxEy0FtOJmiL8Uao7m%-cl!Sk_T2$d9?##v19k+2qlzK|c0~m{-gAm_C<^v&
zuy=zBn%E$AL==<g8WWA0_B@XoH5Tk*>>6W9G-@<zjPVc)YV76S&+I-2cO>86>mT^s
z?(FXD?Ck8!?CfrS#|--i;c~=#$4)M3?zH9UnpVLY{@Hq{oZ)RD(hx7W&c1(O*P_!G
zZGjKoG(PT80)Qobs&w+M!LiMU<s3tBh6X>t<NB%cRjn<Rbn&)gGjPl{?Bc&c$p!eW
z2X|OL{TeH8Yv05w(v>Z`)t6yy>E*FSklwYi?qXdte&A>qKyXvEs#kB>3zd+9)1(m%
zPRK#fDCN!jk!6u=XNoqOr-NN=XyXNn2Z8Ig0(ZTZvW9QNTz9aILzrT$V<@WUKMl!e
z5J*J!_NbOEWJ*wZd{_;YAORuoHZ!G#v~Uv)F$O7i{IIU2n~{P*3?C+sk1H+J#;;B*
zl&am!pe_<-y(4+dXgt6EA7*PvJXRstt*G}l313e#q_U<Zo3kd3w7e!SDVd0mCCDI@
z4n%3ZG<1L@jSRCqtM^=~!S^N+tLcRgiuMeBw$Yx0xSnzgNkquT4TPrnuYmHL!Af11
zjV88#Fv897fAC6Jmpy*eJ9S}$Ze8xf2e&TQZV>%>R8O}qXCsGOmlZ!(;)3cCo`WGD
zVd~;<@sy^8!Y9S20(i3MoEgiYP}39ZVRC$~bdY|6vHALQrD>IqPlz@?u1mE|hum|h
zC#6)EV5u}p<&^5;?|)B2rz36C2A%F_4Znmmc6PWL=#r;*<P%M|p+3Y%=L69}e*FML
zq+MUfer|CiD#Ei0W$IRx_63-jTT#zd6T7i5y05enADmYy*>9W*cF{v+c0Ct%)Y@Gp
z_TbkIT_cf4^zTudx?+SZE$)h#$DhM9P@IMcf8uk+fzK<=!*8nPVl5k=v*gVKqa~vv
zI^$lA13b4(005S@FO>n+@nto<f{-h&9IBJ@Gj2kv32I>wpzRNdsTHU1pq329x0^K_
zQQ@ULD%oV9_#J^zO>t>XZqgcMgR}HPGv!*>D!W`_@40dbkpM*;Oz)Y1OTBAa4H1xc
z1=S%iZu4viIUl6p_x&PptHBvb{DMB#<;5ufQuVBcZy<L9zfn5-SEp_z{$SrNu?Q5F
zYO`GGxy-}@zEwUfT^k|>Gm0&3u+fig{#J2I52b<-GMK_59{t)ekire5u!bL+ZC@W<
zhQni4GvU{V#15B8V)KAi6=jf;wm1;%K>@2&-n7#de|fxWCFlY$>l}|KBdgFOVTT7g
z`N>(77a_Ku=kRG4VJia%n{&V9smE>m?C~QRG-mBY>Bf@(aR4(iE~d82bQ8Nbc5Q?7
z>r0?al{|n+am>7vuYpw9QChxWjqHN2g60IAtx%ZE*;!;qU`y{G-0X`L!0IH63sE`9
zxzDMq(^8yLL(SP8lL7YU5vs@S1;BWu20vAs4jYX_?pc7!1n>s{-Y0<XIRIm_i&|?s
zrB(ybYn-=4jdzNG$`C@Cm+@8v!F_aSg+OqMsO&o6ct`jV9AF918VG{|EJt}H$#skl
z`AbW(H_Pyq{Q|5;RR5m`v2G-<`8wT`BLYf^3nxt3;AJ}VjBECJwfvrDYk2&(V7~0h
zxEsTLd|4s}B>e$slTLI?#o^BcZyzqGj6G7m0Ax<L?QDQWeU<^+ti}ybY<4a*d2Ftj
zhM1B&mhr)htO>#5#l3=W&};$Dqd*iFPi{De*DD6!9fycR_lD)6x!nk8M$aEvK4$CJ
zE4#xc5%K1P9Y-pN%chepIvvjp!XHlHc&u}ZiDhn3R!FDb7+KgxrGcy4k5FKGZB(MY
zbNDQn6DCOR_C1D%eYsJ&DxI5bVl%(TF&1enpByJ27-`V9J_Ie%^U}JTJqw*I2#0}b
z<QTe7d&R--y>kQ`3NTn@*@o)Rjljr_p;R@j()7Ast=&XKkc>xDjb4G##45czU=g+e
z51AwMURy@r69&~fWWdP@(O66+T81_$3I2sIXryB)jsaqcY;kO&9{L9R5u21bcuvj8
zHZ>d;#M*C$>RFD7r6&F1@)Ao8HqMYlhcG`noCDN~+)T86xO5*UhlZ9wjskRt$YDFE
zJ87y;j>DTdSk^rbmU`a?CN?J$0LCRDc6*rX7Nw?-87)$`{R@PZl;Z~_Mcx9VFm#^D
z3AY^7nEl$>W9|)*3RE1uALDmri(-^c%{8&gKPdFnN4H<xS^pp4A3r&nSYU5h2nPn2
z;%)K?CYJq!@>&}D%*Yb9E1_)TR;4@&T|w~OzO71hf7}p#+MN^6-<&;%a}H551gnd2
zdl{Yqf<{kB3ven3riiJEdX$vgn&NWNmyk_OuL0Tk1i{V3?_)LFhNi#zhc_MX@)0&V
zwktJbX1oCvb{x;{Vx9fU#bfqTDw7q{i>DUCYl2m74qQn$xY`tBM7lXUE)s%z&2Du6
z&2~fxY(bs752{h=8s=C22tdv~;W6huDuM8=*QBs05PGO)ZdYuO=C>0$zU%quT>G1k
z&e1!Lqq90yAH;_m2iqaQzAOPY1z_N5+IV(lmv<;0rKZn7L4-2lHaqtTIbv}?=tXO{
zXRh*x)PA0cJ<3&Zvxi$Yb|TB|RKi^+Y)4lb?^L#V&s_;8(Pq#<_jv`cgS%~~QZ>Et
zSgMKE+U%I7Pk=ENFpQDg5ClPs>)o9_=Ff0Jq{t38kCzT4eGjQ1Y5ogJ1xb^(36ds?
z^m9lTB&9PPnTy1zXS+N1rKz?^h?G*<?gc3UPHgoq#P3vmWMn6H;au#yr6yK(w^BQ1
z6tBBz5Wgax%Zh1hYjH4a9U8=4Vi4;Twdg)>CwiW;8#7TZG%~gul}4h{-*zj(Qt#1-
z_t>rcA_Y!D;L{$ZM%fk5Xe>jaf4$wKY^#y&rXC}1of9TzM0CCJLhOM@KMlJCB%qd!
zFtJN}6~${TCLvvqmN(qvsN3qB=*!Z5%E4AAKfq`KKBnzge3;8!=iKlF|Jh`xF6545
z1W0<t9C$)lEZqTz{eESvR2Fme?SA;S;}@7%{R2vkIwMxlG=`km8`ca;zNN-hA++8D
zC|*rOE{xkb7-T4)83!PeqlTGSP@b~Lc>z=Ml;HN+Zl@{y7g0#$MO}??vKl`57@Sd+
zI0OB{?>gWVp1mJUkdxKZ?J2|!Jggr0{2iaH{6Xx*-n(OD(vM1?fWpCqcDbdF47P5C
ziKYDr2HT13gv_Wg@YlY4!Cz&-U-^i(D&nuDXd3*r@u35MO%bC#pQqB4g@R3^Jw&9x
zk95vonK#Xu31KvK7vZ{d`i6vdKRg0smYKl34`DA(0kRDaDN*g$E&w)gA(CcUCjSz8
zjCLzHwhP^zxa{u-I$sCt?M4YM`}u*1sfU#6u2+U*u+JWXL3jUeQGM{=^C2iUBff+L
zg+g&A*)eTU53c&&Y+@}BW5ruE8X#wcq-e2<^M><f&Kq~}AMwUn^iSuF1H-{Z`itW<
zd*Qd6sB_ES`&8{@SfwO?LTIn>Gp;b~r@^!uzE~)j1tHIT)53D<96%ZdV)Ftc&e;g-
zxaC_o&I&5y$ot0-ABPq13MsQF_qrud0{?j)QDVHSF2>M?pi*6S<SsMiCLdAaouwfV
z{2Pucf4I8b11T0CQ|d;yfuIGSeBK^9eyutD=`H-6uKz4VEno!qKLsN|Q+6BvEtG<X
z$CP<BN;{UZv=deEGD59(bA5nzzBsO|lzjWcPj`HnFH1b3c%=UvOSe$CSG~ar+3YVt
z$Veh2A&yss27!<RF&ZB#oaEcZbd2DT#R|u20&5Det^#ba0JGi_GTf$@Od&9RSg8JB
zyv{w2k4xqu`+Z?}c4y3hpgo~<Pk)z%IXVj3U(p;Th5Dm=TsK0<Y_?k%!YGQS1gX(r
z%}9&Glvs#Vux2@)iYejs6%BvtOr$-#qfZCe81PurpKL?sMp|64NSi~l4gHg8Ms$bj
zBBo1%_=2=|zkA)t?w?fZcgoK|&&q&%=avQW@Vp`B%Ypi6RhJHzm!K6A9<In1(jg3_
zf^?{YVJ<H|>6(SY?;t2fp28giK7Sb5`|qpa%YRZTM&>Nz<nMKk50rdf(6x-t?*8xT
z%>Dk~#N0Pws<!?~39RV~I|m%QpAgxNh9OX3aFm)RIJM`SESpy^<0l1k-|Y%w#6Zcd
zE<iQyD#+-J`ihi+Nz*{C>$fQdB>Z^|C*cmHokE(f1ibyWiqrDb2oBtR&B(Ug(&{$d
zGZV31m!PxD{SMLWj>C!%M(K|-IEnV1n1&-s4XB4dMT5*TPAl!D<<Lq_oL0iS&zuWS
z7x%*RKiv6W2}}V*Q@7&CYe6Z~K8R&>5N_=UJTkmaFR~1#V3;UmtllWlJ$nkI-QF-6
zq_BK3g0=Zs$?n`~9!a(hVaJikz4Xs4cW2>+FpnMciI*_Q->IPe5TB3C&L{Ef8vV+0
zJ(!R=mehIoYgaH9U<};Q^l4ZItM<bO-YoKr;t}x6*ED3JHM%A#g`c>z9Bs{dpHZe8
zFa1qiH76{CH(~=z4NF0=J?2D0*4JTXpkzjzOA`H$nk*beT!Xe@5rj_S00Vo!<ET<(
zvw-1XPBb~Iye}F1nV51`nHKPBUCH+GE})a;&sMC}Ipw2@WA*H_s1!!asdGwC>GOpq
z7It2#CN)Si<(khUklO#%+LE=9vTXT;E&N59TmP{T#Pu(5w)~O{V$2$yE&VV880wtk
zWL+#=jNrgumG0qnz?9^GgZdn+Z?<7?1id;rkybo7;Qq<NJC(mGk#(NX+&>4w>KOP$
znnZjixM*)!O?)DjWf~ms7nE+2|1U;1;)1eKx`YqEi%Rm)3!SOb7cd&ARFToZgATVa
z>YMvX%qCb3<@HHrvl>3>jwww>)L#oZ*!rU!?9*dn?s@2)9NXQ*e!r;5;eAp#`n0Pu
z`GD}*uYN=wSOD2jq+iItDb*95iT2>3EZ0)l0;w<sT8z6J(mZz5g$TM)%oc9OR<ttD
z30uIqB>F`+p-@3af!UCTO|b+7_x+|UlfF4;WF0Ok1HBJVh3sjDOnu$yKg-1STta}<
zu!~0a>XH(a&@=(YRZTz?$KfQ5$5`PCK29Y5Vl8?;XaVne&BMIsUPq|sqFuf7e|Isl
zL6;FH_1yr(R$hkM7&6nus;z46+wuUIn7=9ZZa=z!)wH-lTp~}ISS%kuAOc;5hVEcC
z7G72|rRp#Rr(aQeq)+QWz;`U&ek5940+#*)OS1gD#TX|3%u(F=D^12fb?jOsQ9-`(
z=f}%lw`{sk4SqJ=ZaHz>%|*@T%nP`tg3e83^@UVqNxv%|jogm}U<J~zqe`o_o3sir
zE3TmghsJ}Pl%SInj<&zYAPVPqCD66Yajd+Xepgnyb~}l$PFI!Csxyw+*EK33bAx^x
z5DI=a6>98NaPZA!2=Qxh5FduJ@cA{Rc{Pg$_Yy9GYDPXj8P{7sUtPtiV`gl0X?*{M
zZ}#+>@`tZ_f@r|aZCKh6X;#Djj@Uu}L&@_yGznsqZ#e2=6w5&`OrE^!N<`w!&jeSR
zvRq3SvE@fd^w?1u3^#`(Ni{==x;1Y=gTY&gPU}cqDJCP?myx(ZuC0kh-%!?<t)OEQ
z$xPd0tFdx7mBZ3ZWS+Z;c)^}+NkpeXM2o_f9z94(r*SDw`itdoHx~G(qNe{olXK#_
z-F%p{_BhVLA!ba~N#KUQSsZMVn5x@2!xsAiS`k<Rz_LYc-9>FNC2BJe7)|`)0<7L{
zqaO(f-x6>S;t+Xx3ma!~sbGHkxG@Aq^ex34eGPQx9w%CjESq*?bvuggz$4|5v79o*
zRT=AHQ~CUbpu|wr(c>?rliPV10Q_K*cbM=?Rro6lFHhqTQWlm1UfVi=kjLurElA8i
z{!;vc(vgBgQIMo~&lG=)rxncI+e)CHWie4m_yYKXM5m+PhB4D^C9&FHV@ys9V#DA)
zjh<x>M+*nREn-`4BUJBIR~US^mC1fD?SVvqd%k5`b++(trFF%?CB-dSda;X0lP<L~
zF~2*?7-{s6MmG13(neYad+_8PCCG0++BWT_HN2QLgFuuw$c%`NDP|NWOi@czqK#3e
z(^MFX6@G0e7GqJeTswdV*iRNE#?^<u-1C)Yt~D0nD?VT8hZvCug(R5ZoO~g9%wLJh
zpy$-aE=ZA{<1u?WNr9{wSDp%8=XWewWI>G;>GzJK2JZA&#NXE?tDLZc6#r}t1)wYn
zD<gicFwr8vh-)0?Y(TN<ca<vACwWE|dsm4nwFnAv{#j;hJ<7l)fAeW2rW7bi?CD*_
zzgFT<WHkXj%uqBUJ?4x;jWAY6Le$_3=;7T?sCw|@G$~MOg=M?794%sB%ox2GS<Fb8
zqtQJ~#*xQni1cbb$~$*?f#U95R&7R9fPg?`=7+weJgtUJeNF86JtZQ&saWqC?B#RK
zd`QeSS-<0}S!>LW7ML9eju4YMFAy5sw=mlB!(mN9d%m_4CFv06-rhtg!)e>^4fqX{
zU6|s094jd>qj0*U?`S}h=h2$#)mhgH@SGCrc-aRo&-==pDiiw<2p$l+LLz*_D0}9H
zt1+bEuxd4eKu;3g)>PaybOE73!-%PfUV>;8CcbH`iH&@qRF#f2!O_?U2sU`R+sK|h
zP+EqKo5;mS)c3sS!J9<SZPv@vmV`ZbB>9#@PiU8@?`7!FMFFoY<Dt^YuK|r2my)qz
zBXt?+wy-|Sc)7}ly?Cg2_dMN_h9@Bm0o51b#ej1B!69563g2cXtj_G{`t!MWzjhu;
z@|(LoXuRo)j&n^-{Hl)(B%l=EIq~3|9eZYg!3Py8{x!2eY;&d$RrA+8Ud^Ke)E(ME
zDQ~N29(F9&7Al6(or|Fl2<UA^&|Ws^cr2IXbjNxdtpSSPEChro%^LoBbL3`6PofNR
zf){1XLWUh}LLMm*;gfmo;(e3Byus+UNJ9CS)43_y28nFUBPAfc8Li%W#5M9OQ2pg}
zl)|47`(o2#y1uVO<O%-+i6Trv>^gnXHc)J$VAqMVipB}MQn<^{=#&}(qH~I;0Td$s
zul<7J*kno<Bro5DNRFnGY?bk*QXT5UHkacz);?Yj-^Lm@m-EyF{8u~(bnl8jrayk9
z6So*WY!{ldDmq5~vz*6DRUbnuZgf?{`H7m`miu+Mi5+^3nD<Q?CidbnB76pSgs60g
z$94M9gm9GMk*3V?%?ef(6^%#H&QFy3Q5UkXk|W03{+@=fKPWCklddj+tOj4mBtc-d
z`H6xHcHEBrjlJF{N)u^3M0M*`v;0`dKZ>V!D;T5)lF&t61tm1w{-gAlHb$D*x_^{e
zp*15(qVxOM5g27@-WBrvqoX7fc)x0mGqLth5kvfU0}~tdR59W*pTP)q-1t<f8f2Lw
z#IYO1O+5K&gai7J1q#-kr%*zh?=iALd(!F~j`x5NT>+<2{On^O7`o6N%WIcs%0#I-
zwo;BhQw9u}5C@nZsEVvpRrsDR+#uO@9eOD_iKZeme+hEnjxs{})q(VjoJGTGaD@u7
zzb-n8AUJYR>&^}8Izmc}CYJFW*OokOk1Pan8=%u^&y~*7;rFop{u~EeBZ&*{SRR(8
z|F2uVJ4<9<3hLn%X8bMYi5$ic5uEC*?}jh&Pn5m5ZDX|@Jwv5755z`1zt089c99#E
ze08wl0Mkbgk?wU}I_ZJ#8a__Hgr@n;U?*|&O?W4)G9l=LuF#_PN&w<F-&}>g!Ee6F
zgAq}D^UXI%F24C@0`ka|J9rw33BUQq_!>9g;1}H8{i$~y_}^Ik<xv)S9~ncXzGi5;
zbn{J+Y<F(K@Denq%1-=5#kcmOB8cO8g8;W}P{DBiJ&^S{Xbh~H20(HMnDI~<!djoD
z;zb0yiiWNv7z9Y%FW|$zSB<6E-F8_%k|%hPZX0Uel}E57U;wO!2MsV(xXJryU+^b|
ziAYpqB!>`}()>jWU{&0hkM%O>E$&u4MQF_ceDP=zf=O?c9(DZmYB07H1aDh>IQ%=T
zX7=zh!e)mJ4RL9YSeK%UYxdT+qeGRI^#vVfoumfGI#hrKaLp;BZ`sMvsHx{wSYDS_
zfztYcCicZUC7?Vn;zC6bb@5J-Jx@>_xxI;&85n59C!93~x(v`mII3eL_)RBe@xenl
z3NTA(5L%*OG2RHF=$u%?gYxtUjutIY7mwhW4~pk?PVDD`|9JpMWMZPfFJ?l?_>G3W
zOl)9cV%NIJqc!#RF~aRkPe%g9>Q{%-8HZ^x`Wc5xFtczSPGGgC&>slBxxDQA|1Qf?
zZX2t39R>3^>_)T1sRR97+Sn6)KXlZhOQ`(6fW)PWe>zG??SMSdr;w+MIz-CEmdIom
zwNu%1&<(Iyh4f>ON>2<5*odE0>e>-1bqt;a+u3<ZjgT&ay*V#FT#Va^Vq2QnY!|s&
zqYuDXG<JdJEPlqA^Bhif?|Fgo!I2w`9=74h_T`*<vjxJ#+D!J5rj9hReUcg?UGIjI
z2a@bpb5#qlXd|m(UpE^Q^SWB{av@M5=@{!8Kv#8DBdZ-I97h7w=A>|-5a`Zsm}7hc
zmv5l8@jo~0*SM+;J&L(P1c}^mRl9jNhwM4v3H<ei;9L*LbvN~#bbpzV1(s5)_PT|I
zK<I>!gBJlwa&YF49H%bDIOzxXz75brU?})3tC=<Y*8v10W5L7)pJ#Z13{(Ohe3bB>
zG#8ZSCyj^7ARa2-b}&nvG%j2;u(1nr!?OprbAg=xqO=<2nMbYONu(M@C3IbPc}Nvo
z7!^A+EzwZHE&=nV-^8X=(dB*<!z-Z`8umC|QA1RegZpCD0p16w;*+37F_9P#qPf@*
zQ2?deOz@b6HHIF7fG{SxBZ6r{%CvE9zG6QWo`v)h=l{q(8J~G3KJzU!ml_jjJ;Kp_
z(kn;eIn@vd^>S*g%kM*T5B1Z&a3&nLR8Tv+{yDyiQ|{IQ+5qQ}Z%9vvbB0I9-+^*j
zjGh?7jEZWYZ`?RhbqHB7$I&R_*DHhfDynAZRQ9r>8s&T-x4wtE(OLQsbLS6F^$*wZ
z(NN>^ywrit?^xAJ>H+C{%(0u5)UTv6ZA`iIy;V2o^d2L*W>jr8*R~(yKXM)<?Z<_5
zXyTPG*c5h#VGw2DK~{m~Ck>HY9m!LXTu_13YxpJ%a~y!i1BkW;4KYaO%YJ{PaB)tX
z=cuVB{5lUNn#z|ZS?>aWM6f}vD%}8*MuS=<{mfRP`K~s6wu_y?{C*wnudK_-@96lO
zPLd+3qY_up=zM3t{Fi2U9KkxAmqh+}`}|$;cKP`&6N>7m+mv(i`*kWx;J>GJcKp2_
zI#cn0<t%?c)xRuQ4rihwEqhr*U$tiGI*qZAXW;Z*aGZDLL4pPau|x<08d(UQL%>&#
z$;7Oi;sVT98-ci$u(p^4wX&xrS@IrPtz1ppP2E7h5GaC*h|PQaKvXgUxEKwcZ*Y#k
z-1hQ1GFO?GACT#Y+KZ6+i1feAqs7Q9z_mJr%x3WE5??hi9gPq!i!i4I!bz4JK)3`h
z;i!jjN!voWya(VCxR}Y07YC=w2eR4uxix$ayotpi6rkpqzrif>TZv&Go|9jvj{}|a
z*Y|Sxt;ctX*WqC(>=}yr73;4CI=k*p#w-{dpso!bwTOJ+9qR(wY`4Ro8S&-=VoXW&
zQH<%0f8qnee?hA4>BnCOleG}N21%%K8-BsJup9reDo^7B0=}sM%Ic<3abHO3$O%;I
zd3iL~odkSmprJbsRtDlq>#`<h2vVC!nRT(I2dOQk#!)zl6Ql+O)B|259cOH`U)-s_
zydbr&w5~DcM`abaNJB*I!}?=qO>Zo3VqGh%HKeVHaMxB=D+k=eu*W+enHbGCUg%&^
z<`p<Zn?w9mR%_P#(@32$^v{6eTpLv(76nXO&=VcRN{+Fla|ygiroV}m3RbIDd-)#k
z|Hx%rP`q3&1cm2*a!Wz8tB55fSZ$o%ueM-?_3Q0>q2GL+ZTOgK$-K2o7{OrU*Kpf%
ze%4SB<iwTHVkL33yv+2d3SJ(_lHsR}?uA;oL2kXFPi%4HrpJz&We?tz&@(p-I^qt!
z06djY&5CNsO~z{#XtZfLP1@bpw?&R0w>V1^2yA>;KDl7yN0ieI&M^QeN)BJbOJ@KI
zd*?^i_$0Iu<u8LM4&^VE)yoGvlsBO~G#A0tCF4)onjgQZ92N<!q0`*^sf}<C_}GO+
zYpe_LIQpGkZ~GE=9rwr|OjSbv4&wwvaG&jg?0=~YXD5yJYwih6KYWcl{T*G|e%kS%
zODy0xR!oNb({}cmTzP)pD<FIbA8_F;xHgc_h)C)#<`{l~VfNua_Vcd3f&QT!p%SOF
zsiKTOR`>-}B@A+47+b@4V_7MlGAzVzwcn_El(7PH${OCGqJ6e-BRm*@At%SAHT;t*
z_Src$CB!FIOym;XT1MJpk<)>&Ne(soROZ;+f*7)fyE|Y*5Zua}7NM)m*DJ@#UJ=CB
zR?Fn?NWvvIft458a$-Z5aJX>7jg`HQgbTJeAYbrT&L;_xWsz!c1P<p=R?CiWi;TdK
zrYgeoi{Q8qpyWC4XEf4~4DC^jEo`a=mB$CH!D#eMH#s8EA3KwyAJo!&P1S(%-w@yr
zQ5=w;tZp8r8=U3vF|HW|i(7Nu-k4h*IyarH9)}Me``)Fx=+)Y<vlu^F-55FCz#Q0I
zjSKpkV}aET=l}7yn99KFM%zwpDog}Ni2m!RTHU)Kg;t8SUu7ZoD{tP=K$oU^^HQj8
z?&Md4DbgLMeya)CAix&a4P~yoTEhh}`7P8iX#_qHqTY`ZY!T}Iz9Gbkha!n+`M6Pp
z4*GgQ$(y-9x@#-s(MTRyOW1FM^e?WPj~w`kE9y8*aSl@SkbbrU3x}U>@cbF88$3tA
za(oTubs7I%7dLn+EyqAP%uURQdbl4I`dhJ?x!Bj<;u#B`q?*52Ls-sh04xPt$uY29
zmIv9}F0LraZI@;N|EKLT0c>DzyR0?nwo41BUT<SyyL<^#*OP3Q0S2rFuw7=r+T|LX
zWM{iTLF2YdGN9jUtwyGQNjTO7s7<tCYidY$%-5QjuM~HW-`(tgmlS<;zjBrd>OmKO
zF8v*d1z}zCw;r0mNZ29iq(9J&B1iQE`duhovRl!t9)F%kpLX%*NlwKGJA{Wj0}#(V
z?Gk$_*qmz(^V6I?$rJ0!5E980zj3}4u~<u|RBv-SUSUEqTu4|np|Da8MFZS;4U0&R
zzUBxeQVku7G3r$UqXSkMB+LNOP|hJDzaFojyE6B5<5D*d{|Q%S1yWQ^J1H=q<hY>{
zt*GQEw&!aQ!I8vFmeq;Q{&)mU{Xt?-_ePpvLcC?GOqf)^c$wH?liF4q7l@O2ZPcY9
zT^2ymZ%yGAA=p2IxDtnn%b-yle5r@M?Ka?_&*mH1A8pi;A*G(9>zS7du!^NpK${+(
zy?}$~Ka<(;wrcY#Gs<8DU?Id*NuoX(vgbh^p-aPX2olbPeQni1X%+O3D{a-#p({MV
zb>;E!cTFNMB1_{lt8~g7Uxr?zqJ0=o%lDsgA1dy+>EuMOd-J`S6B2=6w=6{_d=@BN
zOcpF1uvg>wx{-lqu{6Z0wWYh5=iK*@@+i&A!%s{^AC%{6Voo$};|2s5HXcn>*^^II
ztEK%4Y9X=)H0O3|RoAJVu`K@3PF-yb0|4YY*v35j*aw!kXo#++>VYN2F8OaH6QZ3N
zRnrWa`fL)_E$>9twFi1DFm125R|iVzSbXF-)lhypl^Bdcf!vMsOR3@F1A8`3z3#t^
zG7_<R6!%$IetJx-;o^-@Kr=@BJAAC^F|i*d@LqZLoapcC4eWFg+UK<pp;!)B>z)(4
zhQNLz5$g6S)&CG8y=472;?)7wKcU>I4!I>KKFb@{Cb+s0%M9r}IN=;TZIXk|bNB<&
zd7zzhmFF3>7%`*%r^+MGNom#~RtQ2f0`L4i=3F4kW{t-Q=vKkB6GcqRJt2G|pA9qR
z#&uN7J6Bvv_zuJJpfBL_QyNE|!0?;r-lv+9J?8wz-98i%oHY>D?G19M4kv%%Sgmf#
zJ(i%>cL`cd)%}PT0f@iFB*G{qf6!)*R5KVG)ro3YIEQ@WpqmZn8gmHDS>od|mhW@f
zjYPF^aB(dVt7Oeu=I`VI8F(QgXZco>Pi0q9X}qx%S;J!>fE)^tVl&zW#sVMaP3xj%
zFRXAhl;18QY;(||<%8!&mPM+)-tr9UFhR8klx-d2*R+(wIl3-t9qAU7CVpM}5I~l2
zS|<UBJFNrpK~C!$@1PwQ#PD@x62H<WmfjUW0|@U#7Oi`Yv!Lp%>Z(S0EF{GK#(+Yg
z;xFQ&qZ>(sVMcwkJ33Yh!bktZt)e_RSPcN!yhhv;+XS=UPAwW!#l)_5gIbiy$Ht$}
zn4D{^0$qZ2C8Ti~T?q-mNBuK#m3>PKggT-~F)cBIBcOzoHnCmZF@qRBHjhyIQ35Az
z$Vk<nO4?>n{wpzqOb{HMdvEMo7i$C&^yz#;<T?aIaowEzij<D5x3aj9CbW*Obhy<K
z7%k&v)BjyoC><9umX1pR?)sSM>*8Xsbo~5AwsW&?cq4P-U!6x-9fb}c277rg@|QZ>
z>m0EtDEy^Zv;HrCX&{JT?=O8V>;BSOy3TPO!iwu0tH7<?U+VK8I!8z?p>wPObk*MQ
zm(C>=M*`HQbNpMh`15y~X5QJ4cbWpG7@Vc(8!{UmIHf~{8!6-n=u5LQhZTkjxZ8l6
zRh`~*YVwCH-gCM?p5R7+k|l<RrSw;`z2C<)IS>+2<X0{2ZOZi=pt?FsIcUjmpjyA>
zZ}+jJ<3<bYVbC;Ia7zxccS<^;-`By;5x%Ji5;&Qc`r%2>jDf1j<-W`gEuY#_>ikM(
z&TOh#dh$eO32bVd;U1P)+~{YPTJlQ`9$O9HU6Gl>rp8vtu2*qAVrR4J^+L)EHuW>9
z<4c*<$!Qb9UVb^%OZw6xv*XEXy}D8Bd}-lL9!&;aDy{AAE+Djl4pm^+9PyGQe&ES$
zj}p~Bo9Zu3$GmLy+0>pD@qx=;Kmj2w*9=lG+TZTYO{gri%ICuw_l>gGOX4o8W!_XO
znSzPVLSl`PWnah+vgRUw6IcYmbXl``2yCReMR5OVBMnD3EuT9+1cHG>VI$!K9$Tmw
z7-P?@-i=*e$gEvf?{+TFWwtjuBg*pw0yu_Qs*8-}!_<J%{h+zf1>S`Lo$3%|r(qCp
z-7Dzg;a8|Gd`o6GK4?p(!WYlPoVhmz?fx}PtyUf%Fu5?nQOk|?c$)^G^@pn+qy+Hp
zwBc&gDwV*t#08Z&=o>eC_JS1ej$^##^ah7K)f<e*$Gfw}%DzuUd($R6%A?40#u_gF
z$SiXN<k2yFWSlehqXbU>!gEG{-+w?MeMN6h@+j77nBWR|G*XSNp9a<G;0<_AqVkHv
z5l=r6LlKNztD!Vj7MpM_9IbY7nHJ94j!~COZF?Bm)iG+E)aNYT(H^T-b@^>hZroVa
z-`VBbD>i7HYUt3rJXcz)#&PFS88d0iwgACDf2EPb?*3jL+h$n_+-M}bPNY^_IXhB^
z<>B;k=WMsj_34mHEcuWT!Xbjf@e{gcbhq>V;O4zy8MN-hnGLS?K8>DaZR1G^S$p+J
zPAG^CpIP1yWr^d}sR-WjDy}p7%0*ELk8l^2^!-U@_s6RNE<38RGViNHrOjP<aCpa#
zK4p3LevjqdJKT<D6Ggm{1%bm1=ONfAl<j^Q4z^8ztttVQ1~5dngsf`q=d<8};O0y3
zlh!HxMJzH!Z6@u#Dzh;uYLN8o6b3s*Z6#fYh&Z02M!3v;$_i7|i(d0yp|IY63!Tqq
z_a>@Itj0vOee<S}8YR}}FeFj*V-hJh*@8ymw%jc8`jD^r@(G#c{4>^<?VYGrk}ej=
z?A%24h)es&Y{euswEd6pPE!Qj=qDoLb{(EikheS2Am-wlExNW6ug>6fe*k_F<9m&z
zp?wWJac?313K5drs^iy^(_NXBj_FvV(#3qi=n-Rz<N)riO?Ju0dPvvS#v-3u_;j?c
znDc9Eua&~ZidEDGr9Z!mj%Mgi_j4B6(a-&YHhSRac7lN7PWJ?WlcW18#E8w&?FoXQ
z3T(jBA5MrgR74#(GKxB|3BV;6hNSax{w{}PHnl2{*aIAkka%>b1QPx_5+M*w9Eq_2
zCnVlL2HB86Y(hySmZ2g-;`T^F;tYUGB9W1+HFbf+-j%C`SJF`)!J)eV8V^4Nn**e2
zKgw)uu=&es@qeS)mEg~@Rk#_}ya&v%c4!yp3&0!T$+f4Aev;SUGP_aETzRzBVjh7Y
zNQ54diDd~wOa=+;#z@4Kz>tUb=!oll`0c3BR`Dt?G_uSi&wg}HZA~{DlSdD%QPXPp
z2kcKzcH-R<#LMEw)xX|Z*}*?k{c9y1m!0HiN1RhDV8bMdu5}%FfsZ{-$sdss9Fj_0
zYI*dA-H$NW3ww18-Ersiqb0X7>H)Q|83)yrQV~h8kX1XV1+ZQ<%<iSn{v|u*_p`E)
zC*S+^{Q*CyE|=ldmwS+yh_^Y39&rxkLCVElnSrJ9Kf7}HoMTt!+_H5g1h_eNr9PK_
z*Kyw9aB){|zGCA-)%w+sI`l+BHM}P+uy+1OPuAQj?n%Nd{GgtkA4)yh3rP+w8iW)*
zv0e3@LFA`lxdn=P?8t*VH#!JRFvJxHEsk4nz;W~0hcf#<+Z-uB`1_sJW5-zxoyVNZ
zyd1DD3-m>~TY+}vfF}2aXygJR2@-%Q@gPjCZg_o$Qewko+c@vO3F0IzG5eO1VG|z#
zPcAWs7&IL$86gc|hv$}21h#gG*{@VG-iHC$;l<|ah8{Xth^;msUR#bipxh?VlL&CV
z6sx+#T-o5PgW_#j!C-keM8g46zr%W~n|~I_^|rP8KEa?>V}-vCfw+Aj5kPoCH=xY{
zq+k=2RxX+bFRs5s>?Hu8Lp>7n7b5Xbr1CKffI^Vp7|~0JZYiX}@INZExEyn6SU;+V
ztB8PKZi7D!tw4;i$DD=ln6u^kAg1J)-J3MHL8A=OVW$RtP;@1z7jmiBg9g#CcjPUl
zVUn=@OUzY?bh()Io=eSD)0h2-W+RHw|M`!1eARuHOa*T|Eb75_Wbhu`!}_0J0byJS
zZALa;#|4EU1&+Cf@mb6tMz^%*(+x2D0FJrlF(;m)xiH1enJ@Ee@Zvw9pp2^zP)o6>
zz-^rTwYiV(6*1*km`8%S41RXZ1*YtiCbOAgYD1Sl-?1%Ws&{P+u7Et`YX@m#!@yrS
zRj`olhb~qNY`Eu?80jK5oO;cU4Gjl%h8V4b6|rG00<*E<p*)=p4LVp68~%EgY9ls$
zKTiyZhpS-2gODb~|3z$=!9l@LQV^=+%%7se6tQ6gg5hlV^?{OXn2r=XHr$Du^>sEp
z4dG2J1h!g-R6dB8p-$;+_&u_5#WuRi*)WLev9V!K8+<n4|C0?L{{DZl;W^|I8&(@Y
z+*F>o6n)T+4X0orI2-oZ@4$wOuLw5W(Vq&gDJbee8ZvkfHo$GGv*Aa`#!Jee@W0rw
z6eccK5qPix{y*4oA_`WAhKXAK&4&El4hY67w`I0vpV>RzAHvgqeY$iR;?NU*NDt41
zun@dlo#=@_rMc%fbssuaOYuw%hagGfXrJSv<vR9`&dN?onY8jqrKM~XA8S&y@IaP+
zMWXv-G=*E)cnrRI_8&w_H@xKnbL4}1YNLp|dr`eV4GScXr=>bDq44dNcR96qbBR`&
zt=VsGTzbo8j8j{&yhVP3A2ckt`Vw{Dg7n25hd)V7KwHnhzoqwF!7^mu^O2YSch6l3
zHOHP0g6@q*t%gF7z^>;nIYAwJ9t`#5KYG3i#*d{wdOmfJL(jMVCVGC#Qrz?FaG0Du
zYK|&($*$wo@q;=(sSkBL8^iOT9Z%wG;c)VFTr&IlL_u)ccl@7=n1*}*GzYlshJAGg
z%hYYY$Uu*=Ef`-DNQGPGAj59a;&@2Ef-1cKpXXwJN2+b4zjw*(qg&>xgLa`ekc)f;
z@wB|VAb3BbHzDZ>El(ffNXso`@o^1=izeR+=?}jv)HW=vAUM|aIarXf3&17l?0cdg
z&%gt`ABVBR*!N=&YGaizoBgE_V8T0+#zE{l5=Ag$FPj5>f8P18p48bPv#Sl!lgT?}
zcJs2iN|zo0vg^v?U-fC+lTYK@c3qi-EZ!9jiof2KbO7L?L6EGdD=cK!=e0^hyP*9e
z=9#AUaxJI;7x<VoHO_SneeFn7!@NRoK*PqOD>!WL9hnuRsozQ+x5(_%$!a6X7au1k
ztF2u-!UARGr>G62b(>`tGe!N#b+r%f6Z&zA`c=*Qs1I(C<1!RqZ&YSA)C0rN)&%Ak
z6dAl<WckG#(AgiTe&OE>=*(j12fxYU33jgZ)Wj?+U^%YC1Kq1(1tY$j(3Q433qMe|
zdiA-gW6Z_V6HKygAF4^-mo}18&#$k5)(SE41|FoT>I>ISUTD{Qn%cJd(HKOmfOZI#
z;YMvw4E+J>JCg8X)<tUd=Dn7I?h}Npu^ddKR@Y2Zt4VFq&f#fln9Eg}-PQm1oUYcC
zemX6)mebWX)#r<8YWb}**;5&)7MSy0wMMpZKei?%!KX4Ng*CkKBl<gln9pHvJ#U73
zQ0l13Y|c!zcBLvytevuEdKT;|9#%Pc{V?eaY*+4=Xqm1WeWzmeB#r-M0x`=rEFHq*
zPxrOIKB+^#x2l`$1zAae&pHy|jVoABHb-`<QHhfE$k&t6&Ir6O#d4mi{!&{M-j<;b
zmi~bK%G*oYA6=S#`c(Dt+js&aqkBU}K`SZfiE})cWj635wNqF;GO3}@I#5HiF`gtH
zdv;4Q<7iAMgoNe53U=`P27k#NHIpAG=pm#T*xF)55qpxvI>BY#8R5B<uOr!^v9m2a
z_qZ&=bMZe%kca2ONU))nN#X;$*9|WLHH7Dq0YRAEHWOxNz;`7Z%b2b9_etT|eI2q{
z;cPV^c=mGGlOY&fo0|vwDP`d6$7VMa(lL+L2Q}Er<^6Swgi5%QIWyTp_s0+;Ka8Vx
zFN4>Lhcxn$slQJK&lpV^MGV0<Pncj}Pv@wWT-qhGvUAlKmy7YtJXd`wHOA1y&QoVf
zE7!>E$UJqvq@0&o;(Rq*@;@)<UZ1blb(XrUmRZG2wP$0`hP3O-V<eLiDTsBO2Nrtq
zWSDk^&|NTp&qWd#e&0ACGmp*7f=U;(!RGln+m8@j(2F0xXCjKKYa8lFE6mSge92L`
ze0`A1+Fq>QLN(DPIWBkRLbWkoaDaiZElXW3^*t)*_E@A&aglBulG&NX>d2Ncb;y}@
z-Tu}$v{M7JtN`n|p$W2qI*uJ61;3xw)_=QU4cU8WQE-`pE)ac~0_?z{MS-OY8X&L}
z(_`lnH8G%FD?+jXGK-NEzLJm}b+P389aiWZb#iF~W&qZT;&@d*sU?-X4?eap=_KM^
zpKXxY%cbgvrB8w>9m=)Z*__I)L;CO>*<;5s?h|wmbcTG)@_~-x-YW{-&2lXRAF0Fc
z0`WPIP%c%I=<#0>%F91de@K5-i?Z<u3ogI?5jMovL>2cpA{C)K&`6PFThJVi1^0%m
zGiUx1pZOfeg0bD7J`;ke7Gg>9Jw*S;4*T@5-sa4Uh+$kKri#+Zi60;t?S|sz;N_;B
zCd*ebxh+3cW1Xd^7>8NQ)NGe)W0==+wU^7BF}b6ct5u{*m8<C^i(8LxY{GcXWE+q4
z@?$wG)!_K-n8HWFg!-@$3~097yXpXTJeU2;r+mZ@698=uPC^~vfS>T2GYqOt-UKPX
zQjL-xLHF;xQVlD863mTBSJYC7=NAoWNai6OQ;x`-w^E%t5|>i7fo7XkW^+07?3cLa
zXanZ7#}4=1*sSo_aV~qRb+#2ZM}3S`3X05%S;{jW;hhVZ`tX@diFf`3$y1SR#?c+}
z_`{d#zA_I~5?5@v?`HnEjJ{Qy%F_3tMt1OXwSM}tt+LbRas{q)&*OFT*@t^WazJ~D
zd4_EsGy~NNs~b)XW**#JZVv9@XbVN9;J0EH<dGS(jV@^h_-ViUBET-T?$lD*33>}Z
z2(}bCplNahQOYhXuSTOKG7f?j*9Wm&bgyeSKwHDFL6LFDU#_XOBx#Y%TD|zLfx+p&
zE(c^OnmQThs1W7K3N$r1raQW0cM|mohzL^E=czb}Iu7O}okTq?(tVLmBn0*5{DY0e
zcI(v!fxY=CFA`qW%rC-v6Z2-f-;6M_#p~6!RlT=>p=uQg(YYs5D}#>1_&%q{6`2*T
zSEovC7Rzkh1~me>U2kn-D>kTjxX*17J_|OeLqj`}poWRP?4Y^%FCL%%IOkldAN;Up
zviT70IUI`4gpF!|R0+(Ly-{uH()|@XxlvspwfID4J-%1(S6Jy!hu~A)*WrKGd6PP*
zLOqe<7LEUN_iR#|JEO(%i4Yi@)y4q}wxLD1mTyqc;VU+ySGZMTHg;CFsOeJgFXh~0
zThvL;(%@}SvbL(Tq<T$_?8mL@a_2d$&o=c#DX@u=UD&3EN^=#Nz1oItghy9dr|oL8
z%YmD0({^=-@BA^&PO}j(;^O2arIu@m7l)o(+Wy9-?NB?o#EoOecBog=^AQMOH$d?c
z(8-E9#8WXq=Rp`6pxW>^BYi!E4d_ROk8>eHTlm@TU;TkQi^1y%DRn=P34cGnW!g`G
z&X*8oHe=Xwct_oLc@rlt5_bU}o5MnPs!gS=uVvPMry36eoo<9PWjoanmme;&pLVKM
zTt|Nifu6Hht%A(q$n@H!hBo|&cFT%ybz_7|R!l#h3ar~evm&f}VA3GHE%xb$?oz8)
z%68xSyFk<oL}TY;Qhv4zs$2O=Ms|3Y8a4RdI%v{Az$h5b{}rvjI8)sam6N-nS**v7
z8z$UMXPx~5V&MsOD=S9gO(R0bYUmA1h8iCQ-#v2j;Vjj8dd6+=bl=_Ba_Hq{WFPES
zW26S_ut4orBg^iEClYUdVZC~^TMbB`h*EHyVl_flb5}xl$^Q*|1MTMil~%4{9xjB*
zzeCk$$2fDqLjdH+5j6Zp*8IVMhI=Oz;S1t)xU0wfzkw@yQV~V$h<9A{zybvLO*kHh
zWT(c|ft@1bEHZ3kzL}E5*cy^Il*V^=jBd6eU>-=hcMk%W3O$VM`W{3ZoWr6~5Sf_=
zLNERe{SMu$_V#IWPHbY}7|>qM@|ME$Z1G-os!Qs5R&F1dx#s6GYp_rK+$}p=K`_*r
zeX8%k2DGzSJlf?1kCx@B80{Pgbi(%)_#6a(1plB;@Wks_SU9@ykefRa^599C_)llY
zMegEmzoFw+W8@d2hIS2~HO$NR0!PJX{sZK{_Mt@w_qj}(4~PS$C>?k4yZ1*r0&00y
zZ_4@_S!P@-!Rd)RPH5VJG_iF7mmRaVm9G=~eZLx>URNZ1jRczb0&J0frrvGfdX&mU
ze0FAM%$@c)QhgW`AipNBJSGQv8UmCcJMw)+%K6KD?TjnK*UlW8U06G5ob)}j?b89A
zPb+p7zj4vi$*mct#qilLh9V^2f>?+p2h>&R7HCsIvt3KV3N)faDex`RWi5I~{tys7
zIfOVl0|xWgh#>6|Slt<MWbN^42G*`=M9k~1)c=^zFL4AtOLGMKRQeZ!Gp7MK{Rcqr
z9tyN^A!@e!5P;?1g{CZ$z{&0zlyrcU=j<4>sB>Q_Ugra^f7Mxs>U<AX(iK+c@jn!s
zhXZvb=ZVMrZs+j>FP^~ZM4XuC!fGE>8^xqxOT~`Sx(i0@z*E6!0q}MZqx~h)8zEh1
zwB)Pc@XroH*D;h63>EQgB~VBuNZtTR_b2n<wsB5vryIi;EghOOpC8qb`j$OTyy8Oi
zKmOQJa!P;)JE60{J8OU)-sACu4gOJWJTMV^CU&^)5zJqUrvld-@b3_=>qWX3(sf)5
zuh>tDmj5v+u9gvfkoJ8hv)YH$$^&=6d1=>JxTrLTr=qb2dSi2`vaFa7kghk@-=VSS
z|7fg^t+5Jd?Ds=zc=NiBjb#hrUdq;38q|MiU3i`&<}tY>g}yKV^MEx!j1fpHEwGR8
zxq_I0mVoS-$L=(7T)EyD^Opa3{=JOCF=Z-J&RzV-Uk&u=)btvTX3PVtjGUTq>;86F
zt?u&p2zzr_4Q*4<oJV?GFGpM_<}dvCpF!F|>x)Tw!r8qG87J9pqxqcC=VMh=i!h1F
zGD|+9)=D43s~?xg$7$|<40e7`j65Om1d-OLYXXPps6$X@eiZ&7=S!Z`P|sP1#W{c6
zGoBO9bNuw2(uk7D_d(Dh%KZM0y7TscXm8a(T2uOgIt51l6eVptJD<Q$Je~dFIvJDt
zX#Pqr1&`)ui2rSzY$<yRaBT=;naHuXgAuR$Xer`SkE+$`E;|lRzMo$PP*y`3)S7<<
zM4*DC@!@}S)?O|!En|+etw+_K(kE+WR^b>t4V|H}O*p2u@hN-M$~V4?*Nog_v}V+1
zkB+GkuFJd-E>geR#-KoKl$*9Y=l4OMtcE^oxRyT$%|OvlI<AI7e{e$B<&@*<d(zA$
zGP`_St?%=+Crz$7d^sSwZ~?zr&<QowYgjtb;0Vkl%)w+zUUNb<xHhG)T_@E1!B-%u
zX@+fbadOIkL^5WF+k;oK{XA)neuGVq^Hj`}1JL=Y$X6uBvSKzPedkUhgv13=VkC*%
z3?x9Xj@eL}xt>z1yPlhjwYAPE1kX%%GO|9W)Tn@7(D3sgU;yn=@6a8XeS1nBTXxn<
z8tK2_kqr8YtGo@X;!M#`>M5xX)K#C;YD{t+l_Nhl4#=Z19~=ZJx<n=dY3PgRbBDgr
z1~YKJi(P51COAXwroOxoeLRnJeJU3GgsHgYG!9Yy^R_kn{WNaQy|5SvrxUMa?Z`v_
zJm%D;Vz88w@J7ROx#Tgd?W<55ZF%hjztjGB79jKAQOO-{GDo54HrSU$udJ9r8)5;Q
zQ8o*%Kf>-OPHE4Ww@;BMB*leOKyUTWI3MW&^zwd&%~+T%v*$mnU84Shev%)Iuo;u?
z4uq=)`v2+SK)*32B~4BX=#J?WfEwY^g8z2<88ytgE?av>t?E-b$&sJlBno~CWDm}$
z!_p@lf^;a}5{@2qHrOeDDRltPzTkTg7Imlm4E(`m61(sp;>AAJyTgr<UkZi;G;B(M
z(;je~Q$cV1s!s*6(9nxV;#YwQA3jCNjq&U0WE64dWe`9U?TSox{VW*z`5An@IIGr^
zN)MA+&2ws0ec0fANVkh6eLnj9yVgL@(6SbV@q7`MfrfO={yJX&`9fw3&#AS0XS?l(
z#U*$MHZ;w64AtW&#4SZbb(hL!#r(umF(1}%(ECP1bwOlqLZ&`amY;!Ih4UDxwJ-IN
znzc}7!_KSCTs<x=#zx+Gb({2$zf*4SU({~SE?rKsjlZgYOAX-*SbjmBE(Ipb?Co!A
z0IPpdZQ&aGD~gQ0sD`@+(buwzm|Xw-g0H<7)!ME{>Fe%Ab%o2+<801v>SU?WKwi3s
zbY*~E&G<{I$@T3y0B*gc)^I&fUw>ReHS6ii?J}yKMPKzVL&yK+;9{0=Ssm=X`T+<?
zdK9Oeo6kY?>fmK{kn6&;fQ`6<5cd)E6@LY2G^ejAl;%rcE9vXW8GP-#q6Xo*CzsVl
zBNG!ff`-H};w23byfKJ(nN7rtskWalLd);9rbXz?Bg+3YjI;|~DRdn~aE99$T7IbV
z>uL1c?E*n!*r61;1uSv0u|Q0_-h9bB8pvznEqx+dioHv-V6g^S{k!U$zKU0fqZ6^b
zLPIwH4UbI}{~dGMLg0xS7aendhK-Vc8KF)<`MrG{<zEXp%HjV;xlJ-h`SaJUQN!)2
z{D&|9afyELmu1V@yj}1=!k0S0`|Uz31+^F1J2F_tRkey&=L`PO|5DD<TX%*o_`z~M
z9uuDX>s57>c%shpxv8387UJJZyo<L0N#Z#>c3st<v*T~*9X|6f*n>zCumk^8@rK?d
z3=6yT7e;;(eepN++R>No4ZYmF+v<F0DH|$6hdb&8-%bx{d>)eYi=?aa5ZtqFyv(94
zYG^=@N7OfChJD|JS1ZM$&hUB<1lMmK1K7)1h<UWA?OabB2TF1IYO=Hu6>0fuM3b?T
z;b<E38lkBZK}d(7ev~XV3&cgB&p9mCcz2z@iudXgmej<%*cWJmN~+x@Nslmsj(63{
zweF9jWpjXkr_8jF_+#yAg6Gf$tEJw<g$~|)r`(*oaEVCeC(7)n0(DB+a~OHt5;Gbx
zx%bpM0nzuVdsSh)*!!Sjolx$c%ABQr`K?*)2kMt2Zhb-xo{!Ibl#uyb0^ZgoXXvvL
zkUQ9Pa@%epj{c1&-b5mjb|b0a7kr$+M||d$0z6H{FI9Yb51a_k{L;JB^t2D{n?|G;
zy;+!30P>A|s1B`I6JPq9g)^qY|3YsTK0gRi6i}$*&B6l{v7;1%zVk7_t%Ss*w4i;3
zG>{T+7WU8c$K?-nXYT)cvv3xc9mh8dM^d$RZx%X<Y8~Dz{O2r2hrd}EIb0TR7T&_3
zh+{_L&B9;C$>PnzpCIzrza1S|=FUP99m$+ekMm~9uSSQtdRov|%VYFaxl`2Fw_r{5
zwUvbDrgA@fLR~e!@7UGfz)!rZ-xYQB>fZlfS6zmb?5brvs+C<p!7`}FYRC}PrVa)5
zY|k@B{fw?Ida72IHVoFg`rc?;SE(#y4H&BMDI62A1o3usfNRFBg;o~%Og--39b^%a
z0ko<9AXUfPlch{m>bw5D8~tzdTut)YJr;0;1>b(?o+|VA83$#%WvwP}5|@`TtxQ}P
z%h!c4#>V3X3?ILolJ8}DjMNe1dyLNb_3!r?rDURl)za-I4Tn>1@(Z<%v(#v)%(hEo
z#+7yXgQm#d{$h%h9e$noGzn8M@s;|-_2drV+y1pWKzcb=X5YS6>q;l_apAQZ?)$?v
z0{sI0D4tEjb8<c3sEN)}TC$uw_^mqD*`xhsnk~4#_9!l_=q0mj@6>v}>#k7QMWafT
z4YA^so0Ks?-rh@#clJoV$d?jKK$uKD<lIfpS}*6ohznHV8SEnP8F-)@dR;XGlyu4s
zk+eF_Qf41`>s_@W9z%ZNq7HASc11%uxp}TyPiJXAkO(NHt*OxOoSt1NN%Y=x?|DM&
zTP$S4nZKj7266Iv4_;p|>r+NEdrUf`m#W>FD#gB?vedtPzoJpc!t~8xeboDj2N0(#
zU~KUK;^Iy?<UkJ~J}jqYxXxIOMVLQ;xZx*WD?cmn3g?_!!1Ut}AZB%^LDh#G7pYF`
zj@?^&0C8*rjq4rD-qZF%(1y^SUiJv}c+U}`y59(d8aumm(DC69GS>UthEM+!4)_?F
z+VE-F#Sx!6U1a7uUkUe%7wC*V>4;8ll7}|eCH>4%VzU!mMTjYPjPsoMk&Pb(rLkK7
z#8Zj*`M+Z@p-OZ`p#(ZKc`z3EXS+25ME+Kh_l)PA0kK71Px0Hv6-z|w0-pMtIbCO#
z4@Gh%N8lkm)v#9p<H<|`RRPV#<Cr9TD{g0zN8e3=R%IJp9Z{~ks0~*sigJ~Cx#I;e
zF5PbMa>w!J$VK!-tRrm^l~GBnR#7`j-1cb?;$In26yDll>4Ro+?r+{&Ip<LCBgE#{
z;YKi_^CAkRrp0g!Rx(~L#eTaJ8y~PSwEX<TRLcbX&iU_m0vE3e(k}$k??;pM-E6ua
z%~KZA;pjoCWiuwiLqDyCG`RtkFWmdZl0J&7;NQIg0X?^j<v=}?Y}129mK*Bp(h70+
zMb~j%tYTkqTNP38ULMtcF|nv%;U@`x-cN@@HF$QkOlmnqS3%Ld4Vm=HU+WYwjDsf<
zc(J#fZ>}W=Xsuj1werrGnoHAKBhn>63zNFz!_*?izeDrZ#3^|3+FS~@3&O5aFiRob
zi{C-#G_3?M>e1i>;MSbt<6NKy&%aV#Ki6fd3eQT0(P#O`-AYA;VVLNSx;LG8owTld
zfg7o!m;0%Qw~%3rMWDFdNw#XPfGl(gSCf4@MZV$iO8{S@i(*f;I~_Nos}rydk_lxl
zI!H503(PW`5~RgQYe4ecAg!vQ35LS)Qo^wzh_MOMLZpxC$l_t~gx)gyys{>Hl<kd~
zH4FISj;@a2o-JP{`Znl}E^&I@qBAEkP?nGddKEnk7+d@>V9k~?OINhOrnPyQ5X<ip
zXzYO}Wl;vt6o`@(Olom<6J%+=m&j5bIUozm2-Z4EnJr}YbFfyq$!N$pBH`{m3!x(6
zaz$f2F1xT4pi)Zy3dz{9?BGZtoJy(!{&YtrBCw;m7)T?aOHfh-c2K@8u;XhdTVO|X
zJ+K4+7YBAU13r4piS6CIhVgn}2l8kUy}gT&I%9T33K}H4QB|ua#Wh3RWC-{%1RqU9
zw5owUc>x&(@S3SZF_zq`lPp25+Pzr5wVNznEbou>|9G)H4YQokShkbUNRRtB8vO0=
za8$$J{w~kqpIc7l68!e|Gz=WsJX2)ZCXOe&eDRy=9u8Q2D?2Gv^QllwRWg9^X!z*K
zZLzj^f{}QT3dTwgQo+mN)^JlaQIQ9&{O3#J%~6=<<)C)NXC+?}mr$B3D?7Nd!jh|N
z2Kd<C9>bB1>e^8089aG6t83mh&aOpY=#2%|SGbI(l20}(W+&2hOMm4@m^eXUT9CAO
zM{CwROsg-=z_5%C(;~`70SsHPgJkwu7!F}P*hciZ1k`NC9y=SRRrl^=gnpHRp6dGI
zqxLc@6|Rk|ml+CBeoHS_-~_TZ!LebymWrsQm}Xp7tqIpMq`mcFfNk$onHeLrz#wlg
zbQC5S-NA_Ga?pghgK-R?QX{lJeqVYP1Ekg$nXl_%CvSVFD)k{OM<5?`_NV)0a2Gvo
z^T%$ZWpy6(0$O@vI`N-V5@Z%xL-VU0jsp3!(GV_{G@)$fAsof8n3l>n4q%fZyI_RX
zP~QXrUPFtMwt2{GPYtbdz=bVDoC6Sz_T3^jDy*R$l~!Y^h)-M7N_r0;FKTMx-c9x8
zV*X|t#0)fv1LC!`h=iGSQO9tzr8Q;jFjHhisyzFpOIk?7`|TRuFBk``J5MK@-BA9A
z)=vBDaBN2sM`cIHw{il~$KXE2X$&u!t*fQA4h{2@o#X{$!z#w&k4LBMO|VnIKo4~b
z>8(L#F1598-t#dL;<FFr@m%b?Jr9!E$l6-{!0}PC)6v+lN>0P+IV`k*02N61UcNX8
zTU)Cw)yBuQ+FI3$k>v@C>0uS&?nbTU>R^_?D<`vtb+iC!VKp2@tfS%iRivckuJ>az
z@vC3y7?cq!H;N51(68$j=kJN01+DDqiMtL;+^EEZ`z|ge8wWW!Z=O{(BfX4MS|unI
zy$WR}tF3~oKMyB1K7l1}PF~v0qitQC3w|#-Nc?fuFR>a_rPobqS)j*RdkwFHN$d}L
z*d{U59wgD^`)UK9d_}9`SCQ29X=O5SpN5z1{uMt2j+X+<;NA+`g)D~iSfI3tn`^MK
z^|U$x22^7;SRv(0qLgtU+Ako@4Yd}P4Q~zMh+tAKo$6`P&5T%NXx*mSSBzpUq|$Qx
z;d(Bl<{;C_shj-ls52+btNStwZfgvzwW>PN8Y?hq$sjt&^T*LRkmpiKTypAbDW$UO
zm75C9w^Re|ku;ztw2%hci1a5lcu`AR73&kGY8msvzum-bQ}6`Kh+`lCWYjd{M#@}r
z4@VY(AW~A#^+aykR|VTKZWSg6+uyok*pl1YX{R%KKvA?MPe{uSfi$3ti1%!Qs2{-+
z;^w9Hhx`S7tl>k-*^`>C`_{(0KxpSQ)Y`^xDZ?ojpE=Oed@POz-X^9YI^3V^Z;jwp
zoW%4Y5orI&`$zX)08~VE;rVswj+Gl}k&wyHaMZ6$BW<{3aFf~YMp{JWMWkwFbvB!`
zCiFHpFHB2n*(G^O68b%DC#>5>TIGoTkf)up+BY+0b(S%gNhgM5r8O@%6A>LS5f5T=
zwQj7naKob`7MaaxthJL?c19FpV=boANl7^Q!rXv8Zm~hgwojDSNU9hH85E_p3Aot^
zLjt#`0-W*I%x3Ckw%ac|WcGEG7Ak!ogLva8tsBtqiL`3bTH{WaW`UqSXNP;#bianr
z;U4|Z;rq&P55twm9=)%4^g938qqeB(vByBe&3*n(NdM)r$-{G?KOp~n?9u<$V~;-J
zUt&73wb4*eN6^>JXw474)v4Qo5w6m=9!KQ7o5!qrKpjr(I!i(5Vkfo-bto&wji+K&
z8;aRL{%fl%PrsjoO7sw!71SrhAHYlRemh-6o+RTtbP5C~(&1;NOnmv9*{K#<1!>oY
z*6c=`g!)os1oXxxS}f3-vJExz8~))~4|L%;^+PLmIK2U90;g!6N;t&{obHMA;3AxG
zz(Q}>{e#;QM}lH@x>OJ`JBa1bV|Ks`JaDIi9;%b=zH5DJHm|7`HKH~oS^hB84BG5p
z;($jyumc_|cq;JN)L!6`M|&n&F&RkLSNwOFUxG9c=E>fC@O4^%D(+R#ShZ#v!sNox
zSRdNz+Tr$cu|s1QMdyCusc0-vZ;U^<mKC!H>9&E$u^Whj0Yw9`h%+CdF%oUIsX+&!
z`AL2E!{r1)*nt+BztmIHN98n(guv!n2$-_WEtwgcYc&V2@|W=<RDNwJ<-oC*BaWE@
z$A&f>ouEn)vy7r0-mI7a9Y;Dfypz+wy?q2>u_!E0{Hz2-*oo#^RjIqGljKw=NOA`|
zyR;iMAI)MZj?3n&3zT=%K6fQ;CXYi7LHsEoo-QJY?{o-v+Dtw!P@aaecDyu4jA0L+
z3bIy!rA#Pi3zTE3BZKG~pWV5c7(wt)xF8)dcbl@ncuxzhvNTK)WDCAp4H$ds`)7qX
zM-7bEaD1-7rxD&#+b1n-C$rlvwP;Yb_a-cWt+bd9#}_&vwv{N76|;_~0<nNLgjnh~
zNL!3F!ila`qRIAcpQ15#pIpj@&(v=PKEoful4_SV17S7LM2SWL0;dzG2Ftye&~xd9
z&wMMk)d}LA*m%E_$?2>^M51^;g<H{r@&N>5J@oVWKeYcm58|s&j8?PG@KIu8V>SFE
z*>2I_k$Vt_4s?ZS?mOHDHG}k|#wf5MM)ObihbBUUI33&eN89>1=TGAM_XZ~v-5<)i
zBIZd-uv0;OP_h05u7decURC5Fz8!MAAOLEa<y)i$2>1tp$N5`ikykt>n)l+25E63>
zC`jP0;F5v`rKyA4<DdYyhG}{?0CAJ8waDt$TC~RN2bCM$7YCJJtt7SKFJuWjzqRID
zvwlO_DFf7SORI&e-y36GGTVA)c7v30o4o<Q^j9bEvNgR;zRbs{(XLioJqJg%Jm$9*
zqNUdYhtaR4&m^9T(T_xDh%F5wJpk!qwsQeS7ks(5yCx)D8GP4s6%%?S!eI4DPO~1<
zy>}^OXMNS0Z8K{1JzRn@geyTc%;lr=p~D+t!K|52sG!mL@I_Fg7Cz=N3y>}vb-(>S
zESNg77AQSm*P5ASt*(?(89o4fbaDn5R5mg7=Oz%-#0hpfGmmnb>p3`lVlCLFYoVT&
zt_5H$D4{1;5S2+s;Z!b^wH8u`hBB*X(%RQw`!zAtbSO5N+rriW@65Z1b16^N?hkde
zh<etR*;<p<Lz)?hAXJl<<$WCU^1w(G(ru>XS~6p8v|EN*u3#el@_*9m;G1!k*^;(e
zZNn`HWGH*M#jbo>S-yD~-~ul}TdjJBC(c6S+q#SpUIjqdeE6#y7P^vZ&O~G~oh?`t
z#OJRsJ)Pzu>f>kr4#SVrGFGeRvj)?YG)ObAuMuj3hLjRZLLz+CZ_r<3LFLsjv@XX&
zK2FES>sW1c#qVf+Y62=lrHq!@q;^`hux^9+EIhcJ&%%Xk#4IeM&%%k%jF=d#;mkzu
zvdt?H+T~I3*LGS&#5xcW-6ay2v0S(<Ze3XQ33YHjvTQa}NP7*j#W8O#U>mHxR$VGp
z7p7Tzt@+Twz`9@=HX&iWWFC<-o;u?xzV<$lTdT~OII>3;5f;1{Lo!Ej_A-v(&@UYk
zjCx84f*FJvNe`M?!>#2A({qh+v?ET7s5=saS%m55e+f*7d`y^jLYBQU?ZlGfv_`;p
z^RF22IL+)mt}-~GSurQLK}&lar!@|UTju11YbO#iEoss5Ssn><Z>Hk5hqaBM`I)tL
z6*EDDd^b+(&PZEo)<QZo8OXcx^(VY5t5%^axT2&EDu=Q51o94#a$g6R<9YS6Bpxmm
zWQolwY9H&3mHG;?0v3O5)~dEYKN~1`?08CZ!51S?0DERUSOd2f;V*R=hW)BPMTdvw
zP=^zdVc+3cn6=6AT3nwa+*yP3p_xbf;lesJ1=<f8#)WA7=S4zvIOLXnc|!9!4BI9n
zVHNlgn&Gn_;lbY`muJrM4%)DO#|jYjg|}ETCGoJE0!Tfs|I!HF#sDk>`o(<fNdL`_
zVIre0Wz^&ZsOAFya7iPR<#o^+xMkPtH@7VNr-L?C`nv)+tfSTgY17Zj>{Lfsz<%I`
zH*FIFm{$T!-eci1YnGsOk)+o~wkScX)<zo6k;wZ3ZPns!&4r`@65b-?Kyk)cWWd10
zL%{HY=Hn1EJ_|9!9wum^O+7id`_}-+nsyCzqczP_ALFMFXaITPlddR?1H>rIP}tl_
z3v-nhVgD_qlUChu5DZKc%hLkg*r@=q)6WBCrgYN68#lnTp{z(tJ7m$wpU$Fz%?+e+
z-@^Z{$6xyq=uEawaHXHILEc%r7WfL{1qBh1nqLtJ;7|n~Qo@59u&V1OYBjq4JcP69
z;FY`+r#^F>aa-?+P9U0X0mdUXvoJq}vw7D#VtMw$FVoR>Sf5Mt^cJZ1n?x<D#v$l~
zMe}f8X(uki_Gc3I3bJfotK~`B5zN3Dr(||ANt@yA=8YNXi9yk2@hXs_Zx^kH_o_<B
zh%C;CM#hg_v?$3JA1}LTkp>f&9R?qUVQtTcwQMQO&#szZmG2-p^5-CpM?^vY0|q?I
z5V8@*^Q5j?MA8BwdMcwhMsqtvr2S})%g2lj*Ne-TF!_Bjo^+YAznHazGfsDN35A{a
z8Zyi8szs*H<}MW6)o8W6D237Ofi*-V!I$Nc)(V0hOB9%^prO^!Q{)I{2yg{B-Xb>H
zYItthK{a^8<5dhNTh=0xIHT4)qOCWwU=Gv4T~qgNNv!4%9lfzmd^x==OF6ippYJ0q
z><*q#tDy<jv@Jh$^c(pBmso~q2w#0(ypq5?*)a=5MpSXeO=MtnOVso`foHjf@w;7d
zTRylZ1?|z|<v*9ObAhpr#cNG>EzEm?hvR^T_#wiyyH>@!7iHM7z?54?R;GtG$op1B
zWF&*mI&Vyar)zo-t+)3Flwrpkp2)b<LrYBmsXw3TBOrryz3`1QK+8}a1dsP#AiwMf
z@KgLQ2o)*R6mI;Y6kQ1rWm1sBU8&q1DGv2w)2k3tG%Gf&4DWqC8pICR{{9uoIJjp!
zlbz;_A%wf`v=>N4cX(PYmCy_g;K^A;qHV|^1xFmc&U}sN^g*}xS(&w`*0YY)Nl-Hp
zpv7~Z`=A`$ZO0A^cbh!o6@~RSuTGQof4JLhtU^ao+rtBe7pXJ<+6UGS|G1|UyVgtV
z?ol1h5{8pL5<YIZx8_?4(Q^P}{d;RID`bZsx<y6m{nW#Webrk_lUiAgtZ=Jlhzz5}
zg*I4bW4>U6z>J`XR9q51Ey<dMFq-F<ei_v5b{KTwOG_H1$ar7k(fcz)q(hk7DI;2i
zH5&^9;Xig4=0f%n3BO6FI+lP9N>GJ`^wkEtpMOgW9Jbib0S7kdyKx4VoM&>A*1t9K
zJ-GNB8^96(kgxxkyWsC;7@J~W-Y9?(%DZO%r!TL?LE+2mc@2sb_vLNCK!R}p)0gLP
z98p1AMK6E+*^4;0_~nllH;lP6`f2}<urCjc`FQ_NvI&AnG}&Bok`PBCj<|O>K}iVW
zj{81aq=ZsOq7kHPT_vMcSGA7!I7`JX?)z4yilEqtTU8IWzt=PK-t2Dl^ZorH_WjKD
z%rnnC&oj?FGjqoo;jfsk^yJ5~uE9=u8jtn8ox{(50ijj==11Nedz~z)8rx67Q7_$*
zy|`wvAGReTVO>7zr!)?@4t^^f4B0J?6yAU?Dw<`{t_I<o^;aszY$WdAf@?28X>?<0
z0$k5N&P88}tBOAn@-LZm7ue<07<ZQ4Uzr*k+DWLCZL@_Wb;W=7lGODEY9w#}X(Yfg
z{y{veJ3y(UX<Qo7(gT#RMiaaww}nikK`m37RGka{$_rgcswHFBjqZr-1YTYDi{RC*
z$+(hc03s;rf%Y^;S)WQ?U0JP1qW2Y=^>zZ{V|N%;)p~rGGNq#s5OK30AmYSy9|#F<
zFCfa^x1a1%sLlM1#`m^)`2@mnwwq0zv9Li(Bh7c{Q?EhFhvgpMGvFix1T+k<gk4G?
zJ32`5bWfQ{9Y2NLikpL!Fz?Odsg|!?(L<|NWCfdghWMDGKMpSk+C{fZ35HIJ47rB+
z_QB?!FFj1rL&HQ$>ke3N4Y;%_ywVKBB;3am?h$^7P%ru1!j}aG?9;#eSlj;4OI$|a
z4@?9<i_zW;5cR_{?mck=EAL`^Sa~`WC^TSJl$=;AxAv?O-S{lV(%zr$gt1FKY#z{j
zu7!-(NiO!C3Oly4oy!Ycad&KG5dBYH{pKscU^cXX4OT<|(X9S;tUX$ICkI>1f8x0h
zxTig5BtnovPkUVp&GWmO+L=xj?z|eBH|FQmDCZu<gp?lWkha!%f)aQ655X$OzGI-q
zOPHK^gDBCMR>l(fVaaqxFCZjcg;0%Ld71u>ylX$##Qo2=Nj=C-Bxx@H+y;b%I|<px
zftzd%A{1v59#kL>kMw#gsss1h(yiF24=QxU>co}^Ezi=<^!5otm6piWn8udKv%lIG
zryLhXDn~MQo-#PKYy4(xwU$ofyzAs+_2eaQ;|0HblLgi%6||fFz#jUAWTjhIfGMU6
zP6OTUWHFyV$Pn|nGo`@JEwevF6zF_GoggHx%9xu0NIZ396mj(?^lE5y@%n%iTk-kY
zwx44fMDD}XbnH~@SwjcS{UU?h{=s5GFiO-0tSU+{%2#5cVKEneY$uO%4;oKu_EbPT
z<w0XNmuChRamd(HQwo6Thm2{VS($oyNSJQEfcL)X&-Nt4dppW^n#5lWZ0#7Og{JIN
z1A8(?84H8jc)L6soTiLR`hHq*1!9i{!300ifTLryHVSBo!FD6cM1Bdf+q(8Yj<;W(
zM1=mY<LxZv6D2Cj<n}`>dGX{`luxG+@wNQ2AO54eMBtu|#X|3`fvx;R35!i^C5Gzg
zL@`uXMQ*w{QZ93bIv_-Y!JdDj4Dt(r97qtip4hHF+4z@%jU1~~cR%?A0uhr9=fu1H
z5X;VtRqDB1F)-(G*hQ>+*ua9vDNPB`bDWY)|F0XTjEFXQe1f-eum~(lPdfP2Ez#5)
zZ&>BrZkGe^(OS$8LOx6c1a8Hvx%zZvtfu}61KXCa<Td;IJgn=P#6~7v-^nB@6UjaJ
zDLywe7u|~=FS=KqNGH6AvU{tJ8Q7Zfimpzp94!*Gfg(LUA`KC=FyG1NrwtiM6+VYl
z#7E-+^l`7iz<eesQJO(mkr^hyV>{rbf%ToBR1Rwf!pN01A`EX!#nK4bEZWLQL44lI
z2}(a_=lMG(Dyhz8tkOHL|0LzMb7RNn?PrU5LDvj?{~fk(s^ckH{LWE-hY>;2L}$!H
z@+MAJrnqEWt15KUq~4gIQN&Q%zG7}_Sr1|v2+CX6L^lk`A->Pa?|%4(7ZxAIa*!?=
zjK`x$X!7DJTk}7vzeV$y>b+@Deld@p2~&-Yo2DG^Ix>~&+Kx#Adfo3%A8X}DzWDf>
zrVsXdr$1gPI`~R9Vq7U3!DUu%W5jP)xFWF!2_Fb<q@S0ebabC0DyZ<YffZ&bbu;Q5
zLL2lhO?t#cv+I|@0ES`=-i4=%dr`DNa3eAL!$*qI&lxR8f1(=9Unm~(*8SN~WNINZ
zO(~J-2xWpT4m({KqS%|pMeH<>+1Hs$h14E2ww`ADc`NKE`FsN88$@G)R?bIU+KxAb
zCIF=U;3&<<WV&a^1=EGxQx1EfPPx+&%MtRUfz_F=1Z21XD|?xH=?Ib6ZO<qgM=5i|
zWH%;`5PjW6DRwe<7ak}TD-c4zjQQI~(nVS$mC*NjNa6^B_CGi1-_@;D+8SK9a&+I3
zE>|&^dpGlDp%qi(D?*Zy=55fODhhjGaLU!Sj?;F>?7^Fv)@2<y@8}U&&fj&Zr167*
zecpe5sB1R*z`_R@yhCn1l@n!VH>w0LG|HQ9aLLW@H(-8;O>Z5jX@K&!Xgwd4C7Z35
zDB(*wQd+HBvXln)mq6z)SvS+=vZ@*G;0Kuym5)Iam(UE`0HTg)x=Jf>zJI&MnvYPR
zd^TJ{E%Ae5?~<w`n^+hup~W`r{{CdJy%&3jCIx<-x<Jp^V(%t{T4LUv+Q}AtHqB2{
zXS<;|^e)P0JA@WidXHft2pMwQd=Q*W{VeQEl(~!qQqlP_z1q24GBD5Dy@Kd}>Qe*D
z#rOL37$E9XGnBTe6+3*k<w-OGw+S=?!~gw3;(fmpwRir`du*LMOPS_U;WoQCX_~+P
z@3&;`S|YbE<(8w6nTV_DFBsVMS)kpg_;Dc-SJUHv!8h?qxSAd!+Zu@07#m!4!%#TH
z>gc5Pox+etX#bQ#NF0C^wIQ$8Pr(&&3h|gVFeCCE98WU1Lg0ArSBc|x7&t`1#~rA$
ztH4;rG5<tryz@D^YV7>TAXklVVV?fSs!{t$ViYGT38hNxEEG6N7kee9y9~b}nylC!
z>lJEpW_xNf?WTcsFe+m-tqO62iBahrejn0;(!Xy<>GMihV5p5zgqus8Syb1$lA8TS
zGG#xC%B6r2k&|m`LU<J)jLXU><K($0|1e(pz>D0<CEV7P51M3xix8e<Qeri=)*IL$
zld@Rz_P&ArV^aFLDmyR@@6`Rie%`{lN~Cl3HX>3nA?uxnF13AVzE4|xFwg!?qUIk$
zN2nF%70gpIoHfxu8Q8!DN^9@KXwKdX(+f7y-UW(9a}kqg|3c-c#vMOqeyJR;)&f}z
zkI?oUHnCHLp{w<TRcK!vN`s{>Qo1#0un?<Ub)0qJ3n&-xbx~crvRU95`?8f#_U$62
ze?~s|+3K9}0uf+e5=3>*NXR#U2+>G)DVD(vilwN#4O*%Zo07q>V}pk8kmYKh%L};>
z@{jI7M_7^c5qW<^-XM|?H)Sf7^S9Q1y#*|XH;WZrxm0AMT$z~1hFqmagDL<Nt{1o_
z%96!CBG2pvfC~wZyQ|6QnJ)5$q3nuWEF<q<G_YTCVUHZckH2!2YF^C=KL&bXPZ56+
z-N=+c*RkPP1h!{NqUI^=v9FkN&vT2ASa&hvh|f3wz>G_jEt(O#VQPJ)RM%u5hi&(j
z@`I0o>RWowegdG*uaywz(X7MQN_h1R)5s@rB#F)rkz&F{7g4zP_ap|$ZaF;-_<i-Y
zlB;>L!NBS+RT}u~sp1ZpekEoW%Up_Wq3V$SYnCc)!fKr$Qr|YuC?x-b#e7Cb<#wDY
zp4ML9p!?6S8(8gcl%%NNkE303$*2y%IV5(n^T)T83wBCDj46jLjAGtfO5{#FZ(!%Y
zQS>gJTbbuF#eW30V*kP_TGhB;uO}U@J<*AjFaqw*A4Fqis4-dZaR?}>b1{vS+R}~J
z>9pV#npq4W>Pv@a)Q84MD7L=X{AEg%^CGrunKH}ySC+6`8R6TMa(R?6$e|3D1Hq83
zxhs^!#MJ@9l=(14*Z{fsk9Lr-5rAG6d}D`AFKh=<)18}8r8<m`J=r0ERw&hcG1ZfD
zu264biFXn40i6(Od3FVS=;Iz3Sgpm`?KI;C=-HIT*)`a-l}bbJyu%=Y6KwzenWE7S
zrwz=!I6E|8$YOLG_D%|RKC!c~8(Dyp;g}(Jl~OG<ZXqUtFY$S*Fd2l0G!-|qUm;2P
zoK-Ln_GKAA#k*zfSp%-$LXJUT)Ss@}=ufdw)EexeeP_y|$1~K+^>tg9kyXE4rqX%j
z@%vDEtSC*7Az8Ftjv2(hG}+n$aF|5PR9rcM1Wal28I2Lh!u<ifGc4MLke5Zh)wI5L
zX%_9LNFu5pZzyC3`TqNxf4L_%*zhp?QEDqaT(r}h+VO?wLbj7=+AFX$*Mi+n6FkLy
z=z$!f&rlfxlaLSQd>#B}KT`4U+ib!aVTs(n2*XY5HTjYt3`wDT=_SG7AEh>%(12?0
z546-BX7g`*tmanL@9fPj*YBjp3KAtsp@db5u2u$UI>U&G_)e)&w<-)6Qfw3AzQDE-
z?kK?9Ab5h^+zOL|;C%td+6=avb>YJ@zf*$bVTZJF9U8iCv+8gr&OY>lT@v&?Ht1sT
zgY2))-pG+Txw=cbkFdgmux=*l*%EyBz7_W12Z>LE`eL;Y%~~Aq*$XtlP~oBFCDH_{
zxX5OS)%*QRj1DZZGgx7$mRLo}A?B0ys1Mta086a6x)y3J%9qlRYG6VQ)aCIadp~5i
zA2wj}-WiB~-jK=S3`FWagFFL~w$&icK!g#+t=dIuqTe6~aE-VZ$-pu&CjEM7H62$P
z<Z+0gvj$eQ7RMp3LoTYvA!g=7&5Pp@XE56Z@ib7tbR41=lF-ZlIu7yYW(d+?C7`v>
z3Q;J`+*AXK<2-~n3PBvnqQYI@(N&JJdmW<Cs{=L)S+A_Dox#$oZPJ#)RgY6qu{hk&
zZ?h!S=2&|hRhoJE*P2z;gdk^+^{^w~Y%<V0i#;`8<A-2o+@<N~H)<0wQ;#%ELPQQ(
zlB@O`*wZT;I)x#PDAct!p=8+q-YBr=qgpq1;TxqHxa*`a1N~Vku2gIs112_NcUH{T
zl#OV`*uqPQrvkL+CAen<Xh{v^AhS()r*I|E_uDCWq&N&*qk2z)z#AyLOpdNxz>l?D
z2@60m_!jmODIejljYn7kR~9#&N7^pS?x4Xju?I-cO5@Zq5{bp?MpGq04#lx$mRXn(
z>&)53w^M^Zn7}2P$7)$8f;i=%`D3Snjab{IQZh7^Lp#TDgQ@5$Y#E5jT{|%!FwO2@
z75V;whAfmOB3!O1mrfVvjv7)EFzGR*;3u)0Y>q%k80AYwK3h)-)#YoOXcSnc)61`o
zs)P$!MZeD1u+Jtr;`x^y{JejH`C)&i>gYKGYqA+fQ#?>bO3i6LY}#hHVy>){^+cc^
z+z__Qp1dR(bJvdw@>zmR4hwHGzn`PH?<3eE34a_fla8H-JzFr27VXcNS5aHw<#S($
zmC6>SUg+huvg=i<QyU&2ldWTr4=jI+GEmcLt${^uReFW}zD8oyGKzA?<T>VstX{bl
z@%8N>iFR)Vm*lQ7usd6oD8G-?a(k-TQv`4OEL+<~Qx>_Rm#@|Np88(a9*A5BWr8je
z@<0Cv1>Hp2``!FOY|5qQ$W6JLp>At2eJ&>($3>CeYljVldPu`2T{Dstp={>tbz?Of
zpczhYL!j|2{GbiHvSXkfAW*{0o0#WzrFQcMs<xOJNr<FDDOle|c89rSc7u&#^f?9h
z%xn5-_a0{OEW(*aAalDi*meGDh%C#2gfRB(%$6uk%hd)}??)Vr3dD~-KPr_gzW!GB
z_`?WdJSsQ;N2Q_rMu6q#1^OIS{OPp=q==mgUbf$XcyqwO;&&*%nscbP#}0%>JzHg9
zvv=SST0cNu6twmsiM1HOyF1|Yqvk#G6hE&eTWQ`d6o2R7FI&$IAu*TG+<r2Fc4vZV
z#7y;ECGqT6nFx}Eti`e-clpYOF5enh<K-(OKTx~#Fr2bo+(PF1^E{=GxA-23ZyR&5
z{wvn?sV)-!h6J@GKqbNTgaEx)xS}-C^eLh%!zUZqgPlr7CGJG#p>|6{IFmjU9K8&D
zAsz>#&8C1(Bu;9FN#zYAB-VTv15dy}0O=Yi$x}jiQ8S2R#rcC}5Iyo05?Yd3A5@7)
zB$5$&XqQqiq``E9?a`5mbm@G{xx^K>aTafyfi>H$G}m0s#Qfi_Xf>@4V{Ncosa<-*
zGH9=k^5Xc!x%fZ<^Q{oV<OIaAMf>t|^t|}dhLwWcz~|LGpebGw`RQGd-Rjunw!WT$
z#q3c=)i7Ce^tR7|o(d1Mak7e>%Txn9x(8G7UXFo1-h&lZY=(hV+lv*^6hJ!fRrH#}
z=)j`AaMqOt<mg`H=|0VnyAOrd%|_mR0K7&uqEG@LbN4CjH4_23y-%sFX@wsZ_bYxe
ziy$z`)BxGN%(Kd==IC;0(ZUcBCo>KiK<f;VjU^mVqC((2ygUWmY<+6R%UsJ^umza<
zoBc|?#^2-Z_`>Sa<fXHRVk?Y+RK*W=WFZGp_HrOmb|0iKmig#ZnFC6k#%~HH#{tX<
zGni=10Y#f3a@9kwVr;9HRk77U!4`gwm~%V<E2?QWP3Q|cc0`MOaoGy7)Akxv0@=!u
zN>20~eFzpr{4QD);P^1M;0k{fwY<e##WR4A(bC>T<Us|&-|>R+Heupa%vZcM>#{-M
ze5GFM-=BdT*317VqA5hqVOv3P+5-%_-R1w!AZ$b=A&D;a*@JpC@Fku-!0Bt)w?E`7
z%``(lgE+`nd;;<y_R)P&|7mbPk%BI%7@lk16vUbwR6I&YGti>3WZqhy_#hJZ^CuEd
z!k85c02#HB^*BxRs9U~)EjS1z5HZ8R_(7$fX2K*WfrDVULs<|zhm;1s6(`Bcwj#`0
zz1M&A1W2w!N(aq`i70kRiE1}}A_#%lR(QdQp?*<Ae(w4b0%tJm)zOPL)6I;cBUho^
z3vuT@GH_(TJq#eGl%wLYQ2*~?v>a9<w4#p35b`#u10`N?SovJj6FOnY5v8hDOYPJu
znP=q@C8B)n0+bw@XnyVkAIJqjH1R;+*)Kkv`5%Q|c?3?=9aT~@=80)|4Tec0yBFpK
zuIb=e+*$Tvo!<(F17WqF<zdUBOcr|VLI<v?=ife+%cw`*gwYkD3$SXEN6+5)sgCWg
zBsOzi<@}2yY|F8PrCsl`s?Xpr^gHC3QfbKL_OzZp2D1i1q{l{C7yFbKObQVvpIO8>
zU+*DkY91gOZHq>2q{1doaa(sF)DB?9XLV0ZLQ~6+DOLJiZfDn&zPKsMinB!aO*wa$
zO<n(h`ga(b26l%f(go{nTbpv18H{T61%@40DrZ!EMbgnHH_`c}<t{cNOTP|s+6`_%
zCy!eq>!*XwOmXE1hzTx%p%VD$cL3e3z_Jo}i-1@i$egdoiQ>N!u(-|w3H*+Lr8BHq
zPXh`MgLqqdEt0TFf2}(8|4wm9ZM9DfxON%%OwLo!f(az&%L-#0fb@Vbh+uDY_?Ig-
zI>ysaGCES6--$ZfiR`c*<Xg-(D%n@yl!`ETX|;^7R-l&mu$E`@PbhUu{{ZciXv7)m
zIjJ9NhR%b8I;m8PY6fVD9f#@wkvTlcOBm%dKn_?iu}#O;ahYpit0E0S6^}wog5S+r
zWRWv5|0IsBjzW6bQ&2h0@T2J|C8DBM%{au<nlbH^(nZrB%^yFd)F@XEZ583AnZwKA
z7(Jy_saS!yWeM011`PgU{)#h{2j-|-C9Cj5Y?aJ}_$-0=IDiQ8!yeM!_d26Q)-(VJ
znNs2og6bkG&N3ovvB+bw%`@A%z&6Neo*6{{Q$sc98Q*JY3P9A*nez5_FUgw7^d?j=
z`K*$ldH98a%|EO7`y&^&;+EPozDl&S$~etQtRowoQ`&k|>HxV}mYg$Q=GtuTIfTI9
z9&TV;&MD!cdxlGbzbZ?0-Gr2}O(L)q%MTpf#5qT<7JFc_Qm9#sOAd{=x;FGEUK>_|
z5GCxJin=0Em&7J4$Jo#XIQPggMt<;xZ11=`wYPN%nS5c-T37O^GYA7_Z>9c;);c_E
z9i}-7Gb6M7=7@~tXqK2mFUm%ttktVh@|Yzimw1fcf@3J!^My3)%YTvRe9?jv9pbk0
z$&bXW>m4R%9R(xM)X>%hImE2ng$yD_0pL``DU38YWneNc9FNK9Dsuxo6<|PHY_d&J
zK!-`_XsSY$8Gv?_&<_c!$_GH3O6UvVxSKpKvbjhJee3|ui1d`;KM0I)VKwt#BY=eL
z)|qsF5+-XyWw%sB5j8tZ?bZe=>QP*DKNU5_&DrRH|2hdZQC?xi2ofyJP%}GLF-1a0
z64chMp@7;m5`r~_8RHM7k0Ega5t4Eq>>@|4P;c$QI*G<giFkPq$z_1Q0N)-1a28G|
zdjlHtf#??QTE7MDLn#zJ`(!X>p(FEs9oBnzr{oeG#EV)JnJ6;E*c7fg+KGPERPIEF
zVR!6nQ8>QWVRI$eVz5}~?!>Gk@d)`J2v)FlfyG}|>bYM3-Oq`AdKp5`s#msLRsy}h
zoe!->E^t+WHd%tLjh~gK^<1GS>^7nA!&^gE(K0t;{#lENfiqDI#=E%6e)@wTC)W0g
z5}C0Gzid2fa_eLUc>|FX8o_PuV|>8w6(7O$5utueE5e7b`caKiDytv+D8*WV3w^*M
z6%~ZiM@{u(0Dbs5K~o(DPIw&N;~!ct7<~@nXR3ve63-M88c~$Df?Dt<eNeO$rGysv
zIqjysCi>`0DWU2|fPJ=S50OGFK-t#NM;-NJ;3@jDcCj^e-de+8N~t9C`NSt?9SQ_y
zuWXANs_S3M6QI@=MWvh5hix=TvR(KIBlkJfi2cX~=E{+a`VH#WZsd-_lS3mnRYM~;
z4BmSy1N6U&c<iUJwC$^zxfoXMRi%~Y!%wh3bycZU$%V=tf+2`&xyT$W-c5yY_xc%I
zG4Um;xCW;P@le%o(;P6#!WF)RNmEf{B<hkvcID6L&JWN&_IR{WD~a-PtmHLL9#SP6
zoe3=l_O*5=_8M>rD^bl(IC%vwpJUe9QDu-?O(ju{o2aHGRC@k3;Ia_9%pR8-Y9&#>
zk9Mf!C-tHYlM~_cDfG4#mz3+k#i>L!OBSlQ40Nofg<8!&7FuTA$GA$m6kG=`W5003
zrL0;>)D>8ob{+bWuF3~pMu|$gi%K%VItU~D1-KOCI94-pfr?9W$7-sm)!cYTxE#gE
z3S4q;D52i%O4M<GzN|yD`D19;8;Z7^C{!1Ph&4>vA>R9Eqgm`ISj9^>6iF~;H}aT_
zbyac>E^T#N)lkpM-&BIww7aRLG{1j@D4Ls!f3rHp8M?y-g7cMSXz47@W|lFZNg#>$
z(EQyq>80%bFJapXV{g&M!y3x?RjK5C35!O1gMB0nEay9^ojk^4-67jH%C;+Oo{p5w
zwys&6mSAlbuN>k5nuq4u@n{t5lrrY!Sf`M+(CsZX8;@beWjgq4n;LBXO+{C6Ef!^o
z$2DT9Y;sFzpl7#kDm5E^<N$VSAiGEXDOAs#uKI^6He%>)RnBMex0L9%=lh{fTEAka
z9W;RAZ`Vy|0<63G9!C6jY=uO;v57>wN2Iz74kKhc4*d{}4@F;%VsBe3mDw-1l(>$g
z3dQ#5{tw`7k~{77XlW%zPHvDEL8qu|ribQpz>}Em0Zwm{Su^c#!go0M0~hz>FNVMW
zZ4xds9GixL$`;%v;Q}M>m)j67e^J3h;1UQI{IzwLIH&+s=u1>_6{ciD0j_x%Kg__C
z0&5j7G1!R4!C!|e3JR3E-aWG%v3LoCF7l4jU-JxW+1YoLs+!S54Q%Tj#lJP5fLPj`
zhDka7pl-?NtosNCXeEpGmziWTACbUdacK3SdB{WR{zLQGH`I$fWPx3Xzd-#i=8Fz4
zFMBca6Rbg!MVb{uU>4rRd=cd;qXc@p@~+a-)&CN-wE3<QU47mQQeLhH6O2Kna%f#$
ze6tSX@kF>EtP!^!WpD=So)X?^-$M+K_5Ox&6LDO8sem9Nv&mAimw6PhS%4+V8=`kY
z(a_0Y+`fTWhib%3*z(0ri8xifKS0m6-cxENRD%PfZ~&I=bUwTXE#FPLN~p!6jl@cs
zj&OejV4(qjtQM^udXo_KAM%?L5%=;zN%SrV2+->eLk3%|@G9x{0;ZzZ0qC)qD{TWc
zH~b|ku`S^yDeQ}e2$gR5AE>0D1fD{{O1c=8W&#zG<<EapYIt{o6VCq1q(?L1g1@g!
z)pQzTU>omazw*b9;Kln`q4^9nuyPNS5X~S!YCTW_8%@9n!Yhuy>e!bte_2<K`A4s4
z%)25<2uQn52jKpZX%CcIal3yj+36($f=)k!lL?*PjZV)1Ozrf^`{?v-G^`otD?8oj
z*YW5yb(T8aUUu3aCBTuGpv9f8j}#l@d%{NO{}8biv(q38A1XDx#$iR1WSkHy1V#)T
zPrDu})iOSAkEX#~(~r!@_{%LITP;K97oNUgUo9AqT*#YJ1n#u4)vK`Zti{sH8n#qu
zyy%d>aL*-&Zy3^8-uz?s!8umA-B~}g;@#H;`kfY|j&AtJP}d|`n!U)e>li%<h4&0w
zBRF$nJkAPOA{U_x4k+)r=FlX&U`9yF_1*^dhgk`4wh>aA0%7BUd~(iHyfI_$6a&`B
z93U}=G{|>cBGAd;WOa`x88gE0`Y>wfTnHcEIq*hKp;9O2J_ZXWd1rr!%<(9S&2o$t
zcyiwxk?=AK3DF{94D1JUAvV1XDD3}82}+(ljfU`Z{6*K>W&f7$YYR?5bV~SWtSB|A
z+Yk7>0Lh6O1D+AnwM8*opP?7357BBG_A;;~k8t<Q7bymI_K^~k(F29(iC)^$GjG2o
zRo338RKpthYO%z}B#~k5+kS(g=}ovs4nirr%GK4VNjna!B-N>sNk8qjf?`p`I{B?G
zQZHO_Nz0{CsF{{av`iK2qU})9iKe!QhK}ooG%WeP@TCYCUA^<=<kAq?5-dL_nvBGh
z$ksq+%R)Bm(ov>Ak?Fy9>8kUK(%D}{iud4u?};`hp)eGz4Bgkh8iBxsJq0N4lwJib
z^!k;wpT||1ca)k}>cQj4i;}pI3{;00R?k-0NCeTH_E-tZ_(GO$EK1vX!_tz~1?)g%
zuy()_d7b8-DXu30X(d84GxA6YZpLhRo@n$09rfpk=2lODDegp1ht<5XJ;WTUt3uV;
z*0STNk*wp0>=Lenk9&wUcAmDx8v9&Z6~!BOQQWrfZ{S$`?OaiOqFS7c10hf5QSnkT
zo|Dagf@_8rpCxQ<ufmtJVT)axW0uG>?Fe1BUbglme7l4v6I^yf!oLCBx(qjI7m<T6
z=iV+?U_d)(v^TX7W(Vk0<b%G|5PR5oR<R3UWFoasB09Xk(vHXdi%*q+$a^T246y*E
zAAI@_aZKD6s>l?#17Bc`$KCy%Se?0Fdxw_poX`!=GY%FN3Y*Ku3ZCS3dJ4^Nf+Vol
z{E^r>5}N;6s)5BmQ?!APXc~@%aveG!*Kq|&^<i>rgrgq)klt^}uXeh_GiwIX+UPM>
zK%bK*A_rH^R>Fz{orfYh0!7jliHTCVzbydP#mc=Q6}D6E-*`ynlHoQ=lrQX~>X)uU
zzqmcPL0~ii%KZ)Bv}nRJo3v0Nw4a?kem@8uhh*IPiYY+1As5!%Y@Z#{o1Td6c2>Ib
z=`OI8*-5d^!(`;cnqeg6@L;PMGG9n1=CwPnzDs|Z?vbFTFF^YIyn<IaoZ;fpj3vBQ
zy164i(Fj_9<!dFfoNY|tEPajp6_$Y&AWspB;G8bbDtO>gtK=M9ZG5jUgu#>u52tiJ
zY;~%la1s6>$RiDd7>1wwiO(Rdp*G|G!07HQk&uFfVSgwiVjp+5mz_iBTOxl+u!qnn
z_b19i%QQ0UFXX;adTKrxj~((iN|PQYx7FZi^7!E3k8XBnVUbUSMXqjm{R>GX7kqGs
zM$xH;So2ow`I315>Nn!2EY+D_;%ESS{zj=$N>Vh>>)$q=oLzgsQ^JP6Ytv6t8k<)q
z-nEGe3qoW!QGf7Vs;WJl2sR>$;DoThm3qPUFyKnV`EGBZ^~gcm-|!qc2NKG?>C|Xk
z9e6Mx+hYJighHVBigpqi;+*h>sYU;>TYoFzVfW#3!YoZGN>0o=2$_Ww7np%$s6tE3
zheaCt53UY6AivKAP%Fq%yp5q96fep{LibMSBQBwIz}6~1jG>Sd?j8JvUZSBDdTGB9
z?+6uwmklZ%FyXB0K$3$d!UVmj+`p{w)=BQ{U)kW3+yk0C@&;C`mdNi@9f{^-Y~@AK
z!7k%H=s(x-<t>pfV8vP@y)pAFk)y!S4k)seO9^#c`l>q$--9!OhxzsG9Cb%wOX;=k
zDA`haZ4muW&iMYG$hMz0wroe4-}aF+DH$bg4cHwfXaSdX;(uJB$QzY#Wsk)MpSVKt
z@rjYO8r>q+SOMH^l?qBE%FXKZ3fPvB;i8dsfC5y4Iw{2si?17^QQIMa{a6O8N+awY
zwzy0l&!15Scih9N@tk!MJ;Dp6J{L(4UNnuhWW96o%-RenWZlyX1bu<ML>R)b!E+A6
zj>QwAGrpAR=a4RCAu$m+3BFm6^<Pswa55aKuuJ~L^g>u_JOL7s_)L?GDdBZ^U67_$
zd429*U1JPi_D3bSxrLrDt#B;fx$IWw+4PKQnmDf%O-)eyGoX2_?Pphpd@Q;wh?19L
zK|rvVn<p_Uo|(<TrA5Qr8-9Gqw>fJ*gCbbqyudean+yNdIpfY{nhV-BZm=22`-hv9
z;D{*d06}m}CK+u>jVP%;lDJGtvn2&n5-!Hl&6i1CZAmUj65<0-NEOvB>P!2uwEOCm
z9+1c?xN#rN%dS`#yYU)cN4p{fWX6;6wTk*#v`$zX_jBXn8H)f_OGK0O@hZMtlJ;l(
zal15SfG|3I6^GR+#Qsxp*CgnF+q@Yt+^Ae!1a|_cxfdfv&?^OZ<qUwx%|!oIZ}dSp
z9mrMDKJmB{({yR1Wj>{N^Rh!*f&<klSc(VI;oyf@=#=82&0B2^l=FEAisDFnGPap9
zj0eaED~>-R<OH)$dQh-K0QnVsEeP@}-V;AH_{j=N@fb~oLD&o|%>y+T8zKw^KkC#v
zNi0|V%+G3ax*K(+1QaW}C(z|sj?D-F10)-xpPn$VNu_zDW*Qcit4i}qns`)npfoqQ
z-fRIzi@M5#G*4Y{+g%wRo#A@|DB)<_a2WU9vEZvAcJ|j{Vjl>yAs#<eMf@3H!1nCV
z0`c<rxkLN}^)-pdTa=+PMFu!~sRHtBt39_2Q7hOlEAW#&uTUB_yh9D_N*NwktJiVJ
zChbNTl(f8z2P%ahBYYtNM{Co=A&^gRQc3&^+!%50ykV6TXgP6+bU(EWk67_HHI8e{
z5)5pfJ5Sb3s%>Dm+<Abv7SiDWnY}7z8wX>Tv@EafeYrOh>>P$4AtAXe57S&Lr)Oiz
z@&<!Fu{KM@n`KrX7#87FhGvag*%K0OlzapgLFuD+=OwA!@pF%rR2xL-ITm{*n%sn;
zcQ41o{Q}Ej=H|2rQ(bs1X%#RNqnJ>Rx6eQ!(Z+SOOFEnGep_%CKqDr}pO9Z$k%0Tv
z;*L77jVhl!1r%&EZM<ZgEULz+dvgRe2pf*B%Y<ke4$*XXFh$DCI~$$iNp2-aunOh5
zzvjU^9SdyKGe*;{Gmhw%=ly&uK^>8_LCE!XwSQ?fa5ADikN0<jId7*ZFljO6p0`6d
zjt6f#W-OFfiIT^w10+bDKFp%cLDdK7UMQ8!I1VUDP!^WDB(wKV#F0+N<Gsd?9Wyo&
z7e3BLepnM!)NWKC^f$1J9+&~oIv_65gNJ0yZKhWCm<R!ShJl_H3jnmzGam_{=h;IJ
z^!%2x8+B_16!d&IR?<^=M~%99fLrMqMsy=RFmRxxC-i{FH#$L27G9ADXokMkF<nKj
z)9l9@y08LI$N;aA=ZBc7B_@1w&R~Jqt6O%61t9^5-9G4m*gJ{XE&&B%1u&>cK0KB1
zRe-;TSjz!6#FjS$VmP)5$&vVviq=X{tF#wy=zFz|{YZ)n>JGOtur6M_ZH5-3Y{i-0
z47TDt^`;%pRVB_H^Br)e2hBjtngR-(N5ar0od1+KQyBSsIG^ih!?_i<Cs{~EjO(Sp
zRFrG9H?XM{xxqg*$sT3W7+}5@Nd|VMBJb{7m}s9WuCKV7h?({QS27@hoeGZu1$z$K
zOF)`p_Q16S{DzP<>Gtd+DYjTnuWUxwKSsmCManLbGFeUe7k5GyeoJPwNq1hP3{X>?
z5!P1d@^6MnS|*ZOt4V$6*399Mj8f{6Aj9o<XdUO*Ktrnz_a}&#goq2(w50$MN*K;K
z3hztzNHTWw!gDmBMe7nID8lL=N|Y6Pb1zM$)(8gi=G8{NXyup<GU*mTpeOu9Gh#48
z(6$jL=(-qyNXZ-V_BvWZ6h&7r_@^DptK;wufI_^rP%F51JjcRJKD=GV=d`<kT5_J5
z8Qk51ytqdKP+UVw^~;tIN6VH6p`e<5II<U|K^w>#Xl>DzYFHqtC81KNs)ehng-v^f
z+%Qil=j7qEpD0Hz_`hJD4At_mz_}l)*v6^lemX{W=>ep#)bikr?noyptQFt|UEz?2
z*_mj>0hftoECakeLy`PE5xWBERY7Cn8qwAhzK#0tbV##%L!L*fu94?;Z4MVpq)(K+
z4NPuHTYVX#!lTHKWs7Uc3VT^AT<K8Zk!t_DLQ&s%S>Kg^OCVUzT3?E_K5Zh_E0O6X
zDr6UYxleg>cVTm9f~0VLlxg3n-VCbHBv)(OPm9&sR)DZtTPD7uvqXltEPO#;(tmQb
zHk|Z@x>_R-6LFg<uBj;G=KZgZy)Dz;Ke)O4?kFm8Sgk#%0v+JTt7cS07ByZ)I(uqW
zMa?F+N2dVy1ft}lB&U&&gx_2dD7WaX@V6iVR@Ts$xP~C7fV2ltar-w@9{+>0*m{yb
zygq~~EgErWghb!}@JQQQrr6n84k)S4&f)aa&e=I1jaip9w4SF0<5$3x{86;)55|LI
zW*{)4AE%lNB6*RE9L}Z!e;&|!5OP~1NN`)9SbZ8umzuQxZw2LFtSU!FEDm=jSgrsZ
z4lo843sU-~)#$@8g!%^X&^kk~9cb$SaW-`pPiq_FVUff=Itdz92U?Z_>(=!A0BAa6
zgn?}c;0^Tq-pIGGL6H?SBUL9^oqX%B5|ul?3c$hwG2cvXuP>vhP}EqW<)Jy~L+2kI
zbjvcLjZt@FJ3*ma?hci@B}c*!18&tVU?#Ch^H>AHO26a5cyH?nMNQ`jDG^YZM#*%d
z&>bfgk>SwaI(9S=ru){GaQ4%W*&#4(D)Cs&J_D?yO1y@9{x(tybw?SPsS>YNzP|yD
zLQrhUhqTMD#Jkn{1B&&)7NDdqK<1LMi3Lb?A=4i0rX(={8-on2c@VFhkqU_^y)xJc
z{0J)ws_@kT5=b}OmmC}6FWIrl8p$gCC%Jat<n7IB>^xqJvAcL2W2eSSSt5srQ{biW
zi-_RMO-O}&X&3&F6bQv}VEG{=vE=edx{p0~&{>ZDCyIIcNBU{U(;lc>E~jFH`FPD3
zoqA@gDUSE}2I{0QVdQ@5Q<rv>6|5|dDlToN<~*=7A>Ion90~c{eUvdX8By~gyiNsI
z0-GjBQPRpaEF=`{ce5!@0fq8Tn%VfVAl#^BkG3df*``q5+$W+bal+(yvp4i>Q5US=
z+8UT^7;mdN+QgPw>rI}K$9t$LvW6_$3owA@h4DCt2V!!A+NHQOR^udp#t-tCMD1;C
zuS3N|T@Mgp_}6aXdsN*PTVmT)`+!o^7kf^9hdVZnrP%z}co(t-s@tB4SDbG(QmKG5
zZl&3x*Xw=!Ho}i$J?M547Df?##&=-Q^qs!Goi+)H)YezK2>UFUKA5+xpfYcud57f%
zMUz&#4MTx?SQ~llr(jFS?M%ORS_cp3$_A}tog0!9H6%lnvzXWHwE9pX3BSk(Cq;pE
zA%#F&x6ev^kF@_T8Ibt@`*w&;YDwW&CGaizExEqImyWaGk2Q|pLrZ*@%>SS`owl5C
zZyafWq#U*{f>%t@L+l<1vrXfxFg}G5-vibecEqp@)V$Eqs^5zq#D4f(=k&@m11YX}
z%FLMx_qP@P3Px&3ByaBd>-T<eJ7myZHy(|i>)4n`9_zXcK(;!Pr<4khgSA(KZ5`1r
z)b(wBgA?mJqoZ$zv`?uzEcPOVJt!7JVFL0oAgVnmj(eo{Dn9D59#xPm`RhkvQAvGZ
zE`m{7)BtBm-~u6;WYTqfrgJj;xRUesjrmvNH9y?CfMo2{wlrY8=^n~A=EF##>Nu){
zU5s=&<5PZ`5K<>3-jQBAV2cWRg%;E6-cw00knY4&9b187-sd4d?a4e0M(PD5c-~rV
zqf{H@o?4C9a$OA|i@rLcR;i}-iYcY>t%svTS0_~Iv!rrK;>-lZfjAS2iF3HFB#!rX
zd*Zm!(YKE9#b5*_aXxwi;>5UE*z_nKSoR>`7VRGVWdn2*12Tvn$~L0MBEU$jNi*U(
zSu;@V9+4=n2D>la1DOd(7@2hlln@q6!cOuZ3x#k9z82D%4&06;x;4z$MGaE5L~67)
zolwOIhG~wxl1{w@ZhQw@GPEefLjUUAx5jNWE@Esgk=uOibIgZe--?kbezk?Itj>qU
z6z_(}xz^rf_0UU;g*FxaJa^#KMcirB%(Nqt!!mxxgrGez^gEd2HxmCmBy`MFe2MNB
z3h!&yAt-3v5QhwAnIY&UWhd(n`p>DT1wtELtyvDpEW1RFl!dnSioy~tI65RNX&FK!
z^>fQB&QeU&GhR5qI3hWubrqypk$Z#Linfzv#nlNpxm9>Pp;JQV&WHmG5JM4$;eg>~
zlSbHXDk(bi(rWTj&VheyCMGD*i#u3s1&IFhYw>EDNFN;Yti@xJes3kJj-rX@^}7z-
zG!mi(mlp~l)Rn~0^vA<7X>xFrH|^4x;x->8#@QRO68#p3GqC;M9nogdyjDd&V<1@M
zp$Is&Xh#4%I+{1{Fy%F5Vf7gi1t@~~HdXz6E<bM}l9y5`U;?SP)lV<^nWkorm7g8)
z$t=-4z~#tg78t{;!CHH90G+V9Rh%i`4!7~&VFK8^oA=NZthEjT3Ty2a>>%<4T$b>L
z0xqAmIar{<ycqun2E`enw%QxiU*|)KS+dLMI|T@Dm#>g`w#0=<Jld<ao}`iVyypc2
z#qj#@8hHP%WAXKQO--Lz18Y;82f0kR#J0xr%7aaA>-N8obgk9@g>)$a1=5Q<Iw1Y@
zTgp8n;sp92k*@XHiuA%Gm<CU4^F*%)h##_IHaf_P*{PQjvv8l<kWyt3jFa8b9VEhw
z;{`+#+-wGqc$7K%q7~nMa2S*%^1W66h3`HA1-{8C4)}gA;4>o3#rWQPWyLq?Fz{_y
z2ly^)YQs0Ok`>?SFH}mNjyAAg>wuEKows7<yZ3#}zFzrXn57FSFw;OR*$sbh0iO{;
z{vt`quSo)k;djEcWSMn=S(hd@%zh29Vn&LS#yITrT2@NF!t^CdhM~G*N-kwvVtEw|
z{Mp^_quX)Cf1z7bK!NUV7^!yXdJFiBh^S(8JCdjo=;p!nVJGVW-Exg>=zi&MMfVxB
z7opp@aZM|_M__7W-eo@VqfHXe85D*>H~!IWc)bAhtWL|&2jp6bGJkdqFFo-ZolS0o
zciHtLTh2PC<qrKAMg%bGepyCP^rIs}N2nj&CHxTJayEI~+y}J7<KP^8{zS(NaXcov
zVGTIHgopqxDZpj)W5T5+ZE-!Mt9;`Hizes1G}k}LzK-J&Kq`Hw9a0adBRkxpMDxWP
z9W-5ll#3Oq0f_b>q;^X9qi>3lI=&Z3Rcye0HEt?W4U*wOF6u$kr5uDhkovMnB1H&(
zs{SSf>Ha&3pgH~oo7;fbiWqobW+l3|62Hmv!mBH|Cr8e<=f~Nt20RWTEi})rA3w={
z7?(N_mzJgI#}EMpam!=XK>b)N;q3rdi93E9B$!xWA_go?gcL!!4JQyJna9#N$tdJL
zuA(I`?ZSr85#x$<Y;QweN0V0#KJAA5l%{7Z1KZb#x7RMf8#>}*R4FA87-4RInuRsy
zBQkDo7G_1zUD9uELkhu{phT?t%7D&|kkajxncmzHnNmw+@<*n^*VGG>?zbgm;oNF3
zx|W@ZAos$d6m@UXof0WW)RfHt7B2q7l0ivZM3SN=-TDJbN90>Uxgur0n&LrD)K_#6
z#H5=dQYNS=&EQ!rtV|ZBN!LcC^j1?YkQ4O_xJ!}JU!*iwQ$9iV!sa)m=e4g$ic*tW
z16cS0N}|yIO@ctdvhTTOM*@Yo8raDu{Ns#<t4M=~$HLc_LaScs)tlB_IN?5^Qt;}L
z;Vq1{j!v{jRy`smY(6)US*)=)=ZUs|z<<)_BVI_@S-jM)jQJ^TzPiPSB0NLEWsY8w
z6kHeu>0y7T*2TIw=HHYzth}NEnAC1DhvH<Th2eQcu-D1mm{Epid~ck|twV3=&VpM<
zcixlySlStnh#J_5#Rbz5uw72hY#W9CnOm-)EmbVi)Ap|oX>D?Q+so<+!@$X+b=0Ep
z`?Nw)dz&ZTscYwyoY%(CoZI^~=y08Ui}qWKo-Nk#`VBv_=$*3uw4}QW4^f$3eXs%k
z5G!_=69)@mah-4hK?v+vW3HZ8*Lc6vvs!xYAC&oD1+4z5{(4BYIv*I=G-TDpz(KIJ
z_4a`FV$Z$LP8tyHQw-7mUO)}+SXBo7LY-2K24ilffCOL}Mi{!*$?rkY0Zr_YvpPm{
z4g5pRo40tx$iU+@+wsF_;L(j{yp_ExD|#mmX5l6nH~<{FC*bz|L#VNVf2~H?u=(+P
zeeofy_yit9aZYIoyqfFAA2FOu6L`LxTzmCz&ii<nf*%2#YziJ4HrJAOsyW~4>>2|J
zl$X(x-*>5N3O-f|*KOyFfDS0kz@G%m<%8yOSq080!jV)+=B9M_KzLWbYRJoN%}YDG
zmWR+_s}gx=sL5^MRWK_2-xNeV6K<6)&O@_LPQ;ltx5TS((<E{~&9N(nyuT9p2bx~H
zZs^3@i@QJ!&vHdHW9YUo|3ssR4^J#(Hq3v|DM7(C#@28<cJMlKcj`p9Zam0|et5K3
ze`s6b2OFBqr@J0f@T(}9->RXGxn1F*SdQPEN~^~)9{1({+I{$+y=up2yT+_X$&B{=
zq20Bid1)Q^35~ziCo5MxA%m?e9+uJ>l#g43f|EP*5uHqK?GbQJmKiqnvcs^s0IFU7
z!a-F$^b)FKqkuwHG{Zgvsfw2fk%bCb47jQ)s;)!54Z83U&FsrMc5xW5uL&rJdn3B=
zNVJskm93>_ABdLHa~xV~B3o)NplE3nj3R2O0&=6J27s$AtzV0l=61u}*n3IG`t?Rj
z?aIQf*_DU-o7{Fmep>sqr=n;nWH!8IUAcGjKW9;ssC+Gi5LIqM22@@ExLWx=kVmX@
zDd_oAOe6IHvHp-je_hnEQT^afo$qd7e%(aJ{$RG|wxJ6|LeWaG)$p2Jw?^GYYumro
zkZotn4llN~9Y#YVI#v%YQO8OjDFcn>@5L&Ci@Gm{xCNuuuxs)mb_LMn+L;ctY%80b
zE}-bHzuM$3<OV7u09U))<$G(B!!D?_{Ij%yZSF2Q*EiSJxk|F7ZH_Ii!ZB3TXtK6M
zRt^#NiNs*Mt)<!DSzB6qUbZx%R%vuDQ{-$>CbN-~=Zr<NhpQLc+Fguv^srI3Ll4Wy
zc0UkM^l$-op{U(qvfaOD6!-A#YP5SNl}CX$s@v8305zcA_Sps&-h+Eri?UYbr&hI7
zHsJ-hN~{Q~Dxo(RZ|FIdSZ~~L1iJ^<NB*(`d}EFCP1sM)>cTWa2J78Se868EV_@Dr
zd5XpvKZf??>tL)!d}-_GA2>t_gsx*V&Tjd64Nwqxn}DLDA5@hcJt5&s0T<ZGXYTrg
zOJ~QF0@KQPiGN>WPXn(@t^@|^9)bD@rfE(DGxg%0n)owtVfEtmM_<%nG@77V+@ur+
z*KT6g#EBS^I<Qv3bS)OzFm=N24lvF9+yT=KFbRNZPXPs{bs{CEmn6J7;3^&UE3I_Q
zJT2*%QIQ%Sf}F*T?_2_$(f&OsUbLUNz}CJF`Otp!bcgm`Wjmz>6zz|OGAEYsl<;Sn
z#qCd~v7*yGG{^f9X;_Ee+(WbPlsc;IU2x954-bOi+Be_U?q^u%qTSt&?e?bCuTi(i
z+Agmm+fA16DS)f}-nrb`@4ru~Eg7A0RbXEp1YY=io~@<Fu+Pv^?F@$=o&yvuxeF+I
zXokk89?}jC;4h{XxAb~h$sXGHqsd7!0f|4*ee#U}y=0cr4_=3hP6l?hFRuY?>e^vb
zUt(i%#Ku>)dfkdmn2Jp)2|oz9+VAN91DmlY{wFr>PKLbY{rGqnM74$DxSan$UIQcY
z+-Rdydx~4z;nru01D&=@3>pe3=yWSY(kYDgq>Q>yz*WrVd_}@x1lBC!N2SuL{R4D;
z;aZR-b0;n8ojkMG<3Dg<b-Q+F0fcs2;bxuiK@c8c2;dZo#ZPUDyz6MH4B%>0N0(Te
z>Ul&qHKOPrG*y5$ikrGCM#F6&sZ~`k=L3YMT2FT9;z$S>)Q>x|WV<QBvWsf4k2~OM
zyYHB_-7gQzcC`^`w<t($bbMv>?OUA3TRfQSK<WPY`SW02t=;}fw1C<vxjFkS4tf?k
zV=j{6^qZiFuDr;RtL9jb6R3r!kU}|16RAzQo)f8#bnI`p9l`_Lw}{V9_#8!_IDLiG
zSbWZ-&)>vn1$=I$PZ#m|xUzv=9>V8E++GZp#><_@#maBaL9+K3MXUsM)O+y<T*HIK
zLwR+>#!so*(vlss({PNpNS}Q&y$SG9MAGAML9FbiSo#%JK@t`iI?Dtqbuk=QFb?HY
zS}CtUqfH?E9l-76aTgLtcx_lf!CQv{B;m!wyhhz>z*WMhEdt@U41+;bAzw9!R=m-(
zGQ;^WP4K^ZHg-7g0D6A{1$1mUZ}g$>OK^i9Oj0!JGTx!l+mf4pO;<;|rav{Bz8r|0
z08DN0=0e$^U)fAh1+<#HUrL#z@_(S}7=&Y@>UhVh&&sL;1r+^R;3xZYnU=8dbpWnb
zZ=mY$&|JB)Pxfc<kk_cUCvu|Rq;U=?C(3%O2q@}(<SXkPE$b}@xLWU$1$MHkEn#kx
zRn5>6SzN)Fe@9DYQI?pig<O*NLme2gV2s#E@XPD5^tl<IULWy*47yIoqBY5RkzE@_
z3I}3sPUU;ze~h@hDDaV*;|k@7S93IyIW~(rlGGe@O=n?<n!{J-_)z4irsnX)=oP+2
zw(OG`o--QAESC}PX3@H-S(Z{3I$!_<Mu@^iL4q>b`7e+XDxCncM45|f$_TJ<VH26+
zCd%ZgDSkLFUl=P>E{pCgQ&Zf_(R6%(B(cH6l0N1$%YXQk!Z>f67mvX%|Ba7%xN91I
z<&NUvRomhRHj1G4@p^h`{OjQ5S#kDk3<tIb;b+3TdsL`3^18axua8IZNYAV%vck)w
zMQK(sW3nI18^u@qegKF?`xe5~wmif;B59*}8QTLQEOQKB8T{MNm}=T&#HwItTsW5C
zF2rGNfbmKzwx<GF_cR{r{>MjRYvOM`%Shu9n)R3UY)u-ks@eIAo}EwQRqC4DViyuV
z8iaIXg_fFh@R=LA`{+isb~%6IlB_pKhTp6V?nJg|KRTvo5ufl+wDsrv0IdCUuk<0H
zZI9=ArhLL<wa?~>q{+6V6VLSQ*(W?y-~KOZ3)>%4A`)>Q@dHVT#F2z#U8ErtD*ICU
z;KZ!I_2ckLp4-(QQN0BhNP29Tg*9#RSU$<wH9QBC>f|^+#&!Q}{A!lYE4j|4U%k@#
z1lN5(VY&BHI*)OEN<~VK=YyQBr&rP@@JSlKtbx?rs2BERh7%z7Gaf=~?Xb`IG{~4m
z;|y%|XS}mvXsW{`jl(2O%6XfFtvREviAcj#ZCpx7mpOn{1x%f$H$Deeag%v$(5D-u
z%Eq?W91)#H)&%y-JdSPDvFVe!UUUDRo*kOZd${3tu335(Hig$J@6?@wF>$lqu<{0$
zI)%sjJ}#1@5l?#}E5T_v-ML%OmQUgN70z*5c_Zw{q8)Tv&pw_CqkHNpJ^NxRZ|dzj
zLk!CNErbWoh~7qX*QWAN&5$R0_V-jCRiRB^B1?U6r*QtnPU8)|zc=fh4me@ar3UTl
zFvg!v<Nc~t`HdJ&9m+ChS1pO4+vX{KsE(nJL0aLX$j#slK+CtIad}k+$Me5#7x8mw
z1|No>L-6xb2H%XITM<(;Gn3z-3?C!IbiS_MFB2i-2D#$)q6?M+;+PbRw(OtizHvrG
zCVHN1if~EFIucg+0;UUu=_Z_xP57L9SDKBD8(~<yd8Ze)9>v3BVA7Cb%;!8T^tD1n
zm=kdUwa|FTodX#M^wk<2+w?h{&=(XPyET*7^!(vhh|wkRL86T{i0pOFLK~UbY!PiV
zRNH7H+Zc`vqKzT{M;q6_SKIKiw(;@?+Sn=loNg0F;_-+qz8$pKH^RU^o52&|YEK&h
zu7Y_Zp8q}yg$iuGY45<9Yo(ecuc|<;4+IIBx=h0R0<QAqr<1^!+H77sXvw#Bd}*Zv
z@#VwSI@Uj%>w`=E0@Pl?G!aG&X(E#jVYy&DSB-(~$>tHRk>gR_y=<P^wg<LOEZWH~
zQaT?Y?`=55DR9j|ik(UDTH-|c1+E2uOI-VrlsD=U5LPb87_;_&57p=2s$|@SF{7c<
zExiU@&q9}=!P1Tmc9#v_fzMSm7^XHjm;A&=-ATk7wVDOq=)2~BH+X23+TdRpK+)h0
z$lJoVvWIzX9eTJ+8qNy@6cVC8#2byqEZN{Bge8d{?*IOOH|Sz*u(8^prqa)PHfJ_p
zqU|!)Zgz+e?msX$8|U!Ku8onz`sMH<P4gRi*6s^l$-Q?HjZ1rYP(S&C2h{vreAbez
zn>~kyiK3fngl|bTdjVlZm~JTW;}^WKX8AArycb{ac;~v7(W2eyiOwf5E9p!_A?Y)C
z_+rJj?V+&36POB~J4Bqz6Xa%t=I|++jj%ND&f!Llp+L{lOuW#&+=tXeAE>5*bFuG{
zbU@E?=i<oAMW~qlb9uG8p~zszGXBy!`m3cnf+?{5h@g$0(+I}h0i1<@mJrFB&Ew@X
z%V0LPnTH6wg8LYvA}Dt7L`zY&*vq8u-Go?c+y|9FHC{k&@I)!V)d|!66SB8RLSX%u
z3MU5==&M+Wc(^Z-!+4F-aDxhv6|#jD&Er9aW#@s!AXG~vj-~2Ny6Y{d|4Sj!&}Q~&
zvT=OX9F1j;F(SvLKlQBDd^nst?$fim^Le=Y%_E>VUW5<I{i=z79iIX{qOS{Z4FkDy
zi%&21p&$dlkAb&Io5bMpjsiv&?cDu(=DYwWlM-M7ge>6x{#7x-i-wRWM+jm-DHkV-
zx~_=S_6xAQeR*BaMlC?=3V!^!fY-0~Y7eO(xjk>rr9pw<AKiuof9iEo9y8Do;>^4j
zg8Fku5WCneo-98Op(s!mD1<2E-#Aqj*MfjD`W3+Q0D`h&3uWCiKib%OyOfA)w*ymi
zy&gL-D0&~fZoNJZ*Ez`g?hp_zP$%3XfC@7t)Wf0akrKF&vQmh+z^AJO9&o5MUIO<J
z5FT8av!(=|BOsi766gz{&2l3x8fzayxf7Yyu;8Qg(=LSarb2{k398Mnv)Cu-fF8#?
zvx?~N#vP7z;)L>PgRlF8gL)^rxjTgAcWf4@sdQ7%&V0%J%g;`vaTp7+1WV@mm+-s(
zf$0>!h*$GJb4;8|H3uP!4NEe3SZWp5A;U0JTeH**O$8J<$x^FU)U~F%s$C`2GSNpw
zZJHB8EB<&?Zy%&byA$^fAs=*u3Uk=DLG~93y?xSJQ7t`xvhPNoS1w=WthskW&$b)a
zFV}o_N}tzt3IEhZ;{?$8x$B2FeZ7!|{5GCpOh#ygS2DK4!z|j?`@ySWw1<Oa1VLJ~
zae&}^ll40i{Jr<^oZvDP$#oLbjvY8WC$Mx;Z8)&c>)FnE>pKJtiKmhskZ7ZWr2g|#
z&2u%~e$caB-|$JLYn;=={5r-K)ZXaFwyas_*3>`+T>yrm3b*<2Ag6fG9p^EqC%}t!
zKcYc(otx<V{P58CUvvx`yumNv3+mN>KIoXg45B-vFHF`4%lIYdM%$ZFTgy*7A{h@3
za@-!2I~LRYigzrYui*2rYqt&hPZ|t3P4)vu5AttCJqL+O-a^Q^NdgKLwGxtq<R497
zzy~0<?$}CR#no$*uX?t%*IXUjzqnsa)JPf#*X)zy4MTB5mGkiyu44Y0-0IAw9=3p;
z>ox{+pAB5aBLbJ#B~cgqP>MP)I^?QI1Cgy<g}Bw2^?G)F74PoVtO<3x>Pd834oLjB
zd?B7DZgkCw{roK-f}iJphCg{VPb%IoTg^LFupdWkTs~jTBVay-v@zrbe8>AadqrRm
zNCYz=7@!R82hILo_{B1z=8CPVOVW<q9^*hH)iE|#KtZHY;Bz9<cgUS+44wcu#cF^#
zx1H6qRh;{>z%|^{HEunK7QF`HNab^Mtk)VITj5SLDHI&Mr#A}p?5j0=ux4|#A$KkJ
zZ8sBX!Z3-0IG&N8m~$Nmr=+Ryktl{RD6G%?6Q>`XL&F2jLm^wVGI~KrsOCfn{b=$i
zSc`TCtwp<6XX)62wY+|n+j*EHIoAujqCR>aw;k1+a~k?#A2y8e*a1|s8IM$eYgR(%
z787JD+}Pln?`k>_q#vN*j%fl4f|y`*5kWdg_|TeoyJIu=W6#&|)~>Y)8$pG4*@6l+
znCXqatfur1JzKdRe#*Ie=BM!b@KHX5wkvKr3!55fT7yj(I}>0CZFLxRH?d(NXmtg$
ziJI;z;K4@$SH~joq#O(H0C-2}oghgaw};<Z@fkNmj!H%>m6D?}emm6kdg^uFjEFz+
z|4{7mEj~EoqI&So<aV#Q9g-Q86CP)QPO(+dO47mIisS`|K0=ZnO##Eaz*dQhr0)rg
z3tP=G#o86)H6}~tmfn<6;`PZkJ!`Omw|AMNXJt3@6n1q34qUhSRnMMm;0H9ZYxHdM
zMn22s3q5PJiC=KZ5!r@mPUq`c`exqI{Xhhb^9$Hu=Qi_Pm)UwYbPKn*V4XQ^D{rB3
z$<woqTe)AkJ}wkCj#x$v&-tyqO~#<DupH_T!<lrSVKrMs_mK`IV1xwb0%*}5SqH+2
zv#ciFb9f37*eHi4yAQ>K9FWU~QgAQgtyDE-5cy#Oi4{${E22yTHRUe3mD<p1h%Na6
zd&)hR>)6I0aEdn+KQ8>hecUs_RyZEB2?Y3ohiX&t3B0Z^gY1zM%SBT7Htrp;6R;v2
zXPtqU$%zxlPBm$FFVnGh+pu?k9zCDGjkm6zE#`=bb^f~<WxQ?vJc@+T$4Ib=m!b1>
zxAS4nJ=pN=IDgRToIY>gcHZ6@GpAZ3JI*MFw!j&y;n}uh-zQS8P8Cqh93KdG;*6UT
zJ_H9&I_=;oRl>fe9jKOcu>jrXfnO=~E0KPslIM9M&Z_L7vnuQK?2jFMMYX)HP(3DX
z!DkqlTBr^8Kr)QTemO?Y@S`CL?;<o~9<QdI{;i-^;8&7b!*TWv^7qd?Uf-*cOxguw
z7Rxw5o9*O5+VT?mJ(;*5Z<s~f21%oK@(*2iSAkn=$4(wm>hm8+E3$%}yry#(R(=<J
zp4U%;ZFljtE*W}udlwIP9>kn?^EHj*9t9J&$J}vU0jUifTVDxtCTGn$e6-8izlG37
zAj-0EdrQR=;j{(2`H29WNPs>m78SHM1+7B@ux#FgrTL%!s&x1ih6<7Qs9cE^_#4=>
zJ-kDevx|tlv_7G8!k}pxaqP?bmY7?qaXL0&FQ$dlYCT)Km$!A9tY>w4C-}0m`}ia0
zetEC=@fyyR_uUu0*hF_E$X;AtO16k@k(S6k4V_Oo02j=<1@I^z;K5;O3y6Mh?rYFH
zvS|`?aL~%6yNJ=onXhm4?3)9;vi}+ye3RB7GH;I{9gV{utMu$DrG6|^-5gTaBGoG&
z5}^^-<8cJI{i+5L>w4j{13uB{5z-;XG9u6$7i2hl&f0;BaY4pM2ne^kAVVB~HR?VT
z&=(f%hJ2!7`Xor*I*4N4k<UY1=gx-=O=#9UNRu{N#||!CAEU`wu4hpPd3d#@-qiO|
z$Mv|=LNtb3HL{zK!oOxeiCEe}9smu!z80b#4)SptO^!a#^$_=R?(t_uF?^<OmaM;B
zJhN61FBo-~Botc9q75OFFXuW9Z8zz4*^X4XQcI2~Z}qIL_(>iuM#Pgx>|CHc>M+(b
zH$Kv_g67FFRUXk`K`H(OIYUbEtnj|*YEo6y%H1P+cJnZ=q3x3^2IP-9#oWJinVtn5
z;emlMGHJ6d>EmT&EyDy!IU=mE&O#-rZky@wL6E-ia*zsxq-VliKp_?4_e!?yEa5La
z4Xo->UfZ>?34Q2s6fV2RBXn%?Q5-aX{FR>VIm*{m9!rcTH_d5>hu+yF2jNcqpHqnQ
z9EbEQ>lh#B@(JeoF<#I6lU`&G&4`#!OyK3#37<@VoF_q!acq_s&#gTY<2(-sj6au{
zEf7#(ykwWe*d*bTJPhpIabDkbYYs5h`zHr!nh(>l$P>W0In%QtC-^g$F?!bRB#(0L
z%rZ{$WNe-egNiC{_fsi9dzEu&SKT0t6Hv6<1)`a_AW0ZPh|rZ2U5oTYQwOZQTGA;$
z`h#C^YPsD=biv?KFcP3(6q^4gx9pluwFEc{AD3s5aG-0mkwwVfc>0ASgF*_sy%?-x
z6HcKgFBa+9j#E6#y<Ayh`Kef(H$Tmr)y{RN&qn(MYS|OvPAR-4m0Zi~LSV%G1tBd3
zM$dWByQg_rH3t5~q>s%e9@`#~h7MV@mlngu?gR;uAgVmQSI>Sw&7=KW$jraakeM?v
zh7dQ4;r%%S3E?hNzja7$iPUjtc-3l$mlM}R%~{NiputJa<$IE>P>^7op)CIl_w8=-
z=ncIruhfCW_?nnyheu`^8kFKIb*Onv(4GP+uheM;GfKVECVe>4^hlG_)1z7otO=se
z!v7FFP$%vP)x<2+vw!p(12iuO=ve0H4So^0l^nfR5a|L`aiVHZadn>A^+=Zd2t{+@
zEN=l{c_@yu`k&(?lLL|6bH@eiO+V#{Cyct^;g^T0n3QwIqTK=wm7H^jIA%0zLF!ec
zTIB}Dn$CloJnEb(%g&wS{;s8GfPMSkpAn?#+h51r&qLvkny+U~&hxPu1#aY-N2R5~
z`?AvPi{!#d70xd=Gt%v_=_0W?B%r|N9Gv7^so)F3rk#{x-yzkCjgVr5&BGH?ih+?m
z-h58HNq#3b`2GxEO_hEUt>Ja&iMk5UK!!oUXdD|qE=TC5t4azqzI97+<C|pT2ax(+
z<8|#C|7w_zN{!KdWwTYL&XvtZql)ZHh#HY1bSSD4T^tYNs?9|nRHK3w(hf6Lb~@V^
zLr{1VC2U+r8h-voJ_3rNF%HPSyU3F?`zE4}OFYB52|IO(C*ePz%RH&!7`T|pvid~c
z>r^Pam?WT}@6UMBW+OHAH_>;h>|#wss4Tk7hr8-Be4TQyKp7<V(y`Dh7}xGbJxjTQ
z6Yi<bggc6N*bX=46^Q>+*<xxAnj*zNwynyTU~XUG;bDtplGc`VX^z7zdVYn^Lua<Z
z@|f`xuUjbwfy2PMr76LZko70D+hKvXM=8XRT>OdqM2vw42}lda#~;wUEZG=&12MDM
z=YTkaVZI5f$NefcyqZr1bBb$#!g}b~$$PxAFJ0AvMWSvH3Xq+KJC&kxu<>`52Wp!V
zOkB#Bl=Fw^U`2R2HeKbhm1ky&4wi=PsFphNg?%qz^8U=LLNk=dHn)_}!2A&~2dm}3
zgTAvJ{1H1UM%~u}3JLue{B$$|d*%3i4uA5fpK<K*!DL`BOo+AJbu9m99^<=X7NlM6
zoS%SSqG?)U&Q*)H3d~#AYZ#tR$aJCl1|ODmjaLX*{4X41+J0bRRGs|*gIlyydJEF7
z!RqXTRnXVh_-M^{SOb*1&TCe-ahQ0JN4&sv88<)Xq(cdq+-}3LNxjay*2}<#iCt$l
zN~C)TXnxLXTq2;Iu@<uEDMn@%2yH;%Z^3o$7i7|E4$w61B9E5G)2~EK*qxKmO>rq$
zTvr`k3f8S<w%!T0U-`n{Y0khI{Fr#tr2Fn4)cYE-qMKy>p4oI&V&OTY+OWs`khjob
zZ&~19A2zJpbZ^*YzwnmPZBU0D`fgI@P~eJKEH_<41QP)eUjM*OyupL(nzTFiNyM?j
zNRPm=yL4J%#67P~iZY$f$BUy2T_V!Zoh1`VARZin3tBqs*p}|iV>EZN^z7IT-o2h5
z_EQi?zCjMkE#O^flwIRTg27nYn1@h%<SNBoCF6h+=6cGne4yr1Cv|L3{>tN9AY_OP
zFuBq7sSzBOfPE9YUfq|2Qb|C;VS(RC4(lT&y5=uEOTNi#hFqN>Wo3Lax`DBvYXH!f
zSajo3M;%*y6Kr*7I*`A~QwPSt2@f*{PFUiocZB?CiTvLU#KP)zZy+xn=)0%TI;U|S
z8Rlb4=ZOCggL=9*GV5K++F0~+9<o|pr<u3jcT*MI;<3&#tm17RrMZl?Mzh;|eMk>X
zR0=Xf4NmQhW5UFN4(My#H*AKu(iHHGv9%;g_uVVDB$|KrUkj*3|IC(=`~?O4P6*;=
z%1hePg+z42P(tRrQsXePZmHN`zI}(c)Z7`aXI1a=O?6fxmdB3lWC()eKNC=peE`e_
zn%Gx}Oh(<nS9<1lj}L{goA+Z`mUfRfaIO9cxJ9`KF}u92kWexGH%`W)^fF}ru1;t@
zvl*VS&!)G{fI($gQN`w;9;}O@KZYG1I~>IJq*1q0K!JlNY;D3p_`!_2*)R31`)|CX
z>zy%ZSpOIef73?C`aI?}*qjFlRs8ldAbFpsX*>a*c%Oe*$MW2v0lL-*ow+WcXkg+}
z*?=qAZ${lgY_L7Oj|SY+tPQv&*)<ScZW6lJ2D^bYv8&^Ma7ErTVl8*9?sh!D^-5fP
z{<unV+CJj6E94v@^+};~poACMJ=UGxPo*EM3yRrMqKEW@#Rw=6{r4-0Xp(@t`2tS%
zYO3&%$3rJ28tGB*tV1mGA+C_CJKBnWc54;?@@DQ{Vc1jTgc!g>k~2QlvnpoZE5+ot
zoy-y|K0m;Tg^}?>PCI-S3D=hH5ycKrsQ9WS5}z3Y9()OKfl47n^Eoqb;X3<cD+cvi
z2@L85MI)2ic-;x0;|Xw_C{zpHgRDY6vf+Vg$l<mUoI?^ckuEZc$kjWobC$Pjk$co@
z=y7Lf=bVnNg<S;s-Mn$aC*lzTUUv7#R_G&M10C9<vFp&!pgua(8X*gI9hxLp65#@h
z4y{8w#A@qltc=0#fD7E7!;^OW5f63kJkr{szAe=b&Bp$X+Mzz_=ukzJ6@|J_)w9$h
z9;XS#kNHL1r(6|syTJ%|0$_6yuiK;w%G#krZ$N+n|9zy=w+mJVgifTGeZltu7v;Z!
zL$A_fpmS)r6`iszBsvuaBa@1b`#405Jm!PlUltN`ZeI#L`2^8mE5+wRd`3UPna`Pe
z*7gan67g>hAp;wBgtQ^C1nw9GUEK=Y-C2}~Mu~+_c-6`qFsu;u(SvAn2GK%~Nzmhk
zcO6F@34Bst>)9_)cy;#$;&U55%Rl9v>--BjiG3FGiuM;*E#Wx3vAY+pp7yt-gwgc_
zMNejfJU<C}+7cU47w#|d3F?A6BUg8%zoYuwTP&noo<D8s6Ev98s?4Xq?Ru5W5$30i
zbomIop}m`VvlTDL$5;GFkkP#3F*UXlvI=jqZm33ic3n=m74Ur#!RJBJ+N)$jr{FoS
zTcM{&Zi!^!00?`*D+epw*=c_mXr{gl{YD&bO28YlJ4fhQzZbk(ler@>E?9=$dNf-G
zlT90L7JHX~odOKw1F=F?LieX67C*4fo!N!y>-{u3R3x6)4n;*ot1&2462W-WglaAj
z?TueT)ojC$!7uqxO&k0Wy)Ssl{rrN50}=Ig?Ly2RdR@CCtZ#j{v7N$(Nz%9#5<<^D
zeV+uGuXt1ST+;L4b+ufEVRt!XU9`(kJq!MwcXXb{#{7<RLUZx$G29TK8H*q7Le>Sc
z1HZ%UP8ce2U+{3Yg%u217t1_fbD!WOd|I^iAPy|rX#BPB77VKm|BtZifQ#yQ{@lGo
zK}1kEic}Q@1rZB2?jb1Zp`h4%HzxLOG)6(eC?aYS^=V9u#uAPD?2*KZy(SuCEU`yp
zI7t+fSYo^XcXr<$2l1Ex=ab00Ewi(;v$M0av$Ls*p^M)tb?o@>W4Bvo*{ALIO`+Vr
z@!T!F<htL3IsC9$pF(9F4x10QqQhowAz%7rllRD-)p=wCSFI!@6>2~n&E+Mvv+F!j
z=!jW>gG3R92J=EV-^xY`&FeRv=RG;;11Cb{An3r8O|i~-L9?FX{QU`bFI%c%3tjE$
zCS%i!IInY%5<4L!lJa#B6e`bv+<KWqf+7{(8If?|<SJ6!BAoV&c?uWXo6x)#Jw;?3
zSC}DgJl#~=J9#>WfeKrWLb5<CzChW)XPf*hp0z>r!Hy#78T_NrhSKX9tiyTk7gmuD
zIX|oiNzFX>SA8LTZoh`1>KABQV=6FN+Ktiv<JqQQ*GD&KEH|M+?|(Lhxt_U6KWE@)
z(m$KN#UW6WzrlpI#b!MS3nV6@jzc%+B6XV%x|{($HS;|5Gz8lR9Gm5i40G|w9)%*v
zjJg43@cE`l!=HAH9(T|%`fdnh(eq7F;dw!IpwyUiB_6S44o1XdS8|vS`tef`KhGss
z7p33JO@WomrJx|pY{e*qy;Wc68!!0Ll~NuVIAo#>iy!Vz0PFZ`rLb-V+Ssx7;CaA$
z!EA@|Nfat9e8H6KFF?Jm?fLk`D_afB#dFYLf+sLr9|#uc^m0>V<@0SEQTn?#ZX&+i
zG)6iP7_VM#3W!*Hm1?1-2H9fC$gjppGau<<yYD^{e5y2m1xt1PG^`b`;On6ul%TA8
zg#(xJY4Xw<EI_&QYEy*kp(`|43~RX8>rKhJpOqf3H^tUV<t^AxzrMl?WgvY`Tf6Ek
z(e5WAy%G?sXJAI<``0)leca2&Df6Ks5~pMgfh4yWP&g&mFXgxspEX%8^d7T^k#3Xc
ze1UWn8-pN_Kan~Th&eDwGo;!{{Sv2>oB(@f3Pi$?3k2^XT_eCdp%`brH#nZ`6V_x2
zO-k$+u;CU4q1{jyITwG_KVgZHEowZ6!?bsKXoy35y>0Ey%M|UUBNy$pyqvJ)8jCOt
z>SpWmQ0R^vY(l>TWtfg-Rvz5KaWH3h<AW(HjrFX)^x^_MI`u3d;=2o4hmJrUA|=2a
z$Q$??=~{<g5qt0vJxux?jp)aHFykb4+w?Y0BOPc(x7+NrisyM?mS&Ix_Q|voMbLrZ
zpZLgy8BTN+JqXo9b>kiQy%)^T23B3)5a&DwRtwUqwgqzDnMDRS2isyh14WRix>qwz
z^D}T${RE}6GwT}$;Rc1kvD7)5z%XRfgfe5}Gq0R-!I?!jo&RGg?0?5qM0>SdxgXC3
z{&l7a(p(T%6<fpWnKNDca?HaJ)7drx6``u30}Yg2<yaNzT8{+fbU9W{540YXW5@LM
zptF}}9bDf{PjK3yvozBwXUnlb=};`suYmxFY>mFIC?qxMkf5}2WnV~p&L$|oyE6aK
zg=e*aYK`U6PR&0AHOHeAN2yr_p!8LH8%m*x8cm;dfht&m#Y)rPg5z8TR;aH77aupa
zP8yMfL*0rjT>8t5BcqC}W?*&bIhHGU{g9*>cMyF57d1?bsiz^>D>DCxw9^_cT_y_3
z&{LQg)HtMTOmnIVm?qerg-LB?S!sJ_zTB&NC%}zINjwGS=V=G-1BW{RU&~?IXTf4m
z2Tqz|Yi}VmKzrY>lUrM^+#6U?-@Q&(r_r^q8(ULsR2XIwROp)o?anghciKrgAH`Z>
zpZO!i&D(7!O7X)DLEK!P3O?9AUi4N*X*4_m=~{0Cska4{Sb(%GUZZ$UI#d=979?#v
z38lw_1q4hxsZs6EaRScA0{&nWnCQW(85Xnw##=+d6qlOG$|s(zmGotYgr%MUvha9<
z66y&c1CMJ!JT)NO#C6LQ6zJv&Agr|w$m6C0Ncp4f(QW@q%FN2lS9#^hqOq@by`G@N
zRA%A&hy<m$G7DBFRAwEKJ{n#CCn>!qPnYR$-72gDcl?@J1&nwKj$d2^ZX4||7(K*o
zDD{}eh-a&S5&IG@eCf_@tdV7KYJ!sN#XgdrG?JAoUaWgP(~(j{H;exG@Kg}p8Jh!=
zOHD-j>%$4kKyT(%1ux`e3tKkMR@~ofY3ud<I9WLx3MJuC+XUrTZ`Q4M&Y@Bbyf1il
zFi%AT&qs&`MvC-yNY_TSyjzJR4{NfgtRVlVq3BcBAFz;H=<ev;<S<{bR!3S4Y>P@e
zoXvo}U%|u9K~UB~Dp=?ePX!VQ8WKSw{lGySfcmgt!zYR8S6d$zBGo`^BYjxQjK^lQ
zHV0aP*4m^?4y_#*+QP8Xt!+dqT5D-*ZP0Mh<>ewh3hAQDslZ<|Ypq8NbNVLg?r$!v
zUw(8=v6Bz;mD)5A*hv168Vh`xuPac-a$Xrnf}4F=9qCbhTIzk3$MoZ?`Z%xiW7T2x
zEyAK;r_BU$o3ndCDcW=uw>InXRM6(~I|AEQBHh0LE&74eAILV^?5-!U={dhOXv5%2
zm5gZL+)AA1?BdwsW#nNr_8utJB5kKYpQSt%Ek1r*wD^@sp8;RuasFu0&EDdrSgrpX
zTO}y3{W0-(ASJLWOO=M;V?<RJ?tUR2U8P{kcVz7SX1@KAx8fGTT$SBbS+MkXU9Jkb
zSzxsyjN0QkP8Yy%33@M~1|%9|6GMz&1uic@&J*bxUv@P>+T094qmAkcW>2Y<jE;Yb
z%X9!Wi$kzWQi>3Q`h9G0KYmNVbro=vOW<ykY;Zq{(I(OGmI;a+$ZqHZu<;6F2~xHA
z1f^dP`&M5yLGcg9@`k^rU>4|lZ8wd7zu}mk!7SKy-8b~JF@DYsW<jpLJhw7_ZVqNu
zT`TgR4~8WuKLoQD(zj7UFRT~B>es7>nhrBXQ@-7JD#&tvpg_N`P|E+pq0r(Gj7?Ny
zn*_+Ots%d#d4l2>%39Q`j&mXhkiA6Jm%B7dUxkuLlx{21@4{OtHxwYp*+CZ65+H+?
zC4kNpSdMIR!Q?8QCkFzK)wmQ})LPY8q%^IT;QSHQn7iwzJTC!xGbyizmUp-st1HcG
zl%PDW1|i=9A98h8Eh6{>+35g=3v6?-s1hb#I1>1SKlKnL112~Fd}SbzXIE#T9ubi;
z%p9#fA#lEa72u@otj<!Tvk}yI11TjAzA`nis?V&A@v6b9)pxHC{vj`Kb8a@js#0vW
zx=cbNd-*S`F*z;4sZ}<Dsc@eC9?I9Y8mzVJ^qthZ149y)hB2SEl_KE(6on@LsEH4{
zw;D|;c;v&`jXnsQ`t(sAAKOr7yAFpJh69+o=+yV-oKxnUgI431umoj57;7F|`??pn
z+W5K_cC|RE7F!`F%ood5)DV3Ji9g^-6c2_QSr`k<SiOUAIt^VA!!~=~&oFx)#|1sR
z?v^Ky;T1M&CH}sJ5_eF-4)ATBpTqOTE^qcXcTwmty~LX*PvP0awd(Q}<lIM&Ry{dS
zzPz0<XsZ<%OOeD|^3X=^ufs8hqPsYAYElC{=H`IdmTgqAGJ3K(ocX){#D6}-2I*Wl
z^Ua9k9XmTnbnF0iEE0A;V04EU{94O-3f0FFAxy$Jc>}~1TF$rNNy}RzXAIAospZt7
zD~vNm&SyO5Z7t_d%GrXPUTEkq-cXvBbpmgzTD*kAK|P++z}67mMs6Z<e%neY_-i@G
z>5^t+k@Gdru?|d73Tm=2eU${|UQISqUzsZvk;?lKEHL<PEG-GxX~WuJae~!>jCZ)8
zH2@yhP>y#+VD<YFAD1JTNistq`9?w`io{3bNERdcBI}(<sJ2I1Bq%E)S?vtpa1xb!
zd2GGHQ<&5xZ2f6nVHwKaL8hS5ElL}K5_!0z0XW%AoI5cLFWotZ9VOf}hntOHNyyh_
z=#zsqSxBs%E05=?5Kxufd(iMr%s^tltqDrUT3E-M)rEB8M|ZD6h0n9+-8jwXIU4O)
zk%}Y9TE08B5GnWd6C4nYJ$%tVGC+FPX6c?4!^n{?1`2@Y&pfs^DA5KxjYYLtgTSV%
zeUNdfK(<=R*!^VEj?}!#r0W)k$jZ&yEY-(??w35e!F@9?V#|>f#ey<+{X1_BlE|3&
z*H&&!By->tvK=Go7LwpH+1!zUZ+Kv8c?7x>-m)|OJ1W?*FgjHdr!pO}a^)}L`bbw}
zG#g@u-jrB5MwkgNZlSgcAbQ1Zg^Q7;ZY#JYCn(pVnP0^zyxbs^gPkk3MP?dpaxz+E
z2GU=OwH&puj${AP54@#`Bv`u(&un(Ia{|DkACqcI38>lhNSm8}DxvVXsdNvx?KlQ|
zoY3e5<!KBA{NtzurFvb~TT<|mS(n9n4~ZgXoEBS1vxsgHtiTF-q%Jduxlm5lVX)iH
z!o@hYBJ!p(YNru22ROLnUvU{?X<{j>B=N(5SQZ=mJE+UuZ=RZG9*@MxSdCYB(#^ty
zn+VXRW{wCiQVL=*&@BrCaIv7|^~QaF28ie5&2+t`sXO5t_Xj1~Z?c3T5vENZ`@i~M
z0d$FGV306GiscH{%FGJdC7L-@)qb_bQjx=(O^L9TXqRX%h}3oPKjiU7dD90(VlyfV
zZ693&K3|E%@stRaR3t7DiIXW2n<$Z(DH6w0qP_VMNCdrLmi5?0PghER$D#MR-naxT
zr~gfaXt>a<!>f&GDv_5JcGOaLPiUOS)@tGF??-)p<9&<7`mC<cD_`QJ*D1L(TvDV2
zbI#9jTrP*@x;~3-*TG1LWCB^DWU)rf*KN6x_<n#OCUimG7vm2u4o2d#Hr=HSSXu+$
z2!1%Sm4*R_Y%X|t2-BsMNn70Icrw4l_S=93>Fz5l8$crQQ-y*CEZpr~fUp`jLTE0^
zFK)of=`vOZQ_4F@G;(q##v6qD0%@8v@Ix+Np^ea~pbO;7&{#s7JH^TM!#Q53sYe2@
zvC#y_p?G75;*uzyT~a(L+711%*|YOA;|QZl9LLKLH^8X)5yz+s(lm_vhm~pKVoV7}
zU)10j#aFdsbgOom;$J!xpCF3=?Qbu>t#&DlJR7s>x{N`<*lLW1umMKN#T=udNYgOd
zQN2tPwd<5%^rRZcXd$tapi#qGWs1Lm-?fdT$3<~-Npa^|9%aTlzn}@x>3d)e*8|8Y
zV72uD$Lc)NG^|3Zm1$;aR7o>~LOE71eC$}QB4Oe<a&J2nZy<{AEGa%Nq7<Fdn-N9{
zz#2|Yv=_>gL;v6ywLqGN(ZY~2O_Zx$g3<Y4j?oCC9V5@0Wr|;_RZ@J7C>~Z){C0RL
zjBdpfMw@{#PUD+$j20DfjJ6|9!^j#`risasB~7#l;uu}^vSXB4mi5{=6!#Lv7nc<8
z7*-0Su`*#442%&=s4>UL=|0D(I?^<Z#srqZ=w8hdjJ5}GjM`PPV^mz0_3|BxXNls5
zlHv!eJ7T0{wq!=<yzrnc2};%GY*Kt)Q0En-@3i!E(0N?>PAQ)6Q`bUF(C%p-X$HCR
zX7T9jR`fzS)f{`&14daXPK2ViAOu^+L^d6_t^#pZyCRVVHTe`P8&w{H10s5nPgGv1
zdE2;<>xySJ5{j^(!>?YLBl5j9h#v&wT1FCVB6)KA<+Nm`w-I_%6X;ErP23ek4n&T}
zt~QS7n}8~UF5rDg-h=I2tiTC?FhRTnU_vV$u1Mv%ucgHj?Fv-DY^6~-P9vM6{FTU}
z+ArmdL*7`SfPpt_)MW`yNp#5K*!C%aAo#pxFSJaJ-YMPai{C)JJ}p4JI$olyDKEhT
zmJAf5jb|SIVm3trKI~VmM4x|#eqouQl^7`czF(oE@V{}^jY6ogSxHbHwP01<^5g@^
zg4Bok!lxyxZjSclY^1siHiEO?aHwnKv<0J&b0cnA<^IjGUX)x>QZf-GZSva2Kc9UC
zx4D+=9qCVuk#jQ3h84f(Qdn-1Vf@%&f;Bps8AG=JO4QZDfQ9qL@3zeVb;MIv7Hk+F
zGx+1G<iuv7ONV&9b;%M=)KcTQh0|0FrV+A_NZOZ^)W%W1<Iz1^L!6;Rgc};-23kWB
z*)rC(Vr@h6<im@JI!CcT0Ib;!iJexFik27t;o=0PQfq8UBA~~`wr1WT!FL@x!8xP^
zcCv@)gol?u#xF;Js0$FQ0HV<nsAq($h2v`Hx#@Qt0OGs{nA@qcy^;X<)=WPDoU0A@
zC-{ruRX-MPf73A~$*s_1c2~4$d0#7aQtZi^qm<RyQ%u|0UnA491v$i6O$3}YUZOEh
z2IjV5)s4HWaNdY_6};hTH9qrCP!6<VRef_sR#-{aNpuva%tDIPS&yq@W-dhrfApVH
zWM>mWiqcY~;I>VQoUN$M`ISC!Sxw<mB>F>5iZDn{qGM?(vUwDZxoztHONtzK(;zN2
z+NDUpMMRnbSk#Glj#4BVIsYw14mF}F_GT%v^X7j_kxLc06dBx}MW=adP;5eE-@^Y-
zh}1yC)cZ0*#0_l<AtG1Mgh)jIFDpcv06s!9z~n+*ev=USet{-LeidrP{snd+au!)u
z<F}a3<x(L;OqDpJ>@(Pf$a~OwZ9=3qw<rrCQbm;9R8lgX>&HU*wy}@88sTPAIs4qn
z`%m_1*ig`*H2Wl8x3NzL7j3YEVS>m><Ltw5{gE$1(G5i9((Ds6>_6G3O?eKnF4;1)
zHRwhzQR7xqK}tvNVaWM!?rBl~e{)a6tN+P8-OF+AxswF$@hrnVG8+ExC1_1O(fKmm
zll!xcd-geN+%q3KXIbv~W*&8Uo|wFE<ev5@!Iz-7PzW+AVV<3PI`GO(n;>XhI=E-A
zE9V~B$<95`sXN*dbc_z&u*V1mjE_XgsFITBP_pb2ROd4YpN>NK<oqZ1?5z7H?kTuz
z<DRpU#yu<DA$&Rs;WO7Je6a0$gYX&hpWJg?uR&Z|(at{o<`69h#QmFnqLK68>~jcK
zjQ=ToF8(L`T+)>YA83Lcie318@c*$-4K(~F;e$3c;iJ>ory_utWuGR158)#w?;F|Y
z``I?(gGq{^-#^>VK4*~y;nM)Zrz;5`XCZuEn0Ozc!MsNX0gZiH<2>2MK2=1?O(iAM
z9d`b9;j;|Fr>hV?+5gEt4Wr(~K8Y7>?9;(&5*l!@D}+xsA$+oI!UucNf3r`_fd6El
zHm^Cvx_TEo_uQC8)VLM<Z|-5p`ETxN!FQi;Ub-5d|4;7e{tD#IQMm9aUxs^RH2nVv
zA6W9<z&*J?*tlokOF_Dn`Q`r2J>SfvF3%H__l?}s9wmhEK_L=8Gws~dfmdz{>*ohO
zN%%Mk;q%naJ<q8-HsM3ZvNqu(N=B8GJcp8Y;Zxj`4VJ$BO;)<~VvRdrQ8?JGPfWsb
z6IPmV!o<NEa*YmQHRH(!IPJpLQVYd3!@xcC+tH|lyP&svvF`foveL9S>)a(B*URg{
z)AQ$gCvnBP0uUhw*=8w01SbHQ+TFlJ+NO$7c`k)3%2AUy3)f_lkuVQ(-LVO@(3_2>
z*mdcBSazuw?37!5Sb>xb6>Lpk_I9oNpaJepLKEGM4WW}q_X3LC<brU8enXEt!E-v@
z0R8&+KTS%5ek{)K<qO`sC4bs!+)P5#&=&i#HM-A~u>P!>wEvMw8Q7nNBu)eo5IELH
zkjtA$6p5|KV;CIi8=AX(@Hq$A>yZE$X*F7PG!&UY2L2fRSq<HO<!*o0F`)A)aB-gT
z++z@=5i((7e~u@_c#NF%0nA5#ubuMF09M1uldR!Y@KS0CO_XzeQvJiDfDk?V1dCUY
z4)9X(CKcepSXy+Fpu7KuKgx{(%-{blyv79I+$Oz~`js*y;*!eK?*8EcsAhxI*WyEv
zT=<a3eIX#tFT`;{y#=3m!4*8I8xExDt(`Z)Te>63I}oo?;3=*f^zU@M5mtgX8H!hp
zP4!NFM0pLcKedMUEi6-_Gmblkf|wUBBV(w!aO8V)t(j9iohIsWZ<4?B3BD=Z)onhw
z>~inJixkg6tc~lwXEHtD2X;KyIIX=j^qH(wYmzq6t<6+osd_M9!UR8<jnhwfswCCT
zG%DW=X7P2ZJ>_wB3dc>MQoS*6N|61xuWjP4Oy6O@gTik#xx$D#GsDH{)F<)$fyy;^
zVM;b&Xo0ge{P-2wZm`Zn4h+_7iA&&!Yb#@{aY=?FuHDk86co(%&gdix=aem6c##TY
ztm~9&rz6_2Lm;zmmg76V&H`AUvcOi@fZe*|h_vB~?CwAiObkM4<aQJS{<X?NG25Wz
zm4dR3#?dB@98AqIct!|d^conusaeOtXp?5i*7pA4ZYW}7&)Y{hqhBuOjD8xw!05;E
zM=*LTy!ZD;##Ca5vaGJ#P%RY)z<#NDizs9Y1s4rX&2#^jr>D|{UN)DHnYc@JkeVSY
z4}~I41h(gRK_0B43x%yP-YhmLE^o6C-|HF(L>65fmI)ZCc}5E|6W(S~Rj+b5d&M(f
z@TA?!^PTS&oAR^XX5l*N+C!7F=^Zvvp8b$o%nrK@>_{xb$b_fP_z&kCEw7M%A_!YB
zpg;mOKg@}c3lM#VF@MPlv%!>MtVYJkVlIx_{zkOo522LDEGgk|E?dex@Dle2wa=rI
zJucvI|H2=~NB!&vEa%C-l=ZJi{rFqMI8S&#gD$1JJC^|5A^@so0K!uXP2$96)*Asj
zuuSwJe$-Q+&%xWfU2PTX{XmmJV;SC|-152ImF2@(yVT5woCvymf(SU5*#CqxBo0v=
zKrcDSL2u_IzHNIm55bSmIe=DTN3bq|w;phaQ-8HX47Nj5R*hi(;q3s$#<2HzZ{z$3
za9-Sxf&_*G#IPvp&mT2<lO!e1j|gx8v_JqVe82$>7l20N&u+J+DINWqK#snV^UI#r
zh*Ox0a1+%$@K=pwCtM6;w7Ya;N3p;TdG6~oF}S&|BACWm5E@tGPmLnQ&3-lhYa)NH
zyq2dv!XdfUxX25Jo`b15#fXcMy<FtuHjQ$16pJ)?{9)8?#SZ+##Baq)>5pWk`)F2E
zx(VjR<@k_{eIrRj0w`~?vT2}Zzl0sAXb0z4dH^U9O9bLNbX3uYT4c`jbdKZSh<cK9
zudwN#PNc=nu7`PotW!Hmif!iKycj7Q9$LxrqGaMum;r1M!**iLiyp(O8oGlwl(u77
zkm2h-NE?AK&xzYhO7_6FvTO`9A<jd;8ALait#~Ve!jRk$lshq^6y?4bl=*_EA`D4N
zWubPi73uSkj&~ySoGX_G_Mrea*b&%-X&8be4N!p5i9?#$ABlC4s2PoAaEUT{EbO;0
z?wb_dnzShCj|Z}{dn~JJIyan@)?a*y+FQ#}JQE`w@?XUY{29+W?vT}zvI^|dJl}I1
zYprWrsgO^Ig*U{6fITi1VmK`)e-RK)$@zR4bqfJ+9t?9l(x$~4cc5IX;iIqFCZw`z
zJUgv_)I%9Hf%*5kcpWSa!3#0s{2ZaM=^NHx`Pe<)UYqOo_TYQxAlHU2BDgsh;oXy(
zbI{_^N9T~qnMk=cfxYYRF5oP<Cg4Ccw1c`rO3K)Y43UbRhfT$WzKP7o|3noo>fUh(
zKMBW+FDBs{!bBDrHDMABZ*dy&ZC%>rk-Z+b_*~$2u^L0s8TshL{Co^U@+8*V|5uV7
zqBj(G17D%YfB36O`DPM}iQR8O$EiL6vfR|nrI)xd)H!D&fYH%+&T(8OhshikB%jGF
zCOY&kC(G)eMR#K1{Z>Tk4ZP8dE|ih_%Gk-GhqwqSdPt^?tRrQ5SbYF`IGF{7{n@{y
zhcVFV&AIfVJx~lq7e7ZAf9Mad;&)kkjUIP^1v=D&RxeNb8bDt?=*x^wUc6&cw!O<@
z>L2}0bTX8~viz#`^1A4y2O6YDLb3jdZf^EWP%2Mhbwk5`;oV$!S#%Rh_8^dpx*1t?
z0fU!6U<$jflSaTalKdVN_!xZ5e2>-2*nN{%jK3%<hQe%ok1B@IHS?qQ1%E-AmOm5)
zt587-CjCQ6v6T+RhKpj7t=Ly6R_3wO6P)w^N<nCXJcC>T7ZdADV_#Hw6{7<`$o<A6
zF5om)n3Tn-YY+FZhEE%Evg~Ce`;DBR5Ub08NqQg7A!#{((JnQCNChu<kX}EXWmVeJ
zk8VlxqByfwKAz5II_J4J3aFs?&tSC-dDkI-ThD-3h|hJCGHwQIC|PgG%7z*2l?2q4
zYSHVxoDoH_51gYiSU~K!K77or#<AGMq~?AawhDMryIsg`pIfIR^37RCW4YT3`%6~b
zGFgBj{2E%RorzZJUo|ORGg(}NL%mTD3J5sT<0dGsfwHWJix*k>R|+Sv6)2XPa~%;V
zVMW-N$^0|)+erg4zI_|Jq#9`4Y7G1tOp_<GCxMjFuQJXg=|BSEzeGmRPF~}?Ur?hy
z&$thb7&V*)s8j-lLu1tVL1Y}<#%lzWWPC#zIU~bjm98_HhtcT@XPcR41>2w#38324
znXH=e)McJExFpL3SzBhZK{0nkdy5Gy1(-vSE9k*MWWC7vm@>k6#)->#q;eLk>gy)J
z&HrAs1bLJKav=ceEEeHkAnJ9adX0I#-T+9#YU?aGO_a=U1Sy-v+CzF7MkFW=vY4s4
zb59ybJ9`CTu}h&y6gY5{uk_Fcx!{$|2bZ3INy(cpqPXYE-@=(|a~2Eq$&1Ux6DMSV
zz*H7DhsGEyD7Ug$6Wo#e#arBw<Dx##T}DroI@!265P!*}q-Nu^wf0rKbe+xWRN38~
zR`{2EUW2J61LC%2vyiH#R`+9bY5)%%CT0sb<vz}44dRBNp8d#o!W7`%f~OS2#qA~G
zK5+-qVvuGQN2NcKw}0Q+tg7UG5i;k_SJBO0V`wcMu!s@cwZUHu$f0hu0KU`<L)8c*
zTI%4R5`t<g#%vZFegW$PE@aQH0OXRT_rofVbxwwmLYNIaiJeT+csm~VjQfB+>%3(P
z*PcBwUf4Gr<ZBf?Pxq73jz|*uvJ*L?qWwmnl1aw>w_Cj6R(ruvUT`c5+BQ#0<{Xyp
z-vv5+PNBJ07Hw2&ZK7=q$kcvlf?}D&+BBTl#eqy7Sq93^mD}@FkjnWVPO25=yj;G~
z$(0-6D$bC(tQto6=&Uj$ywkISvSKbD;Rw%CBi#IgZG<z=ixG|=gN++Svvo<%4GXhu
z(&YIXF3;r_or%grtenYa(~@SPlWk3BSH|YBZWY#df_@;VeJ+Pl0JRicV|<Xq;(H(N
zRH|1(QF8x`rxrjPH0PYfVo2++j&JFoKq!GDmZIxZP>6E`tq>sehUwHvvA_HKJbJ+c
zwcI^t;<4VMf4o3z0@b(pYK-E+8O8ZgM*y+~nZYwJuVm%bJmwqScr%wE)u2Y~uf_-M
z##x&}V+|kwqoZn~B<3=o;fV(vx7p{mlVFJZ5ny)P_Cn!%keF`HI*9d;Z^rf_7kuPR
z>;a>Jee2_e7Y`ha2BoY!*x@MYtc!2Pd8+g#H!+6|(D#q{u6__HLyp&jS8s9H0F~J+
zcIAaRe$Q3T?$7Y&Uz^3Mw7DDq0=@j#Zc!OKpQY&k@>cfXui<!2%vhH^EZU#oLAX|V
z?4V(2t@&1^!UERRP>a6WEMRq_=VFK;{ij0FNu~AK^E7@#A;BYzJbdFj$hXg#RSQ^M
zy;@oMVFA?N;_qbT;R3e6@Gt_vW-erLhF$cvdm#(27le@l*qT>}0yl9l4=;P3EDibj
zdB?%b_gut``uJKK`1o&y9-u{l*#|KJj)XfF*~#*Z)47U(-^s@v>*Mj00Uxn?y1Hd#
z&6{^@n``*nc5DS7vvEOpj!`2I%vr|<nDh3AT?XgvUd7pO^;%hJznJwjcLt{mHL?rE
zm<Dl@o*dIna)rDYG#XCvspee7+)X+70B@q;>0qu|Kt?R(gm^#9%pcoWg?9)ZE@l(z
zygicp#t(*|qSYLV7aocu`>tljg+6r%K!dHub3e(-!X+%oyP!4M)xP@4vDZq$5*BTk
zxE8u_@e*d1x?rf|m$F~6d8$If8=EIDdW&=Rm*@<3oyOKQ_3gV(h$s?h4_i?x_D-*%
z{E<?!NTgpvx+edRti!lqqMONUC!O>M^4c+Tdk*BlQ9dgua1J^3=$w?@x#Oz!yNeOp
z>Q&^0%S?3P;Vmo<v<=3KQ0@ppPa7K8P?P!}24X231v_Ghdr64Z5QtG^H#1PnIhb=f
z`{cyK$Z>^lOYkzdI&M1(sgt;jg}6Tcfp`szt#T`(bFgyb;6~4|O2B}ebShaIll(#C
zl)7C0$di(x{sF9WF}7~YaEawDB;cu&hY0z&jQQJMRb9HAb*uD*-sixWLWc-AAS*+b
zvxrIuOVaM)8K~vUS!lT$yV2Np%A>e-aY|ItELY{#ayH$d-w$;#{p}In!4xspYP`FT
zSnX!vnIsy{T`-AgVtVT*Y>57yDvHkv)<%z@v;9}FQ0b4&vNCH0TQB`yAS+RyvM$me
zcm-zGr%aV(RnD*f8Jnszb}kGAg2q23XmCQcYqJ-jvQ{$hjM$A>q`%|CB?pUQ`$~#c
z*^69qurcREV-G}|BzmUd#Ren`?L)Tw#$nGbsdRl07;`!)b%=CGk9~tQO{~Uas8j@7
zvwPf6WZTa`!$sYd&Y!a?$)8hJbBZ~J8YAsB=29|N5jlP}pY#P6FzFM34Wfcl8}8`S
z5u{m-55AR^ji0ko6}p*-Xo-+f%GQ6T`Y4T7u_V2-yE1hZ>nxek>9ea?Gra=!c{T3G
zm^R8vgVpTg3JOS`+b66EtgfD`LDly+$oYS*W*NGS`FD8tqO53IkS-HSg5`^U(PY?K
zB<Bi3b{CbNytY?rhe}0bsdH1zIXlBLc{xY{Sj$nbs2j+#>Kxb;f;ADrO(?BJDwG`=
z#Xof{E>RZIWY?#hCh@4H(WGz}vWO<lk!Cdx`&w3F*0N##KQ$(r9DoEXBl?uBYjKPG
z+a&=``B&GniuziA;7}B??fDXEe1;#XbOeAHe~Xb+QkkgqCF|J#=<)!kZ{C?WacqNf
z9=qBbvK~#?P4-IHgOh?F^u9!HQ5@FVa%+5?W+qTMZhoIwRhuh&Prz=GH^VO_x3wPv
zCQOPeYJqB(d4OQ|hi725`jX9+&v0zyEz5X!6V9N!k!ZwfT!Rb`H<+*XhvK*PqV`R=
z*dv|1>5Cd5{)e@u*+*Hif%$ms!B4Ak9fYP(dI~nMNd0nIxxayRs`5|?a7yuL^_Vcj
zo}=<{$n=eH<d;sH6t<Dco`+9iaImQ+BWoiR&i`j48>EwTM`fkoCN@4ckJ^0phIcbi
z2fJM7y(jGTo$G?&OBrsyoyXj5#n?n?4J5=~##VWI)+HpLLjsggTN$ge2&iW(5^+Tv
zpIw*3X~V9Ydt~*&g)|7f2|N`G3h6-5#`YksKhlJJP7NzhqEFi~9H-l^__+#%Lx(nQ
zg^2Xqj9sMnUX#*tGpi@XZj+UFH?x>ZUoH`{4JYbnFk5zP#*NOGYvueqn^~}~QoF_W
z+_4*E#bYararMAytJOFa`>fVmS%|?GlUSMAN%m1PwzBe7pL{8#+l?sd=?RjEwnsiz
zZDrl1*)N@x=UZ7P2@zhE4%;wU=V+64?=m#M4U_eQGL!YCBIi%oj>+1#;*Wf?Zi3ZT
zo2*V~&a#=hSxSIeK1Q;_doN!)&nrzXsdO4|0GW2OAm2?WR@4U+s#<{I6LYiwVp$oB
z%sTH<Ce6g!^Eqp7IbffOeb#F;aR<_@#_LcKFcUi|6~AV_?kN$}^9Go#w4aRqn&mg0
zU6Yc=eC;^woJ$d>5ff+%8lX$|IKZnh*RjkZegcS<#v1+tase-V<T_>({LCj~yaPX_
zypJ*6tl|5BbqQ~A48DjPrjJ@n2X)>`-7WJHE3YADwieb5C#*boV*E0F(~OS0-lcDC
z^e>-_auigipmAn`ZjEAXoN27ct3EB988+9dU7~pnjfRIjnpA_p^)Dq!#8l)Fh44I4
z({I6oJMcjfh4gJ#3zS4aq1704Euhd;SVVY0A@C>#6pCFX@O7?E4LpR7?$|--<^R&t
zDUMIia=U3tzDZF}>MlYf!k`9IlCj_e2#1_|-_mx0uh519;`&^%8I0S2Y-|>~0~|b5
zGxZe|>u%;#VV+1%-)&Mt_OQ^5KaX*hzcp|5H!iN=@AH}Ll)1+UZAw3}rg`RJ9)2z_
zuBoWoOe+f?0bqIsYXyq)1$gW>BF7O=p&kkSz+rn4e2BMIpVt@BhpL!qU+^fyVSk~V
z+rxsI<vFMQ;tHs+il*i^GUxV#xH5JCvZTNHp}*#w8<@`E0%%u-VFr)Ihrp7#v!PK&
z>}A1$SI=Vlpmr0|>=Gf1KqJ~6;Ki|S2z`zNn(w*g*8!N01H<Le6NxT`02WNZKHtj%
z+}<HzdG7u3N4d3+h3K0I7-1=8VZ6VCUoU--n0XHfyRXd#h#LD?HMbkza}Yn_j{vc`
zD@P;rz^`OKazNuxuwu@^?PT`|1i_Sz`&hJFny8+vRS(sP+F>zeYY*hLx9YM_PO5@F
z{Q4c*OW4nRMwT$&&_%>aNnPj^#ZT~3k1S#q=uzLosYGzo0O(lYCT-{qynwu87jaYg
zwb!mreEW%Uzzd2=)(a@fA0Nnz^Fv9cU_bL~a(ou&!0>#N6JLNa)L<7XOk-YdGv^gQ
zGN+R=U4ozDc>p)UzI-3z%i%`Y7l2mstdeC0VHbCW5(#Aj8GZqYU^ntvj#CA%Z3Duk
zwz9GB6RV-XG^&c=DWd9f0q<Q(tU`(WS*2`|x~5dqV?<&kCE72e^%99)O95>q5<60&
z{qk3=NE||m_G@ARNQBT6mk;^CC{YE>3)`WW*TpPwDVYVY4`LSN+_ueu+K?<cmdx9R
zB#*^MFiA`^K{(izLW%Pui8x6vM<$jpu;^V*6tx9c<((E&BbEv@5mSR`<~+6&Sw*;J
zfFp72k(7M}tU}e9WNa^KZx@UKVC{RE80XssEW*u?;N`h{;g2%5-sVufrK7UBfcaN{
ze!En~x~PcrB^zt*I7Q_TGCvplQoHCNi)f(k#E|9n!Dclt?kXCA^m-3TV7ue|SDlGF
zs6gD;PyDFab%e(!@1#~UUQszm4X_{3;567NKlBiru5bA^&ZQt{pcf<^D^GzH3-|e!
zK8V6X`lcvl3;y)8?YM6pVMas#bTs$R5jI2Wi{<mZqpYPAfu*6~DDDAY#)E>^qpZI)
z86N|WL2U@c$DU)j2b?rbRvsK<MN$^@k!#1<H_{0#KtG&dzU6x0N~G;O9`UlocU5T|
zJ|3K4LB@ezw1Bk3GlnH|1W#I>WIo1^rt(R$$gDePg**NWY}2;NO1qQTU`|7pGU_C-
zDOiF1#Ytu??KM?=k|i2$O+lfCr`STN@@`o<c8W3SKDssOG&_$M$jxV1wlrW8YM){M
zNP)}c{L|mDTDpo;+zFvUSiTWB`791cD@_EL;Ir&<?UjpUr`ZKX6-?zPxq0N59~xiI
zV{t*x!}aig3G!lj4LyfTs*9lNwmHX!dL3{hm>WL<OglRi9~wGbmm`+jF^7jHR?ZPC
z>b(k7_S|x400qUJ8|ZUn<#BQ6R`hpdUcZK(Jlhx9nq`rz1)HFvkXlgepH^FXZ?3F-
zb{<#e>L>;0;Vu!6-xOi6X%I?bVik^Zooj^-Uqp&L?Ru}1Ovv4H4u1;A;U6lKf-=yU
zmI;k%K${r}(j1_)dTT$g0DMr9+b&QzN(D9Sa8fyVp7}|Ap+EANhRwC23sLl6Bs$Y3
zLjQrR_+Nkq@*_UD1~U8u2Mt6fwNukTuHX!XG>~yiWhMB0^G>0NwNDyTczHt9W2qwp
zi7^<kwO^c+foF>d759O>{L{j1<w#8`_=z>Ix?}=C<n0U_Aff;Gn+Tl%0lO~_0#X-o
zc=Yr=SxLXh0%He(3cK7g|8c{3Lxh;%wofF>bKc@h))V0P3`gN61f;>C=?M6oetMDl
z$2NDRJwtKQ*E-y@Pui)2;~&&UGUZqyxUf}#cPfDJTTePH2+FS)am%IPbCYuFXV${K
zq*}+ha(=f<EKnzXF$?^AnGKbi;^W3;T<}K-dBYW!K!203ux$E!>I$1QFwglfxGHG4
z(PjTck2yo(g$M)>IhWeYn2`z`fzNWDQEbEZJTz*;wk|m@=E~EMt6>{JGi%k)EJAv<
zf@7Of=fiAh_p8ZOFwfcO*fM0D*8DOkb7;OX&O;Kff<A6I?JG?m%R13wZ<Iuf_u;Il
zwU|5^E#_QBi{7He7L7{ivn~s5p8}S2=y3>tdDw_hY!j{mf&={*GuUgcu_%2XS?O^N
zR9k;qS$2&z4eCQu9}Ix?VmH|t$=>)5xB}MpK63tpYs^Jws5uk-@AfCFt%TiRXQhrk
zWaY^X_D9b==MI(Zl=hhOq2Pjer&2_ofK)-`Dm;UTjBDr6u!+Kbk&FI5#o>Y0-+trK
zU(+r0ci>V^;bdo6A7|j~?G}^qoNQ}%hbAAR%OLFT*TkmwFf^CMur21P*rPUp%1(_P
z7wPXKU2E*%STxrBHX7@<#H4)o8*8e>E=sD9@oYNi+MEN&QzHf*04au+Qtknuas4#W
z_{7qU_Z5w_w>94PbJ2L3NN;3sd_H#-qm3~UA4}d<C=>M4tPiK(sbMknOT38Uo`FZW
z=%*H`Qa1ye==5J$l$5gAq|Eq*we+|H70B`d_>c^&6Wx^Czq9Jf^;?Jn^x_wGA8!w(
z@xy%$`9m(8av#2smDhKePsBU0;q!ZfjiL1uu|7lrj7&P&_Qgy!jRvve?}Au^K5`(I
z^zuD9f74yISO<pqi#(ZaV&OBv_6p9W97ZPtsbC1ium<=MJP%{^GnNQyc9@s|osq6J
z%SPBHfb$~G5KWaA_n3Rer&G}18=$ISa~>*(rl2DRw?Gc?$7-CbIbd)IsiOHQJOj;J
zv8+(@TaX2`1|VH)e*19JyR^YNo*niLCP{Prugv+4c}cYwa!Rz84!$er-}{ZZ>Gkbp
zg~j#hqjb2>qUp!<`>YNODsv@VM7+-eQhxrs6f&=caeF6E1tudP&k2(UBK=dO3rsYA
zApb%z%gY4@#j6OeSEna}6Pg!+6ME&Elu<>jWsScf-7U4LK4$iCF5>rwwZ-q<7f~4}
z?TD87V-fp6pDO3~{+-3^3^PVyhI_p15vc6?gAL4R1@#(FR$|fgaHF}4m@shbwMoZ0
zVyI?EBf6dCU0bM|P?R!KsS@ebPb+wj3Jw<GZknM84okG04=EhX2=Q?5R-RKEIT`5x
z>@<30O+}VKV46SxH#oGa?cp_KIf6TfKnqRpC?>dnh+&-F00D9=KO+-4+j!28T23Jr
zQ;P*T!~l8n5uUkA%WU`zng6`<=8cL1dwGGSP?BmrWOa1X{^7FHvzQ&062bK$kJuo6
zNKxS&tiwOOO9-6Bzh#&ERe!<qo##B`IY!bpH4bASz?j>AFU1QRX>4=l`8>4%@2AtL
z=TKPth#}~J0-0lwNen^z-dHfgLmFrDV<m~<L0^eTUEZ9;1s#dxxwjt)4&eb|Ce1R@
zTMkm#2wBPco5h6effo^frd<ye8b?Azc=X;{bU-K)8tU!;`8VprQPp8iX{aajR2%Az
z=9fY}0-27eAD|xn3-w_MC8(#2u%X^+ra=AgVX(_RW;HXW-Pch6`6D~(frR>TNBYAC
zb*O{mkT}>aHsir0m{JCPfPIJKvFOZJ4rYrtZyzchbg}Or20USF0}{CoOV$f|1SRW8
zD7TeZ!*6BcotCF?0ErsR{Yh9)+T?JD-C@JY0VMq?#YhbQ0I?BgK4tTz1JKJopD}M~
z3e>lVXDp&|)wdvk^4#+m&}PZmZ#Dtw66T`0x=d+JlN7qF)tH90+%gs<z}ph2Jo_1|
z8NO{iQHjSmaw%+xK%1n#vOC1EOOd6W^_+Xgh8yq7)Q(Xa3Bw`+NPwBY83?23KP<4-
zKLa@OA9WYV!#dme9cmVk5!%ab67GS(NdgaQx1gbTTKK~+)WDu`j)Y%?BNEuSuS}Km
zD?MkGb^5f+O0^d(S&x{Vj}{O0QKr9Of9nxGbFBGue`Wqlwz^82ekN?v5JC*=Bb+@W
z`<W0MmPL52ABMPBv}o?f8U;KP#=&Xl6${nJ%gPG;&G^AYh%V-`dVh7|GCW%Cg9Cz^
zngEAPBw`+PEEgrpt*y$*eJqhg;H^ZMRznU@GyADQt8sm*Ft*Cy9isxr#|rYp^stvV
zSGW$34K;hss&&;trt<SsEu*rhlT%Ruh%{15cb*d}7Rw)Q(SZaGyKWX<yH1oV2g6wr
z)`I;g>d4Kw0<rZq3ya=xoCXq6eBjIQb78Z64!=0xSt1aS(6&pmvbcbuQvzvh{XWLn
zhM+UJlhPZAi#sV+wqM%ZQC?D69fg}XOET3)6-pXiQlR2EAUq&AVaf06S?|ig2qSC>
z0hi$&8f@3F13s%$!x~QN&FNMJ{0YkTo>rPoe>9;-oj99r=!DOih>C%l5qdQ`t#S{+
zUF`*T;asyre~r5mJ$5}NvcP!&4|w8=4%p7l&I6%461QEsLNq%}90?QjDu4vSjRF($
zf6%LwbkYKBYElepo2n+T4c;P2&H2R=4gVDQNtx;4n#WUQ<tu|45v}y#J!m+K_duN@
zdf=x`w8u?>_As=EP*fe@9%4`fr7TnpbXKE#1a{?J_`03w0wzc=Oh$fwPF)}@>p{Dt
zE?C~uh973j!jW+Hp#I&xNL~0IStXPwCt76{pi^)B(Hm#Akxu#!+nfsJ)tIV_huV9S
z?a-UF$+FU^yc$vWVOQRp`5C-7X_HHjM_OaZiZ5suP=`XG5Ns%~c9lM#BrkPQqm4~E
z@&5c^whzhVp0bkUqWaWy9&E?orEo4OwZPx$0^xrjyG0FuMfcq(FJ+O7S{K;2#3imH
zF6!c{6NlJw?#>xVj6j`<vNGOPjfgqhnd3ZiI>-6dgwi<Ii6fE%;hdwmyN0ma$5BVx
zJOT2<RjnPKG|&ODBhc9iG1GZMtR}KFQI}Xj^^t~-#v)!pjgrzafO9ISb3Kn@IwbBg
zB+hLxx3ey%ok3YNxSx;PP#|e@V@h;WW2^Q-=Zj!dBa`!f5+Y=WgXDczR_3{>Yg?@E
z1v|09@=i%TzTV_wU9L#x%V~I72D76)%?`&Ur+r<q<Y2_dR#e{!^2TCca?pq_V@Ywr
z)V79Kher9hqS_$x_cZD*dU$pYyr&N%5Y&`H9()>Ukw~)|tMo&!apP^!#^Jg&VOy{+
zAD8Hfiex_M_B|C!?284ek{X+E6oSp1+rW&c*}cuV(_G94?-}^HL2qmLM&$J_Yw6+k
z4?41Neh>b;d6m>U(l4OvzDjCD;N0&B_IS*Jp^G}3b3-z5dx{L#&gD@waib}y@t0U+
zVd#geN_N4d+s9fObVXMkc^?NUoipjRlm0H58J?o@4i8Z|q%*G^{y!?i#zE#IFbFpv
z;V(BIogtKbx!B9ZsNt9iFG1@OA$_{1T3w$uUl?$DBY~_YX1Ohq>1ko!={coLM$=K%
zW-=l>GnE;JGFD?}3_c`KDZ9|wTmklaie?u&kRrf(ph}tkDyys;BJhTTvb?eyDRssN
zw+r1jJJ^NxnK4S5UC4rPjbs;kg#Gx+dTE_Pkw*i&?j&Keu!nsz0!tz4Z&gtT>VIrQ
z@Qg|iFEu`BW*brGhZ9t1Pj|;USh2m-&Qj$zvQo}ljduA3s)jjtLZq^?%GT=oZ(0)=
zA7!Gq+Puy{%E~$%NetN+Iy*<>I7g$KBS;MmZ?%hbtCg(Otuw?|X>U|VNWJlEuTgCy
zRTjy9O0bVw#nW_*VASkNyb_9k`O6uei<8Ob7h^Lh;^@yu?Jm_x7WV?HR60tPo^__t
z$VT5W)Ul6}`gpH8Lh196UQ$=N<*Q~%|KL4|p?+#ujb9E^kuzAKN{WDk6UnuT*tZu#
ztOd1fUbWV%cyyQyvu7aE&}%U9jbm-V#14<eiq01Mscj5-U^~S1RfD`PV<wANB2SGX
z1>z+PG9&!eaQWIHYWi45G|elPL@YGV{CxvDkwSiuuOL0Hv?M9{KHX8n6KC+j3X}7{
z^H<>*e-9+sR&ir{!{Q`34M^@A`{=6uIt;=z2YYQC16hp`ScglxCNRtlQe}OBtQ-hZ
zXGoWzfh7h*6Q~M{OR(BsS{W_pR}N95b$UPeGKZ=)=x;U4`##Ehq3ZimFv5rb6N>Sq
zr>WAbsYbW*d#EFiz~^vpuBJv|@B23VDOXif59*4PLDkg>hzobIx*7rpcK4UE^1Qkl
zm+={98^~zskEM*$wGSo}5*q3}cBOgKm7`(Ep_>4HaNi1rK3BdOUn|xQ7VBFtu~yht
z>$d_RsLfWRTn~TeT8-`iN1L0Gkj%$gdFw2L@j*BLaC8Wm%H|qsCC?3w_^OvwhX$qy
zdg+-OYCx??m?D}VoL}KHeo5eF;n;7elf95tLQTapOvMWV^2z5oDGpPAs`@RTkoQ1+
z3%wZ$&*&6VIL2eX)(KZ@_B1x(UD!U5cOhU9EegMA>c%90AU+lSTwj?A8ILx%tL5)u
z9W3ex?F;mQA0n0x+{&_a<t+fIzwqQB3s+-W&1=ZJQzMGt!k6+Cc$VwzIMgkCTnOP|
zv>N+DltQDjDOwA#At#B}Z5Q<~5tA{brfQZ{L<G;QxW!wUQB(Esn$u9ouuEUhu`iFS
zYSL0KH+Uv17iy~Q`cKEaCxSQO<_G6;$3aAFe(`?W>=W3rV(**vEzl`3+RcM{jqPn;
zo(kRf@1A1s_zCTA@vbw{Z5Ejr7=&g-r~y*T?r{E|w<<>Z88P3#i%^5XYi*9n`Na`x
z8(qgq`K21zg*gO39e64lcnx7k`|1_Ma=CJ2r1J(u03>Xu-FKRZ8O4UWV`J<@=hlMK
z*QBdxG~+DB!4iVnWPA+;`7v6jcaf<24l6Hpz9)r5Du)~@@mQE6KIA1fX(h-V-Ex(3
za&FS?w6S=;sU^^k#HVF3To1Iw-XzT^G3RJv=3|}Z!<W_!s)N{BwSmP!>H}_1MR8tP
z*u}2qdxwKphQs88`h*d^Y?yScH73AJQDtC7US)nWR0#ux5UnW|RT^vVN5*zFO-@Dp
z!C^Qf8N>05Z(kt`y}xZnXt&0Jxcos~BWj*Qoc-TwtKkg?Y$NVzi_KHX?0EA=I%d9o
zADtMb#``}C#wcV#y>jx%#sxm7dRNh^cPk9|;wW{T+nB~QNXBK!NbrnS)7`v9f=me`
zqSX+oevqu>MXQm$J^G+W6yi6P;-dc$%_~0dttIln(|eIfS~gUk3W@a_<8WV>Q_NpP
z+}Jjd+Ufn4osdp3R90I~JnN`cagoyHAb{E~QjXwU?Vb!aa&T$wD7ZJ6r;0a*|HM#e
zZwz~6$BF#cyRd_;qXruWV9qKl>Zl<AKZP7WY~U$IH5^kv1@}0BUnzKcGEWuY2RVXY
zC-S=iylV`=&uCz?rx@QdDf^f7j|q&1gv4$8qKMh&C)U7FUig}R!xuHGm#i#~QENy?
zhwuxWzDi7UwOp;wZ28wPL2dn*JqX-{$Bpf4GW4LOb=AklF7>$#+5jm{eAC2gRO?{_
z6RU=mPhecJQVtph`g)Vh2}A<+zK~Lyu09}EU1ID~Pe35)C=4fREFjcVs~ZwG&9N%g
z9!?GP4#gKtgUuWnP8m>-M3VEGz34|hl`j3Y!snm$)Gl}&;P*X5Tr!5^N!aIn?3~AL
zC*s<V5w3}`Y0Fa~Fs`&00^^KGufH9fRv$zSi3L%M8$dLCIKZSNb!`#z_6Bg4rM-a4
zwv~c9Sk(T2rvhpn4Jv=OGglssbWP56XagpM`0=9y{m^zal;luCN#um`vcHMHWGZ`6
zW92ab5USR#r5Y<1<9~&xqOoPr{YmCErpb?YA#tkweFJo1XN;{2>3~XIklv1hBG6E+
zE>%Sef5LWZL)9}X0HA<$7a>kE0mq_)_#y$<T?n|_Td0Iv7g^ca5c{*HHE~|oPz{xQ
z@S%%S0~)U41wPRvQW9!eNO~q6E9aIpceKuoQ~Ww#&Y|BDeOJRb>|}9jeT?ANZ?IvD
zQ&a0y1`vm_;y%T>a?xf=MMnp<BLw*+kxQH9rH$0|8i%66NT3~zrgX;%U)*FGOJAX&
z=kI+?O6a=rF*T)HvQskDB~P3kdRyqyBK7VkB3Yj7gBGA%cEs+p5qeiM47<-pYOQje
z)<K`g@qJ^pHqeA~tkR*e+8v+s@wut7nwkME%Ms&f!3R&7hH(NECJo~|NE1B39Vx|d
ze*hB*p$akV{=By63hw~yMtq5){@{x&zRyV;!go4x4mpkioHDtI8q~gW1T{A@th~hw
zBnQLv;O*Oaezjnj`ZlaSgbG6p!^1%4%2n-{xqG#QpU3ScScM1l5`lA?zgrWGSW~0d
zWI?aPn}}YMItYHrN1~;VR^p}LmmFTAGi)j&n}VV<tI5jJrq}>=!^gp<YOO}oYH<m$
z0s@^YYcNcr7ssRuiE~GAZW;K+9P2TOGfOvoYSJULnHmQAKiC2DPcyY|?+?BzMgL4e
z{{cL;K(n>a!#+ls!Lz4=KA0kj$hVCJXBx1N`{|2fEJ#TxjKtK@#bfC)^)M+l;?)?b
zGnk@FyxLl-?gM{>c=gMQmp5p}>M^O%l1*xD>62h=JWcA`73Y3VN|d&+6r0pfr25_v
zEHXAl*CJ)*g{%gZc+!L>@P+3Ym|v_65MFd3g_Ys&_0&E4l?82O_@1YVmEjjyXKeyI
zdzKjJ&Ff_)Cjk<mbGU6~SkgtT3=#`P^Ypy^J4m7D?fC*w(Fq{=0+E3oYGQNskn~<>
zp6`v2t7>y;NM&wHEJ6BQqUsx)=iCnbFI2#ZgJBBkX$o}OT@zRw5H^&ZP<x=5n(4@+
zAW2qylhovTy0xXo>|=rS)isogS^jf#!JT8oSRIC2&io{F=F{rv%$N=11Er5Tnw0O7
z)Tkg91l}z3baf)&VEfcsR*Wscd6%)VY2HGW4aLi`u4J}Q6ATvvpjRAfq1FT=wcR8u
zf3#3L;1gFcl%$qw3w&<D=iHWRBwlBoMXX|5QvAVQm|jnC&g~$kUhodMpW~^;*y!-9
zM8jn2I`)tr*}sS$ZdolaO-4uJL(!4S<`!PAVq#b8U{Y?iNR5%2V81pdSxo^3?`?$9
zB^hk@VSAJEAXzoH9*y&Eher94ajv_Wr{alu>>F@j=^w1KSaqq<MKlp}<p>lItnOa1
z87B9()@oJhSem$B+3u!4FK?-Z!sysHIM#M(<5zSSyHh|}$TKiF{m=jeT7RTXLz)J8
zN>dx;`WoaO?Eo20BGA(;M+MbfO9P+Er>gs%m3-J!u$iR}9KmXjtrc~EVv3@fLnxp%
zbE%1~nGaJ%2hzUs<K-=8(yDjWIgP@J9=nd_nXOs>U>eb*<Dv(vMGkgq5oki|!u%50
zNp{#T+6mZE-hf^2k5={WQYYqP3~9ya$nQQo7veyj6CK`>1~B%XHfmtAbvzLrLE@D}
zTSsQo9>KC2^{9RaQGbv_(ani6*g>5rEvy2zGpkX3|M`@72YduTubR_0@zHEI)U~*x
zr_`l9xd^4;8IJs%qm<o%<nR~xCwXoIlA_6Tr|AKraKy)sRw-P(NKxw>h8i&mTBoQh
zrP#_)@Ke;t%6&g_EJtSd(6%taeC7$?xwdMo&!G=#HMEBR=~Y@I8<ko;<AxV@9D}`=
znst9#e}Nz{y*7$yN|w)v`K<>vTWL&OAlXVAq|;h<n>$rnj!=obxaSQaJ1XJ3XjE!m
ziVk-vfjtbYS--m=G>;B7Y$00ipd=g)zwbb6N8C@Zj7}Ml*(a&K0rivU#Ug+|p42I+
z^YC&!0M=DkP%-OBtY&g0r_vczo?PNl(r$^(rPyM2Y=cJm5w;&tL%<eiJx)bcwVq7m
zNI1{qd7%ywXih#vX<^xQ2o5!1aH?;{*#?2Y*!f%f<IxH<!P(+5Yj`;{>ZoNWqCR>1
z7Msb&EVP6Ayd7?DF6L0&AK=fwu5J>?bif=10)7tGGyzMwI5M@?z^1&Oa{`^rpi>&H
zz(@~F!rRsZ1?(4A!&_6lr>ujB)z2Gu616kaL~Wy>AD*`0wKdxlT>S$|I`r?rT;x1o
z)u%Oqc$4!y52aI-S~B1j>hl5r21yvW2lWE+$NhKw+3l=&_61>Qm*-vncf7PRe)zjl
zhy3ty!a;J<YP=AQih1qGjK3Ip80=ZRUAglZxJ{GSJc=b*FQH5*%4CW%!6?I7Rm&Wn
zH4X93LQr6|DA12E&H0T3;BNN_p-TyPE+m*^YID0^<ZyHygEwA)Knq^?wsso{<EcYL
zCVR9bCDFCLx2X!60VBPP#UBSoN&)LFdh?!q=s2UzH`cR*y45E-t@L38P)l-?m5UwJ
zKMfNHVSzf6u7>M>Gbw+it83}+@{Vez^uh&aW1ZA6DbQb5T6R)f8**J>1g-XZqkmOv
z;gKBLux*CeEE#+cI`As!q=r<xj+a5P{a!Ev+wW8m)@t-Z-I9`vmUdQ+0lP8OD3u6y
z-(Q!Px{k3Gd==YS&9y!1Ozx)Tgbkg$o0j9^w(#B@LgAbbkmBbB<+Sqx{N?8bJlhx9
zwiBTAuBv}fR-4kqC^?z=&>5E8N1FobPH?6Hyjgho1KY{WfWpSKgduGU(hwrRh~C(h
zKK}YkFlzVo9eXokHWkS5cI+<iQmJEwhpoi1!YfHTR=6oqr=AwpMfDOoX>-iHF+z`m
zQ@cZ}o`4U2tWZG`B;glcuIq`_4r4ELvv4Yw4mwt-jCk-f_Q!P!MIPDnk7f~OTdMpE
zGo_%1>aX`oR@|~T`s?+A3LPZ^32>cJO`J~+C_GMz2GW{yP_+n@jS3KBJ^u0-Q+}w&
z*b~V^Js!IE?rlWw*mDo?!`Kf$ltmwn2+yC>Q+3ysc6m;pu%Wt7Pb!@O0Z0I-j(Z`J
zl$k@jhU7o(r4H3gv`Q@+vmw$qtoy&pRzs2~yT7kGS#LNM4)vkQ0Ck|@E&BRy{D#_w
z#`N`K{Dw{hDL-_e+EgdSBRJ}rqK)smu7-IQ=O<4PFX8u%QT}gDC0Zd8v;)(M!AO5T
zyrE&hduXo5V0B2PXH$(%6PAG{I7D=XE&TcLc*F5@qf@@?5Otz1W1$Y74x!-f{jiRr
zfe2cgU_;Gbi=QytdPF)$cc9sd|8TH}C)RzieZlda8OL{edOQx5Iz5JX%$b0@(k;`4
z!$cDTI~KW`1I0NY3a}Fg0%U6Lv``Fpy(fjgY*Svo1@+(hHv-r_-dNvj`%9CP@P(kd
zxI&MJseOlH2ly#UOdG2DSG+u_WHXb$YN*;mCvAUbQofc(jB>3G6Qk8=Ld;DfQH6UG
zh(zbWB}#GDh7bLUUSS#&!rU}Bo8}O8w725wJfg9oPdm`$LiUFGI%zZ_?+vfeqNY;!
zgAJL6pwwKe(xCi^@M!PG)Xj(JKU{FE##RWYP~=h%ZH#ydHxjo40yb{`_kL<pvdfRa
zbtA~YRM^5l9qTx0u#3Mn0^7NLr%Z}|r24Vc{gEku*+})0zVfS)g!6AN08b12nK?!c
z_58FYSwH(BYLVD_<}aGn;*!qQ&fChOaq3m6BcdaX9<N@IKKjc<4hc1scP6M|-nZT%
zn5Tea$-K>9H9^Hi>LMIOphw!#&8WL3(B`m`-gJ{+RZOB9Z&OA0Cyo_~#|KPOA5<S5
zO;vF*2fL|ecTnVCvL0cg)Er}!CuHd0igWo*1GHr|R)c`3^sYL<aNZ-(DS!OCm~PUj
z-%R<lrl_5DQht$1xja>^*1bk88qFm)iL?;H(fA3ju^O|G0xSWlFfj-^P-Q$!M{0pc
zs)HmF0C9r|_Yh>1bXuDq@2RPk$NmmpAXeoVRRDLX@2MN5^;lbaPE!kN-ML52rp>-P
zF^XRkM+BbxCa0u*+)qc;!y+{a!C+gwuVz<mPtnWJ>dO9(<II<vTkosUh5;2YvpuJ)
zL%c4xH#%9m@=b^ydV@1E^5;xfgLMWESCrW}Lk)CS(u{a>5HoKjK9ut_)RWR9ME6>m
zp`P_fMRj@&0=W(Gt-PP9HmrFDyle4CYSP|t^vN<4@RRli(C1`oD$@BrN+=gI)joz^
z^wnsl+T1XQzNXGpM|)89JG5zubpE+55}(XeV-1t(tM)8x`!0Z;d(Tp*`+An+W2xO5
z!2w|?PH>R<aF*K6aLO6@CuFHV2mk$x$!SjkT2I<bq&h&KnjDyk5OR&O)zQ*eMAi8+
zTQy1kH%!XCY&F&QX9T+u6?j=Lu|``=`6;v2M>^@}A5Ho49CfxNo&U*{e{`N&UMDT{
zHRYepRbBOxH^RtV%~Q`ww*hwZ0<~qv=g;}6Ll<w1GhMdAd0{c8D{f>P$07|omgy*=
zWnHAK2--sBxz9pwJ)BUzF7gx!IY<EGnREWM8fSmYxsh1STIhn#6%Bx+$Tf}otc8!^
zTU?X|FVO*40WlOjNi5VL<=|bZU0%Z>T#e$Y-t5!J4?sS7b!`QHg?p$fymxk>CQk=-
z3)dr&_-b=1aq}`{*;cdsa|=}$y_9_g9sf{`_Is->mFRGV=1dCywTTAhfZvBc`Eehq
zZFRoe9@D<aFwd+zXT3$|yFh;VJ(IHZV>R6HAu{t1e5_{bq%?%HX|Y62N*h;+z+FYm
z4tfjIsK-yZH(_UgSWHT}2`{jl3eaM~VHU0d%aNwAsWqXr<R?Np8As%cw)gVQ2-#ue
zyBJg?g`c)a*z#D7U$4^?{^#4Z%^D?#2XEkAL3OcfsCV8RUwNDn%I*15<(_<Lq8ogC
zSFjg3P+eP=ZK4yJs6e`FHW~#!W0$JKeLiYMNWOo;QBKfhpQUOqpXxlXV%fY<rAH0J
zV?5iXv{8CwNR<wol#@!2n$_fF0u}Ki^*57R5c+=3i`3la@MpYjQqq^HL!?D(O-lYU
zwRXs=(ruP19dgsObh+A3y0-=aq?fA^E}z?}xLozG-uWa(BDe9xFsrf0cbGN@Kys)3
z^bemlzh5vZr<bdN{-}kMTe$FP7i;aOCrdw3Pe_X~&Zj?7quNeRBFqPzqtWh#e@jHB
zpt{E{*MqkuaKKLw!9ls+l|ldKt{B1GhV}R`z52q2-q@F8Vs!_UZR=+SRr%lmpE-pW
z6Co8j59F^}p}Ocw40l^URhyQN+HVpUtRlWTCiUBgrEAhElN5rFXOUlpdp_MuP@WdH
zNf2kj-0>?v^i|syIzx&#WYo~tZTm}45tZ)5>$Z`h(NHdFc6KpQpAs<7N_xWu@~Ty8
zs)2u{f2lt8|Lg}7o-hgwOC$FMP!BGTSltU(zE%coP=n#Fn4h^pZLgDjK&&4&s^PW2
z*AeTUMc+aFf$(FuO*N!GgA-}ZAp7Pf^eZ*d>wQd?17;c@5{8IPiWm%M&$Mr*s9&jG
zv1itUa`q@Vh1cmY8x#JmCWL*5<E62uSycR$n$;!Gc_EDXFa_?=^8;@`s2(txebS<o
z$?Ogo0!FKeJQen`X%JLo%(^eq`ykycE?$IMz|F@usU3S}gR`)i`_(MK>p1w)r~vSn
zlS+Z_BEW3tsQ~{2#1nz1t6pgK6Qpb4=i}WeWgLUCubSSZEMTf%K%R3SdlOmDB#$|F
zK^(L(1NN(fO!aBf)dn_M1G|H`J6D!9u;i&hCl&4nq8Oc8!Rm4VuCbaivj=`>>r6_N
zs>U=9fZQ%hL>wLy1phHu!+7w^AgoguZZcPOhJCjv1O)<6AP)s_VFMF(k*Wq}{C1Bo
zB?q0blnA$FpPfV`<8h>*mA{dXFwm4wrw8dt-(UxaH3U~OPf?QW!Qm~(`bJHeu}&AQ
zbYw~lt6-gb2pA~h>RQ7)<!fV4HW7?_*^mXw)^FotbvwjNYrR9vw51JgGfmmLSxxh5
zj^9>eEpVWnNtN`UCI{Esj5#ONe!-Njj{#HChC?uTDLKc%$D6G2T<6E<B5S<zIjVW}
zFH`O5QJmZ%Be;DfzT-h`+&uRxs0eouzGfaOY>0~zO2vzlgA86Mqtv-LIlA2GZ5WQ)
z%C=!?A=3J7CS~Tu$u;^$uBK&1X#b(;vDN5<6h1dna^H0!x53FNx!pba`q>!}Xr8R8
z&-Z>v!-`$F4!b{km2~<+%Ej6$H+UWIRQUQ&gzJjjRJB4!q~k&?{#6FbQ~VJ_;AUYn
zK(HFakj7<#=Qh<pTtY3IeecR08r`^auh6NyxGz`INs;?OBq|A0Qv919{R&OJDFid#
zV>2Ib;|cCW{_$9AxZ4rO$qbjWuhlDFAFH%q#hJtnbIzgEoJWP7?kex^Qga<td(V8e
zjeZ?ddgiNJn!LY<Xo~;_Em<jOZ?>~Ma4qqD_y#uJDW78L`38IR@8+45U%pXiNhfgQ
zkEaA7<)d$r;%7@4l>;qcH&WjD#H1YGjavKWnv_3xt8M+}D#UI>NM3S-AP*HaK|v6_
ztDksPAT0onVBPS0+#c1ZDT0q6;y7-Hb6Pmm2t!86JirDb>v$7O`30}-E<Xi()Dgx!
z=i_iG)6R8bP{y-x^im~pFOIl|H<Fc6d)2_m_(mj|AcJO|MO(QP`4!?>JM0WbCPdoL
zH!x<~_Nu-8n>;5XQiun{mW9@UI1k8g@jPA$->1gZudEV`h6ut7IF<{Tu4F4egTE-%
z1ui+Z(6Z(nS^}Q`WKw4DQ$wORY=4ch<PKl*#4o+krt$G-#5Mdf#`evQomI~5Q}Hrk
z9rt)d?AfQ*)CbN}s_a*v4SU`|$k?gYEGy0owDYJ7JhgzIA*SS9uo~~2p%K77^cRx2
z^z0c#<7Sl7ByI>Ei=x31Fa3#&2lNX`bfkFUX*_?#CF3yISHQ85T%wL9@{Y<)0W2lw
z5`S>yYv?oxmWOqb1Xwa;rKKuLL0r3O=ytSbJqNm4Z0cX@Ys29UGzq~Nf#7#YPbR)W
z+^C9aP2cuZLJL%rCq0U&c>_6L-s<hN^ui{;@{r%od!NKBxdm!W#-@!XC(9JfZbEP@
z*?1sT0Sp(v&kLzaai=ZaM9#(;Rf+gZ)p(o7(do4qQZY2nZMKME3Iz<WwS1V^Ct{f3
zRo`(FN`fu8Ly{kG@I&!Ps!QeXuHoh1Dk)zb<x6;28E{bbqZ2cDi%mbMUXxlbMO^(u
zYG9iSpP>gCVwqkB|0ny&77m*{vWmr$IfiEx<UFQL^>EVh#Oc!yoP2TVa7#IGNd3Bg
z@n6KiU5IVFgf*luoXH!%cq~%WX-~0=<PI)yfsFFT$MMSg!#FMe<~!`w4#SN^x7Vap
zI-<^Tdp8CLHaLg6`MpV5bwsUgpxYJDbCSHIJs+Et&#$O{QaU7p^$0%lcA1o_N3kOM
zAU>z&mv!fJPLUx?<1rXDp@oyc=1k^X{FNXyu$1?TVls-+e1MnEb0|LAKF6i-XjN=}
zl5vT9t3%>eO00`(93qhpI}XEf%SEr`e3euw=*mYlQutjMf`TN<yH_Joo`m8supCt*
zg2QJ41A4@TFKrnhNow8@8pt}E4!pK1;m6ds^k2+W<{widqnB+I*hT`|AuD;OeqAiE
z4TT{Jdk2SMzI6=HooD<{==*KZXHD0jZ*YMAnSlOr33RZhBlP3ys<wIZcyL2XZh5oy
z1bm2`J!ZWI{+M!iYCCX`N7gMG=v;XpPlW{RgT<bv+&P{ex2`rWt)EZ_ON}4IE3qfl
z1_4PFx(jrS)lY=}G?7?`2MPNSqdViIx=ug!uo8YsU7{bqMA>^v9g#76&TA_#?~#3$
z_|&0JuROp)pgA06z0iAPZ{=)U0<vf^n4a7qfc8`F7h-n<sZEM5B7gH#pgp%hpiOcG
z>E9yVoGayacF9%NpN7}4%OCMd#2GmGIOC)38MU6Yy7>QSdlRrIt1o_>VFpA62ZUkY
z1pyHR6c=U?P}D&|aX0rBm)r$+1wzzunxsXpTP~?t=DaVJiIyp9rkS}_n!7FPAi1Qb
zspb4W=f1OHegDt%f1cm3=Lz4r`#txZbI&>V+;i1zF+RdRBhq>X^My32u8spdgBz<S
zPZ<5j6uga*mR~CLC46X)J7sRtoibqJ7I0=nIwOEtV#*9dghrQz&FjH=GoM@f0G^5g
zUx6q@aHfti;Ev7V1oEA+D*aRVL)wU2S@w&xJO-YMYJYzzRja0>SABXB(k(3e*lFxf
zZBH7b0&bg#konF^uZrLcjL2i(Z8e*9(wG=>cpc`OjQYe3ov0l{`o<_?h6lfbW5r2h
zKtm({xe-6F)6XsZ=OX-cK4naft-T|)KS2u_dODgm)k+C-wU*~ckoKrn&4!!;uQ&pL
z&qp=Y-nHl#hEMA6vu4!a0jRz;r;NVEvo}fTJpoyrR&n$`te4PxBpy>=Pn-<q1~93e
zNUnqaXyLGw^s%)hxNQP&h<kiKd&dV|WTP&z6hwlrtFc$B+hyS$Nv3B?ry-nq90HBn
zQg0wc4lxg-lxSrhFC%@E<)}mWZ|a8%#6({AB_=YP=v^{fRGl_XjY!-mO%N25{_Jf&
z!38U%2}0Cq4-T1ehI9UPG3jjR8DmH1rc>DZGsYm-BI65l-S-kpJ+ainQb)ZZvD8i*
zu(3gWbPPSS+vURu2NarB2sBy7Q-D5Kp~w){#bCSB>Qkq|gGqZ9#1MZ#!xo-324u{E
z@M7~QJ50o6NN<eVa2b{;tejj~YQgNl!66|N|1877Gr_6{j13ERWCe%sESI3-W_m!;
z69APKJ_Hq?EmkS{dt)HBxnt3|Vevg2iZ1QIDaH53X32NL9EPqe>xc~x!#~PXF?`oO
z((ogt;frDEEc^%K?jCRaA|YU=)?kU^2c!pM@=)EDGO(xR(oUC48=6PVZ&E6-=XJ}o
zIJl>P3|G)d#E-BlcEbiY@<(HU_H76_wdWugKt<q!bDu)k_b%~$q%fOUMK}inj9RY&
zOUVe3Q})8SFpg~E)~q)m93TAAm>jyJUYU5uG8ri2c@Dee!fjAG&l$suOG60k@e;w8
zlWtN=FOm`xFC>I+4}8C}M#3vhJpIErI9|0Vm+%Ul>DDSM@>AK59m+0}%Dz})EBgh?
z+E#QaZv6$*hT0PrAY1ATq|!Qf*eI=Y=-N{2I$wtxNbBtHN$c#4TI6bY-Wcj>aM=a)
zk;HH1lGQR+72nf`HTodSm(4wIOmL2w#I~O|o|BK50T->GjNv^`07YwW0lzqml}jQm
zdxjO5my6LU_6#>^&yZX83~Tn3WvKo=xF+H@J;fD~yFcNiq`{{E?geA0{KYjjOTJ)i
z-7FKBM7x+9ww=3N?6WV|>kut!FZ{z!eVC<^I~7}KZWV}+#F&_~o2lwob8X?Ch8-qO
zIz|#6AHi41tXjHP!=7F+2K8uP`2rp;BtjU{6?(ov<)zRL>AFKUBoGJNjRy|$>$>8e
zKKQc@=6^wbuS<r*8Cb-Ki^kAqVT+N=$!;972<Gp)6U>*Pmi5eM(?w%Ya4m@K16g6C
zJphnX?FLX1NzK56a5(mzzi1rpJZB7Rcgc8Z8r}0rK3n<^Js+lAb%?z9Gs&wTstwFp
z7-$DrscL_dmc$<bvo1*z4Fp1O&O(d{OX6RDNvzoy%j`>1;Fr!yFB`+63Pp*O>6PUi
z(v}QeQ9hRhXX!q}tC!X6tINjL19)66EEV;9&$3k3rk}!a$ipb`{6fBWTl1zYa2OTN
zVL*`9Eax%}%e!LqkIUGAsn`6+YL1pxa|BM;Vfz0JR;Me*pyDlW*;jMgGQOJk7g<(Q
ze8XWi{Y`TLa9YjG)wb32H;ti0tY*BFSQlJJD=m%PlbDHhfGg%ptL$$&P56yfc5ArI
zjIH7U>AZMN?y505xYs6HVP$zJipVENDW)s1!V0YLQsDiJtH#{!y>N{0AWRq}VIq#F
zf}OSpv$rU@Dx{GhLHjH*&Mw@LNDjINkKu2@EQXNLzN}(;j;lQ4CpByG(cr`oPd$Ji
z0#;1uPYM)p{2llOm{m=7L3h7qR86X?2|}|TPi~Px#HH#wu^S2vKxa!h`ItmFy9D3F
z<}=LE=a<@$*k(D#4*$VdXhrXH9PR%}pJUpr)XLx_2m`;zM5>Vu1J|Z+GkhC%EzvmT
z!O|1TYI<t|<qJSHldl{7-A%4UBWJ<m0KDlpGD4fS1-&>p716om>7!!<eP632VFPR&
z;ok<Fq+us0e|M`qHg-qx=V%<Lg2)L&vxZ55xZw~2DuIQZ$Np=wou3>;-o!L<I6<Z{
z8l>vyu?|iz6#Wout=f19GtvFZ10Q06ai0qW%RkmG;r)0H!C8Yt`{NC%b5I9x{N;w!
z0eSxL4oV$6;E+7<x&tI1z`Uc?x7X^Y<H4ioPXGj)As_SR<y(PmTG$8oSo#QESWQ@q
za1;m=)?DfpksS|W+y;+Y{PTHZHvM6afAJzd-hVqR!77=n&l-u+llX|w!$_57zHYN6
z{$I*3{(s%U|8Ad$?!)UL5)Q)z#ZCB&uliZ+u<ZV?#<7SAbrobGdEO!zSs`c(3PN`;
zBF@u>nPvzK%Cf;+qftfiRA3Z5CSg56u<1k4ih&m-wxvm0j}yEcxBq5rrs!b+WuE*E
zQug2*YIf&0NODWdH7w$WF+p(~&%9OlxnbPkT)fKzy>k~#-r$$8IlxvZwOKwHGDY1n
zAY|gtYA5?akXbdAxVk~rijoz;wEgtQtQsgK`%^O5nbq+lQ%aUmGMSwB(;wK5ksN_m
zZiDm>VDwJ>QaY}FBi)XLtioj66pi;7J?)|bU02FcewPcLhRw4u$^(?RwymPNf30zd
ztZ#7RdYo+?T85zb7@ld|j#rL7ngBMQ<Wzn7Rq|NlM->)@h@`+*_PPNo(rYpu!OSH<
zMngh~tTQG?_Jf>}iwhR9wZCC6AQpF7+7tSsF*w6~pkXuXj8QEOF6#-r{OVv~Pbi&Q
zy+1gD!DARGL|LuKD!}$nF(nh)DA=JoW9!s=@R4!g%I`^I|Awd5WJxcHsKMLurVF@p
z3C3@P=S_>>;cl&5ig9wk@yl1#?2Qj*CdwNx*0A-z8w29Q&;V-V-XP=`URPPJCSm<7
zfMAC;H&b8#-Iy8B58_*{>{qRBXjJ%@u^2`2B{03+DGJu%jxkt~0W%nT<&JThd}j#`
z`tHC0G^RvT?Q_>SP$q9!tf`)Q&v-}HIqo8vZd%Xc$fCdx7@f?jX7n2q_s80wzW~Mo
zV<;pAcd3{MiUIv#IfUFi6Rrt=7(=79qo@i=5eC)k_9_Qw0#mFM#;*Ti>?7~AP{UFm
z7@GwL1B-G>|1QDUm9Nn;c&=e`loGIBkf30N4~%{M1qcC_5;OZ#Ze!$nA@}M7<0yIR
z0@$b@8k;%Bat2E?hC?}d5B_ee9vWZqeII@ikB`WdOMascxUt=I{C%c)WNgu?EB5Ky
z5Rd`r`H-yMvhvtL`t<cY6`SpI?A(Ns>5}fU1nDI6FfWgdKJ3KZx4hV@NAP88`z}1T
z9~q<NvtfF;fIdQI%tIf}=!0+&)@|Bme{>=o+_(W3g8qbMz2!U&>+z>C2%#*Nv{0~D
z|1|at`(iF;UUu~7oKiEvXXd0_!&Zp91fv8$6#D5;T%FIEt6_<cafd1jAAKJin>Bnf
z2feLC1-9`|V_?`N{Dj}#&)U-Gyp`-+7zd?RqT9tO*q+B&k4bYh%;SkMja*4{4LhSA
zpqCt|DRBE;615t13|V|dtb&buVw^5FFN1^56Jw&H51wnOZuA!pNt+soN)g8n-GXpB
zegsQK+B0Ks`GwUGyq+1O6z6szY4<Z+=T1RV>T_eI!iADfJqM=?##iOvMorB1Dr`-3
zybLqMa^9Be&$EPk!Cs&@^EW`OxDQcl%-_ZgTm{xPQ?TuS8>a$lKSnB8;6KI@%?HwZ
zDpnr{#S7)`nuFJIa_ylPdDGxT9v_^+Y1Ti+c!ev<vXlQ9*DIRP*VGrFkg9iZAo9YP
zDPJ^A!=Al>S^xX@d5fi5*)j8V(3iGXARa~lQ1tS$n)S-+np}e>6GB@*q_Zw&V`RWn
zUc()J7H7;qf5H8B4e7^vBD=&4W#-4J8up&qn48>HD))v~_6LHn8d7JWNNrQFbG@Vl
zmmNg&m~@*QjCwvYSA_|oKI6C1cr2}BJW-U<TkusR(#NYpgxoYmvudT_CqIdQKNQLV
zo_(PT)><YM6&s>Eg({qCJs*>=5V3PKa3B}m{sp|u+DAMeDTgTKCQq@HSxqT)6q2=%
zb`g|$y)T@G4ms8;p)yrGg}XEx(kD>L28UY3>4T}->qyd?4|8Fu?^K{UJ=6C?Z4r{u
za!0B~m+`-VzDixWP{MG)g?wZv!PEl@d6Zxo@Ks9CIFvX*3GogI$0;GO7%BX9Z$O);
zj6f&}$?F_0{8XeTCD5c%VjCr-Qv%Hy32Xac@GTvxtfUe_l)yzf$XJxn$f3%sROKn6
zzL8OWGnt@qbrAX*{N|Lq@i;FMYA^BZR4vs#g>T!+#8Qesb}ie=#8ZkZPqD0wj8Yz9
zUbdC_vp2f@g{N4+Q`;S7P9r5ZYoBFl&QQ{R$7+YE+D@d<Na^`iv+DE7*0rIrQt-}N
zJ+*?@JyD(AM`#@RynY&1pa9mn4Arm|3L&&uLoBECE4r6&leCAy)THXM1Gc{g_!x{2
zFu?;WZ5~+uP#o&gkv3*4up2&FM{#!3nGa%Be`G}>ZP(Y9>WA@xqN}%{I&FIhc{CEz
zujECskHxqMUh=3JnrgL+&_X7k(?`Q5xC-!tyuK70+wp1j1eZ;&f*&@E1@PqC=PCpj
zYv8fzu(zK=^IE-!FHfzJu2V_JGkswr!vjhr*A-T4^)3(ZV%7$266r^{pCBE{oLf&K
z3O)8L9mS|r+{)OGZioIt851zCGi#+n)A6mC^(q8}Aq|9J`FDq4cWodf%b$*hPg?`Q
zuVV&v!Nov2vZ;mkW*LC8yaCAxmq9ZY9iTsHDKO_ghbBZCWg9rf%H4$2;zxJt&F>37
zzx0zl)pGFk6zab2E~d2|lFKgSNRn3%wBs<f1?y~68%jnw6<uGUDPd}4jKdcu<dHoI
zS~e0O6p%%aO*}Z!OTO@+nqMq#_7Ow|sPzh42!j{I8DOzQuQbOkFscPN6aqu+;?K)7
z`wfr(_H8J{6d(Wnzh<_Tr&?xK4f7qJ*=Ly93grCf%sN=s1B)ijY%Vu~zC5#(iT^RP
zv>It<+KIqOJ~Ik-NE^R9i4BJIpX;QVjnYX&QI<#1(%r?p@%-mYtG4T|hLtrEG{x_t
zmIGFPBdyvTo@$xfObCN~ZksT-VaWN<xjkC_(yFz_-N=8hn*W6VnA@NGrMbzYa9_Ku
zvCypX`?saZz>3a3ZY+2Yy|a;1ukH}2S9-WIaj?dTTd?W``x<hEAK;bl6mh4$+D%+D
zzJ{8ldfPPP4QZ0<oeA}RXl_7E9ST_W+Wovv>K>{C=8RuJxDEIRdTrIXbiaTbeF295
za?W6<Z>;tS&Vn~c^p=kFcS@ckS0H1;{kv+P;NFzi4C=8tI#2s@iEzIilbi?PN#vm#
zZ?^G4QKr`*(#y=I-4}?_Y?^?RRBqJR-KU;Wqi%|Z{p}(6yAR^!I-wjHTbl?8<oD0=
zn+UDss|La!x`_}f^E`2$8rxlfF{rBWmvQ&Q&nh9XaQDOg2o^%_hhBHiQNi=$fGJ@m
zKoB@M!cG#=_SKi|B;;tA)t{bm&^<Sun!-+b3K23d_J^ksC~t_?ns^C=<O10GL@%Lv
zba_9pUw7`@xgge590n{dJM0O*XX=cjC-S!WXsm|q@)ESg{wPYGdJ}%6k@SI0qkvy2
z!o{(&qu?H@vUjjVR?)>`bE(0zN-&A!?voZC{1FHMo6D<hxI?Ip8)hy@g<>p)K#x+P
zu8xI@S4yRvEv2k)ET|$JOD#sBx+F{IeWe<wxmV54mK##&{9bE^&L>KRKC%?DKK-CN
z?pUb*nxJBu$5Klv+g-G6yp$dHDXP14qYi=1RF7~wLwY}hj7{9NX)E+4-0*4-l=hW+
z?t?bDkizr(<!hYE)Uv{&vITBXYBr)CZhYa3&GQygiX){uO=%otW+uL?_}mYr;FjEr
znnt2o)dH&n(!eVk!w>5_E1>CNfl?Q*=8N&;=k+SnjDdWp%)2Zf1&*cf>~5(uM5?n{
zs?){VqjcwbA+LndmD784`p!O<N-0vMDfK%-00MNR#TDdfJ_4>NNrgJpFXYV&`S6Cr
z(eSTeo%+sEmWChVF)J*COZ_@@lM}Hvd(sSIQD-l&)6!DsJE_i@z4d18(~4Kx$txuR
zz7*Mp%eS0;5%mDA{r5Y0Lh(Lp3ZBkVR6=}foawwxJQfZk_Ln!V%^|lj?1I))sD_|q
z+>|%C3_{<mLM4PLW|ZRVQ<ab$HFh;wrX5N%5VgYt7(rB$-e&0|(U%38_kky1>Ywb9
zD9Oe`XCygTFU`@PfJ@oY@ny#`Hr-c<k*5#Wu(iH|&LihEk#g%1#8eRE%uh&!M=TrZ
zCrp-W^Wn$p2d1U%h=UbBVV&>UlT>)$Fvs>$x~g`w5Bthr80Opp;R^zU$@K4=0YX55
zuqp@>RW;s??IK!Q`&@7vy!n=X?K84UtQn7var-0P4Rb@ukCD1x!mK7UfWXoTroX9!
z<(P8DcQk?_LmfweJH~-Rv~!$>wF?v`g{h@JTiRRd-2=sK28!t~1_nl9K-Nvhm_`(u
zx*ADDk!xuj9+x}7l`;8^wccS0extWb7fwz8wxF`>vYvi%DYSt&VHwQP$FbcwLZ6K0
zv+XQ<<S(oJI)F6I(G^%GbM$R&9S+5Hk|lU9+}oymnxlPa>#&)E0qRZDa{U6Z>6xQ5
zThZT0Y+&{R?D~jYzxYm+aeoT^4ea2U4XzZc)pykDXM<_Dd<NoUDZxU__=tH;F=wEo
zSrrRJ0N03xVH?1w?HjJ)SeMl(td$J>+vwB5!2fPbnq4*+HXRU{vA&k=iT_rDHQTnU
zNx3N@XFrud@2NF}ypM0d{P(vwUjOu|njM&w8<te*P-K!+<Rhtw2EVL#i0Qs{UtBgy
z!G`u~Zdl*#Qps6T$$9uC-B*UGgZ7fFK5zn^%4g?^8NzlCV=%Y6*SZ`gv09oz?O%uJ
z#}ZV+21|?k3M2<}v=-8VIr>>*J$TZDi?QmC6ZQk9Sbtkq6TYo<64D=NU|%aDx9KN_
z`e-t!;Vsz2&C%breW`?2cLvu|03!Xzpq6NldX&cr7H^@+gSuH{l#DJPW_os&WE9_H
zL@7=K@tPN6b0(J~`G3XcoQS-C#pe9CKeFd{89weP3f!=OC#h3Oo^uxsEACVhO#k+N
zq4rN(2>|T(2lOn*E7x%Q0!bt{o%njGgPjwvO%3Rquf>hSND@?9Eo0MT1eGfyl%}IC
z{sc-GulU3?tzJdGR*W8D^Ug-Y`dQ%=Q<4OeN*R2SM->=-Tyfj_(`*gDrz-D`4=%$=
zFSDVJ^`fc{$}WGI4Z;w;%og5R8mP+=0^U6kn&W~2Ls&_qkRpc?!)|yR!<;*7D6VBf
z15~qxwUnDW@$P(Cmu5l;FT2VIW+sp&x`nsTHPd$xtOy=I9;R*%)MEkC<gSlc+{+p5
zM6}N<Z2aU975f>aj!>*oLW=W)7tBWmSE<Y_jY9y;FEZhZ7%fD*{qe$_r@L2oiv_CS
zkv{{;h?2>}VR|bMQd3JIVZdt#e<>PfmJ%rFaMFgu%jUu)=RT!ueRCm8-Yx@9M$Lsb
zawmLz93zCYT&3W~GGc^Q&WlTE&4T62u|uqk5yIpJ_&}Mq?g?OnG{r>+mYUha7$G|@
z8v88lK)6{t*EA7E5Xy}}E&@Fv2M^ccuQd6Qu|k4p5JYNq$D)Q@B)UBSZzRMDe$GJ}
zwmVkn859U$8q#MiC1$M}vK^a-WG66bfbVgFe_S-EmSkE$`!-oLfE<zgsWbO_iU93(
zap(>0*?W5r==W|MdJ9Bvap)~T>aASr?R|T1YV_7Z@Gp)A*R%9C3AQ2L+n2mIWY|%N
zj-Tj##8R}x*_b){aHwMe#JlL!+%dr#Q6OBo8+H{BBi;ss@l!HYDtC92kw?D?hSwHC
zAl?TE<hRM_(N8OvS9#_5z?TfhOo%dY$go9~XW(c0ZVDY7`gPYyn4vA<B18)McBnsw
z>i+?1)|zn@6tcR#^ojXU6&y;V1(g=X*}!-q9;2CHZ!I*J?>VZ^v}ld&?)q+S^}ANv
z3tKiQl@AKn^`}8*M+K8pO|W&GP3(oOEq9>86YR~#TBh_HEM$&@#2EkVCP`lqk_#Y-
z#<dhe;tVcZ?FFrED$yqGi(uc^aE%1<V@YsrDYQyy-;f@=cF4H`<dp<CW%;WRgp+G(
z$KoIR(zE+Q$xQjG6=pU)VEyY#?$SWvn6pL<qqnE7f4RDavr5BSR+Y3$d1nPM=w_aN
zv1i?Go7{rUC%7JF5bxB7Vb#_?$D<vILblhKcEn<MlxGCryYh;L9ZD3kLcEYn7&&SW
zVPubPj;%l~Z6$P<?`VrAS_$dJlduC(+0Uz~>{f7lI*pPvn%Hc8JGf3Ynbi`VP6P^f
z*ZbTDQl6yGF^Z32KbK;RkO09WO=~#esMePd;ovPJ9ti`$#D!wm{IX%Xg1d{V`DQh;
z>037tS;xXK3sMm8`S9sbQx4pTvj~VL%H2xTrDq*2a>;381`cvbjXw?EvQvfE><k@%
zgTT3x<nHih-iDzR2+j6p-tq1lr%W6sNl)f^?1m&x)-CDDJhJrDlX)(929iIRms9{5
z>QR!A6d1LL3@Wx}UO_Ve%|H_5@f4m9>ys>aH~wNAS~Ga;#y|8Po;vc~h4pHk&9Pz;
zf1+^!FNb&V+S&1_f^_Yt9&=!BbNObY8k1KX102qAIJh6LbKgs<5HhR4Dp+uekl6JV
zxrD|L@7kdQS{<Mqx6Vk)_wWJSE8@WhH0S6Qk&FefhXScc5oXB02Y*+z77~>95lK8d
zv$aqv_x>Nbm2HF|MVEOPP*@uwN|8Wc-P#CK<-OLa*`7ASP+zBHN1*{*19aIWO?8V@
zK_eTKf${*`wKXKtxzykvGE^$}x5G?vtI-?lOs3%+;xTY7@yO8+z$KzvxV{Y;*)EFk
zR!1X=Hib{BurIx-C<rJ{M+%{QNG-9mYo>DK;B8y%i7(Bu+*~A2uHnHwvj{B=s>pTN
z3Oevnu+;x54?8hM10~PIbGV*YpVv#S2#tK<1}ohOW1ho5@CmT@>KHb9KJ3>#Y;;I0
zO#oq|f5-NX@&3=S(UqgilVpkf`dH-S1Zg+!DnbC`3sx_r`cW8<DWrPw_!!!WJD}zN
z8B!fGGk30bHAj1aykYitc>+}Xoc3R?H5goO)%y*E)n{Qx>Ftl~OgMAZBW6dzL)nIe
z@Os(!ErDt2dMlKq-vzec%(H`#CO_U1x6ItP#|CYLIzr2N&*&&?N=RC<q%u|B3nh;&
zsf?9J;bT<B6n}PI%y3uy6Ax*~@b;A8)GPR+77|`+!71OY+6!KKAPG~o-1Y1YG{N12
z!o<pc?fu!3G$FE)FC-UbV}6KVl_vOhcSRBY#7RRQlIH*vA}f=I$l#E(4LQ_r(N03Z
z5$b;-6!TOIDZ@<??)6;@+za5iSJeVd;?PXW=tCJaM6-$^!;VfI29`_64{`M!F=D{&
z9WM#`fqplsg;vRTu(A~A`6$K%r&`k;i@;j`5vL89Y+q`&QX}AvkMv7-u!U&^O^2-@
z2kE9CnY|FRBb~!Zxnv7|=IX*hJRNX#Ds#!5Lhrg5Za+qnuwKnJYlL=99%1seU9f=y
z;yn;PKqG{|vU4%#0>zAT0jKrg0=7`shumRRuv{&aI$TcNA6(%YF$N;O;z)w-1H`GV
zor!j(6G?dgq4^Q%LW^Q=FuP34TOqd~!`1mgGH*}huor*1aCghJ7|!vuM7uvEIBY@&
znfhoptBC;{hT@%E$R<RWcx(|nE&s@Dz?VFntDIZ_oQ~3;HzUYIw{FaV8Ee_8D!5KM
z7xa?pkN?BrjAhgRB_vMjD6}fpwX=vOW>qAC7KXlhbb}NrrWcN-plN&D;k=z2;_oft
zaD0S+Bn6p_t+ps;aQx}_pY7EnV`o_FuXhx}iW}R<@tWqp>JfY}0M$(D)zO*mBghsU
zI)lM;Fn)_O-OJ`G2d4XpB<-g`T(B_RcE#XpFTn>D>T}&7U&k^P;8#o0kd0scfAJ%3
z6W|VGp-Zd|V`LV@%~e=@4mgDabo^32;!t(au!fm}rg1ffWHor?XTsEWV-t?~GNDMl
z60KpIdo1*4=Q4%%-Y=5S!bpJL!bvLIYpNr%goZMY+sz15TVtSZ8`Z2`Cm~Wk##_UZ
zuk7$I-ek+$&sVgw8>vyhY+XtSO_pCz(>MtGb*Xrs2X<*B=9S+mi~-I{&(<Ku3~#|~
z60CLhMU`L_rbPUqwknYh-4K<rYBF>pO)z@@3$;^$hXXEVI#qVYfx_qj+L(m4@={nK
z26PtMq;v<~6OmlpLM?qowlURy{B>L?E>mJ-1Sk*t;|TDxoc8X#_!ty~VWTozDDv1C
z0j*3I13-KU#_(FU5EVGpmh?IpK#r~(=KsW0^&U3!nry*OVIYC)QnoNKXnrHeQb#n-
zMGdRudjS%sx*RS5r1-(JxQozSJ_=gi>@Gs9=I61Cn^g@xX~yZt`H%Hr^C0=JI}dWE
z_P1?D``>nfqFa=tVYl&7d=gd!YxZDd!&w{)N?afNllEu>>Jj@L-@i!Z>j@c{zaMRm
ze(3B73p{S3d(H=l6JHOaiJu&8F*q}{ALo?*u0^}L?{ajkysKc4U-Zy0RX5>7@19`v
zj>vQ~8L<qy2_xjcg=ko7Eld_7J|<{|cA7s|bGZ5Q2aF^ZJrZL@U`ce&<*5Din;UO<
z?40Zn8q_t@I~$g=h=+oA9|%^>kd{MlVRBYyn!I5tT{fXmC{Re?M`oIjJPLNw3DjUQ
z;>Mb+{_yE2jyM_)gp!#f_y$f}M2tx_5CgP`cDcY+zL8GP5en-^?7E*LWXMBYG%TgN
zFkb$BBTe=C?t)zA{1<kR9>Qs7+<%>wEA*7Vs?@Nra)nOb6%ZmnCyPHq2+(xjhjk?&
zPiQ9BHpJbYJP@j@8&1UXglzRd7aBD575-QRrz*?@i5y%!KuRu-7U_aCif|V?5FUaN
zVK}BdA-P-CelMEIS8uEF55F9&gXl+&lAffCLU!lnzf#zMgW8EI3C_N22s%y>^H@dl
zDxY8_=qI`i8=^Vd=<0|$L?%RmXMqKr0{?(Hf>Yq<C{1|VeKj@J1`HO><M02Vz}9GB
z=v_^_fLcc7zlQ|^ZFA!s5vU&7Z|+O=l}DoektG>{NiLT5SMl=2DDT)ZaQ-Ex$_``;
z{)%C<t+bhDR{tk$K4@&A&4@G$ZQiON+Wdw9Wk|ose+-3y=Rlj|Dy_7c3jW%nw-DU@
zjShC&3`90?J6b{{>uxl+NZO4^e&U-D9Y*qx`IwA-H)0jNg@|6Au`*aT1zuQd%6D3f
zWdt9~8qy|UnZS-CSx_<&9!)Yg7}DQsPJ6U!5lRvkz})aT%uIL~yARs@9^%H!ZQff+
zlZ|`1&C|W?ZKg<Vdf40S&f8?0+ICBlc}u|}20$YsR{s7wR%xG|?gJjMHc`V|`U(+V
zJ#gfK01j}kB}%xD^=;Qz=qPW{O2g*%6~ZULfjx!*lT9}b(#J>fd8~Xxnnxz?I9i0O
z!&*HoLhyocGi}D%8F7g<Zxg)BAZ!7JAl$lK|AAYKOVAaRRhKi;&n5KJsj?qf>R(=(
z>ac#oTe5%Yl-K(Uz5#7#kerfGoZbLXOz`KwqLUx(H8bS^q0GaOVAAlMQhJAX;{aj)
zcs*S=)Sbpk!N6j<2te*h9xHeTeB2R>;UbQ;|E6-71K!OewNb0@4|0a#_+pd#YU4dT
z(uX9Po?pdMs|QZyV8Jh79H2kwuxat+6=r2)v+5jac#@b_lQ<*~@syad)sSHNmu%zh
z&ET<ig_I-Q??|G>(yVmUS4clMq<?^Wq9$)-usef=h)Chp6=o<KMYYK4vx0DCGPXmd
zgKsQ5Jw#~hYl!xNY+2WX4mdPX+=ut0IyDO(Ds+{<cS^&?4Hc4Oo5w+9F0BtFkS!5D
zxexS%b;;oJA!6d}A1X|g{{z%$F-%DG|7|$|4SE4gtH*P7-{9u-QwRpQvoTE2`Y-uc
zZYL@C^f2LF#XVR%s%H!rN@R)!3-I~p2%*1Bkuo19!=9sr-xVqIkl1lF*tjBSE)u(p
z5!8wkbC9@XjL_LJ8s6!#!Y#$NBIJBAP8cLpyi$lyzwts3nIdo&Y8FfoY84?fk=S>l
z;4M=;o{q#xlY~IUF?>}op9Hf)n4M=?Hrc+GXOeI-wdA0t`qx*5)-pxcsi+V*Mfgn-
zH+-UxQ$e=!#d-R3ivAp>KTooiv16l>>N?@awA45hs*af{<jCZ^AR5h@B_ztr@UeB4
zkR;E?$9eh)!AGM)z~r+66#uADXe(3b$6=5+iiBSkyT<xBZ9g$vkSR8eLH6l6f<mTP
zJ{s9S%@y(#G5D&En<qre=&Uw>zEI)wcdsC)Ba5b~eDe9fAuaK5^`rU1cK~Hi5XO;(
zLV{w_aJ2Avp>Va>aq3v+SMvUU3&fSftonFgEuQ^oZ?$o}QKxo-J{(KWe>8nk|6;-p
zh>)Z#`zGkH1*(E4sB!EBOQ=ER#XlV{F)X`?;4~IDmy*RoSj3YT7LzM99w*MDU($G3
z4HZ*-ZY%Z+b{WpD?X#sVvsf52?3<%dBI#DpMTr206ML9EUd;o;Aw1L}oROSIZG%S!
zPvk5Ei8GK`K__x_aA-Z&Yfyjt!<ouo+kAo_fIg$kPSW3T_dy{Jk~0D<MrQaFpRt$7
zyYf;AvbdK1evEh~ybuhkHa&tc8c0@q$>Y<k`ppgI`^IoPTmBw?!$9c+8FQ>Bx8q$e
zppm02S*U%uAP0_o6Fn&J)gZ#@5+0APfR&X9o#Zj!s@bs;A-g!AYUzCr>98KDhjY=L
zUI7}X7!<S*po>^!EI|fraEHeMeumVA-LW%4>E%7eTEbgj%QBxs$?;Ojy(mfJ$o!m6
z^}+FwTf2^=Sbm8xwTDz}rt>&8Gn5L8eGYa4k@10!Jy@W;<g)n{AZ^%d!fts6qFns+
znh@6FM0Y-j(6J8ljOFd)l<ZeaqFEIRSumnZSn3dJr>aaCF28zI&AgTfT?dut&@6op
z(v&^^8jXtjHVBh_4Zf{a7%W~bd=5O(aY&NX1~?>vT7*bxKgM+}HBSBL*yFc@64oW*
zi~vz)#3jNkpB)+XC$eIIG!bDKz=ey1IBW-wl%RDdkPn0iAL;;kE`!3P4#MpnjH;13
zfDL!YUl^!mgxI_gMUZx2oGW5WTk3_USC$H;O&rk;y87v*@D>j#g6^_Z2yS$fuwNhj
z#0ht9mkG0r3-B9sIWN?#ng!C*gMb$|E&Hpva@E1Izhuf)HQ~pymAn7S)us0<Bu6*1
zvYhTn<m%IN@jIu?Y%Xks&<jN!YUf~Ku{ot~C5f~81a*@hYbm3Y9*i)g`|;d><J9RT
z<&w^xsD$Cv{!Yac9+=fkwOknO)ndOl{jU6x)+M1B$;+1ueFElxM+|1}d`#ROk5U~&
zB}4T7FTI`E!{tIp&r35&B1`|_JsQEeV``SAgN%Rwgqn@l37Yg#w4gtsz(^Dz9yJmT
z;OU|_CC#lKVgHGp*%6LT)tM`VAu>x$=uLXzmL0RID_+N5=CBi2RNprUDw)5%0ZEbL
z+v<)Dkl0rWQ5l`V5wmq>dQldZsS5>I1kjF46tE9erkX;ME?K3_`2VqmRpG>l-_V1Y
z%}Q1Z6Kuius_(B9*2$Dy{OC^%1ko1O!_DVS_-=pmT+Q~sDfk8(JcLOk%E+iyoUBM~
zN#Yp0|E7>G2al{ydQ14laqI*gOOx-efh6z_n(Xk@)}-%*|Jh{8J3@_O*JPl6_A23R
zMF@ReS|yxT<d7e<SSiePFHiGvI`VXy>Yr?EYpt2kPo|iHO_b?Zqu81W_!_ZBc&=DG
z9$&-P3g0Te#h%F$)(JBe{poAVI^mpR0d1a()(h)w;9%kJ3Z;rmZIQn1U167^8GQ}g
zARP2gA;O%d+AjSYQjCAAlQ#-eWr{1Usl83YDtjxLn}yIwI=HQe8=pOXiD9#n%|fcb
z*cHgCgM@hw7b(rE>0i?(2H;8|4X<w&X2=xF;;}XNM@$mgi1=(Oj&oJmCr^EXZ-dMI
z&Xgo66WmuH-=4tN_M5m$`7>op%EZ!d=~J~GDY?4yxpWb+?_tMLA;{%cAypCI0{z8p
z6U+^Z*QZh0<7Som1FGvW)cQM~|DNNDv<hpQAJTFRGsBUV%hNEe+fYn-QI}FAQIJG(
zP`|C!9YidH?R-4i4z!CVKQ^m2?BNN$kRaV!EC!*2Dwj#=`IJu1IXq-DfF&jOrerxK
z(;vJgCnfixWCbPDAE@I}a$icOEzxqDF<wgUN6BQK*iU~D*McVps`^tp-7(oufAHKz
zH7!uK6G*#C_)t;&YbpT<Hsf;~Ooi{!45kwZK1L3gd$Fv;kep+fB}ejWQUzYRD^H#Y
zH%pJcJQ<6E(ye$Ss=wM;8u%K!H(zVjXAVhcC}|L`VInP8cM9?~jAl}??YtNacu4w4
zO1kWjw3?FYV`tGXj(7lqW}el;P@li9Qb~HfI#*Ylr~9k!Lx_(h)q<Z_L;wUpvPW~3
zq_|SeKByL2E4_%zLz2K%>(nk@ZtQlokg3>r9K1Ghj}R4lb`|bxI9K8EjIXo~nwC{;
z<LX<1e-Kz%!hvh9fMkM}|B9YbX;<H3rJRrbtm@mA6dL7!sBiD_44e8^w}Hz2hx!)y
zF$_pH2PAI8YJen6%``B@roOSH&xNSqO`uTdZ=1a({jK3al9H^4#uWuq@|>&G>{`K;
zVEUI-xcF98j;(We1tW=6xXH=&RX7&@g)qj$z5~!gRD2=$M;csa(l*6!q$-yj0^AEg
z;xA62^8&5u{Uj)S$G?E@&_8dgnQ&5wVoml50l0lzM=p`5MK8{kSI}}9T$G(~RHEnK
z9&abBS?)d|+1KE*%2L$eaTum5@QGaHi8Vq1+qqA`yQwZp{64);(6rIEB2Ds>9iW89
zIp!vK+A*9zi8ZLzQhMi6`q2YF>=UVAnO_Qip^yWoTc=Stil)#P@-9u`c_OAz^re7@
z$6Y!kAvoEWLIeiY!&2PfF)x!3${BeWl!`t0QkX7(ZKaxx+b?v$OHYN<Y%?vIiCM14
zAzIyZ9ukzyZg|g55k=etSzfKw?Bsr-54!q15fT0l2uq7UY)NzS2CJeuDYL%rCQV~+
zOPZ7A$4>mP&#9iFl^>o!?skctYMr2R$vc*H+6Bf-lN^frFt96kXU3A4v}7y>#8;+k
zLwup~&IC1UT_Y4==JT+X)5;k<w$pKqL6w9&%>1-`-0LuH9~3%Zc?V9mO<GyLLz>+J
zoT}7rlfKRIYIgmgum&?7h0n!@gp+OD;%KHbx4t}6|2T)4HpUP8OyO-J3=Z`%B%Jtx
z6Xih<BGKr@dJtt(aqt7!RKEV6=X~J~qAcB55D^puO22{8U&IIB;3N~uLs&SO=Yz?r
zj*;&>k_9I^C6b8fM#MPw&e?6P8Yd@?Bf6j3t8F7;o7!SCuiVsYY;h)jat|3C;9-v>
z7aS9XCL~f@*xa#AdLbOgOt|9v8w~fj*wh$WrLF<^5>Az1baKT(9T81Yj^5=gN~Gg{
zUB;Z@2CeMA@?(!0q!jf=<paEO(ReJ~zIK|%7<@Mf_b!{;A?p6uf^TsN@<|=jJu&4q
zhABpOP47}@ZEp5^C|Y1G0r!<d0-rwG9mLx$T!RArc>y?G8C=r%C*SGQk2DS<+{kDS
zMuKA>{9`}ce720%7MzaBj|yRlgQLm7_QM)1$bFov?gB2_R7<Nzt2ugC4JtusV^zn6
z5bu>JZ7;=FfL%W>v<D&$9uHCUTcLSK0Lt+5n3^Me+;9Lm`*k-rS=|X@TO+>}{OvLk
zXPs5pQ^7iu8%nG*01mfy)>-oRjy&i0)a=yXJA&z7Vx6yKU?;RQW`GY*4<m`MXS4e2
zX|q9*_UrOutV9^(?N(`_!WD-kDojC5M1X@pTE0Zh9-I(5=NVk4SSoOGB)UZ-Z?*v?
zt(3m=?D?R@ImprKJJBu|-w?E*%)YPHcSl5k^#092oZksU04M`KfB8=6KQONuQJf!6
zuW40|T3M#)%LqCIIm%h4sR}>rNA0*5=F)MDeGXeJb2yGwB2F?BrP&)N!STO&jdT2T
zxX)FOmMZW$Y>>u%38!PVbahj?Tdt8qKf`@>QqPvlB|<?zB~rB<eLKQ<VAFQg$<b?p
z$>~EH0L_%yPjmG7kSSftBe2rS>_bHXStaeA3ca=ZKAu|hac$Wz_t~UVLTk+Wy9hOV
z@08G|Wd+J2b~sMQ>hBUx;SRgR!!X)jaf9i!5NpSl{CdAiPQy8nqo7vr>TqUFA~qeI
zkwhpRoZ&4O*8*js%UDm6*UukIt|`U2Jm&sRjaK*Ua7C5Op*p(VL$aPjlEWwO&;EOW
zB=o&>O5s?SS9m#}q>?dyT76D9*4g|s27Fqpclgap&IkeREaDF`c^(vVl%?5O3QGy}
zTe+JmXG)E+(`N*~I2#4MB+*6Fo@1kPg0bgWVYsUyA-4ovyYQ?qTaJ@UcIT|nA+1P`
zRW_)ego4`o10>LrL1mJHYYq4E7BV>>uNUrxZTen_u`9I*-6o7eAKxrSAIp9a3Z2(V
zU9|X9#=DpkV(Vi4CaH^;VTK@WU_jy%x>ZJgXSO-8imJhpO#;yZ*{X0jViwe_rfRT{
zs#Iz`f*LpS@xQ=1_{kGhIRQ<<q+a46=GEYYAF)yEHGUm`!S_qqr;tQPVPS!^S%1y@
zGSRcpl-LM~cqW|01mcyO&Ix;Bt<s;(^?pncFh4ra`0@gjoELgKGc^l4stJ-0z{ej?
z76mkC{~AFol8D94^(W$hGKl|J(oceauJxDoRI0BTVQuUANYI@WVv~c>hP0bWnz;3X
zUp{R|`V3Q}d+Z(gd&8$zI`)oE;opL!y7zK)M_xMSz#(q*ze_ho65jd2q53`3a6d<u
zO#SXLUad!9Y~%$Y-pi1BYQ6%C2;UcQOz-BdZ2bjccuYzFF^qR08Uq&>CHP=t^KeBP
zKM;k2h?9d`<&Yk{ZcR`Hb_9ZAqNd@#v>;k+{8reo{EI@2BI_UAMqhAI=-cw<Y_(G@
ztsja0<m2}v5~%8DDyq5>f>5rZO)%VF-%+z?7X?JMECK}X<><cB>aJ*?T!AvO@{WRK
zUK08w{sN?}+oRQEKZaRaiQ_7_BFRhZ7;^ITG1<Cb%YG$2@9*arK+PqggWm$=;EWzb
zYg+9?UB0#jn1MS;mxb*5N7N%P3!jE0`w|!y0DE$EY62})Ec7N+0LCSaD$H?)kpIPm
z!XUZtPMlpwX9NeWe3ME)F<om~e+8hYveQ?DadPA{^MR~zcJD-0to*AAH7mO+#5&_&
z<5i)VXN6S#h!^!jm9AeE5}P8`f&6&);n#%dAWA3a@Y=;V!n4ySFEH|&&`q9)0se8l
zn-AU0D1(UJuj#C)#_kwHUAS4b9;Es3nh+nkQtEV$C&6SCJX3K^3xDkmLTR`zv~Bzb
z>fuJwf_zghdvo`WHu4M%+uD558)|m;x)9g+DVnPbGOKhO)Xeo~p?MUl5lAK~srkN8
z{Se>>f9=hKCsuCQ)Xo_L?66@|bW_WCZZ)9_XRuqt)%jkxAfMh7&@x;StzL{O|BuwH
z*S&7x@*C*9#9fRE+;8b@IIpWkT`M+L=l>!U$%;jZL;VGG-X9NKgh@b8n4R9#If&5x
zi9I7*%2*`TSZvRTmoipL8H*^R1#haUlp%Y>V_at|ks)1Fe7XVyp}TU$72!1h?j&F1
z=A2Zp4Hb;#Eu29?;Crra0nRgL;Y#8yQ*(C+Cr3MbA|Kd$)Z~lb$V2`D*tL(ET=AP%
zF=v?v@EVUA6X33{tq)`P?F`Ift=}*7l|P5Y{_=0arf?kqx)uXj@_>){j0XnNg%6}B
za7)>k^Je**Iw&uVw4t4jHR7BYG4;X`{E!%OxG5X^11;}P<e62KYtSjjT(V-8{XRjf
zBY#D$Va{BHz#Xe*zBh&9pjm(L?rPj^-KAsA$!qazmbG_B069IGPBpZ#{Unn!zjXrV
zb|k{N9XkU@^7}W1;m(O4vHV-Y(C)K|2gC8n&j$9{kiRjz*QE?6%D~|`tvO{JEn7}7
z#eW3GPu#c+2%kaF^5a`V8|P(e*3u*d`!6N@y=BTn0kdlSWa_$vYO#?f^e*gRH6~#|
zH}@C3cc!xS?v9G+JyOc3qztL|hhUyq(Ye$Jb={+ZrRzSx=V7%%8y6I)jbp7$g1=WK
zzN!10uGGELtGH-aE4=Ex;SRd9UMGP-I4KCyr$Ot_`rj7(oe#Xvrrj3yDU82^_qD3S
z6-)mQ*nm1Pn!DRs3H?60oo%lZB8#_dmpRqxFwDu%`1o5l#W15VFtaMZjE~;{{t2)?
zpp51`qn(uDC)KF+LIxS2aBL%Glu9*zq8bwZyC4H=O8%&aey8`Epkz(N-d)?Y3A93l
zLjz^=#Qq<s+2G#+d<fGOzYD=*U!#m`rdm18UT!URdpqi`1k*FC?u{pkISQi!iJ$y!
zizlWP@5|61au1>)HVEaCh0q(d`W~6J2$+rZy{LtgwYO+7A&}h>CV5Z2T_2)>{%UqL
z9}wMkM~HCVy_p@mBmAHkS__D7x+}yxf4qf#cNceVOSiCp?&4-w-WHa8PlzpUhBuaK
zr=Sx6^}=HgyG>1OK>f0q1NGSxo-u+bUjph@DPxILV*u5VfU1`=?n*Vf*qO>qWLSXO
zs@4M3b6bICwGa3lFVP_zLHf{E$bR>PHm;~p+sMqq9}0fa^n)Nfz=<F`-CA}acH!Dt
zy#7#-t4ym^wO71nfo4213$)6qhhQSt>N{t0-?!SSymS~^fEyh6uT2nURriH#=jEH(
z<NLx6=b>Yn=8@2x9s5J@D%M$8Byj*~nmLO&VBVH8I#Wh8N2(;skj(0&aZ5&Zm(hqf
zMBiY6KTEef@B_!3>6P2*xJ?y^2DrQe!GdGuvJ&72u_E2k&z;;5jTM3Q!3IY@5CSLf
z;3WQ}wyCsgHzoXSN%$MY$B=_2>JriHvBpRv@<30|9tOfu4vF7VBJBW3Y>4p#w-*vS
zbKo#_(n@@@8K$FbZEJb_LO69i1am<_T7_Z%lw%d<jIuMA{D*+uPa9d~Lt(4)p-}|8
zcE$H3#<`;*I+VaB&gWozDrI~~84}nkDdS&YJGSS4fbH+C9Bd_MzydaxQu_Q4uyq+D
zfo-Da5{`gYu;o7GIQ<r3s022#!~(WN8kYrZBQaDCwq#1QfNdHQagZ`k0-MAdEig-g
zn6l_kFhyk6X0xz|V2ZQxO<?=_8G-Hka2R_36s9?czRU6-3$fZq>j`0>m`+f{ByQm*
zFM;$!_xS+Zx}jf*6Tdx|+5w3;Lm;W!YF0HG?zm~Pn#aOa=br0W(i0)MXAsW5snyO<
zWzp&cy4-|TFWlp;<~6Xjx?_%|)d0vJb?b1^c^LOS_)B-Nj6c<N;X0T|*rtMD#W(bo
zv8kZEzWllA<H5}mKJ1O!j^fVrcevT+<12WU0v=1Xz*+}dYyEz{^K6Sw6N3-3+r+v<
z#C}PwdJ3VMl$x9;<#eHB3GfzsS;>J^zn-7vW8gONDta+Ygpxjw&7AZVaNq?fVOZdX
zg)Q{57KOY00@SQG)=qEZ1pkpbNWSkCHS>NZv`jX<!m-6v{+QNm8n!h@2{0SfQ<mYR
zET0W-B6Z59KNEcA8-}Wx?wJr0uy`mz^_q!x3|a<X-i}i_HpFK_4`)2i<NjRmmph?+
z%yXe-@tGk~`B7+)97f8d+jUs6Wq+js*?L3ds0+YP<6XXhy60(5`zHVvX4TguUywAS
zU*Jzi<gVB%EUkH?wYn@^d<E{;D=^wp-~l!olCBePgJ+;bod*?L7^Q$hXDL#`NA$$>
z(<6e!A(Vq>;otDX{(2%L;J?AB4XGXjp}5cbTWBpGfW!~~7Buo{)790czlC&J!&`sS
z1lGX(ocKcUZJ9Kq{vyNaEd)sfq$v-u$Tr2D_PXgWggiN1V_3}#c;Eh5pk^)1LI?TN
z)oNB?7WC*^*B4zsF$;T&^Tq)VyR)MjYUG8X8t1}js8eq~Orw^qo_K??DjIoF11XM>
z2&e5dganLAuBqDs(8gTkpzVS>`;{EDeSlNQxPF0Ww4{t-JmYC0&u~TxR1+P+uK4SE
znlBa~;V!1un=1ed|JzU`(rl;Rt3TUJX#YEUIU*Xaf<}LU4aJK0^xFi2u>R&A+a$QQ
z2f8z(OpHu1xP0`Xm1!DM|5*;#2AtxC(>*rH=P;@}P9{lw=NC=e&cm+hEG8tJgFgl&
zkMg&W0|8AW&nM!?y2l7jY1XP;j7XU^1QE>E!<%D>v)HV7sin$VUL}15ewr>0LUo;7
ztLy7lOV?B3pVOf(P;yAG!yU}jMhSjS{Ka`b2AsN9f={+ZN!_2O%ioiSLhVRikB5;#
zfM`Gpj};-vok{tF4y5rSOYcgS$|dX{XE8X&<0rHpff3ZL#!GCbGBkmS)eb-#c1(iS
zoGBOEdYw6sb;SGSbf5$6A855qE@t`~U#+)Fv~X)7xlSLiiE1_L-+3dEL@cT5cMwGM
z+4?*<Ng;OgyKzy5OS<5mWlv>=z7jdD>4PY(3NgLShm-!*TP2d}HUrT*-Qb88`oKoq
zLqPWy&1TH-f7k4RB&q#Bz<&v=-mEJp`;(M-*^;;riH_iq?v}WM-5wxBw_GjRut?43
zxrkkwZ2&#mi<9osmk!;+Acm3^`P%JrGyB;^jA)XQOI+)xuRCjHLk`0<;VMSRXBn{J
z!g)J*fI%A3Y!rw83pPOuV>bQpE}P^khRbhH0QPm&d$UchqNnFqke6u&J}A%ir5aZ;
zDf~_BIgnahzy&Sa;AoVykB)gZ5QF7&bJVO=1JPGL0v~S#rTcR3G^znQ*#eHVq=6VO
z|5Izp8j6%}8;AkHnG>ZRubXIu$FULG+pTmHyCo)I#`MOtKK1*a7{2+OenAp>o#{Kr
zk_|^$ew5?>f>^vl1O=?fO^j*rQ-QV4;{U2sG#fh-%72LRU%QFT<<}v&-g6TJT1>W8
zZ2F%Sp~6zdbX2VHs)~*aL3!&wQRgf@n_6}ltl*mII9^mFQ1-cnb+2GG-;4gu@=#je
zIh+hoX?Qr>KWiV6K~CIPFjSe;(5t))*gA2FI(#wssD1&Se27Msx~7O@Y_(T`F!n;6
z@@*t$1%{v$(tEiT9o|pczQz5|6;kSqMq+F%$@9FG*9b?-7HFM{(o4TMhLZHSKv7p3
zp7JIT>0l!<(K)X#`=gN<5jq;RDCd(Kv?A-lW$i0MJ_OkJ15_C_6RTMz`YI$p%N9Jc
zu^8#`U<`Hak2PD}L(QhCtD>W^`&j`cg#w|&o`K};^7w8V5csO8((J@8$MuVq59z3u
z?jQt~s#%D;7|`f98cFFavg=GQ?G`9Mj`iYZobC7^GfqZ{WzgZgXd@K05884z^Zav~
zwQ2E6u*Z7ve0{Q-{pv32<b$xcP4f^VGg@O=>tb;AWhUQ|>lfb--h<#CP%N&QngWyr
zt46=l2p@rFIn|u@5MOthfYlko{%9~W*c)F|O8X0yN+HUwV7$x+7&b2x)M>e82Frh@
zLNljRA?wI<4aJ$n?k>M0!|_f#@?ggS4u7>>ZdvrFBXCHp6kCTL9-&4=F?k^$Uq_1-
z#FaOCe;SmD=w3-KhJ*zvGFI4M(^npXdZiUpeAw0gnjnula8mLkH>F(%TDT6-v{l^4
zR>_i*`h_%`)}h{_w}&QD&&UXgjCp#AW99jyfq+GWyjgx}H}}BA(bDV_uhGQ((VTVf
zWK~{bo_sr2`OV_RzHOR7+SyMw4n8G-m!ET)qq{;F2A<^p$hlC>?=~(JG7PUrH5Ehs
zHNd~Rre;;{6luK-3;azL4-p<l)>Kr*uN?eRyJpo12qCm0!B=TauBay2pjb^)u!A=s
z5$^3)73GY7mEK}2c_I)a%NsoID0&>}jUpTHq4O47G@gOM)oINt8IWkdx0oac>9Rk(
zMODOQYWia!ixuCAe_t4cuE4+7AeY7Xh|T1;)731`M_drQ^EwGKT?f);V@KWsgb8^s
z4V7#%8N2Tzw!mQ-xAumsME~}>uLG^|RnLs%Q;}qJ+G6;=Vv1};GC{q|W?ZyWi9?-F
zw`C_)VrRL!otpXhisPNnyv7#!ifZq#uyF7R&d(zABCbm8!m@trD-M%KwN+Qg`-!nK
z`8RoLHo#xZ3mJuBQ+#PB1yR>@(DlA3C+N?(m%Ip)qrVs+{}ycPvcI_2fA>r$r!Klj
zS-LCIQ^)snl?T&HYt_|n1c-?;c|{5Y^g!{h_W@w?ff70P#u6X}V%<Yns0k9oBBmtM
z>g|g12lvEfUn)j@SuR)ljaOF&i&Nz{2LlU(MKL)SNPS>6ny?i34dh5HcqE+@7<Tb7
ze@^*av3t=9nox+?DMputm5r2c%~3A2ZA!7+JeDT64Z6zbAy~zgLtya?5nq#cf@(P~
zR7{p%%~!KEq1gOB#W?nb0%um><3_01%(EqE0G_pl{&mgFs_i4y%s))*lYNHpB@gRo
zR(0clv+&n)BM{*oarIdDCl=JKx&S&kK>Xe^pBdn`++@{S#zuYL%SWX}xD_1F^!Skk
zZ=AO!n@us}+4(Rr+TH(Gq9w?{rlsweTex^@a6(5)N#Agpun&|=W(eKk`#9>h9FM%t
z1&nK^U8iV(8|ukgTrS~*Y6~KB6l6}0k_4HiC;K}hFK3UNBE%`q8FQF2QtacbZo$Sx
zg87bYfju}<ob3EZ5gXP_O!K;din=3N<nDM2p)mWyPpz3aQLc_tSNlYXelqzVnNVk<
z#g@*I&k+kr43nRU0S}B8H#@((mqj!eGsEBRDp6bC;}B<dYY|LCRyeZksdG^V<m;&?
z(^zS9F(_%gKeuGOauWLx(4m53)fi|2wMF=Zz<lZq-66-B67>F8<JIg$bMZZAVK>4d
zi3!S>@1<%cV4&&HuWV<Gn3}gB616YV>uLz3ejhoKsB#P`W>s6@U+tHaX-I$VI|BO;
z5Q4a7`OT-C$1OqX{?;7lYC&O%v0|XSaG;v?h!s=h_kdU>v0}H0M$C@ZQfpFQHJka0
z;lyBJRHj+Ag7k8bARm<BIuy*|X4R1aNYov!8*f?P%+F*+Iou`>9e~tv4V|;07D2$Y
z{T6C9G^<t)P_v{saX_P^wEW3v13pDfC;NC3JIn1X0oWaxY*!pa&k?b3+>aCICw<a|
zc=6GkgEt%G$sS3DB`^lQm^Z-{F<zzgYM&d#97yJ`wGeaU6S0IRTZk=k_kBZvxk(#w
zJUSYR_ah;K?nkP{j@2WZh!JV?k;eJcH=PK1A$aqqLuqDcdQ5LM%Z?W#;*QYx`}D(r
z`M%0;J@K;!n#fF$Hu2>Ylwxnhi(&rvaILp)0apLq2_8X!ul~&DYIY=E40o<>z;4Bh
zE#q}mN|mSYm}5Aw8er>^{Fr2!nMlqlJ(`4-M+$A-_v2W{mSVDV`m1b4OR-0bk$irU
zgbL+YXsTyOulk(NGU}{ti!1G<W;a`kJzE|wCv@p175L(et$;tDv{^Nw4>69>_zT%$
zWP<3Qvk)>GO-X~QR^(47<PXG~JVm3sBvXUij}n;4+*BJZA^Vl%W<(T&!gqwvcy^SU
z9ZV2AHR<pVjglKuPC`=iN)%hATz(4a)!faq?pO|9N5(Xq>b6PkI`ekNVw<fSjc(TQ
zpGDXKW+sZ6{ZH-T^Xz=uHjPc0w05|k2t33J0%8QlU(QRGo7)Fz?S4QW@ehj%L(BFw
zU7F)w6krWn0sq{asabq0F*w|2sd6a3#!~zhDn7oI7$UEVgaX=19MYr@C&ZQ-sS9?$
zl^EsR{s{9;5_>f~b%cO44;*c3k{D7PwUdv&6H@nQa3Y-pT(64&yi6`XbF#kp5iin?
zib#gTtzfejAEK_|xw>Yi=LfiwNVstt1PTnM)Eh{JSrf_!TBC#?kRWkcimg!A(W!_v
zN)~4icK?dTG#pz5z|emO@6Hox7Pe6Y>fnqVy0$6&8U_Vv)t@)+jK(D=x^S~<TMpQE
zCMIFoOVU9t7n8+q-aRP8-=6U+xK5iCv1R7ImdJ3U49YdDcH+0x6VaQ=09HhOx?Gm}
zOy5rvih&vfG{awnwM-FxyLTj!2FUs1OFMFg13AfJl)Co_)x|3UaDwh1Mtl8zcv@*?
zC3CyN7j^}@CE9L47_xXlWot3g{VYUNYVIvG#}Zp(VQWLxtS3JD{{i1ojWax_Eb0dZ
z;R5&n#SF;lowR4JlPJ&x7I<uI^diV?Zu&@n<pT~<??V7-5GVuMGf|q=`dQOj?3|E{
zOtb0|h(~)AVhU~%9oCv*csXhk_c<#2lBkx{MjS1F0Cv8rjo7Al*+HtSLS6e&EV0{5
z-FXVyp)<TIU(|2M5}gZY7|#j)Z?==B{XUAZz*I2|wkH{pG0aA!TJ7VZ%W!3vUl=+7
z8Uu8b5CPK)-4nrF_zYy_sbcqtZ3k#f8EsKa=a&3UZ8w0zQ5MA|gH$noT*1d2G#8KA
zkh>j$-zK2)=^_|XNrtRQg$~u*U>{P`s$m0-RtNJ@Ono1TeXWVjk?7b!ChW^?#bWuk
zK&)bWF^~nf6FWzA3547vyOF1xMs_sQ@V$guTCKyfl(Z9*q1}AbNXB-z69>sF191JT
zy_hC{1s`arzmF^c_#}ItBVGA_VhY#;&{ek=Q{|_-LI7zmCZ=4L=z9-QlSI6!0Ey%9
zFcZ6Jev8dCPhVu3&$X8&UoZ*@;Y%>UZUFn@77&cR0P^cyHu;k{xC1ERVCT2NFDC@_
z6P=IwBhG7_V~LllkAo~&uR0IRdH^J^w46b6{e7Dfi(uE^r=nAf{(d@5Y@;bT4T(rP
z3UXOLQ?g|eKAr2!C8Zf(qydrmE%%#5#}30qpb$5M&-Q+5(b?Mx%(QMJR*Ea$W|bRG
zoX4k&1B<`@PHG-ay8JTDW-3*k+atA0U47i!+o>*%uFBa?@T%=aJ<50!6srxx#3`QY
z6NkE6Q5RbYh@&nUe2?y@G*e@TBZp!%9kLN+VNZZu3)6~0b^16KI-J%<^)7_}!5v}p
zN+D4{2potwO;T>$Jz_Rj%E?3ns?Acf9UaAN)yLSBrS|D|P2J~+mkgOyo*~A#z6D~#
zPMnk>Myp$$u!FP5R697!dvS1<RNKJ0>SaV@6&d2v?gRYMdO7dP!o|$dEkJV^U-CCq
zaBQw>T*QN;7^-X|YJ~i{I=nniVt{Rh*vL#VF6LK1Vyci-u34Ick7ex!NTl|HTu`sd
z6hqu&2w%ZlZ;7Ck3z<-4QoYp7IZMoyjbpvC#4g?|-UV{E2LKO{Q5$c3LsZ?KCC19f
zdBVjfOHB8O-b)Z~)kKXrDh=705t{=8!E)<V#A&XX^a2rb5jJOuQ|5OP)0#^Pu0z0-
zQO&4yJslPRuIdD#>JnqWb`s;{`3<13cNXKjKEv)sj$4vbI08_E+wh|retG9_5+q2=
zp^d5?xhrB2BaAeN9N?@?a*!GyvPNpW#MRPxi<cT#)@!__W8>o=OO3DGNsZ3~651Qj
z&laPCKLcL?3cmRXP;deV-bp%skl;{}Eq0Q(h)}a1v&BSLL&BUUIA>|tMNF6P4p+0B
zE>POr1K(D55kDTOsUiq3#<ovLTR+SJ)F%~~#!JU~&PXCQ+GhtDD8ZxFt**C>(K=#9
zwjFO%SMbw9to-w?;ym~3P{D0kCEdg@_x{l+4Kz`G2sHVq8+77=Mrs765x<k4RKnR!
zE57ERoCGSQvx*#j20C=ctP!NOfx23qBZkRjz1fiNVxfE-R`G0iF-krhS3I6}7sCSk
zdC*XA)c%a4vQM4q9;_!3bu{u*dWb#cKP12_u7?<(GTU9kDBo?M18cE26F>=9@o;Es
z5<=?m*N*1UWqODUdwHT>-Flz_#PBkH>}QVt4S4@A0_(QbMqpndp9m}p4ca9%Tqn4x
zW*_B>uScYR1iIGU<PWXzOL61}nUAS(g?W3nnhnYmqoVGU$;6O;<4ukUYd-`ggmFwL
zj-`f6@C^r&JTW}^Q9Mk0+?6W-fzmTODvI8P#c9^o_Goj=eXh!x#v{&&^z~08_6Mr<
zdK*oeRYqVoJ(nJ9VeIMQ2I|mb+cv0A2A7`iW3V`(vc3lTLSdni0_Ajc(!W5t_$chT
zN8Mlm>nZxSc#q%!L5gI)!8;@@?}S9S`2#iV00xO}>M14%t^>3j!_T#DgW-^$%@O7~
zbdwJ=_Y~dQl<y*l-J+NsxJ-wui%w;lC|S`M8n+ui%}KrkYH3k{ky~G$V7<S~Nc3$S
z{xAIgD@@Ibdx<Rqo^Pl5t3Z5`+!_vm!lMgFNhjW2*FwU4i8PjRq0?+SzlntJ5|nq!
z$973}6=E3`IF21u&-4j-g;pr25H$5)D+G%fd!8@0?d8qKl7QW!-db#0!Pg>s3tx+q
z_{VWA7CZmvT66<L!dj@*=Qlbm#>MT@VjMyur1Ql3i%~BWWV>I~JQQTJ^Vkn?9D*(D
ze};l&nPpRw8bS<_E+4R;*%npgZu}+%#ua@@JgZ*&%YK&HPmJO1KgCY;KijvSOBFsd
zvoq@k`O3#&lch5(uddjNiBA=5pb6!J)Rle3<nW*0A&{y1?*zR_Qrai=gh)2Buh?wZ
z1rBM)(~}XQIGgB<$C0JeeNZ@lQTzMf<qBDSV}G(#n({Xw->g~=Jhm~u%)?oMO?u%z
zRTCIoapm#WJtyYYPb`qX4^d}EKQW^5Xh4X>`a>`qz1vUB@M#}Jv$<tjzMfi}35v#1
zenh&ja|TSzTl)pcH^YnUN^ebAP%$=r>Nkv+Y)B<-9m8<0R&B=4m17a&5IP&pF*-RR
zQ~C=4{J%`;Z3BULhIGwa9ClU2Yb4ltK+xu<^p?<5$&{{XA?+mGln$>L$&_CFa=Vat
zNT9|r-Ph5C9)kcZyVvvqVhj0v$ld&S@qVjbo+<q-Ww)-Clv)@y2jS*N1Mrw**$4#T
z@$F1+RG)tOE`F#^;s>jE>(%ILzk#AsmSSfr|El-u460Y08|6t&QEiV2NMfZ0{llu~
z3=$j5UXGGb@rsxdH@_WcLPgCvW8lGaVzA&aBI&!j)p=TuR$BVPtmxUvH|!Gm@jz4<
z!)U5`%^gXL%;~46Y)Of`P3jW@_c*l4fCMkKxn5;$6VW!Q&F?Fz%`a&awFzs~X4POZ
z*u{|A_5$|O!D5Bat1)O^cdd3f$+Bb(ZUM7>(GW4B^Ufulha6bXdB|V*N8%xpOqPVh
zTV-Rir{ey(9D-Q3?t#u!R|*F=Ze)cI3wYFpA!0(qf>kt>d>DR|L&YA=a8JFrU1q)4
zhRdv7c=KEZNCWCD8Y=!8vGaKvHuhpqMEO^iPs8}?AYf5UB7Q@BHdM{hVPabsLr9Nv
zu!s*6d-xrRBHST4v~CLq0w)8A<!#g~bhwDntfhQD>a~16>+z5Mp4=PoXHhn`oDYp^
zOdtU$l2CQpa52i`!do<h!x2QP;LO9t*TTAgg-B)SiQIZJp{F|r^4j0C0m~X8`sV!e
zAx+Msv^BYGc(64D!osNbxuk_8qs3t|T1d;jmt=B<d5YHV>YLQvF>FCr0<GROLX443
z9K4LCpgOt1MrZM)c;SNXYNRA!TLCdHF1EP0^`b;6qH}sB5^-f6>tqvDKWHwal{e*A
zP;Y72qU@Mbois`;mGv^X<n*vFl{SelRb{0#4cJ0|^>(aeHG_hh5Nae0w0Xb@h8>F~
zs5)F-IR=W1A-(lnotY(!5xciN0!fO*OQ5$(+DoZ|SvAE6Ok-Rgy-q(9T#Ks#mS!43
zQZ<edb5vggJCuzbYd!K-v&Lh^4Bz8?0k4??4UX0hHgc>O=x#{Oyn!=TLv+psC$@B~
z*vJ2OH;JV#1Sh4z;3(E&V41!p(0BCf1f5*u*`Wg&Bz#_{AXh`kwYz)FENfn;G4kmU
zPPdN}TPWA*sX{pzBX6ZTX->s?SqB@d1-`U$o+&$=kEoF#p$ZZM$oJ)~8cAWs?<mK+
zY3%-ZF+J`SmKnY<2$D!|1tt|X$B`po{{^5W!IzuCM`4#3FhOkXVF)=>w+FZH6XxR|
zRyjc&B|q{gjXj$nE|UL<Lh~nzk-md4@7m`OJ%9ujje6L<H1^3vF@5BBoF2#oi7T)`
zR_-m}%cV23$^=J4+Jm&dL??&oPBk=U#G*0nu9XnD<1&IlEb^@g>|o#+Hrs08$fK`+
z`yP&*Ec(axlXF+Y?<PyGhN+O<I6Mhn`u4b_%88NWq{(8x&^@#f=+)d%AA|XTDDjXx
z0_2;cyFjXGIz?>JCh1O^Q{7v%!u3w;Wv<eGGozfwJOr3$UugIkO)SrMmRp<}89umE
z<3bGXB@qt?Nnkx@)7~Xqbiw|O|0L&z=&K+YyK&?$=-Of&$)75=l;_JJS5Acpd<|lm
z<mFI)J5BOTiIqH4!a4lOStJ}!ZNVaaV5%5BxdP=K#18AbBw2WIfi}=@${a=_xi${K
zYD-<075keDo6r+g6dlGK{Rm!f`CuNq^d#FZ#Rg-C0$1Jhr-{K$tAKN4-W)@C0kdTI
z-)!+Tv2)u`!N*>L$0j7f2Tv|(%{-VMmIHh;{lyCE;xyPd!E)rdf7k7UB!cC8uVDt3
z&^KTzvHZLeEga%4Xnw}_pgWDgnC@V%0@4TxVe7$b0Ma9^x`U>SAK0|%qQCrIQyN<_
zT}+OiXhJz~y@qHTv(Uj+aeyW1aVZB_HrDO>bm*IUNGS(HKaODuGelL7Ky0ND#oc5@
z?zxDW<hh5eZ*}AK=pIAbr=v-Q;>cYZk^)2e0BM|LXh;g%kpB3d8D?Ne#kbPf2Q$Pr
z#oAlakW3}EA*EW9enb*SdmcbXx~4wykYre{K>uX4z3_J$SCrRKS<9hh9-Yg;UEJmG
z<<vI6GaiS77^|+f>m<F}q`FJFfy8D%bD@1CwfS-?a}<Dqi1~9GE1D^4<Xb>NyJm`0
zdZ{mff|N_XDfA@B{RpRJNXQhyMKX*aAP}u@!V&_-(PzY-IiB1y9iqcY0DV$1(O5s)
zg>de|rq2>Pd95IK9a8(?4`^1s4zxHtON?t;a+9bPm69LpzQ=hYbodvuM8BZL1S4*O
zOC>f0eR&l$U<<=86a!Q(YSd1$(goq%B`FTqva6?q%M3?W*cFgEEZ21dKuFl3c7q|{
zOX_$p*kWa&81A+EMw(N}f+VM+WvF{)8tNV`6kCQYvh_O<tx&(!?$mDyRsn7*MdCd9
z7BumCkvP3|?5`l-vKQvUhS?;61n{5#@Si}pM)+Cw4<cXzi3;5a0ss0XjkTIBc5*c&
zG`t3eJ!iJqMjjE3`!usf|ITkfbH-Y22UtNAK(eO<Sqf`F@x!FxlYOxwXs8T8cc4QU
zEU-yWeU`==&JmOR7L?Pe5E(kW&?HS^Mk6{v$)6+YWO{aSj#%J38EccHS444!10?{a
z9@+CWHejwe)b|kfD|_o`%B&LqN@K_7ij#daU&=$h1mty}C#Ll{&B@tnwY>-$sf_|7
zLIaj<=O`s*LBO*NZzC$yt)uvH2xE?Y#Zqk3^)z;Bo){in{^VZ+nTe!Y@~U9TO?s;W
z`n^;F!^uKYT`x%Rqy2mp0AZf)|L}F)0Z|>#AMQX=Q0jqnL=Y5FP(kk$1uG~DYU~Yb
zFluZNjSUox5=61YHFl%M?ptFNdpEYIXkw3IjYlqajYcE)`^>&~1(WaZAGo)5c6N4l
zW_EV=^YEm+&!cc^ZE%zcZ0JO(VeDQTbgl+^tu3KOz3&7w0W78xz}{OBf@yza#S^8P
zl`TAT(Ily%YIgvOog`)02D8nRV0ru0sAJD2NxrItTdc}tDOeqMTgU28mTETsr;PZ<
zN4D4gUzmIR4f)h#Q>;=;9}q(dCrh<$>$826rE%(Jw{$FeiWD4a`(LdM&NR1n_k-M8
z0;mA~cT=S9s&!sP*QZETY-@ZDW@1=`6{g_)i<`jfMG_K-w?ekof5IwdN&9QBzk!VV
zbf-yPjad-Kgo`dnwFx#6#Q^T`Ovj#PNljwsV@_%BMKdseqt<PG^ENPlBiQ(OIm?7^
zdeKWP@HZgbv~0<vjspscig@VhS6T&c^sUDdC#i>;2zraZX8DS(%9he>`!L&S@a<4t
z)v=M&q+;7>)@-^I(!btkKD3l-d<po*fmm>J13Mb1JTdPVWx$WFf+^(PNO0cu)ozra
z6TB{B_;E`HippgZP+3-TcYt*{JEA(RsYM|7Bh#f|Ovi)iQeDqpUB#Ux{d63lCFPuq
z0%x2%tqBXyfy;&4WgY9ABXt}yHC?nheJ0vW7XUFgTJ3Q|<cw*SjH$>l(MW<bcM6d$
z^d+CusumFRAqoeT?8p3;qY{@~DXC^-xy3%?&10u~b4hvsSSI@!z{<*%TI1!96S-1^
z=j1Llgh%?dMp#&Lj?)mfXW>rm3@Kh+!4VeY8L-LUf30H~GbC-DNLw(ytX9ShEtDtd
zz6eW~SE}FGS=KTxmO(kmIYw>Vo{B@X`kmdg(w-At#l;R4NYKqNBO%3w7`2H8dt%NL
zre%#Lj_#c64nAQbmCU}_;$HVdb#b_K5{5<cpfsQIP(VcAT|}dJa1%X!k0|Px|IwK`
z{L9FqM+?_I$8VxHNK)aJKvc%ipI<2%xWk8^hD9din-52VN0^t?N-6==8^M4rsFwv+
z2rhVltLzjM!N&c4aGl|B;vf&a!gYoo<!Xc!_WUc!FKed>O!M<w5B3nW;%UXBMgRi<
z%NYp)H=g&4+l%oZ6miKz7eHCEbYEEN_@(s`Okrt04x_E|Q)Oqq6Y$JQ^vF9JeYj`2
z_OU~+nko5t97J|bxi=!fd5ULBG3~>OaYl`(4azMo%sYe!Wg)eP(+Lo3I9M)|R*E-d
zP0HD00ficzB~?$m50SPfWDhk+nf~|2>;Nbem(6eEvJvyE%B({F>@uB<q1#cz82Za!
zkU2slQQFcbRCVFvUJsJQP#h#Y9fpGhxVUS&eLse9ElW8q&Jr*tcXv7-BALqLlw4;E
z>SRxFvB^+D#itsuBp=gvOC@&_oE(`vG4+FSq|f%(O9@c>K+rTBs9at_jw5!}3hfAy
zCv8|t2NeWAX;_LM{U;GPqCZMmHddep3a6-O)GteiOlmgZ08Qe!)gF!lRvN{5Fmlsz
zD|rf^g8CqP0mp8@PXb`Wr^GMk15L`yiI}RKld$y%-lC?g4VqnF>SW7dQ5p8Dw8B6;
z4JM3LAJE+0XDYT9YA!%D=YZx+Q^VqCOP+y0!G+Swp*S`1$nSQF)hh>b72C48xv%;+
zw<c`CY-x@v!k5)3kQ#Wcct9|;j52FEQHUu9nJ8@zTx6G?(6QMCQlxq~evIi?=)sB$
zq$s;rkfKC$wL5@~CFbl~1&XlAfGjS4>BrO7R4^%BUlxvC2HNUh7}n}!?x8*exmL8i
z;W*gc94XNCtK;&hz8_3TDnvnPj?})+J>U**m85aQpo?>oj1Yu|0MAd@Z>4vm#+bi!
ztma%e(c%e+j<9WXn=5_p-2)0?BAlLJ+lUZW3J?z@=09}o)?B#XeE<~iP)AeT&4+l>
zm=U0XC=3D5fgnp;C`D_&hK2)b(BBwnMFcWzZl(VLTNMbjAH%j9dcOkOJBW`mY_qUq
z{u{RXAYB1lBm^x1n@v{%+v?BEu-z_^Ve{NuBEwdBfE8?bpM1V_x78XbRIt_MJ3)-<
z=wc{Lq6<7GVQ<ArLbkEAHu$(~*(G08;r-X(puFnN_Qy)iTp-n{G=|`Oq#yhf+q3|F
z*~|7(r$<QPz-^?T5dGEgy;xSy7D$QSxz4sW*-dOR`y>?<x!7SFps-&r^dp^Fr-hQn
zyPJ|-7uiwrlfabS+?iz|TNUoi7A=$l`Z%B%7DQ<mzz0q+rn5jn?R20(zSl}CMv?nX
z{`3e}jrll~1`j61OttA5Af@A|x0q7w9EfGR@{EqTd?UTLzYEeWEOJ>S#i%r!dWz;Z
zj7IZWV)i=#`MnlPom%u9g(m0(&3x9^$bgibV+bx)rD?fLkQSW<dLf^zF%H=F8a#vc
zx;mkgNB_7{MzQPd8$|616Kf$&UV-L0Qj{Q<{jQ1>$&!*Rr+h$12jc-50(RmJI3!xw
zk*sy4eJd5GZt3nrEw1|<rR6uczk?(RK=+MA!+H0_7!vc&6PSyEE0jGlQ0X0v74i12
zShrkQl)VH7Pwh;3ar8qY3ig|z94b#9U|o6Fuhx|XMci2`d8@iCX786u$xcId%7pcy
z8wjh*GD+ulAq|sQYoTyWb$0PDPSX{wTqcdPt@{U1bBLk}D-$^#jF?OwZ3uN~dnpI-
zVn%VTd%KRsuaNvy_}^~@{Dtcs)3NLoQnkbf&=5#qP1E}rV79J8YOwfR`k07{&NvhP
zq&*049(+PPCkG^9)J(x&YwW@fu|n$Oy5ToMp-CG0VV{n5SSiJ-|Asp8)k>+2)1B?|
z=q7Z*=&r4l+Pi4`f)O~owob=kh<($(I@Vwn)R7Yl*|1eotm@V&wtAIRR~>Uv$1bgs
zE~xfZU~5)Ojl60Xqa)ZjTx^_kb7`P})J6X@d%jvKQx*Kgo_`0uv;=O>;cKAIEWwYv
zgQmN)>^0D7j@Yr~Yov}<H)0K!Zo?r2oCh}R*xzfU0QEVD;XZ4n2I``7I+nUts;;`}
z#>TCM8&!8C@U>D+pKk8p(zQv%x+y~-NB3~ipF<#8$){%Lj$p*3&yoOf4m4mWg@%ch
zSRP+d>!fh6{W!u)%DYTLUm7Wq>5#MH(_qS9C;e4X!o=fZ0h{+^ush58UTV?4326F|
z4b6DASb)FW7BlXgI}@LzX2XY@a`sXgL93-3Py&Kk8iZpAy2{<dW7l=eX+18b?Odm0
zhgN^7sh9~qn4I^PRn-snWLcNv?dvqz3&@Aijxw4?Gg^_AGIpRr`Y!DQU4w?$?pGaK
zzFzWfUSRKW$DSY#nFScYkQ}zV;GYZ<_!kVpm^EQ(A?v5}j66|na!3!OX5s@Kd%a$&
zSp&KnNKjZuyVImjFlw4%&&4y8WZy+ueF<x}L8{Rl1|C7H`$MwPjQ+O=G7+TdJKvMZ
z^+r1)*W)OM5VQDejee3BH%Q*Ty*Cp6e<iaMT~vjA1xyTcaI;Sn_Ui`euJ<Duuk_+2
z{GfhP@MjAuIloZ~@qYImK=ZKJo#khI_dnDz$4!!d;;$SORs#fvJ%v!U<s!c85w}J^
zF#kabps6R>|I1s1I$8D~y^ZjeLGc<8?7R_(cl0JHR6XjXjxF9K)g)E%@FvO6GaUO9
zEzAixc2dyeqK{xNHc7#LyGvv&#3K(UWgr~5Yv8ZoI8mFW4Eut}q2p}X#?8_nKAp}{
zLv|rz^rT`wX_a>m*H9q=Y~3QIc<Rps?hr8!qe2Idx9XVNR_QO#-%z)7V!6D#TXZa7
zn^a#lVpCD)ZBidwRn^}Zm!uP_ihIO*w(AcUP*y$iYxgV!Q`P!lw3?HtV3V@48iL%?
zuVAzU4aLa08!fpNC^ucs^^$Y*ExG!`$ZdyQY}^W{w=l`2Lt)p$g3WtM^RVL#QXYVQ
z6Fhg?qVMFM;_%BY)`#|iy2%iBw@aFa{lKkCpJ6E_?6losOVk&S7)y}COJ|`jH~?+<
z&td2?kn25tJji29woBnoEdT`xpYs#I=gx1J`UO2~Bu3dY#XQPghtQCGk4IgsW63{A
z4TI*%rR*)G22!cxpm12QF6h{*AEZ#nz|)|*4!Hh<gyJ8h-d*QiGa7SmA{?mf5!b;c
zvj+9<6A!v5h&zR0VUSHbn!ElMoR8L_K*r=#Xsy_&`3;kdSn~KQ%Q`H3hqPL~Z>Nrh
z{3wl47o7t2{U~iwC*IVtwmYRCRL8cm_dBH&_e=2jFV6|nSl?Zef3?p}5Lw+Q9R>k6
zuQ=z98Y`<=l#dOYze}2x^#>S?MU@ct!mCIU(w1cp*}n!!V<<L7LEMS@Vj$Xf=7B7t
z3eSKY<ocmy46{ZX<kBl|aK@wDOZZ8%174D@e}V`Fr7J}W`?g4O@6_YpK(t1Z;Zt#;
z6>JE&>`iqO;cJBb)zA^I(SUl;qM@bItc(6@G;3&xD;AKOJ`_oDZGxK!%oj%skXj{~
z0badF#=Ni^<sOqU{{Zue7*zQC5s%8=Ev@NreYKz^!-~X$97|jlBIEVYtuW8fMbueK
z<+nH!DSni=Tl%gg2EY6h>-e*DB0PGJ<eT-kB4q5*TI}$`1w9ak^$eId1vx|1aal?|
z$S&wV#kV4E1C94*9nMQk$2q|KjYu)fv*=Nr?84p%IRI?{GDqbq)#uQ$i6*<DOM8TO
z05v)9g(;?~0?I#){{xhwcmhSfjnQQZj5m8>#pwZ4r0dZM?&{7(I<|AK6jkj)9nt^c
z7UupR-vnlD*qEtZG*w^hqMnWV7U%(5DepG6wp}n7F*_XBwy}EZF6demjjq2a_C_x?
zvepu0xiS04O@r<308*=PbPKUC8tmK@rv3~+`tIBm?AjUyXo%m$k_Js@GYC8v;^%^7
zIr7{=aE<aayof@%0Rk;Txph<kcoah%`yv#*!uY>V+Gcbh|De2=r0c%|Ln8aYk0@d~
zKN0g5jCmUsM;u?4_Z*pyJw78<D<3IE1crM)2dJ@*l(HMLmAFwn0|TKO#ZCGt11W1r
zkmy0BCe;}()##~XbI@yOkA*tfYGLFuREJQU%{wT0HO^=%K*62_5?Z7K*$ArzK*j?b
zsjZ2U@=n1f5uf`PZYRWNzp;&Xcq`rqKL~x(XMv85IwI9#kB&&eS=Gehs5q`U4>}XZ
zP$5j@&~9e(NN~_Ey8$kM&G1130{T3bMtM}5j-_BW(LehE4C%^Vn@WRmUmezSqh?N_
zAXtcE2twA3mg6V$32r+!dnylMhC@<>&QT`wLvbK8*(AIFiU|bp{;Stz00IR7l?VV6
z+F0sgjBC?8t8w+P8dpEiuVq}MURaH*j?!#KeHvFkY<}g(CC8Qe{SFqoOmr?s;Lb60
zJIw$@3vB5@#J^w`D5G}`?9uwPcjClps6HO0%H!cSr~`sz-enN7QL~{?KwP(aZiF?2
z+RGrJOiQtzaxpPskt3><D|;0Bj@4*xUd2fy{K(z0K??DW6pWvcNK;oenuhomJDv$~
zrM{uoOQx{2ea&*;Ec>YB7m^)_v*J|D+=wv22<~746;UEiqQ+<~Qpv2KAf;p-x#TKK
z$q(C<lBJu=_fhH?Uars5&2`Fux35+1J2Ahli!m+8Jo)lByt4vxHQ0GDR8b(xT!4)}
zCbd<6kaXtwkPWu!*l`4{tPJQWK2GvM9aA5dYS*~BRc0|^^$1h0*v1iE2Y)Rjfitq>
zxY3aX@od&{xJy4pQ>L(!p-4p7$=a1MREj#OJ)mQrC#2BUr?<$>de^09)d#5A5Bsf~
z#nw^k+pyd?OCuVT`(~?7NZ(~O4G~kYpb4fxj%Rmxvt>Som9zOqv<xn0tYhI~b?6kh
z3a0R=mO9S>4S>;XMUPmZf{!GDGR=G>zD;jf5#!+pK(AZjalV3>Hr0I~yfwG)+=$BE
z6*o?V3iLdm46}+E#LAZyMhM6!<?YBei%v@3b@QP#5rFLhAo@n+d-%QBX81-whWkrK
z0y?u5fRz|Es|p|tos?Rt=3i&CPeSsW1*C{wG7LF~PvYLOF@}(fW4#Lbn2M8<rXAw`
zA5xYlMm+A4uz7gL(vWe`ii^fzsOT35JFgI+HvP3|Q6C>clT#bgiDkA~>M5zAoxTG6
z{brq#q5?}Ux+%fGg}Rqu{1q?2*o9DdX{`eaT|FhW@Y*rX)VcX#r&XxOqE1VGt%l$i
z(1(lIAS>+gjp?9)+#xKT!V#!hBD@5}+sy?rGXmf{Prh5mJEk*c0o4Y387lw!Z%BLt
zGeQm1OHwb3|0ke-(`W!_ovd%o^`I#U=WXar_T%ubwX8LnTibxv3<1e`4JqLKAagBq
z{ujs>gQ^J9{vU&)D_beF)jIF$Z%do){fM<P8LSDn(5ZR1?H5H*$h+;kJbAZmZ-pb;
zZk%@oI`0}K8k?cC)!M49P@;KzY;Ux=#k_}JXljt5!PK*o#wr*B!hf8VYB;$n?OY7Q
zUc2(F<mogM^#rr7iAqP#O0(*`tgEEVp9R|r-5$iBR<^BYecsyOg`Orw6G4KOrhf&u
ziJzsAEHzHI;BKy>$Qh6HF;5AS68*WFL~unA223_Yft^4?&h_tP+<c2NCP^gHw1)dM
zpfy|-qAq%C3usK^x<8Y8w%lmUbez?rO=3>0Iog;e&<Axiv#}PG*sAluJ<OaEp;1X)
zv&R5RpY>xM&*9?B*0nk|@f-{^qwyo{&@^vWd`_yM?uf7J=WvsCR30;)gJq{85`xZ4
zVd`6JaM*tyPBRkN;pp?Q+b6;bGWR^}_SNv?`RgX`?9zFuX4T(->r$9lF_vLFbgaS!
zshRrDch;R8#MiJ3QiyE{D?10P+IW2P3+ST*e%!c#J_5Js78Oe#e(5y`mz{qg#3YNq
zZSWTZ!`8HDV;3*)6O$oS8xv<v3L?Q8N_z$zk@}UEwPb0<lE(K@OEIT<V=%Q-N^+oS
zk7R|#lCM)iXy7DlEd`O`qik4FvD8`ZyBdcO<cPg~1=xKh7!qLoYkX0v=Y3$6;7Ix^
zqOmvNHl~G}eNhV5PDeI`_i|3u(0W9rH~Rh6t>t6$5sf}$iphKZI8Y?K*N;;-@Lop^
zIMs3;3%rD2JApG;$|YQJ*}hW8zPKcXsV?NQm6s%6&(Bs0y43FtqVll00W275M1-aE
zZ1|l}gryYx5D}Jkt<o_OVQB$=hzLs$vy`l4q=*PhQ3}k(fz;w&Y<rd!%Caj-ULhZ5
zfJpyWT%sNsB&;ZLiJmOi$q|LVL6wi=64hFUos{Ad6`&Nfo{!@aeX$&KL2-%Nn_791
zi;n+0E>Tth*0zXCbReHaUq)P_OUq<T1|tWzh9Cr3#$h^Wn=zh7VvbAH5&ML4&?e#r
z`K(Z+{5JrFq<p_(fI`zV+MgQj1rfl~C=0p*FZ<^cKK8PIbO=l4iWCss=3AWGiG2ag
zV3E5It=h^FX0hwjrC118ByY!jY~<uqzZ3@6U$01^o;MfEy-xC@UWW+TpcP(7lVkH3
zM%u8!{u4h@LD>_bdCvP!^mAH5BSU1KO};?Pu0b;zsW(9tbEy>Xse)i6t`5wD!XvH@
zjAC;8&M0ft{7s^Ud7)%qBkBg^|3TeIC1mXP`ETl8SYTxP>ZJs#YkzBXXc}dwRQm+g
zh*-hzZdb*2SP9$VA#ny1npa*CxGsfe6%irQT^UuT2Lcj&8QePhG3<+QSwV0}kStwr
z3UYQy4vBJhZSUgjsx}O!^E@y(n}h@4M{>k8!SwAgZDjL5jH}d!3UW{_+0-j^B>yjH
zSTJlVk9d<!vA`)N%pbL&6gcP)EV_Xk<75~Jx*;`I+kqwaz5#>#FEHWFzJXXSEAitn
zrF@Pb&u>7YtcxGfH^Fe9V@^N6iIna5u?;C%8JJG6FOzBm2o)2YZx&c-W2nEDBnL|B
zS}y7JR3uSMOG~MHl(ev1(gjK)RoYT&KPBnQActGhHd2~K*d<L+ETW{wNP;)gZ&E*c
zRrc9$l14q(N5>p)Nu50_R|f^tfhn$nFR*aM(YK`LQTE>m&FDXadT94y)msPkm;l~e
zatp?af*>8Md|L`?c<*y81VpYf`Kw{0#XSlTf{ZU&#=;`19V7@5*D>egsOGj59RDjQ
zg1o$7U@Xx;rF$6V8~Ibw34Zk;ia)r<dL0u@79GBg^C?Zc%09G657H22GpjFp_@@N+
z<ags)$Q>!DOW|Arj*GmoVF|t9g9Kq0$Kjrn`Ec(J_A2Of1##;tiZ&+%piLZ80&P=v
z0ZTbQ1z{eHnxN@A#_mWV8gFVC(C=|05ZAz<MHE+j2T@OI1n8LGT?yerj<b$;5nkkA
z4>tO)<PG!m>OnSa&RwWRDbO#k-IW?Rc|%J_%lcuiU<6+Gq|k=M;R!W@nD2L&1($uV
z1R>~apqNop1w|~JP1wNhN!`?Kz%fqWlWKd`TB`flJDv9RO82F%k=qu5V%+HjcE-(&
zS~%|pD@qU)BK`<LzXe1gT7qYp^L?orTXSD(RWFq4eT}DJQ7<`vf5<939QdQYzo?&0
zOPKzM`rAP(o)4rB6$&CNj)hC*um@6-N|()kd;qKKN^E7}52g0FI&$@<noW2pC8|d(
z(y?O?rE^{dkvB%|HX1J<nm`T8bQ^?Sb^Y&%AFv3`)_R2EUBIz2@T0nZEP&bv=@`EG
z8DZFw0i>uUw39!uFWh=09aha9$5!g4Zr(+7o9@Vc7hudPSk-oTy;d!iN&~urwUQVf
zMQ6v|A7nN@L?aSB?A=@))BJ%g-Y`>F)btMuShR7luBe+q>T2sgW**M4dcZ)h09*;+
z9sCo*Q{W&SyYr_s)uSNJX_&YYurqx(%)XIjPiGm6#y*zZY*icDv9F#;ZB;AN*@Y(%
z>Kf(1@8gN&Yj-*uJ3@S`SsHfx(B~Cc*3~r?`Y*$H4XxyB7la|i2BMVua!R;JnLsH)
zatZ-u)C{GRsv;$s+>IA~O~eiw+bfR`Y#OPHLE3Yl!sECnew=@bo8eLT@#d*CNPT7+
z?19guM(RTRV9%tWnwLRg;xP}rYKzeu`p{7wmcv$fGnF<F0_J?!hHgERe0(xd0NLOs
zRWqw57RV8aa6@S-jGoUCGB$81OL;B@SKWaDmu?UcKg06KdJYVp$B)&|B_Gw8w(P)j
zDa<pxw+?}89w5R_^kZQr$5nHbdG{Pgf6^3C)(gqsf9@231oyH)VFEiT+ib<lW_=+t
z4}1YGb_ODI!3)V(GZ{=f_hzPR!Y*61Yp4z97tHm67gDOK|6u0)62kP~fVA#QDMj^k
z5X*Wg1v$?E*M*by9Qu1?4t9!{uumkQ)bB3=hT|+9^LPbM*;SKhZ5#FR##}7g+9+;W
zv@G=%V(X0t#6_>9ajMP(S)JEXnB!_EkYGXF;Pp^m`@NRBs-x99w(GT&pkBTLqkJv(
zR%d;wV?F+oQnSWB_a^ptz`@L_+JP?^hN1ouq!~45Ar2XO!IAn5K1;o@OCT#zu64mu
z%Y$k)Ai^(qey6c>6tJ}Uo|Jj9&DtmI!RvB)ZQ$3ua+)oW{RV!tHzwjp{EgI1<(j|>
z-hk(ZO#nbdox=A>u+6~}Wla3|J{Q(+_)bG}#;iD)Lq@%Xs7I(;fC6B-AW#dcuv!<r
zl_FfOPow4863!>7ICljlHhC)zP(2&MR=kxisI!Jaj{94Rsn#E4l$_tPM}GS>C~5Q_
zC~hCu|60f986|J;FF-#-lbk=lGSqpX#`~HZWT`%y>iEx|{w?{q4f3F16X(9v+2BsL
zrZ2vj?>p&d7k^NRxo;Op<!|0eCEj1Txuaaamf=I4yPtmH-2W6R*?)<|qNner5|!%q
zKvrA^PuLyc1Awh28)%fgs^t?hJ_fK~t^(k9U9A9Y4MPe6*a80uK#f-vbuqUpLHYMM
z8Ol6-6+JadzP76R1DTU8KZ+}clMkucFSh&_mwqHfo3PetJg7;<_p4iU(G_K?`7%`l
zNAy?vPRJhO?CgFfs9`$hLXmR}pCEsv$QNhh$1-)SRRvzCj>3<t6?o&UDpaBYOggAU
zXE+Zt@coVatu*pS7bH!8X)bb<icm~PI)QXh3Z0-r2E<sPMpjXY3AhsrPOjvyqx{p5
z7LY_mrcjXv?^={^C7Vi(rhAywG?nW{<^Dj5Wl+7T&{`T)L6z<=wXC=z_sB{oOvvwX
z#)UlB0>kHr0vD69Xu7_k&#*E09Es1ezv#0XefEQSW-dPEC%GW(rXvw?*x>C)Wk%2^
z0-wa)7oUAW!W02bGh2Liq+CCIjzs$&kkIHGCPPg(ksXz;W8)ooXp8i5NO#1gM9`%i
zmKLn`>;;_Ajl;<=5*2wNNPh*U6GJycCnR*3@!0f8%i((LwgdM`bfR`3c8{QTybWIF
zwuVz%uwi$x?w}hINi^yB2d&A*$TF)P@s;>6HHONzRN}$$SB8LOVO(5PN~`-PlX0;w
zOpBQwhQ=7ZlNiqmEbG!pFnH(`y60uoIN~3+)3K_R`Rq#HJ;QuxTH$j|W!^^}`l*ho
z9C?FEC9epPJz)xJ=Exg5oq4KM9G0YGQyuwmb^De&_NOC{^{OmNj+mwFZsLqUKco)R
zI`Ihg;UPNqsS~fIUWgwH@I!Scf*o|?!LF?UK8<tX?=;S-AnWH&yqao31aqvy0~);_
z3}jV7_yQ~pjII^bwuEe>Dnmr)tAH4SZRP3_qPhm9Wb1rd6&_v3cQObOlGNwU@P9DE
z>B%lcmOO;>?=$BkF|KcEeLm7pOJ)bE@Qxbo3mUEgtJcB+apSQnALfzM43Jo#bF~8#
zTwaw2;LXAAbd%T|0jo03UZK<DJ<S`y{x`pgjbbg(b1+8i&DV#a(}K8(0%6NgQpmn7
z1<}9$LX6Yd#V*9zwWUKM#jbjz@Bcu|EkSBmQNH4qj3mTA1WlRZmlmH`<<azLD&4oW
zfBupd#ofIS6Y(DhuRU;<+LO$J%Td6b9D1ZRMrtN3(ZX1{h3X%-;9zQ@L%9~l{JVu<
zxdqpcTiD$~f#Cy!^;lr2{_hqpp#Vm47qd}r6zQfGww7z*Vyllw(RRArLZ^>gsAg)R
zZ@CtxS+_t&TRPRtXlAlN%`jP@Fj+JoL+=stQ^&vp<;v@->-C3u)s=hJKA1)}9SX2L
zI1z&V#{sr8m6+FaK{*ujI${*clX(sb(lO#9O1$f!6nTy}+|7j*AQy9p^QJqlJXrlT
zwtIUwo~nkB#d^5$boF5LEliA8+;~m(=utXmbmL*_HuzD?9W|=sM@M(wB4}Yh8TJPy
z1p9fYj}{UacCq4L7kIGa?!3KP(+@U@K20@<s>`)O$NN%6quxVQEF1Z+irF6At63G=
z+QEj--7d$5>JS@3WT?0T1Ffv);M%44i6{$V#{I7F61R9AyX?V(Y87S3>vflDy+SB5
zFV!EO(W)V@yr9-BK*N31P4!yVM8l)hs~f>^py8fbY1rI>Ph4gYuY+V>5lc_?1WQl$
z;271%#Gb&zCjt&bC`8T?3J=FsvVyoRkBI1Q>yzKoE~Xam-->`xOK;`kG5~^A!>t)E
zT52Ie{Vr54J#p@viIGa;C6V|~EE2KwK0)&&oy!Vs8+^fC0e?j#=uU@F%F4_(3oTh4
zjR<CDa<xrXLRXK#^+zjD^F(->n?hIT_13W!o;)~hFs1_(Wr)C^|4}vpMa<Ey>%g7q
z;9?-e6fhbg29Zz1KIS(fnBK#!=N)bj6gJ~|qkkFnAcu>v86A6A%b^&*Faj7uzv@NP
z7&rTpm>QcuFg3FEpl>gj(J2D;WXShq;+y@MGA)QeeFu{vht0Uq{iAkazeJM+XrG$|
zXd6@mOM@MpMOEYLhlLc2p8mqLD&bBedI}KIFN%zFdSuAYK)J~onR3R@lp!BE{*A#D
z?xBUa`)B-lmgv0Q8IA_!CJO4JH}4Xce?hd`nYs%>S-iG_%0yQ(9Ilq`x*_A^HR#Rj
zMYoijDEr+Ev084TgPie!GGvGBKY$HbouYhrI$oVU`b`Bk=D-#&zqnV^#2MfOloZ+n
zj$g5gWvmqYppX3X0?anllnkaCO##eBaz<;)p!b1{nm@Y9efaWGo%YDN0hBA_Y!Gr$
zElAEd@X%bXot&{%&ak5zGBTs7Ju_Q-=F3~vIe$(-)01k;h0a49lxGo(!wSzBY?>br
z4v^#;HK>M6KiQ~ZZgrI(uh;ByXS4y9^v#w3W=UP|6HBUy-MI8QHfFG-Cbt!qbORiv
zia)QdehpTr^XGxKU05%FUfn54Ps4@dp1!Clo9WLRsE?*XVfE(+V$a;A<|cm%>V*~<
zv*S0Vt<JH^sTu58;pEkx4q{EryONl9UH`<L@c<qXe(9{Y&A}W3BL9<+G{|M3L}4T#
z#t{PIHz3B_2q-e@KwdpLage++pvbvc6geF9rhqw<<XugFSqSfM^pU@UX^E6$NP+PR
zRWWAq*A{<q3>e7ksO~gkD*|~9)%&{aSRjv3ov+KD1@f8*SkkJHluqGO8n<M!psLdt
zsB*GArw4qEf_Tm70{i!KEd}**!Nrz>tv{l5M577f$=YyQaTZ5W#iwNK7nBN{H6m6U
zHFhWirxG9siNd+2T|L-?s`Fa*1#y3VuwgB$^ElUBu|%*vh`ZEtFn{x^bN7feN-o!d
z@I>7RK{4;5@WGV>WIY>!3$|#|uIW$SHte7398vY|&@kirPQqF6D9nSR2t94AV^P68
zK5HT1G9W00MRTXS=9+UQqT0!cbVU3+6qMryCbc~nluy1ZAJxc_Ydk^?!_S6zaBR~h
zzl?bFOIj4+$<P2HllqI9r~G&dRhSW^6mXyd&>_+-1uUTq2Ni<|<c975A9PzU9%4hi
z8oZ7BdN9vJJ%C%qeAav*96f6AbniNpLAP?0jN=1<NeI)3t#osfKdTwStEuP2;kYD(
zdo&pzr_igg_V__ufI35lFIS`HJva{uH=yKI@cbuE{q{U@>U+q*dM*s%UUtim0qvVZ
zc$2KZ8qhqqBDZP!BO}W`E#E?2CnpFp?0d^hhMS;KCKj~Ck-pU}yvH##^(6`}Q^GUy
zEJX;XJ24x`Ps|@5gsbGvxez|Ezx$pHf&>xN+Zb9#yw!aFOjy3NLwTXC`qd{o<{riq
zHCK*$qgze88)hc79tzaxFs@Ov20&vNALUK@x!}8{277DYNjxtT&Xd%G(sZm(IG?9#
z?!umi^T+P-(O^f300lTCD64hGE#g`{xa-SKIM6jksEm`PoIVMC>C8+xv)LRLz+_xC
z19K6&5s{mTa!*I0X^Q(tSV7aPJL%Za+Pr$wLyXkmgE=BGZx-fAIUabV&&Pvb;=|mt
z5QUDPG80q+z#@WLjW!Bdac$nbLP6xx7;M*?2%d`Ht?|2Pcm&^LTdT?e0phe@%^==}
z+)digK0OFcSzwnUVbY4^sa-zpNV6)k2;3g{#GN$f8E^nF8j67U+h_>ngqvxQ>gmNg
zTvU9dKUEpoPPohl%p<8oUNekWKmSB7d22q4<lEF!>%gvA7xH?C4%9>3xP1byN0-cS
zwQ8x*vwRS6pc1=Vmuq~!I&L1f8dYiBgFt$)krlbr;}vby_7S-55yfK?cD6_MD%}61
zfkodGca2ZdD3&1uCKNFcn&#38M0N!lKXfj};u|j-WQ9@uwVKre8AbDEx@PSNQqdZ&
zlo209TeXmgDZ`PU^Nh}f6exI_<HcGcYolf}6jngCt3E$stL_~J53mNjp1Kx({MCRr
zYg!EI_*aYjggPy^2-h~b#b)P~7UP;yi;%2}MmOZuZPodq@@U&OY4blu8;p$q8tr#K
zE2CYl6Z<@gRuI@+VtJ@<3i4z@|J>hYbp19Q=gvxj)L5R|G%*Cd%@IV5TvDElp?**z
zF_SHJh?(4V#ypemO#rjWoqmq3n8%^r_nYVOS5P3$V?)dft#R=>1k8MGtC6{YTvIwX
zmc<A+R5H1ynBB`RpQ25Frl8cA!^Z%x;$GIrU&rzr@c@;&GuzyV`(~A$BM3=<84*lN
z@Y>1v#<Zt7heOqOk8dit4kj?p`$sW`@6Tckvex2GNHTLG`Q|O&>&u8EekZQ7mSSm}
zR1&<zjoA;R>CJB`8+ttwb6Cf<pHx*(12+-(T1zl7;$EvqBBUhZ$@;y-lP@KqE5w;>
z%saTx6)9g*ig^Ok>ZdeS>#+rrkF(}9P(yXSQPNW8Sxic7<*CS0`~`%=MRu&>aPcXA
z2#1S~_#qrFBJe{vTzrU8vL4`vaJV=H9!?!R+fBgTz?dv}V5@XI(Whx6lY_)b>xY{{
zApoeF@VYLqAbn8_t<Zu{bMdND4JRbZ;fB%!aPH!WIA?j_UkWwh=`RtTh&RMJ2t_Aq
zZZ7`NUs3D-D>{)&cU*o#bRzXLfZwPo6w{F)g3p@r>h=Ypha4gDH0AA^Bw<Jp$ehp_
z&b3V(+!%V-58I^TZ{dYi{c-*<>?odbJi6MghH?YAI)^GG+_~th@5(i@{&Bo+trF0)
z1xI4Fig)!Ay2`IKywA^yhi>NwQ*;~;#;NGo$~Np)9FGgBOzlo;B_qKC*BW1R0tpHh
z&CEy^81{{q=Y<BMq*3z)<&h_aW+(a|-i$}v6@zoiFH6mjRy;&T;fL@LNyOepb20iy
zn$2D)X@QglHRl0tzt^`;qxo92DrIn;(MT5hBdjEJ(nY~I)(Ts+QNLveXwSSjK)dk?
zxaoYVn~rr)-~o=#R8=9w>;xXGt{J6cdlI-W41_d_C>U$HdE+`?0xSx&Jjzf@oeq$V
zM@NQKNkAbhvS<O*N)_ZyY{C7j6htndw}1*Fm%(<**0$i?)p=-q-Z}Vb4Z;tL^H>7D
z+O*_hs{R_`Jm&PK9$~_$9}l6N)jBT))H;V0Y<8(&33{zCJ>&$zSS!SP7^U~o2M&I;
zkT1x^jAN5Dw&Z^5dH4~~3MSSj5Q@be@w8UFcGciW?Dd<#Uf`zH92ad`@lcgBLc_vy
z&1rpIx$`hs`$gvsry#}Dc_~s8^Z%>!6f9|!Y79v9$KJ6ft$9FLglOxHev(8}Is{ve
zQPW@i?TNn@p0MhxMSdQ70A;1i3F2hDHSeiD3!FN&;o-GYQN%=n<RvN}T_WO#2M7ld
z4KW?$dNu}vXTLT)$gKj(6C%596C4P86N{fe(#zvSMYH=GT;J^V_7}>GY}$d5HPqi@
z^S|4MS93aczD&Hzau&N9;|E3tI;GW->635GH7;6{;^)yA3I75(tu6QSaQLsB!nQEM
zorefe>L%5Q*$^SnMOP>FA#~bOu#X-w(L2DK00?%#GY96`r4NKF0^bmCV`X96Kb*A2
zPo0JzDTzEp?TS{vNaS@KE7t-BS{pUNO>oTZE_sG)#X-)0HMbHA8lBSfN_zJ<%#g?f
zye8F_hj?}~&DTzBEb=S_CBdlZQ5*d)Oz~mG3sb6UO3@RoRxOHJCXy#%b@hNJMan;8
zgIQ@3%%39xq)$5@;W|?*OZo--$daVr@RW6H#{>Lal!nqaQJ?Kl$g*BpVLR>_SfNij
zi<Wilgk#~D9g3Y$)sN(LCB#AY6ZWJXAE%zw&xVB{j)G?x@;(ZqpsI-_NMRK2LrnR(
zJ=V%`{4lh~TKOD8kXS2`$vnm`7?njAL6b;iRJtgkTgnB9q7XX*W<t<hU2G{Lio%-^
zrQvJ%K@G?4fkcv+^WK=@gBfk_km-JqE=yZXX=7^2s64WsFt8chi3J0&-gE#;;{k0}
z&Y}RvK$JBxEFxufBp848fsrBVD*%6W)%D?Cn?vR1-hXe+`Vb)F0BCjsGXF)hK^<Ys
z=-dT@bw}PvZG(npcI4se%NW3b<|C`IGab28g>58Pg|n&?z#P{>D!}Ng>HFXo_ae5_
zFK94wi5z}hM`Kt4+Omv6Y^=pUt@85-N2!1HK01YadnqoVFy|!ZXE_+ts)43xxvom#
zkzF9CrXm_2{BEk;Sq|}MkR77LoHE`)X*#utE1|>!P2-)Ai8=|c779W}#uGWC5oHV#
z8BWL$@C2puhP@qzfJ4hdVrg=HcqLCol%7bTj=tAB;{6lsCi(`k!qFr#=O;QYi`zw$
zDdfu1)8Rw}aVzCs*6c?w>7tk2Z4oIWmDg1rn#oF1xn4c8l8&9}#6v0+MD8c1{;Cs?
z^6dfcbch^76dn2*tw;)u5Mj@bl+MtwddH?#V7)qXuI?2Mi&Ga~U-coFC3NB2JPNAQ
zT{YaCNi5hO5>HH|cZ(wRC;YO?WefIwH~~Enkfhk@n7$hi$%>M+Vxxx1VaOvAL`i)v
zh<j#mCDa9rTzHy155~?g9aT~8!!~o3`c_pA$W@+-TvR!TDu&M1ZZ1DMVj#GfO>iaV
zEeuIS44C}x+%^6VjQZ4bI(i;1H*;VeI)MvA8XizUL!^-&D}6}-$og7AH5@uWHe?w!
zFTvz~>&|O=XF;wo4=`9weU<2sE`y8_(1X{_$|la5cMRdnh#-UYG)M4>LX-NKhel(3
z?&FLel;S{G%XxroRPT-IMonwEsu`!3cL^(<{uW$k44#OCZ^;+6AKtfWyz%d%DUIGm
zwDk^@W?2L5P7faG9@x*uW)IzlGEvZ+S}dq1_ef5hCezwzgsO%3qR`sJtr&?yYZahy
z0c*c46r}!khnd!1(@tuZaIjQZc25X0{VGF{>B*a@7KgIGdh+n#fE=3CxXE$@#cR-j
ze61`J4akcvz84Qwj}O+d^j^G<=Cf}_SI;?0YJokRzXs~q#$LQ`v)45U#WDr0TtdaF
zwA&7yt-yZA4>X;))_xGt@lmDAKU$%}PYP1>_s`&)QoRpYS`+kBr#JVmS8=#J_PO8E
z6nqJeZr)Es02C2AO9M>?ue1)Yt^n6>u>kHN=vD!4EM#>7Tq(%N1l$5KhAPc41^~An
zFj@oG_Weh|^|MictA~CFxWM<rWZ-fZ6L2H37nH~K=sw)L(l5`oHu`2L!RGgYTt9G|
zmYv<nL+irl7A{Z$1decaLD(-up2op0I85GU(jMQsqd^#<cQaJ3)|UrX8nTj(+AIF8
zW$}Iaz)J5{(C4zZTDG|_4#*3kGF<J89lsOysItC1s9Ce_Ha4ZugoPa!J{9`qQ)bbz
zcIGuSzxW$5H}kiM;cv!28h(X?5n^uMqt!nB!1~)vnZ@$@@ft(Y;p;$~SvBkuwEptR
z76}!inlTm80ZQ~PiwFzvz{M?C5SOe1-Q;nUd}Gmq193qkqdIKeOO{&{-`F===Gve8
z+6g8c)t}c2%V~%eei)2=+R?*+3vM45mjTec-=h)E%&7U(#Idvc^DytYwKN7&YW5-c
z9u@~8f62sqn6f{BtmW)U<+B&1@mh^`G%)ux3yU8;*;@DHr}PAV==!}DAqXH93NX{s
zxPOP4F7goDF0>4>1>HfZ4u5KLPwNSUkDcR<{x!dVsVPVv?G02G#N1sfZ~(t)ILEx!
zvMisD!R*g8emLsc63Ri0%DEtn#60~^trKl=W!1LTthCngJ5`3ZNx1)15Hn^unGz<w
z(6ZkK@JRJp4MgIByhe5VcfwYpUpJqoW^Q%#CO?q{n$s5|k<rduqnhi#cV4T|!>eb*
zz#6z}sGr?D`qdn7D`i=xm_p5VqqP_XlLC?L&MGo4GUr)v(UWiyi*2Lu8ybf=6R@|t
zNrQu}9^4r9W|xTFW-65+w>6_C-;;R0$c=fkxQu*M0Ju@J;DtYpOTN4#vO$F~-isI&
z&Q6F#Fo-u-El*^wgSn6AMF{Cc*>pm?d<k{`yFP9+OBl>U`&YmrBDq3?TM2>MA^NdV
za~c9V1Q-WIMapnB9k6=gWTg~^t=%|QQ9(rbgMQgp9KyqdnCl9o-DBDhDuW@O7|f%6
zDgXf5ZEnw{SvZ9yZ?=g9IW+h78V<2mCRQs>9S?0}2#?0;$n%S+o*zzbK@LgAbEVxu
zop5@@w6lC~07?N-=+4^?TUaw;cle>+jC$&E(9#RveLsN34CSohZYN0B1+7u1N<lF?
z%d<rTRQ~D*Ewx3_DB#>DZv5H(O(?PpVXo0LYOz|M@~Y}k4@iH}Gita8Rx5AVFTxN<
zf6Bj74}Gs?e}Bq5y2p5-L?WP3#FlelyuH%-fPm{DQJU;1M3BX_T0d&n5oNBY^BU?X
zcW9>RJlNNrwvc?qKRrae=J+W3CMeuX$C?h~Nnz^&r0G>y>J9O1DMfh|wwg%E0h`=1
z466A-$XBO_@kHl+SZ-tm0Lp^&Pb#qL$(uZ?+F(aO5A+CZ0hIX`pTW}E(i48lpYiAl
zZ(_;Gl&vy;@11JYdwvbupUn0qI4JQ~HaXDb8ujn;XmTF_L2%*0U&{g^E<xw;iV+1O
zERNgS8?<bp<2PM3?KKwLjr@GXo*-~<$8S8lte8R5tMOh6eo;#d=^zM>{LJF~kp@E@
z&?F3$CgV>dK!SsuAe5>@i=|wIx{DsrRVW^vrw#>(AaBefn2%%11SfMD0rxG3$67XO
z1nd|RwqRG=_3`Q-D<B+b#~C5&IL!9;iLKq)9NYDt>H$bT+;N6~<a64?$dXeylbV}|
z*+t)mDg*#99i?v!*wGz=gg{7pZoA&!tvSlzCL8=ZOuIP?eA?E}V>`~x%B`>oHL&Nt
zYT~PQgC^7bRTE7>6$<5r?FKK4!8}8wIQ12E`vdT(SRdU+iIkp{qO3G=si#6g<og?t
zuQT!DwhE%J>A`J3Cp%>XOJ;y2iublt30d*oM#fZv2r1i-#A7Q}w&R=T+ZIJ(?2K(2
z^-&4`Zc2&ob4_*ylUGoyw`KCp9UryT%^jClDtRESP(j{O>Zio1REnWAPszQWW35ZO
zjN$dwFK}6;^%!0!@R*O>!XT8vRSw#3tyl@-%f0N<K?T`r<;yO9^k2kJ9Ayi42wEx@
zWwQ^GXmDGmTWg187#qu*sREo>_E_%eapmSmv$Pxwc+*&3TXSxbpx9vy6f4V*Q=u=G
zj^%Z|PfR1wB-$sfKqD<q#AXadn<iFU!5I1k#!{2zjb6HceWP6VL96WV279Th=vdFL
zDUs@JMlHKO4g$nAXH4JSx`~>|@kZ2ybaFDAkeiL+nqDqdf|GpzH5It6Z?hDnajVuR
zVQR-4TKVPsGhm`qGI%w|wy2C(chM-OJc9?;JW-}4D=?1whQm7na<!GC4Z<6s@Qx>1
zJkPqhxqHL|lpqLZzr=Qz-+*FIBS13(Xq%!u3i2|B4ldKO2E9^hIyFJ#MA-RRpvEJM
zntO(hQJOdnR~yP1fE@6Us<et)<F72_h*|!im1i0M<yi)Y|9F;>BxZT)N3$&6mv_Ea
z4%OE{TL03@#VbS*-mMmf+b(=ls}-nK8K65~K$H)URSZ7f<9VZ~$+Q!JF-$u~b{;~@
zUKkB&Ok=0enED{!LLi{L?D4RhzJ{4-(|E3pSpDAAsbFt%B=7jd{4NNxjM~$YO>JG8
z49t-+B5WKCNZ=SkK>ZZ9QOaG3T%#rrdZ>v#V1-QJm#Qv#Eku42F%E&(MSaN|whe*^
zMf;XZQvMedH{3b*ZvdW@-%Vyhwv-Ja*hQZ*iCP^-2l7;Whi&O9F+w!f3XN_45=XX$
z*pl9Si2)78kLnY-yZY2^Eo(H9w{ROYk*as71aPVU!B|rH6M39N!`nn(kOo|S+t$j@
z8Z}rhRucnMMNQ(PUDiUur$~=E$6d%21WzWseVBD<0l5?ioy`7bjC>wW@{q<$oQJz)
z0cyHj1uYiDXXynEl;)o-v$B#G!iRq~`Y?wvFow1Rh?XkG&|VO#EZ?R3-jq36H^9;+
zV^f}fMa!m4=G9f7zhSE;bI%qPE<^Rv9?xu^puIf4Dc;Vr$?pmy#N?20qvi#a`f2Y(
zB;y&vC|c`H*+<brPX4N8ZzuB*_f<IAEj<9#W2z~3XdyD{O~JYP1pH__g$JoMx3uiD
zDLh_X*%d*>rtoOzGMVo|gp59|pBBm<PvPFWvRSmpW`nGOsDb0W@vq7mq(N7FkAEam
zRy&x0j_|JKb?Xs>T~6ioJ(s*DiS=XxV!A;n7L7Sy*0Nbsd1v?UY#;)SMqNcr(mCMT
z{!~69OEuOTzP^HR&OjX`>cZ16qo{Mup_yj3N^*ut+M#9;APpW#!ahPMbI~t-0iy&w
zC~DBwCL2qx`N|6}D3d6yGBPZaWRg$VwJcs;?fa*e{gcIG12(}UfY#`D8B}F9Ha1HY
z5L{|DPsejEFHV7T9?a&aRhdIr-ZWk>Jmd;?2s~l|`x|)_#gHWp%~Tmj&Ab7!O_#jy
zOyj=p`!GD~hbyc5!n1rj@8|9UMr9pia052&tm)iWee}GREuYSZr-zWhPy^mk)u6A9
z`iii%FeDoY5f=nuEFmRvJS`zQ$AyURm|25hLMXp)K_?`pPs3CQQDwiVsGkO-IB|(D
z#}KfCkV~s*bPn%bp&+v41crJshkt_K>w3*HvWQ&%Lv14t;K_Y}l>+Iw4p4$M1a$#_
zfdbrc%Y-jViT?U1Fr|t!U`1I4PG4^Z_YA!-O=km}-VAyzINyFNzOY8^2tZIiUcW$$
z97v*{&EQ(6yN|_=13w<nkTiowsw(Q(?HSy!rVa~-yiK9je{EQqUkCRDMnM=p<N`D(
z<W&)Se$ZFELACTxW*JLCmqytlM@1k2{-$Nazv4a--9H!JZlrIn1$GE%yC*U>nj)**
z-1Dz^e>hP!$+ux1GkHzTnk^clQO9i1Xm!!-HK?O0GkI9E6}W>#qts!PiTVCB=}OLw
zo6fn-@r@(2QTWCTI<$^9%3*l%0?#j9$e<PJGy*98aV8(5ZVq`ld=?)S^%%_Mqy6j#
zlJe~bPZho7{)Ex#%R0f%k?)^4RmV=w;&p1m&)!B3YFG{HDcVPHy*^VhMxYtuxGRh_
z&W>!rvZh{HpZvRr1SAnn%o{E{(}UqV=o`X#NQsk?h`V}Ns`9p%Y6%20Bi)<W#k(nl
z%)5J?ffvEu=bh177$`mbM6oR$a5)-0nMrxPvez+k#lSJI6^9qQKye<NtcR6qS-{u4
zj@k{|2)wP`S=!g!?Q=Kir->(9I-nQYiLn_$G$7K3>(%0<ysOX{Cw}UUA>-BVz0FWa
ze+|}a0HnY32OKsu^Re>_7J^a1old{^fv{QX-9DoM{_~cIy5@P)Fxj22c|>T!k7Y)<
z&XfoP9^P8Q5#B|@)nA6I7II-x`8+%RZhz`q({(&1Q1-k00iLdwQpV6fPFR0qf6E__
zm2<Lm;3Vuo@DN(LUgJI<R|Bk-M`viBZ&$AOtF?O)MvuYf2=hBUn~b5CkD@H0LlBHn
za~W(2vrM7b0^HCyi7NxsLD&c*W9sYZMA28_sZI4O9wo6WKc2bF?$KKP#qTgqo!%4{
zo{ZFwC{T+eYAo+lA^YUg4B#63=)p;<hg!BTJ;PUB6V^i!+-)WNPKj)u4z*rUikZqY
z#ls2t*tkt?%;9a-{%GX0IXu?x!2<}D3CG%Myw2hmwc=Z@72s$N@1%AIs10Z4*LM6J
zZINR8#ValAIhO}(1`MI8Y!71+1V{XpyDgl{KT)TmlapsQ)pjJuSgN!G_pAI0d9d4x
z!BlA$5Dy6pe=!v<SKG#_w>{9Zq^oU1+-EAlgo%Q5c>{7=t+6qc?wO=DS$7(PZ$i_N
zL8Lp05OC24(3!PO<t;>b5d!YSeXTh9&su?<jfUC`wcyV9f}obM1AEevH0&MWz&6P`
zh^cQOCw!Otf~o<V7B1nfXs)qwc7^Ozn2J>gZX5T{P|P#&Tm4>K`yt6jZeQqav9eXG
z^fm?#W9-I(7OPeWS+(q<PaCkO#H4+u81a6>S~;d=5%na$N)`drMKuK1Ml-dn;K|@R
zEaw}Z>>l}N`R(ll5PtDVzOTCEfR+WRhj`Wc<^p6Hs0}caVJlTOs5^8=4y-wR0O7;!
znV69HMZA`i?=2a|n`zi-G8gf{&;k9#nme5VlFbB`jG8jcE}$KiuDBRiJ*s7U7V#k4
zFm?m~oPtdmM~-M&1;%4lX@9e3jQcqq{Zy$k069Y$Zx{bF*>1%S-x=pt25;PIhSp=$
z<l-+uEZF3FVc;#%XZ0s=hat;?lxK|Ba2f;Ek1!jJ0xWPb_a1VfkAOOKoEhp~pfEsv
zb|~Sv1gAlVwRpoi(KZ=g7>RkqqeRGx-}Uc95Jc{T^RD)ZIe*(`1an)Opo(;;Q=RVr
z#pIjn*FFpZVlg&Rw>RwP#oWg!)|7Mkke0nz%)@IAglh&#P_?n~VlYIvDM%vBhxMbO
zxFQ3h-nZN<G4h5ygvWi!Im{fTD}ZjW*pvAecLifs4N-t^e#iv;AOJo*3h$hRQ}f2Z
z*vfBtJ*SSQf{zbs+2JMJr_u)KNQN-9%vOKP{ovyBNZ()Bj7#*5&?TI5KuQWMaU_cZ
zoge!AKd|t@3M?rH{~MN+*KF<*9_o~CDp*m0MWuSpep|x*y>f(U8i!-(2h0Sv9GRK8
zEai<IJdh~%tJJ03!|!ZQF`urZF`p1ZK_PYF-YxHzEPE;U^Ij!N#B8R2&aIvuq7{v^
z1ei&7F6DKyY5>2m_sZ%fcC;kg7@$XoB;_N(C=rCMDDg($skhjnQGn9*!Jtdx9Xcc<
z=rFc%f=aCGd=We<2@)=0s}c&BJoLheY8;e}1nVxwdH+B{mmFcM$9@>dmT^t_c$S6B
z_#n-q6fw@RpJJTy4)^q$mN_ivp*2#zD>LF{M#CR8(ZRh48YgVm7IsDA^m0Bxla?yl
z_|?)zG}`!SIS;Eb7soy3HU{>jHj?!pwIPftC+M8b5`Sk7)LQT~FhB%e=Yi_2e`(pk
z6}(A}5@l%?^`N#^V@DK^QPOiB$@z`on+Q4M@Cx2n?X?FCX(bQwTl}Mi`<hK2RP@4a
z?IJd|t2%49mi1s`10pJ*q&&llZUHd|C#x|dyVCe3hcw<R9$(Q^g`vWB757pvJEdj5
ztKdrVEd<=pSMgue$DpvaTFtYvN{3-QFiC^o*To5#qR8UlKxo=XP4u-x0r{rEW;-F=
z-4b<h0=*WLVTk9p&bywGjD8?tmeCN6ItxVsYNWva8Zb-s!?79sr55#PP&W32AgD?M
z(S)-j-sRgbBt-S<U%&vr<IR2h{~~Wq(kK7k%X!zVM&4CKC-)Ev*Br6Ljo2Ob$2ELH
zVqQB!hUUWnGr{zNDlxQhcRc7HSA~vLgzPo}PR{l}q!S9>(F2$jA=OyuMw!>Oe3So!
zB+*(EYE8ZhlMY#oW>Y_YBCEKLw+fAwi)>0WcUTccK5lLFIzCt(v{TEjuHzv?7PS}6
z)+dUTje2cCP=M(zZJWRvbQSw#!H(!eupsX0N^y`=s_d#TDqMl!g^VTg`q+RBq2uCe
z(JK?%Nc*054ScgzYtuge$FRc~K25k11RRg#B5czxE&KI*ey094%oSNT<Y0ipf&Gp=
ztjR;nAkHH>#k7yJ;`O{q=ygb{seodtT-e7_xE=~C8fj6~2Hx1Vah<`mk9~z*#~L^B
z0O|!oW+HeXv6qv^&`)4+vXsEIuG+}oL=9{qFxIS>8O!_Nk!$cq=WXSz8kVe8XCZfO
z;$fW;S|~a1y#awykAp;T7+8qYo($Kdf>C7L(w87VDetKP4+oZz6JrSi<<Um4KA9Hp
zJXFDf8PS&6yowEBGk=|xEO&Xhrx_Z5s2>8FXgO=0B};`YXGep|5F`U|KBH-}c<ir4
zKMD`7D*!gcg0Kb<p8ePzk#7y4vkYJ}y;pmJkT^7MbkOc(fl#rG%bv(t*wo7(S?q+7
zNW|3gx~G+$k266@;t)f78(Rpm_Nnct^>nmrnr`8=O80PofkKk^fzBkS{e*78<`Ynu
zWo_l2RXZsh9k#ZGo3(7sRvs1Ny@8rEBG_e$5Fi4u5o83C=oPa9<#F`|CEsl2bt6u$
zC(=j8<d6yoki3b$O7!!R2$V_J$_=q7bsHaG>%I@p2#AAK`U>rk1O9?yEjupp2HtJy
zOsQ!IrFDkVNAv#!1_@f?U(WO>3gJ9T<!*BxIp1Nr6-Nn&ty=c!4}4p*?l`tD4ada{
z<WUp#&fz;nz87HVgBcIPQZj0GA3=TGrPW-uq^*S**JTIX1#bPUWfOPspl-onXTlT$
z3zG8M+yyUqupvHcMXRjDT2JY$&_VwLG6@Axprv*4Y&>mAD7X$TX4L$Gzhpb%`#NeI
zPhxU=D7%o$kKA8#M5et&S_!fT2^`{Ciyv_>?#(7Gn}9Omhp=pbSS&ZO-5&s*IKbxa
zf<e+sUc3yh6>9Xz4*bY#w!2<Sc5ZlptX~tn0a}&wJpfjLy%GP&URO~$cW(q}EmSC2
zXctrpr}h@KKzorpdCkZpRLi;5vEIkT`6%2cx+^_gGF*4I3WzBro$Q_5qtfoBXrTtR
zuzV++1(SOSXOB8gAE4$C{T)a^mU<Ttbx0z5s<=kWqIU6yD*YBVbQceINTk%&-)Y&R
zUA%GRlQ4NecK};yb1|U%-Nb-Ay2}HqsthO@4ZYt5!}5}_SuC`O*9_US8YSejN{fre
zh<KWvZqO=l1^oi#m?B<F(@nIjxrLUMiTLb<mTfKKjfX$lk4AFjOXgT>3h|8r@f(id
zn+PuX6h01#%grQ*tvij+J+w6P%Y_$PPAy@HeAApD$O1WkgnyR0n|F)Yc7lqT8NYI=
z?=AGkyo*T%Q(+B|@7y)R5zWQjJk-74N%V&pII;l(W|;4_tkND_u`942@Lsm~V0(&d
z{8Vg7Pd=gMArx#qhH7n4O}t>I1c@_-UICk+9Syq}{gFiuZ>x4jJreEAF|{)U?FiGN
z>5@~1PBd!lp~**EhDbz&_*pC}a{(W@fMz)5(;=xTM}C>`=QtAE#U-mGDuMeY8_|Mg
zFALhsTj5fG=P(;KY%iQWuB_FvZ};*xS(yTNVmqck@-Xa+{<he?*8VP_@6!dNl<i)&
zkR{5)AEb01hSum-;7lyRe*rnYsToM)aT&<|15xm!IfcEo?X#&QzAWiXh<$g=desaq
z6dqh)N@JUNBlrFu1S!LRP|;HC72-#`efU9}Jvax>Ko0NYM+08$5ox%*W4dWzrRQS@
z-p`A?{ZYm&AXuORQyqN(Awn9uv9AyCPt`YpyH^KzqU>-Ke-O5{yQ{Qp&OzRz^5<Zg
zii+~=AkR_XJ*+MI;t+SU4S28uP7~Q#Q8vyq;0JCrWC2uVX`Ei6W#1p>A7U@I1CZc2
zK|<~mt`%g8R)O&tOcYRn<z_en>O7uI3-SpT<n<%)<LV4m%l;@2@{KWLIh2Zm6lMV1
zio|!6x3*$IFsHnnUQ_kOlA_&5apl<V6GsFdx_ONEQ15}T8he~aI5!Y$pM*!bg*)4N
z1$Y!h)+vGPTo5^}zBf2!=<RQcjLc2y^#WHEYTgz(lcM4D<H~yl`87xa6c52xTi}NX
zoP*VfXJNVkA<X5)2u<DT98AP~rYs_NjY1L-q(2n>Zy9;?&pfQ^kVHZi?4LNq0OL8#
zdwFOoqE8UU2xJ}HDt54MA^x5JnJ0N~#YSrBLQu&PBpEgf**s~=zq3C>5=jbsqh#x?
zc&mxx3zz7<;NVVKE0KjGK`7>yg;scu-wfGa52mWbyo=(|$e5fqn5fVLSo9W}at<^(
z7et^9);eNh7ZrAA;aspS0wF^o(+c;9Gj+lH7r7uB8#V(Lb*_1e`r#HW3q0A>SA7yc
z=(sj~3-<GmM)xg}NWLnKv^Flr7xNJwqmhK$FyO5gc*Fs<>%+~a1M2(*@-F<WnAdc^
zod95FoX$uAa{oxsve1jXecD>^8Dauu7CP206eu%HLy};T@>RLYJO6_jjI3iO(?5Qc
z$&{9@6-31s`G|&h2tArJd#!U4bFv(4GAhxwUK#}<#%dwUG&=ecmSpJ;ZPCF?e50*<
z+z)6UVvuPkYCR8<%dh-Y>mTBfftNw!j^Kw;a|~1tB~NCfZMH)sswYIExUnL8EoGB5
z^fDgUmL;Ua>$Gg<Wv&ZqUt|`7Qj=@ZOI7-}u(-jeD;9Q(A}zan8T+gqemGv?@r^Eq
znMdCdlunCu+b-)d3WEdOf1rmI=iF1%aX?KhsOeYuldPlo1u&*G0~oT&qdph}hH+8O
zu%nEYg8sebjQ4Uz1Im!&IM^VA?!m@YM4D04iG=8axO-xtt?)q(Ply;<0a!D3A>Raj
zY)zU8((j&L<!$V`gnHW)X|HjWt$NyQEo*k2SL^ayhyd(OQ!`+YFl-F<tjIxx2{nd>
z5P28Gd7=@Fq$5?3;qpZVI!zE;SsCbi<8>ZVBPGO)uAf2IgswU}tkDG){p>n#=wgGG
zXb;1AjlEwJFtdg?_(GN41$O2Jm+ZoVfx;;_`GUkPc^G1T+n~gPM5u*-tDJL&5l^0K
zlBqKwo0o1x5+x{HdIIW{x)Vhxf_KU$ZBdWk_(9t&zaTM=Mvct_pS?nBLxN5Ql!H>b
zu7%P56(~x%no1?-hv3w0AW9mhQrSc*`;T1qj9m6yBXf&7Du>t9TZP2a2w`-vZ?1*W
z0lzCo;bUAQEn9Y*`$n9bgM!{T*|cj2WMDT*HCqwxts?9yLjQ^NT6XU?&uG_iJt|zm
zGc`h{Fu!;FRKGO<XjcYXiwZ%@$ivK;xn1;Mr9DAs=5MyD1m{apKWN#767K1Eb%x9j
zPSNy~@D*X6-xFn#q@v)|Uz9K!W-BxP8f0nM$fWB$z(2{~Jn27CGA6wyCSTcyp51{I
zLwZ8cU0%zpMhx&IFUe=$VvMGPkhHsem{%7+qTD#}HVb#5ns@HvP<Q}j;Ig}1tG541
z%XIhPYrP4+)+6un;BF76L4YiQdnEps&c--f!8Gkbn+^=H5C<R5g%z|_NF5RGILf&e
z34f5C#q<Q_^&uC8KLEH0E2<o+P6v;Fc#jWJ4_vKf9q#jhu9eVuD`=0#%Xv@nr*-aw
z%$l^feCuOARsB6%hT}H=Q`S@^3!t4<l7=J6GPpu^_&(RE=C5P_+~<Ls)6+o*IL!;p
zJCbu(jrEr6jdc+9fZtIiUu13%d0hPh`zCkQrj-+ye^y9*snJ9~;-vHSaw44U3C=Y#
zkCP?Uc%H4cL+Dv=2E1GC+;G>cz_jehLmuw=3*1A1r_y&q&lF<+28c<<hdj9dnnnMr
zSBNA~f&PvcO}kK%9rP`gv+;c(93+|uw5ohIz7s`(5L!F+LD@th^HC7gmi;@_qqpnW
zuHSh|g@VY3!?DLYKEmyp8W&iTN4%ca*~J@U)AX(fIMM~H496aW#spy|=DmbcJeB&q
zUFwP@uk>QK5<34QxVK-0#8&)>`_!!eB?^%kqEB=XVyHgIlc=pSCf+h3%ta5!yEEBZ
z)>@AcS#hZSnVt_-FPp1nzv%fu^`r4x*0>bDK1=Z<x0FZ5I!*@BWf3!wdExzK_}(Lb
zD~m@z2}y3mkmMqVmucCfQXbyv8<aIXBAp!MD7z^8D6-OvFOc<b{o$s&d9C%J%E09A
z@2u95fPdmt1^&lN75GCSa|-wwj;I9u?eRmvzYmD9hJV45f5E?)idexvdI`Lm{sjE3
zQTBhp|6Rs^!k_PIhTnlI1O9YSgqaWUKXDr`dlvZ8pS-C$2|ubn<_+rIT#VVn%7~Pe
zwzx5_L={#1!a)iJ_A_b`0o*$%UpomKr)8rb^WZMECjjhD7NSsr;TQ@P3VDqd4M(wi
z$}g|sYWyPvk{E~0fFfytw^q%dm+gpT&rnfM92J469zMo>Dt8y6oDbmhaCgC9#keTz
zJL0a&b1XN&n^{5DZix4jo|-L)xk^Ns0DB>zC$?|8FVk==tzGky^1mwxM!(LPdYg-W
z6gma{Dq2F}6CPXHih70Ac&93rKLbW!m6Q6EYb%=EatfbvzgAH_WTQA(A>LSl^IL(Y
z*AZeT$t0?e1yKR^YEbm8UtoDx73Z<!jZQDHKx2FMlqWbFs+8wxJftA3LP2ECK&<6k
zAq5F)PsknBLkns<mFCmZHR`pf!McYQgsN?@6r7)Pzt#h~6F8>rCWok}q_A{p?{dy*
zFwO=gUeqTxX&dgm@bEF5>$eRGv9&yf&PG4Swg$ptE1z?p?gjR)CuQ|G2*^KmNHEJU
zLJ8~g1%!DD!bJ>Z2w6f)dAJ${z~4fh2#?M%`B?BMi>)p%aBSWJe$nLivZVspNxpx6
z2gF}}K^OY%J9LCo&kOMN4X*6_7yN<hk{dI=;TpF3C68CV_h9#5@|q~OF&RDsvB~am
zfyMzz)9Hv=_lo-?qn9aT^eaBU%6H#r(NRWktQ1&3oL`GRrngt>CcegnuYe)YNM7T-
zv#y5m*Ia`(9wXk&_M&wj?DlJZ#q$}ogc*ku3;KklI_F*&Y;-G><1>HpwyNQd%>4}y
z^_)EelLNzFR5p%pY%={Js!%LX0pWl*FeIj6u4cW#ZvJSXmhFDSTdVq4rGbU1w}H>p
zddq!1dJH7w;>rT}aUKrC?&@QmS&z58DWZxG^|WE%zU7Ho_j9l=kHXg#d-7;pTEJhr
zF&IVuLj`e}@K?vu{whGMk&5_7PG6KsYw<z>>Q<xB^aXK;?Y)tw`Pm;^gO3=~FcQq@
zqC8fvQPTh$RjC`w;-xQe`G&To{`lZowpfjJLV0zg5)S|g7ilo{qFh4W@r3MGwxxf{
z-nj7kCk}rDo1<Jx)GVen`9<I5sFMpq_zdOo{EeM$X&Qb(nOD;1qo$lbOSHjC{^pfD
zW>W)3Xdb4nyFf$v=Wn=9#^Q(fJMQ1NCI)8IT*E>(be2nDwBL%vmk=imapF#k=ShqP
zqX#PX3pC-fJs6!OHEyk)z|&Jd;HingQwV5n!8@K^WjlnL=$nQyM$J>`T0!q&jIL9W
zb$-vo9NQzy;Dtj6WaPf*O{#0a25IqjRnfX=j<xggy14Tmm*+=djpIB$KNOEN7TNv7
zJKCyS^wzSjA9!H*Oj`lTG;i~a1*}CcutVLRMf0p_<U>Q=I7O_>f|xxhzc(HrAA%x}
zjNM>@u%DwWh4Gm<n7%Rw!wCC<2WdKqPhZG-7Ptx*mGNfoQ@@6A7ljr?91x?%b3Uo#
zypelD%Gf{|#8VNy8e?5r##^|TK!rGzYRMRnjAv!MVb+Ft@@_kviCde;vytB$@=x5P
zY6Qq-;79h#qplEve<Z*RmK~I+54@j7Das`lY8<hmN5~_Mn`x{@<KO57%mj+8nm_{W
z1vmpb28uS+#0|)T&*U_$uvGnR_?wXjLpLl5rQq-?vS`z#49|pW;*eoM1qA6-oEnP_
z6m7adLg`UXAxDIp_`iO#rI?)do8ooMzh!fuS{)#U;Dphr@monhN^%cp-u|hrovq=T
zb<1@2oa(T>zI{RDgsL{*%-o);emqGwl6>=IyKj|!5P(QO(O3SEV`QF{w#Q~22ALQ`
zTXeSuQ8_NshhT?+3w`5*gf{v5LXHy6Cjl)9dC58#TQice=JgZ*$*~fzt-_m-`6Iu7
zwdDL!K}kkD^U2QIZue9zwPE*dw@0bBPgET3YN@tYt3qoeDeq6i?@9S>Tv*j#(!G59
zPn2n2dQXV`7Gz^lr3#(Iz!RNpSog}?JE`}7shEcjRo?DbB@eQb82Yt$7`ndl_J($a
zATAc~6d%owRM{S_zBfVX+@b3BrhbJJ<eu*QO+ArAvIWtLT(-x$#^!=Vh+Lr^8a2iF
z@OpOHo}-@LRm;w~Y>#pM4BS=FxyZLezPs!8eJ$opB}x<2D0HH!_!d+%f;3ce<82D=
zMEl;aZ>Z;kUs?AoAAzX0FIR_w_XnxB$M)LhLJge6StabA*sd)uxS`+@xG+2$#O?!g
z$qX@L!Z}xLu|ZI!kw??@-CxudZ9JAiLMh<t?W5JpI%`=CyX|#7hr_s>HzLHLLz9Lf
znN`K8Y%*{@X1CqnsWI}Bj6ZcC-%2*mwY@v*b!xJ+GgeZHGj##jz8?!U=l@uH?|>+e
z=YO2zITQ;X3P+KSAQli%@eUOQ6+INJvG*FgsGuemP_UerGsLKys-$X6Vtn>V#1su`
zRN^}^XcA+MXrhAHHTHPl*X(l#2j=tp>&G9*K3ivJXJ=+-XLq%-_kf{59C}PFY$h(%
zpsv2~54GO~3DxaWS8EW?1JDjm4Puex%tOYnPGrs9<i*-2ICj83a+AaA1w(t>OLLzU
z)R+A{|AjiIUMda4Yxz}I_P|ZfmO_EQIdzb`A<AW7!}ki??j{H3#3HvS{Ea7S0C1Rc
zh$1Y_yh~6H!Qv2<PvFn6n>7cCgd`+5ga4n<gPAxpy753c*qAQAR5W(r8!wt_VmQ&)
zCH<(WF|41P+>&M1m4iKp%ysHZN`))iTvwj0%^e3q&Ya)RP%pE}1;x$=-f&gffJdei
z8#prutr8n(b=%Gcv}Hgm+o_S`wE?)9o?X(&v95ERCZm>KSYfHIa#+*Z>coh>McD91
zx#y-}2~aPlVCUJ+Q?MRNie`u1bWA}{P(RB(xMOl_uw;kdk>mcLEIeF7XnqH8I9DT<
z=&}Le{1&eFV!XTm3Fcj6$f~w1Y?1qshS9QX+-bI-vb-~_Ulaq$RP!j*;WYL+wJXAn
zo`|Bc|L!{V_G2gusyPJ?A{uZ`i|{W7+Z{x_`6l?0*-xAYLGCQc{7`s8>?shgF2m~r
zOkx-|{r!TPq=IKHEnUrQQWLppc%zI&m%N9zEG?bK#>Nop#J%PF%0f+fC9dQ&i3>TJ
z$id-9(`)4G^&k1lkZ<6+n)&KJpAT(YHsuPyUK&-S($nCO&W)>mXSce3`c`u_Y>RB$
z+qo~c$oG3We=|>SIZ`@27OP!vF!;}CMcHMmp5=PWT|6$2AZ_?19kw?S|37cp5Zq({
zxYY^AGSn7%5ztqUy;@t*m_%mM%Ppk9-id6!UT!PR0TU3_?$OIBEqg*^f<I57`KEYs
z2O0p-O%6Wh8CvyRc4auuHLg<2M35i;Z<uN7aUQyvn(k|?ZdCBxaXxaCE4G=<K5~pS
z21UR2k>^TR`zEp&UpYLdz)7Ur^bAB(>y^<O=|eGT{=d?<LK@dfA7t^hbcsK+m-H{%
z;abvNbjb}sk33)t*QbJ!Sp4vK56I+yt|GQp4+_56)O(1lTCA>k%-av-^&@z0^$3fV
z=9B_w;<c_7#G9h2BHlxwpxSl&$q~{vXmdq=a=6qf9|z?9<lvq*vncyNm#VTxl!c;p
zSxw;82_Z-jYi=418gvp1D=uT=!(s2^O)*ke*m*Mj<@VC<<V3dBU+(8KdlIU3GNnNZ
zkAw~yxOG#0+HVtUreW^xLsaGF$~Ho4fjJC*jUFb;U^xBIIgDEQQP*pf-@sy@?a+5y
zP%9bLO+*wi2IcQO^}zi3@~P^Ar@RnR@X>`7szwtF-La`niyPAuaY5$&tX8m>;lfFq
z{yJEq(}M@75GQ38B(eoNHpTf@mv*`(Ap4S^{g!~q6zYmw0&2QQj+@pm!*x6kuT1L~
zNdIZSYvkDR&iD{gEgeyUyI!oxUHhBNcwLutnkEov!@<F-lvP++hCfG{j0mgu`XoV*
z)r2)1H2xf6k(1o_E-vn1fy0N10u9aG!RX95#6)zgZ<dqD<X&I;OL!`rc?Qcbrp1gA
z`RbdCP3G>N@x_$O45?9F_s9c#>Bw5;`_=fODXUt6=(<^SWe!+Iaj@LlO*I_!|8!HJ
z^bjhUE<}!O<=$B|(FE)P&WG?N_ytnBhb4}b`XAIF(a6_5QOBp7!dY&J>{eq>_*Qe-
z)PSTvTu**J582i|N{(r0jhP-Mme7AaGO{I6a&xKe^u(f%qU2^8|7hs3mFux7Gnpv;
z09nHT<x%jn3oT?OErIH~xTXApWX0y;@s?2IS4_k%Vk_{Tj<c|aYXx=n1m=OcmAp0Z
zrwM8uuZucnn^5yn5&U#vVo`c)*;4~E!~&eL9Um<RY5%;w+QwEy%Pl4N39}v1a+k*L
zSX)$lErczAcnpK&ztQqG|9;u1X(O(zhIWBTQ~A0eo7<__C5(}E8tvF?sOeZ6d61L~
z>_)}P8Pb~eiA4)z<wA|LvTY)38ZU2=K1fVt-^I(bq_+npvgo$5UtHWxBl_GU!bCS|
zo4|;{^2H7oZWn<5Qt_JD(9z$%VFa1{Iv|l{wUwjeA_l2EA?vq18~o-_!(mgNy3lr^
zw?^D>-X6Z3Huv&@$N{cVmL|tHd>dV(QIQbGf_lqg4Xp{E;lMib&$?k`y?e_q`zJ#i
zs@w#xGe{#E3*eD>P}f9uuD5)z;oBXk3e}g6%}JN_>`os!$jcg8xy2Rr#N<!K_Pr%2
zqeCJKPnQ=<uU<2<!gP6k;AwDillfrfJ7O@FV1iVh6v3}&CbGU6@|$i}k0&@9c`ZZ!
zL;J}^AoFlvIdtN=<6;H6qr&L2cc~D{i(f!R*h%pu!^;lTTJaGEOT^d>+cIFRxB<Kg
z(9eL&RLl|MiH`hCU#ICX16CK~U=9I~?A=f9-1}%B!n=TIKIL%}7FtliWcrFiZI#+8
zOk)d2MRN-rEf;8h@o1joq&F+=Cx?YvV;<q;Hq5{rBqkoM#Fm=Rjn#NWNPiRmSmXY3
zSskms9)%zDmz(*&p9mIY)t^CrWW5J^Lg}SMR_zAJ10@4UXUzaPd8+n`5v=NpxHmjE
z4ah(xA`0uIL%0!0jcTsuvgt>w-_I^nDRANpe2aOn+tsVZp<XRqJ8S4+Ew_WXL4~>k
zohl!QhSFO4;Y9z)K~xVcbg;w*)hYEuI3W~K@J_t*3k{9OHY4^)|J=FCzvadr07kr+
zJ*I}jfZ^(Di+mNS4pVPv;acy&ZnV_C3r*J+8HBDo^D8Ld8(!Au90trLb3?dbCp?-(
z!qa0o+DwNn*i)>(Q+C73Nwg2m6r`<MhOG&5J-v&4y#jC9Z=z8*u8X0|Fz8NEaq`XT
z_Bzgdi`z8F<JnVvR@7wMZ?Xms1Q{<ys>#Ee(BY~Wg`7%^!oIQcq$YoWwlFN7hyYYy
zS0LUnPR?&)2J1rn%gB%TW)%PPIQa!l9~M4dzAhzz%$iJ)yM&JVo91zsRCSVzW#2St
zF(ltLC3!fYR5n3Ql=?uE3Y;i+iqZEa5oy!qH-R)Y|8CQJV`-VPHyPa)Kj~%|hsCgd
zFdPQ4iQtwpI7{#(+0bj~6yj8eGtAe>G}P>SDkNMeaa0H@Mdj2K5k)6O>L61FN!z>q
zu_6nl+Evxu0wwRANpcryV0$otNpf1#F*L}4cE>?yK`FGt%opY0Zq3znv70Ie39ge(
z5LZ3CbW+iR(^qrh(LBJDMlZ54wjQ8Ct8}+%&h`(b-Dq#?obBDEmraT6`kd|aV5)tR
zScgr@+&<s`T$xdQj|UG%lTRp)jl~ji;a2Mz@-fZWU(XS(ABAgA7XYhyXiD5?()EJV
zll~Y|h*we~IY1!lhRA$gL`_$t4yaM0ilK<AhFwgYqU2ffN=?qO--YGgbQY|MP)3gx
zP>o3^)r5uB3HL}SS@j8s!4*>ATX_(&$hl6<N%8h7jvy!KXb@t6WxTo&e;gWna!nY-
zTAKBkBZoDJ`++7zWak5Zxa4|{+(~1X={qy!rcICRrx}XF>?ylJK0wJc@hI+$VTnb5
zXUbWc29r(!AT)5Tb0V8KPtMSvJxQ1Y<GgP&A4xaghT?{#gY)Fu&Ko+VM`!&gEgqG~
z8kQ~_>6(OFcz&5RMfwW%)Cr}tM&>;Dy=r*Sq)l&&s0lt6h$;=}cGUw`ii-iI#rp{G
z;js_FiS1uCY2X$Fx`=6N=T%U{1ktF>;BTD81d@84AS7M*2AA5>pu)K0OZu3Wh;h>!
z!;;!DOjgM1YFZRBdpS*E=&HwxFyCsQ-eZLe<emX_&;xiZW%tHQeN*=0;4+~P?B~XB
zMy6RP-<FyrB(i@NLKFEObZS~88$Hi{MQZLLqI6ZODp({BmE3+cvRg070ot7Jpq|!y
zNlun#WF)fmm!NShJZ@x*UXs&Yr>3$)FUe7o?U+6D%ikii?qzwD^d98s?3d+OsUOk`
zUzYo5{oBJvuunVQm(^J;C;A?2M}!1vNSjCF#PD7WbL5z{SPt}>4^itpr5mJTN-vgs
zHc*NPiwR%s2I*X1EH}_d4WXtySt6%Mi_#KV*QN3?>0TQc>Xyk1(igXZ6#NKsQ?(q2
z0v~wcJ{WAIF@|u~&kn-=72H;=T&j^S)c8&)Pi({T1yqmUm&x;`?_v^JpBy=b=x1Gy
z+%5T)9fZLJ02fa^<JXk8EYu~-3k>@ZxC9Ieodj!vW^6iK7wx0IhfZ<^8gj1OGURS&
zO2Eb@E-4eYXIS;uCt{+SFW^bOZa62DD|c>adx8hnDCRsg%EDZEV9xq4{ah*&@J0?^
zp4V;I@4i1v2MUY$pE^G}6ZCn{G(?4Yr67&_AcnCh0#EHnCh%YY2(O`Z>m>NFn<FA{
zn7kgY{Y)1ILQ9tnbt5xLZB?CLHob2O>?8YjYVv=~9?Rw~m(!c9m>>XkWY`Iv_Lt>y
zu-DKdMCf2yLt-4{wQGg^jz(K9gHQ_d<iM!R5}LTbV1tY1^NQ9W{Jh7wZt}P(?>HpL
zalrc#W&SHq?l)l|LSGX}SEi(hE*Gbu&#CVFGt9TL^yv4g!_**IQK`1dR#e+V)V9x*
zcMP=^BTFOHk*4cWY)U+m?Ss`@8Xez8`_Mq{Vq`bu%WUv)fJ>W^*mA{&QpIResjP02
zsGMA?@uCc5QA@$`t{<W%Q3p8Be!+SELIQZY(-5l@tMH#seRD)^9gfr1p1|;#)a|Of
zuMCbV9#a9M$<iLGi^o?~z|z^>7Wu(oXKqyBoZncTe`Qtv`8D&a_s$jhtdhMnzU{UW
z$p(R;IEx6lrCQ}Q=|D$ZW@wdTLfQchSz(~xc*ySW2=C&NFflKFF=D1Q?AD&0waNy6
zYY_XBcF}W@#|0-sw6Oqv5ujqx>*OS8$S?h5WV6@F5slwRT{Q3Ggf;my7dV!zlNSul
zJkki!`X3IUx5N<ej5Y?Zdix%BI&g=|V4Rj9#z7wQ^nx*jsF7+j5d-NTN)z?R52<Sk
za*>TK^Hq7K;H#|vvNZ4L08-ix^rYYGjcawj_JFW5uhn{%P#|}0JPgyQy6bnqLsu5a
zsk#$8h!M?1U#yWQ&bY8s1#;gItJ}9f(vU&(toRZ*>tVi~cVP+KLaq8S$j^GdCcmh?
z`#D1LYjPVY!2{lCugOWFLBx}=ON<@kc*wCkcy6262FN!%5cd#j*z&8x{MgX-auZ1b
z05jLiof=y)K-B$AA+Fd{Bip@RUfC)AkU(bP_bM{ua8FHhLZ*-g0`H@tw-6GE0b`*Y
zh^8^lTVrvO<aIgJZ$lyBa2a$HXYxpfcKf>Q6WX^yqD$ui*#pw7tH4ZcrX&r1=M9E2
z%IdNAGj!}S>X3HrHL`je<miAodmTJhA5^nK>~d|8)3kM|%)1-pmfF*wB6MVfJYJhk
zq1cTuLmjA>$X?heCkL%*i#~Yvh#05yOpnMU?@C;2DG=2h%uwDadrLzh2TC@|EhC)4
zCaIlw=o#2xm~QpkpiitBI&FpQ&~K7cG}_G+9KmG2y4nd_5L~cX{!pXsyBX~V7s_L_
zCWMM|3*{w}HsUQmmt7yqb&!luQT>l(b3jnNm3}U`QTZ2W0wvI(SFHA<Tb0+DG`BFx
z+0J75Zz=bjk+FRcPfxuQ*_nNE^N?EbJ;y5gfA)f}e*uQi{9mks_1`ZC<oGv&`6S1^
z+@BWOq#EL(tJ6?gHHfd$NmcU+PBN_kSU5C*`xf#4JdT#>hyoC(?@CnWI5YrGhE9Bg
z+~1H*&KBA1SECaV6qx8ajCypck6qm_dsH9U-*iBZNH0BZbiuh`I3Wz6n*uJshDNP!
z-gH&v${$U-Q~-$wxenPPw<05*NxJe1<<RH84n493wWl8qvx3Sl%MNsI=X%q~^gnb?
zb;T<G70a;pIhjP551vt;T;!+f<55S|r3Uy8bN;S9scV1N#(eE>^%8`>>E7xk2;;$a
z=~jfQi2vWecO8_q8tt03pfC4BvYSTudU_s)CYFRjDT+NTTQyOh_kl0s#~Gv<10%5{
zXlVngH)7*|1WF^V$o*G|oS<p(9qtr7BsHj505Mk00@mGf9$2vsN<JbFu3-@?JR<w%
z99xDln%HoyNpsA00r+)o*hJk$2K#X9Vg~Z*rWX3xOdoVmnLY+Mrwmzxl!o?{f9OMR
z|7b-YP3#|cFnPZ5v40Hi=}oKQ9JRU#N}?k#RJVaX>e)Yn)qHBoa!T>Cr@XcbAEa?n
znLkoRb?Qe5Wec*W9C9vmn94XH)!-wiDqmwtBAuP8n@b-KxNp#h0}IPfG*%aRl<gk4
zLsiNm%H{xj61D0;RxxFRw}GhoB7M+Ar3z-|(3hjtQ}p3xPZ~uZw39&jZhAP4%2nqN
zKg#AnNmFXof%|s|9>>Qkl+Dp`V>NzoHtY%Ia{yG4j}He@b0{A<3lRwZ&NU>^hoi5A
z$Epg(_i!4BEJ`6`2vrbIWgIx|LRI6)WR6IhMqdu-ZW0KNy1P+|19eGM13A=Db-~Wn
zeMt>Du#iV7j@r7@hhy-<k*zWeg{uZ3fvTEGr5)6Fl|DkK5!%KZWLkc$7$4B|;eh2%
z94T?7kzM{-4$&S$PIk<9h%XC0Dql%Eh?XEDZ{$JcwYtUTW6p|WmQ)vx`5gvVtM*qk
z((4t_XKqa*mUsHD^K51Pf5Fl!W}lI*_(kq0-6}S+?|;DtT?qnLev#v<*)j_)m1l=_
z0m9Jmiz`IK+whMX*4bTS9v(CneNiem(d5(;OVCGAYRF1tw`lj7Y`F9`In-8GC0vLX
z?$QZj055;M6pc)5h&Avd!6(iMk)!ha(+8+YH<ChPv>kF_KjL+}`g@x49((HYat;w5
zZN-k%kJM7-zt|^~Bi^dUucq4IdH~d`tz@h5OA+sgnxIAvubs8G8vk02s&gQj+Nuc&
zRDdR$qoSr1Zvmv1WSoUk+pDAI)z{8@W51AY9;;}C@uDITS3CxB_Rr3PNG!KMEzD@6
z#+vZka=#oRiwSvD$jLYmR&0cEz%K99A=$eGJ*;}V!Rq!`9sA^WKsE~y0N<6h;|Htp
z2WrPBiTH_bO6`P5wSc8|ya(b*fM*aSR{hZxRRa9LpU#~us4Y-g@~&K8|7Fz2|5j~&
zlY=MtJSDQ|1wA4YdW6S2xztF~k)KJAD25*K2=><}DgYlW765dv2EZQxh{KY}*q+lB
z)t!PBE*|w9@d#~_)27EjRL4qxlkq5%TS-$l_TV?Uc~1IDtgK<64aLPLm}}68l1J8n
zy~bdb=aA;__Wp9@biS&r@m{B~a_C-1kePHZVp2lo3iy|borj+l?V$+WD}tzjM$ek?
z39<`LWsB^Np|75kINtEPyd&r6OQ_DO-;!H}@*Xg{RcEU{DSCt?cMYWvNK=(Q?8?+u
z`aVZ)d%MlPcdpQm%)G~LxPv~AT|Xg@(53<i*5?m7DS89+2vW;KNiD}|5ZJisK{uPe
z^%Y|c`^^F9a9{o*cc`--$_iZ{m$b;=KpZY)6mhtEm1xspN)<Op;QbPDqnRyIU$6GU
zA^D^nsci<1!={~-??jAu!`fiuep4s6qB2yzu{eK!b{lLN;z|S91F_YJB^kS5?dHeW
zDS1e<t|O?$mK9Dd)>aHz!Asjp{O<h)B$J30SX&1Wg_c#1c|Q0gR*G-z!rp&*TUz7s
zl#L9}LK%B<)yST{yloUDXIs7MFbykL(qBbHVfuxOQ3+OgF#aw%2MnpT|A~vf|HPMC
z32cws@I^jghlPa4k{cEhn|?bihiIex@la<Yw%yT>u5O6mg+5`Y>_=o^L(j@_{(BS}
za~wdwm1Z8|4$oOnO=XEt_X^L-CU*zM*{!p3p!VS+XpNrd<kqg*9~S_*UC%>`eN3SV
z=dnI}i9)ZQms@BvDD>@l3_=8j{yr~<YoBE!RKHA4jsFUv+|G?%boryn3l5JiE=1pm
z4eq5M_yCtW6ByP>xn;6`hHZgSmBhp>uhyVJ$6QKBYedo{<HeYqxlP@}T)K)es7=y`
zdO&iJ1DGvR`pUUQoNWGSly@|!0(O;u==bLuQw?(cIf6*OAg|T-p*|kHAo~S0`qBs+
z?K4c+aKzbP%>^9y6_{Et%Avv5n3jXwPz|hebeoVEM?i`KC$msV*NgI6Jo_8(<)9Et
zCzAzN^jh_a?%;Fkxq*q7jO^M)xmC`e+z7AeY+sbVJ>R*xgGewRG?%06POscSXYqJF
zi!eiyN-UDw@4=_lW3n0xD}aa%Mr<|fAhK{^dJ~!<Op`ul>O>fBK-`J~O)nr&YsvUB
zK@})a-3}mC*NI#9{*n^{{{Wj1>aM9J_Nv-zu_TA^!#1VQA4V4Tx9kIE{OJNC>-@Lu
z-}w9)f))493%f?eb|ahex18O2N0zW_9GOR{SrKsFTKyZ%60&4aRVlD~l8FcsfHm%%
zsn<WY+l1=%qxpUp(~WFGahE`>kLO|xh9Fcu19C6PowWrNUwlb6Xa`g1$t5|Y4%iX~
zkcD2ByJ@dxB6iAUIbS=0LN_kUF_EV-G5v)x|L|d~vCvc$SX?y<)Z)ok<eu6?b1=cy
zUXef7X!WyEzEg!9*Y>^HC{IfPlcW3}&;@Iirz<!7J~ZN;o!*$*?^ej+VM*<25@1nH
z9zdVc;G8_vJyb)UYx$@RAeU9h9i&Yk8;ks}%1<?Y>TWlx_EU9V#c?S8*L3sa@+b4L
z186>NvW)bsIDlDOtNDr<qiVjYJMNks<)mj8T$A+yIWq`|%jL0HS`k4y2~bviO*Z*O
zpb>E)5BUOD?y2JUEc813zeapuWOZ)JEt~9^huurdM9<1^t9nv!T@DS+ny!w#XZi8w
zq6IuzQguBJ4Q=W5=Yi5uAp$D=d7$EM$i4i(n(GYI-s&1z!40`h6GC#{56;frtn`N5
zPWt3M723xCW>!O+E6^^0{b8yD*gH}G32gCAd60HE3NznZ@(S&*-DzBJ$q~A02vo``
zy(PD(CR2gwelMz>8r$+eI(1u4^SwKphVwk;xj;1#X$S4L9OLz>@%cU#P(oL_;<Q$0
zJ@3fvT{k=WI_tmtI@!_J_XGa3uVr_ruPDq6cfm&gmyEt1yemgk9iqB*7a7uKB15lx
z@-pq=uE_A?J-L}M-WJ`uC(qGHsTD>x;XY8m@GWD}8~5cQ8fn)RBfI@T?iQRf&aYY}
zCfZ5w)GS+lp>+uI40wn+uR$KR@S)t+Rf%PvK9u8JUyEnw9)jVl8>_<aUj9xP9sy$i
zGS9Ky^mXo(&wddQg+G#;1@uBF&0J1ZR~&@Nt$L6O*tkdXJS`uC+D|-^^IYdgvyqSG
zP+h$-_FB`-C(8f!Vrw7ELtRHkvA-V6`$k2M2EbN*%4p1eT9?}N!FwT5EPdV6%zbgi
z?cwr6M);&Teec4z%8FD)@x&;wTv94+krUr?<`=l$B9ez`pQPgf;nYZeK%?~zg{smp
zieJ!<4M*s96ki~HzTe2Ex8U!(W<O%}TJmvKLy^q4gt)fD)v32KeciR~$v=clzb$zW
z$yi`4deD-e(?}(+8`--(w*<I0y~FOc=CM+}bw<`anzyb$a`b9jhGn*A<=3pB7uUyi
zwtrVl1y{i&h4IkS)Ed`<B_3L+Ibe%y|D`kRQwoYgJ$miaX#0!=<|nt|A)U#5EVQ4T
zx1Do}xly~a4{I=9C>F(Sc(8U1ZUtZ$+wePDlP|h|GM1ZN1MaYiaeTPCIZzyj&b2T*
zI=A~3d*|v`GHp8^X~-L*_Nn6g8l16q>sg;W1BkBdY{%m@+D~<8^iq31!y_7N=?u-K
z4D)QyigMOJm3tS>P2j(3x^7zoQn5*xd(JntfaUx4A-@Y5@_=*)T>T*Szf}Gm4;g;7
zeCa?SD$l^9<1-K<%vY=wT36D_-c+_|w^}tQD!RF|+DP722EJ5_2T@(vcq0#~69M^B
z;lbRy@-Vj5$WJ$D_5nm@3sUYIvvtWlywf2QRXOfpl^jtORvhdk84}kYbHp+PTbMmP
zE6$N!+L|;;l-RV($c}aA%^PogA4G1$?SxSLFEqnOc2Q_Y!ciY@;An6szQp6xWz{&k
zqT=XICw^ShwFTCA|A`~kgMf<P_kZK)-#);R)CD;D86knARVt3$L|Fq=7OEOJ`Yfat
zj>dK2In6(B2RD|3`Ndh`*q4hCFB`lMQ!9CIIo`H;|6OB|TUWkBBQ<-+$VPSN(P=-V
z5MX04ukE8o%06^?6<cl6s<D-3#k|k6dFoc=0&Nw;RouNG%CGvuj=Pnhe+TZ41(MTE
zTnb=27xx@&+iSsg91QdK6rQh<`n;*aR_|IDf^F5eM)q2FuGbFf2@GxT&V%bM5eYj!
zQycaF{Eg~HANdOoq$(Fho;`Rwjg**eEb5ucpMi!K{U77w+liWzi~jHNS=x<gxEBv^
zJrp4^J}cDmd9@>z-M6i3d^-3zxF8En<9_bnZ7_=Kj9GFTk5*@MW*QH61$Eyl?GVU5
zOXDHZvE@c~G>tEo1|g8%o5xEb%Z)|3z4<R1Y3Upz8<@_wtCFVdi9AsgRM8n?j!s;H
zoELhgC7#f&{1!t}`Ga7E<NlRTN?9|FtkW|&THm0(A2IU2?ZL>K2}b^813X2a$-&z7
zozSh#&*T!R=L{p8W|LQI&)Pg)itgFuN=;aX@wrBJ*c(wXyvdcX(O-=f)yKqDRe!p`
z$aZMK*5(>eeW{keD6M+Y$U3_5W-MLe8>FA67}+B?9_mpoqewaO)N-@_RE(%DuuWBU
zKZ0?K>c%BFs>_}%s{2mbHA$_hN;ZVn;g7X<u6aW99g@>j`vQd;4$W!ZI02z4sk$@!
zrs&S-jTCJfniHrMp{YZ2+DMg%dUI$_Z|#p1x-v9prM5qXGKb|vw~9k(N)O$cpk8X=
z;SZ?m>G?al%tN-jy3A5aoTKkZ`41t#PR%vvM?~k$j7Vmh;W@!t4@w?Xj}Oq6Tt#Tn
z@SITXmlXP`9#{N45JIKrFHA|%Wggg06?(i`fz%gA<iy8hA%v*&_b5JT7k#DZ=KL~6
zcfJHb9Q<&KF0;6Fif&F!Cn|DqL{6+kfd?aU;zlG;Ze8UuBzv4Hr|=wL;ru~Vb%r7z
zq1nni^c8az$#>Cy$yQYO;||1C&Wz}fJPE~W!5b)8L0Kbn5W$v@%!$$NrO?F&JW`vD
zP*H=1e6vQI7mdOC+=B;442V<(<c)Omer$Zt#7wbzL?F^+zF{)s>XO2l#-f`Z#6f4Y
zf>LPl2J`(h-QsGpbn{GWS)87DNVjUXU^pHfn^9e&qAgIHo#_WFpiQ3qyAJ*T7Cnr7
z_?P$}WB*QgcoE+~o?DKZ!DBW3M?~a01lS!<9;IzZp^Ob%no7vbrf=91t9>2SVDop&
zGT#)cu!rvVUxBVUM-h7J(FIXOu1)xxuG-fk(cdlJJS1#Pa21RPCX3FtM~twLVAFgj
zNcX%qe@8puJSxu7^CIp2W+>XxhX?r|46G{JYLavJiZXq8vL<#(`2U3;n~I-40aX?3
zoPdUW`6}srp^;7X<5*JqLjhdp$A6KoY%#KN{ya+BgTPvU9-uw%hqO=pc`NBue`C=J
zf8N2hVc|)EL62?t&-?=UTMZxoK{03CToF^WH;`}DY7hGX_`)!*XUoDc<qPbeflcBX
z6DVTW7sI}Pm=Q8Oocn2eQjV)(yq#7@p|Efsp}pdZP+B;T(<&5N8qWP&4e?aFasz%c
zLj@Y65hGmf9^;raqN>(j#o_!@ZM+UWn9~fSSO=k^x0>-G8qdxZE1VQzQYiYOIlo58
z>fVpHP9E)n?Ua7@wFm654e5A#L-IL-Ma*sS>+rc2{zouVz?CBuY_#cnsvQ<?3EwR-
zvibeEQJaHW*cbhH!YHfT<@L{(N$XHmCTa=UNp$(R_{3IW1~;xUpIH+;P>t<(O3grO
z<!q;<TMf}da)0hS=oCU~CSS?~?~)!7Ffgb9PyOWi#u*BbwFUscxmazSG#^=mmlCZB
zi>Tu5{dthnQaRMCpLgIGh_y(?Ouy$|a3)2;sRwZH^kK*Xg~LynmQ(|vsveH9Mdk~_
zPkPdT+V*JE5Cdm*tLs6-SbcA2Y#NPWE|35&iy9l6NXevSIkizRfJf;LV)cPGy1;>@
ze%dY@J2ZfI4C|)Wn%zLu+832O*Sf$2d(A+uZ?z6H2w;`}dC8duNI=$Dl!I@uaRa%(
zZ!^?qGS|hX5#7uDdp`n>5=+;A;+s~V(r80~&X$-g9m?}bgQ3$TwRlifx;S(Cd^)=|
zko)<5IS1kmHJ}REtNJcP?YQ&dMYivsE<V~9p;fWsAv~6yit5&cy*!Bfcm~39QQZ;<
zxo{8<h`bFR2peBkt2Fa(upiAfI-l|pRj-E0s%#Js@A6hMWgP=AI(XWtN<0prIks)+
z@Qo!I+guMd;--z~jEk9rd9p{338<sx^>j^Ty7?j7GH-huRymjlN}~rFS^XhACg-DR
zMwhHmT*x`g=ptP6tNYk3Tl6uzZsl>|Gpim<hbJ6l04^OI+12QRYdLh;scCSW^31@)
zH)$4}0=8Fx0|x#h1Su>?w<e8A-DR^=-AxFQ6x$zr#Q`n0YX~2cGp4Q|5#4Kb1$j(&
zN4w(I74;?D_0Xrq*=4nex;%hwZu>Zb?@U$;)l!OMt71v_I--e){<^S2oWFw64~Fqe
zAWMq<8L?Qvz`SOsV|c@}x<AkIV1+|@Y?DZ}u%nMXyBXPqp*+6X5g144Zkw4jDSyVu
z*22|<`9_v7jE6}Jl8kKlFdoq)7VH!AAO;67-~u_fJEp>`!+7(=J#M0}x7<Wuf2^bS
zRcF6P_I5Y5uRl2V6#&;83;W~#MP9nQn8G;mP~N?41+9FU=Wrh9H506rn9y4wPt3c|
zyQ%Z8HCr~Edr1L9;lwq92MzCzvd)x*rPL0sfaZc$Kobt2oG0c*kTo)y)lA>1nKstS
zv?oQKy^Vjjqd4+BfkyK%ZUlf!AEE-cSq09T;s9>*2<|IA7;FbF1f^>Mw^kCs?U4j<
z&+yL~xV@Mj0B*9H=?yj0T)^m@>CI#nI1hOg;q5`W=Fb&a<n$lOeVo0xGe`2s)&^=o
za1*%I(($k(<-gS@lb1MvcB&VqbG7`U0#{s}3mh}$U4X0hlk(i^LMu^7MTO@mK2N&X
z$H?9s&BOh_0&&oC_1&{XjjKUV4z5}}ig%FOfQUTC@PL}<_d-X*#B#K^T7~{SlCY@4
ze1@u+54J+&P&%4-l$v%{i&q=?;>PfGP1c>JoQp8wtGZD-hWj^`Cfhk1@MF`zi$%!e
zF+9Be&JKhzT*D)_mIP}`N}x9BZM#tQNOraF&w5N8@VNeCVYhL!8Q6-ke1x>^nSq@j
z3%gN6I+7i~{$-!$N!wl%dsZE71`L$A5$#2gWi_Kz(Um-o;}kE7&ltytO8fscu!G}x
zYi;1|s(LcidL}%ps%If6sCGR9o=6lI@RU4N;n74h%{bmPwd7R+%ZPug>R1gjsa1z+
z8C&?&S9RC0MgC=U&Vx(dCvZa$d^DdLTq>vI4v_KKm?Gw8KQ|&xGqMd6cto5xWoS(g
zM3ETL4K3C+?oK+(mroGym2RGo(<?ACn&$)KZczZWd;$+i+t>r+Mf(vL9jH>}kvCN*
zj+hfPn!Xr2JL#x!&U*qlY2&~a`KzHOoQ042dk3bIdN6+x{l44XIi08{cM?{=Rm4#^
ziH8Tbg(e~V=+s+2%;(__7>qdkg}`N#xUav}tpU1LEr?e_GT5npGVc<-ZX{7n=LnK{
zIJWcZSjfC;*Iz+c&A?tsoc_dS$4~ZekQfiqVzOnpWVc~sXK`QOu7jMR5Of-iC=$6*
z?CxaV&UrG&P2rPUj2&3B1aOs(D6s;+qB=I>6`S@(wr2{D3BNNO?7g+g?2S$4`yiuQ
z+}(l|K*JY#s8kqhWU(*u@YoLqJXd`IqD<y<6@8)Pslqw5N;tFJ7kP~SodvWDr@!^k
z;Ifx|pP;gUHSd2BQ?|5?k=b74-SqBio~-ITDabQqDqkUKhZ)(Ksl2sxC<cD8(|D-w
z0bsWFA>pADjVyT@?<5UCu4U7BlutkCMKy-drtjR($iAJ%Uy|HytC(Rr<ksKMR<V)O
zd8mHhvsGBFJxI4m>DW80n2+9IUKdQ~<Gh{%OW(JsrtA&ljZB)sr%3I<uV&8Re$km3
zgkoEH@zE7FRjnEV*}EQ`<T=F)=HD57owO_6$WmtVRB1K>=9xSxbX6zhwseA3+&$eg
z!!x7hrF6{|vAKvvL`6&ZLCxd^KFj(zcS=yi3~<+1X7RS69crYh1cs=}ZlI|?q1l~S
z!8}MF8#w91Sv*KOkAUB79u|f9QoZx%10y5x*JuB$t&6g8vw5M{wZS!!kw4nVyyoyF
z<J;#6rqboM%2ZlF%fkRb1A#Rsos4^Qg_r$~Aws52e+CRiG>qeIS&hYd>4DH`Y<fQ^
z+yuqcBP3JvksV_7)*Rkh8VA~q&E#QT?_f4Mk4pPdMm8~%zu|QoGsHQ;JkrP-&E-lf
zwp>6MaZ`oR2xAz=P574!ZvjCpHvN|!jI44l_aF5J#!o0<cuFy=v0aS=k>KLa-+K!9
zZ2I<KQy7Kvz!IT#iJSo3o*6kmMNZ1_<ghb7vC%P)M@n;g8rhn8Jfvj?a@C+!u$x50
zJ*Tv@(s?{Sv=0Ol@Rea%=AL1h0$O>Bqb}(h$ZRO6JDNfE&xh1#3-2A)e?HfDI(*&W
zw8Bkn2L|ZCYTmOp(4*byZ4sQ%T!qQ(EC-Ttwq!m}$?<~pRB6#Zw<}%ai`~1UP$wY~
zael9bQ>7|TzFY~OOm<rM7)3ePTcD<wP&#>?foK0$`lnUtIg!eLWms30A@cSAN}pSu
zKL5YcU!ZhyO|wM~`mgjvN+&mq99v|&+8OX5OSN0gM-YC_cmwgO=|+<!6DLkm=lvh)
zcDJ0!=hN+1e+OJMxY*i8dVmMjY5=F<3?|D^_|V~)+{Wg$(pf<^Z{K+8RrG*dOa(XS
z*4)T`&*p6#b?mPLM;7-fjsSPnFW?E<SC+zd(suz5ZS-rus?@t+!b=wLpjOs|V?Su2
zWKY68##MNQT2<1S%+V1}?ig7WzAo&*0^U+P7<I5)3m{1wA`aZY^;K|x@-?yPi=kdS
z$dAP><jsu>La<R`CiC#0I##UeSXda{tS}JO394=vONF2+Uu&Uy?zJjMTk96`KsX15
z&Qh%j@F{d$85y~RCcEh3`_ROpyR{(q)7>alv5633bt^zv3@?$Rc)_s+&LKx2v(;@f
zr4em9r)iL8>7^w*3mG%8wb%oPqQ_a?F3fzc{r!up+HdC6eo9;o4@?5f7P-BdX!GwY
zXj65^sfK4AX0z@ku17C_TB3ESSgykUJLOf~;HvWuLOpkMp1s`f=o;6A5k9iQ3P8q}
zDijTBSOwx-aCHZYjHtTeeQJhY9CCD)1--=UCR^R=EPJl2U%y;cPm8L0sH}J-tr|Qf
z+{h-q#9QU8s4nm;xVWR?eV2V*D!T&ts}Zmt>8vh2AY35n{1hON*22yMlc1(eq;lkp
z?40J0v;vc*Cr0apt&EgL8dm1{GH(u?e)x{s9RTZ~9AhJNhfW6isj!98vgodfZt{X#
zvLDjO%hYXpRY_~Y{mUd$^v^s95#lHyil2fU!b;eErv@EFCAhuP&m|j=F(ur*1USJM
zN20FtxcMWDGG?EQFIF=O9g@0WO(>z9<ev=&gk04ez|KOyoovU3Ez+xIIvcl``%B6o
z%-_X4D(1o@BhKMv*Ed;GAEFh{(Fa6p_>W0ti>zOxFe_cm+e<A1jjZkxNU34ix`<uE
zTle1Il%xPm5Ys{_AS$YU?ZPpo2b;{7>~F7qi<6jO8VT7pU+4fy18Fg8i5vuh{NWPb
zH(>u2ppCq4a1s!L>q$$Jw?OUsD+cDV6uL@TYa_e9nMaSl4dtlXG$63{C!%cnH(JBc
zV}GW{gI?tmD$)MuvwtD7hoPS~eL#)g;%L!Q?q9bO98@eNmts$=Pll0cm+^3E3~bXa
zm+@xCLdZAOB83;g#t_<Y8=F&4vF@jy9{X4HbRJAV=;{37_MTq6RHLT>s7&;fU$Xbq
zrIo#>jj>BttEbNr3FzIx&htIJh_qVSe-YVJz*2GE5Wh}D!*=HI<{s9_9z%(j$5?}4
zllUu#_tIazpehLB=;$SZi5{>~=kk`WziHT8x!mA7at`}7m&a(o#fp$=m-A@c8iBK^
zNI5W@%~;N3weFO%86np#E^12i+01<fY~@3+I%Azzpo|uq6)RB2GK+n%f;ZQG`4}lb
zui#y!aW)Op<-wYNWhU#D$2)7UJVMgyJRT$Mex_kXc|66n{Y>^4|FvF7D(afg?`yPW
z_mL}c6_=&`4>auhDjw*XcZ4-q&7&o^hZ@##HNa{1KQ;pquKyfiZ?5JoT>p239aznq
zxt^HA%2)H5(bw*Q<7J9{3AdvNn=GT(;Bp;ztXVzDX|LiqPCYv;6}f9*xNrFnTK#kl
zf5pidoovR^|1l=qyJp@ov;oy)^>_x(0E6<vlNf*N;1c`$c$r>C_P~sVl^g6dP1kZ`
zmu?Vmq$aN42{jRun~p~Ltn;)#7^{Atc)#ZNkXIbvtY9sltPQ#gpdPK|VIJ?VA{LgB
z3jlf*vnUG>PThKhcvD6$9(Tw3m#k(uatQw%h=nw3KQKp;d%O^28EZ@yp}2sjy?uxJ
zLFHC<#}15zhq-EIu+LGY$FQm-1CmZ!c#yUuqSzw~9~EHr_<bzh2X9>@)`gDhik?C*
z$b5x&>xEOT|CM3RZEDY&iBdLwhi-y1`lneS77}8RWM3Z~)Cu0|y;H-&V%B;y4=Zoi
zXi0umufz6g*bV>`wY<d9ZI&Xsy^_vurIG3ekZ=IOns9Ur6rc50J}AtZuyGnDhB@1*
z|DRnTWr+G;4+g(F>v+Q8=~YpOVT%JQSAGoIsZpnL(*bIKKlOmO$+Bl0TGr*K;2xTa
zg(y%xFU3}P!8+cd>6FVj0jf{N_7RQ~f@4+ZVP)%h-)4=1$Tp6LH86f#FmzbmW04|E
z&%$B)GFGGmUIpj$Zfj&SUc~~}1Qz=0tNhLANmw&fXMENf(v)fmAas}yRlEUeFj<$P
zpLt+KFBI^hz7^n7PQ1mkv=j@U7Ff9#U~(<119!0kp4xZ_)_20>BRKD^PDa-2HU6`d
zsWmd+^}O#4UsBu}RMzHQkRp1h)V1r^AP#0du~V`%x4hLw!p9`>xo0XsEgyD<Vg@1x
zeaCM#hOk^OUC)O|KHgy2uVaxv9ZTzvUgvQ&4&s%)&JEJL<(PIGct}Y17*Z;dnnF#s
zE2oK#jV`ili+yW6#v;?O4KO!&$Jemjh%1G*8G+Ufd_Xho1E*Uim!?~06+^a`VA>9Y
z!rKiBSZF<bbi+rHw2=pEq?Xt(jM&7Ri9qj7e3}UCqL>y)I=hKC7XdeB541s`VKS*U
zSP2(=u)@a1G2S9tOAZGZdk`w7$Yu<y7|2hcP~Zg)$WyFP;X-87e+zr$my8dWR!16{
z=No)(Tmy8sy68t3IlQJQO23N=dt2MLHre3g46_4@?}Zssegi|@9MF}$!9)D5(PVca
z^-27Qnr!+ItjPV|<PrXv9?;@xDQ{o>q8hm0cMCPL!Ef^3Qbwwgz5gc9)-HumV(-n^
z;N2=I;zz7*^gAH)DjV62swmO{L{N3c8sE*Mu(|LS4`>^Tl5|`dM!}n69nLTxDuWS0
z?fTSc_g*lPB$mXuuh$<46B45e$()dj4!9JRzQsSsMPNzi-jvviclc=UpJ5f%?Mn8X
zqMKbZMVIA4-|X%?e2?^ZfRQQh^0u9Fu(?L8a~^PjO-iC)bs%6srUi;X<&Riz0U}at
zEZN1vH@x2?0}I^@<5Xh=#%$)HUPA(mE_r*(;hCe!rbBW*M-1$>&AgTC?W1hZW<JVi
zF?21b$w7MJ)TYqGw(yZs{a_=rZsESk1)xl73MRykFfwMC@0nH}&l-<&=#f>RVMA&f
zhF#?v*?sI-#$NT?VMg}%7TB$q`x}{0ArF>}4-Cvu$R|l581c=8yhrHT`w(9mD8KJ6
zqU*CPpJ%GKXo(%C$#sp)^*x>%kl_a~EZHS=g`iFhg2}RUr%j*WXDpiV9zU(ol^xfB
zTvdYj4fC^jdy=;{!3T73Z1=m~Y~csoM>>DkzzRO#+oUf$!XM~E7|Hse!#{n9ZM)A<
zr1C?kW2+JH{D{w*b@K}iChnebB(&jzVZK;yJ+#VJ5v5+h{`DRrtL_+)$}Y$?6+k;V
z`-uW~${RMNsk?`IWU`3<RXoN0=+(CUw=qU!pGsxNns@M$n3r+W$2=tJUvP-Z7ZF`*
zvV28VQ@8!V->D|Md>Q}&-}7Tky?>g3=s)H?dhcig99j321K{#jzW{j4(rv(5A#T$}
zePA8CO_n&S$x96{ayY|fQ$g_F@*iF&;)O*fZY%%9H=vc#g_QWw2b}hG;U{@(EAQv(
zl>yMd9|tlQoEb(qEWHM9=O0Vnt8GP3w)2CM?{@;Ajl;lHF`HCSG8-7#A3OK}znLI(
znlRs4oUK;iu*qNWucarToTp!4IPN!ssc9#_EnUPU*ULOb+UtR-D)XnISMHI<vviHR
zrHI=+GR$Qe=10@rrekE@f{iwt^R_KBb{g#V3Cq$FlO>~A+;I|8&zY}_<xo*6=j%0%
zs=2+uMCO-#VD$Ej2A6J!@{>Y=S~&F`MyrJmyXk!`rrFX$jd(QRYsJ8Be90qR-};()
zf5m(FbVh3R924@ZCB)Y3ueeXtu%cDAyrm_YtaUvs**`%MT98JX#2#v;hxz{3E;tNR
zK7SAU^eaAEiqIHYgIzpbvNklb5xYRKM}eYSv5GhQzO53|{IqM$hQPNEBMO&M5G(3I
z`%f=kHL$W>yhYS2&*yy!Q6f_)j3_iL#d#~(+~Uc8AsMwYqoR&fG4ia<gTR153}Gva
zc!c!9MkD*I2<G&U0c-qj?j1Z9xUXyj8ZN&E8n*876IbGGB%V~>XBV5eoA+sQ*~REG
z-EYiv_Ynd+f4E@k?uPBS2!XQQyo=QHnt_FV&3o0cCba$gD;t~rH8)B(Ab39cnum7D
zdmUPB;zM2jE9j=lyfO~NX0o_tAsX|iINcI67r~5`*Ry(o>WkB@nW59&Q^w++xi|kp
zWp%&dL%VbkJ7!5&)}xH|t2k@}eQm^w`0j_MyvTa*ko&#mT|ZH8!mpHP<$YcLwpfbx
z_;$UKz4HwpCKbF5eft{-+P3SBMM2;4k2S60^^~_*w-FcGJZ^-$Z$gjcKGtLh5ZksU
zblvakGQH6VoGWz2y6ihFPvEc3V)yWcQqLRc+#cRV|2g)roN%)lpYdnd+`HT_HWy*b
zo@79UGmw9Qg<8HU5sc!DF8?*~m<;O__vxCHu~>tRK97!e-^*9KPKake?d2c3-Z!v$
z-@_BJ^1Oka{hq(A3wl&t+rBbG(W+w5uyhsqKHtyJNf&=LFzW%Rdd(3dAK<<n&wfZ`
zveHCYF~3V-RJOoUVDuIMtQ|qFPPn3HEa0jhe9Bb**(c2P2i~_ykAECJ10jKp|6^bi
ze&7Q`%N`nB)~+lAxo97CmUMY3AYTv;jS2351?m6x15XT{gH5rDgYaP>|B87;K$?^>
zs0ecsO0Bz*#T?|_rKiUXZ2m$1nlu%Gx`+5uFQbn{W)N>snh-Cg7YvLY;t5h=se%1+
zh(DFy`^CVH9_CG@C1nOyc^IPW<=X}pRKiO<4WA2^x*P0<4ucws{wd+xrKn40jB?&X
zZFaEfu-k9=pa}<sZ{=zn|4IIg%DC+_8`+_s(9VEdBYXA}&j?7QQYuxYxBLt1__E~`
zp}(*k$ESYgKQwJc--!=&d8b2B-LzlgpnI7lj|NEZag?{|x<41`Dq=|3SoRQsng>G}
zcwD}&6P88RjfBN?GhS^Sfi;NRYgEA8jkZPC0SfsjPjKDUt*HDc@2HXHRTx-gDSGR-
z)X0XG^2(g|mr(s~Z{uJ5@iiI6xsU4OEN`jB?Gz=LSJGOxhjkd{TF`35!1S_+5-e_J
zH9bzqJh%DkS2DgVZg1hkyt2QVGFMF@iDq$ILLU~7!6MFD@D%qT9)m%$r<$iwEs?B#
z<*HxX)vulE*9Q9+`5{}}HmhGH#BMBZYt*k|HEq56RjQ_mhRrKUW+LauYT8LPtsqDJ
zG^zy&dUU)@P0UxnlGU^^>Q}j%W>UXQYT7*Y>z0}}O8x4urcF`5=oLmZ-(US2rl#Fl
z48s!|+@>a8TP(hIs$U({th?2(xFyCS+i{p1q*jZJEb@2wRzI*{nLPM+{#dG5Wn%+R
zz?tz@v4Q2B;2Wi32>AZNJM|if-RksCk)7}_+XFP)76F?+zb*}iTMQ+dFPQdSz=JWk
z-pV}6-963rL%KOK04cisO4u!stqxjz^AB#46ilYS|KQyk3|WZsR(<D>0YUsp-l2hB
zjR>HKc@**60+FNQBSa_^@wysuk|OR=#6UHo(+g0L6Hf824cyg;d6XlEBKBsBIyz9q
zkEgh?!D2NcYY>VwJdFsW8Zqia<mh*rH*Zi^jYy=3+|xX;L0Oil!+?mQt*3d3rg2b(
z0XuupxTm|1fiu%B1Is;&P2|&O4Q$U@?jN-GtYEd{Fht_vBw%e1ec1G8e>bqZXZaXu
zF#<1~<1f43h-0PaU>kb3U6JNb-ov$VFPP}6E5C5fP&A~B*LQVYQphg+#e-SyMcz|7
zhvEA1BF~au1uIJaiw8(&5i{m5zT7qAqax(9Xc~u>p`sE8l;6OXx%3jB-gM)uq_HM-
z1)hQb)oa0GgV2i(rwvSVnSUYuecVu_T;{nNX*@V$hjRGCxM2T%PC0*5dIcP?K?NLe
zAHR;~4ps12{gz)0F8OEdTq?UGYMwk1zHL|eNaNN;V8Gd@K($s6uXQ8}PT2IvzeB*9
z^efVEH4yZOiaxk3WV-v<y@XJk{{6j%qIa+IN1CwU0xWWV%*K0fNngL_3o!^NPwzI^
zSH&)ngGJYPhVLXw(+r2+>jDfze=M-+dwgkN0oQp-({Tk*#<%_@Kp3?eU3G`pfl2&p
z16y#NkCoUb26pl~Uz=S26N5{d2C`vKf7AjwNkR(}Kr9_EeT_cCyfTgYV)=?>6lur}
zr)yMo<R2`W-oL?{O<DL2`r|=N*s33t1tOpei#uX%2@F`K5Z;9_Mjf}nORyxvN=9hn
z!An=!Oy5E#&|hxF-QNge{TeeN>2V3cJ$5e*C2n2)#=u(N#DJG#1k!HumLiaS6aG3B
zQ+N}Gatf4C(k}?yqa+H1+_DFH-$EXWnRkn~8H|9vyBI|3d_^<jme!=7-X;q1Sdxo=
zSl#sV07dIDkQl0%wSHz0reo0|!auEk9;ca0%Fi4{)&JZ=^ArfXjaDg;?g%Wr4K{Q4
zuz`Jen@2X1_5o#G#X8pgq=Ef`T=g~{MqDz`$c}aSQZFq;-q1TdY`CQun6#`cyoGs%
z>w$?I?V%5wzA<owj{;}_<&jw$mx}kqAgB@Eh`^bhKSUOSzMRjZm~_P0^gZz_+UarW
z5W474GEL^exu8}=Rd@mMWS_9^$$f~z%~zrR*{B~o1t&l?W^g-IQ;0r@*?ot1iJgdI
zl~@V?P!X(_tzZ~ewGIKm)j6o+9WkIeCk$-dUEWgH0EHaN+83W2*c*3wWF2eFxlf>&
z9k|OkNu5yrsCzu9UBE%n6`>)s<*LF#Diml6=YI|W<Q+AeTR)q9c8`blDER?!)wAi{
ze;06584@F)Wo*aoxrH!D+NOUG*??!kzZ`g0`PcV*49xQ%p6J^LS;!Ca?NoAuTKOA@
zLAV@_`-g`$fAT-79%Qx9GYhx2KLv|WZ#5QH3ZcvSeQ01?|A9Y!qap)4_7Cr?%a}zq
zV!}ajs@P{>ZSHfQhW*hQM3xu!z#^jmeco0(;tlZSRTPS+(03H7L!mnq`ja8l;sNiX
z-AbY94-mJ6LWLAJfkGE4)P_P453$`GM4{0S5qD`5LR%<qFNIE0Tw@9~eT2}djR=i;
z#M@{~DYWhp_tox4sOXbN{H#Vh^mRm<pYTL&6on2wLBmhiBlPqMDm+G^gr~fd_FW2P
zJw@Cc3Vr?*RS%}nO$vokDE?ohdQxcmzlb{t{>DC|IGIA1C{9bEsAmZMRDjU5XS_|w
z0feS|3|B2u<!q-gr>2?z03Z1ZNkzM!@h>%v!$CTbT0+3UAO9!A#>Gl^pGF)5Zhm(S
zmIP^*r7)3ZyO*!c+W4DdaD6R}d1#aZDdZbhR;W>WN_EZ|ScOJ8=jxNoN?esQuI82O
zBT2a`o%_nb)@zkk(n)aN@3l&hv>So*6nFyxn^p;vvJhzIro1PWLvudtrW}w?e`6@J
z)=^q(Tqg}>-_%v|T{ma4WOpS?dv+MQw%c8ab^T`!t8iCxwRI_GRz1Wd&taSEDH*P}
zXBS<sryQ1~-8)@bk%!VndQf6u4?UDWr0bu#79DS-eBdfA#JpM5SUD}d^@D*8Zld&+
z(h&H#iISkbFddxfd=q7i^u+-PQZMDY)b(Qni}OY|I(}sDMpFbtHy(p%-}Od+P9w0#
zTj}ar+KWB&R>Gw$L?lKa<pl(~>y;>}6#}#L$|tUeW->n?<vrK=^VqjON{Upv1-S50
zK9d@w#T~v%P$Lblcms1O#q=vr?a5C0D$&y6w+zhPPl<7j8qExTN(bM5`)P>wW2u-u
z3DQ6;VxDX>uzWuyR=QAVV7vU3P-$<Wq3D#K@=T-sU?OmJrm50F>oN%;eSi|8O`teq
zfD)~Zq|np=C047U(AxouQQMS4e^BV!1cbZ-k#8!6x(6bzBZYD(E|x-H1S;X$Pd%YU
z{T`?!xlVtbc?T&gTraO@Zv+7^D~GaEK}wh_@64VCDWQ#$hiX7o;uhTU_Ct$W1uM-o
zuDT(tUx+fLRo!pVHS{ae(XU<afrWJ@4sL!}shjRTQf$laeiOqGq70Jin+-(?p~^l@
z%bp}}W6Qv{+{cQwS~ixJw4u2%_W{XQ82Yf*E5!JPge!45Nh35a3a%j9L#gHGlfZ-T
z3r2YeaW2r3%SU!ZTp8kUB6h3FBkd_EosbeLICjsfltOUa@~Eyzp-a*6YJ^Ck+Q=YS
zp43I-lA3>Aw{jg)r@OPG;YuUDi<(E6GE_t4$D0i7cDT~nb!>MQ+f4E8cONw>nu<}P
zPV>hE#~}f?sPzrNoqtBR@(94JxFlemEb{yyE*Z8gEiC_ifS{-n%;$1{1KZe4iE8Qz
zU>sET0(J8<QM4Y&{X{b~{*94&M}U;aY_yYd7X*fbrbB`^8sHUk50;T_Bz6@|HvA6u
z>=p`b$91SaLWytZ^AQPCPyDK4PM~u<+9YNI;UX6HbMf>fioOBsX!)g%>`{c$vTsMk
z5z{g420ZkaYf3zv)hIRJmQ_zMB7c!Vr5z81N$hOYli11mklK6+zg2EzEHhH+ENy$=
zz`lr70wsA7R_c+;{O2xU=-*sfEZzRfl^t!aBuis54XkmL;?v^u^#+&RrMWIyP2k6$
znL@&6axt9gvb$HpcVp?A6pO*8cUfv+{h}0q>FiE8NJlBnnuT}tb?H5^;Wm?IpX~xJ
z%Y}OjEC}5z;RSHTwC`qU`M<N79Hn%XHlXO;C?&;b+-q<{A}?i!UoT!mc+J3iw@^Cy
z>T0Hm{jMhk2KG)1B}w{r1FSJE6hA2$lm9^r0G}{h1>Q5izz#eveU9wa6>3FGMX%R&
z#2isqi+1=AzHDG?TLL?qcff?yQi*6+v{)#(`Tq*dZ;uNRZ=Y_UkqQyv@oINcX$P06
zicWcQ&sDZftrS16Nj2m3h-a-^DIu;GQ&@T{rG2vZt2MeQy5fR3G7R?jTmcIZoS~K$
zm*=N|Fc8-naoA_UELN{YV8yMJL}~s^1AE#^@t^TMRuQ>NOX$8*tJ{hsC^OA5Dy3pn
z0$wsWp69B>ArbB8(59-M=fY!@+c2AiN7rb&N++lr^(eJWc<A7o)&1rF>#@pK`A0P&
z<+fG^M!z*fwdr~SBX*naZdKE@=`UN+;L_b1TA{do(%HbCwFbwtc4J}DO6#bCWU||C
z(`5bH!!qkL2;m*aX#;l;)zrg$L$%v}+LO(XRz^#s)*9Ha(TY(@{M4YDYr|udXrG?1
zIAc$2v$cE0z$PJ0`fag+y&j_s@t*M((3vOdb;%k5P`*hpuzzDn%2^DoZyTkh^z%G0
zK(8S_te_33wi1nf)<y|xFcFM|w7~{%8`y7clt|yVu^6;0#kr_%^HjC#VgvF5V4ksx
zum0~}1pIN(G0lIf;9u;{I>##grNY$)_G+xsQ5uAK_fxFm-(c)EjLle^ekh0(=I8D{
z<FS;fMelvh29_45w2BFPKCKa=$dP$WeP_GBu(cP)DM4NjrmKVPhF6N{4aJ394XiXy
znHSw^%KvSIU$BM-3`Tewutb9a&h8knpd|KMJO(VZlikpc0TYJyE<cM7hl&BS8`?Xi
zu)pFlVAt{?=G!WhrFS4(s_g4N+g3UEQViI}RR-qTPMIXNL10=tB}ls$iY_Y{g{hg<
z3aTzmc914@7kl22abLE>H2+|wf!%AT#DvUWX;5wMO;L=d$TxMIQNohjD`TafC%_K5
zU-9?!NA9XFo^5Af|7(vf7ALYB?Ukl6zZs~DyER#V_pmJej?Qikg6TUL{1Xi0a4d$*
zUuf}oVd?_|OGr>s>K?@eNH>?U+qoOOSV4lKi=T{qPR>%B=L(5yKG1{UUxVxfWD7SZ
zf9cW$B_eS5OiH1%EAAtod&JGNgA&wvEb$7$1S-J8ubWg!0=>XnY=sH=-r9ntggCq)
zggegroVMxfjE4ofbCKV3OunFl(o#Eg6x5YH9TZ>JMTzW02c^B^@+VJ&(z5;&Ok&_b
z`yR&ApiGy(A8TMc4N7<y*BI;wg#sG8nR@yhgX78vJB%<55Z^eqnjH3TrCSzzR<3vW
zo-ws@%wMV;+L>DU7)RyNwJM+ee^tKfKPyip$bkx~9O|T6`DjPwt!q^d!l|+Ac-{f|
z%Kxam$g`u;N25E12?&F=Ejz%bKlhG-P45H^e>vFu(9X)MPNzMJZgr;Yk3jg2?Eiv>
zdv{UFq-Dq+(^Xkj>(YYau1aS8FHrynZI3q$tYfnBt@NN7)b?a0B&{sP7i?00IReDc
z59kMb%0b;$k86k#79=lBahNAIs2M+^jJ-t0i_0K3sxFUW<5HBs#>I>>2Tf}xko65T
zEo+K0DZ~rk!b3s5GcA3xb4lWO-INvypM_Cb@-{hwfy9dgmeiB^KW2rJt{Mdhypnv8
zuAhZ$dp{Qt9D#VB)lKQ`e{KQdYKr$Gh^pMq#=q0qH|_K1lixxVt#q$GST2rD<}E$x
zk_CI}`EtLOr1Lx|FGY$?{|yl5)JXy8wNMA3+d&l11A4cU05k*H?0{}xVh40j_H%%4
zN0b9l>+{JkBZ|N|a=$j952I8-cOnIQt6)X70evUL0q9zYn&$!i6?zmf8iQ<hK-WUd
z35>p*^&FsU5oHH-@T}*PM<9v--TqH)Ku<PT0WClZUdhgP2Go2jPdwOQ3Iy9&lByVL
zQ*WvgkRyX6t65c_)zr{4yJv$Fw|W_BmHmNRGgKY0s$m02W1WZM&PUYhqXH0BRxeVW
z&3@_TMHu*DP-4<*WxPPsY-MqSthjV@DCWfa7z3N!QweLkYXVSVKh#2GhldjpBMyyV
z7qLHh8EMU-fe`p1Hhqgc1FjYrx=ZhM*e>XO?=5#Yq_DD{ir$N1E;)l33+d(FOKCl;
zp1t0~KrL8uxjBGvX)Ay4F5%L$!WowZ=7%aWr#8j7I&Qbs?aJ}QiE+}4D_UcUQvlzH
z*421Lg`8judjZ>#&ZR*fV~oBKSYMGQ@->~B03_ItfE+bh`(WoPVd*^`SuA@8q1V<V
z={HHeyc^kY?iuO6qP*L5q}$IV!1ebOrP0ehgMgfhO7M8ozRFPZ=rYp?tNw2T;J3aT
zN-bhps!Av?(PF~Me?)700;#oxO~2BvT1MG7S~XjW4a(&K%hIy)=)Nv4Yf`VE{Xg%D
z5}yVd*anj_WJ<R|26~%hO#&LV_e*rC<3y@*=}w>*>sZJd+><|=qOwU57nbR<kiMw#
zeg|JfyR`%ij#C!m-I7~i{i0K`D-5iE8gSV%6Z7t5#a4n2{aZ77ClLB25QgpvgxcY@
z=?xIaNGlAWf7v^QQ2yU=dwqBMg5D;Ztle#<yaPIueMdd-8V+UXkD^4nS{o2DOn{a&
zTvX%Mpa(udxC`&V{qmnQC3NKBX{a*qhd5~HB><{QLr>bGGA&&&rdlLYZ2EiPJhWhN
zc=(X&Z})RagmfleX}-0bE>u$wY87SnRw6ahAAMj;?W44nvLKIs?xO@p&WEubWh<s)
zJgai=)Hpe?5bb%UD}PGMdSh*#u8frCp>V$pB|a1ZoOkl97>mNBkUn?tzc52-A$^zz
z-3!^h=aP)2$F6Xk&$Ciit)!lPp~1%?OIHN+BFkl}wDRjJa9D0%#U~^LK6dck?|;b6
z8zDUUGrAmtr#RK%Qr`O7avS@quhJ&?LT`hMxFMi2EdF?90O+9z7q|-&8j^usoqkGd
z?>CSKG3C1}X`-w6Vafdz@3ir7$|7Gf7f@fC`Cgj&U$h`m3$u|o-MTXq3A$ami|`MZ
z9b^UPJ#^LOA14B`CImPd`X(Kwv3`mXcYb~jr<&9Klw`aSGZn#*{z{^DW*RuovTnP4
z*u4HqeB$k?HJCZZ0$K**u;|z2_W@!nCgMkE#LE_AIzEC94nHcaXU_JAH7O3%S7AgH
zd^ZtSe}EE|Gx0yF?1#8Y3C0sF$#EUY(vtF2a6s5F8sGo|mYvvuGO1`;S^>JLQXMe*
z7PoG0;-muYire6ybAX)e%U3jCWgCr{>l9O602;&20g890`thJ{bLvjh;Z*S+VEKzM
zlE4xGuLrlYaFjw?nY!vsEhYfOw1!xCV-jqF1C-!F{T>l>Ni9L9a{Mnvx#*>?6m=4#
zlK2tLQ~i1`5W6)S;Fn{5lV=z$qRY#V`>TuSwdKT$vlb$a+_VY?DR}cV=-=L7VOPiP
zV=n{yagZ`Bq7%syde2&)a;TRd+!?3PUlk5)`fw~kQeRNoYTs-GQMmX8rAXqvuq+s?
z7#q!jgr-}CU|qX6&_GYw>XWh66$U-ZN$s%^iaiiVxJTylmxP93D<5!~Anb(sT-_ip
z=%AI|m7X<Mb}!}`HVskIr8nll=rTkJ%ee;;WAQZYyBKQ9JL0O|jG-PRIUZlE9x17=
z6eCIFX6c%&+XYyMfuq`=@E(mDRzIPts%!*wmZFCXM!u;=jJ!q+ISzVx9!j;rYM2TU
zo_Z@D<M0^HBw%8TeTmVz<$Ka_48BE=>6H@070^_}z(R*AKK={9p;Gp`Kze*nKSF!J
zM$AI=YN!$w*yaTkgkCw;rvGcXSox$|$&)uo{{pP)LzQ-6QPaRl$dOavQsDkqQX23=
z6>#~|U<126RB7&C3h_nmx2S8B-GvaRKVO~>*NtIH+rZHf-<2KJ-59|;RpEjyQ!F9p
z4^z5HSEd=*?qNzZ{i*Q)2|TssUrs!g-5REhh}w>%yrnxe+0C(VoQ3|wOjZhi^^#Qc
zm6W_I66j2+2cnrfTxq3UNue#nm7rFhU0lesrah8Z>ZtPW?&;=sDS7ZcjjimPw(nYK
zHl4knrbAzbD+VbRfzT03qR+^2&U7U>n`xYZ%^9IIjcWaTnjfMF@~Ib`nBC41Fq-`h
zHRgXKQ1v_*&D=&RU1H{rRrBsETW%{LS{c+Imq=hoaT3Kl)~k*~7nvimHa`zr&(4up
zZMQ~QvhmPr!0m>Ift?zuEC`=G<~d*oBC0ZyW_<Y<UJxX6M=5E|A48T`PZrUsD~KY%
z4d<QIu~CY5(9|%&Jhst*w=(S>tp2%S1=TYQH<OH3e5CBj2G(k{lH9l(Bx<!I{8^Yb
z7mrpphNSm%EU2?^%6=VKquuNP5BL_y6gx%<59rhp0CXA+!W&$uTR96HR^^kg_cO4W
zV<1DHO*F9g#wdO{Pevjqb?B<E%5}P(TV7?(J7JG&gShI6K-`Eh?EL=eB8%I<aEeX>
zpX{nzy#X`Big%WDvd0y~>Q?3<LbuE9B0fwOw=21zG)oI`*Eg7PEcT-Qgm_y%R!NmM
zA@Ji^Y~xs$0Sn`lR*i>Ev3C&owCV56f}%W536b252DW;f5*%CCkq*TeJD&fKus4B^
z>3aXiGjkJy#Drv$5ZOc$OOTM6*g`^56N1>Oo!WO2dn7~<F{Fy4N~^T0Ep6(aYpfAF
zZ4vv{qAl%2YH#f|zxQ+QBpH0Z|G(GE<leJ9_nhZE=h@D4&Jl_d1u*Ltz|oHrJ)zv*
z5Q6)61hB(bbbhehLFzmeQHDe0hSGNIN$Wa9j?dU$!M<S$p}#i$&tP69Bk1rFb8L@V
z6eiOR90!n!hoggF8Dmi#BP}B1QGOkjH;OaIW9x|W-$1mXK=EXtzTEBc1qiw<Fdfr*
zCEkT{4>6{0N7z)8`3;prQ&Rh&B#AtX%^K^3XW%p>Cm-kz7`{X-uI*ILgHQtf^ztOk
zy{Fc7S1@WgVutecI@0Qj;Y|Z^lu~@&P`OQ$eFoL5b{V};-JtvW07|JRv;sbwB~mnL
z4KNjsR)E$qOdjPdxq;Zn50i)J3!DiLi8~XcY$flDAzAr;4Etl4+`}^sENOox^oat}
zJs~j0#8^6fAXm^xt)v*%eYiZkdO$yfar_P?0D=S}h4n#<>TtQ;*jIr*AVPfyE!yo_
zfMcEMtq$JMrLB~gI{?M|fwz{#A*V8O?4@GO$fonW^zM{s5LHDTTysF>J@!*;3NrBn
zX3#%|EgK>GHaOK=43Bl-1=Xe`+S+YT>)?>Kxi?m|N63L5hoRdOp1qJs^uKzf9Fnms
zS`|aCQFei4(>H=4RxXO{B1Fg|l_%NsZYY6M|Dy_VOYjfw%e)bdRT1ULn`UZ$Jk<@d
zA_?P`XFFH&3f+HF%g3nzM{1+>ZQDD_SyOHRZ91}r{?bZS5XAm*ygMh`6^6o*vTu{I
znBPvRfk0682lQb~h9}gl(tVb;&<=tF#O5}Hs`%s_l+ntgFf;yb0guioxp77dGyp_+
zWB0dcg!RHTA{SC<5JA2Lt7SOeKOPLpRuT4zbvmls2~KoZT#TF>n{ppt&bFnEHsu<U
z@q8@t0bmi-2hbi`lGT(pD0jev>}w#qTthv_A{kW1S1r>DWhm_DH)x@7dbY{Ap<*%i
z!MzwKV2(~(KY~2;(k_=jGvX}^=kL>EfuXwEm8ZK0;p-)2V#<D^b5D1FLY;elRdf!j
zIkd2!t5N5w`k{AF=Als7g$n#d@cLQjo&~1nkCyw?YVq2Lf(cV;Dx0!qyJFGF1ScY_
z{^%I?WVBr0?PpXNfvX?RpFy37F>+{=k4QkMgN|G2F)QEYu0nntZSShJ=@a9ib$=e&
z#Z#IFw)gQE*}rD5W@tmOW}!`2#inl#Hi8W!#7toC6pfL++?*m~=<L-@bPN0D$H*<U
znp3RdSb3Os-AT4$tUOxR_kC)D>KPmWwpw|de8D-k8z%Z6<Kz)#$BL$mhl%6S0KtUg
zW#9G#I?=)nJX*AH6ZFdHR1$)zd=mk2_Nm|;RY<EgUygla8q7Pq0nAwJa|QFv{EJ;5
zFW0CvTtf5JXp`A;gtk6nMJ7NRZv*{ir5CC0{Yfv4toH;tx|zmG8ubn9*RQi}CD$E@
zjPB{l)#XMB`*;t=+d(n>0_xJC33Bb^&xk4@b6XQfCGWt9)+9w~<6CMcT<L+SZ<nGV
zueMMJ$b$o_jIpa;*ff+14uJ4FK#ZCwH|`QqPcQ_V{#+w^Xo)k2z=&s;%_|41!hw2l
zCWd}@FSG@!K7s%U{lL~vsA}I&l>JIQ+C>xPi<JXrpjfWIWfYW@N%Fil?Yw-PcDKNA
zmf)yH!$f+E#oK<modC=h<VSj#(4%wSKCPO_V$x)+6#9<D3eRMDmgJcl!`!CGzST#C
zp`yBPpri?oYDNL$6uDk-LrR}_cqgFSZFxr$#dKhqQ{)=Hp5U>2$mHBlKlWL-xgP?@
zr^xla;z1R{Ht9rKaB{985>w*-6gkxSawia)?^HA?as)OBO_dX*<}ga;PL=%(?ZE!*
zs&D;r)%Pxh8p+DTZz{cFIidJHEDuk`y6p1Kh-*rfgFF^MA``zpe@x}qEG|{{k-n^i
z?G&l<^q8xl6GXL=Nt|rXz6ps$Ua*TfKkl;W2%UC1(k+;b5{V0*q*XlX^2D{7#WhWS
zUlV=@V~?TJWiJ=@?Bk)--lGY*&5{oM6_k{9S_@TY8a6ZKOp}9aYB0N<QvK+X?x?c@
zd}34~PWA*Q4o{PVB1Wme(sc1zt*fS0I_gpZ5xJU@6-QnEtI*6zTih42y3Eq|m@WrM
z6B0p#(`7&BTP5DOsB^kpN7IL;O_%4?IMfz&T;{Gu|8eRnl1e^hU5m&01b*~xb|#W&
zS`{4vYl@p8H;(WRQgwt4WjaDSOaeMY92>t-T1-tJO#g_7M)t`Jd1kA^+UlfBG?`}y
zVNV6Q*LLR#vK$atPF?!atbAnQn>Kx$KzOre%3cvpU|r=>vzRm+@QLcbs8hcFznJnT
z%5ac36OjRh0f^zBDf=|23jUm#Ug(tSD@Y%X!k_OOo#GWOmTUuy|E5pD(84NjELPWN
z$^H%Jg1y-1I?&?_`hAPmVE%P5(Oh@K8dASm2&I7Uie=7{4W3UsLdA&$O#3#d<=tc0
z@mX>gX9Z1UezWCT^+Fp9IY6fTzBrJF)k~x5)q4xcR^HsDRGh4yAUBXS{(|Y%)U~lA
zmX<U<?irb7wj7-?@2ZM`q=#?uJo|A7xV!*5YOc#&7`k@Ndk-3C*Ss$wRhRt@5<re;
z@gnFU+s+B&i2D&Ibc+(yOPsJJ4&;P?sT4a{GO~81Ou-66?Nbrxsfp>9JqHTVEkBxN
zO;z4E)uRC8CREfoe9cis#g59$r3wcS6B|VN`T$_LI6;hcY*mr6vMGr59GGJnq$e=Z
z9U+O8l)D8&*}YnWGWCP0613gpkWFPo5|=Lbs1`YdREyM<c%eoYT6eN9)8%koUMNiX
ztk?ghHMQxNf>m8hmzxeL5KKoE4s9`pCUc4gPTMV|cJ;k6)YbGg7$13z@Z@X&8!nzr
zo}BbT_zl+B^x7II1I-p2c(M7cXVHFK0fI_U^dG>en>ZKNU1Qjsi{~Q1OoxXpb7g~c
zsU?))xpM6W+o9ypRMhT+v1K=5p;z>yR7Yvi0tz=ti}DlZ24~3rO_o7wIi*4yScr%C
zoMX^@cjNQKYYt;dW4P%Ss=n}bkSa1{FXsFA8FDkPZLg7noFkBLl%uDdml<-6zFWXU
zRqYu}5QvTg2L_qw7P#Y38BoPBr}0BZPbld|dpQ6E7s;l!GqrS0!<n@WBXFlwyxkBO
z3^=7Ug)nHCc;ho=-=03c7&j>~>J}UhMK=9S7$2C4VucfG9qGpZVL-EkZ~zP35<B68
z{tpRBxfM)jZc;O{eUXFex*hsa$iTo1_%DWC&6L9vTH+lyqUHMkh$fH7OKxt}Em#E;
z)OHS#lXX8dtce0?)=tB)rPlx6D{4D-Qe8nW6LN+xg@yY2EBMUj$zS(38xA8oA$Ryv
z`=&G64wi+2c8B#2=wT((l1cO2lmK)Ekxz(@lYwFjMkCNw5!X|ijv<X^v&%0pk$lYM
z%1f-S&X-$xZKn5~G;{DT138}~XYG9O`8jylGarlDrxE*AHw!7>;UOtY9;KJHKIpLi
z)h(k_0qNzie8Jz2X3626r@^Bgn=!IO%<2X5DygCu+~*7AQ0WFdhlL9e^KjY+V6(yB
zzVV5%bjp_B(|Fd4L*>l!J{*8d-n>vYOQWknFIXgpNpW~U?J$<T2r~Pe2LeSF$;+jW
z0e#?Nxsfyq56c%Ly05xdjOF%XIYLvf%0GxZBfOEC0au5Fcbk3{%ofK_HB5lPu|$rm
zyzwy*lH;=JF@hqO$U`f?hj$GAF}y!m0=LaEv>-AUK{iYAFg90SAwBhoS-n&~7e3@6
z0p5f@6rXwwZ0bj)&{Q}apZSlb_zF@mV`Cr2uop|^(2Q75Djbdyv?U<xUz_cyi!%Ud
zil^gQJ;04d)20vc2SCUoVBCGspGNikO7fZ_!r8|Ud4+0TKjcA)5GMwanewtG^1eWx
z3XITd(_gHG#N~8(D(2ipCoznVZ(|tiq99_@V1<>W;zLi7Chj$*4`F-V_W)MX&#_r%
zKq^TBlsYJiU@LIbk`|7i8b<}-vX1R23b;@K92XRO*5>VGN;K>J>9ZuwZ2BdzP|9}5
zgTpsLRl)D=Q@A#P@+qJ$ln1&EkH9{@WpY37il|*cxDt87kNFQQhI7m034^l`#ZX>P
z<V`{ngz_4ggtW~AG3y9iuVSB2-6`{!OW{3mGyH=Tb;U?pqag|r5^Y_&l??VHrOEzR
z+2_mU;Hp~GqU>(Sh7-SNxg1hc1H}qApa<dF`vNEYChOWEx+Av3JsgpfC)aJU2&hi3
z_p*});U8ob+w?A|0g`}(ggWQIh%VeEMs$;?*Boj>{fT+9Pvz}M1=IQJF1DHH$#vWo
z<2|)8zTndaQzTCgsnr)LX@9|@jijP91MUGyU@vv=##n55@+yt?_?K+;3i%^RDv4nc
zAIT9J&R=337JI+ZX>8}1fj=gj`~Ewm<XqCEbus0}Zo~^vr&|yJwhUlv#XH!tzj$9x
z17XT>pH0cO<CsY^>FF5paEFnAv<jzbX~SuKG&xrua6OP#Z8tN`Y3*kGjg)^!o|FI(
z^bb+63$CRhp3@CCtsF?ph$>v<QU`fhOG@p=&MeONOf<(DAA!Ei`i%2s%&AU85d8ww
z2lZKt3CZ=FBc&>$5^ehXpv#;?nU6KaJ|ardaI`pvO<pN`wZBvaRJY8g-;WYBN$C*H
zqb}<JKvO)DFk_CLbDd~^1e8EQ+8dsWPaj2UK`_1tJv$T}YNcGaOA(|#2rCw~=^rR4
z1t6?HoF{DEuvYrY?)FrZ*V>aGZ7vnYq;t^?e50UExuJ#aR>=)KS`)RJ(=vr7b)_~8
zm{qc$lvM{oo~vYIAdGNqOD0*hR*cPnoACT&1&EGCF=B>1TqQ>jXBdYkiHorqHy`cV
zkLzsE?A_3*?Zms^DM%3SGsr5*3feSB2S(Y%VRE}_J87Nb#Xu!Soj|Yv@GR`DB-PG^
zaTIkH5vf`Pimry&)H56*gRA8l8Q()llq=kD=-jj~XJN(4<(uY0zk!b@w(SREr7Gnt
zI2)F$f$93dbQ@fl`~L-CbUA?2!vuh*XG#Ht0)Q?9q22nMn`!ynJzdQ@3<C*0ST0nr
z*q-;rIDU=1f`$Si_v#U*_1~(M2CJ0{)k^P+O8Vt$UVk-jubS7I^2Ea0P3y)B!g|g*
z1m`AJ@>k-OhCcZV(#(xbp(+Sd-F7<5Hgo!TU}D5iFtF}1d3KpQWYQYhJ7iiV!6C$;
zU-hDPrBF2bV9=A`BXgY)kGn=5t2Omu-XF^r?egB1(;p+ezD}v@yn6}`xNi3o%+4F|
zYhtX+jcZ&Tv`#iky=+D{dL6b}G{J*;9Za5=l|jkt<eJhG$nD~Fa(ihj9-6L)*{g*z
znYLaI*9W~e3jfD@=-^%vS<nb&epoNpX!htoH47^<v|tIP)Csy^V$|I&nq*z#osw!e
zK)WTWI(3r{+=dl<QVUj==8UMvPvtP*WcYn?WI(*_e9jI0fR9^$TaT3%7Wb*FWK6p!
zhU+-Uq@acvuJsVY<$e$02Q;VMwCV3wR&B*3=*L#mycbSCu5CHB3L>&@mbvL%l70lS
zV2KX&H&Ot0zXZTop&LvYSfR5Y@?Osd{}WDK)r@QL7By4VhHBOIYSpT5R=p2Al`gnG
zuzr0KbWz==?@F^-(8>erDx?u{bXrHm5rdpkZ`#ez<eJ_?olq1L`!gJvQ9gFeV}opx
zlHoS*w*jXA-orr4Ft61n%_H0I2Yz$SI+0P*8173r@qTE}z1TM!<krpp`%B<%6&h$)
z<;Db&(rSWon&UF?S89@B5dJuPN2~{L_!g^twd=;P+uzE)q!XCht+&bn0k~bgH)2=7
zcYuUy@6+^4!&x9bp<<7Ry*+EI92h>V0ugQO(h_g=hC6W+uQAY(48<o3x5_Eamnv#d
zIc=2_dh$I8LQ__3yGG!ox&^y1-eSFf7Fb*|b`m2QEV8!(Rdt)(y5)Fs!R8#y)!L3{
zJqy(>B0&WGrtLw(jq^N{=D6)<{F5UZT{gDdI~{eo%?a!dm+L%+9o!}xE8l{f5$~Vk
zUHhG!*m4^jDvkgvssL-g3-B(QcGM-*4ln=!=6@&0RF<KxAmTC_@zsaElTDS+yaaXS
zHvBz0hUveTQ~av@Ax0$c2u6flY(N~;pQA1TGTZ>)!-yMr1zy<i<^KN5^<=iM(dZUj
zr$*rT6-=&tkZ7Sb`A1egUyi7&71+qXOgKzyXE%fH?*^-|VIJ8XfFCxEVI%V8I)>3G
zrx6jjgVAg3x85#7in2+^r#RnH3AwRPexT-uHU^cT)y+_Kf4)3A<L^U8panE@T|}rI
z(a;dPd+&cE^?RgRL(W0*B0H`<8c~u0LU?pj^mqtBh$R&8chX(g(^s*5^`KzX4Umf<
zTC)-Ww+8X*`j0XH=9muL3^HXM&(M}s1jpQ8K;O&uMG?SN1YGw!plwWFKWd?Q73CEK
z2)s6b3J5JxZPGzJID-u!D!;UHf?9c-T6r}}lvb`OD!+PCHi!55zU}~7E+4@>)`Ovj
z5QUHjhQ4K8hh&<{Jyz0GZmnhtB(Hrzt-WDwfgFcfJZZaJH}uv$qp*kn{s@Xe7FKCO
zAydgvCXJR1<#Whj`?kw9BKzO+M%zl4NS=LyzSH!B>j7?ZEUo@|n25*~q+rT%wbm_U
z6=b=7ty>rH4x70H+02P_j(t6vvxc90A*L!>#@g)8`{-faM9RpAN&t3^xr_)dcx`&N
zqS41u_gHDb-gLJ*_8T>S4S>2`<^e?C5WrcDmNu;~OQ>0N{C&Kwx9__rKTbt4!o}1-
zF}j7|#*rCiE*n~8_!;Paw^nO=t%9F{`sM%*p<^8a$3sa3+=an0bhQZ@2Y+FDVM!JB
zg<^KlpQdOkeelp}F~tBLd=@pzeEV!D$9{#`pt79AUr344ib>`Y{2f;DIBd-|@Sg4G
zSeCe3MW{s;Otw>|r<YB^NAZOXP*z~LVGu~#<86yKX=67DPz3^nPycty$!QOsL7j%l
zg+>;j$bnvqP!6^H;Wff4Cl%Xwigi`svoU%@F;(PR8Gav$8F8E@mpSbhRnz#9OhHoN
zForF=>VR{b{(3B8ww>bWYc6-TqQCU@^B~IN%lL`6KyA=_tH3@|f!$Prr2`mUaiq^*
zAwKn`W9|p~LC8ktN;NabF;m|TdG?4=Y#~eBFW7UMO9_1EaBl(MkZc$zYsWmA4hC@j
zHw87tzkG((zezjf;5KHLnRSFVh()p3q2icly^sBKs0{vBE=B_ns93$UoB$ud@WK+?
zAqROTgP8~|R<J+ZF&-SlBnvhpZn*~is*Oc%Sj)F6IO#qU7?LI}2!Y<0_ktn7q3l0s
zw~;Nj$l=;;2iXtw*Bw3{i`+u*?nvmuwHbh{dOPLGo*RAXdl*;y_gVyDW5G`Oj5Gqu
z(7au8PiaD91bOVjGN*U3kyY9augKAQaH{V{%0dkCklk`y=PMpqqWEgJJWu-PFC%NP
zNA4rd^NnE(_sCIN<uu#1M;@p>(uUR8D;u@uHmocC?b(Lq?3EL=x;E_eUb&lgPiq#k
zPoAlDI?F!YC)e<~eFi834J;T+!qhA}Y%My&PVJLVYum)K&kE!(DqZ-|8&l!XT_a20
z50A@kHz;@e<vPxPR6&E*@5g%FC*K>{&->*By~{gDsO^FXp+Y%45DHs?Q;^+JWfDH{
z+ephzKMb$u-$pjJ5c^E$;bB>!9H1?1%f2g=n}v+{PB8hLiy{uf^$|wFLv;iYKH+6R
zV=5hxLu(TFGCm{F?~J74&#*8Q|HW|MuD7Ij3Y<X_5nyn3sj20Q@wT=FcckRXYBH_1
zbO36Eb!OZFPSOhV$P+5l0okXD9mL56;JxP#$n`@g0eqeS9X_N2T8hkaZVq=q&_Q{M
zwB)9dtvU$DR5TvMCYww!<Sg1pM6nL-elRkxLvj<Xw}qJw!6~-37W|ZluxstfV<Y?e
zkleZhWanF5?uaCT*+*6tZO>@Q42UAmIUpX_ObtNHFwCa2$j72EHc(FWu*M!^QHSLj
zdZ>_Z!OL-qu@oGZ^_q~cT`1o4_ays?{Keu_95c=|Gk3z7L@%r#Z_j2=jvy+lKMJxs
zN96_?P-))+_Xm>1=a&f2)D3I>Oo4f^l@mS}9B|yzL%3viy<2%Rl4w|-WQaNfPFp*i
z-_<lAo_1AP&lLjk)lv2*q}%ig=CWWZ?B-E<a^+8Ml6n=o4*2YMO#VQFn}3hV-d+P?
zkMG|OT;&{%Ld2g<|L^ZccITM<VP%cb$3mz0VU^*y{6X)>^#upY17GdZTKL;<K*d^Y
zy_PKmtq7(fLA%9z;ya?zk`hQN@H!l~X5V`81Ja4*jZUZbb$6ro;a0g5a=Y3mwo*6S
zxgL|y6dW!lJTHhPFpCH4`+J?(ZyDn}+0GO4rHl~;F;1;usCU9qC%PTNux}uy#Zs7X
z@i|A{=uZ&(P0N*8ui&d8Hz0K8$G_kjZ`}e{%>D$5SGt9FT1i}R5MYqs;4bB_I*<U5
z^~%Bp2XqU5MTRI^{F|`?l+Zu+#W1g*<PN@nLb$=!hwk|&$&=}bpttFXK~4KfuB)A!
z%{KfbhkG^L7vm&Zbz1=)=SN{l&+2)JUHeIHr<?W%I-Y$3!6&)y-QY=W_%k-3Kk$lS
zgMOBqglu|fBq2Bv-qWN5w_pzbtc~9Xz2B+0o9J*ma8mxW+@Sh@SYQ(Eb3=Erc)1r|
z4Wvt^S4I|iQVt3Wg(6E*Zw)GE(L!B~+%$0p2U@M(=AhT2?C_IvjPII%scc%C5%K%9
zVr}3q6#oW$@Trq>9qk<>yLwU%@%W2+uJ#6AECdL+pOX9aT6!I*Oy8+3KYnG(FW4Q2
z!(T;4p;k9P48sQgSL}<w06=HAU|k<<OALYPpAxAB?r1C)!>h)yf>W~35KILif_fpL
zN}|qkH$Lm6bMZ+4!1+_VVoF!va^U&5uf8otsxEs563~S#yp->YPHKJ(3Q?}hOp@_X
zR}TQ`#?x|8jn7c56$~Ll)v?4Pd<vRp?Dtk9n|K;W5iG>R$EW3b+V|(N!zl0Of$~~X
zZmjpdVh>KkBVfR=v?!AOqt}D5)B!6XFcdcywiAxG^0+bGyflylq<U3K*RKS2bBp9U
zjefJdSuC?Poj;1b_5xev?=HiAlV?WuYY_%J8Unq_8M#qJZ&bFgL}q|m?6`<WsxEs1
z5`c?V1YiFG3kSo`Ai!R-z<qiKYxAA18QC{yV2(Y4WQSq%5;Xbhj662f?6Rp9Eum&N
z6YbRx{{n<-j%{tw!7C4#xGD-om!3uVU<e*gxBf~WR@UiHmA86B-ch0ZTdx?I?wq`&
zTE8nsCvhQVZaRmr49VY|gM}Z7WY8<fhAdnmHvN%z^&E`t!<UV$>3O+s@W+=`qMLF}
zklGUQTBx0JR+OKOVsp;J-8Km6aCm3gY^fFCW)N@d>~HPxW@^5k9KO2j%l}|1-@p$#
zcvL1t9fpZgEKWf)$F5l_oN0ZxfzzvNOhzbR#r1&%l%J*Mwk*%}rCc{jU2B*jz`cgg
zzj(Irv&N1PDSuPSDWEnvM<E6QSy&AHy$s)m&r<2D?k$=KMbzbU!v3lvPy-?-r~>J^
zr!mKhH<3=0726gb7x1{ncoQ1}nx54d*~$xYQpV{Gc8eOV?OovQR7`i-!4Cy_k&qiy
z%4d>uzNDEc>fXKx*?}ET|IPt+c07Xw_;{bU)9yG?uMlb;El#U5+4}kC;7&d`Dgg;Z
zD%LzCKuMmAukPuB8c-)=ccZ!p8JPoCQ=AW8R$6+PTH1@+NTpHOjKT>0q>>9oNte~z
z5jJ~K_LACMG_su+<t|$NELQ1~++7>DoejJs`)AAps}%|pj#7r40Tc=LI-FF`0A(7^
zt0?_mvkjtkXFf$bVY4(nNTeG+*^7pn)4$(MM!2=gbQHku92y_6WfD(<nLmcUh0PPc
z(wM}C0aOMyA-ICA1mZn6pFUg-e7-pU8GRtuA0-eLiULAw$I`8^k_p|`uK}tg90_9Q
zxD4lg@j*g^eMj&{O85Z@C6rW9%2dMX8|6%8QU*S3XB9&{9azPj2dF-e;F)9p`JUP}
z>v!mua8CdJ3XK=dAP!><p=MMoZAL?UwWL$&TOhreN+R%H(!rt5eb7;fM5XpMc?BRe
zvtY44Jcr_xEacN4rEkD$zBPR_H6?we_3&q`{uSB3hC(6|Dom&Gq$0$iQKkOA!B^yn
z%6<MKB_?(Ve6Xvp$cD-_)c4wWzi>rvUil(4Bjn$x6vKS4f)jPQZDfP5f~}?L;d8r+
z%`Vk3&&b_V&!+E!Qd^J~?uEfkptHqZ0#`x^aiAzEw_pQd3P(`u5Yzpuk=?&4`*zL7
zY!+qaA~QZ~Zk#5qT72%b1e$+2@OdLIbwqq-0gaj_4gKdJ3rg$?uDfQNa6ozPC&@+@
z-e2HleXhZ+JlHjcv1@W@a5I82+f_TIICr+2O<zyEdT6Iq%AM_nn2$5y_1Cb5umwWV
zc1;dw*QO#3;~D%qOkO%S8<&E(jKQ2v&WR+9_TGfi`3MKLtLCQ(ucV8`je!b3_!l`{
zYJc9yZvFxT$89CdLDyg9$jS@Iy_)N<z?0hcSGk=u5f8#;y6#tbfX_IE=7!#R4W_EP
z`h5j@6L$Mvm-WulM*vdqI*hRsMmFR+OuHx8evorr9#p$UxX>Q40MqlhbtK$0B9yTi
zd7mk0@h+U*Bt2N*4LPo>e!gI~7dMtMTN%D<kngK`B4b~9##&^E2_+8I?SGO8`iAw@
zh_}p;{2TIUX_F>~)w(I~*Ty$uzutr}zhz{uzsb#U;BBSj+{W7fCJ)j60U7ign9CnV
z%gf*7Z?sY%th&L!_wr^1x8$|eZb8AddlC`CG#B>C=-YCLl()~wmfw~eRm&*NM>BAJ
zEb>p?#-<4)@{4cFO|?$-ECGMYi!|Cr!`N4U$sM&VhFSjkOCGP$LIw{jmLuu!s$zLi
zcr#)i$DD~6ucfxP>6?M<<Av-IKLY;G2v_pE1H)<r$a?Y}S@F6`>_{w!z*{JoODb-y
zFOj!N1`Blj5*&6?^FJeN__rLSg^29(w>(txgCWlUMr{5?47KL29OXRg7sON<@5*t`
z6|UoH)?GQw`Ileu^u=BD;evr(xhuznTrxU!G&}!ga`7MztsZ&(ttq$cxNEOV5Y_h(
z$DH<!Aev8>19!og1h_W}!UcT99J@b{*kUy@c3YZ6Wcqr@GaL+W*7siw!w%D>&IKd{
z2*xg!cxc_x9?37n$vC`&1ah-Sfinv4U#>zTz2tlGVovv1W39m;pz5QU5DkAC*~5Es
z4K2io+kLsV_S7O4c^^kSTrjfk^p3yN@5^EI_p|%5cYpdkVxJC`G*|haz^ZnJo$mqL
z;#{8K)kp}zhA8kFyI)2OgS8JnjY7wX!~Q%C&!Eqhy@=Dz1*59=K%V4ljy<uHmv5s)
z33Sw|Z^}M?Aos8GRZlAXA>vK)RzCzS&AEy}e<=HfZ}iqV70{(7h_?sFfIN0QvR~cZ
zdgq*x4R|QGNoYnc(A;*eB^Q9&j@c?|J)tk4Q}0%r1&&P({jrDRL}E7|%3Xr>@EoIk
zFolH;w6d^7o3Byh(&1Wc59XHg2yp=;^<}MlaN5W+9?3O>@Hr}az7xf7tj4(Q_dxUQ
z3RNQv%&tdr<M1BHu+K4c{2mZ$4->3mCjx{72LTDX$6)eL;E$>I7$+;#z=ys6k%O8a
z{SZ9*Xa%vX)ZsVLL3(|+ledf1P8zyVpeioOnRIrCmnG{Txt2!iiP^I8UwMSj-#fsX
z(|?98I*!N-M?=~4mv_LxdLmEt9x5`6kogmaSFoTi$lLNnju;n&JVIe%mwCv6!Kt$s
zo^nbQbP}&yY^g^|Dq#$;3Cfnb8}PT_h<8Q(=9GN(dl$s}c`0>s$u?0GkDrumEO)f9
zxTkW>(h%msPvs>+FN*PXT-XAY#iUDs_NI@UMkxwS5^Lq3SmkFhYh=v)=x1^Z?Wy%_
z(lfc4>pz|BF}wNC<e~kVuk&_7?FYJ52TeI?g*eagI8OJZwN_}VohnP{pE~Kx@SfwS
zVm0IZ03!1283J9+O}Ud@@%8+w#JSB>7i!&aMmGMr+}PU$-wXvqIxOJ+3y0tK=kPEe
z#={@aAwynaV5_{4+g3lm*4wFo79c=+I55}xeI+*Nh3r>dq4Zki>GLbGr7z@W+8Lj)
zqc7z5obx(D+<Cl|eVr}KAfO^%%Iz~g{sGv4IyVHG2m&<_<&yzpK%5faS?7^hq^pMY
z5VOnsozZNunbgJdZ|TxJt(4GaQkM_<QBSdcnhV}FmAW~~jk?(hZYL{oDPMT8X-{8r
zPI{60q3iJDK}2N0$=}Q#+-=`rX?@xix_e+I`XTl^SbciF@$L{5b7CoiTX2Aw%PTyX
z5KM69Ci;?wt;<k1@+r;i@+JPz&WqS}c)&`;H8kg>O+OSL&pDVG_(+4I3)P~tMbUC<
zA_vWeS8{N*klC1_V4CRUMVmerlzsM<ytjJmS->4FcOh{KNE25TZ1_)3(>C~Qy6TF<
zcHF<WqYN$%LQ3hf*cBvUm7i>VC#O|$e7uV}H1?TB+0L;~DfPC7?a}aQZy!KoiPLfo
z?)C`%`d<xuPvYN5t^Uwh9!s2dr5l|PSKQT8i}psk@Vf2(`N@%SECUb2V!NGpsAo!u
zb@_eA$UvulfhWZ4R^sqcTtR{u>y_&fR_(&ycV<T*>z=#tSn0_+BWqrPw{-TUq!|@>
zu+N?X>eCHtl{iP<i0#YBl*Ses+2M-3gC2#-U4keMIaUC1Sdq7B^!vVd@=ha(7WM<%
zIKostc>?b2{YG}a0#EX8|8C`IC>J5F0Q_k0JAiK>i2yfl{Vw1<SKeI8Ei_twcBLVh
zk562v#4lCP8%cHORu*yNN%Jp_te`R<D!Hw}cdGFI&anl+MOGEwI^(DP*@%@&Eb5dy
z3fGqo_9(6;ctCav{mDsO3_>*hLLP)fxDaC}y{ZbL&<Bho+DKcBjn7!l5Of`{ZbF9P
ziLYW2)jFjNFo6C6=1Quz`vFwUO~)~EX$bkX6&gJpf;UuTrMU49HFu-ax*dWa(dqV6
z`(o~at+p$Ip5w+Fw&^!qAO%7UhkN3jvrY8+B43l-{1IK^+1-P#M8yo9@qcW;m{gV5
z^sIgulfw!6nSG_>o1ctqeN}GspE;IP8b45<m^%ej2BDGYDov~hRe2YW8nekO;|vlc
z1kJ_<W*x67J)VUfqB`zdHEu8(gh(Y)!y&&{=(th)4QD^<c;gyo_m5}Mq_2b^FkSX1
zAYuvxOG4G^9=t(Q-5C1#4^Rhe`i>U~&#|s3j}x9wK%Kk;MB4N}fzw5k7zPWtKNG7>
z9^6|xiwBDQ>i*d$C^!Y>a3BZ@Qt(%Ayc~7;awY|T(a{1hCv-c~&I9%`q*;F*P5po?
z%nJ`>U(||mBsQ!9Jn-O|9;rf#VaKx$I|X7sFtW^Q+`DGj7#NMXoFmO2;oC(?S*_tW
zCK$^`vixeiPOTZEs4F!gsypSh2G_Cr7|S-gvG@(c^vtC?uV2ky6x)BAkemsmz{Omh
z2e+BpRb9l71FAFAp91OFS|(zyYrs^XrR32D_}H--9+&L|nsQw#qk^gV!L&}f?p3<R
zunpC@SI^_qF<N%MMIm0g1z1W#k5e?Xk5K<LvJq;SQw`PkA*L18Q)LHk{R7f;*|}6D
zN52j)Iqn-%u$1G;gEHph6`9K@^O(zIyb<Do*eQ6lrcFmC2_uhAH+9wACm>B%&80W~
zm~1X4D(v1Gzu578%q0{L^pB{4o+&I4kv_2>PXnM@ivbk(lVUHPHE1eA5X`Z~BY@Y&
z`i`fFM$(^Jf0~>Pn+zCQU;&YoU>P^I;vhnO(gmT=nhizRz)Tb}yeo{q5(Y)Yp>0RH
zh_-!)KWN)$^v4{#7=NsX22#gwSg$p;FFj%R;&Rf1&9S2>f0I3b5Av~l4Y3CHne4^&
zI0~cTG@P8}#hZrg$9%(#1*noe*m{vfQKPfrl~B{7H6^=Xg?e+N!^v7K#hcgCI;~<8
zym^fpWwIyAR{ZrUhht0F25%mq{ca^IM6t4PGm$u9<!T>Zvp%XO*nLaI-fC66m+rG{
zhUSQ=Zhf(mCHU|Vt;<R_+J{GUZ1bf$ff7J;`I?0;RZ__nklF$ff0uDe5gEg#9JrBP
zCLlT$mqtK^Fr0f#Ofvm1>+a@63E1F}Q_;F?61(Zcy>ZKFba}}sr6n^RO7@sU+-C0A
z7}lIa@i`acGyl|JIi4oQjzUOe-p{){_~&TiWqgaYIyA}U`BUQ5q7k7P_C|!NpwY~V
z*5?z4!N%!{N?1EDt#qWk(!;s-N)MZfmWxV9CZbL-`n4egA4b1aui7bxA{$Wz$BWR=
zTEm91%f6g00yf?yl)ML&#J+qa<VKHSM2`!>MxZm6R=6>gcn*$`jVxme*p-ljoxZPe
z3yh?j4{wvYWnP4k2B9UL)s|cq7xdcnW)L_e3I^l>A{ZuDkfrTfcCH3*@6iG)vI#kl
zXiG%C|G$&5Exsmi+}_S$FxyW|MmUNiXTXh5<aejt#oLgVR$|IIuAX{weSEgV!l;Pw
zdQg+c)YE@tr*|Bw(%yBhdSHh2^joDtY%J4{*VU$e$iDI8{VR`H0m9D>oer7fQHy`z
zR<68(+h*3{{xv>B2~Ys`DcJ+pfd-pC{v#vXQH$4>ZXGbPYqfZ!R0#s6sy}Zpg?|FC
zls^yh?f)%JDqJBG@fH`)^XI;GCm^DwkhrDZ)UvAw2<lv8sJyy_1LC-*L)iGbfY=cB
z!us==%EMvaV?kjW{6W<Mc<LM1_vHof7E<MJjO--B!`|#cWDt*PGi*GV2z(#$*xXOS
zKU2XPh+`kBk27_0o<^N8HTNySeqVhHQSfZ4FOpiOpiM3wjS$DPA&A#@UNjpT|Ir{G
z)~pK{K4c3lR6LZpm+jD5ybOq10}Uk~=Qq(+BD)dT3)I~p-^1+HMph@7H|{jE1(BH=
z6mCY*oWx9g=g^<RCRm)DGd>SOEmagsUz40Od;`?}EughEcZqaGumN26WFc9rHf0-v
zd5X95mUpzZhhG_4h1xtk*zEq_Z35j%1&z&54lu9$T@}}R*XGPy_tiTfUTrqA--eCx
z^v2Lk?N2mtQFMs(r`(n3O$cxH!J5tQ)XPQ^$=wU#sxd6)459st`6}ACB7<xV2$pH?
zpw_qtb9JVy!Ur%ia*hos{&fW6+20u7!VvD~*419SFKV;DLU^P$bP17gJJ!DruTj}2
zSI|e@!*CGP;k{~hA+v!5Rrw-5afJ=Tv)TPRymo*m@)3cBg#wC;@&_v@r+i%?yLoSi
z9;<qr^PziXf(Y%ZS?irf);E-Qa@I@%HGC7wBRmIw0c%gJGixY9$|ayX9CV>PSgY;J
z+`@Qb)Fvo}<qAA7W7Fp$sW=*oy*S<Ui-a6;zlD8lt$+Kn`C+`1)CoN~8^)spMugaG
zTd<%Q?M!~=r%44gDex~7CzLKRTIz)JnHtF_-^e!9<tL@UOByz*9{*mt@R^a-uFqRn
zTZ&m|cY?ro5GEVh<odje<d$w^hwAef>BXl;_FsKIulBT0-)tzxc^HxsbM6T@L&b&o
zL<7wDCa7?v0Ur?k0yu}|+hl(aGzVJo$3!FtRRuij1+<%uME}`mp_b5tS)bF%$a+Qa
zre0HBbl`W_4vf$}D;lAj=tA#oeFP74u7@Yfu?UXKtaj}(vU`nqbI&87D92G4@STyh
zXv{-Ams5rpK5ieLaAZts%<D_qj!>Z+bEBKtC44T2@bfS1U}QHM^JUVY=_nJ)vx6_e
zje(;@U{U8|uOFt^zC6rXVXMG`o4FTGpeQ~NF5QK5;L@EH#alSf_!Q>K&L|$@+?Aeg
zMDYmcV0zLu;VJL;1W5@<xoP=W?=t1~+=-*?Z2I9qB4qXGUF4#IIRxK{>fq4tsiJeT
z8dutH2ROg0+S>&x4EJ`j>Q}N|O?YSNE?7wArra;!^lBiQ;#6rjN;vL46WeaY*(n@l
z+BN0PJST5_6K9pc9+#oAXFJMpz}dC0jcjjI{<$=9Dpot9c^Bs%!$8||G!K<H$o*P0
z50Q4jH>NT0&`PI=dSj&X!QmSl`1z(MCL8IRJp%*goRYGRLdJ@zP-^j2TUkCiXjkl+
zwnk<&^7`7XCN|W_Tk5}u{}4t1?x|F_%OHYe7Th*Q-n4=_R6iYvFER2k_f6Z-V_Y1F
z`!%;A!Y_uWN-vIUEURL;RwMm;47X7?<6WiCk7+FTn(;KP^NE!hl#wlYy^34ovu(vc
zy<iWcxV{p2;1la?%2QhMeu=ltZxTFa<{2c}QJbnW!G~tw(X>lVUrf84s+OaBquI!M
zw&FdaI=+(+Ze!C&BN-=_r&bqL0Iv|30lPu9tF3sXbM24Nma4Hl)cN@eJjKNFx)~?&
zgdHYpu%fXTXQt#8dx-@{clTHf9MnI!vS~j^7<?xsBUHmM6RFr`3S>LJN8`OD!7-&a
zr8H4fhy-v(Jf#FVrg*-FBH?(x&ApG{=8omj-ls9$9T^$;!`@sYYuTC`YA$#q&y*_;
z!a>Y6@|U#ce)YP%kuR8FD<qYSEEx)KbLrS$nSxc0*4)>->bu2XE-|uK$dmF=$fphX
z&>p0;Y6H(h1|Dc)_zhX|zeg_#1-@&;8%sWTxY>pWdHj<@Lh3JTLKVB4(j$)R-71by
zC6o@SEGiCK#V*XJ330r3<yR93w7>fnBU>BCCwgZkfv#GTjiv9iKoufEAH$g&4_)Q;
zH$oP*hYTJZ&nGllfoYCSGJ(yAh||ui!J*B8`7)Ky7P=A4qg(>5ZVN*Af|8)7xK%<M
zcbHtWo@-L0Va@N%dag~=L7=v4MKUZMW;WId%!VE@#7J;x=`ou=1=c%`ijF^;P{&nc
z%7rhY6C5Ium_tPn8{|uauZ7%}9uUB;;sicqY@bLCZ%Hx9rd;+_Ti&n&R;0&b7G7=3
zduW$MvB-8jO!^d(pl>^FXgp#eedVcjM@97n9y`p@0_HIFV{3u9lHNA`d|+~4J1FFS
zsD!M1>)L4AfqcCr0t^6ZA{KARu}tCPXqQgFs3g+k3HK1*eVY*fd}@ut=inCs7sRr;
z;DztjaYr4S{^=_EeTZMN7n`<!u|5gh%WW_OJK^?t1&s8J1l~|r(Ew9}e394%ERBMH
zCjpe@lV)TO65!N$Z#+Uw6L}lYFQA9+kHg%tuQjxSE3023|JFHd2_|sm_xNa^(I8%m
z-91(kg&$BEah)$B*pl~naK`6jMemEOms`S|iLvQ3G2O6`j$ct2^5~wme+2R>;f`xH
z71-KoUEG*NC`{hZP?5Ci-p+&t=;5f|62IltlV=M(3lc0(P*1(VZlyoG18BRF)$Iev
ztHz<}$F=7%+9M;`%=SF2`pLCIu6KloA}!gbf3m?y>$c;yC>Lqs4Yi+Tvq2`_L8>y^
z$hMmJkmx}}fjf$b{S=6SMq3EtJm1|L?R8H8(PP`d$tKk8o`v>ZKda%iiBIDG83o{C
zIOHJ-D*{w$v0CX_jHuN0%}O0UfY#Iw956oTbxt~*M)aR9%bh8J=(272y1F6)9}cns
zQC+3z!^kyMs7dPp#)@72s`d?5&VEheZV`T&D6Y!WH<-SJ^xS=^nBx?T&=2>ajWjZS
z2hha`Jap~AKNu6&P4qI~C>k6b^+qqXFf-|vbI=qHoWoBneyCm6{3r}CHY@d6jtcg)
zbx0Gf{}x<`GFv)iW<;^Tj=YBH=ehs8shrZy>3P=fm?PzFMxas$K%>cX$Ce3lIll}|
z3XFph*pUZGhu0d}rjERQwd!D;b{!Fc3|l`mvX>os&90Xqopn{<PTNU`9b$)RYB<7R
z!8+|_Auz{%2=G`k@Dwrxl#X5OsHG}_w3bIRfR0?nF!eLC5y{*j#pB`AWS*j(jM<gU
zCpX?SM{VQd|1vQLY0n3(`B<aT7i#)1NG>O4P+?vt9_Udij=W(_Ko2mOn#ExkK_^Vq
zzp!ujawp!w_h2N!BwH-@bjoX}fN5~t_Jk9@MQ7elS~MG8!_K^S>)%?d9<Ig?URqT7
z5y?1>0^+-PuW)sm*Hif5(fG_Kn&Lx90l(ecT6JTEO@)`W<Ogh7K^bfiT6@$b6V){(
zAC@;7I2Vh8Y*-f_8d{6dY(FA2wz{Z<cEWQ4?OZ~J;NMq)nr&V9dy=NNkv-|cQ``m;
zqa)UCKvuUD9#^$~BNaUdUjRKgu``AHNCuoBusekZS0C5WTM)!<by>GM=J4GV7)^^H
zqq_3i`teDWFYs*lUVIIMp;uQPPDL`h@&IY%3@H3vxsQhd`&6)LIJFBpeFc4I$GUQZ
zyXy>K#GI&E?DA(zI3c_7_c9a+mf~a#9R`uqp7y0`4>{wpPK#_1=@x5Gn71^rzdjS=
zO@vi?KRgx-KtkiFBns?R3y4ZV_DWljR_Yrd#zu#N>O3l9osHe=#$8()Bg9u82*+t+
zR3Y5*5QaqbrH6mHyljCzEhd}O+$Q35!1G;=PS!R6%er>wP1w=y+}l5k((XN__8rLA
zn6h@!jenZym{3s=WY4?vTGE|yM&{dt*YYVL<qu{KZNGkUK$8lKS>L<9k#+3B!=eig
z;cDO9>8^=OGCY#Z)1V>i+cgj^EVK>>!-D$>JpZZn3C<Zomm$xg9Ddn@*Y5nFCyHeq
z?qgp&08UHGen(}^>6fiNy;VfseUfRT-jRTd?-}2N_Bhu~$~m6|dokxfD4Y|)xO(y+
zw<YKn$-Nb*z~X!I8qveCfi)>N(L=WbAl<`*y~~|?_(Xox6S2j$yo3u%uw^~LyUp%R
zu=Zuj>3}{N1}0P`sbnjnO621+8o=T{NXkv9W5POS(NPV#`jCT-L+&s3memV;yWVSP
z1tk$tg$rH&t|ok(L4bZT0Re;Sfh~L@-qwRarhAFc6rp&j2d_t6C-&jw)t<FW6O1^I
zfkfrpe;pZ!;D3{P@fPme>xqH5jMKYD7@4IP4^7xvmb8!<r`YN3mWD55giqk|B&-|!
z`VXiA2d1gSP5Q#rsVIu`Ns(EIOjgtz8h!X#I9Hzc=C}(I4|V$RAm`4Bz@4cNZ(03g
zI8+dXo_(46WNx_Dh?|@G@NUvJwBt@6-n=!O=Gb#-)xy;Tc62Qn)cD@xOxw}SA~FGR
z<<x?`RFzI6$ISW(k_yGn8;EO#%|XmmU*4_C^BuyCddceXk`?sj^+u<CPvp`T?qb85
z(!4V-h&iS&E`jsHu)3W$;G|y~)9-!jPBjA#t%}yAkWDz_4t!3q=h#=#Xxmeuo+fFR
zM<iLA&jV$Z&P%qTf3kPYf|<}wLW@Agw$SaE(dFz=&F>7>hkWt-O~*I#BYUp(>6=E`
zizm@<i{6gebWxDmaJwyt0*(b_XJMhS9D1H9=aD!_k=Edj*+MU1ewOFb+F4LP9z3We
zT1?lBN8u3nLg>{XUH@YjwO|#Q01Dg=FA}%sQv3^MZ9*6taxTesGVL}{1h(>+R5?1A
zu-wH|{uN@#{gZuapkcPqNdxKk>UhUyu%dpv_P`|=IBG+rLmRx&26dg_?Ix@YeX9xW
z{(qW~(x2<A#Gp{=TGpig++Tk`gVc5$5^Ofq0z}YX`UNf9*q`@kF&C`ztv;1{so%tD
z_BzMT5Kbcp@a8dQ_aD9$?nWzQ+5=b}&w#nQ)7(H+onT<p$r9k>9QRv`>FDw7ORrkf
z2uoSr=y!PP+u&2?CVAC@_F@YSfqH5Sz5V{%C5mpZ@v1eP@+2rFw$O%{W90)PnmCaE
zC{^zOf7d`B-fEN&N#P2en!nPmD158aU{XmUyDClU)_33GAA<++@1)lzc%ujN`uZrW
zdD+j5FFUk5kEIOe8!O*|x&+5{$zqtVgSkmE>5Z)Y5N-<A>uEMYJ3;^yw4=_T@T43Z
zvUSY*#~qSzPAq>2Un4~?gCH5oV=^iuwY)o~oHIn_IQ89=`sxn-uRIf#%kuk){JZJ@
zSH2WL^-unv`MK38e_MLv{|mrRqJa5r04#DCw`uY$kst7HH3qTlC8Ra^KSMgfErg&}
z=P2yFM~DZg0{-9wH-oSTSxZNM+dcmtBd`RP6Tl23c!z)siE1UI{e-$W=o$7C>ZZW0
zw0;EltJ0$_G%*}`20CMhM)1%+rJ(GhAL2geqSfX{8cO+b(pVIEBfqilJNd<as~s(-
zJckA20iYAa5MTgGCt2P|-bUN-V|HdF4~$HJ5g@)51UWtc%P3<1=IS6~Fi)*>Z#fRC
zm<mCoV4s@4MHAGs%k!8>>2vFyl<yo;)P?b(KoK1UE*8eCsSD%UFdtTTG;h^^1_%xd
z;25aV1@J$J&IGfg{#&17*Kodu@DIU<Ek!to_6y81YE|ibf3RtKFD`-CvYg=Zn22QP
z1`g*K$#5st9?7uFi$2{CYQE}fQX?7ufSE>g9yf-^YiF-!Sz~wuY2jd4n`3xD#=hT3
ztb7IbU&eu+nP?ja{mV4vzyso5w~;p}y^E{qSbL9}NH*n6_ci784nh~u=A3uR|Jks-
zJSoO+lqVdNDNre_^H{F0U~YJ+9o!$I$MTVlKENtA#>Dl1@_Q9$!f8>#7CO3(k-Z+v
zLmGRcj>DM`rmPGcEnCTyb<DLm58hsfEc;sZIC!|6`(S71I3DYJ>jt6V6kHkQs1`I*
zIF65Ok_HU`{$|)^w^FB>%mX09gkcMF=tVrYmDDOFeh6uDK_u>FeaG{`W$V&~<9V%y
zg?q|@Ojd<ZY%<jjDE}k~6`@zwReM;a2@drqO@IkGXMmA?G=U%WY5FU*)gKW#<rQgg
z)l&UYY9g;w>B28Wa+q+ea3VCLWLSbF6M1*($@_2!OhQ!BHy}7DS4Gz6*9hJpLUqRy
z+$0{1*sbTqSc97cJ*k#j-itM!%v*Z@*w<dEhNvXjD`ifG5Bpd*gi%iB^{ei_N&vqY
ztrD=>E;oRYrl4KJk*T&Tatd!Moxuo<n8IuOZtY_q^EV|H8Z?Cuk(#0yTJ42HP<c!L
z-@w5|(<86YmuiB#%Td85P32+eL7l&F!|PPuQ%ZngC+eaHu1uH8+XejI%MKvwG6C>=
zQ>kH-QYp%+7kn<MJlJz23X^VYxl}fZ+09gRcw`p@qo<+6?;{6ZVW_c!X5!L#2+?zM
zqUSW8>C>^Ny>I3E3l&^FjR(N(SBuKknZ`emw)ViTvS~b|`t=J0@HpHsrIf`Ar}5hG
z)c0wI!q#a#)$4NicYuO9Oy^O$2F)Gufhf1>h>C099WH?BJk&1`^@t%(JpU#`BvOf-
zfhC=*7{>uKxWBX;59u>_ptJ@LpUvQ*Zj+!gh>1DiP#*j6#11cZ3;F14j1kSMG?R~&
z3cDf}dnRuXumT3q|2c`Vt92%D+!BRf&E!E|z9>wM8g-U%Y!^zAv$!|HNq)hGzmBtb
zGyfzb@wTQ@h3$XzXgg<3Nuh%xJc}D+S0~}4xmlB-x(g10yVCd2i%nmPnq!_l*xD2;
zDB@Q6(xcf(TG&GCq!^j!Y+ldnSr@e_rZY4KO`wTG!yJ6FzgIFc$|NSSFtUe1eISpV
z#8>dlR8Zvz^svh3V56DcZ8ihGnf6NcL+|PbP-UIVpN-JNVW1#^>UMY#s1C*hp<4gE
za~Y}~Xgg&N$05RBgP&sN(w3L*;6Vx3aZ$+}gw2G0%|4z3Ypc8h@r9dncn469M-vQD
zWI7*NV?C4tVy$Asb$MBIv(USXmm6}+y2*;tv4W}ZWMrL|fM32yhBxkYOWy`JU?!EX
zPzY=KXC%=ysddVct^hQ1F7MKHIC9IrNyJ~K2jsRPpC8QqM@^xe%yzcF-4buEL_w5-
z1K(l5APw<QcJ?8S^a=pfvbL%a<DMMVq*ccX*ahrk>6XEpg|&?WCh2mEdSLHpDjY|J
zN85vVcE8(q2;DMx>}Gnlm)jdD4>EW-s6C`HQ0bq^zp6E<gMF0BXLk7z-^>Jq3x*Qx
zJ&!kTa9@xn3?=wr^rqYl57nwAF^8_5p<MBN2q>F056i{oB<yRM2P!!b1*})(!BL5#
z&}<Jny*=xY2bqLdvE7ugKL1Ce)^T9ZZ*&SgHd+ha87wx$$5j4_GToU7ByT<sL$4M@
zpjUh6Bd#P0H7aEBKH93^u)$f}r@A@zPy<LRJ?uRp;BJ4-a<X_rb<`HJ9C12?;88JH
z`px3LuB#f;Xb&8~9?ov%Q*#>LXmU?DPHpT1=3O=mA{X%So`Ij2({pFgv+g1^@&(*S
z`|k#JVgc{qKJyq=9EOQT%?--Na?#a9%$#hv-*!M*CEyiMMz!TwUN#S_->4xpG}@na
zOYF}I6tCEybq)KoR7BfCD<cuuzL_ofbxb|<zwaWR;&UzGolzBxebPcWqqZbq-_SxH
z*ll5HDWb?s=s4IaTH_5}E$+!NO`82e9dm3~e{XODePehU3J@m_o^%V;<2YQa7x9`E
zY62{{YtSNEnQi!2cxj_@+x_oG6)xf-uI7flQLv;cD>>1pA@g0#J^d=7Jl2<jaOO>2
z+DK8alX(OVz-c%$-pJlt%oDu7feJ4$QBJ#r-pCVUYDqJo=kH(4>!1a_!_b1_#k_~~
z6gA^=cq1^ApF@$Dn!`KBr^UYmrMydoH7K;D%G&4k(6!7qrFz*}oH2SRZ}k!&)zlf@
z(j`zz@5I?z&1pOks|n(9@35NBkwirQ@IWTcRNJrw+R@hLutS#cRz3#gnR55gnE|F;
z*#m#D!KXFmU@q_9`CyxOGmWj0Ht&!xRltM_$8KMur~8FOb63Fg%O<obs}20%-jC2~
zyJnTkYkBnnOrW@wrk=xjf#}&>9_4Osc%nZ{bhCf;5MZm(Qr<O8p^v?(*+RMQ@|OYU
z-#~Mu<>n3%@JcS_VF{yAmRhoFzo2YYD3(t*sJ3-&`eYJoI3|O*iYLy@@D*G|6=`+R
zZJn9>d%4;n^#P=^sV9i}a;%XJGIKxU?pS-n9M!M9^08|20DFuxoNb};p$-^f`DPyN
zml;R~^*|iv53>v18TFL9gJYcGnYEdD-Ac5eu3}8+3<=A)pU&LyS`fE&%6VF%qiM@J
zA2!rsE0*!<wengC!u2I*^?Rn=ejdr@*|=dZG!x}n;W9qFiVh|0Q;tP0M*!#{uy~@~
zl;zw{`}uh`emQR_t!)XLXgO~jII5*11p%d4o<Nc*w<)lewwiTbk{?_PYXYI~maC4W
z5{Y^IJj1*ClNKt~y|=fF)1>6_rOtvi+|1*xHIrE2hul!7oc>4T(J7d)j&QLKg^=`y
zDuOk-i9z0$86WbY*d*cN8t84gv4TfvTvQBstmHLZ%(1)ty)BJa@*x@=0Ft+gH_)WA
zy{q_8S{ZzB2A-uh?@?pY;8}_tS7IQ~(#cP>toB*Haa<;?$Gqh&D;;&n#osExnFn_*
z2|C0DzF`=>V<w^PIuDm=A5}#Zb45s|x68B0b9{T%@(v4JJUGYYw{(#Iku>STJ2fql
z7rCT)t7_aOzE$AZ^57C5u5pZ4vkbn%r%LWIj$G7o^A{fAqHSVa{X4JeeGtr+I7N%i
zj!FrO{GIOyVjuj@KYx4o3fu4pH;3%6uZEN0o{Y4jBw8}x*9b&J#|Vh!quxernY+aY
zO1)~sh`z;JdHU3*FFm!6+*D>ItiH_`MvMT@OE&K-x{pgV=}@4OCS@S|LHv}1{5Klm
zIJe=qsvImp)?nU$av#r2K`Pwvjb(6I+@Am(R<|5*Cfely*e}8nu+r4X9{mZxKL*+X
z_xcNf8D=dt_^%D+fHVK%OQhe!a7Kug`}>>)65{t!pUYc0q6v&CE3B#s0XSa6%IkQZ
zzD7Qr8&>vNIULcz)!-DRJ%6i#xj;%e%uwhz^NZ2I7XFS6tmv;cu=l6sfIaT;MbeR{
z2DbJN-z|BdV($`uO0qmNu)2TqeNskaBkO;c`>wvr`$|>Rmtm6sQ-kH;U9M<r+--ol
zG4Jp*Fnb5*0<jJOIq{)^)qDuZ&42>|Ip&ca@>g{nAU9QChDqxm7%Xl7A;|jR{}b|4
zYV#em`6;5}B3zA@2G97{TFDhjmtOD-(iUeU`~D@us(PpozRd3x?<h^P8Z4t<@#Y!?
zHyhc9wt1fAXV@412blU>2G-#<KJI~-F&n=kX>S|YuQpz!t!iBLy)s(;<I9?8lpa#A
zKMa-}jdETaQu%*1^sOnJ>8vc0dj4u)m0grir0KsJEL&U@Nh3vFH?Z$2DA%RDYX-Kw
zqS94rr9Swwmlc(c(&}FfmLyl@mNw-6CD=aiVA}CBPL`A^%1cT5@Pfh8S*K_;lHLsq
zt{%#5>C1BlON(lXk8_t#4(my2I=sc8p1p}UjAsUj^nNg{C>F>4AacacC)K&z@`eGj
z2)<r&q#!Ub-=;U6rV=)5;gn39WrJS1q?LyMY+$o|l~>Z{69zW3hVoFF@}t2rzNRwI
zx!ddA;)~&*m3{Gxd-TPEf9+okMGgfQ(q6jHFNn_xYfOCaxJ|$9i2A+I(L}c}t1WSX
z$~moc;-G<f*H(^8(}2$3YAYXVq%nmCOIjVp*`@c?eDT$FE6cuG;}(6jDVV$H=UU{H
ze%1S@H#=DfNADi>qn`|PWOR9!qI$|sN$O!Su-t~qUF}WuyOHv{l&KgjgBqjXgV${q
zA3n0A?89xZ(ue#1X8-UZ<N%!_&=8lmwK_oGK8m|rq>g5<413Sv{rEu?v+nKT*Z}M^
z%x_AA9JQ@<kO$l_u<gw-$cf(?ENh$7Ah%p6+VDYUSsQ-CnBkm<i}p4QMUKNDU)%9!
z|1rqc&1(M#cgVD@Zmm3eOD3&uqx|zmy!wtfe7J_Y6(67>GU2MBPzz|MRIMmVQ2eB*
zX0O@31jR>dHL!|_O0e`#+t;i?q7qik^Nay9Ha*`dwIM|6@Not<G*RgkY(@wRg%cUh
z+8a35gDB6~u1sSnN>m!^pPoW(L|^2T-D#AFfuUO}LcxmcmT_)HxP|pP48xm6UF=0A
z;#!m5Q?jL}m~_wHQ$jRSr6UFwU{bJRe%N4%H7OR2v?X%^dzz$7k_>nl(?RJh-O5<N
z_H<C9rEPe4)Is@Da>2vej>;Hm&D;f+ipff_)@|uD`tB**?X$<gqB|=Q8D5jbEU*|5
z%X>Y!`IBT_`zM&0|4kI*4u2nV@P0wOBYI+``o0bCrkvAazwSIFCE>(Lv!1D?MCw?z
z;5xM+rZ(Q~Xiy^#+PhN7!Hv#J#f%CY0Zn-8g(8eacv^smCmMGT>i^8sL*S%c-UXYO
zNY<twbeY;@I4?3>g457cbL{UmwNATnrWF;j-+-NUh*s8RwOCCQ`yV%CH~7&Y_5foQ
zQaDbi0n|QIPCAy}(w`x;Oet*~sX_1NZ`|aVZwozm#o%E6iKW!`2nU=FkXTDy0M=5@
zF4Zee*sU(g6z7He7T8!u6AQ4IqGY{A=}g?RoU+nDw=6dZo4<Df42!p~S+<3)-R=mT
zWp-6QlsvB*m{&I?Q}R#@jCE5!@dST*<8}<~af2nXyV6V}^<HIQnLU&`QY0R}>Y*&~
zoQ$(@9dFX8bkx9F_f&q7hAuZS|6VBC5)TQzl<889j|{A!ml7`BUtzFVdnv;-o?XGe
z9PhU%2D2R4N4X@mUus~@`YJ(E9X#~wt89|y<{FshedSxJF5rFtzS2(meVM`X@B7M1
zji)DQ#}Ul81qREy{t9B3ji~<l0KoCY!{Gs#Ho1V4JP<rkx5mKY1}XZCHbXG-RX`bJ
zy}Vdua4J587YLcw$e>*rZuY$El=l^0950aA#gMo{REXU*TTheW;$Uzz(zW4V|H|N0
zG99q4BCYHrs{p8Eh<&?HUtz3H1(=d9$vGtmGpLBNHhrZ-NQrg)R2M4K00kO}0@j0g
zt)*7kK1+Q0zd`u2dRxVquMDi=V6e0Pc<4A-X(&bDVfJ7pK&pa=b%T|b(#g#Rc6G2)
zGcq51)bVl(m__T61YU=;=sZ=I6@s-9u2G2aR@AC9L}@0O@GxkI;uGEoWlMCl^kzS1
zDs&XQt(oYU{jv+dtBk_yhbXm7C0_zCb_<ooY;O^VgPcb)rlz${xIJdcmgWvyFbylV
zH>^4&B1%9sL}=ohzXUZ5RlNL`6Eu{#5#}g>RHG_#sPY6}iv^2i+$cCq=`Yp#0s?WE
zvaf=<;m}30&C>Y;WxXbJ*XICXj$P4@u>NYVDtuyP@p@Oh3Qci@au2|^E&wp+kxGh`
zvcbT5k5mo-*orIw3m8Sfiq{KZ2YVB+h+TGIe~4Fq@k+pMjutIDp9x^Uj6uuBtuwHe
zV@1ohX8_piu>`ErS^@0$?gT7Zu>+HO&}*!CC18c)l{M0w*_bC2AOi;AVb%mCN!m5d
zU^zNL>8A;lX97$vMU6%up`+cBHTQ@KV*doL7fZt|n52a3KOdk67W4~K%4pY*8Q7dj
zirls97?HKC3$oOk7rL(&4I8Uwm?<M%(0dCt<LPKo!;3Q1i4cs8GM5U=oUCL?XQmri
zg(*si^erADrYMc1+EWc|z!asn^xqT%n?FVQTN*LVz$Q;s{H1%74eZ0IN&|iJ`vP=S
zr!vq-!B@^qRle)087Z<_CzrKT`bf0XPtAy>47HtiR)~zRMu-}RJC*@EgN(9vT8dJY
zt{SP|L=gNmrL8mp?HfG}t?7)1oN3@e`4bH6^faKo7%jdxP1&lS&`W^)B&iIfl^E7^
zB|mERFp;&{ge-(!Vh}@?i)O4;Grpt@6<w8)0WB(T2H2a_XRLvR&r;%~@o31HS;`1$
z>lgz&Hw&uCO??09EM=?z@NNS3io`MyH*x_x>-SetC*Vt%q<j`NdyxA1g!0c*5p(QH
zHRDUluzwyI@HynoffAQA&cK$XD}$uvBMt09y3$<w7VU|ci}rXRW#U|L^wwhymXGHu
z!5Zn{a0A<y0qwK#A_JR|sl>IP(@%VMRUDwx_Gz2`$A#jv57ms7lu=(~{Get`P=`3T
zO<8-^EHp4%rcxxij54sZ^T5o~hZ&f5J}jKMXhYxm$}CAU(qOqbUkTJmi-s83vn*ww
zbbr2q?OdS5bWQ9n+Ay$HSsOl@FWRtM%@{x#Y8z&$88PZG_Gnqwh9Sr(qYM_84U8B*
zFtCl;N^j}fFoWe)w$ex|&B`!X8ZK5=Youy}4eV%+5+h~wGpt^sbdZ(|GGILgg3x1-
z!E$VgQd1*+($`?Qm8*nlI_~TuTG%hTtRXXIfvHAgc$#(=St(7+nlga0=$4}0okW%k
zWz7~Se3WTmJ<Up8&v29>#yI_D2JDecWWwcdRwhap`T=vx!2MZ2gC%a6(n2fMpKh?E
z=PCIb>8sub7P&$hDc$Y{%XNj)N_yQ3he)jesSid<;71VXANDd>-up<=X{7M321}on
zXnsaQd(n`;8k9BPd5XRH`x8ahFZIisUp(2~{P)zX4=GD+{@fXY$%z<can#*~rmCO8
z|8a&xJcM0QBt0+}hXG`<|5ho!x?^L|W%C|a_*<;G^|89TS_uvrgpUaqr4UbQX7~E4
z!k#-%ST!s{9$zak2n9(1O?s4}#(Jv2&9mWeb;A~{c@wAUrN1W`*dBnDj^ly6tkM=d
zR9oN0zsq81%2faILqhnQep@usJln&%FPtJuUfNOv;2ZDgn&wjwhhcehMKT^>sJ*OU
zWtX6o8g`(g0kn+xgc4lZIuC2Zu(zSoBz_a>nTd9&-|rhAr2iUk)YRt>9H26fHA-lM
ziO3R7^j4dw0}YirxvzDjJaG%N@c0d016CLgo|L&p331nmnj#mhBY%zJ)#@^6kR(kG
z4%11cd4-K9?yA3-?m8sDvHe!5fdetQ9G0gLK|gqdaw}kgpWZ2HSoF?h%~9K*rmO?6
zO<B)frmupa`VKj4=;un7vyPsMKUcz>PuA2sSv)r?O*B=ehmnx1w8#Lre99)JW3?gE
zL1YkqXb{xAmvaql>n0_*g4uuD_yso0xlPI!TFDIVGHbKaT?)jY7Hw8)dHIe)t1*j4
z6_*d{>aP@U=c?ZLRL!pxpUUsJ661bQF4frQL*I`9IXiZX+yar?m0nuMvk&sP(#-iE
zS9IcMt~_%74o{YYijrNyd2|INcHFD%asE+4V&#2GyvF%UCp>m3P*zob!?a}&jw|h)
z*FX1iVlgL_3C`E>Wcm7pvQ6Xs-7`GC|C4e@`(}-lQ%Z<){1eoeeoFbm*@fx`o>qE0
z-+79s&x;gKW<ISPaSkhc9bKeEJ9o6dCOL1Wy7!6{f9JdZ;z@T#Y3}@to<!Y2XB30;
z9C}@IMrrGOik_~YQKFommlX*+t88(8{~u(WJ*#we-bPR1=ad=F@sIJe>6|i66T)hq
zSNtoL5kHGNuRM^xh&Nc8UI6d%0V|;3sjNbf#xs}ch+cCqe1OUeE-5KN<+#UPF%G40
zh=ThlD)rALrH|@nPPwe?m2@Bc?d8;ESj6`*82jSU;`fU(+i|cg8?Gy>ou&5@4VLDA
zC>u4>mDUE!^;=3cjpPqT`RKN?UP`NLU@QJqlC^VhSZ@BQ_-mz04GlYrl@yKhy6gC6
zk2^|7=i*-hebXJ~h9u1oGO%y{fgaQ!4@Lhdfl>=RoV<qz-ynnK{ypWgR?@$Ww*2@|
zF={+tg~Qk(z9C$xu(%r=nCD~VlJkTM0DkYWk|PcG10DYZDLJ5~9dryH1ZX`T1n9>#
z3>L3{6<22|&jpPAxl$labTwFRK37g?q)intJzgq3CCSt9|CsyoxGIb9|9kKAU?{7=
z6$DvaP~3t0fGY^D7X`(A$pzOm*Hm081rtj|lp=j>6<gFai!x`fR*L&l8fBJQD%K~%
z&|Fi?^#0ywp6A}nBCqeiKYao7oHOUlnKNh3>@%wT->xU6_x<Adg#UJ_CaKF^h5z?x
zm&GW#{jIEvW#^>(UhsuR)>8V~D~@+DvJ|6~?HQ-OWMYk_(Fklev5}GifhQ!^N;>U<
zsRfDkNz3&>-OB&62qzxO&m4GUuV{t&_7JLXbV4Qi0l;Hz*gTEu$5v<A(cp=fIm$mk
zTmo(a5J%-T3U&OQT@9K%(pU;wKb`hz5p4*fk<(f)vjBP0VJJUHW+$tzE8K8nKe;=%
zZ<Ttp&6TTZwh#L-gjo2n1D^!bLp@LUyrk_fcT3w1)%Wpb<+LHQKHFrf;S|dJS+Sh7
z3(;N;U_0d5pFx6NW_H&k@A?G5Zb7Vv{1Js-3}PvAGD7@x5Q}h=$9#z3y-;Q{%IbFD
zABM3^c`St%gtG;5&NhT@gtPs!{R2eY6~R=g8A(}vVj-YmWmg0bJ*OFKTtm#F#{o;5
zu`t=R842BL#v-LLL6|O&WY)yaUn_KL`O0vyzO^eF8%E*nv3uqh1v4%<_D#FzaaqU#
zykGYNf#`lU+U;#O5C2n9iy~Q*CvmG%Bpp^*VFk78dNz+}FW5#tvBbF+oLRuo^BApm
zPN%6yF%G1I0rC|En?EatS@&O$z>M5mhXN2$#>9+Q=dFqw+MI<%zV|Fy%L?3LQi*+U
z8||3Z**AHlsAHNlOVSP$3R;#>RWa<1L<Pge>DQ4m%u!FAPAqGQ<8q2}LSX@9nyY_R
z+MG2F&Hd^j-iFD>z501W&-&nmmQPRoT7HN&W#i(T7Oas}_E1sVw_qKN@#<48SXcj%
zw-rpHP?eTNvN!)#RMvuZk><UlsCQbhrP8@gikcb4qMCMF^AJzFYcI|ch28w{j8dhI
z!GJJ|g?pOq0OKUe<fpQ5$UBO)3_JD#RROJILboH$pO%`RVWg*CBX@idrygj-I+*Ik
zsnc7s$mXlxUyf4?37IfhXe4n1G}2t8)}<a*+UMNSw%&)3Em=gXBPU1`XDi;-_udYB
z`4QPc`K&2byKJa@tsvN$hnirKK&!1=vDOhUZWTRiG>#;ePY%5@;1q4z);M)RE7r%q
z#abkTI{>kpTO9lU_#Z_rZN+l3ihqN2L6FYT<-z0yKozUYKYCZ>Lft8Hk+I&Hi!tu#
z_~mCI7p?CqhAR)nfwP1})F9+`Lq6i|5V`#u_Jw(P9K7Fmf)ZGUU*g;ojDk)+ojj%(
z+>rMxiE7fWZNX#xYKmh26=LV%EKxf=gidPdJt>Rs<-*)bsklMQUOs;vOq8N{=uw&?
z3NBHDRk#{3G18}kUGYHE-<gSyg6+7u)`AVitV?W57B9{JR?$lKzfD3Xzr({&FX~mN
zPPW%^l<eX=ddbEgh3u6|_DH^#g$om^m#kXQmc`e<Y(Rf6KXUDARQ9}tGP|Pw*p{tR
z-0_XcO<J1C#f^i>r-V}T6YjsEz<&QUA>F*RQmZ|gra;RNj0bb<?`X#qX)C1uu^sE@
zx93X*6VR8_au-HX9W39rNLAXimZq#l>bUl-M-xAC5fjON<jfv);A4X0yku(bpLp#8
zRs2wU7A4JDrKs22vw>M}exVprj2DPuOi7Bpk1uLy<&!2b{umsfwwpbSq!urEmB<55
z4-19~aD8F~Hc8Xtt~a4ae_=EAey8k-h*&sjgi}0pe)G*M3(3eJJ22MV#?XTasEQRL
zZDf1(xXL<(0?MLUnl$`3MU9SO4Q2is+;3V8Ybpf*G%tp=>`7jph601r(Y49z81pl|
zH+GxSqsk4lJU|a8+=98_*0lY<Mp&1hFo}npTzm78N(?i18GeL_4*6n#C+=4AVc7a@
z-p&G0ECDB=h#MTiiOO0ly#k9lYC{Qf=-jRu%lb=oepR+Ci)F^h<rfu0_LpdR?e%<e
zzK1^Osvdk{MK~QE7$;&{h8fh&7FH^)xuB?v6&Bgj@s791g?I=GvxUN^R9-8&0e3@d
zCDkXsZz!xm=OgQof!qMxv>A7BffsDh?NvZh^V9C@J^?EetKbl|Ou8x+)SMK@n)w|>
zDT<Sv6}UCttq5Q0f;bi?6?~znY8)F8xsFUa->o@WGHwT=qNKA9M{&8Cem6=8iX|YP
zwU9Q!W)tICZz=m#MSUqA&U+*3lY0j?+q7b<y0`-yX!>1IzwW?VOMic^sQ-3=F3#Oj
z)RP@qC)3@{s(UBa*VK2VI;0aDCXG6ys5?5b2&n@CrJb0$Z8+RL?sZyrXezv9rPXZM
z=+y$!g0r6OIH0J>ofCq>&wUT$tm+_-0z}Rza2T9ON@vzIAR|+&+vP*a_k8z1I2ml>
z?9Ad5KDq<8dAKAA&F?6b;DYb*`Yt)*{I<_YI7;PGC#}3{bH=dCi@2VHE9&jeEXA)Q
z)o~gK{vbR+OH-WMzYA-S<swD@Tv*=zOA?GP`r`mHzWON7ldn+f3btgx@(P&C@?0w|
zH?+l=xD$Ou(a#eN1&W^TgCR2WPdmXwJMG~dW735M>Tg|Guz7eHuvOOO-oL5YS}!==
zVq?|4GS&COXf<#jjVy6#{jKV(dg-iM=~EWk!WHHNNI!#bP;>-tour=B{6==O0r7cP
z*4(r&N4?mUHN^dD--+Wiy~<G&y&6)t$egqWbmFPdHD`q{r5^K=8|8~~w4QPFU@F64
zv^*{aSMLutgRgdB^*Sh4)$+|JMMF5Ie7A?eacXwhO<mN<XySygth{B6T#;Ioz(TU}
zK#GcT0BtCaq}>-U@K%Iq2i4+cXvh@~Bq>c4(9TZ;Q#c@PT{ibtb~mw~H(?e?v`Y;l
z$5I8(Pe>vNT_S9cOa(;rb!i<p9D@1O(Pz4n5?Q+GqN2W%$YLU5-wgnv*MXNr9rhQg
z4?U(|m2hXLqW+f1+Bd!R4cMbY*L@(hKcZNn4lC7j^ks1|?^Q*O>&Av*xQH95_jO~~
z?H@N{=cm}1-;J$lwHK`#ZMdYD27SbZA2{}E<XScRX8;w*Zx={hC@P7yk+zm9>NiQO
zfvLp;^^YWU0_&cu+6mlrNm1jI*%T@1OGVw7%mRbo77{wnRaGuLwKSP^mCAosRG;pw
zk=M?bkzw(g>FfuJ+Oa!pV^04Ixx@W9qAM#<?SNX`orQK@nn^;^!EkX<uFoElG8+np
zI_MneFK@#+(i)gOvhd@|CWU<l-PuZ0mIB2Jzk{t2E0JSs?l||<+yTBlSK_tHgeC<L
zCg0owk@VT+H;*GuzSr+BBExWE`h`3Fg|3DR%8Jdv@2HAz2fQoKj>ZoMiqs!_vHjAU
zD4sWZvk}t%lZtw`H+x$8zCuwa_F-egALJ+oap|4@Onk_$%AC*!_F)mezg&hE^4gw9
z>s=9mQd&R$vz}7Nxr#d6%GwQF{0M!vFgmDS<$MyPbek(O@6cZ2XXsaG#|%&Rp^<@T
zqUqSv;B@RLqa6q4Z54`P{f**4)5S&Vbt?;%vk_DEO<_sW7w;<S;1t%l?jqFWd^f*m
z6m>}oYZQ2U4za~#+|ly#-ma-AwKxT)6b&LQ`?fKEwH!Un>Z`tLL|+!rC}OK3B(a+r
zB&@1OHN7u-7#FkA>doxS`pMR17)gH7mo+vHhWvEfVqOPp-f-=(@8r!@$zfGE$~N2`
zHCG>6Xy4YO^yVy;^XY8T&;a*?n8QIIUyV*>Eu!-;QHIb~jlq2(Ax9Ataj~Hm9WL}P
z#APRR5i9Q7NzIEJu?sC}Dhrj)?o-q)sVq@ih(LKNn^}2Zpqi1!f`@&25_Tq1CdZnJ
z){>4FBPHi08e%%~IoO~uJ``3;?o#9pJ+fgNNvN^Z7sM$vvEJ{PIxkIQuSk7ARn*D-
zQA|EZ6m@HV))xnkY}}~c>(7=nvMq6187dhD2T$#ARwT7x0E-P%Hv~{kcn%TunvjHM
z)}c4GjN;7J;`E?6xRC~J$_?^s&fZo!3u`kLjkh(AHVq6%j~T7%5qspVO_htqnpX#k
z@BTbW^x1UQU7HZVKIZw@J7xBGp339Cxb6}s%043YR4!%dtWj1pI$o9U`akxqD2@64
zxCJ#ecMdj8n0Gy=Xfx{j+#%pzYGv_oC^C!ZSMi%#aypf~2GMkPUd=+tw`x=OskpcS
zw_H(K5SzUimJzcdH4{yKT%wB5Fq)p?fvi*Dob^JzLl9F}Z$q?z1?vZ~^`^_W)eVDK
zu}QhDHX6cW)aM4Xjiw2==wpj%_e~9WcL>WJ=(Py_D?4q;p11{B&-ZF00Kz^73P{4;
zERj%aAoPUh>=se4EOgMeKuo9U3}s!tN@r1wC1se+IHjl!hp`aJwop+!3}a0Kf3^XK
zmZx>+%0mFm&<ta}y_#!;$8d}nj_u$ume9V<A?S<xbNUS6p|3!X?gKg%D5FL2pc%d>
zfWr#_#uK&bGrf13r43sYwa;+YK6tP2v-irqJ5^3iwBQB9(J38Rtf+g3v*Cf^h*+uH
zDBk?=K##7?2o@uEdl9xZegx|veK-}4cLZA$HgYOuL%UHtKfxpKKX@>4^`hOp<_ATM
z8OajlZYw}GcO;8#TmUDGq2(qtO2^Rqay++KkDgnk+v*kd@JJRN(hbo_H*4doN(+PK
zzN6ScV~r`SIZwhrJStMuPo89>k{j<sCdeJ2w~K8}M~K@&@&%43DsUUhHMDqeM7D}x
zeRy<HY<t6@@q-15nmU?|mb0IM+#il+E#)`nAoSB{w!nB^O&^0XLgGe6eP#@6AHEvX
zUVZar{W1&O@((vqtkuLwBHuTLMfeT<1Zg?pw~5)!F)Z5Tu~}_8mNl0qzKs;evhIGH
zi_s7z!enrvC??F-qHQl4%fh8h6wiUN?1=Q?$BLRajs=ITMWakAx)@zUMQX`7w$&uh
zSD(&cqoqWqsK+zdbmK}jZakZ2yude(XWts74`(k|=S^e<rj|vj+awkzb$?~KnlOn4
zRrantV-mwfn9|G3)n6vVOm=NtuGX8v3Zw%wmg8_ZW`94*2m2{(vfqU%B+xgh^jO2Q
z)LdYc^%VO?dYGedzp3mCNxJ*3qJBG_%?xiaf&4S>awLa24L+;_XZOtI<H?zf!kpKb
z8LUb2u6F>JsNC{;;o3f7>yCTX@M0XEU4BE;!2g<3H|x}=m0ckjHZPgMuH&f?%n5!v
zi#=tWs0PnwBaD63d9ztk(DAVt&Eak*5+ZNt*O-ggnwEQ`e1iJbY!=$^)yHGozN#AM
zu!B_=RCwte*3%e%<2`CcN|W=%Jt|+8(_k@g*ID|LyTANTZkfwQ8Ks42v<v33P~&X%
zqj{`MT7ap(m*=w=q?^dLKwMFkOg7fks+;<1CJgWAk+7BhnXI{Som!sBUNm`+Q0FXQ
zjf_QV{sJ~eZZZn^zZS44;}kV;A<LHYiQtWetd)_gM;5Z#vJU||En@NViV+CSTZFim
z)HfHgr%a275-+nFyqE<U|5YuEp`~B>8;jYWvhgML#ieYf^x6)E-(3o|NpC}s1GCx7
ze%rQV@~liel=oba-TcOOh2P0W&Cnk>;d5SKZyCjoMc*72)9yFXH#&@08&MzO4RMY^
zyze=K^mPRDVaAl@7swoNzuqE6ot?w1!8=j|92e%K<=(fKp`fzSF`Ci=29$%*_6!6b
z<gh04I7H-)SFmiO?9&gy_g`dhni{-o4KVbb=(*l%ylKA#AC4;qGr)RyE;<t{(V8#J
zWnIFaoe*H?o+lT;Sx&7qqPCkaJ&pE5EzM<S|2{9n=XP}Y+>09&^?ojk%7_55HP;$}
z#xcs8J0hC88qV&6J@VSypcCyR5#tW)`DhsE@;dk<bVSPE0+cq3M%E$I^;uWdbg5a+
zUWLxtmhmXCw^p&>lqET2>u1qb7YnFp7C>V+Uw*18rM?ppL;M_(?p}1la1GD2N_`1&
z-uc0DMLX~O<8rErxSre1HJ?2vk9DlG8i>6e)$~=LnWbkCn~rBS876?>?3#1!p))9y
zMYnhTY8HZnE^D!r6|tJN4?wR#yHUgKAlxyA6{%R;nz)*MfwL|=Vh#HZ`&h>)YMlbs
zG-*4gSyJ*A_*U$9bQS2F;gVNHEvIbb+M30}XyEtk=I0Tn$&5C5+0SlnuvXy(1+2f(
zCp3`=v`wftpHtLpFSAVPwK?d+y~4ulemqK}I-%yj!k+Uzje>y(&`h#jj-mz?Vy6CR
zF52iqbkWB>Tx#bd3R$|b{_RYR^zvF%B;gnKVU1AK-LGP<vfU&_z40pR<@xq(A!qr5
z2TO4W)H*iS9FQP}?JGJ%lM$jgUSEvC*Luw68W5ReKl?8tUtGuLw7Sy?v7!-+#{0tp
z3>CPl+<cFKL<(S!u3jk0GcaS~(6|da2*kl39E7^`u?C*ZfHo44?@e#9AobhzET+{n
zV1pMf3N;%%vUdaSNOqNAmqi+<yni6ejV+%Bsy$S;IB4Ne<Y#(j>6}#K<&^0^%n=Ld
z6NW14_bP_1g&ooD)pk!}41@_tsG;cw*0fnZsx>uBlkZoO3nS`9;?gWMX{(0_(L#LY
z*lFPiopdY|jasXyuWn%dJr|?*LfJZg55mmJ{<MKAzs6=rAyD_c*P!nI4Oi4{ud!z&
z!yrWsd!4Oz%a428&7gk#Iy)v!Dpb^G-(bz8FVQ*K^afMvCMuNk(lv^D;SCn)St|M}
z7t6Qa0e7D_S-RBdHAS89CYvtR!I-P`P1aUgx<Oh07N*|((~+aMSWnLxsAH6)p0`1i
z(a6?NUHumGlZMV0`Dh_E#pLo=Z!xPBF+fopyv^pfi;0DDwC$r})AQo7Xvt{f&fjSP
zC`$9C7!<3v<!U|b()Kos3co!Wu&M<!6{A1Wh3zIKtbQ7#25w|iB~Rr1g^kd~nSrpu
zjTo1_g1~<p*&EXLs}=S2A~sPvm8GoT#F_?KQKhW;yWFAbJsV(0V2520{S-ARVR~Q)
zZZCyUQ{guu)cp1kK<kKKnyIKWH?fGU-V-$m!mewDiH8$W>GpMm{pg+0)MZEjolx8_
zqx(DHV1HvA<Id$oK>5-MLaGxG4qI(>0*pDuGT&};o~q|N%w1AP!TY?!f+PG;1Ig5@
z#7VZzK}@@Oj2=rmi*lLu4(sl=9hP`d-Tp2cC;d2BQN7+{g{?k7R~;=4OqOomYk+GP
z`k`n7tVerLdO*$dt?;*-TV*NgiTBWVDn#d|<@>C)|KG67ed&mzXCr^9qCWLLvq<5H
z@z(n+Bd#mW2;`g3w}u*#C5UuDSR2jJ9TQYyW)k&q93sM=o~uBy#%^X^L#CT(2Gc7C
zq-Y+?wb>EO>bHJYcNdL8LYDB)pCI{cGwa#zTQVussYjU!Da)5e8Rq+><S#{Ie4Kj!
z=;!WB>(V?E_q?LG<6)M~x3IS1M|#3}F7Mh5Z-^{_K~N_X$=Sph=k?KwI(G|;_G|&h
zl$8AnlKN;1YZK9-6|9+ZL>r}>3`6#)V=YPvH=@FM|GS0lk;W`gIN!>)8?!F9pgPxy
z$~iwFt7iad<u|}|i!XtpXLmA`e?FYtT3U%U7gyNPb6uHeD=>a_^X>tJcvzwrh6uee
zrg1x&C_vcy-#-GMhu;;SQQ&{}6I#+Wzai2zqr``*m$tD6($h(hYa8p=U~7*6gXrJu
z3wW3pj)9waayvWK#?YK3otvc?lCqC(Ov<)5To{(*!;bDR!)&zI3nY480LH#vfvpuj
z^g|YG^o)%}wrFy>@nnTRw}W|_{3bLdjs1w4j*cEKo1CbquYJtgH@n$Hz*A|8;V^Z0
z^WE-hAVj5+X7L1tU;UWXH+uI=3^43%D2!$|?8)O3wx-d`;l9XO!qx;x;nVXU?BXrK
ziX;X}K8UgF6E;336)3T{$!;z}J*Ss|n#s^i-rxv&00K9ICv>DJR9t9B;T!sV$~t;)
z5A$^l-#Y-7|0x^hF}W)hQ$i9@>R+ESi+4HzI^nuJEL-nnG2UBJy&Ox`!vLGLleO?Z
z-^CfPF<|fRWGNn_0RyuRp<tHrGc!xO;30iJV<p~&ot+Z@fhP9+XJ~5+tZ-hRVXKIO
zz=&PUGU4-10lImae@>u$Wk%!Fa|G;lC7w<~r2-@jvqpf#6}aMlEaLj)T)>?l$;?=>
z)S-yE5atEM)ARG=O7sbKv5;P)2&T>8f3#9?jkhlEf>YnEMBiQ0A`(f6b`YbBx5(91
zv_~!kt2D-%c>moItR$i5K7cJ@EHrXjimt8-+yJ35vw#_+s85KfZiu>%!CF0^SJbnN
zHT9lPNUgj+e@Rj6ax_Hl^Dy}4tYOpEKwjxb{chZfnKM*$z!L&o6r({gl|!X&y)kjd
z*)ws|I_T^mI8JP9w}9Z*z!zb}x=7S4c{Frdg!-bQwzaWj?{o1W)lAX~*z-0P*&;O#
z1v^n*W;Gr|mt1EM3I?kwvL^O_D-`vZ4c4-PV48Nn1ni03tX)$-z^=T2h?R-kx`<~W
z;)va>dDOp1X)hhyx$+ZOIAXU%Qs)VyB^8F)n|HJE9?2vZ?$!x(7~JdV$hF$TqP*L=
zVow4rV-JgqyQ(-jG)AwQstsMVuP5S@Lsvn9+Ywi^f6@Ovv4=%^H|yoB0Y?FQxQBK1
z{-LK6wgj*~pR<J?t1LpG$z}+2{BzdM+k%ijWw!4HMRofEupWq{=VUox$zQM#?~i*p
znT-PM=`UDs@6)k}r`c8=!1jK@R>_Hgsi|MGVDH9+)yye<nWE1Bl8vfweHL7(K@&6k
zzh^7z#V^?eDI0;Fds*)`bz%ZER67h0DE}1{H*b0bEurIR3ED^8EsO<pZ&0wkEYV{~
zw8&6<KV-<h7gc%(TFAhC&~Qb4XU-M^mbQ<z=opOH`ld@T=?4FbhZ@|Ix$#ON5^|I#
zS>EmT&b$SI`on#w13L+(mGB>EWzX+pao%o8PQAPbSVRenue;rkymznZiaM@@Wq9Yd
z1DR&9_m*H?wFHCb!EK?Ye@h_dEW&C`Uj;ULKPztX06l84_2$YHsMlHk!$sSe(35CQ
z2Uxr^9wD7}>GO&K`5>MB;G&sNbs*3cYXqwEi~}spdl^Om`sSWCfNeOyHhBN*<y6><
z=%ptfWNnppZJa6ed(N4Hcr?CJExX>@87mT$8xOL$);nCVU!T<qGr?73d~!N##{3eZ
zsrG}cfp?CJU=z9*O%JgdW8d&}iqry3u55JqKcAdTjl)N+^u*yxqFt`!-eLup7~joo
z?kH7K#U4joyZJ|qc&;5{LEdv+uulN<Kg>E>B3-cQ;B%!MoBwJsYw3#A8-z;_gIRG)
zrzRo*d+#u7(f)ZCtYQ(E(L;DWS7nwu1Z#(m!$`z|e2Ry|j6cP2%I^q^k4hzK>f~H`
z<jOo<Ih+vY;yVPf=Ny5FK0z?8N;U;-(-9Ua{}=@opE$yn^=W{RuotK*NgKCLT&Oq<
zY<~1A>g{;_*h0wiX<c8`4y#YEf5iJ=ir&b_F2pM4QTA?18$@$3vudjoXm_ZWr&|Wt
zp%?E}(Oj@Q;{I56y%#`p$JqNRiHKH%T`oG-)!03Z6ztAE@mO{vG6lP~>TAbYgL;P$
z7yEw(&o!vKkF$04BE@&x&z>=;BTlfx9<7@RUUlj?w4Q?&E$J&Z2<s@Ba}28b6>Bf=
zXiDn)iap(UC`LzA!Om3j6@kK?pfvhZw4q<KPV(s{2)*((YvZvBA)qG9;D7vU7So`=
z251R@rdo_!Fue0U$%cF3p|e?VcKHbs(a%4LN$m@b5&GaHn<bB;P{=9Pw{bI!hDeBS
zs|Z0wj+DYF+KZ=HcX?X`LSLU^jpW4?x_XLrY0wxUMEcL@O8uqTikk2Z8(QyDIH{`b
zoEZl7&2Ly?y`I|l>FJoED`me*4Mt*A`z>o&r&So0llqKXUw`G9nTlc6n9`KIVWMBx
z28R55s7Ry4?t@E<VLbPJ7{(b6<4KySs5#%V#x3lKraNLxYkPx_a9){-!pCDz6QK8J
zU|Y(!tXZpXX8?`o6(l^0+Y@U!)t-66LzPByxT_#y@OLaeVwjM@>sgcN+MYHj$o0_c
zdlR4|=({nh%6II2X><zaR8F&=k{N+<r&&;kKSQdR;OOKrV$IDS88e;cf3!>nL4&Iv
z;)QBo!L9+k{70u*q(>%*fl3ET>sy|B8tcBNS&9^ERn+d^v+)5JlC+|u@ovvtT)dw)
z44W&yXJe!>eb8u~VV$H8ELcbUk+oExKf^pC<^&T@uXpVh>ZAYi$U+&h=^F)>gkkOR
z3~N?D2(h%9Lmm3^sfzl`8P>3V+yh-mF^t*^aGf7m%W(gOuGr9Ir9Ec$$OVYh{|6S>
z?)lLe#8Ic_`yf|rG-*>Q1DWe-;Fy}*UMyU08my>=Kd_j99laF8C!zsLfn$a(;m!#4
z><?^(Z?i-}wop7~ts?%+AK4-)AVy?$wA8jIIwxn@=iaj$=!v0}CZksT#F84{Hw(3%
zz6X1%>5K*=+A}|~2_BhRv~)z%wU23^yFanWI=z8`y)FwM>M!L3*x?*&()2*2v-uk{
z3C6{Q+%z-UE9M%iV8M8U`usUmo}U9ydEPw7I(hpLAFbDT2?MF$&at^3xBZ21r~Y=N
znhMOKpIPHN$AEF9>I2}epIQ5E9hx~){ceJuYUVyI#kv`IRJhaC`GZAI$Kmt*9o}UK
z_^C~QVZFScC(fE2{U<2uf?wD&@9TbmX<mQdcy!{<vu57LJ5C$T2du++7L{b8c+}T$
zHIoCzV>@1tAbUw}kD!D*z%9sdBu?ERULO=%-z5@UHlAmVz1t8MZ6e`rhN7N2&sx^I
zg?R9^9%Buv@d6v*eeRYs^(lxm_5zCy9WUa%pM>Tw*`}R*{{!!Ulwvn_n!<NnU^9%8
z`yC5!RK`Y{q)9g|e9^C1B9)f?W#O%VXA7k)`3X@UqOOYiaOqE~59^}9Pp{kKJW%6t
z$x)|AR-Zm}hxg?Q3#$D6NCgqi`|*)VBjj@J`!#%vS+KMCu5z2e$08<XDE0z_n%4&@
zVOn7fuD9uf&-wz5HQChMn^=}@DdKdcI8-i}juclG^wZ#PI^Y$aAl*z~R8k@qs3Wyl
zr><DkrB_&B){LHzHLqJ<Z(pB1Wew+g;&<>|PkUsWHgIu~dz;hmIbMiEyC8ggSY2eS
zl+>bajl4#|N?RlI>k4-E$mc1~V*5-JHw<Eh0Y$D2)#k07x8PdU2c=`{sbPOI_k?*J
zK!J17tyA+Sm!#&;q)VRct4VU)MP$bdKIn}9h14ZvDcSy`)&5oH|KJ!(Fpbd!8(scn
zMUB=E1`Dyz%`w>?*9Eb0y>w?q4X<D^Qc5!RmsGIdrG{{lU9Pfj((slTrCw!|{b!S^
zFl&I>9kFs3SYJ{9zRKFjSAIoxi@e6(4m#!Q$kb31G9_#>@-;U_{rMW}jh$-y(QUKl
zCS#%`uIV3SEavSuJ@5(-=JF%p&#^v&+4`1lSop=84>`x@52zR`CVkvix(NTgEC_cS
z13*u&DGh{PXl*F7A;u0J!1_I)_5?ss!S0+)&ThV3oMf!1kA$L;P)C8;4-B+{KB~B&
zEMb{o>D3Aez%q7<bns#hy~c}+OppsaO4wTZ%Ue;sud{2?0!iVIuCrj1IpdMPVNYF3
zFmKFO!McwTgX3E)xKk^%gz(VlQpP1dL@cW8B1U};Va5km6^gMNs|bh74MJ9P&)jk~
z=GoVAB;)7*bfPQWG4jL-2|T$Ix-Z3`?zqKb$8Ec4G3?D2^8FE_PkD;FCvMQz)|A{%
zXsp)%O0~+9w!Xd&2>?m-@G|W20#&k&ic?Hdm8Cc>gSLU-3gs7(&&1m-(Yq7LEnYE+
z{L^mXt8TLuQr*G#{h^f6|5?<adu&GCp8wG29}g@%{~p5$+xNR*gXDc!&+>mQ>dpID
zmLC7Fh5P@*yo^~}?)n?%KQm=nm+tA1Ddlf`O~lur-uUW7UqkVgIs{)W=&KLD`p{P}
zeRU!n(TT6tL`PrVgbVGO>9c~KJiJ1amf2l;0CDGzzrkk(4JI|!=PhZCof6;Nw-~O>
zK+OGRo^?x?-*1=MS=2zW*C0P`6Ns=2>%K)j@h^+1dlJm;<~jE*Tz<fOOcAHzsFYH3
z|MAIb_b(2L4kt3PBLHLA<hvHt@{n1wemhIvjp}5~cj7!k6SIQNqIj&k;u|<}1!$~A
zwS%u}`B$3pDl9JdCyOQ}$gJeaZUl%%34M%xJy*tpDB+eU!1N!5g*FBYz3<Wgt_3aS
z-HPwQ<`!Xdvyk$snD4F>AnVQ)+%=hK=l4b@&_e@~l$exUf;7P-Q3Hy-=;tbM{ifS{
zfK+rwpbG_JG?D*6S{3!Q@boh-@sU0@3nB~cHFg_7BMQLLoxEZ<2LNTY?*~UyRjl3o
zkG~Lt;CRlx;)E`cD5Hum@MUmNQ1zkvXpVxyvA883VBx<#V&52jUiyKoAKS<f=jZy$
zuKoN;W71pSL268TnkONUN(+F%7I{LPeDgE`0s;0W<P)eR&J8|_n1>qC9Nj*9WKbhT
z9c|)G1{^H6RN5z35OdteSSq&B*Db}iCc_GQri8t~Vi_Voq1AONIrB@<(cVrd66}3O
z_FdcTumvK$E)S4{9$Ih=d(kd4Us9I`8Rd)D{0-`B^>~8(L$;?uJy(xECx;Vkqz7*)
z-$#hQ=)seX((ix3T0MCm=?w$|ynyUb0c5fl4>Q(Z{3lX(O~>^rQDeM$JGnE!>O0;%
z+GE?_7K2Ze+s;Ku<GeSIlvh2EP#qs0El)v+clP14B}w|#!awxmw~Y1OU-vYu@^oLB
z26tpm`yUeeIDlJ?@{->Wd|>8QIieGqi&Xf-UdBf~(LyD&dOh=&1f}Kvif)Pd0ur7W
z%&*8-&m)u`!tcuMenF^jBcA9J_KK&W*D4u%L)|75P;JD&k-z&HoSzQmJ!I+Q?<{I@
zWB!6<`qHAtHQ_N?><gHe_Smo3?PfNU)64gI5pb(M;eG;l*^@EkdzAy4n)?IoB=JfW
z;U8&rQCxTN%Ow%T>r0&>E+fz&Z-|KBAXc`x;%lb{zVkT>bduI8ihli@0&dO(gS|=c
zFn05xTg1}bLrbXwO@TQJ;l0{v5JkhTa6p7N4%dLb0HSfQVL*1vqNX(Ezh*5f74kI!
zh8~RZ`WES9NdecHl?lWL_!jN6SS+<@z+V7_8d7tyln^0639tU(PeN@2rotPZB}e-n
zgl}E2i}x*6YZR7dqttE9cus@<7cF?g;8I%tQ}*QLzhec&ZR=^2Q_n~~scsH9U_X}u
z+p8jZg`D~w5Jk;-V`=9ei+ZRz?<k!`z}}p{l=TE~kl~&UX=+;;+gztiB!p^+yM(Zc
z%Hl5&UWfKjZmIhrbba_25j|du&UYg(4CHTV-%lVi?GsMurG0-)_>b}Zq4u3+C%{HX
zP=^A(2>gx|E5;*m2mzEt#ZZKc2$+gM76s6#Xz_7G*lZ@kCJ4-+0Q%?VgA@oy;5!P?
z%KRk+;Poo%A$(1Q(FMYJ_irWin$^;^JI(yfDBjvA?K)@SCtC7zCaL6tMcvYdHwo(U
zwa8$TQ~sKx7r9=4!=hel!{dS%!1)SunTdeQmB9C?(QWw}&qrfCaUsR*&^lvLgHN>O
ziIVH4K;IZ1khS$D6zuGgbpJ=NqcuV8F*zZo0*~c5Duv{+j)=`S2PsQ8@F}`ZjxG7x
zmQ($nDp{)P-l`ujc+X#HTS;iz6zX_T<r8wV`TthWQ&Pa3fHwcLxNhRsy3f6i`#XA?
zw~tn)!CA^!K3(2_=LK;s)`m()#KmP;8T&2j01J<ZIeGg9n3T3H`jBJaI1Wu=W4|3<
zV=q;?O0Sh*J86-HcWW6+-A5>^xkEkh74Uf#6H;^USJW5d2^8};zgkpxg}0KQz6Ckr
z6&@i?`O~6~RCvpFgW#oT1@)bYOC2W)C{^q$`ku-?-B>wUY+_Y-X<+I#^zQNO7uJ{Q
z7c9$eF1usFDJ0(1KX?bx;kCfre?{y20y-ln<9K|F-Ds;|`SFMS@yBcVhe$Wy?JEAD
zZ}H>aVWN&LIb=~=#q(g#0&)>pb}k!_h264vZjD-WNYI%zx-}Y|UGIBbhc!61vSxJP
z<8Z5rT|Ll&<0WaaZTJR)(&u)I+NdLss2`27nl3pOiBG_<rFG;}B|L$w+B))H(vOcU
z>pSsSDHwpbPCOy_FBA^8-BfH5!!#PuU`@V!2*B#<PQ0^3f#aQcc-XZUurf2|7)8Ev
z22-<ovA|wO{f?T}Mg6p4{h{Zzti3;WDYoAC#KwW>&U~PB6+Ch}^N1?D_0){6Jhc8s
zXwFqfI-%~Z>B<{PgW$w=bmdKw6JU{5>K-m&4zfqG2LS68gU(18_rpqQ7mPi!$G*xG
zu+jt`T>ln^L#||2U$>}T5_q`u&Tfl3CV_|6dF3|{6{y(>yjj9jgi~^VOv(LQ7|S$}
zCgVXjr$u0#{O~X26Pqo**50E<Hx4FYH-~}Ur3BtxGNL$|C-M%`fC`J6k;pp+tv;t|
z=9ed7i_Sw(NU}JQH>+>OU`Q`DaR2q1Mg2XIw~;D1`WoGMlX^d()zf$HCw1dyc_|D=
z9odbCH0lqN)343D2%jM)xyy8O;RW6J(?(P5*ZjXE{=nGj%Xc6HPC#07Po(Bv!o%HX
z>3a+&<})$ibz_94`#`Yap)XJ_G1cfEJkhlGxH_i?AL%-v--C~rzv_#QOk7VMBX6eA
z(>-~t;#1;p*i9pDa1*)0tJi3+F&2!_9a<97?RI4YUiWkEtS{}!!v-z*s&caAD=_Y-
z>#)rz<A%dMwE;3Y<;Z@B3LrysDh9#=7+-^4P3pyW3|@FbB#-k=&U-AX9jh3M7_JP{
zu?srW)E>S`SEl$5|JwPjCiUih8irCA!jUf*J<7GHH@cfvD|BM(&0|^|_|mD9d%8}x
zqAAyA3tWWUw-2vxZ0`aH8>ddL%VBOt_n@-pg2PO=@;>t9-bm~XE01Y#@pETljsiHm
z+rodf@`gsaY&Uv(_7q-Zl)Ksxe77GzWR&MKSk&}1zB`NW^2ZemsRND4E3u=a`gt33
z%mzwb>+uggjxgG50YV?Ym-c-@bw!EQKsyBpokzq9*FY;P#q!iZ*8s}Gj=>o0WBd1*
z;Ozn4`<e<{0_pD>(3^nGs7BH+>^RoIJ_L?*#NDj{{Rl{B=k){h?`Ytk*Slm~tAWY{
z$Q#LI0pM`C(F6D(dE{r%&Wi(hWMni#K5YI%W75j`?slvFxV7a8tio44qo|e+;BDlK
zJN*so)A@b*w@*R+Uph~cH&Q5RAUC%juue}OCo<6pCLN*Nx^)sz4444LX1rE_l2;nY
zhst$`^rwORhV1tVLMI3D<UuEk^`ctoS;sNOiPZ=5(n43}<{l!>=IH>5y)nq%I1MyH
zfV7fK1xOr0$QX?5wgg|54dzW{6NSzX=IzX{eFQ$$&v2>{LwG-V&c}!}dk9aJBPg_Q
z2yZ6e{|KQ!hVa<HJZdzn5sE(4P(Gwlgoebde6?p$C`QpxJ|gHtY7ND_y%xjiFnotW
zp?N!y%#dMxu&hvM`!L>E_MuSeFy78@^L9tlE~??Yhcs}zMIAPr_itp-B4}=@TBTD<
zhGU#{dOMhTjzEsKQ%D)X+XZyr=3v_^<~T}iRXi%*f)QMiCs61k#A)^oV(UK8QQvoc
z;2_g&YyC(*S6&rI#3N}WNTF>bd2F+9wmFF%^>^3Ss%j`$KZ=i&-%>y_aTJf07gFf8
zQ9QcquOHMPKDI?mS@*u#s14fwz2#SvaC}VU!fP|=RJSL2Y|FVW4i4EzX&kCNYzWKD
zcoI!O7YmX;{3NpPPoalT^7fsww$>10@@64~s|gT8cY55G=@PsV3-ZaMc}zF6i`*f>
zgZCZUt6WZwY`B<oaWHB1{uZYU4kmezXM(pK`E+w#4H@OIMXdu<Jcjpc`@wr6acwHo
zVM|W=xi0_D(HIa+X(t?hmqD9rq~1~ELamUq2jF1hD1{l|p}snn$0S{TzXpS^-+i18
zDqVW(;PRk7xVVkumZW(#xr}@a7jfPeBT!!-M`rTC!kHOUO)llsTc}p8t7oPWi6Jtx
z{=FKRdHyjB9HRr0#A%q@+c`4Rv?iCjkKs}?GyTBAnVC=Dts%>XP5*aherfB-Oz)Zu
z+B}BAV>2_IxQLQD{Z0)rb{EwYqh@9vw5gPt2{pM`AH$`3$*cwstz_<Qsv*WN8*7U3
z*vy0w7s^c3@|s+xJ%$Tr;U=Q{s<sB*KNI=TCfAB;q<;Esk$QyV#VJ7%=%g4^lcGm8
ziaC=w3;y9{nndZK4=nZOMXS<DlYy^OJKlE+@bLw;(w70BHDzsWc;`raVit|G&r>7r
ztnbvbbd1DLuO$4Jwc?ix{9BL3ccHgYB@toCV<QlL`Ad|*nCf^neJbA|H(CdOe|0K<
zN8a%jLPaxq3w8H2Uf<)V*Zrw4at43YGt>A=sr?oVVxH#d%?_b0#?hH8-7p%$iJ_GJ
ze|5ts2rDM%UK1og;E!51i?{W@=9AL|k-#SY1YkbXd79+=kwqOhoi~w7j%%P0wP-pI
zle6jb)NF(fZ9wS8Y#yx!%-{{>h4dLSgNHR%5Cxr>#3dLeQ3ua%-U(4$TE$t-89Yx8
zeHjGy8T>7I<57f=r4AlnuNR^n!yn2`f*L-H_mi5uYf)#;;^`9KYEesOakIxMr~~4j
zAgv$^9pqL=5Q5;LYDY*U$=fXI^x3?*TzpuAhp5G~d9Xa6K85tQR}q5rDe`m*k>HV0
zz(VlY#ZJMuY^^M~W{}x)_=|G$d=S-phQBYbK8Vnz`8-Pf`5E58<I`7!WFO&=`rk8L
zktShqY?;eDdUVt<ijE0V*UaVN@~a1kJd^h^eQr_zoy)^IjDF8TR!7rhJ*OO9k%8qK
zdLhZp8!@f9E2iSxdUORH1EHl_nrL$yNva$$k9V(ezO!f^UnhI40=m<D{+>Lxgi@Q&
zyLl{ME9A_=A0ej?t_VaE@g*gPo$ha`-RAN}>Z(kbn7bBL)}!izPud5{Pv-L8(%%^P
z3dx0EeT?K6_SPzS%QfJVwcs(5moDH+)hP(yh1DQDeIfrEC)hCZR3jGiG>=|+lqs)H
z_@gdb%zMiBDCZ@Md0)wIrbYF7mPds=2avYHoE~)LA54w73{y>imUoh)i6;M9-Za{s
zqS9Of&3<7RI}khRFH*N`Wgp+%{kc`g5j1~N_AHNXxH}hAw1c3+KP4|QC9gNF@V*70
z+VVNxy6bp^XsuSv;NW5~)OWEWYpginiav~ZP|6kCT;ib%SMVGk<59AbIK&;nANBro
z=uQ?=sNM4z)@M*?;`2PE^_-_I5W80~t}r-6DPXrM?a<4QyZ@3%zd+N0c>^Z8ete#{
z4*LjjhhCC%4_#5KswQFyZ=>Wm;$Sj2ucI|DiLy3}fF!Fuo%Dll243r1*~fW<LG}_p
zQvUu$2!?_PRPQX|QF0-DMl6N#u&EYx+EO0by*)sV^hw+YNdHKWdPZ!kx^i8Jo{)to
zsGo<XqJHL6f@ULHa_1z0TDp{nm@tufZ7ENcetXKIcFjT!8@d8%jmzTgn)X2m^tPu!
zkL?nmk3{S1QZNl;inDmLt`BltSz6gcJg|s26)|UM);P>@aX5^IvnmJQY~ER(2o7rh
zY~D?7LZO$lk=0&PEb6&z9vSn=a#vQt{z#9y`s8Mkb6i-NC9FGo84qg`^;oG~F<~Eb
zmhnJ273|f#WxP?PN#5dR-0Gb0UjG7*so^P-Uf@Hj)Hh!A0(Ub?8{vGnF6S0`d_D97
zE-vQ{<a>4xT(7l(H{#|T-ohjYEyB!1(u;gHolY!%iO)33eKH|K<6M5lak|xa6)wA!
z+dK>KfIK*66NMJ%aeGjsC&^NOaGsSJ@~l3(Em(~jd|@Hton6h_${$gvZa$Bf&X2UH
z-SaWv?MI+#`8+N*1R;kJ(mt=uqpr&IXn_ltyT4)w42CLeX+G~R7Xha>Sc56)c@*lo
zhIf)Sj<BfNYcPoPB+%A17^VJ?vU73`$7L2k`mW`cwle{8+3P39%<o(&jwGC3C6J;G
z1+x~38Hfv8i^NXPN9ccRk(hm$MU5yxVlxP2Ex>YP5`~^AfDMlWvV@Rd&jYBOkVO=#
z|1u=`YN$mW@-nw{Y6(znl9&lsNfMW}kg=D%jP~#I91D(0uj8#7ZkVexs$9Ka08kzH
z3U8>Fq&nvnuGGnId%4_hSGT>wM>IV3%wx!G01C1yHl-#Na!Z~3$Uq`qT*zlNyfWu8
z#HRri#Lnr<h*ycOZHGTVH}X}U)A07}$IzVzP|)GwGM%Cio)K45*70{6{%_V}C{6(=
zDCpI=i1mCB5()YpB#YK#VmoLc))Ln9jtz~Eqpg^!(}v>|+Oc$4aeihA))0KPw`@<%
z6~2i~EkfmcCG<hnODgX#d)-C#5f$m(3J(KEMQUx5|C<PA&%e&kJF_h6@{`j5e(nw4
z6!P(+H~3nrV$pB$z9w_{+rpbo><@3YR(P|H*%rQbBi|!Ac<}Uhc>`0crQK;d3ClWv
z;kr>s1s}LvfbiXfq;z(8)q?l=U((Wai@Izxj~MW7G9sgD(m@G2#@0H6h`mMwtR2mB
zApA7MlTHL3qrj2Lag~`D@Ee=?DI;mRWGjEQs$pb&z^6IHR!cwNL)y5ca^87I%RwK!
zKr%V*b#hFe7j5HbO!a<Dp^WY<g34buzTDtR$QsbaqCMpogOx^XW5^kaD8>^h`CS97
zcI-Vd-|mdeL<w=D(PpL^&jR;^hWpWl3jnUNMCy$lJX`v3goV%hh+B+(*AMe2z1lm1
zTd3gn;WSc~`5HlpKlLEYEzouWc-8^5o6Uf@7*nmh@iDsHR`63B6k~~hIYN9)F<)Wq
zzp4XxHNsA^J@iX3>@ZX?JQfd(0UbiIhw#tI0@wr5_YqKF?B>$|yOM$(eae}!uXkM4
zSdS(O;){yTQ6zH(z!dv2h<?uj7b$%UxT^t<{)}G}HyA|h;uh)nKnowXi_emRM!-gK
zp7t2dUhVOPJm@Ca&GQm1>Mu4P+M;!|p3)wY74JNV*j{Y_rqz2a)zk+B=iYboJ#vF>
ztsyRXv>5ReXb%**P}-O1<UQNN!V~uLCya6_Iwh)gACGPI-92oo3rs%J+h{DtEP0(P
zb!CI$w$D<xPk_jN&^FV3iqCbouW@^u`rbZtO>U6)E#1faOJf&W)W#(|B{aWn$xS=n
z;ru#zZ&xI|{J#G@@7xj?S7txNeW`@wx!1OFc)d{lyaXemW&}N3!ZYx2`K=p(Chq4Q
z>L2|Za`>g}zf4;MUZFn8i~IQm>1witSM29qjh-iGK}n>T{{~>haF7p|f87P4)*Qsr
zm*|-s<O5|7D~!SI5N}iSDwm|gnA4rs4U7v8^F;aJY=pi$%%7BxB_b4agtr?w7%&v!
zl%`O4V_~GX2T{o+glLFRLWB#%ISsKLjt>-#2+>3!_5<N6@!})=q_nXc8qA|uQXh-J
z{-b<IzxGY2?680!wo%pXMv1tYssQgK3gDT>m1AB6&}E@oJDqWiuf=Ph9y9&bJIDBZ
z*@gy*&p6K0jCD_kW5{fdn_}SyPVfL@R=k#ttT0F`F1<59pC<CxNkc3pL^F|%i5g-X
z{44Tzm=Kyq`U-@3IUrbmE3wiV|B-&g#rzUr!jEEFey0ZdEEI$T!I5f%hxu(lweAJa
z_?idP<E7bC{dv|&{y$^gm_{UR-gpb2@eO~~l=WT+am~bO;&n8d(^`#v!wHyhW2!%;
zcsvN~wVcHF5r{xd;A4c){7k5Z2+<HnT@<p02-6Tp2oW#xUeTLaWhHdcGfx<8W9N4Q
zlW=%~Nc|8Y+6t208X`%fIOswY3559)AW&D4P*<Z~#NYfoVB#pXr}pg?2zI0^VdeMy
zde$gw?t7X~HcEVkMP2kgZxNn9gE(BCvf}RIA98QpJL|)5ShYu!u+uftqVD~kH<U7)
zSopc`p=`O$6j;XnGdx#n@D<8s&sI?`_GCMD0>+K}-frjWPdu%T)Ukzy|8bFjYLu3P
z$(xr@!NwD}OMGHhUL9w9VK+Z&Mj7#1=z@uDAb)7!h<ciX(hh`tCx8jtM+nu;uZz5D
z1$Ps!872CihL}ePt>DgTh#xe>TtSf~w7pNm{G?%?A&gdXn>EB;4KarhTEXROh?Y%7
z>POvx2obF23xwB~h$?Q~gEwudiT@5FiAQermeG&ES@~WQ5taO|maT`V`H=o<6Tx^k
zF%A}t8wtkdF@Wr&=1p%y*P(ep*~g3YP<2*l-xu6P`gU_BzAM-8YTK&#+rROlCfpTy
z?<gGStjn0@inz=h#gzJEGs)n4IJC3xHcWu7(ZL?ZQDBNXI;GbN`{J)~_=YUxEXw**
z9BG<)8GYo9z7}458H*har+PXK0t=fLlI>@(WBm33*u=v>d7zur@d*nLyunw>QhusM
zedi8e(&b@&WF>Ftv6N0{ta&SLU<|qd+iSgs-H+AugPW2OBl*Y^F}NMuC~hGUM}rR6
zx2U83=FeuGy%p=wu-)8`xaE5ta=}D@MA5)ITwrWf#YJ-hoZ#sz)V>y2UF}`9@;Kj9
zAlBanLNl|b8ba<R5bJ=*((SCChH=+0uewNX!Xcw<Jv2liAv7~Pt0AH^#4Ci*%xs^A
z_!KP)3i)M1X#QcdKzRLe)0yMc-2Rtwb-gboVJ-!{vX!{Q>jOLu4B$0zUjZ!TP6S|B
zOU*Yw4KVK5#MU2xTy0InJ*>NxBID|idl*>fBgEBvJk=PwtB1c~4{ae7o}~v_rv6k)
zd#i>0!+$nr%}hoVeVYRc16G)P_eg|K&Ph7MoF6xg(CB?=9NK8;B%d6chVDUVbh$LN
z7tlCx>681ehV4YydJgP$3wYl<LJt}HtXPE@S6+W;k4GY2{jWK-V>j>j5Gv>lSY^%3
zMI+&=A8OG9o-2O^{%YI*__I>mjuv&>fBX=R52TKw;{&~la0|qL_`4MiY~9`hRBX*(
zu?Y18P#d7Pdyv@lpc!t(&Bf&q`EJElfi1;F5-V}r>{)=zU<j$RJWwi`xI+!g*+ZyA
zb5B@v*9l%umT0crN&`kZ6DOXO_!z5de8kO7dsb#*6lNhND-n%IUjn7t=@AcW>81$*
zxr7if0y>eIkU6uG5Ffx!3e@aJ822nueeFEOIYh{?^Gwg9Ydl~dvqNX+prdrj&T~9F
z=#Y!cJq){^v85U1HM23sI$*SAOVuyKPIt4#dIsleEDkKCzLuLU&yfO;sAK!qXbQCO
z+fUd!Ns|n}>D6BBJ2d?V%f)S-zmlaw(>U99{Q-f@ivSX>#1?oQd}lkpRqcDF_{Kv1
z1q?<2auqhs?|InT$?-8T>;oRQ!^TPzIKJMtKsn*2pFwTyZR;$3<7-i;dfTGqp35Nj
zo8Gp4(nvI6V|{EL<=)u<z3yXst@<nBzP9F--{`o3@4C+9)o?%CSyzJV{cRPIxxZ+6
zhC}N8x5)5XKrkRcJ;l4b08z)ZG{6=t?`aDg{VTw>Lmv4TgxqMhwQ^`uEj8OLA!*V6
z*k>1N#UI?roo~(+-)=A9j~dp%HcM`UY^wzgY?DHiHX>?!{1H*J#kbpH{84=ZZBNO+
zQs~)0+j9B(V&v5rWDD~=`7{;e6t^=3X&q#1tfc>h>edL=P>f*SfeS*3bs?a*Yn_H;
z`2v{W4WQi|gx;iD5MoP{2M~`-A+|0(_aQUYc1OK`mCAe`-FxaQ*66KyiB_8B%}WY`
zCs~CIX@`Bv9J^9*`%#oUlrp-yku5glE-FQ8-uoj^MblRN&nIUV+!7k2Etq;&e`;hq
zDYNE?x-Hb!HE6-#blKC)4QaW5r{rEp&3%A)FN{OHN1?X1^3HaM*FMbFNj|gy0?!Du
zDS`QJPkW2{UZlA|Xga#Io<ZedwjMwxVRH>C8Y<gGbO(U^;Ts_9hucCzRz_42YsG7t
zb9<c%wokaNag<{zoo;E&TY&rqTJr|DlX4?d%#|E9F9^5Yl;zW9u!9xNY!^LCzajNL
zT_15U6BcQU9=E!=@E`C+y^6JZ@Agv%0XmzOr!-5;d%l@FgxjBtF;i1(9;RT019Kaq
z(^Za?Jb)ZVS_!(E;_}B*Z)~ZKw54VJTR;f&Kc~=2CBr-8Hc@-5A=!ubY}Nn-NH`6K
z=(RhN5>7j2)vwx{l1m58&BIU#mD$F6TlAAynXMpElrGV8f||Ulxy7-1l_}!P29Ur?
zun|GKLIg9&UOA9P9FL;;l<>>3mFmA3?yPTN3z0wn4XO)oVGEM?L_+&rTG(32t0*+B
zg)J)ZNra&F-II`~r=^MpsrlyKgxuP~)~KtqK10`5`zd>5pG#Crvk@0fZH<Eai9C>_
zVAn_4Mo6RK@t%ybH8z^cuJENTZSlrB`EBFzB8<AHl`Y;&ZYtDLgj?_HTGWTFY)zzf
z0T#7MYug|{_Y>qCXy2H)2BYEKSoOu$w#djU#{s8iJ}(oc^d}Ar+0EzSJY2F0H`3bH
zY=8&)nOf~h55if#vnzX*9qDxmT097Qh?@m7$KJ<6@Iys-bEr53c2=CjL+R@e73ar&
z)tLN;+v?-7YL7OyE`wgU;HS0ymFG2Q5D?CRmMxmmRn?AdO|+b(?WQhX<zd(pK~W-4
zU#ToEt~qRDi>=<C__no$4Whl<w8!;_2xKHk&<?IjOBepyk7jo?X5tu4i|eQwk&P?B
z-BAkIVdKN@U&)NN>$`HZ!50m_XB$yL%5Z;wIU3UQ?Zqb!TEhFFHs+f*^+9b31sdk-
zwpT-!xzIa-hC!djmQ{>r$Sx~yZGqg_<QWC4bjU%w5a{CJ<yRwc`TsSmt+~_^R!|pP
zKLb`EW7>AAy;Hz7_aEA?(Xl6v(X7X}*jU=k{&Nl2`8)h95_at>THoH*5uN?Hcw$gZ
zY;Ox6we|>kY4hmbBr9FCm4+3pQ5a*;l29H}MTdNYb@{)(^PWaerAYMmq(21LsbYzy
z*WaLlV;hP>$h>3C#c9I)xPM4+@DClG*9CVXk+Od4CA0zVzso`!8o5_D5&%=4K1hqI
z=o9BjpoHhlWcFU;50T}$nS_)>Z|j@BAAF}ZgwfHqxS*#RiE=?##yoGYa0obKH%PXq
zOQLPbVct4cTp@oMaRQuiZcCUCi?+3PwZW=yjIBdcH|<4(W5~z9NFFq+z9hc5gB4y6
z8-qdjbc`)Rs`q=Wnjd3ZBO52848mh=mc}@Yf{_wj)dsORA<X2%9wO%jII(E5sPkfN
z7s8%vs6_(rmp&IV7l?Td?Ci`iTGZJV+m!HoL0TN@?&M{zMAZM#=Y<Gh^s~XD-m%!Q
zn=crCsG(vT9yVG;AA=G!Pu1f&SSBO(8pYPZKdc(!o;_AQtJvE6|FXNP5W9c~jsxQL
zYKVD2j3&g0YKRyh-X=tYYKZHPV%4%ZTMPeRY}L{LA~+t1cd8+t17b+Lt$fmbyhBT-
z(Ly(kk~35qUdj8=zPJPCx*KvcFfk=pLUAAxw&U+DZ0DaZgzfxGT=IvO>b6t(RTam=
zi#pikI&#TTGyq!@Y;Q>WAH?$BiMCco`HP|G$j<L(3pEa?>^QN$fZfq}h6YE3Y2)>l
z@o-w0;sg{8^G`y?xSq%1?6mO<fQJBdu|S(#mShW;$B@-X$+oUoVMt20C7R?58GyXd
z!=_a3HJ0?S#kKCBnQ^(xyO?8zRh8n}=o`qO@Gjc?oo_o^to*EhP1o^JI!G$Hju-JQ
zT*r{>hikZwGY17%m+R0n4fFcE9@MKHFh5JdN(am{zNLzp17+X>?4(|##aj=d*;&19
zedLAxk=*Xywzt~3bm8!Mxwmn)r#vj!ZpTt$uy|<=eGqi+>cGBp`q-LuzKklP&Gb11
zdD7h}NHzs42~vVq-ysNIP_V_AD!f#GtF486D-}{CT5XZ?PZWB}YK!gD{XmWEN0o@|
zYaLF#Ij2`Y>fwZiY>!+_-SXu}P4>twXlxw)PNDfd-ZeG<SHG&7KZ0+~X}8~BBWW}2
zyNc6ROH*tyL!UGWe*iz%3$NBum&q;4Pk_pxsQeE>ggrocRLSrbdVU(b;D$eAg&%*B
ztTS)uR`~G-^CrVjqbr7a@8qvz)nR>Y;aPteovh1s)}PhaSvwv0iB+Qhf^8JoLckHi
z|9ic#9bc%WW+Xxmyzc>$Bw_Ere)!|{-Up%*#tHF;{;gNSM4M=TQI*I5)H{7`$z20A
zA#BJWnh_d4yWP=*fG6&C86afc?UJvM3%QS5KndrYAGU%npXq07D}7|JtDE}S0$S(0
zt<Wg5b!PCMZgVwCG`o%_X$?`9^|LkVlx`4QE2rI7i;lG84r~(%4UDgg^uC-*BYn|K
zzFr=y#-*Y|mT)3g9hGW}G@Z1o%TjG-bRORG5gfB!sU3?W@_Zu4B2+n8E;~ebzi3*V
z0X>lxJL_6h$o_Dx;(b5-@mjM*Xt9G3WN5Lj#V8hQpyMA6s}6`3nM|lOfoZlTEi86=
za;I0NK1-{X!flk>%?q_w96JfIQ#s8R9r5PJu{HMuI#(*;wTdZL>i-dIeSbvy@1y^N
zRXWA`@c)Wc)ZZ53QTL7?x&Y?74d9KB^tYWh26{~QFdV$)<Lmb4R0N#;IJG$4w$-`k
zLd_UxJ6!pScr|*E?MS6Joo@St{cFwhx;CV(;Yvx`61(`$#p`{K#A?@-{{VA2swo9J
z-hn<@1&#i6b^6g&BIxuXxwjk)##F&mhrD30%^dI&z_0<qZTVHP73QG2tXb0xwV+wk
zf&c&h3Q|i3H<o+-2-#`Yj~1%E>IWy+F(!M?_G_2jOy1O;aE^ax5%>u|=kW70e$M0P
z0)EQy^DE^yB<nW>9smA^!0-CUW&HgEKjrwjf}cO}V^+Rj(Bs<??<QZqGWPJTR$~r4
ze|g~aro+ANy?*#;_V^ZSVxDV1;(Pb#f|UDiPf0J=Ke{P2)#o+qzW3^{9n{u;O8ujC
z&wsciIsB64^yf{#xR|nPDp;yH&6=7EJ3bL){H^ekS72fB6G4TGq#)y}!esYAHK^+s
zzJ)iu+>KF%&v*nHmrxX=iGII=IQ<21MBzZ+pu(2!fyR)+@#et7Y&ocKgj-PIeQ+wM
ziytYdu*faQIHYjAU!XCv@LTV|LYsS#u}DzgrF04l>I4-=gX6}+PkaLlGeBjn6J-2O
z;Cw+FSNJk$R}_BY4=mzMB-+B2z&sKnT_!r?HNkPQ#sl=R0-7RX%%ao_i{&8WMZvWQ
z5`0SWUqQqjB$V--_#G`+Tk8fH+luU*MRIRY!p6}8<1Poi0%W<!#~g486RDgmOs<c-
zBhT*8WlthiqlY$@3$L023e%D7k;3}*gM<p23U1wnu=ygqM~E~P#AWy?L5inDR*!+z
zYQg@5P(X?Z&(v_>Ialy_qcGVcNWk3d1sT5(ajuKJ>@1A&6Bwf#(HEAx2Nn84<mDp0
zG89xavJxVA?-Q^M;M!kg%?c^Lplld@1b(WJG*Xv<^i?k4uL&(Bp}=kU*^0tG3yq!?
zlD#Z6R)X)Yf;xkgWSmDS88-_FpAhkeig-aN_GrXCO=%Ragq$XkT7ro4w+Ocvg?U=g
zJ`jAo1nmtN&>Wb<YXZMe$lX}bT@{+?*dVB|6!JwNf6xf{Zw197r1m>;aqEk7qfK63
z<`2sv6aQZPj;CbY*5VqM`al(ygMJb86)5-?in9D!MEpu<EC~{4h?JKKU6$f|m(crJ
zpP<5yD4Wd!`;(CSX~E@Hl1?q&Y?BMS$^mM`_1$t|BPqc6l#n_KIkHkbw*m;!nB?0b
z6nRy!7$w5RBD_x!M8IIqiR?xD$;Jqh`Uc8zC#CE5vYrv+b|J<JA#}7)kZ~J0v^S0t
z#W_f*cB$ZYAIf?lLP1bgxkr%kun_u)NO7S^{bP~Asfd{)a6v*LH-!uvV9aMdVHD<|
z!gNUXtw{HhNFkhlXO&~7#LplbB7*5=IfJ3K_-!z>#F`1g3*LHKKxo)Z|LW@SbUi+e
zkLce@ollvh@wrLMCivG{hnJc(c%TM048>pY$Fiu7ppCWkuPeMdC7hurK&zef?*V=Y
zo~_4E7Em~GM||85P5&Hx@^pBC&S#yh5scH}*#eIAVRz!+P(5eG)pGnDu$1r|Jz+=u
zdOD-(no#xl5!D3kq4O`Q%%7HpZ4T9WYdNs!DP-!5e04?+Rgco+-_YTg5Rd+SstXjY
zYoeJ3HW<c@durzFS>xu-A3t~gxN(MYDMQl6O`1G+@>A31?JNi#RHv|_>4BY}HT&DN
z^OF{l#+{d<LXB?YCNG*cztF2ya^Z+p|7$gQ)`DqsXU_sBK{bE!+;QXQPnkV;Iv|U{
zcRv135rK`*q{v49jkEFF&7y(E&yQCOGp0?LHetc!xfABKn>V{%41G@-KVj~)iOx?E
ziZ5Kzrg<+y&d6K@ndeTLIey%nxw9usMm!>VYU0FkE*5j=JIQBKD4wEBnnA(X!b`0K
zgHpN=>outR;Bhf{guqbgqi}y~b5^vWcXIbZDLsI-82a?+G0x)r8!f(-cCqacN=@nB
zV_a-I3$8J8gu%@btOSg60y{WEu`XatM<+BU-q0se=iA8%jja^Hm2QlS8Lk3#Bx@<W
z(Pn4s$ulO8pEtSvQ<G;+o;!a2<Vo#kj-R!7#<W?Pi^j!{i|yEc;*8nzCQlkSZ_@N}
zh3~gbCUY}k0aJoKn+$IFsUyBk_-#U8%H2>`giQErG}Lp3O{gUV(|)wr6oWz@fP3P%
zu@bEo!vwfVaPbl`y$x9=gO3P$>ckogExKgzHPlB{qojz?A&QoWKOh14k#r2jayOVo
zOh<Brt?Q)oFf>4%K>RrV*Ub_^BGqz4e}h2aA=o(bXfiYuOoD|d6sN8s1iu}^l5q6j
z@mKqDU`@z`$<PQt^#vCf++>I`88lV+0UZhklt(H8`tOe9NCZlXScl;!yl`M}%fgIc
zIqNB`{*Zr&z)xoIG+e|MZkP)g{WIeKm>PI<75o#G@cz@Lp(XM)EOpYG3>O5%V2B34
zCfg^&S%n%_>NKB>iqC>yt!r54B#;b$=>$n282{3F;2Rn?=>!?#yMf_D{d=PLb~o@!
z^gVSP(GPBpg*oW!fDTI+-=2mO`gcY~Rtx0#3Bz|z2C|`%BQhAwZ%7&mGW?>$G!1zO
z4UpDed3ikqtYawG@c}{uZid@Vem;hWdWI0)py9&=p6J(Q2?mV}4|N8Cf<cJE9StKz
zSRwGi20#6KgZK_KgzDex#dm-qO8?f1z+V&r(Ki(Q{0tTyzf#2aF(l~USp@>%jmHnP
z1Xc0vWf-h~YZ|EM)WE9(FB`_{__;zul3|+ut!c>Qw2`v9#Sp^)E7blKJhfB=$~AbF
z6A|&6){@?+Mo_jvgWs<PcYFuctC~RB?~6qO5!K*dTwEpK9jn0Mxg3b}DhL;RYAx{W
zTHqUMffqjxPM-5vHH1{ANm^D5{C+KPUyrJq*rfA`ss^{~@Fc(~eP<Dr-PXDYBdQUU
zj-Xd|42DJ3;3WlZ1bjm^c+sy~FU?jBo?S=lb(Of_B7MV{OInW4x)6f#9vyz87Pz}-
z)f_wGN7MrESOcD=C7fOZp~0tCgE#n9gJ;(Q-%ty@xEA=atXdFdwZQLJgMX$A<m**c
z6ApM(HMsw8S_YDIc$TAHIuIjjA(&GOd}S^0qFUg#s_-mBS$REC)}>Vuh8rLE6!5dv
z;00f5@Um*~*?P|I*8=zTuBxFTG=>JU|EOvR-vgSpM^}Su1el4g1~(kl;-^=GI|Q0q
z3p|_PWdDvLa1d;$g`l_=__12xWwpS4eO#Il_0QolgDN3N_YTh(T?^b=3p}G1_@bI{
zt^OC(L{R#Mt+l{QYJs1v1%9IzxVvwbOBIx$BgYZGkB4`x1)g3Dd}=N5YzJJ+zboMl
z4g^Vqe-43)Yk?oD2LG+e8bNoX8oc0en1K7%ubQ!}IfpbvbTz~rouFeixI>`yTHsS_
zfoDG+o@LnZc!Z(27WlDR;AOSIef_HDIJ%RbVF8E!9n~-We_F>Oy&6IBevM#6HMm0)
zb83OFtOZ_F8BXQzU}UR|s01&q1zuhY+~8j|#}58MkAVyOi>`)PU!gS;)>_~h)!=Kc
zYVjA<0xzfqUgBS@*}tO*eDxwYRtrH{E%5ubz<mR%Y9j2KCTNrsuBC5qAd;L2QCpnw
z5!K+Ce`$>7RD(NIT~rP3u&t76aNn$bnsJp?L!_5zaD%yO4h*`6BC5eNba+xVc)?zc
zPewJkuWr;?Q>!7a>p9D=1-_vccyTT8W3|A`G`Oq(?@0K5Ed;&|s%pX!KdKts{iaql
zN!8#>T4<gzy$T%V|NrQ^^T7G7aev^)KIMm?WzZ$Hby}@PEggF-_nOOf#oBRQ#6^v&
zHnmP|iPkb&tyrp4il|~N_e!}KrEM%_tc`sxMXq&dky4DM`b*C9JTr6N{hrSs>ic?f
za-Q?#oJ?lRNQ03P*m`2|sl{`PFTnL&Y3JV>0wte%)ve4C%jD`>+_U%q{DLc~LSf^2
z{>$?FD+k8VAk{ZtR4N7ce@$o1DY)z>w|KR6T7M}&2(7jOz5ZlJs%ut4ybJEXhn~QA
z;K9#ssQ1?gcRm+4Pw$&Q{~7`E0l0rIbr6ErKcx;v;N@p%Kas`9F$82}DY&|vI+%ew
zi}q7GO6A}l`y4zg>FT*)-(3IKKcK(@8WaV22`-7QEUs>CIb^2CN_OO#fsGF=9$I{C
z@pO;g%)i+l14<PZUs}Ajc;_~Iu7ulqJO6R{^(_qoi;paxSbVzUdi}{E$aezmq!M3P
zyt4S(;?8ZaQ3+cAJqVojXF5aq79UzXviQW}*=^zaUpk&!8k81aSzPUFj#&2J6{qnl
zB>_(YZT*`+@en-VGiCzr^L4-kT=tWJ#}b%BK)kg0%HnE2%ZT^vvGVpDPy_IrTt#yt
zwD{QKsl{j7oBGT0lMV`K;NFy;-!H+#Pv2S}q6)mch<pWJu-Ch;kN@qcgU<eD>7t8o
zuRCzS!v%R4JYaXhWng{qu=%>U?mvKl;zzR~c>O(k5DG0m0+)^xi%<85>;LCoO~*Kg
z2I33w_wn|X#n<4M^7hUFQfXd){`XJQr5<bo`kyN0N(A8UkEs$vbakq37+HJ*p2mD>
zl|jJ0H_eF|xN|S^9Nc~5p}ONa_;Wa+65M$^UC6{M2t?m#zl6}N3Rg;`|EbD8b=(6_
zIZ+S1ybo>P2lw`WncksKzP<iW_M^Z68q~a_0K8xyf`5`nJONi9-%od(8r~d#=UQ~k
zW=3G^g~gW^ufb2?{dW#DE2_Pnf9{?FjrT1cSbSvh1pF(U(6n(q|K$vL$7@q1a%dpF
zuy|$hwZ)y=Z7M<QPdeyr1NvBr`xYNsJOWR6U=#2kT|1@`XArpWb;#%7uV*hUz5)+F
zbt63xb^FbT^}oY|pRfPhi7~(pT=42A&(jTh;IbnRToUPnr;n#)>9cRH|GgtAFn|UQ
zdjOs`AHQw?hTtx5AA(=Tl^dHLD+#1#VB<53FTv}N()wP5`}@$FPTf10hrqo->&^V@
zLm>S8U1?<C^-T`eJ_dKL)BaqVQd96!-US2CZ%X@Fw%*QvS$-M6owkMs=}l<_>W=0J
z<Y{>qyyjDNA3V7=?Ps{-di_P5>3Ap5j>x?cHAuj{U(>9ff~&{ftZk;|;L#IkZY{z6
zpWKkve+2>eN_u!*gV)V3Vzz(XJDHVmZcHV0!Ebvvdd<fJ-;dqDQ*7?&((CYxM9|=~
zN05i$vs;r#;QzQic>;bX?sz6n<5wzqCY5L*0X@#<g^BOB-yUi{EDY}MeG~1SgUkWs
zH>N|@122!}<qaO!^&xsk0R-gDs1dllu{Z^n_mJk`-v6V7mf-weaP$5j1f=6N_?g$I
zQ?k=DM=aj6xNq^H_NM-_{A5RwrNPAFnZ@T8FL%8?{&MkI?*<yLp2x@dU~|Mdzv1YB
zOXYgt-tTEYKDeVCdi)O|;2n1-Jts!s#W}R21U&yPO|A*JB$R;%=hA-W2gCJ$bt&zr
zfCjRoC3yWF+EESe|Ah9l2ABOfhe$<v{rT^u9rZQ=T>zE+fp+A9%Z>&X4=p|h590-O
zoI*hHo6uA6khjml^AROF2bb+jaEG^#mk>}KsK8}MYw)c7rbPR9XDKQDQ?~D-^NGkM
z-(LSm9Oyv<hus604hG=$+o%!&xKwm#cys*6JfhGDG%u-gB}U*=-aZ1Cl8(Wpq6zrC
z-A_CJCJ>O4rr>f&rr;r0C<B*@&cLOjdE<Ki%NbDdhI42jv%R$V%Hrx!b56*9x?899
zCjoC8(6dN<VDZr6V~eNPaQ^(y>>2@jA)>JO(&DwnJBRJL5^ih>^erA(d}Q&&;#2m`
z^}m!lw=`H-yt4S(;?7-+O2kS!?wNs&`xYNsJhJ#?kKW9`Y>$EFD%Rqq#a9+rhZ`f_
z46NIFJO5?*Iqio&n?DyC$V(<YaCybV1NV48eQ^Du(q{kuj_dX3e48GGhC6{ak>qST
zm4@K5{TRGHi?&a|EA|O^vmaXj83d#xGjQp+Kz|l>ya0FEOYnkE?aRaA`d>Pzp+WQ=
z>R=5n6;hsgjD6V-Tq@*<)A*ZfJuXpK0&V@9zmRw2f=h*Z;8J1_+~G>}!DA_r4*@CB
z09+1904~dTWbtIr-hBRN&jFQNd|~m*;%kdLcWn<@Q-4{0GJ>8CT+@Av4=o;n%iH&p
zU2l)S1hU=0j?XP#g3Bi&R^akhjyl4eq^;}u*WE*)>0f!^@_PQj;-SUI7Eh0W>woEB
zW@%7Zd};C8;+?xmC3yW^YhQYD+1~`(@hcVa$8(0@0YCi?!IKW1Nk`x=zbHKgFJj(N
z1_76MG(+bd72w&0)bSEr-GClbD)9Px<namu@<u`pE^j1s?k=UH3i%;*?1Ibt2t9Dw
z-Y4I={^vIy29^dPxO6ZAmktte*?wYpbNr=2W(1mJ&k4=IW%~kLwqJnD_7%9^zMX$7
z2uK5U53|(LK?hv6cfn=*9=L4pH?HTuoB^f502&lLxk7OFE3|wP@SG>t1Y9O*wsqP;
z$qi=PfSz4GFUtZvV_$+_&0d4cTRfe6niX}f#jpRn*9h?Wz~TY8yrnV%mp2{~@E`FT
z64Mw0Puh<<&cWpki3RxiynSWyHTZ%1^Q&k_QYALm|MJd;&jFbel|wJBhT!S(2k1kT
zfR{I<*ZVSX#rr8tk5#c3HK@#hk}sF2zIn{#RcseLy#<|!d~kUYI|MKE_RaiDAdozc
z-T}?P%TLf73^VWvm$b0>(&BaN?fjQg%Z@ttGDj@l2hRgKhY!JPe(VUr)kCR5;~m%Q
zFZ~DYXu1>72lurn>HlQlF7Id#?mgpfdiy1~-=R5Ffj@b8y6#`q5IAOdy55nxw^@mk
z*d6dUv%BEmd;smo1AiB9@827)|7RQsputDkL-0*W!Gph3MH6tT+*F*#-&|^O>E;rk
z@vD^IbSl85<0W``6?I&JOUG;QSUT?B$1JtF8Na21&d0tF9$ZZw`{2^?5S;ss)ffWq
z|D%o*a2fFw+~E;t;L`CNTn4<<-qc@~UwI>*rO=@II4zqsxO*wxbf9}*vvM_`h+J^*
zINDEt*W2S?zJ|YGup4MR`URCV1P?f&F?ia3hqL)hz^hwQ$5U{>*<R1TIRspJdJJCh
zIlltG`4ecF)!;dQsz%+<tk8bEy>maf{y&5RE;P6Yy9a(Bb|3t)>;d?QJ={32zn5|#
z+5~hZ)miKb_<ymd;1{va!GnLHL$d_;;<IVets#)GckgeO&V4&=-v_VWMm_{j*~j4Z
zLn)zn3W4C}w4)4Mo*mCEURqo|z#M?QPw0|wum3&%)O!ybe9qCw!Us>DKp#FIfLFYI
zi2e+Eb9!WWbNppTkr8OV7s&q}gL@I}C;?Abl;{LJWKY4X%MYc;|0x6#Zjgb0%cX0#
zIru#fBrn0I>?`m`-;TEL`f&YU-j6<l<u-x#PtJ@d|0k_)58QhYxexw5-aY`o!P98_
zaO<@G-pYY!8_)?{_Zie60sjhn3Vz+AY5NTPgFNCAJpD{er`{z5q(N<Q_km`G<oi87
zxO^>V0RAyfG>9S4<9`pqFZlv}KrsZD?Gx~lzu%LA2mFG@jD2(cf5Y3;q*y|On!kut
zfy?&JgUm|E2ar8*j}r<^kCnsgerN`ibT9!|A9<;s8!5P~`x$uh7CKKX!2QRx%ea|;
zD+qWWrVeUwSvH*qn<Ex?E#9|y(0V)nWtqv2MwSMN#itg}Exy=sz5b-*YA4XvSbS}9
z=OKHpM9<>>HJ#S~@S1_Pe-&ALV)4x4bBmV`iT6B$6*O>fMd$n)T;7^lgUeep>YvR0
z`@ElyIE}x#2D}Az;7CA^zxnMjUY0$J``{7pX8@k>L;DZF<8p5b3?U$yhT!$hY5Ng)
z#vMoC;Vo(VF?dDW$0~t<bUXofxq}q^pgYisYX*MlGwHEl4*sw^@}s5prv9@0B(SnH
zQ2%Tm%l!S0K1f~g;#_hUJoq=NL~qyI<1YbkH_-UI4x&s$@RZNt3AlW-c>=z<ZUC>F
z?~v&Ex5NOSk}Gi8(HdM1LGPhvg%bYg<p8|k*NB3L!u9`=JsR-{8l>zA_=<fB{*Z%d
zKRNih?2C=_`n!q))h0me@7P0VN6x?;nY=jVfh#`t0l0G>y>=9V7csy3l|sP%Fg3`*
zoxSPRvJ$*L;Q*a+4KA;it-&whfyK_hm?M)w5B%^uQzd+h55Zr-+ehGXLYt6pum2^G
zSsKj2zsVhx7GHti_D~vtdf4uOo8vEmt`XR}XYml+=g$F;z|~>&`QQXRdTrzF{F`9l
zP->8Y%g1YH;O~4cpXtE=?RfG9_&L1&vT;5C<qY^94y>TTqj^Vb@ELF4dH8NgmHIGy
z7yLr@-qv;h>bo51Zv%QZ|B`(G{wMY!_+HPW5s$zlKK2RtHxA|3|ECZr-axMb=iv1X
z=(}BW^k>udC3rTW=NC12%CCs7V+b5^7|qh&znUeD9#0(%z!UZnc=`Z(Di?ugd(+eV
zG5hBF-@hdV5@;~vgr*i>fam<W;R@W14$z0R^9W;L&GrBDDbO<ms{R9y7`)&S2jEFU
z+mFDjAJWTo6L6(p+-~OI3<C0r<pp?gL#ogUJbff}T!YsyChz>4F=ACMXb$ySZ|A=(
zzmi|`89)QYFUbVpkG~7el?1$eEOk5q{|axP?ReY2lE8c?(E3R+pFqIRWnY4)Cvzph
zqo2_sa2^Sj`1y&tf7OM+J|2zCv-ki!<6|F!S9?)HBk+9_8rb-eaQ!bGr_ex3Jp+H_
zJt@(`;!BIy;xzu|%VsC?WC_d?CHEkAz~z$?J#ZO-Z}A~`EDa(E6tAU@C*Z-?$Ww6V
zW#lvP{AM)U7vSY3diz+dAdr29cGP*4S&3Yh4S4-7+I|2YPzP!R?(-GYM0->J&GLH&
zed;}h269TCS-i0L5?sCqSnqm!{3XzNv^ipN*W!I}d9yjN_-GHV=U=jiK)e2@;7__Y
z&Gy{l3yW74Uq2eI|1aPUoX41zkaxd*aQP}#2=08H=0pOX+=3=!wsBs61;6Q3Yy$20
zo6m-pw4)0B5A>~>6}aM6qaJGxAbJcv_jAGPnBU*?As|mMLh$Oj2k68S@Z?!Ec{6b5
zDdYvX$Bz+l1%ZISB&Hr`jv(g_Ty*~Gl@BiO_Yc73%PtA|_WIxXHI+1j2HrVz2nz80
ztK<vt^jUn!z$-rXE5n=PpPxbv)Z@(&yL{|jaF4%8+yg)JmGq#}2S1B_0A63(yrkRC
zzaa!NZZHCW=E?l11+IQbuMKD5K3`cC;LfACLXGSBFK0l-r_2>J@ZZE0I?Ak2@X=@K
z$>@T+zoSFxgO~h?s&MPNf93s(Iv8yOddJ@B<O#T1k!Rp8uZ|hGoEewk#a=NzonAwr
zdJZj{?$8{ur@u7Xd}q|+L-6D`REZG$wENPTbR1g(sl{g&FD$+UKkfn4am~KD{+En8
zPcTP(+G}ajb<ueQp2Y_i4^5AibUZc#8&54hvv>jiYF;%ZxVmmTux9>M5IFgzG~yau
z67BpuRER6#f*<iPDs><HnWxeI2d%gBUzXq1kDvx2G!P$yS1+Mekb-*`(4*WGT&@`x
zJFeGX^1K7|a$D^LT8LgqUW4y@6eZeuqFD*?K6uS%(jmBa_QAS;6=L8bT9#vQ_crZs
z$v1D=g1?9pnp%7TE^k7YPlW6L{f9KN6*S1+NeQX{Fh?96MG1Al-_84R!Ef>eo)h9U
zex)Q3NI;KMZN4lr0)OojX-5h8FWILS&%xvS{|D`80fCFzD~qo!?mWq?knE?oXOEQ+
z0so-(_vxG4?1IZ%EdjW^)iMMRc|Rez$3D{D)L)k0aZllrLId%s#dGkl^L`c<uXepX
z{?cH*8`yE@$!1Aq`yTk=Aq~K{_;3%d=U)T?bvB)$5^(8YYVq9S3yW7zhU<UnU~OsO
zJjJYpY~QoEZ}H*AdHu<bqD`Qkf=Y=`ES_0>Zt)U5=3}<P0J{qJJmRj!J&O-49*35|
z*y5?hXBICkz9ipX|4XTBOM}i+_go3r;(dz;hBwDwIvyE;ttS?rT0FP-Vo%=AziLl`
z#@7~i{&UZj=vmyi_^@$3|K$uQm53}2CKk`Y@Afo05zQ@LZk^VjeB5TW4YaFI$&S?1
z%n^T|JLp>6v-sc|&aeN6*9g!EQgA1y2d5ldJ^VzS@Ekl1`RzJz`KHA(hJZAv!KH!o
zbh8rqhZEhg2OjWGE%d>|&rm`E`{w#T<OV}%;C!7LMBqMeKSt-zd``g+dpcEgVS21e
zF6qh)sG4saQiBJdrGz@qFe{<<rFT4f;0fQ(X8@k-7do2xH-doNFlYi^-JCj3!DAlT
z3_Se;ZC`-PEt?jtxAR|?pERhTf!zCP1ui?P!6lJ3c=>*syz1y}<@EY1913)H0`07F
z*d1`W_fr=<<n3MX>SC%yAKX1Nq4n=WKpG6e<qJn4`k6_auNtBAza#MaEwugk=y+R-
zb_XSoAb|#oeF9$aj#BV|x1WL+zoJUy;xzuI;|IL3?O)9$p#Rm}gq9nW;4W{!1eg6(
z;F8D+JT5*;$G(O@#v@pROC{7Z&B{f0qMK57z@-unctp!MRy_!$e`|lBuK7j;I5$uO
zaF@3az-2!}a7iT8-qc@~UwC_}#0VNBT!{!=DlrC6A4s=sO2DNOlU;9*e^k(<$aVvb
zm;Xc$Dl>4|z5q}6p#dzwWj`f&n~0u&O9*&8;tD)vUx7R9HMs0&4Ic9L-4R^>XYZ$D
z-yfNiEBOeG%m<h42jGhT9f14X@o?k3{&Eh4n?O4Sn?Lpuc(ihKI06rN`!TrtBRa$>
zcp5+b`FclF2uOn*+~e)%;3<0nE{QC_bFOGyLLlN1EWxD`6}ZdWufU}eHTbumLDvDD
zXX!({z5bVgOM%U@6z_wVzon7};MGIvPKiVC!O_%lWO#G@&*i|x2y8vG_}t<p_;sI2
z9k0N%2Q>rG^Y0jQwtEk!+1>#UE~62<;OQlF!s&s#e5K^0Kb&5)8Z@r^mos2cQ3oM3
z$O1kyf){JrJ^^p;V4^4W1U&r#?I+zjt-tzq)L^;|=p6(X9j5=Afy-+<GjK_$01x)1
z{V%|k8&jZ!fMmJ^mqaUYNpuA+iPqpF{`WeDK>a8xk$Sc{C(55wsk`9W{ptMSf~V{~
z@PgfA-(3H@kEV|M(7<8$!6l&~c)}fo;F9Rb^jJxzkr_~u=@?uRO~5753Ao~ar|5cM
z&HS4}K)%bJgNMA17Z$H9zP7k?Y;%a)`7g^)-sSGKfgS%eckF{dWJD*HA^7{*Bk<%W
zG>0ZTuGe31=8JWQ=}w>p_Y#^DQ}B?t&%hJ*8Mw#$$-$e1X#FoB;PZ}3a7lCtE{Rs)
zlIRLt60MJg>wn2~4GpA}-RGExCjT(68t{rg-!}wz`8niRoW|c=1M<`9sRZ-^X>Lxz
zpH`WJ%jbFvaOX~RjF;fS2Px4tcpSZgzT>TqGe;&n>Vl^qpdGp3vV9-C;O%{I-ab}C
z2q<naMxWCsqNm_dP6=h;$(2-zIe2;jZNJps)L)igz#XiiLBX%>bdNVH6x@b7=!46z
zTn@ntzT_J3dVBmU-qCb7(71dMaSk5voLGX_=kYNH_xYZ%-N+n3e#_g^<9{Cl{;g<a
zLvXoO!x+5gkxjt^{`~(OTs|AJjNtk|;Yw7{Kwg+!gUcz|Il&y+{?DQ_qYo}$(+fAw
z>o4GMr;RoNT7PoUn1CPl-}DYi3NG8v!1q6f5-QMR4lE(?n|D(O6?pg~`mDza{4wvR
z?Q8I-v#-IQ#~!Qanx#9510C=;vpeALVef*U$L@khJb)hg_WJ*PZs0+Ki`o0&m$3Wb
zm$DDQf59FY-W>lwaA0Tzl)9Qd1b03_r5=Ibjy(eR*vH`i+<H6z5(qq+8%)6e$a5kE
ze-dv$1wWcS13!U%*0`Skat3@U2XbieTJ|~k8SDl4yVw`tSMdPKt<(DZC^uMc1A6^^
zhP?v+8v6?TQuZ4BckFBMzkYx}$*i7du7c}*kdAQ&{O0Tq_<rnN@PpW0@I%>qF$ALa
zLt)LI2mWAg&<B4!yAOW7b7=qr@Tc+i0sH3qf6Rd)G)Oq15d0M0egytr_6WRSADbSl
zZ*w3q1L|`23Hamr%P1-MwLe57o`UbiJ_q;i*IrLF^KS_O`RHW@eiEOm*Wl$d=)y!j
z-<(4Zdk5S-nznaZZ|A=(zwqf4=t2YO*aNS*gFbk{`|-g&?s%}{di`bGAlM1ClQ8EF
zhTtK42<~tPBk+XxAA$ezm{V!}PayEEkMXetmk*DY;PQE%CHP^_p@-cX{CVu17r^!Z
zcRAp`z&w^WIF5GIw|D^lw&Q905x9!T6LA`UQ)>=PCD7Kt{bSF;vtQC&S%ABrCSQS<
zujVfzfycr3s6pq2=7=|MID*U1>+~!>1ec%P8H1PfY5V5;zYyrm>DZ^>AL2^PEM9>B
ziML;Z*LUDbXm9E-%dftQ0&8gCT}`fDWLBuUnwKkhwxaD_@bqW2eSg>6<6m8TU45wi
z-9RG=cQ6F^Kkn-7L+~e_K$B|>K4+hSx4)R8=idSX@($<<oPIK;so2=8g#2Pk4_tmR
zWdJU}m@*o}^?&p+D%}Jcr0*l2foJ?N`~|qn&v;hg`A2xNpC|*6^~cZsdYgc*aPu&H
zfc`%N@ba~kPyin6Lp}m8F5rQI2Qhb?LZCW;M-1+sLcRd6avIqRJm>obbzUqZrh!H5
zu>%2V&;>7f$1eIkD4`yBaZhp&Jml^B<lF22^i=wKoevEZ?`QyC|A9svf_tx|jz{3K
zePVcX{L_=D!NdqOmtef36kHOSf>%7U3_Rlj%)pa&`*!~25GeT##5uUbJ1W4{MO29;
z`nfc)3Z1uKH?HTuoB^|QsDXNkIaw6%r~@vEIN%vqq6;4J0NkzX{*^98Q;FU-pr@(q
z$OD&3^ub++1`vSP<^A>khTyIfQ-cTs<(zyBE;~xVC6NiZ!|Of;54aN37y_Y8BJhOY
zUY~)>>d3+UJJ0|Y;MKS8r7KagZ?6BP!3r9<_oB&FgUgQA;F5@XsX2#A9$3fp=JB6P
z;g|s>mFR+d@1#$?yWmoZ9=OM|-3Kq;-BzfXe**|egAiReXg*{DPCII@)W9W?F?hk1
zNLp{_zbrqWD=~ovQi&8?b~FW-N@U<Nu=$Sb^;hzPL9r8PXNfdef~UNF1upwpflDGa
zcrzzx{jVXAawXKu%t<7b=zwSZ*x`UnCA#1tuMY2JaQ$ELG45L$1mF&zF^Ax?pAcLU
z8Hv;Qn_BaZA_=thZ~j8A#28&B5qQcz0hdb5z~kbr^st*lApJS5`vrJ%PkMX31eb@`
z6}UXQc3y5C%8YJ$*?j&70xrMzGXUoXDgc-5hu{wXI|Q$}LL==>{bl*(T<QoKMBHEu
zp75kgz+K)?2JQuP;wpB%J^u35%4#>zI)AlN!6cQJ&s}i&2Bi-k+>0IyLU7d_0zLmm
z5b#Pm_6c|>SFzygD%w5+58q227vLW6r;6eFU%pzof(D~c(R0Ez_%ZCA#GG9EtCdX!
zyWl7A_Pves`upVh)Iom}Xj->_{ME_<xc@gAaR~06N+TYD`!^#`!0Y&Y3QQoNmRwSB
zpD#>i;0|wJfJeN21@3-?`i)l*I9*B&euk9#6=td5&E5t7q?8)`681j%_WEBAK?n`f
zo7_$xi3D7}-I{@CynO*)-kA1N8QvWK=+jgRb&@%<>I38*aDPpQ#syFLshJNh?*|UR
z)#sZ1wDT{7K>bVVI028ig9*5EW7<AL|2X*!Jo*L=plDpre>nrn-D)am5O7IX;J<q=
zz2MM2*{odpDe9mPUa$|hPV2AYFP)FK0e#HV8I52HUY^Gz2CuI}J_k?UPrd|qpBo>b
zJ6c0P-sx1YG)ESFl}6SD&%Z+-!Rmvje5M<MSNyudIEFyZfhl<P0!nla?(kPMm*5q@
z0<s3rZ$fYFc3(vU+g$(Gd?T_x2V_nJ{2Q=7xOZJD=@49QQZ)vT_+$8q>9O*@MkSq^
z0p;+SYYv{vu>{X}`!#sPUq)B2HV-Ae!qUvYE(8*OZKn?&@yBb2;5E<cF?i0O^_YTJ
z{9@L;^>+SCspV_)1vF6nO2-o1FOJufw*r^#*Wl%aw7q)Gwi0dsN_N!Q3A8SWIN&aK
z+y(de%Etwl%l004@yjE0|H^}aT&)J+^7Z@3;wgB@hb9M?Pgaz#feVV7f2E>^28w5|
zGuf7|tx$3_-6y~UkNAEf0eHec<s6CA_?wSf@wZ)43AB4}{^Z*$Ik<els03Ghld2j#
z<Qo?_uQdk{hx}{Q9t7lvgah!DD-nS^eE0kmJmC9*<=`Ier}_R51akf)R1Ge-R&-7=
zM-cI4wFjQ?8885^WdPcn`pfc@kJY5mz~@7ggBRDL+w_&-Ie+S<1~2&7JE!gpKp+3+
zb2#mvw;O2w?ee2y0G>UKCS3$x+<>0SrQj}K$mHNz<GTM60tGjy!4r1pbvq+y5_Q-;
zaGyN@SM1U2;QBw}Kne{)_8dHCFTpE*jHoT{oF)U{_2=@AyiK4zAk9}W*!$r53+T!x
zu=vR033wFq6N4!PvQP1q47mJA#S*;u7;V1>mm83)(`Cdouy1^hp76vy2*^!jJ@C%w
zseuoE1NH%U#fb#qvfm;3_WIx94aeAkZ$_Jd%e!4u@DV381D89f=Y}`OUoxE=f#!3;
z{O<x>5?z3ozoiSA3f%h}eTaPpUjM%FcK+26DEX>)4eqN0=-|EHJeI{3d{GJ>9C{bM
zy$c@wffDL9uIIm;0bO1;9yE}S`{3E-)Nugr-GMqDf|u=xo4;`Dx_{+y$D?gPZzvr{
z;0~910-oH0I!?h;?sy7b&-nHK3<A>e4BY(_jko|0u1_5=z;o`n1owHs%NPTEj4Slt
zQ^#xY<VMu7O3gXp@iFdz7d*Ed_RaObjJOL86i+S>+}oEr?t=&1u@CO>hzF)O_y6D#
z2WCKpzo8M2z^kii5=Gz+cRU8Kc*F@f_1nz92?UawI?ljz?qCL<vghE6M?43Y0T->e
z^Iw)<@Tvp!tY1QdWJX?rNADwFfy+-gcHUsliSSXheQ(F(wnzWF^z3!86KFjfQ-cw>
zTpLE<cYh&0Do()bH_?7FaObNB=>F9V0%1Z83h>Pf6yS0@UG+wD#Pt<)`z;sT`xW1y
z?2T~!pYfB$5E`T_YLI|OT%im+e-RG=yk@V&Y5dJ~KJQ4q$s9q>&+lFEg55{w4npvh
z_n&~rp^N|mE_(s)u~*=7!{HUU+;F%C=lc!EY7GIo;c)NGW+ejd*aMgCL-33%k$@{1
zu=b|@vi$OZj~O(mYdZD|@Y}tJW_tx5@#I~DXT1EnXY35DJ^tl_I_~cV8u!?T;0gZ>
z*BIRA-+G#YNBo>H1Aj;JNy@f=l|$f8Up>8LRe<-|OYldqSKvpp*Wf3ytGB@Q|Jym>
zyk)0EO(GYvyWl@#_rS09H5z~qp8fbVJ+NTodi+Z5%MHR!KyRlGWRJk**RUqwazEhA
z;&bqGV!1~<1n$lqFTv%5g*Eu`U!oDKGtJ7SJYom@<-C3DLf~W$c;NE;zXR}sS3w9a
z4`yR@e$bkdZ?FG@FVZTQLj#W+EWr!jehn`7gzZkvN_hNPG1u_s_{)z@1V&){_FII`
zA0kV^i?7fCa`22Fgi3Jzc3nIFmJpC%wdkB>jzHe==z+`ofgX4`rV~^M?(Idd6C{nd
z{cp~I>6d5(88oQbXW-H4w0!|y@b(qB+@5o_b=|)zI8*gjbHukjkw)Nw%j<xF#UqQS
z*Kof7XMT+Uy(CjwytcUWHgf=ysAuth41qWDhy(C~*Kr8`<x6PYN8sOPPrxholznsk
z|7#9p(BKCzrb95dcxmw!_$yAP{iw5z3dKqSo*7UDzfKo`%WJno@b=NH{TqRQ@O$KA
z@QbuJ^KSwHd61Zbe~WiC1HYVo4*oax1$cK!2`yW1=f7Nl+=BxvXdo9F>g`79RQ~Vu
zj%F7;`?T8@Lb>4AsZP<}-*LVEp7ehd2zCPPmglpNES`Yh@+Y*Psl{{fTm1ACTK|h{
z26UzsxOxGNcn$8|@<6@4dWTt|YQz-+4{l2Cz5}lR%fHf&deA`J1D7utgy8apgb}!G
zpNP}=m6E_z0yLhD=N4ap`^VDADsXp116zT|(y@A{S-RkXTsm+^N(b)!ohxT?54?HV
ztsP?X{2u}r{(_cA0RHJ8)8raiJhAxH;<@&w{<8euav627fCl1gaCxP)o0*k!enz+L
zalt!R(Ej_o-X8y>PNh?0up4N+dJY|e5&FBS)Dd{e+fTr~chdGL_+PI)g&zM42&A8<
z7n2v@Z|5(SEy2&_Lso;!_Uc_`g<k)2I>g;~;q^av(1Qk7aRVP*ItaiY%n6OaW&82Q
zdHsca*Sd5QXeXyq(jWtmc>6iHY`*|Miw97Fzdhy=*ARFKH|U&WmQFh8f<KZ+?19Vn
zKKKc|eLRGKG#G(@k{cx8vV97kaD`^zvi+QVd;R|s?x3_ZsKC$T3a!DVgU-9n%6*Xc
z?;745e`(+u0i}M)9Sp!_`yu$3dHV=lwokzKZWC(f-xLDUU<Uqp9zg*vr|>2ClDA)h
zf1iEbxSs!V2E0FCLUqnHOSj~ab-`aH%N6{m+(94wx9o$h)B2O|^(EVYUVd_S%M3g_
zm~J*V1FzU~aJhH%96Z@Cewps5fPgxLI#__0+(8L0--=W3F)JtEe(Qk0>2-9<cVh@_
zuF)(WSbSvh#Nt!-&GrAg_~I~!23NB$!2Nw`1QodaXwBN<&U=jt#hYKh>6w9z``~hy
zoFTY#8YMIVk5&ihL!5#KZ)qQ0oB20`K=oOA^vl5&`y9OHdq))D9zTj!;N@Q^p;hbc
z{FmiN88z@eqeMy)>VQi^4!9)L1($^SJKpxMg0E3V{!T!<E>ZIXCE$`!2rdbYz$Kvw
zyh%v+uTlskzomqx;8LL+ToRgtOF{*>B(!*6Y?fL|w1NiN6_ij7E(vvJ=6)n02V4^B
ziqrU;_kej4xe{pW-~35JK6v<3N@xHs35DR2&<H%1j3Nj~LSt}AXbK+um=em+c@E9N
zIiXk;5Rilx;F3@YE(z7>-=u`r;8G#y{p}%Z>MzSrO4QYXtxG~KxFpmAmxKo3#UCl5
zVAq@em1H#94KywZMc|Uq7+excz$Kvx`0KB8sy_dyY!88^e>DeBPoO6xCAi#(cnL1s
z*WhwP<MsRD`d@aWK431VO(NjsztY3BgU;WU>w<^u?#A2tH-B<R<K8Afo^b;Y{IaHW
z?cc!Sp~c7OG4E&w0l5jq0=)gscKf#im#=JhK4?}>zOvl|m#=Kc0|>}>wnyOdo$Uzx
zIC<E$cn1Di-hNKLz5Y+$%99Hk$OnpRaQQ&7^C5G@34ai=3m(3d_U{?q9Dn)rYu^Yo
zpHkrl0l0jOb_g!}3Be_i5xD*oZ9D%W2oyZ&#^3>a0^WR#R?mqEc+T6W==|ZeS>t;C
z%NekK3YDmU2L2cLY8YI8P^bc5Urx{OJO5=Kn(}^hwe4)3*57;hi9~lB&?EXUb{G6(
z^27uD0(KAlV)j1x*W{N>eF%Jq8w|jI$R2=Sy`m8h!LR!(@(_G4_E8Lhn{XfkzXkgk
zyvv?|@5ep?za4wZzPbLt#p!fLn?VEdCAhr8S%JTV_p=6<A0F%dw=pN0`+xp|CfC3W
zC^-X;z$^YK^$EDocR-k-^Y#ny{D0arX*2&y2>g&oumZo!>#0KB4;v#;{<G=RGcI`c
zzw|NPK6v#r8t}07cK*xqllSk(&_Le5pMnQR(Y;^i;OUnsp#ogCU+lPEe+fgm6KL08
z&Nm`hg8L7m4l3}Fw_kzFeroXgfd|q0Uqj$5F13@JrIt4;df@U#g>Uhp#hd#NnjOeH
z7!zn9o>_bj-n_HX7O?qo3v>VCD{&gXQW8+-nGNKX5f@x0V;?+t_8oM`K6uDJ0FNaQ
zKtOy59(;p8d=6gH_j%PA{C`tgH7WSd-=IBKGYI(Kr49=4?8P*)1$fQdSK!r&wEYU4
zJ67r=ZKa#~%kq;zR|mE}ej|;*v-rT`A@~Q*p#6+@y*>UCNOuD}KC^gX@ukJ<J-D8K
zosXK6P7-o0-nV#Q@sY)okHYo8bUd{*$SuCGcm*!+A+0yg>rVpC|Cp5!?}7j8U+HnZ
z4?bicfXjZy;AzaCZl6LRV4tHG^y1VK+_{Ln0+){07LT2eSw?Je-{M1yM;4!uZ?FF)
z)6CLfZt)d(#4o#bK5h;y;)*(kH^*N(?iqot`xcMD<>s;}c*zM(!F9jw{LA+gXnbMu
z%HnJA;^%ZGbv|KMBD>&@&EA_YJ~mG4U;ndtCUiM9@Ss7tpay;P^J)74Ty<#sA$V~K
zZ69r&*WcTy!FU_cDb*jR1}V6EE}h$_;Qp6r`y4zvhW0-PKmGEUAE&PoAYXyYT<Olu
zlFEC*eQ=o*LvY3K5szaC$oF-o;OT|5zUSbMy!Z_MyWi3PmKLwsH`o8tpz}#{Wa6&H
z`xXx@J~BPtEWgAIsP|n>BbZt|2mjF9>EX2kkGMkWd~;x>u4ps=TnKo4iuJ*BJ_I3n
z&8OZ3JmURKz$MXn>+SrP3lNVxSV9AjJ6MC4?CMkI$ij!x<#`8O-UV}ZT(3X*3DxdS
zpk03n@5luY*nRMlM;xN_AxOaM3;Ff`3<4?dXa;_fdc8g`l;Am^Vr%e-E4l{X>m4*#
zoKM5`fBAemf%HCYmNfk*DyavaJcPUtE?>d$!R1r5kvO0Kls}>!r4rENY+eKYI(ZHr
z9#4su;65i*gR6h0{j9;`@-*6!bAdTxx&LPuT;Ay%fXh3b0k~9j1n!*uigt*xiXb2j
zCgAnkbOV)w^N!RMToTE^3x1M1)85oymY?%rE;TerxWOD;c2s~Xes;V7e*#asYS-K2
zFF!!E-VN-ybD?=?Wc!}QeTxtG;ClW=5Rmt9Cl=2vKDT%Y{-phA`K>O5>wkG~S6yU|
zxP7Oh{p(uX0}uW}lX?Iy?=J)!=k+HIMw@`{PsuwK5xDGV3@(Wz;L*`Ew<h3z%#$vK
zK*W=73NCL{WZ;#|YH)d@qOf?pv;=C4cM9{+$V)XYxV#P+fXf>g5&8D|U*5q;p@F=E
zk%P-S7$vy8fl-6Y8yL=Kb_dWLf4Nz#X9Sw#&%gT-fXfe)M&Rk^?y4tE3SK>hCSwk+
zzeU&1zY+s{d%YSwVqb&j?CP_-BWvEilkLFe#N{-u=f9i*J)VqRXdq`m7hG=H+5?v}
zpa)()mzU+%dHtPBSGU17pi3zYM&NRz(g<8`R5}KiL=tdye9Y?-0tKJLQ}E5Q1kd;$
zaT)k#S%Q0g>bHm?AU6(NfJ=i4Ty8+P0+;>N;4}XBn*Y1G{+AmNs?V8|DCbIaz-3N2
z;Bo`PF1XAI*YxK8AAHHxHv>v;Ch4Q|_CxTLS3w9a`x${#BF+4ZARx<Q3|?_15^$-+
z1YB-PnSx6trmeU0UzT6i;|maIAUB<zgUj|MczPo3X9+I*sdikiKb=XF$Z99huD|Hz
zw4)lGE3pQbN~q79b4YGp+W~JXLF?avKyV~=+yj@J&U)ao{Q%tKw^{;l+0XFvv6-nP
z5<&x+6C?1FD-nT9CC1=#^V&q5#^2PMcQlbeTmR-yR!0V2@Qq4m;Ie%I?(y~u@K|<K
zLO>E(f;-34p{c+F9>5A*Dp7;;&1;+Q|3W}2p)NKLP4*9Z@aTd^{LIM(m+kxLd@1H@
zZ|X10Pj)nb29ihsUh*Z^5M1%2Xb3Kk9iv@ukH73F+6^>baR+1Y<W*FO6g=V^i%r30
z`yAYD9(DEnn?pc$RDeq&3-FLTF2QS_6H9QZM0GJ-|L6QLx`GB$i5lEJohs4!f;m@Y
z01mip-`hB^zqS<ZpSKC<e=6BgA6ydg!KD%daE~hyfJd=RA_zz&LU5_X2s}BNDv^N8
z04CtFeVjo+Dlr3>9p&JX$Q)cMQGh#Ki3R!g`d=nR2@RwYOK_<~1zx|1DzOHa0jMwT
z&Xwl)OM|WvXr34FoN&QqM?G*!!~>T~^udGnJkicS9|BT|0k~8m0GCP(!M%IasX79e
z0gM~h^Iy(@(jbKfQi&<J>?i}5L}uVpiG1s{{t})P^KC${KdD3kE|pk-OC?Hhbpp+a
z6?pW%nAUv_0cp@#>`s>LoN&OU5?ydf#08g1^kN8PTnP_cD$xg*O8DSXi2=Aw_K<yZ
z{VyXJSsEnZGAAbBvY!-O5}BGFD=9^022{$Gn1M?ra&W1{99$|<fID8hI-2>ngn*2o
z0;dK_t-+-d>PzNak^OYQB@w6fcK*xqlS*`<LCBSG!KD&CaH)g`E|uu-xL$wtX|xLb
zoj|+(@?+@)G5~j;Lmq%fZ>RkX(Ruq2+&P0^{~tl1;*KNmFr^O0;2Ce9fcxC>1l&EF
z_LF`IuK!DJFog!uo2fwtE{V>-3%(C{4qkGib8$NVH6J$RjtdF2^>6-)v#8?*xOW^K
zf)YG<3vIsymqaV@IC&j4SV17<OlxqD6J3MnQ`(REvbhQ}-o67~zDaK%D+dCSX&2n(
zN$P^9oM;a`;Ep};;+>ReUwc!3S$>L3>O+J43~Dd{mqY{b;&j@62p(~w;jZiB&zX*P
z1I@9o-%2}*z;jM?3?99awokw%(Fu54QQdzEfr2xgg1ek(2A;ixI-Y@toM;a2y@9r$
ze;Ka-CDQ^Lq_3w23-E*!Ex~K{C3uz5eyWZ0`m1@_tTq9?`jmSnHK@^f1kP8?*)Bgu
z;ek8+8PPtt8}qMS_z+lghXe4OpDzU9E<foUf``0)2rfTf5sx5HbAt)E_hh<+nt{9g
zdcXp_;18j$z~y$_ov-T3ZLj}}<EVok1vbkv<QoVNz~xsnM&Lfb+&%%%M?3(-+vERq
z3M`C3bL!<gqL<+Ec|i3w^VqBZr2V+yNl5O4J5O!A?LUNoM?a0I67Y(B0v=4LgA815
zN?(B2{IXuvxSs!V29&$ftFN0Qlbh1J=zLRpA6#x$AA-xx>PK6r^_SkB9?g<%fY#sR
zZl?d6fy;M43UK~WNwolX-b@v$z`dWx^jU0mi8*4IZ?W6~FP5|;7d+(`8hvn2&iUX8
zzkQ#?5GeTAWZ)^EKnn1R?|!`i|J3#9lM+jC^?!5+v=#g2`u`Gcu!aWz$KEN;3a#0@
z;Mci6b=(8L6?<TMbN&AuDrsZ}RLRRJ1y{$?_BnWd4EY@WD)JJXzOK{Eza<26Zcu~E
z_kPyk^1UDR4YNX<M8Ng;ewu0RwBF8tS$-~G=Xaq&!lz^xT)y|y16RDC0l3_ZD%f$o
z{^YwEqn$vz?xI6^S%L?zA<w{5p1d<~|E{!sfqn_U{$D{rehFa(zB%=N(=4@k7yKsg
zq|Xg_79V^QuK(ZsE@}`$1Mw6*;d{a5;35BFN(r8Sn7+QZ6sPlFQ|lkmEUhKb*1!3y
zA46wA=Ue88gXjPq_rTRBsDl7Jzd7CWEdr0_zMW$T$bCB#aK3M+nt;n~I5UgS!5{P<
zUFqiizdZ+(`nEY@xo@WnE;lgs!R7v+1Ms&}$12p`)L)jL1jf+dhVP|0k%E7neP;2(
z;`Oe#$6vlmwcZUhzK=&8JKr%YA>OmN4=(oy8ScUL{EPMwXlK{N;+e(g;0Nwaj|COD
zd=GH-9k~8Kfg7x$!FlYR@0yi3=Yv!s*W!KfUw??U4>qpHuapEvn?O7MttS?rT095;
zGY_BucjJfCx?Dn_IJTz~sK761?%CA-t-;UwGr99UvqI%vX#YL%^c32E>_H$nlo|}c
zomWtU06cs!Z9f8cFQV-uaCJ0oKOx^<|5w+d1}QX%o<I#|;N=;#eGVQTL)$OF-CNW4
zrQyx-&+bDFRz{%lA5eoDJUWiH?<~zyyLX`N9dJ1`y*+t5|NK1#8XsCbviQW}8F;!s
z4Pf55p8uV8Mm2xQEh$hy1OG`hvW3M<aQR;F%HryOH<hFHCk?vWfKEu<v-rT`p~c77
zaQ^&%dW`@rry01MN(+lGEnZu^6MuhG3O!=!zy*&cbZGkEYDVsZSGOP^fV+H%1NP1J
z|MPP?HIAUcSGsf#PrzmSDY*MW>Np1vPa~h39;@JW6e!Gql8;a?z~v*<YjB76)BS;2
zQI~(<)CG60)eg9sfBiiMn%i<%d;~5ZTAhNY-0>V-e$r{#dOQDR`Q?1f*3e*cN8?M)
zkvV(QO=|n#a(n(Ec*VbfINou+{wn^}tLaXlosIGp>^XS$82TmCB|6_?c?~YFq;!91
z4j{SpZE5}YA&?$OKQilshx_oXMweL)E|YNt?(tli{1C4H13m;ZXyEd%;4Q!t-hPEH
zKVk)*@m;grA8{pU{LQJC?^f?ipsj!NCmw>Aa(8=hNA7M9uK2c{1$bQZGnEPg6}$Se
zdCW@o4tQ}J`bMM!zF_Zym*lZ>A+Y2IJ@AU%17ETC!E1IOe9b=4-qc@~-y`@;7eIqY
zvk$?KVh_RpgM9@4RQ71s+v9&U2gbXB#-GiefJf{Zc)~wYQGgeJJfxjUssfMRbO=5E
ztI9ma&Slh~1706Yj|E-un;pWh`GDVzy$}9q_CW>L{}Bg<(BNeD5%}BK$KdZ}pMamo
zKHWI4zw<dT+XQsQ)X&-H;Mck{KeGXsTdS|YAIRIU!Go9so&Pfrfn?eRe==|113!kn
z5B^H_0r<Pw;~@k-!GQ$4ej?3@3|xLYrT~`*p#}Ike2>W``S$wXIh0DOeqvT4yplS0
z!Cju!K6uXChu}VYVt8}>Qx0TCpn2(qy#P<xEAW6_{nQ*l#_oa#?Eu>O=R+Xk1|fLK
zo`6^E8F;~7fGas4G_L2roB<sUsGpf5@Yr2&pWO$S*OUg}@|sexby|P&qSA01(CbfL
zREjK~fjc}&3-HZPxPV`h$8^=ZhCp$hJL?3xKQ}88@`(H3Df<vyz4j!%pE0=e8=BNf
z41rhk@<_oSz^fwzmvx+jf8ZAMa9n^tjQ3NrZ?6BJ$$<(QoXB2-pUSR&VOA((cfjAr
z?wTH}{7+Phz8O&U^$yjg8-j;7rfa|u{NCr$p&VO0-J>`2Zw7%=?m{P`Ik<GN0+-)(
z>ip8IguF1>126c}&1=1#|FZl}J%T#+p}`sK0r=VMA$ZOnfjhUQIg#u*tv^0C=}w@n
z{a);I@a!LS$d=&6-^kbCzO1H|S)t~q9H@U60*^bKD&c|u^zK|C@GIB@@ax@!whzH?
z#U8C<GoyQOU<wWLt7&9&@Q{58Uh_|}R^YefL~C&xe^Y7>s9%{0$#sAOetX{D1ut(+
z$JhhE2XF6##}DT~0D-5nkHM?IQzfS0;jg(u;OSN5OYoA;fX(OsAt3Mls9&3vkU8Oi
zM|{X!@RQj+@OQHN+MD{z@(X{#KMn;AKFtk6@UO8);6Gze!2ilV+jV{XuT2j&i`_uG
z{<zdD@Kn+Eoy*J$CHzBWJ#cybU;y6!B9iWZ1cB_gbj&8;4zJ@Gc=J5IO;;_z3w}5*
z!R2{Gbs1d$%M*zj8psm{b-6iWd0yav%ku&kT%H$r8|U>W%go;d^njE+F9^WpiAo6m
z$a~TWCjx&VdjfuD%z+dFH{6@naRx3=sdDf`c>4leo_Lhtfn5Jr5RgjL;PM1R{l+{5
z@&v;H{{j!p1^)@VN4~xOmn#_`8mzfN0Dki$snla|`8BL5xcqunW_WY__x?CtILwVe
z^Rb-2&?+dwQ(gr%c*1YVI=?k5RNaIwSUhmmF5`Co^&uc<x&io;`B8BQek}V4JYgS$
zzma{?xSs!V2Fy7yg$CbXpMn2~eGYyZ`vUw*_T|=T{mG-&Y8%k&@A@7c<2Crc?4944
zr9Oha3;s{+J@DnNV_If?2t1q{48R}DJ_P@F_7V68_;P*>E{Av$L*S{rqbd0F*=OJ>
z`yAZ6lpf3$;Qz(jFWEQO{}*y#1r5H#z6QUHy;GZq;6`_)L)Hb~m%V3t^ZP%XY2OT}
z1G&Kf{Lbt{aG7)?@O$$1WALN2H}h`-ffKpG6#Pu~8Tg0U=iukFFTf?yW$W$ym*sac
zH&{V~ntcs^9lp-*Twxx9L)g3E4`=V~xL$u><|m8&oj|+(j^zde@L%)xL-0@X_9O5G
z`xv~b1g-xG1is4+rr<UE4E&~dqe(Xhzcc#+{DJJtE8zP7aU57dgX7uP;4kLK4(Ipg
zA$U1IIJw~8;fGyMoW`%zr5x}jpwE9wy@gL80r<~(`w;vfe##bsAI6@5$9;M32Z0aq
zh%@l}a>qHiJb@{|<rz;2&es{SsvscGY-(_Mj8K0tOD)fA9B_GJ<ATc*8&7*ve_4KS
z;t~7MKt?<Qclfzq1pXU7_6c~mPm?s=_4fE*!f(CKb_0#S>JxNfQdqnOPx<$Moh!`>
z$=i4ydh-j5dj16v2>DJXL+}+R6j^*?@yz1$E8+TIIw&m-Ru)%(G)FA^=~{fSabADv
zKJ*M`v<cAq^Z1#~1YAlwLw^IkXte;BXGkTu6VIu^3IfIchv^JDe=<iVZ$$RMQ|{OU
z|Cc$<p#iwu&^Qh)fw9F?@c-rxX5iH+G=LmjZbCOF-(LUAP3Q_}piZS7Ex=3epalOP
z{t?QR#nqp8E7}}?x%G0_2yET6_`u?!#mC_KqaN-2OCca17%IT!bAk(S`OHXV@wLUB
zHC+G8j(Sa?{gX4JxNq?xxWkh=0<RCCLpk0$t-p$Ad$JAa1mrUy6L9$q$Q<0;k2+X_
zhc0;q?!POh<+sMbmk-bhsK1z%kh|Y`;Bxo7KKK(apyd~U$4@68#SoANiN&WD&n>>N
zc*VZC{+Eu|mIlsW%}U7jJ&XGmADSL3*->N$Ha@X<X7Rbj%RPEC|5kepG>89hdmga|
zF86rtgMUJfy~RhZxAR|?+4Mk~6bUqtpJtna%TKfA7GGGr+Ht-9=%Y~0he~$>?erIS
z{%%%6yaz7#4fHKOyr%2^Rdmfj+rOHC%SWv;aJfI=+~Os;I-ehP{|?vxa$mpN(x7vd
zSqZs6paU-Z>4Hllt~iaq`LJnCXQ-Y8^!S_q`3+_2ftQz)_rc}<fIfK5+Yi9w!9_Ib
zLI}u>1IHFmEk3h&0bYJg4<J@c2n7G&?`VSO>??4&)>Hp54~=-&;-2=V{<8d}!NAfW
z1V88wRJk$ukv;Mh{1aU1*{-+8UjoH$pmjchEWt0kkUFR>-nrVW#A6ED-UV+zvZd!=
z4+8R;Ef1VOv!(jr@{uhcTt2cj0GE$!1y{rMzkFtE2o2;jTOs)VK0T!xf#04z0`IYp
zH_q$tFb*V}0Ik0x*eBpevZvtpWuJmSkUax`QG65~n-T(Yt+xc1UqGqB<rh#o>O7sf
zOlol#d~^NZw*&%kxk?^cJOTF>bT`ZixXYfBZ?FHQ!PL?q1DEY*;L<@3F5AxyZ;rpu
z85KsLxfc}s0$e&M!Dag;xNKj6>+Re5w}L?MB`RGFp8SA*=c{uq^BAYghw5YQfS2DS
z?}EGEBX=9u^Is;5d;NjlQ4bm%&%b8lTYPBo$l{Z&)B2MRvTZ;oB0jfxY4MfC)wRva
z9rpnK{7)AGkGv->OV8p1@N+&(+lLk(gUjy-q_HJ1vv>ji*2mBpumnH-@>6sL)pg7f
zr~E4zF8k*CU#?<(XyEWK6%4?ogV5q*i>Ic?s`pqLL1qS2=L#CZ+~TFhR~A>-H7h~;
zZ{}YY0yq5}AA5@rz~w7hA^0mlPx~2LJZ-(5|FZmKeb1ml^r6G`vCP3k_Bpu!d)mGL
zuis1SezD_v{U!WmvvMb(d;BCdSb}?>C$GT$cag8agZGfv;Nck$rS-qYz*ne&x}JH=
z{>tBe^S}eX&wn3WwjY5z^3x30i_H#l{z-)yHeg?Xr=O>b)e>AfURhjSpZlfpD<uuO
z5}?()anIr*c+Ts41TOnez+(waAt1g0mtQ(5!DaiE#k)5!E6u-((|rCP0<xpN#RH3v
zES^|=s=cYdEI;Wuw=`H-yt4S(;!bC$67BJqj(fX-9Up?rZ^VqjbDq@+xa@zr2iNm&
z0fC6m`6amQXk~G=*Urdx2GF&*x7T?z|K$+KE1v^sARbzLZ1EX*z{_>9aq3_BGU82u
z)}M5|vbegTIbzwqYjF=f=I`weFu)#Kd<-t%luRu?vv^!s0!#4c^3U<q7I$xCR-*dC
zU3Ce2;QnXHJ@W1KzpMBX3L1F4qY=3CIoi<#T((caW&7Ol=J+Sv!Q2Qmcfa@yb+81N
z4k~czK>fe-^vGpWOC>tsx)SaD>p>v<B9{m}<<bS<lF$%b5*mZc_DSP<{!6CPAj1Zn
z&<wof3gzH(C>P)l`63<SYU{NA($naf&3YTqC9Ho>u5Jt^y@H<!fy?^^4!FEu;DcvZ
z#I&Oj0^uLXN8s*@$rEt-wVVmKcO`9~qVG??gglKQAn$@@-~sPw2JW)w;POUA1ukz?
ztk^f#|KENF9UFBMv()lqGhJ|b4cN2zz~Z6lv62^!$7W#Tsl{g&FD$;?qc`)fhQJ-K
zO_k`})U1TKYw^Ct1B;JZZ|A=(Kj|Q`G?-dExA+2FUOlgNT(7_IgnjjLTkQl|DBnh2
zg9oo9UxQ~Oa^;wnOC$0Qc>SDxY5hA8DBeyDJaC5-?So6AK6rf+?Pmb)Jc~SV;QHS`
zo&rN?5FAGyf@hp)0v<h=wx594T+vjV#^1aL{0eF?m4H4V&387rq#1a@C7pps&!PR~
z;5jE+g2y$NbO`~;v;y~EOC7AhBQ9wT9&kn1;3ZYG8UM{-vT&v@xX&f+fjehYLLRu6
zlJ~(AuBflQ>0g##&6y6MLCVKI053Vw2%QrhgG)t|U2l)Sa~5Sf*$uSEpG%s8hkWd(
z;3*&b3_Rcp72s);sGffd2*`3O!Gq^hqD%0E6Rp5guILIpI+pfR-wdw*11_m^b8}AQ
zJW0FYQc@S(J%c*vfd_o-y^ZVfH)lF7X@3)-_2+R(eejS=8lv;DAAw7v5x5s8l<61(
z8J9Fc=aNpqYc6RD?!1HcpMxu|Xgr62ET;lIdL!*<0bU(LUV=wl(It4!tEnR2UjK)D
z?A0yIV_$Hl9dIeBgZ>&ys0&_lqORfX@#m8Ej6kz2`Ph5l5hogeyL{}2;If)R^p`h@
zw*8MFka4CFc+I67gFDZr5hvgYCz^q~T+vzMdj4<Dfc)r`Lxbck)WIA)<w;tAmt4^W
zcr9~f>$Lt#UQYEkpx2+znXbX**sHzGxl*1+iFUvPPSgPpkB_NA7Xlua)CG??Q6IeI
zL<iuKXaMfMg!&!E5J>q96@t55(h+#diALZVCz^s+JV~eQo9lm>r5QAEUPPJBz)Mav
z2lqJ9Ie5v57N$3!|K(X)nE~Z+rYm%rE8yv=l;|3~;6&9v=3H^~396ZY9SC@QDs{jW
zC+dL*oM<0hD(ZvhucAZ;t+(@EmS4)tBY*}0pGt?|IVT!|`&^*}JmpC`*>S!8B-3;!
z(5^r46v}i8p7V0bz!N_9Gw_^`eU5%MU;md72sqOvxFlME*D_bYbFOF&UT~u8ec<{(
z;!~`;r8!v?Ka9HI9w*uZmqa~q=M7ZRzBrx#nkS(=OMMCG^I!A1AU^g3a7Qjm!3#e2
z5qQOkj=^KeG=YG_52F)smydl4?s1}1aEB*p2JTU!u__>-_*gE$YkqJl!HYLhNtfUr
zCt88~oajn>yZ*V<IX~Xl(4gXyI=3?CM8=7B!Q~3d1<y~XM0>m59{-S!y|)`^+~HZ;
z2d{ZK`QR>}phED7kNpU|t*D-V5d`uVP^M#aPBa0pIME5X$CETg=S1^c!S#R6C7nY9
zIras3IHp7w=zQ!;@SKnRa^t-I0zUTDCP0&-=3}qA=CLn0(GIw*CI>uvD<#?m_hZh~
zg+Rn5?SYqaQ3~$z2`T`udBj6-nWS+Df$DXX=?J{wL?iH=6CHyGJV_Jqlq;H%Z?FG7
zF6j&!NJ(?>;zUYx4({_LEx;45#KQ3A_@{h^Dvdz%xgegUHF(C$X$>wVRkt?hN_8eB
z+5u162d8%aIS{Bg(=K?#C3V3aPSgiaIMD&PR5WN@&wn`sRxhJWhtQzlhtUw+<wQr|
zC08^8uQ}0l>$Lt7KK9dXK(9Yp_ZfKdQc83N9`Uiy!4)Su2M><r>;D1*3D43B{2PbT
zYr|`B`2ezW8}rzU_rP<0!^4juARinafJ=iATt0w20+;<n;F8FgeRKUU9~@4gLG?>|
z2V(-Bu&3a%pDB3B+h?Z7N<L^jHv=0lExxjN_qOICkgsa>!Rd#{oB20{fcy~o7+ijc
zd<rf<L_P<XA0l6Z%MX#STW{yTEI-9>M0WQzM<Dm_=z}MGlSv<3-c1{V7yPc-c*phn
zlW(U@cLMGD%PzjFUWRjU`4ZX^yyWfI;1&ONOm{zXV8yX_qV?a0K+eAjF$9;N<rsq}
z{M#;5@Zeeen-J){{c=CJ{?GVFCn{(lA4FV(%kKj8_BTfs9(^}mxdFI$pGRpQiPQMo
zo6X)`2PP8G|7xCsy}Gae-wa$nADn}~<a9bgEx`SI-9zuE0*}L-0xJlV*C$s8m?JB{
zcptqZ7u<O%CF+Cwhd)AZKLA&E)cbFK{{sTa6He3(M&R5)CE(8cDbWeI>?Z}6M5fxC
z`pfe3c}E#E2p>ir%)ov296USmpY;Id-~n%6?0S3rzva>~t9Jv9=g*)?<hbS`C_YY;
zs0)79>uEn8cyC0XupEMWKRS^f|3e4_PrfG|0`UAaN+<%ac&<#qqi50fGjR9aRMCYC
z*Z<`?6j(t6|GTt0ItQAS@Ot;siT1!lo{S#&-LFfx`|vl;>+e6fM8PJY_p6R$55Z4n
zkHF7nPr&EwDfqWy4rCCxl065%&9mrO7T`y+m*CltPtzl*z#q-q$2A0w;()rHS?cPx
zbZENZ#p!g6UGVSxm_EMS2haDV{RHIO>;EdF9Sxy@>?pGM6#OSVfEoB-o=KIP8{Qm$
zSuP7B&^#~r=*M*FN^qYi=Mr2xSb-nThtj#dS<%}Z(<Ic+KNkYBBM)2>^}%PH=m1<2
z4ZvmpVdHxK%NbBIoj`*}x0yD7Q*hbQ3|tbOgO54UV(Ya2B-6z<pgWWfmf(`8x`SEL
zQ#ervT=wIFdu~iS@E{O!rhRZp)CZRi0&q!m4E|Y8bP_{Ab~FW-lFq;jPBaIXMCahL
z{{{Qz`d>1wp}}7{Q*}qP)UqQ7ToQG`YfiLhdUO9DUQV7FP||@9E{Tr7k9ams(lNN~
zX97-%HuG-^fhA{}flHz@aOq$UE{Rs)$8e%`>+SrP<tIB*cQQ*YC3V0%|3fFJF1RG>
zg3JEB9oOqmG9B&&+Vyu1XF39x9gV>y(FwTAiKgI9qO|^}5ReXL;F4$w{(Vlg0+;>N
z;F731h}XXyf)QuhImkQ&Qc?$8I&i@y(E<3)kEKaE6sPg4&1@e@K%f7%4^Ct7J|~)h
zOQI8SNpuPxOQr<`9>$rL;Ig9%TuNGl2b|~{oD*%v-!n@s9XQ~UXdnC}PILe+`x$~u
zq9g51|8nee&NPAsQqnQFbT9#zM04=-IniR*+v6`gDt7~oOQse0niE}tOQJQn>|Y&h
zR=Q18&%Yi7e$Scq!DUASa7lCsKIKG1a7lD@FkJsj2V-a;CC$JOc@8b799;HOfJ>s~
z#`XA{JC|~%%T0jRpJZBrO9wT$B-%a1EcJhKqCN1x#C%oShk#@{08cp409+Csf=i+!
za7i>yA@EktGy|6%<=~QN0q%T^9-J27l4wc3z5bUDDrg{?cJ6GJ^qZV$7hLw!1D8bm
zhBwE*;*$DCpn3hDFH8pD(!mg15>3EwcpOdA6kPA8oqrhwB-0$c$0ePEOQHq1BwB(?
zqU*->{FgJ}gE-U9p=PONM_q79v<L2Uq8>U|w7+#)f6~EV8_?@dGL67b<U|v2*-r{C
ziDux#kHs`gXAqE*=HSvn0WOKIz;jM?4KDlX#D|%smQ1_g5tq~jmqdHu(m@|w5)Iim
z*Z;rdOe1I@J4(PM(G+~biB7>K(aiLC^XQkG0VSC(z~$AfCHPUt(=uCu|2uo<E@q_<
z(B90yE(B!6J#a~+4?g}l%^@FLMmzwQ{SRAj=f5mJ8F2y)p2Q<a!DUAoxFni`ujKr(
z<9hu`ro~R6U4PO+2`-7Q!OxIVA8wXf_R|G#5~cOugFq%H5O7Jf4=x=Hz$MWTT;@=8
zI9&f<FQQ45K!d&6Q}DysGw=to=ipCZFU4v6N_~w>S4lvh|F(yq2A2^j&n$Jwld%IX
zm2<#jDV+-eDP132N;d$P<u?RBn@2nbe>!=rCJ>N>rr?su4BX=p=ioBpIk@b9p}na;
zF25QYyq8Cy?rN4=cI1G|nb8F=c~bXwy*>Vtska;0S$;ma9GW4x9GVfh9GWrsEl=R<
z|0x81#3P=8%ZTUTlE?yF@u4ZfWx&h3TCV?B&_G7)9AO@U1DX-Ee=fKr>VeCd(cd_)
zzX4}D*aY-`H-{zwmkvU3Npu2!6el_b-(3ICARw8}!MmJj0WKw7fJ>rFa7i>)cQZ@+
zdd}1VmmRs_lBfqh=h@x|mqdN?YhM2c&_FUBgMX0|oq$WCQ*c?9GsBzXpUMfu2yB<-
z99%kBfJ>q^_|=@Ky1Q9vy`OgeIS`OcUGNzv+5?x8df<|%4=#xg8`tw+&Vce(O9Bm!
zd@etO0hbOka2Y@jUhn|sTc`CWBPg~3z5b+w5?n^G20xw??c8GzrEd1v1>d~>--E#7
z6Ld}IflH!&a7lCkE{R6q@8d+17y`1R6kJN0fhU~k3|tb;!Dasi`{w#zGF?G~A9JQ_
zaM@Ako@S{f(Jpw-iMpn5U;po!fz8EdA6ya*!Eg0Enxql9B$|LzqV4*JfXkUq!KI`b
zxO9+%OQK8gM{=U8*4z0n%TIQ+h6Ym7&XH!Rm%N-Da7nZaF8lB8xL$vfX|NM$*WYV6
z(-2&C6oE^k33$a7oq#uq()v#!ART1jlIQ~bB2IJ(F8f)5OQP!|;rf5dnX0~7YAI<4
zTsr82OQJsbpE=P$oW{Ss&JQKf*1!3aOe64UPA8}_xFni@OQI?G=Jo$M1P*^bEvE&z
z>}UxtiLSu=T+tew6K#I~3j)$X=U(O^kdk`f&*VgXaM@1)E{TTPoBGT0>u{zcXdoqx
zz@>u(ToRpuzmpT4?|OUuWk-wMz|OH>f(M*v1uluMz-9ky@HSCB|J-|<rT!jg>VeCS
zd~hjg06yVKIs}(Q!+Tq<|08H1C7pub^aV6YXW)|P99$AzY@FAh!<m+wK)d+1*MLiK
z>0kvei8}W&EBa7Q)CJ#M|9cRSOnq>l6CI%QORE96BpQNCqVWU*F=sjjmmST(CDA$f
znkQ)iF2{aBe$DIuB{Yys)qTy9eu5Kqz$H-^ToUyRZ;pS)CG8u5?Xma4rGo%m5*>s8
zjuV}L>;1IzZwdj)bOt`+lIGx2(mA*!x&W6%>&Er`mowl&FQnz9?q`--cI1FdqAqwX
zPgKAqQE%(C{-gtc8_>&7G97_Gg%cfv%YG){lIRqCIOo^@GYCkgGjQo(4lapS;Ae88
zHMs0Y#rHQ$EtxvtJ)Wdpa7ok!mkvB|Np#4*x&FU|GaW$#+0htW5}kn0Infkc5}lg9
zef@uC1~#w%m*6*e5lzwxToSFp<pm1$0JGAiPPCbS9SBIK4!CsSf=fvU;1A$Lhv2fG
zQS0sem*pp!j-kPdOPYX7q7!iGU<xjY7CWxj--|fYawpKPKiN?QF2}wG?|zalO4s0$
zsPfH2(CnYqzXJiuv=9DaPILe+i4MUf(Gj@fL?b^oGm=cl&_FtvfJ>q|_%Aup0$lb}
ziqrVF*ZGwM^!cxG&U6JXiPqrKfqI}hFiErv9?OfyJqWZf4!3`O@PdCOcL09Wn6@8+
zKb?I9&Tq>#um3~f0B$e^myylDWkhrE0ava7m&z@)H}#k0Cmk%Ifs{@?$Si5Xi8|o2
z9~WFEqqpnr@eeuE{%)Xg$<zmz4gzpVbObJkcnn@Q1JLtt0)aovAppPDiFAx-;PMvh
z0({Q<S%S*|Ru6*f{}FGvh6X8DNIlp*1X7_6xOC73mkRkC=k?d&kp-JTJNLI|zz|##
zjljp8=onlQO~5zT|0x6{(*nHw^1tfDDsZ`d_Zr;ifps48|LMB(z<KWZe&9n|wx=PE
ztq_BxHqLQoE650ql|(bqhILOJv5v?fSQ2LH>WU*%QC&nj;#x-;L9#)ZIAWa{A+f|U
zu3xtlOVQQR{AT9$dhYJ~neTl6A&=L--|yG^^?twSGoStJVO9<min<iQF71)8b!IL(
zX4WUi00VMNEEM0}|Bp4(m>Qs?gdB;c<TFilMvg=?!>jej0J#ycwl^Rv@=O!mkfWc@
zUz?>yqFwU5PPE>C4h4{Dj~oN^$x+gPe5Hwo<me}^yxIS_0wU9d8Z5P>Q*tDll4F33
z9EmP>F6YmAfm~QtyFjzc(b0w+iFS@POWpa1+<@5RNVH4-+b2gdaE}7W)F*$2CK`|<
z(U2U8#^jDBI*BNNOcQbpkdh<O1^GKP(Iq+hS*dUD|B>m28u*&2^&qp<NVG$a0lMT!
z)H6M@zN4A?W?*|P19Bu9lJ_;yF*y>A$tBTh|0NVarZaN<b*v!2=^3(zN^(?UO^yjz
zgQ}wS{>Sl~>I^z{V9zlFn;Zi;<e0#K{BJbT;hs0=4;_v60(An&bWA?dL}PL!Iw42@
zQ}QZNIsZ8YUapxI<mjj*N1|);SQFilBT?(YbpMY5><61mfRgsfKdy-m$kES`9EpzL
zGXLtmo|<WhKwbapA2J=2V}J=c5>3gmdFSNY`~L+6t~pb7^^&~vLcLUz<CRSt@*C;n
zJI9$7Jxn~Zx)c~_gC6-))cfQwRv(bRPJKxJUiDGqRsC`NKB<8*HTbIfg#7#JQ}RN8
zLz<EQS|7jI_j>&oDD{4za;))+9Ba5C-{>B)jyFq<J=7tu`)~GNmjc*C9{K<14197V
z8jxeRhvcOuIzFE6|B-1-4KP4LjznkV_>E^yj!nJTx}HDm>g6_2A3n>%u3nL2EjuTe
zrM~Nn<aBh&F@YZWEYgnq6j*49JaSZMK#l>1<fu?cj_W}*p#VxZCC4ixXXKaYj2GlD
zS6`AN(Uth_{vU~KsDb@axu>%pVwM_}=#XQ8E;%aU8eXk`tRKBFFanm9>$}~3ay))S
z?&}+vLvoaQav-nwUwWWG<?|LVT6{zPNnL`@-<Xx#R;co3|KkdX^V*{ZJzWBq981tA
z#{dIzEJ3hyIe#e8co(QopLKzL3r5o7vld^HJFa{P#fIGbVI&_m(LK>Dk)@wn;gBPt
zevA7pK5FqeY6(oqZ})q7JAKyTixw|ie51a-|6hDjK0Lzq%}T&~<d^AhP9FK``epV*
z@*90g`VUQyECeQIVCyOQ6Sbpxix(}vI-uA4?<8}^7@*tYF8M{8(16@`?%8bOfIK@v
zd{lcqK8{~{yaYmO5TAT})6tk5-)fPNr?-%PX6zpp&-T1If6fsSSnLJr5d(Z22fHS^
zCdWs#bRKF}G=9CDGMn7`?LFlD_b5<)T|Po(K%S+N=!iVf4=kCGCo_3`LjIE5%4VEB
zl<xl#SW*MGcTBScB{{yldP9!y_qPAmtOOq4gUkG_?YCWf2sFd(eAwb)i%(iSC6AEN
zoC5Ho#aAtE{oR3Q+&!>ImV4lUHE8jm#m6n4wD_#?s{S~Bm~l=G@J%Pn7GJk`=VY@I
z`1+0hzSryTT}RHhw;!n7xx4J%A$fe<!<*d^kf#q8ACV{OA$f89!{z6HLV@J>$29{?
z$&pY-j)dmqNGK;qLW`5>{=d$s{<oqA!S5uYH8~RMJj^UL60*sWP<QKk{*aNg4K#UJ
zNXR31{#Ozju<Mcq<Va{lo<>+33Lv2|ITD(Z``1W9DLE=MCr3h2P63o?L5_q9awN1S
z53ehmdP9zc?1wi?w!8mFMqLSPk0lav$dOQw90|GP_;jp+;nn)%Bh$u4p!!HQ{Z6<k
zd2mO$nM}#?F<u3^r#GK#^0dCktoPrB0_dnWG<S7*e<|sJJb&Lw&2Al$CohwaWSfwO
z`te({%A5U<E1-X&-Um>FL_dUXMQ&&E_|7BDL<{{SwH|r;0ZG)|xtu@TDh+mlW=75#
z_mi2C``XcjJo|=xPS}jRxUrm$1^YRX-wd##KzTR$l)KI&&6$N4%M5ICOrS>|>z&eo
z+<&Dk%_yS4`kVSWfaLxw^m72o9sT8X!LEs}*dL-x_9&Uy_WnPAiv(;9U{3`4*={}Z
zSoexcZrw@x8IZ@iCq|}M>;GC=g3t_D=e|syN{PwOQ%}g(-;z%{OUd7^kI%^8`;xl<
zYW$o6*0-gj6?t~G{BY_#+T0V#*Ja6i<hdTR0lE8r*+Zk+>-~>Xm+zC(O{hWse({9d
zx`+6TJkZB4$UVJ@UF~^u{+vT~w?D?5SrE&n>yek9UWmx;3uI<K`K#~qN;$^Y_GWx5
zzILE#Fm3Uy#TVqyI9diS$&t|JF?9cb^NDP_&ST9=pn=ok{TBCId<2*ITNVb05oqSW
z^J$A`<X>rab+xI<E&b%ff;`H#K}i85v}tksab|_?cAS*DNB*Q&N=5tRSHGZnd}R3t
z4p<}dYaSv4Ov&S$=$#Mw=iev;&&YqTo;6<8AII-5Z;}RcY7nUB<o~3;Ape|tLH;}S
z<-XVJAHG2bF82eKpRc|m|El_${2-m#hWzg8R$wmKQ!8)wUxxzcYJ(nm@M^gp49G40
zxXlr{{~@^^gyjEmj!ZZX=>C7BfrJ`d?{(53CBK1sMt+ETPJU1IV(WVT{!RnsHX!G3
zq~7^^vvk=b^n*vqJ-y``kh_P;<45F4gnKj!tY4)+@5xK`1$nN%BG1%2k2fb!s7E~t
zBuC3Ple*;Acjc#FpFA$bJ@VO|<hTx7JQUyE|2ton8BeG|{3Q7>+JyWDuh-*BUVo}>
z{Vyj^E|(=(7+$Tv^IRFAGy>Jr@Bb_VtjT|*Zau*)DH62FJ$?4POP<#K*89()00wZ$
zZ>lp6$njawBXT@h9h3k1sd^=?T+V+}Fw45?R0(9%;8YzrCx4!LLH;83lKi#m>z&K_
zyXD*Eb9t>Nnk9YDmnEStIcDaPJ8#wt6nXL#ai84%WF&zR1&VhZ+0-N?&(G6MN?sf)
zo{)#16`zq?CyHkg1(J&-uprOAF9{Xo@q6U)EAsL^^7u75D%W|ERC;^=kASNI{8W7F
zR8E0Mj!o*5;}itsasJ_^q9fBIt2qW$C^Q2W28hXV3Z~?kK-S_*@&`6QMXUX{q5uZo
zkYi?@Q_M{|)bnkVV`5!$^xvz!-v1~yX68`?%xpw{*157YV{!~IA;$!!d)}PCiOwM1
z3)G8+8O+Erz?>WtD9JC<MAzh1KXU%9Cz~ZjrZ#zqODQ=Lb;yyZOO8Z`Pmauif2f&`
zr~x_}lOxdyd8&yf?E1503fK8>cl!*1y8hKaWSWy>Pb^z}-QwMmIpOGKZ<bBeqX1^y
zC&!Ej<m*q!`S!`NG(&RjKe9#?z>E{}3pCM`9EoP+NHiyR^g^^~ysAHrA2Kbd0R||^
zk!a^BW=X%RiFV1+PjBDr^+%@t{Xpd-&D0}Dq62aaFeFE!G5MdKr}zH}1<+ASjzlx^
zz9u>+N1{17`Y)bB_y5RrLk<3_%C!F1d8%1zbkrqBqCN7CChBfo&mS`FZv)ME+haK(
zN1`G5DVk_ZjzkmkB+?5)N&#OposlEaj2r{x<VbWyevT#@Z76__I!`l8jgofB3%$}g
z<Vdtfj{f`NyZe7+8c>5=GY!enQB00R6Y{wxIyJmne`J~(0c*SV895SNlK)f_U6CWv
z4SADjz5hB-H%o1OOfIE1ITG!XV}Kqx67|V%{;zVHg36oyk1HTL3aJ4~8k4WIq!V%^
znvkRabmwyZkm+I<XwKh*G}9$HI$Dt<(G9t)6}3(^E1f<bKmRF!0lMT!)FVG#6ZOf_
zPe6`D!-xW1&2&tTlE&m1AR$MhIk}VQ?-%OZ`~UUp^cM_j0AG{GXG=#L^6VIK>ltRL
z;T_W>E4xY>IA*{KUnAZlU*A#OZE>GG(-{xR*Ke#RT<yQ$fC0-IlYdm#ctVaPn37|S
zXXJq{aaMbC{^e)Q_ChqL1{h#Ljx}DBuQXBXG;;~ikG<#3`9r48UZBotpqci_u^C-*
z4B(L?(GmGgQoa8lQve-J$dTxje5yY!Q*tCaBS-)9({TQE36N<?4US3WlDQ^FM^<Q-
z8j0HEnI_tW%k^*fL&!lu6T$#4IT9U^<5{sGxu?(nkI18Qb!KA<oUcA1f0z1<{517B
zIVP|mAIN`4){+9HmZ&7hTCT`3z=j+Za-L}}&3iRbxACg}{L{~)23Sj<e4&XB$&qM4
zjzq(Kuh$=$PWA(p<9EC{IbO}WB=__M3mbC0kfHl5vl8`-T$}ypQow(U>~@bFGw{h#
zp@4j;*N+i7Dil78?*B1BObt+>8Tkt}(K$K#S&$>q<<|B5buN)xu5ufY^M_1V<QQN>
zjzpbjo27oYChC&^DAFgBJqjRGpM0hz9g-u_fE<a2<VZA{QsC>F>5Lp5&B>AIf_$xs
z7UW2DDZab^#{es8fK2Vv&657X`LanJa`fYpBT>)rYW;J~bYKK_mt>zD0|ewqbV7bt
zO>|1$^i%J@83mB(oP4Z_=Hw{pf*gr1$&sk_9J>F1tY&Igf%+d`869#Y>auI1eR3q~
z?Oe_uGWB<XCIMtRBFB|6Az$ePQgZa4ktewS&neK?>%oE?GbqS0KuL}Xbe?Ng^d@hW
z&D)JAfR1|PD0QFQ(L_CRBsw5R|3mfd{Xa5|slhRtX+n;UQgS4kk^7qH-1Ob^|G631
z{`y^zBhd}{X_{!~d1k4RXqQ|Pt@dA!0<mW5lB1-3attsaN1`G5xteHPd%gepm?hKz
zB~8gkn&^xiiDu+TG~e^){2|ljUZ6gIIA+$^Ea@M<O?IzMjsYBUOu!|dUh-i%|9uKz
z1|B&E@X0ZOG5HCa=!6{oOviNpk4$IOAk$K3<VbW*jsX_rNVJ5@{CB0^AkbX@c5Xl4
zTmmdjuf@F<ACgDtD5L;<(&A~0FUa4gORyx@3Psk60$73#`9hb#dVyI9EJ24HOVB09
z5_pYQ^~dqMS~K;j0XhoEk!VP6e_ZY*$K*&f-uHU_F+j2(s2rKj$vbbC<F_D3KTC2X
zx*{*DiZ=UiO#x)OA;$onGt4DGqAvM8HBpZo{rG3l{Xa4dsKG|pengH$LvjodlOxgT
z*7f{hw`bdcoIm)Y#n<Fl=!~s1%?cqQn|%BHze9nZZlWGJX6%w<0FN9q9+G2XQP>ig
zl3$}Un~`JSIXRYcK|a)p72>=5f6Q!24KTop95b_DXqNhp@6g{1$kC5$c(wk>)H4Fr
z3lcQb0XY)&$uU4cjzlNqkEj!^_urHP=x9ccMCat5CYqBY(FHmBUsm4ie_R2Psr4eW
zq~~f$ZE|$vkRwr-Jk><|JD2l^Oub#8Ie!?yCr6@V^3Q3a6LR!3CEwov&nPg_OfzyM
zIw!{f3vwj7CjX5lYDIJdf{tu*loVfBj3rxXqCI*%5_QSZKR)>ITKE4WYH-_k%5ma5
zC3G~Q$0N}xd7+7>rtj|mXJ%mgQ*lm?l9uGYCb}j^qE>8fYDu)(e>Mf?nrW9DC3VO#
zfJ=@<2jsZ)hPBuGA8Yw0ok2_uFhD|%Qm5nteJRF_923a)yg7duAm0nr=MOVjkuNmS
z4LSPh{KJ7tU48uqdHxB#|92>WOnc-QpihoO1M**Mq9Hl@iT{B%3rd<$gPE3eN{&QR
zatx4>Bhe*Xu78$wo0%N56#~umZ+CCFAxEN}7n`N-YN9qd677;l$h1cRWa^WjsEG#T
z=qDscqA~ec60JV}lLE*zA;$nIITBrvpQ(v1$<fcM@v8nfe#mq~4FWBx^%AqxNVG$a
z0lMT!)Z6!Z{okdT`ul;((NRE-L_>B>bWDy!WAeKHX8$D=K&Er@t2EICITBrxBheMP
ztBI~(Lihj3bVCg=K<B0A5+G5R{GfNqY4XU?kH2+2f5<f02K4-CrXzAB8j@pxm>h{t
z$uEfX6HampEOZ71IR+@nF@ZJtQYWw>#{?qlWoAh+fK84W^vLnk%xm#si-+R7`+sya
zX=#v>;}cQlEnc+v%J6Fa(UJ9Xvl8$w`LX&cdAG#}<oE=Y;6PsQzwv<rl_xDeYw^6r
zmo2`oyxIS_0;WHgmsWKC(X2$N?{=}t6Ma8Wm)zHvZaC!lY?%Je<@|-;lh^tCyFhdP
z5`AsRh}^w}yq6;+cMcIBlj9RqV)9e1NZ;{5f%4|k(VX1+x>TqjFFt-+lkk%KVoUm8
zw|FO-n5BN`ZKQ$I;{6u)TYS{wvHJG@9|KQY8e}cLXz{YeH>O7x2DV>u;7asb+-vb+
zi-!mFYX40R7^wdK*W&XQUy%ndl)bVh$LEQ3&Z;I{?|&RW1e`i>0PmCI14VrD+Z`r*
zC?>~y$kRP<&R?MK@6Y!Fbpm+5eo2lGBCuX*ChERKX6&$Q{~mc6_vQQt6tHhE$1f&#
z^@5X<<L&f0Io`m$Ajfs3d?nrgTY3SpUS-bA(t#cF^#@O?3uSri#~j~yK#up2$8ec{
z^&T+&Y=;Q~O>@h7#;av5(-tqtOC5MkZmHX^HYXO@I<QLtyi2`Lo?R_#?2`wsUXsbz
z-*|X4m4rMzym@@}`acS!`aZpa+|}c>B)|R#^fxE+KUd$7m-_LXo!8WrsOpd7_ZQlr
z+XQz0!-M3_X+82o_3=Krf1&J&A^HDglIUpP>-GP%2FCk=%5U&5(qKY<3-u{E-X%LD
zKSCcrCqKM;*Il#!78E#28!X9BQeTljS$#wPVXaW-Y;)6L!rim!{{JT*m)$;~299hN
zYeZh?+iEA|fnJCba`c~XUC*EWQQ5uaHqdNZE7Ny2TZuV??2+<#hdkChC6C-cLOx+3
zAP=I)$(v7O3M6`*CggZmdqR$PwNJ_MruLK^Z)%Tb6u`UMGjhDEeNK*dwddq`Q~QD(
zZ)z{ZclZBzSNoD0;9cz{Io{R2BCp@oUjJK@<4x`MKkYANwf^osWNlm{P+ilnkTvd;
z2l{xQy!^cM6OwyxKe<ULAz#0)`rwm#|78>ib>M>BJxVStYj*wdx*-pqDGAxH-Jfyw
zfu~oBcPnr9Kdyk;Kr2BFiqDGs<hGuUAvr#FV?yrUUiz8sT+Uzeml9a)0!_)vTZtFs
z#bd-*<la|h$vWqlGfqDzkMEJYy+|4iC=lQi4ak$P$m1vE`GvAH3Ay)8`7D`?{IegG
zO}dOIfOoH#<Z*PLrXnly<m-~qn*1AyTuHmHGb{1qkIBG2_3i!ttuB#3pBf<Z0l9an
z{FU1$&oz-DIr<-&9$6>pz=;{K&QMRu(NRW@M04_uzD##PE{RtAub==1D9Mp%=bz1z
zW}0Z19R2jjk!Zj6djI42^|YiOH9$!R<QQN`jznYfAEDBF-kd*ll<o!U-G)pva$6If
zlOxfb9Q_yMRibkKHx#(j$7M5iUT>Bf9d*f(XpelTiMr%SwEud#|Hl9WYJif4<d4@x
zV{-J9kR#C)F7vPc*sPh(5NJ+&_2N`LP8m4{$jOoDiu_+R(G7WojynHhmKvFM$=y%N
zxp&BsXpbEI_sKQU$O<U%Ma?uMM@KO^5>3b_TG1&v5=|Sg>W|}x0WxZUk}k=w^9k9c
zD{}O+AxEN}>0YJl^-ncZdp}S)GVPLMfF3y#^~vw0i3a3#Kh6FNDS%94@<J1xkR#EA
z9EqmnNOUo!`~RnDrb}voj#lJIbVJ_NO=`Viuhe@L?QC7o9|q`d19JY5sYjk_qCPqL
z3CNLXNNz=%>6ij2X-tj*5^^LuC%;k?U67-nXh{KNx*}ic+ONrx=!P5vblzw#0TOk^
zclZB)oXc_Yr~x|i$&qM4KG#G?<VZ9$yjp(@5F3H&W5M;u<&6AjO>|C<eir0NbV;7n
zOJDE5k^;zdMUDYB<Ve(clUeH1HBpxw{dko(`yW?8Wa?9cfo{?vIT8)XF+fO;M5jBK
z^Y<>zbhZmL=MNpt$&u)Se5Q#O<VbW$eyd9&y@pc&ncC-?CH;;j>X0K*mmG<D<bftS
zh$w(eeR2#CkR#Cv`N5aU#HQrvXQsZr|3{{CYLIKDIlJDNEXXmyk{pRzZ#F6#Sp&_~
zHUryZ>5wB)mwc&-_Q_FEk6aS1_McAyWI85)p(Z*Z$Bd`sNOVTN)<m<~>-~@8hfL?x
z00S(@k?5NI0!`F9&nWe_qV}FQ=MR}Wdx84=jWyFAITCfrk*G(GL`UTRektDnO96B=
zAxEN9a_3WWQ<{<^(HS}VpPxtf|H!nY2DkX69H%uoI<o%NEHx6f$vc{87cSSo-MyZJ
zKy&@u{cv*0k?4TDc(gpz5s+u!mFEdY<k6j7d7>bu!1<pPpSE~T{#mV1L4Ko8N##m%
ztx#mGDbUvvZOE~f)nBEW+The+0Gs^bI<QBMPs<xNUezBRy+a#}r~w8TlVgo1<i1WI
zA;$!!`(Cd<2AJ&!D#r|R@?W5&<Tv=VZc=jeZ@tB=Ts?ti|Jf86VV9C)1`as}aLF-&
zA^9UU(a~Gz{vREUslm3?<S|N3jzp*A=zq3#J%7kF-v;FTU96cF<X5Pd<Uhs|kRS9J
zSsMF%a|v!4X~3btaq2EPD&dh&wGsnzRKh1m|4~4J({<o6`M;@8$glT9xlW`lJ}1XB
zp9}Hb{r};YNr_g};0rqNhWxkcowu4L#eiM%<!AJX3&X4RM~Qkyp!)hf9iUI%(?or8
z%q$>3LmwZKzqa;z|HTw|mo`YqbM=(`YW1A_1oeU(6Duok_CKzGn9-UVthIC-a#YTG
zo4EuSz$QoKdOMf%htl<Tf#&?-Q!57Kz0b;C8Im8VJ|cgp`h@&{@GVwT3Sb5^@}B<p
zoIKOxmy@GH3v%?oj3|H-S#LK>8tM#ea&+X7BT<)pp^5g@xA*_Z)T0I%z$ZtdBXTU|
zm>f$vF+H-dmQyoeVJ&CmU(`x0$j?(>l4AlZ@=^2O)&AR1pwtps?=Y7D73z><fG#;I
z<dUO8UhVb%$MHjnd}@FS1>~quO#XeXL_&^4(>-s_A2Q7L0`>XZXeH+4s6<YV0Sa<d
zVnc2(^!~r|PP5eLs7sDSd*t?~<=XC&BhfxN`X9VAG6zPcV`>oS_W@4HZT-lVIXOOZ
zWl0{~zWUCWy0UP&{#CF4IYI*V%uHzZIl0m~<d}g=zP&#n?`eew<Pl2bQvd@5<fzbu
z{3=a!N{)VJ<eF$?%_-2iOx7|dN1_XI46r0eqHA&-KkHp}rK|em__?2#Qrk^n=eRL(
z$dA;=yX5y%_sI`Z5B9xYf6O4<4^)oKWAeUMXhMz(CFJNoC9f;g?7uk$P@)AnDzqej
zx8C)x$WPZ9Z^&P*-g!6O|G!ZKy?2|Z;6dtra?ET%jtLFP9j#ojbv=J5-Dn%A>R<iC
z0Aq4&u9W;;nrKFjesb~*fB!Ei;A^H!awJ-kV}La|679UltSFW^>QVq}+#|=$XP+E5
zpF{Giv=Sq7Bsvz~-Tx!Q2{jmLB@%K}VoHtyX5^?uZg{o+_zh-d1T5>IFUa*^LyiGD
z?=?$`<Ju*Ubpj4~Gl6>l^(cS=`sA2FKz>(EG$hB9Q!zPyMkJLt`yW?8Pk%^EsR2rz
zl4F3398XRy$xqQlS38&UhmJP8Ky&<%Y3JX}QV%szn;eOD$<cq0{3Ja8?^EC*UzD{E
z$k9<qjznYfP!pYyBhe(H00v0OQPKtZi#5?DIr>?VBhiie_WpmOnOg5NON~rB<QSk!
zjznGZKm3wZ)H6M@Zmj{|3|M$#a@67pyY`ckBhidpDpBpfoC2v<VnL2d6yzA7Bu6DW
z?>8&@1WmMCd%gd0{LoR48eq-(<X!!>+#^S#19J2~-1FxAA=7v-P@li4W}1+rqm&$p
zX5@3N=$yPtRL*}+0Sr)(Bhd}{mo(8%W|kWLbjguuFQfbam1gQv1C+E+jsXVbNHiqB
z?w92h#BiDa?s@(Mf#&+RdkI!bZt2?3$dPD9jzn|v2$`-ZaHM9sAxB4@516G!NxS5Q
zR@5QaM62KbDS!d`<Ve&f$8};%{vSGl2|4<oHeS^q#}6}@Q3F>?ospx|b8-x@AjbsO
z`(CgAEiac%VO?OB6dl>*NYo)8Yoa}JB<hma{Wts1qX04;v1_7ZawIw-N1{{mKod<b
zp!<JhI->>{U`~!iOY)a#qHA*WV|@^n*7Ju<?QKBL-#|0%k|R-v90R!INOVAc=Sctj
z7E<6lI)j)T10>{_KuVtI1ZL!zK$KAc1LWkG!HWElugK=zkfWc@hfr#%C=%_8@9zI+
znyEt#kZF$`1N6y}Xh43VCK?)Etv@=7jlk~Gn~>+4=#>2&nQ2On{xk9>(R%+aD6oFA
z{0+AxFV50ey_4s!5MPtyU9TJRQ}s=$y${p<f37bwA5?+*AFhnC4lpA3mNM{!+|@4{
zO~}7<h3u7d=W_nu8_FM%=DR?X0DML6UntL(buKg$P4vxXJ#y!3lIVbZ{iR3(BMRW1
zj}vmdk7vfNU(dTBFY(RE<W5h<?L-%uGjQ)DfgZVc)Ui!P2IQGmVnklOwX%8qggpH#
z>1U?Cz5n<1EfN_uaGxg$Ey(R}iLc1<HoeZ=oEW}Qxo3K0;VYE~X28mBDFckiy)TPT
z$P?YXGxAcu;%!0hTzpbhp=$rFC{W%(2IyRD&cMdE;gUPImd6js3w^iCh}?UnPN4RB
z|Kpeimq{R@2H69|XXNG8;u*R3bnyjw{zdWCo;T;u*N!?LF=vdgX12-ie5IUYhul?n
z$??_99{G`1>hu3T1&-5>0&;vc^Mo94t4+w?|1-I+%*froR3iTf-T(V%$lGj6YEXPZ
z8dx7SE9Acaq~@48<ak%DM~*in58!hBtKMw(92p=$py{@HaoPu;()_=eyqL?tDS4=0
z<(!k-`i15tc@!M3Gy9l1GfUr+<&bCEkw>2EaSg~5z0$?xmR#tn&;O!8pjW`0JW(&n
zb9L(ya{`&Zcg!KrFP8~>jaT*G9=|IjFrWthX}UDzP9YwX<7>7j<ko%U@#((T>z_PU
z-UFKN2P)6>SeE2zU#{WS$IThr>JE9R?y*-t3!42GP{6yl3@{=u|50a5o-K4{<j&3H
zMQ1s=tzUY(_&DGH>-+jjYLMvr`m9fwGfwo1=8!vDIgfm;Kjea~>-qDqlJ9UIZ3A-t
zF8{h*>Bi*N_vC$j6Y?ME<EP}mR-cjoX|$99<`lS@`hxrp>TB}icCrL^ZdNG2v$#th
z-$gv~DS+>G4_iEG@r*pZy9`i}2WQER$x?iG|Bp9~b}lt%fG?G|$vwR>>5=C@kbwu}
z>u-vW46oMT(TqYPQ2Fzv!Gzq8<!3}fo}4L<pOM=yxL>oG7Ua!)%j^ADP+)SX{M1^t
zxb;c1LU??)#oZPkRNm}=TmjKhKn-5^7D;H_;z^6=<oK%g#m?pYxlfbQmAgPwvbFx$
zU6Gfk%j2z2nUx5x5_iZGy$9@(+b`Gqe~$vm^JUEj<mquTKtS&4`+`U0>EFxaWA-zo
z|1_e2rEf0J$wNI(3-avYGC)ag>07p~Pn#7=^mI7t+x!1afBJdUz`Ihe;REvfe^)MC
zL-G^VN92!EADbRor)Xee2CVB|ECWo*PuIuK$X}&CCx4gvg8b8sSNm^Cfu%NBk^hJK
zhWv!NB-;6mS?X)_@m=yiE#>jO+Uxy~<98zs^r^w!bbtZ*q5AkC`Q6lG@<R7ey64UL
z!{_$Q_5$_!3!W&OD<{v+mCtlpkQYzT%}AbnUfjCOtdM=wv2y-96u@Tbl4tsM`W`t-
z-6#LZ_oUPVaxB5{vdGNnGumK84Y0;zaxB4w9Gh`UE}O3U$``oI-?Fe~a|D{}pJjbV
z6DrC5e~=%eD{@yaIM!#)iDhTX1;-(e3cWe(Q6N8F*32W%^us9z<oD1o7#orw{(V`3
z5&2(<N7k4E>38+kiu@tk(UklY^%?nd)aT@{RbMn-)gQ<2{Tf(O16zNtugT*=u8bS<
z@Mx)=y)c)+JyY%*y8B+QzoU1(?tY;1Snp!{<h~v=pFGx|mP7Kh^m-7GzpnCT|BWc%
zep{9xB>$y8e>W!oh<=(y+~O1RP?tDa(EWd^nNF#}n?53&C?$W74m=~jRQt)uzo9<g
zx}LuuYarhS<osP<kKcm)mg)uh3F=GoC*v5Czc|vsiUQ}UcRpusqUJ+ms@!_y$(v<!
z4ao7CF(YzobKho$(S!o7K4Uo}&(4(r7UcNklY-p4j$Ck7<o-{@JD+bRw!8nwGa9x8
zw#U->6KT*RxBgRnKwf@Pd_?Z)Jz!{fwf^}{q`|}pRBy}u6DiS*+<L`}o6=?ENmu$=
zkZ0eK$`$10jjPAk`)@@7OB<}o6GsN<e8Jok-q*x?<e64tKpwtSKf<l@X8+>~nA}1-
z8gT<1U_ze!NGg<&XaA>_BX@o!{V#Sd=P&NbrF69mG$ju8SF_F+%^4RzmH}*XEJ2Ul
z)1@4c=l>N+M?MAq<$CfP&#1-Y7N53w*5Zq(B~Z5brp4_qnH9nWdgNcYvrNoW-`@Wt
zFl=cMw)mvQ(-xnb9$6T;Fauj(k@tQfKMU+Hn={5ICw0l!Ka)-8kmq-;m%iG6eF}VU
ztv8M2*VBQA<VbKtKGoO#h2$HZ(75(`|Ks>!fC)9Yiw-;|$2%Ewa#W}wzfk*G?|F0n
zPSt>QxmnV4)NOJM=#ZB>;~qI??2=dg%lY>xaIp?NB*)A~<e1r*{C~Bd3Ay!4S>oB{
zbpL;)HkeZbRANDn1efFstwc$VO03{Af6KxE8w8r`pJkyEc400JD&df$5-#}>I%A(a
zI!FTn1&~lkjznVi&&td8C*+uMLazN+&;L^ZGoF)U#tU-Hcu9^m-jLr#C*1i;UD2xk
zIDVLMw+ZYViS)>OI%Ag{Gwze4|G~c3>yH_S`+>?&)=Xn^bd-?eSf=C~-HbE#>O$1)
zzl;JHASXwnOL8pDiX2POxx(DMXXwPbSJ3@G2JTS<4A>|4bO}6iEWv;r{SUXU=MOWB
zw*fhSZ_!K>a&(lE<9d*hXSxJ)@=c^a3~~x!fPx%}uE;ObMD4Gdr7k{yLNgPWJUH$6
z#v`8sxxUkBNRA)VA^Cgs1Itr#N8jl*Bgf-&@!kDD0&8l3w^G?(GiMg)Td%t0H~*Df
z+a2<a_S-YOTK~&0lizk-BT&6ZOB?v)-W?y(lrAK<^etRt@;|<<+;Yvx<GP=E|78?F
zgOVKI?`>UaR>Hf3B;=4=u6U0e{SPZ|_CKzGfj;XUP=kvukr|9zJRzUnT4zi?_=Na!
z=W_mv^G|L{TJ8ePf8&$P?W@cg<7GH5IbLq#v+IXkhveCXk(4N*K=MMlX`GU0e<_}k
zr}`UGL5^3$tjS}Y@Ft?bkv%C<@9XA_@j`<EIbKjOBFE>6hvaxgM5?~M|Hms9X4K#!
zU9-H!m+ZP%I!ki`ss4eoXL@AW`pM+38L;xZNT~<po-WOZ9Di({kmHZdGjjPuXSM$p
z2MkodmXoLdEx#*vzG2P`f6?rb<L`<tx%E3);z8~8{>Sk{AZTeYZt<kWXDy!Zxtu@E
zXt@`t&mVq|Uz4Z5l%?5_7y5g@{Y|q%<!z2{j<ZXiy+l9%zfXZ1{Z@YkBR^DqNPaK%
z5&5HkBmIoYU;8uh$v5f#f1n*rslkcrGxA5O&&g4Vf*h4t!=?V!-+=W6gc}5!g6)>T
zzM4v^Po;FpF|bRHfqn7_e;OT90BawTr@xl9ACqI?gd78B<cWNofA#)f3Si)ZJoqme
zcu9_d*W?)3{+3y}L|?|&ZM>>Kj$f|Ne!0{jevu5^C(jQP_sN|?d`O<$Q9RuDdj0Xo
z=J9@@^8C8eAR#Z`Bu^+#$?ZRv$7kfJ{;|0rFRBY#v;US9$aLT}IX(y6{<c}tP_K+#
za#x>ZcG*$UZ`1vMczv0HPYv+b?2z2PQY%Cr=(FJ&x%F+S+<fbL{$8Tzc(D!0`THmJ
zCHb4xSL8GG4f%!Yo$r{HyEM{3mjd5V?~(sTy-$9_|IsTZ`QhqA@_VUABMO|LfiZcY
zJ|RC<eM<gp^%;4jJ{RBJ|Gz;43u^Fh>T7a*Y0ZY*|1;SW_IJ%vC%X2o;nn(k`jTkh
z2vpw-aISO|k~>Gplhp}%c{}lpywE4N3-Yk;r`~^S3gkL~U79nnzbpy4<oV~seezU)
zrVPn1(<eBC%A5U<E8rJ3Fro%msE6b)`)~d6N^TwPHOD6*w{LWG<I|lt<6F;rxZDzD
zyFl|mcu9_DK3C)izef78zGqer?vgu)>Fa-d3gC+eLh|J9_iqv#lb5&h8c)cbhslgH
zau<6dq5!^lV99<18DLG0E8~XzX4b2kgzWE|m4NruxA*@Dcr6WvEgrV`gnX<CrKU&L
z)f$+afvp!UzG`vn2j+}l@hI67UGn=qy7p@SxfJ;F<D|i$#e)_fw|LUxv)b$ZkK=du
zC&<7#HOSr|Yri0O4}D>?#sztNOYtRnq5YJ5-kiTw1FOA2-7^xherT2yPt|nE@pzZ~
zn>w+<wY?eN3a%Y!W;Sl|8F`?`G9!0>cy!axg1r2?yui8mVPwwiPEV92uzqBEdX9AD
zkZ1oWe@g9<N7|1^{)qFW{~=uFZ&_b^k_18on!I;DY4McYdy?0*oRgOidUoSEc{Dgh
z23}I&ZR+b5@BBZrLU_E>;{5}AWcddUSfdt?$^YQVGJz?%{~1}bj6D8;R;cl+{y2X5
zBP38zgZyLSOY-&Ki?7L(qvScI4S8{YdA$AadzGu#KfRA++T9OS9_Y;679X^D(BfnA
z<S0*m{wEah50)8B$;-#c3^MZk`46npt$v9m$GhB?<PSVTmTdj+bpMYTJFC4CRUP9w
zV2?c3XFdnyZ@rHE^b5$b*~eS2>tFqQ{q>XPe<#~O^Pd(Pq~zhZUfn!kM*giolzuYu
zpR3Qw|1f%+e7Rgsf!}F^1^ErHCj%7Zu_m-6zpXyLBtKd`T2bH;8d#H`s=gtAnR@p>
z%q6q4lbQ<k$%7Zk6>})QyZ<ls6^&zR;D1m$ipjsN_j*(EJD)9^YeDWm{PZTFmEqO;
zXU~(}yEX#Vrqc!+@=X8R`ms6V?1m3$2I!F6HxjqW)B5rC{_9cz9XaHs4$vci<J)D%
zUW<q1nf@?KDsT2bu7G&+>698+k3XiFSw>!5C3nMf@`K8=n#UL951vb+tDVdFyXp6(
zf%Ox!r0{NwyX5cF0S4sRZDk33a`(_kZk2`<z%5ijUK}qSjmT3SASC~gPHfWRX+(j8
ze;}2Zw|LRws}{HZ)2t}^ch$G||M-=vPYrOKd~$qk?}+?I|0HW1le=fj9-5jSS>+8S
zkeUIj)CP0%^k8{>PL6?>ExsoI-JjQ2(t7{>)GSe=uTHhe|KtX8>2=6$b(b8!cm(9G
z{v{-?y&fOO&(oJ;r_`X(Cn$3AT;Ka$l3V(C>u2V~@QjJG=gs-U69wL0pgzF(p5K5x
z)b|I*?75tdl-zy)nRRzoPHtUrrkwwh0-+wK6}j_hS$pf}=FHY-AKwhnA&);Lk9WvR
zN8I~4-T$vOFrWs`Tp9%A)~&@y<oMpd2|2zGJcY~rt?jp9&k<<mv-6_Gt+iQ+LYKfH
zw~l{))1yZoxktzh1{4S`))|vqw~#AlOm5#s9-oq1|9o^aa8B;Z<E!&e0eo%tiu`Lg
zl;gJ{Kkjh3;Ml(~D*^AdxYu}9e;mJaUL_q3sR4ePg)Kg5@wCO~`(Cd<1}OFem6zX@
zlCH?p`^lZmnmke8kmu^wFU<<As~={~{_9Yn)Sq%TyC&2lk97c-9EtYHk*N1ey8lO}
z18PubTL1IOk?4>dl?=!&{P^B_Gym!y@IR&0@ix$mX9b^<=X59Jsopat<o;#y_$hgD
zTk(`V(u`&lKtegW^$F={L5@TVawNJWN1{<l0c5&j*F@LkBmM6U`T96nGV8z0P4^bP
zH|&b<?*FgRfJ+UoxrH3d0l9r0@u0=WEuI)&t^YH%qnQ!ddEVm77GIO!=O9V6^DDCw
zAFF@8ulJurfwQ$izr}rW=M%DdN94f~a-9gt@%TyQa{gtrTjlrVNuq=rpra`{5=qIk
zOJwb5<d*&>l<i#3U!uR+%y)q%rR3emHUFEFul4Z@@}Fqs$`;>T%OhDE``6~$pranS
zr}qIKdGbN|O=v*AR`<!@ayuD!6j30!S}#Q8{=dASsl<fbey;rTnve(j_$hg;o~m!}
z{~hgUMh%cqPVQ+(3vwh{kR#Eh>Gk)2%FIeLU?I~LITBrykMzIo-<V73=^c?vUN&Fx
zT<t%f0{Km4(}m==-s>ggcn&xt_g^W`bQI*VK4-kHz25)00g3M`uhra8gX>;bp3Un0
zw>h)?#WH|Pe&|zWa}8QN*z@N6#h1vY8}9|`-R6Br{;(L6C+CSz$h}X=xlhPbeSUCC
zo-B@$^Pf?`e!mPbCtvHpIk~F?FUT=)K^|Nx6JGr{-T&MFDg&>nL7@Y0$Q>Qn+L%j&
zfji{RCuLv<F7vl6`<*gy4}s>iS2rd)uuE?1z<qKI?2%g^lYxiiQF^Hi98e(Cfk))N
z4jhtW;4yiw11IF`c{6TgO)22(z$tm41JB4Ya7O;qx5_iCbMoLj^3-kKcvXKKzkfYg
ze!*B!gG{|3|AhLI{LAVkd8xkI_j>(*p@H>&pz`0VZ^%QPf%RK+(_QbzGJy{H4b^S(
zLn?3fUzY+sZQzjKO}$5cw7N@vyn3Jf(dyoB>Hhy28W>Q6Gu3_a*QyW6&r=V`f316B
zv~@jy@6rb0HX!Hk0`)QZCF(KxLVZGhrFugCy+{L73j9<(CI7w7U`Bq8K0YJ=vzy4C
zn3Mm7dX!V3r-23eQR)TxvFc0mlhjM{$EvTyclZBK(ZHG-JX?K3K32E>$2<k$NdC6l
zC6BK^Y}T}Ic(wk))$(Z;o)M`2niWb%L-OPo;$w1ribhO+j6OX-J&@P?Z$Sa~V<$D4
zuE-1Z&i|S-_S9|id+E#Yd*pa|zE^p(|8WI;{-Ls2M$`artqjSnUuq@D(>Lf%DS52@
zr#qMPcaa9NU7)EzonieiCm-tjeir1u{&zu+{!8+o92)5*^LJ)RZ+0v3E;%~tkt5MQ
zd5AYCkt5MTL;(yiB>#z4C?<cpCYq3=pOhSlX6oDf|CMGsrv}J0C&vH<ITGEFzf}|M
z{NAW^WTB(38L*IPk9@9)y5vZ-PmcZv<dSH$|3V6UQ!|ap(NRK<L{suY6P=MG(X94*
z|Ks>!fSekjq$~0pI<iSO<mjjKe@3ad747bMbN(ipsk0ZTj~z1Ykz;^9IT8)X2byR|
zUiBmAKc)amnvkcO=#(6ZrsPO8BS)gk|D*f=NHbkg19Y?@N1~l;%u-tmc{i+0jzqg~
znZLC?1w91n`d9yusZV~PCK`|<(U2U8#^ljJGo4TXnI_~IASFkl3-X_8qDyk^C$d%)
zK&Bh=u_kI+7c`Z@sX?M0awOU%N1|TiRsGS?VYim!<WmE56p$m)ki4sjj>(Z|yzlk;
zV}N8ou($Se@<(Z+3v%?cBuAnv@}Nqz*?(&aAkz&w2IySJTmqETC4a3Z>XD-#|2h}Q
z{>Ks^(|{VdTGA0Y5)H{QKunHAr(2itt>Q6qCzEXh%^tIY_sE^hoc!2R<tdheJbaw=
zvm#G2eT@nE!O^ef@BN+Ynk7yDUOIBf{Y#~z9yxB^`sAnFMmF_;{B-qbNP(AYU_^el
z`h@%%UE?YFJ@oN2@}B<pT>f`=|DWg@=hOgeydcK_OY(Dd;Lbs2MezcMp5fK{<HcnI
zBT)VMP2bP!lOL>0HX_fTAWIgLuM1hS33<~`z5h}Ql-kjpJpPt+l#^ra3-a_3c?P5;
zzvFFXPpm6%_CJo_Q5vxRz%1Qy>Nfe~)gAI@s=MT`RQGo-=kLFD&4OK^Ie%E=kQ^0=
z$!EHUCgj*d3Hd#46G<sj3Sbk>$x-SBIZC}GN2yojsB|a#L$lQ9YKgk!s6>w(3HHfz
zt%OI8N(|Ju_x~7RNDWYlkQ}EVB`<sO+R>am(9=|!9$C4*o!+{hSqZ$q-yzSnBahtv
z*h$Tv8Ib?rFj?Y|ytr@uLWXMpjVW;cd*s@lwD_#WbMmj~)Amd9yB{tIt!l6LKaStC
zHL#%u*mRxin-#jFe&k}0{5<WaPmU!X?0IwkFyL@6P}g#)n<ya1CK{1rfH67tP(of!
zOwNBw0elm3M&9{LDP2xJ(<@y;esg_%Nq)Hc`udSs(w+wFj_F_3k~-v=u}hAbdgRXM
z<oALBT;{*~Rm(@9u7C9p0|ewK>6jdQWkQaM&d8&?>Wt?Uz`zS~47em;>s~3zu~$~)
z+J9tiD1e#Se`GEJX6BG%W-j@gbYedFDe6JvRsC`NFyoLKAd#57uWLCW$BYwl^q=l~
zz5bZ-d_Pb*X1pNB?p=|er!(7-W8lson-#6cYxZB40v(;1LynpC$T2{l91{!3zp9Cb
ze@yrP=qRQJ_`M(@_chTeyFSmClB54@>w5l>>2e#W4_~!6Zl~93a&)vI$6o3DiCJpz
z^ZI-MxgTk!T?$};9yt>A$?vO)2IS}`BuAoA%mK}GLXNdh$T2`ljzkya&(cJf;=B8Q
zbhM%d$aF(K)I_a6HA{^|JLKrUYk0N($ka0emi11})F($r0XeRWA$d;|9g{bS*84A}
z00v0Nk?5TKTbk&C9Q`cGk?5-OX8+>~xX|OYrUoeKh8zQQ{>)qgB<hgkg68gA&L6Jf
z-Y(D_zhirH{Cx8J>9gS>`3?2)F*y=V$elmapZ_TZrdo*^IVzEnV}P6-l~|FVtch+S
z3ZSFTpPMDcnsv!DT&l^DXpbEI_tm%e|Hw3;24`ueAvrpV$&qM6KEkEi^y>Y8xK^8i
z?VV3XjzpK_pU^~C<VbWwE{RtAuX6*l)Ujr2lOxeCIR@yFBT=9HSDI*0d%gd0{LoQI
z4IJGgF?onfH8~PZ$kBhg=gs*;ri;Bmeg2L(LXO{(938F5x0h=2jaJmM%}Q5^%K7h5
z00VT%k*G)hSWVO?M?V2MHfd<n{eP*Mj;R4k8k1vygdB;^$njfq4ww1w?)3@;n(JTn
zw_%-GNsizB*5r61!n&bZYCI8PlSg<?#-RXipFQ$(P-=2iA|S_1L-Lhu-s<!JDX=Xy
zIR;3`x1}b>51TnTD!ORAsy~h&O1h*5DCvqECEbvtqMaL=OYjG`m($eS_j>&=*OK=4
z1C?XO1M-;;I3%Cw^&lWeMMvay|IPjzQvfAR$WhXi9D5}v|6`qTL5_))H=_H047jES
z))(aVc|(qwSqGb?#sD@sCf3`!o<Gd2zYWOw!)6(fW3LR!u~$aq*ehf5S4R4L-;@GJ
zYw2d>nAw~hGg^=rx+e;9R4!Ul00XSZQ9Ap^W~ootL>+SU<C5c7IZu3d|3BAE2h;$W
z`s5fOAV;DT@^@*XQ^TwEM@KUwP<<?yZnimjs)^?0NOVDt{+HxUqV@h;QvjRMx`|n8
z+$G!OxJ!1(ahL3p<GA{jH~Sw~!0%{@0&0L6gycv(ChzKTosgqK$<F2cVSscOXwDzj
za!!sPqXjuCSCT*X4sz+WZfaKa{&&#l|7{8&A%`3Ty5s|$ai1JB_Q=t{A5j1^9+RJ`
zGnkO0qbWHOosqkmXr{is|3{{CYJdS2<VbWw9_!}^TQ@UHjis?ok1Xs)#|&75JIb1Q
z<Oi$!<VZ9iM<OA4&{U$@e`5-u5-~XjNXSu%898P=Ctn^Uf0kR+UhjV#za#Xw+9fqW
zg*N0TY9%^dv(!kmOO6D4d)}PCL^p-I7pTu4D$ys$00VMVA|!vQCK{7h{mA)GD1b~;
z^06j5BS)ecITFpuk?6Y1_y4+kH`D-Y+4&2z)Yzn5@`LZB_j=@5$^l&FUwzM)mS~7T
zbN$=>a2k;#!7=$vD-@HXLKE@`C7MzICCbQAiJTmjD9AD6HMt`ds^))lv!qDKCPyL;
zd9E|=kz>X#Ir{e+ug1sm!;DAN;ACCPF*!P#kmJ5#O1{)Y(|xbkADPbf1C?WdIXMz7
z$njHgMUExgkk>yIoBh{0#9V?0-C1^Tm;7Psee#3V2jrN*kQ@n)4x#)1&KKoAKcohz
z(3l(pOvq88jQmNOXukDk{<~5a+kl)u{1`3C*SeM~awNJYN21m(%u1gd=_?<46nFzl
zO^%KR<VbW#?r22=awHm!D1ZUR<S6NkJkXC|T9D&aH3j*0lZx-||M8Itom-kE%AY5H
zj(5n>QNP6l@>5;e)S=<k`eVki5vX4OuQ!nid0$I9B}Yk9a`c~(Hx;e--+}@-uS;_L
z(zznXFP$55{L<Mu)T}68w$rU#&cAGS>+4#g9yP!-8Uyn4_3=Y;%y>kOiH>(J=g-%Y
z#=Ah15=uHD#{g4uY|@Mz70t<Sa#y|oFDX#!%+}->*t(TjQVeL5k91;Pa!kyLD1ZT6
za?ET%j+qU~Z*o`J?IUvhCNxps-v8fR8%(JI5}J`CkvVy+GtS8|<Av$b_V_K$!1m8_
zYjVuka?B;bjBRo}h2xORX{z?0O931wj~vIzC&zIL$Z?uNa-625_Im&02INFtf|MFy
z2{Lk2CMVBy2^Qp7f@05`^M?V-y+D2bu<17BSc1;254;3jax6iQJUiqya{l`iz)j<j
z{H55{<e0#i9EnfJ7h0j@){!{_lxRu~Fu;r)6)MOt)<jEk^s|P`{Hyo*>V?L-jhWC?
zGwqNgQJWkCIOIsQPaa_{2Nb|@8j@ozN96e7G$H>Pt}Eo4Xk^VOfDGs4B`z%FsKkOC
zl~|Ia66?mR`s4WFhN5#@a|uwPE;*i#>yhK>xIQ_ajvMTIz5e)RakL+({I++KYxtNP
zGn<fi^uMR%{+H#hI%Ti^^4jdb83i!FoE)Vq$Wft^92HuVqe9kUbpMYM*@u}+fC@R}
zxK4QF57)~1<d|5nbv=KWQMe7%*T3pD;99ydIW}EPjsX&KRBlfGsz@_kPyih*$?=ry
zihQAouE~+;h8+Dzox{yiBU6|BQcct&M@K$6He*1ZX`&<X-Tgl@4XFVJh{=)YlpLFJ
zMvl!mH@sSZ?8b!=uq<rGB{??ZiX69Aoxe0I`WvlWm%N!+z5jX?z>NCjBQ2drj>-+l
zQMn;GDi>GY?0;MVZ+~~W;3U)l9i`+*G-KC9=j2E<-?^MW3{dO>&GAE~8}i3#qMh5B
zrA9wpa%{#PdHm%_E{!e)kZGSB0}RNKXh4piDPwYM(n&;th0bhB{!R5c`8nzfawNJW
zM<Ofr?fw5of4r`#0V=T}#{iw4xdf<$Lyk)HO^+-Dd^50p^=m+m;}?=Y;2yGhWAaC<
zr{p(iyxM;m1u(Om90?ZW_LpQ2Ey+>2k{tc7Yp?e|jvq?bIl?R{HcOZM$a~6+d*s+d
zeRAxf!Jaqg?}6IUa4%4wzx?0jqf*A?2kGM{<e1r%921(6_rCODIsX|2P`Wue23U}z
zawR$T)~3bn+td9&8uV^&E&<$Y@nMUHEk1$E{HuFFeN$PAKy&@u`Mkx87GII$4U6_2
z%!x(6(Y16afVWV(<lDdBv+F4skYg!*a_ztR{4WaNJ(^?kJKalm`;>g7J|o8j=H!^b
zqVcN!IDTuLK|u{LgC#izSdn7_)*a1KV+nfuUa$X0bO!zXK;;-<K#my<$vgUEHz3CZ
zM&xz>&Hfux05eF)F@sr)=PkZ$@%0_){vQK$?_`$ln@8%EjvN*0lcPcdaz`uVZ(YwH
zN;KRC<oscP5&5=4<aS>YP07(uM(*MD|2YNvn(2ZZi5BD-pd?448*)@SvhQq`8i79f
z$8}}{atu5q#}bUl$9l>_@oV4zkEsC$n2=*;DLE!EZ}GzLYW>k*Wdy3fOa8fh?4ETO
zvqJGH@;=`#x&3l|%Qm_7GVvaHeDd+~^WUYwsh0f3BOuRSDjki;^T&$E<n~g0LXO9$
zl{fnzS3oq#sX=&|bhIExM<qG>v0Srq?#tx^3p+cP^M}uJb#{T~{K5Mz?vo#WU8&rt
z#p7$ae*Wk5S^?=OYw<;km*n{DSNpDJB?_&m8&LosqunRRHzAM6{R`z?uM>9t@X3T6
z-!D8<-`@Wx`o+UJHGnV4SNizQ-OQQcTW@W0eCJEg^vHUfei_Wr3|R90yw%HdT725#
z^A=wo(5wBoIbfjrT8_J$GebiC79Y0wxW%Wn*ZUvG4+G3w8sy|Fy+AEneBI)md+a9G
zoIiBb-wV{|&&L-Cl7~mh^<Ye%eoQvwl)Su1-V;72Pd{>!oc|>SitFFIIsY5-^m>EF
zyZ7A9pa!QaAKB`VKMMB^E$-fv?*GxC-_pQq@j;9GEk1<H{4EOu2M9FttiFOxXD}k~
ztB2(GRUeZdqaKq-57NMd0w<^^<R__5$seYklIJ&<SG&!~7vhnXQJ~NUbMmEnPF|`n
z$XDtG`C5J1cvXKKzl{b;YJeqJkz)zg<XD0YIhMe>*WTu>*B?vJ*$-5XC9uh{1YL40
zfkS@38_11JpZtQ#oBih>AW-kWQH#gq_DOR5rsSm_%ak0CpWln_|BFMUqnsMlnb!Z7
zExvB?&XIeiuG*s?XX|?Y@ZuA18)(L}USrF^!xo>A<3nZ=@)zqzGSA5E=${|djFeFz
zf1UW8+||eD<f%S>L5_h-^2dBnK6fbEP~amPu={4|;Jp_2$nn)p!xj(4clZBjFllL!
zlH<Fc=H%H2bq|r_+cFo1SL=`OdMb=S_4*&}Xi1)`m*n_rrA>?5e`Qv*d3?S9dIt(r
z?zQ-^#Y6J&Z>16w^71vZx01@6{f{f)TZeMjJEI24Ev2K3JXN2Q<MBB;9>3VRoIf-u
zc7f(ppuv(Hk1xsb_!T)Gzb4Oa8Oh8x6hH&(-sYMWI^zyG9&eK)p)R?jOXEfyc)hGm
zpZv|AmZkAqd_->jolGnyFWw^kPt>>f{}>>p2AOs=Cr{rl9p&WcXGxxGKWoz?%X_DE
zv@rt~I<k*4m!Q;+dgQ^y(vM4yeg@?0rk`s61r*3XEgg->(NRpE;HMw?`U}!eN{)W!
zwb%O}$IpJ4tXV+~g0D(POLBCyCQlzJ{dDeQR?hl{^keUNbN<j#Z!b`vzpv;|Kac#h
zzm{jYM&#Si2`2ad==kP1kJ<nEL3;iv@cReq(`e*J>cAN}63of1%jHiq3vyroySNYC
z|6_oX8a!7A?%dZb={wZB<mjhIjzs%#nSb@mre^9P&=jot6-*NukYj)$IT8)Yulm(l
zO^*}u2y35G06uT=qQzG&Zr#tUoc14C-2(?Kx5WqK>5;PA1M);~K1byFujO~hu<@$?
zIDQC>sR0H^$djAPz*F+|uVjF<#b^6ouRlti?*}T!F)PS_cA9>!ANl2aYS!des#`~!
zOK|H4>GS^%1wL`C96y)*7wR5468FioLXO{%9Gf~gn(qHGKu8S^t1_+sO~_H9Dfv=A
z4{T0;g7&l6x}HA_yxazw@wNl5$Xz|IYjVtNLyrDCp1A~vMVgUA0nE%L$ILwPO#2DQ
zU!)$ABcUj!01`>a2Rh>^IcA)aV}OhtOIeEV?*H+|!4);Y>FD0yEZz3=0m-+OBi~le
z@M`^ksmIAT0+xki6OuoFAe%8J$BYwlNB=t|AJ-MF_uq^HC}~EH0djJbbVdFiO>{$!
zemcj{{Xa78R)P8-u8fJUy+e*fd*m3PPmV-`oy+<Awq_dc0!;$wC?-du33-4`N{&QR
z@?RXQum8^|fJ_(U{z$I*CAs(G=Qjyk4=^i-cfoYXv8kP?CD3nipB%eAAji*$kQ_fF
zV)gC)KX!Xc4c>U1?DmWtOOul$!Ge6IOS3e+`urcg!zs;xg#p&&SQ_VnW~m*0>t>G}
z73z~e<oJ4G)&3h&;E*OzJ^MwDgvR6;a6+Ezj1zK9cv^eC|8dMPz>FGT#!GT+u96%x
zUXx=_Sbx2%Tyy@GdV^r^1?ufw-yqcgT=Mg^LLNCL;FBZ4fP7Kt>wiWRK#4+f3=or}
zLQ`@av#iAze;w^gQO^_&*3{t8he#!?W6j4SA)6fc`40I~_e2ja*T3C;zKcMeP4y20
zc;uMzkQ{42BEL{4FeZ;atAPmxu2P?p|3H0C{!;Y?IVP|qAIg7MpZ`yRwU%g2jy<s<
z#{iuNnM;ET^~v#h!^6g_`s4WFgM|ZXfITrLN2w>|xWrD$-}g7NhvxfUum71ESnLP(
z)_zHjL{{W|z1?1uZ!1S$SFYKAoxy=i=a6H@E;(lGk>h8IPmW521G@kJkX9n523X^S
z90{iET8SAsDv@nn&mRWJw}JZbSr#_Yiv0g+q8oDb(|NF2Q6$<W??jrZLjh#kBgX)J
zawO`LW61(?ELjv%0BaVLA9tec-h})S>M1$aI4AGw;|uZK{Xb?_QUlCr&90T(u<QMV
zb)2~b=-)QHT7Q(TX9RY?e)q{yx&b*VHza?C?v)XFQ=xkQO(^grEzy)5GnkS0^uOoi
zBdt(Qj=i<0T+V;9*LOc`mec?h>Kt#DwD|l9O-q{`SIizcHe-M1a{lnsX}AkC9pCsQ
z*>odvRANky0Vm{BtwciZ<N3cS1u(#j9F@q)F|&evt*@Y7lOL-Sv!WBsl44++90NM!
zvCgbVjx~14(Z8p@z5mC|hScESA0>Zy2wQwY{+UP1<I@(On;uzcP?&+OuUg!Ch*`O3
zJWdAgwzzvhulC=70(S|dqoBpdEuN5H@=)2lDLML|*Iw^`+<+iZv@}??xb-(?CD2c|
z#oaw`&L0{K_5$_!g9j}>Zt<kWXV-Q)|M|58&G}!p_`1bACmy&GPK)<Xr2Bu&*l%et
zYVo+mr!AhrW&XQTFA!+vzw@%iH!W`a2d+eqJi?4U3c!ag9=7<T#nS_OWX%s8u!<I6
zwYYWCfoI%pakufR{(SrfEe(PeAGdhY;<J6P*B_<M_XG9%hjJlWw)ncmI}bH0@uRN1
zh{Ykl*I(%CfBFXq)Z_atK5Fr}#iuQvJ(TYM>x}Aui<Smui*H)o{#&yW=)bphJ%0#z
z+dz|t1s}F}*y58GPuU}#@tgzdMT@V<pZF!&E7sqcGlqA`FVe?HE(P!m=YTxCK%V*Z
z$%7Aw56PQXw^v0B$noO#M0|Ju@BUmm%BX>Lygap9kQeWl$FIrrpNZQio0TYa0$sza
z^$(Ad2CfmP-uwM^d6jFQym){--X~w5eSEWNhUDl!Byak!_urTTXpoR2p(!~YpONG7
zbMlMz{ROMaoBfX~VDLhDeg2vn;Kk>ihnXdXJLGRWMK)u<#r>Vj`9p)zF3^+`um6u*
zeA?n!i!aCzzplRizr0pJX0T~-`{8CKVtwO5uf@F<A4V;Kko=N+OF|QJyulzP$7??4
z<P%(1)VKHl2&`HfSVMEhXCEX9bz9sePo5&DW?*{t{=XwmZ`Rs30~Q*L$jk3PyLo&_
zj(*1ENF*jt-d!hD?Y{{HiY8Ef{x5l~J|&lqs;}`Q&-L*$@}Fqs^4jbDkK>2HvZcYg
z#XFBMm*zKm-{6qDZ<i(L?|F0n+z;NrDXF&?s3H82_<%flm2?!a|Jm_PKO^!-JyZ6|
zl)SwE@pAs>6o~&(E<{Um_cq5g18m5xso!|_k!B^ro9K+m^Y_Uc6^4(b`~TwpGJ`QS
z2=v7yQ*ykcX-*#K53?nCep5+k1DE+%Z?)E+a@|LnGjMg_KDn>&?-`O?Z#%iE#F#ud
zODZ}gkAheNDFxpDGg-5OJo$~xV9k!1k>ko}KiZsFK5qJttR4k$H|&vr`w{Z%v`>EH
zM~VmJ2dj_BE&XeF*mzZc96xkCrUq+$Hf&1n=^q?Za_sgw`RSU_V&Ciazx*<Jn|-k#
zs8>-lU6P~Yk{pSy$e(_DSxW0M<`UfH4zHA-|6L0FLlvn1x#Taot@xnDgBBl?|6YFx
zC6A%||0{Ih88v|C<d4yxic9jeersj*Z%rONTYR&1J%9eQBw#((ED`QvJLHGlQ7YlI
zc)!Jc_DDM#aX>w8@o9@M$Z@<2@=*JatjC!%#yc1~<g1Hx#x34&alge!;=B8Q3=p?8
zn6`M<;)@n94X@UJ{Z)Audu0Tw-G6BP1))`(9Pby{klSCAeyo5hs{MD!-SewGSMNWY
z0$v@c{&id2Y4INULvJp>O?%`wJVbn0d9(j<1$?RoLTUh?kpKKyvM16OpSO6ib2)$L
zXtfJ86&Sx(2C)9#EGfL(;x75kESd4(S{_LtpukugjLDr_$m5e1pS5`2;>)Ndux|0r
z<IPGSA*aRrE$*vt@Bh)!sHH*N;?ow-T6|%8WMSaa3~YVV;`S2`T!~(bdk6Gt{|zay
zeW^4#USO1vU*{IGNptcPpNvfY-Z#tRH?`OMAIHzq2Hhu`GfVXwkNf1ge%11jJifiW
z-F8f#s!#V^&YuR-y+D2bkZD1l>Q^?e*)<{iN#+DBeY{Iv-r*rKzE1&98-(P!RwyAa
zF*EWLA20WYIk|(Sc~WF%`bX!<+LYA5f7l7l1!+T`eM#Ip#q1~jqIicK_Y*c;=5JYe
zTFgVB8LoN?_O)K~{{r&lzA`{ezScj<PRPp#$m3J;2u~8tD1ZhzyFM$nAfM=!v25`T
z`9bAb^~55}ezI9Q4OqPv_sHKO9a%&2Yt%z>Jf}2iysAHr-#2vzDK)@vFmv+z-ttw=
z(iG&lky*94HQJkSz5Zy>-4E=!+u{K^o+*vV-6Q0;=9K*<efjyHQ^4!W1*9a;bkkW+
z*_%O?D1N!@kmJX6pFF*{JhM7{3f=!(`uqBr8ie`*0#kBNpAVRm$NJmxlKm(5ZI*1a
zbv=Kn4$yt7IkWichc^xS<i#<^H$EgU&y?S$$K>H}WZ)@z620!|rlUCp9G%&cJikg3
z+K`tomVvuZGbdm@KoaefyMHB15Dh8dd|L(>lUurprsV$3<oSR(d2t`P;4I0@^W_PO
zjri{VKfX{lUH9qc42r{L_x8!-#Fr%?$0w+a$(>tEKU2f2^-qtKQp}A&_5A;@WzCl4
zp+0^?j^~29r<xNe@gx+vUq2;N@4q1hytND*kmERwTYN_D{Do9>K_2SyURB=ge_R25
zZP0m!IfGOi^jdsC?rA?Ga#ww_^JaX@*1&8RXx28-ffwX!%z(U5@0?~%AXm4^(<>t>
zQI7)F&;F)KU_ids>%@rM)6F{}$CWW5$L9@X5e4r30l5KLkU#M$awoGU$6GEp<e^T$
z3e8G{13hKx+x!2oj%0uyHMo@y+$TqZ1M=<_@}4iBe5nZzO^+-LFfs$y({$jN9F<7O
zf2)sA$$zJwlmA=e)&46efP_kNB(f$i@j^s$%-DLSxdiCnuD#y>IDVLMj~Zacee&a;
zDoZvX|6BDTd7wVp^XB|L=I!!^!pUBs-u~BU>89kE!Hm48|2-$);Dw0fRfXjIFDQTk
zmgK0A^(?cbr|HaW@{g)J<k-CKv*`Zc{)+70J~hBvdgK_uC%?|qWNF6a4^*GPW&W0h
zj;07Sm!ImD5PEE8<ULI^BS)fha`e9-kC5q_0*Pj7J=-ibI<m=;s6*~)qCIj=G_qU@
zU;vLCiH^v>g;JB>>FKfr6LKUvZM>>Kj$f#mrqlo>osnaJIr&%zF3EHC^}g5ZkB+R<
z%~B&%n|!E=cFB>bLyrDk@;cFG{|zZ{qf@1HBXV>!CP$(Z@`)yzkR#FQ>2&{(0cO+y
zCC$lkWh}@$&yWd}<Tp@XZ(Yydp&GECV=loHwGs~b#p*6O67<MZt;B$QiJ$*I1u#HB
z?r5SD@~5j$$<fb@97`6>DX`K^b8@WNf*b=Z$&sk_T(hE=qSE5K`+s!gPy=M@lFv2K
zJ~<Ng$kD%Vc(wk>bZi7H>!zpa1%w<OP05kyjNH;YqKv#rwBCPn3SfW*ITBryKTQ+0
zo@bUC{n+G4)TzAL|F{AcTGAdhKuKM44B(L?(IGjWSq*nC=MRC&F3|k^gQw))t>vkg
zd5f3iw+Uq_*W@RM`u<;QY?clsvdPD~mR)jG$RR&j2X@I{u0D(?@O}-9$kEZ59EncI
zT}?D0N1{{p?fpLnm{9{{T9AKV6D`Tn&zc;GTF*BsUA_KCGwqlG3z^#F7{DP%q66}q
zJX6+wNG|<U`)@=6WI84vXreJW5}lAE(J46+&1$drKaSrix~mt|0A7-Zr^qj<EAs6h
zF3GolxZLyR{3Y6v^#WsUtU$d(e!0G&z-e)xJRVD;A$fjQU(WxS0@-uqx8S73XDyzS
zhgZmNyG!!;`ore>vUvgB|Kk%+yJwh{D9-kq27U76XYy3dkbM0*dHk3>|EWF?2$%U+
zFSWX{ydr6iKr>wR8E`L?=k=E4;W;wEhCDm{#HMBUOmhO&ORXAr$fNZKb!HSu?xru1
zA}{9RWAf}K;!|?x4buOdJeP__){+8&zLsl4zQ$|3UTDtDdc})nX~;{hkVkI)f&8-T
zH(u2r$M1~iBuz&FHF&vtNbVmi9mV8t)W;{}7pbTFUa$Y>G?48FD!*DiCts@<<o}<p
zI}eoR8uJHUVo3|4h^1#NQ-jc1jQUxk5mJ`W_QIfztw==M%bJcsmA#RSN)U~pETNMa
zDQnsiYAmA(rft!dp%Ap#YGy2L&9ADS@6+Aq>#g^%<nz?2^PK0LQ+;mVd;9(#UXYjH
zz*-@9pLZvD{kL9VmUKCn23>ORRx-zZ_DB|~N1lF6?lUB}o-2!V`~o`v>)T~9HAp`s
zH=2?!kCBAt<oQb^p`2Xrv)VfLUvgWy(PkTHmVy=cZrA(=|DEs<KThY+^W*I&C(ZRP
zxxTG8V2|*AU%&zQxWyB4e=HrR<gbHg<QKrBoC2EZs>RC|@5JUB()&0q-WT7U|FwbN
z(qPo$af?q|JTttSf9-f-1a@Au_=f!So5-QmexX^3XFf$<%zEU_52e)W&pS|{@?ndI
zEk0@Sw8iI@H|t-YfcjG}OKNb%!)0Xa7Pnqxj##hnlHdOrsf4?8*?$@s>;la;I`?(b
zAZYP%izh8U`y0p4|L1=bkd9X^UbcAW#bzaR08Wedqn3c*;-eOiTYTE$8GL*G*Gv~J
z4T=`uw7C6}16QJFdSq$Go*A$XzNsv_A$jNe^0GT3f8xK&6EG&%>l5;)H`iC|Z$<%a
zFem?4bg(4X>kINzas7r|ukXCHs!+ZDb^8V1KCM~xP94~DZQzoJxPCyc*AL03NGRNM
z+5aeMycehwcsCkM$+d$S`Q!D#Lax^@$v^b3iR}M11+>A2{F6w?e%XO5<dDaxP@i1y
zKX@6vntcWx1T76h@^9h#3AuJKCI4SspQ+3Et2KZr$Td*czy9|;S=B3Yy?#x8HC%7K
z{J<5m$)oF`L5~93L7)6+Tt6b$pBoOzU-|-UOLF|xoyeLVIACQhzG(4+{0r!~GchZn
z-!Zituj;Scue`OK0lU<oJY7z!F8MFefk*ysxKFML2K!#me~LF2M*D%vON=Na*A8Ox
zub|@@`8Dt+*POh*PqY3O6wpjp<Z~oikZYoAa!qtYu8G>Op!5IYi#RI1!kja8uf>Ng
z9=7;o>)3zVLADLld(X1oh0^8ZI<h6XR<0mlqH=5UGQu2}6wnT=SDKa3(sjvo0518f
zE^B_w&Ki*Sdh+TT1ucPbizh8UBiCO%&RcvXzB~VGgR-ST=T&AU^m?bo`{eo?&m+UD
z`A<^6nd{I9RLAniiI2%0{QB&S+<l8&pRqqvd`a%t?~K&zZ$*LfL}{=g58f<pooZGh
ze}=e2p1n!DM{XgZLFLW**C$|t20k}<mfR>LPv0m$CbuwvDS3hWr#qMZ7d}aDl<xw~
zlvr;QUyvu5nl-tH3YF|nm;2bKnUyQfiX_mbK#CIe$(uQ=QuD}l$^!BNYimRvK3V#m
zL=?~t5_0VzBiHNa<a+&zTo-!*-=6<<wOjvYmMF!l?vN)Z$OwAmDW<?B&qBGrZ+i9f
z|JY8x8L;m5Ie9G@kryA88^z=f*2;uD!1XD){nq+E)%u%JApMARkh9nOwfeUpFWw<u
zkeA;UUy~Q#5-)47*S~H*{o(KpHPD|8@4ecb8Xq@u$+HWkg8{j7k?b~q&l_2uFAYX}
zfqJC+v*8o+{Hk(NO30m0%6(?!%TGM5zMYk^pYKaX3kqn*Yxe6)$DPEiM0ykX*-o2W
zE72o&ULQ9Jx%@VoHW+XNEgd^<G$hwV0`l@q>3F0r<F9_s|C>^}Py<bV)i0r4EIuaB
zaif^L#Pt*M_;YfflssA<_nfAy83nXKPVV6P1-ag5Nv?^k$OHL?M`RToKqc1XT8WZ;
zd5ya^1K5yjC9KoUwPIm+bQ`bguiG#A)3ci!IV}zP<PNU)$n`!0a!thF_j>+=@5tN?
z_XD-B!~=4z#E3k_+=t{^i7|Qb3143S6As`b8K&%2gZf`at{=%TC)bZ;$jLR4#p!hZ
z&;M6CSW<%=Yhp$2VZ;Twek8-1+`@f2XXu*1{!7o1x$kWQ%|NYkBMG_WdVQa~M28-E
zfJ6u6VT6o)3g{dU$-UFPCbNKC=XgY(e_RF-lP`~#Pt}Pg6wn4Kd59OA8M)plBiBUc
z<OM2`i|@|=87i@$20F(}@*MkqMXqyPkS}wo#K!Py{*x2s14yjb=%SFh*9Kj37uP%F
zdY>M-CgPGif2b0w*I%CkG4{Pju4`gI9-^c^xvq&JxgJ=;%A57CPeA*u7dAs5w=_t|
z%QwmOQ*ymeO0J2_b}su*w@0=MG>Ifw6LWH{L{6^vS&(ZbmgILE;r;(L1<o1C;j{Z%
zb4}<6lk~~;gGq+u)>IbVm|Q=YWExRGKbd4st{+UYBG2)AKO1uYh&wbD?7q$%K!HEO
z+=p+^|HbbmQ;!-XpBEpJ+t-t$*qGeKXGl%it6w&&|IJO0tmG*97VF9kSl*H11-V|o
zCQtGICAqGN4Y}X!vU>fUX_iPASBE^iOh#an>*DH?$6u4mx#S*B&;8o#{&o9l1D_g%
zhe)Z1<a(okToW0Q2e?nT=gt0evCYPNfqJgA5;1v#2hN0CE0K`v17}8_9d$d|{}~0e
z!Gb)%npl!oH>&fsR^*yUL9T0JeI~vCZ{g8fQUk5ThCIibuwHMjA+1D*Ji%8;j=GG$
z`uv~Y$YSYfpczl~;)Dhsd5M$KfL!n6lWQVF@~FUE1{4TUi4nPn>qBzA&zM|aj$?96
zarOQ`1p;i3lw8-uoZPyK?2epV@3SD+M3#+L_1Eo}V`M98V51TRxvq&dx!$KF*EO-(
z_j>*_yn$d(%|+y(5?yk=-X%{^i9WgB$0M&3Y1ZF>0x>G#lc#u249PuRL*#m&5xK63
za7yQY|EsbKCe)z#n(Xg{T(6&zF9Z3OO-8QwnQtBYugav^aQQYM`!B%A7UT{pu_V_u
zu_7;DE-%LgdxQ?w6!6ZKN?30&*F=gn(IMCC9r760_sI1=kxKzhq)(pUMjm;AN({(#
zP59(K20Rqso&R-F1k|ATf>dHmt|N%a_4+BfRw6aLnt#2~%m`Fpe&hc$a;?Oi+(RXD
zc3nf{O(p8}x1@kpVnrUmQz}uC>i{<7dcFNda}8-Fx|KKUU!Q<_BZnGjB0X}ggi9Wy
z5`A)A6W-2c|LLL_>;kg?a3h~Q#i4Y>jzt=><N67CeAP%^JQ50MC8p$>NJ_4in2|3r
zfQ(!#F^?#qmB`6;O)SWZnXHL|TnDfw*Xyk}$(q=n|8-Gx5a2aolWQVfa;=0z?%`Fm
zXL|Mbf3ZDWGhk^Y`s7*(kG#N7xem#-5&^kfU#-6}1+)?|x!!0(u8Ab%T8Sxni8Ybd
zUax;GwN_$A4YU#&xmIFM?qsqimgG8s)t)!|PaBkbfqMUGB{t-GBkL^l!Lm(+Tq|Ld
zJ1e~Z-=%<7!Xej6^vJamF1bDd2jn^c|13KHYl9Ir&`N~ldZRJ9CK8itB_`_f{HxCS
z*dB=n<oUPV9aD0xL`tren30!%k~NW$M``^oRP}F80sk-JIeBp<d15Zeb6me9FE1z8
zugERAzIy+k0vQrolZWt<+(E}1^5wzOvGrzik@|m?fpr?M>aW|+N2WG4K&DogJVr?!
zau<pA$UP+L?t4A|HcHyx4^*C@fk&Pq(E+(8>XT=Glo1cfgDTNx{RI?=(ea2pyu6e&
zBzI8KF?nXm^)b07I(ajl|6P<cp#~mGIwcQ~XiA=5SvsDPm$*LLy6!)ebiNJLd!qV>
z203~7XDR7|JVByM@(}k~k>^oIGA$?&qoiwc_cH0YB-cbY<U04(Tg+V$Bhjcs0T-Ft
z>{paTyW~qG>X2KQ`yM;)?~3ov{|;7ZpBnhc)FZcXqXD^p1xeH=_YM*t8eYwRh(KTj
zs^1Gnsbg~YkYTelCgd5u)sm9O$H)hk=j6fftEsHl-+}`Ao=-up@A+77HRsZK{d1dy
z9P*}vD$*m@>)pzm^{-FBH9G85gC&k=9=VGbtpT}%>wR+jN%v_I9qwHApN%8Yco%3c
z)K9OSlDp^2T+YcI{Fd8_yuinGZOEPL;{4xD&62wKbv%dM$2XDs<n9KKSaJ&;kIB=U
z$@>9uL;)M6o02E>VyXVk$(`%solkNbzc;vHzZ$mj+hoAo^M5jx4*Ce_n#d;duJ@3<
zKnDSNiciBFlfUdp`GLd4^vJs56XaVhGc#bh_?j&z_pc)(D996hkh%4Cb1IjwkO4U4
z#m(x<RqM~Az!Jan6_C4+lsA=P@*I^*$(_R_(VRTS=YbWq*Xw^<Y6RBQ;Kwgb>Z!Nv
zchJc0`25DZ<mrp#dWZZy@ZO#``|r~TxO;*6&R>G}$-e{l$o~gEAV2iQl8{e+gBRoH
z|3eC7_<a6^+`3Ronz27bd`a$qP<%x`JzWx7zauhB`Vj;+)Zjbt&O6QP{|N7rch8Ux
zdgMpJ`|9%iv#h%!Fwj6VvzB!~_>lZz@DcfA;bZdC;1lxb90W27gcqQs<mK(fOLF%P
z;`Z5Qg|?rHM}EtjH`~7Y{2vOu{b}<1Js$aeUn3<Qkvkugjwj^7$HiylF?`W@Re#-n
z7H+hr1{NB0-ery~g!jmO_<%hAs3bJn_j>+q9l?H}@*Fpsktgs4J33gCXYkIu%>fjZ
zH|wuQff5Y{<V*O7Jcm!nJskkKivcg*P3M1Kr+^w1xKU?jj-bT#J#r5|AWx2yC#Ju3
z-GASgPrV#&1G4|(LOdX!$?CNd@)C(o$@TgLxf`LungUB5@j2#*?c2*D>XGLk7I(?N
z{4RNQ9kh59v;@ZFFFYEr-z`3C@tpjr$4Npf@!k3V()UQ9qz3ApbInSqJ1yRCao_N2
z{%?o}OJD>n>t^tfJU>|yP07O_$Q0z{?n1mEw|-oCv;NLAN0!uq>Yqcdza8Hr{|XZA
zlYi!o^28jFe-%Egyy;(`fImTCL=86ZG5K}gBppo1@ocx!7N752_MbLb?gC8(4#%I>
zvfg7>s6eS5a`%T)IgdQR51$OkpYn!CMlhs6@CLltkn79tnEbi8enP(dJ9#milAns}
zXAuS7j=-FJ4ll^F@5_j-e>W?Xz8`CdJSb2h`1brCe@FrWHPDaOh{^SHKqln67^mc?
zV6DtdkE~M>n41A>249c|Kat;(U6Fql*RRPhhHuD!*?6`7I`1`0clonq?p^ZoM^Yi5
zeEB``kUYj>OvnoyO0(MQ^{?A+iH}BJQiB9vYL(>W2c%>Bd~*OfUL(5Xdg|@%d9(lY
z)Z5<+)ca3Qw*zuL#SY2!5IZ8*L+qHm+D)?mClt_A?37%O)id%FFlBS{SHc(M=fPL!
z)A|39Ysr3HQv*H!Z^)0t^_|R|f?s00cFF$?@2Si9ElVFPeGN3vzv@Hi^cha>>NA}D
z+Zfr1{CDs%d31l=XhMOjzFBs`l>DafoIL!9EXIOd->R|RXI99O>#Ns)3Iy_p!7PXT
zS|65|U7tL_lWs_^526wIxAAH@ZoI0$Zof4G6Ke2h_>}z6*Gh$E<VVBj<oAUy_Pw6}
ze?efiAE^BC@HKe|-;nEzP3Qe)sb7TayX4c#oAuYDz<bf4PyQe90r?8AazpaZ;rbEz
z5<Y%Eo&PUJU_uSf#n*&Wa-HKD`G4a+bMg|t*gE##RbMA_x!ML~|GD3l7n?Qt5x9Os
zetUT51LhPw0Ny2ke1t%c0xyU6$*1rExraoD<Zs6HBl35{qcH_^(M`zTj|Nlnufb>J
zzlG1q4?9yTy%67>|BpgoMGcODugNvh4f&mMedmMb6g(N;HN2Yt2!WmvsDAew-Y5SY
zd_ew%!{oJNNWRAPBl1h@>+AJ5rogXXFD06g{}nzZ*GkODuR4|c%*k&GUsT?#e|-WT
zkHCr=JO;idKN-Fue-*s*A#)1OhIe-^`|pfX<k{}-0?q!*zc1U*BfkhQqdxh?@PJ%j
zT|@F8==ndUz;p3pGbMi;Uj1g||A%+c=H!2bFUZft18o&i;PQB}S(Bd#-;h5M-ubXu
z>Sx2d<Ojb+)<h4!J^$Ylfj%|(uS}+9L~i3{HzdFQL*@EOi>IbX*2!qFGy|4?ph!u+
zJo~}T+ORJ$N9;@<)OeTNKUc1I$%|XpZ|zj;&!>Qg4u<469LmT-^7mg|-Wi#+cuF4J
z_90E8^V;k6uiMXhmt>k#1MOf%9^650RFW6C&xTyDx97XcHTy4_Nypv2K%Js??6&xz
z#e)_flRxqYuay0tP~f9KkWa0ckzePB;(3d&$lp7cDJ#j#FG%G!b2|U)N2gjJ*_EiS
zgno2thupqMZe)`e=%7n}*pFlYuDXohvNSNzK;3KgPd#YyF}eMINhl%DUMjmIBabZo
z14I;f^Jk=VOY%b>CcbWQ>!W7nj&o&qbPw#+`~L?HSc4W1T72B%NsG@Kuj;Sc@9oGm
zrv_SyRg0G`-uakW3B8ZA@Adp^puZp3bHBw$Ej}fW@rR1%<o+e6$m{=#0u~w+<eKQF
z#qEzDc*MOH_dZVNf9+sM4G#OQY@4vfCoP_~_;Tyme*s2ZZUgn^tG+c;m8kx=A=iX@
z7n&np;?M87<a+&pJ;KNW4#3Cc@Bh72B5Cm%`IRn_?Ybf_FyN@5fHv5)c<&SDhyzq;
zKwdAd`rnA$(Le1dzB~VG$0;?)(O^cd*XJ$1YVp$WYX0>`ollx0(~sSDTD;%lev6L|
z<n{WC4-}|;+TvM@FIv24@lEB;`qw9*j@Zr*T!~(bdo4aBzu8}~jdw2lPXm)(pk6zc
zdfMXi7GIL*_!O-5-*_Y$S^r^<_~2X1tCmadVB7fQfqUO3;UT&Hov$%@{$#vNM-=dI
zaF~+2pO*$HxqfEMj9fo6W<_2u<USkt_WYlrW9w69CG5vZgD(3@{%W2>UR+JC?~|9W
zzIRh0&-BRp2tNNOGy_(EUnCxrfBkXtL`%rud6M{yT>su@en79*-|B#Y>f`rXyz^<Z
zLi%?@9diBVRlmjk+UxbN+fN&esKK$9myyNf!JoXQq!aS;h&wl)kcZb3pYD0H|GfW^
z8>M@J`VPe(#AoE*|A}Yh@ln#jl6?6`xqiid#GPgT7Zk8AlLl+@B@!*k^WV$$8*=M6
z;?`%(DT|MkM4it>X23?KJ!+sOb;<qf%8mNu#s5mj9=Wp-AE?Xtt6xI<tpt1xSn|(B
zrXhKbM91Vy%zaGm-#`+bkVhp-noz(-rc-hcB~8f_B$|^uNOVDtL?dfSfxwbXSL88D
zT9B8R`!#v+JE>?%Zex+!pRK39s=sc(0GW21z|OU#4taTHNwi0vBT<)piA4MRUeAAu
zl6w1r%9ki<K<*;Z5xFkXklg-zNpwt}Ra4)rznB66_WgvsK%xnGjzlx^5Q)yoHPQUD
zbpB8OB6GH&1{NMTOLio>A`ejNf;_?8TmPxsz8Qb@9uP9^Yy(yOtA9H8HhK7uQqnGY
zg1L9d1MH?AdxVm@6!4Cg4t(+y&-@{|CK`|@*OL2;$bD@4D5OA)OvmIo9#Ap4kCLY3
z&Y!)ef-~|A52#FhcmDUUDVffxfs2yn<SFKULGEGSFUc)bv^2b$e-9<y7=hi~Tc6X#
z(hSH-uP%vp$P1LzCSM}aE_qrn(t7<l9Kd$+$P+Bm0lCh-Pww|5(IL5u-4s;btbct1
zy2x}y4GNSrB)5@hLcT;rr|g*fbmy}F+`}Z(*)Gu3+Q!^x<Ovd;lUqnMC(p1*3v&0*
zQ8fqEzcmF)WLlDYhf1Owatn!C3v;bx*i9XB2Z`Dd1qx*9l3UnLeR7?9kK8?25*?5y
zSfoCDd;Skm(jhenbg{4_(U{!ULn*mdG%-E0vaV!0H3L?NOjGh4iO$GlJo7X10*iD>
zZZ(Nk>u*H?&9oq2-bfN%lRKFElDtHs8*&d%QtR{8TB+B+Za)ttb?U&L7ufeba-DmZ
zJh;9j+9!`uQE$(i{kOy_9qa|_1PVQrl6xp=NM2y>$K;x5Ozz$U=l=->GL$qS&ynbq
zJjHfO$#YaRC%3Vi7N4i{e};X(qz2hlrKBrz2fL#nw=wr?@)XyX>hk=n-e|<Dll=vA
z?j4l0ORkI5A@{E$iT21nRMaJpVr1H<K#aNf$SssKAkVN!N93AlNN!)gNi?#?6iAV2
zOztDm3Au-TpO6Pwq#1dMiq0Fa>aW{RS7}ZSl8%&gL2h9?Ey+DB(iM5GYh~Z-`FBxL
z>mqaRU1ZuJ*OJ=gwj+sl$xBq!A-AeToAuYDK#WXXaz_uP<SFKUNUjwP$jh5bqN9uG
z{BNVAAvJI?_ha%Hr{|d5$K0pn2`W0<I`*HIG}{L1=U;U;#Dii^9-^c<xr@19kXzVI
zOL8~TQz-><WV#{Ol3HIh*GhInDQSn?N1`@)fn5`IDd3=_4m%d9M{en%lw2$7lP|9*
zi4Mhg=l=k6A5eo7B^{AFC}~JuBGH80L!wi|tNGVVQzKCQ`u*XO>5SY(q8WLKMCard
zN}ZF3^&+j;UqOKwnXbt-(ULs8f+V^jPm!qgC3CHK*iD_voAs|xzykZ;rUofW>XOG;
zq<!)Xuc98geu+2Ox$M6HtJL2Gn(ddMq(kx?ulE6YhJ7EChe&inzC0q5(j^qgFDE`F
zcTm!lyg;He@)(I`<RL1$j3|&H(-k{PT99i=*W@`8Ey;Z(x`A)c{{gm>^<{Ihlqjjg
zjz!vIN1`tKwWXqc)2sLYF!!DrutH=yAkXoD^2wJdX-Mv)qGNK|P1X8~DPUbgGM$jy
z*c}OZhV3*Zcd+kMc2qR4y<Y#i{l0RvywAU)2Cv5Z|7DAJ{>z-Q0^eM6$o1p6dwbsO
zKW*Uc1?v5$pX)s!*Bkldn#hp6xaC8e?HsT#9wPgHM1dUNr3%UQbG^spOI#n5{~VQ@
zws`hmbpF={i<Slj`TXfJW%kmX0{1pDVwc>$k^G?oUtPvul^UO15Ne<)ShYA`-f#XZ
zA=eKa&dBuxhnM8~fx{(vq#rnJf5jYue&Dc6o_$!p)9I7@uaZPVa_1jq#0hyI6{^1e
zr$GLW2R9>LlDqJd+<K>6zaiIevD#lX2WI0tscz#{{dN0=XUmOzYM_4;IwVhV{h0jx
zU*Q{(<ocTs*}m8F|DaqN6#Ie7v;USwWPQyXK?--sW4K2i!UOX9w_%(0H==-r--Zpz
z^|xWi<oesKNsH&?F+P%^_!^!61FUxI>*k1ccR1wf_oPA|xh}>5x%E>#h_;UXm;FWp
z@ix$`K}+X8B@fZ@jQsT%CbD?R^^eZ2$eqX=HVq02cyE=2HsrTN2c2)26*>vtCD#Od
z<ZJvvvdE>t93A$_wSxiqThQ^CTz`BwCV$93$zspMcjx~lKFwlI4Zi*<Dd~dz3)hw(
zw_lO>J}uX;$%pWb;nn<WM)t*KN%fD?_FCL)@nMUH<j?y|m1w>GVha4^voeB&{44({
zo{}H(Iq?O#cgZQT7|HdgYBrTO>tCOMXW~YkZ<>|Rx$ly17Z-W(wGTBNyX4!owR72j
z+QDEKXl|g3D<uB{5{=3AJ_)%dnv!?F7D=Wv3TUPoxpt6~YocrNzar5Mx!$J}t;|wu
zrd@IuC3VO((H^;W&?nbK1Nip*f6Ij|qL3Qsjbd_5G$9`#(J8qmnwlP2+CgRpEX{O9
zei9O0v*SUuA=gAZ-!dz0HHlX1&!&K8+9lUSd*qs^PyR+E8j$OK!rJTguiH;Ejj2J7
zl1|7q(S%$(NXa$P#hy3&@5{(^wHK)OpWbLqu8D5QS4h<QwpnUTv_oFqU-o~O0-C8u
ze$eM-k^1DCXh5!shU6s@9e<n7|C(t`4YY%VToav>AA>{}<a(c#x{Sa2BXoG#U2C9u
z{#A}lOL9$gL#`ckzGF^-ChC$$Pei631@uNfxh5KrJ71S4>4;nt4asr;$cibTna<de
z=$u>=U65;{D{>!+7L8Z+*X^g7uBm}`up!q(o$s2Z{wfl6$@M<ozSr}wnfm*I%Ey@d
zA-N_RkZT7axh6U#ztR`*`@b^^=#A#&n&^T&L841?O>{-B_g{aP&i|UJ{oiIuZ(n6v
z|8vOoMlQJ~>XCOa_k*ot|7oWFHqi99eF6sLn&^c5sYrB6u8GdbXA$=OoC1Ahnv-jy
z3v%sXMXrfj-!m&ZN1~BU0lkq!t|fKJM@Y0!u8Df&dVgPhcmCH*$JF2#$aF%kH=2@b
zqBHUsiDrgZ^RJoCjlk~JZ$Yk!mgLSwvPiA(o2Ax7ZSp43di^;Rm?G02xhCq8YX=^=
zCORVjXCykVyjlPH1k@W%sDYMrN}eInlw1>?k?Z~EJD2^ZnHIZ1v;QW@v?SLXS%q0@
zP1Gj$z9BD8UGn+YBe{V?0qwvg*F=ZpA4j4ia=p)(Toau{6c{4Ygj`EHCD#sS<eKP`
zyhNe}e0%=a8<o^RGqrwTmU@G^?~rSvHo4y4F+JLz^9N?Yy2%%1I}OS8Mk8`fbWC0#
z(U@Ekt=8X!0@}fpTuYjh50U7ST<=qmYocZC_4?QCH^JO*sDYN$`k^@m+JQ~3iT24)
zMWTZ}Z}y+wXt)=s_n&4uB441SA-N_xCfEB<$g4zU|7R4)k!en@H(HWwq6K*m6<w2S
zqU8^<|8)wq1M5d-skNj%^4}oQKDpj!K(2`n)n)wE7oo^B&_MJ2+r2oA$hCtpxh9&D
z_r4^%DI<^cMmYsE(<OO`L|5cm(t=#?Uy>uy$m(8VmiiIMv`4Nt>XU1t1M(#j^~p8S
zVdGW(dG1HlKuemCzZ!|A<eF$ku8HRRUeAAuOc(os$~Ds^xpq*HYoeVWn-%>O677=L
z_i5H&j{=%$pL~u)J$4*o2jrUQkX#cDe@y3pefvD72E8xK>P^W1A3P<$Jv<}7D?Hyi
z_TN1bSZ)Kd|B6fH14s(;2jTjX{IPKBC*~A92X2!`5dsbcPJ_GTZ-jf~XTyE+5(5ax
zKaA_6kOCJW5R-oco{(Px&&Yp^MVFK7npleO&i^4wSx|#D7Tua$cSlLC9auj#r$85-
zYj`#P`H}dJrV*&#mOnx~B-h{ZPRKpnCnJyXJEKeT=6B2M^;c3rf2G=9n<L1PkjswW
zkoL(vTt6c3{Fm&eapleW=O^HV8tC(2O5VL#j@2o-PR)#5r)Iu$*?&4W#V*k7zhjYU
zNv=1ter8rk6Sc`LB-$n4o&PDI9k}G0=zv_mr4qFGxW#7?1v30`i3R)laZ`~sd4g|T
zb}lt5QQ)^{ZF2o>*dBa){?~xl(qKrgzpNUz_@u>C(<4iNyLD*>tmGe`*^GEap5vR-
z1$l~(YPNoERwB5ze23K`x0;XPtk$1LfhE4T8<6WKqL0Y0hYzosk{8~+n*q$p%NyK5
z23C8${&oA=_(K8(HTcUB@-5R1x&FM6{R?x%pE*W;dA&#8yREpl=gt1R;Jflb80`h>
z6!p8-A$fW2M>ZoElV`ttMB@qh$+&+?e)f0u{7(VRFei7hj~C=V{(nhcb<iYKkbeSh
z|B}xC`d#bpFU^u_>D(3{kSDfOC?NMA{n#d<SY4if)gPg`rZh-3&|Fr%H}q>MX-@9L
z3-b7Jk8WD7$<HjL5*za9%?NaUWsdkA@Gkib-Xni6+$YyHG$gkl)(kkZ0tz^H#^NGB
z79C8;Pliv)wE{EpG1gGlcvXMhetldxrv}==g8YN%xFFY3m*iS$>(_gguIFD%ZSMyv
z*HSy=|L_BuOON~#odR+lKtNt6-mJfn0s%@iCf5qZ<k~?(t`(Y--v|R({F=`HdZQIJ
z(79Zb&yZ+Iu8D5Q_5Phwr=S_XWof4FHX!@&ky>hUy^&9@i3a2YBswDRM_42w1+;^h
zToav=>!O>H>!O>J>za#J6qsVfYjRC!L%vPqf3&1hxdbD&$#rVF;=A*|cF>~+I%1Ff
zT)div<oXC7ljj3@t|W$6^Y2|MKPHnIf$Dd{^~Yz(^~Y*f<eE^~;+_9BE7V+HuRrHN
zfy(>jI>!TY>qqiD7?K|ZACX@bKCZl3|M~>%A~2x_{{Wwo9}S<A|K|@Sp#`~4@oML?
z|N4OSF3_x^mF{nHT|^sl?V$62W~p@zIpk*+`22sD0$Ng!TubVcYe@rgt!PND6^$bb
zXh{?DXQ0$6`3vAVc^|$c*9sNz?fKsUl++-{6l}<K3asClrPdB?a-9Ot^vLp02%5PL
z%)oa0#pL?c@q}D=$CO;3fHU%!Tv9L6YW*!JaIYp%{a!G+j%-b?iEPMARL=UXSs|@l
zr}ldN>-N(Qy3{~RHz2p3B$e~YwGsijRwCT<X8#@aW7)6CUZ9?n|3M{Ea!oWN*F<u1
z=bQ3A!GgT1gzWz%1+;^LTr065*AaJqXO>z=+$BFKl%E~#|BlZ8w?-uf)Ibv&l4~L(
z@(xBElIz@$)n)var5#K(P}jfurz4(|$C&#Sc?vJc^~GsJ9%;b-y;(Z-UW<DzJ|x$v
z8IeEYC(W9RtO*5fBmrwmt`(Y*Yln044W=L`*C|*uUe%ws--;UO6qMvTGHYX2P8Xd`
zjuBhVzSr}w&vth|P`N(aee$QELIJr}C?wa!WAeDFP_zCf6wneS<k~?>t`(Y-YlRl%
zT8Y($&i`78H8s#mbpBwL`rW8Rms}I=k!ynetz-Z7u~@uqpx%7d5e&!k0l9WCB-cvB
z<Uc^73HiwpzGh1)pqXamQzSYk*F<x2O>{}FiAHM*=$viHbyau&XimZPek!jWJ#y{1
zPp<t9#CPX^A0zXrfsSlQt{sfXbz}+ogOO-zcs2ieqs$0cmOfZ=@&yuIkZYn#a=m{+
z-XvPDzs{e`lD-<5cFFZdJ#t+ueeyyVHMu4_sJvPK`~)0Q11)Jtu4^SG*R_(6>%Px+
zF8lBE7;(M}G}}){yd>8|3i1piUX$yHOY)QT{BQl)oB|zjkNom$S?zstO>{u6YiLM5
zLZU%L0nKzot{sfYHPIP)fO9}b?%!3u3ZBEa=YRdA(iJt(b3jS1b8r2{tenohP5zTh
zrE-qxk+pp{%M4iWK?9#$D-n=uf+4xRlEdeiTq<3yznB8rK|-#j&dK8^2F+q!kl*R&
zGU65a@$hx+&HitiTh;)94K=toyz^JH)DMPt$sYmlk)H(b?|HNT3cNMq?*;0d{0GWn
z3CYt3;H?yL|E`a2hLVv7-<0c@<j(PrZu+-M3Ir$0jqJ<J5xaPI+a(WEx!x!D9xon}
z>$~mAWs%uIeiz9!qXs2>Nv?0VugG<GtjS-7zx&a#KG0OEBjdNM-~B=sOIHI;c=zJe
zBi9c5<UOo*k6fQC1M)~$`;Y><+9%}MgQP+;at9BV1$l9jOu>>o>o?zwimWvS^nqht
z4kbb*E|vzCOKxM1`{epS8<OkanhYDS>aVYUw>Vb5JvN~R>S>G5TYTB#>wT~1Upuf4
zGDoc5ZE?572Q3~Pz?=0qK0u(ZdeY*v7SCIJ)#BwrA87jDPQk-3l<#zQE^k&s-D&ZD
zi~B7;+Pd^_X$SE(AgfM&+TvM@FIv1{k1*m52jKP<4qS;|i+e3TZ1E_hfNqaTi>EC<
zC%>*GyJ^|tYw_LrUmI9gG)KJs10pT%w)lYjiib-=f#KEsC*wyolRY*9mK7W?9+ThY
zIJwc3{H^e;#TN(idi@m#3RJ!!f52~Xgu0ShA^jF>k39Ll48SE{o-ID8yjlPH1iTzN
z7*c~{;3INPa7^yuMJOik;QuE(m;I+5Om~51N`~loL9XB9S+ZkfD{_4;*pR>VxJc&G
zKG-bjw$$Wz{+&#LOMVZyNAAM|@~gnZhyq%Pm|PP~$cHHPlw3=llI#65`1bs-rCw2k
z2O-lnx!!0)u8DR!W<^6JYMWl|f6PhO3|QJhk6aV=$aVV-TYN(9G+!ZA>u*MZ0_XXR
zJbkxpn+3Uk|8PnE8c){Ny2Y(4R~4$)zivNm(5(XpaJR(=EgrP^c+Z>tryVDIfjR;8
zS&Qc_zH0IEZ(a6(=a2)B*lF=Txo+11`Oi19T}R~agO3l1%#QDM9r?z<gc@jvQ}PK`
zbxN*_dPc7IpR3FGtMflHT5F)LfBg^Ngto3?Ci>7n$jEGR-8BxmKB`^vD8&f+6wncP
z<l2ExuG?}%j&r^hljD&bSt$jcdYYU8=PkY@&mZ;Zrci70-~{oKJioj6rtzx&y8YsN
zNWi+PS?XuuFCccwKm13$7Le=p1M=li?jP)X)xQ<rTLPo~K;`8_#bffq7oU*p^(lFZ
zfz8On>i%{AR!#xyzS6;hTstVpmk*Td*W`5v&A+Re6)o>4-nkl`|FwZb4U&6GgC4mi
z<dNt9EY}anuQI?HaO;sIsDWe~5clTt^LiOOzUW+%>pLJNxxNEpA8J;@iH?^{T?*(s
zAU?Ui0}_(!J0J;pg4I4Hzw%pTmqiN-#CWe}P415*(azOr1b9oPN1i?zQ$X(EJ|pqn
z`M*R-C)7aSKuE|x{U_OeDfyS+8TnV?x#89Pe*=M~5wNTe<Gq@Ke1+>v@<Z@VWy>}z
z^c`GplYg)Fs(;I&z_ZVm7a^B?jT;Tg^<A!j{oC@(D>3=}p7;W$^1A=+6Ho(LOM`+u
zd!Nj)bq#aG8Q#9@kRN$(>DbwM)4!#G{w~n$KXt#wM=c(=_>}yOf5FfH%qXB8=PkY>
zUmq$XD_gvCO|wFJy%V(r`sDi6vESmO7LQwe3g4dpwS%ms!Ge5@ukQ<T=lW8KO^e%y
z8I_1EZO}6VTlZRg*y3S}PY&qS`b!TOsDAyf#g{F<ZgJ~c#)!8A>(*Yce?5SF2PJi>
zf%<?vyMEB@l7L*_xEPV^_3@rJ`%fE8_5$^ty$4GNDS7IP&)AO?&suy=?mjqZ`nQ%8
zaL~bud~}&S^Vj50gWK0OORevWbjge6YrpErdu=-Z7x$MD^r^vh(7}NGzVIQrCO#sc
z<Fp;B%lNDJdN87~1}yof9Zbldg^uUs`p(FTJjEBa1$m?;Eh%sn>+~iA`#NSxzmAR_
za!u4F*A6}MrBoua1{Bar_~hC_K(3WY$a9Q%O0EN*HD1+Ux8E}`;srIh1AIlU39ZSs
z!wtFnE%`>Ib=|#+*7L6;?(7FD*ABYmI%1Ff`AF0!*ZTzIb)wDs3n^eB(=oXw8k1`W
z3ArXZBiAXIUzg7R+bN(1FU5&yP5wcQctfrUb-H_{t}3dDbhnQE*TsmPZJ=5F+o|c1
zYX^OD9kEZYBM!)K6kSfXSxkYSV`K@rcAS!HhZ*@A51cu<PGyu+Ks#8H>&VvRI<n5+
znWa7)1M8CO{d?lO^S|D>PYni`8joB@Fd)|shU7Yc(C}*hbp){ysD3O@r-0o1xg4uA
z@<(9AIk_gZBySR_*Iz+_03%+L>xfHo?ZEnba|(3CE_seuKfm&3{p%A@f8$|D4KBL6
zoaw?APs#N+Byx6iyx6(yzwih64aZ%e*?-}$<hS3t*E2^JKU}^n@0077*+cRSU!;!7
z^It~N!IT2}Rq&iV$4@w{$X)!>+J?M<cdu^_AjMbN{fGkYO1{1Bkw49sDHyhR*y58G
zPvP71zjiQhX|QbZb&Fd!Fh{KS@0uQ28gR|P)(0&fwD`Ei6LNV2vRZ!`1vH@r`5Q3>
z8}j(4vKYHJG)L^g`{V(9SbM$xb^8@RksFPvL5>Df@)SNN&vBm>xrOUDd*19n2Z8QC
zm?Nk^AiVzPu;1#$#(U)ct;Jn({e1Aj-@5GoF$KbFp3rnKCC`5*6`GSLzZYMT2Y(RX
zko%X2cb&)_ap_CPj$`^`ZXz$!F8S+jChn2H1MZVw01wn<{Fe231VRlo<F~Az!l&eg
z&OLeXYgB^VhHuED{Dv}T)<2pf?(}f}C%-n_A-@saB|i%8ksmHcy6X3TC~!wK2*@7<
z56PbZpOU*jmrBgpe~bz>Ue$lQ{m@`T4FX*(H!>?^z2Zg9B=yPN>&hDP$aM|*`(Drg
zIXdF~K;<9T5tFarF?sM4IhZ8mzs2<_`IU}1U0(k)3f!Oy)c<nwTfx`l@$aOhog14K
zDzII9<o0jn`oWFq{9j;hM%2K&zmzm2zt02ZRdLedX^YRdj{T=MT5khQ0WA9;WOtP0
zdVS|6=7`mu7Voo17=h0L_^8F>7N53w*5c8kC9okcz9n;J9d3^Ji&zsj`7hxP`PGla
zlT>_n{=Yc_9yK@~?vwlQfLtF$A^F2`eQbC&|1U!zF#?wL26#%I!!z<9z;p6Lt|f2h
zFUb!&s;Wf2{t5~li3TP4E$RmKznhv<a3{D;u9a}e?}O{z%A57CPr#E9@TkE{;Xe7>
z-~sss@R0l>c)WAje?LZGwhJ@^wGWo<w;)d+EYE`_xjteG@+;n4Dp!&pcJl}&y_s3k
zo1uYCeml5B{!q9}{>vN7{XOzO!u^N>2jid-klXN(9516*OnxI=pOE+ADSUhWzaIh_
zHF!B*JaY2G--T68K1L-9^0RQC()7rBI|5eEoPu-l?KhiT=hz{CA_m}+KOgRqzoGGJ
z{rMDdzbh}J0r`h<qmcY_@R<C2@Pzy~@U-@N{p<F7Axf7~gU9I0F}a6Cm*gkm`hxrn
z+`ruOX8-A;vyL#Q;F!Z@_1feQg*)V@z+Lj!!#(oz4?kV@zfXaWqCr5eiH78##q}|H
z2~Wr`e^VJ)dIX*Sk3=A&2KR>N<X<=pyMX-3xV|926xWyPGJeZ?6&hGanp5ybxJ|B=
zaL8x4-X;GO+#`>EfPhbdzrX|X!}JRk@|(e9@;k#5a-5VRYes=TV3p3v^=P#ufBr3G
zE(>zKenWo9b!EyrN7a?C>aW{R8#qm1=ZPyFxa4~Mfc(&-<$9m|X!vm7>-oP20>OTu
z@<+i(<j;an$lWW+tL2RSI`V3{AP=s3qP+gEDWEUAoukdgm~`bvJ@OLnlE?T;Xh5Fh
z`q9yJ{tr&ZIiDI_?x8s6w|Ls(bMk)~%6*nw$Ntm6dK;+fU;R_JZf;gWz1!k0`B@K_
zjtA@!0s#l$;})Nhr#;LuxxR(7WXD@L(TW249!^27@8N7(-2NxCLdzqtR>;$T5_iRS
z=l|s966jNd3?uW%pJK^-#vyrrC%I2T9^(F);r0CEkhwGh)$av7P;OL`yVy<}@`G<L
z`@VAvvl6ErD~UP>^1A;%1)h4GH1NswMkDf<qvJ8TUZ1r1tnz04>l5&2xY3dtg!e@y
z$n%GY+palc=dR)|dGHGH{?29pb&r+O4R(Qg_gS}t56K@6ACW&7J|>^SC*<cHi}U}K
z0-r{M8TpstbMkM&7vw*LugI@<M;Y)sqQDUd*#FNgY5o|Ll-)Y1sgzIddUAb8Ui?Ws
zfp5?M`W8z@4bsO-gC+arq~nsjc$i#o-_jgFb~AC;^y>XT>~G%;Smoi;AS4fNBA$?E
z@Qge_$4m0~xcWZT`YS15y-GURke_}Nd4}7!GDoJ{wMYK_K(6;%d{}$E{&o9lg9$Z=
zA0!FQ$d^O$1$lyPxh8jTpU$m!1CafPIqU5O>Q$9s(GAE$yd5_p*C*zLJjGPb$je)v
zDE%)eVB^(kP44RmZnGOfov5YXkRT5qAQf`SZ9Jd`x1sZYi5HI%H~1I1(S$rZ3`Z_<
zPp5`l-%nht%lNA=LMPHesexu#mZgiUbBsCS`#we%m(${X^5;BOuJ_3!4U8yo_6gD;
zZt*F(bG$s!a`N(_GO&U?6|csBTXSUk4T%o<m(f9&{5$X-xjvHn<ZE0%XuRrQx1YY1
zGNcB7M1v8zeRmo0nEa;jlsq_5Dv|GdJ^%3uDA9hP^5A~rR^P0Ue`j%r+`Wsq$BykC
zkO!4F>o2B2f(9u&5}J{}?>MQ%ocuQUv7H6^9pS4!o&R5r(ygh%o8cSs^WdG^nH9PK
z?vkgdkiYe2{ME<r>dWOeAp5U?C*(P%AR`a(=v|Wg_`c$bd>K7a=B%VZ_+;@7dGI80
z>-Oe|^_1Kp*Hdzz+{1mMAqDhnzkpo-NOeM9;*p$@$9SME+4U?bzB~VyI2_t{Fh^E@
zm0JJnk~?Fmgi9X4ee&`Uxld?#HU9}3Bu1cmTmG`gH63T<OMUa1JjNWC<QBe;u#Ytd
zmb|hWK)wFD6nMkq<k9PrKjZP@gBA~3JR#3;z{x6a*1tXhJ)JXZpy&1#`5W$qQ!M!m
zz9IiGymQBGC1n475`pe6(3Jinc#r(Y@ILt!?kx!o$h+{6JbzgvizuOh9+NY2JtZ&6
zlT+nBCAl7A?K^Ep+ziaZiO7v8V82Xm<df^6G$gN%P|Xb!ay>z1<a&Zy!nfytJwmOh
z!T&x*7G2rm&T%xdm&*V=@(>=F9$5ueV{8U28zoK2J$O!@;KgY{Zv8^u&R>zsi&M4!
z))dfJrw#e1?<0$=<C!D=3cO4HeRz-j=WxIFdj0G6^AjmuNDVAJh{oj6iSj-{LarZL
zF>CRB&zt?H4OV-BdR3{HE#A4aSqZ(~AwT=RQaP9W()YYd_W$5-1I?-qT09}Q50zbz
zk?Xr(b9Q{akl#5nN1*S1EvSLM`&G2~hFt%4ynPq*{_38(jK4bn+cJVc1I_rW7a@2|
zp5oOkCD-?WbMg{zauwuJfS+)%?rLVLUyyXjFUaw37Wv!p?K+qI=l7SnACf!LZ)A-r
z;3J_axd)$<>i|~dI`;*;er?%!RsZew!%wf3)IjInxtm!b7YX&q^?HvyKUpdl?t4A|
z?%^``<NZM8`cW)Ni|6F};<O;Y;S;3e4S8HuqFI04<IRz2=^S>Hu1BuB#wFKE3|f4A
zJe~iSca};_sX=m#_?&#Z+R5+tba~NQwRpL8>_2VLxw}~jb*IJqEj}XGMLHq(BP^mB
z1+YD=j9mW~OhKL>EN{nI_b>;bZ@W3<`mS5#Q9w^D0l9Zmd2x!#3wTQI<Ajrw>)UjN
z`0o6#@6%ZWa|C)+a>x^O+#`Scr)0Gc$@Qc(HoTgDJt|F&K=nw*S2lC<?MaE;|B-yX
zupzg9EZ)7RIk5PkYRc;M*QbDuxg3&v@G*G^pOWi|C?(e~*R#r-^{-Dr{dzs826`e|
zl0WAW@@y~2Uji@5&wyL^+EzmL-&+vq?E=l~UyhOv$V-%TL>|K@<iSs53TEWt4<iXI
zC{X-Rd`+HSBHp?8b_7kLF5D)+!ZYPT)FXf4(c)gz5*W64*y58GpOYtdk>|t;zCHgt
z|0IEe8k9E|-;jH^74P21tVDqh`sB-($n`_hBP+bS1jc5d`o4hplsven_?$ewmH3MN
zX5t(2tnq67b?<AAAij+>=#wvRDejTGM~e^1LsWE3?xI4|+UxbN+t0p*+-Ob>te1(e
z$cq!iH{{L{;@$h11M}`G-rw_P|LGJA_X72@&IZz8OkN_PnB2dITt6kxJ|doySJ%t_
zpL5`2(qKjIAfXLAI_}=z9C41d)hE|Vc=xCC|5NZ&Z9X-);tBGk3&^hp56S-y9+Tf3
zo~X<CE$dzgq#9@*E0*;L_=4Q)ONG|tJ}T7l%}T`Z9(knu)un*G7I@_PTHuqv1c?UZ
zXTU@9w~9wrOo8*zAR)g1o|51Gee!xgZ}DY|uN$xGuiH;=WIezvoqD&$-4-9Tc(CvF
z{A&lvexULYPr8iUgD=VT$yk!RxZZxCIWWKSX8pMo&}X$zUSd0i<OLR2LZ01O7HLKv
zdg99m()mBbsxGO4cQ<KZKgb+`^(AqaJisH?C(lQ6eYkb(KOaxD@irj)PhY2#7N50v
z-r_6v2nT`AKbs@dDd>^wqk2HDYhpyMb3Y*uo*<QoW)z4YBY}+EM(Gyh{s*4Wlxj_`
zFIt@kn**~SEBEh-@6P}6<0LSk2JutGN96k83dtYyczIOE<Rf@ucs2hI@T5U%1T5>B
zXpoVgiFZ13@-ePolb3jz?mWb-gm+>!uzLOVC=fmol_0nA`aL4I?jzSv$bD3FMxJ0Q
zv&x(GuTQ|ooFtW)Q-dKqCtr@_`UUxQo*=#?e--Xi?p*fY@;NdB`=Mruv~*o^-Ii{P
z4_bUo9^O5Yj;9pR?KdaaBiD*Ntmm@&w;?ai6}N`wz^ZpXo9nw#OTcaML5l}1J|+)e
zE(s;@?fE~Spc2#|LxYsuhtJ6M8;&b-J@sx(kE{eY>ORaYQTT6?kVF2BSIC!6KDka=
zNUl%JguQu9sn%ac0S~WQOL8CEuOts=lBoSJ<^Xi=yX4!&TYJ6!b^B>x(9&Q`u3yVd
z*|F&6<nenX(R|OF{g<C7fz@81UY_3h;u~^(^jZ%$N9?16F8LDPC$Ao8vj2w^(1XL6
z+<&(uG$k+JD?TUJbN-54*UIMMbpDTVRO&v$99e=2IpnsEjJ(Jsp&_}xDhBE@e#=^-
zgRush$3ykaY20W^9_on6^@+J6x6Z*-l1BxOR^3OMBi8-eC(kd$$jJ4@X-w{YQLdko
z<7>#sno}UfQ7k8SPLq9Kk}v1df&D0R0NFy^B`+=#_ZzS3uiMW?rXe@LVRB5aUm;D%
z^(&+)`L&-TuZpvMujl{92+a2bmAmi-`LXa7`2cP`+N^|!FTXqFbw!)?=TJbuOVw|2
zzr{x_9+Q8?mZ_XRn$G|4!yISa;2>#Gkn5?}3d|AfS3(ZCo`$`xWB>V|kVO$}1G4|h
zkBi6T`UOc!?qIFV$j|#X89>e+A+X{AylnB#W6Tks|0_9AIOKPKwRGHX@yMru_e&Y^
zh}<v5Lvrue;$!mg(8o6=jLE<JE=hDMzB~VGAZux`AkQw7jtg=hUlXp$6C`9kcE57f
z{O4DfOgl!PIv1dUO|B#Bk`GUpQoH1Tgbxnn_4*4a@cdKcK`|nKF+3!HC45Z&YIsck
zY`n=esk~YL`UE@^4H9Z_(it+c8M*!dLQZZ!LMpmqKT*8cIriTP5?Jp7&EnBgm*jfL
zbWYfx%j&!3kCprM$bBT_k(Y-?qo$()1^lav`{WsXNN(G5eLx<<N90R*7*W8!n%rni
z?j9;0lZUu|LhfHvu20Al+-C~kp8u0;NQ0Cb*oTSF$d~9iBQJ5EIeCVJa?>NrMT5c&
zSWZVeUXy$9l01NK$YZ#5BCVA}>ibvguR{UrD$=n{?lujo?-!8gaEClSSnks!UtU?<
zt-W6Von{Hv{~>`sHAv9FBe&7<fZT`s<PHWl-1BDt6$k`-fjXxU9mnJj5}lBH@Ps^o
zPs!uXNcMk9ffNm9<USJ0$jd89<>urCrXVNRsac#DnTtZ_W=Rb!B(x&esVT^HYS!dA
z5-QbY{MCyMMz+xa)<g-n9%m*R!aL+&!=u_Ecku-5lSj@Kq;wtyT=;<8zoK04lYjLn
zd0ij1cubBTZi%evfdf|7;)@n9$d{+cYr%%x`B!o4q`IP2{W~bN{agujn!wKWMaU-C
z7a@<lM8^a2AHGIjMT32>=RbLobUfY<RIXDKlk3z>$aQKGa($Vek=H-2*Q~$%0D-zF
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%0DJgdBGnX|Q09A=L?<$kFNNZznE^F#@C
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%0Dm8kA$#*AvjT1#aSWp|sl{DrUmzOq+B`<UEPBhv
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

diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
index 946f033..973a453 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
@@ -89,8 +89,8 @@ async fn apply_delete_client_kv_meta_cache_item(
     let client_api = view.client_kv_api();
     let client_inner = client_api.inner();
 
-    let cached_info = {
-        let controls = client_inner.owner_key_control.lock();
+    let (cached_info, pending_get) = {
+        let controls = client_inner.owner_key_control.lock_key(&delete_item.key);
         if controls
             .get(&delete_item.key)
             .is_some_and(|state| state.reclaim.is_some())
@@ -133,8 +133,19 @@ async fn apply_delete_client_kv_meta_cache_item(
                     snapshot.put_time_ms <= delete_item.put_time_ms
                 }
             });
-        cached_info
+        let pending_get = client_inner
+            .pending_local_get_info
+            .remove_if(&delete_item.key, |_, pending| {
+                if pending.put_id.0 == delete_item.put_time_ms {
+                    pending.put_id.1 <= delete_item.put_version
+                } else {
+                    pending.put_id.0 <= delete_item.put_time_ms
+                }
+            })
+            .map(|(_, pending)| pending);
+        (cached_info, pending_get)
     };
+    drop(pending_get);
     if let Some(cached_info) = cached_info {
         client_inner.owner_hot_invalidate_version(
             &delete_item.key,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 28ba872..42fe4e7 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -1,4 +1,5 @@
 use crate::client_kv_api::ClientKvApi;
+use crate::client_kv_api::get::{StartedGetRevokeCleanup, finish_started_get_revoke_cleanup};
 use crate::client_kv_api::msg_pack::{
     ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetCancelResp,
     ExternalBatchGetItemResp, ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq,
@@ -14,10 +15,11 @@ use crate::client_kv_api::msg_pack::{
     ExternalPutTransferEndReq, ExternalPutTransferEndResp, TestPutPhaseTrace,
 };
 use crate::client_kv_api::{
-    self, ExternalGetStartDedupKey, ExternalGetStartEntry, ExternalGetStartOwnerItem,
-    ExternalGetStartPrefixResult, ExternalGetStartSharedItemResult, ExternalGetStartSharedOp,
-    ExternalGetStartSharedPhase, ExternalGetStartTransferOutput, ExternalPendingPutCtx,
-    ReplicaTaskTarget,
+    self, ExternalGetKeyInterest, ExternalGetKeySharedOp, ExternalGetKeySharedPhase,
+    ExternalGetStartEntry, ExternalGetStartOwnerItem, ExternalGetStartPrefixResult,
+    ExternalGetStartSharedItemResult, ExternalGetStartTransferOutput, ExternalPendingPutCtx,
+    OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerLocalReserveSlotLease,
+    OwnerLocalReserveSlotRef, ReplicaTaskTarget,
 };
 use crate::client_seg_pool::{ResolveSideTransferLaneReq, parse_side_transfer_worker_lane_idx};
 use crate::cluster_manager::NodeIDString;
@@ -26,7 +28,8 @@ use crate::cluster_manager::{
 };
 use crate::master_kv_router::msg_pack::{
     BatchGetStartItemResp, BatchGetStartResp, BatchPutDoneItemReq, BatchPutRevokeItemReq,
-    BatchPutStartItemReq, PutDoneCommittedSlot, build_put_atomic_group_assignments,
+    BatchPutStartItemReq, GetPreparedLocalReserveTarget, PutAtomicGroup, PutDoneCommittedSlot,
+    build_put_atomic_group_assignments,
 };
 use crate::memholder::MemholderManagerTrait;
 use crate::memholder::NodeHolderKey;
@@ -36,7 +39,8 @@ use crate::rpcresp_kvresult_convert::FromError;
 use crate::rpcresp_kvresult_convert::ToResult;
 use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK, codes_api};
 use async_trait::async_trait;
-use dashmap::mapref::entry::Entry;
+use futures::StreamExt;
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use std::time::Duration;
@@ -49,7 +53,181 @@ fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
 
 const SIDE_TRANSFER_OWNER_RPC_TIMEOUT_SECS: u64 = 30;
 const SIDE_TRANSFER_TARGET_RESOLVE_TIMEOUT_SECS: u64 = 10;
-const GET_TARGET_NO_SPACE_RESERVE_SHRINK_RETRY_LIMIT: usize = 8;
+// A handle can legitimately wait behind one full SGLang request-timeout
+// window before layerwise restore consumes it.  Keep a bounded crash cleanup
+// lease, but do not expire a live plan earlier than the supported 300-second
+// request window used by the aligned agent workload.
+const EXTERNAL_GET_START_HANDLE_TTL: Duration = Duration::from_secs(360);
+const EXTERNAL_GET_START_HANDLE_SWEEP_INTERVAL: Duration = Duration::from_secs(5);
+// A BatchGetStart transport error has an unknown commit point: the master may
+// already hold the prepared target even though the owner never received its
+// get_id.  Keep such slots out of reuse until the master's 60-second inflight
+// Get TTL has elapsed, with a small scheduling margin.
+const PREPARED_GET_START_UNCERTAIN_QUARANTINE: Duration = Duration::from_secs(65);
+// PutStart has the same unknown-commit-point problem as GetStart.  Keep the
+// owner reclaim fence alive beyond the master's 60-second inflight Put TTL if
+// the caller future is cancelled or the RPC returns a transport error.
+const EXTERNAL_PUT_START_UNCERTAIN_QUARANTINE: Duration = Duration::from_secs(65);
+// Keep control-plane batching, but bound the failure domain of one uncertain
+// BatchGetDone. Atomic groups are never split merely to satisfy this soft cap.
+const EXTERNAL_GET_FINISH_TARGET_KEYS_PER_BATCH: usize = 128;
+const EXTERNAL_GET_FINISH_BATCH_CONCURRENCY: usize = 4;
+
+/// Resolve the generation carried by a MemberLeft event without guessing.
+/// ClusterEvent::MemberLeft contains only a node id, so a currently live
+/// generation makes the event ambiguous (normally a delayed leave after a
+/// reconnect).  Missing previous-generation metadata is ambiguous as well.
+pub(crate) fn external_member_left_departed_epoch(
+    previous_epoch: Option<i64>,
+    current_epoch: Option<i64>,
+) -> Option<i64> {
+    current_epoch.is_none().then_some(previous_epoch).flatten()
+}
+
+/// MemberLeft is a cold path.  It may scan the handle registry, but removal is
+/// conditional on both requester identity and membership generation so a
+/// collected handle id can never delete a newer generation's entry.
+pub(crate) fn cleanup_external_get_start_handles_for_generation(
+    registry: &dashmap::DashMap<u64, ExternalGetStartEntry>,
+    req_node_id: &str,
+    requester_node_start_time: i64,
+) -> usize {
+    let handles = registry
+        .iter()
+        .filter_map(|entry| {
+            let value = entry.value();
+            (value.req_node_id == req_node_id
+                && value.requester_node_start_time == Some(requester_node_start_time))
+            .then_some(*entry.key())
+        })
+        .collect::<Vec<_>>();
+
+    handles
+        .into_iter()
+        .filter(|handle| {
+            registry
+                .remove_if(handle, |_, value| {
+                    value.req_node_id == req_node_id
+                        && value.requester_node_start_time == Some(requester_node_start_time)
+                })
+                .is_some()
+        })
+        .count()
+}
+
+struct ExternalPutStartFenceClaim {
+    view: Option<crate::client_kv_api::ClientKvApiView>,
+    fence: Option<Arc<client_kv_api::ExternalPendingPutFenceGuard>>,
+    uncertain_delay: Duration,
+    #[cfg(test)]
+    uncertain_test_sink:
+        Option<Arc<parking_lot::Mutex<Option<Arc<client_kv_api::ExternalPendingPutFenceGuard>>>>>,
+}
+
+impl ExternalPutStartFenceClaim {
+    fn new(
+        view: crate::client_kv_api::ClientKvApiView,
+        fence: Arc<client_kv_api::ExternalPendingPutFenceGuard>,
+    ) -> Self {
+        Self {
+            view: Some(view),
+            fence: Some(fence),
+            uncertain_delay: EXTERNAL_PUT_START_UNCERTAIN_QUARANTINE,
+            #[cfg(test)]
+            uncertain_test_sink: None,
+        }
+    }
+
+    #[cfg(test)]
+    fn new_for_cancellation_test(
+        fence: Arc<client_kv_api::ExternalPendingPutFenceGuard>,
+        sink: Arc<parking_lot::Mutex<Option<Arc<client_kv_api::ExternalPendingPutFenceGuard>>>>,
+    ) -> Self {
+        Self {
+            view: None,
+            fence: Some(fence),
+            uncertain_delay: Duration::ZERO,
+            uncertain_test_sink: Some(sink),
+        }
+    }
+
+    fn take_for_pending_context(&mut self) -> Arc<client_kv_api::ExternalPendingPutFenceGuard> {
+        self.fence
+            .take()
+            .expect("external PutStart fence claim is armed")
+    }
+
+    fn release_after_definite_response(&mut self) {
+        drop(self.fence.take());
+    }
+}
+
+impl Drop for ExternalPutStartFenceClaim {
+    fn drop(&mut self) {
+        let Some(fence) = self.fence.take() else {
+            return;
+        };
+        #[cfg(test)]
+        if let Some(sink) = self.uncertain_test_sink.take() {
+            let replaced = sink.lock().replace(fence);
+            assert!(replaced.is_none(), "cancellation test sink must be empty");
+            return;
+        }
+        let delay = self.uncertain_delay;
+        let view = self
+            .view
+            .take()
+            .expect("production uncertain PutStart fence requires owner view");
+        let spawn_view = view.clone();
+        let worker_view = view;
+        spawn_view.spawn("external_put_start_uncertain_fence", async move {
+            let mut shutdown_waiter = worker_view.register_shutdown_waiter();
+            tokio::select! {
+                _ = tokio::time::sleep(delay) => {}
+                _ = shutdown_waiter.wait() => return,
+            }
+            drop(fence);
+        });
+    }
+}
+
+pub(crate) fn spawn_external_get_start_handle_sweeper(view: crate::client_kv_api::ClientKvApiView) {
+    let spawn_view = view.clone();
+    let worker_view = view;
+    spawn_view.spawn("external_get_start_handle_sweeper", async move {
+        let mut shutdown_waiter = worker_view.register_shutdown_waiter();
+        let mut interval = tokio::time::interval(EXTERNAL_GET_START_HANDLE_SWEEP_INTERVAL);
+        loop {
+            tokio::select! {
+                _ = interval.tick() => {
+                    let expired = worker_view
+                        .client_kv_api()
+                        .inner()
+                        .external_get_start_registry
+                        .iter()
+                        .filter_map(|entry| {
+                            (entry.value().created_at.elapsed() >= EXTERNAL_GET_START_HANDLE_TTL)
+                                .then_some(*entry.key())
+                        })
+                        .collect::<Vec<_>>();
+                    if !expired.is_empty() {
+                        let inner = worker_view.client_kv_api().inner();
+                        let mut removed = 0usize;
+                        for handle in expired {
+                            removed += usize::from(inner.external_get_start_registry.remove(&handle).is_some());
+                        }
+                        tracing::warn!(
+                            "expired abandoned external Get handles: removed={} ttl_secs={}",
+                            removed,
+                            EXTERNAL_GET_START_HANDLE_TTL.as_secs()
+                        );
+                    }
+                }
+                _ = shutdown_waiter.wait() => break,
+            }
+        }
+    });
+}
 
 #[derive(Clone)]
 struct LocalCommittedCachePublish {
@@ -61,19 +239,23 @@ fn local_committed_cache_publish(
     op: &'static str,
     key: &str,
     put_id: crate::master_kv_router::put::PutIDForAKey,
-    pending_ctx: Option<&ExternalPendingPutCtx>,
+    pending_ctx: &ExternalPendingPutCtx,
     req_src_offset: u64,
     req_len: u64,
 ) -> KvResult<LocalCommittedCachePublish> {
-    if let Some(ctx) = pending_ctx {
-        if ctx.src_offset != req_src_offset || ctx.len != req_len {
-            return Err(KvError::Api(ApiError::InvalidArgument {
-                detail: format!(
-                    "{op} local cache publish request mismatches pending ctx: key={} put_id=({},{}) req_src_offset={} ctx_src_offset={} req_len={} ctx_len={}",
-                    key, put_id.0, put_id.1, req_src_offset, ctx.src_offset, req_len, ctx.len
-                ),
-            }));
-        }
+    if pending_ctx.src_offset != req_src_offset || pending_ctx.len != req_len {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "{op} local cache publish request mismatches pending ctx: key={} put_id=({},{}) req_src_offset={} ctx_src_offset={} req_len={} ctx_len={}",
+                key,
+                put_id.0,
+                put_id.1,
+                req_src_offset,
+                pending_ctx.src_offset,
+                req_len,
+                pending_ctx.len
+            ),
+        }));
     }
     let len = u32::try_from(req_len).map_err(|_| {
         KvError::Api(ApiError::Unknown {
@@ -89,6 +271,65 @@ fn local_committed_cache_publish(
     })
 }
 
+fn external_pending_put_ctx_missing(
+    op: &'static str,
+    key: &str,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+) -> KvError {
+    KvError::Api(ApiError::InvalidArgument {
+        detail: format!(
+            "{op} requires a live owner pending Put context: key={} put_id=({},{}) (missing, expired, or already terminal)",
+            key, put_id.0, put_id.1
+        ),
+    })
+}
+
+fn require_external_pending_put_ctx(
+    inner: &client_kv_api::ClientKvApiInner,
+    op: &'static str,
+    key: &str,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+) -> KvResult<ExternalPendingPutCtx> {
+    require_external_pending_put_ctx_value(
+        inner
+            .external_pending_puts
+            .get(&(key.to_string(), put_id.0, put_id.1)),
+        op,
+        key,
+        put_id,
+    )
+}
+
+fn require_external_pending_put_ctx_value(
+    pending_ctx: Option<ExternalPendingPutCtx>,
+    op: &'static str,
+    key: &str,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+) -> KvResult<ExternalPendingPutCtx> {
+    pending_ctx.ok_or_else(|| external_pending_put_ctx_missing(op, key, put_id))
+}
+
+async fn best_effort_revoke_missing_external_pending_ctx(
+    inner: &client_kv_api::ClientKvApiInner,
+    op: &'static str,
+    key: &str,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+) -> bool {
+    if let Err(err) = inner.put_revoke(key, put_id).await {
+        tracing::warn!(
+            "{} could not clean missing pending Put context at master: key={} put_id=({},{}) err={}",
+            op,
+            key,
+            put_id.0,
+            put_id.1,
+            err
+        );
+        false
+    } else {
+        true
+    }
+}
+
 fn external_local_first_error_item(err: &KvError) -> ExternalBatchPutStartItemResp {
     ExternalBatchPutStartItemResp {
         put_id: None,
@@ -96,12 +337,6 @@ fn external_local_first_error_item(err: &KvError) -> ExternalBatchPutStartItemRe
     }
 }
 
-fn external_local_first_release_keys(inner: &client_kv_api::ClientKvApiInner, keys: &[String]) {
-    for key in keys {
-        inner.release_external_local_first_put_key(key);
-    }
-}
-
 async fn commit_external_local_first_pending(
     inner: &client_kv_api::ClientKvApiInner,
     key: &str,
@@ -162,12 +397,7 @@ async fn commit_external_local_first_pending(
         )
         .await;
     inner.install_precommit_local_visible_memory_info(key, memory_info.clone());
-    inner.promote_precommit_local_reserve_resident_slot_if_same(
-        key,
-        put_id,
-        memory_info,
-        ctx.atomic_group.as_ref(),
-    )?;
+    ctx._pending_fence.disarm_local_slot_lease();
     Ok(PutDoneCommittedSlot {
         grant_id: slot_ref.grant_id,
         slot_index: slot_ref.slot_index,
@@ -178,82 +408,47 @@ async fn commit_external_local_first_pending(
     })
 }
 
-fn spawn_external_local_first_publish(
+async fn release_external_local_first_pending_slot(
     inner: &client_kv_api::ClientKvApiInner,
-    key: String,
+    ctx: &ExternalPendingPutCtx,
+    op: &'static str,
+    key: &str,
     put_id: crate::master_kv_router::put::PutIDForAKey,
-    lease_id: Option<u64>,
-    committed_slot: PutDoneCommittedSlot,
-    make_replica_task: bool,
-    preferred_sub_cluster: Option<String>,
-    atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
 ) {
+    if let Err(err) = ctx._pending_fence.release_local_slot_lease_now(inner).await {
+        tracing::error!(
+            "{} could not release local-first pending slot: key={} put_id=({},{}) err={}",
+            op,
+            key,
+            put_id.0,
+            put_id.1,
+            err
+        );
+    }
+}
+
+fn spawn_external_local_first_publish(
+    inner: &client_kv_api::ClientKvApiInner,
+    items: Vec<OwnerLocalPublishItem>,
+    pending_contexts: Vec<ExternalPendingPutCtx>,
+) {
+    assert_eq!(
+        items.len(),
+        pending_contexts.len(),
+        "external local-first publish job must retain one context per item"
+    );
     let view = inner.view.clone_view();
     let spawn_view = view.clone();
     spawn_view.spawn("external_local_first_route_publish", async move {
-        let inner = view.client_kv_api().inner();
-        let publish_ok = match inner
-            .batch_put_done(vec![BatchPutDoneItemReq {
-                key: key.clone(),
-                put_id,
-                lease_id,
-                committed_slot: Some(committed_slot),
-                publish_local_cache: false,
-                atomic_group,
-            }])
-            .await
-        {
-            Ok(resp) => {
-                if let Some(item) = resp.items.into_iter().next() {
-                    if let Err(err) =
-                        crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)
-                    {
-                        tracing::warn!(
-                            "external local-first route publish failed: key={} put_id=({},{}) err={}",
-                            key,
-                            put_id.0,
-                            put_id.1,
-                            err
-                        );
-                        false
-                    } else {
-                        true
-                    }
-                } else {
-                    tracing::warn!(
-                        "external local-first route publish returned empty response: key={} put_id=({},{})",
-                        key,
-                        put_id.0,
-                        put_id.1
-                    );
-                    false
-                }
-            }
-            Err(err) => {
-                tracing::warn!(
-                    "external local-first route publish rpc failed: key={} put_id=({},{}) err={}",
-                    key,
-                    put_id.0,
-                    put_id.1,
-                    err
-                );
-                false
-            }
-        };
-        if publish_ok && make_replica_task {
-            if let Err(err) = inner
-                .make_replica_append_task(&key, put_id, preferred_sub_cluster, true)
-                .await
-            {
-                tracing::warn!(
-                    "external local-first enqueue replica append failed: key={} put_id=({},{}) err={}",
-                    key,
-                    put_id.0,
-                    put_id.1,
-                    err
-                );
-            }
-        }
+        client_kv_api::put::publish_owner_local_job(
+            view,
+            OwnerLocalPublishJob {
+                items,
+                key_reservation_ids: Vec::new(),
+                external_pending_contexts: pending_contexts,
+            },
+        )
+        .await;
     });
 }
 
@@ -397,25 +592,179 @@ fn collect_all_local_external_get_start_infos(
         .iter()
         .map(|item| match item {
             ExternalGetStartOwnerItem::Local { memory_info } => Some(memory_info.clone()),
-            ExternalGetStartOwnerItem::Started { .. } => None,
+            ExternalGetStartOwnerItem::Shared { .. } => None,
         })
         .collect()
 }
 
-fn collect_get_target_no_space_indices(items: &[BatchGetStartItemResp]) -> Vec<usize> {
-    items
-        .iter()
-        .enumerate()
-        .filter_map(|(idx, item)| (item.error_code == codes_api::API_NO_SPACE).then_some(idx))
-        .collect()
+fn prepared_target_from_slot(
+    slot_size: u64,
+    slot: &OwnerLocalReserveSlotRef,
+) -> GetPreparedLocalReserveTarget {
+    GetPreparedLocalReserveTarget {
+        grant_id: slot.grant_id,
+        slot_index: slot.slot_index,
+        slot_size,
+        addr: slot.ptr,
+        base_addr: slot.base_addr,
+    }
+}
+
+async fn release_prepared_get_target(
+    inner: &client_kv_api::ClientKvApiInner,
+    target: &GetPreparedLocalReserveTarget,
+) -> KvResult<()> {
+    inner
+        .owner_release_local_reserve_slot_lease(OwnerLocalReserveSlotLease {
+            value_len: target.slot_size,
+            slot_size: target.slot_size,
+            slots: vec![OwnerLocalReserveSlotRef {
+                grant_id: target.grant_id,
+                slot_index: target.slot_index,
+                ptr: target.addr,
+                base_addr: target.base_addr,
+            }],
+        })
+        .await
+}
+
+/// Cancellation-safe ownership for slots claimed before BatchGetStart.
+/// Accepted slots are disarmed one by one and become owned by their per-key
+/// flight.  Any slots still present when the future is dropped are returned by
+/// a registered owner task, so an RPC cancellation cannot strand Prepared
+/// state in the local-reserve pool.
+struct PreparedGetSlotClaimGuard {
+    view: crate::client_kv_api::ClientKvApiView,
+    lease: Option<OwnerLocalReserveSlotLease>,
+    drop_delay: Duration,
+}
+
+impl PreparedGetSlotClaimGuard {
+    fn new(view: crate::client_kv_api::ClientKvApiView, lease: OwnerLocalReserveSlotLease) -> Self {
+        Self {
+            view,
+            lease: Some(lease),
+            drop_delay: PREPARED_GET_START_UNCERTAIN_QUARANTINE,
+        }
+    }
+
+    fn lease(&self) -> &OwnerLocalReserveSlotLease {
+        self.lease.as_ref().expect("prepared slot claim is armed")
+    }
+
+    fn disarm_accepted(&mut self, target: &GetPreparedLocalReserveTarget) {
+        let lease = self.lease.as_mut().expect("prepared slot claim is armed");
+        lease.slots.retain(|slot| {
+            !(slot.grant_id == target.grant_id
+                && slot.slot_index == target.slot_index
+                && slot.ptr == target.addr
+                && slot.base_addr == target.base_addr)
+        });
+    }
+
+    fn mark_start_response_received(&mut self) {
+        self.drop_delay = Duration::ZERO;
+    }
+
+    fn handoff_started(
+        &mut self,
+        items: &[crate::master_kv_router::msg_pack::BatchGetStartItemResp],
+    ) -> Vec<StartedGetRevokeCleanup> {
+        items
+            .iter()
+            .filter(|item| item.error_code == OK)
+            .map(|item| {
+                if let Some(target) = item.prepared_target.as_ref() {
+                    self.disarm_accepted(target);
+                }
+                StartedGetRevokeCleanup {
+                    get_id: item.get_id,
+                    prepared_target: item.prepared_target.clone(),
+                }
+            })
+            .collect()
+    }
+}
+
+impl Drop for PreparedGetSlotClaimGuard {
+    fn drop(&mut self) {
+        let Some(lease) = self.lease.take() else {
+            return;
+        };
+        if lease.slots.is_empty() {
+            return;
+        }
+        let drop_delay = self.drop_delay;
+        let spawn_view = self.view.clone();
+        let worker_view = spawn_view.clone();
+        spawn_view.spawn("prepared_get_slot_drop_cleanup", async move {
+            if !drop_delay.is_zero() {
+                tracing::warn!(
+                    "quarantining prepared Get slots after uncertain BatchGetStart: slots={} delay_secs={}",
+                    lease.slots.len(),
+                    drop_delay.as_secs()
+                );
+                let mut shutdown_waiter = worker_view.register_shutdown_waiter();
+                tokio::select! {
+                    _ = tokio::time::sleep(drop_delay) => {}
+                    _ = shutdown_waiter.wait() => return,
+                }
+            }
+            if let Err(err) = worker_view
+                .client_kv_api()
+                .inner()
+                .owner_release_local_reserve_slot_lease(lease)
+                .await
+            {
+                tracing::error!("prepared Get slot Drop cleanup failed: {}", err);
+            }
+        });
+    }
 }
 
-async fn batch_get_start_with_reserve_pressure_retry(
+async fn batch_get_start_with_local_reserve_targets(
     inner: &client_kv_api::ClientKvApiInner,
     keys: &[String],
 ) -> KvResult<BatchGetStartResp> {
-    let mut response = inner.batch_get_start(keys.to_vec()).await?;
+    let Some(value_len) = inner
+        .test_spec_config
+        .owner_local_reserve_expected_capacity
+        .as_ref()
+        .map(|expected| expected.value_len)
+    else {
+        return inner.batch_get_start(keys.to_vec()).await;
+    };
+    let lease = inner
+        .owner_claim_local_reserve_slot_lease(value_len, keys.len())
+        .await?;
+    let mut claim_guard = PreparedGetSlotClaimGuard::new(inner.view.clone_view(), lease);
+    let prepared_targets = claim_guard
+        .lease()
+        .slots
+        .iter()
+        .map(|slot| {
+            Some(prepared_target_from_slot(
+                claim_guard.lease().slot_size,
+                slot,
+            ))
+        })
+        .collect::<Vec<_>>();
+    let response_result = inner
+        .batch_get_start_with_prepared_targets(keys.to_vec(), prepared_targets.clone())
+        .await;
+    let response = match response_result {
+        Ok(response) => {
+            claim_guard.mark_start_response_received();
+            response
+        }
+        Err(err) => return Err(err),
+    };
     if response.items.len() != keys.len() {
+        let started = claim_guard.handoff_started(&response.items);
+        if !started.is_empty() {
+            finish_started_get_revoke_cleanup(inner, started, "BatchGetStart length mismatch")
+                .await;
+        }
         return Err(KvError::Api(ApiError::Unknown {
             detail: format!(
                 "external_batch_get_start response length mismatch: expected={} got={}",
@@ -425,60 +774,152 @@ async fn batch_get_start_with_reserve_pressure_retry(
         }));
     }
 
-    for attempt in 1..=GET_TARGET_NO_SPACE_RESERVE_SHRINK_RETRY_LIMIT {
-        let retry_indices = collect_get_target_no_space_indices(&response.items);
-        if retry_indices.is_empty() {
-            break;
-        }
-        let no_space_before = retry_indices.len();
-        if !crate::client_kv_api::local_reserve_rebalance::release_one_excess_reserve_grant_for_get_target_pressure(inner).await
-        {
-            break;
-        }
-        let retry_keys = retry_indices
+    let accepted_exactly =
+        response
+            .items
             .iter()
-            .map(|idx| keys[*idx].clone())
-            .collect::<Vec<_>>();
-        let retry_response = inner.batch_get_start(retry_keys).await?;
-        if retry_response.items.len() != retry_indices.len() {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "external_batch_get_start NoSpace retry response length mismatch: expected={} got={} attempt={}",
-                    retry_indices.len(),
-                    retry_response.items.len(),
-                    attempt
-                ),
-            }));
-        }
-        response.server_process_us = response
-            .server_process_us
-            .saturating_add(retry_response.server_process_us);
-        for (idx, item) in retry_indices
-            .into_iter()
-            .zip(retry_response.items.into_iter())
-        {
-            response.items[idx] = item;
+            .zip(prepared_targets.iter())
+            .all(|(item, requested_target)| {
+                item.error_code != OK || item.prepared_target.as_ref() == requested_target.as_ref()
+            });
+    if !accepted_exactly {
+        let started = claim_guard.handoff_started(&response.items);
+        finish_started_get_revoke_cleanup(inner, started, "BatchGetStart target mismatch").await;
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: "master did not accept the exact prepared local-reserve Get target".to_string(),
+        }));
+    }
+    for (item, requested_target) in response.items.iter().zip(prepared_targets.iter()) {
+        if item.error_code == OK {
+            claim_guard.disarm_accepted(
+                requested_target
+                    .as_ref()
+                    .expect("external prepared target vector must be dense"),
+            );
         }
-        let no_space_after = collect_get_target_no_space_indices(&response.items).len();
-        tracing::info!(
-            "external_batch_get_start retried local Get-target NoSpace after reserve shrink: attempt={} no_space_before={} no_space_after={}",
-            attempt,
-            no_space_before,
-            no_space_after
-        );
     }
     Ok(response)
 }
 
+#[cfg(test)]
+mod external_put_pending_tests {
+    use super::{ExternalPutStartFenceClaim, require_external_pending_put_ctx_value};
+    use crate::client_kv_api::{
+        ExternalPendingPutFenceGuard, OwnerKeyControlTable,
+        acquire_external_pending_put_fence_for_key,
+    };
+    use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError};
+    use parking_lot::Mutex;
+    use std::sync::Arc;
+
+    #[test]
+    fn missing_or_expired_pending_context_is_not_a_commit_capability() {
+        let result = require_external_pending_put_ctx_value(
+            None,
+            "external_put_commit",
+            "missing-key",
+            (17, 3),
+        );
+        let Err(KvError::Api(ApiError::InvalidArgument { detail })) = result else {
+            panic!("missing pending context must be rejected")
+        };
+        assert!(detail.contains("requires a live owner pending Put context"));
+        assert!(detail.contains("put_id=(17,3)"));
+    }
+
+    #[test]
+    fn cancelled_put_start_hands_fence_to_uncertainty_quarantine() {
+        let controls = Arc::new(OwnerKeyControlTable::default());
+        let fence = acquire_external_pending_put_fence_for_key(&controls, "cancelled-start")
+            .expect("pending fence acquisition must succeed");
+        let sink: Arc<Mutex<Option<Arc<ExternalPendingPutFenceGuard>>>> =
+            Arc::new(Mutex::new(None));
+
+        let claim = ExternalPutStartFenceClaim::new_for_cancellation_test(fence, sink.clone());
+        drop(claim);
+        assert_eq!(
+            controls.lock_key("cancelled-start")["cancelled-start"].external_pending_puts,
+            1,
+            "cancellation must transfer, not drop, the reclaim fence"
+        );
+
+        drop(sink.lock().take());
+        assert!(
+            controls
+                .lock_key("cancelled-start")
+                .get("cancelled-start")
+                .is_none()
+        );
+    }
+}
+
 #[cfg(test)]
 mod external_get_start_batch_tests {
     use super::{
-        collect_external_get_start_missing, collect_get_target_no_space_indices,
-        compute_external_get_start_raw_prefix, compute_external_get_start_transfer_prefix,
-        normalize_external_put_start_group_lens,
+        abandon_unstarted_external_get_key_locked,
+        cleanup_external_get_start_handles_for_generation, clear_external_get_key_marker_locked,
+        collect_external_get_start_missing, compute_external_get_start_raw_prefix,
+        compute_external_get_start_transfer_prefix, decide_external_get_key_item,
+        external_member_left_departed_epoch, normalize_external_put_start_group_lens,
+        partition_external_get_finish_leaders, register_external_get_key_under_fence,
+    };
+    use crate::client_kv_api::{
+        ExternalGetKeySharedOp, ExternalGetStartEntry, ExternalGetStartOwnerItem,
+        OwnerKeyControlState,
+    };
+    use crate::master_kv_router::msg_pack::{
+        BatchGetStartItemResp, PutAtomicGroup, PutAtomicGroupMember,
     };
-    use crate::master_kv_router::msg_pack::BatchGetStartItemResp;
     use crate::rpcresp_kvresult_convert::msg_and_error::{OK, codes_api};
+    use dashmap::DashMap;
+    use std::collections::HashMap;
+    use std::sync::Arc;
+    use std::time::Instant;
+
+    fn abandoned_handle_entry(
+        req_node_id: &str,
+        requester_node_start_time: Option<i64>,
+    ) -> ExternalGetStartEntry {
+        ExternalGetStartEntry {
+            req_node_id: req_node_id.to_string(),
+            requester_node_start_time,
+            keys: Vec::new(),
+            items: Vec::new(),
+            created_at: Instant::now(),
+        }
+    }
+
+    #[test]
+    fn member_left_requires_previous_epoch_and_skips_delayed_leave_after_reconnect() {
+        assert_eq!(
+            external_member_left_departed_epoch(Some(11), None),
+            Some(11)
+        );
+        assert_eq!(external_member_left_departed_epoch(None, None), None);
+        assert_eq!(
+            external_member_left_departed_epoch(Some(11), Some(12)),
+            None
+        );
+        assert_eq!(external_member_left_departed_epoch(None, Some(12)), None);
+    }
+
+    #[test]
+    fn member_left_removes_only_matching_requester_handle_generation() {
+        let registry = DashMap::new();
+        registry.insert(1, abandoned_handle_entry("external-a", Some(11)));
+        registry.insert(2, abandoned_handle_entry("external-a", Some(12)));
+        registry.insert(3, abandoned_handle_entry("external-b", Some(11)));
+        registry.insert(4, abandoned_handle_entry("external-a", None));
+
+        assert_eq!(
+            cleanup_external_get_start_handles_for_generation(&registry, "external-a", 11),
+            1
+        );
+        assert!(!registry.contains_key(&1));
+        assert!(registry.contains_key(&2));
+        assert!(registry.contains_key(&3));
+        assert!(registry.contains_key(&4));
+    }
 
     #[test]
     fn all_local_batch_has_no_master_fallback_and_keeps_full_atomic_prefix() {
@@ -553,277 +994,1057 @@ mod external_get_start_batch_tests {
     }
 
     #[test]
-    fn get_target_pressure_retry_selects_only_no_space_items() {
-        let mut items = vec![BatchGetStartItemResp::default(); 4];
-        items[0].error_code = OK;
-        items[1].error_code = codes_api::API_NO_SPACE;
-        items[2].error_code = codes_api::API_KEY_NOT_FOUND;
-        items[3].error_code = codes_api::API_NO_SPACE;
-        assert_eq!(collect_get_target_no_space_indices(&items), vec![1, 3]);
-    }
-}
-
-async fn finish_external_get_start_transfer(
-    view: crate::client_kv_api::ClientKvApiView,
+    fn overlapping_nonidentical_batches_share_each_key_but_keep_leaders_batched() {
+        fn register_batch(
+            controls: &mut HashMap<String, OwnerKeyControlState>,
+            keys: &[&str],
+        ) -> (
+            Vec<ExternalGetStartOwnerItem>,
+            Vec<Arc<ExternalGetKeySharedOp>>,
+        ) {
+            let mut leaders = Vec::new();
+            let items = keys
+                .iter()
+                .map(|key| {
+                    let control = controls.entry((*key).to_string()).or_default();
+                    let interest =
+                        register_external_get_key_under_fence(control, key, &mut leaders);
+                    ExternalGetStartOwnerItem::Shared { interest }
+                })
+                .collect();
+            (items, leaders)
+        }
+
+        let mut controls = HashMap::new();
+        let (mut batch_a, leaders_a) =
+            register_batch(&mut controls, &["a", "shared-b", "shared-c"]);
+        let (mut batch_b, leaders_b) =
+            register_batch(&mut controls, &["shared-b", "shared-c", "d"]);
+
+        assert_eq!(
+            leaders_a.len(),
+            3,
+            "first required batch has one leader subset"
+        );
+        assert_eq!(
+            leaders_b.len(),
+            1,
+            "second batch starts only its new leader d"
+        );
+        let shared_b_a = match &batch_a[1] {
+            ExternalGetStartOwnerItem::Shared { interest } => interest.op().clone(),
+            ExternalGetStartOwnerItem::Local { .. } => unreachable!(),
+        };
+        let shared_b_b = match &batch_b[0] {
+            ExternalGetStartOwnerItem::Shared { interest } => interest.op().clone(),
+            ExternalGetStartOwnerItem::Local { .. } => unreachable!(),
+        };
+        assert!(Arc::ptr_eq(&shared_b_a, &shared_b_b));
+
+        // Batch A keeps only [a,b], while batch B keeps [b,c,d].  Prefix
+        // decisions are independent, yet each physical key operation is still
+        // represented by one shared marker.
+        for (idx, item) in batch_a.iter_mut().enumerate() {
+            decide_external_get_key_item(item, idx < 2);
+        }
+        for item in &mut batch_b {
+            decide_external_get_key_item(item, true);
+        }
+        let state_b = shared_b_a.state.lock();
+        assert_eq!(state_b.undecided, 0);
+        assert_eq!(state_b.retained, 2);
+        drop(state_b);
+        let shared_c = controls["shared-c"]
+            .external_get
+            .as_ref()
+            .expect("shared-c marker")
+            .state
+            .lock();
+        assert_eq!(shared_c.undecided, 0);
+        assert_eq!(shared_c.retained, 1);
+    }
+
+    #[test]
+    fn dropped_pending_interest_retires_decision_without_losing_batch_sharing() {
+        let key = "cancel-safe-key".to_string();
+        let mut controls = HashMap::new();
+        let mut first_leaders = Vec::new();
+        let mut second_leaders = Vec::new();
+        let first = register_external_get_key_under_fence(
+            controls.entry(key.clone()).or_default(),
+            &key,
+            &mut first_leaders,
+        );
+        let mut second = register_external_get_key_under_fence(
+            controls.entry(key.clone()).or_default(),
+            &key,
+            &mut second_leaders,
+        );
+        assert_eq!(first_leaders.len(), 1);
+        assert!(second_leaders.is_empty());
+        assert!(Arc::ptr_eq(first.op(), second.op()));
+        assert_eq!(first.op().state.lock().undecided, 2);
+
+        drop(first);
+        assert_eq!(second.op().state.lock().undecided, 1);
+        second.decide(true);
+        let state = second.op().state.lock();
+        assert_eq!(state.undecided, 0);
+        assert_eq!(state.retained, 1);
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn aborting_waiter_future_retires_pending_interest_and_wakes_flight() {
+        let op = Arc::new(ExternalGetKeySharedOp::new("abort-safe-key".to_string()));
+        let waiter_op = op.clone();
+        let (registered_tx, registered_rx) = ::tokio::sync::oneshot::channel();
+        let waiter = ::tokio::spawn(async move {
+            let _interest = crate::client_kv_api::ExternalGetKeyInterest::new(waiter_op, true);
+            let _ = registered_tx.send(());
+            futures::future::pending::<()>().await;
+        });
+
+        registered_rx.await.expect("waiter registered interest");
+        assert_eq!(op.state.lock().undecided, 1);
+        let notified = op.notify.notified();
+        futures::pin_mut!(notified);
+        notified.as_mut().enable();
+
+        waiter.abort();
+        assert!(
+            waiter
+                .await
+                .expect_err("waiter must be aborted")
+                .is_cancelled()
+        );
+        assert_eq!(op.state.lock().undecided, 0);
+        ::tokio::time::timeout(std::time::Duration::from_secs(1), notified)
+            .await
+            .expect("interest Drop must wake the flight");
+    }
+
+    #[test]
+    fn old_singleflight_cleanup_cannot_remove_new_generation() {
+        let key = "aba-key".to_string();
+        let old = Arc::new(ExternalGetKeySharedOp::new(key.clone()));
+        let mut controls = HashMap::from([(
+            key.clone(),
+            OwnerKeyControlState {
+                local_puts: 0,
+                external_pending_puts: 0,
+                reclaim: None,
+                external_get: Some(old.clone()),
+            },
+        )]);
+        clear_external_get_key_marker_locked(&mut controls, &old);
+        assert!(!controls.contains_key(&key));
+
+        let new = Arc::new(ExternalGetKeySharedOp::new(key.clone()));
+        controls.entry(key.clone()).or_default().external_get = Some(new.clone());
+        clear_external_get_key_marker_locked(&mut controls, &old);
+        assert!(
+            controls[&key]
+                .external_get
+                .as_ref()
+                .is_some_and(|current| Arc::ptr_eq(current, &new))
+        );
+    }
+
+    #[test]
+    fn cancelled_planning_leader_becomes_miss_and_clears_only_its_generation() {
+        let key = "planning-cancel-key".to_string();
+        let op = Arc::new(ExternalGetKeySharedOp::new(key.clone()));
+        let mut controls = HashMap::from([(
+            key.clone(),
+            OwnerKeyControlState {
+                local_puts: 0,
+                external_pending_puts: 0,
+                reclaim: None,
+                external_get: Some(op.clone()),
+            },
+        )]);
+
+        assert!(abandon_unstarted_external_get_key_locked(
+            &mut controls,
+            &op
+        ));
+        assert!(!controls.contains_key(&key));
+        assert!(matches!(
+            &op.state.lock().phase,
+            crate::client_kv_api::ExternalGetKeySharedPhase::Ready {
+                result: crate::client_kv_api::ExternalGetStartSharedItemResult::Miss
+            }
+        ));
+        assert!(!abandon_unstarted_external_get_key_locked(
+            &mut controls,
+            &op
+        ));
+    }
+
+    #[test]
+    fn done_partition_keeps_atomic_groups_intact_and_bounds_other_batches() {
+        let group = PutAtomicGroup {
+            members: (0..3)
+                .map(|idx| PutAtomicGroupMember {
+                    key: format!("group-{idx}"),
+                    put_id: (7, idx),
+                })
+                .collect(),
+        };
+        let leader = |key: &str, atomic_group: Option<PutAtomicGroup>| {
+            (
+                Arc::new(ExternalGetKeySharedOp::new(key.to_string())),
+                BatchGetStartItemResp {
+                    atomic_group,
+                    ..Default::default()
+                },
+            )
+        };
+        let batches = partition_external_get_finish_leaders(
+            vec![
+                leader("single-a", None),
+                leader("group-0", Some(group.clone())),
+                leader("single-b", None),
+                leader("group-1", Some(group.clone())),
+                leader("group-2", Some(group.clone())),
+                leader("single-c", None),
+            ],
+            2,
+        );
+
+        let group_batch_count = batches
+            .iter()
+            .filter(|batch| batch.iter().any(|(op, _)| op.key.starts_with("group-")))
+            .count();
+        assert_eq!(group_batch_count, 1, "one atomic group must not be split");
+        let group_batch = batches
+            .iter()
+            .find(|batch| batch.iter().any(|(op, _)| op.key == "group-0"))
+            .unwrap();
+        assert_eq!(
+            group_batch
+                .iter()
+                .filter(|(op, _)| op.key.starts_with("group-"))
+                .count(),
+            3
+        );
+        assert!(batches.iter().all(|batch| {
+            batch.len() <= 2
+                || batch
+                    .iter()
+                    .all(|(_, item)| item.atomic_group.as_ref() == Some(&group))
+        }));
+    }
+}
+
+async fn finish_external_get_start_transfer(
+    view: crate::client_kv_api::ClientKvApiView,
     transfer_items: Vec<ExternalGetStartOwnerItem>,
-    transfer_concurrency: usize,
+    _transfer_concurrency: usize,
 ) -> KvResult<ExternalGetStartTransferOutput> {
     let client_api = view.client_kv_api();
     let inner = client_api.inner();
     let refcount = inner.get_or_init_all_memholder_refcount();
-    let mut results: Vec<
-        Option<KvResult<Option<(Arc<UserMemHolder>, Option<client_kv_api::RemoteGetInfo>)>>>,
-    > = (0..transfer_items.len()).map(|_| None).collect();
-    let mut started_positions = Vec::new();
-    let mut started_keys = Vec::new();
-    let mut started_items = Vec::new();
-
-    for (idx, item) in transfer_items.into_iter().enumerate() {
-        match item {
-            ExternalGetStartOwnerItem::Local { memory_info } => {
-                let holder = Arc::new(UserMemHolder::new(
-                    memory_info,
-                    refcount.clone(),
-                    UserMemHolderExposeKind::SegPtr,
-                ));
-                results[idx] = Some(Ok(Some((holder, None))));
+    let waits = transfer_items.into_iter().map(|item| {
+        let refcount = refcount.clone();
+        async move {
+            match item {
+                ExternalGetStartOwnerItem::Local { memory_info } => Ok(Some((
+                    Arc::new(UserMemHolder::new(
+                        memory_info,
+                        refcount,
+                        UserMemHolderExposeKind::SegPtr,
+                    )),
+                    None,
+                ))),
+                ExternalGetStartOwnerItem::Shared { interest } => {
+                    match wait_external_get_key_result(interest.op().clone()).await? {
+                        ExternalGetStartSharedItemResult::Hit { memholder } => {
+                            Ok(Some((memholder, None)))
+                        }
+                        ExternalGetStartSharedItemResult::Miss => Ok(None),
+                        ExternalGetStartSharedItemResult::Error {
+                            error_code,
+                            error_json,
+                        } => Err(KvError::from_json(error_code, &error_json)),
+                    }
+                }
+            }
+        }
+    });
+    Ok(futures::future::join_all(waits).await)
+}
+
+fn external_get_start_error_parts(err: &KvError) -> (u32, String) {
+    (err.code(), err.to_json())
+}
+
+async fn wait_external_get_key_not_revoking(op: Arc<ExternalGetKeySharedOp>) {
+    loop {
+        let notified = op.notify.notified();
+        futures::pin_mut!(notified);
+        let should_wait = {
+            let state = op.state.lock();
+            if matches!(state.phase, ExternalGetKeySharedPhase::Revoking { .. }) {
+                notified.as_mut().enable();
+                true
+            } else {
+                false
+            }
+        };
+        if !should_wait {
+            return;
+        }
+        notified.await;
+    }
+}
+
+fn register_external_get_key_under_fence(
+    control: &mut client_kv_api::OwnerKeyControlState,
+    key: &str,
+    leaders: &mut Vec<Arc<ExternalGetKeySharedOp>>,
+) -> ExternalGetKeyInterest {
+    if let Some(op) = control.external_get.clone() {
+        let mut state = op.state.lock();
+        let decision_registered = match state.phase {
+            ExternalGetKeySharedPhase::Starting | ExternalGetKeySharedPhase::Started { .. } => {
+                state.undecided = state
+                    .undecided
+                    .checked_add(1)
+                    .expect("external Get singleflight undecided overflow");
+                true
             }
-            ExternalGetStartOwnerItem::Started { key, item } => {
-                started_positions.push(idx);
-                started_keys.push(key);
-                started_items.push(item);
+            ExternalGetKeySharedPhase::Finishing { .. }
+            | ExternalGetKeySharedPhase::Ready { .. }
+            | ExternalGetKeySharedPhase::Failed { .. } => false,
+            ExternalGetKeySharedPhase::Revoking { .. } => {
+                unreachable!("revoking markers were checked under the same fence")
             }
+        };
+        drop(state);
+        ExternalGetKeyInterest::new(op, decision_registered)
+    } else {
+        let op = Arc::new(ExternalGetKeySharedOp::new(key.to_string()));
+        control.external_get = Some(op.clone());
+        leaders.push(op.clone());
+        ExternalGetKeyInterest::new(op, true)
+    }
+}
+
+/// Owns newly installed `Starting` markers until the complete request batch is
+/// ready to hand them to one BatchGetStart worker.  If planning is cancelled
+/// while waiting for an older Revoke on another key, Drop converts only these
+/// never-started operations to a safe miss and removes their markers.  No
+/// prepared target or master identity exists yet, so there is nothing to
+/// revoke and no storage state to guess.
+struct ExternalGetPlanningLeadersGuard<'a> {
+    inner: &'a client_kv_api::ClientKvApiInner,
+    leaders: Vec<Arc<ExternalGetKeySharedOp>>,
+    handed_off: bool,
+}
+
+impl<'a> ExternalGetPlanningLeadersGuard<'a> {
+    fn new(inner: &'a client_kv_api::ClientKvApiInner) -> Self {
+        Self {
+            inner,
+            leaders: Vec::new(),
+            handed_off: false,
         }
     }
 
-    if !started_items.is_empty() {
-        let started_results = inner
-            .batch_get_finish_started(started_keys, started_items, transfer_concurrency)
-            .await?;
-        if started_results.len() != started_positions.len() {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "external get_start transfer result length mismatch: expected={} got={}",
-                    started_positions.len(),
-                    started_results.len()
-                ),
-            }));
+    fn leaders_mut(&mut self) -> &mut Vec<Arc<ExternalGetKeySharedOp>> {
+        &mut self.leaders
+    }
+
+    fn handoff(mut self) -> Vec<Arc<ExternalGetKeySharedOp>> {
+        self.handed_off = true;
+        std::mem::take(&mut self.leaders)
+    }
+}
+
+impl Drop for ExternalGetPlanningLeadersGuard<'_> {
+    fn drop(&mut self) {
+        if self.handed_off {
+            return;
         }
-        for (idx, result) in started_positions
-            .into_iter()
-            .zip(started_results.into_iter())
-        {
-            results[idx] = Some(result);
+        for op in &self.leaders {
+            let notify = {
+                let mut controls = self.inner.owner_key_control.lock_key(&op.key);
+                abandon_unstarted_external_get_key_locked(&mut controls, op)
+            };
+            if notify {
+                self.inner.untrack_external_get_flight(op);
+                op.notify.notify_waiters();
+            }
         }
     }
+}
 
-    Ok(results
-        .into_iter()
-        .map(|item| {
-            item.unwrap_or_else(|| {
-                Err(KvError::Api(ApiError::Unknown {
-                    detail: "external get_start transfer result slot was not populated".to_string(),
-                }))
-            })
-        })
-        .collect())
+async fn plan_external_get_key_items(
+    inner: &client_kv_api::ClientKvApiInner,
+    keys: &[String],
+) -> (
+    Vec<ExternalGetStartOwnerItem>,
+    Vec<Arc<ExternalGetKeySharedOp>>,
+) {
+    enum KeyAttempt {
+        Wait(Arc<ExternalGetKeySharedOp>),
+        Ready {
+            item: ExternalGetStartOwnerItem,
+            hot_touch: Option<(
+                crate::master_kv_router::put::PutIDForAKey,
+                Arc<crate::memholder::MemoryInfo>,
+            )>,
+        },
+    }
+
+    let mut items = Vec::with_capacity(keys.len());
+    let mut planning_leaders = ExternalGetPlanningLeadersGuard::new(inner);
+    let mut hot_touches = Vec::new();
+    for key in keys {
+        loop {
+            // One short per-key shard section atomically chooses local,
+            // joiner, or leader.  No synchronous lock spans the request batch
+            // or the wait for an older Revoke to finish.
+            let attempt = {
+                let mut controls = inner.owner_key_control.lock_key(key);
+                let revoking = controls
+                    .get(key)
+                    .and_then(|state| state.external_get.clone())
+                    .filter(|op| {
+                        matches!(
+                            op.state.lock().phase,
+                            ExternalGetKeySharedPhase::Revoking { .. }
+                        )
+                    });
+                if let Some(op) = revoking {
+                    KeyAttempt::Wait(op)
+                } else {
+                    let fenced = controls
+                        .get(key)
+                        .is_some_and(|state| state.reclaim.is_some());
+                    if !fenced {
+                        if let Some(memory_info) = inner.local_visible_mem_holder_unfenced(key) {
+                            let hot_touch = inner.get_cached_info.get(key).and_then(|cached| {
+                                Arc::ptr_eq(&cached.mem_holder, &memory_info).then_some((
+                                    (cached.put_time_ms, cached.put_version),
+                                    memory_info.clone(),
+                                ))
+                            });
+                            KeyAttempt::Ready {
+                                item: ExternalGetStartOwnerItem::Local { memory_info },
+                                hot_touch,
+                            }
+                        } else {
+                            let control = controls.entry(key.clone()).or_default();
+                            let leader_count = planning_leaders.leaders.len();
+                            let interest = register_external_get_key_under_fence(
+                                control,
+                                key,
+                                planning_leaders.leaders_mut(),
+                            );
+                            if planning_leaders.leaders.len() != leader_count {
+                                inner.track_external_get_flight(interest.op());
+                            }
+                            KeyAttempt::Ready {
+                                item: ExternalGetStartOwnerItem::Shared { interest },
+                                hot_touch: None,
+                            }
+                        }
+                    } else {
+                        let control = controls.entry(key.clone()).or_default();
+                        let leader_count = planning_leaders.leaders.len();
+                        let interest = register_external_get_key_under_fence(
+                            control,
+                            key,
+                            planning_leaders.leaders_mut(),
+                        );
+                        if planning_leaders.leaders.len() != leader_count {
+                            inner.track_external_get_flight(interest.op());
+                        }
+                        KeyAttempt::Ready {
+                            item: ExternalGetStartOwnerItem::Shared { interest },
+                            hot_touch: None,
+                        }
+                    }
+                }
+            };
+
+            match attempt {
+                KeyAttempt::Wait(op) => wait_external_get_key_not_revoking(op).await,
+                KeyAttempt::Ready { item, hot_touch } => {
+                    if let Some((put_id, memory_info)) = hot_touch {
+                        hot_touches.push((key.clone(), put_id, memory_info));
+                    }
+                    items.push(item);
+                    break;
+                }
+            }
+        }
+    }
+
+    for (key, put_id, memory_info) in hot_touches {
+        inner.owner_hot_touch_or_promote(&key, put_id, &memory_info);
+    }
+    (items, planning_leaders.handoff())
 }
 
-fn external_get_start_error_parts(err: &KvError) -> (u32, String) {
-    (err.code(), err.to_json())
+fn clear_external_get_key_marker_locked(
+    controls: &mut std::collections::HashMap<String, client_kv_api::OwnerKeyControlState>,
+    op: &Arc<ExternalGetKeySharedOp>,
+) {
+    let remove_control = if let Some(control) = controls.get_mut(&op.key) {
+        if control
+            .external_get
+            .as_ref()
+            .is_some_and(|current| Arc::ptr_eq(current, op))
+        {
+            control.external_get = None;
+        }
+        control.is_idle()
+    } else {
+        false
+    };
+    if remove_control {
+        controls.remove(&op.key);
+    }
 }
 
-fn register_external_get_start_waiter(shared_op: &Arc<ExternalGetStartSharedOp>) {
-    let mut state = shared_op.state.lock();
-    state.waiter_count = state
-        .waiter_count
-        .checked_add(1)
-        .expect("external get_start shared waiter count overflow");
+fn abandon_unstarted_external_get_key_locked(
+    controls: &mut std::collections::HashMap<String, client_kv_api::OwnerKeyControlState>,
+    op: &Arc<ExternalGetKeySharedOp>,
+) -> bool {
+    let mut state = op.state.lock();
+    if !matches!(state.phase, ExternalGetKeySharedPhase::Starting) {
+        return false;
+    }
+    state.phase = ExternalGetKeySharedPhase::Ready {
+        result: ExternalGetStartSharedItemResult::Miss,
+    };
+    clear_external_get_key_marker_locked(controls, op);
+    true
 }
 
-fn release_external_get_start_waiter(
+fn publish_external_get_key_terminal(
     inner: &client_kv_api::ClientKvApiInner,
-    shared_op: &Arc<ExternalGetStartSharedOp>,
+    op: &Arc<ExternalGetKeySharedOp>,
+    phase: ExternalGetKeySharedPhase,
 ) {
-    let should_remove = {
-        let mut state = shared_op.state.lock();
-        assert!(
-            state.waiter_count > 0,
-            "external get_start shared waiter count underflow"
-        );
-        state.waiter_count -= 1;
-        state.waiter_count == 0
-    };
-    if should_remove {
-        inner
-            .external_get_start_by_key
-            .remove_if(&shared_op.dedup_key, |_, op| {
-                if !Arc::ptr_eq(op, shared_op) {
-                    return false;
-                }
-                op.state.lock().waiter_count == 0
-            });
+    {
+        let mut controls = inner.owner_key_control.lock_key(&op.key);
+        op.state.lock().phase = phase;
+        clear_external_get_key_marker_locked(&mut controls, op);
     }
+    inner.untrack_external_get_flight(op);
+    op.notify.notify_waiters();
 }
 
-fn publish_external_get_start_failed(shared_op: &Arc<ExternalGetStartSharedOp>, err: &KvError) {
+fn publish_external_get_key_failed(
+    inner: &client_kv_api::ClientKvApiInner,
+    op: &Arc<ExternalGetKeySharedOp>,
+    err: &KvError,
+) {
     let (error_code, error_json) = external_get_start_error_parts(err);
+    publish_external_get_key_terminal(
+        inner,
+        op,
+        ExternalGetKeySharedPhase::Failed {
+            error_code,
+            error_json,
+        },
+    );
+}
+
+fn publish_external_get_key_started(
+    op: &Arc<ExternalGetKeySharedOp>,
+    item: crate::master_kv_router::msg_pack::BatchGetStartItemResp,
+) {
     {
-        let mut state = shared_op.state.lock();
-        state.phase = ExternalGetStartSharedPhase::Failed {
+        let mut state = op.state.lock();
+        assert!(matches!(state.phase, ExternalGetKeySharedPhase::Starting));
+        state.phase = ExternalGetKeySharedPhase::Started { item };
+    }
+    op.notify.notify_waiters();
+}
+
+fn external_get_key_ready_from_code(
+    error_code: u32,
+    error_json: String,
+) -> ExternalGetStartSharedItemResult {
+    if error_code == codes_api::API_KEY_NOT_FOUND {
+        ExternalGetStartSharedItemResult::Miss
+    } else {
+        ExternalGetStartSharedItemResult::Error {
             error_code,
             error_json,
+        }
+    }
+}
+
+async fn wait_external_get_key_start_code(
+    op: Arc<ExternalGetKeySharedOp>,
+) -> KvResult<(u32, String)> {
+    loop {
+        let notified = op.notify.notified();
+        futures::pin_mut!(notified);
+        let should_wait = {
+            let state = op.state.lock();
+            match &state.phase {
+                ExternalGetKeySharedPhase::Starting => {
+                    notified.as_mut().enable();
+                    true
+                }
+                ExternalGetKeySharedPhase::Started { item }
+                | ExternalGetKeySharedPhase::Finishing { item } => {
+                    return Ok((item.error_code, item.error_json.clone()));
+                }
+                ExternalGetKeySharedPhase::Ready { result } => {
+                    return Ok(match result {
+                        ExternalGetStartSharedItemResult::Hit { .. } => (OK, String::new()),
+                        ExternalGetStartSharedItemResult::Miss => {
+                            (codes_api::API_KEY_NOT_FOUND, String::new())
+                        }
+                        ExternalGetStartSharedItemResult::Error {
+                            error_code,
+                            error_json,
+                        } => (*error_code, error_json.clone()),
+                    });
+                }
+                ExternalGetKeySharedPhase::Failed {
+                    error_code,
+                    error_json,
+                } => return Err(KvError::from_json(*error_code, error_json)),
+                ExternalGetKeySharedPhase::Revoking { .. } => {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "external Get key entered revoke before prefix decision: key={}",
+                            op.key
+                        ),
+                    }));
+                }
+            }
         };
+        if should_wait {
+            notified.await;
+        }
     }
-    shared_op.notify.notify_waiters();
 }
 
-fn publish_external_get_start_ready(
-    shared_op: &Arc<ExternalGetStartSharedOp>,
-    keys: Vec<String>,
-    transfer_result: KvResult<ExternalGetStartTransferOutput>,
-) {
-    let phase = match transfer_result {
-        Ok(transfer_results) => {
-            if transfer_results.len() != keys.len() {
-                let err = KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "external shared get_start transfer result length mismatch: expected={} got={}",
-                        keys.len(),
-                        transfer_results.len()
-                    ),
-                });
-                let (error_code, error_json) = external_get_start_error_parts(&err);
-                ExternalGetStartSharedPhase::Failed {
+async fn wait_external_get_key_result(
+    op: Arc<ExternalGetKeySharedOp>,
+) -> KvResult<ExternalGetStartSharedItemResult> {
+    loop {
+        let notified = op.notify.notified();
+        futures::pin_mut!(notified);
+        let should_wait = {
+            let state = op.state.lock();
+            match &state.phase {
+                ExternalGetKeySharedPhase::Starting
+                | ExternalGetKeySharedPhase::Started { .. }
+                | ExternalGetKeySharedPhase::Finishing { .. } => {
+                    notified.as_mut().enable();
+                    true
+                }
+                ExternalGetKeySharedPhase::Ready { result } => return Ok(result.clone()),
+                ExternalGetKeySharedPhase::Failed {
                     error_code,
                     error_json,
+                } => return Err(KvError::from_json(*error_code, error_json)),
+                ExternalGetKeySharedPhase::Revoking { .. } => {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "retained external Get key was unexpectedly revoked: key={}",
+                            op.key
+                        ),
+                    }));
+                }
+            }
+        };
+        if should_wait {
+            notified.await;
+        }
+    }
+}
+
+fn decide_external_get_key_item(item: &mut ExternalGetStartOwnerItem, retain: bool) {
+    if let ExternalGetStartOwnerItem::Shared { interest } = item {
+        interest.decide(retain);
+    }
+}
+
+enum ExternalGetKeyLeaderAction {
+    Finish {
+        op: Arc<ExternalGetKeySharedOp>,
+        item: crate::master_kv_router::msg_pack::BatchGetStartItemResp,
+    },
+    Revoke {
+        op: Arc<ExternalGetKeySharedOp>,
+        item: crate::master_kv_router::msg_pack::BatchGetStartItemResp,
+    },
+    Terminal,
+}
+
+type ExternalGetFinishLeader = (Arc<ExternalGetKeySharedOp>, BatchGetStartItemResp);
+
+struct ExternalGetFinishUnit {
+    group: Option<PutAtomicGroup>,
+    leaders: Vec<ExternalGetFinishLeader>,
+}
+
+/// Partition leaders into independent Done failure domains while preserving
+/// caller-declared atomic groups. The target is deliberately soft: one large
+/// atomic group stays intact instead of being split across terminal RPCs.
+fn partition_external_get_finish_leaders(
+    leaders: Vec<ExternalGetFinishLeader>,
+    target_keys_per_batch: usize,
+) -> Vec<Vec<ExternalGetFinishLeader>> {
+    if leaders.is_empty() {
+        return Vec::new();
+    }
+    let target_keys_per_batch = target_keys_per_batch.max(1);
+    let mut units: Vec<ExternalGetFinishUnit> = Vec::new();
+    let mut group_unit_by_anchor = HashMap::<(String, u64, u32), usize>::new();
+
+    for leader in leaders {
+        let group = leader.1.atomic_group.as_ref();
+        let Some(group) = group else {
+            units.push(ExternalGetFinishUnit {
+                group: None,
+                leaders: vec![leader],
+            });
+            continue;
+        };
+        let Some(anchor) = group.members.first() else {
+            // Master validation rejects empty groups. Treat malformed legacy
+            // metadata as a singleton here so partitioning cannot lose work.
+            units.push(ExternalGetFinishUnit {
+                group: None,
+                leaders: vec![leader],
+            });
+            continue;
+        };
+        let signature = (anchor.key.clone(), anchor.put_id.0, anchor.put_id.1);
+        if let Some(unit_idx) = group_unit_by_anchor.get(&signature).copied()
+            && units[unit_idx].group.as_ref() == Some(group)
+        {
+            units[unit_idx].leaders.push(leader);
+            continue;
+        }
+        let unit_idx = units.len();
+        units.push(ExternalGetFinishUnit {
+            group: Some(group.clone()),
+            leaders: vec![leader],
+        });
+        group_unit_by_anchor.insert(signature, unit_idx);
+    }
+
+    let mut batches = Vec::new();
+    let mut current = Vec::new();
+    for mut unit in units {
+        if !current.is_empty()
+            && current.len().saturating_add(unit.leaders.len()) > target_keys_per_batch
+        {
+            batches.push(std::mem::take(&mut current));
+        }
+        current.append(&mut unit.leaders);
+        if current.len() >= target_keys_per_batch {
+            batches.push(std::mem::take(&mut current));
+        }
+    }
+    if !current.is_empty() {
+        batches.push(current);
+    }
+    batches
+}
+
+async fn classify_external_get_key_leader(
+    inner: &client_kv_api::ClientKvApiInner,
+    op: Arc<ExternalGetKeySharedOp>,
+) -> ExternalGetKeyLeaderAction {
+    loop {
+        let notified = op.notify.notified();
+        futures::pin_mut!(notified);
+        let wait_for_decisions = {
+            let state = op.state.lock();
+            if matches!(
+                state.phase,
+                ExternalGetKeySharedPhase::Starting | ExternalGetKeySharedPhase::Started { .. }
+            ) && state.undecided != 0
+            {
+                notified.as_mut().enable();
+                true
+            } else {
+                false
+            }
+        };
+        if wait_for_decisions {
+            notified.await;
+            continue;
+        }
+
+        let mut notify_terminal = false;
+        let action = {
+            // Planner lock order is owner fence -> per-key op.  Use the same
+            // order here so no request can join after undecided reaches zero
+            // but before the leader closes admission.
+            let mut controls = inner.owner_key_control.lock_key(&op.key);
+            let mut state = op.state.lock();
+            match &state.phase {
+                ExternalGetKeySharedPhase::Started { item } if state.undecided == 0 => {
+                    let item = item.clone();
+                    if item.error_code != OK {
+                        state.phase = ExternalGetKeySharedPhase::Ready {
+                            result: external_get_key_ready_from_code(
+                                item.error_code,
+                                item.error_json,
+                            ),
+                        };
+                        clear_external_get_key_marker_locked(&mut controls, &op);
+                        notify_terminal = true;
+                        Some(ExternalGetKeyLeaderAction::Terminal)
+                    } else if state.retained == 0 {
+                        state.phase = ExternalGetKeySharedPhase::Revoking { item: item.clone() };
+                        Some(ExternalGetKeyLeaderAction::Revoke {
+                            op: op.clone(),
+                            item,
+                        })
+                    } else {
+                        state.phase = ExternalGetKeySharedPhase::Finishing { item: item.clone() };
+                        Some(ExternalGetKeyLeaderAction::Finish {
+                            op: op.clone(),
+                            item,
+                        })
+                    }
+                }
+                ExternalGetKeySharedPhase::Starting | ExternalGetKeySharedPhase::Started { .. } => {
+                    None
+                }
+                ExternalGetKeySharedPhase::Finishing { .. }
+                | ExternalGetKeySharedPhase::Revoking { .. }
+                | ExternalGetKeySharedPhase::Ready { .. }
+                | ExternalGetKeySharedPhase::Failed { .. } => {
+                    Some(ExternalGetKeyLeaderAction::Terminal)
+                }
+            }
+        };
+        if notify_terminal {
+            inner.untrack_external_get_flight(&op);
+            op.notify.notify_waiters();
+        }
+        if let Some(action) = action {
+            return action;
+        }
+        tokio::task::yield_now().await;
+    }
+}
+
+async fn finish_external_get_key_leaders(
+    view: crate::client_kv_api::ClientKvApiView,
+    leaders: Vec<Arc<ExternalGetKeySharedOp>>,
+    transfer_concurrency: usize,
+) {
+    let client_api = view.client_kv_api();
+    let inner = client_api.inner();
+    let mut finish = Vec::new();
+    let mut revoke = Vec::new();
+    for op in leaders {
+        match classify_external_get_key_leader(inner, op).await {
+            ExternalGetKeyLeaderAction::Finish { op, item } => finish.push((op, item)),
+            ExternalGetKeyLeaderAction::Revoke { op, item } => revoke.push((op, item)),
+            ExternalGetKeyLeaderAction::Terminal => {}
+        }
+    }
+
+    if !revoke.is_empty() {
+        let mut attempt = 1u32;
+        loop {
+            let get_ids = revoke
+                .iter()
+                .map(|(_, item)| item.get_id)
+                .collect::<Vec<_>>();
+            let response = inner.batch_get_revoke(get_ids).await;
+            let resp = match response {
+                Ok(resp)
+                    if resp.items.len() == revoke.len()
+                        && resp
+                            .items
+                            .iter()
+                            .zip(&revoke)
+                            .all(|(resp, (_, expected))| resp.get_id == expected.get_id) =>
+                {
+                    resp
+                }
+                Ok(resp) => {
+                    tracing::warn!(
+                        "BatchGetRevoke response length mismatch; retaining prepared slots and retrying: expected={} got={} attempt={}",
+                        revoke.len(),
+                        resp.items.len(),
+                        attempt
+                    );
+                    tokio::time::sleep(Duration::from_millis(
+                        (50u64.saturating_mul(1u64 << attempt.min(6))).min(2_000),
+                    ))
+                    .await;
+                    attempt = attempt.saturating_add(1);
+                    continue;
+                }
+                Err(err) => {
+                    if matches!(&err, KvError::Api(ApiError::SystemShutdown { .. })) {
+                        tracing::warn!(
+                            "BatchGetRevoke cleanup stopped during owner shutdown: items={}",
+                            revoke.len()
+                        );
+                        return;
+                    }
+                    tracing::warn!(
+                        "BatchGetRevoke uncertain; retaining operation identity and prepared slots for retry: items={} attempt={} err={}",
+                        revoke.len(),
+                        attempt,
+                        err
+                    );
+                    tokio::time::sleep(Duration::from_millis(
+                        (50u64.saturating_mul(1u64 << attempt.min(6))).min(2_000),
+                    ))
+                    .await;
+                    attempt = attempt.saturating_add(1);
+                    continue;
+                }
+            };
+
+            for ((op, item), revoke_item) in revoke.drain(..).zip(resp.items) {
+                if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                    revoke_item.error_code,
+                    revoke_item.error_json,
+                ) {
+                    // Done won the per-get terminal lock (or requester identity
+                    // is invalid).  The candidate may be committed, so never
+                    // return its slot from the losing Revoke path.
+                    publish_external_get_key_failed(inner, &op, &err);
+                    continue;
                 }
-            } else {
-                let items = keys
-                    .iter()
-                    .zip(transfer_results.into_iter())
-                    .map(|(_key, item_result)| match item_result {
-                        Ok(Some((memholder, _))) => {
-                            ExternalGetStartSharedItemResult::Hit { memholder }
-                        }
-                        Ok(None) => ExternalGetStartSharedItemResult::Miss,
-                        Err(err) => {
-                            let (error_code, error_json) = external_get_start_error_parts(&err);
-                            ExternalGetStartSharedItemResult::Error {
-                                error_code,
-                                error_json,
+                if let Some(target) = item.prepared_target.as_ref() {
+                    let mut release_attempt = 1u32;
+                    loop {
+                        match release_prepared_get_target(inner, target).await {
+                            Ok(()) => break,
+                            Err(err) => {
+                                if !inner.view.register_shutdown_poller().is_running() {
+                                    return;
+                                }
+                                tracing::error!(
+                                    "Revoke confirmed but prepared slot release failed; keeping key fenced for retry: key={} get_id={} attempt={} err={}",
+                                    op.key,
+                                    item.get_id,
+                                    release_attempt,
+                                    err
+                                );
+                                tokio::time::sleep(Duration::from_millis(1000)).await;
+                                release_attempt = release_attempt.saturating_add(1);
                             }
                         }
-                    })
-                    .collect::<Vec<_>>();
-                let prefix = match {
-                    let state = shared_op.state.lock();
-                    match &state.phase {
-                        ExternalGetStartSharedPhase::Running { prefix, .. }
-                        | ExternalGetStartSharedPhase::Ready { prefix, .. } => Ok(prefix.clone()),
-                        ExternalGetStartSharedPhase::Starting
-                        | ExternalGetStartSharedPhase::Failed { .. } => Err(KvError::Api(
-                            ApiError::Unknown {
-                                detail:
-                                    "external shared get_start transfer completed before prefix was published"
-                                        .to_string(),
-                            },
-                        )),
-                    }
-                } {
-                    Ok(prefix) => prefix,
-                    Err(err) => {
-                        let (error_code, error_json) = external_get_start_error_parts(&err);
-                        let mut state = shared_op.state.lock();
-                        state.phase = ExternalGetStartSharedPhase::Failed {
-                            error_code,
-                            error_json,
-                        };
-                        shared_op.notify.notify_waiters();
-                        return;
                     }
-                };
-                ExternalGetStartSharedPhase::Ready {
-                    prefix,
-                    keys,
-                    items,
                 }
+                publish_external_get_key_terminal(
+                    inner,
+                    &op,
+                    ExternalGetKeySharedPhase::Ready {
+                        result: ExternalGetStartSharedItemResult::Miss,
+                    },
+                );
             }
+            break;
         }
-        Err(err) => {
-            let (error_code, error_json) = external_get_start_error_parts(&err);
-            ExternalGetStartSharedPhase::Failed {
-                error_code,
-                error_json,
-            }
-        }
-    };
-    {
-        let mut state = shared_op.state.lock();
-        state.phase = phase;
     }
-    shared_op.notify.notify_waiters();
-}
 
-async fn wait_external_get_start_prefix(
-    shared_op: Arc<ExternalGetStartSharedOp>,
-) -> KvResult<ExternalGetStartPrefixResult> {
-    loop {
-        let notified = shared_op.notify.notified();
-        futures::pin_mut!(notified);
-        let should_wait = {
-            let state = shared_op.state.lock();
-            match &state.phase {
-                ExternalGetStartSharedPhase::Starting => {
-                    notified.as_mut().enable();
-                    true
-                }
-                ExternalGetStartSharedPhase::Running { prefix, .. }
-                | ExternalGetStartSharedPhase::Ready { prefix, .. } => {
-                    return Ok(prefix.clone());
-                }
-                ExternalGetStartSharedPhase::Failed {
-                    error_code,
-                    error_json,
-                } => return Err(KvError::from_json(*error_code, error_json)),
-            }
-        };
-        if should_wait {
-            notified.await;
-        }
+    if finish.is_empty() {
+        return;
     }
-}
+    let finish_batches =
+        partition_external_get_finish_leaders(finish, EXTERNAL_GET_FINISH_TARGET_KEYS_PER_BATCH);
+    let batch_concurrency = EXTERNAL_GET_FINISH_BATCH_CONCURRENCY
+        .min(finish_batches.len())
+        .max(1);
+    let per_batch_transfer_concurrency = transfer_concurrency
+        .max(1)
+        .div_ceil(batch_concurrency)
+        .max(1);
+    tracing::debug!(
+        "external Get singleflight finish partitioned: batches={} batch_concurrency={} transfer_concurrency_per_batch={}",
+        finish_batches.len(),
+        batch_concurrency,
+        per_batch_transfer_concurrency
+    );
 
-async fn wait_external_get_start_transfer(
-    shared_op: Arc<ExternalGetStartSharedOp>,
-) -> KvResult<(Vec<String>, Vec<ExternalGetStartSharedItemResult>)> {
-    loop {
-        let notified = shared_op.notify.notified();
-        futures::pin_mut!(notified);
-        let should_wait = {
-            let state = shared_op.state.lock();
-            match &state.phase {
-                ExternalGetStartSharedPhase::Starting
-                | ExternalGetStartSharedPhase::Running { .. } => {
-                    notified.as_mut().enable();
-                    true
+    let finish_futures = finish_batches.into_iter().map(|batch| {
+        let batch_view = view.clone();
+        async move {
+            let keys = batch
+                .iter()
+                .map(|(op, _)| op.key.clone())
+                .collect::<Vec<_>>();
+            let start_items = batch
+                .iter()
+                .map(|(_, item)| item.clone())
+                .collect::<Vec<_>>();
+            let result = batch_view
+                .client_kv_api()
+                .inner()
+                .batch_get_finish_started(keys, start_items, per_batch_transfer_concurrency)
+                .await;
+            (batch, result)
+        }
+    });
+    let mut finish_stream =
+        futures::stream::iter(finish_futures).buffer_unordered(batch_concurrency);
+    while let Some((batch, finish_result)) = finish_stream.next().await {
+        match finish_result {
+            Ok(results) if results.len() == batch.len() => {
+                // Publish each confirmed sub-batch immediately. A different
+                // uncertain Done cohort therefore cannot retain these flights
+                // or their pending-visible slots.
+                for ((op, _), result) in batch.into_iter().zip(results) {
+                    let phase = match result {
+                        Ok(Some((memholder, _))) => ExternalGetKeySharedPhase::Ready {
+                            result: ExternalGetStartSharedItemResult::Hit { memholder },
+                        },
+                        Ok(None) => ExternalGetKeySharedPhase::Ready {
+                            result: ExternalGetStartSharedItemResult::Miss,
+                        },
+                        Err(err) => {
+                            let (error_code, error_json) = external_get_start_error_parts(&err);
+                            ExternalGetKeySharedPhase::Ready {
+                                result: ExternalGetStartSharedItemResult::Error {
+                                    error_code,
+                                    error_json,
+                                },
+                            }
+                        }
+                    };
+                    publish_external_get_key_terminal(inner, &op, phase);
                 }
-                ExternalGetStartSharedPhase::Ready { keys, items, .. } => {
-                    return Ok((keys.clone(), items.clone()));
+            }
+            Ok(results) => {
+                let err = KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "singleflight leader finish length mismatch: expected={} got={}",
+                        batch.len(),
+                        results.len()
+                    ),
+                });
+                for (op, _) in batch {
+                    publish_external_get_key_failed(inner, &op, &err);
+                }
+            }
+            Err(err) => {
+                for (op, _) in batch {
+                    publish_external_get_key_failed(inner, &op, &err);
                 }
-                ExternalGetStartSharedPhase::Failed {
-                    error_code,
-                    error_json,
-                } => return Err(KvError::from_json(*error_code, error_json)),
             }
-        };
-        if should_wait {
-            notified.await;
         }
     }
 }
 
-async fn prepare_external_get_start_shared_op(
+async fn prepare_external_get_batch_plan(
     inner: &client_kv_api::ClientKvApiInner,
     req: &ExternalBatchGetStartReq,
     group_lens: &[usize],
@@ -832,71 +2053,53 @@ async fn prepare_external_get_start_shared_op(
     Vec<String>,
     Vec<ExternalGetStartOwnerItem>,
 )> {
-    let local_memory_infos = inner.local_visible_mem_holders(&req.keys);
-    if local_memory_infos.iter().all(Option::is_some) {
-        let key_count = req.keys.len();
-        let transfer_items = local_memory_infos
-            .into_iter()
-            .map(|memory_info| ExternalGetStartOwnerItem::Local {
-                memory_info: memory_info.expect("all local-visible entries were checked"),
-            })
-            .collect();
-        tracing::debug!(
-            key_count,
-            req_node_id = %req.req_node_id,
-            "external_batch_get_start used all-local-visible batch fast path"
-        );
-        return Ok((
-            ExternalGetStartPrefixResult {
-                raw_prefix_hit_len: key_count,
-                transferable_len: key_count,
-                first_miss_index: None,
-                first_error_kind: None,
-            },
-            req.keys.clone(),
-            transfer_items,
-        ));
+    let (mut items, leaders) = plan_external_get_key_items(inner, &req.keys).await;
+    if !leaders.is_empty() {
+        let leader_keys = leaders.iter().map(|op| op.key.clone()).collect::<Vec<_>>();
+        let spawn_view = inner.view.clone_view();
+        let worker_view = spawn_view.clone();
+        let transfer_concurrency = req.transfer_concurrency;
+        spawn_view.spawn("external_get_key_singleflight", async move {
+            let start_result = {
+                let worker_inner = worker_view.client_kv_api().inner();
+                batch_get_start_with_local_reserve_targets(worker_inner, &leader_keys).await
+            };
+            match start_result {
+                Ok(start_resp) => {
+                    assert_eq!(
+                        start_resp.items.len(),
+                        leaders.len(),
+                        "validated BatchGetStart response must match leader count"
+                    );
+                    for (op, item) in leaders.iter().zip(start_resp.items) {
+                        publish_external_get_key_started(op, item);
+                    }
+                    finish_external_get_key_leaders(worker_view, leaders, transfer_concurrency)
+                        .await;
+                }
+                Err(err) => {
+                    let worker_inner = worker_view.client_kv_api().inner();
+                    for op in &leaders {
+                        publish_external_get_key_failed(worker_inner, op, &err);
+                    }
+                }
+            }
+        });
     }
 
-    let mut item_slots: Vec<Option<ExternalGetStartOwnerItem>> = local_memory_infos
-        .into_iter()
-        .map(|memory_info| {
-            memory_info.map(|memory_info| ExternalGetStartOwnerItem::Local { memory_info })
-        })
-        .collect();
-    let (missing_indices, missing_keys) =
-        collect_external_get_start_missing(&req.keys, &item_slots);
-
-    if !missing_keys.is_empty() {
-        let start_resp = batch_get_start_with_reserve_pressure_retry(inner, &missing_keys).await?;
-        for ((idx, key), item) in missing_indices
-            .into_iter()
-            .zip(missing_keys.into_iter())
-            .zip(start_resp.items.into_iter())
-        {
-            item_slots[idx] = Some(ExternalGetStartOwnerItem::Started { key, item });
+    let mut item_codes = Vec::with_capacity(items.len());
+    for item in &items {
+        match item {
+            ExternalGetStartOwnerItem::Local { .. } => item_codes.push((OK, String::new())),
+            ExternalGetStartOwnerItem::Shared { interest } => {
+                match wait_external_get_key_start_code(interest.op().clone()).await {
+                    Ok(code) => item_codes.push(code),
+                    Err(err) => return Err(err),
+                }
+            }
         }
     }
 
-    let items = item_slots
-        .into_iter()
-        .map(|item| {
-            item.ok_or_else(|| {
-                KvError::Api(ApiError::Unknown {
-                    detail: "external_batch_get_start item slot was not populated".to_string(),
-                })
-            })
-        })
-        .collect::<KvResult<Vec<_>>>()?;
-    let item_codes = items
-        .iter()
-        .map(|item| match item {
-            ExternalGetStartOwnerItem::Local { .. } => (OK, String::new()),
-            ExternalGetStartOwnerItem::Started { item, .. } => {
-                (item.error_code, item.error_json.clone())
-            }
-        })
-        .collect::<Vec<_>>();
     let (raw_prefix_hit_len, first_miss_index, first_error_kind) =
         compute_external_get_start_raw_prefix(&item_codes);
     let transferable_len = compute_external_get_start_transfer_prefix(
@@ -914,19 +2117,8 @@ async fn prepare_external_get_start_shared_op(
             error_kind
         );
     }
-
-    let revoke_get_ids = items
-        .iter()
-        .skip(transferable_len)
-        .filter_map(|item| match item {
-            ExternalGetStartOwnerItem::Started { item, .. } if item.error_code == OK => {
-                Some(item.get_id)
-            }
-            _ => None,
-        })
-        .collect::<Vec<_>>();
-    if !revoke_get_ids.is_empty() {
-        inner.batch_get_revoke(revoke_get_ids).await?;
+    for (idx, item) in items.iter_mut().enumerate() {
+        decide_external_get_key_item(item, idx < transferable_len);
     }
 
     let transfer_keys = req.keys[..transferable_len].to_vec();
@@ -1373,115 +2565,45 @@ impl HandlerForExternalClient for ClientKvApi {
 
         let group_lens =
             normalize_external_get_start_group_lens(req.keys.len(), req.atomic_group_lens.clone())?;
-        let dedup_key = ExternalGetStartDedupKey {
-            keys: req.keys.clone(),
-            atomic_group_lens: group_lens.clone(),
-            prefix_best_effort: req.prefix_best_effort,
-        };
-        let (shared_op, is_creator) = match inner.external_get_start_by_key.entry(dedup_key.clone())
-        {
-            Entry::Occupied(entry) => {
-                let shared_op = entry.get().clone();
-                register_external_get_start_waiter(&shared_op);
-                (shared_op, false)
-            }
-            Entry::Vacant(entry) => {
-                let shared_op = Arc::new(ExternalGetStartSharedOp::new(
-                    dedup_key,
-                    req.transfer_concurrency,
-                ));
-                entry.insert(shared_op.clone());
-                (shared_op, true)
-            }
-        };
-
-        if is_creator {
-            match prepare_external_get_start_shared_op(inner, &req, &group_lens).await {
-                Ok((prefix, transfer_keys, transfer_items)) => {
-                    let inline_memory_infos = (transfer_items.len() == req.keys.len())
-                        .then(|| collect_all_local_external_get_start_infos(&transfer_items))
-                        .flatten();
-                    let inline_local = inline_memory_infos.is_some();
-                    if let Some(memory_infos) = inline_memory_infos {
-                        shared_op
-                            .inline_local_memory_infos
-                            .set(memory_infos)
-                            .unwrap_or_else(|_| {
-                                panic!("external get_start inline plan initialized twice")
-                            });
-                    }
-                    {
-                        let mut state = shared_op.state.lock();
-                        state.phase = ExternalGetStartSharedPhase::Running {
-                            prefix: prefix.clone(),
-                            keys: transfer_keys.clone(),
-                        };
-                    }
-                    shared_op.notify.notify_waiters();
-
-                    if !inline_local {
-                        let transfer_shared_op = shared_op.clone();
-                        let transfer_concurrency = shared_op.transfer_concurrency;
-                        let spawn_view = inner.view.clone_view();
-                        let transfer_view = spawn_view.clone();
-                        spawn_view.spawn("external_get_start_transfer", async move {
-                            let transfer_result = finish_external_get_start_transfer(
-                                transfer_view,
-                                transfer_items,
-                                transfer_concurrency,
-                            )
-                            .await;
-                            publish_external_get_start_ready(
-                                &transfer_shared_op,
-                                transfer_keys,
-                                transfer_result,
-                            );
-                        });
-                    }
-                }
-                Err(err) => {
-                    publish_external_get_start_failed(&shared_op, &err);
-                    release_external_get_start_waiter(inner, &shared_op);
-                    return Err(err);
-                }
-            }
-        }
-
-        let prefix = match wait_external_get_start_prefix(shared_op.clone()).await {
-            Ok(prefix) => prefix,
-            Err(err) => {
-                release_external_get_start_waiter(inner, &shared_op);
-                return Err(err);
-            }
-        };
+        let (prefix, transfer_keys, transfer_items) =
+            prepare_external_get_batch_plan(inner, &req, &group_lens).await?;
         let handle = inner
             .next_external_get_start_handle
             .fetch_add(1, Ordering::Relaxed);
-        let transfer_plan = if let Some(memory_infos) = shared_op.inline_local_memory_infos.get() {
+        let inline_memory_infos = (transfer_items.len() == req.keys.len())
+            .then(|| collect_all_local_external_get_start_infos(&transfer_items))
+            .flatten();
+        let transfer_plan = if let Some(memory_infos) = inline_memory_infos {
             assert_eq!(
                 memory_infos.len(),
                 req.keys.len(),
                 "inline local get_start plan must cover the full request"
             );
             let items = memory_infos
-                .iter()
+                .into_iter()
                 .map(|memory_info| ExternalBatchGetItemResp {
                     error_code: OK,
                     error_json: String::new(),
                     external_memholder_info: Some(
-                        inner.install_external_get_holding(&req.req_node_id, memory_info.clone()),
+                        inner.install_external_get_holding(&req.req_node_id, memory_info),
                     ),
                 })
                 .collect();
-            release_external_get_start_waiter(inner, &shared_op);
             ExternalBatchGetStartTransferPlan::InlineLocal { items }
         } else {
             inner.external_get_start_registry.insert(
                 handle,
-                Arc::new(ExternalGetStartEntry {
+                ExternalGetStartEntry {
                     req_node_id: req.req_node_id.clone(),
-                    shared_op,
-                }),
+                    requester_node_start_time: inner
+                        .view
+                        .cluster_manager()
+                        .get_member_info_cached(&req.req_node_id)
+                        .map(|member| member.node_start_time),
+                    keys: transfer_keys,
+                    items: transfer_items,
+                    created_at: Instant::now(),
+                },
             );
             ExternalBatchGetStartTransferPlan::OwnerRpc
         };
@@ -1520,62 +2642,46 @@ impl HandlerForExternalClient for ClientKvApi {
                 req.req_node_id
             );
         }
-        let shared_op = entry.shared_op.clone();
-        let result = match wait_external_get_start_transfer(shared_op.clone()).await {
-            Ok((keys, shared_items)) => {
-                if shared_items.len() != keys.len() {
-                    Err(KvError::Api(ApiError::Unknown {
-                        detail: format!(
-                            "external_batch_get_transfer shared result length mismatch: expected={} got={}",
-                            keys.len(),
-                            shared_items.len()
-                        ),
-                    }))
-                } else {
-                    let mut items = Vec::with_capacity(shared_items.len());
-                    for (key, item_result) in keys.iter().zip(shared_items.into_iter()) {
-                        match item_result {
-                            ExternalGetStartSharedItemResult::Hit { memholder } => {
-                                let external_memholder_info = inner.install_external_get_holding(
-                                    &req.req_node_id,
-                                    memholder.memory_info(),
-                                );
-                                items.push(ExternalBatchGetItemResp {
-                                    error_code: OK,
-                                    error_json: String::new(),
-                                    external_memholder_info: Some(external_memholder_info),
-                                });
-                            }
-                            ExternalGetStartSharedItemResult::Miss => {
-                                items.push(ExternalBatchGetItemResp {
-                                    error_code: codes_api::API_KEY_NOT_FOUND,
-                                    error_json: format!("Key not found: {}", key),
-                                    external_memholder_info: None,
-                                });
-                            }
-                            ExternalGetStartSharedItemResult::Error {
-                                error_code,
-                                error_json,
-                            } => {
-                                items.push(ExternalBatchGetItemResp {
-                                    error_code,
-                                    error_json,
-                                    external_memholder_info: None,
-                                });
-                            }
-                        }
-                    }
-                    Ok(ExternalBatchGetTransferResp {
-                        items,
+        let keys = entry.keys;
+        let transfer_results =
+            finish_external_get_start_transfer(inner.view.clone_view(), entry.items, 0).await?;
+        if transfer_results.len() != keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external_batch_get_transfer result length mismatch: expected={} got={}",
+                    keys.len(),
+                    transfer_results.len()
+                ),
+            }));
+        }
+        let mut items = Vec::with_capacity(transfer_results.len());
+        for (key, item_result) in keys.iter().zip(transfer_results) {
+            match item_result {
+                Ok(Some((memholder, _))) => {
+                    let external_memholder_info = inner
+                        .install_external_get_holding(&req.req_node_id, memholder.memory_info());
+                    items.push(ExternalBatchGetItemResp {
                         error_code: OK,
                         error_json: String::new(),
-                    })
+                        external_memholder_info: Some(external_memholder_info),
+                    });
                 }
+                Ok(None) => items.push(ExternalBatchGetItemResp {
+                    error_code: codes_api::API_KEY_NOT_FOUND,
+                    error_json: format!("Key not found: {}", key),
+                    external_memholder_info: None,
+                }),
+                Err(err) => items.push(ExternalBatchGetItemResp {
+                    external_memholder_info: None,
+                    ..ExternalBatchGetItemResp::from_error(&err)
+                }),
             }
-            Err(err) => Err(err),
-        };
-        release_external_get_start_waiter(inner, &shared_op);
-        result
+        }
+        Ok(ExternalBatchGetTransferResp {
+            items,
+            error_code: OK,
+            error_json: String::new(),
+        })
     }
 
     async fn external_batch_get_cancel(
@@ -1601,7 +2707,7 @@ impl HandlerForExternalClient for ClientKvApi {
                             req.req_node_id
                         );
                     }
-                    release_external_get_start_waiter(inner, &entry.shared_op);
+                    drop(entry);
                 }
             }
             ExternalBatchGetCancelPlan::InlineLocal { holder_ids } => {
@@ -1626,6 +2732,12 @@ impl HandlerForExternalClient for ClientKvApi {
         let started_at = Instant::now();
 
         self.validate_requester_owner_status_updated(req.started_time)?;
+        // Register before the master PutStart RPC. Reclaim Prepare checks this
+        // counter under the same per-key key-control shard, closing the old gap
+        // between master admission and insertion into external_pending_puts.
+        let pending_fence = inner.acquire_external_pending_put_fence(&req.key)?;
+        let mut pending_fence_claim =
+            ExternalPutStartFenceClaim::new(inner.view.clone_view(), pending_fence);
 
         let put_start_started_at = Instant::now();
         let source_node_id = if self.is_side_transfer_worker() {
@@ -1649,10 +2761,15 @@ impl HandlerForExternalClient for ClientKvApi {
                 e
             })?;
         // Ensure master responded OK before using returned addresses
-        crate::rpcresp_kvresult_convert::try_from_code(
+        if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
             put_start_resp.error_code,
             put_start_resp.error_json.clone(),
-        )?;
+        ) {
+            // An application response proves the master did not admit this Put;
+            // no uncertainty quarantine is required.
+            pending_fence_claim.release_after_definite_response();
+            return Err(err);
+        }
         tracing::debug!(
             "handle external put start for key: {}, len: {}",
             req.key,
@@ -1709,6 +2826,7 @@ impl HandlerForExternalClient for ClientKvApi {
                 local_reserve_slot: None,
                 local_reserve_slot_size: None,
                 atomic_group: None,
+                _pending_fence: pending_fence_claim.take_for_pending_context(),
             },
         );
         if !is_local_target {
@@ -1789,39 +2907,33 @@ impl HandlerForExternalClient for ClientKvApi {
             }));
         }
 
-        let mut reserved_keys = Vec::with_capacity(req.items.len());
+        let mut pending_fences = Vec::with_capacity(req.items.len());
         for item in &req.items {
-            if let Err(err) = inner.reserve_external_local_first_put_key(
+            let pending_fence = match inner.reserve_external_local_first_put_key(
                 &item.key,
                 item.reject_if_inflight_same_key,
                 item.reject_if_exist_same_key,
             ) {
-                external_local_first_release_keys(inner, &reserved_keys);
-                let items = req
-                    .items
-                    .iter()
-                    .map(|_| external_local_first_error_item(&err))
-                    .collect();
-                return Ok(ExternalBatchPutStartResp {
-                    items,
-                    error_code: OK,
-                    error_json: String::new(),
-                });
-            }
-            reserved_keys.push(item.key.clone());
+                Ok(pending_fence) => pending_fence,
+                Err(err) => {
+                    let items = req
+                        .items
+                        .iter()
+                        .map(|_| external_local_first_error_item(&err))
+                        .collect();
+                    return Ok(ExternalBatchPutStartResp {
+                        items,
+                        error_code: OK,
+                        error_json: String::new(),
+                    });
+                }
+            };
+            pending_fences.push(pending_fence);
         }
 
-        let slot_lease = match inner
-            .owner_claim_local_reserve_slot_lease(value_len, req.items.len())
-            .await
-        {
-            Ok(slot_lease) => slot_lease,
-            Err(err) => {
-                external_local_first_release_keys(inner, &reserved_keys);
-                return Err(err);
-            }
-        };
-        let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
+        // Finish every fallible, purely logical derivation before claiming
+        // physical slots.  The per-key fences above are RAII-owned, so any
+        // error or cancellation before cache insertion releases both counters.
         let put_ids = req
             .items
             .iter()
@@ -1836,11 +2948,29 @@ impl HandlerForExternalClient for ClientKvApi {
         let atomic_groups =
             build_put_atomic_group_assignments(&keys_and_put_ids, &atomic_group_lens)
                 .map_err(|detail| KvError::Api(ApiError::InvalidArgument { detail }))?;
+
+        let slot_lease = match inner
+            .owner_claim_local_reserve_slot_lease(value_len, req.items.len())
+            .await
+        {
+            Ok(slot_lease) => slot_lease,
+            Err(err) => return Err(err),
+        };
+        let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
+        let slot_size = slot_lease.slot_size;
+        for (slot_ref, pending_fence) in slot_lease.slots.iter().zip(&pending_fences) {
+            pending_fence.attach_local_slot_lease(OwnerLocalReserveSlotLease {
+                value_len,
+                slot_size,
+                slots: vec![slot_ref.clone()],
+            });
+        }
         let mut items = Vec::with_capacity(req.items.len());
-        for (idx, (req_item, slot_ref)) in req
+        for (idx, ((req_item, slot_ref), pending_fence)) in req
             .items
             .into_iter()
             .zip(slot_lease.slots.into_iter())
+            .zip(pending_fences.into_iter())
             .enumerate()
         {
             let put_id = put_ids[idx];
@@ -1857,8 +2987,9 @@ impl HandlerForExternalClient for ClientKvApi {
                     preferred_sub_cluster: req_item.preferred_sub_cluster.clone(),
                     replica_target: None,
                     local_reserve_slot: Some(slot_ref.clone()),
-                    local_reserve_slot_size: Some(slot_lease.slot_size),
+                    local_reserve_slot_size: Some(slot_size),
                     atomic_group: atomic_groups[idx].clone(),
+                    _pending_fence: pending_fence,
                 },
             );
             tracing::debug!(
@@ -1914,45 +3045,53 @@ impl HandlerForExternalClient for ClientKvApi {
             return Ok(ExternalPutTransferEndResp::from_error(&err));
         };
 
-        let pending_ctx = inner
-            .external_pending_puts
-            .get(&(req.key.clone(), put_id.0, put_id.1))
-            .map(|ctx| ctx.clone());
-        let replica_target = pending_ctx
-            .as_ref()
-            .and_then(|ctx| ctx.replica_target.clone());
-        let admitted_replica_task = pending_ctx
-            .as_ref()
-            .map(|ctx| ctx.make_replica_task)
-            .unwrap_or(false);
+        let pending_ctx = match require_external_pending_put_ctx(
+            inner,
+            "external_put_transfer_end",
+            &req.key,
+            put_id,
+        ) {
+            Ok(ctx) => ctx,
+            Err(err) => {
+                best_effort_revoke_missing_external_pending_ctx(
+                    inner,
+                    "external_put_transfer_end",
+                    &req.key,
+                    put_id,
+                )
+                .await;
+                return Ok(ExternalPutTransferEndResp::from_error(&err));
+            }
+        };
+        let replica_target = pending_ctx.replica_target.clone();
+        let admitted_replica_task = pending_ctx.make_replica_task;
         let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
         let req_remote_target = req
             .peer_id
             .as_deref()
             .is_some_and(|peer| peer != self_node_id.as_str());
-        let has_remote_target = pending_ctx
-            .as_ref()
-            .and_then(|ctx| ctx.peer_id.as_ref())
-            .is_some();
-        if pending_ctx.is_some() && req_remote_target != has_remote_target {
+        let has_remote_target = pending_ctx.peer_id.is_some();
+        if req_remote_target != has_remote_target {
             let err = KvError::Api(ApiError::InvalidArgument {
                 detail: format!(
                     "external_put_transfer_end peer_id mismatches pending ctx: key={} put_id=({},{}) req_remote_target={} ctx_remote_target={}",
                     req.key, put_id.0, put_id.1, req_remote_target, has_remote_target
                 ),
             });
-            if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                tracing::warn!(
-                    "external_put_transfer_end put_revoke failed after peer_id mismatch: key={} put_id=({},{}) err={}",
+            match inner.put_revoke(&req.key, put_id).await {
+                Ok(_) => {
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(req.key.clone(), put_id.0, put_id.1))
+                }
+                Err(revoke_err) => tracing::warn!(
+                    "external_put_transfer_end put_revoke failed after peer_id mismatch; pending fence retained: key={} put_id=({},{}) err={}",
                     req.key,
                     put_id.0,
                     put_id.1,
                     revoke_err
-                );
+                ),
             }
-            inner
-                .external_pending_puts
-                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
             return Ok(ExternalPutTransferEndResp::from_error(&err));
         }
         let put_transfer_total_us = 0;
@@ -1993,24 +3132,26 @@ impl HandlerForExternalClient for ClientKvApi {
             "external_put_transfer_end",
             &req.key,
             put_id,
-            pending_ctx.as_ref(),
+            &pending_ctx,
             req.src_offset,
             req.len,
         ) {
             Ok(publish) => publish,
             Err(err) => {
-                if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                    tracing::warn!(
-                        "external_put_transfer_end put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
+                match inner.put_revoke(&req.key, put_id).await {
+                    Ok(_) => inner.external_pending_puts.invalidate(&(
+                        req.key.clone(),
+                        put_id.0,
+                        put_id.1,
+                    )),
+                    Err(revoke_err) => tracing::warn!(
+                        "external_put_transfer_end put_revoke failed after local cache publish precheck error; pending fence retained: key={} put_id=({},{}) err={}",
                         req.key,
                         put_id.0,
                         put_id.1,
                         revoke_err
-                    );
+                    ),
                 }
-                inner
-                    .external_pending_puts
-                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
                 return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
             }
         };
@@ -2021,9 +3162,12 @@ impl HandlerForExternalClient for ClientKvApi {
             Ok(end) => end,
             Err(e) => {
                 tracing::error!("Failed to end put operation: {}", e);
-                inner
-                    .external_pending_puts
-                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                tracing::warn!(
+                    "external_put_transfer_end PutDone was not terminal; pending fence retained for retry: key={} put_id=({},{})",
+                    req.key,
+                    put_id.0,
+                    put_id.1
+                );
                 return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&e));
             }
         };
@@ -2037,9 +3181,12 @@ impl HandlerForExternalClient for ClientKvApi {
                     req.key, put_id.0, put_id.1
                 ),
             });
-            inner
-                .external_pending_puts
-                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+            tracing::warn!(
+                "external_put_transfer_end retained pending fence after terminal response omitted local holder: key={} put_id=({},{})",
+                req.key,
+                put_id.0,
+                put_id.1
+            );
             return Ok(crate::rpcresp_kvresult_convert::FromError::from_error(&err));
         };
         inner
@@ -2128,12 +3275,17 @@ impl HandlerForExternalClient for ClientKvApi {
             local_cache_publish: LocalCommittedCachePublish,
             make_replica_task: bool,
             replica_target: Option<ReplicaTaskTarget>,
+            // Keep the per-key reclaim fence alive until the master's terminal
+            // response has been applied to the owner-local index.
+            _pending_ctx: ExternalPendingPutCtx,
         }
 
         let mut results: Vec<Option<ExternalBatchPutTransferEndItemResp>> =
             (0..req.items.len()).map(|_| None).collect();
         let mut done_pending = Vec::new();
         let mut revoke_pending = Vec::new();
+        let mut local_publish_items = Vec::new();
+        let mut local_publish_contexts = Vec::new();
 
         for (idx, item) in req.items.into_iter().enumerate() {
             let Some(put_id) = item.put_id else {
@@ -2148,81 +3300,99 @@ impl HandlerForExternalClient for ClientKvApi {
                 results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
                 continue;
             };
-
-            let pending_ctx = inner
-                .external_pending_puts
-                .get(&(item.key.clone(), put_id.0, put_id.1))
-                .map(|ctx| ctx.clone());
-            if let Some(ctx) = pending_ctx.as_ref() {
-                if ctx.local_reserve_slot.is_some() {
-                    if item.peer_id.is_some() {
-                        let err = KvError::Api(ApiError::InvalidArgument {
-                            detail: format!(
-                                "external_batch_put_transfer_end local-first item must be local target: key={} put_id=({},{})",
-                                item.key, put_id.0, put_id.1
-                            ),
-                        });
-                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+
+            let pending_ctx = match require_external_pending_put_ctx(
+                inner,
+                "external_batch_put_transfer_end",
+                &item.key,
+                put_id,
+            ) {
+                Ok(ctx) => ctx,
+                Err(err) => {
+                    results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                    revoke_pending.push(BatchPutRevokeItemReq {
+                        key: item.key.clone(),
+                        put_id,
+                    });
+                    continue;
+                }
+            };
+            if pending_ctx.local_reserve_slot.is_some() {
+                if item.peer_id.is_some() {
+                    let err = KvError::Api(ApiError::InvalidArgument {
+                        detail: format!(
+                            "external_batch_put_transfer_end local-first item must be local target: key={} put_id=({},{})",
+                            item.key, put_id.0, put_id.1
+                        ),
+                    });
+                    results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
+                    release_external_local_first_pending_slot(
+                        inner,
+                        &pending_ctx,
+                        "external_batch_put_transfer_end",
+                        &item.key,
+                        put_id,
+                    )
+                    .await;
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(item.key.clone(), put_id.0, put_id.1));
+                    continue;
+                }
+                match commit_external_local_first_pending(
+                    inner,
+                    &item.key,
+                    put_id,
+                    &pending_ctx,
+                    item.src_offset,
+                    item.len,
+                    "external_batch_put_transfer_end",
+                )
+                .await
+                {
+                    Ok(committed_slot) => {
+                        inner.record_put_locality(false, item.len, 0);
                         inner.external_pending_puts.invalidate(&(
                             item.key.clone(),
                             put_id.0,
                             put_id.1,
                         ));
-                        inner.release_external_local_first_put_key(&item.key);
-                        continue;
+                        local_publish_items.push(OwnerLocalPublishItem {
+                            key: item.key.clone(),
+                            put_id,
+                            value_len: item.len,
+                            lease_id: item.lease_id,
+                            committed_slot,
+                            make_replica_task: pending_ctx.make_replica_task,
+                            preferred_sub_cluster: pending_ctx.preferred_sub_cluster.clone(),
+                            atomic_group: pending_ctx.atomic_group.clone(),
+                        });
+                        local_publish_contexts.push(pending_ctx);
+                        results[idx] = Some(ExternalBatchPutTransferEndItemResp {
+                            error_code: OK,
+                            error_json: String::new(),
+                        });
                     }
-                    match commit_external_local_first_pending(
-                        inner,
-                        &item.key,
-                        put_id,
-                        ctx,
-                        item.src_offset,
-                        item.len,
-                        "external_batch_put_transfer_end",
-                    )
-                    .await
-                    {
-                        Ok(committed_slot) => {
-                            inner.record_put_locality(false, item.len, 0);
-                            inner.external_pending_puts.invalidate(&(
-                                item.key.clone(),
-                                put_id.0,
-                                put_id.1,
-                            ));
-                            inner.release_external_local_first_put_key(&item.key);
-                            spawn_external_local_first_publish(
-                                inner,
-                                item.key.clone(),
-                                put_id,
-                                item.lease_id,
-                                committed_slot,
-                                ctx.make_replica_task,
-                                ctx.preferred_sub_cluster.clone(),
-                                ctx.atomic_group.clone(),
-                            );
-                            results[idx] = Some(ExternalBatchPutTransferEndItemResp {
-                                error_code: OK,
-                                error_json: String::new(),
-                            });
-                        }
-                        Err(err) => {
-                            inner.external_pending_puts.invalidate(&(
-                                item.key.clone(),
-                                put_id.0,
-                                put_id.1,
-                            ));
-                            inner.release_external_local_first_put_key(&item.key);
-                            results[idx] =
-                                Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
-                        }
+                    Err(err) => {
+                        release_external_local_first_pending_slot(
+                            inner,
+                            &pending_ctx,
+                            "external_batch_put_transfer_end",
+                            &item.key,
+                            put_id,
+                        )
+                        .await;
+                        inner.external_pending_puts.invalidate(&(
+                            item.key.clone(),
+                            put_id.0,
+                            put_id.1,
+                        ));
+                        results[idx] = Some(ExternalBatchPutTransferEndItemResp::from_error(&err));
                     }
-                    continue;
                 }
+                continue;
             }
-            let has_remote_append = pending_ctx
-                .as_ref()
-                .and_then(|ctx| ctx.peer_id.as_ref())
-                .is_some();
+            let has_remote_append = pending_ctx.peer_id.is_some();
             if item.peer_id.is_some() || has_remote_append {
                 let err = KvError::Api(ApiError::InvalidArgument {
                     detail: format!(
@@ -2239,16 +3409,13 @@ impl HandlerForExternalClient for ClientKvApi {
                     key: item.key.clone(),
                     put_id,
                 });
-                inner
-                    .external_pending_puts
-                    .invalidate(&(item.key.clone(), put_id.0, put_id.1));
                 continue;
             }
             let local_cache_publish = match local_committed_cache_publish(
                 "external_batch_put_transfer_end",
                 &item.key,
                 put_id,
-                pending_ctx.as_ref(),
+                &pending_ctx,
                 item.src_offset,
                 item.len,
             ) {
@@ -2259,9 +3426,6 @@ impl HandlerForExternalClient for ClientKvApi {
                         key: item.key.clone(),
                         put_id,
                     });
-                    inner
-                        .external_pending_puts
-                        .invalidate(&(item.key.clone(), put_id.0, put_id.1));
                     continue;
                 }
             };
@@ -2273,22 +3437,42 @@ impl HandlerForExternalClient for ClientKvApi {
                 len: item.len,
                 put_locality: Some((false, 0)),
                 local_cache_publish,
-                make_replica_task: pending_ctx
-                    .as_ref()
-                    .map(|ctx| ctx.make_replica_task)
-                    .unwrap_or(false),
-                replica_target: pending_ctx
-                    .as_ref()
-                    .and_then(|ctx| ctx.replica_target.clone()),
+                make_replica_task: pending_ctx.make_replica_task,
+                replica_target: pending_ctx.replica_target.clone(),
+                _pending_ctx: pending_ctx,
             });
         }
 
+        if !local_publish_items.is_empty() {
+            spawn_external_local_first_publish(inner, local_publish_items, local_publish_contexts);
+        }
+
         if !revoke_pending.is_empty() {
-            if let Err(err) = inner.batch_put_revoke(revoke_pending).await {
-                tracing::warn!(
-                    "external_batch_put_transfer_end batch_put_revoke failed after precheck errors: {}",
+            let requested = revoke_pending.clone();
+            match inner.batch_put_revoke(revoke_pending).await {
+                Ok(response) if response.items.len() == requested.len() => {
+                    for (request, response) in requested.into_iter().zip(response.items) {
+                        if response.key == request.key
+                            && response.put_id == request.put_id
+                            && response.error_code == OK
+                        {
+                            inner.external_pending_puts.invalidate(&(
+                                request.key,
+                                request.put_id.0,
+                                request.put_id.1,
+                            ));
+                        }
+                    }
+                }
+                Ok(response) => tracing::warn!(
+                    "external_batch_put_transfer_end batch_put_revoke response length mismatch: expected={} got={}",
+                    requested.len(),
+                    response.items.len()
+                ),
+                Err(err) => tracing::warn!(
+                    "external_batch_put_transfer_end batch_put_revoke failed after precheck errors; pending fences retained for retry: {}",
                     err
-                );
+                ),
             }
         }
 
@@ -2348,11 +3532,6 @@ impl HandlerForExternalClient for ClientKvApi {
         }
 
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
-            inner.external_pending_puts.invalidate(&(
-                pending.key.clone(),
-                pending.put_id.0,
-                pending.put_id.1,
-            ));
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
                 done_item.error_json.clone(),
@@ -2380,6 +3559,11 @@ impl HandlerForExternalClient for ClientKvApi {
                     holder_id,
                 )
                 .await?;
+            inner.external_pending_puts.invalidate(&(
+                pending.key.clone(),
+                pending.put_id.0,
+                pending.put_id.1,
+            ));
             if pending.make_replica_task {
                 let target = pending
                     .replica_target
@@ -2436,14 +3620,25 @@ impl HandlerForExternalClient for ClientKvApi {
             );
             return Ok(ExternalPutCommitResp::from_error(&err));
         };
-        let pending_ctx = inner
-            .external_pending_puts
-            .get(&(req.key.clone(), put_id.0, put_id.1))
-            .map(|ctx| ctx.clone());
-        let has_remote_append = pending_ctx
-            .as_ref()
-            .and_then(|ctx| ctx.peer_id.as_ref())
-            .is_some();
+        let pending_ctx = match require_external_pending_put_ctx(
+            inner,
+            "external_put_commit",
+            &req.key,
+            put_id,
+        ) {
+            Ok(ctx) => ctx,
+            Err(err) => {
+                best_effort_revoke_missing_external_pending_ctx(
+                    inner,
+                    "external_put_commit",
+                    &req.key,
+                    put_id,
+                )
+                .await;
+                return Ok(ExternalPutCommitResp::from_error(&err));
+            }
+        };
+        let has_remote_append = pending_ctx.peer_id.is_some();
         if req.remote_target || has_remote_append {
             let err = KvError::Api(ApiError::InvalidArgument {
                 detail: format!(
@@ -2451,51 +3646,50 @@ impl HandlerForExternalClient for ClientKvApi {
                     req.key, put_id.0, put_id.1, req.remote_target, has_remote_append
                 ),
             });
-            if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                tracing::warn!(
-                    "external_put_commit put_revoke failed after remote primary target: key={} put_id=({},{}) err={}",
+            match inner.put_revoke(&req.key, put_id).await {
+                Ok(_) => {
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(req.key.clone(), put_id.0, put_id.1))
+                }
+                Err(revoke_err) => tracing::warn!(
+                    "external_put_commit put_revoke failed after remote primary target; pending fence retained: key={} put_id=({},{}) err={}",
                     req.key,
                     put_id.0,
                     put_id.1,
                     revoke_err
-                );
+                ),
             }
-            inner
-                .external_pending_puts
-                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
             return Ok(ExternalPutCommitResp::from_error(&err));
         }
-        let replica_target = pending_ctx
-            .as_ref()
-            .and_then(|ctx| ctx.replica_target.clone());
-        let admitted_replica_task = pending_ctx
-            .as_ref()
-            .map(|ctx| ctx.make_replica_task)
-            .unwrap_or(false);
+        let replica_target = pending_ctx.replica_target.clone();
+        let admitted_replica_task = pending_ctx.make_replica_task;
 
         let end_started_at = Instant::now();
         let local_cache_publish = match local_committed_cache_publish(
             "external_put_commit",
             &req.key,
             put_id,
-            pending_ctx.as_ref(),
+            &pending_ctx,
             req.src_offset,
             req.len,
         ) {
             Ok(publish) => publish,
             Err(err) => {
-                if let Err(revoke_err) = inner.put_revoke(&req.key, put_id).await {
-                    tracing::warn!(
-                        "external_put_commit put_revoke failed after local cache publish precheck error: key={} put_id=({},{}) err={}",
+                match inner.put_revoke(&req.key, put_id).await {
+                    Ok(_) => inner.external_pending_puts.invalidate(&(
+                        req.key.clone(),
+                        put_id.0,
+                        put_id.1,
+                    )),
+                    Err(revoke_err) => tracing::warn!(
+                        "external_put_commit put_revoke failed after local cache publish precheck error; pending fence retained: key={} put_id=({},{}) err={}",
                         req.key,
                         put_id.0,
                         put_id.1,
                         revoke_err
-                    );
+                    ),
                 }
-                inner
-                    .external_pending_puts
-                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
                 return Ok(ExternalPutCommitResp::from_error(&err));
             }
         };
@@ -2505,9 +3699,13 @@ impl HandlerForExternalClient for ClientKvApi {
         {
             Ok(end) => end,
             Err(e) => {
-                inner
-                    .external_pending_puts
-                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                tracing::warn!(
+                    "external_put_commit PutDone was not terminal; pending fence retained for retry: key={} put_id=({},{}) err={}",
+                    req.key,
+                    put_id.0,
+                    put_id.1,
+                    e
+                );
                 return Ok(ExternalPutCommitResp::from_error(&e));
             }
         };
@@ -2520,9 +3718,12 @@ impl HandlerForExternalClient for ClientKvApi {
                     req.key, put_id.0, put_id.1
                 ),
             });
-            inner
-                .external_pending_puts
-                .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+            tracing::warn!(
+                "external_put_commit retained pending fence after terminal response omitted local holder: key={} put_id=({},{})",
+                req.key,
+                put_id.0,
+                put_id.1
+            );
             return Ok(ExternalPutCommitResp::from_error(&err));
         };
         inner
@@ -2602,12 +3803,15 @@ impl HandlerForExternalClient for ClientKvApi {
             local_cache_publish: LocalCommittedCachePublish,
             make_replica_task: bool,
             replica_target: Option<ReplicaTaskTarget>,
+            _pending_ctx: ExternalPendingPutCtx,
         }
 
         let mut results: Vec<Option<ExternalBatchPutCommitItemResp>> =
             (0..req.items.len()).map(|_| None).collect();
         let mut done_pending = Vec::new();
         let mut revoke_pending = Vec::new();
+        let mut local_publish_items = Vec::new();
+        let mut local_publish_contexts = Vec::new();
 
         for (idx, item) in req.items.into_iter().enumerate() {
             let Some(put_id) = item.put_id else {
@@ -2622,79 +3826,98 @@ impl HandlerForExternalClient for ClientKvApi {
                 results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
                 continue;
             };
-            let pending_ctx = inner
-                .external_pending_puts
-                .get(&(item.key.clone(), put_id.0, put_id.1))
-                .map(|ctx| ctx.clone());
-            if let Some(ctx) = pending_ctx.as_ref() {
-                if ctx.local_reserve_slot.is_some() {
-                    if item.remote_target {
-                        let err = KvError::Api(ApiError::InvalidArgument {
-                            detail: format!(
-                                "external_batch_put_commit local-first item must be local target: key={} put_id=({},{})",
-                                item.key, put_id.0, put_id.1
-                            ),
-                        });
-                        results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+            let pending_ctx = match require_external_pending_put_ctx(
+                inner,
+                "external_batch_put_commit",
+                &item.key,
+                put_id,
+            ) {
+                Ok(ctx) => ctx,
+                Err(err) => {
+                    results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                    revoke_pending.push(BatchPutRevokeItemReq {
+                        key: item.key.clone(),
+                        put_id,
+                    });
+                    continue;
+                }
+            };
+            if pending_ctx.local_reserve_slot.is_some() {
+                if item.remote_target {
+                    let err = KvError::Api(ApiError::InvalidArgument {
+                        detail: format!(
+                            "external_batch_put_commit local-first item must be local target: key={} put_id=({},{})",
+                            item.key, put_id.0, put_id.1
+                        ),
+                    });
+                    results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
+                    release_external_local_first_pending_slot(
+                        inner,
+                        &pending_ctx,
+                        "external_batch_put_commit",
+                        &item.key,
+                        put_id,
+                    )
+                    .await;
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(item.key.clone(), put_id.0, put_id.1));
+                    continue;
+                }
+                match commit_external_local_first_pending(
+                    inner,
+                    &item.key,
+                    put_id,
+                    &pending_ctx,
+                    item.src_offset,
+                    item.len,
+                    "external_batch_put_commit",
+                )
+                .await
+                {
+                    Ok(committed_slot) => {
+                        inner.record_put_locality(false, item.len, 0);
                         inner.external_pending_puts.invalidate(&(
                             item.key.clone(),
                             put_id.0,
                             put_id.1,
                         ));
-                        inner.release_external_local_first_put_key(&item.key);
-                        continue;
+                        local_publish_items.push(OwnerLocalPublishItem {
+                            key: item.key.clone(),
+                            put_id,
+                            value_len: item.len,
+                            lease_id: item.lease_id,
+                            committed_slot,
+                            make_replica_task: pending_ctx.make_replica_task,
+                            preferred_sub_cluster: pending_ctx.preferred_sub_cluster.clone(),
+                            atomic_group: pending_ctx.atomic_group.clone(),
+                        });
+                        local_publish_contexts.push(pending_ctx);
+                        results[idx] = Some(ExternalBatchPutCommitItemResp {
+                            error_code: OK,
+                            error_json: String::new(),
+                        });
                     }
-                    match commit_external_local_first_pending(
-                        inner,
-                        &item.key,
-                        put_id,
-                        ctx,
-                        item.src_offset,
-                        item.len,
-                        "external_batch_put_commit",
-                    )
-                    .await
-                    {
-                        Ok(committed_slot) => {
-                            inner.record_put_locality(false, item.len, 0);
-                            inner.external_pending_puts.invalidate(&(
-                                item.key.clone(),
-                                put_id.0,
-                                put_id.1,
-                            ));
-                            inner.release_external_local_first_put_key(&item.key);
-                            spawn_external_local_first_publish(
-                                inner,
-                                item.key.clone(),
-                                put_id,
-                                item.lease_id,
-                                committed_slot,
-                                ctx.make_replica_task,
-                                ctx.preferred_sub_cluster.clone(),
-                                ctx.atomic_group.clone(),
-                            );
-                            results[idx] = Some(ExternalBatchPutCommitItemResp {
-                                error_code: OK,
-                                error_json: String::new(),
-                            });
-                        }
-                        Err(err) => {
-                            inner.external_pending_puts.invalidate(&(
-                                item.key.clone(),
-                                put_id.0,
-                                put_id.1,
-                            ));
-                            inner.release_external_local_first_put_key(&item.key);
-                            results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
-                        }
+                    Err(err) => {
+                        release_external_local_first_pending_slot(
+                            inner,
+                            &pending_ctx,
+                            "external_batch_put_commit",
+                            &item.key,
+                            put_id,
+                        )
+                        .await;
+                        inner.external_pending_puts.invalidate(&(
+                            item.key.clone(),
+                            put_id.0,
+                            put_id.1,
+                        ));
+                        results[idx] = Some(ExternalBatchPutCommitItemResp::from_error(&err));
                     }
-                    continue;
                 }
+                continue;
             }
-            let has_remote_append = pending_ctx
-                .as_ref()
-                .and_then(|ctx| ctx.peer_id.as_ref())
-                .is_some();
+            let has_remote_append = pending_ctx.peer_id.is_some();
             if item.remote_target || has_remote_append {
                 let err = KvError::Api(ApiError::InvalidArgument {
                     detail: format!(
@@ -2707,16 +3930,13 @@ impl HandlerForExternalClient for ClientKvApi {
                     key: item.key.clone(),
                     put_id,
                 });
-                inner
-                    .external_pending_puts
-                    .invalidate(&(item.key.clone(), put_id.0, put_id.1));
                 continue;
             };
             let local_cache_publish = match local_committed_cache_publish(
                 "external_batch_put_commit",
                 &item.key,
                 put_id,
-                pending_ctx.as_ref(),
+                &pending_ctx,
                 item.src_offset,
                 item.len,
             ) {
@@ -2727,9 +3947,6 @@ impl HandlerForExternalClient for ClientKvApi {
                         key: item.key.clone(),
                         put_id,
                     });
-                    inner
-                        .external_pending_puts
-                        .invalidate(&(item.key.clone(), put_id.0, put_id.1));
                     continue;
                 }
             };
@@ -2739,22 +3956,42 @@ impl HandlerForExternalClient for ClientKvApi {
                 put_id,
                 lease_id: item.lease_id,
                 local_cache_publish,
-                make_replica_task: pending_ctx
-                    .as_ref()
-                    .map(|ctx| ctx.make_replica_task)
-                    .unwrap_or(false),
-                replica_target: pending_ctx
-                    .as_ref()
-                    .and_then(|ctx| ctx.replica_target.clone()),
+                make_replica_task: pending_ctx.make_replica_task,
+                replica_target: pending_ctx.replica_target.clone(),
+                _pending_ctx: pending_ctx,
             });
         }
 
+        if !local_publish_items.is_empty() {
+            spawn_external_local_first_publish(inner, local_publish_items, local_publish_contexts);
+        }
+
         if !revoke_pending.is_empty() {
-            if let Err(err) = inner.batch_put_revoke(revoke_pending).await {
-                tracing::warn!(
-                    "external_batch_put_commit batch_put_revoke failed after local cache publish precheck errors: {}",
+            let requested = revoke_pending.clone();
+            match inner.batch_put_revoke(revoke_pending).await {
+                Ok(response) if response.items.len() == requested.len() => {
+                    for (request, response) in requested.into_iter().zip(response.items) {
+                        if response.key == request.key
+                            && response.put_id == request.put_id
+                            && response.error_code == OK
+                        {
+                            inner.external_pending_puts.invalidate(&(
+                                request.key,
+                                request.put_id.0,
+                                request.put_id.1,
+                            ));
+                        }
+                    }
+                }
+                Ok(response) => tracing::warn!(
+                    "external_batch_put_commit batch_put_revoke response length mismatch: expected={} got={}",
+                    requested.len(),
+                    response.items.len()
+                ),
+                Err(err) => tracing::warn!(
+                    "external_batch_put_commit batch_put_revoke failed after precheck errors; pending fences retained for retry: {}",
                     err
-                );
+                ),
             }
         }
 
@@ -2811,11 +4048,6 @@ impl HandlerForExternalClient for ClientKvApi {
         }
 
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
-            inner.external_pending_puts.invalidate(&(
-                pending.key.clone(),
-                pending.put_id.0,
-                pending.put_id.1,
-            ));
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
                 done_item.error_json.clone(),
@@ -2840,6 +4072,11 @@ impl HandlerForExternalClient for ClientKvApi {
                     holder_id,
                 )
                 .await?;
+            inner.external_pending_puts.invalidate(&(
+                pending.key.clone(),
+                pending.put_id.0,
+                pending.put_id.1,
+            ));
             if pending.make_replica_task {
                 let target = pending
                     .replica_target
@@ -2896,37 +4133,52 @@ impl HandlerForExternalClient for ClientKvApi {
             );
             return Ok(ExternalPutRevokeResp::from_error(&err));
         };
-        let pending_ctx = inner
-            .external_pending_puts
-            .get(&(req.key.clone(), put_id.0, put_id.1))
-            .map(|ctx| ctx.clone());
-        inner
-            .external_pending_puts
-            .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-        if let Some(ctx) = pending_ctx {
-            if let (Some(slot_ref), Some(slot_size)) =
-                (ctx.local_reserve_slot, ctx.local_reserve_slot_size)
+        let pending_ctx = match require_external_pending_put_ctx(
+            inner,
+            "external_put_revoke",
+            &req.key,
+            put_id,
+        ) {
+            Ok(ctx) => ctx,
+            Err(err) => {
+                best_effort_revoke_missing_external_pending_ctx(
+                    inner,
+                    "external_put_revoke",
+                    &req.key,
+                    put_id,
+                )
+                .await;
+                return Ok(ExternalPutRevokeResp::from_error(&err));
+            }
+        };
+        if pending_ctx.local_reserve_slot.is_some() {
+            return match pending_ctx
+                ._pending_fence
+                .release_local_slot_lease_now(inner)
+                .await
             {
-                inner.release_external_local_first_put_key(&req.key);
-                let lease = client_kv_api::OwnerLocalReserveSlotLease {
-                    value_len: ctx.len,
-                    slot_size,
-                    slots: vec![slot_ref],
-                };
-                return match inner.owner_release_local_reserve_slot_lease(lease).await {
-                    Ok(_) => Ok(ExternalPutRevokeResp {
+                Ok(_) => {
+                    inner
+                        .external_pending_puts
+                        .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                    Ok(ExternalPutRevokeResp {
                         error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
                         error_json: String::new(),
-                    }),
-                    Err(e) => Ok(ExternalPutRevokeResp::from_error(&e)),
-                };
-            }
+                    })
+                }
+                Err(e) => Ok(ExternalPutRevokeResp::from_error(&e)),
+            };
         }
         match inner.put_revoke(&req.key, put_id).await {
-            Ok(_) => Ok(ExternalPutRevokeResp {
-                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
-                error_json: String::new(),
-            }),
+            Ok(_) => {
+                inner
+                    .external_pending_puts
+                    .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+                Ok(ExternalPutRevokeResp {
+                    error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                    error_json: String::new(),
+                })
+            }
             Err(e) => Ok(ExternalPutRevokeResp::from_error(&e)),
         }
     }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 363c443..874107a 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -1,4 +1,7 @@
-use super::{ClientKvApiInner, KvMetrics};
+use super::{
+    ClientKvApiInner, ClientKvApiView, KvMetrics, OwnerLocalReserveSlotLease,
+    OwnerLocalReserveSlotRef,
+};
 use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::memholder::{MemoryInfo, UserMemHolder, UserMemHolderExposeKind};
 // no StageScope; timestamps-based metrics only
@@ -13,19 +16,186 @@ use crate::{
     master_kv_router::msg_pack::{
         BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeReq, BatchGetRevokeResp,
         BatchGetStartItemResp, BatchGetStartReq, BatchGetStartResp, BatchIsExistReq,
-        GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetMetaResp, GetRevokeReq,
-        GetStartReq, GetStartResp,
+        GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetMetaResp,
+        GetPreparedLocalReserveTarget, GetRevokeReq, GetStartReq, GetStartResp,
     },
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::codes_api,
     rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK},
 };
+use ::tokio::sync::Semaphore;
 use chrono::Utc;
 use futures::stream::{self, StreamExt};
 use limit_thirdparty::tokio;
 use std::sync::Arc;
+use std::sync::OnceLock;
+use std::time::Duration;
 use std::time::Instant;
 
+const BATCH_GET_DONE_MAX_INFLIGHT: usize = 4;
+
+fn batch_get_done_rpc_limiter() -> &'static Semaphore {
+    static LIMITER: OnceLock<Semaphore> = OnceLock::new();
+    LIMITER.get_or_init(|| Semaphore::new(BATCH_GET_DONE_MAX_INFLIGHT))
+}
+
+async fn release_prepared_get_target(
+    inner: &ClientKvApiInner,
+    target: &GetPreparedLocalReserveTarget,
+) -> KvResult<()> {
+    inner
+        .owner_release_local_reserve_slot_lease(OwnerLocalReserveSlotLease {
+            value_len: target.slot_size,
+            slot_size: target.slot_size,
+            slots: vec![OwnerLocalReserveSlotRef {
+                grant_id: target.grant_id,
+                slot_index: target.slot_index,
+                ptr: target.addr,
+                base_addr: target.base_addr,
+            }],
+        })
+        .await
+}
+
+fn batch_get_done_response_matches(get_ids: &[u64], response: &BatchGetDoneResp) -> bool {
+    response.items.len() == get_ids.len()
+        && response
+            .items
+            .iter()
+            .zip(get_ids)
+            .all(|(item, expected_get_id)| item.get_id == *expected_get_id)
+}
+
+#[derive(Clone)]
+pub(crate) struct StartedGetRevokeCleanup {
+    pub(crate) get_id: u64,
+    pub(crate) prepared_target: Option<GetPreparedLocalReserveTarget>,
+}
+
+async fn run_started_get_revoke_cleanup(
+    view: ClientKvApiView,
+    pending: Vec<StartedGetRevokeCleanup>,
+    context: &'static str,
+) {
+    if pending.is_empty() {
+        return;
+    }
+    let mut attempt = 1u32;
+    loop {
+        let get_ids = pending.iter().map(|item| item.get_id).collect::<Vec<_>>();
+        let response = view.client_kv_api().inner().batch_get_revoke(get_ids).await;
+        let resp = match response {
+            Ok(resp)
+                if resp.items.len() == pending.len()
+                    && resp
+                        .items
+                        .iter()
+                        .zip(&pending)
+                        .all(|(resp, expected)| resp.get_id == expected.get_id) =>
+            {
+                resp
+            }
+            Ok(resp) => {
+                tracing::warn!(
+                    "{} Revoke response shape/identity mismatch; retaining prepared slots for retry: expected={} got={} attempt={}",
+                    context,
+                    pending.len(),
+                    resp.items.len(),
+                    attempt
+                );
+                tokio::time::sleep(Duration::from_millis(
+                    (50u64.saturating_mul(1u64 << attempt.min(6))).min(2_000),
+                ))
+                .await;
+                attempt = attempt.saturating_add(1);
+                continue;
+            }
+            Err(err) => {
+                if matches!(&err, KvError::Api(ApiError::SystemShutdown { .. })) {
+                    tracing::warn!(
+                        "{} Revoke cleanup stopped during owner shutdown: items={}",
+                        context,
+                        pending.len()
+                    );
+                    return;
+                }
+                tracing::warn!(
+                    "{} Revoke uncertain; retaining get ids and prepared slots for retry: items={} attempt={} err={}",
+                    context,
+                    pending.len(),
+                    attempt,
+                    err
+                );
+                tokio::time::sleep(Duration::from_millis(
+                    (50u64.saturating_mul(1u64 << attempt.min(6))).min(2_000),
+                ))
+                .await;
+                attempt = attempt.saturating_add(1);
+                continue;
+            }
+        };
+
+        for (expected, item_resp) in pending.iter().zip(resp.items) {
+            if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+                item_resp.error_code,
+                item_resp.error_json,
+            ) {
+                // A terminal Done may have won.  Never release a possibly
+                // committed slot from the losing Revoke path.
+                tracing::warn!(
+                    "{} Revoke reached non-releasable terminal: get_id={} err={}",
+                    context,
+                    expected.get_id,
+                    err
+                );
+                continue;
+            }
+            let Some(target) = expected.prepared_target.as_ref() else {
+                continue;
+            };
+            let mut release_attempt = 1u32;
+            loop {
+                match release_prepared_get_target(view.client_kv_api().inner(), target).await {
+                    Ok(()) => break,
+                    Err(err) => {
+                        tracing::error!(
+                            "{} Revoke confirmed but prepared slot release failed; retrying: get_id={} attempt={} err={}",
+                            context,
+                            expected.get_id,
+                            release_attempt,
+                            err
+                        );
+                        tokio::time::sleep(Duration::from_secs(1)).await;
+                        release_attempt = release_attempt.saturating_add(1);
+                    }
+                }
+            }
+        }
+        return;
+    }
+}
+
+/// Move cleanup ownership to a registered task before awaiting it.  If the
+/// caller future is cancelled, the task still drives Revoke to a definite
+/// terminal and releases only confirmed-uncommitted prepared slots.
+pub(crate) async fn finish_started_get_revoke_cleanup(
+    inner: &ClientKvApiInner,
+    pending: Vec<StartedGetRevokeCleanup>,
+    context: &'static str,
+) {
+    if pending.is_empty() {
+        return;
+    }
+    let (done_tx, done_rx) = ::tokio::sync::oneshot::channel::<()>();
+    let spawn_view = inner.view.clone_view();
+    let worker_view = spawn_view.clone();
+    spawn_view.spawn("started_get_revoke_cleanup", async move {
+        run_started_get_revoke_cleanup(worker_view, pending, context).await;
+        let _ = done_tx.send(());
+    });
+    let _ = done_rx.await;
+}
+
 #[derive(Debug, Clone)]
 pub struct RemoteGetInfo {
     get_id: u64,
@@ -94,6 +264,7 @@ impl ClientKvApiInner {
             start_item: BatchGetStartItemResp,
             peer_is_remote: bool,
             transfer_us: i64,
+            prepared_memory_info: Option<Arc<MemoryInfo>>,
         }
 
         let transfer_concurrency = transfer_concurrency.max(1);
@@ -106,11 +277,14 @@ impl ClientKvApiInner {
             Option<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>,
         > = (0..keys.len()).map(|_| None).collect();
         let mut done_pending = Vec::new();
-        let mut revoke_get_ids = Vec::new();
+        let mut transfer_error_cleanup = Vec::new();
         let mut transfer_futures = Vec::new();
 
         for (idx, (key, start_item)) in keys.into_iter().zip(start_items.into_iter()).enumerate() {
             if start_item.error_code == codes_api::API_KEY_NOT_FOUND {
+                if let Some(target) = start_item.prepared_target.as_ref() {
+                    release_prepared_get_target(self, target).await?;
+                }
                 results[idx] = Some(Ok(None));
                 continue;
             }
@@ -118,6 +292,9 @@ impl ClientKvApiInner {
                 start_item.error_code,
                 start_item.error_json.clone(),
             ) {
+                if let Some(target) = start_item.prepared_target.as_ref() {
+                    release_prepared_get_target(self, target).await?;
+                }
                 results[idx] = Some(Err(err));
                 continue;
             }
@@ -140,6 +317,7 @@ impl ClientKvApiInner {
                     start_item,
                     peer_is_remote,
                     transfer_us: 0,
+                    prepared_memory_info: None,
                 });
                 continue;
             }
@@ -186,50 +364,156 @@ impl ClientKvApiInner {
                         start_item,
                         peer_is_remote,
                         transfer_us,
+                        prepared_memory_info: None,
                     });
                 }
-                (idx, _key, _start_item, _peer_is_remote, get_id, _transfer_us, Err(err)) => {
+                (idx, _key, start_item, _peer_is_remote, get_id, _transfer_us, Err(err)) => {
                     results[idx] = Some(Err(err));
-                    revoke_get_ids.push(get_id);
+                    transfer_error_cleanup.push(StartedGetRevokeCleanup {
+                        get_id,
+                        prepared_target: start_item.prepared_target,
+                    });
                 }
             }
         }
 
-        if !revoke_get_ids.is_empty() {
-            if let Err(err) = self.batch_get_revoke(revoke_get_ids).await {
-                tracing::warn!("batch_get_revoke failed after transfer errors: {}", err);
+        finish_started_get_revoke_cleanup(
+            self,
+            transfer_error_cleanup,
+            "batch_get transfer failure",
+        )
+        .await;
+
+        let mut ready_done_pending = Vec::with_capacity(done_pending.len());
+        let mut install_failed_cleanup = Vec::new();
+        for mut pending in done_pending {
+            let install_result = if let Some(target) = pending.start_item.prepared_target.as_ref() {
+                match u32::try_from(pending.start_item.len) {
+                    Ok(len) => self
+                        .install_hidden_pending_local_get(
+                            &pending.key,
+                            pending.start_item.get_id,
+                            pending.start_item.put_id,
+                            target.addr,
+                            target.base_addr,
+                            len,
+                            target.slot_size,
+                            target.grant_id,
+                            target.slot_index,
+                        )
+                        .map(Some),
+                    Err(_) => Err(KvError::Api(ApiError::InvalidArgument {
+                        detail: format!(
+                            "local-reserve Get value length exceeds u32: key={} len={}",
+                            pending.key, pending.start_item.len
+                        ),
+                    })),
+                }
+            } else {
+                Ok(None)
+            };
+            match install_result {
+                Ok(memory_info) => {
+                    pending.prepared_memory_info = memory_info;
+                    ready_done_pending.push(pending);
+                }
+                Err(err) => {
+                    install_failed_cleanup.push(StartedGetRevokeCleanup {
+                        get_id: pending.start_item.get_id,
+                        prepared_target: pending.start_item.prepared_target.clone(),
+                    });
+                    results[pending.idx] = Some(Err(err));
+                }
             }
         }
+        done_pending = ready_done_pending;
 
-        let done_resp = self
-            .batch_get_done(
-                done_pending
-                    .iter()
-                    .map(|pending| pending.start_item.get_id)
-                    .collect(),
-            )
-            .await?;
-        if done_resp.items.len() != done_pending.len() {
-            return Err(KvError::Api(ApiError::Unknown {
-                detail: format!(
-                    "batch_get_done response length mismatch: expected={} got={}",
-                    done_pending.len(),
-                    done_resp.items.len()
-                ),
-            }));
-        }
+        finish_started_get_revoke_cleanup(
+            self,
+            install_failed_cleanup,
+            "batch_get pending install failure",
+        )
+        .await;
+
+        let done_get_ids = done_pending
+            .iter()
+            .map(|pending| pending.start_item.get_id)
+            .collect::<Vec<_>>();
+        let done_first_get_id = done_get_ids.first().copied();
+        let done_last_get_id = done_get_ids.last().copied();
+        let mut done_attempt = 1u32;
+        let done_resp = loop {
+            match self.batch_get_done(done_get_ids.clone()).await {
+                Ok(resp) if batch_get_done_response_matches(&done_get_ids, &resp) => break resp,
+                Ok(resp) => {
+                    tracing::warn!(
+                        "batch_get_done response shape/identity mismatch; retaining pending-visible slots and retrying the same idempotent get_ids: items={} first_get_id={:?} last_get_id={:?} got_items={} got_first_get_id={:?} got_last_get_id={:?} attempt={}",
+                        done_get_ids.len(),
+                        done_first_get_id,
+                        done_last_get_id,
+                        resp.items.len(),
+                        resp.items.first().map(|item| item.get_id),
+                        resp.items.last().map(|item| item.get_id),
+                        done_attempt
+                    );
+                }
+                Err(err) => {
+                    if matches!(&err, KvError::Api(ApiError::SystemShutdown { .. })) {
+                        return Err(err);
+                    }
+                    tracing::warn!(
+                        "batch_get_done transport uncertain; retaining pending-visible slots and retrying the same idempotent get_ids: items={} first_get_id={:?} last_get_id={:?} attempt={} err={}",
+                        done_get_ids.len(),
+                        done_first_get_id,
+                        done_last_get_id,
+                        done_attempt,
+                        err
+                    );
+                }
+            }
+            tokio::time::sleep(Duration::from_millis(
+                (10u64.saturating_mul(1u64 << done_attempt.min(8))).min(2_000),
+            ))
+            .await;
+            done_attempt = done_attempt.saturating_add(1);
+        };
         let master_node_id: NodeID = self
             .view
             .cluster_manager()
             .find_or_wait_master_node()
             .await?
             .into();
+        let mut local_hot_admissions = Vec::new();
 
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
                 done_item.error_json.clone(),
             ) {
+                if let Some(target) = pending.start_item.prepared_target.as_ref() {
+                    self.abort_hidden_pending_local_get(&pending.key, pending.start_item.get_id);
+                    let canonical = self.local_committed_mem_holder_for_put_id(
+                        &pending.key,
+                        pending.start_item.put_id,
+                    );
+                    if let Err(release_err) = release_prepared_get_target(self, target).await {
+                        results[pending.idx] = Some(Err(release_err));
+                        continue;
+                    }
+                    // A same-version PutDone/GetDone may have won while this
+                    // transfer was in flight.  Converge on the owner's
+                    // canonical local backing instead of turning an already
+                    // available KV page into a prefix miss.
+                    if let Some(memory_info) = canonical {
+                        let user_mem_holder = Arc::new(UserMemHolder::new(
+                            memory_info,
+                            self.get_or_init_all_memholder_refcount(),
+                            UserMemHolderExposeKind::SegPtr,
+                        ));
+                        results[pending.idx] = Some(Ok(Some((user_mem_holder, None))));
+                        continue;
+                    }
+                }
                 results[pending.idx] = Some(Err(err));
                 continue;
             }
@@ -238,7 +522,6 @@ impl ClientKvApiInner {
             } else {
                 UserMemHolderExposeKind::SegPtr
             };
-            let offset = pending.start_item.target_addr - pending.start_item.target_base_addr;
             let data_len = pending.start_item.len as usize;
             metrics.record_l2_hit_locality(pending.peer_is_remote, data_len as u64);
             metrics.record_get_io_locality(
@@ -246,37 +529,88 @@ impl ClientKvApiInner {
                 data_len as u64,
                 pending.transfer_us,
             );
-            let memory_info = Arc::new(
-                MemoryInfo::new(
-                    offset,
-                    pending.start_item.len as u32,
-                    done_item.holder_id,
-                    pending.key.clone(),
-                    master_node_id.clone(),
-                    self.view.clone(),
-                )
-                .await,
-            );
-            let get_info = RemoteGetInfo {
-                get_id: pending.start_item.get_id,
-                data_len,
-                src_addr: pending.start_item.src_addr,
-                target_addr: pending.start_item.target_addr,
-                node_id: pending.start_item.node_id.clone().into(),
-                peer_is_src_or_target: pending.peer_is_remote,
-            };
-            if done_item.allocation_mode != GetAllocationMode::Temporary {
-                if self.install_get_cached_info_if_unfenced(
+            let memory_info = if pending.start_item.prepared_target.is_some() {
+                if done_item.allocation_mode != GetAllocationMode::LocalCommittedSlot {
+                    self.abort_hidden_pending_local_get(&pending.key, pending.start_item.get_id);
+                    results[pending.idx] = Some(Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "prepared local-reserve Get completed with unexpected allocation mode: key={} mode={:?}",
+                            pending.key, done_item.allocation_mode
+                        ),
+                    })));
+                    continue;
+                }
+                let memory_info = match self.promote_hidden_pending_local_get(
                     &pending.key,
+                    pending.start_item.get_id,
                     pending.start_item.put_id,
-                    memory_info.clone(),
                 ) {
+                    Ok(memory_info) => memory_info,
+                    Err(err) => {
+                        results[pending.idx] = Some(Err(err));
+                        continue;
+                    }
+                };
+                if let Some(prepared) = pending.prepared_memory_info.as_ref() {
+                    assert!(
+                        Arc::ptr_eq(prepared, &memory_info),
+                        "Get promotion must retain the unique prepared MemoryInfo"
+                    );
+                }
+                local_hot_admissions.push((
+                    pending.key.clone(),
+                    pending.start_item.put_id,
+                    memory_info.clone(),
+                    pending.start_item.atomic_group.clone(),
+                ));
+                memory_info
+            } else {
+                if done_item.allocation_mode == GetAllocationMode::LocalCommittedSlot {
+                    results[pending.idx] = Some(Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "master returned local committed-slot mode without a prepared target: key={}",
+                            pending.key
+                        ),
+                    })));
+                    continue;
+                }
+                let offset = pending.start_item.target_addr - pending.start_item.target_base_addr;
+                let memory_info = Arc::new(
+                    MemoryInfo::new(
+                        offset,
+                        pending.start_item.len as u32,
+                        done_item.holder_id,
+                        pending.key.clone(),
+                        master_node_id.clone(),
+                        self.view.clone(),
+                    )
+                    .await,
+                );
+                if done_item.allocation_mode != GetAllocationMode::Temporary
+                    && self.install_get_cached_info_if_unfenced(
+                        &pending.key,
+                        pending.start_item.put_id,
+                        memory_info.clone(),
+                    )
+                {
                     metrics.observe_cache_value_size(
                         &client_id,
                         node_role.as_str(),
                         data_len as u64,
                     );
                 }
+                memory_info
+            };
+            let get_info = RemoteGetInfo {
+                get_id: pending.start_item.get_id,
+                data_len,
+                src_addr: pending.start_item.src_addr,
+                target_addr: pending.start_item.target_addr,
+                node_id: pending.start_item.node_id.clone().into(),
+                peer_is_src_or_target: pending.peer_is_remote,
+            };
+            if done_item.allocation_mode == GetAllocationMode::LocalCommittedSlot {
+                metrics.observe_cache_value_size(&client_id, node_role.as_str(), data_len as u64);
             }
             let user_mem_holder = Arc::new(UserMemHolder::new(
                 memory_info,
@@ -286,6 +620,12 @@ impl ClientKvApiInner {
             results[pending.idx] = Some(Ok(Some((user_mem_holder, Some(get_info)))));
         }
 
+        // All members are in get_cached_info before any hot admission can evict one of them.
+        // This keeps atomic/TP cohort write-back decisions complete.
+        for (key, put_id, memory_info, atomic_group) in local_hot_admissions {
+            self.owner_hot_track_committed(&key, put_id, &memory_info, atomic_group.as_ref());
+        }
+
         Ok(results
             .into_iter()
             .map(|item| {
@@ -994,6 +1334,7 @@ impl ClientKvApiInner {
         let req = MsgPack {
             serialize_part: GetStartReq {
                 key: key.to_string(),
+                prepared_target: None,
             },
             raw_bytes: Vec::new(),
         };
@@ -1016,13 +1357,25 @@ impl ClientKvApiInner {
     }
 
     pub async fn batch_get_start(&self, keys: Vec<String>) -> KvResult<BatchGetStartResp> {
+        self.batch_get_start_with_prepared_targets(keys, Vec::new())
+            .await
+    }
+
+    pub(crate) async fn batch_get_start_with_prepared_targets(
+        &self,
+        keys: Vec<String>,
+        prepared_targets: Vec<Option<GetPreparedLocalReserveTarget>>,
+    ) -> KvResult<BatchGetStartResp> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
                 detail: "ClientKvApi is shutting down; rejecting batch_get_start".to_string(),
             }));
         }
         let req = MsgPack {
-            serialize_part: BatchGetStartReq { keys },
+            serialize_part: BatchGetStartReq {
+                keys,
+                prepared_targets,
+            },
             raw_bytes: Vec::new(),
         };
         let master_node_id = self
@@ -1074,6 +1427,11 @@ impl ClientKvApiInner {
                 error_json: String::new(),
             });
         }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_get_revoke".to_string(),
+            }));
+        }
         let req = MsgPack {
             serialize_part: BatchGetRevokeReq { get_ids },
             raw_bytes: Vec::new(),
@@ -1128,6 +1486,20 @@ impl ClientKvApiInner {
                 server_process_us: 0,
             });
         }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_get_done".to_string(),
+            }));
+        }
+        // The master performs synchronous Moka policy work before acknowledging
+        // committed-slot Done.  Bound the number of callers entering that path
+        // so a capacity scan cannot park every master Tokio worker on Moka's
+        // blocking housekeeper lock.  The permit covers one RPC attempt only;
+        // idempotent retry backoff releases it and lets other cohorts converge.
+        let _done_rpc_permit = batch_get_done_rpc_limiter()
+            .acquire()
+            .await
+            .expect("the process-wide BatchGetDone limiter is never closed");
         let req = MsgPack {
             serialize_part: BatchGetDoneReq { get_ids },
             raw_bytes: Vec::new(),
@@ -1139,7 +1511,7 @@ impl ClientKvApiInner {
             .await?;
         let resp = self
             .rpc_caller_batch_get_done
-            .call(self.view.p2p_module(), master_node_id.into(), req, None, 0)
+            .call(self.view.p2p_module(), master_node_id.into(), req, None, 2)
             .await
             .map_err(KvError::from)?;
         crate::rpcresp_kvresult_convert::try_from_code(
@@ -1149,3 +1521,38 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::batch_get_done_response_matches;
+    use crate::master_kv_router::msg_pack::{BatchGetDoneItemResp, BatchGetDoneResp};
+
+    fn response(get_ids: &[u64]) -> BatchGetDoneResp {
+        BatchGetDoneResp {
+            items: get_ids
+                .iter()
+                .map(|get_id| BatchGetDoneItemResp {
+                    get_id: *get_id,
+                    ..Default::default()
+                })
+                .collect(),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn batch_get_done_requires_exact_response_identity() {
+        assert!(batch_get_done_response_matches(
+            &[11, 22],
+            &response(&[11, 22])
+        ));
+        assert!(!batch_get_done_response_matches(
+            &[11, 22],
+            &response(&[22, 11])
+        ));
+        assert!(!batch_get_done_response_matches(
+            &[11, 22],
+            &response(&[11])
+        ));
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
index cbe5467..08ad95e 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
@@ -10,10 +10,17 @@ const OWNER_LOCAL_RESERVE_REBALANCE_INTERVAL: Duration = Duration::from_millis(2
 const OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN: Duration = Duration::from_secs(5);
 const OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN: Duration = Duration::from_secs(1);
 const OWNER_LOCAL_RESERVE_DEFAULT_SOFT_WAIT_TIMEOUT: Duration = Duration::from_millis(10);
-const OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT: Duration = Duration::from_secs(10);
+// Cohort-safe master route deletion plus owner slot release is asynchronous.
+// Thirty seconds turns a recoverable pressure burst into a storage exception that
+// can wedge SGLang's detokenizer.  This remains well below the external request
+// timeout while allowing bounded backpressure to finish reclaiming slots.
+const OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT: Duration = Duration::from_secs(30);
 const OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS: usize = 0;
 const OWNER_LOCAL_RESERVE_REPORT_INTERVAL: Duration = Duration::from_secs(30);
 const OWNER_LOCAL_RESERVE_FREE_SLOT_HEADROOM_GRANTS: usize = 4;
+const OWNER_SLOT_PRESSURE_INTERVAL: Duration = Duration::from_millis(10);
+const OWNER_SLOT_PRESSURE_MIN_KICK_INTERVAL: Duration = Duration::from_millis(200);
+const OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES: u64 = 256 * 1024 * 1024;
 
 #[derive(Debug, Clone, Copy)]
 struct ExpectedCapacityLayout {
@@ -32,6 +39,7 @@ struct RebalanceClassSnapshot {
     free_slots: usize,
     grant_count: usize,
     pending_slot_demand: usize,
+    max_observed_claim_slots: usize,
     expected_grant_count: usize,
 }
 
@@ -49,7 +57,43 @@ fn owner_local_reserve_target_grant_count(
     let slots_per_grant = slots_per_grant as usize;
     let demand_grants =
         required_slots / slots_per_grant + usize::from(required_slots % slots_per_grant != 0);
-    demand_grants.max(expected_grant_count)
+    if expected_grant_count == 0 {
+        demand_grants
+    } else {
+        // A configured expected capacity is the owner's physical slot budget,
+        // not a minimum that demand may grow past.  Once all expected grants
+        // are installed, additional demand must be served by owner-local
+        // source eviction/reclaim; asking the master for another grant silently
+        // changes the configured owner capacity and can starve the remote
+        // allocation domain.
+        expected_grant_count
+    }
+}
+
+fn owner_slot_pressure_request_bytes(
+    snapshot: RebalanceClassSnapshot,
+    outstanding_selection_debt_bytes: u64,
+) -> u64 {
+    let low_watermark = (snapshot.slots_per_grant as usize)
+        .saturating_mul(2)
+        .max(snapshot.max_observed_claim_slots);
+    let high_watermark = (snapshot.slots_per_grant as usize)
+        .saturating_mul(OWNER_LOCAL_RESERVE_FREE_SLOT_HEADROOM_GRANTS);
+    let projected_eviction_slots =
+        usize::try_from(outstanding_selection_debt_bytes / snapshot.slot_size.max(1))
+            .unwrap_or(usize::MAX);
+    let projected_free_slots = snapshot.free_slots.saturating_add(projected_eviction_slots);
+    let pressure_active =
+        snapshot.pending_slot_demand > snapshot.free_slots || projected_free_slots < low_watermark;
+    if !pressure_active {
+        return 0;
+    }
+    let desired_free_slots = snapshot.pending_slot_demand.saturating_add(high_watermark);
+    let selection_slots = desired_free_slots.saturating_sub(projected_free_slots);
+    u64::try_from(selection_slots)
+        .unwrap_or(u64::MAX)
+        .saturating_mul(snapshot.slot_size)
+        .min(OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES)
 }
 
 fn owner_local_reserve_desired_free_slots(snapshot: RebalanceClassSnapshot) -> usize {
@@ -111,6 +155,7 @@ fn snapshot_rebalance_classes(pool: &OwnerLocalReservePoolState) -> Vec<Rebalanc
             free_slots: class_state.free_slot_count(),
             grant_count: class_state.grant_count(),
             pending_slot_demand: class_state.pending_slot_demand,
+            max_observed_claim_slots: class_state.max_observed_claim_slots,
             expected_grant_count: class_state.expected_grant_count,
         })
         .collect()
@@ -156,17 +201,8 @@ async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
     let mut total_rpc_latency = Duration::ZERO;
     let mut max_rpc_latency = Duration::ZERO;
     for _ in 0..additional_grants {
-        let missing_slots = desired_free_slots
-            .saturating_sub(snapshot.free_slots)
-            .max(1);
-        let required_free_slots = u32::try_from(missing_slots).unwrap_or(u32::MAX);
-        let reclaim_before_grow = snapshot.expected_grant_count != 0
-            && snapshot.grant_count >= snapshot.expected_grant_count;
         let rpc_started_at = Instant::now();
-        let outcome = match inner
-            .reserve_local_grant(snapshot.slot_size, required_free_slots, reclaim_before_grow)
-            .await
-        {
+        let outcome = match inner.reserve_local_grant().await {
             Ok(outcome) => {
                 let rpc_latency = rpc_started_at.elapsed();
                 total_rpc_latency = total_rpc_latency.saturating_add(rpc_latency);
@@ -197,22 +233,6 @@ async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
                 base_addr,
                 len,
             } => (grant_id, base_addr, addr, len),
-            ReserveLocalGrantOutcome::Reclaimed {
-                slot_size,
-                reclaimed_slots,
-            } => {
-                assert_eq!(slot_size, snapshot.slot_size);
-                tracing::info!(
-                    "owner local reserve reused reclaimed slots: slot_size={} reclaimed_slots={} pending_slots={}",
-                    slot_size,
-                    reclaimed_slots,
-                    snapshot.pending_slot_demand
-                );
-                inner
-                    .owner_local_reserve_rebalance_notify()
-                    .notify_waiters();
-                return;
-            }
             ReserveLocalGrantOutcome::None => {
                 unreachable!("reserve_local_grant filters empty successful outcomes")
             }
@@ -246,7 +266,7 @@ async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
                 OwnerLocalReserveClassState::new(snapshot.slot_size, snapshot.slots_per_grant)
             });
             class_state.last_grow_at = Some(Instant::now());
-            class_state.grants.push(detached_grant);
+            class_state.install_grant(detached_grant);
         }
         added_grants += 1;
         inner
@@ -272,16 +292,13 @@ async fn try_refill_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
 
 fn detach_excess_fully_free_grant(
     class_state: &mut OwnerLocalReserveClassState,
-    get_target_pressure: bool,
-) -> Option<(usize, super::OwnerLocalReserveGrantState)> {
-    if !get_target_pressure {
-        let grow_cooldown_ok = class_state
-            .last_grow_at
-            .map(|last_grow_at| last_grow_at.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN)
-            .unwrap_or(true);
-        if !grow_cooldown_ok {
-            return None;
-        }
+) -> Option<super::OwnerLocalReserveGrantState> {
+    let grow_cooldown_ok = class_state
+        .last_grow_at
+        .map(|last_grow_at| last_grow_at.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN)
+        .unwrap_or(true);
+    if !grow_cooldown_ok {
+        return None;
     }
     let shrink_keep_grants = owner_local_reserve_target_grant_count(
         class_state.slots_per_grant,
@@ -290,30 +307,19 @@ fn detach_excess_fully_free_grant(
         class_state.expected_grant_count,
     )
     .max(OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS);
-    if class_state.grants.len() <= shrink_keep_grants {
+    if class_state.grant_count() <= shrink_keep_grants {
         return None;
     }
 
-    let candidate_index = if get_target_pressure {
-        // A physical Get-target allocation can be blocked while reclaimed slots remain trapped in
-        // a detached 512-MiB reserve grant. Under explicit pressure, any fully-free excess grant is
-        // safe to return; restricting the actor to the tail would leave allocator space stranded.
-        class_state
-            .grants
-            .iter()
-            .rposition(super::OwnerLocalReserveGrantState::is_fully_free)
-    } else {
-        let tail_index = class_state.grants.len().checked_sub(1)?;
-        class_state.grants.get(tail_index).and_then(|grant| {
-            (grant.is_fully_free()
-                && grant
-                    .fully_free_since
-                    .map(|since| since.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN)
-                    .unwrap_or(false))
-            .then_some(tail_index)
-        })
-    }?;
-    Some((candidate_index, class_state.grants.remove(candidate_index)))
+    let candidate_grant_id = class_state.grants.last().and_then(|grant| {
+        (grant.is_fully_free()
+            && grant
+                .fully_free_since
+                .map(|since| since.elapsed() >= OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN)
+                .unwrap_or(false))
+        .then_some(grant.grant_id)
+    })?;
+    class_state.detach_fully_free_grant(candidate_grant_id)
 }
 
 async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnapshot) {
@@ -322,10 +328,10 @@ async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
         let Some(class_state) = pool.classes.get_mut(&snapshot.slot_size) else {
             return;
         };
-        detach_excess_fully_free_grant(class_state, false)
+        detach_excess_fully_free_grant(class_state)
     };
 
-    let Some((grant_index, grant)) = detached else {
+    let Some(grant) = detached else {
         return;
     };
 
@@ -339,9 +345,7 @@ async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
         let class_state = pool.classes.entry(snapshot.slot_size).or_insert_with(|| {
             OwnerLocalReserveClassState::new(snapshot.slot_size, snapshot.slots_per_grant)
         });
-        class_state
-            .grants
-            .insert(grant_index.min(class_state.grants.len()), grant);
+        class_state.install_grant(grant);
     } else {
         tracing::info!(
             "owner local reserve released excess grant: slot_size={} grant_id={} pending_slots={}",
@@ -352,71 +356,9 @@ async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
     }
 }
 
-/// Return one fully-free reserve grant immediately when an ordinary local Get-target allocation
-/// reports physical NoSpace. This never shrinks below the configured/active reserve target and does
-/// not evict a live slot; it only makes already-free physical capacity visible to the master
-/// allocator without waiting for the periodic idle cooldown.
-pub(crate) async fn release_one_excess_reserve_grant_for_get_target_pressure(
-    inner: &ClientKvApiInner,
-) -> bool {
-    let detached = {
-        let mut pool = inner.owner_local_reserve_pool.lock();
-        let mut detached = None;
-        for class_state in pool.classes.values_mut() {
-            if let Some((grant_index, grant)) = detach_excess_fully_free_grant(class_state, true) {
-                detached = Some((
-                    class_state.slot_size,
-                    class_state.slots_per_grant,
-                    class_state.pending_slot_demand,
-                    grant_index,
-                    grant,
-                ));
-                break;
-            }
-        }
-        detached
-    };
-    let Some((slot_size, slots_per_grant, pending_slots, grant_index, grant)) = detached else {
-        return false;
-    };
-    let grant_id = grant.grant_id;
-
-    if let Err(err) = inner.release_local_grant(grant_id).await {
-        tracing::warn!(
-            "owner local reserve get-target pressure failed to release grant_id={} err={}",
-            grant_id,
-            err
-        );
-        let mut pool = inner.owner_local_reserve_pool.lock();
-        let class_state = pool
-            .classes
-            .entry(slot_size)
-            .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
-        class_state
-            .grants
-            .insert(grant_index.min(class_state.grants.len()), grant);
-        inner
-            .owner_local_reserve_rebalance_notify()
-            .notify_waiters();
-        false
-    } else {
-        tracing::info!(
-            "owner local reserve released excess grant for get-target pressure: slot_size={} grant_id={} pending_slots={}",
-            slot_size,
-            grant_id,
-            pending_slots
-        );
-        inner
-            .owner_local_reserve_rebalance_notify()
-            .notify_waiters();
-        true
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::client_kv_api::OwnerLocalReserveGrantState;
 
     const SLOT_SIZE: u64 = 8 * 1024 * 1024;
 
@@ -456,10 +398,10 @@ mod tests {
     }
 
     #[test]
-    fn default_hard_timeout_covers_pressure_reclaim_transaction() {
+    fn default_hard_timeout_covers_owner_source_eviction_transaction() {
         assert_eq!(
             OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT,
-            Duration::from_secs(10)
+            Duration::from_secs(30)
         );
         assert!(
             OWNER_LOCAL_RESERVE_DEFAULT_HARD_TIMEOUT > OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN
@@ -475,6 +417,7 @@ mod tests {
             free_slots: 64 * 4,
             grant_count: 232,
             pending_slot_demand: 0,
+            max_observed_claim_slots: 0,
             expected_grant_count: 232,
         };
         assert_eq!(owner_local_reserve_desired_free_slots(snapshot), 64 * 4);
@@ -500,62 +443,71 @@ mod tests {
                 owner_local_reserve_desired_free_slots(pressured),
                 pressured.expected_grant_count,
             ),
-            233
+            232
         );
     }
 
     #[test]
-    fn get_target_pressure_can_detach_a_non_tail_fully_free_excess_grant() {
-        let mut class_state = OwnerLocalReserveClassState::new(SLOT_SIZE, 2);
-        class_state.expected_grant_count = 1;
-        for grant_id in 1..=3 {
-            class_state.grants.push(OwnerLocalReserveGrantState::new(
-                grant_id,
-                0,
-                grant_id * 1024,
-                1024,
-                SLOT_SIZE,
-                2,
-            ));
-        }
-        class_state.grants[0]
-            .claim_prepared_slot()
-            .expect("first grant must have a slot");
-        class_state.grants[2]
-            .claim_prepared_slot()
-            .expect("tail grant must have a slot");
-
-        assert!(detach_excess_fully_free_grant(&mut class_state, false).is_none());
-        let (index, grant) = detach_excess_fully_free_grant(&mut class_state, true)
-            .expect("pressure shrink must find the free middle grant");
-        assert_eq!(index, 1);
-        assert_eq!(grant.grant_id, 2);
-        assert_eq!(class_state.grants.len(), 2);
+    fn configured_expected_grants_are_a_hard_upper_bound() {
+        assert_eq!(
+            owner_local_reserve_target_grant_count(64, 64 * 300, 64, 232),
+            232
+        );
+        assert_eq!(
+            owner_local_reserve_target_grant_count(64, 64 * 300, 64, 0),
+            301
+        );
     }
 
     #[test]
-    fn get_target_pressure_never_shrinks_below_active_or_expected_target() {
-        let mut class_state = OwnerLocalReserveClassState::new(SLOT_SIZE, 2);
-        class_state.expected_grant_count = 2;
-        for grant_id in 1..=2 {
-            class_state.grants.push(OwnerLocalReserveGrantState::new(
-                grant_id,
+    fn owner_slot_pressure_targets_pending_plus_high_watermark() {
+        let snapshot = RebalanceClassSnapshot {
+            slot_size: 1024 * 1024,
+            slots_per_grant: 4,
+            used_slots: 4,
+            free_slots: 1,
+            grant_count: 1,
+            pending_slot_demand: 3,
+            max_observed_claim_slots: 3,
+            expected_grant_count: 1,
+        };
+        assert_eq!(
+            owner_slot_pressure_request_bytes(snapshot, 0),
+            18 * 1024 * 1024,
+            "3 pending slots plus 16 slots of retained headroom minus one physical Free"
+        );
+        assert_eq!(
+            owner_slot_pressure_request_bytes(snapshot, 10 * 1024 * 1024),
+            8 * 1024 * 1024,
+            "exact selected debt contributes projected slots of the same class"
+        );
+        assert_eq!(
+            owner_slot_pressure_request_bytes(
+                RebalanceClassSnapshot {
+                    free_slots: 16,
+                    pending_slot_demand: 0,
+                    ..snapshot
+                },
                 0,
-                grant_id * 1024,
-                1024,
-                SLOT_SIZE,
-                2,
-            ));
-        }
-        assert!(detach_excess_fully_free_grant(&mut class_state, true).is_none());
+            ),
+            0,
+            "pressure stops after the high watermark is physically available"
+        );
 
-        class_state.expected_grant_count = 0;
-        for grant in &mut class_state.grants {
-            grant
-                .claim_prepared_slot()
-                .expect("each grant must have a slot");
-        }
-        assert!(detach_excess_fully_free_grant(&mut class_state, true).is_none());
+        let clamped = RebalanceClassSnapshot {
+            slot_size: 8 * 1024 * 1024,
+            slots_per_grant: 64,
+            used_slots: 64,
+            free_slots: 1,
+            grant_count: 1,
+            pending_slot_demand: 100,
+            max_observed_claim_slots: 100,
+            expected_grant_count: 1,
+        };
+        assert_eq!(
+            owner_slot_pressure_request_bytes(clamped, 0),
+            OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES
+        );
     }
 }
 
@@ -650,6 +602,107 @@ pub fn spawn_owner_local_reserve_rebalance_actor(view: ClientKvApiView) {
     });
 }
 
+/// Drive owner slot pressure outside RPC handlers and outside Tokio's worker
+/// threads.  This is the sole production call site for Moka's synchronous
+/// `evict_some`: selection is deliberately bounded, and the returned weight
+/// means only "source-eviction candidates selected", never "slots reclaimed".
+pub fn spawn_owner_slot_pressure_actor(view: ClientKvApiView) {
+    let view_task = view.clone();
+    view.spawn("owner_slot_pressure_actor", async move {
+        let shutdown_poller = view_task.register_shutdown_poller();
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        let notify = view_task
+            .client_kv_api()
+            .inner()
+            .owner_local_reserve_rebalance_notify();
+        let mut tick = tokio::time::interval(OWNER_SLOT_PRESSURE_INTERVAL);
+        let mut last_kick_at: Option<Instant> = None;
+        let mut last_unsupported_class_report_at: Option<Instant> = None;
+
+        loop {
+            tokio::select! {
+                biased;
+                _ = shutdown_waiter.wait() => {
+                    tracing::info!("owner slot pressure actor stopped by shutdown");
+                    return;
+                }
+                _ = tick.tick() => {}
+                _ = notify.notified() => {}
+            }
+            if !shutdown_poller.is_running() {
+                return;
+            }
+
+            let inner = view_task.client_kv_api().inner();
+            if last_kick_at
+                .is_some_and(|last| last.elapsed() < OWNER_SLOT_PRESSURE_MIN_KICK_INTERVAL)
+            {
+                continue;
+            }
+            let outstanding_selection_debt_bytes = inner
+                .owner_hot_counters
+                .selection_debt_bytes
+                .load(std::sync::atomic::Ordering::Acquire);
+            let requested_bytes = {
+                let pool = inner.owner_local_reserve_pool.lock();
+                let snapshots = snapshot_rebalance_classes(&pool);
+                match snapshots.as_slice() {
+                    // No local allocation class has been observed yet.  This is
+                    // the normal idle state, not a configuration error.
+                    [] => 0,
+                    [snapshot] => owner_slot_pressure_request_bytes(
+                        *snapshot,
+                        outstanding_selection_debt_bytes,
+                    ),
+                    _ => {
+                        // Selection is intentionally disabled until the victim
+                        // cache is class-indexed.  Rate-limit the diagnostic so
+                        // an unsupported configuration cannot become a 100 Hz
+                        // logging/CPU loop.
+                        if last_unsupported_class_report_at.is_none_or(|last| {
+                            last.elapsed() >= OWNER_LOCAL_RESERVE_REPORT_INTERVAL
+                        }) {
+                            tracing::error!(
+                                active_classes = snapshots.len(),
+                                "owner slot pressure requires a class-indexed victim domain when more than one size class is active"
+                            );
+                            last_unsupported_class_report_at = Some(Instant::now());
+                        }
+                        0
+                    }
+                }
+            };
+            if requested_bytes == 0 {
+                continue;
+            }
+            let Some(cache) = inner.owner_hot_cache.clone() else {
+                continue;
+            };
+            let selected_bytes = match limit_thirdparty::tokio::task::spawn_blocking(move || {
+                cache.evict_some(requested_bytes)
+            })
+            .await
+            {
+                Ok(selected_bytes) => selected_bytes,
+                Err(err) => {
+                    tracing::warn!(
+                        requested_bytes,
+                        err = ?err,
+                        "owner slot pressure Moka selection task failed"
+                    );
+                    continue;
+                }
+            };
+            last_kick_at = Some(Instant::now());
+            tracing::debug!(
+                requested_bytes,
+                selected_bytes,
+                "owner slot pressure selected bounded source-eviction candidates"
+            );
+        }
+    });
+}
+
 pub async fn wait_owner_local_reserve_ready(
     inner: &ClientKvApiInner,
     slot_size: u64,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index 898172b..d5843c4 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -1,5 +1,7 @@
 use crate::client_kv_api::delete::handle_batch_delete_client_kv_meta_cache;
-use crate::client_kv_api::local_reserve_rebalance::spawn_owner_local_reserve_rebalance_actor;
+use crate::client_kv_api::local_reserve_rebalance::{
+    spawn_owner_local_reserve_rebalance_actor, spawn_owner_slot_pressure_actor,
+};
 use crate::client_kv_api::msg_pack::{
     ExternalBatchGetCancelReq, ExternalBatchGetCancelResp, ExternalBatchGetReq,
     ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
@@ -18,10 +20,11 @@ use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::config::TestSpecConfig;
 use crate::master_kv_router::msg_pack::{
     BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
-    BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartItemResp, BatchGetStartReq, BatchIsExistReq,
-    BatchOwnerReclaimReq, BatchPreparePutKeysReq, BatchPutDoneReq, BatchPutRevokeReq,
-    BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq,
-    DeleteClientKvMetaCacheItem, GroupedBatchPutDoneReq,
+    BatchEvictOwnerSourceReq, BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartItemResp,
+    BatchGetStartReq, BatchIsExistReq, BatchOwnerReclaimReq, BatchPreparePutKeysReq,
+    BatchPutAppendDoneReq, BatchPutAppendStartReq, BatchPutDoneReq, BatchPutRevokeReq,
+    BatchPutStartReq, BatchReleasePutKeyReservationsReq, DeleteClientKvMetaCacheItem,
+    GroupedBatchPutDoneReq,
 };
 use crate::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
 use crate::memholder::{AllMemholderRefCount, ExternalMemHolderInfo, MemoryInfo, UserMemHolder};
@@ -32,14 +35,11 @@ use crate::memholder::{
 use crate::{
     client_seg_pool::{ClientSegPool, ClientSegPoolAccessTrait, ResolveSideTransferLaneReq},
     client_transfer_engine::{ClientTransferEngine, ClientTransferEngineAccessTrait},
-    cluster_manager::{
-        ClusterEvent, ClusterManager, ClusterManagerAccessTrait,
-        app_logic_ext::{ClusterManagerAppLogicExt, ClusterManagerExtError},
-    },
+    cluster_manager::{ClusterEvent, ClusterManager, ClusterManagerAccessTrait},
     master_kv_router::msg_pack::{
-        DeleteAckReq, DeleteReq, GetDoneReq, GetMetaReq, GetRevokeReq, GetStartReq,
-        MemHolderKeepAliveReq, PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq, PutDoneReq,
-        PutRevokeReq, PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq,
+        DeleteReq, GetDoneReq, GetMetaReq, GetRevokeReq, GetStartReq, PutAppendDoneReq,
+        PutAppendRevokeReq, PutAppendStartReq, PutDoneReq, PutRevokeReq, PutStartReq,
+        ReleaseLocalGrantReq, ReserveLocalGrantReq,
     },
     metric_reporter::{MetricReporter, MetricReporterAccessTrait},
     metrics::{KvLocalitySnapshot, MetricsHandle, OperationKind, RequestStage},
@@ -50,17 +50,16 @@ use crate::{
     rpcresp_kvresult_convert::msg_and_error::{ApiError, ErrorCode, KvError, KvResult},
 };
 use async_trait::async_trait;
-use crossbeam::queue::SegQueue;
-use dashmap::{DashMap, DashSet};
+use dashmap::DashMap;
 use fluxon_framework::{LogicalModule, define_module};
-use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 use fluxon_util::map_lock::AMapLock;
 use limit_thirdparty::tokio;
 use moka::notification::RemovalCause;
 use moka::ops::compute::Op as MokaComputeOp;
-use parking_lot::{Mutex, RwLock};
+use parking_lot::Mutex;
+use std::collections::BTreeSet;
 use std::collections::HashMap;
-use std::collections::HashSet;
+use std::hash::{Hash, Hasher};
 use std::sync::Weak;
 use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, OnceLock};
@@ -71,7 +70,6 @@ const REPLICA_TASK_QUEUE_CAPACITY: usize = 128;
 // Queue only weak source references. This preserves a deep policy backlog without turning queued
 // write-back work into non-reclaimable owner memory; the dispatcher pins a still-current source
 // immediately before handing it to the bounded replica-task actor.
-const OWNER_HOT_EVICTION_QUEUE_CAPACITY: usize = 4096;
 const OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY: usize = 4096;
 const OWNER_LOCAL_PUBLISH_MAX_INFLIGHT: usize = 64;
 
@@ -80,6 +78,10 @@ const OWNER_LOCAL_PUBLISH_MAX_INFLIGHT: usize = 64;
 pub struct ExternalHoldingGetInfo {
     pub key: String,
     pub req_node_id: String,
+    /// Requester membership generation observed when this holding was
+    /// installed. Unknown generations are never removed by generation-scoped
+    /// MemberLeft cleanup.
+    pub requester_node_start_time: Option<i64>,
     pub memory_info: Arc<MemoryInfo>, // The actual memholder being held
 }
 
@@ -87,25 +89,35 @@ pub struct ExternalHoldingGetInfo {
 pub struct OwnerRuntimeObserveSnapshot {
     pub external_get_holding_entries: u64,
     pub external_get_holding_bytes: u64,
+    pub external_get_start_handles: u64,
+    pub external_get_flights: u64,
+    pub external_get_flights_starting: u64,
+    pub external_get_flights_finishing: u64,
+    pub external_get_flights_revoking: u64,
+    pub external_get_undecided_interests: u64,
+    pub external_get_retained_interests: u64,
     pub external_pending_put_entries: u64,
+    pub local_reserve_slots_free: u64,
+    pub local_reserve_slots_prepared: u64,
+    pub local_reserve_slots_pending_visible: u64,
+    pub local_reserve_slots_committed: u64,
     pub hot_cache_capacity_bytes: u64,
     pub hot_cache_entries: u64,
     pub hot_cache_weighted_bytes: u64,
     pub hot_size_evictions: u64,
-    pub hot_replica_enqueued: u64,
-    pub hot_replica_completed: u64,
-    pub hot_replica_already_satisfied: u64,
-    pub hot_replica_failed: u64,
-    pub hot_replica_obsolete: u64,
-    pub hot_replica_dispatch_failed: u64,
-    pub hot_replica_inflight: u64,
+    pub hot_source_evict_handoff_members: u64,
+    pub hot_source_evict_committed_members: u64,
+    pub hot_source_evict_restored_members: u64,
+    pub hot_source_evict_obsolete: u64,
+    pub hot_source_evict_dispatch_failed: u64,
+    pub hot_source_eviction_selected: u64,
+    pub hot_source_evict_retry_entries: u64,
+    pub hot_source_evict_retry_scheduled: u64,
+    pub hot_source_evict_retry_emitted: u64,
+    pub hot_selection_debt_bytes: u64,
     pub hot_eviction_skipped_stale: u64,
     pub hot_eviction_skipped_reclaim: u64,
-    pub hot_eviction_skipped_duplicate: u64,
     pub hot_group_registry_entries: u64,
-    pub hot_group_replica_triggered: u64,
-    pub hot_group_replica_triggers: u64,
-    pub hot_group_members_enqueued: u64,
     pub hot_group_trigger_duplicates: u64,
     pub hot_group_trigger_incomplete: u64,
     pub grouped_put_done_batches: u64,
@@ -125,52 +137,94 @@ pub type ExternalGetStartTransferOutput =
     Vec<KvResult<Option<(Arc<UserMemHolder>, Option<RemoteGetInfo>)>>>;
 
 pub enum ExternalGetStartOwnerItem {
-    Local {
-        memory_info: Arc<MemoryInfo>,
-    },
-    Started {
-        key: String,
-        item: BatchGetStartItemResp,
-    },
+    Local { memory_info: Arc<MemoryInfo> },
+    Shared { interest: ExternalGetKeyInterest },
 }
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub struct ExternalGetStartDedupKey {
-    pub keys: Vec<String>,
-    pub atomic_group_lens: Vec<usize>,
-    pub prefix_best_effort: bool,
+/// One request's interest in a per-key Get flight.
+///
+/// A pending prefix decision is owned by this guard, not by control flow.  If
+/// the request future is cancelled at any await point, Drop retires the
+/// undecided count so the cohort task can still choose Finish or Revoke.
+pub struct ExternalGetKeyInterest {
+    op: Arc<ExternalGetKeySharedOp>,
+    decision_pending: bool,
 }
 
-#[derive(Clone, Debug)]
-pub struct ExternalGetStartPrefixResult {
-    pub raw_prefix_hit_len: usize,
-    pub transferable_len: usize,
-    pub first_miss_index: Option<usize>,
-    pub first_error_kind: Option<String>,
+impl ExternalGetKeyInterest {
+    pub fn new(op: Arc<ExternalGetKeySharedOp>, decision_pending: bool) -> Self {
+        Self {
+            op,
+            decision_pending,
+        }
+    }
+
+    pub fn op(&self) -> &Arc<ExternalGetKeySharedOp> {
+        &self.op
+    }
+
+    pub fn decide(&mut self, retain: bool) {
+        if !self.decision_pending {
+            return;
+        }
+        self.decision_pending = false;
+
+        let wake = {
+            let mut state = self.op.state.lock();
+            if state.undecided == 0 {
+                tracing::error!(
+                    "external Get interest observed undecided underflow: key={}",
+                    self.op.key
+                );
+                return;
+            }
+            state.undecided -= 1;
+            if retain
+                && matches!(
+                    state.phase,
+                    ExternalGetKeySharedPhase::Starting | ExternalGetKeySharedPhase::Started { .. }
+                )
+            {
+                state.retained = state
+                    .retained
+                    .checked_add(1)
+                    .expect("external Get singleflight retained overflow");
+            }
+            state.undecided == 0
+        };
+        if wake {
+            self.op.notify.notify_waiters();
+        }
+    }
 }
 
-#[derive(Clone)]
-pub enum ExternalGetStartSharedItemResult {
-    Hit {
-        memholder: Arc<UserMemHolder>,
-    },
-    Miss,
-    Error {
-        error_code: ErrorCode,
-        error_json: String,
-    },
+impl Drop for ExternalGetKeyInterest {
+    fn drop(&mut self) {
+        self.decide(false);
+    }
 }
 
-pub enum ExternalGetStartSharedPhase {
+#[derive(Clone)]
+pub enum ExternalGetKeySharedPhase {
     Starting,
-    Running {
-        prefix: ExternalGetStartPrefixResult,
-        keys: Vec<String>,
+    Started {
+        item: BatchGetStartItemResp,
+    },
+    /// At least one request plan's prefix retained this key.  The leader cohort is
+    /// transferring/completing it and later publishes one canonical result.
+    Finishing {
+        item: BatchGetStartItemResp,
+    },
+    /// No request plan's prefix retained this prepared Get.  Keep the marker in
+    /// the owner key fence until BatchGetRevoke and local-slot release finish,
+    /// so a new overlapping batch cannot race the revoke.
+    Revoking {
+        /// Keep the exact master operation and prepared target reachable until
+        /// Revoke reaches a definite terminal response.
+        item: BatchGetStartItemResp,
     },
     Ready {
-        prefix: ExternalGetStartPrefixResult,
-        keys: Vec<String>,
-        items: Vec<ExternalGetStartSharedItemResult>,
+        result: ExternalGetStartSharedItemResult,
     },
     Failed {
         error_code: ErrorCode,
@@ -178,38 +232,64 @@ pub enum ExternalGetStartSharedPhase {
     },
 }
 
-pub struct ExternalGetStartSharedState {
-    pub waiter_count: usize,
-    pub phase: ExternalGetStartSharedPhase,
+pub struct ExternalGetKeySharedState {
+    /// Exact-batch operations which joined while the key was Starting/Started
+    /// and have not yet applied their own atomic-prefix decision.
+    pub undecided: usize,
+    /// Number of those operations whose transferable prefix retained the key.
+    pub retained: usize,
+    pub phase: ExternalGetKeySharedPhase,
 }
 
-pub struct ExternalGetStartSharedOp {
-    pub dedup_key: ExternalGetStartDedupKey,
-    pub transfer_concurrency: usize,
-    /// Set only when every requested page is already owner-local.
-    pub inline_local_memory_infos: OnceLock<Vec<Arc<MemoryInfo>>>,
-    pub state: Mutex<ExternalGetStartSharedState>,
+pub struct ExternalGetKeySharedOp {
+    pub key: String,
+    pub state: Mutex<ExternalGetKeySharedState>,
     pub notify: Arc<limit_thirdparty::tokio::sync::Notify>,
 }
 
-impl ExternalGetStartSharedOp {
-    pub fn new(dedup_key: ExternalGetStartDedupKey, transfer_concurrency: usize) -> Self {
+impl ExternalGetKeySharedOp {
+    pub fn new(key: String) -> Self {
         Self {
-            dedup_key,
-            transfer_concurrency,
-            inline_local_memory_infos: OnceLock::new(),
-            state: Mutex::new(ExternalGetStartSharedState {
-                waiter_count: 1,
-                phase: ExternalGetStartSharedPhase::Starting,
+            key,
+            state: Mutex::new(ExternalGetKeySharedState {
+                undecided: 1,
+                retained: 0,
+                phase: ExternalGetKeySharedPhase::Starting,
             }),
             notify: Arc::new(limit_thirdparty::tokio::sync::Notify::new()),
         }
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct ExternalGetStartPrefixResult {
+    pub raw_prefix_hit_len: usize,
+    pub transferable_len: usize,
+    pub first_miss_index: Option<usize>,
+    pub first_error_kind: Option<String>,
+}
+
+#[derive(Clone)]
+pub enum ExternalGetStartSharedItemResult {
+    Hit {
+        memholder: Arc<UserMemHolder>,
+    },
+    Miss,
+    Error {
+        error_code: ErrorCode,
+        error_json: String,
+    },
+}
+
 pub struct ExternalGetStartEntry {
     pub req_node_id: String,
-    pub shared_op: Arc<ExternalGetStartSharedOp>,
+    /// Requester membership generation observed when this handle was created.
+    /// `None` is retained only for compatibility with a temporarily incomplete
+    /// cluster cache; generation cleanup must never guess in that case.
+    pub requester_node_start_time: Option<i64>,
+    pub keys: Vec<String>,
+    pub items: Vec<ExternalGetStartOwnerItem>,
+    pub created_at: Instant,
 }
 
 /// Optional arguments for put operations
@@ -1133,6 +1213,13 @@ pub struct PrecommitLocalVisibleInfo {
     mem_holder: Arc<MemoryInfo>,
 }
 
+#[derive(Debug)]
+pub(crate) struct PendingLocalGetInfo {
+    get_id: u64,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    mem_holder: Arc<MemoryInfo>,
+}
+
 #[derive(Debug)]
 pub(crate) struct LocalSnapshotInfo {
     put_time_ms: u64,
@@ -1146,8 +1233,8 @@ struct OwnerHotCacheEntry {
     weight_bytes: u32,
 }
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-struct OwnerHotReplicaIdentity {
+#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) struct OwnerHotReplicaIdentity {
     key: String,
     put_time_ms: u64,
     put_version: u32,
@@ -1166,17 +1253,16 @@ impl OwnerHotReplicaIdentity {
 #[derive(Default)]
 struct OwnerHotCacheCounters {
     size_evictions: AtomicU64,
-    replica_enqueued: AtomicU64,
-    replica_completed: AtomicU64,
-    replica_already_satisfied: AtomicU64,
-    replica_failed: AtomicU64,
-    replica_obsolete: AtomicU64,
-    replica_dispatch_failed: AtomicU64,
+    source_evict_handoff_members: AtomicU64,
+    source_evict_committed_members: AtomicU64,
+    source_evict_restored_members: AtomicU64,
+    source_evict_obsolete: AtomicU64,
+    source_evict_dispatch_failed: AtomicU64,
+    source_evict_retry_scheduled: AtomicU64,
+    source_evict_retry_emitted: AtomicU64,
+    selection_debt_bytes: Arc<AtomicU64>,
     skipped_stale: AtomicU64,
     skipped_reclaim: AtomicU64,
-    skipped_duplicate: AtomicU64,
-    group_replica_triggers: AtomicU64,
-    group_members_enqueued: AtomicU64,
     group_trigger_duplicates: AtomicU64,
     group_trigger_incomplete: AtomicU64,
     grouped_put_done_batches: AtomicU64,
@@ -1185,128 +1271,224 @@ struct OwnerHotCacheCounters {
     legacy_put_done_items: AtomicU64,
 }
 
-const OWNER_HOT_REPLICA_OUTCOME_PENDING: u32 = 0;
-const OWNER_HOT_REPLICA_OUTCOME_RECORDED: u32 = 1;
+struct OwnerHotSelectionDebt {
+    weight_bytes: u64,
+    outstanding_bytes: Arc<AtomicU64>,
+    released: AtomicU32,
+}
+
+impl OwnerHotSelectionDebt {
+    fn new(weight_bytes: u64, outstanding_bytes: Arc<AtomicU64>) -> Arc<Self> {
+        outstanding_bytes.fetch_add(weight_bytes, Ordering::AcqRel);
+        Arc::new(Self {
+            weight_bytes,
+            outstanding_bytes,
+            released: AtomicU32::new(0),
+        })
+    }
+
+    fn release(&self) {
+        if self
+            .released
+            .compare_exchange(0, 1, Ordering::AcqRel, Ordering::Acquire)
+            .is_ok()
+        {
+            self.outstanding_bytes
+                .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
+                    Some(current.saturating_sub(self.weight_bytes))
+                })
+                .expect("owner hot selection debt update cannot fail");
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct OwnerHotEvictionEvent {
+    key: String,
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    memory_info: Weak<MemoryInfo>,
+    selection_debt: Arc<OwnerHotSelectionDebt>,
+    /// Retry events already own one exact source-delete cohort.
+    retry: bool,
+    /// Exact owner source-delete cohort retained across RPC retries. Once set,
+    /// retries never re-expand or re-pin the local cohort.
+    source_eviction_cohort:
+        Option<Arc<crate::master_kv_router::msg_pack::OwnerSourceEvictionCohort>>,
+    /// Failure count follows the event while it is dispatched, preserving
+    /// exponential backoff across queue take/reinsert cycles.
+    retry_failures: u32,
+}
+
+pub(crate) enum OwnerHotEvictionPreparation {
+    Ready {
+        trigger: OwnerHotReplicaIdentity,
+        sources: Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>,
+    },
+    RetryableReclaimFence,
+    RetryableIncompleteCohort,
+    Obsolete,
+}
+
+struct OwnerHotRetryEntry {
+    event: OwnerHotEvictionEvent,
+    failures: u32,
+    next_attempt_at: Instant,
+    dispatched: bool,
+}
+
+#[derive(Default)]
+struct OwnerHotRetryState {
+    entries: HashMap<OwnerHotReplicaIdentity, OwnerHotRetryEntry>,
+    /// Exactly one deadline for each non-dispatched entry.  Unlike a lazy
+    /// generation heap, rescheduling replaces the old tuple, so both memory
+    /// and lock-held work are bounded by the live retry set, not its history.
+    deadlines: BTreeSet<(Instant, OwnerHotReplicaIdentity)>,
+}
 
-pub(crate) struct OwnerHotReplicaGuard {
-    identity: OwnerHotReplicaIdentity,
-    inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
+/// Exactly-once owner-local retry state.  It is physically bounded by the
+/// owner committed-slot pool: one identity can occupy at most one entry, and
+/// obsolete identities are removed when their local version is invalidated.
+/// The actor emits only a small due batch and applies exponential backoff.
+struct OwnerHotRetryQueue {
+    state: Mutex<OwnerHotRetryState>,
+    notify: Arc<limit_thirdparty::tokio::sync::Notify>,
     counters: Arc<OwnerHotCacheCounters>,
-    group_trigger: Option<OwnerHotReplicaIdentity>,
-    group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
-    outcome: AtomicU32,
 }
 
-impl OwnerHotReplicaGuard {
-    fn new(
-        identity: OwnerHotReplicaIdentity,
-        inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
-        counters: Arc<OwnerHotCacheCounters>,
-        group_trigger: Option<OwnerHotReplicaIdentity>,
-        group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
-    ) -> Self {
+impl OwnerHotRetryQueue {
+    fn new(counters: Arc<OwnerHotCacheCounters>) -> Self {
         Self {
-            identity,
-            inflight,
+            state: Mutex::new(OwnerHotRetryState::default()),
+            notify: Arc::new(limit_thirdparty::tokio::sync::Notify::new()),
             counters,
-            group_trigger,
-            group_replica_triggered,
-            outcome: AtomicU32::new(OWNER_HOT_REPLICA_OUTCOME_PENDING),
         }
     }
 
-    fn release_group_trigger(&self) {
-        if let Some(group_trigger) = self.group_trigger.as_ref() {
-            self.group_replica_triggered.remove(group_trigger);
-        }
+    fn retry_delay(failures: u32) -> Duration {
+        let shift = failures.saturating_sub(1).min(8);
+        Duration::from_millis(25u64.saturating_mul(1u64 << shift)).min(Duration::from_secs(5))
     }
 
-    pub(crate) fn mark_completed(&self) {
-        if self
-            .outcome
-            .compare_exchange(
-                OWNER_HOT_REPLICA_OUTCOME_PENDING,
-                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            )
-            .is_ok()
-        {
-            self.counters
-                .replica_completed
-                .fetch_add(1, Ordering::Relaxed);
+    fn schedule(&self, mut event: OwnerHotEvictionEvent, reason: &'static str) {
+        let identity = OwnerHotReplicaIdentity {
+            key: event.key.clone(),
+            put_time_ms: event.put_id.0,
+            put_version: event.put_id.1,
+        };
+        let now = Instant::now();
+        let mut state = self.state.lock();
+        let previous_deadline = state
+            .entries
+            .get(&identity)
+            .and_then(|entry| (!entry.dispatched).then_some(entry.next_attempt_at));
+        if let Some(previous_deadline) = previous_deadline {
+            state
+                .deadlines
+                .remove(&(previous_deadline, identity.clone()));
         }
-    }
-
-    pub(crate) fn mark_already_satisfied(&self) {
-        if self
-            .outcome
-            .compare_exchange(
-                OWNER_HOT_REPLICA_OUTCOME_PENDING,
-                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            )
-            .is_ok()
-        {
-            self.counters
-                .replica_already_satisfied
-                .fetch_add(1, Ordering::Relaxed);
+        let entry = state
+            .entries
+            .entry(identity.clone())
+            .or_insert_with(|| OwnerHotRetryEntry {
+                event: event.clone(),
+                failures: event.retry_failures,
+                next_attempt_at: now,
+                dispatched: false,
+            });
+        if !Arc::ptr_eq(&entry.event.selection_debt, &event.selection_debt) {
+            entry.event.selection_debt.release();
         }
+        if event.source_eviction_cohort.is_none() {
+            event.source_eviction_cohort = entry.event.source_eviction_cohort.clone();
+        }
+        entry.failures = entry.failures.max(event.retry_failures).saturating_add(1);
+        event.retry = true;
+        event.retry_failures = entry.failures;
+        entry.event = event;
+        entry.next_attempt_at = now + Self::retry_delay(entry.failures);
+        entry.dispatched = false;
+        let next_attempt_at = entry.next_attempt_at;
+        let inserted = state.deadlines.insert((next_attempt_at, identity.clone()));
+        debug_assert!(inserted, "owner retry deadline must be unique per identity");
+        drop(state);
+        self.counters
+            .source_evict_retry_scheduled
+            .fetch_add(1, Ordering::Relaxed);
+        tracing::debug!(
+            key = identity.key,
+            put_time_ms = identity.put_time_ms,
+            put_version = identity.put_version,
+            reason,
+            "owner writeback entered retryable local state"
+        );
+        self.notify.notify_waiters();
     }
 
-    pub(crate) fn mark_obsolete(&self) {
-        if self
-            .outcome
-            .compare_exchange(
-                OWNER_HOT_REPLICA_OUTCOME_PENDING,
-                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            )
-            .is_ok()
-        {
-            self.counters
-                .replica_obsolete
-                .fetch_add(1, Ordering::Relaxed);
-            self.release_group_trigger();
+    fn take_due_batch(&self, now: Instant, limit: usize) -> Vec<OwnerHotEvictionEvent> {
+        let mut state = self.state.lock();
+        let mut due = Vec::with_capacity(limit);
+        while due.len() < limit {
+            let Some((deadline, identity)) = state.deadlines.iter().next().cloned() else {
+                break;
+            };
+            if deadline > now {
+                break;
+            }
+            state.deadlines.remove(&(deadline, identity.clone()));
+            let Some(entry) = state.entries.get_mut(&identity) else {
+                debug_assert!(false, "owner retry deadline must reference a live entry");
+                continue;
+            };
+            if entry.dispatched || entry.next_attempt_at != deadline {
+                debug_assert!(false, "owner retry deadline and entry must agree");
+                continue;
+            }
+            due.push(entry.event.clone());
+            // Keep the authoritative retry record until the dispatcher has
+            // atomically pinned the source and installed an inflight guard,
+            // but emit it only once. A failed dispatcher attempt explicitly
+            // reschedules it with the next backoff.
+            entry.dispatched = true;
         }
+        due
     }
 
-    fn mark_dispatch_failed(&self) {
-        if self
-            .outcome
-            .compare_exchange(
-                OWNER_HOT_REPLICA_OUTCOME_PENDING,
-                OWNER_HOT_REPLICA_OUTCOME_RECORDED,
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            )
-            .is_ok()
-        {
-            self.counters
-                .replica_dispatch_failed
-                .fetch_add(1, Ordering::Relaxed);
-            self.release_group_trigger();
+    fn remove(&self, identity: &OwnerHotReplicaIdentity) {
+        let entry = {
+            let mut state = self.state.lock();
+            let entry = state.entries.remove(identity);
+            if let Some(entry) = entry.as_ref()
+                && !entry.dispatched
+            {
+                state
+                    .deadlines
+                    .remove(&(entry.next_attempt_at, identity.clone()));
+            }
+            entry
+        };
+        if let Some(entry) = entry {
+            entry.event.selection_debt.release();
         }
     }
-}
 
-impl Drop for OwnerHotReplicaGuard {
-    fn drop(&mut self) {
-        if self.outcome.load(Ordering::Relaxed) == OWNER_HOT_REPLICA_OUTCOME_PENDING {
-            self.counters.replica_failed.fetch_add(1, Ordering::Relaxed);
-            self.release_group_trigger();
+    fn take_for_inflight(
+        &self,
+        identity: &OwnerHotReplicaIdentity,
+    ) -> Option<OwnerHotEvictionEvent> {
+        // The inflight guard takes over the same debt token; do not release it.
+        let mut state = self.state.lock();
+        let entry = state.entries.remove(identity)?;
+        if !entry.dispatched {
+            state
+                .deadlines
+                .remove(&(entry.next_attempt_at, identity.clone()));
         }
-        self.inflight.remove(&self.identity);
+        Some(entry.event)
     }
-}
 
-pub(crate) struct OwnerHotEvictionEvent {
-    key: String,
-    put_id: crate::master_kv_router::put::PutIDForAKey,
-    memory_info: Weak<MemoryInfo>,
-    guard: OwnerHotReplicaGuard,
+    fn len(&self) -> usize {
+        self.state.lock().entries.len()
+    }
 }
 
 pub(crate) struct OwnerPreparedReclaim {
@@ -1317,32 +1499,237 @@ pub(crate) struct OwnerPreparedReclaim {
 
 pub(crate) enum OwnerReclaimRecord {
     Prepared(OwnerPreparedReclaim),
+    /// The local index is fenced and the Commit handler owns the detached
+    /// backing while it updates the slot pool. Keeping this marker in the
+    /// per-key table lets that O(1) pool update happen without nesting the
+    /// pool mutex under the key-shard mutex.
+    Releasing(crate::master_kv_router::msg_pack::OwnerReclaimItem),
     Committed(crate::master_kv_router::msg_pack::OwnerReclaimItem),
 }
 
 #[derive(Default)]
 pub(crate) struct OwnerKeyControlState {
     local_puts: u32,
+    /// External Put contexts that may still expose or commit owner-local
+    /// backing for this key.  This counter is maintained by an Arc-backed
+    /// guard stored in every context, so cache invalidation cannot clear the
+    /// reclaim fence while a cloned context is still in use.
+    external_pending_puts: u32,
     reclaim: Option<OwnerReclaimRecord>,
+    /// Per-key owner-side Get singleflight marker.  It deliberately lives in
+    /// the same fence as local visibility and reclaim so `R ∩ local`,
+    /// `R ∩ inflight`, and new leaders are classified atomically.
+    external_get: Option<Arc<ExternalGetKeySharedOp>>,
 }
 
-fn resolve_local_visible_batch<T>(
-    keys: &[String],
-    controls: &HashMap<String, OwnerKeyControlState>,
-    mut resolve_unfenced: impl FnMut(&str) -> Option<T>,
-) -> Vec<Option<T>> {
-    keys.iter()
-        .map(|key| {
-            if controls
-                .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
-            {
-                None
-            } else {
-                resolve_unfenced(key)
+impl OwnerKeyControlState {
+    fn is_idle(&self) -> bool {
+        self.local_puts == 0
+            && self.external_pending_puts == 0
+            && self.reclaim.is_none()
+            && self.external_get.is_none()
+    }
+}
+
+const OWNER_KEY_CONTROL_SHARDS: usize = 256;
+
+/// Per-key owner fencing without a process-wide mutex.
+///
+/// Every operation for one key hashes to the same shard, so local index
+/// publication, Get singleflight registration, and reclaim remain linearized.
+/// Callers must hold a shard only for one key and must not await, perform RPC,
+/// or walk a request batch while holding it.  Unrelated keys normally proceed
+/// on independent shards; a hash collision only adds a short O(1) critical
+/// section and does not change correctness.
+pub(crate) struct OwnerKeyControlTable {
+    shards: Box<[Mutex<HashMap<String, OwnerKeyControlState>>]>,
+}
+
+impl Default for OwnerKeyControlTable {
+    fn default() -> Self {
+        Self {
+            shards: (0..OWNER_KEY_CONTROL_SHARDS)
+                .map(|_| Mutex::new(HashMap::new()))
+                .collect(),
+        }
+    }
+}
+
+impl OwnerKeyControlTable {
+    fn shard_index(key: &str) -> usize {
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        key.hash(&mut hasher);
+        (hasher.finish() as usize) % OWNER_KEY_CONTROL_SHARDS
+    }
+
+    pub(crate) fn lock_key(
+        &self,
+        key: &str,
+    ) -> parking_lot::MutexGuard<'_, HashMap<String, OwnerKeyControlState>> {
+        self.shards[Self::shard_index(key)].lock()
+    }
+}
+
+pub(crate) struct ExternalPendingPutFenceGuard {
+    key: String,
+    owner_key_control: Arc<OwnerKeyControlTable>,
+    owns_local_put: bool,
+    local_slot_cleanup_view: Option<ClientKvApiView>,
+    local_slot_lease: Mutex<Option<OwnerLocalReserveSlotLease>>,
+    local_slot_release_failed: std::sync::atomic::AtomicBool,
+}
+
+impl std::fmt::Debug for ExternalPendingPutFenceGuard {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter
+            .debug_struct("ExternalPendingPutFenceGuard")
+            .field("key", &self.key)
+            .field("owns_local_put", &self.owns_local_put)
+            .finish_non_exhaustive()
+    }
+}
+
+impl ExternalPendingPutFenceGuard {
+    pub(crate) fn attach_local_slot_lease(&self, lease: OwnerLocalReserveSlotLease) {
+        assert!(
+            self.owns_local_put,
+            "only local-first Put owns a slot lease"
+        );
+        assert_eq!(
+            lease.slots.len(),
+            1,
+            "a pending local-first Put fence must own exactly one slot"
+        );
+        let mut current = self.local_slot_lease.lock();
+        assert!(
+            current.is_none(),
+            "a pending local-first Put fence cannot replace its slot lease"
+        );
+        *current = Some(lease);
+    }
+
+    /// Transfer the prepared slot to the precommit/committed MemoryInfo.  Once
+    /// disarmed, dropping the pending context must not return that resident slot
+    /// to the free list.
+    pub(crate) fn disarm_local_slot_lease(&self) {
+        assert!(
+            self.local_slot_lease.lock().take().is_some(),
+            "pending local-first Put slot lease is absent while committing"
+        );
+    }
+
+    pub(crate) async fn release_local_slot_lease_now(
+        &self,
+        inner: &ClientKvApiInner,
+    ) -> KvResult<()> {
+        let lease = self.local_slot_lease.lock().take();
+        if let Some(lease) = lease {
+            if let Err(err) = inner.owner_release_local_reserve_slot_lease(lease).await {
+                // The lease object has been consumed and the physical state is
+                // now uncertain.  Keep the per-key fence permanently rather
+                // than allow reclaim to cross a possibly-live prepared slot.
+                self.local_slot_release_failed
+                    .store(true, Ordering::Release);
+                return Err(err);
             }
-        })
-        .collect()
+        }
+        Ok(())
+    }
+}
+
+fn release_external_pending_put_counts(
+    owner_key_control: &Arc<OwnerKeyControlTable>,
+    key: &str,
+    owns_local_put: bool,
+) {
+    let mut controls = owner_key_control.lock_key(key);
+    let remove = {
+        let state = controls
+            .get_mut(key)
+            .expect("external pending Put fence state missing on release");
+        state.external_pending_puts = state
+            .external_pending_puts
+            .checked_sub(1)
+            .expect("external pending Put fence counter underflow");
+        if owns_local_put {
+            state.local_puts = state
+                .local_puts
+                .checked_sub(1)
+                .expect("owner local-first Put fence counter underflow");
+        }
+        state.is_idle()
+    };
+    if remove {
+        controls.remove(key);
+    }
+}
+
+fn acquire_external_pending_put_fence_for_key(
+    owner_key_control: &Arc<OwnerKeyControlTable>,
+    key: &str,
+) -> KvResult<Arc<ExternalPendingPutFenceGuard>> {
+    let mut controls = owner_key_control.lock_key(key);
+    if controls
+        .get(key)
+        .is_some_and(|state| state.reclaim.is_some())
+    {
+        return Err(KvError::Api(ApiError::KeyBeingWritten {
+            key: key.to_string(),
+        }));
+    }
+    let state = controls.entry(key.to_string()).or_default();
+    state.external_pending_puts = state
+        .external_pending_puts
+        .checked_add(1)
+        .expect("external pending Put fence counter overflow");
+    Ok(Arc::new(ExternalPendingPutFenceGuard {
+        key: key.to_string(),
+        owner_key_control: owner_key_control.clone(),
+        owns_local_put: false,
+        local_slot_cleanup_view: None,
+        local_slot_lease: Mutex::new(None),
+        local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+    }))
+}
+
+impl Drop for ExternalPendingPutFenceGuard {
+    fn drop(&mut self) {
+        let abandoned_slot_lease = self.local_slot_lease.get_mut().take();
+        if let Some(lease) = abandoned_slot_lease {
+            let view = self
+                .local_slot_cleanup_view
+                .as_ref()
+                .expect("local-first Put slot cleanup requires an attached owner view")
+                .clone();
+            let worker_view = view.clone();
+            let key = self.key.clone();
+            let owner_key_control = self.owner_key_control.clone();
+            let owns_local_put = self.owns_local_put;
+            view.spawn("external_pending_put_slot_drop_cleanup", async move {
+                if let Err(err) = worker_view
+                    .client_kv_api()
+                    .inner()
+                    .owner_release_local_reserve_slot_lease(lease)
+                    .await
+                {
+                    tracing::error!("pending local-first Put slot Drop cleanup failed: {}", err);
+                    return;
+                }
+                release_external_pending_put_counts(&owner_key_control, &key, owns_local_put);
+            });
+        } else if !self.local_slot_release_failed.load(Ordering::Acquire) {
+            release_external_pending_put_counts(
+                &self.owner_key_control,
+                &self.key,
+                self.owns_local_put,
+            );
+        } else {
+            tracing::error!(
+                "retaining pending Put fence after local slot release failure: key={}",
+                self.key
+            );
+        }
+    }
 }
 
 fn allocate_external_holding_id(counter: &AtomicU64) -> u64 {
@@ -1371,46 +1758,74 @@ fn clone_if_owner_hot_entry_matches<T>(
         .then(|| current.clone())
 }
 
-fn pin_current_owner_hot_source(
-    key: &str,
-    entry: &OwnerHotCacheEntry,
-    owner_key_control: &Mutex<HashMap<String, OwnerKeyControlState>>,
-    get_cached_info: &DashMap<String, GetCachedInfo>,
-    counters: &OwnerHotCacheCounters,
-) -> Option<Arc<MemoryInfo>> {
-    let controls = owner_key_control.lock();
-    if controls
-        .get(key)
-        .is_some_and(|state| state.reclaim.is_some())
-    {
-        counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
-        return None;
-    }
-    let Some(cached) = get_cached_info.get(key) else {
-        counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
-        return None;
+enum OwnerHotPinResult<T> {
+    Pinned(Arc<T>),
+    ReclaimBusy,
+    Stale,
+}
+
+fn pin_current_owner_hot_source_from_index<T>(
+    entry_put_id: crate::master_kv_router::put::PutIDForAKey,
+    entry: &Weak<T>,
+    resolve_current: impl FnOnce() -> Option<(crate::master_kv_router::put::PutIDForAKey, Arc<T>)>,
+) -> OwnerHotPinResult<T> {
+    let Some((current_put_id, current)) = resolve_current() else {
+        // Do not upgrade the listener's Weak after the local index has
+        // disappeared.  A reclaim Prepare may already own the sole Arc and
+        // Commit relies on that ownership.  A still-live Weak therefore means
+        // "retry after the transient owner transition"; a dead Weak is
+        // definitively obsolete.
+        return if entry.strong_count() == 0 {
+            OwnerHotPinResult::Stale
+        } else {
+            OwnerHotPinResult::ReclaimBusy
+        };
     };
-    let Some(pinned) = clone_if_owner_hot_entry_matches(
-        (cached.put_time_ms, cached.put_version),
-        &cached.mem_holder,
-        entry.put_id,
-        &entry.memory_info,
-    ) else {
-        counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
-        return None;
+    let Some(pinned) =
+        clone_if_owner_hot_entry_matches(current_put_id, &current, entry_put_id, entry)
+    else {
+        return OwnerHotPinResult::Stale;
     };
 
-    // This clone is made under the same key fence used by reclaim. If reclaim
-    // wins first the source is absent/fenced; if this clone wins, reclaim sees
-    // the additional strong reference and returns Busy.
-    Some(pinned)
+    // `resolve_current` clones from the DashMap entry while its shard read
+    // guard is held. Reclaim Prepare cannot remove that entry until the clone
+    // exists, and its strong-count check will consequently return Busy. This
+    // gives us the required per-key pin without the global owner-control lock.
+    Some(pinned).map_or(OwnerHotPinResult::Stale, OwnerHotPinResult::Pinned)
 }
 
-fn owner_hot_group_anchor_identity(
-    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
-) -> Option<OwnerHotReplicaIdentity> {
-    group
-        .members
+fn pin_current_owner_hot_source(
+    key: &str,
+    entry: &OwnerHotCacheEntry,
+    get_cached_info: &DashMap<String, GetCachedInfo>,
+    counters: &OwnerHotCacheCounters,
+) -> OwnerHotPinResult<MemoryInfo> {
+    let result = pin_current_owner_hot_source_from_index(entry.put_id, &entry.memory_info, || {
+        get_cached_info.get(key).map(|cached| {
+            (
+                (cached.put_time_ms, cached.put_version),
+                cached.mem_holder.clone(),
+            )
+        })
+    });
+    match result {
+        OwnerHotPinResult::Pinned(pinned) => OwnerHotPinResult::Pinned(pinned),
+        OwnerHotPinResult::ReclaimBusy => {
+            counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
+            OwnerHotPinResult::ReclaimBusy
+        }
+        OwnerHotPinResult::Stale => {
+            counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+            OwnerHotPinResult::Stale
+        }
+    }
+}
+
+fn owner_hot_group_anchor_identity(
+    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
+) -> Option<OwnerHotReplicaIdentity> {
+    group
+        .members
         .first()
         .map(OwnerHotReplicaIdentity::from_group_member)
 }
@@ -1454,7 +1869,6 @@ fn forget_owner_hot_atomic_group(
         OwnerHotReplicaIdentity,
         Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
     >,
-    group_replica_triggered: &DashSet<OwnerHotReplicaIdentity>,
     identity: &OwnerHotReplicaIdentity,
 ) {
     let group = atomic_groups
@@ -1463,9 +1877,6 @@ fn forget_owner_hot_atomic_group(
     let Some(group) = group else {
         return;
     };
-    if let Some(anchor) = owner_hot_group_anchor_identity(group.as_ref()) {
-        group_replica_triggered.remove(&anchor);
-    }
     for member in &group.members {
         atomic_groups.remove(&OwnerHotReplicaIdentity::from_group_member(member));
     }
@@ -1473,22 +1884,13 @@ fn forget_owner_hot_atomic_group(
 
 fn pin_current_owner_hot_group_sources(
     group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
-    owner_key_control: &Mutex<HashMap<String, OwnerKeyControlState>>,
     get_cached_info: &DashMap<String, GetCachedInfo>,
     counters: &OwnerHotCacheCounters,
 ) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
-    let controls = owner_key_control.lock();
     let mut sources = Vec::with_capacity(group.members.len());
     for member in &group.members {
-        if controls
-            .get(&member.key)
-            .is_some_and(|state| state.reclaim.is_some())
-        {
-            counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
-            return None;
-        }
         let Some(cached) = get_cached_info.get(&member.key) else {
-            counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+            counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
             return None;
         };
         if (cached.put_time_ms, cached.put_version) != member.put_id {
@@ -1555,7 +1957,6 @@ fn owner_hot_tp_cohort_key_rows(
 fn pin_current_owner_hot_tp_cohort_sources(
     cohort_key_rows: &[Vec<String>],
     expect_atomic_group: bool,
-    owner_key_control: &Mutex<HashMap<String, OwnerKeyControlState>>,
     get_cached_info: &DashMap<String, GetCachedInfo>,
     atomic_groups: &DashMap<
         OwnerHotReplicaIdentity,
@@ -1563,7 +1964,6 @@ fn pin_current_owner_hot_tp_cohort_sources(
     >,
     counters: &OwnerHotCacheCounters,
 ) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
-    let controls = owner_key_control.lock();
     let mut cohort_sources = Vec::new();
     for rank_keys in cohort_key_rows {
         if rank_keys.is_empty() {
@@ -1571,15 +1971,8 @@ fn pin_current_owner_hot_tp_cohort_sources(
         }
         let mut rank_sources = Vec::with_capacity(rank_keys.len());
         for key in rank_keys {
-            if controls
-                .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
-            {
-                counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
-                return None;
-            }
             let Some(cached) = get_cached_info.get(key) else {
-                counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
+                counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
                 return None;
             };
             rank_sources.push((
@@ -1625,61 +2018,11 @@ fn pin_current_owner_hot_tp_cohort_sources(
     Some(cohort_sources)
 }
 
-fn try_enqueue_owner_hot_replica_event(
-    identity: OwnerHotReplicaIdentity,
-    memory_info: Arc<MemoryInfo>,
-    group_trigger: Option<OwnerHotReplicaIdentity>,
-    inflight: &Arc<DashSet<OwnerHotReplicaIdentity>>,
-    group_replica_triggered: &Arc<DashSet<OwnerHotReplicaIdentity>>,
-    counters: &Arc<OwnerHotCacheCounters>,
-    eviction_tx: &tokio::sync::ampsc::Sender<OwnerHotEvictionEvent>,
-) -> bool {
-    if !inflight.insert(identity.clone()) {
-        counters.skipped_duplicate.fetch_add(1, Ordering::Relaxed);
-        return false;
-    }
-    let event = OwnerHotEvictionEvent {
-        key: identity.key.clone(),
-        put_id: (identity.put_time_ms, identity.put_version),
-        memory_info: Arc::downgrade(&memory_info),
-        guard: OwnerHotReplicaGuard::new(
-            identity,
-            inflight.clone(),
-            counters.clone(),
-            group_trigger,
-            group_replica_triggered.clone(),
-        ),
-    };
-    match eviction_tx.try_send(event) {
-        Ok(()) => {
-            counters.replica_enqueued.fetch_add(1, Ordering::Relaxed);
-            true
-        }
-        Err(err) => {
-            let event = err.into_inner();
-            tracing::warn!(
-                "owner hot-cache eviction actor is closed; replica event dropped: key={} put_id=({},{})",
-                event.key,
-                event.put_id.0,
-                event.put_id.1
-            );
-            event.guard.mark_dispatch_failed();
-            false
-        }
-    }
-}
-
 fn build_owner_hot_cache(
     capacity_bytes: u64,
-    owner_key_control: Arc<Mutex<HashMap<String, OwnerKeyControlState>>>,
-    get_cached_info: Arc<DashMap<String, GetCachedInfo>>,
-    inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
-    atomic_groups: Arc<
-        DashMap<OwnerHotReplicaIdentity, Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>>,
-    >,
-    group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
     counters: Arc<OwnerHotCacheCounters>,
-    eviction_tx: tokio::sync::ampsc::Sender<OwnerHotEvictionEvent>,
+    retry_queue: Arc<OwnerHotRetryQueue>,
+    eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionEvent>,
 ) -> moka::sync::Cache<String, OwnerHotCacheEntry> {
     assert!(
         capacity_bytes > 0,
@@ -1693,90 +2036,31 @@ fn build_owner_hot_cache(
                 return;
             }
             counters.size_evictions.fetch_add(1, Ordering::Relaxed);
-            let Some(memory_info) = pin_current_owner_hot_source(
-                key.as_str(),
-                &entry,
-                owner_key_control.as_ref(),
-                get_cached_info.as_ref(),
-                counters.as_ref(),
-            ) else {
-                return;
-            };
             let identity = OwnerHotReplicaIdentity {
                 key: (*key).clone(),
                 put_time_ms: entry.put_id.0,
                 put_version: entry.put_id.1,
             };
-            let group = atomic_groups
-                .get(&identity)
-                .map(|entry| entry.value().clone());
-            let cohort_sources = match owner_hot_tp_cohort_key_rows(&identity, group.as_deref()) {
-                Ok(Some(cohort_key_rows)) => pin_current_owner_hot_tp_cohort_sources(
-                    &cohort_key_rows,
-                    group.is_some(),
-                    owner_key_control.as_ref(),
-                    get_cached_info.as_ref(),
-                    atomic_groups.as_ref(),
-                    counters.as_ref(),
-                ),
-                Ok(None) => match group.as_deref() {
-                    Some(group) => pin_current_owner_hot_group_sources(
-                        group,
-                        owner_key_control.as_ref(),
-                        get_cached_info.as_ref(),
-                        counters.as_ref(),
-                    ),
-                    None => Some(vec![(identity.clone(), memory_info)]),
-                },
-                Err(()) => None,
-            };
-            let Some(cohort_sources) = cohort_sources else {
-                counters
-                    .group_trigger_incomplete
-                    .fetch_add(1, Ordering::Relaxed);
-                return;
+            let selection_debt = OwnerHotSelectionDebt::new(
+                u64::from(entry.weight_bytes),
+                counters.selection_debt_bytes.clone(),
+            );
+            let event = OwnerHotEvictionEvent {
+                key: identity.key.clone(),
+                put_id: entry.put_id,
+                memory_info: entry.memory_info.clone(),
+                selection_debt,
+                retry: false,
+                source_eviction_cohort: None,
+                retry_failures: 0,
             };
-            if cohort_sources.len() > 1 {
+            if let Err(err) = eviction_tx.send(event) {
+                let event = err.0;
                 counters
-                    .group_replica_triggers
+                    .source_evict_dispatch_failed
                     .fetch_add(1, Ordering::Relaxed);
-                let mut enqueued = 0u64;
-                for (member_identity, member_memory_info) in cohort_sources {
-                    if try_enqueue_owner_hot_replica_event(
-                        member_identity,
-                        member_memory_info,
-                        None,
-                        &inflight,
-                        &group_replica_triggered,
-                        &counters,
-                        &eviction_tx,
-                    ) {
-                        enqueued = enqueued.saturating_add(1);
-                    }
-                }
-                counters
-                    .group_members_enqueued
-                    .fetch_add(enqueued, Ordering::Relaxed);
-                if enqueued == 0 {
-                    counters
-                        .group_trigger_duplicates
-                        .fetch_add(1, Ordering::Relaxed);
-                }
-                return;
+                retry_queue.schedule(event, "eviction dispatcher closed");
             }
-            let (identity, memory_info) = cohort_sources
-                .into_iter()
-                .next()
-                .expect("owner hot cohort must contain its trigger source");
-            let _ = try_enqueue_owner_hot_replica_event(
-                identity,
-                memory_info,
-                None,
-                &inflight,
-                &group_replica_triggered,
-                &counters,
-                &eviction_tx,
-            );
         })
         .build()
 }
@@ -1833,31 +2117,42 @@ pub struct ClientKvApiInner {
     get_cached_info: Arc<DashMap<String, GetCachedInfo>>,
     /// key -> locally readable resident slot before backend put_start/put_done finishes.
     precommit_local_visible_info: DashMap<String, PrecommitLocalVisibleInfo>,
+    /// Transferred Get targets awaiting an idempotent master GetDone result.
+    /// These entries fence reclaim but are never visible to readers.
+    pending_local_get_info: DashMap<String, PendingLocalGetInfo>,
     /// key -> local replica version remembered from local put/get durable-replica success.
     /// This authority is positive-only: hit means "can answer exists=true immediately when
     /// allow_local_snapshot is enabled"; miss does not imply non-existence.
     local_snapshot_info: DashMap<String, LocalSnapshotInfo>,
     /// KvOwner-managed resident staging grants for hostless put_start.
     owner_local_reserve_pool: Mutex<OwnerLocalReservePoolState>,
-    /// Serialize reserve claims so a later waiter cannot steal slots reclaimed for the
-    /// waiter currently assembling a lease. Tokio's mutex provides FIFO acquisition order.
-    owner_local_reserve_claim_lock: limit_thirdparty::tokio::sync::AMutex<()>,
+    /// Serialize claims only within one slot-size class. Tokio's mutex provides FIFO
+    /// acquisition order for equal-size waiters without making an unrelated class wait
+    /// behind a pressured class.
+    owner_local_reserve_claim_locks: DashMap<u64, Arc<limit_thirdparty::tokio::sync::AMutex<()>>>,
     /// Wake the background reserve actor after demand/free-slot changes.
     owner_local_reserve_rebalance_notify: Arc<limit_thirdparty::tokio::sync::Notify>,
     /// Owner-local write-back put ids for external local-first path.
     external_local_first_put_id_counter: AtomicU32,
-    /// Atomic owner-side gate for local-first puts, local index access, and reclaim fencing.
-    owner_key_control: Arc<Mutex<HashMap<String, OwnerKeyControlState>>>,
+    /// Correlates idempotent owner source-eviction batches in logs and RPC responses.
+    next_owner_source_eviction_operation_id: AtomicU64,
+    /// Sharded per-key gate for local-first puts, local index access, and reclaim fencing.
+    owner_key_control: Arc<OwnerKeyControlTable>,
     /// A weak-value admission/recency tier. It never owns resident memory and
     /// therefore cannot become a second physical-reclaim authority.
     owner_hot_cache: Option<moka::sync::Cache<String, OwnerHotCacheEntry>>,
-    owner_hot_replica_inflight: Arc<DashSet<OwnerHotReplicaIdentity>>,
+    /// Exact selected identities remain here until their backing is physically
+    /// Free or the source is restored to owner-hot.
+    owner_source_eviction_selected:
+        Arc<DashMap<OwnerHotReplicaIdentity, Arc<OwnerHotSelectionDebt>>>,
     owner_hot_atomic_groups: Arc<
         DashMap<OwnerHotReplicaIdentity, Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>>,
     >,
-    owner_hot_group_replica_triggered: Arc<DashSet<OwnerHotReplicaIdentity>>,
     owner_hot_counters: Arc<OwnerHotCacheCounters>,
-    owner_hot_eviction_rx: Mutex<Option<tokio::sync::ampsc::Receiver<OwnerHotEvictionEvent>>>,
+    owner_hot_retry_queue: Arc<OwnerHotRetryQueue>,
+    owner_hot_eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionEvent>,
+    owner_hot_eviction_rx:
+        Mutex<Option<tokio::sync::ampsc::UnboundedReceiver<OwnerHotEvictionEvent>>>,
 
     /// Shared delete actor input for owner -> external weak-index invalidation.
     pub external_invalidate_delete: EnsureMemholderMgmtDeleteHandle<DeleteClientKvMetaCacheItem>,
@@ -1868,8 +2163,11 @@ pub struct ClientKvApiInner {
 
     // record external_client get_holding info (owned, flattened manager)
     pub external_get_holding: OwnerExternalMemMgr,
-    pub external_get_start_registry: DashMap<u64, Arc<ExternalGetStartEntry>>,
-    pub external_get_start_by_key: DashMap<ExternalGetStartDedupKey, Arc<ExternalGetStartSharedOp>>,
+    pub external_get_start_registry: DashMap<u64, ExternalGetStartEntry>,
+    /// Metrics-only weak index of active per-key Get flights. Correctness
+    /// remains in the sharded key-control table; observing metrics must never
+    /// scan or hold those fences.
+    external_get_flight_registry: DashMap<String, Weak<ExternalGetKeySharedOp>>,
     next_external_get_start_handle: AtomicU64,
     /// External holding identities are independent from upstream and resident holder ids.
     next_external_holding_id: AtomicU64,
@@ -1901,8 +2199,11 @@ pub struct ClientKvApiInner {
     rpc_caller_batch_prepare_put_keys: RPCCaller<BatchPreparePutKeysReq>,
     rpc_caller_batch_release_put_key_reservations: RPCCaller<BatchReleasePutKeyReservationsReq>,
     rpc_caller_put_append_start: RPCCaller<PutAppendStartReq>,
+    rpc_caller_batch_put_append_start: RPCCaller<BatchPutAppendStartReq>,
     rpc_caller_put_append_revoke: RPCCaller<PutAppendRevokeReq>,
     rpc_caller_put_append_done: RPCCaller<PutAppendDoneReq>,
+    rpc_caller_batch_put_append_done: RPCCaller<BatchPutAppendDoneReq>,
+    rpc_caller_batch_evict_owner_source: RPCCaller<BatchEvictOwnerSourceReq>,
     rpc_caller_reserve_local_grant: RPCCaller<ReserveLocalGrantReq>,
     rpc_caller_release_local_grant: RPCCaller<ReleaseLocalGrantReq>,
     rpc_caller_delete: RPCCaller<DeleteReq>,
@@ -1933,6 +2234,34 @@ impl ClientKvApiInner {
         &self.view
     }
 
+    pub(crate) fn track_external_get_flight(&self, op: &Arc<ExternalGetKeySharedOp>) {
+        self.external_get_flight_registry
+            .insert(op.key.clone(), Arc::downgrade(op));
+    }
+
+    pub(crate) fn untrack_external_get_flight(&self, op: &Arc<ExternalGetKeySharedOp>) {
+        let weak = Arc::downgrade(op);
+        self.external_get_flight_registry
+            .remove_if(&op.key, |_, current| Weak::ptr_eq(current, &weak));
+    }
+
+    fn external_get_flight_snapshot(&self) -> Vec<Arc<ExternalGetKeySharedOp>> {
+        let mut ops = Vec::new();
+        let mut stale = Vec::new();
+        for entry in &self.external_get_flight_registry {
+            if let Some(op) = entry.value().upgrade() {
+                ops.push(op);
+            } else {
+                stale.push(entry.key().clone());
+            }
+        }
+        for key in stale {
+            self.external_get_flight_registry
+                .remove_if(&key, |_, weak| weak.strong_count() == 0);
+        }
+        ops
+    }
+
     fn owner_hot_register_atomic_group(
         &self,
         group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
@@ -1941,11 +2270,84 @@ impl ClientKvApiInner {
     }
 
     fn owner_hot_forget_atomic_group_for_member(&self, identity: &OwnerHotReplicaIdentity) {
-        forget_owner_hot_atomic_group(
-            self.owner_hot_atomic_groups.as_ref(),
-            self.owner_hot_group_replica_triggered.as_ref(),
-            identity,
-        );
+        forget_owner_hot_atomic_group(self.owner_hot_atomic_groups.as_ref(), identity);
+    }
+
+    pub(crate) fn owner_hot_prepare_eviction(
+        &self,
+        event: &OwnerHotEvictionEvent,
+    ) -> OwnerHotEvictionPreparation {
+        let trigger = OwnerHotReplicaIdentity {
+            key: event.key.clone(),
+            put_time_ms: event.put_id.0,
+            put_version: event.put_id.1,
+        };
+        let cache_entry = OwnerHotCacheEntry {
+            put_id: event.put_id,
+            memory_info: event.memory_info.clone(),
+            weight_bytes: 0,
+        };
+        let memory_info = match pin_current_owner_hot_source(
+            event.key.as_str(),
+            &cache_entry,
+            self.get_cached_info.as_ref(),
+            self.owner_hot_counters.as_ref(),
+        ) {
+            OwnerHotPinResult::Pinned(memory_info) => memory_info,
+            OwnerHotPinResult::ReclaimBusy => {
+                return OwnerHotEvictionPreparation::RetryableReclaimFence;
+            }
+            OwnerHotPinResult::Stale => return OwnerHotEvictionPreparation::Obsolete,
+        };
+
+        // A retry is authoritative for exactly one previously selected key.
+        // Re-expanding it would pin every cohort member again while the safe
+        // reclaim pipeline is waiting for those very pins to disappear.
+        if event.retry {
+            return OwnerHotEvictionPreparation::Ready {
+                trigger: trigger.clone(),
+                sources: vec![(trigger, memory_info)],
+            };
+        }
+
+        // Cohort lookup and pinning deliberately happen here, after the
+        // synchronous Moka listener has returned. Each source Arc is cloned
+        // directly from its current DashMap entry. A concurrent reclaim must
+        // wait for that shard read guard and then observes the extra strong
+        // reference, so no global owner-control lock is needed.
+        let group = self
+            .owner_hot_atomic_groups
+            .get(&trigger)
+            .map(|entry| entry.value().clone());
+        let cohort_sources = match owner_hot_tp_cohort_key_rows(&trigger, group.as_deref()) {
+            Ok(Some(cohort_key_rows)) => pin_current_owner_hot_tp_cohort_sources(
+                &cohort_key_rows,
+                group.is_some(),
+                self.get_cached_info.as_ref(),
+                self.owner_hot_atomic_groups.as_ref(),
+                self.owner_hot_counters.as_ref(),
+            ),
+            Ok(None) => match group.as_deref() {
+                Some(group) => pin_current_owner_hot_group_sources(
+                    group,
+                    self.get_cached_info.as_ref(),
+                    self.owner_hot_counters.as_ref(),
+                ),
+                None => Some(vec![(trigger.clone(), memory_info)]),
+            },
+            Err(()) => None,
+        };
+        match cohort_sources {
+            Some(sources) if !sources.is_empty() => {
+                OwnerHotEvictionPreparation::Ready { trigger, sources }
+            }
+            _ => {
+                self.owner_hot_counters
+                    .group_trigger_incomplete
+                    .fetch_add(1, Ordering::Relaxed);
+                OwnerHotEvictionPreparation::RetryableIncompleteCohort
+            }
+        }
     }
 
     fn owner_hot_track_committed(
@@ -1977,6 +2379,22 @@ impl ClientKvApiInner {
         }
     }
 
+    pub(crate) fn owner_hot_admit_published_committed(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
+    ) -> bool {
+        let memory_info = self.get_cached_info.get(key).and_then(|cached| {
+            ((cached.put_time_ms, cached.put_version) == put_id).then(|| cached.mem_holder.clone())
+        });
+        let Some(memory_info) = memory_info else {
+            return false;
+        };
+        self.owner_hot_track_committed(key, put_id, &memory_info, atomic_group);
+        true
+    }
+
     fn owner_hot_touch_or_promote(
         &self,
         key: &str,
@@ -2000,7 +2418,7 @@ impl ClientKvApiInner {
         put_id: crate::master_kv_router::put::PutIDForAKey,
         memory_info: &Arc<MemoryInfo>,
     ) -> bool {
-        let controls = self.owner_key_control.lock();
+        let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
             .is_some_and(|state| state.reclaim.is_some())
@@ -2019,24 +2437,31 @@ impl ClientKvApiInner {
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
     ) {
-        let Some(cache) = self.owner_hot_cache.as_ref() else {
-            return;
-        };
-        let _ = cache.entry(key.to_string()).and_compute_with(|entry| {
-            if entry
-                .as_ref()
-                .is_some_and(|entry| entry.value().put_id == put_id)
-            {
-                MokaComputeOp::Remove
-            } else {
-                MokaComputeOp::Nop
-            }
-        });
-        self.owner_hot_forget_atomic_group_for_member(&OwnerHotReplicaIdentity {
+        let identity = OwnerHotReplicaIdentity {
             key: key.to_string(),
             put_time_ms: put_id.0,
             put_version: put_id.1,
-        });
+        };
+        if let Some(cache) = self.owner_hot_cache.as_ref() {
+            let _ = cache.entry(key.to_string()).and_compute_with(|entry| {
+                if entry
+                    .as_ref()
+                    .is_some_and(|entry| entry.value().put_id == put_id)
+                {
+                    MokaComputeOp::Remove
+                } else {
+                    MokaComputeOp::Nop
+                }
+            });
+        }
+        if let Some((_identity, debt)) = self.owner_source_eviction_selected.remove(&identity) {
+            debt.release();
+            self.owner_hot_counters
+                .source_evict_committed_members
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        self.owner_hot_retry_queue.remove(&identity);
+        self.owner_hot_forget_atomic_group_for_member(&identity);
     }
 
     pub(crate) fn release_local_reserve_route_for_memory_info(&self, memory_info: &MemoryInfo) {
@@ -2103,8 +2528,8 @@ impl ClientKvApiInner {
         key: &str,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-    ) -> KvResult<()> {
-        let mut controls = self.owner_key_control.lock();
+    ) -> KvResult<Arc<ExternalPendingPutFenceGuard>> {
+        let mut controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
             .is_some_and(|state| state.reclaim.is_some())
@@ -2115,6 +2540,7 @@ impl ClientKvApiInner {
         }
         if reject_if_exist_same_key
             && (self.precommit_local_visible_info.contains_key(key)
+                || self.pending_local_get_info.contains_key(key)
                 || self.get_cached_info.contains_key(key)
                 || self.local_snapshot_info.contains_key(key))
         {
@@ -2132,24 +2558,25 @@ impl ClientKvApiInner {
             .local_puts
             .checked_add(1)
             .expect("owner local-first put counter overflow");
-        Ok(())
+        state.external_pending_puts = state
+            .external_pending_puts
+            .checked_add(1)
+            .expect("external pending Put fence counter overflow");
+        Ok(Arc::new(ExternalPendingPutFenceGuard {
+            key: key.to_string(),
+            owner_key_control: self.owner_key_control.clone(),
+            owns_local_put: true,
+            local_slot_cleanup_view: Some(self.view.clone_view()),
+            local_slot_lease: Mutex::new(None),
+            local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+        }))
     }
 
-    pub(crate) fn release_external_local_first_put_key(&self, key: &str) {
-        let mut controls = self.owner_key_control.lock();
-        let remove = {
-            let state = controls
-                .get_mut(key)
-                .expect("owner local-first put state missing on release");
-            state.local_puts = state
-                .local_puts
-                .checked_sub(1)
-                .expect("owner local-first put counter underflow");
-            state.local_puts == 0 && state.reclaim.is_none()
-        };
-        if remove {
-            controls.remove(key);
-        }
+    pub(crate) fn acquire_external_pending_put_fence(
+        &self,
+        key: &str,
+    ) -> KvResult<Arc<ExternalPendingPutFenceGuard>> {
+        acquire_external_pending_put_fence_for_key(&self.owner_key_control, key)
     }
 
     pub(crate) fn remember_local_snapshot(
@@ -2157,7 +2584,7 @@ impl ClientKvApiInner {
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
     ) {
-        let controls = self.owner_key_control.lock();
+        let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
             .is_some_and(|state| state.reclaim.is_some())
@@ -2180,7 +2607,7 @@ impl ClientKvApiInner {
     }
 
     pub(crate) fn has_local_snapshot(&self, key: &str) -> bool {
-        let controls = self.owner_key_control.lock();
+        let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
             .is_some_and(|state| state.reclaim.is_some())
@@ -2194,7 +2621,7 @@ impl ClientKvApiInner {
 
     pub(crate) fn local_visible_mem_holder(&self, key: &str) -> Option<Arc<MemoryInfo>> {
         let (memory_info, hot_put_id) = {
-            let controls = self.owner_key_control.lock();
+            let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
                 .is_some_and(|state| state.reclaim.is_some())
@@ -2227,7 +2654,7 @@ impl ClientKvApiInner {
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
     ) -> Option<Arc<MemoryInfo>> {
-        let controls = self.owner_key_control.lock();
+        let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
             .is_some_and(|state| state.reclaim.is_some())
@@ -2253,13 +2680,19 @@ impl ClientKvApiInner {
         &self,
         keys: &[String],
     ) -> Vec<Option<Arc<MemoryInfo>>> {
-        // A hostless get_start commonly checks hundreds of pages from one
-        // local prefix. Take one coherent reclaim-fence snapshot instead of
-        // locking owner_key_control once per page. The MemoryInfo Arcs keep
-        // any selected backing alive if reclaim begins after this snapshot.
-        let resolved = {
-            let controls = self.owner_key_control.lock();
-            resolve_local_visible_batch(keys, &controls, |key| {
+        // Resolve each page under only its own short sharded fence.  The batch
+        // itself never owns a synchronous lock.  A cloned MemoryInfo pins the
+        // selected backing if reclaim starts after this point.
+        let resolved = keys
+            .iter()
+            .map(|key| {
+                let controls = self.owner_key_control.lock_key(key);
+                if controls
+                    .get(key)
+                    .is_some_and(|state| state.reclaim.is_some())
+                {
+                    return None;
+                }
                 let memory_info = self.local_visible_mem_holder_unfenced(key)?;
                 let hot_put_id = self
                     .get_cached_info
@@ -2268,7 +2701,7 @@ impl ClientKvApiInner {
                     .map(|cached| (cached.put_time_ms, cached.put_version));
                 Some((memory_info, hot_put_id))
             })
-        };
+            .collect::<Vec<_>>();
         resolved
             .into_iter()
             .zip(keys)
@@ -2299,6 +2732,11 @@ impl ClientKvApiInner {
             ExternalHoldingGetInfo {
                 key: memory_info.key.clone(),
                 req_node_id: req_node_id.to_string(),
+                requester_node_start_time: self
+                    .view
+                    .cluster_manager()
+                    .get_member_info_cached(req_node_id)
+                    .map(|member| member.node_start_time),
                 memory_info,
             },
         );
@@ -2334,6 +2772,140 @@ impl ClientKvApiInner {
         )
     }
 
+    pub(crate) fn install_hidden_pending_local_get(
+        &self,
+        key: &str,
+        get_id: u64,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        addr: u64,
+        base_addr: u64,
+        len: u32,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<Arc<MemoryInfo>> {
+        let controls = self.owner_key_control.lock_key(key);
+        if controls
+            .get(key)
+            .is_some_and(|state| state.reclaim.is_some())
+            || self.pending_local_get_info.contains_key(key)
+        {
+            return Err(KvError::Api(ApiError::KeyBeingWritten {
+                key: key.to_string(),
+            }));
+        }
+        self.owner_mark_local_reserve_slot_pending_visible(slot_size, grant_id, slot_index)?;
+        self.owner_retain_local_reserve_resident_slot_holder(slot_size, grant_id, slot_index)?;
+        let resident_owner_node_id: NodeID = self.view.cluster_manager().get_self_info().id.into();
+        let memory_info = Arc::new(MemoryInfo::new_local_reserve_resident_with_base(
+            addr,
+            base_addr,
+            len,
+            key.to_string(),
+            resident_owner_node_id,
+            self.view.clone(),
+            slot_size,
+            grant_id,
+            slot_index,
+        ));
+        let previous = self.pending_local_get_info.insert(
+            key.to_string(),
+            PendingLocalGetInfo {
+                get_id,
+                put_id,
+                mem_holder: memory_info.clone(),
+            },
+        );
+        assert!(
+            previous.is_none(),
+            "pending local Get must be unique per key"
+        );
+        drop(controls);
+        Ok(memory_info)
+    }
+
+    pub(crate) fn abort_hidden_pending_local_get(&self, key: &str, get_id: u64) -> bool {
+        let _controls = self.owner_key_control.lock_key(key);
+        self.pending_local_get_info
+            .remove_if(key, |_, pending| pending.get_id == get_id)
+            .is_some()
+    }
+
+    pub(crate) fn promote_hidden_pending_local_get(
+        &self,
+        key: &str,
+        get_id: u64,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+    ) -> KvResult<Arc<MemoryInfo>> {
+        let memory_info = {
+            let controls = self.owner_key_control.lock_key(key);
+            if controls
+                .get(key)
+                .is_some_and(|state| state.reclaim.is_some())
+            {
+                return Err(KvError::Api(ApiError::KeyBeingWritten {
+                    key: key.to_string(),
+                }));
+            }
+            let Some(pending_memory_info) =
+                self.pending_local_get_info.get(key).and_then(|pending| {
+                    (pending.get_id == get_id && pending.put_id == put_id)
+                        .then(|| pending.mem_holder.clone())
+                })
+            else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "hidden pending local Get is absent: key={} get_id={}",
+                        key, get_id
+                    ),
+                }));
+            };
+            let (slot_size, grant_id, slot_index) = pending_memory_info
+                .local_reserve_resident_slot_ref()
+                .expect("pending local Get must carry a local-reserve slot");
+            self.owner_promote_local_reserve_pending_slot_to_committed(
+                slot_size, grant_id, slot_index,
+            )?;
+            let removed = self
+                .pending_local_get_info
+                .remove_if(key, |_, pending| {
+                    pending.get_id == get_id
+                        && pending.put_id == put_id
+                        && Arc::ptr_eq(&pending.mem_holder, &pending_memory_info)
+                })
+                .is_some();
+            if !removed {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "hidden pending local Get changed while promoting: key={} get_id={}",
+                        key, get_id
+                    ),
+                }));
+            }
+            let replaced = self.get_cached_info.insert(
+                key.to_string(),
+                GetCachedInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                    mem_holder: pending_memory_info.clone(),
+                },
+            );
+            if let Some(previous) = replaced {
+                self.release_local_reserve_route_for_memory_info(previous.mem_holder.as_ref());
+            }
+            self.local_snapshot_info.insert(
+                key.to_string(),
+                LocalSnapshotInfo {
+                    put_time_ms: put_id.0,
+                    put_version: put_id.1,
+                },
+            );
+            drop(controls);
+            pending_memory_info
+        };
+        Ok(memory_info)
+    }
+
     pub async fn install_local_committed_memory_info(
         &self,
         key: &str,
@@ -2355,7 +2927,7 @@ impl ClientKvApiInner {
             .await,
         );
         {
-            let controls = self.owner_key_control.lock();
+            let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
                 .is_some_and(|state| state.reclaim.is_some())
@@ -2394,7 +2966,7 @@ impl ClientKvApiInner {
         memory_info: Arc<MemoryInfo>,
     ) -> bool {
         {
-            let controls = self.owner_key_control.lock();
+            let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
                 .is_some_and(|state| state.reclaim.is_some())
@@ -2435,7 +3007,7 @@ impl ClientKvApiInner {
         key: &str,
         memory_info: Arc<MemoryInfo>,
     ) {
-        let controls = self.owner_key_control.lock();
+        let controls = self.owner_key_control.lock_key(key);
         assert!(
             !controls
                 .get(key)
@@ -2466,7 +3038,7 @@ impl ClientKvApiInner {
         key: &str,
         expected_mem_holder: &Arc<MemoryInfo>,
     ) -> bool {
-        let _controls = self.owner_key_control.lock();
+        let _controls = self.owner_key_control.lock_key(key);
         self.precommit_local_visible_info
             .remove_if(key, |_, info| {
                 Arc::ptr_eq(&info.mem_holder, expected_mem_holder)
@@ -2474,15 +3046,34 @@ impl ClientKvApiInner {
             .is_some()
     }
 
+    pub fn precommit_local_visible_memory_info(&self, key: &str) -> Option<Arc<MemoryInfo>> {
+        self.precommit_local_visible_info
+            .get(key)
+            .map(|info| info.mem_holder.clone())
+    }
+
+    pub(crate) fn committed_local_reserve_slot_is_current(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        expected: &crate::master_kv_router::msg_pack::PutDoneCommittedSlot,
+    ) -> bool {
+        self.get_cached_info.get(key).is_some_and(|cached| {
+            (cached.put_time_ms, cached.put_version) == put_id
+                && cached.mem_holder.local_reserve_resident_slot_ref()
+                    == Some((expected.slot_size, expected.grant_id, expected.slot_index))
+        })
+    }
+
     pub fn promote_precommit_local_reserve_resident_slot_if_same(
         &self,
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
         memory_info: Arc<MemoryInfo>,
-        atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
+        _atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
     ) -> KvResult<()> {
         {
-            let controls = self.owner_key_control.lock();
+            let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
                 .is_some_and(|state| state.reclaim.is_some())
@@ -2541,7 +3132,6 @@ impl ClientKvApiInner {
                 },
             );
         }
-        self.owner_hot_track_committed(key, put_id, &memory_info, atomic_group);
         Ok(())
     }
 }
@@ -2559,6 +3149,9 @@ pub struct ExternalPendingPutCtx {
     pub local_reserve_slot: Option<OwnerLocalReserveSlotRef>,
     pub local_reserve_slot_size: Option<u64>,
     pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
+    /// Keep the per-key reclaim fence alive for every cache/user clone of this
+    /// pending context.  The counter is released only by the final Arc drop.
+    pub(crate) _pending_fence: Arc<ExternalPendingPutFenceGuard>,
 }
 
 #[derive(Debug, Clone)]
@@ -2572,10 +3165,12 @@ pub(crate) struct ReplicaTaskTarget {
 pub(crate) struct ReplicaTaskJob {
     pub key: String,
     pub put_id: crate::master_kv_router::put::PutIDForAKey,
-    pub holder: Arc<UserMemHolder>,
+    /// Replica tasks are independent hit-rate work and keep their transfer
+    /// source alive until the transfer finishes. Capacity eviction never enters
+    /// this queue.
+    pub holder: Option<Arc<UserMemHolder>>,
     pub target: Option<ReplicaTaskTarget>,
     pub preferred_sub_cluster: Option<String>,
-    pub hot_replica_guard: Option<OwnerHotReplicaGuard>,
     pub protect_source_on_remote_complete: bool,
 }
 
@@ -2807,76 +3402,577 @@ impl OwnerLocalReserveGrantState {
                     }
                 }
             }
-            _ => {
-                unreachable!("release_committed_slot_route expects a committed slot");
+            _ => {
+                unreachable!("release_committed_slot_route expects a committed slot");
+            }
+        }
+    }
+
+    pub fn is_fully_free(&self) -> bool {
+        self.free_slots.len() == self.slot_count as usize
+    }
+
+    pub fn used_slot_count(&self) -> usize {
+        self.slot_count as usize - self.free_slots.len()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct OwnerLocalReserveClassState {
+    pub slot_size: u64,
+    pub slots_per_grant: u32,
+    pub grants: Vec<OwnerLocalReserveGrantState>,
+    /// Stable grant identity -> current index in `grants`. Every vector removal uses
+    /// swap-remove and repairs the one moved entry, so per-slot state transitions never
+    /// scan all grants.
+    grant_indices: HashMap<u64, usize>,
+    /// Dense set of grants which currently contain at least one free slot. This avoids
+    /// scanning full grants while assembling a lease.
+    claimable_grant_ids: Vec<u64>,
+    claimable_grant_indices: HashMap<u64, usize>,
+    free_slots: usize,
+    prepared_slots: usize,
+    pending_visible_slots: usize,
+    committed_slots: usize,
+    pub last_grow_at: Option<Instant>,
+    pub pending_slot_demand: usize,
+    pub max_observed_claim_slots: usize,
+    pub expected_grant_count: usize,
+}
+
+impl OwnerLocalReserveClassState {
+    pub fn new(slot_size: u64, slots_per_grant: u32) -> Self {
+        Self {
+            slot_size,
+            slots_per_grant,
+            grants: Vec::new(),
+            grant_indices: HashMap::new(),
+            claimable_grant_ids: Vec::new(),
+            claimable_grant_indices: HashMap::new(),
+            free_slots: 0,
+            prepared_slots: 0,
+            pending_visible_slots: 0,
+            committed_slots: 0,
+            last_grow_at: None,
+            pending_slot_demand: 0,
+            max_observed_claim_slots: 0,
+            expected_grant_count: 0,
+        }
+    }
+
+    pub fn free_slot_count(&self) -> usize {
+        self.free_slots
+    }
+
+    pub fn used_slot_count(&self) -> usize {
+        self.prepared_slots
+            .saturating_add(self.pending_visible_slots)
+            .saturating_add(self.committed_slots)
+    }
+
+    pub fn grant_count(&self) -> usize {
+        self.grants.len()
+    }
+
+    pub fn prepared_slot_count(&self) -> usize {
+        self.prepared_slots
+    }
+
+    pub fn pending_visible_slot_count(&self) -> usize {
+        self.pending_visible_slots
+    }
+
+    pub fn committed_slot_count(&self) -> usize {
+        self.committed_slots
+    }
+
+    fn add_claimable_grant(&mut self, grant_id: u64) {
+        if self.claimable_grant_indices.contains_key(&grant_id) {
+            return;
+        }
+        let index = self.claimable_grant_ids.len();
+        self.claimable_grant_ids.push(grant_id);
+        let previous = self.claimable_grant_indices.insert(grant_id, index);
+        assert!(
+            previous.is_none(),
+            "duplicate claimable local-reserve grant"
+        );
+    }
+
+    fn remove_claimable_grant(&mut self, grant_id: u64) {
+        let Some(index) = self.claimable_grant_indices.remove(&grant_id) else {
+            return;
+        };
+        let removed = self.claimable_grant_ids.swap_remove(index);
+        assert_eq!(removed, grant_id, "claimable grant index drift");
+        if let Some(moved_grant_id) = self.claimable_grant_ids.get(index).copied() {
+            let moved_index = self
+                .claimable_grant_indices
+                .get_mut(&moved_grant_id)
+                .expect("moved claimable grant must remain indexed");
+            *moved_index = index;
+        }
+    }
+
+    pub fn install_grant(&mut self, grant: OwnerLocalReserveGrantState) {
+        assert_eq!(grant.slot_size, self.slot_size, "grant slot-size drift");
+        assert_eq!(
+            grant.slot_count, self.slots_per_grant,
+            "grant slot-count drift"
+        );
+        assert!(
+            !self.grant_indices.contains_key(&grant.grant_id),
+            "duplicate local-reserve grant id"
+        );
+
+        let mut free = 0usize;
+        let mut prepared = 0usize;
+        let mut pending_visible = 0usize;
+        let mut committed = 0usize;
+        for state in &grant.slot_states {
+            match state {
+                OwnerLocalReserveSlotState::Free => free += 1,
+                OwnerLocalReserveSlotState::Prepared => prepared += 1,
+                OwnerLocalReserveSlotState::PendingLocalVisible { .. } => pending_visible += 1,
+                OwnerLocalReserveSlotState::Committed { .. } => committed += 1,
+            }
+        }
+        assert_eq!(free, grant.free_slots.len(), "grant free-slot index drift");
+
+        let grant_id = grant.grant_id;
+        let index = self.grants.len();
+        self.grants.push(grant);
+        let previous = self.grant_indices.insert(grant_id, index);
+        assert!(previous.is_none(), "duplicate local-reserve grant id");
+        if free != 0 {
+            self.add_claimable_grant(grant_id);
+        }
+        self.free_slots = self
+            .free_slots
+            .checked_add(free)
+            .expect("free slot overflow");
+        self.prepared_slots = self
+            .prepared_slots
+            .checked_add(prepared)
+            .expect("prepared slot overflow");
+        self.pending_visible_slots = self
+            .pending_visible_slots
+            .checked_add(pending_visible)
+            .expect("pending-visible slot overflow");
+        self.committed_slots = self
+            .committed_slots
+            .checked_add(committed)
+            .expect("committed slot overflow");
+    }
+
+    pub fn claim_available(&mut self, max_slots: usize) -> Vec<OwnerLocalReserveSlotRef> {
+        let claim_count = self.free_slots.min(max_slots);
+        let mut slots = Vec::with_capacity(claim_count);
+        while slots.len() < claim_count {
+            let grant_id = *self
+                .claimable_grant_ids
+                .last()
+                .expect("free-slot counter requires a claimable grant");
+            let grant_index = *self
+                .grant_indices
+                .get(&grant_id)
+                .expect("claimable grant must be installed");
+            let (slot, exhausted) = {
+                let grant = &mut self.grants[grant_index];
+                let slot = grant
+                    .claim_prepared_slot()
+                    .expect("claimable grant must contain a free slot");
+                (slot, grant.free_slots.is_empty())
+            };
+            self.free_slots = self
+                .free_slots
+                .checked_sub(1)
+                .expect("free slot counter underflow");
+            self.prepared_slots = self
+                .prepared_slots
+                .checked_add(1)
+                .expect("prepared slot overflow");
+            if exhausted {
+                self.remove_claimable_grant(grant_id);
             }
+            slots.push(slot);
         }
+        slots
     }
 
-    pub fn is_fully_free(&self) -> bool {
-        self.free_slots.len() == self.slot_count as usize
+    fn grant_index(&self, grant_id: u64) -> Option<usize> {
+        self.grant_indices.get(&grant_id).copied()
     }
 
-    pub fn used_slot_count(&self) -> usize {
-        self.slot_count as usize - self.free_slots.len()
+    pub fn grant(&self, grant_id: u64) -> Option<&OwnerLocalReserveGrantState> {
+        self.grant_index(grant_id)
+            .and_then(|index| self.grants.get(index))
     }
-}
 
-#[derive(Debug, Clone)]
-pub(crate) struct OwnerLocalReserveClassState {
-    pub slot_size: u64,
-    pub slots_per_grant: u32,
-    pub grants: Vec<OwnerLocalReserveGrantState>,
-    pub last_grow_at: Option<Instant>,
-    pub pending_slot_demand: usize,
-    pub expected_grant_count: usize,
-}
+    pub fn release_prepared_slot(&mut self, grant_id: u64, slot_index: u32) -> bool {
+        let Some(grant_index) = self.grant_index(grant_id) else {
+            return false;
+        };
+        let was_exhausted = self.grants[grant_index].free_slots.is_empty();
+        self.grants[grant_index].release_prepared_slot(slot_index);
+        self.prepared_slots = self
+            .prepared_slots
+            .checked_sub(1)
+            .expect("prepared slot counter underflow");
+        self.free_slots = self.free_slots.checked_add(1).expect("free slot overflow");
+        if was_exhausted {
+            self.add_claimable_grant(grant_id);
+        }
+        true
+    }
 
-impl OwnerLocalReserveClassState {
-    pub fn new(slot_size: u64, slots_per_grant: u32) -> Self {
-        Self {
-            slot_size,
-            slots_per_grant,
-            grants: Vec::new(),
-            last_grow_at: None,
-            pending_slot_demand: 0,
-            expected_grant_count: 0,
+    pub fn mark_prepared_slot_pending_visible(&mut self, grant_id: u64, slot_index: u32) -> bool {
+        let Some(grant_index) = self.grant_index(grant_id) else {
+            return false;
+        };
+        self.grants[grant_index].mark_prepared_slot_pending_visible(slot_index);
+        self.prepared_slots = self
+            .prepared_slots
+            .checked_sub(1)
+            .expect("prepared slot counter underflow");
+        self.pending_visible_slots = self
+            .pending_visible_slots
+            .checked_add(1)
+            .expect("pending-visible slot overflow");
+        true
+    }
+
+    pub fn promote_pending_visible_slot_to_committed(
+        &mut self,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> bool {
+        let Some(grant_index) = self.grant_index(grant_id) else {
+            return false;
+        };
+        self.grants[grant_index].promote_pending_visible_slot_to_committed(slot_index);
+        self.pending_visible_slots = self
+            .pending_visible_slots
+            .checked_sub(1)
+            .expect("pending-visible slot counter underflow");
+        self.committed_slots = self
+            .committed_slots
+            .checked_add(1)
+            .expect("committed slot overflow");
+        true
+    }
+
+    pub fn retain_resident_slot_holder(&mut self, grant_id: u64, slot_index: u32) -> bool {
+        let Some(grant_index) = self.grant_index(grant_id) else {
+            return false;
+        };
+        self.grants[grant_index].retain_resident_slot_holder(slot_index);
+        true
+    }
+
+    pub fn release_resident_slot_holder(&mut self, grant_id: u64, slot_index: u32) -> bool {
+        let Some(grant_index) = self.grant_index(grant_id) else {
+            return false;
+        };
+        let (was_exhausted, prior_state, became_free) = {
+            let grant = &mut self.grants[grant_index];
+            let was_exhausted = grant.free_slots.is_empty();
+            let prior_state = grant
+                .slot_states
+                .get(slot_index as usize)
+                .expect("slot state index out of range")
+                .clone();
+            let free_before = grant.free_slots.len();
+            grant.release_resident_slot_holder(slot_index);
+            (
+                was_exhausted,
+                prior_state,
+                grant.free_slots.len() != free_before,
+            )
+        };
+        if became_free {
+            match prior_state {
+                OwnerLocalReserveSlotState::PendingLocalVisible { .. } => {
+                    self.pending_visible_slots = self
+                        .pending_visible_slots
+                        .checked_sub(1)
+                        .expect("pending-visible slot counter underflow");
+                }
+                OwnerLocalReserveSlotState::Committed { .. } => {
+                    self.committed_slots = self
+                        .committed_slots
+                        .checked_sub(1)
+                        .expect("committed slot counter underflow");
+                }
+                _ => unreachable!("resident holder must belong to a resident slot"),
+            }
+            self.free_slots = self.free_slots.checked_add(1).expect("free slot overflow");
+            if was_exhausted {
+                self.add_claimable_grant(grant_id);
+            }
         }
+        true
     }
 
-    pub fn free_slot_count(&self) -> usize {
-        self.grants.iter().map(|grant| grant.free_slots.len()).sum()
+    pub fn release_committed_slot_route(&mut self, grant_id: u64, slot_index: u32) -> bool {
+        let Some(grant_index) = self.grant_index(grant_id) else {
+            return false;
+        };
+        let (was_exhausted, became_free) = {
+            let grant = &mut self.grants[grant_index];
+            let was_exhausted = grant.free_slots.is_empty();
+            let free_before = grant.free_slots.len();
+            grant.release_committed_slot_route(slot_index);
+            (was_exhausted, grant.free_slots.len() != free_before)
+        };
+        if became_free {
+            self.committed_slots = self
+                .committed_slots
+                .checked_sub(1)
+                .expect("committed slot counter underflow");
+            self.free_slots = self.free_slots.checked_add(1).expect("free slot overflow");
+            if was_exhausted {
+                self.add_claimable_grant(grant_id);
+            }
+        }
+        true
     }
 
-    pub fn used_slot_count(&self) -> usize {
-        self.grants
-            .iter()
-            .map(|grant| grant.used_slot_count())
-            .sum()
+    /// Drop the route reference and the resident `MemoryInfo` reference as one
+    /// slot-pool transaction. This is the normal owner-reclaim transition and
+    /// avoids exposing an intermediate state across two pool lock acquisitions.
+    pub fn release_committed_resident_slot(&mut self, grant_id: u64, slot_index: u32) -> bool {
+        if self.grant_index(grant_id).is_none() {
+            return false;
+        }
+        assert!(self.release_committed_slot_route(grant_id, slot_index));
+        assert!(self.release_resident_slot_holder(grant_id, slot_index));
+        true
     }
 
-    pub fn grant_count(&self) -> usize {
-        self.grants.len()
+    pub fn detach_fully_free_grant(
+        &mut self,
+        grant_id: u64,
+    ) -> Option<OwnerLocalReserveGrantState> {
+        let grant_index = self.grant_indices.remove(&grant_id)?;
+        assert!(
+            self.grants[grant_index].is_fully_free(),
+            "only a fully-free grant may be detached"
+        );
+        self.remove_claimable_grant(grant_id);
+        let grant = self.grants.swap_remove(grant_index);
+        assert_eq!(grant.grant_id, grant_id, "grant index drift");
+        if let Some(moved_grant) = self.grants.get(grant_index) {
+            let moved_index = self
+                .grant_indices
+                .get_mut(&moved_grant.grant_id)
+                .expect("moved grant must remain indexed");
+            *moved_index = grant_index;
+        }
+        self.free_slots = self
+            .free_slots
+            .checked_sub(grant.slot_count as usize)
+            .expect("free slot counter underflow");
+        Some(grant)
+    }
+
+    pub fn take_all_grants(&mut self) -> Vec<OwnerLocalReserveGrantState> {
+        self.grant_indices.clear();
+        self.claimable_grant_ids.clear();
+        self.claimable_grant_indices.clear();
+        self.free_slots = 0;
+        self.prepared_slots = 0;
+        self.pending_visible_slots = 0;
+        self.committed_slots = 0;
+        std::mem::take(&mut self.grants)
     }
 }
 
 #[cfg(test)]
 mod owner_reclaim_slot_tests {
     use super::{
-        GetCachedInfo, OwnerHotCacheCounters, OwnerHotCacheEntry, OwnerHotReplicaGuard,
-        OwnerHotReplicaIdentity, OwnerKeyControlState, OwnerLocalReserveGrantState,
-        OwnerReclaimRecord, allocate_external_holding_id, build_owner_hot_cache,
-        clone_if_owner_hot_entry_matches, forget_owner_hot_atomic_group,
-        owner_hot_tp_cohort_key_rows, register_owner_hot_atomic_group, resolve_local_visible_batch,
+        ExternalPendingPutCtx, ExternalPendingPutFenceGuard, OwnerHotCacheCounters,
+        OwnerHotCacheEntry, OwnerHotEvictionEvent, OwnerHotReplicaIdentity, OwnerHotRetryQueue,
+        OwnerHotSelectionDebt, OwnerKeyControlState, OwnerKeyControlTable,
+        OwnerLocalReserveGrantState, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef,
+        OwnerLocalReserveSlotState, OwnerReclaimRecord, acquire_external_pending_put_fence_for_key,
+        allocate_external_holding_id, build_owner_hot_cache, clone_if_owner_hot_entry_matches,
+        forget_owner_hot_atomic_group, owner_hot_tp_cohort_key_rows,
+        pin_current_owner_hot_source_from_index, register_owner_hot_atomic_group,
     };
     use crate::master_kv_router::msg_pack::{
         OwnerReclaimItem, PutAtomicGroup, PutAtomicGroupMember,
     };
-    use dashmap::{DashMap, DashSet};
+    use dashmap::DashMap;
     use parking_lot::Mutex;
-    use std::collections::HashMap;
     use std::sync::atomic::{AtomicU64, Ordering};
     use std::sync::{Arc, Weak};
+    use std::time::{Duration, Instant};
+
+    fn pending_put_count(controls: &Arc<OwnerKeyControlTable>, key: &str) -> Option<u32> {
+        controls
+            .lock_key(key)
+            .get(key)
+            .map(|state| state.external_pending_puts)
+    }
+
+    fn controls_with_state(key: &str, state: OwnerKeyControlState) -> Arc<OwnerKeyControlTable> {
+        let controls = Arc::new(OwnerKeyControlTable::default());
+        controls.lock_key(key).insert(key.to_string(), state);
+        controls
+    }
+
+    #[test]
+    fn external_pending_put_guard_clone_releases_only_after_last_drop() {
+        let controls = Arc::new(OwnerKeyControlTable::default());
+        let guard = acquire_external_pending_put_fence_for_key(&controls, "clone-key")
+            .expect("pending fence acquisition must succeed");
+        let clone = guard.clone();
+        assert_eq!(pending_put_count(&controls, "clone-key"), Some(1));
+
+        drop(guard);
+        assert_eq!(pending_put_count(&controls, "clone-key"), Some(1));
+        drop(clone);
+        assert_eq!(pending_put_count(&controls, "clone-key"), None);
+    }
+
+    #[test]
+    fn stale_pending_put_guard_drop_cannot_erase_new_generation() {
+        let controls = Arc::new(OwnerKeyControlTable::default());
+        let old = acquire_external_pending_put_fence_for_key(&controls, "aba-key")
+            .expect("old pending fence acquisition must succeed");
+        let new = acquire_external_pending_put_fence_for_key(&controls, "aba-key")
+            .expect("new pending fence acquisition must succeed");
+        assert_eq!(pending_put_count(&controls, "aba-key"), Some(2));
+
+        drop(old);
+        assert_eq!(pending_put_count(&controls, "aba-key"), Some(1));
+        drop(new);
+        assert_eq!(pending_put_count(&controls, "aba-key"), None);
+    }
+
+    #[test]
+    fn local_first_pending_guard_releases_both_key_counters() {
+        let controls = controls_with_state(
+            "local-key",
+            OwnerKeyControlState {
+                local_puts: 1,
+                external_pending_puts: 1,
+                reclaim: None,
+                external_get: None,
+            },
+        );
+        let guard = Arc::new(ExternalPendingPutFenceGuard {
+            key: "local-key".to_string(),
+            owner_key_control: controls.clone(),
+            owns_local_put: true,
+            local_slot_cleanup_view: None,
+            local_slot_lease: Mutex::new(None),
+            local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+        });
+
+        drop(guard);
+        assert!(controls.lock_key("local-key").get("local-key").is_none());
+    }
+
+    #[test]
+    fn failed_local_slot_release_keeps_key_fence_closed() {
+        let controls = controls_with_state(
+            "failed-slot",
+            OwnerKeyControlState {
+                local_puts: 1,
+                external_pending_puts: 1,
+                reclaim: None,
+                external_get: None,
+            },
+        );
+        let guard = Arc::new(ExternalPendingPutFenceGuard {
+            key: "failed-slot".to_string(),
+            owner_key_control: controls.clone(),
+            owns_local_put: true,
+            local_slot_cleanup_view: None,
+            local_slot_lease: Mutex::new(None),
+            local_slot_release_failed: std::sync::atomic::AtomicBool::new(true),
+        });
+
+        drop(guard);
+        let controls = controls.lock_key("failed-slot");
+        assert_eq!(controls["failed-slot"].local_puts, 1);
+        assert_eq!(controls["failed-slot"].external_pending_puts, 1);
+    }
+
+    #[test]
+    fn committed_local_first_slot_disarms_drop_cleanup_before_fence_release() {
+        let controls = controls_with_state(
+            "committed-slot",
+            OwnerKeyControlState {
+                local_puts: 1,
+                external_pending_puts: 1,
+                reclaim: None,
+                external_get: None,
+            },
+        );
+        let guard = Arc::new(ExternalPendingPutFenceGuard {
+            key: "committed-slot".to_string(),
+            owner_key_control: controls.clone(),
+            owns_local_put: true,
+            local_slot_cleanup_view: None,
+            local_slot_lease: Mutex::new(None),
+            local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+        });
+        guard.attach_local_slot_lease(OwnerLocalReserveSlotLease {
+            value_len: 8,
+            slot_size: 8,
+            slots: vec![OwnerLocalReserveSlotRef {
+                grant_id: 7,
+                slot_index: 2,
+                ptr: 0x1008,
+                base_addr: 0x1000,
+            }],
+        });
+
+        guard.disarm_local_slot_lease();
+        drop(guard);
+        assert!(
+            controls
+                .lock_key("committed-slot")
+                .get("committed-slot")
+                .is_none()
+        );
+    }
+
+    #[test]
+    fn pending_ctx_clone_keeps_fence_after_explicit_cache_invalidation() {
+        let controls = Arc::new(OwnerKeyControlTable::default());
+        let fence = acquire_external_pending_put_fence_for_key(&controls, "cached-key")
+            .expect("pending fence acquisition must succeed");
+        let cache = moka::sync::Cache::new(1);
+        let identity = ("cached-key".to_string(), 10, 2);
+        cache.insert(
+            identity.clone(),
+            ExternalPendingPutCtx {
+                peer_id: None,
+                src_offset: 0,
+                target_base_addr: 0,
+                target_offset: 0,
+                len: 1,
+                make_replica_task: false,
+                preferred_sub_cluster: None,
+                replica_target: None,
+                local_reserve_slot: None,
+                local_reserve_slot_size: None,
+                atomic_group: None,
+                _pending_fence: fence,
+            },
+        );
+        let clone = cache.get(&identity).expect("pending ctx must exist");
+        cache.invalidate(&identity);
+        cache.run_pending_tasks();
+        assert_eq!(pending_put_count(&controls, "cached-key"), Some(1));
+
+        drop(clone);
+        assert_eq!(pending_put_count(&controls, "cached-key"), None);
+    }
 
     #[test]
     fn external_holding_ids_are_nonzero_and_unique_for_resident_pages() {
@@ -2910,30 +4006,162 @@ mod owner_reclaim_slot_tests {
     }
 
     #[test]
-    fn hot_replica_guard_keeps_dedup_until_terminal_outcome() {
-        let identity = OwnerHotReplicaIdentity {
-            key: "hot-key".to_string(),
-            put_time_ms: 10,
-            put_version: 2,
+    fn dispatcher_pin_and_reclaim_prepare_are_serialized_by_the_current_index() {
+        let current = Mutex::new(Some(((10, 2), Arc::new(7u64))));
+        let weak = Arc::downgrade(&current.lock().as_ref().unwrap().1);
+
+        let pinned = match pin_current_owner_hot_source_from_index((10, 2), &weak, || {
+            current
+                .lock()
+                .as_ref()
+                .map(|(put_id, value)| (*put_id, value.clone()))
+        }) {
+            super::OwnerHotPinResult::Pinned(pinned) => pinned,
+            _ => panic!("current source must pin under the owner fence"),
         };
-        let inflight = Arc::new(DashSet::new());
-        assert!(inflight.insert(identity.clone()));
+        let prepared_after_pin = current.lock().take().unwrap().1;
+        assert_eq!(Arc::strong_count(&prepared_after_pin), 2);
+        drop(pinned);
+        assert_eq!(Arc::strong_count(&prepared_after_pin), 1);
+
+        // If Prepare wins and moves the sole Arc out of the local index, the
+        // dispatcher observes an absent current entry. It must not upgrade the
+        // Weak that now points into Prepared, or Commit's try_unwrap could race
+        // an unexpected second holder.
+        let current = Mutex::new(Some(((11, 3), Arc::new(9u64))));
+        let weak = Arc::downgrade(&current.lock().as_ref().unwrap().1);
+        let prepared_before_pin = current.lock().take().unwrap().1;
+        assert!(matches!(
+            pin_current_owner_hot_source_from_index((11, 3), &weak, || {
+                current
+                    .lock()
+                    .as_ref()
+                    .map(|(put_id, value)| (*put_id, value.clone()))
+            }),
+            super::OwnerHotPinResult::ReclaimBusy
+        ));
+        assert_eq!(Arc::strong_count(&prepared_before_pin), 1);
+
+        drop(prepared_before_pin);
+        assert!(matches!(
+            pin_current_owner_hot_source_from_index((11, 3), &weak, || None),
+            super::OwnerHotPinResult::Stale
+        ));
+    }
+
+    #[test]
+    fn owner_hot_retry_queue_is_exactly_once_and_keeps_selection_debt() {
         let counters = Arc::new(OwnerHotCacheCounters::default());
-        let group_replica_triggered = Arc::new(DashSet::new());
-        let guard = OwnerHotReplicaGuard::new(
-            identity.clone(),
-            inflight.clone(),
-            counters.clone(),
-            None,
-            group_replica_triggered,
+        let retry_queue = OwnerHotRetryQueue::new(counters.clone());
+        let identity = OwnerHotReplicaIdentity {
+            key: "retry-key".to_string(),
+            put_time_ms: 12,
+            put_version: 3,
+        };
+        let debt = OwnerHotSelectionDebt::new(64, counters.selection_debt_bytes.clone());
+        let event = OwnerHotEvictionEvent {
+            key: identity.key.clone(),
+            put_id: (identity.put_time_ms, identity.put_version),
+            memory_info: Weak::new(),
+            selection_debt: debt,
+            retry: true,
+            source_eviction_cohort: None,
+            retry_failures: 0,
+        };
+        retry_queue.schedule(event.clone(), "first failure");
+        retry_queue.schedule(event, "duplicate failure");
+        assert_eq!(retry_queue.len(), 1);
+        assert_eq!(counters.selection_debt_bytes.load(Ordering::Acquire), 64);
+
+        let due = retry_queue.take_due_batch(Instant::now() + Duration::from_secs(10), 128);
+        assert_eq!(due.len(), 1);
+        assert_eq!(retry_queue.len(), 1);
+        assert_eq!(counters.selection_debt_bytes.load(Ordering::Acquire), 64);
+        assert!(
+            retry_queue
+                .take_due_batch(Instant::now() + Duration::from_secs(30), 128)
+                .is_empty(),
+            "a dispatched retry stays exactly once until dispatcher acknowledgement"
         );
-        assert!(inflight.contains(&identity));
+        let accepted = retry_queue
+            .take_for_inflight(&identity)
+            .expect("dispatcher acknowledgement must take the authoritative event");
+        accepted.selection_debt.release();
+        assert_eq!(retry_queue.len(), 0);
+        assert_eq!(counters.selection_debt_bytes.load(Ordering::Acquire), 0);
+    }
 
-        guard.mark_completed();
-        drop(guard);
-        assert!(!inflight.contains(&identity));
-        assert_eq!(counters.replica_completed.load(Ordering::Relaxed), 1);
-        assert_eq!(counters.replica_failed.load(Ordering::Relaxed), 0);
+    #[test]
+    fn owner_hot_retry_queue_deadlines_stay_bounded_under_high_churn() {
+        const CHURN: usize = 20_000;
+
+        let counters = Arc::new(OwnerHotCacheCounters::default());
+        let retry_queue = OwnerHotRetryQueue::new(counters.clone());
+        let identity = OwnerHotReplicaIdentity {
+            key: "retry-churn".to_string(),
+            put_time_ms: 21,
+            put_version: 5,
+        };
+        let debt = OwnerHotSelectionDebt::new(64, counters.selection_debt_bytes.clone());
+        let event = OwnerHotEvictionEvent {
+            key: identity.key.clone(),
+            put_id: (identity.put_time_ms, identity.put_version),
+            memory_info: Weak::new(),
+            selection_debt: debt,
+            retry: true,
+            source_eviction_cohort: None,
+            retry_failures: 0,
+        };
+
+        for _ in 0..CHURN {
+            retry_queue.schedule(event.clone(), "repeated failure");
+        }
+        assert_eq!(retry_queue.len(), 1);
+        assert_eq!(retry_queue.state.lock().deadlines.len(), 1);
+
+        let due = retry_queue.take_due_batch(Instant::now() + Duration::from_secs(10), 1);
+        assert_eq!(due.len(), 1);
+        assert_eq!(retry_queue.len(), 1);
+        assert_eq!(retry_queue.state.lock().deadlines.len(), 0);
+
+        for _ in 0..CHURN {
+            retry_queue.schedule(due[0].clone(), "repeated dispatcher failure");
+        }
+        assert_eq!(retry_queue.len(), 1);
+        assert_eq!(retry_queue.state.lock().deadlines.len(), 1);
+
+        let event = retry_queue
+            .take_for_inflight(&identity)
+            .expect("live retry must remain available to the dispatcher");
+        assert_eq!(retry_queue.len(), 0);
+        assert_eq!(retry_queue.state.lock().deadlines.len(), 0);
+        event.selection_debt.release();
+        assert_eq!(counters.selection_debt_bytes.load(Ordering::Acquire), 0);
+
+        let remove_identity = OwnerHotReplicaIdentity {
+            key: "retry-remove-churn".to_string(),
+            put_time_ms: 22,
+            put_version: 6,
+        };
+        let remove_debt = OwnerHotSelectionDebt::new(32, counters.selection_debt_bytes.clone());
+        let remove_event = OwnerHotEvictionEvent {
+            key: remove_identity.key.clone(),
+            put_id: (remove_identity.put_time_ms, remove_identity.put_version),
+            memory_info: Weak::new(),
+            selection_debt: remove_debt,
+            retry: true,
+            source_eviction_cohort: None,
+            retry_failures: 0,
+        };
+        for _ in 0..CHURN {
+            retry_queue.schedule(remove_event.clone(), "remove churn");
+        }
+        assert_eq!(retry_queue.len(), 1);
+        assert_eq!(retry_queue.state.lock().deadlines.len(), 1);
+        retry_queue.remove(&remove_identity);
+        assert_eq!(retry_queue.len(), 0);
+        assert_eq!(retry_queue.state.lock().deadlines.len(), 0);
+        assert_eq!(counters.selection_debt_bytes.load(Ordering::Acquire), 0);
     }
 
     #[test]
@@ -2961,11 +4189,8 @@ mod owner_reclaim_slot_tests {
         let second_group = atomic_groups.get(&second).unwrap().value().clone();
         assert!(Arc::ptr_eq(&first_group, &second_group));
 
-        let triggered = DashSet::new();
-        assert!(triggered.insert(first.clone()));
-        forget_owner_hot_atomic_group(&atomic_groups, &triggered, &second);
+        forget_owner_hot_atomic_group(&atomic_groups, &second);
         assert!(atomic_groups.is_empty());
-        assert!(!triggered.contains(&first));
     }
 
     #[test]
@@ -3010,71 +4235,12 @@ mod owner_reclaim_slot_tests {
         );
     }
 
-    #[test]
-    fn hot_group_trigger_is_persistent_on_success_and_retryable_on_failure() {
-        let member = OwnerHotReplicaIdentity {
-            key: "member".to_string(),
-            put_time_ms: 10,
-            put_version: 2,
-        };
-        let group_trigger = OwnerHotReplicaIdentity {
-            key: "anchor".to_string(),
-            put_time_ms: 10,
-            put_version: 1,
-        };
-        let inflight = Arc::new(DashSet::new());
-        let triggered = Arc::new(DashSet::new());
-        let counters = Arc::new(OwnerHotCacheCounters::default());
-
-        assert!(inflight.insert(member.clone()));
-        assert!(triggered.insert(group_trigger.clone()));
-        let failed_guard = OwnerHotReplicaGuard::new(
-            member.clone(),
-            inflight.clone(),
-            counters.clone(),
-            Some(group_trigger.clone()),
-            triggered.clone(),
-        );
-        drop(failed_guard);
-        assert!(!inflight.contains(&member));
-        assert!(!triggered.contains(&group_trigger));
-        assert_eq!(counters.replica_failed.load(Ordering::Relaxed), 1);
-
-        assert!(inflight.insert(member.clone()));
-        assert!(triggered.insert(group_trigger.clone()));
-        let completed_guard = OwnerHotReplicaGuard::new(
-            member.clone(),
-            inflight.clone(),
-            counters.clone(),
-            Some(group_trigger.clone()),
-            triggered.clone(),
-        );
-        completed_guard.mark_completed();
-        drop(completed_guard);
-        assert!(!inflight.contains(&member));
-        assert!(triggered.contains(&group_trigger));
-        assert_eq!(counters.replica_completed.load(Ordering::Relaxed), 1);
-    }
-
     #[test]
     fn hot_cache_only_dispatches_size_removals_and_keeps_capacity() {
-        let controls = Arc::new(Mutex::new(HashMap::new()));
-        let cached = Arc::new(DashMap::<String, GetCachedInfo>::new());
-        let inflight = Arc::new(DashSet::new());
-        let atomic_groups = Arc::new(DashMap::new());
-        let group_replica_triggered = Arc::new(DashSet::new());
         let counters = Arc::new(OwnerHotCacheCounters::default());
-        let (tx, mut rx) = limit_thirdparty::tokio::sync::ampsc::channel(8);
-        let cache = build_owner_hot_cache(
-            10,
-            controls,
-            cached,
-            inflight,
-            atomic_groups,
-            group_replica_triggered,
-            counters.clone(),
-            tx,
-        );
+        let retry_queue = Arc::new(OwnerHotRetryQueue::new(counters.clone()));
+        let (tx, mut rx) = limit_thirdparty::tokio::sync::ampsc::unbounded_channel();
+        let cache = build_owner_hot_cache(10, counters.clone(), retry_queue, tx);
         let entry = |put_version| OwnerHotCacheEntry {
             put_id: (10, put_version),
             memory_info: Weak::new(),
@@ -3092,36 +4258,45 @@ mod owner_reclaim_slot_tests {
         cache.run_pending_tasks();
         assert!(counters.size_evictions.load(Ordering::Relaxed) >= 1);
         assert_eq!(cache.policy().max_capacity(), Some(10));
-        assert!(
-            rx.try_recv().is_err(),
-            "stale weak entries must not dispatch"
-        );
+        let event = rx
+            .try_recv()
+            .expect("the Moka listener must emit lightweight metadata without pinning");
+        assert!(event.memory_info.upgrade().is_none());
     }
 
     #[test]
-    fn batch_local_visibility_skips_reclaim_fenced_keys() {
+    fn pointwise_batch_visibility_skips_reclaim_fenced_keys() {
         let keys = vec![
             "local-a".to_string(),
             "fenced".to_string(),
             "local-b".to_string(),
         ];
-        let mut controls = HashMap::new();
-        controls.insert(
+        let controls = OwnerKeyControlTable::default();
+        controls.lock_key("fenced").insert(
             "fenced".to_string(),
             OwnerKeyControlState {
                 local_puts: 0,
+                external_pending_puts: 0,
                 reclaim: Some(OwnerReclaimRecord::Committed(OwnerReclaimItem {
                     key: "fenced".to_string(),
                     ..OwnerReclaimItem::default()
                 })),
+                external_get: None,
             },
         );
         let mut resolved_keys = Vec::new();
-
-        let visible = resolve_local_visible_batch(&keys, &controls, |key| {
-            resolved_keys.push(key.to_string());
-            Some(key.to_string())
-        });
+        let visible = keys
+            .iter()
+            .map(|key| {
+                let shard = controls.lock_key(key);
+                if shard.get(key).is_some_and(|state| state.reclaim.is_some()) {
+                    None
+                } else {
+                    resolved_keys.push(key.to_string());
+                    Some(key.to_string())
+                }
+            })
+            .collect::<Vec<_>>();
 
         assert_eq!(
             visible,
@@ -3134,6 +4309,29 @@ mod owner_reclaim_slot_tests {
         assert_eq!(resolved_keys, vec!["local-a", "local-b"]);
     }
 
+    #[test]
+    fn sharded_owner_control_does_not_globally_block_unrelated_keys() {
+        let controls = OwnerKeyControlTable::default();
+        let first = "shard-key-a";
+        let first_shard = OwnerKeyControlTable::shard_index(first);
+        let second = (0..10_000)
+            .map(|idx| format!("shard-key-b-{idx}"))
+            .find(|key| OwnerKeyControlTable::shard_index(key) != first_shard)
+            .expect("a key on another owner-control shard must exist");
+
+        let _first_guard = controls.lock_key(first);
+        assert!(
+            controls.shards[OwnerKeyControlTable::shard_index(&second)]
+                .try_lock()
+                .is_some(),
+            "one key fence must not block an unrelated shard"
+        );
+        assert!(
+            controls.shards[first_shard].try_lock().is_none(),
+            "the same shard must remain serialized while its guard is held"
+        );
+    }
+
     #[test]
     fn committed_slot_becomes_free_only_after_route_and_holder_are_released() {
         let mut grant = OwnerLocalReserveGrantState::new(7, 0, 0, 16, 8, 2);
@@ -3149,6 +4347,43 @@ mod owner_reclaim_slot_tests {
         assert_eq!(grant.free_slots.len(), 2);
         assert!(grant.is_fully_free());
     }
+
+    #[test]
+    fn owner_reclaim_releases_committed_route_and_resident_holder_as_one_pool_update() {
+        let mut class = super::OwnerLocalReserveClassState::new(8, 2);
+        class.install_grant(OwnerLocalReserveGrantState::new(7, 0, 0, 16, 8, 2));
+        let slot = class.claim_available(1).pop().expect("slot should be free");
+        assert!(class.mark_prepared_slot_pending_visible(slot.grant_id, slot.slot_index));
+        assert!(class.retain_resident_slot_holder(slot.grant_id, slot.slot_index));
+        assert!(class.promote_pending_visible_slot_to_committed(slot.grant_id, slot.slot_index));
+        assert_eq!(class.committed_slot_count(), 1);
+        assert_eq!(class.free_slot_count(), 1);
+
+        assert!(class.release_committed_resident_slot(slot.grant_id, slot.slot_index));
+        assert_eq!(class.committed_slot_count(), 0);
+        assert_eq!(class.free_slot_count(), 2);
+    }
+
+    #[test]
+    fn failed_pending_get_releases_only_its_slot() {
+        let mut grant = OwnerLocalReserveGrantState::new(7, 0, 0, 24, 8, 3);
+        let failed = grant.claim_prepared_slot().expect("first slot");
+        let unrelated = grant.claim_prepared_slot().expect("second slot");
+        grant.mark_prepared_slot_pending_visible(failed.slot_index);
+        grant.retain_resident_slot_holder(failed.slot_index);
+
+        grant.release_resident_slot_holder(failed.slot_index);
+
+        assert!(matches!(
+            grant.slot_states[failed.slot_index as usize],
+            OwnerLocalReserveSlotState::Free
+        ));
+        assert!(matches!(
+            grant.slot_states[unrelated.slot_index as usize],
+            OwnerLocalReserveSlotState::Prepared
+        ));
+        assert_eq!(grant.free_slots.len(), 2);
+    }
 }
 
 #[derive(Debug, Default)]
@@ -3339,6 +4574,16 @@ fn format_metrics_snapshot_prometheus(
 }
 
 impl ClientKvApiInner {
+    pub(crate) fn owner_local_reserve_claim_lock(
+        &self,
+        slot_size: u64,
+    ) -> Arc<limit_thirdparty::tokio::sync::AMutex<()>> {
+        self.owner_local_reserve_claim_locks
+            .entry(slot_size)
+            .or_insert_with(|| Arc::new(limit_thirdparty::tokio::sync::AMutex::new(())))
+            .clone()
+    }
+
     pub fn get_holding_len(&self) -> usize {
         self.external_get_holding.total()
     }
@@ -3360,10 +4605,83 @@ impl ClientKvApiInner {
                 )
             })
             .unwrap_or_default();
+        let (
+            external_get_flights,
+            external_get_flights_starting,
+            external_get_flights_finishing,
+            external_get_flights_revoking,
+            external_get_undecided_interests,
+            external_get_retained_interests,
+        ) = {
+            let mut flights = 0u64;
+            let mut starting = 0u64;
+            let mut finishing = 0u64;
+            let mut revoking = 0u64;
+            let mut undecided = 0u64;
+            let mut retained = 0u64;
+            // Metrics use a weak side index and never scan correctness fences.
+            for op in self.external_get_flight_snapshot() {
+                flights = flights.saturating_add(1);
+                let state = op.state.lock();
+                undecided = undecided.saturating_add(state.undecided as u64);
+                retained = retained.saturating_add(state.retained as u64);
+                match &state.phase {
+                    ExternalGetKeySharedPhase::Starting
+                    | ExternalGetKeySharedPhase::Started { .. } => {
+                        starting = starting.saturating_add(1)
+                    }
+                    ExternalGetKeySharedPhase::Finishing { .. } => {
+                        finishing = finishing.saturating_add(1)
+                    }
+                    ExternalGetKeySharedPhase::Revoking { .. } => {
+                        revoking = revoking.saturating_add(1)
+                    }
+                    ExternalGetKeySharedPhase::Ready { .. }
+                    | ExternalGetKeySharedPhase::Failed { .. } => {}
+                }
+            }
+            (flights, starting, finishing, revoking, undecided, retained)
+        };
+        let (
+            local_reserve_slots_free,
+            local_reserve_slots_prepared,
+            local_reserve_slots_pending_visible,
+            local_reserve_slots_committed,
+        ) = {
+            let pool = self.owner_local_reserve_pool.lock();
+            let mut free = 0u64;
+            let mut prepared = 0u64;
+            let mut pending_visible = 0u64;
+            let mut committed = 0u64;
+            for class in pool.classes.values() {
+                free =
+                    free.saturating_add(u64::try_from(class.free_slot_count()).unwrap_or(u64::MAX));
+                prepared = prepared
+                    .saturating_add(u64::try_from(class.prepared_slot_count()).unwrap_or(u64::MAX));
+                pending_visible = pending_visible.saturating_add(
+                    u64::try_from(class.pending_visible_slot_count()).unwrap_or(u64::MAX),
+                );
+                committed = committed.saturating_add(
+                    u64::try_from(class.committed_slot_count()).unwrap_or(u64::MAX),
+                );
+            }
+            (free, prepared, pending_visible, committed)
+        };
         OwnerRuntimeObserveSnapshot {
             external_get_holding_entries: self.external_get_holding.total() as u64,
             external_get_holding_bytes,
+            external_get_start_handles: self.external_get_start_registry.len() as u64,
+            external_get_flights,
+            external_get_flights_starting,
+            external_get_flights_finishing,
+            external_get_flights_revoking,
+            external_get_undecided_interests,
+            external_get_retained_interests,
             external_pending_put_entries: self.external_pending_puts.entry_count(),
+            local_reserve_slots_free,
+            local_reserve_slots_prepared,
+            local_reserve_slots_pending_visible,
+            local_reserve_slots_committed,
             hot_cache_capacity_bytes,
             hot_cache_entries,
             hot_cache_weighted_bytes,
@@ -3371,31 +4689,40 @@ impl ClientKvApiInner {
                 .owner_hot_counters
                 .size_evictions
                 .load(Ordering::Relaxed),
-            hot_replica_enqueued: self
+            hot_source_evict_handoff_members: self
+                .owner_hot_counters
+                .source_evict_handoff_members
+                .load(Ordering::Relaxed),
+            hot_source_evict_committed_members: self
                 .owner_hot_counters
-                .replica_enqueued
+                .source_evict_committed_members
                 .load(Ordering::Relaxed),
-            hot_replica_completed: self
+            hot_source_evict_restored_members: self
                 .owner_hot_counters
-                .replica_completed
+                .source_evict_restored_members
                 .load(Ordering::Relaxed),
-            hot_replica_already_satisfied: self
+            hot_source_evict_obsolete: self
                 .owner_hot_counters
-                .replica_already_satisfied
+                .source_evict_obsolete
                 .load(Ordering::Relaxed),
-            hot_replica_failed: self
+            hot_source_evict_dispatch_failed: self
                 .owner_hot_counters
-                .replica_failed
+                .source_evict_dispatch_failed
                 .load(Ordering::Relaxed),
-            hot_replica_obsolete: self
+            hot_source_eviction_selected: self.owner_source_eviction_selected.len() as u64,
+            hot_source_evict_retry_entries: self.owner_hot_retry_queue.len() as u64,
+            hot_source_evict_retry_scheduled: self
                 .owner_hot_counters
-                .replica_obsolete
+                .source_evict_retry_scheduled
                 .load(Ordering::Relaxed),
-            hot_replica_dispatch_failed: self
+            hot_source_evict_retry_emitted: self
                 .owner_hot_counters
-                .replica_dispatch_failed
+                .source_evict_retry_emitted
+                .load(Ordering::Relaxed),
+            hot_selection_debt_bytes: self
+                .owner_hot_counters
+                .selection_debt_bytes
                 .load(Ordering::Relaxed),
-            hot_replica_inflight: self.owner_hot_replica_inflight.len() as u64,
             hot_eviction_skipped_stale: self
                 .owner_hot_counters
                 .skipped_stale
@@ -3404,20 +4731,7 @@ impl ClientKvApiInner {
                 .owner_hot_counters
                 .skipped_reclaim
                 .load(Ordering::Relaxed),
-            hot_eviction_skipped_duplicate: self
-                .owner_hot_counters
-                .skipped_duplicate
-                .load(Ordering::Relaxed),
             hot_group_registry_entries: self.owner_hot_atomic_groups.len() as u64,
-            hot_group_replica_triggered: self.owner_hot_group_replica_triggered.len() as u64,
-            hot_group_replica_triggers: self
-                .owner_hot_counters
-                .group_replica_triggers
-                .load(Ordering::Relaxed),
-            hot_group_members_enqueued: self
-                .owner_hot_counters
-                .group_members_enqueued
-                .load(Ordering::Relaxed),
             hot_group_trigger_duplicates: self
                 .owner_hot_counters
                 .group_trigger_duplicates
@@ -3905,6 +5219,8 @@ impl ClientKvApiInner {
             .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
         class_state.pending_slot_demand =
             class_state.pending_slot_demand.saturating_add(demand_slots);
+        class_state.max_observed_claim_slots =
+            class_state.max_observed_claim_slots.max(demand_slots);
     }
 
     pub(crate) fn owner_local_reserve_consume_pending_demand(
@@ -3950,33 +5266,46 @@ impl ClientKvApi {
                         metrics.set_kv_external_pending_put_entries(
                             snapshot.external_pending_put_entries,
                         );
+                        tracing::info!(
+                            active_handles = snapshot.external_get_start_handles,
+                            active_flights = snapshot.external_get_flights,
+                            starting_flights = snapshot.external_get_flights_starting,
+                            finishing_flights = snapshot.external_get_flights_finishing,
+                            revoking_flights = snapshot.external_get_flights_revoking,
+                            undecided_interests = snapshot.external_get_undecided_interests,
+                            retained_interests = snapshot.external_get_retained_interests,
+                            reserve_free = snapshot.local_reserve_slots_free,
+                            reserve_prepared = snapshot.local_reserve_slots_prepared,
+                            reserve_pending_visible = snapshot.local_reserve_slots_pending_visible,
+                            reserve_committed = snapshot.local_reserve_slots_committed,
+                            "owner Get lifecycle snapshot"
+                        );
                         if snapshot.hot_cache_capacity_bytes > 0 {
                             tracing::info!(
                                 capacity_bytes = snapshot.hot_cache_capacity_bytes,
                                 entries = snapshot.hot_cache_entries,
                                 weighted_bytes = snapshot.hot_cache_weighted_bytes,
                                 size_evictions = snapshot.hot_size_evictions,
-                                replica_enqueued = snapshot.hot_replica_enqueued,
-                                replica_completed = snapshot.hot_replica_completed,
-                                replica_already_satisfied = snapshot.hot_replica_already_satisfied,
-                                replica_failed = snapshot.hot_replica_failed,
-                                replica_obsolete = snapshot.hot_replica_obsolete,
-                                replica_dispatch_failed = snapshot.hot_replica_dispatch_failed,
-                                replica_inflight = snapshot.hot_replica_inflight,
+                                source_evict_handoff_members = snapshot.hot_source_evict_handoff_members,
+                                source_evict_committed_members = snapshot.hot_source_evict_committed_members,
+                                source_evict_restored_members = snapshot.hot_source_evict_restored_members,
+                                source_evict_obsolete = snapshot.hot_source_evict_obsolete,
+                                source_evict_dispatch_failed = snapshot.hot_source_evict_dispatch_failed,
+                                source_eviction_selected = snapshot.hot_source_eviction_selected,
+                                source_evict_retry_entries = snapshot.hot_source_evict_retry_entries,
+                                source_evict_retry_scheduled = snapshot.hot_source_evict_retry_scheduled,
+                                source_evict_retry_emitted = snapshot.hot_source_evict_retry_emitted,
+                                selection_debt_bytes = snapshot.hot_selection_debt_bytes,
                                 skipped_stale = snapshot.hot_eviction_skipped_stale,
                                 skipped_reclaim = snapshot.hot_eviction_skipped_reclaim,
-                                skipped_duplicate = snapshot.hot_eviction_skipped_duplicate,
                                 group_registry_entries = snapshot.hot_group_registry_entries,
-                                group_replica_triggered = snapshot.hot_group_replica_triggered,
-                                group_replica_triggers = snapshot.hot_group_replica_triggers,
-                                group_members_enqueued = snapshot.hot_group_members_enqueued,
                                 group_trigger_duplicates = snapshot.hot_group_trigger_duplicates,
                                 group_trigger_incomplete = snapshot.hot_group_trigger_incomplete,
                                 grouped_put_done_batches = snapshot.grouped_put_done_batches,
                                 grouped_put_done_items = snapshot.grouped_put_done_items,
                                 legacy_put_done_batches = snapshot.legacy_put_done_batches,
                                 legacy_put_done_items = snapshot.legacy_put_done_items,
-                                "owner hot replica policy snapshot"
+                                "owner hot source-eviction policy snapshot"
                             );
                         }
                     }
@@ -3999,24 +5328,25 @@ impl ClientKvApi {
             tokio::sync::ampsc::channel(REPLICA_TASK_QUEUE_CAPACITY);
         let (owner_local_publish_tx, owner_local_publish_rx) =
             tokio::sync::ampsc::channel(OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY);
+        // The Moka eviction listener is synchronous and must never block while
+        // holding Moka's housekeeper lock. Events contain only weak payload
+        // references and are deduplicated by exact selected identities, so use
+        // a lossless metadata channel instead of dropping cohorts when the old
+        // bounded queue briefly filled under cache pressure.
         let (owner_hot_eviction_tx, owner_hot_eviction_rx) =
-            tokio::sync::ampsc::channel(OWNER_HOT_EVICTION_QUEUE_CAPACITY);
+            tokio::sync::ampsc::unbounded_channel();
         let get_cached_info = Arc::new(DashMap::new());
-        let owner_key_control = Arc::new(Mutex::new(HashMap::new()));
-        let owner_hot_replica_inflight = Arc::new(DashSet::new());
+        let owner_key_control = Arc::new(OwnerKeyControlTable::default());
+        let owner_source_eviction_selected = Arc::new(DashMap::new());
         let owner_hot_atomic_groups = Arc::new(DashMap::new());
-        let owner_hot_group_replica_triggered = Arc::new(DashSet::new());
         let owner_hot_counters = Arc::new(OwnerHotCacheCounters::default());
+        let owner_hot_retry_queue = Arc::new(OwnerHotRetryQueue::new(owner_hot_counters.clone()));
         let owner_hot_cache = owner_hot_cache_capacity_bytes.map(|capacity_bytes| {
             build_owner_hot_cache(
                 capacity_bytes,
-                owner_key_control.clone(),
-                get_cached_info.clone(),
-                owner_hot_replica_inflight.clone(),
-                owner_hot_atomic_groups.clone(),
-                owner_hot_group_replica_triggered.clone(),
                 owner_hot_counters.clone(),
-                owner_hot_eviction_tx,
+                owner_hot_retry_queue.clone(),
+                owner_hot_eviction_tx.clone(),
             )
         });
 
@@ -4028,19 +5358,22 @@ impl ClientKvApi {
             get_remote_kv_lock: AMapLock::new(Duration::from_secs(60)),
             get_cached_info,
             precommit_local_visible_info: DashMap::new(),
+            pending_local_get_info: DashMap::new(),
             local_snapshot_info: DashMap::new(),
             owner_local_reserve_pool: Mutex::new(OwnerLocalReservePoolState::default()),
-            owner_local_reserve_claim_lock: limit_thirdparty::tokio::sync::AMutex::new(()),
+            owner_local_reserve_claim_locks: DashMap::new(),
             owner_local_reserve_rebalance_notify: Arc::new(
                 limit_thirdparty::tokio::sync::Notify::new(),
             ),
             external_local_first_put_id_counter: AtomicU32::new(0),
+            next_owner_source_eviction_operation_id: AtomicU64::new(1),
             owner_key_control,
             owner_hot_cache,
-            owner_hot_replica_inflight,
+            owner_source_eviction_selected,
             owner_hot_atomic_groups,
-            owner_hot_group_replica_triggered,
             owner_hot_counters,
+            owner_hot_retry_queue,
+            owner_hot_eviction_tx,
             owner_hot_eviction_rx: Mutex::new(Some(owner_hot_eviction_rx)),
             external_invalidate_delete: EnsureMemholderMgmtDeleteHandle::new(
                 OwnerExternalMemMgr::DELETE_SUBMIT_QUEUE_CAPACITY,
@@ -4051,7 +5384,7 @@ impl ClientKvApi {
             owner_delete_ack_mgr: OwnerDeleteAckMemMgr::default(),
             external_get_holding: OwnerExternalMemMgr::default(),
             external_get_start_registry: DashMap::new(),
-            external_get_start_by_key: DashMap::new(),
+            external_get_flight_registry: DashMap::new(),
             next_external_get_start_handle: AtomicU64::new(1),
             next_external_holding_id: AtomicU64::new(1),
             external_pending_puts: moka::sync::Cache::builder()
@@ -4076,8 +5409,11 @@ impl ClientKvApi {
             rpc_caller_batch_prepare_put_keys: RPCCaller::new(),
             rpc_caller_batch_release_put_key_reservations: RPCCaller::new(),
             rpc_caller_put_append_start: RPCCaller::new(),
+            rpc_caller_batch_put_append_start: RPCCaller::new(),
             rpc_caller_put_append_revoke: RPCCaller::new(),
             rpc_caller_put_append_done: RPCCaller::new(),
+            rpc_caller_batch_put_append_done: RPCCaller::new(),
+            rpc_caller_batch_evict_owner_source: RPCCaller::new(),
             rpc_caller_reserve_local_grant: RPCCaller::new(),
             rpc_caller_release_local_grant: RPCCaller::new(),
             rpc_caller_delete: RPCCaller::new(),
@@ -4142,12 +5478,21 @@ impl ClientKvApi {
         inner
             .rpc_caller_put_append_start
             .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_put_append_start
+            .regist(inner.view.p2p_module());
         inner
             .rpc_caller_put_append_revoke
             .regist(inner.view.p2p_module());
         inner
             .rpc_caller_put_append_done
             .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_put_append_done
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_evict_owner_source
+            .regist(inner.view.p2p_module());
         inner
             .rpc_caller_reserve_local_grant
             .regist(inner.view.p2p_module());
@@ -4179,6 +5524,8 @@ impl ClientKvApi {
         RPCCaller::<BatchIsExistReq>::new().regist(inner.view.p2p_module());
         RPCCaller::<BatchDeleteClientKvMetaCacheReq>::new().regist(inner.view.p2p_module());
         spawn_owner_local_reserve_rebalance_actor(inner.view.clone_view());
+        spawn_owner_slot_pressure_actor(inner.view.clone_view());
+        external_api::spawn_external_get_start_handle_sweeper(inner.view.clone_view());
         self.spawn_runtime_observe_reporter();
 
         // External RPC handlers
@@ -4533,10 +5880,11 @@ impl ClientKvApi {
         }
         if inner.owner_hot_cache.is_some() {
             if let Some(owner_hot_eviction_rx) = inner.owner_hot_eviction_rx.lock().take() {
-                put::spawn_owner_hot_replica_dispatcher(
+                put::spawn_owner_source_eviction_dispatcher(
                     inner.view.clone_view(),
                     owner_hot_eviction_rx,
                 );
+                put::spawn_owner_hot_retry_actor(inner.view.clone_view());
             } else {
                 tracing::warn!("owner_hot_eviction_rx already taken for ClientKvApi");
             }
@@ -4551,7 +5899,7 @@ impl ClientKvApi {
             tracing::warn!("owner_local_publish_rx already taken for ClientKvApi");
         }
 
-        // Spawn cluster listener to clean up get_holding when external_client leaves
+        // Spawn cluster listener to retire generation-scoped external requester state.
         let view = inner.view.clone_view();
         let view2 = view.clone();
         let view_task = view2.clone();
@@ -4566,15 +5914,43 @@ impl ClientKvApi {
                             Ok(event) => {
                                 match event {
                                     ClusterEvent::MemberLeft(node_id) => {
-                                        let removed = view_task
-                                            .client_kv_api()
-                                            .inner()
+                                        let departed_epoch = view_task
+                                            .cluster_manager()
+                                            .get_prev_member_info(&node_id)
+                                            .map(|member| member.node_start_time);
+                                        let current_epoch = view_task
+                                            .cluster_manager()
+                                            .get_member_info_cached(&node_id)
+                                            .map(|member| member.node_start_time);
+                                        let Some(departed_epoch) = external_api::external_member_left_departed_epoch(
+                                            departed_epoch,
+                                            current_epoch,
+                                        ) else {
+                                            tracing::debug!(
+                                                "Ignoring ambiguous/delayed external MemberLeft: node={} departed_epoch={:?} current_epoch={:?}",
+                                                node_id,
+                                                departed_epoch,
+                                                current_epoch,
+                                            );
+                                            continue;
+                                        };
+
+                                        let inner = view_task.client_kv_api().inner();
+                                        let removed_handles = external_api::cleanup_external_get_start_handles_for_generation(
+                                            &inner.external_get_start_registry,
+                                            &node_id,
+                                            departed_epoch,
+                                        );
+                                        let removed_holdings = inner
                                             .external_get_holding
-                                            .cleanup_node(&node_id);
-                                        if removed > 0 {
+                                            .cleanup_node_generation(&node_id, departed_epoch);
+                                        if removed_handles > 0 || removed_holdings > 0 {
                                             tracing::info!(
-                                                "Cleaned up get_holding for external_client: {} (removed {} holdings)",
-                                                node_id, removed
+                                                "Cleaned up departed external requester state: node={} epoch={} handles={} holdings={}",
+                                                node_id,
+                                                departed_epoch,
+                                                removed_handles,
+                                                removed_holdings,
                                             );
                                         }
                                     }
@@ -4582,8 +5958,11 @@ impl ClientKvApi {
                                 }
                             }
                             Err(e) => {
-                                tracing::error!("Failed to receive cluster event: {}", e);
-                                break;
+                                tracing::warn!(
+                                    "Client cluster event receiver error (will resubscribe): {}",
+                                    e
+                                );
+                                listen_cluster_event = view_task.cluster_manager().listen();
                             }
                         }
                     }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index 1171c65..8bfa822 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -1,8 +1,9 @@
 use super::{
-    ClientKvApiInner, OwnerHotEvictionEvent, OwnerLocalReserveClassState,
-    OwnerLocalReserveGrantState, OwnerLocalReservePoolState, OwnerLocalReserveSlotLease,
-    OwnerLocalReserveSlotRef, ReplicaTaskJob, ReplicaTaskTarget,
+    ClientKvApiInner, OwnerHotEvictionEvent, OwnerHotEvictionPreparation, OwnerHotSelectionDebt,
+    OwnerLocalReserveClassState, OwnerLocalReserveGrantState, OwnerLocalReservePoolState,
+    OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, ReplicaTaskJob, ReplicaTaskTarget,
     local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
+    owner_hot_weight_bytes,
 };
 use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 use crate::cluster_manager::NodeIDString;
@@ -16,16 +17,20 @@ use crate::observe_kvope::{
 use crate::{
     client_kv_api::ClientKvApiView,
     master_kv_router::msg_pack::{
-        BatchEnqueueReplicaTaskReq, BatchEnqueueReplicaTaskResp, BatchPreparePutKeyItemReq,
-        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutDoneItemReq, BatchPutDoneReq,
+        BatchEnqueueReplicaTaskReq, BatchEnqueueReplicaTaskResp, BatchEvictOwnerSourceReq,
+        BatchEvictOwnerSourceResp, BatchPreparePutKeyItemReq, BatchPreparePutKeysReq,
+        BatchPreparePutKeysResp, BatchPutAppendDoneItemReq, BatchPutAppendDoneReq,
+        BatchPutAppendDoneResp, BatchPutAppendStartItemReq, BatchPutAppendStartReq,
+        BatchPutAppendStartResp, BatchPutDoneItemReq, BatchPutDoneItemResp, BatchPutDoneReq,
         BatchPutDoneResp, BatchPutRevokeItemReq, BatchPutRevokeReq, BatchPutRevokeResp,
         BatchPutStartItemReq, BatchPutStartReq, BatchPutStartResp,
         BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
         EnqueueReplicaTaskItemResp, GroupedBatchPutDoneItemReq, GroupedBatchPutDoneReq,
-        GroupedBatchPutDoneResp, PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq,
-        PutAppendStartReq, PutAppendStartResp, PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq,
-        PutRevokeReq, PutStartReq, PutStartResp, ReleaseLocalGrantReq, ReserveLocalGrantOutcome,
-        ReserveLocalGrantReq,
+        GroupedBatchPutDoneResp, OwnerReclaimBacking, OwnerSourceEvictionCohort,
+        OwnerSourceEvictionMember, OwnerSourceEvictionOutcome, PutAppendDoneReq, PutAppendDoneResp,
+        PutAppendRevokeReq, PutAppendStartOutcome, PutAppendStartReq, PutAppendStartResp,
+        PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
+        ReleaseLocalGrantReq, ReserveLocalGrantOutcome, ReserveLocalGrantReq,
     },
     memholder::{UserMemHolder, UserMemHolderExposeKind},
     p2p::msg_pack::MsgPack,
@@ -34,7 +39,7 @@ use crate::{
 };
 use chrono::Utc;
 use fluxon_commu::TransferBreakdown;
-use fluxon_util::semaphore_map::SemaphoreMap;
+use futures::future::join_all;
 use limit_thirdparty::tokio;
 use std::sync::{Arc, atomic::Ordering};
 use std::time::{Duration, Instant};
@@ -78,7 +83,7 @@ fn owner_local_reserve_install_grant(
         class_state.slots_per_grant == slots_per_grant,
         "slots_per_grant drift detected while installing local reserve grant"
     );
-    class_state.grants.push(grant);
+    class_state.install_grant(grant);
 }
 
 fn owner_local_reserve_try_claim(
@@ -120,18 +125,7 @@ fn owner_local_reserve_claim_available(
         .entry(slot_size)
         .or_insert_with(|| OwnerLocalReserveClassState::new(slot_size, slots_per_grant));
     let claim_count = class_state.free_slot_count().min(max_slots);
-    let mut slots = Vec::with_capacity(claim_count);
-    for grant in class_state.grants.iter_mut() {
-        while slots.len() < claim_count {
-            match grant.claim_prepared_slot() {
-                Some(slot) => slots.push(slot),
-                None => break,
-            }
-        }
-        if slots.len() == claim_count {
-            break;
-        }
-    }
+    let slots = class_state.claim_available(max_slots);
     assert_eq!(
         slots.len(),
         claim_count,
@@ -241,6 +235,125 @@ mod local_reserve_claim_tests {
         assert_eq!(pool.classes.get(&8).unwrap().free_slot_count(), 0);
     }
 
+    #[test]
+    fn grant_index_and_cached_counters_survive_swap_remove_and_reinstall() {
+        const SLOT_SIZE: u64 = 8;
+        const SLOTS_PER_GRANT: u32 = 4;
+        let mut pool = OwnerLocalReservePoolState::default();
+        for grant_id in 1..=3 {
+            owner_local_reserve_install_grant(
+                &mut pool,
+                SLOT_SIZE,
+                SLOTS_PER_GRANT,
+                OwnerLocalReserveGrantState::new(
+                    grant_id,
+                    grant_id * 1000,
+                    grant_id * 1000,
+                    SLOT_SIZE * u64::from(SLOTS_PER_GRANT),
+                    SLOT_SIZE,
+                    SLOTS_PER_GRANT,
+                ),
+            );
+        }
+
+        let class = pool.classes.get_mut(&SLOT_SIZE).unwrap();
+        assert_eq!(class.free_slot_count(), 12);
+        assert_eq!(class.used_slot_count(), 0);
+        let detached = class
+            .detach_fully_free_grant(2)
+            .expect("middle grant must be indexed");
+        assert_eq!(class.free_slot_count(), 8);
+        assert_eq!(class.grant_count(), 2);
+
+        // Removing the middle Vec entry swap-moves grant 3. A subsequent state
+        // transition by grant id proves that its repaired index is authoritative.
+        let claimed = class.claim_available(1);
+        assert_eq!(claimed.len(), 1);
+        assert_eq!(claimed[0].grant_id, 3);
+        assert_eq!(class.free_slot_count(), 7);
+        assert_eq!(class.prepared_slot_count(), 1);
+        assert!(class.release_prepared_slot(3, claimed[0].slot_index));
+        assert_eq!(class.free_slot_count(), 8);
+        assert_eq!(class.prepared_slot_count(), 0);
+
+        class.install_grant(detached);
+        assert_eq!(class.free_slot_count(), 12);
+        assert_eq!(class.used_slot_count(), 0);
+        assert_eq!(class.grant_count(), 3);
+    }
+
+    #[test]
+    fn committed_slots_are_reclaimed_and_reused_independently_across_grants() {
+        const SLOT_SIZE: u64 = 8;
+        const SLOTS_PER_GRANT: u32 = 4;
+
+        let mut pool = OwnerLocalReservePoolState::default();
+        for (grant_id, addr) in [(1, 1000), (2, 2000)] {
+            owner_local_reserve_install_grant(
+                &mut pool,
+                SLOT_SIZE,
+                SLOTS_PER_GRANT,
+                OwnerLocalReserveGrantState::new(
+                    grant_id,
+                    addr,
+                    addr,
+                    SLOT_SIZE * u64::from(SLOTS_PER_GRANT),
+                    SLOT_SIZE,
+                    SLOTS_PER_GRANT,
+                ),
+            );
+        }
+
+        let initial = owner_local_reserve_claim_available(&mut pool, SLOT_SIZE, SLOTS_PER_GRANT, 8);
+        assert_eq!(initial.len(), 8);
+        {
+            let class = pool.classes.get_mut(&SLOT_SIZE).unwrap();
+            for slot in &initial {
+                assert!(class.mark_prepared_slot_pending_visible(slot.grant_id, slot.slot_index));
+                assert!(class.retain_resident_slot_holder(slot.grant_id, slot.slot_index));
+                assert!(
+                    class.promote_pending_visible_slot_to_committed(slot.grant_id, slot.slot_index)
+                );
+            }
+        }
+
+        let victims = [initial[1].clone(), initial[5].clone()];
+        {
+            let class = pool.classes.get_mut(&SLOT_SIZE).unwrap();
+            for victim in &victims {
+                assert!(class.release_committed_slot_route(victim.grant_id, victim.slot_index));
+                assert!(class.release_resident_slot_holder(victim.grant_id, victim.slot_index));
+            }
+            assert_eq!(class.free_slot_count(), 2);
+            assert_eq!(class.grant_count(), 2);
+            assert!(class.grants.iter().all(|grant| !grant.is_fully_free()));
+            assert!(class.grants.iter().all(|grant| grant.free_slots.len() == 1));
+        }
+
+        for cycle in 0..10 {
+            let reused =
+                owner_local_reserve_claim_available(&mut pool, SLOT_SIZE, SLOTS_PER_GRANT, 2);
+            assert_eq!(reused.len(), 2, "cycle {cycle} did not reuse both slots");
+            let mut reused_grant_ids = reused.iter().map(|slot| slot.grant_id).collect::<Vec<_>>();
+            reused_grant_ids.sort_unstable();
+            assert_eq!(reused_grant_ids, vec![1, 2]);
+
+            let class = pool.classes.get_mut(&SLOT_SIZE).unwrap();
+            for slot in reused {
+                assert!(class.mark_prepared_slot_pending_visible(slot.grant_id, slot.slot_index));
+                assert!(class.retain_resident_slot_holder(slot.grant_id, slot.slot_index));
+                assert!(
+                    class.promote_pending_visible_slot_to_committed(slot.grant_id, slot.slot_index)
+                );
+                assert!(class.release_committed_slot_route(slot.grant_id, slot.slot_index));
+                assert!(class.release_resident_slot_holder(slot.grant_id, slot.slot_index));
+            }
+            assert_eq!(class.free_slot_count(), 2);
+            assert_eq!(class.grant_count(), 2);
+            assert!(class.grants.iter().all(|grant| !grant.is_fully_free()));
+        }
+    }
+
     #[limit_thirdparty::tokio::test]
     async fn later_waiter_cannot_steal_slot_before_current_claim_turn_completes() {
         const SLOT_SIZE: u64 = 4 * 1024;
@@ -272,7 +385,8 @@ mod local_reserve_claim_tests {
         }
 
         // Model a five-slot waiter that has made partial progress while owning the claim turn.
-        let current_claim_turn = api.inner().owner_local_reserve_claim_lock.lock().await;
+        let claim_lock = api.inner().owner_local_reserve_claim_lock(SLOT_SIZE);
+        let current_claim_turn = claim_lock.lock().await;
         let first_partial = {
             let mut pool = api.inner().owner_local_reserve_pool.lock();
             owner_local_reserve_claim_available(&mut pool, SLOT_SIZE, SLOTS_PER_GRANT, 3)
@@ -335,10 +449,110 @@ mod local_reserve_claim_tests {
         assert_eq!(later_lease.slots.len(), 1);
     }
 
+    #[limit_thirdparty::tokio::test]
+    async fn same_class_claim_waiters_complete_in_fifo_order() {
+        const SLOT_SIZE: u64 = 4 * 1024;
+
+        let api = Arc::new(
+            ClientKvApi::construct(ClientKvApiNewArg {
+                test_spec_config: TestSpecConfig::default(),
+                owner_hot_cache_capacity_bytes: None,
+            })
+            .await
+            .expect("construct test ClientKvApi"),
+        );
+        let claim_lock = api.inner().owner_local_reserve_claim_lock(SLOT_SIZE);
+        let claim_turn = claim_lock.lock().await;
+        let order = Arc::new(std::sync::Mutex::new(Vec::new()));
+
+        let first_queued = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let first_lock = api.inner().owner_local_reserve_claim_lock(SLOT_SIZE);
+        let first_order = Arc::clone(&order);
+        let first_queued_task = Arc::clone(&first_queued);
+        let first = tokio::spawn(async move {
+            first_queued_task.store(true, std::sync::atomic::Ordering::Release);
+            let _turn = first_lock.lock_owned().await;
+            first_order.lock().unwrap().push(1u8);
+        });
+        while !first_queued.load(std::sync::atomic::Ordering::Acquire) {
+            tokio::task::yield_now().await;
+        }
+
+        let second_queued = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let second_lock = api.inner().owner_local_reserve_claim_lock(SLOT_SIZE);
+        let second_order = Arc::clone(&order);
+        let second_queued_task = Arc::clone(&second_queued);
+        let second = tokio::spawn(async move {
+            second_queued_task.store(true, std::sync::atomic::Ordering::Release);
+            let _turn = second_lock.lock_owned().await;
+            second_order.lock().unwrap().push(2u8);
+        });
+        while !second_queued.load(std::sync::atomic::Ordering::Acquire) {
+            tokio::task::yield_now().await;
+        }
+        drop(claim_turn);
+
+        limit_thirdparty::tokio::time::timeout(Duration::from_secs(1), async {
+            first.await.expect("first same-class waiter panicked");
+            second.await.expect("second same-class waiter panicked");
+        })
+        .await
+        .expect("same-class FIFO waiters did not complete");
+        assert_eq!(*order.lock().unwrap(), vec![1, 2]);
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn pressured_class_does_not_block_an_unrelated_slot_class() {
+        const BLOCKED_SLOT_SIZE: u64 = 4 * 1024;
+        const READY_SLOT_SIZE: u64 = 8 * 1024;
+        let ready_slots_per_grant = owner_local_reserve_slots_per_grant(READY_SLOT_SIZE);
+
+        let api = Arc::new(
+            ClientKvApi::construct(ClientKvApiNewArg {
+                test_spec_config: TestSpecConfig::default(),
+                owner_hot_cache_capacity_bytes: None,
+            })
+            .await
+            .expect("construct test ClientKvApi"),
+        );
+        let blocked_lock = api
+            .inner()
+            .owner_local_reserve_claim_lock(BLOCKED_SLOT_SIZE);
+        let _blocked_turn = blocked_lock.lock().await;
+        {
+            let mut pool = api.inner().owner_local_reserve_pool.lock();
+            owner_local_reserve_install_grant(
+                &mut pool,
+                READY_SLOT_SIZE,
+                ready_slots_per_grant,
+                OwnerLocalReserveGrantState::new(
+                    1,
+                    1000,
+                    1000,
+                    READY_SLOT_SIZE * u64::from(ready_slots_per_grant),
+                    READY_SLOT_SIZE,
+                    ready_slots_per_grant,
+                ),
+            );
+        }
+
+        let ready_api = Arc::clone(&api);
+        let ready_lease = limit_thirdparty::tokio::time::timeout(
+            Duration::from_secs(1),
+            ready_api
+                .inner()
+                .owner_claim_local_reserve_slot_lease(READY_SLOT_SIZE, 1),
+        )
+        .await
+        .expect("an unrelated slot class was head-of-line blocked")
+        .expect("ready slot class claim failed");
+        assert_eq!(ready_lease.slot_size, READY_SLOT_SIZE);
+        assert_eq!(ready_lease.slots.len(), 1);
+    }
+
     #[limit_thirdparty::tokio::test]
     async fn queued_claims_publish_aggregate_demand_and_cancel_cleanly() {
         const SLOT_SIZE: u64 = 4 * 1024;
-        const SLOTS_PER_GRANT: u32 = 4;
 
         let api = Arc::new(
             ClientKvApi::construct(ClientKvApiNewArg {
@@ -348,7 +562,8 @@ mod local_reserve_claim_tests {
             .await
             .expect("construct test ClientKvApi"),
         );
-        let claim_turn = api.inner().owner_local_reserve_claim_lock.lock().await;
+        let claim_lock = api.inner().owner_local_reserve_claim_lock(SLOT_SIZE);
+        let claim_turn = claim_lock.lock().await;
 
         let first_api = Arc::clone(&api);
         let first = tokio::spawn(async move {
@@ -435,6 +650,10 @@ pub struct OwnerLocalPublishItem {
 pub struct OwnerLocalPublishJob {
     pub items: Vec<OwnerLocalPublishItem>,
     pub key_reservation_ids: Vec<u64>,
+    /// External local-first requests keep their owner reclaim fences here until
+    /// the grouped master terminal response and all local promotions complete.
+    /// Native/Pyo3 jobs use master key reservations instead and leave this empty.
+    pub external_pending_contexts: Vec<super::ExternalPendingPutCtx>,
 }
 
 #[derive(Debug, Clone, Copy, Default)]
@@ -525,12 +744,8 @@ impl ClientKvApiInner {
                 request_started_at,
             ));
         };
-        let _claim_turn = match tokio::time::timeout(
-            remaining_for_turn,
-            self.owner_local_reserve_claim_lock.lock(),
-        )
-        .await
-        {
+        let claim_lock = self.owner_local_reserve_claim_lock(slot_size);
+        let _claim_turn = match tokio::time::timeout(remaining_for_turn, claim_lock.lock()).await {
             Ok(claim_turn) => claim_turn,
             Err(_) => {
                 return Err(owner_local_reserve_timeout_error(
@@ -611,19 +826,14 @@ impl ClientKvApiInner {
                 }));
             };
             for slot_ref in &lease.slots {
-                let Some(grant) = class_state
-                    .grants
-                    .iter_mut()
-                    .find(|grant| grant.grant_id == slot_ref.grant_id)
-                else {
+                if !class_state.release_prepared_slot(slot_ref.grant_id, slot_ref.slot_index) {
                     return Err(KvError::Api(ApiError::Unknown {
                         detail: format!(
                             "resident local reserve grant missing while releasing slot lease: grant_id={}",
                             slot_ref.grant_id
                         ),
                     }));
-                };
-                grant.release_prepared_slot(slot_ref.slot_index);
+                }
             }
         }
         self.owner_local_reserve_rebalance_notify().notify_waiters();
@@ -645,19 +855,14 @@ impl ClientKvApiInner {
                 ),
             }));
         };
-        let Some(grant) = class_state
-            .grants
-            .iter_mut()
-            .find(|grant| grant.grant_id == grant_id)
-        else {
+        if !class_state.mark_prepared_slot_pending_visible(grant_id, slot_index) {
             return Err(KvError::Api(ApiError::Unknown {
                 detail: format!(
                     "local reserve grant missing while marking pending slot: grant_id={}",
                     grant_id
                 ),
             }));
-        };
-        grant.mark_prepared_slot_pending_visible(slot_index);
+        }
         Ok(())
     }
 
@@ -676,19 +881,14 @@ impl ClientKvApiInner {
                 ),
             }));
         };
-        let Some(grant) = class_state
-            .grants
-            .iter_mut()
-            .find(|grant| grant.grant_id == grant_id)
-        else {
+        if !class_state.promote_pending_visible_slot_to_committed(grant_id, slot_index) {
             return Err(KvError::Api(ApiError::Unknown {
                 detail: format!(
                     "local reserve grant missing while promoting pending slot: grant_id={}",
                     grant_id
                 ),
             }));
-        };
-        grant.promote_pending_visible_slot_to_committed(slot_index);
+        }
         Ok(())
     }
 
@@ -707,19 +907,14 @@ impl ClientKvApiInner {
                 ),
             }));
         };
-        let Some(grant) = class_state
-            .grants
-            .iter_mut()
-            .find(|grant| grant.grant_id == grant_id)
-        else {
+        if !class_state.retain_resident_slot_holder(grant_id, slot_index) {
             return Err(KvError::Api(ApiError::Unknown {
                 detail: format!(
                     "local reserve grant missing while retaining resident slot holder: grant_id={}",
                     grant_id
                 ),
             }));
-        };
-        grant.retain_resident_slot_holder(slot_index);
+        }
         Ok(())
     }
 
@@ -739,19 +934,14 @@ impl ClientKvApiInner {
                     ),
                 }));
             };
-            let Some(grant) = class_state
-                .grants
-                .iter_mut()
-                .find(|grant| grant.grant_id == grant_id)
-            else {
+            if !class_state.release_resident_slot_holder(grant_id, slot_index) {
                 return Err(KvError::Api(ApiError::Unknown {
                     detail: format!(
                         "local reserve grant missing while releasing resident slot holder: grant_id={}",
                         grant_id
                     ),
                 }));
-            };
-            grant.release_resident_slot_holder(slot_index);
+            }
         }
         self.owner_local_reserve_rebalance_notify().notify_waiters();
         Ok(())
@@ -773,19 +963,43 @@ impl ClientKvApiInner {
                     ),
                 }));
             };
-            let Some(grant) = class_state
-                .grants
-                .iter_mut()
-                .find(|grant| grant.grant_id == grant_id)
-            else {
+            if !class_state.release_committed_slot_route(grant_id, slot_index) {
                 return Err(KvError::Api(ApiError::Unknown {
                     detail: format!(
                         "local reserve grant missing while releasing committed slot route: grant_id={}",
                         grant_id
                     ),
                 }));
+            }
+        }
+        self.owner_local_reserve_rebalance_notify().notify_waiters();
+        Ok(())
+    }
+
+    pub fn owner_release_local_reserve_committed_resident_slot(
+        &self,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> KvResult<()> {
+        {
+            let mut pool = self.owner_local_reserve_pool.lock();
+            let Some(class_state) = pool.classes.get_mut(&slot_size) else {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "local reserve class missing while reclaiming committed resident slot: slot_size={}",
+                        slot_size
+                    ),
+                }));
             };
-            grant.release_committed_slot_route(slot_index);
+            if !class_state.release_committed_resident_slot(grant_id, slot_index) {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "local reserve grant missing while reclaiming committed resident slot: grant_id={}",
+                        grant_id
+                    ),
+                }));
+            }
         }
         self.owner_local_reserve_rebalance_notify().notify_waiters();
         Ok(())
@@ -795,8 +1009,8 @@ impl ClientKvApiInner {
         let grants = {
             let mut pool = self.owner_local_reserve_pool.lock();
             let mut detached = Vec::new();
-            for (_slot_size, class_state) in pool.classes.drain() {
-                detached.extend(class_state.grants);
+            for (_slot_size, mut class_state) in pool.classes.drain() {
+                detached.extend(class_state.take_all_grants());
             }
             detached
         };
@@ -1263,10 +1477,9 @@ impl ClientKvApiInner {
             .send(ReplicaTaskJob {
                 key: key.to_string(),
                 put_id,
-                holder,
+                holder: Some(holder),
                 target: Some(target),
                 preferred_sub_cluster: None,
-                hot_replica_guard: None,
                 protect_source_on_remote_complete: true,
             })
             .await
@@ -1314,10 +1527,9 @@ impl ClientKvApiInner {
             .send(ReplicaTaskJob {
                 key: key.to_string(),
                 put_id,
-                holder,
+                holder: Some(holder),
                 target: None,
                 preferred_sub_cluster,
-                hot_replica_guard: None,
                 protect_source_on_remote_complete,
             })
             .await
@@ -1808,23 +2020,14 @@ impl ClientKvApiInner {
         .await
     }
 
-    pub async fn reserve_local_grant(
-        &self,
-        slot_size: u64,
-        required_free_slots: u32,
-        reclaim_before_grow: bool,
-    ) -> KvResult<ReserveLocalGrantOutcome> {
+    pub async fn reserve_local_grant(&self) -> KvResult<ReserveLocalGrantOutcome> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
                 detail: "ClientKvApi is shutting down; rejecting reserve_local_grant".to_string(),
             }));
         }
         let req = MsgPack {
-            serialize_part: ReserveLocalGrantReq {
-                slot_size,
-                required_free_slots,
-                reclaim_before_grow,
-            },
+            serialize_part: ReserveLocalGrantReq {},
             raw_bytes: Vec::new(),
         };
         let master_node_id = self
@@ -1933,7 +2136,6 @@ impl ClientKvApiInner {
         put_id: PutIDForAKey,
         len: u32,
         preferred_sub_cluster: Option<&str>,
-        demote_source_on_remote_complete: bool,
         protect_source_on_remote_complete: bool,
     ) -> KvResult<PutAppendStartResp> {
         if !self.view.register_shutdown_poller().is_running() {
@@ -1947,7 +2149,6 @@ impl ClientKvApiInner {
                 put_id,
                 len: len as u64,
                 preferred_sub_cluster: preferred_sub_cluster.map(|s| s.to_string()),
-                demote_source_on_remote_complete,
                 protect_source_on_remote_complete,
             },
             raw_bytes: Vec::new(),
@@ -1975,6 +2176,113 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
+    pub async fn batch_put_append_start(
+        &self,
+        items: Vec<BatchPutAppendStartItemReq>,
+    ) -> KvResult<BatchPutAppendStartResp> {
+        if items.is_empty() {
+            return Ok(BatchPutAppendStartResp {
+                items: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_put_append_start"
+                    .to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchPutAppendStartReq { items },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_put_append_start
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_evict_owner_source(
+        &self,
+        cohorts: Vec<OwnerSourceEvictionCohort>,
+    ) -> KvResult<BatchEvictOwnerSourceResp> {
+        if cohorts.is_empty() {
+            return Ok(BatchEvictOwnerSourceResp {
+                operation_id: 0,
+                cohorts: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting owner source eviction".to_string(),
+            }));
+        }
+        let operation_id = self
+            .next_owner_source_eviction_operation_id
+            .fetch_add(1, Ordering::Relaxed);
+        let self_info = self.view.cluster_manager().get_self_info();
+        let req = MsgPack {
+            serialize_part: BatchEvictOwnerSourceReq {
+                operation_id,
+                owner_node_start_time: self_info.node_start_time,
+                cohorts,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_evict_owner_source
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        if resp.serialize_part.operation_id != operation_id {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "owner source-eviction operation id mismatch: requested={} response={}",
+                    operation_id, resp.serialize_part.operation_id
+                ),
+            }));
+        }
+        Ok(resp.serialize_part)
+    }
+
     pub async fn put_append_revoke(&self, key: &str, put_id: PutIDForAKey) -> KvResult<()> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
@@ -2047,17 +2355,25 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
-    pub async fn batch_put_start(
+    pub async fn batch_put_append_done(
         &self,
-        items: Vec<BatchPutStartItemReq>,
-    ) -> KvResult<BatchPutStartResp> {
+        items: Vec<BatchPutAppendDoneItemReq>,
+    ) -> KvResult<BatchPutAppendDoneResp> {
+        if items.is_empty() {
+            return Ok(BatchPutAppendDoneResp {
+                items: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
-                detail: "ClientKvApi is shutting down; rejecting batch_put_start".to_string(),
+                detail: "ClientKvApi is shutting down; rejecting batch_put_append_done".to_string(),
             }));
         }
         let req = MsgPack {
-            serialize_part: BatchPutStartReq { items },
+            serialize_part: BatchPutAppendDoneReq { items },
             raw_bytes: Vec::new(),
         };
         let master_node_id = self
@@ -2066,14 +2382,14 @@ impl ClientKvApiInner {
             .find_or_wait_master_node()
             .await?;
         let resp = self
-            .rpc_caller_batch_put_start
+            .rpc_caller_batch_put_append_done
             .call_with_transport_policy(
                 self.view.p2p_module(),
                 master_node_id.into(),
                 req,
                 Some(std::time::Duration::from_secs(60)),
                 RpcTransportPolicy::ForceTransport,
-                2,
+                0,
             )
             .await
             .map_err(KvError::from)?;
@@ -2084,21 +2400,58 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
-    pub async fn batch_prepare_put_keys(
+    pub async fn batch_put_start(
         &self,
-        items: Vec<BatchPreparePutKeyItemReq>,
-    ) -> KvResult<BatchPreparePutKeysResp> {
-        if items.is_empty() {
-            return Ok(BatchPreparePutKeysResp {
-                reservation_ids: Vec::new(),
-                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
-                error_json: String::new(),
-                server_process_us: 0,
-            });
-        }
+        items: Vec<BatchPutStartItemReq>,
+    ) -> KvResult<BatchPutStartResp> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
-                detail: "ClientKvApi is shutting down; rejecting batch_prepare_put_keys"
+                detail: "ClientKvApi is shutting down; rejecting batch_put_start".to_string(),
+            }));
+        }
+        let req = MsgPack {
+            serialize_part: BatchPutStartReq { items },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_put_start
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(std::time::Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
+    pub async fn batch_prepare_put_keys(
+        &self,
+        items: Vec<BatchPreparePutKeyItemReq>,
+    ) -> KvResult<BatchPreparePutKeysResp> {
+        if items.is_empty() {
+            return Ok(BatchPreparePutKeysResp {
+                reservation_ids: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting batch_prepare_put_keys"
                     .to_string(),
             }));
         }
@@ -2486,30 +2839,20 @@ impl ClientKvApiInner {
     }
 }
 
-const OWNER_HOT_APPEND_START_MAX_ATTEMPTS: usize = 3;
-
-fn replica_append_demotes_source_on_remote_complete(is_owner_hot: bool) -> bool {
-    // Owner-hot eviction is an exclusive tier transition after the remote cohort is recoverable.
-    // Ordinary replica and tier-1 append tasks remain inclusive.
-    is_owner_hot
-}
+const REPLICA_TASK_BATCH_MERGE_WINDOW: Duration = Duration::from_millis(2);
+const OWNER_LOCAL_PUBLISH_RETRY_INITIAL: Duration = Duration::from_millis(25);
+const OWNER_LOCAL_PUBLISH_RETRY_MAX: Duration = Duration::from_secs(1);
 
 #[cfg(test)]
 mod owner_hot_replica_policy_tests {
     use super::{
         OwnerLocalPublishItem, complete_owner_local_publish_group_lens,
-        replica_append_demotes_source_on_remote_complete,
+        owner_local_publish_cohort_complete,
     };
     use crate::master_kv_router::msg_pack::{
         PutAtomicGroup, PutAtomicGroupMember, PutDoneCommittedSlot,
     };
 
-    #[test]
-    fn owner_hot_replication_is_exclusive_after_remote_completion() {
-        assert!(replica_append_demotes_source_on_remote_complete(true));
-        assert!(!replica_append_demotes_source_on_remote_complete(false));
-    }
-
     fn publish_item(
         key: &str,
         put_id: (u64, u32),
@@ -2562,6 +2905,33 @@ mod owner_hot_replica_policy_tests {
         ];
         assert_eq!(complete_owner_local_publish_group_lens(&partial), None);
     }
+
+    #[test]
+    fn hot_admission_waits_for_every_atomic_group_member_to_publish() {
+        let group = PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: "a".to_string(),
+                    put_id: (1, 0),
+                },
+                PutAtomicGroupMember {
+                    key: "b".to_string(),
+                    put_id: (1, 1),
+                },
+            ],
+        };
+        let items = vec![
+            publish_item("a", (1, 0), Some(group.clone())),
+            publish_item("b", (1, 1), Some(group)),
+            publish_item("single", (2, 0), None),
+        ];
+        let partial = vec![&items[0]];
+        assert!(!owner_local_publish_cohort_complete(&items[0], &partial));
+        let complete = vec![&items[0], &items[1]];
+        assert!(owner_local_publish_cohort_complete(&items[0], &complete));
+        assert!(owner_local_publish_cohort_complete(&items[1], &complete));
+        assert!(owner_local_publish_cohort_complete(&items[2], &partial));
+    }
 }
 
 async fn start_replica_append_with_retry(
@@ -2569,116 +2939,411 @@ async fn start_replica_append_with_retry(
     job: &ReplicaTaskJob,
     len: u32,
 ) -> KvResult<PutAppendStartResp> {
-    let max_attempts = if job.hot_replica_guard.is_some() {
-        OWNER_HOT_APPEND_START_MAX_ATTEMPTS
-    } else {
-        1
+    inner
+        .put_append_start(
+            &job.key,
+            job.put_id,
+            len,
+            job.preferred_sub_cluster.as_deref(),
+            job.protect_source_on_remote_complete,
+        )
+        .await
+}
+
+fn owner_source_eviction_identity(
+    member: &OwnerSourceEvictionMember,
+) -> super::OwnerHotReplicaIdentity {
+    super::OwnerHotReplicaIdentity {
+        key: member.key.clone(),
+        put_time_ms: member.put_id.0,
+        put_version: member.put_id.1,
+    }
+}
+
+fn owner_source_eviction_member(
+    identity: &super::OwnerHotReplicaIdentity,
+    memory_info: &crate::memholder::MemoryInfo,
+) -> Option<OwnerSourceEvictionMember> {
+    let (slot_size, grant_id, slot_index) = memory_info.local_reserve_resident_slot_ref()?;
+    Some(OwnerSourceEvictionMember {
+        key: identity.key.clone(),
+        put_id: (identity.put_time_ms, identity.put_version),
+        backing: OwnerReclaimBacking::CommittedSlot {
+            grant_id,
+            slot_index,
+            slot_size,
+        },
+    })
+}
+
+fn finish_owner_source_selection(
+    inner: &ClientKvApiInner,
+    cohort: &OwnerSourceEvictionCohort,
+    restore_current: bool,
+    reason: &str,
+) {
+    for member in &cohort.members {
+        let identity = owner_source_eviction_identity(member);
+        if let Some((_identity, debt)) = inner.owner_source_eviction_selected.remove(&identity) {
+            debt.release();
+            inner
+                .owner_hot_counters
+                .source_evict_restored_members
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        inner.owner_hot_retry_queue.remove(&identity);
+        if !restore_current {
+            continue;
+        }
+        let group = inner
+            .owner_hot_atomic_groups
+            .get(&identity)
+            .map(|entry| entry.value().clone());
+        if inner.owner_hot_admit_published_committed(&member.key, member.put_id, group.as_deref()) {
+            tracing::warn!(
+                key = member.key,
+                put_time_ms = member.put_id.0,
+                put_version = member.put_id.1,
+                reason,
+                "restored current source to owner-hot after source eviction did not enter reclaim"
+            );
+        }
+    }
+}
+
+fn schedule_owner_source_eviction_retry(
+    inner: &ClientKvApiInner,
+    mut event: OwnerHotEvictionEvent,
+    cohort: Arc<OwnerSourceEvictionCohort>,
+    reason: &'static str,
+) {
+    event.retry = true;
+    event.source_eviction_cohort = Some(cohort);
+    inner.owner_hot_retry_queue.schedule(event, reason);
+}
+
+fn prepare_owner_source_eviction_event(
+    inner: &ClientKvApiInner,
+    mut event: OwnerHotEvictionEvent,
+) -> Option<(OwnerHotEvictionEvent, Arc<OwnerSourceEvictionCohort>)> {
+    let trigger = super::OwnerHotReplicaIdentity {
+        key: event.key.clone(),
+        put_time_ms: event.put_id.0,
+        put_version: event.put_id.1,
     };
-    let mut attempt = 1usize;
-    loop {
-        match inner
-            .put_append_start(
-                &job.key,
-                job.put_id,
-                len,
-                job.preferred_sub_cluster.as_deref(),
-                replica_append_demotes_source_on_remote_complete(job.hot_replica_guard.is_some()),
-                job.protect_source_on_remote_complete,
+
+    if event.retry {
+        let _ = inner.owner_hot_retry_queue.take_for_inflight(&trigger);
+    }
+    if let Some(cohort) = event.source_eviction_cohort.clone() {
+        if cohort.members.iter().all(|member| {
+            inner
+                .owner_source_eviction_selected
+                .contains_key(&owner_source_eviction_identity(member))
+        }) {
+            return Some((event, cohort));
+        }
+        // Commit/invalidation may win the race with a due retry. Any remaining
+        // selected members are restored rather than leaving false projected credit.
+        finish_owner_source_selection(inner, &cohort, true, "retry cohort lost selected identity");
+        event.selection_debt.release();
+        return None;
+    }
+
+    if inner.owner_source_eviction_selected.contains_key(&trigger) {
+        event.selection_debt.release();
+        inner
+            .owner_hot_counters
+            .group_trigger_duplicates
+            .fetch_add(1, Ordering::Relaxed);
+        return None;
+    }
+
+    let (resolved_trigger, sources) = match inner.owner_hot_prepare_eviction(&event) {
+        OwnerHotEvictionPreparation::Ready { trigger, sources } => (trigger, sources),
+        OwnerHotEvictionPreparation::RetryableReclaimFence => {
+            inner.owner_hot_retry_queue.schedule(
+                event,
+                "owner reclaim fence busy before exact source selection",
+            );
+            return None;
+        }
+        OwnerHotEvictionPreparation::RetryableIncompleteCohort => {
+            inner
+                .owner_hot_retry_queue
+                .schedule(event, "owner source cohort is temporarily incomplete");
+            return None;
+        }
+        OwnerHotEvictionPreparation::Obsolete => {
+            event.selection_debt.release();
+            inner
+                .owner_hot_counters
+                .source_evict_obsolete
+                .fetch_add(1, Ordering::Relaxed);
+            return None;
+        }
+    };
+    debug_assert_eq!(resolved_trigger, trigger);
+
+    let members = sources
+        .iter()
+        .map(|(identity, memory_info)| owner_source_eviction_member(identity, memory_info.as_ref()))
+        .collect::<Option<Vec<_>>>();
+    let Some(members) = members else {
+        event.selection_debt.release();
+        inner
+            .owner_hot_counters
+            .group_trigger_incomplete
+            .fetch_add(1, Ordering::Relaxed);
+        tracing::error!(
+            key = event.key,
+            put_time_ms = event.put_id.0,
+            put_version = event.put_id.1,
+            "owner-hot selected a source without exact CommittedSlot backing"
+        );
+        return None;
+    };
+    let cohort = Arc::new(OwnerSourceEvictionCohort { members });
+
+    if cohort.members.iter().any(|member| {
+        inner
+            .owner_source_eviction_selected
+            .contains_key(&owner_source_eviction_identity(member))
+    }) {
+        event.selection_debt.release();
+        inner
+            .owner_hot_counters
+            .group_trigger_duplicates
+            .fetch_add(1, Ordering::Relaxed);
+        return None;
+    }
+
+    let mut installed = Vec::with_capacity(cohort.members.len());
+    for ((identity, memory_info), member) in sources.iter().zip(cohort.members.iter()) {
+        debug_assert_eq!(identity, &owner_source_eviction_identity(member));
+        let debt = if identity == &trigger {
+            event.selection_debt.clone()
+        } else {
+            OwnerHotSelectionDebt::new(
+                u64::from(owner_hot_weight_bytes(memory_info.as_ref())),
+                inner.owner_hot_counters.selection_debt_bytes.clone(),
             )
-            .await
+        };
+        if inner
+            .owner_source_eviction_selected
+            .insert(identity.clone(), debt.clone())
+            .is_some()
         {
-            Ok(resp) => return Ok(resp),
-            Err(err)
-                if attempt < max_attempts
-                    && matches!(err, KvError::Api(ApiError::KeyBeingWritten { .. })) =>
-            {
-                tracing::warn!(
-                    "owner hot replica append start failed; retrying: key={} put_id=({},{}) attempt={}/{} err={}",
-                    job.key,
-                    job.put_id.0,
-                    job.put_id.1,
-                    attempt,
-                    max_attempts,
-                    err
+            debt.release();
+            for installed_identity in installed {
+                if let Some((_identity, installed_debt)) = inner
+                    .owner_source_eviction_selected
+                    .remove(&installed_identity)
+                {
+                    installed_debt.release();
+                }
+            }
+            event.selection_debt.release();
+            return None;
+        }
+        installed.push(identity.clone());
+    }
+    event.source_eviction_cohort = Some(cohort.clone());
+    Some((event, cohort))
+}
+
+async fn process_owner_source_eviction_events(
+    view: &ClientKvApiView,
+    events: Vec<OwnerHotEvictionEvent>,
+) {
+    let inner = view.client_kv_api().inner();
+    let prepared = events
+        .into_iter()
+        .filter_map(|event| prepare_owner_source_eviction_event(inner, event))
+        .collect::<Vec<_>>();
+    if prepared.is_empty() {
+        return;
+    }
+    let cohorts = prepared
+        .iter()
+        .map(|(_, cohort)| cohort.as_ref().clone())
+        .collect::<Vec<_>>();
+    let response = inner.batch_evict_owner_source(cohorts).await;
+    let Ok(response) = response else {
+        for (event, cohort) in prepared {
+            schedule_owner_source_eviction_retry(
+                inner,
+                event,
+                cohort,
+                "owner source-eviction RPC failed",
+            );
+        }
+        return;
+    };
+    if response.cohorts.len() != prepared.len() {
+        for (event, cohort) in prepared {
+            schedule_owner_source_eviction_retry(
+                inner,
+                event,
+                cohort,
+                "owner source-eviction response length mismatch",
+            );
+        }
+        return;
+    }
+
+    for (index, ((event, cohort), result)) in prepared
+        .into_iter()
+        .zip(response.cohorts.into_iter())
+        .enumerate()
+    {
+        if result.cohort_index != u32::try_from(index).unwrap_or(u32::MAX) {
+            schedule_owner_source_eviction_retry(
+                inner,
+                event,
+                cohort,
+                "owner source-eviction response identity mismatch",
+            );
+            continue;
+        }
+        match result.outcome {
+            OwnerSourceEvictionOutcome::Accepted
+            | OwnerSourceEvictionOutcome::AlreadyInProgress => {
+                inner
+                    .owner_hot_counters
+                    .source_evict_handoff_members
+                    .fetch_add(cohort.members.len() as u64, Ordering::Relaxed);
+                // Selected debt stays live until owner reclaim Commit calls
+                // owner_hot_invalidate_version for every exact member.
+            }
+            OwnerSourceEvictionOutcome::Completed => {
+                finish_owner_source_selection(
+                    inner,
+                    &cohort,
+                    true,
+                    "master reported source deletion already completed",
+                );
+            }
+            OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified => {
+                schedule_owner_source_eviction_retry(
+                    inner,
+                    event,
+                    cohort,
+                    "master source reclaim is temporarily busy",
+                );
+            }
+            OwnerSourceEvictionOutcome::Stale => {
+                finish_owner_source_selection(
+                    inner,
+                    &cohort,
+                    true,
+                    "master rejected stale source identity",
+                );
+            }
+            OwnerSourceEvictionOutcome::RejectedNotEvictable => {
+                tracing::error!(
+                    cohort_members = cohort.members.len(),
+                    detail = result.detail,
+                    "owner selected a source cohort that master declared non-evictable"
+                );
+                finish_owner_source_selection(
+                    inner,
+                    &cohort,
+                    true,
+                    "master rejected non-evictable source cohort",
                 );
-                let delay_ms = 25u64.saturating_mul(1u64 << (attempt - 1));
-                tokio::time::sleep(Duration::from_millis(delay_ms)).await;
-                attempt += 1;
             }
-            Err(err) => return Err(err),
         }
     }
 }
 
-pub fn spawn_owner_hot_replica_dispatcher(
+pub fn spawn_owner_source_eviction_dispatcher(
     view: ClientKvApiView,
-    mut rx: tokio::sync::ampsc::Receiver<OwnerHotEvictionEvent>,
+    mut rx: tokio::sync::ampsc::UnboundedReceiver<OwnerHotEvictionEvent>,
 ) {
+    const MAX_COHORTS_PER_RPC: usize = 128;
+    const MERGE_WINDOW: Duration = Duration::from_millis(2);
+
     let view_task = view.clone();
-    let _ = view.spawn("owner_hot_replica_dispatcher", async move {
+    let _ = view.spawn("owner_source_eviction_dispatcher", async move {
         let mut shutdown_waiter = view_task.register_shutdown_waiter();
         loop {
-            let event = tokio::select! {
+            let first = tokio::select! {
                 _ = shutdown_waiter.wait() => {
-                    tracing::info!("owner_hot_replica_dispatcher stopping due to shutdown signal");
+                    tracing::info!("owner source-eviction dispatcher stopping due to shutdown");
                     break;
                 }
                 event = rx.recv() => {
-                    match event {
-                        Some(event) => event,
-                        None => break,
-                    }
+                    let Some(event) = event else { break; };
+                    event
                 }
             };
-            let inner = view_task.client_kv_api().inner();
-            let Some(memory_info) = event.memory_info.upgrade() else {
-                event.guard.mark_obsolete();
-                continue;
-            };
-            if !inner.owner_hot_source_is_current(
-                &event.key,
-                event.put_id,
-                &memory_info,
-            ) {
-                event.guard.mark_obsolete();
+            let mut events = Vec::with_capacity(MAX_COHORTS_PER_RPC);
+            events.push(first);
+            let merge_window = tokio::time::sleep(MERGE_WINDOW);
+            tokio::pin!(merge_window);
+            while events.len() < MAX_COHORTS_PER_RPC {
+                tokio::select! {
+                    _ = &mut merge_window => break,
+                    event = rx.recv() => {
+                        let Some(event) = event else { break; };
+                        events.push(event);
+                    }
+                }
+            }
+            process_owner_source_eviction_events(&view_task, events).await;
+        }
+    });
+}
+
+pub fn spawn_owner_hot_retry_actor(view: ClientKvApiView) {
+    const RETRY_EMIT_BATCH: usize = 128;
+    const RETRY_POLL_INTERVAL: Duration = Duration::from_millis(25);
+
+    let view_task = view.clone();
+    let _ = view.spawn("owner_hot_retry_actor", async move {
+        let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        let retry_queue = view_task
+            .client_kv_api()
+            .inner()
+            .owner_hot_retry_queue
+            .clone();
+        let notify = retry_queue.notify.clone();
+        let mut tick = tokio::time::interval(RETRY_POLL_INTERVAL);
+        loop {
+            tokio::select! {
+                _ = shutdown_waiter.wait() => return,
+                _ = tick.tick() => {},
+                _ = notify.notified() => {},
+            }
+            let events = retry_queue.take_due_batch(Instant::now(), RETRY_EMIT_BATCH);
+            if events.is_empty() {
                 continue;
             }
-            let holder = Arc::new(UserMemHolder::new(
-                memory_info,
-                inner.get_or_init_all_memholder_refcount(),
-                UserMemHolderExposeKind::SegPtr,
-            ));
-            let key = event.key.clone();
-            let put_id = event.put_id;
-            if let Err(err) = inner
-                .replica_task_tx
-                .send(ReplicaTaskJob {
-                    key: event.key,
-                    put_id: event.put_id,
-                    holder,
-                    target: None,
-                    preferred_sub_cluster: None,
-                    hot_replica_guard: Some(event.guard),
-                    protect_source_on_remote_complete: false,
-                })
-                .await
-            {
-                tracing::warn!(
-                    "replica task actor queue closed for owner hot eviction: key={} put_id=({},{}) err={}",
-                    key,
-                    put_id.0,
-                    put_id.1,
-                    err
-                );
+            let inner = view_task.client_kv_api().inner();
+            for event in events {
+                if let Err(err) = inner.owner_hot_eviction_tx.send(event) {
+                    let event = err.0;
+                    retry_queue.schedule(event, "retry dispatcher closed");
+                    return;
+                }
+                inner
+                    .owner_hot_counters
+                    .source_evict_retry_emitted
+                    .fetch_add(1, Ordering::Relaxed);
             }
         }
     });
 }
 
-async fn process_replica_task(view_task: ClientKvApiView, job: ReplicaTaskJob) {
+async fn process_replica_task(view_task: ClientKvApiView, mut job: ReplicaTaskJob) {
     let inner = view_task.client_kv_api().inner();
-    let src_offset = job.holder.memory_info().offset;
-    let len = job.holder.get_length() as u64;
+    let holder = job
+        .holder
+        .as_ref()
+        .expect("replica task source must be pinned before transfer");
+    let src_offset = holder.memory_info().offset;
+    let len = holder.get_length() as u64;
     let target = if let Some(target) = job.target.clone() {
         target
     } else {
@@ -2708,17 +3373,19 @@ async fn process_replica_task(view_task: ClientKvApiView, job: ReplicaTaskJob) {
                 return;
             }
         };
-        if !append_start.scheduled {
-            tracing::debug!(
-                "replica append task not scheduled: key={} put_id=({},{})",
-                job.key,
-                job.put_id.0,
-                job.put_id.1
-            );
-            if let Some(guard) = job.hot_replica_guard.as_ref() {
-                guard.mark_already_satisfied();
+        match append_start.outcome {
+            PutAppendStartOutcome::Scheduled => {}
+            PutAppendStartOutcome::AlreadySatisfied | PutAppendStartOutcome::Obsolete => return,
+            PutAppendStartOutcome::RetryableNoSpace | PutAppendStartOutcome::Unspecified => {
+                tracing::debug!(
+                    outcome = ?append_start.outcome,
+                    "replica append task deferred: key={} put_id=({},{})",
+                    job.key,
+                    job.put_id.0,
+                    job.put_id.1
+                );
+                return;
             }
-            return;
         }
         ReplicaTaskTarget {
             node_id: append_start.node_id,
@@ -2763,7 +3430,7 @@ async fn process_replica_task(view_task: ClientKvApiView, job: ReplicaTaskJob) {
     }
     // Append-done may reclaim the source synchronously. Release the transfer-only holder first so
     // this task does not make its own reclaim look busy.
-    drop(job.holder);
+    drop(job.holder.take());
     match inner.put_append_done(&job.key, job.put_id).await {
         Ok(resp) => {
             tracing::debug!(
@@ -2773,13 +3440,6 @@ async fn process_replica_task(view_task: ClientKvApiView, job: ReplicaTaskJob) {
                 job.put_id.1,
                 resp.appended
             );
-            if let Some(guard) = job.hot_replica_guard.as_ref() {
-                if resp.appended {
-                    guard.mark_completed();
-                } else {
-                    guard.mark_already_satisfied();
-                }
-            }
         }
         Err(err) => {
             tracing::warn!(
@@ -2793,6 +3453,349 @@ async fn process_replica_task(view_task: ClientKvApiView, job: ReplicaTaskJob) {
     }
 }
 
+struct ReplicaAppendDoneJob {
+    key: String,
+    put_id: PutIDForAKey,
+}
+
+async fn finish_replica_append_jobs_individually(
+    inner: &ClientKvApiInner,
+    jobs: Vec<ReplicaAppendDoneJob>,
+) {
+    let results = join_all(jobs.into_iter().map(|job| async move {
+        let result = inner.put_append_done(&job.key, job.put_id).await;
+        (job, result)
+    }))
+    .await;
+    for (job, result) in results {
+        match result {
+            Ok(_resp) => {}
+            Err(err) => {
+                tracing::warn!(
+                    "replica task append done fallback failed: key={} put_id=({},{}) err={}",
+                    job.key,
+                    job.put_id.0,
+                    job.put_id.1,
+                    err
+                );
+            }
+        }
+    }
+}
+
+async fn process_replica_append_batch(view_task: ClientKvApiView, jobs: Vec<ReplicaTaskJob>) {
+    if jobs.is_empty() {
+        return;
+    }
+    let inner = view_task.client_kv_api().inner();
+    let mut valid_jobs = Vec::with_capacity(jobs.len());
+    let mut start_items = Vec::with_capacity(jobs.len());
+    for job in jobs {
+        let len = job
+            .holder
+            .as_ref()
+            .expect("batch replica source must be pinned")
+            .get_length() as u64;
+        if u32::try_from(len).is_err() {
+            tracing::warn!(
+                "replica append task length does not fit u32: key={} put_id=({},{}) len={}",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                len
+            );
+            continue;
+        }
+        start_items.push(BatchPutAppendStartItemReq {
+            key: job.key.clone(),
+            put_id: job.put_id,
+            len,
+            preferred_sub_cluster: job.preferred_sub_cluster.clone(),
+            protect_source_on_remote_complete: job.protect_source_on_remote_complete,
+        });
+        valid_jobs.push(job);
+    }
+    if valid_jobs.is_empty() {
+        return;
+    }
+
+    let requested = valid_jobs.len();
+    let start_time = Instant::now();
+    let start_resp = match inner.batch_put_append_start(start_items).await {
+        Ok(resp) if resp.items.len() == requested => resp,
+        Ok(resp) => {
+            tracing::warn!(
+                "batch replica append start response length mismatch: expected={} got={}",
+                requested,
+                resp.items.len()
+            );
+            for job in valid_jobs {
+                spawn_replica_task_revoke(
+                    view_task.clone(),
+                    job.key,
+                    job.put_id,
+                    "batch start response mismatch",
+                );
+            }
+            return;
+        }
+        Err(err) => {
+            tracing::warn!(
+                "batch replica append start RPC failed; falling back per item: items={} err={}",
+                requested,
+                err
+            );
+            join_all(
+                valid_jobs
+                    .into_iter()
+                    .map(|job| process_replica_task(view_task.clone(), job)),
+            )
+            .await;
+            return;
+        }
+    };
+
+    let mut scheduled = Vec::new();
+    let mut already_satisfied = 0usize;
+    let mut start_failed = 0usize;
+    for (job, item) in valid_jobs.into_iter().zip(start_resp.items.into_iter()) {
+        if item.key != job.key || item.put_id != job.put_id {
+            tracing::warn!(
+                "batch replica append start identity mismatch: request_key={} request_put_id=({},{}) response_key={} response_put_id=({},{})",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                item.key,
+                item.put_id.0,
+                item.put_id.1
+            );
+            spawn_replica_task_revoke(
+                view_task.clone(),
+                job.key,
+                job.put_id,
+                "batch start identity mismatch",
+            );
+            start_failed += 1;
+            continue;
+        }
+        if let Err(err) =
+            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json.clone())
+        {
+            tracing::warn!(
+                "batch replica append start item failed: key={} put_id=({},{}) err={}",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                err
+            );
+            start_failed += 1;
+            continue;
+        }
+        match item.outcome {
+            PutAppendStartOutcome::Scheduled => {}
+            PutAppendStartOutcome::AlreadySatisfied => {
+                already_satisfied += 1;
+                continue;
+            }
+            PutAppendStartOutcome::Obsolete => continue,
+            PutAppendStartOutcome::RetryableNoSpace | PutAppendStartOutcome::Unspecified => {
+                start_failed += 1;
+                continue;
+            }
+        }
+        let target = ReplicaTaskTarget {
+            node_id: item.node_id,
+            target_offset: item.target_addr - item.target_base_addr,
+            target_base_addr: item.target_base_addr,
+            len: item.len,
+        };
+        let source_len = job
+            .holder
+            .as_ref()
+            .expect("scheduled batch replica source must remain pinned")
+            .get_length() as u64;
+        if source_len != target.len {
+            tracing::warn!(
+                "batch replica task length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                source_len,
+                target.len
+            );
+            spawn_replica_task_revoke(
+                view_task.clone(),
+                job.key,
+                job.put_id,
+                "batch length mismatch",
+            );
+            start_failed += 1;
+            continue;
+        }
+        scheduled.push((job, target));
+    }
+    tracing::info!(
+        requested,
+        scheduled = scheduled.len(),
+        already_satisfied,
+        failed = start_failed,
+        rpc_us = duration_to_i64_us(start_time.elapsed()),
+        "replica writeback batch start complete"
+    );
+
+    let transfer_results = join_all(scheduled.into_iter().map(|(job, target)| {
+        let transfer_view = view_task.clone();
+        async move {
+            let inner = transfer_view.client_kv_api().inner();
+            let src_offset = job
+                .holder
+                .as_ref()
+                .expect("scheduled batch replica source must remain pinned")
+                .memory_info()
+                .offset;
+            let result = inner
+                .put_transfer(
+                    &job.key,
+                    job.put_id,
+                    src_offset,
+                    target.target_offset,
+                    target.len,
+                    Some(target.node_id),
+                    Some(target.target_base_addr),
+                )
+                .await;
+            (job, result)
+        }
+    }))
+    .await;
+
+    let mut done_jobs = Vec::new();
+    for (job, result) in transfer_results {
+        match result {
+            Ok(_) => {
+                let ReplicaTaskJob {
+                    key,
+                    put_id,
+                    holder,
+                    ..
+                } = job;
+                drop(holder);
+                done_jobs.push(ReplicaAppendDoneJob { key, put_id });
+            }
+            Err(err) => {
+                tracing::warn!(
+                    "batch replica task transfer failed: key={} put_id=({},{}) err={}",
+                    job.key,
+                    job.put_id.0,
+                    job.put_id.1,
+                    err
+                );
+                spawn_replica_task_revoke(
+                    view_task.clone(),
+                    job.key,
+                    job.put_id,
+                    "batch transfer error",
+                );
+            }
+        }
+    }
+    if done_jobs.is_empty() {
+        return;
+    }
+
+    let done_requested = done_jobs.len();
+    let done_items = done_jobs
+        .iter()
+        .map(|job| BatchPutAppendDoneItemReq {
+            key: job.key.clone(),
+            put_id: job.put_id,
+        })
+        .collect();
+    let done_time = Instant::now();
+    let done_resp = match inner.batch_put_append_done(done_items).await {
+        Ok(resp) if resp.items.len() == done_requested => resp,
+        Ok(resp) => {
+            tracing::warn!(
+                "batch replica append done response length mismatch: expected={} got={}; falling back per item",
+                done_requested,
+                resp.items.len()
+            );
+            finish_replica_append_jobs_individually(inner, done_jobs).await;
+            return;
+        }
+        Err(err) => {
+            tracing::warn!(
+                "batch replica append done RPC failed; falling back per item: items={} err={}",
+                done_requested,
+                err
+            );
+            finish_replica_append_jobs_individually(inner, done_jobs).await;
+            return;
+        }
+    };
+
+    let mut appended = 0usize;
+    let mut already_done = 0usize;
+    let mut done_failed = 0usize;
+    for (job, item) in done_jobs.into_iter().zip(done_resp.items.into_iter()) {
+        let identity_matches = item.key == job.key && item.put_id == job.put_id;
+        let item_result = crate::rpcresp_kvresult_convert::try_from_code(
+            item.error_code,
+            item.error_json.clone(),
+        );
+        if !identity_matches || item_result.is_err() {
+            tracing::warn!(
+                "batch replica append done item failed: key={} put_id=({},{}) identity_matches={} err={:?}",
+                job.key,
+                job.put_id.0,
+                job.put_id.1,
+                identity_matches,
+                item_result.err()
+            );
+            spawn_replica_task_revoke(
+                view_task.clone(),
+                job.key,
+                job.put_id,
+                "batch done item error",
+            );
+            done_failed += 1;
+            continue;
+        }
+        if item.appended {
+            appended += 1;
+        } else {
+            already_done += 1;
+        }
+    }
+    tracing::info!(
+        requested = done_requested,
+        appended,
+        already_satisfied = already_done,
+        failed = done_failed,
+        rpc_us = duration_to_i64_us(done_time.elapsed()),
+        "replica writeback batch done complete"
+    );
+}
+
+async fn process_replica_task_batch(view_task: ClientKvApiView, jobs: Vec<ReplicaTaskJob>) {
+    let mut append_jobs = Vec::new();
+    let mut reserved_target_jobs = Vec::new();
+    for job in jobs {
+        if job.target.is_some() {
+            reserved_target_jobs.push(job);
+        } else {
+            append_jobs.push(job);
+        }
+    }
+    let append = process_replica_append_batch(view_task.clone(), append_jobs);
+    let reserved = join_all(
+        reserved_target_jobs
+            .into_iter()
+            .map(|job| process_replica_task(view_task.clone(), job)),
+    );
+    let (_, _) = futures::join!(append, reserved);
+}
+
 pub fn spawn_replica_task_actor(
     view: ClientKvApiView,
     mut rx: tokio::sync::ampsc::Receiver<ReplicaTaskJob>,
@@ -2801,15 +3804,14 @@ pub fn spawn_replica_task_actor(
     let view_task = view.clone();
     let _ = view.spawn("replica_task_actor", async move {
         let max_inflight = max_inflight.max(1);
-        let semaphore = Arc::new(::tokio::sync::Semaphore::new(max_inflight));
-        let per_key = Arc::new(SemaphoreMap::new(1, Duration::from_secs(10 * 60)));
         tracing::info!(
             max_inflight,
-            "replica task actor started with bounded cross-key concurrency"
+            merge_window_ms = REPLICA_TASK_BATCH_MERGE_WINDOW.as_millis(),
+            "replica task actor started with time-window batching"
         );
         let mut shutdown_waiter = view_task.register_shutdown_waiter();
         loop {
-            let job = tokio::select! {
+            let first = tokio::select! {
                 _ = shutdown_waiter.wait() => {
                     tracing::info!("replica_task_actor stopping due to shutdown signal");
                     break;
@@ -2821,24 +3823,23 @@ pub fn spawn_replica_task_actor(
                     }
                 }
             };
-            let permit = match semaphore.clone().acquire_owned().await {
-                Ok(permit) => permit,
-                Err(err) => {
-                    tracing::warn!(
-                        "replica task actor semaphore closed; dropping queued work: err={}",
-                        err
-                    );
-                    break;
+            let mut batch = Vec::with_capacity(max_inflight);
+            batch.push(first);
+            let merge_window = tokio::time::sleep(REPLICA_TASK_BATCH_MERGE_WINDOW);
+            tokio::pin!(merge_window);
+            while batch.len() < max_inflight {
+                tokio::select! {
+                    _ = &mut merge_window => break,
+                    job = rx.recv() => {
+                        match job {
+                            Some(job) => batch.push(job),
+                            None => break,
+                        }
+                    }
                 }
-            };
-            let spawn_view = view_task.clone();
-            let worker_view = view_task.clone();
-            let worker_per_key = per_key.clone();
-            spawn_view.spawn("replica_task_worker", async move {
-                let _permit = permit;
-                let _key_permit = worker_per_key.acquire(job.key.clone()).await;
-                process_replica_task(worker_view, job).await;
-            });
+            }
+            tracing::info!(items = batch.len(), "replica writeback batch flushed");
+            process_replica_task_batch(view_task.clone(), batch).await;
         }
     });
 }
@@ -2962,7 +3963,20 @@ fn complete_owner_local_publish_group_lens(items: &[OwnerLocalPublishItem]) -> O
     Some(group_lens)
 }
 
-async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJob) {
+fn owner_local_publish_cohort_complete(
+    item: &OwnerLocalPublishItem,
+    promoted_items: &[&OwnerLocalPublishItem],
+) -> bool {
+    item.atomic_group.as_ref().map_or(true, |group| {
+        group.members.iter().all(|member| {
+            promoted_items
+                .iter()
+                .any(|published| published.key == member.key && published.put_id == member.put_id)
+        })
+    })
+}
+
+pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJob) {
     let inner = view.client_kv_api().inner();
     if job.items.is_empty() {
         release_owner_local_publish_reservations(inner, job.key_reservation_ids).await;
@@ -2970,105 +3984,209 @@ async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLocalPublishJo
     }
 
     let group_lens = complete_owner_local_publish_group_lens(&job.items);
-    let done_items = if let Some(atomic_group_lens) = group_lens {
-        inner
-            .owner_hot_counters
-            .grouped_put_done_batches
-            .fetch_add(1, Ordering::Relaxed);
-        inner
-            .owner_hot_counters
-            .grouped_put_done_items
-            .fetch_add(job.items.len() as u64, Ordering::Relaxed);
-        let items = job
-            .items
-            .iter()
-            .map(|item| GroupedBatchPutDoneItemReq {
-                key: item.key.clone(),
-                put_id: item.put_id,
-                lease_id: item.lease_id,
-                committed_slot: Some(item.committed_slot.clone()),
-                publish_local_cache: false,
-            })
-            .collect::<Vec<_>>();
-        inner
-            .grouped_batch_put_done(items, atomic_group_lens)
-            .await
-            .map(|resp| resp.items)
-    } else {
-        inner
-            .owner_hot_counters
-            .legacy_put_done_batches
-            .fetch_add(1, Ordering::Relaxed);
-        inner
-            .owner_hot_counters
-            .legacy_put_done_items
-            .fetch_add(job.items.len() as u64, Ordering::Relaxed);
-        let items = job
-            .items
-            .iter()
-            .map(|item| BatchPutDoneItemReq {
-                key: item.key.clone(),
-                put_id: item.put_id,
-                lease_id: item.lease_id,
-                committed_slot: Some(item.committed_slot.clone()),
-                publish_local_cache: false,
-                atomic_group: item.atomic_group.clone(),
-            })
-            .collect::<Vec<_>>();
-        inner.batch_put_done(items).await.map(|resp| resp.items)
-    };
+    let incomplete_declared_group =
+        group_lens.is_none() && job.items.iter().any(|item| item.atomic_group.is_some());
+    let mut shutdown_waiter = view.register_shutdown_waiter();
+    let mut retry_delay = OWNER_LOCAL_PUBLISH_RETRY_INITIAL;
+    let mut published = false;
 
-    match done_items {
-        Ok(done_items) if done_items.len() == job.items.len() => {
-            for (item, done_item) in job.items.iter().zip(done_items.into_iter()) {
-                if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
+    loop {
+        let attempt: Result<(), String> = async {
+            if incomplete_declared_group {
+                return Err(
+                    "declared atomic group is incomplete or non-contiguous in publish job"
+                        .to_string(),
+                );
+            }
+            let done_items: Vec<BatchPutDoneItemResp> =
+                if let Some(atomic_group_lens) = group_lens.clone() {
+                    inner
+                        .owner_hot_counters
+                        .grouped_put_done_batches
+                        .fetch_add(1, Ordering::Relaxed);
+                    inner
+                        .owner_hot_counters
+                        .grouped_put_done_items
+                        .fetch_add(job.items.len() as u64, Ordering::Relaxed);
+                    let items = job
+                        .items
+                        .iter()
+                        .map(|item| GroupedBatchPutDoneItemReq {
+                            key: item.key.clone(),
+                            put_id: item.put_id,
+                            lease_id: item.lease_id,
+                            committed_slot: Some(item.committed_slot.clone()),
+                            publish_local_cache: false,
+                        })
+                        .collect::<Vec<_>>();
+                    inner
+                        .grouped_batch_put_done(items, atomic_group_lens)
+                        .await
+                        .map(|resp| resp.items)
+                        .map_err(|err| format!("PutDone RPC uncertain: {err}"))?
+                } else {
+                    inner
+                        .owner_hot_counters
+                        .legacy_put_done_batches
+                        .fetch_add(1, Ordering::Relaxed);
+                    inner
+                        .owner_hot_counters
+                        .legacy_put_done_items
+                        .fetch_add(job.items.len() as u64, Ordering::Relaxed);
+                    let items = job
+                        .items
+                        .iter()
+                        .map(|item| BatchPutDoneItemReq {
+                            key: item.key.clone(),
+                            put_id: item.put_id,
+                            lease_id: item.lease_id,
+                            committed_slot: Some(item.committed_slot.clone()),
+                            publish_local_cache: false,
+                            atomic_group: item.atomic_group.clone(),
+                        })
+                        .collect::<Vec<_>>();
+                    inner
+                        .batch_put_done(items)
+                        .await
+                        .map(|resp| resp.items)
+                        .map_err(|err| format!("PutDone RPC uncertain: {err}"))?
+                };
+
+            if done_items.len() != job.items.len() {
+                return Err(format!(
+                    "PutDone response length mismatch: expected={} got={}",
+                    job.items.len(),
+                    done_items.len()
+                ));
+            }
+            for (item, done_item) in job.items.iter().zip(done_items.iter()) {
+                if done_item.key != item.key || done_item.put_id != item.put_id {
+                    return Err(format!(
+                        "PutDone identity mismatch: request=({},({},{}) response=({},({},{}))",
+                        item.key,
+                        item.put_id.0,
+                        item.put_id.1,
+                        done_item.key,
+                        done_item.put_id.0,
+                        done_item.put_id.1,
+                    ));
+                }
+                crate::rpcresp_kvresult_convert::try_from_code(
                     done_item.error_code,
                     done_item.error_json.clone(),
+                )
+                .map_err(|err| {
+                    format!(
+                        "PutDone item unresolved: key={} put_id=({},{}) err={}",
+                        item.key, item.put_id.0, item.put_id.1, err
+                    )
+                })?;
+            }
+
+            // Do not expose only part of an atomic/TP cohort to owner-hot.
+            // First prove every master route terminal, then roll all local
+            // precommit slots forward. Replayed attempts accept members that
+            // were already promoted before a cancellation or partial local
+            // failure.
+            for item in &job.items {
+                if inner.committed_local_reserve_slot_is_current(
+                    &item.key,
+                    item.put_id,
+                    &item.committed_slot,
                 ) {
+                    continue;
+                }
+                let memory_info = inner
+                    .precommit_local_visible_memory_info(&item.key)
+                    .ok_or_else(|| {
+                        format!(
+                            "precommit slot missing before promotion: key={} put_id=({},{})",
+                            item.key, item.put_id.0, item.put_id.1
+                        )
+                    })?;
+                inner
+                    .promote_precommit_local_reserve_resident_slot_if_same(
+                        &item.key,
+                        item.put_id,
+                        memory_info,
+                        item.atomic_group.as_ref(),
+                    )
+                    .map_err(|err| {
+                        format!(
+                            "local promotion unresolved: key={} put_id=({},{}) err={}",
+                            item.key, item.put_id.0, item.put_id.1, err
+                        )
+                    })?;
+            }
+            Ok(())
+        }
+        .await;
+
+        match attempt {
+            Ok(()) => {
+                published = true;
+                break;
+            }
+            Err(reason) => {
+                tracing::warn!(
+                    "owner local publish retained full cohort for retry: key_count={} external_fences={} retry_ms={} reason={}",
+                    job.items.len(),
+                    job.external_pending_contexts.len(),
+                    retry_delay.as_millis(),
+                    reason,
+                );
+            }
+        }
+
+        tokio::select! {
+            _ = tokio::time::sleep(retry_delay) => {}
+            _ = shutdown_waiter.wait() => break,
+        }
+        retry_delay = retry_delay
+            .saturating_mul(2)
+            .min(OWNER_LOCAL_PUBLISH_RETRY_MAX);
+    }
+
+    if published {
+        let promoted_items = job.items.iter().collect::<Vec<_>>();
+        for item in &promoted_items {
+            if !owner_local_publish_cohort_complete(item, &promoted_items) {
+                tracing::warn!(
+                    "owner local publish skipped hot admission for incomplete atomic group: key={} put_id=({},{})",
+                    item.key,
+                    item.put_id.0,
+                    item.put_id.1
+                );
+                continue;
+            }
+            let _ = inner.owner_hot_admit_published_committed(
+                &item.key,
+                item.put_id,
+                item.atomic_group.as_ref(),
+            );
+        }
+
+        for item in promoted_items {
+            if item.make_replica_task {
+                if let Err(err) = inner
+                    .make_replica_append_task(
+                        &item.key,
+                        item.put_id,
+                        item.preferred_sub_cluster.clone(),
+                        true,
+                    )
+                    .await
+                {
                     tracing::warn!(
-                        "owner local publish failed: key={} put_id=({},{}) err={}",
+                        "owner local publish enqueue replica append failed: key={} put_id=({},{}) err={}",
                         item.key,
                         item.put_id.0,
                         item.put_id.1,
                         err
                     );
-                    continue;
-                }
-                if item.make_replica_task {
-                    if let Err(err) = inner
-                        .make_replica_append_task(
-                            &item.key,
-                            item.put_id,
-                            item.preferred_sub_cluster.clone(),
-                            true,
-                        )
-                        .await
-                    {
-                        tracing::warn!(
-                            "owner local publish enqueue replica append failed: key={} put_id=({},{}) err={}",
-                            item.key,
-                            item.put_id.0,
-                            item.put_id.1,
-                            err
-                        );
-                    }
                 }
             }
         }
-        Ok(done_items) => {
-            tracing::warn!(
-                "owner local publish response length mismatch: expected={} got={}",
-                job.items.len(),
-                done_items.len()
-            );
-        }
-        Err(err) => {
-            tracing::warn!(
-                "owner local publish batch_put_done rpc failed: key_count={} err={}",
-                job.items.len(),
-                err
-            );
-        }
     }
 
     release_owner_local_publish_reservations(inner, job.key_reservation_ids).await;
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
index 2c33a58..f3ea172 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
@@ -24,6 +24,7 @@ fn item_resp(
 fn record_item(record: &OwnerReclaimRecord) -> &OwnerReclaimItem {
     match record {
         OwnerReclaimRecord::Prepared(prepared) => &prepared.item,
+        OwnerReclaimRecord::Releasing(item) => item,
         OwnerReclaimRecord::Committed(item) => item,
     }
 }
@@ -49,15 +50,23 @@ fn memory_matches_reclaim_backing(
     }
 }
 
+fn reclaim_key_control_busy_detail(state: &super::OwnerKeyControlState) -> Option<&'static str> {
+    if state.local_puts != 0 {
+        Some("owner local put is inflight")
+    } else if state.external_pending_puts != 0 {
+        Some("owner external put context is still pending")
+    } else if state.external_get.is_some() {
+        Some("owner external Get is inflight")
+    } else {
+        None
+    }
+}
+
 fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
-    let mut controls = inner.owner_key_control.lock();
+    let mut controls = inner.owner_key_control.lock_key(&item.key);
     if let Some(state) = controls.get(&item.key) {
-        if state.local_puts != 0 {
-            return item_resp(
-                item,
-                OwnerReclaimItemState::Busy,
-                "owner local put is inflight",
-            );
+        if let Some(detail) = reclaim_key_control_busy_detail(state) {
+            return item_resp(item, OwnerReclaimItemState::Busy, detail);
         }
         if let Some(record) = state.reclaim.as_ref() {
             if record_item(record) == item {
@@ -65,6 +74,7 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
                     item,
                     match record {
                         OwnerReclaimRecord::Prepared(_) => OwnerReclaimItemState::Prepared,
+                        OwnerReclaimRecord::Releasing(_) => OwnerReclaimItemState::Busy,
                         OwnerReclaimRecord::Committed(_) => OwnerReclaimItemState::Committed,
                     },
                     "reclaim phase already applied",
@@ -84,18 +94,13 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
             "owner precommit local index is still visible",
         );
     }
-    if inner
-        .external_pending_puts
-        .iter()
-        .any(|(pending_key, _)| pending_key.0 == item.key)
-    {
+    if inner.pending_local_get_info.contains_key(&item.key) {
         return item_resp(
             item,
             OwnerReclaimItemState::Busy,
-            "owner external put context is still pending",
+            "owner local Get commit is pending",
         );
     }
-
     let Some((_key, cached_info)) = inner.get_cached_info.remove_if(&item.key, |_, cached| {
         cached.put_time_ms == item.put_id.0
             && cached.put_version == item.put_id.1
@@ -130,7 +135,12 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
         })
         .map(|(_, snapshot)| snapshot);
     let state = controls.entry(item.key.clone()).or_default();
-    assert!(state.reclaim.is_none() && state.local_puts == 0);
+    assert!(
+        state.reclaim.is_none()
+            && state.local_puts == 0
+            && state.external_pending_puts == 0
+            && state.external_get.is_none()
+    );
     state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
         item: item.clone(),
         cached_info,
@@ -173,26 +183,33 @@ fn release_prepared_backing_now(inner: &ClientKvApiInner, prepared: OwnerPrepare
             assert_eq!(actual_slot_index, *slot_index);
 
             inner
-                .owner_release_local_reserve_committed_slot_route(
+                .owner_release_local_reserve_committed_resident_slot(
                     actual_slot_size,
                     actual_grant_id,
                     actual_slot_index,
                 )
-                .expect("owner reclaim committed route release must succeed");
-            inner
-                .owner_release_local_reserve_resident_slot_holder(
-                    actual_slot_size,
-                    actual_grant_id,
-                    actual_slot_index,
-                )
-                .expect("owner reclaim resident holder release must succeed");
+                .expect("owner reclaim committed resident slot release must succeed");
         }
     }
     drop(memory_info);
 }
 
+fn reclaim_release_fence_is_intact(
+    state: &super::OwnerKeyControlState,
+    item: &OwnerReclaimItem,
+) -> bool {
+    // Prepare hides the local index before installing the reclaim fence. A
+    // later external Get may share this key state, but it can only take the
+    // remote path and therefore does not hold the detached local backing.
+    matches!(
+        state.reclaim.as_ref(),
+        Some(OwnerReclaimRecord::Releasing(releasing)) if releasing == item
+    ) && state.local_puts == 0
+        && state.external_pending_puts == 0
+}
+
 fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
-    let mut controls = inner.owner_key_control.lock();
+    let mut controls = inner.owner_key_control.lock_key(&item.key);
     let Some(state) = controls.get_mut(&item.key) else {
         return item_resp(
             item,
@@ -208,7 +225,18 @@ fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaim
         );
     };
     let prepared = match record {
-        OwnerReclaimRecord::Prepared(prepared) if prepared.item == *item => prepared,
+        OwnerReclaimRecord::Prepared(prepared) if prepared.item == *item => {
+            state.reclaim = Some(OwnerReclaimRecord::Releasing(item.clone()));
+            prepared
+        }
+        OwnerReclaimRecord::Releasing(releasing) if releasing == *item => {
+            state.reclaim = Some(OwnerReclaimRecord::Releasing(releasing));
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner reclaim slot release is already in progress",
+            );
+        }
         OwnerReclaimRecord::Committed(committed) if committed == *item => {
             state.reclaim = Some(OwnerReclaimRecord::Committed(committed));
             return item_resp(
@@ -227,9 +255,19 @@ fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaim
         }
     };
 
-    // Keep the owner fence installed by holding the control lock until the slot is fully free.
+    // The Releasing marker keeps local Put/Get out. Drop the key-shard lock
+    // before touching the slot pool so no synchronous locks are nested.
+    drop(controls);
     release_prepared_backing_now(inner, prepared);
-    assert!(state.reclaim.is_none() && state.local_puts == 0);
+
+    let mut controls = inner.owner_key_control.lock_key(&item.key);
+    let state = controls
+        .get_mut(&item.key)
+        .expect("owner reclaim releasing fence disappeared");
+    assert!(
+        reclaim_release_fence_is_intact(state, item),
+        "a local put crossed an owner reclaim fence"
+    );
     state.reclaim = Some(OwnerReclaimRecord::Committed(item.clone()));
     drop(controls);
     inner.owner_hot_invalidate_version(&item.key, item.put_id);
@@ -240,8 +278,65 @@ fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaim
     )
 }
 
+#[cfg(test)]
+mod tests {
+    use super::{reclaim_key_control_busy_detail, reclaim_release_fence_is_intact};
+    use crate::client_kv_api::{
+        ExternalGetKeySharedOp, OwnerKeyControlState, OwnerKeyControlTable, OwnerReclaimRecord,
+        acquire_external_pending_put_fence_for_key,
+    };
+    use crate::master_kv_router::msg_pack::{
+        OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimReason,
+    };
+    use std::sync::Arc;
+
+    #[test]
+    fn pending_external_put_rejects_reclaim_prepare_precheck() {
+        let controls = Arc::new(OwnerKeyControlTable::default());
+        let _guard = acquire_external_pending_put_fence_for_key(&controls, "pending-key")
+            .expect("pending fence acquisition must succeed");
+        let controls = controls.lock_key("pending-key");
+        assert_eq!(
+            reclaim_key_control_busy_detail(&controls["pending-key"]),
+            Some("owner external put context is still pending")
+        );
+    }
+
+    #[test]
+    fn remote_get_marker_can_overlap_reclaim_commit() {
+        let item = OwnerReclaimItem {
+            key: "remote-during-reclaim".to_string(),
+            put_id: (7, 1),
+            epoch: 9,
+            backing: OwnerReclaimBacking::CommittedSlot {
+                grant_id: 3,
+                slot_index: 4,
+                slot_size: 4096,
+            },
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
+        };
+        let state = OwnerKeyControlState {
+            local_puts: 0,
+            external_pending_puts: 0,
+            reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
+            external_get: Some(Arc::new(ExternalGetKeySharedOp::new(
+                "remote-during-reclaim".to_string(),
+            ))),
+        };
+        assert!(reclaim_release_fence_is_intact(&state, &item));
+
+        let local_put_state = OwnerKeyControlState {
+            local_puts: 1,
+            external_pending_puts: 0,
+            reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
+            external_get: state.external_get,
+        };
+        assert!(!reclaim_release_fence_is_intact(&local_put_state, &item));
+    }
+}
+
 fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
-    let mut controls = inner.owner_key_control.lock();
+    let mut controls = inner.owner_key_control.lock_key(&item.key);
     let Some(state) = controls.get_mut(&item.key) else {
         return item_resp(
             item,
@@ -272,7 +367,7 @@ fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimI
                     "owner reclaim abort must restore an empty local snapshot slot"
                 );
             }
-            if state.local_puts == 0 {
+            if state.is_idle() {
                 controls.remove(&item.key);
             }
             item_resp(
@@ -281,6 +376,14 @@ fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimI
                 "owner local index fence rolled back",
             )
         }
+        OwnerReclaimRecord::Releasing(releasing) if releasing == *item => {
+            state.reclaim = Some(OwnerReclaimRecord::Releasing(releasing));
+            item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner slot release is already in progress and cannot be aborted",
+            )
+        }
         OwnerReclaimRecord::Committed(committed) if committed == *item => {
             state.reclaim = Some(OwnerReclaimRecord::Committed(committed));
             item_resp(
@@ -301,7 +404,7 @@ fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimI
 }
 
 fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
-    let mut controls = inner.owner_key_control.lock();
+    let mut controls = inner.owner_key_control.lock_key(&item.key);
     let Some(state) = controls.get_mut(&item.key) else {
         return item_resp(
             item,
@@ -311,7 +414,7 @@ fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerRecla
     };
     match state.reclaim.take() {
         Some(OwnerReclaimRecord::Committed(committed)) if committed == *item => {
-            if state.local_puts == 0 {
+            if state.is_idle() {
                 controls.remove(&item.key);
             }
             item_resp(
@@ -320,6 +423,14 @@ fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerRecla
                 "owner reclaim fence cleared",
             )
         }
+        Some(OwnerReclaimRecord::Releasing(releasing)) if releasing == *item => {
+            state.reclaim = Some(OwnerReclaimRecord::Releasing(releasing));
+            item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner slot release is still in progress",
+            )
+        }
         Some(other) => {
             state.reclaim = Some(other);
             item_resp(
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
index 703257f..87a18da 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
@@ -31,7 +31,7 @@ use std::time::Duration;
 ///
 /// It removes the key from `kv_routes`, then asynchronously:
 /// - emits a `DeleteKeyInfo` to the shared delete broadcast actor for clients
-/// - removes the key from every node's local `node_kv_cache_controller`
+/// - point-removes the exact version from ring-B and tier1 metadata caches
 pub fn do_delete_one_kv_all_replicas(
     view: &MasterKvRouterView,
     key: String,
@@ -67,21 +67,9 @@ pub fn do_delete_one_kv_all_replicas(
                     tracing::warn!("Failed to send delete broadcast: {}", err);
                 }
 
-                // Remove from all node caches that hold replicas of this key
-                let nodes_replicas = kv_route_info.nodes_replicas.read();
-                for (node_id, _kv_info) in nodes_replicas.iter() {
-                    if let Some(cache) = view.master_kv_router().get_node_cache_controller(node_id)
-                    {
-                        let _ = cache.remove(&key_clone);
-                        view.master_kv_router()
-                            .remove_node_writeback_tier1_entry(node_id, &key_clone);
-                        tracing::debug!(
-                            "Removed key {} from node cache controller: {}",
-                            key_clone,
-                            node_id
-                        );
-                    }
-                }
+                view.master_kv_router()
+                    .remove_route_cache_entries_exact(&key_clone, &kv_route_info)
+                    .await;
             }
         });
 
@@ -99,7 +87,6 @@ pub fn evict_one_kv_replica_for_node(
     node_id: NodeID,
     put_id: PutIDForAKey,
 ) -> Result<(), msg_and_error::ErrorCode> {
-    let _guard = view.master_kv_router().inner().route_lifetime_lock.lock();
     let route = if let Some(route) = view.master_kv_router().inner().kv_routes.get(&key) {
         route.clone()
     } else {
@@ -146,7 +133,11 @@ pub fn evict_one_kv_replica_for_node(
             .master_kv_router()
             .inner()
             .kv_routes
-            .remove_if(&key, |_, current| current.put_id == put_id)
+            .remove_if(&key, |_, current| {
+                Arc::ptr_eq(current, &route)
+                    && current.put_id == put_id
+                    && current.nodes_replicas.read().is_empty()
+            })
             .is_some();
         if removed && view.master_kv_router().prefix_index_enabled() {
             let view_task = view.clone();
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 5e0833e..795a1c4 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -1,22 +1,24 @@
 use super::{
-    InflightGetInfo, KvRouteInfo, MasterKeyActivityCompletionGuard, MasterKvRouterView,
-    OwnerHoldingGetInfo,
+    CommittedSlotReplica, CompletedGetInfo, InflightGetInfo, InflightGetTarget, KvRouteInfo,
+    MasterKeyActivityCompletionGuard, MasterKvRouterView, OwnerHoldingGetInfo,
+    ReservedCapacityReason,
     msg_pack::{
         BatchGetDoneItemResp, BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeItemResp,
         BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
         BatchGetStartResp, BatchIsExistReq, BatchIsExistResp, GetAllocationMode, GetDoneReq,
-        GetDoneResp, GetMetaReq, GetMetaResp, GetRevokeReq, GetRevokeResp, GetStartReq,
-        GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq,
-        MemHolderReleaseResp,
+        GetDoneResp, GetMetaReq, GetMetaResp, GetPreparedLocalReserveTarget, GetRevokeReq,
+        GetRevokeResp, GetStartReq, GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp,
+        MemHolderReleaseReq, MemHolderReleaseResp,
     },
-    route_maintenance::{RoutePublishEvent, enqueue_post_route_maintenance},
+    node_generation_is_current_live, publish_route_replica_tomb_fenced,
+    route_maintenance::{RoutePublishEvent, apply_post_route_maintenance_batch},
 };
 use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::put::PutIDForAKey;
 use crate::memholder::MemholderManagerTrait;
 use crate::{
     cluster_manager::NodeID,
-    master_seg_manager::{MasterSegManagerAccessTrait, one_seg_allocator::Allocation},
+    master_seg_manager::{MasterSegManagerAccessTrait, NodeTombTag, one_seg_allocator::Allocation},
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::{self, kv},
 };
@@ -28,6 +30,7 @@ use std::collections::HashSet;
 use std::{
     collections::HashMap,
     sync::{Arc, atomic::Ordering},
+    time::Instant,
 };
 
 fn touch_moka_for_node(view: MasterKvRouterView, node_id: String, key: String) {
@@ -36,16 +39,27 @@ fn touch_moka_for_node(view: MasterKvRouterView, node_id: String, key: String) {
     }
     let view_task = view.clone();
     view.spawn("touch_moka_for_node", async move {
+        let owner_cache_lock = view_task
+            .master_kv_router()
+            .inner()
+            .owner_cache_operation_locks
+            .get_lock(node_id.clone());
+        let _owner_cache_guard = owner_cache_lock.lock().await;
         if let Some(cache) = view_task
             .master_kv_router()
             .get_node_cache_controller(&node_id)
         {
-            if let Some(desc) = cache.get(&key)
-                && let Some(tier1_cache) = view_task
-                    .master_kv_router()
-                    .get_node_writeback_tier1_controller(&node_id)
+            // A get is a hit signal for ring B when the source is an
+            // unindexed Allocation. Owner-indexed routes are intentionally
+            // absent from this cache.
+            let _ = cache.get(&key);
+            if let Some(tier1_cache) = view_task
+                .master_kv_router()
+                .get_node_writeback_tier1_controller(&node_id)
             {
-                tier1_cache.insert(key.clone(), desc);
+                // Tier1 has independent admission and replacement state; a
+                // hit only touches an already-admitted entry.
+                let _ = tier1_cache.get(&key);
             }
             tracing::debug!(
                 "Touched key: {:?} on node cache: {} (TTL refresh)",
@@ -69,6 +83,93 @@ fn one_kv_routes_has_live_replica(one_kv_nodes_routes: &OneKvNodesRoutes) -> boo
         .any(|kv_info| !kv_info.tomb_tag.is_tomb())
 }
 
+fn validate_prepared_local_reserve_target(
+    view: &MasterKvRouterView,
+    req_node_id: &NodeID,
+    target: &GetPreparedLocalReserveTarget,
+    value_len: u64,
+) -> Result<(CommittedSlotReplica, NodeTombTag), msg_and_error::KvError> {
+    let invalid = |detail: String| {
+        msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument { detail })
+    };
+    if target.slot_size == 0 {
+        return Err(invalid(
+            "prepared local-reserve Get target has zero slot_size".to_string(),
+        ));
+    }
+    if value_len > target.slot_size {
+        return Err(invalid(format!(
+            "prepared local-reserve Get target is too small: value_len={} slot_size={}",
+            value_len, target.slot_size
+        )));
+    }
+    let Some(grant) = view
+        .master_kv_router()
+        .inner()
+        .local_reserve_grants
+        .get(&target.grant_id)
+    else {
+        return Err(invalid(format!(
+            "prepared local-reserve Get target references unknown grant_id={}",
+            target.grant_id
+        )));
+    };
+    if grant.owner_node_id != *req_node_id {
+        return Err(invalid(format!(
+            "prepared local-reserve Get target owner mismatch: grant_id={} owner={} requester={}",
+            target.grant_id, grant.owner_node_id, req_node_id
+        )));
+    }
+    let tomb_tag = grant.tomb_tag.clone();
+    if !node_generation_is_current_live(view, req_node_id, &tomb_tag) {
+        return Err(invalid(format!(
+            "prepared local-reserve Get target belongs to a departed owner generation: grant_id={} requester={}",
+            target.grant_id, req_node_id
+        )));
+    }
+    let grant_base_addr = grant.allocation.base_addr();
+    let grant_addr = grant_base_addr
+        .checked_add(grant.allocation.addr())
+        .ok_or_else(|| invalid("local-reserve grant address overflow".to_string()))?;
+    let slot_offset = target
+        .slot_size
+        .checked_mul(u64::from(target.slot_index))
+        .ok_or_else(|| invalid("prepared local-reserve Get slot offset overflow".to_string()))?;
+    let slot_end = slot_offset
+        .checked_add(target.slot_size)
+        .ok_or_else(|| invalid("prepared local-reserve Get slot end overflow".to_string()))?;
+    if slot_end > grant.allocation.capcity() {
+        return Err(invalid(format!(
+            "prepared local-reserve Get target is outside grant: grant_id={} slot_index={} slot_size={} grant_len={}",
+            target.grant_id,
+            target.slot_index,
+            target.slot_size,
+            grant.allocation.capcity()
+        )));
+    }
+    let expected_addr = grant_addr
+        .checked_add(slot_offset)
+        .ok_or_else(|| invalid("prepared local-reserve Get target address overflow".to_string()))?;
+    if target.base_addr != grant_base_addr || target.addr != expected_addr {
+        return Err(invalid(format!(
+            "prepared local-reserve Get target geometry mismatch: grant_id={} expected_base={:#x} got_base={:#x} expected_addr={:#x} got_addr={:#x}",
+            target.grant_id, grant_base_addr, target.base_addr, expected_addr, target.addr
+        )));
+    }
+    Ok((
+        CommittedSlotReplica {
+            owner_node_id: req_node_id.clone(),
+            grant_id: target.grant_id,
+            slot_index: target.slot_index,
+            slot_size: target.slot_size,
+            addr: target.addr,
+            len: value_len,
+            base_addr: target.base_addr,
+        },
+        tomb_tag,
+    ))
+}
+
 pub async fn handle_get_start(
     view: MasterKvRouterView,
     req: MsgPack<GetStartReq>,
@@ -130,6 +231,18 @@ pub async fn handle_get_start(
         .inner()
         .next_get_id
         .fetch_add(1, Ordering::Relaxed);
+    let prepared_requester_lease = if req.serialize_part.prepared_target.is_some() {
+        match view.master_kv_router().reserve_prepared_get_requester(
+            &req.serialize_part.key,
+            &req_node_id,
+            get_id,
+        ) {
+            Ok(lease) => Some(lease),
+            Err(err) => return failed_resp_err(err, None, &view, &req.serialize_part.key),
+        }
+    } else {
+        None
+    };
 
     let one_kv_nodes_routes: Arc<OneKvNodesRoutes> = if let Some(one_kv_nodes_routes) = view
         .master_kv_router()
@@ -140,7 +253,7 @@ pub async fn handle_get_start(
         one_kv_nodes_routes.clone()
     } else {
         // Key not found
-        tracing::info!("Key not found: {}", req.serialize_part.key);
+        tracing::debug!("Key not found: {}", req.serialize_part.key);
         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::KeyNotFound {
             key: req.serialize_part.key.clone(),
         });
@@ -148,12 +261,14 @@ pub async fn handle_get_start(
     };
 
     let replicas: HashMap<NodeID, KvRouteInfo> = one_kv_nodes_routes.nodes_replicas.read().clone();
+    let prepared_target = req.serialize_part.prepared_target.clone();
     // Currently we are holding the lock with `replicas`
     // 选择一个replica (这里可以实现更复杂的选择逻辑)
     let mut replica_keys = replicas.keys().collect::<Vec<_>>();
     let mut tombs = HashSet::new();
-    let mut target_allocations = None;
+    let mut target = None;
     let mut allocation_mode = GetAllocationMode::Temporary;
+    let mut durable_reservation = None;
     for _ in 0..replicas.len() {
         let to_remove_idx = rand::thread_rng().gen_range(0..replica_keys.len());
         let selected_replica_key = replica_keys.remove(to_remove_idx);
@@ -172,7 +287,7 @@ pub async fn handle_get_start(
         // MemHolder backing. That keeps the existing get-path carrier stable
         // and avoids the old None->unwrap panic.
         let mut allocate_request_target =
-            || -> Result<Arc<Allocation>, (u64, MsgPack<GetStartResp>)> {
+            || -> Result<InflightGetTarget, (u64, MsgPack<GetStartResp>)> {
                 let target_allocation = {
                     let req_node_allocators =
                         view.master_seg_manager().get_node_allocators(&req_node_id);
@@ -228,56 +343,127 @@ pub async fn handle_get_start(
                     }
                     allocated_addr.unwrap()
                 };
-                if one_kv_nodes_routes.try_reserve_get_durable_slot() {
+                if let Some(reservation) = one_kv_nodes_routes.try_reserve_get_durable_slot() {
                     allocation_mode = GetAllocationMode::DurableReplica;
+                    durable_reservation = Some(reservation);
                 } else {
                     allocation_mode = GetAllocationMode::Temporary;
                 }
-                Ok(Arc::new(target_allocation))
+                Ok(InflightGetTarget::Allocation(Arc::new(target_allocation)))
             };
 
         // 为get调用方分配接收内存作为传输target
-        if target_allocations.is_none() {
-            target_allocations = Some(
-                if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
-                    match &replica_on_recv_node.backing {
-                        super::KvReplicaBacking::Allocation(allocation) => {
-                            allocation_mode = GetAllocationMode::ReuseReplica;
-                            allocation.clone()
-                        }
-                        super::KvReplicaBacking::CommittedSlot(_) => {
-                            match allocate_request_target() {
-                                Ok(allocation) => allocation,
-                                Err(resp) => return resp,
-                            }
-                        }
+        if target.is_none() {
+            target = Some(if let Some(prepared_target) = prepared_target.as_ref() {
+                if replicas
+                    .get(&req_node_id)
+                    .is_some_and(|replica| !replica.tomb_tag.is_tomb())
+                {
+                    let err = msg_and_error::KvError::Api(
+                        msg_and_error::ApiError::InvalidArgument {
+                            detail: format!(
+                                "prepared local-reserve Get target cannot replace a live replica: key={} requester={}",
+                                req.serialize_part.key, req_node_id
+                            ),
+                        },
+                    );
+                    return failed_resp_err(
+                        err,
+                        Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+                        &view,
+                        &req.serialize_part.key,
+                    );
+                }
+                let (slot, _prepared_tomb_tag) = match validate_prepared_local_reserve_target(
+                    &view,
+                    &req_node_id,
+                    prepared_target,
+                    src_len,
+                ) {
+                    Ok(slot) => slot,
+                    Err(err) => {
+                        return failed_resp_err(
+                            err,
+                            Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+                            &view,
+                            &req.serialize_part.key,
+                        );
                     }
-                } else {
-                    match allocate_request_target() {
+                };
+                allocation_mode = GetAllocationMode::LocalCommittedSlot;
+                InflightGetTarget::PreparedLocalReserveSlot(slot)
+            } else if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
+                match &replica_on_recv_node.backing {
+                    super::KvReplicaBacking::Allocation(allocation) => {
+                        allocation_mode = GetAllocationMode::ReuseReplica;
+                        InflightGetTarget::Allocation(allocation.clone())
+                    }
+                    super::KvReplicaBacking::CommittedSlot(_) => match allocate_request_target() {
                         Ok(allocation) => allocation,
                         Err(resp) => return resp,
-                    }
-                },
-            );
+                    },
+                }
+            } else {
+                match allocate_request_target() {
+                    Ok(allocation) => allocation,
+                    Err(resp) => return resp,
+                }
+            });
         }
 
-        let target_allocation = target_allocations.unwrap();
+        let target = target
+            .as_ref()
+            .expect("Get target must be selected before building response")
+            .clone();
+
+        // Bind the target to the exact registration generation that owns its
+        // allocator/grant.  Looking up only by node id at GetDone would allow
+        // an old completion to publish addresses into a reconnected node.
+        let target_tomb_tag = match &target {
+            InflightGetTarget::Allocation(allocation) => view
+                .master_seg_manager()
+                .get_allocation_tomb_tag(&req_node_id, allocation),
+            InflightGetTarget::PreparedLocalReserveSlot(slot) => view
+                .master_kv_router()
+                .inner()
+                .local_reserve_grants
+                .get(&slot.grant_id)
+                .and_then(|grant| {
+                    (grant.owner_node_id == req_node_id
+                        && node_generation_is_current_live(&view, &req_node_id, &grant.tomb_tag))
+                    .then(|| grant.tomb_tag.clone())
+                }),
+        };
+        let Some(target_tomb_tag) = target_tomb_tag else {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "Get target generation changed before start publication: get_id={} key={} requester={}",
+                    get_id, req.serialize_part.key, req_node_id
+                ),
+            });
+            return failed_resp_err(
+                err,
+                Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+                &view,
+                &req.serialize_part.key,
+            );
+        };
 
         // Convert to absolute addresses for Mooncake (requires absolute)
         // Use allocation's allocator base directly
-        let target_base = target_allocation.base_addr();
+        let target_base = target.base_addr();
 
         // If we reuse existing target on requesting node, declare src=target on req node
         let (resp_node_id, resp_src_addr, resp_target_addr, resp_src_base, resp_target_base) =
             if allocation_mode == GetAllocationMode::ReuseReplica {
-                let addr = target_base + target_allocation.addr();
+                let addr = target.abs_addr();
                 // both src/target are on requesting node's allocation in this reuse case
                 (req_node_id.clone(), addr, addr, target_base, target_base)
             } else {
                 (
                     src_node_id.clone(),
                     src_abs_addr,
-                    target_base + target_allocation.addr(),
+                    target.abs_addr(),
                     src_base,
                     target_base,
                 )
@@ -292,6 +478,10 @@ pub async fn handle_get_start(
             src_base_addr: resp_src_base,
             target_base_addr: resp_target_base,
             len: src_len,
+            prepared_target: (allocation_mode == GetAllocationMode::LocalCommittedSlot)
+                .then(|| prepared_target.clone())
+                .flatten(),
+            atomic_group: one_kv_nodes_routes.atomic_group.as_deref().cloned(),
             error_code: msg_and_error::OK,
             error_json: String::new(),
             server_process_us: 0,
@@ -309,10 +499,13 @@ pub async fn handle_get_start(
             key: req.serialize_part.key.clone(),
             req_node_id,
             len: src_len,
-            allocation: target_allocation, // 存储target allocation
+            target,
+            target_tomb_tag,
             route: one_kv_nodes_routes.clone(),
             allocation_mode,
+            durable_reservation,
             _activity_lease: activity_lease,
+            _prepared_requester_lease: prepared_requester_lease,
         };
 
         view.master_kv_router()
@@ -346,7 +539,7 @@ pub async fn handle_get_start(
             },
         );
     }
-    tracing::info!("Key not found: {}", req.serialize_part.key);
+    tracing::debug!("Key not found: {}", req.serialize_part.key);
     {
         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::KeyNotFound {
             key: req.serialize_part.key.clone(),
@@ -363,10 +556,61 @@ pub async fn handle_get_start(
 pub async fn handle_get_revoke(
     view: MasterKvRouterView,
     req: MsgPack<GetRevokeReq>,
+    req_node_id: NodeID,
 ) -> MsgPack<GetRevokeResp> {
     tracing::debug!("Handling GetRevokeReq: {:?}", req.serialize_part);
 
     let get_id = req.serialize_part.get_id;
+    let done_lock = view
+        .master_kv_router()
+        .inner()
+        .get_done_locks
+        .get_lock(get_id);
+    let _done_guard = done_lock.lock().await;
+
+    if let Some(inflight_info) = view
+        .master_kv_router()
+        .inner()
+        .inflight_gets
+        .get(&get_id)
+        .await
+    {
+        if inflight_info.req_node_id != req_node_id {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "GetRevoke requester mismatch: get_id={} expected={} got={}",
+                    get_id, inflight_info.req_node_id, req_node_id
+                ),
+            });
+            return MsgPack {
+                serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                raw_bytes: Vec::new(),
+            };
+        }
+    } else if let Some(completed) = view
+        .master_kv_router()
+        .inner()
+        .completed_gets
+        .get(&get_id)
+        .await
+    {
+        let detail = if completed.req_node_id != req_node_id {
+            format!(
+                "GetRevoke requester mismatch after completion: get_id={} expected={} got={}",
+                get_id, completed.req_node_id, req_node_id
+            )
+        } else {
+            format!(
+                "GetRevoke lost the Done race; committed target must not be released: get_id={}",
+                get_id
+            )
+        };
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument { detail });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    }
 
     // Remove from inflight_gets
     if let Some(inflight_info) = view
@@ -378,8 +622,7 @@ pub async fn handle_get_revoke(
     {
         let _activity_completion =
             MasterKeyActivityCompletionGuard::new(inflight_info._activity_lease.clone());
-        inflight_info.release_durable_slot_if_needed();
-        tracing::info!("Revoked get operation with get_id: {}", get_id);
+        tracing::debug!("Revoked get operation with get_id: {}", get_id);
     } else {
         tracing::warn!("Get operation with get_id {} not found for revoke", get_id);
     }
@@ -393,13 +636,59 @@ pub async fn handle_get_revoke(
     }
 }
 
-pub async fn handle_get_done(
+async fn handle_get_done_locked(
     view: MasterKvRouterView,
     req: MsgPack<GetDoneReq>,
+    req_node_id: NodeID,
+    mut deferred_route_events: Option<&mut Vec<RoutePublishEvent>>,
+    mut deferred_terminals: Option<&mut Vec<(u64, CompletedGetInfo)>>,
 ) -> MsgPack<GetDoneResp> {
     tracing::debug!("Handling GetDoneReq: {:?}", req.serialize_part);
 
     let get_id = req.serialize_part.get_id;
+    if let Some(inflight_info) = view
+        .master_kv_router()
+        .inner()
+        .inflight_gets
+        .get(&get_id)
+        .await
+    {
+        if inflight_info.req_node_id != req_node_id {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "GetDone requester mismatch: get_id={} expected={} got={}",
+                    get_id, inflight_info.req_node_id, req_node_id
+                ),
+            });
+            return MsgPack {
+                serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                raw_bytes: Vec::new(),
+            };
+        }
+    } else if let Some(completed) = view
+        .master_kv_router()
+        .inner()
+        .completed_gets
+        .get(&get_id)
+        .await
+    {
+        if completed.req_node_id != req_node_id {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "GetDone requester mismatch after completion: get_id={} expected={} got={}",
+                    get_id, completed.req_node_id, req_node_id
+                ),
+            });
+            return MsgPack {
+                serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                raw_bytes: Vec::new(),
+            };
+        }
+        return MsgPack {
+            serialize_part: completed.response,
+            raw_bytes: Vec::new(),
+        };
+    }
     // Remove from inflight_gets and transfer to get_holding
     if let Some(inflight_info) = view
         .master_kv_router()
@@ -411,77 +700,163 @@ pub async fn handle_get_done(
         let _activity_completion =
             MasterKeyActivityCompletionGuard::new(inflight_info._activity_lease.clone());
         let mut allocation_mode = inflight_info.allocation_mode;
-        let route = inflight_info.route.clone();
         // clone req_node_id to avoid borrow/move conflict when inserting into kv_routes
         let req_node_id = inflight_info.req_node_id.clone();
-        // capture allocation capacity before moving it
-        let alloc_cap = inflight_info.allocation.capcity();
-        // Generate holder_id
-        let holder_id = view
-            .master_kv_router()
-            .inner()
-            .next_holder_id
-            .fetch_add(1, Ordering::Relaxed);
-
-        let src_node_id = inflight_info.src_node_id;
         let key = inflight_info.key;
-
-        // Create holding info
-        let holding_info = OwnerHoldingGetInfo {
-            key: key.clone(),
-            holding_node_id: inflight_info.req_node_id.clone(),
-            len: inflight_info.len,
-            allocation: inflight_info.allocation.clone(),
+        let target_cap = inflight_info.target.capacity();
+        if !node_generation_is_current_live(&view, &req_node_id, &inflight_info.target_tomb_tag) {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "GetDone target generation departed: get_id={} key={} requester={}",
+                    get_id, key, req_node_id
+                ),
+            });
+            let terminal: GetDoneResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            let completed = CompletedGetInfo {
+                req_node_id: req_node_id.clone(),
+                response: terminal.clone(),
+            };
+            if let Some(terminals) = deferred_terminals.as_deref_mut() {
+                terminals.push((get_id, completed));
+            } else {
+                view.master_kv_router()
+                    .inner()
+                    .completed_gets
+                    .insert(get_id, completed)
+                    .await;
+            }
+            return MsgPack {
+                serialize_part: terminal,
+                raw_bytes: Vec::new(),
+            };
+        }
+        // Allocation-backed Gets need a master holder to keep their allocator guard alive.
+        // Local-reserve slots instead carry independent route and holder references in the
+        // owner's slot state, so they deliberately do not create a master Allocation holder.
+        let mut inserted_holder_key = None;
+        let holder_id = match &inflight_info.target {
+            InflightGetTarget::Allocation(allocation) => {
+                let holder_id = view
+                    .master_kv_router()
+                    .inner()
+                    .next_holder_id
+                    .fetch_add(1, Ordering::Relaxed);
+                let holder_key =
+                    crate::memholder::NodeHolderKey::new(req_node_id.to_string(), holder_id);
+                view.master_kv_router().inner().get_holding.insert(
+                    holder_key.clone(),
+                    OwnerHoldingGetInfo {
+                        key: key.clone(),
+                        holding_node_id: inflight_info.req_node_id.clone(),
+                        len: inflight_info.len,
+                        allocation: allocation.clone(),
+                    },
+                );
+                inserted_holder_key = Some(holder_key);
+                holder_id
+            }
+            InflightGetTarget::PreparedLocalReserveSlot(_) => 0,
         };
 
-        // Store in get_holding cache (owned manager, flattened key)
-        view.master_kv_router().inner().get_holding.insert(
-            crate::memholder::NodeHolderKey::new(req_node_id.to_string(), holder_id),
-            holding_info,
-        );
+        // Close the insertion-vs-MemberLeft cleanup race for the holder.  If
+        // MemberLeft marked the shared tag before this check, remove the exact
+        // holder we just inserted.  Otherwise its later cleanup must observe it.
+        if inflight_info.target_tomb_tag.is_tomb() {
+            if let Some(holder_key) = inserted_holder_key.as_ref() {
+                view.master_kv_router()
+                    .inner()
+                    .get_holding
+                    .remove(holder_key);
+            }
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "GetDone target generation departed during holder publication: get_id={} key={} requester={}",
+                    get_id, key, req_node_id
+                ),
+            });
+            let terminal: GetDoneResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            let completed = CompletedGetInfo {
+                req_node_id: req_node_id.clone(),
+                response: terminal.clone(),
+            };
+            if let Some(terminals) = deferred_terminals.as_deref_mut() {
+                terminals.push((get_id, completed));
+            } else {
+                view.master_kv_router()
+                    .inner()
+                    .completed_gets
+                    .insert(get_id, completed)
+                    .await;
+            }
+            return MsgPack {
+                serialize_part: terminal,
+                raw_bytes: Vec::new(),
+            };
+        }
 
         if allocation_mode == GetAllocationMode::DurableReplica {
             let mut promote_committed = false;
             let mut route_publish_event = None;
-            if let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(&key) {
+            if let Some(one_kv_nodes_routes) = view
+                .master_kv_router()
+                .inner()
+                .kv_routes
+                .get(&key)
+                .map(|route| route.clone())
+            {
                 if one_kv_nodes_routes.put_id == inflight_info.put_id {
-                    let mut nodes_replicas = one_kv_nodes_routes.nodes_replicas.write();
-                    if let Some(tomb_tag) =
-                        view.master_seg_manager().get_node_tomb_tag(&src_node_id)
-                    {
-                        if !tomb_tag.is_tomb() {
-                            nodes_replicas.insert(
-                                inflight_info.req_node_id.clone(),
-                                KvRouteInfo {
-                                    node_id: inflight_info.req_node_id,
-                                    backing: super::KvReplicaBacking::Allocation(
-                                        inflight_info.allocation,
-                                    ),
-                                    owner_local_indexed: true,
-                                    tomb_tag,
-                                },
-                            );
-                            promote_committed = true;
-                            route_publish_event = Some(RoutePublishEvent::replica_append(
-                                key.clone(),
-                                inflight_info.put_id,
-                                one_kv_nodes_routes.lease_id,
+                    match view.master_kv_router().reserve_node_cache_capacity(
+                        &req_node_id,
+                        &inflight_info.target_tomb_tag,
+                        ReservedCapacityReason::OwnerIndexedAllocation,
+                        target_cap,
+                    ) {
+                        Ok(capacity_reservation) => {
+                            let replica = KvRouteInfo {
+                                node_id: req_node_id.clone(),
+                                backing: super::KvReplicaBacking::Allocation(match &inflight_info
+                                    .target
+                                {
+                                    InflightGetTarget::Allocation(allocation) => allocation.clone(),
+                                    InflightGetTarget::PreparedLocalReserveSlot(_) => {
+                                        unreachable!("durable Get mode must use Allocation target")
+                                    }
+                                }),
+                                owner_local_indexed: true,
+                                get_durable_reservation: inflight_info.durable_reservation.clone(),
+                                capacity_reservation,
+                                tomb_tag: inflight_info.target_tomb_tag.clone(),
+                            };
+                            if publish_route_replica_tomb_fenced(
+                                &one_kv_nodes_routes,
                                 req_node_id.clone(),
-                                alloc_cap,
-                            ));
-                        } else {
-                            tracing::warn!(
-                                "get node is tomb, get_id: {}, put_id: {:?}",
-                                get_id,
-                                one_kv_nodes_routes.put_id
-                            );
+                                replica,
+                            ) {
+                                promote_committed = true;
+                                route_publish_event = Some(RoutePublishEvent::replica_append(
+                                    key.clone(),
+                                    inflight_info.put_id,
+                                    one_kv_nodes_routes.lease_id,
+                                    req_node_id.clone(),
+                                    target_cap,
+                                ));
+                            } else {
+                                tracing::warn!(
+                                    "durable Get replica publication rejected by generation/live-replica fence: get_id={} put_id={:?}",
+                                    get_id,
+                                    one_kv_nodes_routes.put_id
+                                );
+                            }
                         }
-                    } else {
-                        tracing::warn!(
-                            "get node is tomb, get_id: {}, put_id: {:?}",
+                        Err(err) => tracing::warn!(
+                            "durable Get could not reserve owner-indexed Allocation capacity; keeping temporary: get_id={} key={} owner={} err={}",
                             get_id,
-                            one_kv_nodes_routes.put_id
-                        );
+                            key,
+                            req_node_id,
+                            err,
+                        ),
                     }
                 } else {
                     tracing::warn!(
@@ -499,29 +874,91 @@ pub async fn handle_get_done(
                 );
             }
             if let Some(event) = route_publish_event {
-                enqueue_post_route_maintenance(&view, event).await;
+                if let Some(events) = deferred_route_events.as_deref_mut() {
+                    events.push(event);
+                } else {
+                    apply_post_route_maintenance_batch(&view, vec![event]).await;
+                }
             }
             if !promote_committed {
                 allocation_mode = GetAllocationMode::Temporary;
-                route.release_get_durable_slot();
             }
         } else if allocation_mode == GetAllocationMode::ReuseReplica {
             let mut local_index_published = false;
-            if let Some(current_route) = view.master_kv_router().inner().kv_routes.get(&key) {
-                if current_route.put_id == inflight_info.put_id {
-                    let mut replicas = current_route.nodes_replicas.write();
-                    if let Some(replica) = replicas.get_mut(&req_node_id) {
-                        local_index_published = !replica.tomb_tag.is_tomb()
-                            && matches!(
-                                &replica.backing,
-                                super::KvReplicaBacking::Allocation(allocation)
-                                    if Arc::ptr_eq(allocation, &inflight_info.allocation)
-                            );
-                        if local_index_published {
-                            replica.owner_local_indexed = true;
+            let mut route_lease_id = None;
+            let capacity_reservation = view.master_kv_router().reserve_node_cache_capacity(
+                &req_node_id,
+                &inflight_info.target_tomb_tag,
+                ReservedCapacityReason::OwnerIndexedAllocation,
+                target_cap,
+            );
+            match capacity_reservation {
+                Ok(capacity_reservation) => {
+                    if let Some(current_route) = view
+                        .master_kv_router()
+                        .inner()
+                        .kv_routes
+                        .get(&key)
+                        .map(|route| route.clone())
+                    {
+                        if current_route.put_id == inflight_info.put_id {
+                            route_lease_id = current_route.lease_id;
+                            let mut replicas = current_route.nodes_replicas.write();
+                            if let Some(replica) = replicas.get_mut(&req_node_id) {
+                                local_index_published = !replica.tomb_tag.is_tomb()
+                                    && replica
+                                        .tomb_tag
+                                        .same_generation(&inflight_info.target_tomb_tag)
+                                    && matches!(
+                                        &replica.backing,
+                                        super::KvReplicaBacking::Allocation(allocation)
+                                            if matches!(
+                                                &inflight_info.target,
+                                                InflightGetTarget::Allocation(target)
+                                                    if Arc::ptr_eq(allocation, target)
+                                            )
+                                    );
+                                if local_index_published {
+                                    replica.owner_local_indexed = true;
+                                    replica.capacity_reservation = capacity_reservation;
+                                }
+                            }
+                        }
+                    }
+                    if local_index_published {
+                        let old_ring_b_desc = super::NodeValueReplicaDesc {
+                            weight_bytes: u32::try_from(target_cap).unwrap_or(u32::MAX),
+                            put_id: inflight_info.put_id,
+                        };
+                        let _ = view
+                            .master_kv_router()
+                            .remove_node_cache_entry_exact(
+                                req_node_id.as_ref(),
+                                &key,
+                                &old_ring_b_desc,
+                            )
+                            .await;
+                        let event = RoutePublishEvent::replica_append(
+                            key.clone(),
+                            inflight_info.put_id,
+                            route_lease_id,
+                            req_node_id.clone(),
+                            target_cap,
+                        );
+                        if let Some(events) = deferred_route_events.as_deref_mut() {
+                            events.push(event);
+                        } else {
+                            apply_post_route_maintenance_batch(&view, vec![event]).await;
                         }
                     }
                 }
+                Err(err) => tracing::warn!(
+                    "reused Get allocation could not reserve owner-indexed capacity; keeping temporary: get_id={} key={} owner={} err={}",
+                    get_id,
+                    key,
+                    req_node_id,
+                    err,
+                ),
             }
             if !local_index_published {
                 tracing::warn!(
@@ -534,9 +971,78 @@ pub async fn handle_get_done(
                 );
                 allocation_mode = GetAllocationMode::Temporary;
             }
+        } else if allocation_mode == GetAllocationMode::LocalCommittedSlot {
+            let slot = match &inflight_info.target {
+                InflightGetTarget::PreparedLocalReserveSlot(slot) => slot.clone(),
+                InflightGetTarget::Allocation(_) => {
+                    unreachable!("local committed-slot Get mode must use a prepared slot")
+                }
+            };
+            let mut published = false;
+            let mut route_publish_event = None;
+            if let Some(current_route) = view.master_kv_router().inner().kv_routes.get(&key) {
+                if current_route.put_id == inflight_info.put_id {
+                    let replica = KvRouteInfo {
+                        node_id: req_node_id.clone(),
+                        backing: super::KvReplicaBacking::CommittedSlot(slot),
+                        owner_local_indexed: true,
+                        get_durable_reservation: None,
+                        capacity_reservation: None,
+                        tomb_tag: inflight_info.target_tomb_tag.clone(),
+                    };
+                    if publish_route_replica_tomb_fenced(
+                        &current_route,
+                        req_node_id.clone(),
+                        replica,
+                    ) {
+                        published = true;
+                        route_publish_event = Some(RoutePublishEvent::replica_append(
+                            key.clone(),
+                            inflight_info.put_id,
+                            current_route.lease_id,
+                            req_node_id.clone(),
+                            target_cap,
+                        ));
+                    }
+                }
+            }
+            if !published {
+                let err = msg_and_error::KvError::Api(msg_and_error::ApiError::Unknown {
+                    detail: format!(
+                        "prepared local-reserve Get target could not publish current route: get_id={} key={} put_id=({},{}) owner={}",
+                        get_id, key, inflight_info.put_id.0, inflight_info.put_id.1, req_node_id
+                    ),
+                });
+                let terminal: GetDoneResp =
+                    crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+                let completed = CompletedGetInfo {
+                    req_node_id: req_node_id.clone(),
+                    response: terminal.clone(),
+                };
+                if let Some(terminals) = deferred_terminals.as_deref_mut() {
+                    terminals.push((get_id, completed));
+                } else {
+                    view.master_kv_router()
+                        .inner()
+                        .completed_gets
+                        .insert(get_id, completed)
+                        .await;
+                }
+                return MsgPack {
+                    serialize_part: terminal,
+                    raw_bytes: Vec::new(),
+                };
+            }
+            if let Some(event) = route_publish_event {
+                if let Some(events) = deferred_route_events.as_deref_mut() {
+                    events.push(event);
+                } else {
+                    apply_post_route_maintenance_batch(&view, vec![event]).await;
+                }
+            }
         }
 
-        tracing::info!(
+        tracing::debug!(
             "Completed get operation with get_id: {}, assigned holder_id: {}",
             get_id,
             holder_id
@@ -549,19 +1055,58 @@ pub async fn handle_get_done(
                 GetAllocationMode::Temporary => "temporary",
                 GetAllocationMode::ReuseReplica => "reuse_replica",
                 GetAllocationMode::DurableReplica => "durable_replica",
+                GetAllocationMode::LocalCommittedSlot => "local_committed_slot",
             });
 
+        let terminal = GetDoneResp {
+            holder_id,
+            allocation_mode,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        };
+        let completed = CompletedGetInfo {
+            req_node_id: req_node_id.clone(),
+            response: terminal.clone(),
+        };
+        if let Some(terminals) = deferred_terminals.as_deref_mut() {
+            terminals.push((get_id, completed));
+        } else {
+            view.master_kv_router()
+                .inner()
+                .completed_gets
+                .insert(get_id, completed)
+                .await;
+        }
         MsgPack {
-            serialize_part: GetDoneResp {
-                holder_id,
-                allocation_mode,
-                error_code: msg_and_error::OK,
-                error_json: String::new(),
-                server_process_us: 0,
-            },
+            serialize_part: terminal,
             raw_bytes: Vec::new(),
         }
     } else {
+        if let Some(completed) = view
+            .master_kv_router()
+            .inner()
+            .completed_gets
+            .get(&get_id)
+            .await
+        {
+            if completed.req_node_id != req_node_id {
+                let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                    detail: format!(
+                        "GetDone requester mismatch after completion: get_id={} expected={} got={}",
+                        get_id, completed.req_node_id, req_node_id
+                    ),
+                });
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
+            }
+            return MsgPack {
+                serialize_part: completed.response,
+                raw_bytes: Vec::new(),
+            };
+        }
         tracing::warn!(
             "Get operation with get_id {} not found for completion",
             get_id
@@ -583,6 +1128,20 @@ pub async fn handle_get_done(
     }
 }
 
+pub async fn handle_get_done(
+    view: MasterKvRouterView,
+    req: MsgPack<GetDoneReq>,
+    req_node_id: NodeID,
+) -> MsgPack<GetDoneResp> {
+    let done_lock = view
+        .master_kv_router()
+        .inner()
+        .get_done_locks
+        .get_lock(req.serialize_part.get_id);
+    let _done_guard = done_lock.lock().await;
+    handle_get_done_locked(view, req, req_node_id, None, None).await
+}
+
 // --- MemHolder Handler Functions ---
 
 // pub async fn handle_mem_holder_keep_alive(
@@ -757,15 +1316,12 @@ pub async fn handle_batch_is_exist(
 
     let mut exists_list = Vec::with_capacity(req.serialize_part.keys.len());
 
-    {
-        let _guard = view.master_kv_router().inner().route_lifetime_lock.lock();
-        for key in &req.serialize_part.keys {
-            if let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) {
-                let exists = one_kv_routes_has_live_replica(&one_kv_nodes_routes);
-                exists_list.push(exists);
-            } else {
-                exists_list.push(false);
-            }
+    for key in &req.serialize_part.keys {
+        if let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) {
+            let exists = one_kv_routes_has_live_replica(&one_kv_nodes_routes);
+            exists_list.push(exists);
+        } else {
+            exists_list.push(false);
         }
     }
 
@@ -784,12 +1340,43 @@ pub async fn handle_batch_get_start(
     req: MsgPack<BatchGetStartReq>,
     req_node_id: NodeID,
 ) -> MsgPack<BatchGetStartResp> {
-    let mut items = Vec::with_capacity(req.serialize_part.keys.len());
-    for key in req.serialize_part.keys {
+    let BatchGetStartReq {
+        keys,
+        prepared_targets,
+    } = req.serialize_part;
+    if !prepared_targets.is_empty() && prepared_targets.len() != keys.len() {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: format!(
+                "batch_get_start prepared target length mismatch: keys={} targets={}",
+                keys.len(),
+                prepared_targets.len()
+            ),
+        });
+        let error: GetStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+        return MsgPack {
+            serialize_part: BatchGetStartResp {
+                items: Vec::new(),
+                error_code: error.error_code,
+                error_json: error.error_json,
+                server_process_us: 0,
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+    let prepared_targets = if prepared_targets.is_empty() {
+        vec![None; keys.len()]
+    } else {
+        prepared_targets
+    };
+    let mut items = Vec::with_capacity(keys.len());
+    for (key, prepared_target) in keys.into_iter().zip(prepared_targets) {
         let (_get_id, resp) = handle_get_start(
             view.clone(),
             MsgPack {
-                serialize_part: GetStartReq { key },
+                serialize_part: GetStartReq {
+                    key,
+                    prepared_target,
+                },
                 raw_bytes: Vec::new(),
             },
             req_node_id.clone(),
@@ -805,6 +1392,8 @@ pub async fn handle_batch_get_start(
             target_base_addr: part.target_base_addr,
             src_base_addr: part.src_base_addr,
             len: part.len,
+            prepared_target: part.prepared_target,
+            atomic_group: part.atomic_group,
             error_code: part.error_code,
             error_json: part.error_json,
         });
@@ -823,6 +1412,7 @@ pub async fn handle_batch_get_start(
 pub async fn handle_batch_get_revoke(
     view: MasterKvRouterView,
     req: MsgPack<BatchGetRevokeReq>,
+    req_node_id: NodeID,
 ) -> MsgPack<BatchGetRevokeResp> {
     let mut items = Vec::with_capacity(req.serialize_part.get_ids.len());
     for get_id in req.serialize_part.get_ids {
@@ -832,6 +1422,7 @@ pub async fn handle_batch_get_revoke(
                 serialize_part: GetRevokeReq { get_id },
                 raw_bytes: Vec::new(),
             },
+            req_node_id.clone(),
         )
         .await;
         let part = resp.serialize_part;
@@ -854,18 +1445,50 @@ pub async fn handle_batch_get_revoke(
 pub async fn handle_batch_get_done(
     view: MasterKvRouterView,
     req: MsgPack<BatchGetDoneReq>,
+    req_node_id: NodeID,
 ) -> MsgPack<BatchGetDoneResp> {
-    let mut items = Vec::with_capacity(req.serialize_part.get_ids.len());
-    for get_id in req.serialize_part.get_ids {
-        let resp = handle_get_done(
-            view.clone(),
-            MsgPack {
-                serialize_part: GetDoneReq { get_id },
-                raw_bytes: Vec::new(),
-            },
-        )
-        .await;
-        let part = resp.serialize_part;
+    let started_at = Instant::now();
+    let get_ids = req.serialize_part.get_ids;
+
+    // Hold every per-get terminal lock until the combined route-maintenance
+    // batch and idempotency records are durable. Sorting gives overlapping
+    // retries one global acquisition order and avoids lock cycles.
+    let mut unique_get_ids = get_ids.clone();
+    unique_get_ids.sort_unstable();
+    unique_get_ids.dedup();
+    let mut _done_guards = Vec::with_capacity(unique_get_ids.len());
+    for get_id in unique_get_ids {
+        let lock = view
+            .master_kv_router()
+            .inner()
+            .get_done_locks
+            .get_lock(get_id);
+        _done_guards.push(lock.lock_owned().await);
+    }
+
+    let mut items = Vec::with_capacity(get_ids.len());
+    let mut route_events = Vec::new();
+    let mut deferred_terminals = Vec::new();
+    let mut response_by_get_id = HashMap::<u64, GetDoneResp>::new();
+    for get_id in get_ids {
+        let part = if let Some(part) = response_by_get_id.get(&get_id) {
+            part.clone()
+        } else {
+            let part = handle_get_done_locked(
+                view.clone(),
+                MsgPack {
+                    serialize_part: GetDoneReq { get_id },
+                    raw_bytes: Vec::new(),
+                },
+                req_node_id.clone(),
+                Some(&mut route_events),
+                Some(&mut deferred_terminals),
+            )
+            .await
+            .serialize_part;
+            response_by_get_id.insert(get_id, part.clone());
+            part
+        };
         items.push(BatchGetDoneItemResp {
             get_id,
             holder_id: part.holder_id,
@@ -874,6 +1497,33 @@ pub async fn handle_batch_get_done(
             error_json: part.error_json,
         });
     }
+
+    let route_event_count = route_events.len();
+    let maintenance_started_at = Instant::now();
+    if !route_events.is_empty() {
+        // One Moka capacity decision for the entire Done RPC replaces the old
+        // per-key full-LRU scan while preserving the rule that no success ACK
+        // is visible before every route is admitted to resident policy state.
+        apply_post_route_maintenance_batch(&view, route_events).await;
+    }
+    let maintenance_elapsed = maintenance_started_at.elapsed();
+    for (get_id, completed) in deferred_terminals {
+        view.master_kv_router()
+            .inner()
+            .completed_gets
+            .insert(get_id, completed)
+            .await;
+    }
+    let elapsed = started_at.elapsed();
+    if elapsed.as_millis() >= 100 {
+        tracing::warn!(
+            "slow BatchGetDone convergence: items={} route_events={} maintenance_ms={} total_ms={}",
+            items.len(),
+            route_event_count,
+            maintenance_elapsed.as_millis(),
+            elapsed.as_millis()
+        );
+    }
     MsgPack {
         serialize_part: BatchGetDoneResp {
             items,
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index c0af49e..ccba45e 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -21,24 +21,26 @@ use self::{
     },
     msg_pack::{
         BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
-        BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartReq, BatchIsExistReq,
-        BatchOwnerReclaimReq, BatchPreparePutKeysReq, BatchPutDoneReq, BatchPutRevokeReq,
-        BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq, CountPrefixResp,
-        DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq, GetMasterOnlyMetricPartReq,
-        GetMasterOnlyMetricPartResp, GetMetaReq, GetRevokeReq, GetStartReq, GroupedBatchPutDoneReq,
-        MemHolderKeepAliveReq, MemHolderReleaseReq, OwnerReclaimBacking, OwnerReclaimItem,
+        BatchEvictOwnerSourceReq, BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartReq,
+        BatchIsExistReq, BatchOwnerReclaimReq, BatchPreparePutKeysReq, BatchPutAppendDoneReq,
+        BatchPutAppendStartReq, BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq,
+        BatchReleasePutKeyReservationsReq, CountPrefixReq, CountPrefixResp, DeleteAckReq,
+        DeleteReq, GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetRevokeReq,
+        GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimBacking, OwnerReclaimItem,
         OwnerReclaimReason, PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq,
         PutAtomicGroup, PutDoneReq, PutRevokeReq, PutStartReq, ReleaseLocalGrantReq,
         ReserveLocalGrantReq,
     },
     placement::{PlacementPolicy, build_placement_policy},
     put::{
-        handle_batch_prepare_put_keys, handle_batch_put_done, handle_batch_put_revoke,
-        handle_batch_put_start, handle_batch_release_put_key_reservations,
-        handle_grouped_batch_put_done, handle_put_append_done, handle_put_append_revoke,
-        handle_put_append_start, handle_put_done, handle_put_revoke, handle_put_start,
-        handle_release_local_grant, handle_reserve_local_grant,
+        handle_batch_prepare_put_keys, handle_batch_put_append_done, handle_batch_put_append_start,
+        handle_batch_put_done, handle_batch_put_revoke, handle_batch_put_start,
+        handle_batch_release_put_key_reservations, handle_grouped_batch_put_done,
+        handle_put_append_done, handle_put_append_revoke, handle_put_append_start, handle_put_done,
+        handle_put_revoke, handle_put_start, handle_release_local_grant,
+        handle_reserve_local_grant,
     },
+    reclaim::handle_batch_evict_owner_source,
 };
 use crate::ClientKvApiAccessTrait;
 use crate::client_kv_api::ClientKvApi;
@@ -53,31 +55,26 @@ use crate::master_seg_manager::MasterSegManager;
 use crate::master_seg_manager::MasterSegManagerAccessTrait;
 use crate::master_seg_manager::NodeTombTag;
 use crate::master_seg_manager::one_seg_allocator::Allocation;
-use crate::memholder::{
-    EnsureMemholderMgmtDeleteHandle, MasterOwnerMemMgr, MemholderManagerTrait, NodeHolderKey,
-};
+use crate::memholder::{EnsureMemholderMgmtDeleteHandle, MasterOwnerMemMgr, MemholderManagerTrait};
 use crate::metric_reporter::{MetricReporter, MetricReporterAccessTrait};
 use crate::p2p::msg_pack::{MsgPack, RPCCaller, RPCHandler};
 use crate::p2p::p2p_module::{P2pModule, P2pModuleAccessTrait};
-use crate::rpcresp_kvresult_convert;
 use crate::rpcresp_kvresult_convert::msg_and_error::{KvError, OK};
 use fluxon_framework::{LogicalModule, define_module};
-use fluxon_framework_compiled::upgrade_view_guard::UpgradeViewGuard;
 use fluxon_util::map_lock::AMapLock;
 
 use async_trait::async_trait;
 use chrono::Utc;
-use dashmap::DashMap;
-use limit_thirdparty::tokio::sync::{ARwLock, abroadcast};
+use dashmap::{DashMap, DashSet};
+use limit_thirdparty::tokio::sync::ARwLock;
 use limit_thirdparty::tokio::{self, sync::ampsc};
 use moka::notification::RemovalCause;
 use parking_lot::Mutex;
 use parking_lot::RwLock;
-use std::borrow::Cow;
+use std::collections::HashMap;
 use std::collections::HashSet;
-use std::collections::{HashMap, VecDeque};
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
+use std::sync::{Arc, Weak};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tracing::{debug, error, info, warn};
 
@@ -85,7 +82,6 @@ const MAX_GET_DURABLE_REPLICA_SLOTS: u32 = 2;
 const PLACEMENT_REPORT_INTERVAL_SECS: u64 = 10;
 const INFLIGHT_PUT_TTL_SECONDS: u64 = 60;
 const INFLIGHT_PUT_TTL_SECONDS_SKIP_PUT_END_COMMIT: u64 = 5;
-const EVICTION_RECLAIM_QUEUE_CAPACITY: usize = 4096;
 const POST_ROUTE_MAINTENANCE_QUEUE_CAPACITY: usize = 512;
 const TIER1_WRITEBACK_QUEUE_CAPACITY: usize = 4096;
 
@@ -109,26 +105,39 @@ fn subtract_pending_eviction_weight(
         });
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum UnrecoverableCacheEvictionContext {
-    NormalCapacity,
-    OwnerLocalReserveNoSpace,
+fn try_install_eviction_reclaim_identities(
+    inflight: &DashSet<reclaim::EvictionReclaimIdentity>,
+    identities: Vec<reclaim::EvictionReclaimIdentity>,
+) -> bool {
+    let mut installed = Vec::with_capacity(identities.len());
+    for identity in identities {
+        if inflight.insert(identity.clone()) {
+            installed.push(identity);
+        } else {
+            for identity in installed {
+                assert!(inflight.remove(&identity).is_some());
+            }
+            return false;
+        }
+    }
+    true
 }
 
-fn allow_unrecoverable_cache_eviction(
-    owner_is_remote_only: bool,
-    has_ready_remote_only_owner: bool,
-    context: UnrecoverableCacheEvictionContext,
-) -> bool {
-    // A normal active-tier eviction must preserve the remote copy whenever a remote-only tier is
-    // available. Physical local-reserve exhaustion is the liveness boundary: if that remote tier
-    // has filled and no recoverable active-tier entry remains, refusing to evict the last cached
-    // copy prevents the owner from accepting any subsequent write-back. The existing three-phase
-    // owner reclaim transaction removes the route and slot atomically, so dropping that cold cache
-    // entry is safe and a future lookup simply recomputes it.
-    context == UnrecoverableCacheEvictionContext::OwnerLocalReserveNoSpace
-        || owner_is_remote_only
-        || !has_ready_remote_only_owner
+fn classify_existing_eviction_reclaim(
+    inflight: &DashSet<reclaim::EvictionReclaimIdentity>,
+    identities: &[reclaim::EvictionReclaimIdentity],
+) -> reclaim::EnqueueEvictionReclaimResult {
+    let inflight_count = identities
+        .iter()
+        .filter(|identity| inflight.contains(identity))
+        .count();
+    if inflight_count == identities.len() {
+        reclaim::EnqueueEvictionReclaimResult::AlreadyInProgress
+    } else if inflight_count == 0 {
+        reclaim::EnqueueEvictionReclaimResult::NotInProgress
+    } else {
+        reclaim::EnqueueEvictionReclaimResult::PartialOverlap
+    }
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -139,21 +148,45 @@ pub enum PutPlacementMode {
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum ReservedCapacityReason {
+    LocalReserveGrant,
+    OwnerIndexedAllocation,
     LeaseBoundKv,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct NodeCacheReservedCapacity {
+    /// Exact node registration generation owning these counters.
+    generation: NodeTombTag,
     pub total_bytes: AtomicU64,
+    pub local_reserve_grant_bytes: AtomicU64,
+    pub owner_indexed_allocation_bytes: AtomicU64,
     pub lease_bound_kv_bytes: AtomicU64,
 }
 
 impl NodeCacheReservedCapacity {
+    fn new(generation: NodeTombTag) -> Self {
+        Self {
+            generation,
+            total_bytes: AtomicU64::new(0),
+            local_reserve_grant_bytes: AtomicU64::new(0),
+            owner_indexed_allocation_bytes: AtomicU64::new(0),
+            lease_bound_kv_bytes: AtomicU64::new(0),
+        }
+    }
+
     fn apply_delta(&self, reason: ReservedCapacityReason, delta_bytes: i64) {
         if delta_bytes >= 0 {
             let delta = delta_bytes as u64;
             self.total_bytes.fetch_add(delta, Ordering::Relaxed);
             match reason {
+                ReservedCapacityReason::LocalReserveGrant => {
+                    self.local_reserve_grant_bytes
+                        .fetch_add(delta, Ordering::Relaxed);
+                }
+                ReservedCapacityReason::OwnerIndexedAllocation => {
+                    self.owner_indexed_allocation_bytes
+                        .fetch_add(delta, Ordering::Relaxed);
+                }
                 ReservedCapacityReason::LeaseBoundKv => {
                     self.lease_bound_kv_bytes
                         .fetch_add(delta, Ordering::Relaxed);
@@ -163,6 +196,14 @@ impl NodeCacheReservedCapacity {
             let delta = (-delta_bytes) as u64;
             self.total_bytes.fetch_sub(delta, Ordering::Relaxed);
             match reason {
+                ReservedCapacityReason::LocalReserveGrant => {
+                    self.local_reserve_grant_bytes
+                        .fetch_sub(delta, Ordering::Relaxed);
+                }
+                ReservedCapacityReason::OwnerIndexedAllocation => {
+                    self.owner_indexed_allocation_bytes
+                        .fetch_sub(delta, Ordering::Relaxed);
+                }
                 ReservedCapacityReason::LeaseBoundKv => {
                     self.lease_bound_kv_bytes
                         .fetch_sub(delta, Ordering::Relaxed);
@@ -176,6 +217,57 @@ impl NodeCacheReservedCapacity {
     }
 }
 
+/// Version-scoped reservation that reduces the usable resident-cache capacity
+/// while a lease-bound route is alive.  The token owns the exact counter Arc;
+/// dropping an old Allocation/route can therefore never decrement a newly
+/// reconnected node's counters merely because it reused the same node id.
+pub struct NodeCacheCapacityReservation {
+    view: MasterKvRouterView,
+    node_id: NodeIDString,
+    generation: NodeTombTag,
+    reserved_capacity: Arc<NodeCacheReservedCapacity>,
+    reason: ReservedCapacityReason,
+    bytes: u64,
+    released: AtomicBool,
+}
+
+impl std::fmt::Debug for NodeCacheCapacityReservation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("NodeCacheCapacityReservation")
+            .field("node_id", &self.node_id)
+            .field("bytes", &self.bytes)
+            .field("released", &self.released.load(Ordering::Acquire))
+            .finish()
+    }
+}
+
+impl Drop for NodeCacheCapacityReservation {
+    fn drop(&mut self) {
+        if self.released.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        let Some(_view_guard) = self.view.try_upgrade() else {
+            return;
+        };
+        if let Err(err) = self
+            .view
+            .master_kv_router()
+            .adjust_node_cache_reserved_capacity_identity(
+                &self.node_id,
+                &self.generation,
+                &self.reserved_capacity,
+                self.reason,
+                -(self.bytes as i64),
+            )
+        {
+            warn!(
+                "failed to release generation-scoped cache reservation: node={} bytes={} err={}",
+                self.node_id, self.bytes, err
+            );
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct RequesterTargetPair {
     requester_node_id: NodeIDString,
@@ -198,7 +290,6 @@ pub struct ReplicaCacheNodeObserveSnapshot {
     pub writeback_tier1_owner_accepted: u64,
     pub writeback_tier1_failed: u64,
     pub reclaim_master_activity_deferred: u64,
-    pub reclaim_master_get_holder_observed: u64,
     pub reclaim_owner_holder_deferred: u64,
     pub reclaim_owner_other_deferred: u64,
     pub reclaim_route_changed: u64,
@@ -206,21 +297,18 @@ pub struct ReplicaCacheNodeObserveSnapshot {
     pub reclaim_retry_completed: u64,
     pub reclaim_retry_restored: u64,
     pub reclaim_completed: u64,
-    pub owner_hot_demotion_attempts: u64,
-    pub owner_hot_demotion_cohorts: u64,
-    pub owner_hot_demotion_selected_bytes: u64,
-    pub owner_hot_demotion_precheck_rejected: u64,
-    pub owner_hot_demotion_partial_mismatch: u64,
-    pub recoverable_first_requested_bytes: u64,
-    pub recoverable_first_selected_bytes: u64,
-    pub recoverable_first_shortfall_bytes: u64,
-    pub recoverable_first_eligible_checks: u64,
-    pub recoverable_first_route_absent_checks: u64,
-    pub recoverable_first_version_changed_checks: u64,
-    pub recoverable_first_route_ineligible_checks: u64,
-    pub recoverable_first_cpu_route_absent_checks: u64,
-    pub recoverable_first_atomic_group_incomplete_checks: u64,
-    pub recoverable_first_tp_cohort_incomplete_checks: u64,
+    pub source_evict_rpc_requests: u64,
+    pub source_evict_cohorts: u64,
+    pub source_evict_requested_bytes: u64,
+    pub source_evict_accepted: u64,
+    pub source_evict_in_progress: u64,
+    pub source_evict_completed: u64,
+    pub source_evict_retryable_busy: u64,
+    pub source_evict_stale: u64,
+    pub source_evict_rejected: u64,
+    pub capacity_eviction_non_ring_b_entry_total: u64,
+    pub capacity_eviction_hit_committed_slot: u64,
+    pub eviction_reclaim_deduplicated: u64,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -267,6 +355,8 @@ pub enum InflightPutAllocation {
 #[derive(Clone)]
 pub struct InflightPutCommitInfo {
     pub node_id: NodeID,
+    /// Exact target registration generation captured while the allocation was current.
+    pub target_tomb_tag: NodeTombTag,
     pub src_target_allocation: Arc<Mutex<Option<InflightPutAllocation>>>,
     pub replica_target: Option<InflightReplicaTaskInfo>,
 }
@@ -284,11 +374,12 @@ pub struct InflightPutInfo {
 #[derive(Clone)]
 pub struct InflightReplicaTaskInfo {
     pub node_id: NodeID,
+    /// Exact target registration generation that owns `target_allocation`.
+    pub target_tomb_tag: NodeTombTag,
     pub source_node_id: NodeID,
     pub key: String,
     pub put_id: PutIDForAKey,
     pub target_allocation: Arc<Mutex<Option<Allocation>>>,
-    pub demote_source_on_remote_complete: bool,
     /// Protect the source-owner copy only after this inclusive replica has been
     /// published successfully.  Backend-admitted replicas set this bit; tiered
     /// write-back and owner-hot exclusive demotion deliberately do not.
@@ -304,17 +395,57 @@ pub struct InflightGetInfo {
     pub key: String,
     pub req_node_id: NodeID,
     pub len: u64,
-    pub allocation: Arc<Allocation>,
+    pub target: InflightGetTarget,
+    /// Exact requester registration generation that owns `target`.
+    pub target_tomb_tag: NodeTombTag,
     pub route: Arc<OneKvNodesRoutes>,
     pub allocation_mode: GetAllocationMode,
+    pub durable_reservation: Option<Arc<GetDurableSlotReservation>>,
     pub(crate) _activity_lease: Arc<MasterKeyActivityLease>,
+    /// Requester-scoped guard for prepared local-reserve Gets.  Different GPU
+    /// owners may fetch the same key concurrently, but one owner must never
+    /// materialize two candidate committed slots for the same key.
+    pub(crate) _prepared_requester_lease: Option<Arc<PreparedGetRequesterLease>>,
+}
+
+#[derive(Clone)]
+pub struct CompletedGetInfo {
+    pub req_node_id: NodeID,
+    pub response: GetDoneResp,
+}
+
+#[derive(Clone, Debug)]
+pub enum InflightGetTarget {
+    Allocation(Arc<Allocation>),
+    PreparedLocalReserveSlot(CommittedSlotReplica),
+}
+
+impl InflightGetTarget {
+    pub fn abs_addr(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.base_addr() + allocation.addr(),
+            Self::PreparedLocalReserveSlot(slot) => slot.addr,
+        }
+    }
+
+    pub fn base_addr(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.base_addr(),
+            Self::PreparedLocalReserveSlot(slot) => slot.base_addr,
+        }
+    }
+
+    pub fn capacity(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.capcity(),
+            Self::PreparedLocalReserveSlot(slot) => slot.slot_size,
+        }
+    }
 }
 
 impl InflightGetInfo {
     pub fn release_durable_slot_if_needed(&self) {
-        if self.allocation_mode == GetAllocationMode::DurableReplica {
-            self.route.release_get_durable_slot();
-        }
+        // Durable-slot capacity is returned by the reservation token's Drop.
     }
 }
 
@@ -329,7 +460,11 @@ pub struct OwnerHoldingGetInfo {
 
 pub struct LocalReserveGrantInfo {
     pub owner_node_id: NodeID,
+    /// Exact owner registration generation that owns the grant allocation.
+    pub tomb_tag: NodeTombTag,
     pub allocation: Allocation,
+    /// Excludes this whole grant from the master unindexed-Allocation domain.
+    pub capacity_reservation: Option<Arc<NodeCacheCapacityReservation>>,
 }
 
 pub struct PreparedPutKeyReservationInfo {
@@ -341,7 +476,6 @@ pub struct PreparedPutKeyReservationInfo {
 #[derive(Default)]
 pub(crate) struct EvictionReclaimCounters {
     pub master_activity_deferred: AtomicU64,
-    pub master_get_holder_observed: AtomicU64,
     pub owner_holder_deferred: AtomicU64,
     pub owner_other_deferred: AtomicU64,
     pub route_changed: AtomicU64,
@@ -349,21 +483,24 @@ pub(crate) struct EvictionReclaimCounters {
     pub retry_completed: AtomicU64,
     pub retry_restored: AtomicU64,
     pub completed: AtomicU64,
-    pub owner_hot_demotion_attempts: AtomicU64,
-    pub owner_hot_demotion_cohorts: AtomicU64,
-    pub owner_hot_demotion_selected_bytes: AtomicU64,
-    pub owner_hot_demotion_precheck_rejected: AtomicU64,
-    pub owner_hot_demotion_partial_mismatch: AtomicU64,
-    pub recoverable_first_requested_bytes: AtomicU64,
-    pub recoverable_first_selected_bytes: AtomicU64,
-    pub recoverable_first_shortfall_bytes: AtomicU64,
-    pub recoverable_first_eligible_checks: AtomicU64,
-    pub recoverable_first_route_absent_checks: AtomicU64,
-    pub recoverable_first_version_changed_checks: AtomicU64,
-    pub recoverable_first_route_ineligible_checks: AtomicU64,
-    pub recoverable_first_cpu_route_absent_checks: AtomicU64,
-    pub recoverable_first_atomic_group_incomplete_checks: AtomicU64,
-    pub recoverable_first_tp_cohort_incomplete_checks: AtomicU64,
+    pub source_evict_rpc_requests: AtomicU64,
+    pub source_evict_cohorts: AtomicU64,
+    pub source_evict_requested_bytes: AtomicU64,
+    pub source_evict_accepted: AtomicU64,
+    pub source_evict_in_progress: AtomicU64,
+    pub source_evict_completed: AtomicU64,
+    pub source_evict_retryable_busy: AtomicU64,
+    pub source_evict_stale: AtomicU64,
+    pub source_evict_rejected: AtomicU64,
+    /// A Size event from the ring-B controller resolved to any current route
+    /// outside `Allocation && !owner_local_indexed`.
+    pub capacity_eviction_non_ring_b_entry_total: AtomicU64,
+    /// More specific subset retained for diagnostics/backward-compatible
+    /// metrics: the non-ring-B route used a CommittedSlot backing.
+    pub capacity_eviction_hit_committed_slot: AtomicU64,
+    /// Duplicate listener/cohort events suppressed while the same physical
+    /// cache version already has an outstanding reclaim lifecycle.
+    pub eviction_reclaim_deduplicated: AtomicU64,
 }
 
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
@@ -423,6 +560,82 @@ pub(crate) struct MasterKeyActivityCompletionGuard {
     lease: Option<Arc<MasterKeyActivityLease>>,
 }
 
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+struct PreparedGetRequesterKey {
+    key: String,
+    requester: NodeID,
+}
+
+#[derive(Default)]
+pub(crate) struct PreparedGetRequesterTable {
+    active: Mutex<HashMap<PreparedGetRequesterKey, u64>>,
+}
+
+pub(crate) struct PreparedGetRequesterLease {
+    table: Arc<PreparedGetRequesterTable>,
+    identity: PreparedGetRequesterKey,
+    get_id: u64,
+    released: AtomicBool,
+}
+
+impl PreparedGetRequesterTable {
+    fn reserve(
+        self: &Arc<Self>,
+        key: &str,
+        requester: &NodeID,
+        get_id: u64,
+    ) -> Option<Arc<PreparedGetRequesterLease>> {
+        let identity = PreparedGetRequesterKey {
+            key: key.to_string(),
+            requester: requester.clone(),
+        };
+        let mut active = self.active.lock();
+        if active.contains_key(&identity) {
+            return None;
+        }
+        active.insert(identity.clone(), get_id);
+        Some(Arc::new(PreparedGetRequesterLease {
+            table: self.clone(),
+            identity,
+            get_id,
+            released: AtomicBool::new(false),
+        }))
+    }
+
+    #[cfg(test)]
+    fn active_get_id(&self, key: &str, requester: &NodeID) -> Option<u64> {
+        self.active
+            .lock()
+            .get(&PreparedGetRequesterKey {
+                key: key.to_string(),
+                requester: requester.clone(),
+            })
+            .copied()
+    }
+}
+
+impl PreparedGetRequesterLease {
+    pub(crate) fn release_now(&self) {
+        if self
+            .released
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_err()
+        {
+            return;
+        }
+        let mut active = self.table.active.lock();
+        if active.get(&self.identity) == Some(&self.get_id) {
+            active.remove(&self.identity);
+        }
+    }
+}
+
+impl Drop for PreparedGetRequesterLease {
+    fn drop(&mut self) {
+        self.release_now();
+    }
+}
+
 impl MasterKeyActivityCompletionGuard {
     pub(crate) fn new(lease: Arc<MasterKeyActivityLease>) -> Self {
         Self { lease: Some(lease) }
@@ -640,6 +853,17 @@ impl KvReplicaBacking {
             Self::CommittedSlot(slot) => slot.len,
         }
     }
+
+    /// Bytes owned by the physical backing.  Capacity accounting must use
+    /// this value rather than the logical payload length: an Allocation owns
+    /// its allocator capacity and a committed local-reserve slot owns the
+    /// whole slot.
+    pub fn capacity_bytes(&self) -> u64 {
+        match self {
+            Self::Allocation(allocation) => allocation.capcity(),
+            Self::CommittedSlot(slot) => slot.slot_size,
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -650,9 +874,40 @@ pub struct KvRouteInfo {
     /// Replica-task and remote-put targets are raw master-owned allocations and have no
     /// owner-side key entry to fence during capacity eviction.
     pub owner_local_indexed: bool,
+    /// Present only for an allocation replica created by GetDone. The shared
+    /// token returns the per-key durable-replica budget when this route entry's
+    /// final clone is dropped.
+    pub get_durable_reservation: Option<Arc<GetDurableSlotReservation>>,
+    /// Excludes a non-ring-B backing from the unindexed-Allocation budget and
+    /// is released with the exact route lifetime.
+    pub capacity_reservation: Option<Arc<NodeCacheCapacityReservation>>,
     pub tomb_tag: NodeTombTag,
 }
 
+pub struct GetDurableSlotReservation {
+    route: Weak<OneKvNodesRoutes>,
+    released: AtomicBool,
+}
+
+impl std::fmt::Debug for GetDurableSlotReservation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GetDurableSlotReservation")
+            .field("released", &self.released.load(Ordering::Acquire))
+            .finish()
+    }
+}
+
+impl Drop for GetDurableSlotReservation {
+    fn drop(&mut self) {
+        if self.released.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        if let Some(route) = self.route.upgrade() {
+            route.release_get_durable_slot();
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct OneKvNodesRoutes {
     /// the version id for a kv put operation
@@ -705,7 +960,7 @@ impl OneKvNodesRoutes {
         return true;
     }
 
-    fn try_reserve_get_durable_slot(&self) -> bool {
+    fn try_reserve_get_durable_slot(self: &Arc<Self>) -> Option<Arc<GetDurableSlotReservation>> {
         self.get_durable_slots_used
             .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
                 if current < MAX_GET_DURABLE_REPLICA_SLOTS {
@@ -714,7 +969,13 @@ impl OneKvNodesRoutes {
                     None
                 }
             })
-            .is_ok()
+            .ok()
+            .map(|_| {
+                Arc::new(GetDurableSlotReservation {
+                    route: Arc::downgrade(self),
+                    released: AtomicBool::new(false),
+                })
+            })
     }
 
     fn release_get_durable_slot(&self) {
@@ -726,40 +987,288 @@ impl OneKvNodesRoutes {
     }
 }
 
-fn route_has_live_replica_on_node(route: &OneKvNodesRoutes, node_id: &str) -> bool {
-    route
-        .nodes_replicas
-        .read()
-        .iter()
-        .any(|(candidate, replica)| candidate.as_ref() == node_id && !replica.tomb_tag.is_tomb())
+/// Ring B contains exactly master-only, unindexed Allocation routes.  Node
+/// role is deliberately absent from this predicate: placement and capacity
+/// ownership are orthogonal.
+fn ring_b_route_replica_desc(
+    route: &OneKvNodesRoutes,
+    node_id: &str,
+) -> Option<NodeValueReplicaDesc> {
+    if route.lease_id.is_some() {
+        return None;
+    }
+    let replicas = route.nodes_replicas.read();
+    let replica = replicas.get(node_id)?;
+    if replica.tomb_tag.is_tomb()
+        || replica.owner_local_indexed
+        || !matches!(&replica.backing, KvReplicaBacking::Allocation(_))
+    {
+        return None;
+    }
+    Some(NodeValueReplicaDesc {
+        weight_bytes: u32::try_from(replica.backing.capacity_bytes()).unwrap_or(u32::MAX),
+        put_id: route.put_id,
+    })
 }
 
-fn route_live_remote_cache_nodes(
+/// True only while `tag` is the live registration generation currently bound to `node_id`.
+/// Completion paths must validate their captured tag instead of borrowing the tag of a later
+/// registration that happens to reuse the same node id.
+pub(crate) fn node_generation_is_current_live(
     view: &MasterKvRouterView,
+    node_id: &NodeID,
+    tag: &NodeTombTag,
+) -> bool {
+    !tag.is_tomb()
+        && view
+            .master_seg_manager()
+            .get_node_tomb_tag(node_id)
+            .is_some_and(|current| !current.is_tomb() && current.same_generation(tag))
+}
+
+/// Publish one replica under the route-local lock and close the MemberLeft snapshot race.
+///
+/// There are only two possible linearizations:
+/// - publication wins the final tag check, so a later MemberLeft snapshot observes the route;
+/// - MemberLeft marks the shared tag first, so this function rolls back the exact generation
+///   before releasing the route lock.
+///
+/// A previous live generation is never overwritten on rollback.  In normal operation such a
+/// generation cannot coexist with `replica` (registration replacement tombs the old tag first),
+/// but preserving it makes the identity rule explicit and keeps tests resistant to ABA setup.
+pub(crate) fn publish_route_replica_tomb_fenced(
     route: &OneKvNodesRoutes,
-) -> HashSet<String> {
-    route
-        .nodes_replicas
-        .read()
-        .iter()
-        .filter_map(|(node_id, replica)| {
-            if replica.tomb_tag.is_tomb() {
-                return None;
+    node_id: NodeID,
+    replica: KvRouteInfo,
+) -> bool {
+    let publish_tag = replica.tomb_tag.clone();
+    if publish_tag.is_tomb() {
+        return false;
+    }
+
+    let mut replicas = route.nodes_replicas.write();
+    if publish_tag.is_tomb() {
+        return false;
+    }
+    // A completion pre-check is necessarily racy with another completion for
+    // the same requester.  Never replace a live replica here: only a tombed
+    // generation may be superseded.
+    if replicas
+        .get(&node_id)
+        .is_some_and(|current| !current.tomb_tag.is_tomb())
+    {
+        return false;
+    }
+    let previous = replicas.insert(node_id.clone(), replica);
+
+    if publish_tag.is_tomb() {
+        let published_is_current = replicas.get(&node_id).is_some_and(|current| {
+            current.node_id == node_id && current.tomb_tag.same_generation(&publish_tag)
+        });
+        if published_is_current {
+            replicas.remove(&node_id);
+            if let Some(previous) = previous.filter(|old| !old.tomb_tag.is_tomb()) {
+                replicas.insert(node_id, previous);
             }
-            let member = view
-                .cluster_manager()
-                .get_member_info_cached(node_id.as_ref());
-            placement::member_matches_roles(
-                member.as_ref(),
-                &view
-                    .master_kv_router()
-                    .inner()
-                    .replica_task_placement
-                    .remote_only_node_roles,
-            )
-            .then(|| node_id.as_ref().to_string())
+        }
+        return false;
+    }
+    true
+}
+
+/// Replace one key's primary route while closing the MemberLeft snapshot race.
+///
+/// The DashMap entry guard is held through the final tomb check.  Therefore a
+/// MemberLeft cleanup that starts after a successful check must observe the new
+/// route, while a MemberLeft that marks the generation first causes the exact
+/// replacement to be rolled back.  Restoring `previous` also protects a newer
+/// key version from being lost when a stale completion races node departure.
+pub(crate) fn publish_primary_route_tomb_fenced(
+    routes: &DashMap<String, Arc<OneKvNodesRoutes>>,
+    key: &str,
+    new_route: Arc<OneKvNodesRoutes>,
+    publish_tag: &NodeTombTag,
+) -> Result<Option<Arc<OneKvNodesRoutes>>, ()> {
+    if publish_tag.is_tomb() {
+        return Err(());
+    }
+
+    let mut inserted = false;
+    let mut current = routes.entry(key.to_string()).or_insert_with(|| {
+        inserted = true;
+        new_route.clone()
+    });
+    let previous = if inserted {
+        None
+    } else {
+        Some(std::mem::replace(&mut *current, new_route.clone()))
+    };
+
+    if publish_tag.is_tomb() {
+        if let Some(previous) = previous {
+            *current = previous;
+        } else {
+            // DashMap's vacant-entry guard cannot remove itself.  Drop the
+            // shard guard first, then remove only our exact Arc.  The route is
+            // tombed throughout this tiny window, so readers cannot use it.
+            drop(current);
+            routes.remove_if(key, |_, route| Arc::ptr_eq(route, &new_route));
+        }
+        return Err(());
+    }
+
+    Ok(previous)
+}
+
+fn member_left_can_forward_to_registration_actor(current_node_start_time: Option<i64>) -> bool {
+    // MemberLeft carries only a node id. If membership already exposes a live generation,
+    // forwarding the ambiguous old leave would cancel that generation's registration actor.
+    current_node_start_time.is_none()
+}
+
+/// Remove one departed node generation from a single route.
+///
+/// The route map and replica map deliberately use their normal fine-grained locking only:
+/// MemberLeft is a cold path and must not introduce a process-wide lock around a full-table scan.
+/// The tomb-tag identity fences a delayed cleanup from deleting a live replica published by a
+/// reconnected generation that reused the same node id.
+fn remove_departed_generation_from_route(
+    routes: &DashMap<String, Arc<OneKvNodesRoutes>>,
+    key: &str,
+    route: &Arc<OneKvNodesRoutes>,
+    node_id: &str,
+    departed_tag: &NodeTombTag,
+) -> Option<PutIDForAKey> {
+    let became_empty = {
+        let mut replicas = route.nodes_replicas.write();
+        let remove = replicas.get(node_id).is_some_and(|replica| {
+            replica.node_id.as_ref() == node_id
+                && replica.tomb_tag.is_tomb()
+                && replica.tomb_tag.same_generation(departed_tag)
+        });
+        if !remove {
+            return None;
+        }
+        replicas.remove(node_id);
+        replicas.is_empty()
+    };
+
+    if !became_empty {
+        return None;
+    }
+
+    routes
+        .remove_if(key, |_, current| {
+            // `Arc::ptr_eq` prevents an old cleanup from removing a replacement route (ABA).
+            // Recheck emptiness under the per-route read lock because another replica may have
+            // joined after the write lock above was released.
+            Arc::ptr_eq(current, route) && current.nodes_replicas.read().is_empty()
+        })
+        .map(|(_, removed)| removed.put_id)
+}
+
+const MEMBER_LEFT_ROUTE_CLEANUP_BATCH: usize = 512;
+
+async fn cleanup_departed_generation_routes(
+    view: MasterKvRouterView,
+    node_id: NodeIDString,
+    departed_tag: NodeTombTag,
+) {
+    // Grants own master-side Allocation guards and therefore must be released
+    // for the exact departed generation as well.  Collect ids without keeping
+    // DashMap guards across a removal or yield.
+    let departed_grant_ids: Vec<u64> = view
+        .master_kv_router()
+        .inner()
+        .local_reserve_grants
+        .iter()
+        .filter_map(|entry| {
+            (entry.value().owner_node_id.as_ref() == node_id.as_str()
+                && entry.value().tomb_tag.is_tomb()
+                && entry.value().tomb_tag.same_generation(&departed_tag))
+            .then_some(*entry.key())
         })
-        .collect()
+        .collect();
+    let mut removed_grants = 0usize;
+    for grant_id in departed_grant_ids {
+        if view
+            .master_kv_router()
+            .inner()
+            .local_reserve_grants
+            .remove_if(&grant_id, |_, grant| {
+                grant.owner_node_id.as_ref() == node_id.as_str()
+                    && grant.tomb_tag.is_tomb()
+                    && grant.tomb_tag.same_generation(&departed_tag)
+            })
+            .is_some()
+        {
+            removed_grants = removed_grants.saturating_add(1);
+        }
+    }
+
+    // Weak snapshots avoid pinning every route Allocation for the duration of a large scan.
+    // No DashMap guard or replica lock is held across an await.
+    let route_snapshot: Vec<(String, Weak<OneKvNodesRoutes>)> = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .iter()
+        .map(|entry| (entry.key().clone(), Arc::downgrade(entry.value())))
+        .collect();
+    let mut removed_empty_routes = Vec::new();
+    let mut removed_replicas = 0usize;
+
+    for batch in route_snapshot.chunks(MEMBER_LEFT_ROUTE_CLEANUP_BATCH) {
+        for (key, weak_route) in batch {
+            let Some(route) = weak_route.upgrade() else {
+                continue;
+            };
+            let had_departed_replica = route
+                .nodes_replicas
+                .read()
+                .get(node_id.as_str())
+                .is_some_and(|replica| {
+                    replica.node_id.as_ref() == node_id.as_str()
+                        && replica.tomb_tag.is_tomb()
+                        && replica.tomb_tag.same_generation(&departed_tag)
+                });
+            if !had_departed_replica {
+                continue;
+            }
+            if let Some(put_id) = remove_departed_generation_from_route(
+                &view.master_kv_router().inner().kv_routes,
+                key,
+                &route,
+                node_id.as_str(),
+                &departed_tag,
+            ) {
+                removed_empty_routes.push((key.clone(), put_id));
+            }
+            removed_replicas = removed_replicas.saturating_add(1);
+        }
+        tokio::task::yield_now().await;
+    }
+
+    if view.master_kv_router().prefix_index_enabled() {
+        // Prefix cleanup is batched so one MemberLeft does not spawn one task or acquire one
+        // async write lock per key.
+        for batch in removed_empty_routes.chunks(MEMBER_LEFT_ROUTE_CLEANUP_BATCH) {
+            let mut tree = view.master_kv_router().inner().prefix_index.write().await;
+            for (key, put_id) in batch {
+                tree.remove(key, *put_id);
+            }
+            drop(tree);
+            tokio::task::yield_now().await;
+        }
+    }
+
+    info!(
+        "MemberLeft route cleanup completed: node={} removed_grants={} removed_replicas={} removed_empty_routes={}",
+        node_id,
+        removed_grants,
+        removed_replicas,
+        removed_empty_routes.len()
+    );
 }
 
 const MAX_INFERRED_TP_COHORT_SIZE: usize = 256;
@@ -806,63 +1315,69 @@ pub(crate) fn infer_sglang_tp_key(key: &str) -> Option<InferredTpKey<'_>> {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum RecoverableReplicaStatus {
-    Recoverable,
-    RouteAbsent,
-    VersionChanged,
-    RouteIneligible,
-    CpuRouteAbsent,
+enum CohortExpansionError {
     AtomicGroupIncomplete,
     TpCohortIncomplete,
 }
 
-fn recoverable_cohort_weight<F>(
+fn take_exact_cache_entries(
+    cache: &moka::sync::SegmentedCache<String, NodeValueReplicaDesc>,
     expected_entries: &HashMap<String, NodeValueReplicaDesc>,
-    mut recoverable_status: F,
-) -> Option<u64>
-where
-    F: FnMut(&str, &NodeValueReplicaDesc) -> RecoverableReplicaStatus,
-{
-    let mut expected_weight = 0u64;
-    for (key, desc) in expected_entries {
-        if recoverable_status(key, desc) != RecoverableReplicaStatus::Recoverable {
-            return None;
+) -> Option<Vec<(String, NodeValueReplicaDesc)>> {
+    let mut removed_entries = Vec::with_capacity(expected_entries.len());
+    for (candidate_key, expected_desc) in expected_entries {
+        let result = cache
+            .entry(candidate_key.clone())
+            .and_compute_with(|current| {
+                if current.as_ref().is_some_and(|entry| {
+                    entry.value().put_id == expected_desc.put_id
+                        && entry.value().weight_bytes == expected_desc.weight_bytes
+                }) {
+                    moka::ops::compute::Op::Remove
+                } else {
+                    moka::ops::compute::Op::Nop
+                }
+            });
+        match result {
+            moka::ops::compute::CompResult::Removed(entry) => {
+                removed_entries.push((candidate_key.clone(), entry.into_value()));
+            }
+            _ => {
+                for (removed_key, removed_desc) in removed_entries {
+                    cache.insert(removed_key, removed_desc);
+                }
+                return None;
+            }
         }
-        expected_weight = expected_weight.checked_add(u64::from(desc.weight_bytes))?;
     }
-    (expected_weight != 0).then_some(expected_weight)
+    Some(removed_entries)
 }
 
-impl EvictionReclaimCounters {
-    fn record_recoverable_first_status(&self, status: RecoverableReplicaStatus) {
-        let counter = match status {
-            RecoverableReplicaStatus::Recoverable => &self.recoverable_first_eligible_checks,
-            RecoverableReplicaStatus::RouteAbsent => &self.recoverable_first_route_absent_checks,
-            RecoverableReplicaStatus::VersionChanged => {
-                &self.recoverable_first_version_changed_checks
-            }
-            RecoverableReplicaStatus::RouteIneligible => {
-                &self.recoverable_first_route_ineligible_checks
-            }
-            RecoverableReplicaStatus::CpuRouteAbsent => {
-                &self.recoverable_first_cpu_route_absent_checks
-            }
-            RecoverableReplicaStatus::AtomicGroupIncomplete => {
-                &self.recoverable_first_atomic_group_incomplete_checks
-            }
-            RecoverableReplicaStatus::TpCohortIncomplete => {
-                &self.recoverable_first_tp_cohort_incomplete_checks
+fn remove_exact_cache_entry(
+    cache: &moka::sync::SegmentedCache<String, NodeValueReplicaDesc>,
+    key: &str,
+    expected_desc: &NodeValueReplicaDesc,
+) -> bool {
+    matches!(
+        cache.entry(key.to_string()).and_compute_with(|current| {
+            if current.as_ref().is_some_and(|entry| {
+                entry.value().put_id == expected_desc.put_id
+                    && entry.value().weight_bytes == expected_desc.weight_bytes
+            }) {
+                moka::ops::compute::Op::Remove
+            } else {
+                moka::ops::compute::Op::Nop
             }
-        };
-        counter.fetch_add(1, Ordering::Relaxed);
-    }
+        }),
+        moka::ops::compute::CompResult::Removed(_)
+    )
 }
 
 fn current_atomic_group_members(
     key: &str,
     route: &OneKvNodesRoutes,
     desc: &NodeValueReplicaDesc,
-) -> Result<Vec<msg_pack::PutAtomicGroupMember>, RecoverableReplicaStatus> {
+) -> Result<Vec<msg_pack::PutAtomicGroupMember>, CohortExpansionError> {
     let Some(group) = route.atomic_group.as_ref() else {
         return Ok(vec![msg_pack::PutAtomicGroupMember {
             key: key.to_string(),
@@ -874,7 +1389,7 @@ fn current_atomic_group_members(
         .iter()
         .any(|member| member.key == key && member.put_id == desc.put_id)
     {
-        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
+        return Err(CohortExpansionError::AtomicGroupIncomplete);
     }
     Ok(group.members.clone())
 }
@@ -883,7 +1398,7 @@ fn current_tp_cohort_keys(
     key: &str,
     route: &OneKvNodesRoutes,
     desc: &NodeValueReplicaDesc,
-) -> Result<Vec<String>, RecoverableReplicaStatus> {
+) -> Result<Vec<String>, CohortExpansionError> {
     let current_members = current_atomic_group_members(key, route, desc)?;
     let Some(key_tp) = infer_sglang_tp_key(key) else {
         return Ok(current_members
@@ -901,10 +1416,10 @@ fn current_tp_cohort_keys(
     let mut logical_members = Vec::with_capacity(current_members.len());
     for member in current_members {
         let Some(member_tp) = infer_sglang_tp_key(&member.key) else {
-            return Err(RecoverableReplicaStatus::TpCohortIncomplete);
+            return Err(CohortExpansionError::TpCohortIncomplete);
         };
         if member_tp.rank != key_tp.rank || member_tp.size != key_tp.size {
-            return Err(RecoverableReplicaStatus::TpCohortIncomplete);
+            return Err(CohortExpansionError::TpCohortIncomplete);
         }
         logical_members.push(member_tp.logical_prefix.to_string());
     }
@@ -920,292 +1435,93 @@ fn current_tp_cohort_keys(
     Ok(cohort_keys)
 }
 
-fn intersect_remote_nodes(
-    common_remote_nodes: &mut Option<HashSet<String>>,
-    mut member_remote_nodes: HashSet<String>,
-    owner_node_id: &str,
-) -> Result<(), RecoverableReplicaStatus> {
-    member_remote_nodes.remove(owner_node_id);
-    if member_remote_nodes.is_empty() {
-        return Err(RecoverableReplicaStatus::CpuRouteAbsent);
-    }
-    match common_remote_nodes.as_mut() {
-        Some(common) => common.retain(|node_id| member_remote_nodes.contains(node_id)),
-        None => *common_remote_nodes = Some(member_remote_nodes),
-    }
-    if common_remote_nodes.as_ref().is_some_and(HashSet::is_empty) {
-        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-    }
-    Ok(())
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cluster_manager::ClusterMember;
+    use std::collections::HashMap;
 
-fn validate_recoverable_group(
-    owner_node_id: &str,
-    expected_keys: &[String],
-    expected_put_ids: Option<&[PutIDForAKey]>,
-    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
-    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
-) -> Result<HashSet<String>, RecoverableReplicaStatus> {
-    if expected_put_ids.is_some_and(|put_ids| put_ids.len() != expected_keys.len()) {
-        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-    }
-    let Some(first_key) = expected_keys.first() else {
-        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-    };
-    let Some(first_route) = route_lookup(first_key) else {
-        return Err(RecoverableReplicaStatus::RouteAbsent);
-    };
+    #[test]
+    fn one_kv_nodes_routes_only_reserves_two_get_durable_slots() {
+        let routes = Arc::new(OneKvNodesRoutes {
+            put_id: (1, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::new()),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
 
-    if expected_keys.len() == 1 {
-        if expected_put_ids.is_some_and(|put_ids| first_route.put_id != put_ids[0]) {
-            return Err(RecoverableReplicaStatus::VersionChanged);
-        }
-        if first_route.lease_id.is_some() || first_route.atomic_group.is_some() {
-            return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-        }
-        let mut common_remote_nodes = None;
-        intersect_remote_nodes(
-            &mut common_remote_nodes,
-            live_remote_nodes(&first_route),
-            owner_node_id,
-        )?;
-        return common_remote_nodes.ok_or(RecoverableReplicaStatus::CpuRouteAbsent);
-    }
-
-    let Some(group) = first_route.atomic_group.as_ref() else {
-        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-    };
-    if group.members.len() != expected_keys.len()
-        || group
-            .members
-            .iter()
-            .zip(expected_keys)
-            .any(|(member, expected_key)| member.key != *expected_key)
-        || expected_put_ids.is_some_and(|put_ids| {
-            group
-                .members
-                .iter()
-                .zip(put_ids)
-                .any(|(member, expected_put_id)| member.put_id != *expected_put_id)
-        })
-    {
-        return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-    }
-
-    let mut common_remote_nodes = None;
-    for member in &group.members {
-        let Some(member_route) = route_lookup(&member.key) else {
-            return Err(RecoverableReplicaStatus::RouteAbsent);
-        };
-        if member_route.put_id != member.put_id
-            || member_route.lease_id.is_some()
-            || member_route.atomic_group.as_deref() != Some(group.as_ref())
-        {
-            return Err(RecoverableReplicaStatus::AtomicGroupIncomplete);
-        }
-        intersect_remote_nodes(
-            &mut common_remote_nodes,
-            live_remote_nodes(&member_route),
-            owner_node_id,
-        )?;
-    }
-    common_remote_nodes.ok_or(RecoverableReplicaStatus::CpuRouteAbsent)
-}
-
-fn validate_current_recoverable_group(
-    owner_node_id: &str,
-    route: &OneKvNodesRoutes,
-    current_members: &[msg_pack::PutAtomicGroupMember],
-    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
-    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
-) -> Result<HashSet<String>, RecoverableReplicaStatus> {
-    if current_members.len() == 1 {
-        let mut common_remote_nodes = None;
-        intersect_remote_nodes(
-            &mut common_remote_nodes,
-            live_remote_nodes(route),
-            owner_node_id,
-        )?;
-        return common_remote_nodes.ok_or(RecoverableReplicaStatus::CpuRouteAbsent);
-    }
-    let current_keys = current_members
-        .iter()
-        .map(|member| member.key.clone())
-        .collect::<Vec<_>>();
-    let current_put_ids = current_members
-        .iter()
-        .map(|member| member.put_id)
-        .collect::<Vec<_>>();
-    validate_recoverable_group(
-        owner_node_id,
-        &current_keys,
-        Some(&current_put_ids),
-        route_lookup,
-        live_remote_nodes,
-    )
-}
-
-fn route_recoverable_replica_status_with(
-    owner_node_id: &str,
-    key: &str,
-    route: &OneKvNodesRoutes,
-    desc: &NodeValueReplicaDesc,
-    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
-    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
-) -> RecoverableReplicaStatus {
-    if route.put_id != desc.put_id {
-        return RecoverableReplicaStatus::VersionChanged;
-    }
-    if route.lease_id.is_some() || !route_has_live_replica_on_node(route, owner_node_id) {
-        return RecoverableReplicaStatus::RouteIneligible;
-    }
+        let first = routes.try_reserve_get_durable_slot().unwrap();
+        let second = routes.try_reserve_get_durable_slot().unwrap();
+        assert!(routes.try_reserve_get_durable_slot().is_none());
 
-    let current_members = match current_atomic_group_members(key, route, desc) {
-        Ok(members) => members,
-        Err(status) => return status,
-    };
-    let Some(key_tp) = infer_sglang_tp_key(key) else {
-        return match validate_current_recoverable_group(
-            owner_node_id,
-            route,
-            &current_members,
-            route_lookup,
-            live_remote_nodes,
-        ) {
-            Ok(_) => RecoverableReplicaStatus::Recoverable,
-            Err(status) => status,
-        };
-    };
-    if key_tp.size == 1 {
-        return match validate_current_recoverable_group(
-            owner_node_id,
-            route,
-            &current_members,
-            route_lookup,
-            live_remote_nodes,
-        ) {
-            Ok(_) => RecoverableReplicaStatus::Recoverable,
-            Err(status) => status,
-        };
-    }
-
-    let mut logical_members = Vec::with_capacity(current_members.len());
-    for member in &current_members {
-        let Some(member_tp) = infer_sglang_tp_key(&member.key) else {
-            return RecoverableReplicaStatus::TpCohortIncomplete;
-        };
-        if member_tp.rank != key_tp.rank || member_tp.size != key_tp.size {
-            return RecoverableReplicaStatus::TpCohortIncomplete;
-        }
-        logical_members.push(member_tp.logical_prefix.to_string());
-    }
-
-    let mut cohort_remote_nodes: Option<HashSet<String>> = None;
-    for rank in 0..key_tp.size {
-        let peer_keys = logical_members
-            .iter()
-            .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", key_tp.size))
-            .collect::<Vec<_>>();
-        let rank_result = if rank == key_tp.rank {
-            validate_current_recoverable_group(
-                owner_node_id,
-                route,
-                &current_members,
-                route_lookup,
-                live_remote_nodes,
-            )
-        } else {
-            validate_recoverable_group(
-                owner_node_id,
-                &peer_keys,
-                None,
-                route_lookup,
-                live_remote_nodes,
-            )
-        };
-        let rank_remote_nodes = match rank_result {
-            Ok(nodes) => nodes,
-            Err(_) => return RecoverableReplicaStatus::TpCohortIncomplete,
-        };
-        match cohort_remote_nodes.as_mut() {
-            Some(common) => common.retain(|node_id| rank_remote_nodes.contains(node_id)),
-            None => cohort_remote_nodes = Some(rank_remote_nodes),
-        }
-        if cohort_remote_nodes.as_ref().is_some_and(HashSet::is_empty) {
-            return RecoverableReplicaStatus::TpCohortIncomplete;
-        }
+        drop(first);
+        assert!(routes.try_reserve_get_durable_slot().is_some());
+        drop(second);
     }
-    if cohort_remote_nodes.is_some_and(|nodes| !nodes.is_empty()) {
-        RecoverableReplicaStatus::Recoverable
-    } else {
-        RecoverableReplicaStatus::TpCohortIncomplete
-    }
-}
-
-#[cfg(test)]
-fn route_has_recoverable_replica_with(
-    owner_node_id: &str,
-    key: &str,
-    route: &OneKvNodesRoutes,
-    desc: &NodeValueReplicaDesc,
-    route_lookup: &dyn Fn(&str) -> Option<Arc<OneKvNodesRoutes>>,
-    live_remote_nodes: &dyn Fn(&OneKvNodesRoutes) -> HashSet<String>,
-) -> bool {
-    route_recoverable_replica_status_with(
-        owner_node_id,
-        key,
-        route,
-        desc,
-        route_lookup,
-        live_remote_nodes,
-    ) == RecoverableReplicaStatus::Recoverable
-}
-
-fn route_recoverable_replica_status(
-    view: &MasterKvRouterView,
-    owner_node_id: &str,
-    key: &str,
-    route: &OneKvNodesRoutes,
-    desc: &NodeValueReplicaDesc,
-) -> RecoverableReplicaStatus {
-    route_recoverable_replica_status_with(
-        owner_node_id,
-        key,
-        route,
-        desc,
-        &|member_key| {
-            view.master_kv_router()
-                .inner()
-                .kv_routes
-                .get(member_key)
-                .map(|entry| entry.clone())
-        },
-        &|member_route| route_live_remote_cache_nodes(view, member_route),
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::cluster_manager::ClusterMember;
-    use std::collections::HashMap;
 
     #[test]
-    fn one_kv_nodes_routes_only_reserves_two_get_durable_slots() {
-        let routes = OneKvNodesRoutes {
+    fn durable_slot_token_returns_capacity_across_ten_fill_demote_cycles() {
+        let routes = Arc::new(OneKvNodesRoutes {
             put_id: (1, 0),
             lease_id: None,
             atomic_group: None,
             nodes_replicas: RwLock::new(HashMap::new()),
             get_durable_slots_used: AtomicU32::new(0),
-        };
+        });
 
-        assert!(routes.try_reserve_get_durable_slot());
-        assert!(routes.try_reserve_get_durable_slot());
-        assert!(!routes.try_reserve_get_durable_slot());
+        for cycle in 0..10 {
+            let reservation = routes
+                .try_reserve_get_durable_slot()
+                .expect("each fill must reacquire durable capacity after demotion");
+            assert_eq!(routes.get_durable_slots_used.load(Ordering::Acquire), 1);
+            let route_clone = reservation.clone();
+            drop(reservation);
+            assert_eq!(
+                routes.get_durable_slots_used.load(Ordering::Acquire),
+                1,
+                "route clone must retain the token during cycle {cycle}"
+            );
+            drop(route_clone);
+            assert_eq!(
+                routes.get_durable_slots_used.load(Ordering::Acquire),
+                0,
+                "demotion must return durable capacity during cycle {cycle}"
+            );
+        }
+    }
 
-        routes.release_get_durable_slot();
-        assert!(routes.try_reserve_get_durable_slot());
+    #[test]
+    fn prepared_get_singleflight_is_same_owner_only_and_aba_safe() {
+        let table = Arc::new(PreparedGetRequesterTable::default());
+        let gpu0: NodeID = "gpu-owner-0".to_string().into();
+        let gpu1: NodeID = "gpu-owner-1".to_string().into();
+
+        let gpu0_first = table
+            .reserve("shared-key", &gpu0, 11)
+            .expect("first prepared Get on gpu0 must lead");
+        assert!(
+            table.reserve("shared-key", &gpu0, 12).is_none(),
+            "same owner cannot materialize a second candidate slot"
+        );
+        let gpu1_first = table
+            .reserve("shared-key", &gpu1, 13)
+            .expect("different requester owners remain parallel");
+        assert_eq!(table.active_get_id("shared-key", &gpu0), Some(11));
+        assert_eq!(table.active_get_id("shared-key", &gpu1), Some(13));
+
+        gpu0_first.release_now();
+        let gpu0_second = table
+            .reserve("shared-key", &gpu0, 14)
+            .expect("released owner identity can be reused");
+        // A delayed Drop/release of the old generation must not delete get 14.
+        gpu0_first.release_now();
+        assert_eq!(table.active_get_id("shared-key", &gpu0), Some(14));
+
+        drop(gpu0_second);
+        drop(gpu1_first);
+        assert_eq!(table.active_get_id("shared-key", &gpu0), None);
+        assert_eq!(table.active_get_id("shared-key", &gpu1), None);
     }
 
     #[test]
@@ -1220,7 +1536,7 @@ mod tests {
                 slot_index: 17,
                 slot_size: 8 * 1024 * 1024,
             },
-            reason: OwnerReclaimReason::Reserve,
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
         };
 
         let get_lease = table
@@ -1284,11 +1600,7 @@ mod tests {
         assert!(table.is_quiescent("retired-clone"));
     }
 
-    fn test_route_info(node_id: &str, tomb: bool) -> KvRouteInfo {
-        let tomb_tag = NodeTombTag::new();
-        if tomb {
-            tomb_tag.set_tomb();
-        }
+    fn test_route_info_with_tag(node_id: &str, tomb_tag: NodeTombTag) -> KvRouteInfo {
         KvRouteInfo {
             node_id: node_id.to_string().into(),
             backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
@@ -1301,10 +1613,41 @@ mod tests {
                 base_addr: 0,
             }),
             owner_local_indexed: true,
+            get_durable_reservation: None,
+            capacity_reservation: None,
             tomb_tag,
         }
     }
 
+    fn test_route_info(node_id: &str, tomb: bool) -> KvRouteInfo {
+        let tomb_tag = NodeTombTag::new();
+        if tomb {
+            tomb_tag.set_tomb();
+        }
+        test_route_info_with_tag(node_id, tomb_tag)
+    }
+
+    fn test_allocation_route_info(node_id: &str, owner_local_indexed: bool) -> KvRouteInfo {
+        let allocator = Arc::new(
+            crate::master_seg_manager::one_seg_allocator::OneSegAllocator::new(
+                format!("{node_id}-segment"),
+                crate::master_seg_manager::msg_pack::SegmentDeviceDescription::Cpu,
+                0,
+                4096,
+            )
+            .unwrap(),
+        );
+        let allocation = allocator.allocate(1024).unwrap();
+        KvRouteInfo {
+            node_id: node_id.to_string().into(),
+            backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
+            owner_local_indexed,
+            get_durable_reservation: None,
+            capacity_reservation: None,
+            tomb_tag: NodeTombTag::new(),
+        }
+    }
+
     fn test_route(
         put_id: PutIDForAKey,
         lease_id: Option<u64>,
@@ -1326,123 +1669,279 @@ mod tests {
         }
     }
 
-    fn test_remote_nodes(route: &OneKvNodesRoutes) -> HashSet<String> {
-        route
-            .nodes_replicas
-            .read()
-            .iter()
-            .filter_map(|(node_id, replica)| {
-                (!replica.tomb_tag.is_tomb() && node_id.as_ref().starts_with("cpu"))
-                    .then(|| node_id.as_ref().to_string())
-            })
-            .collect()
-    }
-
     #[test]
-    fn recoverable_route_requires_live_local_and_live_remote_cache_same_version() {
-        let desc = NodeValueReplicaDesc {
-            weight_bytes: 1024,
-            put_id: (7, 3),
-        };
-        let no_lookup = |_key: &str| None;
-        let recoverable = |route: &OneKvNodesRoutes| {
-            route_has_recoverable_replica_with(
-                "gpu0",
-                "k",
-                route,
-                &desc,
-                &no_lookup,
-                &test_remote_nodes,
-            )
+    fn ring_b_admission_depends_on_backing_and_local_index_not_node_role() {
+        let node: NodeID = "same-node".to_string().into();
+        let make_route = |lease_id, replica| OneKvNodesRoutes {
+            put_id: (91, 3),
+            lease_id,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(node.clone(), replica)])),
+            get_durable_slots_used: AtomicU32::new(0),
         };
 
-        let cpu_copy = test_route((7, 3), None, vec![("gpu0", false), ("cpu0", false)]);
-        assert!(recoverable(&cpu_copy));
+        let unindexed = make_route(None, test_allocation_route_info("same-node", false));
+        let desc = ring_b_route_replica_desc(&unindexed, "same-node")
+            .expect("unindexed Allocation must enter ring B on any node role");
+        assert_eq!(desc.put_id, (91, 3));
+        assert_eq!(desc.weight_bytes, 4096);
 
-        let local_only = test_route((7, 3), None, vec![("gpu0", false)]);
-        assert!(!recoverable(&local_only));
+        let indexed = make_route(None, test_allocation_route_info("same-node", true));
+        assert!(ring_b_route_replica_desc(&indexed, "same-node").is_none());
 
-        let gpu_copy = test_route((7, 3), None, vec![("gpu0", false), ("gpu1", false)]);
-        assert!(!recoverable(&gpu_copy));
+        let leased = make_route(Some(7), test_allocation_route_info("same-node", false));
+        assert!(ring_b_route_replica_desc(&leased, "same-node").is_none());
 
-        let remote_tomb = test_route((7, 3), None, vec![("gpu0", false), ("cpu0", true)]);
-        assert!(!recoverable(&remote_tomb));
-
-        let local_tomb = test_route((7, 3), None, vec![("gpu0", true), ("cpu0", false)]);
-        assert!(!recoverable(&local_tomb));
+        let mut committed = test_route_info("same-node", false);
+        committed.owner_local_indexed = false;
+        let committed = make_route(None, committed);
+        assert!(ring_b_route_replica_desc(&committed, "same-node").is_none());
+    }
 
-        let stale = test_route((8, 0), None, vec![("gpu0", false), ("cpu0", false)]);
-        assert!(!recoverable(&stale));
+    #[test]
+    fn member_left_cleanup_removes_only_the_exact_tomb_generation() {
+        let routes = DashMap::new();
+        let departed_tag = NodeTombTag::new();
+        departed_tag.set_tomb();
+        let live_reconnect_tag = NodeTombTag::new();
+        let newer_tomb_tag = NodeTombTag::new();
+        newer_tomb_tag.set_tomb();
+
+        let departed_route = Arc::new(OneKvNodesRoutes {
+            put_id: (10, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                "owner".to_string().into(),
+                test_route_info_with_tag("owner", departed_tag.clone()),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        let live_route = Arc::new(OneKvNodesRoutes {
+            put_id: (11, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                "owner".to_string().into(),
+                test_route_info_with_tag("owner", live_reconnect_tag),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        let newer_tomb_route = Arc::new(OneKvNodesRoutes {
+            put_id: (12, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                "owner".to_string().into(),
+                test_route_info_with_tag("owner", newer_tomb_tag),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        routes.insert("departed".to_string(), departed_route.clone());
+        routes.insert("live".to_string(), live_route.clone());
+        routes.insert("newer-tomb".to_string(), newer_tomb_route.clone());
 
-        let leased = test_route((7, 3), Some(11), vec![("gpu0", false), ("cpu0", false)]);
-        assert!(!recoverable(&leased));
+        assert_eq!(
+            remove_departed_generation_from_route(
+                &routes,
+                "departed",
+                &departed_route,
+                "owner",
+                &departed_tag,
+            ),
+            Some((10, 0))
+        );
+        assert!(routes.get("departed").is_none());
+        assert_eq!(
+            remove_departed_generation_from_route(
+                &routes,
+                "live",
+                &live_route,
+                "owner",
+                &departed_tag,
+            ),
+            None
+        );
+        assert!(
+            live_route
+                .nodes_replicas
+                .read()
+                .get("owner")
+                .is_some_and(|replica| !replica.tomb_tag.is_tomb())
+        );
+        assert_eq!(
+            remove_departed_generation_from_route(
+                &routes,
+                "newer-tomb",
+                &newer_tomb_route,
+                "owner",
+                &departed_tag,
+            ),
+            None
+        );
+        assert!(newer_tomb_route.nodes_replicas.read().contains_key("owner"));
     }
 
     #[test]
-    fn recoverable_atomic_group_requires_one_common_remote_cache_owner() {
-        let group = Arc::new(PutAtomicGroup {
-            members: vec![
-                msg_pack::PutAtomicGroupMember {
-                    key: "k0".to_string(),
-                    put_id: (7, 0),
-                },
-                msg_pack::PutAtomicGroupMember {
-                    key: "k1".to_string(),
-                    put_id: (7, 1),
-                },
-            ],
+    fn member_left_empty_route_removal_is_arc_identity_aba_safe() {
+        let routes = DashMap::new();
+        let departed_tag = NodeTombTag::new();
+        departed_tag.set_tomb();
+        let old_route = Arc::new(OneKvNodesRoutes {
+            put_id: (20, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                "owner".to_string().into(),
+                test_route_info_with_tag("owner", departed_tag.clone()),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
         });
-        let make_route = |put_id, remote_node: Option<&str>| {
-            let mut replicas = vec![("gpu0", false)];
-            if let Some(remote_node) = remote_node {
-                replicas.push((remote_node, false));
-            }
-            let mut route = test_route(put_id, None, replicas);
-            route.atomic_group = Some(group.clone());
-            Arc::new(route)
-        };
-        let desc = NodeValueReplicaDesc {
-            weight_bytes: 1024,
-            put_id: (7, 0),
-        };
+        let replacement = Arc::new(test_route((21, 0), None, vec![("peer", false)]));
+        routes.insert("aba".to_string(), old_route.clone());
+        routes.insert("aba".to_string(), replacement.clone());
+
+        assert_eq!(
+            remove_departed_generation_from_route(
+                &routes,
+                "aba",
+                &old_route,
+                "owner",
+                &departed_tag,
+            ),
+            None
+        );
+        let current = routes.get("aba").expect("replacement route must survive");
+        assert!(Arc::ptr_eq(current.value(), &replacement));
+        assert!(
+            current
+                .nodes_replicas
+                .read()
+                .get("peer")
+                .is_some_and(|replica| !replica.tomb_tag.is_tomb())
+        );
+    }
+
+    #[test]
+    fn replica_publish_fence_never_overwrites_live_or_publishes_tomb_generation() {
+        let old_tag = NodeTombTag::new();
+        let route = test_route((30, 0), None, vec![]);
+        route.nodes_replicas.write().insert(
+            "owner".to_string().into(),
+            test_route_info_with_tag("owner", old_tag.clone()),
+        );
 
-        let k0 = make_route((7, 0), Some("cpu0"));
-        let k1 = make_route((7, 1), Some("cpu0"));
-        let routes = HashMap::from([("k0".to_string(), k0.clone()), ("k1".to_string(), k1)]);
-        assert!(route_has_recoverable_replica_with(
-            "gpu0",
-            "k0",
-            &k0,
-            &desc,
-            &|key| routes.get(key).cloned(),
-            &test_remote_nodes,
+        let contender_tag = NodeTombTag::new();
+        assert!(!publish_route_replica_tomb_fenced(
+            &route,
+            "owner".to_string().into(),
+            test_route_info_with_tag("owner", contender_tag),
         ));
+        assert!(
+            route
+                .nodes_replicas
+                .read()
+                .get("owner")
+                .is_some_and(|replica| replica.tomb_tag.same_generation(&old_tag))
+        );
 
-        let split_k1 = make_route((7, 1), Some("cpu1"));
-        let split_routes =
-            HashMap::from([("k0".to_string(), k0.clone()), ("k1".to_string(), split_k1)]);
-        assert!(!route_has_recoverable_replica_with(
-            "gpu0",
-            "k0",
-            &k0,
-            &desc,
-            &|key| split_routes.get(key).cloned(),
-            &test_remote_nodes,
+        old_tag.set_tomb();
+        let replacement_tag = NodeTombTag::new();
+        assert!(publish_route_replica_tomb_fenced(
+            &route,
+            "owner".to_string().into(),
+            test_route_info_with_tag("owner", replacement_tag.clone()),
         ));
+        assert!(
+            route
+                .nodes_replicas
+                .read()
+                .get("owner")
+                .is_some_and(|replica| replica.tomb_tag.same_generation(&replacement_tag))
+        );
 
-        let partial_k1 = make_route((7, 1), None);
-        let partial_routes = HashMap::from([
-            ("k0".to_string(), k0.clone()),
-            ("k1".to_string(), partial_k1),
-        ]);
-        assert!(!route_has_recoverable_replica_with(
-            "gpu0",
-            "k0",
-            &k0,
-            &desc,
-            &|key| partial_routes.get(key).cloned(),
-            &test_remote_nodes,
+        let departed_tag = NodeTombTag::new();
+        departed_tag.set_tomb();
+        assert!(!publish_route_replica_tomb_fenced(
+            &route,
+            "departed".to_string().into(),
+            test_route_info_with_tag("departed", departed_tag),
         ));
+        assert!(!route.nodes_replicas.read().contains_key("departed"));
+    }
+
+    #[test]
+    fn primary_publish_fence_restores_previous_route_on_tomb_generation() {
+        let routes = DashMap::new();
+        let previous = Arc::new(test_route((40, 0), None, vec![("peer", false)]));
+        routes.insert("key".to_string(), previous.clone());
+
+        let departed_tag = NodeTombTag::new();
+        departed_tag.set_tomb();
+        let rejected = Arc::new(OneKvNodesRoutes {
+            put_id: (41, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                "owner".to_string().into(),
+                test_route_info_with_tag("owner", departed_tag.clone()),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        assert!(
+            publish_primary_route_tomb_fenced(&routes, "key", rejected, &departed_tag).is_err()
+        );
+        assert!(
+            routes
+                .get("key")
+                .is_some_and(|route| Arc::ptr_eq(route.value(), &previous))
+        );
+
+        let live_tag = NodeTombTag::new();
+        let accepted = Arc::new(OneKvNodesRoutes {
+            put_id: (42, 0),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                "owner".to_string().into(),
+                test_route_info_with_tag("owner", live_tag.clone()),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        let replaced =
+            publish_primary_route_tomb_fenced(&routes, "key", accepted.clone(), &live_tag)
+                .expect("live generation must publish")
+                .expect("previous route must be returned");
+        assert!(Arc::ptr_eq(&replaced, &previous));
+        assert!(
+            routes
+                .get("key")
+                .is_some_and(|route| Arc::ptr_eq(route.value(), &accepted))
+        );
+    }
+
+    #[test]
+    fn reserved_capacity_counters_are_generation_and_arc_scoped() {
+        let old_tag = NodeTombTag::new();
+        let new_tag = NodeTombTag::new();
+        let old = Arc::new(NodeCacheReservedCapacity::new(old_tag.clone()));
+        let new = Arc::new(NodeCacheReservedCapacity::new(new_tag.clone()));
+
+        old.apply_delta(ReservedCapacityReason::LeaseBoundKv, 4096);
+        new.apply_delta(ReservedCapacityReason::LeaseBoundKv, 8192);
+        old_tag.set_tomb();
+        old.apply_delta(ReservedCapacityReason::LeaseBoundKv, -4096);
+
+        assert_eq!(old.total_reserved_bytes(), 0);
+        assert_eq!(new.total_reserved_bytes(), 8192);
+        assert!(!old.generation.same_generation(&new.generation));
+        assert!(!new_tag.is_tomb());
+    }
+
+    #[test]
+    fn delayed_member_left_is_not_forwarded_to_a_live_generation_actor() {
+        assert!(member_left_can_forward_to_registration_actor(None));
+        assert!(!member_left_can_forward_to_registration_actor(Some(17)));
     }
 
     #[test]
@@ -1462,7 +1961,7 @@ mod tests {
     }
 
     #[test]
-    fn recoverable_atomic_group_requires_complete_tp_cohort_on_one_cpu_owner() {
+    fn tp_cohort_expansion_preserves_every_atomic_member_across_ranks() {
         let rank0_group = Arc::new(PutAtomicGroup {
             members: vec![
                 msg_pack::PutAtomicGroupMember {
@@ -1475,37 +1974,8 @@ mod tests {
                 },
             ],
         });
-        let rank1_group = Arc::new(PutAtomicGroup {
-            members: vec![
-                msg_pack::PutAtomicGroupMember {
-                    key: "page0_model_1_2".to_string(),
-                    put_id: (11, 0),
-                },
-                msg_pack::PutAtomicGroupMember {
-                    key: "page1_model_1_2".to_string(),
-                    put_id: (11, 1),
-                },
-            ],
-        });
-        let make_route = |put_id, group: Arc<PutAtomicGroup>, remote_node: Option<&str>| {
-            let mut replicas = vec![("gpu0", false)];
-            if let Some(remote_node) = remote_node {
-                replicas.push((remote_node, false));
-            }
-            let mut route = test_route(put_id, None, replicas);
-            route.atomic_group = Some(group);
-            Arc::new(route)
-        };
-        let rank0_page0 = make_route((10, 0), rank0_group.clone(), Some("cpu0"));
-        let rank0_page1 = make_route((10, 1), rank0_group.clone(), Some("cpu0"));
-        let rank1_page0 = make_route((11, 0), rank1_group.clone(), Some("cpu0"));
-        let rank1_page1 = make_route((11, 1), rank1_group.clone(), Some("cpu0"));
-        let routes = HashMap::from([
-            ("page0_model_0_2".to_string(), rank0_page0.clone()),
-            ("page1_model_0_2".to_string(), rank0_page1),
-            ("page0_model_1_2".to_string(), rank1_page0),
-            ("page1_model_1_2".to_string(), rank1_page1),
-        ]);
+        let mut rank0_page0 = test_route((10, 0), None, vec![("gpu0", false)]);
+        rank0_page0.atomic_group = Some(rank0_group);
         let desc = NodeValueReplicaDesc {
             weight_bytes: 1024,
             put_id: (10, 0),
@@ -1519,95 +1989,16 @@ mod tests {
                 "page1_model_1_2",
             ]
         );
-        assert!(route_has_recoverable_replica_with(
-            "gpu0",
-            "page0_model_0_2",
-            &rank0_page0,
-            &desc,
-            &|key| routes.get(key).cloned(),
-            &test_remote_nodes,
-        ));
-
-        let missing_peer_routes = routes
-            .iter()
-            .filter(|(key, _)| key.as_str() != "page1_model_1_2")
-            .map(|(key, route)| (key.clone(), route.clone()))
-            .collect::<HashMap<_, _>>();
-        assert_eq!(
-            route_recoverable_replica_status_with(
-                "gpu0",
-                "page0_model_0_2",
-                &rank0_page0,
-                &desc,
-                &|key| missing_peer_routes.get(key).cloned(),
-                &test_remote_nodes,
-            ),
-            RecoverableReplicaStatus::TpCohortIncomplete
-        );
-
-        let rank1_page0_cpu1 = make_route((11, 0), rank1_group.clone(), Some("cpu1"));
-        let rank1_page1_cpu1 = make_route((11, 1), rank1_group, Some("cpu1"));
-        let split_cpu_routes = routes
-            .iter()
-            .map(|(key, route)| (key.clone(), route.clone()))
-            .chain([
-                ("page0_model_1_2".to_string(), rank1_page0_cpu1),
-                ("page1_model_1_2".to_string(), rank1_page1_cpu1),
-            ])
-            .collect::<HashMap<_, _>>();
-        assert!(!route_has_recoverable_replica_with(
-            "gpu0",
-            "page0_model_0_2",
-            &rank0_page0,
-            &desc,
-            &|key| split_cpu_routes.get(key).cloned(),
-            &test_remote_nodes,
-        ));
     }
 
     #[test]
-    fn recoverable_single_page_requires_all_tp_ranks() {
-        let rank0 = Arc::new(test_route(
-            (20, 0),
-            None,
-            vec![("gpu0", false), ("cpu0", false)],
-        ));
-        let rank1 = Arc::new(test_route(
-            (21, 0),
-            None,
-            vec![("gpu0", false), ("cpu0", false)],
-        ));
-        let desc = NodeValueReplicaDesc {
-            weight_bytes: 1024,
-            put_id: (20, 0),
-        };
-        let complete = HashMap::from([
-            ("page_model_0_2".to_string(), rank0.clone()),
-            ("page_model_1_2".to_string(), rank1),
-        ]);
-        assert!(route_has_recoverable_replica_with(
-            "gpu0",
-            "page_model_0_2",
-            &rank0,
-            &desc,
-            &|key| complete.get(key).cloned(),
-            &test_remote_nodes,
-        ));
-
-        let rank0_only = HashMap::from([("page_model_0_2".to_string(), rank0.clone())]);
-        assert!(!route_has_recoverable_replica_with(
-            "gpu0",
-            "page_model_0_2",
-            &rank0,
-            &desc,
-            &|key| rank0_only.get(key).cloned(),
-            &test_remote_nodes,
-        ));
-    }
-
-    #[test]
-    fn owner_hot_demotion_rejects_the_whole_cohort_before_moka_selection() {
-        let expected_entries = HashMap::from([
+    fn exact_cache_detach_rolls_back_identity_mismatch() {
+        let cache = moka::sync::SegmentedCache::builder(8)
+            .weigher(Box::new(|_key: &String, desc: &NodeValueReplicaDesc| {
+                desc.weight_bytes
+            }))
+            .build();
+        let actual = HashMap::from([
             (
                 "rank0".to_string(),
                 NodeValueReplicaDesc {
@@ -1623,77 +2014,48 @@ mod tests {
                 },
             ),
         ]);
-        let cache = moka::sync::SegmentedCache::builder(8)
-            .weigher(Box::new(|_key: &String, desc: &NodeValueReplicaDesc| {
-                desc.weight_bytes
-            }))
-            .build();
-        for (key, desc) in &expected_entries {
+        for (key, desc) in &actual {
             cache.insert(key.clone(), desc.clone());
         }
-        cache.run_pending_tasks();
+        let mut stale_expected = actual.clone();
+        stale_expected.get_mut("rank1").unwrap().put_id = (999, 0);
 
-        let selected_weight = recoverable_cohort_weight(&expected_entries, |key, _desc| {
-            if key == "rank0" {
-                RecoverableReplicaStatus::Recoverable
-            } else {
-                RecoverableReplicaStatus::TpCohortIncomplete
-            }
-        })
-        .map_or(0, |expected_weight| {
-            cache.evict_some_if(expected_weight, |candidate_key, candidate_desc| {
-                expected_entries.get(candidate_key).is_some_and(|expected| {
-                    expected.put_id == candidate_desc.put_id
-                        && expected.weight_bytes == candidate_desc.weight_bytes
-                })
-            })
-        });
-
-        assert_eq!(selected_weight, 0);
-        assert!(cache.get("rank0").is_some());
-        assert!(cache.get("rank1").is_some());
-    }
+        assert!(take_exact_cache_entries(&cache, &stale_expected).is_none());
+        assert_eq!(cache.get("rank0").unwrap().put_id, (30, 0));
+        assert_eq!(cache.get("rank1").unwrap().put_id, (31, 0));
 
-    #[test]
-    fn unrecoverable_fallback_is_only_for_last_level_or_no_remote_tier() {
-        assert!(allow_unrecoverable_cache_eviction(
-            false,
-            false,
-            UnrecoverableCacheEvictionContext::NormalCapacity,
-        ));
-        assert!(!allow_unrecoverable_cache_eviction(
-            false,
-            true,
-            UnrecoverableCacheEvictionContext::NormalCapacity,
-        ));
-        assert!(allow_unrecoverable_cache_eviction(
-            true,
-            true,
-            UnrecoverableCacheEvictionContext::NormalCapacity,
-        ));
-        assert!(allow_unrecoverable_cache_eviction(
-            false,
-            true,
-            UnrecoverableCacheEvictionContext::OwnerLocalReserveNoSpace,
-        ));
+        let removed = take_exact_cache_entries(&cache, &actual).unwrap();
+        assert_eq!(removed.len(), 2);
+        assert!(cache.get("rank0").is_none());
+        assert!(cache.get("rank1").is_none());
     }
 
     #[test]
-    fn unbounded_segmented_metadata_cache_only_evicts_when_requested() {
+    fn ring_b_cache_is_bounded_for_every_node_role() {
         let cache = moka::sync::SegmentedCache::builder(8)
+            .max_capacity(64)
             .weigher(Box::new(|_key: &u64, weight: &u32| *weight))
             .build();
-        assert_eq!(cache.policy().max_capacity(), None);
+        assert_eq!(cache.policy().max_capacity(), Some(64));
 
         for key in 0..128 {
             cache.insert(key, 8);
         }
         cache.run_pending_tasks();
-        assert_eq!(cache.weighted_size(), 1024);
+        assert!(cache.weighted_size() <= 64);
+    }
 
-        let evicted = cache.evict_some_if(64, |_key, _weight| true);
-        assert!(evicted >= 64);
-        assert_eq!(cache.weighted_size(), 1024 - evicted);
+    #[test]
+    fn ring_b_live_capacity_update_never_clears_boundary() {
+        let cache = moka::sync::SegmentedCache::builder(8)
+            .max_capacity(1024)
+            .weigher(Box::new(|_key: &u64, weight: &u32| *weight))
+            .build();
+        assert_eq!(cache.policy().max_capacity(), Some(1024));
+        cache.set_max_capacity(512).unwrap();
+        assert_eq!(cache.policy().max_capacity(), Some(512));
+        cache.set_max_capacity(2048).unwrap();
+        assert_eq!(cache.policy().max_capacity(), Some(2048));
     }
 
     #[test]
@@ -1711,6 +2073,139 @@ mod tests {
         assert_eq!(pending.load(Ordering::Acquire), 0);
     }
 
+    #[test]
+    fn cohort_reclaim_identity_registration_is_all_or_nothing() {
+        let request = |keys: &[&str]| reclaim::EvictionReclaimRequest {
+            owner_node_id: "cpu0".to_string(),
+            owner_node_start_time: None,
+            members: keys
+                .iter()
+                .enumerate()
+                .map(|(index, key)| reclaim::EvictionReclaimMember {
+                    key: (*key).to_string(),
+                    desc: NodeValueReplicaDesc {
+                        weight_bytes: 1024,
+                        put_id: (7, index as u32),
+                    },
+                    expected_backing: None,
+                })
+                .collect(),
+            origin: reclaim::EvictionReclaimOrigin::MasterAllocationCapacity,
+            retry_count: 0,
+        };
+        let inflight = DashSet::new();
+        let first = request(&["a", "b"]);
+        assert!(try_install_eviction_reclaim_identities(
+            &inflight,
+            first.identities(),
+        ));
+        assert_eq!(inflight.len(), 2);
+        assert_eq!(
+            classify_existing_eviction_reclaim(&inflight, &first.identities()),
+            reclaim::EnqueueEvictionReclaimResult::AlreadyInProgress
+        );
+
+        // `c` is tentatively installed before the collision on `a`; failure
+        // must roll it back and preserve only the original cohort.
+        let overlapping = reclaim::EvictionReclaimRequest {
+            members: vec![
+                reclaim::EvictionReclaimMember {
+                    key: "c".to_string(),
+                    desc: NodeValueReplicaDesc {
+                        weight_bytes: 1024,
+                        put_id: (7, 2),
+                    },
+                    expected_backing: None,
+                },
+                first.members[0].clone(),
+            ],
+            ..request(&[])
+        };
+        let tentative_identity = overlapping.identities()[0].clone();
+        assert!(!try_install_eviction_reclaim_identities(
+            &inflight,
+            overlapping.identities(),
+        ));
+        assert_eq!(inflight.len(), 2);
+        assert!(!inflight.contains(&tentative_identity));
+        assert_eq!(
+            classify_existing_eviction_reclaim(&inflight, &overlapping.identities()),
+            reclaim::EnqueueEvictionReclaimResult::PartialOverlap
+        );
+
+        for identity in first.identities() {
+            assert!(inflight.remove(&identity).is_some());
+        }
+        assert_eq!(
+            classify_existing_eviction_reclaim(&inflight, &first.identities()),
+            reclaim::EnqueueEvictionReclaimResult::NotInProgress
+        );
+    }
+
+    #[test]
+    fn eviction_reclaim_metadata_channel_does_not_drop_at_old_queue_limit() {
+        let (tx, mut rx) = ampsc::unbounded_channel();
+        let count = 4096 * 2 + 1;
+        for index in 0..count {
+            tx.send(reclaim::EvictionReclaimRequest {
+                owner_node_id: "cpu0".to_string(),
+                owner_node_start_time: None,
+                members: vec![reclaim::EvictionReclaimMember {
+                    key: format!("key-{index}"),
+                    desc: NodeValueReplicaDesc {
+                        weight_bytes: 4096,
+                        put_id: (7, index as u32),
+                    },
+                    expected_backing: None,
+                }],
+                origin: reclaim::EvictionReclaimOrigin::MasterAllocationCapacity,
+                retry_count: 0,
+            })
+            .unwrap();
+        }
+        assert_eq!((0..count).filter(|_| rx.try_recv().is_ok()).count(), count);
+    }
+
+    #[test]
+    fn closed_lossless_channel_rolls_back_identity_accounting_and_metadata() {
+        let cache = moka::sync::SegmentedCache::builder(8).build();
+        let request = reclaim::EvictionReclaimRequest {
+            owner_node_id: "cpu0".to_string(),
+            owner_node_start_time: None,
+            members: vec![reclaim::EvictionReclaimMember {
+                key: "closed-channel".to_string(),
+                desc: NodeValueReplicaDesc {
+                    weight_bytes: 4096,
+                    put_id: (7, 1),
+                },
+                expected_backing: None,
+            }],
+            origin: reclaim::EvictionReclaimOrigin::MasterAllocationCapacity,
+            retry_count: 0,
+        };
+        let inflight = DashSet::new();
+        assert!(try_install_eviction_reclaim_identities(
+            &inflight,
+            request.identities(),
+        ));
+        let pending = AtomicU64::new(request.weight_bytes());
+        let (tx, rx) = ampsc::unbounded_channel();
+        drop(rx);
+
+        let returned = tx.send(request).unwrap_err().0;
+        for identity in returned.identities() {
+            assert!(inflight.remove(&identity).is_some());
+        }
+        subtract_pending_eviction_weight(&pending, "cpu0", returned.weight_bytes());
+        for member in returned.members {
+            cache.insert(member.key, member.desc);
+        }
+
+        assert!(inflight.is_empty());
+        assert_eq!(pending.load(Ordering::Acquire), 0);
+        assert!(cache.get("closed-channel").is_some());
+    }
+
     fn new_test_member(metadata: HashMap<String, String>) -> ClusterMember {
         ClusterMember {
             id: "node-a".to_string(),
@@ -1795,7 +2290,11 @@ pub struct MasterKvRouterInner {
     pub inflight_puts: moka::future::Cache<(String, u64, u32), InflightPutInfo>,
     pub inflight_replica_tasks: moka::future::Cache<(String, u64, u32), InflightReplicaTaskInfo>,
     pub inflight_gets: moka::future::Cache<u64, InflightGetInfo>,
+    /// Idempotent terminal GetDone results retained across response loss/retry.
+    pub completed_gets: moka::future::Cache<u64, CompletedGetInfo>,
+    pub get_done_locks: AMapLock<u64>,
     pub(crate) key_activity: Arc<MasterKeyActivityTable>,
+    pub(crate) prepared_get_requesters: Arc<PreparedGetRequesterTable>,
 
     /// Cache for holding get operations (owned, flattened by (node_id, holder_id))
     pub get_holding: MasterOwnerMemMgr,
@@ -1821,11 +2320,6 @@ pub struct MasterKvRouterInner {
     /// Interns recent multi-key put groups so all member routes share one descriptor.
     put_atomic_groups: moka::sync::SegmentedCache<(String, u64, u32), Arc<PutAtomicGroup>>,
 
-    /// Serializes route-level existence checks with cache-eviction route cleanup.
-    /// This protects route metadata consistency only; it does not create MemHolders
-    /// or move payload data.
-    pub route_lifetime_lock: Mutex<()>,
-
     /// Grants reserved for owner-local hot-path staging.
     pub local_reserve_grants: DashMap<u64, LocalReserveGrantInfo>,
 
@@ -1839,8 +2333,9 @@ pub struct MasterKvRouterInner {
     pub node_kv_cache_controller:
         DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
 
-    /// Inclusive hot tier. L1 eviction starts a remote-only replica task while the owner copy
-    /// remains governed by `node_kv_cache_controller` at its unchanged resident capacity.
+    /// Independent pre-writeback tier. Its Size eviction starts a replica task
+    /// while owner residency remains governed by the owner's local hot cache;
+    /// `node_kv_cache_controller` tracks ring B only.
     pub node_writeback_tier1_controller:
         DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
 
@@ -1852,14 +2347,21 @@ pub struct MasterKvRouterInner {
     /// Moka weight already removed and queued for owner-side safe reclaim.
     pub eviction_reclaim_pending_weight: DashMap<NodeIDString, Arc<AtomicU64>>,
 
+    /// Exact, versioned metadata identities currently owned by the lossless
+    /// eviction-reclaim pipeline.  This bounds duplicate Size/cohort events;
+    /// payload memory is not retained here.
+    pub(crate) eviction_reclaim_inflight: DashSet<reclaim::EvictionReclaimIdentity>,
+
     /// Per-owner reclaim lifecycle counters. These distinguish transient holder/activity
     /// deferrals from terminal route changes and bounded retry restoration.
     pub(crate) eviction_reclaim_counters: DashMap<NodeIDString, Arc<EvictionReclaimCounters>>,
 
-    /// Serializes all append completions for one logical TP/atomic cohort. Without this lock,
-    /// several member completions can pass the recoverability precheck together and concurrently
-    /// select overlapping subsets from Moka.
-    owner_hot_demotion_locks: AMapLock<String>,
+    /// Async admission gate in front of Moka's synchronous housekeeper lock.
+    /// Bounded maintenance can still process a batch of Size evictions; without
+    /// this gate, concurrent async tasks can park multiple Tokio workers on the
+    /// same blocking Moka lock. It is a scheduling gate, not a correctness or
+    /// cohort lock, and no cache/global scan occurs under it.
+    pub(crate) owner_cache_operation_locks: AMapLock<String>,
 
     /// Historical final put placement decisions by target node.
     pub put_target_decision_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
@@ -1884,8 +2386,8 @@ pub struct MasterKvRouterInner {
     pub delete_broadcast: EnsureMemholderMgmtDeleteHandle<DeleteKeyInfo>,
     post_route_maintenance_tx: ampsc::Sender<route_maintenance::RoutePublishEvent>,
     post_route_maintenance_rx: Mutex<Option<ampsc::Receiver<route_maintenance::RoutePublishEvent>>>,
-    eviction_reclaim_tx: ampsc::Sender<reclaim::EvictionReclaimRequest>,
-    eviction_reclaim_rx: Mutex<Option<ampsc::Receiver<reclaim::EvictionReclaimRequest>>>,
+    eviction_reclaim_tx: ampsc::UnboundedSender<reclaim::EvictionReclaimRequest>,
+    eviction_reclaim_rx: Mutex<Option<ampsc::UnboundedReceiver<reclaim::EvictionReclaimRequest>>>,
     tier1_writeback_tx: ampsc::Sender<tiered_writeback::Tier1WritebackRequest>,
     tier1_writeback_rx: Mutex<Option<ampsc::Receiver<tiered_writeback::Tier1WritebackRequest>>>,
     tier1_writeback_dedupe: moka::sync::SegmentedCache<(String, u64, u32), ()>,
@@ -1978,6 +2480,7 @@ impl MasterKvRouter {
             INFLIGHT_PUT_TTL_SECONDS
         };
         let key_activity = Arc::new(MasterKeyActivityTable::default());
+        let prepared_get_requesters = Arc::new(PreparedGetRequesterTable::default());
         let inflight_puts = moka::future::Cache::builder()
             .time_to_live(Duration::from_secs(inflight_put_ttl_seconds))
             .eviction_listener(|_put_id, inflight_info: InflightPutInfo, cause| {
@@ -1999,6 +2502,9 @@ impl MasterKvRouter {
                 }
             })
             .build();
+        let completed_gets = moka::future::Cache::builder()
+            .time_to_live(Duration::from_secs(120))
+            .build();
         let inflight_replica_tasks = moka::future::Cache::builder()
             .time_to_live(Duration::from_secs(60))
             .eviction_listener(|_put_id, inflight_info: InflightReplicaTaskInfo, cause| {
@@ -2007,8 +2513,10 @@ impl MasterKvRouter {
                 }
             })
             .build();
-        let (eviction_reclaim_tx, eviction_reclaim_rx) =
-            ampsc::channel(EVICTION_RECLAIM_QUEUE_CAPACITY);
+        // A synchronous Moka listener must perform only constant-size metadata
+        // work and must never block or drop an Allocation reclaim event.  The
+        // versioned inflight set deduplicates this unbounded channel.
+        let (eviction_reclaim_tx, eviction_reclaim_rx) = ampsc::unbounded_channel();
         let (post_route_maintenance_tx, post_route_maintenance_rx) =
             ampsc::channel(POST_ROUTE_MAINTENANCE_QUEUE_CAPACITY);
         let (tier1_writeback_tx, tier1_writeback_rx) =
@@ -2023,7 +2531,10 @@ impl MasterKvRouter {
             inflight_puts,
             inflight_replica_tasks,
             inflight_gets,
+            completed_gets,
+            get_done_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             key_activity,
+            prepared_get_requesters,
             get_holding: MasterOwnerMemMgr::default(),
             next_get_id: AtomicU64::new(0),
             next_holder_id: AtomicU64::new(0),
@@ -2035,7 +2546,6 @@ impl MasterKvRouter {
                 .max_capacity(262_144)
                 .time_to_idle(Duration::from_secs(30 * 60))
                 .build(),
-            route_lifetime_lock: Mutex::new(()),
             local_reserve_grants: DashMap::new(),
             prepared_put_key_reservations: DashMap::new(),
             prefix_index: ARwLock::new(PrefixRadixTree::new()),
@@ -2043,8 +2553,9 @@ impl MasterKvRouter {
             node_writeback_tier1_controller: DashMap::new(),
             node_cache_reserved_capacity: DashMap::new(),
             eviction_reclaim_pending_weight: DashMap::new(),
+            eviction_reclaim_inflight: DashSet::new(),
             eviction_reclaim_counters: DashMap::new(),
-            owner_hot_demotion_locks: AMapLock::new(Duration::from_secs(10 * 60)),
+            owner_cache_operation_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             put_target_decision_counts: DashMap::new(),
             put_requester_target_decision_counts: DashMap::new(),
             put_placement_mode_counts: DashMap::new(),
@@ -2131,62 +2642,56 @@ impl MasterKvRouter {
             .inner()
             .node_cache_reserved_capacity
             .get(node_id)
+            .filter(|reserved| !reserved.generation.is_tomb())
             .map(|reserved| reserved.total_reserved_bytes())
             .unwrap_or(0);
         self.replica_cache_base_capacity(node_space_size)
             .saturating_sub(reserved_capacity)
     }
 
-    fn owner_cache_allows_unrecoverable_eviction_in_context(
-        &self,
-        owner_node_id: &str,
-        context: UnrecoverableCacheEvictionContext,
-    ) -> bool {
-        let remote_only_roles = &self.inner().replica_task_placement.remote_only_node_roles;
-        let owner = self
+    /// Refresh an already-created node controller after segment metadata or
+    /// reservation inputs change. The boundary is derived only from physical
+    /// node space and generation-scoped reservations, never placement roles.
+    fn reconcile_node_cache_capacity(&self, node_id: &str) {
+        let node_space_size = self
             .inner()
             .view()
-            .cluster_manager()
-            .get_member_info_cached(owner_node_id);
-        let owner_is_remote_only =
-            placement::member_matches_roles(owner.as_ref(), remote_only_roles);
-        let has_ready_remote_only_owner = self
+            .master_seg_manager()
+            .get_node_space_size(node_id);
+        if node_space_size == 0 {
+            return;
+        }
+        let capacity = self.replica_cache_effective_capacity(node_id, node_space_size);
+        if let Some(cache) = self
             .inner()
-            .view()
-            .cluster_manager()
-            .get_members()
-            .into_iter()
-            .any(|member| {
-                placement::member_matches_roles(Some(&member), remote_only_roles)
-                    && self
-                        .inner()
-                        .view()
-                        .master_seg_manager()
-                        .get_node_space_size(member.id.as_str())
-                        != 0
-            });
-        allow_unrecoverable_cache_eviction(
-            owner_is_remote_only,
-            has_ready_remote_only_owner,
-            context,
-        )
-    }
-
-    pub(crate) fn owner_cache_allows_unrecoverable_eviction(&self, owner_node_id: &str) -> bool {
-        self.owner_cache_allows_unrecoverable_eviction_in_context(
-            owner_node_id,
-            UnrecoverableCacheEvictionContext::NormalCapacity,
-        )
-    }
-
-    pub(crate) fn owner_cache_allows_unrecoverable_reserve_pressure_eviction(
-        &self,
-        owner_node_id: &str,
-    ) -> bool {
-        self.owner_cache_allows_unrecoverable_eviction_in_context(
-            owner_node_id,
-            UnrecoverableCacheEvictionContext::OwnerLocalReserveNoSpace,
-        )
+            .node_kv_cache_controller
+            .get(node_id)
+            .map(|entry| entry.value().clone())
+        {
+            if let Err(err) = cache.set_max_capacity(capacity) {
+                error!(
+                    "failed to refresh ring-B cache capacity: node={} capacity={} err={}",
+                    node_id, capacity, err,
+                );
+            }
+        }
+        if let Some(cache) = self
+            .inner()
+            .node_writeback_tier1_controller
+            .get(node_id)
+            .map(|entry| entry.value().clone())
+        {
+            let tier1_capacity = self
+                .writeback_tier1_base_capacity(node_space_size)
+                .unwrap_or(0)
+                .min(capacity);
+            if let Err(err) = cache.set_max_capacity(tier1_capacity) {
+                error!(
+                    "failed to refresh tier1 cache capacity: node={} capacity={} err={}",
+                    node_id, tier1_capacity, err,
+                );
+            }
+        }
     }
 
     fn writeback_tier1_base_capacity(&self, node_space_size: u64) -> Option<u64> {
@@ -2265,6 +2770,24 @@ impl MasterKvRouter {
             })
     }
 
+    pub(crate) fn reserve_prepared_get_requester(
+        &self,
+        key: &str,
+        requester: &NodeID,
+        get_id: u64,
+    ) -> Result<Arc<PreparedGetRequesterLease>, KvError> {
+        self.inner()
+            .prepared_get_requesters
+            .reserve(key, requester, get_id)
+            .ok_or_else(|| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::KeyBeingWritten {
+                        key: key.to_string(),
+                    },
+                )
+            })
+    }
+
     pub(crate) fn reserve_inflight_replica_key(
         &self,
         key: &str,
@@ -2376,40 +2899,151 @@ impl MasterKvRouter {
         owner_node_id: NodeIDString,
         key: String,
         desc: NodeValueReplicaDesc,
-    ) {
-        let weight_bytes = desc.weight_bytes;
-        let pending_weight = self
-            .inner()
-            .eviction_reclaim_pending_weight
-            .entry(owner_node_id.clone())
-            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
-            .value()
-            .clone();
-        pending_weight.fetch_add(u64::from(weight_bytes), Ordering::AcqRel);
+        origin: reclaim::EvictionReclaimOrigin,
+    ) -> bool {
+        self.enqueue_eviction_reclaim_cohort(
+            owner_node_id,
+            vec![reclaim::EvictionReclaimMember {
+                key,
+                desc,
+                expected_backing: None,
+            }],
+            origin,
+        )
+    }
+
+    fn enqueue_eviction_reclaim_cohort(
+        &self,
+        owner_node_id: NodeIDString,
+        members: Vec<reclaim::EvictionReclaimMember>,
+        origin: reclaim::EvictionReclaimOrigin,
+    ) -> bool {
+        matches!(
+            self.enqueue_eviction_reclaim_cohort_exact(owner_node_id, None, members, origin, true,),
+            reclaim::EnqueueEvictionReclaimResult::Accepted
+                | reclaim::EnqueueEvictionReclaimResult::AlreadyInProgress
+        )
+    }
+
+    pub(crate) fn enqueue_owner_capacity_eviction_cohort(
+        &self,
+        owner_node_id: NodeIDString,
+        owner_node_start_time: i64,
+        members: Vec<reclaim::EvictionReclaimMember>,
+        allow_new_request: bool,
+    ) -> reclaim::EnqueueEvictionReclaimResult {
+        self.enqueue_eviction_reclaim_cohort_exact(
+            owner_node_id,
+            Some(owner_node_start_time),
+            members,
+            reclaim::EvictionReclaimOrigin::OwnerCapacityEviction,
+            allow_new_request,
+        )
+    }
+
+    fn enqueue_eviction_reclaim_cohort_exact(
+        &self,
+        owner_node_id: NodeIDString,
+        owner_node_start_time: Option<i64>,
+        members: Vec<reclaim::EvictionReclaimMember>,
+        origin: reclaim::EvictionReclaimOrigin,
+        allow_new_request: bool,
+    ) -> reclaim::EnqueueEvictionReclaimResult {
+        if members.is_empty() {
+            return reclaim::EnqueueEvictionReclaimResult::PartialOverlap;
+        }
         let request = reclaim::EvictionReclaimRequest {
             owner_node_id,
-            key,
-            desc,
+            owner_node_start_time,
+            members,
+            origin,
             retry_count: 0,
         };
-        if let Err(err) = self.inner().eviction_reclaim_tx.try_send(request) {
-            let queue_error = err.to_string();
-            let request = err.into_inner();
-            subtract_pending_eviction_weight(
-                pending_weight.as_ref(),
-                request.owner_node_id.as_str(),
-                u64::from(weight_bytes),
-            );
-            let restored = self.restore_eviction_cache_entry_if_current(
-                request.owner_node_id.as_str(),
-                request.key,
-                request.desc,
+        if !allow_new_request {
+            let identities = request.identities();
+            return classify_existing_eviction_reclaim(
+                &self.inner().eviction_reclaim_inflight,
+                &identities,
             );
+        }
+        if !self.register_eviction_reclaim(&request) {
+            self.eviction_reclaim_counters(&request.owner_node_id)
+                .eviction_reclaim_deduplicated
+                .fetch_add(1, Ordering::Relaxed);
+            // An idempotent retry is accepted only when the complete cohort
+            // is already owned by the pipeline. A partial overlap is not a
+            // valid source handoff.
+            return if request
+                .identities()
+                .iter()
+                .all(|identity| self.inner().eviction_reclaim_inflight.contains(identity))
+            {
+                reclaim::EnqueueEvictionReclaimResult::AlreadyInProgress
+            } else {
+                reclaim::EnqueueEvictionReclaimResult::PartialOverlap
+            };
+        }
+        if let Err(err) = self.inner().eviction_reclaim_tx.send(request) {
+            let request = err.0;
+            self.complete_eviction_reclaim(&request);
+            if request.origin == reclaim::EvictionReclaimOrigin::MasterAllocationCapacity {
+                // This branch can run inside Moka's synchronous Size listener.
+                // Never re-enter that cache while its housekeeper lock is
+                // held; restore by key after yielding out of the callback.
+                let restore_view = self.inner().view().clone();
+                let restore_request = request.clone();
+                let spawn_view = restore_view.clone();
+                let _ = spawn_view.spawn("closed_eviction_reclaim_restore", async move {
+                    tokio::task::yield_now().await;
+                    let mut restored = 0usize;
+                    for member in &restore_request.members {
+                        if restore_view.master_kv_router().restore_eviction_cache_entry_if_current(
+                            &restore_request.owner_node_id,
+                            member.key.clone(),
+                            member.desc.clone(),
+                        ) {
+                            restored += 1;
+                        }
+                    }
+                    warn!(
+                        "restored master Allocation metadata after reclaim actor closed: owner={} members={} restored={}",
+                        restore_request.owner_node_id,
+                        restore_request.members.len(),
+                        restored,
+                    );
+                });
+            }
             warn!(
-                "safe eviction reclaim queue is full or closed: {}; restored={}",
-                queue_error, restored
+                "lossless eviction reclaim actor is closed: owner={} members={} origin={:?} restore_deferred={}",
+                request.owner_node_id,
+                request.members.len(),
+                request.origin,
+                request.origin == reclaim::EvictionReclaimOrigin::MasterAllocationCapacity,
             );
+            return reclaim::EnqueueEvictionReclaimResult::Closed;
         }
+        reclaim::EnqueueEvictionReclaimResult::Accepted
+    }
+
+    pub(crate) fn register_eviction_reclaim(
+        &self,
+        request: &reclaim::EvictionReclaimRequest,
+    ) -> bool {
+        if !try_install_eviction_reclaim_identities(
+            &self.inner().eviction_reclaim_inflight,
+            request.identities(),
+        ) {
+            return false;
+        }
+        let pending_weight = self
+            .inner()
+            .eviction_reclaim_pending_weight
+            .entry(request.owner_node_id.clone())
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .clone();
+        pending_weight.fetch_add(request.weight_bytes(), Ordering::AcqRel);
+        true
     }
 
     pub(crate) fn eviction_reclaim_pending_weight(&self, owner_node_id: &str) -> u64 {
@@ -2432,27 +3066,31 @@ impl MasterKvRouter {
             .clone()
     }
 
-    pub(crate) fn complete_eviction_reclaim_weight(
-        &self,
-        owner_node_id: &str,
-        completed_weight: u64,
-    ) {
-        if completed_weight == 0 {
-            return;
+    pub(crate) fn complete_eviction_reclaim(&self, request: &reclaim::EvictionReclaimRequest) {
+        for identity in request.identities() {
+            assert!(
+                self.inner()
+                    .eviction_reclaim_inflight
+                    .remove(&identity)
+                    .is_some(),
+                "eviction reclaim identity completed without registration: {:?}",
+                identity,
+            );
         }
+        let completed_weight = request.weight_bytes();
         let pending_weight = self
             .inner()
             .eviction_reclaim_pending_weight
-            .get(owner_node_id)
+            .get(&request.owner_node_id)
             .unwrap_or_else(|| {
                 panic!(
                     "eviction reclaim pending weight missing for owner {}",
-                    owner_node_id
+                    request.owner_node_id
                 )
             });
         subtract_pending_eviction_weight(
             pending_weight.value().as_ref(),
-            owner_node_id,
+            &request.owner_node_id,
             completed_weight,
         );
     }
@@ -2464,233 +3102,82 @@ impl MasterKvRouter {
         desc: NodeValueReplicaDesc,
     ) -> bool {
         if !self.eviction_cache_entry_is_current(owner_node_id, &key, &desc) {
-            return false;
-        }
-        self.insert_node_cache_entry(owner_node_id, key, desc)
-    }
-
-    pub(crate) fn eviction_cache_entry_is_current(
-        &self,
-        owner_node_id: &str,
-        key: &str,
-        desc: &NodeValueReplicaDesc,
-    ) -> bool {
-        self.inner().kv_routes.get(key).is_some_and(|route| {
-            route.put_id == desc.put_id
-                && route.lease_id.is_none()
-                && route
-                    .nodes_replicas
-                    .read()
-                    .iter()
-                    .any(|(node_id, replica)| {
-                        node_id.as_ref() == owner_node_id && !replica.tomb_tag.is_tomb()
-                    })
-        })
-    }
-
-    fn eviction_cache_entry_recoverable_status(
-        &self,
-        owner_node_id: &str,
-        key: &str,
-        desc: &NodeValueReplicaDesc,
-    ) -> RecoverableReplicaStatus {
-        let Some(route) = self.inner().kv_routes.get(key).map(|route| route.clone()) else {
-            return RecoverableReplicaStatus::RouteAbsent;
-        };
-        route_recoverable_replica_status(self.inner().view(), owner_node_id, key, &route, desc)
-    }
-
-    pub(crate) fn evict_recoverable_cache_weight(
-        &self,
-        owner_node_id: &str,
-        requested_weight: u64,
-    ) -> u64 {
-        self.evict_recoverable_cache_weight_excluding(
-            owner_node_id,
-            requested_weight,
-            &HashSet::new(),
-        )
-    }
-
-    pub(crate) fn evict_recoverable_cache_weight_excluding(
-        &self,
-        owner_node_id: &str,
-        requested_weight: u64,
-        excluded_keys: &HashSet<String>,
-    ) -> u64 {
-        if requested_weight == 0 {
-            return 0;
-        }
-        let Some(cache) = self.get_node_cache_controller(owner_node_id) else {
-            return 0;
-        };
-        let counters = self.eviction_reclaim_counters(owner_node_id);
-        counters
-            .recoverable_first_requested_bytes
-            .fetch_add(requested_weight, Ordering::Relaxed);
-        let selected_weight = cache.evict_some_if(requested_weight, |key, desc| {
-            if excluded_keys.contains(key) {
-                return false;
-            }
-            let status = self.eviction_cache_entry_recoverable_status(owner_node_id, key, desc);
-            counters.record_recoverable_first_status(status);
-            status == RecoverableReplicaStatus::Recoverable
-        });
-        counters
-            .recoverable_first_selected_bytes
-            .fetch_add(selected_weight, Ordering::Relaxed);
-        counters.recoverable_first_shortfall_bytes.fetch_add(
-            requested_weight.saturating_sub(selected_weight),
-            Ordering::Relaxed,
-        );
-        selected_weight
+            return false;
+        }
+        self.insert_node_cache_entry(owner_node_id, key, desc)
     }
 
-    pub(crate) async fn demote_owner_hot_cohort_if_recoverable(
+    pub(crate) fn eviction_cache_entry_is_current(
         &self,
         owner_node_id: &str,
         key: &str,
-        put_id: PutIDForAKey,
-    ) -> u64 {
-        let counters = self.eviction_reclaim_counters(owner_node_id);
-        counters
-            .owner_hot_demotion_attempts
-            .fetch_add(1, Ordering::Relaxed);
+        desc: &NodeValueReplicaDesc,
+    ) -> bool {
+        self.inner().kv_routes.get(key).is_some_and(|route| {
+            ring_b_route_replica_desc(&route, owner_node_id).is_some_and(|current| {
+                current.put_id == desc.put_id && current.weight_bytes == desc.weight_bytes
+            })
+        })
+    }
 
-        let Some(cache) = self.get_node_cache_controller(owner_node_id) else {
-            return 0;
-        };
-        cache.run_pending_tasks();
-        let Some(anchor_desc) = cache.get(key) else {
-            return 0;
-        };
-        if anchor_desc.put_id != put_id {
-            return 0;
-        }
-        let Some(anchor_route) = self.inner().kv_routes.get(key).map(|route| route.clone()) else {
-            return 0;
-        };
-        let Ok(cohort_keys) = current_tp_cohort_keys(key, &anchor_route, &anchor_desc) else {
-            return 0;
-        };
-        let Some(cohort_anchor) = cohort_keys.iter().min() else {
-            return 0;
-        };
-        let cohort_lock = self
+    /// Point-remove one exact ring-B metadata identity.  Callers use the
+    /// async per-node gate before entering Moka's synchronous housekeeper, so
+    /// route conversion never falls back to a cache scan.
+    pub(crate) async fn remove_node_cache_entry_exact(
+        &self,
+        owner_node_id: &str,
+        key: &str,
+        desc: &NodeValueReplicaDesc,
+    ) -> bool {
+        let owner_cache_lock = self
             .inner()
-            .owner_hot_demotion_locks
-            .get_lock(format!("{owner_node_id}\0{cohort_anchor}"));
-        let _cohort_guard = cohort_lock.lock().await;
-
-        // The route and Moka state may have changed while another member completion held the
-        // cohort lock. Recompute the complete cohort under the lock before selecting anything.
-        cache.run_pending_tasks();
-        let Some(anchor_desc) = cache.get(key) else {
-            return 0;
-        };
-        if anchor_desc.put_id != put_id {
-            return 0;
-        }
-        let Some(anchor_route) = self.inner().kv_routes.get(key).map(|route| route.clone()) else {
-            return 0;
-        };
-        let Ok(locked_cohort_keys) = current_tp_cohort_keys(key, &anchor_route, &anchor_desc)
-        else {
-            return 0;
-        };
-        if locked_cohort_keys != cohort_keys {
-            counters
-                .owner_hot_demotion_precheck_rejected
-                .fetch_add(1, Ordering::Relaxed);
-            return 0;
-        }
-
-        // Demotion is an all-or-nothing TP/atomic-cohort transition.  Do not
-        // silently shrink the cohort when one of its source entries has
-        // already disappeared from this owner's cache: doing so can recreate
-        // the mixed local/remote layout that made the prefix unrecoverable in
-        // E23.
-        let expected_cohort_len = locked_cohort_keys.len();
-        let expected_entries = locked_cohort_keys
-            .into_iter()
-            .map(|cohort_key| cache.get(&cohort_key).map(|desc| (cohort_key, desc)))
-            .collect::<Option<HashMap<_, _>>>();
-        let Some(expected_entries) = expected_entries else {
-            counters
-                .owner_hot_demotion_precheck_rejected
-                .fetch_add(1, Ordering::Relaxed);
-            return 0;
-        };
-        if expected_entries.len() != expected_cohort_len || expected_entries.is_empty() {
-            counters
-                .owner_hot_demotion_precheck_rejected
-                .fetch_add(1, Ordering::Relaxed);
-            return 0;
-        }
+            .owner_cache_operation_locks
+            .get_lock(owner_node_id.to_string());
+        let _owner_cache_guard = owner_cache_lock.lock().await;
+        self.inner()
+            .node_kv_cache_controller
+            .get(owner_node_id)
+            .is_some_and(|cache| remove_exact_cache_entry(cache.value(), key, desc))
+    }
 
-        // Validate the whole TP/atomic cohort before asking Moka to select anything.  Performing
-        // this check in the eviction predicate allowed one recoverable member to be selected even
-        // when a later member was not recoverable, which turned an intended exclusive transition
-        // into a partial source demotion.
-        let Some(expected_weight) =
-            recoverable_cohort_weight(&expected_entries, |candidate_key, candidate_desc| {
-                let status = self.eviction_cache_entry_recoverable_status(
-                    owner_node_id,
-                    candidate_key,
-                    candidate_desc,
-                );
-                counters.record_recoverable_first_status(status);
-                status
+    /// Remove one superseded route version from both metadata policies using
+    /// only the route's own replica list.  This is O(replica count), never a
+    /// Moka or global-route scan, and cannot delete a newer same-key version.
+    pub(crate) async fn remove_route_cache_entries_exact(
+        &self,
+        key: &str,
+        route: &OneKvNodesRoutes,
+    ) {
+        let replicas = route
+            .nodes_replicas
+            .read()
+            .iter()
+            .filter_map(|(node_id, replica)| {
+                (!replica.tomb_tag.is_tomb()).then(|| {
+                    (
+                        node_id.as_ref().to_string(),
+                        NodeValueReplicaDesc {
+                            weight_bytes: u32::try_from(replica.backing.capacity_bytes())
+                                .unwrap_or(u32::MAX),
+                            put_id: route.put_id,
+                        },
+                    )
+                })
             })
-        else {
-            counters
-                .owner_hot_demotion_precheck_rejected
-                .fetch_add(1, Ordering::Relaxed);
-            return 0;
-        };
-
-        let selected_weight =
-            cache.evict_some_if(expected_weight, |candidate_key, candidate_desc| {
-                expected_entries
-                    .get(candidate_key)
-                    .is_some_and(|expected_desc| {
-                        expected_desc.put_id == candidate_desc.put_id
-                            && expected_desc.weight_bytes == candidate_desc.weight_bytes
-                    })
-            });
-        if selected_weight != expected_weight {
-            counters
-                .owner_hot_demotion_partial_mismatch
-                .fetch_add(1, Ordering::Relaxed);
-            tracing::error!(
-                "owner hot TP-cohort demotion selected a partial cohort: owner={} key={} put_id=({},{}) cohort_entries={} expected_weight={} selected_weight={}",
-                owner_node_id,
-                key,
-                put_id.0,
-                put_id.1,
-                expected_entries.len(),
-                expected_weight,
-                selected_weight
-            );
-        }
-        if selected_weight == expected_weight {
-            counters
-                .owner_hot_demotion_cohorts
-                .fetch_add(1, Ordering::Relaxed);
-            counters
-                .owner_hot_demotion_selected_bytes
-                .fetch_add(selected_weight, Ordering::Relaxed);
-            tracing::debug!(
-                "owner hot complete TP-cohort demotion selected: owner={} key={} put_id=({},{}) cohort_entries={} selected_weight={}",
-                owner_node_id,
-                key,
-                put_id.0,
-                put_id.1,
-                expected_entries.len(),
-                selected_weight
-            );
+            .collect::<Vec<_>>();
+        for (node_id, desc) in replicas {
+            let owner_cache_lock = self
+                .inner()
+                .owner_cache_operation_locks
+                .get_lock(node_id.clone());
+            let _owner_cache_guard = owner_cache_lock.lock().await;
+            if let Some(cache) = self.inner().node_kv_cache_controller.get(&node_id) {
+                let _ = remove_exact_cache_entry(cache.value(), key, &desc);
+            }
+            if let Some(cache) = self.inner().node_writeback_tier1_controller.get(&node_id) {
+                let _ = remove_exact_cache_entry(cache.value(), key, &desc);
+            }
         }
-        selected_weight
     }
 
     pub(crate) fn insert_node_cache_entry(
@@ -2702,45 +3189,8 @@ impl MasterKvRouter {
         let Some(cache) = self.get_node_cache_controller(owner_node_id) else {
             return false;
         };
-        cache.run_pending_tasks();
-        let existing_weight = cache
-            .get(&key)
-            .map(|existing| u64::from(existing.weight_bytes))
-            .unwrap_or(0);
-        let projected_weight = cache
-            .weighted_size()
-            .saturating_sub(existing_weight)
-            .saturating_add(u64::from(desc.weight_bytes));
-        let node_space_size = self
-            .inner()
-            .view()
-            .master_seg_manager()
-            .get_node_space_size(owner_node_id);
-        let capacity = self.replica_cache_effective_capacity(owner_node_id, node_space_size);
-        let requested_weight = projected_weight.saturating_sub(capacity);
-        if requested_weight != 0 {
-            let recoverable_selected_weight =
-                self.evict_recoverable_cache_weight(owner_node_id, requested_weight);
-            let fallback_requested_weight =
-                requested_weight.saturating_sub(recoverable_selected_weight);
-            let fallback_selected_weight =
-                if self.owner_cache_allows_unrecoverable_eviction(owner_node_id) {
-                    cache.evict_some(fallback_requested_weight)
-                } else {
-                    0
-                };
-            tracing::debug!(
-                "recoverable-first cache admission: owner={} key={} requested_weight={} recoverable_selected_weight={} fallback_requested_weight={} fallback_selected_weight={} projected_weight={} capacity={}",
-                owner_node_id,
-                key,
-                requested_weight,
-                recoverable_selected_weight,
-                fallback_requested_weight,
-                fallback_selected_weight,
-                projected_weight,
-                capacity
-            );
-        }
+        // Restoration is an exact metadata repair after a failed reclaim
+        // dispatch. It must never search for or evict an unrelated victim.
         cache.insert(key, desc);
         true
     }
@@ -2792,8 +3242,9 @@ impl MasterKvRouter {
             let view = view.clone();
             let view2 = view.clone();
             let view_task = view2.clone();
+            let req_node_id = resp.node_id().clone();
             let _ = view.spawn("rpc_get_revoke", async move {
-                let ack = handle_get_revoke(view_task, msg).await;
+                let ack = handle_get_revoke(view_task, msg, req_node_id).await;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send GetRevokeResp: {:?}", e);
                 }
@@ -2806,9 +3257,10 @@ impl MasterKvRouter {
             let view = view.clone();
             let view2 = view.clone();
             let view_task = view2.clone();
+            let req_node_id = resp.node_id().clone();
             let _ = view.spawn("rpc_get_done", async move {
                 let t0 = Utc::now().timestamp_micros();
-                let mut ack = handle_get_done(view_task, msg).await;
+                let mut ack = handle_get_done(view_task, msg, req_node_id).await;
                 ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send GetDoneResp: {:?}", e);
@@ -3070,6 +3522,20 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<BatchEvictOwnerSourceReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let owner = resp.node_id().clone();
+            let view_task = view.clone();
+            let _ = view.spawn("rpc_batch_evict_owner_source", async move {
+                let ack = handle_batch_evict_owner_source(&view_task, msg, owner).await;
+                if let Err(err) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchEvictOwnerSourceResp: {:?}", err);
+                }
+            });
+            Ok(())
+        });
+
         let view = self.0.view().clone();
         RPCHandler::<PutAppendStartReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
@@ -3087,6 +3553,23 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPutAppendStartReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_batch_put_append_start", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_put_append_start(view_task, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPutAppendStartResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
         let view = self.0.view().clone();
         RPCHandler::<PutAppendRevokeReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
@@ -3117,6 +3600,22 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPutAppendDoneReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let view_task = view2.clone();
+            let _ = view.spawn("rpc_batch_put_append_done", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_put_append_done(view_task, msg).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPutAppendDoneResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
         // --- GetMeta Handler ---
         let view = self.0.view().clone();
         RPCHandler::<GetMetaReq>::new().regist(p2p, move |resp, msg| {
@@ -3247,8 +3746,9 @@ impl MasterKvRouter {
         RPCHandler::<BatchGetRevokeReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
             let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
             view.spawn("rpc_batch_get_revoke", async move {
-                let ack = handle_batch_get_revoke(view2, msg).await;
+                let ack = handle_batch_get_revoke(view2, msg, req_node_id).await;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send BatchGetRevokeResp: {:?}", e);
                 }
@@ -3260,9 +3760,10 @@ impl MasterKvRouter {
         RPCHandler::<BatchGetDoneReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
             let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
             view.spawn("rpc_batch_get_done", async move {
                 let t0 = Utc::now().timestamp_micros();
-                let mut ack = handle_batch_get_done(view2, msg).await;
+                let mut ack = handle_batch_get_done(view2, msg, req_node_id).await;
                 ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
                 if let Err(e) = resp.send_resp(ack).await {
                     error!("Failed to send BatchGetDoneResp: {:?}", e);
@@ -3272,6 +3773,65 @@ impl MasterKvRouter {
         });
     }
 
+    /// Start cleanup for one exact departed membership generation.
+    ///
+    /// Tomb publication and O(1) controller detachment happen synchronously in the cluster
+    /// listener. The potentially large route scan is then performed by a yielding async task.
+    fn begin_departed_generation_cleanup(
+        &self,
+        node_id: &str,
+        expected_node_start_time: Option<i64>,
+    ) -> bool {
+        let node: NodeID = node_id.to_string().into();
+        let Some(departed_tag) = self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .mark_node_tomb_generation(&node, expected_node_start_time)
+        else {
+            debug!(
+                "MemberLeft generation cleanup skipped because the registered generation changed or no segment was registered: node={} expected_node_start_time={:?}",
+                node_id, expected_node_start_time
+            );
+            return false;
+        };
+
+        // Detach generation-scoped controllers before starting the full route scan. A tombed
+        // segment reports zero usable space, so old-generation work cannot recreate the caches.
+        let resident_cache_detached = self
+            .inner()
+            .node_kv_cache_controller
+            .remove(node_id)
+            .is_some();
+        let tier1_cache_detached = self
+            .inner()
+            .node_writeback_tier1_controller
+            .remove(node_id)
+            .is_some();
+        self.inner()
+            .node_cache_reserved_capacity
+            .remove_if(node_id, |_, reserved| {
+                reserved.generation.same_generation(&departed_tag)
+            });
+
+        let removed_holdings = self.inner().get_holding.cleanup_node(node_id);
+        let view = self.inner().view().clone();
+        let node_id_owned = node_id.to_string();
+        let _ = view.clone().spawn("member_left_route_cleanup", async move {
+            cleanup_departed_generation_routes(view, node_id_owned, departed_tag).await;
+        });
+
+        info!(
+            "MemberLeft generation marked and controllers detached: node={} expected_node_start_time={:?} resident_cache_detached={} tier1_cache_detached={} removed_holdings={}",
+            node_id,
+            expected_node_start_time,
+            resident_cache_detached,
+            tier1_cache_detached,
+            removed_holdings
+        );
+        true
+    }
+
     fn spawn_node_segement_registration_caller(&self) -> ampsc::Sender<ClusterEvent> {
         const KEEP_ALIVE_TIME: Duration = Duration::from_secs(30);
         const NODE_EVENT_QUEUE_CAPACITY: usize = 64;
@@ -3338,8 +3898,8 @@ impl MasterKvRouter {
 	                let epoch = member.node_start_time;
 	                if let Some(prev) = *last_seen_epoch {
 	                    if prev != epoch {
-	                        view.master_seg_manager()
-	                            .mark_node_tomb(&node_id.clone().into());
+	                        view.master_kv_router()
+	                            .begin_departed_generation_cleanup(&node_id, Some(prev));
 	                    }
 	                }
 	                *last_seen_epoch = Some(epoch);
@@ -3397,10 +3957,9 @@ impl MasterKvRouter {
                                     inflight = None;
 
                                     debug!(
-                                        "MasterKvRouter received node leave event: {:?}, mark it as tomb",
+                                        "MasterKvRouter registration actor canceled departed node: {:?}",
                                         node_id
                                     );
-                                    view_task.master_seg_manager().mark_node_tomb(&node_id.into());
                                 }
                             }
                         }
@@ -3476,10 +4035,9 @@ impl MasterKvRouter {
                                     inflight = None;
 
                                     debug!(
-                                        "MasterKvRouter received node leave event: {:?}, mark it as tomb",
+                                        "MasterKvRouter registration actor canceled departed node: {:?}",
                                         node_id
                                     );
-                                    view_task.master_seg_manager().mark_node_tomb(&node_id.into());
                                 }
                             }
                         }
@@ -3504,6 +4062,11 @@ impl MasterKvRouter {
                                     registered_epoch = Some(epoch);
                                     desired_epoch = None;
                                     backoff = INITIAL_BACKOFF;
+                                    if let Some(node_id) = actor_node_id.as_deref() {
+                                        view_task
+                                            .master_kv_router()
+                                            .reconcile_node_cache_capacity(node_id);
+                                    }
                                     info!(
                                         "Successfully requested segment registration from client {}",
                                         actor_node_id.clone().unwrap_or_default()
@@ -3561,10 +4124,9 @@ impl MasterKvRouter {
                                     inflight = None;
 
                                     debug!(
-                                        "MasterKvRouter received node leave event: {:?}, mark it as tomb",
+                                        "MasterKvRouter registration actor canceled departed node: {:?}",
                                         node_id
                                     );
-                                    view_task.master_seg_manager().mark_node_tomb(&node_id.into());
                                 }
                             }
                         }
@@ -3630,17 +4192,66 @@ impl MasterKvRouter {
                 event: ClusterEvent,
             ) {
                 match &event {
+                    ClusterEvent::MemberJoined(member) | ClusterEvent::MemberUpdated(member) => {
+                        view.master_kv_router()
+                            .reconcile_node_cache_capacity(&member.id);
+                    }
                     ClusterEvent::MemberLeft(node_id) => {
-                        let removed = view
+                        let departed_epoch = view
+                            .cluster_manager()
+                            .get_prev_member_info(node_id)
+                            .map(|member| member.node_start_time);
+                        let current_member = view
+                            .cluster_manager()
+                            .get_member_info_cached(node_id);
+                        let current_epoch = current_member
+                            .as_ref()
+                            .map(|member| member.node_start_time);
+
+                        // MemberLeft has no epoch. Once a live generation is visible, this leave
+                        // is ambiguous and must neither clean state nor reach the per-node actor:
+                        // forwarding it would clear desired/registered_epoch for the reconnect.
+                        if !member_left_can_forward_to_registration_actor(current_epoch) {
+                            debug!(
+                                "ignoring delayed MemberLeft after reconnect: node={} current_node_start_time={}",
+                                node_id,
+                                current_epoch.unwrap_or_default()
+                            );
+                            return;
+                        }
+
+                        let registered_tag_before = view
+                            .master_seg_manager()
+                            .get_node_tomb_tag(&node_id.clone().into());
+                        if !view
                             .master_kv_router()
-                            .inner()
-                            .get_holding
-                            .cleanup_node(&node_id);
-                        if removed > 0 {
-                            info!("Cleaned up {} holdings for left member {}", removed, node_id);
+                            .begin_departed_generation_cleanup(node_id, departed_epoch)
+                        {
+                            // A registered segment exists but did not match `departed_epoch`:
+                            // preserve it and do not forward the old leave to the actor.
+                            if registered_tag_before.is_some() {
+                                debug!(
+                                    "ignoring generation-mismatched MemberLeft: node={} departed_epoch={:?}",
+                                    node_id, departed_epoch
+                                );
+                                return;
+                            }
+
+                            // External/zero-contribution members do not register a segment or
+                            // own route backing, but they can still own get holdings.
+                            let removed = view
+                                .master_kv_router()
+                                .inner()
+                                .get_holding
+                                .cleanup_node(node_id);
+                            if removed > 0 {
+                                info!(
+                                    "Cleaned up {} holdings for segmentless left member {}",
+                                    removed, node_id
+                                );
+                            }
                         }
                     }
-                    _ => {}
                 }
 
                 let node_id = event.node_id();
@@ -3787,6 +4398,7 @@ impl MasterKvRouter {
             GetAllocationMode::Temporary => "temporary",
             GetAllocationMode::ReuseReplica => "reuse_replica",
             GetAllocationMode::DurableReplica => "durable_replica",
+            GetAllocationMode::LocalCommittedSlot => "local_committed_slot",
         };
         let mode_count = self
             .inner()
@@ -3901,6 +4513,11 @@ impl MasterKvRouter {
         if node_space_size == 0 {
             return None;
         }
+        // Ring B is a backing/index domain, not a placement-role domain.  A
+        // GPU owner can also hold master-only Allocation replicas, so every
+        // live segment gets the same bounded controller.  Non-ring-B bytes
+        // are subtracted through generation-scoped reservation tokens.
+        let allocation_capacity = self.replica_cache_effective_capacity(node_id, node_space_size);
         let view = self.inner().view().clone();
         let node_id_owned = node_id.to_string();
         Some(
@@ -3910,46 +4527,32 @@ impl MasterKvRouter {
                 .or_insert_with(move || {
                     let view = view.clone();
                     let cache_node_id = node_id_owned.clone();
-                    Arc::new(
-                        moka::sync::SegmentedCache::builder(8)
-                            // The resident cache is a metadata/LRU controller. Its aggregate
-                            // effective capacity is enforced explicitly with `evict_some_if`.
-                            // Leaving the Moka segments unbounded prevents per-segment hash skew
-                            // from performing an independent Size eviction outside that policy.
-                            // Use the actual allocated/rounded size as weight to
-                            // make eviction reflect real memory usage.
-                            .weigher(Box::new(|_key: &String, value: &NodeValueReplicaDesc| {
-                                value.weight_bytes
-                            }))
-                            .eviction_listener(Box::new(
-                                move |key: Arc<String>,
-                                      _value: NodeValueReplicaDesc,
-                                      cause: RemovalCause| {
-                                    debug!("Evicted key: {:?}, caused by: {:?}", key, cause);
-                                    match cause {
-                                        // timeout or size exceed
-                                        RemovalCause::Size | RemovalCause::Expired => {
-                                            let k = (*key).clone();
-                                            let evicted_put_id = _value.put_id;
-                                            tracing::debug!(
-                                                "Eviction-triggered local replica cleanup for key {} on node {} put_id=({},{})",
-                                                k,
-                                                cache_node_id,
-                                                evicted_put_id.0,
-                                                evicted_put_id.1
-                                            );
-                                            view.master_kv_router().enqueue_eviction_reclaim(
-                                                cache_node_id.clone(),
-                                                k,
-                                                _value,
-                                            );
-                                        }
-                                        _ => {}
-                                    }
-                                },
-                            ))
-                            .build(),
-                    )
+                    let builder = moka::sync::SegmentedCache::builder(8)
+                        // Admission is restricted to unindexed Allocation
+                        // routes. CommittedSlot and owner-indexed Allocation
+                        // entries belong to ring A and never enter this cache.
+                        .weigher(Box::new(|_key: &String, value: &NodeValueReplicaDesc| {
+                            value.weight_bytes
+                        }))
+                        .eviction_listener(Box::new(
+                            move |key: Arc<String>,
+                                  _value: NodeValueReplicaDesc,
+                                  cause: RemovalCause| {
+                                if cause == RemovalCause::Size {
+                                    // Listener work is deliberately O(1):
+                                    // clone fixed metadata, dedupe, and send
+                                    // to a lossless channel.  Route/cohort
+                                    // lookup belongs to the async actor.
+                                    let _ = view.master_kv_router().enqueue_eviction_reclaim(
+                                        cache_node_id.clone(),
+                                        (*key).clone(),
+                                        _value,
+                                        reclaim::EvictionReclaimOrigin::MasterAllocationCapacity,
+                                    );
+                                }
+                            },
+                        ));
+                    Arc::new(builder.max_capacity(allocation_capacity).build())
                 })
                 .value()
                 .clone(),
@@ -4034,17 +4637,6 @@ impl MasterKvRouter {
         )
     }
 
-    pub fn remove_node_writeback_tier1_entry(&self, node_id: &str, key: &str) {
-        if let Some(cache) = self
-            .inner()
-            .node_writeback_tier1_controller
-            .get(node_id)
-            .map(|entry| entry.value().clone())
-        {
-            let _ = cache.remove(key);
-        }
-    }
-
     pub(crate) fn tier1_writeback_entry_is_current(
         &self,
         source_node_id: &str,
@@ -4160,28 +4752,67 @@ impl MasterKvRouter {
         ));
     }
 
-    /// Atomically adjust a node's moka usable-capacity reservation by `delta_bytes`.
-    /// Positive delta reserves capacity (fetch_sub from usable capacity),
-    /// negative delta releases reservation (fetch_add back to usable capacity).
-    pub fn adjust_node_cache_reserved_capacity(
+    /// Adjust one exact generation/counter identity and refresh its live cache
+    /// boundary.  Negative releases always stay applied to the captured Arc,
+    /// even when the node has already left and its controller was detached.
+    fn adjust_node_cache_reserved_capacity_identity(
         &self,
         node_id: &str,
+        generation: &NodeTombTag,
+        reserved_capacity: &Arc<NodeCacheReservedCapacity>,
         reason: ReservedCapacityReason,
         delta_bytes: i64,
     ) -> crate::rpcresp_kvresult_convert::msg_and_error::KvResult<()> {
         if !self.replica_cache_enabled() {
             return Ok(());
         }
-        let reserved_capacity = self
-            .inner()
-            .node_cache_reserved_capacity
-            .entry(node_id.to_string())
-            .or_insert_with(|| Arc::new(NodeCacheReservedCapacity::default()))
-            .value()
-            .clone();
+        if !reserved_capacity.generation.same_generation(generation) {
+            return Err(
+                crate::rpcresp_kvresult_convert::msg_and_error::KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "cache reservation generation/counter identity mismatch: node_id={}",
+                            node_id
+                        ),
+                    },
+                ),
+            );
+        }
 
         reserved_capacity.apply_delta(reason, delta_bytes);
 
+        let current_identity = self
+            .inner()
+            .node_cache_reserved_capacity
+            .get(node_id)
+            .is_some_and(|current| {
+                Arc::ptr_eq(current.value(), reserved_capacity)
+                    && current.generation.same_generation(generation)
+            })
+            && node_generation_is_current_live(
+                self.inner().view(),
+                &node_id.to_string().into(),
+                generation,
+            );
+        if !current_identity {
+            if delta_bytes >= 0 {
+                reserved_capacity.apply_delta(reason, -delta_bytes);
+                return Err(
+                    crate::rpcresp_kvresult_convert::msg_and_error::KvError::Api(
+                        crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidPutMasterState {
+                            detail: format!(
+                                "cache reservation target generation changed: node_id={}",
+                                node_id
+                            ),
+                        },
+                    ),
+                );
+            }
+            // The old generation has been detached.  Its exact counter Arc is
+            // now balanced, and no live controller must be modified.
+            return Ok(());
+        }
+
         // Recompute target capacity from the configured base ratio minus live reservations.
         let reserved_total = reserved_capacity.total_reserved_bytes();
         let node_space_size = self
@@ -4190,9 +4821,9 @@ impl MasterKvRouter {
             .master_seg_manager()
             .get_node_space_size(node_id);
         if node_space_size == 0 {
-            // Node not ready: this should not happen in a successful put_done path.
-            // Revert the counter delta before returning error.
-            reserved_capacity.apply_delta(reason, -delta_bytes);
+            if delta_bytes >= 0 {
+                reserved_capacity.apply_delta(reason, -delta_bytes);
+            }
             return Err(
                 crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
                     crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::OwnerNoSeg {
@@ -4219,7 +4850,9 @@ impl MasterKvRouter {
                     .unwrap_or(0)
                     .min(new_capacity);
                 if let Err(e) = tier1_cache.set_max_capacity(tier1_capacity) {
-                    reserved_capacity.apply_delta(reason, -delta_bytes);
+                    if delta_bytes >= 0 {
+                        reserved_capacity.apply_delta(reason, -delta_bytes);
+                    }
                     return Err(
                         crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
                             crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
@@ -4232,33 +4865,26 @@ impl MasterKvRouter {
                     );
                 }
             }
-            cache.run_pending_tasks();
-            let requested_weight = cache.weighted_size().saturating_sub(new_capacity);
-            let recoverable_selected_weight =
-                self.evict_recoverable_cache_weight(node_id, requested_weight);
-            let fallback_requested_weight =
-                requested_weight.saturating_sub(recoverable_selected_weight);
-            let fallback_selected_weight =
-                if self.owner_cache_allows_unrecoverable_eviction(node_id) {
-                    cache.evict_some(fallback_requested_weight)
-                } else {
-                    0
-                };
-            if requested_weight != 0 {
-                tracing::debug!(
-                    "resident cache effective-capacity adjustment: owner={} effective_capacity={} requested_weight={} recoverable_selected_weight={} fallback_requested_weight={} fallback_selected_weight={}",
-                    node_id,
-                    new_capacity,
-                    requested_weight,
-                    recoverable_selected_weight,
-                    fallback_requested_weight,
-                    fallback_selected_weight
+            if let Err(e) = cache.set_max_capacity(new_capacity) {
+                if delta_bytes >= 0 {
+                    reserved_capacity.apply_delta(reason, -delta_bytes);
+                }
+                return Err(
+                    crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
+                        crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
+                            rpc_input_json: format!(
+                                "ring-B allocation moka.set_max_capacity failed: node_id={}, new_capacity={}, err={}",
+                                node_id, new_capacity, e
+                            ),
+                        },
+                    ),
                 );
             }
             Ok(())
         } else {
-            // Revert counter and return error.
-            reserved_capacity.apply_delta(reason, -delta_bytes);
+            if delta_bytes >= 0 {
+                reserved_capacity.apply_delta(reason, -delta_bytes);
+            }
             Err(
                 crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
                     crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::OwnerNoSeg {
@@ -4269,6 +4895,83 @@ impl MasterKvRouter {
         }
     }
 
+    /// Reserve cache capacity for one exact live node generation.  The returned
+    /// route-lifetime token releases the same counter identity on Drop.
+    pub fn reserve_node_cache_capacity(
+        &self,
+        node_id: &NodeID,
+        generation: &NodeTombTag,
+        reason: ReservedCapacityReason,
+        bytes: u64,
+    ) -> crate::rpcresp_kvresult_convert::msg_and_error::KvResult<
+        Option<Arc<NodeCacheCapacityReservation>>,
+    > {
+        if !self.replica_cache_enabled() {
+            return Ok(None);
+        }
+        if !node_generation_is_current_live(self.inner().view(), node_id, generation) {
+            return Err(
+                crate::rpcresp_kvresult_convert::msg_and_error::KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "cannot reserve cache capacity for departed generation: node_id={}",
+                            node_id
+                        ),
+                    },
+                ),
+            );
+        }
+
+        let reserved_capacity = match self
+            .inner()
+            .node_cache_reserved_capacity
+            .entry(node_id.to_string())
+        {
+            dashmap::mapref::entry::Entry::Occupied(mut entry) => {
+                if entry.get().generation.same_generation(generation) {
+                    entry.get().clone()
+                } else if entry.get().generation.is_tomb() {
+                    let replacement = Arc::new(NodeCacheReservedCapacity::new(generation.clone()));
+                    entry.insert(replacement.clone());
+                    replacement
+                } else {
+                    return Err(
+                        crate::rpcresp_kvresult_convert::msg_and_error::KvError::Api(
+                            crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidPutMasterState {
+                                detail: format!(
+                                    "live cache reservation counter belongs to another generation: node_id={}",
+                                    node_id
+                                ),
+                            },
+                        ),
+                    );
+                }
+            }
+            dashmap::mapref::entry::Entry::Vacant(entry) => {
+                let counter = Arc::new(NodeCacheReservedCapacity::new(generation.clone()));
+                entry.insert(counter.clone());
+                counter
+            }
+        };
+
+        self.adjust_node_cache_reserved_capacity_identity(
+            node_id.as_ref(),
+            generation,
+            &reserved_capacity,
+            reason,
+            bytes as i64,
+        )?;
+        Ok(Some(Arc::new(NodeCacheCapacityReservation {
+            view: self.inner().view().clone(),
+            node_id: node_id.to_string(),
+            generation: generation.clone(),
+            reserved_capacity,
+            reason,
+            bytes,
+            released: AtomicBool::new(false),
+        })))
+    }
+
     pub fn next_local_reserve_grant_id(&self) -> u64 {
         self.inner()
             .next_local_reserve_grant_id
@@ -4350,10 +5053,15 @@ impl MasterKvRouter {
                 .inner()
                 .node_cache_reserved_capacity
                 .get(owner_node.as_str())
+                .filter(|reserved| !reserved.generation.is_tomb())
                 .map(|reserved| reserved.total_reserved_bytes())
                 .unwrap_or(0);
-            let effective_capacity_bytes =
-                self.replica_cache_effective_capacity(owner_node.as_str(), node_space_size);
+            // Every live node's ring-B controller is bounded, independent of
+            // its placement role.
+            let effective_capacity_bytes = cache
+                .policy()
+                .max_capacity()
+                .expect("ring-B controller must always be bounded");
             let pending_eviction_reclaim_bytes =
                 self.eviction_reclaim_pending_weight(owner_node.as_str());
             let reclaim_counters = self.eviction_reclaim_counters(owner_node.as_str());
@@ -4397,9 +5105,6 @@ impl MasterKvRouter {
                 reclaim_master_activity_deferred: reclaim_counters
                     .master_activity_deferred
                     .load(Ordering::Relaxed),
-                reclaim_master_get_holder_observed: reclaim_counters
-                    .master_get_holder_observed
-                    .load(Ordering::Relaxed),
                 reclaim_owner_holder_deferred: reclaim_counters
                     .owner_holder_deferred
                     .load(Ordering::Relaxed),
@@ -4411,50 +5116,39 @@ impl MasterKvRouter {
                 reclaim_retry_completed: reclaim_counters.retry_completed.load(Ordering::Relaxed),
                 reclaim_retry_restored: reclaim_counters.retry_restored.load(Ordering::Relaxed),
                 reclaim_completed: reclaim_counters.completed.load(Ordering::Relaxed),
-                owner_hot_demotion_attempts: reclaim_counters
-                    .owner_hot_demotion_attempts
-                    .load(Ordering::Relaxed),
-                owner_hot_demotion_cohorts: reclaim_counters
-                    .owner_hot_demotion_cohorts
-                    .load(Ordering::Relaxed),
-                owner_hot_demotion_selected_bytes: reclaim_counters
-                    .owner_hot_demotion_selected_bytes
-                    .load(Ordering::Relaxed),
-                owner_hot_demotion_precheck_rejected: reclaim_counters
-                    .owner_hot_demotion_precheck_rejected
-                    .load(Ordering::Relaxed),
-                owner_hot_demotion_partial_mismatch: reclaim_counters
-                    .owner_hot_demotion_partial_mismatch
+                source_evict_rpc_requests: reclaim_counters
+                    .source_evict_rpc_requests
                     .load(Ordering::Relaxed),
-                recoverable_first_requested_bytes: reclaim_counters
-                    .recoverable_first_requested_bytes
+                source_evict_cohorts: reclaim_counters
+                    .source_evict_cohorts
                     .load(Ordering::Relaxed),
-                recoverable_first_selected_bytes: reclaim_counters
-                    .recoverable_first_selected_bytes
+                source_evict_requested_bytes: reclaim_counters
+                    .source_evict_requested_bytes
                     .load(Ordering::Relaxed),
-                recoverable_first_shortfall_bytes: reclaim_counters
-                    .recoverable_first_shortfall_bytes
+                source_evict_accepted: reclaim_counters
+                    .source_evict_accepted
                     .load(Ordering::Relaxed),
-                recoverable_first_eligible_checks: reclaim_counters
-                    .recoverable_first_eligible_checks
+                source_evict_in_progress: reclaim_counters
+                    .source_evict_in_progress
                     .load(Ordering::Relaxed),
-                recoverable_first_route_absent_checks: reclaim_counters
-                    .recoverable_first_route_absent_checks
+                source_evict_completed: reclaim_counters
+                    .source_evict_completed
                     .load(Ordering::Relaxed),
-                recoverable_first_version_changed_checks: reclaim_counters
-                    .recoverable_first_version_changed_checks
+                source_evict_retryable_busy: reclaim_counters
+                    .source_evict_retryable_busy
                     .load(Ordering::Relaxed),
-                recoverable_first_route_ineligible_checks: reclaim_counters
-                    .recoverable_first_route_ineligible_checks
+                source_evict_stale: reclaim_counters.source_evict_stale.load(Ordering::Relaxed),
+                source_evict_rejected: reclaim_counters
+                    .source_evict_rejected
                     .load(Ordering::Relaxed),
-                recoverable_first_cpu_route_absent_checks: reclaim_counters
-                    .recoverable_first_cpu_route_absent_checks
+                capacity_eviction_non_ring_b_entry_total: reclaim_counters
+                    .capacity_eviction_non_ring_b_entry_total
                     .load(Ordering::Relaxed),
-                recoverable_first_atomic_group_incomplete_checks: reclaim_counters
-                    .recoverable_first_atomic_group_incomplete_checks
+                capacity_eviction_hit_committed_slot: reclaim_counters
+                    .capacity_eviction_hit_committed_slot
                     .load(Ordering::Relaxed),
-                recoverable_first_tp_cohort_incomplete_checks: reclaim_counters
-                    .recoverable_first_tp_cohort_incomplete_checks
+                eviction_reclaim_deduplicated: reclaim_counters
+                    .eviction_reclaim_deduplicated
                     .load(Ordering::Relaxed),
             });
         }
@@ -4493,7 +5187,7 @@ impl MasterKvRouter {
                         );
                         for node in snapshot.replica_cache_nodes {
                             tracing::info!(
-                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_master_get_holder_observed={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} owner_hot_demotion_attempts={} owner_hot_demotion_cohorts={} owner_hot_demotion_selected_bytes={} owner_hot_demotion_precheck_rejected={} owner_hot_demotion_partial_mismatch={} recoverable_first_requested_bytes={} recoverable_first_selected_bytes={} recoverable_first_shortfall_bytes={} recoverable_first_eligible_checks={} recoverable_first_route_absent_checks={} recoverable_first_version_changed_checks={} recoverable_first_route_ineligible_checks={} recoverable_first_cpu_route_absent_checks={} recoverable_first_atomic_group_incomplete_checks={} recoverable_first_tp_cohort_incomplete_checks={}",
+                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_cohorts={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
                                 node.owner_node,
                                 node.entries,
                                 node.weighted_bytes,
@@ -4508,7 +5202,6 @@ impl MasterKvRouter {
                                 node.writeback_tier1_owner_accepted,
                                 node.writeback_tier1_failed,
                                 node.reclaim_master_activity_deferred,
-                                node.reclaim_master_get_holder_observed,
                                 node.reclaim_owner_holder_deferred,
                                 node.reclaim_owner_other_deferred,
                                 node.reclaim_route_changed,
@@ -4516,21 +5209,18 @@ impl MasterKvRouter {
                                 node.reclaim_retry_completed,
                                 node.reclaim_retry_restored,
                                 node.reclaim_completed,
-                                node.owner_hot_demotion_attempts,
-                                node.owner_hot_demotion_cohorts,
-                                node.owner_hot_demotion_selected_bytes,
-                                node.owner_hot_demotion_precheck_rejected,
-                                node.owner_hot_demotion_partial_mismatch,
-                                node.recoverable_first_requested_bytes,
-                                node.recoverable_first_selected_bytes,
-                                node.recoverable_first_shortfall_bytes,
-                                node.recoverable_first_eligible_checks,
-                                node.recoverable_first_route_absent_checks,
-                                node.recoverable_first_version_changed_checks,
-                                node.recoverable_first_route_ineligible_checks,
-                                node.recoverable_first_cpu_route_absent_checks,
-                                node.recoverable_first_atomic_group_incomplete_checks,
-                                node.recoverable_first_tp_cohort_incomplete_checks
+                                node.source_evict_rpc_requests,
+                                node.source_evict_cohorts,
+                                node.source_evict_requested_bytes,
+                                node.source_evict_accepted,
+                                node.source_evict_in_progress,
+                                node.source_evict_completed,
+                                node.source_evict_retryable_busy,
+                                node.source_evict_stale,
+                                node.source_evict_rejected,
+                                node.capacity_eviction_non_ring_b_entry_total,
+                                node.capacity_eviction_hit_committed_slot,
+                                node.eviction_reclaim_deduplicated,
                             );
                             metrics.set_kv_replica_cache_entries(
                                 node.owner_node.as_str(),
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index 9f7717b..048732e 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -17,11 +17,22 @@ pub enum GetAllocationMode {
     Temporary = 0,
     ReuseReplica = 1,
     DurableReplica = 2,
+    LocalCommittedSlot = 3,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct GetPreparedLocalReserveTarget {
+    pub grant_id: u64,
+    pub slot_index: u32,
+    pub slot_size: u64,
+    pub addr: u64,
+    pub base_addr: u64,
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct GetStartReq {
     pub key: String,
+    pub prepared_target: Option<GetPreparedLocalReserveTarget>,
 }
 impl MsgPackSerializePart for GetStartReq {
     fn msg_id(&self) -> u32 {
@@ -40,6 +51,9 @@ pub struct GetStartResp {
     pub target_base_addr: u64,
     pub src_base_addr: u64,
     pub len: u64,
+    /// Echoes the owner-local slot accepted as this Get's target.
+    pub prepared_target: Option<GetPreparedLocalReserveTarget>,
+    pub atomic_group: Option<PutAtomicGroup>,
     pub error_code: ErrorCode,
     pub error_json: String,
     /// Server-side processing time in microseconds for this RPC handler
@@ -107,6 +121,9 @@ impl RPCReq for GetDoneReq {
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct BatchGetStartReq {
     pub keys: Vec<String>,
+    /// Empty selects ordinary master allocations. Otherwise this must contain
+    /// exactly one entry per key.
+    pub prepared_targets: Vec<Option<GetPreparedLocalReserveTarget>>,
 }
 impl MsgPackSerializePart for BatchGetStartReq {
     fn msg_id(&self) -> u32 {
@@ -124,6 +141,8 @@ pub struct BatchGetStartItemResp {
     pub target_base_addr: u64,
     pub src_base_addr: u64,
     pub len: u64,
+    pub prepared_target: Option<GetPreparedLocalReserveTarget>,
+    pub atomic_group: Option<PutAtomicGroup>,
     pub error_code: ErrorCode,
     pub error_json: String,
 }
@@ -265,15 +284,7 @@ impl RPCReq for GetMasterOnlyMetricPartReq {
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
-pub struct ReserveLocalGrantReq {
-    /// Slot class that needs capacity. Zero means a raw grant request with no reclaim fallback.
-    pub slot_size: u64,
-    /// Number of slots the owner is currently short of in this class.
-    pub required_free_slots: u32,
-    /// Reclaim committed slots before growing the physical grant pool. This keeps owner-local
-    /// free-slot headroom without changing the owner's advertised capacity.
-    pub reclaim_before_grow: bool,
-}
+pub struct ReserveLocalGrantReq {}
 impl MsgPackSerializePart for ReserveLocalGrantReq {
     fn msg_id(&self) -> u32 {
         MsgId::ReserveLocalGrantReq as u32
@@ -292,10 +303,6 @@ pub enum ReserveLocalGrantOutcome {
         base_addr: u64,
         len: u64,
     },
-    Reclaimed {
-        slot_size: u64,
-        reclaimed_slots: u32,
-    },
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -334,7 +341,7 @@ pub enum OwnerReclaimItemState {
     Stale,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+#[derive(Default, Debug, Clone, Hash, PartialEq, Eq, Encode, Decode)]
 pub enum OwnerReclaimBacking {
     #[default]
     Allocation,
@@ -351,8 +358,73 @@ pub enum OwnerReclaimBacking {
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
 pub enum OwnerReclaimReason {
     #[default]
-    Reserve,
-    CapacityEviction,
+    OwnerCapacityEviction,
+    MasterAllocationCapacity,
+}
+
+/// One exact owner-local source selected for capacity eviction.
+#[derive(Default, Debug, Clone, Hash, PartialEq, Eq, Encode, Decode)]
+pub struct OwnerSourceEvictionMember {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub backing: OwnerReclaimBacking,
+}
+
+/// Atomic/TP members which must enter the reclaim pipeline together.
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct OwnerSourceEvictionCohort {
+    pub members: Vec<OwnerSourceEvictionMember>,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchEvictOwnerSourceReq {
+    pub operation_id: u64,
+    /// Membership generation of the authenticated source owner.
+    pub owner_node_start_time: i64,
+    pub cohorts: Vec<OwnerSourceEvictionCohort>,
+}
+
+impl MsgPackSerializePart for BatchEvictOwnerSourceReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchEvictOwnerSourceReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerSourceEvictionOutcome {
+    #[default]
+    Unspecified,
+    Accepted,
+    AlreadyInProgress,
+    Completed,
+    RetryableBusy,
+    Stale,
+    RejectedNotEvictable,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct OwnerSourceEvictionCohortResp {
+    pub cohort_index: u32,
+    pub outcome: OwnerSourceEvictionOutcome,
+    pub detail: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchEvictOwnerSourceResp {
+    pub operation_id: u64,
+    pub cohorts: Vec<OwnerSourceEvictionCohortResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for BatchEvictOwnerSourceResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchEvictOwnerSourceResp as u32
+    }
+}
+
+impl RPCReq for BatchEvictOwnerSourceReq {
+    type Resp = BatchEvictOwnerSourceResp;
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
@@ -919,7 +991,6 @@ pub struct PutAppendStartReq {
     pub put_id: PutIDForAKey,
     pub len: u64,
     pub preferred_sub_cluster: Option<String>,
-    pub demote_source_on_remote_complete: bool,
     pub protect_source_on_remote_complete: bool,
 }
 impl MsgPackSerializePart for PutAppendStartReq {
@@ -927,9 +998,26 @@ impl MsgPackSerializePart for PutAppendStartReq {
         MsgId::PutAppendStartReq as u32
     }
 }
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum PutAppendStartOutcome {
+    /// Missing/old peers must not accidentally interpret a zero value as
+    /// successful completion.
+    #[default]
+    Unspecified,
+    Scheduled,
+    /// A complete non-source replica already exists for this exact put_id.
+    AlreadySatisfied,
+    /// The source route/version no longer exists; retry would target stale data.
+    Obsolete,
+    /// No remote allocation is available now. The owner keeps its local slot
+    /// and retries with backoff; this is never a demotion/drop instruction.
+    RetryableNoSpace,
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutAppendStartResp {
-    pub scheduled: bool,
+    pub outcome: PutAppendStartOutcome,
     pub node_id: NodeIDString,
     pub target_addr: u64,
     pub target_base_addr: u64,
@@ -947,6 +1035,54 @@ impl RPCReq for PutAppendStartReq {
     type Resp = PutAppendStartResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendStartItemReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub len: u64,
+    pub preferred_sub_cluster: Option<String>,
+    pub protect_source_on_remote_complete: bool,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendStartReq {
+    pub items: Vec<BatchPutAppendStartItemReq>,
+}
+impl MsgPackSerializePart for BatchPutAppendStartReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutAppendStartReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendStartItemResp {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub outcome: PutAppendStartOutcome,
+    pub node_id: NodeIDString,
+    pub target_addr: u64,
+    pub target_base_addr: u64,
+    pub len: u64,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendStartResp {
+    pub items: Vec<BatchPutAppendStartItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchPutAppendStartResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutAppendStartResp as u32
+    }
+}
+impl RPCReq for BatchPutAppendStartReq {
+    type Resp = BatchPutAppendStartResp;
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutAppendRevokeReq {
     pub key: String,
@@ -997,6 +1133,47 @@ impl RPCReq for PutAppendDoneReq {
     type Resp = PutAppendDoneResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendDoneItemReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendDoneReq {
+    pub items: Vec<BatchPutAppendDoneItemReq>,
+}
+impl MsgPackSerializePart for BatchPutAppendDoneReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutAppendDoneReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendDoneItemResp {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub appended: bool,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPutAppendDoneResp {
+    pub items: Vec<BatchPutAppendDoneItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchPutAppendDoneResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPutAppendDoneResp as u32
+    }
+}
+impl RPCReq for BatchPutAppendDoneReq {
+    type Resp = BatchPutAppendDoneResp;
+}
+
 // --- RPC for MemHolder KeepAlive ---
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index ccdf281..4992419 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -1,21 +1,28 @@
 use super::{
     CommittedSlotReplica, InflightPutAllocation, InflightPutCommitInfo, InflightPutInfo,
     InflightReplicaTaskInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo,
-    MasterKeyActivityCompletionGuard, MasterKvRouterView, OwnerHoldingGetInfo,
-    PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
+    MasterKeyActivityCompletionGuard, MasterKvRouterView, NodeCacheCapacityReservation,
+    OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
     msg_pack::{
-        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutDoneItemResp, BatchPutDoneReq,
+        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutAppendDoneItemResp,
+        BatchPutAppendDoneReq, BatchPutAppendDoneResp, BatchPutAppendStartItemResp,
+        BatchPutAppendStartReq, BatchPutAppendStartResp, BatchPutDoneItemResp, BatchPutDoneReq,
         BatchPutDoneResp, BatchPutRevokeItemResp, BatchPutRevokeReq, BatchPutRevokeResp,
         BatchPutStartItemResp, BatchPutStartReq, BatchPutStartResp,
         BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
         GroupedBatchPutDoneReq, GroupedBatchPutDoneResp, PutAppendDoneReq, PutAppendDoneResp,
-        PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartReq, PutAppendStartResp,
-        PutAtomicGroup, PutDoneReq, PutDoneResp, PutRevokeReq, PutRevokeResp, PutStartReq,
-        PutStartResp, ReleaseLocalGrantReq, ReleaseLocalGrantResp, ReserveLocalGrantOutcome,
-        ReserveLocalGrantReq, ReserveLocalGrantResp, build_shared_put_atomic_group_assignments,
+        PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartOutcome, PutAppendStartReq,
+        PutAppendStartResp, PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq, PutDoneResp,
+        PutRevokeReq, PutRevokeResp, PutStartReq, PutStartResp, ReleaseLocalGrantReq,
+        ReleaseLocalGrantResp, ReserveLocalGrantOutcome, ReserveLocalGrantReq,
+        ReserveLocalGrantResp, build_shared_put_atomic_group_assignments,
     },
+    node_generation_is_current_live,
     placement::PutPlacementTarget,
-    route_maintenance::{RoutePublishEvent, enqueue_post_route_maintenance},
+    publish_primary_route_tomb_fenced, publish_route_replica_tomb_fenced,
+    route_maintenance::{
+        RoutePublishEvent, apply_post_route_maintenance_batch, enqueue_post_route_maintenance,
+    },
 };
 use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::delete::DeleteKeyInfo;
@@ -142,19 +149,55 @@ fn validate_put_start_source_node_override(
     Ok(())
 }
 
-fn current_route_needs_remote_replica(
+fn current_route_append_outcome(
     route: &OneKvNodesRoutes,
     source_node_id: &NodeID,
     verify_put_id: PutIDForAKey,
-) -> bool {
-    if route.put_id != verify_put_id {
-        return false;
-    }
-    route
+) -> PutAppendStartOutcome {
+    let has_complete_remote = route
         .nodes_replicas
         .read()
         .values()
-        .all(|replica| replica.tomb_tag.is_tomb() || replica.node_id == *source_node_id)
+        .any(|replica| !replica.tomb_tag.is_tomb() && replica.node_id != *source_node_id);
+    classify_put_append_start_outcome(route.put_id == verify_put_id, has_complete_remote)
+}
+
+fn classify_put_append_start_outcome(
+    current_identity: bool,
+    has_complete_remote: bool,
+) -> PutAppendStartOutcome {
+    if !current_identity {
+        PutAppendStartOutcome::Obsolete
+    } else if has_complete_remote {
+        PutAppendStartOutcome::AlreadySatisfied
+    } else {
+        PutAppendStartOutcome::Scheduled
+    }
+}
+
+#[cfg(test)]
+mod append_start_outcome_tests {
+    use super::{PutAppendStartOutcome, classify_put_append_start_outcome};
+
+    #[test]
+    fn append_start_never_conflates_no_remote_with_already_satisfied() {
+        assert_eq!(
+            classify_put_append_start_outcome(true, false),
+            PutAppendStartOutcome::Scheduled
+        );
+        assert_eq!(
+            classify_put_append_start_outcome(true, true),
+            PutAppendStartOutcome::AlreadySatisfied
+        );
+        assert_eq!(
+            classify_put_append_start_outcome(false, true),
+            PutAppendStartOutcome::Obsolete
+        );
+        assert_ne!(
+            PutAppendStartOutcome::RetryableNoSpace,
+            PutAppendStartOutcome::AlreadySatisfied
+        );
+    }
 }
 
 fn append_current_route_replica_if_matching(
@@ -162,6 +205,7 @@ fn append_current_route_replica_if_matching(
     key: &str,
     put_id: PutIDForAKey,
     node_id: NodeID,
+    target_tomb_tag: crate::master_seg_manager::NodeTombTag,
     allocation: Allocation,
 ) -> Option<RoutePublishEvent> {
     let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) else {
@@ -184,19 +228,9 @@ fn append_current_route_replica_if_matching(
         );
         return None;
     }
-    let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
+    if !node_generation_is_current_live(view, &node_id, &target_tomb_tag) {
         tracing::warn!(
-            "append_current_route_replica_if_matching skipped because target node tomb-tag missing: key={} put_id=({},{}) node_id={}",
-            key,
-            put_id.0,
-            put_id.1,
-            node_id
-        );
-        return None;
-    };
-    if tomb_tag.is_tomb() {
-        tracing::warn!(
-            "append_current_route_replica_if_matching skipped because target node is tomb: key={} put_id=({},{}) node_id={}",
+            "append_current_route_replica_if_matching skipped because target generation departed: key={} put_id=({},{}) node_id={}",
             key,
             put_id.0,
             put_id.1,
@@ -206,15 +240,50 @@ fn append_current_route_replica_if_matching(
     }
     let capacity_bytes = allocation.capcity();
     let lease_id = one_kv_nodes_routes.lease_id;
-    one_kv_nodes_routes.nodes_replicas.write().insert(
+    let capacity_reservation = match lease_id {
+        Some(_) => match view.master_kv_router().reserve_node_cache_capacity(
+            &node_id,
+            &target_tomb_tag,
+            ReservedCapacityReason::LeaseBoundKv,
+            capacity_bytes,
+        ) {
+            Ok(reservation) => reservation,
+            Err(err) => {
+                tracing::warn!(
+                    "append_current_route_replica_if_matching could not reserve lease-bound capacity: key={} put_id=({},{}) node_id={} err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    node_id,
+                    err,
+                );
+                return None;
+            }
+        },
+        None => None,
+    };
+    let published = publish_route_replica_tomb_fenced(
+        &one_kv_nodes_routes,
         node_id.clone(),
         KvRouteInfo {
             node_id: node_id.clone(),
             backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
             owner_local_indexed: false,
-            tomb_tag,
+            get_durable_reservation: None,
+            capacity_reservation,
+            tomb_tag: target_tomb_tag,
         },
     );
+    if !published {
+        tracing::warn!(
+            "append_current_route_replica_if_matching rejected by generation/live-replica fence: key={} put_id=({},{}) node_id={}",
+            key,
+            put_id.0,
+            put_id.1,
+            node_id
+        );
+        return None;
+    }
     Some(RoutePublishEvent::replica_append(
         key.to_string(),
         put_id,
@@ -270,6 +339,123 @@ fn allocate_from_node_local_segment(
     ))
 }
 
+fn validate_put_done_committed_slot(
+    view: &MasterKvRouterView,
+    node_id: &NodeID,
+    slot: &PutDoneCommittedSlot,
+    expected_tomb_tag: Option<&crate::master_seg_manager::NodeTombTag>,
+) -> msg_and_error::KvResult<(CommittedSlotReplica, crate::master_seg_manager::NodeTombTag)> {
+    let invalid = |detail: String| {
+        msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument { detail })
+    };
+    if slot.slot_size == 0 || slot.len > slot.slot_size {
+        return Err(invalid(format!(
+            "invalid committed local slot geometry: grant_id={} slot_size={} len={}",
+            slot.grant_id, slot.slot_size, slot.len
+        )));
+    }
+    let Some(grant) = view
+        .master_kv_router()
+        .inner()
+        .local_reserve_grants
+        .get(&slot.grant_id)
+    else {
+        return Err(invalid(format!(
+            "committed local slot references unknown grant_id={}",
+            slot.grant_id
+        )));
+    };
+    if grant.owner_node_id != *node_id {
+        return Err(invalid(format!(
+            "committed local slot owner mismatch: grant_id={} owner={} requester={}",
+            slot.grant_id, grant.owner_node_id, node_id
+        )));
+    }
+    let tomb_tag = grant.tomb_tag.clone();
+    if !node_generation_is_current_live(view, node_id, &tomb_tag)
+        || expected_tomb_tag.is_some_and(|expected| !expected.same_generation(&tomb_tag))
+    {
+        return Err(invalid(format!(
+            "committed local slot belongs to a different/departed owner generation: grant_id={} requester={}",
+            slot.grant_id, node_id
+        )));
+    }
+
+    let grant_base = grant.allocation.base_addr();
+    let grant_addr = grant_base
+        .checked_add(grant.allocation.addr())
+        .ok_or_else(|| invalid("committed local slot grant address overflow".to_string()))?;
+    let slot_offset = slot
+        .slot_size
+        .checked_mul(u64::from(slot.slot_index))
+        .ok_or_else(|| invalid("committed local slot offset overflow".to_string()))?;
+    let slot_end = slot_offset
+        .checked_add(slot.slot_size)
+        .ok_or_else(|| invalid("committed local slot end overflow".to_string()))?;
+    if slot_end > grant.allocation.capcity() {
+        return Err(invalid(format!(
+            "committed local slot is outside grant: grant_id={} slot_index={} slot_size={} grant_len={}",
+            slot.grant_id,
+            slot.slot_index,
+            slot.slot_size,
+            grant.allocation.capcity()
+        )));
+    }
+    let expected_addr = grant_addr
+        .checked_add(slot_offset)
+        .ok_or_else(|| invalid("committed local slot address overflow".to_string()))?;
+    if slot.base_addr != grant_base || slot.addr != expected_addr {
+        return Err(invalid(format!(
+            "committed local slot address mismatch: grant_id={} expected_base={:#x} got_base={:#x} expected_addr={:#x} got_addr={:#x}",
+            slot.grant_id, grant_base, slot.base_addr, expected_addr, slot.addr
+        )));
+    }
+
+    Ok((
+        CommittedSlotReplica {
+            owner_node_id: node_id.clone(),
+            grant_id: slot.grant_id,
+            slot_index: slot.slot_index,
+            slot_size: slot.slot_size,
+            addr: slot.addr,
+            len: slot.len,
+            base_addr: slot.base_addr,
+        },
+        tomb_tag,
+    ))
+}
+
+async fn prepare_route_state(
+    view: &MasterKvRouterView,
+    lease_id: Option<u64>,
+    key: &str,
+    put_id: PutIDForAKey,
+    node_id: &NodeID,
+    tomb_tag: &crate::master_seg_manager::NodeTombTag,
+    reservation_reason: Option<ReservedCapacityReason>,
+    target_cap_bytes: u64,
+) -> msg_and_error::KvResult<Option<Arc<NodeCacheCapacityReservation>>> {
+    // Reserve first. If lease attachment fails, dropping this local token
+    // restores the exact generation-scoped counter automatically. Committed
+    // slots do not reserve again because their whole grant is already excluded.
+    let reservation = match reservation_reason {
+        Some(reason) => view.master_kv_router().reserve_node_cache_capacity(
+            node_id,
+            tomb_tag,
+            reason,
+            target_cap_bytes,
+        )?,
+        None => None,
+    };
+    if let Some(lease_id) = lease_id {
+        view.master_lease_manager()
+            .attach_key(lease_id, key.to_string(), put_id)
+            .await
+            .map_err(|err| -> msg_and_error::KvError { err.into() })?;
+    }
+    Ok(reservation)
+}
+
 fn reserve_replica_task(
     view: &MasterKvRouterView,
     key: &str,
@@ -286,7 +472,6 @@ fn reserve_replica_task(
         preferred_sub_cluster,
         len,
         &HashSet::new(),
-        false,
         true,
     )
 }
@@ -299,7 +484,6 @@ fn reserve_replica_task_excluding(
     preferred_sub_cluster: Option<&str>,
     len: u64,
     excluded_nodes: &HashSet<NodeID>,
-    demote_source_on_remote_complete: bool,
     protect_source_on_remote_complete: bool,
 ) -> msg_and_error::KvResult<InflightReplicaTaskInfo> {
     let activity_lease = view.master_kv_router().reserve_inflight_replica_key(key)?;
@@ -314,6 +498,19 @@ fn reserve_replica_task_excluding(
             preferred_sub_cluster,
             len,
         )?;
+    let Some(target_tomb_tag) = view
+        .master_seg_manager()
+        .get_allocation_tomb_tag(&target_node_id, &target_allocation)
+    else {
+        return Err(msg_and_error::KvError::Api(
+            msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "replica target generation changed during reservation: key={} put_id=({},{}) target_node_id={}",
+                    key, put_id.0, put_id.1, target_node_id
+                ),
+            },
+        ));
+    };
     tracing::debug!(
         "replica task reserved: key={} put_id=({},{}) source_node_id={} target_node_id={} preferred_sub_cluster={:?} len={}",
         key,
@@ -326,11 +523,11 @@ fn reserve_replica_task_excluding(
     );
     Ok(InflightReplicaTaskInfo {
         node_id: target_node_id,
+        target_tomb_tag,
         source_node_id: source_node_id.clone(),
         key: key.to_string(),
         put_id,
         target_allocation: Arc::new(Mutex::new(Some(target_allocation))),
-        demote_source_on_remote_complete,
         protect_source_on_remote_complete,
         _activity_lease: activity_lease,
     })
@@ -347,41 +544,43 @@ async fn publish_completed_put_route(
     target_cap_bytes: u64,
     local_cache_holder_id: Option<u64>,
 ) -> MsgPack<PutDoneResp> {
-    let mut old_one_kv_routes: Option<Arc<OneKvNodesRoutes>> = None;
-    let mut inserted = false;
-    {
-        let mut one_kv_routes = view
-            .master_kv_router()
-            .inner()
-            .kv_routes
-            .entry(key.clone())
-            .or_insert_with(|| {
-                inserted = true;
-                Arc::new(OneKvNodesRoutes {
-                    put_id,
-                    lease_id: lease_id_opt,
-                    atomic_group: atomic_group.clone(),
-                    nodes_replicas: RwLock::new(HashMap::new()),
-                    get_durable_slots_used: AtomicU32::new(0),
-                })
-            });
-        if !inserted {
-            old_one_kv_routes = Some(one_kv_routes.clone());
-            *one_kv_routes = Arc::new(OneKvNodesRoutes {
-                put_id,
-                lease_id: lease_id_opt,
-                atomic_group: atomic_group.clone(),
-                nodes_replicas: RwLock::new(HashMap::new()),
-                get_durable_slots_used: AtomicU32::new(0),
+    let publish_tag = completed_info.tomb_tag.clone();
+    let new_route = Arc::new(OneKvNodesRoutes {
+        put_id,
+        lease_id: lease_id_opt,
+        atomic_group: atomic_group.clone(),
+        nodes_replicas: RwLock::new(HashMap::from([(node_id.clone(), completed_info)])),
+        get_durable_slots_used: AtomicU32::new(0),
+    });
+    let old_one_kv_routes = match publish_primary_route_tomb_fenced(
+        &view.master_kv_router().inner().kv_routes,
+        &key,
+        new_route,
+        &publish_tag,
+    ) {
+        Ok(previous) => previous,
+        Err(()) => {
+            if let Some(lease_id) = lease_id_opt {
+                view.master_lease_manager()
+                    .detach_key_if_version(lease_id, &key, put_id);
+            }
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "primary route publication rejected because target generation departed: key={} put_id=({},{}) node_id={}",
+                    key, put_id.0, put_id.1, node_id
+                ),
             });
+            return MsgPack {
+                serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                raw_bytes: Vec::new(),
+            };
         }
-        one_kv_routes
-            .nodes_replicas
-            .write()
-            .insert(node_id.clone(), completed_info);
-    }
+    };
 
     if let Some(old) = old_one_kv_routes {
+        view.master_kv_router()
+            .remove_route_cache_entries_exact(&key, &old)
+            .await;
         if let Err(err) = view
             .master_kv_router()
             .inner()
@@ -397,15 +596,15 @@ async fn publish_completed_put_route(
         }
     }
 
-    enqueue_post_route_maintenance(
+    apply_post_route_maintenance_batch(
         &view,
-        RoutePublishEvent::primary_put(
+        vec![RoutePublishEvent::primary_put(
             key.clone(),
             put_id,
             lease_id_opt,
             node_id.clone(),
             target_cap_bytes,
-        ),
+        )],
     )
     .await;
 
@@ -498,6 +697,7 @@ pub async fn handle_put_start(
     let mut src_allocation = Some(src_allocation);
 
     let finalize = |commit_node_id: NodeID,
+                    target_tomb_tag: crate::master_seg_manager::NodeTombTag,
                     response_node_id: NodeID,
                     inflight_alloc: InflightPutAllocation,
                     src_addr: u64,
@@ -512,6 +712,7 @@ pub async fn handle_put_start(
             req_node_id: req_node_id.clone(),
             commit_info: InflightPutCommitInfo {
                 node_id: commit_node_id,
+                target_tomb_tag,
                 src_target_allocation: Arc::new(Mutex::new(Some(inflight_alloc))),
                 replica_target: replica_target.clone(),
             },
@@ -618,6 +819,28 @@ pub async fn handle_put_start(
             let src = src_allocation
                 .take()
                 .expect("src_allocation must exist when finalizing local put");
+            let Some(target_tomb_tag) = view
+                .master_seg_manager()
+                .get_allocation_tomb_tag(&node_id, &src)
+            else {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "local put target generation changed before start publication: key={} put_id=({},{}) node_id={}",
+                            key, put_id.0, put_id.1, node_id
+                        ),
+                    },
+                );
+                return (
+                    (0, 0),
+                    MsgPack {
+                        serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                            &err,
+                        ),
+                        raw_bytes: Vec::new(),
+                    },
+                );
+            };
             let replica_target = if req.serialize_part.make_replica_task {
                 match reserve_replica_task(
                     &view,
@@ -670,6 +893,7 @@ pub async fn handle_put_start(
             };
             let fut = finalize(
                 node_id.clone(),
+                target_tomb_tag,
                 node_id,
                 InflightPutAllocation::Local(src),
                 abs,
@@ -718,8 +942,31 @@ pub async fn handle_put_start(
             let src = src_allocation
                 .take()
                 .expect("src_allocation must exist when finalizing remote put");
+            let Some(target_tomb_tag) = view
+                .master_seg_manager()
+                .get_allocation_tomb_tag(&node_id, &target_allocation)
+            else {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "remote put target generation changed before start publication: key={} put_id=({},{}) node_id={}",
+                            key, put_id.0, put_id.1, node_id
+                        ),
+                    },
+                );
+                return (
+                    (0, 0),
+                    MsgPack {
+                        serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                            &err,
+                        ),
+                        raw_bytes: Vec::new(),
+                    },
+                );
+            };
             let fut = finalize(
                 node_id.clone(),
+                target_tomb_tag,
                 node_id,
                 InflightPutAllocation::Remote {
                     src,
@@ -749,44 +996,9 @@ pub async fn handle_put_start(
 
 pub async fn handle_reserve_local_grant(
     view: MasterKvRouterView,
-    req: MsgPack<ReserveLocalGrantReq>,
+    _req: MsgPack<ReserveLocalGrantReq>,
     req_node_id: NodeID,
 ) -> (u64, MsgPack<ReserveLocalGrantResp>) {
-    if req.serialize_part.reclaim_before_grow
-        && req.serialize_part.slot_size != 0
-        && req.serialize_part.required_free_slots != 0
-    {
-        let reclaimed = crate::master_kv_router::reclaim::reclaim_owner_slots_for_reserve(
-            &view,
-            &req_node_id,
-            req.serialize_part.slot_size,
-            req.serialize_part.required_free_slots,
-        )
-        .await;
-        tracing::info!(
-            "owner reserve proactive headroom reclaim: owner={} slot_size={} requested_slots={} reclaimed={}",
-            req_node_id,
-            req.serialize_part.slot_size,
-            req.serialize_part.required_free_slots,
-            reclaimed
-        );
-        if reclaimed != 0 {
-            return (
-                0,
-                MsgPack {
-                    serialize_part: ReserveLocalGrantResp {
-                        outcome: ReserveLocalGrantOutcome::Reclaimed {
-                            slot_size: req.serialize_part.slot_size,
-                            reclaimed_slots: reclaimed,
-                        },
-                        error_code: msg_and_error::OK,
-                        ..Default::default()
-                    },
-                    raw_bytes: Vec::new(),
-                },
-            );
-        }
-    }
     let allocation = match allocate_from_node_local_segment(
         &view,
         &req_node_id,
@@ -795,85 +1007,6 @@ pub async fn handle_reserve_local_grant(
     ) {
         Ok(allocation) => allocation,
         Err(err) => {
-            let physical_no_space = matches!(
-                &err,
-                msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace { .. })
-            );
-            if physical_no_space
-                && req.serialize_part.slot_size != 0
-                && req.serialize_part.required_free_slots != 0
-            {
-                let requested_eviction_weight = req
-                    .serialize_part
-                    .slot_size
-                    .saturating_mul(u64::from(req.serialize_part.required_free_slots));
-                let pending_eviction_weight = view
-                    .master_kv_router()
-                    .eviction_reclaim_pending_weight(req_node_id.as_ref());
-                let additional_eviction_weight =
-                    requested_eviction_weight.saturating_sub(pending_eviction_weight);
-                if additional_eviction_weight != 0 {
-                    if let Some(cache) = view
-                        .master_kv_router()
-                        .get_node_cache_controller(req_node_id.as_ref())
-                    {
-                        let weighted_size_before = cache.weighted_size();
-                        let recoverable_evicted_weight =
-                            view.master_kv_router().evict_recoverable_cache_weight(
-                                req_node_id.as_ref(),
-                                additional_eviction_weight,
-                            );
-                        let fallback_requested_weight =
-                            additional_eviction_weight.saturating_sub(recoverable_evicted_weight);
-                        let fallback_evicted_weight = if view
-                            .master_kv_router()
-                            .owner_cache_allows_unrecoverable_reserve_pressure_eviction(
-                                req_node_id.as_ref(),
-                            ) {
-                            cache.evict_some(fallback_requested_weight)
-                        } else {
-                            0
-                        };
-                        tracing::info!(
-                            "owner reserve requested moka eviction: owner={} slot_size={} requested_slots={} requested_weight={} pending_weight_before={} recoverable_evicted_weight={} fallback_requested_weight={} fallback_evicted_weight={} shortfall_weight={} weighted_size_before={} weighted_size_after={}",
-                            req_node_id,
-                            req.serialize_part.slot_size,
-                            req.serialize_part.required_free_slots,
-                            requested_eviction_weight,
-                            pending_eviction_weight,
-                            recoverable_evicted_weight,
-                            fallback_requested_weight,
-                            fallback_evicted_weight,
-                            fallback_requested_weight.saturating_sub(fallback_evicted_weight),
-                            weighted_size_before,
-                            cache.weighted_size()
-                        );
-                    }
-                }
-                let reclaimed = crate::master_kv_router::reclaim::reclaim_owner_slots_for_reserve(
-                    &view,
-                    &req_node_id,
-                    req.serialize_part.slot_size,
-                    req.serialize_part.required_free_slots,
-                )
-                .await;
-                if reclaimed != 0 {
-                    return (
-                        0,
-                        MsgPack {
-                            serialize_part: ReserveLocalGrantResp {
-                                outcome: ReserveLocalGrantOutcome::Reclaimed {
-                                    slot_size: req.serialize_part.slot_size,
-                                    reclaimed_slots: reclaimed,
-                                },
-                                error_code: msg_and_error::OK,
-                                ..Default::default()
-                            },
-                            raw_bytes: Vec::new(),
-                        },
-                    );
-                }
-            }
             let resp: ReserveLocalGrantResp =
                 crate::rpcresp_kvresult_convert::FromError::from_error(&err);
             return (
@@ -890,13 +1023,75 @@ pub async fn handle_reserve_local_grant(
     let grant_base_addr = allocation.base_addr();
     let grant_abs_addr = grant_base_addr + allocation.addr();
     let grant_len = allocation.capcity();
+    let Some(tomb_tag) = view
+        .master_seg_manager()
+        .get_allocation_tomb_tag(&req_node_id, &allocation)
+    else {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "local reserve grant generation changed before publication: owner={}",
+                req_node_id
+            ),
+        });
+        let resp: ReserveLocalGrantResp =
+            crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+        return (
+            0,
+            MsgPack {
+                serialize_part: resp,
+                raw_bytes: Vec::new(),
+            },
+        );
+    };
+    let capacity_reservation = match view.master_kv_router().reserve_node_cache_capacity(
+        &req_node_id,
+        &tomb_tag,
+        ReservedCapacityReason::LocalReserveGrant,
+        grant_len,
+    ) {
+        Ok(reservation) => reservation,
+        Err(err) => {
+            let resp: ReserveLocalGrantResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            return (
+                0,
+                MsgPack {
+                    serialize_part: resp,
+                    raw_bytes: Vec::new(),
+                },
+            );
+        }
+    };
     view.master_kv_router().install_local_reserve_grant(
         grant_id,
         LocalReserveGrantInfo {
             owner_node_id: req_node_id.clone(),
+            tomb_tag: tomb_tag.clone(),
             allocation,
+            capacity_reservation,
         },
     );
+    if tomb_tag.is_tomb() {
+        // MemberLeft may mark the shared tag between allocation and map
+        // insertion.  Remove the exact grant before returning so the old
+        // allocator cannot be pinned after its cleanup snapshot.
+        drop(view.master_kv_router().take_local_reserve_grant(grant_id));
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "local reserve grant owner departed during publication: owner={} grant_id={}",
+                req_node_id, grant_id
+            ),
+        });
+        let resp: ReserveLocalGrantResp =
+            crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+        return (
+            0,
+            MsgPack {
+                serialize_part: resp,
+                raw_bytes: Vec::new(),
+            },
+        );
+    }
 
     (
         grant_id,
@@ -952,6 +1147,23 @@ pub async fn handle_release_local_grant(
         };
     }
 
+    if !node_generation_is_current_live(&view, &req_node_id, &grant.tomb_tag) {
+        // Do not reinsert an old-generation allocation: MemberLeft cleanup may
+        // already have taken its snapshot.  Dropping it here is the exact
+        // generation-safe release.
+        drop(grant);
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: format!(
+                "release_local_grant references a departed owner generation: grant_id={} requester_node_id={}",
+                grant_id, req_node_id
+            ),
+        });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    }
+
     drop(grant);
     MsgPack {
         serialize_part: ReleaseLocalGrantResp::default(),
@@ -1123,7 +1335,7 @@ async fn handle_put_done_with_resolved_group(
     let put_id = req.serialize_part.put_id;
     let lease_id_opt = req.serialize_part.lease_id;
     let full_put_id: (String, u64, u32) = (req.serialize_part.key.clone(), put_id.0, put_id.1);
-    let local_cache_holder_id: Option<u64>;
+    let mut local_cache_holder_id: Option<u64>;
     let atomic_group = if let Some(group) = resolved_atomic_group {
         Some(group)
     } else {
@@ -1161,6 +1373,7 @@ async fn handle_put_done_with_resolved_group(
             .as_ref()
             .map(|target| MasterKeyActivityCompletionGuard::new(target._activity_lease.clone()));
         let node_id = commit_info.node_id;
+        let tomb_tag = commit_info.target_tomb_tag.clone();
         let Some(allocs) = commit_info.src_target_allocation.lock().take() else {
             tracing::warn!(
                 "Put operation with put_id {:?} not found for completion",
@@ -1178,14 +1391,14 @@ async fn handle_put_done_with_resolved_group(
             };
         };
 
-        let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
-            tracing::warn!(
-                "Put operation with put_id {:?} not found for completion",
+        if !node_generation_is_current_live(&view, &node_id, &tomb_tag) {
+            tracing::info!(
+                "Put operation with put_id {:?} belongs to a departed target generation, skip",
                 put_id
             );
             let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
                 detail: format!(
-                    "Put operation with put_id {:?} not found for completion",
+                    "Put operation with put_id {:?} belongs to a departed target generation",
                     put_id
                 ),
             });
@@ -1193,205 +1406,153 @@ async fn handle_put_done_with_resolved_group(
                 serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
                 raw_bytes: Vec::new(),
             };
-        };
+        }
 
-        if tomb_tag.is_tomb() {
-            tracing::info!("Put operation with put_id {:?} is tomb, skip", put_id);
+        let route_committed_slot = req.serialize_part.committed_slot.clone();
+        if req.serialize_part.publish_local_cache
+            && (!matches!(&allocs, InflightPutAllocation::Local(_))
+                || route_committed_slot.is_some())
+        {
             let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
-                detail: format!("Put operation with put_id {:?} is tomb, skip", put_id),
+                detail: format!(
+                    "publish_local_cache requires owner-local allocation backing; key={} put_id=({},{})",
+                    key, put_id.0, put_id.1
+                ),
             });
             return MsgPack {
                 serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
                 raw_bytes: Vec::new(),
             };
         }
-
-        let route_committed_slot = req.serialize_part.committed_slot.clone();
         let (target_cap_bytes, completed_info, local_cache_publish_supported) = match allocs {
-            InflightPutAllocation::Local(mut target_allocation) => {
+            InflightPutAllocation::Local(target_allocation) => {
                 if let Some(slot) = route_committed_slot {
-                    let target_cap_bytes = slot.slot_size;
-                    if let Some(lease_id) = lease_id_opt {
-                        if let Err(e) = view
-                            .master_lease_manager()
-                            .attach_key(lease_id, key.clone(), put_id)
-                            .await
-                        {
-                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                                e.into();
+                    let (committed_slot, slot_tomb_tag) = match validate_put_done_committed_slot(
+                        &view,
+                        &node_id,
+                        &slot,
+                        Some(&tomb_tag),
+                    ) {
+                        Ok(validated) => validated,
+                        Err(err) => {
                             return MsgPack {
                                 serialize_part:
-                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&err),
                                 raw_bytes: Vec::new(),
                             };
                         }
-                        if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
-                            node_id.as_ref(),
-                            ReservedCapacityReason::LeaseBoundKv,
-                            target_cap_bytes as i64,
-                        ) {
-                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                                e.into();
+                    };
+                    let target_cap_bytes = committed_slot.slot_size;
+                    let capacity_reservation = match prepare_route_state(
+                        &view,
+                        lease_id_opt,
+                        &key,
+                        put_id,
+                        &node_id,
+                        &slot_tomb_tag,
+                        None,
+                        target_cap_bytes,
+                    )
+                    .await
+                    {
+                        Ok(reservation) => reservation,
+                        Err(err) => {
                             return MsgPack {
                                 serialize_part:
-                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&err),
                                 raw_bytes: Vec::new(),
                             };
                         }
-                    }
+                    };
                     drop(target_allocation);
                     (
                         target_cap_bytes,
                         KvRouteInfo {
                             node_id: node_id.clone(),
-                            backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
-                                owner_node_id: node_id.clone(),
-                                grant_id: slot.grant_id,
-                                slot_index: slot.slot_index,
-                                slot_size: slot.slot_size,
-                                addr: slot.addr,
-                                len: slot.len,
-                                base_addr: slot.base_addr,
-                            }),
+                            backing: KvReplicaBacking::CommittedSlot(committed_slot),
                             owner_local_indexed: true,
-                            tomb_tag,
+                            get_durable_reservation: None,
+                            capacity_reservation,
+                            tomb_tag: slot_tomb_tag,
                         },
                         false,
                     )
                 } else {
                     let target_cap_bytes = target_allocation.capcity();
-                    if let Some(lease_id) = lease_id_opt {
-                        if let Err(e) = view
-                            .master_lease_manager()
-                            .attach_key(lease_id, key.clone(), put_id)
-                            .await
-                        {
-                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                                e.into();
-                            return MsgPack {
-                                serialize_part:
-                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
-                                raw_bytes: Vec::new(),
-                            };
-                        }
-                        if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
-                            node_id.as_ref(),
-                            ReservedCapacityReason::LeaseBoundKv,
-                            target_cap_bytes as i64,
-                        ) {
-                            let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                                e.into();
+                    let reservation_reason = if req.serialize_part.publish_local_cache {
+                        Some(ReservedCapacityReason::OwnerIndexedAllocation)
+                    } else if lease_id_opt.is_some() {
+                        Some(ReservedCapacityReason::LeaseBoundKv)
+                    } else {
+                        None
+                    };
+                    let capacity_reservation = match prepare_route_state(
+                        &view,
+                        lease_id_opt,
+                        &key,
+                        put_id,
+                        &node_id,
+                        &tomb_tag,
+                        reservation_reason,
+                        target_cap_bytes,
+                    )
+                    .await
+                    {
+                        Ok(reservation) => reservation,
+                        Err(err) => {
                             return MsgPack {
                                 serialize_part:
-                                    crate::rpcresp_kvresult_convert::FromError::from_error(&kv_err),
+                                    crate::rpcresp_kvresult_convert::FromError::from_error(&err),
                                 raw_bytes: Vec::new(),
                             };
                         }
-                        let view_clone = view.clone();
-                        let node_id_string = node_id.as_ref().to_string();
-                        target_allocation.set_on_drop(move || {
-                            // The allocation can be released while FrameworkInner itself is
-                            // being dropped.  At that point the weak module view can no longer
-                            // be upgraded and restoring the runtime Moka reservation is both
-                            // impossible and unnecessary.  Keep an upgrade guard alive for the
-                            // whole callback so dependency access cannot race the final drop.
-                            let Some(_view_guard) = view_clone.try_upgrade() else {
-                                return;
-                            };
-                            if let Err(e) = view_clone
-                                .master_kv_router()
-                                .adjust_node_cache_reserved_capacity(
-                                    &node_id_string,
-                                    ReservedCapacityReason::LeaseBoundKv,
-                                    -(target_cap_bytes as i64),
-                                )
-                            {
-                                tracing::warn!(
-                                    "Failed to restore moka capacity on drop: node_id={}, bytes={}, err={}",
-                                    node_id_string,
-                                    target_cap_bytes,
-                                    e
-                                );
-                            }
-                        });
-                    }
+                    };
                     (
                         target_cap_bytes,
                         KvRouteInfo {
                             node_id: node_id.clone(),
                             backing: KvReplicaBacking::Allocation(Arc::new(target_allocation)),
                             owner_local_indexed: req.serialize_part.publish_local_cache,
+                            get_durable_reservation: None,
+                            capacity_reservation,
                             tomb_tag,
                         },
                         true,
                     )
                 }
             }
-            InflightPutAllocation::Remote {
-                src: _src,
-                mut target,
-            } => {
+            InflightPutAllocation::Remote { src: _src, target } => {
                 let target_cap_bytes = target.capcity();
-                if let Some(lease_id) = lease_id_opt {
-                    if let Err(e) = view
-                        .master_lease_manager()
-                        .attach_key(lease_id, key.clone(), put_id)
-                        .await
-                    {
-                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                            e.into();
-                        return MsgPack {
-                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
-                                &kv_err,
-                            ),
-                            raw_bytes: Vec::new(),
-                        };
-                    }
-                    if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
-                        node_id.as_ref(),
-                        ReservedCapacityReason::LeaseBoundKv,
-                        target_cap_bytes as i64,
-                    ) {
-                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                            e.into();
+                let capacity_reservation = match prepare_route_state(
+                    &view,
+                    lease_id_opt,
+                    &key,
+                    put_id,
+                    &node_id,
+                    &tomb_tag,
+                    lease_id_opt.map(|_| ReservedCapacityReason::LeaseBoundKv),
+                    target_cap_bytes,
+                )
+                .await
+                {
+                    Ok(reservation) => reservation,
+                    Err(err) => {
                         return MsgPack {
                             serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
-                                &kv_err,
+                                &err,
                             ),
                             raw_bytes: Vec::new(),
                         };
                     }
-                    let view_clone = view.clone();
-                    let node_id_string = node_id.as_ref().to_string();
-                    target.set_on_drop(move || {
-                        // See the equivalent local-placement callback above.  A final framework
-                        // teardown must not call back into the module currently being destroyed.
-                        let Some(_view_guard) = view_clone.try_upgrade() else {
-                            return;
-                        };
-                        if let Err(e) = view_clone
-                            .master_kv_router()
-                            .adjust_node_cache_reserved_capacity(
-                                &node_id_string,
-                                ReservedCapacityReason::LeaseBoundKv,
-                                -(target_cap_bytes as i64),
-                            )
-                        {
-                            tracing::warn!(
-                                "Failed to restore moka capacity on drop: node_id={}, bytes={}, err={}",
-                                node_id_string,
-                                target_cap_bytes,
-                                e
-                            );
-                        }
-                    });
-                }
+                };
                 (
                     target_cap_bytes,
                     KvRouteInfo {
                         node_id: node_id.clone(),
                         backing: KvReplicaBacking::Allocation(Arc::new(target)),
                         owner_local_indexed: false,
+                        get_durable_reservation: None,
+                        capacity_reservation,
                         tomb_tag,
                     },
                     false,
@@ -1399,42 +1560,36 @@ async fn handle_put_done_with_resolved_group(
             }
             InflightPutAllocation::LocalCommittedSlot(slot) => {
                 let target_cap_bytes = slot.slot_size;
-                if let Some(lease_id) = lease_id_opt {
-                    if let Err(e) = view
-                        .master_lease_manager()
-                        .attach_key(lease_id, key.clone(), put_id)
-                        .await
-                    {
-                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                            e.into();
-                        return MsgPack {
-                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
-                                &kv_err,
-                            ),
-                            raw_bytes: Vec::new(),
-                        };
-                    }
-                    if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
-                        node_id.as_ref(),
-                        ReservedCapacityReason::LeaseBoundKv,
-                        target_cap_bytes as i64,
-                    ) {
-                        let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError =
-                            e.into();
+                let capacity_reservation = match prepare_route_state(
+                    &view,
+                    lease_id_opt,
+                    &key,
+                    put_id,
+                    &node_id,
+                    &tomb_tag,
+                    None,
+                    target_cap_bytes,
+                )
+                .await
+                {
+                    Ok(reservation) => reservation,
+                    Err(err) => {
                         return MsgPack {
                             serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
-                                &kv_err,
+                                &err,
                             ),
                             raw_bytes: Vec::new(),
                         };
                     }
-                }
+                };
                 (
                     target_cap_bytes,
                     KvRouteInfo {
                         node_id: node_id.clone(),
                         backing: KvReplicaBacking::CommittedSlot(slot),
                         owner_local_indexed: true,
+                        get_durable_reservation: None,
+                        capacity_reservation,
                         tomb_tag,
                     },
                     false,
@@ -1490,41 +1645,48 @@ async fn handle_put_done_with_resolved_group(
             None
         };
 
-        // Insert into kv_routes with replica support
-        let mut old_one_kv_routes: Option<Arc<OneKvNodesRoutes>> = None;
-        let mut inserted = false;
-        {
-            let mut one_kv_routes = view
-                .master_kv_router()
-                .inner()
-                .kv_routes
-                .entry(key.clone())
-                .or_insert_with(|| {
-                    inserted = true;
-                    Arc::new(OneKvNodesRoutes {
-                        put_id,
-                        lease_id: lease_id_opt,
-                        atomic_group: atomic_group.clone(),
-                        nodes_replicas: RwLock::new(HashMap::new()),
-                        get_durable_slots_used: AtomicU32::new(0),
-                    })
-                });
-            // we need to take out old one_kv_routes if it is not inserted
-            if !inserted {
-                old_one_kv_routes = Some(one_kv_routes.clone());
-                *one_kv_routes = Arc::new(OneKvNodesRoutes {
-                    put_id,
-                    lease_id: lease_id_opt,
-                    atomic_group: atomic_group.clone(),
-                    nodes_replicas: RwLock::new(HashMap::new()),
-                    get_durable_slots_used: AtomicU32::new(0),
-                });
+        // Publish the primary route under the node-generation fence.  This
+        // closes the gap where MemberLeft marked/snapshotted routes between a
+        // pre-check and a later DashMap insert.
+        let publish_tag = completed_info.tomb_tag.clone();
+        let new_route = Arc::new(OneKvNodesRoutes {
+            put_id,
+            lease_id: lease_id_opt,
+            atomic_group: atomic_group.clone(),
+            nodes_replicas: RwLock::new(HashMap::from([(node_id.clone(), completed_info)])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        let old_one_kv_routes = match publish_primary_route_tomb_fenced(
+            &view.master_kv_router().inner().kv_routes,
+            &key,
+            new_route,
+            &publish_tag,
+        ) {
+            Ok(previous) => previous,
+            Err(()) => {
+                if let Some(lease_id) = lease_id_opt {
+                    view.master_lease_manager()
+                        .detach_key_if_version(lease_id, &key, put_id);
+                }
+                if let Some(holder_id) = local_cache_holder_id.take() {
+                    view.master_kv_router().inner().get_holding.remove(
+                        &crate::memholder::NodeHolderKey::new(node_id.to_string(), holder_id),
+                    );
+                }
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "primary route publication rejected because target generation departed: key={} put_id=({},{}) node_id={}",
+                            key, put_id.0, put_id.1, node_id
+                        ),
+                    },
+                );
+                return MsgPack {
+                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                    raw_bytes: Vec::new(),
+                };
             }
-            one_kv_routes
-                .nodes_replicas
-                .write()
-                .insert(node_id.clone(), completed_info);
-        }
+        };
 
         if let Some(replica_target) = commit_info.replica_target {
             view.master_kv_router()
@@ -1546,6 +1708,9 @@ async fn handle_put_done_with_resolved_group(
         }
 
         if let Some(old) = old_one_kv_routes {
+            view.master_kv_router()
+                .remove_route_cache_entries_exact(&key, &old)
+                .await;
             if let Err(err) = view
                 .master_kv_router()
                 .inner()
@@ -1598,33 +1763,18 @@ async fn handle_put_done_with_resolved_group(
                 }
             };
             let node_id = req_node_id;
-            let Some(tomb_tag) = view.master_seg_manager().get_node_tomb_tag(&node_id) else {
-                let err = msg_and_error::KvError::Api(
-                    msg_and_error::ApiError::InvalidPutMasterState {
-                        detail: format!(
-                            "local-first put_done node tomb tag missing: key={} put_id=({},{}) node_id={}",
-                            key, put_id.0, put_id.1, node_id
-                        ),
-                    },
-                );
-                return MsgPack {
-                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
-                    raw_bytes: Vec::new(),
-                };
-            };
-            if tomb_tag.is_tomb() {
-                let err =
-                    msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
-                        detail: format!(
-                            "local-first put_done node is tomb: key={} put_id=({},{}) node_id={}",
-                            key, put_id.0, put_id.1, node_id
-                        ),
-                    });
-                return MsgPack {
-                    serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
-                    raw_bytes: Vec::new(),
+            let (committed_slot, tomb_tag) =
+                match validate_put_done_committed_slot(&view, &node_id, &slot, None) {
+                    Ok(validated) => validated,
+                    Err(err) => {
+                        return MsgPack {
+                            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
+                                &err,
+                            ),
+                            raw_bytes: Vec::new(),
+                        };
+                    }
                 };
-            }
             if req.serialize_part.publish_local_cache {
                 let err = msg_and_error::KvError::Api(
                     msg_and_error::ApiError::InvalidPutMasterState {
@@ -1639,47 +1789,35 @@ async fn handle_put_done_with_resolved_group(
                     raw_bytes: Vec::new(),
                 };
             }
-            let target_cap_bytes = slot.slot_size;
-            if let Some(lease_id) = lease_id_opt {
-                if let Err(e) = view
-                    .master_lease_manager()
-                    .attach_key(lease_id, key.clone(), put_id)
-                    .await
-                {
-                    let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError = e.into();
-                    return MsgPack {
-                        serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
-                            &kv_err,
-                        ),
-                        raw_bytes: Vec::new(),
-                    };
-                }
-                if let Err(e) = view.master_kv_router().adjust_node_cache_reserved_capacity(
-                    node_id.as_ref(),
-                    ReservedCapacityReason::LeaseBoundKv,
-                    target_cap_bytes as i64,
-                ) {
-                    let kv_err: crate::rpcresp_kvresult_convert::msg_and_error::KvError = e.into();
+            let target_cap_bytes = committed_slot.slot_size;
+            let capacity_reservation = match prepare_route_state(
+                &view,
+                lease_id_opt,
+                &key,
+                put_id,
+                &node_id,
+                &tomb_tag,
+                None,
+                target_cap_bytes,
+            )
+            .await
+            {
+                Ok(reservation) => reservation,
+                Err(err) => {
                     return MsgPack {
                         serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(
-                            &kv_err,
+                            &err,
                         ),
                         raw_bytes: Vec::new(),
                     };
                 }
-            }
+            };
             let completed_info = KvRouteInfo {
                 node_id: node_id.clone(),
-                backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
-                    owner_node_id: node_id.clone(),
-                    grant_id: slot.grant_id,
-                    slot_index: slot.slot_index,
-                    slot_size: slot.slot_size,
-                    addr: slot.addr,
-                    len: slot.len,
-                    base_addr: slot.base_addr,
-                }),
+                backing: KvReplicaBacking::CommittedSlot(committed_slot),
                 owner_local_indexed: true,
+                get_durable_reservation: None,
+                capacity_reservation,
                 tomb_tag,
             };
             return publish_completed_put_route(
@@ -1957,7 +2095,7 @@ pub async fn handle_grouped_batch_put_done(
     }
 }
 
-pub async fn handle_put_append_start(
+async fn handle_put_append_start_inner(
     view: MasterKvRouterView,
     req: MsgPack<PutAppendStartReq>,
     req_node_id: NodeID,
@@ -1970,11 +2108,11 @@ pub async fn handle_put_append_start(
         .kv_routes
         .get(&key)
         .map(|route| route.clone());
-    let current_route_still_needs_remote = route_snapshot
+    let current_outcome = route_snapshot
         .as_ref()
-        .map(|route| current_route_needs_remote_replica(route, &req_node_id, put_id))
-        .unwrap_or(false);
-    if !current_route_still_needs_remote {
+        .map(|route| current_route_append_outcome(route, &req_node_id, put_id))
+        .unwrap_or(PutAppendStartOutcome::Obsolete);
+    if current_outcome != PutAppendStartOutcome::Scheduled {
         if let Some(inflight) = view
             .master_kv_router()
             .inner()
@@ -1984,14 +2122,9 @@ pub async fn handle_put_append_start(
         {
             inflight._activity_lease.release_now();
         }
-        if req.serialize_part.demote_source_on_remote_complete {
-            view.master_kv_router()
-                .demote_owner_hot_cohort_if_recoverable(req_node_id.as_ref(), &key, put_id)
-                .await;
-        }
         return MsgPack {
             serialize_part: PutAppendStartResp {
-                scheduled: false,
+                outcome: current_outcome,
                 error_code: msg_and_error::OK,
                 error_json: String::new(),
                 ..Default::default()
@@ -2031,7 +2164,6 @@ pub async fn handle_put_append_start(
             req.serialize_part.preferred_sub_cluster.as_deref(),
             req.serialize_part.len,
             &excluded_nodes,
-            req.serialize_part.demote_source_on_remote_complete,
             req.serialize_part.protect_source_on_remote_complete,
         ) {
             Ok(reservation) => reservation,
@@ -2055,7 +2187,7 @@ pub async fn handle_put_append_start(
                 );
                 return MsgPack {
                     serialize_part: PutAppendStartResp {
-                        scheduled: false,
+                        outcome: PutAppendStartOutcome::RetryableNoSpace,
                         error_code: msg_and_error::OK,
                         error_json: String::new(),
                         ..Default::default()
@@ -2105,7 +2237,7 @@ pub async fn handle_put_append_start(
 
     MsgPack {
         serialize_part: PutAppendStartResp {
-            scheduled: true,
+            outcome: PutAppendStartOutcome::Scheduled,
             node_id: inflight.node_id.clone().into(),
             target_addr,
             target_base_addr,
@@ -2118,6 +2250,62 @@ pub async fn handle_put_append_start(
     }
 }
 
+pub async fn handle_put_append_start(
+    view: MasterKvRouterView,
+    req: MsgPack<PutAppendStartReq>,
+    req_node_id: NodeID,
+) -> MsgPack<PutAppendStartResp> {
+    handle_put_append_start_inner(view, req, req_node_id).await
+}
+
+pub async fn handle_batch_put_append_start(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPutAppendStartReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchPutAppendStartResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        let key = item.key.clone();
+        let put_id = item.put_id;
+        let resp = handle_put_append_start_inner(
+            view.clone(),
+            MsgPack {
+                serialize_part: PutAppendStartReq {
+                    key,
+                    put_id,
+                    len: item.len,
+                    preferred_sub_cluster: item.preferred_sub_cluster,
+                    protect_source_on_remote_complete: item.protect_source_on_remote_complete,
+                },
+                raw_bytes: Vec::new(),
+            },
+            req_node_id.clone(),
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchPutAppendStartItemResp {
+            key: item.key,
+            put_id: item.put_id,
+            outcome: part.outcome,
+            node_id: part.node_id,
+            target_addr: part.target_addr,
+            target_base_addr: part.target_base_addr,
+            len: part.len,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchPutAppendStartResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
 pub async fn handle_put_append_revoke(
     view: MasterKvRouterView,
     req: MsgPack<PutAppendRevokeReq>,
@@ -2142,7 +2330,7 @@ pub async fn handle_put_append_revoke(
     }
 }
 
-pub async fn handle_put_append_done(
+async fn handle_put_append_done_inner(
     view: MasterKvRouterView,
     req: MsgPack<PutAppendDoneReq>,
 ) -> MsgPack<PutAppendDoneResp> {
@@ -2185,17 +2373,13 @@ pub async fn handle_put_append_done(
         &key,
         inflight.put_id,
         inflight.node_id,
+        inflight.target_tomb_tag,
         allocation,
     );
     let appended = published.is_some();
     if let Some(event) = published {
         enqueue_post_route_maintenance(&view, event).await;
     }
-    if inflight.demote_source_on_remote_complete {
-        view.master_kv_router()
-            .demote_owner_hot_cohort_if_recoverable(inflight.source_node_id.as_ref(), &key, put_id)
-            .await;
-    }
     MsgPack {
         serialize_part: PutAppendDoneResp {
             appended,
@@ -2206,3 +2390,46 @@ pub async fn handle_put_append_done(
         raw_bytes: Vec::new(),
     }
 }
+
+pub async fn handle_put_append_done(
+    view: MasterKvRouterView,
+    req: MsgPack<PutAppendDoneReq>,
+) -> MsgPack<PutAppendDoneResp> {
+    handle_put_append_done_inner(view, req).await
+}
+
+pub async fn handle_batch_put_append_done(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPutAppendDoneReq>,
+) -> MsgPack<BatchPutAppendDoneResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        let key = item.key.clone();
+        let put_id = item.put_id;
+        let resp = handle_put_append_done_inner(
+            view.clone(),
+            MsgPack {
+                serialize_part: PutAppendDoneReq { key, put_id },
+                raw_bytes: Vec::new(),
+            },
+        )
+        .await;
+        let part = resp.serialize_part;
+        items.push(BatchPutAppendDoneItemResp {
+            key: item.key,
+            put_id: item.put_id,
+            appended: part.appended,
+            error_code: part.error_code,
+            error_json: part.error_json,
+        });
+    }
+    MsgPack {
+        serialize_part: BatchPutAppendDoneResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
index 8a4223c..39f2ee7 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
@@ -1,18 +1,19 @@
 use super::{KvReplicaBacking, MasterKvRouterView, NodeValueReplicaDesc};
 use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::master_kv_router::msg_pack::{
-    BatchOwnerReclaimReq, OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimItemResp,
-    OwnerReclaimItemState, OwnerReclaimPhase, OwnerReclaimReason,
+    BatchEvictOwnerSourceReq, BatchEvictOwnerSourceResp, BatchOwnerReclaimReq, OwnerReclaimBacking,
+    OwnerReclaimItem, OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase,
+    OwnerReclaimReason, OwnerSourceEvictionCohort, OwnerSourceEvictionCohortResp,
+    OwnerSourceEvictionOutcome,
 };
-use crate::memholder::MemholderManagerTrait;
 use crate::p2p::msg_pack::{MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, RPCCaller};
-use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
 use limit_thirdparty::tokio;
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::future::Future;
+use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 const OWNER_RECLAIM_RPC_TIMEOUT: Duration = Duration::from_secs(MIN_EXPLICIT_RPC_TIMEOUT_SECS);
 const OWNER_RECLAIM_MAX_BATCH: usize = 256;
@@ -64,14 +65,532 @@ mod timeout_contract_tests {
     }
 }
 
+#[cfg(test)]
+mod cohort_transaction_tests {
+    use super::*;
+    use crate::master_kv_router::msg_pack::{
+        OwnerSourceEvictionMember, PutAtomicGroup, PutAtomicGroupMember,
+    };
+    use crate::master_kv_router::{
+        CommittedSlotReplica, KvRouteInfo, MasterKeyActivityKind, MasterKeyActivityTable,
+        OneKvNodesRoutes,
+    };
+    use crate::master_seg_manager::NodeTombTag;
+    use parking_lot::RwLock;
+    use std::collections::HashMap;
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicU32;
+
+    fn item(key: &str, epoch: u64) -> OwnerReclaimItem {
+        OwnerReclaimItem {
+            key: key.to_string(),
+            put_id: (7, epoch as u32),
+            epoch,
+            backing: OwnerReclaimBacking::CommittedSlot {
+                grant_id: 1,
+                slot_index: epoch as u32,
+                slot_size: 4096,
+            },
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
+        }
+    }
+
+    #[test]
+    fn cohort_master_fences_roll_back_all_members_when_one_is_busy() {
+        let activity = Arc::new(MasterKeyActivityTable::default());
+        let items = vec![item("rank0", 1), item("rank1", 2)];
+        let _busy = activity
+            .reserve("rank1", MasterKeyActivityKind::Get, false)
+            .unwrap();
+
+        assert!(try_install_cohort_master_fences(&activity, &items).is_err());
+        assert!(!activity.has_reclaim("rank0"));
+        assert!(!activity.has_reclaim("rank1"));
+    }
+
+    #[test]
+    fn cohort_master_fences_install_and_clear_as_one_set() {
+        let activity = Arc::new(MasterKeyActivityTable::default());
+        let items = vec![item("rank0", 1), item("rank1", 2)];
+
+        try_install_cohort_master_fences(&activity, &items).unwrap();
+        assert!(activity.has_reclaim("rank0"));
+        assert!(activity.has_reclaim("rank1"));
+        for item in &items {
+            assert!(activity.clear_reclaim(item));
+        }
+    }
+
+    #[test]
+    fn master_capacity_origin_rejects_committed_slot_backing() {
+        let backing = KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+            owner_node_id: "gpu0".to_string().into(),
+            grant_id: 1,
+            slot_index: 2,
+            slot_size: 4096,
+            addr: 0,
+            len: 4096,
+            base_addr: 0,
+        });
+        assert_eq!(
+            master_allocation_capacity_weight(&backing),
+            Err(MasterCapacityPlanError::CommittedSlot),
+        );
+    }
+
+    fn source_member(
+        key: &str,
+        put_id: (u64, u32),
+        grant_id: u64,
+        slot_index: u32,
+    ) -> OwnerSourceEvictionMember {
+        OwnerSourceEvictionMember {
+            key: key.to_string(),
+            put_id,
+            backing: OwnerReclaimBacking::CommittedSlot {
+                grant_id,
+                slot_index,
+                slot_size: 4096,
+            },
+        }
+    }
+
+    fn source_route(
+        owner: &NodeID,
+        member: &OwnerSourceEvictionMember,
+        atomic_group: Option<Arc<PutAtomicGroup>>,
+        include_cpu_replica: bool,
+    ) -> Arc<OneKvNodesRoutes> {
+        let OwnerReclaimBacking::CommittedSlot {
+            grant_id,
+            slot_index,
+            slot_size,
+        } = &member.backing
+        else {
+            unreachable!()
+        };
+        let owner_replica = KvRouteInfo {
+            node_id: owner.clone(),
+            backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                owner_node_id: owner.clone(),
+                grant_id: *grant_id,
+                slot_index: *slot_index,
+                slot_size: *slot_size,
+                addr: 0,
+                len: *slot_size,
+                base_addr: 0,
+            }),
+            owner_local_indexed: true,
+            get_durable_reservation: None,
+            capacity_reservation: None,
+            tomb_tag: NodeTombTag::new(),
+        };
+        let mut replicas = HashMap::from([(owner.clone(), owner_replica)]);
+        if include_cpu_replica {
+            let cpu: NodeID = "cpu0".to_string().into();
+            replicas.insert(
+                cpu.clone(),
+                KvRouteInfo {
+                    node_id: cpu.clone(),
+                    backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                        owner_node_id: cpu,
+                        grant_id: 900 + *grant_id,
+                        slot_index: *slot_index,
+                        slot_size: *slot_size,
+                        addr: 0,
+                        len: *slot_size,
+                        base_addr: 0,
+                    }),
+                    owner_local_indexed: false,
+                    get_durable_reservation: None,
+                    capacity_reservation: None,
+                    tomb_tag: NodeTombTag::new(),
+                },
+            );
+        }
+        Arc::new(OneKvNodesRoutes {
+            put_id: member.put_id,
+            lease_id: None,
+            atomic_group,
+            nodes_replicas: RwLock::new(replicas),
+            get_durable_slots_used: AtomicU32::new(0),
+        })
+    }
+
+    fn source_reclaim_item(member: &OwnerSourceEvictionMember) -> OwnerReclaimItem {
+        OwnerReclaimItem {
+            key: member.key.clone(),
+            put_id: member.put_id,
+            epoch: 1,
+            backing: member.backing.clone(),
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
+        }
+    }
+
+    #[test]
+    fn exact_source_plan_accepts_with_or_without_a_cpu_replica() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let member = source_member("single", (10, 1), 7, 3);
+        let cohort = OwnerSourceEvictionCohort {
+            members: vec![member.clone()],
+        };
+
+        for include_cpu_replica in [false, true] {
+            let route = source_route(&owner, &member, None, include_cpu_replica);
+            let plan = plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| {
+                (key == "single").then(|| route.clone())
+            });
+            match plan {
+                OwnerSourceCohortPlan::Ready {
+                    members,
+                    all_sources_present,
+                } => {
+                    assert!(all_sources_present);
+                    assert_eq!(members.len(), 1);
+                    assert_eq!(members[0].key, "single");
+                    assert_eq!(members[0].expected_backing, Some(member.backing.clone()));
+                }
+                _ => panic!("exact current owner source must be accepted"),
+            }
+        }
+    }
+
+    #[test]
+    fn exact_source_removal_deletes_only_gpu_when_cpu_exists_and_last_route_otherwise() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let member = source_member("with-cpu", (10, 2), 7, 4);
+        let routes = dashmap::DashMap::new();
+        routes.insert(
+            member.key.clone(),
+            source_route(&owner, &member, None, true),
+        );
+        let removed =
+            remove_exact_owner_source_route(&routes, &owner, &source_reclaim_item(&member))
+                .expect("exact GPU source must be removed");
+        assert!(!removed.removed_last_route);
+        let remaining = routes.get(&member.key).expect("CPU route must remain");
+        assert!(!remaining.nodes_replicas.read().contains_key(&owner));
+        assert!(remaining.nodes_replicas.read().contains_key("cpu0"));
+
+        let last = source_member("last", (10, 3), 7, 5);
+        routes.insert(last.key.clone(), source_route(&owner, &last, None, false));
+        let removed = remove_exact_owner_source_route(&routes, &owner, &source_reclaim_item(&last))
+            .expect("last exact GPU source must be removed");
+        assert!(removed.removed_last_route);
+        assert!(!routes.contains_key(&last.key));
+
+        let stale = source_member("stale", (10, 4), 8, 6);
+        routes.insert(stale.key.clone(), source_route(&owner, &stale, None, false));
+        let wrong_identity = source_member("stale", stale.put_id, 999, 6);
+        assert!(
+            remove_exact_owner_source_route(
+                &routes,
+                &owner,
+                &source_reclaim_item(&wrong_identity),
+            )
+            .is_none()
+        );
+        assert!(routes.contains_key(&stale.key));
+    }
+
+    #[test]
+    fn partial_source_absence_is_replay_only_and_all_absent_is_completed() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let a = source_member("a", (11, 0), 8, 0);
+        let b = source_member("b", (11, 1), 8, 1);
+        let cohort = OwnerSourceEvictionCohort {
+            members: vec![a.clone(), b.clone()],
+        };
+        let group = Arc::new(PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: a.key.clone(),
+                    put_id: a.put_id,
+                },
+                PutAtomicGroupMember {
+                    key: b.key.clone(),
+                    put_id: b.put_id,
+                },
+            ],
+        });
+        let route_a = source_route(&owner, &a, Some(group), false);
+
+        match plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| {
+            (key == "a").then(|| route_a.clone())
+        }) {
+            OwnerSourceCohortPlan::Ready {
+                all_sources_present,
+                ..
+            } => assert!(!all_sources_present),
+            _ => panic!("a partially removed accepted cohort must be recognized as replay-only"),
+        }
+        assert!(matches!(
+            plan_exact_owner_source_cohort_with(&owner, &cohort, &|_| None),
+            OwnerSourceCohortPlan::Completed(_)
+        ));
+    }
+
+    #[test]
+    fn one_stale_or_inconsistent_member_rejects_the_whole_source_cohort() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let a = source_member("a", (12, 0), 9, 0);
+        let b = source_member("b", (12, 1), 9, 1);
+        let cohort = OwnerSourceEvictionCohort {
+            members: vec![a.clone(), b.clone()],
+        };
+        let group = Arc::new(PutAtomicGroup {
+            members: vec![
+                PutAtomicGroupMember {
+                    key: a.key.clone(),
+                    put_id: a.put_id,
+                },
+                PutAtomicGroupMember {
+                    key: b.key.clone(),
+                    put_id: b.put_id,
+                },
+            ],
+        });
+        let route_a = source_route(&owner, &a, Some(group.clone()), false);
+        let changed_b = source_member("b", b.put_id, 99, 1);
+        let route_b_with_changed_backing =
+            source_route(&owner, &changed_b, Some(group.clone()), false);
+        let stale_backing_plan =
+            plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| match key {
+                "a" => Some(route_a.clone()),
+                "b" => Some(route_b_with_changed_backing.clone()),
+                _ => None,
+            });
+        assert!(matches!(
+            stale_backing_plan,
+            OwnerSourceCohortPlan::Stale(_)
+        ));
+
+        let route_b_without_group = source_route(&owner, &b, None, false);
+        let inconsistent_group_plan =
+            plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| match key {
+                "a" => Some(route_a.clone()),
+                "b" => Some(route_b_without_group.clone()),
+                _ => None,
+            });
+        assert!(matches!(
+            inconsistent_group_plan,
+            OwnerSourceCohortPlan::Rejected(_)
+        ));
+    }
+}
+
+/// Why an entry entered the shared safe-reclaim pipeline.
+///
+/// Only `MasterAllocationCapacity` may originate from the master resident
+/// cache's Size listener. `OwnerCapacityEviction` is an exact source-deletion
+/// request selected by the owner and may resolve to a CommittedSlot.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum EvictionReclaimOrigin {
+    MasterAllocationCapacity,
+    OwnerCapacityEviction,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum EnqueueEvictionReclaimResult {
+    Accepted,
+    AlreadyInProgress,
+    PartialOverlap,
+    NotInProgress,
+    Closed,
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub(crate) struct EvictionReclaimIdentity {
+    owner_node_id: NodeIDString,
+    owner_node_start_time: Option<i64>,
+    key: String,
+    put_id: (u64, u32),
+    weight_bytes: u32,
+    expected_backing: Option<OwnerReclaimBacking>,
+}
+
 #[derive(Clone, Debug)]
-pub(crate) struct EvictionReclaimRequest {
-    pub owner_node_id: NodeIDString,
+pub(crate) struct EvictionReclaimMember {
     pub key: String,
     pub desc: NodeValueReplicaDesc,
+    pub expected_backing: Option<OwnerReclaimBacking>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct EvictionReclaimRequest {
+    pub owner_node_id: NodeIDString,
+    pub owner_node_start_time: Option<i64>,
+    pub members: Vec<EvictionReclaimMember>,
+    pub origin: EvictionReclaimOrigin,
     pub retry_count: u32,
 }
 
+impl EvictionReclaimRequest {
+    pub(crate) fn identities(&self) -> Vec<EvictionReclaimIdentity> {
+        self.members
+            .iter()
+            .map(|member| EvictionReclaimIdentity {
+                owner_node_id: self.owner_node_id.clone(),
+                owner_node_start_time: self.owner_node_start_time,
+                key: member.key.clone(),
+                put_id: member.desc.put_id,
+                weight_bytes: member.desc.weight_bytes,
+                expected_backing: member.expected_backing.clone(),
+            })
+            .collect()
+    }
+
+    pub(crate) fn weight_bytes(&self) -> u64 {
+        self.members
+            .iter()
+            .map(|member| u64::from(member.desc.weight_bytes))
+            .fold(0u64, u64::saturating_add)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum MasterCapacityPlanError {
+    RouteChanged,
+    InvalidCohort,
+    WrongRole,
+    CommittedSlot,
+}
+
+fn master_allocation_capacity_weight(
+    backing: &KvReplicaBacking,
+) -> Result<u32, MasterCapacityPlanError> {
+    match backing {
+        KvReplicaBacking::Allocation(allocation) => {
+            Ok(u32::try_from(allocation.capcity()).unwrap_or(u32::MAX))
+        }
+        KvReplicaBacking::CommittedSlot(_) => Err(MasterCapacityPlanError::CommittedSlot),
+    }
+}
+
+fn allocation_member_from_route(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    key: &str,
+) -> Result<
+    (
+        EvictionReclaimMember,
+        std::sync::Arc<super::OneKvNodesRoutes>,
+    ),
+    MasterCapacityPlanError,
+> {
+    let route = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .get(key)
+        .map(|entry| entry.clone())
+        .ok_or(MasterCapacityPlanError::RouteChanged)?;
+    if route.lease_id.is_some() {
+        return Err(MasterCapacityPlanError::RouteChanged);
+    }
+    let replicas = route.nodes_replicas.read();
+    let replica = replicas
+        .get(owner)
+        .filter(|replica| !replica.tomb_tag.is_tomb())
+        .ok_or(MasterCapacityPlanError::RouteChanged)?;
+    if replica.owner_local_indexed {
+        return Err(MasterCapacityPlanError::WrongRole);
+    }
+    let weight_bytes = master_allocation_capacity_weight(&replica.backing)?;
+    drop(replicas);
+    Ok((
+        EvictionReclaimMember {
+            key: key.to_string(),
+            desc: NodeValueReplicaDesc {
+                weight_bytes,
+                put_id: route.put_id,
+            },
+            expected_backing: None,
+        },
+        route,
+    ))
+}
+
+/// Expand one master Size event by point-looking up its atomic/TP cohort.
+/// This function never iterates the resident cache or global route table.
+fn plan_master_allocation_capacity_cohort(
+    view: &MasterKvRouterView,
+    request: &EvictionReclaimRequest,
+) -> Result<Vec<EvictionReclaimMember>, MasterCapacityPlanError> {
+    if request.origin != EvictionReclaimOrigin::MasterAllocationCapacity
+        || request.members.is_empty()
+    {
+        return Err(MasterCapacityPlanError::WrongRole);
+    }
+    let owner: NodeID = request.owner_node_id.clone().into();
+    let anchor = &request.members[0];
+    let (current_anchor, anchor_route) = allocation_member_from_route(view, &owner, &anchor.key)?;
+    if current_anchor.desc.put_id != anchor.desc.put_id
+        || current_anchor.desc.weight_bytes != anchor.desc.weight_bytes
+    {
+        return Err(MasterCapacityPlanError::RouteChanged);
+    }
+    let mut cohort_keys =
+        super::current_tp_cohort_keys(&anchor.key, &anchor_route, &current_anchor.desc)
+            .map_err(|_| MasterCapacityPlanError::InvalidCohort)?;
+    cohort_keys.sort_unstable();
+    cohort_keys.dedup();
+    if cohort_keys.is_empty() {
+        return Err(MasterCapacityPlanError::InvalidCohort);
+    }
+
+    let mut members = Vec::with_capacity(cohort_keys.len());
+    for key in &cohort_keys {
+        let (member, route) = allocation_member_from_route(view, &owner, key)?;
+        let mut peer_keys = super::current_tp_cohort_keys(key, &route, &member.desc)
+            .map_err(|_| MasterCapacityPlanError::InvalidCohort)?;
+        peer_keys.sort_unstable();
+        peer_keys.dedup();
+        if peer_keys != cohort_keys {
+            return Err(MasterCapacityPlanError::InvalidCohort);
+        }
+        members.push(member);
+    }
+    Ok(members)
+}
+
+fn detach_present_capacity_cohort_siblings(
+    view: &MasterKvRouterView,
+    owner_node_id: &str,
+    members: &[EvictionReclaimMember],
+) -> Result<Vec<EvictionReclaimMember>, MasterCapacityPlanError> {
+    let cache = view
+        .master_kv_router()
+        .get_node_cache_controller(owner_node_id)
+        .ok_or(MasterCapacityPlanError::RouteChanged)?;
+    let mut expected = HashMap::new();
+    for member in members {
+        if let Some(cached) = cache.get(&member.key) {
+            if cached.put_id != member.desc.put_id
+                || cached.weight_bytes != member.desc.weight_bytes
+            {
+                return Err(MasterCapacityPlanError::RouteChanged);
+            }
+            expected.insert(member.key.clone(), member.desc.clone());
+        }
+    }
+    if expected.is_empty() {
+        return Ok(Vec::new());
+    }
+    super::take_exact_cache_entries(&cache, &expected)
+        .map(|removed| {
+            removed
+                .into_iter()
+                .map(|(key, desc)| EvictionReclaimMember {
+                    key,
+                    desc,
+                    expected_backing: None,
+                })
+                .collect()
+        })
+        .ok_or(MasterCapacityPlanError::RouteChanged)
+}
+
 fn route_item(
     view: &MasterKvRouterView,
     owner_node_id: &NodeID,
@@ -111,32 +630,7 @@ fn route_item(
         }
         KvReplicaBacking::CommittedSlot(_) => return None,
     };
-    let has_other_live_replica = replicas
-        .iter()
-        .any(|(node_id, replica)| node_id != owner_node_id && !replica.tomb_tag.is_tomb());
     drop(replicas);
-    if reason == OwnerReclaimReason::Reserve {
-        let normally_recoverable = has_other_live_replica
-            && (view
-                .master_kv_router()
-                .owner_cache_allows_unrecoverable_eviction(owner_node_id.as_ref())
-                || {
-                    let desc = NodeValueReplicaDesc {
-                        weight_bytes: 0,
-                        put_id: route.put_id,
-                    };
-                    view.master_kv_router()
-                        .eviction_cache_entry_recoverable_status(owner_node_id.as_ref(), key, &desc)
-                        == super::RecoverableReplicaStatus::Recoverable
-                });
-        if !normally_recoverable
-            && !view
-                .master_kv_router()
-                .owner_cache_allows_unrecoverable_reserve_pressure_eviction(owner_node_id.as_ref())
-        {
-            return None;
-        }
-    }
     Some(OwnerReclaimItem {
         key: key.to_string(),
         put_id: route.put_id,
@@ -146,15 +640,6 @@ fn route_item(
     })
 }
 
-fn master_has_holder(view: &MasterKvRouterView, key: &str) -> bool {
-    view.master_kv_router()
-        .inner()
-        .get_holding
-        .inner()
-        .iter()
-        .any(|entry| entry.value().key == key)
-}
-
 fn item_still_valid(view: &MasterKvRouterView, owner: &NodeID, item: &OwnerReclaimItem) -> bool {
     if !view
         .master_kv_router()
@@ -250,6 +735,7 @@ fn clear_master_fence(view: &MasterKvRouterView, item: &OwnerReclaimItem) {
     }
 }
 
+#[cfg(test)]
 async fn abort_prepared(
     view: &MasterKvRouterView,
     owner: &NodeID,
@@ -291,6 +777,7 @@ async fn abort_prepared(
     }
 }
 
+#[cfg(test)]
 fn spawn_abort_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<OwnerReclaimItem>) {
     if items.is_empty() {
         return;
@@ -365,55 +852,351 @@ fn reclaim_backing_matches(replica: &super::KvRouteInfo, expected: &OwnerReclaim
     }
 }
 
-fn remove_reclaimed_replica(
+fn owner_source_member_weight(backing: &OwnerReclaimBacking) -> Option<u32> {
+    match backing {
+        OwnerReclaimBacking::CommittedSlot { slot_size, .. } => u32::try_from(*slot_size).ok(),
+        // Allocation does not carry an address/generation identity in the
+        // current wire contract, so accepting it would not be an exact delete.
+        OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation => None,
+    }
+}
+
+enum OwnerSourceCohortPlan {
+    Ready {
+        members: Vec<EvictionReclaimMember>,
+        all_sources_present: bool,
+    },
+    Completed(&'static str),
+    Stale(String),
+    Rejected(String),
+}
+
+fn plan_exact_owner_source_cohort(
     view: &MasterKvRouterView,
     owner: &NodeID,
-    item: &OwnerReclaimItem,
-) -> bool {
-    if !view
-        .master_kv_router()
-        .inner()
-        .key_activity
-        .reclaim_matches(item)
-    {
-        return false;
+    cohort: &OwnerSourceEvictionCohort,
+) -> OwnerSourceCohortPlan {
+    plan_exact_owner_source_cohort_with(owner, cohort, &|key| {
+        view.master_kv_router()
+            .inner()
+            .kv_routes
+            .get(key)
+            .map(|entry| entry.clone())
+    })
+}
+
+fn plan_exact_owner_source_cohort_with(
+    owner: &NodeID,
+    cohort: &OwnerSourceEvictionCohort,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
+) -> OwnerSourceCohortPlan {
+    if cohort.members.is_empty() {
+        return OwnerSourceCohortPlan::Rejected("empty source-eviction cohort".to_string());
+    }
+
+    let mut expected_keys = cohort
+        .members
+        .iter()
+        .map(|member| member.key.clone())
+        .collect::<Vec<_>>();
+    expected_keys.sort_unstable();
+    expected_keys.dedup();
+    if expected_keys.len() != cohort.members.len() {
+        return OwnerSourceCohortPlan::Rejected(
+            "source-eviction cohort contains duplicate keys".to_string(),
+        );
+    }
+
+    let mut planned = Vec::with_capacity(cohort.members.len());
+    let mut absent_sources = 0usize;
+    for member in &cohort.members {
+        let Some(weight_bytes) = owner_source_member_weight(&member.backing) else {
+            return OwnerSourceCohortPlan::Rejected(format!(
+                "source backing is not an exact committed slot: key={}",
+                member.key
+            ));
+        };
+        let desc = NodeValueReplicaDesc {
+            weight_bytes,
+            put_id: member.put_id,
+        };
+        planned.push(EvictionReclaimMember {
+            key: member.key.clone(),
+            desc: desc.clone(),
+            expected_backing: Some(member.backing.clone()),
+        });
+
+        let Some(route) = route_lookup(&member.key) else {
+            absent_sources += 1;
+            continue;
+        };
+        if route.put_id != member.put_id {
+            return OwnerSourceCohortPlan::Stale(format!(
+                "route version changed: key={} expected=({},{}) current=({},{})",
+                member.key, member.put_id.0, member.put_id.1, route.put_id.0, route.put_id.1,
+            ));
+        }
+        if route.lease_id.is_some() {
+            return OwnerSourceCohortPlan::Rejected(format!(
+                "leased route is not cache-evictable: key={}",
+                member.key
+            ));
+        }
+        let replica_matches = {
+            let replicas = route.nodes_replicas.read();
+            match replicas.get(owner) {
+                Some(replica) if !replica.tomb_tag.is_tomb() => {
+                    if !replica.owner_local_indexed {
+                        return OwnerSourceCohortPlan::Rejected(format!(
+                            "source route is not owner-local indexed: key={}",
+                            member.key
+                        ));
+                    }
+                    reclaim_backing_matches(replica, &member.backing)
+                }
+                _ => {
+                    absent_sources += 1;
+                    continue;
+                }
+            }
+        };
+        if !replica_matches {
+            return OwnerSourceCohortPlan::Stale(format!(
+                "source backing changed: key={} put_id=({},{})",
+                member.key, member.put_id.0, member.put_id.1
+            ));
+        }
+
+        let mut route_cohort = match super::current_tp_cohort_keys(&member.key, &route, &desc) {
+            Ok(keys) => keys,
+            Err(_) => {
+                return OwnerSourceCohortPlan::Rejected(format!(
+                    "master route has an invalid TP/atomic cohort: key={}",
+                    member.key
+                ));
+            }
+        };
+        route_cohort.sort_unstable();
+        route_cohort.dedup();
+        if route_cohort != expected_keys {
+            return OwnerSourceCohortPlan::Rejected(format!(
+                "owner did not submit the complete TP/atomic cohort: key={} expected_members={} route_members={}",
+                member.key,
+                expected_keys.len(),
+                route_cohort.len(),
+            ));
+        }
+    }
+
+    if absent_sources == cohort.members.len() {
+        OwnerSourceCohortPlan::Completed("all exact source replicas are already absent")
+    } else if absent_sources != 0 {
+        // This can be observed while an accepted cohort is between individual
+        // route removals. The exact inflight registration below distinguishes
+        // that case from a malformed new request.
+        OwnerSourceCohortPlan::Ready {
+            members: planned,
+            all_sources_present: false,
+        }
+    } else {
+        OwnerSourceCohortPlan::Ready {
+            members: planned,
+            all_sources_present: true,
+        }
     }
-    let _route_guard = view.master_kv_router().inner().route_lifetime_lock.lock();
-    let Some(route) = view
+}
+
+pub(crate) async fn handle_batch_evict_owner_source(
+    view: &MasterKvRouterView,
+    req: MsgPack<BatchEvictOwnerSourceReq>,
+    owner: NodeID,
+) -> MsgPack<BatchEvictOwnerSourceResp> {
+    let operation_id = req.serialize_part.operation_id;
+    let counters = view
         .master_kv_router()
-        .inner()
-        .kv_routes
-        .get(&item.key)
-        .map(|route| route.clone())
-    else {
-        return true;
-    };
+        .eviction_reclaim_counters(owner.as_ref());
+    counters
+        .source_evict_rpc_requests
+        .fetch_add(1, Ordering::Relaxed);
+    counters.source_evict_cohorts.fetch_add(
+        u64::try_from(req.serialize_part.cohorts.len()).unwrap_or(u64::MAX),
+        Ordering::Relaxed,
+    );
+    let requested_bytes = req
+        .serialize_part
+        .cohorts
+        .iter()
+        .flat_map(|cohort| cohort.members.iter())
+        .filter_map(|member| owner_source_member_weight(&member.backing))
+        .map(u64::from)
+        .fold(0u64, u64::saturating_add);
+    counters
+        .source_evict_requested_bytes
+        .fetch_add(requested_bytes, Ordering::Relaxed);
+    let current_generation = view
+        .cluster_manager()
+        .get_member_info_cached(owner.as_ref())
+        .map(|member| member.node_start_time);
+    if current_generation != Some(req.serialize_part.owner_node_start_time) {
+        counters.source_evict_rejected.fetch_add(
+            u64::try_from(req.serialize_part.cohorts.len()).unwrap_or(u64::MAX),
+            Ordering::Relaxed,
+        );
+        let err = KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "owner source-eviction generation mismatch: owner={} requested={} current={:?}",
+                owner, req.serialize_part.owner_node_start_time, current_generation
+            ),
+        });
+        return MsgPack {
+            serialize_part: BatchEvictOwnerSourceResp {
+                operation_id,
+                cohorts: Vec::new(),
+                error_code: err.code(),
+                error_json: err.to_json(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+
+    let mut responses = Vec::with_capacity(req.serialize_part.cohorts.len());
+    for (index, cohort) in req.serialize_part.cohorts.iter().enumerate() {
+        let (outcome, detail) = match plan_exact_owner_source_cohort(view, &owner, cohort) {
+            OwnerSourceCohortPlan::Completed(detail) => {
+                (OwnerSourceEvictionOutcome::Completed, detail.to_string())
+            }
+            OwnerSourceCohortPlan::Stale(detail) => (OwnerSourceEvictionOutcome::Stale, detail),
+            OwnerSourceCohortPlan::Rejected(detail) => {
+                (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
+            }
+            OwnerSourceCohortPlan::Ready {
+                members,
+                all_sources_present,
+            } => {
+                match view
+                    .master_kv_router()
+                    .enqueue_owner_capacity_eviction_cohort(
+                        owner.as_ref().to_string(),
+                        req.serialize_part.owner_node_start_time,
+                        members,
+                        all_sources_present,
+                    ) {
+                    EnqueueEvictionReclaimResult::Accepted => (
+                        OwnerSourceEvictionOutcome::Accepted,
+                        "exact source cohort accepted by reclaim pipeline".to_string(),
+                    ),
+                    EnqueueEvictionReclaimResult::AlreadyInProgress => (
+                        OwnerSourceEvictionOutcome::AlreadyInProgress,
+                        "same exact source cohort is already in progress".to_string(),
+                    ),
+                    EnqueueEvictionReclaimResult::PartialOverlap => (
+                        OwnerSourceEvictionOutcome::RetryableBusy,
+                        "source cohort partially overlaps another reclaim transaction".to_string(),
+                    ),
+                    EnqueueEvictionReclaimResult::NotInProgress => (
+                        OwnerSourceEvictionOutcome::Stale,
+                        "partially absent source cohort is not an in-progress replay".to_string(),
+                    ),
+                    EnqueueEvictionReclaimResult::Closed => (
+                        OwnerSourceEvictionOutcome::RetryableBusy,
+                        "source reclaim actor is unavailable".to_string(),
+                    ),
+                }
+            }
+        };
+        let outcome_counter = match outcome {
+            OwnerSourceEvictionOutcome::Accepted => &counters.source_evict_accepted,
+            OwnerSourceEvictionOutcome::AlreadyInProgress => &counters.source_evict_in_progress,
+            OwnerSourceEvictionOutcome::Completed => &counters.source_evict_completed,
+            OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified => {
+                &counters.source_evict_retryable_busy
+            }
+            OwnerSourceEvictionOutcome::Stale => &counters.source_evict_stale,
+            OwnerSourceEvictionOutcome::RejectedNotEvictable => &counters.source_evict_rejected,
+        };
+        outcome_counter.fetch_add(1, Ordering::Relaxed);
+        responses.push(OwnerSourceEvictionCohortResp {
+            cohort_index: u32::try_from(index).unwrap_or(u32::MAX),
+            outcome,
+            detail,
+        });
+    }
+
+    MsgPack {
+        serialize_part: BatchEvictOwnerSourceResp {
+            operation_id,
+            cohorts: responses,
+            error_code: OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+struct RemovedOwnerSource {
+    desc: NodeValueReplicaDesc,
+    removed_last_route: bool,
+}
+
+fn remove_exact_owner_source_route(
+    routes: &dashmap::DashMap<String, Arc<super::OneKvNodesRoutes>>,
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+) -> Option<RemovedOwnerSource> {
+    let route = routes.get(&item.key).map(|route| route.clone())?;
     if route.put_id != item.put_id {
-        return true;
+        return None;
     }
-    let removed = {
+    let removed_desc = {
         let mut replicas = route.nodes_replicas.write();
         let Some(replica) = replicas.get(owner) else {
-            return true;
+            return None;
         };
         if !reclaim_backing_matches(replica, &item.backing) {
-            // This backing is no longer advertised by the fenced route version.
-            return true;
+            return None;
         }
-        replicas.remove(owner).is_some()
+        let desc = NodeValueReplicaDesc {
+            weight_bytes: u32::try_from(replica.backing.capacity_bytes()).unwrap_or(u32::MAX),
+            put_id: route.put_id,
+        };
+        replicas.remove(owner).map(|_| desc)
     };
-    if !removed {
-        return true;
-    }
+    let removed_desc = removed_desc?;
 
-    if route.nodes_replicas.read().is_empty() {
-        let route_removed = view
-            .master_kv_router()
-            .inner()
-            .kv_routes
-            .remove_if(&item.key, |_, current| current.put_id == item.put_id)
-            .is_some();
-        if route_removed && view.master_kv_router().prefix_index_enabled() {
+    let removed_last_route = if route.nodes_replicas.read().is_empty() {
+        routes
+            .remove_if(&item.key, |_, current| {
+                Arc::ptr_eq(current, &route)
+                    && current.put_id == item.put_id
+                    && current.nodes_replicas.read().is_empty()
+            })
+            .is_some()
+    } else {
+        false
+    };
+    Some(RemovedOwnerSource {
+        desc: removed_desc,
+        removed_last_route,
+    })
+}
+
+fn remove_reclaimed_replica(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+) -> bool {
+    if !view
+        .master_kv_router()
+        .inner()
+        .key_activity
+        .reclaim_matches(item)
+    {
+        return false;
+    }
+    let removed =
+        remove_exact_owner_source_route(&view.master_kv_router().inner().kv_routes, owner, item);
+    if let Some(removed) = removed {
+        if removed.removed_last_route && view.master_kv_router().prefix_index_enabled() {
             let view_task = view.clone();
             let key = item.key.clone();
             let put_id = item.put_id;
@@ -428,15 +1211,23 @@ fn remove_reclaimed_replica(
                 tree.remove(&key, put_id);
             });
         }
+        if let Some(cache) = view
+            .master_kv_router()
+            .inner()
+            .node_kv_cache_controller
+            .get(owner.as_ref())
+        {
+            let _ = super::remove_exact_cache_entry(cache.value(), &item.key, &removed.desc);
+        }
+        if let Some(cache) = view
+            .master_kv_router()
+            .inner()
+            .node_writeback_tier1_controller
+            .get(owner.as_ref())
+        {
+            let _ = super::remove_exact_cache_entry(cache.value(), &item.key, &removed.desc);
+        }
     }
-    if let Some(cache) = view
-        .master_kv_router()
-        .get_node_cache_controller(owner.as_ref())
-    {
-        let _ = cache.remove(&item.key);
-    }
-    view.master_kv_router()
-        .remove_node_writeback_tier1_entry(owner.as_ref(), &item.key);
     true
 }
 
@@ -572,6 +1363,7 @@ fn spawn_finalize_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<Owne
     });
 }
 
+#[cfg(test)]
 async fn reclaim_items(
     view: &MasterKvRouterView,
     owner: &NodeID,
@@ -582,14 +1374,6 @@ async fn reclaim_items(
         .eviction_reclaim_counters(owner.as_ref());
     let mut fenced = Vec::new();
     for item in candidates {
-        if master_has_holder(view, &item.key) {
-            // A completed get holder keeps an Allocation alive after its route disappears. It is
-            // not a reclaim exclusion: owner Prepare is the authority that fences the local index
-            // and rejects reclaim only while a real MemoryInfo reader is still active.
-            counters
-                .master_get_holder_observed
-                .fetch_add(1, Ordering::Relaxed);
-        }
         match view
             .master_kv_router()
             .inner()
@@ -688,11 +1472,6 @@ async fn reclaim_items(
 
     let mut invalid_prepared = Vec::new();
     prepared.retain(|item| {
-        if master_has_holder(view, &item.key) {
-            counters
-                .master_get_holder_observed
-                .fetch_add(1, Ordering::Relaxed);
-        }
         let valid = item_still_valid(view, owner, item);
         if !valid {
             counters.route_changed.fetch_add(1, Ordering::Relaxed);
@@ -733,85 +1512,223 @@ async fn reclaim_items(
     reclaimed
 }
 
-fn collect_reserve_candidates(
+fn clear_master_fences(view: &MasterKvRouterView, items: &[OwnerReclaimItem]) {
+    for item in items {
+        clear_master_fence(view, item);
+    }
+}
+
+fn try_install_cohort_master_fences(
+    activity: &super::MasterKeyActivityTable,
+    items: &[OwnerReclaimItem],
+) -> Result<(), (usize, super::MasterKeyActivitySnapshot)> {
+    let mut installed = Vec::with_capacity(items.len());
+    for (index, item) in items.iter().enumerate() {
+        match activity.try_install_reclaim(item) {
+            Ok(()) => installed.push(item),
+            Err(snapshot) => {
+                for installed_item in installed {
+                    assert!(activity.clear_reclaim(installed_item));
+                }
+                return Err((index, snapshot));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Reclaim one TP/atomic cohort as a transaction.
+///
+/// Before the first owner Commit, any failed fence/validation/Prepare rolls
+/// the entire cohort back.  Once a response (including an Abort response)
+/// proves that any member was committed, rollback is impossible; the same
+/// transaction retains every master fence and keeps driving the remaining
+/// members until all are committed, then removes/finalizes the whole cohort.
+async fn reclaim_cohort_items(
     view: &MasterKvRouterView,
     owner: &NodeID,
-    slot_size: u64,
-    limit: usize,
-) -> Vec<OwnerReclaimItem> {
-    let mut candidates = Vec::new();
-    // Moka iteration may synchronously drain cache maintenance and eviction listeners. Under
-    // pressure that made a 256-item candidate lookup take seconds. Route metadata is the
-    // reclaim authority, so snapshot its keys and validate candidates directly instead.
-    let route_keys = view
+    items: Vec<OwnerReclaimItem>,
+) -> u32 {
+    if items.is_empty() {
+        return 0;
+    }
+    let counters = view
         .master_kv_router()
-        .inner()
-        .kv_routes
+        .eviction_reclaim_counters(owner.as_ref());
+    if let Err((failed_index, activity)) =
+        try_install_cohort_master_fences(&view.master_kv_router().inner().key_activity, &items)
+    {
+        counters
+            .master_activity_deferred
+            .fetch_add(1, Ordering::Relaxed);
+        tracing::trace!(
+            "cohort reclaim deferred by master activity: owner={} key={} puts={} gets={} replicas={} reclaim_installed={}",
+            owner,
+            items[failed_index].key,
+            activity.puts,
+            activity.gets,
+            activity.replicas,
+            activity.reclaim_installed,
+        );
+        return 0;
+    }
+    let fenced = items;
+    if fenced
         .iter()
-        .map(|route| route.key().clone())
-        .collect::<Vec<_>>();
-    for key in route_keys {
-        if candidates.len() >= limit {
-            break;
-        }
-        if !view
-            .master_kv_router()
-            .inner()
-            .key_activity
-            .is_quiescent(&key)
+        .any(|item| !item_still_valid(view, owner, item))
+    {
+        clear_master_fences(view, &fenced);
+        return 0;
+    }
+
+    let (master_only, owner_coordinated) = partition_reclaim_coordination(fenced.clone());
+    if owner_coordinated.is_empty() {
+        // All master-owned allocations are fenced and revalidated before the
+        // first route mutation, so no member can be admitted independently.
+        if master_only.len() != fenced.len()
+            || master_only
+                .iter()
+                .any(|item| !item_still_valid(view, owner, item))
         {
-            continue;
+            clear_master_fences(view, &fenced);
+            return 0;
         }
-        if let Some(item) = route_item(
-            view,
+        let reclaimed = finish_unindexed_allocations(view, owner, master_only);
+        counters
+            .completed
+            .fetch_add(u64::from(reclaimed), Ordering::Relaxed);
+        return reclaimed;
+    }
+    if !master_only.is_empty() || owner_coordinated.len() != fenced.len() {
+        tracing::error!(
+            "BUG: one reclaim cohort mixed master-only and owner-coordinated backings: owner={} cohort={} master_only={} owner_coordinated={}",
             owner,
-            &key,
-            None,
-            Some(slot_size),
-            OwnerReclaimReason::Reserve,
-            view.master_kv_router().next_owner_reclaim_epoch(),
-        ) {
-            candidates.push(item);
-        }
+            fenced.len(),
+            master_only.len(),
+            owner_coordinated.len(),
+        );
+        clear_master_fences(view, &fenced);
+        return 0;
     }
-    candidates
-}
 
-async fn reclaim_reserve_candidate_batches<F, Fut>(
-    candidates: Vec<OwnerReclaimItem>,
-    required_free_slots: u32,
-    mut reclaim_batch: F,
-) -> (u32, usize)
-where
-    F: FnMut(Vec<OwnerReclaimItem>) -> Fut,
-    Fut: Future<Output = u32>,
-{
-    let mut reclaimed = 0u32;
-    let mut scanned_candidates = 0usize;
-    while reclaimed < required_free_slots && scanned_candidates < candidates.len() {
-        let remaining_slots = required_free_slots.saturating_sub(reclaimed);
-        let batch_len = usize::try_from(remaining_slots)
-            .unwrap_or(usize::MAX)
-            .min(candidates.len() - scanned_candidates);
-        let batch_end = scanned_candidates + batch_len;
-        let batch = candidates[scanned_candidates..batch_end].to_vec();
-        scanned_candidates = batch_end;
-
-        let batch_size = u32::try_from(batch.len()).unwrap_or(u32::MAX);
-        let batch_reclaimed = reclaim_batch(batch).await;
-        debug_assert!(batch_reclaimed <= batch_size);
-        reclaimed = reclaimed.saturating_add(batch_reclaimed.min(batch_size));
-    }
-    (reclaimed, scanned_candidates)
+    let all_by_key = owner_coordinated
+        .iter()
+        .cloned()
+        .map(|item| (item.key.clone(), item))
+        .collect::<HashMap<_, _>>();
+    let mut committed_keys = HashSet::new();
+    let mut delay = Duration::from_millis(25);
+    let mut rounds = 0u32;
+    loop {
+        let pending = all_by_key
+            .iter()
+            .filter(|(key, _)| !committed_keys.contains(*key))
+            .map(|(_, item)| item.clone())
+            .collect::<Vec<_>>();
+        if pending.is_empty() {
+            let reclaimed = finish_committed(view, owner, owner_coordinated).await;
+            counters
+                .completed
+                .fetch_add(u64::from(reclaimed), Ordering::Relaxed);
+            return reclaimed;
+        }
+
+        rounds = rounds.saturating_add(1);
+        let prepare =
+            call_owner_phase(view, owner, OwnerReclaimPhase::Prepare, pending.clone()).await;
+        let Ok(prepare_responses) = prepare else {
+            // No member is known committed yet. Abort is both rollback and
+            // response-loss resolution: a Committed response moves us onto
+            // the mandatory roll-forward branch.
+            if committed_keys.is_empty() {
+                if let Ok(abort_responses) =
+                    call_owner_phase(view, owner, OwnerReclaimPhase::Abort, pending.clone()).await
+                {
+                    for (item, response) in pending.iter().zip(abort_responses) {
+                        if response.state == OwnerReclaimItemState::Committed {
+                            committed_keys.insert(item.key.clone());
+                        }
+                    }
+                    if committed_keys.is_empty() {
+                        clear_master_fences(view, &fenced);
+                        return 0;
+                    }
+                }
+            }
+            tokio::time::sleep(delay).await;
+            delay = (delay * 2).min(Duration::from_secs(1));
+            continue;
+        };
+
+        let mut prepared = Vec::new();
+        let mut blocked = false;
+        for (item, response) in pending.iter().cloned().zip(prepare_responses) {
+            match response.state {
+                OwnerReclaimItemState::Prepared => prepared.push(item),
+                OwnerReclaimItemState::Committed => {
+                    committed_keys.insert(item.key);
+                }
+                _ => blocked = true,
+            }
+        }
+
+        if blocked && committed_keys.is_empty() {
+            // Nothing irreversible happened. Abort every possibly-prepared
+            // member, and only roll back after the response proves that none
+            // had crossed Commit during a lost response.
+            match call_owner_phase(view, owner, OwnerReclaimPhase::Abort, pending.clone()).await {
+                Ok(responses) => {
+                    for (item, response) in pending.iter().zip(responses) {
+                        if response.state == OwnerReclaimItemState::Committed {
+                            committed_keys.insert(item.key.clone());
+                        }
+                    }
+                    if committed_keys.is_empty() {
+                        clear_master_fences(view, &fenced);
+                        return 0;
+                    }
+                }
+                Err(_) => {
+                    tokio::time::sleep(delay).await;
+                    delay = (delay * 2).min(Duration::from_secs(1));
+                    continue;
+                }
+            }
+        }
+
+        // With no blocked member this is the first atomic Commit attempt. If
+        // another member was already observed Committed, this is mandatory
+        // roll-forward for the rest of the transaction.
+        if !prepared.is_empty() && (!blocked || !committed_keys.is_empty()) {
+            if let Ok(commit_responses) =
+                call_owner_phase(view, owner, OwnerReclaimPhase::Commit, prepared.clone()).await
+            {
+                for (item, response) in prepared.iter().zip(commit_responses) {
+                    if response.state == OwnerReclaimItemState::Committed {
+                        committed_keys.insert(item.key.clone());
+                    }
+                }
+            }
+        }
+
+        if rounds == 8 && !committed_keys.is_empty() {
+            tracing::warn!(
+                "owner cohort reclaim is rolling forward after partial/uncertain commit: owner={} cohort={} committed={}",
+                owner,
+                owner_coordinated.len(),
+                committed_keys.len(),
+            );
+        }
+        tokio::time::sleep(delay).await;
+        delay = (delay * 2).min(Duration::from_secs(1));
+    }
 }
 
 #[cfg(test)]
-mod reserve_scan_tests {
+mod reclaim_partition_tests {
     use super::{
         OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimReason, partition_reclaim_coordination,
-        reclaim_reserve_candidate_batches,
     };
-    use std::future::ready;
 
     fn candidate(index: u32) -> OwnerReclaimItem {
         OwnerReclaimItem {
@@ -823,7 +1740,7 @@ mod reserve_scan_tests {
                 slot_index: index,
                 slot_size: 8 * 1024 * 1024,
             },
-            reason: OwnerReclaimReason::Reserve,
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
         }
     }
 
@@ -831,10 +1748,10 @@ mod reserve_scan_tests {
     fn only_unindexed_allocations_skip_owner_coordination() {
         let mut indexed_allocation = candidate(1);
         indexed_allocation.backing = OwnerReclaimBacking::Allocation;
-        indexed_allocation.reason = OwnerReclaimReason::CapacityEviction;
+        indexed_allocation.reason = OwnerReclaimReason::OwnerCapacityEviction;
         let mut unindexed_allocation = candidate(2);
         unindexed_allocation.backing = OwnerReclaimBacking::UnindexedAllocation;
-        unindexed_allocation.reason = OwnerReclaimReason::CapacityEviction;
+        unindexed_allocation.reason = OwnerReclaimReason::MasterAllocationCapacity;
         let committed_slot = candidate(3);
 
         let (master_only, owner_coordinated) = partition_reclaim_coordination(vec![
@@ -851,57 +1768,6 @@ mod reserve_scan_tests {
                 .all(|item| item.backing != OwnerReclaimBacking::UnindexedAllocation)
         );
     }
-
-    #[limit_thirdparty::tokio::test]
-    async fn reserve_scan_continues_after_busy_first_batch() {
-        let candidates = (0..12).map(candidate).collect::<Vec<_>>();
-        let mut batches = Vec::new();
-        let mut call_count = 0usize;
-
-        let (reclaimed, scanned_candidates) =
-            reclaim_reserve_candidate_batches(candidates, 5, |batch: Vec<OwnerReclaimItem>| {
-                call_count += 1;
-                batches.push(
-                    batch
-                        .iter()
-                        .map(|item| item.key.clone())
-                        .collect::<Vec<_>>(),
-                );
-                ready(if call_count == 1 {
-                    0
-                } else {
-                    u32::try_from(batch.len()).unwrap()
-                })
-            })
-            .await;
-
-        assert_eq!(reclaimed, 5);
-        assert_eq!(scanned_candidates, 10);
-        assert_eq!(batches.len(), 2);
-        assert_eq!(batches[0][0], "candidate-0");
-        assert_eq!(batches[0][4], "candidate-4");
-        assert_eq!(batches[1][0], "candidate-5");
-        assert_eq!(batches[1][4], "candidate-9");
-    }
-
-    #[limit_thirdparty::tokio::test]
-    async fn reserve_scan_shrinks_next_batch_after_partial_reclaim() {
-        let candidates = (0..10).map(candidate).collect::<Vec<_>>();
-        let mut batch_lengths = Vec::new();
-        let mut call_count = 0usize;
-
-        let (reclaimed, scanned_candidates) =
-            reclaim_reserve_candidate_batches(candidates, 5, |batch| {
-                call_count += 1;
-                batch_lengths.push(batch.len());
-                ready(if call_count == 1 { 2 } else { 3 })
-            })
-            .await;
-
-        assert_eq!(reclaimed, 5);
-        assert_eq!(scanned_candidates, 8);
-        assert_eq!(batch_lengths, vec![5, 3]);
-    }
 }
 
 #[cfg(test)]
@@ -967,7 +1833,7 @@ mod owner_get_holding_reclaim_tests {
             key,
             None,
             None,
-            OwnerReclaimReason::CapacityEviction,
+            OwnerReclaimReason::OwnerCapacityEviction,
             master_view.master_kv_router().next_owner_reclaim_epoch(),
         )
         .expect("active-holder owner route should be reclaimable after the reader exits");
@@ -995,7 +1861,7 @@ mod owner_get_holding_reclaim_tests {
             key,
             None,
             None,
-            OwnerReclaimReason::CapacityEviction,
+            OwnerReclaimReason::OwnerCapacityEviction,
             master_view.master_kv_router().next_owner_reclaim_epoch(),
         )
         .expect("current owner route should be reclaimable");
@@ -1036,36 +1902,69 @@ mod owner_get_holding_reclaim_tests {
     }
 }
 
-pub(crate) async fn reclaim_owner_slots_for_reserve(
-    view: &MasterKvRouterView,
-    owner_node_id: &NodeID,
-    slot_size: u64,
-    required_free_slots: u32,
-) -> u32 {
-    if slot_size == 0 || required_free_slots == 0 {
-        return 0;
+fn request_is_current(view: &MasterKvRouterView, request: &EvictionReclaimRequest) -> bool {
+    if let Some(expected_generation) = request.owner_node_start_time
+        && view
+            .cluster_manager()
+            .get_member_info_cached(&request.owner_node_id)
+            .map(|member| member.node_start_time)
+            != Some(expected_generation)
+    {
+        return false;
+    }
+    match request.origin {
+        EvictionReclaimOrigin::MasterAllocationCapacity => request.members.iter().all(|member| {
+            view.master_kv_router().eviction_cache_entry_is_current(
+                &request.owner_node_id,
+                &member.key,
+                &member.desc,
+            )
+        }),
+        EvictionReclaimOrigin::OwnerCapacityEviction => {
+            let owner: NodeID = request.owner_node_id.clone().into();
+            request.members.iter().all(|member| {
+                let Some(expected_backing) = member.expected_backing.as_ref() else {
+                    return false;
+                };
+                let Some(route) = view
+                    .master_kv_router()
+                    .inner()
+                    .kv_routes
+                    .get(&member.key)
+                    .map(|entry| entry.clone())
+                else {
+                    return false;
+                };
+                if route.put_id != member.desc.put_id || route.lease_id.is_some() {
+                    return false;
+                }
+                route
+                    .nodes_replicas
+                    .read()
+                    .get(&owner)
+                    .is_some_and(|replica| {
+                        !replica.tomb_tag.is_tomb()
+                            && replica.owner_local_indexed
+                            && reclaim_backing_matches(replica, expected_backing)
+                    })
+            })
+        }
     }
-    let scan_started = Instant::now();
-    let candidates =
-        collect_reserve_candidates(view, owner_node_id, slot_size, OWNER_RECLAIM_MAX_BATCH);
-    let candidate_scan_us = scan_started.elapsed().as_micros();
-    let candidate_count = candidates.len();
-    let (reclaimed, scanned_candidate_count) =
-        reclaim_reserve_candidate_batches(candidates, required_free_slots, |batch| {
-            reclaim_items(view, owner_node_id, batch)
+}
+
+fn restore_request_entries(view: &MasterKvRouterView, request: &EvictionReclaimRequest) -> usize {
+    request
+        .members
+        .iter()
+        .filter(|member| {
+            view.master_kv_router()
+                .restore_eviction_cache_entry_if_current(
+                    &request.owner_node_id,
+                    member.key.clone(),
+                    member.desc.clone(),
+                )
         })
-        .await;
-    tracing::info!(
-        "owner reserve reclaim completed: owner={} slot_size={} requested_slots={} candidates={} scanned_candidates={} reclaimed={} candidate_scan_us={}",
-        owner_node_id,
-        slot_size,
-        required_free_slots,
-        candidate_count,
-        scanned_candidate_count,
-        reclaimed,
-        candidate_scan_us
-    );
-    reclaimed
+        .count()
 }
 
 fn spawn_eviction_reclaim_retry(view: MasterKvRouterView, requests: Vec<EvictionReclaimRequest>) {
@@ -1080,46 +1979,31 @@ fn spawn_eviction_reclaim_retry(view: MasterKvRouterView, requests: Vec<Eviction
         let counters = view
             .master_kv_router()
             .eviction_reclaim_counters(&request.owner_node_id);
-        let weight = u64::from(request.desc.weight_bytes);
-        if !view.master_kv_router().eviction_cache_entry_is_current(
-            &request.owner_node_id,
-            &request.key,
-            &request.desc,
-        ) {
-            view.master_kv_router()
-                .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+        let weight = request.weight_bytes();
+        if !request_is_current(&view, &request) {
+            view.master_kv_router().complete_eviction_reclaim(&request);
             counters.route_changed.fetch_add(1, Ordering::Relaxed);
             counters.retry_completed.fetch_add(1, Ordering::Relaxed);
             continue;
         }
-        if should_restore_after_retry(request.retry_count) {
-            let restored = view
-                .master_kv_router()
-                .restore_eviction_cache_entry_if_current(
-                    &request.owner_node_id,
-                    request.key.clone(),
-                    request.desc.clone(),
-                );
-            if restored {
-                view.master_kv_router()
-                    .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+        if request.origin == EvictionReclaimOrigin::MasterAllocationCapacity
+            && should_restore_after_retry(request.retry_count)
+        {
+            // Release the old identity before reinsertion.  A bounded remote
+            // cache may synchronously produce a fresh Size event; that event
+            // must own a new, independently-accounted lifecycle.
+            view.master_kv_router().complete_eviction_reclaim(&request);
+            let restored = restore_request_entries(&view, &request);
+            if restored == request.members.len() {
                 counters.retry_restored.fetch_add(1, Ordering::Relaxed);
                 counters.retry_completed.fetch_add(1, Ordering::Relaxed);
-                restored_count += 1;
+                restored_count += restored;
                 restored_weight = restored_weight.saturating_add(weight);
                 continue;
             }
-            if !view.master_kv_router().eviction_cache_entry_is_current(
-                &request.owner_node_id,
-                &request.key,
-                &request.desc,
-            ) {
-                view.master_kv_router()
-                    .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
-                counters.route_changed.fetch_add(1, Ordering::Relaxed);
-                counters.retry_completed.fetch_add(1, Ordering::Relaxed);
-                continue;
-            }
+            counters.route_changed.fetch_add(1, Ordering::Relaxed);
+            counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+            continue;
         }
         counters.retry_queued.fetch_add(1, Ordering::Relaxed);
         delayed.push(request);
@@ -1146,40 +2030,23 @@ fn spawn_eviction_reclaim_retry(view: MasterKvRouterView, requests: Vec<Eviction
         tokio::time::sleep(retry_delay).await;
         let tx = view.master_kv_router().inner().eviction_reclaim_tx.clone();
         for request in delayed {
-            let weight = u64::from(request.desc.weight_bytes);
             let counters = view
                 .master_kv_router()
                 .eviction_reclaim_counters(&request.owner_node_id);
-            if !view.master_kv_router().eviction_cache_entry_is_current(
-                &request.owner_node_id,
-                &request.key,
-                &request.desc,
-            ) {
-                view.master_kv_router()
-                    .complete_eviction_reclaim_weight(&request.owner_node_id, weight);
+            if !request_is_current(&view, &request) {
+                view.master_kv_router().complete_eviction_reclaim(&request);
                 counters.route_changed.fetch_add(1, Ordering::Relaxed);
                 counters.retry_completed.fetch_add(1, Ordering::Relaxed);
                 continue;
             }
-            let restore_request = request.clone();
-            if tx.send(request).await.is_err() {
-                view.master_kv_router()
-                    .complete_eviction_reclaim_weight(&restore_request.owner_node_id, weight);
-                let restored = view
-                    .master_kv_router()
-                    .restore_eviction_cache_entry_if_current(
-                        &restore_request.owner_node_id,
-                        restore_request.key,
-                        restore_request.desc,
-                    );
+            if let Err(err) = tx.send(request) {
+                let request = err.0;
+                view.master_kv_router().complete_eviction_reclaim(&request);
                 counters.retry_completed.fetch_add(1, Ordering::Relaxed);
-                if restored {
-                    counters.retry_restored.fetch_add(1, Ordering::Relaxed);
-                }
                 tracing::warn!(
-                    "safe eviction reclaim retry queue closed: owner={} restored={}",
-                    restore_request.owner_node_id,
-                    restored
+                    "lossless eviction reclaim retry channel closed: owner={} members={}",
+                    request.owner_node_id,
+                    request.members.len(),
                 );
             }
         }
@@ -1188,7 +2055,7 @@ fn spawn_eviction_reclaim_retry(view: MasterKvRouterView, requests: Vec<Eviction
 
 pub(crate) fn spawn_eviction_reclaim_actor(
     view: MasterKvRouterView,
-    mut rx: limit_thirdparty::tokio::sync::ampsc::Receiver<EvictionReclaimRequest>,
+    mut rx: limit_thirdparty::tokio::sync::ampsc::UnboundedReceiver<EvictionReclaimRequest>,
 ) {
     let view_task = view.clone();
     let _ = view.spawn("eviction_reclaim_actor", async move {
@@ -1226,64 +2093,192 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                 let counters = view_task
                     .master_kv_router()
                     .eviction_reclaim_counters(&owner_node_id);
-                let mut seen = HashSet::new();
-                let mut items = Vec::new();
-                let mut unique_requests = Vec::new();
-                let mut completed_weight = 0u64;
-                for request in requests {
-                    if !seen.insert((request.key.clone(), request.desc.put_id)) {
-                        completed_weight = completed_weight
-                            .saturating_add(u64::from(request.desc.weight_bytes));
-                        continue;
-                    }
-                    if let Some(item) = route_item(
-                        &view_task,
-                        &owner,
-                        &request.key,
-                        Some(request.desc.put_id),
-                        None,
-                        OwnerReclaimReason::CapacityEviction,
-                        view_task.master_kv_router().next_owner_reclaim_epoch(),
-                    ) {
-                        items.push(item);
-                    }
-                    unique_requests.push(request);
-                }
-                let candidate_count = items.len();
-                let reclaimed = reclaim_items(&view_task, &owner, items).await;
+                let mut pending = std::collections::VecDeque::from(requests);
                 let mut retry_requests = Vec::new();
-                for request in unique_requests {
-                    if view_task
-                        .master_kv_router()
-                        .eviction_cache_entry_is_current(
-                            &owner_node_id,
-                            &request.key,
-                            &request.desc,
-                        )
-                    {
-                        retry_requests.push(request);
-                    } else {
-                        completed_weight = completed_weight
-                            .saturating_add(u64::from(request.desc.weight_bytes));
-                        counters.route_changed.fetch_add(1, Ordering::Relaxed);
-                        if request.retry_count != 0 {
-                            counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                while let Some(request) = pending.pop_front() {
+                    let (members, mut accounting_requests, reason) = match request.origin {
+                        EvictionReclaimOrigin::OwnerCapacityEviction => (
+                            request.members.clone(),
+                            vec![request],
+                            OwnerReclaimReason::OwnerCapacityEviction,
+                        ),
+                        EvictionReclaimOrigin::MasterAllocationCapacity => {
+                            let members = match plan_master_allocation_capacity_cohort(
+                                &view_task,
+                                &request,
+                            ) {
+                                Ok(members) => members,
+                                Err(MasterCapacityPlanError::CommittedSlot) => {
+                                    counters
+                                        .capacity_eviction_non_ring_b_entry_total
+                                        .fetch_add(1, Ordering::Relaxed);
+                                    counters
+                                        .capacity_eviction_hit_committed_slot
+                                        .fetch_add(1, Ordering::Relaxed);
+                                    view_task
+                                        .master_kv_router()
+                                        .complete_eviction_reclaim(&request);
+                                    let restored = restore_request_entries(&view_task, &request);
+                                    tracing::error!(
+                                        "BUG: master Allocation capacity event resolved to CommittedSlot; restored metadata: owner={} members={} restored={}",
+                                        owner_node_id,
+                                        request.members.len(),
+                                        restored,
+                                    );
+                                    continue;
+                                }
+                                Err(MasterCapacityPlanError::RouteChanged) => {
+                                    view_task
+                                        .master_kv_router()
+                                        .complete_eviction_reclaim(&request);
+                                    counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                                    continue;
+                                }
+                                Err(MasterCapacityPlanError::InvalidCohort) => {
+                                    retry_requests.push(request);
+                                    continue;
+                                }
+                                Err(MasterCapacityPlanError::WrongRole) => {
+                                    counters
+                                        .capacity_eviction_non_ring_b_entry_total
+                                        .fetch_add(1, Ordering::Relaxed);
+                                    view_task
+                                        .master_kv_router()
+                                        .complete_eviction_reclaim(&request);
+                                    let restored = restore_request_entries(&view_task, &request);
+                                    tracing::error!(
+                                        "BUG: master Allocation Size event resolved to a non-ring-B route; restored metadata: owner={} members={} restored={}",
+                                        owner_node_id,
+                                        request.members.len(),
+                                        restored,
+                                    );
+                                    continue;
+                                }
+                            };
+                            let owner_cache_lock = view_task
+                                .master_kv_router()
+                                .inner()
+                                .owner_cache_operation_locks
+                                .get_lock(owner_node_id.clone());
+                            let owner_cache_guard = owner_cache_lock.lock().await;
+                            let detach_result = detach_present_capacity_cohort_siblings(
+                                &view_task,
+                                &owner_node_id,
+                                &members,
+                            );
+                            drop(owner_cache_guard);
+                            if detach_result.is_err() {
+                                retry_requests.push(request);
+                                continue;
+                            }
+
+                            let planned = members
+                                .iter()
+                                .map(|member| {
+                                    (
+                                        member.key.clone(),
+                                        member.desc.put_id,
+                                        member.desc.weight_bytes,
+                                    )
+                                })
+                                .collect::<HashSet<_>>();
+                            let mut accounting_requests = vec![request];
+                            let mut retained = std::collections::VecDeque::new();
+                            while let Some(other) = pending.pop_front() {
+                                let belongs = other.origin
+                                    == EvictionReclaimOrigin::MasterAllocationCapacity
+                                    && other.members.iter().all(|member| {
+                                        planned.contains(&(
+                                            member.key.clone(),
+                                            member.desc.put_id,
+                                            member.desc.weight_bytes,
+                                        ))
+                                    });
+                                if belongs {
+                                    accounting_requests.push(other);
+                                } else {
+                                    retained.push_back(other);
+                                }
+                            }
+                            pending = retained;
+
+                            let mut accounted = accounting_requests
+                                .iter()
+                                .flat_map(EvictionReclaimRequest::identities)
+                                .collect::<HashSet<_>>();
+                            for member in &members {
+                                let synthetic = EvictionReclaimRequest {
+                                    owner_node_id: owner_node_id.clone(),
+                                    owner_node_start_time: None,
+                                    members: vec![member.clone()],
+                                    origin: EvictionReclaimOrigin::MasterAllocationCapacity,
+                                    retry_count: 0,
+                                };
+                                let identity = synthetic.identities().pop().unwrap();
+                                if accounted.contains(&identity) {
+                                    continue;
+                                }
+                                if view_task
+                                    .master_kv_router()
+                                    .register_eviction_reclaim(&synthetic)
+                                {
+                                    accounted.insert(identity);
+                                    accounting_requests.push(synthetic);
+                                }
+                            }
+                            (
+                                members,
+                                accounting_requests,
+                                OwnerReclaimReason::MasterAllocationCapacity,
+                            )
+                        }
+                    };
+
+                    let items = members
+                        .iter()
+                        .map(|member| {
+                            let item = route_item(
+                                &view_task,
+                                &owner,
+                                &member.key,
+                                Some(member.desc.put_id),
+                                None,
+                                reason,
+                                view_task.master_kv_router().next_owner_reclaim_epoch(),
+                            )?;
+                            if member
+                                .expected_backing
+                                .as_ref()
+                                .is_some_and(|expected| expected != &item.backing)
+                            {
+                                return None;
+                            }
+                            Some(item)
+                        })
+                        .collect::<Option<Vec<_>>>();
+                    if let Some(items) = items {
+                        let _ = reclaim_cohort_items(&view_task, &owner, items).await;
+                    }
+                    for accounting_request in accounting_requests.drain(..) {
+                        if request_is_current(&view_task, &accounting_request) {
+                            retry_requests.push(accounting_request);
+                        } else {
+                            view_task
+                                .master_kv_router()
+                                .complete_eviction_reclaim(&accounting_request);
+                            counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                            if accounting_request.retry_count != 0 {
+                                counters.retry_completed.fetch_add(1, Ordering::Relaxed);
+                            }
                         }
                     }
                 }
-                view_task.master_kv_router().complete_eviction_reclaim_weight(
-                    &owner_node_id,
-                    completed_weight,
-                );
                 let retry_count = retry_requests.len();
                 spawn_eviction_reclaim_retry(view_task.clone(), retry_requests);
                 tracing::trace!(
-                    "batched safe eviction reclaim completed: owner={} candidates={} reclaimed={} retry_deferred={} completed_weight={}",
+                    "safe cohort eviction reclaim batch completed: owner={} retry_deferred={}",
                     owner_node_id,
-                    candidate_count,
-                    reclaimed,
                     retry_count,
-                    completed_weight
                 );
             }
         }
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
index b1c0932..6ebd982 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
@@ -1,7 +1,7 @@
 use super::{MasterKvRouterView, NodeValueReplicaDesc, put::PutIDForAKey};
 use crate::cluster_manager::NodeID;
 use limit_thirdparty::tokio;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::time::Duration;
 
 const POST_ROUTE_MAINTENANCE_MAX_BATCH: usize = 512;
@@ -73,12 +73,6 @@ fn saturating_moka_weight_bytes(key: &str, put_id: PutIDForAKey, capacity_bytes:
     }
 }
 
-fn projected_batch_weight(current_weight: u64, replaced_weight: u64, incoming_weight: u64) -> u64 {
-    current_weight
-        .saturating_sub(replaced_weight)
-        .saturating_add(incoming_weight)
-}
-
 fn deduplicate_owner_events(
     events: Vec<(usize, String, NodeValueReplicaDesc)>,
 ) -> Vec<(String, NodeValueReplicaDesc)> {
@@ -95,7 +89,7 @@ fn deduplicate_owner_events(
 }
 
 /// Applies index and cache work after route guards have been released.
-async fn apply_post_route_maintenance_batch(
+pub(super) async fn apply_post_route_maintenance_batch(
     view: &MasterKvRouterView,
     events: Vec<RoutePublishEvent>,
 ) {
@@ -126,7 +120,10 @@ async fn apply_post_route_maintenance_batch(
     if !view.master_kv_router().replica_cache_enabled() {
         return;
     }
-    let mut events_by_owner = HashMap::<String, Vec<(usize, String, NodeValueReplicaDesc)>>::new();
+    let mut ring_b_events_by_owner =
+        HashMap::<String, Vec<(usize, String, NodeValueReplicaDesc)>>::new();
+    let mut tier1_events_by_owner =
+        HashMap::<String, Vec<(usize, String, NodeValueReplicaDesc)>>::new();
     for (sequence, event) in events.into_iter().enumerate() {
         if event.lease_id.is_some() {
             continue;
@@ -137,21 +134,39 @@ async fn apply_post_route_maintenance_batch(
             weight_bytes,
             put_id: event.put_id,
         };
-        if !view.master_kv_router().eviction_cache_entry_is_current(
+        if view.master_kv_router().eviction_cache_entry_is_current(
             event.node_id.as_ref(),
             &event.key,
             &desc,
         ) {
-            continue;
+            ring_b_events_by_owner
+                .entry(event.node_id.as_ref().to_string())
+                .or_default()
+                .push((sequence, event.key.clone(), desc.clone()));
+        }
+        if view.master_kv_router().tier1_writeback_entry_is_current(
+            event.node_id.as_ref(),
+            &event.key,
+            &desc,
+        ) {
+            tier1_events_by_owner
+                .entry(event.node_id.as_ref().to_string())
+                .or_default()
+                .push((sequence, event.key, desc));
         }
-        events_by_owner
-            .entry(event.node_id.as_ref().to_string())
-            .or_default()
-            .push((sequence, event.key, desc));
     }
 
-    for (owner_node_id, owner_events) in events_by_owner {
+    for (owner_node_id, owner_events) in ring_b_events_by_owner {
         let entries = deduplicate_owner_events(owner_events);
+        // Moka's sync housekeeper uses a blocking mutex. Serialize before
+        // entering it with an async owner-level gate so waiting route-publish
+        // tasks yield instead of occupying every Tokio worker thread.
+        let owner_cache_lock = view
+            .master_kv_router()
+            .inner()
+            .owner_cache_operation_locks
+            .get_lock(owner_node_id.clone());
+        let _owner_cache_guard = owner_cache_lock.lock().await;
         let Some(cache) = view
             .master_kv_router()
             .get_node_cache_controller(&owner_node_id)
@@ -163,85 +178,58 @@ async fn apply_post_route_maintenance_batch(
             continue;
         };
 
-        // Drain prior writes once, then admit this owner batch as one unit. This exposes the
-        // aggregate incoming weight to the explicit resident-capacity policy.
+        // Drain prior writes once, then admit this owner batch as one unit.
+        // Every node's controller is the bounded authority for that node's
+        // unindexed Allocation domain; placement role is irrelevant.
         cache.run_pending_tasks();
-        let weighted_size_before = cache.weighted_size();
-        let replaced_weight = entries
-            .iter()
-            .filter_map(|(key, _)| cache.get(key))
-            .map(|existing| u64::from(existing.weight_bytes))
-            .fold(0u64, u64::saturating_add);
-        let incoming_weight = entries
-            .iter()
-            .map(|(_, desc)| u64::from(desc.weight_bytes))
-            .fold(0u64, u64::saturating_add);
-        let projected_weight =
-            projected_batch_weight(weighted_size_before, replaced_weight, incoming_weight);
-        let node_space_size = view
-            .master_seg_manager()
-            .get_node_space_size(&owner_node_id);
-        let capacity = view
-            .master_kv_router()
-            .replica_cache_effective_capacity(&owner_node_id, node_space_size);
-        let requested_weight = projected_weight.saturating_sub(capacity);
-        let incoming_keys = entries
-            .iter()
-            .map(|(key, _)| key.clone())
-            .collect::<HashSet<_>>();
-
-        let recoverable_selected_weight = view
-            .master_kv_router()
-            .evict_recoverable_cache_weight_excluding(
-                &owner_node_id,
-                requested_weight,
-                &incoming_keys,
-            );
-        let fallback_requested_weight =
-            requested_weight.saturating_sub(recoverable_selected_weight);
-        let fallback_selected_weight = if view
-            .master_kv_router()
-            .owner_cache_allows_unrecoverable_eviction(&owner_node_id)
-        {
-            cache.evict_some_if(fallback_requested_weight, |key, _desc| {
-                !incoming_keys.contains(key)
-            })
-        } else {
-            0
-        };
-        if requested_weight != 0 {
-            tracing::debug!(
-                "recoverable-first batch admission: owner={} entries={} weighted_size_before={} replaced_weight={} incoming_weight={} projected_weight={} capacity={} requested_weight={} recoverable_selected_weight={} fallback_requested_weight={} fallback_selected_weight={} shortfall_weight={}",
-                owner_node_id,
-                entries.len(),
-                weighted_size_before,
-                replaced_weight,
-                incoming_weight,
-                projected_weight,
-                capacity,
-                requested_weight,
-                recoverable_selected_weight,
-                fallback_requested_weight,
-                fallback_selected_weight,
-                fallback_requested_weight.saturating_sub(fallback_selected_weight),
-            );
-        }
-
-        let tier1_cache = view
-            .master_kv_router()
-            .get_node_writeback_tier1_controller(&owner_node_id);
         for (key, desc) in entries {
+            if !view
+                .master_kv_router()
+                .eviction_cache_entry_is_current(&owner_node_id, &key, &desc)
+            {
+                continue;
+            }
             tracing::debug!("Inserting key: {:?} into cache", key);
             cache.insert(key.clone(), desc.clone());
-            if let Some(tier1_cache) = tier1_cache.as_ref() {
-                tier1_cache.insert(key.clone(), desc);
-            }
             tracing::debug!(
                 "Inserted key: {:?} into cache, current cache size: {}",
                 key,
                 cache.weighted_size()
             );
         }
+        // Do not search Moka for a recoverable victim here. CPU append Done
+        // already carries the exact source key/cohort and performs a validated
+        // point demotion. Local-reserve Free/Prepared/Pending/Committed state is
+        // the physical capacity authority while that writeback is in flight.
+    }
+
+    // Tier1 is a separate pre-writeback policy.  Its admission rules remain
+    // owner-route based and must not be coupled to ring-B backing admission.
+    for (owner_node_id, owner_events) in tier1_events_by_owner {
+        let entries = deduplicate_owner_events(owner_events);
+        let owner_cache_lock = view
+            .master_kv_router()
+            .inner()
+            .owner_cache_operation_locks
+            .get_lock(owner_node_id.clone());
+        let _owner_cache_guard = owner_cache_lock.lock().await;
+        let Some(tier1_cache) = view
+            .master_kv_router()
+            .get_node_writeback_tier1_controller(&owner_node_id)
+        else {
+            continue;
+        };
+        tier1_cache.run_pending_tasks();
+        for (key, desc) in entries {
+            if !view.master_kv_router().tier1_writeback_entry_is_current(
+                &owner_node_id,
+                &key,
+                &desc,
+            ) {
+                continue;
+            }
+            tier1_cache.insert(key, desc);
+        }
     }
 }
 
@@ -306,7 +294,7 @@ pub(super) async fn enqueue_post_route_maintenance(
 
 #[cfg(test)]
 mod tests {
-    use super::{deduplicate_owner_events, projected_batch_weight, saturating_moka_weight_bytes};
+    use super::{deduplicate_owner_events, saturating_moka_weight_bytes};
     use crate::master_kv_router::NodeValueReplicaDesc;
 
     #[test]
@@ -321,12 +309,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn projected_weight_accounts_for_batch_replacements_once() {
-        assert_eq!(projected_batch_weight(90, 30, 50), 110);
-        assert_eq!(projected_batch_weight(10, 20, 5), 5);
-    }
-
     #[test]
     fn owner_batch_keeps_only_the_last_event_for_each_key() {
         let desc = |weight_bytes, put_id| NodeValueReplicaDesc {
diff --git a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease.rs b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease.rs
index 1df23e3..eeb24e6 100755
--- a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease.rs
+++ b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease.rs
@@ -146,6 +146,15 @@ impl Lease {
         Ok(())
     }
 
+    /// Remove only the exact version installed by a failed route publication.
+    /// A newer Put may already have rebound the same key, so key-only removal
+    /// would be an ABA bug.
+    pub fn detach_key_if_version(&self, key: &str, put_id: PutIDForAKey) -> bool {
+        self.keys
+            .remove_if(key, |_, current_put_id| *current_put_id == put_id)
+            .is_some()
+    }
+
     // Note: no detach_all_keys semantics; deletion paths iterate keys directly.
 
     /// Get all keys with their put_id information
diff --git a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
index 5d344c9..ed7f6be 100755
--- a/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
+++ b/fluxon_rs/fluxon_kv/src/master_lease_manager/lease_manager_test.rs
@@ -350,6 +350,36 @@ async fn test5_eviction_when_lease_consumes_space() {
         leased_success_keys.len()
     );
 
+    // Rounded allocations and the three reclaimable normal keys mean that a
+    // fixed 19 * 5MiB loop does not itself prove the physical segment is full.
+    // Establish the precondition explicitly before asserting later NoSpace
+    // behavior; otherwise the first post-check lease put can legitimately use
+    // the final free 5MiB slot.
+    let mut reached_lease_full = false;
+    for i in 0..32u32 {
+        let k = format!("t5_lease_topoff_{}", i);
+        match client_view
+            .client_kv_api()
+            .put(&k, &leased_value, Some(lease_id))
+            .await
+        {
+            Ok(()) => leased_success_keys.push(k),
+            Err(e) => {
+                assert!(
+                    e.to_string().contains("NoSpace"),
+                    "expected top-off to end in NoSpace, got: {}",
+                    e
+                );
+                reached_lease_full = true;
+                break;
+            }
+        }
+    }
+    assert!(
+        reached_lease_full,
+        "lease top-off did not establish a full physical segment"
+    );
+
     // Canvas assertion: assert 放成功的所有 lease key 都存在（TTL 尚未到期）
     tracing::info!(
         "[test5-assert-all-leased-keys-exist] verifying all successfully stored leased keys still exist before TTL expiry"
diff --git a/fluxon_rs/fluxon_kv/src/master_lease_manager/master_lease_manager.rs b/fluxon_rs/fluxon_kv/src/master_lease_manager/master_lease_manager.rs
index 86d6736..5eb2120 100644
--- a/fluxon_rs/fluxon_kv/src/master_lease_manager/master_lease_manager.rs
+++ b/fluxon_rs/fluxon_kv/src/master_lease_manager/master_lease_manager.rs
@@ -503,6 +503,21 @@ impl MasterLeaseManager {
         }
     }
 
+    /// Roll back one exact lease binding when its route publication did not
+    /// linearize.  This is synchronous because it only touches the lease's
+    /// DashMap and is used from completion rollback paths.
+    pub fn detach_key_if_version(
+        &self,
+        lease_id: LeaseID,
+        key: &str,
+        put_id: PutIDForAKey,
+    ) -> bool {
+        self.inner()
+            .leases
+            .get(&lease_id)
+            .is_some_and(|lease| lease.detach_key_if_version(key, put_id))
+    }
+
     /// Get lease information
     /// pub fn get_lease(&self, lease_id: LeaseID) -> Option<Arc<Lease>> {
     ///    let leases_guard = self.leases.read();
diff --git a/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs b/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs
index 8a50032..627d361 100644
--- a/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs
@@ -2,7 +2,7 @@ pub mod msg_pack;
 pub mod one_seg_allocator;
 use self::msg_pack::RequestSegmentRegistrationReq;
 use self::msg_pack::SegmentDeviceDescription;
-use self::one_seg_allocator::OneSegAllocator;
+use self::one_seg_allocator::{Allocation, OneSegAllocator};
 use crate::cluster_manager::NodeID;
 use crate::p2p::p2p_module::P2pModuleAccessTrait;
 use crate::rpcresp_kvresult_convert::msg_and_error::OK;
@@ -27,6 +27,7 @@ use std::time::Duration;
 fn register_node_segments(
     view: &MasterSegManagerView,
     node_id: NodeID,
+    node_start_time: i64,
     seg_map: std::collections::HashMap<
         SegmentDeviceID,
         (SegmentDeviceDescription, msg_pack::SegmentDeviceMemInfo),
@@ -72,13 +73,29 @@ fn register_node_segments(
                 device_id_2_allocator.insert(device_id, Arc::new(allocator));
             }
 
-            v.insert(NodeSegmentsManager::new(total_size, device_id_2_allocator));
+            v.insert(NodeSegmentsManager::new(
+                node_start_time,
+                total_size,
+                device_id_2_allocator,
+            ));
         }
         dashmap::mapref::entry::Entry::Occupied(mut occ) => {
             let node_segments_manager = occ.get_mut();
 
             // Tomb means the previous instance has left/restarted; replace the full segment set.
             if node_segments_manager.tomb_tag.is_tomb() {
+                // An RPC response already in flight at MemberLeft must not resurrect the
+                // departed generation. Only a genuinely newer epoch may replace a tomb.
+                if node_segments_manager.node_start_time == node_start_time {
+                    return Err(KvError::Api(
+                        crate::rpcresp_kvresult_convert::msg_and_error::ApiError::RegisterSegmentFailed {
+                            detail: format!(
+                                "stale segment registration for tombed node generation: node={} node_start_time={}",
+                                node_id, node_start_time
+                            ),
+                        },
+                    ));
+                }
                 let mut total_size: u64 = 0;
                 let mut device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>> =
                     HashMap::new();
@@ -100,12 +117,24 @@ fn register_node_segments(
                 }
 
                 *node_segments_manager =
-                    NodeSegmentsManager::new(total_size, device_id_2_allocator);
+                    NodeSegmentsManager::new(node_start_time, total_size, device_id_2_allocator);
                 tracing::info!("RegisterSegment replaced tombed node: {}", node_id);
                 return Ok(());
             }
 
-            // Non-tomb: allow re-entrant registration (idempotent) to tolerate transient retries.
+            if node_segments_manager.node_start_time != node_start_time {
+                return Err(KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::RegisterSegmentFailed {
+                        detail: format!(
+                            "new segment generation attempted to replace a live generation: node={} live_node_start_time={} requested_node_start_time={}",
+                            node_id, node_segments_manager.node_start_time, node_start_time
+                        ),
+                    },
+                ));
+            }
+
+            // Non-tomb, same generation: allow re-entrant registration (idempotent) to
+            // tolerate transient retries.
             for (device_id, (seg_device_desc, seg_mem_info)) in seg_map {
                 if let Some(existing) = node_segments_manager.device_id_2_allocator.get(&device_id)
                 {
@@ -181,9 +210,15 @@ impl NodeTombTag {
     pub fn set_tomb(&self) {
         self.0.store(true, Ordering::Release);
     }
+
+    /// True only when both tags belong to the same node registration generation.
+    pub fn same_generation(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
+    }
 }
 
 pub struct NodeSegmentsManager {
+    node_start_time: i64,
     total_size: u64,
     device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>>,
     tomb_tag: NodeTombTag,
@@ -191,10 +226,12 @@ pub struct NodeSegmentsManager {
 
 impl NodeSegmentsManager {
     pub fn new(
+        node_start_time: i64,
         total_size: u64,
         device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>>,
     ) -> Self {
         Self {
+            node_start_time,
             total_size,
             device_id_2_allocator,
             tomb_tag: NodeTombTag::new(),
@@ -298,11 +335,30 @@ impl MasterSegManager {
     //     allocator.clone().allocate(size)
     // }
 
-    pub fn mark_node_tomb(&self, node_id: &NodeID) {
+    pub fn mark_node_tomb(&self, node_id: &NodeID) -> Option<NodeTombTag> {
+        self.mark_node_tomb_generation(node_id, None)
+    }
+
+    /// Mark one exact membership generation as departed and return its shared tomb tag.
+    /// A delayed leave for an older epoch must not tomb a newly registered generation that
+    /// happens to reuse the same node id.
+    pub fn mark_node_tomb_generation(
+        &self,
+        node_id: &NodeID,
+        expected_node_start_time: Option<i64>,
+    ) -> Option<NodeTombTag> {
         if let Some(allocators_and_tomb_tag) =
             self.inner().node_allocators_and_tomb_tag.get(node_id)
         {
+            if expected_node_start_time
+                .is_some_and(|expected| allocators_and_tomb_tag.node_start_time != expected)
+            {
+                return None;
+            }
             allocators_and_tomb_tag.tomb_tag.set_tomb();
+            Some(allocators_and_tomb_tag.tomb_tag.clone())
+        } else {
+            None
         }
     }
 
@@ -316,6 +372,28 @@ impl MasterSegManager {
         }
     }
 
+    /// Resolve the registration generation that owns an already-created allocation.
+    ///
+    /// A plain `get_node_tomb_tag(node_id)` is insufficient: the node may have left and
+    /// re-registered between allocation and completion.  In that case the current tag belongs
+    /// to a different allocator set and must never be attached to the old allocation.
+    pub fn get_allocation_tomb_tag(
+        &self,
+        node_id: &NodeID,
+        allocation: &Allocation,
+    ) -> Option<NodeTombTag> {
+        let node = self.inner().node_allocators_and_tomb_tag.get(node_id)?;
+        if node.tomb_tag.is_tomb()
+            || !node
+                .device_id_2_allocator
+                .values()
+                .any(|allocator| allocation.belongs_to_allocator(allocator))
+        {
+            return None;
+        }
+        Some(node.tomb_tag.clone())
+    }
+
     pub fn get_node_allocators(&self, node_id: &NodeID) -> Vec<Arc<OneSegAllocator>> {
         let mut ret = Vec::new();
         if let Some(node_allocators) = self.inner().node_allocators_and_tomb_tag.get(node_id) {
@@ -417,7 +495,12 @@ impl MasterSegManager {
         );
 
         // Now, register these segments in the master.
-        match register_node_segments(inner.view(), node_id.clone(), resp.serialize_part.seg_map) {
+        match register_node_segments(
+            inner.view(),
+            node_id.clone(),
+            expected_node_start_time,
+            resp.serialize_part.seg_map,
+        ) {
             Ok(()) => {
                 tracing::info!("Successfully registered segments for node {}", node_id);
             }
@@ -434,6 +517,7 @@ impl MasterSegManager {
         self.inner()
             .node_allocators_and_tomb_tag
             .get(node_id)
+            .filter(|node_segments_manager| !node_segments_manager.tomb_tag.is_tomb())
             .map(|node_segments_manager| node_segments_manager.total_size)
             .unwrap_or(0)
     }
diff --git a/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs b/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs
index 6dcd136..18eaf66 100755
--- a/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs
+++ b/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs
@@ -72,6 +72,15 @@ impl Allocation {
         self.allocator.base_addr
     }
 
+    /// Returns whether this allocation was created by the exact allocator instance.
+    ///
+    /// Segment names and node ids are reusable after a node reconnects.  Pointer identity is
+    /// therefore the only safe way for master-side completion paths to bind an allocation back
+    /// to the registration generation that created it.
+    pub(crate) fn belongs_to_allocator(&self, allocator: &Arc<OneSegAllocator>) -> bool {
+        Arc::ptr_eq(&self.allocator, allocator)
+    }
+
     /// Attach an on-drop callback. It will be executed exactly once
     /// when this allocation is dropped.
     pub fn set_on_drop<F>(&mut self, f: F)
diff --git a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
index 1ea35eb..e070b1d 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
@@ -721,6 +721,86 @@ pub struct OwnerExternalMemMgr {
     inner: MemholderManagerInner<NodeHolderKey, ExternalHoldingGetInfo>,
 }
 
+impl OwnerExternalMemMgr {
+    /// Remove only holdings owned by the departed membership generation.
+    /// Node ids are reusable, so node-only cleanup can release memory still in
+    /// use by a reconnected external requester.
+    pub fn cleanup_node_generation(&self, node_id: &str, node_start_time: i64) -> usize {
+        let keys = self
+            .inner
+            .as_map()
+            .iter()
+            .filter_map(|entry| {
+                owner_external_holding_matches_generation(
+                    &entry.value().req_node_id,
+                    entry.value().requester_node_start_time,
+                    node_id,
+                    node_start_time,
+                )
+                .then(|| entry.key().clone())
+            })
+            .collect::<Vec<_>>();
+
+        keys.into_iter()
+            .filter(|key| {
+                self.inner
+                    .as_map()
+                    .remove_if(key, |_, holding| {
+                        owner_external_holding_matches_generation(
+                            &holding.req_node_id,
+                            holding.requester_node_start_time,
+                            node_id,
+                            node_start_time,
+                        )
+                    })
+                    .is_some()
+            })
+            .count()
+    }
+}
+
+fn owner_external_holding_matches_generation(
+    holding_node_id: &str,
+    holding_node_start_time: Option<i64>,
+    departed_node_id: &str,
+    departed_node_start_time: i64,
+) -> bool {
+    holding_node_id == departed_node_id && holding_node_start_time == Some(departed_node_start_time)
+}
+
+#[cfg(test)]
+mod owner_external_generation_tests {
+    use super::owner_external_holding_matches_generation;
+
+    #[test]
+    fn holding_cleanup_never_matches_reconnected_or_unknown_generation() {
+        assert!(owner_external_holding_matches_generation(
+            "external-a",
+            Some(11),
+            "external-a",
+            11,
+        ));
+        assert!(!owner_external_holding_matches_generation(
+            "external-a",
+            Some(12),
+            "external-a",
+            11,
+        ));
+        assert!(!owner_external_holding_matches_generation(
+            "external-a",
+            None,
+            "external-a",
+            11,
+        ));
+        assert!(!owner_external_holding_matches_generation(
+            "external-b",
+            Some(11),
+            "external-a",
+            11,
+        ));
+    }
+}
+
 impl Default for OwnerExternalMemMgr {
     fn default() -> Self {
         Self {
@@ -762,15 +842,21 @@ impl MemholderManagerTrait for OwnerExternalMemMgr {
             if holding.key != task.key {
                 continue;
             }
+            let Some(holding_epoch) = holding.requester_node_start_time else {
+                continue;
+            };
             let Some(member) = ctx
                 .cluster_manager()
                 .get_member_info_cached(&holding.req_node_id)
             else {
                 continue;
             };
+            if member.node_start_time != holding_epoch {
+                continue;
+            }
             targets.insert(DeleteTargetMember::new(
                 holding.req_node_id.clone(),
-                member.node_start_time,
+                holding_epoch,
             ));
         }
         targets.into_iter().collect()
diff --git a/fluxon_rs/fluxon_kv/src/memholder/mod.rs b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
index 0cd6a6f..7221f2d 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
@@ -194,6 +194,30 @@ impl MemoryInfo {
                 .expect("segment cpu mem must be available when creating resident MemoryInfo");
             base_guard.allocated_addr
         };
+        Self::new_local_reserve_resident_with_base(
+            addr,
+            base_addr,
+            len,
+            key,
+            master_node_id,
+            view,
+            slot_size,
+            grant_id,
+            slot_index,
+        )
+    }
+
+    pub fn new_local_reserve_resident_with_base(
+        addr: u64,
+        base_addr: u64,
+        len: u32,
+        key: String,
+        master_node_id: NodeID,
+        view: ClientKvApiView,
+        slot_size: u64,
+        grant_id: u64,
+        slot_index: u32,
+    ) -> Self {
         assert!(
             addr >= base_addr,
             "resident local reserve addr must be within client segment: addr={:#x} base_addr={:#x}",
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
index d771141..5f6e8ca 100644
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
@@ -77,6 +77,12 @@ pub enum MsgId {
     BatchEnqueueReplicaTaskResp = 3062,
     GroupedBatchPutDoneReq = 3063,
     GroupedBatchPutDoneResp = 3064,
+    BatchPutAppendStartReq = 3065,
+    BatchPutAppendStartResp = 3066,
+    BatchPutAppendDoneReq = 3067,
+    BatchPutAppendDoneResp = 3068,
+    BatchEvictOwnerSourceReq = 3069,
+    BatchEvictOwnerSourceResp = 3070,
     ExternalGetReq = 4001,
     ExternalGetResp = 4002,
     ExternalPutStartReq = 4003,
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index 693e873..412ec5f 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -3481,7 +3481,7 @@ impl KvClient {
                         .client_kv_api_view()
                         .client_kv_api()
                         .inner()
-                        .reserve_local_grant(0, 0, false)
+                        .reserve_local_grant()
                         .await
                 })
             }) {
@@ -3501,12 +3501,6 @@ impl KvClient {
                     base_addr,
                     len,
                 }) => ApiResult::new_success((grant_id, addr, base_addr, len).into_py(py)),
-                Ok(ReserveLocalGrantOutcome::Reclaimed { .. }) => {
-                    ApiResult::new_error(new_general_error(
-                        py,
-                        "raw reserve_local_grant request unexpectedly reclaimed class slots",
-                    ))
-                }
                 Ok(ReserveLocalGrantOutcome::None) => {
                     unreachable!("reserve_local_grant filters empty successful outcomes")
                 }
@@ -4202,55 +4196,38 @@ impl KvClient {
                                     slot_ref.slot_index,
                                 )
                                 .await;
-                            inner.install_precommit_local_visible_memory_info(
-                                key,
-                                memory_info.clone(),
-                            );
+                            inner.install_precommit_local_visible_memory_info(key, memory_info);
                             let put_id = put_ids[idx];
-                            let promote = inner
-                                .promote_precommit_local_reserve_resident_slot_if_same(
-                                    key,
-                                    put_id,
-                                    memory_info.clone(),
-                                    atomic_groups[idx].as_ref(),
-                                );
-                            match promote {
-                                Ok(()) => {
-                                    inner.record_put_locality(false, owner_data.value_len, 0);
-                                    publish_items.push(OwnerLocalPublishItem {
-                                        key: key.clone(),
-                                        put_id,
-                                        value_len: owner_data.value_len,
-                                        lease_id: None,
-                                        committed_slot: PutDoneCommittedSlot {
-                                            grant_id: slot_ref.grant_id,
-                                            slot_index: slot_ref.slot_index,
-                                            slot_size,
-                                            addr: slot_ref.ptr,
-                                            base_addr: slot_ref.base_addr,
-                                            len: owner_data.value_len,
-                                        },
-                                        make_replica_task: *make_replica_task,
-                                        preferred_sub_cluster: None,
-                                        atomic_group: atomic_groups[idx].clone(),
-                                    });
-                                    ret_codes.push(0);
-                                }
-                                Err(err) => {
-                                    let _ = inner
-                                        .remove_precommit_local_reserve_resident_slot_if_same(
-                                            key,
-                                            &memory_info,
-                                        );
-                                    ret_codes.push(kv_error_to_ret_code(&err));
-                                }
-                            }
+                            inner.record_put_locality(false, owner_data.value_len, 0);
+                            publish_items.push(OwnerLocalPublishItem {
+                                key: key.clone(),
+                                put_id,
+                                value_len: owner_data.value_len,
+                                lease_id: None,
+                                committed_slot: PutDoneCommittedSlot {
+                                    grant_id: slot_ref.grant_id,
+                                    slot_index: slot_ref.slot_index,
+                                    slot_size,
+                                    addr: slot_ref.ptr,
+                                    base_addr: slot_ref.base_addr,
+                                    len: owner_data.value_len,
+                                },
+                                make_replica_task: *make_replica_task,
+                                preferred_sub_cluster: None,
+                                atomic_group: atomic_groups[idx].clone(),
+                            });
+                            ret_codes.push(0);
                         }
                         if !publish_items.is_empty() {
+                            let publish_keys = publish_items
+                                .iter()
+                                .map(|item| item.key.clone())
+                                .collect::<Vec<_>>();
                             if let Err(err) = inner
                                 .enqueue_owner_local_publish(OwnerLocalPublishJob {
                                     items: publish_items,
                                     key_reservation_ids: owner_data.key_reservation_ids.clone(),
+                                    external_pending_contexts: Vec::new(),
                                 })
                                 .await
                             {
@@ -4258,6 +4235,17 @@ impl KvClient {
                                     "local_fast_put_commit owner local publish enqueue failed after local commit: {}",
                                     err
                                 );
+                                for key in publish_keys {
+                                    if let Some(memory_info) =
+                                        inner.precommit_local_visible_memory_info(&key)
+                                    {
+                                        let _ = inner
+                                            .remove_precommit_local_reserve_resident_slot_if_same(
+                                                &key,
+                                                &memory_info,
+                                            );
+                                    }
+                                }
                                 if let Err(cleanup_err) = release_put_key_reservations_only(
                                     inner,
                                     owner_data.key_reservation_ids,
diff --git a/pegaflow b/pegaflow
new file mode 160000
index 0000000..939363f
--- /dev/null
+++ b/pegaflow
@@ -0,0 +1 @@
+Subproject commit 939363f198a0ffded9e3f30d8af9cdd74439f16c
diff --git a/scripts/preview_doc_html.py b/scripts/preview_doc_html.py
new file mode 100755
index 0000000..18f5093
--- /dev/null
+++ b/scripts/preview_doc_html.py
@@ -0,0 +1,547 @@
+#!/usr/bin/env python3
+"""Generate a standalone HTML preview for a Markdown document."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_OUTPUT_ROOT = REPO_ROOT / ".dever/html_preview"
+
+
+HTML_TEMPLATE = """<!doctype html>
+<html lang="{html_lang}">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>{title}</title>
+  <link rel="preconnect" href="https://cdn.jsdelivr.net" />
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/github-markdown-css@5/github-markdown-light.css" />
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/highlight.js@11/styles/github.min.css" />
+  <style>
+    :root {{
+      color-scheme: light;
+      --page-bg: #f5f7fa;
+      --panel-bg: #ffffff;
+      --border: #d8dee4;
+      --text-muted: #57606a;
+      --accent: #0969da;
+    }}
+
+    body {{
+      margin: 0;
+      background: var(--page-bg);
+      color: #24292f;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans SC", "PingFang SC", "Microsoft YaHei", sans-serif;
+    }}
+
+    .topbar {{
+      position: sticky;
+      top: 0;
+      z-index: 5;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      padding: 10px 18px;
+      border-bottom: 1px solid var(--border);
+      background: rgba(255, 255, 255, 0.92);
+      backdrop-filter: blur(10px);
+    }}
+
+    .topbar-title {{
+      min-width: 0;
+      font-size: 14px;
+      font-weight: 600;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }}
+
+    .topbar-actions {{
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      flex: none;
+    }}
+
+    .status {{
+      color: var(--text-muted);
+      font-size: 13px;
+      white-space: nowrap;
+    }}
+
+    button {{
+      height: 32px;
+      padding: 0 10px;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      background: #ffffff;
+      color: #24292f;
+      font: inherit;
+      cursor: pointer;
+    }}
+
+    button:hover {{
+      border-color: var(--accent);
+      color: var(--accent);
+    }}
+
+    .page {{
+      max-width: 1040px;
+      margin: 0 auto;
+      padding: 28px 18px 64px;
+    }}
+
+    .markdown-body {{
+      box-sizing: border-box;
+      min-width: 200px;
+      padding: 38px 48px;
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      background: var(--panel-bg);
+      box-shadow: 0 10px 30px rgba(31, 35, 40, 0.06);
+    }}
+
+    .markdown-body h1 {{
+      margin-top: 0;
+      padding-bottom: 0.4em;
+      font-size: 2em;
+    }}
+
+    .markdown-body pre {{
+      border: 1px solid #d0d7de;
+    }}
+
+    .mermaid-card {{
+      position: relative;
+      margin: 18px 0;
+      padding: 16px;
+      border: 1px solid #d0d7de;
+      border-radius: 8px;
+      background: #ffffff;
+      overflow: auto;
+    }}
+
+    .mermaid-card::before {{
+      content: "Click diagram to fullscreen";
+      position: absolute;
+      top: 8px;
+      right: 10px;
+      font-size: 12px;
+      color: var(--text-muted);
+      pointer-events: none;
+    }}
+
+    .mermaid-card svg {{
+      display: block;
+      max-width: none;
+      margin: 0 auto;
+      cursor: zoom-in;
+    }}
+
+    .mermaid-error {{
+      white-space: pre-wrap;
+      color: #b42318;
+      background: #fff1f0;
+    }}
+
+    .diagram-modal {{
+      position: fixed;
+      inset: 0;
+      z-index: 1000;
+      display: none;
+      background: rgba(15, 23, 42, 0.86);
+    }}
+
+    .diagram-modal.open {{
+      display: grid;
+      grid-template-rows: auto 1fr;
+    }}
+
+    .diagram-toolbar {{
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
+      padding: 10px 12px;
+      background: #ffffff;
+      border-bottom: 1px solid var(--border);
+    }}
+
+    .diagram-toolbar-title {{
+      min-width: 0;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      color: #24292f;
+      font-size: 14px;
+      font-weight: 600;
+    }}
+
+    .diagram-toolbar-actions {{
+      display: flex;
+      gap: 8px;
+      flex: none;
+    }}
+
+    .diagram-stage {{
+      min-height: 0;
+      background: #f6f8fa;
+      overflow: hidden;
+      cursor: grab;
+    }}
+
+    .diagram-stage:active {{
+      cursor: grabbing;
+    }}
+
+    .diagram-stage svg {{
+      width: 100%;
+      height: 100%;
+      background: #ffffff;
+    }}
+
+    .help {{
+      color: var(--text-muted);
+      font-size: 13px;
+    }}
+
+    @media (max-width: 720px) {{
+      .markdown-body {{
+        padding: 24px 18px;
+      }}
+
+      .topbar {{
+        align-items: flex-start;
+        flex-direction: column;
+      }}
+
+      .topbar-actions {{
+        width: 100%;
+        overflow-x: auto;
+      }}
+    }}
+  </style>
+</head>
+<body>
+  <header class="topbar">
+    <div class="topbar-title" id="previewTitle">{title}</div>
+    <div class="topbar-actions">
+      <span class="status" id="renderStatus">Waiting</span>
+      <button type="button" id="rerenderBtn">重新渲染 Mermaid</button>
+      <button type="button" id="printBtn">打印 / PDF</button>
+    </div>
+  </header>
+
+  <main class="page">
+    <article id="content" class="markdown-body"></article>
+  </main>
+
+  <div id="diagramModal" class="diagram-modal" aria-hidden="true">
+    <div class="diagram-toolbar">
+      <div class="diagram-toolbar-title">Mermaid diagram preview</div>
+      <div class="help">拖拽平移，滚轮缩放，Esc 关闭</div>
+      <div class="diagram-toolbar-actions">
+        <button type="button" id="zoomInBtn">放大</button>
+        <button type="button" id="zoomOutBtn">缩小</button>
+        <button type="button" id="resetZoomBtn">重置</button>
+        <button type="button" id="closeModalBtn">关闭</button>
+      </div>
+    </div>
+    <div id="diagramStage" class="diagram-stage"></div>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/marked@12/marked.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/dompurify@3/dist/purify.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/highlight.js@11/lib/common.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/svg-pan-zoom@3/dist/svg-pan-zoom.min.js"></script>
+  <script>
+    const markdownSource = {markdown_json};
+    let panZoom = null;
+    let mermaidSources = [];
+
+    marked.setOptions({{
+      gfm: true,
+      breaks: false,
+      headerIds: true,
+      mangle: false,
+    }});
+
+    mermaid.initialize({{
+      startOnLoad: false,
+      securityLevel: "loose",
+      theme: "default",
+      flowchart: {{ useMaxWidth: false, htmlLabels: true }},
+      sequence: {{ useMaxWidth: false }},
+    }});
+
+    function renderMarkdown() {{
+      const content = document.getElementById("content");
+      const preparedMarkdown = extractMermaidBlocks(markdownSource);
+      const unsafeHtml = marked.parse(preparedMarkdown);
+      content.innerHTML = DOMPurify.sanitize(unsafeHtml, {{
+        ADD_TAGS: ["foreignObject"],
+        ADD_ATTR: ["target", "rel", "class", "style", "data-mermaid-index"],
+      }});
+
+      restoreMermaidSources();
+
+      content.querySelectorAll("a[href]").forEach((link) => {{
+        const href = link.getAttribute("href") || "";
+        if (/^https?:\\/\\//.test(href)) {{
+          link.target = "_blank";
+          link.rel = "noopener noreferrer";
+        }}
+      }});
+
+      content.querySelectorAll("pre code").forEach((block) => {{
+        try {{
+          const languageClass = Array.from(block.classList).find((name) => name.startsWith("language-"));
+          const language = languageClass ? languageClass.slice("language-".length) : "";
+          if (!["", "text", "txt", "plain", "plaintext"].includes(language)) {{
+            hljs.highlightElement(block);
+          }}
+        }} catch (error) {{
+          console.warn("highlight.js skipped a block:", error);
+        }}
+      }});
+
+      renderMermaid();
+    }}
+
+    function extractMermaidBlocks(markdown) {{
+      mermaidSources = [];
+      return markdown.replace(/^```mermaid[^\\n]*\\n([\\s\\S]*?)\\n```\\s*$/gm, (_match, source) => {{
+        const index = mermaidSources.push(source.trim()) - 1;
+        return `\\n<div class="mermaid-card"><div class="mermaid" data-mermaid-index="${{index}}"></div></div>\\n`;
+      }});
+    }}
+
+    function restoreMermaidSources() {{
+      document.querySelectorAll(".mermaid[data-mermaid-index]").forEach((diagram) => {{
+        const index = Number(diagram.dataset.mermaidIndex);
+        diagram.textContent = mermaidSources[index] || "";
+      }});
+    }}
+
+    async function renderMermaid() {{
+      const diagrams = Array.from(document.querySelectorAll(".mermaid"));
+      const status = document.getElementById("renderStatus");
+      status.textContent = `Rendering ${{diagrams.length}} diagrams`;
+      let rendered = 0;
+
+      for (const [index, diagram] of diagrams.entries()) {{
+        const sourceIndex = Number(diagram.dataset.mermaidIndex);
+        const source = (mermaidSources[sourceIndex] || diagram.textContent || "").trim();
+        diagram.classList.remove("mermaid-error");
+        diagram.textContent = "";
+
+        try {{
+          const result = await mermaid.render(`doc-mermaid-${{Date.now()}}-${{index}}`, source);
+          diagram.innerHTML = result.svg;
+          if (typeof result.bindFunctions === "function") {{
+            result.bindFunctions(diagram);
+          }}
+          const svg = diagram.querySelector("svg");
+          if (svg) {{
+            rendered += 1;
+            svg.dataset.diagramTitle = "Diagram " + (index + 1);
+            svg.addEventListener("click", () => openDiagram(svg));
+          }}
+        }} catch (error) {{
+          diagram.classList.add("mermaid-error");
+          diagram.textContent = "Mermaid render failed:\\n" + String(error) + "\\n\\n" + source;
+          console.error("Mermaid render failed for diagram", index + 1, error);
+        }}
+      }}
+
+      status.textContent = `Mermaid: ${{rendered}}/${{diagrams.length}} rendered`;
+    }}
+
+    function openDiagram(sourceSvg) {{
+      const modal = document.getElementById("diagramModal");
+      const stage = document.getElementById("diagramStage");
+      stage.innerHTML = sourceSvg.outerHTML;
+      modal.classList.add("open");
+      modal.setAttribute("aria-hidden", "false");
+      document.body.style.overflow = "hidden";
+
+      const svg = stage.querySelector("svg");
+      svg.removeAttribute("style");
+      svg.removeAttribute("width");
+      svg.removeAttribute("height");
+      svg.setAttribute("width", "100%");
+      svg.setAttribute("height", "100%");
+
+      if (panZoom) {{
+        panZoom.destroy();
+      }}
+      panZoom = svgPanZoom(svg, {{
+        zoomEnabled: true,
+        controlIconsEnabled: false,
+        fit: true,
+        center: true,
+        minZoom: 0.1,
+        maxZoom: 20,
+        zoomScaleSensitivity: 0.35,
+      }});
+      window.setTimeout(() => {{
+        panZoom.resize();
+        panZoom.fit();
+        panZoom.center();
+      }}, 0);
+    }}
+
+    function closeDiagram() {{
+      const modal = document.getElementById("diagramModal");
+      const stage = document.getElementById("diagramStage");
+      if (panZoom) {{
+        panZoom.destroy();
+        panZoom = null;
+      }}
+      stage.innerHTML = "";
+      modal.classList.remove("open");
+      modal.setAttribute("aria-hidden", "true");
+      document.body.style.overflow = "";
+    }}
+
+    document.getElementById("closeModalBtn").addEventListener("click", closeDiagram);
+    document.getElementById("diagramModal").addEventListener("click", (event) => {{
+      if (event.target.id === "diagramModal") {{
+        closeDiagram();
+      }}
+    }});
+    document.getElementById("zoomInBtn").addEventListener("click", () => panZoom && panZoom.zoomIn());
+    document.getElementById("zoomOutBtn").addEventListener("click", () => panZoom && panZoom.zoomOut());
+    document.getElementById("resetZoomBtn").addEventListener("click", () => {{
+      if (panZoom) {{
+        panZoom.resetZoom();
+        panZoom.fit();
+        panZoom.center();
+      }}
+    }});
+    document.getElementById("rerenderBtn").addEventListener("click", renderMarkdown);
+    document.getElementById("printBtn").addEventListener("click", () => window.print());
+    window.addEventListener("keydown", (event) => {{
+      if (event.key === "Escape") {{
+        closeDiagram();
+      }}
+    }});
+    window.addEventListener("resize", () => {{
+      if (panZoom) {{
+        panZoom.resize();
+        panZoom.fit();
+        panZoom.center();
+      }}
+    }});
+
+    renderMarkdown();
+  </script>
+</body>
+</html>
+"""
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Generate a standalone HTML preview for a Markdown document with Mermaid fullscreen zoom/pan support."
+    )
+    parser.add_argument(
+        "markdown_path",
+        type=Path,
+        help="Markdown input path.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help=f"HTML output path. Default: {DEFAULT_OUTPUT_ROOT.relative_to(REPO_ROOT)}/<input-relative-path>.html",
+    )
+    parser.add_argument(
+        "--open",
+        action="store_true",
+        help="Open the generated HTML file with the system browser.",
+    )
+    return parser.parse_args()
+
+
+def default_output_path(input_path: Path) -> Path:
+    try:
+        relative_input = input_path.relative_to(REPO_ROOT)
+    except ValueError:
+        digest = hashlib.sha256(str(input_path).encode("utf-8")).hexdigest()[:12]
+        relative_input = Path("external") / f"{input_path.stem}-{digest}{input_path.suffix}"
+    return (DEFAULT_OUTPUT_ROOT / relative_input).with_suffix(".html")
+
+
+def infer_html_lang(input_path: Path, markdown: str) -> str:
+    parts = set(input_path.parts)
+    if "fluxon_doc_cn" in parts or input_path.name == "README_CN.md":
+        return "zh-CN"
+    if "fluxon_doc_en" in parts or input_path.name == "README.md":
+        return "en"
+    return "zh-CN" if re.search(r"[\u4e00-\u9fff]", markdown) else "en"
+
+
+def first_markdown_heading(markdown: str, fallback: str) -> str:
+    for line in markdown.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("# "):
+            return stripped[2:].strip() or fallback
+    return fallback
+
+
+def open_in_browser(path: Path) -> None:
+    if sys.platform == "darwin":
+        subprocess.run(["open", str(path)], check=False)
+    elif os.name == "nt":
+        os.startfile(str(path))  # type: ignore[attr-defined]
+    else:
+        subprocess.run(["xdg-open", str(path)], check=False)
+
+
+def main() -> int:
+    args = parse_args()
+    input_path = args.markdown_path.resolve()
+
+    if not input_path.exists():
+        print(f"Input markdown does not exist: {input_path}", file=sys.stderr)
+        return 1
+    if not input_path.is_file():
+        print(f"Input path is not a file: {input_path}", file=sys.stderr)
+        return 1
+
+    output_path = args.output.resolve() if args.output else default_output_path(input_path)
+
+    markdown = input_path.read_text(encoding="utf-8")
+    title = first_markdown_heading(markdown, input_path.stem)
+    html = HTML_TEMPLATE.format(
+        title=title,
+        html_lang=infer_html_lang(input_path, markdown),
+        markdown_json=json.dumps(markdown, ensure_ascii=False),
+    )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(html, encoding="utf-8")
+
+    print(f"Generated HTML preview: {output_path}")
+    print("Open it in a browser. Mermaid fullscreen zoom/pan uses CDN assets, so internet access is required.")
+
+    if args.open:
+        open_in_browser(output_path)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

From 568ef15fc6b7ed33adf850819e10e5cc5d7fcd5d Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Sat, 18 Jul 2026 22:02:46 +0800
Subject: [PATCH 05/10] bak

---
 .../fluxon_kv/src/client_kv_api/delete.rs     |   2 +-
 .../src/client_kv_api/external_api.rs         |   6 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |   4 +-
 .../client_kv_api/local_reserve_rebalance.rs  | 122 ++-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 726 +++++++++++++++---
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  | 207 +++--
 .../fluxon_kv/src/client_kv_api/reclaim.rs    |  75 ++
 .../fluxon_kv/src/master_kv_router/mod.rs     | 378 ++++++---
 .../src/master_kv_router/msg_pack.rs          |  10 +-
 .../fluxon_kv/src/master_kv_router/put.rs     |   7 +
 .../fluxon_kv/src/master_kv_router/reclaim.rs | 351 +++++----
 .../src/master_kv_router/route_maintenance.rs |   6 +-
 fluxon_rs/fluxon_kv/src/memholder/mod.rs      |  11 +
 fluxon_rs/fluxon_util/src/lib.rs              |   1 +
 fluxon_rs/fluxon_util/src/pin_aware_moka.rs   | 671 ++++++++++++++++
 15 files changed, 2104 insertions(+), 473 deletions(-)
 create mode 100644 fluxon_rs/fluxon_util/src/pin_aware_moka.rs

diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
index 973a453..809ca0e 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/delete.rs
@@ -93,7 +93,7 @@ async fn apply_delete_client_kv_meta_cache_item(
         let controls = client_inner.owner_key_control.lock_key(&delete_item.key);
         if controls
             .get(&delete_item.key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
         {
             tracing::debug!(
                 "skip legacy local-index delete while owner reclaim fence is active: key={}",
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 42fe4e7..015d41c 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -1132,6 +1132,7 @@ mod external_get_start_batch_tests {
             OwnerKeyControlState {
                 local_puts: 0,
                 external_pending_puts: 0,
+                source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(old.clone()),
             },
@@ -1159,6 +1160,7 @@ mod external_get_start_batch_tests {
             OwnerKeyControlState {
                 local_puts: 0,
                 external_pending_puts: 0,
+                source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(op.clone()),
             },
@@ -1422,7 +1424,7 @@ async fn plan_external_get_key_items(
                 } else {
                     let fenced = controls
                         .get(key)
-                        .is_some_and(|state| state.reclaim.is_some());
+                        .is_some_and(|state| state.local_access_fenced());
                     if !fenced {
                         if let Some(memory_info) = inner.local_visible_mem_holder_unfenced(key) {
                             let hot_touch = inner.get_cached_info.get(key).and_then(|cached| {
@@ -2000,7 +2002,7 @@ async fn finish_external_get_key_leaders(
         match finish_result {
             Ok(results) if results.len() == batch.len() => {
                 // Publish each confirmed sub-batch immediately. A different
-                // uncertain Done cohort therefore cannot retain these flights
+                // uncertain Done atomic_batch therefore cannot retain these flights
                 // or their pending-visible slots.
                 for ((op, _), result) in batch.into_iter().zip(results) {
                     let phase = match result {
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 874107a..8cfbf99 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -621,7 +621,7 @@ impl ClientKvApiInner {
         }
 
         // All members are in get_cached_info before any hot admission can evict one of them.
-        // This keeps atomic/TP cohort write-back decisions complete.
+        // This keeps atomic/TP atomic_batch write-back decisions complete.
         for (key, put_id, memory_info, atomic_group) in local_hot_admissions {
             self.owner_hot_track_committed(&key, put_id, &memory_info, atomic_group.as_ref());
         }
@@ -1495,7 +1495,7 @@ impl ClientKvApiInner {
         // committed-slot Done.  Bound the number of callers entering that path
         // so a capacity scan cannot park every master Tokio worker on Moka's
         // blocking housekeeper lock.  The permit covers one RPC attempt only;
-        // idempotent retry backoff releases it and lets other cohorts converge.
+        // idempotent retry backoff releases it and lets other atomic_batches converge.
         let _done_rpc_permit = batch_get_done_rpc_limiter()
             .acquire()
             .await
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
index 08ad95e..a9db5e5 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
@@ -10,7 +10,7 @@ const OWNER_LOCAL_RESERVE_REBALANCE_INTERVAL: Duration = Duration::from_millis(2
 const OWNER_LOCAL_RESERVE_SHRINK_IDLE_COOLDOWN: Duration = Duration::from_secs(5);
 const OWNER_LOCAL_RESERVE_SHRINK_GROW_COOLDOWN: Duration = Duration::from_secs(1);
 const OWNER_LOCAL_RESERVE_DEFAULT_SOFT_WAIT_TIMEOUT: Duration = Duration::from_millis(10);
-// Cohort-safe master route deletion plus owner slot release is asynchronous.
+// AtomicBatch-safe master route deletion plus owner slot release is asynchronous.
 // Thirty seconds turns a recoverable pressure burst into a storage exception that
 // can wedge SGLang's detokenizer.  This remains well below the external request
 // timeout while allowing bounded backpressure to finish reclaiming slots.
@@ -19,8 +19,17 @@ const OWNER_LOCAL_RESERVE_MIN_GRANTS_PER_CLASS: usize = 0;
 const OWNER_LOCAL_RESERVE_REPORT_INTERVAL: Duration = Duration::from_secs(30);
 const OWNER_LOCAL_RESERVE_FREE_SLOT_HEADROOM_GRANTS: usize = 4;
 const OWNER_SLOT_PRESSURE_INTERVAL: Duration = Duration::from_millis(10);
-const OWNER_SLOT_PRESSURE_MIN_KICK_INTERVAL: Duration = Duration::from_millis(200);
-const OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES: u64 = 256 * 1024 * 1024;
+// Source deletion now has an exact, idempotent owner -> master transaction and
+// selection debt accounts for candidates until their slots are physically Free.
+// Keep pressure retries responsive: a 200 ms gate used to surface directly as
+// local_fast_put_start tail latency whenever one bounded kick was insufficient.
+const OWNER_SLOT_PRESSURE_MIN_KICK_INTERVAL: Duration = Duration::from_millis(25);
+// One 512 MiB grant contains 113 production KV slots.  The old 256 MiB cap was
+// smaller than a single grant and could never refill the configured four-grant
+// high watermark in one pass.  Bound a kick at eight grants so it covers the
+// four-grant retained headroom plus a normal large claimant, while selection
+// debt still prevents repeated over-selection before physical reclaim lands.
+const OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES: u64 = OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES * 8;
 
 #[derive(Debug, Clone, Copy)]
 struct ExpectedCapacityLayout {
@@ -72,7 +81,7 @@ fn owner_local_reserve_target_grant_count(
 
 fn owner_slot_pressure_request_bytes(
     snapshot: RebalanceClassSnapshot,
-    outstanding_selection_debt_bytes: u64,
+    source_eviction_selected_bytes: u64,
 ) -> u64 {
     let low_watermark = (snapshot.slots_per_grant as usize)
         .saturating_mul(2)
@@ -80,7 +89,7 @@ fn owner_slot_pressure_request_bytes(
     let high_watermark = (snapshot.slots_per_grant as usize)
         .saturating_mul(OWNER_LOCAL_RESERVE_FREE_SLOT_HEADROOM_GRANTS);
     let projected_eviction_slots =
-        usize::try_from(outstanding_selection_debt_bytes / snapshot.slot_size.max(1))
+        usize::try_from(source_eviction_selected_bytes / snapshot.slot_size.max(1))
             .unwrap_or(usize::MAX);
     let projected_free_slots = snapshot.free_slots.saturating_add(projected_eviction_slots);
     let pressure_active =
@@ -96,6 +105,17 @@ fn owner_slot_pressure_request_bytes(
         .min(OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES)
 }
 
+fn owner_slot_pressure_projected_reclaim_bytes(inner: &ClientKvApiInner) -> u64 {
+    // Candidate debt starts in Moka's synchronous eviction listener. A
+    // candidate that is incomplete, pinned, or waiting in the retry queue has
+    // no installed owner fence and cannot release a slot. Only exact selected
+    // source debt is valid projected reclaim credit.
+    inner
+        .owner_hot_counters
+        .source_eviction_selected_bytes
+        .load(std::sync::atomic::Ordering::Acquire)
+}
+
 fn owner_local_reserve_desired_free_slots(snapshot: RebalanceClassSnapshot) -> usize {
     let configured_headroom = if snapshot.expected_grant_count == 0 {
         0
@@ -359,6 +379,8 @@ async fn try_shrink_once(inner: &ClientKvApiInner, snapshot: RebalanceClassSnaps
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::client_kv_api::OwnerHotCacheCounters;
+    use std::sync::atomic::Ordering;
 
     const SLOT_SIZE: u64 = 8 * 1024 * 1024;
 
@@ -500,8 +522,8 @@ mod tests {
             used_slots: 64,
             free_slots: 1,
             grant_count: 1,
-            pending_slot_demand: 100,
-            max_observed_claim_slots: 100,
+            pending_slot_demand: 1_000,
+            max_observed_claim_slots: 1_000,
             expected_grant_count: 1,
         };
         assert_eq!(
@@ -509,6 +531,84 @@ mod tests {
             OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES
         );
     }
+
+    #[test]
+    fn retry_candidate_debt_is_not_projected_reclaim_credit() {
+        let snapshot = RebalanceClassSnapshot {
+            slot_size: 1024 * 1024,
+            slots_per_grant: 4,
+            used_slots: 4,
+            free_slots: 1,
+            grant_count: 1,
+            pending_slot_demand: 3,
+            max_observed_claim_slots: 3,
+            expected_grant_count: 1,
+        };
+        let counters = OwnerHotCacheCounters::default();
+        counters
+            .selection_debt_bytes
+            .store(10 * 1024 * 1024, Ordering::Release);
+
+        assert_eq!(
+            counters
+                .source_eviction_selected_bytes
+                .load(Ordering::Acquire),
+            0
+        );
+        assert_eq!(
+            owner_slot_pressure_request_bytes(
+                snapshot,
+                counters
+                    .source_eviction_selected_bytes
+                    .load(Ordering::Acquire),
+            ),
+            18 * 1024 * 1024,
+            "retry-only candidate debt must not suppress physical victim selection"
+        );
+
+        counters.add_source_eviction_selected_bytes(10 * 1024 * 1024);
+        assert_eq!(
+            owner_slot_pressure_request_bytes(
+                snapshot,
+                counters
+                    .source_eviction_selected_bytes
+                    .load(Ordering::Acquire),
+            ),
+            8 * 1024 * 1024,
+            "only installed source-selection debt is valid projected reclaim credit"
+        );
+        counters.remove_source_eviction_selected_bytes(10 * 1024 * 1024);
+        assert_eq!(
+            counters
+                .source_eviction_selected_bytes
+                .load(Ordering::Acquire),
+            0
+        );
+    }
+
+    #[test]
+    fn production_pressure_fills_high_watermark_in_one_kick() {
+        const VALUE_LEN: u64 = 4_718_592;
+        let slots_per_grant = crate::owner_local_reserve_slots_per_grant(VALUE_LEN).unwrap();
+        assert_eq!(slots_per_grant, 113);
+        let snapshot = RebalanceClassSnapshot {
+            slot_size: VALUE_LEN,
+            slots_per_grant,
+            used_slots: 113 * 174 - 8,
+            free_slots: 8,
+            grant_count: 174,
+            pending_slot_demand: 128,
+            max_observed_claim_slots: 128,
+            expected_grant_count: 174,
+        };
+        let requested = owner_slot_pressure_request_bytes(snapshot, 0);
+        assert_eq!(
+            requested,
+            u64::from(128_u32 + slots_per_grant * 4 - 8) * VALUE_LEN,
+            "one pressure kick must cover the claimant and retained four-grant headroom"
+        );
+        assert!(requested < OWNER_SLOT_PRESSURE_MAX_EVICT_BYTES);
+    }
 }
 
 async fn owner_local_reserve_rebalance_once(view: &ClientKvApiView) {
@@ -639,10 +739,8 @@ pub fn spawn_owner_slot_pressure_actor(view: ClientKvApiView) {
             {
                 continue;
             }
-            let outstanding_selection_debt_bytes = inner
-                .owner_hot_counters
-                .selection_debt_bytes
-                .load(std::sync::atomic::Ordering::Acquire);
+            let source_eviction_selected_bytes =
+                owner_slot_pressure_projected_reclaim_bytes(inner);
             let requested_bytes = {
                 let pool = inner.owner_local_reserve_pool.lock();
                 let snapshots = snapshot_rebalance_classes(&pool);
@@ -652,7 +750,7 @@ pub fn spawn_owner_slot_pressure_actor(view: ClientKvApiView) {
                     [] => 0,
                     [snapshot] => owner_slot_pressure_request_bytes(
                         *snapshot,
-                        outstanding_selection_debt_bytes,
+                        source_eviction_selected_bytes,
                     ),
                     _ => {
                         // Selection is intentionally disabled until the victim
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index d5843c4..efb4dde 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -50,12 +50,12 @@ use crate::{
     rpcresp_kvresult_convert::msg_and_error::{ApiError, ErrorCode, KvError, KvResult},
 };
 use async_trait::async_trait;
-use dashmap::DashMap;
+use dashmap::{DashMap, mapref::entry::Entry as DashMapEntry};
 use fluxon_framework::{LogicalModule, define_module};
 use fluxon_util::map_lock::AMapLock;
+use fluxon_util::pin_aware_moka::{PinAwareMoka, PinGuard};
 use limit_thirdparty::tokio;
 use moka::notification::RemovalCause;
-use moka::ops::compute::Op as MokaComputeOp;
 use parking_lot::Mutex;
 use std::collections::BTreeSet;
 use std::collections::HashMap;
@@ -83,6 +83,7 @@ pub struct ExternalHoldingGetInfo {
     /// MemberLeft cleanup.
     pub requester_node_start_time: Option<i64>,
     pub memory_info: Arc<MemoryInfo>, // The actual memholder being held
+    _owner_hot_pin: Option<PinGuard>,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -115,8 +116,10 @@ pub struct OwnerRuntimeObserveSnapshot {
     pub hot_source_evict_retry_scheduled: u64,
     pub hot_source_evict_retry_emitted: u64,
     pub hot_selection_debt_bytes: u64,
+    pub hot_source_eviction_selected_bytes: u64,
     pub hot_eviction_skipped_stale: u64,
     pub hot_eviction_skipped_reclaim: u64,
+    pub hot_eviction_skipped_active_holders: u64,
     pub hot_group_registry_entries: u64,
     pub hot_group_trigger_duplicates: u64,
     pub hot_group_trigger_incomplete: u64,
@@ -145,7 +148,7 @@ pub enum ExternalGetStartOwnerItem {
 ///
 /// A pending prefix decision is owned by this guard, not by control flow.  If
 /// the request future is cancelled at any await point, Drop retires the
-/// undecided count so the cohort task can still choose Finish or Revoke.
+/// undecided count so the atomic_batch task can still choose Finish or Revoke.
 pub struct ExternalGetKeyInterest {
     op: Arc<ExternalGetKeySharedOp>,
     decision_pending: bool,
@@ -210,7 +213,7 @@ pub enum ExternalGetKeySharedPhase {
     Started {
         item: BatchGetStartItemResp,
     },
-    /// At least one request plan's prefix retained this key.  The leader cohort is
+    /// At least one request plan's prefix retained this key.  The leader atomic_batch is
     /// transferring/completing it and later publishes one canonical result.
     Finishing {
         item: BatchGetStartItemResp,
@@ -1233,6 +1236,23 @@ struct OwnerHotCacheEntry {
     weight_bytes: u32,
 }
 
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub(crate) struct OwnerHotPinAlias {
+    key: String,
+    memory_info_ptr: usize,
+}
+
+impl OwnerHotPinAlias {
+    fn new(memory_info: &Arc<MemoryInfo>) -> Self {
+        Self {
+            key: memory_info.key.clone(),
+            memory_info_ptr: Arc::as_ptr(memory_info) as usize,
+        }
+    }
+}
+
+type OwnerHotCache = PinAwareMoka<String, OwnerHotPinAlias, OwnerHotCacheEntry>;
+
 #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub(crate) struct OwnerHotReplicaIdentity {
     key: String,
@@ -1261,8 +1281,12 @@ struct OwnerHotCacheCounters {
     source_evict_retry_scheduled: AtomicU64,
     source_evict_retry_emitted: AtomicU64,
     selection_debt_bytes: Arc<AtomicU64>,
+    /// Bytes behind an installed source-selection fence. Unlike candidate
+    /// debt, every byte here can become a physical Free slot after reclaim.
+    source_eviction_selected_bytes: AtomicU64,
     skipped_stale: AtomicU64,
     skipped_reclaim: AtomicU64,
+    skipped_active_holders: AtomicU64,
     group_trigger_duplicates: AtomicU64,
     group_trigger_incomplete: AtomicU64,
     grouped_put_done_batches: AtomicU64,
@@ -1302,18 +1326,37 @@ impl OwnerHotSelectionDebt {
     }
 }
 
+impl OwnerHotCacheCounters {
+    fn add_source_eviction_selected_bytes(&self, bytes: u64) {
+        self.source_eviction_selected_bytes
+            .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
+                current.checked_add(bytes)
+            })
+            .expect("owner source-selection byte credit overflowed");
+    }
+
+    fn remove_source_eviction_selected_bytes(&self, bytes: u64) {
+        self.source_eviction_selected_bytes
+            .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
+                current.checked_sub(bytes)
+            })
+            .expect("owner source-selection byte credit underflowed");
+    }
+}
+
 #[derive(Clone)]
 pub(crate) struct OwnerHotEvictionEvent {
     key: String,
     put_id: crate::master_kv_router::put::PutIDForAKey,
     memory_info: Weak<MemoryInfo>,
     selection_debt: Arc<OwnerHotSelectionDebt>,
-    /// Retry events already own one exact source-delete cohort.
+    /// The event was dispatched from the bounded retry queue. It may be a
+    /// pre-selection retry (no atomic_batch yet) or an exact installed-atomic_batch retry.
     retry: bool,
-    /// Exact owner source-delete cohort retained across RPC retries. Once set,
-    /// retries never re-expand or re-pin the local cohort.
-    source_eviction_cohort:
-        Option<Arc<crate::master_kv_router::msg_pack::OwnerSourceEvictionCohort>>,
+    /// Exact owner source-delete atomic_batch retained across RPC retries. Once set,
+    /// retries never re-expand or re-pin the local atomic_batch.
+    source_eviction_atomic_batch:
+        Option<Arc<crate::master_kv_router::msg_pack::OwnerSourceEvictionAtomicBatch>>,
     /// Failure count follows the event while it is dispatched, preserving
     /// exponential backoff across queue take/reinsert cycles.
     retry_failures: u32,
@@ -1325,7 +1368,17 @@ pub(crate) enum OwnerHotEvictionPreparation {
         sources: Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>,
     },
     RetryableReclaimFence,
-    RetryableIncompleteCohort,
+    RetryableIncompleteAtomicBatch,
+    TemporarilyPinned {
+        active_members: usize,
+    },
+    Obsolete,
+}
+
+pub(crate) enum OwnerHotSelectionFenceOutcome {
+    Fenced,
+    Retryable,
+    TemporarilyPinned { active_members: usize },
     Obsolete,
 }
 
@@ -1398,8 +1451,8 @@ impl OwnerHotRetryQueue {
         if !Arc::ptr_eq(&entry.event.selection_debt, &event.selection_debt) {
             entry.event.selection_debt.release();
         }
-        if event.source_eviction_cohort.is_none() {
-            event.source_eviction_cohort = entry.event.source_eviction_cohort.clone();
+        if event.source_eviction_atomic_batch.is_none() {
+            event.source_eviction_atomic_batch = entry.event.source_eviction_atomic_batch.clone();
         }
         entry.failures = entry.failures.max(event.retry_failures).saturating_add(1);
         event.retry = true;
@@ -1497,6 +1550,11 @@ pub(crate) struct OwnerPreparedReclaim {
     local_snapshot: Option<LocalSnapshotInfo>,
 }
 
+pub(crate) struct OwnerSourceEvictionSelection {
+    put_id: crate::master_kv_router::put::PutIDForAKey,
+    cached_info: GetCachedInfo,
+}
+
 pub(crate) enum OwnerReclaimRecord {
     Prepared(OwnerPreparedReclaim),
     /// The local index is fenced and the Commit handler owns the detached
@@ -1515,6 +1573,11 @@ pub(crate) struct OwnerKeyControlState {
     /// guard stored in every context, so cache invalidation cannot clear the
     /// reclaim fence while a cloned context is still in use.
     external_pending_puts: u32,
+    /// Owner-local pre-Prepare fence installed by the Moka source-eviction
+    /// dispatcher.  The matching committed index is moved into this record,
+    /// so a new local Get cannot acquire the source between victim selection
+    /// and the master's reclaim Prepare RPC.
+    source_eviction_selection: Option<OwnerSourceEvictionSelection>,
     reclaim: Option<OwnerReclaimRecord>,
     /// Per-key owner-side Get singleflight marker.  It deliberately lives in
     /// the same fence as local visibility and reclaim so `R ∩ local`,
@@ -1523,9 +1586,14 @@ pub(crate) struct OwnerKeyControlState {
 }
 
 impl OwnerKeyControlState {
+    fn local_access_fenced(&self) -> bool {
+        self.source_eviction_selection.is_some() || self.reclaim.is_some()
+    }
+
     fn is_idle(&self) -> bool {
         self.local_puts == 0
             && self.external_pending_puts == 0
+            && self.source_eviction_selection.is_none()
             && self.reclaim.is_none()
             && self.external_get.is_none()
     }
@@ -1671,7 +1739,7 @@ fn acquire_external_pending_put_fence_for_key(
     let mut controls = owner_key_control.lock_key(key);
     if controls
         .get(key)
-        .is_some_and(|state| state.reclaim.is_some())
+        .is_some_and(|state| state.local_access_fenced())
     {
         return Err(KvError::Api(ApiError::KeyBeingWritten {
             key: key.to_string(),
@@ -1758,6 +1826,15 @@ fn clone_if_owner_hot_entry_matches<T>(
         .then(|| current.clone())
 }
 
+fn owner_hot_source_has_active_holders<T>(selected_source: &Arc<T>) -> bool {
+    // A reclaimable committed source has exactly two strong references here:
+    // one in get_cached_info and one temporary selection pin. Any additional
+    // reference belongs to an active local reader/transfer. Sending such a
+    // source to the master would only make Prepare return Busy while its
+    // selection debt suppresses choosing a different, reclaimable victim.
+    Arc::strong_count(selected_source) > 2
+}
+
 enum OwnerHotPinResult<T> {
     Pinned(Arc<T>),
     ReclaimBusy,
@@ -1905,7 +1982,7 @@ fn pin_current_owner_hot_group_sources(
     Some(sources)
 }
 
-fn owner_hot_tp_cohort_key_rows(
+fn owner_hot_tp_atomic_batch_key_rows(
     identity: &OwnerHotReplicaIdentity,
     group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
 ) -> Result<Option<Vec<Vec<String>>>, ()> {
@@ -1954,8 +2031,8 @@ fn owner_hot_tp_cohort_key_rows(
     ))
 }
 
-fn pin_current_owner_hot_tp_cohort_sources(
-    cohort_key_rows: &[Vec<String>],
+fn pin_current_owner_hot_tp_atomic_batch_sources(
+    atomic_batch_key_rows: &[Vec<String>],
     expect_atomic_group: bool,
     get_cached_info: &DashMap<String, GetCachedInfo>,
     atomic_groups: &DashMap<
@@ -1964,8 +2041,8 @@ fn pin_current_owner_hot_tp_cohort_sources(
     >,
     counters: &OwnerHotCacheCounters,
 ) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
-    let mut cohort_sources = Vec::new();
-    for rank_keys in cohort_key_rows {
+    let mut atomic_batch_sources = Vec::new();
+    for rank_keys in atomic_batch_key_rows {
         if rank_keys.is_empty() {
             return None;
         }
@@ -2013,9 +2090,9 @@ fn pin_current_owner_hot_tp_cohort_sources(
         } else if rank_sources.len() != 1 || atomic_groups.contains_key(&rank_sources[0].0) {
             return None;
         }
-        cohort_sources.extend(rank_sources);
+        atomic_batch_sources.extend(rank_sources);
     }
-    Some(cohort_sources)
+    Some(atomic_batch_sources)
 }
 
 fn build_owner_hot_cache(
@@ -2023,13 +2100,12 @@ fn build_owner_hot_cache(
     counters: Arc<OwnerHotCacheCounters>,
     retry_queue: Arc<OwnerHotRetryQueue>,
     eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionEvent>,
-) -> moka::sync::Cache<String, OwnerHotCacheEntry> {
+) -> OwnerHotCache {
     assert!(
         capacity_bytes > 0,
         "owner hot-cache capacity must be positive"
     );
-    moka::sync::Cache::builder()
-        .max_capacity(capacity_bytes)
+    OwnerHotCache::builder(capacity_bytes)
         .weigher(|_key: &String, entry: &OwnerHotCacheEntry| entry.weight_bytes)
         .eviction_listener(move |key, entry, cause| {
             if cause != RemovalCause::Size {
@@ -2051,7 +2127,7 @@ fn build_owner_hot_cache(
                 memory_info: entry.memory_info.clone(),
                 selection_debt,
                 retry: false,
-                source_eviction_cohort: None,
+                source_eviction_atomic_batch: None,
                 retry_failures: 0,
             };
             if let Err(err) = eviction_tx.send(event) {
@@ -2140,7 +2216,7 @@ pub struct ClientKvApiInner {
     owner_key_control: Arc<OwnerKeyControlTable>,
     /// A weak-value admission/recency tier. It never owns resident memory and
     /// therefore cannot become a second physical-reclaim authority.
-    owner_hot_cache: Option<moka::sync::Cache<String, OwnerHotCacheEntry>>,
+    owner_hot_cache: Option<OwnerHotCache>,
     /// Exact selected identities remain here until their backing is physically
     /// Free or the source is restored to owner-hot.
     owner_source_eviction_selected:
@@ -2300,56 +2376,206 @@ impl ClientKvApiInner {
             OwnerHotPinResult::Stale => return OwnerHotEvictionPreparation::Obsolete,
         };
 
-        // A retry is authoritative for exactly one previously selected key.
-        // Re-expanding it would pin every cohort member again while the safe
-        // reclaim pipeline is waiting for those very pins to disappear.
-        if event.retry {
-            return OwnerHotEvictionPreparation::Ready {
-                trigger: trigger.clone(),
-                sources: vec![(trigger, memory_info)],
-            };
-        }
-
-        // Cohort lookup and pinning deliberately happen here, after the
-        // synchronous Moka listener has returned. Each source Arc is cloned
-        // directly from its current DashMap entry. A concurrent reclaim must
-        // wait for that shard read guard and then observes the extra strong
-        // reference, so no global owner-control lock is needed.
+        // A retry reaches this function only when no source-selection atomic_batch
+        // has been installed yet. Installed retries are handled from the
+        // event's exact `source_eviction_atomic_batch` before this method is called.
+        // Therefore a pre-selection retry must resolve the complete current
+        // TP/atomic atomic_batch again; degrading it to the trigger key would make
+        // the master reject a valid victim as an incomplete atomic_batch forever.
+        // AtomicBatch lookup and pinning deliberately happen after the synchronous
+        // Moka listener has returned. Each source Arc is cloned directly from
+        // its current DashMap entry. A concurrent reclaim must wait for that
+        // shard read guard and then observes the extra strong reference, so no
+        // global owner-control lock is needed.
         let group = self
             .owner_hot_atomic_groups
             .get(&trigger)
             .map(|entry| entry.value().clone());
-        let cohort_sources = match owner_hot_tp_cohort_key_rows(&trigger, group.as_deref()) {
-            Ok(Some(cohort_key_rows)) => pin_current_owner_hot_tp_cohort_sources(
-                &cohort_key_rows,
-                group.is_some(),
-                self.get_cached_info.as_ref(),
-                self.owner_hot_atomic_groups.as_ref(),
-                self.owner_hot_counters.as_ref(),
-            ),
-            Ok(None) => match group.as_deref() {
-                Some(group) => pin_current_owner_hot_group_sources(
-                    group,
-                    self.get_cached_info.as_ref(),
-                    self.owner_hot_counters.as_ref(),
-                ),
-                None => Some(vec![(trigger.clone(), memory_info)]),
-            },
-            Err(()) => None,
-        };
-        match cohort_sources {
+        let atomic_batch_sources =
+            match owner_hot_tp_atomic_batch_key_rows(&trigger, group.as_deref()) {
+                Ok(Some(atomic_batch_key_rows)) => {
+                    // pin_current_owner_hot_tp_atomic_batch_sources clones the trigger
+                    // again. Drop the probe pin first so the active-holder test
+                    // below has the exact index + selection baseline of two Arcs.
+                    drop(memory_info);
+                    pin_current_owner_hot_tp_atomic_batch_sources(
+                        &atomic_batch_key_rows,
+                        group.is_some(),
+                        self.get_cached_info.as_ref(),
+                        self.owner_hot_atomic_groups.as_ref(),
+                        self.owner_hot_counters.as_ref(),
+                    )
+                }
+                Ok(None) => match group.as_deref() {
+                    Some(group) => {
+                        drop(memory_info);
+                        pin_current_owner_hot_group_sources(
+                            group,
+                            self.get_cached_info.as_ref(),
+                            self.owner_hot_counters.as_ref(),
+                        )
+                    }
+                    None => Some(vec![(trigger.clone(), memory_info)]),
+                },
+                Err(()) => None,
+            };
+        match atomic_batch_sources {
             Some(sources) if !sources.is_empty() => {
-                OwnerHotEvictionPreparation::Ready { trigger, sources }
+                let active_members = sources
+                    .iter()
+                    .filter(|(_, source)| owner_hot_source_has_active_holders(source))
+                    .count();
+                if active_members == 0 {
+                    OwnerHotEvictionPreparation::Ready { trigger, sources }
+                } else {
+                    OwnerHotEvictionPreparation::TemporarilyPinned { active_members }
+                }
             }
             _ => {
                 self.owner_hot_counters
                     .group_trigger_incomplete
                     .fetch_add(1, Ordering::Relaxed);
-                OwnerHotEvictionPreparation::RetryableIncompleteCohort
+                OwnerHotEvictionPreparation::RetryableIncompleteAtomicBatch
             }
         }
     }
 
+    pub(crate) fn owner_hot_restore_source_selection(
+        &self,
+        identity: &OwnerHotReplicaIdentity,
+    ) -> bool {
+        let mut controls = self.owner_key_control.lock_key(&identity.key);
+        let Some(state) = controls.get_mut(&identity.key) else {
+            return false;
+        };
+        let matches = state
+            .source_eviction_selection
+            .as_ref()
+            .is_some_and(|selection| {
+                selection.put_id == (identity.put_time_ms, identity.put_version)
+            });
+        if !matches {
+            return false;
+        }
+        let selection = state
+            .source_eviction_selection
+            .take()
+            .expect("matching owner source selection must exist");
+        let replaced = self
+            .get_cached_info
+            .insert(identity.key.clone(), selection.cached_info);
+        assert!(
+            replaced.is_none(),
+            "rolling back an owner source selection must restore an empty local index"
+        );
+        if state.is_idle() {
+            controls.remove(&identity.key);
+        }
+        true
+    }
+
+    fn owner_hot_install_source_selection_debt(
+        &self,
+        identity: OwnerHotReplicaIdentity,
+        debt: Arc<OwnerHotSelectionDebt>,
+    ) -> bool {
+        match self.owner_source_eviction_selected.entry(identity) {
+            DashMapEntry::Vacant(entry) => {
+                entry.insert(debt.clone());
+                self.owner_hot_counters
+                    .add_source_eviction_selected_bytes(debt.weight_bytes);
+                true
+            }
+            DashMapEntry::Occupied(_) => false,
+        }
+    }
+
+    fn owner_hot_remove_source_selection_debt(
+        &self,
+        identity: &OwnerHotReplicaIdentity,
+    ) -> Option<Arc<OwnerHotSelectionDebt>> {
+        let debt = self
+            .owner_source_eviction_selected
+            .remove(identity)
+            .map(|(_, debt)| debt)?;
+        self.owner_hot_counters
+            .remove_source_eviction_selected_bytes(debt.weight_bytes);
+        Some(debt)
+    }
+
+    pub(crate) fn owner_hot_install_source_selection_fences(
+        &self,
+        sources: &[(OwnerHotReplicaIdentity, Arc<MemoryInfo>)],
+    ) -> OwnerHotSelectionFenceOutcome {
+        let mut installed = Vec::with_capacity(sources.len());
+        let mut outcome = OwnerHotSelectionFenceOutcome::Fenced;
+
+        for (identity, source) in sources {
+            let mut controls = self.owner_key_control.lock_key(&identity.key);
+            let control_busy = controls.get(&identity.key).is_some_and(|state| {
+                state.local_puts != 0
+                    || state.external_pending_puts != 0
+                    || state.external_get.is_some()
+                    || state.local_access_fenced()
+            });
+            if control_busy
+                || self
+                    .precommit_local_visible_info
+                    .contains_key(&identity.key)
+                || self.pending_local_get_info.contains_key(&identity.key)
+            {
+                outcome = OwnerHotSelectionFenceOutcome::Retryable;
+                break;
+            }
+
+            let cached_info = self
+                .get_cached_info
+                .remove_if(&identity.key, |_, cached| {
+                    (cached.put_time_ms, cached.put_version)
+                        == (identity.put_time_ms, identity.put_version)
+                        && Arc::ptr_eq(&cached.mem_holder, source)
+                })
+                .map(|(_, cached)| cached);
+            let Some(cached_info) = cached_info else {
+                outcome = OwnerHotSelectionFenceOutcome::Obsolete;
+                break;
+            };
+
+            let state = controls.entry(identity.key.clone()).or_default();
+            assert!(state.source_eviction_selection.is_none());
+            state.source_eviction_selection = Some(OwnerSourceEvictionSelection {
+                put_id: (identity.put_time_ms, identity.put_version),
+                cached_info,
+            });
+            installed.push(identity.clone());
+        }
+
+        if matches!(outcome, OwnerHotSelectionFenceOutcome::Fenced) {
+            // Every matching local index is now hidden under its per-key fence.
+            // Each source has exactly two expected Arcs: the selection record
+            // and this temporary atomic_batch pin.  No new local reader can enter,
+            // so an extra reference is an already-active holder and the whole
+            // atomic_batch must be rolled back before choosing another victim.
+            let active_members = sources
+                .iter()
+                .filter(|(_, source)| owner_hot_source_has_active_holders(source))
+                .count();
+            if active_members != 0 {
+                outcome = OwnerHotSelectionFenceOutcome::TemporarilyPinned { active_members };
+            }
+        }
+
+        if !matches!(outcome, OwnerHotSelectionFenceOutcome::Fenced) {
+            for identity in installed.iter().rev() {
+                assert!(
+                    self.owner_hot_restore_source_selection(identity),
+                    "partial owner source selection rollback must find every installed fence"
+                );
+            }
+        }
+        outcome
+    }
+
     fn owner_hot_track_committed(
         &self,
         key: &str,
@@ -2368,6 +2594,7 @@ impl ClientKvApiInner {
         }
         cache.insert(
             key.to_string(),
+            [OwnerHotPinAlias::new(memory_info)],
             OwnerHotCacheEntry {
                 put_id,
                 memory_info: Arc::downgrade(memory_info),
@@ -2404,7 +2631,7 @@ impl ClientKvApiInner {
         let Some(cache) = self.owner_hot_cache.as_ref() else {
             return;
         };
-        if cache.get(key).is_some_and(|entry| {
+        if cache.get(&key.to_string()).is_some_and(|entry| {
             entry.put_id == put_id && Weak::ptr_eq(&entry.memory_info, &Arc::downgrade(memory_info))
         }) {
             return;
@@ -2421,7 +2648,7 @@ impl ClientKvApiInner {
         let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
         {
             return false;
         }
@@ -2443,18 +2670,9 @@ impl ClientKvApiInner {
             put_version: put_id.1,
         };
         if let Some(cache) = self.owner_hot_cache.as_ref() {
-            let _ = cache.entry(key.to_string()).and_compute_with(|entry| {
-                if entry
-                    .as_ref()
-                    .is_some_and(|entry| entry.value().put_id == put_id)
-                {
-                    MokaComputeOp::Remove
-                } else {
-                    MokaComputeOp::Nop
-                }
-            });
+            cache.invalidate_if(&key.to_string(), |entry| entry.put_id == put_id);
         }
-        if let Some((_identity, debt)) = self.owner_source_eviction_selected.remove(&identity) {
+        if let Some(debt) = self.owner_hot_remove_source_selection_debt(&identity) {
             debt.release();
             self.owner_hot_counters
                 .source_evict_committed_members
@@ -2483,6 +2701,15 @@ impl ClientKvApiInner {
         }
     }
 
+    pub(crate) fn owner_hot_pin_memory_info(
+        &self,
+        memory_info: &Arc<MemoryInfo>,
+    ) -> Option<PinGuard> {
+        self.owner_hot_cache
+            .as_ref()?
+            .try_pin_alias(OwnerHotPinAlias::new(memory_info))
+    }
+
     pub(crate) fn short_circuit_put_payload_path_enabled(&self) -> bool {
         self.test_spec_config.short_circuit_put_payload_path
     }
@@ -2532,7 +2759,7 @@ impl ClientKvApiInner {
         let mut controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
         {
             return Err(KvError::Api(ApiError::KeyBeingWritten {
                 key: key.to_string(),
@@ -2587,7 +2814,7 @@ impl ClientKvApiInner {
         let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
         {
             tracing::debug!(
                 "skip local snapshot publication behind owner reclaim fence: key={} put_id=({},{})",
@@ -2610,7 +2837,7 @@ impl ClientKvApiInner {
         let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
         {
             return false;
         }
@@ -2624,7 +2851,7 @@ impl ClientKvApiInner {
             let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
+                .is_some_and(|state| state.local_access_fenced())
             {
                 return None;
             }
@@ -2657,7 +2884,7 @@ impl ClientKvApiInner {
         let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
         {
             return None;
         }
@@ -2689,7 +2916,7 @@ impl ClientKvApiInner {
                 let controls = self.owner_key_control.lock_key(key);
                 if controls
                     .get(key)
-                    .is_some_and(|state| state.reclaim.is_some())
+                    .is_some_and(|state| state.local_access_fenced())
                 {
                     return None;
                 }
@@ -2727,6 +2954,7 @@ impl ClientKvApiInner {
             len: memory_info.len,
             holder_id: external_holder_id,
         };
+        let owner_hot_pin = self.owner_hot_pin_memory_info(&memory_info);
         let previous = self.external_get_holding.inner().insert(
             key,
             ExternalHoldingGetInfo {
@@ -2738,6 +2966,7 @@ impl ClientKvApiInner {
                     .get_member_info_cached(req_node_id)
                     .map(|member| member.node_start_time),
                 memory_info,
+                _owner_hot_pin: owner_hot_pin,
             },
         );
         assert!(
@@ -2787,7 +3016,7 @@ impl ClientKvApiInner {
         let controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
-            .is_some_and(|state| state.reclaim.is_some())
+            .is_some_and(|state| state.local_access_fenced())
             || self.pending_local_get_info.contains_key(key)
         {
             return Err(KvError::Api(ApiError::KeyBeingWritten {
@@ -2841,7 +3070,7 @@ impl ClientKvApiInner {
             let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
+                .is_some_and(|state| state.local_access_fenced())
             {
                 return Err(KvError::Api(ApiError::KeyBeingWritten {
                     key: key.to_string(),
@@ -2930,7 +3159,7 @@ impl ClientKvApiInner {
             let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
+                .is_some_and(|state| state.local_access_fenced())
             {
                 return Err(KvError::Api(ApiError::KeyBeingWritten {
                     key: key.to_string(),
@@ -2969,7 +3198,7 @@ impl ClientKvApiInner {
             let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
+                .is_some_and(|state| state.local_access_fenced())
             {
                 tracing::debug!(
                     "skip get cache publication behind owner reclaim fence: key={} put_id=({},{})",
@@ -3011,7 +3240,7 @@ impl ClientKvApiInner {
         assert!(
             !controls
                 .get(key)
-                .is_some_and(|state| state.reclaim.is_some()),
+                .is_some_and(|state| state.local_access_fenced()),
             "precommit local index publication must not cross an owner reclaim fence"
         );
         let (slot_size, grant_id, slot_index) = memory_info
@@ -3076,7 +3305,7 @@ impl ClientKvApiInner {
             let controls = self.owner_key_control.lock_key(key);
             if controls
                 .get(key)
-                .is_some_and(|state| state.reclaim.is_some())
+                .is_some_and(|state| state.local_access_fenced())
             {
                 return Err(KvError::Api(ApiError::KeyBeingWritten {
                     key: key.to_string(),
@@ -3792,17 +4021,21 @@ impl OwnerLocalReserveClassState {
 mod owner_reclaim_slot_tests {
     use super::{
         ExternalPendingPutCtx, ExternalPendingPutFenceGuard, OwnerHotCacheCounters,
-        OwnerHotCacheEntry, OwnerHotEvictionEvent, OwnerHotReplicaIdentity, OwnerHotRetryQueue,
-        OwnerHotSelectionDebt, OwnerKeyControlState, OwnerKeyControlTable,
-        OwnerLocalReserveGrantState, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef,
-        OwnerLocalReserveSlotState, OwnerReclaimRecord, acquire_external_pending_put_fence_for_key,
+        OwnerHotCacheEntry, OwnerHotEvictionEvent, OwnerHotPinAlias, OwnerHotReplicaIdentity,
+        OwnerHotRetryQueue, OwnerHotSelectionDebt, OwnerHotSelectionFenceOutcome,
+        OwnerKeyControlState, OwnerKeyControlTable, OwnerLocalReserveGrantState,
+        OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, OwnerLocalReserveSlotState,
+        OwnerReclaimRecord, acquire_external_pending_put_fence_for_key,
         allocate_external_holding_id, build_owner_hot_cache, clone_if_owner_hot_entry_matches,
-        forget_owner_hot_atomic_group, owner_hot_tp_cohort_key_rows,
-        pin_current_owner_hot_source_from_index, register_owner_hot_atomic_group,
+        forget_owner_hot_atomic_group, owner_hot_source_has_active_holders,
+        owner_hot_tp_atomic_batch_key_rows, pin_current_owner_hot_source_from_index,
+        register_owner_hot_atomic_group,
     };
     use crate::master_kv_router::msg_pack::{
-        OwnerReclaimItem, PutAtomicGroup, PutAtomicGroupMember,
+        BatchOwnerReclaimReq, OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimItemState,
+        OwnerReclaimPhase, OwnerReclaimReason, PutAtomicGroup, PutAtomicGroupMember,
     };
+    use crate::p2p::msg_pack::MsgPack;
     use dashmap::DashMap;
     use parking_lot::Mutex;
     use std::sync::atomic::{AtomicU64, Ordering};
@@ -3858,6 +4091,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 1,
                 external_pending_puts: 1,
+                source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
             },
@@ -3882,6 +4116,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 1,
                 external_pending_puts: 1,
+                source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
             },
@@ -3908,6 +4143,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 1,
                 external_pending_puts: 1,
+                source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
             },
@@ -4005,6 +4241,264 @@ mod owner_reclaim_slot_tests {
         );
     }
 
+    #[test]
+    fn pressure_victim_rejects_an_extra_active_holder() {
+        let indexed = Arc::new(7u64);
+        let selected = indexed.clone();
+        assert_eq!(Arc::strong_count(&selected), 2);
+        assert!(
+            !owner_hot_source_has_active_holders(&selected),
+            "index plus the temporary selection pin is reclaimable"
+        );
+
+        let active_reader = indexed.clone();
+        assert_eq!(Arc::strong_count(&selected), 3);
+        assert!(owner_hot_source_has_active_holders(&selected));
+
+        drop(active_reader);
+        assert!(!owner_hot_source_has_active_holders(&selected));
+    }
+
+    #[limit_thirdparty::tokio::test(flavor = "multi_thread", worker_threads = 8)]
+    async fn source_selection_fence_closes_late_get_and_rolls_back_whole_atomic_batch() {
+        use crate::client_kv_api::PutOptionalArgs;
+        use crate::kvcore_test_lib::{
+            integration_test_lock, start_master_and_client, stop_master_and_client,
+        };
+
+        let _test_guard = integration_test_lock().await;
+        let (master, client) = start_master_and_client(
+            "source_selection_fence_master",
+            "source_selection_fence_owner",
+        )
+        .await;
+        let owner_view = client.client_kv_api_view();
+        let inner = owner_view.client_kv_api().inner();
+        let keys = ["selection-rank0", "selection-rank1"];
+        for key in keys {
+            inner
+                .put(key, &[7u8; 4096], PutOptionalArgs::default())
+                .await
+                .expect("owner put must publish a committed route");
+            let (holder, _remote) = inner
+                .get(key)
+                .await
+                .expect("owner get must succeed")
+                .expect("committed route must be readable");
+            drop(holder);
+        }
+
+        let sources = keys
+            .iter()
+            .map(|key| {
+                let cached = inner
+                    .get_cached_info
+                    .get(*key)
+                    .expect("committed owner source must be indexed");
+                (
+                    OwnerHotReplicaIdentity {
+                        key: (*key).to_string(),
+                        put_time_ms: cached.put_time_ms,
+                        put_version: cached.put_version,
+                    },
+                    cached.mem_holder.clone(),
+                )
+            })
+            .collect::<Vec<_>>();
+        assert!(
+            sources
+                .iter()
+                .all(|(_, source)| !owner_hot_source_has_active_holders(source)),
+            "the initial victim check must see only index plus selection pins"
+        );
+
+        // Reproduce the r11 TOCTOU exactly: a local Get acquires one atomic_batch
+        // member after the dispatcher's first holder check but before the
+        // source-selection fence is installed.
+        let late_reader = inner
+            .local_visible_mem_holder(keys[1])
+            .expect("late local Get must acquire the source before fencing");
+        assert!(matches!(
+            inner.owner_hot_install_source_selection_fences(&sources),
+            OwnerHotSelectionFenceOutcome::TemporarilyPinned { active_members: 1 }
+        ));
+        for key in keys {
+            assert!(inner.get_cached_info.contains_key(key));
+            assert!(
+                inner
+                    .owner_key_control
+                    .lock_key(key)
+                    .get(key)
+                    .is_none_or(|state| state.source_eviction_selection.is_none()),
+                "a pinned member must roll back every partial atomic_batch fence"
+            );
+        }
+
+        drop(late_reader);
+        assert!(matches!(
+            inner.owner_hot_install_source_selection_fences(&sources),
+            OwnerHotSelectionFenceOutcome::Fenced
+        ));
+        for key in keys {
+            assert!(!inner.get_cached_info.contains_key(key));
+            assert!(inner.local_visible_mem_holder(key).is_none());
+            assert!(
+                acquire_external_pending_put_fence_for_key(&inner.owner_key_control, key).is_err(),
+                "a new local Put must not cross a source-selection fence"
+            );
+        }
+
+        let identities = sources
+            .iter()
+            .map(|(identity, _)| identity.clone())
+            .collect::<Vec<_>>();
+        drop(sources);
+        let master_id = master
+            .cluster_manager_view()
+            .cluster_manager()
+            .get_self_info()
+            .id;
+
+        let mismatched = OwnerReclaimItem {
+            key: identities[0].key.clone(),
+            put_id: (
+                identities[0].put_time_ms,
+                identities[0].put_version.wrapping_add(1),
+            ),
+            epoch: 90,
+            backing: OwnerReclaimBacking::Allocation,
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
+        };
+        let mismatch_resp = super::reclaim::handle_batch_owner_reclaim(
+            &owner_view,
+            MsgPack {
+                serialize_part: BatchOwnerReclaimReq {
+                    phase: OwnerReclaimPhase::Prepare,
+                    items: vec![mismatched],
+                },
+                raw_bytes: Vec::new(),
+            },
+            master_id.clone().into(),
+        )
+        .await;
+        assert_eq!(
+            mismatch_resp.serialize_part.items[0].state,
+            OwnerReclaimItemState::Busy
+        );
+        assert!(
+            inner
+                .owner_key_control
+                .lock_key(&identities[0].key)
+                .get(&identities[0].key)
+                .is_some_and(|state| state.source_eviction_selection.is_some()),
+            "a mismatched Prepare must not consume the owner selection"
+        );
+
+        let matching = identities
+            .iter()
+            .enumerate()
+            .map(|(index, identity)| OwnerReclaimItem {
+                key: identity.key.clone(),
+                put_id: (identity.put_time_ms, identity.put_version),
+                epoch: 100 + index as u64,
+                backing: OwnerReclaimBacking::Allocation,
+                reason: OwnerReclaimReason::OwnerCapacityEviction,
+            })
+            .collect::<Vec<_>>();
+        let prepare_resp = super::reclaim::handle_batch_owner_reclaim(
+            &owner_view,
+            MsgPack {
+                serialize_part: BatchOwnerReclaimReq {
+                    phase: OwnerReclaimPhase::Prepare,
+                    items: matching.clone(),
+                },
+                raw_bytes: Vec::new(),
+            },
+            master_id.clone().into(),
+        )
+        .await;
+        assert!(
+            prepare_resp
+                .serialize_part
+                .items
+                .iter()
+                .all(|item| item.state == OwnerReclaimItemState::Prepared),
+            "matching Prepare must atomically promote each selection into reclaim"
+        );
+        for key in keys {
+            assert!(inner.local_visible_mem_holder(key).is_none());
+        }
+
+        let abort_resp = super::reclaim::handle_batch_owner_reclaim(
+            &owner_view,
+            MsgPack {
+                serialize_part: BatchOwnerReclaimReq {
+                    phase: OwnerReclaimPhase::Abort,
+                    items: matching,
+                },
+                raw_bytes: Vec::new(),
+            },
+            master_id.into(),
+        )
+        .await;
+        assert!(
+            abort_resp
+                .serialize_part
+                .items
+                .iter()
+                .all(|item| item.state == OwnerReclaimItemState::Aborted)
+        );
+        for key in keys {
+            assert!(
+                inner.local_visible_mem_holder(key).is_some(),
+                "Abort must restore the exact committed local index"
+            );
+        }
+
+        let group = PutAtomicGroup {
+            members: identities
+                .iter()
+                .map(|identity| PutAtomicGroupMember {
+                    key: identity.key.clone(),
+                    put_id: (identity.put_time_ms, identity.put_version),
+                })
+                .collect(),
+        };
+        inner.owner_hot_register_atomic_group(&group);
+        let trigger_weak = {
+            let cached = inner
+                .get_cached_info
+                .get(&identities[0].key)
+                .expect("Abort-restored trigger must be indexed");
+            Arc::downgrade(&cached.mem_holder)
+        };
+        let retry_event = OwnerHotEvictionEvent {
+            key: identities[0].key.clone(),
+            put_id: (identities[0].put_time_ms, identities[0].put_version),
+            memory_info: trigger_weak,
+            selection_debt: OwnerHotSelectionDebt::new(
+                4096,
+                inner.owner_hot_counters.selection_debt_bytes.clone(),
+            ),
+            retry: true,
+            source_eviction_atomic_batch: None,
+            retry_failures: 1,
+        };
+        match inner.owner_hot_prepare_eviction(&retry_event) {
+            super::OwnerHotEvictionPreparation::Ready { sources, .. } => {
+                assert_eq!(
+                    sources.len(),
+                    identities.len(),
+                    "a pre-selection retry must resolve the complete atomic atomic_batch"
+                );
+            }
+            _ => panic!("a pre-selection retry with a complete atomic_batch must be ready"),
+        }
+        retry_event.selection_debt.release();
+
+        stop_master_and_client(master, client).await;
+    }
+
     #[test]
     fn dispatcher_pin_and_reclaim_prepare_are_serialized_by_the_current_index() {
         let current = Mutex::new(Some(((10, 2), Arc::new(7u64))));
@@ -4065,7 +4559,7 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             selection_debt: debt,
             retry: true,
-            source_eviction_cohort: None,
+            source_eviction_atomic_batch: None,
             retry_failures: 0,
         };
         retry_queue.schedule(event.clone(), "first failure");
@@ -4109,7 +4603,7 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             selection_debt: debt,
             retry: true,
-            source_eviction_cohort: None,
+            source_eviction_atomic_batch: None,
             retry_failures: 0,
         };
 
@@ -4150,7 +4644,7 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             selection_debt: remove_debt,
             retry: true,
-            source_eviction_cohort: None,
+            source_eviction_atomic_batch: None,
             retry_failures: 0,
         };
         for _ in 0..CHURN {
@@ -4194,7 +4688,7 @@ mod owner_reclaim_slot_tests {
     }
 
     #[test]
-    fn owner_hot_tp_cohort_expands_the_same_group_boundary_across_ranks() {
+    fn owner_hot_tp_atomic_batch_expands_the_same_group_boundary_across_ranks() {
         let identity = OwnerHotReplicaIdentity {
             key: "page0_model_0_2".to_string(),
             put_time_ms: 10,
@@ -4213,7 +4707,7 @@ mod owner_reclaim_slot_tests {
             ],
         };
         assert_eq!(
-            owner_hot_tp_cohort_key_rows(&identity, Some(&rank0_group)),
+            owner_hot_tp_atomic_batch_key_rows(&identity, Some(&rank0_group)),
             Ok(Some(vec![
                 vec!["page0_model_0_2".to_string(), "page1_model_0_2".to_string(),],
                 vec!["page0_model_1_2".to_string(), "page1_model_1_2".to_string(),],
@@ -4230,7 +4724,7 @@ mod owner_reclaim_slot_tests {
             ],
         };
         assert_eq!(
-            owner_hot_tp_cohort_key_rows(&identity, Some(&mixed_rank_group)),
+            owner_hot_tp_atomic_batch_key_rows(&identity, Some(&mixed_rank_group)),
             Err(())
         );
     }
@@ -4246,18 +4740,22 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             weight_bytes: 6,
         };
+        let alias = |key: &str, put_version: usize| OwnerHotPinAlias {
+            key: key.to_string(),
+            memory_info_ptr: put_version,
+        };
 
-        cache.insert("explicit".to_string(), entry(0));
+        cache.insert("explicit".to_string(), [alias("explicit", 0)], entry(0));
         cache.run_pending_tasks();
-        cache.invalidate("explicit");
+        cache.invalidate(&"explicit".to_string());
         cache.run_pending_tasks();
         assert_eq!(counters.size_evictions.load(Ordering::Relaxed), 0);
 
-        cache.insert("size-a".to_string(), entry(1));
-        cache.insert("size-b".to_string(), entry(2));
+        cache.insert("size-a".to_string(), [alias("size-a", 1)], entry(1));
+        cache.insert("size-b".to_string(), [alias("size-b", 2)], entry(2));
         cache.run_pending_tasks();
         assert!(counters.size_evictions.load(Ordering::Relaxed) >= 1);
-        assert_eq!(cache.policy().max_capacity(), Some(10));
+        assert_eq!(cache.max_capacity(), Some(10));
         let event = rx
             .try_recv()
             .expect("the Moka listener must emit lightweight metadata without pinning");
@@ -4277,6 +4775,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 0,
                 external_pending_puts: 0,
+                source_eviction_selection: None,
                 reclaim: Some(OwnerReclaimRecord::Committed(OwnerReclaimItem {
                     key: "fenced".to_string(),
                     ..OwnerReclaimItem::default()
@@ -4289,7 +4788,10 @@ mod owner_reclaim_slot_tests {
             .iter()
             .map(|key| {
                 let shard = controls.lock_key(key);
-                if shard.get(key).is_some_and(|state| state.reclaim.is_some()) {
+                if shard
+                    .get(key)
+                    .is_some_and(|state| state.local_access_fenced())
+                {
                     None
                 } else {
                     resolved_keys.push(key.to_string());
@@ -4599,7 +5101,7 @@ impl ClientKvApiInner {
             .as_ref()
             .map(|cache| {
                 (
-                    cache.policy().max_capacity().unwrap_or(0),
+                    cache.max_capacity().unwrap_or(0),
                     cache.entry_count(),
                     cache.weighted_size(),
                 )
@@ -4723,6 +5225,10 @@ impl ClientKvApiInner {
                 .owner_hot_counters
                 .selection_debt_bytes
                 .load(Ordering::Relaxed),
+            hot_source_eviction_selected_bytes: self
+                .owner_hot_counters
+                .source_eviction_selected_bytes
+                .load(Ordering::Relaxed),
             hot_eviction_skipped_stale: self
                 .owner_hot_counters
                 .skipped_stale
@@ -4731,6 +5237,10 @@ impl ClientKvApiInner {
                 .owner_hot_counters
                 .skipped_reclaim
                 .load(Ordering::Relaxed),
+            hot_eviction_skipped_active_holders: self
+                .owner_hot_counters
+                .skipped_active_holders
+                .load(Ordering::Relaxed),
             hot_group_registry_entries: self.owner_hot_atomic_groups.len() as u64,
             hot_group_trigger_duplicates: self
                 .owner_hot_counters
@@ -5296,8 +5806,10 @@ impl ClientKvApi {
                                 source_evict_retry_scheduled = snapshot.hot_source_evict_retry_scheduled,
                                 source_evict_retry_emitted = snapshot.hot_source_evict_retry_emitted,
                                 selection_debt_bytes = snapshot.hot_selection_debt_bytes,
+                                source_eviction_selected_bytes = snapshot.hot_source_eviction_selected_bytes,
                                 skipped_stale = snapshot.hot_eviction_skipped_stale,
                                 skipped_reclaim = snapshot.hot_eviction_skipped_reclaim,
+                                skipped_active_holders = snapshot.hot_eviction_skipped_active_holders,
                                 group_registry_entries = snapshot.hot_group_registry_entries,
                                 group_trigger_duplicates = snapshot.hot_group_trigger_duplicates,
                                 group_trigger_incomplete = snapshot.hot_group_trigger_incomplete,
@@ -5331,7 +5843,7 @@ impl ClientKvApi {
         // The Moka eviction listener is synchronous and must never block while
         // holding Moka's housekeeper lock. Events contain only weak payload
         // references and are deduplicated by exact selected identities, so use
-        // a lossless metadata channel instead of dropping cohorts when the old
+        // a lossless metadata channel instead of dropping atomic_batches when the old
         // bounded queue briefly filled under cache pressure.
         let (owner_hot_eviction_tx, owner_hot_eviction_rx) =
             tokio::sync::ampsc::unbounded_channel();
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index 8bfa822..862adab 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -1,7 +1,8 @@
 use super::{
     ClientKvApiInner, OwnerHotEvictionEvent, OwnerHotEvictionPreparation, OwnerHotSelectionDebt,
-    OwnerLocalReserveClassState, OwnerLocalReserveGrantState, OwnerLocalReservePoolState,
-    OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, ReplicaTaskJob, ReplicaTaskTarget,
+    OwnerHotSelectionFenceOutcome, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
+    OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef,
+    ReplicaTaskJob, ReplicaTaskTarget,
     local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
     owner_hot_weight_bytes,
 };
@@ -26,7 +27,7 @@ use crate::{
         BatchPutStartItemReq, BatchPutStartReq, BatchPutStartResp,
         BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
         EnqueueReplicaTaskItemResp, GroupedBatchPutDoneItemReq, GroupedBatchPutDoneReq,
-        GroupedBatchPutDoneResp, OwnerReclaimBacking, OwnerSourceEvictionCohort,
+        GroupedBatchPutDoneResp, OwnerReclaimBacking, OwnerSourceEvictionAtomicBatch,
         OwnerSourceEvictionMember, OwnerSourceEvictionOutcome, PutAppendDoneReq, PutAppendDoneResp,
         PutAppendRevokeReq, PutAppendStartOutcome, PutAppendStartReq, PutAppendStartResp,
         PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
@@ -2224,12 +2225,12 @@ impl ClientKvApiInner {
 
     pub async fn batch_evict_owner_source(
         &self,
-        cohorts: Vec<OwnerSourceEvictionCohort>,
+        atomic_batches: Vec<OwnerSourceEvictionAtomicBatch>,
     ) -> KvResult<BatchEvictOwnerSourceResp> {
-        if cohorts.is_empty() {
+        if atomic_batches.is_empty() {
             return Ok(BatchEvictOwnerSourceResp {
                 operation_id: 0,
-                cohorts: Vec::new(),
+                atomic_batches: Vec::new(),
                 error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
                 error_json: String::new(),
             });
@@ -2247,7 +2248,7 @@ impl ClientKvApiInner {
             serialize_part: BatchEvictOwnerSourceReq {
                 operation_id,
                 owner_node_start_time: self_info.node_start_time,
-                cohorts,
+                atomic_batches,
             },
             raw_bytes: Vec::new(),
         };
@@ -2847,7 +2848,7 @@ const OWNER_LOCAL_PUBLISH_RETRY_MAX: Duration = Duration::from_secs(1);
 mod owner_hot_replica_policy_tests {
     use super::{
         OwnerLocalPublishItem, complete_owner_local_publish_group_lens,
-        owner_local_publish_cohort_complete,
+        owner_local_publish_atomic_batch_complete,
     };
     use crate::master_kv_router::msg_pack::{
         PutAtomicGroup, PutAtomicGroupMember, PutDoneCommittedSlot,
@@ -2926,11 +2927,19 @@ mod owner_hot_replica_policy_tests {
             publish_item("single", (2, 0), None),
         ];
         let partial = vec![&items[0]];
-        assert!(!owner_local_publish_cohort_complete(&items[0], &partial));
+        assert!(!owner_local_publish_atomic_batch_complete(
+            &items[0], &partial
+        ));
         let complete = vec![&items[0], &items[1]];
-        assert!(owner_local_publish_cohort_complete(&items[0], &complete));
-        assert!(owner_local_publish_cohort_complete(&items[1], &complete));
-        assert!(owner_local_publish_cohort_complete(&items[2], &partial));
+        assert!(owner_local_publish_atomic_batch_complete(
+            &items[0], &complete
+        ));
+        assert!(owner_local_publish_atomic_batch_complete(
+            &items[1], &complete
+        ));
+        assert!(owner_local_publish_atomic_batch_complete(
+            &items[2], &partial
+        ));
     }
 }
 
@@ -2978,13 +2987,13 @@ fn owner_source_eviction_member(
 
 fn finish_owner_source_selection(
     inner: &ClientKvApiInner,
-    cohort: &OwnerSourceEvictionCohort,
+    atomic_batch: &OwnerSourceEvictionAtomicBatch,
     restore_current: bool,
     reason: &str,
 ) {
-    for member in &cohort.members {
+    for member in &atomic_batch.members {
         let identity = owner_source_eviction_identity(member);
-        if let Some((_identity, debt)) = inner.owner_source_eviction_selected.remove(&identity) {
+        if let Some(debt) = inner.owner_hot_remove_source_selection_debt(&identity) {
             debt.release();
             inner
                 .owner_hot_counters
@@ -2995,6 +3004,7 @@ fn finish_owner_source_selection(
         if !restore_current {
             continue;
         }
+        inner.owner_hot_restore_source_selection(&identity);
         let group = inner
             .owner_hot_atomic_groups
             .get(&identity)
@@ -3014,18 +3024,18 @@ fn finish_owner_source_selection(
 fn schedule_owner_source_eviction_retry(
     inner: &ClientKvApiInner,
     mut event: OwnerHotEvictionEvent,
-    cohort: Arc<OwnerSourceEvictionCohort>,
+    atomic_batch: Arc<OwnerSourceEvictionAtomicBatch>,
     reason: &'static str,
 ) {
     event.retry = true;
-    event.source_eviction_cohort = Some(cohort);
+    event.source_eviction_atomic_batch = Some(atomic_batch);
     inner.owner_hot_retry_queue.schedule(event, reason);
 }
 
 fn prepare_owner_source_eviction_event(
     inner: &ClientKvApiInner,
     mut event: OwnerHotEvictionEvent,
-) -> Option<(OwnerHotEvictionEvent, Arc<OwnerSourceEvictionCohort>)> {
+) -> Option<(OwnerHotEvictionEvent, Arc<OwnerSourceEvictionAtomicBatch>)> {
     let trigger = super::OwnerHotReplicaIdentity {
         key: event.key.clone(),
         put_time_ms: event.put_id.0,
@@ -3035,17 +3045,22 @@ fn prepare_owner_source_eviction_event(
     if event.retry {
         let _ = inner.owner_hot_retry_queue.take_for_inflight(&trigger);
     }
-    if let Some(cohort) = event.source_eviction_cohort.clone() {
-        if cohort.members.iter().all(|member| {
+    if let Some(atomic_batch) = event.source_eviction_atomic_batch.clone() {
+        if atomic_batch.members.iter().all(|member| {
             inner
                 .owner_source_eviction_selected
                 .contains_key(&owner_source_eviction_identity(member))
         }) {
-            return Some((event, cohort));
+            return Some((event, atomic_batch));
         }
         // Commit/invalidation may win the race with a due retry. Any remaining
         // selected members are restored rather than leaving false projected credit.
-        finish_owner_source_selection(inner, &cohort, true, "retry cohort lost selected identity");
+        finish_owner_source_selection(
+            inner,
+            &atomic_batch,
+            true,
+            "retry atomic_batch lost selected identity",
+        );
         event.selection_debt.release();
         return None;
     }
@@ -3068,10 +3083,40 @@ fn prepare_owner_source_eviction_event(
             );
             return None;
         }
-        OwnerHotEvictionPreparation::RetryableIncompleteCohort => {
+        OwnerHotEvictionPreparation::RetryableIncompleteAtomicBatch => {
             inner
                 .owner_hot_retry_queue
-                .schedule(event, "owner source cohort is temporarily incomplete");
+                .schedule(event, "owner source atomic_batch is temporarily incomplete");
+            return None;
+        }
+        OwnerHotEvictionPreparation::TemporarilyPinned { active_members } => {
+            // This event was removed from Moka, but its source atomic_batch is still
+            // serving a local reader. Do not hand it to the master's reclaim
+            // loop and do not retain projected selection credit. Re-admission
+            // refreshes the trigger's recency so the next pressure kick can
+            // choose a different, currently reclaimable victim.
+            event.selection_debt.release();
+            inner.owner_hot_counters.skipped_active_holders.fetch_add(
+                u64::try_from(active_members).unwrap_or(u64::MAX),
+                Ordering::Relaxed,
+            );
+            let group = inner
+                .owner_hot_atomic_groups
+                .get(&trigger)
+                .map(|entry| entry.value().clone());
+            let restored = inner.owner_hot_admit_published_committed(
+                &event.key,
+                event.put_id,
+                group.as_deref(),
+            );
+            tracing::debug!(
+                key = event.key,
+                put_time_ms = event.put_id.0,
+                put_version = event.put_id.1,
+                active_members,
+                restored,
+                "owner pressure eviction skipped an actively held source atomic_batch"
+            );
             return None;
         }
         OwnerHotEvictionPreparation::Obsolete => {
@@ -3103,13 +3148,47 @@ fn prepare_owner_source_eviction_event(
         );
         return None;
     };
-    let cohort = Arc::new(OwnerSourceEvictionCohort { members });
+    let atomic_batch = Arc::new(OwnerSourceEvictionAtomicBatch { members });
+
+    match inner.owner_hot_install_source_selection_fences(&sources) {
+        OwnerHotSelectionFenceOutcome::Fenced => {}
+        OwnerHotSelectionFenceOutcome::Retryable => {
+            inner
+                .owner_hot_retry_queue
+                .schedule(event, "owner source selection fence is temporarily busy");
+            return None;
+        }
+        OwnerHotSelectionFenceOutcome::TemporarilyPinned { active_members } => {
+            event.selection_debt.release();
+            inner.owner_hot_counters.skipped_active_holders.fetch_add(
+                u64::try_from(active_members).unwrap_or(u64::MAX),
+                Ordering::Relaxed,
+            );
+            let group = inner
+                .owner_hot_atomic_groups
+                .get(&trigger)
+                .map(|entry| entry.value().clone());
+            inner.owner_hot_admit_published_committed(&event.key, event.put_id, group.as_deref());
+            return None;
+        }
+        OwnerHotSelectionFenceOutcome::Obsolete => {
+            event.selection_debt.release();
+            inner
+                .owner_hot_counters
+                .source_evict_obsolete
+                .fetch_add(1, Ordering::Relaxed);
+            return None;
+        }
+    }
 
-    if cohort.members.iter().any(|member| {
+    if atomic_batch.members.iter().any(|member| {
         inner
             .owner_source_eviction_selected
             .contains_key(&owner_source_eviction_identity(member))
     }) {
+        for member in &atomic_batch.members {
+            inner.owner_hot_restore_source_selection(&owner_source_eviction_identity(member));
+        }
         event.selection_debt.release();
         inner
             .owner_hot_counters
@@ -3118,8 +3197,8 @@ fn prepare_owner_source_eviction_event(
         return None;
     }
 
-    let mut installed = Vec::with_capacity(cohort.members.len());
-    for ((identity, memory_info), member) in sources.iter().zip(cohort.members.iter()) {
+    let mut installed = Vec::with_capacity(atomic_batch.members.len());
+    for ((identity, memory_info), member) in sources.iter().zip(atomic_batch.members.iter()) {
         debug_assert_eq!(identity, &owner_source_eviction_identity(member));
         let debt = if identity == &trigger {
             event.selection_debt.clone()
@@ -3129,27 +3208,25 @@ fn prepare_owner_source_eviction_event(
                 inner.owner_hot_counters.selection_debt_bytes.clone(),
             )
         };
-        if inner
-            .owner_source_eviction_selected
-            .insert(identity.clone(), debt.clone())
-            .is_some()
-        {
+        if !inner.owner_hot_install_source_selection_debt(identity.clone(), debt.clone()) {
             debt.release();
             for installed_identity in installed {
-                if let Some((_identity, installed_debt)) = inner
-                    .owner_source_eviction_selected
-                    .remove(&installed_identity)
+                if let Some(installed_debt) =
+                    inner.owner_hot_remove_source_selection_debt(&installed_identity)
                 {
                     installed_debt.release();
                 }
             }
+            for member in &atomic_batch.members {
+                inner.owner_hot_restore_source_selection(&owner_source_eviction_identity(member));
+            }
             event.selection_debt.release();
             return None;
         }
         installed.push(identity.clone());
     }
-    event.source_eviction_cohort = Some(cohort.clone());
-    Some((event, cohort))
+    event.source_eviction_atomic_batch = Some(atomic_batch.clone());
+    Some((event, atomic_batch))
 }
 
 async fn process_owner_source_eviction_events(
@@ -3164,44 +3241,44 @@ async fn process_owner_source_eviction_events(
     if prepared.is_empty() {
         return;
     }
-    let cohorts = prepared
+    let atomic_batches = prepared
         .iter()
-        .map(|(_, cohort)| cohort.as_ref().clone())
+        .map(|(_, atomic_batch)| atomic_batch.as_ref().clone())
         .collect::<Vec<_>>();
-    let response = inner.batch_evict_owner_source(cohorts).await;
+    let response = inner.batch_evict_owner_source(atomic_batches).await;
     let Ok(response) = response else {
-        for (event, cohort) in prepared {
+        for (event, atomic_batch) in prepared {
             schedule_owner_source_eviction_retry(
                 inner,
                 event,
-                cohort,
+                atomic_batch,
                 "owner source-eviction RPC failed",
             );
         }
         return;
     };
-    if response.cohorts.len() != prepared.len() {
-        for (event, cohort) in prepared {
+    if response.atomic_batches.len() != prepared.len() {
+        for (event, atomic_batch) in prepared {
             schedule_owner_source_eviction_retry(
                 inner,
                 event,
-                cohort,
+                atomic_batch,
                 "owner source-eviction response length mismatch",
             );
         }
         return;
     }
 
-    for (index, ((event, cohort), result)) in prepared
+    for (index, ((event, atomic_batch), result)) in prepared
         .into_iter()
-        .zip(response.cohorts.into_iter())
+        .zip(response.atomic_batches.into_iter())
         .enumerate()
     {
-        if result.cohort_index != u32::try_from(index).unwrap_or(u32::MAX) {
+        if result.atomic_batch_index != u32::try_from(index).unwrap_or(u32::MAX) {
             schedule_owner_source_eviction_retry(
                 inner,
                 event,
-                cohort,
+                atomic_batch,
                 "owner source-eviction response identity mismatch",
             );
             continue;
@@ -3212,14 +3289,14 @@ async fn process_owner_source_eviction_events(
                 inner
                     .owner_hot_counters
                     .source_evict_handoff_members
-                    .fetch_add(cohort.members.len() as u64, Ordering::Relaxed);
+                    .fetch_add(atomic_batch.members.len() as u64, Ordering::Relaxed);
                 // Selected debt stays live until owner reclaim Commit calls
                 // owner_hot_invalidate_version for every exact member.
             }
             OwnerSourceEvictionOutcome::Completed => {
                 finish_owner_source_selection(
                     inner,
-                    &cohort,
+                    &atomic_batch,
                     true,
                     "master reported source deletion already completed",
                 );
@@ -3228,29 +3305,29 @@ async fn process_owner_source_eviction_events(
                 schedule_owner_source_eviction_retry(
                     inner,
                     event,
-                    cohort,
+                    atomic_batch,
                     "master source reclaim is temporarily busy",
                 );
             }
             OwnerSourceEvictionOutcome::Stale => {
                 finish_owner_source_selection(
                     inner,
-                    &cohort,
+                    &atomic_batch,
                     true,
                     "master rejected stale source identity",
                 );
             }
             OwnerSourceEvictionOutcome::RejectedNotEvictable => {
                 tracing::error!(
-                    cohort_members = cohort.members.len(),
+                    atomic_batch_members = atomic_batch.members.len(),
                     detail = result.detail,
-                    "owner selected a source cohort that master declared non-evictable"
+                    "owner selected a source atomic_batch that master declared non-evictable"
                 );
                 finish_owner_source_selection(
                     inner,
-                    &cohort,
+                    &atomic_batch,
                     true,
-                    "master rejected non-evictable source cohort",
+                    "master rejected non-evictable source atomic_batch",
                 );
             }
         }
@@ -3261,7 +3338,7 @@ pub fn spawn_owner_source_eviction_dispatcher(
     view: ClientKvApiView,
     mut rx: tokio::sync::ampsc::UnboundedReceiver<OwnerHotEvictionEvent>,
 ) {
-    const MAX_COHORTS_PER_RPC: usize = 128;
+    const MAX_ATOMIC_BATCHES_PER_RPC: usize = 128;
     const MERGE_WINDOW: Duration = Duration::from_millis(2);
 
     let view_task = view.clone();
@@ -3278,11 +3355,11 @@ pub fn spawn_owner_source_eviction_dispatcher(
                     event
                 }
             };
-            let mut events = Vec::with_capacity(MAX_COHORTS_PER_RPC);
+            let mut events = Vec::with_capacity(MAX_ATOMIC_BATCHES_PER_RPC);
             events.push(first);
             let merge_window = tokio::time::sleep(MERGE_WINDOW);
             tokio::pin!(merge_window);
-            while events.len() < MAX_COHORTS_PER_RPC {
+            while events.len() < MAX_ATOMIC_BATCHES_PER_RPC {
                 tokio::select! {
                     _ = &mut merge_window => break,
                     event = rx.recv() => {
@@ -3963,7 +4040,7 @@ fn complete_owner_local_publish_group_lens(items: &[OwnerLocalPublishItem]) -> O
     Some(group_lens)
 }
 
-fn owner_local_publish_cohort_complete(
+fn owner_local_publish_atomic_batch_complete(
     item: &OwnerLocalPublishItem,
     promoted_items: &[&OwnerLocalPublishItem],
 ) -> bool {
@@ -4083,7 +4160,7 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
                 })?;
             }
 
-            // Do not expose only part of an atomic/TP cohort to owner-hot.
+            // Do not expose only part of an atomic/TP atomic_batch to owner-hot.
             // First prove every master route terminal, then roll all local
             // precommit slots forward. Replayed attempts accept members that
             // were already promoted before a cancellation or partial local
@@ -4129,7 +4206,7 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
             }
             Err(reason) => {
                 tracing::warn!(
-                    "owner local publish retained full cohort for retry: key_count={} external_fences={} retry_ms={} reason={}",
+                    "owner local publish retained full atomic_batch for retry: key_count={} external_fences={} retry_ms={} reason={}",
                     job.items.len(),
                     job.external_pending_contexts.len(),
                     retry_delay.as_millis(),
@@ -4150,7 +4227,7 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
     if published {
         let promoted_items = job.items.iter().collect::<Vec<_>>();
         for item in &promoted_items {
-            if !owner_local_publish_cohort_complete(item, &promoted_items) {
+            if !owner_local_publish_atomic_batch_complete(item, &promoted_items) {
                 tracing::warn!(
                     "owner local publish skipped hot admission for incomplete atomic group: key={} put_id=({},{})",
                     item.key,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
index f3ea172..0071968 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
@@ -55,6 +55,8 @@ fn reclaim_key_control_busy_detail(state: &super::OwnerKeyControlState) -> Optio
         Some("owner local put is inflight")
     } else if state.external_pending_puts != 0 {
         Some("owner external put context is still pending")
+    } else if state.source_eviction_selection.is_some() {
+        Some("owner source eviction selection fence is active")
     } else if state.external_get.is_some() {
         Some("owner external Get is inflight")
     } else {
@@ -64,6 +66,76 @@ fn reclaim_key_control_busy_detail(state: &super::OwnerKeyControlState) -> Optio
 
 fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
     let mut controls = inner.owner_key_control.lock_key(&item.key);
+    if controls
+        .get(&item.key)
+        .is_some_and(|state| state.source_eviction_selection.is_some())
+    {
+        let state = controls
+            .get_mut(&item.key)
+            .expect("owner source selection control state disappeared");
+        let selection_matches = state
+            .source_eviction_selection
+            .as_ref()
+            .is_some_and(|selection| {
+                selection.put_id == item.put_id
+                    && memory_matches_reclaim_backing(
+                        selection.cached_info.mem_holder.as_ref(),
+                        &item.backing,
+                    )
+            });
+        if !selection_matches {
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "another owner source selection owns the key fence",
+            );
+        }
+        if state.local_puts != 0 || state.external_pending_puts != 0 {
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner put crossed the source selection fence",
+            );
+        }
+        if inner.precommit_local_visible_info.contains_key(&item.key)
+            || inner.pending_local_get_info.contains_key(&item.key)
+        {
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner local publication crossed the source selection fence",
+            );
+        }
+        let selection = state
+            .source_eviction_selection
+            .take()
+            .expect("matching owner source selection must exist");
+        if Arc::strong_count(&selection.cached_info.mem_holder) != 1 {
+            state.source_eviction_selection = Some(selection);
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Busy,
+                "owner local memory still has active holders",
+            );
+        }
+        let local_snapshot = inner
+            .local_snapshot_info
+            .remove_if(&item.key, |_, snapshot| {
+                snapshot.put_time_ms == item.put_id.0 && snapshot.put_version == item.put_id.1
+            })
+            .map(|(_, snapshot)| snapshot);
+        assert!(state.reclaim.is_none());
+        state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
+            item: item.clone(),
+            cached_info: selection.cached_info,
+            local_snapshot,
+        }));
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Prepared,
+            "owner source selection promoted to reclaim fence",
+        );
+    }
     if let Some(state) = controls.get(&item.key) {
         if let Some(detail) = reclaim_key_control_busy_detail(state) {
             return item_resp(item, OwnerReclaimItemState::Busy, detail);
@@ -206,6 +278,7 @@ fn reclaim_release_fence_is_intact(
         Some(OwnerReclaimRecord::Releasing(releasing)) if releasing == item
     ) && state.local_puts == 0
         && state.external_pending_puts == 0
+        && state.source_eviction_selection.is_none()
 }
 
 fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
@@ -318,6 +391,7 @@ mod tests {
         let state = OwnerKeyControlState {
             local_puts: 0,
             external_pending_puts: 0,
+            source_eviction_selection: None,
             reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
             external_get: Some(Arc::new(ExternalGetKeySharedOp::new(
                 "remote-during-reclaim".to_string(),
@@ -328,6 +402,7 @@ mod tests {
         let local_put_state = OwnerKeyControlState {
             local_puts: 1,
             external_pending_puts: 0,
+            source_eviction_selection: None,
             reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
             external_get: state.external_get,
         };
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index ccba45e..2bc3846 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -62,6 +62,7 @@ use crate::p2p::p2p_module::{P2pModule, P2pModuleAccessTrait};
 use crate::rpcresp_kvresult_convert::msg_and_error::{KvError, OK};
 use fluxon_framework::{LogicalModule, define_module};
 use fluxon_util::map_lock::AMapLock;
+use fluxon_util::pin_aware_moka::{PinAwareMoka, PinGuard};
 
 use async_trait::async_trait;
 use chrono::Utc;
@@ -298,7 +299,7 @@ pub struct ReplicaCacheNodeObserveSnapshot {
     pub reclaim_retry_restored: u64,
     pub reclaim_completed: u64,
     pub source_evict_rpc_requests: u64,
-    pub source_evict_cohorts: u64,
+    pub source_evict_atomic_batches: u64,
     pub source_evict_requested_bytes: u64,
     pub source_evict_accepted: u64,
     pub source_evict_in_progress: u64,
@@ -306,6 +307,8 @@ pub struct ReplicaCacheNodeObserveSnapshot {
     pub source_evict_retryable_busy: u64,
     pub source_evict_stale: u64,
     pub source_evict_rejected: u64,
+    pub last_route_removed_members: u64,
+    pub last_route_removed_bytes: u64,
     pub capacity_eviction_non_ring_b_entry_total: u64,
     pub capacity_eviction_hit_committed_slot: u64,
     pub eviction_reclaim_deduplicated: u64,
@@ -484,7 +487,7 @@ pub(crate) struct EvictionReclaimCounters {
     pub retry_restored: AtomicU64,
     pub completed: AtomicU64,
     pub source_evict_rpc_requests: AtomicU64,
-    pub source_evict_cohorts: AtomicU64,
+    pub source_evict_atomic_batches: AtomicU64,
     pub source_evict_requested_bytes: AtomicU64,
     pub source_evict_accepted: AtomicU64,
     pub source_evict_in_progress: AtomicU64,
@@ -492,13 +495,17 @@ pub(crate) struct EvictionReclaimCounters {
     pub source_evict_retryable_busy: AtomicU64,
     pub source_evict_stale: AtomicU64,
     pub source_evict_rejected: AtomicU64,
+    /// Exact reclaim commits that removed the final readable route for a key.
+    pub last_route_removed_members: AtomicU64,
+    /// Physical backing bytes represented by `last_route_removed_members`.
+    pub last_route_removed_bytes: AtomicU64,
     /// A Size event from the ring-B controller resolved to any current route
     /// outside `Allocation && !owner_local_indexed`.
     pub capacity_eviction_non_ring_b_entry_total: AtomicU64,
     /// More specific subset retained for diagnostics/backward-compatible
     /// metrics: the non-ring-B route used a CommittedSlot backing.
     pub capacity_eviction_hit_committed_slot: AtomicU64,
-    /// Duplicate listener/cohort events suppressed while the same physical
+    /// Duplicate listener/atomic_batch events suppressed while the same physical
     /// cache version already has an outstanding reclaim lifecycle.
     pub eviction_reclaim_deduplicated: AtomicU64,
 }
@@ -535,16 +542,25 @@ pub(crate) struct MasterKeyActivityLease {
     table: Arc<MasterKeyActivityTable>,
     key: String,
     kind: MasterKeyActivityKind,
+    cache_pins: Mutex<Vec<PinGuard>>,
     released: AtomicBool,
 }
 
 impl MasterKeyActivityLease {
+    pub(crate) fn attach_cache_pin(&self, pin: PinGuard) {
+        let mut pins = self.cache_pins.lock();
+        if !self.released.load(Ordering::Acquire) {
+            pins.push(pin);
+        }
+    }
+
     pub(crate) fn release_now(&self) {
         if self
             .released
             .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
             .is_ok()
         {
+            self.cache_pins.lock().clear();
             self.table.release(&self.key, self.kind);
         }
     }
@@ -681,6 +697,7 @@ impl MasterKeyActivityTable {
             table: self.clone(),
             key: key.to_string(),
             kind,
+            cache_pins: Mutex::new(Vec::new()),
             released: AtomicBool::new(false),
         }))
     }
@@ -824,6 +841,25 @@ pub struct NodeValueReplicaDesc {
     pub put_id: PutIDForAKey,
 }
 
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct MasterPinAlias {
+    key: String,
+    put_time_ms: u64,
+    put_version: u32,
+}
+
+impl MasterPinAlias {
+    fn new(key: &str, put_id: PutIDForAKey) -> Self {
+        Self {
+            key: key.to_string(),
+            put_time_ms: put_id.0,
+            put_version: put_id.1,
+        }
+    }
+}
+
+pub type MasterNodeCache = PinAwareMoka<String, MasterPinAlias, NodeValueReplicaDesc>;
+
 /// Information about a completed `put` operation that can be retrieved via `get`.
 /// Now supports multiple replicas per key.
 #[derive(Clone, Debug)]
@@ -1271,7 +1307,7 @@ async fn cleanup_departed_generation_routes(
     );
 }
 
-const MAX_INFERRED_TP_COHORT_SIZE: usize = 256;
+const MAX_INFERRED_TP_ATOMIC_BATCH_SIZE: usize = 256;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) struct InferredTpKey<'a> {
@@ -1300,7 +1336,7 @@ pub(crate) fn infer_sglang_tp_key(key: &str) -> Option<InferredTpKey<'_>> {
     let rank = raw_rank.parse::<usize>().ok()?;
     let size = raw_size.parse::<usize>().ok()?;
     if size == 0
-        || size > MAX_INFERRED_TP_COHORT_SIZE
+        || size > MAX_INFERRED_TP_ATOMIC_BATCH_SIZE
         || rank >= size
         || raw_rank != rank.to_string()
         || raw_size != size.to_string()
@@ -1315,69 +1351,54 @@ pub(crate) fn infer_sglang_tp_key(key: &str) -> Option<InferredTpKey<'_>> {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum CohortExpansionError {
+enum AtomicBatchExpansionError {
     AtomicGroupIncomplete,
-    TpCohortIncomplete,
+    TpAtomicBatchIncomplete,
 }
 
 fn take_exact_cache_entries(
-    cache: &moka::sync::SegmentedCache<String, NodeValueReplicaDesc>,
+    cache: &MasterNodeCache,
     expected_entries: &HashMap<String, NodeValueReplicaDesc>,
 ) -> Option<Vec<(String, NodeValueReplicaDesc)>> {
     let mut removed_entries = Vec::with_capacity(expected_entries.len());
     for (candidate_key, expected_desc) in expected_entries {
-        let result = cache
-            .entry(candidate_key.clone())
-            .and_compute_with(|current| {
-                if current.as_ref().is_some_and(|entry| {
-                    entry.value().put_id == expected_desc.put_id
-                        && entry.value().weight_bytes == expected_desc.weight_bytes
-                }) {
-                    moka::ops::compute::Op::Remove
-                } else {
-                    moka::ops::compute::Op::Nop
-                }
-            });
-        match result {
-            moka::ops::compute::CompResult::Removed(entry) => {
-                removed_entries.push((candidate_key.clone(), entry.into_value()));
-            }
-            _ => {
-                for (removed_key, removed_desc) in removed_entries {
-                    cache.insert(removed_key, removed_desc);
-                }
-                return None;
+        let removed = cache.take_if(candidate_key, |entry| {
+            entry.put_id == expected_desc.put_id && entry.weight_bytes == expected_desc.weight_bytes
+        });
+        if let Some(removed) = removed {
+            removed_entries.push((candidate_key.clone(), removed));
+        } else {
+            for (removed_key, removed_desc) in removed_entries {
+                insert_master_cache_entry(cache, removed_key, removed_desc);
             }
+            return None;
         }
     }
     Some(removed_entries)
 }
 
 fn remove_exact_cache_entry(
-    cache: &moka::sync::SegmentedCache<String, NodeValueReplicaDesc>,
+    cache: &MasterNodeCache,
     key: &str,
     expected_desc: &NodeValueReplicaDesc,
 ) -> bool {
-    matches!(
-        cache.entry(key.to_string()).and_compute_with(|current| {
-            if current.as_ref().is_some_and(|entry| {
-                entry.value().put_id == expected_desc.put_id
-                    && entry.value().weight_bytes == expected_desc.weight_bytes
-            }) {
-                moka::ops::compute::Op::Remove
-            } else {
-                moka::ops::compute::Op::Nop
-            }
-        }),
-        moka::ops::compute::CompResult::Removed(_)
-    )
+    cache
+        .take_if(&key.to_string(), |entry| {
+            entry.put_id == expected_desc.put_id && entry.weight_bytes == expected_desc.weight_bytes
+        })
+        .is_some()
+}
+
+fn insert_master_cache_entry(cache: &MasterNodeCache, key: String, desc: NodeValueReplicaDesc) {
+    let alias = MasterPinAlias::new(&key, desc.put_id);
+    cache.insert(key, [alias], desc);
 }
 
 fn current_atomic_group_members(
     key: &str,
     route: &OneKvNodesRoutes,
     desc: &NodeValueReplicaDesc,
-) -> Result<Vec<msg_pack::PutAtomicGroupMember>, CohortExpansionError> {
+) -> Result<Vec<msg_pack::PutAtomicGroupMember>, AtomicBatchExpansionError> {
     let Some(group) = route.atomic_group.as_ref() else {
         return Ok(vec![msg_pack::PutAtomicGroupMember {
             key: key.to_string(),
@@ -1389,16 +1410,16 @@ fn current_atomic_group_members(
         .iter()
         .any(|member| member.key == key && member.put_id == desc.put_id)
     {
-        return Err(CohortExpansionError::AtomicGroupIncomplete);
+        return Err(AtomicBatchExpansionError::AtomicGroupIncomplete);
     }
     Ok(group.members.clone())
 }
 
-fn current_tp_cohort_keys(
+fn current_tp_atomic_batch_keys(
     key: &str,
     route: &OneKvNodesRoutes,
     desc: &NodeValueReplicaDesc,
-) -> Result<Vec<String>, CohortExpansionError> {
+) -> Result<Vec<String>, AtomicBatchExpansionError> {
     let current_members = current_atomic_group_members(key, route, desc)?;
     let Some(key_tp) = infer_sglang_tp_key(key) else {
         return Ok(current_members
@@ -1416,23 +1437,23 @@ fn current_tp_cohort_keys(
     let mut logical_members = Vec::with_capacity(current_members.len());
     for member in current_members {
         let Some(member_tp) = infer_sglang_tp_key(&member.key) else {
-            return Err(CohortExpansionError::TpCohortIncomplete);
+            return Err(AtomicBatchExpansionError::TpAtomicBatchIncomplete);
         };
         if member_tp.rank != key_tp.rank || member_tp.size != key_tp.size {
-            return Err(CohortExpansionError::TpCohortIncomplete);
+            return Err(AtomicBatchExpansionError::TpAtomicBatchIncomplete);
         }
         logical_members.push(member_tp.logical_prefix.to_string());
     }
 
-    let mut cohort_keys = Vec::with_capacity(logical_members.len() * key_tp.size);
+    let mut atomic_batch_keys = Vec::with_capacity(logical_members.len() * key_tp.size);
     for rank in 0..key_tp.size {
-        cohort_keys.extend(
+        atomic_batch_keys.extend(
             logical_members
                 .iter()
                 .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", key_tp.size)),
         );
     }
-    Ok(cohort_keys)
+    Ok(atomic_batch_keys)
 }
 
 #[cfg(test)]
@@ -1961,7 +1982,7 @@ mod tests {
     }
 
     #[test]
-    fn tp_cohort_expansion_preserves_every_atomic_member_across_ranks() {
+    fn tp_atomic_batch_expansion_preserves_every_atomic_member_across_ranks() {
         let rank0_group = Arc::new(PutAtomicGroup {
             members: vec![
                 msg_pack::PutAtomicGroupMember {
@@ -1981,7 +2002,7 @@ mod tests {
             put_id: (10, 0),
         };
         assert_eq!(
-            current_tp_cohort_keys("page0_model_0_2", &rank0_page0, &desc).unwrap(),
+            current_tp_atomic_batch_keys("page0_model_0_2", &rank0_page0, &desc).unwrap(),
             vec![
                 "page0_model_0_2",
                 "page1_model_0_2",
@@ -1993,10 +2014,8 @@ mod tests {
 
     #[test]
     fn exact_cache_detach_rolls_back_identity_mismatch() {
-        let cache = moka::sync::SegmentedCache::builder(8)
-            .weigher(Box::new(|_key: &String, desc: &NodeValueReplicaDesc| {
-                desc.weight_bytes
-            }))
+        let cache = MasterNodeCache::builder(1024 * 1024)
+            .weigher(|_key: &String, desc: &NodeValueReplicaDesc| desc.weight_bytes)
             .build();
         let actual = HashMap::from([
             (
@@ -2015,31 +2034,37 @@ mod tests {
             ),
         ]);
         for (key, desc) in &actual {
-            cache.insert(key.clone(), desc.clone());
+            insert_master_cache_entry(&cache, key.clone(), desc.clone());
         }
         let mut stale_expected = actual.clone();
         stale_expected.get_mut("rank1").unwrap().put_id = (999, 0);
 
         assert!(take_exact_cache_entries(&cache, &stale_expected).is_none());
-        assert_eq!(cache.get("rank0").unwrap().put_id, (30, 0));
-        assert_eq!(cache.get("rank1").unwrap().put_id, (31, 0));
+        assert_eq!(cache.get(&"rank0".to_string()).unwrap().put_id, (30, 0));
+        assert_eq!(cache.get(&"rank1".to_string()).unwrap().put_id, (31, 0));
 
         let removed = take_exact_cache_entries(&cache, &actual).unwrap();
         assert_eq!(removed.len(), 2);
-        assert!(cache.get("rank0").is_none());
-        assert!(cache.get("rank1").is_none());
+        assert!(cache.get(&"rank0".to_string()).is_none());
+        assert!(cache.get(&"rank1".to_string()).is_none());
     }
 
     #[test]
     fn ring_b_cache_is_bounded_for_every_node_role() {
-        let cache = moka::sync::SegmentedCache::builder(8)
-            .max_capacity(64)
-            .weigher(Box::new(|_key: &u64, weight: &u32| *weight))
+        let cache = MasterNodeCache::builder(64)
+            .weigher(|_key: &String, desc: &NodeValueReplicaDesc| desc.weight_bytes)
             .build();
-        assert_eq!(cache.policy().max_capacity(), Some(64));
+        assert_eq!(cache.max_capacity(), Some(64));
 
         for key in 0..128 {
-            cache.insert(key, 8);
+            insert_master_cache_entry(
+                &cache,
+                key.to_string(),
+                NodeValueReplicaDesc {
+                    weight_bytes: 8,
+                    put_id: (10, key),
+                },
+            );
         }
         cache.run_pending_tasks();
         assert!(cache.weighted_size() <= 64);
@@ -2047,15 +2072,14 @@ mod tests {
 
     #[test]
     fn ring_b_live_capacity_update_never_clears_boundary() {
-        let cache = moka::sync::SegmentedCache::builder(8)
-            .max_capacity(1024)
-            .weigher(Box::new(|_key: &u64, weight: &u32| *weight))
+        let cache = MasterNodeCache::builder(1024)
+            .weigher(|_key: &String, desc: &NodeValueReplicaDesc| desc.weight_bytes)
             .build();
-        assert_eq!(cache.policy().max_capacity(), Some(1024));
+        assert_eq!(cache.max_capacity(), Some(1024));
         cache.set_max_capacity(512).unwrap();
-        assert_eq!(cache.policy().max_capacity(), Some(512));
+        assert_eq!(cache.max_capacity(), Some(512));
         cache.set_max_capacity(2048).unwrap();
-        assert_eq!(cache.policy().max_capacity(), Some(2048));
+        assert_eq!(cache.max_capacity(), Some(2048));
     }
 
     #[test]
@@ -2074,7 +2098,7 @@ mod tests {
     }
 
     #[test]
-    fn cohort_reclaim_identity_registration_is_all_or_nothing() {
+    fn atomic_batch_reclaim_identity_registration_is_all_or_nothing() {
         let request = |keys: &[&str]| reclaim::EvictionReclaimRequest {
             owner_node_id: "cpu0".to_string(),
             owner_node_start_time: None,
@@ -2106,7 +2130,7 @@ mod tests {
         );
 
         // `c` is tentatively installed before the collision on `a`; failure
-        // must roll it back and preserve only the original cohort.
+        // must roll it back and preserve only the original atomic_batch.
         let overlapping = reclaim::EvictionReclaimRequest {
             members: vec![
                 reclaim::EvictionReclaimMember {
@@ -2168,7 +2192,7 @@ mod tests {
 
     #[test]
     fn closed_lossless_channel_rolls_back_identity_accounting_and_metadata() {
-        let cache = moka::sync::SegmentedCache::builder(8).build();
+        let cache = MasterNodeCache::builder(1024 * 1024).build();
         let request = reclaim::EvictionReclaimRequest {
             owner_node_id: "cpu0".to_string(),
             owner_node_start_time: None,
@@ -2198,12 +2222,12 @@ mod tests {
         }
         subtract_pending_eviction_weight(&pending, "cpu0", returned.weight_bytes());
         for member in returned.members {
-            cache.insert(member.key, member.desc);
+            insert_master_cache_entry(&cache, member.key, member.desc);
         }
 
         assert!(inflight.is_empty());
         assert_eq!(pending.load(Ordering::Acquire), 0);
-        assert!(cache.get("closed-channel").is_some());
+        assert!(cache.get(&"closed-channel".to_string()).is_some());
     }
 
     fn new_test_member(metadata: HashMap<String, String>) -> ClusterMember {
@@ -2330,14 +2354,12 @@ pub struct MasterKvRouterInner {
     pub prefix_index: ARwLock<PrefixRadixTree>,
 
     /// Support replicas: node_id -> key -> route_info
-    pub node_kv_cache_controller:
-        DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
+    pub node_kv_cache_controller: DashMap<NodeIDString, Arc<MasterNodeCache>>,
 
     /// Independent pre-writeback tier. Its Size eviction starts a replica task
     /// while owner residency remains governed by the owner's local hot cache;
     /// `node_kv_cache_controller` tracks ring B only.
-    pub node_writeback_tier1_controller:
-        DashMap<NodeIDString, Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>>,
+    pub node_writeback_tier1_controller: DashMap<NodeIDString, Arc<MasterNodeCache>>,
 
     /// Per-node bytes reserved out of moka usable capacity.
     /// The reservation is reason-grouped, but `total_bytes` is the authority
@@ -2348,7 +2370,7 @@ pub struct MasterKvRouterInner {
     pub eviction_reclaim_pending_weight: DashMap<NodeIDString, Arc<AtomicU64>>,
 
     /// Exact, versioned metadata identities currently owned by the lossless
-    /// eviction-reclaim pipeline.  This bounds duplicate Size/cohort events;
+    /// eviction-reclaim pipeline.  This bounds duplicate Size/atomic_batch events;
     /// payload memory is not retained here.
     pub(crate) eviction_reclaim_inflight: DashSet<reclaim::EvictionReclaimIdentity>,
 
@@ -2360,7 +2382,7 @@ pub struct MasterKvRouterInner {
     /// Bounded maintenance can still process a batch of Size evictions; without
     /// this gate, concurrent async tasks can park multiple Tokio workers on the
     /// same blocking Moka lock. It is a scheduling gate, not a correctness or
-    /// cohort lock, and no cache/global scan occurs under it.
+    /// atomic_batch lock, and no cache/global scan occurs under it.
     pub(crate) owner_cache_operation_locks: AMapLock<String>,
 
     /// Historical final put placement decisions by target node.
@@ -2742,7 +2764,8 @@ impl MasterKvRouter {
                 },
             ));
         }
-        self.inner()
+        let lease = self
+            .inner()
             .key_activity
             .reserve(key, MasterKeyActivityKind::Put, reject_if_inflight_same_key)
             .ok_or_else(|| {
@@ -2751,14 +2774,17 @@ impl MasterKvRouter {
                         key: key.to_string(),
                     },
                 )
-            })
+            })?;
+        self.pin_current_master_cache_entries_for_activity(&lease, key);
+        Ok(lease)
     }
 
     pub(crate) fn reserve_inflight_get_key(
         &self,
         key: &str,
     ) -> Result<Arc<MasterKeyActivityLease>, KvError> {
-        self.inner()
+        let lease = self
+            .inner()
             .key_activity
             .reserve(key, MasterKeyActivityKind::Get, false)
             .ok_or_else(|| {
@@ -2767,7 +2793,9 @@ impl MasterKvRouter {
                         key: key.to_string(),
                     },
                 )
-            })
+            })?;
+        self.pin_current_master_cache_entries_for_activity(&lease, key);
+        Ok(lease)
     }
 
     pub(crate) fn reserve_prepared_get_requester(
@@ -2792,7 +2820,8 @@ impl MasterKvRouter {
         &self,
         key: &str,
     ) -> Result<Arc<MasterKeyActivityLease>, KvError> {
-        self.inner()
+        let lease = self
+            .inner()
             .key_activity
             .reserve(key, MasterKeyActivityKind::Replica, false)
             .ok_or_else(|| {
@@ -2801,7 +2830,99 @@ impl MasterKvRouter {
                         key: key.to_string(),
                     },
                 )
+            })?;
+        self.pin_current_master_cache_entries_for_activity(&lease, key);
+        Ok(lease)
+    }
+
+    fn attach_cache_pin_if_present(
+        &self,
+        lease: &Arc<MasterKeyActivityLease>,
+        cache: &MasterNodeCache,
+        key: &str,
+        desc: &NodeValueReplicaDesc,
+    ) {
+        let alias = MasterPinAlias::new(key, desc.put_id);
+        if let Some(pin) = cache.try_pin_alias_if(alias, |entry| {
+            entry.put_id == desc.put_id && entry.weight_bytes == desc.weight_bytes
+        }) {
+            lease.attach_cache_pin(pin);
+        }
+    }
+
+    pub(crate) fn pin_master_cache_identity_for_activity(
+        &self,
+        lease: &Arc<MasterKeyActivityLease>,
+        owner_node_id: &str,
+        key: &str,
+        desc: &NodeValueReplicaDesc,
+    ) {
+        if let Some(cache) = self
+            .inner()
+            .node_kv_cache_controller
+            .get(owner_node_id)
+            .map(|entry| entry.value().clone())
+        {
+            self.attach_cache_pin_if_present(lease, cache.as_ref(), key, desc);
+        }
+        if let Some(cache) = self
+            .inner()
+            .node_writeback_tier1_controller
+            .get(owner_node_id)
+            .map(|entry| entry.value().clone())
+        {
+            self.attach_cache_pin_if_present(lease, cache.as_ref(), key, desc);
+        }
+    }
+
+    pub(crate) fn pin_current_master_cache_identity_for_activity(
+        &self,
+        lease: &Arc<MasterKeyActivityLease>,
+        owner_node_id: &str,
+        key: &str,
+        put_id: PutIDForAKey,
+    ) {
+        let desc = self.inner().kv_routes.get(key).and_then(|route| {
+            (route.put_id == put_id).then(|| ring_b_route_replica_desc(&route, owner_node_id))?
+        });
+        if let Some(desc) = desc {
+            self.pin_master_cache_identity_for_activity(lease, owner_node_id, key, &desc);
+        }
+    }
+
+    fn pin_current_master_cache_entries_for_activity(
+        &self,
+        lease: &Arc<MasterKeyActivityLease>,
+        key: &str,
+    ) {
+        let entries = self
+            .inner()
+            .kv_routes
+            .get(key)
+            .map(|route| {
+                let put_id = route.put_id;
+                route
+                    .nodes_replicas
+                    .read()
+                    .iter()
+                    .filter_map(|(node_id, replica)| {
+                        (!replica.tomb_tag.is_tomb()).then(|| {
+                            (
+                                node_id.as_ref().to_string(),
+                                NodeValueReplicaDesc {
+                                    weight_bytes: u32::try_from(replica.backing.capacity_bytes())
+                                        .unwrap_or(u32::MAX),
+                                    put_id,
+                                },
+                            )
+                        })
+                    })
+                    .collect::<Vec<_>>()
             })
+            .unwrap_or_default();
+        for (node_id, desc) in entries {
+            self.pin_master_cache_identity_for_activity(lease, node_id.as_str(), key, &desc);
+        }
     }
 
     pub fn key_has_live_replica(&self, key: &str) -> bool {
@@ -2901,7 +3022,7 @@ impl MasterKvRouter {
         desc: NodeValueReplicaDesc,
         origin: reclaim::EvictionReclaimOrigin,
     ) -> bool {
-        self.enqueue_eviction_reclaim_cohort(
+        self.enqueue_eviction_reclaim_atomic_batch(
             owner_node_id,
             vec![reclaim::EvictionReclaimMember {
                 key,
@@ -2912,27 +3033,33 @@ impl MasterKvRouter {
         )
     }
 
-    fn enqueue_eviction_reclaim_cohort(
+    fn enqueue_eviction_reclaim_atomic_batch(
         &self,
         owner_node_id: NodeIDString,
         members: Vec<reclaim::EvictionReclaimMember>,
         origin: reclaim::EvictionReclaimOrigin,
     ) -> bool {
         matches!(
-            self.enqueue_eviction_reclaim_cohort_exact(owner_node_id, None, members, origin, true,),
+            self.enqueue_eviction_reclaim_atomic_batch_exact(
+                owner_node_id,
+                None,
+                members,
+                origin,
+                true,
+            ),
             reclaim::EnqueueEvictionReclaimResult::Accepted
                 | reclaim::EnqueueEvictionReclaimResult::AlreadyInProgress
         )
     }
 
-    pub(crate) fn enqueue_owner_capacity_eviction_cohort(
+    pub(crate) fn enqueue_owner_capacity_eviction_atomic_batch(
         &self,
         owner_node_id: NodeIDString,
         owner_node_start_time: i64,
         members: Vec<reclaim::EvictionReclaimMember>,
         allow_new_request: bool,
     ) -> reclaim::EnqueueEvictionReclaimResult {
-        self.enqueue_eviction_reclaim_cohort_exact(
+        self.enqueue_eviction_reclaim_atomic_batch_exact(
             owner_node_id,
             Some(owner_node_start_time),
             members,
@@ -2941,7 +3068,7 @@ impl MasterKvRouter {
         )
     }
 
-    fn enqueue_eviction_reclaim_cohort_exact(
+    fn enqueue_eviction_reclaim_atomic_batch_exact(
         &self,
         owner_node_id: NodeIDString,
         owner_node_start_time: Option<i64>,
@@ -2970,7 +3097,7 @@ impl MasterKvRouter {
             self.eviction_reclaim_counters(&request.owner_node_id)
                 .eviction_reclaim_deduplicated
                 .fetch_add(1, Ordering::Relaxed);
-            // An idempotent retry is accepted only when the complete cohort
+            // An idempotent retry is accepted only when the complete atomic_batch
             // is already owned by the pipeline. A partial overlap is not a
             // valid source handoff.
             return if request
@@ -3191,7 +3318,7 @@ impl MasterKvRouter {
         };
         // Restoration is an exact metadata repair after a failed reclaim
         // dispatch. It must never search for or evict an unrelated victim.
-        cache.insert(key, desc);
+        insert_master_cache_entry(cache.as_ref(), key, desc);
         true
     }
 
@@ -4498,10 +4625,7 @@ impl MasterKvRouter {
         });
     }
 
-    pub fn get_node_cache_controller(
-        &self,
-        node_id: &str,
-    ) -> Option<Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>> {
+    pub fn get_node_cache_controller(&self, node_id: &str) -> Option<Arc<MasterNodeCache>> {
         if !self.replica_cache_enabled() {
             return None;
         }
@@ -4527,32 +4651,30 @@ impl MasterKvRouter {
                 .or_insert_with(move || {
                     let view = view.clone();
                     let cache_node_id = node_id_owned.clone();
-                    let builder = moka::sync::SegmentedCache::builder(8)
+                    let builder = MasterNodeCache::builder(allocation_capacity)
                         // Admission is restricted to unindexed Allocation
                         // routes. CommittedSlot and owner-indexed Allocation
                         // entries belong to ring A and never enter this cache.
-                        .weigher(Box::new(|_key: &String, value: &NodeValueReplicaDesc| {
-                            value.weight_bytes
-                        }))
-                        .eviction_listener(Box::new(
+                        .weigher(|_key: &String, value: &NodeValueReplicaDesc| value.weight_bytes)
+                        .eviction_listener(
                             move |key: Arc<String>,
-                                  _value: NodeValueReplicaDesc,
+                                  value: NodeValueReplicaDesc,
                                   cause: RemovalCause| {
                                 if cause == RemovalCause::Size {
                                     // Listener work is deliberately O(1):
                                     // clone fixed metadata, dedupe, and send
-                                    // to a lossless channel.  Route/cohort
+                                    // to a lossless channel.  Route/atomic_batch
                                     // lookup belongs to the async actor.
                                     let _ = view.master_kv_router().enqueue_eviction_reclaim(
                                         cache_node_id.clone(),
                                         (*key).clone(),
-                                        _value,
+                                        value,
                                         reclaim::EvictionReclaimOrigin::MasterAllocationCapacity,
                                     );
                                 }
                             },
-                        ));
-                    Arc::new(builder.max_capacity(allocation_capacity).build())
+                        );
+                    Arc::new(builder.build())
                 })
                 .value()
                 .clone(),
@@ -4589,7 +4711,7 @@ impl MasterKvRouter {
     pub fn get_node_writeback_tier1_controller(
         &self,
         node_id: &str,
-    ) -> Option<Arc<moka::sync::SegmentedCache<String, NodeValueReplicaDesc>>> {
+    ) -> Option<Arc<MasterNodeCache>> {
         if !self.tier1_source_node_eligible(node_id) {
             return None;
         }
@@ -4611,12 +4733,11 @@ impl MasterKvRouter {
                 .or_insert_with(move || {
                     let cache_node_id = node_id_owned.clone();
                     Arc::new(
-                        moka::sync::SegmentedCache::builder(8)
-                            .max_capacity(base_capacity)
-                            .weigher(Box::new(|_key: &String, value: &NodeValueReplicaDesc| {
+                        MasterNodeCache::builder(base_capacity)
+                            .weigher(|_key: &String, value: &NodeValueReplicaDesc| {
                                 value.weight_bytes
-                            }))
-                            .eviction_listener(Box::new(
+                            })
+                            .eviction_listener(
                                 move |key: Arc<String>,
                                       value: NodeValueReplicaDesc,
                                       cause: RemovalCause| {
@@ -4628,7 +4749,7 @@ impl MasterKvRouter {
                                         );
                                     }
                                 },
-                            ))
+                            )
                             .build(),
                     )
                 })
@@ -5059,7 +5180,6 @@ impl MasterKvRouter {
             // Every live node's ring-B controller is bounded, independent of
             // its placement role.
             let effective_capacity_bytes = cache
-                .policy()
                 .max_capacity()
                 .expect("ring-B controller must always be bounded");
             let pending_eviction_reclaim_bytes =
@@ -5088,7 +5208,7 @@ impl MasterKvRouter {
                     .unwrap_or(0),
                 writeback_tier1_capacity_bytes: tier1_cache
                     .as_ref()
-                    .and_then(|cache| cache.policy().max_capacity())
+                    .and_then(|cache| cache.max_capacity())
                     .unwrap_or(0),
                 writeback_tier1_triggered: Self::tier1_writeback_counter(
                     &self.inner().tier1_writeback_trigger_counts,
@@ -5119,8 +5239,8 @@ impl MasterKvRouter {
                 source_evict_rpc_requests: reclaim_counters
                     .source_evict_rpc_requests
                     .load(Ordering::Relaxed),
-                source_evict_cohorts: reclaim_counters
-                    .source_evict_cohorts
+                source_evict_atomic_batches: reclaim_counters
+                    .source_evict_atomic_batches
                     .load(Ordering::Relaxed),
                 source_evict_requested_bytes: reclaim_counters
                     .source_evict_requested_bytes
@@ -5141,6 +5261,12 @@ impl MasterKvRouter {
                 source_evict_rejected: reclaim_counters
                     .source_evict_rejected
                     .load(Ordering::Relaxed),
+                last_route_removed_members: reclaim_counters
+                    .last_route_removed_members
+                    .load(Ordering::Relaxed),
+                last_route_removed_bytes: reclaim_counters
+                    .last_route_removed_bytes
+                    .load(Ordering::Relaxed),
                 capacity_eviction_non_ring_b_entry_total: reclaim_counters
                     .capacity_eviction_non_ring_b_entry_total
                     .load(Ordering::Relaxed),
@@ -5187,7 +5313,7 @@ impl MasterKvRouter {
                         );
                         for node in snapshot.replica_cache_nodes {
                             tracing::info!(
-                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_cohorts={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
+                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_atomic_batches={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} last_route_removed_members={} last_route_removed_bytes={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
                                 node.owner_node,
                                 node.entries,
                                 node.weighted_bytes,
@@ -5210,7 +5336,7 @@ impl MasterKvRouter {
                                 node.reclaim_retry_restored,
                                 node.reclaim_completed,
                                 node.source_evict_rpc_requests,
-                                node.source_evict_cohorts,
+                                node.source_evict_atomic_batches,
                                 node.source_evict_requested_bytes,
                                 node.source_evict_accepted,
                                 node.source_evict_in_progress,
@@ -5218,6 +5344,8 @@ impl MasterKvRouter {
                                 node.source_evict_retryable_busy,
                                 node.source_evict_stale,
                                 node.source_evict_rejected,
+                                node.last_route_removed_members,
+                                node.last_route_removed_bytes,
                                 node.capacity_eviction_non_ring_b_entry_total,
                                 node.capacity_eviction_hit_committed_slot,
                                 node.eviction_reclaim_deduplicated,
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index 048732e..6b23403 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -372,7 +372,7 @@ pub struct OwnerSourceEvictionMember {
 
 /// Atomic/TP members which must enter the reclaim pipeline together.
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
-pub struct OwnerSourceEvictionCohort {
+pub struct OwnerSourceEvictionAtomicBatch {
     pub members: Vec<OwnerSourceEvictionMember>,
 }
 
@@ -381,7 +381,7 @@ pub struct BatchEvictOwnerSourceReq {
     pub operation_id: u64,
     /// Membership generation of the authenticated source owner.
     pub owner_node_start_time: i64,
-    pub cohorts: Vec<OwnerSourceEvictionCohort>,
+    pub atomic_batches: Vec<OwnerSourceEvictionAtomicBatch>,
 }
 
 impl MsgPackSerializePart for BatchEvictOwnerSourceReq {
@@ -403,8 +403,8 @@ pub enum OwnerSourceEvictionOutcome {
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
-pub struct OwnerSourceEvictionCohortResp {
-    pub cohort_index: u32,
+pub struct OwnerSourceEvictionAtomicBatchResp {
+    pub atomic_batch_index: u32,
     pub outcome: OwnerSourceEvictionOutcome,
     pub detail: String,
 }
@@ -412,7 +412,7 @@ pub struct OwnerSourceEvictionCohortResp {
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct BatchEvictOwnerSourceResp {
     pub operation_id: u64,
-    pub cohorts: Vec<OwnerSourceEvictionCohortResp>,
+    pub atomic_batches: Vec<OwnerSourceEvictionAtomicBatchResp>,
     pub error_code: ErrorCode,
     pub error_json: String,
 }
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index 4992419..1edc824 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -487,6 +487,13 @@ fn reserve_replica_task_excluding(
     protect_source_on_remote_complete: bool,
 ) -> msg_and_error::KvResult<InflightReplicaTaskInfo> {
     let activity_lease = view.master_kv_router().reserve_inflight_replica_key(key)?;
+    view.master_kv_router()
+        .pin_current_master_cache_identity_for_activity(
+            &activity_lease,
+            source_node_id.as_ref(),
+            key,
+            put_id,
+        );
     let (target_node_id, target_allocation) = view
         .master_kv_router()
         .inner()
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
index 39f2ee7..e2c8d01 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
@@ -3,7 +3,7 @@ use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::master_kv_router::msg_pack::{
     BatchEvictOwnerSourceReq, BatchEvictOwnerSourceResp, BatchOwnerReclaimReq, OwnerReclaimBacking,
     OwnerReclaimItem, OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase,
-    OwnerReclaimReason, OwnerSourceEvictionCohort, OwnerSourceEvictionCohortResp,
+    OwnerReclaimReason, OwnerSourceEvictionAtomicBatch, OwnerSourceEvictionAtomicBatchResp,
     OwnerSourceEvictionOutcome,
 };
 use crate::p2p::msg_pack::{MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, RPCCaller};
@@ -66,7 +66,7 @@ mod timeout_contract_tests {
 }
 
 #[cfg(test)]
-mod cohort_transaction_tests {
+mod atomic_batch_transaction_tests {
     use super::*;
     use crate::master_kv_router::msg_pack::{
         OwnerSourceEvictionMember, PutAtomicGroup, PutAtomicGroupMember,
@@ -96,24 +96,24 @@ mod cohort_transaction_tests {
     }
 
     #[test]
-    fn cohort_master_fences_roll_back_all_members_when_one_is_busy() {
+    fn atomic_batch_master_fences_roll_back_all_members_when_one_is_busy() {
         let activity = Arc::new(MasterKeyActivityTable::default());
         let items = vec![item("rank0", 1), item("rank1", 2)];
         let _busy = activity
             .reserve("rank1", MasterKeyActivityKind::Get, false)
             .unwrap();
 
-        assert!(try_install_cohort_master_fences(&activity, &items).is_err());
+        assert!(try_install_atomic_batch_master_fences(&activity, &items).is_err());
         assert!(!activity.has_reclaim("rank0"));
         assert!(!activity.has_reclaim("rank1"));
     }
 
     #[test]
-    fn cohort_master_fences_install_and_clear_as_one_set() {
+    fn atomic_batch_master_fences_install_and_clear_as_one_set() {
         let activity = Arc::new(MasterKeyActivityTable::default());
         let items = vec![item("rank0", 1), item("rank1", 2)];
 
-        try_install_cohort_master_fences(&activity, &items).unwrap();
+        try_install_atomic_batch_master_fences(&activity, &items).unwrap();
         assert!(activity.has_reclaim("rank0"));
         assert!(activity.has_reclaim("rank1"));
         for item in &items {
@@ -231,17 +231,17 @@ mod cohort_transaction_tests {
     fn exact_source_plan_accepts_with_or_without_a_cpu_replica() {
         let owner: NodeID = "gpu0".to_string().into();
         let member = source_member("single", (10, 1), 7, 3);
-        let cohort = OwnerSourceEvictionCohort {
+        let atomic_batch = OwnerSourceEvictionAtomicBatch {
             members: vec![member.clone()],
         };
 
         for include_cpu_replica in [false, true] {
             let route = source_route(&owner, &member, None, include_cpu_replica);
-            let plan = plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| {
+            let plan = plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| {
                 (key == "single").then(|| route.clone())
             });
             match plan {
-                OwnerSourceCohortPlan::Ready {
+                OwnerSourceAtomicBatchPlan::Ready {
                     members,
                     all_sources_present,
                 } => {
@@ -267,7 +267,14 @@ mod cohort_transaction_tests {
         let removed =
             remove_exact_owner_source_route(&routes, &owner, &source_reclaim_item(&member))
                 .expect("exact GPU source must be removed");
+        let counters = crate::master_kv_router::EvictionReclaimCounters::default();
+        record_last_route_removal(&counters, &removed);
         assert!(!removed.removed_last_route);
+        assert_eq!(
+            counters.last_route_removed_members.load(Ordering::Relaxed),
+            0
+        );
+        assert_eq!(counters.last_route_removed_bytes.load(Ordering::Relaxed), 0);
         let remaining = routes.get(&member.key).expect("CPU route must remain");
         assert!(!remaining.nodes_replicas.read().contains_key(&owner));
         assert!(remaining.nodes_replicas.read().contains_key("cpu0"));
@@ -276,8 +283,17 @@ mod cohort_transaction_tests {
         routes.insert(last.key.clone(), source_route(&owner, &last, None, false));
         let removed = remove_exact_owner_source_route(&routes, &owner, &source_reclaim_item(&last))
             .expect("last exact GPU source must be removed");
+        record_last_route_removal(&counters, &removed);
         assert!(removed.removed_last_route);
         assert!(!routes.contains_key(&last.key));
+        assert_eq!(
+            counters.last_route_removed_members.load(Ordering::Relaxed),
+            1
+        );
+        assert_eq!(
+            counters.last_route_removed_bytes.load(Ordering::Relaxed),
+            removed.capacity_bytes
+        );
 
         let stale = source_member("stale", (10, 4), 8, 6);
         routes.insert(stale.key.clone(), source_route(&owner, &stale, None, false));
@@ -298,7 +314,7 @@ mod cohort_transaction_tests {
         let owner: NodeID = "gpu0".to_string().into();
         let a = source_member("a", (11, 0), 8, 0);
         let b = source_member("b", (11, 1), 8, 1);
-        let cohort = OwnerSourceEvictionCohort {
+        let atomic_batch = OwnerSourceEvictionAtomicBatch {
             members: vec![a.clone(), b.clone()],
         };
         let group = Arc::new(PutAtomicGroup {
@@ -315,27 +331,29 @@ mod cohort_transaction_tests {
         });
         let route_a = source_route(&owner, &a, Some(group), false);
 
-        match plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| {
+        match plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| {
             (key == "a").then(|| route_a.clone())
         }) {
-            OwnerSourceCohortPlan::Ready {
+            OwnerSourceAtomicBatchPlan::Ready {
                 all_sources_present,
                 ..
             } => assert!(!all_sources_present),
-            _ => panic!("a partially removed accepted cohort must be recognized as replay-only"),
+            _ => panic!(
+                "a partially removed accepted atomic_batch must be recognized as replay-only"
+            ),
         }
         assert!(matches!(
-            plan_exact_owner_source_cohort_with(&owner, &cohort, &|_| None),
-            OwnerSourceCohortPlan::Completed(_)
+            plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|_| None),
+            OwnerSourceAtomicBatchPlan::Completed(_)
         ));
     }
 
     #[test]
-    fn one_stale_or_inconsistent_member_rejects_the_whole_source_cohort() {
+    fn one_stale_or_inconsistent_member_rejects_the_whole_source_atomic_batch() {
         let owner: NodeID = "gpu0".to_string().into();
         let a = source_member("a", (12, 0), 9, 0);
         let b = source_member("b", (12, 1), 9, 1);
-        let cohort = OwnerSourceEvictionCohort {
+        let atomic_batch = OwnerSourceEvictionAtomicBatch {
             members: vec![a.clone(), b.clone()],
         };
         let group = Arc::new(PutAtomicGroup {
@@ -355,26 +373,26 @@ mod cohort_transaction_tests {
         let route_b_with_changed_backing =
             source_route(&owner, &changed_b, Some(group.clone()), false);
         let stale_backing_plan =
-            plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| match key {
+            plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| match key {
                 "a" => Some(route_a.clone()),
                 "b" => Some(route_b_with_changed_backing.clone()),
                 _ => None,
             });
         assert!(matches!(
             stale_backing_plan,
-            OwnerSourceCohortPlan::Stale(_)
+            OwnerSourceAtomicBatchPlan::Stale(_)
         ));
 
         let route_b_without_group = source_route(&owner, &b, None, false);
         let inconsistent_group_plan =
-            plan_exact_owner_source_cohort_with(&owner, &cohort, &|key| match key {
+            plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| match key {
                 "a" => Some(route_a.clone()),
                 "b" => Some(route_b_without_group.clone()),
                 _ => None,
             });
         assert!(matches!(
             inconsistent_group_plan,
-            OwnerSourceCohortPlan::Rejected(_)
+            OwnerSourceAtomicBatchPlan::Rejected(_)
         ));
     }
 }
@@ -451,7 +469,7 @@ impl EvictionReclaimRequest {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum MasterCapacityPlanError {
     RouteChanged,
-    InvalidCohort,
+    InvalidAtomicBatch,
     WrongRole,
     CommittedSlot,
 }
@@ -511,9 +529,9 @@ fn allocation_member_from_route(
     ))
 }
 
-/// Expand one master Size event by point-looking up its atomic/TP cohort.
+/// Expand one master Size event by point-looking up its atomic/TP atomic_batch.
 /// This function never iterates the resident cache or global route table.
-fn plan_master_allocation_capacity_cohort(
+fn plan_master_allocation_capacity_atomic_batch(
     view: &MasterKvRouterView,
     request: &EvictionReclaimRequest,
 ) -> Result<Vec<EvictionReclaimMember>, MasterCapacityPlanError> {
@@ -530,31 +548,31 @@ fn plan_master_allocation_capacity_cohort(
     {
         return Err(MasterCapacityPlanError::RouteChanged);
     }
-    let mut cohort_keys =
-        super::current_tp_cohort_keys(&anchor.key, &anchor_route, &current_anchor.desc)
-            .map_err(|_| MasterCapacityPlanError::InvalidCohort)?;
-    cohort_keys.sort_unstable();
-    cohort_keys.dedup();
-    if cohort_keys.is_empty() {
-        return Err(MasterCapacityPlanError::InvalidCohort);
+    let mut atomic_batch_keys =
+        super::current_tp_atomic_batch_keys(&anchor.key, &anchor_route, &current_anchor.desc)
+            .map_err(|_| MasterCapacityPlanError::InvalidAtomicBatch)?;
+    atomic_batch_keys.sort_unstable();
+    atomic_batch_keys.dedup();
+    if atomic_batch_keys.is_empty() {
+        return Err(MasterCapacityPlanError::InvalidAtomicBatch);
     }
 
-    let mut members = Vec::with_capacity(cohort_keys.len());
-    for key in &cohort_keys {
+    let mut members = Vec::with_capacity(atomic_batch_keys.len());
+    for key in &atomic_batch_keys {
         let (member, route) = allocation_member_from_route(view, &owner, key)?;
-        let mut peer_keys = super::current_tp_cohort_keys(key, &route, &member.desc)
-            .map_err(|_| MasterCapacityPlanError::InvalidCohort)?;
+        let mut peer_keys = super::current_tp_atomic_batch_keys(key, &route, &member.desc)
+            .map_err(|_| MasterCapacityPlanError::InvalidAtomicBatch)?;
         peer_keys.sort_unstable();
         peer_keys.dedup();
-        if peer_keys != cohort_keys {
-            return Err(MasterCapacityPlanError::InvalidCohort);
+        if peer_keys != atomic_batch_keys {
+            return Err(MasterCapacityPlanError::InvalidAtomicBatch);
         }
         members.push(member);
     }
     Ok(members)
 }
 
-fn detach_present_capacity_cohort_siblings(
+fn detach_present_capacity_atomic_batch_siblings(
     view: &MasterKvRouterView,
     owner_node_id: &str,
     members: &[EvictionReclaimMember],
@@ -861,7 +879,7 @@ fn owner_source_member_weight(backing: &OwnerReclaimBacking) -> Option<u32> {
     }
 }
 
-enum OwnerSourceCohortPlan {
+enum OwnerSourceAtomicBatchPlan {
     Ready {
         members: Vec<EvictionReclaimMember>,
         all_sources_present: bool,
@@ -871,12 +889,12 @@ enum OwnerSourceCohortPlan {
     Rejected(String),
 }
 
-fn plan_exact_owner_source_cohort(
+fn plan_exact_owner_source_atomic_batch(
     view: &MasterKvRouterView,
     owner: &NodeID,
-    cohort: &OwnerSourceEvictionCohort,
-) -> OwnerSourceCohortPlan {
-    plan_exact_owner_source_cohort_with(owner, cohort, &|key| {
+    atomic_batch: &OwnerSourceEvictionAtomicBatch,
+) -> OwnerSourceAtomicBatchPlan {
+    plan_exact_owner_source_atomic_batch_with(owner, atomic_batch, &|key| {
         view.master_kv_router()
             .inner()
             .kv_routes
@@ -885,33 +903,35 @@ fn plan_exact_owner_source_cohort(
     })
 }
 
-fn plan_exact_owner_source_cohort_with(
+fn plan_exact_owner_source_atomic_batch_with(
     owner: &NodeID,
-    cohort: &OwnerSourceEvictionCohort,
+    atomic_batch: &OwnerSourceEvictionAtomicBatch,
     route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
-) -> OwnerSourceCohortPlan {
-    if cohort.members.is_empty() {
-        return OwnerSourceCohortPlan::Rejected("empty source-eviction cohort".to_string());
+) -> OwnerSourceAtomicBatchPlan {
+    if atomic_batch.members.is_empty() {
+        return OwnerSourceAtomicBatchPlan::Rejected(
+            "empty source-eviction atomic_batch".to_string(),
+        );
     }
 
-    let mut expected_keys = cohort
+    let mut expected_keys = atomic_batch
         .members
         .iter()
         .map(|member| member.key.clone())
         .collect::<Vec<_>>();
     expected_keys.sort_unstable();
     expected_keys.dedup();
-    if expected_keys.len() != cohort.members.len() {
-        return OwnerSourceCohortPlan::Rejected(
-            "source-eviction cohort contains duplicate keys".to_string(),
+    if expected_keys.len() != atomic_batch.members.len() {
+        return OwnerSourceAtomicBatchPlan::Rejected(
+            "source-eviction atomic_batch contains duplicate keys".to_string(),
         );
     }
 
-    let mut planned = Vec::with_capacity(cohort.members.len());
+    let mut planned = Vec::with_capacity(atomic_batch.members.len());
     let mut absent_sources = 0usize;
-    for member in &cohort.members {
+    for member in &atomic_batch.members {
         let Some(weight_bytes) = owner_source_member_weight(&member.backing) else {
-            return OwnerSourceCohortPlan::Rejected(format!(
+            return OwnerSourceAtomicBatchPlan::Rejected(format!(
                 "source backing is not an exact committed slot: key={}",
                 member.key
             ));
@@ -931,13 +951,13 @@ fn plan_exact_owner_source_cohort_with(
             continue;
         };
         if route.put_id != member.put_id {
-            return OwnerSourceCohortPlan::Stale(format!(
+            return OwnerSourceAtomicBatchPlan::Stale(format!(
                 "route version changed: key={} expected=({},{}) current=({},{})",
                 member.key, member.put_id.0, member.put_id.1, route.put_id.0, route.put_id.1,
             ));
         }
         if route.lease_id.is_some() {
-            return OwnerSourceCohortPlan::Rejected(format!(
+            return OwnerSourceAtomicBatchPlan::Rejected(format!(
                 "leased route is not cache-evictable: key={}",
                 member.key
             ));
@@ -947,7 +967,7 @@ fn plan_exact_owner_source_cohort_with(
             match replicas.get(owner) {
                 Some(replica) if !replica.tomb_tag.is_tomb() => {
                     if !replica.owner_local_indexed {
-                        return OwnerSourceCohortPlan::Rejected(format!(
+                        return OwnerSourceAtomicBatchPlan::Rejected(format!(
                             "source route is not owner-local indexed: key={}",
                             member.key
                         ));
@@ -961,45 +981,46 @@ fn plan_exact_owner_source_cohort_with(
             }
         };
         if !replica_matches {
-            return OwnerSourceCohortPlan::Stale(format!(
+            return OwnerSourceAtomicBatchPlan::Stale(format!(
                 "source backing changed: key={} put_id=({},{})",
                 member.key, member.put_id.0, member.put_id.1
             ));
         }
 
-        let mut route_cohort = match super::current_tp_cohort_keys(&member.key, &route, &desc) {
-            Ok(keys) => keys,
-            Err(_) => {
-                return OwnerSourceCohortPlan::Rejected(format!(
-                    "master route has an invalid TP/atomic cohort: key={}",
-                    member.key
-                ));
-            }
-        };
-        route_cohort.sort_unstable();
-        route_cohort.dedup();
-        if route_cohort != expected_keys {
-            return OwnerSourceCohortPlan::Rejected(format!(
-                "owner did not submit the complete TP/atomic cohort: key={} expected_members={} route_members={}",
+        let mut route_atomic_batch =
+            match super::current_tp_atomic_batch_keys(&member.key, &route, &desc) {
+                Ok(keys) => keys,
+                Err(_) => {
+                    return OwnerSourceAtomicBatchPlan::Rejected(format!(
+                        "master route has an invalid TP/atomic atomic_batch: key={}",
+                        member.key
+                    ));
+                }
+            };
+        route_atomic_batch.sort_unstable();
+        route_atomic_batch.dedup();
+        if route_atomic_batch != expected_keys {
+            return OwnerSourceAtomicBatchPlan::Rejected(format!(
+                "owner did not submit the complete TP/atomic atomic_batch: key={} expected_members={} route_members={}",
                 member.key,
                 expected_keys.len(),
-                route_cohort.len(),
+                route_atomic_batch.len(),
             ));
         }
     }
 
-    if absent_sources == cohort.members.len() {
-        OwnerSourceCohortPlan::Completed("all exact source replicas are already absent")
+    if absent_sources == atomic_batch.members.len() {
+        OwnerSourceAtomicBatchPlan::Completed("all exact source replicas are already absent")
     } else if absent_sources != 0 {
-        // This can be observed while an accepted cohort is between individual
+        // This can be observed while an accepted atomic_batch is between individual
         // route removals. The exact inflight registration below distinguishes
         // that case from a malformed new request.
-        OwnerSourceCohortPlan::Ready {
+        OwnerSourceAtomicBatchPlan::Ready {
             members: planned,
             all_sources_present: false,
         }
     } else {
-        OwnerSourceCohortPlan::Ready {
+        OwnerSourceAtomicBatchPlan::Ready {
             members: planned,
             all_sources_present: true,
         }
@@ -1018,15 +1039,15 @@ pub(crate) async fn handle_batch_evict_owner_source(
     counters
         .source_evict_rpc_requests
         .fetch_add(1, Ordering::Relaxed);
-    counters.source_evict_cohorts.fetch_add(
-        u64::try_from(req.serialize_part.cohorts.len()).unwrap_or(u64::MAX),
+    counters.source_evict_atomic_batches.fetch_add(
+        u64::try_from(req.serialize_part.atomic_batches.len()).unwrap_or(u64::MAX),
         Ordering::Relaxed,
     );
     let requested_bytes = req
         .serialize_part
-        .cohorts
+        .atomic_batches
         .iter()
-        .flat_map(|cohort| cohort.members.iter())
+        .flat_map(|atomic_batch| atomic_batch.members.iter())
         .filter_map(|member| owner_source_member_weight(&member.backing))
         .map(u64::from)
         .fold(0u64, u64::saturating_add);
@@ -1039,7 +1060,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
         .map(|member| member.node_start_time);
     if current_generation != Some(req.serialize_part.owner_node_start_time) {
         counters.source_evict_rejected.fetch_add(
-            u64::try_from(req.serialize_part.cohorts.len()).unwrap_or(u64::MAX),
+            u64::try_from(req.serialize_part.atomic_batches.len()).unwrap_or(u64::MAX),
             Ordering::Relaxed,
         );
         let err = KvError::Api(ApiError::InvalidArgument {
@@ -1051,7 +1072,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
         return MsgPack {
             serialize_part: BatchEvictOwnerSourceResp {
                 operation_id,
-                cohorts: Vec::new(),
+                atomic_batches: Vec::new(),
                 error_code: err.code(),
                 error_json: err.to_json(),
             },
@@ -1059,51 +1080,56 @@ pub(crate) async fn handle_batch_evict_owner_source(
         };
     }
 
-    let mut responses = Vec::with_capacity(req.serialize_part.cohorts.len());
-    for (index, cohort) in req.serialize_part.cohorts.iter().enumerate() {
-        let (outcome, detail) = match plan_exact_owner_source_cohort(view, &owner, cohort) {
-            OwnerSourceCohortPlan::Completed(detail) => {
-                (OwnerSourceEvictionOutcome::Completed, detail.to_string())
-            }
-            OwnerSourceCohortPlan::Stale(detail) => (OwnerSourceEvictionOutcome::Stale, detail),
-            OwnerSourceCohortPlan::Rejected(detail) => {
-                (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
-            }
-            OwnerSourceCohortPlan::Ready {
-                members,
-                all_sources_present,
-            } => {
-                match view
-                    .master_kv_router()
-                    .enqueue_owner_capacity_eviction_cohort(
-                        owner.as_ref().to_string(),
-                        req.serialize_part.owner_node_start_time,
-                        members,
-                        all_sources_present,
-                    ) {
-                    EnqueueEvictionReclaimResult::Accepted => (
-                        OwnerSourceEvictionOutcome::Accepted,
-                        "exact source cohort accepted by reclaim pipeline".to_string(),
-                    ),
-                    EnqueueEvictionReclaimResult::AlreadyInProgress => (
-                        OwnerSourceEvictionOutcome::AlreadyInProgress,
-                        "same exact source cohort is already in progress".to_string(),
-                    ),
-                    EnqueueEvictionReclaimResult::PartialOverlap => (
-                        OwnerSourceEvictionOutcome::RetryableBusy,
-                        "source cohort partially overlaps another reclaim transaction".to_string(),
-                    ),
-                    EnqueueEvictionReclaimResult::NotInProgress => (
-                        OwnerSourceEvictionOutcome::Stale,
-                        "partially absent source cohort is not an in-progress replay".to_string(),
-                    ),
-                    EnqueueEvictionReclaimResult::Closed => (
-                        OwnerSourceEvictionOutcome::RetryableBusy,
-                        "source reclaim actor is unavailable".to_string(),
-                    ),
+    let mut responses = Vec::with_capacity(req.serialize_part.atomic_batches.len());
+    for (index, atomic_batch) in req.serialize_part.atomic_batches.iter().enumerate() {
+        let (outcome, detail) =
+            match plan_exact_owner_source_atomic_batch(view, &owner, atomic_batch) {
+                OwnerSourceAtomicBatchPlan::Completed(detail) => {
+                    (OwnerSourceEvictionOutcome::Completed, detail.to_string())
                 }
-            }
-        };
+                OwnerSourceAtomicBatchPlan::Stale(detail) => {
+                    (OwnerSourceEvictionOutcome::Stale, detail)
+                }
+                OwnerSourceAtomicBatchPlan::Rejected(detail) => {
+                    (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
+                }
+                OwnerSourceAtomicBatchPlan::Ready {
+                    members,
+                    all_sources_present,
+                } => {
+                    match view
+                        .master_kv_router()
+                        .enqueue_owner_capacity_eviction_atomic_batch(
+                            owner.as_ref().to_string(),
+                            req.serialize_part.owner_node_start_time,
+                            members,
+                            all_sources_present,
+                        ) {
+                        EnqueueEvictionReclaimResult::Accepted => (
+                            OwnerSourceEvictionOutcome::Accepted,
+                            "exact source atomic_batch accepted by reclaim pipeline".to_string(),
+                        ),
+                        EnqueueEvictionReclaimResult::AlreadyInProgress => (
+                            OwnerSourceEvictionOutcome::AlreadyInProgress,
+                            "same exact source atomic_batch is already in progress".to_string(),
+                        ),
+                        EnqueueEvictionReclaimResult::PartialOverlap => (
+                            OwnerSourceEvictionOutcome::RetryableBusy,
+                            "source atomic_batch partially overlaps another reclaim transaction"
+                                .to_string(),
+                        ),
+                        EnqueueEvictionReclaimResult::NotInProgress => (
+                            OwnerSourceEvictionOutcome::Stale,
+                            "partially absent source atomic_batch is not an in-progress replay"
+                                .to_string(),
+                        ),
+                        EnqueueEvictionReclaimResult::Closed => (
+                            OwnerSourceEvictionOutcome::RetryableBusy,
+                            "source reclaim actor is unavailable".to_string(),
+                        ),
+                    }
+                }
+            };
         let outcome_counter = match outcome {
             OwnerSourceEvictionOutcome::Accepted => &counters.source_evict_accepted,
             OwnerSourceEvictionOutcome::AlreadyInProgress => &counters.source_evict_in_progress,
@@ -1115,8 +1141,8 @@ pub(crate) async fn handle_batch_evict_owner_source(
             OwnerSourceEvictionOutcome::RejectedNotEvictable => &counters.source_evict_rejected,
         };
         outcome_counter.fetch_add(1, Ordering::Relaxed);
-        responses.push(OwnerSourceEvictionCohortResp {
-            cohort_index: u32::try_from(index).unwrap_or(u32::MAX),
+        responses.push(OwnerSourceEvictionAtomicBatchResp {
+            atomic_batch_index: u32::try_from(index).unwrap_or(u32::MAX),
             outcome,
             detail,
         });
@@ -1125,7 +1151,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
     MsgPack {
         serialize_part: BatchEvictOwnerSourceResp {
             operation_id,
-            cohorts: responses,
+            atomic_batches: responses,
             error_code: OK,
             error_json: String::new(),
         },
@@ -1135,9 +1161,25 @@ pub(crate) async fn handle_batch_evict_owner_source(
 
 struct RemovedOwnerSource {
     desc: NodeValueReplicaDesc,
+    capacity_bytes: u64,
     removed_last_route: bool,
 }
 
+fn record_last_route_removal(
+    counters: &super::EvictionReclaimCounters,
+    removed: &RemovedOwnerSource,
+) {
+    if !removed.removed_last_route {
+        return;
+    }
+    counters
+        .last_route_removed_members
+        .fetch_add(1, Ordering::Relaxed);
+    counters
+        .last_route_removed_bytes
+        .fetch_add(removed.capacity_bytes, Ordering::Relaxed);
+}
+
 fn remove_exact_owner_source_route(
     routes: &dashmap::DashMap<String, Arc<super::OneKvNodesRoutes>>,
     owner: &NodeID,
@@ -1155,13 +1197,14 @@ fn remove_exact_owner_source_route(
         if !reclaim_backing_matches(replica, &item.backing) {
             return None;
         }
+        let capacity_bytes = replica.backing.capacity_bytes();
         let desc = NodeValueReplicaDesc {
-            weight_bytes: u32::try_from(replica.backing.capacity_bytes()).unwrap_or(u32::MAX),
+            weight_bytes: u32::try_from(capacity_bytes).unwrap_or(u32::MAX),
             put_id: route.put_id,
         };
-        replicas.remove(owner).map(|_| desc)
+        replicas.remove(owner).map(|_| (desc, capacity_bytes))
     };
-    let removed_desc = removed_desc?;
+    let (removed_desc, capacity_bytes) = removed_desc?;
 
     let removed_last_route = if route.nodes_replicas.read().is_empty() {
         routes
@@ -1176,6 +1219,7 @@ fn remove_exact_owner_source_route(
     };
     Some(RemovedOwnerSource {
         desc: removed_desc,
+        capacity_bytes,
         removed_last_route,
     })
 }
@@ -1196,6 +1240,10 @@ fn remove_reclaimed_replica(
     let removed =
         remove_exact_owner_source_route(&view.master_kv_router().inner().kv_routes, owner, item);
     if let Some(removed) = removed {
+        let counters = view
+            .master_kv_router()
+            .eviction_reclaim_counters(owner.as_ref());
+        record_last_route_removal(counters.as_ref(), &removed);
         if removed.removed_last_route && view.master_kv_router().prefix_index_enabled() {
             let view_task = view.clone();
             let key = item.key.clone();
@@ -1518,7 +1566,7 @@ fn clear_master_fences(view: &MasterKvRouterView, items: &[OwnerReclaimItem]) {
     }
 }
 
-fn try_install_cohort_master_fences(
+fn try_install_atomic_batch_master_fences(
     activity: &super::MasterKeyActivityTable,
     items: &[OwnerReclaimItem],
 ) -> Result<(), (usize, super::MasterKeyActivitySnapshot)> {
@@ -1537,14 +1585,14 @@ fn try_install_cohort_master_fences(
     Ok(())
 }
 
-/// Reclaim one TP/atomic cohort as a transaction.
+/// Reclaim one TP/atomic atomic_batch as a transaction.
 ///
 /// Before the first owner Commit, any failed fence/validation/Prepare rolls
-/// the entire cohort back.  Once a response (including an Abort response)
+/// the entire atomic_batch back.  Once a response (including an Abort response)
 /// proves that any member was committed, rollback is impossible; the same
 /// transaction retains every master fence and keeps driving the remaining
-/// members until all are committed, then removes/finalizes the whole cohort.
-async fn reclaim_cohort_items(
+/// members until all are committed, then removes/finalizes the whole atomic_batch.
+async fn reclaim_atomic_batch_items(
     view: &MasterKvRouterView,
     owner: &NodeID,
     items: Vec<OwnerReclaimItem>,
@@ -1555,14 +1603,15 @@ async fn reclaim_cohort_items(
     let counters = view
         .master_kv_router()
         .eviction_reclaim_counters(owner.as_ref());
-    if let Err((failed_index, activity)) =
-        try_install_cohort_master_fences(&view.master_kv_router().inner().key_activity, &items)
-    {
+    if let Err((failed_index, activity)) = try_install_atomic_batch_master_fences(
+        &view.master_kv_router().inner().key_activity,
+        &items,
+    ) {
         counters
             .master_activity_deferred
             .fetch_add(1, Ordering::Relaxed);
         tracing::trace!(
-            "cohort reclaim deferred by master activity: owner={} key={} puts={} gets={} replicas={} reclaim_installed={}",
+            "atomic_batch reclaim deferred by master activity: owner={} key={} puts={} gets={} replicas={} reclaim_installed={}",
             owner,
             items[failed_index].key,
             activity.puts,
@@ -1601,7 +1650,7 @@ async fn reclaim_cohort_items(
     }
     if !master_only.is_empty() || owner_coordinated.len() != fenced.len() {
         tracing::error!(
-            "BUG: one reclaim cohort mixed master-only and owner-coordinated backings: owner={} cohort={} master_only={} owner_coordinated={}",
+            "BUG: one reclaim atomic_batch mixed master-only and owner-coordinated backings: owner={} atomic_batch={} master_only={} owner_coordinated={}",
             owner,
             fenced.len(),
             master_only.len(),
@@ -1713,7 +1762,7 @@ async fn reclaim_cohort_items(
 
         if rounds == 8 && !committed_keys.is_empty() {
             tracing::warn!(
-                "owner cohort reclaim is rolling forward after partial/uncertain commit: owner={} cohort={} committed={}",
+                "owner atomic_batch reclaim is rolling forward after partial/uncertain commit: owner={} atomic_batch={} committed={}",
                 owner,
                 owner_coordinated.len(),
                 committed_keys.len(),
@@ -2103,7 +2152,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                             OwnerReclaimReason::OwnerCapacityEviction,
                         ),
                         EvictionReclaimOrigin::MasterAllocationCapacity => {
-                            let members = match plan_master_allocation_capacity_cohort(
+                            let members = match plan_master_allocation_capacity_atomic_batch(
                                 &view_task,
                                 &request,
                             ) {
@@ -2134,7 +2183,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                                     counters.route_changed.fetch_add(1, Ordering::Relaxed);
                                     continue;
                                 }
-                                Err(MasterCapacityPlanError::InvalidCohort) => {
+                                Err(MasterCapacityPlanError::InvalidAtomicBatch) => {
                                     retry_requests.push(request);
                                     continue;
                                 }
@@ -2161,7 +2210,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                                 .owner_cache_operation_locks
                                 .get_lock(owner_node_id.clone());
                             let owner_cache_guard = owner_cache_lock.lock().await;
-                            let detach_result = detach_present_capacity_cohort_siblings(
+                            let detach_result = detach_present_capacity_atomic_batch_siblings(
                                 &view_task,
                                 &owner_node_id,
                                 &members,
@@ -2257,7 +2306,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                         })
                         .collect::<Option<Vec<_>>>();
                     if let Some(items) = items {
-                        let _ = reclaim_cohort_items(&view_task, &owner, items).await;
+                        let _ = reclaim_atomic_batch_items(&view_task, &owner, items).await;
                     }
                     for accounting_request in accounting_requests.drain(..) {
                         if request_is_current(&view_task, &accounting_request) {
@@ -2276,7 +2325,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                 let retry_count = retry_requests.len();
                 spawn_eviction_reclaim_retry(view_task.clone(), retry_requests);
                 tracing::trace!(
-                    "safe cohort eviction reclaim batch completed: owner={} retry_deferred={}",
+                    "safe atomic_batch eviction reclaim batch completed: owner={} retry_deferred={}",
                     owner_node_id,
                     retry_count,
                 );
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
index 6ebd982..25edd27 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
@@ -190,7 +190,7 @@ pub(super) async fn apply_post_route_maintenance_batch(
                 continue;
             }
             tracing::debug!("Inserting key: {:?} into cache", key);
-            cache.insert(key.clone(), desc.clone());
+            super::insert_master_cache_entry(cache.as_ref(), key.clone(), desc.clone());
             tracing::debug!(
                 "Inserted key: {:?} into cache, current cache size: {}",
                 key,
@@ -198,7 +198,7 @@ pub(super) async fn apply_post_route_maintenance_batch(
             );
         }
         // Do not search Moka for a recoverable victim here. CPU append Done
-        // already carries the exact source key/cohort and performs a validated
+        // already carries the exact source key/atomic_batch and performs a validated
         // point demotion. Local-reserve Free/Prepared/Pending/Committed state is
         // the physical capacity authority while that writeback is in flight.
     }
@@ -228,7 +228,7 @@ pub(super) async fn apply_post_route_maintenance_batch(
             ) {
                 continue;
             }
-            tier1_cache.insert(key, desc);
+            super::insert_master_cache_entry(tier1_cache.as_ref(), key, desc);
         }
     }
 }
diff --git a/fluxon_rs/fluxon_kv/src/memholder/mod.rs b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
index 7221f2d..f44f7c3 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
@@ -23,6 +23,7 @@ use crate::client_kv_api::ClientKvApiView;
 use crate::{cluster_manager::NodeID, external_client_api::ExternalClientApiView};
 
 use bitcode::{Decode, Encode};
+use fluxon_util::pin_aware_moka::PinGuard;
 
 #[derive(Clone, Debug)]
 pub enum MemoryInfoDropAction {
@@ -91,6 +92,7 @@ pub struct UserMemHolder {
     pub memory_info: Arc<MemoryInfo>,
     pub refcount: Arc<AllMemholderRefCount>,
     expose_kind: UserMemHolderExposeKind,
+    _owner_hot_pin: Option<PinGuard>,
 }
 impl UserMemHolder {
     pub fn holder_id(&self) -> u64 {
@@ -117,6 +119,14 @@ impl UserMemHolder {
         refcount: Arc<AllMemholderRefCount>,
         expose_kind: UserMemHolderExposeKind,
     ) -> Self {
+        let owner_hot_pin = match expose_kind {
+            UserMemHolderExposeKind::SegPtr => refcount
+                .view
+                .client_kv_api()
+                .inner()
+                .owner_hot_pin_memory_info(&memory_info),
+            UserMemHolderExposeKind::OwnedCopy => None,
+        };
         tracing::debug!(
             "Creating UserMemHolder for key '{}', _holder_id_ {}, expose_kind={:?}.",
             memory_info.key,
@@ -127,6 +137,7 @@ impl UserMemHolder {
             memory_info,
             refcount,
             expose_kind,
+            _owner_hot_pin: owner_hot_pin,
         }
     }
     pub fn memory_info(&self) -> Arc<MemoryInfo> {
diff --git a/fluxon_rs/fluxon_util/src/lib.rs b/fluxon_rs/fluxon_util/src/lib.rs
index cde6dc7..8d13b8e 100644
--- a/fluxon_rs/fluxon_util/src/lib.rs
+++ b/fluxon_rs/fluxon_util/src/lib.rs
@@ -7,6 +7,7 @@ pub mod hash;
 pub mod init_dag_compiler;
 pub mod map_lock;
 pub mod merge_recent_async_notifies;
+pub mod pin_aware_moka;
 pub mod prefix_scan;
 pub mod prom_remote_write;
 pub mod scoped_future_set;
diff --git a/fluxon_rs/fluxon_util/src/pin_aware_moka.rs b/fluxon_rs/fluxon_util/src/pin_aware_moka.rs
new file mode 100644
index 0000000..b518fac
--- /dev/null
+++ b/fluxon_rs/fluxon_util/src/pin_aware_moka.rs
@@ -0,0 +1,671 @@
+//! Explicit pin management around Moka without changing Moka's entry key.
+//!
+//! The first pin removes one entry from Moka. The final unpin inserts the same
+//! generation again. A pin alias can be reserved before its entry is inserted.
+
+use moka::notification::RemovalCause;
+use moka::ops::compute::{CompResult, Op};
+use moka::sync::Cache;
+use parking_lot::Mutex;
+use std::collections::{HashMap, HashSet};
+use std::hash::Hash;
+use std::sync::{Arc, Weak};
+
+type EvictionListener<Key, Value> = dyn Fn(Arc<Key>, Value, RemovalCause) + Send + Sync + 'static;
+type Weigher<Key, Value> = dyn Fn(&Key, &Value) -> u32 + Send + Sync + 'static;
+
+/// Builder for [`PinAwareMoka`].
+pub struct PinAwareMokaBuilder<Key, PinAlias, Value> {
+    max_capacity: u64,
+    weigher: Arc<Weigher<Key, Value>>,
+    eviction_listener: Option<Arc<EvictionListener<Key, Value>>>,
+    _pin_alias: std::marker::PhantomData<PinAlias>,
+}
+
+impl<Key, PinAlias, Value> PinAwareMokaBuilder<Key, PinAlias, Value> {
+    fn new(max_capacity: u64) -> Self {
+        Self {
+            max_capacity,
+            weigher: Arc::new(|_, _| 1),
+            eviction_listener: None,
+            _pin_alias: std::marker::PhantomData,
+        }
+    }
+
+    pub fn weigher(
+        mut self,
+        weigher: impl Fn(&Key, &Value) -> u32 + Send + Sync + 'static,
+    ) -> Self {
+        self.weigher = Arc::new(weigher);
+        self
+    }
+
+    /// Set the listener for Moka removals.
+    ///
+    /// Pin/unpin removals are internal and are not sent to this listener.
+    pub fn eviction_listener(
+        mut self,
+        listener: impl Fn(Arc<Key>, Value, RemovalCause) + Send + Sync + 'static,
+    ) -> Self {
+        self.eviction_listener = Some(Arc::new(listener));
+        self
+    }
+}
+
+impl<Key, PinAlias, Value> PinAwareMokaBuilder<Key, PinAlias, Value>
+where
+    Key: Clone + Eq + Hash + Send + Sync + 'static,
+    PinAlias: Clone + Eq + Hash + Send + Sync + 'static,
+    Value: Clone + Send + Sync + 'static,
+{
+    pub fn build(self) -> PinAwareMoka<Key, PinAlias, Value> {
+        assert!(
+            self.max_capacity > 0,
+            "pin-aware Moka capacity must be positive"
+        );
+        let weigher = self.weigher;
+        let eviction_listener = self.eviction_listener;
+        let inner = Arc::new_cyclic(|weak: &Weak<Inner<Key, PinAlias, Value>>| {
+            let listener_inner = weak.clone();
+            let cache = Cache::builder()
+                .max_capacity(self.max_capacity)
+                .weigher(move |_key: &Key, entry: &MokaEntry<PinAlias, Value>| entry.weight)
+                .eviction_listener(move |key, entry, cause| {
+                    if let Some(inner) = listener_inner.upgrade() {
+                        inner.handle_moka_removal(key, entry, cause);
+                    }
+                })
+                .build();
+            Inner {
+                cache,
+                state: Mutex::new(State::default()),
+                mutation: Mutex::new(()),
+                weigher,
+                eviction_listener,
+            }
+        });
+        PinAwareMoka { inner }
+    }
+}
+
+/// A key-preserving Moka wrapper with explicit pin aliases.
+pub struct PinAwareMoka<Key, PinAlias, Value> {
+    inner: Arc<Inner<Key, PinAlias, Value>>,
+}
+
+impl<Key, PinAlias, Value> Clone for PinAwareMoka<Key, PinAlias, Value> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+#[derive(Clone)]
+struct MokaEntry<PinAlias, Value> {
+    generation: u64,
+    value: Value,
+    weight: u32,
+    _pin_alias: std::marker::PhantomData<PinAlias>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Residency {
+    InMoka,
+    Pinned,
+    Selected,
+}
+
+struct EntryState<PinAlias, Value> {
+    generation: u64,
+    pin_aliases: Arc<[PinAlias]>,
+    value: Value,
+    weight: u32,
+    pin_count: usize,
+    residency: Residency,
+}
+
+enum PinLease<Key, PinAlias> {
+    Pending(PinAlias),
+    Assigned { key: Key, generation: u64 },
+}
+
+struct State<Key, PinAlias, Value> {
+    next_generation: u64,
+    next_pin_lease: u64,
+    entries: HashMap<Key, EntryState<PinAlias, Value>>,
+    aliases: HashMap<PinAlias, (Key, u64)>,
+    pin_leases: HashMap<u64, PinLease<Key, PinAlias>>,
+    pending_pins: HashMap<PinAlias, HashSet<u64>>,
+}
+
+impl<Key, PinAlias, Value> Default for State<Key, PinAlias, Value> {
+    fn default() -> Self {
+        Self {
+            next_generation: 1,
+            next_pin_lease: 1,
+            entries: HashMap::new(),
+            aliases: HashMap::new(),
+            pin_leases: HashMap::new(),
+            pending_pins: HashMap::new(),
+        }
+    }
+}
+
+struct Inner<Key, PinAlias, Value> {
+    cache: Cache<Key, MokaEntry<PinAlias, Value>>,
+    state: Mutex<State<Key, PinAlias, Value>>,
+    // State transitions and Moka mutations are serialized, but the state lock
+    // is always released before calling Moka and its synchronous listener.
+    mutation: Mutex<()>,
+    weigher: Arc<Weigher<Key, Value>>,
+    eviction_listener: Option<Arc<EvictionListener<Key, Value>>>,
+}
+
+impl<Key, PinAlias, Value> Inner<Key, PinAlias, Value>
+where
+    Key: Clone + Eq + Hash + Send + Sync + 'static,
+    PinAlias: Clone + Eq + Hash + Send + Sync + 'static,
+    Value: Clone + Send + Sync + 'static,
+{
+    fn remove_moka_generation(&self, key: &Key, generation: u64) -> bool {
+        matches!(
+            self.cache.entry(key.clone()).and_compute_with(|current| {
+                if current
+                    .as_ref()
+                    .is_some_and(|entry| entry.value().generation == generation)
+                {
+                    Op::Remove
+                } else {
+                    Op::Nop
+                }
+            }),
+            CompResult::Removed(_)
+        )
+    }
+
+    fn handle_moka_removal(
+        &self,
+        key: Arc<Key>,
+        entry: MokaEntry<PinAlias, Value>,
+        cause: RemovalCause,
+    ) {
+        if cause != RemovalCause::Size {
+            return;
+        }
+        let selected = {
+            let mut state = self.state.lock();
+            let Some(current) = state.entries.get_mut(key.as_ref()) else {
+                return;
+            };
+            if current.generation != entry.generation || current.residency != Residency::InMoka {
+                return;
+            }
+            debug_assert_eq!(current.pin_count, 0);
+            current.residency = Residency::Selected;
+            true
+        };
+        if selected && let Some(listener) = self.eviction_listener.as_ref() {
+            listener(key, entry.value, cause);
+        }
+    }
+
+    fn release_pin(self: &Arc<Self>, lease_id: u64) {
+        let _mutation = self.mutation.lock();
+        let entry_to_admit = {
+            let mut state = self.state.lock();
+            let Some(lease) = state.pin_leases.remove(&lease_id) else {
+                return;
+            };
+            match lease {
+                PinLease::Pending(alias) => {
+                    if let Some(leases) = state.pending_pins.get_mut(&alias) {
+                        leases.remove(&lease_id);
+                        if leases.is_empty() {
+                            state.pending_pins.remove(&alias);
+                        }
+                    }
+                    None
+                }
+                PinLease::Assigned { key, generation } => {
+                    let Some(entry) = state.entries.get_mut(&key) else {
+                        return;
+                    };
+                    if entry.generation != generation {
+                        return;
+                    }
+                    entry.pin_count = entry
+                        .pin_count
+                        .checked_sub(1)
+                        .expect("pin-aware Moka pin count underflow");
+                    if entry.pin_count == 0 && entry.residency == Residency::Pinned {
+                        entry.residency = Residency::InMoka;
+                        Some((
+                            key,
+                            MokaEntry {
+                                generation,
+                                value: entry.value.clone(),
+                                weight: entry.weight,
+                                _pin_alias: std::marker::PhantomData,
+                            },
+                        ))
+                    } else {
+                        None
+                    }
+                }
+            }
+        };
+        if let Some((key, entry)) = entry_to_admit {
+            self.cache.insert(key, entry);
+        }
+    }
+}
+
+impl<Key, PinAlias, Value> PinAwareMoka<Key, PinAlias, Value>
+where
+    Key: Clone + Eq + Hash + Send + Sync + 'static,
+    PinAlias: Clone + Eq + Hash + Send + Sync + 'static,
+    Value: Clone + Send + Sync + 'static,
+{
+    pub fn builder(max_capacity: u64) -> PinAwareMokaBuilder<Key, PinAlias, Value> {
+        PinAwareMokaBuilder::new(max_capacity)
+    }
+
+    /// Insert one normal Moka entry with one or more explicit pin identities.
+    pub fn insert(
+        &self,
+        key: Key,
+        pin_aliases: impl IntoIterator<Item = PinAlias>,
+        value: Value,
+    ) -> u64 {
+        let pin_aliases = pin_aliases.into_iter().collect::<Vec<_>>();
+        assert!(
+            !pin_aliases.is_empty(),
+            "a pin-aware Moka entry must have at least one pin alias"
+        );
+        assert_eq!(
+            pin_aliases.iter().collect::<HashSet<_>>().len(),
+            pin_aliases.len(),
+            "a pin-aware Moka entry cannot contain duplicate pin aliases"
+        );
+        let weight = (self.inner.weigher)(&key, &value);
+        let pin_aliases: Arc<[PinAlias]> = pin_aliases.into();
+        let _mutation = self.inner.mutation.lock();
+        let (generation, admit, displaced) = {
+            let mut state = self.inner.state.lock();
+            let generation = state.next_generation;
+            state.next_generation = state
+                .next_generation
+                .checked_add(1)
+                .expect("pin-aware Moka generation space exhausted");
+
+            let mut displaced_keys = HashSet::new();
+            if state.entries.contains_key(&key) {
+                displaced_keys.insert(key.clone());
+            }
+            for alias in pin_aliases.iter() {
+                if let Some((old_key, _)) = state.aliases.get(alias) {
+                    displaced_keys.insert(old_key.clone());
+                }
+            }
+            let mut displaced = Vec::new();
+            for old_key in displaced_keys {
+                if let Some(old) = state.entries.remove(&old_key) {
+                    for alias in old.pin_aliases.iter() {
+                        if state.aliases.get(alias) == Some(&(old_key.clone(), old.generation)) {
+                            state.aliases.remove(alias);
+                        }
+                    }
+                    displaced.push((old_key, old.generation));
+                }
+            }
+
+            let mut pin_count = 0usize;
+            for alias in pin_aliases.iter() {
+                let pending = state.pending_pins.remove(alias).unwrap_or_default();
+                pin_count = pin_count
+                    .checked_add(pending.len())
+                    .expect("pin-aware Moka pin count overflow");
+                for lease_id in pending {
+                    *state
+                        .pin_leases
+                        .get_mut(&lease_id)
+                        .expect("pending pin lease must exist") = PinLease::Assigned {
+                        key: key.clone(),
+                        generation,
+                    };
+                }
+                state
+                    .aliases
+                    .insert(alias.clone(), (key.clone(), generation));
+            }
+            let residency = if pin_count == 0 {
+                Residency::InMoka
+            } else {
+                Residency::Pinned
+            };
+            state.entries.insert(
+                key.clone(),
+                EntryState {
+                    generation,
+                    pin_aliases: pin_aliases.clone(),
+                    value: value.clone(),
+                    weight,
+                    pin_count,
+                    residency,
+                },
+            );
+            let admit = (residency == Residency::InMoka).then(|| MokaEntry {
+                generation,
+                value,
+                weight,
+                _pin_alias: std::marker::PhantomData,
+            });
+            (generation, admit, displaced)
+        };
+        for (old_key, old_generation) in displaced {
+            self.inner.remove_moka_generation(&old_key, old_generation);
+        }
+        if let Some(entry) = admit {
+            self.inner.cache.insert(key, entry);
+        }
+        generation
+    }
+
+    /// Pin the entry identified by `alias`, or reserve a pin before insertion.
+    ///
+    /// Returns `None` when Moka selection already owns that entry.
+    pub fn try_pin_alias(&self, alias: PinAlias) -> Option<PinGuard> {
+        self.try_pin_alias_if(alias, |_| true)
+    }
+
+    /// Pin only if an existing value satisfies `predicate`.
+    pub fn try_pin_alias_if(
+        &self,
+        alias: PinAlias,
+        predicate: impl FnOnce(&Value) -> bool,
+    ) -> Option<PinGuard> {
+        let _mutation = self.inner.mutation.lock();
+        let mut state = self.inner.state.lock();
+        let lease_id = state.next_pin_lease;
+        state.next_pin_lease = state
+            .next_pin_lease
+            .checked_add(1)
+            .expect("pin-aware Moka pin lease space exhausted");
+        let mut remove = None;
+        if let Some((key, generation)) = state.aliases.get(&alias).cloned() {
+            let entry = state
+                .entries
+                .get_mut(&key)
+                .expect("pin alias must reference a live entry");
+            assert_eq!(entry.generation, generation);
+            if !predicate(&entry.value) || entry.residency == Residency::Selected {
+                return None;
+            }
+            entry.pin_count = entry
+                .pin_count
+                .checked_add(1)
+                .expect("pin-aware Moka pin count overflow");
+            if entry.residency == Residency::InMoka {
+                entry.residency = Residency::Pinned;
+                remove = Some((key.clone(), generation));
+            }
+            state
+                .pin_leases
+                .insert(lease_id, PinLease::Assigned { key, generation });
+        } else {
+            state
+                .pending_pins
+                .entry(alias.clone())
+                .or_default()
+                .insert(lease_id);
+            state.pin_leases.insert(lease_id, PinLease::Pending(alias));
+        }
+        drop(state);
+        if let Some((key, generation)) = remove {
+            self.inner.remove_moka_generation(&key, generation);
+        }
+        Some(PinGuard {
+            _lease: Arc::new(PinGuardLease {
+                release: Box::new({
+                    let inner = Arc::downgrade(&self.inner);
+                    move || {
+                        if let Some(inner) = inner.upgrade() {
+                            inner.release_pin(lease_id);
+                        }
+                    }
+                }),
+            }),
+        })
+    }
+
+    /// Read and touch an unselected entry. Pinned entries remain readable here.
+    pub fn get(&self, key: &Key) -> Option<Value> {
+        let _mutation = self.inner.mutation.lock();
+        let (generation, value, in_moka) = {
+            let state = self.inner.state.lock();
+            let entry = state.entries.get(key)?;
+            if entry.residency == Residency::Selected {
+                return None;
+            }
+            (
+                entry.generation,
+                entry.value.clone(),
+                entry.residency == Residency::InMoka,
+            )
+        };
+        if in_moka {
+            let _ = self
+                .inner
+                .cache
+                .get(key)
+                .filter(|entry| entry.generation == generation);
+        }
+        Some(value)
+    }
+
+    pub fn contains_key(&self, key: &Key) -> bool {
+        self.inner
+            .state
+            .lock()
+            .entries
+            .get(key)
+            .is_some_and(|entry| entry.residency != Residency::Selected)
+    }
+
+    /// Remove an entry generation from both the wrapper and Moka.
+    pub fn invalidate(&self, key: &Key) -> bool {
+        self.invalidate_if(key, |_| true)
+    }
+
+    pub fn invalidate_if(&self, key: &Key, predicate: impl FnOnce(&Value) -> bool) -> bool {
+        self.take_if(key, predicate).is_some()
+    }
+
+    pub fn take_if(&self, key: &Key, predicate: impl FnOnce(&Value) -> bool) -> Option<Value> {
+        let _mutation = self.inner.mutation.lock();
+        let removed = {
+            let mut state = self.inner.state.lock();
+            let Some(entry) = state.entries.get(key) else {
+                return None;
+            };
+            if !predicate(&entry.value) {
+                return None;
+            }
+            let entry = state
+                .entries
+                .remove(key)
+                .expect("validated pin-aware entry disappeared under lock");
+            for alias in entry.pin_aliases.iter() {
+                if state.aliases.get(alias) == Some(&(key.clone(), entry.generation)) {
+                    state.aliases.remove(alias);
+                }
+            }
+            entry
+        };
+        self.inner.remove_moka_generation(key, removed.generation);
+        Some(removed.value)
+    }
+
+    /// Pop LRU entries until at least `weight_to_evict` weight is selected.
+    pub fn evict_some(&self, weight_to_evict: u64) -> u64 {
+        let _mutation = self.inner.mutation.lock();
+        self.inner.cache.evict_some(weight_to_evict)
+    }
+
+    pub fn run_pending_tasks(&self) {
+        let _mutation = self.inner.mutation.lock();
+        self.inner.cache.run_pending_tasks();
+    }
+
+    pub fn set_max_capacity(&self, capacity: u64) -> Result<(), moka::CapacityError> {
+        self.inner.cache.set_max_capacity(capacity)
+    }
+
+    pub fn max_capacity(&self) -> Option<u64> {
+        self.inner.cache.policy().max_capacity()
+    }
+
+    pub fn weighted_size(&self) -> u64 {
+        self.inner.cache.weighted_size()
+    }
+
+    pub fn entry_count(&self) -> u64 {
+        self.inner.cache.entry_count()
+    }
+}
+
+/// A cloneable pin. The final clone performs the unpin transition.
+#[derive(Clone)]
+pub struct PinGuard {
+    _lease: Arc<PinGuardLease>,
+}
+
+struct PinGuardLease {
+    release: Box<dyn Fn() + Send + Sync + 'static>,
+}
+
+impl Drop for PinGuardLease {
+    fn drop(&mut self) {
+        (self.release)();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Barrier;
+    use std::thread;
+
+    type TestCache = PinAwareMoka<String, String, u32>;
+
+    fn cache(capacity: u64, evicted: Arc<Mutex<Vec<String>>>) -> TestCache {
+        TestCache::builder(capacity)
+            .weigher(|_, weight| *weight)
+            .eviction_listener(move |key, _, cause| {
+                assert_eq!(cause, RemovalCause::Size);
+                evicted.lock().push((*key).clone());
+            })
+            .build()
+    }
+
+    fn insert(cache: &TestCache, key: &str, alias: &str, weight: u32) {
+        cache.insert(key.to_string(), [alias.to_string()], weight);
+        cache.run_pending_tasks();
+    }
+
+    #[test]
+    fn first_pin_removes_and_final_unpin_readmits_one_key() {
+        let cache = cache(100, Arc::new(Mutex::new(Vec::new())));
+        insert(&cache, "key", "alias", 10);
+        let first = cache.try_pin_alias("alias".to_string()).unwrap();
+        let second = cache.try_pin_alias("alias".to_string()).unwrap();
+        cache.run_pending_tasks();
+        assert_eq!(cache.entry_count(), 0);
+        assert_eq!(cache.get(&"key".to_string()), Some(10));
+
+        drop(first);
+        cache.run_pending_tasks();
+        assert_eq!(cache.entry_count(), 0);
+        drop(second);
+        cache.run_pending_tasks();
+        assert_eq!(cache.entry_count(), 1);
+    }
+
+    #[test]
+    fn pin_before_insert_defers_moka_admission() {
+        let cache = cache(100, Arc::new(Mutex::new(Vec::new())));
+        let pin = cache.try_pin_alias("alias".to_string()).unwrap();
+        insert(&cache, "key", "alias", 10);
+        assert_eq!(cache.entry_count(), 0);
+        drop(pin);
+        cache.run_pending_tasks();
+        assert_eq!(cache.entry_count(), 1);
+    }
+
+    #[test]
+    fn pin_and_evict_race_has_one_winner() {
+        for iteration in 0..100 {
+            let evicted = Arc::new(Mutex::new(Vec::new()));
+            let cache = cache(100, evicted.clone());
+            insert(&cache, "key", "alias", 10);
+            let barrier = Arc::new(Barrier::new(3));
+            let pin_cache = cache.clone();
+            let pin_barrier = barrier.clone();
+            let pin = thread::spawn(move || {
+                pin_barrier.wait();
+                pin_cache.try_pin_alias("alias".to_string())
+            });
+            let pop_cache = cache.clone();
+            let pop_barrier = barrier.clone();
+            let pop = thread::spawn(move || {
+                pop_barrier.wait();
+                pop_cache.evict_some(1)
+            });
+            barrier.wait();
+            let pin = pin.join().unwrap();
+            let selected_weight = pop.join().unwrap();
+            assert_ne!(pin.is_some(), selected_weight != 0, "iteration {iteration}");
+            assert_eq!(evicted.lock().len(), usize::from(selected_weight != 0));
+            drop(pin);
+        }
+    }
+
+    #[test]
+    fn stale_guard_does_not_readmit_a_new_generation() {
+        let cache = cache(100, Arc::new(Mutex::new(Vec::new())));
+        let stale = cache.try_pin_alias("old-alias".to_string()).unwrap();
+        insert(&cache, "key", "old-alias", 10);
+        insert(&cache, "key", "new-alias", 20);
+        drop(stale);
+        cache.run_pending_tasks();
+        assert_eq!(cache.get(&"key".to_string()), Some(20));
+        assert_eq!(cache.entry_count(), 1);
+    }
+
+    #[test]
+    fn selected_entry_rejects_pin_until_restore_or_invalidate() {
+        let evicted = Arc::new(Mutex::new(Vec::new()));
+        let cache = cache(100, evicted.clone());
+        insert(&cache, "key", "alias", 10);
+        assert_eq!(cache.evict_some(1), 10);
+        assert_eq!(&*evicted.lock(), &["key"]);
+        assert!(cache.try_pin_alias("alias".to_string()).is_none());
+
+        insert(&cache, "key", "alias", 10);
+        let pin = cache.try_pin_alias("alias".to_string()).unwrap();
+        drop(pin);
+        assert!(cache.invalidate(&"key".to_string()));
+        assert!(!cache.contains_key(&"key".to_string()));
+    }
+
+    #[test]
+    fn weighted_pop_keeps_key_granularity_and_can_overshoot() {
+        let evicted = Arc::new(Mutex::new(Vec::new()));
+        let cache = cache(100, evicted.clone());
+        insert(&cache, "first", "a", 12);
+        insert(&cache, "second", "b", 7);
+        assert_eq!(cache.evict_some(13), 19);
+        assert_eq!(evicted.lock().len(), 2);
+    }
+}

From aafac1111007b2c7ac8d2fb13358c63e1dca200b Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Sun, 19 Jul 2026 10:11:03 +0800
Subject: [PATCH 06/10] back 7.3qps

---
 .../src/client_kv_api/external_api.rs         |   94 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |    8 +-
 .../client_kv_api/local_reserve_rebalance.rs  |   32 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 1060 +++++++----------
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  |  412 +++----
 .../fluxon_kv/src/client_kv_api/reclaim.rs    |   40 +-
 .../fluxon_kv/src/master_kv_router/mod.rs     |  274 +----
 .../src/master_kv_router/msg_pack.rs          |   18 +-
 .../fluxon_kv/src/master_kv_router/reclaim.rs |  779 +++++-------
 9 files changed, 1168 insertions(+), 1549 deletions(-)

diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 015d41c..09f5e0f 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -17,7 +17,8 @@ use crate::client_kv_api::msg_pack::{
 use crate::client_kv_api::{
     self, ExternalGetKeyInterest, ExternalGetKeySharedOp, ExternalGetKeySharedPhase,
     ExternalGetStartEntry, ExternalGetStartOwnerItem, ExternalGetStartPrefixResult,
-    ExternalGetStartSharedItemResult, ExternalGetStartTransferOutput, ExternalPendingPutCtx,
+    ExternalGetStartSharedItemResult, ExternalGetStartTransferOutput,
+    ExternalLocalFirstPutKeyReservation, ExternalPendingPutCtx, ExternalPutKeyOutcome,
     OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerLocalReserveSlotLease,
     OwnerLocalReserveSlotRef, ReplicaTaskTarget,
 };
@@ -1132,6 +1133,7 @@ mod external_get_start_batch_tests {
             OwnerKeyControlState {
                 local_puts: 0,
                 external_pending_puts: 0,
+                external_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(old.clone()),
@@ -1160,6 +1162,7 @@ mod external_get_start_batch_tests {
             OwnerKeyControlState {
                 local_puts: 0,
                 external_pending_puts: 0,
+                external_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(op.clone()),
@@ -2909,29 +2912,82 @@ impl HandlerForExternalClient for ClientKvApi {
             }));
         }
 
-        let mut pending_fences = Vec::with_capacity(req.items.len());
-        for item in &req.items {
-            let pending_fence = match inner.reserve_external_local_first_put_key(
-                &item.key,
-                item.reject_if_inflight_same_key,
-                item.reject_if_exist_same_key,
-            ) {
-                Ok(pending_fence) => pending_fence,
-                Err(err) => {
-                    let items = req
-                        .items
-                        .iter()
-                        .map(|_| external_local_first_error_item(&err))
-                        .collect();
+        let pending_fences = loop {
+            let mut pending_fences = Vec::with_capacity(req.items.len());
+            let mut wait_for = None;
+            for item in &req.items {
+                match inner.reserve_external_local_first_put_key(
+                    &item.key,
+                    item.reject_if_inflight_same_key,
+                    item.reject_if_exist_same_key,
+                ) {
+                    Ok(ExternalLocalFirstPutKeyReservation::Leader(pending_fence)) => {
+                        pending_fences.push(pending_fence);
+                    }
+                    Ok(ExternalLocalFirstPutKeyReservation::Wait(op)) => {
+                        if atomic_group_lens.len() != 1 {
+                            let err = KvError::Api(ApiError::KeyBeingWritten {
+                                key: item.key.clone(),
+                            });
+                            return Ok(ExternalBatchPutStartResp {
+                                items: req
+                                    .items
+                                    .iter()
+                                    .map(|_| external_local_first_error_item(&err))
+                                    .collect(),
+                                error_code: OK,
+                                error_json: String::new(),
+                            });
+                        }
+                        wait_for = Some((item.key.clone(), op));
+                        break;
+                    }
+                    Err(err) => {
+                        let items = req
+                            .items
+                            .iter()
+                            .map(|_| external_local_first_error_item(&err))
+                            .collect();
+                        return Ok(ExternalBatchPutStartResp {
+                            items,
+                            error_code: OK,
+                            error_json: String::new(),
+                        });
+                    }
+                }
+            }
+            let Some((joined_key, op)) = wait_for else {
+                break pending_fences;
+            };
+
+            // Never retain a partial atomic_batch while waiting for another
+            // key. Two overlapping requests with different key order must not
+            // each hold one leader fence and wait forever on the other.
+            drop(pending_fences);
+            match op.wait().await {
+                ExternalPutKeyOutcome::Succeeded => {
+                    tracing::info!(
+                        joined_key,
+                        items = req.items.len(),
+                        "external local-first Put reused an inflight leader result"
+                    );
+                    let err = KvError::Api(ApiError::KeyAlreadyExists { key: joined_key });
                     return Ok(ExternalBatchPutStartResp {
-                        items,
+                        items: req
+                            .items
+                            .iter()
+                            .map(|_| external_local_first_error_item(&err))
+                            .collect(),
                         error_code: OK,
                         error_json: String::new(),
                     });
                 }
-            };
-            pending_fences.push(pending_fence);
-        }
+                ExternalPutKeyOutcome::Failed => continue,
+                ExternalPutKeyOutcome::InFlight => {
+                    unreachable!("shared Put wait must return a terminal outcome")
+                }
+            }
+        };
 
         // Finish every fallible, purely logical derivation before claiming
         // physical slots.  The per-key fences above are RAII-owned, so any
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 8cfbf99..57c7164 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -620,10 +620,10 @@ impl ClientKvApiInner {
             results[pending.idx] = Some(Ok(Some((user_mem_holder, Some(get_info)))));
         }
 
-        // All members are in get_cached_info before any hot admission can evict one of them.
-        // This keeps atomic/TP atomic_batch write-back decisions complete.
-        for (key, put_id, memory_info, atomic_group) in local_hot_admissions {
-            self.owner_hot_track_committed(&key, put_id, &memory_info, atomic_group.as_ref());
+        // Publish every local index before Moka admission starts selecting
+        // individual capacity victims.
+        for (key, put_id, memory_info, _atomic_group) in local_hot_admissions {
+            self.owner_hot_track_committed(&key, put_id, &memory_info);
         }
 
         Ok(results
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
index a9db5e5..5fec74f 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/local_reserve_rebalance.rs
@@ -1,5 +1,6 @@
 use super::{
-    ClientKvApiInner, ClientKvApiView, OwnerLocalReserveClassState, OwnerLocalReservePoolState,
+    ClientKvApiInner, ClientKvApiView, OwnerHotEvictionDispatch, OwnerLocalReserveClassState,
+    OwnerLocalReservePoolState,
 };
 use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 use crate::master_kv_router::msg_pack::ReserveLocalGrantOutcome;
@@ -107,7 +108,7 @@ fn owner_slot_pressure_request_bytes(
 
 fn owner_slot_pressure_projected_reclaim_bytes(inner: &ClientKvApiInner) -> u64 {
     // Candidate debt starts in Moka's synchronous eviction listener. A
-    // candidate that is incomplete, pinned, or waiting in the retry queue has
+    // candidate that is stale, pinned, or waiting in the retry queue has
     // no installed owner fence and cannot release a slot. Only exact selected
     // source debt is valid projected reclaim credit.
     inner
@@ -533,7 +534,7 @@ mod tests {
     }
 
     #[test]
-    fn retry_candidate_debt_is_not_projected_reclaim_credit() {
+    fn pre_fence_candidate_debt_is_not_projected_reclaim_credit() {
         let snapshot = RebalanceClassSnapshot {
             slot_size: 1024 * 1024,
             slots_per_grant: 4,
@@ -776,6 +777,17 @@ pub fn spawn_owner_slot_pressure_actor(view: ClientKvApiView) {
             let Some(cache) = inner.owner_hot_cache.clone() else {
                 continue;
             };
+            if inner
+                .owner_hot_eviction_tx
+                .send(OwnerHotEvictionDispatch::BeginPressure { requested_bytes })
+                .is_err()
+            {
+                tracing::warn!(
+                    requested_bytes,
+                    "owner slot pressure dispatcher is closed before Moka selection"
+                );
+                return;
+            }
             let selected_bytes = match limit_thirdparty::tokio::task::spawn_blocking(move || {
                 cache.evict_some(requested_bytes)
             })
@@ -788,9 +800,21 @@ pub fn spawn_owner_slot_pressure_actor(view: ClientKvApiView) {
                         err = ?err,
                         "owner slot pressure Moka selection task failed"
                     );
-                    continue;
+                    0
                 }
             };
+            if inner
+                .owner_hot_eviction_tx
+                .send(OwnerHotEvictionDispatch::EndPressure { selected_bytes })
+                .is_err()
+            {
+                tracing::warn!(
+                    requested_bytes,
+                    selected_bytes,
+                    "owner slot pressure dispatcher closed after Moka selection"
+                );
+                return;
+            }
             last_kick_at = Some(Instant::now());
             tracing::debug!(
                 requested_bytes,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index efb4dde..fe309a7 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -49,6 +49,7 @@ use crate::{
     },
     rpcresp_kvresult_convert::msg_and_error::{ApiError, ErrorCode, KvError, KvResult},
 };
+use ::tokio::sync::watch;
 use async_trait::async_trait;
 use dashmap::{DashMap, mapref::entry::Entry as DashMapEntry};
 use fluxon_framework::{LogicalModule, define_module};
@@ -120,9 +121,8 @@ pub struct OwnerRuntimeObserveSnapshot {
     pub hot_eviction_skipped_stale: u64,
     pub hot_eviction_skipped_reclaim: u64,
     pub hot_eviction_skipped_active_holders: u64,
-    pub hot_group_registry_entries: u64,
-    pub hot_group_trigger_duplicates: u64,
-    pub hot_group_trigger_incomplete: u64,
+    pub hot_victim_duplicates: u64,
+    pub hot_victim_invalid_backing: u64,
     pub grouped_put_done_batches: u64,
     pub grouped_put_done_items: u64,
     pub legacy_put_done_batches: u64,
@@ -1260,16 +1260,6 @@ pub(crate) struct OwnerHotReplicaIdentity {
     put_version: u32,
 }
 
-impl OwnerHotReplicaIdentity {
-    fn from_group_member(member: &crate::master_kv_router::msg_pack::PutAtomicGroupMember) -> Self {
-        Self {
-            key: member.key.clone(),
-            put_time_ms: member.put_id.0,
-            put_version: member.put_id.1,
-        }
-    }
-}
-
 #[derive(Default)]
 struct OwnerHotCacheCounters {
     size_evictions: AtomicU64,
@@ -1287,8 +1277,8 @@ struct OwnerHotCacheCounters {
     skipped_stale: AtomicU64,
     skipped_reclaim: AtomicU64,
     skipped_active_holders: AtomicU64,
-    group_trigger_duplicates: AtomicU64,
-    group_trigger_incomplete: AtomicU64,
+    victim_duplicates: AtomicU64,
+    victim_invalid_backing: AtomicU64,
     grouped_put_done_batches: AtomicU64,
     grouped_put_done_items: AtomicU64,
     legacy_put_done_batches: AtomicU64,
@@ -1350,35 +1340,37 @@ pub(crate) struct OwnerHotEvictionEvent {
     put_id: crate::master_kv_router::put::PutIDForAKey,
     memory_info: Weak<MemoryInfo>,
     selection_debt: Arc<OwnerHotSelectionDebt>,
-    /// The event was dispatched from the bounded retry queue. It may be a
-    /// pre-selection retry (no atomic_batch yet) or an exact installed-atomic_batch retry.
+    /// The event was dispatched from the bounded retry queue.
     retry: bool,
-    /// Exact owner source-delete atomic_batch retained across RPC retries. Once set,
-    /// retries never re-expand or re-pin the local atomic_batch.
-    source_eviction_atomic_batch:
-        Option<Arc<crate::master_kv_router::msg_pack::OwnerSourceEvictionAtomicBatch>>,
+    /// Exact single-key source-delete transaction retained across RPC retries.
+    source_eviction_victim:
+        Option<Arc<crate::master_kv_router::msg_pack::OwnerSourceEvictionVictim>>,
     /// Failure count follows the event while it is dispatched, preserving
     /// exponential backoff across queue take/reinsert cycles.
     retry_failures: u32,
 }
 
+pub(crate) enum OwnerHotEvictionDispatch {
+    Victim(OwnerHotEvictionEvent),
+    BeginPressure { requested_bytes: u64 },
+    EndPressure { selected_bytes: u64 },
+    Flush,
+}
+
 pub(crate) enum OwnerHotEvictionPreparation {
     Ready {
         trigger: OwnerHotReplicaIdentity,
-        sources: Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>,
+        source: Arc<MemoryInfo>,
     },
     RetryableReclaimFence,
-    RetryableIncompleteAtomicBatch,
-    TemporarilyPinned {
-        active_members: usize,
-    },
+    TemporarilyPinned,
     Obsolete,
 }
 
 pub(crate) enum OwnerHotSelectionFenceOutcome {
     Fenced,
     Retryable,
-    TemporarilyPinned { active_members: usize },
+    TemporarilyPinned,
     Obsolete,
 }
 
@@ -1451,8 +1443,8 @@ impl OwnerHotRetryQueue {
         if !Arc::ptr_eq(&entry.event.selection_debt, &event.selection_debt) {
             entry.event.selection_debt.release();
         }
-        if event.source_eviction_atomic_batch.is_none() {
-            event.source_eviction_atomic_batch = entry.event.source_eviction_atomic_batch.clone();
+        if event.source_eviction_victim.is_none() {
+            event.source_eviction_victim = entry.event.source_eviction_victim.clone();
         }
         entry.failures = entry.failures.max(event.retry_failures).saturating_add(1);
         event.retry = true;
@@ -1565,6 +1557,49 @@ pub(crate) enum OwnerReclaimRecord {
     Committed(crate::master_kv_router::msg_pack::OwnerReclaimItem),
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ExternalPutKeyOutcome {
+    InFlight,
+    Succeeded,
+    Failed,
+}
+
+pub(crate) struct ExternalPutKeySharedOp {
+    outcome: watch::Sender<ExternalPutKeyOutcome>,
+}
+
+impl ExternalPutKeySharedOp {
+    fn new() -> Arc<Self> {
+        let (outcome, _receiver) = watch::channel(ExternalPutKeyOutcome::InFlight);
+        Arc::new(Self { outcome })
+    }
+
+    fn complete(&self, outcome: ExternalPutKeyOutcome) {
+        debug_assert_ne!(outcome, ExternalPutKeyOutcome::InFlight);
+        if *self.outcome.borrow() == ExternalPutKeyOutcome::InFlight {
+            self.outcome.send_replace(outcome);
+        }
+    }
+
+    pub(crate) async fn wait(&self) -> ExternalPutKeyOutcome {
+        let mut outcome = self.outcome.subscribe();
+        loop {
+            let current = *outcome.borrow_and_update();
+            if current != ExternalPutKeyOutcome::InFlight {
+                return current;
+            }
+            if outcome.changed().await.is_err() {
+                return ExternalPutKeyOutcome::Failed;
+            }
+        }
+    }
+}
+
+pub(crate) enum ExternalLocalFirstPutKeyReservation {
+    Leader(Arc<ExternalPendingPutFenceGuard>),
+    Wait(Arc<ExternalPutKeySharedOp>),
+}
+
 #[derive(Default)]
 pub(crate) struct OwnerKeyControlState {
     local_puts: u32,
@@ -1573,6 +1608,9 @@ pub(crate) struct OwnerKeyControlState {
     /// guard stored in every context, so cache invalidation cannot clear the
     /// reclaim fence while a cloned context is still in use.
     external_pending_puts: u32,
+    /// The reject-on-inflight local-first Put leader for this key. Followers
+    /// subscribe to its terminal result without claiming another slot.
+    external_put: Option<Arc<ExternalPutKeySharedOp>>,
     /// Owner-local pre-Prepare fence installed by the Moka source-eviction
     /// dispatcher.  The matching committed index is moved into this record,
     /// so a new local Get cannot acquire the source between victim selection
@@ -1593,6 +1631,7 @@ impl OwnerKeyControlState {
     fn is_idle(&self) -> bool {
         self.local_puts == 0
             && self.external_pending_puts == 0
+            && self.external_put.is_none()
             && self.source_eviction_selection.is_none()
             && self.reclaim.is_none()
             && self.external_get.is_none()
@@ -1642,6 +1681,8 @@ pub(crate) struct ExternalPendingPutFenceGuard {
     key: String,
     owner_key_control: Arc<OwnerKeyControlTable>,
     owns_local_put: bool,
+    local_put_op: Option<Arc<ExternalPutKeySharedOp>>,
+    local_put_succeeded: std::sync::atomic::AtomicBool,
     local_slot_cleanup_view: Option<ClientKvApiView>,
     local_slot_lease: Mutex<Option<OwnerLocalReserveSlotLease>>,
     local_slot_release_failed: std::sync::atomic::AtomicBool,
@@ -1658,6 +1699,17 @@ impl std::fmt::Debug for ExternalPendingPutFenceGuard {
 }
 
 impl ExternalPendingPutFenceGuard {
+    pub(crate) fn mark_local_put_succeeded(&self) {
+        assert!(
+            self.owns_local_put,
+            "only a local-first Put can publish a reusable terminal result"
+        );
+        self.local_put_succeeded.store(true, Ordering::Release);
+        if let Some(op) = self.local_put_op.as_ref() {
+            op.complete(ExternalPutKeyOutcome::Succeeded);
+        }
+    }
+
     pub(crate) fn attach_local_slot_lease(&self, lease: OwnerLocalReserveSlotLease) {
         assert!(
             self.owns_local_put,
@@ -1709,6 +1761,8 @@ fn release_external_pending_put_counts(
     owner_key_control: &Arc<OwnerKeyControlTable>,
     key: &str,
     owns_local_put: bool,
+    local_put_op: Option<Arc<ExternalPutKeySharedOp>>,
+    local_put_succeeded: bool,
 ) {
     let mut controls = owner_key_control.lock_key(key);
     let remove = {
@@ -1724,12 +1778,28 @@ fn release_external_pending_put_counts(
                 .local_puts
                 .checked_sub(1)
                 .expect("owner local-first Put fence counter underflow");
+            if let Some(op) = local_put_op.as_ref()
+                && state
+                    .external_put
+                    .as_ref()
+                    .is_some_and(|current| Arc::ptr_eq(current, op))
+            {
+                state.external_put = None;
+            }
         }
         state.is_idle()
     };
     if remove {
         controls.remove(key);
     }
+    drop(controls);
+    if let Some(op) = local_put_op {
+        op.complete(if local_put_succeeded {
+            ExternalPutKeyOutcome::Succeeded
+        } else {
+            ExternalPutKeyOutcome::Failed
+        });
+    }
 }
 
 fn acquire_external_pending_put_fence_for_key(
@@ -1754,6 +1824,8 @@ fn acquire_external_pending_put_fence_for_key(
         key: key.to_string(),
         owner_key_control: owner_key_control.clone(),
         owns_local_put: false,
+        local_put_op: None,
+        local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
         local_slot_cleanup_view: None,
         local_slot_lease: Mutex::new(None),
         local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
@@ -1773,6 +1845,8 @@ impl Drop for ExternalPendingPutFenceGuard {
             let key = self.key.clone();
             let owner_key_control = self.owner_key_control.clone();
             let owns_local_put = self.owns_local_put;
+            let local_put_op = self.local_put_op.clone();
+            let local_put_succeeded = self.local_put_succeeded.load(Ordering::Acquire);
             view.spawn("external_pending_put_slot_drop_cleanup", async move {
                 if let Err(err) = worker_view
                     .client_kv_api()
@@ -1783,13 +1857,21 @@ impl Drop for ExternalPendingPutFenceGuard {
                     tracing::error!("pending local-first Put slot Drop cleanup failed: {}", err);
                     return;
                 }
-                release_external_pending_put_counts(&owner_key_control, &key, owns_local_put);
+                release_external_pending_put_counts(
+                    &owner_key_control,
+                    &key,
+                    owns_local_put,
+                    local_put_op,
+                    local_put_succeeded,
+                );
             });
         } else if !self.local_slot_release_failed.load(Ordering::Acquire) {
             release_external_pending_put_counts(
                 &self.owner_key_control,
                 &self.key,
                 self.owns_local_put,
+                self.local_put_op.clone(),
+                self.local_put_succeeded.load(Ordering::Acquire),
             );
         } else {
             tracing::error!(
@@ -1898,208 +1980,11 @@ fn pin_current_owner_hot_source(
     }
 }
 
-fn owner_hot_group_anchor_identity(
-    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
-) -> Option<OwnerHotReplicaIdentity> {
-    group
-        .members
-        .first()
-        .map(OwnerHotReplicaIdentity::from_group_member)
-}
-
-fn register_owner_hot_atomic_group(
-    atomic_groups: &DashMap<
-        OwnerHotReplicaIdentity,
-        Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
-    >,
-    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
-) {
-    let Some(anchor) = owner_hot_group_anchor_identity(group) else {
-        return;
-    };
-    let existing = atomic_groups
-        .get(&anchor)
-        .map(|entry| entry.value().clone());
-    let group = match existing {
-        Some(existing) if existing.as_ref() == group => existing,
-        Some(_) => {
-            tracing::warn!(
-                "owner hot atomic-group anchor reused with different membership: key={} put_id=({},{})",
-                anchor.key,
-                anchor.put_time_ms,
-                anchor.put_version
-            );
-            Arc::new(group.clone())
-        }
-        None => Arc::new(group.clone()),
-    };
-    for member in &group.members {
-        atomic_groups.insert(
-            OwnerHotReplicaIdentity::from_group_member(member),
-            group.clone(),
-        );
-    }
-}
-
-fn forget_owner_hot_atomic_group(
-    atomic_groups: &DashMap<
-        OwnerHotReplicaIdentity,
-        Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
-    >,
-    identity: &OwnerHotReplicaIdentity,
-) {
-    let group = atomic_groups
-        .get(identity)
-        .map(|entry| entry.value().clone());
-    let Some(group) = group else {
-        return;
-    };
-    for member in &group.members {
-        atomic_groups.remove(&OwnerHotReplicaIdentity::from_group_member(member));
-    }
-}
-
-fn pin_current_owner_hot_group_sources(
-    group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
-    get_cached_info: &DashMap<String, GetCachedInfo>,
-    counters: &OwnerHotCacheCounters,
-) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
-    let mut sources = Vec::with_capacity(group.members.len());
-    for member in &group.members {
-        let Some(cached) = get_cached_info.get(&member.key) else {
-            counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
-            return None;
-        };
-        if (cached.put_time_ms, cached.put_version) != member.put_id {
-            counters.skipped_stale.fetch_add(1, Ordering::Relaxed);
-            return None;
-        }
-        sources.push((
-            OwnerHotReplicaIdentity::from_group_member(member),
-            cached.mem_holder.clone(),
-        ));
-    }
-    Some(sources)
-}
-
-fn owner_hot_tp_atomic_batch_key_rows(
-    identity: &OwnerHotReplicaIdentity,
-    group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
-) -> Result<Option<Vec<Vec<String>>>, ()> {
-    let member_keys = group
-        .map(|group| {
-            group
-                .members
-                .iter()
-                .map(|member| member.key.as_str())
-                .collect::<Vec<_>>()
-        })
-        .unwrap_or_else(|| vec![identity.key.as_str()]);
-    let Some(first_key) = member_keys.first().copied() else {
-        return Err(());
-    };
-    let first_tp = crate::master_kv_router::infer_sglang_tp_key(first_key);
-    let Some(first_tp) = first_tp else {
-        return member_keys
-            .iter()
-            .all(|key| crate::master_kv_router::infer_sglang_tp_key(key).is_none())
-            .then_some(None)
-            .ok_or(());
-    };
-    let mut logical_members = Vec::with_capacity(member_keys.len());
-    for key in member_keys {
-        let Some(member_tp) = crate::master_kv_router::infer_sglang_tp_key(key) else {
-            return Err(());
-        };
-        if member_tp.rank != first_tp.rank || member_tp.size != first_tp.size {
-            return Err(());
-        }
-        logical_members.push(member_tp.logical_prefix.to_string());
-    }
-    if first_tp.size == 1 {
-        return Ok(None);
-    }
-    Ok(Some(
-        (0..first_tp.size)
-            .map(|rank| {
-                logical_members
-                    .iter()
-                    .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", first_tp.size))
-                    .collect::<Vec<_>>()
-            })
-            .collect(),
-    ))
-}
-
-fn pin_current_owner_hot_tp_atomic_batch_sources(
-    atomic_batch_key_rows: &[Vec<String>],
-    expect_atomic_group: bool,
-    get_cached_info: &DashMap<String, GetCachedInfo>,
-    atomic_groups: &DashMap<
-        OwnerHotReplicaIdentity,
-        Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>,
-    >,
-    counters: &OwnerHotCacheCounters,
-) -> Option<Vec<(OwnerHotReplicaIdentity, Arc<MemoryInfo>)>> {
-    let mut atomic_batch_sources = Vec::new();
-    for rank_keys in atomic_batch_key_rows {
-        if rank_keys.is_empty() {
-            return None;
-        }
-        let mut rank_sources = Vec::with_capacity(rank_keys.len());
-        for key in rank_keys {
-            let Some(cached) = get_cached_info.get(key) else {
-                counters.skipped_reclaim.fetch_add(1, Ordering::Relaxed);
-                return None;
-            };
-            rank_sources.push((
-                OwnerHotReplicaIdentity {
-                    key: key.clone(),
-                    put_time_ms: cached.put_time_ms,
-                    put_version: cached.put_version,
-                },
-                cached.mem_holder.clone(),
-            ));
-        }
-
-        if expect_atomic_group {
-            let Some(rank_group) = atomic_groups
-                .get(&rank_sources[0].0)
-                .map(|entry| entry.value().clone())
-            else {
-                return None;
-            };
-            if rank_group.members.len() != rank_sources.len()
-                || rank_group.members.iter().zip(rank_sources.iter()).any(
-                    |(member, (identity, _))| {
-                        member.key != identity.key
-                            || member.put_id != (identity.put_time_ms, identity.put_version)
-                    },
-                )
-            {
-                return None;
-            }
-            for (identity, _) in &rank_sources {
-                if !atomic_groups
-                    .get(identity)
-                    .is_some_and(|entry| Arc::ptr_eq(entry.value(), &rank_group))
-                {
-                    return None;
-                }
-            }
-        } else if rank_sources.len() != 1 || atomic_groups.contains_key(&rank_sources[0].0) {
-            return None;
-        }
-        atomic_batch_sources.extend(rank_sources);
-    }
-    Some(atomic_batch_sources)
-}
-
 fn build_owner_hot_cache(
     capacity_bytes: u64,
     counters: Arc<OwnerHotCacheCounters>,
     retry_queue: Arc<OwnerHotRetryQueue>,
-    eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionEvent>,
+    eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionDispatch>,
 ) -> OwnerHotCache {
     assert!(
         capacity_bytes > 0,
@@ -2127,11 +2012,13 @@ fn build_owner_hot_cache(
                 memory_info: entry.memory_info.clone(),
                 selection_debt,
                 retry: false,
-                source_eviction_atomic_batch: None,
+                source_eviction_victim: None,
                 retry_failures: 0,
             };
-            if let Err(err) = eviction_tx.send(event) {
-                let event = err.0;
+            if let Err(err) = eviction_tx.send(OwnerHotEvictionDispatch::Victim(event)) {
+                let OwnerHotEvictionDispatch::Victim(event) = err.0 else {
+                    unreachable!("the Moka listener only sends victim events")
+                };
                 counters
                     .source_evict_dispatch_failed
                     .fetch_add(1, Ordering::Relaxed);
@@ -2221,14 +2108,11 @@ pub struct ClientKvApiInner {
     /// Free or the source is restored to owner-hot.
     owner_source_eviction_selected:
         Arc<DashMap<OwnerHotReplicaIdentity, Arc<OwnerHotSelectionDebt>>>,
-    owner_hot_atomic_groups: Arc<
-        DashMap<OwnerHotReplicaIdentity, Arc<crate::master_kv_router::msg_pack::PutAtomicGroup>>,
-    >,
     owner_hot_counters: Arc<OwnerHotCacheCounters>,
     owner_hot_retry_queue: Arc<OwnerHotRetryQueue>,
-    owner_hot_eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionEvent>,
+    owner_hot_eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionDispatch>,
     owner_hot_eviction_rx:
-        Mutex<Option<tokio::sync::ampsc::UnboundedReceiver<OwnerHotEvictionEvent>>>,
+        Mutex<Option<tokio::sync::ampsc::UnboundedReceiver<OwnerHotEvictionDispatch>>>,
 
     /// Shared delete actor input for owner -> external weak-index invalidation.
     pub external_invalidate_delete: EnsureMemholderMgmtDeleteHandle<DeleteClientKvMetaCacheItem>,
@@ -2338,17 +2222,6 @@ impl ClientKvApiInner {
         ops
     }
 
-    fn owner_hot_register_atomic_group(
-        &self,
-        group: &crate::master_kv_router::msg_pack::PutAtomicGroup,
-    ) {
-        register_owner_hot_atomic_group(self.owner_hot_atomic_groups.as_ref(), group);
-    }
-
-    fn owner_hot_forget_atomic_group_for_member(&self, identity: &OwnerHotReplicaIdentity) {
-        forget_owner_hot_atomic_group(self.owner_hot_atomic_groups.as_ref(), identity);
-    }
-
     pub(crate) fn owner_hot_prepare_eviction(
         &self,
         event: &OwnerHotEvictionEvent,
@@ -2376,66 +2249,12 @@ impl ClientKvApiInner {
             OwnerHotPinResult::Stale => return OwnerHotEvictionPreparation::Obsolete,
         };
 
-        // A retry reaches this function only when no source-selection atomic_batch
-        // has been installed yet. Installed retries are handled from the
-        // event's exact `source_eviction_atomic_batch` before this method is called.
-        // Therefore a pre-selection retry must resolve the complete current
-        // TP/atomic atomic_batch again; degrading it to the trigger key would make
-        // the master reject a valid victim as an incomplete atomic_batch forever.
-        // AtomicBatch lookup and pinning deliberately happen after the synchronous
-        // Moka listener has returned. Each source Arc is cloned directly from
-        // its current DashMap entry. A concurrent reclaim must wait for that
-        // shard read guard and then observes the extra strong reference, so no
-        // global owner-control lock is needed.
-        let group = self
-            .owner_hot_atomic_groups
-            .get(&trigger)
-            .map(|entry| entry.value().clone());
-        let atomic_batch_sources =
-            match owner_hot_tp_atomic_batch_key_rows(&trigger, group.as_deref()) {
-                Ok(Some(atomic_batch_key_rows)) => {
-                    // pin_current_owner_hot_tp_atomic_batch_sources clones the trigger
-                    // again. Drop the probe pin first so the active-holder test
-                    // below has the exact index + selection baseline of two Arcs.
-                    drop(memory_info);
-                    pin_current_owner_hot_tp_atomic_batch_sources(
-                        &atomic_batch_key_rows,
-                        group.is_some(),
-                        self.get_cached_info.as_ref(),
-                        self.owner_hot_atomic_groups.as_ref(),
-                        self.owner_hot_counters.as_ref(),
-                    )
-                }
-                Ok(None) => match group.as_deref() {
-                    Some(group) => {
-                        drop(memory_info);
-                        pin_current_owner_hot_group_sources(
-                            group,
-                            self.get_cached_info.as_ref(),
-                            self.owner_hot_counters.as_ref(),
-                        )
-                    }
-                    None => Some(vec![(trigger.clone(), memory_info)]),
-                },
-                Err(()) => None,
-            };
-        match atomic_batch_sources {
-            Some(sources) if !sources.is_empty() => {
-                let active_members = sources
-                    .iter()
-                    .filter(|(_, source)| owner_hot_source_has_active_holders(source))
-                    .count();
-                if active_members == 0 {
-                    OwnerHotEvictionPreparation::Ready { trigger, sources }
-                } else {
-                    OwnerHotEvictionPreparation::TemporarilyPinned { active_members }
-                }
-            }
-            _ => {
-                self.owner_hot_counters
-                    .group_trigger_incomplete
-                    .fetch_add(1, Ordering::Relaxed);
-                OwnerHotEvictionPreparation::RetryableIncompleteAtomicBatch
+        if owner_hot_source_has_active_holders(&memory_info) {
+            OwnerHotEvictionPreparation::TemporarilyPinned
+        } else {
+            OwnerHotEvictionPreparation::Ready {
+                trigger,
+                source: memory_info,
             }
         }
     }
@@ -2503,77 +2322,59 @@ impl ClientKvApiInner {
         Some(debt)
     }
 
-    pub(crate) fn owner_hot_install_source_selection_fences(
+    pub(crate) fn owner_hot_install_source_selection_fence(
         &self,
-        sources: &[(OwnerHotReplicaIdentity, Arc<MemoryInfo>)],
+        identity: &OwnerHotReplicaIdentity,
+        source: &Arc<MemoryInfo>,
     ) -> OwnerHotSelectionFenceOutcome {
-        let mut installed = Vec::with_capacity(sources.len());
-        let mut outcome = OwnerHotSelectionFenceOutcome::Fenced;
-
-        for (identity, source) in sources {
-            let mut controls = self.owner_key_control.lock_key(&identity.key);
-            let control_busy = controls.get(&identity.key).is_some_and(|state| {
-                state.local_puts != 0
-                    || state.external_pending_puts != 0
-                    || state.external_get.is_some()
-                    || state.local_access_fenced()
-            });
-            if control_busy
-                || self
-                    .precommit_local_visible_info
-                    .contains_key(&identity.key)
-                || self.pending_local_get_info.contains_key(&identity.key)
-            {
-                outcome = OwnerHotSelectionFenceOutcome::Retryable;
-                break;
-            }
-
-            let cached_info = self
-                .get_cached_info
-                .remove_if(&identity.key, |_, cached| {
-                    (cached.put_time_ms, cached.put_version)
-                        == (identity.put_time_ms, identity.put_version)
-                        && Arc::ptr_eq(&cached.mem_holder, source)
-                })
-                .map(|(_, cached)| cached);
-            let Some(cached_info) = cached_info else {
-                outcome = OwnerHotSelectionFenceOutcome::Obsolete;
-                break;
-            };
-
-            let state = controls.entry(identity.key.clone()).or_default();
-            assert!(state.source_eviction_selection.is_none());
-            state.source_eviction_selection = Some(OwnerSourceEvictionSelection {
-                put_id: (identity.put_time_ms, identity.put_version),
-                cached_info,
-            });
-            installed.push(identity.clone());
+        let mut controls = self.owner_key_control.lock_key(&identity.key);
+        let control_busy = controls.get(&identity.key).is_some_and(|state| {
+            state.local_puts != 0
+                || state.external_pending_puts != 0
+                || state.external_get.is_some()
+                || state.local_access_fenced()
+        });
+        if control_busy
+            || self
+                .precommit_local_visible_info
+                .contains_key(&identity.key)
+            || self.pending_local_get_info.contains_key(&identity.key)
+        {
+            return OwnerHotSelectionFenceOutcome::Retryable;
         }
 
-        if matches!(outcome, OwnerHotSelectionFenceOutcome::Fenced) {
-            // Every matching local index is now hidden under its per-key fence.
-            // Each source has exactly two expected Arcs: the selection record
-            // and this temporary atomic_batch pin.  No new local reader can enter,
-            // so an extra reference is an already-active holder and the whole
-            // atomic_batch must be rolled back before choosing another victim.
-            let active_members = sources
-                .iter()
-                .filter(|(_, source)| owner_hot_source_has_active_holders(source))
-                .count();
-            if active_members != 0 {
-                outcome = OwnerHotSelectionFenceOutcome::TemporarilyPinned { active_members };
-            }
-        }
+        let cached_info = self
+            .get_cached_info
+            .remove_if(&identity.key, |_, cached| {
+                (cached.put_time_ms, cached.put_version)
+                    == (identity.put_time_ms, identity.put_version)
+                    && Arc::ptr_eq(&cached.mem_holder, source)
+            })
+            .map(|(_, cached)| cached);
+        let Some(cached_info) = cached_info else {
+            return OwnerHotSelectionFenceOutcome::Obsolete;
+        };
 
-        if !matches!(outcome, OwnerHotSelectionFenceOutcome::Fenced) {
-            for identity in installed.iter().rev() {
-                assert!(
-                    self.owner_hot_restore_source_selection(identity),
-                    "partial owner source selection rollback must find every installed fence"
-                );
-            }
+        let state = controls.entry(identity.key.clone()).or_default();
+        assert!(state.source_eviction_selection.is_none());
+        state.source_eviction_selection = Some(OwnerSourceEvictionSelection {
+            put_id: (identity.put_time_ms, identity.put_version),
+            cached_info,
+        });
+        drop(controls);
+
+        // The index Arc moved into source_eviction_selection. The temporary
+        // source Arc is the second expected reference; any extra Arc is an
+        // active reader or transfer that arrived before the fence was installed.
+        if owner_hot_source_has_active_holders(source) {
+            assert!(
+                self.owner_hot_restore_source_selection(identity),
+                "a pinned single-key victim must restore its source fence"
+            );
+            OwnerHotSelectionFenceOutcome::TemporarilyPinned
+        } else {
+            OwnerHotSelectionFenceOutcome::Fenced
         }
-        outcome
     }
 
     fn owner_hot_track_committed(
@@ -2581,7 +2382,6 @@ impl ClientKvApiInner {
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
         memory_info: &Arc<MemoryInfo>,
-        atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
     ) {
         let Some(cache) = self.owner_hot_cache.as_ref() else {
             return;
@@ -2589,9 +2389,6 @@ impl ClientKvApiInner {
         if !self.owner_hot_source_is_current(key, put_id, memory_info) {
             return;
         }
-        if let Some(group) = atomic_group {
-            self.owner_hot_register_atomic_group(group);
-        }
         cache.insert(
             key.to_string(),
             [OwnerHotPinAlias::new(memory_info)],
@@ -2610,7 +2407,6 @@ impl ClientKvApiInner {
         &self,
         key: &str,
         put_id: crate::master_kv_router::put::PutIDForAKey,
-        atomic_group: Option<&crate::master_kv_router::msg_pack::PutAtomicGroup>,
     ) -> bool {
         let memory_info = self.get_cached_info.get(key).and_then(|cached| {
             ((cached.put_time_ms, cached.put_version) == put_id).then(|| cached.mem_holder.clone())
@@ -2618,7 +2414,7 @@ impl ClientKvApiInner {
         let Some(memory_info) = memory_info else {
             return false;
         };
-        self.owner_hot_track_committed(key, put_id, &memory_info, atomic_group);
+        self.owner_hot_track_committed(key, put_id, &memory_info);
         true
     }
 
@@ -2636,7 +2432,7 @@ impl ClientKvApiInner {
         }) {
             return;
         }
-        self.owner_hot_track_committed(key, put_id, memory_info, None);
+        self.owner_hot_track_committed(key, put_id, memory_info);
     }
 
     pub(crate) fn owner_hot_source_is_current(
@@ -2679,7 +2475,6 @@ impl ClientKvApiInner {
                 .fetch_add(1, Ordering::Relaxed);
         }
         self.owner_hot_retry_queue.remove(&identity);
-        self.owner_hot_forget_atomic_group_for_member(&identity);
     }
 
     pub(crate) fn release_local_reserve_route_for_memory_info(&self, memory_info: &MemoryInfo) {
@@ -2755,7 +2550,7 @@ impl ClientKvApiInner {
         key: &str,
         reject_if_inflight_same_key: bool,
         reject_if_exist_same_key: bool,
-    ) -> KvResult<Arc<ExternalPendingPutFenceGuard>> {
+    ) -> KvResult<ExternalLocalFirstPutKeyReservation> {
         let mut controls = self.owner_key_control.lock_key(key);
         if controls
             .get(key)
@@ -2776,10 +2571,26 @@ impl ClientKvApiInner {
             }));
         }
         let state = controls.entry(key.to_string()).or_default();
+        let reusable_singleflight = reject_if_inflight_same_key && reject_if_exist_same_key;
         if reject_if_inflight_same_key && state.local_puts > 0 {
-            return Err(KvError::Api(ApiError::KeyBeingWritten {
-                key: key.to_string(),
-            }));
+            return (reusable_singleflight)
+                .then(|| state.external_put.clone())
+                .flatten()
+                .map_or_else(
+                    || {
+                        Err(KvError::Api(ApiError::KeyBeingWritten {
+                            key: key.to_string(),
+                        }))
+                    },
+                    |op| Ok(ExternalLocalFirstPutKeyReservation::Wait(op)),
+                );
+        }
+        let local_put_op = reusable_singleflight.then(ExternalPutKeySharedOp::new);
+        if let Some(op) = local_put_op.as_ref() {
+            assert!(
+                state.external_put.replace(op.clone()).is_none(),
+                "a reject-on-inflight Put leader must own an empty shared-op slot"
+            );
         }
         state.local_puts = state
             .local_puts
@@ -2789,14 +2600,18 @@ impl ClientKvApiInner {
             .external_pending_puts
             .checked_add(1)
             .expect("external pending Put fence counter overflow");
-        Ok(Arc::new(ExternalPendingPutFenceGuard {
-            key: key.to_string(),
-            owner_key_control: self.owner_key_control.clone(),
-            owns_local_put: true,
-            local_slot_cleanup_view: Some(self.view.clone_view()),
-            local_slot_lease: Mutex::new(None),
-            local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
-        }))
+        Ok(ExternalLocalFirstPutKeyReservation::Leader(Arc::new(
+            ExternalPendingPutFenceGuard {
+                key: key.to_string(),
+                owner_key_control: self.owner_key_control.clone(),
+                owns_local_put: true,
+                local_put_op,
+                local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
+                local_slot_cleanup_view: Some(self.view.clone_view()),
+                local_slot_lease: Mutex::new(None),
+                local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+            },
+        )))
     }
 
     pub(crate) fn acquire_external_pending_put_fence(
@@ -3184,7 +2999,7 @@ impl ClientKvApiInner {
                 },
             );
         }
-        self.owner_hot_track_committed(key, put_id, &memory_info, None);
+        self.owner_hot_track_committed(key, put_id, &memory_info);
         Ok(())
     }
 
@@ -3227,7 +3042,7 @@ impl ClientKvApiInner {
                 },
             );
         }
-        self.owner_hot_track_committed(key, put_id, &memory_info, None);
+        self.owner_hot_track_committed(key, put_id, &memory_info);
         true
     }
 
@@ -4020,23 +3835,21 @@ impl OwnerLocalReserveClassState {
 #[cfg(test)]
 mod owner_reclaim_slot_tests {
     use super::{
-        ExternalPendingPutCtx, ExternalPendingPutFenceGuard, OwnerHotCacheCounters,
-        OwnerHotCacheEntry, OwnerHotEvictionEvent, OwnerHotPinAlias, OwnerHotReplicaIdentity,
+        ExternalLocalFirstPutKeyReservation, ExternalPendingPutCtx, ExternalPendingPutFenceGuard,
+        ExternalPutKeyOutcome, ExternalPutKeySharedOp, OwnerHotCacheCounters, OwnerHotCacheEntry,
+        OwnerHotEvictionDispatch, OwnerHotEvictionEvent, OwnerHotPinAlias, OwnerHotReplicaIdentity,
         OwnerHotRetryQueue, OwnerHotSelectionDebt, OwnerHotSelectionFenceOutcome,
         OwnerKeyControlState, OwnerKeyControlTable, OwnerLocalReserveGrantState,
         OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, OwnerLocalReserveSlotState,
         OwnerReclaimRecord, acquire_external_pending_put_fence_for_key,
         allocate_external_holding_id, build_owner_hot_cache, clone_if_owner_hot_entry_matches,
-        forget_owner_hot_atomic_group, owner_hot_source_has_active_holders,
-        owner_hot_tp_atomic_batch_key_rows, pin_current_owner_hot_source_from_index,
-        register_owner_hot_atomic_group,
+        owner_hot_source_has_active_holders, pin_current_owner_hot_source_from_index,
     };
     use crate::master_kv_router::msg_pack::{
         BatchOwnerReclaimReq, OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimItemState,
-        OwnerReclaimPhase, OwnerReclaimReason, PutAtomicGroup, PutAtomicGroupMember,
+        OwnerReclaimPhase, OwnerReclaimReason, OwnerSourceEvictionVictim,
     };
     use crate::p2p::msg_pack::MsgPack;
-    use dashmap::DashMap;
     use parking_lot::Mutex;
     use std::sync::atomic::{AtomicU64, Ordering};
     use std::sync::{Arc, Weak};
@@ -4091,6 +3904,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 1,
                 external_pending_puts: 1,
+                external_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4100,6 +3914,8 @@ mod owner_reclaim_slot_tests {
             key: "local-key".to_string(),
             owner_key_control: controls.clone(),
             owns_local_put: true,
+            local_put_op: None,
+            local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
             local_slot_cleanup_view: None,
             local_slot_lease: Mutex::new(None),
             local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
@@ -4109,6 +3925,79 @@ mod owner_reclaim_slot_tests {
         assert!(controls.lock_key("local-key").get("local-key").is_none());
     }
 
+    #[limit_thirdparty::tokio::test]
+    async fn same_key_put_waiter_reuses_one_leader_terminal_result() {
+        let key = "put-singleflight";
+        let op = ExternalPutKeySharedOp::new();
+        let controls = controls_with_state(
+            key,
+            OwnerKeyControlState {
+                local_puts: 1,
+                external_pending_puts: 1,
+                external_put: Some(op.clone()),
+                source_eviction_selection: None,
+                reclaim: None,
+                external_get: None,
+            },
+        );
+        let leader = Arc::new(ExternalPendingPutFenceGuard {
+            key: key.to_string(),
+            owner_key_control: controls.clone(),
+            owns_local_put: true,
+            local_put_op: Some(op.clone()),
+            local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
+            local_slot_cleanup_view: None,
+            local_slot_lease: Mutex::new(None),
+            local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+        });
+
+        leader.mark_local_put_succeeded();
+        assert_eq!(
+            ::tokio::time::timeout(Duration::from_secs(1), op.wait())
+                .await
+                .expect("the follower must observe the leader terminal result"),
+            ExternalPutKeyOutcome::Succeeded
+        );
+        drop(leader);
+        assert!(controls.lock_key(key).get(key).is_none());
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn failed_put_leader_wakes_waiter_only_after_its_fence_is_released() {
+        let key = "put-singleflight-failed";
+        let op = ExternalPutKeySharedOp::new();
+        let controls = controls_with_state(
+            key,
+            OwnerKeyControlState {
+                local_puts: 1,
+                external_pending_puts: 1,
+                external_put: Some(op.clone()),
+                source_eviction_selection: None,
+                reclaim: None,
+                external_get: None,
+            },
+        );
+        let leader = Arc::new(ExternalPendingPutFenceGuard {
+            key: key.to_string(),
+            owner_key_control: controls.clone(),
+            owns_local_put: true,
+            local_put_op: Some(op.clone()),
+            local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
+            local_slot_cleanup_view: None,
+            local_slot_lease: Mutex::new(None),
+            local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
+        });
+
+        drop(leader);
+        assert_eq!(
+            ::tokio::time::timeout(Duration::from_secs(1), op.wait())
+                .await
+                .expect("the failed leader must wake its follower"),
+            ExternalPutKeyOutcome::Failed
+        );
+        assert!(controls.lock_key(key).get(key).is_none());
+    }
+
     #[test]
     fn failed_local_slot_release_keeps_key_fence_closed() {
         let controls = controls_with_state(
@@ -4116,6 +4005,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 1,
                 external_pending_puts: 1,
+                external_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4125,6 +4015,8 @@ mod owner_reclaim_slot_tests {
             key: "failed-slot".to_string(),
             owner_key_control: controls.clone(),
             owns_local_put: true,
+            local_put_op: None,
+            local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
             local_slot_cleanup_view: None,
             local_slot_lease: Mutex::new(None),
             local_slot_release_failed: std::sync::atomic::AtomicBool::new(true),
@@ -4143,6 +4035,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 1,
                 external_pending_puts: 1,
+                external_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4152,6 +4045,8 @@ mod owner_reclaim_slot_tests {
             key: "committed-slot".to_string(),
             owner_key_control: controls.clone(),
             owns_local_put: true,
+            local_put_op: None,
+            local_put_succeeded: std::sync::atomic::AtomicBool::new(false),
             local_slot_cleanup_view: None,
             local_slot_lease: Mutex::new(None),
             local_slot_release_failed: std::sync::atomic::AtomicBool::new(false),
@@ -4260,7 +4155,7 @@ mod owner_reclaim_slot_tests {
     }
 
     #[limit_thirdparty::tokio::test(flavor = "multi_thread", worker_threads = 8)]
-    async fn source_selection_fence_closes_late_get_and_rolls_back_whole_atomic_batch() {
+    async fn single_key_source_selection_fence_closes_late_get_and_rolls_back() {
         use crate::client_kv_api::PutOptionalArgs;
         use crate::kvcore_test_lib::{
             integration_test_lock, start_master_and_client, stop_master_and_client,
@@ -4274,85 +4169,90 @@ mod owner_reclaim_slot_tests {
         .await;
         let owner_view = client.client_kv_api_view();
         let inner = owner_view.client_kv_api().inner();
-        let keys = ["selection-rank0", "selection-rank1"];
-        for key in keys {
-            inner
-                .put(key, &[7u8; 4096], PutOptionalArgs::default())
-                .await
-                .expect("owner put must publish a committed route");
-            let (holder, _remote) = inner
-                .get(key)
-                .await
-                .expect("owner get must succeed")
-                .expect("committed route must be readable");
-            drop(holder);
-        }
+        let join_probe_leader = match inner
+            .reserve_external_local_first_put_key("put-join-probe", true, true)
+            .expect("the first same-key Put must become leader")
+        {
+            ExternalLocalFirstPutKeyReservation::Leader(leader) => leader,
+            ExternalLocalFirstPutKeyReservation::Wait(_) => {
+                panic!("the first same-key Put cannot be a follower")
+            }
+        };
+        let join_probe_waiter = match inner
+            .reserve_external_local_first_put_key("put-join-probe", true, true)
+            .expect("the second same-key Put must join the leader")
+        {
+            ExternalLocalFirstPutKeyReservation::Wait(waiter) => waiter,
+            ExternalLocalFirstPutKeyReservation::Leader(_) => {
+                panic!("the second same-key Put must not claim a second leader fence")
+            }
+        };
+        join_probe_leader.mark_local_put_succeeded();
+        assert_eq!(
+            join_probe_waiter.wait().await,
+            ExternalPutKeyOutcome::Succeeded
+        );
+        drop(join_probe_leader);
 
-        let sources = keys
-            .iter()
-            .map(|key| {
-                let cached = inner
-                    .get_cached_info
-                    .get(*key)
-                    .expect("committed owner source must be indexed");
-                (
-                    OwnerHotReplicaIdentity {
-                        key: (*key).to_string(),
-                        put_time_ms: cached.put_time_ms,
-                        put_version: cached.put_version,
-                    },
-                    cached.mem_holder.clone(),
-                )
-            })
-            .collect::<Vec<_>>();
+        let key = "selection-single";
+        inner
+            .put(key, &[7u8; 4096], PutOptionalArgs::default())
+            .await
+            .expect("owner put must publish a committed route");
+        let (holder, _remote) = inner
+            .get(key)
+            .await
+            .expect("owner get must succeed")
+            .expect("committed route must be readable");
+        drop(holder);
+
+        let cached = inner
+            .get_cached_info
+            .get(key)
+            .expect("committed owner source must be indexed");
+        let identity = OwnerHotReplicaIdentity {
+            key: key.to_string(),
+            put_time_ms: cached.put_time_ms,
+            put_version: cached.put_version,
+        };
+        let source = cached.mem_holder.clone();
+        drop(cached);
         assert!(
-            sources
-                .iter()
-                .all(|(_, source)| !owner_hot_source_has_active_holders(source)),
+            !owner_hot_source_has_active_holders(&source),
             "the initial victim check must see only index plus selection pins"
         );
 
-        // Reproduce the r11 TOCTOU exactly: a local Get acquires one atomic_batch
-        // member after the dispatcher's first holder check but before the
-        // source-selection fence is installed.
+        // Reproduce the r11 TOCTOU: a local Get acquires the single victim after
+        // the dispatcher's first holder check but before its fence is installed.
         let late_reader = inner
-            .local_visible_mem_holder(keys[1])
+            .local_visible_mem_holder(key)
             .expect("late local Get must acquire the source before fencing");
         assert!(matches!(
-            inner.owner_hot_install_source_selection_fences(&sources),
-            OwnerHotSelectionFenceOutcome::TemporarilyPinned { active_members: 1 }
+            inner.owner_hot_install_source_selection_fence(&identity, &source),
+            OwnerHotSelectionFenceOutcome::TemporarilyPinned
         ));
-        for key in keys {
-            assert!(inner.get_cached_info.contains_key(key));
-            assert!(
-                inner
-                    .owner_key_control
-                    .lock_key(key)
-                    .get(key)
-                    .is_none_or(|state| state.source_eviction_selection.is_none()),
-                "a pinned member must roll back every partial atomic_batch fence"
-            );
-        }
+        assert!(inner.get_cached_info.contains_key(key));
+        assert!(
+            inner
+                .owner_key_control
+                .lock_key(key)
+                .get(key)
+                .is_none_or(|state| state.source_eviction_selection.is_none()),
+            "a pinned victim must roll back its source fence"
+        );
 
         drop(late_reader);
         assert!(matches!(
-            inner.owner_hot_install_source_selection_fences(&sources),
+            inner.owner_hot_install_source_selection_fence(&identity, &source),
             OwnerHotSelectionFenceOutcome::Fenced
         ));
-        for key in keys {
-            assert!(!inner.get_cached_info.contains_key(key));
-            assert!(inner.local_visible_mem_holder(key).is_none());
-            assert!(
-                acquire_external_pending_put_fence_for_key(&inner.owner_key_control, key).is_err(),
-                "a new local Put must not cross a source-selection fence"
-            );
-        }
-
-        let identities = sources
-            .iter()
-            .map(|(identity, _)| identity.clone())
-            .collect::<Vec<_>>();
-        drop(sources);
+        assert!(!inner.get_cached_info.contains_key(key));
+        assert!(inner.local_visible_mem_holder(key).is_none());
+        assert!(
+            acquire_external_pending_put_fence_for_key(&inner.owner_key_control, key).is_err(),
+            "a new local Put must not cross a source-selection fence"
+        );
+        drop(source);
         let master_id = master
             .cluster_manager_view()
             .cluster_manager()
@@ -4360,11 +4260,8 @@ mod owner_reclaim_slot_tests {
             .id;
 
         let mismatched = OwnerReclaimItem {
-            key: identities[0].key.clone(),
-            put_id: (
-                identities[0].put_time_ms,
-                identities[0].put_version.wrapping_add(1),
-            ),
+            key: identity.key.clone(),
+            put_id: (identity.put_time_ms, identity.put_version.wrapping_add(1)),
             epoch: 90,
             backing: OwnerReclaimBacking::Allocation,
             reason: OwnerReclaimReason::OwnerCapacityEviction,
@@ -4388,29 +4285,25 @@ mod owner_reclaim_slot_tests {
         assert!(
             inner
                 .owner_key_control
-                .lock_key(&identities[0].key)
-                .get(&identities[0].key)
+                .lock_key(&identity.key)
+                .get(&identity.key)
                 .is_some_and(|state| state.source_eviction_selection.is_some()),
             "a mismatched Prepare must not consume the owner selection"
         );
 
-        let matching = identities
-            .iter()
-            .enumerate()
-            .map(|(index, identity)| OwnerReclaimItem {
-                key: identity.key.clone(),
-                put_id: (identity.put_time_ms, identity.put_version),
-                epoch: 100 + index as u64,
-                backing: OwnerReclaimBacking::Allocation,
-                reason: OwnerReclaimReason::OwnerCapacityEviction,
-            })
-            .collect::<Vec<_>>();
+        let matching = OwnerReclaimItem {
+            key: identity.key.clone(),
+            put_id: (identity.put_time_ms, identity.put_version),
+            epoch: 100,
+            backing: OwnerReclaimBacking::Allocation,
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
+        };
         let prepare_resp = super::reclaim::handle_batch_owner_reclaim(
             &owner_view,
             MsgPack {
                 serialize_part: BatchOwnerReclaimReq {
                     phase: OwnerReclaimPhase::Prepare,
-                    items: matching.clone(),
+                    items: vec![matching.clone()],
                 },
                 raw_bytes: Vec::new(),
             },
@@ -4418,84 +4311,94 @@ mod owner_reclaim_slot_tests {
         )
         .await;
         assert!(
-            prepare_resp
-                .serialize_part
-                .items
-                .iter()
-                .all(|item| item.state == OwnerReclaimItemState::Prepared),
-            "matching Prepare must atomically promote each selection into reclaim"
+            prepare_resp.serialize_part.items[0].state == OwnerReclaimItemState::Prepared,
+            "matching Prepare must promote the single selection into reclaim"
         );
-        for key in keys {
-            assert!(inner.local_visible_mem_holder(key).is_none());
-        }
+        assert!(inner.local_visible_mem_holder(key).is_none());
 
         let abort_resp = super::reclaim::handle_batch_owner_reclaim(
             &owner_view,
             MsgPack {
                 serialize_part: BatchOwnerReclaimReq {
                     phase: OwnerReclaimPhase::Abort,
-                    items: matching,
+                    items: vec![matching],
                 },
                 raw_bytes: Vec::new(),
             },
             master_id.into(),
         )
         .await;
+        assert!(abort_resp.serialize_part.items[0].state == OwnerReclaimItemState::Aborted);
         assert!(
-            abort_resp
-                .serialize_part
-                .items
-                .iter()
-                .all(|item| item.state == OwnerReclaimItemState::Aborted)
+            inner.local_visible_mem_holder(key).is_some(),
+            "Abort must restore the exact committed local index"
         );
-        for key in keys {
-            assert!(
-                inner.local_visible_mem_holder(key).is_some(),
-                "Abort must restore the exact committed local index"
-            );
-        }
 
-        let group = PutAtomicGroup {
-            members: identities
-                .iter()
-                .map(|identity| PutAtomicGroupMember {
-                    key: identity.key.clone(),
-                    put_id: (identity.put_time_ms, identity.put_version),
-                })
-                .collect(),
-        };
-        inner.owner_hot_register_atomic_group(&group);
         let trigger_weak = {
             let cached = inner
                 .get_cached_info
-                .get(&identities[0].key)
+                .get(key)
                 .expect("Abort-restored trigger must be indexed");
             Arc::downgrade(&cached.mem_holder)
         };
         let retry_event = OwnerHotEvictionEvent {
-            key: identities[0].key.clone(),
-            put_id: (identities[0].put_time_ms, identities[0].put_version),
+            key: identity.key.clone(),
+            put_id: (identity.put_time_ms, identity.put_version),
             memory_info: trigger_weak,
             selection_debt: OwnerHotSelectionDebt::new(
                 4096,
                 inner.owner_hot_counters.selection_debt_bytes.clone(),
             ),
             retry: true,
-            source_eviction_atomic_batch: None,
+            source_eviction_victim: None,
             retry_failures: 1,
         };
         match inner.owner_hot_prepare_eviction(&retry_event) {
-            super::OwnerHotEvictionPreparation::Ready { sources, .. } => {
-                assert_eq!(
-                    sources.len(),
-                    identities.len(),
-                    "a pre-selection retry must resolve the complete atomic atomic_batch"
-                );
+            super::OwnerHotEvictionPreparation::Ready { trigger, source } => {
+                assert_eq!(trigger, identity);
+                assert_eq!(source.key, key);
             }
-            _ => panic!("a pre-selection retry with a complete atomic_batch must be ready"),
+            _ => panic!("a current single-key retry must be ready"),
         }
         retry_event.selection_debt.release();
 
+        let cached = inner
+            .get_cached_info
+            .get(key)
+            .expect("the aborted source must still be locally indexed");
+        let source = cached.mem_holder.clone();
+        drop(cached);
+        assert!(matches!(
+            inner.owner_hot_install_source_selection_fence(&identity, &source),
+            OwnerHotSelectionFenceOutcome::Fenced
+        ));
+        drop(source);
+        assert!(
+            inner.owner_hot_install_source_selection_debt(
+                identity.clone(),
+                OwnerHotSelectionDebt::new(
+                    4096,
+                    inner.owner_hot_counters.selection_debt_bytes.clone(),
+                ),
+            )
+        );
+        super::reclaim::complete_owner_source_eviction(
+            inner,
+            &OwnerSourceEvictionVictim {
+                key: key.to_string(),
+                put_id: (identity.put_time_ms, identity.put_version),
+                backing: OwnerReclaimBacking::Allocation,
+            },
+            101,
+        )
+        .expect("one direct-delete response must release and finalize the local source");
+        assert!(inner.local_visible_mem_holder(key).is_none());
+        assert!(!inner.owner_source_eviction_selected.contains_key(&identity));
+        assert!(
+            inner.owner_key_control.lock_key(key).get(key).is_none(),
+            "direct local completion must clear the source fence in one call"
+        );
+
         stop_master_and_client(master, client).await;
     }
 
@@ -4559,7 +4462,7 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             selection_debt: debt,
             retry: true,
-            source_eviction_atomic_batch: None,
+            source_eviction_victim: None,
             retry_failures: 0,
         };
         retry_queue.schedule(event.clone(), "first failure");
@@ -4603,7 +4506,7 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             selection_debt: debt,
             retry: true,
-            source_eviction_atomic_batch: None,
+            source_eviction_victim: None,
             retry_failures: 0,
         };
 
@@ -4644,7 +4547,7 @@ mod owner_reclaim_slot_tests {
             memory_info: Weak::new(),
             selection_debt: remove_debt,
             retry: true,
-            source_eviction_atomic_batch: None,
+            source_eviction_victim: None,
             retry_failures: 0,
         };
         for _ in 0..CHURN {
@@ -4658,77 +4561,6 @@ mod owner_reclaim_slot_tests {
         assert_eq!(counters.selection_debt_bytes.load(Ordering::Acquire), 0);
     }
 
-    #[test]
-    fn hot_atomic_group_registry_interns_members_and_forgets_as_one_unit() {
-        let group = PutAtomicGroup {
-            members: vec![
-                PutAtomicGroupMember {
-                    key: "group-a".to_string(),
-                    put_id: (10, 1),
-                },
-                PutAtomicGroupMember {
-                    key: "group-b".to_string(),
-                    put_id: (10, 2),
-                },
-            ],
-        };
-        let atomic_groups = DashMap::new();
-        register_owner_hot_atomic_group(&atomic_groups, &group);
-        register_owner_hot_atomic_group(&atomic_groups, &group);
-        assert_eq!(atomic_groups.len(), 2);
-
-        let first = OwnerHotReplicaIdentity::from_group_member(&group.members[0]);
-        let second = OwnerHotReplicaIdentity::from_group_member(&group.members[1]);
-        let first_group = atomic_groups.get(&first).unwrap().value().clone();
-        let second_group = atomic_groups.get(&second).unwrap().value().clone();
-        assert!(Arc::ptr_eq(&first_group, &second_group));
-
-        forget_owner_hot_atomic_group(&atomic_groups, &second);
-        assert!(atomic_groups.is_empty());
-    }
-
-    #[test]
-    fn owner_hot_tp_atomic_batch_expands_the_same_group_boundary_across_ranks() {
-        let identity = OwnerHotReplicaIdentity {
-            key: "page0_model_0_2".to_string(),
-            put_time_ms: 10,
-            put_version: 1,
-        };
-        let rank0_group = PutAtomicGroup {
-            members: vec![
-                PutAtomicGroupMember {
-                    key: "page0_model_0_2".to_string(),
-                    put_id: (10, 1),
-                },
-                PutAtomicGroupMember {
-                    key: "page1_model_0_2".to_string(),
-                    put_id: (10, 2),
-                },
-            ],
-        };
-        assert_eq!(
-            owner_hot_tp_atomic_batch_key_rows(&identity, Some(&rank0_group)),
-            Ok(Some(vec![
-                vec!["page0_model_0_2".to_string(), "page1_model_0_2".to_string(),],
-                vec!["page0_model_1_2".to_string(), "page1_model_1_2".to_string(),],
-            ]))
-        );
-
-        let mixed_rank_group = PutAtomicGroup {
-            members: vec![
-                rank0_group.members[0].clone(),
-                PutAtomicGroupMember {
-                    key: "page1_model_1_2".to_string(),
-                    put_id: (11, 2),
-                },
-            ],
-        };
-        assert_eq!(
-            owner_hot_tp_atomic_batch_key_rows(&identity, Some(&mixed_rank_group)),
-            Err(())
-        );
-    }
-
     #[test]
     fn hot_cache_only_dispatches_size_removals_and_keeps_capacity() {
         let counters = Arc::new(OwnerHotCacheCounters::default());
@@ -4756,9 +4588,12 @@ mod owner_reclaim_slot_tests {
         cache.run_pending_tasks();
         assert!(counters.size_evictions.load(Ordering::Relaxed) >= 1);
         assert_eq!(cache.max_capacity(), Some(10));
-        let event = rx
+        let dispatch = rx
             .try_recv()
             .expect("the Moka listener must emit lightweight metadata without pinning");
+        let OwnerHotEvictionDispatch::Victim(event) = dispatch else {
+            panic!("the Moka listener must emit a victim event")
+        };
         assert!(event.memory_info.upgrade().is_none());
     }
 
@@ -4775,6 +4610,7 @@ mod owner_reclaim_slot_tests {
             OwnerKeyControlState {
                 local_puts: 0,
                 external_pending_puts: 0,
+                external_put: None,
                 source_eviction_selection: None,
                 reclaim: Some(OwnerReclaimRecord::Committed(OwnerReclaimItem {
                     key: "fenced".to_string(),
@@ -5241,14 +5077,13 @@ impl ClientKvApiInner {
                 .owner_hot_counters
                 .skipped_active_holders
                 .load(Ordering::Relaxed),
-            hot_group_registry_entries: self.owner_hot_atomic_groups.len() as u64,
-            hot_group_trigger_duplicates: self
+            hot_victim_duplicates: self
                 .owner_hot_counters
-                .group_trigger_duplicates
+                .victim_duplicates
                 .load(Ordering::Relaxed),
-            hot_group_trigger_incomplete: self
+            hot_victim_invalid_backing: self
                 .owner_hot_counters
-                .group_trigger_incomplete
+                .victim_invalid_backing
                 .load(Ordering::Relaxed),
             grouped_put_done_batches: self
                 .owner_hot_counters
@@ -5810,9 +5645,8 @@ impl ClientKvApi {
                                 skipped_stale = snapshot.hot_eviction_skipped_stale,
                                 skipped_reclaim = snapshot.hot_eviction_skipped_reclaim,
                                 skipped_active_holders = snapshot.hot_eviction_skipped_active_holders,
-                                group_registry_entries = snapshot.hot_group_registry_entries,
-                                group_trigger_duplicates = snapshot.hot_group_trigger_duplicates,
-                                group_trigger_incomplete = snapshot.hot_group_trigger_incomplete,
+                                victim_duplicates = snapshot.hot_victim_duplicates,
+                                victim_invalid_backing = snapshot.hot_victim_invalid_backing,
                                 grouped_put_done_batches = snapshot.grouped_put_done_batches,
                                 grouped_put_done_items = snapshot.grouped_put_done_items,
                                 legacy_put_done_batches = snapshot.legacy_put_done_batches,
@@ -5843,14 +5677,13 @@ impl ClientKvApi {
         // The Moka eviction listener is synchronous and must never block while
         // holding Moka's housekeeper lock. Events contain only weak payload
         // references and are deduplicated by exact selected identities, so use
-        // a lossless metadata channel instead of dropping atomic_batches when the old
+        // a lossless metadata channel instead of dropping victims when the old
         // bounded queue briefly filled under cache pressure.
         let (owner_hot_eviction_tx, owner_hot_eviction_rx) =
             tokio::sync::ampsc::unbounded_channel();
         let get_cached_info = Arc::new(DashMap::new());
         let owner_key_control = Arc::new(OwnerKeyControlTable::default());
         let owner_source_eviction_selected = Arc::new(DashMap::new());
-        let owner_hot_atomic_groups = Arc::new(DashMap::new());
         let owner_hot_counters = Arc::new(OwnerHotCacheCounters::default());
         let owner_hot_retry_queue = Arc::new(OwnerHotRetryQueue::new(owner_hot_counters.clone()));
         let owner_hot_cache = owner_hot_cache_capacity_bytes.map(|capacity_bytes| {
@@ -5882,7 +5715,6 @@ impl ClientKvApi {
             owner_key_control,
             owner_hot_cache,
             owner_source_eviction_selected,
-            owner_hot_atomic_groups,
             owner_hot_counters,
             owner_hot_retry_queue,
             owner_hot_eviction_tx,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index 862adab..8c70d68 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -1,10 +1,9 @@
 use super::{
-    ClientKvApiInner, OwnerHotEvictionEvent, OwnerHotEvictionPreparation, OwnerHotSelectionDebt,
+    ClientKvApiInner, OwnerHotEvictionEvent, OwnerHotEvictionPreparation,
     OwnerHotSelectionFenceOutcome, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
     OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef,
     ReplicaTaskJob, ReplicaTaskTarget,
     local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
-    owner_hot_weight_bytes,
 };
 use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
 use crate::cluster_manager::NodeIDString;
@@ -27,11 +26,12 @@ use crate::{
         BatchPutStartItemReq, BatchPutStartReq, BatchPutStartResp,
         BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
         EnqueueReplicaTaskItemResp, GroupedBatchPutDoneItemReq, GroupedBatchPutDoneReq,
-        GroupedBatchPutDoneResp, OwnerReclaimBacking, OwnerSourceEvictionAtomicBatch,
-        OwnerSourceEvictionMember, OwnerSourceEvictionOutcome, PutAppendDoneReq, PutAppendDoneResp,
-        PutAppendRevokeReq, PutAppendStartOutcome, PutAppendStartReq, PutAppendStartResp,
-        PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
+        GroupedBatchPutDoneResp, OwnerReclaimBacking, OwnerSourceEvictionOutcome,
+        OwnerSourceEvictionVictim, PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq,
+        PutAppendStartOutcome, PutAppendStartReq, PutAppendStartResp, PutAtomicGroup,
+        PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
         ReleaseLocalGrantReq, ReserveLocalGrantOutcome, ReserveLocalGrantReq,
+        owner_source_eviction_epoch,
     },
     memholder::{UserMemHolder, UserMemHolderExposeKind},
     p2p::msg_pack::MsgPack,
@@ -2225,12 +2225,12 @@ impl ClientKvApiInner {
 
     pub async fn batch_evict_owner_source(
         &self,
-        atomic_batches: Vec<OwnerSourceEvictionAtomicBatch>,
+        victims: Vec<OwnerSourceEvictionVictim>,
     ) -> KvResult<BatchEvictOwnerSourceResp> {
-        if atomic_batches.is_empty() {
+        if victims.is_empty() {
             return Ok(BatchEvictOwnerSourceResp {
                 operation_id: 0,
-                atomic_batches: Vec::new(),
+                victims: Vec::new(),
                 error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
                 error_json: String::new(),
             });
@@ -2248,7 +2248,7 @@ impl ClientKvApiInner {
             serialize_part: BatchEvictOwnerSourceReq {
                 operation_id,
                 owner_node_start_time: self_info.node_start_time,
-                atomic_batches,
+                victims,
             },
             raw_bytes: Vec::new(),
         };
@@ -2960,21 +2960,21 @@ async fn start_replica_append_with_retry(
 }
 
 fn owner_source_eviction_identity(
-    member: &OwnerSourceEvictionMember,
+    victim: &OwnerSourceEvictionVictim,
 ) -> super::OwnerHotReplicaIdentity {
     super::OwnerHotReplicaIdentity {
-        key: member.key.clone(),
-        put_time_ms: member.put_id.0,
-        put_version: member.put_id.1,
+        key: victim.key.clone(),
+        put_time_ms: victim.put_id.0,
+        put_version: victim.put_id.1,
     }
 }
 
-fn owner_source_eviction_member(
+fn owner_source_eviction_victim(
     identity: &super::OwnerHotReplicaIdentity,
     memory_info: &crate::memholder::MemoryInfo,
-) -> Option<OwnerSourceEvictionMember> {
+) -> Option<OwnerSourceEvictionVictim> {
     let (slot_size, grant_id, slot_index) = memory_info.local_reserve_resident_slot_ref()?;
-    Some(OwnerSourceEvictionMember {
+    Some(OwnerSourceEvictionVictim {
         key: identity.key.clone(),
         put_id: (identity.put_time_ms, identity.put_version),
         backing: OwnerReclaimBacking::CommittedSlot {
@@ -2987,55 +2987,49 @@ fn owner_source_eviction_member(
 
 fn finish_owner_source_selection(
     inner: &ClientKvApiInner,
-    atomic_batch: &OwnerSourceEvictionAtomicBatch,
+    victim: &OwnerSourceEvictionVictim,
     restore_current: bool,
     reason: &str,
 ) {
-    for member in &atomic_batch.members {
-        let identity = owner_source_eviction_identity(member);
-        if let Some(debt) = inner.owner_hot_remove_source_selection_debt(&identity) {
-            debt.release();
-            inner
-                .owner_hot_counters
-                .source_evict_restored_members
-                .fetch_add(1, Ordering::Relaxed);
-        }
-        inner.owner_hot_retry_queue.remove(&identity);
-        if !restore_current {
-            continue;
-        }
-        inner.owner_hot_restore_source_selection(&identity);
-        let group = inner
-            .owner_hot_atomic_groups
-            .get(&identity)
-            .map(|entry| entry.value().clone());
-        if inner.owner_hot_admit_published_committed(&member.key, member.put_id, group.as_deref()) {
-            tracing::warn!(
-                key = member.key,
-                put_time_ms = member.put_id.0,
-                put_version = member.put_id.1,
-                reason,
-                "restored current source to owner-hot after source eviction did not enter reclaim"
-            );
-        }
+    let identity = owner_source_eviction_identity(victim);
+    if let Some(debt) = inner.owner_hot_remove_source_selection_debt(&identity) {
+        debt.release();
+        inner
+            .owner_hot_counters
+            .source_evict_restored_members
+            .fetch_add(1, Ordering::Relaxed);
+    }
+    inner.owner_hot_retry_queue.remove(&identity);
+    if !restore_current {
+        return;
+    }
+    inner.owner_hot_restore_source_selection(&identity);
+    if inner.owner_hot_admit_published_committed(&victim.key, victim.put_id) {
+        tracing::warn!(
+            key = victim.key,
+            put_time_ms = victim.put_id.0,
+            put_version = victim.put_id.1,
+            reason,
+            "restored current source to owner-hot after source eviction did not enter reclaim"
+        );
     }
 }
 
 fn schedule_owner_source_eviction_retry(
     inner: &ClientKvApiInner,
     mut event: OwnerHotEvictionEvent,
-    atomic_batch: Arc<OwnerSourceEvictionAtomicBatch>,
+    victim: Arc<OwnerSourceEvictionVictim>,
     reason: &'static str,
 ) {
     event.retry = true;
-    event.source_eviction_atomic_batch = Some(atomic_batch);
+    event.source_eviction_victim = Some(victim);
     inner.owner_hot_retry_queue.schedule(event, reason);
 }
 
 fn prepare_owner_source_eviction_event(
     inner: &ClientKvApiInner,
     mut event: OwnerHotEvictionEvent,
-) -> Option<(OwnerHotEvictionEvent, Arc<OwnerSourceEvictionAtomicBatch>)> {
+) -> Option<(OwnerHotEvictionEvent, Arc<OwnerSourceEvictionVictim>)> {
     let trigger = super::OwnerHotReplicaIdentity {
         key: event.key.clone(),
         put_time_ms: event.put_id.0,
@@ -3045,22 +3039,15 @@ fn prepare_owner_source_eviction_event(
     if event.retry {
         let _ = inner.owner_hot_retry_queue.take_for_inflight(&trigger);
     }
-    if let Some(atomic_batch) = event.source_eviction_atomic_batch.clone() {
-        if atomic_batch.members.iter().all(|member| {
-            inner
-                .owner_source_eviction_selected
-                .contains_key(&owner_source_eviction_identity(member))
-        }) {
-            return Some((event, atomic_batch));
+    if let Some(victim) = event.source_eviction_victim.clone() {
+        if inner
+            .owner_source_eviction_selected
+            .contains_key(&owner_source_eviction_identity(&victim))
+        {
+            return Some((event, victim));
         }
-        // Commit/invalidation may win the race with a due retry. Any remaining
-        // selected members are restored rather than leaving false projected credit.
-        finish_owner_source_selection(
-            inner,
-            &atomic_batch,
-            true,
-            "retry atomic_batch lost selected identity",
-        );
+        // Commit/invalidation may win the race with a due retry.
+        finish_owner_source_selection(inner, &victim, true, "retry victim lost selected identity");
         event.selection_debt.release();
         return None;
     }
@@ -3069,13 +3056,13 @@ fn prepare_owner_source_eviction_event(
         event.selection_debt.release();
         inner
             .owner_hot_counters
-            .group_trigger_duplicates
+            .victim_duplicates
             .fetch_add(1, Ordering::Relaxed);
         return None;
     }
 
-    let (resolved_trigger, sources) = match inner.owner_hot_prepare_eviction(&event) {
-        OwnerHotEvictionPreparation::Ready { trigger, sources } => (trigger, sources),
+    let (resolved_trigger, source) = match inner.owner_hot_prepare_eviction(&event) {
+        OwnerHotEvictionPreparation::Ready { trigger, source } => (trigger, source),
         OwnerHotEvictionPreparation::RetryableReclaimFence => {
             inner.owner_hot_retry_queue.schedule(
                 event,
@@ -3083,39 +3070,24 @@ fn prepare_owner_source_eviction_event(
             );
             return None;
         }
-        OwnerHotEvictionPreparation::RetryableIncompleteAtomicBatch => {
-            inner
-                .owner_hot_retry_queue
-                .schedule(event, "owner source atomic_batch is temporarily incomplete");
-            return None;
-        }
-        OwnerHotEvictionPreparation::TemporarilyPinned { active_members } => {
-            // This event was removed from Moka, but its source atomic_batch is still
+        OwnerHotEvictionPreparation::TemporarilyPinned => {
+            // This event was removed from Moka, but its source is still
             // serving a local reader. Do not hand it to the master's reclaim
             // loop and do not retain projected selection credit. Re-admission
             // refreshes the trigger's recency so the next pressure kick can
             // choose a different, currently reclaimable victim.
             event.selection_debt.release();
-            inner.owner_hot_counters.skipped_active_holders.fetch_add(
-                u64::try_from(active_members).unwrap_or(u64::MAX),
-                Ordering::Relaxed,
-            );
-            let group = inner
-                .owner_hot_atomic_groups
-                .get(&trigger)
-                .map(|entry| entry.value().clone());
-            let restored = inner.owner_hot_admit_published_committed(
-                &event.key,
-                event.put_id,
-                group.as_deref(),
-            );
+            inner
+                .owner_hot_counters
+                .skipped_active_holders
+                .fetch_add(1, Ordering::Relaxed);
+            let restored = inner.owner_hot_admit_published_committed(&event.key, event.put_id);
             tracing::debug!(
                 key = event.key,
                 put_time_ms = event.put_id.0,
                 put_version = event.put_id.1,
-                active_members,
                 restored,
-                "owner pressure eviction skipped an actively held source atomic_batch"
+                "owner pressure eviction skipped an actively held source"
             );
             return None;
         }
@@ -3130,15 +3102,11 @@ fn prepare_owner_source_eviction_event(
     };
     debug_assert_eq!(resolved_trigger, trigger);
 
-    let members = sources
-        .iter()
-        .map(|(identity, memory_info)| owner_source_eviction_member(identity, memory_info.as_ref()))
-        .collect::<Option<Vec<_>>>();
-    let Some(members) = members else {
+    let Some(victim) = owner_source_eviction_victim(&trigger, source.as_ref()) else {
         event.selection_debt.release();
         inner
             .owner_hot_counters
-            .group_trigger_incomplete
+            .victim_invalid_backing
             .fetch_add(1, Ordering::Relaxed);
         tracing::error!(
             key = event.key,
@@ -3148,9 +3116,9 @@ fn prepare_owner_source_eviction_event(
         );
         return None;
     };
-    let atomic_batch = Arc::new(OwnerSourceEvictionAtomicBatch { members });
+    let victim = Arc::new(victim);
 
-    match inner.owner_hot_install_source_selection_fences(&sources) {
+    match inner.owner_hot_install_source_selection_fence(&trigger, &source) {
         OwnerHotSelectionFenceOutcome::Fenced => {}
         OwnerHotSelectionFenceOutcome::Retryable => {
             inner
@@ -3158,17 +3126,13 @@ fn prepare_owner_source_eviction_event(
                 .schedule(event, "owner source selection fence is temporarily busy");
             return None;
         }
-        OwnerHotSelectionFenceOutcome::TemporarilyPinned { active_members } => {
+        OwnerHotSelectionFenceOutcome::TemporarilyPinned => {
             event.selection_debt.release();
-            inner.owner_hot_counters.skipped_active_holders.fetch_add(
-                u64::try_from(active_members).unwrap_or(u64::MAX),
-                Ordering::Relaxed,
-            );
-            let group = inner
-                .owner_hot_atomic_groups
-                .get(&trigger)
-                .map(|entry| entry.value().clone());
-            inner.owner_hot_admit_published_committed(&event.key, event.put_id, group.as_deref());
+            inner
+                .owner_hot_counters
+                .skipped_active_holders
+                .fetch_add(1, Ordering::Relaxed);
+            inner.owner_hot_admit_published_committed(&event.key, event.put_id);
             return None;
         }
         OwnerHotSelectionFenceOutcome::Obsolete => {
@@ -3181,52 +3145,24 @@ fn prepare_owner_source_eviction_event(
         }
     }
 
-    if atomic_batch.members.iter().any(|member| {
-        inner
-            .owner_source_eviction_selected
-            .contains_key(&owner_source_eviction_identity(member))
-    }) {
-        for member in &atomic_batch.members {
-            inner.owner_hot_restore_source_selection(&owner_source_eviction_identity(member));
-        }
+    if inner.owner_source_eviction_selected.contains_key(&trigger) {
+        inner.owner_hot_restore_source_selection(&trigger);
         event.selection_debt.release();
         inner
             .owner_hot_counters
-            .group_trigger_duplicates
+            .victim_duplicates
             .fetch_add(1, Ordering::Relaxed);
         return None;
     }
 
-    let mut installed = Vec::with_capacity(atomic_batch.members.len());
-    for ((identity, memory_info), member) in sources.iter().zip(atomic_batch.members.iter()) {
-        debug_assert_eq!(identity, &owner_source_eviction_identity(member));
-        let debt = if identity == &trigger {
-            event.selection_debt.clone()
-        } else {
-            OwnerHotSelectionDebt::new(
-                u64::from(owner_hot_weight_bytes(memory_info.as_ref())),
-                inner.owner_hot_counters.selection_debt_bytes.clone(),
-            )
-        };
-        if !inner.owner_hot_install_source_selection_debt(identity.clone(), debt.clone()) {
-            debt.release();
-            for installed_identity in installed {
-                if let Some(installed_debt) =
-                    inner.owner_hot_remove_source_selection_debt(&installed_identity)
-                {
-                    installed_debt.release();
-                }
-            }
-            for member in &atomic_batch.members {
-                inner.owner_hot_restore_source_selection(&owner_source_eviction_identity(member));
-            }
-            event.selection_debt.release();
-            return None;
-        }
-        installed.push(identity.clone());
+    if !inner.owner_hot_install_source_selection_debt(trigger.clone(), event.selection_debt.clone())
+    {
+        inner.owner_hot_restore_source_selection(&trigger);
+        event.selection_debt.release();
+        return None;
     }
-    event.source_eviction_atomic_batch = Some(atomic_batch.clone());
-    Some((event, atomic_batch))
+    event.source_eviction_victim = Some(victim.clone());
+    Some((event, victim))
 }
 
 async fn process_owner_source_eviction_events(
@@ -3241,44 +3177,44 @@ async fn process_owner_source_eviction_events(
     if prepared.is_empty() {
         return;
     }
-    let atomic_batches = prepared
+    let victims = prepared
         .iter()
-        .map(|(_, atomic_batch)| atomic_batch.as_ref().clone())
+        .map(|(_, victim)| victim.as_ref().clone())
         .collect::<Vec<_>>();
-    let response = inner.batch_evict_owner_source(atomic_batches).await;
+    let response = inner.batch_evict_owner_source(victims).await;
     let Ok(response) = response else {
-        for (event, atomic_batch) in prepared {
+        for (event, victim) in prepared {
             schedule_owner_source_eviction_retry(
                 inner,
                 event,
-                atomic_batch,
+                victim,
                 "owner source-eviction RPC failed",
             );
         }
         return;
     };
-    if response.atomic_batches.len() != prepared.len() {
-        for (event, atomic_batch) in prepared {
+    if response.victims.len() != prepared.len() {
+        for (event, victim) in prepared {
             schedule_owner_source_eviction_retry(
                 inner,
                 event,
-                atomic_batch,
+                victim,
                 "owner source-eviction response length mismatch",
             );
         }
         return;
     }
 
-    for (index, ((event, atomic_batch), result)) in prepared
+    for (index, ((event, victim), result)) in prepared
         .into_iter()
-        .zip(response.atomic_batches.into_iter())
+        .zip(response.victims.into_iter())
         .enumerate()
     {
-        if result.atomic_batch_index != u32::try_from(index).unwrap_or(u32::MAX) {
+        if result.victim_index != u32::try_from(index).unwrap_or(u32::MAX) {
             schedule_owner_source_eviction_retry(
                 inner,
                 event,
-                atomic_batch,
+                victim,
                 "owner source-eviction response identity mismatch",
             );
             continue;
@@ -3289,45 +3225,63 @@ async fn process_owner_source_eviction_events(
                 inner
                     .owner_hot_counters
                     .source_evict_handoff_members
-                    .fetch_add(atomic_batch.members.len() as u64, Ordering::Relaxed);
+                    .fetch_add(1, Ordering::Relaxed);
                 // Selected debt stays live until owner reclaim Commit calls
-                // owner_hot_invalidate_version for every exact member.
+                // owner_hot_invalidate_version for the exact victim.
             }
             OwnerSourceEvictionOutcome::Completed => {
-                finish_owner_source_selection(
-                    inner,
-                    &atomic_batch,
-                    true,
-                    "master reported source deletion already completed",
-                );
+                let epoch = owner_source_eviction_epoch(response.operation_id, index);
+                match super::reclaim::complete_owner_source_eviction(inner, &victim, epoch) {
+                    Ok(()) => {
+                        inner
+                            .owner_hot_counters
+                            .source_evict_handoff_members
+                            .fetch_add(1, Ordering::Relaxed);
+                    }
+                    Err(detail) => {
+                        tracing::warn!(
+                            key = victim.key,
+                            put_time_ms = victim.put_id.0,
+                            put_version = victim.put_id.1,
+                            detail,
+                            "master deleted source route but owner slot release must retry"
+                        );
+                        schedule_owner_source_eviction_retry(
+                            inner,
+                            event,
+                            victim,
+                            "owner slot release after master direct-delete is temporarily busy",
+                        );
+                    }
+                }
             }
             OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified => {
                 schedule_owner_source_eviction_retry(
                     inner,
                     event,
-                    atomic_batch,
+                    victim,
                     "master source reclaim is temporarily busy",
                 );
             }
             OwnerSourceEvictionOutcome::Stale => {
                 finish_owner_source_selection(
                     inner,
-                    &atomic_batch,
+                    &victim,
                     true,
                     "master rejected stale source identity",
                 );
             }
             OwnerSourceEvictionOutcome::RejectedNotEvictable => {
                 tracing::error!(
-                    atomic_batch_members = atomic_batch.members.len(),
+                    key = victim.key,
                     detail = result.detail,
-                    "owner selected a source atomic_batch that master declared non-evictable"
+                    "owner selected a source victim that master declared non-evictable"
                 );
                 finish_owner_source_selection(
                     inner,
-                    &atomic_batch,
+                    &victim,
                     true,
-                    "master rejected non-evictable source atomic_batch",
+                    "master rejected non-evictable source victim",
                 );
             }
         }
@@ -3336,39 +3290,87 @@ async fn process_owner_source_eviction_events(
 
 pub fn spawn_owner_source_eviction_dispatcher(
     view: ClientKvApiView,
-    mut rx: tokio::sync::ampsc::UnboundedReceiver<OwnerHotEvictionEvent>,
+    mut rx: tokio::sync::ampsc::UnboundedReceiver<super::OwnerHotEvictionDispatch>,
 ) {
-    const MAX_ATOMIC_BATCHES_PER_RPC: usize = 128;
-    const MERGE_WINDOW: Duration = Duration::from_millis(2);
+    const ORPHAN_MERGE_WINDOW: Duration = Duration::from_millis(2);
 
     let view_task = view.clone();
     let _ = view.spawn("owner_source_eviction_dispatcher", async move {
         let mut shutdown_waiter = view_task.register_shutdown_waiter();
+        let mut events = Vec::new();
+        let mut pressure_open = false;
         loop {
-            let first = tokio::select! {
-                _ = shutdown_waiter.wait() => {
-                    tracing::info!("owner source-eviction dispatcher stopping due to shutdown");
-                    break;
+            let dispatch = if events.is_empty() || pressure_open {
+                tokio::select! {
+                    _ = shutdown_waiter.wait() => {
+                        tracing::info!("owner source-eviction dispatcher stopping due to shutdown");
+                        break;
+                    }
+                    dispatch = rx.recv() => dispatch,
+                }
+            } else {
+                tokio::select! {
+                    _ = shutdown_waiter.wait() => {
+                        tracing::info!("owner source-eviction dispatcher stopping due to shutdown");
+                        break;
+                    }
+                    dispatch = rx.recv() => dispatch,
+                    _ = tokio::time::sleep(ORPHAN_MERGE_WINDOW) => {
+                        process_owner_source_eviction_events(
+                            &view_task,
+                            std::mem::take(&mut events),
+                        )
+                        .await;
+                        continue;
+                    }
                 }
-                event = rx.recv() => {
-                    let Some(event) = event else { break; };
-                    event
+            };
+            let Some(dispatch) = dispatch else {
+                if !events.is_empty() {
+                    process_owner_source_eviction_events(&view_task, std::mem::take(&mut events))
+                        .await;
                 }
+                break;
             };
-            let mut events = Vec::with_capacity(MAX_ATOMIC_BATCHES_PER_RPC);
-            events.push(first);
-            let merge_window = tokio::time::sleep(MERGE_WINDOW);
-            tokio::pin!(merge_window);
-            while events.len() < MAX_ATOMIC_BATCHES_PER_RPC {
-                tokio::select! {
-                    _ = &mut merge_window => break,
-                    event = rx.recv() => {
-                        let Some(event) = event else { break; };
-                        events.push(event);
+            match dispatch {
+                super::OwnerHotEvictionDispatch::Victim(event) => events.push(event),
+                super::OwnerHotEvictionDispatch::BeginPressure { requested_bytes } => {
+                    if pressure_open {
+                        tracing::error!(
+                            requested_bytes,
+                            "nested owner pressure selection batch is not allowed"
+                        );
+                    }
+                    if !events.is_empty() {
+                        process_owner_source_eviction_events(
+                            &view_task,
+                            std::mem::take(&mut events),
+                        )
+                        .await;
+                    }
+                    pressure_open = true;
+                }
+                super::OwnerHotEvictionDispatch::EndPressure { selected_bytes } => {
+                    if !pressure_open {
+                        tracing::warn!(
+                            selected_bytes,
+                            "owner pressure selection ended without a matching begin marker"
+                        );
+                    }
+                    pressure_open = false;
+                    process_owner_source_eviction_events(&view_task, std::mem::take(&mut events))
+                        .await;
+                }
+                super::OwnerHotEvictionDispatch::Flush => {
+                    if !pressure_open && !events.is_empty() {
+                        process_owner_source_eviction_events(
+                            &view_task,
+                            std::mem::take(&mut events),
+                        )
+                        .await;
                     }
                 }
             }
-            process_owner_source_eviction_events(&view_task, events).await;
         }
     });
 }
@@ -3399,8 +3401,13 @@ pub fn spawn_owner_hot_retry_actor(view: ClientKvApiView) {
             }
             let inner = view_task.client_kv_api().inner();
             for event in events {
-                if let Err(err) = inner.owner_hot_eviction_tx.send(event) {
-                    let event = err.0;
+                if let Err(err) = inner
+                    .owner_hot_eviction_tx
+                    .send(super::OwnerHotEvictionDispatch::Victim(event))
+                {
+                    let super::OwnerHotEvictionDispatch::Victim(event) = err.0 else {
+                        unreachable!("the retry actor only sends victim events")
+                    };
                     retry_queue.schedule(event, "retry dispatcher closed");
                     return;
                 }
@@ -3409,6 +3416,13 @@ pub fn spawn_owner_hot_retry_actor(view: ClientKvApiView) {
                     .source_evict_retry_emitted
                     .fetch_add(1, Ordering::Relaxed);
             }
+            if inner
+                .owner_hot_eviction_tx
+                .send(super::OwnerHotEvictionDispatch::Flush)
+                .is_err()
+            {
+                return;
+            }
         }
     });
 }
@@ -4236,11 +4250,7 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
                 );
                 continue;
             }
-            let _ = inner.owner_hot_admit_published_committed(
-                &item.key,
-                item.put_id,
-                item.atomic_group.as_ref(),
-            );
+            let _ = inner.owner_hot_admit_published_committed(&item.key, item.put_id);
         }
 
         for item in promoted_items {
@@ -4264,6 +4274,10 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
                 }
             }
         }
+
+        for context in &job.external_pending_contexts {
+            context._pending_fence.mark_local_put_succeeded();
+        }
     }
 
     release_owner_local_publish_reservations(inner, job.key_reservation_ids).await;
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
index 0071968..97b36a0 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
@@ -2,7 +2,8 @@ use super::{ClientKvApiInner, ClientKvApiView, OwnerPreparedReclaim, OwnerReclai
 use crate::cluster_manager::{NodeID, NodeRole};
 use crate::master_kv_router::msg_pack::{
     BatchOwnerReclaimReq, BatchOwnerReclaimResp, OwnerReclaimBacking, OwnerReclaimItem,
-    OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase,
+    OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase, OwnerReclaimReason,
+    OwnerSourceEvictionVictim,
 };
 use crate::p2p::msg_pack::MsgPack;
 use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
@@ -391,6 +392,7 @@ mod tests {
         let state = OwnerKeyControlState {
             local_puts: 0,
             external_pending_puts: 0,
+            external_put: None,
             source_eviction_selection: None,
             reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
             external_get: Some(Arc::new(ExternalGetKeySharedOp::new(
@@ -402,6 +404,7 @@ mod tests {
         let local_put_state = OwnerKeyControlState {
             local_puts: 1,
             external_pending_puts: 0,
+            external_put: None,
             source_eviction_selection: None,
             reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
             external_get: state.external_get,
@@ -522,6 +525,41 @@ fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerRecla
     }
 }
 
+pub(crate) fn complete_owner_source_eviction(
+    inner: &ClientKvApiInner,
+    victim: &OwnerSourceEvictionVictim,
+    epoch: u64,
+) -> Result<(), String> {
+    let item = OwnerReclaimItem {
+        key: victim.key.clone(),
+        put_id: victim.put_id,
+        epoch,
+        backing: victim.backing.clone(),
+        reason: OwnerReclaimReason::OwnerCapacityEviction,
+    };
+    let prepared = prepare_one(inner, &item);
+    match prepared.state {
+        OwnerReclaimItemState::Prepared => {}
+        OwnerReclaimItemState::Committed => {
+            let finalized = finalize_one(inner, &item);
+            return (finalized.state == OwnerReclaimItemState::Finalized)
+                .then_some(())
+                .ok_or(finalized.detail);
+        }
+        OwnerReclaimItemState::Finalized => return Ok(()),
+        _ => return Err(prepared.detail),
+    }
+
+    let committed = commit_one(inner, &item);
+    if committed.state != OwnerReclaimItemState::Committed {
+        return Err(committed.detail);
+    }
+    let finalized = finalize_one(inner, &item);
+    (finalized.state == OwnerReclaimItemState::Finalized)
+        .then_some(())
+        .ok_or(finalized.detail)
+}
+
 pub async fn handle_batch_owner_reclaim(
     view: &ClientKvApiView,
     req: MsgPack<BatchOwnerReclaimReq>,
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index 2bc3846..3be65fe 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -26,10 +26,9 @@ use self::{
         BatchPutAppendStartReq, BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq,
         BatchReleasePutKeyReservationsReq, CountPrefixReq, CountPrefixResp, DeleteAckReq,
         DeleteReq, GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetRevokeReq,
-        GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimBacking, OwnerReclaimItem,
-        OwnerReclaimReason, PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq,
-        PutAtomicGroup, PutDoneReq, PutRevokeReq, PutStartReq, ReleaseLocalGrantReq,
-        ReserveLocalGrantReq,
+        GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimItem, PutAppendDoneReq,
+        PutAppendRevokeReq, PutAppendStartReq, PutAtomicGroup, PutDoneReq, PutRevokeReq,
+        PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq,
     },
     placement::{PlacementPolicy, build_placement_policy},
     put::{
@@ -299,7 +298,7 @@ pub struct ReplicaCacheNodeObserveSnapshot {
     pub reclaim_retry_restored: u64,
     pub reclaim_completed: u64,
     pub source_evict_rpc_requests: u64,
-    pub source_evict_atomic_batches: u64,
+    pub source_evict_victims: u64,
     pub source_evict_requested_bytes: u64,
     pub source_evict_accepted: u64,
     pub source_evict_in_progress: u64,
@@ -487,7 +486,7 @@ pub(crate) struct EvictionReclaimCounters {
     pub retry_restored: AtomicU64,
     pub completed: AtomicU64,
     pub source_evict_rpc_requests: AtomicU64,
-    pub source_evict_atomic_batches: AtomicU64,
+    pub source_evict_victims: AtomicU64,
     pub source_evict_requested_bytes: AtomicU64,
     pub source_evict_accepted: AtomicU64,
     pub source_evict_in_progress: AtomicU64,
@@ -505,7 +504,7 @@ pub(crate) struct EvictionReclaimCounters {
     /// More specific subset retained for diagnostics/backward-compatible
     /// metrics: the non-ring-B route used a CommittedSlot backing.
     pub capacity_eviction_hit_committed_slot: AtomicU64,
-    /// Duplicate listener/atomic_batch events suppressed while the same physical
+    /// Duplicate listener/victim events suppressed while the same physical
     /// cache version already has an outstanding reclaim lifecycle.
     pub eviction_reclaim_deduplicated: AtomicU64,
 }
@@ -1307,76 +1306,6 @@ async fn cleanup_departed_generation_routes(
     );
 }
 
-const MAX_INFERRED_TP_ATOMIC_BATCH_SIZE: usize = 256;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) struct InferredTpKey<'a> {
-    pub(crate) logical_prefix: &'a str,
-    pub(crate) rank: usize,
-    pub(crate) size: usize,
-}
-
-/// Decode the canonical SGLang HiCache suffix `_<tp_rank>_<tp_size>`.
-///
-/// This is deliberately strict and is only used to make owner reclaim more
-/// conservative. A key that cannot be decoded keeps the existing non-TP
-/// behavior; a decoded TP key whose peer routes are absent or inconsistent is
-/// never considered recoverable.
-pub(crate) fn infer_sglang_tp_key(key: &str) -> Option<InferredTpKey<'_>> {
-    let (before_size, raw_size) = key.rsplit_once('_')?;
-    let (logical_prefix, raw_rank) = before_size.rsplit_once('_')?;
-    if logical_prefix.is_empty()
-        || raw_rank.is_empty()
-        || raw_size.is_empty()
-        || !raw_rank.bytes().all(|byte| byte.is_ascii_digit())
-        || !raw_size.bytes().all(|byte| byte.is_ascii_digit())
-    {
-        return None;
-    }
-    let rank = raw_rank.parse::<usize>().ok()?;
-    let size = raw_size.parse::<usize>().ok()?;
-    if size == 0
-        || size > MAX_INFERRED_TP_ATOMIC_BATCH_SIZE
-        || rank >= size
-        || raw_rank != rank.to_string()
-        || raw_size != size.to_string()
-    {
-        return None;
-    }
-    Some(InferredTpKey {
-        logical_prefix,
-        rank,
-        size,
-    })
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum AtomicBatchExpansionError {
-    AtomicGroupIncomplete,
-    TpAtomicBatchIncomplete,
-}
-
-fn take_exact_cache_entries(
-    cache: &MasterNodeCache,
-    expected_entries: &HashMap<String, NodeValueReplicaDesc>,
-) -> Option<Vec<(String, NodeValueReplicaDesc)>> {
-    let mut removed_entries = Vec::with_capacity(expected_entries.len());
-    for (candidate_key, expected_desc) in expected_entries {
-        let removed = cache.take_if(candidate_key, |entry| {
-            entry.put_id == expected_desc.put_id && entry.weight_bytes == expected_desc.weight_bytes
-        });
-        if let Some(removed) = removed {
-            removed_entries.push((candidate_key.clone(), removed));
-        } else {
-            for (removed_key, removed_desc) in removed_entries {
-                insert_master_cache_entry(cache, removed_key, removed_desc);
-            }
-            return None;
-        }
-    }
-    Some(removed_entries)
-}
-
 fn remove_exact_cache_entry(
     cache: &MasterNodeCache,
     key: &str,
@@ -1394,72 +1323,11 @@ fn insert_master_cache_entry(cache: &MasterNodeCache, key: String, desc: NodeVal
     cache.insert(key, [alias], desc);
 }
 
-fn current_atomic_group_members(
-    key: &str,
-    route: &OneKvNodesRoutes,
-    desc: &NodeValueReplicaDesc,
-) -> Result<Vec<msg_pack::PutAtomicGroupMember>, AtomicBatchExpansionError> {
-    let Some(group) = route.atomic_group.as_ref() else {
-        return Ok(vec![msg_pack::PutAtomicGroupMember {
-            key: key.to_string(),
-            put_id: desc.put_id,
-        }]);
-    };
-    if !group
-        .members
-        .iter()
-        .any(|member| member.key == key && member.put_id == desc.put_id)
-    {
-        return Err(AtomicBatchExpansionError::AtomicGroupIncomplete);
-    }
-    Ok(group.members.clone())
-}
-
-fn current_tp_atomic_batch_keys(
-    key: &str,
-    route: &OneKvNodesRoutes,
-    desc: &NodeValueReplicaDesc,
-) -> Result<Vec<String>, AtomicBatchExpansionError> {
-    let current_members = current_atomic_group_members(key, route, desc)?;
-    let Some(key_tp) = infer_sglang_tp_key(key) else {
-        return Ok(current_members
-            .into_iter()
-            .map(|member| member.key)
-            .collect());
-    };
-    if key_tp.size == 1 {
-        return Ok(current_members
-            .into_iter()
-            .map(|member| member.key)
-            .collect());
-    }
-
-    let mut logical_members = Vec::with_capacity(current_members.len());
-    for member in current_members {
-        let Some(member_tp) = infer_sglang_tp_key(&member.key) else {
-            return Err(AtomicBatchExpansionError::TpAtomicBatchIncomplete);
-        };
-        if member_tp.rank != key_tp.rank || member_tp.size != key_tp.size {
-            return Err(AtomicBatchExpansionError::TpAtomicBatchIncomplete);
-        }
-        logical_members.push(member_tp.logical_prefix.to_string());
-    }
-
-    let mut atomic_batch_keys = Vec::with_capacity(logical_members.len() * key_tp.size);
-    for rank in 0..key_tp.size {
-        atomic_batch_keys.extend(
-            logical_members
-                .iter()
-                .map(|logical_prefix| format!("{logical_prefix}_{rank}_{}", key_tp.size)),
-        );
-    }
-    Ok(atomic_batch_keys)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::cluster_manager::ClusterMember;
+    use crate::master_kv_router::msg_pack::{OwnerReclaimBacking, OwnerReclaimReason};
     use std::collections::HashMap;
 
     #[test]
@@ -1965,90 +1833,6 @@ mod tests {
         assert!(!member_left_can_forward_to_registration_actor(Some(17)));
     }
 
-    #[test]
-    fn infer_sglang_tp_key_accepts_only_canonical_suffix() {
-        assert_eq!(
-            infer_sglang_tp_key("prefix:page_model_1_2"),
-            Some(InferredTpKey {
-                logical_prefix: "prefix:page_model",
-                rank: 1,
-                size: 2,
-            })
-        );
-        assert!(infer_sglang_tp_key("prefix:page_model_2_2").is_none());
-        assert!(infer_sglang_tp_key("prefix:page_model_01_2").is_none());
-        assert!(infer_sglang_tp_key("prefix:page_model_x_2").is_none());
-        assert!(infer_sglang_tp_key("prefix:page_model_0_0").is_none());
-    }
-
-    #[test]
-    fn tp_atomic_batch_expansion_preserves_every_atomic_member_across_ranks() {
-        let rank0_group = Arc::new(PutAtomicGroup {
-            members: vec![
-                msg_pack::PutAtomicGroupMember {
-                    key: "page0_model_0_2".to_string(),
-                    put_id: (10, 0),
-                },
-                msg_pack::PutAtomicGroupMember {
-                    key: "page1_model_0_2".to_string(),
-                    put_id: (10, 1),
-                },
-            ],
-        });
-        let mut rank0_page0 = test_route((10, 0), None, vec![("gpu0", false)]);
-        rank0_page0.atomic_group = Some(rank0_group);
-        let desc = NodeValueReplicaDesc {
-            weight_bytes: 1024,
-            put_id: (10, 0),
-        };
-        assert_eq!(
-            current_tp_atomic_batch_keys("page0_model_0_2", &rank0_page0, &desc).unwrap(),
-            vec![
-                "page0_model_0_2",
-                "page1_model_0_2",
-                "page0_model_1_2",
-                "page1_model_1_2",
-            ]
-        );
-    }
-
-    #[test]
-    fn exact_cache_detach_rolls_back_identity_mismatch() {
-        let cache = MasterNodeCache::builder(1024 * 1024)
-            .weigher(|_key: &String, desc: &NodeValueReplicaDesc| desc.weight_bytes)
-            .build();
-        let actual = HashMap::from([
-            (
-                "rank0".to_string(),
-                NodeValueReplicaDesc {
-                    weight_bytes: 1024,
-                    put_id: (30, 0),
-                },
-            ),
-            (
-                "rank1".to_string(),
-                NodeValueReplicaDesc {
-                    weight_bytes: 1024,
-                    put_id: (31, 0),
-                },
-            ),
-        ]);
-        for (key, desc) in &actual {
-            insert_master_cache_entry(&cache, key.clone(), desc.clone());
-        }
-        let mut stale_expected = actual.clone();
-        stale_expected.get_mut("rank1").unwrap().put_id = (999, 0);
-
-        assert!(take_exact_cache_entries(&cache, &stale_expected).is_none());
-        assert_eq!(cache.get(&"rank0".to_string()).unwrap().put_id, (30, 0));
-        assert_eq!(cache.get(&"rank1".to_string()).unwrap().put_id, (31, 0));
-
-        let removed = take_exact_cache_entries(&cache, &actual).unwrap();
-        assert_eq!(removed.len(), 2);
-        assert!(cache.get(&"rank0".to_string()).is_none());
-        assert!(cache.get(&"rank1".to_string()).is_none());
-    }
-
     #[test]
     fn ring_b_cache_is_bounded_for_every_node_role() {
         let cache = MasterNodeCache::builder(64)
@@ -2098,7 +1882,7 @@ mod tests {
     }
 
     #[test]
-    fn atomic_batch_reclaim_identity_registration_is_all_or_nothing() {
+    fn multi_identity_registration_rolls_back_partial_insert() {
         let request = |keys: &[&str]| reclaim::EvictionReclaimRequest {
             owner_node_id: "cpu0".to_string(),
             owner_node_start_time: None,
@@ -2130,7 +1914,7 @@ mod tests {
         );
 
         // `c` is tentatively installed before the collision on `a`; failure
-        // must roll it back and preserve only the original atomic_batch.
+        // must roll it back and preserve only the original request.
         let overlapping = reclaim::EvictionReclaimRequest {
             members: vec![
                 reclaim::EvictionReclaimMember {
@@ -2370,7 +2154,7 @@ pub struct MasterKvRouterInner {
     pub eviction_reclaim_pending_weight: DashMap<NodeIDString, Arc<AtomicU64>>,
 
     /// Exact, versioned metadata identities currently owned by the lossless
-    /// eviction-reclaim pipeline.  This bounds duplicate Size/atomic_batch events;
+    /// eviction-reclaim pipeline. This bounds duplicate Size/victim events;
     /// payload memory is not retained here.
     pub(crate) eviction_reclaim_inflight: DashSet<reclaim::EvictionReclaimIdentity>,
 
@@ -2382,7 +2166,7 @@ pub struct MasterKvRouterInner {
     /// Bounded maintenance can still process a batch of Size evictions; without
     /// this gate, concurrent async tasks can park multiple Tokio workers on the
     /// same blocking Moka lock. It is a scheduling gate, not a correctness or
-    /// atomic_batch lock, and no cache/global scan occurs under it.
+    /// request lock, and no cache/global scan occurs under it.
     pub(crate) owner_cache_operation_locks: AMapLock<String>,
 
     /// Historical final put placement decisions by target node.
@@ -3022,7 +2806,7 @@ impl MasterKvRouter {
         desc: NodeValueReplicaDesc,
         origin: reclaim::EvictionReclaimOrigin,
     ) -> bool {
-        self.enqueue_eviction_reclaim_atomic_batch(
+        self.enqueue_eviction_reclaim_request(
             owner_node_id,
             vec![reclaim::EvictionReclaimMember {
                 key,
@@ -3033,14 +2817,14 @@ impl MasterKvRouter {
         )
     }
 
-    fn enqueue_eviction_reclaim_atomic_batch(
+    fn enqueue_eviction_reclaim_request(
         &self,
         owner_node_id: NodeIDString,
         members: Vec<reclaim::EvictionReclaimMember>,
         origin: reclaim::EvictionReclaimOrigin,
     ) -> bool {
         matches!(
-            self.enqueue_eviction_reclaim_atomic_batch_exact(
+            self.enqueue_eviction_reclaim_request_exact(
                 owner_node_id,
                 None,
                 members,
@@ -3052,23 +2836,22 @@ impl MasterKvRouter {
         )
     }
 
-    pub(crate) fn enqueue_owner_capacity_eviction_atomic_batch(
+    pub(crate) fn enqueue_owner_capacity_eviction_victim(
         &self,
         owner_node_id: NodeIDString,
         owner_node_start_time: i64,
-        members: Vec<reclaim::EvictionReclaimMember>,
-        allow_new_request: bool,
+        victim: reclaim::EvictionReclaimMember,
     ) -> reclaim::EnqueueEvictionReclaimResult {
-        self.enqueue_eviction_reclaim_atomic_batch_exact(
+        self.enqueue_eviction_reclaim_request_exact(
             owner_node_id,
             Some(owner_node_start_time),
-            members,
+            vec![victim],
             reclaim::EvictionReclaimOrigin::OwnerCapacityEviction,
-            allow_new_request,
+            true,
         )
     }
 
-    fn enqueue_eviction_reclaim_atomic_batch_exact(
+    fn enqueue_eviction_reclaim_request_exact(
         &self,
         owner_node_id: NodeIDString,
         owner_node_start_time: Option<i64>,
@@ -3076,7 +2859,7 @@ impl MasterKvRouter {
         origin: reclaim::EvictionReclaimOrigin,
         allow_new_request: bool,
     ) -> reclaim::EnqueueEvictionReclaimResult {
-        if members.is_empty() {
+        if members.len() != 1 {
             return reclaim::EnqueueEvictionReclaimResult::PartialOverlap;
         }
         let request = reclaim::EvictionReclaimRequest {
@@ -3097,9 +2880,8 @@ impl MasterKvRouter {
             self.eviction_reclaim_counters(&request.owner_node_id)
                 .eviction_reclaim_deduplicated
                 .fetch_add(1, Ordering::Relaxed);
-            // An idempotent retry is accepted only when the complete atomic_batch
-            // is already owned by the pipeline. A partial overlap is not a
-            // valid source handoff.
+            // An idempotent retry is accepted only when the exact victim is
+            // already owned by the pipeline.
             return if request
                 .identities()
                 .iter()
@@ -4663,7 +4445,7 @@ impl MasterKvRouter {
                                 if cause == RemovalCause::Size {
                                     // Listener work is deliberately O(1):
                                     // clone fixed metadata, dedupe, and send
-                                    // to a lossless channel.  Route/atomic_batch
+                                    // to a lossless channel. Route/victim
                                     // lookup belongs to the async actor.
                                     let _ = view.master_kv_router().enqueue_eviction_reclaim(
                                         cache_node_id.clone(),
@@ -5239,8 +5021,8 @@ impl MasterKvRouter {
                 source_evict_rpc_requests: reclaim_counters
                     .source_evict_rpc_requests
                     .load(Ordering::Relaxed),
-                source_evict_atomic_batches: reclaim_counters
-                    .source_evict_atomic_batches
+                source_evict_victims: reclaim_counters
+                    .source_evict_victims
                     .load(Ordering::Relaxed),
                 source_evict_requested_bytes: reclaim_counters
                     .source_evict_requested_bytes
@@ -5313,7 +5095,7 @@ impl MasterKvRouter {
                         );
                         for node in snapshot.replica_cache_nodes {
                             tracing::info!(
-                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_atomic_batches={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} last_route_removed_members={} last_route_removed_bytes={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
+                                "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_victims={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} last_route_removed_members={} last_route_removed_bytes={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
                                 node.owner_node,
                                 node.entries,
                                 node.weighted_bytes,
@@ -5336,7 +5118,7 @@ impl MasterKvRouter {
                                 node.reclaim_retry_restored,
                                 node.reclaim_completed,
                                 node.source_evict_rpc_requests,
-                                node.source_evict_atomic_batches,
+                                node.source_evict_victims,
                                 node.source_evict_requested_bytes,
                                 node.source_evict_accepted,
                                 node.source_evict_in_progress,
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index 6b23403..da9b0b8 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -364,16 +364,16 @@ pub enum OwnerReclaimReason {
 
 /// One exact owner-local source selected for capacity eviction.
 #[derive(Default, Debug, Clone, Hash, PartialEq, Eq, Encode, Decode)]
-pub struct OwnerSourceEvictionMember {
+pub struct OwnerSourceEvictionVictim {
     pub key: String,
     pub put_id: PutIDForAKey,
     pub backing: OwnerReclaimBacking,
 }
 
-/// Atomic/TP members which must enter the reclaim pipeline together.
-#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
-pub struct OwnerSourceEvictionAtomicBatch {
-    pub members: Vec<OwnerSourceEvictionMember>,
+pub(crate) fn owner_source_eviction_epoch(operation_id: u64, victim_index: usize) -> u64 {
+    operation_id
+        .rotate_left(32)
+        .wrapping_add(u64::try_from(victim_index).unwrap_or(u64::MAX))
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
@@ -381,7 +381,7 @@ pub struct BatchEvictOwnerSourceReq {
     pub operation_id: u64,
     /// Membership generation of the authenticated source owner.
     pub owner_node_start_time: i64,
-    pub atomic_batches: Vec<OwnerSourceEvictionAtomicBatch>,
+    pub victims: Vec<OwnerSourceEvictionVictim>,
 }
 
 impl MsgPackSerializePart for BatchEvictOwnerSourceReq {
@@ -403,8 +403,8 @@ pub enum OwnerSourceEvictionOutcome {
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
-pub struct OwnerSourceEvictionAtomicBatchResp {
-    pub atomic_batch_index: u32,
+pub struct OwnerSourceEvictionVictimResp {
+    pub victim_index: u32,
     pub outcome: OwnerSourceEvictionOutcome,
     pub detail: String,
 }
@@ -412,7 +412,7 @@ pub struct OwnerSourceEvictionAtomicBatchResp {
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct BatchEvictOwnerSourceResp {
     pub operation_id: u64,
-    pub atomic_batches: Vec<OwnerSourceEvictionAtomicBatchResp>,
+    pub victims: Vec<OwnerSourceEvictionVictimResp>,
     pub error_code: ErrorCode,
     pub error_json: String,
 }
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
index e2c8d01..22f7df6 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
@@ -3,8 +3,8 @@ use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::master_kv_router::msg_pack::{
     BatchEvictOwnerSourceReq, BatchEvictOwnerSourceResp, BatchOwnerReclaimReq, OwnerReclaimBacking,
     OwnerReclaimItem, OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase,
-    OwnerReclaimReason, OwnerSourceEvictionAtomicBatch, OwnerSourceEvictionAtomicBatchResp,
-    OwnerSourceEvictionOutcome,
+    OwnerReclaimReason, OwnerSourceEvictionOutcome, OwnerSourceEvictionVictim,
+    OwnerSourceEvictionVictimResp, owner_source_eviction_epoch,
 };
 use crate::p2p::msg_pack::{MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, RPCCaller};
 use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
@@ -66,10 +66,10 @@ mod timeout_contract_tests {
 }
 
 #[cfg(test)]
-mod atomic_batch_transaction_tests {
+mod single_victim_transaction_tests {
     use super::*;
     use crate::master_kv_router::msg_pack::{
-        OwnerSourceEvictionMember, PutAtomicGroup, PutAtomicGroupMember,
+        OwnerSourceEvictionVictim, PutAtomicGroup, PutAtomicGroupMember,
     };
     use crate::master_kv_router::{
         CommittedSlotReplica, KvRouteInfo, MasterKeyActivityKind, MasterKeyActivityTable,
@@ -79,7 +79,7 @@ mod atomic_batch_transaction_tests {
     use parking_lot::RwLock;
     use std::collections::HashMap;
     use std::sync::Arc;
-    use std::sync::atomic::AtomicU32;
+    use std::sync::atomic::{AtomicBool, AtomicU32};
 
     fn item(key: &str, epoch: u64) -> OwnerReclaimItem {
         OwnerReclaimItem {
@@ -96,26 +96,24 @@ mod atomic_batch_transaction_tests {
     }
 
     #[test]
-    fn atomic_batch_master_fences_roll_back_all_members_when_one_is_busy() {
+    fn single_victim_master_fence_rejects_a_busy_key() {
         let activity = Arc::new(MasterKeyActivityTable::default());
-        let items = vec![item("rank0", 1), item("rank1", 2)];
+        let items = vec![item("victim", 1)];
         let _busy = activity
-            .reserve("rank1", MasterKeyActivityKind::Get, false)
+            .reserve("victim", MasterKeyActivityKind::Get, false)
             .unwrap();
 
-        assert!(try_install_atomic_batch_master_fences(&activity, &items).is_err());
-        assert!(!activity.has_reclaim("rank0"));
-        assert!(!activity.has_reclaim("rank1"));
+        assert!(try_install_master_fences(&activity, &items).is_err());
+        assert!(!activity.has_reclaim("victim"));
     }
 
     #[test]
-    fn atomic_batch_master_fences_install_and_clear_as_one_set() {
+    fn single_victim_master_fence_installs_and_clears() {
         let activity = Arc::new(MasterKeyActivityTable::default());
-        let items = vec![item("rank0", 1), item("rank1", 2)];
+        let items = vec![item("victim", 1)];
 
-        try_install_atomic_batch_master_fences(&activity, &items).unwrap();
-        assert!(activity.has_reclaim("rank0"));
-        assert!(activity.has_reclaim("rank1"));
+        try_install_master_fences(&activity, &items).unwrap();
+        assert!(activity.has_reclaim("victim"));
         for item in &items {
             assert!(activity.clear_reclaim(item));
         }
@@ -138,13 +136,13 @@ mod atomic_batch_transaction_tests {
         );
     }
 
-    fn source_member(
+    fn source_victim(
         key: &str,
         put_id: (u64, u32),
         grant_id: u64,
         slot_index: u32,
-    ) -> OwnerSourceEvictionMember {
-        OwnerSourceEvictionMember {
+    ) -> OwnerSourceEvictionVictim {
+        OwnerSourceEvictionVictim {
             key: key.to_string(),
             put_id,
             backing: OwnerReclaimBacking::CommittedSlot {
@@ -157,7 +155,7 @@ mod atomic_batch_transaction_tests {
 
     fn source_route(
         owner: &NodeID,
-        member: &OwnerSourceEvictionMember,
+        member: &OwnerSourceEvictionVictim,
         atomic_group: Option<Arc<PutAtomicGroup>>,
         include_cpu_replica: bool,
     ) -> Arc<OneKvNodesRoutes> {
@@ -217,7 +215,7 @@ mod atomic_batch_transaction_tests {
         })
     }
 
-    fn source_reclaim_item(member: &OwnerSourceEvictionMember) -> OwnerReclaimItem {
+    fn source_reclaim_item(member: &OwnerSourceEvictionVictim) -> OwnerReclaimItem {
         OwnerReclaimItem {
             key: member.key.clone(),
             put_id: member.put_id,
@@ -230,25 +228,17 @@ mod atomic_batch_transaction_tests {
     #[test]
     fn exact_source_plan_accepts_with_or_without_a_cpu_replica() {
         let owner: NodeID = "gpu0".to_string().into();
-        let member = source_member("single", (10, 1), 7, 3);
-        let atomic_batch = OwnerSourceEvictionAtomicBatch {
-            members: vec![member.clone()],
-        };
+        let member = source_victim("single", (10, 1), 7, 3);
 
         for include_cpu_replica in [false, true] {
             let route = source_route(&owner, &member, None, include_cpu_replica);
-            let plan = plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| {
+            let plan = plan_exact_owner_source_victim_with(&owner, &member, &|key| {
                 (key == "single").then(|| route.clone())
             });
             match plan {
-                OwnerSourceAtomicBatchPlan::Ready {
-                    members,
-                    all_sources_present,
-                } => {
-                    assert!(all_sources_present);
-                    assert_eq!(members.len(), 1);
-                    assert_eq!(members[0].key, "single");
-                    assert_eq!(members[0].expected_backing, Some(member.backing.clone()));
+                OwnerSourceVictimPlan::Ready(planned) => {
+                    assert_eq!(planned.key, "single");
+                    assert_eq!(planned.expected_backing, Some(member.backing.clone()));
                 }
                 _ => panic!("exact current owner source must be accepted"),
             }
@@ -258,7 +248,7 @@ mod atomic_batch_transaction_tests {
     #[test]
     fn exact_source_removal_deletes_only_gpu_when_cpu_exists_and_last_route_otherwise() {
         let owner: NodeID = "gpu0".to_string().into();
-        let member = source_member("with-cpu", (10, 2), 7, 4);
+        let member = source_victim("with-cpu", (10, 2), 7, 4);
         let routes = dashmap::DashMap::new();
         routes.insert(
             member.key.clone(),
@@ -279,7 +269,7 @@ mod atomic_batch_transaction_tests {
         assert!(!remaining.nodes_replicas.read().contains_key(&owner));
         assert!(remaining.nodes_replicas.read().contains_key("cpu0"));
 
-        let last = source_member("last", (10, 3), 7, 5);
+        let last = source_victim("last", (10, 3), 7, 5);
         routes.insert(last.key.clone(), source_route(&owner, &last, None, false));
         let removed = remove_exact_owner_source_route(&routes, &owner, &source_reclaim_item(&last))
             .expect("last exact GPU source must be removed");
@@ -295,9 +285,9 @@ mod atomic_batch_transaction_tests {
             removed.capacity_bytes
         );
 
-        let stale = source_member("stale", (10, 4), 8, 6);
+        let stale = source_victim("stale", (10, 4), 8, 6);
         routes.insert(stale.key.clone(), source_route(&owner, &stale, None, false));
-        let wrong_identity = source_member("stale", stale.put_id, 999, 6);
+        let wrong_identity = source_victim("stale", stale.put_id, 999, 6);
         assert!(
             remove_exact_owner_source_route(
                 &routes,
@@ -310,13 +300,10 @@ mod atomic_batch_transaction_tests {
     }
 
     #[test]
-    fn partial_source_absence_is_replay_only_and_all_absent_is_completed() {
+    fn singleton_source_is_independent_of_atomic_group_siblings() {
         let owner: NodeID = "gpu0".to_string().into();
-        let a = source_member("a", (11, 0), 8, 0);
-        let b = source_member("b", (11, 1), 8, 1);
-        let atomic_batch = OwnerSourceEvictionAtomicBatch {
-            members: vec![a.clone(), b.clone()],
-        };
+        let a = source_victim("a", (12, 0), 9, 0);
+        let b = source_victim("b", (12, 1), 9, 1);
         let group = Arc::new(PutAtomicGroup {
             members: vec![
                 PutAtomicGroupMember {
@@ -329,71 +316,100 @@ mod atomic_batch_transaction_tests {
                 },
             ],
         });
-        let route_a = source_route(&owner, &a, Some(group), false);
-
-        match plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| {
+        let route_a = source_route(&owner, &a, Some(group.clone()), false);
+        match plan_exact_owner_source_victim_with(&owner, &a, &|key| {
             (key == "a").then(|| route_a.clone())
         }) {
-            OwnerSourceAtomicBatchPlan::Ready {
-                all_sources_present,
-                ..
-            } => assert!(!all_sources_present),
-            _ => panic!(
-                "a partially removed accepted atomic_batch must be recognized as replay-only"
-            ),
+            OwnerSourceVictimPlan::Ready(planned) => assert_eq!(planned.key, "a"),
+            _ => panic!("one current key must be reclaimable without its siblings"),
         }
+
+        let changed_a = source_victim("a", a.put_id, 99, 0);
+        let changed_route = source_route(&owner, &changed_a, Some(group), false);
         assert!(matches!(
-            plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|_| None),
-            OwnerSourceAtomicBatchPlan::Completed(_)
+            plan_exact_owner_source_victim_with(&owner, &a, &|key| {
+                (key == "a").then(|| changed_route.clone())
+            }),
+            OwnerSourceVictimPlan::Stale(_)
         ));
     }
 
     #[test]
-    fn one_stale_or_inconsistent_member_rejects_the_whole_source_atomic_batch() {
+    fn absent_single_source_is_already_completed() {
         let owner: NodeID = "gpu0".to_string().into();
-        let a = source_member("a", (12, 0), 9, 0);
-        let b = source_member("b", (12, 1), 9, 1);
-        let atomic_batch = OwnerSourceEvictionAtomicBatch {
-            members: vec![a.clone(), b.clone()],
-        };
-        let group = Arc::new(PutAtomicGroup {
-            members: vec![
-                PutAtomicGroupMember {
-                    key: a.key.clone(),
-                    put_id: a.put_id,
-                },
-                PutAtomicGroupMember {
-                    key: b.key.clone(),
-                    put_id: b.put_id,
-                },
-            ],
-        });
-        let route_a = source_route(&owner, &a, Some(group.clone()), false);
-        let changed_b = source_member("b", b.put_id, 99, 1);
-        let route_b_with_changed_backing =
-            source_route(&owner, &changed_b, Some(group.clone()), false);
-        let stale_backing_plan =
-            plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| match key {
-                "a" => Some(route_a.clone()),
-                "b" => Some(route_b_with_changed_backing.clone()),
-                _ => None,
-            });
+        let victim = source_victim("gone", (13, 0), 10, 0);
         assert!(matches!(
-            stale_backing_plan,
-            OwnerSourceAtomicBatchPlan::Stale(_)
+            plan_exact_owner_source_victim_with(&owner, &victim, &|_| None),
+            OwnerSourceVictimPlan::Completed(_)
         ));
+    }
 
-        let route_b_without_group = source_route(&owner, &b, None, false);
-        let inconsistent_group_plan =
-            plan_exact_owner_source_atomic_batch_with(&owner, &atomic_batch, &|key| match key {
-                "a" => Some(route_a.clone()),
-                "b" => Some(route_b_without_group.clone()),
-                _ => None,
-            });
-        assert!(matches!(
-            inconsistent_group_plan,
-            OwnerSourceAtomicBatchPlan::Rejected(_)
-        ));
+    #[test]
+    fn direct_delete_batch_keeps_results_independent_and_replay_idempotent() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let ready = source_victim("ready", (14, 0), 11, 0);
+        let busy = source_victim("busy", (14, 1), 11, 1);
+        let stale = source_victim("stale", (14, 2), 11, 2);
+        let routes = dashmap::DashMap::new();
+        for victim in [&ready, &busy, &stale] {
+            routes.insert(
+                victim.key.clone(),
+                source_route(&owner, victim, None, false),
+            );
+        }
+        let activity = Arc::new(MasterKeyActivityTable::default());
+        let _busy_get = activity
+            .reserve(&busy.key, MasterKeyActivityKind::Get, false)
+            .expect("busy victim must hold a master Get lease");
+        let stale_request = source_victim("stale", stale.put_id, 999, 2);
+        let victims = vec![ready.clone(), busy.clone(), stale_request];
+        let responses = direct_delete_exact_owner_source_batch_with(
+            activity.as_ref(),
+            &owner,
+            77,
+            &victims,
+            &|key| routes.get(key).map(|route| route.clone()),
+            |item| remove_exact_owner_source_route(&routes, &owner, item).is_some(),
+        );
+
+        assert_eq!(
+            responses
+                .iter()
+                .map(|response| response.outcome)
+                .collect::<Vec<_>>(),
+            vec![
+                OwnerSourceEvictionOutcome::Completed,
+                OwnerSourceEvictionOutcome::RetryableBusy,
+                OwnerSourceEvictionOutcome::Stale,
+            ]
+        );
+        assert_eq!(
+            responses
+                .iter()
+                .map(|response| response.victim_index)
+                .collect::<Vec<_>>(),
+            vec![0, 1, 2],
+            "one batch response vector must stay aligned with every input victim"
+        );
+        assert!(!routes.contains_key(&ready.key));
+        assert!(routes.contains_key(&busy.key));
+        assert!(routes.contains_key(&stale.key));
+        assert!(!activity.has_reclaim(&ready.key));
+
+        let replay_delete_called = AtomicBool::new(false);
+        let replay = direct_delete_exact_owner_source_with(
+            activity.as_ref(),
+            &owner,
+            &ready,
+            owner_source_eviction_epoch(77, 0),
+            &|key| routes.get(key).map(|route| route.clone()),
+            |_| {
+                replay_delete_called.store(true, Ordering::Relaxed);
+                false
+            },
+        );
+        assert_eq!(replay.0, OwnerSourceEvictionOutcome::Completed);
+        assert!(!replay_delete_called.load(Ordering::Relaxed));
     }
 }
 
@@ -469,7 +485,6 @@ impl EvictionReclaimRequest {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum MasterCapacityPlanError {
     RouteChanged,
-    InvalidAtomicBatch,
     WrongRole,
     CommittedSlot,
 }
@@ -529,84 +544,25 @@ fn allocation_member_from_route(
     ))
 }
 
-/// Expand one master Size event by point-looking up its atomic/TP atomic_batch.
-/// This function never iterates the resident cache or global route table.
-fn plan_master_allocation_capacity_atomic_batch(
+/// Validate one exact key popped by the master Allocation Moka.
+fn plan_master_allocation_capacity_victim(
     view: &MasterKvRouterView,
     request: &EvictionReclaimRequest,
-) -> Result<Vec<EvictionReclaimMember>, MasterCapacityPlanError> {
+) -> Result<EvictionReclaimMember, MasterCapacityPlanError> {
     if request.origin != EvictionReclaimOrigin::MasterAllocationCapacity
-        || request.members.is_empty()
+        || request.members.len() != 1
     {
         return Err(MasterCapacityPlanError::WrongRole);
     }
     let owner: NodeID = request.owner_node_id.clone().into();
     let anchor = &request.members[0];
-    let (current_anchor, anchor_route) = allocation_member_from_route(view, &owner, &anchor.key)?;
+    let (current_anchor, _route) = allocation_member_from_route(view, &owner, &anchor.key)?;
     if current_anchor.desc.put_id != anchor.desc.put_id
         || current_anchor.desc.weight_bytes != anchor.desc.weight_bytes
     {
         return Err(MasterCapacityPlanError::RouteChanged);
     }
-    let mut atomic_batch_keys =
-        super::current_tp_atomic_batch_keys(&anchor.key, &anchor_route, &current_anchor.desc)
-            .map_err(|_| MasterCapacityPlanError::InvalidAtomicBatch)?;
-    atomic_batch_keys.sort_unstable();
-    atomic_batch_keys.dedup();
-    if atomic_batch_keys.is_empty() {
-        return Err(MasterCapacityPlanError::InvalidAtomicBatch);
-    }
-
-    let mut members = Vec::with_capacity(atomic_batch_keys.len());
-    for key in &atomic_batch_keys {
-        let (member, route) = allocation_member_from_route(view, &owner, key)?;
-        let mut peer_keys = super::current_tp_atomic_batch_keys(key, &route, &member.desc)
-            .map_err(|_| MasterCapacityPlanError::InvalidAtomicBatch)?;
-        peer_keys.sort_unstable();
-        peer_keys.dedup();
-        if peer_keys != atomic_batch_keys {
-            return Err(MasterCapacityPlanError::InvalidAtomicBatch);
-        }
-        members.push(member);
-    }
-    Ok(members)
-}
-
-fn detach_present_capacity_atomic_batch_siblings(
-    view: &MasterKvRouterView,
-    owner_node_id: &str,
-    members: &[EvictionReclaimMember],
-) -> Result<Vec<EvictionReclaimMember>, MasterCapacityPlanError> {
-    let cache = view
-        .master_kv_router()
-        .get_node_cache_controller(owner_node_id)
-        .ok_or(MasterCapacityPlanError::RouteChanged)?;
-    let mut expected = HashMap::new();
-    for member in members {
-        if let Some(cached) = cache.get(&member.key) {
-            if cached.put_id != member.desc.put_id
-                || cached.weight_bytes != member.desc.weight_bytes
-            {
-                return Err(MasterCapacityPlanError::RouteChanged);
-            }
-            expected.insert(member.key.clone(), member.desc.clone());
-        }
-    }
-    if expected.is_empty() {
-        return Ok(Vec::new());
-    }
-    super::take_exact_cache_entries(&cache, &expected)
-        .map(|removed| {
-            removed
-                .into_iter()
-                .map(|(key, desc)| EvictionReclaimMember {
-                    key,
-                    desc,
-                    expected_backing: None,
-                })
-                .collect()
-        })
-        .ok_or(MasterCapacityPlanError::RouteChanged)
+    Ok(current_anchor)
 }
 
 fn route_item(
@@ -879,152 +835,170 @@ fn owner_source_member_weight(backing: &OwnerReclaimBacking) -> Option<u32> {
     }
 }
 
-enum OwnerSourceAtomicBatchPlan {
-    Ready {
-        members: Vec<EvictionReclaimMember>,
-        all_sources_present: bool,
-    },
+enum OwnerSourceVictimPlan {
+    Ready(EvictionReclaimMember),
     Completed(&'static str),
     Stale(String),
     Rejected(String),
 }
 
-fn plan_exact_owner_source_atomic_batch(
-    view: &MasterKvRouterView,
+fn plan_exact_owner_source_victim_with(
     owner: &NodeID,
-    atomic_batch: &OwnerSourceEvictionAtomicBatch,
-) -> OwnerSourceAtomicBatchPlan {
-    plan_exact_owner_source_atomic_batch_with(owner, atomic_batch, &|key| {
-        view.master_kv_router()
-            .inner()
-            .kv_routes
-            .get(key)
-            .map(|entry| entry.clone())
-    })
-}
-
-fn plan_exact_owner_source_atomic_batch_with(
-    owner: &NodeID,
-    atomic_batch: &OwnerSourceEvictionAtomicBatch,
+    victim: &OwnerSourceEvictionVictim,
     route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
-) -> OwnerSourceAtomicBatchPlan {
-    if atomic_batch.members.is_empty() {
-        return OwnerSourceAtomicBatchPlan::Rejected(
-            "empty source-eviction atomic_batch".to_string(),
-        );
-    }
+) -> OwnerSourceVictimPlan {
+    let Some(weight_bytes) = owner_source_member_weight(&victim.backing) else {
+        return OwnerSourceVictimPlan::Rejected(format!(
+            "source backing is not an exact committed slot: key={}",
+            victim.key
+        ));
+    };
+    let desc = NodeValueReplicaDesc {
+        weight_bytes,
+        put_id: victim.put_id,
+    };
+    let planned = EvictionReclaimMember {
+        key: victim.key.clone(),
+        desc: desc.clone(),
+        expected_backing: Some(victim.backing.clone()),
+    };
 
-    let mut expected_keys = atomic_batch
-        .members
-        .iter()
-        .map(|member| member.key.clone())
-        .collect::<Vec<_>>();
-    expected_keys.sort_unstable();
-    expected_keys.dedup();
-    if expected_keys.len() != atomic_batch.members.len() {
-        return OwnerSourceAtomicBatchPlan::Rejected(
-            "source-eviction atomic_batch contains duplicate keys".to_string(),
-        );
+    let Some(route) = route_lookup(&victim.key) else {
+        return OwnerSourceVictimPlan::Completed("exact source replica is already absent");
+    };
+    if route.put_id != victim.put_id {
+        return OwnerSourceVictimPlan::Stale(format!(
+            "route version changed: key={} expected=({},{}) current=({},{})",
+            victim.key, victim.put_id.0, victim.put_id.1, route.put_id.0, route.put_id.1,
+        ));
     }
-
-    let mut planned = Vec::with_capacity(atomic_batch.members.len());
-    let mut absent_sources = 0usize;
-    for member in &atomic_batch.members {
-        let Some(weight_bytes) = owner_source_member_weight(&member.backing) else {
-            return OwnerSourceAtomicBatchPlan::Rejected(format!(
-                "source backing is not an exact committed slot: key={}",
-                member.key
-            ));
-        };
-        let desc = NodeValueReplicaDesc {
-            weight_bytes,
-            put_id: member.put_id,
-        };
-        planned.push(EvictionReclaimMember {
-            key: member.key.clone(),
-            desc: desc.clone(),
-            expected_backing: Some(member.backing.clone()),
-        });
-
-        let Some(route) = route_lookup(&member.key) else {
-            absent_sources += 1;
-            continue;
-        };
-        if route.put_id != member.put_id {
-            return OwnerSourceAtomicBatchPlan::Stale(format!(
-                "route version changed: key={} expected=({},{}) current=({},{})",
-                member.key, member.put_id.0, member.put_id.1, route.put_id.0, route.put_id.1,
-            ));
-        }
-        if route.lease_id.is_some() {
-            return OwnerSourceAtomicBatchPlan::Rejected(format!(
-                "leased route is not cache-evictable: key={}",
-                member.key
-            ));
-        }
-        let replica_matches = {
-            let replicas = route.nodes_replicas.read();
-            match replicas.get(owner) {
-                Some(replica) if !replica.tomb_tag.is_tomb() => {
-                    if !replica.owner_local_indexed {
-                        return OwnerSourceAtomicBatchPlan::Rejected(format!(
-                            "source route is not owner-local indexed: key={}",
-                            member.key
-                        ));
-                    }
-                    reclaim_backing_matches(replica, &member.backing)
-                }
-                _ => {
-                    absent_sources += 1;
-                    continue;
+    if route.lease_id.is_some() {
+        return OwnerSourceVictimPlan::Rejected(format!(
+            "leased route is not cache-evictable: key={}",
+            victim.key
+        ));
+    }
+    let replica_matches = {
+        let replicas = route.nodes_replicas.read();
+        match replicas.get(owner) {
+            Some(replica) if !replica.tomb_tag.is_tomb() => {
+                if !replica.owner_local_indexed {
+                    return OwnerSourceVictimPlan::Rejected(format!(
+                        "source route is not owner-local indexed: key={}",
+                        victim.key
+                    ));
                 }
+                reclaim_backing_matches(replica, &victim.backing)
+            }
+            _ => {
+                return OwnerSourceVictimPlan::Completed("exact source replica is already absent");
             }
-        };
-        if !replica_matches {
-            return OwnerSourceAtomicBatchPlan::Stale(format!(
-                "source backing changed: key={} put_id=({},{})",
-                member.key, member.put_id.0, member.put_id.1
-            ));
         }
+    };
+    if !replica_matches {
+        return OwnerSourceVictimPlan::Stale(format!(
+            "source backing changed: key={} put_id=({},{})",
+            victim.key, victim.put_id.0, victim.put_id.1
+        ));
+    }
+    OwnerSourceVictimPlan::Ready(planned)
+}
 
-        let mut route_atomic_batch =
-            match super::current_tp_atomic_batch_keys(&member.key, &route, &desc) {
-                Ok(keys) => keys,
-                Err(_) => {
-                    return OwnerSourceAtomicBatchPlan::Rejected(format!(
-                        "master route has an invalid TP/atomic atomic_batch: key={}",
-                        member.key
-                    ));
-                }
-            };
-        route_atomic_batch.sort_unstable();
-        route_atomic_batch.dedup();
-        if route_atomic_batch != expected_keys {
-            return OwnerSourceAtomicBatchPlan::Rejected(format!(
-                "owner did not submit the complete TP/atomic atomic_batch: key={} expected_members={} route_members={}",
-                member.key,
-                expected_keys.len(),
-                route_atomic_batch.len(),
-            ));
+fn direct_delete_exact_owner_source_with(
+    activity: &super::MasterKeyActivityTable,
+    owner: &NodeID,
+    victim: &OwnerSourceEvictionVictim,
+    epoch: u64,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
+    delete: impl FnOnce(&OwnerReclaimItem) -> bool,
+) -> (OwnerSourceEvictionOutcome, String) {
+    let member = match plan_exact_owner_source_victim_with(owner, victim, route_lookup) {
+        OwnerSourceVictimPlan::Ready(member) => member,
+        OwnerSourceVictimPlan::Completed(detail) => {
+            return (OwnerSourceEvictionOutcome::Completed, detail.to_string());
+        }
+        OwnerSourceVictimPlan::Stale(detail) => {
+            return (OwnerSourceEvictionOutcome::Stale, detail);
+        }
+        OwnerSourceVictimPlan::Rejected(detail) => {
+            return (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail);
         }
+    };
+    let item = OwnerReclaimItem {
+        key: member.key,
+        put_id: member.desc.put_id,
+        epoch,
+        backing: member
+            .expected_backing
+            .expect("exact owner source plan must retain its backing"),
+        reason: OwnerReclaimReason::OwnerCapacityEviction,
+    };
+    if let Err(snapshot) = activity.try_install_reclaim(&item) {
+        return (
+            OwnerSourceEvictionOutcome::RetryableBusy,
+            format!(
+                "master key activity is busy: puts={} gets={} replicas={} reclaim_installed={}",
+                snapshot.puts, snapshot.gets, snapshot.replicas, snapshot.reclaim_installed
+            ),
+        );
     }
 
-    if absent_sources == atomic_batch.members.len() {
-        OwnerSourceAtomicBatchPlan::Completed("all exact source replicas are already absent")
-    } else if absent_sources != 0 {
-        // This can be observed while an accepted atomic_batch is between individual
-        // route removals. The exact inflight registration below distinguishes
-        // that case from a malformed new request.
-        OwnerSourceAtomicBatchPlan::Ready {
-            members: planned,
-            all_sources_present: false,
+    let result = match plan_exact_owner_source_victim_with(owner, victim, route_lookup) {
+        OwnerSourceVictimPlan::Ready(_) => {
+            if delete(&item) {
+                (
+                    OwnerSourceEvictionOutcome::Completed,
+                    "exact source route deleted by batch handler".to_string(),
+                )
+            } else {
+                (
+                    OwnerSourceEvictionOutcome::RetryableBusy,
+                    "exact source route could not be deleted under its master fence".to_string(),
+                )
+            }
         }
-    } else {
-        OwnerSourceAtomicBatchPlan::Ready {
-            members: planned,
-            all_sources_present: true,
+        OwnerSourceVictimPlan::Completed(detail) => {
+            (OwnerSourceEvictionOutcome::Completed, detail.to_string())
         }
-    }
+        OwnerSourceVictimPlan::Stale(detail) => (OwnerSourceEvictionOutcome::Stale, detail),
+        OwnerSourceVictimPlan::Rejected(detail) => {
+            (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
+        }
+    };
+    assert!(
+        activity.clear_reclaim(&item),
+        "direct-delete master fence must remain installed until route deletion completes"
+    );
+    result
+}
+
+fn direct_delete_exact_owner_source_batch_with(
+    activity: &super::MasterKeyActivityTable,
+    owner: &NodeID,
+    operation_id: u64,
+    victims: &[OwnerSourceEvictionVictim],
+    route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
+    delete: impl Fn(&OwnerReclaimItem) -> bool,
+) -> Vec<OwnerSourceEvictionVictimResp> {
+    victims
+        .iter()
+        .enumerate()
+        .map(|(index, victim)| {
+            let (outcome, detail) = direct_delete_exact_owner_source_with(
+                activity,
+                owner,
+                victim,
+                owner_source_eviction_epoch(operation_id, index),
+                route_lookup,
+                |item| delete(item),
+            );
+            OwnerSourceEvictionVictimResp {
+                victim_index: u32::try_from(index).unwrap_or(u32::MAX),
+                outcome,
+                detail,
+            }
+        })
+        .collect()
 }
 
 pub(crate) async fn handle_batch_evict_owner_source(
@@ -1039,16 +1013,15 @@ pub(crate) async fn handle_batch_evict_owner_source(
     counters
         .source_evict_rpc_requests
         .fetch_add(1, Ordering::Relaxed);
-    counters.source_evict_atomic_batches.fetch_add(
-        u64::try_from(req.serialize_part.atomic_batches.len()).unwrap_or(u64::MAX),
+    counters.source_evict_victims.fetch_add(
+        u64::try_from(req.serialize_part.victims.len()).unwrap_or(u64::MAX),
         Ordering::Relaxed,
     );
     let requested_bytes = req
         .serialize_part
-        .atomic_batches
+        .victims
         .iter()
-        .flat_map(|atomic_batch| atomic_batch.members.iter())
-        .filter_map(|member| owner_source_member_weight(&member.backing))
+        .filter_map(|victim| owner_source_member_weight(&victim.backing))
         .map(u64::from)
         .fold(0u64, u64::saturating_add);
     counters
@@ -1060,7 +1033,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
         .map(|member| member.node_start_time);
     if current_generation != Some(req.serialize_part.owner_node_start_time) {
         counters.source_evict_rejected.fetch_add(
-            u64::try_from(req.serialize_part.atomic_batches.len()).unwrap_or(u64::MAX),
+            u64::try_from(req.serialize_part.victims.len()).unwrap_or(u64::MAX),
             Ordering::Relaxed,
         );
         let err = KvError::Api(ApiError::InvalidArgument {
@@ -1072,7 +1045,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
         return MsgPack {
             serialize_part: BatchEvictOwnerSourceResp {
                 operation_id,
-                atomic_batches: Vec::new(),
+                victims: Vec::new(),
                 error_code: err.code(),
                 error_json: err.to_json(),
             },
@@ -1080,57 +1053,22 @@ pub(crate) async fn handle_batch_evict_owner_source(
         };
     }
 
-    let mut responses = Vec::with_capacity(req.serialize_part.atomic_batches.len());
-    for (index, atomic_batch) in req.serialize_part.atomic_batches.iter().enumerate() {
-        let (outcome, detail) =
-            match plan_exact_owner_source_atomic_batch(view, &owner, atomic_batch) {
-                OwnerSourceAtomicBatchPlan::Completed(detail) => {
-                    (OwnerSourceEvictionOutcome::Completed, detail.to_string())
-                }
-                OwnerSourceAtomicBatchPlan::Stale(detail) => {
-                    (OwnerSourceEvictionOutcome::Stale, detail)
-                }
-                OwnerSourceAtomicBatchPlan::Rejected(detail) => {
-                    (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
-                }
-                OwnerSourceAtomicBatchPlan::Ready {
-                    members,
-                    all_sources_present,
-                } => {
-                    match view
-                        .master_kv_router()
-                        .enqueue_owner_capacity_eviction_atomic_batch(
-                            owner.as_ref().to_string(),
-                            req.serialize_part.owner_node_start_time,
-                            members,
-                            all_sources_present,
-                        ) {
-                        EnqueueEvictionReclaimResult::Accepted => (
-                            OwnerSourceEvictionOutcome::Accepted,
-                            "exact source atomic_batch accepted by reclaim pipeline".to_string(),
-                        ),
-                        EnqueueEvictionReclaimResult::AlreadyInProgress => (
-                            OwnerSourceEvictionOutcome::AlreadyInProgress,
-                            "same exact source atomic_batch is already in progress".to_string(),
-                        ),
-                        EnqueueEvictionReclaimResult::PartialOverlap => (
-                            OwnerSourceEvictionOutcome::RetryableBusy,
-                            "source atomic_batch partially overlaps another reclaim transaction"
-                                .to_string(),
-                        ),
-                        EnqueueEvictionReclaimResult::NotInProgress => (
-                            OwnerSourceEvictionOutcome::Stale,
-                            "partially absent source atomic_batch is not an in-progress replay"
-                                .to_string(),
-                        ),
-                        EnqueueEvictionReclaimResult::Closed => (
-                            OwnerSourceEvictionOutcome::RetryableBusy,
-                            "source reclaim actor is unavailable".to_string(),
-                        ),
-                    }
-                }
-            };
-        let outcome_counter = match outcome {
+    let responses = direct_delete_exact_owner_source_batch_with(
+        &view.master_kv_router().inner().key_activity,
+        &owner,
+        operation_id,
+        &req.serialize_part.victims,
+        &|key| {
+            view.master_kv_router()
+                .inner()
+                .kv_routes
+                .get(key)
+                .map(|route| route.clone())
+        },
+        |item| remove_reclaimed_replica(view, &owner, item),
+    );
+    for response in &responses {
+        let outcome_counter = match response.outcome {
             OwnerSourceEvictionOutcome::Accepted => &counters.source_evict_accepted,
             OwnerSourceEvictionOutcome::AlreadyInProgress => &counters.source_evict_in_progress,
             OwnerSourceEvictionOutcome::Completed => &counters.source_evict_completed,
@@ -1141,17 +1079,29 @@ pub(crate) async fn handle_batch_evict_owner_source(
             OwnerSourceEvictionOutcome::RejectedNotEvictable => &counters.source_evict_rejected,
         };
         outcome_counter.fetch_add(1, Ordering::Relaxed);
-        responses.push(OwnerSourceEvictionAtomicBatchResp {
-            atomic_batch_index: u32::try_from(index).unwrap_or(u32::MAX),
-            outcome,
-            detail,
-        });
     }
 
+    let completed = responses
+        .iter()
+        .filter(|response| response.outcome == OwnerSourceEvictionOutcome::Completed)
+        .count();
+    let retryable = responses
+        .iter()
+        .filter(|response| response.outcome == OwnerSourceEvictionOutcome::RetryableBusy)
+        .count();
+    tracing::info!(
+        owner = %owner,
+        operation_id,
+        victims = responses.len(),
+        completed,
+        retryable,
+        "owner source direct-delete batch completed"
+    );
+
     MsgPack {
         serialize_part: BatchEvictOwnerSourceResp {
             operation_id,
-            atomic_batches: responses,
+            victims: responses,
             error_code: OK,
             error_json: String::new(),
         },
@@ -1566,7 +1516,7 @@ fn clear_master_fences(view: &MasterKvRouterView, items: &[OwnerReclaimItem]) {
     }
 }
 
-fn try_install_atomic_batch_master_fences(
+fn try_install_master_fences(
     activity: &super::MasterKeyActivityTable,
     items: &[OwnerReclaimItem],
 ) -> Result<(), (usize, super::MasterKeyActivitySnapshot)> {
@@ -1585,33 +1535,31 @@ fn try_install_atomic_batch_master_fences(
     Ok(())
 }
 
-/// Reclaim one TP/atomic atomic_batch as a transaction.
-///
-/// Before the first owner Commit, any failed fence/validation/Prepare rolls
-/// the entire atomic_batch back.  Once a response (including an Abort response)
-/// proves that any member was committed, rollback is impossible; the same
-/// transaction retains every master fence and keeps driving the remaining
-/// members until all are committed, then removes/finalizes the whole atomic_batch.
-async fn reclaim_atomic_batch_items(
+/// Reclaim one independently selected key.
+async fn reclaim_single_victim(
     view: &MasterKvRouterView,
     owner: &NodeID,
     items: Vec<OwnerReclaimItem>,
 ) -> u32 {
-    if items.is_empty() {
+    if items.len() != 1 {
+        tracing::error!(
+            owner = %owner,
+            victims = items.len(),
+            "single-key reclaim received a non-singleton request"
+        );
         return 0;
     }
     let counters = view
         .master_kv_router()
         .eviction_reclaim_counters(owner.as_ref());
-    if let Err((failed_index, activity)) = try_install_atomic_batch_master_fences(
-        &view.master_kv_router().inner().key_activity,
-        &items,
-    ) {
+    if let Err((failed_index, activity)) =
+        try_install_master_fences(&view.master_kv_router().inner().key_activity, &items)
+    {
         counters
             .master_activity_deferred
             .fetch_add(1, Ordering::Relaxed);
         tracing::trace!(
-            "atomic_batch reclaim deferred by master activity: owner={} key={} puts={} gets={} replicas={} reclaim_installed={}",
+            "single-key reclaim deferred by master activity: owner={} key={} puts={} gets={} replicas={} reclaim_installed={}",
             owner,
             items[failed_index].key,
             activity.puts,
@@ -1650,7 +1598,7 @@ async fn reclaim_atomic_batch_items(
     }
     if !master_only.is_empty() || owner_coordinated.len() != fenced.len() {
         tracing::error!(
-            "BUG: one reclaim atomic_batch mixed master-only and owner-coordinated backings: owner={} atomic_batch={} master_only={} owner_coordinated={}",
+            "BUG: one single-key reclaim mixed master-only and owner-coordinated backings: owner={} victims={} master_only={} owner_coordinated={}",
             owner,
             fenced.len(),
             master_only.len(),
@@ -1762,7 +1710,7 @@ async fn reclaim_atomic_batch_items(
 
         if rounds == 8 && !committed_keys.is_empty() {
             tracing::warn!(
-                "owner atomic_batch reclaim is rolling forward after partial/uncertain commit: owner={} atomic_batch={} committed={}",
+                "owner single-key reclaim is rolling forward after uncertain commit: owner={} victims={} committed={}",
                 owner,
                 owner_coordinated.len(),
                 committed_keys.len(),
@@ -2152,11 +2100,11 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                             OwnerReclaimReason::OwnerCapacityEviction,
                         ),
                         EvictionReclaimOrigin::MasterAllocationCapacity => {
-                            let members = match plan_master_allocation_capacity_atomic_batch(
+                            let member = match plan_master_allocation_capacity_victim(
                                 &view_task,
                                 &request,
                             ) {
-                                Ok(members) => members,
+                                Ok(member) => member,
                                 Err(MasterCapacityPlanError::CommittedSlot) => {
                                     counters
                                         .capacity_eviction_non_ring_b_entry_total
@@ -2183,10 +2131,6 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                                     counters.route_changed.fetch_add(1, Ordering::Relaxed);
                                     continue;
                                 }
-                                Err(MasterCapacityPlanError::InvalidAtomicBatch) => {
-                                    retry_requests.push(request);
-                                    continue;
-                                }
                                 Err(MasterCapacityPlanError::WrongRole) => {
                                     counters
                                         .capacity_eviction_non_ring_b_entry_total
@@ -2204,80 +2148,9 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                                     continue;
                                 }
                             };
-                            let owner_cache_lock = view_task
-                                .master_kv_router()
-                                .inner()
-                                .owner_cache_operation_locks
-                                .get_lock(owner_node_id.clone());
-                            let owner_cache_guard = owner_cache_lock.lock().await;
-                            let detach_result = detach_present_capacity_atomic_batch_siblings(
-                                &view_task,
-                                &owner_node_id,
-                                &members,
-                            );
-                            drop(owner_cache_guard);
-                            if detach_result.is_err() {
-                                retry_requests.push(request);
-                                continue;
-                            }
-
-                            let planned = members
-                                .iter()
-                                .map(|member| {
-                                    (
-                                        member.key.clone(),
-                                        member.desc.put_id,
-                                        member.desc.weight_bytes,
-                                    )
-                                })
-                                .collect::<HashSet<_>>();
-                            let mut accounting_requests = vec![request];
-                            let mut retained = std::collections::VecDeque::new();
-                            while let Some(other) = pending.pop_front() {
-                                let belongs = other.origin
-                                    == EvictionReclaimOrigin::MasterAllocationCapacity
-                                    && other.members.iter().all(|member| {
-                                        planned.contains(&(
-                                            member.key.clone(),
-                                            member.desc.put_id,
-                                            member.desc.weight_bytes,
-                                        ))
-                                    });
-                                if belongs {
-                                    accounting_requests.push(other);
-                                } else {
-                                    retained.push_back(other);
-                                }
-                            }
-                            pending = retained;
-
-                            let mut accounted = accounting_requests
-                                .iter()
-                                .flat_map(EvictionReclaimRequest::identities)
-                                .collect::<HashSet<_>>();
-                            for member in &members {
-                                let synthetic = EvictionReclaimRequest {
-                                    owner_node_id: owner_node_id.clone(),
-                                    owner_node_start_time: None,
-                                    members: vec![member.clone()],
-                                    origin: EvictionReclaimOrigin::MasterAllocationCapacity,
-                                    retry_count: 0,
-                                };
-                                let identity = synthetic.identities().pop().unwrap();
-                                if accounted.contains(&identity) {
-                                    continue;
-                                }
-                                if view_task
-                                    .master_kv_router()
-                                    .register_eviction_reclaim(&synthetic)
-                                {
-                                    accounted.insert(identity);
-                                    accounting_requests.push(synthetic);
-                                }
-                            }
                             (
-                                members,
-                                accounting_requests,
+                                vec![member],
+                                vec![request],
                                 OwnerReclaimReason::MasterAllocationCapacity,
                             )
                         }
@@ -2306,7 +2179,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                         })
                         .collect::<Option<Vec<_>>>();
                     if let Some(items) = items {
-                        let _ = reclaim_atomic_batch_items(&view_task, &owner, items).await;
+                        let _ = reclaim_single_victim(&view_task, &owner, items).await;
                     }
                     for accounting_request in accounting_requests.drain(..) {
                         if request_is_current(&view_task, &accounting_request) {
@@ -2325,7 +2198,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                 let retry_count = retry_requests.len();
                 spawn_eviction_reclaim_retry(view_task.clone(), retry_requests);
                 tracing::trace!(
-                    "safe atomic_batch eviction reclaim batch completed: owner={} retry_deferred={}",
+                    "single-key eviction reclaim batch completed: owner={} retry_deferred={}",
                     owner_node_id,
                     retry_count,
                 );

From 1cb188c8847120933969f659afb6ea73a3ddf204 Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Tue, 21 Jul 2026 13:41:38 +0800
Subject: [PATCH 07/10] backup 9qps

---
 ...06\346\210\220\350\256\276\350\256\241.md" |  26 +-
 fluxon_py/config.py                           |   2 +-
 fluxon_py/kvclient/fluxon.py                  |  40 +-
 fluxon_py/kvclient/kvclient_interface.py      |   6 +-
 .../src/client_kv_api/external_api.rs         | 471 +++++++--
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |  93 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 871 +++++++++++++++--
 .../fluxon_kv/src/client_kv_api/msg_pack.rs   |  63 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  | 923 ++++++------------
 .../fluxon_kv/src/client_kv_api/reclaim.rs    |  32 +-
 fluxon_rs/fluxon_kv/src/config.rs             |   6 +-
 .../external_client_api/delete_ack_batch.rs   | 366 +++++++
 .../fluxon_kv/src/external_client_api/mod.rs  | 386 ++++++--
 .../fluxon_kv/src/master_kv_router/mod.rs     | 260 ++++-
 .../src/master_kv_router/msg_pack.rs          |  11 +
 .../fluxon_kv/src/master_kv_router/put.rs     | 149 ++-
 .../fluxon_kv/src/master_kv_router/reclaim.rs | 190 +++-
 fluxon_rs/fluxon_kv/src/memholder/lifetime.rs |  77 +-
 fluxon_rs/fluxon_kv/src/memholder/mod.rs      |   1 -
 .../rpcresp_kvresult_convert.rs               |  29 +-
 fluxon_rs/fluxon_pyo3/src/lib.rs              |  15 +-
 21 files changed, 2987 insertions(+), 1030 deletions(-)
 create mode 100644 fluxon_rs/fluxon_kv/src/external_client_api/delete_ack_batch.rs

diff --git "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md" "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
index 9c38aa5..8d6fa0f 100644
--- "a/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
+++ "b/fluxon_doc_cn/design/sglang_fluxon_kv\351\233\206\346\210\220\350\256\276\350\256\241.md"
@@ -185,7 +185,7 @@ flowchart LR
 | `GetStartResult` | SGLang hostless 读取 | 描述连续命中前缀、可传输长度、atomic group 命中数和第一个 miss 位置。 |
 | `GetStartHandle` | SGLang hostless 读取 | 持有一次 get-start 结果和 backend handle；必须被 `get_transfer` 消费或被 `cancel_get_transfer` 取消。 |
 | `get_start(keys, prefix_best_effort, atomic_group_lens)` | SGLang hostless 读取 | 按 key 顺序计算连续命中的 prefix，并返回 `GetStartHandle`。 |
-| `get_transfer(handle)` | SGLang hostless 读取 | 消费 handle 的可传输前缀，执行必要 transfer，并返回 readable `plan_ptr`。 |
+| `get_transfer(handle, *, consume_prefix_len=None)` | SGLang hostless 读取 | 消费 handle 的全部可传输前缀，或消费由 `consume_prefix_len` 选定的更短完整 atomic-group 前缀；释放 tail，执行必要 transfer，并返回 readable `plan_ptr`。 |
 | `cancel_get_transfer(handle)` | SGLang hostless 读取 | 放弃未 transfer 的 `GetStartHandle`，释放 get-start 期间持有的 owner/external 资源。 |
 | `release_views(plan_ptr)` | SGLang hostless 读取 | 释放 get-transfer 产生的 readable plan，丢弃其持有的 holder 引用。 |
 
@@ -475,7 +475,7 @@ hostless restore 的核心约束是：SGLang 只能恢复有序 page keys 的连
 因此读取侧分成 prefetch 和 restore 两段。当前实现把 start-to-transfer 计划显式限定为两个分支：
 
 - Prefetch：`get_start(keys, prefix_best_effort, atomic_group_lens)` 按 key 顺序做 local visible check / owner get start，计算 page 级连续命中前缀 `raw_prefix_hit_len`，再按 `atomic_group_lens` 向下收敛成 `transferable_len`。全 owner-local 批次返回 `InlineLocal { items }`：owner 为每个导出 page 安装独立 external holding，并把 offset、len、holding ID 和 owner generation 随 start response 返回；该分支不创建 transfer registry，也不启动后台 transfer。混合命中、master fallback 或需要远端 materialization 的批次返回 `OwnerRpc`，继续由 shared op 保存后台 prefetch 的 holder / transfer result。
-- Restore：SGLang 拿到 `transferable_len` 后再决定是否分配 GPU KV pages 并继续恢复。`get_transfer(handle)` 消费 `get_start` 返回的 handle。`InlineLocal` 分支在 external 进程校验 owner generation 和 mmap 范围后直接构造 holders；`OwnerRpc` 分支等待或取得原有 prefetch 结果。两个分支最终都生成持有 holder 引用的 readable `plan_ptr`，随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)` 把 Fluxon value memory 拷回 GPU KV cache。
+- Restore：SGLang 拿到 `transferable_len` 后再决定是否分配 GPU KV pages 并继续恢复。`get_transfer(handle, consume_prefix_len=...)` 可以消费不超过 `transferable_len` 的更短完整 atomic-group 前缀；省略该参数时消费全部可传输前缀。`InlineLocal` 分支在 external 进程校验 owner generation 和 mmap 范围后，只为消费前缀构造 holders，tail holding IDs 进入现有 holder-ACK 合批队列；`OwnerRpc` 分支在同一 transfer handler 内 drop tail items，只等待或取得消费前缀的 prefetch 结果。两个分支最终都生成持有 holder 引用的 readable `plan_ptr`，随后 SGLang native kernel 使用 `restore_*_from_fluxon_values(...)` 把 Fluxon value memory 拷回 GPU KV cache。
 
 读取阶段拆成 prefetch 和 restore 两步，主要是为了保证：
 
@@ -513,14 +513,17 @@ sequenceDiagram
     B-->>U: transferable_len / prefix_hit_groups / first_miss_index
     U->>U: allocate GPU KV pages for transferable prefix
     alt transferable_len > 0 and caller chooses restore
-        U->>B: get_transfer(handle)
-        B->>F: get_transfer(handle)
-        F->>E: batch_get_transfer(handle, transferable keys)
+        U->>B: get_transfer(handle, consume_prefix_len)
+        B->>F: get_transfer(handle, consume_prefix_len)
+        F->>E: batch_get_transfer(handle, consumed prefix)
         alt InlineLocal
-            E->>E: validate generation and mmap range, construct holders
+            E->>E: validate generation and mmap range
+            E->>E: enqueue tail holding IDs to batched ACK
+            E->>E: construct consumed-prefix holders
         else OwnerRpc
-            E->>O: ExternalBatchGetTransferReq
-            O-->>E: prefetched holders / transfer results
+            E->>O: ExternalBatchGetTransferReq(consume_prefix_len)
+            O->>O: validate atomic boundary and drop tail items
+            O-->>E: consumed-prefix holders / transfer results
         end
         E-->>F: plan_ptr(value_ptrs, holders kept alive)
         F-->>B: plan_ptr
@@ -547,7 +550,7 @@ sequenceDiagram
 | 字段 | 含义 |
 | --- | --- |
 | `raw_prefix_hit_len` | 按 key 顺序连续命中的 page 数，未按 atomic group 收敛。 |
-| `transferable_len` | 可以交给 `get_transfer` 的 page 数；它不会切开 atomic group。 |
+| `transferable_len` | `get_transfer` 最多可消费的 page 数；它不会切开 atomic group。 |
 | `prefix_hit_groups` | 完整命中的 atomic group 数。 |
 | `first_miss_index` | 第一个 miss page 的 index；全部命中时为 `None`。 |
 | `first_miss_group_index` | 第一个 miss 所在 atomic group；全部命中时为 `None`。 |
@@ -556,9 +559,10 @@ sequenceDiagram
 生命周期规则：
 
 - `get_start` 成功后，调用方必须二选一：`get_transfer(handle)` 或 `cancel_get_transfer(handle)`；放弃 restore 时必须取消 handle，释放可能已经启动的 prefetch 资源。
-- `get_transfer(handle)` 成功后，handle 已被消费；后续由 returned `plan_ptr` 和 `release_views(plan_ptr)` 管理。
+- `get_transfer(handle, consume_prefix_len=...)` 的值必须大于 0、不超过 `transferable_len`，并精确落在 atomic-group 边界；参数校验失败时 handle 仍可 cancel 或用合法长度重试。
+- `get_transfer` 成功后，handle 已被消费；tail 资源同时移交给 owner 直接 drop 或 external holder-ACK 合批队列，后续只由 returned `plan_ptr` 和 `release_views(plan_ptr)` 管理消费前缀。
 - `release_views(plan_ptr)` 必须在 native restore 完成后执行，即使 native restore 失败也要释放。
-- `InlineLocal` holding 从 owner 返回 start response 前已经安装；`get_transfer` 把它移交给 returned plan，`cancel_get_transfer` 则携带 holding IDs 精确释放。owner 重启或 generation 不匹配时不能继续使用旧 inline plan。
+- `InlineLocal` holding 从 owner 返回 start response 前已经安装；全量 `get_transfer` 把它们移交给 returned plan，部分前缀 `get_transfer` 只移交前缀并将 tail holding IDs 无等待送入 holder-ACK 合批队列，`cancel_get_transfer` 则携带全部 holding IDs 精确释放。owner 重启或 generation 不匹配时不能继续使用旧 inline plan。
 - `get_start` 只命中部分前缀时，SGLang 只能恢复 `transferable_len` 覆盖的完整 atomic groups，不能构造半个 atomic group 的 GPU KV 状态。
 - `get_transfer` 返回 miss / KeyNotFound 时，SGLang 必须放弃本次 restore 并执行 rollback。
 - owner 必须为未被 `get_transfer/cancel_get_transfer` 消费的 handle 设置有界 TTL；TTL 回收与
diff --git a/fluxon_py/config.py b/fluxon_py/config.py
index 74f8746..4eff497 100644
--- a/fluxon_py/config.py
+++ b/fluxon_py/config.py
@@ -93,7 +93,7 @@ def _yaml_template():
   tcp_thread_bulk_lane_count:          # tcp_thread bulk lane count, 1..8 (int(optional))
   tcp_thread_control_lane_count:       # tcp_thread control lane count, 1..8 (int(optional))
   user_rpc_sync_handler_thread_count:  # Owner-dedicated sync user-RPC worker thread count, >0 (int(optional))
-  replica_task_max_inflight:           # Concurrent replica append pipelines, 1..64; per-key order stays serialized (int(optional))
+  replica_task_max_inflight:           # Deprecated compatibility field, still validated as 1..64; direct remote-Put singleflight does not use a global actor queue (int(optional))
   require_transfer_rpc_fast_path_ready_timeout_seconds: # Require owner-owner transfer-rpc fast path before owner ready/shared.json publication (int(optional))
   rdma_device_names:                   # Explicit RDMA devices for benchmark/test fast-path fanout (['{str}'](optional))
   enable_side_transfer: false          # Enable TCP side-transfer fast-path (bool(optional))
diff --git a/fluxon_py/kvclient/fluxon.py b/fluxon_py/kvclient/fluxon.py
index c794c63..ef17660 100644
--- a/fluxon_py/kvclient/fluxon.py
+++ b/fluxon_py/kvclient/fluxon.py
@@ -1713,6 +1713,8 @@ def get_transfer(
         self,
         handle: GetStartHandle,
         concurrency: Optional[int] = None,
+        *,
+        consume_prefix_len: Optional[int] = None,
     ) -> int:
         if not isinstance(handle, GetStartHandle):
             raise TypeError(f"get_transfer requires GetStartHandle, got {type(handle)}")
@@ -1729,12 +1731,48 @@ def get_transfer(
                 f"first_miss_index={result.first_miss_index} "
                 f"first_miss_group_index={result.first_miss_group_index}"
             )
+        if consume_prefix_len is None:
+            normalized_consume_prefix_len = result.transferable_len
+        else:
+            if isinstance(consume_prefix_len, bool) or not isinstance(
+                consume_prefix_len, int
+            ):
+                raise TypeError(
+                    "get_transfer consume_prefix_len must be an int or None, got "
+                    f"{type(consume_prefix_len)}"
+                )
+            normalized_consume_prefix_len = int(consume_prefix_len)
+        if (
+            normalized_consume_prefix_len <= 0
+            or normalized_consume_prefix_len > result.transferable_len
+        ):
+            raise ValueError(
+                "get_transfer consume_prefix_len must be within the live "
+                "transferable prefix: "
+                f"consume={normalized_consume_prefix_len} "
+                f"transferable={result.transferable_len}"
+            )
+        group_lens = result.atomic_group_lens or (len(result.keys),)
+        group_end = 0
+        for group_len in group_lens:
+            group_end += int(group_len)
+            if group_end >= normalized_consume_prefix_len:
+                break
+        if group_end != normalized_consume_prefix_len:
+            raise ValueError(
+                "get_transfer consume_prefix_len must end at an atomic-group "
+                "boundary: "
+                f"consume={normalized_consume_prefix_len} "
+                f"atomic_group_lens={group_lens}"
+            )
         if self._client is None:
             raise RuntimeError(
                 "Store not initialized when get_transfer(). Call setup() first."
             )
         _ = concurrency
-        inner_res = self._client.get_transfer(handle.backend_handle)
+        inner_res = self._client.get_transfer(
+            handle.backend_handle, normalized_consume_prefix_len
+        )
         if not inner_res.is_ok():
             handle.closed = True
             raise RuntimeError(f"get_transfer backend error: {inner_res.unwrap_error()}")
diff --git a/fluxon_py/kvclient/kvclient_interface.py b/fluxon_py/kvclient/kvclient_interface.py
index bb248da..ead8e4e 100644
--- a/fluxon_py/kvclient/kvclient_interface.py
+++ b/fluxon_py/kvclient/kvclient_interface.py
@@ -30,7 +30,8 @@ class GetStartResult:
     - ``keys`` is the caller-provided ordered page-key sequence.
     - ``raw_prefix_hit_len`` is the page-level continuous hit prefix.
     - ``transferable_len`` is rounded down to complete atomic groups and is the
-      only prefix that can be consumed by get_transfer().
+      maximum prefix that can be consumed by get_transfer(). A caller may
+      consume a shorter prefix only at an atomic-group boundary.
     """
 
     keys: Tuple[str, ...]
@@ -301,9 +302,12 @@ def get_transfer(
         self,
         handle: GetStartHandle,
         concurrency: Optional[int] = None,
+        *,
+        consume_prefix_len: Optional[int] = None,
     ) -> int:
         _ = handle
         _ = concurrency
+        _ = consume_prefix_len
         raise NotImplementedError(
             "get_transfer is only implemented by backends with native prefix get support"
         )
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 09f5e0f..22b4882 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -20,7 +20,7 @@ use crate::client_kv_api::{
     ExternalGetStartSharedItemResult, ExternalGetStartTransferOutput,
     ExternalLocalFirstPutKeyReservation, ExternalPendingPutCtx, ExternalPutKeyOutcome,
     OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerLocalReserveSlotLease,
-    OwnerLocalReserveSlotRef, ReplicaTaskTarget,
+    OwnerLocalReserveSlotRef,
 };
 use crate::client_seg_pool::{ResolveSideTransferLaneReq, parse_side_transfer_worker_lane_idx};
 use crate::cluster_manager::NodeIDString;
@@ -29,7 +29,7 @@ use crate::cluster_manager::{
 };
 use crate::master_kv_router::msg_pack::{
     BatchGetStartItemResp, BatchGetStartResp, BatchPutDoneItemReq, BatchPutRevokeItemReq,
-    BatchPutStartItemReq, GetPreparedLocalReserveTarget, PutAtomicGroup, PutDoneCommittedSlot,
+    GetPreparedLocalReserveTarget, PutAtomicGroup, PutDoneCommittedSlot,
     build_put_atomic_group_assignments,
 };
 use crate::memholder::MemholderManagerTrait;
@@ -570,6 +570,42 @@ pub(crate) fn compute_external_get_start_transfer_prefix(
     }
 }
 
+pub(crate) fn validate_external_get_consume_prefix(
+    consume_prefix_len: usize,
+    transferable_len: usize,
+    group_lens: &[usize],
+) -> KvResult<()> {
+    if consume_prefix_len == 0 || consume_prefix_len > transferable_len {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "external get_transfer consume_prefix_len must be within the live prefix: consume={} transferable={}",
+                consume_prefix_len, transferable_len
+            ),
+        }));
+    }
+
+    let mut group_end = 0usize;
+    for group_len in group_lens.iter().copied() {
+        group_end = group_end.checked_add(group_len).ok_or_else(|| {
+            KvError::Api(ApiError::InvalidArgument {
+                detail: "external get_transfer atomic-group boundary overflowed usize".to_string(),
+            })
+        })?;
+        if group_end >= consume_prefix_len {
+            break;
+        }
+    }
+    if group_end != consume_prefix_len {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "external get_transfer consume_prefix_len splits an atomic group: consume={} group_lens={:?}",
+                consume_prefix_len, group_lens
+            ),
+        }));
+    }
+    Ok(())
+}
+
 fn collect_external_get_start_missing<T>(
     keys: &[String],
     item_slots: &[Option<T>],
@@ -862,10 +898,12 @@ mod external_get_start_batch_tests {
         collect_external_get_start_missing, compute_external_get_start_raw_prefix,
         compute_external_get_start_transfer_prefix, decide_external_get_key_item,
         external_member_left_departed_epoch, normalize_external_put_start_group_lens,
-        partition_external_get_finish_leaders, register_external_get_key_under_fence,
+        observe_external_get_consume_phases, partition_external_get_finish_leaders,
+        register_external_get_key_under_fence, validate_external_get_consume_prefix,
     };
     use crate::client_kv_api::{
-        ExternalGetKeySharedOp, ExternalGetStartEntry, ExternalGetStartOwnerItem,
+        ExternalGetKeyInterest, ExternalGetKeySharedOp, ExternalGetKeySharedPhase,
+        ExternalGetStartEntry, ExternalGetStartOwnerItem, ExternalGetStartSharedItemResult,
         OwnerKeyControlState,
     };
     use crate::master_kv_router::msg_pack::{
@@ -875,7 +913,7 @@ mod external_get_start_batch_tests {
     use dashmap::DashMap;
     use std::collections::HashMap;
     use std::sync::Arc;
-    use std::time::Instant;
+    use std::time::{Duration, Instant};
 
     fn abandoned_handle_entry(
         req_node_id: &str,
@@ -886,6 +924,7 @@ mod external_get_start_batch_tests {
             requester_node_start_time,
             keys: Vec::new(),
             items: Vec::new(),
+            atomic_group_lens: Vec::new(),
             created_at: Instant::now(),
         }
     }
@@ -980,6 +1019,51 @@ mod external_get_start_batch_tests {
         );
     }
 
+    #[test]
+    fn get_transfer_consume_prefix_must_be_live_and_end_at_group_boundary() {
+        let group_lens = [2, 2, 3];
+        assert!(validate_external_get_consume_prefix(2, 4, &group_lens).is_ok());
+        assert!(validate_external_get_consume_prefix(4, 4, &group_lens).is_ok());
+        assert!(validate_external_get_consume_prefix(0, 4, &group_lens).is_err());
+        assert!(validate_external_get_consume_prefix(1, 4, &group_lens).is_err());
+        assert!(validate_external_get_consume_prefix(3, 4, &group_lens).is_err());
+        assert!(validate_external_get_consume_prefix(5, 4, &group_lens).is_err());
+    }
+
+    #[test]
+    fn consume_phase_snapshot_distinguishes_ready_data_from_real_wait() {
+        let finishing = Arc::new(ExternalGetKeySharedOp::new("finishing".to_string()));
+        finishing.state.lock().phase = ExternalGetKeySharedPhase::Finishing {
+            item: BatchGetStartItemResp::default(),
+        };
+        let ready = Arc::new(ExternalGetKeySharedOp::new("ready".to_string()));
+        let observed_at = Instant::now();
+        {
+            let mut state = ready.state.lock();
+            state.phase = ExternalGetKeySharedPhase::Ready {
+                result: ExternalGetStartSharedItemResult::Miss,
+            };
+            state.terminal_at = Some(observed_at - Duration::from_millis(5));
+        }
+        let items = vec![
+            ExternalGetStartOwnerItem::Shared {
+                interest: ExternalGetKeyInterest::new(finishing, false),
+            },
+            ExternalGetStartOwnerItem::Shared {
+                interest: ExternalGetKeyInterest::new(ready, false),
+            },
+        ];
+
+        let snapshot = observe_external_get_consume_phases(&items, observed_at);
+        assert_eq!(snapshot.finishing, 1);
+        assert_eq!(snapshot.ready, 1);
+        assert_eq!(snapshot.pending_before_consume(), 1);
+        assert_eq!(snapshot.terminal_before_consume(), 1);
+        assert_eq!(snapshot.terminal_age_count, 1);
+        assert_eq!(snapshot.terminal_age_mean_us(), 5_000);
+        assert_eq!(snapshot.terminal_age_max_us, 5_000);
+    }
+
     #[test]
     fn put_groups_default_per_item_and_reject_malformed_partitions() {
         assert_eq!(
@@ -1134,9 +1218,11 @@ mod external_get_start_batch_tests {
                 local_puts: 0,
                 external_pending_puts: 0,
                 external_put: None,
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(old.clone()),
+                local_access_fence: None,
             },
         )]);
         clear_external_get_key_marker_locked(&mut controls, &old);
@@ -1163,9 +1249,11 @@ mod external_get_start_batch_tests {
                 local_puts: 0,
                 external_pending_puts: 0,
                 external_put: None,
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(op.clone()),
+                local_access_fence: None,
             },
         )]);
 
@@ -1242,6 +1330,92 @@ mod external_get_start_batch_tests {
     }
 }
 
+#[derive(Debug, Default)]
+struct ExternalGetConsumePhaseSnapshot {
+    local: usize,
+    starting: usize,
+    started: usize,
+    finishing: usize,
+    revoking: usize,
+    ready: usize,
+    failed: usize,
+    terminal_age_count: usize,
+    terminal_age_sum_us: u64,
+    terminal_age_max_us: u64,
+}
+
+impl ExternalGetConsumePhaseSnapshot {
+    fn terminal_before_consume(&self) -> usize {
+        self.local
+            .saturating_add(self.ready)
+            .saturating_add(self.failed)
+    }
+
+    fn pending_before_consume(&self) -> usize {
+        self.starting
+            .saturating_add(self.started)
+            .saturating_add(self.finishing)
+            .saturating_add(self.revoking)
+    }
+
+    fn terminal_age_mean_us(&self) -> u64 {
+        if self.terminal_age_count == 0 {
+            0
+        } else {
+            self.terminal_age_sum_us / self.terminal_age_count as u64
+        }
+    }
+}
+
+fn observe_external_get_consume_phases(
+    items: &[ExternalGetStartOwnerItem],
+    observed_at: Instant,
+) -> ExternalGetConsumePhaseSnapshot {
+    let mut snapshot = ExternalGetConsumePhaseSnapshot::default();
+    for item in items {
+        let ExternalGetStartOwnerItem::Shared { interest } = item else {
+            snapshot.local = snapshot.local.saturating_add(1);
+            continue;
+        };
+        let state = interest.op().state.lock();
+        match &state.phase {
+            ExternalGetKeySharedPhase::Starting => {
+                snapshot.starting = snapshot.starting.saturating_add(1)
+            }
+            ExternalGetKeySharedPhase::Started { .. } => {
+                snapshot.started = snapshot.started.saturating_add(1)
+            }
+            ExternalGetKeySharedPhase::Finishing { .. } => {
+                snapshot.finishing = snapshot.finishing.saturating_add(1)
+            }
+            ExternalGetKeySharedPhase::Revoking { .. } => {
+                snapshot.revoking = snapshot.revoking.saturating_add(1)
+            }
+            ExternalGetKeySharedPhase::Ready { .. } => {
+                snapshot.ready = snapshot.ready.saturating_add(1)
+            }
+            ExternalGetKeySharedPhase::Failed { .. } => {
+                snapshot.failed = snapshot.failed.saturating_add(1)
+            }
+        }
+        if matches!(
+            &state.phase,
+            ExternalGetKeySharedPhase::Ready { .. } | ExternalGetKeySharedPhase::Failed { .. }
+        ) {
+            if let Some(age) = state
+                .terminal_at
+                .and_then(|terminal_at| observed_at.checked_duration_since(terminal_at))
+            {
+                let age_us = age.as_micros().min(u64::MAX as u128) as u64;
+                snapshot.terminal_age_count = snapshot.terminal_age_count.saturating_add(1);
+                snapshot.terminal_age_sum_us = snapshot.terminal_age_sum_us.saturating_add(age_us);
+                snapshot.terminal_age_max_us = snapshot.terminal_age_max_us.max(age_us);
+            }
+        }
+    }
+    snapshot
+}
+
 async fn finish_external_get_start_transfer(
     view: crate::client_kv_api::ClientKvApiView,
     transfer_items: Vec<ExternalGetStartOwnerItem>,
@@ -1526,6 +1700,7 @@ fn abandon_unstarted_external_get_key_locked(
     state.phase = ExternalGetKeySharedPhase::Ready {
         result: ExternalGetStartSharedItemResult::Miss,
     };
+    state.terminal_at = Some(Instant::now());
     clear_external_get_key_marker_locked(controls, op);
     true
 }
@@ -1537,7 +1712,9 @@ fn publish_external_get_key_terminal(
 ) {
     {
         let mut controls = inner.owner_key_control.lock_key(&op.key);
-        op.state.lock().phase = phase;
+        let mut state = op.state.lock();
+        state.phase = phase;
+        state.terminal_at = Some(Instant::now());
         clear_external_get_key_marker_locked(&mut controls, op);
     }
     inner.untrack_external_get_flight(op);
@@ -1804,6 +1981,7 @@ async fn classify_external_get_key_leader(
                                 item.error_json,
                             ),
                         };
+                        state.terminal_at = Some(Instant::now());
                         clear_external_get_key_marker_locked(&mut controls, &op);
                         notify_terminal = true;
                         Some(ExternalGetKeyLeaderAction::Terminal)
@@ -2061,14 +2239,17 @@ async fn prepare_external_get_batch_plan(
     let (mut items, leaders) = plan_external_get_key_items(inner, &req.keys).await;
     if !leaders.is_empty() {
         let leader_keys = leaders.iter().map(|op| op.key.clone()).collect::<Vec<_>>();
+        let leader_count = leaders.len();
         let spawn_view = inner.view.clone_view();
         let worker_view = spawn_view.clone();
         let transfer_concurrency = req.transfer_concurrency;
         spawn_view.spawn("external_get_key_singleflight", async move {
+            let batch_start_started_at = Instant::now();
             let start_result = {
                 let worker_inner = worker_view.client_kv_api().inner();
                 batch_get_start_with_local_reserve_targets(worker_inner, &leader_keys).await
             };
+            let batch_start_us = duration_to_i64_us(batch_start_started_at.elapsed());
             match start_result {
                 Ok(start_resp) => {
                     assert_eq!(
@@ -2076,6 +2257,29 @@ async fn prepare_external_get_batch_plan(
                         leaders.len(),
                         "validated BatchGetStart response must match leader count"
                     );
+                    let start_hits = start_resp
+                        .items
+                        .iter()
+                        .filter(|item| item.error_code == OK)
+                        .count();
+                    let start_misses = start_resp
+                        .items
+                        .iter()
+                        .filter(|item| item.error_code == codes_api::API_KEY_NOT_FOUND)
+                        .count();
+                    let start_errors = start_resp
+                        .items
+                        .len()
+                        .saturating_sub(start_hits)
+                        .saturating_sub(start_misses);
+                    tracing::info!(
+                        "external Get leader start lifecycle: leaders={} hits={} misses={} errors={} batch_get_start_us={} outcome=ok",
+                        leader_count,
+                        start_hits,
+                        start_misses,
+                        start_errors,
+                        batch_start_us,
+                    );
                     for (op, item) in leaders.iter().zip(start_resp.items) {
                         publish_external_get_key_started(op, item);
                     }
@@ -2083,6 +2287,12 @@ async fn prepare_external_get_batch_plan(
                         .await;
                 }
                 Err(err) => {
+                    tracing::info!(
+                        "external Get leader start lifecycle: leaders={} hits=0 misses=0 errors={} batch_get_start_us={} outcome=error",
+                        leader_count,
+                        leader_count,
+                        batch_start_us,
+                    );
                     let worker_inner = worker_view.client_kv_api().inner();
                     for op in &leaders {
                         publish_external_get_key_failed(worker_inner, op, &err);
@@ -2567,11 +2777,14 @@ impl HandlerForExternalClient for ClientKvApi {
         }
         let inner = self.inner();
         self.validate_requester_owner_status_updated(req.started_time)?;
+        let observe_started_at = Instant::now();
+        let requested_len = req.keys.len();
 
         let group_lens =
             normalize_external_get_start_group_lens(req.keys.len(), req.atomic_group_lens.clone())?;
         let (prefix, transfer_keys, transfer_items) =
             prepare_external_get_batch_plan(inner, &req, &group_lens).await?;
+        let phase_snapshot = observe_external_get_consume_phases(&transfer_items, Instant::now());
         let handle = inner
             .next_external_get_start_handle
             .fetch_add(1, Ordering::Relaxed);
@@ -2607,11 +2820,36 @@ impl HandlerForExternalClient for ClientKvApi {
                         .map(|member| member.node_start_time),
                     keys: transfer_keys,
                     items: transfer_items,
+                    atomic_group_lens: group_lens,
                     created_at: Instant::now(),
                 },
             );
             ExternalBatchGetStartTransferPlan::OwnerRpc
         };
+        let inline_local = matches!(
+            &transfer_plan,
+            ExternalBatchGetStartTransferPlan::InlineLocal { .. }
+        );
+        tracing::info!(
+            "external Get start lifecycle: handle={} requested={} raw_prefix={} transferable={} inline_local={} local={} starting={} started={} finishing={} revoking={} ready={} failed={} terminal_before_return={} pending_before_return={} terminal_age_mean_us={} terminal_age_max_us={} total_us={}",
+            handle,
+            requested_len,
+            prefix.raw_prefix_hit_len,
+            prefix.transferable_len,
+            inline_local,
+            phase_snapshot.local,
+            phase_snapshot.starting,
+            phase_snapshot.started,
+            phase_snapshot.finishing,
+            phase_snapshot.revoking,
+            phase_snapshot.ready,
+            phase_snapshot.failed,
+            phase_snapshot.terminal_before_consume(),
+            phase_snapshot.pending_before_consume(),
+            phase_snapshot.terminal_age_mean_us(),
+            phase_snapshot.terminal_age_max_us,
+            duration_to_i64_us(observe_started_at.elapsed()),
+        );
 
         Ok(ExternalBatchGetStartResp {
             error_code: OK,
@@ -2633,8 +2871,10 @@ impl HandlerForExternalClient for ClientKvApi {
         }
         let inner = self.inner();
         self.validate_requester_owner_status_updated(req.started_time)?;
+        let consume_started_at = Instant::now();
 
-        let Some((_handle, entry)) = inner.external_get_start_registry.remove(&req.handle) else {
+        let Some((_handle, mut entry)) = inner.external_get_start_registry.remove(&req.handle)
+        else {
             return Err(KvError::Api(ApiError::KeyNotFound {
                 key: format!("external_get_start_handle:{}", req.handle),
             }));
@@ -2647,9 +2887,70 @@ impl HandlerForExternalClient for ClientKvApi {
                 req.req_node_id
             );
         }
+        if let Err(err) = validate_external_get_consume_prefix(
+            req.consume_prefix_len,
+            entry.keys.len(),
+            &entry.atomic_group_lens,
+        ) {
+            inner.external_get_start_registry.insert(req.handle, entry);
+            return Err(err);
+        }
+        assert_eq!(
+            entry.keys.len(),
+            entry.items.len(),
+            "external get-start registry keys and items must stay aligned"
+        );
+        let available_prefix_len = entry.keys.len();
+        let handle_age_us = duration_to_i64_us(entry.created_at.elapsed());
+        let phase_snapshot = observe_external_get_consume_phases(
+            &entry.items[..req.consume_prefix_len],
+            Instant::now(),
+        );
+        let tail_items = entry.items.split_off(req.consume_prefix_len);
+        entry.keys.truncate(req.consume_prefix_len);
+        if !tail_items.is_empty() {
+            tracing::info!(
+                "external_batch_get_transfer consumed prefix and released owner tail: handle={} available={} consumed={} released_tail={}",
+                req.handle,
+                available_prefix_len,
+                req.consume_prefix_len,
+                tail_items.len()
+            );
+        }
+        drop(tail_items);
         let keys = entry.keys;
-        let transfer_results =
-            finish_external_get_start_transfer(inner.view.clone_view(), entry.items, 0).await?;
+        let finish_wait_started_at = Instant::now();
+        let transfer_results_result =
+            finish_external_get_start_transfer(inner.view.clone_view(), entry.items, 0).await;
+        let finish_wait_us = duration_to_i64_us(finish_wait_started_at.elapsed());
+        let transfer_results = match transfer_results_result {
+            Ok(results) => results,
+            Err(err) => {
+                tracing::info!(
+                    "external Get consume lifecycle: handle={} available={} consumed={} released_tail={} handle_age_us={} local_before={} starting_before={} started_before={} finishing_before={} revoking_before={} ready_before={} failed_before={} terminal_before={} pending_before={} terminal_age_mean_us={} terminal_age_max_us={} finish_wait_us={} hits=0 misses=0 errors={} install_us=0 total_us={} outcome=error",
+                    req.handle,
+                    available_prefix_len,
+                    req.consume_prefix_len,
+                    available_prefix_len.saturating_sub(req.consume_prefix_len),
+                    handle_age_us,
+                    phase_snapshot.local,
+                    phase_snapshot.starting,
+                    phase_snapshot.started,
+                    phase_snapshot.finishing,
+                    phase_snapshot.revoking,
+                    phase_snapshot.ready,
+                    phase_snapshot.failed,
+                    phase_snapshot.terminal_before_consume(),
+                    phase_snapshot.pending_before_consume(),
+                    phase_snapshot.terminal_age_mean_us(),
+                    phase_snapshot.terminal_age_max_us,
+                    finish_wait_us,
+                    req.consume_prefix_len,
+                    duration_to_i64_us(consume_started_at.elapsed()),
+                );
+                return Err(err);
+            }
+        };
         if transfer_results.len() != keys.len() {
             return Err(KvError::Api(ApiError::Unknown {
                 detail: format!(
@@ -2659,10 +2960,15 @@ impl HandlerForExternalClient for ClientKvApi {
                 ),
             }));
         }
+        let install_started_at = Instant::now();
         let mut items = Vec::with_capacity(transfer_results.len());
+        let mut hits = 0usize;
+        let mut misses = 0usize;
+        let mut errors = 0usize;
         for (key, item_result) in keys.iter().zip(transfer_results) {
             match item_result {
                 Ok(Some((memholder, _))) => {
+                    hits = hits.saturating_add(1);
                     let external_memholder_info = inner
                         .install_external_get_holding(&req.req_node_id, memholder.memory_info());
                     items.push(ExternalBatchGetItemResp {
@@ -2671,17 +2977,49 @@ impl HandlerForExternalClient for ClientKvApi {
                         external_memholder_info: Some(external_memholder_info),
                     });
                 }
-                Ok(None) => items.push(ExternalBatchGetItemResp {
-                    error_code: codes_api::API_KEY_NOT_FOUND,
-                    error_json: format!("Key not found: {}", key),
-                    external_memholder_info: None,
-                }),
-                Err(err) => items.push(ExternalBatchGetItemResp {
-                    external_memholder_info: None,
-                    ..ExternalBatchGetItemResp::from_error(&err)
-                }),
+                Ok(None) => {
+                    misses = misses.saturating_add(1);
+                    items.push(ExternalBatchGetItemResp {
+                        error_code: codes_api::API_KEY_NOT_FOUND,
+                        error_json: format!("Key not found: {}", key),
+                        external_memholder_info: None,
+                    });
+                }
+                Err(err) => {
+                    errors = errors.saturating_add(1);
+                    items.push(ExternalBatchGetItemResp {
+                        external_memholder_info: None,
+                        ..ExternalBatchGetItemResp::from_error(&err)
+                    });
+                }
             }
         }
+        let install_us = duration_to_i64_us(install_started_at.elapsed());
+        tracing::info!(
+            "external Get consume lifecycle: handle={} available={} consumed={} released_tail={} handle_age_us={} local_before={} starting_before={} started_before={} finishing_before={} revoking_before={} ready_before={} failed_before={} terminal_before={} pending_before={} terminal_age_mean_us={} terminal_age_max_us={} finish_wait_us={} hits={} misses={} errors={} install_us={} total_us={} outcome=ok",
+            req.handle,
+            available_prefix_len,
+            req.consume_prefix_len,
+            available_prefix_len.saturating_sub(req.consume_prefix_len),
+            handle_age_us,
+            phase_snapshot.local,
+            phase_snapshot.starting,
+            phase_snapshot.started,
+            phase_snapshot.finishing,
+            phase_snapshot.revoking,
+            phase_snapshot.ready,
+            phase_snapshot.failed,
+            phase_snapshot.terminal_before_consume(),
+            phase_snapshot.pending_before_consume(),
+            phase_snapshot.terminal_age_mean_us(),
+            phase_snapshot.terminal_age_max_us,
+            finish_wait_us,
+            hits,
+            misses,
+            errors,
+            install_us,
+            duration_to_i64_us(consume_started_at.elapsed()),
+        );
         Ok(ExternalBatchGetTransferResp {
             items,
             error_code: OK,
@@ -2795,16 +3133,7 @@ impl HandlerForExternalClient for ClientKvApi {
             src_offset
         };
         let remote_offset = put_start_resp.target_addr - put_start_resp.target_base_addr;
-        let replica_target =
-            put_start_resp
-                .replica_target
-                .as_ref()
-                .map(|target| ReplicaTaskTarget {
-                    node_id: target.node_id.clone(),
-                    target_offset: target.target_addr - target.target_base_addr,
-                    target_base_addr: target.target_base_addr,
-                    len: target.len,
-                });
+        let replica_admitted = put_start_resp.replica_target.is_some();
         inner.external_pending_puts.insert(
             (
                 req.key.clone(),
@@ -2825,9 +3154,8 @@ impl HandlerForExternalClient for ClientKvApi {
                     remote_offset
                 },
                 len: req.len,
-                make_replica_task: req.make_replica_task && replica_target.is_some(),
+                make_replica_task: req.make_replica_task && replica_admitted,
                 preferred_sub_cluster: req.preferred_sub_cluster.clone(),
-                replica_target,
                 local_reserve_slot: None,
                 local_reserve_slot_size: None,
                 atomic_group: None,
@@ -2915,6 +3243,7 @@ impl HandlerForExternalClient for ClientKvApi {
         let pending_fences = loop {
             let mut pending_fences = Vec::with_capacity(req.items.len());
             let mut wait_for = None;
+            let mut wait_for_local_access = None;
             for item in &req.items {
                 match inner.reserve_external_local_first_put_key(
                     &item.key,
@@ -2942,6 +3271,10 @@ impl HandlerForExternalClient for ClientKvApi {
                         wait_for = Some((item.key.clone(), op));
                         break;
                     }
+                    Ok(ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(completion)) => {
+                        wait_for_local_access = Some((item.key.clone(), completion));
+                        break;
+                    }
                     Err(err) => {
                         let items = req
                             .items
@@ -2956,6 +3289,37 @@ impl HandlerForExternalClient for ClientKvApi {
                     }
                 }
             }
+            if let Some((fenced_key, mut completion)) = wait_for_local_access {
+                // A partial atomic_batch must not hold local-put fences while
+                // the precise source-eviction/reclaim generation drains.  The
+                // watch receiver was subscribed under the per-key lock, so a
+                // rollback/finalize between this drop and changed().await is
+                // observed without polling or a lost wakeup.
+                drop(pending_fences);
+                let wait_started_at = Instant::now();
+                tracing::info!(
+                    fenced_key,
+                    items = req.items.len(),
+                    "external local-first Put waiting for owner source/reclaim fence"
+                );
+                loop {
+                    if *completion.borrow_and_update() {
+                        break;
+                    }
+                    if completion.changed().await.is_err() {
+                        // The state owner disappeared; re-evaluate under the
+                        // key lock instead of treating channel close as success.
+                        break;
+                    }
+                }
+                tracing::info!(
+                    fenced_key,
+                    items = req.items.len(),
+                    wait_us = duration_to_i64_us(wait_started_at.elapsed()),
+                    "external local-first Put resumed after owner source/reclaim fence"
+                );
+                continue;
+            }
             let Some((joined_key, op)) = wait_for else {
                 break pending_fences;
             };
@@ -3043,7 +3407,6 @@ impl HandlerForExternalClient for ClientKvApi {
                     len: req_item.len,
                     make_replica_task: req_item.make_replica_task,
                     preferred_sub_cluster: req_item.preferred_sub_cluster.clone(),
-                    replica_target: None,
                     local_reserve_slot: Some(slot_ref.clone()),
                     local_reserve_slot_size: Some(slot_size),
                     atomic_group: atomic_groups[idx].clone(),
@@ -3121,7 +3484,6 @@ impl HandlerForExternalClient for ClientKvApi {
                 return Ok(ExternalPutTransferEndResp::from_error(&err));
             }
         };
-        let replica_target = pending_ctx.replica_target.clone();
         let admitted_replica_task = pending_ctx.make_replica_task;
         let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
         let req_remote_target = req
@@ -3259,14 +3621,13 @@ impl HandlerForExternalClient for ClientKvApi {
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-        if admitted_replica_task && replica_target.is_some() {
+        if admitted_replica_task {
             if let Err(err) = inner
-                .make_replica_task(
+                .ensure_remote_put(
                     &req.key,
                     put_id,
-                    replica_target
-                        .clone()
-                        .expect("make_replica_task requires pre-reserved replica target"),
+                    pending_ctx.preferred_sub_cluster.clone(),
+                    true,
                 )
                 .await
             {
@@ -3332,7 +3693,6 @@ impl HandlerForExternalClient for ClientKvApi {
             put_locality: Option<(bool, i64)>,
             local_cache_publish: LocalCommittedCachePublish,
             make_replica_task: bool,
-            replica_target: Option<ReplicaTaskTarget>,
             // Keep the per-key reclaim fence alive until the master's terminal
             // response has been applied to the owner-local index.
             _pending_ctx: ExternalPendingPutCtx,
@@ -3496,7 +3856,6 @@ impl HandlerForExternalClient for ClientKvApi {
                 put_locality: Some((false, 0)),
                 local_cache_publish,
                 make_replica_task: pending_ctx.make_replica_task,
-                replica_target: pending_ctx.replica_target.clone(),
                 _pending_ctx: pending_ctx,
             });
         }
@@ -3623,12 +3982,13 @@ impl HandlerForExternalClient for ClientKvApi {
                 pending.put_id.1,
             ));
             if pending.make_replica_task {
-                let target = pending
-                    .replica_target
-                    .clone()
-                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = inner
-                    .make_replica_task(&pending.key, pending.put_id, target)
+                    .ensure_remote_put(
+                        &pending.key,
+                        pending.put_id,
+                        pending._pending_ctx.preferred_sub_cluster.clone(),
+                        true,
+                    )
                     .await
                 {
                     tracing::warn!(
@@ -3720,7 +4080,6 @@ impl HandlerForExternalClient for ClientKvApi {
             }
             return Ok(ExternalPutCommitResp::from_error(&err));
         }
-        let replica_target = pending_ctx.replica_target.clone();
         let admitted_replica_task = pending_ctx.make_replica_task;
 
         let end_started_at = Instant::now();
@@ -3796,14 +4155,13 @@ impl HandlerForExternalClient for ClientKvApi {
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
-        if admitted_replica_task && replica_target.is_some() {
+        if admitted_replica_task {
             if let Err(err) = inner
-                .make_replica_task(
+                .ensure_remote_put(
                     &req.key,
                     put_id,
-                    replica_target
-                        .clone()
-                        .expect("make_replica_task requires pre-reserved replica target"),
+                    pending_ctx.preferred_sub_cluster.clone(),
+                    true,
                 )
                 .await
             {
@@ -3860,7 +4218,6 @@ impl HandlerForExternalClient for ClientKvApi {
             lease_id: Option<u64>,
             local_cache_publish: LocalCommittedCachePublish,
             make_replica_task: bool,
-            replica_target: Option<ReplicaTaskTarget>,
             _pending_ctx: ExternalPendingPutCtx,
         }
 
@@ -4015,7 +4372,6 @@ impl HandlerForExternalClient for ClientKvApi {
                 lease_id: item.lease_id,
                 local_cache_publish,
                 make_replica_task: pending_ctx.make_replica_task,
-                replica_target: pending_ctx.replica_target.clone(),
                 _pending_ctx: pending_ctx,
             });
         }
@@ -4136,12 +4492,13 @@ impl HandlerForExternalClient for ClientKvApi {
                 pending.put_id.1,
             ));
             if pending.make_replica_task {
-                let target = pending
-                    .replica_target
-                    .clone()
-                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = inner
-                    .make_replica_task(&pending.key, pending.put_id, target)
+                    .ensure_remote_put(
+                        &pending.key,
+                        pending.put_id,
+                        pending._pending_ctx.preferred_sub_cluster.clone(),
+                        true,
+                    )
                     .await
                 {
                     tracing::warn!(
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 57c7164..ddc5803 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -256,6 +256,8 @@ impl ClientKvApiInner {
         if keys.is_empty() {
             return Ok(Vec::new());
         }
+        let lifecycle_started_at = Instant::now();
+        let lifecycle_requested_keys = keys.len();
 
         #[derive(Clone)]
         struct DonePending {
@@ -279,6 +281,11 @@ impl ClientKvApiInner {
         let mut done_pending = Vec::new();
         let mut transfer_error_cleanup = Vec::new();
         let mut transfer_futures = Vec::new();
+        let mut lifecycle_zero_copy_items = 0usize;
+        let mut lifecycle_transfer_items = 0usize;
+        let mut lifecycle_remote_transfer_items = 0usize;
+        let mut lifecycle_transfer_bytes = 0u64;
+        let mut lifecycle_remote_transfer_bytes = 0u64;
 
         for (idx, (key, start_item)) in keys.into_iter().zip(start_items.into_iter()).enumerate() {
             if start_item.error_code == codes_api::API_KEY_NOT_FOUND {
@@ -311,6 +318,7 @@ impl ClientKvApiInner {
             let len = start_item.len;
 
             if peer_id.is_none() && src_addr == target_addr {
+                lifecycle_zero_copy_items = lifecycle_zero_copy_items.saturating_add(1);
                 done_pending.push(DonePending {
                     idx,
                     key,
@@ -322,6 +330,14 @@ impl ClientKvApiInner {
                 continue;
             }
 
+            lifecycle_transfer_items = lifecycle_transfer_items.saturating_add(1);
+            lifecycle_transfer_bytes = lifecycle_transfer_bytes.saturating_add(len);
+            if peer_is_remote {
+                lifecycle_remote_transfer_items = lifecycle_remote_transfer_items.saturating_add(1);
+                lifecycle_remote_transfer_bytes =
+                    lifecycle_remote_transfer_bytes.saturating_add(len);
+            }
+
             transfer_futures.push(async move {
                 let transfer_started_at = Instant::now();
                 let transfer_result = self
@@ -353,11 +369,22 @@ impl ClientKvApiInner {
             });
         }
 
+        let lifecycle_plan_us = lifecycle_started_at
+            .elapsed()
+            .as_micros()
+            .min(i64::MAX as u128) as i64;
+        let transfer_wall_started_at = Instant::now();
+        let mut lifecycle_transfer_sum_us = 0u64;
+        let mut lifecycle_transfer_max_us = 0u64;
         let mut transfer_stream =
             stream::iter(transfer_futures).buffer_unordered(transfer_concurrency);
         while let Some(joined) = transfer_stream.next().await {
             match joined {
                 (idx, key, start_item, peer_is_remote, _get_id, transfer_us, Ok(_breakdown)) => {
+                    let transfer_us_u64 = transfer_us.max(0) as u64;
+                    lifecycle_transfer_sum_us =
+                        lifecycle_transfer_sum_us.saturating_add(transfer_us_u64);
+                    lifecycle_transfer_max_us = lifecycle_transfer_max_us.max(transfer_us_u64);
                     done_pending.push(DonePending {
                         idx,
                         key,
@@ -376,14 +403,24 @@ impl ClientKvApiInner {
                 }
             }
         }
+        let lifecycle_transfer_wall_us = transfer_wall_started_at
+            .elapsed()
+            .as_micros()
+            .min(i64::MAX as u128) as i64;
 
+        let transfer_cleanup_started_at = Instant::now();
         finish_started_get_revoke_cleanup(
             self,
             transfer_error_cleanup,
             "batch_get transfer failure",
         )
         .await;
+        let lifecycle_transfer_cleanup_us = transfer_cleanup_started_at
+            .elapsed()
+            .as_micros()
+            .min(i64::MAX as u128) as i64;
 
+        let install_started_at = Instant::now();
         let mut ready_done_pending = Vec::with_capacity(done_pending.len());
         let mut install_failed_cleanup = Vec::new();
         for mut pending in done_pending {
@@ -434,14 +471,20 @@ impl ClientKvApiInner {
             "batch_get pending install failure",
         )
         .await;
+        let lifecycle_install_us = install_started_at
+            .elapsed()
+            .as_micros()
+            .min(i64::MAX as u128) as i64;
 
         let done_get_ids = done_pending
             .iter()
             .map(|pending| pending.start_item.get_id)
             .collect::<Vec<_>>();
+        let lifecycle_done_items = done_get_ids.len();
         let done_first_get_id = done_get_ids.first().copied();
         let done_last_get_id = done_get_ids.last().copied();
         let mut done_attempt = 1u32;
+        let done_started_at = Instant::now();
         let done_resp = loop {
             match self.batch_get_done(done_get_ids.clone()).await {
                 Ok(resp) if batch_get_done_response_matches(&done_get_ids, &resp) => break resp,
@@ -477,6 +520,8 @@ impl ClientKvApiInner {
             .await;
             done_attempt = done_attempt.saturating_add(1);
         };
+        let lifecycle_done_us = done_started_at.elapsed().as_micros().min(i64::MAX as u128) as i64;
+        let publish_started_at = Instant::now();
         let master_node_id: NodeID = self
             .view
             .cluster_manager()
@@ -622,11 +667,12 @@ impl ClientKvApiInner {
 
         // Publish every local index before Moka admission starts selecting
         // individual capacity victims.
+        let lifecycle_local_hot_admissions = local_hot_admissions.len();
         for (key, put_id, memory_info, _atomic_group) in local_hot_admissions {
             self.owner_hot_track_committed(&key, put_id, &memory_info);
         }
 
-        Ok(results
+        let output = results
             .into_iter()
             .map(|item| {
                 item.unwrap_or_else(|| {
@@ -636,7 +682,50 @@ impl ClientKvApiInner {
                     }))
                 })
             })
-            .collect())
+            .collect::<Vec<_>>();
+        let lifecycle_hits = output
+            .iter()
+            .filter(|item| matches!(item, Ok(Some(_))))
+            .count();
+        let lifecycle_misses = output
+            .iter()
+            .filter(|item| matches!(item, Ok(None)))
+            .count();
+        let lifecycle_errors = output.iter().filter(|item| matches!(item, Err(_))).count();
+        let lifecycle_publish_us = publish_started_at
+            .elapsed()
+            .as_micros()
+            .min(i64::MAX as u128) as i64;
+        let lifecycle_total_us = lifecycle_started_at
+            .elapsed()
+            .as_micros()
+            .min(i64::MAX as u128) as i64;
+        tracing::info!(
+            "external Get finish lifecycle: requested={} transfer_concurrency={} zero_copy_items={} transfer_items={} remote_transfer_items={} transfer_bytes={} remote_transfer_bytes={} plan_us={} transfer_wall_us={} transfer_sum_us={} transfer_max_us={} transfer_cleanup_us={} install_us={} done_items={} done_attempts={} done_us={} local_hot_admissions={} publish_us={} hits={} misses={} errors={} total_us={}",
+            lifecycle_requested_keys,
+            transfer_concurrency,
+            lifecycle_zero_copy_items,
+            lifecycle_transfer_items,
+            lifecycle_remote_transfer_items,
+            lifecycle_transfer_bytes,
+            lifecycle_remote_transfer_bytes,
+            lifecycle_plan_us,
+            lifecycle_transfer_wall_us,
+            lifecycle_transfer_sum_us,
+            lifecycle_transfer_max_us,
+            lifecycle_transfer_cleanup_us,
+            lifecycle_install_us,
+            lifecycle_done_items,
+            done_attempt,
+            lifecycle_done_us,
+            lifecycle_local_hot_admissions,
+            lifecycle_publish_us,
+            lifecycle_hits,
+            lifecycle_misses,
+            lifecycle_errors,
+            lifecycle_total_us,
+        );
+        Ok(output)
     }
 
     pub async fn batch_get(
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index fe309a7..fd5a06e 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -3,17 +3,18 @@ use crate::client_kv_api::local_reserve_rebalance::{
     spawn_owner_local_reserve_rebalance_actor, spawn_owner_slot_pressure_actor,
 };
 use crate::client_kv_api::msg_pack::{
-    ExternalBatchGetCancelReq, ExternalBatchGetCancelResp, ExternalBatchGetReq,
-    ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
-    ExternalBatchGetTransferReq, ExternalBatchGetTransferResp, ExternalBatchIsExistReq,
-    ExternalBatchIsExistResp, ExternalBatchPutCommitReq, ExternalBatchPutCommitResp,
-    ExternalBatchPutStartReq, ExternalBatchPutStartResp, ExternalBatchPutTransferEndReq,
-    ExternalBatchPutTransferEndResp, ExternalDeleteAckReq, ExternalDeleteAckResp,
-    ExternalDeleteReq, ExternalDeleteResp, ExternalGetReq, ExternalGetResp, ExternalIsExistReq,
-    ExternalIsExistResp, ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp,
-    ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
-    ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
-    ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
+    ExternalBatchDeleteAckReq, ExternalBatchDeleteAckResp, ExternalBatchGetCancelReq,
+    ExternalBatchGetCancelResp, ExternalBatchGetReq, ExternalBatchGetResp,
+    ExternalBatchGetStartReq, ExternalBatchGetStartResp, ExternalBatchGetTransferReq,
+    ExternalBatchGetTransferResp, ExternalBatchIsExistReq, ExternalBatchIsExistResp,
+    ExternalBatchPutCommitReq, ExternalBatchPutCommitResp, ExternalBatchPutStartReq,
+    ExternalBatchPutStartResp, ExternalBatchPutTransferEndReq, ExternalBatchPutTransferEndResp,
+    ExternalDeleteAckReq, ExternalDeleteAckResp, ExternalDeleteReq, ExternalDeleteResp,
+    ExternalGetReq, ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp,
+    ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp, ExternalPutCommitReq,
+    ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq,
+    ExternalPutStartResp, ExternalPutTransferEndReq, ExternalPutTransferEndResp, SyncKvToFileReq,
+    SyncKvToFileResp, TestPutPhaseTrace,
 };
 use crate::client_kv_api::reclaim::handle_batch_owner_reclaim;
 use crate::cluster_manager::{NodeID, NodeIDString};
@@ -59,18 +60,14 @@ use limit_thirdparty::tokio;
 use moka::notification::RemovalCause;
 use parking_lot::Mutex;
 use std::collections::BTreeSet;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 use std::sync::Weak;
-use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, OnceLock};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tracing::warn;
 
-const REPLICA_TASK_QUEUE_CAPACITY: usize = 128;
-// Queue only weak source references. This preserves a deep policy backlog without turning queued
-// write-back work into non-reclaimable owner memory; the dispatcher pins a still-current source
-// immediately before handing it to the bounded replica-task actor.
 const OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY: usize = 4096;
 const OWNER_LOCAL_PUBLISH_MAX_INFLIGHT: usize = 64;
 
@@ -99,6 +96,18 @@ pub struct OwnerRuntimeObserveSnapshot {
     pub external_get_undecided_interests: u64,
     pub external_get_retained_interests: u64,
     pub external_pending_put_entries: u64,
+    pub remote_put_flights_active: u64,
+    pub remote_put_flight_leaders: u64,
+    pub remote_put_flight_followers: u64,
+    pub remote_put_source_unavailable: u64,
+    pub remote_put_source_fenced: u64,
+    pub remote_put_source_missing: u64,
+    pub remote_put_source_version_mismatch: u64,
+    pub remote_put_transfers: u64,
+    pub remote_put_published: u64,
+    pub remote_put_already_satisfied: u64,
+    pub remote_put_obsolete: u64,
+    pub remote_put_failed: u64,
     pub local_reserve_slots_free: u64,
     pub local_reserve_slots_prepared: u64,
     pub local_reserve_slots_pending_visible: u64,
@@ -242,6 +251,10 @@ pub struct ExternalGetKeySharedState {
     /// Number of those operations whose transferable prefix retained the key.
     pub retained: usize,
     pub phase: ExternalGetKeySharedPhase,
+    /// Monotonic publication time for Ready/Failed.  Observation-only users
+    /// compare this with the later handle-consume time to distinguish data
+    /// that was already ready from time actually spent waiting in Transfer.
+    pub terminal_at: Option<Instant>,
 }
 
 pub struct ExternalGetKeySharedOp {
@@ -258,6 +271,7 @@ impl ExternalGetKeySharedOp {
                 undecided: 1,
                 retained: 0,
                 phase: ExternalGetKeySharedPhase::Starting,
+                terminal_at: None,
             }),
             notify: Arc::new(limit_thirdparty::tokio::sync::Notify::new()),
         }
@@ -292,6 +306,7 @@ pub struct ExternalGetStartEntry {
     pub requester_node_start_time: Option<i64>,
     pub keys: Vec<String>,
     pub items: Vec<ExternalGetStartOwnerItem>,
+    pub atomic_group_lens: Vec<usize>,
     pub created_at: Instant,
 }
 
@@ -924,6 +939,89 @@ async fn handle_external_delete_ack(
         raw_bytes: Vec::new(),
     }
 }
+
+fn release_external_holder_ids_with(
+    holder_ids: Vec<u64>,
+    mut remove: impl FnMut(u64) -> bool,
+) -> (u32, u32) {
+    let mut seen = HashSet::with_capacity(holder_ids.len());
+    let mut released = 0u32;
+    let mut missing = 0u32;
+    for holder_id in holder_ids {
+        if !seen.insert(holder_id) {
+            continue;
+        }
+        if remove(holder_id) {
+            released = released.saturating_add(1);
+        } else {
+            missing = missing.saturating_add(1);
+        }
+    }
+    (released, missing)
+}
+
+async fn handle_external_batch_delete_ack(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchDeleteAckReq>,
+) -> MsgPack<ExternalBatchDeleteAckResp> {
+    let req = msg.serialize_part.clone();
+    let expected = view.cluster_manager().get_self_info().node_start_time;
+    if req.started_time != 0 && req.started_time != expected {
+        let err = crate::rpcresp_kvresult_convert::msg_and_error::KvError::Api(
+            crate::rpcresp_kvresult_convert::msg_and_error::ApiError::OwnerStartTimeMismatch {
+                expected,
+                got: req.started_time,
+            },
+        );
+        return MsgPack {
+            serialize_part: ExternalBatchDeleteAckResp::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    }
+
+    let inner = view.client_kv_api().inner();
+    let external_client_id = req.external_client_id;
+    let requested_count = req.holder_ids.len();
+    let (released_count, missing_count) =
+        release_external_holder_ids_with(req.holder_ids, |holder_id| {
+            inner
+                .external_get_holding
+                .remove(&NodeHolderKey::new(external_client_id.clone(), holder_id))
+                .is_some()
+        });
+    tracing::debug!(
+        external_client_id,
+        requested_count,
+        released_count,
+        missing_count,
+        "processed external holder ACK batch"
+    );
+    MsgPack {
+        serialize_part: ExternalBatchDeleteAckResp {
+            released_count,
+            missing_count,
+            error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+#[cfg(test)]
+mod external_delete_ack_batch_tests {
+    use super::release_external_holder_ids_with;
+    use std::collections::HashSet;
+
+    #[test]
+    fn duplicate_and_missing_holder_ids_are_idempotent() {
+        let mut live = HashSet::from([3u64, 5u64]);
+        let (released, missing) =
+            release_external_holder_ids_with(vec![3, 3, 4, 5], |holder_id| live.remove(&holder_id));
+        assert_eq!((released, missing), (2, 1));
+        assert!(live.is_empty());
+    }
+}
+
 async fn handle_external_delete(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalDeleteReq>,
@@ -1285,6 +1383,22 @@ struct OwnerHotCacheCounters {
     legacy_put_done_items: AtomicU64,
 }
 
+#[derive(Default)]
+struct OwnerRemotePutCounters {
+    active: AtomicU64,
+    leaders: AtomicU64,
+    followers: AtomicU64,
+    source_unavailable: AtomicU64,
+    source_fenced: AtomicU64,
+    source_missing: AtomicU64,
+    source_version_mismatch: AtomicU64,
+    transfers: AtomicU64,
+    published: AtomicU64,
+    already_satisfied: AtomicU64,
+    obsolete: AtomicU64,
+    failed: AtomicU64,
+}
+
 struct OwnerHotSelectionDebt {
     weight_bytes: u64,
     outstanding_bytes: Arc<AtomicU64>,
@@ -1568,6 +1682,110 @@ pub(crate) struct ExternalPutKeySharedOp {
     outcome: watch::Sender<ExternalPutKeyOutcome>,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum OwnerRemotePutOutcome {
+    InFlight,
+    Published,
+    AlreadySatisfied,
+    Obsolete,
+    Failed,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct OwnerRemotePutRequest {
+    pub preferred_sub_cluster: Option<String>,
+    pub protect_source_on_remote_complete: bool,
+}
+
+/// One owner-initiated remote write for an exact local generation.
+///
+/// Every trigger (normal Put, pre-reserved replica, proactive write-back, and
+/// tier1) joins this same operation.  The trigger is deliberately absent from
+/// the identity so policy labels cannot create a second payload transfer.
+pub(crate) struct OwnerRemotePutSharedOp {
+    pub key: String,
+    pub put_id: crate::master_kv_router::put::PutIDForAKey,
+    request: Mutex<OwnerRemotePutRequest>,
+    outcome: watch::Sender<OwnerRemotePutOutcome>,
+    completed: AtomicBool,
+}
+
+impl OwnerRemotePutSharedOp {
+    fn new(
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        preferred_sub_cluster: Option<String>,
+        protect_source_on_remote_complete: bool,
+    ) -> Arc<Self> {
+        let (outcome, _receiver) = watch::channel(OwnerRemotePutOutcome::InFlight);
+        Arc::new(Self {
+            key: key.to_string(),
+            put_id,
+            request: Mutex::new(OwnerRemotePutRequest {
+                preferred_sub_cluster,
+                protect_source_on_remote_complete,
+            }),
+            outcome,
+            completed: AtomicBool::new(false),
+        })
+    }
+
+    fn merge_request(
+        &self,
+        preferred_sub_cluster: Option<String>,
+        protect_source_on_remote_complete: bool,
+    ) {
+        let mut request = self.request.lock();
+        if request.preferred_sub_cluster.is_none() {
+            request.preferred_sub_cluster = preferred_sub_cluster;
+        }
+        request.protect_source_on_remote_complete |= protect_source_on_remote_complete;
+    }
+
+    pub(crate) fn request(&self) -> OwnerRemotePutRequest {
+        self.request.lock().clone()
+    }
+
+    pub(crate) fn outcome(&self) -> OwnerRemotePutOutcome {
+        *self.outcome.borrow()
+    }
+
+    fn complete(&self, outcome: OwnerRemotePutOutcome) -> bool {
+        debug_assert_ne!(outcome, OwnerRemotePutOutcome::InFlight);
+        if self
+            .completed
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_err()
+        {
+            return false;
+        }
+        self.outcome.send_replace(outcome);
+        true
+    }
+
+    pub(crate) async fn wait(&self) -> OwnerRemotePutOutcome {
+        let mut outcome = self.outcome.subscribe();
+        loop {
+            let current = *outcome.borrow_and_update();
+            if current != OwnerRemotePutOutcome::InFlight {
+                return current;
+            }
+            if outcome.changed().await.is_err() {
+                return OwnerRemotePutOutcome::Failed;
+            }
+        }
+    }
+}
+
+pub(crate) enum OwnerRemotePutReservation {
+    Leader {
+        op: Arc<OwnerRemotePutSharedOp>,
+        memory_info: Arc<MemoryInfo>,
+    },
+    Follower(Arc<OwnerRemotePutSharedOp>),
+    SourceUnavailable,
+}
+
 impl ExternalPutKeySharedOp {
     fn new() -> Arc<Self> {
         let (outcome, _receiver) = watch::channel(ExternalPutKeyOutcome::InFlight);
@@ -1598,6 +1816,11 @@ impl ExternalPutKeySharedOp {
 pub(crate) enum ExternalLocalFirstPutKeyReservation {
     Leader(Arc<ExternalPendingPutFenceGuard>),
     Wait(Arc<ExternalPutKeySharedOp>),
+    /// A committed owner-local source is between precise source selection and
+    /// reclaim completion/rollback.  The caller owns only a watch receiver:
+    /// it holds no key fence or physical slot while asynchronously waiting to
+    /// re-evaluate the complete atomic_batch.
+    WaitForLocalAccess(watch::Receiver<bool>),
 }
 
 #[derive(Default)]
@@ -1611,6 +1834,10 @@ pub(crate) struct OwnerKeyControlState {
     /// The reject-on-inflight local-first Put leader for this key. Followers
     /// subscribe to its terminal result without claiming another slot.
     external_put: Option<Arc<ExternalPutKeySharedOp>>,
+    /// Exact-generation owner-side remote Put singleflight.  Unlike
+    /// `external_put`, this remains active after local publication until the
+    /// remote Start/transfer/Done state machine reaches a terminal outcome.
+    remote_put: Option<Arc<OwnerRemotePutSharedOp>>,
     /// Owner-local pre-Prepare fence installed by the Moka source-eviction
     /// dispatcher.  The matching committed index is moved into this record,
     /// so a new local Get cannot acquire the source between victim selection
@@ -1621,6 +1848,10 @@ pub(crate) struct OwnerKeyControlState {
     /// the same fence as local visibility and reclaim so `R ∩ local`,
     /// `R ∩ inflight`, and new leaders are classified atomically.
     external_get: Option<Arc<ExternalGetKeySharedOp>>,
+    /// Completion channel for the exact source-selection/reclaim fence.  A
+    /// receiver subscribed under the key-shard lock cannot miss completion,
+    /// even if the fence clears before the waiter is first polled.
+    local_access_fence: Option<watch::Sender<bool>>,
 }
 
 impl OwnerKeyControlState {
@@ -1632,9 +1863,50 @@ impl OwnerKeyControlState {
         self.local_puts == 0
             && self.external_pending_puts == 0
             && self.external_put.is_none()
+            && self.remote_put.is_none()
             && self.source_eviction_selection.is_none()
             && self.reclaim.is_none()
             && self.external_get.is_none()
+            && self.local_access_fence.is_none()
+    }
+
+    fn begin_local_access_fence(&mut self) {
+        assert!(
+            self.local_access_fence.is_none(),
+            "one key cannot install two owner local-access fence generations"
+        );
+        let (completion, _receiver) = watch::channel(false);
+        self.local_access_fence = Some(completion);
+    }
+
+    fn subscribe_local_access_fence(&self) -> watch::Receiver<bool> {
+        assert!(
+            self.local_access_fenced(),
+            "local-access waiter requires an active source/reclaim fence"
+        );
+        self.local_access_fence
+            .as_ref()
+            .expect("active source/reclaim fence must own a completion channel")
+            .subscribe()
+    }
+
+    fn finish_local_access_fence(&mut self) {
+        assert!(
+            !self.local_access_fenced(),
+            "local-access completion cannot publish before the source/reclaim fence clears"
+        );
+        if let Some(completion) = self.local_access_fence.take() {
+            completion.send_replace(true);
+        }
+    }
+
+    fn install_remote_put_leader(&mut self, op: Arc<OwnerRemotePutSharedOp>) {
+        if let Some(displaced) = self.remote_put.replace(op.clone()) {
+            assert_ne!(
+                displaced.put_id, op.put_id,
+                "a matching remote Put generation must join instead of being replaced"
+            );
+        }
     }
 }
 
@@ -2109,6 +2381,7 @@ pub struct ClientKvApiInner {
     owner_source_eviction_selected:
         Arc<DashMap<OwnerHotReplicaIdentity, Arc<OwnerHotSelectionDebt>>>,
     owner_hot_counters: Arc<OwnerHotCacheCounters>,
+    owner_remote_put_counters: Arc<OwnerRemotePutCounters>,
     owner_hot_retry_queue: Arc<OwnerHotRetryQueue>,
     owner_hot_eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionDispatch>,
     owner_hot_eviction_rx:
@@ -2185,8 +2458,6 @@ pub struct ClientKvApiInner {
     external_pending_puts: moka::sync::SegmentedCache<(String, u64, u32), ExternalPendingPutCtx>,
     owner_local_publish_tx: tokio::sync::ampsc::Sender<OwnerLocalPublishJob>,
     owner_local_publish_rx: Mutex<Option<tokio::sync::ampsc::Receiver<OwnerLocalPublishJob>>>,
-    replica_task_tx: tokio::sync::ampsc::Sender<ReplicaTaskJob>,
-    replica_task_rx: Mutex<Option<tokio::sync::ampsc::Receiver<ReplicaTaskJob>>>,
 }
 
 impl ClientKvApiInner {
@@ -2287,6 +2558,7 @@ impl ClientKvApiInner {
             replaced.is_none(),
             "rolling back an owner source selection must restore an empty local index"
         );
+        state.finish_local_access_fence();
         if state.is_idle() {
             controls.remove(&identity.key);
         }
@@ -2331,6 +2603,7 @@ impl ClientKvApiInner {
         let control_busy = controls.get(&identity.key).is_some_and(|state| {
             state.local_puts != 0
                 || state.external_pending_puts != 0
+                || state.remote_put.is_some()
                 || state.external_get.is_some()
                 || state.local_access_fenced()
         });
@@ -2357,6 +2630,8 @@ impl ClientKvApiInner {
 
         let state = controls.entry(identity.key.clone()).or_default();
         assert!(state.source_eviction_selection.is_none());
+        assert!(state.reclaim.is_none());
+        state.begin_local_access_fence();
         state.source_eviction_selection = Some(OwnerSourceEvictionSelection {
             put_id: (identity.put_time_ms, identity.put_version),
             cached_info,
@@ -2552,13 +2827,19 @@ impl ClientKvApiInner {
         reject_if_exist_same_key: bool,
     ) -> KvResult<ExternalLocalFirstPutKeyReservation> {
         let mut controls = self.owner_key_control.lock_key(key);
-        if controls
-            .get(key)
-            .is_some_and(|state| state.local_access_fenced())
+        let reusable_singleflight = reject_if_inflight_same_key && reject_if_exist_same_key;
+        if let Some(state) = controls.get(key)
+            && state.local_access_fenced()
         {
-            return Err(KvError::Api(ApiError::KeyBeingWritten {
-                key: key.to_string(),
-            }));
+            return if reusable_singleflight {
+                Ok(ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(
+                    state.subscribe_local_access_fence(),
+                ))
+            } else {
+                Err(KvError::Api(ApiError::KeyBeingWritten {
+                    key: key.to_string(),
+                }))
+            };
         }
         if reject_if_exist_same_key
             && (self.precommit_local_visible_info.contains_key(key)
@@ -2571,7 +2852,6 @@ impl ClientKvApiInner {
             }));
         }
         let state = controls.entry(key.to_string()).or_default();
-        let reusable_singleflight = reject_if_inflight_same_key && reject_if_exist_same_key;
         if reject_if_inflight_same_key && state.local_puts > 0 {
             return (reusable_singleflight)
                 .then(|| state.external_put.clone())
@@ -2709,6 +2989,144 @@ impl ClientKvApiInner {
         })
     }
 
+    pub(crate) fn begin_owner_remote_put(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        preferred_sub_cluster: Option<String>,
+        protect_source_on_remote_complete: bool,
+    ) -> OwnerRemotePutReservation {
+        let mut controls = self.owner_key_control.lock_key(key);
+
+        if let Some(existing) = controls.get(key).and_then(|state| state.remote_put.clone()) {
+            if existing.put_id == put_id && existing.outcome() == OwnerRemotePutOutcome::InFlight {
+                existing.merge_request(preferred_sub_cluster, protect_source_on_remote_complete);
+                self.owner_remote_put_counters
+                    .followers
+                    .fetch_add(1, Ordering::Relaxed);
+                return OwnerRemotePutReservation::Follower(existing);
+            }
+            if existing.outcome() != OwnerRemotePutOutcome::InFlight {
+                let state = controls
+                    .get_mut(key)
+                    .expect("terminal remote Put flight control state disappeared");
+                if state
+                    .remote_put
+                    .as_ref()
+                    .is_some_and(|current| Arc::ptr_eq(current, &existing))
+                {
+                    state.remote_put = None;
+                }
+            }
+            // A newer local generation may publish before the old remote task
+            // observes Obsolete.  The new generation may replace the visible
+            // per-key flight slot after its exact source is verified below;
+            // the displaced task keeps its own holder and its pointer-checked
+            // completion cannot clear the replacement.
+        }
+
+        if controls
+            .get(key)
+            .is_some_and(|state| state.local_access_fenced())
+        {
+            self.owner_remote_put_counters
+                .source_unavailable
+                .fetch_add(1, Ordering::Relaxed);
+            self.owner_remote_put_counters
+                .source_fenced
+                .fetch_add(1, Ordering::Relaxed);
+            return OwnerRemotePutReservation::SourceUnavailable;
+        }
+        let memory_info = match self.get_cached_info.get(key) {
+            Some(info) if (info.put_time_ms, info.put_version) == put_id => info.mem_holder.clone(),
+            Some(_) => {
+                self.owner_remote_put_counters
+                    .source_unavailable
+                    .fetch_add(1, Ordering::Relaxed);
+                self.owner_remote_put_counters
+                    .source_version_mismatch
+                    .fetch_add(1, Ordering::Relaxed);
+                return OwnerRemotePutReservation::SourceUnavailable;
+            }
+            None => {
+                self.owner_remote_put_counters
+                    .source_unavailable
+                    .fetch_add(1, Ordering::Relaxed);
+                self.owner_remote_put_counters
+                    .source_missing
+                    .fetch_add(1, Ordering::Relaxed);
+                return OwnerRemotePutReservation::SourceUnavailable;
+            }
+        };
+
+        let op = OwnerRemotePutSharedOp::new(
+            key,
+            put_id,
+            preferred_sub_cluster,
+            protect_source_on_remote_complete,
+        );
+        let state = controls.entry(key.to_string()).or_default();
+        state.install_remote_put_leader(op.clone());
+        self.owner_remote_put_counters
+            .active
+            .fetch_add(1, Ordering::Relaxed);
+        self.owner_remote_put_counters
+            .leaders
+            .fetch_add(1, Ordering::Relaxed);
+        OwnerRemotePutReservation::Leader { op, memory_info }
+    }
+
+    pub(crate) fn finish_owner_remote_put(
+        &self,
+        op: &Arc<OwnerRemotePutSharedOp>,
+        outcome: OwnerRemotePutOutcome,
+    ) -> bool {
+        if !op.complete(outcome) {
+            return false;
+        }
+
+        let mut controls = self.owner_key_control.lock_key(&op.key);
+        let remove_control = if let Some(state) = controls.get_mut(&op.key) {
+            if state
+                .remote_put
+                .as_ref()
+                .is_some_and(|current| Arc::ptr_eq(current, op))
+            {
+                state.remote_put = None;
+            }
+            state.is_idle()
+        } else {
+            false
+        };
+        if remove_control {
+            controls.remove(&op.key);
+        }
+        drop(controls);
+
+        self.owner_remote_put_counters
+            .active
+            .fetch_sub(1, Ordering::Relaxed);
+        let terminal_counter = match outcome {
+            OwnerRemotePutOutcome::InFlight => {
+                unreachable!("remote Put cannot finish with an inflight outcome")
+            }
+            OwnerRemotePutOutcome::Published => &self.owner_remote_put_counters.published,
+            OwnerRemotePutOutcome::AlreadySatisfied => {
+                &self.owner_remote_put_counters.already_satisfied
+            }
+            OwnerRemotePutOutcome::Obsolete => &self.owner_remote_put_counters.obsolete,
+            OwnerRemotePutOutcome::Failed => &self.owner_remote_put_counters.failed,
+        };
+        terminal_counter.fetch_add(1, Ordering::Relaxed);
+        true
+    }
+
+    pub(crate) fn record_owner_remote_put_transfer(&self) {
+        self.owner_remote_put_counters
+            .transfers
+            .fetch_add(1, Ordering::Relaxed);
+    }
+
     fn local_visible_mem_holder_unfenced(&self, key: &str) -> Option<Arc<MemoryInfo>> {
         if let Some(info) = self.precommit_local_visible_info.get(key) {
             return Some(info.mem_holder.clone());
@@ -3189,7 +3607,6 @@ pub struct ExternalPendingPutCtx {
     pub len: u64,
     pub make_replica_task: bool,
     pub preferred_sub_cluster: Option<String>,
-    pub replica_target: Option<ReplicaTaskTarget>,
     pub local_reserve_slot: Option<OwnerLocalReserveSlotRef>,
     pub local_reserve_slot_size: Option<u64>,
     pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
@@ -3198,26 +3615,6 @@ pub struct ExternalPendingPutCtx {
     pub(crate) _pending_fence: Arc<ExternalPendingPutFenceGuard>,
 }
 
-#[derive(Debug, Clone)]
-pub(crate) struct ReplicaTaskTarget {
-    pub node_id: String,
-    pub target_offset: u64,
-    pub target_base_addr: u64,
-    pub len: u64,
-}
-
-pub(crate) struct ReplicaTaskJob {
-    pub key: String,
-    pub put_id: crate::master_kv_router::put::PutIDForAKey,
-    /// Replica tasks are independent hit-rate work and keep their transfer
-    /// source alive until the transfer finishes. Capacity eviction never enters
-    /// this queue.
-    pub holder: Option<Arc<UserMemHolder>>,
-    pub target: Option<ReplicaTaskTarget>,
-    pub preferred_sub_cluster: Option<String>,
-    pub protect_source_on_remote_complete: bool,
-}
-
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) enum OwnerLocalReserveSlotState {
     Free,
@@ -3835,16 +4232,19 @@ impl OwnerLocalReserveClassState {
 #[cfg(test)]
 mod owner_reclaim_slot_tests {
     use super::{
-        ExternalLocalFirstPutKeyReservation, ExternalPendingPutCtx, ExternalPendingPutFenceGuard,
-        ExternalPutKeyOutcome, ExternalPutKeySharedOp, OwnerHotCacheCounters, OwnerHotCacheEntry,
+        ApiError, ClientKvApi, ClientKvApiNewArg, ExternalLocalFirstPutKeyReservation,
+        ExternalPendingPutCtx, ExternalPendingPutFenceGuard, ExternalPutKeyOutcome,
+        ExternalPutKeySharedOp, KvError, OwnerHotCacheCounters, OwnerHotCacheEntry,
         OwnerHotEvictionDispatch, OwnerHotEvictionEvent, OwnerHotPinAlias, OwnerHotReplicaIdentity,
         OwnerHotRetryQueue, OwnerHotSelectionDebt, OwnerHotSelectionFenceOutcome,
         OwnerKeyControlState, OwnerKeyControlTable, OwnerLocalReserveGrantState,
         OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, OwnerLocalReserveSlotState,
-        OwnerReclaimRecord, acquire_external_pending_put_fence_for_key,
+        OwnerReclaimRecord, OwnerRemotePutOutcome, OwnerRemotePutReservation,
+        OwnerRemotePutSharedOp, acquire_external_pending_put_fence_for_key,
         allocate_external_holding_id, build_owner_hot_cache, clone_if_owner_hot_entry_matches,
         owner_hot_source_has_active_holders, pin_current_owner_hot_source_from_index,
     };
+    use crate::config::TestSpecConfig;
     use crate::master_kv_router::msg_pack::{
         BatchOwnerReclaimReq, OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimItemState,
         OwnerReclaimPhase, OwnerReclaimReason, OwnerSourceEvictionVictim,
@@ -3905,9 +4305,11 @@ mod owner_reclaim_slot_tests {
                 local_puts: 1,
                 external_pending_puts: 1,
                 external_put: None,
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
+                local_access_fence: None,
             },
         );
         let guard = Arc::new(ExternalPendingPutFenceGuard {
@@ -3935,9 +4337,11 @@ mod owner_reclaim_slot_tests {
                 local_puts: 1,
                 external_pending_puts: 1,
                 external_put: Some(op.clone()),
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
+                local_access_fence: None,
             },
         );
         let leader = Arc::new(ExternalPendingPutFenceGuard {
@@ -3972,9 +4376,11 @@ mod owner_reclaim_slot_tests {
                 local_puts: 1,
                 external_pending_puts: 1,
                 external_put: Some(op.clone()),
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
+                local_access_fence: None,
             },
         );
         let leader = Arc::new(ExternalPendingPutFenceGuard {
@@ -3998,6 +4404,182 @@ mod owner_reclaim_slot_tests {
         assert!(controls.lock_key(key).get(key).is_none());
     }
 
+    #[limit_thirdparty::tokio::test]
+    async fn every_remote_put_trigger_joins_one_owner_generation_flight() {
+        let key = "remote-put-singleflight";
+        let put_id = (77, 3);
+        let api = ClientKvApi::construct(ClientKvApiNewArg {
+            test_spec_config: TestSpecConfig::default(),
+            owner_hot_cache_capacity_bytes: None,
+        })
+        .await
+        .expect("construct test ClientKvApi");
+        let op = OwnerRemotePutSharedOp::new(key, put_id, None, false);
+        api.inner().owner_key_control.lock_key(key).insert(
+            key.to_string(),
+            OwnerKeyControlState {
+                remote_put: Some(op.clone()),
+                ..Default::default()
+            },
+        );
+        api.inner()
+            .owner_remote_put_counters
+            .active
+            .store(1, Ordering::Relaxed);
+        api.inner()
+            .owner_remote_put_counters
+            .leaders
+            .store(1, Ordering::Relaxed);
+
+        for follower in 0..64 {
+            let preferred = (follower == 0).then(|| "tier1".to_string());
+            let protect_source = follower == 63;
+            match api
+                .inner()
+                .begin_owner_remote_put(key, put_id, preferred, protect_source)
+            {
+                OwnerRemotePutReservation::Follower(joined) => {
+                    assert!(Arc::ptr_eq(&joined, &op));
+                }
+                OwnerRemotePutReservation::Leader { .. } => {
+                    panic!("a follower created a second remote Put leader")
+                }
+                OwnerRemotePutReservation::SourceUnavailable => {
+                    panic!("a matching active remote Put flight was not reusable")
+                }
+            }
+        }
+
+        let request = op.request();
+        assert_eq!(request.preferred_sub_cluster.as_deref(), Some("tier1"));
+        assert!(request.protect_source_on_remote_complete);
+        assert_eq!(
+            api.inner()
+                .owner_remote_put_counters
+                .followers
+                .load(Ordering::Relaxed),
+            64
+        );
+        assert!(matches!(
+            api.inner()
+                .begin_owner_remote_put(key, (78, 0), None, false),
+            OwnerRemotePutReservation::SourceUnavailable
+        ));
+
+        assert!(
+            api.inner()
+                .finish_owner_remote_put(&op, OwnerRemotePutOutcome::Published)
+        );
+        assert!(
+            !api.inner()
+                .finish_owner_remote_put(&op, OwnerRemotePutOutcome::Failed)
+        );
+        assert_eq!(
+            ::tokio::time::timeout(Duration::from_secs(1), op.wait())
+                .await
+                .expect("remote Put followers must observe the terminal result"),
+            OwnerRemotePutOutcome::Published
+        );
+        assert!(
+            api.inner()
+                .owner_key_control
+                .lock_key(key)
+                .get(key)
+                .is_none()
+        );
+        assert_eq!(
+            api.inner()
+                .owner_remote_put_counters
+                .active
+                .load(Ordering::Relaxed),
+            0
+        );
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn new_remote_put_generation_replaces_old_without_aba_cleanup() {
+        let key = "remote-put-generation-aba";
+        let api = ClientKvApi::construct(ClientKvApiNewArg {
+            test_spec_config: TestSpecConfig::default(),
+            owner_hot_cache_capacity_bytes: None,
+        })
+        .await
+        .expect("construct test ClientKvApi");
+        let old = OwnerRemotePutSharedOp::new(key, (80, 0), None, false);
+        let new = OwnerRemotePutSharedOp::new(key, (81, 0), None, false);
+        api.inner().owner_key_control.lock_key(key).insert(
+            key.to_string(),
+            OwnerKeyControlState {
+                remote_put: Some(old.clone()),
+                ..Default::default()
+            },
+        );
+        api.inner()
+            .owner_remote_put_counters
+            .active
+            .store(2, Ordering::Relaxed);
+        api.inner()
+            .owner_key_control
+            .lock_key(key)
+            .get_mut(key)
+            .expect("old generation control state")
+            .install_remote_put_leader(new.clone());
+        let current = api
+            .inner()
+            .owner_key_control
+            .lock_key(key)
+            .get(key)
+            .and_then(|state| state.remote_put.clone())
+            .expect("new generation must own the visible flight slot");
+        assert!(Arc::ptr_eq(&current, &new));
+        assert_eq!(
+            api.inner()
+                .owner_remote_put_counters
+                .active
+                .load(Ordering::Relaxed),
+            2
+        );
+
+        assert!(
+            api.inner()
+                .finish_owner_remote_put(&old, OwnerRemotePutOutcome::Obsolete)
+        );
+        let current = api
+            .inner()
+            .owner_key_control
+            .lock_key(key)
+            .get(key)
+            .and_then(|state| state.remote_put.clone())
+            .expect("old completion must retain the new generation flight");
+        assert!(Arc::ptr_eq(&current, &new));
+        assert_eq!(
+            api.inner()
+                .owner_remote_put_counters
+                .active
+                .load(Ordering::Relaxed),
+            1
+        );
+
+        assert!(
+            api.inner()
+                .finish_owner_remote_put(&new, OwnerRemotePutOutcome::Published)
+        );
+        assert!(
+            api.inner()
+                .owner_key_control
+                .lock_key(key)
+                .get(key)
+                .is_none()
+        );
+        assert_eq!(
+            api.inner()
+                .owner_remote_put_counters
+                .active
+                .load(Ordering::Relaxed),
+            0
+        );
+    }
+
     #[test]
     fn failed_local_slot_release_keeps_key_fence_closed() {
         let controls = controls_with_state(
@@ -4006,9 +4588,11 @@ mod owner_reclaim_slot_tests {
                 local_puts: 1,
                 external_pending_puts: 1,
                 external_put: None,
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
+                local_access_fence: None,
             },
         );
         let guard = Arc::new(ExternalPendingPutFenceGuard {
@@ -4036,9 +4620,11 @@ mod owner_reclaim_slot_tests {
                 local_puts: 1,
                 external_pending_puts: 1,
                 external_put: None,
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
+                local_access_fence: None,
             },
         );
         let guard = Arc::new(ExternalPendingPutFenceGuard {
@@ -4089,7 +4675,6 @@ mod owner_reclaim_slot_tests {
                 len: 1,
                 make_replica_task: false,
                 preferred_sub_cluster: None,
-                replica_target: None,
                 local_reserve_slot: None,
                 local_reserve_slot_size: None,
                 atomic_group: None,
@@ -4177,6 +4762,9 @@ mod owner_reclaim_slot_tests {
             ExternalLocalFirstPutKeyReservation::Wait(_) => {
                 panic!("the first same-key Put cannot be a follower")
             }
+            ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(_) => {
+                panic!("an unfenced key cannot wait for local access")
+            }
         };
         let join_probe_waiter = match inner
             .reserve_external_local_first_put_key("put-join-probe", true, true)
@@ -4186,6 +4774,9 @@ mod owner_reclaim_slot_tests {
             ExternalLocalFirstPutKeyReservation::Leader(_) => {
                 panic!("the second same-key Put must not claim a second leader fence")
             }
+            ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(_) => {
+                panic!("a local-Put follower must wait on the leader result")
+            }
         };
         join_probe_leader.mark_local_put_succeeded();
         assert_eq!(
@@ -4252,6 +4843,40 @@ mod owner_reclaim_slot_tests {
             acquire_external_pending_put_fence_for_key(&inner.owner_key_control, key).is_err(),
             "a new local Put must not cross a source-selection fence"
         );
+        let rollback_waiter = match inner
+            .reserve_external_local_first_put_key(key, true, true)
+            .expect("idempotent local-first Put must asynchronously wait for source selection")
+        {
+            ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(waiter) => waiter,
+            ExternalLocalFirstPutKeyReservation::Leader(_) => {
+                panic!("a source-fenced key cannot claim a local-Put leader")
+            }
+            ExternalLocalFirstPutKeyReservation::Wait(_) => {
+                panic!("a source-fenced key has no local-Put leader to join")
+            }
+        };
+        let second_rollback_waiter = match inner
+            .reserve_external_local_first_put_key(key, true, true)
+            .expect("all idempotent local-first Puts must share the fence completion")
+        {
+            ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(waiter) => waiter,
+            _ => panic!("a second source-fence waiter must not claim a Put fence"),
+        };
+        let cancelled_rollback_waiter = match inner
+            .reserve_external_local_first_put_key(key, true, true)
+            .expect("a cancellable Put may subscribe to the same fence completion")
+        {
+            ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(waiter) => waiter,
+            _ => panic!("a cancellable source-fence waiter must not claim a Put fence"),
+        };
+        // Simulate an external RPC being cancelled before reclaim completes.
+        // Dropping one receiver must neither retain the physical source nor
+        // prevent the shared generation from waking the remaining waiters.
+        drop(cancelled_rollback_waiter);
+        assert!(matches!(
+            inner.reserve_external_local_first_put_key(key, true, false),
+            Err(KvError::Api(ApiError::KeyBeingWritten { .. }))
+        ));
         drop(source);
         let master_id = master
             .cluster_manager_view()
@@ -4333,6 +4958,25 @@ mod owner_reclaim_slot_tests {
             inner.local_visible_mem_holder(key).is_some(),
             "Abort must restore the exact committed local index"
         );
+        for mut waiter in [rollback_waiter, second_rollback_waiter] {
+            ::tokio::time::timeout(Duration::from_secs(1), async {
+                loop {
+                    if *waiter.borrow_and_update() {
+                        break;
+                    }
+                    waiter
+                        .changed()
+                        .await
+                        .expect("rollback completion sender must remain live");
+                }
+            })
+            .await
+            .expect("Abort must wake every live source-fence Put waiter");
+        }
+        assert!(matches!(
+            inner.reserve_external_local_first_put_key(key, true, true),
+            Err(KvError::Api(ApiError::KeyAlreadyExists { .. }))
+        ));
 
         let trigger_weak = {
             let cached = inner
@@ -4382,6 +5026,13 @@ mod owner_reclaim_slot_tests {
                 ),
             )
         );
+        let mut direct_delete_waiter = match inner
+            .reserve_external_local_first_put_key(key, true, true)
+            .expect("direct-delete source fence must expose an async waiter")
+        {
+            ExternalLocalFirstPutKeyReservation::WaitForLocalAccess(waiter) => waiter,
+            _ => panic!("direct-delete source fence must not admit a local Put"),
+        };
         super::reclaim::complete_owner_source_eviction(
             inner,
             &OwnerSourceEvictionVictim {
@@ -4398,6 +5049,27 @@ mod owner_reclaim_slot_tests {
             inner.owner_key_control.lock_key(key).get(key).is_none(),
             "direct local completion must clear the source fence in one call"
         );
+        ::tokio::time::timeout(Duration::from_secs(1), async {
+            loop {
+                if *direct_delete_waiter.borrow_and_update() {
+                    break;
+                }
+                direct_delete_waiter
+                    .changed()
+                    .await
+                    .expect("finalize completion sender must remain live");
+            }
+        })
+        .await
+        .expect("direct-delete Finalize must wake the source-fence Put waiter");
+        let post_delete_leader = match inner
+            .reserve_external_local_first_put_key(key, true, true)
+            .expect("a physically reclaimed key must be eligible for a new local Put")
+        {
+            ExternalLocalFirstPutKeyReservation::Leader(leader) => leader,
+            _ => panic!("a reclaimed key must re-evaluate to a fresh leader"),
+        };
+        drop(post_delete_leader);
 
         stop_master_and_client(master, client).await;
     }
@@ -4611,12 +5283,14 @@ mod owner_reclaim_slot_tests {
                 local_puts: 0,
                 external_pending_puts: 0,
                 external_put: None,
+                remote_put: None,
                 source_eviction_selection: None,
                 reclaim: Some(OwnerReclaimRecord::Committed(OwnerReclaimItem {
                     key: "fenced".to_string(),
                     ..OwnerReclaimItem::default()
                 })),
                 external_get: None,
+                local_access_fence: Some(::tokio::sync::watch::channel(false).0),
             },
         );
         let mut resolved_keys = Vec::new();
@@ -5016,6 +5690,54 @@ impl ClientKvApiInner {
             external_get_undecided_interests,
             external_get_retained_interests,
             external_pending_put_entries: self.external_pending_puts.entry_count(),
+            remote_put_flights_active: self
+                .owner_remote_put_counters
+                .active
+                .load(Ordering::Relaxed),
+            remote_put_flight_leaders: self
+                .owner_remote_put_counters
+                .leaders
+                .load(Ordering::Relaxed),
+            remote_put_flight_followers: self
+                .owner_remote_put_counters
+                .followers
+                .load(Ordering::Relaxed),
+            remote_put_source_unavailable: self
+                .owner_remote_put_counters
+                .source_unavailable
+                .load(Ordering::Relaxed),
+            remote_put_source_fenced: self
+                .owner_remote_put_counters
+                .source_fenced
+                .load(Ordering::Relaxed),
+            remote_put_source_missing: self
+                .owner_remote_put_counters
+                .source_missing
+                .load(Ordering::Relaxed),
+            remote_put_source_version_mismatch: self
+                .owner_remote_put_counters
+                .source_version_mismatch
+                .load(Ordering::Relaxed),
+            remote_put_transfers: self
+                .owner_remote_put_counters
+                .transfers
+                .load(Ordering::Relaxed),
+            remote_put_published: self
+                .owner_remote_put_counters
+                .published
+                .load(Ordering::Relaxed),
+            remote_put_already_satisfied: self
+                .owner_remote_put_counters
+                .already_satisfied
+                .load(Ordering::Relaxed),
+            remote_put_obsolete: self
+                .owner_remote_put_counters
+                .obsolete
+                .load(Ordering::Relaxed),
+            remote_put_failed: self
+                .owner_remote_put_counters
+                .failed
+                .load(Ordering::Relaxed),
             local_reserve_slots_free,
             local_reserve_slots_prepared,
             local_reserve_slots_pending_visible,
@@ -5625,6 +6347,21 @@ impl ClientKvApi {
                             reserve_committed = snapshot.local_reserve_slots_committed,
                             "owner Get lifecycle snapshot"
                         );
+                        tracing::info!(
+                            active = snapshot.remote_put_flights_active,
+                            leaders = snapshot.remote_put_flight_leaders,
+                            followers = snapshot.remote_put_flight_followers,
+                            source_unavailable = snapshot.remote_put_source_unavailable,
+                            source_fenced = snapshot.remote_put_source_fenced,
+                            source_missing = snapshot.remote_put_source_missing,
+                            source_version_mismatch = snapshot.remote_put_source_version_mismatch,
+                            transfers = snapshot.remote_put_transfers,
+                            published = snapshot.remote_put_published,
+                            already_satisfied = snapshot.remote_put_already_satisfied,
+                            obsolete = snapshot.remote_put_obsolete,
+                            failed = snapshot.remote_put_failed,
+                            "owner unified remote Put flight snapshot"
+                        );
                         if snapshot.hot_cache_capacity_bytes > 0 {
                             tracing::info!(
                                 capacity_bytes = snapshot.hot_cache_capacity_bytes,
@@ -5670,8 +6407,6 @@ impl ClientKvApi {
             test_spec_config,
             owner_hot_cache_capacity_bytes,
         } = arg;
-        let (replica_task_tx, replica_task_rx) =
-            tokio::sync::ampsc::channel(REPLICA_TASK_QUEUE_CAPACITY);
         let (owner_local_publish_tx, owner_local_publish_rx) =
             tokio::sync::ampsc::channel(OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY);
         // The Moka eviction listener is synchronous and must never block while
@@ -5685,6 +6420,7 @@ impl ClientKvApi {
         let owner_key_control = Arc::new(OwnerKeyControlTable::default());
         let owner_source_eviction_selected = Arc::new(DashMap::new());
         let owner_hot_counters = Arc::new(OwnerHotCacheCounters::default());
+        let owner_remote_put_counters = Arc::new(OwnerRemotePutCounters::default());
         let owner_hot_retry_queue = Arc::new(OwnerHotRetryQueue::new(owner_hot_counters.clone()));
         let owner_hot_cache = owner_hot_cache_capacity_bytes.map(|capacity_bytes| {
             build_owner_hot_cache(
@@ -5716,6 +6452,7 @@ impl ClientKvApi {
             owner_hot_cache,
             owner_source_eviction_selected,
             owner_hot_counters,
+            owner_remote_put_counters,
             owner_hot_retry_queue,
             owner_hot_eviction_tx,
             owner_hot_eviction_rx: Mutex::new(Some(owner_hot_eviction_rx)),
@@ -5772,8 +6509,6 @@ impl ClientKvApi {
             default_lease_id: parking_lot::RwLock::new(None),
             owner_local_publish_tx,
             owner_local_publish_rx: Mutex::new(Some(owner_local_publish_rx)),
-            replica_task_tx,
-            replica_task_rx: Mutex::new(Some(replica_task_rx)),
         };
         Ok(Self(inner))
     }
@@ -6129,6 +6864,20 @@ impl ClientKvApi {
             },
         );
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchDeleteAckReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_delete_ack", async move {
+                    let result = handle_external_batch_delete_ack(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         // KV->file sync RPC (bytes field -> file@offset)
         RPCCaller::<SyncKvToFileReq>::new().regist(inner.view.p2p_module());
         let view_ext = inner.view.clone_view();
@@ -6210,18 +6959,6 @@ impl ClientKvApi {
             .expect("delete_ack_batch rx already taken, that's impossible");
         delete::spawn_owner_delete_ack_batch(inner.view.clone_view(), delete_ack_batch_rx);
 
-        if let Some(replica_task_rx) = inner.replica_task_rx.lock().take() {
-            put::spawn_replica_task_actor(
-                inner.view.clone_view(),
-                replica_task_rx,
-                inner
-                    .test_spec_config
-                    .replica_task_max_inflight
-                    .unwrap_or(1) as usize,
-            );
-        } else {
-            tracing::warn!("replica_task_rx already taken for ClientKvApi");
-        }
         if inner.owner_hot_cache.is_some() {
             if let Some(owner_hot_eviction_rx) = inner.owner_hot_eviction_rx.lock().take() {
                 put::spawn_owner_source_eviction_dispatcher(
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
index fe83d34..b0077c7 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
@@ -173,6 +173,9 @@ pub struct ExternalBatchGetTransferReq {
     pub req_node_id: String,
     /// Owner node_start_time observed by external when request starts
     pub started_time: i64,
+    /// Complete atomic-group prefix selected by the consumer from the live
+    /// get-start handle.
+    pub consume_prefix_len: usize,
 }
 impl MsgPackSerializePart for ExternalBatchGetTransferReq {
     fn msg_id(&self) -> u32 {
@@ -236,7 +239,7 @@ impl MsgPackSerializePart for ExternalBatchGetCancelResp {
 mod external_batch_get_plan_wire_tests {
     use super::{
         ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetItemResp,
-        ExternalBatchGetStartResp, ExternalBatchGetStartTransferPlan,
+        ExternalBatchGetStartResp, ExternalBatchGetStartTransferPlan, ExternalBatchGetTransferReq,
     };
     use crate::memholder::ExternalMemHolderInfo;
     use crate::rpcresp_kvresult_convert::msg_and_error::OK;
@@ -273,6 +276,16 @@ mod external_batch_get_plan_wire_tests {
                         .is_some_and(|info| info.holder_id == 23)
         ));
 
+        let transfer = ExternalBatchGetTransferReq {
+            handle: 19,
+            req_node_id: "external-a".to_string(),
+            started_time: 29,
+            consume_prefix_len: 1,
+        };
+        let decoded_transfer: ExternalBatchGetTransferReq =
+            bitcode::decode(&bitcode::encode(&transfer)).expect("decode transfer request");
+        assert_eq!(decoded_transfer.consume_prefix_len, 1);
+
         let cancel = ExternalBatchGetCancelReq {
             handle: 19,
             req_node_id: "external-a".to_string(),
@@ -802,6 +815,54 @@ impl MsgPackSerializePart for ExternalDeleteAckResp {
     }
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchDeleteAckReq {
+    pub external_client_id: String,
+    pub holder_ids: Vec<u64>,
+    /// Owner node_start_time observed when these holders were created.
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchDeleteAckReq {
+    fn msg_id(&self) -> u32 {
+        4036
+    }
+}
+impl RPCReq for ExternalBatchDeleteAckReq {
+    type Resp = ExternalBatchDeleteAckResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchDeleteAckResp {
+    pub released_count: u32,
+    pub missing_count: u32,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchDeleteAckResp {
+    fn msg_id(&self) -> u32 {
+        4037
+    }
+}
+
+#[cfg(test)]
+mod external_batch_delete_ack_wire_tests {
+    use super::ExternalBatchDeleteAckReq;
+
+    #[test]
+    fn compact_holder_id_batch_round_trips() {
+        let request = ExternalBatchDeleteAckReq {
+            external_client_id: "external-a".to_string(),
+            holder_ids: vec![3, 5, 8],
+            started_time: 17,
+        };
+        let decoded: ExternalBatchDeleteAckReq =
+            bitcode::decode(&bitcode::encode(&request)).expect("decode holder ACK batch");
+        assert_eq!(decoded.external_client_id, "external-a");
+        assert_eq!(decoded.holder_ids, vec![3, 5, 8]);
+        assert_eq!(decoded.started_time, 17);
+    }
+}
+
 // --- RPC: Owner -> External to invalidate weak-index cache for keys ---
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct ExternalInvalidateWeakIndexItem {
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index 8c70d68..d8bcc0a 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -2,7 +2,7 @@ use super::{
     ClientKvApiInner, OwnerHotEvictionEvent, OwnerHotEvictionPreparation,
     OwnerHotSelectionFenceOutcome, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
     OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef,
-    ReplicaTaskJob, ReplicaTaskTarget,
+    OwnerRemotePutOutcome, OwnerRemotePutReservation, OwnerRemotePutSharedOp,
     local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
 };
 use crate::OWNER_LOCAL_RESERVE_GRANT_QUANTUM_BYTES;
@@ -40,7 +40,6 @@ use crate::{
 };
 use chrono::Utc;
 use fluxon_commu::TransferBreakdown;
-use futures::future::join_all;
 use limit_thirdparty::tokio;
 use std::sync::{Arc, atomic::Ordering};
 use std::time::{Duration, Instant};
@@ -632,7 +631,7 @@ pub struct OwnerReservedPutItem {
     pub peer_node_id: Option<NodeIDString>,
     pub remember_local_snapshot: bool,
     pub make_replica_task: bool,
-    pub replica_target: Option<ReplicaTaskTarget>,
+    pub preferred_sub_cluster: Option<String>,
 }
 
 #[derive(Debug, Clone)]
@@ -1078,16 +1077,7 @@ impl ClientKvApiInner {
             } else {
                 Some(start_item.node_id.clone())
             };
-            let replica_target =
-                start_item
-                    .replica_target
-                    .as_ref()
-                    .map(|target| ReplicaTaskTarget {
-                        node_id: target.node_id.clone(),
-                        target_offset: target.target_addr - target.target_base_addr,
-                        target_base_addr: target.target_base_addr,
-                        len: target.len,
-                    });
+            let replica_admitted = start_item.replica_target.is_some();
             revoke_items.push(BatchPutRevokeItemReq {
                 key: start_req.key.clone(),
                 put_id: start_item.put_id,
@@ -1103,8 +1093,8 @@ impl ClientKvApiInner {
                 lease_id,
                 peer_node_id: peer_node_id.clone(),
                 remember_local_snapshot: true,
-                make_replica_task: start_req.make_replica_task && replica_target.is_some(),
-                replica_target,
+                make_replica_task: start_req.make_replica_task && replica_admitted,
+                preferred_sub_cluster: start_req.preferred_sub_cluster,
             });
         }
 
@@ -1198,13 +1188,13 @@ impl ClientKvApiInner {
                 self.remember_local_snapshot(&pending.item.key, pending.item.put_id);
             }
             if pending.item.make_replica_task {
-                let target = pending
-                    .item
-                    .replica_target
-                    .clone()
-                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = self
-                    .make_replica_task(&pending.item.key, pending.item.put_id, target)
+                    .ensure_remote_put(
+                        &pending.item.key,
+                        pending.item.put_id,
+                        pending.item.preferred_sub_cluster.clone(),
+                        true,
+                    )
                     .await
                 {
                     tracing::warn!(
@@ -1315,7 +1305,7 @@ impl ClientKvApiInner {
             lease_id: Option<u64>,
             remember_local_snapshot: bool,
             make_replica_task: bool,
-            replica_target: Option<ReplicaTaskTarget>,
+            preferred_sub_cluster: Option<String>,
         }
 
         let mut results: Vec<Option<KvResult<()>>> = (0..keys.len()).map(|_| None).collect();
@@ -1323,7 +1313,7 @@ impl ClientKvApiInner {
         let short_circuit_payload = self.short_circuit_put_payload_path_enabled();
         let skip_put_end_commit = self.skip_put_end_commit_enabled();
 
-        for (idx, (((key, ptrs), payload_len), start_item)) in keys
+        for (idx, (((key, ptrs), _payload_len), start_item)) in keys
             .into_iter()
             .zip(ptrs_groups.into_iter())
             .zip(payload_lens.into_iter())
@@ -1340,16 +1330,7 @@ impl ClientKvApiInner {
 
             let put_id = start_item.put_id;
             let remember_local_snapshot = true;
-            let replica_target =
-                start_item
-                    .replica_target
-                    .as_ref()
-                    .map(|target| ReplicaTaskTarget {
-                        node_id: target.node_id.clone(),
-                        target_offset: target.target_addr - target.target_base_addr,
-                        target_base_addr: target.target_base_addr,
-                        len: target.len,
-                    });
+            let replica_admitted = start_item.replica_target.is_some();
 
             if !short_circuit_payload {
                 unsafe {
@@ -1363,8 +1344,8 @@ impl ClientKvApiInner {
                 put_id,
                 lease_id,
                 remember_local_snapshot,
-                make_replica_task: make_replica_task && replica_target.is_some(),
-                replica_target,
+                make_replica_task: make_replica_task && replica_admitted,
+                preferred_sub_cluster: preferred_sub_cluster.clone(),
             });
         }
 
@@ -1417,12 +1398,13 @@ impl ClientKvApiInner {
                 self.remember_local_snapshot(&pending.key, pending.put_id);
             }
             if pending.make_replica_task {
-                let target = pending
-                    .replica_target
-                    .clone()
-                    .expect("make_replica_task requires pre-reserved replica target");
                 if let Err(err) = self
-                    .make_replica_task(&pending.key, pending.put_id, target)
+                    .ensure_remote_put(
+                        &pending.key,
+                        pending.put_id,
+                        pending.preferred_sub_cluster.clone(),
+                        true,
+                    )
                     .await
                 {
                     tracing::warn!(
@@ -1449,102 +1431,71 @@ impl ClientKvApiInner {
             .collect())
     }
 
-    pub async fn make_replica_task(
-        &self,
-        key: &str,
-        put_id: PutIDForAKey,
-        target: ReplicaTaskTarget,
-    ) -> KvResult<()> {
-        let Some(memory_info) = self.local_committed_mem_holder_for_put_id(key, put_id) else {
-            tracing::warn!(
-                "replica task source holder is unavailable or version-mismatched after local commit; dropping replica task: key={} put_id=({},{})",
-                key,
-                put_id.0,
-                put_id.1
-            );
-            return Ok(());
-        };
-
-        let holder = Arc::new(UserMemHolder::new(
-            memory_info,
-            self.get_or_init_all_memholder_refcount(),
-            UserMemHolderExposeKind::SegPtr,
-        ));
-
-        // A full queue must apply backpressure. Dropping a promised replica task leaves a
-        // local-only committed slot that reserve reclaim cannot safely release.
-        match self
-            .replica_task_tx
-            .send(ReplicaTaskJob {
-                key: key.to_string(),
-                put_id,
-                holder: Some(holder),
-                target: Some(target),
-                preferred_sub_cluster: None,
-                protect_source_on_remote_complete: true,
-            })
-            .await
-        {
-            Ok(()) => Ok(()),
-            Err(err) => {
-                tracing::warn!(
-                    "replica task actor queue closed; local-only commit remains valid: key={} put_id=({},{}) err={}",
-                    key,
-                    put_id.0,
-                    put_id.1,
-                    err
-                );
-                Ok(())
-            }
-        }
-    }
-
-    pub async fn make_replica_append_task(
+    /// Ensure one remote backing exists for an exact owner-local generation.
+    ///
+    /// Normal Put, pre-reserved replica, proactive write-back, and tier1 all
+    /// enter here.  Only the flight leader pins the source and immediately
+    /// launches Start/transfer/Done in its own async task; there is no actor or
+    /// intermediate work queue. Followers wait for and reuse that terminal
+    /// result instead of acquiring their own holder.
+    pub async fn ensure_remote_put(
         &self,
         key: &str,
         put_id: PutIDForAKey,
         preferred_sub_cluster: Option<String>,
         protect_source_on_remote_complete: bool,
     ) -> KvResult<bool> {
-        let Some(memory_info) = self.local_committed_mem_holder_for_put_id(key, put_id) else {
-            tracing::warn!(
-                "replica append task source holder is unavailable or version-mismatched after local publish; dropping replica task: key={} put_id=({},{})",
+        let mut follower_takeover_attempted = false;
+        loop {
+            match self.begin_owner_remote_put(
                 key,
-                put_id.0,
-                put_id.1
-            );
-            return Ok(false);
-        };
-
-        let holder = Arc::new(UserMemHolder::new(
-            memory_info,
-            self.get_or_init_all_memholder_refcount(),
-            UserMemHolderExposeKind::SegPtr,
-        ));
-
-        // Preserve append tasks under burst load for the same reclaim-safety reason above.
-        match self
-            .replica_task_tx
-            .send(ReplicaTaskJob {
-                key: key.to_string(),
                 put_id,
-                holder: Some(holder),
-                target: None,
-                preferred_sub_cluster,
+                preferred_sub_cluster.clone(),
                 protect_source_on_remote_complete,
-            })
-            .await
-        {
-            Ok(()) => Ok(true),
-            Err(err) => {
-                tracing::warn!(
-                    "replica append task actor queue closed; local-only commit remains valid: key={} put_id=({},{}) err={}",
-                    key,
-                    put_id.0,
-                    put_id.1,
-                    err
-                );
-                Ok(false)
+            ) {
+                OwnerRemotePutReservation::Leader { op, memory_info } => {
+                    let holder = Arc::new(UserMemHolder::new(
+                        memory_info,
+                        self.get_or_init_all_memholder_refcount(),
+                        UserMemHolderExposeKind::SegPtr,
+                    ));
+                    let spawn_view = self.view.clone_view();
+                    let task_view = spawn_view.clone();
+                    let _ = spawn_view.spawn("owner_remote_put_leader", async move {
+                        run_owner_remote_put(task_view, op, holder).await;
+                    });
+                    return Ok(true);
+                }
+                OwnerRemotePutReservation::Follower(op) => {
+                    tracing::debug!(
+                        "owner remote Put joined existing flight: key={} put_id=({},{})",
+                        op.key,
+                        op.put_id.0,
+                        op.put_id.1
+                    );
+                    match op.wait().await {
+                        OwnerRemotePutOutcome::Published
+                        | OwnerRemotePutOutcome::AlreadySatisfied => return Ok(true),
+                        OwnerRemotePutOutcome::Obsolete => return Ok(false),
+                        OwnerRemotePutOutcome::Failed if !follower_takeover_attempted => {
+                            follower_takeover_attempted = true;
+                            continue;
+                        }
+                        OwnerRemotePutOutcome::Failed => return Ok(false),
+                        OwnerRemotePutOutcome::InFlight => {
+                            unreachable!("remote Put wait must return a terminal outcome")
+                        }
+                    }
+                }
+                OwnerRemotePutReservation::SourceUnavailable => {
+                    tracing::warn!(
+                        "owner remote Put source is unavailable, fenced, or version-mismatched: key={} put_id=({},{})",
+                        key,
+                        put_id.0,
+                        put_id.1
+                    );
+                    return Ok(false);
+                }
             }
         }
     }
@@ -1609,15 +1560,7 @@ impl ClientKvApiInner {
         };
         let abs_src = resp.src_addr;
         let abs_target = resp.target_addr;
-        let replica_target = resp
-            .replica_target
-            .as_ref()
-            .map(|target| ReplicaTaskTarget {
-                node_id: target.node_id.clone(),
-                target_offset: target.target_addr - target.target_base_addr,
-                target_base_addr: target.target_base_addr,
-                len: target.len,
-            });
+        let replica_admitted = resp.replica_target.is_some();
 
         #[cfg(test)]
         {
@@ -1662,15 +1605,9 @@ impl ClientKvApiInner {
             );
             self.put_end(key, put_id, lease_id).await?;
             self.remember_local_snapshot(key, put_id);
-            if make_replica_task && replica_target.is_some() {
+            if make_replica_task && replica_admitted {
                 if let Err(err) = self
-                    .make_replica_task(
-                        key,
-                        put_id,
-                        replica_target
-                            .clone()
-                            .expect("make_replica_task requires pre-reserved replica target"),
-                    )
+                    .ensure_remote_put(key, put_id, preferred_sub_cluster.map(str::to_string), true)
                     .await
                 {
                     tracing::warn!(
@@ -1739,15 +1676,9 @@ impl ClientKvApiInner {
 
         self.put_end(key, put_id, lease_id).await?;
         self.remember_local_snapshot(key, put_id);
-        if make_replica_task && replica_target.is_some() {
+        if make_replica_task && replica_admitted {
             if let Err(err) = self
-                .make_replica_task(
-                    key,
-                    put_id,
-                    replica_target
-                        .clone()
-                        .expect("make_replica_task requires pre-reserved replica target"),
-                )
+                .ensure_remote_put(key, put_id, preferred_sub_cluster.map(str::to_string), true)
                 .await
             {
                 tracing::warn!(
@@ -2284,7 +2215,12 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
-    pub async fn put_append_revoke(&self, key: &str, put_id: PutIDForAKey) -> KvResult<()> {
+    pub async fn put_append_revoke(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        operation_id: u64,
+    ) -> KvResult<()> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
                 detail: "ClientKvApi is shutting down; rejecting put_append_revoke".to_string(),
@@ -2294,6 +2230,7 @@ impl ClientKvApiInner {
             serialize_part: PutAppendRevokeReq {
                 key: key.to_string(),
                 put_id,
+                operation_id,
             },
             raw_bytes: Vec::new(),
         };
@@ -2320,6 +2257,7 @@ impl ClientKvApiInner {
         &self,
         key: &str,
         put_id: PutIDForAKey,
+        operation_id: u64,
     ) -> KvResult<PutAppendDoneResp> {
         if !self.view.register_shutdown_poller().is_running() {
             return Err(KvError::Api(ApiError::SystemShutdown {
@@ -2330,6 +2268,7 @@ impl ClientKvApiInner {
             serialize_part: PutAppendDoneReq {
                 key: key.to_string(),
                 put_id,
+                operation_id,
             },
             raw_bytes: Vec::new(),
         };
@@ -2840,7 +2779,6 @@ impl ClientKvApiInner {
     }
 }
 
-const REPLICA_TASK_BATCH_MERGE_WINDOW: Duration = Duration::from_millis(2);
 const OWNER_LOCAL_PUBLISH_RETRY_INITIAL: Duration = Duration::from_millis(25);
 const OWNER_LOCAL_PUBLISH_RETRY_MAX: Duration = Duration::from_secs(1);
 
@@ -2945,20 +2883,29 @@ mod owner_hot_replica_policy_tests {
 
 async fn start_replica_append_with_retry(
     inner: &ClientKvApiInner,
-    job: &ReplicaTaskJob,
+    op: &OwnerRemotePutSharedOp,
     len: u32,
 ) -> KvResult<PutAppendStartResp> {
+    let request = op.request();
     inner
         .put_append_start(
-            &job.key,
-            job.put_id,
+            &op.key,
+            op.put_id,
             len,
-            job.preferred_sub_cluster.as_deref(),
-            job.protect_source_on_remote_complete,
+            request.preferred_sub_cluster.as_deref(),
+            request.protect_source_on_remote_complete,
         )
         .await
 }
 
+struct RemotePutTarget {
+    operation_id: u64,
+    node_id: String,
+    target_offset: u64,
+    target_base_addr: u64,
+    len: u64,
+}
+
 fn owner_source_eviction_identity(
     victim: &OwnerSourceEvictionVictim,
 ) -> super::OwnerHotReplicaIdentity {
@@ -3205,6 +3152,38 @@ async fn process_owner_source_eviction_events(
         return;
     }
 
+    let retryable = response
+        .victims
+        .iter()
+        .filter(|result| {
+            matches!(
+                result.outcome,
+                OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified
+            )
+        })
+        .count();
+    if retryable != 0
+        && let Some((index, result)) = response.victims.iter().enumerate().find(|(_, result)| {
+            matches!(
+                result.outcome,
+                OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified
+            )
+        })
+    {
+        let victim = &prepared[index].1;
+        tracing::warn!(
+            operation_id = response.operation_id,
+            victims = response.victims.len(),
+            retryable,
+            first_victim_index = result.victim_index,
+            key = %victim.key,
+            put_time_ms = victim.put_id.0,
+            put_version = victim.put_id.1,
+            detail = %result.detail,
+            "owner source direct-delete batch has retryable victims"
+        );
+    }
+
     for (index, ((event, victim), result)) in prepared
         .into_iter()
         .zip(response.victims.into_iter())
@@ -3427,512 +3406,177 @@ pub fn spawn_owner_hot_retry_actor(view: ClientKvApiView) {
     });
 }
 
-async fn process_replica_task(view_task: ClientKvApiView, mut job: ReplicaTaskJob) {
-    let inner = view_task.client_kv_api().inner();
-    let holder = job
-        .holder
-        .as_ref()
-        .expect("replica task source must be pinned before transfer");
-    let src_offset = holder.memory_info().offset;
-    let len = holder.get_length() as u64;
-    let target = if let Some(target) = job.target.clone() {
-        target
-    } else {
-        let len_u32 = match u32::try_from(len) {
-            Ok(len_u32) => len_u32,
-            Err(_) => {
-                tracing::warn!(
-                    "replica append task length does not fit u32: key={} put_id=({},{}) len={}",
-                    job.key,
-                    job.put_id.0,
-                    job.put_id.1,
-                    len
-                );
-                return;
-            }
-        };
-        let append_start = match start_replica_append_with_retry(inner, &job, len_u32).await {
-            Ok(resp) => resp,
-            Err(err) => {
-                tracing::warn!(
-                    "replica append task start failed: key={} put_id=({},{}) err={}",
-                    job.key,
-                    job.put_id.0,
-                    job.put_id.1,
-                    err
-                );
-                return;
-            }
-        };
-        match append_start.outcome {
-            PutAppendStartOutcome::Scheduled => {}
-            PutAppendStartOutcome::AlreadySatisfied | PutAppendStartOutcome::Obsolete => return,
-            PutAppendStartOutcome::RetryableNoSpace | PutAppendStartOutcome::Unspecified => {
-                tracing::debug!(
-                    outcome = ?append_start.outcome,
-                    "replica append task deferred: key={} put_id=({},{})",
-                    job.key,
-                    job.put_id.0,
-                    job.put_id.1
-                );
-                return;
-            }
-        }
-        ReplicaTaskTarget {
-            node_id: append_start.node_id,
-            target_offset: append_start.target_addr - append_start.target_base_addr,
-            target_base_addr: append_start.target_base_addr,
-            len: append_start.len,
-        }
-    };
-    if len != target.len {
-        tracing::warn!(
-            "replica task length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
-            job.key,
-            job.put_id.0,
-            job.put_id.1,
-            len,
-            target.len
-        );
-        spawn_replica_task_revoke(view_task.clone(), job.key, job.put_id, "length mismatch");
-        return;
-    }
-    if let Err(err) = inner
-        .put_transfer(
-            &job.key,
-            job.put_id,
-            src_offset,
-            target.target_offset,
-            len,
-            Some(target.node_id.clone()),
-            Some(target.target_base_addr),
-        )
-        .await
-    {
-        tracing::warn!(
-            "replica task transfer failed: key={} put_id=({},{}) err={}",
-            job.key,
-            job.put_id.0,
-            job.put_id.1,
-            err
-        );
-        spawn_replica_task_revoke(view_task.clone(), job.key, job.put_id, "transfer error");
-        return;
-    }
-    // Append-done may reclaim the source synchronously. Release the transfer-only holder first so
-    // this task does not make its own reclaim look busy.
-    drop(job.holder.take());
-    match inner.put_append_done(&job.key, job.put_id).await {
-        Ok(resp) => {
-            tracing::debug!(
-                "replica task append done: key={} put_id=({},{}) appended={}",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
-                resp.appended
-            );
-        }
-        Err(err) => {
+async fn fail_owner_remote_put(
+    view: &ClientKvApiView,
+    op: Arc<OwnerRemotePutSharedOp>,
+    operation_id: Option<u64>,
+    reason: &'static str,
+) {
+    let inner = view.client_kv_api().inner();
+    if let Some(operation_id) = operation_id {
+        if let Err(revoke_err) = inner
+            .put_append_revoke(&op.key, op.put_id, operation_id)
+            .await
+        {
             tracing::warn!(
-                "replica task append done failed: key={} put_id=({},{}) err={}",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
-                err
+                "owner remote Put revoke failed after {}: key={} put_id=({},{}) operation_id={} err={}",
+                reason,
+                op.key,
+                op.put_id.0,
+                op.put_id.1,
+                operation_id,
+                revoke_err
             );
         }
     }
+    inner.finish_owner_remote_put(&op, OwnerRemotePutOutcome::Failed);
 }
 
-struct ReplicaAppendDoneJob {
-    key: String,
-    put_id: PutIDForAKey,
-}
-
-async fn finish_replica_append_jobs_individually(
-    inner: &ClientKvApiInner,
-    jobs: Vec<ReplicaAppendDoneJob>,
+async fn run_owner_remote_put(
+    view: ClientKvApiView,
+    op: Arc<OwnerRemotePutSharedOp>,
+    holder: Arc<UserMemHolder>,
 ) {
-    let results = join_all(jobs.into_iter().map(|job| async move {
-        let result = inner.put_append_done(&job.key, job.put_id).await;
-        (job, result)
-    }))
-    .await;
-    for (job, result) in results {
-        match result {
-            Ok(_resp) => {}
-            Err(err) => {
-                tracing::warn!(
-                    "replica task append done fallback failed: key={} put_id=({},{}) err={}",
-                    job.key,
-                    job.put_id.0,
-                    job.put_id.1,
-                    err
-                );
-            }
-        }
-    }
-}
-
-async fn process_replica_append_batch(view_task: ClientKvApiView, jobs: Vec<ReplicaTaskJob>) {
-    if jobs.is_empty() {
-        return;
-    }
-    let inner = view_task.client_kv_api().inner();
-    let mut valid_jobs = Vec::with_capacity(jobs.len());
-    let mut start_items = Vec::with_capacity(jobs.len());
-    for job in jobs {
-        let len = job
-            .holder
-            .as_ref()
-            .expect("batch replica source must be pinned")
-            .get_length() as u64;
-        if u32::try_from(len).is_err() {
+    let inner = view.client_kv_api().inner();
+    let src_offset = holder.memory_info().offset;
+    let len = holder.get_length() as u64;
+    let len_u32 = match u32::try_from(len) {
+        Ok(len_u32) => len_u32,
+        Err(_) => {
             tracing::warn!(
-                "replica append task length does not fit u32: key={} put_id=({},{}) len={}",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
+                "owner remote Put length does not fit u32: key={} put_id=({},{}) len={}",
+                op.key,
+                op.put_id.0,
+                op.put_id.1,
                 len
             );
-            continue;
-        }
-        start_items.push(BatchPutAppendStartItemReq {
-            key: job.key.clone(),
-            put_id: job.put_id,
-            len,
-            preferred_sub_cluster: job.preferred_sub_cluster.clone(),
-            protect_source_on_remote_complete: job.protect_source_on_remote_complete,
-        });
-        valid_jobs.push(job);
-    }
-    if valid_jobs.is_empty() {
-        return;
-    }
-
-    let requested = valid_jobs.len();
-    let start_time = Instant::now();
-    let start_resp = match inner.batch_put_append_start(start_items).await {
-        Ok(resp) if resp.items.len() == requested => resp,
-        Ok(resp) => {
-            tracing::warn!(
-                "batch replica append start response length mismatch: expected={} got={}",
-                requested,
-                resp.items.len()
-            );
-            for job in valid_jobs {
-                spawn_replica_task_revoke(
-                    view_task.clone(),
-                    job.key,
-                    job.put_id,
-                    "batch start response mismatch",
-                );
-            }
+            drop(holder);
+            fail_owner_remote_put(&view, op, None, "length does not fit u32").await;
             return;
         }
+    };
+
+    let append_start = match start_replica_append_with_retry(inner, &op, len_u32).await {
+        Ok(resp) => resp,
         Err(err) => {
             tracing::warn!(
-                "batch replica append start RPC failed; falling back per item: items={} err={}",
-                requested,
+                "owner remote Put start failed: key={} put_id=({},{}) err={}",
+                op.key,
+                op.put_id.0,
+                op.put_id.1,
                 err
             );
-            join_all(
-                valid_jobs
-                    .into_iter()
-                    .map(|job| process_replica_task(view_task.clone(), job)),
-            )
-            .await;
+            drop(holder);
+            fail_owner_remote_put(&view, op, None, "start error").await;
             return;
         }
     };
-
-    let mut scheduled = Vec::new();
-    let mut already_satisfied = 0usize;
-    let mut start_failed = 0usize;
-    for (job, item) in valid_jobs.into_iter().zip(start_resp.items.into_iter()) {
-        if item.key != job.key || item.put_id != job.put_id {
-            tracing::warn!(
-                "batch replica append start identity mismatch: request_key={} request_put_id=({},{}) response_key={} response_put_id=({},{})",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
-                item.key,
-                item.put_id.0,
-                item.put_id.1
-            );
-            spawn_replica_task_revoke(
-                view_task.clone(),
-                job.key,
-                job.put_id,
-                "batch start identity mismatch",
-            );
-            start_failed += 1;
-            continue;
-        }
-        if let Err(err) =
-            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json.clone())
-        {
-            tracing::warn!(
-                "batch replica append start item failed: key={} put_id=({},{}) err={}",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
-                err
-            );
-            start_failed += 1;
-            continue;
+    match append_start.outcome {
+        PutAppendStartOutcome::Scheduled => {}
+        PutAppendStartOutcome::AlreadySatisfied => {
+            drop(holder);
+            inner.finish_owner_remote_put(&op, OwnerRemotePutOutcome::AlreadySatisfied);
+            return;
         }
-        match item.outcome {
-            PutAppendStartOutcome::Scheduled => {}
-            PutAppendStartOutcome::AlreadySatisfied => {
-                already_satisfied += 1;
-                continue;
-            }
-            PutAppendStartOutcome::Obsolete => continue,
-            PutAppendStartOutcome::RetryableNoSpace | PutAppendStartOutcome::Unspecified => {
-                start_failed += 1;
-                continue;
-            }
+        PutAppendStartOutcome::Obsolete => {
+            drop(holder);
+            inner.finish_owner_remote_put(&op, OwnerRemotePutOutcome::Obsolete);
+            return;
         }
-        let target = ReplicaTaskTarget {
-            node_id: item.node_id,
-            target_offset: item.target_addr - item.target_base_addr,
-            target_base_addr: item.target_base_addr,
-            len: item.len,
-        };
-        let source_len = job
-            .holder
-            .as_ref()
-            .expect("scheduled batch replica source must remain pinned")
-            .get_length() as u64;
-        if source_len != target.len {
-            tracing::warn!(
-                "batch replica task length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
-                source_len,
-                target.len
-            );
-            spawn_replica_task_revoke(
-                view_task.clone(),
-                job.key,
-                job.put_id,
-                "batch length mismatch",
+        PutAppendStartOutcome::RetryableNoSpace | PutAppendStartOutcome::Unspecified => {
+            tracing::debug!(
+                outcome = ?append_start.outcome,
+                "owner remote Put deferred: key={} put_id=({},{})",
+                op.key,
+                op.put_id.0,
+                op.put_id.1
             );
-            start_failed += 1;
-            continue;
+            drop(holder);
+            inner.finish_owner_remote_put(&op, OwnerRemotePutOutcome::Failed);
+            return;
         }
-        scheduled.push((job, target));
     }
-    tracing::info!(
-        requested,
-        scheduled = scheduled.len(),
-        already_satisfied,
-        failed = start_failed,
-        rpc_us = duration_to_i64_us(start_time.elapsed()),
-        "replica writeback batch start complete"
-    );
 
-    let transfer_results = join_all(scheduled.into_iter().map(|(job, target)| {
-        let transfer_view = view_task.clone();
-        async move {
-            let inner = transfer_view.client_kv_api().inner();
-            let src_offset = job
-                .holder
-                .as_ref()
-                .expect("scheduled batch replica source must remain pinned")
-                .memory_info()
-                .offset;
-            let result = inner
-                .put_transfer(
-                    &job.key,
-                    job.put_id,
-                    src_offset,
-                    target.target_offset,
-                    target.len,
-                    Some(target.node_id),
-                    Some(target.target_base_addr),
-                )
-                .await;
-            (job, result)
-        }
-    }))
-    .await;
-
-    let mut done_jobs = Vec::new();
-    for (job, result) in transfer_results {
-        match result {
-            Ok(_) => {
-                let ReplicaTaskJob {
-                    key,
-                    put_id,
-                    holder,
-                    ..
-                } = job;
-                drop(holder);
-                done_jobs.push(ReplicaAppendDoneJob { key, put_id });
-            }
-            Err(err) => {
-                tracing::warn!(
-                    "batch replica task transfer failed: key={} put_id=({},{}) err={}",
-                    job.key,
-                    job.put_id.0,
-                    job.put_id.1,
-                    err
-                );
-                spawn_replica_task_revoke(
-                    view_task.clone(),
-                    job.key,
-                    job.put_id,
-                    "batch transfer error",
-                );
-            }
-        }
+    let target = RemotePutTarget {
+        operation_id: append_start.operation_id,
+        node_id: append_start.node_id,
+        target_offset: append_start.target_addr - append_start.target_base_addr,
+        target_base_addr: append_start.target_base_addr,
+        len: append_start.len,
+    };
+    if len != target.len {
+        tracing::warn!(
+            "owner remote Put length mismatch: key={} put_id=({},{}) src_len={} target_len={}",
+            op.key,
+            op.put_id.0,
+            op.put_id.1,
+            len,
+            target.len
+        );
+        drop(holder);
+        fail_owner_remote_put(&view, op, Some(target.operation_id), "length mismatch").await;
+        return;
     }
-    if done_jobs.is_empty() {
+
+    inner.record_owner_remote_put_transfer();
+    if let Err(err) = inner
+        .put_transfer(
+            &op.key,
+            op.put_id,
+            src_offset,
+            target.target_offset,
+            len,
+            Some(target.node_id),
+            Some(target.target_base_addr),
+        )
+        .await
+    {
+        tracing::warn!(
+            "owner remote Put transfer failed: key={} put_id=({},{}) err={}",
+            op.key,
+            op.put_id.0,
+            op.put_id.1,
+            err
+        );
+        drop(holder);
+        fail_owner_remote_put(&view, op, Some(target.operation_id), "transfer error").await;
         return;
     }
 
-    let done_requested = done_jobs.len();
-    let done_items = done_jobs
-        .iter()
-        .map(|job| BatchPutAppendDoneItemReq {
-            key: job.key.clone(),
-            put_id: job.put_id,
-        })
-        .collect();
-    let done_time = Instant::now();
-    let done_resp = match inner.batch_put_append_done(done_items).await {
-        Ok(resp) if resp.items.len() == done_requested => resp,
+    // The payload is no longer read after transfer.  Keep the generation
+    // flight installed through Done so eviction cannot cross the completion
+    // protocol even though the physical source holder is now releasable.
+    drop(holder);
+    match inner
+        .put_append_done(&op.key, op.put_id, target.operation_id)
+        .await
+    {
         Ok(resp) => {
-            tracing::warn!(
-                "batch replica append done response length mismatch: expected={} got={}; falling back per item",
-                done_requested,
-                resp.items.len()
+            let outcome = if resp.appended {
+                OwnerRemotePutOutcome::Published
+            } else {
+                OwnerRemotePutOutcome::AlreadySatisfied
+            };
+            tracing::debug!(
+                "owner remote Put done: key={} put_id=({},{}) appended={}",
+                op.key,
+                op.put_id.0,
+                op.put_id.1,
+                resp.appended
             );
-            finish_replica_append_jobs_individually(inner, done_jobs).await;
-            return;
+            inner.finish_owner_remote_put(&op, outcome);
         }
         Err(err) => {
             tracing::warn!(
-                "batch replica append done RPC failed; falling back per item: items={} err={}",
-                done_requested,
+                "owner remote Put done failed: key={} put_id=({},{}) err={}",
+                op.key,
+                op.put_id.0,
+                op.put_id.1,
                 err
             );
-            finish_replica_append_jobs_individually(inner, done_jobs).await;
-            return;
-        }
-    };
-
-    let mut appended = 0usize;
-    let mut already_done = 0usize;
-    let mut done_failed = 0usize;
-    for (job, item) in done_jobs.into_iter().zip(done_resp.items.into_iter()) {
-        let identity_matches = item.key == job.key && item.put_id == job.put_id;
-        let item_result = crate::rpcresp_kvresult_convert::try_from_code(
-            item.error_code,
-            item.error_json.clone(),
-        );
-        if !identity_matches || item_result.is_err() {
-            tracing::warn!(
-                "batch replica append done item failed: key={} put_id=({},{}) identity_matches={} err={:?}",
-                job.key,
-                job.put_id.0,
-                job.put_id.1,
-                identity_matches,
-                item_result.err()
-            );
-            spawn_replica_task_revoke(
-                view_task.clone(),
-                job.key,
-                job.put_id,
-                "batch done item error",
-            );
-            done_failed += 1;
-            continue;
-        }
-        if item.appended {
-            appended += 1;
-        } else {
-            already_done += 1;
+            fail_owner_remote_put(&view, op, Some(target.operation_id), "done error").await;
         }
     }
-    tracing::info!(
-        requested = done_requested,
-        appended,
-        already_satisfied = already_done,
-        failed = done_failed,
-        rpc_us = duration_to_i64_us(done_time.elapsed()),
-        "replica writeback batch done complete"
-    );
-}
-
-async fn process_replica_task_batch(view_task: ClientKvApiView, jobs: Vec<ReplicaTaskJob>) {
-    let mut append_jobs = Vec::new();
-    let mut reserved_target_jobs = Vec::new();
-    for job in jobs {
-        if job.target.is_some() {
-            reserved_target_jobs.push(job);
-        } else {
-            append_jobs.push(job);
-        }
-    }
-    let append = process_replica_append_batch(view_task.clone(), append_jobs);
-    let reserved = join_all(
-        reserved_target_jobs
-            .into_iter()
-            .map(|job| process_replica_task(view_task.clone(), job)),
-    );
-    let (_, _) = futures::join!(append, reserved);
-}
-
-pub fn spawn_replica_task_actor(
-    view: ClientKvApiView,
-    mut rx: tokio::sync::ampsc::Receiver<ReplicaTaskJob>,
-    max_inflight: usize,
-) {
-    let view_task = view.clone();
-    let _ = view.spawn("replica_task_actor", async move {
-        let max_inflight = max_inflight.max(1);
-        tracing::info!(
-            max_inflight,
-            merge_window_ms = REPLICA_TASK_BATCH_MERGE_WINDOW.as_millis(),
-            "replica task actor started with time-window batching"
-        );
-        let mut shutdown_waiter = view_task.register_shutdown_waiter();
-        loop {
-            let first = tokio::select! {
-                _ = shutdown_waiter.wait() => {
-                    tracing::info!("replica_task_actor stopping due to shutdown signal");
-                    break;
-                }
-                job = rx.recv() => {
-                    match job {
-                        Some(job) => job,
-                        None => break,
-                    }
-                }
-            };
-            let mut batch = Vec::with_capacity(max_inflight);
-            batch.push(first);
-            let merge_window = tokio::time::sleep(REPLICA_TASK_BATCH_MERGE_WINDOW);
-            tokio::pin!(merge_window);
-            while batch.len() < max_inflight {
-                tokio::select! {
-                    _ = &mut merge_window => break,
-                    job = rx.recv() => {
-                        match job {
-                            Some(job) => batch.push(job),
-                            None => break,
-                        }
-                    }
-                }
-            }
-            tracing::info!(items = batch.len(), "replica writeback batch flushed");
-            process_replica_task_batch(view_task.clone(), batch).await;
-        }
-    });
 }
 
 pub async fn handle_batch_enqueue_replica_tasks(
@@ -3943,7 +3587,7 @@ pub async fn handle_batch_enqueue_replica_tasks(
     let mut items = Vec::with_capacity(req.serialize_part.items.len());
     for item in req.serialize_part.items {
         let accepted = match inner
-            .make_replica_append_task(&item.key, item.put_id, None, false)
+            .ensure_remote_put(&item.key, item.put_id, None, false)
             .await
         {
             Ok(accepted) => accepted,
@@ -4256,7 +3900,7 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
         for item in promoted_items {
             if item.make_replica_task {
                 if let Err(err) = inner
-                    .make_replica_append_task(
+                    .ensure_remote_put(
                         &item.key,
                         item.put_id,
                         item.preferred_sub_cluster.clone(),
@@ -4297,24 +3941,3 @@ async fn release_owner_local_publish_reservations(
         );
     }
 }
-
-fn spawn_replica_task_revoke(
-    view: ClientKvApiView,
-    key: String,
-    put_id: PutIDForAKey,
-    reason: &'static str,
-) {
-    let _ = view.clone().spawn("replica_task_revoke", async move {
-        let inner = view.client_kv_api().inner();
-        if let Err(revoke_err) = inner.put_append_revoke(&key, put_id).await {
-            tracing::warn!(
-                "replica task append revoke failed after {}: key={} put_id=({},{}) err={}",
-                reason,
-                key,
-                put_id.0,
-                put_id.1,
-                revoke_err
-            );
-        }
-    });
-}
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
index 97b36a0..1eb0a5a 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
@@ -56,6 +56,8 @@ fn reclaim_key_control_busy_detail(state: &super::OwnerKeyControlState) -> Optio
         Some("owner local put is inflight")
     } else if state.external_pending_puts != 0 {
         Some("owner external put context is still pending")
+    } else if state.remote_put.is_some() {
+        Some("owner remote put transfer is inflight")
     } else if state.source_eviction_selection.is_some() {
         Some("owner source eviction selection fence is active")
     } else if state.external_get.is_some() {
@@ -91,7 +93,7 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
                 "another owner source selection owns the key fence",
             );
         }
-        if state.local_puts != 0 || state.external_pending_puts != 0 {
+        if state.local_puts != 0 || state.external_pending_puts != 0 || state.remote_put.is_some() {
             return item_resp(
                 item,
                 OwnerReclaimItemState::Busy,
@@ -126,6 +128,10 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
             })
             .map(|(_, snapshot)| snapshot);
         assert!(state.reclaim.is_none());
+        assert!(
+            state.local_access_fence.is_some(),
+            "source-selection promotion must retain its local-access completion generation"
+        );
         state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
             item: item.clone(),
             cached_info: selection.cached_info,
@@ -214,6 +220,7 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
             && state.external_pending_puts == 0
             && state.external_get.is_none()
     );
+    state.begin_local_access_fence();
     state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
         item: item.clone(),
         cached_info,
@@ -279,7 +286,9 @@ fn reclaim_release_fence_is_intact(
         Some(OwnerReclaimRecord::Releasing(releasing)) if releasing == item
     ) && state.local_puts == 0
         && state.external_pending_puts == 0
+        && state.remote_put.is_none()
         && state.source_eviction_selection.is_none()
+        && state.local_access_fence.is_some()
 }
 
 fn commit_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
@@ -389,26 +398,23 @@ mod tests {
             },
             reason: OwnerReclaimReason::OwnerCapacityEviction,
         };
-        let state = OwnerKeyControlState {
-            local_puts: 0,
-            external_pending_puts: 0,
-            external_put: None,
-            source_eviction_selection: None,
-            reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
+        let mut state = OwnerKeyControlState {
             external_get: Some(Arc::new(ExternalGetKeySharedOp::new(
                 "remote-during-reclaim".to_string(),
             ))),
+            ..Default::default()
         };
+        state.reclaim = Some(OwnerReclaimRecord::Releasing(item.clone()));
+        state.begin_local_access_fence();
         assert!(reclaim_release_fence_is_intact(&state, &item));
 
-        let local_put_state = OwnerKeyControlState {
+        let mut local_put_state = OwnerKeyControlState {
             local_puts: 1,
-            external_pending_puts: 0,
-            external_put: None,
-            source_eviction_selection: None,
-            reclaim: Some(OwnerReclaimRecord::Releasing(item.clone())),
             external_get: state.external_get,
+            ..Default::default()
         };
+        local_put_state.reclaim = Some(OwnerReclaimRecord::Releasing(item.clone()));
+        local_put_state.begin_local_access_fence();
         assert!(!reclaim_release_fence_is_intact(&local_put_state, &item));
     }
 }
@@ -445,6 +451,7 @@ fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimI
                     "owner reclaim abort must restore an empty local snapshot slot"
                 );
             }
+            state.finish_local_access_fence();
             if state.is_idle() {
                 controls.remove(&item.key);
             }
@@ -492,6 +499,7 @@ fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerRecla
     };
     match state.reclaim.take() {
         Some(OwnerReclaimRecord::Committed(committed)) if committed == *item => {
+            state.finish_local_access_fence();
             if state.is_idle() {
                 controls.remove(&item.key);
             }
diff --git a/fluxon_rs/fluxon_kv/src/config.rs b/fluxon_rs/fluxon_kv/src/config.rs
index 8e88dc5..0e12327 100644
--- a/fluxon_rs/fluxon_kv/src/config.rs
+++ b/fluxon_rs/fluxon_kv/src/config.rs
@@ -158,8 +158,10 @@ pub struct TestSpecConfig {
     pub tcp_thread_control_lane_count: Option<u8>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub user_rpc_sync_handler_thread_count: Option<u16>,
-    /// Maximum number of replica append pipelines in flight on an owner. Different keys may run
-    /// concurrently; each key remains strictly serialized by the replica dispatcher.
+    /// Deprecated compatibility field. Remote Put now uses direct per-generation singleflight:
+    /// the elected leader starts immediately and followers await its terminal result, without a
+    /// replica dispatcher or a global inflight queue. The value is still parsed and validated so
+    /// existing configurations remain loadable, but it no longer throttles remote Put execution.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub replica_task_max_inflight: Option<u16>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/delete_ack_batch.rs b/fluxon_rs/fluxon_kv/src/external_client_api/delete_ack_batch.rs
new file mode 100644
index 0000000..6ed9528
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/delete_ack_batch.rs
@@ -0,0 +1,366 @@
+use super::ExternalClientApiView;
+use ::tokio::sync::mpsc;
+use limit_thirdparty::tokio;
+use parking_lot::Mutex;
+use std::collections::{BTreeMap, BTreeSet};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Duration;
+
+pub(crate) const EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS: usize = 1024;
+const EXTERNAL_DELETE_ACK_BATCH_MERGE_WINDOW: Duration = Duration::from_millis(1);
+const EXTERNAL_DELETE_ACK_BATCH_RPC_TIMEOUT: Duration = Duration::from_secs(5);
+const EXTERNAL_DELETE_ACK_BATCH_LOG_EVERY: u64 = 512;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct ExternalDeleteAckItem {
+    pub external_client_id: String,
+    pub holder_id: u64,
+    pub owner_start_time: i64,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+struct ExternalDeleteAckBatch {
+    external_client_id: String,
+    owner_start_time: i64,
+    holder_ids: Vec<u64>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct ExternalDeleteAckBatchSnapshot {
+    pub enqueued_items: u64,
+    pub enqueue_failures: u64,
+    pub rpc_batches: u64,
+    pub rpc_items: u64,
+    pub released_items: u64,
+    pub missing_items: u64,
+    pub generation_mismatch_items: u64,
+    pub rpc_failures: u64,
+    pub max_batch_items: u64,
+}
+
+#[derive(Default)]
+struct ExternalDeleteAckBatchCounters {
+    enqueued_items: AtomicU64,
+    enqueue_failures: AtomicU64,
+    rpc_batches: AtomicU64,
+    rpc_items: AtomicU64,
+    released_items: AtomicU64,
+    missing_items: AtomicU64,
+    generation_mismatch_items: AtomicU64,
+    rpc_failures: AtomicU64,
+    max_batch_items: AtomicU64,
+}
+
+impl ExternalDeleteAckBatchCounters {
+    fn snapshot(&self) -> ExternalDeleteAckBatchSnapshot {
+        ExternalDeleteAckBatchSnapshot {
+            enqueued_items: self.enqueued_items.load(Ordering::Relaxed),
+            enqueue_failures: self.enqueue_failures.load(Ordering::Relaxed),
+            rpc_batches: self.rpc_batches.load(Ordering::Relaxed),
+            rpc_items: self.rpc_items.load(Ordering::Relaxed),
+            released_items: self.released_items.load(Ordering::Relaxed),
+            missing_items: self.missing_items.load(Ordering::Relaxed),
+            generation_mismatch_items: self.generation_mismatch_items.load(Ordering::Relaxed),
+            rpc_failures: self.rpc_failures.load(Ordering::Relaxed),
+            max_batch_items: self.max_batch_items.load(Ordering::Relaxed),
+        }
+    }
+}
+
+pub(crate) struct ExternalDeleteAckBatchHandle {
+    tx: mpsc::UnboundedSender<ExternalDeleteAckItem>,
+    rx: Mutex<Option<mpsc::UnboundedReceiver<ExternalDeleteAckItem>>>,
+    counters: ExternalDeleteAckBatchCounters,
+}
+
+impl ExternalDeleteAckBatchHandle {
+    pub(crate) fn new() -> Self {
+        let (tx, rx) = mpsc::unbounded_channel();
+        Self {
+            tx,
+            rx: Mutex::new(Some(rx)),
+            counters: ExternalDeleteAckBatchCounters::default(),
+        }
+    }
+
+    pub(crate) fn enqueue(&self, item: ExternalDeleteAckItem) -> Result<(), String> {
+        match self.tx.send(item) {
+            Ok(()) => {
+                self.counters.enqueued_items.fetch_add(1, Ordering::Relaxed);
+                Ok(())
+            }
+            Err(err) => {
+                self.counters
+                    .enqueue_failures
+                    .fetch_add(1, Ordering::Relaxed);
+                Err(format!(
+                    "external holder ACK batch worker is unavailable for holder_id={}",
+                    err.0.holder_id
+                ))
+            }
+        }
+    }
+
+    pub(crate) fn take_rx(&self) -> Option<mpsc::UnboundedReceiver<ExternalDeleteAckItem>> {
+        self.rx.lock().take()
+    }
+
+    pub(crate) fn snapshot(&self) -> ExternalDeleteAckBatchSnapshot {
+        self.counters.snapshot()
+    }
+
+    fn record_batch(&self, item_count: usize) -> u64 {
+        let item_count = u64::try_from(item_count).unwrap_or(u64::MAX);
+        self.counters
+            .max_batch_items
+            .fetch_max(item_count, Ordering::Relaxed);
+        self.counters
+            .rpc_items
+            .fetch_add(item_count, Ordering::Relaxed);
+        self.counters.rpc_batches.fetch_add(1, Ordering::Relaxed) + 1
+    }
+
+    fn record_result(&self, result: super::ExternalDeleteAckBatchSendResult) {
+        match result {
+            super::ExternalDeleteAckBatchSendResult::Applied { released, missing } => {
+                self.counters
+                    .released_items
+                    .fetch_add(u64::from(released), Ordering::Relaxed);
+                self.counters
+                    .missing_items
+                    .fetch_add(u64::from(missing), Ordering::Relaxed);
+            }
+            super::ExternalDeleteAckBatchSendResult::OwnerGenerationChanged { items } => {
+                self.counters
+                    .generation_mismatch_items
+                    .fetch_add(items, Ordering::Relaxed);
+            }
+        }
+    }
+
+    fn record_rpc_failure(&self) {
+        self.counters.rpc_failures.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+fn build_external_delete_ack_batches(
+    items: Vec<ExternalDeleteAckItem>,
+) -> Vec<ExternalDeleteAckBatch> {
+    let mut groups: BTreeMap<(String, i64), BTreeSet<u64>> = BTreeMap::new();
+    for item in items {
+        groups
+            .entry((item.external_client_id, item.owner_start_time))
+            .or_default()
+            .insert(item.holder_id);
+    }
+    let mut batches = Vec::new();
+    for ((external_client_id, owner_start_time), holder_ids) in groups {
+        let holder_ids: Vec<_> = holder_ids.into_iter().collect();
+        for chunk in holder_ids.chunks(EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS) {
+            batches.push(ExternalDeleteAckBatch {
+                external_client_id: external_client_id.clone(),
+                owner_start_time,
+                holder_ids: chunk.to_vec(),
+            });
+        }
+    }
+    batches
+}
+
+fn log_external_delete_ack_batch_snapshot(view: &ExternalClientApiView, reason: &'static str) {
+    let snapshot = view
+        .external_client_api()
+        .inner()
+        .external_delete_ack_batch_snapshot();
+    tracing::info!(
+        reason,
+        enqueued_items = snapshot.enqueued_items,
+        enqueue_failures = snapshot.enqueue_failures,
+        rpc_batches = snapshot.rpc_batches,
+        rpc_items = snapshot.rpc_items,
+        released_items = snapshot.released_items,
+        missing_items = snapshot.missing_items,
+        generation_mismatch_items = snapshot.generation_mismatch_items,
+        rpc_failures = snapshot.rpc_failures,
+        max_batch_items = snapshot.max_batch_items,
+        "external holder ACK batch snapshot"
+    );
+}
+
+pub(crate) fn spawn_external_delete_ack_batch(
+    view: ExternalClientApiView,
+    mut rx: mpsc::UnboundedReceiver<ExternalDeleteAckItem>,
+) {
+    let spawn_view = view.clone();
+    let worker_view = view.clone();
+    spawn_view.spawn("external_delete_ack_batch", async move {
+        tracing::info!(
+            max_items = EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS,
+            merge_window_us = EXTERNAL_DELETE_ACK_BATCH_MERGE_WINDOW.as_micros(),
+            "external holder ACK batch worker started"
+        );
+        let mut shutdown_waiter = worker_view.register_shutdown_waiter();
+        loop {
+            let first = tokio::select! {
+                biased;
+                _ = shutdown_waiter.wait() => {
+                    log_external_delete_ack_batch_snapshot(&worker_view, "shutdown");
+                    return;
+                }
+                item = rx.recv() => {
+                    let Some(item) = item else {
+                        log_external_delete_ack_batch_snapshot(&worker_view, "channel_closed");
+                        return;
+                    };
+                    item
+                }
+            };
+
+            let mut pending = Vec::with_capacity(EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS);
+            pending.push(first);
+            let merge_window = tokio::time::sleep(EXTERNAL_DELETE_ACK_BATCH_MERGE_WINDOW);
+            tokio::pin!(merge_window);
+            let mut shutting_down = false;
+            while pending.len() < EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS {
+                tokio::select! {
+                    biased;
+                    _ = shutdown_waiter.wait() => {
+                        shutting_down = true;
+                        break;
+                    }
+                    item = rx.recv() => {
+                        match item {
+                            Some(item) => pending.push(item),
+                            None => break,
+                        }
+                    }
+                    _ = &mut merge_window => break,
+                }
+            }
+            if shutting_down {
+                tracing::info!(
+                    dropped_pending_items = pending.len(),
+                    "external holder ACK batch worker skipped pending items during shutdown"
+                );
+                log_external_delete_ack_batch_snapshot(&worker_view, "shutdown_with_pending");
+                return;
+            }
+
+            for batch in build_external_delete_ack_batches(pending) {
+                let item_count = batch.holder_ids.len();
+                let batch_number = worker_view
+                    .external_client_api()
+                    .inner()
+                    .external_delete_ack_batch
+                    .record_batch(item_count);
+                let send_result = tokio::time::timeout(
+                    EXTERNAL_DELETE_ACK_BATCH_RPC_TIMEOUT,
+                    worker_view
+                        .external_client_api()
+                        .inner()
+                        .send_external_delete_ack_batch(
+                            &batch.external_client_id,
+                            batch.owner_start_time,
+                            batch.holder_ids,
+                        ),
+                )
+                .await;
+                match send_result {
+                    Ok(Ok(result)) => worker_view
+                        .external_client_api()
+                        .inner()
+                        .external_delete_ack_batch
+                        .record_result(result),
+                    Ok(Err(err)) => {
+                        worker_view
+                            .external_client_api()
+                            .inner()
+                            .external_delete_ack_batch
+                            .record_rpc_failure();
+                        tracing::warn!(
+                            external_client_id = %batch.external_client_id,
+                            owner_start_time = batch.owner_start_time,
+                            items = item_count,
+                            error = %err,
+                            "external holder ACK batch RPC failed"
+                        );
+                    }
+                    Err(_) => {
+                        worker_view
+                            .external_client_api()
+                            .inner()
+                            .external_delete_ack_batch
+                            .record_rpc_failure();
+                        tracing::warn!(
+                            external_client_id = %batch.external_client_id,
+                            owner_start_time = batch.owner_start_time,
+                            items = item_count,
+                            timeout_secs = EXTERNAL_DELETE_ACK_BATCH_RPC_TIMEOUT.as_secs(),
+                            "external holder ACK batch RPC timed out"
+                        );
+                    }
+                }
+                if batch_number % EXTERNAL_DELETE_ACK_BATCH_LOG_EVERY == 0 {
+                    log_external_delete_ack_batch_snapshot(&worker_view, "periodic");
+                }
+            }
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS, ExternalDeleteAckItem,
+        build_external_delete_ack_batches,
+    };
+
+    fn item(client: &str, generation: i64, holder_id: u64) -> ExternalDeleteAckItem {
+        ExternalDeleteAckItem {
+            external_client_id: client.to_string(),
+            holder_id,
+            owner_start_time: generation,
+        }
+    }
+
+    #[test]
+    fn grouping_is_generation_safe_and_deduplicates_holder_ids() {
+        let batches = build_external_delete_ack_batches(vec![
+            item("client-a", 11, 3),
+            item("client-a", 11, 3),
+            item("client-a", 11, 2),
+            item("client-a", 12, 4),
+            item("client-b", 11, 5),
+        ]);
+        assert_eq!(batches.len(), 3);
+        assert_eq!(batches[0].external_client_id, "client-a");
+        assert_eq!(batches[0].owner_start_time, 11);
+        assert_eq!(batches[0].holder_ids, vec![2, 3]);
+        assert_eq!(batches[1].owner_start_time, 12);
+        assert_eq!(batches[1].holder_ids, vec![4]);
+        assert_eq!(batches[2].external_client_id, "client-b");
+        assert_eq!(batches[2].holder_ids, vec![5]);
+    }
+
+    #[test]
+    fn batches_never_exceed_wire_batch_limit() {
+        let item_count = EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS * 2 + 1;
+        let items = (0..item_count)
+            .map(|holder_id| item("client-a", 11, holder_id as u64))
+            .collect();
+        let batches = build_external_delete_ack_batches(items);
+        assert_eq!(batches.len(), 3);
+        assert!(
+            batches
+                .iter()
+                .all(|batch| batch.holder_ids.len() <= EXTERNAL_DELETE_ACK_BATCH_MAX_ITEMS)
+        );
+        assert_eq!(
+            batches
+                .iter()
+                .map(|batch| batch.holder_ids.len())
+                .sum::<usize>(),
+            item_count
+        );
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index fed6a1a..2008f1b 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -1,9 +1,10 @@
 use crate::SharedJsonMeta;
 use crate::client_kv_api::external_api::{
     compute_external_get_start_transfer_prefix, normalize_external_get_start_group_lens,
+    validate_external_get_consume_prefix,
 };
 use crate::client_kv_api::msg_pack::{
-    ExternalInvalidateWeakIndexItem, ExternalInvalidateWeakIndexReq,
+    ExternalBatchDeleteAckReq, ExternalInvalidateWeakIndexItem, ExternalInvalidateWeakIndexReq,
     ExternalInvalidateWeakIndexResp,
 };
 use crate::client_seg_pool::{ClientSegPool, SideTransferPeerFileMeta};
@@ -64,6 +65,12 @@ pub mod external_client_test;
 
 type SharedMetaSignature = fluxon_util::fs_watch::FileSignature;
 
+mod delete_ack_batch;
+pub(crate) use delete_ack_batch::{
+    ExternalDeleteAckBatchHandle, ExternalDeleteAckBatchSnapshot, ExternalDeleteAckItem,
+    spawn_external_delete_ack_batch,
+};
+
 // External->Owner staged put consists of multiple potentially slow components:
 // - ExternalPutStartReq triggers owner->master PutStart RPC (60s timeout).
 // - ExternalPutTransferEndReq executes transfer (can be slow) and then owner->master PutEnd RPC (60s timeout).
@@ -73,6 +80,12 @@ const EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS: u64 = 30;
 const EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS: usize = 3;
 const EXTERNAL_PUT_TRACE_LOG_WINDOW_SECS: u64 = 10;
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ExternalDeleteAckBatchSendResult {
+    Applied { released: u32, missing: u32 },
+    OwnerGenerationChanged { items: u64 },
+}
+
 #[derive(Debug, Clone)]
 pub struct ExternalClientGetStartResp {
     pub handle: u64,
@@ -82,6 +95,7 @@ pub struct ExternalClientGetStartResp {
 struct PendingExternalGetStart {
     keys: Vec<String>,
     transferable_len: usize,
+    atomic_group_lens: Vec<usize>,
     first_miss_index: Option<usize>,
 }
 
@@ -133,10 +147,43 @@ fn validate_inline_external_get_owner_generation(
     }))
 }
 
+fn inline_external_get_tail_holder_ids(
+    items: &[ExternalBatchGetItemResp],
+    consume_prefix_len: usize,
+) -> KvResult<Vec<u64>> {
+    if consume_prefix_len == 0 || consume_prefix_len > items.len() {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!(
+                "inline get_transfer consume prefix is out of range: consume={} items={}",
+                consume_prefix_len,
+                items.len()
+            ),
+        }));
+    }
+    items[consume_prefix_len..]
+        .iter()
+        .enumerate()
+        .map(|(tail_idx, item)| {
+            item.external_memholder_info
+                .as_ref()
+                .map(|info| info.holder_id)
+                .ok_or_else(|| {
+                    KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "inline get_transfer tail item has no holder: index={}",
+                            consume_prefix_len + tail_idx
+                        ),
+                    })
+                })
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod inline_external_get_start_tests {
     use super::{
-        validate_inline_external_get_owner_generation, validate_inline_external_get_start_plan,
+        inline_external_get_tail_holder_ids, validate_inline_external_get_owner_generation,
+        validate_inline_external_get_start_plan,
     };
     use crate::client_kv_api::msg_pack::ExternalBatchGetItemResp;
     use crate::memholder::ExternalMemHolderInfo;
@@ -178,6 +225,22 @@ mod inline_external_get_start_tests {
             })
         ));
     }
+
+    #[test]
+    fn inline_partial_consume_returns_only_tail_holder_ids() {
+        let items = vec![inline_hit(11), inline_hit(12), inline_hit(13)];
+        assert_eq!(
+            inline_external_get_tail_holder_ids(&items, 2).unwrap(),
+            vec![13]
+        );
+        assert!(
+            inline_external_get_tail_holder_ids(&items, 3)
+                .unwrap()
+                .is_empty()
+        );
+        assert!(inline_external_get_tail_holder_ids(&items, 0).is_err());
+        assert!(inline_external_get_tail_holder_ids(&items, 4).is_err());
+    }
 }
 
 fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
@@ -446,6 +509,7 @@ pub struct ExternalInner {
     rpc_caller_external_batch_is_exist: RPCCaller<ExternalBatchIsExistReq>,
     rpc_caller_external_observability_snapshot: RPCCaller<ExternalObservabilitySnapshotReq>,
     rpc_caller_external_delete_ack: RPCCaller<ExternalDeleteAckReq>,
+    rpc_caller_external_batch_delete_ack: RPCCaller<ExternalBatchDeleteAckReq>,
     rpc_caller_external_put_revoke: RPCCaller<ExternalPutRevokeReq>,
     /// Lease RPC callers for external mode
     rpc_caller_allocate_client_lease: RPCCaller<AllocateClientLeaseReq>,
@@ -458,6 +522,7 @@ pub struct ExternalInner {
     /// per-key semaphore (permits=1) to ensure single inflight per key
     inflight1_per_key: SemaphoreMap<String>,
     put_trace_log_window: Mutex<ExternalPutTraceLogWindow>,
+    pub(crate) external_delete_ack_batch: ExternalDeleteAckBatchHandle,
 }
 
 pub struct ExternalClientApi(ExternalInner);
@@ -515,6 +580,7 @@ impl ExternalClientApi {
             rpc_caller_external_observability_snapshot:
                 RPCCaller::<ExternalObservabilitySnapshotReq>::new(),
             rpc_caller_external_delete_ack: RPCCaller::<ExternalDeleteAckReq>::new(),
+            rpc_caller_external_batch_delete_ack: RPCCaller::<ExternalBatchDeleteAckReq>::new(),
             rpc_caller_external_put_revoke: RPCCaller::<ExternalPutRevokeReq>::new(),
             rpc_caller_allocate_client_lease: RPCCaller::<AllocateClientLeaseReq>::new(),
             rpc_caller_client_lease_keepalive: RPCCaller::<ClientLeaseKeepaliveReq>::new(),
@@ -523,6 +589,7 @@ impl ExternalClientApi {
             pending_inline_external_get_start: DashMap::new(),
             inflight1_per_key: SemaphoreMap::new(1, std::time::Duration::from_secs(120)),
             put_trace_log_window: Mutex::new(ExternalPutTraceLogWindow::new()),
+            external_delete_ack_batch: ExternalDeleteAckBatchHandle::new(),
         }))
     }
 
@@ -620,12 +687,20 @@ impl ExternalClientApi {
             .regist(ext.view.p2p_module());
         ext.rpc_caller_external_delete_ack
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_delete_ack
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_put_revoke
             .regist(ext.view.p2p_module());
         crate::key_prefix::init_for_p2p_owner(ext.view.p2p_module());
         crate::kvlease::init_for_p2p_owner(ext.view.p2p_module());
         crate::metrics::client::init_for_p2p_owner(ext.view.p2p_module());
 
+        let external_delete_ack_rx = ext
+            .external_delete_ack_batch
+            .take_rx()
+            .expect("external holder ACK batch worker initialized twice");
+        spawn_external_delete_ack_batch(ext.view.clone_view(), external_delete_ack_rx);
+
         let view_ext = ext.view.clone_view();
         RPCHandler::<ExternalInvalidateWeakIndexReq>::new().regist(
             ext.view.p2p_module(),
@@ -2086,22 +2161,35 @@ impl ExternalInner {
         &self,
         handle: u64,
         keys: Vec<String>,
+        consume_prefix_len: usize,
     ) -> KvResult<Vec<KvResult<Option<Arc<ExternalMemHolder>>>>> {
         tracing::debug!(
-            "External batch_get_transfer request: handle={}, batch_len={}",
+            "External batch_get_transfer request: handle={}, batch_len={}, consume_prefix_len={}",
             handle,
-            keys.len()
+            keys.len(),
+            consume_prefix_len
         );
+        if consume_prefix_len == 0 || keys.len() != consume_prefix_len {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "batch_get_transfer keys must equal the non-empty consumed prefix: keys={} consume_prefix_len={}",
+                    keys.len(),
+                    consume_prefix_len
+                ),
+            }));
+        }
         if let Some((_handle, inline_plan)) = self.pending_inline_external_get_start.remove(&handle)
         {
-            if keys != inline_plan.keys {
+            if consume_prefix_len > inline_plan.keys.len()
+                || keys.as_slice() != &inline_plan.keys[..consume_prefix_len]
+            {
                 let expected_keys = inline_plan.keys.clone();
                 self.pending_inline_external_get_start
                     .insert(handle, inline_plan);
                 return Err(KvError::Api(ApiError::InvalidArgument {
                     detail: format!(
-                        "inline external batch_get_transfer keys mismatch: handle={} expected={:?} got={:?}",
-                        handle, expected_keys, keys
+                        "inline external batch_get_transfer prefix mismatch: handle={} consume_prefix_len={} available_keys={:?} got={:?}",
+                        handle, consume_prefix_len, expected_keys, keys
                     ),
                 }));
             }
@@ -2115,32 +2203,78 @@ impl ExternalInner {
                 }
             };
             let (_, current_owner_start_time, _, base_ptr_ro, mapped_len) = owner_snapshot;
-            validate_inline_external_get_owner_generation(
+            if let Err(err) = validate_inline_external_get_owner_generation(
                 inline_plan.owner_start_time,
                 current_owner_start_time,
-            )?;
-            validate_inline_external_get_start_plan(keys.len(), &inline_plan.items)?;
-            for (idx, item) in inline_plan.items.iter().enumerate() {
-                let info = item
-                    .external_memholder_info
-                    .as_ref()
-                    .expect("inline plan was validated above");
-                let end = info.offset.checked_add(u64::from(info.len)).ok_or_else(|| {
-                    KvError::Api(ApiError::Unknown {
-                        detail: format!(
-                            "inline external get_start item range overflow: index={} offset={} len={}",
-                            idx, info.offset, info.len
-                        ),
-                    })
-                })?;
-                if end > mapped_len {
-                    return Err(KvError::Api(ApiError::Unknown {
-                        detail: format!(
-                            "inline external get_start item exceeds owner mapping: index={} end={} mapped_len={}",
-                            idx, end, mapped_len
-                        ),
-                    }));
+            ) {
+                return Err(err);
+            }
+            if let Err(err) =
+                validate_inline_external_get_start_plan(inline_plan.keys.len(), &inline_plan.items)
+            {
+                self.pending_inline_external_get_start
+                    .insert(handle, inline_plan);
+                return Err(err);
+            }
+            let range_validation = inline_plan.items.iter().enumerate().try_for_each(
+                |(idx, item)| -> KvResult<()> {
+                    let info = item
+                        .external_memholder_info
+                        .as_ref()
+                        .expect("inline plan was validated above");
+                    let end = info.offset.checked_add(u64::from(info.len)).ok_or_else(|| {
+                        KvError::Api(ApiError::Unknown {
+                            detail: format!(
+                                "inline external get_start item range overflow: index={} offset={} len={}",
+                                idx, info.offset, info.len
+                            ),
+                        })
+                    })?;
+                    if end > mapped_len {
+                        return Err(KvError::Api(ApiError::Unknown {
+                            detail: format!(
+                                "inline external get_start item exceeds owner mapping: index={} end={} mapped_len={}",
+                                idx, end, mapped_len
+                            ),
+                        }));
+                    }
+                    Ok(())
+                },
+            );
+            if let Err(err) = range_validation {
+                self.pending_inline_external_get_start
+                    .insert(handle, inline_plan);
+                return Err(err);
+            }
+
+            let tail_holder_ids =
+                inline_external_get_tail_holder_ids(&inline_plan.items, consume_prefix_len)
+                    .expect("validated inline plan must yield tail holder ids");
+            if !tail_holder_ids.is_empty() {
+                let external_client_id = self.view.cluster_manager().get_self_info().id.clone();
+                let mut enqueue_failures = 0usize;
+                for holder_id in tail_holder_ids.iter().copied() {
+                    if let Err(err) = self.enqueue_external_delete_ack(
+                        external_client_id.clone(),
+                        holder_id,
+                        inline_plan.owner_start_time,
+                    ) {
+                        enqueue_failures += 1;
+                        tracing::warn!(
+                            "External inline get_transfer could not enqueue tail holder release: handle={} holder_id={} error={}",
+                            handle,
+                            holder_id,
+                            err
+                        );
+                    }
                 }
+                tracing::info!(
+                    "External inline get_transfer enqueued tail release: handle={}, consumed={}, released_tail={}, enqueue_failures={}",
+                    handle,
+                    consume_prefix_len,
+                    tail_holder_ids.len(),
+                    enqueue_failures
+                );
             }
 
             let bandwidth_handle = self
@@ -2150,7 +2284,10 @@ impl ExternalInner {
                 .expect("ExternalClientApi.batch_get_transfer expects IpcBandwidthAttributor handle to be attached");
             let external_client_id = self.view.cluster_manager().get_self_info().id.clone();
             let mut results = Vec::with_capacity(keys.len());
-            for (key, item) in keys.into_iter().zip(inline_plan.items.into_iter()) {
+            for (key, item) in keys
+                .into_iter()
+                .zip(inline_plan.items.into_iter().take(consume_prefix_len))
+            {
                 let info = item
                     .external_memholder_info
                     .expect("inline plan was validated above");
@@ -2202,6 +2339,7 @@ impl ExternalInner {
                 handle,
                 req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
                 started_time,
+                consume_prefix_len,
             },
             raw_bytes: Vec::new(),
         };
@@ -2268,6 +2406,51 @@ impl ExternalInner {
         Ok(results)
     }
 
+    async fn send_batch_get_cancel_plan(
+        &self,
+        handle: u64,
+        started_time: i64,
+        transfer_plan: ExternalBatchGetCancelPlan,
+    ) -> KvResult<()> {
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let req = MsgPack {
+            serialize_part: ExternalBatchGetCancelReq {
+                handle,
+                req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
+                started_time,
+                transfer_plan,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let resp = match self
+            .rpc_caller_external_batch_get_cancel
+            .call(self.view.p2p_module(), owner.into(), req, None, 0)
+            .await
+        {
+            Ok(resp) => resp,
+            Err(err) => return Err(KvError::from(err)),
+        };
+        if resp.serialize_part.error_code == OK {
+            return Ok(());
+        }
+        let err = KvError::from_json(
+            resp.serialize_part.error_code,
+            &resp.serialize_part.error_json,
+        );
+        if matches!(&err, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
+            tracing::info!(
+                "send_batch_get_cancel_plan: owner start_time mismatch; owner restarted, treating handle as gone"
+            );
+            return Ok(());
+        }
+        Err(err)
+    }
+
     pub async fn cancel_batch_get_start(&self, handle: u64) -> KvResult<()> {
         tracing::debug!("External cancel_batch_get_start request: handle={}", handle);
         let inline_plan = self
@@ -2302,57 +2485,15 @@ impl ExternalInner {
             },
             None => ExternalBatchGetCancelPlan::OwnerRpc,
         };
-        let owner = match self.shared_storage_node_id().await {
-            Some(owner) => owner,
-            None => {
-                if let Some(plan) = inline_plan {
-                    self.pending_inline_external_get_start.insert(handle, plan);
-                }
-                return Err(KvError::SharedMem(SharedMemError::NotConfigured {
-                    node_id: None,
-                    detail: Some("Shared storage node id unavailable".to_string()),
-                }));
-            }
-        };
-        let req = MsgPack {
-            serialize_part: ExternalBatchGetCancelReq {
-                handle,
-                req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
-                started_time,
-                transfer_plan,
-            },
-            raw_bytes: Vec::new(),
-        };
-        let resp = match self
-            .rpc_caller_external_batch_get_cancel
-            .call(self.view.p2p_module(), owner.into(), req, None, 0)
-            .await
-        {
-            Ok(resp) => resp,
-            Err(err) => {
-                if let Some(plan) = inline_plan {
-                    self.pending_inline_external_get_start.insert(handle, plan);
-                }
-                return Err(KvError::from(err));
+        let cancel_result = self
+            .send_batch_get_cancel_plan(handle, started_time, transfer_plan)
+            .await;
+        if cancel_result.is_err() {
+            if let Some(plan) = inline_plan {
+                self.pending_inline_external_get_start.insert(handle, plan);
             }
-        };
-        if resp.serialize_part.error_code == OK {
-            return Ok(());
-        }
-        let err = KvError::from_json(
-            resp.serialize_part.error_code,
-            &resp.serialize_part.error_json,
-        );
-        if matches!(&err, KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) {
-            tracing::info!(
-                "cancel_batch_get_start: owner start_time mismatch; owner restarted, treating handle as gone"
-            );
-            return Ok(());
-        }
-        if let Some(plan) = inline_plan {
-            self.pending_inline_external_get_start.insert(handle, plan);
         }
-        Err(err)
+        cancel_result
     }
 
     pub async fn get_start(
@@ -2401,6 +2542,7 @@ impl ExternalInner {
             PendingExternalGetStart {
                 keys: keys.clone(),
                 transferable_len,
+                atomic_group_lens: group_lens,
                 first_miss_index,
             },
         );
@@ -2414,6 +2556,7 @@ impl ExternalInner {
     pub async fn get_transfer(
         &self,
         handle: u64,
+        consume_prefix_len: Option<usize>,
     ) -> KvResult<Vec<KvResult<Option<Arc<ExternalMemHolder>>>>> {
         let Some((_handle, entry)) = self.pending_external_get_start.remove(&handle) else {
             return Err(KvError::Api(ApiError::InvalidArgument {
@@ -2437,8 +2580,21 @@ impl ExternalInner {
                 ),
             }));
         }
-        self.batch_get_transfer(handle, entry.keys[..entry.transferable_len].to_vec())
-            .await
+        let consume_prefix_len = consume_prefix_len.unwrap_or(entry.transferable_len);
+        if let Err(err) = validate_external_get_consume_prefix(
+            consume_prefix_len,
+            entry.transferable_len,
+            &entry.atomic_group_lens,
+        ) {
+            self.pending_external_get_start.insert(handle, entry);
+            return Err(err);
+        }
+        self.batch_get_transfer(
+            handle,
+            entry.keys[..consume_prefix_len].to_vec(),
+            consume_prefix_len,
+        )
+        .await
     }
 
     pub async fn cancel_get_transfer(&self, handle: u64) -> KvResult<()> {
@@ -3882,6 +4038,72 @@ key={}, attempt={}/{}, err={}",
         Ok(())
     }
 
+    pub(crate) fn enqueue_external_delete_ack(
+        &self,
+        external_client_id: String,
+        holder_id: u64,
+        owner_start_time: i64,
+    ) -> Result<(), String> {
+        self.external_delete_ack_batch
+            .enqueue(ExternalDeleteAckItem {
+                external_client_id,
+                holder_id,
+                owner_start_time,
+            })
+    }
+
+    pub(crate) fn external_delete_ack_batch_snapshot(&self) -> ExternalDeleteAckBatchSnapshot {
+        self.external_delete_ack_batch.snapshot()
+    }
+
+    pub(crate) async fn send_external_delete_ack_batch(
+        &self,
+        external_client_id: &str,
+        owner_start_time: i64,
+        holder_ids: Vec<u64>,
+    ) -> KvResult<ExternalDeleteAckBatchSendResult> {
+        let item_count = u64::try_from(holder_ids.len()).unwrap_or(u64::MAX);
+        let req = MsgPack {
+            serialize_part: ExternalBatchDeleteAckReq {
+                external_client_id: external_client_id.to_string(),
+                holder_ids,
+                started_time: owner_start_time,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let owner = self.shared_storage_node_id().await.ok_or_else(|| {
+            KvError::SharedMem(SharedMemError::NotConfigured {
+                node_id: None,
+                detail: Some("Shared storage node id unavailable".to_string()),
+            })
+        })?;
+        let resp = self
+            .rpc_caller_external_batch_delete_ack
+            .call(self.view.p2p_module(), owner.into(), req, None, 0)
+            .await
+            .map_err(KvError::from)?;
+        match resp.serialize_part.to_result() {
+            Ok(resp) => {
+                let accounted = u64::from(resp.released_count) + u64::from(resp.missing_count);
+                if accounted != item_count {
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "external holder ACK batch accounted for {accounted} of {item_count} items"
+                        ),
+                    }));
+                }
+                Ok(ExternalDeleteAckBatchSendResult::Applied {
+                    released: resp.released_count,
+                    missing: resp.missing_count,
+                })
+            }
+            Err(KvError::Api(ApiError::OwnerStartTimeMismatch { .. })) => {
+                Ok(ExternalDeleteAckBatchSendResult::OwnerGenerationChanged { items: item_count })
+            }
+            Err(err) => Err(err),
+        }
+    }
+
     /// Allocate a client lease (external role): send request to master via P2P.
     ///
     /// Semantics:
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index 3be65fe..3939fb2 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -153,6 +153,29 @@ pub enum ReservedCapacityReason {
     LeaseBoundKv,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct NodeCacheCapacityBoundaries {
+    ring_b_bytes: u64,
+    tier1_bytes: Option<u64>,
+}
+
+fn node_cache_capacity_boundaries(
+    node_space_size: u64,
+    replica_cache_capacity_ratio: f64,
+    replica_writeback_tier1_capacity_ratio: Option<f64>,
+    reserved_capacity_bytes: u64,
+) -> NodeCacheCapacityBoundaries {
+    let ring_b_base = (node_space_size as f64 * replica_cache_capacity_ratio).floor() as u64;
+    NodeCacheCapacityBoundaries {
+        ring_b_bytes: ring_b_base.saturating_sub(reserved_capacity_bytes),
+        // Tier1 contains only metadata and defines when pre-writeback starts.
+        // It is inclusive of owner residency, so physical ring-B reservations
+        // never reduce this logical policy window.
+        tier1_bytes: replica_writeback_tier1_capacity_ratio
+            .map(|ratio| (node_space_size as f64 * ratio).floor() as u64),
+    }
+}
+
 #[derive(Debug)]
 pub struct NodeCacheReservedCapacity {
     /// Exact node registration generation owning these counters.
@@ -375,6 +398,11 @@ pub struct InflightPutInfo {
 
 #[derive(Clone)]
 pub struct InflightReplicaTaskInfo {
+    /// Distinguishes repeated remote-copy attempts for the same `(key,
+    /// put_id)` generation.  A generation may lose its remote route and need
+    /// another append while the previous attempt's replayable terminal result
+    /// is still cached.
+    pub operation_id: u64,
     pub node_id: NodeID,
     /// Exact target registration generation that owns `target_allocation`.
     pub target_tomb_tag: NodeTombTag,
@@ -389,6 +417,11 @@ pub struct InflightReplicaTaskInfo {
     pub(crate) _activity_lease: Arc<MasterKeyActivityLease>,
 }
 
+#[derive(Clone, Debug)]
+pub struct CompletedReplicaTaskInfo {
+    pub appended: bool,
+}
+
 /// Information about a `get` operation that is currently in progress.
 #[derive(Clone)]
 pub struct InflightGetInfo {
@@ -517,6 +550,18 @@ pub(crate) struct MasterKeyActivitySnapshot {
     pub reclaim_installed: bool,
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+struct MasterKeyActivityObserveSnapshot {
+    active_keys: u64,
+    put_keys: u64,
+    get_keys: u64,
+    replica_keys: u64,
+    reclaim_keys: u64,
+    inflight_puts: u64,
+    inflight_gets: u64,
+    inflight_replicas: u64,
+}
+
 #[derive(Clone, Copy, Debug)]
 enum MasterKeyActivityKind {
     Put,
@@ -750,6 +795,26 @@ impl MasterKeyActivityTable {
         }
     }
 
+    fn observe_snapshot(&self) -> MasterKeyActivityObserveSnapshot {
+        let states = self.states.lock();
+        let mut snapshot = MasterKeyActivityObserveSnapshot {
+            active_keys: u64::try_from(states.len()).unwrap_or(u64::MAX),
+            ..Default::default()
+        };
+        for state in states.values() {
+            snapshot.put_keys += u64::from(state.puts != 0);
+            snapshot.get_keys += u64::from(state.gets != 0);
+            snapshot.replica_keys += u64::from(state.replicas != 0);
+            snapshot.reclaim_keys += u64::from(state.reclaim.is_some());
+            snapshot.inflight_puts = snapshot.inflight_puts.saturating_add(u64::from(state.puts));
+            snapshot.inflight_gets = snapshot.inflight_gets.saturating_add(u64::from(state.gets));
+            snapshot.inflight_replicas = snapshot
+                .inflight_replicas
+                .saturating_add(u64::from(state.replicas));
+        }
+        snapshot
+    }
+
     pub(crate) fn reclaim_matches(&self, item: &OwnerReclaimItem) -> bool {
         self.states
             .lock()
@@ -1472,6 +1537,61 @@ mod tests {
         );
     }
 
+    #[test]
+    fn master_key_activity_observe_snapshot_counts_keys_and_leases() {
+        let table = Arc::new(MasterKeyActivityTable::default());
+        let put = table
+            .reserve("shared", MasterKeyActivityKind::Put, false)
+            .expect("put activity must be admitted");
+        let get_a = table
+            .reserve("shared", MasterKeyActivityKind::Get, false)
+            .expect("first get activity must be admitted");
+        let get_b = table
+            .reserve("shared", MasterKeyActivityKind::Get, false)
+            .expect("second get activity must be admitted");
+        let replica = table
+            .reserve("replica", MasterKeyActivityKind::Replica, false)
+            .expect("replica activity must be admitted");
+        let reclaim = OwnerReclaimItem {
+            key: "reclaim".to_string(),
+            put_id: (9, 1),
+            epoch: 17,
+            backing: OwnerReclaimBacking::CommittedSlot {
+                grant_id: 19,
+                slot_index: 23,
+                slot_size: 8 * 1024 * 1024,
+            },
+            reason: OwnerReclaimReason::OwnerCapacityEviction,
+        };
+        table
+            .try_install_reclaim(&reclaim)
+            .expect("idle key must accept reclaim fence");
+
+        assert_eq!(
+            table.observe_snapshot(),
+            MasterKeyActivityObserveSnapshot {
+                active_keys: 3,
+                put_keys: 1,
+                get_keys: 1,
+                replica_keys: 1,
+                reclaim_keys: 1,
+                inflight_puts: 1,
+                inflight_gets: 2,
+                inflight_replicas: 1,
+            }
+        );
+
+        drop(put);
+        drop(get_a);
+        drop(get_b);
+        drop(replica);
+        assert!(table.clear_reclaim(&reclaim));
+        assert_eq!(
+            table.observe_snapshot(),
+            MasterKeyActivityObserveSnapshot::default()
+        );
+    }
+
     #[test]
     fn explicit_activity_completion_is_idempotent_with_retired_cache_clones() {
         let table = Arc::new(MasterKeyActivityTable::default());
@@ -1489,6 +1609,35 @@ mod tests {
         assert!(table.is_quiescent("retired-clone"));
     }
 
+    #[test]
+    fn replica_terminal_result_is_scoped_to_one_append_attempt() {
+        let terminals = moka::sync::Cache::builder()
+            .time_to_live(Duration::from_secs(120))
+            .build();
+        let key = "same-kv-generation".to_string();
+        let put_id = (17, 3);
+        let first_operation_id = 41;
+        let second_operation_id = 42;
+
+        terminals.insert(
+            (key.clone(), put_id.0, put_id.1, first_operation_id),
+            CompletedReplicaTaskInfo { appended: true },
+        );
+
+        assert!(
+            terminals
+                .get(&(key.clone(), put_id.0, put_id.1, first_operation_id))
+                .is_some(),
+            "a retry of the same append attempt must replay its terminal result"
+        );
+        assert!(
+            terminals
+                .get(&(key, put_id.0, put_id.1, second_operation_id))
+                .is_none(),
+            "an old terminal result must not complete a later remote-copy attempt"
+        );
+    }
+
     fn test_route_info_with_tag(node_id: &str, tomb_tag: NodeTombTag) -> KvRouteInfo {
         KvRouteInfo {
             node_id: node_id.to_string().into(),
@@ -1827,6 +1976,17 @@ mod tests {
         assert!(!new_tag.is_tomb());
     }
 
+    #[test]
+    fn tier1_capacity_is_independent_of_ring_b_reservations() {
+        let node_space_size = 128 * 1024 * 1024 * 1024;
+        let boundaries =
+            node_cache_capacity_boundaries(node_space_size, 0.95, Some(0.75), 124_554_051_584);
+
+        assert_eq!(boundaries.ring_b_bytes, 6_012_954_214);
+        assert_eq!(boundaries.tier1_bytes, Some(96 * 1024 * 1024 * 1024));
+        assert!(boundaries.tier1_bytes.unwrap() > boundaries.ring_b_bytes);
+    }
+
     #[test]
     fn delayed_member_left_is_not_forwarded_to_a_live_generation_actor() {
         assert!(member_left_can_forward_to_registration_actor(None));
@@ -2097,6 +2257,14 @@ pub struct MasterKvRouterInner {
     /// (key, put_time_ms, put_version) -> inflight_put_info
     pub inflight_puts: moka::future::Cache<(String, u64, u32), InflightPutInfo>,
     pub inflight_replica_tasks: moka::future::Cache<(String, u64, u32), InflightReplicaTaskInfo>,
+    /// Idempotent terminal PutAppendDone results retained across response
+    /// loss and batch-to-individual fallback.
+    pub completed_replica_tasks:
+        moka::future::Cache<(String, u64, u32, u64), CompletedReplicaTaskInfo>,
+    /// Serializes Start/Done/Revoke for one replica operation identity. The
+    /// lock is per `(key, put_id)`, so unrelated remote writes never share a
+    /// queue or actor.
+    pub replica_operation_locks: AMapLock<(String, u64, u32)>,
     pub inflight_gets: moka::future::Cache<u64, InflightGetInfo>,
     /// Idempotent terminal GetDone results retained across response loss/retry.
     pub completed_gets: moka::future::Cache<u64, CompletedGetInfo>,
@@ -2119,6 +2287,11 @@ pub struct MasterKvRouterInner {
     /// Counter for prepared put-key reservation identifiers.
     pub next_prepared_put_key_reservation_id: AtomicU64,
 
+    /// Counter for concrete replica append attempts.  This is separate from
+    /// `put_id`: one KV generation may legitimately be copied remotely again
+    /// after its previous remote route is reclaimed.
+    pub next_replica_operation_id: AtomicU64,
+
     /// Counter for two-sided owner reclaim epochs.
     pub next_owner_reclaim_epoch: AtomicU64,
 
@@ -2180,6 +2353,9 @@ pub struct MasterKvRouterInner {
 
     /// Historical accepted replica task reservations by target node.
     pub replica_task_target_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
+    /// PutAppendDone responses served from the terminal cache after an RPC
+    /// replay or batch fallback.
+    pub replica_done_terminal_replay_count: AtomicU64,
 
     /// Historical get source choices by requester->source pair.
     pub get_requester_source_counts: DashMap<RequesterTargetPair, Arc<AtomicU64>>,
@@ -2319,6 +2495,9 @@ impl MasterKvRouter {
                 }
             })
             .build();
+        let completed_replica_tasks = moka::future::Cache::builder()
+            .time_to_live(Duration::from_secs(120))
+            .build();
         // A synchronous Moka listener must perform only constant-size metadata
         // work and must never block or drop an Allocation reclaim event.  The
         // versioned inflight set deduplicates this unbounded channel.
@@ -2336,6 +2515,8 @@ impl MasterKvRouter {
             replica_writeback_tier1_capacity_ratio: arg.replica_writeback_tier1_capacity_ratio,
             inflight_puts,
             inflight_replica_tasks,
+            completed_replica_tasks,
+            replica_operation_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             inflight_gets,
             completed_gets,
             get_done_locks: AMapLock::new(Duration::from_secs(10 * 60)),
@@ -2346,6 +2527,7 @@ impl MasterKvRouter {
             next_holder_id: AtomicU64::new(0),
             next_local_reserve_grant_id: AtomicU64::new(1),
             next_prepared_put_key_reservation_id: AtomicU64::new(1),
+            next_replica_operation_id: AtomicU64::new(1),
             next_owner_reclaim_epoch: AtomicU64::new(1),
             kv_routes: DashMap::new(),
             put_atomic_groups: moka::sync::SegmentedCache::builder(8)
@@ -2366,6 +2548,7 @@ impl MasterKvRouter {
             put_requester_target_decision_counts: DashMap::new(),
             put_placement_mode_counts: DashMap::new(),
             replica_task_target_counts: DashMap::new(),
+            replica_done_terminal_replay_count: AtomicU64::new(0),
             get_requester_source_counts: DashMap::new(),
             get_requester_source_bytes: DashMap::new(),
             get_allocation_mode_counts: DashMap::new(),
@@ -2440,7 +2623,13 @@ impl MasterKvRouter {
     }
 
     fn replica_cache_base_capacity(&self, node_space_size: u64) -> u64 {
-        (node_space_size as f64 * self.inner().replica_cache_capacity_ratio).floor() as u64
+        node_cache_capacity_boundaries(
+            node_space_size,
+            self.inner().replica_cache_capacity_ratio,
+            self.inner().replica_writeback_tier1_capacity_ratio,
+            0,
+        )
+        .ring_b_bytes
     }
 
     fn replica_cache_effective_capacity(&self, node_id: &str, node_space_size: u64) -> u64 {
@@ -2451,13 +2640,19 @@ impl MasterKvRouter {
             .filter(|reserved| !reserved.generation.is_tomb())
             .map(|reserved| reserved.total_reserved_bytes())
             .unwrap_or(0);
-        self.replica_cache_base_capacity(node_space_size)
-            .saturating_sub(reserved_capacity)
+        node_cache_capacity_boundaries(
+            node_space_size,
+            self.inner().replica_cache_capacity_ratio,
+            self.inner().replica_writeback_tier1_capacity_ratio,
+            reserved_capacity,
+        )
+        .ring_b_bytes
     }
 
-    /// Refresh an already-created node controller after segment metadata or
-    /// reservation inputs change. The boundary is derived only from physical
-    /// node space and generation-scoped reservations, never placement roles.
+    /// Refresh already-created node controllers after segment metadata or
+    /// reservation inputs change. Generation-scoped reservations reduce only
+    /// the physical ring-B allocation boundary. Tier1 is an inclusive metadata
+    /// policy window and always remains ratio-derived from the owner segment.
     fn reconcile_node_cache_capacity(&self, node_id: &str) {
         let node_space_size = self
             .inner()
@@ -2489,8 +2684,7 @@ impl MasterKvRouter {
         {
             let tier1_capacity = self
                 .writeback_tier1_base_capacity(node_space_size)
-                .unwrap_or(0)
-                .min(capacity);
+                .unwrap_or(0);
             if let Err(err) = cache.set_max_capacity(tier1_capacity) {
                 error!(
                     "failed to refresh tier1 cache capacity: node={} capacity={} err={}",
@@ -2501,9 +2695,13 @@ impl MasterKvRouter {
     }
 
     fn writeback_tier1_base_capacity(&self, node_space_size: u64) -> Option<u64> {
-        self.inner()
-            .replica_writeback_tier1_capacity_ratio
-            .map(|ratio| (node_space_size as f64 * ratio).floor() as u64)
+        node_cache_capacity_boundaries(
+            node_space_size,
+            self.inner().replica_cache_capacity_ratio,
+            self.inner().replica_writeback_tier1_capacity_ratio,
+            0,
+        )
+        .tier1_bytes
     }
 
     pub fn tiered_writeback_enabled(&self) -> bool {
@@ -4363,6 +4561,10 @@ impl MasterKvRouter {
                             .map(|entry| (entry.key().clone(), entry.value().load(Ordering::Relaxed)))
                             .collect();
                         replica_task_target_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+                        let replica_done_terminal_replays = router
+                            .inner()
+                            .replica_done_terminal_replay_count
+                            .load(Ordering::Relaxed);
 
                         let mut get_source_counts: Vec<(String, u64)> = router
                             .inner()
@@ -4389,11 +4591,12 @@ impl MasterKvRouter {
                         get_allocation_mode_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
 
                         info!(
-                            "placement historical distribution | put_target_counts={:?} | put_mode_counts={:?} | put_requester_target_counts={:?} | replica_task_target_counts={:?} | get_requester_source_counts={:?} | get_requester_source_bytes={:?} | get_allocation_mode_counts={:?}",
+                            "placement historical distribution | put_target_counts={:?} | put_mode_counts={:?} | put_requester_target_counts={:?} | replica_task_target_counts={:?} | replica_done_terminal_replays={} | get_requester_source_counts={:?} | get_requester_source_bytes={:?} | get_allocation_mode_counts={:?}",
                             target_counts,
                             mode_counts,
                             requester_target_counts,
                             replica_task_target_counts,
+                            replica_done_terminal_replays,
                             get_source_counts,
                             get_source_bytes,
                             get_allocation_mode_counts,
@@ -4738,8 +4941,13 @@ impl MasterKvRouter {
                 ),
             );
         }
-        let base_capacity = self.replica_cache_base_capacity(node_space_size);
-        let new_capacity = base_capacity.saturating_sub(reserved_total);
+        let boundaries = node_cache_capacity_boundaries(
+            node_space_size,
+            self.inner().replica_cache_capacity_ratio,
+            self.inner().replica_writeback_tier1_capacity_ratio,
+            reserved_total,
+        );
+        let new_capacity = boundaries.ring_b_bytes;
 
         if let Some(cache) = self.get_node_cache_controller(node_id) {
             if let Some(tier1_cache) = self
@@ -4748,10 +4956,10 @@ impl MasterKvRouter {
                 .get(node_id)
                 .map(|entry| entry.value().clone())
             {
-                let tier1_capacity = self
-                    .writeback_tier1_base_capacity(node_space_size)
-                    .unwrap_or(0)
-                    .min(new_capacity);
+                // Local-reserve and owner-indexed reservations consume the
+                // physical ring-B allocation domain. They must not collapse
+                // the independent inclusive tier1 metadata window.
+                let tier1_capacity = boundaries.tier1_bytes.unwrap_or(0);
                 if let Err(e) = tier1_cache.set_max_capacity(tier1_capacity) {
                     if delta_bytes >= 0 {
                         reserved_capacity.apply_delta(reason, -delta_bytes);
@@ -5079,6 +5287,11 @@ impl MasterKvRouter {
                     _ = shutdown_waiter.wait() => break,
                     _ = interval.tick() => {
                         let snapshot = view_task.master_kv_router().runtime_observe_snapshot();
+                        let activity = view_task
+                            .master_kv_router()
+                            .inner()
+                            .key_activity
+                            .observe_snapshot();
                         let metrics = view_task.metric_reporter().metrics();
                         metrics.set_kv_holding_entries(
                             "master_get_holding",
@@ -5093,6 +5306,17 @@ impl MasterKvRouter {
                             snapshot.get_holding_entries,
                             snapshot.get_holding_bytes
                         );
+                        tracing::info!(
+                            active_keys = activity.active_keys,
+                            put_keys = activity.put_keys,
+                            get_keys = activity.get_keys,
+                            replica_keys = activity.replica_keys,
+                            reclaim_keys = activity.reclaim_keys,
+                            inflight_puts = activity.inflight_puts,
+                            inflight_gets = activity.inflight_gets,
+                            inflight_replicas = activity.inflight_replicas,
+                            "master key activity runtime"
+                        );
                         for node in snapshot.replica_cache_nodes {
                             tracing::info!(
                                 "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_victims={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} last_route_removed_members={} last_route_removed_bytes={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index da9b0b8..7ba3eb0 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -1018,6 +1018,13 @@ pub enum PutAppendStartOutcome {
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct PutAppendStartResp {
     pub outcome: PutAppendStartOutcome,
+    /// Master-issued identity for this concrete replica append attempt.
+    ///
+    /// `put_id` identifies the KV generation, but one generation may need to
+    /// be copied remotely more than once after an earlier remote route is
+    /// reclaimed.  Done/Revoke must echo this value so an old replayable
+    /// terminal result cannot complete a later reservation.
+    pub operation_id: u64,
     pub node_id: NodeIDString,
     pub target_addr: u64,
     pub target_base_addr: u64,
@@ -1059,6 +1066,7 @@ pub struct BatchPutAppendStartItemResp {
     pub key: String,
     pub put_id: PutIDForAKey,
     pub outcome: PutAppendStartOutcome,
+    pub operation_id: u64,
     pub node_id: NodeIDString,
     pub target_addr: u64,
     pub target_base_addr: u64,
@@ -1087,6 +1095,7 @@ impl RPCReq for BatchPutAppendStartReq {
 pub struct PutAppendRevokeReq {
     pub key: String,
     pub put_id: PutIDForAKey,
+    pub operation_id: u64,
 }
 impl MsgPackSerializePart for PutAppendRevokeReq {
     fn msg_id(&self) -> u32 {
@@ -1111,6 +1120,7 @@ impl RPCReq for PutAppendRevokeReq {
 pub struct PutAppendDoneReq {
     pub key: String,
     pub put_id: PutIDForAKey,
+    pub operation_id: u64,
 }
 impl MsgPackSerializePart for PutAppendDoneReq {
     fn msg_id(&self) -> u32 {
@@ -1137,6 +1147,7 @@ impl RPCReq for PutAppendDoneReq {
 pub struct BatchPutAppendDoneItemReq {
     pub key: String,
     pub put_id: PutIDForAKey,
+    pub operation_id: u64,
 }
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index 1edc824..f5bdef4 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -1,6 +1,6 @@
 use super::{
-    CommittedSlotReplica, InflightPutAllocation, InflightPutCommitInfo, InflightPutInfo,
-    InflightReplicaTaskInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo,
+    CommittedSlotReplica, CompletedReplicaTaskInfo, InflightPutAllocation, InflightPutCommitInfo,
+    InflightPutInfo, InflightReplicaTaskInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo,
     MasterKeyActivityCompletionGuard, MasterKvRouterView, NodeCacheCapacityReservation,
     OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
     msg_pack::{
@@ -487,6 +487,15 @@ fn reserve_replica_task_excluding(
     protect_source_on_remote_complete: bool,
 ) -> msg_and_error::KvResult<InflightReplicaTaskInfo> {
     let activity_lease = view.master_kv_router().reserve_inflight_replica_key(key)?;
+    let operation_id = view
+        .master_kv_router()
+        .inner()
+        .next_replica_operation_id
+        .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    assert_ne!(
+        operation_id, 0,
+        "master replica operation identifier overflow"
+    );
     view.master_kv_router()
         .pin_current_master_cache_identity_for_activity(
             &activity_lease,
@@ -519,16 +528,18 @@ fn reserve_replica_task_excluding(
         ));
     };
     tracing::debug!(
-        "replica task reserved: key={} put_id=({},{}) source_node_id={} target_node_id={} preferred_sub_cluster={:?} len={}",
+        "replica task reserved: key={} put_id=({},{}) operation_id={} source_node_id={} target_node_id={} preferred_sub_cluster={:?} len={}",
         key,
         put_id.0,
         put_id.1,
+        operation_id,
         source_node_id,
         target_node_id,
         preferred_sub_cluster,
         len
     );
     Ok(InflightReplicaTaskInfo {
+        operation_id,
         node_id: target_node_id,
         target_tomb_tag,
         source_node_id: source_node_id.clone(),
@@ -2109,6 +2120,13 @@ async fn handle_put_append_start_inner(
 ) -> MsgPack<PutAppendStartResp> {
     let key = req.serialize_part.key.clone();
     let put_id = req.serialize_part.put_id;
+    let append_key = (key.clone(), put_id.0, put_id.1);
+    let operation_lock = view
+        .master_kv_router()
+        .inner()
+        .replica_operation_locks
+        .get_lock(append_key.clone());
+    let _operation_guard = operation_lock.lock().await;
     let route_snapshot = view
         .master_kv_router()
         .inner()
@@ -2140,7 +2158,6 @@ async fn handle_put_append_start_inner(
         };
     }
 
-    let append_key = (key.clone(), put_id.0, put_id.1);
     let inflight = if let Some(existing) = view
         .master_kv_router()
         .inner()
@@ -2245,6 +2262,7 @@ async fn handle_put_append_start_inner(
     MsgPack {
         serialize_part: PutAppendStartResp {
             outcome: PutAppendStartOutcome::Scheduled,
+            operation_id: inflight.operation_id,
             node_id: inflight.node_id.clone().into(),
             target_addr,
             target_base_addr,
@@ -2294,6 +2312,7 @@ pub async fn handle_batch_put_append_start(
             key: item.key,
             put_id: item.put_id,
             outcome: part.outcome,
+            operation_id: part.operation_id,
             node_id: part.node_id,
             target_addr: part.target_addr,
             target_base_addr: part.target_base_addr,
@@ -2319,14 +2338,50 @@ pub async fn handle_put_append_revoke(
 ) -> MsgPack<PutAppendRevokeResp> {
     let put_id = req.serialize_part.put_id;
     let key = req.serialize_part.key;
-    if let Some(inflight) = view
+    let operation_id = req.serialize_part.operation_id;
+    let generation_identity = (key.clone(), put_id.0, put_id.1);
+    let operation_identity = (key.clone(), put_id.0, put_id.1, operation_id);
+    let operation_lock = view
         .master_kv_router()
         .inner()
-        .inflight_replica_tasks
-        .remove(&(key, put_id.0, put_id.1))
+        .replica_operation_locks
+        .get_lock(generation_identity.clone());
+    let _operation_guard = operation_lock.lock().await;
+    if view
+        .master_kv_router()
+        .inner()
+        .completed_replica_tasks
+        .get(&operation_identity)
         .await
+        .is_some()
     {
-        inflight._activity_lease.release_now();
+        return MsgPack {
+            serialize_part: PutAppendRevokeResp {
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+    let inflight = view
+        .master_kv_router()
+        .inner()
+        .inflight_replica_tasks
+        .get(&generation_identity)
+        .await;
+    if inflight
+        .as_ref()
+        .is_some_and(|inflight| inflight.operation_id == operation_id)
+    {
+        if let Some(inflight) = view
+            .master_kv_router()
+            .inner()
+            .inflight_replica_tasks
+            .remove(&generation_identity)
+            .await
+        {
+            inflight._activity_lease.release_now();
+        }
     }
     MsgPack {
         serialize_part: PutAppendRevokeResp {
@@ -2343,17 +2398,77 @@ async fn handle_put_append_done_inner(
 ) -> MsgPack<PutAppendDoneResp> {
     let put_id = req.serialize_part.put_id;
     let key = req.serialize_part.key.clone();
+    let operation_id = req.serialize_part.operation_id;
+    let generation_identity = (key.clone(), put_id.0, put_id.1);
+    let operation_identity = (key.clone(), put_id.0, put_id.1, operation_id);
+    let operation_lock = view
+        .master_kv_router()
+        .inner()
+        .replica_operation_locks
+        .get_lock(generation_identity.clone());
+    let _operation_guard = operation_lock.lock().await;
+    if let Some(completed) = view
+        .master_kv_router()
+        .inner()
+        .completed_replica_tasks
+        .get(&operation_identity)
+        .await
+    {
+        view.master_kv_router()
+            .inner()
+            .replica_done_terminal_replay_count
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        return MsgPack {
+            serialize_part: PutAppendDoneResp {
+                appended: completed.appended,
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+                server_process_us: 0,
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+    let Some(current) = view
+        .master_kv_router()
+        .inner()
+        .inflight_replica_tasks
+        .get(&generation_identity)
+        .await
+    else {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "Put append operation not found for completion: key={} put_id=({},{}) operation_id={}",
+                key, put_id.0, put_id.1, operation_id
+            ),
+        });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    };
+    if current.operation_id != operation_id {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+            detail: format!(
+                "Put append operation generation mismatch: key={} put_id=({},{}) requested_operation_id={} current_operation_id={}",
+                key, put_id.0, put_id.1, operation_id, current.operation_id
+            ),
+        });
+        return MsgPack {
+            serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+            raw_bytes: Vec::new(),
+        };
+    }
     let Some(inflight) = view
         .master_kv_router()
         .inner()
         .inflight_replica_tasks
-        .remove(&(key.clone(), put_id.0, put_id.1))
+        .remove(&generation_identity)
         .await
     else {
         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
             detail: format!(
-                "Put append operation not found for completion: key={} put_id=({},{})",
-                key, put_id.0, put_id.1
+                "Put append operation disappeared during completion: key={} put_id=({},{}) operation_id={}",
+                key, put_id.0, put_id.1, operation_id
             ),
         });
         return MsgPack {
@@ -2384,6 +2499,11 @@ async fn handle_put_append_done_inner(
         allocation,
     );
     let appended = published.is_some();
+    view.master_kv_router()
+        .inner()
+        .completed_replica_tasks
+        .insert(operation_identity, CompletedReplicaTaskInfo { appended })
+        .await;
     if let Some(event) = published {
         enqueue_post_route_maintenance(&view, event).await;
     }
@@ -2413,10 +2533,15 @@ pub async fn handle_batch_put_append_done(
     for item in req.serialize_part.items {
         let key = item.key.clone();
         let put_id = item.put_id;
+        let operation_id = item.operation_id;
         let resp = handle_put_append_done_inner(
             view.clone(),
             MsgPack {
-                serialize_part: PutAppendDoneReq { key, put_id },
+                serialize_part: PutAppendDoneReq {
+                    key,
+                    put_id,
+                    operation_id,
+                },
                 raw_bytes: Vec::new(),
             },
         )
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
index 22f7df6..f42cd24 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
@@ -363,7 +363,7 @@ mod single_victim_transaction_tests {
             .expect("busy victim must hold a master Get lease");
         let stale_request = source_victim("stale", stale.put_id, 999, 2);
         let victims = vec![ready.clone(), busy.clone(), stale_request];
-        let responses = direct_delete_exact_owner_source_batch_with(
+        let (responses, busy_summary) = direct_delete_exact_owner_source_batch_with(
             activity.as_ref(),
             &owner,
             77,
@@ -391,6 +391,15 @@ mod single_victim_transaction_tests {
             vec![0, 1, 2],
             "one batch response vector must stay aligned with every input victim"
         );
+        assert_eq!(
+            busy_summary,
+            DirectDeleteBatchBusySummary {
+                activity_busy_items: 1,
+                get_busy_items: 1,
+                inflight_gets: 1,
+                ..Default::default()
+            }
+        );
         assert!(!routes.contains_key(&ready.key));
         assert!(routes.contains_key(&busy.key));
         assert!(routes.contains_key(&stale.key));
@@ -408,7 +417,8 @@ mod single_victim_transaction_tests {
                 false
             },
         );
-        assert_eq!(replay.0, OwnerSourceEvictionOutcome::Completed);
+        assert_eq!(replay.outcome, OwnerSourceEvictionOutcome::Completed);
+        assert_eq!(replay.busy_cause, None);
         assert!(!replay_delete_called.load(Ordering::Relaxed));
     }
 }
@@ -904,6 +914,92 @@ fn plan_exact_owner_source_victim_with(
     OwnerSourceVictimPlan::Ready(planned)
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum DirectDeleteBusyCause {
+    MasterActivity(super::MasterKeyActivitySnapshot),
+    DeleteUnderFence,
+}
+
+struct DirectDeleteResult {
+    outcome: OwnerSourceEvictionOutcome,
+    detail: String,
+    busy_cause: Option<DirectDeleteBusyCause>,
+}
+
+impl DirectDeleteResult {
+    fn terminal(outcome: OwnerSourceEvictionOutcome, detail: impl Into<String>) -> Self {
+        Self {
+            outcome,
+            detail: detail.into(),
+            busy_cause: None,
+        }
+    }
+
+    fn activity_busy(snapshot: super::MasterKeyActivitySnapshot) -> Self {
+        Self {
+            outcome: OwnerSourceEvictionOutcome::RetryableBusy,
+            detail: format!(
+                "master key activity is busy: puts={} gets={} replicas={} reclaim_installed={}",
+                snapshot.puts, snapshot.gets, snapshot.replicas, snapshot.reclaim_installed
+            ),
+            busy_cause: Some(DirectDeleteBusyCause::MasterActivity(snapshot)),
+        }
+    }
+
+    fn delete_under_fence_busy() -> Self {
+        Self {
+            outcome: OwnerSourceEvictionOutcome::RetryableBusy,
+            detail: "exact source route could not be deleted under its master fence".to_string(),
+            busy_cause: Some(DirectDeleteBusyCause::DeleteUnderFence),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+struct DirectDeleteBatchBusySummary {
+    activity_busy_items: u64,
+    put_busy_items: u64,
+    get_busy_items: u64,
+    replica_busy_items: u64,
+    reclaim_busy_items: u64,
+    inflight_puts: u64,
+    inflight_gets: u64,
+    inflight_replicas: u64,
+    delete_under_fence_busy_items: u64,
+}
+
+impl DirectDeleteBatchBusySummary {
+    fn record(&mut self, cause: Option<DirectDeleteBusyCause>) {
+        match cause {
+            Some(DirectDeleteBusyCause::MasterActivity(snapshot)) => {
+                self.activity_busy_items = self.activity_busy_items.saturating_add(1);
+                self.put_busy_items = self
+                    .put_busy_items
+                    .saturating_add(u64::from(snapshot.puts != 0));
+                self.get_busy_items = self
+                    .get_busy_items
+                    .saturating_add(u64::from(snapshot.gets != 0));
+                self.replica_busy_items = self
+                    .replica_busy_items
+                    .saturating_add(u64::from(snapshot.replicas != 0));
+                self.reclaim_busy_items = self
+                    .reclaim_busy_items
+                    .saturating_add(u64::from(snapshot.reclaim_installed));
+                self.inflight_puts = self.inflight_puts.saturating_add(u64::from(snapshot.puts));
+                self.inflight_gets = self.inflight_gets.saturating_add(u64::from(snapshot.gets));
+                self.inflight_replicas = self
+                    .inflight_replicas
+                    .saturating_add(u64::from(snapshot.replicas));
+            }
+            Some(DirectDeleteBusyCause::DeleteUnderFence) => {
+                self.delete_under_fence_busy_items =
+                    self.delete_under_fence_busy_items.saturating_add(1);
+            }
+            None => {}
+        }
+    }
+}
+
 fn direct_delete_exact_owner_source_with(
     activity: &super::MasterKeyActivityTable,
     owner: &NodeID,
@@ -911,17 +1007,20 @@ fn direct_delete_exact_owner_source_with(
     epoch: u64,
     route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
     delete: impl FnOnce(&OwnerReclaimItem) -> bool,
-) -> (OwnerSourceEvictionOutcome, String) {
+) -> DirectDeleteResult {
     let member = match plan_exact_owner_source_victim_with(owner, victim, route_lookup) {
         OwnerSourceVictimPlan::Ready(member) => member,
         OwnerSourceVictimPlan::Completed(detail) => {
-            return (OwnerSourceEvictionOutcome::Completed, detail.to_string());
+            return DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Completed, detail);
         }
         OwnerSourceVictimPlan::Stale(detail) => {
-            return (OwnerSourceEvictionOutcome::Stale, detail);
+            return DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Stale, detail);
         }
         OwnerSourceVictimPlan::Rejected(detail) => {
-            return (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail);
+            return DirectDeleteResult::terminal(
+                OwnerSourceEvictionOutcome::RejectedNotEvictable,
+                detail,
+            );
         }
     };
     let item = OwnerReclaimItem {
@@ -934,35 +1033,28 @@ fn direct_delete_exact_owner_source_with(
         reason: OwnerReclaimReason::OwnerCapacityEviction,
     };
     if let Err(snapshot) = activity.try_install_reclaim(&item) {
-        return (
-            OwnerSourceEvictionOutcome::RetryableBusy,
-            format!(
-                "master key activity is busy: puts={} gets={} replicas={} reclaim_installed={}",
-                snapshot.puts, snapshot.gets, snapshot.replicas, snapshot.reclaim_installed
-            ),
-        );
+        return DirectDeleteResult::activity_busy(snapshot);
     }
 
     let result = match plan_exact_owner_source_victim_with(owner, victim, route_lookup) {
         OwnerSourceVictimPlan::Ready(_) => {
             if delete(&item) {
-                (
+                DirectDeleteResult::terminal(
                     OwnerSourceEvictionOutcome::Completed,
-                    "exact source route deleted by batch handler".to_string(),
+                    "exact source route deleted by batch handler",
                 )
             } else {
-                (
-                    OwnerSourceEvictionOutcome::RetryableBusy,
-                    "exact source route could not be deleted under its master fence".to_string(),
-                )
+                DirectDeleteResult::delete_under_fence_busy()
             }
         }
         OwnerSourceVictimPlan::Completed(detail) => {
-            (OwnerSourceEvictionOutcome::Completed, detail.to_string())
+            DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Completed, detail)
+        }
+        OwnerSourceVictimPlan::Stale(detail) => {
+            DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Stale, detail)
         }
-        OwnerSourceVictimPlan::Stale(detail) => (OwnerSourceEvictionOutcome::Stale, detail),
         OwnerSourceVictimPlan::Rejected(detail) => {
-            (OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
+            DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::RejectedNotEvictable, detail)
         }
     };
     assert!(
@@ -979,26 +1071,29 @@ fn direct_delete_exact_owner_source_batch_with(
     victims: &[OwnerSourceEvictionVictim],
     route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
     delete: impl Fn(&OwnerReclaimItem) -> bool,
-) -> Vec<OwnerSourceEvictionVictimResp> {
-    victims
-        .iter()
-        .enumerate()
-        .map(|(index, victim)| {
-            let (outcome, detail) = direct_delete_exact_owner_source_with(
-                activity,
-                owner,
-                victim,
-                owner_source_eviction_epoch(operation_id, index),
-                route_lookup,
-                |item| delete(item),
-            );
-            OwnerSourceEvictionVictimResp {
-                victim_index: u32::try_from(index).unwrap_or(u32::MAX),
-                outcome,
-                detail,
-            }
-        })
-        .collect()
+) -> (
+    Vec<OwnerSourceEvictionVictimResp>,
+    DirectDeleteBatchBusySummary,
+) {
+    let mut responses = Vec::with_capacity(victims.len());
+    let mut busy = DirectDeleteBatchBusySummary::default();
+    for (index, victim) in victims.iter().enumerate() {
+        let result = direct_delete_exact_owner_source_with(
+            activity,
+            owner,
+            victim,
+            owner_source_eviction_epoch(operation_id, index),
+            route_lookup,
+            |item| delete(item),
+        );
+        busy.record(result.busy_cause);
+        responses.push(OwnerSourceEvictionVictimResp {
+            victim_index: u32::try_from(index).unwrap_or(u32::MAX),
+            outcome: result.outcome,
+            detail: result.detail,
+        });
+    }
+    (responses, busy)
 }
 
 pub(crate) async fn handle_batch_evict_owner_source(
@@ -1053,7 +1148,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
         };
     }
 
-    let responses = direct_delete_exact_owner_source_batch_with(
+    let (responses, busy) = direct_delete_exact_owner_source_batch_with(
         &view.master_kv_router().inner().key_activity,
         &owner,
         operation_id,
@@ -1095,6 +1190,15 @@ pub(crate) async fn handle_batch_evict_owner_source(
         victims = responses.len(),
         completed,
         retryable,
+        activity_busy_items = busy.activity_busy_items,
+        put_busy_items = busy.put_busy_items,
+        get_busy_items = busy.get_busy_items,
+        replica_busy_items = busy.replica_busy_items,
+        reclaim_busy_items = busy.reclaim_busy_items,
+        inflight_puts = busy.inflight_puts,
+        inflight_gets = busy.inflight_gets,
+        inflight_replicas = busy.inflight_replicas,
+        delete_under_fence_busy_items = busy.delete_under_fence_busy_items,
         "owner source direct-delete batch completed"
     );
 
diff --git a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
index e070b1d..92a559b 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
@@ -20,8 +20,6 @@ use std::collections::HashSet;
 use std::hash::Hash;
 use std::time::Duration;
 
-const EXTERNAL_DELETE_ACK_TIMEOUT_SECS: u64 = 5;
-
 pub type OwnerDeleteAckItem = DeleteAckItem;
 
 /// Spawn an async task only if the framework/view is still running.
@@ -128,7 +126,6 @@ impl MemholderDropAck for OwnerDeleteAckCtx {
 
 pub struct ExternalDeleteAckCtx {
     pub view: ExternalClientApiView,
-    pub key: String,
     pub external_client_id: String,
     pub holder_id: u64,
     pub started_time: i64,
@@ -148,75 +145,25 @@ impl MemholderDropAck for ExternalDeleteAckCtx {
     }
     fn ack_future(
         &self,
-        guard: Self::Guard,
+        _guard: Self::Guard,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>> {
-        let v = self.view.clone();
-        let key = self.key.clone();
-        let external_client_id = self.external_client_id.clone();
-        let holder_id = self.holder_id;
-        let started_time = self.started_time;
-        Box::pin(async move {
-            let _keep = guard;
-            // Best-effort drop ACK must not outlive framework shutdown.
-            // During step8 teardown, the owner/external peers can already be concurrently exiting,
-            // and the ACK RPC can otherwise stall long enough to block task_registry shutdown.
-            match tokio::time::timeout(
-                Duration::from_secs(EXTERNAL_DELETE_ACK_TIMEOUT_SECS),
-                v.external_client_api().inner().send_external_delete_ack(
-                    &key,
-                    &external_client_id,
-                    holder_id,
-                    started_time,
-                ),
-            )
-            .await
-            {
-                Err(_) => {
-                    tracing::warn!(
-                        "Timed out sending external_delete_ack for key={}, holder_id={}, external_client_id={} after {}s",
-                        key,
-                        holder_id,
-                        external_client_id,
-                        EXTERNAL_DELETE_ACK_TIMEOUT_SECS
-                    );
-                }
-                Ok(Err(e)) => {
-                    tracing::warn!(
-                        "Failed to send external_delete_ack for key={}, holder_id={}, external_client_id={}: {}",
-                        key,
-                        holder_id,
-                        external_client_id,
-                        e
-                    );
-                }
-                Ok(Ok(())) => {
-                    tracing::debug!(
-                        "Successfully sent external_delete_ack for key={}, holder_id={}, external_client_id={}",
-                        key,
-                        holder_id,
-                        external_client_id
-                    );
-                }
-            }
-        })
+        Box::pin(async { unreachable!("external holder ACKs are enqueued synchronously") })
     }
     fn on_view_dropped(&self) {
         tracing::warn!(
-            "ExternalClientApiView has been dropped, cannot send external_delete_ack for key='{}', holder_id {}.",
-            self.key,
+            "ExternalClientApiView has been dropped, cannot enqueue external_delete_ack for holder_id {}.",
             self.holder_id
         );
     }
     fn on_skip_shutdown(&self) {
         tracing::info!(
-            "Skipping external_delete_ack for key={}, holder_id={} due to shutdown",
-            self.key,
+            "Skipping external_delete_ack for holder_id={} due to shutdown",
             self.holder_id
         );
     }
     fn run_drop_ack(&self) {
         let v = self.view().clone();
-        let Some(g) = <Self as MemholderDropAck>::try_upgrade(&v) else {
+        let Some(_guard) = <Self as MemholderDropAck>::try_upgrade(&v) else {
             self.on_view_dropped();
             return;
         };
@@ -224,8 +171,18 @@ impl MemholderDropAck for ExternalDeleteAckCtx {
             self.on_skip_shutdown();
             return;
         }
-        let fut = self.ack_future(g);
-        let _ = v.spawn("memholder_drop_ack_external", async move { fut.await });
+        if let Err(err) = v.external_client_api().inner().enqueue_external_delete_ack(
+            self.external_client_id.clone(),
+            self.holder_id,
+            self.started_time,
+        ) {
+            tracing::warn!(
+                holder_id = self.holder_id,
+                external_client_id = %self.external_client_id,
+                error = %err,
+                "failed to enqueue external holder ACK"
+            );
+        }
     }
 }
 
diff --git a/fluxon_rs/fluxon_kv/src/memholder/mod.rs b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
index f44f7c3..f23c88a 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
@@ -405,7 +405,6 @@ impl Drop for ExternalMemHolder {
 
         let ctx = ExternalDeleteAckCtx {
             view: self.view.clone(),
-            key: self.key.clone(),
             external_client_id: self.external_client_id.clone(),
             holder_id: self.holder_id,
             started_time: self.owner_start_time,
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs
index 30ee572..77efaac 100755
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/rpcresp_kvresult_convert.rs
@@ -3,10 +3,10 @@ use super::msg_and_error::{
     ApiError, ConfigError, ErrorCode, KvError, KvResult, SharedMemError, UnreachableError,
 };
 use crate::client_kv_api::msg_pack::{
-    ExternalBatchGetCancelResp, ExternalBatchGetItemResp, ExternalBatchGetResp,
-    ExternalBatchGetStartResp, ExternalBatchGetTransferResp, ExternalBatchIsExistResp,
-    ExternalBatchPutCommitItemResp, ExternalBatchPutCommitResp, ExternalBatchPutStartItemResp,
-    ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemResp,
+    ExternalBatchDeleteAckResp, ExternalBatchGetCancelResp, ExternalBatchGetItemResp,
+    ExternalBatchGetResp, ExternalBatchGetStartResp, ExternalBatchGetTransferResp,
+    ExternalBatchIsExistResp, ExternalBatchPutCommitItemResp, ExternalBatchPutCommitResp,
+    ExternalBatchPutStartItemResp, ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemResp,
     ExternalBatchPutTransferEndResp, ExternalDeleteAckResp, ExternalDeleteResp, ExternalGetResp,
     ExternalIsExistResp, ExternalObservabilitySnapshotResp, ExternalPutCommitResp,
     ExternalPutRevokeResp, ExternalPutStartResp, ExternalPutTransferEndResp,
@@ -151,6 +151,17 @@ impl ToResult for ExternalDeleteAckResp {
     }
 }
 
+impl ToResult for ExternalBatchDeleteAckResp {
+    type Ok = ExternalBatchDeleteAckResp;
+    fn to_result(self) -> KvResult<Self::Ok> {
+        if self.error_code == OK {
+            Ok(self)
+        } else {
+            Err(KvError::from_json(self.error_code, &self.error_json))
+        }
+    }
+}
+
 impl ToResult for BatchIsExistResp {
     type Ok = Vec<bool>;
     fn to_result(self) -> KvResult<Self::Ok> {
@@ -391,6 +402,16 @@ impl FromError for ExternalDeleteAckResp {
         }
     }
 }
+impl FromError for ExternalBatchDeleteAckResp {
+    fn from_error(e: &KvError) -> Self {
+        let code = e.code();
+        Self {
+            error_code: code,
+            error_json: e.to_json(),
+            ..Default::default()
+        }
+    }
+}
 
 // ---- FromError for Master KV Router Resps ----
 impl FromError for GetStartResp {
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index 412ec5f..be1a652 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -4615,9 +4615,14 @@ impl KvClient {
         .into_py_object(py)
     }
 
-    #[pyo3(signature = (handle))]
-    fn get_transfer(&self, handle: u64, py: Python) -> PyObject {
-        fn get_transfer_inner(client: &KvClient, handle: u64, py: Python) -> ApiResult<PyObject> {
+    #[pyo3(signature = (handle, consume_prefix_len=None))]
+    fn get_transfer(&self, handle: u64, consume_prefix_len: Option<usize>, py: Python) -> PyObject {
+        fn get_transfer_inner(
+            client: &KvClient,
+            handle: u64,
+            consume_prefix_len: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
             let runtime = match client.runtime.as_ref() {
                 Some(v) => v,
                 None => {
@@ -4644,7 +4649,7 @@ impl KvClient {
                         .external_client_api_view()
                         .external_client_api()
                         .inner()
-                        .get_transfer(handle)
+                        .get_transfer(handle, consume_prefix_len)
                         .await
                 })
             }) {
@@ -4704,7 +4709,7 @@ impl KvClient {
             ApiResult::new_success((plan_ptr as u64).into_py(py))
         }
 
-        get_transfer_inner(self, handle, py).into_py_object(py)
+        get_transfer_inner(self, handle, consume_prefix_len, py).into_py_object(py)
     }
 
     #[pyo3(signature = (handle))]

From 2fa4448c7554ecbb2a50c56b3b32dbb02a28ea5b Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Wed, 22 Jul 2026 19:26:41 +0800
Subject: [PATCH 08/10] backup

---
 fluxon_py/__init__.py                         |   6 +
 fluxon_py/kvclient/fluxon.py                  | 446 ++++++++++++
 .../src/facade/transfer_engine.rs             |  49 +-
 .../src/lib.rs                                |  12 +-
 .../src/closed_runtime.rs                     |  12 +
 fluxon_rs/fluxon_kv/framework_init_steps.yaml |   4 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |   2 +
 .../fluxon_kv/src/client_seg_pool/mod.rs      |  36 +-
 .../src/client_transfer_engine/mod.rs         | 572 ++++++++++++++-
 .../fluxon_kv/src/external_client_api/mod.rs  | 687 +++++++++++++++++-
 fluxon_rs/fluxon_kv/src/lib.rs                |  23 +
 .../fluxon_kv/src/master_kv_router/get.rs     | 354 +++++++--
 .../fluxon_kv/src/master_kv_router/mod.rs     |  11 +-
 .../src/master_kv_router/msg_pack.rs          |  20 +
 fluxon_rs/fluxon_pyo3/src/lib.rs              | 428 +++++++++++
 setup_and_pack/nix/pack_fluxonkv_pylib.py     |  15 +
 .../tests/test_vendor_runtime_layout.py       |   9 +
 17 files changed, 2574 insertions(+), 112 deletions(-)

diff --git a/fluxon_py/__init__.py b/fluxon_py/__init__.py
index 753281c..7c57441 100644
--- a/fluxon_py/__init__.py
+++ b/fluxon_py/__init__.py
@@ -66,6 +66,9 @@
     "KvFuture",
     "MemHolder",
     "FluxonMemHolder",
+    "GpuBufferRegistration",
+    "GpuDestination",
+    "GpuGetStartHandle",
     # Backend management
     "KvClientType",
     "new_store",
@@ -148,6 +151,9 @@
 
 _LAZY_PYO3 = {
     "FluxonMemHolder": ("kvclient.fluxon", "FluxonMemHolder"),
+    "GpuBufferRegistration": ("kvclient.fluxon", "GpuBufferRegistration"),
+    "GpuDestination": ("kvclient.fluxon", "GpuDestination"),
+    "GpuGetStartHandle": ("kvclient.fluxon", "GpuGetStartHandle"),
 }
 
 
diff --git a/fluxon_py/kvclient/fluxon.py b/fluxon_py/kvclient/fluxon.py
index ef17660..1602e88 100644
--- a/fluxon_py/kvclient/fluxon.py
+++ b/fluxon_py/kvclient/fluxon.py
@@ -224,6 +224,78 @@ def as_dict(self) -> Dict[str, Any]:
         }
 
 
+@dataclass(frozen=True)
+class GpuBufferRegistration:
+    registration_id: int
+    ptr: int
+    size: int
+    device_id: int
+
+    def __post_init__(self) -> None:
+        if type(self.registration_id) is not int or self.registration_id <= 0:
+            raise ValueError("registration_id must be a positive int")
+        if type(self.ptr) is not int or self.ptr <= 0:
+            raise ValueError("GPU registration ptr must be a positive int")
+        if type(self.size) is not int or self.size <= 0:
+            raise ValueError("GPU registration size must be a positive int")
+        if type(self.device_id) is not int or self.device_id < 0:
+            raise ValueError("GPU device_id must be a non-negative int")
+        if self.end > (1 << 64):
+            raise ValueError("GPU registration range overflows u64")
+
+    @property
+    def end(self) -> int:
+        return self.ptr + self.size
+
+    def destination(self, ptr: int, capacity: int) -> "GpuDestination":
+        destination = GpuDestination(
+            registration_id=self.registration_id,
+            ptr=ptr,
+            capacity=capacity,
+        )
+        if destination.ptr < self.ptr or destination.end > self.end:
+            raise ValueError(
+                "GPU destination is outside its registration: "
+                f"registration=[{self.ptr:#x},{self.end:#x}) "
+                f"destination=[{destination.ptr:#x},{destination.end:#x})"
+            )
+        return destination
+
+
+@dataclass(frozen=True)
+class GpuDestination:
+    registration_id: int
+    ptr: int
+    capacity: int
+
+    def __post_init__(self) -> None:
+        if type(self.registration_id) is not int or self.registration_id <= 0:
+            raise ValueError("registration_id must be a positive int")
+        if type(self.ptr) is not int or self.ptr <= 0:
+            raise ValueError("GPU destination ptr must be a positive int")
+        if type(self.capacity) is not int or self.capacity <= 0:
+            raise ValueError("GPU destination capacity must be a positive int")
+        if self.end > (1 << 64):
+            raise ValueError("GPU destination range overflows u64")
+
+    @property
+    def end(self) -> int:
+        return self.ptr + self.capacity
+
+
+@dataclass
+class GpuGetStartHandle:
+    """One-shot handle for a background RDMA pull into GPU staging."""
+
+    keys: Tuple[str, ...]
+    destinations: Tuple[GpuDestination, ...]
+    result: GetStartResult
+    created_at_ns: int
+    backend_token: int
+    backend_handle: int
+    closed: bool = False
+
+
 def _map_nospace_to_storagefull(err: ApiError) -> ApiError:
     """Normalize storage-capacity errors without depending on backend internals."""
     return err
@@ -461,6 +533,7 @@ def __init__(self, config: FluxonKvClientConfig):
         self._config = config
         self._init_error: Optional[ApiError] = None
         self._registered_buffer_descriptors: List[_RegisteredBufferDescriptor] = []
+        self._gpu_buffer_registration: Optional[GpuBufferRegistration] = None
         cluster_name = config.fluxonkv_spec_cluster_name
         self._batch_concurrency = 128
         if self._batch_concurrency <= 0:
@@ -997,6 +1070,15 @@ def register_buffer(
                     message=f"device_kind must be str; got {type(device_kind)}"
                 )
             )
+        if device_kind.strip().lower() != "host":
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=(
+                        "register_buffer supports host memory only; "
+                        "use register_gpu_buffer for a CUDA staging range"
+                    )
+                )
+            )
         if not isinstance(device_id, str):
             return Result.new_error(
                 InvalidArgumentError(
@@ -1034,6 +1116,164 @@ def register_buffer(
         except ApiError as e:
             return Result.new_error(e)
 
+    def register_gpu_buffer(
+        self,
+        ptr: int,
+        size: int,
+        device_id: int,
+    ) -> Result[GpuBufferRegistration, ApiError]:
+        if self._client is None:
+            return Result.new_error(
+                GeneralError(
+                    message="Store not initialized when register_gpu_buffer(). Call setup() first."
+                )
+            )
+        if isinstance(ptr, bool) or not isinstance(ptr, int) or ptr <= 0:
+            return Result.new_error(
+                InvalidArgumentError(message=f"GPU ptr must be a positive int; got {ptr!r}")
+            )
+        if isinstance(size, bool) or not isinstance(size, int) or size <= 0:
+            return Result.new_error(
+                InvalidArgumentError(message=f"GPU size must be a positive int; got {size!r}")
+            )
+        if (
+            isinstance(device_id, bool)
+            or not isinstance(device_id, int)
+            or device_id < 0
+        ):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"GPU device_id must be a non-negative int; got {device_id!r}"
+                )
+            )
+        if ptr + size > (1 << 64):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"GPU registration range overflows u64: ptr={ptr:#x} size={size}"
+                )
+            )
+        if self._gpu_buffer_registration is not None:
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=(
+                        "one GPU buffer is already registered: "
+                        f"registration_id={self._gpu_buffer_registration.registration_id}"
+                    )
+                )
+            )
+        try:
+            inner_res = self._client.register_gpu_buffer(ptr, size, device_id)
+            if not inner_res.is_ok():
+                return Result.new_error(inner_res.unwrap_error())
+            payload = inner_res.unwrap()
+            if not isinstance(payload, dict):
+                return Result.new_error(
+                    GeneralError(
+                        message=f"register_gpu_buffer returned non-dict payload: {type(payload)}"
+                    )
+                )
+            registration = GpuBufferRegistration(
+                registration_id=int(payload["registration_id"]),
+                ptr=int(payload["ptr"]),
+                size=int(payload["len"]),
+                device_id=int(payload["device_id"]),
+            )
+            if (
+                registration.registration_id <= 0
+                or registration.ptr != ptr
+                or registration.size != size
+                or registration.device_id != device_id
+            ):
+                return Result.new_error(
+                    GeneralError(
+                        message=(
+                            "register_gpu_buffer returned a mismatched registration: "
+                            f"{registration!r}"
+                        )
+                    )
+                )
+            self._gpu_buffer_registration = registration
+            return Result.new_ok(registration)
+        except ApiError as e:
+            return Result.new_error(e)
+
+    def validate_gpu_destination(
+        self,
+        destination: GpuDestination,
+    ) -> Result[OkNone, ApiError]:
+        if self._client is None:
+            return Result.new_error(
+                GeneralError(
+                    message="Store not initialized when validate_gpu_destination()."
+                )
+            )
+        if not isinstance(destination, GpuDestination):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=(
+                        "validate_gpu_destination requires GpuDestination; "
+                        f"got {type(destination)}"
+                    )
+                )
+            )
+        if destination.capacity <= 0 or destination.ptr <= 0:
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=f"invalid GPU destination: {destination!r}"
+                )
+            )
+        try:
+            inner_res = self._client.validate_gpu_destination(
+                destination.registration_id,
+                destination.ptr,
+                destination.capacity,
+            )
+            if not inner_res.is_ok():
+                return Result.new_error(inner_res.unwrap_error())
+            _ = inner_res.unwrap()
+            return Result.new_ok(OkNone())
+        except ApiError as e:
+            return Result.new_error(e)
+
+    def unregister_gpu_buffer(
+        self,
+        registration: GpuBufferRegistration,
+    ) -> Result[OkNone, ApiError]:
+        if self._client is None:
+            return Result.new_error(
+                GeneralError(
+                    message="Store not initialized when unregister_gpu_buffer()."
+                )
+            )
+        if not isinstance(registration, GpuBufferRegistration):
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=(
+                        "unregister_gpu_buffer requires GpuBufferRegistration; "
+                        f"got {type(registration)}"
+                    )
+                )
+            )
+        active = self._gpu_buffer_registration
+        if active != registration:
+            return Result.new_error(
+                InvalidArgumentError(
+                    message=(
+                        "GPU registration is not active on this store: "
+                        f"requested={registration!r} active={active!r}"
+                    )
+                )
+            )
+        try:
+            inner_res = self._client.unregister_gpu_buffer(registration.registration_id)
+            if not inner_res.is_ok():
+                return Result.new_error(inner_res.unwrap_error())
+            _ = inner_res.unwrap()
+            self._gpu_buffer_registration = None
+            return Result.new_ok(OkNone())
+        except ApiError as e:
+            return Result.new_error(e)
+
     def batch_put_from(
         self,
         keys: List[str],
@@ -1443,6 +1683,13 @@ def instance_key(self) -> Result[str, ApiError]:
     def close(self) -> Result[OkNone, ApiError]:
         """Close and tear down the store."""
         try:
+            if self._gpu_buffer_registration is not None:
+                unregister_result = self.unregister_gpu_buffer(
+                    self._gpu_buffer_registration
+                )
+                if not unregister_result.is_ok():
+                    return Result.new_error(unregister_result.unwrap_error())
+                _ = unregister_result.unwrap()
             # Backend returns a Result; MUST be explicitly consumed to avoid
             # leaking an unconsumed Result that triggers __del__ assertion.
             res = self._client.close()
@@ -1782,6 +2029,205 @@ def get_transfer(
             raise RuntimeError(f"get_transfer returned invalid plan_ptr: {plan_ptr!r}")
         return int(plan_ptr)
 
+    def get_start_gpu(
+        self,
+        keys: List[str],
+        destinations: List[GpuDestination],
+        prefix_best_effort: bool = True,
+        atomic_group_lens: Optional[List[int]] = None,
+    ) -> GpuGetStartHandle:
+        """Start background remote reads directly into caller-owned GPU staging."""
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when get_start_gpu(). Call setup() first."
+            )
+        if len(keys) == 0:
+            raise ValueError("get_start_gpu requires at least one key")
+        if len(keys) != len(destinations):
+            raise ValueError(
+                "get_start_gpu requires one destination per key: "
+                f"keys={len(keys)} destinations={len(destinations)}"
+            )
+        active_registration = self._gpu_buffer_registration
+        if active_registration is None:
+            raise RuntimeError("get_start_gpu requires an active GPU registration")
+        for index, destination in enumerate(destinations):
+            if not isinstance(destination, GpuDestination):
+                raise TypeError(
+                    "get_start_gpu destinations must be GpuDestination: "
+                    f"index={index} got={type(destination)}"
+                )
+            if destination.registration_id != active_registration.registration_id:
+                raise ValueError(
+                    "get_start_gpu destination uses a stale registration: "
+                    f"index={index} destination_id={destination.registration_id} "
+                    f"active_id={active_registration.registration_id}"
+                )
+            if (
+                destination.ptr < active_registration.ptr
+                or destination.end > active_registration.end
+            ):
+                raise ValueError(
+                    "get_start_gpu destination is outside the active registration: "
+                    f"index={index} destination={destination!r} "
+                    f"registration={active_registration!r}"
+                )
+
+        normalized_group_lens: Optional[List[int]] = None
+        if atomic_group_lens is not None:
+            normalized_group_lens = [int(length) for length in atomic_group_lens]
+            if any(length <= 0 for length in normalized_group_lens):
+                raise ValueError("get_start_gpu atomic_group_lens entries must be > 0")
+            if sum(normalized_group_lens) != len(keys):
+                raise ValueError(
+                    "get_start_gpu atomic_group_lens must sum to keys length: "
+                    f"sum={sum(normalized_group_lens)} keys={len(keys)}"
+                )
+
+        started_at_ns = time.monotonic_ns()
+        inner_res = self._client.get_start_gpu(
+            list(keys),
+            [
+                (
+                    destination.registration_id,
+                    destination.ptr,
+                    destination.capacity,
+                )
+                for destination in destinations
+            ],
+            bool(prefix_best_effort),
+            normalized_group_lens,
+            self._batch_concurrency,
+        )
+        if not inner_res.is_ok():
+            raise RuntimeError(f"get_start_gpu backend error: {inner_res.unwrap_error()}")
+        payload = inner_res.unwrap()
+        if not isinstance(payload, dict):
+            raise RuntimeError(
+                f"get_start_gpu returned non-dict payload: {type(payload)}"
+            )
+        backend_handle = int(payload["handle"])
+        try:
+            result = _build_get_start_result_from_backend_payload(
+                payload,
+                list(keys),
+                bool(prefix_best_effort),
+                normalized_group_lens,
+            )
+        except Exception:
+            cancel_res = self._client.cancel_get_transfer_gpu(backend_handle)
+            if not cancel_res.is_ok():
+                logging.exception(
+                    "get_start_gpu payload validation failed and cleanup also failed: %s",
+                    cancel_res.unwrap_error(),
+                )
+            raise
+        return GpuGetStartHandle(
+            keys=tuple(keys),
+            destinations=tuple(destinations),
+            result=result,
+            created_at_ns=started_at_ns,
+            backend_token=id(self),
+            backend_handle=backend_handle,
+        )
+
+    def cancel_get_transfer_gpu(self, handle: GpuGetStartHandle) -> None:
+        if not isinstance(handle, GpuGetStartHandle):
+            raise TypeError(
+                f"cancel_get_transfer_gpu requires GpuGetStartHandle, got {type(handle)}"
+            )
+        if handle.backend_token != id(self):
+            raise RuntimeError(
+                "cancel_get_transfer_gpu handle belongs to a different FluxonKVCacheStore"
+            )
+        if handle.closed:
+            return
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when cancel_get_transfer_gpu(). Call setup() first."
+            )
+        inner_res = self._client.cancel_get_transfer_gpu(handle.backend_handle)
+        handle.closed = True
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"cancel_get_transfer_gpu backend error: {inner_res.unwrap_error()}"
+            )
+
+    def get_transfer_gpu(
+        self,
+        handle: GpuGetStartHandle,
+        *,
+        consume_prefix_len: Optional[int] = None,
+    ) -> None:
+        """Wait for the GPU transfer terminal; destinations already contain the bytes."""
+        if not isinstance(handle, GpuGetStartHandle):
+            raise TypeError(
+                f"get_transfer_gpu requires GpuGetStartHandle, got {type(handle)}"
+            )
+        if handle.backend_token != id(self):
+            raise RuntimeError(
+                "get_transfer_gpu handle belongs to a different FluxonKVCacheStore"
+            )
+        if handle.closed:
+            raise RuntimeError("get_transfer_gpu handle has been closed")
+        result = handle.result
+        normalized_consume_prefix_len = (
+            result.transferable_len
+            if consume_prefix_len is None
+            else consume_prefix_len
+        )
+        if (
+            isinstance(normalized_consume_prefix_len, bool)
+            or not isinstance(normalized_consume_prefix_len, int)
+            or normalized_consume_prefix_len <= 0
+            or normalized_consume_prefix_len > result.transferable_len
+        ):
+            raise ValueError(
+                "get_transfer_gpu consume_prefix_len must be within the live prefix: "
+                f"consume={normalized_consume_prefix_len!r} "
+                f"transferable={result.transferable_len}"
+            )
+        group_lens = result.atomic_group_lens or (len(result.keys),)
+        group_end = 0
+        for group_len in group_lens:
+            group_end += int(group_len)
+            if group_end >= normalized_consume_prefix_len:
+                break
+        if group_end != normalized_consume_prefix_len:
+            raise ValueError(
+                "get_transfer_gpu consume_prefix_len must end at an atomic-group boundary: "
+                f"consume={normalized_consume_prefix_len} groups={group_lens}"
+            )
+        if self._client is None:
+            raise RuntimeError(
+                "Store not initialized when get_transfer_gpu(). Call setup() first."
+            )
+        inner_res = self._client.get_transfer_gpu(
+            handle.backend_handle,
+            normalized_consume_prefix_len,
+        )
+        handle.closed = True
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"get_transfer_gpu backend error: {inner_res.unwrap_error()}"
+            )
+        payload = inner_res.unwrap()
+        if not isinstance(payload, dict):
+            raise RuntimeError(
+                f"get_transfer_gpu returned non-dict payload: {type(payload)}"
+            )
+        transferred_prefix_len = int(payload["transferred_prefix_len"])
+        consumed_prefix_len = int(payload["consumed_prefix_len"])
+        if (
+            transferred_prefix_len != result.transferable_len
+            or consumed_prefix_len != normalized_consume_prefix_len
+        ):
+            raise RuntimeError(
+                "get_transfer_gpu returned inconsistent terminal lengths: "
+                f"transferred={transferred_prefix_len}/{result.transferable_len} "
+                f"consumed={consumed_prefix_len}/{normalized_consume_prefix_len}"
+            )
+
     def get_etcd_config(self) -> List[str]:
         if self._client is None:
             raise RuntimeError("Store not initialized")
diff --git a/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs b/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs
index e5353a5..f701659 100644
--- a/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs
+++ b/fluxon_rs/fluxon_commu/src/facade/transfer_engine.rs
@@ -7,6 +7,9 @@ use std::collections::HashMap;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 
 use crate::NodeIDString;
+pub use fluxon_commu_contract::{
+    CLOSED_RUNTIME_DIRECT_FAST_PATH_NOT_READY_MARKER, ClosedRuntimeLocalMemoryKind,
+};
 use fluxon_commu_contract::{
     ClosedRuntimeHandle, ClosedRuntimePeerGen, ClosedRuntimeTransferEngineOpenRuntimeRequest,
     ClosedRuntimeTransferEngineOpenRuntimeResponse,
@@ -377,6 +380,25 @@ impl ClientTransferEngineCore {
         runtime: R,
         cpu_mem: &CpuAllocatedMem,
     ) -> TransferEngineResult<()>
+    where
+        R: ClientTransferEngineRuntime,
+    {
+        self.register_local_memory(
+            runtime,
+            cpu_mem.allocated_addr,
+            cpu_mem.allocated_size,
+            ClosedRuntimeLocalMemoryKind::Host,
+        )
+        .await
+    }
+
+    pub async fn register_local_memory<R>(
+        &self,
+        runtime: R,
+        allocated_addr: u64,
+        allocated_size: u64,
+        memory_kind: ClosedRuntimeLocalMemoryKind,
+    ) -> TransferEngineResult<()>
     where
         R: ClientTransferEngineRuntime,
     {
@@ -384,8 +406,9 @@ impl ClientTransferEngineCore {
             let handle = self.ensure_closed_runtime_handle(&runtime).await?;
             transfer_engine_register_local_segment(
                 handle,
-                cpu_mem.allocated_addr,
-                cpu_mem.allocated_size,
+                allocated_addr,
+                allocated_size,
+                memory_kind,
             )
             .await
             .map_err(transfer_engine_closed_sdk_error)
@@ -395,13 +418,28 @@ impl ClientTransferEngineCore {
     pub async fn unregister_local_segment(
         &self,
         cpu_mem: &CpuAllocatedMem,
+    ) -> TransferEngineResult<()> {
+        self.unregister_local_memory(
+            cpu_mem.allocated_addr,
+            cpu_mem.allocated_size,
+            ClosedRuntimeLocalMemoryKind::Host,
+        )
+        .await
+    }
+
+    pub async fn unregister_local_memory(
+        &self,
+        allocated_addr: u64,
+        allocated_size: u64,
+        memory_kind: ClosedRuntimeLocalMemoryKind,
     ) -> TransferEngineResult<()> {
         {
             if let Some(handle) = self.closed.handle.get().copied() {
                 transfer_engine_unregister_local_segment(
                     handle,
-                    cpu_mem.allocated_addr,
-                    cpu_mem.allocated_size,
+                    allocated_addr,
+                    allocated_size,
+                    memory_kind,
                 )
                 .await
                 .map_err(transfer_engine_closed_sdk_error)
@@ -458,6 +496,7 @@ impl ClientTransferEngineCore {
                 target_addr,
                 len,
                 seg_guard,
+                false,
             )
             .await
         }
@@ -472,6 +511,7 @@ impl ClientTransferEngineCore {
         target_addr: u64,
         len: u64,
         seg_guard: Option<R::LocalSegmentGuard>,
+        require_fast_path: bool,
     ) -> TransferEngineResult<TransferBreakdown>
     where
         R: ClientTransferEngineRuntime,
@@ -506,6 +546,7 @@ impl ClientTransferEngineCore {
                 target_addr,
                 len,
                 initial_local_segment_guard_handle,
+                require_fast_path,
             )
             .await
             .map_err(transfer_engine_closed_sdk_error);
diff --git a/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs b/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs
index caad34b..7395347 100644
--- a/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs
+++ b/fluxon_rs/fluxon_commu_closed_sdk_consumer/src/lib.rs
@@ -13,7 +13,7 @@ use fluxon_commu_contract::{
     ClosedRuntimeClusterRdmaResolvedConfigStreamItem, ClosedRuntimeDesiredTransferPeer,
     ClosedRuntimeDispatchRequestView, ClosedRuntimeDispatchResponse,
     ClosedRuntimeDispatchTransportPolicy, ClosedRuntimeError, ClosedRuntimeHandle,
-    ClosedRuntimeHostCallbackHandle, ClosedRuntimeP2pCall,
+    ClosedRuntimeHostCallbackHandle, ClosedRuntimeLocalMemoryKind, ClosedRuntimeP2pCall,
     ClosedRuntimeP2pCallRawObservedRequestView, ClosedRuntimeP2pResponse,
     ClosedRuntimeP2pSendResponseRawRequestView, ClosedRuntimePeerGen, ClosedRuntimeRawSlice,
     ClosedRuntimeRequest, ClosedRuntimeResponse, ClosedRuntimeTransferEngineCall,
@@ -26,8 +26,8 @@ use fluxon_commu_contract::{
 
 pub mod rdma_probe;
 
-pub const FLUXON_COMMU_CLOSED_SDK_SCHEMA_VERSION: u32 = 5;
-pub const FLUXON_COMMU_CLOSED_ABI_VERSION: u32 = 8;
+pub const FLUXON_COMMU_CLOSED_SDK_SCHEMA_VERSION: u32 = 6;
+pub const FLUXON_COMMU_CLOSED_ABI_VERSION: u32 = 9;
 pub const FLUXON_COMMU_CLOSED_HOST_CALLBACKS_ABI_VERSION: u32 = 8;
 pub const FLUXON_COMMU_CLOSED_RUNTIME_RESULT_OK: i32 = 0;
 pub const FLUXON_COMMU_CLOSED_RUNTIME_RESULT_ERR: i32 = 1;
@@ -1866,12 +1866,14 @@ pub async fn transfer_engine_register_local_segment(
     handle: ClosedRuntimeHandle,
     allocated_addr: u64,
     allocated_size: u64,
+    memory_kind: ClosedRuntimeLocalMemoryKind,
 ) -> Result<(), ClosedSdkConsumerError> {
     match transfer_engine_call(
         handle,
         ClosedRuntimeTransferEngineCall::RegisterLocalSegment {
             allocated_addr,
             allocated_size,
+            memory_kind,
         },
     )
     .await?
@@ -1887,12 +1889,14 @@ pub async fn transfer_engine_unregister_local_segment(
     handle: ClosedRuntimeHandle,
     allocated_addr: u64,
     allocated_size: u64,
+    memory_kind: ClosedRuntimeLocalMemoryKind,
 ) -> Result<(), ClosedSdkConsumerError> {
     match transfer_engine_call(
         handle,
         ClosedRuntimeTransferEngineCall::UnregisterLocalSegment {
             allocated_addr,
             allocated_size,
+            memory_kind,
         },
     )
     .await?
@@ -1912,6 +1916,7 @@ pub async fn transfer_engine_transfer_data_no_copy(
     target_addr: u64,
     len: u64,
     initial_local_segment_guard_handle: Option<u64>,
+    require_fast_path: bool,
 ) -> Result<fluxon_commu_contract::TransferBreakdown, ClosedSdkConsumerError> {
     match transfer_engine_call(
         handle,
@@ -1922,6 +1927,7 @@ pub async fn transfer_engine_transfer_data_no_copy(
             target_addr,
             len,
             initial_local_segment_guard_handle,
+            require_fast_path,
         },
     )
     .await?
diff --git a/fluxon_rs/fluxon_commu_contract/src/closed_runtime.rs b/fluxon_rs/fluxon_commu_contract/src/closed_runtime.rs
index 80872e2..17241cf 100644
--- a/fluxon_rs/fluxon_commu_contract/src/closed_runtime.rs
+++ b/fluxon_rs/fluxon_commu_contract/src/closed_runtime.rs
@@ -744,6 +744,15 @@ pub struct ClosedRuntimeDesiredTransferPeer {
     pub enable_transfer_segment: bool,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum ClosedRuntimeLocalMemoryKind {
+    Host,
+    Gpu { device_id: u32 },
+}
+
+pub const CLOSED_RUNTIME_DIRECT_FAST_PATH_NOT_READY_MARKER: &str =
+    "fluxon_direct_fast_path_not_ready";
+
 #[derive(Debug, Clone, Encode, Decode)]
 pub enum ClosedRuntimeTransferEngineCall {
     Init2ForInitDag {
@@ -764,10 +773,12 @@ pub enum ClosedRuntimeTransferEngineCall {
     RegisterLocalSegment {
         allocated_addr: u64,
         allocated_size: u64,
+        memory_kind: ClosedRuntimeLocalMemoryKind,
     },
     UnregisterLocalSegment {
         allocated_addr: u64,
         allocated_size: u64,
+        memory_kind: ClosedRuntimeLocalMemoryKind,
     },
     TransferDataNoCopy {
         peer_node: Option<String>,
@@ -776,6 +787,7 @@ pub enum ClosedRuntimeTransferEngineCall {
         target_addr: u64,
         len: u64,
         initial_local_segment_guard_handle: Option<u64>,
+        require_fast_path: bool,
     },
     TrySendWireDirect {
         peer_gen: ClosedRuntimePeerGen,
diff --git a/fluxon_rs/fluxon_kv/framework_init_steps.yaml b/fluxon_rs/fluxon_kv/framework_init_steps.yaml
index 923ae30..24ca312 100644
--- a/fluxon_rs/fluxon_kv/framework_init_steps.yaml
+++ b/fluxon_rs/fluxon_kv/framework_init_steps.yaml
@@ -62,8 +62,8 @@ module_tags:
   MasterKvRouter: [master]
   MetricReporter: [master, owner, external]
   ClientKvApi: [owner]
-  ClientSegPool: [owner]
-  ClientTransferEngine: [master, owner]
+  ClientSegPool: [owner, external]
+  ClientTransferEngine: [master, owner, external]
   ExternalClientApi: [external]
   MasterLeaseManager: [master]
 
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index ddc5803..9e1c6a9 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -1424,6 +1424,7 @@ impl ClientKvApiInner {
             serialize_part: GetStartReq {
                 key: key.to_string(),
                 prepared_target: None,
+                external_sink_target: None,
             },
             raw_bytes: Vec::new(),
         };
@@ -1464,6 +1465,7 @@ impl ClientKvApiInner {
             serialize_part: BatchGetStartReq {
                 keys,
                 prepared_targets,
+                external_sink_targets: Vec::new(),
             },
             raw_bytes: Vec::new(),
         };
diff --git a/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs b/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
index 8c7cc78..8dd61aa 100644
--- a/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_seg_pool/mod.rs
@@ -1,7 +1,7 @@
 use crate::ClientKvApiAccessTrait;
 use crate::client_kv_api::ClientKvApi;
 use crate::client_transfer_engine::{ClientTransferEngine, ClientTransferEngineAccessTrait};
-use crate::cluster_manager::ClusterManagerAccessTrait;
+use crate::cluster_manager::{ClusterManagerAccessTrait, NodeRole};
 use crate::config::ContributeToClusterPoolSize;
 use crate::master_seg_manager::msg_pack::SegmentDeviceMemInfo;
 use crate::p2p::p2p_module::P2pModule;
@@ -968,15 +968,24 @@ impl LogicalModule for ClientSegPool {
 
     async fn shutdown(&self) -> Result<(), Self::Error> {
         let _ = self.remove_side_transfer_peer().await;
-        loop {
-            if self.inner().view().client_kv_api().can_be_dropped() {
-                tracing::info!("ClientSegPool can be dropped");
-                break;
+        if !matches!(
+            self.inner()
+                .view()
+                .cluster_manager()
+                .get_self_info()
+                .node_role(),
+            NodeRole::External
+        ) {
+            loop {
+                if self.inner().view().client_kv_api().can_be_dropped() {
+                    tracing::info!("ClientSegPool can be dropped");
+                    break;
+                }
+                tracing::info!(
+                    "ClientSegPool waiting ClientKvApi can not be dropped , will try again after 3s (some user memholder may still be in use)"
+                );
+                tokio::time::sleep(Duration::from_secs(3)).await;
             }
-            tracing::info!(
-                "ClientSegPool waiting ClientKvApi can not be dropped , will try again after 3s (some user memholder may still be in use)"
-            );
-            tokio::time::sleep(Duration::from_secs(3)).await;
         }
 
         if self.0.cpu_allocated_mem.read().await.is_some() {
@@ -989,6 +998,15 @@ impl LogicalModule for ClientSegPool {
 impl ClientSegPool {
     pub async fn init2_for_init_dag(&self) -> KvResult<()> {
         let inner = &self.0;
+        if matches!(
+            inner.view().cluster_manager().get_self_info().node_role(),
+            NodeRole::External
+        ) {
+            // External clients contribute no cache segment. They construct this
+            // module only to provide lifetime guards for an explicitly
+            // registered GPU staging range.
+            return Ok(());
+        }
 
         // English note:
         // - Invariant: register inbound RPC handlers before any awaited etcd operations that
diff --git a/fluxon_rs/fluxon_kv/src/client_transfer_engine/mod.rs b/fluxon_rs/fluxon_kv/src/client_transfer_engine/mod.rs
index 75f82f5..829b57e 100644
--- a/fluxon_rs/fluxon_kv/src/client_transfer_engine/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_transfer_engine/mod.rs
@@ -21,7 +21,10 @@ use crate::{P2pModuleAccessTrait, cluster_manager::ClusterManagerAccessTrait};
 use async_trait::async_trait;
 use fluxon_commu::ClosedRuntimeHandle;
 use fluxon_commu::p2p::PeerGen;
-use fluxon_commu::transfer_engine::AttachedTransferEngine;
+use fluxon_commu::transfer_engine::{
+    AttachedTransferEngine, CLOSED_RUNTIME_DIRECT_FAST_PATH_NOT_READY_MARKER,
+    ClosedRuntimeLocalMemoryKind,
+};
 use fluxon_commu::{
     ClientTransferEngineClusterRuntime, ClientTransferEngineCore, ClientTransferEngineRuntime,
     CpuAllocatedMem, TransferBreakdown,
@@ -29,7 +32,9 @@ use fluxon_commu::{
 use fluxon_framework::{LogicalModule, define_module};
 use std::future::Future;
 use std::pin::Pin;
-use std::sync::OnceLock;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::{Duration, Instant};
 
 pub use fluxon_commu::{ClientTransferEngineNewArg, ClientTransferEngineRuntimeConfig};
 
@@ -43,15 +48,228 @@ define_module!(
     (client_seg_pool, ClientSegPool)
 );
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GpuMemoryRegistration {
+    pub registration_id: u64,
+    pub addr: u64,
+    pub len: u64,
+    pub device_id: u32,
+}
+
+impl GpuMemoryRegistration {
+    fn contains(&self, addr: u64, len: u64) -> bool {
+        if len == 0 {
+            return addr >= self.addr
+                && self
+                    .addr
+                    .checked_add(self.len)
+                    .is_some_and(|end| addr <= end);
+        }
+        let Some(end) = addr.checked_add(len) else {
+            return false;
+        };
+        let Some(registration_end) = self.addr.checked_add(self.len) else {
+            return false;
+        };
+        addr >= self.addr && end <= registration_end
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct GpuMemoryGuard {
+    registration: Arc<GpuMemoryRegistration>,
+}
+
+impl GpuMemoryGuard {
+    pub fn registration(&self) -> &GpuMemoryRegistration {
+        self.registration.as_ref()
+    }
+
+    fn contains(&self, addr: u64, len: u64) -> bool {
+        self.registration.contains(addr, len)
+    }
+}
+
+pub enum ClientTransferMemoryGuard {
+    Cpu(ClientCpuMemReadGuard),
+    Gpu(GpuMemoryGuard),
+}
+
+#[derive(Debug)]
+enum GpuMemoryRegistryState {
+    Empty,
+    Registering(GpuMemoryRegistration),
+    Active(Arc<GpuMemoryRegistration>),
+    Unregistering(GpuMemoryRegistration),
+}
+
+#[derive(Debug)]
+struct GpuMemoryRegistry {
+    next_registration_id: AtomicU64,
+    state: Mutex<GpuMemoryRegistryState>,
+}
+
+impl GpuMemoryRegistry {
+    fn new() -> Self {
+        Self {
+            next_registration_id: AtomicU64::new(1),
+            state: Mutex::new(GpuMemoryRegistryState::Empty),
+        }
+    }
+
+    fn begin_register(
+        &self,
+        addr: u64,
+        len: u64,
+        device_id: u32,
+    ) -> Result<GpuMemoryRegistration, String> {
+        if addr == 0 {
+            return Err("GPU registration address must be non-zero".to_string());
+        }
+        if len == 0 {
+            return Err("GPU registration length must be non-zero".to_string());
+        }
+        if addr.checked_add(len).is_none() {
+            return Err(format!(
+                "GPU registration range overflows: addr={:#x} len={}",
+                addr, len
+            ));
+        }
+        let registration_id = self.next_registration_id.fetch_add(1, Ordering::Relaxed);
+        let registration = GpuMemoryRegistration {
+            registration_id,
+            addr,
+            len,
+            device_id,
+        };
+        let mut state = self.state.lock().expect("gpu memory registry poisoned");
+        match &*state {
+            GpuMemoryRegistryState::Empty => {
+                *state = GpuMemoryRegistryState::Registering(registration.clone());
+                Ok(registration)
+            }
+            current => Err(format!(
+                "one GPU registration is already active or changing: {current:?}"
+            )),
+        }
+    }
+
+    fn finish_register(&self, registration_id: u64, success: bool) {
+        let mut state = self.state.lock().expect("gpu memory registry poisoned");
+        let previous = std::mem::replace(&mut *state, GpuMemoryRegistryState::Empty);
+        match previous {
+            GpuMemoryRegistryState::Registering(registration)
+                if registration.registration_id == registration_id =>
+            {
+                if success {
+                    *state = GpuMemoryRegistryState::Active(Arc::new(registration));
+                }
+            }
+            other => panic!(
+                "GPU registration completion does not match registry state: id={} state={other:?}",
+                registration_id
+            ),
+        }
+    }
+
+    fn begin_unregister(&self, registration_id: u64) -> Result<GpuMemoryRegistration, String> {
+        let mut state = self.state.lock().expect("gpu memory registry poisoned");
+        let previous = std::mem::replace(&mut *state, GpuMemoryRegistryState::Empty);
+        match previous {
+            GpuMemoryRegistryState::Active(registration) => {
+                if registration.registration_id != registration_id {
+                    let actual = registration.registration_id;
+                    *state = GpuMemoryRegistryState::Active(registration);
+                    return Err(format!(
+                        "GPU registration id mismatch: expected={} got={}",
+                        actual, registration_id
+                    ));
+                }
+                let guard_count = Arc::strong_count(&registration).saturating_sub(1);
+                if guard_count != 0 {
+                    *state = GpuMemoryRegistryState::Active(registration);
+                    return Err(format!(
+                        "GPU registration is busy: registration_id={} active_guards={}",
+                        registration_id, guard_count
+                    ));
+                }
+                let descriptor = registration.as_ref().clone();
+                *state = GpuMemoryRegistryState::Unregistering(descriptor.clone());
+                Ok(descriptor)
+            }
+            other => {
+                *state = other;
+                Err(format!(
+                    "GPU registration is not active: registration_id={}",
+                    registration_id
+                ))
+            }
+        }
+    }
+
+    fn finish_unregister(&self, registration_id: u64, success: bool) {
+        let mut state = self.state.lock().expect("gpu memory registry poisoned");
+        let previous = std::mem::replace(&mut *state, GpuMemoryRegistryState::Empty);
+        match previous {
+            GpuMemoryRegistryState::Unregistering(registration)
+                if registration.registration_id == registration_id =>
+            {
+                if !success {
+                    *state = GpuMemoryRegistryState::Active(Arc::new(registration));
+                }
+            }
+            other => panic!(
+                "GPU unregistration completion does not match registry state: id={} state={other:?}",
+                registration_id
+            ),
+        }
+    }
+
+    fn guard_for_range(&self, addr: u64, len: u64) -> Option<GpuMemoryGuard> {
+        let state = self.state.lock().expect("gpu memory registry poisoned");
+        match &*state {
+            GpuMemoryRegistryState::Active(registration) if registration.contains(addr, len) => {
+                Some(GpuMemoryGuard {
+                    registration: registration.clone(),
+                })
+            }
+            _ => None,
+        }
+    }
+
+    fn validate_destination(
+        &self,
+        registration_id: u64,
+        addr: u64,
+        capacity: u64,
+    ) -> Result<GpuMemoryGuard, String> {
+        let guard = self.guard_for_range(addr, capacity).ok_or_else(|| {
+            format!(
+                "GPU destination is outside the active registration: registration_id={} addr={:#x} capacity={}",
+                registration_id, addr, capacity
+            )
+        })?;
+        if guard.registration().registration_id != registration_id {
+            return Err(format!(
+                "GPU destination registration id mismatch: expected={} got={}",
+                guard.registration().registration_id,
+                registration_id
+            ));
+        }
+        Ok(guard)
+    }
+}
+
 #[derive(Clone)]
 struct ClientTransferRuntimeAdapter {
     view: ClientTransferEngineView,
+    gpu_memory_registry: Arc<GpuMemoryRegistry>,
 }
 
 impl ClientTransferRuntimeAdapter {
     fn local_segment_transfer_enabled(&self) -> bool {
         let self_info = self.view.cluster_manager().get_self_info();
-        matches!(self_info.node_role(), NodeRole::Client)
+        matches!(self_info.node_role(), NodeRole::Client | NodeRole::External)
             || self_info
                 .metadata
                 .get("side_transfer_worker")
@@ -156,7 +374,7 @@ impl ClientTransferEngineClusterRuntime for ClientTransferRuntimeAdapter {
 
 #[async_trait]
 impl ClientTransferEngineRuntime for ClientTransferRuntimeAdapter {
-    type LocalSegmentGuard = ClientCpuMemReadGuard;
+    type LocalSegmentGuard = ClientTransferMemoryGuard;
 
     fn supports_local_segment_transfer(&self) -> bool {
         self.local_segment_transfer_enabled()
@@ -181,12 +399,40 @@ impl ClientTransferEngineRuntime for ClientTransferRuntimeAdapter {
     async fn ensure_local_segment_guard(
         &self,
         local_addr: u64,
-        seg_guard: Option<ClientCpuMemReadGuard>,
-    ) -> Result<ClientCpuMemReadGuard, String> {
+        seg_guard: Option<ClientTransferMemoryGuard>,
+    ) -> Result<ClientTransferMemoryGuard, String> {
         if !self.local_segment_transfer_enabled() {
             return Err("local segment transfer is not supported on this node role".to_string());
         }
-        p2p_transfer_rpc::ensure_local_segment_guard(&self.view, local_addr, seg_guard).await
+        if let Some(guard) = seg_guard {
+            return match guard {
+                ClientTransferMemoryGuard::Cpu(cpu_guard) => {
+                    p2p_transfer_rpc::ensure_local_segment_guard(
+                        &self.view,
+                        local_addr,
+                        Some(cpu_guard),
+                    )
+                    .await
+                    .map(ClientTransferMemoryGuard::Cpu)
+                }
+                ClientTransferMemoryGuard::Gpu(gpu_guard) => {
+                    if gpu_guard.contains(local_addr, 1) {
+                        Ok(ClientTransferMemoryGuard::Gpu(gpu_guard))
+                    } else {
+                        Err(format!(
+                            "GPU guard does not cover local address: addr={:#x}",
+                            local_addr
+                        ))
+                    }
+                }
+            };
+        }
+        if let Some(gpu_guard) = self.gpu_memory_registry.guard_for_range(local_addr, 1) {
+            return Ok(ClientTransferMemoryGuard::Gpu(gpu_guard));
+        }
+        p2p_transfer_rpc::ensure_local_segment_guard(&self.view, local_addr, None)
+            .await
+            .map(ClientTransferMemoryGuard::Cpu)
     }
 
     fn register_p2p_transfer_rpc(&self) {
@@ -231,20 +477,27 @@ impl ClientTransferEngineRuntime for ClientTransferRuntimeAdapter {
         remote_src: u64,
         local_target: u64,
         len: u64,
-        seg_guard: ClientCpuMemReadGuard,
+        seg_guard: ClientTransferMemoryGuard,
     ) -> Result<(), String> {
         if !self.local_segment_transfer_enabled() {
             return Err("p2p raw-memory read is not supported on this node role".to_string());
         }
-        p2p_transfer_rpc::p2p_read_to_local(
-            &self.view,
-            peer,
-            remote_src,
-            local_target,
-            len,
-            seg_guard,
-        )
-        .await
+        match seg_guard {
+            ClientTransferMemoryGuard::Cpu(cpu_guard) => {
+                p2p_transfer_rpc::p2p_read_to_local(
+                    &self.view,
+                    peer,
+                    remote_src,
+                    local_target,
+                    len,
+                    cpu_guard,
+                )
+                .await
+            }
+            ClientTransferMemoryGuard::Gpu(_) => Err(
+                "GPU destination requires the RDMA fast path; P2P fallback is disabled".to_string(),
+            ),
+        }
     }
 
     async fn p2p_write_from_local(
@@ -254,21 +507,28 @@ impl ClientTransferEngineRuntime for ClientTransferRuntimeAdapter {
         remote_target: u64,
         len: u64,
         copy_from: Option<Pin<&[u8]>>,
-        seg_guard: ClientCpuMemReadGuard,
+        seg_guard: ClientTransferMemoryGuard,
     ) -> Result<(), String> {
         if !self.local_segment_transfer_enabled() {
             return Err("p2p raw-memory write is not supported on this node role".to_string());
         }
-        p2p_transfer_rpc::p2p_write_from_local(
-            &self.view,
-            peer,
-            local_src,
-            remote_target,
-            len,
-            copy_from,
-            seg_guard,
-        )
-        .await
+        match seg_guard {
+            ClientTransferMemoryGuard::Cpu(cpu_guard) => {
+                p2p_transfer_rpc::p2p_write_from_local(
+                    &self.view,
+                    peer,
+                    local_src,
+                    remote_target,
+                    len,
+                    copy_from,
+                    cpu_guard,
+                )
+                .await
+            }
+            ClientTransferMemoryGuard::Gpu(_) => {
+                Err("GPU source requires the RDMA fast path; P2P fallback is disabled".to_string())
+            }
+        }
     }
 
     fn try_record_local_ipc_bytes_for_owner_topology(
@@ -308,12 +568,14 @@ impl ClientTransferEngineRuntime for ClientTransferRuntimeAdapter {
 pub struct ClientTransferEngine {
     view: OnceLock<ClientTransferEngineView>,
     core: ClientTransferEngineCore,
+    gpu_memory_registry: Arc<GpuMemoryRegistry>,
 }
 
 impl ClientTransferEngine {
     fn runtime(&self) -> ClientTransferRuntimeAdapter {
         ClientTransferRuntimeAdapter {
             view: self.view.get().unwrap().clone(),
+            gpu_memory_registry: self.gpu_memory_registry.clone(),
         }
     }
 
@@ -333,6 +595,7 @@ impl ClientTransferEngine {
         Ok(Self {
             view: OnceLock::new(),
             core,
+            gpu_memory_registry: Arc::new(GpuMemoryRegistry::new()),
         })
     }
 
@@ -369,6 +632,81 @@ impl ClientTransferEngine {
             .map_err(KvError::from)
     }
 
+    pub async fn register_gpu_memory(
+        &self,
+        addr: u64,
+        len: u64,
+        device_id: u32,
+    ) -> KvResult<GpuMemoryRegistration> {
+        let registration = self
+            .gpu_memory_registry
+            .begin_register(addr, len, device_id)
+            .map_err(|detail| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                        detail,
+                    },
+                )
+            })?;
+        let result = self
+            .core
+            .register_local_memory(
+                self.runtime(),
+                addr,
+                len,
+                ClosedRuntimeLocalMemoryKind::Gpu { device_id },
+            )
+            .await
+            .map_err(KvError::from);
+        self.gpu_memory_registry
+            .finish_register(registration.registration_id, result.is_ok());
+        result.map(|()| registration)
+    }
+
+    pub async fn unregister_gpu_memory(&self, registration_id: u64) -> KvResult<()> {
+        let registration = self
+            .gpu_memory_registry
+            .begin_unregister(registration_id)
+            .map_err(|detail| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                        detail,
+                    },
+                )
+            })?;
+        let result = self
+            .core
+            .unregister_local_memory(
+                registration.addr,
+                registration.len,
+                ClosedRuntimeLocalMemoryKind::Gpu {
+                    device_id: registration.device_id,
+                },
+            )
+            .await
+            .map_err(KvError::from);
+        self.gpu_memory_registry
+            .finish_unregister(registration_id, result.is_ok());
+        result
+    }
+
+    pub fn validate_gpu_destination(
+        &self,
+        registration_id: u64,
+        addr: u64,
+        capacity: u64,
+    ) -> KvResult<GpuMemoryGuard> {
+        self.gpu_memory_registry
+            .validate_destination(registration_id, addr, capacity)
+            .map_err(|detail| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                        detail,
+                    },
+                )
+            })
+    }
+
     pub async fn write_data(
         &self,
         data: Pin<&[u8]>,
@@ -386,7 +724,7 @@ impl ClientTransferEngine {
                 target_addr,
                 peer_id,
                 do_copy,
-                seg_guard,
+                seg_guard.map(ClientTransferMemoryGuard::Cpu),
             )
             .await
             .map_err(KvError::from)
@@ -409,11 +747,87 @@ impl ClientTransferEngine {
                 src_addr,
                 target_addr,
                 len,
-                seg_guard,
+                seg_guard.map(ClientTransferMemoryGuard::Cpu),
+                false,
             )
             .await
             .map_err(KvError::from)
     }
+
+    /// Pull remote bytes into an explicitly validated caller-owned GPU range.
+    ///
+    /// Keeping this separate from the CPU entry point prevents a CUDA virtual
+    /// address from silently falling through CPU/P2P guard discovery.  The
+    /// guard is moved into the transfer engine and retains the exact
+    /// registration generation until the backend releases the local segment
+    /// lease.
+    pub async fn transfer_data_no_copy_to_gpu(
+        &self,
+        peer_node: NodeIDString,
+        src_addr: u64,
+        target_addr: u64,
+        len: u64,
+        gpu_guard: GpuMemoryGuard,
+    ) -> KvResult<TransferBreakdown> {
+        if len == 0 {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                    detail: "GPU transfer length must be non-zero".to_string(),
+                },
+            ));
+        }
+        if !gpu_guard.contains(target_addr, len) {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                    detail: format!(
+                        "GPU transfer exceeds destination guard: target={:#x} len={} registration_id={}",
+                        target_addr,
+                        len,
+                        gpu_guard.registration().registration_id
+                    ),
+                },
+            ));
+        }
+        const DIRECT_READY_TIMEOUT: Duration = Duration::from_secs(5);
+        const DIRECT_RETRY_DELAY: Duration = Duration::from_millis(10);
+
+        let started = Instant::now();
+        let mut attempt = 0_u32;
+        loop {
+            attempt = attempt.saturating_add(1);
+            let result = self
+                .core
+                .transfer_data_no_copy(
+                    self.runtime(),
+                    Some(peer_node.clone()),
+                    true,
+                    src_addr,
+                    target_addr,
+                    len,
+                    Some(ClientTransferMemoryGuard::Gpu(gpu_guard.clone())),
+                    true,
+                )
+                .await;
+            match result {
+                Ok(breakdown) => return Ok(breakdown),
+                Err(err)
+                    if err
+                        .to_string()
+                        .contains(CLOSED_RUNTIME_DIRECT_FAST_PATH_NOT_READY_MARKER)
+                        && started.elapsed() < DIRECT_READY_TIMEOUT =>
+                {
+                    tracing::debug!(
+                        peer = %peer_node,
+                        attempt,
+                        elapsed_ms = started.elapsed().as_millis(),
+                        "GPU direct transfer is waiting for the RDMA peer fast path"
+                    );
+                    limit_thirdparty::tokio::time::sleep(DIRECT_RETRY_DELAY).await;
+                }
+                Err(err) => return Err(KvError::from(err)),
+            }
+        }
+    }
 }
 
 #[async_trait]
@@ -435,3 +849,101 @@ impl LogicalModule for ClientTransferEngine {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod gpu_memory_registry_tests {
+    use super::GpuMemoryRegistry;
+
+    fn active_registry() -> (GpuMemoryRegistry, u64) {
+        let registry = GpuMemoryRegistry::new();
+        let registration = registry
+            .begin_register(0x1000, 0x1000, 2)
+            .expect("registration must start");
+        let registration_id = registration.registration_id;
+        registry.finish_register(registration_id, true);
+        (registry, registration_id)
+    }
+
+    #[test]
+    fn validates_exact_registration_generation_and_range() {
+        let (registry, registration_id) = active_registry();
+
+        let guard = registry
+            .validate_destination(registration_id, 0x1400, 0x400)
+            .expect("subrange must validate");
+        assert_eq!(guard.registration().registration_id, registration_id);
+        assert_eq!(guard.registration().device_id, 2);
+
+        assert!(
+            registry
+                .validate_destination(registration_id + 1, 0x1400, 0x400)
+                .unwrap_err()
+                .contains("registration id mismatch")
+        );
+        assert!(
+            registry
+                .validate_destination(registration_id, 0x1f00, 0x200)
+                .unwrap_err()
+                .contains("outside the active registration")
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_registration_geometry() {
+        let registry = GpuMemoryRegistry::new();
+        assert!(registry.begin_register(0, 1, 0).is_err());
+        assert!(registry.begin_register(1, 0, 0).is_err());
+        assert!(registry.begin_register(u64::MAX, 2, 0).is_err());
+    }
+
+    #[test]
+    fn unregister_waits_for_destination_guards() {
+        let (registry, registration_id) = active_registry();
+        let guard = registry
+            .validate_destination(registration_id, 0x1000, 0x1000)
+            .expect("full range must validate");
+
+        assert!(
+            registry
+                .begin_unregister(registration_id)
+                .unwrap_err()
+                .contains("GPU registration is busy")
+        );
+        drop(guard);
+
+        let descriptor = registry
+            .begin_unregister(registration_id)
+            .expect("unregister must start after guards drop");
+        assert_eq!(descriptor.registration_id, registration_id);
+        registry.finish_unregister(registration_id, true);
+        assert!(
+            registry
+                .validate_destination(registration_id, 0x1000, 1)
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn failed_backend_transitions_restore_retryable_state() {
+        let registry = GpuMemoryRegistry::new();
+        let first = registry
+            .begin_register(0x1000, 0x1000, 0)
+            .expect("first registration must start");
+        registry.finish_register(first.registration_id, false);
+
+        let second = registry
+            .begin_register(0x3000, 0x1000, 1)
+            .expect("failed registration must return to empty");
+        registry.finish_register(second.registration_id, true);
+        let descriptor = registry
+            .begin_unregister(second.registration_id)
+            .expect("unregister must start");
+        registry.finish_unregister(descriptor.registration_id, false);
+
+        assert!(
+            registry
+                .validate_destination(second.registration_id, 0x3000, 1)
+                .is_ok()
+        );
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index 2008f1b..86851bf 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -1,3 +1,4 @@
+use crate::ClientTransferEngineAccessTrait;
 use crate::SharedJsonMeta;
 use crate::client_kv_api::external_api::{
     compute_external_get_start_transfer_prefix, normalize_external_get_start_group_lens,
@@ -8,9 +9,16 @@ use crate::client_kv_api::msg_pack::{
     ExternalInvalidateWeakIndexResp,
 };
 use crate::client_seg_pool::{ClientSegPool, SideTransferPeerFileMeta};
+use crate::client_transfer_engine::{ClientTransferEngine, GpuMemoryGuard};
+use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
+use crate::master_kv_router::msg_pack::{
+    BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeReq, BatchGetRevokeResp,
+    BatchGetStartItemResp, BatchGetStartReq, BatchGetStartResp, GetAllocationMode,
+    GetExternalSinkTarget,
+};
 use crate::rpcresp_kvresult_convert::ToResult;
 use crate::{
     client_kv_api::msg_pack::{
@@ -37,6 +45,7 @@ use crate::{
     },
     rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK, SharedMemError},
 };
+use ::tokio::sync::watch;
 use async_trait::async_trait;
 use core::panic;
 use dashmap::DashMap;
@@ -44,6 +53,7 @@ use fluxon_commu::ShareGroupOwnerRef;
 use fluxon_framework::{LogicalModule, define_module};
 use fluxon_observability::kv_metrics_actor::{ObserveComponent, ObserveDirection};
 use fluxon_util::semaphore_map::SemaphoreMap;
+use futures::{StreamExt, stream};
 use libc::{MAP_SHARED, PROT_READ, PROT_WRITE, mmap};
 use limit_thirdparty::tokio;
 use limit_thirdparty::tokio::sync::{ARwLock, Notify};
@@ -54,7 +64,7 @@ use std::{
     // path::PathBuf, // 不再使用PathBuf
     sync::{
         Arc, OnceLock, Weak,
-        atomic::{AtomicUsize, Ordering},
+        atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
     },
     time::{Duration, Instant},
 };
@@ -79,6 +89,7 @@ const EXTERNAL_PUT_START_RPC_TIMEOUT_SECS: u64 = 30;
 const EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS: u64 = 30;
 const EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS: usize = 3;
 const EXTERNAL_PUT_TRACE_LOG_WINDOW_SECS: u64 = 10;
+const EXTERNAL_OWNER_INTRA_RPC_READY_TIMEOUT_SECS: u64 = 30;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum ExternalDeleteAckBatchSendResult {
@@ -92,6 +103,52 @@ pub struct ExternalClientGetStartResp {
     pub raw_prefix_hit_len: usize,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExternalGpuDestination {
+    pub registration_id: u64,
+    pub addr: u64,
+    pub capacity: u64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExternalGpuGetStartResp {
+    pub handle: u64,
+    pub raw_prefix_hit_len: usize,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExternalGpuGetTransferResp {
+    pub transferred_prefix_len: usize,
+    pub consumed_prefix_len: usize,
+}
+
+fn external_gpu_transfer_plan_geometry_is_valid(
+    item: &BatchGetStartItemResp,
+    destination: &ExternalGpuDestination,
+    registered_generation: u64,
+) -> bool {
+    item.len != 0
+        && item.target_addr == destination.addr
+        && item.target_base_addr == destination.addr
+        && item.len <= destination.capacity
+        && item.prepared_target.is_none()
+        && registered_generation == destination.registration_id
+}
+
+#[derive(Clone, Debug)]
+enum ExternalGpuGetTerminal {
+    Completed,
+    Revoked { transfer_error: Option<String> },
+    Failed { detail: String },
+}
+
+struct PendingExternalGpuGet {
+    transferable_len: usize,
+    atomic_group_lens: Vec<usize>,
+    cancel_requested: Arc<AtomicBool>,
+    terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminal>>,
+}
+
 struct PendingExternalGetStart {
     keys: Vec<String>,
     transferable_len: usize,
@@ -182,10 +239,12 @@ fn inline_external_get_tail_holder_ids(
 #[cfg(test)]
 mod inline_external_get_start_tests {
     use super::{
+        ExternalGpuDestination, external_gpu_transfer_plan_geometry_is_valid,
         inline_external_get_tail_holder_ids, validate_inline_external_get_owner_generation,
         validate_inline_external_get_start_plan,
     };
     use crate::client_kv_api::msg_pack::ExternalBatchGetItemResp;
+    use crate::master_kv_router::msg_pack::BatchGetStartItemResp;
     use crate::memholder::ExternalMemHolderInfo;
     use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
 
@@ -241,6 +300,28 @@ mod inline_external_get_start_tests {
         assert!(inline_external_get_tail_holder_ids(&items, 0).is_err());
         assert!(inline_external_get_tail_holder_ids(&items, 4).is_err());
     }
+
+    #[test]
+    fn gpu_transfer_plan_accepts_zero_as_the_first_master_get_id() {
+        let destination = ExternalGpuDestination {
+            registration_id: 7,
+            addr: 0x1000,
+            capacity: 4096,
+        };
+        let item = BatchGetStartItemResp {
+            get_id: 0,
+            target_addr: destination.addr,
+            target_base_addr: destination.addr,
+            len: destination.capacity,
+            ..Default::default()
+        };
+
+        assert!(external_gpu_transfer_plan_geometry_is_valid(
+            &item,
+            &destination,
+            destination.registration_id,
+        ));
+    }
 }
 
 fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
@@ -422,7 +503,8 @@ define_module!(
     ExternalClientApi,
     (external_client_api, ExternalClientApi),
     (p2p, P2pModule),
-    (cluster_manager, ClusterManager)
+    (cluster_manager, ClusterManager),
+    (client_transfer_engine, ClientTransferEngine)
 );
 
 /// External Client configuration parameters
@@ -498,6 +580,9 @@ pub struct ExternalInner {
     rpc_caller_external_batch_get_start: RPCCaller<ExternalBatchGetStartReq>,
     rpc_caller_external_batch_get_transfer: RPCCaller<ExternalBatchGetTransferReq>,
     rpc_caller_external_batch_get_cancel: RPCCaller<ExternalBatchGetCancelReq>,
+    rpc_caller_master_batch_get_start: RPCCaller<BatchGetStartReq>,
+    rpc_caller_master_batch_get_done: RPCCaller<BatchGetDoneReq>,
+    rpc_caller_master_batch_get_revoke: RPCCaller<BatchGetRevokeReq>,
     rpc_caller_external_put_commit: RPCCaller<ExternalPutCommitReq>,
     rpc_caller_external_batch_put_commit: RPCCaller<ExternalBatchPutCommitReq>,
     rpc_caller_external_put_start: RPCCaller<ExternalPutStartReq>,
@@ -519,6 +604,8 @@ pub struct ExternalInner {
     pending_external_get_start: DashMap<u64, PendingExternalGetStart>,
     /// Fully local plans consumed without a follow-up owner transfer RPC.
     pending_inline_external_get_start: DashMap<u64, PendingInlineExternalGetStart>,
+    next_gpu_get_handle: AtomicU64,
+    pending_external_gpu_get: DashMap<u64, PendingExternalGpuGet>,
     /// per-key semaphore (permits=1) to ensure single inflight per key
     inflight1_per_key: SemaphoreMap<String>,
     put_trace_log_window: Mutex<ExternalPutTraceLogWindow>,
@@ -527,6 +614,133 @@ pub struct ExternalInner {
 
 pub struct ExternalClientApi(ExternalInner);
 
+async fn wait_external_gpu_get_terminal(
+    mut terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminal>>,
+) -> KvResult<ExternalGpuGetTerminal> {
+    loop {
+        if let Some(terminal) = terminal_rx.borrow().clone() {
+            return Ok(terminal);
+        }
+        if terminal_rx.changed().await.is_err() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: "GPU Get transfer task ended without publishing a terminal state"
+                    .to_string(),
+            }));
+        }
+    }
+}
+
+async fn run_external_gpu_get_transfer(
+    view: ExternalClientApiView,
+    transfer_items: Vec<(BatchGetStartItemResp, GpuMemoryGuard)>,
+    skipped_get_ids: Vec<u64>,
+    transfer_concurrency: usize,
+    cancel_requested: Arc<AtomicBool>,
+) -> ExternalGpuGetTerminal {
+    let transfer_get_ids = transfer_items
+        .iter()
+        .map(|(item, _)| item.get_id)
+        .collect::<Vec<_>>();
+    let mut all_get_ids = skipped_get_ids.clone();
+    all_get_ids.extend(transfer_get_ids.iter().copied());
+
+    let skipped_revoke_error = view
+        .external_client_api()
+        .inner()
+        .master_batch_gpu_get_revoke(skipped_get_ids)
+        .await
+        .err()
+        .map(|err| err.to_string());
+
+    if transfer_items.is_empty() {
+        return match skipped_revoke_error {
+            Some(detail) => ExternalGpuGetTerminal::Failed {
+                detail: format!("GPU Get could not revoke non-transferable starts: {detail}"),
+            },
+            None => ExternalGpuGetTerminal::Revoked {
+                transfer_error: None,
+            },
+        };
+    }
+
+    let transfer_futures = transfer_items.into_iter().map(|(item, gpu_guard)| {
+        let transfer_view = view.clone();
+        let cancel_requested = cancel_requested.clone();
+        async move {
+            if cancel_requested.load(Ordering::Acquire) {
+                return None;
+            }
+            transfer_view
+                .client_transfer_engine()
+                .transfer_data_no_copy_to_gpu(
+                    item.node_id.clone(),
+                    item.src_addr,
+                    item.target_addr,
+                    item.len,
+                    gpu_guard,
+                )
+                .await
+                .err()
+                .map(|err| {
+                    format!(
+                        "GPU Get transfer failed: get_id={} source={} src={:#x} target={:#x} len={} error={}",
+                        item.get_id,
+                        item.node_id,
+                        item.src_addr,
+                        item.target_addr,
+                        item.len,
+                        err
+                    )
+                })
+        }
+    });
+    let mut transfer_stream =
+        stream::iter(transfer_futures).buffer_unordered(transfer_concurrency.max(1));
+    let mut transfer_error = None;
+    while let Some(item_error) = transfer_stream.next().await {
+        if transfer_error.is_none() {
+            transfer_error = item_error;
+        }
+    }
+
+    let cancelled = cancel_requested.load(Ordering::Acquire);
+    if cancelled || transfer_error.is_some() || skipped_revoke_error.is_some() {
+        if let Err(err) = view
+            .external_client_api()
+            .inner()
+            .master_batch_gpu_get_revoke(all_get_ids)
+            .await
+        {
+            return ExternalGpuGetTerminal::Failed {
+                detail: format!(
+                    "GPU Get cleanup failed after transfer/cancel: transfer_error={:?} skipped_revoke_error={:?} revoke_error={}",
+                    transfer_error, skipped_revoke_error, err
+                ),
+            };
+        }
+        if let Some(detail) = skipped_revoke_error {
+            return ExternalGpuGetTerminal::Failed {
+                detail: format!(
+                    "GPU Get initially failed to revoke non-transferable starts: {detail}"
+                ),
+            };
+        }
+        return ExternalGpuGetTerminal::Revoked { transfer_error };
+    }
+
+    match view
+        .external_client_api()
+        .inner()
+        .master_batch_gpu_get_done(transfer_get_ids)
+        .await
+    {
+        Ok(()) => ExternalGpuGetTerminal::Completed,
+        Err(err) => ExternalGpuGetTerminal::Failed {
+            detail: format!("GPU Get BatchDone failed: {err}"),
+        },
+    }
+}
+
 impl ExternalClientApi {
     /// Access inner external-only API. Safe to unwrap in external role.
     pub fn inner(&self) -> &ExternalInner {
@@ -567,6 +781,9 @@ impl ExternalClientApi {
             rpc_caller_external_batch_get_start: RPCCaller::<ExternalBatchGetStartReq>::new(),
             rpc_caller_external_batch_get_transfer: RPCCaller::<ExternalBatchGetTransferReq>::new(),
             rpc_caller_external_batch_get_cancel: RPCCaller::<ExternalBatchGetCancelReq>::new(),
+            rpc_caller_master_batch_get_start: RPCCaller::<BatchGetStartReq>::new(),
+            rpc_caller_master_batch_get_done: RPCCaller::<BatchGetDoneReq>::new(),
+            rpc_caller_master_batch_get_revoke: RPCCaller::<BatchGetRevokeReq>::new(),
             rpc_caller_external_put_commit: RPCCaller::<ExternalPutCommitReq>::new(),
             rpc_caller_external_batch_put_commit: RPCCaller::<ExternalBatchPutCommitReq>::new(),
             rpc_caller_external_put_start: RPCCaller::<ExternalPutStartReq>::new(),
@@ -587,6 +804,8 @@ impl ExternalClientApi {
             key_weak_memholder_index: DashMap::new(),
             pending_external_get_start: DashMap::new(),
             pending_inline_external_get_start: DashMap::new(),
+            next_gpu_get_handle: AtomicU64::new(1),
+            pending_external_gpu_get: DashMap::new(),
             inflight1_per_key: SemaphoreMap::new(1, std::time::Duration::from_secs(120)),
             put_trace_log_window: Mutex::new(ExternalPutTraceLogWindow::new()),
             external_delete_ack_batch: ExternalDeleteAckBatchHandle::new(),
@@ -666,6 +885,12 @@ impl ExternalClientApi {
             .regist(ext.view.p2p_module());
         ext.rpc_caller_external_batch_get_cancel
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_master_batch_get_start
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_master_batch_get_done
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_master_batch_get_revoke
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_put_commit
             .regist(ext.view.p2p_module());
         ext.rpc_caller_external_batch_put_commit
@@ -740,6 +965,11 @@ impl ExternalClientApi {
             .set_self_sub_cluster(ext.initial_sub_cluster.get().unwrap().clone())
             .await
             .map_err(KvError::from)?;
+        // Publishing the share-group binding changes the desired local-owner route from the
+        // pre-binding direct lane to intra-machine-only.  Do not announce external init complete
+        // until that topology transition has converged for the exact owner generation.
+        self.wait_current_owner_intra_rpc_ready_after_binding()
+            .await?;
 
         {
             let view = ext.view.clone_view();
@@ -894,6 +1124,61 @@ impl ExternalClientApi {
             }
         }
     }
+
+    async fn wait_current_owner_intra_rpc_ready_after_binding(&self) -> Result<(), KvError> {
+        let ext = &self.0;
+        let owner_id = ext
+            .shared_storage_node_id()
+            .await
+            .expect("external role expects current_owner to be Some after init2");
+        let owner_node_id = owner_id.clone().into();
+        let owner_start_time = ext.current_owner_start_time().await;
+        let expected_binding = ShareGroupOwnerRef {
+            owner_id: owner_id.clone(),
+            owner_start_time,
+        };
+        let started_at = Instant::now();
+        let timeout = Duration::from_secs(EXTERNAL_OWNER_INTRA_RPC_READY_TIMEOUT_SECS);
+
+        tracing::info!(
+            owner_id = %owner_id,
+            owner_start_time,
+            "External init: waiting for current owner intra-machine RPC route after share-group binding"
+        );
+        loop {
+            let snapshot = ext.view.p2p_module().tier_snapshot();
+            let self_binding_ready = snapshot
+                .share_group_owner(&snapshot.self_peer_gen.peer_id)
+                == Some(&expected_binding);
+            if self_binding_ready
+                && let Some(peer_gen) = snapshot.peer_gen(&owner_node_id)
+                && peer_gen.node_start_time == owner_start_time
+                && snapshot.is_send_ready_intra_effective(&peer_gen)
+            {
+                tracing::info!(
+                    owner_id = %owner_id,
+                    owner_start_time,
+                    elapsed_ms = started_at.elapsed().as_millis(),
+                    "External init: current owner intra-machine RPC route ready after share-group binding"
+                );
+                return Ok(());
+            }
+
+            if started_at.elapsed() >= timeout {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "timed out waiting for current owner intra-machine RPC route after share-group binding: owner_id={} owner_start_time={} timeout_s={} self_binding={:?} peer={:?}",
+                        owner_id,
+                        owner_start_time,
+                        EXTERNAL_OWNER_INTRA_RPC_READY_TIMEOUT_SECS,
+                        snapshot.share_group_owner(&snapshot.self_peer_gen.peer_id),
+                        snapshot.peers.get(owner_id.as_str()),
+                    ),
+                }));
+            }
+            sleep(Duration::from_millis(20)).await;
+        }
+    }
 }
 
 impl ExternalInner {
@@ -2044,6 +2329,404 @@ impl ExternalInner {
         }
     }
 
+    async fn master_batch_gpu_get_revoke(&self, get_ids: Vec<u64>) -> KvResult<()> {
+        if get_ids.is_empty() {
+            return Ok(());
+        }
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let expected_get_ids = get_ids.clone();
+        let resp: MsgPack<BatchGetRevokeResp> = self
+            .rpc_caller_master_batch_get_revoke
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: BatchGetRevokeReq { get_ids },
+                    raw_bytes: Vec::new(),
+                },
+                None,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        if resp.serialize_part.items.len() != expected_get_ids.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "GPU Get BatchRevoke response length mismatch: expected={} got={}",
+                    expected_get_ids.len(),
+                    resp.serialize_part.items.len()
+                ),
+            }));
+        }
+        for (expected_get_id, item) in expected_get_ids
+            .into_iter()
+            .zip(resp.serialize_part.items.into_iter())
+        {
+            if item.get_id != expected_get_id {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "GPU Get BatchRevoke response identity mismatch: expected={} got={}",
+                        expected_get_id, item.get_id
+                    ),
+                }));
+            }
+            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)?;
+        }
+        Ok(())
+    }
+
+    async fn master_batch_gpu_get_done(&self, get_ids: Vec<u64>) -> KvResult<()> {
+        if get_ids.is_empty() {
+            return Ok(());
+        }
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let expected_get_ids = get_ids.clone();
+        let resp: MsgPack<BatchGetDoneResp> = self
+            .rpc_caller_master_batch_get_done
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: BatchGetDoneReq { get_ids },
+                    raw_bytes: Vec::new(),
+                },
+                None,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        if resp.serialize_part.items.len() != expected_get_ids.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "GPU Get BatchDone response length mismatch: expected={} got={}",
+                    expected_get_ids.len(),
+                    resp.serialize_part.items.len()
+                ),
+            }));
+        }
+        for (expected_get_id, item) in expected_get_ids
+            .into_iter()
+            .zip(resp.serialize_part.items.into_iter())
+        {
+            if item.get_id != expected_get_id {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "GPU Get BatchDone response identity mismatch: expected={} got={}",
+                        expected_get_id, item.get_id
+                    ),
+                }));
+            }
+            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)?;
+            if item.holder_id != 0 || item.allocation_mode != GetAllocationMode::ExternalSink {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "GPU Get BatchDone returned a cache-owned target: get_id={} holder_id={} allocation_mode={:?}",
+                        item.get_id, item.holder_id, item.allocation_mode
+                    ),
+                }));
+            }
+        }
+        Ok(())
+    }
+
+    pub async fn get_start_gpu(
+        &self,
+        keys: Vec<String>,
+        destinations: Vec<ExternalGpuDestination>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+        transfer_concurrency: usize,
+    ) -> KvResult<ExternalGpuGetStartResp> {
+        if keys.is_empty() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "get_start_gpu requires at least one key".to_string(),
+            }));
+        }
+        if keys.len() != destinations.len() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "get_start_gpu keys/destinations length mismatch: keys={} destinations={}",
+                    keys.len(),
+                    destinations.len()
+                ),
+            }));
+        }
+        if transfer_concurrency == 0 {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "get_start_gpu transfer_concurrency must be > 0".to_string(),
+            }));
+        }
+        let group_lens = normalize_external_get_start_group_lens(keys.len(), atomic_group_lens)?;
+        let self_info = self.view.cluster_manager().get_self_info();
+        if self_info.node_role() != NodeRole::External {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "get_start_gpu requires an external node membership".to_string(),
+            }));
+        }
+
+        let mut destination_guards = Vec::with_capacity(destinations.len());
+        let mut external_sink_targets = Vec::with_capacity(destinations.len());
+        for destination in &destinations {
+            let guard = self
+                .view
+                .client_transfer_engine()
+                .validate_gpu_destination(
+                    destination.registration_id,
+                    destination.addr,
+                    destination.capacity,
+                )?;
+            destination_guards.push(guard);
+            external_sink_targets.push(Some(GetExternalSinkTarget {
+                addr: destination.addr,
+                capacity: destination.capacity,
+                registration_id: destination.registration_id,
+                requester_node_start_time: self_info.node_start_time,
+            }));
+        }
+
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp: MsgPack<BatchGetStartResp> = self
+            .rpc_caller_master_batch_get_start
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: BatchGetStartReq {
+                        keys: keys.clone(),
+                        prepared_targets: Vec::new(),
+                        external_sink_targets,
+                    },
+                    raw_bytes: Vec::new(),
+                },
+                None,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+
+        let start_items = resp.serialize_part.items;
+        let started_get_ids = start_items
+            .iter()
+            .filter(|item| item.error_code == OK)
+            .map(|item| item.get_id)
+            .collect::<Vec<_>>();
+        if start_items.len() != keys.len() {
+            let cleanup = self
+                .master_batch_gpu_get_revoke(started_get_ids)
+                .await
+                .err()
+                .map(|err| err.to_string());
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "get_start_gpu response length mismatch: expected={} got={} cleanup_error={:?}",
+                    keys.len(),
+                    start_items.len(),
+                    cleanup
+                ),
+            }));
+        }
+
+        for item in &start_items {
+            if item.error_code != OK
+                && item.error_code
+                    != crate::rpcresp_kvresult_convert::msg_and_error::codes_api::API_KEY_NOT_FOUND
+            {
+                let err = crate::rpcresp_kvresult_convert::try_from_code(
+                    item.error_code,
+                    item.error_json.clone(),
+                )
+                .expect_err("non-OK GPU GetStart item must decode as an error");
+                let cleanup = self
+                    .master_batch_gpu_get_revoke(started_get_ids)
+                    .await
+                    .err()
+                    .map(|cleanup_err| cleanup_err.to_string());
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "get_start_gpu item failed: error={} cleanup_error={:?}",
+                        err, cleanup
+                    ),
+                }));
+            }
+        }
+
+        for (idx, ((item, destination), guard)) in start_items
+            .iter()
+            .zip(destinations.iter())
+            .zip(destination_guards.iter())
+            .enumerate()
+        {
+            if item.error_code != OK {
+                continue;
+            }
+            let geometry_is_valid = external_gpu_transfer_plan_geometry_is_valid(
+                item,
+                destination,
+                guard.registration().registration_id,
+            );
+            if !geometry_is_valid || item.node_id == self_info.id {
+                let cleanup = self
+                    .master_batch_gpu_get_revoke(started_get_ids)
+                    .await
+                    .err()
+                    .map(|cleanup_err| cleanup_err.to_string());
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "get_start_gpu invalid master transfer plan: index={} get_id={} source={} target={:#x} base={:#x} len={} destination={:?} cleanup_error={:?}",
+                        idx,
+                        item.get_id,
+                        item.node_id,
+                        item.target_addr,
+                        item.target_base_addr,
+                        item.len,
+                        destination,
+                        cleanup
+                    ),
+                }));
+            }
+        }
+
+        let raw_prefix_hit_len = start_items
+            .iter()
+            .take_while(|item| item.error_code == OK)
+            .count();
+        let transferable_len = compute_external_get_start_transfer_prefix(
+            raw_prefix_hit_len,
+            &group_lens,
+            prefix_best_effort,
+        );
+        let mut transfer_items = Vec::with_capacity(transferable_len);
+        let mut skipped_get_ids = Vec::new();
+        for (idx, (item, guard)) in start_items
+            .into_iter()
+            .zip(destination_guards.into_iter())
+            .enumerate()
+        {
+            if item.error_code != OK {
+                continue;
+            }
+            if idx < transferable_len {
+                transfer_items.push((item, guard));
+            } else {
+                skipped_get_ids.push(item.get_id);
+            }
+        }
+
+        let handle = self.next_gpu_get_handle.fetch_add(1, Ordering::Relaxed);
+        if handle == 0 {
+            let mut all_get_ids = skipped_get_ids.clone();
+            all_get_ids.extend(transfer_items.iter().map(|(item, _)| item.get_id));
+            let _ = self.master_batch_gpu_get_revoke(all_get_ids).await;
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: "get_start_gpu local handle space exhausted".to_string(),
+            }));
+        }
+        let cancel_requested = Arc::new(AtomicBool::new(false));
+        let (terminal_tx, terminal_rx) = watch::channel(None);
+        self.pending_external_gpu_get.insert(
+            handle,
+            PendingExternalGpuGet {
+                transferable_len,
+                atomic_group_lens: group_lens,
+                cancel_requested: cancel_requested.clone(),
+                terminal_rx,
+            },
+        );
+        let view = self.view.clone_view();
+        let view_task = view.clone();
+        view.spawn(format!("external_gpu_get_transfer_{handle}"), async move {
+            let terminal = run_external_gpu_get_transfer(
+                view_task,
+                transfer_items,
+                skipped_get_ids,
+                transfer_concurrency,
+                cancel_requested,
+            )
+            .await;
+            let _ = terminal_tx.send(Some(terminal));
+        });
+        Ok(ExternalGpuGetStartResp {
+            handle,
+            raw_prefix_hit_len,
+        })
+    }
+
+    pub async fn get_transfer_gpu(
+        &self,
+        handle: u64,
+        consume_prefix_len: Option<usize>,
+    ) -> KvResult<ExternalGpuGetTransferResp> {
+        let Some((_, pending)) = self.pending_external_gpu_get.remove(&handle) else {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!("get_transfer_gpu requires a live handle: {handle}"),
+            }));
+        };
+        let consumed_prefix_len = consume_prefix_len.unwrap_or(pending.transferable_len);
+        if let Err(err) = validate_external_get_consume_prefix(
+            consumed_prefix_len,
+            pending.transferable_len,
+            &pending.atomic_group_lens,
+        ) {
+            self.pending_external_gpu_get.insert(handle, pending);
+            return Err(err);
+        }
+        let terminal = wait_external_gpu_get_terminal(pending.terminal_rx).await?;
+        match terminal {
+            ExternalGpuGetTerminal::Completed => Ok(ExternalGpuGetTransferResp {
+                transferred_prefix_len: pending.transferable_len,
+                consumed_prefix_len,
+            }),
+            ExternalGpuGetTerminal::Revoked { transfer_error } => {
+                Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "get_transfer_gpu was revoked: handle={} transfer_error={:?}",
+                        handle, transfer_error
+                    ),
+                }))
+            }
+            ExternalGpuGetTerminal::Failed { detail } => {
+                Err(KvError::Api(ApiError::Unknown { detail }))
+            }
+        }
+    }
+
+    pub async fn cancel_get_transfer_gpu(&self, handle: u64) -> KvResult<()> {
+        let Some((_, pending)) = self.pending_external_gpu_get.remove(&handle) else {
+            return Ok(());
+        };
+        pending.cancel_requested.store(true, Ordering::Release);
+        match wait_external_gpu_get_terminal(pending.terminal_rx).await? {
+            ExternalGpuGetTerminal::Completed | ExternalGpuGetTerminal::Revoked { .. } => Ok(()),
+            ExternalGpuGetTerminal::Failed { detail } => {
+                Err(KvError::Api(ApiError::Unknown { detail }))
+            }
+        }
+    }
+
     pub async fn batch_get_start(
         &self,
         keys: Vec<String>,
diff --git a/fluxon_rs/fluxon_kv/src/lib.rs b/fluxon_rs/fluxon_kv/src/lib.rs
index 0842a68..a9d38ae 100644
--- a/fluxon_rs/fluxon_kv/src/lib.rs
+++ b/fluxon_rs/fluxon_kv/src/lib.rs
@@ -2057,6 +2057,29 @@ async fn run_client_impl(
             metric_reporter_arg: MetricReporterNewArg {
                 test_spec_config: config.test_spec_config.clone(),
             },
+            client_seg_pool_arg: ClientSegPoolNewArg {
+                contribute_size: config.contribute_to_cluster_pool_size.clone(),
+                share_mem_path: config.share_mem_path.clone(),
+                large_file_paths: config.large_file_paths.clone(),
+                cluster_name: config.cluster_name.clone(),
+                etcd_addresses: config.etcd_addresses_raw.clone(),
+                attach_existing_meta: None,
+                side_transfer_worker: false,
+                require_transfer_rpc_fast_path_ready_timeout: None,
+            },
+            client_transfer_engine_arg: ClientTransferEngineNewArg {
+                metadata_uri: config.fluxonkv_spec.etcd_addresses[0].clone(),
+                instance_name: config.instance_key.clone(),
+                enable_transfer_rpc_fast_path: config.fluxonkv_spec.enable_transfer_rpc_fast_path,
+                rpc_port: 12345,
+                protocol_type: config.protocol.protocol_type.clone(),
+                rdma_device_names: transfer_engine_rdma_device_names_from_config(
+                    &config.protocol,
+                    Some(&config.test_spec_config),
+                ),
+                backend_activation_mode: transfer_backend_activation_mode,
+                transfer_engine: config.fluxonkv_spec.transfer_engine.clone(),
+            },
             external_client_api_arg: ExternalClientApiNewArg {
                 shared_memory_path: config.share_mem_path.clone(),
                 shared_file_path: config.share_mem_path.clone(),
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 795a1c4..46c8e2f 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -6,9 +6,9 @@ use super::{
         BatchGetDoneItemResp, BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeItemResp,
         BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
         BatchGetStartResp, BatchIsExistReq, BatchIsExistResp, GetAllocationMode, GetDoneReq,
-        GetDoneResp, GetMetaReq, GetMetaResp, GetPreparedLocalReserveTarget, GetRevokeReq,
-        GetRevokeResp, GetStartReq, GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp,
-        MemHolderReleaseReq, MemHolderReleaseResp,
+        GetDoneResp, GetExternalSinkTarget, GetMetaReq, GetMetaResp, GetPreparedLocalReserveTarget,
+        GetRevokeReq, GetRevokeResp, GetStartReq, GetStartResp, MemHolderKeepAliveReq,
+        MemHolderKeepAliveResp, MemHolderReleaseReq, MemHolderReleaseResp,
     },
     node_generation_is_current_live, publish_route_replica_tomb_fenced,
     route_maintenance::{RoutePublishEvent, apply_post_route_maintenance_batch},
@@ -17,12 +17,13 @@ use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::put::PutIDForAKey;
 use crate::memholder::MemholderManagerTrait;
 use crate::{
-    cluster_manager::NodeID,
+    cluster_manager::{ClusterManagerAccessTrait, NodeID, NodeRole},
     master_seg_manager::{MasterSegManagerAccessTrait, NodeTombTag, one_seg_allocator::Allocation},
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::{self, kv},
 };
 use dashmap::DashMap;
+use fluxon_commu::share_group_owner_ref_from_metadata;
 use limit_thirdparty::tokio;
 use rand::Rng;
 use rand::seq::SliceRandom;
@@ -170,6 +171,75 @@ fn validate_prepared_local_reserve_target(
     ))
 }
 
+fn external_sink_local_owner_id(
+    view: &MasterKvRouterView,
+    req_node_id: &NodeID,
+    requester_node_start_time: i64,
+) -> Option<String> {
+    let requester = view
+        .cluster_manager()
+        .get_member_info_cached(req_node_id.as_ref())?;
+    if requester.node_start_time != requester_node_start_time
+        || requester.node_role() != NodeRole::External
+    {
+        return None;
+    }
+    let owner_ref = share_group_owner_ref_from_metadata(&requester.metadata)?;
+    let owner = view
+        .cluster_manager()
+        .get_member_info_cached(&owner_ref.owner_id)?;
+    (owner.node_start_time == owner_ref.owner_start_time && owner.node_role() == NodeRole::Client)
+        .then_some(owner_ref.owner_id)
+}
+
+fn external_sink_requester_generation_is_current(
+    view: &MasterKvRouterView,
+    req_node_id: &NodeID,
+    requester_node_start_time: i64,
+) -> bool {
+    external_sink_local_owner_id(view, req_node_id, requester_node_start_time).is_some()
+}
+
+fn validate_external_sink_target(
+    view: &MasterKvRouterView,
+    req_node_id: &NodeID,
+    target: &GetExternalSinkTarget,
+    value_len: u64,
+) -> Result<(), msg_and_error::KvError> {
+    let invalid = |detail: String| {
+        msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument { detail })
+    };
+    if target.addr == 0 || target.capacity == 0 || target.registration_id == 0 {
+        return Err(invalid(format!(
+            "external Get sink requires non-zero addr/capacity/registration_id: addr={:#x} capacity={} registration_id={}",
+            target.addr, target.capacity, target.registration_id
+        )));
+    }
+    if target.addr.checked_add(target.capacity).is_none() {
+        return Err(invalid(format!(
+            "external Get sink range overflows: addr={:#x} capacity={}",
+            target.addr, target.capacity
+        )));
+    }
+    if value_len > target.capacity {
+        return Err(invalid(format!(
+            "external Get sink is too small: value_len={} capacity={}",
+            value_len, target.capacity
+        )));
+    }
+    if !external_sink_requester_generation_is_current(
+        view,
+        req_node_id,
+        target.requester_node_start_time,
+    ) {
+        return Err(invalid(format!(
+            "external Get sink requester generation is not current: requester={} start_time={}",
+            req_node_id, target.requester_node_start_time
+        )));
+    }
+    Ok(())
+}
+
 pub async fn handle_get_start(
     view: MasterKvRouterView,
     req: MsgPack<GetStartReq>,
@@ -218,6 +288,16 @@ pub async fn handle_get_start(
 
     tracing::debug!("Handling GetStartReq: {:?}", req.serialize_part);
 
+    if req.serialize_part.prepared_target.is_some()
+        && req.serialize_part.external_sink_target.is_some()
+    {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: "GetStart prepared_target and external_sink_target are mutually exclusive"
+                .to_string(),
+        });
+        return failed_resp_err(err, None, &view, &req.serialize_part.key);
+    }
+
     let activity_lease = match view
         .master_kv_router()
         .reserve_inflight_get_key(&req.serialize_part.key)
@@ -262,6 +342,10 @@ pub async fn handle_get_start(
 
     let replicas: HashMap<NodeID, KvRouteInfo> = one_kv_nodes_routes.nodes_replicas.read().clone();
     let prepared_target = req.serialize_part.prepared_target.clone();
+    let external_sink_target = req.serialize_part.external_sink_target.clone();
+    let external_sink_local_owner = external_sink_target.as_ref().and_then(|target| {
+        external_sink_local_owner_id(&view, &req_node_id, target.requester_node_start_time)
+    });
     // Currently we are holding the lock with `replicas`
     // 选择一个replica (这里可以实现更复杂的选择逻辑)
     let mut replica_keys = replicas.keys().collect::<Vec<_>>();
@@ -277,6 +361,16 @@ pub async fn handle_get_start(
             tombs.insert(selected_replica_key.to_owned());
             continue;
         }
+        if external_sink_local_owner
+            .as_deref()
+            .is_some_and(|owner_id| selected_replica.node_id.as_ref() == owner_id)
+        {
+            // The explicit GPU path is RDMA-only. The requester's share-group
+            // owner is local IPC/P2P topology, whose fallback would require
+            // CPU access to a CUDA virtual address. Leave that replica for the
+            // ordinary CPU-buffered Get path and search for a remote route.
+            continue;
+        }
         let src_node_id = selected_replica.node_id.clone();
         let src_len = selected_replica.backing.len();
         let src_abs_addr = selected_replica.backing.abs_addr();
@@ -354,34 +448,14 @@ pub async fn handle_get_start(
 
         // 为get调用方分配接收内存作为传输target
         if target.is_none() {
-            target = Some(if let Some(prepared_target) = prepared_target.as_ref() {
-                if replicas
-                    .get(&req_node_id)
-                    .is_some_and(|replica| !replica.tomb_tag.is_tomb())
-                {
-                    let err = msg_and_error::KvError::Api(
-                        msg_and_error::ApiError::InvalidArgument {
-                            detail: format!(
-                                "prepared local-reserve Get target cannot replace a live replica: key={} requester={}",
-                                req.serialize_part.key, req_node_id
-                            ),
-                        },
-                    );
-                    return failed_resp_err(
-                        err,
-                        Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+            target = Some(
+                if let Some(external_sink_target) = external_sink_target.as_ref() {
+                    if let Err(err) = validate_external_sink_target(
                         &view,
-                        &req.serialize_part.key,
-                    );
-                }
-                let (slot, _prepared_tomb_tag) = match validate_prepared_local_reserve_target(
-                    &view,
-                    &req_node_id,
-                    prepared_target,
-                    src_len,
-                ) {
-                    Ok(slot) => slot,
-                    Err(err) => {
+                        &req_node_id,
+                        external_sink_target,
+                        src_len,
+                    ) {
                         return failed_resp_err(
                             err,
                             Some((tombs.clone(), one_kv_nodes_routes.put_id)),
@@ -389,26 +463,66 @@ pub async fn handle_get_start(
                             &req.serialize_part.key,
                         );
                     }
-                };
-                allocation_mode = GetAllocationMode::LocalCommittedSlot;
-                InflightGetTarget::PreparedLocalReserveSlot(slot)
-            } else if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
-                match &replica_on_recv_node.backing {
-                    super::KvReplicaBacking::Allocation(allocation) => {
-                        allocation_mode = GetAllocationMode::ReuseReplica;
-                        InflightGetTarget::Allocation(allocation.clone())
+                    allocation_mode = GetAllocationMode::ExternalSink;
+                    InflightGetTarget::ExternalSink(external_sink_target.clone())
+                } else if let Some(prepared_target) = prepared_target.as_ref() {
+                    if replicas
+                        .get(&req_node_id)
+                        .is_some_and(|replica| !replica.tomb_tag.is_tomb())
+                    {
+                        let err = msg_and_error::KvError::Api(
+                            msg_and_error::ApiError::InvalidArgument {
+                                detail: format!(
+                                    "prepared local-reserve Get target cannot replace a live replica: key={} requester={}",
+                                    req.serialize_part.key, req_node_id
+                                ),
+                            },
+                        );
+                        return failed_resp_err(
+                            err,
+                            Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+                            &view,
+                            &req.serialize_part.key,
+                        );
                     }
-                    super::KvReplicaBacking::CommittedSlot(_) => match allocate_request_target() {
+                    let (slot, _prepared_tomb_tag) = match validate_prepared_local_reserve_target(
+                        &view,
+                        &req_node_id,
+                        prepared_target,
+                        src_len,
+                    ) {
+                        Ok(slot) => slot,
+                        Err(err) => {
+                            return failed_resp_err(
+                                err,
+                                Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+                                &view,
+                                &req.serialize_part.key,
+                            );
+                        }
+                    };
+                    allocation_mode = GetAllocationMode::LocalCommittedSlot;
+                    InflightGetTarget::PreparedLocalReserveSlot(slot)
+                } else if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
+                    match &replica_on_recv_node.backing {
+                        super::KvReplicaBacking::Allocation(allocation) => {
+                            allocation_mode = GetAllocationMode::ReuseReplica;
+                            InflightGetTarget::Allocation(allocation.clone())
+                        }
+                        super::KvReplicaBacking::CommittedSlot(_) => {
+                            match allocate_request_target() {
+                                Ok(allocation) => allocation,
+                                Err(resp) => return resp,
+                            }
+                        }
+                    }
+                } else {
+                    match allocate_request_target() {
                         Ok(allocation) => allocation,
                         Err(resp) => return resp,
-                    },
-                }
-            } else {
-                match allocate_request_target() {
-                    Ok(allocation) => allocation,
-                    Err(resp) => return resp,
-                }
-            });
+                    }
+                },
+            );
         }
 
         let target = target
@@ -433,8 +547,9 @@ pub async fn handle_get_start(
                         && node_generation_is_current_live(&view, &req_node_id, &grant.tomb_tag))
                     .then(|| grant.tomb_tag.clone())
                 }),
+            InflightGetTarget::ExternalSink(_) => None,
         };
-        let Some(target_tomb_tag) = target_tomb_tag else {
+        if !matches!(&target, InflightGetTarget::ExternalSink(_)) && target_tomb_tag.is_none() {
             let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
                 detail: format!(
                     "Get target generation changed before start publication: get_id={} key={} requester={}",
@@ -447,7 +562,7 @@ pub async fn handle_get_start(
                 &view,
                 &req.serialize_part.key,
             );
-        };
+        }
 
         // Convert to absolute addresses for Mooncake (requires absolute)
         // Use allocation's allocator base directly
@@ -704,7 +819,88 @@ async fn handle_get_done_locked(
         let req_node_id = inflight_info.req_node_id.clone();
         let key = inflight_info.key;
         let target_cap = inflight_info.target.capacity();
-        if !node_generation_is_current_live(&view, &req_node_id, &inflight_info.target_tomb_tag) {
+        if allocation_mode == GetAllocationMode::ExternalSink {
+            let generation_is_current = match &inflight_info.target {
+                InflightGetTarget::ExternalSink(target) => {
+                    external_sink_requester_generation_is_current(
+                        &view,
+                        &req_node_id,
+                        target.requester_node_start_time,
+                    )
+                }
+                _ => false,
+            };
+            let terminal = if generation_is_current {
+                view.master_kv_router()
+                    .view()
+                    .metric_reporter()
+                    .metrics()
+                    .inc_kv_get_done_allocation("external_sink");
+                GetDoneResp {
+                    holder_id: 0,
+                    allocation_mode: GetAllocationMode::ExternalSink,
+                    error_code: msg_and_error::OK,
+                    error_json: String::new(),
+                    server_process_us: 0,
+                }
+            } else {
+                let err = msg_and_error::KvError::Api(
+                    msg_and_error::ApiError::InvalidPutMasterState {
+                        detail: format!(
+                            "external Get sink requester generation departed before Done: get_id={} key={} requester={}",
+                            get_id, key, req_node_id
+                        ),
+                    },
+                );
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err)
+            };
+            let completed = CompletedGetInfo {
+                req_node_id: req_node_id.clone(),
+                response: terminal.clone(),
+            };
+            if let Some(terminals) = deferred_terminals.as_deref_mut() {
+                terminals.push((get_id, completed));
+            } else {
+                view.master_kv_router()
+                    .inner()
+                    .completed_gets
+                    .insert(get_id, completed)
+                    .await;
+            }
+            return MsgPack {
+                serialize_part: terminal,
+                raw_bytes: Vec::new(),
+            };
+        }
+
+        let Some(target_tomb_tag) = inflight_info.target_tomb_tag.as_ref() else {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
+                detail: format!(
+                    "allocator-backed Get lost its target generation: get_id={} key={} requester={}",
+                    get_id, key, req_node_id
+                ),
+            });
+            let terminal: GetDoneResp =
+                crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+            let completed = CompletedGetInfo {
+                req_node_id: req_node_id.clone(),
+                response: terminal.clone(),
+            };
+            if let Some(terminals) = deferred_terminals.as_deref_mut() {
+                terminals.push((get_id, completed));
+            } else {
+                view.master_kv_router()
+                    .inner()
+                    .completed_gets
+                    .insert(get_id, completed)
+                    .await;
+            }
+            return MsgPack {
+                serialize_part: terminal,
+                raw_bytes: Vec::new(),
+            };
+        };
+        if !node_generation_is_current_live(&view, &req_node_id, target_tomb_tag) {
             let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidPutMasterState {
                 detail: format!(
                     "GetDone target generation departed: get_id={} key={} requester={}",
@@ -757,12 +953,15 @@ async fn handle_get_done_locked(
                 holder_id
             }
             InflightGetTarget::PreparedLocalReserveSlot(_) => 0,
+            InflightGetTarget::ExternalSink(_) => {
+                unreachable!("external Get sink must complete before holder publication")
+            }
         };
 
         // Close the insertion-vs-MemberLeft cleanup race for the holder.  If
         // MemberLeft marked the shared tag before this check, remove the exact
         // holder we just inserted.  Otherwise its later cleanup must observe it.
-        if inflight_info.target_tomb_tag.is_tomb() {
+        if target_tomb_tag.is_tomb() {
             if let Some(holder_key) = inserted_holder_key.as_ref() {
                 view.master_kv_router()
                     .inner()
@@ -809,7 +1008,7 @@ async fn handle_get_done_locked(
                 if one_kv_nodes_routes.put_id == inflight_info.put_id {
                     match view.master_kv_router().reserve_node_cache_capacity(
                         &req_node_id,
-                        &inflight_info.target_tomb_tag,
+                        target_tomb_tag,
                         ReservedCapacityReason::OwnerIndexedAllocation,
                         target_cap,
                     ) {
@@ -823,11 +1022,14 @@ async fn handle_get_done_locked(
                                     InflightGetTarget::PreparedLocalReserveSlot(_) => {
                                         unreachable!("durable Get mode must use Allocation target")
                                     }
+                                    InflightGetTarget::ExternalSink(_) => {
+                                        unreachable!("durable Get mode cannot use external sink")
+                                    }
                                 }),
                                 owner_local_indexed: true,
                                 get_durable_reservation: inflight_info.durable_reservation.clone(),
                                 capacity_reservation,
-                                tomb_tag: inflight_info.target_tomb_tag.clone(),
+                                tomb_tag: target_tomb_tag.clone(),
                             };
                             if publish_route_replica_tomb_fenced(
                                 &one_kv_nodes_routes,
@@ -888,7 +1090,7 @@ async fn handle_get_done_locked(
             let mut route_lease_id = None;
             let capacity_reservation = view.master_kv_router().reserve_node_cache_capacity(
                 &req_node_id,
-                &inflight_info.target_tomb_tag,
+                target_tomb_tag,
                 ReservedCapacityReason::OwnerIndexedAllocation,
                 target_cap,
             );
@@ -906,9 +1108,7 @@ async fn handle_get_done_locked(
                             let mut replicas = current_route.nodes_replicas.write();
                             if let Some(replica) = replicas.get_mut(&req_node_id) {
                                 local_index_published = !replica.tomb_tag.is_tomb()
-                                    && replica
-                                        .tomb_tag
-                                        .same_generation(&inflight_info.target_tomb_tag)
+                                    && replica.tomb_tag.same_generation(target_tomb_tag)
                                     && matches!(
                                         &replica.backing,
                                         super::KvReplicaBacking::Allocation(allocation)
@@ -977,6 +1177,9 @@ async fn handle_get_done_locked(
                 InflightGetTarget::Allocation(_) => {
                     unreachable!("local committed-slot Get mode must use a prepared slot")
                 }
+                InflightGetTarget::ExternalSink(_) => {
+                    unreachable!("local committed-slot Get mode cannot use external sink")
+                }
             };
             let mut published = false;
             let mut route_publish_event = None;
@@ -988,7 +1191,7 @@ async fn handle_get_done_locked(
                         owner_local_indexed: true,
                         get_durable_reservation: None,
                         capacity_reservation: None,
-                        tomb_tag: inflight_info.target_tomb_tag.clone(),
+                        tomb_tag: target_tomb_tag.clone(),
                     };
                     if publish_route_replica_tomb_fenced(
                         &current_route,
@@ -1056,6 +1259,7 @@ async fn handle_get_done_locked(
                 GetAllocationMode::ReuseReplica => "reuse_replica",
                 GetAllocationMode::DurableReplica => "durable_replica",
                 GetAllocationMode::LocalCommittedSlot => "local_committed_slot",
+                GetAllocationMode::ExternalSink => "external_sink",
             });
 
         let terminal = GetDoneResp {
@@ -1343,6 +1547,7 @@ pub async fn handle_batch_get_start(
     let BatchGetStartReq {
         keys,
         prepared_targets,
+        external_sink_targets,
     } = req.serialize_part;
     if !prepared_targets.is_empty() && prepared_targets.len() != keys.len() {
         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
@@ -1363,19 +1568,48 @@ pub async fn handle_batch_get_start(
             raw_bytes: Vec::new(),
         };
     }
+    if !external_sink_targets.is_empty() && external_sink_targets.len() != keys.len() {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: format!(
+                "batch_get_start external sink target length mismatch: keys={} targets={}",
+                keys.len(),
+                external_sink_targets.len()
+            ),
+        });
+        let error: GetStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(&err);
+        return MsgPack {
+            serialize_part: BatchGetStartResp {
+                items: Vec::new(),
+                error_code: error.error_code,
+                error_json: error.error_json,
+                server_process_us: 0,
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
     let prepared_targets = if prepared_targets.is_empty() {
         vec![None; keys.len()]
     } else {
         prepared_targets
     };
+    let external_sink_targets = if external_sink_targets.is_empty() {
+        vec![None; keys.len()]
+    } else {
+        external_sink_targets
+    };
     let mut items = Vec::with_capacity(keys.len());
-    for (key, prepared_target) in keys.into_iter().zip(prepared_targets) {
+    for ((key, prepared_target), external_sink_target) in keys
+        .into_iter()
+        .zip(prepared_targets)
+        .zip(external_sink_targets)
+    {
         let (_get_id, resp) = handle_get_start(
             view.clone(),
             MsgPack {
                 serialize_part: GetStartReq {
                     key,
                     prepared_target,
+                    external_sink_target,
                 },
                 raw_bytes: Vec::new(),
             },
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index 3939fb2..9f927d9 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -431,8 +431,10 @@ pub struct InflightGetInfo {
     pub req_node_id: NodeID,
     pub len: u64,
     pub target: InflightGetTarget,
-    /// Exact requester registration generation that owns `target`.
-    pub target_tomb_tag: NodeTombTag,
+    /// Exact requester segment-registration generation that owns an
+    /// allocator-backed target. External sinks are caller-owned and instead
+    /// carry their membership generation inside `InflightGetTarget`.
+    pub target_tomb_tag: Option<NodeTombTag>,
     pub route: Arc<OneKvNodesRoutes>,
     pub allocation_mode: GetAllocationMode,
     pub durable_reservation: Option<Arc<GetDurableSlotReservation>>,
@@ -453,6 +455,7 @@ pub struct CompletedGetInfo {
 pub enum InflightGetTarget {
     Allocation(Arc<Allocation>),
     PreparedLocalReserveSlot(CommittedSlotReplica),
+    ExternalSink(crate::master_kv_router::msg_pack::GetExternalSinkTarget),
 }
 
 impl InflightGetTarget {
@@ -460,6 +463,7 @@ impl InflightGetTarget {
         match self {
             Self::Allocation(allocation) => allocation.base_addr() + allocation.addr(),
             Self::PreparedLocalReserveSlot(slot) => slot.addr,
+            Self::ExternalSink(target) => target.addr,
         }
     }
 
@@ -467,6 +471,7 @@ impl InflightGetTarget {
         match self {
             Self::Allocation(allocation) => allocation.base_addr(),
             Self::PreparedLocalReserveSlot(slot) => slot.base_addr,
+            Self::ExternalSink(target) => target.addr,
         }
     }
 
@@ -474,6 +479,7 @@ impl InflightGetTarget {
         match self {
             Self::Allocation(allocation) => allocation.capcity(),
             Self::PreparedLocalReserveSlot(slot) => slot.slot_size,
+            Self::ExternalSink(target) => target.capacity,
         }
     }
 }
@@ -4506,6 +4512,7 @@ impl MasterKvRouter {
             GetAllocationMode::ReuseReplica => "reuse_replica",
             GetAllocationMode::DurableReplica => "durable_replica",
             GetAllocationMode::LocalCommittedSlot => "local_committed_slot",
+            GetAllocationMode::ExternalSink => "external_sink",
         };
         let mode_count = self
             .inner()
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index 7ba3eb0..d21e39d 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -18,6 +18,9 @@ pub enum GetAllocationMode {
     ReuseReplica = 1,
     DurableReplica = 2,
     LocalCommittedSlot = 3,
+    /// Caller-owned memory used only as the terminal data sink. The master
+    /// neither allocates it nor publishes it as a cache route on GetDone.
+    ExternalSink = 4,
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
@@ -29,10 +32,24 @@ pub struct GetPreparedLocalReserveTarget {
     pub base_addr: u64,
 }
 
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct GetExternalSinkTarget {
+    /// Exact destination address in the requester's registered memory.
+    pub addr: u64,
+    /// Caller-validated writable bytes starting at `addr`.
+    pub capacity: u64,
+    /// Opaque requester-side registration generation, retained for identity
+    /// and observability. The requester remains authoritative for MR lifetime.
+    pub registration_id: u64,
+    /// Requester membership generation captured with the GPU registration.
+    pub requester_node_start_time: i64,
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct GetStartReq {
     pub key: String,
     pub prepared_target: Option<GetPreparedLocalReserveTarget>,
+    pub external_sink_target: Option<GetExternalSinkTarget>,
 }
 impl MsgPackSerializePart for GetStartReq {
     fn msg_id(&self) -> u32 {
@@ -124,6 +141,9 @@ pub struct BatchGetStartReq {
     /// Empty selects ordinary master allocations. Otherwise this must contain
     /// exactly one entry per key.
     pub prepared_targets: Vec<Option<GetPreparedLocalReserveTarget>>,
+    /// Empty selects no external sinks. Otherwise this must contain exactly
+    /// one entry per key and is mutually exclusive with prepared targets.
+    pub external_sink_targets: Vec<Option<GetExternalSinkTarget>>,
 }
 impl MsgPackSerializePart for BatchGetStartReq {
     fn msg_id(&self) -> u32 {
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index be1a652..d849e62 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -25,6 +25,7 @@ use fluxon_kv::client_kv_api::{
     ClientKvApiInner, OwnerLocalPublishItem, OwnerLocalPublishJob, OwnerLocalReserveSlotLease,
 };
 use fluxon_kv::client_seg_pool::ClientSegPoolViewTrait;
+use fluxon_kv::client_transfer_engine::ClientTransferEngineAccessTrait;
 use fluxon_kv::cluster_manager::ClusterManagerViewTrait;
 use fluxon_kv::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use fluxon_kv::config::{ClientConfigYaml, MasterConfigYaml};
@@ -4770,6 +4771,263 @@ impl KvClient {
         cancel_get_transfer_inner(self, handle, py).into_py_object(py)
     }
 
+    /// Start background RDMA pulls directly into caller-owned GPU destinations.
+    #[pyo3(signature = (keys, destinations, prefix_best_effort=true, atomic_group_lens=None, concurrency=None))]
+    fn get_start_gpu(
+        &self,
+        keys: Vec<String>,
+        destinations: Vec<(u64, u64, u64)>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+        concurrency: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        fn get_start_gpu_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            destinations: Vec<(u64, u64, u64)>,
+            prefix_best_effort: bool,
+            atomic_group_lens: Option<Vec<usize>>,
+            concurrency: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_start_gpu requires at least one key",
+                ));
+            }
+            if keys.len() != destinations.len() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_start_gpu requires one destination per key",
+                ));
+            }
+            let batch_concurrency = match concurrency.unwrap_or(DEFAULT_PYO3_BATCH_CONCURRENCY) {
+                0 => {
+                    return ApiResult::new_error(new_invalid_argument_error(
+                        py,
+                        "get_start_gpu concurrency must be > 0",
+                    ));
+                }
+                value => value,
+            };
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(value) => value,
+                Err(err) => return ApiResult::new_error(err),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_start_gpu is supported only in external-client mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(value) => value,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let destinations = destinations
+                .into_iter()
+                .map(|(registration_id, addr, capacity)| {
+                    fluxon_kv::external_client_api::ExternalGpuDestination {
+                        registration_id,
+                        addr,
+                        capacity,
+                    }
+                })
+                .collect();
+            let framework_for_start = framework.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_start
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .get_start_gpu(
+                            keys,
+                            destinations,
+                            prefix_best_effort,
+                            atomic_group_lens,
+                            batch_concurrency,
+                        )
+                        .await
+                })
+            }) {
+                Ok(value) => value,
+                Err(err) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {err}"),
+                    ));
+                }
+            };
+            match result {
+                Ok(started) => {
+                    let out = PyDict::new_bound(py);
+                    out.set_item("handle", started.handle).expect("set handle");
+                    out.set_item("raw_prefix_hit_len", started.raw_prefix_hit_len as u64)
+                        .expect("set raw_prefix_hit_len");
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "get_start_gpu failed",
+                )),
+            }
+        }
+
+        get_start_gpu_inner(
+            self,
+            keys,
+            destinations,
+            prefix_best_effort,
+            atomic_group_lens,
+            concurrency,
+            py,
+        )
+        .into_py_object(py)
+    }
+
+    /// Wait for a GPU Get terminal and consume an atomic prefix.
+    #[pyo3(signature = (handle, consume_prefix_len=None))]
+    fn get_transfer_gpu(
+        &self,
+        handle: u64,
+        consume_prefix_len: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        fn get_transfer_gpu_inner(
+            client: &KvClient,
+            handle: u64,
+            consume_prefix_len: Option<usize>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(value) => value,
+                Err(err) => return ApiResult::new_error(err),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_transfer_gpu is supported only in external-client mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(value) => value,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework_for_transfer = framework.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_transfer
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .get_transfer_gpu(handle, consume_prefix_len)
+                        .await
+                })
+            }) {
+                Ok(value) => value,
+                Err(err) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {err}"),
+                    ));
+                }
+            };
+            match result {
+                Ok(terminal) => {
+                    let out = PyDict::new_bound(py);
+                    out.set_item(
+                        "transferred_prefix_len",
+                        terminal.transferred_prefix_len as u64,
+                    )
+                    .expect("set transferred_prefix_len");
+                    out.set_item("consumed_prefix_len", terminal.consumed_prefix_len as u64)
+                        .expect("set consumed_prefix_len");
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "get_transfer_gpu failed",
+                )),
+            }
+        }
+
+        get_transfer_gpu_inner(self, handle, consume_prefix_len, py).into_py_object(py)
+    }
+
+    /// Cancel a live GPU Get handle and wait until master cleanup is terminal.
+    #[pyo3(signature = (handle))]
+    fn cancel_get_transfer_gpu(&self, handle: u64, py: Python) -> PyObject {
+        fn cancel_get_transfer_gpu_inner(
+            client: &KvClient,
+            handle: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(value) => value,
+                Err(err) => return ApiResult::new_error(err),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "cancel_get_transfer_gpu is supported only in external-client mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(value) => value,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework_for_cancel = framework.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_cancel
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .cancel_get_transfer_gpu(handle)
+                        .await
+                })
+            }) {
+                Ok(value) => value,
+                Err(err) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {err}"),
+                    ));
+                }
+            };
+            match result {
+                Ok(()) => ApiResult::new_success(0i32.into_py(py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "cancel_get_transfer_gpu failed",
+                )),
+            }
+        }
+
+        cancel_get_transfer_gpu_inner(self, handle, py).into_py_object(py)
+    }
+
     /// Allocate a fluxon-kv lease id synchronously.
     /// Always allocate a new lease id (no reuse by requested id).
     /// Allocate with the provided TTL seconds (must be >= MIN_CLIENT_TTL_SECONDS).
@@ -5371,6 +5629,176 @@ impl KvClient {
         .into_py_object(py)
     }
 
+    /// Register one caller-owned GPU staging range with the transfer engine.
+    #[pyo3(signature = (ptr, len, device_id))]
+    fn register_gpu_buffer(&self, ptr: u64, len: u64, device_id: u32, py: Python) -> PyObject {
+        fn register_gpu_buffer_inner(
+            client: &KvClient,
+            ptr: u64,
+            len: u64,
+            device_id: u32,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "register_gpu_buffer is supported only in external-client mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework_for_register = framework.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_register
+                        .client_seg_pool_view()
+                        .client_transfer_engine()
+                        .register_gpu_memory(ptr, len, device_id)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match result {
+                Ok(registration) => {
+                    let out = PyDict::new_bound(py);
+                    out.set_item("registration_id", registration.registration_id)
+                        .expect("set registration_id");
+                    out.set_item("ptr", registration.addr).expect("set ptr");
+                    out.set_item("len", registration.len).expect("set len");
+                    out.set_item("device_id", registration.device_id)
+                        .expect("set device_id");
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "register_gpu_buffer failed",
+                )),
+            }
+        }
+
+        register_gpu_buffer_inner(self, ptr, len, device_id, py).into_py_object(py)
+    }
+
+    /// Unregister a GPU staging range after every destination guard is released.
+    #[pyo3(signature = (registration_id))]
+    fn unregister_gpu_buffer(&self, registration_id: u64, py: Python) -> PyObject {
+        fn unregister_gpu_buffer_inner(
+            client: &KvClient,
+            registration_id: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "unregister_gpu_buffer is supported only in external-client mode",
+                ));
+            }
+            let runtime = match client.runtime.as_ref() {
+                Some(v) => v,
+                None => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        "Client runtime is missing",
+                    ));
+                }
+            };
+            let framework_for_unregister = framework.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_unregister
+                        .client_seg_pool_view()
+                        .client_transfer_engine()
+                        .unregister_gpu_memory(registration_id)
+                        .await
+                })
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {}", e),
+                    ));
+                }
+            };
+            match result {
+                Ok(()) => ApiResult::new_success(0i32.into_py(py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "unregister_gpu_buffer failed",
+                )),
+            }
+        }
+
+        unregister_gpu_buffer_inner(self, registration_id, py).into_py_object(py)
+    }
+
+    /// Validate one destination against the exact GPU registration generation.
+    #[pyo3(signature = (registration_id, ptr, capacity))]
+    fn validate_gpu_destination(
+        &self,
+        registration_id: u64,
+        ptr: u64,
+        capacity: u64,
+        py: Python,
+    ) -> PyObject {
+        fn validate_gpu_destination_inner(
+            client: &KvClient,
+            registration_id: u64,
+            ptr: u64,
+            capacity: u64,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(v) => v,
+                Err(e) => return ApiResult::new_error(e),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "validate_gpu_destination is supported only in external-client mode",
+                ));
+            }
+            match framework
+                .client_seg_pool_view()
+                .client_transfer_engine()
+                .validate_gpu_destination(registration_id, ptr, capacity)
+            {
+                Ok(_guard) => ApiResult::new_success(0i32.into_py(py)),
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "validate_gpu_destination failed",
+                )),
+            }
+        }
+
+        validate_gpu_destination_inner(self, registration_id, ptr, capacity, py).into_py_object(py)
+    }
+
     /// Register a caller-owned host buffer range used by batch zero-copy paths.
     #[pyo3(signature = (ptr, len))]
     fn register_buffer(&self, ptr: u64, len: u64, py: Python) -> PyObject {
diff --git a/setup_and_pack/nix/pack_fluxonkv_pylib.py b/setup_and_pack/nix/pack_fluxonkv_pylib.py
index e12f8fe..cb0af6d 100644
--- a/setup_and_pack/nix/pack_fluxonkv_pylib.py
+++ b/setup_and_pack/nix/pack_fluxonkv_pylib.py
@@ -198,6 +198,11 @@ def _cleanup_temp_workspace_mount_dirs() -> None:
     "libstdc++.so.6",
     "libgomp.so.1",
 )
+EXTERNAL_DRIVER_RUNTIME_LIBRARY_NAMES = (
+    # libcuda is supplied by the NVIDIA kernel-driver installation on the target GPU node.
+    # Packaging the build-time stub would make the wheel non-functional at runtime.
+    "libcuda.so.1",
+)
 
 def _dedupe_relative_paths(relative_paths: tuple[str, ...]) -> tuple[str, ...]:
     ordered_relative_paths: list[str] = []
@@ -2273,6 +2278,10 @@ def _is_core_system_runtime_lib(lib_name: str) -> bool:
     return any(lib_name.startswith(prefix) for prefix in CORE_SYSTEM_RUNTIME_LIB_PREFIXES)
 
 
+def _is_external_driver_runtime_lib(lib_name: str) -> bool:
+    return lib_name in EXTERNAL_DRIVER_RUNTIME_LIBRARY_NAMES
+
+
 def _read_runtime_dependency_entries(
     path: Path,
     *,
@@ -2314,6 +2323,12 @@ def _read_runtime_dependency_entries(
         if "=>" in line:
             needed_name, raw_target = (part.strip() for part in line.split("=>", 1))
             if raw_target == "not found":
+                if _is_external_driver_runtime_lib(needed_name):
+                    print(
+                        "wheel finalize: leaving target-driver dependency external: "
+                        f"{path} -> {needed_name}"
+                    )
+                    continue
                 raise RuntimeError(f"runtime dependency not found for {path}: {needed_name}")
             dep_path_str = raw_target.split(" ", 1)[0].strip()
         else:
diff --git a/setup_and_pack/tests/test_vendor_runtime_layout.py b/setup_and_pack/tests/test_vendor_runtime_layout.py
index 48f87be..52eac3d 100644
--- a/setup_and_pack/tests/test_vendor_runtime_layout.py
+++ b/setup_and_pack/tests/test_vendor_runtime_layout.py
@@ -33,6 +33,15 @@ def _load_module(module_path: Path, module_name: str):
 
 
 class VendorRuntimeLayoutTest(unittest.TestCase):
+    def test_cuda_driver_is_external_but_cuda_runtime_is_packaged(self) -> None:
+        for module_path in PACKER_MODULE_PATHS:
+            mod = _load_module(
+                module_path=module_path,
+                module_name=f"vendor_runtime_cuda_external_{module_path.stem}",
+            )
+            self.assertTrue(mod._is_external_driver_runtime_lib("libcuda.so.1"))
+            self.assertFalse(mod._is_external_driver_runtime_lib("libcudart.so.12"))
+
     def test_ensure_vendor_runtime_soname_aliases_materializes_missing_alias_files(self) -> None:
         with tempfile.TemporaryDirectory() as tmpdir:
             root = Path(tmpdir)

From 0bc5524f5fc2551a712638375c6d02911524d836 Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Fri, 24 Jul 2026 19:04:31 +0800
Subject: [PATCH 09/10] backup gdr

---
 fluxon_py/kvclient/fluxon.py                  |  294 ++-
 .../src/client_kv_api/external_api.rs         |  454 +++-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |   57 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  |  196 +-
 .../fluxon_kv/src/client_kv_api/msg_pack.rs   |  164 +-
 .../fluxon_kv/src/external_client_api/mod.rs  | 2229 +++++++++++++++--
 .../fluxon_kv/src/master_kv_router/get.rs     |  696 ++++-
 .../fluxon_kv/src/master_kv_router/mod.rs     |  167 +-
 .../src/master_kv_router/msg_pack.rs          |  137 +
 .../rpcresp_kvresult_convert/msg_and_error.rs |    7 +
 .../fluxon_pyo3/src/fixed_slab_allocator.rs   |   52 +
 fluxon_rs/fluxon_pyo3/src/lib.rs              |  275 ++
 .../fluxon_util/src/fixed_slab_allocator.rs   |  245 ++
 fluxon_rs/fluxon_util/src/lib.rs              |    1 +
 14 files changed, 4741 insertions(+), 233 deletions(-)
 create mode 100644 fluxon_rs/fluxon_pyo3/src/fixed_slab_allocator.rs
 create mode 100644 fluxon_rs/fluxon_util/src/fixed_slab_allocator.rs

diff --git a/fluxon_py/kvclient/fluxon.py b/fluxon_py/kvclient/fluxon.py
index 1602e88..25f3776 100644
--- a/fluxon_py/kvclient/fluxon.py
+++ b/fluxon_py/kvclient/fluxon.py
@@ -293,6 +293,25 @@ class GpuGetStartHandle:
     created_at_ns: int
     backend_token: int
     backend_handle: int
+    remote_indices: Tuple[int, ...]
+    closed: bool = False
+    transfer_wall_us: Optional[int] = None
+    finish_wait_us: Optional[int] = None
+    terminal_before_consume: Optional[bool] = None
+    terminal_to_consume_us: Optional[int] = None
+
+
+@dataclass
+class GetPlanHandle:
+    """Target-free Get plan that must be executed once or cancelled."""
+
+    keys: Tuple[str, ...]
+    result: GetStartResult
+    gpu_result: GetStartResult
+    created_at_ns: int
+    backend_token: int
+    backend_handle: int
+    gpu_remote_indices: Tuple[int, ...]
     closed: bool = False
 
 
@@ -376,6 +395,34 @@ def _build_get_start_result_from_backend_payload(
     )
 
 
+def _narrow_get_start_result(result: GetStartResult, consume_prefix_len: int) -> GetStartResult:
+    group_lens = result.atomic_group_lens or (len(result.keys),)
+    selected_groups: List[int] = []
+    cursor = 0
+    for group_len in group_lens:
+        if cursor + group_len > consume_prefix_len:
+            break
+        selected_groups.append(int(group_len))
+        cursor += int(group_len)
+    if cursor != consume_prefix_len:
+        raise ValueError(
+            "consume_prefix_len must end at an atomic-group boundary: "
+            f"consume={consume_prefix_len} groups={group_lens}"
+        )
+    keys = result.keys[:consume_prefix_len]
+    return GetStartResult(
+        keys=keys,
+        raw_prefix_hit_len=consume_prefix_len,
+        transferable_len=consume_prefix_len,
+        prefix_hit_groups=len(selected_groups),
+        atomic_group_lens=tuple(selected_groups),
+        prefix_best_effort=result.prefix_best_effort,
+        first_miss_index=None,
+        first_miss_group_index=None,
+        all_hit=True,
+    )
+
+
 def _error_to_ret_code(err: ApiError) -> int:
     if hasattr(err, "code") and callable(err.code):
         try:
@@ -1935,6 +1982,218 @@ def get_start(
             backend_handle=backend_handle,
         )
 
+    def get_plan(
+        self,
+        keys: List[str],
+        prefix_best_effort: bool = True,
+        atomic_group_lens: Optional[List[int]] = None,
+    ) -> GetPlanHandle:
+        if self._client is None:
+            raise RuntimeError("Store not initialized when get_plan(). Call setup() first.")
+        if not keys:
+            raise ValueError("get_plan requires at least one key")
+        normalized_group_lens: Optional[List[int]] = None
+        if atomic_group_lens is not None:
+            normalized_group_lens = [int(length) for length in atomic_group_lens]
+            if any(length <= 0 for length in normalized_group_lens):
+                raise ValueError("get_plan atomic_group_lens entries must be > 0")
+            if sum(normalized_group_lens) != len(keys):
+                raise ValueError(
+                    "get_plan atomic_group_lens must sum to keys length: "
+                    f"sum={sum(normalized_group_lens)} keys={len(keys)}"
+                )
+        started_at_ns = time.monotonic_ns()
+        inner_res = self._client.get_plan(
+            list(keys),
+            bool(prefix_best_effort),
+            normalized_group_lens,
+        )
+        if not inner_res.is_ok():
+            raise RuntimeError(f"get_plan backend error: {inner_res.unwrap_error()}")
+        payload = inner_res.unwrap()
+        if not isinstance(payload, dict):
+            raise RuntimeError(f"get_plan returned non-dict payload: {type(payload)}")
+        backend_handle = int(payload["handle"])
+        try:
+            result = _build_get_start_result_from_backend_payload(
+                payload,
+                list(keys),
+                bool(prefix_best_effort),
+                normalized_group_lens,
+            )
+            gpu_payload = dict(payload)
+            gpu_payload["raw_prefix_hit_len"] = payload["gpu_raw_prefix_hit_len"]
+            gpu_result = _build_get_start_result_from_backend_payload(
+                gpu_payload,
+                list(keys),
+                bool(prefix_best_effort),
+                normalized_group_lens,
+            )
+            gpu_remote_indices = tuple(int(index) for index in payload["gpu_remote_indices"])
+            if (
+                tuple(sorted(set(gpu_remote_indices))) != gpu_remote_indices
+                or any(
+                    index < 0 or index >= gpu_result.transferable_len
+                    for index in gpu_remote_indices
+                )
+            ):
+                raise RuntimeError(
+                    "get_plan returned invalid gpu_remote_indices: "
+                    f"indices={gpu_remote_indices} "
+                    f"transferable={gpu_result.transferable_len}"
+                )
+        except Exception:
+            cancel_res = self._client.cancel_get_plan(backend_handle)
+            if not cancel_res.is_ok():
+                logging.exception(
+                    "get_plan payload validation failed and cleanup also failed: %s",
+                    cancel_res.unwrap_error(),
+                )
+            else:
+                _ = cancel_res.unwrap()
+            raise
+        return GetPlanHandle(
+            keys=tuple(keys),
+            result=result,
+            gpu_result=gpu_result,
+            created_at_ns=started_at_ns,
+            backend_token=id(self),
+            backend_handle=backend_handle,
+            gpu_remote_indices=gpu_remote_indices,
+        )
+
+    def cancel_get_plan(self, handle: GetPlanHandle) -> None:
+        if not isinstance(handle, GetPlanHandle):
+            raise TypeError(f"cancel_get_plan requires GetPlanHandle, got {type(handle)}")
+        if handle.backend_token != id(self):
+            raise RuntimeError("cancel_get_plan handle belongs to a different store")
+        if handle.closed:
+            return
+        if self._client is None:
+            raise RuntimeError("Store not initialized when cancel_get_plan().")
+        inner_res = self._client.cancel_get_plan(handle.backend_handle)
+        if not inner_res.is_ok():
+            raise RuntimeError(f"cancel_get_plan backend error: {inner_res.unwrap_error()}")
+        _ = inner_res.unwrap()
+        handle.closed = True
+
+    def execute_get_plan_cpu(
+        self,
+        handle: GetPlanHandle,
+        *,
+        consume_prefix_len: int,
+        concurrency: Optional[int] = None,
+    ) -> GetStartHandle:
+        if not isinstance(handle, GetPlanHandle):
+            raise TypeError(
+                f"execute_get_plan_cpu requires GetPlanHandle, got {type(handle)}"
+            )
+        if handle.backend_token != id(self) or handle.closed:
+            raise RuntimeError("execute_get_plan_cpu requires a live plan from this store")
+        narrowed = _narrow_get_start_result(handle.result, int(consume_prefix_len))
+        if consume_prefix_len <= 0 or consume_prefix_len > handle.result.transferable_len:
+            raise ValueError(
+                "execute_get_plan_cpu consume prefix is outside the CPU plan: "
+                f"consume={consume_prefix_len} transferable={handle.result.transferable_len}"
+            )
+        if self._client is None:
+            raise RuntimeError("Store not initialized when execute_get_plan_cpu().")
+        inner_res = self._client.execute_get_plan_cpu(
+            handle.backend_handle,
+            int(consume_prefix_len),
+            self._batch_concurrency if concurrency is None else int(concurrency),
+        )
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"execute_get_plan_cpu backend error: {inner_res.unwrap_error()}"
+            )
+        _ = inner_res.unwrap()
+        handle.closed = True
+        return GetStartHandle(
+            keys=narrowed.keys,
+            result=narrowed,
+            created_at_ns=handle.created_at_ns,
+            backend_token=id(self),
+            backend_handle=handle.backend_handle,
+        )
+
+    def execute_get_plan_gpu(
+        self,
+        handle: GetPlanHandle,
+        destinations: List[GpuDestination],
+        *,
+        consume_prefix_len: int,
+        concurrency: Optional[int] = None,
+    ) -> GpuGetStartHandle:
+        if not isinstance(handle, GetPlanHandle):
+            raise TypeError(
+                f"execute_get_plan_gpu requires GetPlanHandle, got {type(handle)}"
+            )
+        if handle.backend_token != id(self) or handle.closed:
+            raise RuntimeError("execute_get_plan_gpu requires a live plan from this store")
+        remote_indices = tuple(
+            index for index in handle.gpu_remote_indices if index < consume_prefix_len
+        )
+        if not remote_indices:
+            raise ValueError("execute_get_plan_gpu requires at least one remote source")
+        if len(destinations) != len(remote_indices):
+            raise ValueError(
+                "execute_get_plan_gpu requires one exact destination per remote source: "
+                f"destinations={len(destinations)} remote={len(remote_indices)} "
+                f"consume={consume_prefix_len}"
+            )
+        narrowed = _narrow_get_start_result(handle.gpu_result, int(consume_prefix_len))
+        if consume_prefix_len <= 0 or consume_prefix_len > handle.gpu_result.transferable_len:
+            raise ValueError(
+                "execute_get_plan_gpu consume prefix is outside the GPU plan: "
+                f"consume={consume_prefix_len} transferable={handle.gpu_result.transferable_len}"
+            )
+        active_registration = self._gpu_buffer_registration
+        if active_registration is None:
+            raise RuntimeError("execute_get_plan_gpu requires an active GPU registration")
+        for index, destination in enumerate(destinations):
+            if not isinstance(destination, GpuDestination):
+                raise TypeError(
+                    "execute_get_plan_gpu destinations must be GpuDestination: "
+                    f"index={index} got={type(destination)}"
+                )
+            if destination.registration_id != active_registration.registration_id:
+                raise ValueError(
+                    "execute_get_plan_gpu destination uses a stale registration: "
+                    f"index={index}"
+                )
+            if destination.ptr < active_registration.ptr or destination.end > active_registration.end:
+                raise ValueError(
+                    "execute_get_plan_gpu destination is outside the active registration: "
+                    f"index={index}"
+                )
+        if self._client is None:
+            raise RuntimeError("Store not initialized when execute_get_plan_gpu().")
+        inner_res = self._client.execute_get_plan_gpu(
+            handle.backend_handle,
+            [
+                (destination.registration_id, destination.ptr, destination.capacity)
+                for destination in destinations
+            ],
+            int(consume_prefix_len),
+            self._batch_concurrency if concurrency is None else int(concurrency),
+        )
+        if not inner_res.is_ok():
+            raise RuntimeError(
+                f"execute_get_plan_gpu backend error: {inner_res.unwrap_error()}"
+            )
+        _ = inner_res.unwrap()
+        handle.closed = True
+        return GpuGetStartHandle(
+            keys=narrowed.keys,
+            destinations=tuple(destinations),
+            result=narrowed,
+            created_at_ns=handle.created_at_ns,
+            backend_token=id(self),
+            backend_handle=handle.backend_handle,
+            remote_indices=remote_indices,
+        )
+
     def cancel_get_transfer(self, handle: GetStartHandle) -> None:
         if not isinstance(handle, GetStartHandle):
             raise TypeError(f"cancel_get_transfer requires GetStartHandle, got {type(handle)}")
@@ -2121,6 +2380,8 @@ def get_start_gpu(
                     "get_start_gpu payload validation failed and cleanup also failed: %s",
                     cancel_res.unwrap_error(),
                 )
+            else:
+                _ = cancel_res.unwrap()
             raise
         return GpuGetStartHandle(
             keys=tuple(keys),
@@ -2129,6 +2390,7 @@ def get_start_gpu(
             created_at_ns=started_at_ns,
             backend_token=id(self),
             backend_handle=backend_handle,
+            remote_indices=tuple(range(result.transferable_len)),
         )
 
     def cancel_get_transfer_gpu(self, handle: GpuGetStartHandle) -> None:
@@ -2152,14 +2414,15 @@ def cancel_get_transfer_gpu(self, handle: GpuGetStartHandle) -> None:
             raise RuntimeError(
                 f"cancel_get_transfer_gpu backend error: {inner_res.unwrap_error()}"
             )
+        _ = inner_res.unwrap()
 
     def get_transfer_gpu(
         self,
         handle: GpuGetStartHandle,
         *,
         consume_prefix_len: Optional[int] = None,
-    ) -> None:
-        """Wait for the GPU transfer terminal; destinations already contain the bytes."""
+    ) -> int:
+        """Wait for GPU transfer and return one ordered CPU/GPU source plan."""
         if not isinstance(handle, GpuGetStartHandle):
             raise TypeError(
                 f"get_transfer_gpu requires GpuGetStartHandle, got {type(handle)}"
@@ -2227,6 +2490,33 @@ def get_transfer_gpu(
                 f"transferred={transferred_prefix_len}/{result.transferable_len} "
                 f"consumed={consumed_prefix_len}/{normalized_consume_prefix_len}"
             )
+        transfer_wall_us = payload["transfer_wall_us"]
+        finish_wait_us = payload["finish_wait_us"]
+        terminal_before_consume = payload["terminal_before_consume"]
+        terminal_to_consume_us = payload["terminal_to_consume_us"]
+        for field_name, value in (
+            ("transfer_wall_us", transfer_wall_us),
+            ("finish_wait_us", finish_wait_us),
+            ("terminal_to_consume_us", terminal_to_consume_us),
+        ):
+            if type(value) is not int or value < 0:
+                raise RuntimeError(
+                    "get_transfer_gpu returned invalid timing: "
+                    f"{field_name}={value!r}"
+                )
+        if type(terminal_before_consume) is not bool:
+            raise RuntimeError(
+                "get_transfer_gpu returned invalid terminal_before_consume: "
+                f"{terminal_before_consume!r}"
+            )
+        handle.transfer_wall_us = transfer_wall_us
+        handle.finish_wait_us = finish_wait_us
+        handle.terminal_before_consume = terminal_before_consume
+        handle.terminal_to_consume_us = terminal_to_consume_us
+        plan_ptr = int(payload["plan_ptr"])
+        if plan_ptr <= 0:
+            raise RuntimeError(f"get_transfer_gpu returned invalid plan_ptr: {plan_ptr}")
+        return plan_ptr
 
     def get_etcd_config(self) -> List[str]:
         if self._client is None:
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index 22b4882..e6f3caa 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -2,17 +2,18 @@ use crate::client_kv_api::ClientKvApi;
 use crate::client_kv_api::get::{StartedGetRevokeCleanup, finish_started_get_revoke_cleanup};
 use crate::client_kv_api::msg_pack::{
     ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetCancelResp,
-    ExternalBatchGetItemResp, ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq,
-    ExternalBatchGetStartResp, ExternalBatchGetStartTransferPlan, ExternalBatchGetTransferReq,
-    ExternalBatchGetTransferResp, ExternalBatchIsExistReq, ExternalBatchIsExistResp,
-    ExternalBatchPutCommitItemResp, ExternalBatchPutCommitReq, ExternalBatchPutCommitResp,
-    ExternalBatchPutStartItemResp, ExternalBatchPutStartReq, ExternalBatchPutStartResp,
-    ExternalBatchPutTransferEndItemResp, ExternalBatchPutTransferEndReq,
-    ExternalBatchPutTransferEndResp, ExternalDeleteReq, ExternalDeleteResp, ExternalGetReq,
-    ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp, ExternalObservabilitySnapshotReq,
-    ExternalObservabilitySnapshotResp, ExternalPutCommitReq, ExternalPutCommitResp,
-    ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq, ExternalPutStartResp,
-    ExternalPutTransferEndReq, ExternalPutTransferEndResp, TestPutPhaseTrace,
+    ExternalBatchGetItemResp, ExternalBatchGetLocalProbeReq, ExternalBatchGetLocalProbeResp,
+    ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
+    ExternalBatchGetStartTransferPlan, ExternalBatchGetTransferReq, ExternalBatchGetTransferResp,
+    ExternalBatchIsExistReq, ExternalBatchIsExistResp, ExternalBatchPutCommitItemResp,
+    ExternalBatchPutCommitReq, ExternalBatchPutCommitResp, ExternalBatchPutStartItemResp,
+    ExternalBatchPutStartReq, ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemResp,
+    ExternalBatchPutTransferEndReq, ExternalBatchPutTransferEndResp, ExternalDeleteReq,
+    ExternalDeleteResp, ExternalExecutePlannedGetReq, ExternalExecutePlannedGetResp,
+    ExternalGetReq, ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp,
+    ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp, ExternalPutCommitReq,
+    ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq,
+    ExternalPutStartResp, ExternalPutTransferEndReq, ExternalPutTransferEndResp, TestPutPhaseTrace,
 };
 use crate::client_kv_api::{
     self, ExternalGetKeyInterest, ExternalGetKeySharedOp, ExternalGetKeySharedPhase,
@@ -838,6 +839,84 @@ async fn batch_get_start_with_local_reserve_targets(
     Ok(response)
 }
 
+async fn batch_get_bind_with_local_reserve_targets(
+    inner: &client_kv_api::ClientKvApiInner,
+    get_ids: &[u64],
+) -> KvResult<Vec<BatchGetStartItemResp>> {
+    if get_ids.is_empty() {
+        return Ok(Vec::new());
+    }
+    let Some(value_len) = inner
+        .test_spec_config
+        .owner_local_reserve_expected_capacity
+        .as_ref()
+        .map(|expected| expected.value_len)
+    else {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: "planned external Get requires owner-local reserve capacity".to_string(),
+        }));
+    };
+    let lease = inner
+        .owner_claim_local_reserve_slot_lease(value_len, get_ids.len())
+        .await?;
+    let mut claim_guard = PreparedGetSlotClaimGuard::new(inner.view.clone_view(), lease);
+    let prepared_targets = claim_guard
+        .lease()
+        .slots
+        .iter()
+        .map(|slot| prepared_target_from_slot(claim_guard.lease().slot_size, slot))
+        .collect::<Vec<_>>();
+    let response = match inner
+        .batch_get_bind_prepared_targets(get_ids.to_vec(), prepared_targets.clone())
+        .await
+    {
+        Ok(response) => {
+            claim_guard.mark_start_response_received();
+            response
+        }
+        Err(err) => return Err(err),
+    };
+    if response.items.len() != get_ids.len() {
+        let started = claim_guard.handoff_started(&response.items);
+        finish_started_get_revoke_cleanup(inner, started, "BatchGetBind length mismatch").await;
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "planned BatchGetBind response length mismatch: expected={} got={}",
+                get_ids.len(),
+                response.items.len()
+            ),
+        }));
+    }
+    let identities_match = response
+        .items
+        .iter()
+        .zip(get_ids)
+        .all(|(item, get_id)| item.get_id == *get_id);
+    let targets_match =
+        response
+            .items
+            .iter()
+            .zip(prepared_targets.iter())
+            .all(|(item, expected)| {
+                item.error_code != OK || item.prepared_target.as_ref() == Some(expected)
+            });
+    if !identities_match || !targets_match {
+        let started = claim_guard.handoff_started(&response.items);
+        finish_started_get_revoke_cleanup(inner, started, "BatchGetBind identity/target mismatch")
+            .await;
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: "master did not replay the exact planned Get identity and prepared target"
+                .to_string(),
+        }));
+    }
+    for (item, target) in response.items.iter().zip(prepared_targets.iter()) {
+        if item.error_code == OK {
+            claim_guard.disarm_accepted(target);
+        }
+    }
+    Ok(response.items)
+}
+
 #[cfg(test)]
 mod external_put_pending_tests {
     use super::{ExternalPutStartFenceClaim, require_external_pending_put_ctx_value};
@@ -2626,6 +2705,10 @@ pub trait HandlerForExternalClient {
     fn validate_requester_owner_status_updated(&self, started_time: i64) -> KvResult<()>;
     async fn external_get(&self, req: ExternalGetReq) -> KvResult<ExternalGetResp>;
     async fn external_batch_get(&self, req: ExternalBatchGetReq) -> KvResult<ExternalBatchGetResp>;
+    async fn external_batch_get_local_probe(
+        &self,
+        req: ExternalBatchGetLocalProbeReq,
+    ) -> KvResult<ExternalBatchGetLocalProbeResp>;
     async fn external_batch_get_start(
         &self,
         req: ExternalBatchGetStartReq,
@@ -2638,6 +2721,10 @@ pub trait HandlerForExternalClient {
         &self,
         req: ExternalBatchGetCancelReq,
     ) -> KvResult<ExternalBatchGetCancelResp>;
+    async fn external_execute_planned_get(
+        &self,
+        req: ExternalExecutePlannedGetReq,
+    ) -> KvResult<ExternalExecutePlannedGetResp>;
     async fn external_put_start(&self, req: ExternalPutStartReq) -> KvResult<ExternalPutStartResp>;
     async fn external_batch_put_start(
         &self,
@@ -2763,6 +2850,118 @@ impl HandlerForExternalClient for ClientKvApi {
         })
     }
 
+    async fn external_batch_get_local_probe(
+        &self,
+        req: ExternalBatchGetLocalProbeReq,
+    ) -> KvResult<ExternalBatchGetLocalProbeResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported(
+                "external_batch_get_local_probe",
+            ));
+        }
+        if req.keys.is_empty() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "external_batch_get_local_probe requires at least one key".to_string(),
+            }));
+        }
+        if req.plan_handle == 0 {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "external_batch_get_local_probe requires a non-zero plan_handle"
+                    .to_string(),
+            }));
+        }
+        self.validate_requester_owner_status_updated(req.started_time)?;
+        let inner = self.inner();
+        let identity = (req.req_node_id.clone(), req.started_time, req.plan_handle);
+        let operation_lock = inner
+            .external_get_local_probe_locks
+            .get_lock(identity.clone());
+        let _operation_guard = operation_lock.lock().await;
+        if let Some((completed_keys, completed)) = inner
+            .completed_external_get_local_probes
+            .get(&identity)
+            .await
+        {
+            if completed_keys != req.keys {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "external_batch_get_local_probe operation identity was reused with different keys: plan_handle={}",
+                        req.plan_handle
+                    ),
+                }));
+            }
+            return Ok(completed);
+        }
+        let mut items = Vec::with_capacity(req.keys.len());
+        let mut hot_touches = Vec::new();
+        for key in &req.keys {
+            let (item, hot_touch) = {
+                let controls = inner.owner_key_control.lock_key(key);
+                if controls
+                    .get(key)
+                    .is_some_and(|state| state.local_access_fenced())
+                {
+                    (None, None)
+                } else if let Some(memory_info) = inner.local_visible_mem_holder_unfenced(key) {
+                    let hot_touch = inner.get_cached_info.get(key).and_then(|cached| {
+                        Arc::ptr_eq(&cached.mem_holder, &memory_info).then_some((
+                            (cached.put_time_ms, cached.put_version),
+                            memory_info.clone(),
+                        ))
+                    });
+                    // Install the holder under the same per-key fence used for
+                    // local visibility. Reclaim cannot slip between the probe
+                    // decision and the pin that owns this exact backing.
+                    let info = inner.install_external_get_holding(&req.req_node_id, memory_info);
+                    (Some(info), hot_touch)
+                } else {
+                    (None, None)
+                }
+            };
+            if let Some((put_id, memory_info)) = hot_touch {
+                hot_touches.push((key.clone(), put_id, memory_info));
+            }
+            items.push(item);
+        }
+        for (key, put_id, memory_info) in hot_touches {
+            inner.owner_hot_touch_or_promote(&key, put_id, &memory_info);
+        }
+        let local_items = items.iter().filter(|item| item.is_some()).count();
+        let remote_items = items.len().saturating_sub(local_items);
+        inner
+            .planned_get_counters
+            .local_probe_batches
+            .fetch_add(1, Ordering::Relaxed);
+        inner
+            .planned_get_counters
+            .local_probe_items
+            .fetch_add(items.len() as u64, Ordering::Relaxed);
+        inner
+            .planned_get_counters
+            .local_probe_local_items
+            .fetch_add(local_items as u64, Ordering::Relaxed);
+        inner
+            .planned_get_counters
+            .local_probe_remote_items
+            .fetch_add(remote_items as u64, Ordering::Relaxed);
+        tracing::debug!(
+            requested = req.keys.len(),
+            local = local_items,
+            remote = remote_items,
+            "external Get owner-local probe"
+        );
+        let response = ExternalBatchGetLocalProbeResp {
+            items,
+            error_code: OK,
+            error_json: String::new(),
+        };
+        inner
+            .completed_external_get_local_probes
+            .insert(identity, (req.keys, response.clone()))
+            .await;
+        Ok(response)
+    }
+
     async fn external_batch_get_start(
         &self,
         req: ExternalBatchGetStartReq,
@@ -3027,6 +3226,239 @@ impl HandlerForExternalClient for ClientKvApi {
         })
     }
 
+    async fn external_execute_planned_get(
+        &self,
+        req: ExternalExecutePlannedGetReq,
+    ) -> KvResult<ExternalExecutePlannedGetResp> {
+        if self.is_side_transfer_worker() {
+            return Err(Self::side_transfer_unsupported(
+                "external_execute_planned_get",
+            ));
+        }
+        if req.items.is_empty() || req.transfer_concurrency == 0 {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "external_execute_planned_get requires non-empty items and positive concurrency: items={} concurrency={}",
+                    req.items.len(),
+                    req.transfer_concurrency
+                ),
+            }));
+        }
+        let inner = self.inner();
+        self.validate_requester_owner_status_updated(req.started_time)?;
+        let identity = (req.req_node_id.clone(), req.started_time, req.plan_handle);
+        let operation_lock = inner
+            .planned_external_get_execute_locks
+            .get_lock(identity.clone());
+        let _operation_guard = operation_lock.lock().await;
+        if let Some(completed) = inner
+            .completed_planned_external_get_executes
+            .get(&identity)
+            .await
+        {
+            return Ok(completed);
+        }
+
+        let mut requested_by_key = HashMap::with_capacity(req.items.len());
+        for item in &req.items {
+            if item.key.is_empty()
+                || requested_by_key
+                    .insert(item.key.clone(), item.get_id)
+                    .is_some()
+            {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "external_execute_planned_get requires unique non-empty keys: plan_handle={}",
+                        req.plan_handle
+                    ),
+                }));
+            }
+        }
+        let keys = req
+            .items
+            .iter()
+            .map(|item| item.key.clone())
+            .collect::<Vec<_>>();
+        let (mut owner_items, leaders) = plan_external_get_key_items(inner, &keys).await;
+        let local_items = owner_items
+            .iter()
+            .filter(|item| matches!(item, ExternalGetStartOwnerItem::Local { .. }))
+            .count();
+        let leader_items = leaders.len();
+        let follower_items = owner_items
+            .len()
+            .saturating_sub(local_items)
+            .saturating_sub(leader_items);
+        inner
+            .planned_get_counters
+            .batches
+            .fetch_add(1, Ordering::Relaxed);
+        inner
+            .planned_get_counters
+            .local_items
+            .fetch_add(local_items as u64, Ordering::Relaxed);
+        inner
+            .planned_get_counters
+            .leader_items
+            .fetch_add(leader_items as u64, Ordering::Relaxed);
+        inner
+            .planned_get_counters
+            .follower_items
+            .fetch_add(follower_items as u64, Ordering::Relaxed);
+        tracing::info!(
+            plan_handle = req.plan_handle,
+            items = owner_items.len(),
+            local_items,
+            leader_items,
+            follower_items,
+            "planned CPU Get owner classification"
+        );
+        let leader_get_ids = leaders
+            .iter()
+            .map(|leader| {
+                requested_by_key
+                    .get(&leader.key)
+                    .copied()
+                    .expect("planned leader key must come from the request")
+            })
+            .collect::<Vec<_>>();
+        let leader_id_set = leader_get_ids
+            .iter()
+            .copied()
+            .collect::<std::collections::HashSet<_>>();
+        let mut cleanup = req
+            .items
+            .iter()
+            .filter(|item| !leader_id_set.contains(&item.get_id))
+            .map(|item| StartedGetRevokeCleanup {
+                get_id: item.get_id,
+                prepared_target: None,
+            })
+            .collect::<Vec<_>>();
+
+        let bound_items =
+            match batch_get_bind_with_local_reserve_targets(inner, &leader_get_ids).await {
+                Ok(items) => items,
+                Err(err) => {
+                    for leader in &leaders {
+                        publish_external_get_key_failed(inner, leader, &err);
+                    }
+                    cleanup.extend(leader_get_ids.into_iter().map(|get_id| {
+                        StartedGetRevokeCleanup {
+                            get_id,
+                            prepared_target: None,
+                        }
+                    }));
+                    finish_started_get_revoke_cleanup(
+                        inner,
+                        cleanup,
+                        "planned external Get bind failure",
+                    )
+                    .await;
+                    let response = ExternalExecutePlannedGetResp {
+                        items: Vec::new(),
+                        error_code: err.code(),
+                        error_json: err.to_json(),
+                    };
+                    inner
+                        .completed_planned_external_get_executes
+                        .insert(identity, response.clone())
+                        .await;
+                    return Ok(response);
+                }
+            };
+        assert_eq!(leaders.len(), bound_items.len());
+        for (leader, item) in leaders.iter().zip(bound_items) {
+            if item.error_code != OK {
+                cleanup.push(StartedGetRevokeCleanup {
+                    get_id: item.get_id,
+                    prepared_target: None,
+                });
+            }
+            publish_external_get_key_started(leader, item);
+        }
+        for item in &mut owner_items {
+            decide_external_get_key_item(item, true);
+        }
+
+        // From this point on the owner has published Started for every leader,
+        // so it must retain lifecycle ownership independently of the inbound
+        // RPC future.  P2P timeout/cancellation drops the handler future; if
+        // finish lived on that future, the per-key marker would remain in
+        // Finishing forever and every replay would only become a follower.
+        // The registered owner task is process-scoped and therefore continues
+        // both transfer/Done and unused-operation cleanup after caller loss.
+        let spawn_view = inner.view.clone_view();
+        let worker_view = spawn_view.clone();
+        let finish_leaders = leaders;
+        let transfer_concurrency = req.transfer_concurrency;
+        let plan_handle = req.plan_handle;
+        spawn_view.spawn(
+            format!("planned_external_get_finish_{plan_handle}"),
+            async move {
+                let finish_view = worker_view.clone();
+                let cleanup_view = worker_view;
+                let finish = finish_external_get_key_leaders(
+                    finish_view,
+                    finish_leaders,
+                    transfer_concurrency,
+                );
+                let cleanup_future = async move {
+                    finish_started_get_revoke_cleanup(
+                        cleanup_view.client_kv_api().inner(),
+                        cleanup,
+                        "planned external Get unused operation",
+                    )
+                    .await;
+                };
+                tokio::join!(finish, cleanup_future);
+            },
+        );
+
+        let transfer_results =
+            finish_external_get_start_transfer(inner.view.clone_view(), owner_items, 0).await?;
+        if transfer_results.len() != keys.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "planned external Get result length mismatch: expected={} got={}",
+                    keys.len(),
+                    transfer_results.len()
+                ),
+            }));
+        }
+        let mut items = Vec::with_capacity(keys.len());
+        for (key, result) in keys.iter().zip(transfer_results) {
+            match result {
+                Ok(Some((holder, _))) => items.push(ExternalBatchGetItemResp {
+                    error_code: OK,
+                    error_json: String::new(),
+                    external_memholder_info: Some(
+                        inner.install_external_get_holding(&req.req_node_id, holder.memory_info()),
+                    ),
+                }),
+                Ok(None) => items.push(ExternalBatchGetItemResp {
+                    error_code: codes_api::API_KEY_NOT_FOUND,
+                    error_json: format!("Key not found: {key}"),
+                    external_memholder_info: None,
+                }),
+                Err(err) => items.push(ExternalBatchGetItemResp {
+                    external_memholder_info: None,
+                    ..ExternalBatchGetItemResp::from_error(&err)
+                }),
+            }
+        }
+        let response = ExternalExecutePlannedGetResp {
+            items,
+            error_code: OK,
+            error_json: String::new(),
+        };
+        inner
+            .completed_planned_external_get_executes
+            .insert(identity, response.clone())
+            .await;
+        Ok(response)
+    }
+
     async fn external_batch_get_cancel(
         &self,
         req: ExternalBatchGetCancelReq,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 9e1c6a9..35e2dd4 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -14,10 +14,11 @@ use crate::observe_kvope::{
 use crate::{
     cluster_manager::NodeID,
     master_kv_router::msg_pack::{
-        BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeReq, BatchGetRevokeResp,
-        BatchGetStartItemResp, BatchGetStartReq, BatchGetStartResp, BatchIsExistReq,
-        GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetMetaResp,
-        GetPreparedLocalReserveTarget, GetRevokeReq, GetStartReq, GetStartResp,
+        BatchGetBindItemReq, BatchGetBindReq, BatchGetBindResp, BatchGetDoneReq, BatchGetDoneResp,
+        BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
+        BatchGetStartResp, BatchIsExistReq, GetAllocationMode, GetBindTarget, GetDoneReq,
+        GetDoneResp, GetMetaReq, GetMetaResp, GetPreparedLocalReserveTarget, GetRevokeReq,
+        GetStartReq, GetStartResp,
     },
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::codes_api,
@@ -1486,6 +1487,54 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
+    pub(crate) async fn batch_get_bind_prepared_targets(
+        &self,
+        get_ids: Vec<u64>,
+        prepared_targets: Vec<GetPreparedLocalReserveTarget>,
+    ) -> KvResult<BatchGetBindResp> {
+        if get_ids.len() != prepared_targets.len() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "batch_get_bind_prepared_targets length mismatch: get_ids={} targets={}",
+                    get_ids.len(),
+                    prepared_targets.len()
+                ),
+            }));
+        }
+        let items = get_ids
+            .into_iter()
+            .zip(prepared_targets)
+            .map(|(get_id, target)| BatchGetBindItemReq {
+                get_id,
+                target: GetBindTarget::PreparedLocalReserve(target),
+            })
+            .collect();
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_get_bind
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: BatchGetBindReq { items },
+                    raw_bytes: Vec::new(),
+                },
+                None,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
     /// 撤销 Get 操作，释放已分配的资源
     pub async fn get_revoke(&self, get_id: u64) -> KvResult<()> {
         let req = MsgPack {
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index fd5a06e..6d59d5f 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -4,28 +4,29 @@ use crate::client_kv_api::local_reserve_rebalance::{
 };
 use crate::client_kv_api::msg_pack::{
     ExternalBatchDeleteAckReq, ExternalBatchDeleteAckResp, ExternalBatchGetCancelReq,
-    ExternalBatchGetCancelResp, ExternalBatchGetReq, ExternalBatchGetResp,
-    ExternalBatchGetStartReq, ExternalBatchGetStartResp, ExternalBatchGetTransferReq,
-    ExternalBatchGetTransferResp, ExternalBatchIsExistReq, ExternalBatchIsExistResp,
-    ExternalBatchPutCommitReq, ExternalBatchPutCommitResp, ExternalBatchPutStartReq,
-    ExternalBatchPutStartResp, ExternalBatchPutTransferEndReq, ExternalBatchPutTransferEndResp,
-    ExternalDeleteAckReq, ExternalDeleteAckResp, ExternalDeleteReq, ExternalDeleteResp,
-    ExternalGetReq, ExternalGetResp, ExternalIsExistReq, ExternalIsExistResp,
-    ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp, ExternalPutCommitReq,
-    ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq,
-    ExternalPutStartResp, ExternalPutTransferEndReq, ExternalPutTransferEndResp, SyncKvToFileReq,
-    SyncKvToFileResp, TestPutPhaseTrace,
+    ExternalBatchGetCancelResp, ExternalBatchGetLocalProbeReq, ExternalBatchGetLocalProbeResp,
+    ExternalBatchGetReq, ExternalBatchGetResp, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
+    ExternalBatchGetTransferReq, ExternalBatchGetTransferResp, ExternalBatchIsExistReq,
+    ExternalBatchIsExistResp, ExternalBatchPutCommitReq, ExternalBatchPutCommitResp,
+    ExternalBatchPutStartReq, ExternalBatchPutStartResp, ExternalBatchPutTransferEndReq,
+    ExternalBatchPutTransferEndResp, ExternalDeleteAckReq, ExternalDeleteAckResp,
+    ExternalDeleteReq, ExternalDeleteResp, ExternalExecutePlannedGetReq,
+    ExternalExecutePlannedGetResp, ExternalGetReq, ExternalGetResp, ExternalIsExistReq,
+    ExternalIsExistResp, ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp,
+    ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
+    ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
+    ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
 };
 use crate::client_kv_api::reclaim::handle_batch_owner_reclaim;
 use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::config::TestSpecConfig;
 use crate::master_kv_router::msg_pack::{
     BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
-    BatchEvictOwnerSourceReq, BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartItemResp,
-    BatchGetStartReq, BatchIsExistReq, BatchOwnerReclaimReq, BatchPreparePutKeysReq,
-    BatchPutAppendDoneReq, BatchPutAppendStartReq, BatchPutDoneReq, BatchPutRevokeReq,
-    BatchPutStartReq, BatchReleasePutKeyReservationsReq, DeleteClientKvMetaCacheItem,
-    GroupedBatchPutDoneReq,
+    BatchEvictOwnerSourceReq, BatchGetBindReq, BatchGetDoneReq, BatchGetRevokeReq,
+    BatchGetStartItemResp, BatchGetStartReq, BatchIsExistReq, BatchOwnerReclaimReq,
+    BatchPreparePutKeysReq, BatchPutAppendDoneReq, BatchPutAppendStartReq, BatchPutDoneReq,
+    BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq,
+    DeleteClientKvMetaCacheItem, GroupedBatchPutDoneReq,
 };
 use crate::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
 use crate::memholder::{AllMemholderRefCount, ExternalMemHolderInfo, MemoryInfo, UserMemHolder};
@@ -95,6 +96,14 @@ pub struct OwnerRuntimeObserveSnapshot {
     pub external_get_flights_revoking: u64,
     pub external_get_undecided_interests: u64,
     pub external_get_retained_interests: u64,
+    pub owner_local_probe_batches: u64,
+    pub owner_local_probe_items: u64,
+    pub owner_local_probe_local_items: u64,
+    pub owner_local_probe_remote_items: u64,
+    pub planned_cpu_get_batches: u64,
+    pub planned_cpu_get_local_items: u64,
+    pub planned_cpu_get_leader_items: u64,
+    pub planned_cpu_get_follower_items: u64,
     pub external_pending_put_entries: u64,
     pub remote_put_flights_active: u64,
     pub remote_put_flight_leaders: u64,
@@ -631,6 +640,33 @@ async fn handle_external_batch_get(
     }
 }
 
+async fn handle_external_batch_get_local_probe(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalBatchGetLocalProbeReq>,
+) -> MsgPack<ExternalBatchGetLocalProbeResp> {
+    let req = msg.serialize_part.clone();
+    let dbg_len = req.keys.len();
+    let resp = view
+        .client_kv_api()
+        .external_batch_get_local_probe(req)
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!(
+                "handle_external_batch_get_local_probe error: {e}; batch_len={batch_len}",
+                batch_len = dbg_len
+            );
+            ExternalBatchGetLocalProbeResp {
+                items: Vec::new(),
+                error_code: e.code(),
+                error_json: e.to_json(),
+            }
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_batch_get_start(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalBatchGetStartReq>,
@@ -680,6 +716,36 @@ async fn handle_external_batch_get_transfer(
     }
 }
 
+async fn handle_external_execute_planned_get(
+    view: &ClientKvApiView,
+    msg: &MsgPack<ExternalExecutePlannedGetReq>,
+) -> MsgPack<ExternalExecutePlannedGetResp> {
+    let req = msg.serialize_part.clone();
+    let plan_handle = req.plan_handle;
+    let item_count = req.items.len();
+    let resp = view
+        .client_kv_api()
+        .external_execute_planned_get(req)
+        .await
+        .unwrap_or_else(|err| {
+            tracing::error!(
+                "handle_external_execute_planned_get error: {}; plan_handle={} items={}",
+                err,
+                plan_handle,
+                item_count
+            );
+            ExternalExecutePlannedGetResp {
+                items: Vec::new(),
+                error_code: err.code(),
+                error_json: err.to_json(),
+            }
+        });
+    MsgPack {
+        serialize_part: resp,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_batch_get_cancel(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalBatchGetCancelReq>,
@@ -1399,6 +1465,18 @@ struct OwnerRemotePutCounters {
     failed: AtomicU64,
 }
 
+#[derive(Default)]
+struct OwnerPlannedGetCounters {
+    local_probe_batches: AtomicU64,
+    local_probe_items: AtomicU64,
+    local_probe_local_items: AtomicU64,
+    local_probe_remote_items: AtomicU64,
+    batches: AtomicU64,
+    local_items: AtomicU64,
+    leader_items: AtomicU64,
+    follower_items: AtomicU64,
+}
+
 struct OwnerHotSelectionDebt {
     weight_bytes: u64,
     outstanding_bytes: Arc<AtomicU64>,
@@ -2382,6 +2460,7 @@ pub struct ClientKvApiInner {
         Arc<DashMap<OwnerHotReplicaIdentity, Arc<OwnerHotSelectionDebt>>>,
     owner_hot_counters: Arc<OwnerHotCacheCounters>,
     owner_remote_put_counters: Arc<OwnerRemotePutCounters>,
+    planned_get_counters: OwnerPlannedGetCounters,
     owner_hot_retry_queue: Arc<OwnerHotRetryQueue>,
     owner_hot_eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionDispatch>,
     owner_hot_eviction_rx:
@@ -2401,6 +2480,12 @@ pub struct ClientKvApiInner {
     /// remains in the sharded key-control table; observing metrics must never
     /// scan or hold those fences.
     external_get_flight_registry: DashMap<String, Weak<ExternalGetKeySharedOp>>,
+    external_get_local_probe_locks: AMapLock<(String, i64, u64)>,
+    completed_external_get_local_probes:
+        moka::future::Cache<(String, i64, u64), (Vec<String>, ExternalBatchGetLocalProbeResp)>,
+    planned_external_get_execute_locks: AMapLock<(String, i64, u64)>,
+    completed_planned_external_get_executes:
+        moka::future::Cache<(String, i64, u64), ExternalExecutePlannedGetResp>,
     next_external_get_start_handle: AtomicU64,
     /// External holding identities are independent from upstream and resident holder ids.
     next_external_holding_id: AtomicU64,
@@ -2420,6 +2505,7 @@ pub struct ClientKvApiInner {
     rpc_caller_get_revoke: RPCCaller<GetRevokeReq>,
     rpc_caller_get_done: RPCCaller<GetDoneReq>,
     rpc_caller_batch_get_start: RPCCaller<BatchGetStartReq>,
+    rpc_caller_batch_get_bind: RPCCaller<BatchGetBindReq>,
     rpc_caller_batch_get_revoke: RPCCaller<BatchGetRevokeReq>,
     rpc_caller_batch_get_done: RPCCaller<BatchGetDoneReq>,
     rpc_caller_put_start: RPCCaller<PutStartReq>,
@@ -5689,6 +5775,35 @@ impl ClientKvApiInner {
             external_get_flights_revoking,
             external_get_undecided_interests,
             external_get_retained_interests,
+            owner_local_probe_batches: self
+                .planned_get_counters
+                .local_probe_batches
+                .load(Ordering::Relaxed),
+            owner_local_probe_items: self
+                .planned_get_counters
+                .local_probe_items
+                .load(Ordering::Relaxed),
+            owner_local_probe_local_items: self
+                .planned_get_counters
+                .local_probe_local_items
+                .load(Ordering::Relaxed),
+            owner_local_probe_remote_items: self
+                .planned_get_counters
+                .local_probe_remote_items
+                .load(Ordering::Relaxed),
+            planned_cpu_get_batches: self.planned_get_counters.batches.load(Ordering::Relaxed),
+            planned_cpu_get_local_items: self
+                .planned_get_counters
+                .local_items
+                .load(Ordering::Relaxed),
+            planned_cpu_get_leader_items: self
+                .planned_get_counters
+                .leader_items
+                .load(Ordering::Relaxed),
+            planned_cpu_get_follower_items: self
+                .planned_get_counters
+                .follower_items
+                .load(Ordering::Relaxed),
             external_pending_put_entries: self.external_pending_puts.entry_count(),
             remote_put_flights_active: self
                 .owner_remote_put_counters
@@ -6341,6 +6456,14 @@ impl ClientKvApi {
                             revoking_flights = snapshot.external_get_flights_revoking,
                             undecided_interests = snapshot.external_get_undecided_interests,
                             retained_interests = snapshot.external_get_retained_interests,
+                            local_probe_batches = snapshot.owner_local_probe_batches,
+                            local_probe_items = snapshot.owner_local_probe_items,
+                            local_probe_local_items = snapshot.owner_local_probe_local_items,
+                            local_probe_remote_items = snapshot.owner_local_probe_remote_items,
+                            planned_cpu_batches = snapshot.planned_cpu_get_batches,
+                            planned_cpu_local_items = snapshot.planned_cpu_get_local_items,
+                            planned_cpu_leader_items = snapshot.planned_cpu_get_leader_items,
+                            planned_cpu_follower_items = snapshot.planned_cpu_get_follower_items,
                             reserve_free = snapshot.local_reserve_slots_free,
                             reserve_prepared = snapshot.local_reserve_slots_prepared,
                             reserve_pending_visible = snapshot.local_reserve_slots_pending_visible,
@@ -6453,6 +6576,7 @@ impl ClientKvApi {
             owner_source_eviction_selected,
             owner_hot_counters,
             owner_remote_put_counters,
+            planned_get_counters: OwnerPlannedGetCounters::default(),
             owner_hot_retry_queue,
             owner_hot_eviction_tx,
             owner_hot_eviction_rx: Mutex::new(Some(owner_hot_eviction_rx)),
@@ -6466,6 +6590,14 @@ impl ClientKvApi {
             external_get_holding: OwnerExternalMemMgr::default(),
             external_get_start_registry: DashMap::new(),
             external_get_flight_registry: DashMap::new(),
+            external_get_local_probe_locks: AMapLock::new(Duration::from_secs(120)),
+            completed_external_get_local_probes: moka::future::Cache::builder()
+                .time_to_live(Duration::from_secs(120))
+                .build(),
+            planned_external_get_execute_locks: AMapLock::new(Duration::from_secs(120)),
+            completed_planned_external_get_executes: moka::future::Cache::builder()
+                .time_to_live(Duration::from_secs(120))
+                .build(),
             next_external_get_start_handle: AtomicU64::new(1),
             next_external_holding_id: AtomicU64::new(1),
             external_pending_puts: moka::sync::Cache::builder()
@@ -6478,6 +6610,7 @@ impl ClientKvApi {
             rpc_caller_get_revoke: RPCCaller::new(),
             rpc_caller_get_done: RPCCaller::new(),
             rpc_caller_batch_get_start: RPCCaller::new(),
+            rpc_caller_batch_get_bind: RPCCaller::new(),
             rpc_caller_batch_get_revoke: RPCCaller::new(),
             rpc_caller_batch_get_done: RPCCaller::new(),
             rpc_caller_put_start: RPCCaller::new(),
@@ -6527,6 +6660,9 @@ impl ClientKvApi {
         inner
             .rpc_caller_batch_get_start
             .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_get_bind
+            .regist(inner.view.p2p_module());
         inner
             .rpc_caller_batch_get_revoke
             .regist(inner.view.p2p_module());
@@ -6633,6 +6769,20 @@ impl ClientKvApi {
             },
         );
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalBatchGetLocalProbeReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_batch_get_local_probe", async move {
+                    let result = handle_external_batch_get_local_probe(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalBatchGetStartReq>::new().regist(
             inner.view.p2p_module(),
@@ -6675,6 +6825,20 @@ impl ClientKvApi {
             },
         );
 
+        let view_ext = inner.view.clone_view();
+        RPCHandler::<ExternalExecutePlannedGetReq>::new().regist(
+            inner.view.p2p_module(),
+            move |resp, msg| {
+                let view = view_ext.clone();
+                let view_task = view.clone();
+                view.spawn("rpc_external_execute_planned_get", async move {
+                    let result = handle_external_execute_planned_get(&view_task, &msg).await;
+                    let _ = resp.send_resp(result).await;
+                });
+                Ok(())
+            },
+        );
+
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalPutStartReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
             let view = view_ext.clone();
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
index b0077c7..372a9a2 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
@@ -3,7 +3,7 @@ use crate::p2p::msg_pack::{MsgPackSerializePart, RPCReq};
 use crate::rpcresp_kvresult_convert::msg_and_error::{ErrorCode, OK};
 use bitcode::{Decode, Encode};
 
-use crate::memholder::{ExternalMemHolder, ExternalMemHolderInfo};
+use crate::memholder::ExternalMemHolderInfo;
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct TestPutPhaseTrace {
@@ -119,6 +119,78 @@ pub struct ExternalBatchGetResp {
     pub error_code: ErrorCode,
     pub error_json: String,
 }
+
+/// Probe only the requester's share-group owner. A `Some` item is pinned
+/// owner-local data; `None` must be resolved through the remote directory.
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetLocalProbeReq {
+    pub plan_handle: u64,
+    pub keys: Vec<String>,
+    pub req_node_id: String,
+    pub started_time: i64,
+}
+impl MsgPackSerializePart for ExternalBatchGetLocalProbeReq {
+    fn msg_id(&self) -> u32 {
+        4040
+    }
+}
+impl RPCReq for ExternalBatchGetLocalProbeReq {
+    type Resp = ExternalBatchGetLocalProbeResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalBatchGetLocalProbeResp {
+    pub items: Vec<Option<ExternalMemHolderInfo>>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+impl MsgPackSerializePart for ExternalBatchGetLocalProbeResp {
+    fn msg_id(&self) -> u32 {
+        4041
+    }
+}
+
+#[cfg(test)]
+mod external_batch_get_local_probe_wire_tests {
+    use super::{ExternalBatchGetLocalProbeReq, ExternalBatchGetLocalProbeResp};
+    use crate::memholder::ExternalMemHolderInfo;
+    use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+
+    #[test]
+    fn mixed_local_remote_probe_round_trip() {
+        let request = ExternalBatchGetLocalProbeReq {
+            plan_handle: 41,
+            keys: vec!["local".to_string(), "remote".to_string()],
+            req_node_id: "external-a".to_string(),
+            started_time: 17,
+        };
+        let decoded: ExternalBatchGetLocalProbeReq =
+            bitcode::decode(&bitcode::encode(&request)).expect("decode local probe request");
+        assert_eq!(decoded.plan_handle, 41);
+        assert_eq!(decoded.keys, request.keys);
+
+        let response = ExternalBatchGetLocalProbeResp {
+            items: vec![
+                Some(ExternalMemHolderInfo {
+                    offset: 4096,
+                    len: 8192,
+                    holder_id: 23,
+                }),
+                None,
+            ],
+            error_code: OK,
+            error_json: String::new(),
+        };
+        let decoded: ExternalBatchGetLocalProbeResp =
+            bitcode::decode(&bitcode::encode(&response)).expect("decode local probe response");
+        assert_eq!(decoded.items.len(), 2);
+        assert_eq!(
+            decoded.items[0].as_ref().map(|info| info.holder_id),
+            Some(23)
+        );
+        assert!(decoded.items[1].is_none());
+    }
+}
 impl MsgPackSerializePart for ExternalBatchGetResp {
     fn msg_id(&self) -> u32 {
         4021
@@ -229,6 +301,96 @@ pub struct ExternalBatchGetCancelResp {
     pub error_code: ErrorCode,
     pub error_json: String,
 }
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalPlannedGetItem {
+    pub key: String,
+    pub get_id: u64,
+}
+
+/// Execute a target-free master plan into the requester's owner-local CPU
+/// pool. The stable `(requester generation, plan_handle)` identity makes a
+/// lost response replayable without another lookup or transfer.
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalExecutePlannedGetReq {
+    pub plan_handle: u64,
+    pub items: Vec<ExternalPlannedGetItem>,
+    pub req_node_id: String,
+    pub started_time: i64,
+    pub transfer_concurrency: usize,
+}
+impl MsgPackSerializePart for ExternalExecutePlannedGetReq {
+    fn msg_id(&self) -> u32 {
+        4038
+    }
+}
+impl RPCReq for ExternalExecutePlannedGetReq {
+    type Resp = ExternalExecutePlannedGetResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct ExternalExecutePlannedGetResp {
+    pub items: Vec<ExternalBatchGetItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[cfg(test)]
+mod external_execute_planned_get_wire_tests {
+    use super::{
+        ExternalBatchGetItemResp, ExternalExecutePlannedGetReq, ExternalExecutePlannedGetResp,
+        ExternalPlannedGetItem,
+    };
+    use crate::memholder::ExternalMemHolderInfo;
+    use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+
+    #[test]
+    fn operation_identity_and_holder_terminal_round_trip() {
+        let request = ExternalExecutePlannedGetReq {
+            plan_handle: 19,
+            items: vec![ExternalPlannedGetItem {
+                key: "page-a".to_string(),
+                get_id: 0,
+            }],
+            req_node_id: "external-a".to_string(),
+            started_time: 23,
+            transfer_concurrency: 32,
+        };
+        let decoded: ExternalExecutePlannedGetReq =
+            bitcode::decode(&bitcode::encode(&request)).expect("decode planned execute request");
+        assert_eq!(decoded.plan_handle, 19);
+        assert_eq!(decoded.items[0].get_id, 0);
+        assert_eq!(decoded.started_time, 23);
+
+        let terminal = ExternalExecutePlannedGetResp {
+            items: vec![ExternalBatchGetItemResp {
+                error_code: OK,
+                error_json: String::new(),
+                external_memholder_info: Some(ExternalMemHolderInfo {
+                    offset: 4096,
+                    len: 8192,
+                    holder_id: 29,
+                }),
+            }],
+            error_code: OK,
+            error_json: String::new(),
+        };
+        let decoded: ExternalExecutePlannedGetResp =
+            bitcode::decode(&bitcode::encode(&terminal)).expect("decode planned execute terminal");
+        assert_eq!(
+            decoded.items[0]
+                .external_memholder_info
+                .as_ref()
+                .map(|info| info.holder_id),
+            Some(29)
+        );
+    }
+}
+impl MsgPackSerializePart for ExternalExecutePlannedGetResp {
+    fn msg_id(&self) -> u32 {
+        4039
+    }
+}
 impl MsgPackSerializePart for ExternalBatchGetCancelResp {
     fn msg_id(&self) -> u32 {
         4035
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index 86851bf..5af3351 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -5,8 +5,9 @@ use crate::client_kv_api::external_api::{
     validate_external_get_consume_prefix,
 };
 use crate::client_kv_api::msg_pack::{
-    ExternalBatchDeleteAckReq, ExternalInvalidateWeakIndexItem, ExternalInvalidateWeakIndexReq,
-    ExternalInvalidateWeakIndexResp,
+    ExternalBatchDeleteAckReq, ExternalExecutePlannedGetReq, ExternalExecutePlannedGetResp,
+    ExternalInvalidateWeakIndexItem, ExternalInvalidateWeakIndexReq,
+    ExternalInvalidateWeakIndexResp, ExternalPlannedGetItem,
 };
 use crate::client_seg_pool::{ClientSegPool, SideTransferPeerFileMeta};
 use crate::client_transfer_engine::{ClientTransferEngine, GpuMemoryGuard};
@@ -15,24 +16,26 @@ use crate::cluster_manager::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
 use crate::master_kv_router::msg_pack::{
-    BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeReq, BatchGetRevokeResp,
-    BatchGetStartItemResp, BatchGetStartReq, BatchGetStartResp, GetAllocationMode,
+    BatchGetBindItemReq, BatchGetBindReq, BatchGetBindResp, BatchGetDoneReq, BatchGetDoneResp,
+    BatchGetPlanItemResp, BatchGetPlanReq, BatchGetPlanResp, BatchGetRevokeReq, BatchGetRevokeResp,
+    BatchGetStartItemResp, BatchGetStartReq, BatchGetStartResp, GetAllocationMode, GetBindTarget,
     GetExternalSinkTarget,
 };
 use crate::rpcresp_kvresult_convert::ToResult;
 use crate::{
     client_kv_api::msg_pack::{
         ExternalBatchGetCancelPlan, ExternalBatchGetCancelReq, ExternalBatchGetItemResp,
-        ExternalBatchGetReq, ExternalBatchGetStartReq, ExternalBatchGetStartResp,
-        ExternalBatchGetStartTransferPlan, ExternalBatchGetTransferReq,
-        ExternalBatchGetTransferResp, ExternalBatchIsExistReq, ExternalBatchPutCommitItemReq,
-        ExternalBatchPutCommitReq, ExternalBatchPutCommitResp, ExternalBatchPutStartItemReq,
-        ExternalBatchPutStartReq, ExternalBatchPutStartResp, ExternalBatchPutTransferEndItemReq,
-        ExternalBatchPutTransferEndReq, ExternalBatchPutTransferEndResp, ExternalDeleteAckReq,
-        ExternalDeleteReq, ExternalGetReq, ExternalIsExistReq, ExternalObservabilitySnapshotReq,
-        ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
-        ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
-        ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
+        ExternalBatchGetLocalProbeReq, ExternalBatchGetLocalProbeResp, ExternalBatchGetReq,
+        ExternalBatchGetStartReq, ExternalBatchGetStartResp, ExternalBatchGetStartTransferPlan,
+        ExternalBatchGetTransferReq, ExternalBatchGetTransferResp, ExternalBatchIsExistReq,
+        ExternalBatchPutCommitItemReq, ExternalBatchPutCommitReq, ExternalBatchPutCommitResp,
+        ExternalBatchPutStartItemReq, ExternalBatchPutStartReq, ExternalBatchPutStartResp,
+        ExternalBatchPutTransferEndItemReq, ExternalBatchPutTransferEndReq,
+        ExternalBatchPutTransferEndResp, ExternalDeleteAckReq, ExternalDeleteReq, ExternalGetReq,
+        ExternalIsExistReq, ExternalObservabilitySnapshotReq, ExternalPutCommitReq,
+        ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp, ExternalPutStartReq,
+        ExternalPutStartResp, ExternalPutTransferEndReq, ExternalPutTransferEndResp,
+        SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
     },
     cluster_manager::{
         ClusterManager, ClusterManagerAccessTrait, IpcBandwidthAttributorHandle, NodeRole,
@@ -90,6 +93,13 @@ const EXTERNAL_PUT_TRANSFER_END_RPC_TIMEOUT_SECS: u64 = 30;
 const EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS: usize = 3;
 const EXTERNAL_PUT_TRACE_LOG_WINDOW_SECS: u64 = 10;
 const EXTERNAL_OWNER_INTRA_RPC_READY_TIMEOUT_SECS: u64 = 30;
+// This is a foreground scheduler wait, not the owner operation lifetime.
+// Owner finish is cancellation-safe and the uncertain replay below keeps its
+// longer timeout.  Fail the foreground request at the P2P minimum so SGLang
+// can fall back to compute instead of parking a TP scheduler for 300 seconds.
+const EXTERNAL_PLANNED_CPU_GET_FOREGROUND_RPC_TIMEOUT_SECS: u64 =
+    crate::p2p::msg_pack::MIN_EXPLICIT_RPC_TIMEOUT_SECS;
+const EXTERNAL_PLANNED_CPU_GET_REPLAY_RPC_TIMEOUT_SECS: u64 = 300;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum ExternalDeleteAckBatchSendResult {
@@ -117,9 +127,29 @@ pub struct ExternalGpuGetStartResp {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExternalGetPlanResp {
+    pub handle: u64,
+    pub raw_prefix_hit_len: usize,
+    pub gpu_raw_prefix_hit_len: usize,
+    /// Original key positions that need remote GPU destinations. Owner-local
+    /// positions remain CPU-backed and are absent from this vector.
+    pub gpu_remote_indices: Vec<usize>,
+}
+
 pub struct ExternalGpuGetTransferResp {
     pub transferred_prefix_len: usize,
     pub consumed_prefix_len: usize,
+    pub value_ptrs: Vec<u64>,
+    pub local_holders: Vec<Arc<ExternalMemHolder>>,
+    /// Wall time from publishing the live GPU Get handle until the transfer,
+    /// cleanup, and master Done path reached a terminal state.
+    pub transfer_wall_us: i64,
+    /// Time spent by the consuming call waiting for that terminal state.
+    pub finish_wait_us: i64,
+    /// Whether the terminal state was already available when consumption began.
+    pub terminal_before_consume: bool,
+    /// Ready-but-unconsumed residence when the terminal preceded consumption.
+    pub terminal_to_consume_us: i64,
 }
 
 fn external_gpu_transfer_plan_geometry_is_valid(
@@ -135,6 +165,34 @@ fn external_gpu_transfer_plan_geometry_is_valid(
         && registered_generation == destination.registration_id
 }
 
+fn external_get_plan_raw_prefixes(items: &[BatchGetPlanItemResp]) -> (usize, usize) {
+    external_get_plan_raw_prefixes_from_statuses(
+        items
+            .iter()
+            .map(|item| (item.error_code == OK, item.gpu_direct_eligible)),
+    )
+}
+
+fn external_get_plan_raw_prefixes_from_statuses(
+    statuses: impl IntoIterator<Item = (bool, bool)>,
+) -> (usize, usize) {
+    let mut cpu_prefix = 0usize;
+    let mut gpu_prefix = 0usize;
+    let mut gpu_prefix_open = true;
+    for (hit, gpu_eligible) in statuses {
+        if !hit {
+            break;
+        }
+        cpu_prefix += 1;
+        if gpu_prefix_open && gpu_eligible {
+            gpu_prefix += 1;
+        } else {
+            gpu_prefix_open = false;
+        }
+    }
+    (cpu_prefix, gpu_prefix)
+}
+
 #[derive(Clone, Debug)]
 enum ExternalGpuGetTerminal {
     Completed,
@@ -142,11 +200,90 @@ enum ExternalGpuGetTerminal {
     Failed { detail: String },
 }
 
+#[derive(Clone, Debug)]
+struct ExternalGpuGetTerminalEvent {
+    outcome: ExternalGpuGetTerminal,
+    terminal_at: Instant,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct ExternalGpuGetConsumeTiming {
+    transfer_wall_us: i64,
+    finish_wait_us: i64,
+    terminal_before_consume: bool,
+    terminal_to_consume_us: i64,
+}
+
+fn observe_external_gpu_get_consume_timing(
+    transfer_started_at: Instant,
+    terminal_at: Instant,
+    consume_started_at: Instant,
+    finish_wait: Duration,
+) -> ExternalGpuGetConsumeTiming {
+    let terminal_to_consume = consume_started_at.checked_duration_since(terminal_at);
+    ExternalGpuGetConsumeTiming {
+        transfer_wall_us: duration_to_i64_us(
+            terminal_at
+                .checked_duration_since(transfer_started_at)
+                .unwrap_or_default(),
+        ),
+        finish_wait_us: duration_to_i64_us(finish_wait),
+        terminal_before_consume: terminal_to_consume.is_some(),
+        terminal_to_consume_us: duration_to_i64_us(terminal_to_consume.unwrap_or_default()),
+    }
+}
+
 struct PendingExternalGpuGet {
+    transferable_len: usize,
+    atomic_group_lens: Vec<usize>,
+    value_ptrs: Vec<u64>,
+    local_holders: Vec<(usize, Arc<ExternalMemHolder>)>,
+    cancel_requested: Arc<AtomicBool>,
+    transfer_started_at: Instant,
+    terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminalEvent>>,
+}
+
+enum PendingExternalGetPlanItem {
+    Local {
+        holder: Arc<ExternalMemHolder>,
+    },
+    Remote {
+        key: String,
+        plan: BatchGetPlanItemResp,
+    },
+}
+
+struct PendingExternalGetPlan {
+    items: Vec<PendingExternalGetPlanItem>,
+    transferable_len: usize,
+    gpu_transferable_len: usize,
+    gpu_remote_indices: Vec<usize>,
+    atomic_group_lens: Vec<usize>,
+}
+
+#[derive(Clone, Debug)]
+enum ExternalPlannedCpuGetTerminal {
+    Completed {
+        items: Vec<ExternalBatchGetItemResp>,
+        owner_start_time: i64,
+    },
+    Revoked,
+    Failed {
+        detail: String,
+    },
+}
+
+struct PendingExternalPlannedCpuGet {
+    sources: Vec<PendingExternalCpuSource>,
     transferable_len: usize,
     atomic_group_lens: Vec<usize>,
     cancel_requested: Arc<AtomicBool>,
-    terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminal>>,
+    terminal_rx: watch::Receiver<Option<ExternalPlannedCpuGetTerminal>>,
+}
+
+enum PendingExternalCpuSource {
+    Local { holder: Arc<ExternalMemHolder> },
+    Remote { key: String },
 }
 
 struct PendingExternalGetStart {
@@ -156,6 +293,47 @@ struct PendingExternalGetStart {
     first_miss_index: Option<usize>,
 }
 
+/// Keeps ownership in a pending registry across cancellation points.  A
+/// future that is dropped while waiting automatically restores the exact
+/// entry, so a later transfer/cancel call can still drive its terminal
+/// cleanup.  `take()` disarms the guard once no further await can lose the
+/// entry.
+struct PendingRegistryEntryGuard<'a, T> {
+    registry: &'a DashMap<u64, T>,
+    handle: u64,
+    entry: Option<T>,
+}
+
+impl<'a, T> PendingRegistryEntryGuard<'a, T> {
+    fn new(registry: &'a DashMap<u64, T>, handle: u64, entry: T) -> Self {
+        Self {
+            registry,
+            handle,
+            entry: Some(entry),
+        }
+    }
+
+    fn entry(&self) -> &T {
+        self.entry
+            .as_ref()
+            .expect("pending registry guard must be armed")
+    }
+
+    fn take(mut self) -> T {
+        self.entry
+            .take()
+            .expect("pending registry guard must be armed")
+    }
+}
+
+impl<T> Drop for PendingRegistryEntryGuard<'_, T> {
+    fn drop(&mut self) {
+        if let Some(entry) = self.entry.take() {
+            self.registry.insert(self.handle, entry);
+        }
+    }
+}
+
 #[derive(Clone)]
 struct PendingInlineExternalGetStart {
     keys: Vec<String>,
@@ -204,6 +382,86 @@ fn validate_inline_external_get_owner_generation(
     }))
 }
 
+#[allow(clippy::too_many_arguments)]
+fn validate_external_local_holder_geometry(
+    index: usize,
+    holder_owner_start_time: i64,
+    holder_offset: u64,
+    holder_len: u32,
+    holder_addr: u64,
+    current_owner_start_time: i64,
+    base_ptr: u64,
+    mapped_len: u64,
+) -> KvResult<()> {
+    validate_inline_external_get_owner_generation(
+        holder_owner_start_time,
+        current_owner_start_time,
+    )?;
+    let end = holder_offset
+        .checked_add(u64::from(holder_len))
+        .ok_or_else(|| {
+            KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "mixed Get local holder range overflow: index={} offset={} len={}",
+                    index, holder_offset, holder_len
+                ),
+            })
+        })?;
+    let pointer = base_ptr.checked_add(holder_offset).ok_or_else(|| {
+        KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "mixed Get local holder pointer overflow: index={} base={:#x} offset={}",
+                index, base_ptr, holder_offset
+            ),
+        })
+    })?;
+    if end > mapped_len || pointer != holder_addr {
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "mixed Get local holder no longer matches owner mapping: index={} end={} mapped_len={} pointer={:#x} expected={:#x}",
+                index, end, mapped_len, pointer, holder_addr
+            ),
+        }));
+    }
+    Ok(())
+}
+
+fn validate_external_local_holder_mapping(
+    index: usize,
+    holder: &ExternalMemHolder,
+    current_owner_start_time: i64,
+    base_ptr: u64,
+    mapped_len: u64,
+) -> KvResult<()> {
+    validate_external_local_holder_geometry(
+        index,
+        holder.owner_start_time,
+        holder.offset,
+        holder.len,
+        holder.addr,
+        current_owner_start_time,
+        base_ptr,
+        mapped_len,
+    )
+}
+
+fn validate_external_local_holders_mapping(
+    holders: &[(usize, Arc<ExternalMemHolder>)],
+    current_owner_start_time: i64,
+    base_ptr: u64,
+    mapped_len: u64,
+) -> KvResult<()> {
+    holders.iter().try_for_each(|(index, holder)| {
+        validate_external_local_holder_mapping(
+            *index,
+            holder,
+            current_owner_start_time,
+            base_ptr,
+            mapped_len,
+        )
+    })
+}
+
 fn inline_external_get_tail_holder_ids(
     items: &[ExternalBatchGetItemResp],
     consume_prefix_len: usize,
@@ -239,14 +497,20 @@ fn inline_external_get_tail_holder_ids(
 #[cfg(test)]
 mod inline_external_get_start_tests {
     use super::{
-        ExternalGpuDestination, external_gpu_transfer_plan_geometry_is_valid,
-        inline_external_get_tail_holder_ids, validate_inline_external_get_owner_generation,
+        EXTERNAL_PLANNED_CPU_GET_FOREGROUND_RPC_TIMEOUT_SECS,
+        EXTERNAL_PLANNED_CPU_GET_REPLAY_RPC_TIMEOUT_SECS, ExternalGpuDestination,
+        PendingRegistryEntryGuard, external_get_plan_raw_prefixes,
+        external_get_plan_raw_prefixes_from_statuses, external_gpu_transfer_plan_geometry_is_valid,
+        inline_external_get_tail_holder_ids, observe_external_gpu_get_consume_timing,
+        validate_external_local_holder_geometry, validate_inline_external_get_owner_generation,
         validate_inline_external_get_start_plan,
     };
     use crate::client_kv_api::msg_pack::ExternalBatchGetItemResp;
-    use crate::master_kv_router::msg_pack::BatchGetStartItemResp;
+    use crate::master_kv_router::msg_pack::{BatchGetPlanItemResp, BatchGetStartItemResp};
     use crate::memholder::ExternalMemHolderInfo;
     use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
+    use dashmap::DashMap;
+    use std::time::{Duration, Instant};
 
     fn inline_hit(holder_id: u64) -> ExternalBatchGetItemResp {
         ExternalBatchGetItemResp {
@@ -271,6 +535,18 @@ mod inline_external_get_start_tests {
         assert!(validate_inline_external_get_start_plan(2, &missing).is_err());
     }
 
+    #[test]
+    fn planned_cpu_get_foreground_timeout_is_bounded_below_replay_cleanup() {
+        assert_eq!(
+            EXTERNAL_PLANNED_CPU_GET_FOREGROUND_RPC_TIMEOUT_SECS,
+            crate::p2p::msg_pack::MIN_EXPLICIT_RPC_TIMEOUT_SECS,
+        );
+        assert!(
+            EXTERNAL_PLANNED_CPU_GET_FOREGROUND_RPC_TIMEOUT_SECS
+                < EXTERNAL_PLANNED_CPU_GET_REPLAY_RPC_TIMEOUT_SECS
+        );
+    }
+
     #[test]
     fn inline_plan_rejects_a_stale_owner_generation() {
         assert!(validate_inline_external_get_owner_generation(17, 17).is_ok());
@@ -285,6 +561,41 @@ mod inline_external_get_start_tests {
         ));
     }
 
+    #[test]
+    fn mixed_source_local_holder_requires_the_exact_live_mapping() {
+        assert!(
+            validate_external_local_holder_geometry(
+                2, 17, 0x1000, 0x1000, 0x11_000, 17, 0x10_000, 0x4000,
+            )
+            .is_ok()
+        );
+
+        let stale = validate_external_local_holder_geometry(
+            2, 16, 0x1000, 0x1000, 0x11_000, 17, 0x10_000, 0x4000,
+        )
+        .expect_err("an old owner generation must be rejected before GPU Bind");
+        assert!(matches!(
+            stale,
+            KvError::Api(ApiError::OwnerStartTimeMismatch {
+                expected: 17,
+                got: 16
+            })
+        ));
+
+        assert!(
+            validate_external_local_holder_geometry(
+                2, 17, 0x3800, 0x1000, 0x13_800, 17, 0x10_000, 0x4000,
+            )
+            .is_err()
+        );
+        assert!(
+            validate_external_local_holder_geometry(
+                2, 17, 0x1000, 0x1000, 0x21_000, 17, 0x10_000, 0x4000,
+            )
+            .is_err()
+        );
+    }
+
     #[test]
     fn inline_partial_consume_returns_only_tail_holder_ids() {
         let items = vec![inline_hit(11), inline_hit(12), inline_hit(13)];
@@ -322,6 +633,140 @@ mod inline_external_get_start_tests {
             destination.registration_id,
         ));
     }
+
+    #[test]
+    fn gpu_prefix_stops_without_shortening_the_cpu_plan() {
+        let items = vec![
+            BatchGetPlanItemResp {
+                error_code: OK,
+                gpu_direct_eligible: true,
+                ..Default::default()
+            },
+            BatchGetPlanItemResp {
+                error_code: OK,
+                gpu_direct_eligible: false,
+                ..Default::default()
+            },
+            BatchGetPlanItemResp {
+                error_code: OK,
+                gpu_direct_eligible: true,
+                ..Default::default()
+            },
+        ];
+        assert_eq!(external_get_plan_raw_prefixes(&items), (3, 1));
+    }
+
+    #[test]
+    fn owner_local_positions_do_not_consume_remote_gpu_destinations() {
+        // local, remote-GPU, local stays a three-page GPU-capable source
+        // prefix, while only the middle page needs a GPU destination.
+        assert_eq!(
+            external_get_plan_raw_prefixes_from_statuses([
+                (true, true),
+                (true, true),
+                (true, true),
+            ]),
+            (3, 3)
+        );
+        // A remote source that cannot bind a GPU sink stops only the mixed
+        // GPU prefix; the CPU plan can still consume later local pages.
+        assert_eq!(
+            external_get_plan_raw_prefixes_from_statuses([
+                (true, true),
+                (true, false),
+                (true, true),
+            ]),
+            (3, 1)
+        );
+        assert_eq!(
+            external_get_plan_raw_prefixes_from_statuses([
+                (true, true),
+                (false, false),
+                (true, true),
+            ]),
+            (1, 1)
+        );
+    }
+
+    #[test]
+    fn gpu_get_timing_separates_ready_residence_from_real_wait() {
+        let transfer_started_at = Instant::now();
+        let terminal_at = transfer_started_at + Duration::from_millis(20);
+        let consume_after_terminal = terminal_at + Duration::from_millis(30);
+        let ready = observe_external_gpu_get_consume_timing(
+            transfer_started_at,
+            terminal_at,
+            consume_after_terminal,
+            Duration::from_micros(7),
+        );
+        assert_eq!(ready.transfer_wall_us, 20_000);
+        assert!(ready.terminal_before_consume);
+        assert_eq!(ready.terminal_to_consume_us, 30_000);
+        assert_eq!(ready.finish_wait_us, 7);
+
+        let consume_before_terminal = transfer_started_at + Duration::from_millis(5);
+        let waiting = observe_external_gpu_get_consume_timing(
+            transfer_started_at,
+            terminal_at,
+            consume_before_terminal,
+            Duration::from_millis(15),
+        );
+        assert_eq!(waiting.transfer_wall_us, 20_000);
+        assert!(!waiting.terminal_before_consume);
+        assert_eq!(waiting.terminal_to_consume_us, 0);
+        assert_eq!(waiting.finish_wait_us, 15_000);
+    }
+
+    #[test]
+    fn pending_registry_guard_reinserts_on_drop_and_disarms_on_take() {
+        let registry = DashMap::new();
+        let handle = 17;
+
+        {
+            let guard = PendingRegistryEntryGuard::new(&registry, handle, "pending-a");
+            assert_eq!(guard.entry(), &"pending-a");
+            assert!(!registry.contains_key(&handle));
+        }
+        assert_eq!(
+            registry.remove(&handle).map(|(_, value)| value),
+            Some("pending-a")
+        );
+
+        let guard = PendingRegistryEntryGuard::new(&registry, handle, "pending-b");
+        assert_eq!(guard.take(), "pending-b");
+        assert!(!registry.contains_key(&handle));
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn aborted_terminal_waiter_restores_the_pending_entry() {
+        let registry = std::sync::Arc::new(DashMap::new());
+        let handle = 23;
+        registry.insert(handle, "terminal-pending");
+        let task_registry = registry.clone();
+        let (armed_tx, armed_rx) = ::tokio::sync::oneshot::channel();
+        let waiter = ::tokio::spawn(async move {
+            let (_, entry) = task_registry
+                .remove(&handle)
+                .expect("test pending entry must exist");
+            let _guard = PendingRegistryEntryGuard::new(&task_registry, handle, entry);
+            let _ = armed_tx.send(());
+            futures::future::pending::<()>().await;
+        });
+
+        armed_rx.await.expect("waiter armed its guard");
+        assert!(!registry.contains_key(&handle));
+        waiter.abort();
+        assert!(
+            waiter
+                .await
+                .expect_err("waiter must be aborted")
+                .is_cancelled()
+        );
+        assert_eq!(
+            registry.remove(&handle).map(|(_, value)| value),
+            Some("terminal-pending")
+        );
+    }
 }
 
 fn duration_to_i64_us(duration: std::time::Duration) -> i64 {
@@ -577,12 +1022,16 @@ pub struct ExternalInner {
     side_transfer_put_bindings: moka::sync::SegmentedCache<(u64, u32), (String, u16)>,
     rpc_caller_external_get: RPCCaller<ExternalGetReq>,
     rpc_caller_external_batch_get: RPCCaller<ExternalBatchGetReq>,
+    rpc_caller_external_batch_get_local_probe: RPCCaller<ExternalBatchGetLocalProbeReq>,
     rpc_caller_external_batch_get_start: RPCCaller<ExternalBatchGetStartReq>,
     rpc_caller_external_batch_get_transfer: RPCCaller<ExternalBatchGetTransferReq>,
     rpc_caller_external_batch_get_cancel: RPCCaller<ExternalBatchGetCancelReq>,
     rpc_caller_master_batch_get_start: RPCCaller<BatchGetStartReq>,
+    rpc_caller_master_batch_get_plan: RPCCaller<BatchGetPlanReq>,
+    rpc_caller_master_batch_get_bind: RPCCaller<BatchGetBindReq>,
     rpc_caller_master_batch_get_done: RPCCaller<BatchGetDoneReq>,
     rpc_caller_master_batch_get_revoke: RPCCaller<BatchGetRevokeReq>,
+    rpc_caller_external_execute_planned_get: RPCCaller<ExternalExecutePlannedGetReq>,
     rpc_caller_external_put_commit: RPCCaller<ExternalPutCommitReq>,
     rpc_caller_external_batch_put_commit: RPCCaller<ExternalBatchPutCommitReq>,
     rpc_caller_external_put_start: RPCCaller<ExternalPutStartReq>,
@@ -605,7 +1054,9 @@ pub struct ExternalInner {
     /// Fully local plans consumed without a follow-up owner transfer RPC.
     pending_inline_external_get_start: DashMap<u64, PendingInlineExternalGetStart>,
     next_gpu_get_handle: AtomicU64,
+    pending_external_get_plan: DashMap<u64, PendingExternalGetPlan>,
     pending_external_gpu_get: DashMap<u64, PendingExternalGpuGet>,
+    pending_external_planned_cpu_get: DashMap<u64, PendingExternalPlannedCpuGet>,
     /// per-key semaphore (permits=1) to ensure single inflight per key
     inflight1_per_key: SemaphoreMap<String>,
     put_trace_log_window: Mutex<ExternalPutTraceLogWindow>,
@@ -615,8 +1066,8 @@ pub struct ExternalInner {
 pub struct ExternalClientApi(ExternalInner);
 
 async fn wait_external_gpu_get_terminal(
-    mut terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminal>>,
-) -> KvResult<ExternalGpuGetTerminal> {
+    mut terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminalEvent>>,
+) -> KvResult<ExternalGpuGetTerminalEvent> {
     loop {
         if let Some(terminal) = terminal_rx.borrow().clone() {
             return Ok(terminal);
@@ -630,104 +1081,447 @@ async fn wait_external_gpu_get_terminal(
     }
 }
 
-async fn run_external_gpu_get_transfer(
-    view: ExternalClientApiView,
-    transfer_items: Vec<(BatchGetStartItemResp, GpuMemoryGuard)>,
-    skipped_get_ids: Vec<u64>,
-    transfer_concurrency: usize,
-    cancel_requested: Arc<AtomicBool>,
-) -> ExternalGpuGetTerminal {
-    let transfer_get_ids = transfer_items
-        .iter()
-        .map(|(item, _)| item.get_id)
-        .collect::<Vec<_>>();
-    let mut all_get_ids = skipped_get_ids.clone();
-    all_get_ids.extend(transfer_get_ids.iter().copied());
-
-    let skipped_revoke_error = view
-        .external_client_api()
-        .inner()
-        .master_batch_gpu_get_revoke(skipped_get_ids)
-        .await
-        .err()
-        .map(|err| err.to_string());
-
-    if transfer_items.is_empty() {
-        return match skipped_revoke_error {
-            Some(detail) => ExternalGpuGetTerminal::Failed {
-                detail: format!("GPU Get could not revoke non-transferable starts: {detail}"),
-            },
-            None => ExternalGpuGetTerminal::Revoked {
-                transfer_error: None,
-            },
-        };
-    }
-
-    let transfer_futures = transfer_items.into_iter().map(|(item, gpu_guard)| {
-        let transfer_view = view.clone();
-        let cancel_requested = cancel_requested.clone();
-        async move {
-            if cancel_requested.load(Ordering::Acquire) {
-                return None;
-            }
-            transfer_view
-                .client_transfer_engine()
-                .transfer_data_no_copy_to_gpu(
-                    item.node_id.clone(),
-                    item.src_addr,
-                    item.target_addr,
-                    item.len,
-                    gpu_guard,
-                )
-                .await
-                .err()
-                .map(|err| {
-                    format!(
-                        "GPU Get transfer failed: get_id={} source={} src={:#x} target={:#x} len={} error={}",
-                        item.get_id,
-                        item.node_id,
-                        item.src_addr,
-                        item.target_addr,
-                        item.len,
-                        err
-                    )
-                })
+async fn wait_external_planned_cpu_get_terminal(
+    mut terminal_rx: watch::Receiver<Option<ExternalPlannedCpuGetTerminal>>,
+) -> KvResult<ExternalPlannedCpuGetTerminal> {
+    loop {
+        if let Some(terminal) = terminal_rx.borrow().clone() {
+            return Ok(terminal);
         }
-    });
-    let mut transfer_stream =
-        stream::iter(transfer_futures).buffer_unordered(transfer_concurrency.max(1));
-    let mut transfer_error = None;
-    while let Some(item_error) = transfer_stream.next().await {
-        if transfer_error.is_none() {
-            transfer_error = item_error;
+        if terminal_rx.changed().await.is_err() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: "planned CPU Get task ended without publishing a terminal state"
+                    .to_string(),
+            }));
         }
     }
+}
 
-    let cancelled = cancel_requested.load(Ordering::Acquire);
-    if cancelled || transfer_error.is_some() || skipped_revoke_error.is_some() {
-        if let Err(err) = view
+async fn run_planned_get_revoke_cleanup(
+    view: ExternalClientApiView,
+    get_ids: Vec<u64>,
+    context: &'static str,
+) -> KvResult<()> {
+    if get_ids.is_empty() {
+        return Ok(());
+    }
+    let mut attempt = 1u32;
+    let mut shutdown = view.register_shutdown_waiter();
+    loop {
+        match view
             .external_client_api()
             .inner()
-            .master_batch_gpu_get_revoke(all_get_ids)
+            .master_batch_gpu_get_revoke(get_ids.clone())
             .await
         {
-            return ExternalGpuGetTerminal::Failed {
-                detail: format!(
-                    "GPU Get cleanup failed after transfer/cancel: transfer_error={:?} skipped_revoke_error={:?} revoke_error={}",
-                    transfer_error, skipped_revoke_error, err
-                ),
-            };
-        }
-        if let Some(detail) = skipped_revoke_error {
-            return ExternalGpuGetTerminal::Failed {
-                detail: format!(
-                    "GPU Get initially failed to revoke non-transferable starts: {detail}"
-                ),
-            };
+            Ok(()) => return Ok(()),
+            Err(err) if matches!(&err, KvError::Api(ApiError::SystemShutdown { .. })) => {
+                return Err(err);
+            }
+            Err(err) => {
+                tracing::warn!(
+                    "{} planned Get Revoke uncertain; retaining cleanup ownership: items={} attempt={} err={}",
+                    context,
+                    get_ids.len(),
+                    attempt,
+                    err
+                );
+            }
         }
-        return ExternalGpuGetTerminal::Revoked { transfer_error };
-    }
-
+        attempt = attempt.saturating_add(1);
+        tokio::select! {
+            _ = tokio::time::sleep(Duration::from_millis(
+                (50u64.saturating_mul(1u64 << attempt.min(6))).min(2_000),
+            )) => {}
+            _ = shutdown.wait() => {
+                return Err(KvError::Api(ApiError::SystemShutdown {
+                    detail: format!(
+                        "{} planned Get Revoke cleanup stopped during shutdown",
+                        context
+                    ),
+                }));
+            }
+        }
+    }
+}
+
+fn spawn_planned_get_revoke_cleanup(
+    view: ExternalClientApiView,
+    get_ids: Vec<u64>,
+    context: &'static str,
+) -> ::tokio::sync::oneshot::Receiver<KvResult<()>> {
+    let (done_tx, done_rx) = ::tokio::sync::oneshot::channel();
+    let spawn_view = view.clone();
+    let worker_view = view;
+    spawn_view.spawn("planned_get_revoke_cleanup", async move {
+        let result = run_planned_get_revoke_cleanup(worker_view, get_ids, context).await;
+        let _ = done_tx.send(result);
+    });
+    done_rx
+}
+
+async fn finish_planned_get_revoke_cleanup(
+    view: ExternalClientApiView,
+    get_ids: Vec<u64>,
+    context: &'static str,
+) -> KvResult<()> {
+    spawn_planned_get_revoke_cleanup(view, get_ids, context)
+        .await
+        .map_err(|_| {
+            KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "{} planned Get Revoke task ended without publishing a terminal",
+                    context
+                ),
+            })
+        })?
+}
+
+/// Owns master plan identities until a durable local pending entry or a
+/// registered cleanup task takes over.  This closes the cancellation window
+/// around late Bind RPCs without adding a normal-path RPC.
+struct PlannedGetRevokeGuard {
+    view: ExternalClientApiView,
+    get_ids: Option<Vec<u64>>,
+    context: &'static str,
+}
+
+impl PlannedGetRevokeGuard {
+    fn new(view: ExternalClientApiView, get_ids: Vec<u64>, context: &'static str) -> Self {
+        Self {
+            view,
+            get_ids: Some(get_ids),
+            context,
+        }
+    }
+
+    fn disarm(&mut self) {
+        self.get_ids = None;
+    }
+}
+
+impl Drop for PlannedGetRevokeGuard {
+    fn drop(&mut self) {
+        let Some(get_ids) = self.get_ids.take() else {
+            return;
+        };
+        if get_ids.is_empty() {
+            return;
+        }
+        drop(spawn_planned_get_revoke_cleanup(
+            self.view.clone(),
+            get_ids,
+            self.context,
+        ));
+    }
+}
+
+fn release_planned_cpu_response_holders(
+    inner: &ExternalInner,
+    response: &ExternalExecutePlannedGetResp,
+    owner_start_time: i64,
+) {
+    let external_client_id = inner.view.cluster_manager().get_self_info().id;
+    for holder_id in response.items.iter().filter_map(|item| {
+        item.external_memholder_info
+            .as_ref()
+            .map(|info| info.holder_id)
+    }) {
+        if let Err(err) = inner.enqueue_external_delete_ack(
+            external_client_id.clone(),
+            holder_id,
+            owner_start_time,
+        ) {
+            tracing::warn!(
+                "planned CPU Get could not enqueue unused holder release: holder_id={} err={}",
+                holder_id,
+                err
+            );
+        }
+    }
+}
+
+fn spawn_uncertain_planned_cpu_get_cleanup(
+    view: ExternalClientApiView,
+    owner: String,
+    request: MsgPack<ExternalExecutePlannedGetReq>,
+    owner_start_time: i64,
+) {
+    let spawn_view = view.clone();
+    let task_view = view.clone();
+    spawn_view.spawn("uncertain_planned_cpu_get_cleanup", async move {
+        let mut shutdown = task_view.register_shutdown_waiter();
+        loop {
+            let inner = task_view.external_client_api().inner();
+            if inner.current_owner_start_time().await != owner_start_time {
+                return;
+            }
+            let attempt = inner
+                .rpc_caller_external_execute_planned_get
+                .call(
+                    inner.view.p2p_module(),
+                    owner.clone().into(),
+                    request.clone(),
+                    Some(Duration::from_secs(
+                        EXTERNAL_PLANNED_CPU_GET_REPLAY_RPC_TIMEOUT_SECS,
+                    )),
+                    0,
+                )
+                .await;
+            if let Ok(response) = attempt {
+                release_planned_cpu_response_holders(
+                    inner,
+                    &response.serialize_part,
+                    owner_start_time,
+                );
+                return;
+            }
+            tokio::select! {
+                _ = tokio::time::sleep(Duration::from_secs(1)) => {}
+                _ = shutdown.wait() => return,
+            }
+        }
+    });
+}
+
+async fn run_external_planned_cpu_get(
+    view: ExternalClientApiView,
+    plan_handle: u64,
+    plan_items: Vec<(String, u64)>,
+    skipped_get_ids: Vec<u64>,
+    transfer_concurrency: usize,
+    cancel_requested: Arc<AtomicBool>,
+) -> ExternalPlannedCpuGetTerminal {
+    let inner = view.external_client_api().inner();
+    let mut all_plan_get_ids = skipped_get_ids.clone();
+    all_plan_get_ids.extend(plan_items.iter().map(|(_, get_id)| *get_id));
+    if let Err(err) = inner.master_batch_gpu_get_revoke(skipped_get_ids).await {
+        let cleanup = finish_planned_get_revoke_cleanup(
+            view.clone(),
+            all_plan_get_ids,
+            "planned CPU tail failure",
+        )
+        .await
+        .err()
+        .map(|cleanup_err| cleanup_err.to_string());
+        return ExternalPlannedCpuGetTerminal::Failed {
+            detail: format!(
+                "planned CPU Get could not revoke its unconsumed tail: {err}; cleanup_error={cleanup:?}"
+            ),
+        };
+    }
+    if cancel_requested.load(Ordering::Acquire) {
+        let get_ids = plan_items.iter().map(|(_, get_id)| *get_id).collect();
+        return match finish_planned_get_revoke_cleanup(
+            view.clone(),
+            get_ids,
+            "planned CPU pre-owner cancel",
+        )
+        .await
+        {
+            Ok(()) => ExternalPlannedCpuGetTerminal::Revoked,
+            Err(err) => ExternalPlannedCpuGetTerminal::Failed {
+                detail: format!("planned CPU Get cancel cleanup failed: {err}"),
+            },
+        };
+    }
+
+    if plan_items.is_empty() {
+        return ExternalPlannedCpuGetTerminal::Completed {
+            items: Vec::new(),
+            owner_start_time: inner.current_owner_start_time().await,
+        };
+    }
+
+    let Some(owner) = inner.shared_storage_node_id().await else {
+        let get_ids = plan_items.iter().map(|(_, get_id)| *get_id).collect();
+        let cleanup =
+            finish_planned_get_revoke_cleanup(view.clone(), get_ids, "planned CPU missing owner")
+                .await
+                .err()
+                .map(|cleanup_err| cleanup_err.to_string());
+        return ExternalPlannedCpuGetTerminal::Failed {
+            detail: format!(
+                "planned CPU Get has no current share-group owner; cleanup_error={cleanup:?}"
+            ),
+        };
+    };
+    let owner_start_time = inner.current_owner_start_time().await;
+    let external_client_id = inner.view.cluster_manager().get_self_info().id;
+    let request = MsgPack {
+        serialize_part: ExternalExecutePlannedGetReq {
+            plan_handle,
+            items: plan_items
+                .iter()
+                .map(|(key, get_id)| ExternalPlannedGetItem {
+                    key: key.clone(),
+                    get_id: *get_id,
+                })
+                .collect(),
+            req_node_id: external_client_id,
+            started_time: owner_start_time,
+            transfer_concurrency,
+        },
+        raw_bytes: Vec::new(),
+    };
+    let response = match inner
+        .rpc_caller_external_execute_planned_get
+        .call(
+            inner.view.p2p_module(),
+            owner.clone().into(),
+            request.clone(),
+            Some(Duration::from_secs(
+                EXTERNAL_PLANNED_CPU_GET_FOREGROUND_RPC_TIMEOUT_SECS,
+            )),
+            0,
+        )
+        .await
+    {
+        Ok(response) => response.serialize_part,
+        Err(err) => {
+            spawn_uncertain_planned_cpu_get_cleanup(view.clone(), owner, request, owner_start_time);
+            return ExternalPlannedCpuGetTerminal::Failed {
+                detail: format!(
+                    "planned CPU Get owner RPC failed; replay cleanup continues in background: error={}",
+                    KvError::from(err)
+                ),
+            };
+        }
+    };
+    if response.error_code != OK || response.items.len() != plan_items.len() {
+        release_planned_cpu_response_holders(inner, &response, owner_start_time);
+        return ExternalPlannedCpuGetTerminal::Failed {
+            detail: format!(
+                "planned CPU Get owner response failed or changed shape: error_code={} expected={} got={} error_json={}",
+                response.error_code,
+                plan_items.len(),
+                response.items.len(),
+                response.error_json
+            ),
+        };
+    }
+    if let Some((index, item)) = response
+        .items
+        .iter()
+        .enumerate()
+        .find(|(_, item)| item.error_code != OK || item.external_memholder_info.is_none())
+    {
+        release_planned_cpu_response_holders(inner, &response, owner_start_time);
+        return ExternalPlannedCpuGetTerminal::Failed {
+            detail: format!(
+                "planned CPU Get item failed: index={} error_code={} error_json={}",
+                index, item.error_code, item.error_json
+            ),
+        };
+    }
+    if cancel_requested.load(Ordering::Acquire) {
+        release_planned_cpu_response_holders(inner, &response, owner_start_time);
+        return ExternalPlannedCpuGetTerminal::Revoked;
+    }
+    ExternalPlannedCpuGetTerminal::Completed {
+        items: response.items,
+        owner_start_time,
+    }
+}
+
+async fn run_external_gpu_get_transfer(
+    view: ExternalClientApiView,
+    transfer_items: Vec<(BatchGetStartItemResp, GpuMemoryGuard)>,
+    skipped_get_ids: Vec<u64>,
+    transfer_concurrency: usize,
+    cancel_requested: Arc<AtomicBool>,
+) -> ExternalGpuGetTerminal {
+    let transfer_get_ids = transfer_items
+        .iter()
+        .map(|(item, _)| item.get_id)
+        .collect::<Vec<_>>();
+    let mut all_get_ids = skipped_get_ids.clone();
+    all_get_ids.extend(transfer_get_ids.iter().copied());
+
+    let skipped_revoke_error = view
+        .external_client_api()
+        .inner()
+        .master_batch_gpu_get_revoke(skipped_get_ids)
+        .await
+        .err()
+        .map(|err| err.to_string());
+
+    if transfer_items.is_empty() {
+        return match skipped_revoke_error {
+            Some(detail) => ExternalGpuGetTerminal::Failed {
+                detail: format!("GPU Get could not revoke non-transferable starts: {detail}"),
+            },
+            None => ExternalGpuGetTerminal::Revoked {
+                transfer_error: None,
+            },
+        };
+    }
+
+    let transfer_futures = transfer_items.into_iter().map(|(item, gpu_guard)| {
+        let transfer_view = view.clone();
+        let cancel_requested = cancel_requested.clone();
+        async move {
+            if cancel_requested.load(Ordering::Acquire) {
+                return None;
+            }
+            transfer_view
+                .client_transfer_engine()
+                .transfer_data_no_copy_to_gpu(
+                    item.node_id.clone(),
+                    item.src_addr,
+                    item.target_addr,
+                    item.len,
+                    gpu_guard,
+                )
+                .await
+                .err()
+                .map(|err| {
+                    format!(
+                        "GPU Get transfer failed: get_id={} source={} src={:#x} target={:#x} len={} error={}",
+                        item.get_id,
+                        item.node_id,
+                        item.src_addr,
+                        item.target_addr,
+                        item.len,
+                        err
+                    )
+                })
+        }
+    });
+    let mut transfer_stream =
+        stream::iter(transfer_futures).buffer_unordered(transfer_concurrency.max(1));
+    let mut transfer_error = None;
+    while let Some(item_error) = transfer_stream.next().await {
+        if transfer_error.is_none() {
+            transfer_error = item_error;
+        }
+    }
+
+    let cancelled = cancel_requested.load(Ordering::Acquire);
+    if cancelled || transfer_error.is_some() || skipped_revoke_error.is_some() {
+        if let Err(err) = view
+            .external_client_api()
+            .inner()
+            .master_batch_gpu_get_revoke(all_get_ids)
+            .await
+        {
+            return ExternalGpuGetTerminal::Failed {
+                detail: format!(
+                    "GPU Get cleanup failed after transfer/cancel: transfer_error={:?} skipped_revoke_error={:?} revoke_error={}",
+                    transfer_error, skipped_revoke_error, err
+                ),
+            };
+        }
+        if let Some(detail) = skipped_revoke_error {
+            return ExternalGpuGetTerminal::Failed {
+                detail: format!(
+                    "GPU Get initially failed to revoke non-transferable starts: {detail}"
+                ),
+            };
+        }
+        return ExternalGpuGetTerminal::Revoked { transfer_error };
+    }
+
     match view
         .external_client_api()
         .inner()
@@ -741,6 +1535,27 @@ async fn run_external_gpu_get_transfer(
     }
 }
 
+async fn run_external_gpu_get_transfer_timed(
+    view: ExternalClientApiView,
+    transfer_items: Vec<(BatchGetStartItemResp, GpuMemoryGuard)>,
+    skipped_get_ids: Vec<u64>,
+    transfer_concurrency: usize,
+    cancel_requested: Arc<AtomicBool>,
+) -> ExternalGpuGetTerminalEvent {
+    let outcome = run_external_gpu_get_transfer(
+        view,
+        transfer_items,
+        skipped_get_ids,
+        transfer_concurrency,
+        cancel_requested,
+    )
+    .await;
+    ExternalGpuGetTerminalEvent {
+        outcome,
+        terminal_at: Instant::now(),
+    }
+}
+
 impl ExternalClientApi {
     /// Access inner external-only API. Safe to unwrap in external role.
     pub fn inner(&self) -> &ExternalInner {
@@ -778,12 +1593,18 @@ impl ExternalClientApi {
                 .build(),
             rpc_caller_external_get: RPCCaller::<ExternalGetReq>::new(),
             rpc_caller_external_batch_get: RPCCaller::<ExternalBatchGetReq>::new(),
+            rpc_caller_external_batch_get_local_probe:
+                RPCCaller::<ExternalBatchGetLocalProbeReq>::new(),
             rpc_caller_external_batch_get_start: RPCCaller::<ExternalBatchGetStartReq>::new(),
             rpc_caller_external_batch_get_transfer: RPCCaller::<ExternalBatchGetTransferReq>::new(),
             rpc_caller_external_batch_get_cancel: RPCCaller::<ExternalBatchGetCancelReq>::new(),
             rpc_caller_master_batch_get_start: RPCCaller::<BatchGetStartReq>::new(),
+            rpc_caller_master_batch_get_plan: RPCCaller::<BatchGetPlanReq>::new(),
+            rpc_caller_master_batch_get_bind: RPCCaller::<BatchGetBindReq>::new(),
             rpc_caller_master_batch_get_done: RPCCaller::<BatchGetDoneReq>::new(),
             rpc_caller_master_batch_get_revoke: RPCCaller::<BatchGetRevokeReq>::new(),
+            rpc_caller_external_execute_planned_get: RPCCaller::<ExternalExecutePlannedGetReq>::new(
+            ),
             rpc_caller_external_put_commit: RPCCaller::<ExternalPutCommitReq>::new(),
             rpc_caller_external_batch_put_commit: RPCCaller::<ExternalBatchPutCommitReq>::new(),
             rpc_caller_external_put_start: RPCCaller::<ExternalPutStartReq>::new(),
@@ -805,7 +1626,9 @@ impl ExternalClientApi {
             pending_external_get_start: DashMap::new(),
             pending_inline_external_get_start: DashMap::new(),
             next_gpu_get_handle: AtomicU64::new(1),
+            pending_external_get_plan: DashMap::new(),
             pending_external_gpu_get: DashMap::new(),
+            pending_external_planned_cpu_get: DashMap::new(),
             inflight1_per_key: SemaphoreMap::new(1, std::time::Duration::from_secs(120)),
             put_trace_log_window: Mutex::new(ExternalPutTraceLogWindow::new()),
             external_delete_ack_batch: ExternalDeleteAckBatchHandle::new(),
@@ -879,6 +1702,8 @@ impl ExternalClientApi {
         ext.rpc_caller_external_get.regist(ext.view.p2p_module());
         ext.rpc_caller_external_batch_get
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_batch_get_local_probe
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_batch_get_start
             .regist(ext.view.p2p_module());
         ext.rpc_caller_external_batch_get_transfer
@@ -887,10 +1712,16 @@ impl ExternalClientApi {
             .regist(ext.view.p2p_module());
         ext.rpc_caller_master_batch_get_start
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_master_batch_get_plan
+            .regist(ext.view.p2p_module());
+        ext.rpc_caller_master_batch_get_bind
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_master_batch_get_done
             .regist(ext.view.p2p_module());
         ext.rpc_caller_master_batch_get_revoke
             .regist(ext.view.p2p_module());
+        ext.rpc_caller_external_execute_planned_get
+            .regist(ext.view.p2p_module());
         ext.rpc_caller_external_put_commit
             .regist(ext.view.p2p_module());
         ext.rpc_caller_external_batch_put_commit
@@ -1147,8 +1978,7 @@ impl ExternalClientApi {
         );
         loop {
             let snapshot = ext.view.p2p_module().tier_snapshot();
-            let self_binding_ready = snapshot
-                .share_group_owner(&snapshot.self_peer_gen.peer_id)
+            let self_binding_ready = snapshot.share_group_owner(&snapshot.self_peer_gen.peer_id)
                 == Some(&expected_binding);
             if self_binding_ready
                 && let Some(peer_gen) = snapshot.peer_gen(&owner_node_id)
@@ -2366,82 +3196,806 @@ impl ExternalInner {
                 ),
             }));
         }
-        for (expected_get_id, item) in expected_get_ids
-            .into_iter()
-            .zip(resp.serialize_part.items.into_iter())
+        for (expected_get_id, item) in expected_get_ids
+            .into_iter()
+            .zip(resp.serialize_part.items.into_iter())
+        {
+            if item.get_id != expected_get_id {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "GPU Get BatchRevoke response identity mismatch: expected={} got={}",
+                        expected_get_id, item.get_id
+                    ),
+                }));
+            }
+            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)?;
+        }
+        Ok(())
+    }
+
+    async fn master_batch_gpu_get_done(&self, get_ids: Vec<u64>) -> KvResult<()> {
+        if get_ids.is_empty() {
+            return Ok(());
+        }
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let expected_get_ids = get_ids.clone();
+        let resp: MsgPack<BatchGetDoneResp> = self
+            .rpc_caller_master_batch_get_done
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: BatchGetDoneReq { get_ids },
+                    raw_bytes: Vec::new(),
+                },
+                None,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        if resp.serialize_part.items.len() != expected_get_ids.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "GPU Get BatchDone response length mismatch: expected={} got={}",
+                    expected_get_ids.len(),
+                    resp.serialize_part.items.len()
+                ),
+            }));
+        }
+        for (expected_get_id, item) in expected_get_ids
+            .into_iter()
+            .zip(resp.serialize_part.items.into_iter())
+        {
+            if item.get_id != expected_get_id {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "GPU Get BatchDone response identity mismatch: expected={} got={}",
+                        expected_get_id, item.get_id
+                    ),
+                }));
+            }
+            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)?;
+            if item.holder_id != 0 || item.allocation_mode != GetAllocationMode::ExternalSink {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "GPU Get BatchDone returned a cache-owned target: get_id={} holder_id={} allocation_mode={:?}",
+                        item.get_id, item.holder_id, item.allocation_mode
+                    ),
+                }));
+            }
+        }
+        Ok(())
+    }
+
+    async fn master_batch_get_bind_external(
+        &self,
+        plan_items: &[BatchGetPlanItemResp],
+        destinations: &[ExternalGpuDestination],
+        requester_node_start_time: i64,
+    ) -> KvResult<Vec<BatchGetStartItemResp>> {
+        if plan_items.len() != destinations.len() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "external GetBind plan/destination length mismatch: plan={} destinations={}",
+                    plan_items.len(),
+                    destinations.len()
+                ),
+            }));
+        }
+        let items = plan_items
+            .iter()
+            .zip(destinations)
+            .map(|(plan, destination)| BatchGetBindItemReq {
+                get_id: plan.get_id,
+                target: GetBindTarget::ExternalSink(GetExternalSinkTarget {
+                    addr: destination.addr,
+                    capacity: destination.capacity,
+                    registration_id: destination.registration_id,
+                    requester_node_start_time,
+                }),
+            })
+            .collect();
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let response: MsgPack<BatchGetBindResp> = self
+            .rpc_caller_master_batch_get_bind
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: BatchGetBindReq { items },
+                    raw_bytes: Vec::new(),
+                },
+                None,
+                0,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            response.serialize_part.error_code,
+            response.serialize_part.error_json.clone(),
+        )?;
+        if response.serialize_part.items.len() != plan_items.len() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "external GetBind response length mismatch: expected={} got={}",
+                    plan_items.len(),
+                    response.serialize_part.items.len()
+                ),
+            }));
+        }
+        for (plan, bound) in plan_items.iter().zip(&response.serialize_part.items) {
+            if bound.get_id != plan.get_id {
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "external GetBind response identity mismatch: expected={} got={}",
+                        plan.get_id, bound.get_id
+                    ),
+                }));
+            }
+            crate::rpcresp_kvresult_convert::try_from_code(
+                bound.error_code,
+                bound.error_json.clone(),
+            )?;
+        }
+        Ok(response.serialize_part.items)
+    }
+
+    async fn probe_owner_local_gets(
+        &self,
+        plan_handle: u64,
+        keys: &[String],
+    ) -> KvResult<Vec<Option<Arc<ExternalMemHolder>>>> {
+        let mut previous_owner_start_time = self.current_owner_start_time().await;
+        let mut recover_attempts = 0usize;
+        loop {
+            let (owner, owner_start_time, _, base_ptr, mapped_len) =
+                self.wait_current_owner_mapped_range().await?;
+            let request = MsgPack {
+                serialize_part: ExternalBatchGetLocalProbeReq {
+                    plan_handle,
+                    keys: keys.to_vec(),
+                    req_node_id: self.view.cluster_manager().get_self_info().id.clone(),
+                    started_time: owner_start_time,
+                },
+                raw_bytes: Vec::new(),
+            };
+            let response: MsgPack<ExternalBatchGetLocalProbeResp> = match self
+                .rpc_caller_external_batch_get_local_probe
+                .call(self.view.p2p_module(), owner.into(), request, None, 0)
+                .await
+            {
+                Ok(response) => response,
+                Err(error) => {
+                    let error = KvError::from(error);
+                    if matches!(&error, KvError::P2p(_))
+                        && recover_attempts < EXTERNAL_RPC_P2P_RECOVER_MAX_ATTEMPTS
+                    {
+                        recover_attempts += 1;
+                        let _ = self
+                            .recover_after_p2p_error(&mut previous_owner_start_time)
+                            .await?;
+                        continue;
+                    }
+                    return Err(error);
+                }
+            };
+            if response.serialize_part.error_code != OK {
+                let error = KvError::from_json(
+                    response.serialize_part.error_code,
+                    &response.serialize_part.error_json,
+                );
+                if matches!(
+                    &error,
+                    KvError::Api(ApiError::OwnerStartTimeMismatch { .. })
+                ) {
+                    let _ = self
+                        .recover_after_owner_start_time_mismatch(&mut previous_owner_start_time)
+                        .await?;
+                    continue;
+                }
+                return Err(error);
+            }
+            let infos = response.serialize_part.items;
+            let release_infos = |infos: &[Option<crate::memholder::ExternalMemHolderInfo>]| {
+                let external_client_id = self.view.cluster_manager().get_self_info().id.clone();
+                for info in infos.iter().flatten() {
+                    if let Err(error) = self.enqueue_external_delete_ack(
+                        external_client_id.clone(),
+                        info.holder_id,
+                        owner_start_time,
+                    ) {
+                        tracing::warn!(
+                            plan_handle,
+                            holder_id = info.holder_id,
+                            %error,
+                            "owner-local Get probe cleanup enqueue failed"
+                        );
+                    }
+                }
+            };
+            if infos.len() != keys.len() {
+                release_infos(&infos);
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "owner-local Get probe length mismatch: expected={} got={}",
+                        keys.len(),
+                        infos.len()
+                    ),
+                }));
+            }
+            let mut holders = Vec::with_capacity(keys.len());
+            for (index, (key, info)) in keys.iter().zip(&infos).enumerate() {
+                let Some(info) = info else {
+                    holders.push(None);
+                    continue;
+                };
+                let Some(end) = info.offset.checked_add(u64::from(info.len)) else {
+                    release_infos(&infos);
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "owner-local Get probe range overflow: index={} offset={} len={}",
+                            index, info.offset, info.len
+                        ),
+                    }));
+                };
+                if end > mapped_len {
+                    release_infos(&infos);
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "owner-local Get probe exceeds owner mapping: index={} end={} mapped_len={}",
+                            index, end, mapped_len
+                        ),
+                    }));
+                }
+                let Some(pointer) = base_ptr.checked_add(info.offset) else {
+                    release_infos(&infos);
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "owner-local Get probe pointer overflow: index={} base={:#x} offset={}",
+                            index, base_ptr, info.offset
+                        ),
+                    }));
+                };
+                let holder = Arc::new(ExternalMemHolder::new(
+                    info.offset,
+                    pointer,
+                    info.len,
+                    info.holder_id,
+                    key.clone(),
+                    self.view.cluster_manager().get_self_info().id.clone(),
+                    self.view.clone(),
+                    owner_start_time,
+                ));
+                self.key_weak_memholder_index
+                    .insert(key.clone(), Arc::downgrade(&holder));
+                holders.push(Some(holder));
+            }
+            return Ok(holders);
+        }
+    }
+
+    pub async fn get_plan(
+        &self,
+        keys: Vec<String>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+    ) -> KvResult<ExternalGetPlanResp> {
+        if keys.is_empty() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "get_plan requires at least one key".to_string(),
+            }));
+        }
+        let group_lens = normalize_external_get_start_group_lens(keys.len(), atomic_group_lens)?;
+        let self_info = self.view.cluster_manager().get_self_info();
+        if self_info.node_role() != NodeRole::External {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "get_plan is supported only in external-client mode".to_string(),
+            }));
+        }
+        let handle = self.next_gpu_get_handle.fetch_add(1, Ordering::Relaxed);
+        if handle == 0 {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: "get_plan local handle space exhausted".to_string(),
+            }));
+        }
+
+        // Resolve and pin owner-local pages before consulting the cluster
+        // directory. Only the remaining positions are remote plan work.
+        let local_holders = self.probe_owner_local_gets(handle, &keys).await?;
+        let remote_keys = keys
+            .iter()
+            .zip(&local_holders)
+            .filter_map(|(key, local)| local.is_none().then_some(key.clone()))
+            .collect::<Vec<_>>();
+        let plan_items = if remote_keys.is_empty() {
+            Vec::new()
+        } else {
+            let master_node_id = self
+                .view
+                .cluster_manager()
+                .find_or_wait_master_node()
+                .await?;
+            let response: MsgPack<BatchGetPlanResp> = self
+                .rpc_caller_master_batch_get_plan
+                .call(
+                    self.view.p2p_module(),
+                    master_node_id.into(),
+                    MsgPack {
+                        serialize_part: BatchGetPlanReq {
+                            keys: remote_keys.clone(),
+                        },
+                        raw_bytes: Vec::new(),
+                    },
+                    None,
+                    0,
+                )
+                .await
+                .map_err(KvError::from)?;
+            crate::rpcresp_kvresult_convert::try_from_code(
+                response.serialize_part.error_code,
+                response.serialize_part.error_json.clone(),
+            )?;
+            response.serialize_part.items
+        };
+        let started_get_ids = plan_items
+            .iter()
+            .filter(|item| item.error_code == OK)
+            .map(|item| item.get_id)
+            .collect::<Vec<_>>();
+        let mut cleanup_guard = PlannedGetRevokeGuard::new(
+            self.view.clone_view(),
+            started_get_ids.clone(),
+            "get_plan abandoned",
+        );
+        if plan_items.len() != remote_keys.len() {
+            let cleanup = finish_planned_get_revoke_cleanup(
+                self.view.clone_view(),
+                started_get_ids,
+                "get_plan shape failure",
+            )
+            .await
+            .err()
+            .map(|err| err.to_string());
+            if cleanup.is_none() {
+                cleanup_guard.disarm();
+            }
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "get_plan response length mismatch: expected={} got={} cleanup_error={cleanup:?}",
+                    remote_keys.len(),
+                    plan_items.len()
+                ),
+            }));
+        }
+        for item in &plan_items {
+            if item.error_code != OK
+                && item.error_code
+                    != crate::rpcresp_kvresult_convert::msg_and_error::codes_api::API_KEY_NOT_FOUND
+            {
+                let error = crate::rpcresp_kvresult_convert::try_from_code(
+                    item.error_code,
+                    item.error_json.clone(),
+                )
+                .expect_err("non-OK GetPlan item must decode as an error");
+                let cleanup = finish_planned_get_revoke_cleanup(
+                    self.view.clone_view(),
+                    started_get_ids,
+                    "get_plan item failure",
+                )
+                .await
+                .err()
+                .map(|err| err.to_string());
+                if cleanup.is_none() {
+                    cleanup_guard.disarm();
+                }
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "get_plan item failed: error={} cleanup_error={cleanup:?}",
+                        error
+                    ),
+                }));
+            }
+        }
+        let mut remote_items = plan_items.into_iter();
+        let mut combined_items = Vec::with_capacity(keys.len());
+        for (key, local) in keys.iter().cloned().zip(local_holders) {
+            if let Some(holder) = local {
+                combined_items.push(PendingExternalGetPlanItem::Local { holder });
+            } else {
+                let plan = remote_items
+                    .next()
+                    .expect("validated remote plan shape must cover every remote key");
+                combined_items.push(PendingExternalGetPlanItem::Remote { key, plan });
+            }
+        }
+        assert!(remote_items.next().is_none());
+        let (raw_prefix_hit_len, gpu_raw_prefix_hit_len) =
+            external_get_plan_raw_prefixes_from_statuses(combined_items.iter().map(
+                |item| match item {
+                    PendingExternalGetPlanItem::Local { .. } => (true, true),
+                    PendingExternalGetPlanItem::Remote { plan, .. } => {
+                        (plan.error_code == OK, plan.gpu_direct_eligible)
+                    }
+                },
+            ));
+        let transferable_len = compute_external_get_start_transfer_prefix(
+            raw_prefix_hit_len,
+            &group_lens,
+            prefix_best_effort,
+        );
+        let gpu_transferable_len = compute_external_get_start_transfer_prefix(
+            gpu_raw_prefix_hit_len,
+            &group_lens,
+            prefix_best_effort,
+        );
+        let kept_ids = combined_items[..transferable_len]
+            .iter()
+            .filter_map(|item| match item {
+                PendingExternalGetPlanItem::Remote { plan, .. } => Some(plan.get_id),
+                PendingExternalGetPlanItem::Local { .. } => None,
+            })
+            .collect::<std::collections::HashSet<_>>();
+        let skipped_get_ids = started_get_ids
+            .iter()
+            .copied()
+            .filter(|get_id| !kept_ids.contains(get_id))
+            .collect::<Vec<_>>();
+        if let Err(err) = self.master_batch_gpu_get_revoke(skipped_get_ids).await {
+            return Err(err);
+        }
+        combined_items.truncate(transferable_len);
+        let gpu_remote_indices = combined_items
+            .iter()
+            .take(gpu_transferable_len)
+            .enumerate()
+            .filter_map(|(index, item)| {
+                matches!(item, PendingExternalGetPlanItem::Remote { .. }).then_some(index)
+            })
+            .collect::<Vec<_>>();
+        self.pending_external_get_plan.insert(
+            handle,
+            PendingExternalGetPlan {
+                items: combined_items,
+                transferable_len,
+                gpu_transferable_len,
+                gpu_remote_indices: gpu_remote_indices.clone(),
+                atomic_group_lens: group_lens,
+            },
+        );
+        cleanup_guard.disarm();
+        Ok(ExternalGetPlanResp {
+            handle,
+            raw_prefix_hit_len,
+            gpu_raw_prefix_hit_len,
+            gpu_remote_indices,
+        })
+    }
+
+    pub async fn cancel_get_plan(&self, handle: u64) -> KvResult<()> {
+        let Some((_handle, plan)) = self.pending_external_get_plan.remove(&handle) else {
+            return Ok(());
+        };
+        finish_planned_get_revoke_cleanup(
+            self.view.clone_view(),
+            plan.items
+                .into_iter()
+                .filter_map(|item| match item {
+                    PendingExternalGetPlanItem::Remote { plan, .. } => Some(plan.get_id),
+                    PendingExternalGetPlanItem::Local { .. } => None,
+                })
+                .collect(),
+            "cancel_get_plan",
+        )
+        .await
+    }
+
+    pub async fn execute_get_plan_gpu(
+        &self,
+        handle: u64,
+        destinations: Vec<ExternalGpuDestination>,
+        consume_prefix_len: usize,
+        transfer_concurrency: usize,
+    ) -> KvResult<()> {
+        let Some((_handle, plan)) = self.pending_external_get_plan.remove(&handle) else {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!("execute_get_plan_gpu requires a live plan: {handle}"),
+            }));
+        };
+        let expected_remote_destinations = plan
+            .gpu_remote_indices
+            .iter()
+            .take_while(|index| **index < consume_prefix_len)
+            .count();
+        if transfer_concurrency == 0
+            || expected_remote_destinations == 0
+            || destinations.len() != expected_remote_destinations
+            || validate_external_get_consume_prefix(
+                consume_prefix_len,
+                plan.gpu_transferable_len,
+                &plan.atomic_group_lens,
+            )
+            .is_err()
+        {
+            self.pending_external_get_plan.insert(handle, plan);
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "execute_get_plan_gpu invalid consume/remote-destinations/concurrency: consume={} destinations={} expected_remote={} concurrency={}",
+                    consume_prefix_len,
+                    destinations.len(),
+                    expected_remote_destinations,
+                    transfer_concurrency
+                ),
+            }));
+        }
+        let self_info = self.view.cluster_manager().get_self_info();
+        let mut guards = Vec::with_capacity(destinations.len());
+        for destination in &destinations {
+            match self.view.client_transfer_engine().validate_gpu_destination(
+                destination.registration_id,
+                destination.addr,
+                destination.capacity,
+            ) {
+                Ok(guard) => guards.push(guard),
+                Err(err) => {
+                    self.pending_external_get_plan.insert(handle, plan);
+                    return Err(err);
+                }
+            }
+        }
+        let all_get_ids = plan
+            .items
+            .iter()
+            .filter_map(|item| match item {
+                PendingExternalGetPlanItem::Remote { plan, .. } => Some(plan.get_id),
+                PendingExternalGetPlanItem::Local { .. } => None,
+            })
+            .collect::<Vec<_>>();
+        let mut cleanup_guard = PlannedGetRevokeGuard::new(
+            self.view.clone_view(),
+            all_get_ids.clone(),
+            "execute_get_plan_gpu abandoned",
+        );
+        if plan
+            .items
+            .iter()
+            .any(|item| matches!(item, PendingExternalGetPlanItem::Local { .. }))
+        {
+            let (_, current_owner_start_time, _, base_ptr, mapped_len) =
+                self.wait_current_owner_mapped_range().await?;
+            for (index, item) in plan.items.iter().enumerate() {
+                if let PendingExternalGetPlanItem::Local { holder } = item {
+                    validate_external_local_holder_mapping(
+                        index,
+                        holder,
+                        current_owner_start_time,
+                        base_ptr,
+                        mapped_len,
+                    )?;
+                }
+            }
+        }
+        let PendingExternalGetPlan {
+            mut items,
+            atomic_group_lens,
+            ..
+        } = plan;
+        let tail_items = items.split_off(consume_prefix_len);
+        let skipped_get_ids = tail_items
+            .into_iter()
+            .filter_map(|item| match item {
+                PendingExternalGetPlanItem::Remote { plan, .. } => Some(plan.get_id),
+                PendingExternalGetPlanItem::Local { .. } => None,
+            })
+            .collect::<Vec<_>>();
+        let mut remote_plans = Vec::with_capacity(destinations.len());
+        let mut local_holders = Vec::new();
+        let mut value_ptrs = Vec::with_capacity(consume_prefix_len);
+        let mut destination_index = 0usize;
+        for (source_index, item) in items.into_iter().enumerate() {
+            match item {
+                PendingExternalGetPlanItem::Local { holder, .. } => {
+                    // The exact owner mapping was validated immediately above.
+                    // Keep the saved address opaque until SGLang submits the
+                    // restore; constructing a slice here would dereference a
+                    // mapping that could become stale after an owner restart.
+                    value_ptrs.push(holder.addr);
+                    local_holders.push((source_index, holder));
+                }
+                PendingExternalGetPlanItem::Remote { plan, .. } => {
+                    let destination = &destinations[destination_index];
+                    value_ptrs.push(destination.addr);
+                    remote_plans.push(plan);
+                    destination_index += 1;
+                }
+            }
+        }
+        assert_eq!(destination_index, destinations.len());
+        let bound_items = match self
+            .master_batch_get_bind_external(&remote_plans, &destinations, self_info.node_start_time)
+            .await
         {
-            if item.get_id != expected_get_id {
+            Ok(items) => items,
+            Err(err) => {
+                let cleanup = finish_planned_get_revoke_cleanup(
+                    self.view.clone_view(),
+                    all_get_ids,
+                    "execute_get_plan_gpu bind failure",
+                )
+                .await
+                .err()
+                .map(|cleanup_err| cleanup_err.to_string());
+                if cleanup.is_none() {
+                    cleanup_guard.disarm();
+                }
                 return Err(KvError::Api(ApiError::Unknown {
                     detail: format!(
-                        "GPU Get BatchRevoke response identity mismatch: expected={} got={}",
-                        expected_get_id, item.get_id
+                        "execute_get_plan_gpu bind failed: error={} cleanup_error={cleanup:?}",
+                        err
                     ),
                 }));
             }
-            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)?;
+        };
+        let mut transfer_items = Vec::with_capacity(destinations.len());
+        for (index, (((planned, bound), destination), guard)) in remote_plans
+            .iter()
+            .zip(bound_items)
+            .zip(destinations.iter())
+            .zip(guards)
+            .enumerate()
+        {
+            if bound.node_id != planned.node_id
+                || bound.src_addr != planned.src_addr
+                || bound.src_base_addr != planned.src_base_addr
+                || bound.len != planned.len
+                || !external_gpu_transfer_plan_geometry_is_valid(
+                    &bound,
+                    destination,
+                    guard.registration().registration_id,
+                )
+                || bound.node_id == self_info.id
+            {
+                let cleanup = finish_planned_get_revoke_cleanup(
+                    self.view.clone_view(),
+                    all_get_ids,
+                    "execute_get_plan_gpu changed bind",
+                )
+                .await
+                .err()
+                .map(|cleanup_err| cleanup_err.to_string());
+                if cleanup.is_none() {
+                    cleanup_guard.disarm();
+                }
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "execute_get_plan_gpu received a changed bind plan at index={index}; cleanup_error={cleanup:?}"
+                    ),
+                }));
+            }
+            transfer_items.push((bound, guard));
         }
+        let cancel_requested = Arc::new(AtomicBool::new(false));
+        let (terminal_tx, terminal_rx) = watch::channel(None);
+        let transfer_started_at = Instant::now();
+        self.pending_external_gpu_get.insert(
+            handle,
+            PendingExternalGpuGet {
+                transferable_len: consume_prefix_len,
+                atomic_group_lens,
+                value_ptrs,
+                local_holders,
+                cancel_requested: cancel_requested.clone(),
+                transfer_started_at,
+                terminal_rx,
+            },
+        );
+        let view = self.view.clone_view();
+        let task_view = view.clone();
+        view.spawn(format!("external_gpu_get_execute_{handle}"), async move {
+            let terminal = run_external_gpu_get_transfer_timed(
+                task_view,
+                transfer_items,
+                skipped_get_ids,
+                transfer_concurrency,
+                cancel_requested,
+            )
+            .await;
+            let _ = terminal_tx.send(Some(terminal));
+        });
+        cleanup_guard.disarm();
         Ok(())
     }
 
-    async fn master_batch_gpu_get_done(&self, get_ids: Vec<u64>) -> KvResult<()> {
-        if get_ids.is_empty() {
-            return Ok(());
-        }
-        let master_node_id = self
-            .view
-            .cluster_manager()
-            .find_or_wait_master_node()
-            .await?;
-        let expected_get_ids = get_ids.clone();
-        let resp: MsgPack<BatchGetDoneResp> = self
-            .rpc_caller_master_batch_get_done
-            .call(
-                self.view.p2p_module(),
-                master_node_id.into(),
-                MsgPack {
-                    serialize_part: BatchGetDoneReq { get_ids },
-                    raw_bytes: Vec::new(),
-                },
-                None,
-                0,
+    pub async fn execute_get_plan_cpu(
+        &self,
+        handle: u64,
+        consume_prefix_len: usize,
+        transfer_concurrency: usize,
+    ) -> KvResult<()> {
+        let Some((_handle, plan)) = self.pending_external_get_plan.remove(&handle) else {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!("execute_get_plan_cpu requires a live plan: {handle}"),
+            }));
+        };
+        if transfer_concurrency == 0
+            || validate_external_get_consume_prefix(
+                consume_prefix_len,
+                plan.transferable_len,
+                &plan.atomic_group_lens,
             )
-            .await
-            .map_err(KvError::from)?;
-        crate::rpcresp_kvresult_convert::try_from_code(
-            resp.serialize_part.error_code,
-            resp.serialize_part.error_json.clone(),
-        )?;
-        if resp.serialize_part.items.len() != expected_get_ids.len() {
-            return Err(KvError::Api(ApiError::Unknown {
+            .is_err()
+        {
+            self.pending_external_get_plan.insert(handle, plan);
+            return Err(KvError::Api(ApiError::InvalidArgument {
                 detail: format!(
-                    "GPU Get BatchDone response length mismatch: expected={} got={}",
-                    expected_get_ids.len(),
-                    resp.serialize_part.items.len()
+                    "execute_get_plan_cpu invalid consume/concurrency: consume={} concurrency={}",
+                    consume_prefix_len, transfer_concurrency
                 ),
             }));
         }
-        for (expected_get_id, item) in expected_get_ids
+        let PendingExternalGetPlan {
+            mut items,
+            atomic_group_lens,
+            ..
+        } = plan;
+        let tail_items = items.split_off(consume_prefix_len);
+        let skipped_get_ids = tail_items
             .into_iter()
-            .zip(resp.serialize_part.items.into_iter())
-        {
-            if item.get_id != expected_get_id {
-                return Err(KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "GPU Get BatchDone response identity mismatch: expected={} got={}",
-                        expected_get_id, item.get_id
-                    ),
-                }));
-            }
-            crate::rpcresp_kvresult_convert::try_from_code(item.error_code, item.error_json)?;
-            if item.holder_id != 0 || item.allocation_mode != GetAllocationMode::ExternalSink {
-                return Err(KvError::Api(ApiError::Unknown {
-                    detail: format!(
-                        "GPU Get BatchDone returned a cache-owned target: get_id={} holder_id={} allocation_mode={:?}",
-                        item.get_id, item.holder_id, item.allocation_mode
-                    ),
-                }));
+            .filter_map(|item| match item {
+                PendingExternalGetPlanItem::Remote { plan, .. } => Some(plan.get_id),
+                PendingExternalGetPlanItem::Local { .. } => None,
+            })
+            .collect();
+        let mut plan_items = Vec::new();
+        let mut sources = Vec::with_capacity(consume_prefix_len);
+        for item in items {
+            match item {
+                PendingExternalGetPlanItem::Local { holder, .. } => {
+                    sources.push(PendingExternalCpuSource::Local { holder });
+                }
+                PendingExternalGetPlanItem::Remote { key, plan } => {
+                    plan_items.push((key.clone(), plan.get_id));
+                    sources.push(PendingExternalCpuSource::Remote { key });
+                }
             }
         }
+        let cancel_requested = Arc::new(AtomicBool::new(false));
+        let (terminal_tx, terminal_rx) = watch::channel(None);
+        self.pending_external_planned_cpu_get.insert(
+            handle,
+            PendingExternalPlannedCpuGet {
+                sources,
+                transferable_len: consume_prefix_len,
+                atomic_group_lens,
+                cancel_requested: cancel_requested.clone(),
+                terminal_rx,
+            },
+        );
+        let view = self.view.clone_view();
+        let task_view = view.clone();
+        view.spawn(format!("external_cpu_get_execute_{handle}"), async move {
+            let terminal = run_external_planned_cpu_get(
+                task_view,
+                handle,
+                plan_items,
+                skipped_get_ids,
+                transfer_concurrency,
+                cancel_requested,
+            )
+            .await;
+            let _ = terminal_tx.send(Some(terminal));
+        });
         Ok(())
     }
 
@@ -2647,19 +4201,27 @@ impl ExternalInner {
         }
         let cancel_requested = Arc::new(AtomicBool::new(false));
         let (terminal_tx, terminal_rx) = watch::channel(None);
+        let transfer_started_at = Instant::now();
         self.pending_external_gpu_get.insert(
             handle,
             PendingExternalGpuGet {
                 transferable_len,
                 atomic_group_lens: group_lens,
+                value_ptrs: destinations
+                    .into_iter()
+                    .take(transferable_len)
+                    .map(|destination| destination.addr)
+                    .collect(),
+                local_holders: Vec::new(),
                 cancel_requested: cancel_requested.clone(),
+                transfer_started_at,
                 terminal_rx,
             },
         );
         let view = self.view.clone_view();
         let view_task = view.clone();
         view.spawn(format!("external_gpu_get_transfer_{handle}"), async move {
-            let terminal = run_external_gpu_get_transfer(
+            let terminal = run_external_gpu_get_transfer_timed(
                 view_task,
                 transfer_items,
                 skipped_get_ids,
@@ -2680,26 +4242,95 @@ impl ExternalInner {
         handle: u64,
         consume_prefix_len: Option<usize>,
     ) -> KvResult<ExternalGpuGetTransferResp> {
+        let consume_started_at = Instant::now();
         let Some((_, pending)) = self.pending_external_gpu_get.remove(&handle) else {
             return Err(KvError::Api(ApiError::InvalidArgument {
                 detail: format!("get_transfer_gpu requires a live handle: {handle}"),
             }));
         };
-        let consumed_prefix_len = consume_prefix_len.unwrap_or(pending.transferable_len);
+        let pending_guard =
+            PendingRegistryEntryGuard::new(&self.pending_external_gpu_get, handle, pending);
+        let consumed_prefix_len =
+            consume_prefix_len.unwrap_or(pending_guard.entry().transferable_len);
         if let Err(err) = validate_external_get_consume_prefix(
             consumed_prefix_len,
-            pending.transferable_len,
-            &pending.atomic_group_lens,
+            pending_guard.entry().transferable_len,
+            &pending_guard.entry().atomic_group_lens,
         ) {
-            self.pending_external_gpu_get.insert(handle, pending);
             return Err(err);
         }
-        let terminal = wait_external_gpu_get_terminal(pending.terminal_rx).await?;
-        match terminal {
-            ExternalGpuGetTerminal::Completed => Ok(ExternalGpuGetTransferResp {
-                transferred_prefix_len: pending.transferable_len,
-                consumed_prefix_len,
-            }),
+        let finish_wait_started_at = Instant::now();
+        let terminal_event =
+            match wait_external_gpu_get_terminal(pending_guard.entry().terminal_rx.clone()).await {
+                Ok(terminal) => terminal,
+                Err(err) => {
+                    let _ = pending_guard.take();
+                    return Err(err);
+                }
+            };
+        let finish_wait = finish_wait_started_at.elapsed();
+        let pending = pending_guard.take();
+        let timing = observe_external_gpu_get_consume_timing(
+            pending.transfer_started_at,
+            terminal_event.terminal_at,
+            consume_started_at,
+            finish_wait,
+        );
+        let outcome = match &terminal_event.outcome {
+            ExternalGpuGetTerminal::Completed => "completed",
+            ExternalGpuGetTerminal::Revoked { .. } => "revoked",
+            ExternalGpuGetTerminal::Failed { .. } => "failed",
+        };
+        tracing::info!(
+            "external GPU Get consume lifecycle: handle={} transferred={} consumed={} outcome={} transfer_wall_us={} terminal_before_consume={} terminal_to_consume_us={} finish_wait_us={}",
+            handle,
+            pending.transferable_len,
+            consumed_prefix_len,
+            outcome,
+            timing.transfer_wall_us,
+            timing.terminal_before_consume,
+            timing.terminal_to_consume_us,
+            timing.finish_wait_us,
+        );
+        match terminal_event.outcome {
+            ExternalGpuGetTerminal::Completed => {
+                assert_eq!(pending.value_ptrs.len(), pending.transferable_len);
+                if !pending.local_holders.is_empty() {
+                    let (_, current_owner_start_time, _, base_ptr, mapped_len) =
+                        self.wait_current_owner_mapped_range().await?;
+                    validate_external_local_holders_mapping(
+                        &pending.local_holders,
+                        current_owner_start_time,
+                        base_ptr,
+                        mapped_len,
+                    )?;
+                }
+                let bandwidth_handle = self
+                    .view
+                    .cluster_manager()
+                    .ipc_bandwidth_attributor_handle()
+                    .expect("GPU get_transfer expects an IPC bandwidth handle");
+                let local_holders = pending
+                    .local_holders
+                    .into_iter()
+                    .filter_map(|(index, holder)| {
+                        (index < consumed_prefix_len).then(|| {
+                            bandwidth_handle.record_tx_bytes(u64::from(holder.len));
+                            holder
+                        })
+                    })
+                    .collect();
+                Ok(ExternalGpuGetTransferResp {
+                    transferred_prefix_len: pending.transferable_len,
+                    consumed_prefix_len,
+                    value_ptrs: pending.value_ptrs[..consumed_prefix_len].to_vec(),
+                    local_holders,
+                    transfer_wall_us: timing.transfer_wall_us,
+                    finish_wait_us: timing.finish_wait_us,
+                    terminal_before_consume: timing.terminal_before_consume,
+                    terminal_to_consume_us: timing.terminal_to_consume_us,
+                })
+            }
             ExternalGpuGetTerminal::Revoked { transfer_error } => {
                 Err(KvError::Api(ApiError::Unknown {
                     detail: format!(
@@ -2719,7 +4350,10 @@ impl ExternalInner {
             return Ok(());
         };
         pending.cancel_requested.store(true, Ordering::Release);
-        match wait_external_gpu_get_terminal(pending.terminal_rx).await? {
+        match wait_external_gpu_get_terminal(pending.terminal_rx)
+            .await?
+            .outcome
+        {
             ExternalGpuGetTerminal::Completed | ExternalGpuGetTerminal::Revoked { .. } => Ok(()),
             ExternalGpuGetTerminal::Failed { detail } => {
                 Err(KvError::Api(ApiError::Unknown { detail }))
@@ -3241,6 +4875,212 @@ impl ExternalInner {
         handle: u64,
         consume_prefix_len: Option<usize>,
     ) -> KvResult<Vec<KvResult<Option<Arc<ExternalMemHolder>>>>> {
+        if let Some((_handle, pending)) = self.pending_external_planned_cpu_get.remove(&handle) {
+            let pending_guard = PendingRegistryEntryGuard::new(
+                &self.pending_external_planned_cpu_get,
+                handle,
+                pending,
+            );
+            let consumed_prefix_len =
+                consume_prefix_len.unwrap_or(pending_guard.entry().transferable_len);
+            if let Err(err) = validate_external_get_consume_prefix(
+                consumed_prefix_len,
+                pending_guard.entry().transferable_len,
+                &pending_guard.entry().atomic_group_lens,
+            ) {
+                return Err(err);
+            }
+            let terminal = match wait_external_planned_cpu_get_terminal(
+                pending_guard.entry().terminal_rx.clone(),
+            )
+            .await
+            {
+                Ok(terminal) => terminal,
+                Err(err) => {
+                    let _ = pending_guard.take();
+                    return Err(err);
+                }
+            };
+            let ExternalPlannedCpuGetTerminal::Completed {
+                items,
+                owner_start_time,
+            } = terminal
+            else {
+                let _ = pending_guard.take();
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: match terminal {
+                        ExternalPlannedCpuGetTerminal::Revoked => {
+                            format!("planned CPU Get was revoked: handle={handle}")
+                        }
+                        ExternalPlannedCpuGetTerminal::Failed { detail } => detail,
+                        ExternalPlannedCpuGetTerminal::Completed { .. } => unreachable!(),
+                    },
+                }));
+            };
+            let response = ExternalExecutePlannedGetResp {
+                items: items.clone(),
+                error_code: OK,
+                error_json: String::new(),
+            };
+            let expected_remote_items = pending_guard
+                .entry()
+                .sources
+                .iter()
+                .filter(|source| matches!(source, PendingExternalCpuSource::Remote { .. }))
+                .count();
+            if items.len() != expected_remote_items {
+                release_planned_cpu_response_holders(self, &response, owner_start_time);
+                let _ = pending_guard.take();
+                return Err(KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "planned CPU Get terminal remote length mismatch: expected={} got={}",
+                        expected_remote_items,
+                        items.len()
+                    ),
+                }));
+            }
+            let owner_snapshot = match self.wait_current_owner_mapped_range().await {
+                Ok(snapshot) => snapshot,
+                Err(err) => {
+                    release_planned_cpu_response_holders(self, &response, owner_start_time);
+                    let _ = pending_guard.take();
+                    return Err(err);
+                }
+            };
+            let (_, current_owner_start_time, _, base_ptr, mapped_len) = owner_snapshot;
+            if let Err(err) = validate_inline_external_get_owner_generation(
+                owner_start_time,
+                current_owner_start_time,
+            ) {
+                release_planned_cpu_response_holders(self, &response, owner_start_time);
+                let _ = pending_guard.take();
+                return Err(err);
+            }
+            if let Some(local) =
+                pending_guard
+                    .entry()
+                    .sources
+                    .iter()
+                    .find_map(|source| match source {
+                        PendingExternalCpuSource::Local { holder }
+                            if holder.owner_start_time != current_owner_start_time =>
+                        {
+                            Some(holder.owner_start_time)
+                        }
+                        _ => None,
+                    })
+            {
+                release_planned_cpu_response_holders(self, &response, owner_start_time);
+                let _ = pending_guard.take();
+                return Err(KvError::Api(ApiError::OwnerStartTimeMismatch {
+                    expected: current_owner_start_time,
+                    got: local,
+                }));
+            }
+            for (index, item) in items.iter().enumerate() {
+                let Some(info) = item.external_memholder_info.as_ref() else {
+                    release_planned_cpu_response_holders(self, &response, owner_start_time);
+                    let _ = pending_guard.take();
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "planned CPU Get terminal remote item has no holder: index={index}"
+                        ),
+                    }));
+                };
+                let Some(end) = info.offset.checked_add(u64::from(info.len)) else {
+                    release_planned_cpu_response_holders(self, &response, owner_start_time);
+                    let _ = pending_guard.take();
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "planned CPU Get holder range overflow: index={} offset={} len={}",
+                            index, info.offset, info.len
+                        ),
+                    }));
+                };
+                if end > mapped_len {
+                    release_planned_cpu_response_holders(self, &response, owner_start_time);
+                    let _ = pending_guard.take();
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "planned CPU Get holder exceeds owner mapping: index={} end={} mapped_len={}",
+                            index, end, mapped_len
+                        ),
+                    }));
+                }
+                if base_ptr.checked_add(info.offset).is_none() {
+                    release_planned_cpu_response_holders(self, &response, owner_start_time);
+                    let _ = pending_guard.take();
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "planned CPU Get holder pointer overflow: index={} base={:#x} offset={}",
+                            index, base_ptr, info.offset
+                        ),
+                    }));
+                }
+            }
+            let mut pending = pending_guard.take();
+            let consumed_remote_items = pending.sources[..consumed_prefix_len]
+                .iter()
+                .filter(|source| matches!(source, PendingExternalCpuSource::Remote { .. }))
+                .count();
+            for item in items.iter().skip(consumed_remote_items) {
+                let info = item
+                    .external_memholder_info
+                    .as_ref()
+                    .expect("validated planned CPU remote item must have a holder");
+                if let Err(detail) = self.enqueue_external_delete_ack(
+                    self.view.cluster_manager().get_self_info().id.clone(),
+                    info.holder_id,
+                    owner_start_time,
+                ) {
+                    release_planned_cpu_response_holders(self, &response, owner_start_time);
+                    return Err(KvError::Api(ApiError::Unknown { detail }));
+                }
+            }
+            pending.sources.truncate(consumed_prefix_len);
+            let bandwidth_handle = self
+                .view
+                .cluster_manager()
+                .ipc_bandwidth_attributor_handle()
+                .expect("planned CPU get_transfer expects an IPC bandwidth handle");
+            let external_client_id = self.view.cluster_manager().get_self_info().id.clone();
+            let mut remote_items = items.into_iter();
+            let mut results = Vec::with_capacity(consumed_prefix_len);
+            for source in pending.sources {
+                match source {
+                    PendingExternalCpuSource::Local { holder } => {
+                        bandwidth_handle.record_tx_bytes(u64::from(holder.len));
+                        results.push(Ok(Some(holder)));
+                    }
+                    PendingExternalCpuSource::Remote { key } => {
+                        let item = remote_items
+                            .next()
+                            .expect("validated remote terminal must match source positions");
+                        let info = item
+                            .external_memholder_info
+                            .expect("validated planned CPU remote item must have a holder");
+                        let holder_ptr = base_ptr
+                            .checked_add(info.offset)
+                            .expect("validated planned CPU holder pointer must not overflow");
+                        bandwidth_handle.record_tx_bytes(u64::from(info.len));
+                        let holder = Arc::new(ExternalMemHolder::new(
+                            info.offset,
+                            holder_ptr,
+                            info.len,
+                            info.holder_id,
+                            key.clone(),
+                            external_client_id.clone(),
+                            self.view.clone(),
+                            owner_start_time,
+                        ));
+                        self.key_weak_memholder_index
+                            .insert(key, Arc::downgrade(&holder));
+                        results.push(Ok(Some(holder)));
+                    }
+                }
+            }
+            return Ok(results);
+        }
         let Some((_handle, entry)) = self.pending_external_get_start.remove(&handle) else {
             return Err(KvError::Api(ApiError::InvalidArgument {
                 detail: format!("get_transfer requires a live get-start handle: {}", handle),
@@ -3281,6 +5121,33 @@ impl ExternalInner {
     }
 
     pub async fn cancel_get_transfer(&self, handle: u64) -> KvResult<()> {
+        if self.pending_external_get_plan.contains_key(&handle) {
+            return self.cancel_get_plan(handle).await;
+        }
+        if let Some((_handle, pending)) = self.pending_external_planned_cpu_get.remove(&handle) {
+            pending.cancel_requested.store(true, Ordering::Release);
+            return match wait_external_planned_cpu_get_terminal(pending.terminal_rx).await? {
+                ExternalPlannedCpuGetTerminal::Revoked => Ok(()),
+                ExternalPlannedCpuGetTerminal::Completed {
+                    items,
+                    owner_start_time,
+                } => {
+                    release_planned_cpu_response_holders(
+                        self,
+                        &ExternalExecutePlannedGetResp {
+                            items,
+                            error_code: OK,
+                            error_json: String::new(),
+                        },
+                        owner_start_time,
+                    );
+                    Ok(())
+                }
+                ExternalPlannedCpuGetTerminal::Failed { detail } => {
+                    Err(KvError::Api(ApiError::Unknown { detail }))
+                }
+            };
+        }
         let removed = self.pending_external_get_start.remove(&handle);
         if removed.is_none() {
             return Err(KvError::Api(ApiError::InvalidArgument {
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 46c8e2f..533127d 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -3,12 +3,13 @@ use super::{
     MasterKeyActivityCompletionGuard, MasterKvRouterView, OwnerHoldingGetInfo,
     ReservedCapacityReason,
     msg_pack::{
-        BatchGetDoneItemResp, BatchGetDoneReq, BatchGetDoneResp, BatchGetRevokeItemResp,
-        BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
-        BatchGetStartResp, BatchIsExistReq, BatchIsExistResp, GetAllocationMode, GetDoneReq,
-        GetDoneResp, GetExternalSinkTarget, GetMetaReq, GetMetaResp, GetPreparedLocalReserveTarget,
-        GetRevokeReq, GetRevokeResp, GetStartReq, GetStartResp, MemHolderKeepAliveReq,
-        MemHolderKeepAliveResp, MemHolderReleaseReq, MemHolderReleaseResp,
+        BatchGetBindItemReq, BatchGetBindReq, BatchGetBindResp, BatchGetDoneItemResp,
+        BatchGetDoneReq, BatchGetDoneResp, BatchGetPlanItemResp, BatchGetPlanReq, BatchGetPlanResp,
+        BatchGetRevokeItemResp, BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp,
+        BatchGetStartReq, BatchGetStartResp, BatchIsExistReq, BatchIsExistResp, GetAllocationMode,
+        GetBindTarget, GetDoneReq, GetDoneResp, GetExternalSinkTarget, GetMetaReq, GetMetaResp,
+        GetPreparedLocalReserveTarget, GetRevokeReq, GetRevokeResp, GetStartReq, GetStartResp,
+        MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq, MemHolderReleaseResp,
     },
     node_generation_is_current_live, publish_route_replica_tomb_fenced,
     route_maintenance::{RoutePublishEvent, apply_post_route_maintenance_batch},
@@ -240,6 +241,631 @@ fn validate_external_sink_target(
     Ok(())
 }
 
+fn get_plan_item_error(err: &msg_and_error::KvError) -> BatchGetPlanItemResp {
+    let response: GetStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(err);
+    BatchGetPlanItemResp {
+        error_code: response.error_code,
+        error_json: response.error_json,
+        ..Default::default()
+    }
+}
+
+fn get_bind_item_error(get_id: u64, err: &msg_and_error::KvError) -> BatchGetStartItemResp {
+    let response: GetStartResp = crate::rpcresp_kvresult_convert::FromError::from_error(err);
+    BatchGetStartItemResp {
+        get_id,
+        error_code: response.error_code,
+        error_json: response.error_json,
+        ..Default::default()
+    }
+}
+
+#[derive(Clone)]
+struct PlannedGetSourceSnapshot {
+    node_id: NodeID,
+    tomb_tag: crate::master_seg_manager::NodeTombTag,
+    len: u64,
+    addr: u64,
+    base_addr: u64,
+}
+
+fn snapshot_live_get_sources(route: &OneKvNodesRoutes) -> Vec<PlannedGetSourceSnapshot> {
+    route
+        .nodes_replicas
+        .read()
+        .values()
+        .filter(|replica| !replica.tomb_tag.is_tomb())
+        .map(|replica| PlannedGetSourceSnapshot {
+            node_id: replica.node_id.clone(),
+            tomb_tag: replica.tomb_tag.clone(),
+            len: replica.backing.len(),
+            addr: replica.backing.abs_addr(),
+            base_addr: replica.backing.base_addr(),
+        })
+        .collect()
+}
+
+fn planned_get_source_is_current(
+    planned: &super::PlannedGetInfo,
+    route: &Arc<OneKvNodesRoutes>,
+) -> bool {
+    if planned.src_tomb_tag.is_tomb() || route.put_id != planned.put_id {
+        return false;
+    }
+    route
+        .nodes_replicas
+        .read()
+        .get(&planned.src_node_id)
+        .is_some_and(|replica| {
+            !replica.tomb_tag.is_tomb()
+                && replica.tomb_tag.same_generation(&planned.src_tomb_tag)
+                && replica.backing.abs_addr() == planned.src_addr
+                && replica.backing.base_addr() == planned.src_base_addr
+                && replica.backing.len() == planned.len
+        })
+}
+
+#[cfg(test)]
+mod planned_get_tests {
+    use super::{planned_get_source_is_current, snapshot_live_get_sources};
+    use crate::cluster_manager::NodeID;
+    use crate::master_kv_router::{
+        CommittedSlotReplica, KvReplicaBacking, KvRouteInfo, OneKvNodesRoutes, PlannedGetInfo,
+    };
+    use crate::master_seg_manager::NodeTombTag;
+    use parking_lot::RwLock;
+    use std::collections::HashMap;
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicU32;
+
+    fn planned_route() -> (PlannedGetInfo, Arc<OneKvNodesRoutes>, NodeTombTag) {
+        let source: NodeID = "source".to_string().into();
+        let source_tag = NodeTombTag::new();
+        let route = Arc::new(OneKvNodesRoutes {
+            put_id: (7, 3),
+            lease_id: None,
+            atomic_group: None,
+            nodes_replicas: RwLock::new(HashMap::from([(
+                source.clone(),
+                KvRouteInfo {
+                    node_id: source.clone(),
+                    backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                        owner_node_id: source.clone(),
+                        grant_id: 11,
+                        slot_index: 2,
+                        slot_size: 8192,
+                        addr: 0x3000,
+                        len: 4096,
+                        base_addr: 0x1000,
+                    }),
+                    owner_local_indexed: true,
+                    get_durable_reservation: None,
+                    capacity_reservation: None,
+                    tomb_tag: source_tag.clone(),
+                },
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        let planned = PlannedGetInfo {
+            put_id: route.put_id,
+            src_node_id: source,
+            src_tomb_tag: source_tag.clone(),
+            key: "key".to_string(),
+            controller_node_id: "external".to_string().into(),
+            controller_node_start_time: 17,
+            len: 4096,
+            src_addr: 0x3000,
+            src_base_addr: 0x1000,
+            atomic_group: None,
+        };
+        (planned, route, source_tag)
+    }
+
+    #[test]
+    fn bind_revalidation_accepts_only_the_exact_source_generation() {
+        let (planned, route, source_tag) = planned_route();
+        assert!(planned_get_source_is_current(&planned, &route));
+
+        route
+            .nodes_replicas
+            .write()
+            .get_mut(&planned.src_node_id)
+            .unwrap()
+            .backing = KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+            owner_node_id: planned.src_node_id.clone(),
+            grant_id: 11,
+            slot_index: 2,
+            slot_size: 8192,
+            addr: 0x4000,
+            len: 4096,
+            base_addr: 0x1000,
+        });
+        assert!(!planned_get_source_is_current(&planned, &route));
+
+        route
+            .nodes_replicas
+            .write()
+            .get_mut(&planned.src_node_id)
+            .unwrap()
+            .backing = KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+            owner_node_id: planned.src_node_id.clone(),
+            grant_id: 11,
+            slot_index: 2,
+            slot_size: 8192,
+            addr: 0x3000,
+            len: 4096,
+            base_addr: 0x1000,
+        });
+        source_tag.set_tomb();
+        assert!(!planned_get_source_is_current(&planned, &route));
+    }
+
+    #[test]
+    fn bind_revalidation_rejects_a_replacement_route_generation() {
+        let (planned, route, _) = planned_route();
+        let replacement_tag = NodeTombTag::new();
+        route
+            .nodes_replicas
+            .write()
+            .get_mut(&planned.src_node_id)
+            .unwrap()
+            .tomb_tag = replacement_tag;
+        assert!(!planned_get_source_is_current(&planned, &route));
+    }
+
+    #[test]
+    fn metadata_plan_does_not_retain_the_route() {
+        let (planned, route, _) = planned_route();
+        let weak_route = Arc::downgrade(&route);
+        let sources = snapshot_live_get_sources(&route);
+        drop(route);
+        assert!(weak_route.upgrade().is_none());
+        assert_eq!(sources.len(), 1);
+        assert_eq!(planned.key, "key");
+    }
+}
+
+async fn handle_get_plan_item(
+    view: MasterKvRouterView,
+    key: String,
+    controller_node_id: NodeID,
+) -> BatchGetPlanItemResp {
+    view.master_kv_router()
+        .inner()
+        .planned_get_counters
+        .plan_items
+        .fetch_add(1, Ordering::Relaxed);
+    let Some(controller) = view
+        .cluster_manager()
+        .get_member_info_cached(controller_node_id.as_ref())
+    else {
+        return get_plan_item_error(&msg_and_error::KvError::Api(
+            msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "GetPlan controller is not a current member: {}",
+                    controller_node_id
+                ),
+            },
+        ));
+    };
+    if controller.node_role() != NodeRole::External {
+        return get_plan_item_error(&msg_and_error::KvError::Api(
+            msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "GetPlan is supported only for external controllers: {}",
+                    controller_node_id
+                ),
+            },
+        ));
+    }
+
+    let Some(route) = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .get(&key)
+        .map(|route| route.clone())
+    else {
+        view.master_kv_router()
+            .inner()
+            .planned_get_counters
+            .plan_misses
+            .fetch_add(1, Ordering::Relaxed);
+        return get_plan_item_error(&msg_and_error::KvError::Api(
+            msg_and_error::ApiError::KeyNotFound { key },
+        ));
+    };
+
+    let local_owner =
+        external_sink_local_owner_id(&view, &controller_node_id, controller.node_start_time);
+    let mut candidates = snapshot_live_get_sources(&route);
+    candidates.shuffle(&mut rand::thread_rng());
+    candidates.sort_by_key(|replica| {
+        local_owner
+            .as_deref()
+            .is_some_and(|owner| replica.node_id.as_ref() == owner)
+    });
+    let Some(source) = candidates.into_iter().next() else {
+        view.master_kv_router()
+            .inner()
+            .planned_get_counters
+            .plan_misses
+            .fetch_add(1, Ordering::Relaxed);
+        return get_plan_item_error(&msg_and_error::KvError::Api(
+            msg_and_error::ApiError::KeyNotFound { key },
+        ));
+    };
+
+    let get_id = view
+        .master_kv_router()
+        .inner()
+        .next_get_id
+        .fetch_add(1, Ordering::Relaxed);
+    let gpu_direct_eligible = local_owner
+        .as_deref()
+        .is_none_or(|owner| source.node_id.as_ref() != owner);
+    let planned = super::PlannedGetInfo {
+        put_id: route.put_id,
+        src_node_id: source.node_id.clone(),
+        src_tomb_tag: source.tomb_tag.clone(),
+        key: key.clone(),
+        controller_node_id: controller_node_id.clone(),
+        controller_node_start_time: controller.node_start_time,
+        len: source.len,
+        src_addr: source.addr,
+        src_base_addr: source.base_addr,
+        atomic_group: route.atomic_group.as_deref().cloned(),
+    };
+    drop(route);
+    view.master_kv_router()
+        .inner()
+        .planned_gets
+        .insert(get_id, planned.clone())
+        .await;
+    view.master_kv_router()
+        .inner()
+        .planned_get_counters
+        .plan_hits
+        .fetch_add(1, Ordering::Relaxed);
+    BatchGetPlanItemResp {
+        get_id,
+        node_id: source.node_id.into(),
+        put_id: planned.put_id,
+        src_addr: planned.src_addr,
+        src_base_addr: planned.src_base_addr,
+        len: planned.len,
+        atomic_group: planned.atomic_group,
+        gpu_direct_eligible,
+        error_code: msg_and_error::OK,
+        error_json: String::new(),
+    }
+}
+
+fn bound_get_matches_target(info: &InflightGetInfo, target: &GetBindTarget) -> bool {
+    match (target, &info.target) {
+        (GetBindTarget::ExternalSink(expected), InflightGetTarget::ExternalSink(actual)) => {
+            expected == actual
+        }
+        (
+            GetBindTarget::PreparedLocalReserve(expected),
+            InflightGetTarget::PreparedLocalReserveSlot(actual),
+        ) => {
+            expected.grant_id == actual.grant_id
+                && expected.slot_index == actual.slot_index
+                && expected.slot_size == actual.slot_size
+                && expected.addr == actual.addr
+                && expected.base_addr == actual.base_addr
+        }
+        _ => false,
+    }
+}
+
+fn bound_get_start_item(get_id: u64, info: &InflightGetInfo) -> BatchGetStartItemResp {
+    BatchGetStartItemResp {
+        get_id,
+        node_id: info.src_node_id.to_string().into(),
+        put_id: info.put_id,
+        target_addr: info.target.abs_addr(),
+        src_addr: info.src_addr,
+        target_base_addr: info.target.base_addr(),
+        src_base_addr: info.src_base_addr,
+        len: info.len,
+        prepared_target: match &info.target {
+            InflightGetTarget::PreparedLocalReserveSlot(slot) => {
+                Some(GetPreparedLocalReserveTarget {
+                    grant_id: slot.grant_id,
+                    slot_index: slot.slot_index,
+                    slot_size: slot.slot_size,
+                    addr: slot.addr,
+                    base_addr: slot.base_addr,
+                })
+            }
+            _ => None,
+        },
+        atomic_group: info.atomic_group.clone(),
+        error_code: msg_and_error::OK,
+        error_json: String::new(),
+    }
+}
+
+async fn handle_get_bind_item(
+    view: MasterKvRouterView,
+    request: BatchGetBindItemReq,
+    req_node_id: NodeID,
+) -> BatchGetStartItemResp {
+    let get_id = request.get_id;
+    let operation_lock = view
+        .master_kv_router()
+        .inner()
+        .get_done_locks
+        .get_lock(get_id);
+    let _operation_guard = operation_lock.lock().await;
+
+    if let Some(bound) = view
+        .master_kv_router()
+        .inner()
+        .inflight_gets
+        .get(&get_id)
+        .await
+    {
+        if bound.req_node_id != req_node_id || !bound_get_matches_target(&bound, &request.target) {
+            return get_bind_item_error(
+                get_id,
+                &msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                    detail: format!(
+                        "GetBind replay identity/target mismatch: get_id={} requester={}",
+                        get_id, req_node_id
+                    ),
+                }),
+            );
+        }
+        return bound_get_start_item(get_id, &bound);
+    }
+
+    let Some(planned) = view
+        .master_kv_router()
+        .inner()
+        .planned_gets
+        .get(&get_id)
+        .await
+    else {
+        return get_bind_item_error(
+            get_id,
+            &msg_and_error::KvError::Api(msg_and_error::ApiError::KeyNotFound {
+                key: format!("planned_get_id:{get_id}"),
+            }),
+        );
+    };
+    let (target, target_tomb_tag, allocation_mode, prepared_requester_lease) = match &request.target
+    {
+        GetBindTarget::ExternalSink(target) => {
+            if req_node_id != planned.controller_node_id {
+                return get_bind_item_error(
+                    get_id,
+                    &msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                        detail: format!(
+                            "external GetBind controller mismatch: get_id={} expected={} got={}",
+                            get_id, planned.controller_node_id, req_node_id
+                        ),
+                    }),
+                );
+            }
+            if let Err(err) =
+                validate_external_sink_target(&view, &req_node_id, target, planned.len)
+            {
+                return get_bind_item_error(get_id, &err);
+            }
+            (
+                InflightGetTarget::ExternalSink(target.clone()),
+                None,
+                GetAllocationMode::ExternalSink,
+                None,
+            )
+        }
+        GetBindTarget::PreparedLocalReserve(target) => {
+            let expected_owner = external_sink_local_owner_id(
+                &view,
+                &planned.controller_node_id,
+                planned.controller_node_start_time,
+            );
+            if expected_owner.as_deref() != Some(req_node_id.as_ref()) {
+                return get_bind_item_error(
+                    get_id,
+                    &msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                        detail: format!(
+                            "prepared GetBind executor is not the controller's owner: get_id={} controller={} expected_owner={:?} got={}",
+                            get_id, planned.controller_node_id, expected_owner, req_node_id
+                        ),
+                    }),
+                );
+            }
+            let requester_lease = match view.master_kv_router().reserve_prepared_get_requester(
+                &planned.key,
+                &req_node_id,
+                get_id,
+            ) {
+                Ok(lease) => lease,
+                Err(err) => return get_bind_item_error(get_id, &err),
+            };
+            let (slot, tomb_tag) = match validate_prepared_local_reserve_target(
+                &view,
+                &req_node_id,
+                target,
+                planned.len,
+            ) {
+                Ok(value) => value,
+                Err(err) => return get_bind_item_error(get_id, &err),
+            };
+            (
+                InflightGetTarget::PreparedLocalReserveSlot(slot),
+                Some(tomb_tag),
+                GetAllocationMode::LocalCommittedSlot,
+                Some(requester_lease),
+            )
+        }
+        GetBindTarget::Invalid => {
+            return get_bind_item_error(
+                get_id,
+                &msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                    detail: format!("GetBind requires a concrete target: get_id={get_id}"),
+                }),
+            );
+        }
+    };
+
+    let activity_lease = match view
+        .master_kv_router()
+        .reserve_inflight_get_key(&planned.key)
+    {
+        Ok(lease) => lease,
+        Err(err) => {
+            view.master_kv_router()
+                .inner()
+                .planned_get_counters
+                .bind_activity_busy
+                .fetch_add(1, Ordering::Relaxed);
+            return get_bind_item_error(get_id, &err);
+        }
+    };
+    let current_route = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .get(&planned.key)
+        .map(|route| route.clone());
+    let Some(current_route) =
+        current_route.filter(|route| planned_get_source_is_current(&planned, route))
+    else {
+        view.master_kv_router()
+            .inner()
+            .planned_get_counters
+            .bind_stale
+            .fetch_add(1, Ordering::Relaxed);
+        return get_bind_item_error(
+            get_id,
+            &msg_and_error::KvError::Api(msg_and_error::ApiError::StaleGetPlan {
+                get_id,
+                key: planned.key.clone(),
+                detail: format!(
+                    "source route changed before Bind: source={}",
+                    planned.src_node_id
+                ),
+            }),
+        );
+    };
+    if matches!(&request.target, GetBindTarget::PreparedLocalReserve(_))
+        && current_route
+            .nodes_replicas
+            .read()
+            .get(&req_node_id)
+            .is_some_and(|replica| !replica.tomb_tag.is_tomb())
+    {
+        return get_bind_item_error(
+            get_id,
+            &msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "prepared GetBind cannot replace a live owner replica: get_id={} key={} owner={}",
+                    get_id, planned.key, req_node_id
+                ),
+            }),
+        );
+    }
+
+    let Some(planned) = view
+        .master_kv_router()
+        .inner()
+        .planned_gets
+        .remove(&get_id)
+        .await
+    else {
+        return get_bind_item_error(
+            get_id,
+            &msg_and_error::KvError::Api(msg_and_error::ApiError::KeyNotFound {
+                key: format!("planned_get_id:{get_id}"),
+            }),
+        );
+    };
+    let inflight = InflightGetInfo {
+        put_id: planned.put_id,
+        src_node_id: planned.src_node_id.clone(),
+        key: planned.key.clone(),
+        req_node_id: req_node_id.clone(),
+        controller_node_id: Some(planned.controller_node_id),
+        len: planned.len,
+        src_addr: planned.src_addr,
+        src_base_addr: planned.src_base_addr,
+        atomic_group: planned.atomic_group,
+        target,
+        target_tomb_tag,
+        route: current_route.clone(),
+        allocation_mode,
+        durable_reservation: None,
+        _activity_lease: activity_lease,
+        _prepared_requester_lease: prepared_requester_lease,
+    };
+    let response = bound_get_start_item(get_id, &inflight);
+    view.master_kv_router().record_get_source_selection(
+        req_node_id.as_ref(),
+        inflight.src_node_id.as_ref(),
+        inflight.len,
+        allocation_mode,
+    );
+    view.master_kv_router()
+        .inner()
+        .inflight_gets
+        .insert(get_id, inflight)
+        .await;
+    view.master_kv_router()
+        .inner()
+        .planned_get_counters
+        .bind_succeeded
+        .fetch_add(1, Ordering::Relaxed);
+    if current_route.lease_id.is_none() {
+        touch_moka_for_node(view, response.node_id.to_string(), planned.key);
+    }
+    response
+}
+
+pub async fn handle_batch_get_plan(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchGetPlanReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchGetPlanResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.keys.len());
+    for key in req.serialize_part.keys {
+        items.push(handle_get_plan_item(view.clone(), key, req_node_id.clone()).await);
+    }
+    MsgPack {
+        serialize_part: BatchGetPlanResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_batch_get_bind(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchGetBindReq>,
+    req_node_id: NodeID,
+) -> MsgPack<BatchGetBindResp> {
+    let mut items = Vec::with_capacity(req.serialize_part.items.len());
+    for item in req.serialize_part.items {
+        items.push(handle_get_bind_item(view.clone(), item, req_node_id.clone()).await);
+    }
+    MsgPack {
+        serialize_part: BatchGetBindResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+            server_process_us: 0,
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
 pub async fn handle_get_start(
     view: MasterKvRouterView,
     req: MsgPack<GetStartReq>,
@@ -613,7 +1239,11 @@ pub async fn handle_get_start(
             src_node_id: src_node_id.clone(),
             key: req.serialize_part.key.clone(),
             req_node_id,
+            controller_node_id: None,
             len: src_len,
+            src_addr: resp_src_addr,
+            src_base_addr: resp_src_base,
+            atomic_group: one_kv_nodes_routes.atomic_group.as_deref().cloned(),
             target,
             target_tomb_tag,
             route: one_kv_nodes_routes.clone(),
@@ -683,6 +1313,56 @@ pub async fn handle_get_revoke(
         .get_lock(get_id);
     let _done_guard = done_lock.lock().await;
 
+    if let Some(planned) = view
+        .master_kv_router()
+        .inner()
+        .planned_gets
+        .get(&get_id)
+        .await
+    {
+        let controller_owner = external_sink_local_owner_id(
+            &view,
+            &planned.controller_node_id,
+            planned.controller_node_start_time,
+        );
+        let authorized = planned.controller_node_id == req_node_id
+            || controller_owner.as_deref() == Some(req_node_id.as_ref());
+        if !authorized {
+            let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                detail: format!(
+                    "GetRevoke planned-operation requester mismatch: get_id={} controller={} got={}",
+                    get_id, planned.controller_node_id, req_node_id
+                ),
+            });
+            return MsgPack {
+                serialize_part: crate::rpcresp_kvresult_convert::FromError::from_error(&err),
+                raw_bytes: Vec::new(),
+            };
+        }
+        drop(planned);
+        if view
+            .master_kv_router()
+            .inner()
+            .planned_gets
+            .remove(&get_id)
+            .await
+            .is_some()
+        {
+            view.master_kv_router()
+                .inner()
+                .planned_get_counters
+                .plan_revoked
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        return MsgPack {
+            serialize_part: GetRevokeResp {
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+
     if let Some(inflight_info) = view
         .master_kv_router()
         .inner()
@@ -690,7 +1370,9 @@ pub async fn handle_get_revoke(
         .get(&get_id)
         .await
     {
-        if inflight_info.req_node_id != req_node_id {
+        if inflight_info.req_node_id != req_node_id
+            && inflight_info.controller_node_id.as_ref() != Some(&req_node_id)
+        {
             let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
                 detail: format!(
                     "GetRevoke requester mismatch: get_id={} expected={} got={}",
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index 9f927d9..d5c43ee 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -15,20 +15,20 @@ use self::{
     delete::handle_delete,
     delete::handle_delete_ack,
     get::{
-        handle_batch_get_done, handle_batch_get_revoke, handle_batch_get_start,
-        handle_batch_is_exist, handle_get_done, handle_get_meta, handle_get_revoke,
-        handle_get_start,
+        handle_batch_get_bind, handle_batch_get_done, handle_batch_get_plan,
+        handle_batch_get_revoke, handle_batch_get_start, handle_batch_is_exist, handle_get_done,
+        handle_get_meta, handle_get_revoke, handle_get_start,
     },
     msg_pack::{
         BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
-        BatchEvictOwnerSourceReq, BatchGetDoneReq, BatchGetRevokeReq, BatchGetStartReq,
-        BatchIsExistReq, BatchOwnerReclaimReq, BatchPreparePutKeysReq, BatchPutAppendDoneReq,
-        BatchPutAppendStartReq, BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq,
-        BatchReleasePutKeyReservationsReq, CountPrefixReq, CountPrefixResp, DeleteAckReq,
-        DeleteReq, GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetRevokeReq,
-        GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimItem, PutAppendDoneReq,
-        PutAppendRevokeReq, PutAppendStartReq, PutAtomicGroup, PutDoneReq, PutRevokeReq,
-        PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq,
+        BatchEvictOwnerSourceReq, BatchGetBindReq, BatchGetDoneReq, BatchGetPlanReq,
+        BatchGetRevokeReq, BatchGetStartReq, BatchIsExistReq, BatchOwnerReclaimReq,
+        BatchPreparePutKeysReq, BatchPutAppendDoneReq, BatchPutAppendStartReq, BatchPutDoneReq,
+        BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq,
+        CountPrefixResp, DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq, GetDoneResp,
+        GetMetaReq, GetRevokeReq, GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimItem,
+        PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq, PutAtomicGroup, PutDoneReq,
+        PutRevokeReq, PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq,
     },
     placement::{PlacementPolicy, build_placement_policy},
     put::{
@@ -429,7 +429,13 @@ pub struct InflightGetInfo {
     pub src_node_id: NodeID,
     pub key: String,
     pub req_node_id: NodeID,
+    /// Optional external controller for a late-bound operation whose executor
+    /// is the share-group owner in `req_node_id`.
+    pub controller_node_id: Option<NodeID>,
     pub len: u64,
+    pub src_addr: u64,
+    pub src_base_addr: u64,
+    pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
     pub target: InflightGetTarget,
     /// Exact requester segment-registration generation that owns an
     /// allocator-backed target. External sinks are caller-owned and instead
@@ -445,6 +451,25 @@ pub struct InflightGetInfo {
     pub(crate) _prepared_requester_lease: Option<Arc<PreparedGetRequesterLease>>,
 }
 
+/// A metadata-only Get source snapshot before caller-owned destination binding.
+///
+/// This type must not own a route, allocation, activity lease, cache pin, or
+/// destination resource. Bind re-reads the current route and installs the real
+/// Get activity before accepting the snapshot.
+#[derive(Clone)]
+pub struct PlannedGetInfo {
+    pub put_id: PutIDForAKey,
+    pub src_node_id: NodeID,
+    pub src_tomb_tag: NodeTombTag,
+    pub key: String,
+    pub controller_node_id: NodeID,
+    pub controller_node_start_time: i64,
+    pub len: u64,
+    pub src_addr: u64,
+    pub src_base_addr: u64,
+    pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
+}
+
 #[derive(Clone)]
 pub struct CompletedGetInfo {
     pub req_node_id: NodeID,
@@ -568,6 +593,17 @@ struct MasterKeyActivityObserveSnapshot {
     inflight_replicas: u64,
 }
 
+#[derive(Default)]
+pub(crate) struct MasterPlannedGetCounters {
+    plan_items: AtomicU64,
+    plan_hits: AtomicU64,
+    plan_misses: AtomicU64,
+    bind_succeeded: AtomicU64,
+    bind_stale: AtomicU64,
+    bind_activity_busy: AtomicU64,
+    plan_revoked: AtomicU64,
+}
+
 #[derive(Clone, Copy, Debug)]
 enum MasterKeyActivityKind {
     Put,
@@ -2272,6 +2308,10 @@ pub struct MasterKvRouterInner {
     /// queue or actor.
     pub replica_operation_locks: AMapLock<(String, u64, u32)>,
     pub inflight_gets: moka::future::Cache<u64, InflightGetInfo>,
+    /// Target-free source plans. Bind atomically moves an entry into
+    /// `inflight_gets` after re-reading and validating the current route.
+    pub planned_gets: moka::future::Cache<u64, PlannedGetInfo>,
+    pub(crate) planned_get_counters: MasterPlannedGetCounters,
     /// Idempotent terminal GetDone results retained across response loss/retry.
     pub completed_gets: moka::future::Cache<u64, CompletedGetInfo>,
     pub get_done_locks: AMapLock<u64>,
@@ -2490,6 +2530,9 @@ impl MasterKvRouter {
                 }
             })
             .build();
+        let planned_gets: moka::future::Cache<u64, PlannedGetInfo> = moka::future::Cache::builder()
+            .time_to_live(Duration::from_secs(60))
+            .build();
         let completed_gets = moka::future::Cache::builder()
             .time_to_live(Duration::from_secs(120))
             .build();
@@ -2524,6 +2567,8 @@ impl MasterKvRouter {
             completed_replica_tasks,
             replica_operation_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             inflight_gets,
+            planned_gets,
+            planned_get_counters: MasterPlannedGetCounters::default(),
             completed_gets,
             get_done_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             key_activity,
@@ -3817,6 +3862,56 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<BatchGetPlanReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let cleanup_view = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_batch_get_plan", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_get_plan(view2, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                let planned_get_ids = ack
+                    .serialize_part
+                    .items
+                    .iter()
+                    .filter(|item| {
+                        item.error_code == crate::rpcresp_kvresult_convert::msg_and_error::OK
+                    })
+                    .map(|item| item.get_id)
+                    .collect::<Vec<_>>();
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchGetPlanResp: {:?}", e);
+                    for get_id in planned_get_ids {
+                        cleanup_view
+                            .master_kv_router()
+                            .inner()
+                            .planned_gets
+                            .remove(&get_id)
+                            .await;
+                    }
+                }
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<BatchGetBindReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let view2 = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_batch_get_bind", async move {
+                let t0 = Utc::now().timestamp_micros();
+                let mut ack = handle_batch_get_bind(view2, msg, req_node_id).await;
+                ack.serialize_part.server_process_us = Utc::now().timestamp_micros() - t0;
+                if let Err(e) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchGetBindResp: {:?}", e);
+                }
+            });
+            Ok(())
+        });
+
         let view = self.0.view().clone();
         RPCHandler::<BatchGetStartReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
@@ -5324,6 +5419,56 @@ impl MasterKvRouter {
                             inflight_replicas = activity.inflight_replicas,
                             "master key activity runtime"
                         );
+                        tracing::info!(
+                            active_plans = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_gets
+                                .entry_count(),
+                            plan_items = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .plan_items
+                                .load(Ordering::Relaxed),
+                            plan_hits = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .plan_hits
+                                .load(Ordering::Relaxed),
+                            plan_misses = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .plan_misses
+                                .load(Ordering::Relaxed),
+                            bind_succeeded = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .bind_succeeded
+                                .load(Ordering::Relaxed),
+                            bind_stale = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .bind_stale
+                                .load(Ordering::Relaxed),
+                            bind_activity_busy = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .bind_activity_busy
+                                .load(Ordering::Relaxed),
+                            plan_revoked = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .plan_revoked
+                                .load(Ordering::Relaxed),
+                            "master metadata-only Get plan runtime"
+                        );
                         for node in snapshot.replica_cache_nodes {
                             tracing::info!(
                                 "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_victims={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} last_route_removed_members={} last_route_removed_bytes={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index d21e39d..b873956 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -183,6 +183,143 @@ impl RPCReq for BatchGetStartReq {
     type Resp = BatchGetStartResp;
 }
 
+/// Target-free Get planning. Successful items retain one exact source
+/// generation until Bind, Revoke, or expiry.
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetPlanReq {
+    pub keys: Vec<String>,
+}
+impl MsgPackSerializePart for BatchGetPlanReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetPlanReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetPlanItemResp {
+    pub get_id: u64,
+    pub node_id: NodeIDString,
+    pub put_id: PutIDForAKey,
+    pub src_addr: u64,
+    pub src_base_addr: u64,
+    pub len: u64,
+    pub atomic_group: Option<PutAtomicGroup>,
+    /// False when the selected source is the external requester's local
+    /// share-group owner and therefore cannot use the RDMA-only GPU sink.
+    pub gpu_direct_eligible: bool,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetPlanResp {
+    pub items: Vec<BatchGetPlanItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchGetPlanResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetPlanResp as u32
+    }
+}
+impl RPCReq for BatchGetPlanReq {
+    type Resp = BatchGetPlanResp;
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub enum GetBindTarget {
+    #[default]
+    Invalid,
+    PreparedLocalReserve(GetPreparedLocalReserveTarget),
+    ExternalSink(GetExternalSinkTarget),
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetBindItemReq {
+    pub get_id: u64,
+    pub target: GetBindTarget,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetBindReq {
+    pub items: Vec<BatchGetBindItemReq>,
+}
+impl MsgPackSerializePart for BatchGetBindReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetBindReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchGetBindResp {
+    pub items: Vec<BatchGetStartItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+    pub server_process_us: i64,
+}
+impl MsgPackSerializePart for BatchGetBindResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchGetBindResp as u32
+    }
+}
+impl RPCReq for BatchGetBindReq {
+    type Resp = BatchGetBindResp;
+}
+
+#[cfg(test)]
+mod planned_get_wire_tests {
+    use super::{
+        BatchGetBindItemReq, BatchGetBindReq, BatchGetPlanItemResp, BatchGetPlanResp,
+        GetBindTarget, GetExternalSinkTarget,
+    };
+    use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+
+    #[test]
+    fn first_get_id_and_late_gpu_binding_round_trip() {
+        let plan = BatchGetPlanResp {
+            items: vec![BatchGetPlanItemResp {
+                get_id: 0,
+                node_id: "source-a".to_string(),
+                src_addr: 0x1000,
+                src_base_addr: 0x800,
+                len: 4096,
+                gpu_direct_eligible: true,
+                error_code: OK,
+                ..Default::default()
+            }],
+            error_code: OK,
+            ..Default::default()
+        };
+        let decoded: BatchGetPlanResp =
+            bitcode::decode(&bitcode::encode(&plan)).expect("decode GetPlan response");
+        assert_eq!(decoded.items[0].get_id, 0);
+        assert!(decoded.items[0].gpu_direct_eligible);
+        assert_eq!(decoded.items[0].src_addr, 0x1000);
+
+        let bind = BatchGetBindReq {
+            items: vec![BatchGetBindItemReq {
+                get_id: 0,
+                target: GetBindTarget::ExternalSink(GetExternalSinkTarget {
+                    addr: 0x2000,
+                    capacity: 4096,
+                    registration_id: 7,
+                    requester_node_start_time: 11,
+                }),
+            }],
+        };
+        let decoded: BatchGetBindReq =
+            bitcode::decode(&bitcode::encode(&bind)).expect("decode GetBind request");
+        assert!(matches!(
+            &decoded.items[0].target,
+            GetBindTarget::ExternalSink(target)
+                if decoded.items[0].get_id == 0
+                    && target.registration_id == 7
+                    && target.requester_node_start_time == 11
+        ));
+    }
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct BatchGetRevokeReq {
     pub get_ids: Vec<u64>,
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
index 5f6e8ca..91558b6 100644
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
@@ -83,6 +83,10 @@ pub enum MsgId {
     BatchPutAppendDoneResp = 3068,
     BatchEvictOwnerSourceReq = 3069,
     BatchEvictOwnerSourceResp = 3070,
+    BatchGetPlanReq = 3071,
+    BatchGetPlanResp = 3072,
+    BatchGetBindReq = 3073,
+    BatchGetBindResp = 3074,
     ExternalGetReq = 4001,
     ExternalGetResp = 4002,
     ExternalPutStartReq = 4003,
@@ -749,6 +753,9 @@ crate::define_err_group! {
         ,
         (123, KeyAlreadyExists { key: String },
             msg: "Key already exists: key={key}")
+        ,
+        (124, StaleGetPlan { get_id: u64, key: String, detail: String },
+            msg: "Get plan is stale: get_id={get_id}, key={key}, detail={detail}")
     }
 }
 
diff --git a/fluxon_rs/fluxon_pyo3/src/fixed_slab_allocator.rs b/fluxon_rs/fluxon_pyo3/src/fixed_slab_allocator.rs
new file mode 100644
index 0000000..bbcd7df
--- /dev/null
+++ b/fluxon_rs/fluxon_pyo3/src/fixed_slab_allocator.rs
@@ -0,0 +1,52 @@
+use fluxon_util::fixed_slab_allocator::FixedSlabAllocator as RustFixedSlabAllocator;
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+
+/// Thread-safe fixed-slot slab allocator.
+///
+/// `try_reserve` is all-or-none. `release` rejects invalid input atomically.
+#[pyclass(module = "fluxon_pyo3")]
+pub struct FixedSlabAllocator {
+    inner: RustFixedSlabAllocator,
+}
+
+#[pymethods]
+impl FixedSlabAllocator {
+    #[new]
+    fn new(slot_count: u32) -> PyResult<Self> {
+        let inner = RustFixedSlabAllocator::new(slot_count)
+            .map_err(|error| PyValueError::new_err(error.to_string()))?;
+        Ok(Self { inner })
+    }
+
+    /// Reserve exactly `count` slots, returning `None` if capacity is unavailable.
+    fn try_reserve(&self, count: u32) -> Option<Vec<u32>> {
+        self.inner.try_reserve(count)
+    }
+
+    /// Release all slots atomically after bounds, duplicate, and live-state checks.
+    fn release(&self, slots: Vec<u32>) -> PyResult<()> {
+        self.inner
+            .release(&slots)
+            .map_err(|error| PyValueError::new_err(error.to_string()))
+    }
+
+    #[getter]
+    fn capacity(&self) -> u32 {
+        self.inner.capacity()
+    }
+
+    #[getter]
+    fn free_count(&self) -> u32 {
+        self.inner.free_count()
+    }
+
+    #[getter]
+    fn live_count(&self) -> u32 {
+        self.inner.live_count()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index d849e62..a6453dc 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -77,6 +77,8 @@ include!(env!("FLUXON_PYO3_TEST_PYTHON_LINK_RS"));
 
 mod memholder;
 pub use memholder::{ExternalMemHolder, MemHolder};
+mod fixed_slab_allocator;
+pub use fixed_slab_allocator::FixedSlabAllocator;
 mod flatdict_zerocopy;
 use flatdict_zerocopy::{FlatDictDataOwner, decode_flat_dict_to_wrapped_py_object};
 mod kvfuture;
@@ -4771,6 +4773,244 @@ impl KvClient {
         cancel_get_transfer_inner(self, handle, py).into_py_object(py)
     }
 
+    /// Plan one generation-fenced Get prefix without allocating a destination.
+    #[pyo3(signature = (keys, prefix_best_effort=true, atomic_group_lens=None))]
+    fn get_plan(
+        &self,
+        keys: Vec<String>,
+        prefix_best_effort: bool,
+        atomic_group_lens: Option<Vec<usize>>,
+        py: Python,
+    ) -> PyObject {
+        fn get_plan_inner(
+            client: &KvClient,
+            keys: Vec<String>,
+            prefix_best_effort: bool,
+            atomic_group_lens: Option<Vec<usize>>,
+            py: Python,
+        ) -> ApiResult<PyObject> {
+            if keys.is_empty() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_plan requires at least one key",
+                ));
+            }
+            let framework = match require_kv_framework_api(client, py) {
+                Ok(value) => value,
+                Err(err) => return ApiResult::new_error(err),
+            };
+            if !framework.is_external_mode() {
+                return ApiResult::new_error(new_invalid_argument_error(
+                    py,
+                    "get_plan is supported only in external-client mode",
+                ));
+            }
+            let Some(runtime) = client.runtime.as_ref() else {
+                return ApiResult::new_error(new_general_error(py, "Client runtime is missing"));
+            };
+            let framework_for_plan = framework.clone();
+            let result = match py.allow_threads(|| {
+                runtime.run_async_from_sync(async move {
+                    framework_for_plan
+                        .external_client_api_view()
+                        .external_client_api()
+                        .inner()
+                        .get_plan(keys, prefix_best_effort, atomic_group_lens)
+                        .await
+                })
+            }) {
+                Ok(result) => result,
+                Err(err) => {
+                    return ApiResult::new_error(new_general_error(
+                        py,
+                        &format!("runtime bridge failed: {err}"),
+                    ));
+                }
+            };
+            match result {
+                Ok(plan) => {
+                    let out = PyDict::new_bound(py);
+                    out.set_item("handle", plan.handle).expect("set handle");
+                    out.set_item("raw_prefix_hit_len", plan.raw_prefix_hit_len as u64)
+                        .expect("set raw_prefix_hit_len");
+                    out.set_item("gpu_raw_prefix_hit_len", plan.gpu_raw_prefix_hit_len as u64)
+                        .expect("set gpu_raw_prefix_hit_len");
+                    out.set_item("gpu_remote_indices", plan.gpu_remote_indices)
+                        .expect("set gpu_remote_indices");
+                    ApiResult::new_success(out.into_py(py))
+                }
+                Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                    py,
+                    &err,
+                    "get_plan failed",
+                )),
+            }
+        }
+
+        get_plan_inner(self, keys, prefix_best_effort, atomic_group_lens, py).into_py_object(py)
+    }
+
+    #[pyo3(signature = (handle, consume_prefix_len, concurrency=None))]
+    fn execute_get_plan_cpu(
+        &self,
+        handle: u64,
+        consume_prefix_len: usize,
+        concurrency: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        let batch_concurrency = concurrency.unwrap_or(DEFAULT_PYO3_BATCH_CONCURRENCY);
+        let framework = match require_kv_framework_api(self, py) {
+            Ok(value) => value,
+            Err(err) => return ApiResult::<PyObject>::new_error(err).into_py_object(py),
+        };
+        if !framework.is_external_mode() || batch_concurrency == 0 {
+            return ApiResult::<PyObject>::new_error(new_invalid_argument_error(
+                py,
+                "execute_get_plan_cpu requires external mode and positive concurrency",
+            ))
+            .into_py_object(py);
+        }
+        let Some(runtime) = self.runtime.as_ref() else {
+            return ApiResult::<PyObject>::new_error(new_general_error(
+                py,
+                "Client runtime is missing",
+            ))
+            .into_py_object(py);
+        };
+        let framework_for_execute = framework.clone();
+        let result = py.allow_threads(|| {
+            runtime.run_async_from_sync(async move {
+                framework_for_execute
+                    .external_client_api_view()
+                    .external_client_api()
+                    .inner()
+                    .execute_get_plan_cpu(handle, consume_prefix_len, batch_concurrency)
+                    .await
+            })
+        });
+        match result {
+            Ok(Ok(())) => ApiResult::new_success(0i32.into_py(py)),
+            Ok(Err(err)) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                py,
+                &err,
+                "execute_get_plan_cpu failed",
+            )),
+            Err(err) => ApiResult::new_error(new_general_error(
+                py,
+                &format!("runtime bridge failed: {err}"),
+            )),
+        }
+        .into_py_object(py)
+    }
+
+    #[pyo3(signature = (handle, destinations, consume_prefix_len, concurrency=None))]
+    fn execute_get_plan_gpu(
+        &self,
+        handle: u64,
+        destinations: Vec<(u64, u64, u64)>,
+        consume_prefix_len: usize,
+        concurrency: Option<usize>,
+        py: Python,
+    ) -> PyObject {
+        let batch_concurrency = concurrency.unwrap_or(DEFAULT_PYO3_BATCH_CONCURRENCY);
+        let framework = match require_kv_framework_api(self, py) {
+            Ok(value) => value,
+            Err(err) => return ApiResult::<PyObject>::new_error(err).into_py_object(py),
+        };
+        if !framework.is_external_mode() || batch_concurrency == 0 {
+            return ApiResult::<PyObject>::new_error(new_invalid_argument_error(
+                py,
+                "execute_get_plan_gpu requires external mode and positive concurrency",
+            ))
+            .into_py_object(py);
+        }
+        let Some(runtime) = self.runtime.as_ref() else {
+            return ApiResult::<PyObject>::new_error(new_general_error(
+                py,
+                "Client runtime is missing",
+            ))
+            .into_py_object(py);
+        };
+        let destinations = destinations
+            .into_iter()
+            .map(|(registration_id, addr, capacity)| {
+                fluxon_kv::external_client_api::ExternalGpuDestination {
+                    registration_id,
+                    addr,
+                    capacity,
+                }
+            })
+            .collect();
+        let framework_for_execute = framework.clone();
+        let result = py.allow_threads(|| {
+            runtime.run_async_from_sync(async move {
+                framework_for_execute
+                    .external_client_api_view()
+                    .external_client_api()
+                    .inner()
+                    .execute_get_plan_gpu(
+                        handle,
+                        destinations,
+                        consume_prefix_len,
+                        batch_concurrency,
+                    )
+                    .await
+            })
+        });
+        match result {
+            Ok(Ok(())) => ApiResult::new_success(0i32.into_py(py)),
+            Ok(Err(err)) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                py,
+                &err,
+                "execute_get_plan_gpu failed",
+            )),
+            Err(err) => ApiResult::new_error(new_general_error(
+                py,
+                &format!("runtime bridge failed: {err}"),
+            )),
+        }
+        .into_py_object(py)
+    }
+
+    #[pyo3(signature = (handle))]
+    fn cancel_get_plan(&self, handle: u64, py: Python) -> PyObject {
+        let framework = match require_kv_framework_api(self, py) {
+            Ok(value) => value,
+            Err(err) => return ApiResult::<PyObject>::new_error(err).into_py_object(py),
+        };
+        let Some(runtime) = self.runtime.as_ref() else {
+            return ApiResult::<PyObject>::new_error(new_general_error(
+                py,
+                "Client runtime is missing",
+            ))
+            .into_py_object(py);
+        };
+        let framework_for_cancel = framework.clone();
+        let result = py.allow_threads(|| {
+            runtime.run_async_from_sync(async move {
+                framework_for_cancel
+                    .external_client_api_view()
+                    .external_client_api()
+                    .inner()
+                    .cancel_get_plan(handle)
+                    .await
+            })
+        });
+        match result {
+            Ok(Ok(())) => ApiResult::new_success(0i32.into_py(py)),
+            Ok(Err(err)) => ApiResult::new_error(crate::error::py_error_from_kv_error(
+                py,
+                &err,
+                "cancel_get_plan failed",
+            )),
+            Err(err) => ApiResult::new_error(new_general_error(
+                py,
+                &format!("runtime bridge failed: {err}"),
+            )),
+        }
+        .into_py_object(py)
+    }
+
     /// Start background RDMA pulls directly into caller-owned GPU destinations.
     #[pyo3(signature = (keys, destinations, prefix_best_effort=true, atomic_group_lens=None, concurrency=None))]
     fn get_start_gpu(
@@ -4948,6 +5188,30 @@ impl KvClient {
             };
             match result {
                 Ok(terminal) => {
+                    if terminal.value_ptrs.len() != terminal.consumed_prefix_len {
+                        return ApiResult::new_error(new_general_error(
+                            py,
+                            &format!(
+                                "get_transfer_gpu source plan length mismatch: values={} consumed={}",
+                                terminal.value_ptrs.len(),
+                                terminal.consumed_prefix_len
+                            ),
+                        ));
+                    }
+                    let view_plan = Arc::new(FluxonGetViewsPlan {
+                        blob: build_plan_blob(&terminal.value_ptrs),
+                        _holders: terminal
+                            .local_holders
+                            .into_iter()
+                            .map(|holder| StagedGetViewHolder::External { _holder: holder })
+                            .collect(),
+                    });
+                    let plan_ptr = plan_ptr_from_blob(view_plan.blob.as_ref());
+                    client
+                        .plan_registry
+                        .write()
+                        .expect("plan_registry poisoned")
+                        .insert(plan_ptr, FluxonPlanRegistryEntry::Get(view_plan));
                     let out = PyDict::new_bound(py);
                     out.set_item(
                         "transferred_prefix_len",
@@ -4956,6 +5220,16 @@ impl KvClient {
                     .expect("set transferred_prefix_len");
                     out.set_item("consumed_prefix_len", terminal.consumed_prefix_len as u64)
                         .expect("set consumed_prefix_len");
+                    out.set_item("transfer_wall_us", terminal.transfer_wall_us)
+                        .expect("set transfer_wall_us");
+                    out.set_item("finish_wait_us", terminal.finish_wait_us)
+                        .expect("set finish_wait_us");
+                    out.set_item("terminal_before_consume", terminal.terminal_before_consume)
+                        .expect("set terminal_before_consume");
+                    out.set_item("terminal_to_consume_us", terminal.terminal_to_consume_us)
+                        .expect("set terminal_to_consume_us");
+                    out.set_item("plan_ptr", plan_ptr as u64)
+                        .expect("set plan_ptr");
                     ApiResult::new_success(out.into_py(py))
                 }
                 Err(err) => ApiResult::new_error(crate::error::py_error_from_kv_error(
@@ -7621,6 +7895,7 @@ fn fluxon_pyo3(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<KvFuture>()?;
     m.add_class::<MemHolder>()?;
     m.add_class::<ExternalMemHolder>()?;
+    m.add_class::<FixedSlabAllocator>()?;
     m.add_class::<FluxonFsAgent>()?;
     m.add_class::<MpscContext>()?;
     m.add_class::<MpscProducerHandle>()?;
diff --git a/fluxon_rs/fluxon_util/src/fixed_slab_allocator.rs b/fluxon_rs/fluxon_util/src/fixed_slab_allocator.rs
new file mode 100644
index 0000000..fe9c6ce
--- /dev/null
+++ b/fluxon_rs/fluxon_util/src/fixed_slab_allocator.rs
@@ -0,0 +1,245 @@
+use parking_lot::Mutex;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FixedSlabAllocatorError {
+    ZeroCapacity,
+    DuplicateSlot { slot: u32 },
+    SlotOutOfBounds { slot: u32, capacity: u32 },
+    SlotNotAllocated { slot: u32 },
+}
+
+impl Display for FixedSlabAllocatorError {
+    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ZeroCapacity => write!(formatter, "fixed slab capacity must be positive"),
+            Self::DuplicateSlot { slot } => {
+                write!(
+                    formatter,
+                    "fixed slab release contains duplicate slot {slot}"
+                )
+            }
+            Self::SlotOutOfBounds { slot, capacity } => write!(
+                formatter,
+                "fixed slab slot {slot} is outside capacity {capacity}"
+            ),
+            Self::SlotNotAllocated { slot } => {
+                write!(
+                    formatter,
+                    "fixed slab slot {slot} is not currently allocated"
+                )
+            }
+        }
+    }
+}
+
+impl Error for FixedSlabAllocatorError {}
+
+#[derive(Debug)]
+struct FixedSlabState {
+    free_slots: Vec<u32>,
+    allocated: Vec<bool>,
+    validation_marks: Vec<u64>,
+    validation_epoch: u64,
+}
+
+/// Thread-safe allocator for a fixed number of equally sized slab slots.
+///
+/// Reservations are all-or-none. Releases validate every supplied slot before
+/// changing allocator state, so an invalid release cannot partially free slots.
+#[derive(Debug)]
+pub struct FixedSlabAllocator {
+    capacity: u32,
+    state: Mutex<FixedSlabState>,
+}
+
+impl FixedSlabAllocator {
+    pub fn new(capacity: u32) -> Result<Self, FixedSlabAllocatorError> {
+        if capacity == 0 {
+            return Err(FixedSlabAllocatorError::ZeroCapacity);
+        }
+        Ok(Self {
+            capacity,
+            state: Mutex::new(FixedSlabState {
+                free_slots: (0..capacity).rev().collect(),
+                allocated: vec![false; capacity as usize],
+                validation_marks: vec![0; capacity as usize],
+                validation_epoch: 0,
+            }),
+        })
+    }
+
+    /// Reserves exactly `count` slots, or returns `None` without changing state.
+    pub fn try_reserve(&self, count: u32) -> Option<Vec<u32>> {
+        let mut state = self.state.lock();
+        let count = count as usize;
+        if count > state.free_slots.len() {
+            return None;
+        }
+
+        let mut slots = Vec::with_capacity(count);
+        for _ in 0..count {
+            let slot = state
+                .free_slots
+                .pop()
+                .expect("fixed slab free count was checked before reservation");
+            let was_allocated = std::mem::replace(&mut state.allocated[slot as usize], true);
+            assert!(!was_allocated, "fixed slab freelist contained a live slot");
+            slots.push(slot);
+        }
+        Some(slots)
+    }
+
+    /// Atomically releases all supplied slots after validating the full input.
+    pub fn release(&self, slots: &[u32]) -> Result<(), FixedSlabAllocatorError> {
+        let mut state = self.state.lock();
+        state.validation_epoch = state.validation_epoch.wrapping_add(1);
+        if state.validation_epoch == 0 {
+            state.validation_marks.fill(0);
+            state.validation_epoch = 1;
+        }
+        let validation_epoch = state.validation_epoch;
+
+        for &slot in slots {
+            if slot >= self.capacity {
+                return Err(FixedSlabAllocatorError::SlotOutOfBounds {
+                    slot,
+                    capacity: self.capacity,
+                });
+            }
+            let slot_index = slot as usize;
+            if state.validation_marks[slot_index] == validation_epoch {
+                return Err(FixedSlabAllocatorError::DuplicateSlot { slot });
+            }
+            state.validation_marks[slot_index] = validation_epoch;
+        }
+        for &slot in slots {
+            if !state.allocated[slot as usize] {
+                return Err(FixedSlabAllocatorError::SlotNotAllocated { slot });
+            }
+        }
+
+        for &slot in slots {
+            state.allocated[slot as usize] = false;
+            state.free_slots.push(slot);
+        }
+        Ok(())
+    }
+
+    pub fn capacity(&self) -> u32 {
+        self.capacity
+    }
+
+    pub fn free_count(&self) -> u32 {
+        self.state.lock().free_slots.len() as u32
+    }
+
+    pub fn live_count(&self) -> u32 {
+        self.capacity - self.free_count()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.free_count() == self.capacity
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{FixedSlabAllocator, FixedSlabAllocatorError};
+    use std::collections::HashSet;
+    use std::sync::{Arc, Mutex};
+    use std::thread;
+
+    #[test]
+    fn rejects_zero_capacity() {
+        assert!(matches!(
+            FixedSlabAllocator::new(0),
+            Err(FixedSlabAllocatorError::ZeroCapacity)
+        ));
+    }
+
+    #[test]
+    fn reserve_is_ordered_and_all_or_none() {
+        let allocator = FixedSlabAllocator::new(4).unwrap();
+        assert_eq!(allocator.try_reserve(3), Some(vec![0, 1, 2]));
+        assert_eq!(allocator.free_count(), 1);
+        assert_eq!(allocator.live_count(), 3);
+
+        assert_eq!(allocator.try_reserve(2), None);
+        assert_eq!(allocator.free_count(), 1);
+        assert_eq!(allocator.try_reserve(1), Some(vec![3]));
+        assert_eq!(allocator.try_reserve(0), Some(Vec::new()));
+        assert!(!allocator.is_empty());
+    }
+
+    #[test]
+    fn released_slots_are_reused_and_counts_close() {
+        let allocator = FixedSlabAllocator::new(4).unwrap();
+        let slots = allocator.try_reserve(3).unwrap();
+        allocator.release(&slots[2..]).unwrap();
+        assert_eq!(allocator.try_reserve(1), Some(vec![2]));
+        allocator.release(&slots[..2]).unwrap();
+        allocator.release(&[2]).unwrap();
+
+        assert_eq!(allocator.capacity(), 4);
+        assert_eq!(allocator.free_count(), 4);
+        assert_eq!(allocator.live_count(), 0);
+        assert!(allocator.is_empty());
+    }
+
+    #[test]
+    fn invalid_release_is_atomic() {
+        let allocator = FixedSlabAllocator::new(4).unwrap();
+        assert_eq!(allocator.try_reserve(2), Some(vec![0, 1]));
+
+        assert_eq!(
+            allocator.release(&[0, 0]),
+            Err(FixedSlabAllocatorError::DuplicateSlot { slot: 0 })
+        );
+        assert_eq!(allocator.live_count(), 2);
+        assert_eq!(
+            allocator.release(&[0, 4]),
+            Err(FixedSlabAllocatorError::SlotOutOfBounds {
+                slot: 4,
+                capacity: 4,
+            })
+        );
+        assert_eq!(allocator.live_count(), 2);
+
+        allocator.release(&[0]).unwrap();
+        assert_eq!(
+            allocator.release(&[0]),
+            Err(FixedSlabAllocatorError::SlotNotAllocated { slot: 0 })
+        );
+        assert_eq!(allocator.live_count(), 1);
+        allocator.release(&[1]).unwrap();
+        assert!(allocator.is_empty());
+    }
+
+    #[test]
+    fn concurrent_single_slot_reservations_are_unique() {
+        let allocator = Arc::new(FixedSlabAllocator::new(64).unwrap());
+        let reserved = Arc::new(Mutex::new(Vec::new()));
+        let workers = (0..8)
+            .map(|_| {
+                let allocator = Arc::clone(&allocator);
+                let reserved = Arc::clone(&reserved);
+                thread::spawn(move || {
+                    while let Some(mut slots) = allocator.try_reserve(1) {
+                        reserved.lock().unwrap().append(&mut slots);
+                    }
+                })
+            })
+            .collect::<Vec<_>>();
+        for worker in workers {
+            worker.join().unwrap();
+        }
+
+        let slots = reserved.lock().unwrap();
+        assert_eq!(slots.len(), 64);
+        assert_eq!(slots.iter().copied().collect::<HashSet<_>>().len(), 64);
+        allocator.release(&slots).unwrap();
+        assert!(allocator.is_empty());
+    }
+}
diff --git a/fluxon_rs/fluxon_util/src/lib.rs b/fluxon_rs/fluxon_util/src/lib.rs
index 8d13b8e..b95ff96 100644
--- a/fluxon_rs/fluxon_util/src/lib.rs
+++ b/fluxon_rs/fluxon_util/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod dag_viz_html;
 pub mod dev_config;
+pub mod fixed_slab_allocator;
 pub mod fs_statvfs;
 pub mod fs_watch;
 pub mod git_version_build_record;

From b221a538777c28bdfb6068add57b9424f75ab2ce Mon Sep 17 00:00:00 2001
From: zTz01 <1773266173@qq.com>
Date: Tue, 28 Jul 2026 13:47:01 +0800
Subject: [PATCH 10/10] ssd

---
 fluxon_py/config.py                           |   54 +-
 fluxon_py/tests/test_config.py                |   82 +
 fluxon_rs/Cargo.lock                          |  326 +++-
 fluxon_rs/fluxon_kv/Cargo.toml                |    1 +
 .../src/client_kv_api/external_api.rs         |  126 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/get.rs  |  179 +-
 fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs  | 1519 ++++++++++++++++-
 .../fluxon_kv/src/client_kv_api/msg_pack.rs   |   32 +
 fluxon_rs/fluxon_kv/src/client_kv_api/put.rs  |  958 +++++++++--
 .../fluxon_kv/src/client_kv_api/reclaim.rs    |  541 ++++--
 .../fluxon_kv/src/cluster_manager/mod.rs      |    2 +
 fluxon_rs/fluxon_kv/src/config.rs             |  240 +++
 .../external_client_test.rs                   |    2 +
 .../fluxon_kv/src/external_client_api/mod.rs  |  477 +++++-
 fluxon_rs/fluxon_kv/src/kv_ssd_storage.rs     | 1360 +++++++++++++++
 fluxon_rs/fluxon_kv/src/kv_test.rs            |    3 +-
 fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs    |   30 +
 fluxon_rs/fluxon_kv/src/lib.rs                |   33 +
 .../fluxon_kv/src/master_kv_router/delete.rs  |    8 +-
 .../fluxon_kv/src/master_kv_router/get.rs     |  750 ++++++--
 .../fluxon_kv/src/master_kv_router/mod.rs     | 1200 ++++++++++---
 .../src/master_kv_router/msg_pack.rs          |  187 +-
 .../src/master_kv_router/placement.rs         |   43 +-
 .../fluxon_kv/src/master_kv_router/put.rs     |  255 ++-
 .../fluxon_kv/src/master_kv_router/reclaim.rs | 1272 +++++++++++---
 .../src/master_kv_router/route_maintenance.rs |    2 +-
 .../fluxon_kv/src/master_seg_manager/mod.rs   |  228 ++-
 .../master_seg_manager/one_seg_allocator.rs   |  306 +++-
 fluxon_rs/fluxon_kv/src/memholder/lifetime.rs |    8 +-
 .../fluxon_kv/src/memholder/memholder_test.rs |    4 +-
 fluxon_rs/fluxon_kv/src/memholder/mod.rs      |   57 +-
 .../rpcresp_kvresult_convert/msg_and_error.rs |    6 +
 fluxon_rs/fluxon_pyo3/src/lib.rs              |   25 +-
 setup_and_pack/rather_no_git_submodule.yaml   |    2 +-
 34 files changed, 9187 insertions(+), 1131 deletions(-)
 create mode 100644 fluxon_rs/fluxon_kv/src/kv_ssd_storage.rs

diff --git a/fluxon_py/config.py b/fluxon_py/config.py
index 4eff497..7340d5f 100644
--- a/fluxon_py/config.py
+++ b/fluxon_py/config.py
@@ -83,6 +83,7 @@ def _yaml_template():
   prefer_local_placement: false        # Prefer placing new KV writes on the requester-local owner when possible (bool(optional))
   short_circuit_put_payload_path: false # Keep large put_start allocation but skip payload memcpy + transfer (bool(optional))
   skip_put_end_commit: false           # Return success after payload transfer without put_done commit; inflight_put TTL cleanup only (bool(optional))
+  ssd_read_source_policy: legacy_remote_first # legacy_remote_first|local_ssd_only_first (str(optional))
   owner_local_reserve_soft_wait_timeout_ms: # Local-reserve polling interval, >0 (int(optional))
   owner_local_reserve_hard_timeout_ms: # Local-reserve end-to-end claim timeout, > soft wait (int(optional))
   owner_local_reserve_expected_capacity: # Owner-only local-reserve prewarm target (dict(optional))
@@ -117,6 +118,9 @@ def _yaml_template():
   cluster_name:                       # Cluster name (str)
   share_mem_path:                     # Shared bundle path for mmap.file/shared.json/peer metadata (str)
   large_file_paths:                   # Owner-mode ordered large-file roots (['{str}'](optional))
+  large_limit_size:                   # Optional per-root SSD capacity in bytes (list(optional))
+  ssd_write_rate_limit_bytes_per_sec: # Optional non-queueing SSD write rate (int(optional))
+  ssd_write_burst_bytes:              # Paired immediate SSD write burst (int(optional))
   p2p_listen_port:                    # P2P QUIC listen port override (int(optional))
   redis_compat:                       # Enable Redis protocol shim (dict(optional))
     listen_addr:                      # TCP listen addr, e.g. "127.0.0.1:16379" (str)
@@ -142,6 +146,7 @@ def _normalize_test_spec_config(raw: Any, ctx: str) -> Dict[str, Any]:
         "prefer_local_placement",
         "short_circuit_put_payload_path",
         "skip_put_end_commit",
+        "ssd_read_source_policy",
         "owner_local_reserve_soft_wait_timeout_ms",
         "owner_local_reserve_hard_timeout_ms",
         "owner_local_reserve_expected_capacity",
@@ -183,6 +188,21 @@ def _normalize_test_spec_config(raw: Any, ctx: str) -> Dict[str, Any]:
                 raise ValueError(f"{ctx}.{key} must be a bool")
             out[key] = value
 
+    ssd_read_source_policy = raw.get("ssd_read_source_policy")
+    if ssd_read_source_policy is not None:
+        if not isinstance(ssd_read_source_policy, str):
+            raise ValueError(f"{ctx}.ssd_read_source_policy must be a string")
+        allowed_ssd_read_source_policies = {
+            "legacy_remote_first",
+            "local_ssd_only_first",
+        }
+        if ssd_read_source_policy not in allowed_ssd_read_source_policies:
+            raise ValueError(
+                f"{ctx}.ssd_read_source_policy must be one of "
+                f"{sorted(allowed_ssd_read_source_policies)}, got {ssd_read_source_policy!r}"
+            )
+        out["ssd_read_source_policy"] = ssd_read_source_policy
+
     transport_mode = raw.get("transport_mode")
     transport_mode_was_explicit = transport_mode is not None
     side_transfer_role_raw = raw.get("side_transfer_role")
@@ -446,6 +466,9 @@ def _validate_fluxonkv_contract(cfg: Dict[str, Any]) -> None:
             "redis_compat",
             "sub_cluster",
             "large_file_paths",
+            "large_limit_size",
+            "ssd_write_rate_limit_bytes_per_sec",
+            "ssd_write_burst_bytes",
         ]
         for key in forbidden_spec_keys:
             if key in spec:
@@ -502,6 +525,26 @@ def _validate_fluxonkv_contract(cfg: Dict[str, Any]) -> None:
                 f"fluxonkv_spec.large_file_paths[{idx}] must be a non-empty string in owner mode"
             )
 
+    write_rate = spec.get("ssd_write_rate_limit_bytes_per_sec")
+    write_burst = spec.get("ssd_write_burst_bytes")
+    if (write_rate is None) != (write_burst is None):
+        raise ValueError(
+            "fluxonkv_spec.ssd_write_rate_limit_bytes_per_sec and "
+            "ssd_write_burst_bytes must be configured together"
+        )
+    if write_rate is not None:
+        if (
+            isinstance(write_rate, bool)
+            or not isinstance(write_rate, int)
+            or write_rate <= 0
+            or isinstance(write_burst, bool)
+            or not isinstance(write_burst, int)
+            or write_burst <= 0
+        ):
+            raise ValueError("SSD write rate and burst must both be positive integers")
+        if "large_limit_size" not in spec:
+            raise ValueError("SSD write admission requires fluxonkv_spec.large_limit_size")
+
 
 class FluxonKvClientConfig():
     """Configuration class for KV Cache stores that reads from YAML config files."""
@@ -852,8 +895,8 @@ def parse_type_recursive(type_str: str) -> Optional[Tuple[str, Dict[str, Any]]]:
                         return parsed_type_name, merged_params
                     return type_name, {"constraint": constraint}
         
-        # 6) Primitive types: str, int, float, bool, None
-        if type_str in ["str", "int", "float", "bool", "None"]:
+        # 6) Primitive types: str, int, float, bool, list, None
+        if type_str in ["str", "int", "float", "bool", "list", "None"]:
             return type_str, {}
         
         debug_print("type_str ", type_str, "not matched to any type")
@@ -989,6 +1032,13 @@ def raise_validation_error(msg: str):
                 raise_validation_error(f"Expected bool, got {type(value).__name__}")
             else:
                 return None
+
+    elif type_name == "list":
+        if not isinstance(value, list):
+            if raise_err:
+                raise_validation_error(f"Expected list, got {type(value).__name__}")
+            else:
+                return None
     
     elif type_name == "dict":
         if not isinstance(value, dict):
diff --git a/fluxon_py/tests/test_config.py b/fluxon_py/tests/test_config.py
index 3ed2a5e..0b7cdc6 100644
--- a/fluxon_py/tests/test_config.py
+++ b/fluxon_py/tests/test_config.py
@@ -49,6 +49,7 @@ def _build_checks(selected_test_id: Optional[str]) -> List[Tuple[str, Callable[[
         ("fluxonkv_owner_requires_sub_cluster", test_fluxonkv_owner_requires_sub_cluster),
         ("fluxonkv_owner_requires_large_file_paths", test_fluxonkv_owner_requires_large_file_paths),
         ("fluxonkv_external_forbids_large_file_paths", test_fluxonkv_external_forbids_large_file_paths),
+        ("fluxonkv_owner_ssd_capacity", test_fluxonkv_owner_ssd_capacity),
         ("fluxonkv_p2p_relay_removed", test_fluxonkv_p2p_relay_removed),
         ("fluxon_client_config_yaml_shape", test_fluxon_client_config_yaml_shape),
         ("fluxonkv_protocol_field", test_fluxonkv_protocol_field),
@@ -334,6 +335,66 @@ def test_fluxonkv_external_forbids_large_file_paths():
         print(f"❌ FAIL: test_fluxonkv_external_forbids_large_file_paths - {e}")
 
 
+def test_fluxonkv_owner_ssd_capacity():
+    """Ensure the Python schema forwards owner SSD capacity to Rust unchanged."""
+    try:
+        owner = _owner_fluxonkv_base_config(tag="owner_ssd_capacity")
+        owner["fluxonkv_spec"]["large_limit_size"] = [67108864]
+        owner["fluxonkv_spec"]["ssd_write_rate_limit_bytes_per_sec"] = 268435456
+        owner["fluxonkv_spec"]["ssd_write_burst_bytes"] = 67108864
+        config = FluxonKvClientConfig(owner)
+        assert config.to_dict()["fluxonkv_spec"]["large_limit_size"] == [67108864]
+        assert (
+            config.to_dict()["fluxonkv_spec"]["ssd_write_rate_limit_bytes_per_sec"]
+            == 268435456
+        )
+        assert config.to_dict()["fluxonkv_spec"]["ssd_write_burst_bytes"] == 67108864
+        rendered = config.to_fluxon_kv_client_config_yaml_str()
+        assert "large_limit_size:" in rendered
+        assert "- 67108864" in rendered
+        assert "ssd_write_rate_limit_bytes_per_sec: 268435456" in rendered
+        assert "ssd_write_burst_bytes: 67108864" in rendered
+
+        unpaired = _owner_fluxonkv_base_config(tag="owner_ssd_unpaired_limit")
+        unpaired["fluxonkv_spec"]["large_limit_size"] = [67108864]
+        unpaired["fluxonkv_spec"]["ssd_write_rate_limit_bytes_per_sec"] = 1
+        try:
+            FluxonKvClientConfig(unpaired)
+            print("❌ FAIL: test_fluxonkv_owner_ssd_capacity - unpaired rate should be rejected")
+            return
+        except ValueError:
+            pass
+
+        wrong_shape = _owner_fluxonkv_base_config(tag="owner_ssd_capacity_wrong_shape")
+        wrong_shape["fluxonkv_spec"]["large_limit_size"] = 67108864
+        try:
+            FluxonKvClientConfig(wrong_shape)
+            print("❌ FAIL: test_fluxonkv_owner_ssd_capacity - non-list capacity should be rejected")
+            return
+        except ValueError:
+            pass
+
+        external = {
+            "instance_key": "test_external_ssd_capacity",
+            "contribute_to_cluster_pool_size": {"dram": 0, "vram": {}},
+            "fluxonkv_spec": {
+                "cluster_name": "test_cluster",
+                "share_mem_path": "/tmp/kvcache_shared_memory/test",
+                "large_limit_size": [67108864],
+            },
+        }
+        try:
+            FluxonKvClientConfig(external)
+            print("❌ FAIL: test_fluxonkv_owner_ssd_capacity - external capacity should be rejected")
+            return
+        except ValueError:
+            pass
+
+        print("✅ PASS: test_fluxonkv_owner_ssd_capacity")
+    except Exception as e:
+        print(f"❌ FAIL: test_fluxonkv_owner_ssd_capacity - {e}")
+
+
 def test_fluxonkv_p2p_relay_removed():
     """Ensure removed fluxonkv_spec.p2p_relay is rejected as an unknown key."""
     try:
@@ -530,6 +591,9 @@ def test_fluxonkv_test_spec_config():
         rdma_devices["test_spec_config"]["tcp_thread_bulk_lane_count"] = 4
         rdma_devices["test_spec_config"]["tcp_thread_control_lane_count"] = 3
         rdma_devices["test_spec_config"]["replica_task_max_inflight"] = 16
+        rdma_devices["test_spec_config"]["ssd_read_source_policy"] = (
+            "local_ssd_only_first"
+        )
         rdma_devices["test_spec_config"][
             "require_transfer_rpc_fast_path_ready_timeout_seconds"
         ] = 45
@@ -545,12 +609,30 @@ def test_fluxonkv_test_spec_config():
         assert loaded["test_spec_config"]["tcp_thread_bulk_lane_count"] == 4
         assert loaded["test_spec_config"]["tcp_thread_control_lane_count"] == 3
         assert loaded["test_spec_config"]["replica_task_max_inflight"] == 16
+        assert (
+            loaded["test_spec_config"]["ssd_read_source_policy"]
+            == "local_ssd_only_first"
+        )
         assert (
             loaded["test_spec_config"]["require_transfer_rpc_fast_path_ready_timeout_seconds"]
             == 45
         )
         assert config.protocol_rdma_device_names == "mlx5_0,mlx5_4"
 
+        for removed_policy in (
+            "local_ssd_after_memory",
+            "local_ssd_before_remote_memory",
+        ):
+            invalid_policy = copy.deepcopy(rdma_devices)
+            invalid_policy["test_spec_config"]["ssd_read_source_policy"] = removed_policy
+            try:
+                FluxonKvClientConfig(invalid_policy)
+                raise AssertionError(
+                    f"removed SSD read policy must be rejected: {removed_policy}"
+                )
+            except ValueError:
+                pass
+
         expected_capacity = _owner_fluxonkv_base_config(tag="expected_capacity")
         expected_capacity["contribute_to_cluster_pool_size"]["dram"] = 137438953472
         expected_capacity["test_spec_config"] = {
diff --git a/fluxon_rs/Cargo.lock b/fluxon_rs/Cargo.lock
index a4b0ecd..59b0cd0 100644
--- a/fluxon_rs/Cargo.lock
+++ b/fluxon_rs/Cargo.lock
@@ -485,6 +485,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d"
 dependencies = [
  "find-msvc-tools",
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
@@ -575,6 +577,12 @@ version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
 
+[[package]]
+name = "cmsketch"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7ee2cfacbd29706479902b06d75ad8f1362900836aa32799eabc7e004bfd854"
+
 [[package]]
 name = "cobs"
 version = "0.3.0"
@@ -615,6 +623,17 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "core_affinity"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342"
+dependencies = [
+ "libc",
+ "num_cpus",
+ "winapi",
+]
+
 [[package]]
 name = "cpp_demangle"
 version = "0.4.5"
@@ -960,6 +979,16 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
+[[package]]
+name = "fastant"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e825441bfb2d831c47c97d05821552db8832479f44c571b97fededbf0099c07"
+dependencies = [
+ "small_ctor",
+ "web-time",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@@ -1232,6 +1261,7 @@ dependencies = [
  "fluxon_framework_compiled",
  "fluxon_observability",
  "fluxon_util",
+ "foyer",
  "futures",
  "hex",
  "hyper 0.14.32",
@@ -1447,6 +1477,12 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "foreign-types"
 version = "0.3.2"
@@ -1471,6 +1507,130 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "foyer"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0abc0b87814989efa711f9becd9f26969820e2d3905db27d10969c4bd45890"
+dependencies = [
+ "anyhow",
+ "equivalent",
+ "foyer-common",
+ "foyer-memory",
+ "foyer-storage",
+ "foyer-tokio",
+ "futures-util",
+ "mea",
+ "mixtrics",
+ "pin-project",
+ "serde",
+ "tracing",
+]
+
+[[package]]
+name = "foyer-common"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3db80d5dece93adb7ad709c84578794724a9cba342a7e566c3551c7ec626789"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "bytes",
+ "cfg-if",
+ "foyer-tokio",
+ "mixtrics",
+ "parking_lot",
+ "pin-project",
+ "serde",
+ "twox-hash",
+]
+
+[[package]]
+name = "foyer-intrusive-collections"
+version = "0.10.0-dev"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e4fee46bea69e0596130e3210e65d3424e0ac1e6df3bde6636304bdf1ca4a3b"
+dependencies = [
+ "memoffset",
+]
+
+[[package]]
+name = "foyer-memory"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db907f40a527ca2aa2f40a5f68b32ea58aa70f050cd233518e9ffd402cfba6ce"
+dependencies = [
+ "anyhow",
+ "bitflags 2.9.1",
+ "cmsketch",
+ "equivalent",
+ "foyer-common",
+ "foyer-intrusive-collections",
+ "foyer-tokio",
+ "futures-util",
+ "hashbrown 0.16.1",
+ "itertools 0.14.0",
+ "mea",
+ "mixtrics",
+ "parking_lot",
+ "paste",
+ "pin-project",
+ "serde",
+ "tracing",
+]
+
+[[package]]
+name = "foyer-storage"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1983f1db3d0710e9c9d5fc116d9202dccd41a2d1e032572224f1aff5520aa958"
+dependencies = [
+ "allocator-api2",
+ "anyhow",
+ "bytes",
+ "core_affinity",
+ "equivalent",
+ "fastant",
+ "foyer-common",
+ "foyer-memory",
+ "foyer-tokio",
+ "fs4",
+ "futures-core",
+ "futures-util",
+ "hashbrown 0.16.1",
+ "io-uring",
+ "itertools 0.14.0",
+ "libc",
+ "lz4",
+ "mea",
+ "parking_lot",
+ "pin-project",
+ "rand 0.9.2",
+ "serde",
+ "tracing",
+ "twox-hash",
+ "zstd",
+]
+
+[[package]]
+name = "foyer-tokio"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6577b05a7ffad0db555aedf00bfe52af818220fc4c1c3a7a12520896fc38627"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "fs4"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8640e34b88f7652208ce9e88b1a37a2ae95227d84abec377ccd3c5cfeb141ed4"
+dependencies = [
+ "rustix 1.0.7",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -1618,11 +1778,22 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasi 0.14.2+wasi-0.2.4",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+]
+
 [[package]]
 name = "gimli"
 version = "0.31.1"
@@ -1711,7 +1882,18 @@ checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
@@ -2395,6 +2577,17 @@ dependencies = [
  "str_stack",
 ]
 
+[[package]]
+name = "io-uring"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9080b15e63775b9a2ac7dca720f7050a8b955e092ea0f6020a4a80f69998cdc0"
+dependencies = [
+ "bitflags 2.9.1",
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.11.0"
@@ -2446,12 +2639,40 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
+[[package]]
+name = "jobserver"
+version = "0.1.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
+dependencies = [
+ "getrandom 0.4.3",
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -2586,6 +2807,25 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 
+[[package]]
+name = "lz4"
+version = "1.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a20b523e860d03443e98350ceaac5e71c6ba89aea7d960769ec3ce37f4de5af4"
+dependencies = [
+ "lz4-sys",
+]
+
+[[package]]
+name = "lz4-sys"
+version = "1.11.1+lz4-1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "matchers"
 version = "0.1.0"
@@ -2601,6 +2841,15 @@ version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
 
+[[package]]
+name = "mea"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2640d335e7273dacdcf51044026139b2e269c3bb0dfc3f8cb3496b85e3f6a42c"
+dependencies = [
+ "slab",
+]
+
 [[package]]
 name = "memchr"
 version = "2.7.5"
@@ -2668,6 +2917,16 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "mixtrics"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c46b5adfb7a3ae4996d327a5bdc90e78fec025806dd312bdbe6f07a755e0ec9"
+dependencies = [
+ "itertools 0.15.0",
+ "parking_lot",
+]
+
 [[package]]
 name = "moka"
 version = "0.12.11"
@@ -2831,6 +3090,16 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
 [[package]]
 name = "object"
 version = "0.36.7"
@@ -3498,6 +3767,12 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "rand"
 version = "0.7.3"
@@ -4206,9 +4481,15 @@ checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "small_ctor"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88414a5ca1f85d82cc34471e975f0f74f6aa54c40f062efa42c0080e7f763f81"
 
 [[package]]
 name = "smallvec"
@@ -5080,6 +5361,15 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "twox-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8464ec13c3691491391d9fce00f6416c9a48e46972f72d7865688be2080192c9"
+dependencies = [
+ "rand 0.9.2",
+]
+
 [[package]]
 name = "typenum"
 version = "1.18.0"
@@ -5902,3 +6192,31 @@ dependencies = [
  "quote",
  "syn 2.0.104",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/fluxon_rs/fluxon_kv/Cargo.toml b/fluxon_rs/fluxon_kv/Cargo.toml
index 22ff136..2d0208c 100644
--- a/fluxon_rs/fluxon_kv/Cargo.toml
+++ b/fluxon_rs/fluxon_kv/Cargo.toml
@@ -75,6 +75,7 @@ bytes = "1"
 pprof = { version = "0.15", features = ["flamegraph"] }
 hex = "0.4"
 sha2 = "0.10"
+foyer = { version = "0.22.3", features = ["serde"] }
 tokio-tungstenite = { version = "0.21", default-features = false, features = ["connect", "handshake"], optional = true }
 
 sockudo-ws = { version = "^1.7.4", default-features = false, features = ["tokio-runtime", "fastrand"], optional = true }
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
index e6f3caa..c63a298 100755
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/external_api.rs
@@ -1298,6 +1298,7 @@ mod external_get_start_batch_tests {
                 external_pending_puts: 0,
                 external_put: None,
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(old.clone()),
@@ -1329,6 +1330,7 @@ mod external_get_start_batch_tests {
                 external_pending_puts: 0,
                 external_put: None,
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: Some(op.clone()),
@@ -3586,7 +3588,8 @@ impl HandlerForExternalClient for ClientKvApi {
                     remote_offset
                 },
                 len: req.len,
-                make_replica_task: req.make_replica_task && replica_admitted,
+                make_replica_task: req.make_replica_task,
+                remote_replica_admitted: replica_admitted,
                 preferred_sub_cluster: req.preferred_sub_cluster.clone(),
                 local_reserve_slot: None,
                 local_reserve_slot_size: None,
@@ -3838,6 +3841,7 @@ impl HandlerForExternalClient for ClientKvApi {
                     target_offset: src_offset,
                     len: req_item.len,
                     make_replica_task: req_item.make_replica_task,
+                    remote_replica_admitted: true,
                     preferred_sub_cluster: req_item.preferred_sub_cluster.clone(),
                     local_reserve_slot: Some(slot_ref.clone()),
                     local_reserve_slot_size: Some(slot_size),
@@ -3916,7 +3920,8 @@ impl HandlerForExternalClient for ClientKvApi {
                 return Ok(ExternalPutTransferEndResp::from_error(&err));
             }
         };
-        let admitted_replica_task = pending_ctx.make_replica_task;
+        let admitted_replica_task =
+            pending_ctx.make_replica_task && pending_ctx.remote_replica_admitted;
         let self_node_id = inner.view.cluster_manager().get_self_info().id.clone();
         let req_remote_target = req
             .peer_id
@@ -4053,6 +4058,13 @@ impl HandlerForExternalClient for ClientKvApi {
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+        if pending_ctx.make_replica_task {
+            inner.start_early_owner_local_ssd_put(
+                &req.key,
+                put_id,
+                u64::from(local_cache_publish.len),
+            );
+        }
         if admitted_replica_task {
             if let Err(err) = inner
                 .ensure_remote_put(
@@ -4125,6 +4137,7 @@ impl HandlerForExternalClient for ClientKvApi {
             put_locality: Option<(bool, i64)>,
             local_cache_publish: LocalCommittedCachePublish,
             make_replica_task: bool,
+            remote_replica_admitted: bool,
             // Keep the per-key reclaim fence alive until the master's terminal
             // response has been applied to the owner-local index.
             _pending_ctx: ExternalPendingPutCtx,
@@ -4214,6 +4227,7 @@ impl HandlerForExternalClient for ClientKvApi {
                             lease_id: item.lease_id,
                             committed_slot,
                             make_replica_task: pending_ctx.make_replica_task,
+                            remote_replica_admitted: pending_ctx.remote_replica_admitted,
                             preferred_sub_cluster: pending_ctx.preferred_sub_cluster.clone(),
                             atomic_group: pending_ctx.atomic_group.clone(),
                         });
@@ -4288,6 +4302,7 @@ impl HandlerForExternalClient for ClientKvApi {
                 put_locality: Some((false, 0)),
                 local_cache_publish,
                 make_replica_task: pending_ctx.make_replica_task,
+                remote_replica_admitted: pending_ctx.remote_replica_admitted,
                 _pending_ctx: pending_ctx,
             });
         }
@@ -4380,6 +4395,8 @@ impl HandlerForExternalClient for ClientKvApi {
             }));
         }
 
+        let mut early_ssd_candidates = Vec::new();
+        let mut remote_replica_pending = Vec::new();
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
@@ -4414,23 +4431,18 @@ impl HandlerForExternalClient for ClientKvApi {
                 pending.put_id.1,
             ));
             if pending.make_replica_task {
-                if let Err(err) = inner
-                    .ensure_remote_put(
-                        &pending.key,
-                        pending.put_id,
-                        pending._pending_ctx.preferred_sub_cluster.clone(),
-                        true,
-                    )
-                    .await
-                {
-                    tracing::warn!(
-                        "external_batch_put_transfer_end make replica task failed after local commit: key={} put_id=({},{}) err={}",
-                        pending.key,
-                        pending.put_id.0,
-                        pending.put_id.1,
-                        err
-                    );
-                }
+                early_ssd_candidates.push((
+                    pending.key.clone(),
+                    pending.put_id,
+                    u64::from(pending.local_cache_publish.len),
+                ));
+            }
+            if pending.make_replica_task && pending.remote_replica_admitted {
+                remote_replica_pending.push((
+                    pending.key.clone(),
+                    pending.put_id,
+                    pending._pending_ctx.preferred_sub_cluster.clone(),
+                ));
             }
             results[pending.idx] = Some(ExternalBatchPutTransferEndItemResp {
                 error_code: OK,
@@ -4438,6 +4450,22 @@ impl HandlerForExternalClient for ClientKvApi {
             });
         }
 
+        inner.start_early_owner_local_ssd_puts(early_ssd_candidates);
+        for (key, put_id, preferred_sub_cluster) in remote_replica_pending {
+            if let Err(err) = inner
+                .ensure_remote_put(&key, put_id, preferred_sub_cluster, true)
+                .await
+            {
+                tracing::warn!(
+                    "external_batch_put_transfer_end make replica task failed after local commit: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
+
         Ok(ExternalBatchPutTransferEndResp {
             items: results
                 .into_iter()
@@ -4512,7 +4540,8 @@ impl HandlerForExternalClient for ClientKvApi {
             }
             return Ok(ExternalPutCommitResp::from_error(&err));
         }
-        let admitted_replica_task = pending_ctx.make_replica_task;
+        let admitted_replica_task =
+            pending_ctx.make_replica_task && pending_ctx.remote_replica_admitted;
 
         let end_started_at = Instant::now();
         let local_cache_publish = match local_committed_cache_publish(
@@ -4587,6 +4616,13 @@ impl HandlerForExternalClient for ClientKvApi {
         inner
             .external_pending_puts
             .invalidate(&(req.key.clone(), put_id.0, put_id.1));
+        if pending_ctx.make_replica_task {
+            inner.start_early_owner_local_ssd_put(
+                &req.key,
+                put_id,
+                u64::from(local_cache_publish.len),
+            );
+        }
         if admitted_replica_task {
             if let Err(err) = inner
                 .ensure_remote_put(
@@ -4650,6 +4686,7 @@ impl HandlerForExternalClient for ClientKvApi {
             lease_id: Option<u64>,
             local_cache_publish: LocalCommittedCachePublish,
             make_replica_task: bool,
+            remote_replica_admitted: bool,
             _pending_ctx: ExternalPendingPutCtx,
         }
 
@@ -4736,6 +4773,7 @@ impl HandlerForExternalClient for ClientKvApi {
                             lease_id: item.lease_id,
                             committed_slot,
                             make_replica_task: pending_ctx.make_replica_task,
+                            remote_replica_admitted: pending_ctx.remote_replica_admitted,
                             preferred_sub_cluster: pending_ctx.preferred_sub_cluster.clone(),
                             atomic_group: pending_ctx.atomic_group.clone(),
                         });
@@ -4804,6 +4842,7 @@ impl HandlerForExternalClient for ClientKvApi {
                 lease_id: item.lease_id,
                 local_cache_publish,
                 make_replica_task: pending_ctx.make_replica_task,
+                remote_replica_admitted: pending_ctx.remote_replica_admitted,
                 _pending_ctx: pending_ctx,
             });
         }
@@ -4893,6 +4932,8 @@ impl HandlerForExternalClient for ClientKvApi {
             }));
         }
 
+        let mut early_ssd_candidates = Vec::new();
+        let mut remote_replica_pending = Vec::new();
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
@@ -4924,23 +4965,18 @@ impl HandlerForExternalClient for ClientKvApi {
                 pending.put_id.1,
             ));
             if pending.make_replica_task {
-                if let Err(err) = inner
-                    .ensure_remote_put(
-                        &pending.key,
-                        pending.put_id,
-                        pending._pending_ctx.preferred_sub_cluster.clone(),
-                        true,
-                    )
-                    .await
-                {
-                    tracing::warn!(
-                        "external_batch_put_commit make replica task failed after local commit: key={} put_id=({},{}) err={}",
-                        pending.key,
-                        pending.put_id.0,
-                        pending.put_id.1,
-                        err
-                    );
-                }
+                early_ssd_candidates.push((
+                    pending.key.clone(),
+                    pending.put_id,
+                    u64::from(pending.local_cache_publish.len),
+                ));
+            }
+            if pending.make_replica_task && pending.remote_replica_admitted {
+                remote_replica_pending.push((
+                    pending.key.clone(),
+                    pending.put_id,
+                    pending._pending_ctx.preferred_sub_cluster.clone(),
+                ));
             }
             results[pending.idx] = Some(ExternalBatchPutCommitItemResp {
                 error_code: OK,
@@ -4948,6 +4984,22 @@ impl HandlerForExternalClient for ClientKvApi {
             });
         }
 
+        inner.start_early_owner_local_ssd_puts(early_ssd_candidates);
+        for (key, put_id, preferred_sub_cluster) in remote_replica_pending {
+            if let Err(err) = inner
+                .ensure_remote_put(&key, put_id, preferred_sub_cluster, true)
+                .await
+            {
+                tracing::warn!(
+                    "external_batch_put_commit make replica task failed after local commit: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
+
         Ok(ExternalBatchPutCommitResp {
             items: results
                 .into_iter()
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
index 35e2dd4..27d57ec 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/get.rs
@@ -18,7 +18,7 @@ use crate::{
         BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp, BatchGetStartReq,
         BatchGetStartResp, BatchIsExistReq, GetAllocationMode, GetBindTarget, GetDoneReq,
         GetDoneResp, GetMetaReq, GetMetaResp, GetPreparedLocalReserveTarget, GetRevokeReq,
-        GetStartReq, GetStartResp,
+        GetSourceKind, GetStartReq, GetStartResp,
     },
     p2p::msg_pack::MsgPack,
     rpcresp_kvresult_convert::msg_and_error::codes_api,
@@ -28,6 +28,7 @@ use ::tokio::sync::Semaphore;
 use chrono::Utc;
 use futures::stream::{self, StreamExt};
 use limit_thirdparty::tokio;
+use std::collections::HashSet;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use std::time::Duration;
@@ -287,6 +288,10 @@ impl ClientKvApiInner {
         let mut lifecycle_remote_transfer_items = 0usize;
         let mut lifecycle_transfer_bytes = 0u64;
         let mut lifecycle_remote_transfer_bytes = 0u64;
+        let mut lifecycle_local_ssd_items = 0usize;
+        let mut lifecycle_remote_ssd_items = 0usize;
+        let mut lifecycle_transfer_source_nodes = HashSet::new();
+        let mut lifecycle_ssd_source_nodes = HashSet::new();
 
         for (idx, (key, start_item)) in keys.into_iter().zip(start_items.into_iter()).enumerate() {
             if start_item.error_code == codes_api::API_KEY_NOT_FOUND {
@@ -318,7 +323,20 @@ impl ClientKvApiInner {
             let target_addr = start_item.target_addr;
             let len = start_item.len;
 
-            if peer_id.is_none() && src_addr == target_addr {
+            lifecycle_transfer_source_nodes.insert(start_item.node_id.to_string());
+            if start_item.source_kind == GetSourceKind::Ssd {
+                lifecycle_ssd_source_nodes.insert(start_item.node_id.to_string());
+                if peer_is_remote {
+                    lifecycle_remote_ssd_items = lifecycle_remote_ssd_items.saturating_add(1);
+                } else {
+                    lifecycle_local_ssd_items = lifecycle_local_ssd_items.saturating_add(1);
+                }
+            }
+
+            if start_item.source_kind == GetSourceKind::Memory
+                && peer_id.is_none()
+                && src_addr == target_addr
+            {
                 lifecycle_zero_copy_items = lifecycle_zero_copy_items.saturating_add(1);
                 done_pending.push(DonePending {
                     idx,
@@ -341,19 +359,33 @@ impl ClientKvApiInner {
 
             transfer_futures.push(async move {
                 let transfer_started_at = Instant::now();
-                let transfer_result = self
-                    .view
-                    .client_transfer_engine()
-                    .transfer_data_no_copy(peer_id, true, src_addr, target_addr, len, None)
+                let transfer_result = if start_item.source_kind == GetSourceKind::Ssd {
+                    self.stage_kv_from_ssd_source(
+                        &start_item.node_id,
+                        &key,
+                        start_item.put_id,
+                        get_id,
+                        src_addr,
+                        len,
+                        target_addr,
+                        len,
+                    )
                     .await
-                    .map_err(|err| {
-                        KvError::Api(ApiError::Transfer {
-                            from_addr: src_addr,
-                            to_addr: target_addr,
-                            len,
-                            error: err.to_string(),
+                } else {
+                    self.view
+                        .client_transfer_engine()
+                        .transfer_data_no_copy(peer_id, true, src_addr, target_addr, len, None)
+                        .await
+                        .map(|_| ())
+                        .map_err(|err| {
+                            KvError::Api(ApiError::Transfer {
+                                from_addr: src_addr,
+                                to_addr: target_addr,
+                                len,
+                                error: err.to_string(),
+                            })
                         })
-                    });
+                };
                 let transfer_us = transfer_started_at
                     .elapsed()
                     .as_micros()
@@ -702,12 +734,16 @@ impl ClientKvApiInner {
             .as_micros()
             .min(i64::MAX as u128) as i64;
         tracing::info!(
-            "external Get finish lifecycle: requested={} transfer_concurrency={} zero_copy_items={} transfer_items={} remote_transfer_items={} transfer_bytes={} remote_transfer_bytes={} plan_us={} transfer_wall_us={} transfer_sum_us={} transfer_max_us={} transfer_cleanup_us={} install_us={} done_items={} done_attempts={} done_us={} local_hot_admissions={} publish_us={} hits={} misses={} errors={} total_us={}",
+            "external Get finish lifecycle: requested={} transfer_concurrency={} zero_copy_items={} transfer_items={} remote_transfer_items={} local_ssd_items={} remote_ssd_items={} transfer_source_nodes={} ssd_source_nodes={} transfer_bytes={} remote_transfer_bytes={} plan_us={} transfer_wall_us={} transfer_sum_us={} transfer_max_us={} transfer_cleanup_us={} install_us={} done_items={} done_attempts={} done_us={} local_hot_admissions={} publish_us={} hits={} misses={} errors={} total_us={}",
             lifecycle_requested_keys,
             transfer_concurrency,
             lifecycle_zero_copy_items,
             lifecycle_transfer_items,
             lifecycle_remote_transfer_items,
+            lifecycle_local_ssd_items,
+            lifecycle_remote_ssd_items,
+            lifecycle_transfer_source_nodes.len(),
+            lifecycle_ssd_source_nodes.len(),
             lifecycle_transfer_bytes,
             lifecycle_remote_transfer_bytes,
             lifecycle_plan_us,
@@ -847,7 +883,10 @@ impl ClientKvApiInner {
             let target_addr = start_item.target_addr;
             let len = start_item.len;
 
-            if peer_id.is_none() && src_addr == target_addr {
+            if start_item.source_kind == GetSourceKind::Memory
+                && peer_id.is_none()
+                && src_addr == target_addr
+            {
                 done_pending.push(DonePending {
                     idx,
                     key,
@@ -860,19 +899,33 @@ impl ClientKvApiInner {
 
             transfer_futures.push(async move {
                 let transfer_started_at = Instant::now();
-                let transfer_result = self
-                    .view
-                    .client_transfer_engine()
-                    .transfer_data_no_copy(peer_id, true, src_addr, target_addr, len, None)
+                let transfer_result = if start_item.source_kind == GetSourceKind::Ssd {
+                    self.stage_kv_from_ssd_source(
+                        &start_item.node_id,
+                        &key,
+                        start_item.put_id,
+                        get_id,
+                        src_addr,
+                        len,
+                        target_addr,
+                        len,
+                    )
                     .await
-                    .map_err(|err| {
-                        KvError::Api(ApiError::Transfer {
-                            from_addr: src_addr,
-                            to_addr: target_addr,
-                            len,
-                            error: err.to_string(),
+                } else {
+                    self.view
+                        .client_transfer_engine()
+                        .transfer_data_no_copy(peer_id, true, src_addr, target_addr, len, None)
+                        .await
+                        .map(|_| ())
+                        .map_err(|err| {
+                            KvError::Api(ApiError::Transfer {
+                                from_addr: src_addr,
+                                to_addr: target_addr,
+                                len,
+                                error: err.to_string(),
+                            })
                         })
-                    });
+                };
                 let transfer_us = transfer_started_at
                     .elapsed()
                     .as_micros()
@@ -1209,18 +1262,26 @@ impl ClientKvApiInner {
             );
         }
 
-        // transfer data (skip if local and src==target to avoid redundant copy)
-        if peer_id.is_none() && abs_src == abs_target {
+        let transfer_result = if resp.source_kind == GetSourceKind::Ssd {
+            self.stage_kv_from_ssd_source(
+                &resp.node_id,
+                key,
+                put_id,
+                get_id,
+                abs_src,
+                data_len as u64,
+                abs_target,
+                data_len as u64,
+            )
+            .await
+        } else if peer_id.is_none() && abs_src == abs_target {
             tracing::debug!(
                 "kv get local no-op: src==target {:#x}, len={} (skip transfer)",
                 abs_target,
                 data_len
             );
+            Ok(())
         } else {
-            // tracing::debug!(
-            //     "kv get transfer in transfer engine path from {}",
-            //     peer_id.as_ref().map(|v| &**v).unwrap_or("self")
-            // );
             tracing::debug!(
                 "p2p get transfer: key={}, remote_src={:#x} -> local_target={:#x}, len={}, peer={:?}",
                 key,
@@ -1229,8 +1290,7 @@ impl ClientKvApiInner {
                 data_len,
                 peer_id
             );
-            if let Err(e) = self
-                .view
+            self.view
                 .client_transfer_engine()
                 .transfer_data_no_copy(
                     peer_id.clone(),
@@ -1241,33 +1301,32 @@ impl ClientKvApiInner {
                     None,
                 )
                 .await
-            {
-                tracing::warn!("transfer data failed: {:?}", e);
-
-                #[cfg(test)]
-                {
-                    self.test_record.remove_transfering_get(get_id);
-                }
-
-                obe_get_transfer_error(&metrics, &client_id, &node_role, key, data_len as u64);
-                self.get_revoke(get_id).await?;
-                return Err(KvError::Api(ApiError::Transfer {
-                    from_addr: abs_src,
-                    to_addr: abs_target,
-                    len: data_len as u64,
-                    error: e.to_string(),
-                }));
-            } else {
-                tracing::debug!(
-                    "get_transfer success key={}, src_addr={:#x}, target_addr={:#x}, len={}, peer_id={:?}",
-                    key,
-                    abs_src,
-                    abs_target,
-                    data_len,
-                    peer_id
-                );
-            }
+                .map(|_| ())
+                .map_err(|err| {
+                    KvError::Api(ApiError::Transfer {
+                        from_addr: abs_src,
+                        to_addr: abs_target,
+                        len: data_len as u64,
+                        error: err.to_string(),
+                    })
+                })
+        };
+        if let Err(err) = transfer_result {
+            tracing::warn!("transfer data failed: {:?}", err);
+            #[cfg(test)]
+            self.test_record.remove_transfering_get(get_id);
+            obe_get_transfer_error(&metrics, &client_id, &node_role, key, data_len as u64);
+            self.get_revoke(get_id).await?;
+            return Err(err);
         }
+        tracing::debug!(
+            "get_transfer success key={}, src_addr={:#x}, target_addr={:#x}, len={}, peer_id={:?}",
+            key,
+            abs_src,
+            abs_target,
+            data_len,
+            peer_id
+        );
         let t3 = Utc::now().timestamp_micros();
         obe_get_transfer_success(
             &metrics,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
index 6d59d5f..5ecf000 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/mod.rs
@@ -15,17 +15,22 @@ use crate::client_kv_api::msg_pack::{
     ExternalIsExistResp, ExternalObservabilitySnapshotReq, ExternalObservabilitySnapshotResp,
     ExternalPutCommitReq, ExternalPutCommitResp, ExternalPutRevokeReq, ExternalPutRevokeResp,
     ExternalPutStartReq, ExternalPutStartResp, ExternalPutTransferEndReq,
-    ExternalPutTransferEndResp, SyncKvToFileReq, SyncKvToFileResp, TestPutPhaseTrace,
+    ExternalPutTransferEndResp, SsdStageReadReq, SsdStageReadResp, SyncKvToFileReq,
+    SyncKvToFileResp, TestPutPhaseTrace,
 };
 use crate::client_kv_api::reclaim::handle_batch_owner_reclaim;
+use crate::cluster_manager::app_logic_ext::ClusterManagerAppLogicExt;
 use crate::cluster_manager::{NodeID, NodeIDString};
 use crate::config::TestSpecConfig;
+use crate::kv_ssd_storage::{
+    KvSsdPersistBatchPermit, KvSsdPersistCopy, KvSsdPersistSource, KvSsdStorage, KvSsdStorageInit,
+};
 use crate::master_kv_router::msg_pack::{
     BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
     BatchEvictOwnerSourceReq, BatchGetBindReq, BatchGetDoneReq, BatchGetRevokeReq,
     BatchGetStartItemResp, BatchGetStartReq, BatchIsExistReq, BatchOwnerReclaimReq,
-    BatchPreparePutKeysReq, BatchPutAppendDoneReq, BatchPutAppendStartReq, BatchPutDoneReq,
-    BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq,
+    BatchPreparePutKeysReq, BatchPublishOwnerSsdReq, BatchPutAppendDoneReq, BatchPutAppendStartReq,
+    BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq,
     DeleteClientKvMetaCacheItem, GroupedBatchPutDoneReq,
 };
 use crate::master_lease_manager::msg_pack::{AllocateClientLeaseReq, ClientLeaseKeepaliveReq};
@@ -41,13 +46,13 @@ use crate::{
     master_kv_router::msg_pack::{
         DeleteReq, GetDoneReq, GetMetaReq, GetRevokeReq, GetStartReq, PutAppendDoneReq,
         PutAppendRevokeReq, PutAppendStartReq, PutDoneReq, PutRevokeReq, PutStartReq,
-        ReleaseLocalGrantReq, ReserveLocalGrantReq,
+        ReleaseLocalGrantReq, ReserveLocalGrantReq, SsdStageBeginReq, SsdStageDoneReq,
     },
     metric_reporter::{MetricReporter, MetricReporterAccessTrait},
     metrics::{KvLocalitySnapshot, MetricsHandle, OperationKind, RequestStage},
     p2p::{
         msg_pack::{RPCCaller, RPCHandler},
-        p2p_module::{P2pModule, P2pModuleAccessTrait},
+        p2p_module::{P2pModule, P2pModuleAccessTrait, RpcTransportPolicy},
     },
     rpcresp_kvresult_convert::msg_and_error::{ApiError, ErrorCode, KvError, KvResult},
 };
@@ -71,6 +76,129 @@ use tracing::warn;
 
 const OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY: usize = 4096;
 const OWNER_LOCAL_PUBLISH_MAX_INFLIGHT: usize = 64;
+const SSD_STAGE_RPC_TIMEOUT: Duration = Duration::from_secs(300);
+const SSD_STAGE_TERMINAL_TTL: Duration = Duration::from_secs(10 * 60);
+const SSD_STAGE_DONE_RETRY_INITIAL_BACKOFF: Duration = Duration::from_millis(50);
+const SSD_STAGE_DONE_RETRY_MAX_BACKOFF: Duration = Duration::from_secs(5);
+
+#[derive(Clone, Debug)]
+struct CompletedSsdStage {
+    request: SsdStageReadReq,
+    response: SsdStageReadResp,
+}
+
+struct SsdStageSharedOp {
+    request: SsdStageReadReq,
+    terminal: watch::Sender<Option<SsdStageReadResp>>,
+    completed: AtomicBool,
+}
+
+impl SsdStageSharedOp {
+    fn new(request: SsdStageReadReq) -> Arc<Self> {
+        let (terminal, _receiver) = watch::channel(None);
+        Arc::new(Self {
+            request,
+            terminal,
+            completed: AtomicBool::new(false),
+        })
+    }
+
+    fn complete(&self, response: SsdStageReadResp) -> bool {
+        if self
+            .completed
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_err()
+        {
+            return false;
+        }
+        self.terminal.send_replace(Some(response));
+        true
+    }
+
+    async fn wait(&self) -> SsdStageReadResp {
+        let mut terminal = self.terminal.subscribe();
+        loop {
+            if let Some(response) = terminal.borrow_and_update().clone() {
+                return response;
+            }
+            if terminal.changed().await.is_err() {
+                let err = KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "SSD stage singleflight closed without a terminal result: get_id={}",
+                        self.request.get_id
+                    ),
+                });
+                return ssd_stage_error_response(err);
+            }
+        }
+    }
+}
+
+fn ssd_stage_error_response(err: KvError) -> SsdStageReadResp {
+    SsdStageReadResp {
+        error_code: err.code(),
+        error_json: err.to_json(),
+    }
+}
+
+fn ssd_stage_request_mismatch_response(
+    expected: &SsdStageReadReq,
+    actual: &SsdStageReadReq,
+) -> SsdStageReadResp {
+    ssd_stage_error_response(KvError::Api(ApiError::InvalidArgument {
+        detail: format!(
+            "SSD stage get_id was reused with a different operation identity: get_id={} expected={:?} actual={:?}",
+            actual.get_id, expected, actual
+        ),
+    }))
+}
+
+#[cfg(test)]
+mod ssd_stage_singleflight_tests {
+    use super::{SsdStageReadReq, SsdStageReadResp, SsdStageSharedOp};
+    use crate::rpcresp_kvresult_convert::msg_and_error::OK;
+    use std::sync::Arc;
+
+    fn request(get_id: u64) -> SsdStageReadReq {
+        SsdStageReadReq {
+            key: "ssd-key".to_string(),
+            put_id: (17, 2),
+            get_id,
+            stage_addr: 0x1000,
+            stage_capacity: 8192,
+            len: 4096,
+        }
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn all_ssd_stage_followers_reuse_one_terminal_result() {
+        let op = SsdStageSharedOp::new(request(91));
+        let waiters = futures::future::join_all((0..64).map(|_| {
+            let waiter = op.clone();
+            async move { waiter.wait().await }
+        }));
+        let leader = async {
+            assert!(op.complete(SsdStageReadResp {
+                error_code: OK,
+                error_json: String::new(),
+            }));
+            assert!(
+                !op.complete(SsdStageReadResp {
+                    error_code: 1,
+                    error_json: "second terminal".to_string(),
+                }),
+                "the source operation must publish only one terminal result"
+            );
+        };
+        let (responses, ()) = futures::future::join(waiters, leader).await;
+
+        for response in responses {
+            assert_eq!(response.error_code, OK);
+            assert!(response.error_json.is_empty());
+        }
+        assert_eq!(Arc::strong_count(&op), 1);
+    }
+}
 
 /// Information about a memholder held by external client
 #[derive(Clone)]
@@ -87,6 +215,60 @@ pub struct ExternalHoldingGetInfo {
 
 #[derive(Clone, Debug, Default)]
 pub struct OwnerRuntimeObserveSnapshot {
+    pub ssd_capacity_bytes: u64,
+    pub ssd_used_bytes: u64,
+    pub ssd_persist_requests: u64,
+    pub ssd_persist_successes: u64,
+    pub ssd_persist_failures: u64,
+    pub ssd_persist_bytes: u64,
+    pub ssd_persist_duration_us: u64,
+    pub ssd_persist_batch_requests: u64,
+    pub ssd_persist_batch_items: u64,
+    pub ssd_persist_flush_batches: u64,
+    pub ssd_persist_busy_batches: u64,
+    pub ssd_persist_admission_skips: u64,
+    pub ssd_persist_batch_duration_us: u64,
+    pub ssd_write_candidate_items: u64,
+    pub ssd_write_candidate_bytes: u64,
+    pub ssd_write_admitted_items: u64,
+    pub ssd_write_admitted_bytes: u64,
+    pub ssd_write_dropped_items: u64,
+    pub ssd_write_dropped_bytes: u64,
+    pub ssd_write_refunded_items: u64,
+    pub ssd_write_refunded_bytes: u64,
+    pub ssd_load_requests: u64,
+    pub ssd_load_successes: u64,
+    pub ssd_load_misses: u64,
+    pub ssd_load_failures: u64,
+    pub ssd_load_bytes: u64,
+    pub ssd_load_duration_us: u64,
+    pub ssd_memory_hits: u64,
+    pub ssd_disk_hits: u64,
+    pub ssd_outer_hits: u64,
+    pub ssd_removals: u64,
+    pub ssd_stage_flights: u64,
+    pub ssd_stage_terminals: u64,
+    pub ssd_stage_ready_requests: u64,
+    pub ssd_stage_ready_successes: u64,
+    pub ssd_stage_ready_failures: u64,
+    pub ssd_stage_ready_duration_us: u64,
+    pub ssd_stage_execute_completions: u64,
+    pub ssd_stage_terminal_published: u64,
+    pub ssd_stage_terminal_cache_inserts: u64,
+    pub ssd_stage_terminal_cache_duration_us: u64,
+    pub ssd_stage_response_send_attempts: u64,
+    pub ssd_stage_response_send_successes: u64,
+    pub ssd_stage_response_send_failures: u64,
+    pub ssd_stage_response_send_duration_us: u64,
+    pub ssd_source_ready_wait_requests: u64,
+    pub ssd_source_ready_wait_successes: u64,
+    pub ssd_source_ready_wait_failures: u64,
+    pub ssd_source_ready_wait_duration_us: u64,
+    pub ssd_target_pull_requests: u64,
+    pub ssd_target_pull_successes: u64,
+    pub ssd_target_pull_failures: u64,
+    pub ssd_target_pull_duration_us: u64,
+    pub ssd_stage_done_detached: u64,
     pub external_get_holding_entries: u64,
     pub external_get_holding_bytes: u64,
     pub external_get_start_handles: u64,
@@ -117,6 +299,15 @@ pub struct OwnerRuntimeObserveSnapshot {
     pub remote_put_already_satisfied: u64,
     pub remote_put_obsolete: u64,
     pub remote_put_failed: u64,
+    pub local_ssd_put_flights_active: u64,
+    pub local_ssd_put_flight_leaders: u64,
+    pub local_ssd_put_flight_followers: u64,
+    pub local_ssd_put_source_unavailable: u64,
+    pub local_ssd_put_published: u64,
+    pub local_ssd_put_already_present: u64,
+    pub local_ssd_put_dropped: u64,
+    pub local_ssd_put_obsolete: u64,
+    pub local_ssd_put_failed: u64,
     pub local_reserve_slots_free: u64,
     pub local_reserve_slots_prepared: u64,
     pub local_reserve_slots_pending_visible: u64,
@@ -956,6 +1147,20 @@ async fn handle_external_put_revoke(
     }
 }
 
+async fn handle_ssd_stage_read(
+    view: &ClientKvApiView,
+    msg: &MsgPack<SsdStageReadReq>,
+) -> MsgPack<SsdStageReadResp> {
+    MsgPack {
+        serialize_part: view
+            .client_kv_api()
+            .inner()
+            .execute_ssd_stage(&msg.serialize_part)
+            .await,
+        raw_bytes: Vec::new(),
+    }
+}
+
 async fn handle_external_delete_ack(
     view: &ClientKvApiView,
     msg: &MsgPack<ExternalDeleteAckReq>,
@@ -1364,6 +1569,7 @@ pub struct ClientKvApiNewArg {
     pub test_spec_config: TestSpecConfig,
     /// Logical hot-tier capacity only. This does not resize the owner segment.
     pub owner_hot_cache_capacity_bytes: Option<u64>,
+    pub ssd_storage: Option<KvSsdStorageInit>,
 }
 
 pub struct ClientKvApi(ClientKvApiInner);
@@ -1465,6 +1671,19 @@ struct OwnerRemotePutCounters {
     failed: AtomicU64,
 }
 
+#[derive(Default)]
+struct OwnerLocalSsdPutCounters {
+    active: AtomicU64,
+    leaders: AtomicU64,
+    followers: AtomicU64,
+    source_unavailable: AtomicU64,
+    published: AtomicU64,
+    already_present: AtomicU64,
+    dropped: AtomicU64,
+    obsolete: AtomicU64,
+    failed: AtomicU64,
+}
+
 #[derive(Default)]
 struct OwnerPlannedGetCounters {
     local_probe_batches: AtomicU64,
@@ -1477,6 +1696,31 @@ struct OwnerPlannedGetCounters {
     follower_items: AtomicU64,
 }
 
+#[derive(Default)]
+struct OwnerSsdStageCounters {
+    ready_requests: AtomicU64,
+    ready_successes: AtomicU64,
+    ready_failures: AtomicU64,
+    ready_duration_us: AtomicU64,
+    execute_completions: AtomicU64,
+    terminal_published: AtomicU64,
+    terminal_cache_inserts: AtomicU64,
+    terminal_cache_duration_us: AtomicU64,
+    response_send_attempts: AtomicU64,
+    response_send_successes: AtomicU64,
+    response_send_failures: AtomicU64,
+    response_send_duration_us: AtomicU64,
+    source_ready_wait_requests: AtomicU64,
+    source_ready_wait_successes: AtomicU64,
+    source_ready_wait_failures: AtomicU64,
+    source_ready_wait_duration_us: AtomicU64,
+    target_pull_requests: AtomicU64,
+    target_pull_successes: AtomicU64,
+    target_pull_failures: AtomicU64,
+    target_pull_duration_us: AtomicU64,
+    done_detached: AtomicU64,
+}
+
 struct OwnerHotSelectionDebt {
     weight_bytes: u64,
     outstanding_bytes: Arc<AtomicU64>,
@@ -1730,8 +1974,26 @@ impl OwnerHotRetryQueue {
 
 pub(crate) struct OwnerPreparedReclaim {
     item: crate::master_kv_router::msg_pack::OwnerReclaimItem,
-    cached_info: GetCachedInfo,
-    local_snapshot: Option<LocalSnapshotInfo>,
+    source: OwnerPreparedReclaimSource,
+    ssd_prepare_lock: Arc<tokio::sync::AMutex<()>>,
+    ssd_prepare_complete: bool,
+    ssd_backing: Option<OwnerPreparedSsdBacking>,
+}
+
+pub(crate) enum OwnerPreparedReclaimSource {
+    /// An owner-indexed source detached from the local Moka while the reclaim fence is active.
+    Indexed {
+        cached_info: GetCachedInfo,
+        local_snapshot: Option<LocalSnapshotInfo>,
+    },
+    /// A master-owned allocation that has no owner-local key index. The master route owns the
+    /// physical allocation through Commit; the owner only reads it under the reclaim fence.
+    UnindexedAllocation { addr: u64, len: u64 },
+}
+
+pub(crate) struct OwnerPreparedSsdBacking {
+    len: u64,
+    _persist_guard: crate::kv_ssd_storage::KvSsdPersistGuard,
 }
 
 pub(crate) struct OwnerSourceEvictionSelection {
@@ -1769,6 +2031,51 @@ pub(crate) enum OwnerRemotePutOutcome {
     Failed,
 }
 
+/// Shared leader/follower terminal publication used by owner backing writes.
+/// Target-specific requests and executors stay outside this type.
+struct OwnerTargetPutFlight<T: Copy> {
+    terminal: watch::Sender<Option<T>>,
+    completed: AtomicBool,
+}
+
+impl<T: Copy> OwnerTargetPutFlight<T> {
+    fn new() -> Self {
+        let (terminal, _receiver) = watch::channel(None);
+        Self {
+            terminal,
+            completed: AtomicBool::new(false),
+        }
+    }
+
+    fn terminal(&self) -> Option<T> {
+        *self.terminal.borrow()
+    }
+
+    fn complete(&self, terminal: T) -> bool {
+        if self
+            .completed
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_err()
+        {
+            return false;
+        }
+        self.terminal.send_replace(Some(terminal));
+        true
+    }
+
+    async fn wait(&self) -> Option<T> {
+        let mut terminal = self.terminal.subscribe();
+        loop {
+            if let Some(terminal) = *terminal.borrow_and_update() {
+                return Some(terminal);
+            }
+            if terminal.changed().await.is_err() {
+                return None;
+            }
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct OwnerRemotePutRequest {
     pub preferred_sub_cluster: Option<String>,
@@ -1784,8 +2091,7 @@ pub(crate) struct OwnerRemotePutSharedOp {
     pub key: String,
     pub put_id: crate::master_kv_router::put::PutIDForAKey,
     request: Mutex<OwnerRemotePutRequest>,
-    outcome: watch::Sender<OwnerRemotePutOutcome>,
-    completed: AtomicBool,
+    flight: OwnerTargetPutFlight<OwnerRemotePutOutcome>,
 }
 
 impl OwnerRemotePutSharedOp {
@@ -1795,7 +2101,6 @@ impl OwnerRemotePutSharedOp {
         preferred_sub_cluster: Option<String>,
         protect_source_on_remote_complete: bool,
     ) -> Arc<Self> {
-        let (outcome, _receiver) = watch::channel(OwnerRemotePutOutcome::InFlight);
         Arc::new(Self {
             key: key.to_string(),
             put_id,
@@ -1803,8 +2108,7 @@ impl OwnerRemotePutSharedOp {
                 preferred_sub_cluster,
                 protect_source_on_remote_complete,
             }),
-            outcome,
-            completed: AtomicBool::new(false),
+            flight: OwnerTargetPutFlight::new(),
         })
     }
 
@@ -1825,33 +2129,21 @@ impl OwnerRemotePutSharedOp {
     }
 
     pub(crate) fn outcome(&self) -> OwnerRemotePutOutcome {
-        *self.outcome.borrow()
+        self.flight
+            .terminal()
+            .unwrap_or(OwnerRemotePutOutcome::InFlight)
     }
 
     fn complete(&self, outcome: OwnerRemotePutOutcome) -> bool {
         debug_assert_ne!(outcome, OwnerRemotePutOutcome::InFlight);
-        if self
-            .completed
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
-            .is_err()
-        {
-            return false;
-        }
-        self.outcome.send_replace(outcome);
-        true
+        self.flight.complete(outcome)
     }
 
     pub(crate) async fn wait(&self) -> OwnerRemotePutOutcome {
-        let mut outcome = self.outcome.subscribe();
-        loop {
-            let current = *outcome.borrow_and_update();
-            if current != OwnerRemotePutOutcome::InFlight {
-                return current;
-            }
-            if outcome.changed().await.is_err() {
-                return OwnerRemotePutOutcome::Failed;
-            }
-        }
+        self.flight
+            .wait()
+            .await
+            .unwrap_or(OwnerRemotePutOutcome::Failed)
     }
 }
 
@@ -1864,6 +2156,58 @@ pub(crate) enum OwnerRemotePutReservation {
     SourceUnavailable,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum OwnerLocalSsdPutOutcome {
+    Published,
+    AlreadyPresent,
+    Dropped,
+    Obsolete,
+    Failed,
+}
+
+/// One same-owner SSD write for an exact local generation. The common flight
+/// owns only terminal publication; admission, copy, durability, and route
+/// publication remain in the SSD executor.
+pub(crate) struct OwnerLocalSsdPutSharedOp {
+    pub key: String,
+    pub put_id: crate::master_kv_router::put::PutIDForAKey,
+    flight: OwnerTargetPutFlight<OwnerLocalSsdPutOutcome>,
+}
+
+impl OwnerLocalSsdPutSharedOp {
+    fn new(key: &str, put_id: crate::master_kv_router::put::PutIDForAKey) -> Arc<Self> {
+        Arc::new(Self {
+            key: key.to_string(),
+            put_id,
+            flight: OwnerTargetPutFlight::new(),
+        })
+    }
+
+    fn outcome(&self) -> Option<OwnerLocalSsdPutOutcome> {
+        self.flight.terminal()
+    }
+
+    fn complete(&self, outcome: OwnerLocalSsdPutOutcome) -> bool {
+        self.flight.complete(outcome)
+    }
+
+    pub(crate) async fn wait(&self) -> OwnerLocalSsdPutOutcome {
+        self.flight
+            .wait()
+            .await
+            .unwrap_or(OwnerLocalSsdPutOutcome::Failed)
+    }
+}
+
+pub(crate) enum OwnerLocalSsdPutReservation {
+    Leader {
+        op: Arc<OwnerLocalSsdPutSharedOp>,
+        memory_info: Arc<MemoryInfo>,
+    },
+    Follower(Arc<OwnerLocalSsdPutSharedOp>),
+    SourceUnavailable,
+}
+
 impl ExternalPutKeySharedOp {
     fn new() -> Arc<Self> {
         let (outcome, _receiver) = watch::channel(ExternalPutKeyOutcome::InFlight);
@@ -1916,6 +2260,9 @@ pub(crate) struct OwnerKeyControlState {
     /// `external_put`, this remains active after local publication until the
     /// remote Start/transfer/Done state machine reaches a terminal outcome.
     remote_put: Option<Arc<OwnerRemotePutSharedOp>>,
+    /// Exact-generation same-owner SSD write. This is independent from
+    /// `remote_put`, so both backing writes may run concurrently.
+    local_ssd_put: Option<Arc<OwnerLocalSsdPutSharedOp>>,
     /// Owner-local pre-Prepare fence installed by the Moka source-eviction
     /// dispatcher.  The matching committed index is moved into this record,
     /// so a new local Get cannot acquire the source between victim selection
@@ -1942,6 +2289,7 @@ impl OwnerKeyControlState {
             && self.external_pending_puts == 0
             && self.external_put.is_none()
             && self.remote_put.is_none()
+            && self.local_ssd_put.is_none()
             && self.source_eviction_selection.is_none()
             && self.reclaim.is_none()
             && self.external_get.is_none()
@@ -1986,6 +2334,15 @@ impl OwnerKeyControlState {
             );
         }
     }
+
+    fn install_local_ssd_put_leader(&mut self, op: Arc<OwnerLocalSsdPutSharedOp>) {
+        if let Some(displaced) = self.local_ssd_put.replace(op.clone()) {
+            assert_ne!(
+                displaced.put_id, op.put_id,
+                "a matching local SSD Put generation must join instead of being replaced"
+            );
+        }
+    }
 }
 
 const OWNER_KEY_CONTROL_SHARDS: usize = 256;
@@ -2421,6 +2778,7 @@ impl std::ops::Deref for ClientKvApiViewHolder {
 pub struct ClientKvApiInner {
     view: ClientKvApiViewHolder,
     test_spec_config: TestSpecConfig,
+    ssd_storage: Option<Arc<KvSsdStorage>>,
     metrics: OnceLock<Arc<MetricsHandle>>,
 
     /// make sure each remote kv get run in order
@@ -2460,7 +2818,9 @@ pub struct ClientKvApiInner {
         Arc<DashMap<OwnerHotReplicaIdentity, Arc<OwnerHotSelectionDebt>>>,
     owner_hot_counters: Arc<OwnerHotCacheCounters>,
     owner_remote_put_counters: Arc<OwnerRemotePutCounters>,
+    owner_local_ssd_put_counters: Arc<OwnerLocalSsdPutCounters>,
     planned_get_counters: OwnerPlannedGetCounters,
+    ssd_stage_counters: OwnerSsdStageCounters,
     owner_hot_retry_queue: Arc<OwnerHotRetryQueue>,
     owner_hot_eviction_tx: tokio::sync::ampsc::UnboundedSender<OwnerHotEvictionDispatch>,
     owner_hot_eviction_rx:
@@ -2486,6 +2846,12 @@ pub struct ClientKvApiInner {
     planned_external_get_execute_locks: AMapLock<(String, i64, u64)>,
     completed_planned_external_get_executes:
         moka::future::Cache<(String, i64, u64), ExternalExecutePlannedGetResp>,
+    /// Exact `get_id` SSD source operations. RPC retransmits and concurrent
+    /// callers join one disk read plus one payload transfer.
+    ssd_stage_flights: DashMap<u64, Arc<SsdStageSharedOp>>,
+    /// Short-lived terminal replay closes the active-map removal race and
+    /// prevents a lost response from re-reading or re-transferring the value.
+    completed_ssd_stages: moka::future::Cache<u64, CompletedSsdStage>,
     next_external_get_start_handle: AtomicU64,
     /// External holding identities are independent from upstream and resident holder ids.
     next_external_holding_id: AtomicU64,
@@ -2523,6 +2889,7 @@ pub struct ClientKvApiInner {
     rpc_caller_put_append_done: RPCCaller<PutAppendDoneReq>,
     rpc_caller_batch_put_append_done: RPCCaller<BatchPutAppendDoneReq>,
     rpc_caller_batch_evict_owner_source: RPCCaller<BatchEvictOwnerSourceReq>,
+    rpc_caller_batch_publish_owner_ssd: RPCCaller<BatchPublishOwnerSsdReq>,
     rpc_caller_reserve_local_grant: RPCCaller<ReserveLocalGrantReq>,
     rpc_caller_release_local_grant: RPCCaller<ReleaseLocalGrantReq>,
     rpc_caller_delete: RPCCaller<DeleteReq>,
@@ -2531,24 +2898,490 @@ pub struct ClientKvApiInner {
     rpc_caller_get_meta: RPCCaller<GetMetaReq>,
     rpc_caller_allocate_client_lease: RPCCaller<AllocateClientLeaseReq>,
     rpc_caller_client_lease_keepalive: RPCCaller<ClientLeaseKeepaliveReq>,
+    rpc_caller_ssd_stage_read: RPCCaller<SsdStageReadReq>,
+    rpc_caller_ssd_stage_begin: RPCCaller<SsdStageBeginReq>,
+    rpc_caller_ssd_stage_done: RPCCaller<SsdStageDoneReq>,
     rpc_caller_external_put_commit: RPCCaller<ExternalPutCommitReq>,
     rpc_caller_external_put_revoke: RPCCaller<ExternalPutRevokeReq>,
     rpc_caller_resolve_side_transfer_lane: RPCCaller<ResolveSideTransferLaneReq>,
 
-    /// Default lease id recorded for inspection/convenience, but NOT auto-applied.
-    /// Callers must explicitly pass `Some(lease_id)` to attach a put to a lease.
-    default_lease_id: parking_lot::RwLock<Option<u64>>,
-    /// External put (remote target) pending context keyed by (key, put_time_ms, put_version).
-    /// 注意：put_id (time_ms,version) 在不同 key 上并不全局唯一，因此必须携带 key 作为索引的一部分，避免碰撞。
-    /// 使用 moka::sync::SegmentedCache 并设置 30 分钟 TTL，避免异常路径未清理导致的泄漏；不设置容量上限，纯 TTL 控制。
-    external_pending_puts: moka::sync::SegmentedCache<(String, u64, u32), ExternalPendingPutCtx>,
-    owner_local_publish_tx: tokio::sync::ampsc::Sender<OwnerLocalPublishJob>,
-    owner_local_publish_rx: Mutex<Option<tokio::sync::ampsc::Receiver<OwnerLocalPublishJob>>>,
-}
+    /// Default lease id recorded for inspection/convenience, but NOT auto-applied.
+    /// Callers must explicitly pass `Some(lease_id)` to attach a put to a lease.
+    default_lease_id: parking_lot::RwLock<Option<u64>>,
+    /// External put (remote target) pending context keyed by (key, put_time_ms, put_version).
+    /// 注意：put_id (time_ms,version) 在不同 key 上并不全局唯一，因此必须携带 key 作为索引的一部分，避免碰撞。
+    /// 使用 moka::sync::SegmentedCache 并设置 30 分钟 TTL，避免异常路径未清理导致的泄漏；不设置容量上限，纯 TTL 控制。
+    external_pending_puts: moka::sync::SegmentedCache<(String, u64, u32), ExternalPendingPutCtx>,
+    owner_local_publish_tx: tokio::sync::ampsc::Sender<OwnerLocalPublishJob>,
+    owner_local_publish_rx: Mutex<Option<tokio::sync::ampsc::Receiver<OwnerLocalPublishJob>>>,
+}
+
+impl ClientKvApiInner {
+    fn view(&self) -> &ClientKvApiView {
+        &self.view
+    }
+
+    pub(crate) async fn persist_local_kvs_to_ssd(
+        &self,
+        sources: &[KvSsdPersistSource],
+    ) -> KvResult<Vec<KvResult<Option<crate::kv_ssd_storage::KvSsdPersistGuard>>>> {
+        let Some(store) = self.ssd_storage.as_ref() else {
+            return Ok(sources.iter().map(|_| Ok(None)).collect());
+        };
+        let segment_guard = self.view.client_seg_pool().cpu_mem_read_guard().await?;
+        for source in sources {
+            if !segment_guard.contains_rw_or_ro(source.addr, source.len) {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "SSD persist source is outside the local segment: key={} put_id=({},{}) addr={:#x} len={}",
+                        source.key, source.put_id.0, source.put_id.1, source.addr, source.len
+                    ),
+                }));
+            }
+        }
+        let results = store.persist_batch_from_addrs(sources).await;
+        drop(segment_guard);
+        Ok(results)
+    }
+
+    pub(crate) async fn copy_local_kvs_for_ssd(
+        &self,
+        sources: &[KvSsdPersistSource],
+    ) -> KvResult<Vec<KvResult<KvSsdPersistCopy>>> {
+        if self.ssd_storage.is_none() {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "local SSD storage is disabled".to_string(),
+            }));
+        }
+        let segment_guard = self.view.client_seg_pool().cpu_mem_read_guard().await?;
+        for source in sources {
+            if !segment_guard.contains_rw_or_ro(source.addr, source.len) {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "SSD persist source is outside the local segment: key={} put_id=({},{}) addr={:#x} len={}",
+                        source.key, source.put_id.0, source.put_id.1, source.addr, source.len
+                    ),
+                }));
+            }
+        }
+        let copies = KvSsdStorage::copy_batch_from_addrs(sources);
+        drop(segment_guard);
+        Ok(copies)
+    }
+
+    pub(crate) async fn persist_copied_local_kvs_to_ssd(
+        &self,
+        permit: KvSsdPersistBatchPermit,
+        copies: Vec<KvResult<KvSsdPersistCopy>>,
+    ) -> KvResult<Vec<KvResult<Option<crate::kv_ssd_storage::KvSsdPersistGuard>>>> {
+        let Some(store) = self.ssd_storage.as_ref() else {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "local SSD storage is disabled".to_string(),
+            }));
+        };
+        Ok(store
+            .persist_batch_from_copies_with_permit(permit, copies)
+            .await)
+    }
+
+    pub(crate) fn try_acquire_local_ssd_persist_batch(
+        &self,
+        item_count: usize,
+    ) -> KvResult<Option<KvSsdPersistBatchPermit>> {
+        let Some(store) = self.ssd_storage.as_ref() else {
+            return Ok(None);
+        };
+        store.try_acquire_persist_batch(item_count)
+    }
+
+    async fn discard_local_ssd_replica(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+    ) -> bool {
+        let Some(store) = self.ssd_storage.as_ref() else {
+            return false;
+        };
+        store.remove_exact(key, put_id).await
+    }
+
+    async fn begin_ssd_stage(&self, get_id: u64) -> KvResult<bool> {
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let response = self
+            .rpc_caller_ssd_stage_begin
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: SsdStageBeginReq { get_id },
+                    raw_bytes: Vec::new(),
+                },
+                Some(SSD_STAGE_RPC_TIMEOUT),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            response.serialize_part.error_code,
+            response.serialize_part.error_json,
+        )?;
+        Ok(response.serialize_part.started)
+    }
+
+    async fn finish_ssd_stage_once(&self, get_id: u64, drop_ssd_source: bool) -> KvResult<()> {
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let response = self
+            .rpc_caller_ssd_stage_done
+            .call(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                MsgPack {
+                    serialize_part: SsdStageDoneReq {
+                        get_id,
+                        drop_ssd_source,
+                    },
+                    raw_bytes: Vec::new(),
+                },
+                Some(SSD_STAGE_RPC_TIMEOUT),
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            response.serialize_part.error_code,
+            response.serialize_part.error_json,
+        )
+    }
+
+    async fn finish_ssd_stage_until_acked(&self, get_id: u64, drop_ssd_source: bool) {
+        let mut attempt = 0_u64;
+        let mut backoff = SSD_STAGE_DONE_RETRY_INITIAL_BACKOFF;
+        loop {
+            attempt = attempt.saturating_add(1);
+            match self.finish_ssd_stage_once(get_id, drop_ssd_source).await {
+                Ok(()) => return,
+                Err(err) => {
+                    if attempt == 1 || attempt.is_power_of_two() {
+                        tracing::warn!(
+                            get_id,
+                            drop_ssd_source,
+                            attempt,
+                            retry_delay_ms = backoff.as_millis(),
+                            error = %err,
+                            "SSD StageDone failed; retaining the source flight and retrying"
+                        );
+                    }
+                }
+            }
+            tokio::time::sleep(backoff).await;
+            backoff = backoff
+                .saturating_mul(2)
+                .min(SSD_STAGE_DONE_RETRY_MAX_BACKOFF);
+        }
+    }
+
+    fn finish_ssd_stage_detached(&self, get_id: u64) {
+        self.ssd_stage_counters
+            .done_detached
+            .fetch_add(1, Ordering::Relaxed);
+        let spawn_view = self.view.clone_view();
+        let task_view = spawn_view.clone();
+        spawn_view.spawn("ssd_stage_done_retry", async move {
+            task_view
+                .client_kv_api()
+                .inner()
+                .finish_ssd_stage_until_acked(get_id, false)
+                .await;
+        });
+    }
+
+    async fn run_ssd_stage_once(&self, req: &SsdStageReadReq) -> SsdStageReadResp {
+        self.ssd_stage_counters
+            .ready_requests
+            .fetch_add(1, Ordering::Relaxed);
+        let ready_started_at = Instant::now();
+        match self.begin_ssd_stage(req.get_id).await {
+            Ok(true) => {}
+            Ok(false) => {
+                let response = ssd_stage_error_response(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!("SSD stage is not startable: get_id={}", req.get_id),
+                }));
+                self.ssd_stage_counters
+                    .ready_failures
+                    .fetch_add(1, Ordering::Relaxed);
+                self.ssd_stage_counters.ready_duration_us.fetch_add(
+                    u64::try_from(ready_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+                    Ordering::Relaxed,
+                );
+                return response;
+            }
+            Err(err) => {
+                let response = ssd_stage_error_response(err);
+                self.ssd_stage_counters
+                    .ready_failures
+                    .fetch_add(1, Ordering::Relaxed);
+                self.ssd_stage_counters.ready_duration_us.fetch_add(
+                    u64::try_from(ready_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+                    Ordering::Relaxed,
+                );
+                return response;
+            }
+        }
+
+        let load_result = async {
+            let Some(store) = self.ssd_storage.as_ref() else {
+                return Err(KvError::Api(ApiError::KeyNotFound {
+                    key: req.key.clone(),
+                }));
+            };
+            let segment_guard = self.view.client_seg_pool().cpu_mem_read_guard().await?;
+            if !segment_guard.contains_rw(req.stage_addr, req.stage_capacity) {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "SSD stage is outside the local writable segment: get_id={} addr={:#x} capacity={}",
+                        req.get_id, req.stage_addr, req.stage_capacity
+                    ),
+                }));
+            }
+            store
+                .load_into_addr(
+                    &req.key,
+                    req.put_id,
+                    req.stage_addr,
+                    req.len,
+                    req.stage_capacity,
+                )
+                .await?;
+            drop(segment_guard);
+            Ok(())
+        }
+        .await;
+
+        let response = match load_result {
+            Ok(()) => SsdStageReadResp {
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+            },
+            Err(load_err) => {
+                let stale_ssd_source =
+                    matches!(&load_err, KvError::Api(ApiError::KeyNotFound { .. }));
+                // A failed load never becomes pull-ready. The source owner is
+                // therefore the only side that can safely close the stage. A
+                // true miss also removes the exact stale SSD route.
+                self.finish_ssd_stage_until_acked(req.get_id, stale_ssd_source)
+                    .await;
+                ssd_stage_error_response(load_err)
+            }
+        };
+        self.ssd_stage_counters.ready_duration_us.fetch_add(
+            u64::try_from(ready_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+            Ordering::Relaxed,
+        );
+        if response.error_code == crate::rpcresp_kvresult_convert::msg_and_error::OK {
+            self.ssd_stage_counters
+                .ready_successes
+                .fetch_add(1, Ordering::Relaxed);
+        } else {
+            self.ssd_stage_counters
+                .ready_failures
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        response
+    }
+
+    async fn execute_ssd_stage(&self, req: &SsdStageReadReq) -> SsdStageReadResp {
+        if let Some(completed) = self.completed_ssd_stages.get(&req.get_id).await {
+            return if completed.request == *req {
+                completed.response
+            } else {
+                ssd_stage_request_mismatch_response(&completed.request, req)
+            };
+        }
+
+        let (op, is_leader) = match self.ssd_stage_flights.entry(req.get_id) {
+            DashMapEntry::Occupied(entry) => (entry.get().clone(), false),
+            DashMapEntry::Vacant(entry) => {
+                let op = SsdStageSharedOp::new(req.clone());
+                entry.insert(op.clone());
+                (op, true)
+            }
+        };
+        if op.request != *req {
+            return ssd_stage_request_mismatch_response(&op.request, req);
+        }
+
+        if is_leader {
+            let spawn_view = self.view.clone_view();
+            let task_view = spawn_view.clone();
+            let task_op = op.clone();
+            spawn_view.spawn("ssd_stage_singleflight", async move {
+                let inner = task_view.client_kv_api().inner();
+                let response = inner.run_ssd_stage_once(&task_op.request).await;
+                inner
+                    .ssd_stage_counters
+                    .execute_completions
+                    .fetch_add(1, Ordering::Relaxed);
+                assert!(
+                    task_op.complete(response.clone()),
+                    "one SSD stage flight must publish exactly one terminal result"
+                );
+                inner
+                    .ssd_stage_counters
+                    .terminal_published
+                    .fetch_add(1, Ordering::Relaxed);
+
+                // Wake the foreground RPC before maintaining the replay cache.
+                // The completed flight remains indexed until the cache insert
+                // finishes, so retransmits cannot start a second disk read.
+                let cache_started_at = Instant::now();
+                inner
+                    .completed_ssd_stages
+                    .insert(
+                        task_op.request.get_id,
+                        CompletedSsdStage {
+                            request: task_op.request.clone(),
+                            response: response.clone(),
+                        },
+                    )
+                    .await;
+                inner
+                    .ssd_stage_counters
+                    .terminal_cache_duration_us
+                    .fetch_add(
+                        u64::try_from(cache_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+                        Ordering::Relaxed,
+                    );
+                inner
+                    .ssd_stage_counters
+                    .terminal_cache_inserts
+                    .fetch_add(1, Ordering::Relaxed);
+                inner
+                    .ssd_stage_flights
+                    .remove_if(&task_op.request.get_id, |_, current| {
+                        Arc::ptr_eq(current, &task_op)
+                    });
+            });
+        }
+        op.wait().await
+    }
+
+    pub(crate) async fn stage_kv_from_ssd_source(
+        &self,
+        source_node_id: &NodeIDString,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        get_id: u64,
+        stage_addr: u64,
+        stage_capacity: u64,
+        target_addr: u64,
+        len: u64,
+    ) -> KvResult<()> {
+        let req = SsdStageReadReq {
+            key: key.to_string(),
+            put_id,
+            get_id,
+            stage_addr,
+            stage_capacity,
+            len,
+        };
+        let self_node_id = self.view.cluster_manager().get_self_info().id.clone();
+        self.ssd_stage_counters
+            .source_ready_wait_requests
+            .fetch_add(1, Ordering::Relaxed);
+        let ready_wait_started_at = Instant::now();
+        let response_result: KvResult<SsdStageReadResp> = if source_node_id == &self_node_id {
+            Ok(self.execute_ssd_stage(&req).await)
+        } else {
+            self.rpc_caller_ssd_stage_read
+                .call_with_transport_policy(
+                    self.view.p2p_module(),
+                    source_node_id.clone().into(),
+                    MsgPack {
+                        serialize_part: req,
+                        raw_bytes: Vec::new(),
+                    },
+                    Some(SSD_STAGE_RPC_TIMEOUT),
+                    RpcTransportPolicy::ForceTransport,
+                    1,
+                )
+                .await
+                .map(|response| response.serialize_part)
+                .map_err(KvError::from)
+        };
+        self.ssd_stage_counters
+            .source_ready_wait_duration_us
+            .fetch_add(
+                u64::try_from(ready_wait_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+                Ordering::Relaxed,
+            );
+        let ready_result = response_result.and_then(|response| {
+            crate::rpcresp_kvresult_convert::try_from_code(response.error_code, response.error_json)
+        });
+        if ready_result.is_ok() {
+            self.ssd_stage_counters
+                .source_ready_wait_successes
+                .fetch_add(1, Ordering::Relaxed);
+        } else {
+            self.ssd_stage_counters
+                .source_ready_wait_failures
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        ready_result?;
+
+        self.ssd_stage_counters
+            .target_pull_requests
+            .fetch_add(1, Ordering::Relaxed);
+        let pull_started_at = Instant::now();
+        let peer_id = (source_node_id != &self_node_id).then(|| source_node_id.clone());
+        let transfer_result = self
+            .view
+            .client_transfer_engine()
+            .transfer_data_no_copy(peer_id, true, stage_addr, target_addr, len, None)
+            .await
+            .map(|_| ())
+            .map_err(|err| {
+                KvError::Api(ApiError::Transfer {
+                    from_addr: stage_addr,
+                    to_addr: target_addr,
+                    len,
+                    error: err.to_string(),
+                })
+            });
+        self.ssd_stage_counters.target_pull_duration_us.fetch_add(
+            u64::try_from(pull_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+            Ordering::Relaxed,
+        );
+        if transfer_result.is_ok() {
+            self.ssd_stage_counters
+                .target_pull_successes
+                .fetch_add(1, Ordering::Relaxed);
+        } else {
+            self.ssd_stage_counters
+                .target_pull_failures
+                .fetch_add(1, Ordering::Relaxed);
+        }
 
-impl ClientKvApiInner {
-    fn view(&self) -> &ClientKvApiView {
-        &self.view
+        // Payload completion is the ownership hand-off point: the target no
+        // longer reads the source stage, so master may release it. Do not put
+        // this control-plane ACK on the foreground Get latency path.
+        self.finish_ssd_stage_detached(get_id);
+        transfer_result
+    }
+
+    pub(crate) fn kv_ssd_storage_usage_snapshot(
+        &self,
+    ) -> Option<crate::kv_ssd_storage::KvSsdStorageDeviceUsage> {
+        self.ssd_storage
+            .as_ref()
+            .map(|store| store.usage_snapshot())
     }
 
     pub(crate) fn track_external_get_flight(&self, op: &Arc<ExternalGetKeySharedOp>) {
@@ -2690,6 +3523,7 @@ impl ClientKvApiInner {
             state.local_puts != 0
                 || state.external_pending_puts != 0
                 || state.remote_put.is_some()
+                || state.local_ssd_put.is_some()
                 || state.external_get.is_some()
                 || state.local_access_fenced()
         });
@@ -3207,6 +4041,140 @@ impl ClientKvApiInner {
         true
     }
 
+    pub(crate) fn begin_owner_local_ssd_put(
+        &self,
+        key: &str,
+        put_id: crate::master_kv_router::put::PutIDForAKey,
+        selected_victim: Option<&crate::master_kv_router::msg_pack::OwnerSourceEvictionVictim>,
+    ) -> OwnerLocalSsdPutReservation {
+        if self.ssd_storage.is_none() {
+            return OwnerLocalSsdPutReservation::SourceUnavailable;
+        }
+        let mut controls = self.owner_key_control.lock_key(key);
+
+        if let Some(existing) = controls
+            .get(key)
+            .and_then(|state| state.local_ssd_put.clone())
+        {
+            if existing.put_id == put_id && existing.outcome().is_none() {
+                self.owner_local_ssd_put_counters
+                    .followers
+                    .fetch_add(1, Ordering::Relaxed);
+                return OwnerLocalSsdPutReservation::Follower(existing);
+            }
+            if existing.outcome().is_some() {
+                let state = controls
+                    .get_mut(key)
+                    .expect("terminal local SSD Put control state disappeared");
+                if state
+                    .local_ssd_put
+                    .as_ref()
+                    .is_some_and(|current| Arc::ptr_eq(current, &existing))
+                {
+                    state.local_ssd_put = None;
+                }
+            }
+        }
+
+        let memory_info = if let Some(victim) = selected_victim {
+            let selected = controls
+                .get(key)
+                .and_then(|state| state.source_eviction_selection.as_ref())
+                .filter(|selection| selection.put_id == put_id)
+                .map(|selection| selection.cached_info.mem_holder.clone());
+            selected.filter(|source| {
+                source.local_reserve_resident_slot_ref().is_some_and(
+                    |(slot_size, grant_id, slot_index)| {
+                        matches!(
+                            &victim.backing,
+                            crate::master_kv_router::msg_pack::OwnerReclaimBacking::CommittedSlot {
+                                grant_id: expected_grant_id,
+                                slot_index: expected_slot_index,
+                                slot_size: expected_slot_size,
+                            } if *expected_grant_id == grant_id
+                                && *expected_slot_index == slot_index
+                                && *expected_slot_size == slot_size
+                        )
+                    },
+                )
+            })
+        } else {
+            if controls
+                .get(key)
+                .is_some_and(|state| state.local_access_fenced())
+            {
+                None
+            } else {
+                self.get_cached_info.get(key).and_then(|info| {
+                    ((info.put_time_ms, info.put_version) == put_id)
+                        .then(|| info.mem_holder.clone())
+                })
+            }
+        };
+        let Some(memory_info) = memory_info else {
+            self.owner_local_ssd_put_counters
+                .source_unavailable
+                .fetch_add(1, Ordering::Relaxed);
+            return OwnerLocalSsdPutReservation::SourceUnavailable;
+        };
+
+        let op = OwnerLocalSsdPutSharedOp::new(key, put_id);
+        controls
+            .entry(key.to_string())
+            .or_default()
+            .install_local_ssd_put_leader(op.clone());
+        self.owner_local_ssd_put_counters
+            .active
+            .fetch_add(1, Ordering::Relaxed);
+        self.owner_local_ssd_put_counters
+            .leaders
+            .fetch_add(1, Ordering::Relaxed);
+        OwnerLocalSsdPutReservation::Leader { op, memory_info }
+    }
+
+    pub(crate) fn finish_owner_local_ssd_put(
+        &self,
+        op: &Arc<OwnerLocalSsdPutSharedOp>,
+        outcome: OwnerLocalSsdPutOutcome,
+    ) -> bool {
+        if !op.complete(outcome) {
+            return false;
+        }
+
+        let mut controls = self.owner_key_control.lock_key(&op.key);
+        let remove_control = if let Some(state) = controls.get_mut(&op.key) {
+            if state
+                .local_ssd_put
+                .as_ref()
+                .is_some_and(|current| Arc::ptr_eq(current, op))
+            {
+                state.local_ssd_put = None;
+            }
+            state.is_idle()
+        } else {
+            false
+        };
+        if remove_control {
+            controls.remove(&op.key);
+        }
+        drop(controls);
+
+        self.owner_local_ssd_put_counters
+            .active
+            .fetch_sub(1, Ordering::Relaxed);
+        let terminal_counter = match outcome {
+            OwnerLocalSsdPutOutcome::Published => &self.owner_local_ssd_put_counters.published,
+            OwnerLocalSsdPutOutcome::AlreadyPresent => {
+                &self.owner_local_ssd_put_counters.already_present
+            }
+            OwnerLocalSsdPutOutcome::Dropped => &self.owner_local_ssd_put_counters.dropped,
+            OwnerLocalSsdPutOutcome::Obsolete => &self.owner_local_ssd_put_counters.obsolete,
+            OwnerLocalSsdPutOutcome::Failed => &self.owner_local_ssd_put_counters.failed,
+        };
+        terminal_counter.fetch_add(1, Ordering::Relaxed);
+        true
+    }
+
     pub(crate) fn record_owner_remote_put_transfer(&self) {
         self.owner_remote_put_counters
             .transfers
@@ -3691,7 +4659,11 @@ pub struct ExternalPendingPutCtx {
     pub target_base_addr: u64,
     pub target_offset: u64,
     pub len: u64,
+    /// Original content-selection signal from the caller/adapter.
     pub make_replica_task: bool,
+    /// A remote memory target was pre-reserved, or this local-first path may
+    /// perform normal append-time remote admission.
+    pub remote_replica_admitted: bool,
     pub preferred_sub_cluster: Option<String>,
     pub local_reserve_slot: Option<OwnerLocalReserveSlotRef>,
     pub local_reserve_slot_size: Option<u64>,
@@ -4325,18 +5297,22 @@ mod owner_reclaim_slot_tests {
         OwnerHotRetryQueue, OwnerHotSelectionDebt, OwnerHotSelectionFenceOutcome,
         OwnerKeyControlState, OwnerKeyControlTable, OwnerLocalReserveGrantState,
         OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef, OwnerLocalReserveSlotState,
-        OwnerReclaimRecord, OwnerRemotePutOutcome, OwnerRemotePutReservation,
-        OwnerRemotePutSharedOp, acquire_external_pending_put_fence_for_key,
-        allocate_external_holding_id, build_owner_hot_cache, clone_if_owner_hot_entry_matches,
+        OwnerLocalSsdPutOutcome, OwnerLocalSsdPutSharedOp, OwnerReclaimRecord,
+        OwnerRemotePutOutcome, OwnerRemotePutReservation, OwnerRemotePutSharedOp,
+        acquire_external_pending_put_fence_for_key, allocate_external_holding_id,
+        build_owner_hot_cache, clone_if_owner_hot_entry_matches,
         owner_hot_source_has_active_holders, pin_current_owner_hot_source_from_index,
     };
     use crate::config::TestSpecConfig;
+    use crate::kv_ssd_storage::{KvSsdStorageInit, KvSsdStorageRootLimit, MIN_CAPACITY_BYTES};
     use crate::master_kv_router::msg_pack::{
         BatchOwnerReclaimReq, OwnerReclaimBacking, OwnerReclaimItem, OwnerReclaimItemState,
-        OwnerReclaimPhase, OwnerReclaimReason, OwnerSourceEvictionVictim,
+        OwnerReclaimPhase, OwnerReclaimReason, OwnerSourceEvictionVictim, OwnerSourceSsdPolicy,
     };
     use crate::p2p::msg_pack::MsgPack;
     use parking_lot::Mutex;
+    use std::fs;
+    use std::path::PathBuf;
     use std::sync::atomic::{AtomicU64, Ordering};
     use std::sync::{Arc, Weak};
     use std::time::{Duration, Instant};
@@ -4392,6 +5368,7 @@ mod owner_reclaim_slot_tests {
                 external_pending_puts: 1,
                 external_put: None,
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4424,6 +5401,7 @@ mod owner_reclaim_slot_tests {
                 external_pending_puts: 1,
                 external_put: Some(op.clone()),
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4463,6 +5441,7 @@ mod owner_reclaim_slot_tests {
                 external_pending_puts: 1,
                 external_put: Some(op.clone()),
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4497,6 +5476,7 @@ mod owner_reclaim_slot_tests {
         let api = ClientKvApi::construct(ClientKvApiNewArg {
             test_spec_config: TestSpecConfig::default(),
             owner_hot_cache_capacity_bytes: None,
+            ssd_storage: None,
         })
         .await
         .expect("construct test ClientKvApi");
@@ -4588,6 +5568,7 @@ mod owner_reclaim_slot_tests {
         let api = ClientKvApi::construct(ClientKvApiNewArg {
             test_spec_config: TestSpecConfig::default(),
             owner_hot_cache_capacity_bytes: None,
+            ssd_storage: None,
         })
         .await
         .expect("construct test ClientKvApi");
@@ -4666,6 +5647,136 @@ mod owner_reclaim_slot_tests {
         );
     }
 
+    #[limit_thirdparty::tokio::test]
+    async fn remote_and_local_ssd_flights_publish_independent_terminals() {
+        let key = "parallel-backing-flights";
+        let put_id = (82, 4);
+        let api = ClientKvApi::construct(ClientKvApiNewArg {
+            test_spec_config: TestSpecConfig::default(),
+            owner_hot_cache_capacity_bytes: None,
+            ssd_storage: None,
+        })
+        .await
+        .expect("construct test ClientKvApi");
+        let remote = OwnerRemotePutSharedOp::new(key, put_id, None, false);
+        let local_ssd = OwnerLocalSsdPutSharedOp::new(key, put_id);
+        api.inner().owner_key_control.lock_key(key).insert(
+            key.to_string(),
+            OwnerKeyControlState {
+                remote_put: Some(remote.clone()),
+                local_ssd_put: Some(local_ssd.clone()),
+                ..Default::default()
+            },
+        );
+        api.inner()
+            .owner_remote_put_counters
+            .active
+            .store(1, Ordering::Relaxed);
+        api.inner()
+            .owner_local_ssd_put_counters
+            .active
+            .store(1, Ordering::Relaxed);
+
+        assert!(
+            api.inner()
+                .finish_owner_remote_put(&remote, OwnerRemotePutOutcome::Published)
+        );
+        {
+            let controls = api.inner().owner_key_control.lock_key(key);
+            let state = controls.get(key).expect("SSD flight must remain installed");
+            assert!(state.remote_put.is_none());
+            assert!(
+                state
+                    .local_ssd_put
+                    .as_ref()
+                    .is_some_and(|current| Arc::ptr_eq(current, &local_ssd))
+            );
+        }
+        assert_eq!(
+            local_ssd.outcome(),
+            None,
+            "remote completion must not publish the SSD terminal"
+        );
+        assert!(
+            api.inner()
+                .finish_owner_local_ssd_put(&local_ssd, OwnerLocalSsdPutOutcome::Published)
+        );
+        assert_eq!(local_ssd.wait().await, OwnerLocalSsdPutOutcome::Published);
+        assert!(
+            api.inner()
+                .owner_key_control
+                .lock_key(key)
+                .get(key)
+                .is_none()
+        );
+    }
+
+    #[limit_thirdparty::tokio::test]
+    async fn early_ssd_byte_rejection_does_not_install_generation_flight() {
+        let target = std::env::var_os("CARGO_TARGET_DIR")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| PathBuf::from("/mnt/nvme0/mjq_build/push_sglang_fluxon_target"));
+        let root = target.join("kv_ssd_tests").join(format!(
+            "early-pre-admission-{}-{}",
+            std::process::id(),
+            uuid::Uuid::new_v4()
+        ));
+        let api = ClientKvApi::construct(ClientKvApiNewArg {
+            test_spec_config: TestSpecConfig::default(),
+            owner_hot_cache_capacity_bytes: None,
+            ssd_storage: Some(KvSsdStorageInit {
+                roots: vec![KvSsdStorageRootLimit {
+                    root_dir: root.clone(),
+                    limit_bytes: MIN_CAPACITY_BYTES,
+                }],
+                write_rate_limit_bytes_per_sec: Some(1),
+                write_burst_bytes: Some(4),
+            }),
+        })
+        .await
+        .expect("construct SSD-enabled test ClientKvApi");
+        let key = "early-pre-admission-drop";
+
+        api.inner()
+            .start_early_owner_local_ssd_puts(vec![(key.to_string(), (83, 1), 8)]);
+
+        let usage = api
+            .inner()
+            .ssd_storage
+            .as_ref()
+            .expect("SSD store")
+            .usage_snapshot();
+        assert_eq!(usage.write_candidate_items, 1);
+        assert_eq!(usage.write_admitted_items, 0);
+        assert_eq!(usage.write_dropped_items, 1);
+        assert_eq!(
+            api.inner()
+                .owner_local_ssd_put_counters
+                .leaders
+                .load(Ordering::Relaxed),
+            0,
+            "a byte-rejected early candidate must never enter singleflight"
+        );
+        assert!(
+            api.inner()
+                .owner_key_control
+                .lock_key(key)
+                .get(key)
+                .is_none(),
+            "a byte-rejected early candidate must not create per-key state"
+        );
+
+        api.inner()
+            .ssd_storage
+            .as_ref()
+            .expect("SSD store")
+            .close()
+            .await
+            .expect("close SSD store");
+        drop(api);
+        fs::remove_dir_all(root).expect("remove SSD test root");
+    }
+
     #[test]
     fn failed_local_slot_release_keeps_key_fence_closed() {
         let controls = controls_with_state(
@@ -4675,6 +5786,7 @@ mod owner_reclaim_slot_tests {
                 external_pending_puts: 1,
                 external_put: None,
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4707,6 +5819,7 @@ mod owner_reclaim_slot_tests {
                 external_pending_puts: 1,
                 external_put: None,
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: None,
                 external_get: None,
@@ -4760,6 +5873,7 @@ mod owner_reclaim_slot_tests {
                 target_offset: 0,
                 len: 1,
                 make_replica_task: false,
+                remote_replica_admitted: false,
                 preferred_sub_cluster: None,
                 local_reserve_slot: None,
                 local_reserve_slot_size: None,
@@ -5125,6 +6239,8 @@ mod owner_reclaim_slot_tests {
                 key: key.to_string(),
                 put_id: (identity.put_time_ms, identity.put_version),
                 backing: OwnerReclaimBacking::Allocation,
+                ssd_backing_len: None,
+                ssd_policy: OwnerSourceSsdPolicy::Drop,
             },
             101,
         )
@@ -5370,6 +6486,7 @@ mod owner_reclaim_slot_tests {
                 external_pending_puts: 0,
                 external_put: None,
                 remote_put: None,
+                local_ssd_put: None,
                 source_eviction_selection: None,
                 reclaim: Some(OwnerReclaimRecord::Committed(OwnerReclaimItem {
                     key: "fenced".to_string(),
@@ -5687,6 +6804,7 @@ impl ClientKvApiInner {
     }
 
     pub fn runtime_observe_snapshot(&self) -> OwnerRuntimeObserveSnapshot {
+        let ssd = self.kv_ssd_storage_usage_snapshot().unwrap_or_default();
         let mut external_get_holding_bytes = 0u64;
         for entry in self.external_get_holding.inner().iter() {
             external_get_holding_bytes =
@@ -5766,6 +6884,123 @@ impl ClientKvApiInner {
             (free, prepared, pending_visible, committed)
         };
         OwnerRuntimeObserveSnapshot {
+            ssd_capacity_bytes: ssd.capacity_bytes,
+            ssd_used_bytes: ssd.used_bytes,
+            ssd_persist_requests: ssd.persist_requests,
+            ssd_persist_successes: ssd.persist_successes,
+            ssd_persist_failures: ssd.persist_failures,
+            ssd_persist_bytes: ssd.persist_bytes,
+            ssd_persist_duration_us: ssd.persist_duration_us,
+            ssd_persist_batch_requests: ssd.persist_batch_requests,
+            ssd_persist_batch_items: ssd.persist_batch_items,
+            ssd_persist_flush_batches: ssd.persist_flush_batches,
+            ssd_persist_busy_batches: ssd.persist_busy_batches,
+            ssd_persist_admission_skips: ssd.persist_admission_skips,
+            ssd_persist_batch_duration_us: ssd.persist_batch_duration_us,
+            ssd_write_candidate_items: ssd.write_candidate_items,
+            ssd_write_candidate_bytes: ssd.write_candidate_bytes,
+            ssd_write_admitted_items: ssd.write_admitted_items,
+            ssd_write_admitted_bytes: ssd.write_admitted_bytes,
+            ssd_write_dropped_items: ssd.write_dropped_items,
+            ssd_write_dropped_bytes: ssd.write_dropped_bytes,
+            ssd_write_refunded_items: ssd.write_refunded_items,
+            ssd_write_refunded_bytes: ssd.write_refunded_bytes,
+            ssd_load_requests: ssd.load_requests,
+            ssd_load_successes: ssd.load_successes,
+            ssd_load_misses: ssd.load_misses,
+            ssd_load_failures: ssd.load_failures,
+            ssd_load_bytes: ssd.load_bytes,
+            ssd_load_duration_us: ssd.load_duration_us,
+            ssd_memory_hits: ssd.memory_hits,
+            ssd_disk_hits: ssd.disk_hits,
+            ssd_outer_hits: ssd.outer_hits,
+            ssd_removals: ssd.removals,
+            ssd_stage_flights: self.ssd_stage_flights.len() as u64,
+            ssd_stage_terminals: self.completed_ssd_stages.entry_count(),
+            ssd_stage_ready_requests: self
+                .ssd_stage_counters
+                .ready_requests
+                .load(Ordering::Relaxed),
+            ssd_stage_ready_successes: self
+                .ssd_stage_counters
+                .ready_successes
+                .load(Ordering::Relaxed),
+            ssd_stage_ready_failures: self
+                .ssd_stage_counters
+                .ready_failures
+                .load(Ordering::Relaxed),
+            ssd_stage_ready_duration_us: self
+                .ssd_stage_counters
+                .ready_duration_us
+                .load(Ordering::Relaxed),
+            ssd_stage_execute_completions: self
+                .ssd_stage_counters
+                .execute_completions
+                .load(Ordering::Relaxed),
+            ssd_stage_terminal_published: self
+                .ssd_stage_counters
+                .terminal_published
+                .load(Ordering::Relaxed),
+            ssd_stage_terminal_cache_inserts: self
+                .ssd_stage_counters
+                .terminal_cache_inserts
+                .load(Ordering::Relaxed),
+            ssd_stage_terminal_cache_duration_us: self
+                .ssd_stage_counters
+                .terminal_cache_duration_us
+                .load(Ordering::Relaxed),
+            ssd_stage_response_send_attempts: self
+                .ssd_stage_counters
+                .response_send_attempts
+                .load(Ordering::Relaxed),
+            ssd_stage_response_send_successes: self
+                .ssd_stage_counters
+                .response_send_successes
+                .load(Ordering::Relaxed),
+            ssd_stage_response_send_failures: self
+                .ssd_stage_counters
+                .response_send_failures
+                .load(Ordering::Relaxed),
+            ssd_stage_response_send_duration_us: self
+                .ssd_stage_counters
+                .response_send_duration_us
+                .load(Ordering::Relaxed),
+            ssd_source_ready_wait_requests: self
+                .ssd_stage_counters
+                .source_ready_wait_requests
+                .load(Ordering::Relaxed),
+            ssd_source_ready_wait_successes: self
+                .ssd_stage_counters
+                .source_ready_wait_successes
+                .load(Ordering::Relaxed),
+            ssd_source_ready_wait_failures: self
+                .ssd_stage_counters
+                .source_ready_wait_failures
+                .load(Ordering::Relaxed),
+            ssd_source_ready_wait_duration_us: self
+                .ssd_stage_counters
+                .source_ready_wait_duration_us
+                .load(Ordering::Relaxed),
+            ssd_target_pull_requests: self
+                .ssd_stage_counters
+                .target_pull_requests
+                .load(Ordering::Relaxed),
+            ssd_target_pull_successes: self
+                .ssd_stage_counters
+                .target_pull_successes
+                .load(Ordering::Relaxed),
+            ssd_target_pull_failures: self
+                .ssd_stage_counters
+                .target_pull_failures
+                .load(Ordering::Relaxed),
+            ssd_target_pull_duration_us: self
+                .ssd_stage_counters
+                .target_pull_duration_us
+                .load(Ordering::Relaxed),
+            ssd_stage_done_detached: self
+                .ssd_stage_counters
+                .done_detached
+                .load(Ordering::Relaxed),
             external_get_holding_entries: self.external_get_holding.total() as u64,
             external_get_holding_bytes,
             external_get_start_handles: self.external_get_start_registry.len() as u64,
@@ -5853,6 +7088,42 @@ impl ClientKvApiInner {
                 .owner_remote_put_counters
                 .failed
                 .load(Ordering::Relaxed),
+            local_ssd_put_flights_active: self
+                .owner_local_ssd_put_counters
+                .active
+                .load(Ordering::Relaxed),
+            local_ssd_put_flight_leaders: self
+                .owner_local_ssd_put_counters
+                .leaders
+                .load(Ordering::Relaxed),
+            local_ssd_put_flight_followers: self
+                .owner_local_ssd_put_counters
+                .followers
+                .load(Ordering::Relaxed),
+            local_ssd_put_source_unavailable: self
+                .owner_local_ssd_put_counters
+                .source_unavailable
+                .load(Ordering::Relaxed),
+            local_ssd_put_published: self
+                .owner_local_ssd_put_counters
+                .published
+                .load(Ordering::Relaxed),
+            local_ssd_put_already_present: self
+                .owner_local_ssd_put_counters
+                .already_present
+                .load(Ordering::Relaxed),
+            local_ssd_put_dropped: self
+                .owner_local_ssd_put_counters
+                .dropped
+                .load(Ordering::Relaxed),
+            local_ssd_put_obsolete: self
+                .owner_local_ssd_put_counters
+                .obsolete
+                .load(Ordering::Relaxed),
+            local_ssd_put_failed: self
+                .owner_local_ssd_put_counters
+                .failed
+                .load(Ordering::Relaxed),
             local_reserve_slots_free,
             local_reserve_slots_prepared,
             local_reserve_slots_pending_visible,
@@ -6436,6 +7707,44 @@ impl ClientKvApi {
                     _ = shutdown_waiter.wait() => break,
                     _ = interval.tick() => {
                         let snapshot = view_task.client_kv_api().inner().runtime_observe_snapshot();
+                        if snapshot.ssd_capacity_bytes > 0 {
+                            tracing::info!(
+                                capacity_bytes = snapshot.ssd_capacity_bytes,
+                                used_bytes = snapshot.ssd_used_bytes,
+                                persist_requests = snapshot.ssd_persist_requests,
+                                persist_successes = snapshot.ssd_persist_successes,
+                                persist_failures = snapshot.ssd_persist_failures,
+                                persist_bytes = snapshot.ssd_persist_bytes,
+                                persist_duration_us = snapshot.ssd_persist_duration_us,
+                                persist_batch_requests = snapshot.ssd_persist_batch_requests,
+                                persist_batch_items = snapshot.ssd_persist_batch_items,
+                                persist_flush_batches = snapshot.ssd_persist_flush_batches,
+                                persist_busy_batches = snapshot.ssd_persist_busy_batches,
+                                persist_admission_skips = snapshot.ssd_persist_admission_skips,
+                                persist_batch_duration_us = snapshot.ssd_persist_batch_duration_us,
+                                write_candidate_items = snapshot.ssd_write_candidate_items,
+                                write_candidate_bytes = snapshot.ssd_write_candidate_bytes,
+                                write_admitted_items = snapshot.ssd_write_admitted_items,
+                                write_admitted_bytes = snapshot.ssd_write_admitted_bytes,
+                                write_dropped_items = snapshot.ssd_write_dropped_items,
+                                write_dropped_bytes = snapshot.ssd_write_dropped_bytes,
+                                write_refunded_items = snapshot.ssd_write_refunded_items,
+                                write_refunded_bytes = snapshot.ssd_write_refunded_bytes,
+                                load_requests = snapshot.ssd_load_requests,
+                                load_successes = snapshot.ssd_load_successes,
+                                load_misses = snapshot.ssd_load_misses,
+                                load_failures = snapshot.ssd_load_failures,
+                                load_bytes = snapshot.ssd_load_bytes,
+                                load_duration_us = snapshot.ssd_load_duration_us,
+                                memory_hits = snapshot.ssd_memory_hits,
+                                disk_hits = snapshot.ssd_disk_hits,
+                                outer_hits = snapshot.ssd_outer_hits,
+                                removals = snapshot.ssd_removals,
+                                active_stage_flights = snapshot.ssd_stage_flights,
+                                retained_stage_terminals = snapshot.ssd_stage_terminals,
+                                "owner KV SSD storage snapshot"
+                            );
+                        }
                         let metrics = view_task.metric_reporter().metrics();
                         metrics.set_kv_holding_entries(
                             "owner_external_get_holding",
@@ -6464,6 +7773,27 @@ impl ClientKvApi {
                             planned_cpu_local_items = snapshot.planned_cpu_get_local_items,
                             planned_cpu_leader_items = snapshot.planned_cpu_get_leader_items,
                             planned_cpu_follower_items = snapshot.planned_cpu_get_follower_items,
+                            ssd_stage_ready_requests = snapshot.ssd_stage_ready_requests,
+                            ssd_stage_ready_successes = snapshot.ssd_stage_ready_successes,
+                            ssd_stage_ready_failures = snapshot.ssd_stage_ready_failures,
+                            ssd_stage_ready_duration_us = snapshot.ssd_stage_ready_duration_us,
+                            ssd_stage_execute_completions = snapshot.ssd_stage_execute_completions,
+                            ssd_stage_terminal_published = snapshot.ssd_stage_terminal_published,
+                            ssd_stage_terminal_cache_inserts = snapshot.ssd_stage_terminal_cache_inserts,
+                            ssd_stage_terminal_cache_duration_us = snapshot.ssd_stage_terminal_cache_duration_us,
+                            ssd_stage_response_send_attempts = snapshot.ssd_stage_response_send_attempts,
+                            ssd_stage_response_send_successes = snapshot.ssd_stage_response_send_successes,
+                            ssd_stage_response_send_failures = snapshot.ssd_stage_response_send_failures,
+                            ssd_stage_response_send_duration_us = snapshot.ssd_stage_response_send_duration_us,
+                            ssd_source_ready_wait_requests = snapshot.ssd_source_ready_wait_requests,
+                            ssd_source_ready_wait_successes = snapshot.ssd_source_ready_wait_successes,
+                            ssd_source_ready_wait_failures = snapshot.ssd_source_ready_wait_failures,
+                            ssd_source_ready_wait_duration_us = snapshot.ssd_source_ready_wait_duration_us,
+                            ssd_target_pull_requests = snapshot.ssd_target_pull_requests,
+                            ssd_target_pull_successes = snapshot.ssd_target_pull_successes,
+                            ssd_target_pull_failures = snapshot.ssd_target_pull_failures,
+                            ssd_target_pull_duration_us = snapshot.ssd_target_pull_duration_us,
+                            ssd_stage_done_detached = snapshot.ssd_stage_done_detached,
                             reserve_free = snapshot.local_reserve_slots_free,
                             reserve_prepared = snapshot.local_reserve_slots_prepared,
                             reserve_pending_visible = snapshot.local_reserve_slots_pending_visible,
@@ -6485,6 +7815,18 @@ impl ClientKvApi {
                             failed = snapshot.remote_put_failed,
                             "owner unified remote Put flight snapshot"
                         );
+                        tracing::info!(
+                            active = snapshot.local_ssd_put_flights_active,
+                            leaders = snapshot.local_ssd_put_flight_leaders,
+                            followers = snapshot.local_ssd_put_flight_followers,
+                            source_unavailable = snapshot.local_ssd_put_source_unavailable,
+                            published = snapshot.local_ssd_put_published,
+                            already_present = snapshot.local_ssd_put_already_present,
+                            dropped = snapshot.local_ssd_put_dropped,
+                            obsolete = snapshot.local_ssd_put_obsolete,
+                            failed = snapshot.local_ssd_put_failed,
+                            "owner local SSD Put flight snapshot"
+                        );
                         if snapshot.hot_cache_capacity_bytes > 0 {
                             tracing::info!(
                                 capacity_bytes = snapshot.hot_cache_capacity_bytes,
@@ -6529,7 +7871,12 @@ impl ClientKvApi {
         let ClientKvApiNewArg {
             test_spec_config,
             owner_hot_cache_capacity_bytes,
+            ssd_storage,
         } = arg;
+        let ssd_storage = match ssd_storage {
+            Some(init) => Some(Arc::new(KvSsdStorage::new(init).await?)),
+            None => None,
+        };
         let (owner_local_publish_tx, owner_local_publish_rx) =
             tokio::sync::ampsc::channel(OWNER_LOCAL_PUBLISH_QUEUE_CAPACITY);
         // The Moka eviction listener is synchronous and must never block while
@@ -6544,6 +7891,7 @@ impl ClientKvApi {
         let owner_source_eviction_selected = Arc::new(DashMap::new());
         let owner_hot_counters = Arc::new(OwnerHotCacheCounters::default());
         let owner_remote_put_counters = Arc::new(OwnerRemotePutCounters::default());
+        let owner_local_ssd_put_counters = Arc::new(OwnerLocalSsdPutCounters::default());
         let owner_hot_retry_queue = Arc::new(OwnerHotRetryQueue::new(owner_hot_counters.clone()));
         let owner_hot_cache = owner_hot_cache_capacity_bytes.map(|capacity_bytes| {
             build_owner_hot_cache(
@@ -6557,6 +7905,7 @@ impl ClientKvApi {
         let inner = ClientKvApiInner {
             view: ClientKvApiViewHolder::new(),
             test_spec_config,
+            ssd_storage,
             metrics: OnceLock::new(),
             all_memholder_refcount: OnceLock::new(),
             get_remote_kv_lock: AMapLock::new(Duration::from_secs(60)),
@@ -6576,7 +7925,9 @@ impl ClientKvApi {
             owner_source_eviction_selected,
             owner_hot_counters,
             owner_remote_put_counters,
+            owner_local_ssd_put_counters,
             planned_get_counters: OwnerPlannedGetCounters::default(),
+            ssd_stage_counters: OwnerSsdStageCounters::default(),
             owner_hot_retry_queue,
             owner_hot_eviction_tx,
             owner_hot_eviction_rx: Mutex::new(Some(owner_hot_eviction_rx)),
@@ -6598,6 +7949,10 @@ impl ClientKvApi {
             completed_planned_external_get_executes: moka::future::Cache::builder()
                 .time_to_live(Duration::from_secs(120))
                 .build(),
+            ssd_stage_flights: DashMap::new(),
+            completed_ssd_stages: moka::future::Cache::builder()
+                .time_to_live(SSD_STAGE_TERMINAL_TTL)
+                .build(),
             next_external_get_start_handle: AtomicU64::new(1),
             next_external_holding_id: AtomicU64::new(1),
             external_pending_puts: moka::sync::Cache::builder()
@@ -6628,6 +7983,7 @@ impl ClientKvApi {
             rpc_caller_put_append_done: RPCCaller::new(),
             rpc_caller_batch_put_append_done: RPCCaller::new(),
             rpc_caller_batch_evict_owner_source: RPCCaller::new(),
+            rpc_caller_batch_publish_owner_ssd: RPCCaller::new(),
             rpc_caller_reserve_local_grant: RPCCaller::new(),
             rpc_caller_release_local_grant: RPCCaller::new(),
             rpc_caller_delete: RPCCaller::new(),
@@ -6636,6 +7992,9 @@ impl ClientKvApi {
             rpc_caller_get_meta: RPCCaller::new(),
             rpc_caller_allocate_client_lease: RPCCaller::new(),
             rpc_caller_client_lease_keepalive: RPCCaller::new(),
+            rpc_caller_ssd_stage_read: RPCCaller::new(),
+            rpc_caller_ssd_stage_begin: RPCCaller::new(),
+            rpc_caller_ssd_stage_done: RPCCaller::new(),
             rpc_caller_external_put_commit: RPCCaller::new(),
             rpc_caller_external_put_revoke: RPCCaller::new(),
             rpc_caller_resolve_side_transfer_lane: RPCCaller::new(),
@@ -6708,6 +8067,9 @@ impl ClientKvApi {
         inner
             .rpc_caller_batch_evict_owner_source
             .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_batch_publish_owner_ssd
+            .regist(inner.view.p2p_module());
         inner
             .rpc_caller_reserve_local_grant
             .regist(inner.view.p2p_module());
@@ -6722,6 +8084,15 @@ impl ClientKvApi {
             .rpc_caller_batch_is_exist
             .regist(inner.view.p2p_module());
         inner.rpc_caller_get_meta.regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_ssd_stage_read
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_ssd_stage_begin
+            .regist(inner.view.p2p_module());
+        inner
+            .rpc_caller_ssd_stage_done
+            .regist(inner.view.p2p_module());
         inner
             .rpc_caller_external_put_commit
             .regist(inner.view.p2p_module());
@@ -6743,6 +8114,53 @@ impl ClientKvApi {
         external_api::spawn_external_get_start_handle_sweeper(inner.view.clone_view());
         self.spawn_runtime_observe_reporter();
 
+        let view_ssd = inner.view.clone_view();
+        RPCHandler::<SsdStageReadReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
+            let view = view_ssd.clone();
+            let task_view = view.clone();
+            view.spawn("rpc_ssd_stage_read", async move {
+                let get_id = msg.serialize_part.get_id;
+                let peer = resp.node_id();
+                let task_id = resp.task_id();
+                let result = handle_ssd_stage_read(&task_view, &msg).await;
+                let inner = task_view.client_kv_api().inner();
+                inner
+                    .ssd_stage_counters
+                    .response_send_attempts
+                    .fetch_add(1, Ordering::Relaxed);
+                let send_started_at = Instant::now();
+                let send_result = resp
+                    .send_resp_with_transport_policy(result, RpcTransportPolicy::ForceTransport)
+                    .await;
+                inner
+                    .ssd_stage_counters
+                    .response_send_duration_us
+                    .fetch_add(
+                        u64::try_from(send_started_at.elapsed().as_micros()).unwrap_or(u64::MAX),
+                        Ordering::Relaxed,
+                    );
+                if let Err(err) = send_result {
+                    inner
+                        .ssd_stage_counters
+                        .response_send_failures
+                        .fetch_add(1, Ordering::Relaxed);
+                    tracing::warn!(
+                        get_id,
+                        peer = %peer,
+                        task_id,
+                        error = ?err,
+                        "SSD stage-ready response send failed"
+                    );
+                } else {
+                    inner
+                        .ssd_stage_counters
+                        .response_send_successes
+                        .fetch_add(1, Ordering::Relaxed);
+                }
+            });
+            Ok(())
+        });
+
         // External RPC handlers
         let view_ext = inner.view.clone_view();
         RPCHandler::<ExternalGetReq>::new().regist(inner.view.p2p_module(), move |resp, msg| {
@@ -7357,6 +8775,9 @@ impl LogicalModule for ClientKvApi {
     }
     async fn shutdown(&self) -> Result<(), Self::Error> {
         tracing::info!("ClientKvApi shutting down...");
+        if let Some(store) = self.0.ssd_storage.as_ref() {
+            store.close().await?;
+        }
         tracing::info!(
             "ClientKvApi final: holding_len={} , cache_len={}",
             self.0.get_holding_len(),
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
index 372a9a2..4c87394 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/msg_pack.rs
@@ -59,6 +59,38 @@ impl TestPutPhaseTrace {
         merge_i64_field!(owner_master_put_end_server_us);
     }
 }
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct SsdStageReadReq {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub get_id: u64,
+    pub stage_addr: u64,
+    pub stage_capacity: u64,
+    pub len: u64,
+}
+
+impl MsgPackSerializePart for SsdStageReadReq {
+    fn msg_id(&self) -> u32 {
+        4044
+    }
+}
+
+impl RPCReq for SsdStageReadReq {
+    type Resp = SsdStageReadResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct SsdStageReadResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for SsdStageReadResp {
+    fn msg_id(&self) -> u32 {
+        4045
+    }
+}
 // --- RPC for Physical Node Shared Memory ---
 
 #[derive(Default, Debug, Clone, Encode, Decode)]
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
index d8bcc0a..11a5f5a 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/put.rs
@@ -2,6 +2,7 @@ use super::{
     ClientKvApiInner, OwnerHotEvictionEvent, OwnerHotEvictionPreparation,
     OwnerHotSelectionFenceOutcome, OwnerLocalReserveClassState, OwnerLocalReserveGrantState,
     OwnerLocalReservePoolState, OwnerLocalReserveSlotLease, OwnerLocalReserveSlotRef,
+    OwnerLocalSsdPutOutcome, OwnerLocalSsdPutReservation, OwnerLocalSsdPutSharedOp,
     OwnerRemotePutOutcome, OwnerRemotePutReservation, OwnerRemotePutSharedOp,
     local_reserve_rebalance::{owner_local_reserve_timeout_config, wait_owner_local_reserve_ready},
 };
@@ -19,19 +20,20 @@ use crate::{
     master_kv_router::msg_pack::{
         BatchEnqueueReplicaTaskReq, BatchEnqueueReplicaTaskResp, BatchEvictOwnerSourceReq,
         BatchEvictOwnerSourceResp, BatchPreparePutKeyItemReq, BatchPreparePutKeysReq,
-        BatchPreparePutKeysResp, BatchPutAppendDoneItemReq, BatchPutAppendDoneReq,
-        BatchPutAppendDoneResp, BatchPutAppendStartItemReq, BatchPutAppendStartReq,
-        BatchPutAppendStartResp, BatchPutDoneItemReq, BatchPutDoneItemResp, BatchPutDoneReq,
-        BatchPutDoneResp, BatchPutRevokeItemReq, BatchPutRevokeReq, BatchPutRevokeResp,
-        BatchPutStartItemReq, BatchPutStartReq, BatchPutStartResp,
-        BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
-        EnqueueReplicaTaskItemResp, GroupedBatchPutDoneItemReq, GroupedBatchPutDoneReq,
-        GroupedBatchPutDoneResp, OwnerReclaimBacking, OwnerSourceEvictionOutcome,
-        OwnerSourceEvictionVictim, PutAppendDoneReq, PutAppendDoneResp, PutAppendRevokeReq,
-        PutAppendStartOutcome, PutAppendStartReq, PutAppendStartResp, PutAtomicGroup,
-        PutDoneCommittedSlot, PutDoneReq, PutRevokeReq, PutStartReq, PutStartResp,
-        ReleaseLocalGrantReq, ReserveLocalGrantOutcome, ReserveLocalGrantReq,
-        owner_source_eviction_epoch,
+        BatchPreparePutKeysResp, BatchPublishOwnerSsdReq, BatchPublishOwnerSsdResp,
+        BatchPutAppendDoneItemReq, BatchPutAppendDoneReq, BatchPutAppendDoneResp,
+        BatchPutAppendStartItemReq, BatchPutAppendStartReq, BatchPutAppendStartResp,
+        BatchPutDoneItemReq, BatchPutDoneItemResp, BatchPutDoneReq, BatchPutDoneResp,
+        BatchPutRevokeItemReq, BatchPutRevokeReq, BatchPutRevokeResp, BatchPutStartItemReq,
+        BatchPutStartReq, BatchPutStartResp, BatchReleasePutKeyReservationsReq,
+        BatchReleasePutKeyReservationsResp, EnqueueReplicaTaskItemResp, GroupedBatchPutDoneItemReq,
+        GroupedBatchPutDoneReq, GroupedBatchPutDoneResp, OwnerReclaimBacking,
+        OwnerSourceEvictionOutcome, OwnerSourceEvictionVictim, OwnerSourceEvictionVictimResp,
+        OwnerSourceSsdPolicy, OwnerSsdPublishItem, OwnerSsdPublishOutcome, PutAppendDoneReq,
+        PutAppendDoneResp, PutAppendRevokeReq, PutAppendStartOutcome, PutAppendStartReq,
+        PutAppendStartResp, PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq, PutRevokeReq,
+        PutStartReq, PutStartResp, ReleaseLocalGrantReq, ReserveLocalGrantOutcome,
+        ReserveLocalGrantReq, owner_source_eviction_epoch,
     },
     memholder::{UserMemHolder, UserMemHolderExposeKind},
     p2p::msg_pack::MsgPack,
@@ -41,6 +43,7 @@ use crate::{
 use chrono::Utc;
 use fluxon_commu::TransferBreakdown;
 use limit_thirdparty::tokio;
+use std::future::Future;
 use std::sync::{Arc, atomic::Ordering};
 use std::time::{Duration, Instant};
 use tracing::info;
@@ -363,6 +366,7 @@ mod local_reserve_claim_tests {
             ClientKvApi::construct(ClientKvApiNewArg {
                 test_spec_config: TestSpecConfig::default(),
                 owner_hot_cache_capacity_bytes: None,
+                ssd_storage: None,
             })
             .await
             .expect("construct test ClientKvApi"),
@@ -457,6 +461,7 @@ mod local_reserve_claim_tests {
             ClientKvApi::construct(ClientKvApiNewArg {
                 test_spec_config: TestSpecConfig::default(),
                 owner_hot_cache_capacity_bytes: None,
+                ssd_storage: None,
             })
             .await
             .expect("construct test ClientKvApi"),
@@ -511,6 +516,7 @@ mod local_reserve_claim_tests {
             ClientKvApi::construct(ClientKvApiNewArg {
                 test_spec_config: TestSpecConfig::default(),
                 owner_hot_cache_capacity_bytes: None,
+                ssd_storage: None,
             })
             .await
             .expect("construct test ClientKvApi"),
@@ -558,6 +564,7 @@ mod local_reserve_claim_tests {
             ClientKvApi::construct(ClientKvApiNewArg {
                 test_spec_config: TestSpecConfig::default(),
                 owner_hot_cache_capacity_bytes: None,
+                ssd_storage: None,
             })
             .await
             .expect("construct test ClientKvApi"),
@@ -630,7 +637,10 @@ pub struct OwnerReservedPutItem {
     pub lease_id: Option<u64>,
     pub peer_node_id: Option<NodeIDString>,
     pub remember_local_snapshot: bool,
+    /// Original caller/content selection, independent of remote capacity.
     pub make_replica_task: bool,
+    /// The master pre-reserved a remote memory target for this Put.
+    pub remote_replica_admitted: bool,
     pub preferred_sub_cluster: Option<String>,
 }
 
@@ -641,7 +651,12 @@ pub struct OwnerLocalPublishItem {
     pub value_len: u64,
     pub lease_id: Option<u64>,
     pub committed_slot: PutDoneCommittedSlot,
+    /// Original caller/content selection, independent of remote capacity.
     pub make_replica_task: bool,
+    /// This Put path admitted a remote trigger. Pre-reserved paths set this
+    /// only when a target exists; owner-local fast Put admits selected items
+    /// here and performs allocation inside the later append Start.
+    pub remote_replica_admitted: bool,
     pub preferred_sub_cluster: Option<String>,
     pub atomic_group: Option<PutAtomicGroup>,
 }
@@ -656,6 +671,40 @@ pub struct OwnerLocalPublishJob {
     pub external_pending_contexts: Vec<super::ExternalPendingPutCtx>,
 }
 
+fn owner_local_publish_starts_remote(item: &OwnerLocalPublishItem) -> bool {
+    item.make_replica_task && item.remote_replica_admitted
+}
+
+#[derive(Clone)]
+struct OwnerLocalSsdPutCandidate {
+    key: String,
+    put_id: PutIDForAKey,
+    /// Exact logical value bytes known by the publishing Put path. Early SSD
+    /// writes use this to reject over-budget candidates before installing a
+    /// generation flight or acquiring a source holder. A zero value is kept
+    /// only for legacy allocation-backed last-backing candidates whose
+    /// resource admission already happened upstream.
+    value_len: u64,
+    selected_victim: Option<Arc<OwnerSourceEvictionVictim>>,
+}
+
+struct OwnerLocalSsdPutLeader {
+    op: Arc<OwnerLocalSsdPutSharedOp>,
+    memory_info: Arc<crate::memholder::MemoryInfo>,
+    /// Bytes actually charged by the caller's admission pass. This can be
+    /// zero for a legacy allocation-backed last-backing candidate, so gate
+    /// failure must refund this value rather than minting credit from the
+    /// subsequently discovered source length.
+    admission_len: u64,
+}
+
+fn owner_reclaim_backing_len(backing: &OwnerReclaimBacking) -> u64 {
+    match backing {
+        OwnerReclaimBacking::CommittedSlot { slot_size, .. } => *slot_size,
+        OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation { .. } => 0,
+    }
+}
+
 #[derive(Debug, Clone, Copy, Default)]
 pub struct PutEndStats {
     pub master_put_end_rpc_us: i64,
@@ -1093,7 +1142,8 @@ impl ClientKvApiInner {
                 lease_id,
                 peer_node_id: peer_node_id.clone(),
                 remember_local_snapshot: true,
-                make_replica_task: start_req.make_replica_task && replica_admitted,
+                make_replica_task: start_req.make_replica_task,
+                remote_replica_admitted: replica_admitted,
                 preferred_sub_cluster: start_req.preferred_sub_cluster,
             });
         }
@@ -1176,6 +1226,8 @@ impl ClientKvApiInner {
             }));
         }
 
+        let mut early_ssd_candidates = Vec::new();
+        let mut remote_replica_pending = Vec::new();
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
@@ -1188,27 +1240,38 @@ impl ClientKvApiInner {
                 self.remember_local_snapshot(&pending.item.key, pending.item.put_id);
             }
             if pending.item.make_replica_task {
-                if let Err(err) = self
-                    .ensure_remote_put(
-                        &pending.item.key,
-                        pending.item.put_id,
-                        pending.item.preferred_sub_cluster.clone(),
-                        true,
-                    )
-                    .await
-                {
-                    tracing::warn!(
-                        "owner_batch_put_commit_reserved make replica task failed after local commit: key={} put_id=({},{}) err={}",
-                        pending.item.key,
-                        pending.item.put_id.0,
-                        pending.item.put_id.1,
-                        err
-                    );
-                }
+                early_ssd_candidates.push((
+                    pending.item.key.clone(),
+                    pending.item.put_id,
+                    pending.item.value_len,
+                ));
+            }
+            if pending.item.make_replica_task && pending.item.remote_replica_admitted {
+                remote_replica_pending.push((
+                    pending.item.key.clone(),
+                    pending.item.put_id,
+                    pending.item.preferred_sub_cluster.clone(),
+                ));
             }
             results[pending.idx] = Some(Ok(()));
         }
 
+        self.start_early_owner_local_ssd_puts(early_ssd_candidates);
+        for (key, put_id, preferred_sub_cluster) in remote_replica_pending {
+            if let Err(err) = self
+                .ensure_remote_put(&key, put_id, preferred_sub_cluster, true)
+                .await
+            {
+                tracing::warn!(
+                    "owner_batch_put_commit_reserved make replica task failed after local commit: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
+
         Ok(results
             .into_iter()
             .map(|item| {
@@ -1302,9 +1365,11 @@ impl ClientKvApiInner {
             idx: usize,
             key: String,
             put_id: PutIDForAKey,
+            value_len: u64,
             lease_id: Option<u64>,
             remember_local_snapshot: bool,
             make_replica_task: bool,
+            remote_replica_admitted: bool,
             preferred_sub_cluster: Option<String>,
         }
 
@@ -1313,7 +1378,7 @@ impl ClientKvApiInner {
         let short_circuit_payload = self.short_circuit_put_payload_path_enabled();
         let skip_put_end_commit = self.skip_put_end_commit_enabled();
 
-        for (idx, (((key, ptrs), _payload_len), start_item)) in keys
+        for (idx, (((key, ptrs), payload_len), start_item)) in keys
             .into_iter()
             .zip(ptrs_groups.into_iter())
             .zip(payload_lens.into_iter())
@@ -1342,9 +1407,11 @@ impl ClientKvApiInner {
                 idx,
                 key,
                 put_id,
+                value_len: payload_len,
                 lease_id,
                 remember_local_snapshot,
-                make_replica_task: make_replica_task && replica_admitted,
+                make_replica_task,
+                remote_replica_admitted: replica_admitted,
                 preferred_sub_cluster: preferred_sub_cluster.clone(),
             });
         }
@@ -1386,6 +1453,8 @@ impl ClientKvApiInner {
                 ),
             }));
         }
+        let mut early_ssd_candidates = Vec::new();
+        let mut remote_replica_pending = Vec::new();
         for (pending, done_item) in done_pending.into_iter().zip(done_resp.items.into_iter()) {
             if let Err(err) = crate::rpcresp_kvresult_convert::try_from_code(
                 done_item.error_code,
@@ -1398,27 +1467,34 @@ impl ClientKvApiInner {
                 self.remember_local_snapshot(&pending.key, pending.put_id);
             }
             if pending.make_replica_task {
-                if let Err(err) = self
-                    .ensure_remote_put(
-                        &pending.key,
-                        pending.put_id,
-                        pending.preferred_sub_cluster.clone(),
-                        true,
-                    )
-                    .await
-                {
-                    tracing::warn!(
-                        "batch make replica task failed after local commit: key={} put_id=({},{}) err={}",
-                        pending.key,
-                        pending.put_id.0,
-                        pending.put_id.1,
-                        err
-                    );
-                }
+                early_ssd_candidates.push((pending.key.clone(), pending.put_id, pending.value_len));
+            }
+            if pending.make_replica_task && pending.remote_replica_admitted {
+                remote_replica_pending.push((
+                    pending.key.clone(),
+                    pending.put_id,
+                    pending.preferred_sub_cluster.clone(),
+                ));
             }
             results[pending.idx] = Some(Ok(()));
         }
 
+        self.start_early_owner_local_ssd_puts(early_ssd_candidates);
+        for (key, put_id, preferred_sub_cluster) in remote_replica_pending {
+            if let Err(err) = self
+                .ensure_remote_put(&key, put_id, preferred_sub_cluster, true)
+                .await
+            {
+                tracing::warn!(
+                    "batch make replica task failed after local commit: key={} put_id=({},{}) err={}",
+                    key,
+                    put_id.0,
+                    put_id.1,
+                    err
+                );
+            }
+        }
+
         Ok(results
             .into_iter()
             .map(|item| {
@@ -1431,6 +1507,148 @@ impl ClientKvApiInner {
             .collect())
     }
 
+    fn start_owner_local_ssd_puts(
+        &self,
+        candidates: Vec<OwnerLocalSsdPutCandidate>,
+        resources_pre_admitted: bool,
+    ) -> Vec<Option<Arc<OwnerLocalSsdPutSharedOp>>> {
+        // Early backing is optional work. Apply its independent byte budget
+        // before touching the per-key generation table or pinning a source.
+        // Last-backing callers have already performed the same admission while
+        // deciding which capacity victims may enter durability, so they pass
+        // resources_pre_admitted=true and must not be charged twice.
+        let admission = if resources_pre_admitted {
+            vec![true; candidates.len()]
+        } else {
+            let lengths = candidates
+                .iter()
+                .map(|candidate| candidate.value_len)
+                .collect::<Vec<_>>();
+            self.ssd_storage
+                .as_ref()
+                .map(|store| store.admit_owner_write_candidates(&lengths))
+                .unwrap_or_else(|| vec![false; candidates.len()])
+        };
+        let mut operations = std::iter::repeat_with(|| None)
+            .take(candidates.len())
+            .collect::<Vec<_>>();
+        let mut leaders = Vec::new();
+        let mut unused_pre_admission_lengths = Vec::new();
+        for (index, (candidate, admitted_by_resource)) in
+            candidates.into_iter().zip(admission).enumerate()
+        {
+            if !admitted_by_resource {
+                continue;
+            }
+            let pre_admitted_len = candidate.value_len;
+            match self.begin_owner_local_ssd_put(
+                &candidate.key,
+                candidate.put_id,
+                candidate.selected_victim.as_deref(),
+            ) {
+                OwnerLocalSsdPutReservation::Leader { op, memory_info } => {
+                    operations[index] = Some(op.clone());
+                    if pre_admitted_len != 0 && u64::from(memory_info.len) != pre_admitted_len {
+                        tracing::warn!(
+                            key = %candidate.key,
+                            put_id_time = candidate.put_id.0,
+                            put_id_version = candidate.put_id.1,
+                            admitted_len = pre_admitted_len,
+                            source_len = memory_info.len,
+                            "owner local SSD pre-admission length no longer matches exact source"
+                        );
+                        unused_pre_admission_lengths.push(pre_admitted_len);
+                        self.finish_owner_local_ssd_put(&op, OwnerLocalSsdPutOutcome::Failed);
+                        continue;
+                    }
+                    leaders.push(OwnerLocalSsdPutLeader {
+                        op,
+                        memory_info,
+                        admission_len: pre_admitted_len,
+                    });
+                }
+                OwnerLocalSsdPutReservation::Follower(op) => {
+                    operations[index] = Some(op);
+                    unused_pre_admission_lengths.push(pre_admitted_len);
+                }
+                OwnerLocalSsdPutReservation::SourceUnavailable => {
+                    unused_pre_admission_lengths.push(pre_admitted_len);
+                }
+            }
+        }
+        if let Some(store) = self.ssd_storage.as_ref() {
+            store.refund_owner_write_admission(&unused_pre_admission_lengths);
+        }
+        if leaders.is_empty() {
+            return operations;
+        }
+
+        let admitted_lengths = leaders
+            .iter()
+            .map(|leader| leader.admission_len)
+            .collect::<Vec<_>>();
+        let permit = match self.try_acquire_local_ssd_persist_batch(leaders.len()) {
+            Ok(Some(permit)) => permit,
+            Ok(None) => {
+                if let Some(store) = self.ssd_storage.as_ref() {
+                    store.refund_owner_write_admission(&admitted_lengths);
+                }
+                for leader in leaders {
+                    self.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Dropped);
+                }
+                return operations;
+            }
+            Err(err) => {
+                if let Some(store) = self.ssd_storage.as_ref() {
+                    store.refund_owner_write_admission(&admitted_lengths);
+                }
+                tracing::warn!(
+                    items = leaders.len(),
+                    error = %err,
+                    "owner local SSD durability batch admission failed"
+                );
+                for leader in leaders {
+                    self.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+                }
+                return operations;
+            }
+        };
+
+        let spawn_view = self.view.clone_view();
+        let task_view = spawn_view.clone();
+        let _ = spawn_view.spawn("owner_local_ssd_put_batch", async move {
+            run_owner_local_ssd_put_batch(task_view, leaders, permit).await;
+        });
+        operations
+    }
+
+    pub(crate) fn start_early_owner_local_ssd_puts(
+        &self,
+        candidates: Vec<(String, PutIDForAKey, u64)>,
+    ) {
+        let _ = self.start_owner_local_ssd_puts(
+            candidates
+                .into_iter()
+                .map(|(key, put_id, value_len)| OwnerLocalSsdPutCandidate {
+                    key,
+                    put_id,
+                    value_len,
+                    selected_victim: None,
+                })
+                .collect(),
+            false,
+        );
+    }
+
+    pub(crate) fn start_early_owner_local_ssd_put(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        value_len: u64,
+    ) {
+        self.start_early_owner_local_ssd_puts(vec![(key.to_string(), put_id, value_len)]);
+    }
+
     /// Ensure one remote backing exists for an exact owner-local generation.
     ///
     /// Normal Put, pre-reserved replica, proactive write-back, and tier1 all
@@ -1605,6 +1823,9 @@ impl ClientKvApiInner {
             );
             self.put_end(key, put_id, lease_id).await?;
             self.remember_local_snapshot(key, put_id);
+            if make_replica_task {
+                self.start_early_owner_local_ssd_put(key, put_id, payload_len);
+            }
             if make_replica_task && replica_admitted {
                 if let Err(err) = self
                     .ensure_remote_put(key, put_id, preferred_sub_cluster.map(str::to_string), true)
@@ -1676,6 +1897,9 @@ impl ClientKvApiInner {
 
         self.put_end(key, put_id, lease_id).await?;
         self.remember_local_snapshot(key, put_id);
+        if make_replica_task {
+            self.start_early_owner_local_ssd_put(key, put_id, payload_len);
+        }
         if make_replica_task && replica_admitted {
             if let Err(err) = self
                 .ensure_remote_put(key, put_id, preferred_sub_cluster.map(str::to_string), true)
@@ -2215,6 +2439,54 @@ impl ClientKvApiInner {
         Ok(resp.serialize_part)
     }
 
+    async fn batch_publish_owner_ssd(
+        &self,
+        items: Vec<OwnerSsdPublishItem>,
+    ) -> KvResult<BatchPublishOwnerSsdResp> {
+        if items.is_empty() {
+            return Ok(BatchPublishOwnerSsdResp {
+                items: Vec::new(),
+                error_code: crate::rpcresp_kvresult_convert::msg_and_error::OK,
+                error_json: String::new(),
+            });
+        }
+        if !self.view.register_shutdown_poller().is_running() {
+            return Err(KvError::Api(ApiError::SystemShutdown {
+                detail: "ClientKvApi is shutting down; rejecting owner SSD publication".to_string(),
+            }));
+        }
+        let self_info = self.view.cluster_manager().get_self_info();
+        let req = MsgPack {
+            serialize_part: BatchPublishOwnerSsdReq {
+                owner_node_start_time: self_info.node_start_time,
+                items,
+            },
+            raw_bytes: Vec::new(),
+        };
+        let master_node_id = self
+            .view
+            .cluster_manager()
+            .find_or_wait_master_node()
+            .await?;
+        let resp = self
+            .rpc_caller_batch_publish_owner_ssd
+            .call_with_transport_policy(
+                self.view.p2p_module(),
+                master_node_id.into(),
+                req,
+                Some(Duration::from_secs(60)),
+                RpcTransportPolicy::ForceTransport,
+                2,
+            )
+            .await
+            .map_err(KvError::from)?;
+        crate::rpcresp_kvresult_convert::try_from_code(
+            resp.serialize_part.error_code,
+            resp.serialize_part.error_json.clone(),
+        )?;
+        Ok(resp.serialize_part)
+    }
+
     pub async fn put_append_revoke(
         &self,
         key: &str,
@@ -2786,7 +3058,7 @@ const OWNER_LOCAL_PUBLISH_RETRY_MAX: Duration = Duration::from_secs(1);
 mod owner_hot_replica_policy_tests {
     use super::{
         OwnerLocalPublishItem, complete_owner_local_publish_group_lens,
-        owner_local_publish_atomic_batch_complete,
+        owner_local_publish_atomic_batch_complete, owner_local_publish_starts_remote,
     };
     use crate::master_kv_router::msg_pack::{
         PutAtomicGroup, PutAtomicGroupMember, PutDoneCommittedSlot,
@@ -2804,6 +3076,7 @@ mod owner_hot_replica_policy_tests {
             lease_id: None,
             committed_slot: PutDoneCommittedSlot::default(),
             make_replica_task: false,
+            remote_replica_admitted: false,
             preferred_sub_cluster: None,
             atomic_group,
         }
@@ -2845,6 +3118,19 @@ mod owner_hot_replica_policy_tests {
         assert_eq!(complete_owner_local_publish_group_lens(&partial), None);
     }
 
+    #[test]
+    fn local_ssd_content_selection_does_not_bypass_remote_resource_admission() {
+        let mut item = publish_item("key", (1, 0), None);
+        item.make_replica_task = true;
+        assert!(!owner_local_publish_starts_remote(&item));
+
+        item.remote_replica_admitted = true;
+        assert!(owner_local_publish_starts_remote(&item));
+
+        item.make_replica_task = false;
+        assert!(!owner_local_publish_starts_remote(&item));
+    }
+
     #[test]
     fn hot_admission_waits_for_every_atomic_group_member_to_publish() {
         let group = PutAtomicGroup {
@@ -2919,6 +3205,7 @@ fn owner_source_eviction_identity(
 fn owner_source_eviction_victim(
     identity: &super::OwnerHotReplicaIdentity,
     memory_info: &crate::memholder::MemoryInfo,
+    ssd_enabled: bool,
 ) -> Option<OwnerSourceEvictionVictim> {
     let (slot_size, grant_id, slot_index) = memory_info.local_reserve_resident_slot_ref()?;
     Some(OwnerSourceEvictionVictim {
@@ -2929,6 +3216,12 @@ fn owner_source_eviction_victim(
             slot_index,
             slot_size,
         },
+        ssd_backing_len: None,
+        ssd_policy: if ssd_enabled {
+            OwnerSourceSsdPolicy::SelectLastLive
+        } else {
+            OwnerSourceSsdPolicy::Drop
+        },
     })
 }
 
@@ -3049,7 +3342,9 @@ fn prepare_owner_source_eviction_event(
     };
     debug_assert_eq!(resolved_trigger, trigger);
 
-    let Some(victim) = owner_source_eviction_victim(&trigger, source.as_ref()) else {
+    let Some(victim) =
+        owner_source_eviction_victim(&trigger, source.as_ref(), inner.ssd_storage.is_some())
+    else {
         event.selection_debt.release();
         inner
             .owner_hot_counters
@@ -3112,6 +3407,194 @@ fn prepare_owner_source_eviction_event(
     Some((event, victim))
 }
 
+async fn finish_owner_source_eviction_result(
+    inner: &ClientKvApiInner,
+    operation_id: u64,
+    index: usize,
+    event: OwnerHotEvictionEvent,
+    victim: Arc<OwnerSourceEvictionVictim>,
+    result: OwnerSourceEvictionVictimResp,
+) {
+    if victim.ssd_policy == OwnerSourceSsdPolicy::Persisted
+        && !result.ssd_backing_committed
+        && matches!(
+            result.outcome,
+            OwnerSourceEvictionOutcome::Completed
+                | OwnerSourceEvictionOutcome::Stale
+                | OwnerSourceEvictionOutcome::RejectedNotEvictable
+        )
+    {
+        inner
+            .discard_local_ssd_replica(&victim.key, victim.put_id)
+            .await;
+    }
+    match result.outcome {
+        OwnerSourceEvictionOutcome::Accepted | OwnerSourceEvictionOutcome::AlreadyInProgress => {
+            inner
+                .owner_hot_counters
+                .source_evict_handoff_members
+                .fetch_add(1, Ordering::Relaxed);
+        }
+        OwnerSourceEvictionOutcome::Completed => {
+            let epoch = owner_source_eviction_epoch(operation_id, index);
+            match super::reclaim::complete_owner_source_eviction(inner, &victim, epoch) {
+                Ok(()) => {
+                    inner
+                        .owner_hot_counters
+                        .source_evict_handoff_members
+                        .fetch_add(1, Ordering::Relaxed);
+                }
+                Err(detail) => {
+                    tracing::warn!(
+                        key = victim.key,
+                        put_time_ms = victim.put_id.0,
+                        put_version = victim.put_id.1,
+                        detail,
+                        "master deleted source route but owner slot release must retry"
+                    );
+                    schedule_owner_source_eviction_retry(
+                        inner,
+                        event,
+                        victim,
+                        "owner slot release after master direct-delete is temporarily busy",
+                    );
+                }
+            }
+        }
+        OwnerSourceEvictionOutcome::SsdCandidate => {
+            tracing::error!(
+                key = victim.key,
+                policy = ?victim.ssd_policy,
+                "master returned an SSD candidate outside the selection phase"
+            );
+            schedule_owner_source_eviction_retry(
+                inner,
+                event,
+                victim,
+                "unexpected repeated SSD candidate response",
+            );
+        }
+        OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified => {
+            schedule_owner_source_eviction_retry(
+                inner,
+                event,
+                victim,
+                "master source reclaim is temporarily busy",
+            );
+        }
+        OwnerSourceEvictionOutcome::Stale => {
+            finish_owner_source_selection(
+                inner,
+                &victim,
+                true,
+                "master rejected stale source identity",
+            );
+        }
+        OwnerSourceEvictionOutcome::RejectedNotEvictable => {
+            tracing::error!(
+                key = victim.key,
+                detail = result.detail,
+                "owner selected a source victim that master declared non-evictable"
+            );
+            finish_owner_source_selection(
+                inner,
+                &victim,
+                true,
+                "master rejected non-evictable source victim",
+            );
+        }
+    }
+}
+
+async fn submit_owner_source_eviction_decisions(
+    inner: &ClientKvApiInner,
+    prepared: Vec<(OwnerHotEvictionEvent, Arc<OwnerSourceEvictionVictim>)>,
+    rpc_failure_reason: &'static str,
+    response_length_reason: &'static str,
+    response_identity_reason: &'static str,
+) {
+    if prepared.is_empty() {
+        return;
+    }
+    let response = inner
+        .batch_evict_owner_source(
+            prepared
+                .iter()
+                .map(|(_, victim)| victim.as_ref().clone())
+                .collect(),
+        )
+        .await;
+    let Ok(response) = response else {
+        for (event, victim) in prepared {
+            schedule_owner_source_eviction_retry(inner, event, victim, rpc_failure_reason);
+        }
+        return;
+    };
+    if response.victims.len() != prepared.len() {
+        for (event, victim) in prepared {
+            schedule_owner_source_eviction_retry(inner, event, victim, response_length_reason);
+        }
+        return;
+    }
+    let operation_id = response.operation_id;
+    for (index, ((event, victim), result)) in prepared.into_iter().zip(response.victims).enumerate()
+    {
+        if result.victim_index != u32::try_from(index).unwrap_or(u32::MAX) {
+            schedule_owner_source_eviction_retry(inner, event, victim, response_identity_reason);
+            continue;
+        }
+        finish_owner_source_eviction_result(inner, operation_id, index, event, victim, result)
+            .await;
+    }
+}
+
+async fn reclaim_admission_drops_before_ssd_persist<T, DropFuture, PersistFn, PersistFuture>(
+    drop_reclaim: DropFuture,
+    persist: PersistFn,
+) -> T
+where
+    DropFuture: Future<Output = ()>,
+    PersistFn: FnOnce() -> PersistFuture,
+    PersistFuture: Future<Output = T>,
+{
+    drop_reclaim.await;
+    persist().await
+}
+
+#[cfg(test)]
+mod owner_ssd_fast_drop_tests {
+    use super::reclaim_admission_drops_before_ssd_persist;
+    use std::sync::{Arc, Mutex};
+
+    #[limit_thirdparty::tokio::test]
+    async fn admission_drops_finish_before_ssd_persist_starts() {
+        let order = Arc::new(Mutex::new(Vec::new()));
+        let drop_order = order.clone();
+        let persist_order = order.clone();
+
+        let result = reclaim_admission_drops_before_ssd_persist(
+            async move {
+                drop_order.lock().unwrap().push("drop-start");
+                limit_thirdparty::tokio::task::yield_now().await;
+                drop_order.lock().unwrap().push("drop-finished");
+            },
+            move || async move {
+                let mut order = persist_order.lock().unwrap();
+                assert_eq!(order.last(), Some(&"drop-finished"));
+                order.push("persist-start");
+                17
+            },
+        )
+        .await;
+
+        assert_eq!(result, 17);
+        assert_eq!(
+            order.lock().unwrap().as_slice(),
+            ["drop-start", "drop-finished", "persist-start"]
+        );
+    }
+}
+
 async fn process_owner_source_eviction_events(
     view: &ClientKvApiView,
     events: Vec<OwnerHotEvictionEvent>,
@@ -3124,11 +3607,16 @@ async fn process_owner_source_eviction_events(
     if prepared.is_empty() {
         return;
     }
-    let victims = prepared
-        .iter()
-        .map(|(_, victim)| victim.as_ref().clone())
-        .collect::<Vec<_>>();
-    let response = inner.batch_evict_owner_source(victims).await;
+    // The first pass never touches SSD. Master deletes sources that already
+    // have another live backing and returns only exact last-copy candidates.
+    let response = inner
+        .batch_evict_owner_source(
+            prepared
+                .iter()
+                .map(|(_, victim)| victim.as_ref().clone())
+                .collect(),
+        )
+        .await;
     let Ok(response) = response else {
         for (event, victim) in prepared {
             schedule_owner_source_eviction_retry(
@@ -3184,6 +3672,8 @@ async fn process_owner_source_eviction_events(
         );
     }
 
+    let first_operation_id = response.operation_id;
+    let mut candidates = Vec::new();
     for (index, ((event, victim), result)) in prepared
         .into_iter()
         .zip(response.victims.into_iter())
@@ -3198,73 +3688,120 @@ async fn process_owner_source_eviction_events(
             );
             continue;
         }
-        match result.outcome {
-            OwnerSourceEvictionOutcome::Accepted
-            | OwnerSourceEvictionOutcome::AlreadyInProgress => {
-                inner
-                    .owner_hot_counters
-                    .source_evict_handoff_members
-                    .fetch_add(1, Ordering::Relaxed);
-                // Selected debt stays live until owner reclaim Commit calls
-                // owner_hot_invalidate_version for the exact victim.
-            }
-            OwnerSourceEvictionOutcome::Completed => {
-                let epoch = owner_source_eviction_epoch(response.operation_id, index);
-                match super::reclaim::complete_owner_source_eviction(inner, &victim, epoch) {
-                    Ok(()) => {
-                        inner
-                            .owner_hot_counters
-                            .source_evict_handoff_members
-                            .fetch_add(1, Ordering::Relaxed);
-                    }
-                    Err(detail) => {
-                        tracing::warn!(
-                            key = victim.key,
-                            put_time_ms = victim.put_id.0,
-                            put_version = victim.put_id.1,
-                            detail,
-                            "master deleted source route but owner slot release must retry"
-                        );
-                        schedule_owner_source_eviction_retry(
-                            inner,
-                            event,
-                            victim,
-                            "owner slot release after master direct-delete is temporarily busy",
-                        );
-                    }
-                }
-            }
-            OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified => {
-                schedule_owner_source_eviction_retry(
-                    inner,
-                    event,
-                    victim,
-                    "master source reclaim is temporarily busy",
-                );
-            }
-            OwnerSourceEvictionOutcome::Stale => {
-                finish_owner_source_selection(
-                    inner,
-                    &victim,
-                    true,
-                    "master rejected stale source identity",
-                );
-            }
-            OwnerSourceEvictionOutcome::RejectedNotEvictable => {
-                tracing::error!(
-                    key = victim.key,
-                    detail = result.detail,
-                    "owner selected a source victim that master declared non-evictable"
-                );
-                finish_owner_source_selection(
-                    inner,
-                    &victim,
-                    true,
-                    "master rejected non-evictable source victim",
-                );
-            }
+        if result.outcome == OwnerSourceEvictionOutcome::SsdCandidate
+            && victim.ssd_policy == OwnerSourceSsdPolicy::SelectLastLive
+        {
+            candidates.push((event, victim));
+            continue;
+        }
+        finish_owner_source_eviction_result(
+            inner,
+            first_operation_id,
+            index,
+            event,
+            victim,
+            result,
+        )
+        .await;
+    }
+
+    if candidates.is_empty() {
+        return;
+    }
+    let candidate_lengths = candidates
+        .iter()
+        .map(|(_, victim)| owner_reclaim_backing_len(&victim.backing))
+        .collect::<Vec<_>>();
+    let admission = inner
+        .ssd_storage
+        .as_ref()
+        .map(|store| store.admit_owner_write_candidates(&candidate_lengths))
+        .unwrap_or_else(|| vec![false; candidates.len()]);
+    let candidate_items = candidates.len();
+    let mut dropped = Vec::new();
+    let mut admitted_candidates = Vec::new();
+    for ((mut event, victim), is_admitted) in candidates.into_iter().zip(admission) {
+        let mut request = victim.as_ref().clone();
+        request.ssd_backing_len = None;
+        request.ssd_policy = OwnerSourceSsdPolicy::Drop;
+        let request = Arc::new(request);
+        event.source_eviction_victim = Some(request.clone());
+        if is_admitted {
+            admitted_candidates.push((event, request));
+        } else {
+            dropped.push((event, request));
         }
     }
+
+    // Candidates rejected by the byte budget must release their DRAM slots
+    // before the admitted durability batch starts. Otherwise one slow SSD
+    // flush makes every intentional Drop in the same pressure batch wait,
+    // recreating a reclaim backlog even though no SSD queue exists.
+    let dropped_items = dropped.len();
+    let admitted_items = admitted_candidates.len();
+    // Both early Put and last-backing fallback enter the same per-generation
+    // local_ssd_put flight. The fallback starts only after explicit admission
+    // Drops have released their DRAM slots.
+    let operations = reclaim_admission_drops_before_ssd_persist(
+        submit_owner_source_eviction_decisions(
+            inner,
+            dropped,
+            "owner SSD admission-drop direct-delete RPC failed",
+            "owner SSD admission-drop response length mismatch",
+            "owner SSD admission-drop response identity mismatch",
+        ),
+        || async {
+            inner.start_owner_local_ssd_puts(
+                admitted_candidates
+                    .iter()
+                    .map(|(_, victim)| OwnerLocalSsdPutCandidate {
+                        key: victim.key.clone(),
+                        put_id: victim.put_id,
+                        value_len: owner_reclaim_backing_len(&victim.backing),
+                        selected_victim: Some(victim.clone()),
+                    })
+                    .collect(),
+                true,
+            )
+        },
+    )
+    .await;
+    let mut admitted_decisions = Vec::with_capacity(admitted_candidates.len());
+    let mut persisted_items = 0usize;
+    for ((mut event, victim), operation) in admitted_candidates.into_iter().zip(operations) {
+        let outcome = match operation {
+            Some(operation) => operation.wait().await,
+            None => OwnerLocalSsdPutOutcome::Failed,
+        };
+        if matches!(
+            outcome,
+            OwnerLocalSsdPutOutcome::Published | OwnerLocalSsdPutOutcome::AlreadyPresent
+        ) {
+            persisted_items += 1;
+        }
+        // Publication, when successful, already attached SSD to the exact
+        // route. Direct-delete now removes only memory. Failed/Drop outcomes
+        // retain the cache's existing fail-open eviction behavior.
+        event.source_eviction_victim = Some(victim.clone());
+        admitted_decisions.push((event, victim));
+    }
+    tracing::info!(
+        candidates = candidate_items,
+        admitted = admitted_items,
+        persisted = persisted_items,
+        admission_dropped = dropped_items,
+        persist_dropped = admitted_items.saturating_sub(persisted_items),
+        "owner last-backing SSD admission completed without queueing excess victims"
+    );
+
+    submit_owner_source_eviction_decisions(
+        inner,
+        admitted_decisions,
+        "owner SSD persisted decision direct-delete RPC failed",
+        "owner SSD persisted decision response length mismatch",
+        "owner SSD persisted decision response identity mismatch",
+    )
+    .await;
 }
 
 pub fn spawn_owner_source_eviction_dispatcher(
@@ -3406,6 +3943,167 @@ pub fn spawn_owner_hot_retry_actor(view: ClientKvApiView) {
     });
 }
 
+async fn run_owner_local_ssd_put_batch(
+    view: ClientKvApiView,
+    leaders: Vec<OwnerLocalSsdPutLeader>,
+    permit: crate::kv_ssd_storage::KvSsdPersistBatchPermit,
+) {
+    let inner = view.client_kv_api().inner();
+    let mut holders = Vec::with_capacity(leaders.len());
+    let mut sources = Vec::with_capacity(leaders.len());
+    for leader in &leaders {
+        let holder = Arc::new(UserMemHolder::new(
+            leader.memory_info.clone(),
+            inner.get_or_init_all_memholder_refcount(),
+            UserMemHolderExposeKind::SegPtr,
+        ));
+        sources.push(crate::kv_ssd_storage::KvSsdPersistSource {
+            key: leader.op.key.clone(),
+            put_id: leader.op.put_id,
+            addr: holder.memory_info.addr,
+            len: u64::from(holder.memory_info.len),
+        });
+        holders.push(holder);
+    }
+
+    let copies = match inner.copy_local_kvs_for_ssd(&sources).await {
+        Ok(copies) => copies,
+        Err(err) => {
+            drop(holders);
+            tracing::warn!(
+                items = leaders.len(),
+                error = %err,
+                "owner local SSD source copy validation failed"
+            );
+            for leader in leaders {
+                inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+            }
+            return;
+        }
+    };
+    // Durability now reads only owner-owned copies. The source Moka pins may
+    // be released while this flight remains installed through route publish.
+    drop(holders);
+
+    let persisted = match inner.persist_copied_local_kvs_to_ssd(permit, copies).await {
+        Ok(persisted) => persisted,
+        Err(err) => {
+            tracing::warn!(
+                items = leaders.len(),
+                error = %err,
+                "owner local SSD durability setup failed"
+            );
+            for leader in leaders {
+                inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+            }
+            return;
+        }
+    };
+
+    let mut publish = Vec::new();
+    for ((leader, source), outcome) in leaders
+        .into_iter()
+        .zip(sources.into_iter())
+        .zip(persisted.into_iter())
+    {
+        match outcome {
+            Ok(Some(guard)) => {
+                publish.push((leader, source, guard));
+            }
+            Ok(None) => {
+                inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Dropped);
+            }
+            Err(err) => {
+                tracing::warn!(
+                    key = leader.op.key,
+                    put_time_ms = leader.op.put_id.0,
+                    put_version = leader.op.put_id.1,
+                    error = %err,
+                    "owner local SSD persist failed"
+                );
+                inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+            }
+        }
+    }
+    if publish.is_empty() {
+        return;
+    }
+
+    let response = match inner
+        .batch_publish_owner_ssd(
+            publish
+                .iter()
+                .map(|(leader, source, _)| OwnerSsdPublishItem {
+                    key: leader.op.key.clone(),
+                    put_id: leader.op.put_id,
+                    len: source.len,
+                })
+                .collect(),
+        )
+        .await
+    {
+        Ok(response) => response,
+        Err(err) => {
+            tracing::warn!(
+                items = publish.len(),
+                error = %err,
+                "owner local SSD publication was uncertain; retaining durable bytes for replay"
+            );
+            for (leader, _, _guard) in publish {
+                inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+            }
+            return;
+        }
+    };
+    if response.items.len() != publish.len() {
+        tracing::warn!(
+            requested = publish.len(),
+            received = response.items.len(),
+            "owner local SSD publication response length mismatch; retaining bytes for replay"
+        );
+        for (leader, _, _guard) in publish {
+            inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+        }
+        return;
+    }
+
+    for ((leader, _, _guard), result) in publish.into_iter().zip(response.items) {
+        if result.key != leader.op.key || result.put_id != leader.op.put_id {
+            tracing::warn!(
+                expected_key = leader.op.key,
+                expected_put_time_ms = leader.op.put_id.0,
+                expected_put_version = leader.op.put_id.1,
+                response_key = result.key,
+                response_put_time_ms = result.put_id.0,
+                response_put_version = result.put_id.1,
+                "owner local SSD publication identity mismatch; retaining bytes for replay"
+            );
+            inner.finish_owner_local_ssd_put(&leader.op, OwnerLocalSsdPutOutcome::Failed);
+            continue;
+        }
+        let outcome = match result.outcome {
+            OwnerSsdPublishOutcome::Published => OwnerLocalSsdPutOutcome::Published,
+            OwnerSsdPublishOutcome::AlreadyPresent => OwnerLocalSsdPutOutcome::AlreadyPresent,
+            OwnerSsdPublishOutcome::Obsolete => {
+                inner
+                    .discard_local_ssd_replica(&leader.op.key, leader.op.put_id)
+                    .await;
+                OwnerLocalSsdPutOutcome::Obsolete
+            }
+            OwnerSsdPublishOutcome::Rejected => {
+                inner
+                    .discard_local_ssd_replica(&leader.op.key, leader.op.put_id)
+                    .await;
+                OwnerLocalSsdPutOutcome::Failed
+            }
+            OwnerSsdPublishOutcome::RetryableBusy | OwnerSsdPublishOutcome::Unspecified => {
+                OwnerLocalSsdPutOutcome::Failed
+            }
+        };
+        inner.finish_owner_local_ssd_put(&leader.op, outcome);
+    }
+}
+
 async fn fail_owner_remote_put(
     view: &ClientKvApiView,
     op: Arc<OwnerRemotePutSharedOp>,
@@ -3897,8 +4595,22 @@ pub(crate) async fn publish_owner_local_job(view: ClientKvApiView, job: OwnerLoc
             let _ = inner.owner_hot_admit_published_committed(&item.key, item.put_id);
         }
 
+        let _ = inner.start_owner_local_ssd_puts(
+            promoted_items
+                .iter()
+                .filter(|item| item.make_replica_task)
+                .map(|item| OwnerLocalSsdPutCandidate {
+                    key: item.key.clone(),
+                    put_id: item.put_id,
+                    value_len: item.value_len,
+                    selected_victim: None,
+                })
+                .collect(),
+            false,
+        );
+
         for item in promoted_items {
-            if item.make_replica_task {
+            if owner_local_publish_starts_remote(item) {
                 if let Err(err) = inner
                     .ensure_remote_put(
                         &item.key,
diff --git a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
index 1eb0a5a..43a3b47 100644
--- a/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/client_kv_api/reclaim.rs
@@ -1,4 +1,7 @@
-use super::{ClientKvApiInner, ClientKvApiView, OwnerPreparedReclaim, OwnerReclaimRecord};
+use super::{
+    ClientKvApiInner, ClientKvApiView, OwnerPreparedReclaim, OwnerPreparedReclaimSource,
+    OwnerPreparedSsdBacking, OwnerReclaimRecord,
+};
 use crate::cluster_manager::{NodeID, NodeRole};
 use crate::master_kv_router::msg_pack::{
     BatchOwnerReclaimReq, BatchOwnerReclaimResp, OwnerReclaimBacking, OwnerReclaimItem,
@@ -7,6 +10,7 @@ use crate::master_kv_router::msg_pack::{
 };
 use crate::p2p::msg_pack::MsgPack;
 use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
+use limit_thirdparty::tokio;
 use std::{collections::HashMap, sync::Arc};
 
 fn item_resp(
@@ -18,6 +22,7 @@ fn item_resp(
         key: item.key.clone(),
         epoch: item.epoch,
         state,
+        ssd_backing_len: None,
         detail: detail.into(),
     }
 }
@@ -36,7 +41,7 @@ fn memory_matches_reclaim_backing(
 ) -> bool {
     match backing {
         OwnerReclaimBacking::Allocation => memory_info.local_reserve_resident_slot_ref().is_none(),
-        OwnerReclaimBacking::UnindexedAllocation => false,
+        OwnerReclaimBacking::UnindexedAllocation { .. } => false,
         OwnerReclaimBacking::CommittedSlot {
             grant_id,
             slot_index,
@@ -58,6 +63,8 @@ fn reclaim_key_control_busy_detail(state: &super::OwnerKeyControlState) -> Optio
         Some("owner external put context is still pending")
     } else if state.remote_put.is_some() {
         Some("owner remote put transfer is inflight")
+    } else if state.local_ssd_put.is_some() {
+        Some("owner local SSD put is inflight")
     } else if state.source_eviction_selection.is_some() {
         Some("owner source eviction selection fence is active")
     } else if state.external_get.is_some() {
@@ -93,7 +100,11 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
                 "another owner source selection owns the key fence",
             );
         }
-        if state.local_puts != 0 || state.external_pending_puts != 0 || state.remote_put.is_some() {
+        if state.local_puts != 0
+            || state.external_pending_puts != 0
+            || state.remote_put.is_some()
+            || state.local_ssd_put.is_some()
+        {
             return item_resp(
                 item,
                 OwnerReclaimItemState::Busy,
@@ -134,8 +145,13 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
         );
         state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
             item: item.clone(),
-            cached_info: selection.cached_info,
-            local_snapshot,
+            source: OwnerPreparedReclaimSource::Indexed {
+                cached_info: selection.cached_info,
+                local_snapshot,
+            },
+            ssd_prepare_lock: Arc::new(tokio::sync::AMutex::new(())),
+            ssd_prepare_complete: false,
+            ssd_backing: None,
         }));
         return item_resp(
             item,
@@ -180,6 +196,58 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
             "owner local Get commit is pending",
         );
     }
+    if let OwnerReclaimBacking::UnindexedAllocation {
+        addr,
+        base_addr,
+        len,
+        capacity_bytes,
+    } = &item.backing
+    {
+        if item.reason != OwnerReclaimReason::MasterAllocationCapacity
+            || *len == 0
+            || *capacity_bytes < *len
+            || *addr < *base_addr
+            || addr.checked_add(*len).is_none()
+        {
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Stale,
+                "invalid unindexed Allocation source identity",
+            );
+        }
+        if inner.get_cached_info.contains_key(&item.key)
+            || inner.local_snapshot_info.contains_key(&item.key)
+        {
+            return item_resp(
+                item,
+                OwnerReclaimItemState::Stale,
+                "unindexed Allocation unexpectedly has an owner-local index",
+            );
+        }
+        let state = controls.entry(item.key.clone()).or_default();
+        assert!(
+            state.reclaim.is_none()
+                && state.local_puts == 0
+                && state.external_pending_puts == 0
+                && state.external_get.is_none()
+        );
+        state.begin_local_access_fence();
+        state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
+            item: item.clone(),
+            source: OwnerPreparedReclaimSource::UnindexedAllocation {
+                addr: *addr,
+                len: *len,
+            },
+            ssd_prepare_lock: Arc::new(tokio::sync::AMutex::new(())),
+            ssd_prepare_complete: false,
+            ssd_backing: None,
+        }));
+        return item_resp(
+            item,
+            OwnerReclaimItemState::Prepared,
+            "master-owned Allocation source fenced",
+        );
+    }
     let Some((_key, cached_info)) = inner.get_cached_info.remove_if(&item.key, |_, cached| {
         cached.put_time_ms == item.put_id.0
             && cached.put_version == item.put_id.1
@@ -223,8 +291,13 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
     state.begin_local_access_fence();
     state.reclaim = Some(OwnerReclaimRecord::Prepared(OwnerPreparedReclaim {
         item: item.clone(),
-        cached_info,
-        local_snapshot,
+        source: OwnerPreparedReclaimSource::Indexed {
+            cached_info,
+            local_snapshot,
+        },
+        ssd_prepare_lock: Arc::new(tokio::sync::AMutex::new(())),
+        ssd_prepare_complete: false,
+        ssd_backing: None,
     }));
     item_resp(
         item,
@@ -233,45 +306,227 @@ fn prepare_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclai
     )
 }
 
-fn release_prepared_backing_now(inner: &ClientKvApiInner, prepared: OwnerPreparedReclaim) {
-    let mut memory_info = Arc::try_unwrap(prepared.cached_info.mem_holder).unwrap_or_else(|_| {
-        panic!(
-            "owner reclaim prepared memory unexpectedly gained a holder: key={} epoch={}",
-            prepared.item.key, prepared.item.epoch
-        )
-    });
-    match &prepared.item.backing {
-        OwnerReclaimBacking::Allocation => {
-            assert!(
-                memory_info.local_reserve_resident_slot_ref().is_none(),
-                "allocation reclaim must not carry a local-reserve slot"
-            );
+/// Persist one bounded master-capacity batch while every exact source remains
+/// fenced. Per-key async locks make an overlapping RPC replay join the first
+/// attempt. The storage layer then admits the whole batch without queueing,
+/// inserts every independent generation, and executes one durability barrier.
+async fn persist_prepared_reclaim_batch_to_ssd(
+    inner: &ClientKvApiInner,
+    items: &[OwnerReclaimItem],
+) -> Vec<Option<u64>> {
+    let mut backing_lens = vec![None; items.len()];
+    if items.is_empty() || inner.ssd_storage.is_none() {
+        return backing_lens;
+    }
+
+    let mut prepare_locks = Vec::new();
+    for (index, item) in items.iter().enumerate() {
+        if item.reason != OwnerReclaimReason::MasterAllocationCapacity {
+            continue;
         }
-        OwnerReclaimBacking::UnindexedAllocation => {
-            unreachable!("unindexed allocations must be reclaimed entirely on the master")
+        let controls = inner.owner_key_control.lock_key(&item.key);
+        let Some(OwnerReclaimRecord::Prepared(prepared)) = controls
+            .get(&item.key)
+            .and_then(|state| state.reclaim.as_ref())
+        else {
+            continue;
+        };
+        if prepared.item != *item {
+            continue;
         }
-        OwnerReclaimBacking::CommittedSlot {
-            grant_id,
-            slot_index,
-            slot_size,
-        } => {
-            let (actual_slot_size, actual_grant_id, actual_slot_index) = memory_info
-                .take_local_reserve_resident_slot_ref()
-                .expect("committed-slot reclaim must carry a local-reserve slot");
-            assert_eq!(actual_slot_size, *slot_size);
-            assert_eq!(actual_grant_id, *grant_id);
-            assert_eq!(actual_slot_index, *slot_index);
+        if prepared.ssd_prepare_complete {
+            backing_lens[index] = prepared.ssd_backing.as_ref().map(|backing| backing.len);
+            continue;
+        }
+        prepare_locks.push((item.key.clone(), index, prepared.ssd_prepare_lock.clone()));
+    }
+    prepare_locks.sort_by(|left, right| left.0.cmp(&right.0));
+    debug_assert!(
+        prepare_locks
+            .windows(2)
+            .all(|window| window[0].0 != window[1].0)
+    );
+    let mut prepare_guards = Vec::with_capacity(prepare_locks.len());
+    for (_, _, lock) in &prepare_locks {
+        prepare_guards.push(lock.clone().lock_owned().await);
+    }
+
+    let mut sources = Vec::new();
+    let mut source_indices = Vec::new();
+    let mut source_holders = Vec::new();
+    for (_, index, _) in &prepare_locks {
+        let item = &items[*index];
+        let controls = inner.owner_key_control.lock_key(&item.key);
+        let Some(OwnerReclaimRecord::Prepared(prepared)) = controls
+            .get(&item.key)
+            .and_then(|state| state.reclaim.as_ref())
+        else {
+            continue;
+        };
+        if prepared.item != *item {
+            continue;
+        }
+        if prepared.ssd_prepare_complete {
+            backing_lens[*index] = prepared.ssd_backing.as_ref().map(|backing| backing.len);
+            continue;
+        }
+        let (addr, len, holder) = match &prepared.source {
+            OwnerPreparedReclaimSource::Indexed { cached_info, .. } => {
+                let holder = cached_info.mem_holder.clone();
+                (holder.addr, u64::from(holder.len), Some(holder))
+            }
+            OwnerPreparedReclaimSource::UnindexedAllocation { addr, len } => (*addr, *len, None),
+        };
+        sources.push(crate::kv_ssd_storage::KvSsdPersistSource {
+            key: item.key.clone(),
+            put_id: item.put_id,
+            addr,
+            len,
+        });
+        source_indices.push(*index);
+        source_holders.push(holder);
+    }
+
+    let persisted = if sources.is_empty() {
+        Vec::new()
+    } else {
+        match inner.persist_local_kvs_to_ssd(&sources).await {
+            Ok(results) => results,
+            Err(err) => {
+                tracing::warn!(
+                    items = sources.len(),
+                    error = %err,
+                    "master-capacity SSD batch validation failed; continuing DRAM reclaim"
+                );
+                sources
+                    .iter()
+                    .map(|_| None)
+                    .collect::<Vec<_>>()
+                    .into_iter()
+                    .map(Ok)
+                    .collect()
+            }
+        }
+    };
+    drop(source_holders);
+
+    let mut discard = Vec::new();
+    for ((index, source), outcome) in source_indices
+        .into_iter()
+        .zip(sources.into_iter())
+        .zip(persisted.into_iter())
+    {
+        let item = &items[index];
+        let mut persist_guard = match outcome {
+            Ok(Some(guard)) => Some(guard),
+            Ok(None) => None,
+            Err(err) => {
+                tracing::warn!(
+                    key = item.key,
+                    put_time_ms = item.put_id.0,
+                    put_version = item.put_id.1,
+                    epoch = item.epoch,
+                    len = source.len,
+                    error = %err,
+                    "master-capacity victim SSD write-back failed; continuing DRAM reclaim"
+                );
+                None
+            }
+        };
+        let attached = {
+            let mut controls = inner.owner_key_control.lock_key(&item.key);
+            match controls
+                .get_mut(&item.key)
+                .and_then(|state| state.reclaim.as_mut())
+            {
+                Some(OwnerReclaimRecord::Prepared(prepared)) if prepared.item == *item => {
+                    if prepared.ssd_prepare_complete {
+                        Some(prepared.ssd_backing.as_ref().map(|backing| backing.len))
+                    } else {
+                        prepared.ssd_prepare_complete = true;
+                        if let Some(guard) = persist_guard.take() {
+                            prepared.ssd_backing = Some(OwnerPreparedSsdBacking {
+                                len: source.len,
+                                _persist_guard: guard,
+                            });
+                            Some(Some(source.len))
+                        } else {
+                            Some(None)
+                        }
+                    }
+                }
+                _ => None,
+            }
+        };
+        match attached {
+            Some(len) => backing_lens[index] = len,
+            None => {
+                let should_discard = persist_guard.is_some();
+                drop(persist_guard);
+                if should_discard {
+                    discard.push((item.key.clone(), item.put_id));
+                }
+            }
+        }
+    }
+    drop(prepare_guards);
+    for (key, put_id) in discard {
+        inner.discard_local_ssd_replica(&key, put_id).await;
+    }
+    backing_lens
+}
 
-            inner
-                .owner_release_local_reserve_committed_resident_slot(
-                    actual_slot_size,
-                    actual_grant_id,
-                    actual_slot_index,
+fn release_prepared_backing_now(inner: &ClientKvApiInner, prepared: OwnerPreparedReclaim) {
+    match prepared.source {
+        OwnerPreparedReclaimSource::Indexed { cached_info, .. } => {
+            let mut memory_info = Arc::try_unwrap(cached_info.mem_holder).unwrap_or_else(|_| {
+                panic!(
+                    "owner reclaim prepared memory unexpectedly gained a holder: key={} epoch={}",
+                    prepared.item.key, prepared.item.epoch
                 )
-                .expect("owner reclaim committed resident slot release must succeed");
+            });
+            match &prepared.item.backing {
+                OwnerReclaimBacking::Allocation => {
+                    assert!(
+                        memory_info.local_reserve_resident_slot_ref().is_none(),
+                        "allocation reclaim must not carry a local-reserve slot"
+                    );
+                }
+                OwnerReclaimBacking::UnindexedAllocation { .. } => {
+                    unreachable!("indexed reclaim source cannot name an unindexed Allocation")
+                }
+                OwnerReclaimBacking::CommittedSlot {
+                    grant_id,
+                    slot_index,
+                    slot_size,
+                } => {
+                    let (actual_slot_size, actual_grant_id, actual_slot_index) = memory_info
+                        .take_local_reserve_resident_slot_ref()
+                        .expect("committed-slot reclaim must carry a local-reserve slot");
+                    assert_eq!(actual_slot_size, *slot_size);
+                    assert_eq!(actual_grant_id, *grant_id);
+                    assert_eq!(actual_slot_index, *slot_index);
+
+                    inner
+                        .owner_release_local_reserve_committed_resident_slot(
+                            actual_slot_size,
+                            actual_grant_id,
+                            actual_slot_index,
+                        )
+                        .expect("owner reclaim committed resident slot release must succeed");
+                }
+            }
+            drop(memory_info);
+        }
+        OwnerPreparedReclaimSource::UnindexedAllocation { .. } => {
+            assert!(matches!(
+                prepared.item.backing,
+                OwnerReclaimBacking::UnindexedAllocation { .. }
+            ));
+            // The master route still owns the Allocation. It is removed only after this Commit
+            // response, which releases the physical bytes on the master side.
         }
     }
-    drop(memory_info);
 }
 
 fn reclaim_release_fence_is_intact(
@@ -287,6 +542,7 @@ fn reclaim_release_fence_is_intact(
     ) && state.local_puts == 0
         && state.external_pending_puts == 0
         && state.remote_put.is_none()
+        && state.local_ssd_put.is_none()
         && state.source_eviction_selection.is_none()
         && state.local_access_fence.is_some()
 }
@@ -419,75 +675,118 @@ mod tests {
     }
 }
 
-fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
+struct AbortOneResult {
+    response: OwnerReclaimItemResp,
+    discard_ssd: bool,
+}
+
+fn abort_one_fenced(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> AbortOneResult {
     let mut controls = inner.owner_key_control.lock_key(&item.key);
     let Some(state) = controls.get_mut(&item.key) else {
-        return item_resp(
-            item,
-            OwnerReclaimItemState::Aborted,
-            "owner reclaim was already absent",
-        );
+        return AbortOneResult {
+            response: item_resp(
+                item,
+                OwnerReclaimItemState::Aborted,
+                "owner reclaim was already absent",
+            ),
+            discard_ssd: false,
+        };
     };
     let Some(record) = state.reclaim.take() else {
-        return item_resp(
-            item,
-            OwnerReclaimItemState::Aborted,
-            "owner reclaim was already absent",
-        );
+        return AbortOneResult {
+            response: item_resp(
+                item,
+                OwnerReclaimItemState::Aborted,
+                "owner reclaim was already absent",
+            ),
+            discard_ssd: false,
+        };
     };
     match record {
         OwnerReclaimRecord::Prepared(prepared) if prepared.item == *item => {
-            let replaced = inner
-                .get_cached_info
-                .insert(item.key.clone(), prepared.cached_info);
-            assert!(
-                replaced.is_none(),
-                "owner reclaim abort must restore an empty local index slot"
-            );
-            if let Some(snapshot) = prepared.local_snapshot {
-                let replaced = inner.local_snapshot_info.insert(item.key.clone(), snapshot);
-                assert!(
-                    replaced.is_none(),
-                    "owner reclaim abort must restore an empty local snapshot slot"
-                );
-            }
+            let OwnerPreparedReclaim {
+                source,
+                ssd_backing,
+                ..
+            } = prepared;
+            let detail = match source {
+                OwnerPreparedReclaimSource::Indexed {
+                    cached_info,
+                    local_snapshot,
+                } => {
+                    let replaced = inner.get_cached_info.insert(item.key.clone(), cached_info);
+                    assert!(
+                        replaced.is_none(),
+                        "owner reclaim abort must restore an empty local index slot"
+                    );
+                    if let Some(snapshot) = local_snapshot {
+                        let replaced = inner.local_snapshot_info.insert(item.key.clone(), snapshot);
+                        assert!(
+                            replaced.is_none(),
+                            "owner reclaim abort must restore an empty local snapshot slot"
+                        );
+                    }
+                    "owner local index fence rolled back"
+                }
+                OwnerPreparedReclaimSource::UnindexedAllocation { .. } => {
+                    "master-owned Allocation source fence rolled back"
+                }
+            };
             state.finish_local_access_fence();
             if state.is_idle() {
                 controls.remove(&item.key);
             }
-            item_resp(
-                item,
-                OwnerReclaimItemState::Aborted,
-                "owner local index fence rolled back",
-            )
+            AbortOneResult {
+                response: item_resp(item, OwnerReclaimItemState::Aborted, detail),
+                discard_ssd: ssd_backing.is_some(),
+            }
         }
         OwnerReclaimRecord::Releasing(releasing) if releasing == *item => {
             state.reclaim = Some(OwnerReclaimRecord::Releasing(releasing));
-            item_resp(
-                item,
-                OwnerReclaimItemState::Busy,
-                "owner slot release is already in progress and cannot be aborted",
-            )
+            AbortOneResult {
+                response: item_resp(
+                    item,
+                    OwnerReclaimItemState::Busy,
+                    "owner slot release is already in progress and cannot be aborted",
+                ),
+                discard_ssd: false,
+            }
         }
         OwnerReclaimRecord::Committed(committed) if committed == *item => {
             state.reclaim = Some(OwnerReclaimRecord::Committed(committed));
-            item_resp(
-                item,
-                OwnerReclaimItemState::Committed,
-                "owner slot was already committed and cannot be restored",
-            )
+            AbortOneResult {
+                response: item_resp(
+                    item,
+                    OwnerReclaimItemState::Committed,
+                    "owner slot was already committed and cannot be restored",
+                ),
+                discard_ssd: false,
+            }
         }
         other => {
             state.reclaim = Some(other);
-            item_resp(
-                item,
-                OwnerReclaimItemState::Stale,
-                "owner reclaim epoch or slot identity changed",
-            )
+            AbortOneResult {
+                response: item_resp(
+                    item,
+                    OwnerReclaimItemState::Stale,
+                    "owner reclaim epoch or slot identity changed",
+                ),
+                discard_ssd: false,
+            }
         }
     }
 }
 
+async fn abort_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
+    let outcome = abort_one_fenced(inner, item);
+    if outcome.discard_ssd {
+        inner
+            .discard_local_ssd_replica(&item.key, item.put_id)
+            .await;
+    }
+    outcome.response
+}
+
 fn finalize_one(inner: &ClientKvApiInner, item: &OwnerReclaimItem) -> OwnerReclaimItemResp {
     let mut controls = inner.owner_key_control.lock_key(&item.key);
     let Some(state) = controls.get_mut(&item.key) else {
@@ -595,17 +894,55 @@ pub async fn handle_batch_owner_reclaim(
     }
     let inner = view.client_kv_api().inner();
     let phase = req.serialize_part.phase;
-    let items = req
-        .serialize_part
-        .items
-        .iter()
-        .map(|item| match phase {
-            OwnerReclaimPhase::Prepare => prepare_one(inner, item),
-            OwnerReclaimPhase::Commit => commit_one(inner, item),
-            OwnerReclaimPhase::Abort => abort_one(inner, item),
-            OwnerReclaimPhase::Finalize => finalize_one(inner, item),
-        })
-        .collect::<Vec<_>>();
+    let items = match phase {
+        OwnerReclaimPhase::Prepare => {
+            let mut responses = req
+                .serialize_part
+                .items
+                .iter()
+                .map(|item| prepare_one(inner, item))
+                .collect::<Vec<_>>();
+            let prepared_indices = responses
+                .iter()
+                .enumerate()
+                .filter_map(|(index, response)| {
+                    (response.state == OwnerReclaimItemState::Prepared).then_some(index)
+                })
+                .collect::<Vec<_>>();
+            for indices in prepared_indices.chunks(crate::kv_ssd_storage::MAX_PERSIST_BATCH_ITEMS) {
+                let batch = indices
+                    .iter()
+                    .map(|index| req.serialize_part.items[*index].clone())
+                    .collect::<Vec<_>>();
+                let persisted = persist_prepared_reclaim_batch_to_ssd(inner, &batch).await;
+                for (index, ssd_backing_len) in indices.iter().copied().zip(persisted) {
+                    responses[index].ssd_backing_len = ssd_backing_len;
+                }
+            }
+            responses
+        }
+        OwnerReclaimPhase::Commit => req
+            .serialize_part
+            .items
+            .iter()
+            .map(|item| commit_one(inner, item))
+            .collect(),
+        OwnerReclaimPhase::Abort => {
+            futures::future::join_all(
+                req.serialize_part
+                    .items
+                    .iter()
+                    .map(|item| abort_one(inner, item)),
+            )
+            .await
+        }
+        OwnerReclaimPhase::Finalize => req
+            .serialize_part
+            .items
+            .iter()
+            .map(|item| finalize_one(inner, item))
+            .collect(),
+    };
     let prepared = items
         .iter()
         .filter(|item| item.state == OwnerReclaimItemState::Prepared)
@@ -618,6 +955,14 @@ pub async fn handle_batch_owner_reclaim(
         .iter()
         .filter(|item| item.state == OwnerReclaimItemState::Finalized)
         .count();
+    let ssd_prepared = items
+        .iter()
+        .filter(|item| item.ssd_backing_len.is_some())
+        .count();
+    let ssd_prepared_bytes = items
+        .iter()
+        .filter_map(|item| item.ssd_backing_len)
+        .fold(0_u64, u64::saturating_add);
     let busy_or_stale = items
         .iter()
         .filter(|item| {
@@ -641,12 +986,14 @@ pub async fn handle_batch_owner_reclaim(
     let mut rejection_reason_counts = rejection_reason_counts.into_iter().collect::<Vec<_>>();
     rejection_reason_counts.sort_by(|a, b| a.0.cmp(&b.0));
     tracing::info!(
-        "owner reclaim phase completed: phase={:?} items={} prepared={} committed={} finalized={} busy_or_stale={} rejection_reasons={:?}",
+        "owner reclaim phase completed: phase={:?} items={} prepared={} committed={} finalized={} ssd_prepared={} ssd_prepared_bytes={} busy_or_stale={} rejection_reasons={:?}",
         phase,
         items.len(),
         prepared,
         committed,
         finalized,
+        ssd_prepared,
+        ssd_prepared_bytes,
         busy_or_stale,
         rejection_reason_counts
     );
diff --git a/fluxon_rs/fluxon_kv/src/cluster_manager/mod.rs b/fluxon_rs/fluxon_kv/src/cluster_manager/mod.rs
index 97a5758..b563d5a 100644
--- a/fluxon_rs/fluxon_kv/src/cluster_manager/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/cluster_manager/mod.rs
@@ -5,6 +5,8 @@ pub use fluxon_commu::{
     META_KEY_SHARED_STORAGE_NODE_ID, META_KEY_SHARED_STORAGE_NODE_START_TIME,
 };
 
+pub(crate) const META_KEY_KV_SSD_STORAGE: &str = "kv_ssd_storage";
+
 pub mod app_logic_ext;
 
 #[cfg(test)]
diff --git a/fluxon_rs/fluxon_kv/src/config.rs b/fluxon_rs/fluxon_kv/src/config.rs
index 0e12327..3634c63 100644
--- a/fluxon_rs/fluxon_kv/src/config.rs
+++ b/fluxon_rs/fluxon_kv/src/config.rs
@@ -97,6 +97,23 @@ pub enum SideTransferRole {
     Worker,
 }
 
+/// Experimental source ordering for an external planned Get when SSD routes
+/// are present. The default preserves the sealed r89 behavior so a new
+/// release does not silently change an existing baseline.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum SsdReadSourcePolicy {
+    /// Any memory source wins over any SSD source; within a tier a remote
+    /// source wins over the requester-local owner. This is the r89 order.
+    #[default]
+    LegacyRemoteFirst,
+    /// Treat SSD as a requester-local tier, never as a cross-node source.
+    /// The eligible order is local memory, local SSD, then remote memory.
+    /// A remote owner's SSD route is deliberately excluded rather than used
+    /// as a fallback.
+    LocalSsdOnlyFirst,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(deny_unknown_fields)]
 pub struct OwnerLocalReserveExpectedCapacity {
@@ -142,6 +159,8 @@ pub struct TestSpecConfig {
     pub short_circuit_put_payload_path: bool,
     #[serde(default)]
     pub skip_put_end_commit: bool,
+    #[serde(default)]
+    pub ssd_read_source_policy: SsdReadSourcePolicy,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub owner_local_reserve_soft_wait_timeout_ms: Option<u64>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -192,6 +211,7 @@ impl Default for TestSpecConfig {
             prefer_local_placement: false,
             short_circuit_put_payload_path: false,
             skip_put_end_commit: false,
+            ssd_read_source_policy: SsdReadSourcePolicy::default(),
             owner_local_reserve_soft_wait_timeout_ms: None,
             owner_local_reserve_hard_timeout_ms: None,
             owner_local_reserve_expected_capacity: None,
@@ -891,6 +911,19 @@ pub struct FluxonKvSpecYaml {
     pub share_mem_path: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub large_file_paths: Option<LargeFilePathsYaml>,
+    /// Optional per-owner SSD capacity. When present, it must contain one
+    /// value matching the single local `large_file_paths` root.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub large_limit_size: Option<YamlNullable<Vec<u64>>>,
+    /// Optional sustained SSD write admission rate. This is a load-shedding
+    /// limit, not a queue: owner-local victims beyond the available budget are
+    /// reclaimed without an SSD copy.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ssd_write_rate_limit_bytes_per_sec: Option<u64>,
+    /// Maximum immediately admissible SSD bytes. It must be paired with
+    /// `ssd_write_rate_limit_bytes_per_sec`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ssd_write_burst_bytes: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub p2p_listen_port: Option<u16>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -903,6 +936,13 @@ pub struct FluxonKvSpecYaml {
 #[serde(transparent)]
 pub struct LargeFilePathsYaml(pub Vec<String>);
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct KvSsdStorageConfig {
+    pub limit_bytes: u64,
+    pub write_rate_limit_bytes_per_sec: Option<u64>,
+    pub write_burst_bytes: Option<u64>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct RedisCompatConfigYaml {
@@ -1029,6 +1069,14 @@ impl LargeFilePaths {
             "fluxon fs disk cache",
         )
     }
+
+    pub fn kv_ssd_storage_root(&self, cluster_name: &str, instance_key: &str) -> KvResult<PathBuf> {
+        let relative_dir = PathBuf::from(format!(
+            "{cluster_name}_cluster_kv_ssd_storage/{}",
+            crate::kv_ssd_storage::safe_path_component(instance_key)
+        ));
+        self.resolve_preferred_root_subdir(&relative_dir, "kv ssd storage")
+    }
 }
 
 /// KV client backend types supported by the system
@@ -1051,6 +1099,7 @@ pub struct ClientConfig {
     pub fluxonkv_spec: FluxonKvSpec,
     pub share_mem_path: String,           // Mandatory shared bundle path
     pub large_file_paths: LargeFilePaths, // Mandatory large-file roots for logs and caches
+    pub ssd_storage: Option<KvSsdStorageConfig>,
     pub test_spec_config: TestSpecConfig,
 }
 
@@ -1398,6 +1447,13 @@ impl ClientConfigYaml {
                 }
                 .into_kverror());
             }
+            if self.fluxonkv_spec.large_limit_size.is_some() {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "fluxonkv_spec.large_limit_size is forbidden in zero-contribution mode"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
         }
 
         // Preserve historical behavior for configs that omit `protocol`, but allow
@@ -1576,6 +1632,81 @@ impl ClientConfigYaml {
             }
         };
 
+        let ssd_write_rate_limit_bytes_per_sec =
+            self.fluxonkv_spec.ssd_write_rate_limit_bytes_per_sec;
+        let ssd_write_burst_bytes = self.fluxonkv_spec.ssd_write_burst_bytes;
+        let write_limit = match (ssd_write_rate_limit_bytes_per_sec, ssd_write_burst_bytes) {
+            (None, None) => None,
+            (Some(rate), Some(burst)) if rate > 0 && burst > 0 => Some((rate, burst)),
+            (Some(_), Some(_)) => {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "fluxonkv_spec SSD write rate and burst must both be positive"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
+            _ => {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "fluxonkv_spec.ssd_write_rate_limit_bytes_per_sec and ssd_write_burst_bytes must be configured together"
+                        .to_string(),
+                }
+                .into_kverror());
+            }
+        };
+
+        let ssd_storage = if is_external {
+            if write_limit.is_some() {
+                return Err(ConfigError::InvalidClientConfig {
+                    detail: "SSD write admission is only valid on owner configs".to_string(),
+                }
+                .into_kverror());
+            }
+            None
+        } else {
+            match std::mem::take(&mut self.fluxonkv_spec.large_limit_size) {
+                None | Some(YamlNullable::Null) => {
+                    if write_limit.is_some() {
+                        return Err(ConfigError::InvalidClientConfig {
+                            detail: "SSD write admission requires fluxonkv_spec.large_limit_size"
+                                .to_string(),
+                        }
+                        .into_kverror());
+                    }
+                    None
+                }
+                Some(YamlNullable::Value(limits)) => {
+                    if large_file_paths.paths.len() != 1 || limits.len() != 1 {
+                        return Err(ConfigError::InvalidClientConfig {
+                            detail: format!(
+                                "SSD-enabled owners require exactly one local large_file_paths root and one large_limit_size value: roots={} limits={}",
+                                large_file_paths.paths.len(),
+                                limits.len()
+                            ),
+                        }
+                        .into_kverror());
+                    }
+                    let limit_bytes = limits[0];
+                    if limit_bytes < crate::kv_ssd_storage::MIN_CAPACITY_BYTES {
+                        return Err(ConfigError::InvalidClientConfig {
+                            detail: format!(
+                                "fluxonkv_spec.large_limit_size[0] must be at least {} bytes",
+                                crate::kv_ssd_storage::MIN_CAPACITY_BYTES
+                            ),
+                        }
+                        .into_kverror());
+                    }
+                    let (write_rate_limit_bytes_per_sec, write_burst_bytes) = write_limit
+                        .map(|(rate, burst)| (Some(rate), Some(burst)))
+                        .unwrap_or((None, None));
+                    Some(KvSsdStorageConfig {
+                        limit_bytes,
+                        write_rate_limit_bytes_per_sec,
+                        write_burst_bytes,
+                    })
+                }
+            }
+        };
+
         Ok(ClientConfig {
             cluster_name: fluxonkv_spec.cluster_name.clone(),
             etcd_addresses_raw,
@@ -1588,6 +1719,7 @@ impl ClientConfigYaml {
             fluxonkv_spec,
             share_mem_path,
             large_file_paths,
+            ssd_storage,
             test_spec_config,
         })
     }
@@ -2264,6 +2396,114 @@ fluxonkv_spec:
         );
     }
 
+    #[test]
+    fn owner_ssd_config_requires_one_local_root_and_one_capacity() {
+        let valid = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_ssd_owner
+contribute_to_cluster_pool_size:
+  dram: 16777216
+  vram: {}
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /mnt/nvme0/mjq_build/fluxon_config_ssd_share
+  large_file_paths: [/mnt/nvme0/mjq_build/fluxon_config_ssd_local]
+  large_limit_size: [67108864]
+  ssd_write_rate_limit_bytes_per_sec: 268435456
+  ssd_write_burst_bytes: 67108864
+  sub_cluster: rack-a
+"#,
+        )
+        .unwrap()
+        .verify()
+        .unwrap();
+        assert_eq!(
+            valid.ssd_storage.as_ref().map(|ssd| ssd.limit_bytes),
+            Some(crate::kv_ssd_storage::MIN_CAPACITY_BYTES)
+        );
+        assert_eq!(
+            valid
+                .ssd_storage
+                .as_ref()
+                .and_then(|ssd| ssd.write_rate_limit_bytes_per_sec),
+            Some(268435456)
+        );
+        assert_eq!(
+            valid
+                .ssd_storage
+                .as_ref()
+                .and_then(|ssd| ssd.write_burst_bytes),
+            Some(67108864)
+        );
+
+        let multiple_roots = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_ssd_owner
+contribute_to_cluster_pool_size:
+  dram: 16777216
+  vram: {}
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /mnt/nvme0/mjq_build/fluxon_config_ssd_share
+  large_file_paths:
+    - /mnt/nvme0/mjq_build/fluxon_config_ssd_local_a
+    - /mnt/nvme0/mjq_build/fluxon_config_ssd_local_b
+  large_limit_size: [67108864]
+  sub_cluster: rack-a
+"#,
+        )
+        .unwrap()
+        .verify()
+        .unwrap_err();
+        assert!(
+            multiple_roots
+                .to_string()
+                .contains("SSD-enabled owners require exactly one local large_file_paths root")
+        );
+
+        let too_small = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_ssd_owner
+contribute_to_cluster_pool_size:
+  dram: 16777216
+  vram: {}
+fluxonkv_spec:
+  etcd_addresses: ["127.0.0.1:2379"]
+  cluster_name: test_cluster
+  share_mem_path: /mnt/nvme0/mjq_build/fluxon_config_ssd_share
+  large_file_paths: [/mnt/nvme0/mjq_build/fluxon_config_ssd_local]
+  large_limit_size: [67108863]
+  sub_cluster: rack-a
+"#,
+        )
+        .unwrap()
+        .verify()
+        .unwrap_err();
+        assert!(too_small.to_string().contains("must be at least 67108864"));
+    }
+
+    #[test]
+    fn zero_contribution_rejects_owner_ssd_capacity() {
+        let cfg = ClientConfigYaml::from_str(
+            r#"
+instance_key: test_external
+fluxonkv_spec:
+  cluster_name: test_cluster
+  share_mem_path: /mnt/nvme0/mjq_build/fluxon_config_ssd_external
+  large_limit_size: [67108864]
+"#,
+        )
+        .unwrap();
+        assert!(
+            cfg.verify()
+                .unwrap_err()
+                .to_string()
+                .contains("large_limit_size is forbidden in zero-contribution mode")
+        );
+    }
+
     #[test]
     fn large_file_paths_prefers_first_usable_root() {
         let tempdir = new_test_dir("fluxon_large_paths_prefers_first_usable_root");
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs b/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
index ed9863e..e1d4162 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/external_client_test.rs
@@ -94,6 +94,7 @@ fn new_client_config(
         large_file_paths: LargeFilePaths {
             paths: vec![format!("{}_large", shm_path)],
         },
+        ssd_storage: None,
         test_spec_config: TestSpecConfig::default(),
     }
 }
@@ -136,6 +137,7 @@ fn new_zero_contribution_client_config(
         },
         share_mem_path: shm_path.to_string(),
         large_file_paths: LargeFilePaths { paths: Vec::new() },
+        ssd_storage: None,
         test_spec_config: TestSpecConfig::default(),
     }
 }
diff --git a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
index 5af3351..d984e05 100644
--- a/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/external_client_api/mod.rs
@@ -130,9 +130,13 @@ pub struct ExternalGpuGetStartResp {
 pub struct ExternalGetPlanResp {
     pub handle: u64,
     pub raw_prefix_hit_len: usize,
+    /// Prefix that can be executed by the mixed GPU path. CPU-backed sources
+    /// inside this prefix remain holder/H2D sources; only indices listed in
+    /// `gpu_remote_indices` consume GPU destinations.
     pub gpu_raw_prefix_hit_len: usize,
-    /// Original key positions that need remote GPU destinations. Owner-local
-    /// positions remain CPU-backed and are absent from this vector.
+    /// Original key positions that can bind remote GPU destinations. Local
+    /// DRAM, requester-local SSD, and other CPU-only positions remain
+    /// holder/H2D sources and are absent from this vector.
     pub gpu_remote_indices: Vec<usize>,
 }
 
@@ -177,27 +181,30 @@ fn external_get_plan_raw_prefixes_from_statuses(
     statuses: impl IntoIterator<Item = (bool, bool)>,
 ) -> (usize, usize) {
     let mut cpu_prefix = 0usize;
-    let mut gpu_prefix = 0usize;
-    let mut gpu_prefix_open = true;
-    for (hit, gpu_eligible) in statuses {
+    for (hit, _gpu_eligible) in statuses {
         if !hit {
             break;
         }
         cpu_prefix += 1;
-        if gpu_prefix_open && gpu_eligible {
-            gpu_prefix += 1;
-        } else {
-            gpu_prefix_open = false;
-        }
     }
-    (cpu_prefix, gpu_prefix)
+    // The GPU execution path is mixed: CPU-only sources are materialized as
+    // holders while later eligible remote-memory sources still bind GPU
+    // destinations. Therefore one CPU-only hit no longer truncates the plan.
+    (cpu_prefix, cpu_prefix)
 }
 
 #[derive(Clone, Debug)]
 enum ExternalGpuGetTerminal {
-    Completed,
-    Revoked { transfer_error: Option<String> },
-    Failed { detail: String },
+    Completed {
+        planned_cpu_items: Vec<ExternalBatchGetItemResp>,
+        planned_cpu_owner_start_time: Option<i64>,
+    },
+    Revoked {
+        transfer_error: Option<String>,
+    },
+    Failed {
+        detail: String,
+    },
 }
 
 #[derive(Clone, Debug)]
@@ -238,6 +245,7 @@ struct PendingExternalGpuGet {
     atomic_group_lens: Vec<usize>,
     value_ptrs: Vec<u64>,
     local_holders: Vec<(usize, Arc<ExternalMemHolder>)>,
+    planned_cpu_sources: Vec<(usize, String)>,
     cancel_requested: Arc<AtomicBool>,
     transfer_started_at: Instant,
     terminal_rx: watch::Receiver<Option<ExternalGpuGetTerminalEvent>>,
@@ -503,7 +511,7 @@ mod inline_external_get_start_tests {
         external_get_plan_raw_prefixes_from_statuses, external_gpu_transfer_plan_geometry_is_valid,
         inline_external_get_tail_holder_ids, observe_external_gpu_get_consume_timing,
         validate_external_local_holder_geometry, validate_inline_external_get_owner_generation,
-        validate_inline_external_get_start_plan,
+        validate_inline_external_get_start_plan, validate_mixed_planned_cpu_terminal,
     };
     use crate::client_kv_api::msg_pack::ExternalBatchGetItemResp;
     use crate::master_kv_router::msg_pack::{BatchGetPlanItemResp, BatchGetStartItemResp};
@@ -596,6 +604,29 @@ mod inline_external_get_start_tests {
         );
     }
 
+    #[test]
+    fn mixed_planned_cpu_terminal_requires_exact_owner_mapping() {
+        let items = vec![inline_hit(1), inline_hit(2)];
+        assert!(
+            validate_mixed_planned_cpu_terminal(&items, 2, Some(17), 17, 0x10_000, 0x10_000,)
+                .is_ok()
+        );
+        assert!(
+            validate_mixed_planned_cpu_terminal(&items, 1, Some(17), 17, 0x10_000, 0x10_000)
+                .is_err()
+        );
+        assert!(
+            validate_mixed_planned_cpu_terminal(&items, 2, None, 17, 0x10_000, 0x10_000).is_err()
+        );
+        assert!(
+            validate_mixed_planned_cpu_terminal(&items, 2, Some(16), 17, 0x10_000, 0x10_000,)
+                .is_err()
+        );
+        assert!(
+            validate_mixed_planned_cpu_terminal(&items, 2, Some(17), 17, 0x10_000, 4096).is_err()
+        );
+    }
+
     #[test]
     fn inline_partial_consume_returns_only_tail_holder_ids() {
         let items = vec![inline_hit(11), inline_hit(12), inline_hit(13)];
@@ -635,7 +666,7 @@ mod inline_external_get_start_tests {
     }
 
     #[test]
-    fn gpu_prefix_stops_without_shortening_the_cpu_plan() {
+    fn mixed_gpu_prefix_keeps_cpu_only_sources_and_later_gpu_sources() {
         let items = vec![
             BatchGetPlanItemResp {
                 error_code: OK,
@@ -653,7 +684,7 @@ mod inline_external_get_start_tests {
                 ..Default::default()
             },
         ];
-        assert_eq!(external_get_plan_raw_prefixes(&items), (3, 1));
+        assert_eq!(external_get_plan_raw_prefixes(&items), (3, 3));
     }
 
     #[test]
@@ -668,15 +699,15 @@ mod inline_external_get_start_tests {
             ]),
             (3, 3)
         );
-        // A remote source that cannot bind a GPU sink stops only the mixed
-        // GPU prefix; the CPU plan can still consume later local pages.
+        // A CPU-only source is materialized through the existing planned CPU
+        // holder path and does not hide a later GPU-eligible source.
         assert_eq!(
             external_get_plan_raw_prefixes_from_statuses([
                 (true, true),
                 (true, false),
                 (true, true),
             ]),
-            (3, 1)
+            (3, 3)
         );
         assert_eq!(
             external_get_plan_raw_prefixes_from_statuses([
@@ -1220,9 +1251,17 @@ fn release_planned_cpu_response_holders(
     inner: &ExternalInner,
     response: &ExternalExecutePlannedGetResp,
     owner_start_time: i64,
+) {
+    release_planned_cpu_item_holders(inner, &response.items, owner_start_time);
+}
+
+fn release_planned_cpu_item_holders(
+    inner: &ExternalInner,
+    items: &[ExternalBatchGetItemResp],
+    owner_start_time: i64,
 ) {
     let external_client_id = inner.view.cluster_manager().get_self_info().id;
-    for holder_id in response.items.iter().filter_map(|item| {
+    for holder_id in items.iter().filter_map(|item| {
         item.external_memholder_info
             .as_ref()
             .map(|info| info.holder_id)
@@ -1241,6 +1280,84 @@ fn release_planned_cpu_response_holders(
     }
 }
 
+fn release_optional_planned_cpu_item_holders(
+    inner: &ExternalInner,
+    items: &[ExternalBatchGetItemResp],
+    owner_start_time: Option<i64>,
+) {
+    if items.is_empty() {
+        return;
+    }
+    let Some(owner_start_time) = owner_start_time else {
+        tracing::error!(
+            items = items.len(),
+            "mixed Get terminal lost the owner generation needed to release CPU holders"
+        );
+        return;
+    };
+    release_planned_cpu_item_holders(inner, items, owner_start_time);
+}
+
+fn validate_mixed_planned_cpu_terminal(
+    items: &[ExternalBatchGetItemResp],
+    expected_items: usize,
+    owner_start_time: Option<i64>,
+    current_owner_start_time: i64,
+    base_ptr: u64,
+    mapped_len: u64,
+) -> KvResult<i64> {
+    if items.len() != expected_items {
+        return Err(KvError::Api(ApiError::Unknown {
+            detail: format!(
+                "mixed Get planned CPU terminal length mismatch: expected={} got={}",
+                expected_items,
+                items.len()
+            ),
+        }));
+    }
+    let owner_start_time = owner_start_time.ok_or_else(|| {
+        KvError::Api(ApiError::Unknown {
+            detail: "mixed Get planned CPU terminal omitted its owner generation".to_string(),
+        })
+    })?;
+    validate_inline_external_get_owner_generation(owner_start_time, current_owner_start_time)?;
+    for (index, item) in items.iter().enumerate() {
+        if item.error_code != OK {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "mixed Get planned CPU item failed: index={} error_code={} error_json={}",
+                    index, item.error_code, item.error_json
+                ),
+            }));
+        }
+        let Some(info) = item.external_memholder_info.as_ref() else {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!("mixed Get planned CPU item has no holder: index={index}"),
+            }));
+        };
+        let end = info
+            .offset
+            .checked_add(u64::from(info.len))
+            .ok_or_else(|| {
+                KvError::Api(ApiError::Unknown {
+                    detail: format!(
+                        "mixed Get planned CPU holder range overflow: index={} offset={} len={}",
+                        index, info.offset, info.len
+                    ),
+                })
+            })?;
+        if end > mapped_len || base_ptr.checked_add(info.offset).is_none() {
+            return Err(KvError::Api(ApiError::Unknown {
+                detail: format!(
+                    "mixed Get planned CPU holder is outside owner mapping: index={} end={} mapped_len={} base={:#x} offset={}",
+                    index, end, mapped_len, base_ptr, info.offset
+                ),
+            }));
+        }
+    }
+    Ok(owner_start_time)
+}
+
 fn spawn_uncertain_planned_cpu_get_cleanup(
     view: ExternalClientApiView,
     owner: String,
@@ -1528,7 +1645,10 @@ async fn run_external_gpu_get_transfer(
         .master_batch_gpu_get_done(transfer_get_ids)
         .await
     {
-        Ok(()) => ExternalGpuGetTerminal::Completed,
+        Ok(()) => ExternalGpuGetTerminal::Completed {
+            planned_cpu_items: Vec::new(),
+            planned_cpu_owner_start_time: None,
+        },
         Err(err) => ExternalGpuGetTerminal::Failed {
             detail: format!("GPU Get BatchDone failed: {err}"),
         },
@@ -1556,6 +1676,104 @@ async fn run_external_gpu_get_transfer_timed(
     }
 }
 
+async fn run_external_mixed_gpu_get_transfer_timed(
+    view: ExternalClientApiView,
+    plan_handle: u64,
+    gpu_transfer_items: Vec<(BatchGetStartItemResp, GpuMemoryGuard)>,
+    planned_cpu_items: Vec<(String, u64)>,
+    skipped_get_ids: Vec<u64>,
+    transfer_concurrency: usize,
+    cancel_requested: Arc<AtomicBool>,
+) -> ExternalGpuGetTerminalEvent {
+    if planned_cpu_items.is_empty() {
+        return run_external_gpu_get_transfer_timed(
+            view,
+            gpu_transfer_items,
+            skipped_get_ids,
+            transfer_concurrency,
+            cancel_requested,
+        )
+        .await;
+    }
+
+    // The GPU branch owns tail Revoke. The planned CPU branch receives an
+    // empty tail so every master operation identity is finalized exactly
+    // once while both source classes still execute concurrently.
+    let gpu_future = run_external_gpu_get_transfer(
+        view.clone(),
+        gpu_transfer_items,
+        skipped_get_ids,
+        transfer_concurrency,
+        cancel_requested.clone(),
+    );
+    let cpu_future = run_external_planned_cpu_get(
+        view.clone(),
+        plan_handle,
+        planned_cpu_items,
+        Vec::new(),
+        transfer_concurrency,
+        cancel_requested,
+    );
+    let (gpu_terminal, cpu_terminal) = futures::future::join(gpu_future, cpu_future).await;
+
+    let outcome = match (gpu_terminal, cpu_terminal) {
+        (
+            ExternalGpuGetTerminal::Completed { .. },
+            ExternalPlannedCpuGetTerminal::Completed {
+                items,
+                owner_start_time,
+            },
+        ) => ExternalGpuGetTerminal::Completed {
+            planned_cpu_items: items,
+            planned_cpu_owner_start_time: Some(owner_start_time),
+        },
+        (gpu_terminal, cpu_terminal) => {
+            if let ExternalPlannedCpuGetTerminal::Completed {
+                items,
+                owner_start_time,
+            } = &cpu_terminal
+            {
+                release_planned_cpu_item_holders(
+                    view.external_client_api().inner(),
+                    items,
+                    *owner_start_time,
+                );
+            }
+            match (&gpu_terminal, &cpu_terminal) {
+                (
+                    ExternalGpuGetTerminal::Failed { detail: gpu_detail },
+                    ExternalPlannedCpuGetTerminal::Failed { detail: cpu_detail },
+                ) => ExternalGpuGetTerminal::Failed {
+                    detail: format!(
+                        "mixed Get GPU and CPU branches failed: gpu={gpu_detail}; cpu={cpu_detail}"
+                    ),
+                },
+                (ExternalGpuGetTerminal::Failed { detail }, _) => ExternalGpuGetTerminal::Failed {
+                    detail: format!("mixed Get GPU branch failed: {detail}"),
+                },
+                (_, ExternalPlannedCpuGetTerminal::Failed { detail }) => {
+                    ExternalGpuGetTerminal::Failed {
+                        detail: format!("mixed Get CPU branch failed: {detail}"),
+                    }
+                }
+                (ExternalGpuGetTerminal::Revoked { transfer_error }, _) => {
+                    ExternalGpuGetTerminal::Revoked {
+                        transfer_error: transfer_error.clone(),
+                    }
+                }
+                (_, ExternalPlannedCpuGetTerminal::Revoked) => ExternalGpuGetTerminal::Revoked {
+                    transfer_error: Some("mixed Get CPU branch was revoked".to_string()),
+                },
+                _ => unreachable!("mixed Get non-completed branches must fail or revoke"),
+            }
+        }
+    };
+    ExternalGpuGetTerminalEvent {
+        outcome,
+        terminal_at: Instant::now(),
+    }
+}
+
 impl ExternalClientApi {
     /// Access inner external-only API. Safe to unwrap in external role.
     pub fn inner(&self) -> &ExternalInner {
@@ -3660,8 +3878,11 @@ impl ExternalInner {
             .iter()
             .take(gpu_transferable_len)
             .enumerate()
-            .filter_map(|(index, item)| {
-                matches!(item, PendingExternalGetPlanItem::Remote { .. }).then_some(index)
+            .filter_map(|(index, item)| match item {
+                PendingExternalGetPlanItem::Remote { plan, .. } if plan.gpu_direct_eligible => {
+                    Some(index)
+                }
+                _ => None,
             })
             .collect::<Vec<_>>();
         self.pending_external_get_plan.insert(
@@ -3800,6 +4021,8 @@ impl ExternalInner {
             })
             .collect::<Vec<_>>();
         let mut remote_plans = Vec::with_capacity(destinations.len());
+        let mut planned_cpu_items = Vec::new();
+        let mut planned_cpu_sources = Vec::new();
         let mut local_holders = Vec::new();
         let mut value_ptrs = Vec::with_capacity(consume_prefix_len);
         let mut destination_index = 0usize;
@@ -3813,11 +4036,19 @@ impl ExternalInner {
                     value_ptrs.push(holder.addr);
                     local_holders.push((source_index, holder));
                 }
-                PendingExternalGetPlanItem::Remote { plan, .. } => {
-                    let destination = &destinations[destination_index];
-                    value_ptrs.push(destination.addr);
-                    remote_plans.push(plan);
-                    destination_index += 1;
+                PendingExternalGetPlanItem::Remote { key, plan } => {
+                    if plan.gpu_direct_eligible {
+                        let destination = &destinations[destination_index];
+                        value_ptrs.push(destination.addr);
+                        remote_plans.push(plan);
+                        destination_index += 1;
+                    } else {
+                        // Filled with the owner-mapped holder pointer after the
+                        // planned CPU branch reaches its terminal.
+                        value_ptrs.push(0);
+                        planned_cpu_sources.push((source_index, key.clone()));
+                        planned_cpu_items.push((key, plan.get_id));
+                    }
                 }
             }
         }
@@ -3895,6 +4126,7 @@ impl ExternalInner {
                 atomic_group_lens,
                 value_ptrs,
                 local_holders,
+                planned_cpu_sources,
                 cancel_requested: cancel_requested.clone(),
                 transfer_started_at,
                 terminal_rx,
@@ -3903,9 +4135,11 @@ impl ExternalInner {
         let view = self.view.clone_view();
         let task_view = view.clone();
         view.spawn(format!("external_gpu_get_execute_{handle}"), async move {
-            let terminal = run_external_gpu_get_transfer_timed(
+            let terminal = run_external_mixed_gpu_get_transfer_timed(
                 task_view,
+                handle,
                 transfer_items,
+                planned_cpu_items,
                 skipped_get_ids,
                 transfer_concurrency,
                 cancel_requested,
@@ -4213,6 +4447,7 @@ impl ExternalInner {
                     .map(|destination| destination.addr)
                     .collect(),
                 local_holders: Vec::new(),
+                planned_cpu_sources: Vec::new(),
                 cancel_requested: cancel_requested.clone(),
                 transfer_started_at,
                 terminal_rx,
@@ -4269,7 +4504,7 @@ impl ExternalInner {
                 }
             };
         let finish_wait = finish_wait_started_at.elapsed();
-        let pending = pending_guard.take();
+        let mut pending = pending_guard.take();
         let timing = observe_external_gpu_get_consume_timing(
             pending.transfer_started_at,
             terminal_event.terminal_at,
@@ -4277,15 +4512,24 @@ impl ExternalInner {
             finish_wait,
         );
         let outcome = match &terminal_event.outcome {
-            ExternalGpuGetTerminal::Completed => "completed",
+            ExternalGpuGetTerminal::Completed { .. } => "completed",
             ExternalGpuGetTerminal::Revoked { .. } => "revoked",
             ExternalGpuGetTerminal::Failed { .. } => "failed",
         };
+        let local_source_count = pending.local_holders.len();
+        let planned_cpu_source_count = pending.planned_cpu_sources.len();
+        let gpu_direct_source_count = pending
+            .transferable_len
+            .saturating_sub(local_source_count)
+            .saturating_sub(planned_cpu_source_count);
         tracing::info!(
-            "external GPU Get consume lifecycle: handle={} transferred={} consumed={} outcome={} transfer_wall_us={} terminal_before_consume={} terminal_to_consume_us={} finish_wait_us={}",
+            "external GPU Get consume lifecycle: handle={} transferred={} consumed={} local_sources={} planned_cpu_sources={} gpu_direct_sources={} outcome={} transfer_wall_us={} terminal_before_consume={} terminal_to_consume_us={} finish_wait_us={}",
             handle,
             pending.transferable_len,
             consumed_prefix_len,
+            local_source_count,
+            planned_cpu_source_count,
+            gpu_direct_source_count,
             outcome,
             timing.transfer_wall_us,
             timing.terminal_before_consume,
@@ -4293,17 +4537,159 @@ impl ExternalInner {
             timing.finish_wait_us,
         );
         match terminal_event.outcome {
-            ExternalGpuGetTerminal::Completed => {
+            ExternalGpuGetTerminal::Completed {
+                planned_cpu_items,
+                planned_cpu_owner_start_time,
+            } => {
                 assert_eq!(pending.value_ptrs.len(), pending.transferable_len);
-                if !pending.local_holders.is_empty() {
-                    let (_, current_owner_start_time, _, base_ptr, mapped_len) =
-                        self.wait_current_owner_mapped_range().await?;
-                    validate_external_local_holders_mapping(
+                let planned_cpu_sources = std::mem::take(&mut pending.planned_cpu_sources);
+                let cpu_terminal_shape_is_valid = planned_cpu_sources.len()
+                    == planned_cpu_items.len()
+                    && planned_cpu_sources.iter().enumerate().all(
+                        |(source_order, (source_index, _))| {
+                            *source_index < pending.value_ptrs.len()
+                                && pending.value_ptrs[*source_index] == 0
+                                && source_order.checked_sub(1).is_none_or(|previous_order| {
+                                    planned_cpu_sources[previous_order].0 < *source_index
+                                })
+                        },
+                    );
+                if !cpu_terminal_shape_is_valid {
+                    release_optional_planned_cpu_item_holders(
+                        self,
+                        &planned_cpu_items,
+                        planned_cpu_owner_start_time,
+                    );
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "mixed Get CPU source/terminal shape mismatch: sources={} items={} values={}",
+                            planned_cpu_sources.len(),
+                            planned_cpu_items.len(),
+                            pending.value_ptrs.len()
+                        ),
+                    }));
+                }
+
+                let needs_owner_mapping =
+                    !pending.local_holders.is_empty() || !planned_cpu_sources.is_empty();
+                let owner_mapping = if needs_owner_mapping {
+                    match self.wait_current_owner_mapped_range().await {
+                        Ok(mapping) => Some(mapping),
+                        Err(err) => {
+                            release_optional_planned_cpu_item_holders(
+                                self,
+                                &planned_cpu_items,
+                                planned_cpu_owner_start_time,
+                            );
+                            return Err(err);
+                        }
+                    }
+                } else {
+                    None
+                };
+                if let Some((_, current_owner_start_time, _, base_ptr, mapped_len)) = owner_mapping
+                {
+                    if let Err(err) = validate_external_local_holders_mapping(
                         &pending.local_holders,
                         current_owner_start_time,
                         base_ptr,
                         mapped_len,
-                    )?;
+                    ) {
+                        release_optional_planned_cpu_item_holders(
+                            self,
+                            &planned_cpu_items,
+                            planned_cpu_owner_start_time,
+                        );
+                        return Err(err);
+                    }
+                    if !planned_cpu_sources.is_empty() {
+                        let owner_start_time = match validate_mixed_planned_cpu_terminal(
+                            &planned_cpu_items,
+                            planned_cpu_sources.len(),
+                            planned_cpu_owner_start_time,
+                            current_owner_start_time,
+                            base_ptr,
+                            mapped_len,
+                        ) {
+                            Ok(owner_start_time) => owner_start_time,
+                            Err(err) => {
+                                release_optional_planned_cpu_item_holders(
+                                    self,
+                                    &planned_cpu_items,
+                                    planned_cpu_owner_start_time,
+                                );
+                                return Err(err);
+                            }
+                        };
+                        for ((source_index, _), item) in
+                            planned_cpu_sources.iter().zip(&planned_cpu_items)
+                        {
+                            if *source_index >= consumed_prefix_len {
+                                let info = item
+                                    .external_memholder_info
+                                    .as_ref()
+                                    .expect("validated mixed CPU item must have a holder");
+                                if let Err(detail) = self.enqueue_external_delete_ack(
+                                    self.view.cluster_manager().get_self_info().id.clone(),
+                                    info.holder_id,
+                                    owner_start_time,
+                                ) {
+                                    release_optional_planned_cpu_item_holders(
+                                        self,
+                                        &planned_cpu_items,
+                                        planned_cpu_owner_start_time,
+                                    );
+                                    return Err(KvError::Api(ApiError::Unknown { detail }));
+                                }
+                            }
+                        }
+                        let external_client_id =
+                            self.view.cluster_manager().get_self_info().id.clone();
+                        for ((source_index, key), item) in planned_cpu_sources
+                            .into_iter()
+                            .zip(planned_cpu_items.iter())
+                            .take_while(|((source_index, _), _)| {
+                                *source_index < consumed_prefix_len
+                            })
+                        {
+                            let info = item
+                                .external_memholder_info
+                                .as_ref()
+                                .expect("validated mixed CPU item must have a holder");
+                            let holder_ptr = base_ptr
+                                .checked_add(info.offset)
+                                .expect("validated mixed CPU holder pointer must not overflow");
+                            let holder = Arc::new(ExternalMemHolder::new(
+                                info.offset,
+                                holder_ptr,
+                                info.len,
+                                info.holder_id,
+                                key.clone(),
+                                external_client_id.clone(),
+                                self.view.clone(),
+                                owner_start_time,
+                            ));
+                            pending.value_ptrs[source_index] = holder_ptr;
+                            self.key_weak_memholder_index
+                                .insert(key, Arc::downgrade(&holder));
+                            pending.local_holders.push((source_index, holder));
+                        }
+                    }
+                }
+                if let Some(index) = pending.value_ptrs[..consumed_prefix_len]
+                    .iter()
+                    .position(|pointer| *pointer == 0)
+                {
+                    release_optional_planned_cpu_item_holders(
+                        self,
+                        &planned_cpu_items,
+                        planned_cpu_owner_start_time,
+                    );
+                    return Err(KvError::Api(ApiError::Unknown {
+                        detail: format!(
+                            "mixed Get left a consumed source pointer unresolved: index={index}"
+                        ),
+                    }));
                 }
                 let bandwidth_handle = self
                     .view
@@ -4354,7 +4740,18 @@ impl ExternalInner {
             .await?
             .outcome
         {
-            ExternalGpuGetTerminal::Completed | ExternalGpuGetTerminal::Revoked { .. } => Ok(()),
+            ExternalGpuGetTerminal::Completed {
+                planned_cpu_items,
+                planned_cpu_owner_start_time,
+            } => {
+                release_optional_planned_cpu_item_holders(
+                    self,
+                    &planned_cpu_items,
+                    planned_cpu_owner_start_time,
+                );
+                Ok(())
+            }
+            ExternalGpuGetTerminal::Revoked { .. } => Ok(()),
             ExternalGpuGetTerminal::Failed { detail } => {
                 Err(KvError::Api(ApiError::Unknown { detail }))
             }
diff --git a/fluxon_rs/fluxon_kv/src/kv_ssd_storage.rs b/fluxon_rs/fluxon_kv/src/kv_ssd_storage.rs
new file mode 100644
index 0000000..d5875a2
--- /dev/null
+++ b/fluxon_rs/fluxon_kv/src/kv_ssd_storage.rs
@@ -0,0 +1,1360 @@
+use crate::master_kv_router::put::PutIDForAKey;
+use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult};
+use ::tokio::sync::{Mutex as AsyncMutex, OwnedMutexGuard};
+use foyer::{
+    BlockEngineConfig, DeviceBuilder, FsDeviceBuilder, HybridCache, HybridCacheBuilder,
+    HybridCacheEntry, HybridCachePolicy, PsyncIoEngineConfig, Source,
+};
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{
+    Arc,
+    atomic::{AtomicU64, Ordering},
+};
+use std::time::Instant;
+
+const MEMORY_CAPACITY_BYTES: usize = 1;
+const MEMORY_SHARDS: usize = 1;
+const BLOCK_SIZE_BYTES: usize = 64 * 1024 * 1024;
+const FLUSH_BUFFER_BYTES: usize = BLOCK_SIZE_BYTES;
+const SUBMIT_QUEUE_BYTES: usize = 2 * FLUSH_BUFFER_BYTES;
+// Thirteen workload-sized values (13 * 4.5 MiB) fit below one 64 MiB block.
+// This is an I/O aggregation bound only; every entry keeps an independent
+// single-KV generation and result.
+pub(crate) const MAX_PERSIST_BATCH_ITEMS: usize = 13;
+pub const MIN_CAPACITY_BYTES: u64 = BLOCK_SIZE_BYTES as u64;
+
+pub fn safe_path_component(raw: &str) -> String {
+    format!("v1-{}", hex::encode(Sha256::digest(raw.as_bytes())))
+}
+
+#[derive(Clone, Debug)]
+pub struct KvSsdStorageRootLimit {
+    pub root_dir: PathBuf,
+    pub limit_bytes: u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct KvSsdStorageInit {
+    pub roots: Vec<KvSsdStorageRootLimit>,
+    pub write_rate_limit_bytes_per_sec: Option<u64>,
+    pub write_burst_bytes: Option<u64>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct KvSsdStorageDeviceUsage {
+    pub device: String,
+    pub capacity_bytes: u64,
+    pub used_bytes: u64,
+    pub persist_requests: u64,
+    pub persist_successes: u64,
+    pub persist_failures: u64,
+    pub persist_bytes: u64,
+    pub persist_duration_us: u64,
+    pub persist_batch_requests: u64,
+    pub persist_batch_items: u64,
+    pub persist_flush_batches: u64,
+    pub persist_busy_batches: u64,
+    pub persist_admission_skips: u64,
+    pub persist_batch_duration_us: u64,
+    pub write_candidate_items: u64,
+    pub write_candidate_bytes: u64,
+    pub write_admitted_items: u64,
+    pub write_admitted_bytes: u64,
+    pub write_dropped_items: u64,
+    pub write_dropped_bytes: u64,
+    pub write_refunded_items: u64,
+    pub write_refunded_bytes: u64,
+    pub load_requests: u64,
+    pub load_successes: u64,
+    pub load_misses: u64,
+    pub load_failures: u64,
+    pub load_bytes: u64,
+    pub load_duration_us: u64,
+    pub memory_hits: u64,
+    pub disk_hits: u64,
+    pub outer_hits: u64,
+    pub removals: u64,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
+struct KvSsdKey {
+    key: String,
+    put_id: PutIDForAKey,
+}
+
+#[derive(Debug)]
+struct WriteRateLimiter {
+    rate_bytes_per_sec: u64,
+    burst_bytes: u64,
+    available_bytes: u64,
+    refill_remainder: u128,
+    last_refill: Instant,
+}
+
+impl WriteRateLimiter {
+    fn new(rate_bytes_per_sec: u64, burst_bytes: u64) -> Self {
+        Self {
+            rate_bytes_per_sec,
+            burst_bytes,
+            available_bytes: burst_bytes,
+            refill_remainder: 0,
+            last_refill: Instant::now(),
+        }
+    }
+
+    fn refill(&mut self, now: Instant) {
+        let elapsed_ns = now.duration_since(self.last_refill).as_nanos();
+        self.last_refill = now;
+        if self.available_bytes == self.burst_bytes {
+            self.refill_remainder = 0;
+            return;
+        }
+        let scaled = elapsed_ns
+            .saturating_mul(u128::from(self.rate_bytes_per_sec))
+            .saturating_add(self.refill_remainder);
+        let refill = scaled / 1_000_000_000u128;
+        self.refill_remainder = scaled % 1_000_000_000u128;
+        let refill = u64::try_from(refill).unwrap_or(u64::MAX);
+        self.available_bytes = self
+            .available_bytes
+            .saturating_add(refill)
+            .min(self.burst_bytes);
+        if self.available_bytes == self.burst_bytes {
+            self.refill_remainder = 0;
+        }
+    }
+
+    fn try_consume(&mut self, bytes: u64, now: Instant) -> bool {
+        self.refill(now);
+        if bytes > self.available_bytes {
+            return false;
+        }
+        self.available_bytes -= bytes;
+        true
+    }
+}
+
+type SsdEntry = HybridCacheEntry<KvSsdKey, Vec<u8>>;
+
+/// Pins a just-persisted entry until the master has published its SSD backing.
+pub(crate) struct KvSsdPersistGuard {
+    _entry: Option<SsdEntry>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct KvSsdPersistSource {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub addr: u64,
+    pub len: u64,
+}
+
+pub(crate) struct KvSsdPersistCopy {
+    key: String,
+    put_id: PutIDForAKey,
+    data: Vec<u8>,
+}
+
+impl KvSsdPersistCopy {
+    fn len(&self) -> u64 {
+        u64::try_from(self.data.len()).unwrap_or(u64::MAX)
+    }
+}
+
+pub(crate) struct KvSsdPersistBatchPermit {
+    _guard: OwnedMutexGuard<()>,
+}
+
+/// The only owner-local SSD store used by Fluxon KV.
+///
+/// DRAM ownership, distributed routing, and Put/Get terminal state remain in
+/// their existing modules. This type only persists and materializes bytes for
+/// one `(key, put_id)` generation.
+#[derive(Debug)]
+pub struct KvSsdStorage {
+    cache: HybridCache<KvSsdKey, Vec<u8>>,
+    root_dir: PathBuf,
+    capacity_bytes: u64,
+    write_rate_limiter: Option<Mutex<WriteRateLimiter>>,
+    // Exactly one admitted write batch may own Foyer's global durability
+    // barrier. New unrelated pressure batches use try_lock and fail open to
+    // ordinary DRAM reclaim instead of becoming SSD backlog.
+    persist_batch_gate: Arc<AsyncMutex<()>>,
+    entry_lengths: Mutex<HashMap<KvSsdKey, u64>>,
+    logical_used_bytes: AtomicU64,
+    persist_requests: AtomicU64,
+    persist_successes: AtomicU64,
+    persist_failures: AtomicU64,
+    persist_bytes: AtomicU64,
+    persist_duration_us: AtomicU64,
+    persist_batch_requests: AtomicU64,
+    persist_batch_items: AtomicU64,
+    persist_flush_batches: AtomicU64,
+    persist_busy_batches: AtomicU64,
+    persist_admission_skips: AtomicU64,
+    persist_batch_duration_us: AtomicU64,
+    write_candidate_items: AtomicU64,
+    write_candidate_bytes: AtomicU64,
+    write_admitted_items: AtomicU64,
+    write_admitted_bytes: AtomicU64,
+    write_dropped_items: AtomicU64,
+    write_dropped_bytes: AtomicU64,
+    write_refunded_items: AtomicU64,
+    write_refunded_bytes: AtomicU64,
+    load_requests: AtomicU64,
+    load_successes: AtomicU64,
+    load_misses: AtomicU64,
+    load_failures: AtomicU64,
+    load_bytes: AtomicU64,
+    load_duration_us: AtomicU64,
+    memory_hits: AtomicU64,
+    disk_hits: AtomicU64,
+    outer_hits: AtomicU64,
+    removals: AtomicU64,
+}
+
+impl KvSsdStorage {
+    pub async fn new(init: KvSsdStorageInit) -> KvResult<Self> {
+        let write_rate_limiter = match (init.write_rate_limit_bytes_per_sec, init.write_burst_bytes)
+        {
+            (None, None) => None,
+            (Some(rate), Some(burst)) if rate > 0 && burst > 0 => {
+                Some(Mutex::new(WriteRateLimiter::new(rate, burst)))
+            }
+            _ => {
+                return Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: "SSD write rate and burst must be configured together and be positive"
+                        .to_string(),
+                }));
+            }
+        };
+        let [root] = init.roots.as_slice() else {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "kv ssd storage currently requires exactly one local root, got {}",
+                    init.roots.len()
+                ),
+            }));
+        };
+        if root.limit_bytes < MIN_CAPACITY_BYTES {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "kv ssd capacity must be at least {} bytes, got {}",
+                    BLOCK_SIZE_BYTES, root.limit_bytes
+                ),
+            }));
+        }
+        let capacity_bytes = usize::try_from(root.limit_bytes).map_err(|_| {
+            KvError::Api(ApiError::InvalidArgument {
+                detail: format!("kv ssd capacity does not fit usize: {}", root.limit_bytes),
+            })
+        })?;
+
+        fs::create_dir_all(&root.root_dir)
+            .map_err(|err| file_error(&root.root_dir, "create root", err))?;
+        let storage_root = root.root_dir.join("foyer");
+        match fs::remove_dir_all(&storage_root) {
+            Ok(()) => {}
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
+            Err(err) => return Err(file_error(&storage_root, "clear old store", err)),
+        }
+        fs::create_dir_all(&storage_root)
+            .map_err(|err| file_error(&storage_root, "create store", err))?;
+
+        let device = FsDeviceBuilder::new(&storage_root)
+            .with_capacity(capacity_bytes)
+            .with_direct(true)
+            .build()
+            .map_err(|err| storage_error("build filesystem device", err))?;
+        let engine = BlockEngineConfig::new(device)
+            .with_block_size(BLOCK_SIZE_BYTES)
+            .with_buffer_pool_size(FLUSH_BUFFER_BYTES)
+            .with_submit_queue_size_threshold(SUBMIT_QUEUE_BYTES);
+        let cache = HybridCacheBuilder::new()
+            .with_name("fluxon_kv_ssd")
+            .with_policy(HybridCachePolicy::WriteOnInsertion)
+            .with_flush_on_close(false)
+            .memory(MEMORY_CAPACITY_BYTES)
+            .with_shards(MEMORY_SHARDS)
+            .with_weighter(|_key: &KvSsdKey, value: &Vec<u8>| value.len())
+            .with_filter(|_key: &KvSsdKey, _value: &Vec<u8>| false)
+            .storage()
+            .with_io_engine_config(PsyncIoEngineConfig::new())
+            .with_engine_config(engine)
+            .build()
+            .await
+            .map_err(|err| storage_error("build cache", err))?;
+
+        tracing::info!(
+            root = %root.root_dir.display(),
+            capacity_bytes = root.limit_bytes,
+            write_rate_limit_bytes_per_sec = init.write_rate_limit_bytes_per_sec,
+            write_burst_bytes = init.write_burst_bytes,
+            direct_io = true,
+            "Initialized owner-local KV SSD backing"
+        );
+
+        Ok(Self {
+            cache,
+            root_dir: root.root_dir.clone(),
+            capacity_bytes: root.limit_bytes,
+            write_rate_limiter,
+            persist_batch_gate: Arc::new(AsyncMutex::new(())),
+            entry_lengths: Mutex::new(HashMap::new()),
+            logical_used_bytes: AtomicU64::new(0),
+            persist_requests: AtomicU64::new(0),
+            persist_successes: AtomicU64::new(0),
+            persist_failures: AtomicU64::new(0),
+            persist_bytes: AtomicU64::new(0),
+            persist_duration_us: AtomicU64::new(0),
+            persist_batch_requests: AtomicU64::new(0),
+            persist_batch_items: AtomicU64::new(0),
+            persist_flush_batches: AtomicU64::new(0),
+            persist_busy_batches: AtomicU64::new(0),
+            persist_admission_skips: AtomicU64::new(0),
+            persist_batch_duration_us: AtomicU64::new(0),
+            write_candidate_items: AtomicU64::new(0),
+            write_candidate_bytes: AtomicU64::new(0),
+            write_admitted_items: AtomicU64::new(0),
+            write_admitted_bytes: AtomicU64::new(0),
+            write_dropped_items: AtomicU64::new(0),
+            write_dropped_bytes: AtomicU64::new(0),
+            write_refunded_items: AtomicU64::new(0),
+            write_refunded_bytes: AtomicU64::new(0),
+            load_requests: AtomicU64::new(0),
+            load_successes: AtomicU64::new(0),
+            load_misses: AtomicU64::new(0),
+            load_failures: AtomicU64::new(0),
+            load_bytes: AtomicU64::new(0),
+            load_duration_us: AtomicU64::new(0),
+            memory_hits: AtomicU64::new(0),
+            disk_hits: AtomicU64::new(0),
+            outer_hits: AtomicU64::new(0),
+            removals: AtomicU64::new(0),
+        })
+    }
+
+    pub fn root_dir(&self) -> &Path {
+        &self.root_dir
+    }
+
+    pub fn usage_snapshot(&self) -> KvSsdStorageDeviceUsage {
+        KvSsdStorageDeviceUsage {
+            device: self.root_dir.display().to_string(),
+            capacity_bytes: self.capacity_bytes,
+            used_bytes: self
+                .logical_used_bytes
+                .load(Ordering::Relaxed)
+                .min(self.capacity_bytes),
+            persist_requests: self.persist_requests.load(Ordering::Relaxed),
+            persist_successes: self.persist_successes.load(Ordering::Relaxed),
+            persist_failures: self.persist_failures.load(Ordering::Relaxed),
+            persist_bytes: self.persist_bytes.load(Ordering::Relaxed),
+            persist_duration_us: self.persist_duration_us.load(Ordering::Relaxed),
+            persist_batch_requests: self.persist_batch_requests.load(Ordering::Relaxed),
+            persist_batch_items: self.persist_batch_items.load(Ordering::Relaxed),
+            persist_flush_batches: self.persist_flush_batches.load(Ordering::Relaxed),
+            persist_busy_batches: self.persist_busy_batches.load(Ordering::Relaxed),
+            persist_admission_skips: self.persist_admission_skips.load(Ordering::Relaxed),
+            persist_batch_duration_us: self.persist_batch_duration_us.load(Ordering::Relaxed),
+            write_candidate_items: self.write_candidate_items.load(Ordering::Relaxed),
+            write_candidate_bytes: self.write_candidate_bytes.load(Ordering::Relaxed),
+            write_admitted_items: self.write_admitted_items.load(Ordering::Relaxed),
+            write_admitted_bytes: self.write_admitted_bytes.load(Ordering::Relaxed),
+            write_dropped_items: self.write_dropped_items.load(Ordering::Relaxed),
+            write_dropped_bytes: self.write_dropped_bytes.load(Ordering::Relaxed),
+            write_refunded_items: self.write_refunded_items.load(Ordering::Relaxed),
+            write_refunded_bytes: self.write_refunded_bytes.load(Ordering::Relaxed),
+            load_requests: self.load_requests.load(Ordering::Relaxed),
+            load_successes: self.load_successes.load(Ordering::Relaxed),
+            load_misses: self.load_misses.load(Ordering::Relaxed),
+            load_failures: self.load_failures.load(Ordering::Relaxed),
+            load_bytes: self.load_bytes.load(Ordering::Relaxed),
+            load_duration_us: self.load_duration_us.load(Ordering::Relaxed),
+            memory_hits: self.memory_hits.load(Ordering::Relaxed),
+            disk_hits: self.disk_hits.load(Ordering::Relaxed),
+            outer_hits: self.outer_hits.load(Ordering::Relaxed),
+            removals: self.removals.load(Ordering::Relaxed),
+        }
+    }
+
+    pub async fn close(&self) -> KvResult<()> {
+        self.cache
+            .close()
+            .await
+            .map_err(|err| storage_error("close", err))
+    }
+
+    /// Select at most one bounded durability batch from master-confirmed
+    /// last-backing candidates. Smaller values win ties because they preserve
+    /// more independently reusable keys per admitted byte. The decision is
+    /// immediate: candidates outside the burst/rate budget are returned as
+    /// false and must be reclaimed without waiting for SSD bandwidth.
+    pub(crate) fn admit_owner_write_candidates(&self, lengths: &[u64]) -> Vec<bool> {
+        let mut order = (0..lengths.len()).collect::<Vec<_>>();
+        order.sort_by_key(|index| (lengths[*index], *index));
+        let mut admitted = vec![false; lengths.len()];
+        let mut admitted_items = 0usize;
+        let mut admitted_bytes = 0u64;
+        let now = Instant::now();
+        let mut limiter = self
+            .write_rate_limiter
+            .as_ref()
+            .map(|limiter| limiter.lock());
+        for index in order {
+            if admitted_items == MAX_PERSIST_BATCH_ITEMS {
+                break;
+            }
+            let len = lengths[index];
+            let allowed = limiter
+                .as_mut()
+                .is_none_or(|limiter| limiter.try_consume(len, now));
+            if allowed {
+                admitted[index] = true;
+                admitted_items += 1;
+                admitted_bytes = admitted_bytes.saturating_add(len);
+            }
+        }
+        let candidate_bytes = lengths.iter().copied().fold(0u64, u64::saturating_add);
+        let candidate_items = u64::try_from(lengths.len()).unwrap_or(u64::MAX);
+        let admitted_items = u64::try_from(admitted_items).unwrap_or(u64::MAX);
+        let dropped_items = candidate_items.saturating_sub(admitted_items);
+        let dropped_bytes = candidate_bytes.saturating_sub(admitted_bytes);
+        self.write_candidate_items
+            .fetch_add(candidate_items, Ordering::Relaxed);
+        self.write_candidate_bytes
+            .fetch_add(candidate_bytes, Ordering::Relaxed);
+        self.write_admitted_items
+            .fetch_add(admitted_items, Ordering::Relaxed);
+        self.write_admitted_bytes
+            .fetch_add(admitted_bytes, Ordering::Relaxed);
+        self.write_dropped_items
+            .fetch_add(dropped_items, Ordering::Relaxed);
+        self.write_dropped_bytes
+            .fetch_add(dropped_bytes, Ordering::Relaxed);
+        admitted
+    }
+
+    /// Return rate-budget bytes when a provisionally admitted no-queue batch
+    /// loses the persist gate before any copy or I/O starts. This keeps gate
+    /// contention from silently burning future bandwidth while preserving the
+    /// immediate-Drop contract.
+    pub(crate) fn refund_owner_write_admission(&self, lengths: &[u64]) {
+        if lengths.is_empty() {
+            return;
+        }
+        let Some(limiter) = self.write_rate_limiter.as_ref() else {
+            return;
+        };
+        let refunded_bytes = lengths.iter().copied().fold(0u64, u64::saturating_add);
+        let mut limiter = limiter.lock();
+        limiter.refill(Instant::now());
+        limiter.available_bytes = limiter
+            .available_bytes
+            .saturating_add(refunded_bytes)
+            .min(limiter.burst_bytes);
+        drop(limiter);
+        self.write_refunded_items.fetch_add(
+            u64::try_from(lengths.len()).unwrap_or(u64::MAX),
+            Ordering::Relaxed,
+        );
+        self.write_refunded_bytes
+            .fetch_add(refunded_bytes, Ordering::Relaxed);
+    }
+
+    /// Copy exact source bytes into owner-owned buffers. Callers may release
+    /// source holders after this returns; durability uses only these copies.
+    pub(crate) fn copy_batch_from_addrs(
+        sources: &[KvSsdPersistSource],
+    ) -> Vec<KvResult<KvSsdPersistCopy>> {
+        sources
+            .iter()
+            .map(|source| {
+                let len = checked_len(source.len, "persist copy")?;
+                let data =
+                    unsafe { std::slice::from_raw_parts(source.addr as *const u8, len).to_vec() };
+                Ok(KvSsdPersistCopy {
+                    key: source.key.clone(),
+                    put_id: source.put_id,
+                    data,
+                })
+            })
+            .collect()
+    }
+
+    pub(crate) async fn persist_batch_from_addrs(
+        &self,
+        sources: &[KvSsdPersistSource],
+    ) -> Vec<KvResult<Option<KvSsdPersistGuard>>> {
+        if sources.is_empty() {
+            return Vec::new();
+        }
+        match self.try_acquire_persist_batch(sources.len()) {
+            Ok(Some(permit)) => {
+                self.persist_batch_from_copies_with_permit(
+                    permit,
+                    Self::copy_batch_from_addrs(sources),
+                )
+                .await
+            }
+            Ok(None) => sources.iter().map(|_| Ok(None)).collect(),
+            Err(_) => sources
+                .iter()
+                .map(|_| Err(persist_batch_size_error(sources.len())))
+                .collect(),
+        }
+    }
+
+    pub(crate) fn try_acquire_persist_batch(
+        &self,
+        item_count: usize,
+    ) -> KvResult<Option<KvSsdPersistBatchPermit>> {
+        self.persist_requests
+            .fetch_add(item_count as u64, Ordering::Relaxed);
+        self.persist_batch_requests.fetch_add(1, Ordering::Relaxed);
+        self.persist_batch_items
+            .fetch_add(item_count as u64, Ordering::Relaxed);
+        if item_count == 0 || item_count > MAX_PERSIST_BATCH_ITEMS {
+            self.persist_failures
+                .fetch_add(item_count as u64, Ordering::Relaxed);
+            return Err(persist_batch_size_error(item_count));
+        }
+        let Ok(guard) = self.persist_batch_gate.clone().try_lock_owned() else {
+            self.persist_busy_batches.fetch_add(1, Ordering::Relaxed);
+            self.persist_admission_skips
+                .fetch_add(item_count as u64, Ordering::Relaxed);
+            return Ok(None);
+        };
+        Ok(Some(KvSsdPersistBatchPermit { _guard: guard }))
+    }
+
+    /// Persist owner-owned copies through the canonical durability path.
+    #[cfg(test)]
+    pub(crate) async fn persist_batch_from_copies(
+        &self,
+        copies: Vec<KvResult<KvSsdPersistCopy>>,
+    ) -> Vec<KvResult<Option<KvSsdPersistGuard>>> {
+        if copies.is_empty() {
+            return Vec::new();
+        }
+        let item_count = copies.len();
+        match self.try_acquire_persist_batch(item_count) {
+            Ok(Some(permit)) => {
+                self.persist_batch_from_copies_with_permit(permit, copies)
+                    .await
+            }
+            Ok(None) => copies.into_iter().map(|copy| copy.map(|_| None)).collect(),
+            Err(_) => copies
+                .into_iter()
+                .map(|copy| copy.and_then(|_| Err(persist_batch_size_error(item_count))))
+                .collect(),
+        }
+    }
+
+    pub(crate) async fn persist_batch_from_copies_with_permit(
+        &self,
+        _permit: KvSsdPersistBatchPermit,
+        copies: Vec<KvResult<KvSsdPersistCopy>>,
+    ) -> Vec<KvResult<Option<KvSsdPersistGuard>>> {
+        let item_count = copies.len();
+        let lengths = copies
+            .iter()
+            .map(|copy| copy.as_ref().map_or(0, KvSsdPersistCopy::len))
+            .collect::<Vec<_>>();
+        let started_at = Instant::now();
+        let mut results = std::iter::repeat_with(|| None)
+            .take(item_count)
+            .collect::<Vec<Option<KvResult<Option<KvSsdPersistGuard>>>>>();
+        let mut batch_keys = std::collections::HashSet::with_capacity(item_count);
+        let mut pending = Vec::<(usize, KvSsdKey, u64, SsdEntry)>::new();
+
+        for (index, copy) in copies.into_iter().enumerate() {
+            let copy = match copy {
+                Ok(copy) => copy,
+                Err(err) => {
+                    results[index] = Some(Err(err));
+                    continue;
+                }
+            };
+            let len = lengths[index];
+            let cache_key = KvSsdKey {
+                key: copy.key.clone(),
+                put_id: copy.put_id,
+            };
+            if !batch_keys.insert(cache_key.clone()) {
+                results[index] = Some(Err(KvError::Api(ApiError::InvalidArgument {
+                    detail: format!(
+                        "kv ssd persist batch contains duplicate generation: key={} put_id=({},{})",
+                        copy.key, copy.put_id.0, copy.put_id.1
+                    ),
+                })));
+                continue;
+            }
+            let existing_len = self.entry_lengths.lock().get(&cache_key).copied();
+            if let Some(existing_len) = existing_len {
+                if existing_len != len {
+                    results[index] = Some(Err(KvError::Api(ApiError::InvalidArgument {
+                        detail: format!(
+                            "kv ssd duplicate persist length mismatch: key={} put_id=({},{}) existing={} requested={}",
+                            copy.key, copy.put_id.0, copy.put_id.1, existing_len, len
+                        ),
+                    })));
+                    continue;
+                }
+                // Lengths are published only after the batch durability
+                // barrier, so a tracked generation can be replayed directly.
+                if self.cache.storage().may_contains(&cache_key) {
+                    results[index] = Some(Ok(Some(KvSsdPersistGuard { _entry: None })));
+                    continue;
+                }
+                self.forget_entry(&cache_key);
+            }
+
+            match self
+                .cache
+                .storage_writer(cache_key.clone())
+                .force()
+                .insert(copy.data)
+            {
+                Some(entry) => pending.push((index, cache_key, len, entry)),
+                None => {
+                    results[index] = Some(Err(KvError::Api(ApiError::FileWriteError {
+                        path: self.root_dir.display().to_string(),
+                        offset: 0,
+                        detail: format!(
+                            "SSD admission rejected: key={} put_id=({},{})",
+                            copy.key, copy.put_id.0, copy.put_id.1
+                        ),
+                    })));
+                }
+            }
+        }
+
+        if !pending.is_empty() {
+            self.persist_flush_batches.fetch_add(1, Ordering::Relaxed);
+            // One global barrier covers every independently keyed insertion in
+            // this admitted batch. No per-item Wait is interleaved into the
+            // Foyer submit queue.
+            self.cache.storage().wait().await;
+        }
+        for (index, cache_key, len, entry) in pending {
+            if !self.cache.storage().may_contains(&cache_key) {
+                results[index] = Some(Err(KvError::Api(ApiError::FileWriteError {
+                    path: self.root_dir.display().to_string(),
+                    offset: 0,
+                    detail: format!(
+                        "SSD commit missing: key={} put_id=({},{})",
+                        cache_key.key, cache_key.put_id.0, cache_key.put_id.1
+                    ),
+                })));
+                continue;
+            }
+            let mut lengths = self.entry_lengths.lock();
+            if lengths.insert(cache_key, len).is_none() {
+                self.logical_used_bytes.fetch_add(len, Ordering::Relaxed);
+            }
+            drop(lengths);
+            results[index] = Some(Ok(Some(KvSsdPersistGuard {
+                _entry: Some(entry),
+            })));
+        }
+
+        let elapsed = elapsed_us(started_at);
+        self.persist_batch_duration_us
+            .fetch_add(elapsed, Ordering::Relaxed);
+        self.persist_duration_us
+            .fetch_add(elapsed.saturating_mul(item_count as u64), Ordering::Relaxed);
+        let mut successes = 0u64;
+        let mut failures = 0u64;
+        let mut bytes = 0u64;
+        let results = results
+            .into_iter()
+            .enumerate()
+            .map(|(index, result)| {
+                let result = result.unwrap_or_else(|| {
+                    Err(KvError::Api(ApiError::Unknown {
+                        detail: "kv ssd batch result was not populated".to_string(),
+                    }))
+                });
+                match &result {
+                    Ok(Some(_)) => {
+                        successes = successes.saturating_add(1);
+                        bytes = bytes.saturating_add(lengths[index]);
+                    }
+                    Ok(None) => {}
+                    Err(_) => failures = failures.saturating_add(1),
+                }
+                result
+            })
+            .collect::<Vec<_>>();
+        self.persist_successes
+            .fetch_add(successes, Ordering::Relaxed);
+        self.persist_failures.fetch_add(failures, Ordering::Relaxed);
+        self.persist_bytes.fetch_add(bytes, Ordering::Relaxed);
+        results
+    }
+
+    #[cfg(test)]
+    async fn persist(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        data: &[u8],
+    ) -> KvResult<KvSsdPersistGuard> {
+        let source = KvSsdPersistSource {
+            key: key.to_string(),
+            put_id,
+            addr: data.as_ptr() as u64,
+            len: data.len() as u64,
+        };
+        match self
+            .persist_batch_from_addrs(std::slice::from_ref(&source))
+            .await
+            .pop()
+            .expect("one persist source must produce one result")?
+        {
+            Some(guard) => Ok(guard),
+            None => Err(KvError::Api(ApiError::Unknown {
+                detail: "test persist was skipped by an unexpected busy batch".to_string(),
+            })),
+        }
+    }
+
+    pub(crate) async fn load_into_addr(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        target_addr: u64,
+        len: u64,
+        target_capacity: u64,
+    ) -> KvResult<()> {
+        self.load_requests.fetch_add(1, Ordering::Relaxed);
+        let started_at = Instant::now();
+        let result = self
+            .load_into_addr_inner(key, put_id, target_addr, len, target_capacity)
+            .await;
+        self.load_duration_us
+            .fetch_add(elapsed_us(started_at), Ordering::Relaxed);
+        match &result {
+            Ok(()) => {
+                self.load_successes.fetch_add(1, Ordering::Relaxed);
+                self.load_bytes.fetch_add(len, Ordering::Relaxed);
+            }
+            Err(KvError::Api(ApiError::KeyNotFound { .. })) => {
+                self.load_misses.fetch_add(1, Ordering::Relaxed);
+            }
+            Err(_) => {
+                self.load_failures.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+        result
+    }
+
+    async fn load_into_addr_inner(
+        &self,
+        key: &str,
+        put_id: PutIDForAKey,
+        target_addr: u64,
+        len: u64,
+        target_capacity: u64,
+    ) -> KvResult<()> {
+        if target_capacity < len {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "kv ssd target too small: key={} put_id=({},{}) len={} capacity={}",
+                    key, put_id.0, put_id.1, len, target_capacity
+                ),
+            }));
+        }
+        let len_usize = checked_len(len, "load")?;
+        let cache_key = KvSsdKey {
+            key: key.to_string(),
+            put_id,
+        };
+        let entry = self
+            .cache
+            .get(&cache_key)
+            .await
+            .map_err(|err| storage_error("load", err))?
+            .ok_or_else(|| {
+                self.forget_entry(&cache_key);
+                KvError::Api(ApiError::KeyNotFound {
+                    key: key.to_string(),
+                })
+            })?;
+        match entry.source() {
+            Source::Memory => self.memory_hits.fetch_add(1, Ordering::Relaxed),
+            Source::Disk => self.disk_hits.fetch_add(1, Ordering::Relaxed),
+            Source::Outer => self.outer_hits.fetch_add(1, Ordering::Relaxed),
+        };
+        if entry.value().len() != len_usize {
+            tracing::warn!(
+                key,
+                put_time_ms = put_id.0,
+                put_version = put_id.1,
+                expected_len = len,
+                actual_len = entry.value().len(),
+                "Dropping corrupt/stale KV SSD entry with a length mismatch"
+            );
+            self.forget_entry(&cache_key);
+            self.cache.remove(&cache_key);
+            return Err(KvError::Api(ApiError::KeyNotFound {
+                key: key.to_string(),
+            }));
+        }
+        unsafe {
+            std::ptr::copy_nonoverlapping(
+                entry.value().as_ptr(),
+                target_addr as *mut u8,
+                len_usize,
+            );
+        }
+        Ok(())
+    }
+
+    pub(crate) async fn remove_exact(&self, key: &str, put_id: PutIDForAKey) -> bool {
+        let _batch_guard = self.persist_batch_gate.lock().await;
+        let cache_key = KvSsdKey {
+            key: key.to_string(),
+            put_id,
+        };
+        let removed = self.entry_lengths.lock().remove(&cache_key);
+        self.cache.remove(&cache_key);
+        if let Some(len) = removed {
+            self.logical_used_bytes.fetch_sub(len, Ordering::Relaxed);
+            self.removals.fetch_add(1, Ordering::Relaxed);
+            true
+        } else {
+            false
+        }
+    }
+
+    fn forget_entry(&self, key: &KvSsdKey) {
+        if let Some(len) = self.entry_lengths.lock().remove(key) {
+            self.logical_used_bytes.fetch_sub(len, Ordering::Relaxed);
+        }
+    }
+}
+
+fn elapsed_us(started_at: Instant) -> u64 {
+    u64::try_from(started_at.elapsed().as_micros()).unwrap_or(u64::MAX)
+}
+
+fn checked_len(len: u64, operation: &str) -> KvResult<usize> {
+    let len = usize::try_from(len).map_err(|_| {
+        KvError::Api(ApiError::InvalidArgument {
+            detail: format!("kv ssd {operation} len does not fit usize: {len}"),
+        })
+    })?;
+    if len == 0 {
+        return Err(KvError::Api(ApiError::InvalidArgument {
+            detail: format!("kv ssd {operation} len must be positive"),
+        }));
+    }
+    Ok(len)
+}
+
+fn persist_batch_size_error(item_count: usize) -> KvError {
+    KvError::Api(ApiError::InvalidArgument {
+        detail: format!(
+            "kv ssd persist batch item count is outside 1..={}: items={}",
+            MAX_PERSIST_BATCH_ITEMS, item_count
+        ),
+    })
+}
+
+fn storage_error(operation: &str, err: impl std::fmt::Display) -> KvError {
+    KvError::Api(ApiError::Unknown {
+        detail: format!("kv ssd {operation} failed: {err}"),
+    })
+}
+
+fn file_error(path: &Path, operation: &str, err: std::io::Error) -> KvError {
+    KvError::Api(ApiError::FileWriteError {
+        path: path.display().to_string(),
+        offset: 0,
+        detail: format!("{operation}: {err}"),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cluster_manager::NodeID;
+    use crate::master_kv_router::{
+        CommittedSlotReplica, KvMemoryReplica, KvNodeReplicas, KvReplicaBacking, OneKvNodesRoutes,
+        SsdReplicaCommitStatus,
+    };
+    use crate::master_seg_manager::NodeTombTag;
+    use parking_lot::RwLock;
+    use std::collections::HashMap;
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicU32;
+    use std::time::Duration;
+
+    fn test_root(name: &str) -> PathBuf {
+        let target = std::env::var_os("CARGO_TARGET_DIR")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| PathBuf::from("/mnt/nvme0/mjq_build/push_sglang_fluxon_target"));
+        target.join("kv_ssd_tests").join(format!(
+            "{}-{}-{}",
+            name,
+            std::process::id(),
+            uuid::Uuid::new_v4()
+        ))
+    }
+
+    #[test]
+    fn write_rate_limiter_refills_without_queueing() {
+        let start = Instant::now();
+        let mut limiter = WriteRateLimiter {
+            rate_bytes_per_sec: 100,
+            burst_bytes: 100,
+            available_bytes: 100,
+            refill_remainder: 0,
+            last_refill: start,
+        };
+        assert!(limiter.try_consume(60, start));
+        assert!(!limiter.try_consume(50, start));
+        assert!(limiter.try_consume(50, start + Duration::from_millis(500)));
+        assert_eq!(limiter.available_bytes, 40);
+    }
+
+    #[tokio::test]
+    async fn owner_candidate_admission_prefers_small_values_and_one_batch() {
+        let root = test_root("candidate-admission");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: MIN_CAPACITY_BYTES,
+            }],
+            write_rate_limit_bytes_per_sec: Some(1),
+            write_burst_bytes: Some(10),
+        })
+        .await
+        .unwrap();
+        let admitted = store.admit_owner_write_candidates(&[8, 3, 3]);
+        assert_eq!(admitted, vec![false, true, true]);
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.write_candidate_items, 3);
+        assert_eq!(usage.write_candidate_bytes, 14);
+        assert_eq!(usage.write_admitted_items, 2);
+        assert_eq!(usage.write_admitted_bytes, 6);
+        assert_eq!(usage.write_dropped_items, 1);
+        assert_eq!(usage.write_dropped_bytes, 8);
+
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn busy_gate_refund_restores_owner_write_budget() {
+        let root = test_root("candidate-refund");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: MIN_CAPACITY_BYTES,
+            }],
+            write_rate_limit_bytes_per_sec: Some(1),
+            write_burst_bytes: Some(10),
+        })
+        .await
+        .unwrap();
+
+        assert_eq!(store.admit_owner_write_candidates(&[8]), vec![true]);
+        store.refund_owner_write_admission(&[8]);
+        assert_eq!(store.admit_owner_write_candidates(&[8]), vec![true]);
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.write_refunded_items, 1);
+        assert_eq!(usage.write_refunded_bytes, 8);
+
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn persist_and_load_one_generation() {
+        let root = test_root("roundtrip");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: BLOCK_SIZE_BYTES as u64,
+            }],
+            write_rate_limit_bytes_per_sec: None,
+            write_burst_bytes: None,
+        })
+        .await
+        .unwrap();
+        let input = vec![0x5au8; 4096];
+        let guard = store.persist("key", (7, 3), &input).await.unwrap();
+        let mut output = vec![0u8; input.len()];
+        store
+            .load_into_addr(
+                "key",
+                (7, 3),
+                output.as_mut_ptr() as u64,
+                input.len() as u64,
+                output.len() as u64,
+            )
+            .await
+            .unwrap();
+        assert_eq!(output, input);
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.used_bytes, input.len() as u64);
+        assert_eq!(usage.persist_requests, 1);
+        assert_eq!(usage.persist_successes, 1);
+        assert_eq!(usage.persist_failures, 0);
+        assert_eq!(usage.persist_bytes, input.len() as u64);
+        assert_eq!(usage.load_requests, 1);
+        assert_eq!(usage.load_successes, 1);
+        assert_eq!(usage.load_misses, 0);
+        assert_eq!(usage.load_bytes, input.len() as u64);
+        assert_eq!(usage.memory_hits + usage.disk_hits + usage.outer_hits, 1);
+
+        assert!(store.remove_exact("key", (7, 3)).await);
+        assert!(!store.remove_exact("key", (7, 3)).await);
+        assert_eq!(store.usage_snapshot().used_bytes, 0);
+        assert!(
+            store
+                .load_into_addr(
+                    "key",
+                    (7, 3),
+                    output.as_mut_ptr() as u64,
+                    input.len() as u64,
+                    output.len() as u64,
+                )
+                .await
+                .is_err()
+        );
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.load_requests, 2);
+        assert_eq!(usage.load_misses, 1);
+        assert_eq!(usage.removals, 1);
+        drop(guard);
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn copied_persist_no_longer_reads_the_source_buffer() {
+        let root = test_root("copied-persist");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: BLOCK_SIZE_BYTES as u64,
+            }],
+            write_rate_limit_bytes_per_sec: None,
+            write_burst_bytes: None,
+        })
+        .await
+        .unwrap();
+        let mut input = vec![0x3cu8; 4096];
+        let source = KvSsdPersistSource {
+            key: "copied-key".to_string(),
+            put_id: (8, 4),
+            addr: input.as_ptr() as u64,
+            len: input.len() as u64,
+        };
+        let copies = KvSsdStorage::copy_batch_from_addrs(std::slice::from_ref(&source));
+        input.fill(0xe7);
+        let guard = store
+            .persist_batch_from_copies(copies)
+            .await
+            .pop()
+            .unwrap()
+            .unwrap()
+            .expect("copied persist must acquire the durability gate");
+        let mut output = vec![0u8; input.len()];
+        store
+            .load_into_addr(
+                "copied-key",
+                (8, 4),
+                output.as_mut_ptr() as u64,
+                output.len() as u64,
+                output.len() as u64,
+            )
+            .await
+            .unwrap();
+        assert!(output.iter().all(|byte| *byte == 0x3c));
+
+        drop(guard);
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn one_batch_uses_one_flush_barrier_and_keeps_per_key_results() {
+        let root = test_root("one-batch-one-barrier");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: MIN_CAPACITY_BYTES,
+            }],
+            write_rate_limit_bytes_per_sec: None,
+            write_burst_bytes: None,
+        })
+        .await
+        .unwrap();
+        let payloads = (0..MAX_PERSIST_BATCH_ITEMS)
+            .map(|index| vec![u8::try_from(index + 1).unwrap(); 1024 * 1024])
+            .collect::<Vec<_>>();
+        let sources = payloads
+            .iter()
+            .enumerate()
+            .map(|(index, payload)| KvSsdPersistSource {
+                key: format!("batch-victim-{index}"),
+                put_id: (31, u32::try_from(index).unwrap()),
+                addr: payload.as_ptr() as u64,
+                len: payload.len() as u64,
+            })
+            .collect::<Vec<_>>();
+        let guards = store
+            .persist_batch_from_addrs(&sources)
+            .await
+            .into_iter()
+            .map(|result| result.unwrap().expect("the only batch must be admitted"))
+            .collect::<Vec<_>>();
+        assert_eq!(guards.len(), MAX_PERSIST_BATCH_ITEMS);
+
+        for (index, payload) in payloads.iter().enumerate() {
+            let mut output = vec![0; payload.len()];
+            store
+                .load_into_addr(
+                    &format!("batch-victim-{index}"),
+                    (31, u32::try_from(index).unwrap()),
+                    output.as_mut_ptr() as u64,
+                    output.len() as u64,
+                    output.len() as u64,
+                )
+                .await
+                .unwrap();
+            assert_eq!(&output, payload);
+        }
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.persist_successes, MAX_PERSIST_BATCH_ITEMS as u64);
+        assert_eq!(usage.persist_failures, 0);
+        assert_eq!(usage.persist_batch_requests, 1);
+        assert_eq!(usage.persist_flush_batches, 1);
+        assert_eq!(usage.persist_busy_batches, 0);
+        assert_eq!(usage.persist_admission_skips, 0);
+        assert_eq!(usage.load_successes, MAX_PERSIST_BATCH_ITEMS as u64);
+
+        drop(guards);
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn retrying_a_multi_key_batch_reuses_durable_generations() {
+        let root = test_root("multi-key-batch-retry");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: MIN_CAPACITY_BYTES,
+            }],
+            write_rate_limit_bytes_per_sec: None,
+            write_burst_bytes: None,
+        })
+        .await
+        .unwrap();
+        let original = (0..3)
+            .map(|index| vec![u8::try_from(0x41 + index).unwrap(); 4096])
+            .collect::<Vec<_>>();
+        let original_sources = original
+            .iter()
+            .enumerate()
+            .map(|(index, payload)| KvSsdPersistSource {
+                key: format!("retry-victim-{index}"),
+                put_id: (35, u32::try_from(index).unwrap()),
+                addr: payload.as_ptr() as u64,
+                len: payload.len() as u64,
+            })
+            .collect::<Vec<_>>();
+        let first_guards = store
+            .persist_batch_from_addrs(&original_sources)
+            .await
+            .into_iter()
+            .map(|result| result.unwrap().expect("the first batch must be admitted"))
+            .collect::<Vec<_>>();
+
+        // A retry may arrive after the caller has reused its source buffer. The
+        // generation identity, not the retried bytes, owns the durable result.
+        let retry_payloads = original
+            .iter()
+            .map(|payload| vec![0xee; payload.len()])
+            .collect::<Vec<_>>();
+        let retry_sources = retry_payloads
+            .iter()
+            .enumerate()
+            .map(|(index, payload)| KvSsdPersistSource {
+                key: format!("retry-victim-{index}"),
+                put_id: (35, u32::try_from(index).unwrap()),
+                addr: payload.as_ptr() as u64,
+                len: payload.len() as u64,
+            })
+            .collect::<Vec<_>>();
+        let retry_guards = store
+            .persist_batch_from_addrs(&retry_sources)
+            .await
+            .into_iter()
+            .map(|result| result.unwrap().expect("a durable retry must be replayable"))
+            .collect::<Vec<_>>();
+
+        for (index, expected) in original.iter().enumerate() {
+            let mut output = vec![0; expected.len()];
+            store
+                .load_into_addr(
+                    &format!("retry-victim-{index}"),
+                    (35, u32::try_from(index).unwrap()),
+                    output.as_mut_ptr() as u64,
+                    output.len() as u64,
+                    output.len() as u64,
+                )
+                .await
+                .unwrap();
+            assert_eq!(&output, expected);
+        }
+        let expected_bytes = original.iter().map(Vec::len).sum::<usize>() as u64;
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.used_bytes, expected_bytes);
+        assert_eq!(usage.persist_requests, 6);
+        assert_eq!(usage.persist_successes, 6);
+        assert_eq!(usage.persist_failures, 0);
+        assert_eq!(usage.persist_batch_requests, 2);
+        assert_eq!(usage.persist_flush_batches, 1);
+        assert_eq!(usage.persist_busy_batches, 0);
+
+        drop(retry_guards);
+        drop(first_guards);
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn busy_write_batch_skips_without_copying_or_queueing() {
+        let root = test_root("busy-batch-skip");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: MIN_CAPACITY_BYTES,
+            }],
+            write_rate_limit_bytes_per_sec: None,
+            write_burst_bytes: None,
+        })
+        .await
+        .unwrap();
+        let input = vec![0xabu8; 4096];
+        let source = KvSsdPersistSource {
+            key: "busy-skip".to_string(),
+            put_id: (37, 1),
+            addr: input.as_ptr() as u64,
+            len: input.len() as u64,
+        };
+        let held = store.persist_batch_gate.lock().await;
+        let result = store
+            .persist_batch_from_addrs(std::slice::from_ref(&source))
+            .await
+            .pop()
+            .unwrap()
+            .unwrap();
+        assert!(result.is_none());
+        drop(held);
+
+        let usage = store.usage_snapshot();
+        assert_eq!(usage.persist_requests, 1);
+        assert_eq!(usage.persist_successes, 0);
+        assert_eq!(usage.persist_failures, 0);
+        assert_eq!(usage.persist_busy_batches, 1);
+        assert_eq!(usage.persist_admission_skips, 1);
+        assert_eq!(usage.persist_flush_batches, 0);
+
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[tokio::test]
+    async fn persist_commit_memory_evict_and_ssd_load_roundtrip() {
+        let root = test_root("route-roundtrip");
+        let store = KvSsdStorage::new(KvSsdStorageInit {
+            roots: vec![KvSsdStorageRootLimit {
+                root_dir: root.clone(),
+                limit_bytes: MIN_CAPACITY_BYTES,
+            }],
+            write_rate_limit_bytes_per_sec: None,
+            write_burst_bytes: None,
+        })
+        .await
+        .unwrap();
+        let owner: NodeID = "owner".to_string().into();
+        let put_id = (19, 4);
+        let input = vec![0xa5u8; 4096];
+        let persist_guard = store.persist("route-key", put_id, &input).await.unwrap();
+
+        let route = Arc::new(OneKvNodesRoutes {
+            put_id,
+            lease_id: None,
+            atomic_group: None,
+            node_replicas: RwLock::new(HashMap::from([(
+                owner.clone(),
+                KvNodeReplicas::memory(
+                    NodeTombTag::new(),
+                    KvMemoryReplica {
+                        backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                            owner_node_id: owner.clone(),
+                            grant_id: 7,
+                            slot_index: 3,
+                            slot_size: input.len() as u64,
+                            addr: input.as_ptr() as u64,
+                            len: input.len() as u64,
+                            base_addr: input.as_ptr() as u64,
+                        }),
+                        owner_local_indexed: true,
+                        get_durable_reservation: None,
+                        capacity_reservation: None,
+                    },
+                ),
+            )])),
+            get_durable_slots_used: AtomicU32::new(0),
+        });
+        assert_eq!(
+            route.commit_ssd_replica(&owner, input.len() as u64),
+            SsdReplicaCommitStatus::Committed
+        );
+
+        // This is the terminal state produced by the already-covered exact
+        // owner-memory reclaim transaction: the node and SSD route remain,
+        // while DRAM is no longer readable.
+        route.node_replicas.write().get_mut(&owner).unwrap().memory = None;
+        {
+            let replicas = route.node_replicas.read();
+            let owner_backings = replicas.get(&owner).unwrap();
+            assert!(owner_backings.memory.is_none());
+            assert_eq!(
+                owner_backings.ssd.as_ref().map(|ssd| ssd.len),
+                Some(input.len() as u64)
+            );
+        }
+
+        let mut output = vec![0u8; input.len()];
+        store
+            .load_into_addr(
+                "route-key",
+                put_id,
+                output.as_mut_ptr() as u64,
+                output.len() as u64,
+                output.len() as u64,
+            )
+            .await
+            .unwrap();
+        assert_eq!(output, input);
+
+        drop(persist_guard);
+        store.close().await.unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/fluxon_rs/fluxon_kv/src/kv_test.rs b/fluxon_rs/fluxon_kv/src/kv_test.rs
index d8331ea..a8c60c1 100644
--- a/fluxon_rs/fluxon_kv/src/kv_test.rs
+++ b/fluxon_rs/fluxon_kv/src/kv_test.rs
@@ -1057,6 +1057,7 @@ fn build_client_launch(
             &instance_key,
             &contribute_to_cluster_pool_size,
         ),
+        ssd_storage: None,
         // Mirror round intent into the generated config so logs and runtime behavior
         // agree on whether this launch is transfer_only vs transfer_with_rpc.
         test_spec_config: kv_test_round_test_spec_config(round.round_profile),
@@ -2470,7 +2471,7 @@ async fn run_kv_round(round: &KvTestRoundOptions) {
             .kv_routes
             .get(CLIENT_COMMUNICATION_KEY)
         {
-            let replicas = one_kv_nodes_routes.nodes_replicas.read();
+            let replicas = one_kv_nodes_routes.node_replicas.read();
             let active_replica_count = replicas
                 .iter()
                 .filter(|(_, kv_info)| !kv_info.tomb_tag.is_tomb())
diff --git a/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs b/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
index d17dc57..aba139c 100644
--- a/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
+++ b/fluxon_rs/fluxon_kv/src/kvcore_test_lib.rs
@@ -152,6 +152,7 @@ fn new_client_config_with_cluster_and_dram(
         large_file_paths: crate::config::LargeFilePaths {
             paths: vec![format!("{}/large/{}", base, instance_key)],
         },
+        ssd_storage: None,
         test_spec_config: TestSpecConfig::default(),
     };
     println!("fluxonkv core created client config for test: {:?}", conf);
@@ -225,6 +226,35 @@ pub async fn start_master_and_client_with_client_dram(
     (master_fw, client_fw)
 }
 
+/// Start a test owner after applying one focused configuration mutation. This
+/// keeps integration tests on the same canonical startup path while allowing
+/// storage-tier tests to enable their local SSD root explicitly.
+pub async fn start_master_and_client_with_client_config(
+    master_key: &str,
+    client_key: &str,
+    configure: impl FnOnce(&mut ClientConfig),
+) -> (Arc<Framework>, Arc<Framework>) {
+    let cluster_name = test_cluster_name(master_key);
+    clean_etcd_members(&cluster_name).await;
+
+    let (master_fw, _) = run_master(ConfigArg::Config(new_master_config_with_cluster(
+        master_key,
+        None,
+        &cluster_name,
+    )))
+    .await
+    .expect("start master");
+    let mut client_config =
+        new_client_config_with_cluster_and_dram(client_key, &cluster_name, 1024 * 1024 * 160);
+    configure(&mut client_config);
+    let (client_fw, _) = run_client(ConfigArg::Config(client_config))
+        .await
+        .expect("start client");
+
+    sleep(Duration::from_secs(3)).await;
+    (master_fw, client_fw)
+}
+
 pub async fn stop_master_and_client(master_fw: Arc<Framework>, client_fw: Arc<Framework>) {
     let _ = client_fw.shutdown().await;
     let _ = master_fw.shutdown().await;
diff --git a/fluxon_rs/fluxon_kv/src/lib.rs b/fluxon_rs/fluxon_kv/src/lib.rs
index a9d38ae..e09061f 100644
--- a/fluxon_rs/fluxon_kv/src/lib.rs
+++ b/fluxon_rs/fluxon_kv/src/lib.rs
@@ -7,6 +7,7 @@ pub mod external_client_api;
 pub mod panel_proxy;
 // #[cfg(test)]
 pub mod key_prefix;
+pub mod kv_ssd_storage;
 #[cfg(feature = "test_bins")]
 pub mod kv_test;
 pub mod kvlease;
@@ -86,6 +87,7 @@ use crate::cluster_manager::ClusterManagerViewTrait;
 use crate::external_client_api::ExternalClientApiAccessTrait;
 use crate::external_client_api::ExternalClientApiView;
 use crate::external_client_api::ExternalClientApiViewTrait;
+use crate::kv_ssd_storage::{KvSsdStorageInit, KvSsdStorageRootLimit};
 use crate::master_kv_router::MasterKvRouterAccessTrait;
 use crate::master_kv_router::MasterKvRouterView;
 use crate::master_kv_router::MasterKvRouterViewTrait;
@@ -862,6 +864,7 @@ fn build_side_transfer_worker_config(
         },
         share_mem_path: owner_config.share_mem_path.clone(),
         large_file_paths: owner_config.large_file_paths.clone(),
+        ssd_storage: None,
         test_spec_config,
     })
 }
@@ -907,6 +910,9 @@ fn build_side_transfer_worker_config_yaml(
             cluster_name: side_config.cluster_name,
             share_mem_path: side_config.share_mem_path,
             large_file_paths: None,
+            large_limit_size: None,
+            ssd_write_rate_limit_bytes_per_sec: None,
+            ssd_write_burst_bytes: None,
             p2p_listen_port: side_config.fluxonkv_spec.p2p_listen_port,
             redis_compat: None,
             sub_cluster: None,
@@ -1992,6 +1998,12 @@ async fn run_client_impl(
         // Owner nodes are the global relay set. Keeping a single metadata marker converges
         // route selection, observability proxy eligibility, and ops topology rendering.
         metadata.insert("p2p_relay".to_string(), "true".to_string());
+        if config.ssd_storage.is_some() {
+            metadata.insert(
+                crate::cluster_manager::META_KEY_KV_SSD_STORAGE.to_string(),
+                "true".to_string(),
+            );
+        }
     }
     merge_startup_member_metadata(&mut metadata, startup_member_metadata)?;
 
@@ -2026,6 +2038,24 @@ async fn run_client_impl(
     ));
     info!("Initializing client framework...");
 
+    let ssd_storage_init = config
+        .ssd_storage
+        .as_ref()
+        .map(|ssd| {
+            config
+                .large_file_paths
+                .kv_ssd_storage_root(&config.cluster_name, &config.instance_key)
+                .map(|root_dir| KvSsdStorageInit {
+                    roots: vec![KvSsdStorageRootLimit {
+                        root_dir,
+                        limit_bytes: ssd.limit_bytes,
+                    }],
+                    write_rate_limit_bytes_per_sec: ssd.write_rate_limit_bytes_per_sec,
+                    write_burst_bytes: ssd.write_burst_bytes,
+                })
+        })
+        .transpose()?;
+
     if is_external && !is_side_transfer_worker {
         let init_args = InitArgsExternal {
             cluster_manager_arg: ClusterManagerNewArg {
@@ -2133,6 +2163,7 @@ async fn run_client_impl(
                         (config.contribute_to_cluster_pool_size.dram as f64 * ratio).floor() as u64
                     },
                 ),
+                ssd_storage: ssd_storage_init,
             },
             client_seg_pool_arg: ClientSegPoolNewArg {
                 contribute_size: config.contribute_to_cluster_pool_size.clone(),
@@ -2566,6 +2597,7 @@ mod tests {
             large_file_paths: crate::config::LargeFilePaths {
                 paths: vec!["/tmp/fluxon_side_transfer_test_large".to_string()],
             },
+            ssd_storage: None,
             test_spec_config: TestSpecConfig {
                 enable_side_transfer: true,
                 side_transfer_worker_count: 4,
@@ -2872,6 +2904,7 @@ mod tests {
             },
             share_mem_path: share_mem_root.to_string_lossy().into_owned(),
             large_file_paths: crate::config::LargeFilePaths { paths: Vec::new() },
+            ssd_storage: None,
             test_spec_config: TestSpecConfig::default(),
         };
 
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
index 87a18da..2a2f758 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/delete.rs
@@ -113,8 +113,8 @@ pub fn evict_one_kv_replica_for_node(
     }
 
     let removed_replica = {
-        let mut nodes_replicas = route.nodes_replicas.write();
-        nodes_replicas.remove(&node_id).is_some()
+        let mut node_replicas = route.node_replicas.write();
+        node_replicas.remove(&node_id).is_some()
     };
     if !removed_replica {
         tracing::debug!(
@@ -127,7 +127,7 @@ pub fn evict_one_kv_replica_for_node(
         return Ok(());
     }
 
-    let last_replica_gone = route.nodes_replicas.read().is_empty();
+    let last_replica_gone = route.node_replicas.read().is_empty();
     if last_replica_gone {
         let removed = view
             .master_kv_router()
@@ -136,7 +136,7 @@ pub fn evict_one_kv_replica_for_node(
             .remove_if(&key, |_, current| {
                 Arc::ptr_eq(current, &route)
                     && current.put_id == put_id
-                    && current.nodes_replicas.read().is_empty()
+                    && current.node_replicas.read().is_empty()
             })
             .is_some();
         if removed && view.master_kv_router().prefix_index_enabled() {
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
index 533127d..5e08ec7 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/get.rs
@@ -1,6 +1,6 @@
 use super::{
-    CommittedSlotReplica, CompletedGetInfo, InflightGetInfo, InflightGetTarget, KvRouteInfo,
-    MasterKeyActivityCompletionGuard, MasterKvRouterView, OwnerHoldingGetInfo,
+    CommittedSlotReplica, CompletedGetInfo, InflightGetInfo, InflightGetTarget, KvMemoryReplica,
+    KvNodeReplicas, MasterKeyActivityCompletionGuard, MasterKvRouterView, OwnerHoldingGetInfo,
     ReservedCapacityReason,
     msg_pack::{
         BatchGetBindItemReq, BatchGetBindReq, BatchGetBindResp, BatchGetDoneItemResp,
@@ -8,12 +8,15 @@ use super::{
         BatchGetRevokeItemResp, BatchGetRevokeReq, BatchGetRevokeResp, BatchGetStartItemResp,
         BatchGetStartReq, BatchGetStartResp, BatchIsExistReq, BatchIsExistResp, GetAllocationMode,
         GetBindTarget, GetDoneReq, GetDoneResp, GetExternalSinkTarget, GetMetaReq, GetMetaResp,
-        GetPreparedLocalReserveTarget, GetRevokeReq, GetRevokeResp, GetStartReq, GetStartResp,
-        MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq, MemHolderReleaseResp,
+        GetPreparedLocalReserveTarget, GetRevokeReq, GetRevokeResp, GetSourceKind, GetStartReq,
+        GetStartResp, MemHolderKeepAliveReq, MemHolderKeepAliveResp, MemHolderReleaseReq,
+        MemHolderReleaseResp, SsdStageBeginReq, SsdStageBeginResp, SsdStageDoneReq,
+        SsdStageDoneResp,
     },
     node_generation_is_current_live, publish_route_replica_tomb_fenced,
     route_maintenance::{RoutePublishEvent, apply_post_route_maintenance_batch},
 };
+use crate::config::SsdReadSourcePolicy;
 use crate::master_kv_router::OneKvNodesRoutes;
 use crate::master_kv_router::put::PutIDForAKey;
 use crate::memholder::MemholderManagerTrait;
@@ -79,10 +82,10 @@ fn touch_moka_for_node(view: MasterKvRouterView, node_id: String, key: String) {
 
 fn one_kv_routes_has_live_replica(one_kv_nodes_routes: &OneKvNodesRoutes) -> bool {
     one_kv_nodes_routes
-        .nodes_replicas
+        .node_replicas
         .read()
         .values()
-        .any(|kv_info| !kv_info.tomb_tag.is_tomb())
+        .any(KvNodeReplicas::has_live_backing)
 }
 
 fn validate_prepared_local_reserve_target(
@@ -267,20 +270,57 @@ struct PlannedGetSourceSnapshot {
     len: u64,
     addr: u64,
     base_addr: u64,
+    source_kind: GetSourceKind,
+}
+
+fn planned_get_source_rank(
+    policy: SsdReadSourcePolicy,
+    source_kind: GetSourceKind,
+    requester_local: bool,
+) -> Option<u8> {
+    match policy {
+        SsdReadSourcePolicy::LegacyRemoteFirst => match (source_kind, requester_local) {
+            (GetSourceKind::Memory, false) => Some(0),
+            (GetSourceKind::Memory, true) => Some(1),
+            (GetSourceKind::Ssd, false) => Some(2),
+            (GetSourceKind::Ssd, true) => Some(3),
+        },
+        SsdReadSourcePolicy::LocalSsdOnlyFirst => match (source_kind, requester_local) {
+            (GetSourceKind::Memory, true) => Some(0),
+            (GetSourceKind::Ssd, true) => Some(1),
+            (GetSourceKind::Memory, false) => Some(2),
+            (GetSourceKind::Ssd, false) => None,
+        },
+    }
 }
 
 fn snapshot_live_get_sources(route: &OneKvNodesRoutes) -> Vec<PlannedGetSourceSnapshot> {
     route
-        .nodes_replicas
+        .node_replicas
         .read()
-        .values()
-        .filter(|replica| !replica.tomb_tag.is_tomb())
-        .map(|replica| PlannedGetSourceSnapshot {
-            node_id: replica.node_id.clone(),
-            tomb_tag: replica.tomb_tag.clone(),
-            len: replica.backing.len(),
-            addr: replica.backing.abs_addr(),
-            base_addr: replica.backing.base_addr(),
+        .iter()
+        .filter_map(|(node_id, replicas)| {
+            if replicas.tomb_tag.is_tomb() {
+                return None;
+            }
+            if let Some(memory) = replicas.memory.as_ref() {
+                return Some(PlannedGetSourceSnapshot {
+                    node_id: node_id.clone(),
+                    tomb_tag: replicas.tomb_tag.clone(),
+                    len: memory.backing.len(),
+                    addr: memory.backing.abs_addr(),
+                    base_addr: memory.backing.base_addr(),
+                    source_kind: GetSourceKind::Memory,
+                });
+            }
+            replicas.ssd.as_ref().map(|ssd| PlannedGetSourceSnapshot {
+                node_id: node_id.clone(),
+                tomb_tag: replicas.tomb_tag.clone(),
+                len: ssd.len,
+                addr: 0,
+                base_addr: 0,
+                source_kind: GetSourceKind::Ssd,
+            })
         })
         .collect()
 }
@@ -293,24 +333,71 @@ fn planned_get_source_is_current(
         return false;
     }
     route
-        .nodes_replicas
+        .node_replicas
         .read()
         .get(&planned.src_node_id)
-        .is_some_and(|replica| {
-            !replica.tomb_tag.is_tomb()
-                && replica.tomb_tag.same_generation(&planned.src_tomb_tag)
-                && replica.backing.abs_addr() == planned.src_addr
-                && replica.backing.base_addr() == planned.src_base_addr
-                && replica.backing.len() == planned.len
+        .is_some_and(|replicas| {
+            !replicas.tomb_tag.is_tomb()
+                && replicas.tomb_tag.same_generation(&planned.src_tomb_tag)
+                && match planned.source_kind {
+                    GetSourceKind::Memory => replicas.memory.as_ref().is_some_and(|memory| {
+                        memory.backing.abs_addr() == planned.src_addr
+                            && memory.backing.base_addr() == planned.src_base_addr
+                            && memory.backing.len() == planned.len
+                    }),
+                    GetSourceKind::Ssd => replicas
+                        .ssd
+                        .as_ref()
+                        .is_some_and(|ssd| ssd.len == planned.len),
+                }
         })
 }
 
+fn allocate_ssd_source_stage(
+    view: &MasterKvRouterView,
+    source_node_id: &NodeID,
+    len: u64,
+) -> Result<Arc<Allocation>, msg_and_error::KvError> {
+    let allocators = view
+        .master_seg_manager()
+        .get_node_allocators(source_node_id);
+    if allocators.is_empty() {
+        return Err(msg_and_error::KvError::Unreachable(
+            msg_and_error::UnreachableError::OwnerNoSeg {
+                detail: format!("SSD source owner has no registered segment: {source_node_id}"),
+            },
+        ));
+    }
+    let allocator = allocators
+        .choose(&mut rand::thread_rng())
+        .expect("non-empty SSD source allocators");
+    for _ in 0..3 {
+        if let Ok(allocation) = allocator.allocate(len) {
+            return Ok(Arc::new(allocation));
+        }
+    }
+    let capacity = allocator.node_pool_capacity_snapshot();
+    Err(msg_and_error::KvError::Api(
+        msg_and_error::ApiError::NoSpace {
+            node: source_node_id.to_string(),
+            segment: allocator.seg_device_id.clone(),
+            total_capacity: capacity.active_capacity_bytes,
+            free_capacity: capacity.available_capacity_bytes,
+        },
+    ))
+}
+
 #[cfg(test)]
 mod planned_get_tests {
-    use super::{planned_get_source_is_current, snapshot_live_get_sources};
+    use super::{
+        planned_get_source_is_current, planned_get_source_rank, snapshot_live_get_sources,
+    };
     use crate::cluster_manager::NodeID;
+    use crate::config::SsdReadSourcePolicy;
+    use crate::master_kv_router::msg_pack::GetSourceKind;
     use crate::master_kv_router::{
-        CommittedSlotReplica, KvReplicaBacking, KvRouteInfo, OneKvNodesRoutes, PlannedGetInfo,
+        CommittedSlotReplica, KvMemoryReplica, KvNodeReplicas, KvReplicaBacking, KvSsdReplica,
+        OneKvNodesRoutes, PlannedGetInfo,
     };
     use crate::master_seg_manager::NodeTombTag;
     use parking_lot::RwLock;
@@ -325,24 +412,25 @@ mod planned_get_tests {
             put_id: (7, 3),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 source.clone(),
-                KvRouteInfo {
-                    node_id: source.clone(),
-                    backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
-                        owner_node_id: source.clone(),
-                        grant_id: 11,
-                        slot_index: 2,
-                        slot_size: 8192,
-                        addr: 0x3000,
-                        len: 4096,
-                        base_addr: 0x1000,
-                    }),
-                    owner_local_indexed: true,
-                    get_durable_reservation: None,
-                    capacity_reservation: None,
-                    tomb_tag: source_tag.clone(),
-                },
+                KvNodeReplicas::memory(
+                    source_tag.clone(),
+                    KvMemoryReplica {
+                        backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                            owner_node_id: source.clone(),
+                            grant_id: 11,
+                            slot_index: 2,
+                            slot_size: 8192,
+                            addr: 0x3000,
+                            len: 4096,
+                            base_addr: 0x1000,
+                        }),
+                        owner_local_indexed: true,
+                        get_durable_reservation: None,
+                        capacity_reservation: None,
+                    },
+                ),
             )])),
             get_durable_slots_used: AtomicU32::new(0),
         });
@@ -356,6 +444,7 @@ mod planned_get_tests {
             len: 4096,
             src_addr: 0x3000,
             src_base_addr: 0x1000,
+            source_kind: GetSourceKind::Memory,
             atomic_group: None,
         };
         (planned, route, source_tag)
@@ -367,10 +456,13 @@ mod planned_get_tests {
         assert!(planned_get_source_is_current(&planned, &route));
 
         route
-            .nodes_replicas
+            .node_replicas
             .write()
             .get_mut(&planned.src_node_id)
             .unwrap()
+            .memory
+            .as_mut()
+            .unwrap()
             .backing = KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
             owner_node_id: planned.src_node_id.clone(),
             grant_id: 11,
@@ -383,10 +475,13 @@ mod planned_get_tests {
         assert!(!planned_get_source_is_current(&planned, &route));
 
         route
-            .nodes_replicas
+            .node_replicas
             .write()
             .get_mut(&planned.src_node_id)
             .unwrap()
+            .memory
+            .as_mut()
+            .unwrap()
             .backing = KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
             owner_node_id: planned.src_node_id.clone(),
             grant_id: 11,
@@ -405,7 +500,7 @@ mod planned_get_tests {
         let (planned, route, _) = planned_route();
         let replacement_tag = NodeTombTag::new();
         route
-            .nodes_replicas
+            .node_replicas
             .write()
             .get_mut(&planned.src_node_id)
             .unwrap()
@@ -413,6 +508,37 @@ mod planned_get_tests {
         assert!(!planned_get_source_is_current(&planned, &route));
     }
 
+    #[test]
+    fn ssd_plan_and_bind_revalidate_the_same_owner_backing() {
+        let (mut planned, route, _) = planned_route();
+        planned.source_kind = GetSourceKind::Ssd;
+        planned.src_addr = 0;
+        planned.src_base_addr = 0;
+        let mut replicas = route.node_replicas.write();
+        let source = replicas.get_mut(&planned.src_node_id).unwrap();
+        source.memory = None;
+        source.ssd = Some(KvSsdReplica { len: planned.len });
+        drop(replicas);
+
+        let sources = snapshot_live_get_sources(&route);
+        assert_eq!(sources.len(), 1);
+        assert_eq!(sources[0].source_kind, GetSourceKind::Ssd);
+        assert_eq!(sources[0].addr, 0);
+        assert_eq!(sources[0].base_addr, 0);
+        assert!(planned_get_source_is_current(&planned, &route));
+
+        route
+            .node_replicas
+            .write()
+            .get_mut(&planned.src_node_id)
+            .unwrap()
+            .ssd
+            .as_mut()
+            .unwrap()
+            .len += 1;
+        assert!(!planned_get_source_is_current(&planned, &route));
+    }
+
     #[test]
     fn metadata_plan_does_not_retain_the_route() {
         let (planned, route, _) = planned_route();
@@ -423,6 +549,47 @@ mod planned_get_tests {
         assert_eq!(sources.len(), 1);
         assert_eq!(planned.key, "key");
     }
+
+    #[test]
+    fn ssd_read_source_policies_have_distinct_explicit_orders() {
+        let order = |policy| {
+            let classes = vec![
+                (GetSourceKind::Memory, false, "remote_memory"),
+                (GetSourceKind::Memory, true, "local_memory"),
+                (GetSourceKind::Ssd, false, "remote_ssd"),
+                (GetSourceKind::Ssd, true, "local_ssd"),
+            ];
+            let mut classes = classes
+                .into_iter()
+                .filter_map(|(kind, local, label)| {
+                    planned_get_source_rank(policy, kind, local).map(|rank| (rank, label))
+                })
+                .collect::<Vec<_>>();
+            classes.sort_by_key(|(rank, _)| *rank);
+            classes
+                .into_iter()
+                .map(|(_, label)| label)
+                .collect::<Vec<_>>()
+        };
+
+        assert_eq!(
+            order(SsdReadSourcePolicy::LegacyRemoteFirst),
+            ["remote_memory", "local_memory", "remote_ssd", "local_ssd"]
+        );
+        assert_eq!(
+            order(SsdReadSourcePolicy::LocalSsdOnlyFirst),
+            ["local_memory", "local_ssd", "remote_memory"]
+        );
+        assert_eq!(
+            planned_get_source_rank(
+                SsdReadSourcePolicy::LocalSsdOnlyFirst,
+                GetSourceKind::Ssd,
+                false,
+            ),
+            None,
+            "remote SSD must not be a fallback for the local-only policy"
+        );
+    }
 }
 
 async fn handle_get_plan_item(
@@ -478,14 +645,51 @@ async fn handle_get_plan_item(
 
     let local_owner =
         external_sink_local_owner_id(&view, &controller_node_id, controller.node_start_time);
-    let mut candidates = snapshot_live_get_sources(&route);
+    let source_policy = view
+        .master_kv_router()
+        .inner()
+        .test_spec_config
+        .ssd_read_source_policy;
+    let mut filtered_remote_ssd_items = 0u64;
+    let mut filtered_remote_ssd_bytes = 0u64;
+    let mut candidates = snapshot_live_get_sources(&route)
+        .into_iter()
+        .filter_map(|source| {
+            let requester_local = local_owner
+                .as_deref()
+                .is_some_and(|owner| source.node_id.as_ref() == owner);
+            match planned_get_source_rank(source_policy, source.source_kind, requester_local) {
+                Some(rank) => Some((source, rank)),
+                None => {
+                    filtered_remote_ssd_items = filtered_remote_ssd_items.saturating_add(1);
+                    filtered_remote_ssd_bytes =
+                        filtered_remote_ssd_bytes.saturating_add(source.len);
+                    None
+                }
+            }
+        })
+        .collect::<Vec<_>>();
+    if filtered_remote_ssd_items != 0 {
+        view.master_kv_router()
+            .inner()
+            .planned_get_counters
+            .remote_ssd_filtered_items
+            .fetch_add(filtered_remote_ssd_items, Ordering::Relaxed);
+        view.master_kv_router()
+            .inner()
+            .planned_get_counters
+            .remote_ssd_filtered_bytes
+            .fetch_add(filtered_remote_ssd_bytes, Ordering::Relaxed);
+    }
     candidates.shuffle(&mut rand::thread_rng());
-    candidates.sort_by_key(|replica| {
-        local_owner
-            .as_deref()
-            .is_some_and(|owner| replica.node_id.as_ref() == owner)
+    candidates.sort_by_key(|(_, rank)| *rank);
+    let has_remote_memory_alternative = candidates.iter().any(|(candidate, _)| {
+        candidate.source_kind == GetSourceKind::Memory
+            && local_owner
+                .as_deref()
+                .is_none_or(|owner| candidate.node_id.as_ref() != owner)
     });
-    let Some(source) = candidates.into_iter().next() else {
+    let Some((source, _)) = candidates.into_iter().next() else {
         view.master_kv_router()
             .inner()
             .planned_get_counters
@@ -495,15 +699,36 @@ async fn handle_get_plan_item(
             msg_and_error::ApiError::KeyNotFound { key },
         ));
     };
+    let selected_requester_local_ssd = source.source_kind == GetSourceKind::Ssd
+        && local_owner
+            .as_deref()
+            .is_some_and(|owner| source.node_id.as_ref() == owner);
+    if selected_requester_local_ssd {
+        let counters = &view.master_kv_router().inner().ssd_tier_counters;
+        let (items, bytes) = if has_remote_memory_alternative {
+            (
+                &counters.local_ssd_selected_with_remote_memory_items,
+                &counters.local_ssd_selected_with_remote_memory_bytes,
+            )
+        } else {
+            (
+                &counters.local_ssd_selected_without_remote_memory_items,
+                &counters.local_ssd_selected_without_remote_memory_bytes,
+            )
+        };
+        items.fetch_add(1, Ordering::Relaxed);
+        bytes.fetch_add(source.len, Ordering::Relaxed);
+    }
 
     let get_id = view
         .master_kv_router()
         .inner()
         .next_get_id
         .fetch_add(1, Ordering::Relaxed);
-    let gpu_direct_eligible = local_owner
-        .as_deref()
-        .is_none_or(|owner| source.node_id.as_ref() != owner);
+    let gpu_direct_eligible = source.source_kind == GetSourceKind::Memory
+        && local_owner
+            .as_deref()
+            .is_none_or(|owner| source.node_id.as_ref() != owner);
     let planned = super::PlannedGetInfo {
         put_id: route.put_id,
         src_node_id: source.node_id.clone(),
@@ -514,6 +739,7 @@ async fn handle_get_plan_item(
         len: source.len,
         src_addr: source.addr,
         src_base_addr: source.base_addr,
+        source_kind: source.source_kind,
         atomic_group: route.atomic_group.as_deref().cloned(),
     };
     drop(route);
@@ -534,6 +760,7 @@ async fn handle_get_plan_item(
         src_addr: planned.src_addr,
         src_base_addr: planned.src_base_addr,
         len: planned.len,
+        source_kind: planned.source_kind,
         atomic_group: planned.atomic_group,
         gpu_direct_eligible,
         error_code: msg_and_error::OK,
@@ -570,6 +797,7 @@ fn bound_get_start_item(get_id: u64, info: &InflightGetInfo) -> BatchGetStartIte
         target_base_addr: info.target.base_addr(),
         src_base_addr: info.src_base_addr,
         len: info.len,
+        source_kind: info.source_kind,
         prepared_target: match &info.target {
             InflightGetTarget::PreparedLocalReserveSlot(slot) => {
                 Some(GetPreparedLocalReserveTarget {
@@ -639,6 +867,16 @@ async fn handle_get_bind_item(
     let (target, target_tomb_tag, allocation_mode, prepared_requester_lease) = match &request.target
     {
         GetBindTarget::ExternalSink(target) => {
+            if planned.source_kind == GetSourceKind::Ssd {
+                return get_bind_item_error(
+                    get_id,
+                    &msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+                        detail: format!(
+                            "SSD Get source requires owner-local CPU staging before an external GPU sink: get_id={get_id}"
+                        ),
+                    }),
+                );
+            }
             if req_node_id != planned.controller_node_id {
                 return get_bind_item_error(
                     get_id,
@@ -755,10 +993,10 @@ async fn handle_get_bind_item(
     };
     if matches!(&request.target, GetBindTarget::PreparedLocalReserve(_))
         && current_route
-            .nodes_replicas
+            .node_replicas
             .read()
             .get(&req_node_id)
-            .is_some_and(|replica| !replica.tomb_tag.is_tomb())
+            .is_some_and(|replica| !replica.tomb_tag.is_tomb() && replica.memory.is_some())
     {
         return get_bind_item_error(
             get_id,
@@ -771,6 +1009,22 @@ async fn handle_get_bind_item(
         );
     }
 
+    let (src_addr, src_base_addr, ssd_source_allocation) = match planned.source_kind {
+        GetSourceKind::Memory => (planned.src_addr, planned.src_base_addr, None),
+        GetSourceKind::Ssd => {
+            let allocation =
+                match allocate_ssd_source_stage(&view, &planned.src_node_id, planned.len) {
+                    Ok(allocation) => allocation,
+                    Err(err) => return get_bind_item_error(get_id, &err),
+                };
+            (
+                allocation.base_addr() + allocation.addr(),
+                allocation.base_addr(),
+                Some(allocation),
+            )
+        }
+    };
+
     let Some(planned) = view
         .master_kv_router()
         .inner()
@@ -792,8 +1046,12 @@ async fn handle_get_bind_item(
         req_node_id: req_node_id.clone(),
         controller_node_id: Some(planned.controller_node_id),
         len: planned.len,
-        src_addr: planned.src_addr,
-        src_base_addr: planned.src_base_addr,
+        src_addr,
+        src_base_addr,
+        source_kind: planned.source_kind,
+        ssd_source_allocation,
+        ssd_stage_lifecycle: (planned.source_kind == GetSourceKind::Ssd)
+            .then(|| Arc::new(super::SsdStageLifecycle::new())),
         atomic_group: planned.atomic_group,
         target,
         target_tomb_tag,
@@ -809,6 +1067,8 @@ async fn handle_get_bind_item(
         inflight.src_node_id.as_ref(),
         inflight.len,
         allocation_mode,
+        inflight.source_kind,
+        inflight.src_node_id == inflight.req_node_id,
     );
     view.master_kv_router()
         .inner()
@@ -820,7 +1080,7 @@ async fn handle_get_bind_item(
         .planned_get_counters
         .bind_succeeded
         .fetch_add(1, Ordering::Relaxed);
-    if current_route.lease_id.is_none() {
+    if current_route.lease_id.is_none() && planned.source_kind == GetSourceKind::Memory {
         touch_moka_for_node(view, response.node_id.to_string(), planned.key);
     }
     response
@@ -880,7 +1140,7 @@ pub async fn handle_get_start(
             let mut remove_in_kv_routes = false;
             if let Some(one_kv_nodes_routes) = view.master_kv_router().inner().kv_routes.get(key) {
                 one_kv_nodes_routes.clean_up_tomb_nodes_replicas(put_id, tombs, view);
-                if one_kv_nodes_routes.nodes_replicas.read().is_empty() {
+                if one_kv_nodes_routes.node_replicas.read().is_empty() {
                     remove_in_kv_routes = true;
                 }
             }
@@ -966,30 +1226,44 @@ pub async fn handle_get_start(
         return failed_resp_err(err, None, &view, &req.serialize_part.key);
     };
 
-    let replicas: HashMap<NodeID, KvRouteInfo> = one_kv_nodes_routes.nodes_replicas.read().clone();
+    let replicas: HashMap<NodeID, KvNodeReplicas> =
+        one_kv_nodes_routes.node_replicas.read().clone();
     let prepared_target = req.serialize_part.prepared_target.clone();
     let external_sink_target = req.serialize_part.external_sink_target.clone();
     let external_sink_local_owner = external_sink_target.as_ref().and_then(|target| {
         external_sink_local_owner_id(&view, &req_node_id, target.requester_node_start_time)
     });
-    // Currently we are holding the lock with `replicas`
-    // 选择一个replica (这里可以实现更复杂的选择逻辑)
-    let mut replica_keys = replicas.keys().collect::<Vec<_>>();
-    let mut tombs = HashSet::new();
+    let mut tombs = replicas
+        .iter()
+        .filter_map(|(node_id, replicas)| replicas.tomb_tag.is_tomb().then_some(node_id.clone()))
+        .collect::<HashSet<_>>();
+    let mut memory_sources = replicas
+        .iter()
+        .filter_map(|(node_id, replicas)| {
+            (!replicas.tomb_tag.is_tomb() && replicas.memory.is_some())
+                .then_some((node_id.clone(), GetSourceKind::Memory))
+        })
+        .collect::<Vec<_>>();
+    let mut ssd_sources = replicas
+        .iter()
+        .filter_map(|(node_id, replicas)| {
+            (!replicas.tomb_tag.is_tomb() && replicas.memory.is_none() && replicas.ssd.is_some())
+                .then_some((node_id.clone(), GetSourceKind::Ssd))
+        })
+        .collect::<Vec<_>>();
+    memory_sources.shuffle(&mut rand::thread_rng());
+    ssd_sources.shuffle(&mut rand::thread_rng());
+    memory_sources.extend(ssd_sources);
     let mut target = None;
     let mut allocation_mode = GetAllocationMode::Temporary;
     let mut durable_reservation = None;
-    for _ in 0..replicas.len() {
-        let to_remove_idx = rand::thread_rng().gen_range(0..replica_keys.len());
-        let selected_replica_key = replica_keys.remove(to_remove_idx);
-        let selected_replica = replicas.get(&*selected_replica_key).unwrap();
-        if selected_replica.tomb_tag.is_tomb() {
-            tombs.insert(selected_replica_key.to_owned());
-            continue;
-        }
+    for (selected_replica_key, source_kind) in memory_sources {
+        let selected_replicas = replicas
+            .get(&selected_replica_key)
+            .expect("selected Get source must exist");
         if external_sink_local_owner
             .as_deref()
-            .is_some_and(|owner_id| selected_replica.node_id.as_ref() == owner_id)
+            .is_some_and(|owner_id| selected_replica_key.as_ref() == owner_id)
         {
             // The explicit GPU path is RDMA-only. The requester's share-group
             // owner is local IPC/P2P topology, whose fallback would require
@@ -997,10 +1271,47 @@ pub async fn handle_get_start(
             // ordinary CPU-buffered Get path and search for a remote route.
             continue;
         }
-        let src_node_id = selected_replica.node_id.clone();
-        let src_len = selected_replica.backing.len();
-        let src_abs_addr = selected_replica.backing.abs_addr();
-        let src_base = selected_replica.backing.base_addr();
+        if source_kind == GetSourceKind::Ssd && external_sink_target.is_some() {
+            continue;
+        }
+        let src_node_id = selected_replica_key;
+        let (src_len, src_abs_addr, src_base, ssd_source_allocation) = match source_kind {
+            GetSourceKind::Memory => {
+                let selected_replica = selected_replicas
+                    .memory
+                    .as_ref()
+                    .expect("memory source candidate must retain memory");
+                (
+                    selected_replica.backing.len(),
+                    selected_replica.backing.abs_addr(),
+                    selected_replica.backing.base_addr(),
+                    None,
+                )
+            }
+            GetSourceKind::Ssd => {
+                let ssd = selected_replicas
+                    .ssd
+                    .as_ref()
+                    .expect("SSD source candidate must retain SSD");
+                let allocation = match allocate_ssd_source_stage(&view, &src_node_id, ssd.len) {
+                    Ok(allocation) => allocation,
+                    Err(err) => {
+                        return failed_resp_err(
+                            err,
+                            Some((tombs.clone(), one_kv_nodes_routes.put_id)),
+                            &view,
+                            &req.serialize_part.key,
+                        );
+                    }
+                };
+                (
+                    ssd.len,
+                    allocation.base_addr() + allocation.addr(),
+                    allocation.base_addr(),
+                    Some(allocation),
+                )
+            }
+        };
 
         // For committed-slot replicas on the requester node, we still allocate a
         // normal target buffer here instead of reusing the committed slot as a
@@ -1045,14 +1356,12 @@ pub async fn handle_get_start(
                     }
                     if allocated_addr.is_none() {
                         tracing::info!("No space left for target(Requesting node) allocation");
-                        let total = target_allocator.total_size_bytes();
-                        let used = target_allocator.used_size_bytes();
-                        let free = total.saturating_sub(used);
+                        let capacity = target_allocator.node_pool_capacity_snapshot();
                         let err = msg_and_error::KvError::Api(msg_and_error::ApiError::NoSpace {
                             node: req_node_id.as_ref().to_string(),
                             segment: target_allocator.seg_device_id.clone(),
-                            total_capacity: total,
-                            free_capacity: free,
+                            total_capacity: capacity.active_capacity_bytes,
+                            free_capacity: capacity.available_capacity_bytes,
                         });
                         return Err(failed_resp_err(
                             err,
@@ -1092,10 +1401,9 @@ pub async fn handle_get_start(
                     allocation_mode = GetAllocationMode::ExternalSink;
                     InflightGetTarget::ExternalSink(external_sink_target.clone())
                 } else if let Some(prepared_target) = prepared_target.as_ref() {
-                    if replicas
-                        .get(&req_node_id)
-                        .is_some_and(|replica| !replica.tomb_tag.is_tomb())
-                    {
+                    if replicas.get(&req_node_id).is_some_and(|replicas| {
+                        !replicas.tomb_tag.is_tomb() && replicas.memory.is_some()
+                    }) {
                         let err = msg_and_error::KvError::Api(
                             msg_and_error::ApiError::InvalidArgument {
                                 detail: format!(
@@ -1129,7 +1437,11 @@ pub async fn handle_get_start(
                     };
                     allocation_mode = GetAllocationMode::LocalCommittedSlot;
                     InflightGetTarget::PreparedLocalReserveSlot(slot)
-                } else if let Some(replica_on_recv_node) = replicas.get(&req_node_id) {
+                } else if let Some(replica_on_recv_node) = replicas
+                    .get(&req_node_id)
+                    .filter(|replicas| !replicas.tomb_tag.is_tomb())
+                    .and_then(|replicas| replicas.memory.as_ref())
+                {
                     match &replica_on_recv_node.backing {
                         super::KvReplicaBacking::Allocation(allocation) => {
                             allocation_mode = GetAllocationMode::ReuseReplica;
@@ -1219,6 +1531,7 @@ pub async fn handle_get_start(
             src_base_addr: resp_src_base,
             target_base_addr: resp_target_base,
             len: src_len,
+            source_kind,
             prepared_target: (allocation_mode == GetAllocationMode::LocalCommittedSlot)
                 .then(|| prepared_target.clone())
                 .flatten(),
@@ -1232,6 +1545,8 @@ pub async fn handle_get_start(
             resp_node_id.as_ref(),
             src_len,
             allocation_mode,
+            source_kind,
+            src_node_id == req_node_id,
         );
         // 创建在途的Get操作信息
         let info = InflightGetInfo {
@@ -1243,6 +1558,10 @@ pub async fn handle_get_start(
             len: src_len,
             src_addr: resp_src_addr,
             src_base_addr: resp_src_base,
+            source_kind,
+            ssd_source_allocation,
+            ssd_stage_lifecycle: (source_kind == GetSourceKind::Ssd)
+                .then(|| Arc::new(super::SsdStageLifecycle::new())),
             atomic_group: one_kv_nodes_routes.atomic_group.as_deref().cloned(),
             target,
             target_tomb_tag,
@@ -1263,7 +1582,7 @@ pub async fn handle_get_start(
         // source node's moka to keep the kv alive during transfer (weight=0 => touch).
         // For leased keys, there should be no moka entry; skip touching to avoid
         // unnecessary cache work.
-        if one_kv_nodes_routes.lease_id.is_none() {
+        if one_kv_nodes_routes.lease_id.is_none() && source_kind == GetSourceKind::Memory {
             touch_moka_for_node(
                 view.clone(),
                 src_node_id.to_string(),
@@ -1298,6 +1617,179 @@ pub async fn handle_get_start(
     }
 }
 
+pub async fn handle_ssd_stage_begin(
+    view: MasterKvRouterView,
+    req: MsgPack<SsdStageBeginReq>,
+    req_node_id: NodeID,
+) -> MsgPack<SsdStageBeginResp> {
+    let get_id = req.serialize_part.get_id;
+    let operation_lock = view
+        .master_kv_router()
+        .inner()
+        .get_done_locks
+        .get_lock(get_id);
+    let _operation_guard = operation_lock.lock().await;
+    let result = view
+        .master_kv_router()
+        .inner()
+        .inflight_gets
+        .get(&get_id)
+        .await
+        .and_then(|inflight| {
+            (inflight.source_kind == GetSourceKind::Ssd
+                && inflight.src_node_id == req_node_id
+                && inflight.ssd_source_allocation.is_some())
+            .then(|| inflight.ssd_stage_lifecycle.as_ref().cloned())
+            .flatten()
+        })
+        .is_some_and(|lifecycle| lifecycle.begin());
+    MsgPack {
+        serialize_part: SsdStageBeginResp {
+            started: result,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+pub async fn handle_ssd_stage_done(
+    view: MasterKvRouterView,
+    req: MsgPack<SsdStageDoneReq>,
+    req_node_id: NodeID,
+) -> MsgPack<SsdStageDoneResp> {
+    let get_id = req.serialize_part.get_id;
+    let operation_lock = view
+        .master_kv_router()
+        .inner()
+        .get_done_locks
+        .get_lock(get_id);
+    let _operation_guard = operation_lock.lock().await;
+    let Some(inflight) = view
+        .master_kv_router()
+        .inner()
+        .inflight_gets
+        .get(&get_id)
+        .await
+    else {
+        return MsgPack {
+            serialize_part: SsdStageDoneResp {
+                error_code: msg_and_error::OK,
+                error_json: String::new(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    };
+    if inflight.source_kind != GetSourceKind::Ssd
+        || !ssd_stage_done_request_authorized(
+            &inflight.src_node_id,
+            &inflight.req_node_id,
+            &req_node_id,
+            req.serialize_part.drop_ssd_source,
+        )
+    {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: format!(
+                "SSD stage terminal requester mismatch: get_id={} source={} target={} got={} drop_ssd_source={}",
+                get_id,
+                inflight.src_node_id,
+                inflight.req_node_id,
+                req_node_id,
+                req.serialize_part.drop_ssd_source,
+            ),
+        });
+        return MsgPack {
+            serialize_part: SsdStageDoneResp {
+                error_code: err.code(),
+                error_json: err.to_json(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+    if let Some(lifecycle) = inflight.ssd_stage_lifecycle.as_ref() {
+        lifecycle.finish();
+    }
+
+    let mut removed_empty_route = None;
+    if req.serialize_part.drop_ssd_source {
+        let route = inflight.route.clone();
+        if route.put_id == inflight.put_id && route.remove_ssd_replica(&inflight.src_node_id) {
+            let key = inflight.key.clone();
+            if route.node_replicas.read().is_empty()
+                && view
+                    .master_kv_router()
+                    .inner()
+                    .kv_routes
+                    .remove_if(&key, |_, current| {
+                        Arc::ptr_eq(current, &route)
+                            && current.put_id == inflight.put_id
+                            && current.node_replicas.read().is_empty()
+                    })
+                    .is_some()
+            {
+                removed_empty_route = Some((key, inflight.put_id));
+            }
+        }
+    }
+    drop(inflight);
+    if let Some((key, put_id)) = removed_empty_route
+        && view.master_kv_router().prefix_index_enabled()
+    {
+        view.master_kv_router()
+            .inner()
+            .prefix_index
+            .write()
+            .await
+            .remove(&key, put_id);
+    }
+
+    MsgPack {
+        serialize_part: SsdStageDoneResp {
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
+fn ssd_stage_done_request_authorized(
+    source_node_id: &NodeID,
+    target_node_id: &NodeID,
+    requester_node_id: &NodeID,
+    drop_ssd_source: bool,
+) -> bool {
+    requester_node_id == source_node_id || (!drop_ssd_source && requester_node_id == target_node_id)
+}
+
+#[cfg(test)]
+mod ssd_stage_done_authorization_tests {
+    use super::ssd_stage_done_request_authorized;
+    use crate::cluster_manager::NodeID;
+
+    #[test]
+    fn source_may_close_or_drop_but_target_may_only_close() {
+        let source: NodeID = "cpu-source".to_string().into();
+        let target: NodeID = "gpu-target".to_string().into();
+        let stranger: NodeID = "other-owner".to_string().into();
+
+        assert!(ssd_stage_done_request_authorized(
+            &source, &target, &source, false
+        ));
+        assert!(ssd_stage_done_request_authorized(
+            &source, &target, &source, true
+        ));
+        assert!(ssd_stage_done_request_authorized(
+            &source, &target, &target, false
+        ));
+        assert!(!ssd_stage_done_request_authorized(
+            &source, &target, &target, true
+        ));
+        assert!(!ssd_stage_done_request_authorized(
+            &source, &target, &stranger, false
+        ));
+    }
+}
+
 pub async fn handle_get_revoke(
     view: MasterKvRouterView,
     req: MsgPack<GetRevokeReq>,
@@ -1311,7 +1803,27 @@ pub async fn handle_get_revoke(
         .inner()
         .get_done_locks
         .get_lock(get_id);
-    let _done_guard = done_lock.lock().await;
+    let _done_guard = loop {
+        let guard = done_lock.lock().await;
+        let active_lifecycle = view
+            .master_kv_router()
+            .inner()
+            .inflight_gets
+            .get(&get_id)
+            .await
+            .and_then(|inflight| {
+                inflight
+                    .ssd_stage_lifecycle
+                    .as_ref()
+                    .filter(|lifecycle| lifecycle.is_active())
+                    .cloned()
+            });
+        let Some(lifecycle) = active_lifecycle else {
+            break guard;
+        };
+        drop(guard);
+        lifecycle.wait_until_not_active().await;
+    };
 
     if let Some(planned) = view
         .master_kv_router()
@@ -1695,8 +2207,7 @@ async fn handle_get_done_locked(
                         target_cap,
                     ) {
                         Ok(capacity_reservation) => {
-                            let replica = KvRouteInfo {
-                                node_id: req_node_id.clone(),
+                            let replica = KvMemoryReplica {
                                 backing: super::KvReplicaBacking::Allocation(match &inflight_info
                                     .target
                                 {
@@ -1711,12 +2222,12 @@ async fn handle_get_done_locked(
                                 owner_local_indexed: true,
                                 get_durable_reservation: inflight_info.durable_reservation.clone(),
                                 capacity_reservation,
-                                tomb_tag: target_tomb_tag.clone(),
                             };
                             if publish_route_replica_tomb_fenced(
                                 &one_kv_nodes_routes,
                                 req_node_id.clone(),
                                 replica,
+                                target_tomb_tag.clone(),
                             ) {
                                 promote_committed = true;
                                 route_publish_event = Some(RoutePublishEvent::replica_append(
@@ -1787,20 +2298,26 @@ async fn handle_get_done_locked(
                     {
                         if current_route.put_id == inflight_info.put_id {
                             route_lease_id = current_route.lease_id;
-                            let mut replicas = current_route.nodes_replicas.write();
-                            if let Some(replica) = replicas.get_mut(&req_node_id) {
-                                local_index_published = !replica.tomb_tag.is_tomb()
-                                    && replica.tomb_tag.same_generation(target_tomb_tag)
-                                    && matches!(
-                                        &replica.backing,
-                                        super::KvReplicaBacking::Allocation(allocation)
-                                            if matches!(
-                                                &inflight_info.target,
-                                                InflightGetTarget::Allocation(target)
-                                                    if Arc::ptr_eq(allocation, target)
-                                            )
-                                    );
+                            let mut replicas = current_route.node_replicas.write();
+                            if let Some(node_replicas) = replicas.get_mut(&req_node_id) {
+                                local_index_published = !node_replicas.tomb_tag.is_tomb()
+                                    && node_replicas.tomb_tag.same_generation(target_tomb_tag)
+                                    && node_replicas.memory.as_ref().is_some_and(|replica| {
+                                        matches!(
+                                            &replica.backing,
+                                            super::KvReplicaBacking::Allocation(allocation)
+                                                if matches!(
+                                                    &inflight_info.target,
+                                                    InflightGetTarget::Allocation(target)
+                                                        if Arc::ptr_eq(allocation, target)
+                                                )
+                                        )
+                                    });
                                 if local_index_published {
+                                    let replica = node_replicas
+                                        .memory
+                                        .as_mut()
+                                        .expect("matched live memory replica");
                                     replica.owner_local_indexed = true;
                                     replica.capacity_reservation = capacity_reservation;
                                 }
@@ -1867,18 +2384,17 @@ async fn handle_get_done_locked(
             let mut route_publish_event = None;
             if let Some(current_route) = view.master_kv_router().inner().kv_routes.get(&key) {
                 if current_route.put_id == inflight_info.put_id {
-                    let replica = KvRouteInfo {
-                        node_id: req_node_id.clone(),
+                    let replica = KvMemoryReplica {
                         backing: super::KvReplicaBacking::CommittedSlot(slot),
                         owner_local_indexed: true,
                         get_durable_reservation: None,
                         capacity_reservation: None,
-                        tomb_tag: target_tomb_tag.clone(),
                     };
                     if publish_route_replica_tomb_fenced(
                         &current_route,
                         req_node_id.clone(),
                         replica,
+                        target_tomb_tag.clone(),
                     ) {
                         published = true;
                         route_publish_event = Some(RoutePublishEvent::replica_append(
@@ -2118,15 +2634,22 @@ pub async fn handle_get_meta(
         .get(&req.serialize_part.key)
     {
         // lock and clone, release the lock quickly
-        let nodes_replicas: HashMap<NodeID, KvRouteInfo> =
-            (*one_kv_nodes_routes.nodes_replicas.read()).clone();
+        let node_replicas: HashMap<NodeID, KvNodeReplicas> =
+            (*one_kv_nodes_routes.node_replicas.read()).clone();
 
         // Key exists, get metadata from the first replica
-        for (_, kv_info) in nodes_replicas.iter() {
-            if kv_info.tomb_tag.is_tomb() {
+        for replicas in node_replicas.values() {
+            if replicas.tomb_tag.is_tomb() {
                 continue;
             }
-            let len = kv_info.backing.len();
+            let Some(len) = replicas
+                .memory
+                .as_ref()
+                .map(|memory| memory.backing.len())
+                .or_else(|| replicas.ssd.as_ref().map(|ssd| ssd.len))
+            else {
+                continue;
+            };
             return MsgPack {
                 serialize_part: GetMetaResp {
                     exists: true,
@@ -2308,6 +2831,7 @@ pub async fn handle_batch_get_start(
             target_base_addr: part.target_base_addr,
             src_base_addr: part.src_base_addr,
             len: part.len,
+            source_kind: part.source_kind,
             prepared_target: part.prepared_target,
             atomic_group: part.atomic_group,
             error_code: part.error_code,
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
index d5c43ee..f09f84e 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/mod.rs
@@ -17,27 +17,29 @@ use self::{
     get::{
         handle_batch_get_bind, handle_batch_get_done, handle_batch_get_plan,
         handle_batch_get_revoke, handle_batch_get_start, handle_batch_is_exist, handle_get_done,
-        handle_get_meta, handle_get_revoke, handle_get_start,
+        handle_get_meta, handle_get_revoke, handle_get_start, handle_ssd_stage_begin,
+        handle_ssd_stage_done,
     },
     msg_pack::{
         BatchDeleteAckReq, BatchDeleteClientKvMetaCacheReq, BatchEnqueueReplicaTaskReq,
         BatchEvictOwnerSourceReq, BatchGetBindReq, BatchGetDoneReq, BatchGetPlanReq,
         BatchGetRevokeReq, BatchGetStartReq, BatchIsExistReq, BatchOwnerReclaimReq,
-        BatchPreparePutKeysReq, BatchPutAppendDoneReq, BatchPutAppendStartReq, BatchPutDoneReq,
-        BatchPutRevokeReq, BatchPutStartReq, BatchReleasePutKeyReservationsReq, CountPrefixReq,
-        CountPrefixResp, DeleteAckReq, DeleteReq, GetAllocationMode, GetDoneReq, GetDoneResp,
-        GetMetaReq, GetRevokeReq, GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimItem,
-        PutAppendDoneReq, PutAppendRevokeReq, PutAppendStartReq, PutAtomicGroup, PutDoneReq,
-        PutRevokeReq, PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq,
+        BatchPreparePutKeysReq, BatchPublishOwnerSsdReq, BatchPutAppendDoneReq,
+        BatchPutAppendStartReq, BatchPutDoneReq, BatchPutRevokeReq, BatchPutStartReq,
+        BatchReleasePutKeyReservationsReq, CountPrefixReq, CountPrefixResp, DeleteAckReq,
+        DeleteReq, GetAllocationMode, GetDoneReq, GetDoneResp, GetMetaReq, GetRevokeReq,
+        GetSourceKind, GetStartReq, GroupedBatchPutDoneReq, OwnerReclaimItem, PutAppendDoneReq,
+        PutAppendRevokeReq, PutAppendStartReq, PutAtomicGroup, PutDoneReq, PutRevokeReq,
+        PutStartReq, ReleaseLocalGrantReq, ReserveLocalGrantReq, SsdStageBeginReq, SsdStageDoneReq,
     },
     placement::{PlacementPolicy, build_placement_policy},
     put::{
-        handle_batch_prepare_put_keys, handle_batch_put_append_done, handle_batch_put_append_start,
-        handle_batch_put_done, handle_batch_put_revoke, handle_batch_put_start,
-        handle_batch_release_put_key_reservations, handle_grouped_batch_put_done,
-        handle_put_append_done, handle_put_append_revoke, handle_put_append_start, handle_put_done,
-        handle_put_revoke, handle_put_start, handle_release_local_grant,
-        handle_reserve_local_grant,
+        handle_batch_prepare_put_keys, handle_batch_publish_owner_ssd,
+        handle_batch_put_append_done, handle_batch_put_append_start, handle_batch_put_done,
+        handle_batch_put_revoke, handle_batch_put_start, handle_batch_release_put_key_reservations,
+        handle_grouped_batch_put_done, handle_put_append_done, handle_put_append_revoke,
+        handle_put_append_start, handle_put_done, handle_put_revoke, handle_put_start,
+        handle_release_local_grant, handle_reserve_local_grant,
     },
     reclaim::handle_batch_evict_owner_source,
 };
@@ -53,16 +55,20 @@ use crate::master_lease_manager::{MasterLeaseManager, MasterLeaseManagerAccessTr
 use crate::master_seg_manager::MasterSegManager;
 use crate::master_seg_manager::MasterSegManagerAccessTrait;
 use crate::master_seg_manager::NodeTombTag;
-use crate::master_seg_manager::one_seg_allocator::Allocation;
+use crate::master_seg_manager::one_seg_allocator::{Allocation, NodePoolCapacitySnapshot};
 use crate::memholder::{EnsureMemholderMgmtDeleteHandle, MasterOwnerMemMgr, MemholderManagerTrait};
 use crate::metric_reporter::{MetricReporter, MetricReporterAccessTrait};
 use crate::p2p::msg_pack::{MsgPack, RPCCaller, RPCHandler};
-use crate::p2p::p2p_module::{P2pModule, P2pModuleAccessTrait};
-use crate::rpcresp_kvresult_convert::msg_and_error::{KvError, OK};
+use crate::p2p::p2p_module::{
+    P2pModule, P2pModuleAccessTrait, UserRpcAsyncHandler, UserRpcFuture,
+    user_rpc_register_handler_async,
+};
+use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult, OK};
 use fluxon_framework::{LogicalModule, define_module};
 use fluxon_util::map_lock::AMapLock;
 use fluxon_util::pin_aware_moka::{PinAwareMoka, PinGuard};
 
+use ::tokio::sync::watch;
 use async_trait::async_trait;
 use chrono::Utc;
 use dashmap::{DashMap, DashSet};
@@ -71,6 +77,7 @@ use limit_thirdparty::tokio::{self, sync::ampsc};
 use moka::notification::RemovalCause;
 use parking_lot::Mutex;
 use parking_lot::RwLock;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
@@ -84,6 +91,7 @@ const INFLIGHT_PUT_TTL_SECONDS: u64 = 60;
 const INFLIGHT_PUT_TTL_SECONDS_SKIP_PUT_END_COMMIT: u64 = 5;
 const POST_ROUTE_MAINTENANCE_QUEUE_CAPACITY: usize = 512;
 const TIER1_WRITEBACK_QUEUE_CAPACITY: usize = 4096;
+pub const NODE_POOL_CAPACITY_USER_RPC_PATH: &str = "fluxon_kv/node_pool_capacity";
 
 fn subtract_pending_eviction_weight(
     pending_weight: &AtomicU64,
@@ -300,6 +308,14 @@ pub struct RequesterTargetPair {
 #[derive(Clone, Debug, Default)]
 pub struct ReplicaCacheNodeObserveSnapshot {
     pub owner_node: String,
+    pub owner_node_start_time: i64,
+    pub pool_physical_capacity_bytes: u64,
+    pub pool_active_capacity_bytes: u64,
+    pub pool_used_capacity_bytes: u64,
+    pub pool_parked_capacity_bytes: u64,
+    pub pool_draining_capacity_bytes: u64,
+    pub pool_available_capacity_bytes: u64,
+    pub pool_capacity_epoch: u64,
     pub entries: u64,
     pub weighted_bytes: u64,
     pub effective_capacity_bytes: u64,
@@ -343,6 +359,93 @@ pub struct MasterRuntimeObserveSnapshot {
     pub replica_cache_nodes: Vec<ReplicaCacheNodeObserveSnapshot>,
 }
 
+/// Generation- and epoch-fenced runtime control request for one owner's preallocated pool.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)]
+pub enum NodePoolCapacityControlRequest {
+    Get {
+        owner_node_id: String,
+    },
+    SetActive {
+        owner_node_id: String,
+        expected_owner_node_start_time: i64,
+        expected_capacity_epoch: u64,
+        active_capacity_bytes: u64,
+    },
+}
+
+/// One coherent snapshot returned by both query and mutation operations.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct NodePoolCapacityControlResponse {
+    pub owner_node_id: String,
+    pub owner_node_start_time: i64,
+    pub physical_capacity_bytes: u64,
+    pub active_capacity_bytes: u64,
+    pub used_capacity_bytes: u64,
+    pub parked_capacity_bytes: u64,
+    pub draining_capacity_bytes: u64,
+    pub available_capacity_bytes: u64,
+    pub capacity_epoch: u64,
+    pub ring_b_base_capacity_bytes: u64,
+    pub ring_b_effective_capacity_bytes: u64,
+    pub ring_b_weighted_bytes: u64,
+    pub ring_b_pending_reclaim_bytes: u64,
+    pub tier1_capacity_bytes: u64,
+    pub settled: bool,
+}
+
+struct NodePoolCapacityUserRpcHandler {
+    view: MasterKvRouterView,
+}
+
+impl UserRpcAsyncHandler for NodePoolCapacityUserRpcHandler {
+    fn handle(&self, from_node: NodeID, payload: Vec<u8>) -> UserRpcFuture {
+        let view = self.view.clone();
+        Box::pin(async move {
+            let request: NodePoolCapacityControlRequest = serde_json::from_slice(&payload)
+                .map_err(|err| {
+                    KvError::Api(ApiError::InvalidArgument {
+                        detail: format!("invalid node pool capacity request: {err}"),
+                    })
+                })?;
+            let response = match request {
+                NodePoolCapacityControlRequest::Get { owner_node_id } => view
+                    .master_kv_router()
+                    .node_pool_capacity_control_snapshot(&owner_node_id)?,
+                NodePoolCapacityControlRequest::SetActive {
+                    owner_node_id,
+                    expected_owner_node_start_time,
+                    expected_capacity_epoch,
+                    active_capacity_bytes,
+                } => {
+                    tracing::info!(
+                        caller = %from_node,
+                        owner = %owner_node_id,
+                        expected_owner_node_start_time,
+                        expected_capacity_epoch,
+                        active_capacity_bytes,
+                        "applying node pool active capacity"
+                    );
+                    view.master_kv_router()
+                        .set_node_pool_active_capacity(
+                            owner_node_id.into(),
+                            expected_owner_node_start_time,
+                            expected_capacity_epoch,
+                            active_capacity_bytes,
+                        )
+                        .await?
+                }
+            };
+            serde_json::to_vec(&response).map_err(|err| {
+                KvError::Api(ApiError::Unknown {
+                    detail: format!("serialize node pool capacity response failed: {err}"),
+                })
+            })
+        })
+    }
+}
+
 impl RequesterTargetPair {
     fn new(requester_node_id: &str, target_node_id: &str) -> Self {
         Self {
@@ -435,6 +538,10 @@ pub struct InflightGetInfo {
     pub len: u64,
     pub src_addr: u64,
     pub src_base_addr: u64,
+    pub source_kind: crate::master_kv_router::msg_pack::GetSourceKind,
+    /// Registered source staging owned by the master only for SSD reads.
+    pub ssd_source_allocation: Option<Arc<Allocation>>,
+    pub(crate) ssd_stage_lifecycle: Option<Arc<SsdStageLifecycle>>,
     pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
     pub target: InflightGetTarget,
     /// Exact requester segment-registration generation that owns an
@@ -451,6 +558,70 @@ pub struct InflightGetInfo {
     pub(crate) _prepared_requester_lease: Option<Arc<PreparedGetRequesterLease>>,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum SsdStagePhase {
+    NotStarted,
+    Active,
+    Quiescent,
+}
+
+pub(crate) struct SsdStageLifecycle {
+    phase: Mutex<SsdStagePhase>,
+    phase_changed: watch::Sender<SsdStagePhase>,
+}
+
+impl SsdStageLifecycle {
+    fn new() -> Self {
+        let (phase_changed, _receiver) = watch::channel(SsdStagePhase::NotStarted);
+        Self {
+            phase: Mutex::new(SsdStagePhase::NotStarted),
+            phase_changed,
+        }
+    }
+
+    pub(crate) fn begin(&self) -> bool {
+        let mut phase = self.phase.lock();
+        match *phase {
+            SsdStagePhase::NotStarted => {
+                *phase = SsdStagePhase::Active;
+                self.phase_changed.send_replace(SsdStagePhase::Active);
+                true
+            }
+            // An RPC response can be lost after the master accepted Begin.
+            // Replaying the exact source/get operation must not make the owner
+            // abandon a stage which the master already considers active.
+            SsdStagePhase::Active => true,
+            SsdStagePhase::Quiescent => false,
+        }
+    }
+
+    pub(crate) fn finish(&self) -> bool {
+        let mut phase = self.phase.lock();
+        if *phase != SsdStagePhase::Active {
+            return false;
+        }
+        *phase = SsdStagePhase::Quiescent;
+        self.phase_changed.send_replace(SsdStagePhase::Quiescent);
+        true
+    }
+
+    pub(crate) fn is_active(&self) -> bool {
+        *self.phase.lock() == SsdStagePhase::Active
+    }
+
+    pub(crate) async fn wait_until_not_active(&self) {
+        let mut phase_changed = self.phase_changed.subscribe();
+        loop {
+            if *phase_changed.borrow_and_update() != SsdStagePhase::Active {
+                return;
+            }
+            if phase_changed.changed().await.is_err() {
+                return;
+            }
+        }
+    }
+}
+
 /// A metadata-only Get source snapshot before caller-owned destination binding.
 ///
 /// This type must not own a route, allocation, activity lease, cache pin, or
@@ -467,6 +638,7 @@ pub struct PlannedGetInfo {
     pub len: u64,
     pub src_addr: u64,
     pub src_base_addr: u64,
+    pub source_kind: crate::master_kv_router::msg_pack::GetSourceKind,
     pub atomic_group: Option<crate::master_kv_router::msg_pack::PutAtomicGroup>,
 }
 
@@ -602,6 +774,24 @@ pub(crate) struct MasterPlannedGetCounters {
     bind_stale: AtomicU64,
     bind_activity_busy: AtomicU64,
     plan_revoked: AtomicU64,
+    remote_ssd_filtered_items: AtomicU64,
+    remote_ssd_filtered_bytes: AtomicU64,
+}
+
+#[derive(Default)]
+pub(crate) struct MasterSsdTierCounters {
+    local_ssd_selected_with_remote_memory_items: AtomicU64,
+    local_ssd_selected_with_remote_memory_bytes: AtomicU64,
+    local_ssd_selected_without_remote_memory_items: AtomicU64,
+    local_ssd_selected_without_remote_memory_bytes: AtomicU64,
+    local_ssd_published_with_remote_memory_items: AtomicU64,
+    local_ssd_published_with_remote_memory_bytes: AtomicU64,
+    local_ssd_published_without_remote_memory_items: AtomicU64,
+    local_ssd_published_without_remote_memory_bytes: AtomicU64,
+    memory_removed_ssd_survived_items: AtomicU64,
+    memory_removed_ssd_survived_bytes: AtomicU64,
+    memory_removed_ssd_became_only_items: AtomicU64,
+    memory_removed_ssd_became_only_bytes: AtomicU64,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -1009,8 +1199,7 @@ impl KvReplicaBacking {
 }
 
 #[derive(Clone, Debug)]
-pub struct KvRouteInfo {
-    pub node_id: NodeID,
+pub struct KvMemoryReplica {
     pub backing: KvReplicaBacking,
     /// Whether this owner also published the route backing into its local key index.
     /// Replica-task and remote-put targets are raw master-owned allocations and have no
@@ -1023,7 +1212,44 @@ pub struct KvRouteInfo {
     /// Excludes a non-ring-B backing from the unindexed-Allocation budget and
     /// is released with the exact route lifetime.
     pub capacity_reservation: Option<Arc<NodeCacheCapacityReservation>>,
+}
+
+#[derive(Clone, Debug)]
+pub struct KvSsdReplica {
+    pub len: u64,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum SsdReplicaCommitStatus {
+    Committed,
+    MissingMemory,
+    TombedNode,
+    LengthMismatch,
+}
+
+/// All physical backings contributed by one owner generation for one key-version.
+///
+/// Route, version, and owner generation stay common. Storage tiers only own their
+/// medium-specific state, so adding SSD does not create a second route lifecycle.
+#[derive(Clone, Debug)]
+pub struct KvNodeReplicas {
     pub tomb_tag: NodeTombTag,
+    pub memory: Option<KvMemoryReplica>,
+    pub ssd: Option<KvSsdReplica>,
+}
+
+impl KvNodeReplicas {
+    pub fn memory(tomb_tag: NodeTombTag, memory: KvMemoryReplica) -> Self {
+        Self {
+            tomb_tag,
+            memory: Some(memory),
+            ssd: None,
+        }
+    }
+
+    pub fn has_live_backing(&self) -> bool {
+        !self.tomb_tag.is_tomb() && (self.memory.is_some() || self.ssd.is_some())
+    }
 }
 
 pub struct GetDurableSlotReservation {
@@ -1080,24 +1306,55 @@ pub struct OneKvNodesRoutes {
     /// Version-scoped multi-key group supplied by the put caller.
     pub atomic_group: Option<Arc<PutAtomicGroup>>,
 
-    /// node_id -> KvRouteInfo
-    pub nodes_replicas: RwLock<HashMap<NodeID, KvRouteInfo>>,
+    /// node_id -> all backings owned by that exact node generation.
+    pub node_replicas: RwLock<HashMap<NodeID, KvNodeReplicas>>,
     pub get_durable_slots_used: AtomicU32,
 }
 
 impl OneKvNodesRoutes {
+    pub(crate) fn commit_ssd_replica(&self, node_id: &NodeID, len: u64) -> SsdReplicaCommitStatus {
+        let mut replicas = self.node_replicas.write();
+        let Some(node_replicas) = replicas.get_mut(node_id) else {
+            return SsdReplicaCommitStatus::MissingMemory;
+        };
+        if node_replicas.tomb_tag.is_tomb() {
+            return SsdReplicaCommitStatus::TombedNode;
+        }
+        let Some(memory) = node_replicas.memory.as_ref() else {
+            return SsdReplicaCommitStatus::MissingMemory;
+        };
+        if memory.backing.len() != len {
+            return SsdReplicaCommitStatus::LengthMismatch;
+        }
+        node_replicas.ssd = Some(KvSsdReplica { len });
+        SsdReplicaCommitStatus::Committed
+    }
+
+    pub(crate) fn remove_ssd_replica(&self, node_id: &NodeID) -> bool {
+        let mut replicas = self.node_replicas.write();
+        let Some(node_replicas) = replicas.get_mut(node_id) else {
+            return false;
+        };
+        let removed = node_replicas.ssd.take().is_some();
+        if node_replicas.memory.is_none() {
+            replicas.remove(node_id);
+        }
+        removed
+    }
+
     fn clean_up_tomb_nodes_replicas(
         &self,
         verify_put_id: PutIDForAKey,
         tombs: HashSet<NodeID>,
-        view: &MasterKvRouterView,
+        _view: &MasterKvRouterView,
     ) -> bool {
         if self.put_id != verify_put_id {
             return false;
         }
 
-        let mut nodes_replicas = self.nodes_replicas.write();
-        nodes_replicas.retain(|_, kv_info| !tombs.contains(&kv_info.node_id));
+        let mut node_replicas = self.node_replicas.write();
+        node_replicas
+            .retain(|node_id, replicas| !tombs.contains(node_id) || !replicas.tomb_tag.is_tomb());
 
         return true;
     }
@@ -1139,9 +1396,10 @@ fn ring_b_route_replica_desc(
     if route.lease_id.is_some() {
         return None;
     }
-    let replicas = route.nodes_replicas.read();
-    let replica = replicas.get(node_id)?;
-    if replica.tomb_tag.is_tomb()
+    let replicas = route.node_replicas.read();
+    let node_replicas = replicas.get(node_id)?;
+    let replica = node_replicas.memory.as_ref()?;
+    if node_replicas.tomb_tag.is_tomb()
         || replica.owner_local_indexed
         || !matches!(&replica.backing, KvReplicaBacking::Allocation(_))
     {
@@ -1181,32 +1439,41 @@ pub(crate) fn node_generation_is_current_live(
 pub(crate) fn publish_route_replica_tomb_fenced(
     route: &OneKvNodesRoutes,
     node_id: NodeID,
-    replica: KvRouteInfo,
+    replica: KvMemoryReplica,
+    publish_tag: NodeTombTag,
 ) -> bool {
-    let publish_tag = replica.tomb_tag.clone();
     if publish_tag.is_tomb() {
         return false;
     }
 
-    let mut replicas = route.nodes_replicas.write();
+    let mut replicas = route.node_replicas.write();
     if publish_tag.is_tomb() {
         return false;
     }
-    // A completion pre-check is necessarily racy with another completion for
-    // the same requester.  Never replace a live replica here: only a tombed
-    // generation may be superseded.
-    if replicas
-        .get(&node_id)
-        .is_some_and(|current| !current.tomb_tag.is_tomb())
-    {
-        return false;
-    }
-    let previous = replicas.insert(node_id.clone(), replica);
+    let previous = match replicas.get_mut(&node_id) {
+        Some(current)
+            if !current.tomb_tag.is_tomb() && current.tomb_tag.same_generation(&publish_tag) =>
+        {
+            // A completion pre-check is necessarily racy with another completion.
+            // Preserve an already-published memory backing, while allowing the same
+            // generation to regain DRAM from an SSD-only route.
+            if current.memory.is_some() {
+                return false;
+            }
+            current.memory = Some(replica);
+            None
+        }
+        Some(current) if !current.tomb_tag.is_tomb() => return false,
+        _ => replicas.insert(
+            node_id.clone(),
+            KvNodeReplicas::memory(publish_tag.clone(), replica),
+        ),
+    };
 
     if publish_tag.is_tomb() {
-        let published_is_current = replicas.get(&node_id).is_some_and(|current| {
-            current.node_id == node_id && current.tomb_tag.same_generation(&publish_tag)
-        });
+        let published_is_current = replicas
+            .get(&node_id)
+            .is_some_and(|current| current.tomb_tag.same_generation(&publish_tag));
         if published_is_current {
             replicas.remove(&node_id);
             if let Some(previous) = previous.filter(|old| !old.tomb_tag.is_tomb()) {
@@ -1282,11 +1549,9 @@ fn remove_departed_generation_from_route(
     departed_tag: &NodeTombTag,
 ) -> Option<PutIDForAKey> {
     let became_empty = {
-        let mut replicas = route.nodes_replicas.write();
+        let mut replicas = route.node_replicas.write();
         let remove = replicas.get(node_id).is_some_and(|replica| {
-            replica.node_id.as_ref() == node_id
-                && replica.tomb_tag.is_tomb()
-                && replica.tomb_tag.same_generation(departed_tag)
+            replica.tomb_tag.is_tomb() && replica.tomb_tag.same_generation(departed_tag)
         });
         if !remove {
             return None;
@@ -1304,7 +1569,7 @@ fn remove_departed_generation_from_route(
             // `Arc::ptr_eq` prevents an old cleanup from removing a replacement route (ABA).
             // Recheck emptiness under the per-route read lock because another replica may have
             // joined after the write lock above was released.
-            Arc::ptr_eq(current, route) && current.nodes_replicas.read().is_empty()
+            Arc::ptr_eq(current, route) && current.node_replicas.read().is_empty()
         })
         .map(|(_, removed)| removed.put_id)
 }
@@ -1366,13 +1631,11 @@ async fn cleanup_departed_generation_routes(
                 continue;
             };
             let had_departed_replica = route
-                .nodes_replicas
+                .node_replicas
                 .read()
                 .get(node_id.as_str())
                 .is_some_and(|replica| {
-                    replica.node_id.as_ref() == node_id.as_str()
-                        && replica.tomb_tag.is_tomb()
-                        && replica.tomb_tag.same_generation(&departed_tag)
+                    replica.tomb_tag.is_tomb() && replica.tomb_tag.same_generation(&departed_tag)
                 });
             if !had_departed_replica {
                 continue;
@@ -1443,7 +1706,7 @@ mod tests {
             put_id: (1, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::new()),
+            node_replicas: RwLock::new(HashMap::new()),
             get_durable_slots_used: AtomicU32::new(0),
         });
 
@@ -1456,13 +1719,36 @@ mod tests {
         drop(second);
     }
 
+    #[test]
+    fn ssd_stage_lifecycle_replays_begin_and_never_loses_quiescence() {
+        futures::executor::block_on(async {
+            let lifecycle = Arc::new(SsdStageLifecycle::new());
+            assert!(lifecycle.begin());
+            assert!(
+                lifecycle.begin(),
+                "a lost Begin response must replay Active as accepted"
+            );
+
+            let waiter = lifecycle.wait_until_not_active();
+            let finisher = async {
+                assert!(lifecycle.is_active());
+                assert!(lifecycle.finish());
+            };
+            futures::future::join(waiter, finisher).await;
+
+            assert!(!lifecycle.finish());
+            assert!(!lifecycle.begin());
+            lifecycle.wait_until_not_active().await;
+        });
+    }
+
     #[test]
     fn durable_slot_token_returns_capacity_across_ten_fill_demote_cycles() {
         let routes = Arc::new(OneKvNodesRoutes {
             put_id: (1, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::new()),
+            node_replicas: RwLock::new(HashMap::new()),
             get_durable_slots_used: AtomicU32::new(0),
         });
 
@@ -1680,9 +1966,8 @@ mod tests {
         );
     }
 
-    fn test_route_info_with_tag(node_id: &str, tomb_tag: NodeTombTag) -> KvRouteInfo {
-        KvRouteInfo {
-            node_id: node_id.to_string().into(),
+    fn test_memory_replica(node_id: &str) -> KvMemoryReplica {
+        KvMemoryReplica {
             backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
                 owner_node_id: node_id.to_string().into(),
                 grant_id: 1,
@@ -1695,11 +1980,14 @@ mod tests {
             owner_local_indexed: true,
             get_durable_reservation: None,
             capacity_reservation: None,
-            tomb_tag,
         }
     }
 
-    fn test_route_info(node_id: &str, tomb: bool) -> KvRouteInfo {
+    fn test_route_info_with_tag(node_id: &str, tomb_tag: NodeTombTag) -> KvNodeReplicas {
+        KvNodeReplicas::memory(tomb_tag, test_memory_replica(node_id))
+    }
+
+    fn test_route_info(node_id: &str, tomb: bool) -> KvNodeReplicas {
         let tomb_tag = NodeTombTag::new();
         if tomb {
             tomb_tag.set_tomb();
@@ -1707,7 +1995,7 @@ mod tests {
         test_route_info_with_tag(node_id, tomb_tag)
     }
 
-    fn test_allocation_route_info(node_id: &str, owner_local_indexed: bool) -> KvRouteInfo {
+    fn test_allocation_route_info(node_id: &str, owner_local_indexed: bool) -> KvNodeReplicas {
         let allocator = Arc::new(
             crate::master_seg_manager::one_seg_allocator::OneSegAllocator::new(
                 format!("{node_id}-segment"),
@@ -1718,14 +2006,15 @@ mod tests {
             .unwrap(),
         );
         let allocation = allocator.allocate(1024).unwrap();
-        KvRouteInfo {
-            node_id: node_id.to_string().into(),
-            backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
-            owner_local_indexed,
-            get_durable_reservation: None,
-            capacity_reservation: None,
-            tomb_tag: NodeTombTag::new(),
-        }
+        KvNodeReplicas::memory(
+            NodeTombTag::new(),
+            KvMemoryReplica {
+                backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
+                owner_local_indexed,
+                get_durable_reservation: None,
+                capacity_reservation: None,
+            },
+        )
     }
 
     fn test_route(
@@ -1737,7 +2026,7 @@ mod tests {
             put_id,
             lease_id,
             atomic_group: None,
-            nodes_replicas: RwLock::new(
+            node_replicas: RwLock::new(
                 replicas
                     .into_iter()
                     .map(|(node_id, tomb)| {
@@ -1756,7 +2045,7 @@ mod tests {
             put_id: (91, 3),
             lease_id,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(node.clone(), replica)])),
+            node_replicas: RwLock::new(HashMap::from([(node.clone(), replica)])),
             get_durable_slots_used: AtomicU32::new(0),
         };
 
@@ -1773,11 +2062,48 @@ mod tests {
         assert!(ring_b_route_replica_desc(&leased, "same-node").is_none());
 
         let mut committed = test_route_info("same-node", false);
-        committed.owner_local_indexed = false;
+        committed
+            .memory
+            .as_mut()
+            .expect("test route has memory")
+            .owner_local_indexed = false;
         let committed = make_route(None, committed);
         assert!(ring_b_route_replica_desc(&committed, "same-node").is_none());
     }
 
+    #[test]
+    fn ssd_commit_reuses_the_live_owner_route_and_validates_memory_length() {
+        let owner: NodeID = "owner".to_string().into();
+        let route = test_route((92, 1), None, vec![("owner", false)]);
+
+        assert_eq!(
+            route.commit_ssd_replica(&owner, 2048),
+            SsdReplicaCommitStatus::LengthMismatch
+        );
+        assert_eq!(
+            route.commit_ssd_replica(&owner, 1024),
+            SsdReplicaCommitStatus::Committed
+        );
+        {
+            let replicas = route.node_replicas.read();
+            let owner_replicas = replicas.get(&owner).unwrap();
+            assert!(owner_replicas.memory.is_some());
+            assert_eq!(owner_replicas.ssd.as_ref().map(|ssd| ssd.len), Some(1024));
+        }
+
+        route.node_replicas.write().get_mut(&owner).unwrap().memory = None;
+        assert_eq!(
+            route.commit_ssd_replica(&owner, 1024),
+            SsdReplicaCommitStatus::MissingMemory
+        );
+        assert!(route.remove_ssd_replica(&owner));
+        assert!(
+            route.node_replicas.read().is_empty(),
+            "a stale SSD-only owner entry must converge to an empty route"
+        );
+        assert!(!route.remove_ssd_replica(&owner));
+    }
+
     #[test]
     fn member_left_cleanup_removes_only_the_exact_tomb_generation() {
         let routes = DashMap::new();
@@ -1791,7 +2117,7 @@ mod tests {
             put_id: (10, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 "owner".to_string().into(),
                 test_route_info_with_tag("owner", departed_tag.clone()),
             )])),
@@ -1801,7 +2127,7 @@ mod tests {
             put_id: (11, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 "owner".to_string().into(),
                 test_route_info_with_tag("owner", live_reconnect_tag),
             )])),
@@ -1811,7 +2137,7 @@ mod tests {
             put_id: (12, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 "owner".to_string().into(),
                 test_route_info_with_tag("owner", newer_tomb_tag),
             )])),
@@ -1844,7 +2170,7 @@ mod tests {
         );
         assert!(
             live_route
-                .nodes_replicas
+                .node_replicas
                 .read()
                 .get("owner")
                 .is_some_and(|replica| !replica.tomb_tag.is_tomb())
@@ -1859,7 +2185,7 @@ mod tests {
             ),
             None
         );
-        assert!(newer_tomb_route.nodes_replicas.read().contains_key("owner"));
+        assert!(newer_tomb_route.node_replicas.read().contains_key("owner"));
     }
 
     #[test]
@@ -1871,7 +2197,7 @@ mod tests {
             put_id: (20, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 "owner".to_string().into(),
                 test_route_info_with_tag("owner", departed_tag.clone()),
             )])),
@@ -1895,7 +2221,7 @@ mod tests {
         assert!(Arc::ptr_eq(current.value(), &replacement));
         assert!(
             current
-                .nodes_replicas
+                .node_replicas
                 .read()
                 .get("peer")
                 .is_some_and(|replica| !replica.tomb_tag.is_tomb())
@@ -1906,7 +2232,7 @@ mod tests {
     fn replica_publish_fence_never_overwrites_live_or_publishes_tomb_generation() {
         let old_tag = NodeTombTag::new();
         let route = test_route((30, 0), None, vec![]);
-        route.nodes_replicas.write().insert(
+        route.node_replicas.write().insert(
             "owner".to_string().into(),
             test_route_info_with_tag("owner", old_tag.clone()),
         );
@@ -1915,11 +2241,12 @@ mod tests {
         assert!(!publish_route_replica_tomb_fenced(
             &route,
             "owner".to_string().into(),
-            test_route_info_with_tag("owner", contender_tag),
+            test_memory_replica("owner"),
+            contender_tag,
         ));
         assert!(
             route
-                .nodes_replicas
+                .node_replicas
                 .read()
                 .get("owner")
                 .is_some_and(|replica| replica.tomb_tag.same_generation(&old_tag))
@@ -1930,11 +2257,12 @@ mod tests {
         assert!(publish_route_replica_tomb_fenced(
             &route,
             "owner".to_string().into(),
-            test_route_info_with_tag("owner", replacement_tag.clone()),
+            test_memory_replica("owner"),
+            replacement_tag.clone(),
         ));
         assert!(
             route
-                .nodes_replicas
+                .node_replicas
                 .read()
                 .get("owner")
                 .is_some_and(|replica| replica.tomb_tag.same_generation(&replacement_tag))
@@ -1945,9 +2273,10 @@ mod tests {
         assert!(!publish_route_replica_tomb_fenced(
             &route,
             "departed".to_string().into(),
-            test_route_info_with_tag("departed", departed_tag),
+            test_memory_replica("departed"),
+            departed_tag,
         ));
-        assert!(!route.nodes_replicas.read().contains_key("departed"));
+        assert!(!route.node_replicas.read().contains_key("departed"));
     }
 
     #[test]
@@ -1962,7 +2291,7 @@ mod tests {
             put_id: (41, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 "owner".to_string().into(),
                 test_route_info_with_tag("owner", departed_tag.clone()),
             )])),
@@ -1982,7 +2311,7 @@ mod tests {
             put_id: (42, 0),
             lease_id: None,
             atomic_group: None,
-            nodes_replicas: RwLock::new(HashMap::from([(
+            node_replicas: RwLock::new(HashMap::from([(
                 "owner".to_string().into(),
                 test_route_info_with_tag("owner", live_tag.clone()),
             )])),
@@ -2068,6 +2397,52 @@ mod tests {
         assert_eq!(cache.max_capacity(), Some(2048));
     }
 
+    #[test]
+    fn ring_b_shrink_selects_single_entries_to_the_new_active_boundary() {
+        let selected = Arc::new(AtomicU64::new(0));
+        let selected_for_listener = selected.clone();
+        let cache = MasterNodeCache::builder(1024)
+            .weigher(|_key: &String, desc: &NodeValueReplicaDesc| desc.weight_bytes)
+            .eviction_listener(move |_key, _desc, cause| {
+                assert_eq!(cause, RemovalCause::Size);
+                selected_for_listener.fetch_add(1, Ordering::Relaxed);
+            })
+            .build();
+        for key in 0..8 {
+            insert_master_cache_entry(
+                &cache,
+                key.to_string(),
+                NodeValueReplicaDesc {
+                    weight_bytes: 128,
+                    put_id: (10, key),
+                },
+            );
+        }
+        cache.run_pending_tasks();
+        assert_eq!(cache.weighted_size(), 1024);
+
+        cache.set_max_capacity(512).unwrap();
+        cache.run_pending_tasks();
+        assert!(cache.weighted_size() <= 512);
+        assert_eq!(selected.load(Ordering::Relaxed), 4);
+    }
+
+    #[test]
+    fn node_pool_capacity_control_json_is_a_finite_generation_fenced_contract() {
+        let request = NodePoolCapacityControlRequest::SetActive {
+            owner_node_id: "cpu-owner".to_string(),
+            expected_owner_node_start_time: 17,
+            expected_capacity_epoch: 3,
+            active_capacity_bytes: 240 * 1024 * 1024 * 1024,
+        };
+        let encoded = serde_json::to_vec(&request).unwrap();
+        let decoded: NodePoolCapacityControlRequest = serde_json::from_slice(&encoded).unwrap();
+        assert_eq!(decoded, request);
+        let json: serde_json::Value = serde_json::from_slice(&encoded).unwrap();
+        assert_eq!(json["operation"], "set_active");
+        assert_eq!(json["expected_capacity_epoch"], 3);
+    }
+
     #[test]
     fn synchronous_restore_re_eviction_keeps_new_pending_weight() {
         let weight = 8 * 1024 * 1024;
@@ -2312,6 +2687,7 @@ pub struct MasterKvRouterInner {
     /// `inflight_gets` after re-reading and validating the current route.
     pub planned_gets: moka::future::Cache<u64, PlannedGetInfo>,
     pub(crate) planned_get_counters: MasterPlannedGetCounters,
+    pub(crate) ssd_tier_counters: MasterSsdTierCounters,
     /// Idempotent terminal GetDone results retained across response loss/retry.
     pub completed_gets: moka::future::Cache<u64, CompletedGetInfo>,
     pub get_done_locks: AMapLock<u64>,
@@ -2388,6 +2764,11 @@ pub struct MasterKvRouterInner {
     /// request lock, and no cache/global scan occurs under it.
     pub(crate) owner_cache_operation_locks: AMapLock<String>,
 
+    /// Serializes the active pool target, reservation counters, and their derived Moka limits.
+    /// The critical section contains only local metadata/housekeeping and is shared with
+    /// synchronous reservation Drop paths, so it intentionally uses a short parking_lot lock.
+    node_capacity_boundary_locks: DashMap<NodeIDString, Arc<Mutex<()>>>,
+
     /// Historical final put placement decisions by target node.
     pub put_target_decision_counts: DashMap<NodeIDString, Arc<AtomicU64>>,
 
@@ -2406,6 +2787,11 @@ pub struct MasterKvRouterInner {
     /// Historical get source choices by requester->source pair.
     pub get_requester_source_counts: DashMap<RequesterTargetPair, Arc<AtomicU64>>,
     pub get_requester_source_bytes: DashMap<RequesterTargetPair, Arc<AtomicU64>>,
+    /// Source-tier/locality matrix for planned and ordinary Gets. This keeps
+    /// local SSD, remote SSD, local memory, and remote memory separable in
+    /// evidence instead of inferring them from per-owner aggregate loads.
+    pub get_source_class_counts: DashMap<&'static str, Arc<AtomicU64>>,
+    pub get_source_class_bytes: DashMap<&'static str, Arc<AtomicU64>>,
     pub get_allocation_mode_counts: DashMap<&'static str, Arc<AtomicU64>>,
 
     /// Support replicas: key -> version_id
@@ -2569,6 +2955,7 @@ impl MasterKvRouter {
             inflight_gets,
             planned_gets,
             planned_get_counters: MasterPlannedGetCounters::default(),
+            ssd_tier_counters: MasterSsdTierCounters::default(),
             completed_gets,
             get_done_locks: AMapLock::new(Duration::from_secs(10 * 60)),
             key_activity,
@@ -2595,6 +2982,7 @@ impl MasterKvRouter {
             eviction_reclaim_inflight: DashSet::new(),
             eviction_reclaim_counters: DashMap::new(),
             owner_cache_operation_locks: AMapLock::new(Duration::from_secs(10 * 60)),
+            node_capacity_boundary_locks: DashMap::new(),
             put_target_decision_counts: DashMap::new(),
             put_requester_target_decision_counts: DashMap::new(),
             put_placement_mode_counts: DashMap::new(),
@@ -2602,6 +2990,8 @@ impl MasterKvRouter {
             replica_done_terminal_replay_count: AtomicU64::new(0),
             get_requester_source_counts: DashMap::new(),
             get_requester_source_bytes: DashMap::new(),
+            get_source_class_counts: DashMap::new(),
+            get_source_class_bytes: DashMap::new(),
             get_allocation_mode_counts: DashMap::new(),
             recent_key_versionid_allocator: moka::sync::SegmentedCache::builder(8)
                 .time_to_idle(Duration::from_secs(5))
@@ -2700,33 +3090,47 @@ impl MasterKvRouter {
         .ring_b_bytes
     }
 
-    /// Refresh already-created node controllers after segment metadata or
-    /// reservation inputs change. Generation-scoped reservations reduce only
-    /// the physical ring-B allocation boundary. Tier1 is an inclusive metadata
-    /// policy window and always remains ratio-derived from the owner segment.
-    fn reconcile_node_cache_capacity(&self, node_id: &str) {
+    fn node_capacity_boundary_lock(&self, node_id: &str) -> Arc<Mutex<()>> {
+        self.inner()
+            .node_capacity_boundary_locks
+            .entry(node_id.to_string())
+            .or_insert_with(|| Arc::new(Mutex::new(())))
+            .value()
+            .clone()
+    }
+
+    /// Apply the current active pool size to every derived Moka boundary.
+    fn apply_node_cache_capacity_locked(&self, node_id: &str) -> KvResult<()> {
+        if !self.replica_cache_enabled() {
+            return Ok(());
+        }
         let node_space_size = self
             .inner()
             .view()
             .master_seg_manager()
-            .get_node_space_size(node_id);
+            .get_node_active_space_size(node_id);
         if node_space_size == 0 {
-            return;
+            return Err(KvError::Api(ApiError::NodeNotFound {
+                desc: format!("{node_id} (no live active pool)"),
+            }));
         }
         let capacity = self.replica_cache_effective_capacity(node_id, node_space_size);
-        if let Some(cache) = self
-            .inner()
-            .node_kv_cache_controller
-            .get(node_id)
-            .map(|entry| entry.value().clone())
-        {
-            if let Err(err) = cache.set_max_capacity(capacity) {
-                error!(
-                    "failed to refresh ring-B cache capacity: node={} capacity={} err={}",
-                    node_id, capacity, err,
-                );
-            }
-        }
+        let cache = self.get_node_cache_controller(node_id).ok_or_else(|| {
+            KvError::Api(ApiError::NodeNotFound {
+                desc: format!("{node_id} (ring-B controller unavailable)"),
+            })
+        })?;
+        cache.set_max_capacity(capacity).map_err(|err| {
+            KvError::Api(ApiError::Allocator {
+                detail: format!(
+                    "failed to set ring-B capacity: node={} capacity={} err={}",
+                    node_id, capacity, err
+                ),
+            })
+        })?;
+        // Drive Size selection now. Physical release remains asynchronous and continues through
+        // the existing generation-fenced single-KV reclaim actor.
+        cache.run_pending_tasks();
         if let Some(cache) = self
             .inner()
             .node_writeback_tier1_controller
@@ -2736,12 +3140,50 @@ impl MasterKvRouter {
             let tier1_capacity = self
                 .writeback_tier1_base_capacity(node_space_size)
                 .unwrap_or(0);
-            if let Err(err) = cache.set_max_capacity(tier1_capacity) {
-                error!(
-                    "failed to refresh tier1 cache capacity: node={} capacity={} err={}",
-                    node_id, tier1_capacity, err,
-                );
-            }
+            cache.set_max_capacity(tier1_capacity).map_err(|err| {
+                KvError::Api(ApiError::Allocator {
+                    detail: format!(
+                        "failed to set tier1 capacity: node={} capacity={} err={}",
+                        node_id, tier1_capacity, err
+                    ),
+                })
+            })?;
+            cache.run_pending_tasks();
+        }
+        Ok(())
+    }
+
+    fn apply_node_cache_capacity(&self, node_id: &str) -> KvResult<()> {
+        let capacity_lock = self.node_capacity_boundary_lock(node_id);
+        let _capacity_guard = capacity_lock.lock();
+        self.apply_node_cache_capacity_locked(node_id)
+    }
+
+    /// Refresh controllers after registration or reservation changes. Runtime resize uses the
+    /// fallible helper directly so a control response never reports an unapplied target.
+    fn reconcile_node_cache_capacity(&self, node_id: &str) {
+        // Member discovery can precede segment registration. There is no pool boundary to
+        // reconcile during that normal startup window; registration success will call us again.
+        // Keep the fallible runtime-control path strict, but do not emit a false operational
+        // error for this transient internal reconcile.
+        if self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .get_node_active_space_size(node_id)
+            == 0
+        {
+            debug!(
+                "deferring node cache capacity refresh until pool registration: node={}",
+                node_id
+            );
+            return;
+        }
+        if let Err(err) = self.apply_node_cache_capacity(node_id) {
+            error!(
+                "failed to refresh node cache capacity: node={} err={}",
+                node_id, err
+            );
         }
     }
 
@@ -2755,6 +3197,191 @@ impl MasterKvRouter {
         .tier1_bytes
     }
 
+    fn node_pool_capacity_response(
+        &self,
+        owner_node_id: &str,
+        owner_node_start_time: i64,
+        pool: NodePoolCapacitySnapshot,
+    ) -> NodePoolCapacityControlResponse {
+        let ring_b_base_capacity_bytes =
+            self.replica_cache_base_capacity(pool.active_capacity_bytes);
+        let reserved_capacity_bytes = self
+            .inner()
+            .node_cache_reserved_capacity
+            .get(owner_node_id)
+            .filter(|reserved| !reserved.generation.is_tomb())
+            .map(|reserved| reserved.total_reserved_bytes())
+            .unwrap_or(0);
+        let derived_effective = ring_b_base_capacity_bytes.saturating_sub(reserved_capacity_bytes);
+        let cache = self
+            .inner()
+            .node_kv_cache_controller
+            .get(owner_node_id)
+            .map(|entry| entry.value().clone());
+        let ring_b_effective_capacity_bytes = cache
+            .as_ref()
+            .and_then(|cache| cache.max_capacity())
+            .unwrap_or(derived_effective);
+        let ring_b_weighted_bytes = cache
+            .as_ref()
+            .map(|cache| cache.weighted_size())
+            .unwrap_or(0);
+        let ring_b_pending_reclaim_bytes = self.eviction_reclaim_pending_weight(owner_node_id);
+        let tier1_capacity_bytes = self
+            .inner()
+            .node_writeback_tier1_controller
+            .get(owner_node_id)
+            .and_then(|entry| entry.value().max_capacity())
+            .unwrap_or_else(|| {
+                self.writeback_tier1_base_capacity(pool.active_capacity_bytes)
+                    .unwrap_or(0)
+            });
+        let settled = pool.draining_capacity_bytes == 0
+            && ring_b_weighted_bytes <= ring_b_effective_capacity_bytes
+            && ring_b_pending_reclaim_bytes == 0;
+        NodePoolCapacityControlResponse {
+            owner_node_id: owner_node_id.to_string(),
+            owner_node_start_time,
+            physical_capacity_bytes: pool.physical_capacity_bytes,
+            active_capacity_bytes: pool.active_capacity_bytes,
+            used_capacity_bytes: pool.used_capacity_bytes,
+            parked_capacity_bytes: pool.parked_capacity_bytes,
+            draining_capacity_bytes: pool.draining_capacity_bytes,
+            available_capacity_bytes: pool.available_capacity_bytes,
+            capacity_epoch: pool.capacity_epoch,
+            ring_b_base_capacity_bytes,
+            ring_b_effective_capacity_bytes,
+            ring_b_weighted_bytes,
+            ring_b_pending_reclaim_bytes,
+            tier1_capacity_bytes,
+            settled,
+        }
+    }
+
+    pub fn node_pool_capacity_control_snapshot(
+        &self,
+        owner_node_id: &str,
+    ) -> KvResult<NodePoolCapacityControlResponse> {
+        let capacity_lock = self.node_capacity_boundary_lock(owner_node_id);
+        let _capacity_guard = capacity_lock.lock();
+        let (owner_node_start_time, pool) = self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .get_node_pool_capacity(owner_node_id)
+            .ok_or_else(|| {
+                KvError::Api(ApiError::NodeNotFound {
+                    desc: owner_node_id.to_string(),
+                })
+            })?;
+        Ok(self.node_pool_capacity_response(owner_node_id, owner_node_start_time, pool))
+    }
+
+    /// Atomically close the allocator admission gate before lowering Moka's derived boundaries.
+    /// The returned response is an initiation snapshot; callers poll `Get` until `settled=true`.
+    pub async fn set_node_pool_active_capacity(
+        &self,
+        owner_node_id: NodeID,
+        expected_owner_node_start_time: i64,
+        expected_capacity_epoch: u64,
+        active_capacity_bytes: u64,
+    ) -> KvResult<NodePoolCapacityControlResponse> {
+        let owner_cache_lock = self
+            .inner()
+            .owner_cache_operation_locks
+            .get_lock(owner_node_id.to_string());
+        let _owner_cache_guard = owner_cache_lock.lock().await;
+        let capacity_lock = self.node_capacity_boundary_lock(owner_node_id.as_ref());
+        let _capacity_guard = capacity_lock.lock();
+
+        let (_, before) = self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .get_node_pool_capacity(owner_node_id.as_ref())
+            .ok_or_else(|| {
+                KvError::Api(ApiError::NodeNotFound {
+                    desc: owner_node_id.to_string(),
+                })
+            })?;
+        let reserved_capacity_bytes = self
+            .inner()
+            .node_cache_reserved_capacity
+            .get(owner_node_id.as_ref())
+            .filter(|reserved| !reserved.generation.is_tomb())
+            .map(|reserved| reserved.total_reserved_bytes())
+            .unwrap_or(0);
+        let prospective_ring_b = node_cache_capacity_boundaries(
+            active_capacity_bytes,
+            self.inner().replica_cache_capacity_ratio,
+            self.inner().replica_writeback_tier1_capacity_ratio,
+            reserved_capacity_bytes,
+        )
+        .ring_b_bytes;
+        if self.replica_cache_enabled() && prospective_ring_b == 0 {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "active capacity leaves no ring-B allocation budget: owner={} active={} reserved={}",
+                    owner_node_id, active_capacity_bytes, reserved_capacity_bytes
+                ),
+            }));
+        }
+
+        let updated = self
+            .inner()
+            .view()
+            .master_seg_manager()
+            .set_node_active_capacity(
+                &owner_node_id,
+                expected_owner_node_start_time,
+                expected_capacity_epoch,
+                active_capacity_bytes,
+            )?;
+        if let Err(apply_err) = self.apply_node_cache_capacity_locked(owner_node_id.as_ref()) {
+            let rollback = self
+                .inner()
+                .view()
+                .master_seg_manager()
+                .set_node_active_capacity(
+                    &owner_node_id,
+                    expected_owner_node_start_time,
+                    updated.capacity_epoch,
+                    before.active_capacity_bytes,
+                )
+                .and_then(|_| self.apply_node_cache_capacity_locked(owner_node_id.as_ref()));
+            error!(
+                owner = %owner_node_id,
+                requested_active_capacity_bytes = active_capacity_bytes,
+                error = %apply_err,
+                rollback = ?rollback,
+                "node pool capacity apply failed"
+            );
+            return Err(apply_err);
+        }
+
+        let response = self.node_pool_capacity_response(
+            owner_node_id.as_ref(),
+            expected_owner_node_start_time,
+            updated,
+        );
+        info!(
+            owner = %owner_node_id,
+            owner_node_start_time = response.owner_node_start_time,
+            capacity_epoch = response.capacity_epoch,
+            physical_capacity_bytes = response.physical_capacity_bytes,
+            active_capacity_bytes = response.active_capacity_bytes,
+            parked_capacity_bytes = response.parked_capacity_bytes,
+            used_capacity_bytes = response.used_capacity_bytes,
+            draining_capacity_bytes = response.draining_capacity_bytes,
+            ring_b_effective_capacity_bytes = response.ring_b_effective_capacity_bytes,
+            ring_b_weighted_bytes = response.ring_b_weighted_bytes,
+            ring_b_pending_reclaim_bytes = response.ring_b_pending_reclaim_bytes,
+            settled = response.settled,
+            "node pool active capacity applied"
+        );
+        Ok(response)
+    }
+
     pub fn tiered_writeback_enabled(&self) -> bool {
         self.inner()
             .replica_writeback_tier1_capacity_ratio
@@ -2935,20 +3562,21 @@ impl MasterKvRouter {
             .map(|route| {
                 let put_id = route.put_id;
                 route
-                    .nodes_replicas
+                    .node_replicas
                     .read()
                     .iter()
-                    .filter_map(|(node_id, replica)| {
-                        (!replica.tomb_tag.is_tomb()).then(|| {
-                            (
-                                node_id.as_ref().to_string(),
-                                NodeValueReplicaDesc {
-                                    weight_bytes: u32::try_from(replica.backing.capacity_bytes())
-                                        .unwrap_or(u32::MAX),
-                                    put_id,
-                                },
-                            )
-                        })
+                    .filter_map(|(node_id, replicas)| {
+                        let memory = (!replicas.tomb_tag.is_tomb())
+                            .then(|| replicas.memory.as_ref())
+                            .flatten()?;
+                        Some((
+                            node_id.as_ref().to_string(),
+                            NodeValueReplicaDesc {
+                                weight_bytes: u32::try_from(memory.backing.capacity_bytes())
+                                    .unwrap_or(u32::MAX),
+                                put_id,
+                            },
+                        ))
                     })
                     .collect::<Vec<_>>()
             })
@@ -2964,7 +3592,7 @@ impl MasterKvRouter {
             .get(key)
             .map(|one_kv_nodes_routes| {
                 one_kv_nodes_routes
-                    .nodes_replicas
+                    .node_replicas
                     .read()
                     .values()
                     .any(|kv_info| !kv_info.tomb_tag.is_tomb())
@@ -3307,20 +3935,21 @@ impl MasterKvRouter {
         route: &OneKvNodesRoutes,
     ) {
         let replicas = route
-            .nodes_replicas
+            .node_replicas
             .read()
             .iter()
-            .filter_map(|(node_id, replica)| {
-                (!replica.tomb_tag.is_tomb()).then(|| {
-                    (
-                        node_id.as_ref().to_string(),
-                        NodeValueReplicaDesc {
-                            weight_bytes: u32::try_from(replica.backing.capacity_bytes())
-                                .unwrap_or(u32::MAX),
-                            put_id: route.put_id,
-                        },
-                    )
-                })
+            .filter_map(|(node_id, replicas)| {
+                let memory = (!replicas.tomb_tag.is_tomb())
+                    .then(|| replicas.memory.as_ref())
+                    .flatten()?;
+                Some((
+                    node_id.as_ref().to_string(),
+                    NodeValueReplicaDesc {
+                        weight_bytes: u32::try_from(memory.backing.capacity_bytes())
+                            .unwrap_or(u32::MAX),
+                        put_id: route.put_id,
+                    },
+                ))
             })
             .collect::<Vec<_>>();
         for (node_id, desc) in replicas {
@@ -3362,6 +3991,14 @@ impl MasterKvRouter {
     fn register_rpc_handlers(&self) {
         let p2p = self.0.view().p2p_module();
 
+        user_rpc_register_handler_async(
+            p2p,
+            NODE_POOL_CAPACITY_USER_RPC_PATH.to_string(),
+            Arc::new(NodePoolCapacityUserRpcHandler {
+                view: self.0.view().clone(),
+            }),
+        );
+
         // --- Get Handlers ---
         let view = self.0.view().clone();
         RPCHandler::<GetStartReq>::new().regist(p2p, move |resp, msg| {
@@ -3427,6 +4064,30 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<SsdStageBeginReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let task_view = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_ssd_stage_begin", async move {
+                let ack = handle_ssd_stage_begin(task_view, msg, req_node_id).await;
+                let _ = resp.send_resp(ack).await;
+            });
+            Ok(())
+        });
+
+        let view = self.0.view().clone();
+        RPCHandler::<SsdStageDoneReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let task_view = view.clone();
+            let req_node_id = resp.node_id().clone();
+            view.spawn("rpc_ssd_stage_done", async move {
+                let ack = handle_ssd_stage_done(task_view, msg, req_node_id).await;
+                let _ = resp.send_resp(ack).await;
+            });
+            Ok(())
+        });
+
         // --- CountPrefix Handler ---
         let view = self.0.view().clone();
         RPCHandler::<CountPrefixReq>::new().regist(p2p, move |resp, msg| {
@@ -3694,6 +4355,20 @@ impl MasterKvRouter {
             Ok(())
         });
 
+        let view = self.0.view().clone();
+        RPCHandler::<BatchPublishOwnerSsdReq>::new().regist(p2p, move |resp, msg| {
+            let view = view.clone();
+            let owner = resp.node_id().clone();
+            let view_task = view.clone();
+            let _ = view.spawn("rpc_batch_publish_owner_ssd", async move {
+                let ack = handle_batch_publish_owner_ssd(view_task, msg, owner).await;
+                if let Err(err) = resp.send_resp(ack).await {
+                    error!("Failed to send BatchPublishOwnerSsdResp: {:?}", err);
+                }
+            });
+            Ok(())
+        });
+
         let view = self.0.view().clone();
         RPCHandler::<PutAppendStartReq>::new().regist(p2p, move |resp, msg| {
             let view = view.clone();
@@ -4582,6 +5257,8 @@ impl MasterKvRouter {
         source_node_id: &str,
         bytes: u64,
         allocation_mode: GetAllocationMode,
+        source_kind: GetSourceKind,
+        source_is_requester_local_owner: bool,
     ) {
         let requester_source_key = RequesterTargetPair::new(requester_node_id, source_node_id);
         let source_count = self
@@ -4602,6 +5279,25 @@ impl MasterKvRouter {
             .clone();
         source_bytes.fetch_add(bytes, Ordering::Relaxed);
 
+        let source_class = match (source_kind, source_is_requester_local_owner) {
+            (GetSourceKind::Memory, true) => "local_memory",
+            (GetSourceKind::Memory, false) => "remote_memory",
+            (GetSourceKind::Ssd, true) => "local_ssd",
+            (GetSourceKind::Ssd, false) => "remote_ssd",
+        };
+        self.inner()
+            .get_source_class_counts
+            .entry(source_class)
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .fetch_add(1, Ordering::Relaxed);
+        self.inner()
+            .get_source_class_bytes
+            .entry(source_class)
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)))
+            .value()
+            .fetch_add(bytes, Ordering::Relaxed);
+
         let mode_key = match allocation_mode {
             GetAllocationMode::Temporary => "temporary",
             GetAllocationMode::ReuseReplica => "reuse_replica",
@@ -4684,6 +5380,22 @@ impl MasterKvRouter {
                             .collect();
                         get_source_bytes.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
 
+                        let mut get_source_class_counts: Vec<(String, u64)> = router
+                            .inner()
+                            .get_source_class_counts
+                            .iter()
+                            .map(|entry| (entry.key().to_string(), entry.value().load(Ordering::Relaxed)))
+                            .collect();
+                        get_source_class_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+
+                        let mut get_source_class_bytes: Vec<(String, u64)> = router
+                            .inner()
+                            .get_source_class_bytes
+                            .iter()
+                            .map(|entry| (entry.key().to_string(), entry.value().load(Ordering::Relaxed)))
+                            .collect();
+                        get_source_class_bytes.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+
                         let mut get_allocation_mode_counts: Vec<(String, u64)> = router
                             .inner()
                             .get_allocation_mode_counts
@@ -4693,7 +5405,7 @@ impl MasterKvRouter {
                         get_allocation_mode_counts.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
 
                         info!(
-                            "placement historical distribution | put_target_counts={:?} | put_mode_counts={:?} | put_requester_target_counts={:?} | replica_task_target_counts={:?} | replica_done_terminal_replays={} | get_requester_source_counts={:?} | get_requester_source_bytes={:?} | get_allocation_mode_counts={:?}",
+                            "placement historical distribution | put_target_counts={:?} | put_mode_counts={:?} | put_requester_target_counts={:?} | replica_task_target_counts={:?} | replica_done_terminal_replays={} | get_requester_source_counts={:?} | get_requester_source_bytes={:?} | get_source_class_counts={:?} | get_source_class_bytes={:?} | get_allocation_mode_counts={:?}",
                             target_counts,
                             mode_counts,
                             requester_target_counts,
@@ -4701,6 +5413,8 @@ impl MasterKvRouter {
                             replica_done_terminal_replays,
                             get_source_counts,
                             get_source_bytes,
+                            get_source_class_counts,
+                            get_source_class_bytes,
                             get_allocation_mode_counts,
                         );
                     }
@@ -4720,7 +5434,7 @@ impl MasterKvRouter {
             .inner()
             .view()
             .master_seg_manager()
-            .get_node_space_size(node_id);
+            .get_node_active_space_size(node_id);
         if node_space_size == 0 {
             return None;
         }
@@ -4806,7 +5520,7 @@ impl MasterKvRouter {
             .inner()
             .view()
             .master_seg_manager()
-            .get_node_space_size(node_id);
+            .get_node_active_space_size(node_id);
         let base_capacity = self.writeback_tier1_base_capacity(node_space_size)?;
         if base_capacity == 0 {
             return None;
@@ -4862,11 +5576,13 @@ impl MasterKvRouter {
             if route.put_id != desc.put_id || route.lease_id.is_some() {
                 return false;
             }
-            let replicas = route.nodes_replicas.read();
-            replicas.values().any(|replica| {
-                replica.node_id.as_ref() == source_node_id && !replica.tomb_tag.is_tomb()
-            }) && replicas.values().all(|replica| {
-                replica.tomb_tag.is_tomb() || replica.node_id.as_ref() == source_node_id
+            let replicas = route.node_replicas.read();
+            replicas.iter().any(|(node_id, replica)| {
+                node_id.as_ref() == source_node_id
+                    && !replica.tomb_tag.is_tomb()
+                    && replica.memory.is_some()
+            }) && replicas.iter().all(|(node_id, replica)| {
+                !replica.has_live_backing() || node_id.as_ref() == source_node_id
             })
         })
     }
@@ -4974,6 +5690,8 @@ impl MasterKvRouter {
         if !self.replica_cache_enabled() {
             return Ok(());
         }
+        let capacity_lock = self.node_capacity_boundary_lock(node_id);
+        let _capacity_guard = capacity_lock.lock();
         if !reserved_capacity.generation.same_generation(generation) {
             return Err(
                 crate::rpcresp_kvresult_convert::msg_and_error::KvError::Api(
@@ -5021,91 +5739,20 @@ impl MasterKvRouter {
             return Ok(());
         }
 
-        // Recompute target capacity from the configured base ratio minus live reservations.
-        let reserved_total = reserved_capacity.total_reserved_bytes();
-        let node_space_size = self
-            .inner()
-            .view()
-            .master_seg_manager()
-            .get_node_space_size(node_id);
-        if node_space_size == 0 {
+        if let Err(err) = self.apply_node_cache_capacity_locked(node_id) {
             if delta_bytes >= 0 {
                 reserved_capacity.apply_delta(reason, -delta_bytes);
-            }
-            return Err(
-                crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
-                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::OwnerNoSeg {
-                        detail: format!(
-                            "node_id={} has no segment (node_space_size=0) while adjusting cache capacity",
-                            node_id
-                        ),
-                    },
-                ),
-            );
-        }
-        let boundaries = node_cache_capacity_boundaries(
-            node_space_size,
-            self.inner().replica_cache_capacity_ratio,
-            self.inner().replica_writeback_tier1_capacity_ratio,
-            reserved_total,
-        );
-        let new_capacity = boundaries.ring_b_bytes;
-
-        if let Some(cache) = self.get_node_cache_controller(node_id) {
-            if let Some(tier1_cache) = self
-                .inner()
-                .node_writeback_tier1_controller
-                .get(node_id)
-                .map(|entry| entry.value().clone())
-            {
-                // Local-reserve and owner-indexed reservations consume the
-                // physical ring-B allocation domain. They must not collapse
-                // the independent inclusive tier1 metadata window.
-                let tier1_capacity = boundaries.tier1_bytes.unwrap_or(0);
-                if let Err(e) = tier1_cache.set_max_capacity(tier1_capacity) {
-                    if delta_bytes >= 0 {
-                        reserved_capacity.apply_delta(reason, -delta_bytes);
-                    }
-                    return Err(
-                        crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
-                            crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                                rpc_input_json: format!(
-                                    "tier1 moka.set_max_capacity failed: node_id={}, new_capacity={}, err={}",
-                                    node_id, tier1_capacity, e
-                                ),
-                            },
-                        ),
+                if let Err(rollback_err) = self.apply_node_cache_capacity_locked(node_id) {
+                    error!(
+                        node = node_id,
+                        error = %rollback_err,
+                        "failed to restore node cache boundary after reservation rollback"
                     );
                 }
             }
-            if let Err(e) = cache.set_max_capacity(new_capacity) {
-                if delta_bytes >= 0 {
-                    reserved_capacity.apply_delta(reason, -delta_bytes);
-                }
-                return Err(
-                    crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
-                        crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::RpcDecodeError {
-                            rpc_input_json: format!(
-                                "ring-B allocation moka.set_max_capacity failed: node_id={}, new_capacity={}, err={}",
-                                node_id, new_capacity, e
-                            ),
-                        },
-                    ),
-                );
-            }
-            Ok(())
-        } else {
-            if delta_bytes >= 0 {
-                reserved_capacity.apply_delta(reason, -delta_bytes);
-            }
-            Err(
-                crate::rpcresp_kvresult_convert::msg_and_error::KvError::Unreachable(
-                    crate::rpcresp_kvresult_convert::msg_and_error::UnreachableError::OwnerNoSeg {
-                        detail: format!("node_id={} cache_controller not found", node_id),
-                    },
-                ),
-            )
+            return Err(err);
         }
+        Ok(())
     }
 
     /// Reserve cache capacity for one exact live node generation.  The returned
@@ -5256,11 +5903,15 @@ impl MasterKvRouter {
         for entry in self.inner().node_kv_cache_controller.iter() {
             let owner_node = entry.key().clone();
             let cache = entry.value().clone();
-            let node_space_size = self
+            let Some((owner_node_start_time, pool_capacity)) = self
                 .inner()
                 .view()
                 .master_seg_manager()
-                .get_node_space_size(owner_node.as_str());
+                .get_node_pool_capacity(owner_node.as_str())
+            else {
+                continue;
+            };
+            let node_space_size = pool_capacity.active_capacity_bytes;
             let base_capacity_bytes = self.replica_cache_base_capacity(node_space_size);
             let reserved_capacity_bytes = self
                 .inner()
@@ -5284,6 +5935,14 @@ impl MasterKvRouter {
                 .map(|entry| entry.value().clone());
             replica_cache_nodes.push(ReplicaCacheNodeObserveSnapshot {
                 owner_node: owner_node.clone(),
+                owner_node_start_time,
+                pool_physical_capacity_bytes: pool_capacity.physical_capacity_bytes,
+                pool_active_capacity_bytes: pool_capacity.active_capacity_bytes,
+                pool_used_capacity_bytes: pool_capacity.used_capacity_bytes,
+                pool_parked_capacity_bytes: pool_capacity.parked_capacity_bytes,
+                pool_draining_capacity_bytes: pool_capacity.draining_capacity_bytes,
+                pool_available_capacity_bytes: pool_capacity.available_capacity_bytes,
+                pool_capacity_epoch: pool_capacity.capacity_epoch,
                 entries: cache.entry_count(),
                 weighted_bytes: cache.weighted_size(),
                 effective_capacity_bytes,
@@ -5467,9 +6126,73 @@ impl MasterKvRouter {
                                 .planned_get_counters
                                 .plan_revoked
                                 .load(Ordering::Relaxed),
+                            remote_ssd_filtered_items = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .remote_ssd_filtered_items
+                                .load(Ordering::Relaxed),
+                            remote_ssd_filtered_bytes = view_task
+                                .master_kv_router()
+                                .inner()
+                                .planned_get_counters
+                                .remote_ssd_filtered_bytes
+                                .load(Ordering::Relaxed),
                             "master metadata-only Get plan runtime"
                         );
+                        let ssd_tier = &view_task.master_kv_router().inner().ssd_tier_counters;
+                        tracing::info!(
+                            local_ssd_selected_with_remote_memory_items = ssd_tier
+                                .local_ssd_selected_with_remote_memory_items
+                                .load(Ordering::Relaxed),
+                            local_ssd_selected_with_remote_memory_bytes = ssd_tier
+                                .local_ssd_selected_with_remote_memory_bytes
+                                .load(Ordering::Relaxed),
+                            local_ssd_selected_without_remote_memory_items = ssd_tier
+                                .local_ssd_selected_without_remote_memory_items
+                                .load(Ordering::Relaxed),
+                            local_ssd_selected_without_remote_memory_bytes = ssd_tier
+                                .local_ssd_selected_without_remote_memory_bytes
+                                .load(Ordering::Relaxed),
+                            local_ssd_published_with_remote_memory_items = ssd_tier
+                                .local_ssd_published_with_remote_memory_items
+                                .load(Ordering::Relaxed),
+                            local_ssd_published_with_remote_memory_bytes = ssd_tier
+                                .local_ssd_published_with_remote_memory_bytes
+                                .load(Ordering::Relaxed),
+                            local_ssd_published_without_remote_memory_items = ssd_tier
+                                .local_ssd_published_without_remote_memory_items
+                                .load(Ordering::Relaxed),
+                            local_ssd_published_without_remote_memory_bytes = ssd_tier
+                                .local_ssd_published_without_remote_memory_bytes
+                                .load(Ordering::Relaxed),
+                            memory_removed_ssd_survived_items = ssd_tier
+                                .memory_removed_ssd_survived_items
+                                .load(Ordering::Relaxed),
+                            memory_removed_ssd_survived_bytes = ssd_tier
+                                .memory_removed_ssd_survived_bytes
+                                .load(Ordering::Relaxed),
+                            memory_removed_ssd_became_only_items = ssd_tier
+                                .memory_removed_ssd_became_only_items
+                                .load(Ordering::Relaxed),
+                            memory_removed_ssd_became_only_bytes = ssd_tier
+                                .memory_removed_ssd_became_only_bytes
+                                .load(Ordering::Relaxed),
+                            "master SSD substitution runtime"
+                        );
                         for node in snapshot.replica_cache_nodes {
+                            tracing::info!(
+                                "node pool capacity runtime: owner={} owner_node_start_time={} capacity_epoch={} physical_capacity_bytes={} active_capacity_bytes={} used_capacity_bytes={} parked_capacity_bytes={} draining_capacity_bytes={} available_capacity_bytes={}",
+                                node.owner_node,
+                                node.owner_node_start_time,
+                                node.pool_capacity_epoch,
+                                node.pool_physical_capacity_bytes,
+                                node.pool_active_capacity_bytes,
+                                node.pool_used_capacity_bytes,
+                                node.pool_parked_capacity_bytes,
+                                node.pool_draining_capacity_bytes,
+                                node.pool_available_capacity_bytes,
+                            );
                             tracing::info!(
                                 "replica cache runtime: owner={} entries={} weighted_bytes={} effective_capacity_bytes={} base_capacity_bytes={} reserved_capacity_bytes={} pending_eviction_reclaim_bytes={} writeback_tier1_entries={} writeback_tier1_weighted_bytes={} writeback_tier1_capacity_bytes={} writeback_tier1_triggered={} writeback_tier1_owner_accepted={} writeback_tier1_failed={} reclaim_master_activity_deferred={} reclaim_owner_holder_deferred={} reclaim_owner_other_deferred={} reclaim_route_changed={} reclaim_retry_queued={} reclaim_retry_completed={} reclaim_retry_restored={} reclaim_completed={} source_evict_rpc_requests={} source_evict_victims={} source_evict_requested_bytes={} source_evict_accepted={} source_evict_in_progress={} source_evict_completed={} source_evict_retryable_busy={} source_evict_stale={} source_evict_rejected={} last_route_removed_members={} last_route_removed_bytes={} capacity_eviction_non_ring_b_entry_total={} capacity_eviction_hit_committed_slot={} eviction_reclaim_deduplicated={}",
                                 node.owner_node,
@@ -5541,6 +6264,31 @@ impl MasterKvRouter {
                                 "writeback_tier1",
                                 node.writeback_tier1_capacity_bytes,
                             );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "pool_physical",
+                                node.pool_physical_capacity_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "pool_active",
+                                node.pool_active_capacity_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "pool_used",
+                                node.pool_used_capacity_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "pool_parked",
+                                node.pool_parked_capacity_bytes,
+                            );
+                            metrics.set_kv_replica_cache_capacity_bytes(
+                                node.owner_node.as_str(),
+                                "pool_draining",
+                                node.pool_draining_capacity_bytes,
+                            );
                         }
                     }
                 }
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
index b873956..6cbfca9 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/msg_pack.rs
@@ -23,6 +23,13 @@ pub enum GetAllocationMode {
     ExternalSink = 4,
 }
 
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum GetSourceKind {
+    #[default]
+    Memory = 0,
+    Ssd = 1,
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
 pub struct GetPreparedLocalReserveTarget {
     pub grant_id: u64,
@@ -68,6 +75,7 @@ pub struct GetStartResp {
     pub target_base_addr: u64,
     pub src_base_addr: u64,
     pub len: u64,
+    pub source_kind: GetSourceKind,
     /// Echoes the owner-local slot accepted as this Get's target.
     pub prepared_target: Option<GetPreparedLocalReserveTarget>,
     pub atomic_group: Option<PutAtomicGroup>,
@@ -135,6 +143,62 @@ impl RPCReq for GetDoneReq {
     type Resp = GetDoneResp;
 }
 
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct SsdStageBeginReq {
+    pub get_id: u64,
+}
+
+impl MsgPackSerializePart for SsdStageBeginReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::SsdStageBeginReq as u32
+    }
+}
+
+impl RPCReq for SsdStageBeginReq {
+    type Resp = SsdStageBeginResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct SsdStageBeginResp {
+    pub started: bool,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for SsdStageBeginResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::SsdStageBeginResp as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct SsdStageDoneReq {
+    pub get_id: u64,
+    pub drop_ssd_source: bool,
+}
+
+impl MsgPackSerializePart for SsdStageDoneReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::SsdStageDoneReq as u32
+    }
+}
+
+impl RPCReq for SsdStageDoneReq {
+    type Resp = SsdStageDoneResp;
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct SsdStageDoneResp {
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for SsdStageDoneResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::SsdStageDoneResp as u32
+    }
+}
+
 #[derive(Default, Debug, Clone, Encode, Decode)]
 pub struct BatchGetStartReq {
     pub keys: Vec<String>,
@@ -161,6 +225,7 @@ pub struct BatchGetStartItemResp {
     pub target_base_addr: u64,
     pub src_base_addr: u64,
     pub len: u64,
+    pub source_kind: GetSourceKind,
     pub prepared_target: Option<GetPreparedLocalReserveTarget>,
     pub atomic_group: Option<PutAtomicGroup>,
     pub error_code: ErrorCode,
@@ -203,9 +268,11 @@ pub struct BatchGetPlanItemResp {
     pub src_addr: u64,
     pub src_base_addr: u64,
     pub len: u64,
+    pub source_kind: GetSourceKind,
     pub atomic_group: Option<PutAtomicGroup>,
-    /// False when the selected source is the external requester's local
-    /// share-group owner and therefore cannot use the RDMA-only GPU sink.
+    /// True only for remote memory. Requester-local memory and every SSD
+    /// source must materialize through an owner CPU holder instead of binding
+    /// the RDMA-only GPU sink.
     pub gpu_direct_eligible: bool,
     pub error_code: ErrorCode,
     pub error_json: String,
@@ -507,9 +574,21 @@ pub enum OwnerReclaimBacking {
         slot_index: u32,
         slot_size: u64,
     },
-    /// A master-owned allocation with no owner-side key index. The master reclaims this
-    /// backing directly after installing its key-activity fence and never sends it to the owner.
-    UnindexedAllocation,
+    /// A master-owned allocation with no owner-side key index.
+    ///
+    /// SSD-capable owners use this exact source identity to persist the bytes while the
+    /// master's route and key-activity fence keep the allocation alive. Owners without SSD
+    /// still skip owner coordination and let the master reclaim the allocation directly.
+    UnindexedAllocation {
+        /// Absolute address in the owner's registered CPU segment.
+        addr: u64,
+        /// Base address of the exact registered segment generation.
+        base_addr: u64,
+        /// Logical KV payload length.
+        len: u64,
+        /// Physical allocator capacity released when the master drops the allocation.
+        capacity_bytes: u64,
+    },
 }
 
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
@@ -519,12 +598,31 @@ pub enum OwnerReclaimReason {
     MasterAllocationCapacity,
 }
 
+/// Per-victim SSD action for owner-local capacity reclaim. Selection and
+/// deletion remain single-KV decisions even when one RPC carries a vector.
+#[derive(Default, Debug, Clone, Copy, Hash, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerSourceSsdPolicy {
+    /// Delete the exact memory source without preserving it on SSD.
+    #[default]
+    Drop,
+    /// Ask the master to return `SsdCandidate` only if this is the last live
+    /// backing. Sources with another backing are deleted immediately.
+    SelectLastLive,
+    /// The owner has durably persisted this generation and supplied its exact
+    /// length in `ssd_backing_len`.
+    Persisted,
+}
+
 /// One exact owner-local source selected for capacity eviction.
 #[derive(Default, Debug, Clone, Hash, PartialEq, Eq, Encode, Decode)]
 pub struct OwnerSourceEvictionVictim {
     pub key: String,
     pub put_id: PutIDForAKey,
     pub backing: OwnerReclaimBacking,
+    /// Durable owner-local SSD bytes prepared under the exact source fence.
+    /// The master installs this backing immediately before deleting `memory`.
+    pub ssd_backing_len: Option<u64>,
+    pub ssd_policy: OwnerSourceSsdPolicy,
 }
 
 pub(crate) fn owner_source_eviction_epoch(operation_id: u64, victim_index: usize) -> u64 {
@@ -554,6 +652,7 @@ pub enum OwnerSourceEvictionOutcome {
     Accepted,
     AlreadyInProgress,
     Completed,
+    SsdCandidate,
     RetryableBusy,
     Stale,
     RejectedNotEvictable,
@@ -563,6 +662,7 @@ pub enum OwnerSourceEvictionOutcome {
 pub struct OwnerSourceEvictionVictimResp {
     pub victim_index: u32,
     pub outcome: OwnerSourceEvictionOutcome,
+    pub ssd_backing_committed: bool,
     pub detail: String,
 }
 
@@ -584,6 +684,63 @@ impl RPCReq for BatchEvictOwnerSourceReq {
     type Resp = BatchEvictOwnerSourceResp;
 }
 
+/// One durable same-owner SSD generation to publish without removing memory.
+#[derive(Default, Debug, Clone, Hash, PartialEq, Eq, Encode, Decode)]
+pub struct OwnerSsdPublishItem {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub len: u64,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPublishOwnerSsdReq {
+    /// Membership generation of the authenticated owner.
+    pub owner_node_start_time: i64,
+    pub items: Vec<OwnerSsdPublishItem>,
+}
+
+impl MsgPackSerializePart for BatchPublishOwnerSsdReq {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPublishOwnerSsdReq as u32
+    }
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
+pub enum OwnerSsdPublishOutcome {
+    #[default]
+    Unspecified,
+    Published,
+    AlreadyPresent,
+    RetryableBusy,
+    Obsolete,
+    Rejected,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct OwnerSsdPublishItemResp {
+    pub key: String,
+    pub put_id: PutIDForAKey,
+    pub outcome: OwnerSsdPublishOutcome,
+    pub detail: String,
+}
+
+#[derive(Default, Debug, Clone, Encode, Decode)]
+pub struct BatchPublishOwnerSsdResp {
+    pub items: Vec<OwnerSsdPublishItemResp>,
+    pub error_code: ErrorCode,
+    pub error_json: String,
+}
+
+impl MsgPackSerializePart for BatchPublishOwnerSsdResp {
+    fn msg_id(&self) -> u32 {
+        MsgId::BatchPublishOwnerSsdResp as u32
+    }
+}
+
+impl RPCReq for BatchPublishOwnerSsdReq {
+    type Resp = BatchPublishOwnerSsdResp;
+}
+
 #[derive(Default, Debug, Clone, PartialEq, Eq, Encode, Decode)]
 pub struct OwnerReclaimItem {
     pub key: String,
@@ -610,6 +767,10 @@ pub struct OwnerReclaimItemResp {
     pub key: String,
     pub epoch: u64,
     pub state: OwnerReclaimItemState,
+    /// Durable bytes persisted by the owner while the exact memory source is
+    /// hidden behind the Prepare fence.  The master publishes this backing on
+    /// the existing route before it asks the owner to Commit/free DRAM.
+    pub ssd_backing_len: Option<u64>,
     pub detail: String,
 }
 
@@ -1623,6 +1784,22 @@ mod put_atomic_group_tests {
         assert_eq!(decoded.items[0].atomic_group.as_ref(), Some(&group));
     }
 
+    #[test]
+    fn owner_ssd_publish_only_batch_round_trips_exact_generation() {
+        let req = BatchPublishOwnerSsdReq {
+            owner_node_start_time: 41,
+            items: vec![OwnerSsdPublishItem {
+                key: "ssd-key".to_string(),
+                put_id: (17, 3),
+                len: 4_718_592,
+            }],
+        };
+        let decoded: BatchPublishOwnerSsdReq =
+            bitcode::decode(&bitcode::encode(&req)).expect("decode owner SSD publication");
+        assert_eq!(decoded.owner_node_start_time, 41);
+        assert_eq!(decoded.items, req.items);
+    }
+
     #[test]
     fn grouped_batch_put_done_wire_is_linear_and_round_trips() {
         let keys_and_put_ids = (0..128)
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
index 1880278..161d950 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/placement.rs
@@ -119,9 +119,9 @@ impl PlacementPolicy for LocalFirstPlacementPolicy {
                         continue;
                     };
 
-                    let total = allocator.total_size_bytes();
-                    let used = allocator.used_size_bytes();
-                    let free = total.saturating_sub(used);
+                    let capacity = allocator.node_pool_capacity_snapshot();
+                    let total = capacity.active_capacity_bytes;
+                    let free = capacity.available_capacity_bytes;
                     last_no_space_ctx = Some((
                         node_id.as_ref().to_string(),
                         allocator.seg_device_id.clone(),
@@ -152,9 +152,9 @@ impl PlacementPolicy for LocalFirstPlacementPolicy {
             let all_segs = seg_manager.get_all_segments_allocator();
             if let Some((nodeid, allocator)) = all_segs.choose(&mut rand::thread_rng()).cloned() {
                 let node_id: NodeID = nodeid.into();
-                let total = allocator.total_size_bytes();
-                let used = allocator.used_size_bytes();
-                let free = total.saturating_sub(used);
+                let capacity = allocator.node_pool_capacity_snapshot();
+                let total = capacity.active_capacity_bytes;
+                let free = capacity.available_capacity_bytes;
                 last_no_space_ctx = Some((
                     node_id.as_ref().to_string(),
                     allocator.seg_device_id.clone(),
@@ -260,9 +260,9 @@ impl PlacementPolicy for RandomPlacementPolicy {
                         continue;
                     };
 
-                    let total = allocator.total_size_bytes();
-                    let used = allocator.used_size_bytes();
-                    let free = total.saturating_sub(used);
+                    let capacity = allocator.node_pool_capacity_snapshot();
+                    let total = capacity.active_capacity_bytes;
+                    let free = capacity.available_capacity_bytes;
                     last_no_space_ctx = Some((
                         node_id.as_ref().to_string(),
                         allocator.seg_device_id.clone(),
@@ -294,9 +294,9 @@ impl PlacementPolicy for RandomPlacementPolicy {
                     continue;
                 }
 
-                let total = allocator.total_size_bytes();
-                let used = allocator.used_size_bytes();
-                let free = total.saturating_sub(used);
+                let capacity = allocator.node_pool_capacity_snapshot();
+                let total = capacity.active_capacity_bytes;
+                let free = capacity.available_capacity_bytes;
                 last_no_space_ctx = Some((
                     node_id.as_ref().to_string(),
                     allocator.seg_device_id.clone(),
@@ -449,9 +449,10 @@ fn collect_remote_candidates(
             continue;
         }
 
-        let total = allocator.total_size_bytes();
-        let used = allocator.used_size_bytes();
-        let free = total.saturating_sub(used);
+        let capacity = allocator.node_pool_capacity_snapshot();
+        let total = capacity.active_capacity_bytes;
+        let used = capacity.used_capacity_bytes;
+        let free = capacity.available_capacity_bytes;
         let node_key = node_id.as_ref().to_string();
         let node_write_count = view
             .master_kv_router()
@@ -798,9 +799,9 @@ fn choose_random_remote_target_with_allocator(
             let Some(allocator) = node_allocators.choose(&mut rand::thread_rng()).cloned() else {
                 continue;
             };
-            let total = allocator.total_size_bytes();
-            let used = allocator.used_size_bytes();
-            let free = total.saturating_sub(used);
+            let capacity = allocator.node_pool_capacity_snapshot();
+            let total = capacity.active_capacity_bytes;
+            let free = capacity.available_capacity_bytes;
             last_no_space_ctx = Some((
                 node_id.as_ref().to_string(),
                 allocator.seg_device_id.clone(),
@@ -825,9 +826,9 @@ fn choose_random_remote_target_with_allocator(
         .collect();
     candidates.shuffle(&mut rand::thread_rng());
     for (node_id, allocator) in candidates {
-        let total = allocator.total_size_bytes();
-        let used = allocator.used_size_bytes();
-        let free = total.saturating_sub(used);
+        let capacity = allocator.node_pool_capacity_snapshot();
+        let total = capacity.active_capacity_bytes;
+        let free = capacity.available_capacity_bytes;
         last_no_space_ctx = Some((
             node_id.as_ref().to_string(),
             allocator.seg_device_id.clone(),
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
index f5bdef4..4ce99a6 100755
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/put.rs
@@ -1,19 +1,21 @@
 use super::{
     CommittedSlotReplica, CompletedReplicaTaskInfo, InflightPutAllocation, InflightPutCommitInfo,
-    InflightPutInfo, InflightReplicaTaskInfo, KvReplicaBacking, KvRouteInfo, LocalReserveGrantInfo,
-    MasterKeyActivityCompletionGuard, MasterKvRouterView, NodeCacheCapacityReservation,
-    OwnerHoldingGetInfo, PreparedPutKeyReservationInfo, PutPlacementMode, ReservedCapacityReason,
+    InflightPutInfo, InflightReplicaTaskInfo, KvMemoryReplica, KvNodeReplicas, KvReplicaBacking,
+    LocalReserveGrantInfo, MasterKeyActivityCompletionGuard, MasterKvRouterView,
+    NodeCacheCapacityReservation, OwnerHoldingGetInfo, PreparedPutKeyReservationInfo,
+    PutPlacementMode, ReservedCapacityReason, SsdReplicaCommitStatus,
     msg_pack::{
-        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPutAppendDoneItemResp,
-        BatchPutAppendDoneReq, BatchPutAppendDoneResp, BatchPutAppendStartItemResp,
-        BatchPutAppendStartReq, BatchPutAppendStartResp, BatchPutDoneItemResp, BatchPutDoneReq,
-        BatchPutDoneResp, BatchPutRevokeItemResp, BatchPutRevokeReq, BatchPutRevokeResp,
-        BatchPutStartItemResp, BatchPutStartReq, BatchPutStartResp,
-        BatchReleasePutKeyReservationsReq, BatchReleasePutKeyReservationsResp,
-        GroupedBatchPutDoneReq, GroupedBatchPutDoneResp, PutAppendDoneReq, PutAppendDoneResp,
-        PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartOutcome, PutAppendStartReq,
-        PutAppendStartResp, PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq, PutDoneResp,
-        PutRevokeReq, PutRevokeResp, PutStartReq, PutStartResp, ReleaseLocalGrantReq,
+        BatchPreparePutKeysReq, BatchPreparePutKeysResp, BatchPublishOwnerSsdReq,
+        BatchPublishOwnerSsdResp, BatchPutAppendDoneItemResp, BatchPutAppendDoneReq,
+        BatchPutAppendDoneResp, BatchPutAppendStartItemResp, BatchPutAppendStartReq,
+        BatchPutAppendStartResp, BatchPutDoneItemResp, BatchPutDoneReq, BatchPutDoneResp,
+        BatchPutRevokeItemResp, BatchPutRevokeReq, BatchPutRevokeResp, BatchPutStartItemResp,
+        BatchPutStartReq, BatchPutStartResp, BatchReleasePutKeyReservationsReq,
+        BatchReleasePutKeyReservationsResp, GroupedBatchPutDoneReq, GroupedBatchPutDoneResp,
+        OwnerSsdPublishItem, OwnerSsdPublishItemResp, OwnerSsdPublishOutcome, PutAppendDoneReq,
+        PutAppendDoneResp, PutAppendRevokeReq, PutAppendRevokeResp, PutAppendStartOutcome,
+        PutAppendStartReq, PutAppendStartResp, PutAtomicGroup, PutDoneCommittedSlot, PutDoneReq,
+        PutDoneResp, PutRevokeReq, PutRevokeResp, PutStartReq, PutStartResp, ReleaseLocalGrantReq,
         ReleaseLocalGrantResp, ReserveLocalGrantOutcome, ReserveLocalGrantReq,
         ReserveLocalGrantResp, build_shared_put_atomic_group_assignments,
     },
@@ -44,11 +46,168 @@ use parking_lot::RwLock;
 use rand::seq::SliceRandom;
 use std::{
     collections::{HashMap, HashSet},
-    sync::{Arc, atomic::AtomicU32},
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
 };
 
 pub type PutIDForAKey = (u64, u32);
 
+fn publish_owner_ssd_item(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    item: OwnerSsdPublishItem,
+) -> OwnerSsdPublishItemResp {
+    let response = |outcome, detail: String| OwnerSsdPublishItemResp {
+        key: item.key.clone(),
+        put_id: item.put_id,
+        outcome,
+        detail,
+    };
+    let _activity = match view
+        .master_kv_router()
+        .reserve_inflight_replica_key(&item.key)
+    {
+        Ok(activity) => activity,
+        Err(err) => {
+            return response(
+                OwnerSsdPublishOutcome::RetryableBusy,
+                format!("master key activity is busy: {err}"),
+            );
+        }
+    };
+
+    let Some(route) = view.master_kv_router().inner().kv_routes.get(&item.key) else {
+        return response(
+            OwnerSsdPublishOutcome::Obsolete,
+            "route is absent".to_string(),
+        );
+    };
+    if route.put_id != item.put_id {
+        return response(
+            OwnerSsdPublishOutcome::Obsolete,
+            format!(
+                "route generation changed: current=({},{})",
+                route.put_id.0, route.put_id.1
+            ),
+        );
+    }
+
+    let has_remote_memory = {
+        let replicas = route.node_replicas.read();
+        let Some(owner_replicas) = replicas.get(owner) else {
+            return response(
+                OwnerSsdPublishOutcome::Obsolete,
+                "same-owner route entry is absent".to_string(),
+            );
+        };
+        if owner_replicas.tomb_tag.is_tomb() {
+            return response(
+                OwnerSsdPublishOutcome::Obsolete,
+                "same-owner generation is tombed".to_string(),
+            );
+        }
+        if let Some(existing) = owner_replicas.ssd.as_ref() {
+            return if existing.len == item.len {
+                response(
+                    OwnerSsdPublishOutcome::AlreadyPresent,
+                    "same-owner SSD backing is already published".to_string(),
+                )
+            } else {
+                response(
+                    OwnerSsdPublishOutcome::Rejected,
+                    format!(
+                        "existing SSD length mismatch: existing={} requested={}",
+                        existing.len, item.len
+                    ),
+                )
+            };
+        }
+        replicas.iter().any(|(node_id, replicas)| {
+            node_id != owner && !replicas.tomb_tag.is_tomb() && replicas.memory.is_some()
+        })
+    };
+
+    match route.commit_ssd_replica(owner, item.len) {
+        SsdReplicaCommitStatus::Committed => {
+            let counters = &view.master_kv_router().inner().ssd_tier_counters;
+            let (items, bytes) = if has_remote_memory {
+                (
+                    &counters.local_ssd_published_with_remote_memory_items,
+                    &counters.local_ssd_published_with_remote_memory_bytes,
+                )
+            } else {
+                (
+                    &counters.local_ssd_published_without_remote_memory_items,
+                    &counters.local_ssd_published_without_remote_memory_bytes,
+                )
+            };
+            items.fetch_add(1, Ordering::Relaxed);
+            bytes.fetch_add(item.len, Ordering::Relaxed);
+            response(
+                OwnerSsdPublishOutcome::Published,
+                "same-owner SSD backing published while memory remains live".to_string(),
+            )
+        }
+        SsdReplicaCommitStatus::MissingMemory | SsdReplicaCommitStatus::TombedNode => response(
+            OwnerSsdPublishOutcome::Obsolete,
+            "exact live same-owner memory generation is absent".to_string(),
+        ),
+        SsdReplicaCommitStatus::LengthMismatch => response(
+            OwnerSsdPublishOutcome::Rejected,
+            format!(
+                "SSD length does not match same-owner memory: requested={}",
+                item.len
+            ),
+        ),
+    }
+}
+
+/// Publish durable same-owner SSD bytes onto the current route without
+/// deleting or replacing the memory backing.
+pub async fn handle_batch_publish_owner_ssd(
+    view: MasterKvRouterView,
+    req: MsgPack<BatchPublishOwnerSsdReq>,
+    owner: NodeID,
+) -> MsgPack<BatchPublishOwnerSsdResp> {
+    let current_generation = view
+        .cluster_manager()
+        .get_member_info_cached(owner.as_ref())
+        .map(|member| member.node_start_time);
+    if current_generation != Some(req.serialize_part.owner_node_start_time) {
+        let err = msg_and_error::KvError::Api(msg_and_error::ApiError::InvalidArgument {
+            detail: format!(
+                "owner SSD publication generation mismatch: owner={} requested={} current={:?}",
+                owner, req.serialize_part.owner_node_start_time, current_generation
+            ),
+        });
+        return MsgPack {
+            serialize_part: BatchPublishOwnerSsdResp {
+                items: Vec::new(),
+                error_code: err.code(),
+                error_json: err.to_json(),
+            },
+            raw_bytes: Vec::new(),
+        };
+    }
+
+    let items = req
+        .serialize_part
+        .items
+        .into_iter()
+        .map(|item| publish_owner_ssd_item(&view, &owner, item))
+        .collect();
+    MsgPack {
+        serialize_part: BatchPublishOwnerSsdResp {
+            items,
+            error_code: msg_and_error::OK,
+            error_json: String::new(),
+        },
+        raw_bytes: Vec::new(),
+    }
+}
+
 fn validate_put_start_source_node_override(
     view: &MasterKvRouterView,
     requester_node_id: &NodeID,
@@ -155,10 +314,10 @@ fn current_route_append_outcome(
     verify_put_id: PutIDForAKey,
 ) -> PutAppendStartOutcome {
     let has_complete_remote = route
-        .nodes_replicas
+        .node_replicas
         .read()
-        .values()
-        .any(|replica| !replica.tomb_tag.is_tomb() && replica.node_id != *source_node_id);
+        .iter()
+        .any(|(node_id, replicas)| node_id != source_node_id && replicas.has_live_backing());
     classify_put_append_start_outcome(route.put_id == verify_put_id, has_complete_remote)
 }
 
@@ -265,14 +424,13 @@ fn append_current_route_replica_if_matching(
     let published = publish_route_replica_tomb_fenced(
         &one_kv_nodes_routes,
         node_id.clone(),
-        KvRouteInfo {
-            node_id: node_id.clone(),
+        KvMemoryReplica {
             backing: KvReplicaBacking::Allocation(Arc::new(allocation)),
             owner_local_indexed: false,
             get_durable_reservation: None,
             capacity_reservation,
-            tomb_tag: target_tomb_tag,
         },
+        target_tomb_tag,
     );
     if !published {
         tracing::warn!(
@@ -326,15 +484,13 @@ fn allocate_from_node_local_segment(
         );
     }
 
-    let total = allocator.total_size_bytes();
-    let used = allocator.used_size_bytes();
-    let free = total.saturating_sub(used);
+    let capacity = allocator.node_pool_capacity_snapshot();
     Err(msg_and_error::KvError::Api(
         msg_and_error::ApiError::NoSpace {
             node: node_id.as_ref().to_string(),
             segment: allocator.seg_device_id.clone(),
-            total_capacity: total,
-            free_capacity: free,
+            total_capacity: capacity.active_capacity_bytes,
+            free_capacity: capacity.available_capacity_bytes,
         },
     ))
 }
@@ -558,22 +714,25 @@ async fn publish_completed_put_route(
     lease_id_opt: Option<u64>,
     atomic_group: Option<Arc<super::msg_pack::PutAtomicGroup>>,
     node_id: NodeID,
-    completed_info: KvRouteInfo,
+    publish_tag: crate::master_seg_manager::NodeTombTag,
+    completed_info: KvMemoryReplica,
     target_cap_bytes: u64,
     local_cache_holder_id: Option<u64>,
 ) -> MsgPack<PutDoneResp> {
-    let publish_tag = completed_info.tomb_tag.clone();
     let new_route = Arc::new(OneKvNodesRoutes {
         put_id,
         lease_id: lease_id_opt,
         atomic_group: atomic_group.clone(),
-        nodes_replicas: RwLock::new(HashMap::from([(node_id.clone(), completed_info)])),
+        node_replicas: RwLock::new(HashMap::from([(
+            node_id.clone(),
+            KvNodeReplicas::memory(publish_tag.clone(), completed_info),
+        )])),
         get_durable_slots_used: AtomicU32::new(0),
     });
     let old_one_kv_routes = match publish_primary_route_tomb_fenced(
         &view.master_kv_router().inner().kv_routes,
         &key,
-        new_route,
+        new_route.clone(),
         &publish_tag,
     ) {
         Ok(previous) => previous,
@@ -1485,13 +1644,11 @@ async fn handle_put_done_with_resolved_group(
                     drop(target_allocation);
                     (
                         target_cap_bytes,
-                        KvRouteInfo {
-                            node_id: node_id.clone(),
+                        KvMemoryReplica {
                             backing: KvReplicaBacking::CommittedSlot(committed_slot),
                             owner_local_indexed: true,
                             get_durable_reservation: None,
                             capacity_reservation,
-                            tomb_tag: slot_tomb_tag,
                         },
                         false,
                     )
@@ -1527,13 +1684,11 @@ async fn handle_put_done_with_resolved_group(
                     };
                     (
                         target_cap_bytes,
-                        KvRouteInfo {
-                            node_id: node_id.clone(),
+                        KvMemoryReplica {
                             backing: KvReplicaBacking::Allocation(Arc::new(target_allocation)),
                             owner_local_indexed: req.serialize_part.publish_local_cache,
                             get_durable_reservation: None,
                             capacity_reservation,
-                            tomb_tag,
                         },
                         true,
                     )
@@ -1565,13 +1720,11 @@ async fn handle_put_done_with_resolved_group(
                 };
                 (
                     target_cap_bytes,
-                    KvRouteInfo {
-                        node_id: node_id.clone(),
+                    KvMemoryReplica {
                         backing: KvReplicaBacking::Allocation(Arc::new(target)),
                         owner_local_indexed: false,
                         get_durable_reservation: None,
                         capacity_reservation,
-                        tomb_tag,
                     },
                     false,
                 )
@@ -1602,13 +1755,11 @@ async fn handle_put_done_with_resolved_group(
                 };
                 (
                     target_cap_bytes,
-                    KvRouteInfo {
-                        node_id: node_id.clone(),
+                    KvMemoryReplica {
                         backing: KvReplicaBacking::CommittedSlot(slot),
                         owner_local_indexed: true,
                         get_durable_reservation: None,
                         capacity_reservation,
-                        tomb_tag,
                     },
                     false,
                 )
@@ -1666,18 +1817,21 @@ async fn handle_put_done_with_resolved_group(
         // Publish the primary route under the node-generation fence.  This
         // closes the gap where MemberLeft marked/snapshotted routes between a
         // pre-check and a later DashMap insert.
-        let publish_tag = completed_info.tomb_tag.clone();
+        let publish_tag = tomb_tag.clone();
         let new_route = Arc::new(OneKvNodesRoutes {
             put_id,
             lease_id: lease_id_opt,
             atomic_group: atomic_group.clone(),
-            nodes_replicas: RwLock::new(HashMap::from([(node_id.clone(), completed_info)])),
+            node_replicas: RwLock::new(HashMap::from([(
+                node_id.clone(),
+                KvNodeReplicas::memory(publish_tag.clone(), completed_info),
+            )])),
             get_durable_slots_used: AtomicU32::new(0),
         });
         let old_one_kv_routes = match publish_primary_route_tomb_fenced(
             &view.master_kv_router().inner().kv_routes,
             &key,
-            new_route,
+            new_route.clone(),
             &publish_tag,
         ) {
             Ok(previous) => previous,
@@ -1830,13 +1984,11 @@ async fn handle_put_done_with_resolved_group(
                     };
                 }
             };
-            let completed_info = KvRouteInfo {
-                node_id: node_id.clone(),
+            let completed_info = KvMemoryReplica {
                 backing: KvReplicaBacking::CommittedSlot(committed_slot),
                 owner_local_indexed: true,
                 get_durable_reservation: None,
                 capacity_reservation,
-                tomb_tag,
             };
             return publish_completed_put_route(
                 view,
@@ -1845,6 +1997,7 @@ async fn handle_put_done_with_resolved_group(
                 lease_id_opt,
                 atomic_group,
                 node_id,
+                tomb_tag,
                 completed_info,
                 target_cap_bytes,
                 None,
@@ -2171,11 +2324,11 @@ async fn handle_put_append_start_inner(
             .as_ref()
             .map(|route| {
                 route
-                    .nodes_replicas
+                    .node_replicas
                     .read()
-                    .values()
-                    .filter_map(|replica| {
-                        (!replica.tomb_tag.is_tomb()).then_some(replica.node_id.clone())
+                    .iter()
+                    .filter_map(|(node_id, replicas)| {
+                        replicas.has_live_backing().then_some(node_id.clone())
                     })
                     .collect::<HashSet<_>>()
             })
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
index f42cd24..ac5736b 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/reclaim.rs
@@ -4,7 +4,7 @@ use crate::master_kv_router::msg_pack::{
     BatchEvictOwnerSourceReq, BatchEvictOwnerSourceResp, BatchOwnerReclaimReq, OwnerReclaimBacking,
     OwnerReclaimItem, OwnerReclaimItemResp, OwnerReclaimItemState, OwnerReclaimPhase,
     OwnerReclaimReason, OwnerSourceEvictionOutcome, OwnerSourceEvictionVictim,
-    OwnerSourceEvictionVictimResp, owner_source_eviction_epoch,
+    OwnerSourceEvictionVictimResp, OwnerSourceSsdPolicy, owner_source_eviction_epoch,
 };
 use crate::p2p::msg_pack::{MIN_EXPLICIT_RPC_TIMEOUT_SECS, MsgPack, RPCCaller};
 use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, OK};
@@ -17,6 +17,10 @@ use std::time::Duration;
 
 const OWNER_RECLAIM_RPC_TIMEOUT: Duration = Duration::from_secs(MIN_EXPLICIT_RPC_TIMEOUT_SECS);
 const OWNER_RECLAIM_MAX_BATCH: usize = 256;
+// Keep each transport/SSD transaction small enough to release physical slots
+// continuously.  Every entry remains an independently fenced single-KV
+// victim; this is only an RPC and bounded-I/O aggregation limit.
+const OWNER_RECLAIM_RPC_BATCH: usize = 32;
 const OWNER_RECLAIM_MERGE_WINDOW: Duration = Duration::from_millis(5);
 const EVICTION_RECLAIM_RETRY_INITIAL: Duration = Duration::from_millis(100);
 const EVICTION_RECLAIM_RETRY_MAX: Duration = Duration::from_secs(1);
@@ -72,8 +76,8 @@ mod single_victim_transaction_tests {
         OwnerSourceEvictionVictim, PutAtomicGroup, PutAtomicGroupMember,
     };
     use crate::master_kv_router::{
-        CommittedSlotReplica, KvRouteInfo, MasterKeyActivityKind, MasterKeyActivityTable,
-        OneKvNodesRoutes,
+        CommittedSlotReplica, KvMemoryReplica, KvNodeReplicas, KvSsdReplica, MasterKeyActivityKind,
+        MasterKeyActivityTable, OneKvNodesRoutes,
     };
     use crate::master_seg_manager::NodeTombTag;
     use parking_lot::RwLock;
@@ -150,6 +154,8 @@ mod single_victim_transaction_tests {
                 slot_index,
                 slot_size: 4096,
             },
+            ssd_backing_len: None,
+            ssd_policy: OwnerSourceSsdPolicy::Drop,
         }
     }
 
@@ -167,50 +173,52 @@ mod single_victim_transaction_tests {
         else {
             unreachable!()
         };
-        let owner_replica = KvRouteInfo {
-            node_id: owner.clone(),
-            backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
-                owner_node_id: owner.clone(),
-                grant_id: *grant_id,
-                slot_index: *slot_index,
-                slot_size: *slot_size,
-                addr: 0,
-                len: *slot_size,
-                base_addr: 0,
-            }),
-            owner_local_indexed: true,
-            get_durable_reservation: None,
-            capacity_reservation: None,
-            tomb_tag: NodeTombTag::new(),
-        };
+        let owner_replica = KvNodeReplicas::memory(
+            NodeTombTag::new(),
+            KvMemoryReplica {
+                backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                    owner_node_id: owner.clone(),
+                    grant_id: *grant_id,
+                    slot_index: *slot_index,
+                    slot_size: *slot_size,
+                    addr: 0,
+                    len: *slot_size,
+                    base_addr: 0,
+                }),
+                owner_local_indexed: true,
+                get_durable_reservation: None,
+                capacity_reservation: None,
+            },
+        );
         let mut replicas = HashMap::from([(owner.clone(), owner_replica)]);
         if include_cpu_replica {
             let cpu: NodeID = "cpu0".to_string().into();
             replicas.insert(
                 cpu.clone(),
-                KvRouteInfo {
-                    node_id: cpu.clone(),
-                    backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
-                        owner_node_id: cpu,
-                        grant_id: 900 + *grant_id,
-                        slot_index: *slot_index,
-                        slot_size: *slot_size,
-                        addr: 0,
-                        len: *slot_size,
-                        base_addr: 0,
-                    }),
-                    owner_local_indexed: false,
-                    get_durable_reservation: None,
-                    capacity_reservation: None,
-                    tomb_tag: NodeTombTag::new(),
-                },
+                KvNodeReplicas::memory(
+                    NodeTombTag::new(),
+                    KvMemoryReplica {
+                        backing: KvReplicaBacking::CommittedSlot(CommittedSlotReplica {
+                            owner_node_id: cpu,
+                            grant_id: 900 + *grant_id,
+                            slot_index: *slot_index,
+                            slot_size: *slot_size,
+                            addr: 0,
+                            len: *slot_size,
+                            base_addr: 0,
+                        }),
+                        owner_local_indexed: false,
+                        get_durable_reservation: None,
+                        capacity_reservation: None,
+                    },
+                ),
             );
         }
         Arc::new(OneKvNodesRoutes {
             put_id: member.put_id,
             lease_id: None,
             atomic_group,
-            nodes_replicas: RwLock::new(replicas),
+            node_replicas: RwLock::new(replicas),
             get_durable_slots_used: AtomicU32::new(0),
         })
     }
@@ -260,14 +268,16 @@ mod single_victim_transaction_tests {
         let counters = crate::master_kv_router::EvictionReclaimCounters::default();
         record_last_route_removal(&counters, &removed);
         assert!(!removed.removed_last_route);
+        assert!(!removed.ssd_survived);
+        assert!(!removed.ssd_became_only_backing);
         assert_eq!(
             counters.last_route_removed_members.load(Ordering::Relaxed),
             0
         );
         assert_eq!(counters.last_route_removed_bytes.load(Ordering::Relaxed), 0);
         let remaining = routes.get(&member.key).expect("CPU route must remain");
-        assert!(!remaining.nodes_replicas.read().contains_key(&owner));
-        assert!(remaining.nodes_replicas.read().contains_key("cpu0"));
+        assert!(!remaining.node_replicas.read().contains_key(&owner));
+        assert!(remaining.node_replicas.read().contains_key("cpu0"));
 
         let last = source_victim("last", (10, 3), 7, 5);
         routes.insert(last.key.clone(), source_route(&owner, &last, None, false));
@@ -299,6 +309,141 @@ mod single_victim_transaction_tests {
         assert!(routes.contains_key(&stale.key));
     }
 
+    #[test]
+    fn exact_source_memory_removal_preserves_same_owner_ssd_backing() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let member = source_victim("ssd-backed", (10, 5), 7, 7);
+        let route = source_route(&owner, &member, None, false);
+        route
+            .node_replicas
+            .write()
+            .get_mut(&owner)
+            .expect("owner route must exist")
+            .ssd = Some(KvSsdReplica { len: 4096 });
+        let routes = dashmap::DashMap::new();
+        routes.insert(member.key.clone(), route.clone());
+
+        let removed =
+            remove_exact_owner_source_route(&routes, &owner, &source_reclaim_item(&member))
+                .expect("exact memory backing must be removed");
+
+        assert!(!removed.removed_last_route);
+        assert!(removed.ssd_survived);
+        assert!(removed.ssd_became_only_backing);
+        let current = routes
+            .get(&member.key)
+            .expect("SSD backing must keep the key route alive");
+        let replicas = current.node_replicas.read();
+        let owner_backings = replicas.get(&owner).expect("owner route must remain");
+        assert!(owner_backings.memory.is_none());
+        assert_eq!(owner_backings.ssd.as_ref().map(|ssd| ssd.len), Some(4096));
+    }
+
+    #[test]
+    fn ssd_preservation_selects_only_an_exact_last_live_backing() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let last = source_victim("last-for-ssd", (20, 1), 11, 1);
+        let last_route = source_route(&owner, &last, None, false);
+        let last_item = source_reclaim_item(&last);
+        assert!(exact_memory_reclaim_needs_ssd_with(
+            &owner,
+            &last_item,
+            &|key| (key == last.key).then(|| last_route.clone()),
+        ));
+
+        let with_other = source_victim("other-live", (20, 2), 12, 2);
+        let with_other_route = source_route(&owner, &with_other, None, true);
+        let with_other_item = source_reclaim_item(&with_other);
+        assert!(!exact_memory_reclaim_needs_ssd_with(
+            &owner,
+            &with_other_item,
+            &|key| (key == with_other.key).then(|| with_other_route.clone()),
+        ));
+
+        let already_on_ssd = source_victim("already-on-ssd", (20, 3), 13, 3);
+        let already_on_ssd_route = source_route(&owner, &already_on_ssd, None, false);
+        already_on_ssd_route
+            .node_replicas
+            .write()
+            .get_mut(&owner)
+            .expect("owner route must exist")
+            .ssd = Some(KvSsdReplica { len: 4096 });
+        let already_on_ssd_item = source_reclaim_item(&already_on_ssd);
+        assert!(!exact_memory_reclaim_needs_ssd_with(
+            &owner,
+            &already_on_ssd_item,
+            &|key| (key == already_on_ssd.key).then(|| already_on_ssd_route.clone()),
+        ));
+
+        let stale = source_victim("stale-for-ssd", (20, 4), 14, 4);
+        let stale_route = source_route(&owner, &stale, None, false);
+        let wrong_identity = source_victim("stale-for-ssd", stale.put_id, 999, 4);
+        assert!(!exact_memory_reclaim_needs_ssd_with(
+            &owner,
+            &source_reclaim_item(&wrong_identity),
+            &|key| (key == stale.key).then(|| stale_route.clone()),
+        ));
+    }
+
+    #[test]
+    fn direct_delete_filters_before_ssd_and_drop_finishes_without_waiting() {
+        let owner: NodeID = "gpu0".to_string().into();
+        let mut last = source_victim("last-candidate", (21, 1), 15, 1);
+        last.ssd_policy = OwnerSourceSsdPolicy::SelectLastLive;
+        let mut backed = source_victim("already-backed", (21, 2), 16, 2);
+        backed.ssd_policy = OwnerSourceSsdPolicy::SelectLastLive;
+        let routes = dashmap::DashMap::new();
+        routes.insert(last.key.clone(), source_route(&owner, &last, None, false));
+        routes.insert(
+            backed.key.clone(),
+            source_route(&owner, &backed, None, true),
+        );
+        let activity = MasterKeyActivityTable::default();
+        let (responses, busy) = direct_delete_exact_owner_source_batch_with(
+            &activity,
+            &owner,
+            81,
+            &[last.clone(), backed.clone()],
+            &|key| routes.get(key).map(|route| route.clone()),
+            |item| remove_exact_owner_source_route(&routes, &owner, item).is_some(),
+        );
+        assert_eq!(busy, DirectDeleteBatchBusySummary::default());
+        assert_eq!(
+            responses
+                .iter()
+                .map(|response| response.outcome)
+                .collect::<Vec<_>>(),
+            vec![
+                OwnerSourceEvictionOutcome::SsdCandidate,
+                OwnerSourceEvictionOutcome::Completed,
+            ]
+        );
+        assert!(routes.contains_key(&last.key));
+        assert!(
+            routes
+                .get(&backed.key)
+                .unwrap()
+                .node_replicas
+                .read()
+                .contains_key("cpu0")
+        );
+        assert!(!activity.has_reclaim(&last.key));
+
+        last.ssd_policy = OwnerSourceSsdPolicy::Drop;
+        let dropped = direct_delete_exact_owner_source_with(
+            &activity,
+            &owner,
+            &last,
+            owner_source_eviction_epoch(82, 0),
+            &|key| routes.get(key).map(|route| route.clone()),
+            |item| remove_exact_owner_source_route(&routes, &owner, item).is_some(),
+        );
+        assert_eq!(dropped.outcome, OwnerSourceEvictionOutcome::Completed);
+        assert!(!dropped.ssd_backing_committed);
+        assert!(!routes.contains_key(&last.key));
+        assert!(!activity.has_reclaim(&last.key));
+    }
+
     #[test]
     fn singleton_source_is_independent_of_atomic_group_siblings() {
         let owner: NodeID = "gpu0".to_string().into();
@@ -347,8 +492,12 @@ mod single_victim_transaction_tests {
     #[test]
     fn direct_delete_batch_keeps_results_independent_and_replay_idempotent() {
         let owner: NodeID = "gpu0".to_string().into();
-        let ready = source_victim("ready", (14, 0), 11, 0);
-        let busy = source_victim("busy", (14, 1), 11, 1);
+        let mut ready = source_victim("ready", (14, 0), 11, 0);
+        ready.ssd_backing_len = Some(4096);
+        ready.ssd_policy = OwnerSourceSsdPolicy::Persisted;
+        let mut busy = source_victim("busy", (14, 1), 11, 1);
+        busy.ssd_backing_len = Some(4096);
+        busy.ssd_policy = OwnerSourceSsdPolicy::Persisted;
         let stale = source_victim("stale", (14, 2), 11, 2);
         let routes = dashmap::DashMap::new();
         for victim in [&ready, &busy, &stale] {
@@ -361,7 +510,9 @@ mod single_victim_transaction_tests {
         let _busy_get = activity
             .reserve(&busy.key, MasterKeyActivityKind::Get, false)
             .expect("busy victim must hold a master Get lease");
-        let stale_request = source_victim("stale", stale.put_id, 999, 2);
+        let mut stale_request = source_victim("stale", stale.put_id, 999, 2);
+        stale_request.ssd_backing_len = Some(4096);
+        stale_request.ssd_policy = OwnerSourceSsdPolicy::Persisted;
         let victims = vec![ready.clone(), busy.clone(), stale_request];
         let (responses, busy_summary) = direct_delete_exact_owner_source_batch_with(
             activity.as_ref(),
@@ -391,6 +542,14 @@ mod single_victim_transaction_tests {
             vec![0, 1, 2],
             "one batch response vector must stay aligned with every input victim"
         );
+        assert_eq!(
+            responses
+                .iter()
+                .map(|response| response.ssd_backing_committed)
+                .collect::<Vec<_>>(),
+            vec![true, false, false],
+            "only the exact fenced write-back victim may publish SSD backing"
+        );
         assert_eq!(
             busy_summary,
             DirectDeleteBatchBusySummary {
@@ -400,9 +559,43 @@ mod single_victim_transaction_tests {
                 ..Default::default()
             }
         );
-        assert!(!routes.contains_key(&ready.key));
+        let ready_route = routes
+            .get(&ready.key)
+            .expect("SSD write-back must keep the ready route alive");
+        let ready_replicas = ready_route.node_replicas.read();
+        let ready_backings = ready_replicas
+            .get(&owner)
+            .expect("same-owner SSD backing must remain");
+        assert!(ready_backings.memory.is_none());
+        assert_eq!(ready_backings.ssd.as_ref().map(|ssd| ssd.len), Some(4096));
+        drop(ready_replicas);
+        drop(ready_route);
         assert!(routes.contains_key(&busy.key));
         assert!(routes.contains_key(&stale.key));
+        assert!(
+            routes
+                .get(&busy.key)
+                .unwrap()
+                .node_replicas
+                .read()
+                .get(&owner)
+                .unwrap()
+                .ssd
+                .is_none(),
+            "a busy key must not publish SSD backing before its master fence"
+        );
+        assert!(
+            routes
+                .get(&stale.key)
+                .unwrap()
+                .node_replicas
+                .read()
+                .get(&owner)
+                .unwrap()
+                .ssd
+                .is_none(),
+            "a stale exact backing must not publish SSD backing"
+        );
         assert!(!activity.has_reclaim(&ready.key));
 
         let replay_delete_called = AtomicBool::new(false);
@@ -418,6 +611,10 @@ mod single_victim_transaction_tests {
             },
         );
         assert_eq!(replay.outcome, OwnerSourceEvictionOutcome::Completed);
+        assert!(
+            replay.ssd_backing_committed,
+            "a lost direct-delete response must replay the already-published SSD terminal"
+        );
         assert_eq!(replay.busy_cause, None);
         assert!(!replay_delete_called.load(Ordering::Relaxed));
     }
@@ -531,10 +728,14 @@ fn allocation_member_from_route(
     if route.lease_id.is_some() {
         return Err(MasterCapacityPlanError::RouteChanged);
     }
-    let replicas = route.nodes_replicas.read();
-    let replica = replicas
+    let replicas = route.node_replicas.read();
+    let node_replicas = replicas
         .get(owner)
-        .filter(|replica| !replica.tomb_tag.is_tomb())
+        .filter(|replicas| !replicas.tomb_tag.is_tomb())
+        .ok_or(MasterCapacityPlanError::RouteChanged)?;
+    let replica = node_replicas
+        .memory
+        .as_ref()
         .ok_or(MasterCapacityPlanError::RouteChanged)?;
     if replica.owner_local_indexed {
         return Err(MasterCapacityPlanError::WrongRole);
@@ -588,17 +789,23 @@ fn route_item(
     if expected_put_id.is_some_and(|put_id| put_id != route.put_id) || route.lease_id.is_some() {
         return None;
     }
-    let replicas = route.nodes_replicas.read();
-    let target = replicas.get(owner_node_id)?;
-    if target.tomb_tag.is_tomb() {
+    let replicas = route.node_replicas.read();
+    let node_replicas = replicas.get(owner_node_id)?;
+    if node_replicas.tomb_tag.is_tomb() {
         return None;
     }
+    let target = node_replicas.memory.as_ref()?;
     let backing = match &target.backing {
-        KvReplicaBacking::Allocation(_) if required_slot_size.is_none() => {
+        KvReplicaBacking::Allocation(allocation) if required_slot_size.is_none() => {
             if target.owner_local_indexed {
                 OwnerReclaimBacking::Allocation
             } else {
-                OwnerReclaimBacking::UnindexedAllocation
+                OwnerReclaimBacking::UnindexedAllocation {
+                    addr: allocation.base_addr().checked_add(allocation.addr())?,
+                    base_addr: allocation.base_addr(),
+                    len: allocation.size(),
+                    capacity_bytes: allocation.capcity(),
+                }
             }
         }
         KvReplicaBacking::Allocation(_) => return None,
@@ -639,7 +846,9 @@ fn item_still_valid(view: &MasterKvRouterView, owner: &NodeID, item: &OwnerRecla
         &item.key,
         Some(item.put_id),
         match &item.backing {
-            OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation => None,
+            OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation { .. } => {
+                None
+            }
             OwnerReclaimBacking::CommittedSlot { slot_size, .. } => Some(*slot_size),
         },
         item.reason,
@@ -648,6 +857,81 @@ fn item_still_valid(view: &MasterKvRouterView, owner: &NodeID, item: &OwnerRecla
     .is_some_and(|current| current.backing == item.backing && current.reason == item.reason)
 }
 
+/// Publish bytes already persisted by the owner onto the existing route while
+/// both master and owner Prepare fences still protect the exact memory
+/// generation.  Memory remains present until the subsequent Commit succeeds,
+/// so Get never observes a route gap between DRAM and SSD.
+fn publish_prepared_ssd_backing(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+    ssd_backing_len: Option<u64>,
+) -> Result<bool, String> {
+    let Some(len) = ssd_backing_len else {
+        return Ok(false);
+    };
+    if !item_still_valid(view, owner, item) {
+        return Err(format!(
+            "exact memory route changed before SSD publication: key={} epoch={}",
+            item.key, item.epoch
+        ));
+    }
+    let route = view
+        .master_kv_router()
+        .inner()
+        .kv_routes
+        .get(&item.key)
+        .map(|route| route.clone())
+        .ok_or_else(|| format!("route disappeared before SSD publication: key={}", item.key))?;
+    let existing_ssd_len = route
+        .node_replicas
+        .read()
+        .get(owner)
+        .and_then(|replicas| replicas.ssd.as_ref())
+        .map(|ssd| ssd.len);
+    if let Some(existing_len) = existing_ssd_len {
+        return if existing_len == len {
+            Ok(false)
+        } else {
+            Err(format!(
+                "existing SSD backing length mismatch: key={} existing={} prepared={}",
+                item.key, existing_len, len
+            ))
+        };
+    }
+    match route.commit_ssd_replica(owner, len) {
+        super::SsdReplicaCommitStatus::Committed => Ok(true),
+        super::SsdReplicaCommitStatus::MissingMemory => Err(format!(
+            "memory backing disappeared before SSD publication: key={}",
+            item.key
+        )),
+        super::SsdReplicaCommitStatus::TombedNode => Err(format!(
+            "owner generation was tombed before SSD publication: owner={} key={}",
+            owner, item.key
+        )),
+        super::SsdReplicaCommitStatus::LengthMismatch => Err(format!(
+            "persisted SSD length mismatches memory route: key={} len={}",
+            item.key, len
+        )),
+    }
+}
+
+fn rollback_new_ssd_backing(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+) -> bool {
+    if !item_still_valid(view, owner, item) {
+        return false;
+    }
+    view.master_kv_router()
+        .inner()
+        .kv_routes
+        .get(&item.key)
+        .filter(|route| route.put_id == item.put_id)
+        .is_some_and(|route| route.remove_ssd_replica(owner))
+}
+
 async fn call_owner_phase(
     view: &MasterKvRouterView,
     owner: &NodeID,
@@ -657,11 +941,12 @@ async fn call_owner_phase(
     if items.is_empty() {
         return Ok(Vec::new());
     }
-    debug_assert!(
-        items
-            .iter()
-            .all(|item| item.backing != OwnerReclaimBacking::UnindexedAllocation)
-    );
+    debug_assert!(items.iter().all(|item| {
+        !matches!(
+            &item.backing,
+            OwnerReclaimBacking::UnindexedAllocation { .. }
+        ) || item.reason == OwnerReclaimReason::MasterAllocationCapacity
+    }));
     let caller = RPCCaller::<BatchOwnerReclaimReq>::new();
     caller.regist(view.p2p_module());
     let resp = caller
@@ -719,11 +1004,11 @@ fn clear_master_fence(view: &MasterKvRouterView, item: &OwnerReclaimItem) {
     }
 }
 
-#[cfg(test)]
 async fn abort_prepared(
     view: &MasterKvRouterView,
     owner: &NodeID,
     items: Vec<OwnerReclaimItem>,
+    newly_published_ssd: HashSet<(String, u64)>,
 ) -> Vec<OwnerReclaimItem> {
     if items.is_empty() {
         return Vec::new();
@@ -734,9 +1019,22 @@ async fn abort_prepared(
             for (item, response) in items.into_iter().zip(responses.into_iter()) {
                 match response.state {
                     OwnerReclaimItemState::Committed => already_committed.push(item),
-                    OwnerReclaimItemState::Aborted
-                    | OwnerReclaimItemState::Stale
-                    | OwnerReclaimItemState::Finalized => clear_master_fence(view, &item),
+                    OwnerReclaimItemState::Aborted => {
+                        if newly_published_ssd.contains(&(item.key.clone(), item.epoch))
+                            && !rollback_new_ssd_backing(view, owner, &item)
+                        {
+                            tracing::warn!(
+                                owner = %owner,
+                                key = %item.key,
+                                epoch = item.epoch,
+                                "new SSD backing was not removable after owner reclaim abort"
+                            );
+                        }
+                        clear_master_fence(view, &item);
+                    }
+                    OwnerReclaimItemState::Stale | OwnerReclaimItemState::Finalized => {
+                        clear_master_fence(view, &item)
+                    }
                     state => tracing::warn!(
                         "owner reclaim abort returned unresolved state: key={} epoch={} state={:?} detail={}",
                         item.key,
@@ -755,14 +1053,18 @@ async fn abort_prepared(
                 items.len(),
                 err
             );
-            spawn_abort_retry(view.clone(), owner.clone(), items);
+            spawn_abort_retry(view.clone(), owner.clone(), items, newly_published_ssd);
             Vec::new()
         }
     }
 }
 
-#[cfg(test)]
-fn spawn_abort_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<OwnerReclaimItem>) {
+fn spawn_abort_retry(
+    view: MasterKvRouterView,
+    owner: NodeID,
+    items: Vec<OwnerReclaimItem>,
+    newly_published_ssd: HashSet<(String, u64)>,
+) {
     if items.is_empty() {
         return;
     }
@@ -779,9 +1081,22 @@ fn spawn_abort_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<OwnerRe
                     for (item, response) in pending.into_iter().zip(responses.into_iter()) {
                         match response.state {
                             OwnerReclaimItemState::Committed => committed.push(item),
-                            OwnerReclaimItemState::Aborted
-                            | OwnerReclaimItemState::Stale
-                            | OwnerReclaimItemState::Finalized => clear_master_fence(&view, &item),
+                            OwnerReclaimItemState::Aborted => {
+                                if newly_published_ssd.contains(&(item.key.clone(), item.epoch))
+                                    && !rollback_new_ssd_backing(&view, &owner, &item)
+                                {
+                                    tracing::warn!(
+                                        owner = %owner,
+                                        key = %item.key,
+                                        epoch = item.epoch,
+                                        "new SSD backing was not removable after retried owner reclaim abort"
+                                    );
+                                }
+                                clear_master_fence(&view, &item);
+                            }
+                            OwnerReclaimItemState::Stale | OwnerReclaimItemState::Finalized => {
+                                clear_master_fence(&view, &item)
+                            }
                             _ => next.push(item),
                         }
                     }
@@ -812,13 +1127,28 @@ fn spawn_abort_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<OwnerRe
     });
 }
 
-fn reclaim_backing_matches(replica: &super::KvRouteInfo, expected: &OwnerReclaimBacking) -> bool {
+fn reclaim_backing_matches(
+    replica: &super::KvMemoryReplica,
+    expected: &OwnerReclaimBacking,
+) -> bool {
     match (&replica.backing, expected) {
         (KvReplicaBacking::Allocation(_), OwnerReclaimBacking::Allocation) => {
             replica.owner_local_indexed
         }
-        (KvReplicaBacking::Allocation(_), OwnerReclaimBacking::UnindexedAllocation) => {
+        (
+            KvReplicaBacking::Allocation(allocation),
+            OwnerReclaimBacking::UnindexedAllocation {
+                addr,
+                base_addr,
+                len,
+                capacity_bytes,
+            },
+        ) => {
             !replica.owner_local_indexed
+                && allocation.base_addr().checked_add(allocation.addr()) == Some(*addr)
+                && allocation.base_addr() == *base_addr
+                && allocation.size() == *len
+                && allocation.capcity() == *capacity_bytes
         }
         (
             KvReplicaBacking::CommittedSlot(slot),
@@ -841,7 +1171,7 @@ fn owner_source_member_weight(backing: &OwnerReclaimBacking) -> Option<u32> {
         OwnerReclaimBacking::CommittedSlot { slot_size, .. } => u32::try_from(*slot_size).ok(),
         // Allocation does not carry an address/generation identity in the
         // current wire contract, so accepting it would not be an exact delete.
-        OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation => None,
+        OwnerReclaimBacking::Allocation | OwnerReclaimBacking::UnindexedAllocation { .. } => None,
     }
 }
 
@@ -889,9 +1219,14 @@ fn plan_exact_owner_source_victim_with(
         ));
     }
     let replica_matches = {
-        let replicas = route.nodes_replicas.read();
+        let replicas = route.node_replicas.read();
         match replicas.get(owner) {
-            Some(replica) if !replica.tomb_tag.is_tomb() => {
+            Some(node_replicas) if !node_replicas.tomb_tag.is_tomb() => {
+                let Some(replica) = node_replicas.memory.as_ref() else {
+                    return OwnerSourceVictimPlan::Completed(
+                        "exact source memory replica is already absent",
+                    );
+                };
                 if !replica.owner_local_indexed {
                     return OwnerSourceVictimPlan::Rejected(format!(
                         "source route is not owner-local indexed: key={}",
@@ -922,6 +1257,7 @@ enum DirectDeleteBusyCause {
 
 struct DirectDeleteResult {
     outcome: OwnerSourceEvictionOutcome,
+    ssd_backing_committed: bool,
     detail: String,
     busy_cause: Option<DirectDeleteBusyCause>,
 }
@@ -930,6 +1266,7 @@ impl DirectDeleteResult {
     fn terminal(outcome: OwnerSourceEvictionOutcome, detail: impl Into<String>) -> Self {
         Self {
             outcome,
+            ssd_backing_committed: false,
             detail: detail.into(),
             busy_cause: None,
         }
@@ -938,6 +1275,7 @@ impl DirectDeleteResult {
     fn activity_busy(snapshot: super::MasterKeyActivitySnapshot) -> Self {
         Self {
             outcome: OwnerSourceEvictionOutcome::RetryableBusy,
+            ssd_backing_committed: false,
             detail: format!(
                 "master key activity is busy: puts={} gets={} replicas={} reclaim_installed={}",
                 snapshot.puts, snapshot.gets, snapshot.replicas, snapshot.reclaim_installed
@@ -949,12 +1287,43 @@ impl DirectDeleteResult {
     fn delete_under_fence_busy() -> Self {
         Self {
             outcome: OwnerSourceEvictionOutcome::RetryableBusy,
+            ssd_backing_committed: false,
             detail: "exact source route could not be deleted under its master fence".to_string(),
             busy_cause: Some(DirectDeleteBusyCause::DeleteUnderFence),
         }
     }
 }
 
+fn exact_ssd_writeback_is_published(
+    owner: &NodeID,
+    victim: &OwnerSourceEvictionVictim,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
+) -> bool {
+    if victim.ssd_policy != OwnerSourceSsdPolicy::Persisted {
+        return false;
+    }
+    let Some(expected_len) = victim.ssd_backing_len else {
+        return false;
+    };
+    let Some(route) = route_lookup(&victim.key) else {
+        return false;
+    };
+    if route.put_id != victim.put_id {
+        return false;
+    }
+    route
+        .node_replicas
+        .read()
+        .get(owner)
+        .is_some_and(|replicas| {
+            !replicas.tomb_tag.is_tomb()
+                && replicas
+                    .ssd
+                    .as_ref()
+                    .is_some_and(|ssd| ssd.len == expected_len)
+        })
+}
+
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 struct DirectDeleteBatchBusySummary {
     activity_busy_items: u64,
@@ -1011,7 +1380,11 @@ fn direct_delete_exact_owner_source_with(
     let member = match plan_exact_owner_source_victim_with(owner, victim, route_lookup) {
         OwnerSourceVictimPlan::Ready(member) => member,
         OwnerSourceVictimPlan::Completed(detail) => {
-            return DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Completed, detail);
+            let mut result =
+                DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Completed, detail);
+            result.ssd_backing_committed =
+                exact_ssd_writeback_is_published(owner, victim, route_lookup);
+            return result;
         }
         OwnerSourceVictimPlan::Stale(detail) => {
             return DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Stale, detail);
@@ -1038,17 +1411,97 @@ fn direct_delete_exact_owner_source_with(
 
     let result = match plan_exact_owner_source_victim_with(owner, victim, route_lookup) {
         OwnerSourceVictimPlan::Ready(_) => {
-            if delete(&item) {
-                DirectDeleteResult::terminal(
-                    OwnerSourceEvictionOutcome::Completed,
-                    "exact source route deleted by batch handler",
-                )
-            } else {
-                DirectDeleteResult::delete_under_fence_busy()
+            let ssd_ready = match victim.ssd_policy {
+                OwnerSourceSsdPolicy::Drop => {
+                    if victim.ssd_backing_len.is_none() {
+                        Ok(())
+                    } else {
+                        Err(DirectDeleteResult::terminal(
+                            OwnerSourceEvictionOutcome::RejectedNotEvictable,
+                            format!("drop policy must not carry SSD bytes: key={}", victim.key),
+                        ))
+                    }
+                }
+                OwnerSourceSsdPolicy::SelectLastLive => {
+                    if victim.ssd_backing_len.is_some() {
+                        Err(DirectDeleteResult::terminal(
+                            OwnerSourceEvictionOutcome::RejectedNotEvictable,
+                            format!(
+                                "SSD selection policy must not carry prepared bytes: key={}",
+                                victim.key
+                            ),
+                        ))
+                    } else if exact_memory_reclaim_needs_ssd_with(owner, &item, route_lookup) {
+                        Err(DirectDeleteResult::terminal(
+                            OwnerSourceEvictionOutcome::SsdCandidate,
+                            "exact source is the last live backing; owner SSD admission required",
+                        ))
+                    } else {
+                        Ok(())
+                    }
+                }
+                OwnerSourceSsdPolicy::Persisted => match victim.ssd_backing_len {
+                    None => Err(DirectDeleteResult::terminal(
+                        OwnerSourceEvictionOutcome::RejectedNotEvictable,
+                        format!(
+                            "persisted SSD policy requires exact bytes: key={}",
+                            victim.key
+                        ),
+                    )),
+                    Some(len) => match route_lookup(&victim.key)
+                        .map(|route| route.commit_ssd_replica(owner, len))
+                    {
+                        Some(super::SsdReplicaCommitStatus::Committed) => Ok(()),
+                        Some(super::SsdReplicaCommitStatus::LengthMismatch) => {
+                            Err(DirectDeleteResult::terminal(
+                                OwnerSourceEvictionOutcome::RejectedNotEvictable,
+                                format!(
+                                    "SSD write-back length does not match the exact source: key={} len={}",
+                                    victim.key, len
+                                ),
+                            ))
+                        }
+                        Some(
+                            super::SsdReplicaCommitStatus::MissingMemory
+                            | super::SsdReplicaCommitStatus::TombedNode,
+                        )
+                        | None => Err(DirectDeleteResult::terminal(
+                            OwnerSourceEvictionOutcome::Stale,
+                            format!(
+                                "exact source changed before SSD write-back publication: key={}",
+                                victim.key
+                            ),
+                        )),
+                    },
+                },
+            };
+            match ssd_ready {
+                Err(result) => result,
+                Ok(()) => {
+                    let mut result = if delete(&item) {
+                        DirectDeleteResult::terminal(
+                            OwnerSourceEvictionOutcome::Completed,
+                            if victim.ssd_policy == OwnerSourceSsdPolicy::Persisted {
+                                "SSD backing published and exact memory source deleted by batch handler"
+                            } else {
+                                "exact source route deleted by batch handler"
+                            },
+                        )
+                    } else {
+                        DirectDeleteResult::delete_under_fence_busy()
+                    };
+                    result.ssd_backing_committed =
+                        victim.ssd_policy == OwnerSourceSsdPolicy::Persisted;
+                    result
+                }
             }
         }
         OwnerSourceVictimPlan::Completed(detail) => {
-            DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Completed, detail)
+            let mut result =
+                DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Completed, detail);
+            result.ssd_backing_committed =
+                exact_ssd_writeback_is_published(owner, victim, route_lookup);
+            result
         }
         OwnerSourceVictimPlan::Stale(detail) => {
             DirectDeleteResult::terminal(OwnerSourceEvictionOutcome::Stale, detail)
@@ -1090,6 +1543,7 @@ fn direct_delete_exact_owner_source_batch_with(
         responses.push(OwnerSourceEvictionVictimResp {
             victim_index: u32::try_from(index).unwrap_or(u32::MAX),
             outcome: result.outcome,
+            ssd_backing_committed: result.ssd_backing_committed,
             detail: result.detail,
         });
     }
@@ -1167,6 +1621,7 @@ pub(crate) async fn handle_batch_evict_owner_source(
             OwnerSourceEvictionOutcome::Accepted => &counters.source_evict_accepted,
             OwnerSourceEvictionOutcome::AlreadyInProgress => &counters.source_evict_in_progress,
             OwnerSourceEvictionOutcome::Completed => &counters.source_evict_completed,
+            OwnerSourceEvictionOutcome::SsdCandidate => &counters.source_evict_accepted,
             OwnerSourceEvictionOutcome::RetryableBusy | OwnerSourceEvictionOutcome::Unspecified => {
                 &counters.source_evict_retryable_busy
             }
@@ -1184,11 +1639,16 @@ pub(crate) async fn handle_batch_evict_owner_source(
         .iter()
         .filter(|response| response.outcome == OwnerSourceEvictionOutcome::RetryableBusy)
         .count();
+    let ssd_candidates = responses
+        .iter()
+        .filter(|response| response.outcome == OwnerSourceEvictionOutcome::SsdCandidate)
+        .count();
     tracing::info!(
         owner = %owner,
         operation_id,
         victims = responses.len(),
         completed,
+        ssd_candidates,
         retryable,
         activity_busy_items = busy.activity_busy_items,
         put_busy_items = busy.put_busy_items,
@@ -1216,7 +1676,10 @@ pub(crate) async fn handle_batch_evict_owner_source(
 struct RemovedOwnerSource {
     desc: NodeValueReplicaDesc,
     capacity_bytes: u64,
+    logical_bytes: u64,
     removed_last_route: bool,
+    ssd_survived: bool,
+    ssd_became_only_backing: bool,
 }
 
 fn record_last_route_removal(
@@ -1244,28 +1707,56 @@ fn remove_exact_owner_source_route(
         return None;
     }
     let removed_desc = {
-        let mut replicas = route.nodes_replicas.write();
-        let Some(replica) = replicas.get(owner) else {
+        let mut replicas = route.node_replicas.write();
+        let Some(node_replicas) = replicas.get_mut(owner) else {
+            return None;
+        };
+        if node_replicas.tomb_tag.is_tomb() {
+            return None;
+        }
+        let Some(replica) = node_replicas.memory.as_ref() else {
             return None;
         };
         if !reclaim_backing_matches(replica, &item.backing) {
             return None;
         }
         let capacity_bytes = replica.backing.capacity_bytes();
+        let logical_bytes = replica.backing.len();
         let desc = NodeValueReplicaDesc {
             weight_bytes: u32::try_from(capacity_bytes).unwrap_or(u32::MAX),
             put_id: route.put_id,
         };
-        replicas.remove(owner).map(|_| (desc, capacity_bytes))
+        node_replicas.memory.take();
+        let ssd_survived = node_replicas.ssd.is_some();
+        let remove_node_entry = !ssd_survived;
+        if remove_node_entry {
+            replicas.remove(owner);
+        }
+        let live_backings = replicas
+            .values()
+            .filter(|replicas| !replicas.tomb_tag.is_tomb())
+            .map(|replicas| {
+                usize::from(replicas.memory.is_some()) + usize::from(replicas.ssd.is_some())
+            })
+            .sum::<usize>();
+        let ssd_became_only_backing = ssd_survived && live_backings == 1;
+        Some((
+            desc,
+            capacity_bytes,
+            logical_bytes,
+            ssd_survived,
+            ssd_became_only_backing,
+        ))
     };
-    let (removed_desc, capacity_bytes) = removed_desc?;
+    let (removed_desc, capacity_bytes, logical_bytes, ssd_survived, ssd_became_only_backing) =
+        removed_desc?;
 
-    let removed_last_route = if route.nodes_replicas.read().is_empty() {
+    let removed_last_route = if route.node_replicas.read().is_empty() {
         routes
             .remove_if(&item.key, |_, current| {
                 Arc::ptr_eq(current, &route)
                     && current.put_id == item.put_id
-                    && current.nodes_replicas.read().is_empty()
+                    && current.node_replicas.read().is_empty()
             })
             .is_some()
     } else {
@@ -1274,7 +1765,10 @@ fn remove_exact_owner_source_route(
     Some(RemovedOwnerSource {
         desc: removed_desc,
         capacity_bytes,
+        logical_bytes,
         removed_last_route,
+        ssd_survived,
+        ssd_became_only_backing,
     })
 }
 
@@ -1294,6 +1788,23 @@ fn remove_reclaimed_replica(
     let removed =
         remove_exact_owner_source_route(&view.master_kv_router().inner().kv_routes, owner, item);
     if let Some(removed) = removed {
+        let ssd_tier = &view.master_kv_router().inner().ssd_tier_counters;
+        if removed.ssd_survived {
+            ssd_tier
+                .memory_removed_ssd_survived_items
+                .fetch_add(1, Ordering::Relaxed);
+            ssd_tier
+                .memory_removed_ssd_survived_bytes
+                .fetch_add(removed.logical_bytes, Ordering::Relaxed);
+        }
+        if removed.ssd_became_only_backing {
+            ssd_tier
+                .memory_removed_ssd_became_only_items
+                .fetch_add(1, Ordering::Relaxed);
+            ssd_tier
+                .memory_removed_ssd_became_only_bytes
+                .fetch_add(removed.logical_bytes, Ordering::Relaxed);
+        }
         let counters = view
             .master_kv_router()
             .eviction_reclaim_counters(owner.as_ref());
@@ -1340,7 +1851,10 @@ fn finish_unindexed_allocations(
 ) -> u32 {
     let mut reclaimed = 0u32;
     for item in items {
-        debug_assert_eq!(item.backing, OwnerReclaimBacking::UnindexedAllocation);
+        debug_assert!(matches!(
+            &item.backing,
+            OwnerReclaimBacking::UnindexedAllocation { .. }
+        ));
         if remove_reclaimed_replica(view, owner, &item) {
             clear_master_fence(view, &item);
             reclaimed = reclaimed.saturating_add(1);
@@ -1356,12 +1870,86 @@ fn finish_unindexed_allocations(
     reclaimed
 }
 
-fn partition_reclaim_coordination(
+/// Return true only when removing this exact memory source would leave the key
+/// with no live backing. The caller holds the per-key master reclaim fence, so
+/// this route snapshot cannot race another Put/Get/replica/reclaim mutation.
+fn exact_memory_reclaim_needs_ssd_with(
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+    route_lookup: &dyn Fn(&str) -> Option<Arc<super::OneKvNodesRoutes>>,
+) -> bool {
+    let Some(route) = route_lookup(&item.key) else {
+        return false;
+    };
+    if route.put_id != item.put_id || route.lease_id.is_some() {
+        return false;
+    }
+    let replicas = route.node_replicas.read();
+    let Some(target) = replicas.get(owner) else {
+        return false;
+    };
+    if target.tomb_tag.is_tomb()
+        || !target
+            .memory
+            .as_ref()
+            .is_some_and(|memory| reclaim_backing_matches(memory, &item.backing))
+    {
+        return false;
+    }
+
+    replicas.iter().all(|(node_id, node_replicas)| {
+        if node_replicas.tomb_tag.is_tomb() {
+            return true;
+        }
+        if node_id == owner {
+            // The exact memory above is the source being removed. An existing
+            // same-owner SSD backing already preserves this route.
+            node_replicas.ssd.is_none()
+        } else {
+            !node_replicas.has_live_backing()
+        }
+    })
+}
+
+fn exact_memory_reclaim_needs_ssd(
+    view: &MasterKvRouterView,
+    owner: &NodeID,
+    item: &OwnerReclaimItem,
+) -> bool {
+    exact_memory_reclaim_needs_ssd_with(owner, item, &|key| {
+        view.master_kv_router()
+            .inner()
+            .kv_routes
+            .get(key)
+            .map(|route| route.clone())
+    })
+}
+
+fn partition_reclaim_coordination<F>(
     items: Vec<OwnerReclaimItem>,
-) -> (Vec<OwnerReclaimItem>, Vec<OwnerReclaimItem>) {
-    items
-        .into_iter()
-        .partition(|item| item.backing == OwnerReclaimBacking::UnindexedAllocation)
+    should_coordinate_unindexed: F,
+) -> (Vec<OwnerReclaimItem>, Vec<OwnerReclaimItem>)
+where
+    F: Fn(&OwnerReclaimItem) -> bool,
+{
+    items.into_iter().partition(|item| {
+        matches!(
+            &item.backing,
+            OwnerReclaimBacking::UnindexedAllocation { .. }
+        ) && !should_coordinate_unindexed(item)
+    })
+}
+
+fn owner_has_ssd_storage(view: &MasterKvRouterView, owner: &NodeID) -> bool {
+    view.cluster_manager()
+        .get_member_info_cached(owner.as_ref())
+        .and_then(|member| {
+            member
+                .metadata
+                .get(crate::cluster_manager::META_KEY_KV_SSD_STORAGE)
+                .cloned()
+        })
+        .is_some_and(|value| value == "true")
 }
 
 async fn finish_committed(
@@ -1465,7 +2053,6 @@ fn spawn_finalize_retry(view: MasterKvRouterView, owner: NodeID, items: Vec<Owne
     });
 }
 
-#[cfg(test)]
 async fn reclaim_items(
     view: &MasterKvRouterView,
     owner: &NodeID,
@@ -1510,7 +2097,10 @@ async fn reclaim_items(
         return 0;
     }
 
-    let (master_only, owner_coordinated) = partition_reclaim_coordination(fenced);
+    let owner_has_ssd = owner_has_ssd_storage(view, owner);
+    let (master_only, owner_coordinated) = partition_reclaim_coordination(fenced, |item| {
+        owner_has_ssd && exact_memory_reclaim_needs_ssd(view, owner, item)
+    });
     let master_reclaimed = finish_unindexed_allocations(view, owner, master_only);
     if owner_coordinated.is_empty() {
         counters
@@ -1535,7 +2125,7 @@ async fn reclaim_items(
                 owner_coordinated.len(),
                 err
             );
-            let _ = abort_prepared(view, owner, owner_coordinated).await;
+            let _ = abort_prepared(view, owner, owner_coordinated, HashSet::new()).await;
             counters
                 .completed
                 .fetch_add(u64::from(master_reclaimed), Ordering::Relaxed);
@@ -1544,12 +2134,34 @@ async fn reclaim_items(
     };
     let mut prepared = Vec::new();
     let mut committed = Vec::new();
+    let mut ssd_publish_failed = Vec::new();
+    let mut newly_published_ssd = HashSet::new();
     for (item, response) in owner_coordinated
         .into_iter()
         .zip(prepare_responses.into_iter())
     {
         match response.state {
-            OwnerReclaimItemState::Prepared => prepared.push(item),
+            OwnerReclaimItemState::Prepared => {
+                match publish_prepared_ssd_backing(view, owner, &item, response.ssd_backing_len) {
+                    Ok(newly_published) => {
+                        if newly_published {
+                            newly_published_ssd.insert((item.key.clone(), item.epoch));
+                        }
+                        prepared.push(item);
+                    }
+                    Err(detail) => {
+                        counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                        tracing::warn!(
+                            owner = %owner,
+                            key = %item.key,
+                            epoch = item.epoch,
+                            detail = %detail,
+                            "aborting owner reclaim after SSD backing publication validation failed"
+                        );
+                        ssd_publish_failed.push(item);
+                    }
+                }
+            }
             OwnerReclaimItemState::Committed => committed.push(item),
             OwnerReclaimItemState::Busy => {
                 if response.detail == "owner local memory still has active holders" {
@@ -1571,6 +2183,7 @@ async fn reclaim_items(
             }
         }
     }
+    committed.extend(abort_prepared(view, owner, ssd_publish_failed, HashSet::new()).await);
 
     let mut invalid_prepared = Vec::new();
     prepared.retain(|item| {
@@ -1581,7 +2194,14 @@ async fn reclaim_items(
         }
         valid
     });
-    committed.extend(abort_prepared(view, owner, invalid_prepared).await);
+    let invalid_published = invalid_prepared
+        .iter()
+        .filter_map(|item| {
+            let identity = (item.key.clone(), item.epoch);
+            newly_published_ssd.contains(&identity).then_some(identity)
+        })
+        .collect();
+    committed.extend(abort_prepared(view, owner, invalid_prepared, invalid_published).await);
 
     if !prepared.is_empty() {
         match call_owner_phase(view, owner, OwnerReclaimPhase::Commit, prepared.clone()).await {
@@ -1594,7 +2214,15 @@ async fn reclaim_items(
                         unresolved.push(item);
                     }
                 }
-                committed.extend(abort_prepared(view, owner, unresolved).await);
+                let unresolved_published = unresolved
+                    .iter()
+                    .filter_map(|item| {
+                        let identity = (item.key.clone(), item.epoch);
+                        newly_published_ssd.contains(&identity).then_some(identity)
+                    })
+                    .collect();
+                committed
+                    .extend(abort_prepared(view, owner, unresolved, unresolved_published).await);
             }
             Err(err) => {
                 tracing::warn!(
@@ -1603,7 +2231,14 @@ async fn reclaim_items(
                     prepared.len(),
                     err
                 );
-                committed.extend(abort_prepared(view, owner, prepared).await);
+                let prepared_published = prepared
+                    .iter()
+                    .filter_map(|item| {
+                        let identity = (item.key.clone(), item.epoch);
+                        newly_published_ssd.contains(&identity).then_some(identity)
+                    })
+                    .collect();
+                committed.extend(abort_prepared(view, owner, prepared, prepared_published).await);
             }
         }
     }
@@ -1682,7 +2317,10 @@ async fn reclaim_single_victim(
         return 0;
     }
 
-    let (master_only, owner_coordinated) = partition_reclaim_coordination(fenced.clone());
+    let owner_has_ssd = owner_has_ssd_storage(view, owner);
+    let (master_only, owner_coordinated) = partition_reclaim_coordination(fenced.clone(), |item| {
+        owner_has_ssd && exact_memory_reclaim_needs_ssd(view, owner, item)
+    });
     if owner_coordinated.is_empty() {
         // All master-owned allocations are fenced and revalidated before the
         // first route mutation, so no member can be admitted independently.
@@ -1765,7 +2403,23 @@ async fn reclaim_single_victim(
         let mut blocked = false;
         for (item, response) in pending.iter().cloned().zip(prepare_responses) {
             match response.state {
-                OwnerReclaimItemState::Prepared => prepared.push(item),
+                OwnerReclaimItemState::Prepared => {
+                    match publish_prepared_ssd_backing(view, owner, &item, response.ssd_backing_len)
+                    {
+                        Ok(_) => prepared.push(item),
+                        Err(detail) => {
+                            counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                            tracing::warn!(
+                                owner = %owner,
+                                key = %item.key,
+                                epoch = item.epoch,
+                                detail = %detail,
+                                "single-key reclaim SSD publication validation failed"
+                            );
+                            blocked = true;
+                        }
+                    }
+                }
                 OwnerReclaimItemState::Committed => {
                     committed_keys.insert(item.key);
                 }
@@ -1851,22 +2505,35 @@ mod reclaim_partition_tests {
         indexed_allocation.backing = OwnerReclaimBacking::Allocation;
         indexed_allocation.reason = OwnerReclaimReason::OwnerCapacityEviction;
         let mut unindexed_allocation = candidate(2);
-        unindexed_allocation.backing = OwnerReclaimBacking::UnindexedAllocation;
+        unindexed_allocation.backing = OwnerReclaimBacking::UnindexedAllocation {
+            addr: 0x2000,
+            base_addr: 0x1000,
+            len: 4096,
+            capacity_bytes: 4096,
+        };
         unindexed_allocation.reason = OwnerReclaimReason::MasterAllocationCapacity;
         let committed_slot = candidate(3);
 
-        let (master_only, owner_coordinated) = partition_reclaim_coordination(vec![
-            indexed_allocation,
+        let candidates = vec![
+            indexed_allocation.clone(),
             unindexed_allocation.clone(),
-            committed_slot,
-        ]);
+            committed_slot.clone(),
+        ];
+        let (master_only, owner_coordinated) =
+            partition_reclaim_coordination(candidates.clone(), |_| false);
 
-        assert_eq!(master_only, vec![unindexed_allocation]);
+        assert_eq!(master_only, vec![unindexed_allocation.clone()]);
         assert_eq!(owner_coordinated.len(), 2);
-        assert!(
-            owner_coordinated
-                .iter()
-                .all(|item| item.backing != OwnerReclaimBacking::UnindexedAllocation)
+        assert!(owner_coordinated.iter().all(|item| !matches!(
+            &item.backing,
+            OwnerReclaimBacking::UnindexedAllocation { .. }
+        )));
+
+        let (master_only, owner_coordinated) = partition_reclaim_coordination(candidates, |_| true);
+        assert!(master_only.is_empty());
+        assert_eq!(
+            owner_coordinated,
+            vec![indexed_allocation, unindexed_allocation, committed_slot]
         );
     }
 }
@@ -1875,10 +2542,17 @@ mod reclaim_partition_tests {
 mod owner_get_holding_reclaim_tests {
     use super::{OwnerReclaimBacking, OwnerReclaimReason, reclaim_items, route_item};
     use crate::client_kv_api::PutOptionalArgs;
+    use crate::config::KvSsdStorageConfig;
+    use crate::kv_ssd_storage::MIN_CAPACITY_BYTES;
     use crate::kvcore_test_lib::{
-        integration_test_lock, start_master_and_client, stop_master_and_client,
+        integration_test_lock, start_master_and_client, start_master_and_client_with_client_config,
+        stop_master_and_client,
     };
+    use crate::master_kv_router::msg_pack::{PutDoneReq, PutStartReq};
+    use crate::master_kv_router::put::{handle_put_done, handle_put_start};
     use crate::memholder::{MemholderManagerTrait, NodeHolderKey};
+    use crate::p2p::msg_pack::MsgPack;
+    use crate::rpcresp_kvresult_convert::msg_and_error::OK;
     use std::time::{Duration, Instant};
 
     #[limit_thirdparty::tokio::test(flavor = "multi_thread", worker_threads = 8)]
@@ -1927,7 +2601,7 @@ mod owner_get_holding_reclaim_tests {
                 .is_quiescent(key),
             "completed get must release its master key-activity lease"
         );
-        let owner_node = owner_id.clone().into();
+        let owner_node: crate::cluster_manager::NodeID = owner_id.clone().into();
         let busy_item = route_item(
             &master_view,
             &owner_node,
@@ -2001,6 +2675,183 @@ mod owner_get_holding_reclaim_tests {
 
         stop_master_and_client(master, client).await;
     }
+
+    #[limit_thirdparty::tokio::test(flavor = "multi_thread", worker_threads = 8)]
+    async fn master_unindexed_allocation_reclaim_publishes_ssd_and_reloads_exact_bytes() {
+        let _test_guard = integration_test_lock().await;
+        let (master, client) = start_master_and_client_with_client_config(
+            "master_capacity_ssd_reclaim_master",
+            "master_capacity_ssd_reclaim_owner",
+            |config| {
+                config.ssd_storage = Some(KvSsdStorageConfig {
+                    limit_bytes: MIN_CAPACITY_BYTES,
+                    write_rate_limit_bytes_per_sec: None,
+                    write_burst_bytes: None,
+                });
+                let target = std::env::var("CARGO_TARGET_DIR")
+                    .expect("SSD integration test requires the NVMe Cargo target");
+                let root = format!(
+                    "{target}/kv_ssd_integration/master_capacity_reclaim-{}",
+                    std::process::id()
+                );
+                config.share_mem_path = format!("{root}/sharemem");
+                config.large_file_paths.paths = vec![format!("{root}/large")];
+            },
+        )
+        .await;
+        let key = "master_capacity_ssd_reclaim_key";
+        let payload = vec![0x5au8; 4096];
+        let owner_view = client.client_kv_api_view();
+        let owner_api = owner_view.client_kv_api();
+        let owner_info = client
+            .cluster_manager_view()
+            .cluster_manager()
+            .get_self_info();
+        let owner_id = owner_info.id;
+        let owner_node: crate::cluster_manager::NodeID = owner_id.clone().into();
+        let master_view = master.master_kv_router_view().clone();
+        assert!(
+            master_view
+                .cluster_manager()
+                .get_member_info_cached(&owner_id)
+                .and_then(|member| {
+                    member
+                        .metadata
+                        .get(crate::cluster_manager::META_KEY_KV_SSD_STORAGE)
+                        .cloned()
+                })
+                .is_some_and(|value| value == "true"),
+            "master must observe the owner's SSD capability before selecting coordination"
+        );
+
+        let (_put_id, start) = handle_put_start(
+            master_view.clone(),
+            MsgPack {
+                serialize_part: PutStartReq {
+                    key: key.to_string(),
+                    len: payload.len() as u64,
+                    reject_if_inflight_same_key: false,
+                    reject_if_exist_same_key: false,
+                    make_replica_task: true,
+                    preferred_sub_cluster: None,
+                    source_node_id: None,
+                },
+                raw_bytes: Vec::new(),
+            },
+            owner_node.clone(),
+        )
+        .await;
+        assert_eq!(
+            start.serialize_part.error_code, OK,
+            "PutStart failed: {}",
+            start.serialize_part.error_json
+        );
+        assert_eq!(start.serialize_part.node_id, owner_id);
+        owner_view
+            .client_seg_pool()
+            .copy_into_segment(start.serialize_part.target_addr, &payload)
+            .await
+            .expect("copy payload into the master-owned owner segment Allocation");
+        let done = handle_put_done(
+            master_view.clone(),
+            MsgPack {
+                serialize_part: PutDoneReq {
+                    key: key.to_string(),
+                    put_id: start.serialize_part.put_id,
+                    lease_id: None,
+                    committed_slot: None,
+                    publish_local_cache: false,
+                    atomic_group: None,
+                },
+                raw_bytes: Vec::new(),
+            },
+            owner_node.clone(),
+        )
+        .await;
+        assert_eq!(done.serialize_part.error_code, OK);
+        assert_eq!(done.serialize_part.local_cache_holder_id, None);
+        let route = master_view
+            .master_kv_router()
+            .inner()
+            .kv_routes
+            .get(key)
+            .map(|route| route.clone())
+            .expect("PutDone must publish the production unindexed Allocation route");
+        assert!(
+            route
+                .node_replicas
+                .read()
+                .get(&owner_node)
+                .and_then(|replicas| replicas.memory.as_ref())
+                .is_some_and(|memory| !memory.owner_local_indexed),
+            "production remote backing must have no owner-local key index"
+        );
+        drop(route);
+
+        let item = route_item(
+            &master_view,
+            &owner_node,
+            key,
+            None,
+            None,
+            OwnerReclaimReason::MasterAllocationCapacity,
+            master_view.master_kv_router().next_owner_reclaim_epoch(),
+        )
+        .expect("master-capacity victim must resolve to the current owner Allocation");
+        assert!(matches!(
+            item.backing,
+            OwnerReclaimBacking::UnindexedAllocation { .. }
+        ));
+        assert_eq!(
+            reclaim_items(&master_view, &owner_node, vec![item]).await,
+            1
+        );
+
+        let route = master_view
+            .master_kv_router()
+            .inner()
+            .kv_routes
+            .get(key)
+            .map(|route| route.clone())
+            .expect("SSD backing must keep the route alive after DRAM reclaim");
+        {
+            let replicas = route.node_replicas.read();
+            let owner_backings = replicas
+                .get(&owner_node)
+                .expect("the SSD-only owner route must remain");
+            assert!(owner_backings.memory.is_none());
+            assert_eq!(
+                owner_backings.ssd.as_ref().map(|ssd| ssd.len),
+                Some(payload.len() as u64)
+            );
+        }
+        let persisted = owner_api
+            .inner()
+            .kv_ssd_storage_usage_snapshot()
+            .expect("test owner SSD must be configured");
+        assert_eq!(persisted.persist_successes, 1);
+        assert_eq!(persisted.persist_failures, 0);
+        assert_eq!(persisted.used_bytes, payload.len() as u64);
+
+        let (holder, _get_info) = owner_api
+            .inner()
+            .get(key)
+            .await
+            .expect("SSD-backed get")
+            .expect("SSD-only route must be readable");
+        assert_eq!(holder.bytes(), payload);
+        drop(holder);
+        let loaded = owner_api
+            .inner()
+            .kv_ssd_storage_usage_snapshot()
+            .expect("test owner SSD must remain configured");
+        assert_eq!(loaded.load_successes, 1);
+        assert_eq!(loaded.load_failures, 0);
+        assert_eq!(loaded.load_bytes, payload.len() as u64);
+        assert_eq!(loaded.memory_hits + loaded.disk_hits + loaded.outer_hits, 1);
+
+        stop_master_and_client(master, client).await;
+    }
 }
 
 fn request_is_current(view: &MasterKvRouterView, request: &EvictionReclaimRequest) -> bool {
@@ -2040,13 +2891,15 @@ fn request_is_current(view: &MasterKvRouterView, request: &EvictionReclaimReques
                     return false;
                 }
                 route
-                    .nodes_replicas
+                    .node_replicas
                     .read()
                     .get(&owner)
-                    .is_some_and(|replica| {
-                        !replica.tomb_tag.is_tomb()
-                            && replica.owner_local_indexed
-                            && reclaim_backing_matches(replica, expected_backing)
+                    .is_some_and(|node_replicas| {
+                        !node_replicas.tomb_tag.is_tomb()
+                            && node_replicas.memory.as_ref().is_some_and(|replica| {
+                                replica.owner_local_indexed
+                                    && reclaim_backing_matches(replica, expected_backing)
+                            })
                     })
             })
         }
@@ -2196,96 +3049,105 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                     .eviction_reclaim_counters(&owner_node_id);
                 let mut pending = std::collections::VecDeque::from(requests);
                 let mut retry_requests = Vec::new();
-                while let Some(request) = pending.pop_front() {
-                    let (members, mut accounting_requests, reason) = match request.origin {
-                        EvictionReclaimOrigin::OwnerCapacityEviction => (
-                            request.members.clone(),
-                            vec![request],
-                            OwnerReclaimReason::OwnerCapacityEviction,
-                        ),
-                        EvictionReclaimOrigin::MasterAllocationCapacity => {
-                            let member = match plan_master_allocation_capacity_victim(
-                                &view_task,
-                                &request,
-                            ) {
-                                Ok(member) => member,
-                                Err(MasterCapacityPlanError::CommittedSlot) => {
-                                    counters
-                                        .capacity_eviction_non_ring_b_entry_total
-                                        .fetch_add(1, Ordering::Relaxed);
-                                    counters
-                                        .capacity_eviction_hit_committed_slot
-                                        .fetch_add(1, Ordering::Relaxed);
-                                    view_task
-                                        .master_kv_router()
-                                        .complete_eviction_reclaim(&request);
-                                    let restored = restore_request_entries(&view_task, &request);
-                                    tracing::error!(
-                                        "BUG: master Allocation capacity event resolved to CommittedSlot; restored metadata: owner={} members={} restored={}",
-                                        owner_node_id,
-                                        request.members.len(),
-                                        restored,
-                                    );
-                                    continue;
-                                }
-                                Err(MasterCapacityPlanError::RouteChanged) => {
-                                    view_task
-                                        .master_kv_router()
-                                        .complete_eviction_reclaim(&request);
-                                    counters.route_changed.fetch_add(1, Ordering::Relaxed);
-                                    continue;
-                                }
-                                Err(MasterCapacityPlanError::WrongRole) => {
-                                    counters
-                                        .capacity_eviction_non_ring_b_entry_total
-                                        .fetch_add(1, Ordering::Relaxed);
-                                    view_task
-                                        .master_kv_router()
-                                        .complete_eviction_reclaim(&request);
-                                    let restored = restore_request_entries(&view_task, &request);
-                                    tracing::error!(
-                                        "BUG: master Allocation Size event resolved to a non-ring-B route; restored metadata: owner={} members={} restored={}",
-                                        owner_node_id,
-                                        request.members.len(),
-                                        restored,
-                                    );
-                                    continue;
+                while !pending.is_empty() {
+                    let mut accounting_requests = Vec::with_capacity(OWNER_RECLAIM_RPC_BATCH);
+                    let mut items = Vec::with_capacity(OWNER_RECLAIM_RPC_BATCH);
+                    for _ in 0..OWNER_RECLAIM_RPC_BATCH {
+                        let Some(request) = pending.pop_front() else {
+                            break;
+                        };
+                        let (members, reason) = match request.origin {
+                            EvictionReclaimOrigin::OwnerCapacityEviction => (
+                                request.members.clone(),
+                                OwnerReclaimReason::OwnerCapacityEviction,
+                            ),
+                            EvictionReclaimOrigin::MasterAllocationCapacity => {
+                                let member = match plan_master_allocation_capacity_victim(
+                                    &view_task,
+                                    &request,
+                                ) {
+                                    Ok(member) => member,
+                                    Err(MasterCapacityPlanError::CommittedSlot) => {
+                                        counters
+                                            .capacity_eviction_non_ring_b_entry_total
+                                            .fetch_add(1, Ordering::Relaxed);
+                                        counters
+                                            .capacity_eviction_hit_committed_slot
+                                            .fetch_add(1, Ordering::Relaxed);
+                                        view_task
+                                            .master_kv_router()
+                                            .complete_eviction_reclaim(&request);
+                                        let restored =
+                                            restore_request_entries(&view_task, &request);
+                                        tracing::error!(
+                                            "BUG: master Allocation capacity event resolved to CommittedSlot; restored metadata: owner={} members={} restored={}",
+                                            owner_node_id,
+                                            request.members.len(),
+                                            restored,
+                                        );
+                                        continue;
+                                    }
+                                    Err(MasterCapacityPlanError::RouteChanged) => {
+                                        view_task
+                                            .master_kv_router()
+                                            .complete_eviction_reclaim(&request);
+                                        counters.route_changed.fetch_add(1, Ordering::Relaxed);
+                                        continue;
+                                    }
+                                    Err(MasterCapacityPlanError::WrongRole) => {
+                                        counters
+                                            .capacity_eviction_non_ring_b_entry_total
+                                            .fetch_add(1, Ordering::Relaxed);
+                                        view_task
+                                            .master_kv_router()
+                                            .complete_eviction_reclaim(&request);
+                                        let restored =
+                                            restore_request_entries(&view_task, &request);
+                                        tracing::error!(
+                                            "BUG: master Allocation Size event resolved to a non-ring-B route; restored metadata: owner={} members={} restored={}",
+                                            owner_node_id,
+                                            request.members.len(),
+                                            restored,
+                                        );
+                                        continue;
+                                    }
+                                };
+                                (vec![member], OwnerReclaimReason::MasterAllocationCapacity)
+                            }
+                        };
+
+                        let planned = members
+                            .iter()
+                            .map(|member| {
+                                let item = route_item(
+                                    &view_task,
+                                    &owner,
+                                    &member.key,
+                                    Some(member.desc.put_id),
+                                    None,
+                                    reason,
+                                    view_task.master_kv_router().next_owner_reclaim_epoch(),
+                                )?;
+                                if member
+                                    .expected_backing
+                                    .as_ref()
+                                    .is_some_and(|expected| expected != &item.backing)
+                                {
+                                    return None;
                                 }
-                            };
-                            (
-                                vec![member],
-                                vec![request],
-                                OwnerReclaimReason::MasterAllocationCapacity,
-                            )
+                                Some(item)
+                            })
+                            .collect::<Option<Vec<_>>>();
+                        if let Some(mut planned) = planned {
+                            items.append(&mut planned);
                         }
-                    };
+                        accounting_requests.push(request);
+                    }
 
-                    let items = members
-                        .iter()
-                        .map(|member| {
-                            let item = route_item(
-                                &view_task,
-                                &owner,
-                                &member.key,
-                                Some(member.desc.put_id),
-                                None,
-                                reason,
-                                view_task.master_kv_router().next_owner_reclaim_epoch(),
-                            )?;
-                            if member
-                                .expected_backing
-                                .as_ref()
-                                .is_some_and(|expected| expected != &item.backing)
-                            {
-                                return None;
-                            }
-                            Some(item)
-                        })
-                        .collect::<Option<Vec<_>>>();
-                    if let Some(items) = items {
-                        let _ = reclaim_single_victim(&view_task, &owner, items).await;
+                    if !items.is_empty() {
+                        let _ = reclaim_items(&view_task, &owner, items).await;
                     }
-                    for accounting_request in accounting_requests.drain(..) {
+                    for accounting_request in accounting_requests {
                         if request_is_current(&view_task, &accounting_request) {
                             retry_requests.push(accounting_request);
                         } else {
@@ -2302,7 +3164,7 @@ pub(crate) fn spawn_eviction_reclaim_actor(
                 let retry_count = retry_requests.len();
                 spawn_eviction_reclaim_retry(view_task.clone(), retry_requests);
                 tracing::trace!(
-                    "single-key eviction reclaim batch completed: owner={} retry_deferred={}",
+                    "batched single-key eviction reclaim completed: owner={} retry_deferred={}",
                     owner_node_id,
                     retry_count,
                 );
diff --git a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
index 25edd27..04df8d5 100644
--- a/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
+++ b/fluxon_rs/fluxon_kv/src/master_kv_router/route_maintenance.rs
@@ -105,7 +105,7 @@ pub(super) async fn apply_post_route_maintenance_batch(
                 let event_is_current = inner.kv_routes.get(&event.key).is_some_and(|route| {
                     route.put_id == event.put_id
                         && route
-                            .nodes_replicas
+                            .node_replicas
                             .read()
                             .values()
                             .any(|replica| !replica.tomb_tag.is_tomb())
diff --git a/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs b/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs
index 627d361..45d7059 100644
--- a/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/master_seg_manager/mod.rs
@@ -2,7 +2,9 @@ pub mod msg_pack;
 pub mod one_seg_allocator;
 use self::msg_pack::RequestSegmentRegistrationReq;
 use self::msg_pack::SegmentDeviceDescription;
-use self::one_seg_allocator::{Allocation, OneSegAllocator};
+use self::one_seg_allocator::{
+    Allocation, NodePoolCapacityBudget, NodePoolCapacitySnapshot, OneSegAllocator,
+};
 use crate::cluster_manager::NodeID;
 use crate::p2p::p2p_module::P2pModuleAccessTrait;
 use crate::rpcresp_kvresult_convert::msg_and_error::OK;
@@ -22,6 +24,46 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
+fn build_node_segments_manager(
+    node_start_time: i64,
+    seg_map: std::collections::HashMap<
+        SegmentDeviceID,
+        (SegmentDeviceDescription, msg_pack::SegmentDeviceMemInfo),
+    >,
+) -> KvResult<NodeSegmentsManager> {
+    let total_size = seg_map.values().try_fold(0u64, |total, (_, info)| {
+        total.checked_add(info.len).ok_or_else(|| {
+            KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                    detail: "registered node segment capacity overflows u64".to_string(),
+                },
+            )
+        })
+    })?;
+    let capacity_budget = Arc::new(NodePoolCapacityBudget::new(total_size)?);
+    let mut device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>> = HashMap::new();
+    for (device_id, (seg_device_desc, seg_mem_info)) in seg_map {
+        let allocator = OneSegAllocator::new_with_capacity_budget(
+            device_id.clone(),
+            seg_device_desc,
+            seg_mem_info.addr,
+            seg_mem_info.len,
+            capacity_budget.clone(),
+        )
+        .map_err(|e| {
+            tracing::error!("Failed to create OneSegAllocator: {}", e);
+            e
+        })?;
+        device_id_2_allocator.insert(device_id, Arc::new(allocator));
+    }
+    Ok(NodeSegmentsManager::new(
+        node_start_time,
+        total_size,
+        device_id_2_allocator,
+        capacity_budget,
+    ))
+}
+
 // --- Handler Functions ---
 /// https://qcnoe3hd7k5c.feishu.cn/wiki/KkeXwBbP4iCRN8kWSDccP5GBnrd#share-AuMbdrSaXoadUbxRmUncooKnnQd
 fn register_node_segments(
@@ -53,31 +95,7 @@ fn register_node_segments(
 
     match alloc_map.entry(node_id.clone()) {
         dashmap::mapref::entry::Entry::Vacant(v) => {
-            let mut total_size: u64 = 0;
-            let mut device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>> =
-                HashMap::new();
-
-            for (device_id, (seg_device_desc, seg_mem_info)) in seg_map {
-                let allocator = OneSegAllocator::new(
-                    device_id.clone(),
-                    seg_device_desc,
-                    seg_mem_info.addr,
-                    seg_mem_info.len,
-                )
-                .map_err(|e| {
-                    tracing::error!("Failed to create OneSegAllocator: {}", e);
-                    e
-                })?;
-
-                total_size = total_size.saturating_add(seg_mem_info.len);
-                device_id_2_allocator.insert(device_id, Arc::new(allocator));
-            }
-
-            v.insert(NodeSegmentsManager::new(
-                node_start_time,
-                total_size,
-                device_id_2_allocator,
-            ));
+            v.insert(build_node_segments_manager(node_start_time, seg_map)?);
         }
         dashmap::mapref::entry::Entry::Occupied(mut occ) => {
             let node_segments_manager = occ.get_mut();
@@ -96,28 +114,7 @@ fn register_node_segments(
                         },
                     ));
                 }
-                let mut total_size: u64 = 0;
-                let mut device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>> =
-                    HashMap::new();
-
-                for (device_id, (seg_device_desc, seg_mem_info)) in seg_map {
-                    let allocator = OneSegAllocator::new(
-                        device_id.clone(),
-                        seg_device_desc,
-                        seg_mem_info.addr,
-                        seg_mem_info.len,
-                    )
-                    .map_err(|e| {
-                        tracing::error!("Failed to create OneSegAllocator: {}", e);
-                        e
-                    })?;
-
-                    total_size = total_size.saturating_add(seg_mem_info.len);
-                    device_id_2_allocator.insert(device_id, Arc::new(allocator));
-                }
-
-                *node_segments_manager =
-                    NodeSegmentsManager::new(node_start_time, total_size, device_id_2_allocator);
+                *node_segments_manager = build_node_segments_manager(node_start_time, seg_map)?;
                 tracing::info!("RegisterSegment replaced tombed node: {}", node_id);
                 return Ok(());
             }
@@ -154,23 +151,38 @@ fn register_node_segments(
                     ));
                 }
 
-                let allocator = OneSegAllocator::new(
+                let new_total_size = node_segments_manager
+                    .total_size
+                    .checked_add(seg_mem_info.len)
+                    .ok_or_else(|| {
+                        KvError::Api(
+                            crate::rpcresp_kvresult_convert::msg_and_error::ApiError::InvalidArgument {
+                                detail: format!(
+                                    "registered node segment capacity overflows u64: node={}",
+                                    node_id
+                                ),
+                            },
+                        )
+                    })?;
+                let allocator = OneSegAllocator::new_with_capacity_budget(
                     device_id.clone(),
                     seg_device_desc,
                     seg_mem_info.addr,
                     seg_mem_info.len,
+                    node_segments_manager.capacity_budget.clone(),
                 )
                 .map_err(|e| {
                     tracing::error!("Failed to create OneSegAllocator: {}", e);
                     e
                 })?;
 
+                node_segments_manager
+                    .capacity_budget
+                    .extend_physical_capacity(seg_mem_info.len)?;
                 node_segments_manager
                     .device_id_2_allocator
                     .insert(device_id, Arc::new(allocator));
-                node_segments_manager.total_size = node_segments_manager
-                    .total_size
-                    .saturating_add(seg_mem_info.len);
+                node_segments_manager.total_size = new_total_size;
             }
         }
     }
@@ -221,19 +233,22 @@ pub struct NodeSegmentsManager {
     node_start_time: i64,
     total_size: u64,
     device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>>,
+    capacity_budget: Arc<NodePoolCapacityBudget>,
     tomb_tag: NodeTombTag,
 }
 
 impl NodeSegmentsManager {
-    pub fn new(
+    fn new(
         node_start_time: i64,
         total_size: u64,
         device_id_2_allocator: HashMap<SegmentDeviceID, Arc<OneSegAllocator>>,
+        capacity_budget: Arc<NodePoolCapacityBudget>,
     ) -> Self {
         Self {
             node_start_time,
             total_size,
             device_id_2_allocator,
+            capacity_budget,
             tomb_tag: NodeTombTag::new(),
         }
     }
@@ -513,7 +528,7 @@ impl MasterSegManager {
         Ok(())
     }
 
-    pub fn get_node_space_size(&self, node_id: &str) -> u64 {
+    pub fn get_node_physical_space_size(&self, node_id: &str) -> u64 {
         self.inner()
             .node_allocators_and_tomb_tag
             .get(node_id)
@@ -521,4 +536,109 @@ impl MasterSegManager {
             .map(|node_segments_manager| node_segments_manager.total_size)
             .unwrap_or(0)
     }
+
+    pub fn get_node_active_space_size(&self, node_id: &str) -> u64 {
+        self.get_node_pool_capacity(node_id)
+            .map(|(_, snapshot)| snapshot.active_capacity_bytes)
+            .unwrap_or(0)
+    }
+
+    /// Return the exact live node generation and its shared active/parked capacity state.
+    pub fn get_node_pool_capacity(&self, node_id: &str) -> Option<(i64, NodePoolCapacitySnapshot)> {
+        let node = self.inner().node_allocators_and_tomb_tag.get(node_id)?;
+        if node.tomb_tag.is_tomb() {
+            return None;
+        }
+        Some((node.node_start_time, node.capacity_budget.snapshot()))
+    }
+
+    /// Update one live node generation with optimistic epoch fencing.
+    pub fn set_node_active_capacity(
+        &self,
+        node_id: &NodeID,
+        expected_node_start_time: i64,
+        expected_capacity_epoch: u64,
+        active_capacity_bytes: u64,
+    ) -> KvResult<NodePoolCapacitySnapshot> {
+        let node = self
+            .inner()
+            .node_allocators_and_tomb_tag
+            .get(node_id)
+            .ok_or_else(|| {
+                KvError::Api(
+                    crate::rpcresp_kvresult_convert::msg_and_error::ApiError::NodeNotFound {
+                        desc: node_id.to_string(),
+                    },
+                )
+            })?;
+        if node.tomb_tag.is_tomb() {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::NodeNotFound {
+                    desc: format!("{} (departed generation)", node_id),
+                },
+            ));
+        }
+        if node.node_start_time != expected_node_start_time {
+            return Err(KvError::Api(
+                crate::rpcresp_kvresult_convert::msg_and_error::ApiError::OwnerStartTimeMismatch {
+                    expected: expected_node_start_time,
+                    got: node.node_start_time,
+                },
+            ));
+        }
+        node.capacity_budget
+            .set_active_capacity(expected_capacity_epoch, active_capacity_bytes)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::master_seg_manager::msg_pack::SegmentDeviceMemInfo;
+
+    #[test]
+    fn one_node_generation_shares_one_budget_across_registered_segments() {
+        let manager = build_node_segments_manager(
+            17,
+            HashMap::from([
+                (
+                    "cpu0".to_string(),
+                    (
+                        SegmentDeviceDescription::Cpu,
+                        SegmentDeviceMemInfo {
+                            addr: 0,
+                            len: 8 * 1024,
+                        },
+                    ),
+                ),
+                (
+                    "cpu1".to_string(),
+                    (
+                        SegmentDeviceDescription::Cpu,
+                        SegmentDeviceMemInfo {
+                            addr: 8 * 1024,
+                            len: 8 * 1024,
+                        },
+                    ),
+                ),
+            ]),
+        )
+        .unwrap();
+        let initial = manager.capacity_budget.snapshot();
+        assert_eq!(initial.physical_capacity_bytes, 16 * 1024);
+        assert_eq!(initial.active_capacity_bytes, 16 * 1024);
+
+        let allocators = manager
+            .device_id_2_allocator
+            .values()
+            .cloned()
+            .collect::<Vec<_>>();
+        let _first = allocators[0].allocate(8 * 1024).unwrap();
+        let _second = allocators[1].allocate(8 * 1024).unwrap();
+        assert_eq!(
+            manager.capacity_budget.snapshot().used_capacity_bytes,
+            16 * 1024
+        );
+        assert!(allocators[0].allocate(1).is_err());
+    }
 }
diff --git a/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs b/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs
index 18eaf66..817e278 100755
--- a/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs
+++ b/fluxon_rs/fluxon_kv/src/master_seg_manager/one_seg_allocator.rs
@@ -1,10 +1,209 @@
 use fluxon_util::vallocator::VirtualAllocator;
+use parking_lot::Mutex;
 
-use crate::rpcresp_kvresult_convert::msg_and_error::KvResult;
+use crate::rpcresp_kvresult_convert::msg_and_error::{ApiError, KvError, KvResult};
 use std::sync::Arc;
 
 use super::msg_pack::{SegmentDeviceDescription, SegmentDeviceID};
 
+/// Runtime capacity state shared by every segment registered by one node generation.
+///
+/// Physical capacity describes the already allocated and registered memory. Active capacity is
+/// the allocation budget currently exposed to Fluxon; the remainder is parked without changing
+/// the underlying mapping or registration.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct NodePoolCapacitySnapshot {
+    pub physical_capacity_bytes: u64,
+    pub active_capacity_bytes: u64,
+    pub used_capacity_bytes: u64,
+    pub parked_capacity_bytes: u64,
+    pub draining_capacity_bytes: u64,
+    pub available_capacity_bytes: u64,
+    pub capacity_epoch: u64,
+}
+
+#[derive(Debug)]
+struct NodePoolCapacityState {
+    physical_capacity_bytes: u64,
+    active_capacity_bytes: u64,
+    used_capacity_bytes: u64,
+    capacity_epoch: u64,
+}
+
+/// One generation-scoped allocation budget shared by all of a node's segment allocators.
+#[derive(Debug)]
+pub(crate) struct NodePoolCapacityBudget {
+    state: Mutex<NodePoolCapacityState>,
+}
+
+impl NodePoolCapacityBudget {
+    pub(crate) fn new(physical_capacity_bytes: u64) -> KvResult<Self> {
+        if physical_capacity_bytes == 0 {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "node pool physical capacity must be greater than zero".to_string(),
+            }));
+        }
+        Ok(Self {
+            state: Mutex::new(NodePoolCapacityState {
+                physical_capacity_bytes,
+                active_capacity_bytes: physical_capacity_bytes,
+                used_capacity_bytes: 0,
+                capacity_epoch: 1,
+            }),
+        })
+    }
+
+    fn snapshot_locked(state: &NodePoolCapacityState) -> NodePoolCapacitySnapshot {
+        NodePoolCapacitySnapshot {
+            physical_capacity_bytes: state.physical_capacity_bytes,
+            active_capacity_bytes: state.active_capacity_bytes,
+            used_capacity_bytes: state.used_capacity_bytes,
+            parked_capacity_bytes: state
+                .physical_capacity_bytes
+                .saturating_sub(state.active_capacity_bytes),
+            draining_capacity_bytes: state
+                .used_capacity_bytes
+                .saturating_sub(state.active_capacity_bytes),
+            available_capacity_bytes: state
+                .active_capacity_bytes
+                .saturating_sub(state.used_capacity_bytes),
+            capacity_epoch: state.capacity_epoch,
+        }
+    }
+
+    pub(crate) fn snapshot(&self) -> NodePoolCapacitySnapshot {
+        Self::snapshot_locked(&self.state.lock())
+    }
+
+    /// Change only the active allocation budget. Existing allocations above a lower target are
+    /// accounted as draining bytes and remain valid until the normal single-KV reclaim path drops
+    /// them.
+    pub(crate) fn set_active_capacity(
+        &self,
+        expected_capacity_epoch: u64,
+        active_capacity_bytes: u64,
+    ) -> KvResult<NodePoolCapacitySnapshot> {
+        let mut state = self.state.lock();
+        if state.capacity_epoch != expected_capacity_epoch {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "stale node pool capacity epoch: expected={} current={}",
+                    expected_capacity_epoch, state.capacity_epoch
+                ),
+            }));
+        }
+        if active_capacity_bytes == 0 || active_capacity_bytes > state.physical_capacity_bytes {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: format!(
+                    "active capacity must be in 1..={}: got {}",
+                    state.physical_capacity_bytes, active_capacity_bytes
+                ),
+            }));
+        }
+        if state.active_capacity_bytes != active_capacity_bytes {
+            state.active_capacity_bytes = active_capacity_bytes;
+            state.capacity_epoch = state
+                .capacity_epoch
+                .checked_add(1)
+                .expect("node pool capacity epoch overflow");
+        }
+        Ok(Self::snapshot_locked(&state))
+    }
+
+    /// Extend a live generation when it registers an additional segment. A fully active pool
+    /// grows with its physical mapping; an already parked pool preserves its active byte target.
+    pub(crate) fn extend_physical_capacity(&self, additional_bytes: u64) -> KvResult<()> {
+        if additional_bytes == 0 {
+            return Err(KvError::Api(ApiError::InvalidArgument {
+                detail: "additional physical capacity must be greater than zero".to_string(),
+            }));
+        }
+        let mut state = self.state.lock();
+        let was_fully_active = state.active_capacity_bytes == state.physical_capacity_bytes;
+        state.physical_capacity_bytes = state
+            .physical_capacity_bytes
+            .checked_add(additional_bytes)
+            .ok_or_else(|| {
+                KvError::Api(ApiError::InvalidArgument {
+                    detail: "node pool physical capacity overflow".to_string(),
+                })
+            })?;
+        if was_fully_active {
+            state.active_capacity_bytes = state.physical_capacity_bytes;
+        }
+        state.capacity_epoch = state
+            .capacity_epoch
+            .checked_add(1)
+            .expect("node pool capacity epoch overflow");
+        Ok(())
+    }
+
+    fn allocate(&self, allocator: &VirtualAllocator, size: u64) -> KvResult<(u64, u64)> {
+        // The budget lock spans the physical allocator mutation. Capacity changes and allocations
+        // therefore have one total order; a resize cannot be bypassed by a stale pre-check.
+        let mut state = self.state.lock();
+        if size
+            > state
+                .active_capacity_bytes
+                .saturating_sub(state.used_capacity_bytes)
+        {
+            return Err(KvError::Api(ApiError::Allocator {
+                detail: format!(
+                    "node pool active capacity exhausted: requested={} active={} used={} epoch={}",
+                    size,
+                    state.active_capacity_bytes,
+                    state.used_capacity_bytes,
+                    state.capacity_epoch
+                ),
+            }));
+        }
+        let region = allocator.alloc(size)?;
+        let Some(next_used) = state.used_capacity_bytes.checked_add(region.size) else {
+            let _ = allocator.free(region.start_addr, region.size);
+            return Err(KvError::Api(ApiError::Allocator {
+                detail: "node pool used capacity overflow".to_string(),
+            }));
+        };
+        if next_used > state.active_capacity_bytes {
+            // VirtualAllocator rounds allocations to its alignment. Roll the physical mutation
+            // back when the aligned size crosses the active byte boundary.
+            let _ = allocator.free(region.start_addr, region.size);
+            return Err(KvError::Api(ApiError::Allocator {
+                detail: format!(
+                    "node pool active capacity exhausted after alignment: requested={} aligned={} active={} used={} epoch={}",
+                    size,
+                    region.size,
+                    state.active_capacity_bytes,
+                    state.used_capacity_bytes,
+                    state.capacity_epoch
+                ),
+            }));
+        }
+        state.used_capacity_bytes = next_used;
+        Ok((region.start_addr, region.size))
+    }
+
+    fn free(&self, allocator: &VirtualAllocator, addr: u64, capacity: u64) {
+        let mut state = self.state.lock();
+        match allocator.free(addr, capacity) {
+            Ok(freed) => {
+                state.used_capacity_bytes = state
+                    .used_capacity_bytes
+                    .checked_sub(freed)
+                    .expect("node pool used capacity underflow");
+            }
+            Err(err) => {
+                tracing::error!(
+                    addr,
+                    capacity,
+                    error = %err,
+                    "failed to free segment allocation; preserving node pool used accounting"
+                );
+            }
+        }
+    }
+}
+
 /// An RAII guard for a memory allocation from a `OneSegAllocator`.
 ///
 /// When this guard is dropped, it attempts to free the memory block
@@ -108,6 +307,7 @@ pub struct OneSegAllocator {
     pub seg_device_desc: SegmentDeviceDescription,
     pub base_addr: u64,
     inner: VirtualAllocator,
+    capacity_budget: Arc<NodePoolCapacityBudget>,
 }
 
 impl OneSegAllocator {
@@ -117,6 +317,23 @@ impl OneSegAllocator {
         seg_device_desc: SegmentDeviceDescription,
         base_addr: u64,
         size: u64,
+    ) -> KvResult<Self> {
+        let capacity_budget = Arc::new(NodePoolCapacityBudget::new(size)?);
+        Self::new_with_capacity_budget(
+            seg_device_id,
+            seg_device_desc,
+            base_addr,
+            size,
+            capacity_budget,
+        )
+    }
+
+    pub(crate) fn new_with_capacity_budget(
+        seg_device_id: SegmentDeviceID,
+        seg_device_desc: SegmentDeviceDescription,
+        base_addr: u64,
+        size: u64,
+        capacity_budget: Arc<NodePoolCapacityBudget>,
     ) -> KvResult<Self> {
         let inner = VirtualAllocator::new(size as u64)?;
         Ok(Self {
@@ -124,18 +341,19 @@ impl OneSegAllocator {
             seg_device_desc,
             base_addr,
             inner,
+            capacity_budget,
         })
     }
 
     /// Allocates a block of memory of `size` bytes.
     /// Returns an RAII guard for the allocation.
     pub fn allocate(self: &Arc<Self>, size: u64) -> KvResult<Allocation> {
-        let region = self.inner.alloc(size as u64)?;
+        let (start_addr, capacity) = self.capacity_budget.allocate(&self.inner, size)?;
         // return base0 offset in addr (pure offset); base address is carried separately
         Ok(Allocation::new(
-            region.start_addr,
+            start_addr,
             size,
-            region.size,
+            capacity,
             Arc::clone(self),
         ))
     }
@@ -143,7 +361,7 @@ impl OneSegAllocator {
     /// Frees a block of memory.
     fn free(&self, addr: u64, capcity: u64) {
         // addr is offset (base0); free directly
-        let _ = self.inner.free(addr, capcity as u64);
+        self.capacity_budget.free(&self.inner, addr, capcity);
     }
 
     /// Returns total capacity (bytes) of this segment.
@@ -155,4 +373,82 @@ impl OneSegAllocator {
     pub fn used_size_bytes(&self) -> u64 {
         self.inner.get_allocated_size() as u64
     }
+
+    /// Returns the active/parked capacity state shared by this node generation.
+    pub fn node_pool_capacity_snapshot(&self) -> NodePoolCapacitySnapshot {
+        self.capacity_budget.snapshot()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn allocator_with_budget(
+        id: &str,
+        size: u64,
+        budget: Arc<NodePoolCapacityBudget>,
+    ) -> Arc<OneSegAllocator> {
+        Arc::new(
+            OneSegAllocator::new_with_capacity_budget(
+                id.to_string(),
+                SegmentDeviceDescription::Cpu,
+                0,
+                size,
+                budget,
+            )
+            .unwrap(),
+        )
+    }
+
+    #[test]
+    fn shrinking_below_used_blocks_new_allocations_until_normal_drop_drains() {
+        let budget = Arc::new(NodePoolCapacityBudget::new(16 * 1024).unwrap());
+        let allocator = allocator_with_budget("cpu", 16 * 1024, budget.clone());
+        let first = allocator.allocate(8 * 1024).unwrap();
+
+        let shrinking = budget.set_active_capacity(1, 4 * 1024).unwrap();
+        assert_eq!(shrinking.capacity_epoch, 2);
+        assert_eq!(shrinking.draining_capacity_bytes, 4 * 1024);
+        assert!(allocator.allocate(1).is_err());
+
+        drop(first);
+        let drained = budget.snapshot();
+        assert_eq!(drained.used_capacity_bytes, 0);
+        assert_eq!(drained.draining_capacity_bytes, 0);
+        assert!(allocator.allocate(4 * 1024).is_ok());
+    }
+
+    #[test]
+    fn shared_node_budget_limits_allocations_across_segments_and_expands_immediately() {
+        let budget = Arc::new(NodePoolCapacityBudget::new(16 * 1024).unwrap());
+        let first_allocator = allocator_with_budget("cpu0", 8 * 1024, budget.clone());
+        let second_allocator = allocator_with_budget("cpu1", 8 * 1024, budget.clone());
+        let first = first_allocator.allocate(8 * 1024).unwrap();
+        let _second = second_allocator.allocate(8 * 1024).unwrap();
+        assert!(first_allocator.allocate(1).is_err());
+
+        drop(first);
+        budget.set_active_capacity(1, 12 * 1024).unwrap();
+        assert!(first_allocator.allocate(4 * 1024).is_ok());
+        assert!(second_allocator.allocate(1).is_err());
+
+        let expanded = budget.set_active_capacity(2, 16 * 1024).unwrap();
+        assert_eq!(expanded.capacity_epoch, 3);
+        assert!(first_allocator.allocate(4 * 1024).is_ok());
+    }
+
+    #[test]
+    fn stale_epoch_and_out_of_physical_range_updates_are_rejected() {
+        let budget = NodePoolCapacityBudget::new(16 * 1024).unwrap();
+        assert!(budget.set_active_capacity(0, 8 * 1024).is_err());
+        assert!(budget.set_active_capacity(1, 0).is_err());
+        assert!(budget.set_active_capacity(1, 32 * 1024).is_err());
+        assert_eq!(budget.snapshot().capacity_epoch, 1);
+
+        let updated = budget.set_active_capacity(1, 8 * 1024).unwrap();
+        assert_eq!(updated.capacity_epoch, 2);
+        assert!(budget.set_active_capacity(1, 4 * 1024).is_err());
+        assert_eq!(budget.snapshot().active_capacity_bytes, 8 * 1024);
+    }
 }
diff --git a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
index 92a559b..1ea89ec 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/lifetime.rs
@@ -433,8 +433,8 @@ impl MemholderManagerTrait for MasterOwnerMemMgr {
         };
 
         let mut targets = Vec::new();
-        let nodes_replicas = nodes_kv_route_info.nodes_replicas.read();
-        for (node_id, kv_route_info) in nodes_replicas.iter() {
+        let node_replicas = nodes_kv_route_info.node_replicas.read();
+        for (node_id, kv_route_info) in node_replicas.iter() {
             if kv_route_info.tomb_tag.is_tomb() {
                 continue;
             }
@@ -476,8 +476,8 @@ impl MemholderManagerTrait for MasterOwnerMemMgr {
                 continue;
             };
 
-            let nodes_replicas = nodes_kv_route_info.nodes_replicas.read();
-            let Some(kv_route_info) = nodes_replicas.get(target.node_id.as_str()) else {
+            let node_replicas = nodes_kv_route_info.node_replicas.read();
+            let Some(kv_route_info) = node_replicas.get(target.node_id.as_str()) else {
                 continue;
             };
             if kv_route_info.tomb_tag.is_tomb() {
diff --git a/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs b/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
index eee9dc0..07fdf7b 100644
--- a/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/memholder_test.rs
@@ -105,6 +105,7 @@ fn new_client_config_with_size(
         large_file_paths: crate::config::LargeFilePaths {
             paths: vec![format!("/tmp/kvcache_large/{}", instance_key)],
         },
+        ssd_storage: None,
         test_spec_config: TestSpecConfig::default(),
     }
 }
@@ -139,6 +140,7 @@ fn new_zero_contribution_client_config(
         },
         share_mem_path: format!("/tmp/kvcache_shared_memory/{}", owner_instance_key),
         large_file_paths: crate::config::LargeFilePaths { paths: Vec::new() },
+        ssd_storage: None,
         test_spec_config: TestSpecConfig::default(),
     }
 }
@@ -197,7 +199,7 @@ fn evict_all_replicas_for_key(master_view: &MasterKvRouterView, key: &str) -> us
             .get(key)
             .map(|route| {
                 let node_ids = route
-                    .nodes_replicas
+                    .node_replicas
                     .read()
                     .keys()
                     .cloned()
diff --git a/fluxon_rs/fluxon_kv/src/memholder/mod.rs b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
index f23c88a..55cb437 100755
--- a/fluxon_rs/fluxon_kv/src/memholder/mod.rs
+++ b/fluxon_rs/fluxon_kv/src/memholder/mod.rs
@@ -305,30 +305,39 @@ impl Drop for MemoryInfo {
                 grant_id,
                 slot_index,
             } => {
-                let spawn_view = self.view.clone();
-                let release_view = self.view.clone();
-                let key = self.key.clone();
-                let slot_size = *slot_size;
-                let grant_id = *grant_id;
-                let slot_index = *slot_index;
-                let _ = spawn_view.spawn("resident_local_reserve_slot_release", async move {
-                    if let Err(err) = release_view
-                        .client_kv_api()
-                        .inner()
-                        .owner_release_local_reserve_resident_slot_holder(
-                            slot_size, grant_id, slot_index,
-                        )
-                    {
-                        tracing::warn!(
-                            "failed to release resident local reserve slot holder on MemoryInfo drop: key={} slot_size={} grant_id={} slot_index={} err={}",
-                            key,
-                            slot_size,
-                            grant_id,
-                            slot_index,
-                            err
-                        );
-                    }
-                });
+                let Some(_view_guard) = self.view.try_upgrade() else {
+                    tracing::debug!(
+                        key = self.key,
+                        "skipping resident local reserve slot release after view drop"
+                    );
+                    return;
+                };
+                if !self.view.register_shutdown_poller().is_running() {
+                    tracing::debug!(
+                        key = self.key,
+                        "skipping resident local reserve slot release during shutdown"
+                    );
+                    return;
+                }
+                if let Err(err) = self
+                    .view
+                    .client_kv_api()
+                    .inner()
+                    .owner_release_local_reserve_resident_slot_holder(
+                        *slot_size,
+                        *grant_id,
+                        *slot_index,
+                    )
+                {
+                    tracing::warn!(
+                        "failed to release resident local reserve slot holder on MemoryInfo drop: key={} slot_size={} grant_id={} slot_index={} err={}",
+                        self.key,
+                        slot_size,
+                        grant_id,
+                        slot_index,
+                        err
+                    );
+                }
             }
         }
     }
diff --git a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
index 91558b6..d9d24a8 100644
--- a/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
+++ b/fluxon_rs/fluxon_kv/src/rpcresp_kvresult_convert/msg_and_error.rs
@@ -87,6 +87,12 @@ pub enum MsgId {
     BatchGetPlanResp = 3072,
     BatchGetBindReq = 3073,
     BatchGetBindResp = 3074,
+    BatchPublishOwnerSsdReq = 3075,
+    BatchPublishOwnerSsdResp = 3076,
+    SsdStageBeginReq = 3077,
+    SsdStageBeginResp = 3078,
+    SsdStageDoneReq = 3079,
+    SsdStageDoneResp = 3080,
     ExternalGetReq = 4001,
     ExternalGetResp = 4002,
     ExternalPutStartReq = 4003,
diff --git a/fluxon_rs/fluxon_pyo3/src/lib.rs b/fluxon_rs/fluxon_pyo3/src/lib.rs
index a6453dc..0165f9f 100644
--- a/fluxon_rs/fluxon_pyo3/src/lib.rs
+++ b/fluxon_rs/fluxon_pyo3/src/lib.rs
@@ -60,7 +60,9 @@ use fluxon_util::{
     FluxonCliProxyDescriptorV2, FluxonCliProxyTransportV2, fluxon_cli_proxy_desc_etcd_key_v2,
 };
 use futures::Future;
-use pyo3::exceptions::{PyOSError, PyPermissionError, PyRuntimeError, PyValueError};
+use pyo3::exceptions::{
+    PyKeyboardInterrupt, PyOSError, PyPermissionError, PyRuntimeError, PyValueError,
+};
 use pyo3::prelude::*;
 use pyo3::pybacked::PyBackedBytes;
 use pyo3::types::{PyAny, PyBytes, PyDict, PyList, PyModule, PyString, PyTuple};
@@ -4216,6 +4218,10 @@ impl KvClient {
                                     len: owner_data.value_len,
                                 },
                                 make_replica_task: *make_replica_task,
+                                // This owner-local path has no earlier remote
+                                // reservation. Selected items are admitted to
+                                // run append Start, where allocation occurs.
+                                remote_replica_admitted: *make_replica_task,
                                 preferred_sub_cluster: None,
                                 atomic_group: atomic_groups[idx].clone(),
                             });
@@ -7756,7 +7762,7 @@ impl Drop for KvMaster {
 /// This function creates a master, runs it until Ctrl+C, then shuts down
 #[pyfunction]
 #[pyo3(signature = (config=None))]
-fn run_master_blocking(config: Option<&Bound<'_, PyAny>>, py: Python) -> PyObject {
+fn run_master_blocking(config: Option<&Bound<'_, PyAny>>, py: Python) -> PyResult<PyObject> {
     fn run_master_inner(config: Option<&Bound<'_, PyAny>>, py: Python) -> ApiResult<PyObject> {
         // Debug config
         println!("🛠️  Master init configuration: {:?}", config);
@@ -7878,7 +7884,20 @@ fn run_master_blocking(config: Option<&Bound<'_, PyAny>>, py: Python) -> PyObjec
         out
     }
 
-    run_master_inner(config, py).into_py_object(py)
+    let result = run_master_inner(config, py);
+    // The same SIGINT wakes Tokio's ctrl_c future and becomes a pending Python
+    // KeyboardInterrupt while the GIL is released. Once the framework has
+    // completed its graceful shutdown, consume only that expected interrupt
+    // before constructing the Python Result object. Other Python exceptions
+    // remain visible to the caller.
+    if let Err(err) = py.check_signals() {
+        if err.is_instance_of::<PyKeyboardInterrupt>(py) {
+            tracing::debug!("consumed KeyboardInterrupt after graceful KV master shutdown");
+        } else {
+            return Err(err);
+        }
+    }
+    Ok(result.into_py_object(py))
 }
 
 /// Python module definition
diff --git a/setup_and_pack/rather_no_git_submodule.yaml b/setup_and_pack/rather_no_git_submodule.yaml
index 9f00b04..453a0e3 100644
--- a/setup_and_pack/rather_no_git_submodule.yaml
+++ b/setup_and_pack/rather_no_git_submodule.yaml
@@ -1,4 +1,4 @@
 modules:
   - path: fluxon_rs/moka
     repo: https://github.com/ActivePeter/moka
-    checkout: main
+    checkout: 91c97076e7b1bbac306d7ace7b74f9e994440b2d