Architectural Blueprint: Local Semantic Retrieval using Compressed Vector Indexes for TinyRustLM

1\. Executive Recommendation and Assumptions

The rapid evolution of quantized vector search presents a compelling opportunity for browser-bound retrieval systems. Based on an exhaustive review of public mathematical frameworks and software artifacts, the implementation of a compressed, flat-scan vector index inside the browser provides a viable path to local semantic retrieval without overwhelming client memory. However, the direct adoption of the TurboVec library is firmly discouraged in favor of a clean-room Rust and WebAssembly (WASM) implementation. \[Engineering Analysis and Recommendations\] A direct dependency on TurboVec introduces unnecessary architectural surface area, relies on mathematical paradigms that have been proven suboptimal by preceding research (such as the EDEN and RaBitQ frameworks), and utilizes a dynamic calibration mechanism that breaks the strict determinism required for a reproducible local browser environment. To evaluate these systems correctly, one must explicitly separate three distinct engineering domains of quantization, which have vastly different lifetimes, metrics, and trust boundaries. First, static model-weight quantization focuses on reducing the persistent disk footprint and memory-mapped VRAM requirements of the large language model (LLM) itself. Second, online transformer KV-cache quantization—the original domain of the TurboQuant algorithm—focuses on reducing the ephemeral context-window memory pressure during token generation, where state is short-lived and tolerates slight mean-squared-error (MSE) shifts. Third, persistent embedding and vector-index quantization focuses on enabling long-term, durable semantic retrieval across sessions. \[Engineering Analysis and Recommendations\] This report focuses exclusively on the third domain. Mapping ephemeral KV-cache techniques to persistent embeddings requires robust cryptographic identity, deterministic scaling, and rigorous deletion semantics to satisfy the privacy constraints of a user-facing chat system. The foundational assumptions for this architecture rely on the fixed constraints of the pre-release TinyRustLM chat system. It is assumed that model bytes and ordinary prompts remain entirely local unless the user explicitly opts into a separate service. Furthermore, local memory contents are fundamentally untrusted data and must never be treated as hidden system instructions. Raw conversational streams must not be silently persisted or promoted into durable memory; only user-approved summaries, facts, pointers, and document chunks may be indexed. \[Requires Local TinyRustLM Verification\] It remains unknown whether target browsers in TinyRustLM's specific hosting environment natively pass the Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy (COOP/COEP) headers required to unlock SharedArrayBuffer for multi-threaded WASM execution. Consequently, the baseline architectural design must assume a single-threaded simd128 execution environment, with graceful scaling if concurrency primitives become available.

2\. Public Observation and Version Log

The rigorous evaluation of the underlying algorithms, mathematical proofs, and reference software implementations requires exact provenance. The following primary sources constitute the immutable foundation of this analysis.

• TurboVec: Version 0.9.0 (Rust crate) and 0.8.0 (Python package), published and observed in June 2026\. Authored by Ryan Codrai under the RyanCodrai/turbovec GitHub repository. \[Directly Observed Public Fact\] The project implements online vector ingestion and search utilizing handwritten NEON and AVX-512BW SIMD kernels, alongside search-time bitmask filtering1.
• TurboQuant: Authored by Zandieh et al. (Google Research), published in April 2025 as arXiv:2504.19874, and accepted to ICLR 2026\. \[Directly Observed Public Fact\] The paper outlines a training-free vector quantization algorithm achieving near-optimal distortion rates via random orthogonal rotation and a 1-bit Quantized Johnson-Lindenstrauss (QJL) residual correction4.
• RaBitQ: Authored by Gao & Long, published at SIGMOD 2024 and submitted to arXiv in May 2024 (arXiv:2405.12497), with a multi-bit extension (arXiv:2409.09913) published in September 2024\. \[Directly Observed Public Fact\] This research established the core theoretical basis for using random rotation to normalize high-dimensional coordinate distributions prior to quantization, proving asymptotically optimal error bounds for distance estimation8.
• EDEN and DRIVE: Authored by Vargaftik, Ben-Basat, et al., published at NeurIPS 2021 (DRIVE) and ICML 2022 (EDEN). \[Directly Observed Public Fact\] These papers introduced post-rotation, distribution-aware scalar quantization, deriving specific mathematical scaling parameters that optimize for either mean-squared error or unbiased estimation13.
• Revisiting RaBitQ and TurboQuant (Technical Note): Authored by Gao et al., published in April 2026 (arXiv:2604.19528). \[Directly Observed Public Fact\] This technical note documents reproducibility failures in the original TurboQuant experimental claims and establishes that RaBitQ provides superior empirical performance under symmetric testing conditions16.
• A Note on TurboQuant and EDEN (Technical Note): Authored by Ben-Basat et al., published in April 2026 (arXiv:2604.18555). \[Directly Observed Public Fact\] This analysis mathematically demonstrates that TurboQuant is a structurally restricted, suboptimal special case of the 2022 EDEN algorithm15.
• FAISS FastScan: Maintained by Meta AI Research. \[Directly Observed Public Fact\] The IndexPQFastScan implementation utilizes 4-bit SIMD registers for high-throughput distance calculations, serving as the primary baseline for the performance claims made by the TurboVec repository18.

3\. Retrieval Problem and Metric Definitions

Defining the exact boundaries of the vector retrieval problem is essential before selecting a quantization strategy, as different methodologies optimize for fundamentally different spatial assumptions. \[Engineering Analysis and Recommendations\] The objective within TinyRustLM is to receive a dense floating-point query vector representing the user's immediate context and return the top\-![][image1] most semantically similar memory records stored durably in the browser. Retrieval paradigms differ significantly in their operational mechanics. Exact Cosine Search relies on the normalized inner product of raw 32-bit floating-point (f32) vectors, producing perfect accuracy at the cost of immense memory footprint and severe memory-bandwidth bottlenecks during scanning. Maximum Inner Product Search (MIPS) evaluates unnormalized magnitudes, which is critical for asymmetric dual-encoder models but complicates metric bounding. Euclidean Distance (L2) evaluates spatial separation rather than angular similarity. To circumvent the ![][image2] time complexity of exact searches, Approximate Nearest Neighbor (ANN) search employs candidate generation techniques. Graph-based algorithms, such as Hierarchical Navigable Small World (HNSW), offer logarithmic search times but require substantial metadata overhead. \[Externally Corroborated Fact\] HNSW typically requires between 24 and 32 bytes of edge-pointer metadata per vector21. In the context of aggressive 2-bit quantization—where a 1536-dimensional vector occupies merely 384 bytes—this pointer overhead effectively doubles the index size, negating the primary benefit of compression. Inverted File (IVF) indexes cluster vectors into Voronoi cells, but the boundaries of these cells drift over time, necessitating computationally expensive periodic retraining. Given the strict WebAssembly memory limits and the lack of predictable background processing in a browser tab, the proposed architecture focuses entirely on the compressed flat scan. \[Engineering Analysis and Recommendations\] In a compressed flat scan, the query vector is compared against every compressed vector in the database linearly. By leveraging extreme bit-packing (e.g., 2 to 4 bits per dimension) and executing the scan entirely within SIMD registers, the micro-architectural throughput hides the linear time complexity, allowing millions of vectors to be evaluated in milliseconds without the memory bloat of graph indices. This fits perfectly into TurboVec's operational model. This dense vector retrieval must eventually be combined with hybrid lexical retrieval (e.g., BM25) and subsequent reranking to resolve vocabulary mismatch. To quantify the success of these mechanisms, the quality of retrieval cannot be reduced to vector recall alone. Several metrics define the system's operational health:

• Recall@k: The fraction of the true top\-![][image1] nearest neighbors—determined by an exhaustive f32 oracle search—that are successfully retrieved by the compressed index.
• Normalized Discounted Cumulative Gain (NDCG): Evaluates the ranking quality of the retrieved set, heavily penalizing indexes that swap the position of highly relevant vectors with marginally relevant ones.
• Mean Reciprocal Rank (MRR): Measures the position of the first perfectly relevant document, which is critical when the LLM context window is tightly constrained.
• Answer-Grounding Success: The ultimate downstream product metric, measuring whether the local LLM successfully synthesizes a correct, hallucination-free response based on the retrieved context.

4\. TurboVec Ingest and Search Reconstruction

Evaluating the viability of TurboVec for TinyRustLM requires a forensic reconstruction of its physical execution path, separating the theoretical claims of the TurboQuant paper from the actual software artifacts deployed in the Rust crate. \[Engineering Analysis and Recommendations\] TurboVec successfully synthesizes theoretical bounds into a functional software artifact, but its architectural divergence from the academic TurboQuant paper reveals significant practical realities about high-throughput vector search. The ingestion and search pipeline operates through several distinct phases:

