Public-Source Architecture, Kernels, and Fidelity Audit: TurboVec

1\. Executive Recommendation and Audit Scope

The engineering analysis evaluates the public TurboVec repository as a candidate vector-search substrate for TinyRustLM, a pre-release, browser-local, CPU-bound AI chat system processing 0.3B to 2B parameter transformers. The evaluation boundary strictly targets the public Rust source code, published package artifacts, and accompanying public documentation associated with the project. No proprietary TinyRustLM code, evaluation cases, or unreleased execution environments were inspected, modified, or executed during this assessment. The primary engineering recommendation is to reject the turbovec crate as a direct third-party dependency. The crate's reliance on heavy system dependencies, dense memory allocations that threaten browser memory limits, and target-specific SIMD kernels lacking native wasm32-unknown-unknown support make it unsuitable for direct inclusion. However, the engineering analysis highly recommends reproducing the underlying TurboQuant algorithmic pipeline and SIMD memory layouts via a clean-room WebAssembly (WASM) implementation tailored to TinyRustLM. The foundational data-oblivious quantization method—combining random orthogonal rotation, precomputed Lloyd-Max scalar quantization, and unbiased length-renormalized scoring—provides an exceptional memory-to-recall tradeoff that strictly aligns with browser-local resource constraints.

2\. Exact Public-Source and Package Identity Ledger

The following ledger establishes the exact software revisions, dependencies, and artifacts utilized for this public-source audit, representing directly observed public facts retrieved from package registries and immutable repositories1.

Directly observed public facts confirm that the crate relies on a heavy dependency graph for numerical computation and parallelization, including faer ^0.20, ndarray ^0.17, ordered-float ^4, rand ^0.8, rand\chacha ^0.3, rand\distr ^0.4, rayon ^1.10, and statrs ^0.172.

3\. TurboVec-to-TurboQuant Correspondence Table

The analysis strictly separates three distinct quantization problems to evaluate the project authors' claims regarding algorithm identity, ensuring the boundaries between model weights, active memory, and persistent search remain distinct4.

Claims made by project authors state that turbovec implements the TurboQuant algorithm from Google Research4. The engineering analysis determines this is functionally accurate regarding the foundational rotation-and-quantization premise, but turbovec critically modifies the scoring formulation. Instead of utilizing the QJL residual for dot-product unbiasedness—as heavily featured in the KV-cache variants of the referenced paper—turbovec stores a per-vector scalar correction derived from ![][image1]4. This modification adapts the theoretical framework specifically for persistent semantic-search embeddings.

4\. Rust Module and Call Graph

Directly observed public facts from the source tree reveal a highly structured module hierarchy designed to separate ingest, numerical integration, rotation, and SIMD dispatch2. The core modules include lib.rs for the public API, id\_map.rs for stable external ID mapping, encode.rs for the ingest pipeline, codebook.rs for Lloyd-Max boundary computation, rotation.rs for orthogonal matrix generation, pack.rs for bit-plane to SIMD-block translation, search.rs for hardware-specific scoring kernels, and io.rs for binary serialization. The dataflow map for index construction and first ingestion (TurboQuantIndex::add) proceeds sequentially. The function receives a dense float array. If operating in lazy mode, it locks the dimensionality parameter. It then lazily retrieves or constructs the rotation matrix and the Lloyd-Max codebook using std::sync::OnceLock based on the specified bit width and dimension11. Inside encode::encode, the pipeline strips the L2 norm from each vector to create a unit vector, which is then multiplied by the deterministic, dense orthogonal rotation matrix. During this first ingestion, the system executes the TQ+ calibration phase, calculating the 5th and 95th percentiles of the rotated coordinates to establish permanent shift and scale metadata4. The continuous coordinates are then quantized against the Lloyd-Max boundaries, mapping them to discrete integers, which are subsequently bit-packed. Finally, the system computes the length-renormalized scoring scalar. The packed codes, norms, and scales are extended into internal Vec structures, and the OnceLock managing the blocked SIMD layout is cleared to force a repack on the subsequent query. The dataflow map for later ingestion follows the exact same path, except the rotation matrix, Lloyd-Max codebook, and TQ+ shift/scale arrays are already frozen and retrieved instantly from memory. The dataflow map for querying (TurboQuantIndex::search) begins with query transformation. The query vector is normalized, shifted and scaled according to the frozen TQ+ metadata, and rotated using the identical pipeline10. Next, the query is quantized against the codebook to form a localized query Look-Up Table (LUT). At this stage, if the OnceLock for the blocked layout is empty—which occurs after any mutation—the entire corpus is repacked into 32-vector SIMD blocks. The system then dispatches to the SIMD scoring kernel, which iterates through the blocks, utilizing mask short-circuiting to bypass disallowed candidate IDs10. Finally, the resulting scores are multiplied by the stored bias-correction scale and pushed into a binary heap to isolate the top-k results.

5\. In-Memory Representation and Byte Formulas

Engineering analysis of the structural definitions reconstructs the memory footprints of the core components, demonstrating the exact carrying cost of the index10.

The IdMapIndex introduces an additional dual-mapping layer, mapping u64 external IDs to usize internal slots via a Rust HashMap. This introduces roughly ![][image8] bytes of overhead, heavily dependent on hash table load factors and capacity overallocation. Original float vectors are explicitly not retained in memory, guaranteeing the memory footprint remains bounded by the compressed representations.

6\. Rotation and Initialization Audit

Claims made by project authors assert that applying a random orthogonal rotation redistributes coordinate variance evenly, forcing the marginal coordinate distributions to converge to a predictable Beta distribution regardless of the input data4. Directly observed public facts confirm that the rotation matrix is dense and generated using the faer and ndarray crates2. The pseudo-random number generator (PRNG) relies on a deterministic ChaCha implementation seeded natively, ensuring reproducibility across identical index configurations. The engineering analysis identifies the matrix setup as a critical bottleneck for browser environments. The rotation matrix relies on f64 precision during its generation phase—involving complex QR decompositions of random Gaussian matrices to enforce orthogonality—before being cast to f32 for runtime application2. This requires allocating a dense ![][image9] f64 matrix. For a standard embedding dimension of ![][image10], this matrix consumes roughly 18.8 MB of memory. If a model utilizes ![][image11], the matrix balloons to 134 MB. The v0.9.0 release introduced a MAX\_DIM constraint capping dimensions at 65,5362. Prior to this version, loading a maliciously crafted .tv file declaring a massive dimensionality could trigger an instantaneous, unbounded allocation. While the cap prevents multi-terabyte allocations, 65,536 dimensions still allow for a theoretical rotation matrix allocation of roughly 34 GB. If untrusted files are loaded in a browser context, this remains a severe vector for resource-exhaustion denial of service.

7\. Calibration and Correction Audit

The primary literature frames the TurboQuant algorithm as strictly "data-oblivious" and "training-free," generating boundaries solely from the mathematics of rotated unit vectors. However, directly observed public facts show that turbovec implements an empirical calibration step termed TQ+ to compensate for the fact that finite-dimensional vectors only approximate the theoretical Beta distribution4. The TQ+ behavior observes the first batch of vectors added to the index. It calculates the empirical 5th and 95th percentiles of the rotated coordinates across this cold-path data10. It computes a scalar shift and scale per coordinate to forcibly map this empirical range onto the canonical ![][image12] interval expected by the static Lloyd-Max codebook. Crucially, these shifts and scales are permanently frozen after the first batch is processed. The engineering analysis concludes that this behavior invalidates the strict "data-oblivious" claim, as the index quality becomes highly dependent on insertion order. If a client inserts a tiny first batch—such as a single user query or a two-sentence chunk—the 5th and 95th percentiles are statistically meaningless. The index will freeze a catastrophic calibration state, permanently crippling the accuracy of all subsequent vectors. Furthermore, later distribution drift cannot be detected or corrected. Bias correction is handled via a per-vector scale. Standard scalar quantization systematically underestimates inner products due to quantization shrinkage. Rather than adopting the QJL residual correction outlined in the academic literature, turbovec computes a static multiplier per vector during ingest: ![][image1], where ![][image13] is the original vector, ![][image14] is the rotated unit vector, and ![][image15] is the centroid reconstruction4. The engineering analysis assesses this as a highly efficient design choice. It successfully turns the downward-biased inner-product estimator into an unbiased estimator at zero search-time computational cost, requiring only 4 bytes of metadata per vector, making it superior to dynamic QJL projections for static text embeddings.

