From 148de5caac607426ff0a535216764e82960261f6 Mon Sep 17 00:00:00 2001
From: pgherveou <pgherveou@gmail.com>
Date: Thu, 3 Sep 2026 10:53:00 +0200
Subject: [PATCH 1/4] fix: use runtime statement-slot context

Proofs must include the live network suffix or the People runtime rejects them as BadProof.
---
 rust/crates/truapi-host-cli/src/main.rs       |  31 +++-
 .../tests/live_people_chain.rs                |   4 +
 .../runtime/signing_host/allowance_renewal.rs |   4 +
 .../src/runtime/signing_host/sso_responder.rs |  13 +-
 .../src/runtime/statement_allowance.rs        |  34 +++-
 .../runtime/statement_allowance/renewal.rs    |   8 +
 .../src/runtime/statement_allowance/slot.rs   | 173 +++++++++++++++---
 rust/crates/truapi-server/src/test_support.rs |  21 ++-
 8 files changed, 253 insertions(+), 35 deletions(-)

diff --git a/rust/crates/truapi-host-cli/src/main.rs b/rust/crates/truapi-host-cli/src/main.rs
index f6cd0046e..42bb3a267 100644
--- a/rust/crates/truapi-host-cli/src/main.rs
+++ b/rust/crates/truapi-host-cli/src/main.rs
@@ -795,6 +795,9 @@ async fn run_alloc_check(
     let chain_state = alloc::fetch_chain_state(&rpc)
         .await
         .map_err(anyhow::Error::msg)?;
+    let network_suffix = alloc::slot::read_network_suffix(&rpc)
+        .await
+        .map_err(anyhow::Error::msg)?;
     println!(
         "chain: specVersion={} txVersion={} genesis=0x{}",
         chain_state.spec_version,
@@ -841,16 +844,33 @@ async fn run_alloc_check(
             continue;
         }
         print!("{}: ", candidate.collection);
-        report_slot_scan(&rpc, &metadata, *candidate, period, &target, now).await?;
+        report_slot_scan(
+            &rpc,
+            &metadata,
+            *candidate,
+            &network_suffix,
+            period,
+            &target,
+            now,
+        )
+        .await?;
     }
 
     if submit {
         if memberships.is_empty() {
             bail!("cannot submit: member not in any ring");
         }
-        let scans = alloc::scan_collections(&rpc, &metadata, &candidates, period, &target, true)
-            .await
-            .map_err(anyhow::Error::msg)?;
+        let scans = alloc::scan_collections(
+            &rpc,
+            &metadata,
+            &candidates,
+            &network_suffix,
+            period,
+            &target,
+            true,
+        )
+        .await
+        .map_err(anyhow::Error::msg)?;
         match alloc::register_statement_account_pooled(
             &rpc,
             &metadata,
@@ -860,6 +880,7 @@ async fn run_alloc_check(
             alloc::PooledRegistrationParams {
                 target: &target,
                 period,
+                network_suffix: &network_suffix,
                 reuse_existing: true,
                 // A diagnostic that submits behaves as it did before pooling,
                 // where a full table was replaced rather than reported.
@@ -893,6 +914,7 @@ async fn report_slot_scan(
     rpc: &alloc::rpc::RpcClient,
     metadata: &alloc::extension::Metadata,
     candidate: alloc::CollectionCandidate,
+    network_suffix: &[u8],
     period: u32,
     target: &[u8; 32],
     now: u64,
@@ -903,6 +925,7 @@ async fn report_slot_scan(
         alloc::slot::SlotScan {
             collection: candidate.collection,
             entropy: candidate.entropy,
+            network_suffix,
             period,
             target,
             excluded: &[],
diff --git a/rust/crates/truapi-host-cli/tests/live_people_chain.rs b/rust/crates/truapi-host-cli/tests/live_people_chain.rs
index c8bcc7596..0577fefa9 100644
--- a/rust/crates/truapi-host-cli/tests/live_people_chain.rs
+++ b/rust/crates/truapi-host-cli/tests/live_people_chain.rs
@@ -103,6 +103,9 @@ async fn scanning_a_live_period_answers_without_erroring() {
         .await
         .expect("read the live chain context");
     let period = current_period();
+    let network_suffix = alloc::slot::read_network_suffix(&rpc)
+        .await
+        .expect("read the live network suffix");
 
     // Entropy and target are throwaway: no alias derived from them owns a slot,
     // so the scan must offer a free one or report the table full — never error.
@@ -112,6 +115,7 @@ async fn scanning_a_live_period_answers_without_erroring() {
         alloc::slot::SlotScan {
             collection: PersonhoodCollection::LitePeople,
             entropy: [0x11; 32],
+            network_suffix: &network_suffix,
             period,
             target: &[0x22; 32],
             excluded: &[],
diff --git a/rust/crates/truapi-server/src/runtime/signing_host/allowance_renewal.rs b/rust/crates/truapi-server/src/runtime/signing_host/allowance_renewal.rs
index bcbd17725..0ecb6a5b9 100644
--- a/rust/crates/truapi-server/src/runtime/signing_host/allowance_renewal.rs
+++ b/rust/crates/truapi-server/src/runtime/signing_host/allowance_renewal.rs
@@ -411,6 +411,9 @@ pub(super) async fn renew_now(
     let chain_state = fetch_chain_state(&rpc)
         .await
         .map_err(|err| err.to_string())?;
+    let network_suffix = statement_allowance::slot::read_network_suffix(&rpc)
+        .await
+        .map_err(|err| err.to_string())?;
     // Every ring back to index 0, because a membership that stopped being
     // re-included still proves against the ring that holds it.
     let memberships = find_including_rings(&rpc, &metadata, &candidates, u32::MAX)
@@ -426,6 +429,7 @@ pub(super) async fn renew_now(
         rpc: &rpc,
         metadata: &metadata,
         chain_state: &chain_state,
+        network_suffix: &network_suffix,
         candidates: &candidates,
         memberships: &memberships,
     };
diff --git a/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs b/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
index c5f3908dc..5c96daf91 100644
--- a/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
+++ b/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
@@ -1071,6 +1071,7 @@ pub(super) async fn allocate_statement_store_allowance(
         .await?;
     let rpc = client.rpc();
     let chain = services.chain_context.get(&client).await?;
+    let network_suffix = statement_allowance::slot::read_network_suffix(rpc).await?;
     let period = statement_allowance::slot::current_period(current_unix_secs()?);
     let reuse_existing = matches!(policy, OnExistingAllowancePolicy::Ignore);
 
@@ -1087,6 +1088,7 @@ pub(super) async fn allocate_statement_store_allowance(
         rpc,
         &chain.metadata,
         &candidates,
+        &network_suffix,
         period,
         &target,
         reuse_existing,
@@ -1120,6 +1122,7 @@ pub(super) async fn allocate_statement_store_allowance(
         PooledRegistrationParams {
             target: &target,
             period,
+            network_suffix: &network_suffix,
             reuse_existing,
             // Connecting a product must not revoke another product's allowance.
             // A full period is reported as exhaustion; reclaiming space is the
@@ -1773,6 +1776,10 @@ mod tests {
                     "state_getMetadata",
                     format!(r#""0x{}""#, hex::encode(PEOPLE_METADATA)),
                 ),
+                (
+                    "state_getStorage",
+                    format!(r#""0x{}""#, hex::encode(b"paseo".to_vec().encode())),
+                ),
                 (
                     "state_getStorage",
                     format!(r#""0x{}""#, hex::encode(&slot_entry)),
@@ -1829,14 +1836,14 @@ mod tests {
                 .any(|method| method.starts_with("author_submit")),
             "an extrinsic was submitted for an allowance already in place: {methods:?}"
         );
-        // One slot read answered it; the scan stopped at the first match.
+        // The suffix and one slot read answered it; the scan stopped at the first match.
         assert_eq!(
             methods
                 .iter()
                 .filter(|method| *method == "state_getStorage")
                 .count(),
-            1,
-            "expected a single slot read: {methods:?}"
+            2,
+            "expected one suffix and one slot read: {methods:?}"
         );
     }
 
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance.rs b/rust/crates/truapi-server/src/runtime/statement_allowance.rs
index c312344d5..4e3f4757d 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance.rs
@@ -411,6 +411,8 @@ pub struct RegistrationParams<'a> {
     pub target: &'a [u8; 32],
     /// Statement-store period for which the registration is requested.
     pub period: u32,
+    /// Runtime-wide suffix used for product-scoped aliases and proofs.
+    pub network_suffix: &'a [u8],
     /// Ring parameters used to build the membership proof.
     pub ring: &'a RingParams,
     /// Whether an existing registration for this period may be reused.
@@ -612,6 +614,7 @@ pub async fn register_statement_account(
                 slot::SlotScan {
                     collection,
                     entropy,
+                    network_suffix: params.network_suffix,
                     period: params.period,
                     target: params.target,
                     excluded: &skipped_duplicate_slots,
@@ -668,7 +671,7 @@ pub async fn register_statement_account(
             },
         };
 
-        let context = slot::derive_slot_context(params.period, seq);
+        let context = slot::derive_slot_context(params.network_suffix, params.period, seq);
         let call = extrinsic::build_set_statement_store_account_call(
             metadata,
             params.period,
@@ -691,7 +694,15 @@ pub async fn register_statement_account(
 
         match rpc.submit_and_watch(&extrinsic).await {
             Ok(block_hash) => {
-                if slot::read_slot_account_at(rpc, entropy, params.period, seq, &block_hash).await?
+                if slot::read_slot_account_at(
+                    rpc,
+                    entropy,
+                    params.network_suffix,
+                    params.period,
+                    seq,
+                    &block_hash,
+                )
+                .await?
                     != Some(*params.target)
                 {
                     return Err(SlotError::RegistrationVerificationMismatch {
@@ -753,6 +764,7 @@ pub async fn scan_collections(
     rpc: &RpcClient,
     metadata: &Metadata,
     candidates: &[CollectionCandidate],
+    network_suffix: &[u8],
     period: u32,
     target: &[u8; 32],
     reuse_existing: bool,
@@ -770,6 +782,7 @@ pub async fn scan_collections(
             slot::SlotScan {
                 collection,
                 entropy: candidate.entropy,
+                network_suffix,
                 period,
                 target,
                 excluded: &[],
@@ -816,6 +829,8 @@ pub struct PooledRegistrationParams<'a> {
     pub target: &'a [u8; 32],
     /// Statement-store period for which the registration is requested.
     pub period: u32,
+    /// Runtime-wide suffix used for product-scoped aliases and proofs.
+    pub network_suffix: &'a [u8],
     /// Whether an existing registration for this period may be reused.
     pub reuse_existing: bool,
     /// Whether a live slot may be replaced once every collection is full.
@@ -964,6 +979,7 @@ pub async fn register_statement_account_pooled(
         RegistrationParams {
             target: params.target,
             period: params.period,
+            network_suffix: params.network_suffix,
             ring: &membership.ring,
             reuse_existing: params.reuse_existing,
             preselected: Some(choice),
@@ -1628,6 +1644,7 @@ mod tests {
             RegistrationParams {
                 target: &[0x22; 32],
                 period: 7,
+                network_suffix: b"paseo",
                 ring: &ring,
                 reuse_existing: true,
                 preselected,
@@ -1695,7 +1712,8 @@ mod tests {
         let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
 
         let outcome = futures::executor::block_on(async {
-            let scans = scan_collections(&rpc, &metadata, &candidates, 7, &target, true).await?;
+            let scans =
+                scan_collections(&rpc, &metadata, &candidates, b"paseo", 7, &target, true).await?;
             register_statement_account_pooled(
                 &rpc,
                 &metadata,
@@ -1705,6 +1723,7 @@ mod tests {
                 PooledRegistrationParams {
                     target: &target,
                     period: 7,
+                    network_suffix: b"paseo",
                     reuse_existing: true,
                     allow_eviction,
                     protected,
@@ -1736,7 +1755,8 @@ mod tests {
         let rpc = RpcClient::new(HostRpcClient::new(scripted));
 
         futures::executor::block_on(async {
-            let scans = scan_collections(&rpc, &metadata, &candidates, 7, &target, true).await?;
+            let scans =
+                scan_collections(&rpc, &metadata, &candidates, b"paseo", 7, &target, true).await?;
             register_statement_account_pooled(
                 &rpc,
                 &metadata,
@@ -1746,6 +1766,7 @@ mod tests {
                 PooledRegistrationParams {
                     target: &target,
                     period: 7,
+                    network_suffix: b"paseo",
                     reuse_existing: true,
                     allow_eviction: true,
                     protected: &[],
@@ -2199,6 +2220,7 @@ mod tests {
             &rpc,
             &metadata,
             &candidates,
+            b"paseo",
             7,
             &target,
             true,
@@ -2263,6 +2285,7 @@ mod tests {
             RegistrationParams {
                 target: &[0x22; 32],
                 period: 7,
+                network_suffix: b"paseo",
                 ring: &ring,
                 reuse_existing: true,
                 preselected: None,
@@ -2322,6 +2345,7 @@ mod tests {
             RegistrationParams {
                 target: &[0x22; 32],
                 period: 7,
+                network_suffix: b"paseo",
                 ring: &ring,
                 reuse_existing: true,
                 preselected: None,
@@ -2373,6 +2397,7 @@ mod tests {
             RegistrationParams {
                 target: &[0x22; 32],
                 period: 7,
+                network_suffix: b"paseo",
                 ring: &ring,
                 reuse_existing: true,
                 preselected: None,
@@ -2422,6 +2447,7 @@ mod tests {
             RegistrationParams {
                 target: &[0x22; 32],
                 period: 7,
+                network_suffix: b"paseo",
                 ring: &ring,
                 reuse_existing: true,
                 preselected: None,
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/renewal.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/renewal.rs
index 21f965541..d491cb225 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/renewal.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/renewal.rs
@@ -149,6 +149,8 @@ pub struct RenewalChainContext<'a> {
     pub metadata: &'a Metadata,
     /// Signed-extension chain state.
     pub chain_state: &'a ChainState,
+    /// Runtime-wide suffix used for product-scoped aliases and proofs.
+    pub network_suffix: &'a [u8],
     /// Every collection the host can derive aliases for, so an allowance already
     /// held in a collection whose ring cannot currently be proved is still seen.
     pub candidates: &'a [CollectionCandidate],
@@ -186,6 +188,7 @@ pub async fn renew_targets(
                 context.rpc,
                 context.metadata,
                 context.candidates,
+                context.network_suffix,
                 period,
                 &target.account_id,
                 true,
@@ -218,6 +221,7 @@ pub async fn renew_targets(
                     context.rpc,
                     context.metadata,
                     context.candidates,
+                    context.network_suffix,
                     period,
                     &target.account_id,
                     true,
@@ -235,6 +239,7 @@ pub async fn renew_targets(
                     PooledRegistrationParams {
                         target: &target.account_id,
                         period,
+                        network_suffix: context.network_suffix,
                         reuse_existing: true,
                         // Renewal exists to keep the ledger's targets alive across a
                         // period boundary, so it may reclaim space when full.
@@ -446,6 +451,7 @@ mod tests {
             rpc: &rpc,
             metadata: &metadata,
             chain_state: &chain_state,
+            network_suffix: b"paseo",
             candidates: &candidates,
             memberships: &memberships,
         };
@@ -534,6 +540,7 @@ mod tests {
             rpc: &rpc,
             metadata: &metadata,
             chain_state: &chain_state,
+            network_suffix: b"paseo",
             candidates: &candidates,
             memberships: &memberships,
         };
@@ -633,6 +640,7 @@ mod tests {
             rpc: &rpc,
             metadata: &metadata,
             chain_state: &chain_state,
+            network_suffix: b"paseo",
             candidates: &candidates,
             memberships: &memberships,
         };
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
index a28da7a1d..b25d09001 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
@@ -1,13 +1,13 @@
 //! StatementStore allowance slot selection.
 //!
 //! An allowance is claimed at `(period, seq)`. The slot is bound to a 32-byte
-//! `SSS_SLOT` context; occupancy is read from
+//! product context; occupancy is read from
 //! `Resources.StatementStoreAllowances[period][alias]`, where the alias is
 //! derived from OUR bandersnatch entropy in that slot context. Mirrors
 //! signing-bot `allowance.ts` / `allowance-slots.ts`.
 
-use parity_scale_codec::{Decode, Encode};
-use sp_crypto_hashing::twox_128;
+use parity_scale_codec::{Decode, DecodeAll, Encode};
+use sp_crypto_hashing::{blake2_256, twox_128};
 use thiserror::Error;
 use verifiable::Error as VerifiableError;
 use verifiable::GenerateVerifiable;
@@ -22,6 +22,10 @@ use super::view;
 
 /// StatementStore allowance period: one UTC day, in seconds.
 pub const STATEMENT_STORE_PERIOD_SECONDS: u64 = 86_400;
+const PRODUCT_CONTEXT_PREFIX: &[u8] = b"product/peopl.";
+const STATEMENT_STORE_CONTEXT_PREFIX: &[u8] = b"sys/";
+const STATEMENT_STORE_CONTEXT_FAMILY: u32 = 2;
+const MAX_NETWORK_SUFFIX_LENGTH: usize = 16;
 /// Bulletin long-term-storage claim context prefix.
 const LONG_TERM_STORAGE_CONTEXT_PREFIX: &[u8] = b"pop:polkadot.net/rsc-lts";
 /// Ring-VRF alias context prefix for an Asset Hub PGAS claim.
@@ -104,6 +108,18 @@ pub enum SlotError {
     /// `Timestamp.Now` was absent or undecodable, so slot ages cannot be judged.
     #[error("Timestamp.Now missing from chain state")]
     MissingChainTimestamp,
+    /// The runtime-wide product context suffix was absent from chain storage.
+    #[error("NetworkSuffix.NetworkSuffix missing from chain state")]
+    MissingNetworkSuffix,
+    /// The runtime-wide product context suffix did not have its declared SCALE shape.
+    #[error("NetworkSuffix.NetworkSuffix is not a valid SCALE byte vector: {0}")]
+    NetworkSuffixDecode(#[source] parity_scale_codec::Error),
+    /// The runtime-wide product context suffix was outside its declared bounds.
+    #[error("NetworkSuffix.NetworkSuffix length {len}, expected 1..={MAX_NETWORK_SUFFIX_LENGTH}")]
+    InvalidNetworkSuffixLength {
+        /// Actual suffix length.
+        len: usize,
+    },
     /// Registration reached a block but the slot was not held by the target.
     #[error(
         "registration reached block {block_hash} but slot (period {period}, seq {seq}) is not held by the target account"
@@ -152,22 +168,29 @@ pub fn current_long_term_storage_period(
     Ok((now_seconds / u64::from(period_duration)) as u32)
 }
 
-/// Derive the 32-byte StatementStore slot context:
-/// `"SSS_SLOT:" ‖ u32be(period) ‖ u32be(seq) ‖ 0x20 fill`.
-pub fn derive_slot_context(period: u32, seq: u32) -> [u8; 32] {
-    let mut ctx = [0x20u8; 32];
-    ctx[..9].copy_from_slice(b"SSS_SLOT:");
-    ctx[9..13].copy_from_slice(&period.to_be_bytes());
-    ctx[13..17].copy_from_slice(&seq.to_be_bytes());
-    ctx
+/// Derive the network-scoped 32-byte StatementStore slot context.
+pub fn derive_slot_context(network_suffix: &[u8], period: u32, seq: u32) -> [u8; 32] {
+    let mut suffix = [0u8; 32];
+    suffix[..4].copy_from_slice(STATEMENT_STORE_CONTEXT_PREFIX);
+    suffix[4..8].copy_from_slice(&STATEMENT_STORE_CONTEXT_FAMILY.to_le_bytes());
+    suffix[8..12].copy_from_slice(&period.to_le_bytes());
+    suffix[12..16].copy_from_slice(&seq.to_le_bytes());
+
+    let mut preimage = Vec::with_capacity(
+        PRODUCT_CONTEXT_PREFIX.len() + network_suffix.len() + b"/".len() + suffix.len(),
+    );
+    preimage.extend_from_slice(PRODUCT_CONTEXT_PREFIX);
+    preimage.extend_from_slice(network_suffix);
+    preimage.push(b'/');
+    preimage.extend_from_slice(&suffix);
+    blake2_256(&preimage)
 }
 
 /// Derive the 32-byte Asset Hub PGAS claim context:
 /// `"pop:gas:" ‖ u32le(day) ‖ u32le(slot_index) ‖ zero fill`.
 ///
-/// The two integers are little-endian here, unlike the big-endian statement-store
-/// and long-term-storage contexts. The mobile wallet writes them this way and the
-/// runtime verifies against the same bytes, so the layout is not ours to tidy.
+/// The mobile wallet writes the integers in little-endian order and the runtime
+/// verifies against the same bytes, so the layout is not ours to tidy.
 pub fn derive_pgas_context(day: u32, slot_index: u32) -> [u8; 32] {
     let mut ctx = [0u8; 32];
     ctx[..PGAS_CONTEXT_PREFIX.len()].copy_from_slice(PGAS_CONTEXT_PREFIX);
@@ -191,11 +214,12 @@ pub fn derive_long_term_storage_context(period: u32, counter: u8) -> [u8; 32] {
 /// The slot alias for our `entropy` at `(period, seq)`.
 pub fn slot_alias(
     entropy: [u8; 32],
+    network_suffix: &[u8],
     period: u32,
     seq: u32,
 ) -> Result<[u8; 32], StatementAllowanceError> {
     let secret = BandersnatchVrfVerifiable::new_secret(entropy);
-    let context = derive_slot_context(period, seq);
+    let context = derive_slot_context(network_suffix, period, seq);
     BandersnatchVrfVerifiable::alias_in_context(&secret, &context).map_err(|err| {
         SlotError::AliasInContext {
             context: "statement-store slot",
@@ -366,6 +390,27 @@ fn timestamp_now_key() -> Vec<u8> {
     .concat()
 }
 
+fn network_suffix_key() -> Vec<u8> {
+    [
+        twox_128(b"NetworkSuffix").as_slice(),
+        twox_128(b"NetworkSuffix").as_slice(),
+    ]
+    .concat()
+}
+
+/// Read the runtime-wide suffix used for product-scoped proof contexts.
+pub async fn read_network_suffix(rpc: &RpcClient) -> Result<Vec<u8>, StatementAllowanceError> {
+    let bytes = rpc
+        .get_storage(&network_suffix_key())
+        .await?
+        .ok_or(SlotError::MissingNetworkSuffix)?;
+    let suffix = Vec::<u8>::decode_all(&mut &bytes[..]).map_err(SlotError::NetworkSuffixDecode)?;
+    if suffix.is_empty() || suffix.len() > MAX_NETWORK_SUFFIX_LENGTH {
+        return Err(SlotError::InvalidNetworkSuffixLength { len: suffix.len() }.into());
+    }
+    Ok(suffix)
+}
+
 /// The chain's clock in unix seconds, decoded from `Timestamp.Now` milliseconds.
 ///
 /// Slot ages are judged against this rather than the host clock, which runs up to
@@ -399,11 +444,12 @@ pub async fn replacement_cooldown(
 pub async fn read_slot_account_at(
     rpc: &RpcClient,
     entropy: [u8; 32],
+    network_suffix: &[u8],
     period: u32,
     seq: u32,
     block_hash: &str,
 ) -> Result<Option<[u8; 32]>, StatementAllowanceError> {
-    let alias = slot_alias(entropy, period, seq)?;
+    let alias = slot_alias(entropy, network_suffix, period, seq)?;
     let key = statement_store_allowance_key(period, &alias);
     Ok(rpc
         .get_storage_at(&key, block_hash)
@@ -441,6 +487,8 @@ pub struct SlotScan<'a> {
     pub collection: PersonhoodCollection,
     /// Our bandersnatch entropy for `collection`.
     pub entropy: [u8; 32],
+    /// Runtime-wide suffix used for product-scoped aliases.
+    pub network_suffix: &'a [u8],
     /// Statement-store period to scan.
     pub period: u32,
     /// Account whose existing slot, if any, should be reported.
@@ -461,6 +509,7 @@ pub async fn scan_slot_excluding(
     let SlotScan {
         collection,
         entropy,
+        network_suffix,
         period,
         target,
         excluded,
@@ -471,7 +520,7 @@ pub async fn scan_slot_excluding(
     let mut excluded_free = false;
     let mut occupied = Vec::new();
     for seq in 0..max {
-        let alias = slot_alias(entropy, period, seq)?;
+        let alias = slot_alias(entropy, network_suffix, period, seq)?;
         let key = statement_store_allowance_key(period, &alias);
         match rpc.get_storage(&key).await? {
             None => {
@@ -619,6 +668,7 @@ mod tests {
     /// `LiteStmtStoreSlotsPerPeriod` is 10.
     const FIXTURE: &[u8] = include_bytes!("../../../tests/fixtures/paseo-next-v2-metadata.scale");
     const SLOTS: usize = 10;
+    const NETWORK_SUFFIX: &[u8] = b"paseo";
 
     /// `StmtStoreAllowanceEntry { account_id, seq: 0, since: 0 }` as a scripted
     /// JSON storage result.
@@ -657,6 +707,7 @@ mod tests {
             SlotScan {
                 collection: PersonhoodCollection::LitePeople,
                 entropy: [0x11; 32],
+                network_suffix: NETWORK_SUFFIX,
                 period: 7,
                 target: &[0x22; 32],
                 excluded: &[],
@@ -730,6 +781,7 @@ mod tests {
                 SlotScan {
                     collection: PersonhoodCollection::LitePeople,
                     entropy: [0x11; 32],
+                    network_suffix: NETWORK_SUFFIX,
                     period: 7,
                     target: &[0x22; 32],
                     excluded: &[],
@@ -901,6 +953,7 @@ mod tests {
             SlotScan {
                 collection: PersonhoodCollection::LitePeople,
                 entropy: [0x11; 32],
+                network_suffix: NETWORK_SUFFIX,
                 period: 7,
                 target: &[0x22; 32],
                 excluded: &[(SLOTS - 1) as u32],
@@ -1004,12 +1057,86 @@ mod tests {
     }
 
     #[test]
-    fn slot_context_layout() {
-        let ctx = derive_slot_context(7, 3);
-        assert_eq!(&ctx[..9], b"SSS_SLOT:");
-        assert_eq!(&ctx[9..13], &7u32.to_be_bytes());
-        assert_eq!(&ctx[13..17], &3u32.to_be_bytes());
-        assert!(ctx[17..].iter().all(|&b| b == 0x20));
+    fn statement_slot_context_matches_mobile_clients_and_runtime() {
+        let expected: [u8; 32] =
+            hex::decode("b6c21225dcf4c2aeeca32b6db1fc93b6942ca0e8ff5c3cb1b2c5d8f0b4647ee3")
+                .unwrap()
+                .try_into()
+                .unwrap();
+
+        assert_eq!(derive_slot_context(NETWORK_SUFFIX, 100, 3), expected);
+    }
+
+    #[test]
+    fn statement_slot_context_is_scoped_to_the_network() {
+        assert_ne!(
+            derive_slot_context(b"paseo", 100, 3),
+            derive_slot_context(b"polkadot", 100, 3),
+        );
+    }
+
+    #[test]
+    fn network_suffix_is_read_from_chain_storage() {
+        let scripted = ScriptedRpc::new(vec![r#""0x14706173656f""#]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted));
+
+        assert_eq!(
+            futures::executor::block_on(read_network_suffix(&rpc)).unwrap(),
+            b"paseo",
+        );
+    }
+
+    #[test]
+    fn missing_network_suffix_is_rejected() {
+        let scripted = ScriptedRpc::new(vec!["null"]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted));
+
+        assert!(matches!(
+            futures::executor::block_on(read_network_suffix(&rpc)),
+            Err(StatementAllowanceError::Slot(
+                SlotError::MissingNetworkSuffix
+            )),
+        ));
+    }
+
+    #[test]
+    fn malformed_network_suffix_is_rejected() {
+        let malformed = ScriptedRpc::new(vec![r#""0x14""#]);
+        let malformed_rpc = RpcClient::new(HostRpcClient::new(malformed));
+
+        assert!(matches!(
+            futures::executor::block_on(read_network_suffix(&malformed_rpc)),
+            Err(StatementAllowanceError::Slot(
+                SlotError::NetworkSuffixDecode(_)
+            )),
+        ));
+    }
+
+    #[test]
+    fn empty_network_suffix_is_rejected() {
+        let empty = ScriptedRpc::new(vec![r#""0x00""#]);
+        let empty_rpc = RpcClient::new(HostRpcClient::new(empty));
+
+        assert!(matches!(
+            futures::executor::block_on(read_network_suffix(&empty_rpc)),
+            Err(StatementAllowanceError::Slot(
+                SlotError::InvalidNetworkSuffixLength { len: 0 }
+            )),
+        ));
+    }
+
+    #[test]
+    fn oversized_network_suffix_is_rejected() {
+        let oversized_response = format!(r#""0x{}""#, hex::encode(vec![0x44; 18]));
+        let oversized = ScriptedRpc::new([oversized_response.as_str()]);
+        let oversized_rpc = RpcClient::new(HostRpcClient::new(oversized));
+
+        assert!(matches!(
+            futures::executor::block_on(read_network_suffix(&oversized_rpc)),
+            Err(StatementAllowanceError::Slot(
+                SlotError::InvalidNetworkSuffixLength { len: 17 }
+            )),
+        ));
     }
 
     #[test]
diff --git a/rust/crates/truapi-server/src/test_support.rs b/rust/crates/truapi-server/src/test_support.rs
index 633a555ab..43c1ccf77 100644
--- a/rust/crates/truapi-server/src/test_support.rs
+++ b/rust/crates/truapi-server/src/test_support.rs
@@ -1318,9 +1318,28 @@ fn method_keyed_responses(
                         serde_json::from_str(&request).expect("request is valid JSON");
                     let id = value["id"].as_str().expect("request carries a string id");
                     let method = value["method"].as_str().expect("request carries a method");
+                    let occurrence = sent
+                        .lock()
+                        .expect("rpc list mutex poisoned")
+                        .iter()
+                        .take(answered)
+                        .filter(|request| {
+                            serde_json::from_str::<serde_json::Value>(request)
+                                .ok()
+                                .and_then(|value| value["method"].as_str().map(str::to_owned))
+                                .is_some_and(|candidate| candidate == method)
+                        })
+                        .count();
                     let result = answers
                         .iter()
-                        .find(|(candidate, _)| *candidate == method)
+                        .filter(|(candidate, _)| *candidate == method)
+                        .nth(occurrence)
+                        .or_else(|| {
+                            answers
+                                .iter()
+                                .rev()
+                                .find(|(candidate, _)| *candidate == method)
+                        })
                         .map(|(_, body)| body.clone())
                         .unwrap_or_else(|| panic!("no scripted response for method `{method}`"));
                     return Some((

From 01a932128b2048c2cc36fba972ef4eed38346c6d Mon Sep 17 00:00:00 2001
From: pgherveou <pgherveou@gmail.com>
Date: Thu, 3 Sep 2026 11:37:41 +0200
Subject: [PATCH 2/4] fix: adopt current proof contexts

Remove legacy LTS and PGAS contexts and scope every proof family by the live network suffix. Follow the generation-prefixed Asset Hub ring-root layout used by current mobile clients and runtime.
---
 rust/crates/truapi-host-cli/src/main.rs       |   5 +
 .../truapi-host-cli/tests/live_asset_hub.rs   |  18 +-
 .../src/runtime/signing_host/sso_responder.rs |  21 ++-
 .../src/runtime/statement_allowance.rs        |  41 ++++-
 .../src/runtime/statement_allowance/pgas.rs   | 105 ++++++++---
 .../src/runtime/statement_allowance/proof.rs  |   4 +-
 .../src/runtime/statement_allowance/ring.rs   |   2 +-
 .../src/runtime/statement_allowance/slot.rs   | 174 ++++++++++++------
 .../truapi-server/tests/fixtures/README.md    |   7 +-
 9 files changed, 273 insertions(+), 104 deletions(-)

diff --git a/rust/crates/truapi-host-cli/src/main.rs b/rust/crates/truapi-host-cli/src/main.rs
index 42bb3a267..323672608 100644
--- a/rust/crates/truapi-host-cli/src/main.rs
+++ b/rust/crates/truapi-host-cli/src/main.rs
@@ -642,6 +642,9 @@ async fn run_pgas_check(
     let asset_hub_state = alloc::fetch_chain_state(&asset_hub_rpc)
         .await
         .map_err(anyhow::Error::msg)?;
+    let network_suffix = alloc::slot::read_network_suffix(&asset_hub_rpc)
+        .await
+        .map_err(anyhow::Error::msg)?;
     println!(
         "asset hub: metadata V{} specVersion={} txVersion={} genesis=0x{}",
         asset_hub_metadata.metadata_version(),
@@ -715,6 +718,7 @@ async fn run_pgas_check(
         &asset_hub_metadata,
         ring.collection,
         membership.entropy,
+        &network_suffix,
         day,
         &[],
     )
@@ -738,6 +742,7 @@ async fn run_pgas_check(
         people_rpc: &people_rpc,
         people_metadata: &people_metadata,
         entropy: membership.entropy,
+        network_suffix: &network_suffix,
         target: &target,
         ring: &membership.ring,
     })
diff --git a/rust/crates/truapi-host-cli/tests/live_asset_hub.rs b/rust/crates/truapi-host-cli/tests/live_asset_hub.rs
index 693104035..13794aa0a 100644
--- a/rust/crates/truapi-host-cli/tests/live_asset_hub.rs
+++ b/rust/crates/truapi-host-cli/tests/live_asset_hub.rs
@@ -22,8 +22,8 @@ fn asset_hub_ws() -> String {
 }
 const PEOPLE_WS: &str = "wss://paseo-people-next-system-rpc.polkadot.io";
 
-/// The ring our onboarded test identity sits in.
-const RING_INDEX: u32 = 2;
+/// An active lite-person ring mirrored to Asset Hub.
+const RING_INDEX: u32 = 1;
 /// The ring this fixture's index belongs to.
 const COLLECTION: PersonhoodCollection = PersonhoodCollection::LitePeople;
 
@@ -37,6 +37,20 @@ async fn asset_hub() -> (alloc::rpc::RpcClient, alloc::extension::Metadata) {
     (rpc, metadata)
 }
 
+#[tokio::test]
+#[ignore = "needs network access to a live Asset Hub"]
+async fn live_asset_hub_reports_the_product_context_suffix() {
+    let (rpc, _metadata) = asset_hub().await;
+    let expected = std::env::var("LIVE_TLD").unwrap_or_else(|_| "paseo".to_string());
+
+    assert_eq!(
+        alloc::slot::read_network_suffix(&rpc)
+            .await
+            .expect("read Asset Hub NetworkSuffix"),
+        expected.as_bytes(),
+    );
+}
+
 /// The claim encodes five fields for `AsPgas::Claim`. A short payload is accepted
 /// locally and then panics the runtime inside `validate_transaction`, which is how
 /// the missing `revision` on the statement-store claim went unnoticed.
diff --git a/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs b/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
index 5c96daf91..0eae554e1 100644
--- a/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
+++ b/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
@@ -1210,6 +1210,7 @@ pub(super) async fn allocate_bulletin_allowance(
         .await?;
     let people_rpc = people_client.rpc();
     let chain = services.chain_context.get(&people_client).await?;
+    let network_suffix = statement_allowance::slot::read_network_suffix(people_rpc).await?;
     let session = signing_host
         .current_session()
         .ok_or(AuthorityError::Disconnected)?;
@@ -1237,15 +1238,16 @@ pub(super) async fn allocate_bulletin_allowance(
         current_unix_secs()?,
         period_duration,
     )?;
-    let outcome = claim_long_term_storage(
-        people_rpc,
-        &chain.metadata,
-        &chain.state,
-        membership.entropy,
-        &target,
+    let outcome = claim_long_term_storage(statement_allowance::LongTermStorageClaim {
+        rpc: people_rpc,
+        metadata: &chain.metadata,
+        chain_state: &chain.state,
+        entropy: membership.entropy,
+        network_suffix: &network_suffix,
+        target: &target,
         period,
-        &membership.ring,
-    )
+        ring: &membership.ring,
+    })
     .await?;
     let statement_allowance::LongTermStorageOutcome::Claimed {
         block_hash,
@@ -1353,6 +1355,8 @@ pub(super) async fn allocate_smart_contract_allowance(
         debug!(%product_id, "PGAS allowance already funded; leaving it alone");
         return Ok(());
     }
+    let network_suffix =
+        statement_allowance::slot::read_network_suffix(asset_hub_client.rpc()).await?;
 
     let people_client = services
         .statement_store
@@ -1376,6 +1380,7 @@ pub(super) async fn allocate_smart_contract_allowance(
         people_rpc,
         people_metadata: &people.metadata,
         entropy: membership.entropy,
+        network_suffix: &network_suffix,
         target: &target,
         ring: &membership.ring,
     })
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance.rs b/rust/crates/truapi-server/src/runtime/statement_allowance.rs
index 4e3f4757d..62f13b190 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance.rs
@@ -441,6 +441,26 @@ pub enum LongTermStorageOutcome {
     },
 }
 
+/// Everything one long-term-storage claim needs.
+pub struct LongTermStorageClaim<'a> {
+    /// People connection the claim is submitted on.
+    pub rpc: &'a RpcClient,
+    /// People runtime metadata.
+    pub metadata: &'a Metadata,
+    /// People signed-extension state.
+    pub chain_state: &'a ChainState,
+    /// Our ring-VRF entropy for the collection `ring` names.
+    pub entropy: [u8; 32],
+    /// People suffix used for the product-scoped alias and proof.
+    pub network_suffix: &'a [u8],
+    /// Account whose Bulletin allowance is authorized.
+    pub target: &'a [u8; 32],
+    /// People long-term-storage period.
+    pub period: u32,
+    /// Ring the membership proof is built against.
+    pub ring: &'a RingParams,
+}
+
 /// Bulletin authorization state for one account.
 #[derive(Debug, Clone, Copy)]
 pub struct BulletinAllowanceInfo {
@@ -1004,14 +1024,18 @@ pub async fn register_statement_account_pooled(
 /// Claim long-term Bulletin storage authorization for `target`, proving
 /// membership in the already-located `ring`, at People-chain `period`.
 pub async fn claim_long_term_storage(
-    rpc: &RpcClient,
-    metadata: &Metadata,
-    chain_state: &ChainState,
-    entropy: [u8; 32],
-    target: &[u8; 32],
-    period: u32,
-    ring: &RingParams,
+    params: LongTermStorageClaim<'_>,
 ) -> Result<LongTermStorageOutcome, StatementAllowanceError> {
+    let LongTermStorageClaim {
+        rpc,
+        metadata,
+        chain_state,
+        entropy,
+        network_suffix,
+        target,
+        period,
+        ring,
+    } = params;
     let revision = ring::read_ring_revision(
         rpc,
         metadata,
@@ -1026,12 +1050,13 @@ pub async fn claim_long_term_storage(
             rpc,
             metadata,
             entropy,
+            network_suffix,
             period,
             &skipped_duplicate_counters,
         )
         .await?;
 
-        let context = slot::derive_long_term_storage_context(period, counter);
+        let context = slot::derive_long_term_storage_context(network_suffix, period, counter);
         let call =
             extrinsic::build_claim_long_term_storage_call(metadata, period, counter, target)?;
         let message = extension::build_proof_message(metadata, &call, chain_state)?;
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
index 0464f5bbe..7d1a778cd 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
@@ -21,7 +21,7 @@ use thiserror::Error;
 
 use super::collection::PersonhoodCollection;
 use super::extension::{AS_PGAS, Metadata, MetadataError};
-use super::ring::{self, RingParams, blake2_128_concat};
+use super::ring::{self, RingParams, blake2_128_concat, twox_64_concat};
 use super::rpc::RpcClient;
 use super::{
     ChainContext, StatementAllowanceError, duplicate_submit_error, extension, extrinsic, proof,
@@ -55,6 +55,9 @@ pub enum PgasError {
         /// Revision the proof was built against.
         revision: u32,
     },
+    /// `MembersSubscriber.CurrentGeneration` was not a SCALE-encoded `u32`.
+    #[error("MembersSubscriber.CurrentGeneration: {0}")]
+    GenerationDecode(#[source] parity_scale_codec::Error),
     /// The asset account's leading balance failed to decode.
     #[error("PGAS balance: {0}")]
     BalanceDecode(#[source] parity_scale_codec::Error),
@@ -92,15 +95,30 @@ pub struct PgasClaimOutcome {
     pub ring_index: u32,
 }
 
-/// `MembersSubscriber.RingRoots[(identifier, ring_index)]` storage key on Asset
-/// Hub.
-///
-/// Both map keys are `Blake2_128Concat` here, unlike the People chain's
-/// `Members` maps which take the collection identifier verbatim.
-fn ring_roots_key(collection: PersonhoodCollection, ring_index: u32) -> Vec<u8> {
+fn current_generation_key() -> Vec<u8> {
+    [
+        twox_128(b"MembersSubscriber").as_slice(),
+        twox_128(b"CurrentGeneration").as_slice(),
+    ]
+    .concat()
+}
+
+async fn read_current_generation(rpc: &RpcClient) -> Result<u32, StatementAllowanceError> {
+    match rpc.get_storage(&current_generation_key()).await? {
+        Some(bytes) => u32::decode(&mut &bytes[..])
+            .map_err(PgasError::GenerationDecode)
+            .map_err(Into::into),
+        None => Ok(0),
+    }
+}
+
+/// `MembersSubscriber.RingRoots[(generation, identifier, ring_index)]` storage
+/// key on Asset Hub.
+fn ring_roots_key(generation: u32, collection: PersonhoodCollection, ring_index: u32) -> Vec<u8> {
     [
         twox_128(b"MembersSubscriber").as_slice(),
         twox_128(b"RingRoots").as_slice(),
+        &twox_64_concat(&generation.to_le_bytes()),
         &blake2_128_concat(collection.identifier()),
         &blake2_128_concat(&ring_index.to_le_bytes()),
     ]
@@ -120,6 +138,8 @@ pub struct PgasClaim<'a> {
     pub people_metadata: &'a Metadata,
     /// Our ring-VRF entropy for the collection `ring` names.
     pub entropy: [u8; 32],
+    /// Asset Hub suffix used for the product-scoped alias and proof.
+    pub network_suffix: &'a [u8],
     /// Account the claim credits.
     pub target: &'a [u8; 32],
     /// Ring the membership proof is built against, already located on People.
@@ -174,6 +194,7 @@ pub async fn claim_pgas(
         people_rpc,
         people_metadata,
         entropy,
+        network_suffix,
         target,
         ring,
     } = params;
@@ -206,11 +227,12 @@ pub async fn claim_pgas(
             asset_hub_metadata,
             ring.collection,
             entropy,
+            network_suffix,
             day,
             &skipped_duplicate_slots,
         )
         .await?;
-        let context = slot::derive_pgas_context(day, slot_index);
+        let context = slot::derive_pgas_context(network_suffix, day, slot_index);
         let call = extrinsic::build_claim_pgas_call(asset_hub_metadata, slot_index, target)?;
         let message = extension::build_proof_message_after_extension(
             asset_hub_metadata,
@@ -245,6 +267,7 @@ pub async fn claim_pgas(
                 if !slot::pgas_slot_is_claimed_at(
                     asset_hub_rpc,
                     entropy,
+                    network_suffix,
                     day,
                     slot_index,
                     &block_hash,
@@ -322,10 +345,11 @@ pub async fn await_ring_revision(
             pallet: "MembersSubscriber",
             entry: "RingRoots",
         })?;
+    let generation = read_current_generation(rpc).await?;
     let started = Instant::now();
     loop {
         if let Some(bytes) = rpc
-            .get_storage(&ring_roots_key(collection, ring_index))
+            .get_storage(&ring_roots_key(generation, collection, ring_index))
             .await?
         {
             let mut input = bytes.as_slice();
@@ -380,9 +404,10 @@ mod tests {
     use super::super::test_fixtures;
     use super::*;
 
-    /// The collection the captured roots were read from. `RingRoots` is keyed by
-    /// collection, so the fixture only means anything paired with this one.
+    /// The collection the captured roots were read from. The fixture only means
+    /// anything paired with this identifier.
     const CAPTURED_COLLECTION: PersonhoodCollection = PersonhoodCollection::LitePeople;
+    const TEST_GENERATION: u32 = 7;
 
     /// The captured ring-5 roots as a scripted `state_getStorage` result, with the
     /// transport handle so the key that was read can be checked.
@@ -391,7 +416,8 @@ mod tests {
             r#""0x{}""#,
             hex::encode(test_fixtures::ASSET_HUB_RING_5_ROOTS)
         );
-        let scripted = ScriptedRpc::new([value.as_str()]);
+        let generation = format!(r#""0x{}""#, hex::encode(TEST_GENERATION.to_le_bytes()));
+        let scripted = ScriptedRpc::new([generation.as_str(), value.as_str()]);
         (
             RpcClient::new(HostRpcClient::new(scripted.clone())),
             scripted,
@@ -413,12 +439,24 @@ mod tests {
             CAPTURED_UNDER,
             "the committed blob was read under the lite-people identifier",
         );
-        let expected = format!(
+        let current_generation = format!(
+            r#"["0x{}"]"#,
+            hex::encode(
+                [
+                    twox_128(b"MembersSubscriber").as_slice(),
+                    twox_128(b"CurrentGeneration").as_slice(),
+                ]
+                .concat()
+            )
+        );
+        let generation = twox_64_concat(&TEST_GENERATION.to_le_bytes());
+        let ring_roots = format!(
             r#"["0x{}"]"#,
             hex::encode(
                 [
                     twox_128(b"MembersSubscriber").as_slice(),
                     twox_128(b"RingRoots").as_slice(),
+                    &generation,
                     &blake2_128_concat(CAPTURED_UNDER),
                     &blake2_128_concat(&5u32.to_le_bytes()),
                 ]
@@ -433,8 +471,8 @@ mod tests {
             .collect();
         assert_eq!(
             reads,
-            vec![expected],
-            "the captured blob has to be paired with the collection it was read for"
+            vec![current_generation, ring_roots],
+            "the roots read must use the current generation and the fixture collection"
         );
     }
 
@@ -507,25 +545,50 @@ mod tests {
         assert_read_ring_5_of(&scripted);
     }
 
-    /// Both map keys are hashed here, unlike the People chain's `Members` maps.
+    /// The generation uses `Twox64Concat`; the remaining two keys use
+    /// `Blake2_128Concat`.
     #[test]
-    fn subscriber_ring_key_hashes_both_map_keys() {
+    fn subscriber_ring_key_hashes_all_three_map_keys() {
         let collection = PersonhoodCollection::LitePeople;
-        let key = ring_roots_key(collection, 136);
+        let key = ring_roots_key(7, collection, 136);
 
-        assert_eq!(key.len(), 16 + 16 + 16 + 32 + 16 + 4);
+        assert_eq!(key.len(), 16 + 16 + 8 + 4 + 16 + 32 + 16 + 4);
         assert_eq!(
-            &key[48..80],
+            &key[40..44],
+            &7u32.to_le_bytes(),
+            "generation follows its hash"
+        );
+        assert_eq!(
+            &key[60..92],
             collection.identifier(),
             "identifier follows its hash"
         );
         assert_eq!(
-            &key[96..],
+            &key[108..],
             &136u32.to_le_bytes(),
             "ring index is little-endian"
         );
     }
 
+    #[test]
+    fn missing_current_generation_uses_the_runtime_default() {
+        let scripted = ScriptedRpc::new(["null"]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
+
+        assert_eq!(
+            futures::executor::block_on(read_current_generation(&rpc)).unwrap(),
+            0
+        );
+        assert_eq!(
+            scripted.calls(),
+            vec![(
+                "state_getStorage".to_string(),
+                r#"["0xc8d053ab324196afc756c5ae3fbd2917c2dbc4fc2f665a39ada06f0965cccf86"]"#
+                    .to_string(),
+            )]
+        );
+    }
+
     /// `holds_a_full_claim` reads both of these from the runtime, and compares a
     /// balance against the claim amount. A missing constant would make the warm
     /// check answer the same way for every account.
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/proof.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/proof.rs
index 942b07676..0f8792971 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/proof.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/proof.rs
@@ -117,7 +117,7 @@ mod tests {
             RingDomainSize::Domain11,
             entropy,
             &members,
-            b"SSS_SLOT:test-context-padding..",
+            &[0x33; 32],
             &[0x42; 32],
         )
         .unwrap();
@@ -132,7 +132,7 @@ mod tests {
             RingDomainSize::Domain11,
             entropy,
             &[other],
-            b"SSS_SLOT:test-context-padding..",
+            &[0x33; 32],
             &[0x42; 32],
         )
         .unwrap_err();
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/ring.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/ring.rs
index 534f08c59..4edda67f8 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/ring.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/ring.rs
@@ -199,7 +199,7 @@ pub(super) fn blake2_128_concat(x: &[u8]) -> Vec<u8> {
 }
 
 /// `Twox64Concat(x)` = `twox_64(x) ‖ x`.
-fn twox_64_concat(x: &[u8]) -> Vec<u8> {
+pub(super) fn twox_64_concat(x: &[u8]) -> Vec<u8> {
     [twox_64(x).as_slice(), x].concat()
 }
 
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
index b25d09001..bd3326260 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
@@ -23,13 +23,11 @@ use super::view;
 /// StatementStore allowance period: one UTC day, in seconds.
 pub const STATEMENT_STORE_PERIOD_SECONDS: u64 = 86_400;
 const PRODUCT_CONTEXT_PREFIX: &[u8] = b"product/peopl.";
-const STATEMENT_STORE_CONTEXT_PREFIX: &[u8] = b"sys/";
+const SYSTEM_CONTEXT_PREFIX: &[u8] = b"sys/";
 const STATEMENT_STORE_CONTEXT_FAMILY: u32 = 2;
+const LONG_TERM_STORAGE_CONTEXT_FAMILY: u32 = 3;
+const PGAS_CONTEXT_FAMILY: u32 = 4;
 const MAX_NETWORK_SUFFIX_LENGTH: usize = 16;
-/// Bulletin long-term-storage claim context prefix.
-const LONG_TERM_STORAGE_CONTEXT_PREFIX: &[u8] = b"pop:polkadot.net/rsc-lts";
-/// Ring-VRF alias context prefix for an Asset Hub PGAS claim.
-const PGAS_CONTEXT_PREFIX: &[u8] = b"pop:gas:";
 /// Slots probed per batched storage read while scanning for a free PGAS slot.
 ///
 /// Reading every slot in one request would cost a round trip flat, but each slot's
@@ -168,13 +166,12 @@ pub fn current_long_term_storage_period(
     Ok((now_seconds / u64::from(period_duration)) as u32)
 }
 
-/// Derive the network-scoped 32-byte StatementStore slot context.
-pub fn derive_slot_context(network_suffix: &[u8], period: u32, seq: u32) -> [u8; 32] {
+fn derive_product_context(network_suffix: &[u8], family: u32, first: u32, second: u32) -> [u8; 32] {
     let mut suffix = [0u8; 32];
-    suffix[..4].copy_from_slice(STATEMENT_STORE_CONTEXT_PREFIX);
-    suffix[4..8].copy_from_slice(&STATEMENT_STORE_CONTEXT_FAMILY.to_le_bytes());
-    suffix[8..12].copy_from_slice(&period.to_le_bytes());
-    suffix[12..16].copy_from_slice(&seq.to_le_bytes());
+    suffix[..4].copy_from_slice(SYSTEM_CONTEXT_PREFIX);
+    suffix[4..8].copy_from_slice(&family.to_le_bytes());
+    suffix[8..12].copy_from_slice(&first.to_le_bytes());
+    suffix[12..16].copy_from_slice(&second.to_le_bytes());
 
     let mut preimage = Vec::with_capacity(
         PRODUCT_CONTEXT_PREFIX.len() + network_suffix.len() + b"/".len() + suffix.len(),
@@ -186,29 +183,28 @@ pub fn derive_slot_context(network_suffix: &[u8], period: u32, seq: u32) -> [u8;
     blake2_256(&preimage)
 }
 
-/// Derive the 32-byte Asset Hub PGAS claim context:
-/// `"pop:gas:" ‖ u32le(day) ‖ u32le(slot_index) ‖ zero fill`.
-///
-/// The mobile wallet writes the integers in little-endian order and the runtime
-/// verifies against the same bytes, so the layout is not ours to tidy.
-pub fn derive_pgas_context(day: u32, slot_index: u32) -> [u8; 32] {
-    let mut ctx = [0u8; 32];
-    ctx[..PGAS_CONTEXT_PREFIX.len()].copy_from_slice(PGAS_CONTEXT_PREFIX);
-    let offset = PGAS_CONTEXT_PREFIX.len();
-    ctx[offset..offset + 4].copy_from_slice(&day.to_le_bytes());
-    ctx[offset + 4..offset + 8].copy_from_slice(&slot_index.to_le_bytes());
-    ctx
+/// Derive the network-scoped 32-byte StatementStore slot context.
+pub fn derive_slot_context(network_suffix: &[u8], period: u32, seq: u32) -> [u8; 32] {
+    derive_product_context(network_suffix, STATEMENT_STORE_CONTEXT_FAMILY, period, seq)
+}
+
+/// Derive the network-scoped 32-byte Asset Hub PGAS claim context.
+pub fn derive_pgas_context(network_suffix: &[u8], day: u32, slot_index: u32) -> [u8; 32] {
+    derive_product_context(network_suffix, PGAS_CONTEXT_FAMILY, day, slot_index)
 }
 
-/// Derive the 32-byte Bulletin long-term-storage slot context:
-/// `"pop:polkadot.net/rsc-lts" ‖ u32be(period) ‖ counter ‖ zero fill`.
-pub fn derive_long_term_storage_context(period: u32, counter: u8) -> [u8; 32] {
-    let mut ctx = [0u8; 32];
-    ctx[..LONG_TERM_STORAGE_CONTEXT_PREFIX.len()].copy_from_slice(LONG_TERM_STORAGE_CONTEXT_PREFIX);
-    let offset = LONG_TERM_STORAGE_CONTEXT_PREFIX.len();
-    ctx[offset..offset + 4].copy_from_slice(&period.to_be_bytes());
-    ctx[offset + 4] = counter;
-    ctx
+/// Derive the network-scoped 32-byte Bulletin long-term-storage context.
+pub fn derive_long_term_storage_context(
+    network_suffix: &[u8],
+    period: u32,
+    counter: u8,
+) -> [u8; 32] {
+    derive_product_context(
+        network_suffix,
+        LONG_TERM_STORAGE_CONTEXT_FAMILY,
+        period,
+        u32::from(counter),
+    )
 }
 
 /// The slot alias for our `entropy` at `(period, seq)`.
@@ -232,11 +228,12 @@ pub fn slot_alias(
 /// The PGAS claim alias for our `entropy` at `(day, slot_index)`.
 pub fn pgas_alias(
     entropy: [u8; 32],
+    network_suffix: &[u8],
     day: u32,
     slot_index: u32,
 ) -> Result<[u8; 32], StatementAllowanceError> {
     let secret = BandersnatchVrfVerifiable::new_secret(entropy);
-    let context = derive_pgas_context(day, slot_index);
+    let context = derive_pgas_context(network_suffix, day, slot_index);
     BandersnatchVrfVerifiable::alias_in_context(&secret, &context).map_err(|err| {
         SlotError::AliasInContext {
             context: "PGAS claim slot",
@@ -249,11 +246,12 @@ pub fn pgas_alias(
 /// The long-term-storage slot alias for our `entropy` at `(period, counter)`.
 pub fn long_term_storage_alias(
     entropy: [u8; 32],
+    network_suffix: &[u8],
     period: u32,
     counter: u8,
 ) -> Result<[u8; 32], StatementAllowanceError> {
     let secret = BandersnatchVrfVerifiable::new_secret(entropy);
-    let context = derive_long_term_storage_context(period, counter);
+    let context = derive_long_term_storage_context(network_suffix, period, counter);
     BandersnatchVrfVerifiable::alias_in_context(&secret, &context).map_err(|err| {
         SlotError::AliasInContext {
             context: "long-term-storage slot",
@@ -571,11 +569,12 @@ pub async fn scan_pgas_slot_excluding(
     metadata: &Metadata,
     collection: PersonhoodCollection,
     entropy: [u8; 32],
+    network_suffix: &[u8],
     day: u32,
     excluded: &[u32],
 ) -> Result<u32, StatementAllowanceError> {
     let max = max_pgas_claims(metadata, collection)?;
-    scan_pgas_slot_in(rpc, entropy, day, max, excluded).await
+    scan_pgas_slot_in(rpc, entropy, network_suffix, day, max, excluded).await
 }
 
 /// The scan itself, over a known slot count.
@@ -584,6 +583,7 @@ pub async fn scan_pgas_slot_excluding(
 async fn scan_pgas_slot_in(
     rpc: &RpcClient,
     entropy: [u8; 32],
+    network_suffix: &[u8],
     day: u32,
     max: u32,
     excluded: &[u32],
@@ -600,7 +600,8 @@ async fn scan_pgas_slot_in(
         let keys = batch
             .iter()
             .map(|&slot_index| {
-                pgas_alias(entropy, day, slot_index).map(|alias| claimed_gas_alias_key(day, &alias))
+                pgas_alias(entropy, network_suffix, day, slot_index)
+                    .map(|alias| claimed_gas_alias_key(day, &alias))
             })
             .collect::<Result<Vec<_>, _>>()?;
         let claimed = rpc.get_storage_many(&keys).await?;
@@ -624,11 +625,12 @@ async fn scan_pgas_slot_in(
 pub async fn pgas_slot_is_claimed_at(
     rpc: &RpcClient,
     entropy: [u8; 32],
+    network_suffix: &[u8],
     day: u32,
     slot_index: u32,
     block_hash: &str,
 ) -> Result<bool, StatementAllowanceError> {
-    let alias = pgas_alias(entropy, day, slot_index)?;
+    let alias = pgas_alias(entropy, network_suffix, day, slot_index)?;
     let key = claimed_gas_alias_key(day, &alias);
     Ok(rpc.get_storage_at(&key, block_hash).await?.is_some())
 }
@@ -639,6 +641,7 @@ pub async fn scan_long_term_storage_counter_excluding(
     rpc: &RpcClient,
     metadata: &Metadata,
     entropy: [u8; 32],
+    network_suffix: &[u8],
     period: u32,
     excluded: &[u8],
 ) -> Result<u8, StatementAllowanceError> {
@@ -647,7 +650,7 @@ pub async fn scan_long_term_storage_counter_excluding(
         if excluded.contains(&counter) {
             continue;
         }
-        let alias = long_term_storage_alias(entropy, period, counter)?;
+        let alias = long_term_storage_alias(entropy, network_suffix, period, counter)?;
         let key = spent_long_term_storage_alias_key(period, &alias);
         if rpc.get_storage(&key).await?.is_none() {
             return Ok(counter);
@@ -977,7 +980,7 @@ mod tests {
         // keys that exist, so the absent ones are simply missing from `changes`.
         let claimed: Vec<String> = (0..3u32)
             .map(|slot_index| {
-                let alias = pgas_alias(ENTROPY, DAY, slot_index).unwrap();
+                let alias = pgas_alias(ENTROPY, NETWORK_SUFFIX, DAY, slot_index).unwrap();
                 format!(
                     r#"["0x{}","0x"]"#,
                     hex::encode(claimed_gas_alias_key(DAY, &alias))
@@ -991,8 +994,15 @@ mod tests {
         let scripted = ScriptedRpc::new(vec![response.as_str()]);
         let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
 
-        let chosen =
-            futures::executor::block_on(scan_pgas_slot_in(&rpc, ENTROPY, DAY, 40, &[])).unwrap();
+        let chosen = futures::executor::block_on(scan_pgas_slot_in(
+            &rpc,
+            ENTROPY,
+            NETWORK_SUFFIX,
+            DAY,
+            40,
+            &[],
+        ))
+        .unwrap();
 
         assert_eq!(chosen, 3, "the first free slot, in order");
         let calls = scripted.calls();
@@ -1015,6 +1025,7 @@ mod tests {
             futures::executor::block_on(pgas_slot_is_claimed_at(
                 &RpcClient::new(HostRpcClient::new(spent)),
                 ENTROPY,
+                NETWORK_SUFFIX,
                 DAY,
                 0,
                 "0xb10c",
@@ -1025,6 +1036,7 @@ mod tests {
             !futures::executor::block_on(pgas_slot_is_claimed_at(
                 &RpcClient::new(HostRpcClient::new(absent)),
                 ENTROPY,
+                NETWORK_SUFFIX,
                 DAY,
                 0,
                 "0xb10c",
@@ -1033,16 +1045,15 @@ mod tests {
         );
     }
 
-    /// The PGAS context is little-endian where the other two are big-endian, and
-    /// the runtime verifies the proof against these exact bytes.
     #[test]
-    fn pgas_context_layout_is_little_endian() {
-        let ctx = derive_pgas_context(0x0102_0304, 0x0506_0708);
+    fn pgas_context_matches_mobile_clients_and_runtime() {
+        let expected: [u8; 32] =
+            hex::decode("e47ba2c7eae3b97beabaeef8df599afd53e44ba9c2b851cd80850d3ed95a685b")
+                .unwrap()
+                .try_into()
+                .unwrap();
 
-        assert_eq!(&ctx[..8], b"pop:gas:");
-        assert_eq!(&ctx[8..12], &[0x04, 0x03, 0x02, 0x01]);
-        assert_eq!(&ctx[12..16], &[0x08, 0x07, 0x06, 0x05]);
-        assert_eq!(&ctx[16..], &[0u8; 16]);
+        assert_eq!(derive_pgas_context(NETWORK_SUFFIX, 100, 3), expected);
     }
 
     /// `ClaimedGasAliases` is `Identity(u32be day) ‖ Blake2_128Concat(alias)`.
@@ -1068,10 +1079,15 @@ mod tests {
     }
 
     #[test]
-    fn statement_slot_context_is_scoped_to_the_network() {
-        assert_ne!(
-            derive_slot_context(b"paseo", 100, 3),
-            derive_slot_context(b"polkadot", 100, 3),
+    fn product_contexts_are_scoped_to_the_network() {
+        assert_eq!(
+            [
+                derive_slot_context(b"paseo", 100, 3) != derive_slot_context(b"polkadot", 100, 3),
+                derive_long_term_storage_context(b"paseo", 100, 3)
+                    != derive_long_term_storage_context(b"polkadot", 100, 3),
+                derive_pgas_context(b"paseo", 100, 3) != derive_pgas_context(b"polkadot", 100, 3),
+            ],
+            [true; 3],
         );
     }
 
@@ -1140,12 +1156,52 @@ mod tests {
     }
 
     #[test]
-    fn long_term_storage_context_layout() {
-        let ctx = derive_long_term_storage_context(7, 3);
-        assert_eq!(&ctx[..24], b"pop:polkadot.net/rsc-lts");
-        assert_eq!(&ctx[24..28], &7u32.to_be_bytes());
-        assert_eq!(ctx[28], 3);
-        assert!(ctx[29..].iter().all(|&b| b == 0));
+    fn long_term_storage_context_matches_mobile_clients_and_runtime() {
+        let expected: [u8; 32] =
+            hex::decode("1b3fbe4dd813ea1e349878c9228c6823db8345207690ca4df656acb7fee81bd1")
+                .unwrap()
+                .try_into()
+                .unwrap();
+
+        assert_eq!(
+            derive_long_term_storage_context(NETWORK_SUFFIX, 100, 3),
+            expected,
+        );
+    }
+
+    #[test]
+    fn long_term_storage_scan_uses_the_requested_network_suffix() {
+        const ENTROPY: [u8; 32] = [0x11; 32];
+        const PERIOD: u32 = 7;
+        const SUFFIX: &[u8] = b"previewnet";
+
+        let metadata = Metadata::decode(FIXTURE).unwrap();
+        let scripted = ScriptedRpc::new([r#""0x""#, "null"]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
+
+        let counter = futures::executor::block_on(scan_long_term_storage_counter_excluding(
+            &rpc,
+            &metadata,
+            ENTROPY,
+            SUFFIX,
+            PERIOD,
+            &[],
+        ))
+        .unwrap();
+        let calls = (0..=1)
+            .map(|counter| {
+                let alias = long_term_storage_alias(ENTROPY, SUFFIX, PERIOD, counter).unwrap();
+                (
+                    "state_getStorage".to_string(),
+                    format!(
+                        r#"["0x{}"]"#,
+                        hex::encode(spent_long_term_storage_alias_key(PERIOD, &alias))
+                    ),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        assert_eq!((counter, scripted.calls()), (1, calls));
     }
 
     #[test]
diff --git a/rust/crates/truapi-server/tests/fixtures/README.md b/rust/crates/truapi-server/tests/fixtures/README.md
index e1f6354f6..7161584a6 100644
--- a/rust/crates/truapi-server/tests/fixtures/README.md
+++ b/rust/crates/truapi-server/tests/fixtures/README.md
@@ -37,7 +37,7 @@ and replace both together. Re-capturing metadata alone will fail
 
 | File | Storage | Chain | Block | Captured |
 |---|---|---|---|---|
-| `paseo-next-asset-hub-ring-5-roots.scale` | `MembersSubscriber.RingRoots[(LitePeople, 5)]` | Paseo Asset Hub Next | `0xf25d4e330ade1ce230695976f019df50cdaf97c96b6996838af93b68550654f3` | 2026-08-17 |
+| `paseo-next-asset-hub-ring-5-roots.scale` | `MembersSubscriber.RingRoots[(generation, LitePeople, 5)]` | Paseo Asset Hub Next | `0xf25d4e330ade1ce230695976f019df50cdaf97c96b6996838af93b68550654f3` | 2026-08-17 |
 
 Ring 5 holds `[105, 106, 108]`. The skipped 107 is the case that distinguishes testing the
 newest held root from testing the oldest, and freezing it makes that case permanent
@@ -50,6 +50,7 @@ does, then call `state_getStorageAt`:
 ```
 twox_128("MembersSubscriber")
   ‖ twox_128("RingRoots")
+  ‖ twox_64_concat(current_generation_u32_le)
   ‖ blake2_128_concat(b"pop:polkadot.network/people-lite")
   ‖ blake2_128_concat(ring_index_u32_le)
 ```
@@ -60,8 +61,8 @@ curl -s -H 'Content-Type: application/json' \
   https://paseo-asset-hub-next-rpc.polkadot.io
 ```
 
-Both map keys are hashed here, unlike the People chain's `Members` maps, which take the
-collection identifier verbatim.
+Read `MembersSubscriber.CurrentGeneration` first. The generation uses `Twox64Concat`; the
+collection and ring index use `Blake2_128Concat`.
 
 ## Recapturing
 

From a6f8c4aeb3ff841e0d71f55448d1351a68109038 Mon Sep 17 00:00:00 2001
From: pgherveou <pgherveou@gmail.com>
Date: Thu, 3 Sep 2026 16:06:26 +0200
Subject: [PATCH 3/4] fix(server): harden the ring-root generation read and its
 test scripts

Address review on #587.

`read_current_generation` gates on the runtime declaring
`MembersSubscriber.CurrentGeneration` before treating an absent value as the
`ValueQuery` default, so a renamed pallet or item is named instead of reading as
generation 0, and decodes with `decode_all`, so an entry that stops being a bare
`u32` fails here rather than yielding the first four bytes of another layout.
Either way the failure would otherwise be a key nothing answers and a wait that
can only time out.

`await_ring_revision` re-reads the generation each poll. A rebuild landing during
the wait is what the loop waits through, and a generation read once up front
would key every remaining poll at a generation the roots have left.

`method_keyed_responses` panics when a method's scripted answers run out instead
of replaying the last one, so a script that answers fewer calls than the code
makes fails rather than feeding one read's response to another.

The Asset Hub fixture is recaptured at spec 3000000, which is what declares
`CurrentGeneration`, and the fixtures README records the generation the committed
ring-roots value is addressed under.

Pins the fourth statement-slot context vector iOS carries, family 2 at period 0
seq 0, where every suffix field is already zero and an offset slip would hide.
---
 .../src/runtime/statement_allowance/pgas.rs   |  85 ++++++++++++++++--
 .../src/runtime/statement_allowance/slot.rs   |  21 +++--
 .../statement_allowance/test_fixtures.rs      |   5 +-
 rust/crates/truapi-server/src/test_support.rs |  25 ++++--
 .../truapi-server/tests/fixtures/README.md    |  16 +++-
 .../paseo-next-asset-hub-metadata.scale       | Bin 672225 -> 687563 bytes
 6 files changed, 126 insertions(+), 26 deletions(-)

diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
index 7d1a778cd..5a2c96261 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
@@ -14,7 +14,7 @@
 
 use std::time::{Duration, Instant};
 
-use parity_scale_codec::Decode;
+use parity_scale_codec::{Decode, DecodeAll};
 use scale_decode::DecodeAsType;
 use sp_crypto_hashing::twox_128;
 use thiserror::Error;
@@ -103,9 +103,31 @@ fn current_generation_key() -> Vec<u8> {
     .concat()
 }
 
-async fn read_current_generation(rpc: &RpcClient) -> Result<u32, StatementAllowanceError> {
+/// The generation `RingRoots` is currently keyed under.
+///
+/// An absent value is the `ValueQuery` default, so it only means generation 0
+/// once the runtime is known to declare the entry. Checking the metadata first
+/// keeps a renamed pallet or item from reading as generation 0 and silently
+/// building keys nothing will ever answer.
+///
+/// Decoded with `decode_all`, so an entry that stops being a bare `u32` fails by
+/// name here instead of yielding the first four bytes of some other layout.
+async fn read_current_generation(
+    rpc: &RpcClient,
+    metadata: &Metadata,
+) -> Result<u32, StatementAllowanceError> {
+    if metadata
+        .storage_value_type("MembersSubscriber", "CurrentGeneration")
+        .is_none()
+    {
+        return Err(MetadataError::MissingStorageType {
+            pallet: "MembersSubscriber",
+            entry: "CurrentGeneration",
+        }
+        .into());
+    }
     match rpc.get_storage(&current_generation_key()).await? {
-        Some(bytes) => u32::decode(&mut &bytes[..])
+        Some(bytes) => u32::decode_all(&mut &bytes[..])
             .map_err(PgasError::GenerationDecode)
             .map_err(Into::into),
         None => Ok(0),
@@ -345,9 +367,13 @@ pub async fn await_ring_revision(
             pallet: "MembersSubscriber",
             entry: "RingRoots",
         })?;
-    let generation = read_current_generation(rpc).await?;
     let started = Instant::now();
     loop {
+        // Re-read per poll rather than once up front: a rebuild landing while we
+        // wait is exactly what this loop is waiting through, and a generation
+        // read from before it would key every remaining poll at a generation the
+        // roots have left, so the wait could only ever time out.
+        let generation = read_current_generation(rpc, metadata).await?;
         if let Some(bytes) = rpc
             .get_storage(&ring_roots_key(generation, collection, ring_index))
             .await?
@@ -409,6 +435,12 @@ mod tests {
     const CAPTURED_COLLECTION: PersonhoodCollection = PersonhoodCollection::LitePeople;
     const TEST_GENERATION: u32 = 7;
 
+    /// A real runtime that declares no `MembersSubscriber` at all, for the
+    /// metadata gate below. Preferred over a synthetic `Metadata` because the
+    /// gate is about a runtime not carrying the pallet, which is what this is.
+    const PEOPLE_METADATA: &[u8] =
+        include_bytes!("../../../tests/fixtures/paseo-next-v2-metadata-v16.scale");
+
     /// The captured ring-5 roots as a scripted `state_getStorage` result, with the
     /// transport handle so the key that was read can be checked.
     fn scripted_ring_5_roots() -> (RpcClient, ScriptedRpc) {
@@ -576,7 +608,8 @@ mod tests {
         let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
 
         assert_eq!(
-            futures::executor::block_on(read_current_generation(&rpc)).unwrap(),
+            futures::executor::block_on(read_current_generation(&rpc, test_fixtures::asset_hub()))
+                .unwrap(),
             0
         );
         assert_eq!(
@@ -589,6 +622,48 @@ mod tests {
         );
     }
 
+    /// A trailing byte means the entry is no longer a bare `u32`, which is the
+    /// same layout drift the three-key ring-root key exists to track. Taking the
+    /// first four bytes would build keys for a generation nothing answers, and
+    /// the wait would read as "the ring never arrived".
+    #[test]
+    fn a_current_generation_that_is_not_a_bare_u32_is_rejected() {
+        let overlong = format!(r#""0x{}""#, hex::encode([7u8, 0, 0, 0, 0]));
+        let scripted = ScriptedRpc::new([overlong.as_str()]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted));
+
+        let err =
+            futures::executor::block_on(read_current_generation(&rpc, test_fixtures::asset_hub()))
+                .expect_err("a five-byte value is not a u32");
+
+        assert_eq!(
+            err.to_string(),
+            "MembersSubscriber.CurrentGeneration: Input buffer has still data left after decoding!"
+        );
+    }
+
+    /// An absent value is only the `ValueQuery` default if the runtime declares
+    /// the entry at all. A renamed pallet or item reads as absent too, and
+    /// defaulting there would key every ring-root read at generation 0.
+    #[test]
+    fn a_runtime_without_current_generation_is_named_rather_than_defaulted() {
+        let people = Metadata::decode(PEOPLE_METADATA).unwrap();
+        let scripted = ScriptedRpc::new(["null"]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
+
+        let err = futures::executor::block_on(read_current_generation(&rpc, &people))
+            .expect_err("the People runtime declares no MembersSubscriber");
+
+        assert_eq!(
+            (err.to_string(), scripted.calls()),
+            (
+                "MembersSubscriber.CurrentGeneration type not in metadata".to_string(),
+                vec![],
+            ),
+            "the metadata check comes before the read, so nothing is asked of the chain",
+        );
+    }
+
     /// `holds_a_full_claim` reads both of these from the runtime, and compares a
     /// balance against the claim amount. A missing constant would make the warm
     /// check answer the same way for every account.
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
index bd3326260..761835c93 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
@@ -1067,15 +1067,24 @@ mod tests {
         assert_eq!(&key[52..], &alias, "alias follows its blake2_128 prefix");
     }
 
+    /// Both vectors are pinned against the mobile clients and the runtime. The
+    /// all-zero one is the offset check: every field of the suffix is already
+    /// zero there, so a field written at the wrong offset still hashes to this
+    /// answer only if the offsets agree.
     #[test]
     fn statement_slot_context_matches_mobile_clients_and_runtime() {
-        let expected: [u8; 32] =
-            hex::decode("b6c21225dcf4c2aeeca32b6db1fc93b6942ca0e8ff5c3cb1b2c5d8f0b4647ee3")
-                .unwrap()
-                .try_into()
-                .unwrap();
+        let vector = |hex: &str| -> [u8; 32] { hex::decode(hex).unwrap().try_into().unwrap() };
 
-        assert_eq!(derive_slot_context(NETWORK_SUFFIX, 100, 3), expected);
+        assert_eq!(
+            (
+                derive_slot_context(NETWORK_SUFFIX, 100, 3),
+                derive_slot_context(NETWORK_SUFFIX, 0, 0),
+            ),
+            (
+                vector("b6c21225dcf4c2aeeca32b6db1fc93b6942ca0e8ff5c3cb1b2c5d8f0b4647ee3"),
+                vector("deee1c90cf0d31093d318ac6629b4c4ab08650d4a4164511cc2496205f20f067"),
+            ),
+        );
     }
 
     #[test]
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/test_fixtures.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/test_fixtures.rs
index 61413f0d7..fc28cacb2 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/test_fixtures.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/test_fixtures.rs
@@ -14,9 +14,10 @@ use super::extension::Metadata;
 pub(crate) const ASSET_HUB_RING_5_ROOTS: &[u8] =
     include_bytes!("../../../tests/fixtures/paseo-next-asset-hub-ring-5-roots.scale");
 
-/// Asset Hub metadata captured from paseo Asset Hub Next at spec 2000036.
+/// Asset Hub metadata captured from paseo Asset Hub Next at spec 3000000.
 ///
-/// The only fixture declaring `AsPgas`, `Pgas` and `MembersSubscriber`.
+/// The only fixture declaring `AsPgas`, `Pgas` and `MembersSubscriber`, so it is
+/// also the only one that can exercise the ring-root generation.
 static ASSET_HUB: LazyLock<Metadata> = LazyLock::new(|| {
     Metadata::decode(include_bytes!(
         "../../../tests/fixtures/paseo-next-asset-hub-metadata.scale"
diff --git a/rust/crates/truapi-server/src/test_support.rs b/rust/crates/truapi-server/src/test_support.rs
index 43c1ccf77..8f5aa129d 100644
--- a/rust/crates/truapi-server/src/test_support.rs
+++ b/rust/crates/truapi-server/src/test_support.rs
@@ -1297,6 +1297,11 @@ impl JsonRpcConnection for RecordingConnection {
 
 /// Answer each request as it arrives, by method, echoing its id.
 ///
+/// Repeated entries for one method are answered in call order. Running past the
+/// last one panics rather than replaying it: a script that answers fewer calls
+/// than the code makes would otherwise hand a response meant for one read to a
+/// different one, which decodes to a plausible wrong value instead of failing.
+///
 /// Waits indefinitely for the next request rather than giving up after a fixed
 /// number of polls, so work between requests cannot race the pump.
 fn method_keyed_responses(
@@ -1330,18 +1335,20 @@ fn method_keyed_responses(
                                 .is_some_and(|candidate| candidate == method)
                         })
                         .count();
-                    let result = answers
+                    let scripted = answers
                         .iter()
                         .filter(|(candidate, _)| *candidate == method)
-                        .nth(occurrence)
-                        .or_else(|| {
-                            answers
-                                .iter()
-                                .rev()
-                                .find(|(candidate, _)| *candidate == method)
-                        })
+                        .collect::<Vec<_>>();
+                    let result = scripted
+                        .get(occurrence)
                         .map(|(_, body)| body.clone())
-                        .unwrap_or_else(|| panic!("no scripted response for method `{method}`"));
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "method `{method}` was called {} times, and the script has {} response(s) for it",
+                                occurrence + 1,
+                                scripted.len(),
+                            )
+                        });
                     return Some((
                         format!(r#"{{"jsonrpc":"2.0","id":"{id}","result":{result}}}"#),
                         answered + 1,
diff --git a/rust/crates/truapi-server/tests/fixtures/README.md b/rust/crates/truapi-server/tests/fixtures/README.md
index 7161584a6..45bda954f 100644
--- a/rust/crates/truapi-server/tests/fixtures/README.md
+++ b/rust/crates/truapi-server/tests/fixtures/README.md
@@ -13,7 +13,7 @@ expects.
 |---|---|---|---|---|---|
 | `paseo-next-v2-metadata.scale` | Paseo Next v2 | V14 | | | `AsResources`, three-field allowance info |
 | `paseo-next-v2-metadata-v16.scale` | Paseo Next v2 | V16 | 1000032 | | `AsResources`, four-field allowance info |
-| `paseo-next-asset-hub-metadata.scale` | Paseo Asset Hub Next | V16 | 2000036 | 2026-08-17 | `AsPgas`, `Pgas`, `MembersSubscriber` |
+| `paseo-next-asset-hub-metadata.scale` | Paseo Asset Hub Next | V16 | 3000000 | 2026-09-03 | `AsPgas`, `Pgas`, `MembersSubscriber` incl. `CurrentGeneration` |
 | `bulletin_paseo_metadata.scale` | Polkadot Bulletin (Paseo) | V14 | 1000020 | | preimage and storage calls |
 
 The two paseo-next-v2 fixtures deliberately disagree about arity: V14 predates the
@@ -35,15 +35,23 @@ fixture and the metadata beside it are a matched pair. Capture both from the sam
 and replace both together. Re-capturing metadata alone will fail
 `captured_ring_roots_project_to_their_revisions` if the record layout changed.
 
-| File | Storage | Chain | Block | Captured |
-|---|---|---|---|---|
-| `paseo-next-asset-hub-ring-5-roots.scale` | `MembersSubscriber.RingRoots[(generation, LitePeople, 5)]` | Paseo Asset Hub Next | `0xf25d4e330ade1ce230695976f019df50cdaf97c96b6996838af93b68550654f3` | 2026-08-17 |
+| File | Storage | Chain | Generation | Block | Captured |
+|---|---|---|---|---|---|
+| `paseo-next-asset-hub-ring-5-roots.scale` | `MembersSubscriber.RingRoots[(generation, LitePeople, 5)]` | Paseo Asset Hub Next | 0 | `0xf25d4e330ade1ce230695976f019df50cdaf97c96b6996838af93b68550654f3` | 2026-08-17 |
 
 Ring 5 holds `[105, 106, 108]`. The skipped 107 is the case that distinguishes testing the
 newest held root from testing the oldest, and freezing it makes that case permanent
 instead of dependent on a chain window that moves. Of the fourteen lite-people rings
 holding roots at that block, it was the only one that was not contiguous.
 
+The generation column is what the key's first term has to be to address this value.
+It is 0 because the block predates the generation term, so at that block the entry was
+addressed by the two remaining keys, and `MembersSubscriber.CurrentGeneration` is still
+unset on paseo Asset Hub Next, which reads as 0 through its `ValueQuery` default. A
+capture taken after the first rebuild has to record the generation it was read under, or
+the key recipe below will not reach it. The offline tests build the key from a synthetic
+generation and assert it separately, so they do not depend on this value.
+
 There is no CLI for a storage read by raw key. Build the key the way `pgas::ring_roots_key`
 does, then call `state_getStorageAt`:
 
diff --git a/rust/crates/truapi-server/tests/fixtures/paseo-next-asset-hub-metadata.scale b/rust/crates/truapi-server/tests/fixtures/paseo-next-asset-hub-metadata.scale
index e38a0bf5272fa463212489131d16ccca239917d3..dc510ac791e83487a6af6b9967c412d1cb189162 100644
GIT binary patch
delta 66181
zcmeFa3wRXO`9D5qX3p$xvLOk%-^d0MNFWIbB#?w~2@oJcfN)VjLb4<qSV^);b{9w$
zLlhKLkhtOzD+(&Ms1zvTNLy5FvE^G)(iSbXP|#9~iV`htsiMEnnVC&C3EKYu-{=2(
z{=duf1ZL)3-}9dLytnh7vls5p`1O|=N`u2=4?A*DnL@~)58XswkmT`%T=dz+rM?_1
z_1#Jn2j<Ooc-FXDR?YX;)j8M7f`j;u4Oo`ZD>c(L&)ev6HaI2-j|sNP_Ii6`jl(Sq
z4TK!l8hf86%k6|5)IRJ=64~r)Q|=M>5npH0GM~egj;yVwHgeQAz<jrSjF4l#3TvhB
zb91VEOhPILXtia8cwEvdkf1Db!Z$L=Cw5A{U2)5NgM&xP7bT<pgTcup&DR-x2g&u#
zw%+dhc}TS{BP2;Ik$vlxWxkPN)c1TytXwV|<%bMNAa>ux0qfE0YXk0)J7x69yZ=FG
zIyvn-6?zXji{`3)FNN7im-aR$Je^$kRfTU7!>O-IT;`iTaIl!Bzn&PFB4<!z;5S92
zkt|<R#6~e!&*i-@i5yA_eeIDO<nfg3)&}Q@N+S!AROS09DpzcvzRu8PzT2bI#oc-}
zDJEUqqo;0(H~Ail84d)rN7nj|#)kN^V~5MvDFE`%+tJvGGEsUZgs@#si`ln2E}fk5
zJsG!^T<~Sbw*j^v#c#&wPbF3PSVFeA(ZpxhmzJ0!c9?vV@cL|GJlXC$me?-tG5K<W
zmieAa$|6TlVS{)~D{<(>K@SfnVZO4mpH9gusdw7lB{elJ&;tk{jgTMKwl>-uoHbQV
z_7;1CyQs*{i&WW-GDSsmdAh^nXmJaYApD+nWzY$Srrz|liN9sF74$Bj9#EW^ZCZcR
z91gRPK}h$PAY>7;bWW4U>1r%C9tKrTm>>wk()k{Hy+f-ze~rV@RMv>@SKI5&LLut)
z%Cz?63IaQJzZfeE=u3kwsSj)c{R0AD#o}SPxkQfD0g&YdB%cs-*lbs$12BZmcQrU<
zA)g2W{`iBM(7o1hR-cA@gA@pnAdDyMy&M|vBlFTo$)REM9w4OR(2MhbE6NKA+2z~1
zIOfn(H%}xPCA}ai?GH(*4oRsmXi-*T8OfYn@2Xif+uN|*(LxG{Iku$6<6I4h%YE|~
z<&rXA*pexv+;?KpaJ>I*Q5LE24PKm`QPHcLvi{wa>D?^!wJy#LTa0|${3b_@v(8x~
z3zfc~ES?Z+C&WK#H#=&Iy#<&vR9eh?v{d3vTucPJZ|Rb>HV3iRI~!}At3h4$^$t%}
zqt2|V+#0uv)l<W!AQSi(h&;pHuaHa%de?FiQa`uFRqL(sOmTrS)_Qs|J3)}Yn(y$~
zJS!bzZAML--k;6ucGTLIx7yI3tx0bpt443bR_kbSuC{ZMbo-hgoKBp4JYoZ3%f`}J
z-}jf4k>*1empn^Iv+seWFX3ZK<!C~@ht@2+Ln8UUzuB8fD{Ed$q7L1@d>JqGhnk1T
zI$uNWAYP;P(Zps#(iapJ8H6s7^i?43DlDJX4)38!j$<UI8OT#WYF<34AhdE^%ECHd
z@`@Q^J7KeD)0ji+S3D$=jlTC*<s6!F8zW@nq4!qpHzDPIcOJla%^epDGEVI7CAG=X
zQnj4ZO1`hlJp!CP$x}<V9J<T%k_g6OTOVnP#M1IQ@_h@|3?@5#Yt~F7yAQpxCRs$O
zbFJx$UW!^99cy^`A!IM>dLAfQx_*YZg|OY#QXHE*mzsQUtdB_OAjEd7w_u!YOn#*x
zbYKKh309L;*dACivOQ(lj$V|wvp*&7L}mQ(hiuKq;w%t$_o}m}f1N#gojrk_9coV_
zdwpl{|32S0?bH0Tbn9K~Ws-mBkN14WA8+3O62ar{E%_qE&XEU4lf#EDKR85&oCtq7
z4-9qM!(;IOx`(IBM~StTwTGJH*s_C)>Cj&vJ|sgjJ-%ZEIqqBkM1m!;!Qpn>S2)Uj
zM~}z(=woqO`Y=7$9BX%j#@(BJVaU9FU(BJ$9)o1$HNT}q^r3$}p_nii<k=HMj1v#N
z`GeO*twQ{vz0ZXb<Mp@CLrM6KW>U$qL%a6fZ2EU))*l`z6R+>Uk(2+fr0J(NGsp?!
z2+3UTXmo%@IPER19ESKqD}TO02PYwL#MwaM#N%m@-;U#4N=-Z-?b~}i0(|P|@nHb)
z;_(Kn)@{O}#@`(Gk8<|ua^BYC@7N$zkG_+bb&-&q)p<olvs^XWf)!-Jd~?1m#ED4H
z4@k!%I^k2^E%S{!H_&H)cSKt!A-0>mjbN3oMi7^I(I~UfE3NmJh!Uf%z0<zyOG5d)
zux~HX)+l^?W+NZQqWsA3D)FD^QM5HCwom!q<L{IC9eC(nQbE&W6MLuqXJ2g`?f+R(
zUebh)3T*#*`F~q7qkHbZtEd?u`VO8cgK|0Pe6;WPe;RJQ#ho9jz0Czj?>N6;;8{Xq
zC%bA}%W4G@2K~u%!I$%%t>_FPsfI{Gjztho_hMVf?yF^-(b?7+-+k|0g)+PTkIzH@
zJ9s9-H}UKt==)!sofvirjryT?3&JJe<a7DtvTyCVq@~vhnNiYGQ+%sGf1GVp<pe<^
zURfYwzueKt)kswqX#d<i<Z6^C3l`DWbuLj15q+V5N)*FIU)G-zheh?TQh+MJ+GPww
z!at#l2wlF43-P}D{xp_c?Z%@1#<9rX{tXtd^~K`VURXqSUo2kJv3LzVU%&Y}hegz3
zA$UqqUO8Npze7jl?-u?J9>L#3_`9ONhx2!n{vO5OF*aT%PV_zV{)Dh3vDZ{2`96O?
zUrZ5wt>+S#=JrQUz+6DM^qr}IxhU+P8!#8+^|>g~=b}`fi?aSzjJZhRaPzrH6NNM%
z`HMCeVut7|IUmJI+W(5#&|l|#H&JI{(7lK{Lkv`%k==JXvH$@9$U^7mZqDW4;2#Gk
zpTG0zz<VKo=hK1r@%)`n2i{BgJD(1`m-2T$9e6L}?|eG&UM{jfq>^FKY%4!ZhJaZ2
zVX_!5`JVVNUaSyVRT_zg&DQy0LeN4~5*LfYVv&6x_8zHZC(=j;sr1eM>u`Jw8cHTY
zQ``M@CfUQXa!8!-o4>{({gt64k(^-f4JElTl_JS3_ttxyC7Srgdarf3Jtur`e-ce9
z*tTMl3bm+e7#U0U9Xj@niTDm)iSdPf90p|~<>M@95jmG5S$Q}Kfe35<I7d$~^=@T<
zI2mk|Jdi<@_<nsRHrUrX8=$PQQyFB0Q8a8gv7k{Mklf+Ght^r&wkM(jhb4+#nMll9
znc>9o$OsJa82c=r<Y5@q5hRJDu6YE>0d}rmj=}JMGJ<RcGRiVZG9J!MV)J9^>rcZ-
zyD#*!T(Z+w^4Sc%dEb+tJwOh!-IPosoxX-EL&Y<Mjf^I7<fL!^l|ksmH3cm>e4k#4
zMe8qQ17L@5WLGpkKF%h9$=BQ!g^$dUm?DSopqA4xl4KJvYnqCgI>G)pl8ge>p*bW;
zhb0lv=6n(9JMwwhAiGG4xn0sTTQDi@oB|x8;LwVF`T4*hPLU*PbIF;vwa(kvfEk|V
zZCv48?yPruS_Q$0vfPZn^@}Xhpw-*?MLcO{4e=xvYo+sxNc_)x{nr;m@s{$p3_w_A
zAu-S}6B5X<7_XmJtwJk*4FlO)q0aCA+fYmQ+_Fv!Nzl+3%l0OaY;lXo&Logx;I#Q_
z)adqJt88QcRkjf=W0moTY%bU=3Y!ldxf&v&8DIF4oTv^_o{t=1he%>MRu%vm9lnrj
zBcRo<x|Zf!cFn52%@Mcr3X?56(2&?63OjwKe`Uk_(fqGrzRG_^Xm7*C-C7|a{ZugK
zZLiP#<xS!~k<H8@<AV;0R_ofD2J`CCj8GEc`_Y%7z}_ogPT<4_G=+Z!0`ld46&rIz
zBn7uP>uY<ah!5e2ullQkf&J#?sPDP2#@{IU+E=MiB+)Y4IGBut3cmdMcyNJT*OSpL
zU-l>XP)>@%Ns+ykL-OTL;DB|ekrWW-q_5LRC!3Q?ipV9t^2O^S>xv-}Y(O!I(@OeM
zE=7`yY*I1FOyxCuEqrL8wr=f{@L?bC#{^_TF0uWi!5Ih(3kTbwY(hAe+eMa~M@EQL
zVw3VoWW<e{;+$Xvl}M)6=`?3O{2yRBYwV4lKu~(~1DRLwRech5!zMXr`0hSAhtME3
zSOjI42a+`LjL2-0z)B4+aa`vT$8|0d83<0S$62$=;kn4(o<ueSyWwL=ypHtdOcKj6
z+)+Y?^kNx=<xD2K{oOuU01&z~rg6<+8kbl|A$Z4ejcdf75lN(m5`oyfjohepv~c|S
zLc5Y90y1Mg_LdbKl5K?~ZD2q~q-#whs<6<hB(+xsqb>GzA-ImgXfCn?Q!#BiqcI2s
z>OdzOWF|4}UnUY9cUmOrd|7EgVQHP_BzHy>&hRp+L(cYPG8g(XnX`IhcbJJav==1^
z7xbJTnMpU(xu`Lni+aWY3%McN0nt5a0k`aAZ&}EoK+bYGkh6%Fbq3L8Fo<gb45Ev@
z6+}iuN%M0E{x(OvsxAIe*Z3H_MB#cb)&$`DDgYO;sQI77t_6c(Ut}pMq>$5KvYAA)
zbygBTEP#CAa^pM!N~c6p`I|A(0uuBZzq69$h<+#yk$lg8ReZzre|<GX3^6Ki3n3$+
z9k62|WRMso`Ho$WH$_1S5#uCQl7NLDHGrhaNs_@L#3adA@^va6Y;G<oB>C*v0Fp@-
zvMVtpQfCspEN2q1$yrG;8Ii^lG@#vvdJre}<q`m(qZn&oFWVam9?x|JnTSauJ1`ol
zi*-IxsqqQktSyfW7b|r}5qZPb4uq4G5tTRO6oKIM;S{_A=M*<?vw9*K`fqxj2tlnu
zYw(InjaQH~mOKgaPiGYz+x7@Byl~bug5*X8!eg)s4Dr+?vPnmKMJ9>S-#EJfs<)MZ
zcNVga1kB0F5^w=s%~-7S45NF_GsHB}*LVe*9m|d;@f@843c+yDf728)C^k*%&owwQ
zIoF5`$TYYHfa)j&dkDzU*#<JgrjjAOs_1+JIo}kLbc1p5nL9WY)MBV88qo{|a$;gJ
zoyeS1it#zw(pZu+&`U_za+j-KAckkCnLQCpW^myD8jDo}T_TR8@XrZx(3{q=WpU^z
zi8T%e4|*aFJSau#&4W@nRi{ZpnqKBi90?hcA@$LAvOod7w4DsSv@ITts28OPS$fXA
z_-;lNohy+%jnc~+-5$P~#MgPQUhc>7-@=#j*%YqdU`4%cf#Rl3>@-r!exE?b8`@5x
z6lhb7m-?}k@faJr;tyy$C6Z90E=weXBs9}J1T<DA>FQ1emZD$XDPuoRCZol2$ya|Z
zl`A~@>ugf4)nQL;QwHW%aHN$<!opq<01<teS{%3^AXv;U+t4T`Gs_D1d!;`1mJ|{{
zG=R>#d78a1PqXV4PNaaP^_v`r&eCp_4wgn7yzaCNXD?72`Xj4BM^=O0)!zogx~OC^
zL$pWH5D;=@AHIR1HETF2Z7}fY4Zx$9qX=!b_UbpOKZ=rc6s^;zq}^z0V?a~wEGw1d
z#`UH%D6zbUc1hUG)})d_iO`XYSC1|#>QNK<7L@tsJQ*_hU@D1<0IJiu!_VNlupPIs
zGpQt9?2vrRJ{%<OmV9^Ou}?D!Ne5e&hDGyn5gEoFPs95B|I`lLsXjM~{I6&TvQ?AF
z-2cVQzn$!+95R8=_wMV1#66mLx9s8Mv{w@LvXePv%>PXFUz_{?E%kq(SQqNMHKG20
zp8hWh`wS)WpiX56Ih7rjgu^Us9H@+Qf6d7JpQAw<l=i=?3JF|mD&)TZt3t*=t@>}N
zkicc23VDS2rja&S)=$>aC>cb2lx0pQ$&=xL$>dU3*Y9fm5*Kz?Cf{@OCmUOC&`~nG
zB`{oR5W&aTmg%HHJ}z0C*u)^3$ZT$EVr-2R!m?*TSMstIGsx}I3CYTi{Zffy<tG#q
zBV`!gNj7&ijbh`=NQd#R{<)02BI4ueS)>vsEh&d+I?d*lla=~DVUUf-NY&as_A~5!
zIgE`o^?Es}Ceat5ah2;EvE0KKY3F|1H0GW|PNIR5xnveO!?w<awSShqJQuc@_Q+?$
zD@YjLxi+b3hU5Zkt01$*i?G5@DKYF1lcXSarGkW#OE1kM&64S|M6BN2F}}Aa4p*OA
zNa{s$>5+M4h&pN!nJbbmc6~XS%#JT1J|q2(TgiG8=~9tCorGQD+`}eZ#)Ha2m&9Jn
zq=Vvf=Cn9hI2(Cf1b6({V%@E7kE1~ruCfPeNiMm@Ua2K%*6R{kS>tW+)_dJm>{u;{
z2(<~e`8D>I8aObq^CPox2dv%@nN4<(!RD~JE9?mR31`nbG!x=&2N^A=$Yc|%{!ET%
zwmM=JufjlGtHiQtb!4u5O|qu5t~!!nwl1nc@6dLS){)roUV0mp;p=?H6WQ~1B#2p8
z0HuT-n}n!<IV(u8NM*Kk1sM`zk%@J7od-Tpj8q#Ydu|1>5{q8;)C#gm3Xvn(u}qqz
zu3ZTah8Qlh3;O_>c@-HkA`11V+FKDfQR4zyv@P5?1c&fJP3cbI%}23itB6~S(`rYs
zzpNtpVv@`bJg!8C#Oj#k(LR7;Qavo)6q$8iloQ#qGbR(ezn+_uNa+L;PSwLLt_5{O
zs|gLnERxIYz<QWLTG~*O!5&>pGSmlM<PCG*EEQQXy;GwHr1BuVCYQ6(lO>ZT*5o3I
zYH&L_CH1Nut%htQ)nZ159B2)pMqgVb3mYdue-?Y>UNRr_`q8~)5j+*oK2A#14V%az
z0we3ojWkoOy^p-u{ZaY=nI#%I?3Jz1Q7@}+Y$aQyxI&raAVLMfHEUZJv^K%2i$wH}
zW9?<N{vlErMDkTM?Ush;_W}&H`T|y{16F9vvwau&u{d646@O4-)Xd!k5f@%H@mVr}
zBIu9Jew9YE%s-3qZ0Yl43Od>KJh@+r=`oBm8=Q?*%k`+mW_2GE$4YAJk4deWG^^)+
zLc&BmtM`aM6d8LJ`vcADv44s)B}Pv{67PQ%e(Gj*)>ooaV!wU^Or%-exnF!pQh)ki
z<S{GYm=q@2ME2fk5~FT8LmCme!@l|hNs8*}Kh^23s%vq5&(Y{rv)?1BGTIm)E9Fb-
zruWHx{OfwM^p?o}eiCim@f&d(VG}-vJIAZeN|j6^b6$oYBVXNmnY5XZIN&OI69%jL
z-apA@B9_YBPoEH`+pT4CfZYltieW;z8ucalhlq+HUy~Y<R2*&=-;v-Rne&olQ&-Aj
zwM-VPC(L5|0Dt1D7%^D-mI2%!FE)wdS&5}A71P*XpQ0)1lqB&N{-i<bFq?Rlz%)u4
zEM}q8nS;d+x#u%@n0VbJ<`Nb(64?e2i$;pF2*PWBnMSBhxnd0wD`YnDuSzugc$7F3
z#m0^n(=3bmfC_|4KH|y5&Q6UM=fRjgKUYjrC*_Hf=>M>f5iKHV-`*@nsCO2Ktq6Eh
z|5+s7B9SfX+zH}DiUDt%B8Dl%sqQYr%<6!om?G`9pcM_O6iZ@Vi^K6fM~eaEx^i*3
zL>wx*i#9_Dz4{!D!}!7%ix)+hh7*s{RF<$*909*p!;gWLl}lke=&??5Y(%wq(~Sy!
zSS>#2udRN+2D3@Fs~1*?CJ{k!Y|vmaMGd}9oFR9At!@-onLsh`d&QSXUp)SGjflN`
z1CQ5Qfnc&j9d^4ogOELH(;ebMik%lcN2*ub#g7oL%g)~|W{|^b&<3$qBuAO+9&tE6
zAG=5F6h#O4-zzkdwQm+<(dc8Fk>_N<S2TN%zc(}GJ`sC04<KRAeWH~#u%-8571lf;
zMzQ<v6W5XEN4AQQEa`qRO0S<B5=l~lU{93?+yR?i_hZ`|v~bt`Vnbvrm`53e6k_i@
z&c+ppQSgF|{#}V=F%O8d#8&OY7QIf!Zd5wS3@9oH>$HycKL8}Rvu)eZf9MvmB4cAO
zKC`($pV_SQnax`Dom<3Yz<G3wm=&Gd6QgKE!ofMe1;sMM`ohU79u#BP{H<ag*{-$o
z)>d(%xI<f(Q9EUQUG5H8mpipmD<2dQlg6HSP@FwJA8{Zh4Lqh+5O#AS-zf`wdcnT8
zKkR#T*!OC!jo&6Fjz#338D2oGp@1eyYOS+Hmv{TPylZjRIHvkj1YsXXSP|R(5U}>A
zZQ^tp%_Oqj4~khV!zT`7cXo(_LB_i~#IZL<%VG9u2dL->i+u<skFaqMi8j#s(uc%E
zJX#+TldMMot27Cs)hZm-;C<;K@fl>^>JtmZV*xCjJH$Fa6l2++e4sFml~0q5#HruS
z(s`+aFOg_<+mDGTc7N@Ckzg^!i7N7@_9R=6kS#nKj^!T0?0x?WF%ydl!r*uQ#L>+5
zOYCzSlA*h#ArCYO(Kk^O65WX>zY$AOT@w~aRMF9u?#9*gZ(>V~Ctpw`i}pg^CUE8J
z<IiW~PLVEuQ|c>6#Q*YFjZwp_(&3(gG`=E+bmuYTjb@?SXfQaFCYX2|_JPs`qv0{^
z!9S4te=DLs&~UDyX4m^9#g7V2Xmvw{oQr;d$EXudieGepu~W$sN2n&(cm-`@G|}d-
z&L*Ww97;{ZbtkSGDp_?=_pE<Vqt(ye74Po(O70@1+VBD1X!X%Apkj4bZ#)Y^)FkBd
zJtJ6pL9~$LhPXVgugeq0x;z=ME>Ez>J`l@C_Et`FJdS#3TrD2^@_I+NNEc4>ReAz`
z#2(tM^ph()^`Th$-L%RMe<Q}|gsR?gS)8f(iH|*gRV?-s9s4py>efI&ara5c0g=7I
zpBi1UN2rvie)eDFC{gjcH%OoMJt**Rl#mZ3-g*fd!lb^+B?{(hHrJ~#AtNA+xw`Qz
zQ3s_<XQ&^gyt`PY;nPq*<kPZsDQg~Rj$tQ9OT+j?%$*=bvg|_1-2IWBCw<iY(JN<K
zz7!57xF}yrE(FKw72cewGqT(&2#jyZ8>Qu`2lAzr+I08tdRCzniVoHnO3?$fma4!B
z9f+9L(uQD|&lE~C2~4>wMN%3{Mvs#Q;qixJX*5Rd94BE<Tgyyf2Z}+k`Rr%KQc_Qe
z0pq2?8vO<K4JAWbDO%2OB7wjEEVob^iIp?eq>;s*7JH++&e3Am14S;#q<BH^B!P5W
zr5D*PB~lKy3^$cXAC_m4>OQrrZBDlh2X_#czS7a+u-O}HZ8i4BMwiF7++nL(X>VMC
zEEl#|Y))gZ#cgw}b-F#-Y+I2S$@V`8@jY$^jOjg-F)*#ak?QA@rDhUj{lpI#+c#Cp
zD~%%4?9O`h=W0Pm-3{7YbvC>0)@pxYV_-!^^IhKh<q&JN)s+a3uX8p!5jU$oF;%J}
zx?&W|qNhop!Cam-LrQ=RvvP(sNS!ntc<xS9k@mUR{izq(K2sWpt#Q^_E^QL+ge{pZ
zrL|>hgGboDt;fI{=0*trS`R>l8Dgt-Iq(hC)V8>qGHq_xVq$M>^{j-tVRK`h!zRQV
z9~txz9_Q~_Y4_I!QjIbgYb^?UG`#8<uLD}zvTakfG4dwLNsFVY-d^Kqa5Q>sEq13H
zJ#)}>Kw9j0Z{f{1V)E*7#$kn)yV6zf$h56l>8x34%$*xwfWfia(bBrf<@NCGvf2Q6
zU5&ODhuc+;lN;#3rMAtMej~!?!0qR0{pre_(=$o+4hZDb?m6O?;6+Zcmt+Bd*dIG9
z;ULCknLYTGX{gvGv)sSaSlthEs6vVci`l(dicrs1NV{b5s;n)1i(mg}X2-74G;&RS
z{buQ`g<NI3s--f7UVT(8B}0o0vP-F;wJUZhI>@HER;rw}XW1Mi7lHv#ML<kZQLj*J
z(p?NLqe<QQes>c5M%UO2c4>;<YKs1dV#Ah8VVw6AE|+ZaH*OhKue05&r3AKhxincs
zm`%rZnyhv$mzEOH<m_6hFwR0rIu47hb{di2iH13uujAlQt@N}EGx!##<bjc|zPU<r
z5HW<RqZ_1E6bVnZNJC(sP*(C4jc41kO_Y7$m7<4%u~}{N`JCEYV2_5ac6l6>lCYcc
z6i81mw$)PHKossdmtk$Rx8}2%t0f!szP{;!35oXQAR3K_cGt!R8x4RZRPPUpwG|{`
zF>*dyE!{Rega-N$;H&Cus&mg1C?}jU+cz|hlgBVPtzKONZW_fdu8}fGk{Y^JYEgiN
zyY7^NB$A?TX_uZN$j-T2$|Z4Z`Q0d0$sV{{8jr94x?4in1Z7>VG=`ZrNH;_OShfMp
zrKuY>NE?WlLD|-+rdT%eAUuL2?~xEpr_aKz_eiB&G=eM-Sp10&pY*sSWl<~JHNzCm
z;+ZrHMOH9rH7|PZG3i$kIJ?IZBb9je`j4b!KP4mn5vvq(;_DwtclJx%v0u8wpU6fW
zkoJoCl&vo|B_yOy<IH$r?x+GDHixMR^J?#ffZ&^%rX)5uN>Mb}Nje*UP>S<6V<!4J
znr78=P}(P(nss@|w#_m{vf`Jdfn=cylf5<si|WOnOQS<W3!IHLEe^ZeQKcQgVF%up
zhRihdf1|el7>{M`n`K5}jnQZoG``(vvxBBrJ8Ya$ds;cytJWoNHJfyc6wR!v6vKA@
zN=h`nkY!r{7RJu~0^GKoWZCBR@HL24S4%BeVzt(EbznQ$s0Jy8KkfXK#|4(P0ul%u
z5OI^WoH2sMt%3NeBsQC0z_p+;n2Ih9UIRGeRH4n~ZS!Qg>avz|ahLAMUXhI^YrHKj
zoHK&oJ6am;^<alhS>7gh2Iuq(dCMyu7#{#_0M}j(md$lKl(N~^VD;G`)cAWnLNYM%
z{Jmx+!iaRlI34b6Tbak!;B{+~HF5<okA6~lv*6-6*$WXqGG~A#c3O)g%fXR=>{?A!
za=zc_SYy+X&OwIMvDs^Dxj5v2)<VN{J0WS%wqJO$+*hQCw(JU^nIm1V%Y~4uv7V0t
zxX~xSHWQ6QJfM~C1h<YgXX9#nixWYAI)*tMZf^so-2!ZAgUd1yt2NJMC2z>Fw#MPm
zrlrkc!?6S|!u0+zg-sAQI85oN%`VkILsAVt4yVc1;lm+ahYv^Fj+#|Ho%WeMNIA4#
z4V37FTRjc}R~uJ3;PN)X8*fO<wr;Z0`p>q_wYPF1Xah$B61Zvs9BYCaQ>q_1g~-R$
z)Y}XWZL@p$+{1bAsn?`2rv^Xr{Bl<x-Ev2(3zNgqWROQ2=tCz_x3i%McyF+;0%&$y
zJ)iqu*?=7mkB!TJ+xzPuhH_z)2i9y2E}%(=&cIUkKeKFe`25-Zc-2t@m~{~N1P9D*
zP_1pX(+-H7Zno`3DH^68yYK@kIgP_;V0Fz(m)lPt=%$-2vVX;zE|HjYPSdp*Rj-Al
zqf<y7GQ?K88uRNGPO<Z^NKp|t^P_xzR>Ac)XB{ISz|S_GW&c*14#)87-%9a>l(3H9
zNyUTDO7hL5l*(F+a2X{9lNZ2gR&H-9o|$R889tLz_Sx^Gk)z9~Z1ZQC<(b5&2M$>d
z@vHqOR!{+dn%+@Lg@vr*G<g4F_QTWC6OaxU&Pow%$ve_eVprSWk*Z93S{;0TGtNmV
zaLnCy4uT_NaW8>YN&5+`O7sDNRms~=V}Cp^Wy6)Iz2{tjF7I!Sc`rz%_|kIDUw}F5
zWFhZs4~#sT&3#|Wk{ZC&D;7Z(J^H?6gE%?zzO;agl>vW|UgXc8Uy?{LB+<}+N-gTx
ztJ0_3)r^lxMBf64Qt!AXeSuS;YSWhxC}JyRSMKE-7GFbaF+PG*5w%~{gb*+HIyUiZ
zm?wzg`WjMp9lPgiDV?;d`@fb>;UMSs^>T*xe?mwmUt63$Y8)**J^t_~at0jD41gu5
zxm13hkj?5@MTSnYMZI8_*AqCDmj}s71pdeM!SY-R&tYenOiU~^PEKH#W8}yz2s3jg
z*qg(UDw=rf)+q!bah`)SQbaGpcgMowFc8-gXgcMw@^Fk73F&FjcW^@5)r3j6!qcZU
z!B6fAvGW{!z2MZ5u#OiU#y*La5$vnIr<T&b^^nr19;=SWF3g`|<q)<Z4plenAiN$Y
zH;mrWiz+($Q$>eP75pKaLD0f>z4jgPavp-i4#vwvGj{Z9WM}_IcIu7nd?Z13k=<%j
zg8Yb#WBqJofijGZv|)Povc)#}UU*tB*yIh|^|_^0j#2MSk#AGFzeu_~4YoWrvz!7Y
znK`rMo5())VwOCT9A<ycl5KXcKju%^haSa)RKOqLmJ5W#y<j}jAI2j(jQk;+(+h;7
zyoF;_z#kF{j#J^dzvm6vav|pJm27!%7|@+K*U<u#wH{|8LG~T_avB@323uZ<Bjp(E
zu;z`Fk6>r?(~)webP`Qy1>8CEIBdJ_&yiE5PJgXsg|fm(uKY{sw7=YyTsaeVcG4($
zC^jdjj*^E*U!x?i)Yzw+59LCO5j?}1M$3cQv!mo3dY0ng3OhGij$xmVlCxkU`WI$G
z@&$t>U8OzyAs4g}$``3{k+(7%M*ORz<pjh#zc(6_e5t4U$je6cu7K*7_3H4Bc5#&9
z^D2L$)oZLNPtLPpc@&pI_uw+guXmAD2;3@2t5wh>e~~8-jlNMS;rb)_@>Y>3?7|w;
zFsA0q<3y^cf6JFAOA=KKWCLwkqD5g_3gtu~>A6DL7Hq*0Cox13LQsfre6r6A<&3s)
zq>@-}OSnfR^}LVH?Rn1|-}9bd*7H7QVbA+md(V48L(h9*D}PVa+Rx3|81RwX!9UuJ
ztWi4yvPSO>_{cjP@R5Hk;A6~5d<c91Vw57_4@6lVrwI5H6xbSkIAV$-;18#|tJ4%@
zq-mw%lnh0{pP<kzMaWXvmETG6ZLuKQg}Gx;7<=T}Mmqvcc^mnPfIr?wA#bA)@A~;N
zMc}9rOB4ZrJinCZm-2j=I=nNEF0ot@@W=Bjczy-Xht<sU7xMhYih#d1UZ9c}sN@Ae
zFuZ`B7jP&7{&>EV=R0{m{_*?<p5Lqp_~ZFrp6})P+95VYXyy6q6ajxczn$l|^L*`K
zn<8xF`I{ACv(ly&*uo2J;RSG*ly}g<3v5>e{P6~M@cbP-KS<Bt$@6zB0{(dZ9-hC4
z=LhTgdwKpoMZh1=KgjbB@_cSTqW!}>|A-<SS*#a0$_pIj1w!-!$9RF`ihw`fzzLpz
zg69v=^H1{pPDQ{U&p*xcPxJgxJ^zfty1r-1W0S|rsaOju#>-xERy{jj&Xf$v%92au
z=SD!p1>DaOqV&@SLeMD0)deMtwJ$<2$*a?p0W4;+%#F&N$zW_aEpdx7L|rvm{uj1(
z)w-$jN&d{6CO@QrXZ&)Oe8tqIkXl3wvkDnr-P7eVoCrp>adYL*Byv?9u|OW7z;L@|
ziF}32;Tcu(YowZ4s^y)qgMUyhXZsF0V#Mqe_P1&|m%p>gcKL~fQo@!070@=h`2=$a
zx|(J))VKO}-Wp%lSZmW%Zd*0Hq*Yv{uXof!^26m;WV0_MD<D!~3vu_K?hE94V0F2(
z5qh2zdbX=&GB0Zz$(lErBHDEGhI`07-j+tL>#ugYyzcteGUB$^!Fur6-7BF0Yjznf
zhG=lQ-2kT^aWYV9p>{WECKYZ#fwfd(Tmhro0d?F+SnjBIt<e;0C@2dFV0Jcm8=z3v
zabwWk=7rzO?uXR967ECj&kkF)Hn1uewBDBLEa=qfx{GY3o$KPYjz$<ytvZ%qT|Lv|
z=ED)o78iHpIc&ho3P%fUK|VSTDJ&QP_ndgRyOehVD@Ogy4snIpnh`bf08xbUqiJIc
z9dd;6k-#?c55yxq=8)6)^O!?U5iKV6XNR0BhM3raui^e4R3}IB#JoB=n}n-1b@Iy=
zC|HS2a;=F(sqJgzKN}v<IM&uGTMgNtPU6&;TIF;ZK_P!yCoe-CHsN0RfYEt2f7&+5
zqq_T9xk>&)yr{7Ci?CJh-YnOOmyD0kHp_!@E-O7k8_p!{tU+y$@^BfnuRzuA!V_xO
zRgGm1Vz=HWheloFY1b72e_XLZDPjs-B6IJTLn0u{`f78`_JABo`j*smImyzmh4iaR
z-xiS4N3Rn?`q%qU^g$uKU%jCid>@FB(zm}TW`9)9EjG4@TCq9nKMD|M3S=iqrhe=s
z2^<>iBuQ%_CdH&1Mro#=CQ?jRozq-@Ku(&VZP^-rpFpRb725;V#8%p3#}ap}1ye=C
zVv0$~z*DwjJ_>{^6Kh_g*x1@Fayo){c5jjYmY7IvHT8C!@on^!nMlqQ<9#OF&H}r$
z5>)cSR(Ui|E}Y*guOPK-#)I;y@G_0bxScC-w2k|OJS<_GJTIpV_I<U#HL#OgG`BR*
z$8yq3!)|qA`FY^TaKJ*{CdamUTv+)w@CG+r8w73!4g!{`8yf_H;2=y$D^p$RcX%6q
zZ0^R^x&VhlEp+C@ZiCKCI1|*Y{z$l8T-@bitJcUG;4J`Da~<mXZSrps&!H}OSl%Q7
zEjc^nB=#>R7eL(`{V3GLd~I%`3XQob4VarkUV0Ea{-``JZoG-iK)9I(@)Y=@oE~o3
z;^+u3GYj_bx*gDtOZ4`Cw?j?|D&<pDXcEe_d5L3NACr|~y{CYf6Ai8iF~(IBAc@mU
zxdzj;5(B1+0GKLxt0g93VK35K+@JIoqad1E+|zqzNF}_OGjhk|@Qh0K%f~<{c6Q}4
zd9)b0fX#i)62*$XFNeiBKq~X#3n^XO1lElx1QOZea(UcNR<u)2Q1AS{{8NHZ8GO8q
zup0G?CvlD3f<;YUoRQ?ZZM~z4JKn0aI-t%!>ZTm$%}uz+hLe<5Dr*I9d4W?E62n%_
z`<ur*skWiV7VcjY{>hql$rF4n4^D&Oy=FJ;9w)o{l$^;v-7PmFyrl9exq=OTMjjQ_
zY+!0#0H&IG*=5OI6X|YzPE&EYgWquFo>PaT%kW2d^#-4KS`LMx@S~^Y5mBusBG1Eo
zBu>?LbvUwG*{4s-nU-}N`OPMwU8k7>eK{`<*fib<3Gk#Tm2G)O4nnxtqtD2lWV3qP
z9vP>m7L#<)ysNR!xuU2@-Sn*dHMhF&{h|B`X`74vA?zv}=+j6YH|k-N!w{NVOyp;i
zb^n&ed=NOR=aj+UhZwtZ``Y>4mz+(udumor5R}X-NNZ@qO4IV@!x!X$3kT?S*dbXP
z>`hJF<K=9$wN?8&s)j!dr(OBZm!}6>cyM^pdD!LB6prf3Y{5=SdYaH&aPW?4JBtDJ
zG;Gg@gAhR`=-Le*Ea;%7#(~S)c-QdVaiyY-s}25z?{qIFYgRfMwN<aVaMxhrw>Xx2
zad5eNQx8r<ttzi+!+t58z;GJYA<cl1S8u`g8T`2Z*3w9KbH<ikHs5V&XlmoYv}hg&
zZAXxA0cJuAsIkLE%~cTG;^l1sJJej$P#0?5x#ZSrV-6O$N;q%A_|`Z*&{Cj7aEB*v
zlk-MCKn+T_2l^O3wf#AbmH83aHZBXz&E@gAo}wZQ0r5D!X#tJ<;nSR>(BSm8{iEf|
zPm5PWL$<J(^h{{Cj~ep~{RdlC+~Mf1fnmxa<Zk*FY?i_cipB0HIIab8%?OGR$e{t+
zk<GIPb67~wiXF~WP?)~K%3Z{*T2);XH0b?tr!ESjGN{5&X&gP=C#p4RYjt?CLHB&D
zZM_Hk-z0ofWEs(UPCr8LK?|og?kUxXwM|=-{i)p63#%1mGIUN`cleZBla82S|M*t8
zfRlO`u&RxePmn%T?&RlR#wvrH)NYWgabh_w#NKcl_WvDNo!QuIF;;x_e==|1H3cc;
zhI8Pb&VWT~Z))qax^4CqAcqzkAB&?UySAp@VQ&eXBg9Q`e)ZpFQRdV#G8LQeZ5np^
z@F^X2psK#yss~4YmH`^Xm4e(AzXDsE*+MyZQ}?pt3cXeUWY4n=^8(9=vm=mpk*$p{
zaeovzR0$Y6wK&?ZF&pgP@QoDg-Yg`1gMl*v%quRjG?X25+`?BiXPZ!f43@@MJmB%z
z5Hbp~!1Cg&0e-6hwxydIUt#`XIC)`#*f=sYrrbk2{8~SqS!kgP=%yZW)2-=6c5E-y
z*O!BL_~ptCXgDys0Q|*Zyaqeb2Gh`Hhyt)ut>Y$_CtE1}f5=3>ix_P>E$;GDpMS;Z
zYp^BE&m#R3sa=`4SrfDRv576(d*lt2@DBC-KKbvmxE;n8Lh{v5e=M8C@E%piP^a0X
zpU9J7sZT#F&w?-B_++PFmZ!kC9d`tt#-7ynpFly}q5kA2@<vK_vPrMWIe0X`CRdT2
zYUgY6FXVn5beF39(iF$897o*bPKKh1>f|@%M=5%K@7MCf5~)<1-j=8P-4g1_-^dS0
zWCyk~<TO-R|BjpxzuUwwJsgua&X$Ku4|hZ9&|FFB0`5t<2=!GvS#ahZxeN~AA@9n=
ziuRgF>SS#E&a%Uz7NGNE1GQ?EqjjH&Bu>HmOb5<6%<}KlA@&`6#Mte0)E{IA8k9)&
z(Rby~m8d?ggdq%N)nWC?bMhXF&6UzW%ctP41^`1?;YE1>{HrrA$|-O~Ye`!!%GR+R
zB=EMzgS}K#wB9#XV6U#C9_B3+4eQ-Kjym(3Q)Qvo7;vi#%l!)mew5w*7y0+%QImf1
z!~LOLL5``%Ka~F|;RsUhC-D6L;bVCqB1|rSEGJ}~=mpBj{-B)HK{?5**1|(w)P>!O
z1E0W~bee&@BH5)+<k;{tCbGb|U$(@}4~nqipUL^`{eAL4w)isq`J0*gnLNcBc%+2=
zeua`O!KI|n-S<9|gV>j!%F%EM4g5?VoN=)iXqWnfc1Z{AQg{7gy_@pEhh?%9x?hP0
zj$MzYN6&}RW{0l^h6%1uGnv`Bb0!;`c14ah`|W%-whJWGenrk<tGlq3^X3(K1YBm?
zfCqNT!&r+*6WD?-c`#05vvFN=9P8+khXzwzDFXWwks@YhJ8z0q-|3Pc4-+j$nJpq6
zA%++qzZI!X4mX=O>7jrFBsv0Xi<Hy&xP=m#VW5zM&QDR5)j|=EVhs|V5FCe~mvUDv
z;E&@8Huetw!}SFJkmx7`ehimsE>5j2m1%WEni==m=)!U;&TGLYHv4QVV%T3~8od~X
zbQlS%gNX*GME9N);cQylt?rc?tDnZ`l@?i7Z(rfgFq3rn@LTND_!n*h*1M>uG&C5+
zjaZH>RuYR?mnSKmwLBL-S25o#<eSYob^NB|D*dcgrnav-PYa8H|AZ8pab&1iu#(6o
z=opTaAQCy3zrfalM%CykG!wZLUVBI=XN~){9*038do`0Lvw8&}T#21;9ON3$?onu-
z>@bs`vGBXGO>|bFgJ3Rwr2t_K3;{-nUu4TobOJ*Dcbn+2*?lki-fJc=z%B4?ck31v
zX#*&}@y*}+*zZgfS0AxZGc7@oRE3#NM%d58W}1aquh-3VtbEN(o?&yIRpMB*g(i{f
zEYCu7L>$*@3pEd78!U8?Of6(3`=f;>_)L~iG0MVzW1-^^0yH3q){99Nc9~z2x;+TQ
zl*Wz)p`#2Y1=FDjv=|<Yj&j+eV48`ONE`Xrc(&L|3)siOG!$m}m%*r2%7$5ij&h!J
z6K)RE3jEPZW5k6P<{D^DWHT&u080*`14XBW?Hg!LV6#KePXpT)LT>>H|22f>0FQA4
zXo1{nA-h;g4t9GR22g&J#+Ct~(T(i20W{aV-9ql*w-K`gp*XP^6-o!nJ1pd3wtI#t
zicJbd`JJpflopfSY-cDPi%B^hO7rD?7V-kKr6>t3BMjkkN7$S&T8Mi;Hiyxh!Pm}*
z(Me!wDdDtC#ywxBSXZ{3${q@*Ir3=>`KSK*Q8<9RXdzeh&t21L5L+;i@{O&gfpm;`
z&B9)b!B~GWkfw?_VfWEMI#ooOoCrErv;?vCSaURMi=c60NDzB0g67KMLF9+}nZ8RA
zbeJ3!1S0#>Ia4y9$?%{ZxZB!W>%wt9HaimNO=9aKF%9F{zDPO+sPBrTmB9I&C@f^{
zD@xrMMd3#CvTvekEwXB3=o)1GF$UCG$`WE}LU0-Q0D?QP<VyMCsvu?h8has@Mx(~h
zV`(`iFg%V{Brn7oUEo^fXe@1Makb!*&-9WO*cmv-$?uq6%-Z9C$x8NvIC|?qJ8n^0
z0Ox{U6q^ebEHa)h!g-&DczOiU1;Y~P928!YKqn%wKuw_eM0A+hwv9@P8k$6J6CtX<
zmrNa4TIZAL6;MW}jeb68hlxz`b2Ynr)oiSLTw)yyZi74in%RXET8)a62h$(m@zG$~
zhR1C~=o5HYQt2){o=c^Fz++<?{qe|VvyAO;UX?S6FmQ`<GclXztda$O=bHdN+=566
za2mKKyk_6o>G5p+P#Q0{n#nI78Ah|&n?q>^fyy+DPGtGRK>FJIFX7_Qn8%EC8WR&%
zJRkdzFaiC$s<;~33?dtlMP2M-Ivt43_J5|+^&sii4C>A6d)fPDGs4V^zx%p(b|8zE
zo4NV{3Am0O97(f%IkUsnk;CaQg7%S6z#beySE3Uw^QMXcEH9HTX9q^ok$o?N&+EAi
zUejpI-8ZnyxT8JrKKO6F@?91R`(F7TaKAdxxdpiQ-{79KfOG)yeXelt(DB~EQCSdq
z11xT5!CCYkd50MXs=iF8E7|od8YAyCV;$d-LF<dPm>PK4`yzBVu>YSRbUr^_y}cWm
z>|{3m0Hg!_Z3b5{&=|_r=1@D>3;*tm$l@ME>c9kCtuJF2r29g4W8WI``8zOL(ChMe
zPLq4g)~Ut~?G4TqEq3)%4t<Nl*ZA@n`b^ti^M7)Sd!#0B^lRKF88?OMKT3f(5$GcD
zFF46}-`r049pn89rS`kuy?y}<x<>sfdE;t#_VqA29J+1gSa64Y_R?5-8y+bI^k;aS
zE1)y+7+y%{;jylew%~E4kapm4R}meIdEZk+U%^-HINFHEZ^vQ9=d=06;B)!x*Ts|v
z8^n*-@-~mBv+(uKcv_FglnL}sJYJtbH{daSB5lIs<%w8@`K)jfor}kP`s2MxS}Vg#
z=#(g^BE8N^@Nol_5=gnjtaCDrV}B{3iKr`0rloz7+9rd$YNa?(wkhcGFzc8?=i}?*
z6k6A(_+3*W*)Ou=Q|WT?pqU*Qgb>zgrQk4!b=J~R3O0X){g@{mW#>w1Hpo6?8kYNU
zmOqV-kx!V(<7`(bO=1sB1FBB4{nH@SI@y(Jv{*iEhNQ_YPzJHt)9G;ejG3J8mSQRL
zSu<JBb0gWA=`?om1v9BNsEphCs~tr}Ge8yd5CRJ~dM&pVz@y_><_rkGqin_uid!Ao
z+8N;K$Jvi&&?4!CIWP!!Kp6z$Ni#UQlFAm9(ZOP;nPoSc;@Kl*P;O6~^}wBv%Ahcu
zG3y)7C^mqV-bACMv*y5EuJt$3c<}=81B;Zm6~bP<iIxFzAgDMtWSkPtM$d$na*5ez
zQb!CXFvnPHnr9kUh<cn&`RwdW`ZUz3_F2^Vt!21c%|qIg%IQ(e*?Z-*8LC(LY)*ix
zbq)l9c-8D1<Qc}6&4t3D-O<nX<AQw@R_D^$;x+R_cMWDi$x1NGtH6}#KRck-S3vbZ
znP=zG8a#sLL+a(TrukaCBNqUR<htruNdJa&YL<X2?4i-!LN`H~!(smynxXv+TSTKo
zi-k>CMCT>;K2DWc3(Lg`lLgKa4B^W6Xk>6W?iR!K0LAGU6WF9$95MJ{5gj@1yXpnr
ziWlkNT0ppkq|S$fQ<L+0D~`pq$kw|Ry=;j@Z0Ikb=(~&QB#zNyI}DJ*CG;yGa?Gvt
zO}RTUwVFmiX}H2K@0(RkKShR$((|>0XdN}k+|2gW(3QMGXf238iJiKQrm#h|^f{g;
zJLqwLV+i!tU@l=_IOy{rO<bVS>CaRjT0!5^4iss?+~tI7iu#W@X^Ox9H=XoKpNsdx
zYFuuQ*5##d%}HUOuA<-jj_jTFw6Sk?ox|ZyV#y7(jYDA!^u-2xIHosdd#=7)-$-Bn
z*33CBx`H?KvWqU}6tcewG5*7w=qxeB!qzs?r1%gEnZz%JYr(H`fJU@Q;+xaRN8$1i
zOkSj(D1=*>rI|8rH*B3w64=pZdWtvtU<(#R93yVJ6!g2yt#MX7Mzd%Sohc<*dhQL;
zNY}#d_dvVUE)U5y>2s5!hI^r$>WOzDKJ&M$>0aYAm;Goh-LGdwGfykM9fs-^L~Dv^
z7IxuHC6gWg9!>s#L-@mPr+M%{EWMphV@DoExZF*rlu&l`cJS14^^@DV4qeXb)=?KM
zlXuq9JMcCCPI|MLW#RWt#IxWriiN#(Cw*D&z8-=-+eV-4{W;nksHaA<7uVC}0VT$?
z(`SIU_u65!<+E$;kPo@+w!6R^n%OgV(M_<ovhJosgD)H5RK#p&oo%?;#CtdRk)DaO
z9!oaR0sbo^*!GR!CE8sQT;{F3N0UuP4^Q8t3CV<e={T{_!tZ#9Q=9LlcXL)`6p7dj
z$vK{tze)?)xwq&}<lOPLCL*uD&1I@ue~RK)oxE(qX?h8t>F)qHC}jT?-OfJ!Ejad!
z-_yI0@$28ybvz^J*R+!T^Z`1Atsf6RM?TxXoo<22QT-l0gRgJiq)Q%QFg)^E^GP~`
zozmYsPtu$H?-Sp`h)UF-JW3bwNM!x816Hz&e%SMM%WnD}OpMV_(XD|OCLHA-yKBT`
z^^K?LLmV93dl1PQ_CN#Ie;S27x<`Wp>66)u&%#VA#SCN9mhIR~2dJSxp!+3^*0_P-
z%yTrxh$cx!1K}@#Rp{-gGhd)(lK<`irtYU7bblN@K;H#$+Yf3F+*pw5zn|chAJaFC
zcXjU}`UZZTray%HRobbipTuL%5&EWnwZJGg`zQ1-0q@D|o}WTwX!j0inaS+UpFx4r
zZcKO;IREA-y4LSZVCAm>A!Ud}hi+7^%{S*3e|n3$__Mu(rm<bGX@U&%ud(c-Z^LlQ
zXP^V^Q!6s*er--c6jOM$1E=T%M)gz{`a0E4sqTK54rb4H($PFe`#ARiE#My?zfNcH
zXZ03{N<8;((W_VemOjY8Kl?3s7oOkzf|l|px=dx;9;D;>N7wJ5+-Y=J&OaYG4H1Fo
z`O|bdpafmsZd7@kKTF=#BrPXX{yFaVw241o_&r=XP#b?w9sD!*41I_{0j1V4zK8hH
zzzNwX)13xd_VS}{TtoC9kLz}XxleK;U&ZTedz0S6pM+6<KLaQFfKN{N0iT@q13oqK
zulWDnij)^x0*)h_*w<(2GTil1c@7>A(AZPwHRb-x^K=OYeDej^<51`SOmo$t?*j)Y
zQT%~6Q5!y>3z7AQ59m{RiTQBjcm5e(9DH_NgqoetivL2V!NQsOSGtvje+WbW206b$
zlY=hN*FqK}@KQF%0fR!Ng-50iVwR6+Sfm~4qQfHKPs@iJ)5)?vqPTL1?f3{%DW84#
zk>=5h`xr*Ernbkk^Pf-!IZuB~+xsL<`vitZ?@}LrLaW7Qh|d{Nt?ZZSX`MO5sdGQ2
zu@XYHTyrGsU#x)2a(5T?_DYEO9K6}uT_Ta~yiB8IiyThav!Bx;gKco6HfTFY2nNC4
zDz+f-g*~v94(tXyJ=qIbMTQu~&VLRy^DL9Tpbz8m=oj<>JktI~AIIbMzoFB!tl%o$
zipMXn(&=qsNd(3qcA5Q0mihTt974hm&GFzvY`6t%-tn#0<$RmA8w3<-T+NTfBEoMW
znNwGnh5Zq11Nt}hd29iH*OUw%s)XP0>fQ@n?R2!Q!4YR;U>KCvH+J^0H;U*2V`n#w
za1T5W6{vT)R(YFjYqVg+MjV{tK}z;|9y5TLM83stoKNC+H=+D;9$ASZuI0u#DzC*_
zY?w73)N*^-q`yNC(2tg~O@F5i{&&ki;H=WpAuj#_E6ONy>>soW?<xQ6DT-6MA#DFY
zHG1dAbXmeR8saZse2uP(zp7u>q;Uu>KFoh~7gts5M|VHGMi+^&4kmqt<}b5dUqREk
z%o49tw{b|e&3H~?^S-82k;lHK_rfun{0*e?Ww!MjkZctD$2SlN`P<JaA8G&NL?uyf
zH(vLPinCYA0%*tB@T_lbS6`QuV$Ek{QVP`qszmxf;QCftxHAbEY?Mj4Q-6QLpS0Pm
z?AO~@8!c#GY`3uRZ0w6%3sMG@;LiL7E_4C68VR$vI^3{pBKdh+e(N?4)dqeiy1h+&
z+q<WTu+aj8+?2p-f|bX~=0~hbNzP_Vp!;r%1^&AZi{Zc9!XvH?2VMu>xyOk$Tb0ED
z9?uST+Nxydp(wnSI0@*fayHhvwpd758J>KDfSWjQ3Fb|8x|?_;hM@s(hvqvK=IZx1
zLszT}QMk)OJCprhh?34(l{WK!QV3J?LY3M4o+X})+sOGLA>-(wQB)0Arb;`YAZur3
zUnnzK)TDt5Ja_r5G(tHIZ&N~~QVI{hJyPM?(b`Cb`}?1bRC0#*rzh^R$)_aXM6BkZ
z$$unD$$_IPH%b{z@>EBZa)Dq&YI=<FWL*D7^xa&Drx+yx0n`bx${8tQE)R|Jv<4nl
zW9<W#_}Wx-sUIrDl=X6vr1H_O)_$n2caBwlxx_e2*L@6+#~*bcq~q&X<2hbzth-vW
zS^MqKu=cR%L}dbSurN`16VB|xNuWcZF-d6#gN+!ZEXQN@Af=ISnA(&yZf_UDQ8YCf
zXJ7K!ACr~)z^GT)l$A(Cfm!(C<<!Y3%6p=81e2hhEGtM=cEw{becT1Hx8W8zN3EBA
zo~m%2x++ca+^Cp#S)4mxy_}{T6~C*%FVdB{+(jQXoG(tbV>r-_5kQ-aHybC(G^H|*
z9bIAy(q%|23(iy?M(?{amB;WHm!)ij=Nae8hOp1Flm<BWE3=giWIMx=vJos~B%0pA
zaI9=J``Ji^%eeF$jc9#2%J=X!AQy!<tG-<2V@`5yqm>jqc8^x>f;%TQPjL-DilyfF
z)-J%o!+y?M1S<12cFe+>6R?vx%uPepi+Ktm;&F@a+Y!eo+{1V47-cmczZs)=@R&YU
z;U2eNja3}jZ^<rD?!a_BU!Y6^Mm{M}UPj)YLghJb^c86j6iH_pi(#IP8mH`*Ix$`T
z6Hyi>7b`>H;Yu$C{GIAe#US^Aos`(L4L|-9D#Yw@b*c}HS8PN)Z2>*V#q6UA%1ClX
zjh_gNMD{=YBwS#RPEs~XXY`(ivS}sCNeIly$x4=Z7Q@YxBiPN8l@Eqr=!GM+)YqYX
zO~=ti3wLRaVLPS(zH91#O;KP*U~_w_0w1J0zf@U3q)V0_C)X@wTBn07U|>yG;D6W7
zIE+B*oijN0)Nf`eacDt}yGaS-Ee)Tk*zx(mOyyl%YRPJ6D`&v#C(Kc}+I4o0asZL`
zTjwe<B0}Szou@n{f|ZmlM4?hP<YwhxJ?-Cgi_(rNZ{DJ$@l#fPmO_rZ-qqx&s>3;U
zS4$}iUj)Lt%-R+yi{TbKvq%{(T@4t;02Q+~4Gc$ZTB2k~(si66J71+lss}2SwFEwv
zj4EY^c-_KscYtI+t5WcDWkIY9p|fgsHCR4;0l&5@+eN;EhRDyML0mJ@yw;KGL$%-t
z5mT|vQm_B|tR9qBi-_;pP`<7^lyzhiyS+|{Pt;@kYO`kq7UrVHQ45Tt^icV6?xi-O
z!;ILq?kE~9K9Uz_@pa0wHj<;Y#}8jr**)nv=QJiy{sph^=9&(Up>uUcKQzJPef;g{
z@kmBwP;Itkt{^=zo_Y|b4igV+>$#c)A3XA@I|#{zaMXVBqWrWx)Eq4a@^^Y5l&(D?
z^opMa(LkyWgu9wYs_Ka0T3&X*&*IM0qR*!As5FOx&Q$r~{s_{e)NCAde#c9bjvm>(
zFkoDI8R%)+nDj`o?ocxQbhsAM#Yf)L5)alY(a(MB6?sV3Gkq~}14P(d5_DOX<Asx1
zyNxt&g;K^B%?c1`9FG?HoNv5pj^k^|5age(#2TwqgPaf{kv(BeTzy4gLXD@At-npF
zgGcDY+m!i43=itQe$>M3^~ww2%>x=h;``Xb24x93s3PQN1n1>{Y*g}byWc>U@*cmS
z@zW;db}=f5ojqq7&aBCB9X-(u7I2ik)QoCzEW8E9o7pb6GKt;W0v@69{}}dmi*ia&
ze*`weSPzDg&pJHHF}T6zdzFReG@K$6-xM;~0k5(+FDr;lo#I+kJPf$P4lNHiZo&Ri
zR*-B(GQUVQHwdTm@E=a*;XjHWcw^&NEAxZB-N#%D+4ol~%isd~*J@=b9w}>-?1GXY
zXmGKOt`_{FSxJy~iX#(@Ko2nQPQvNwM(v<et6oMZVfU_4o&t{<zE;6+8?%LLl_ETN
zlkAnXP)W+!=WC&PR<Mz+D3HaLw1Q1%vD;gfDzJz5T9pau3wwZH%z?*$h`i^+t_%|J
z2V2gIn=0*U$@i4!B+(JXBWU88=}ye7lPx)KN{Ma_A_Y9Mn@5|#%yHHLCr+(gBx}4=
znHq6ej?^MiNCWR779BLO<98~>Q=9pBGX{)9_jniN9B<HNQ<v$g>6+;}!ig;A5OcUW
z%A8~tygWNH?6|4ZblP;mB(!o6ok7@{O}R@MtUB8OkENX_ZVVDO@<eP!t;cXTvk%ro
zc%?Af4)t#*%W8*0xmho8f4edpQvMG}O5PIG`&|FyxDKF$!?zuc3LU&c^Em!4?g$d_
z2gE#%{GCC8VtjW{KM}PXMIpv_vz&VnK=PNn0K^`>_bGRS0yeYT?#68BaAoZ6)!M%P
zt?koW+o!jdw?W}Mb{qq&bpuqA!|dt?=w?UQ$c@Ta{V`O;eeC`cQS6P4$}JH`_%MzJ
z3Hal~I2I%v;|)F&kwQt15ezT`=i@Mu$F-hbx)<6X)Ct!nB}O_C6vp1Z3vSX~n?T7Y
z**BY%S-G7zK;KD@zSHPK`%gR*B;b#Ch>WuwrXjx9G6u4Po0SsF1rE~1AmJkWa<ft=
zT?)dn>y0=PwBbJGaNOk}lF2EI@BL~aSC@I|$AvC^V2Ez8sO#=m)^oA@^%kWt0ixBM
zxv;Ut(d@-8jRW@)B^u_zWj1dsR>?KCWvfz}ajh4=FZWk4F6#=$b@t^}B|iZ-AoOY0
z`1Kwd%w|5Qj2A7z?7jz;GLZ!H?ZsKM07v??o*%jvC{CT?3>pa*EWv?vgIf;!sy4hR
z=q5y~QCuK|vtxS{{UUBLDwthJrt#{V+mv-8_#4j|pA^iO5q`-&xF_NYX#q-RO8;I`
z^j=cf%RXg9Q55a{Tk42f;9>o4{ibNrC8ZisYh|@W79t6xZ|iag?z`H-k{(vZz(QW|
zuu_)Th2O;KRTBYj=toQn1}8o8uu@C1)Ir;!qlme|{3qcP*^7_B49;i6m@+P-uoukZ
z`@=k5hj~1^pD9nnUK#l)m|H$u@~9FI&%F0hWmIx$@OSRhvu%GeMUE_OX!5k``|`ls
zhLS$}=mF;l9K0ku^*nUpGLGzMw(WqD8eMK+d|?2_%Y(H@zR(>?v;{6OD=|A^+GOug
z;!{BkJ>h&%oA_R@yCRt2vI*@KAw7EKyLTvqEekou%7YOF#Ai3U(&)<`&{w5i-1?Ye
zi}Z^Aw(;}eu)ei!Cq1Sl@nib_EJ3jIRx5)Ahu*5wXtg1rRi{R~N$lOnl!$`EW`Eu8
zW)Gurevf?5^{oCP;Oo43XE1&{M+4exG`}&Rd2c}Txvjzey4}sUV#2?z`PN`PX7;b&
zS2E;v!3auge;-#mWj>CXZ)ejVR|ZS#f(>hP!{eZecDDa<r6_142g@5QY!2o>VIQxC
z>{KR7(w1Osa{m<$klS`CHnAg^<=&0kP@dYQM1*b+=8Qj>OJY1?*}*}kG<Ip15(_%R
zY4RavAXT0$2s^ZKCT-Ltm@MoJ80Svj=SBj?fBSA_xVR^n|7d-j`r2+~peXJQ=DXVJ
zmrpCl3A7s^s~`khV%?`R59;_kY~b%mK)Z*7`IfiqStT`Jn`kTI&}GuIFmauM-xCrz
z@kcl~hl7Qq>{rh!NugfcIjH?OeF4I>kMSne=pQI&<+S6x+=*ZTf1FbtCc;Uc(itq^
z4=DwwgN4&9_5~#)7B*|oMH*+c+_S;4;OvWEfR=Va-S~o1!%Ztr3WJUqD7q9dluNwj
zBe<9^m~~-6vROY;!h^fChAsye2v>Q{Xjb)@DU@ybkuqq+wP1wn@Ux2uqtSl8^IEVW
zv-$liP`@6>tZ~sGT-Q2{C03m!hCsXWAABWNv+<kt1^bn_<V2DR7pk*~A7^=-#Oe|T
zjw-I=IiSKe?N^dvId9vqL=ElUCrq!mYpyMRA-sR@P>;H`SP3gRphU-$9EcvAi>O-O
z3V&Py?3mG`pb>U={>^?RO}2D@qR!CB5ZpN+5~~o7C!{3qh={@l?|M_Ac8)-f>n{Dl
z0cDw-WHlle)MW?Z8ia;Zav1R?fBdnMtM9}|v(!UyHKwt`Lzs^Y<~XEGH*$jcMeh1-
zX<qi$A?QxHG9RUuq*((628gq-SUL`wgujel<?zE_eamHG3@FDRve|0IPolYAgf_Mg
zmp>^nQ!eqJr_U=YLZ~3lX(Dvk_zjJGN&ngU?sSOXe65KBbX>^atm)yTKp1c3cf}7Y
zF($Y)V1i4u^2brA6mKFv5rBCZUKu<4*<mHmTCTNHARm>43LRx(FDYf=SkZb+G|_+J
zP77v;X6s*4On!7e@sbh*y?O6TN};$=10a2|0YGH{0E;yM!mv6kIRN;y>xCUgVP`;L
zhgKM2J=iYcrSaXs9#)mC=w_?6ykrsaTEWfXg~us99R6%&@2bl10nKP(f%X%lP@Jur
zuE7V;OV{w~gIoWy5+}B507R`b0B8>YU>!UEvQpw7V!;t5#?sCKS!abB%_&N)KcbAa
zKv8|>b>)ZfX_fyRIv})W#~aGTVSSvUIUp+-cPlid%iC@Abg<lCL0^3T4e;rc?D`wZ
z95~X-f2ovZZ0|)!JNnbn4!{CB+M&1b&M%dONhc*>B&-R6QzxNl7{6?yt0>&>?O5yS
zpDygw@O)A#07C{aJ}BYGf2CxKdpKq$OM9()D20ljV0lO)`*5qZvP^<*J@J&%7<5>x
zESnLQrJjOamCrst1zjMEg?8eB)7YI#HmuF%ol3fRR73TRPWv2FPjxDFa>#M5wG&nl
z$O(O3P8##l889y=*`{}(!xysG-cj;o{IWzUBlpk<7W}R<AgU8hh$pSWX|1U<ys0x*
z7M>^PMjB0B2x#gobHA(HX}Q2FowW-8qqT2=kE*)*J!fW;z0YKl%w!TsAb|-akU$a=
zU?2ga1PDSUJOo69n1p12k-W%cgwSF{r4{>OMa3;v)F`M_QBmoLh?TZjX+=$2s;D4n
zsi36=B^DI){?|TdUI|*idoREIn3;3-bM3X)T6^vFI3D=w9muHhC#kZ{;#U12!GW3Y
z;q(hN)AYl!>EgBbV;v^9D(*ZPn~nlXp?LOWY>G(uAa-(;JQ3zK;`$F_`=cmA*{=DW
zsW(XG)(>K@Nb0h|(}6rCW`mykVG|7j9gSGe%YheLK&jDTKH@JFPl93u(Ju^JGC=i?
z!?CVHYSDNEk%OqR--p!UBMm{+XqN1iNrr;4+L6PtmzmUf@$Cl~@Q5R^MJ7CyKYn}!
z=;s#q9syY0;>{zm<LI0aYTbf(p@`{Xu@ze^O1x2L%!jegk(U@8iCC8qfFj_r1~p9%
zqnXk;*8eJG7B~E$XVXD>iJB4*89IVncLRaE#A)!PV75{92o7xxi<;_F#M5ys&lcWi
zDe;8NrnGp<B$66<_GoM=o0SnCNz%{s++t_27T98$QRN)*JxIC(&_TIuaoLI3$%GX-
zA*{Gud~hN*0Z{$y1c<y}*iOb?nGzmXu7s<l7?B>Ra&K|VNoZZ&V*5#)%w<6SUKtUo
zMS^rA3>!hv1do!H^FNJ65)pCwQ|M^jqW;s^R8yrzTy_?wmsfVg#6>7u+<Jx1Ph<Oi
zPldejKudH4IC|Kul+ste64NY`-`wgpRVj}byYGV)<P(#aE%4xHv7cLTAlPs^b|Qfz
zRR_nZ(-IOFPRCY50fU#xV*2d}cQ{M5pMg?pmj39;Ghowm_3y~`5F@@k6PuARKR&Ch
zxw)kYw>v)QwK6}C9gt8N59u!WP!XADp~uCkKsGFEuK8TbrA1w_sp2^}!(plt`6>w;
zQb>LpG~EJi#!+1us)_Fz+ps1+TKOT1gDHD3b@`vk8?WFG5V0HugOZ)E`XV+1k@WI(
zY@X(A@FM9$_@qsH%h=PD1Q>o!^F`@dpvQ8(`uQ&a4Zm=ljZJg<<G-V<UoYEoHkLw~
z(-eU(JI=<EK^ILjwT%X4FFv}#vQk+s2RL6{6R)h%>m_tSL2{{jrnMp9Na3<~n&F<g
zF20+LxlVL;#X4i#fcd!ZloS7^E4CEF822S8=2mg<m(aLu(BIHPr*4b~<Z^;X;K}g6
zm0oQd^&%Pni7hj2ir0;x9-G7x0yqCBHX*L}W;ysYlSS#EZ#H~G>WuHDAKQKq{n+-M
z^kZ9h`mv3GGQqSxl70-?5k(ia_M{72F<wAt=l70v*AE)&uJ0V{uI^*qrH^$_<XBC6
z<3+#E*&xfl_@MF3Z=Gz6Wq;@=Li@8ozhw3X8+QQn3cIRw#^bJgKPD%ARXQ=H;9d8A
zeR}lBf^#1>`az^``xN%IL<PiE>8#mwC|>mW46beR$-mRt8eC^B&tP<^`fLUpXV5rd
z?#CA3QB^-ijA#`;OvmD>L@MH(Khuv@^bq2XQ!{<U;QlO?NKCSr*q==-rL7fWia#U@
zzj9KJz8G}v6t$Qp0{vO9Y4bzP=*MsUh8ki(vf*11!JI-JDrcxITQN1(C7aE`xAS_l
z!(D6$9OS4An{M4IFO+5mZg#OPF_jT9+MN`61s6CnKz%5rKH^uwlTWvd37X7EcX7Jw
z37N%^olct!v+P3PE$H`f#ogK@6*ML_LHuYCD<o*yMfC(mlz;OeHZ(C3Xi7{1FugG4
z5@ArZ1d%?N<+{2og;H<{$s?c(a9&^Rt@YNlv_XOBK`FIM{9-Umfu={*ON)mGu@uXB
zi<&1+okx81qk|c;&Ls#(4(m&w1vzZC$&o+-==%gV=djUcTMB%+Kvr?uOG}6ds{ZXz
z=D^S$d8`z76EpHyIeu--W5Z1uk;P8ru_Thz`sE>Xiz}aLI0p{NXHy`Y-ZYH$2hV(X
z7|Swc%J~k?PSANkZbJA#oGtq=R%4W0d^6!^zOWat(Zc{iisVi9B$2RF(`##*y|_e+
ze5e$K2Q@g0YAW4)Ym}(s?r`xK@l^pMriH2Y6+?%yID8*HjOAr?4^<D7`+5%|$WeHL
z=;@Wn>E)Ih(<_UZUa6ekDKo}YM)Sk(a@qMn+O6?{8HEh-)2E6xqp&MJ9Kq5?pE8d$
zTt!2A&(sP;+HP!Bi|rGk5mi%Sg1Z6xCV37S`9Re)Y$O{Bj=x|ey9u1VY!n-8QuI%e
z=f)QA_H3h@rFDPyZI5!7qeTpD<p0a4`ir>HOiO{PA{{vsYL`j%T9eGHct+%oW_?pq
z5U8JKrl?t-M(71-vKeCjXjW#Km7vy(L^qaZ*Jwtb12nNXm11;zDGJMc@$G1qo4rOe
z0HLVZj8#(k;SULN$w*m;%Pmn+%mzUMlCWN1EcfP9#Vq5xDBPHv5Gk;t|L(elSy)Ff
zocU4ZDtnfz)XP=s{f#eS*N&)(s^jTd$D`Mw4=B6dP`nbe#xxk1wLAi|8uT(itmXJ-
z!cRYawk0U|L+w-M)d{$tl9Qb|hV@Q&t6@AMKTEnU%pyyz22YW=Weghz#D9JayKNxy
z*CkK%BQ&|9%8Y-8?N<0P<Qv)Sim`0qph!KO3N=&{YzHD#bE+L_V(QDqt7F;V;;0uk
zax;l4iMx{Ks3)noh4ePnm5cu4SSCCj%f_)@IcpPCm&^??b<{{KcUx7{;>9@PMLmY2
z!&=ckj^#SmC8#zp3M%UWl^7d@C=A^x?p$GJLdrkK#<9oE>W09&@oXc4HjDlfBqV0w
zqg$c~_;9$zofBC4kVu44?Gz<4>WOhs+?1f+3G)p2Isak`OHeljE>2)qs;14frW4eT
z!1_rn-wYA%!6_*6mn#^_ieFyAMtxVe<gFIm`JvP3HqkVN6@bN~l`ix41l{B;0F$#k
z)wBcLBsn%c@a2yfEO&N_i&wI-;6zy=TSXP=My{X1T!YTTLsreHp|f%oTwCj4KNc<p
zg`{rqCDu=4<XrvU3^vlTD}mROKU!ZATfs(vC5@?IV@-Q>ZX@ohV9i0nBW*fMG+y)(
zlcuv#DE#B;tbgzsgPv_qsI_;evl*7Xp`VjyNWge!00Yj8pU+@908_*`;`T{&FFva5
zPmro8oaUodQ3n8&V8#d@*gTUVn0cr8dM^8{*Fn@Z9ZFE}2cZJN)M55?7&Az-q=}Sy
z0HIq<m<RB}e_<ZWvK&i*TiwEi5Q(0j$6Tgkw370OGbF=pXqb;D^gQ1j7e&`FC#gwr
z-;AD=lSUWbYcRJ{;(xATh3I0>HLN#S`awK|(~O!m6QRmU!{9+g3Zp{ie8_HwVOZ6C
z76Y}9XFhX5aq`poY`Lo2gbh{BMA4azJuenF>KBV$Mze@6K03HqhE*EU)b$cau4P<*
zo&p)mD4e=LZV&(@MN}?e<Q=(c0UL~u0}I$d-mHhmlD~!|V=bbsjFgMAnLZ+WA?syQ
z6GbV&X^Ke{^B1ym`YmC<YavT3=utPE$E8QBF^Qq2n4u=>VuqI3b1AgM=%Z#aPNr%i
z)+L?-;?jR6N1}p1qQ7{NlBi$k1RkqoPG(9=4D7CBWwGWo<GJX)jJ*O0>2J%}ctGmR
zlQ^Ci)?;Ce?=$Klk!Ffj^<d7%qu+#Hr&^V4>M=*jO_XMK_cpLz5S@BAu!r&SVgp-d
zEs{gIZ~?X)8yZ=rnBK?=3B$WVwS?X-z~S~(BbH*hNNHmIoyc9%tyn1)>l;|q#OlrQ
zWwPn=M5wA0jTq@)wJ<jfl?#1rT7+U}Y9cvs=87>JW37SRJ~qW<svvk5in^67joU0a
za}$-h@=3-e;tb8FInGK{DrJdYmncyKXa=qRIuWu^ZG$;ouazv_<dt>$HyBImPYg?r
z4RZLF<%ziOlNENYln0x?u4Gx7pZY|JHhSeTt(MJ<SYtG^Hlmp|dNZ))TT6BDa~(Z_
z9<Eqf9~{@|HkNxSKT^pO3RgkAa*L^}SpTuG66_vqJ(*%R`Zgr0OAS35-32Ye-j?wP
zXVObpI&9Fv=Qqg6#)uJaq;dIGXrVEe!SIkntoS=8#%jn&%6_YwH)D`8<T3)GGQn4~
z;iGyiJhX)}IZe+OS^h=}XA4m(Lo}~uWu}fqJqqsr)vPb%t>dfNya-g-YP`MfM$r0g
za?HtZ=-VwDaT|lzT-(KmH?n*XMR1kmR<aUD&tcwWLx`~DBDb9tn|CCJ4I>l8&)U)H
zPVs0v%g0A&J1fja8;DauFs$m?P^t`N?As*<-NXvDT?D8-iMVB~x`~Y%Dr@$<pwxL;
z<al6z^6E{jEFm%;<vwGg*=txaOi!*`!zP;c(|mQ6mN>G8#ibm$1cf;uzFEV1^X;Ip
zN@s9shTjYdud5nG+s*89SWWG^nPnzKN;}FyIf{Xiqc~)sVrQaqn7;C2#H~GM3~kXZ
z%zY_KWF02Q#g1Fp>>$zUcPnF;AREW2%Q3w!6{i2BT-?lyvHI$sj}5QxDLIsKI5I0|
zjIsRtRyM=b6@rhh)#__(^&VQS^HGbwYc2c0d@<sYJ+SAeY+IZOE;KSA^Nn}0-liD4
z5O=Ww$uW>q^!ymQvjwC&qu9rHu~BBtZtRAlyID3QCLm8S^!Cd<Er`4)vue1-vb&ip
z4Ky@_kV-tlg8;Y}HN|14V8D9NS@FBO+2twonL2W+%%^K4QBaf=S!jT`_-L&5_=I~H
z^kvk5t(X@p8Fr$KNts3>>1=xtZX*AeY^ZqYKFBd`;)DBGt(J{Src67`QVM^`axR;6
z6?WlF3I>bB-$;w(!-WM<KOF3}Sk1X26!{feP1+Q}yWM=*hG^adX(d@aw29?wbQe|S
zgK4VRvk8ZtBJsf{FsTxeaX%YsDxzUZTrL9b+HgN}_IKNR^2TDYMlwTGN<!uJwH4po
z&)CpXdpCV$X|Rpi`kgq{r*zY>7Q`Iy0N&G7#V5aHx8c;=`~aIw&Tub20BNeiF0F$j
z6*qZ-gw1TNseRm4MwmMU)<w|EIz>as;H!e>RWNlm;)Eg&6asG|04k0wxUTe2QX|T-
zs7GTYk18WJYADoc9r+^QL|-svPE%6_(n(DWc`*4Dt3{PcqOl0*Nl_A8aJEE*X55CZ
zLc<LRNvJnjjUciS^{OMhs(ex{WSb@Ni_f(ybM0bf2Vx_?aJ^a#r?yugV*Nzg_3C01
zUaYxZbwclsXN78B;0%nSRqJGrXD+U&Ta_4b-6O05sV$y*gx!t!<>Md4?&jj2NAXY-
zA3e&(z`QzR3#+!($j(x5Vd$|-OWDAqTNrZCd&RuR*dz!C4?G5~PJ?*wF$g6MBKC1M
z91nMF!zpCe<IFX{Z&!<r3oc4NFYWB@b;#Eh#5KQO_{qmv22gpw{vqps`#9vmN|F8q
zTMDdt>Iq274?V$b`u9Qj_{$S4FK)FQAQa4N2&pDe2pj6$vkhCLQv7TiG+XQF(ISYt
z>JBzYjQJJo+rAkwnCA|6k5bf;2vxnP3Q^>$5M;J4{5+@5yBHcWg#T#^KO9F{xO~2<
zV4d)r9PE#lnku>**Z?*)flMV7HH+G<r|X1pNrc4r#p<1j_kP6&q-?aSE?HiVCmCu$
zPfMk6Jjt?>H)F%gSH(D^HTo%N@@6shNeKFxqW(!70AcO+Bu*Ba#qlR0s%;kWPeE+y
z5IIk=e&(%qRUFt3ZAaZx(A%C79Z#`>dv`!JbmA#6#*GAxRFS@&CH388SF@xE4MqSX
znoR(ynbZ<CWwR_b*}e$#362E2Fv{kp!yc*Rz(l(%IX3ID^S0{n$B?eb-ey;4O8!nc
zR!N*_Y9zNRIAJKtHgs>=ZdbPJ<*S}%ZhIJf2q)LnP${-NEvMc2G;m~x_}9~rb$96H
zhdzUo@J`IV`B}`*_Y6xjAHc6WpJ%<rW6uCQ2gTlJaK=0)x}ITf^GUq3qht)G1@lsg
zBB(jCc$Xb<{ldc=J-To>HV?&PhsBtsB|IXFFXH<R9pZy$S)aJjBV`x0IUR?qnLDs<
z`^16&Fjo!*hlFm)8-Z{(;6<pGn(S?C_P1^jyLVv3o5h(I*noZ!ZyPDZbNDwrS1Lu(
zPL|Q1h8a9!hu$lD2&8-MkWJ+LRz4?p*2d@9U~M10+HY6(>#sh0j%6(fRaDcFrHq(I
zC1O~X>0i-$x89*PX|6%EuZWHE9q>^O=)GVuMo#UF2Jpz@kt6>*fP40(bW)qc#pN$x
zQhUV07udM|;R#$Cs(}|+|Gwcu<0zRI#P2E)dLjis7~Z)N>wHk38gR!Z#7<}y4vANH
zvVLjdZvG3R9Mb18{nspg+8zidAe(^vG~^#tWH8b1#TQ9wnkkEXxWE534jmSb04o|1
zYC$<1wY4jIZtY5aYaff4`{M!3{kV8L@V}Y+aeeOBy~xt9|NlAnFe&biwAeCoy4gb8
z#cUDlcv2rqI<4b%yPyw&+Y&wohM=NGuVd&r?xW=HI<X6+xI@@qVkr|tFLhRM=>_`l
zgUk?XUt&&Ys5Rvb?b<FoY*1vEoiDN8*_Dxd)UfCX)gXcb8$WP}-7GC7^jJAh4PCS=
z7wvZO&~BC?uG!7fdGNhRe9h9!7W@TOwL^411&wFLZWbqA-VG&7j6;}T#!U`BN59PS
zBPKjf=75l#^%5MgJGZTGS|ZtMQ^O|l_{(fu-}82L8gU2&>-2b=Td%0`=?p?aPvJ47
z?_uluY7W&!Mg2viz(8`~ukER7Kmb6W<`A#$fw+&)Lwj(8<QM1nu%TAXfjQ%nD&8Rq
zUcrr$!y)Fp!paN$AtnE~MQzQ{Usj>#su80KM~C0Inr~>RqQUybA6{VtBTlm^4n6X*
z?Kf-%VhUiC$B`86@poCaDZ?S&d>3~p_>>RR4&g_p{-b@8As&$$U5`vkk~-r4wtBK1
z>LkO5f!>zG)u;_Kv{Sh0OTSaH9g)m9*U^I+=VJ0;vbhc$!s{c@sCf6drSFogQ2W$*
zvJ6Wc9SRt_cf=6LcZ8zSP1Hjglh;sGpWAy<iS0U-D3UWyr^v|%Om0UY|2?+Sj4wJ+
z_8(^V<3RBNIX>NSge5}2d+-R9n27s!1d8HPdb1Ta@;86T$cOdxhd7)}75$GwR@J?C
zaJ}@CqbyCUpyi$AP-ck-kK*V*SG;kQ{RrZ5?_(_Yn#!oL&hH7I`8s@RP%eC>j#!XL
zJBh;bN_{zE4+gK)J$iAE==TvDAYM8KG21JS9b*IfHaOHNa~qd6LOl^7MiA`10Tjk@
zpn)n46q7%Oc(7b-{1~(Ji`^fyAw_;i^y$fOf@(1p5=tAolmD4kI~4rkpy@ZI;tr+P
z-&y{cFq-Bqh9FvBC4JPxPgCV@-*SgqIJJ@TGBmd8L3`Kg!++@SY*gX8sF|;KM9zFY
zb#FM%8#7<8R~>wuZH+Kj+92LJ&K8W_7zOQ3J)ylx2OoWyHaisjVMeKk<6zp@@DElp
ztIcG@vMz#P3S%)pWb&0!50$M^<4whIw*?o9{IiVFZqqy3M$IB*>L<XO4l(N!9A&qQ
z=1*7|6zZw-Jl-WsTUEr-_@+04A(e~w@IJvEdA8p{g$Ih<6D$SlXl#{{@JO%sQ<!-Y
zAa;tYPOw3vqN?nSg2AqyFxaIJZI|A3=Ly!EZk=r^@;e|xI9iQtPEAMLdHE2QY0Om~
z`A*pr1&Y12bo+v^*o$6*z}TnvNRLc=%*sBo{3P4lzCWtALyfHM0NQq|eITkht}G%t
z!}z-w?~E$G4!0xWv8^+s^kv3M8G}0*RsImo<xFrcha%>3MxV<enuAlg{)uqg|M(O#
zbBRzt!(BWDgXkyRpD}yi!wxlv*aV`OG`50_W>HS*`YL3tKPIX_!*SxcSpOLtIqfik
zrGzWTFoLjKdj$e<cZ)$<ftx{0^f;A2=}_<o<lU#9awzzN$BPMGUBOX}FYJn%(D|qd
zok#f~c#R3c3MDk5C;!RPQZXW%I^MI=Q|qVW5;Ra0n--zfKKLi5dszJEpFn1P3d1f&
z^<@F<)Fgv=k^aPhw3;NxuO^AMQ*4eYCP}<?3No}u{PPq`n|H{hW|3jLyx#-q;a9t%
zzA@vWJNOW4Ni8XoPD0~cuEqzu@<(7nyxv!Ql34gJw!Fv@Rc(z8)l!1h$Ywh@#1y?+
zN|HGCVr;e;_-~e9ofcJBb{VQ0*`-l8BdWMWyv$%%67dXZWa?dICW&YN&04O>#!pjj
zl9HPg3Iqf7S4%C9IeEzNLUCiNU_1h&?baGP_0RGnHVz_2x+qW{<@O`Pxt!n+*eM{E
zK570$XF1{wHJ^@2YKPfrSkq&Hl}TavCn^BD@}tIHlmsx91;<{50S3WTrjMN-ncPW=
z`}@aStdF_9wPqSZt+YThXqTa=WOSaAB=s6Y<_J!0P7TzEv|}P7>gTBoX)nnQ<uASr
zd8J7JE50n3<P$Q4`o02CeE~-80MhrAQc5uS@ct{syu0ncQhnB?KWMhCHTpEdOJuI~
zgrg`GKt%c9uTR<ccby}1K<RN|RErB*!D$3ai)zDxGpGPVaBW()sY%MzB-=tMli@fG
zXGL-2wXwGJNMtKSq8@}oTA|~b!o`z!AjQI?zcBR~qf|tp$}B>anjosoLI*)qsnLN(
zk4$rul(|V#MV%elO|j9<41a4ajD-*wBN@plTYd0jonTJB+=lGu^OMw(vthy{H8)as
zt|-Zqk#HTkXbc1P$|N<|5WOJ7QP6|=dVk|1`|H+{%2Tg`dw5d=#_XDC_}5#M%E+{7
zdMo`RTj|kRs(AZemeyNQCK+N_cz0nW;?94?^zMsImOj0S_N5OhFZkI?d5wNsXtK@{
zi?T2{gwT9xI-WYqcZL80S*+0q=#CuV55xvflE^yE7DGSv^V6)z<V_N<oMv|n@kZ^2
zhMv2jL0{O0q`RjM9U>k+!}_-`kHQHGVO|73?Cv4VVY)*r<B#fq3U=FWM!7b^9DH9L
zRlc*QF>NP<NhKOyBg#K#W1*N`1AA5&OFZ#8ZU)yT$yC51<_p|+t`o0*1wG}PT`+7|
zpA@`Ff#iRxi%o;3a@m(GU0nSoOV+>Vb~9elIpHR;?Mvv8*Hc@tGCYfRH;AQYp$6U{
zZa<5Qw~cx)N6xaeg%F#7WuC=ICDc7(dMXY!v`M3^{4kA8QNUbJ8!QwMem!6k++Y>r
z$!~EK@OMEk-Vrget^c<Z+a@Qr@hW5s_~=VEVD9=PN@?w>MIJarEi=qp?WCv+Z4qT#
z)L^$p4R&kfVD&KS+ml4*E|x8B{0|!lJ?bO>fuVuaRQ{;X&LmxGl4@uW_mJii&PV5<
zb(Kn#<QUSkb%>gC&@6X|)#q?-+a)%hW7+t%`yAGwLmWPbMp23L-uQ5x$7;&DeGv|N
z)_K-@Qina{u}`Xb94vQ4p&0Z+-BFVCnpm2hgpwQV$}VFXo#$Dv_B|j`1|tiOU7GIq
ze6H+?>IeG!?){)`>Su3MxqUtN;64ll<@O~dj}(7_Dqh_56|)!ak6Mfav>2U1(tIFd
zF*^0y2MB50Wc8aYY+vF83vcqTnX6Z%sIR7bT9@joN@P0fgIy(e(A{6N;dX4@RNaw*
z#&R%;)Fr(|m5p1)mtV7a&`VCgfE76`nlG@7s}4oY$=}mWl0+)}9gZq@tmoX1>7zep
ztbyesr0?UR&qbD<c|0llI9thZoIRNYp;C2X-<&k6ti6bt=opgP0~w%yXsYw<5pPkU
zQ{vN$uriYP;~c7-iW=LQo?|<skL^sbqi=wwU83U~&?EVg3Rz6)>Nd)8800vN@jNXN
z{b#zEq~H%i{<v{+<fa&>f<HW{WSEZTjFg2pv&eO(JCGoSFxELfviKYvJ0r_S9=MG1
zj>z(AiW9{{1So~zXb7@KN{SSx*!vYw@W8jwVY<b?zQwI@Bnl~MQSH@G_Zd!uJ=6dm
z!S*uHHhyO4?QLx2Gkf<8dk0}P)2U<H+ZwlTyukaKvYjGL<prjEr<khp5hk}&+^F(_
zL$c9vSg^}QpWQf3uHIvAM1$gUmG_?p^n`_E6O4ODBEfYVj5wOBC~i^cxso5%c2Uo^
zi}bdOBHO;z#0PppZ6N!D*C(SkQGg^|i-+G72Hy}ah8`>Ks7_0Ic3Pr$S`yjm2s6(a
z5o$vn8EhJoaqY73^B#i{cbIuP6h%*(c_uy%n0ZNZDcU!cITic?8H>xEN_j+A`N>c~
z)k6HTNy})9GS#VOk&U$eSW#RM_|R=Dm|mq*G+KDS)YVS4n3#+_YwG2&#8V?$6@RjD
zx?%p%!gJjr&J(=23hT5}k&2V9vcgaF(24#efiTZ56F#eAc<S&9^hk$@(7@;<L7LWC
zPPH)jVp`J@Jl3slI>fdZVA*`9crAu!Cshy(raF~b^f}k5%#9ptRxD4(SW9C0K!^jC
zv3fm87ztfPM=Za_gt-TwIK)7PGBr*yo^iMFnMJ<3hy<xW&C0^2sBvC`vU!}K8h#8z
z@q}BnizLqb>EtaB_f$m3OkSs0#rc3Myxp4FU<d8lLj<ycnxX$p%bg1Tu)G`Wctg#b
z+MEjhB>6#~t0OzJYP>2nj75dW@Cji-kF~f#tkHO{0c)J<6oPALnP<af8eDe`HNDoU
ztPQtUc?~S?ZP2ePYM#+jx0~+ZnySSH&(%2)ts$8JuXC!CqWaO#4C}&O*u_&;J}$Mp
zxRKg`e6THTJMWEy*sxxt#_>4_1JDr1bK2KO?Ya#;cijd|1Z%Y6QosdAM_3FLkpG!B
zITid#;Ns2ZsFurnwu}v?j6~BNC>YifmlH`2ads*bB%uZc-)c-3yg1L`zhk#WHL;zV
z*ntkEkiI>li5>Wk9_bPJZWSv#bb2hlL1U(!PCcAReQb>8kQtcNzlPG1)rh)yKGJfA
zGDgX?WV_>eKZ?BbempNU<;RI(EG9(^O63WnFoCDRxaUU+yk~B*^0@z&n~XaCj@)GH
z#Oee-3<m1k6L>xh$=*-kqb+;mg4xK1CGrfMcq$TkAq-$|Oys3FFT9+H8r#G_6M4C1
zyG{MQ`1z`sOmVdxMR$l+J6`S;TkL4=xcIXj5IrTnrC({HUlKQRj+G0)gAau*bBBW$
zLDehY#3k`0>_B{<0c*U*By@IAJe9;N$@y(VJbaz9oqQa8zZN+GAGkQ(<HTUg6I3J9
z*e6cjAGpYp`Eb*Q1hF>((3_deN%E~v=ExtG5X>?5QZnyPhVwOvF};w2i)Wh-B!~wS
z;c&MnnI~wI6x*blW(#hxXQZIs&QRX5M^jKVB~i?@BcjkhQb6yKWUUv!+Ekh-j@e@}
z#L8ZLfMsf;`l6nv<>g*H$5N9R%tdDF%?m7>5~Grj)%ONHy9m?ZBv=(cg4AOs7@i>o
z*?3%=sHwc%RB5N=V=l2Y6+6u%Zc4@6ai{fMDlf7WIfA*z)HFWWQtAli9=kG)_raaa
z;xs-0cZ2KFct1-fFH=R$yV?x#RT{q+9BM-!060JJRv$j!q!tBoGx(jVnjLtlAFncD
zUVSq8{#a=76ibDu8o&n%+W=mHYS#|nH^aW=@Bl1@JJ4q!zeP<d<w|Pd1hO&Jb@jdy
z@k|zf0;>9Jvib9viER+CHqWwd5KV*lu-sQ)%cni4tUSDY{lb027yT6*NU?kpllkyp
z{(KJXOzAcB%!biVKD9^e9>m{Hx%sNqH7AaZ|CmaBGw4E}_=8U?s<>@1uSGbhe-7p&
zfMKp2{x5{zNX+Gb0HVE<%Qpa4-XZ(}P^H+R{Aq****TP-!@H;R_{+%4zAT^5Rn@J5
zy#+j#vLU=ToPVlr3+x-gUscu3fuFkh923F;zCW5TQPq8ci6wl3YCd4SN$g1D@XH*-
zUq`gk<zx986%^x(ar_uQ4wmx!5S6C!GLD#8ZgK3#+!^?GJnw5pK+nFD(6C2*Fo{ow
z&CkGcUWeeAx0UmcDWceKrtn;`5&r?X@qLUlKF$$G8e#QiMfK8I5LCf7m9NJ5Z=Z@0
z<pw^V$~9b71upyuEy0kyW*VPoZsV{_nTCDn7l)>C$`_Yf!B^pq?d}TxQB0|-V8W}W
z^S4x@B{Mn2&2FE`uTe_^@6P0JtH79TSMg)*(b*5x=%1G8p9m_Vro#N$=V`KJt1crK
zm60gQg-Dlh6@VdKYm*C3=XFR_Vgx3aS;vtt*n0yEB17*eY@?^w%2wpJS3MZ+Hkx}m
z;`J!^D`MSjPA=Nd%;uDg>6_WyW69>KN-J`C;ITP;Bstl=KaYQn3BPj<-v)56na>Mw
zhxhD!o*UDE_O^>7^ErYs2fF6-Z_K^d#VPhlh9_P)JJL>Jy^iM~o};DSHAftt%TvY7
z>mXD4Mcs9LGpylERh+V=R8{fpwDoeG#?4uYgnZ=FHW8+a<fXnrY_8(>#GK@crCR)C
z5l;<FujbF1i5S-M98kWTI&7y7aYG&VBQm`Lq&Qv2$w@KR!|OqieI7o*u@T;Xga>*Q
zZWRs!k9oMux>4PX$M%)3tMBeynJoV9;jf!FqRummc{%hcU5oi_q&ri9Srtn_U$=?&
zCH$wDeC$%b07$)PDVH&Wr(e%S;&zlfkNulGvkA#Y_XN&f&u5sx0u+nr-@@~RuK}`I
zn-C3r86aS8<o^Q|#GQ?N3*xM}oA?>na1U<gW7I=|Ma_J%n!E$;UBs+&kcG~0&PN32
z<@|E+k@Obe+)gp81+@RTSlt3vaVoIAg<q#aEn#Z~K#m8lZG}??g5BQj2guc~z~eU%
zzFrKhSjoA`;;<oL(Jia^6cauVtm0!$X*OZ~F}8$XwEUPOzX@%-D`NLx6si^|_z8!f
zMur%*1~APGJi3POr(nAcw{VKX`G;G0t=Vlu8kSpm2X3<8x|MhFsWy<j2e9z!ES@Zm
zuH^;h3LCO1{*=!Hf${#7UyZI_{V4$L55)eAzl5No=D=@n14fwl;p#Z^c2I`B;?vvt
zncguP&}(j^7a>i3HTBbQtwlFP8G+A#&X=okYY~{n^zvK;&94?!zm3flzgW*7h}{bd
zKP2fXx`U5a*9W|J@ZYI1`|vDH6y3>3#T+niu(cA#XNYxo@<~{OH}B-*&6{l<!m$BJ
zz8^(10+(;#y~#ag-o1dxLGjwXywuf+H`x?aeLLObWGPDe+*U8F8E`pr9ItZ4K*6sB
z18)+1ERgX@!55o%+IETL`*>bTHdF%nnqtcfg;4Q%+=03GVJBiUZP~=*R80EW`}s5=
z$Hn_`+jda=?w5Q*pCVK&(v;NkFn3-V#0Sd8>=ykWz)p1s`flc5(VFynh`)!AGY<iN
z$7vM#aapnw*{7BSK7W}1NHv#O{NnOQ_=@-vOS()~?rWt-zk38k@TACjl;=81(PN3G
zSb~uu++xwAV11{=mPh&hnAqi8c#iqJ?V`Bu_k4y$i$@%m9lz)2EX9uanW7_|r-(PV
z@<E8Qe5RAnHpP^oIb_p$0_4#x`fUTEAq&QSej7d#e+B9fyXs$IZ{gRU_*3y|h(Qq4
zlez<)Px5z6z`kuy^IB7pDiWUIi@-XUKf{+<rdlk270cfOZ8`T0D0Q|N{VW$)g}0u?
z2HPR7dy)SvK3TuxQ@P3XM!q<`19DN382=nEL3gX3<3r6Q@ulL4=dh>B#Np@ojWHD%
zY?-KjUeb{po=0zPap-yMO1BvQ0>2R-zj*=tK#tiNsMrYv0*|=s*TDX%5d&ByCcg+_
zLylrIU{xW$c@c<&lwLdd81eWn$QBJW4wv|77rI(bgBdLPzr<tAZSkvvBU<<psKQzy
zUgGaSDr?#eX~QG7?*=_uFFxGO`wXbTXv;OF7!hxS86|=QLmfZ<%-1UvvHE$w0NzUD
z?ZZ{G`0#mNjj<njS<a+#PiQ6rGr2Et%PTzBgj3}9SNU)_Vjg{!?=^wgJn}n!hdIq;
zEd1tpW8pi33y)N;TO(FJ8)f$ix%Nm~HvTpKts1iz14V|NABY3nBXK|g2ZqD^{oZ%^
zD0~FQKE-#cru`OiW;?%CG`-1(qd$ou1!BxwIPre;CeN~@8Q4-t&x%lD2O-T!y~J~G
z@j(c<bs!Rf`ibPXfwbR)-8&=Z7{=~S%nX@n^qKWJ7>V6+f0Nj~{%>LI-qU?%-oU7L
zd82{in85p(z{l@FM%IxX!+#%ZvDX+pz1{IX<kTqK?<bNz;KR)GwS9p}9{|G>4`NJn
zH6=ZH+RVuwPo;R|F!+O8s7Lrz@*|jb1f;xD>^cH6<rZB>_>(v@bbQFKv?GiL4?DD?
z=!FmYQpf_HqkIm6ouo?7*WrMi*msowEi2+lD9%!zG#jat<{f^uNDchv82__6=!X<d
zFB5x@@$|r7KE`h1=WWX&7+6w-{S$DJJCE}#@Q8T1#Y2w<iI{)z(fzzcj}Ic4%QQm>
zncU*>tb(~2MVe|8*ZzZ7pqhtTiq~8E-9LCacBEUxeZp(g8>s#v)W4JvbNeU!ZV09Q
zP7qra^(XiO^U3&A;*TfzugquSPX$(-<iAo)nneu!j6ViK{KwCDi)!vdk;_kkWSkd|
zo#KCsIgHg<9$51)eu$Xxg3~xo#i$7oK1B7G{24LibMSCPM*W;u#>9jlFZ+W3oNM@P
zdD}Hxy!8dB>iRFZCeqJBXg?!vI?F!<7p?AsR8T1%?gDGw6FAq!>rF|HgvdqgvRLxP
z-hNtv*m8~!!I<7U$M1?sNk~h0mzdxv@xXbA_$8v`EB>dLix_HKK>M2ik*L~VFW}8o
zvHT*RU_NE`ieF#kA4A%>{~JireH}51x>{3`C(ZURYVi8VPAEuvb`IBWGTHnIDSgH(
z3gV(SNp_nO_=`z<H#Tj30+^t&SfmkiDSA2-xA?uLjYEhA)v8s-Wuy7Ev^F?~?zo@l
zi+inFJp{AQQnf5GI8IB2>G=3Kt=NQYYpde4vY1>{z&%);1_3bew>YiI1h`C2(Du_#
zawKZ2=yQFd_G7?Wvul%3YPwyss_-zM@6ZxVko}fAwJULOc>y0deB9ehn-`OhRyT=-
zy)@!aANSIVAp)lN){4zt7Ppw!Ticpigc6%+pgR&2OL*^eiR4u6Zy=r+aB<9DtfNiT
zJGH@q8EM+}#H?THqy5ReFJXV+w!T_F)4&om(*f~d3VA;osYY-$?QQTkfOspf_kO}6
z>~?L4_+u~39hnjOX^$ozh+b*&N<VEGR(ME%&5vYp5BJv|!od;^Z$-l{J=ibFr?WCO
zhY1%ewF9-$>cPM-2Wm%D2xhCYwclf}Up`1%56~SLq&3FOMdj^*@q@LaW=th>DAvav
zxNfL6m1gino`xI^fv!AFHG|pzXP9Q9liXK@+BQfMTZ**R$a*kfxRwF57vo20|3PZ3
z;*nZk6K+N4jMAngHK6rf(L;NBly-&LnF3eik-GQVL;{DW#U0>dv@A0uf&5bKw~#|m
zmuhQbdUv3Oy~txTazf3LIZL7HU5bP(zU;tl6Sc945CwjJ6$Vihm@r#w#)t#Y&(X$G
zlE8n@)s`phL%lFiMB~+3IdJ}ktF<afE6MY;i8#w%Gf&GfK_0kazV?3dR&=%>Vo{V>
z?zvW5q)rXIel0KxAdO!L1gi+FTc{-==6&FSO07VR*^i2yfw!*Hc9{U?bv4>ti25Ja
zXeJYGtUjvM8o||P)oHh=-oU{+?G+@85ce!bJLiRc36Q=`tX_gF-WSoz!N6lnGz;p%
zzsajrsB;5fd9^Jnj^+<7(=sgU660gVtIM=1(6{wsK)trbdMFmcDWT^k@pipd3Lqpj
zpam@7+9qwbSlpyh>>Ygf;p2Rhc70rV46X#B-a7#SzNp!fExv8mlEvfA+HfrLd(GO-
zRJqcpy^oKQR*h5?AGK<S@atv2_Ax#lzCqg}3G5Xsv|mER|9FM=9_6ukrA>PbiUHyI
zvGxtfY28n>wd%>hr$5o$7HmS-8tpF(oAB&y+J4C0udLG!ppor?J8st=FqzjS?g-?s
z*PJSz?G+R6(7wc%lVaR2w9hf6VRvfCIIvGF*q~9e#`7Drry;FAaTkE!CEmFUAT1a7
z-mTq-cf;<{wxMcg;Qf2F<t6~MLTERbVh<%+l)?<r*`Xx|4sX)hOy<Lh$He>x0OON^
z#~;wjsN+-Ov&|p`U4fPdL1l2jy6qwD&p2R-1s%Yz^Wu#TZGOx#0Q_WN$Rk>-hB-g<
zq!w#Uxd?n7hgcynORa4)Vikb`?9}cf=gm34*6NTL%`JBSTB|o9cSvqP3#g@mV*zc7
zYKpf9hVIgy!Wqdf4!xx9ipgg<Z3e_{?K71WUAOMhhNh-xkyGSVptNw!vc(`xtUbeS
zQL@Bqd$eIG^HmoTX82qYK9YGZ@y#Bsq<t)MVAN9*HBSZ1QLFVawuap&t1F>cKs=?D
zlv|@7$1s_&g0he;@z&PVyJ{&#h714QfJ|u={t5dJ4uE<ckM9kaAMxF5U|)??A^48t
zl3r@@Vm$LU4xw;SOFW@09B84TARn1)z%&*ktr=VgYv3!=jObC~-9Koqc0Jo0{1@SC
z=<?`pj$>RkZZ*=EkvNX=5_!*Hi{+}GfxOLl3c~^@7>HFF4vp0=a)u;}cxYIB5M3zN
zm9L1JlRhd<ElASjYx1|?1q|boJO!>f#w>lUF6v0EeMKACUaGpty^&1%8(XO--%L*n
ztx2^6m@!gW!AAkvX~vWzPES-4h73Y$`CDn;D^cQl7$IR;aK0o3501d_uG9~}1<ItT
zrD~@+sY<cFb5m4Tcm;#&N0gD8p+%yFbXA8?rrL!;w;(4;0ZjaADM%-JZECE+oaFje
zflF7>7^D**{5J8MvXl5IXddp?>Rj!$I+>>V0MT&a*NWnPuMd{^OI%^sTwk7^73Kp%
zr%2Qw_tT*JXnq}3TJTP7@#KdbN%eSA1<E)Wh#_Dz4PCkb!`vTu&Koe+nG~25U~n}p
zmXp*mOCn4#$qUULms~)_$jJwh6;ncvJmme8inYcjz34QTgg#vg8H?r<ufC$CvwV9o
z(Mj>)D<IXLz=Gds2&7#me)Fp4HkaG0#qv9Ony~NHuIyWb9jjV#N((`Jy5T81HE_dT
z?K!o53UKF&n&#Q?LI&PQ+qz=Ai>UBX*L3L|NwbmzAu~F7Psu4RscCkR=Q5DJhMX&b
z$=H00C}ms01xkq10C!Zptfe%8gr9SpF%J*nrtAaADZSv^S9qaAk<g*mYLQ&AsU=Ny
z)zsZU_MWucT#FG+8;ysZgK1?k7+@;=7O|=Dl9ClRB7b2EPy}N@MSpXFGE#Te#&z>-
zcmx;Q$zar0PBdvHi8roBzgXW(<L!}aVjv_zya|aF<-DrpidM-5)X|alpU=QY>{%H&
zLWj%>Y4A=!tD$YZ1WT^t1380_l~YALBuRsiO0flg@2=rK5@eBzhl=>_G4>=0s5;67
zheSll7*^o9-)U<t?cYgVa$I(bV}pNo5Vau90o05<Ni<euuf!0;j@WXMX<|Wa3sFGn
zqYV{s(_+x-2x`#YnCEK1riC4%k$H(`acKf(&@UvX!?n01M>>qCR}fKs@pNhhYG43#
zY10bn8;*hE&Jv!w!TIY+l`g}^AY>raS?2LHlPa22(hnG=K?IszhN=loV7ui@_<?=U
zJcavp?P@3o{^xbA1Sjd&Ue`KI^X<aBUz^dMGn;nnY@*BXOf^|@EQ+gAb<JA}@_@nU
zS)gRnq{ZGAnvl%f1Te@YGl&h*niT}+Py(q-rA_ksis6t>!ln*H%H`QEiM`(Rf@)oW
z9y3Po#K1#6=C==gl1La<Qj(Y8$ndKH^w5hn#?~;%&~m^T+YS&KiwgDFkhEWbXLU`+
zzBa&9p!Y8up-IpNB}juMMJ}LB^a+{;yd-o2a-gitgXNMopTQiWvJ=#W+Ya$E@M<*J
zLR;Tp>J+(;rY~2MR<d31lbo`=WJhf<&jJ@54UjGsxgnS87`y^LvKae<>Yzh>QyIlV
z2UH{jAqeETC`lI0&`8K7QGYQgh!1;1PAwRpK;m{ACVH8UHpcLRK-DLO>ySkr7Xog1
z>m(1?>2(9>jk*@}HpZ%?i(mdx`&0XP$Ue<zEX4bBT*~7&=(}>N>Y5Tn?ws(p%#A=U
zz;YP`ki015z)WX{FtfT6b6ZTSC^Mdc6-D9-SaXY~2eKF<0B9RPL%g)bv&iqQ2L@xL
zghYfk1eAz{9_)i47nVh^YI=sX2(*^FbGE1D2CxVK9|4M++Jm$~kJm|yA6iJce+jy1
zm^uqW7<MfrA{ZDKTox%Q8p&lTgaCP2)q<c@L@*h-sG;@?lxt>+Ti<}N>=F0Bp%uq^
z7_#{;6%W0krA;qTi0er(N@R)PddVQ>b7(v;NeK>$Bsp;J6+~cK!_MnK>J}1R5W&He
z(GJ>BW|Rq1bE*|to;alLmM_r?`w+n}u<sGilmt~ndT0pZxB-$f3YZA2ki3=lmrj4N
zSz1>B*5IQgI$n!1)iwUsrHI?O%2O>jo_vAl1Yg?az!i`J{Cd$<O<_@&kb8L*c26s0
zQ98ZKlFc<<@Y*K%U3!~}GjHIyR4G;*(1xfrk3VuiQ)4#(&o!%f;!O?Nz5}P<)W(|t
z=%P;TYk2DA|5=-9u4K!_O@G#|HLte21Bd^N!xA2?5r6(G&NXWTu7lc-R2;^a{Y`rq
zhgI7<+AI|}CfB{IJs5){#>K<hK-GlH?*SibS+PeqjqcweZwmVa7JrCikO@wv|2nFD
zK~AP0AJeW*-H74DTa~<EgmjWJ5M046W_^SsyIUlGti6tL9{yO{0qs)Y7ss`DIu>sJ
z2ecJ<?mVI0Zh}hd!B4eo@%a3wT1gCD(@X77&1sxdQ^ifEwcc<*4Qx8C;lgX1ICn;S
zqP;M}%@oHUu!&3ud``|v6sl`#ojw~xc9EyvSYR9|h|B{CmisA63SivQ<X=LR4C{)>
zrHFsiR-oV}7T0fh4U7*~@il>-Q4$hlga)%)K|+qJ9Yo*LD%q&sGPsQwgi)faZe~{u
zZoJ4>+X8Q22&e^0E?8JiOCz@W7`<0u86g!NY6wq^O-_Pr3$RI-SM-_C^)6-QlZPY7
z>#g~DlHL;q26;xWQPfA~e6FJ4l|&92>%`@sYkk{kC+A^;m=7@^zy{rdK|&s)v=AgJ
zd2lKW_LcAR)_Ghx#NbHKY=$sZqwguufLsh5^P!>Rph$ibfSF`Qgy%tUNkJ5hUv8WB
zHX0_*8Fel=T!gy856=o;0bPM(yp%P23C<CqGB}L*Tjdx490;n!cZda|F?l_X6R6%H
z7L_)bu7L)0K}Ja0sIT!iVxd4STRrt?vYm<<SBb$B2}WAuMeaTTHrOwYF~~a83P2db
z%T01|^mWh+wV-PWCAxlTDF7Vi=wy^u6RsA>>4-SQa>p-`tPiN=Y8pYb0!&HAA|o+(
z7z~DOCd9Ge0LHk+iShG!zX2rt-+)|I;CiiXNF(0R;76#Pwqek}B8S>A_wdWagP&`?
zKqq#7uDuq!6+6;l4XpV>bD8=SITXvxG9U@K3!&j`1pJUu&v%O5UD{8~dsvAW^QAVV
z|1Q)@A<v0Y)EEyVFq{o(Rm&mdx3=vG-14OsXR_`^sWd88Chj|@l?=+jcl^5mFKbJT
z;@XM0HIrb^WwR%zrn|Co@(M>5j~hQpoI9rtYTw7~Bg=whav~O^li5?td^2Hbe~{UW
z%Y2iXS{r>==v(m^v%^(hAA}z3*LRB9r%YVxsa-a`sqtD*OVez!kZ3u>?BnIr+0CBX
zt8rnBNp`W~V)<;&O5@3SRy?;*KB6<S&+EI$#_2^WkbqMHR^{Vzg3Z@@U__ZGf9Zxf
z@!URhqV%JXSBoL51&2_-(vtI1_$F3Z-ntZlo%F$Gp!{r|4CoC&M?k1%x33gsUqP2!
zF0TDbTLX>h2VZF|2vs!WYpqwB4QKet9wIM953n17H;6>yX%zmiwZc;Hxj96w>L8M}
z=qEoC(t*EiF3Bz^z!Q1FM^x7jJFVVk5qCjLYhUC6cWyv*5IGt>7O)W`R<Yf7B6K>F
zuU#@!FlZcwkkut!Ut41>*rAMx=fb{U>0Ko6!V8p=&`FHOv>00icx&*o#eRyjKfqPf
zP877xOUF?RyG^FGCl*W7jqH-n;<G@hbdM~^Mno@KjAM)kLJ0h{AVfu0se`z-6rdry
z8Il_GHbcFEY5+6Z8^<V+)bd?JhFo1V?CRm+;rNCOA*vkRCSZ+_y~{v~{5Z?#R5~;P
z$kf$xi6~eMxI=Xw<Vu$zouOvbO9RI3)!(&H`Jsi<bxom3{u6ELbNh}qT|)uNOD$-1
zfdYJza~)w!v>kx|znLj8&*iH2)h<Oc@OqHg;FMh--E>bF*^D_zR5T<i*AU9b<$}Nu
zt&pd#eTWNrlp$6lM0JxNETs-~-=!ZY3HY9%g*K=hq@<Ot(NL`J2AeQou7@<*Ok?~`
zP-Lp`y=$+>!K<kS2PKJF23kpe1kP?CI*D@&3URu=BvdN_R-mQ?Yj^zlj^16RuA*w<
z4Ze2r_pc>cLZ3+_0((i&cSR#y6b?aeql^B~ct!1W?Ct{B41JdtVxthQyJ)9E#A$5u
z`{q)+a?`d;?TuV93V>&j7`b533F|Es1zV_zXd<-djm;_%e<n3c#*4;5h@^=E1?Rdb
zoC~5HHQx?8QW%tZ!Ybk*7F`0v<k$f^zYpwB*IAR|c`-l%xu=;DZPn#T^(g_RcB!`>
z83!OH)svtBvgo0cl{{pT;NMPD$BEhN1G#dMf(z-J!2l#bCCR&<#1~_Z-60f$aS`<p
z9z9MGo)$UI2!Q1WiKGuIU$D?xC{`vnwL_Mo4dJaN4Ib?zxfXJd=#Vt}UW7&=aCs5l
zpMWe6iH)Rmm%9XGG}N6?+7azBc9o7E4G8E63K(3?)+QV%C=diTYx_NNoZpS7!zG?l
zC*UtqPlt>G=oG|{R09yEyA2<r9F+W|HgQ3{=?O}<@aAf&lPVhc@qvEQo`QFIdzDUy
z8?hyZV>goli@qW0kVN1h5s_{TNED=Qq1TWnP%jCfWG5)wiD(8p3$R#FeHC#_<OoC&
zeJhkTdm;U<@Iu7`fzCtx0xsGv88QTvnid)thkoG8V)QK$oG^godW1!zn+v4As6j{q
zS56ShwZ?FRZ+v51)zrUaHn+O29wCL)JXdvL@S#g*GbFp_7AWVKYqke4(&ajF_)8w2
zXb5q|#U&#ygQ8nJ{<T&%S&okQXas?vc@iVmFGxZ%KwW_Xx<N_9aiu~!x{%P&D!RVb
z#ydf*Xg&28lFQ_YDHpVf?O8!c%NFL)n%At1>@kQ#p}u@Lt9}=655fk^MkCSn=}|nK
zIJhrN>l-5GM$`~{N~#d+P)L%V5Y35@Gl&A#d!8TxpQ2t6#)LbT$=-d-yi)Naw}h|Y
zTn~u1M?riN9Q~!t=)wTN8rsI31^Eg-D;k5l5gFBzj{YQC>ZiPF2~C3w8oZsByuR&?
zh}y%)xDaCw*dMju+HsW;s?s1g3RkX~9pbH5k0@`XJyiz;w#<p(xi^fc^5}0An3tb*
zLA3=J7{I&54@$9^&@Wt?NR&}pN^bI)3qhr(ww<ov3Y4tVuCkd^rMAHX^d}T)gcBI_
z=J*f96%Sgzv&jPG@47nH=z{cQ!JRA*eOO7@EPJSdkiev$kjJ$D9U#I+rTal|;{@U#
zlW@&4W(<jA;QDwNq>B;Lks9!qQFCHYq?_c?&(=*X=tQ2q!^Mr2Q8EmP8Ng_O3@SND
zJ8niO!VTzwtQEOqf*7Ae6jxrHVa4U;CR&Ot=*uPborEXN!T`08<|`Q!biXU)v9i8t
z1x}(kqt_ZT`U8Uq&B>rUgiQo{I^E@?J)&?8SciIX_XVxYd@9Z#c;|xFX@QP>n`$kE
zVa_M2wHPLaE|c}wmiZ3L{|J}a+Dn`^S@UoJ%rIL&hBb$3u^upctu><4Vtw1Z+|ees
z#8{VEr#hs^@N&l*krrz`oxIk;TUUCmIg<5M;ZAhvxOIUHX8nW7T%&FXe4<%hl=Xqf
zS$}Qqa3JCu{N7Txir3?;=Z1K#Hbm|z-tIs=0-O_C+GM~%kO~T#z-|7OtwxC*;!~S7
z6Ph4fJeqTh{CG@byI2-)T?I?Yf5cm7;NhkO>mac(!3s+g`o0#XY5fzeeshIszYvMm
zwdOtM1ERm(x+8U;nhxIJ!);B433LJk5m6`im^%X}?A8u5Y@}{awx+|1_VHxvaBZJz
zLpYrE=B~g;$=2VPU}$_%Z0T+NWnxSc1g%<mBHpKJNn(1c^{E~YwKVHR%RbeSB&>a`
z3*+~xsXA%fr=}$dUmxpZri>)fx36_&dmiraWGEHdv&GodGK5N%)EipT2|Q3%W+&w*
z!F)QjZ%I`o^C|)nBxXV&plF;xG>U{HZ@(mDC7wbV0!D?ymd+%l@fC>=L~Pq(_kYe+
z22_<)iURN&`PF3=P=b}s^^iNIR)YkbpdJOJqY+T>fQeWxU|=<M`MSPWUgXuuODG>G
zOp_}(LAn?RnM4o4S%UMlQ`D6L*iuYi+&Yntxjur!NFvfu?o>gPX!V7_P@YtgWCs{@
z_c_VtgQqTCDu=>Js!vI0tIwZ!HPp+J+Fc4_?W8KA&>p@5obDzX$}&=@<D3aHBh_0?
zwP53hFrl9g4M9WFL4q7{PU;G~kS?>aq(r<Wk$}1$XP{a7LK5GElz_2;1JTN%e`*mz
z60NDxl&)xA(In@9<qztUB&qd5*QJjS*DNRWR9U1{g6;^CUmj`PbR86AS^_Aox)cqm
z4-5;p4kWr@+0J3v#s$~SfH+BivKy$r8gvEs^vQD!){d)wI9eDdAgr3WtFLvm$&(cL
zQ(yQ;#4S(C@!%*=^iQnsZ%q}$`dMQFw`ExWq?-LnHG!-9TakUWEwFQd^#=6^*@B80
zS=P^faLK{KR%}ia4`y38M%tdP4qQIS+5(NScy2K0f*W6k<XD%$*#yR+7esyzM*2*S
zl`?U4<yfa9+JOBHaW2O?RJ7z;e_`>fuD>ITl{F>MXNdK4Qb5P&Sp(GEzI>}6A7cxw
z6Jb!*USQpYUnRppM*SkA(E4+jCT=UVo`vo8gGJWs&6`=Kh#PLLfZ@;l;nv+SY)Tnn
zz03mV_|qbFgf(6GMp%bK-M(2oF~YhKuVY49hk!5_j<inIDw*!->lSXebzowVirXiU
zRB2$5x=y?>(s~m*r+2-J^!NaqlO)AXwZjjhbrb6lO>XN#^Y*0u;!U^p7YW;wQo%A8
zdzTzc+Mi?-Z@V#opN+CkjE{JsIRo#EvW|h~-YJ~L*4r#as>3NBDz>i1cx=l&Z9L5x
z$S%S3jo+#Gy?l&yifZ>*jpj3*rOwnCRs3<BwU79Cto6-a9;>T$WtFr9C=M0cEdDUg
z`n4_8d8V^Nyjf~p)o*)J9_g<UjkXm|37Jl###U#CGr2?+ou$@cfsL10d&7E8Y`@$(
q4<9k(tykh>)_Chx_}DTYY@$+}9dGqw3ATyqGV4!bO88Ev@_zu<4RS&N

delta 52287
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%0D?BU5a
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
Tjuua$E1J~Xtch%9u=KwHG>v%g


From 8ccf1dfe4bcd7c781aaff6a787a7c502bc611cae Mon Sep 17 00:00:00 2001
From: pgherveou <pgherveou@gmail.com>
Date: Thu, 3 Sep 2026 18:21:19 +0200
Subject: [PATCH 4/4] test(server): tighten proof-context coverage

---
 .../truapi-host-cli/tests/live_asset_hub.rs   |   2 +-
 .../src/runtime/signing_host/sso_responder.rs |   1 -
 .../src/runtime/statement_allowance/pgas.rs   | 115 +++++++++++-------
 .../src/runtime/statement_allowance/slot.rs   |  20 +--
 rust/crates/truapi-server/src/test_support.rs |  24 +++-
 5 files changed, 103 insertions(+), 59 deletions(-)

diff --git a/rust/crates/truapi-host-cli/tests/live_asset_hub.rs b/rust/crates/truapi-host-cli/tests/live_asset_hub.rs
index 13794aa0a..c6588cac1 100644
--- a/rust/crates/truapi-host-cli/tests/live_asset_hub.rs
+++ b/rust/crates/truapi-host-cli/tests/live_asset_hub.rs
@@ -22,7 +22,7 @@ fn asset_hub_ws() -> String {
 }
 const PEOPLE_WS: &str = "wss://paseo-people-next-system-rpc.polkadot.io";
 
-/// An active lite-person ring mirrored to Asset Hub.
+/// Must stay active so the ignored live tests can resolve its mirrored roots.
 const RING_INDEX: u32 = 1;
 /// The ring this fixture's index belongs to.
 const COLLECTION: PersonhoodCollection = PersonhoodCollection::LitePeople;
diff --git a/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs b/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
index 0eae554e1..5f1bcec68 100644
--- a/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
+++ b/rust/crates/truapi-server/src/runtime/signing_host/sso_responder.rs
@@ -1841,7 +1841,6 @@ mod tests {
                 .any(|method| method.starts_with("author_submit")),
             "an extrinsic was submitted for an allowance already in place: {methods:?}"
         );
-        // The suffix and one slot read answered it; the scan stopped at the first match.
         assert_eq!(
             methods
                 .iter()
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
index 5a2c96261..3f090032d 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/pgas.rs
@@ -103,19 +103,12 @@ fn current_generation_key() -> Vec<u8> {
     .concat()
 }
 
-/// The generation `RingRoots` is currently keyed under.
-///
-/// An absent value is the `ValueQuery` default, so it only means generation 0
-/// once the runtime is known to declare the entry. Checking the metadata first
-/// keeps a renamed pallet or item from reading as generation 0 and silently
-/// building keys nothing will ever answer.
-///
-/// Decoded with `decode_all`, so an entry that stops being a bare `u32` fails by
-/// name here instead of yielding the first four bytes of some other layout.
 async fn read_current_generation(
     rpc: &RpcClient,
     metadata: &Metadata,
 ) -> Result<u32, StatementAllowanceError> {
+    // Missing entries and absent values both read as `None`, so distinguish them
+    // before accepting the runtime's default generation.
     if metadata
         .storage_value_type("MembersSubscriber", "CurrentGeneration")
         .is_none()
@@ -134,8 +127,6 @@ async fn read_current_generation(
     }
 }
 
-/// `MembersSubscriber.RingRoots[(generation, identifier, ring_index)]` storage
-/// key on Asset Hub.
 fn ring_roots_key(generation: u32, collection: PersonhoodCollection, ring_index: u32) -> Vec<u8> {
     [
         twox_128(b"MembersSubscriber").as_slice(),
@@ -369,10 +360,8 @@ pub async fn await_ring_revision(
         })?;
     let started = Instant::now();
     loop {
-        // Re-read per poll rather than once up front: a rebuild landing while we
-        // wait is exactly what this loop is waiting through, and a generation
-        // read from before it would key every remaining poll at a generation the
-        // roots have left, so the wait could only ever time out.
+        // A rebuild can land during this wait, leaving cached-generation polls
+        // on roots that will never return.
         let generation = read_current_generation(rpc, metadata).await?;
         if let Some(bytes) = rpc
             .get_storage(&ring_roots_key(generation, collection, ring_index))
@@ -435,9 +424,8 @@ mod tests {
     const CAPTURED_COLLECTION: PersonhoodCollection = PersonhoodCollection::LitePeople;
     const TEST_GENERATION: u32 = 7;
 
-    /// A real runtime that declares no `MembersSubscriber` at all, for the
-    /// metadata gate below. Preferred over a synthetic `Metadata` because the
-    /// gate is about a runtime not carrying the pallet, which is what this is.
+    /// Real metadata is needed because this regression depends on the pallet
+    /// being absent.
     const PEOPLE_METADATA: &[u8] =
         include_bytes!("../../../tests/fixtures/paseo-next-v2-metadata-v16.scale");
 
@@ -577,28 +565,18 @@ mod tests {
         assert_read_ring_5_of(&scripted);
     }
 
-    /// The generation uses `Twox64Concat`; the remaining two keys use
-    /// `Blake2_128Concat`.
+    /// A wrong key hasher makes imported roots look absent until timeout.
     #[test]
-    fn subscriber_ring_key_hashes_all_three_map_keys() {
-        let collection = PersonhoodCollection::LitePeople;
-        let key = ring_roots_key(7, collection, 136);
-
-        assert_eq!(key.len(), 16 + 16 + 8 + 4 + 16 + 32 + 16 + 4);
-        assert_eq!(
-            &key[40..44],
-            &7u32.to_le_bytes(),
-            "generation follows its hash"
-        );
+    fn subscriber_ring_key_matches_the_runtime_layout() {
         assert_eq!(
-            &key[60..92],
-            collection.identifier(),
-            "identifier follows its hash"
-        );
-        assert_eq!(
-            &key[108..],
-            &136u32.to_le_bytes(),
-            "ring index is little-endian"
+            ring_roots_key(7, PersonhoodCollection::LitePeople, 136),
+            hex::decode(
+                "c8d053ab324196afc756c5ae3fbd29178034a4ffd558299b9ac8097424772405\
+                 0e0d969b0e48cab7070000000bf6e234fafa085fd6710b952081ed8d706f703a\
+                 706f6c6b61646f742e6e6574776f726b2f70656f706c652d6c697465751c83\
+                 d291ed9a90887239b8a92828a688000000"
+            )
+            .unwrap(),
         );
     }
 
@@ -607,18 +585,63 @@ mod tests {
         let scripted = ScriptedRpc::new(["null"]);
         let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
 
-        assert_eq!(
+        let generation =
             futures::executor::block_on(read_current_generation(&rpc, test_fixtures::asset_hub()))
-                .unwrap(),
-            0
+                .unwrap();
+
+        assert_eq!(
+            (generation, scripted.calls()),
+            (
+                0,
+                vec![(
+                    "state_getStorage".to_string(),
+                    r#"["0xc8d053ab324196afc756c5ae3fbd2917c2dbc4fc2f665a39ada06f0965cccf86"]"#
+                        .to_string(),
+                )],
+            ),
         );
+    }
+
+    /// Caching the generation would leave later polls on abandoned roots.
+    #[test]
+    fn a_generation_change_during_wait_moves_the_ring_root_read() {
+        let first_generation = format!(r#""0x{}""#, hex::encode(7u32.to_le_bytes()));
+        let second_generation = format!(r#""0x{}""#, hex::encode(8u32.to_le_bytes()));
+        let roots = format!(
+            r#""0x{}""#,
+            hex::encode(test_fixtures::ASSET_HUB_RING_5_ROOTS)
+        );
+        let scripted = ScriptedRpc::new([
+            first_generation.as_str(),
+            "null",
+            second_generation.as_str(),
+            roots.as_str(),
+        ]);
+        let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
+
+        futures::executor::block_on(await_ring_revision(
+            &rpc,
+            test_fixtures::asset_hub(),
+            CAPTURED_COLLECTION,
+            5,
+            106,
+        ))
+        .unwrap();
+
+        let storage_call = |key: Vec<u8>| {
+            (
+                "state_getStorage".to_string(),
+                format!(r#"["0x{}"]"#, hex::encode(key)),
+            )
+        };
         assert_eq!(
             scripted.calls(),
-            vec![(
-                "state_getStorage".to_string(),
-                r#"["0xc8d053ab324196afc756c5ae3fbd2917c2dbc4fc2f665a39ada06f0965cccf86"]"#
-                    .to_string(),
-            )]
+            vec![
+                storage_call(current_generation_key()),
+                storage_call(ring_roots_key(7, CAPTURED_COLLECTION, 5)),
+                storage_call(current_generation_key()),
+                storage_call(ring_roots_key(8, CAPTURED_COLLECTION, 5)),
+            ],
         );
     }
 
diff --git a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
index 761835c93..d338a3f5e 100644
--- a/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
+++ b/rust/crates/truapi-server/src/runtime/statement_allowance/slot.rs
@@ -1067,10 +1067,8 @@ mod tests {
         assert_eq!(&key[52..], &alias, "alias follows its blake2_128 prefix");
     }
 
-    /// Both vectors are pinned against the mobile clients and the runtime. The
-    /// all-zero one is the offset check: every field of the suffix is already
-    /// zero there, so a field written at the wrong offset still hashes to this
-    /// answer only if the offsets agree.
+    /// The nonzero vector pins field order and endianness. The second separately
+    /// pins the period-zero, sequence-zero reference vector.
     #[test]
     fn statement_slot_context_matches_mobile_clients_and_runtime() {
         let vector = |hex: &str| -> [u8; 32] { hex::decode(hex).unwrap().try_into().unwrap() };
@@ -1103,11 +1101,19 @@ mod tests {
     #[test]
     fn network_suffix_is_read_from_chain_storage() {
         let scripted = ScriptedRpc::new(vec![r#""0x14706173656f""#]);
-        let rpc = RpcClient::new(HostRpcClient::new(scripted));
+        let rpc = RpcClient::new(HostRpcClient::new(scripted.clone()));
+        let suffix = futures::executor::block_on(read_network_suffix(&rpc)).unwrap();
 
         assert_eq!(
-            futures::executor::block_on(read_network_suffix(&rpc)).unwrap(),
-            b"paseo",
+            (suffix, scripted.calls()),
+            (
+                b"paseo".to_vec(),
+                vec![(
+                    "state_getStorage".to_string(),
+                    r#"["0x63c2d4c355d2d188c234d0a0669dc90863c2d4c355d2d188c234d0a0669dc908"]"#
+                        .to_string(),
+                )],
+            ),
         );
     }
 
diff --git a/rust/crates/truapi-server/src/test_support.rs b/rust/crates/truapi-server/src/test_support.rs
index 8f5aa129d..4991a6f1c 100644
--- a/rust/crates/truapi-server/src/test_support.rs
+++ b/rust/crates/truapi-server/src/test_support.rs
@@ -1297,10 +1297,7 @@ impl JsonRpcConnection for RecordingConnection {
 
 /// Answer each request as it arrives, by method, echoing its id.
 ///
-/// Repeated entries for one method are answered in call order. Running past the
-/// last one panics rather than replaying it: a script that answers fewer calls
-/// than the code makes would otherwise hand a response meant for one read to a
-/// different one, which decodes to a plausible wrong value instead of failing.
+/// Exhausted method scripts panic so one read cannot reuse another's response.
 ///
 /// Waits indefinitely for the next request rather than giving up after a fixed
 /// number of polls, so work between requests cannot race the pump.
@@ -1360,6 +1357,25 @@ fn method_keyed_responses(
     }))
 }
 
+#[test]
+#[should_panic(
+    expected = "method `state_getStorage` was called 2 times, and the script has 1 response(s) for it"
+)]
+fn method_keyed_responses_do_not_replay_an_exhausted_answer() {
+    use futures::StreamExt;
+
+    let request =
+        |id| format!(r#"{{"jsonrpc":"2.0","id":"{id}","method":"state_getStorage","params":[]}}"#);
+    let sent = Arc::new(Mutex::new(vec![request(1), request(2)]));
+    let mut responses =
+        method_keyed_responses(sent, vec![("state_getStorage", "null".to_string())]);
+
+    futures::executor::block_on(async {
+        responses.next().await.expect("first scripted response");
+        responses.next().await.expect("second scripted response");
+    });
+}
+
 async fn wait_for_matching_request_id(sent: Arc<Mutex<Vec<String>>>, response: &str) {
     let Some(id) = json_rpc_id(response) else {
         return;