1. Normalization: The system calculates the L2 norm of the input vector ![][image3], normalizes it to a unit vector ![][image4], and stores the scalar norm alongside the packed bits.
2. Random Rotation: The unit vector is multiplied by a deterministic, pseudo-random orthogonal matrix ![][image5]. \[Paper/Project Author Claim\] Following this rotation, the variance is distributed evenly across all dimensions, causing each coordinate to act as a sum of independent variables that, by the Central Limit Theorem, asymptotically converges to a Gaussian distribution ![][image6] in high dimensions, regardless of the input data's original geometry2.
3. TQ+ Calibration: On the first ingested batch of vectors, the TurboVec index dynamically fits a per-coordinate shift and scale parameter. \[Directly Observed Public Fact\] This maps the empirical 5th and 95th percentiles of the incoming vectors to the target Beta marginal distribution. This calibration is then frozen and applied to all subsequent vectors2.
4. Lloyd-Max Scalar Quantization: A mathematically precomputed optimal codebook assigns each rotated, calibrated coordinate to an integer bucket. Because the distribution is assumed to be a known Gaussian/Beta shape, this requires 4 mathematically fixed levels for 2-bit quantization and 16 levels for 4-bit quantization, avoiding the need to train a codebook on user data.
5. Bit Packing: The integer coordinates are tightly packed into bytes to maximize SIMD lane utilization.
6. Per-Vector Correction (L2 Renormalization): The official TurboQuant paper advocates for a 1-bit Quantized Johnson-Lindenstrauss (QJL) residual correction to eliminate the downward scoring bias introduced by scalar quantization5. \[Directly Observed Public Fact\] TurboVec abandons this approach. Instead, it computes and stores a corrective scalar for each vector: ![][image7], representing the ratio of the original vector's length to its quantized reconstruction2. \[Externally Corroborated Fact\] This mirrors the exact asymmetric length-renormalization technique documented by Qdrant and the RaBitQ authors to eliminate bias without sacrificing codebook bits for a QJL residual22.
7. Blocked Layout and Query Rotation: The database layout is partitioned into SIMD-friendly blocks. During a search, the uncompressed query vector is rotated using the same orthogonal matrix ![][image5].
8. Lookup Tables and SIMD Scan: The query's rotated coordinates are pre-multiplied against the fixed Lloyd-Max centroids, populating a small lookup table (LUT) that fits entirely within SIMD registers. \[Paper/Project Author Claim\] The search kernel uses AVX2 \mm256\maddubs\_epi16 or ARM NEON equivalents to scan the blocked layout, pulling bytes, performing the LUT shuffle, and accumulating integer scores2.
9. Allowlist Filtering and Top-K Selection: Filtering is applied at the 32-vector block level. If a block contains no allowed slots based on the user's access bitmask, the SIMD lookup is short-circuited entirely. The accumulated integer scores are then converted to f32, multiplied by the renormalization scalar, and fed into a binary min-heap for top\-![][image1] selection.

5\. Accuracy, Calibration, and Bias Analysis

The interaction between bit-width, dimensionality, and the specific distribution of the embedding model defines the operational envelope of the local index. \[Engineering Analysis and Recommendations\] A quantized index does not perform uniformly across all vector geometries. Modern sentence embeddings (e.g., 1536-dimensional or 3072-dimensional outputs from advanced models) demonstrate strong concentration of measure. \[Paper/Project Author Claim\] TurboVec achieves 0.970+ Recall@1 at 4-bit quantization for these models, remaining highly competitive with f32 exact searches3. However, at low dimensions (e.g., 128 to 200 dimensions), sparse clusters and traditional word vectors exhibit severe anisotropy. The random rotation fails to perfectly synthesize a Gaussian distribution because the Central Limit Theorem requires a sufficiently large dimension ![][image8] to dominate outlier coordinates. \[Externally Corroborated Fact\] Qdrant engineers confirm that highly anisotropic embeddings break the zero-mean Gaussian assumption, which degrades the precision of the fixed Lloyd-Max grid22. The fundamental algorithms driving TurboQuant have been the subject of intense mathematical scrutiny. The foundational paper minimizes mean-squared error via its ![][image9] algorithm. \[Externally Corroborated Fact\] However, the authors of the prior EDEN and DRIVE research papers demonstrated mathematically that TurboQuant is actually a restricted, suboptimal configuration of their 2022 algorithm15. Specifically, the EDEN framework dictates that after rotation and quantization, the output must be multiplied by a strictly optimized scaling parameter ![][image10]. TurboQuant forces ![][image11], which incurs a persistent MSE penalty13. \[Engineering Analysis and Recommendations\] If TinyRustLM implements a custom quantization kernel, it must utilize the optimized ![][image10] parameters derived in EDEN-unbiased to achieve strictly superior vector-normalized mean-squared error (vNMSE), effectively recovering the accuracy of an entire additional bit of precision per coordinate without increasing the physical storage footprint. Furthermore, TurboVec introduced a "TQ+" dynamic calibration feature, which applies a per-coordinate quantile calibration derived strictly from the first ingested batch of vectors. \[Engineering Analysis and Recommendations\] This mechanism introduces a fatal architectural flaw for deterministic, local, privacy-focused systems. If the first memory a user saves to TinyRustLM consists of a short, semantically anomalous string, the index's empirical 5th and 95th percentiles will permanently calibrate to an out-of-distribution shape. Consequently, the retrieval accuracy for all subsequent, well-formed documents added over the lifetime of the browser profile will be systematically degraded. This order dependence destroys reproducible index identities and introduces unpredictable search failures. Design Alternative: TinyRustLM must entirely reject online first-add calibration. Instead, the architecture must utilize a "frozen public calibration" matrix. The developers must calculate the optimal shift and scale parameters offline using a massive, representative corpus specifically tuned for the exact embedding model shipped with the browser. This static calibration matrix must be shipped alongside the model weights and tokenizer, ensuring every local client executes mathematically identical transformations regardless of their unique ingestion history.

6\. Index and Memory-Record Identity Schemas

To ensure absolute cache coherency and enforce strict privacy boundaries, the physical vectors must be decoupled from the logical user memories.

Index Identity Binding

A vector index cannot safely compare dot products between vectors that were compressed under different paradigms, different bit-widths, or different embedding models. \[Engineering Analysis and Recommendations\] The binary header of the local file must cryptographically bind the exact configuration. Mixing vectors whose identities do not match results in catastrophic semantic collapse. The header schema must explicitly include:

• Model\_Hash: The SHA-256 digest of the underlying embedding model weights.
• Tokenizer\_Identity: The explicit version of the text preprocessor.
• Normalization\_Flag: Indicating whether vectors are unit-normalized prior to quantization.
• Dimension: The exact bounded integer dimension (e.g., 1536).
• Distance\_Metric: Cosine, Maximum Inner Product, or L2 Euclidean.
• Bit\_Width: The allocated bits per coordinate (e.g., 2, 4, or 8).
• Rotation\_Seed: The deterministic seed generating the orthogonal matrix ![][image5].
• Calibration\_Digest: The cryptographic hash of the frozen public shift/scale parameters.
• Format\_Version: The semantic versioning of the binary file layout.

If the browser attempts to load an index where any of these parameters do not match the currently active TinyRustLM instance, the software must transparently trigger a clean background rebuild of the index from the raw untrusted data stored in IndexedDB.

Memory-Record Identity vs. Vector-Slot Identity

TurboVec exposes an IdMapIndex that uses a hash table to map 64-bit external IDs to internal vector slots (the integer sequence 0 to N-1 representing physical memory layout)2. \[Directly Observed Public Fact\] When a vector is deleted via the swap\remove function, TurboVec moves the last physical vector in the array into the vacated slot to maintain a dense contiguous block, updating the internal hash map accordingly2. \[Engineering Analysis and Recommendations\] For TinyRustLM, a single logical memory record (e.g., a summarized user interaction) might be semantically chunked into multiple 1536-dimensional embeddings. The architecture must map a durable, stable Memory\UUID to an array of internal Vector\_Slots.

• Supersession: If a user updates a fact, the old embeddings must be marked as tombstones in the metadata layer, and their physical slots queued for garbage collection during the next compaction cycle.
• Deletion: If a user explicitly deletes a sensitive memory, the system must issue a swap\_remove to sever the connection. However, because standard array truncation only shifts the conceptual boundary of the array, the stale packed bits of the deleted vector technically remain in the memory buffer at the tail end. To satisfy strict privacy constraints, the custom TinyRustLM kernel must proactively execute a memset(0) over the abandoned byte range to explicitly destroy the untrusted data. A delete must never return a removed record through stale packed layouts or browser memory-scraping attacks.

7\. Mutation, Deletion, and Crash-Consistency Design

Browsers offer exceptionally hostile environments for file persistence. Service workers are terminated arbitrarily, tabs are killed by the operating system due to memory pressure, and users frequently close windows mid-transaction.

Incremental Operations and Reliability

• Batch Add and Atomic Upsert: Incoming vectors must be serialized into a robust Write-Ahead Log (WAL) utilizing IndexedDB before any modifications are made to the in-memory WASM array or the Origin Private File System (OPFS) binaries. An atomic upsert requires locating existing slots, writing the new vector, and only then freeing the old slots. \[Paper/Project Author Claim\] Previous iterations of TurboVec integrations destroyed existing data during failed validation; robust designs must defer deletion until the new ingestion completely succeeds3.
• Crash Consistency: If power is lost or the tab is closed during a swap\remove compaction, the in-memory slot\to\_id map will desynchronize from the persistent binary blob. \[Engineering Analysis and Recommendations\] TinyRustLM must implement a strictly monotonic sequence-number check in the header of the binary format. Upon load, the host validates the sequence number against the WAL. If pending operations exist that are not reflected in the binary blob, the WAL is replayed sequentially to restore perfect consistency.
• Quota Exhaustion: Browsers enforce strict quotas (e.g., 5MB for LocalStorage, with larger but variable limits for IndexedDB and OPFS)25. Prior to any batch append, the WASM host must actively query navigator.storage.estimate() to validate available storage headroom. If the boundary is breached, the mutation must be gracefully rejected, and the UI must prompt the user to clear space, preventing partial writes that corrupt the vector headers. Destructive mutations must require validation of the index integrity before execution.

8\. Filtering and Hybrid Retrieval Architecture

Modern Retrieval-Augmented Generation (RAG) pipelines for language models require dense candidate retrieval mixed with hard, deterministic access policies (e.g., filtering out deleted records, respecting workspace boundaries, and isolating user profiles).

Search-Time Filtering Mechanisms