8\. Packing, LUT, and Scoring Specification

The data layouts are strictly optimized for Single Instruction, Multiple Data (SIMD) throughput, explicitly abandoning flat arrays for blocked structures during query execution. During the prepare phase, the raw packed\_codes—which store coordinates densely using either 2 bits or 4 bits—are repacked into a blocked layout. Vectors are grouped into cohesive blocks of 3210. This specific block size is not arbitrary; it directly correlates with the number of 4-bit nibbles that can be mapped inside Advanced Vector Extensions (AVX) or NEON registers for parallel lookups. For every query, the query vector is rotated and then scalar-quantized against the predefined Lloyd-Max centroids. This creates a localized lookup table (LUT) containing 4 elements for 2-bit quantization or 16 elements for 4-bit quantization7. The SIMD kernels execute a byte-shuffle operation, using the packed database codes as indices to gather the precomputed distances from the query LUT in parallel. Accumulator width management is critical. Because dot-product accumulations over thousands of dimensions can easily overflow 8-bit or 16-bit integer bounds, the kernels accumulate intermediate sums into 16-bit registers and periodically flush these into 32-bit accumulators to prevent saturation. Following the accumulation, the raw integer scores are converted to floats, multiplied by the stored bias-correction scale, and pushed into a binary heap to isolate the top-k items. The v0.9.0 release specifically aligned the floating-point reduction order across architectures to guarantee cross-architecture top-K parity, resolving previous issues where identical datasets yielded slightly different tie-breaking outcomes on ARM versus x8610.

9\. Scalar and SIMD Kernel Audit

Directly observed public facts demonstrate distinct, hardware-specific paths located within the search.rs module4. The NEON path for ARM architectures utilizes vqtbl1q\u8 or equivalent byte-shuffle instructions to parallelize the 32-vector block decoding. Additionally, the ingest loop features a fused\quantize\scale\pack routine explicitly vectorized for AArch64 to accelerate the quantization and bit-packing phase11. The AVX-512BW path for modern x86 architectures represents the most heavily optimized kernel. It features an advanced block-level early exit. If a search query provides an ID allowlist mask, the kernel checks the mask at the 32-vector block level. If a block contains zero allowed slots, it branches past the LUT lookup, popcount, and score-decode entirely. The AVX-512BW path goes further, short-circuiting 64-vector pairs where possible. This technique yields observed speedups of up to 12.7x on highly selective queries10. An AVX2 fallback exists for older x86 hardware, alongside a pure scalar fallback for environments lacking target features entirely. The engineering analysis notes that the SIMD implementations heavily rely on unsafe blocks for intrinsic dispatch, unchecked array accesses, and raw pointer arithmetic during the hot loop. The reliance on unsafe to squeeze out nanosecond-level latency requires rigorous bounds proofs. While the public issue tracker does not currently report out-of-bounds reads during search, modifying these kernels without extensive fuzz testing against a scalar oracle is highly discouraged.

10\. WASM/Browser Portability Analysis

A critical assessment for the TinyRustLM context concerns compiling turbovec to the wasm32-unknown-unknown target. Claims made by project authors state the crate is written in Rust, but they do not explicitly claim browser or WebAssembly support. The engineering analysis determines that turbovec is fundamentally incompatible with high-performance WASM execution in its current state. The primary obstacle is SIMD compatibility. The core speed of turbovec relies entirely on std::arch::aarch64 and std::arch::x86\_64 intrinsics, which simply do not compile under the WASM target. While WASM SIMD128 supports byte shuffles (i8x16.swizzle), turbovec does not provide a native core::arch::wasm32 kernel. Executing the fallback scalar path inside a browser JavaScript engine or WASM runtime will result in catastrophic performance degradation, rendering the 12-20% speedup claims void. Furthermore, the crate's dependency graph introduces severe portability issues. The library heavily utilizes rayon to parallelize index builds and multithread the search over discrete chunks of the corpus2. rayon relies on native OS threads, which are incompatible with default wasm32-unknown-unknown execution unless specialized Web Workers and SharedArrayBuffer memory configurations are implemented by the host application. Additionally, the faer and ndarray dependencies required for the dense matrix setup will severely bloat the WASM binary size and induce significant memory fragmentation. The dense rotation matrix setup, requiring large f64 allocations, is highly impractical under strict browser memory limits.

11\. Concurrency and Mutation Invariants

The public API utilizes Rust's ownership model effectively to enforce thread safety. The search function is evaluated via an immutable reference (\&self). It is strictly read-only and thread-safe, allowing concurrent BEAM processes or Rayon threads to query the same index in parallel without locking2. Conversely, mutation operations such as add require a mutable reference (\&mut self). The engineering analysis identifies the OnceLock structures as the crux of the concurrency model. The blocked SIMD layout is initialized lazily. When a mutation occurs, the add function extends the raw packed\_codes array and explicitly invalidates the blocked layout cache by completely replacing its OnceLock2. Because search requires \&self, the Rust compiler guarantees that no thread can execute a search while another thread holds the \&mut self lock to add vectors. This design is fundamentally sound. However, simultaneous searches executed immediately after a mutation will race to initialize the OnceLock cache, potentially causing minor latency spikes for the first query following an ingest.

12\. Persistence Format and Hostile-Input Review

Directly observed public facts detail two distinct binary serialization formats: .tv for the base TurboQuantIndex and .tvim for the IdMapIndex17. The formats underwent a structural revision in version 2 and subsequently version 3\. The current file structure begins with a 4-byte magic string—"TVPI" for .tv and "TVIM" for .tvim—followed immediately by a 1-byte version prefix10. This is followed by a sequence of length prefixes denoting dimensions, bit widths, and vector counts, before proceeding into the raw byte arrays of the packed codes, scales, and ID maps. The engineering analysis uncovers significant security boundaries regarding hostile inputs. During the load sequence, the parser reads the dimension and vector count headers and pre-allocates Vec capacities based entirely on those numbers. While the v0.9.0 MAX\DIM check prevents the rotation matrix from triggering a multi-gigabyte allocation, the packed\codes array is bound only by the product of the dimension and the vector count10. Crucially, the file format lacks cryptographic checksums, CRC32 verification, or Merkle proofs. If a .tv file is truncated during download, or if bits within the packed\_codes array are maliciously flipped, the load function will blindly deserialize the corrupted data. This will not necessarily trigger a parse failure but will result in silent data corruption, returning mathematically arbitrary search scores, or causing a panic if index maps are corrupted. Loading untrusted .tv files across a web boundary is a high-risk operation without implementing strict bounds checking and fail-closed deserialization mechanisms.

13\. Public API and Issue Analysis

The public API provides semantic surfaces for add, search, and block-level allowlist filtering4. The IdMapIndex layer provides an add\with\ids function and an O(1) remove function that executes a swap\_remove on the underlying vectors. An audit of the public issue tracker reveals historical fragility within the mutation semantics. Issue \#90 highlighted a data-loss bug regarding intra-batch duplicate IDs. If a user inserted the same external ID multiple times in a single batch, the index appended a new vector for each instance but only mapped the final instance in the ID hash map. This orphaned the earlier vectors, causing a silent memory leak and leaving unreachable vectors live within the search results10. This was corrected in v0.8.0 to apply a strict deduplication policy. Similarly, Issue \#89 exposed a critical validation-before-mutation flaw. During an upsert operation, the system eagerly deleted the existing vector associated with an ID before fully validating the new incoming vector. If the new vector contained NaN values or mismatched dimensions, the operation threw an error, but the old data had already been irreversibly destroyed10. The engineering analysis concludes that while these specific bugs are fixed, the IdMapIndex layer historically suffered from edge-case state mutations. This reinforces the recommendation that TinyRustLM should bypass the crate entirely and independently verify all mapping logic.

14\. Benchmark Reproducibility and Claim Audit

Claims made by project authors assert that turbovec is up to 16x smaller than float32, searches 12-20% faster than FAISS IndexPQFastScan on ARM, and provides comparable recall4. The methodology comparing TurboVec to FAISS IndexPQFastScan is technically sound, as both systems utilize LUT-based SIMD scoring. However, it is important to note that FAISS utilizes a higher-precision floating-point LUT at scoring time and ![][image16]\-means++ for codebook training20. turbovec achieves its speed by using a heavily constrained u8 LUT. The engineering analysis identifies omissions in the performance claims. The benchmark latency numbers do not account for the setup time of the dense rotation matrix, nor do they account for the cost of the first-query OnceLock layout repacking. While the ingest process is genuinely faster than FAISS because it omits the iterative ![][image16]\-means pass13, the latency to execute the first query includes rearranging the entire multi-megabyte corpus into 32-vector blocks11. This amortized cost is hidden in steady-state benchmarks. Regarding recall, independently reproduced facts confirm that on high dimensions (![][image17]), TurboQuant recall matches or slightly exceeds FAISS. However, on low dimensions like GloVe-200, the mathematical assumption that coordinates converge to a standard Beta distribution weakens significantly. The project authors explicitly acknowledge this limitation, noting that TurboQuant trails FAISS by 3-6 points at Recall@1 on ![][image18], requiring larger ![][image16] values to close the gap20.

15\. Accuracy and Performance Attribution

The following tables isolate the engineering variables responsible for the claimed performance and accuracy metrics, requiring strict ablations to assign credit accurately. Accuracy Attribution

Performance Attribution

16\. License, Dependency, and Supply-Chain Review

Directly observed public facts show the repository is distributed under the MIT License4. This is highly permissive and poses no legal barrier to integration within a commercial or proprietary codebase like TinyRustLM. However, an audit of the Cargo.lock profile reveals a heavy, highly specialized dependency graph. The crate relies on ndarray, faer, statrs, rand, and rayon2. This supply chain introduces significant risk for a browser-bound application. The faer and ndarray crates are designed for high-performance BLAS/LAPACK operations and generate highly specific target code, posing severe cross-compilation risks for WASM. rayon is fundamentally bound to the OS threading model. The unsafe-code policy is equally concerning for a direct dependency. The extensive use of unsafe blocks in search.rs to manipulate raw pointers and SIMD intrinsics concentrates maintenance on hardware-specific knowledge. Relying on an upstream, solo-maintained project to rapidly patch memory-safety vulnerabilities in obscure SIMD paths represents a critical supply-chain liability.

17\. Reusable Design Ideas Ranked by Value

Rather than adopting turbovec as a blanket dependency, TinyRustLM should surgically extract and adapt the architectural insights.

18\. Unknowns Requiring TinyRustLM-Local Verification

Because TinyRustLM's source tree, artifacts, and local benchmarks are strictly private, the following facts require internal verification by the engineering team before implementing the recommended ideas:

1. WASM Matrix Generation Overhead: The internal team must profile the generation and multiplication of a ![][image20] f32 rotation matrix strictly within browser engines (V8/SpiderMonkey) to determine if the mathematical setup breaches acceptable UI-blocking execution thresholds.
2. TQ+ Small-Batch Drift: Engineers must verify how the index performs in real-world chat scenarios if a user ingests 2 chat messages (locking the TQ+ quantiles to an artificially narrow range) and subsequently ingests a massive, diverse document.
3. WASM SIMD Accumulator Saturation: The exact point at which the internal 16-bit WASM accumulators overflow under TinyRustLM's specific embedding distribution requires differential fuzz testing against an exact floating-point oracle to ensure safety.
4. Browser OOM Boundaries: The team must measure exactly how the browser's JavaScript garbage collector responds to the memory fragmentation caused by dynamic Vec allocations during continuous, incremental vector additions.

19\. Annotated Primary-Source Bibliography

The following literature and immutable repository states govern the algorithmic claims and technical implementations evaluated in this report, serving as the foundational reference material for the preceding engineering analysis.

• Zandieh, A., Daliri, M., Hadian, M., & Mirrokni, V. (2025). TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate. arXiv:2504.19874. April 28, 2025\. This primary academic literature establishes the mathematical foundation for PolarQuant and QJL, proving the near-optimal distortion rate of random rotation followed by scalar quantization.4
• Codrai, R. (2026). turbovec Public Repository. GitHub. RyanCodrai/turbovec. Commit 1e7200c. June 10, 2026\. The immutable source tree audited for Rust memory layouts, OnceLock concurrency logic, and SIMD intrinsic dispatch.3
• Crates.io Registry (2026). turbovec v0.9.0 Release. June 10, 2026\. The published metadata establishing the minimum Rust version, feature flags, and dependency graph.2
• PyPI Registry (2026). turbovec v0.8.0 Release. June 10, 2026\. The distributed Python wheel utilized to track the Python boundary integrations and GIL release semantics.1
• Gao, J., & Long, C. (2024). RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search. SIGMOD 2024 / arXiv:2405.12497. May 2024\. The baseline comparison algorithm establishing the lineage of rotation-based vector quantization prior to the TurboQuant publication.23

Works cited

1. turbovec (PyPI) — Safety Package & Vulnerability Database, https://getsafety.com/packages/pypi/turbovec
2. turbovec \- Rust \- Docs.rs, https://docs.rs/turbovec
3. RyanCodrai/turbovec · GitHub \- Workflow runs, https://github.com/RyanCodrai/turbovec/actions
4. turbovec \- crates.io: Rust Package Registry, https://crates.io/crates/turbovec
5. Reproduction of TurboQuant (ICLR 2026, arXiv:2504.19874): Online Vector Quantization with Near-optimal Distortion Rate \- GitHub, https://github.com/dengls24/TurboQuant-Reproduction
6. TurboQuant | LLMS3, https://llms3.com/node/turboquant
7. TurboQuant in Qdrant, https://qdrant.tech/articles/turboquant-quantization/
8. OrdVec — Rust implementation // Lib.rs, https://lib.rs/crates/ordvec
9. GitHub \- RyanCodrai/turbovec \- daily.dev, https://daily.dev/posts/github---ryancodrai-turbovec-vk5u15wft
10. turbovec/CHANGELOG.md at main \- GitHub, https://github.com/RyanCodrai/turbovec/blob/main/CHANGELOG.md
11. 今日开源\[第13期\]turbovec \- zhang-yd \- 博客园, https://www.cnblogs.com/zhang-yd/p/20462536
12. Cost-Governed RAG: Unified Per-Tenant Cost Attribution Across Retrieval and Generation in Multi-Tenant LLM Systems \- arXiv, https://arxiv.org/html/2607.12188v1
13. I Deployed TurboVec Inside Snowflake SPCS: 8x Compression, 63x Faster, 96% Recall | by Navnit Shukla \- Medium, https://medium.com/snowflake/i-deployed-turbovec-inside-snowflake-spcs-8x-compression-63x-faster-96-recall-5a7a6487ee28
14. can not build on mac arm when simple run cargo build · Issue \#92, https://github.com/RyanCodrai/turbovec/issues/92
15. TurboVec: Open-Source Vector Search Library Faster Than FAISS | Dashen Tech, https://dashen-tech.com/en/dev-tools/turbovec-vector-search/
16. README.md \- kvex 0.1.0 \- Hex.pm, https://hex.pm/packages/kvex/0.1.0/files/README.md
17. turbovec::io \- Rust \- Docs.rs, https://docs.rs/turbovec/latest/turbovec/io/index.html
18. turbovec/docs/api.md at main \- GitHub, https://github.com/RyanCodrai/turbovec/blob/main/docs/api.md
19. TurboVec: Fit 10 Million Vectors in 4 GB : The RAG Index That Changes Everything, https://medium.com/aimonks/turbovec-fit-10-million-vectors-in-4-gb-the-rag-index-that-changes-everything-3885a0e3c4ab
20. Meet Turbovec: A Rust Vector Index with Python Bindings, and Built on Google's TurboQuant Algorithm \- MarkTechPost, https://www.marktechpost.com/2026/05/20/meet-turbovec-a-rust-vector-index-with-python-bindings-and-built-on-googles-turboquant-algorithm/
21. Turbovec \- Google's TurboQuant Implementation: An Open-Source Tool Revolutionizing Vector Search with Extreme Compression \- note, https://note.com/humble\_bobcat51/n/ne6f9c0b5f485?hl=en
22. turbovec \- crates.io: Rust Package Registry, https://crates.io/crates/turbovec/0.1.3
23. 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
24. \[2405.12497\] RaBitQ: Quantizing High-Dimensional Vectors with a Theoretical Error Bound for Approximate Nearest Neighbor Search \- arXiv, https://arxiv.org/abs/2405.12497