• Post-filtering (Over-fetching): A naive implementation fetches ![][image12] vectors and discards those that lack the required metadata. \[Engineering Analysis and Recommendations\] A post-filter over-fetch strategy is fundamentally not equivalent to an exact filtered top-k search. At high selectivity (e.g., a filter that only matches 0.01% of the database), over-fetching will prematurely exhaust the dense candidate pool, returning zero valid results even if perfectly matching vectors exist deeper in the index.
• Pre-filtering: Running an exact metadata query first to generate an ID allowlist, then performing a dense search restricted to those IDs.
• Kernel Block Skipping: \[Paper/Project Author Claim\] TurboVec incorporates allowlist bitmasks directly inside the SIMD kernel at 32-vector block granularity. Blocks with zero allowed slots bypass the floating-point lookup tables entirely, preserving critical CPU cycle time2.

\[Engineering Analysis and Recommendations\] For TinyRustLM, kernel block skipping utilizing slot bitmasks is strictly superior. At 100% selectivity (no active filters), the branch predictor overhead of evaluating a bitmask is negligible. At 1% selectivity, dropping 99% of the SIMD LUT lookups accelerates the scan exponentially while mathematically guaranteeing exact top\-![][image13] recall bounded only by the inherent quantization loss.

Hybrid Retrieval Pipeline for TinyRustLM

To integrate seamlessly with a small local LLM, the retrieval architecture must balance semantic nuance with keyword exactitude:

1. Query Construction: The LLM determines if a local index search is required and emits a query string.
2. Dual Execution: The query is simultaneously embedded for dense vector search and tokenized for BM25 lexical search.
3. Filtered Kernel Scan: The WASM index executes the dense SIMD scan, applying bitmasks for user provenance, sensitivity labels, and supersession state.
4. Reciprocal Rank Fusion (RRF): Lexical and vector candidates are merged using RRF to resolve vocabulary mismatch (where dense vectors retrieve concepts, but lexical retrieval ensures exact noun matching).
5. Context Budgeting: The top candidates are dynamically truncated to fit the strict context-window constraints of the local LLM. Retrieved text is explicitly labeled with source provenance and passed as untrusted User data, rather than trusted System instructions, to prevent prompt injection attacks originating from archived memories.

9\. End-to-End Quality Evaluation

Evaluating the efficacy of compressed vector indexes solely on Recall@1 is a fundamental anti-pattern. The evaluation matrix must capture the downstream utility of the conversation.

Evaluation Metrics

1. Vector Recall vs Exact f32: Measure the intersection of the compressed top-10 against an exact 32-bit floating-point oracle top-10.
2. Nearest-Neighbor Margin: Measure the absolute cosine distance gap between the 1st and 2nd retrieved results. \[Engineering Analysis and Recommendations\] Extremely heavy quantization (e.g., 1-bit) can collapse margins, creating artificial score ties that destabilize Reciprocal Rank Fusion algorithms.
3. Answer-Grounding Success: The ultimate product metric. Given a golden dataset of conversational questions, does the local LLM successfully synthesize the correct, hallucination-free answer using the retrieved context?
4. Stale-Memory Avoidance: Assesses whether deleted or superseded tombstones accidentally leak into the context window due to indexing race conditions. The failure rate must be rigorously bounded at 0.0%.

Ablation Matrix Design

To isolate the exact drivers of performance, the engineering team must evaluate the following ablation matrix, strictly equalizing effective byte budgets, build costs, and query time across all rows:

10\. Capacity and Performance Formulas

The mathematical ceiling of browser-based retrieval is dictated by the physical memory footprint of the binary format and the execution speed of the WASM virtual machine.

Total Index Size Formula

For ![][image14] records of dimension ![][image15] at ![][image16] bits per coordinate: ![][image17] ![][image18] ![][image19] ![][image20] Comprehensive Capacity Model Table: (Assuming ![][image21] dimensions, 4-bit compression)

\[Engineering Analysis and Recommendations\] The typical modern browser restricts single WASM linear memory allocations to either 2GB or 4GB, depending on the engine architecture (V8 vs SpiderMonkey). Therefore, TinyRustLM can comfortably hold up to approximately 2.5 million conversational memories entirely in RAM at 4-bit compression. If the corpus exceeds 2.5M records, the system must either shard the index across multiple Web Workers, stream the OPFS file in chunks, or aggressively downgrade to 2-bit quantization.

11\. Browser, WASM, and Storage Portability Matrix

Execution speed in a browser environment depends fundamentally on navigating JavaScript-to-WASM boundary penalties, asynchronous I/O bottlenecks, and multi-threading restrictions.