[image1]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHAAAAAaCAYAAABvj9h3AAAERklEQVR4Xu2ZTahVVRSAl6SSWviXiD1DNBV/EhEJ1By8TAyJfrTyp1QsUQueZAlmGnjBHJigFOHEIEHyZxI4EHSUw0gJHOiooeNmDoXWx17Lu91vn3PPedbzvuv54ONd9zn73n3O2mevtY8iDT3BGHNs1DbKnBC1VaWsL20c6wRjYUw5xpvPpAdGKGXXWonlZn/U9pz5WdRWlbK+tHGsCA/+12pfcgzGqd+aZd/TjUySfKC499vTxjo0ARwenooAEjQkgLmldqX6iTlSWGXeVn+UMAljfFL6fatNNwXwA/PN9IDxuTrHHAksVk+a5P816mF1tOlskzA5sTbdEkAu6Kj5QnIMpqstGXzxvcBsCYHF3MpTStUAzjSPq+9J+KFp5iF1hp2X6+uUBXCh+pWZ4w0z5TX1lDk/al9izorahhOWxo8kLJu4SMJY+cxfdLiXHkAmai2aAP4/dFUAp6rfm6vVWxICtsK8r75t56Z9Y8oCSGFSlAdYMlsy+OIYy4C6z7wsYX84Wf3TXP/w7OGD8VKIMSnnmffUgxKu47oZ75XJ+0gNUIsqAXxd2j/wsfqHOtGOwTfqq/Y57RtTFMBOlRhFCwVMypfqS+pFs2XtS9U75pMoeHjaPrTPBBEZC0XNHnWLGcOkwyNSM8dXCSA8a16VMLvA920E0AuPXF+nKIC+PShirbo5bTQI0F2T6wAm2Q0z93tVYd+We6NUB8bi4ykbixdnxyRfxBVSNYBevv8tYekCljT8QtrVU66vUxRA+r+SNkbwtLckTKCUjepNkxkMP0s79/jEGwosv0zOunAvnre/Pg4Elnh/HRjjTyqpoBZNAIvpqQCSV5CliqQMVFm4zE+SfF8nF0BuOstGp5tcFGSq1l9NbhgF118SAou7JOQkxk6VikxAKlTwNEA71fWL0n57wnd+J2FJi5c1Ksjfzbjydchv/0jYuHsuZiywQULB50Wfw+s09DRQmaoBpNDAcxJm0wH1U9OfPsj1dXIB5CKrVF4Eb3faKCEwBAwH1NMSKrxzJvl6gYTgXDO3quclXA99kDGwJfpF2pP1koRAkwvj95ib1Afm/qjdeUe9ImFr85N5QcK5bBXS72OFYRIjY6pF1QDG8GI2DYRT1jcOoM98Lmj2wzOK4QltSbhYjPEbwlPCEsX3elXHv/kvGybKCZM2zmdS+NPLjWPZ+01dZ56V4pXBg5xWkw7XGff1+5KDFeF9szZDCWAZZX3jAObyZyf8PWnRu9Iy9kq7InRYxo6bQEB5At81yX99Eva8/qLC8fRBn8chnsRVJvIgmgA2AXyEsr5xAKnwsE4wPOB1gg6c+4O0Kz2HV4NnzH4J+ZM232jzinCnDM5Zc9UdZp1x5GCCkKc9pdTmZZP13GHtxreitqqU9aXN8wIbc0zzWRlcIFUlTkmOdaLo7YbfOPJkSlH++y/h4Ymr+IaGhoaGhoaG3uZfd3zM6Y2pdhsAAAAASUVORK5CYII=>

[image2]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAG0AAAAaCAYAAAC939IvAAADyklEQVR4Xu2YWaiNURTHlwyZh0uGKNeUlFCGIsoYypQhMj0oY0I8kKFu5MmDIRlKRMmD6cmQpCuSoeRBSHkgL5KURw/4/9trdffZ9zvn2+fk3ntu7V/9wj6f862z9tp7r+8TSSQSRekM26r/FX5hXzhA/6T+TTqq/Ny0sZaiJ5yutlObCuZikLoQjir8uCid4EHYVf2vpEkrTVVOWg1cAp/BP+o873MGSc/Cz3Ab7KO2FFPgK3gJtlGbCiZ/tfoTLi38uCjj4bpgrD88Dy+q9+AKqTB+TsAZ+Fq9Jo2rdzbcEIy1FKzcerg5GG8qxqofJX6l7YSjvX8znyfhCG+sPTwH53hj0bAqtsDtKivKvyHh57wuhn6wSzio2Mqo1T8rYSh8J/nx5MVRq+bFsUZ9ArsFn2XRA9ZJ4RHCWPj//Ukje6XC4lsPp8Ih6ldxNyV2fh2BvXQsj8HwlLjgqcHk7FJjtxnSXVzlHlW3wreSv0X7cfhYHIwhJo4L6hW4X1wMds5lwV1pZTDGHN6BX+BMtTe8Kq4IyyZNWmmqbtL4A+rgQP07PQ3fi1vSHKe8Jm8b8RkurnmhTFq5iTImwMfivq9W/SQNTUgeFocVkB9HDCxUNj30prjGbQZ8pIZFSTmxLP4QnofM61/1G5xUcEUkDOqAFDYePCt+wVXiqiarcmJgwigP2zqJTxRhFdKX4s5ZYu1zvZR3DlgMlcRhDYjfhDA/XDHUP1dZ5JSTllVQXF3XxRUc5cTxO8b5F8VgTYgPJ5Ad5HNxAdC8Qz8LextwCD6QxttUKRap36UhWdxG6Ac4UcdisBgqicMaEL8J4aT/UP1ucrk61xszuPJuiCtEY4y4lWfdur9wSmLnWQif1X6Lq2oae54ZTNQelT+S54u/TeXBropyW7J7z1d5nrGiYzo5i8O2ZT+OGBiDnWkGz8n7Kp/jCBNepzK2ED6YXw4HxeX+rpT5EJ4mrTRVNWl2aLIrzOqC+KO4PYYBxxAmyrCExSTNno3qxf0YPojaWcCOi29F1trFRfDj8CmngHZLwxFBauEbOE01uG3714VMFrc92iQbbGqOScN8FGWBuHOB8rXVCziy4AoHGwBLXjksg4vDQYUJo/uk9B5uCeUE7YQn4GH1KTwu2cXmkxcHY8iLg9fdVjfBh+JWewgLiBNDs+A9eK9b4ho8ukPcROb9jlYHq69G3Eoz+MK4OV9Y896Uz4VcvSFcPdyxYlYuG5FZ6jDJ/r5EM8BXfqvDwUR1kyatFbJRGr9gT1QxHcQ1aqWamUQikUgkEonWyz8nvcSfY7j7PAAAAABJRU5ErkJggg==>

[image3]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADYAAAAaCAYAAAD8K6+QAAAByUlEQVR4Xu2WzSsFURjGj1BK8pFIlKuUlJ2tpQXlKxYUWVhJFspGpG7ZWEtIJCsL/4EsrMTGlp2UbJWlhTxP53115lzTzFm45XZ+9evezjnNzDNz3nfGmMj/phq2wQ75pRxT6kTOqzpWbnhdtMGf+I2KDdYCp+At/BJHnPl+8RC+wBXYKpabBfHMn0iDF3kAH8QLWJNYYcwwXPLGykkvfBPPvblUBuEyXBXf4UBihZ3nujy0w3p/UKgSC/Kbh1pYhNdi7mCLcAj2iK/GHohoPe3AZhnLohvuwUZRYZA1cdoZz2IWjhsbSM1FRQbjyYqwU/7Tffho7JbiOOUazuWFNcGGQxlOQzFQSCgeZ9vYmg8KxqewZZLNgrX0AeeMbRqUdy0UXhQ9MvbGhARiXdFN2CVjQcG0cbgwJDvjnbEHpnkbh4u+d3jHr0xyW2YxIbIT6/vz0tF/35ag9eXDd9knvBHz1pfCk66LfFKsO92WeQKOiseOz467sOln9S9UXDBtFOx2uoddeHJuxRMxBA3lNwoNpwFDyayxMfgk8hPqHvYlVlj4sp4XQ5iBk/6gwHB0w5R+3aRRMLbmuYPUU5PyxCKRSCQSiUT+nm/DhWKizXqBzQAAAABJRU5ErkJggg==>

[image4]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAC4AAAAbCAYAAAADDr0pAAABoklEQVR4Xu2WTSgFURiGP4WU/5+SUiQWlvKzkIWdlJCyYispRSlWSqSssEI2Vtb2VldZsZVsbJSVtY2FfG/zfubO3Dvnzk1uXc5TTzOdc6b7zpnznXNFPJ4f00THaSUtNbVqVbzRxSi9Vy/UCloqWum1Ohjrc1JHM+pytOvXwQTt0XcpMngPfZTkB+0rdPOaD3xq2B7vcDCmntAXSf79vJRV8AZ1Td1XV+iD2pY9KA+z6qrkhm9UT2lXrC8JrOsDCTcFZ/AheqP2SjCDz9QK0wX659V13kMLjcBpQ+O5DXVAgrAwMTje8I5i1oAVJUxbmBZ+h55J+sDGiLrE+78bfFp9o/1sQ1E+0WG2pQGTkKGbUniJGbb1Hqp9aoc6QV95RX+ELQkOGdjMtkkJihJiN6hnu4sWCWcZzkl0zbuwUxpFeU6v6AevyBRhQcJZwlvheEVBXlKcnoscm0R26GwsvL1AMRRcKqh+C4mt8FjdVW/pkdr5PTpKNd2W3NDGDM2ZMQeoK1uqn7xORUZIGQcHtg7xye2fmK27Ghvk8Xg8Hs+/5wsnEGAY1pQIwgAAAABJRU5ErkJggg==>

[image5]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADYAAAAbCAYAAAA3d3w1AAACKklEQVR4Xu2Wz0sVURTHT1RQlP0Uc2FUZlAIKmli0aIfBLaohRCEtghaRCgaKtSmTeLKRdmm2hQtIqhoVy01clWLNpFu2rSL8G/Q75f7Pb6Z96aZwUiej/nAZ3Pvfe/OuffMOWNWYNvgoJyAXfHp9UvNBLZLnpGj8LjcB2dgq9auK07Jr/A5vAF75Sb4Gl5cWb02NMKn8Bn8KK/ADdFFWWyXs/BmfMpaLPxpQ9n4/4IHSafhEY1tlk/gBY3loln+gJ0a2ymnYJPGstgj09hv4SH/BlOffrZSYM4dqzz4VGoqsB1wBE7CW/I7rLew8XXJBz0K2/mjDHgQj+ABGaVP3rb092SLfA9/wXNwr3xp4QISYemmnyy8PwfhT8nCwU3H4FLERXjM8sGD4LtAPTgPKCuoKNxv3sL+v2V3bEUERv1FDmnMiwbNvOaceEoyuHErBZQ3KMKbemPhsP2AeYMd0UVOzQZ2Gf6RnlrM2QV5QmP/igfRD79ZSPe8HJJvLVwEaZNMzVcW2kEMVhU2YbpbY2y8LBqU1ahO46uFAbGRUt4U93lsyQUliUvyRfkEOA0/WMiyGANWSjtOsvrxqlltKL8+rmntavCgygsFqyWD8wDTOCl5Y1vL5s5aaD8VKc0NPAiW+ofwPpyTDyx/z0qix0LbSHqfvC/es/Ss8C+Pu/AdvAqHJYNNfL6aDYz4pqxa/gXgX/dsjNUEi8d5eFhujE8XFBQUFBQUVC3LoNpy1V0+eGMAAAAASUVORK5CYII=>

[image6]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADUAAAAZCAYAAACRiGY9AAABx0lEQVR4Xu2XTytEURjGX6H8K4nIioXslJKkUJY2CLFVisTC30jJxAdQKFLIh6BYaHYWfAgLOwsrCwvxPp3nmLnXnZlzJ43cub/6NXXuvd37nHPe9zQiRUyZOqNe0Trv5f9JJEOBbnWfRoY5dYMOqpXeywWlnFb7L6TTTq/VZ/VJnaIl9CxtrEfdwYN/AL5lj2KCA2lUz2kDx8bVNzrM8UsxtQT71BPeW2j61XdaXKF6JXXTCsfw4Q8UYTrE2yDWxXTDXDRJ5n1vt3Urf12oF/MdjzRjKLx0maKugD9UjbqrTtItMYWaixb1QK2lFoRYomNp49nAM6vqgJqkGUMFgSV+pdh+oFStomFoU48pgtlACOMaCGDLz4uZ4CR1DoUX34iZFei6NbKBYBB1mJBwYewqJ8QEikMB1MmhOi2pQv4NsHXhtnor3vrKxQIdUpvFTM49xVmF5hH4nTbAojrKMTtDs/amPEEYu+pYITQPW18u4dBl4Sm9UF8oOiA6ccX33QRh0MrhkTpB1yiKOl9sIH9TsMFsuDA4bb8uSR20nwGG2f9+cIiP+AcJgsFNMf8CXOhU79QPiu6Mo+bHSkUyVExMTExMJPgCPeN2PegE9xMAAAAASUVORK5CYII=>

[image7]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIMAAAAaCAYAAACU9O/tAAAEX0lEQVR4Xu2ZXagVVRSAV5RRWZm3NEzBe6UES4moiKLoGoZGWJJBqf29lP3Znw9GaByy3vqjG6UWxQ2iQCSCQKkIox5Egwq0IuglgqCQ3nwIpNbHXuuePduZM3PvPfenzv7g4+jM3Dl79lp7zZo5IplM5n/BGerJ6cbpzDnqvMjTon1cCM5NjuFvpgq+ezDylGjfRMD1L1BXm0uKuys5Xd2qnpnumM7kZOhMzyQDEzmovqz+Y76unmT7+8xH1N/UIXOZ7Z8KrlEPme9Ke6wTBUFdr/5l3lbcXcnl6t3JtsXqBxLG/bF5feGIacAz6ocmQR8o7pbz1BclVI24ckwFrLT95sbCnonjUvVns2lleFxdav+eZb6pnpts261eYttGBRNxvjoj3ZFwqjRfMZzzeQkrDsn+RwtHhCx/MNlWBeObaZbBuPrtcywsUn8wGVcV3RzHBvUr86xkX4oHuSXthUMy4WfSTgbnbXVFsq0SBvukSWkcljAR68y4W+VYJHBVk5BCpj8l4ZaBlLEDEi7IuUe9Nvp/Jxaqr5nxOXxsT0jzUgtnm6y0F9SH1MMmFauKbo6DgL1nUkUZB31EGQQW74i2MU48on6rXqxeZBLPNEEqycmQk2GEAfVek4sAEoCmBj9Vr5Nw8c+am+y4JniX7KxS/7ZPn7iWOj86po4LTe6RBMInfzQBgCvUL03O16/+IqEBa9I8dmMcsyUswj1mn7pc/ULatwSH85MsSNxSblD/lNCof2+WHVcJj3IEoioYZBVf/oZ6szmaFx2PSbgPO96gUSH8UXK7jO0RjkDskJBMTH7TAADXdVBC/+I9jI+NxnE0zeN4xsG93htHbx7pVX61z7hvoU/xZIgT1RcVTxdUF54i/OmNRKuqMqV4mXlJ/UZ9WMIjD5YxKM26fm8e02fhO9VjEkozNm0eU0jKbRKqV7qK6rhFwiqKg0DS/qReaTZlPOPw5pHG0ZtHkumoFMcGt6srzZirzXckNP8kxo0m19gaObIGAsWzP14lYaUymL0mpcezcI5Jf1FXQsH7hRQy/Ef1d7Npv+D4y6rNEsbKLYxS7eW6CVskrBrKNMJNEnoFxod1nX23xkHPEEMfsk+KC5LK2ZL22GI4h5tCsg2nG6vIyZCTYYTLJDQsGONd9qvqdxLupdxCkC61CZTiNelGoyWhWcP04jrhk+8BcAiEB6NJIJik/RIWA1JeaRrfl/Y7kbv84BK6NQ4WCz2A0y9hvmnaY7iFxcfFcNvFITlxkd4nJ77XqYSMc6ugP+D3A18JnehXPzGPq39ImPiUpepOs9N3p6xVbzXLIBBPS/05CRSB976FpH9O/Vp9xezUeHVrHBz3kfqA+bmECpVCYtIXlOEV5C0J80lvsdXcJc2SsudhFfWZ/taVH6om+7U43+1NfNliI9DbpT6oXM8FEhpMPjGtFJn/OFTR9enGTG+SkyEzwv3S/oUy06Pw6zDSgNc1oplMJpPJZDKZzOTyL98+5SMm0207AAAAAElFTkSuQmCC>