• WASM SIMD128: Modern browsers natively support 128-bit vector instructions. Rust targeting the wasm32-unknown-unknown architecture with the \+simd128 feature flag compiles intrinsic calls into highly efficient parallel CPU instructions26. \[Engineering Analysis and Recommendations\] Unlike AVX2's 256-bit or AVX-512's 512-bit registers, WASM restricts execution to 4x32-bit floats or 16x8-bit integers per cycle. The pshufb (shuffle) logic utilized by TurboVec maps cleanly to the WASM i8x16.swizzle instruction, allowing rapid lookup table evaluation without scalar iteration.
• SharedArrayBuffer (SAB): Required for multithreading and transferring memory buffers between the main UI thread and Web Workers without blocking copies. However, utilizing SAB requires the web host to emit strict Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp headers28. \[Requires Local TinyRustLM Verification\] If TinyRustLM is distributed as a static local file (file://), a browser extension, or via a host that cannot modify HTTP headers, SAB will fail. The architecture must dynamically detect this and fallback gracefully to single-threaded Web Worker execution.
• IndexedDB vs. OPFS:
• IndexedDB: Broadly supported and excellent for small JSON transactions, but suffers from high latency for bulk byte retrieval (\~4-10x slower than OPFS) due to serialization overhead on the main thread25.
• OPFS (Origin Private File System): Exposes the createSyncAccessHandle() API, allowing synchronous, high-throughput I/O directly into WASM memory. \[Directly Observed Public Fact\] OPFS synchronous access handles are explicitly restricted to Dedicated Web Workers and cannot be invoked from the main UI thread or Shared Workers25.

\[Engineering Analysis and Recommendations\] TinyRustLM must architect its search module as a Dedicated Web Worker utilizing OPFS for the raw binary .tvim blobs, relegating IndexedDB strictly to JSON metadata and WAL transactions. Incognito and private browsing modes frequently restrict OPFS access or cap storage at severely reduced quotas (e.g., 100MB), necessitating a fallback to an in-memory-only operational mode.

12\. Binary Format and Security Model

A browser parsing local files is highly susceptible to adversarial injection if the binary parsing is not rigorously defensive. A hostile-input-safe binary format must enforce strict data hygiene to prevent arbitrary code execution or memory scraping.

Defensive Binary Layout

The custom .tlm index format must mandate the following structure:

1. Magic Bytes: Explicit verification header (e.g., TLM1) to reject malformed payloads.
2. Canonical Endianness: All integers and floating-point scalars must be strictly encoded as Little-Endian to prevent architecture-dependent memory corruption across different host devices.
3. Dimension Bounding: The header must enforce ![][image22] and explicitly verify that ![][image15] is a multiple of the SIMD register lane size (e.g., modulo 8).
4. Checked Arithmetic: Total memory allocation sizes must be calculated utilizing checked\mul and checked\add in Rust. \[Engineering Analysis and Recommendations\] This prevents malicious integer overflow exploits that trick the WASM runtime into allocating an undersized buffer, followed by catastrophic out-of-bounds writes.
5. No Arbitrary Code or Paths: The binary format must consist solely of pure numerical arrays. It must strictly prohibit filepath references, URL pointers, or serialized executable closures. JSON metadata must be bounded to a strict maximum byte length.
6. Quarantine Checksums: A trailing SHA-256 hash must be verified during the OPFS load sequence before exposing any data pointers to the query processor. Corrupt files must be quarantined, and the system must gracefully rebuild from the durable WAL.

13\. Privacy and Deletion-Backed Test Plan

Given the pre-release nature of TinyRustLM, establishing user trust relies entirely on proving cryptographic and physical deletion certainty. The following automated browser lifecycle tests must be integrated into the CI/CD pipeline:

1. Storage Enumeration Sweep: Launch a clean browser profile, simulate a 1,000-message chat, and programmatically inspect LocalStorage, the Cache API, OPFS, and IndexedDB using DevTools protocols. Assert that zero plain-text strings are leaked by the embedding or index-compaction processes.
2. Tombstone Verification: After a user issues a delete command and triggers a swap\_remove, the test must traverse the linear WASM memory buffer, asserting that the specific byte-range of the deleted vector returns exactly 0x00, mathematically preventing latent data extraction.
3. Stale Worker Interruption: Simulate a browser tab crash (via OS signal) precisely during a WAL-to-OPFS compaction operation. Reload the page and assert that the index recovers to the exact pre-crash state without corrupting the active vector count or resurrecting deleted records.
4. Network Air-Gap Proof: Instantiate the system in a Playwright testing environment with all outbound network requests explicitly blocked via interceptors. The system must successfully embed, index, and retrieve memories without throwing network timeout exceptions, proving that project websites never receive private embeddings or index bytes.

14\. Build/Adopt/Defer Decision Matrix

The engineering leadership of TinyRustLM faces three distinct pathways for integrating vector quantization in the browser.

15\. Prioritized Experiments and Stop Rules

To validate the custom build approach, the engineering team must execute the following sequential experiments, adhering strictly to predefined rejection thresholds.

1. Experiment 1: Browser simd128 Micro-Benchmark

• Setup: Implement a raw 128-bit WASM dot-product function utilizing i8x16.swizzle against a 4-bit scalar quantized byte array.
• Metric: Megabytes per second (MB/s) linear scan speed.
• Stop Rule: If the scan cannot sustain ![][image23] GB/s on an M-class or equivalent x86 processor, the latency for searching 100,000 vectors will breach the 50ms rendering budget. Halt the experiment and re-evaluate the quantization bit-width.

1. Experiment 2: EDEN-Unbiased vs L2-Renormalization Accuracy

• Setup: Compress a corpus of 10,000 conversational slices using ![][image11] (TurboQuant baseline), EDEN-biased optimal scales, and L2-renormalization.
• Metric: Context-grounded generation success (evaluated by an LLM judge on a golden dataset).
• Stop Rule: If aggressive 2-bit quantization causes a ![][image24] degradation in correct-answer generation compared to the exact f32 oracle, the compression is too lossy for the embedding model's geometry. Downgrade to 4-bit quantization.

1. Experiment 3: OPFS Concurrency Stress Test

• Setup: Spawn two identical TinyRustLM tabs. Tab A writes a bulk batch of 1,000 vectors via OPFS. Tab B continuously executes dense queries.
• Metric: Locked file exceptions and cross-tab data consistency.
• Stop Rule: If OPFS exclusive file locks cause Tab B to block the main UI thread for ![][image25], the architecture must fallback to a Shared Worker architecture or implement a robust multi-tab election protocol using Web Locks.

16\. Unknowns Requiring Local or Authorized Service Access

The theoretical limits of this architecture are well-defined, but several environment-specific variables require direct access to the internal TinyRustLM testing harness to finalize the engineering specifications:

• Browser Capability Matrix: \[Requires Local TinyRustLM Verification\] We must determine exactly which minimum browser versions TinyRustLM officially targets to guarantee OPFS createSyncAccessHandle compatibility and determine the fallback execution path.
• Embedding Model Statistics: \[Requires Local TinyRustLM Verification\] The exact dimensionality, underlying architecture, and output distribution (e.g., highly anisotropic vs nearly isotropic) of the specific local embedding model used by TinyRustLM must be analyzed to generate the frozen offline calibration tables.
• Context Budgets: \[Requires Local TinyRustLM Verification\] The exact token limit of the local LLM determines the optimal value of ![][image1] to retrieve. If the model can only ingest 3 standard chunks, the system's sensitivity to Recall@3 dictates the strict minimum required bit-depth.

17\. Annotated Primary-Source Bibliography

• 1

RyanCodrai. turbovec: A vector index built on TurboQuant. GitHub Repository. (Observed June 2026). This repository provides the physical implementation details of online ingestion, SIMD search kernels, the divergence from QJL toward L2 renormalization, and the TQ+ dynamic calibration method.

• 4

Zandieh et al. (Google Research). TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate. arXiv:2504.19874. Published April 2025, Accepted to ICLR 2026\. This foundational paper proposes PolarQuant (random rotation) combined with a 1-bit QJL residual correction primarily optimized for KV-cache compression.

• 9

Gao, J., & Long, C. RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search. SIGMOD 2024\. arXiv:2405.12497 / 2409.09913. This research proves the asymptotic optimality of applying a random rotation prior to 1-bit and multi-bit quantization.

• 13

Ben-Basat et al. A Note on TurboQuant and the Earlier DRIVE/EDEN Line of Work. arXiv:2604.18555 (April 2026). This mathematical critique clarifies that TurboQuant is structurally equivalent to the EDEN algorithm from ICML 2022, but operates suboptimally by fixing the scaling parameter ![][image11].

• 16

Gao et al. Revisiting RaBitQ and TurboQuant: A Symmetric Comparison of Methods, Theory, and Experiments. arXiv:2604.19528 (April 2026). Documents reproducibility issues with the TurboQuant performance claims and establishes RaBitQ's superiority under symmetric testing.

• 22

Qdrant Technologies. TurboQuant Quantization in Qdrant. (May 2026). This engineering blog confirms the necessity of abandoning the PROD (QJL) variant in favor of the MSE variant to allow symmetric scoring, and documents the P-Square calibration technique required for anisotropic embeddings.

• 18

Meta AI Research. FAISS: A library for efficient similarity search. GitHub Wiki. Documents the IndexPQFastScan SIMD architectures acting as the baseline comparison for CPU-based compressed flat scans.

• 24

Mozilla Developer Network & WebAssembly Working Group. Documentation regarding WASM simd128, Origin Private File System (OPFS) createSyncAccessHandle, and SharedArrayBuffer memory control. Contains fundamental constraints on browser thread locking, asynchronous JavaScript bridging, and memory allocation limits.

Works cited

1. GitHub \- RyanCodrai/turbovec \- daily.dev, https://daily.dev/posts/github---ryancodrai-turbovec-vk5u15wft
2. GitHub \- RyanCodrai/turbovec: A vector index built on TurboQuant, written in Rust with Python bindings, https://github.com/RyanCodrai/turbovec
3. turbovec/CHANGELOG.md at main \- GitHub, https://github.com/RyanCodrai/turbovec/blob/main/CHANGELOG.md
4. TurboQuant: 31GB AI Memory Down to 4GB, Explained | TECHSY, https://techsy.io/en/blog/google-turboquant-ai-memory-compression
5. TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate \- Hugging Face, https://huggingface.co/papers/2504.19874
6. (PDF) TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate \- ResearchGate, https://www.researchgate.net/publication/391246798\TurboQuant\Online\Vector\Quantization\with\Near-optimal\Distortion\_Rate
7. TurboQuant: Redefining AI Efficiency with Extreme Compression | William H. English, https://willenglish.tech/posts/2026/04/turboquant/
8. TurboQuant and RaBitQ: What the Public Story Gets Wrong | by Jianyang Gao \- Medium, https://medium.com/@gaojianyang0017/turboquant-and-rabitq-what-the-public-story-gets-wrong-23df83209c22
9. \[2405.12497\] RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search \- arXiv, https://arxiv.org/abs/2405.12497
10. \[SIGMOD 2024\] RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search \- GitHub, https://github.com/gaoj0017/RaBitQ
11. Practical and Asymptotically Optimal Quantization of High-Dimensional Vectors in Euclidean Space for Approximate Nearest Neighbor Search \- arXiv, https://arxiv.org/pdf/2409.09913
12. \[2409.09913\] Practical and Asymptotically Optimal Quantization of High-Dimensional Vectors in Euclidean Space for Approximate Nearest Neighbor Search \- arXiv, https://arxiv.org/abs/2409.09913
13. TurboQuant is a restricted version of EDEN quantization (NeurIPS 21, ICML 22). I... | Hacker News, https://news.ycombinator.com/item?id=47917577
14. How a 2021 Quantization Algorithm Quietly Outperforms Its 2026 Successor, https://towardsdatascience.com/how-a-2021-quantization-algorithm-quietly-outperforms-its-2026-successor/
15. A Note on TurboQuant and the Earlier DRIVE/EDEN Line of Work \- arXiv, https://arxiv.org/html/2604.18555v1
16. Revisiting RaBitQ and TurboQuant: A Symmetric Comparison of Methods, Theory, and Experiments \- arXiv, https://arxiv.org/pdf/2604.19528
17. \[2604.18555\] A Note on TurboQuant and the Earlier DRIVE/EDEN Line of Work \- arXiv, https://arxiv.org/abs/2604.18555
18. Home · facebookresearch/faiss Wiki \- GitHub, https://github.com/facebookresearch/faiss/wiki/Home/d25a6bca4901d5e75091d22207d2a65213289f4e
19. Fast accumulation of PQ and AQ codes (FastScan) · facebookresearch/faiss Wiki \- GitHub, https://github.com/facebookresearch/faiss/wiki/Fast-accumulation-of-PQ-and-AQ-codes-(FastScan))
20. Implementation notes · facebookresearch/faiss Wiki \- GitHub, https://github.com/facebookresearch/faiss/wiki/Implementation-notes
21. Guidelines to choose an index · facebookresearch/faiss Wiki \- GitHub, https://github.com/facebookresearch/faiss/wiki/Guidelines-to-choose-an-index
22. TurboQuant in Qdrant, https://qdrant.tech/articles/turboquant-quantization/
23. Quantization Meets Projection: A Happy Marriage for Approximate k-Nearest Neighbor Search \- VLDB Endowment, https://www.vldb.org/pvldb/vol19/p1240-yang.pdf
24. ADR-003-simd-optimization-strategy.md \- RuVector \- GitHub, https://github.com/ruvnet/ruvector/blob/main/docs/adr/ADR-003-simd-optimization-strategy.md
25. LocalStorage vs. IndexedDB vs. Cookies vs. OPFS vs. WASM-SQLite | RxDB \- JavaScript Database, https://rxdb.info/articles/localstorage-indexeddb-cookies-opfs-sqlite-wasm.html
26. core::arch::wasm \- Rust, https://doc.rust-lang.org/beta/core/arch/wasm/index.html
27. Code generation \- The Rust Reference, https://rustwiki.org/en/reference/attributes/codegen.html
28. SharedArrayBuffer \- JavaScript \- MDN Web Docs, https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/SharedArrayBuffer
29. Real-time video filters in browsers with FFmpeg and webcodecs \- Transloadit, https://transloadit.com/devtips/real-time-video-filters-in-browsers-with-ffmpeg-and-webcodecs/
30. Instant Performance with IndexedDB RxStorage | RxDB \- JavaScript Database, https://rxdb.info/rx-storage-indexeddb.html
31. Llamas on the Web: Memory-Efficient, Performance-Portable, and Multi-Precision LLM Inference with WebGPU \- arXiv, https://arxiv.org/html/2605.20706v1
32. The Current State Of SQLite Persistence On The Web: May 2026 Update \- PowerSync, https://powersync.com/blog/sqlite-persistence-on-the-web
33. The RaBitQ Library \- OpenReview, https://openreview.net/pdf?id=OeZHhOsFir

[image1]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAbCAYAAACqenW9AAAA9UlEQVR4Xu3SoYsCQRTH8ScqKOqhGC+IeAjX/AMuarJpNPgPWLQYxSheunbRfigGu2C0mkwGsVmMd3B33+fOwDK7cggXDP7gAztvht03Mytyk4kgj6w74WaET/yg58yFpoEvvLgTYXnDDo9OPZAMVlgg4cwF8owj+masmy2jhqRdZNPCN6qIY4gx5hKyYdtvCQNUxFsUOJ0c1tjgXbyWNNpGFykzPsf2exLv7drCg3+BP1ct9l/GE7aYyYUjdC9jIt4edC91tE1d0ljiAzFT08U61vN9RdHUpYADOrZAmthjaup6Qefog34uagsm+sU/f9V7/j+/q+oqHbeR1QMAAAAASUVORK5CYII=>

[image2]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADMAAAAaCAYAAAAaAmTUAAADC0lEQVR4Xu2XTahNURTHl1CEJF/5SmRAvhNRGEhiwMhAMcbAyGeMzsTAREIp1BtJIpn4nFBkwEyJQiIRQsyk8P+9fXb23ufsc+/r3mfy3q/+nff22nffvdZZa+19zQYZOIyWRqSDHdC19cZLG6St0jxpaGyusETqkcamhg6YKV0pn31miLRWeiTdlLaXuiO9kJb/mxoxXborzU8NYoJ0X/pT6pu0IJphdrC0eb2TFpa2NdI162OQhkvHpNdW3TS2s+Y2sjSxEYATUpGMp2yRvpvbbBGbeiEgD6W5yTjrn5YOJeNZ2OwZ6au0IrF5SLUv5hbmCzxE+Xn5bKKQdpmL+jNpcmQ1Wyydk4Yl47DK3GdmpYY6dku/y2eOcdJj6am51PEQsevWXKijpPPmok8weDvbohkunfcmYx7/3cxpZI703uqjFeIXfCNNKcdwAEeO+EkZZpuLOvOJ8k/pljQymEOKrw7+TyEYFyzOigqFuUgdTcZT2NAHi53hyf+b/aQMm6QD5d84gCM4hGNAoC5ZczDJABrJmNTgoY/fM5di62NTBezMCxdcJn205ohCYfH6pBgB9PVHPVKzdfXiIWBhICv4yFLYLNjESat2Ipx5Wz5z+HqZFozxBkhrmgFF3VQvHpwhM8iQWrwzjR6LGebOmc8WnyXtOBPWS0hhLjh7rHW9AM78MNf1aqEr0Z2anCENDpv74n2JrR1nOF/4fIpvPKTpbYs7ZB0t04wcvSj9snxkOHc4LDk0OY9CiDobosBzFFZfj/4wJEhcWZrqBUjFV9bcJHpPdDbbY9XNrpM+ScctbqMe/2Y5DOuYaC7qi1JDiW/Tuc+H0P5bnWe9cH15ae5O5u9j3M2emHMo19sZJwg0h5BJ5tYK71unrHpZJUBXLZ8VHt4ab6/tKw1fREfjlkx+TrW8EyG0WTbOWdFf0PHofv5c6jf4qfBA2pgausgOc4dqWgb9Ah3rstXXVacQrBuWvwB3HdKR6wpqJzXbhbUKc0dCN9dtCSmwX1qZGjqAX7o77T87MsggA4G/J2WStVh5SPcAAAAASUVORK5CYII=>

[image3]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAaCAYAAACD+r1hAAAAzUlEQVR4Xu3RsQtBURTH8SspokRSVslgYDAbKMrfIKtZFgMjo1JmyYBRFrNdKYPJ5A+wKJOB73n3ek96ZX2DX32G0zn39u55Sv3jtfhRRA1h+JBFFaGPOStRLNFBD0eMMcQUawTfw3LTACVTp3DBCnlcsUPE9FUcfeXcUMANDQTQRM70XCODd6Xf8zPyeTPsEfvq2ZEHT9BCAielD8lhiWxJenbqeGKEMh7omp5cNkfG1FbSOGCBDdo4K73OLSrOqBPZUFLpn+dW/+OxvAD0xRzAnkbIJQAAAABJRU5ErkJggg==>

[image4]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGYAAAAaCAYAAABFPynYAAADxklEQVR4Xu2YS6hNURjHP3nkVeKKMCKPvJOoGwohFAlJIQMhcksMlEduokTej4lXBp7JY+AxkG6YKWVgJImUDEwUJQO+n29v+zvLPXvv073nXK79q3+dtdc5e6/1/df61ne2SEFBQUFMF1Vn1+6o6u7aYX+ldFD1cG3uxT0LUiBoe1Rj3LWJqgbX3qZa4NqVMkC1X+xZwL24Z0EKg1VnVd3cNYw54dqtYcxFVc+oXRiTg+WqtcG1wpg2pqvqjGpIcL0wpo3hXDml6hRc/+eMoVph0FOjz55e0rLKpSXE45ojVv1wyA5XzZbSsyNko1gqC8lrTJ3YdZ4VV16MYaj/klTZGIJ+VLVd9Vh1yPWNUH2U5idZbVgQl1VbVDtUL8TGuU91TnVLLGWF8LsLqv5hh+QzZpHqimqF6qnqtOqqapPqjWr6729W2RhW306xCT1RXZNk1zC4z6rxUbscu1TvKtADVZ9fv2weVule1bSoTQDeigVsnOqTqkmSgHjqVQckKWE9WcaMVp2UJEPQ/03snsdVP1QLoz6oqjEbxALPw79K6e6g3Hym6u2u1QJMY7HEO4LxsUBYKARtlWpU1BfSqJoVXozIMmaZJIsB/PxJa6ulNIXmMYZxYioqN+ZUGlXvxep/YDAMirTQ3OqrJRjyRSywafQVC1S5hZRljCfP/LOMmaDaLJaBpohlC87x3HDjJtUNSSqZkWIpY33UToPfM8i86id/FhnlICgEJ8/OnSt2HpWjEmP4LouBRVGOLGP4/FrsvCOuxJddmBseQA73N2VApLZJqvmqla4vZKxqaQWaJ+lVFecdAVwntgteSunK5Vykz0PfMUnfVVnGUHldF4sHC9LvUsZ7RGxRxWQZw9gni42NtHxXLKXlBkdxlsoMCMxDMbMGiaU5dlCtwDgOWirEGarvkkyYsRGMsHQlBYevYELSjKEkZs5UoRQYVH3Mn+DDErFzz6e1LGM8PJsYk95yw8O2ip0xlKI3xYqCD6pHYiWqH1C14R/7c9Ul1R2xPP1KbGz3VDOTr/6GooX/L2mkGcP8GsXme1ssJd6PRDXISvdvkiGvMXHpXx925IUHsHvicpHtVye1NSWGZ/uzKGx7yN8EHEPTSDMGmCfzjQMdtkPyGIMpB8UyDuMcVtrdvmHSBDx8BROSZUylZBnDAt8ttlP4LudN+GK1XVPuFUxIrY1ZI3ZWei12/e0aDnuqMVJwFhhz2LVbw5jzkpw9oTH/NQPFdkyec5B/735nLZHs101pcP40uDZvDSjlCwoKCgoK/lp+Av29wL+havvFAAAAAElFTkSuQmCC>

[image5]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA8AAAAaCAYAAABozQZiAAAAZ0lEQVR4XmNgGJmgHIj/k4gPADEPAxKogkr4IgtCgTEQfwXiw0DMiyYHBjAX4NN8gAHNRhgY1YwKhrtmEI0OCGqGJU+SNGcA8SsG1IT/DIhdgFgXiK8A8V8kuS9AvAKIuUGaR8HwBwBse0VGGvGD+AAAAABJRU5ErkJggg==>

[image6]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFYAAAAaCAYAAAAtzKvgAAAEdUlEQVR4Xu2ZX6hUVRSHf2GGlpZpFFF4LXqRAh+iIAisKElEAw0R6k0kH4RLQQn9oUsRokShFVhJ0oOoGSKUESE4UIQoCEF6w67Qg+WDlC8mpmiuzz2b2bPOPmfOzODow3zw486sfc6cvddee+21z5WGDBkSmGy6zRuvMfTpJm/sAGPgvusCOvOp6VHfcI15yfSsN2aYZLrTNE1hDNvUZ5A8aTpl+r+p701Tk/ZbTT8k7Wi36ZbkmhtNn5hWJ7YI94+aPjO9Zbq7vbkrGPxy0xxnLwPHbDXd5RsSbjbtUmtsC5v2F02b1Wfk3qAw8POm/0yPtTdfYanpa7U7PfKMqaHiDI+YfjGtMk1R6PQxdRfVPG+xaaPpT9O/pofbriiHcazzxhJeN5003d/8znO/URh3z9xu+lIhspi1jxWcnfKK6QVnAzpAlK9xdqJ4i8Jk8DnynoqrogquY0KeML2t7hy73vS4N2agf/SzoZAKIitMP6sYMLWZZ/pQYZmOm06Y7kvaefDnzes8DPJ301xnZ+aJgLXOTgR045wUfqvuvSx/0kAdp9xj+sO0ydkZw4TqTU4WIpEkD2MKUZtG4B0KEU1ke7jvR9N0Z3/adElFx7Ks+f1c9HeiG8eyYb3hjQk4fIHCb81XSIFL2q4I+8g+hTTREx+o1dmHTKdNB9SabWbso+ZnDw5HnujAMsd6ex3qOjZupozFw2b0pumQwuSSrv4y/a3iqgPGRoXgU2NHYn4lKoFObVeItlimEJW5CCMfNRTypgcn5Bw4CMeSxnCYz+M45zWF1DWnaZtlOqxifo3wzIbybZXE/JrOCA7FsTiYzpXl1+jYnJPY7HIOHIRj09SWQpXAkh9LbGX5NcIzie5cGqwk1wlSAKmAlPCUyvNrlWPLHFhmr0Mdx1LWEQixbErBeRfUvhnxOZdfIzzzuKpr4QJEKbnzEd+gUCDjgKMKZUuOKsfSYQbh26Jje6kP6ziWvEp+TUs8iH09olbaA36zLL9CT6nA59cUZmhc1Tt4rP/IZ56yJcbqSAcSj5JEWifqOPZV5aMvOpZdPp4aY/+pamaaNphmN9si7B/pPbVgmXM85ViXY0zVswk4bq+KjmE1vKv26oId+SuF3B0jaqXC5KW2MnDsWeVXGPAcatfcsqU/HHwaakXfMtNFheBiw+MIm46De6gIfHCUQo15RmFAiByzqO2KAMuKU1Iuv0aIjl+Vj3oG+p1pp8Lp6QvTT6Z7k2tIDecU8ljuPQKRssP0j1r9RZRIlIkpbE5EXVlpxHOJTqJ0j8Jxl9JrwvStikdtxn1Q+RVw1WGmf1P56YSlztJ9vvmX7x6ihFyfi7RuwEll/Yikb7EiM9z3CBNFOmSMAycu+dz7hbrQ8ffVORVUwYphRdQ5wtYhjgv1Oq6+YYntNz3oG2pABOFU3pD1Q6cjbLc8oLBpjfiGQUN+YmPqNmLIq8+pv6jg3neUP8L2Apssm2AvJeFVgSpj1BsHABvcyyoeYXuF98d1/uswZMiQIUMGxGWUrd7pPknqjwAAAABJRU5ErkJggg==>

[image7]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAAaCAYAAABByvnlAAAEu0lEQVR4Xu2ZWchvUxjGXxkyyxDJ1BEKB8lQZheIZMipk3JBnHOUKJQhlC+SzJlnkowpJElJn7gQpVy4kgyJXLgkbvD8vGud//qvb++91t5nn3P6aj/19O211v7vvdZ63mntz2zChAl12EbcOmnvIG6RtPtiS3H7pJ0/f0PQNbdtAzcn8rUPwlXiceF6R/Elce/ZcG8cI16TtG8Sz0vaQ7GX+LC4XT4QcLd4Qt65kbBV3hFQmmMV0g0bS5BHk/ZYglxsbjxNYCOeMp//xsax4rfiufmAuffeaxtoGMtBECySZx6aDwR0iTUmjhe/Es8XF8WL5kYdJ4u35Z19sBwEQYgnrTlU0EeYWJEPjAzy133ivqG9m3iPuM/6Oxy7iC+ae+0gLAdBsH68oAkrxcetWazNBeaLFw1CrSC7m993iHmsxGLOEg9Kb7LxBSFBPmftHnCreHbeKewnniPunPVTiQ3JNVSKpwZyTUXFWglRXKfAo9mDQUZSI8iF4mviJeJn4hPi6+LV4vfi6evvHF8QEiSJsqncJTy8IO6R9RPbWQch5WtzYwKI8bb4hi3dxC4cYP67deIj4ifis+IN4ofiA7Nb/0cp53WiJMjh4mM2O0tw/9/mG8Xk/rV59xxbkDYPAPQznmJPc5EQ4RbxF/MNBQeKv4rXh3YN8FAquBgJWN8f4oJ4hviPec7IDWZwoVESZLV4StImfHwp7moevi61+bq7RpDDzMWEXLeBdzCf3AMAG3CX+ftSUJauMfeez809O4YOQhjGRJipBUJcl7TTZxC28ZqY6FOQ1BGKefRCSZAUbBBiNFlEREmQo8VrzUPGSeJP1r5BWOBC3hnAZmC5bXPFg/+0+WIAAX+wpZVRH9Q+AyN9Rtw/HyihjyDRXcklbSgJQvs7cwvCct8y97ocCF46ZHVVX7yH8ESYAuSP9wOHfmJhfxbN51xK2FR/5JY2w21FSRAqqTdD35XmgsQwgRU8ZB63I0qCEH44YDHRuEmErhxYIJ7YVRGx2byraXNYx6LNfh/zB3mFtSA239nwVObfJhLhiALmTPMk/bv5miLWmu9Rjq7c14kuQQgLH4m/iUeaVxo/JuOrzE+lqRWUBEnBvXgLYSxHTVJECM4gWGMOvO5TcSfz+d1oXoAwFzbq8nDfFaE/zTUpKAAY577LwnVcD8XCyzar4iII7U+Hv73RJQgLWRA/Ft8xV/2DQBaAZSNailpBSHavWnNI6troHGxumnQjSO4/m4cXytybzdfxhfiezbyauf1lbhhNoZr8Run8irnH3il+Iz4vvmvNpW1T9VeNLkEAomAB0fXzdo4aQRCDzxAshs0/eH64MxTlIBe1VTOU6ozHuRKeCJn5vwMIV7yPe5vA71lzjAR5OwV95I4aY2pESZC+KAnCZtxu7hm8h3xCHE5Buy1ZNwFrpCIbihXi/VZnACXwLKq/tpxUxKYWJMbslOlXUwqFrk8lTeCdlKNNFlsCXoMYJO0x0NeYloDjP4cdMJYgDybtXJAScPU7rN/mDhExgrVeYP3e14Z4qi+dUTqBdR4RrnEzEmRbfqgBp/fUQlaJRyXtEighT8s7K4DoJ+admxic6jHwMcSdMGHChAkTqvAfiCTYqmriqAQAAAAASUVORK5CYII=>

[image8]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAZCAYAAADnstS2AAAA3UlEQVR4Xu3SsQtBURTH8StMlEUsSkZlMymLshgo/gKTyWKSzDJZ7GaLf0AM/gTKZLYaDRj4Hvfduu+6s1J+9Yl3z33XOc9T6meSRAZRt2Cnhhue2CIRLn8mhzMmbsGXqtKnt9yCL0NcUHQLEhlCCk1kscJO6SFDkU17TNELvt8xtzdJ8jhhhEiw1lX6SYT6jWGp9NQFa93br1zIovQnN0rk09uvDCM/17DW5JE90EEFA1MoKX2y6S2l9D92RRlj1IPae6A+DlhggzaOWGOGuNls4r4wsiFtXf/zpbwAH9wkzOofuXsAAAAASUVORK5CYII=>

[image9]: <data:image/png;base64,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>

[image10]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAaCAYAAACHD21cAAABG0lEQVR4Xu3TIUtDURjG8XeooEwUNmxahmVgUxDbkiytKDjQZhAMpo2hWEUEw5jBbLOY7DKMWzJYBEHBL7BgnPP/eO5113f3Ewwf+MF433POPfecO7OxyCxK2MR8VMtjIR7gM4VTvOIIh+jiEo8oDocOM4lr3CKbqOtJHbQt7GQkG3jHim+QE7R8Mc4ZPrDoG6SOii/GucEAx5hwvWXkXO03VQsTpY8H7GMuOSgtOtFzC5PiBeTJ0rc/Em1Tx36BnoXJB39GRNFAvUPGN0gZX2j4hlLAlYV79FnFJ3Z9Q9Ex32PaN8geXrDkG4ruT6uuu7q2r4PZcvWf6BO6Qw3P0W9dQRNv2LH0d7cZCysruo41bFv4Z6Rt/T9jlG+J/Ct4t2V5pAAAAABJRU5ErkJggg==>

[image11]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADQAAAAaCAYAAAD43n+tAAABk0lEQVR4Xu2WPyhFURzHf0IRIaIUiyzKIkq2V0pSLBTFZiCDyZ+IUVIGMZhtbzFZTBIbk8GiFJJRGYz+fL/vvMu9v67XPbecR51Pfep1fufe1/f8vSIez5+hGmbgAKzNtzXAxqDDf6EcrsFbOA/n4CXchmew47urc7rEDHBiyuA+zMKqUDtn5gKeipk5l/TCJTGD+gGXo+XC9MF72KkLYBXu6kYHMNAwHIKvYhloAz7CFl0Ai3BENzqkW1IEOhAzrSuwVNXaYb1qc0mqQBNiAtE3eAKnYU24U5FIFYgn3KaYMEEweiXxyzAMZ+8YPli4nnsyGakCBXC58Xjegi9iQs1EerjHKhADcI+U6AIYhO+S8EW/iFWgNrgn5h7SBC+a1AUFB4P3VbOFdbknk2EViMfxEazQBTAFb2CrLii4//rhmIW8Y5JiFYj3DzvrP+Ay5IEwqtqLQRCIF3xB+ClzCBfgdf43j+odeAfHJX5vuWIWPkn01H2G57Ap1O+LSjEzQbhsesQsh4zEL0GPx+PxeDw/8AkBWVYSa8letAAAAABJRU5ErkJggg==>

[image12]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEEAAAAaCAYAAADovjFxAAACg0lEQVR4Xu2XzUtVQRjG39DCUBBbJNQii0yiFkG4k8hokYtCKMI+/AuEoEVICSVGSAVBQQTVxpUuhAhyEYG1rFy06WMVVKBBUW3ShVH2PLxnuHPee+fqGdGN84MflzsznDvznPm6IolEIhGmE36HC54/Ya/X5qqpfwzrvfrVoAaehC2m3LERnob34Q3Ylq9eGg/hP3jYVoBW+AqehXWmbiXhwI7C23AazsL9uRZKI3wm+rIa4D74Hh73Gy1GE5yCn+DWfJUcgk8k/AZWEobQBQ/CKxIOoV+0/xyH4wz8AJu9sqrshj/ghJTeNKffOTgs2pkibMoMwWdvgetsRRU40EohuBc4Ysrb4W94zJQHYWpc6/whwvV+V3RfKNJRB5fPI7jNVoD18DK8IMWeHQrBvUAbAtux/TVTHuQO/AM74C74Br4UXWuxcF0+lXwQsQGQUAhusKEQbHlF3HT6DPvgqGgA3CSPeO1i8INYTgAkFAI3Ts5iO9hCIbjp9BcOiHa2R/TBDKS21DQKBjEJH0h8ACQUAjfOZYfg9oOLUuogd1TurL/g3qwsFobK5fYR7jB1RQiFEBpsqLwivB+4/cBnUDQcfsbCAG6KzoA9oqdPpc1yKYRCYLBfpXywLoRLprwMtx/wLdnzlDOAM6HQWevhB+BmGJdebBChEHg5eiH5453w0jeffVbFpTUu5Wuf31nO2cCbYhEYwHV4Xsr3gNggGMKc6PlvYf++wO3Zd/4mb49VTzimMyP5/wPf4KmsfjN8berfwp1Z/WJ0il60bAAOPmcIbrAVBt5XxkT/y/h9Yd9vee0Y+j34HHaLBvBOdFNeUzBw3nFOwAOiwSQSiUQikUgU5j/yFJB7Zel+lQAAAABJRU5ErkJggg==>

[image13]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABMAAAAaCAYAAABVX2cEAAABGklEQVR4Xu2TsUoDQRCGRxLBYBHSmMLGIhEEO1ubiEUeQVGfQEgbQppACnvBzt7GJhDfwWhhE0glaGOhaKpUouYbdpfb7BlcsArcBx/H7gx3c//tiWT8lxq+4Y/nB554Pd2g3sNVr57iEr9xPyxAFQd4jCtBLUUJ7/EJ12dLsod93Aj257KF73gjyZNz2MAzLNi9KI7EZNG0a83jQkxuS64plnP8xF3cxAe8xaLfFIPL6xlP8UrMjfRj1L2+KFxeX9jGZTwQ89p643zS+jcur5Yk+ZRxhGPctntR6Plyefl0xDxEr1G4vB7FTOOjE+lkOmFY+5UdnOC1pLPRte7rdHry56K/zIvM/m+veGjra3gX1IdYsfWMjMVlCn+/PCJqzkDYAAAAAElFTkSuQmCC>

[image14]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABMAAAAaCAYAAABVX2cEAAABHElEQVR4XmNgGAWUAkcgfg3E/6F4BxBzIsnzAfEuJHkQXgfE3EhqUAAjEM8C4l9A/BOILVGlwSAIiNcwoFqEFQgC8UIgzmeA2DyFAWIBMigC4mg0MaxAH4j7gVgSiK8D8RMgVkSSZwHi2VB1BAHIxnQou4EB4rocuCwDgwgDxOUgHxAEfUBsDGXrAPF7ID4BxPxQMRsgngxl4wWw8ALZDgIgLy0H4n9A7AEVA7mapPBCDnCQISDDQIaCYo+s8IIBkPdA3gR514mByPACuQYUFqboEkAQwwCJiGtA3IkmhxWghxcyEGeAJBOQgUSFF8gLoKzBhS4BBQ1A/BaINdHEUYALEH9hQOQ1UBbyRlEBAaBkAsqrBMNrFIyCIQMA260zNBT6yKgAAAAASUVORK5CYII=>

[image15]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAZCAYAAAA8CX6UAAAA+UlEQVR4Xu3Tv0sCcRjH8UdQUFRcBIWcGgShLdSlhsA5on/C/0caW9oaWoSChgbRv0FcKwJByKYCk9L38Xi/HtPLzeE+8ILjPndf+D53X5E4u+YMYywCppisrr9xj6r7QlSuMceJuV9BFx9omG4teQwwRNF0TkoY4REZ04VSwzvukDSdmxvRZ5xnN+ZcdB5tWwTiLPSFui2C6cjf83GTxRM+cWw6Lzn0ZPN8nBzgWfTrHoYrP/+ZTwu/eEDadF6i5pPAlehCl6bzEvXZy+iLzqdgulCORH80u60ULkTncitbFjnFi/hH4gdveBU9GjPRY9EU3VqcOPufJU75NY0EHNwQAAAAAElFTkSuQmCC>

[image16]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAZCAYAAADXPsWXAAAA/ElEQVR4Xu2SwQoBURSGj9goWUkpRYryABaUB7BgK09g5RlseAFZKcnCI9hYeQIrslJIJMlGShH/deYy9xozS5v56mum+e/t3HvOELk4kYNr+DB5hlvj/Q6HMCU32NGCF5jRvifhAs5hVMsUAnAMZzCkRi/6xKcq6oGZBNzBHvRomSxwhVk1UikRV6rqASgT96UNfVqm0CSuVIARwxiswz2sQO97tQXyuAfi63QMu8Q9asCgXPwLu37EiSczgWE1UrHrh0BORlzVEqfR5ol7NSJea0kaHuGA1KuIJorKJzglbvIXosKKPr+5GOGG+PcXzxtcwhr08xYXlz/xBB76OKePI6vzAAAAAElFTkSuQmCC>

[image17]: <data:image/png;base64,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>

[image18]: <data:image/png;base64,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>

[image19]: <data:image/png;base64,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>

[image20]: <data:image/png;base64,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>

[image21]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFYAAAAaCAYAAAAtzKvgAAADdklEQVR4Xu2YW6gOURiGXyHkVMghZJOUnLNxg7ZDSnJITjtFkbgQRSglF5LcKBKRkgtRREIkSbhwIeVCiuSQQxRKUcjhfX2z/DNrz/wzf1uzk/XWU/+sWbNm1jvf+tb3DxAUFBQUVJamkNfkZ4z35G30+yu5QIa4C1pQrckiUue1SyPIQtKTtCKdyCSyNN4JNsYscoDsIzNI20SPirqQ9eQw2Rod16wj5BuZ6LX3I+fIBzLeO1eGOpDZZC95ST6RsYkepiVIBod4TkbH+sjsU2Qt7AXUk8fkEuka6ydNJY/IMtKHbCJnYM9TWJ3JTXKf9PDOSb3IA3IZNQ78F6T7zSQNZDuyjZX5MknchkWaH2HTyQ9ykLSJ2nbCXsJq14kaBnuJi6NjzV/jPoOZXFhDyTtyGpUb+joG66O+LaUtqG6szldTA/lOzpL2UZuWuIzdEB1r/lq98SBTalFKWRGdL6w5aPrWfMnYz2Scf6JENddYGdQdFVO1GrQK42MOJC9gQdYOljJ0ja6tWUriafnVqSO5iuxJlaU8Y/XyZZSW7ROyCrZZpUntK2HjKec641y60IZ9CBbJJ8gt2H5TWEro15GdX6W+5CmsehiUPJVQI2zDKModMvj3lcWUZ+w10i061riKvM1oGm1rYPd/Q7bBAsdJ42j1xu+jqkHp4wrMr0Iqkl/dW7yIyjJqCVUzVs8VfzaZeRxmrpZ3mpQKNG9FuNs7nLH+XHVveSAvCikvv+oB98MGne+dK1vVjE2TUoPmpqoiS5qT+pxHpQLRsa6NS/dWe14e/6O8/DoGVsOqSM4qpJ30hlWOFEVlTN6YcWUZqz8vKo+cOU7OWEWhNI3sQTJXaiyN6UqpUeQjmmlsXv3am9yAbVx+AZ2mAWRBDcxFJScWUZaxzpy4sS4VuP5uL/HNcUvfeaB5qg72U2NNqWA4LBr9QRRF82Ab1kkUM7UMaXJpJZ+eTybWxdr0W7nTrTRXnz4kI6M+Mn8HzNiNUZukzU39+kfHhTcv/YdW6GtAoaJZSV47pb4RfIGVGxPQdEctW9qx9XL1/cI9r3gFW9ZO9eQurOBfh/SgUArQCtTfWhX8u2DfQnYjmZJ0z6Ow8ZbDyq17sBX5X0qG6KOKVlsd0oNC9asqAKUipQEV/2nStcrd6jcZte0FQUFBQUFBQUFBQf+MfgGrPdf1YT6k0AAAAABJRU5ErkJggg==>

[image22]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAAAaCAYAAABIIVmfAAAExklEQVR4Xu2Ye6hlcxTHl1DkbTxDLnkk4zF5pdBcIf4geURNUWRG1CiaGaNRt5A8kuQRYTxSFEmeU+LGP6bRjDSoQR55lEIp8sjj+7H2mrPOz9ln73PuzSj7W5/uuXv/9t6/vdb6rbV+26xTp06dOnVyTYqvxZ+J78Q31e9fxQvioLhgE+pgcat4QJwrNk/nDhPni93EZmJbcaJYkMZsJS4Sc6vfXL+3WCgmesP+1p7ievNnXSP26T+9UTzrOHGXuFecVB0bWQ+K38QJxXEm+Jz4XhxbnBtHMeHXxbXFuTptKVaINeIosb94Xlyexlxo/UEEn4sj05gdxeoB4243f0boTPGSOELsKm4QP4tz0hi0jVgpnhWHiEPF2+LUPKiNthNvivfELsU5tLv4QLwiti7OtRXRdrL5c24Tc/pPDxWG/tB6UXqGueEejQHmRvu44i1xldg+nUesihfFevNxj5gHQ45YVgZjCLh51TEcTpbI9uGaO8UbYofq2NXm81pW/d9aeO9b8bTYojgX4mUZw9hRRGQRne+aR3FplCax9DE+SzzEC3MvjBfCAU0vjgN4D9JLnXAAEf27mF8dIwt8Ye40ghGxEn8Ui6r/EeNuMnfYSDrL3HP5ZqWY+E/imPJEjVgpl4h3xKXmy3UcRWohl2McjIchS82WAxDPYYXGyjhd/GGepiNAp6yXsrkv9+S6sUR0Dcr/IYz3qrnH8fwwEeFLxVpz4+XcOo6YGw4gDz8urjR36i32z7yNcUmTROon4jLrL9QY6ilxh3ka+tK8vk2kMaWIatIM9YffKNIU9rhZ3G+eflipV9iIRZhJTVt9/kd7iU/N8+Cw5UUtwVFMbqfi3LjCqDhg2nqRf6D5XOhOQjjgNbFz9f8B5mmDYAiDcP0qcUF1DHDsBrFvNSZEN0W94h4EEwU532fafF55VUyKH8wzSmu1yf+nmC9BDNu0zGZSbAcpHJDT46CgYV55bhjrCXMD7peOESQ5QkmppNapdKwU7xNjWHXxfGyCbUKkoc+snZ02qin/M9m7zR9WtmHDxHXRbnJ9U96tExHG/IjwUBigKSWG8+ia6hTFlJVbV6eiS6Qw02LWpeRwALR+36b8TytGS8aGZJx8jiMOFy+bG4TN1CiK1m6YA9gkks/ZG+Q2ORwQ11I3eNfcp4cDps3vS4c1ZV7080qJe0WhJzBm7ICm/n8P8wKEt6PXnYlIBQ+ZOwOn5Bes0/HiF+vf0ZYpKIyYHcC9SUHZSBgxojgUKWil+TU4C0NnI+acH5mCBoN55cAdOQXNNY/uMv8T6WebF94nbXaMn8VESUts9ZuEQTFsLnZlEWZ+GHui+h/xm24or1yMxu47HM/f5da/y8dZfIq50XrXUdC/Mt+MRidEkaaTyq3vpLUswnwjwVN4FIgKihVbd74B4Vm+/5S7xE0lGoX3xcPmewo2dfdZf0o82rxbuU4stsHBw/h7xDPiYvGYeQOSawTvSyvJ6uJerLx14iPr/6yBKM7YjVaUZ/KboPgv2GzWhfH40HWeec4f9JIUx9PMV++EDR7DMa7nPvOtPlXgOO7FOFZF3k9k5WfWfbD7V8UHL1JMG6Kv7zRLIpqWmOfdNpCTO3Xq1KlTp06dOv0v9BdVyBR367bpOAAAAABJRU5ErkJggg==>

[image23]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAZCAYAAAB3oa15AAABt0lEQVR4Xu2WvytGURzGH6EIpUxKeRlYZBFWi8FgEyYG5U/wY6IMUlKKDJIfC5JBkUSRLHaTMrJhIiXxPJ17e++9XO977n2Zzqc+vW/nnHvf87z3e885gMPh+GuKaT/NRNrjKKNDtMX7ruvr6Cjyv0dqymkvXaT39IW2hUbEU02v6WfEeVoaGBdCSWWhUIAe2kWnYBegkh7RG3pHN2gnLQqM+UYjPaVztCbSl5Zx2AfYpLXRjlwoYSs9pmu0IdydmH8LEKSZ7nnqexqSBNilCzBlpHfoAAlfYD0FPY1L5FGHMSQJcEIHYH5PztBbWh8YZ4Ue5zKSBbENoHtXeZ8+7fSVTgfarNHLvUKvYPc4bQP8hK7VPc5oRaQvJ/r3l+g57P99YRtAK+E77Q60+QEuYEosL1T/q/QQZnWynbjPbwG0y2YQ3oO0An0gHMAvoXXkmIc6C72UKoB+XJOIMgKzy27TEq9tkE4gO1F9TtJn2uG1fUODVB4qE5VLqjUYpk536BPCx4EHmOXRR8eNNzqG7IR1XNCCsU+H6RZ9hNnZY1HnLAq/CydFYZpoH8xxpJDHHIfD4XBk+QLBklMbJOoxsQAAAABJRU5ErkJggg==>

[image24]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADEAAAAZCAYAAACYY8ZHAAACiElEQVR4Xu2WzYtPURjHH6EIUaSEjLc0GxaSbDSKsCApJWTjDxCKvNSUkrwV8v6ysNBMXprNFKEUSrKh7KzYMZnZYInvZ55zuveefr/p/l5o0v3Up3t/99x7f8855znPuWYVFZGxcqacnDYkTJLj04ujgamyT56R9+RuOaZwh7PI/L45acPfhmBWyovyitxmPpp5DskHcpycLl/LF3KDnCUXyyPyi9wcnvlnENQFecJ89AiG4D7IeeEeOvTMPMjIYbladsmdcrvcaz4QvHNEJgTbRaf8Jp9YlusE9ds8IGCkP5nPRoTzTbnfrBXSrFQaLZBP5SnzaW2VJeYp8N6y920178St8HuKfGnFThyUa8M56Ug8DaURDy2Vj+RtOb/Y3DDTLJsF3n1J/jLvTOScvBvaJ8prcnZoWyfPW4k0qgcjeT/IeSsQ4Ho5KM9asUyyPt7Ko+YB7w/XSZ+H4dgyzAazwqKk0tQqfyNBanyWX+V1OaPYPAwzwKgvM38/I0+HYhrRvkOelgvDtaZgEV625jvDhnZSDlmW8/Ug+JhGzNoN2W1eLFhPsbo1BQv0qnwlO4pNpVghf5qXWapOLdI0WiU/mhceYP/YF84bgllgUT638rNAgaCUcozEkvpDLs9dj6RpBKwRnuFZoHPsPaVhPdyU/ebBlAk+cse8nHKMEDgdYP8gNVLyaRSh/OY7wZHiQHrWhUDbUWb58wHz6Y/sMu8YKZmWTUaYTS1NM8pxvhMMxPGsuQjBkyqkDKkTH2oWPux6zD8r9sgD8rvsDW15YhpRoVLmyndyjXmMx6z2fcNsNK8e7ditI/xph9wSJKBadJkHVy9dKQhv5GPz9TAqP8crKioq/lP+APcAZxEsPOItAAAAAElFTkSuQmCC>

[image25]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAE4AAAAZCAYAAACfIRhSAAADRElEQVR4Xu2XS6hNURjHPyGEECUhrjySSHGTQndgQB4JSSgjlBGDS5kYSGJA5FEkGYhiooiiXI8ixiglkUcIKQyU+P98e92z7jl33Xseu660//XrdNZer/1f6/vW2maFChUqVKgR9RZrxPiy8qABYp04KQ6IKR0f/1UvMUccEcfFEvN+/zthxjJxWLwR38WsDjVcQ8QNsUcMEjPFE7EqqoNpO8Rt0SSGi3PmRveN6vWI+mfkJYxbLFrEbksbt1M8EsOisvXiqRiZ/afdezGvvYbZBPFSLIrKekRMhJXfb76ieQpzOjMOszDtbFl5s/gmlmf/95qbNKq9htlgcVecMd+RPSomMENcE6fNwyIPpYybKj5ZpXHUoz6GEQVXrdI4wrrNSrt1qBhnnh5Gm7dryf6HjUBOpO8V5vm23PCxYqPYIqab7/A+HWpUIRL0xYzOknUtShkXDEoZR3kwKGVcKN8uvojf5oazE9eaHyafzXPmBbFZtJr3v81K2iTOm5sPHEC3zMepS+w6dt8d81OtfJWqUco4dgMv2pVxmII53RmHCPEf4rp5jkVjxGvxVkzMythFl8zb089AcVOszJ6jEeJE9rwhMbljVp+BKeM4PLozjgPiuVVnXGhHqAUF4zmF4znTd5t5PyEdvBNbxSTRzzyP1vKeSZErWIV7lr6TdaaUcXmGKgrt2MlBwbjyMWLjENegV+YLCV/NF7YhMfhR85ivdbehlHGc5Kxy+UsFA3ZZKaxSxnGysjNQI8Yh7oSzzcelzUcxLXpetZrEKXHF/LSt1bCglHHh5QmT+A65UPzMfhHtOX05hYPIQY/Nk39QvcYBhwmncRD5kLwY99WlMCfvKwkvTtJuLn8gbTAPkTAO4/MV8cD8qwLxEiR4Tsmg+eKDmBuV0T/jxEm+K+MwngXAOKKJuQSRW+9b5WJXiAkThnRAWMZhUY84qTj+uQqEvAGs4sGoHuFB3mRc7leYxguRc2Jhxgvz68RG888yEnmIgkPil5XG4RrVan6RDmXPzL9K+A1lPF8qLouH2S+fcixc3H9SJMJ9lv9XQzVicpPFarHA0t+fzI3QiS+1eYjxWWjE7mO3peZQqFChQoUKFSr0r+gPPGDIUVbY/FUAAAAASUVORK5CYII=>