[image8]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAAAbCAYAAADMIInqAAACQklEQVR4Xu2Wz4uNURjHH6GIRiTTNGSUklKUhY3lLEwzE6EopVCSZqHkRxhza5Y2kkGZskL+ABsLzWoaKWVFrJRslbJR5PvtfJ/e8773vveed8Fi7vnUp3t7zum+7/m+5z7vMctkMhEr4RY4pE/KmrNGctz12rJgEzwCF+EfeSga3y0fwi/wItws/xeDcAZekp1YC2/Dl/CZPA9XxJPq4GIewHfyOVxVmmE2Cs9Wav8S32VX4B34EV6TMavlI3jVwoJvyc8WwuvJfngBTsnvcE9pRhjnvBR40XXVouAN0hF9prAeLljnALhb6XsrFntAnrEQTk/6PoDT8CDcIb/ClsZ8K87Cjar1Yju8BzdIhwv2//HRqN6LugD4e08k//t8aMfhXpkUMCe14LC+0/vwg4VEWaeck/SDYqeFxkkZgi+eC2+yeFIXgNfpJzgBB+Bj6T2hK3yqN63c9LjVf8CTFpofPRGNp8IQKBtUy5ov3EkJ4K0VO9Tv+ZuFN1hX+j4Ab4AxDIOvwiV4Q6Y2wBgeqOg0fGXlftCElACeWrHdea/0J5xUrRZvgFXYWX9ZcYHUBuhw4Zclnzwbo/eDpkHUBUDmZacAuIvHVGvDGx67+9bKGOFNcgf4BZrgi682PA/Bg0ilWwD+Gly04iH5dXkQ2qZaCXZLnqwoj75v4K7SjMAUPCWbcAwerhYFQ6DXrf202Ylz8DX8beF8Ql/AfRr3k+AcvGvhXhfkuOa00fcBLEf4dx6x0M/88JbJZDKZTCaTifkLPiyJJVb5vpUAAAAASUVORK5CYII=>

[image9]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACkAAAAXCAYAAACWEGYrAAABQUlEQVR4Xu2WvUoDQRSFr6Ai+P8DaQIGSWOtNla2NiqCVeyDIJhKK0EC1tppZ+V7RLDSVsTGJ/AlPMc51yRrEpdNil2YDz5CZqY4uXPvZs0ikR8W5I4cl7liW77CBzgmc8WMbMF691Z+WJPvcCOx53h1K/rsxbQsJTdGQW5DzsEzeA1P5Btc6TzUgwN4an/7dh7eydWO9UxsyidYtVCZT+lDMwjuH8GG5HcPyHBDB1yGL5LVID4wNO3QeFB6Be9tBOGcQoTcg19yXWscmA+5pbU08AfTFjy3/9skNRcWHth0UWu7FgaGcipntT6IJQvV8woeWrs/hw5bs/bV8ponLAzLo+S/zrHO9sMDJofEg3rYzHAKPRAfP7ewCZ/lDSz/nu5mUl5a//7bl7ydzBQiJPG+4bXxuom/BU35oUgkUiC+ASDWPZJieicJAAAAAElFTkSuQmCC>

[image10]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAE8AAAAaCAYAAAD2dwHCAAACu0lEQVR4Xu2YS6hPURTGl1Dk/U6U6zGRAYXSRZRH5JFioDDFlSglxeSmZCAR8hyIEkIyEAPp71FEYYBMDBQjM0UxwPe1v9XZ9zjn3MPt/t3B/uo3WWfv/zn7W2evtc/fLCmpp2moWCj6xBeTqpXM64JaxXNwHvTqeLnb1RfMBTfBWBFrmXgBzop7YlM0boG4BW6Ap1Es1nBx0sK4a5bd4681UDTAlo6XulUzBBdxBnywYvNWiW/gJ3gN1gpP9ETwUixRbAP4LKYpNgTcFpzPXXbRsmQM0LjamiTegpm5a80SzenMPFImmvdRtCvG8TSbLFZsO7gr+kfj1ohau24w2AkOgDbBjI6MBzVRdcxbDUaAMRa2OikTTThhYU1ktGW767iYDtaBKWFKfSXz/sG8WeKBhUkt4L2oahZc0GHhRbszdlj9zl3HvCcWttZK8EhMjca5llpoPtya4wXF3+U9Hoo5FhJxx7IaWipm7Zng3qc8G6SZzSKvKvPGiQlR7JigSf2iuIuF/xy4Itgo3LzrwhPLdb8RpTuPr713H88YG8U7MVux/6Eq8/w0EJu0R/icInE97NCk3TLz9goX7/1VlDZM3oxnOTJMseWW1QW+woMUz4s145DIb88ytoHenFxDZeaxNj8WPF64gXnzVoBXgrWMohFuygULbyOPI0XmfRE+9w8l87pgHg+NDcFtwG7FJnFJtIKNGttslZlHszwZ8xVjU+Nzk8sWatcu8EP4F8U88F1sVYy1Pl/zaGRD0JdCsWi6UTymHAX7LcvsEcs6UzPUIk6DT+CXZTtjt2VvmZ8QaNZ6cBDcF/68o8BVQSM5jms6JfxYQw/YZMg+sNnCycO/dirFrBF+2/kP+h8DRV2rJ4nPx7dpsoVykC8JHuP1RRZOF0XycWyaTErVeTEpKSkpKSkpKSkpqUi/AfOVzyf3J/nrAAAAAElFTkSuQmCC>

[image11]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAE8AAAAaCAYAAAD2dwHCAAAC7UlEQVR4Xu2YS6iNURTHl1Dk/YiUcruhRCGPdDOgFAoplCIDhTyiGCgmN1JKHlEGJqKQEIroUq7HCCmFlAwIE5koE0rWz/6vzneO79wct4472P/6db+zv/19Z+//3mvtda5ZVlZP01AxT/Qp3myyBoi+tTd6qrJ53VCbeOKcdnpV326aRjgdYkahHSNhp3PTueIcEP0L/SaKa85556EzTRQ1XJy09K5LziLRsAaKTmdT9a2miQXb73wTRfNWi4uWTIy+0K4+Y52nYr7apjj3xCi1DbG0ALDCUpSdde4Kdn1DahWvrHrQzdRcSzvhvYhx9LPKZHerDS0VL52Rlhb9g8BINNp5IzAfbXNui9i1vGe5+KuoG+zssLT1N4sXlgbSbBGuBy3l21rzxjjvBJMMYTZ8cqZaMjb68QyKaALmGZ9PCJ5b6Yz/3bsBZfP+wbyZ4r6lh1qct6Krw4IBHRan/pLt1vXJzXfBLme6JcNqzSMEIxyL5nE/+vO3LGyLxp8pfH4g5lgK7VuW8h/UFSv8WBD7qLg6zT4sZosN+lxm3iTni+jKPAx7LuLUXOX8EEXzLotYWOZN7oz8WaplzmfBoFCr81rMUlszxKIdERMsTWyh81FwTZ96YctYgZ0WRrcITuU7ltLSM7HHKu/iGkK8t+yUrxJ5gVoOhqltsaVcB2zhQWqvFUf9IVEbnvXY4vTm4RJRlJPnIPpfdb4Lrhkb46FeA+q8UJy2EaaEf9RvUWDTHilpgaUyhHKkzLyvgjxYqmxeN8xbY5X8RkjwJRwS50Sbs1Z9/4fKch5qF8cLbeRsuGApdzHpMGC9+jCX6yJqOp6pzXkY2SnwpVRU12EU+eCYs895JI5a5aRqtkja5N2fguslukeugg5nnaUD4YYYpz5EBrsKtlo6wblmPsU54QG7GvY6Gy1VHmU/4/5QlAfF7R3/GKCa78livJMtlVpcx/hD0cZ9DsR6KYN2oE+8KysrKysrKysrKyurEf0CbVXsg2DT87YAAAAASUVORK5CYII=>

[image12]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACkAAAAaCAYAAAAqjnX1AAABaElEQVR4Xu2WzysFURiGP0X5VYoFdlZkIUpCLG5RNqSsLOws2CgpkY2VLGyws1AskL0sJCZ/hbLyFyh75f3ynmbOyZy5484szNynns17Zua8986ZmSNSp4Q00W7YBRvs4Vwx8ybOPUr3YAU2WqP50gkX6SFst4dDTMlKJOuhF/AGPtB58fxaD/pP7cNNdyDCuhStpN7ua7rCTNeL+gQnmSXRDLfpEXyFO9YRNqlKDsI3qnmUS3jqZNWgkweSYckF+E57mRkO4CNsc/IkMi+5JPEldZJAPBeLoZwl1+QflPStSX3hB+K5WAyZlxyTsOQwM4M+3VeS/l1ZzpId8IXOMmuh93CZWT99hlPM4si8pDJHAzgOd+mx/OxclAn6Cc+YuaxS/VJ9wQ94S0cixympSxr0pGnYR3+7zfpd3nLDP1DsktUwQ2sll5K6YVU3JFynteAtOUR143ACW+3hXBmAd/Rc0m9c6hSLb8duX8zsJ2MmAAAAAElFTkSuQmCC>

[image13]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAcCAYAAAC3f0UFAAAAj0lEQVR4XmNgGAX0AoxAHADFrUAsAcWsQJwLxHpQDAYOSIqnAXERFAsD8UUgLodi0hUnArEiFB8DYhcoBoEgII6GYjiwgeJTQCwCxSDgB8TGUAwHMKuXMkA8DMMgD/JDMRyQpBjmiSokMU0gDkHiw4EZFJ8E4jQormNAMxEdcDBAggyEQc7AC0hSPAoGAQAAiswYk1zhU/oAAAAASUVORK5CYII=>

[image14]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB8AAAAcCAYAAACZOmSXAAABUUlEQVR4Xu3UvytFYRwG8K/8SH7LXUXCRAYxuFLIIJuSgSwSCcVCJoPF4pZJMliExcxmpmz8PZ6n93nd1+mccO/VGZynPt3u97znfU/vL7MsWbL8l+TlFPojzwahK1KrWMZhS7bhDqqhXZ5h9rN1hZPq4LvQKTdwpPqQvEGPan8Sdk7vMKzakjxBk2qlpl5iMy8v5qaauZQzK76c2ME32TPXf2xSHZwP6RqqoANehS+twoCMmVuiGfHHsBYmhPUWmJYH2IFGtf0Sv7k4GHd9AR7lCvZhVJbhHtaEd0OruRnqlUk4NndH0C10mztFieHX58w14gwQl4H/G2QF1qEm4I+qz4i5kzMlJ8GzxKQ6+E/CjngxhTmP1DZhw4p7ifumD9qCNr9Ks1yYm50wc3AIi3Jgbhb5S/yYBXMzWVY4zXEJl8HHL11dUCsrqQ6eJUvJ+QC9wDjSp2SpdQAAAABJRU5ErkJggg==>

[image15]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAaCAYAAACD+r1hAAAAuklEQVR4Xu3SsQpBURzH8SsZkJRFisFo5RWUrMJiVEZlpDAZjLyBd2A1G208g6fw/Z9+p266bq5RvvWp49zz173cIPjNUiiLrWOzAwNcxNaxQx3MkBFb297bEg98XF6mWKImE8xD111ZbKSKHh7SxxVd+W6g9bIxwknqWKMike2xkMjsj/EPVcAZbbFySIsr8cAYd7FDNzTEfpAViuIa4iA7HHXIbNH0B8P5b7DXwW6xJPY5ssQD/+J6ArD8ItDGyfNZAAAAAElFTkSuQmCC>

[image16]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAeCAYAAAD6t+QOAAAAyElEQVR4Xu3SPa4BURjG8REUcomCguiEQkgUepVCwwY0mkstCnYgWhuwASsQjUqh8JHYitrzTv5k5sYUp3MTT/Ir5pwnk3PeHM/7qCRRlx6yoUYgJSzlhnyoEYhT+ZmxbJD4s/dKDGuZITJOZTufOUkHKRnJBDYtPy1cpYpfGcoFxWd5gKPMUZC29+bPTuUV7nKAFe3SoWRkj740YOcvs2/izmVbOKMmTdh3RaawUfoz3SItOexkIV34cSrbSH4QjK1Hvulv/mMeUnEvNVRjYSEAAAAASUVORK5CYII=>

[image17]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIIAAAAaCAYAAAB7NoTTAAAEnklEQVR4Xu2Ya6imUxTHl1CmMa7jFnJcvmhM88GtZkyU22iQmA8KEx+YIRkpfCC9mURJLrmFcim3qUnKlCZpJnKbwhSTaD4QvgilKD5g/Wb/V8/yzPs8532dmXNOzf7Xr9PZz36f9ey91l577W1WVVVVNYoOEueIffLDqt2qvcQ8/Z1R1UCYOc2qQFgstjjP2/R/EPYmnGec5SJrmfjUSh94R1yT+p0t3nTWOx+ltqw54h5ng/OKc4MYZ+zZVraXta9zmxU70e8+K/bRfMHYPrZmfMGjVuaG98CtzjbnJ+d1caTtIu0vNjmr/vtotyoy0QPiV+cSkRVtfzh/O184V4hw3PHOZ+J8tV1lZcJggdqYzKfFHVZ+f7fzjThC/SZT2AtbKOyFLXSlFWdhN1b/Wmeg5ycLbH/X4hcrwcBvrxfXlZ/ZgdYsho1W/DdlnSCItFNbz6ZLRznfWn8gtNuzcMz3YqA2+hM4cJ7ayCxbRTj9TCsTDEz6KAp7g9QW9rC1nyAT3Jn6IPp9aSUTnCUuSs9xMjzpHOPsbc3q327NdxN48LtNwW8HOGuspKkbBSuNj5sJjRIIlzqHWpmISJVdYuU9bmVMcLja2PpwDpzirHAW6Vlkl3EVvw172GI8eUxZOP5HK3YjYADxntXiDLWhJSIHaw0Eq4GAphQIp4nNzknOhJV0A32FIieJW0S7oOniISuTMYpGCYQPncuci533BPtrWxc4bzhvW0mtgKIO+lrwHhbEs1bqhagZxlHYyvZQ2GX7aI8Hp1EDDHMe2xSLE/q+hWBYJ8auEVhNn4ib1RaTA9NZKLbVFwhHi+NS22MCB8RqypprxcGvCfbcGCunIzhYfdnTWaEwLLAmE7ayPWxFEfiz7TyerkBgsb1o5XuipukShXKMI8/LSCK1RhUdA6ZI/EqcrraZUF8gxKkmO5wCDPhNV9ZhPJw0YGBNILwsYsXhENIrtG2Po7A3sP6tgX5kinYg4BOKyAiiLrFlsAA4Nv6voyMT114NVKuxj7L3zlN7W1SuN4n2FtDFg1b2y1HUFQik7vcF+3oEQzsQljufC/ZelB3MSkPP2fBA+E3k6r1PYS9sobCHLeYR2L64R8hifARCbCMh9vsYT1dws/rJhGSd0IXOwvT/pKqBUANhhzC0SZAmKTgoEGNiFjtXq+90qysQcHwE1lK14UC+G161srcy2X+JuN2jOv9TUIWjZc4HIhbD5dZcKB1r5f13WXPxNEf9ssJevkkMe2ELDaw4Lov6LL47iwKxKxAIAHjLudbKaSd4wXYOql4RReH0Nc4jzr3WrLiHbcwXTlFxbLrdSpb6x/lB4IAJ9YuTDo7npu5+510R33uYNZcuOIl+jOkpQdAj/j4hGH8sDlY4IBz0kjX1VF71obAXtrK9sIVw6EZnpTVX5ThzWIFHtooLIwjlwGeO2pB1ujJ5p3gpHGLNB8dV77DqezaJ72PVnWhlq4KsaOP5uVZOScMUczBh5X1d48Z50FW4ZVt99pjnBdYEdA6ULLZBMlLVLBLbQdwtDNsaqvYQ1UCo2iHuXCKVV1VVVVVVVVVVVVVV7UH6FwQBVMsapJIKAAAAAElFTkSuQmCC>

[image18]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEUAAAAaCAYAAADhVZELAAACb0lEQVR4Xu2XT4hPURTHj1CU/4QpxUhKksWgDDILhQULLBSJhUTC2CiriawkYjdNMU0S0WyGxbD4iVJYIiULko0srfl+ne/pvXnzfj+/3/AmcT/1aWbuu6/f/Z177jl3zBKJ32WW7JKT8g//V1JQSuiUL+B1OGHk48qYLE/BN/ALvC0Xlsw7De/De/CCnJqbt1wOwQH4AK6VLTNN1uCRkY8q5bA8pL9nwkdy2HxNZK9ksBgcbtp52aM5fPeh3KSxZfCZbNdY0yyV3K2OwrOqmGhZVryHCzS+T34zX8sU8+ygZzSH7JCv4Ty4Bb6TbZoTG02b2uwZ8KR5Ch6Vr8w/YLzYIJkpzABSDAq/4AfJIAQb5We42jxgNRkZxtp4V/ZprCEpKDnWyMfmZ26JefrSRkWWi7ske5v0hLXWyRiYOzJqyiL4SeaDwoDRj/p51kYHhfTnLGUufC6Pa6zlc1chu807IF2ssRXwq2wUlKs2xqDsNG97lB9GWGDfyjG1rj/EOjho3orz7bje8YlWywxiUMqOD7P+pqwbFL4YOzFbY9vNawllB5iu8SLz4UVZPCb1PGbeZX4Fs4I7zbYabIWrzNfzRPKeEkT3YVB4xHZZVgaik+VPAY9XKSkoJbCq1yRfYGFjcY0U64T7NXc8YDAob6AH4Z6cN8y/LOmRDFzAmkhvmRfzdvhSRmlgcKKGrtfYKLgTEQC24yvwHHwqL1u2kKrheeeG0O8lMjMia1lX6DA8ALeZB5JGQSZxtWD3Ypu+Brtlva76Ez6kcyy7G8Q/hLw9/s1wvSvNrxT8PdZfhF12s2XHKJFIJBKJRCLxL/ADMzq6NBTaXK0AAAAASUVORK5CYII=>

[image19]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAXCAYAAABNq8wJAAABbklEQVR4Xu2WPUsDQRCGRxQRLIIfKGJArUSws7W0UBCUgCQQSGElYmFloQgH/gVRC3v/hpVoY6utYC9YWojvy87A3hKTi3fgHewDD5fMLtzM5GYvIpFIoQzDGTinV8qYMaZy3bRYKZiEu/ABfqub3vqKeg3f4CGcVksDk7mCz+odHEntENmA+0GsNKzBA3ikfsDV1A63zn39GIKLeqXdGIezYTAPlS+gA9fhkvoOE12zgb2AExrrB2fKmuEXUVM5TwtePBe8QQLn9TO9hC/iusQ45Z7fOhrCfXvqsX63xAtNnrCrZ5IeWj4qn7Albnhp01vPgjWDRSTwRlzihSZPKl+ADbAPi+FR+ghP1SwD3I0peA9PpPdg/xkb4BC+zL7E3ZxmHWCDL0hqnW+ImwebidxYN3i61IM1wqHjL3CrDoIlbskbLMIKyVXENnxV+dfhCS6ndjh4DLbVrIzCc+n9vO/ArTA4CJUvIBKJRP6PH4/2QFX3xvaDAAAAAElFTkSuQmCC>

[image20]: <data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGsAAAAZCAYAAAA2VdDGAAAENElEQVR4Xu2Ye8ifYxjHL9mKMMeY85s/jCjEnKU0Ifwj2qLUyHl/LLMpOYQkSUlzmPPIliyHkP2h9dO0iByKiNSU8ceKWlkhh+/HdV09z+/xHN73rcl0f+vTW89z/+7D9b3v676e16yoqKioqKioaBtrP3GHWNx8IR0j3g+eEo+LV8VdQepw8XKwWnwi5osdgtTO4vbgTbFKXB3U221rzRSnBa+I/cdf/61HxGsB62b968zXCoh+iFu2e9t8/bPjfV3HibXBSvGcOGisRYd2EkuD+8WX4uaxFq7jxffBH2KjWGQ+SUC7my/iqgCdLraIswNE+8fEsgBzbhVfB2yaf0PHmhuxIvjW2s16WvwS/CresMqk1ALxjvnvYYZYI14335iAThTvikNrbBQ3xvteFbO2I7Pq2lWMrNusa4MuYdZ75scfmDC/+1lcE6BzxafmpqQxJ4mFQZrfpr1qdOlg6++jqQuDLrPutsqELmHWVnFKgEhxn4t9Agwj9bHJUzwjfTbNH9RkzdrDfOKcyiExsc3iqIBT9Iz5PXV0cLH5ndi819rEhngoYFc2dZH54of6qWsyZh0SsLn2tuH+afeFeNCqdRHDH8UFVmUaxp0Vv5mShszi1MAV4lSxQZwV1EXggYvzQ3NDUjnGV+aTBib7hI2nxT7lySKVpmGYNB2j0JBZFBWcEiAOd5qnxl2CFKeEzQkfi9viWYoxfjPvL7MK10SmxSmpzyyCc0SQIq2RzoDd1hSp6BbzyVDtQI7xgdgzQPOsuhOPjGdDSsNuMjdpOkahIbPYeHVjSGmfiSuDNs0RH4nrrTpZjPGnuKzWjuxEliFTTEnFrP+JWXTKe0gxOMUDkB7ahEHfWVV0cN+NxAs2fkdlIQL0Oxnx20vNU85EMB31mcUYbKgdA5RxWhl0iY1KBZlFB2NQhMytNzLvY2T/jG+vusxiks+bVzZZ3aCmWexAPoLPDxCLJwijgDGetHaztgTnxbMu5e8uMT9NBPPRYMq53/rNotQmwPVqtmkWVe8D4qV4lwEnjpyk7J/4MEabWXxEN+/AXnWZhe4x/08EZIBpl0UHVRpB5htsYYAOEz+YV0VZGVG6b7DxNEhxkN9ZlN5dSpPSqJwL48N0DOszi5T8rNg3QAeKb8zLdSDABJvUznWQVwIx22xVJZylez0N7ibWW3vMW5W5lw/a38VP4sWAD0dEADhdwGBLzCs93mcbJrPcvNQFSvI14i2rgom4yx62ykD6G9n4iezSyeK6II2qizGowgjCkCbM77xNAaeAgC81T/vAGIusWhPm8O+k+2z8HwJnmH8Asxa4wTz9swnrOsF8o14e3GueZTI2gypmbUdmTVY5OQbkWOdE62JxBwTnxN+2oPJsIuBbg8D8l8U3EZxp7ZUvYg3ccUnXmnjOmmHC2uNTVFRUVFRUVFRUVNNfcZ8zMLooXXAAAAAASUVORK5CYII=>