From 94345325bf990b689cfa99a961c591b8b0afc663 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 13:36:30 -0800 Subject: [PATCH 1/6] Benchmarking guide --- notebooks/benchmarking.ipynb | 1708 ++++++++++++++++++++++++++++++++++ 1 file changed, 1708 insertions(+) create mode 100644 notebooks/benchmarking.ipynb diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb new file mode 100644 index 00000000..5bb7470d --- /dev/null +++ b/notebooks/benchmarking.ipynb @@ -0,0 +1,1708 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_PCU0gUyzX2c" + }, + "source": [ + "# A Practical Guide to GPU Benchmarking\n", + "\n", + "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", + "\n", + "## TL;DR — How to Benchmark Correctly\n", + "\n", + "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", + "\n", + "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", + "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", + "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", + "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", + "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", + "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", + "\n", + "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", + "\n", + "-----\n", + "\n", + "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", + "\n", + "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", + "\n", + "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:36.427802Z", + "iopub.status.busy": "2025-12-17T21:24:36.427684Z", + "iopub.status.idle": "2025-12-17T21:24:40.995279Z", + "shell.execute_reply": "2025-12-17T21:24:40.994328Z" + }, + "id": "PKWz_W7uzX2f", + "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/simon/miniconda3/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using GPU: NVIDIA H200\n" + ] + } + ], + "source": [ + "# @title Environment Setup\n", + "# Ensure we have the necessary libraries and a GPU available\n", + "# !pip install -q triton matplotlib numpy torch\n", + "# !pip install -e .. # Install KernelBench locally for timing utilities\n", + "\n", + "import sys\n", + "sys.path.insert(0, '..') # Add parent directory to path for imports\n", + "\n", + "import torch\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import triton\n", + "\n", + "# Import KernelBench's timing module\n", + "from src import timing\n", + "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", + "\n", + "if not torch.cuda.is_available():\n", + " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", + "\n", + "# Device configuration\n", + "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", + "# The selected GPU will appear as cuda:0\n", + "DEVICE = \"cuda:0\"\n", + "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kjWByrwvzX2f" + }, + "source": [ + "## The Journey: Benchmarking a Matrix Multiplication\n", + "\n", + "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:40.997969Z", + "iopub.status.busy": "2025-12-17T21:24:40.997722Z", + "iopub.status.idle": "2025-12-17T21:24:41.252072Z", + "shell.execute_reply": "2025-12-17T21:24:41.250967Z" + }, + "id": "gxtKes5lzX2g", + "outputId": "5890bae4-5b9a-4366-8947-367146593158" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output shape: torch.Size([8192, 8192])\n", + "Op ran successfully\n" + ] + } + ], + "source": [ + "# A standard size for testing\n", + "N = 8192\n", + "\n", + "def get_data(n=N, device=DEVICE):\n", + " \"\"\"Generate random float32 matrices for benchmarking.\"\"\"\n", + " return torch.randn(n, n, device=device), torch.randn(n, n, device=device)\n", + "\n", + "def simple_mm(a, b):\n", + " \"\"\"Our kernel under test: standard matrix multiplication.\"\"\"\n", + " return torch.matmul(a, b)\n", + "\n", + "# Let's verify it runs\n", + "a, b = get_data()\n", + "res = simple_mm(a, b)\n", + "print(f\"Output shape: {res.shape}\")\n", + "print(\"Op ran successfully\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GWlsBEVyzX2g" + }, + "source": [ + "### Attempt 1: The Naive Timer (The Asynchronous Illusion)\n", + "\n", + "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.254622Z", + "iopub.status.busy": "2025-12-17T21:24:41.254499Z", + "iopub.status.idle": "2025-12-17T21:24:41.258106Z", + "shell.execute_reply": "2025-12-17T21:24:41.257414Z" + }, + "id": "LynIxLaRzX2g", + "outputId": "72548dad-6570-4eaa-ce07-923556fe70b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive time: 0.5236 ms\n" + ] + } + ], + "source": [ + "def benchmark_naive(func, *args):\n", + " \"\"\"WRONG: Measures kernel launch time, not execution time.\"\"\"\n", + " start = time.time()\n", + " func(*args)\n", + " end = time.time()\n", + " return (end - start) * 1000 # to ms\n", + "\n", + "t = benchmark_naive(simple_mm, a, b)\n", + "print(f\"Naive time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gw4NGYRmzX2h" + }, + "source": [ + "**The Problem:**\n", + "Wait, ~0.5ms? That seems impossibly fast for a 4096² matrix multiplication involving 137 billion floating-point operations.\n", + "\n", + "**What happened?**\n", + "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", + "\n", + "To fix this, we need to:\n", + "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", + "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", + "\n", + "Let's compare these approaches to see the difference." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.260592Z", + "iopub.status.busy": "2025-12-17T21:24:41.260479Z", + "iopub.status.idle": "2025-12-17T21:24:41.460207Z", + "shell.execute_reply": "2025-12-17T21:24:41.459267Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparing Synchronized time.time() vs CUDA Events:\n", + "------------------------------------------------------------\n", + "N= 512: sync= 0.0699ms, events= 0.0374ms, overhead=+0.0325ms\n", + "N=1024: sync= 0.0725ms, events= 0.0718ms, overhead=+0.0007ms\n", + "N=2048: sync= 0.3567ms, events= 0.3543ms, overhead=+0.0024ms\n", + "N=4096: sync= 2.7008ms, events= 2.6914ms, overhead=+0.0094ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: Synchronized timing includes 0.009ms of CPU overhead.\n", + "CUDA Events (2.6914ms) measure pure GPU execution time.\n" + ] + } + ], + "source": [ + "# Compare: Synchronized time.time() vs CUDA Events\n", + "# This shows why GPU-side timestamps are more accurate\n", + "\n", + "def benchmark_sync(func, *args):\n", + " \"\"\"Attempt 2: Synchronized - waits for GPU but uses CPU clock.\"\"\"\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start = time.time()\n", + " func(*args)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " end = time.time()\n", + " return (end - start) * 1000\n", + "\n", + "def benchmark_events(func, *args):\n", + " \"\"\"Attempt 3: CUDA Events - GPU-side timestamps, most accurate.\"\"\"\n", + " start_event = torch.cuda.Event(enable_timing=True)\n", + " end_event = torch.cuda.Event(enable_timing=True)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start_event.record()\n", + " func(*args)\n", + " end_event.record()\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " return start_event.elapsed_time(end_event)\n", + "\n", + "# Test across different matrix sizes\n", + "sizes = [512, 1024, 2048, 4096]\n", + "sync_times = []\n", + "event_times = []\n", + "\n", + "print(\"Comparing Synchronized time.time() vs CUDA Events:\")\n", + "print(\"-\" * 60)\n", + "for s in sizes:\n", + " a_test, b_test = get_data(s)\n", + " # Warmup\n", + " for _ in range(3):\n", + " simple_mm(a_test, b_test)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " \n", + " sync_t = benchmark_sync(simple_mm, a_test, b_test)\n", + " event_t = benchmark_events(simple_mm, a_test, b_test)\n", + " \n", + " sync_times.append(sync_t)\n", + " event_times.append(event_t)\n", + " overhead = sync_t - event_t\n", + " print(f\"N={s:4d}: sync={sync_t:7.4f}ms, events={event_t:7.4f}ms, overhead={overhead:+.4f}ms\")\n", + "\n", + "# Create visualization\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + "# Left plot: Both methods across sizes\n", + "axes[0].plot(sizes, sync_times, 's-', label='Synchronized (CPU clock)', linewidth=2, markersize=8, color='orange')\n", + "axes[0].plot(sizes, event_times, '^-', label='CUDA Events (GPU clock)', linewidth=2, markersize=8, color='green')\n", + "axes[0].set_xlabel('Matrix Size (N)')\n", + "axes[0].set_ylabel('Time (ms)')\n", + "axes[0].set_title('CPU Clock vs GPU Clock Timing')\n", + "axes[0].legend()\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "# Right plot: Bar chart showing overhead at largest size\n", + "overhead_ms = sync_times[-1] - event_times[-1]\n", + "axes[1].bar(['Synchronized\\n(time.time + sync)', 'CUDA Events\\n(GPU timestamps)'], \n", + " [sync_times[-1], event_times[-1]], \n", + " color=['orange', 'green'], alpha=0.8)\n", + "axes[1].set_ylabel('Time (ms)')\n", + "axes[1].set_title(f'CPU Overhead at N={sizes[-1]}\\n(Sync includes ~{overhead_ms:.3f}ms CPU overhead)')\n", + "axes[1].axhline(y=event_times[-1], color='green', linestyle='--', alpha=0.5, label='True GPU time')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\nKey insight: Synchronized timing includes {overhead_ms:.3f}ms of CPU overhead.\")\n", + "print(f\"CUDA Events ({event_times[-1]:.4f}ms) measure pure GPU execution time.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dV8AmQi-zX2i" + }, + "source": [ + "### Attempt 3: Removing CPU Overhead (CUDA Events)\n", + "\n", + "To get a precise measurement, we need to bypass the CPU clock entirely. We can ask the GPU driver to record timestamps directly on the device using `torch.cuda.Event`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.463315Z", + "iopub.status.busy": "2025-12-17T21:24:41.463177Z", + "iopub.status.idle": "2025-12-17T21:24:41.532922Z", + "shell.execute_reply": "2025-12-17T21:24:41.531966Z" + }, + "id": "i6PfSdkTzX2i", + "outputId": "8b3e29d1-1789-4bfb-9a44-599016516dd7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.9622 ms\n", + "Run 1: 21.6770 ms\n", + "Run 2: 21.4259 ms\n" + ] + } + ], + "source": [ + "def benchmark_events(func, *args):\n", + " \"\"\"Better: Uses GPU timestamps, avoiding CPU overhead.\"\"\"\n", + " start_event = torch.cuda.Event(enable_timing=True)\n", + " end_event = torch.cuda.Event(enable_timing=True)\n", + "\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start_event.record()\n", + " func(*args)\n", + " end_event.record()\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " return start_event.elapsed_time(end_event) # Returns ms directly\n", + "\n", + "# Run it a few times\n", + "for i in range(3):\n", + " print(f\"Run {i}: {benchmark_events(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BkfaaDawzX2i" + }, + "source": [ + "### Attempt 4: Handling the \"Cold Start\"\n", + "\n", + "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", + "\n", + "**The Fix:**\n", + "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.535509Z", + "iopub.status.busy": "2025-12-17T21:24:41.535387Z", + "iopub.status.idle": "2025-12-17T21:24:42.246476Z", + "shell.execute_reply": "2025-12-17T21:24:42.245382Z" + }, + "id": "j_PsAuJkzX2i", + "outputId": "d6983401-72d3-468c-ffd8-c0833e8d5556" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.4824 ms\n", + "Run 1: 21.4355 ms\n", + "Run 2: 21.4300 ms\n" + ] + } + ], + "source": [ + "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", + " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", + " # Warmup phase\n", + " for _ in range(warmup_iters):\n", + " func(*args)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " # Measurement phase\n", + " measurements = []\n", + " for _ in range(benchmark_iters):\n", + " measurements.append(benchmark_events(func, *args))\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " return measurements\n", + "\n", + "# print(f\"Warmed up time: {benchmark_warmup(simple_mm, a, b):.4f} ms\")\n", + "\n", + "for i, measurement in enumerate(benchmark_warmup(simple_mm, a, b)):\n", + " print(f\"Run {i}: {measurement:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OR3uOh7kzX2i" + }, + "source": [ + "### Attempt 5: The Single Sample Fallacy (Variance)\n", + "\n", + "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", + "\n", + "#### Visualizing the Jitter\n", + "\n", + "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:42.248937Z", + "iopub.status.busy": "2025-12-17T21:24:42.248818Z", + "iopub.status.idle": "2025-12-17T21:24:44.484746Z", + "shell.execute_reply": "2025-12-17T21:24:44.483759Z" + }, + "id": "T-7QH4cHzX2i", + "outputId": "c758effd-a810-422d-d3ca-66c128cdb716" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 21.4449 ms\n", + "Median: 21.4454 ms\n", + "Std: 0.0213 ms\n", + "Min: 21.4074 ms\n", + "Max: 21.5199 ms\n" + ] + } + ], + "source": [ + "# Collect 100 samples\n", + "timings = []\n", + "for i in range(100):\n", + " timings.append(benchmark_events(simple_mm, a, b))\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(range(100), timings, alpha=0.6)\n", + "plt.axhline(y=np.median(timings), color='r', linestyle='--', label=f'Median: {np.median(timings):.4f} ms')\n", + "plt.axhline(y=np.mean(timings), color='g', linestyle=':', label=f'Mean: {np.mean(timings):.4f} ms')\n", + "plt.title(\"Benchmarking Jitter & Cold Start\")\n", + "plt.ylabel(\"Time (ms)\")\n", + "plt.xlabel(\"Run Index\")\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(f\"Mean: {np.mean(timings):.4f} ms\")\n", + "print(f\"Median: {np.median(timings):.4f} ms\")\n", + "print(f\"Std: {np.std(timings):.4f} ms\")\n", + "print(f\"Min: {np.min(timings):.4f} ms\")\n", + "print(f\"Max: {np.max(timings):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hX_-OpftzX2i" + }, + "source": [ + "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", + "\n", + "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", + "\n", + "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", + "\n", + "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", + "\n", + "**The Fix:**\n", + "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.487140Z", + "iopub.status.busy": "2025-12-17T21:24:44.487016Z", + "iopub.status.idle": "2025-12-17T21:24:44.489937Z", + "shell.execute_reply": "2025-12-17T21:24:44.489208Z" + }, + "id": "Kj5azcpxzX2j" + }, + "outputs": [], + "source": [ + "# KernelBench provides utilities to flush the L2 cache\n", + "# This is important for cold cache measurements that simulate real-world inference\n", + "\n", + "def clear_l2_cache(device=DEVICE):\n", + " \"\"\"Flush L2 cache by writing to a large tensor.\n", + " \n", + " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", + " \"\"\"\n", + " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", + " dummy.fill_(1901) # Force write to thrash cache\n", + " del dummy\n", + "\n", + "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", + "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", + "from src.timing import clear_l2_cache_triton" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Why does flushing the cache matter?\n", + "\n", + "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", + "1. **Without** cache flushing between runs (data stays in L2 cache)\n", + "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.492322Z", + "iopub.status.busy": "2025-12-17T21:24:44.492090Z", + "iopub.status.idle": "2025-12-17T21:24:44.507209Z", + "shell.execute_reply": "2025-12-17T21:24:44.506066Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without cache flushing (warm cache):\n", + "\n", + "With cache flushing (cold cache):\n", + "\n", + "Warm cache median: 0.0283 ms\n", + "Cold cache median: 0.0323 ms\n", + "Difference: 0.0040 ms (14.3% slower with cold cache)\n", + "\n", + "Without cache flushing, you measure artificially fast times!\n" + ] + } + ], + "source": [ + "# Demonstrate why L2 cache flushing matters\n", + "# Use a smaller matrix so the effect is visible (data fits in cache)\n", + "N_SMALL = 512\n", + "a_small, b_small = get_data(N_SMALL)\n", + "\n", + "# do warmup runs\n", + "for _ in range(10):\n", + " clear_l2_cache(device=DEVICE)\n", + " benchmark_events(simple_mm, a_small, b_small)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", + "print(\"Without cache flushing (warm cache):\")\n", + "times_warm = []\n", + "for i in range(10):\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_warm.append(t)\n", + "\n", + "# Benchmark WITH cache flushing (cold cache - realistic)\n", + "print(\"\\nWith cache flushing (cold cache):\")\n", + "times_cold = []\n", + "for i in range(10):\n", + " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_cold.append(t)\n", + "\n", + "print(f\"\\nWarm cache median: {np.median(times_warm):.4f} ms\")\n", + "print(f\"Cold cache median: {np.median(times_cold):.4f} ms\")\n", + "print(f\"Difference: {np.median(times_cold) - np.median(times_warm):.4f} ms ({(np.median(times_cold)/np.median(times_warm) - 1)*100:.1f}% slower with cold cache)\")\n", + "print(\"\\nWithout cache flushing, you measure artificially fast times!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.509465Z", + "iopub.status.busy": "2025-12-17T21:24:44.509344Z", + "iopub.status.idle": "2025-12-17T21:24:44.597419Z", + "shell.execute_reply": "2025-12-17T21:24:44.596500Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the cache effect\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_warm)), times_warm, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm):.4f}ms)', color='orange', s=60)\n", + "plt.scatter(range(len(times_cold)), times_cold, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold):.4f}ms)', color='blue', s=60)\n", + "plt.axhline(y=np.mean(times_warm), color='orange', linestyle='--', alpha=0.5)\n", + "plt.axhline(y=np.mean(times_cold), color='blue', linestyle='--', alpha=0.5)\n", + "plt.xlabel('Run Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FAaH1cdBzX2j" + }, + "source": [ + "### Putting it all together\n", + "\n", + "We have now discovered that a robust benchmark requires:\n", + "\n", + "1. Device Synchronization\n", + "2. CUDA Events (to avoid CPU overhead)\n", + "3. Warmup Runs (to avoid initialization costs)\n", + "4. Multiple Samples (to handle variance)\n", + "5. Cache Flushing (to simulate VRAM access)\n", + "6. Median/Mean Aggregation (to ignore jitter)\n", + "\n", + "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", + "\n", + "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.600123Z", + "iopub.status.busy": "2025-12-17T21:24:44.600004Z", + "iopub.status.idle": "2025-12-17T21:24:47.005899Z", + "shell.execute_reply": "2025-12-17T21:24:47.004654Z" + }, + "id": "3aVFtWt_zX2j", + "outputId": "6cf1e493-86ca-419e-a8e1-e19486814e09" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using timing method: cuda_event\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KernelBench cuda_event time: 21.4000 ms\n" + ] + } + ], + "source": [ + "# Get the timing function - cuda_event is the default for trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "def final_benchmark(func, *args, num_trials=100):\n", + " \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n", + " elapsed_times = timing_fn(\n", + " kernel_fn=func,\n", + " args=list(args),\n", + " num_warmup=10,\n", + " num_trials=num_trials,\n", + " discard_first=1, # Discard first trial for consistency\n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " stats = get_timing_stats(elapsed_times, device=DEVICE)\n", + " return stats[\"mean\"]\n", + "\n", + "t = final_benchmark(simple_mm, a, b)\n", + "print(f\"KernelBench cuda_event time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MsZrCYQRzX2j" + }, + "source": [ + "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", + "\n", + "---\n", + "\n", + "## KernelBench's Timing Methods Explained\n", + "\n", + "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", + "- **All 4 timing methods** and when to use each\n", + "- **The `discard_first` parameter** and why it improves measurement consistency\n", + "- **How `host_time` detects side-stream exploits** in untrusted code\n", + "\n", + "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", + "\n", + "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", + "|--------|----------|---------------------|------------|---------------|\n", + "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", + "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", + "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", + "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", + "\n", + "### Method Details\n", + "\n", + "**`cuda_event`** (Default)\n", + "- Uses `torch.cuda.Event` for GPU-side timing\n", + "- Most accurate for pure kernel time measurement\n", + "- Clears L2 cache before each trial for cold-cache performance\n", + "- Use for trusted code where you control the kernel implementation\n", + "\n", + "**`host_time`** (For Untrusted Code)\n", + "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", + "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", + "- Falls back to host time when discrepancy detected, ensuring correctness\n", + "- Waits for ALL streams via `torch.cuda.synchronize()`\n", + "- **Essential for evaluating untrusted/agent-generated code**\n", + "\n", + "**`do_bench`** (Triton's Adaptive Benchmarking)\n", + "- Wraps Triton's `triton.testing.do_bench`\n", + "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", + "- Trial count is automatic based on kernel runtime\n", + "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", + "\n", + "**`do_bench_impl`** (Transparent Implementation)\n", + "- Custom implementation mirroring Triton's do_bench\n", + "- Gives you explicit control over `num_warmup` and `num_trials`\n", + "- Useful when you need do_bench's approach but with specific trial counts\n", + "\n", + "### Key Parameters\n", + "\n", + "All timing functions share a common interface:\n", + "\n", + "```python\n", + "timing_fn(\n", + " kernel_fn, # Function to time\n", + " args, # List of arguments to pass\n", + " num_warmup=3, # Warmup iterations before timing\n", + " num_trials=10, # Number of timing samples to collect\n", + " discard_first=1, # Drop first N trials after warmup\n", + " device=\"cuda:0\", # Explicit GPU device selection\n", + " verbose=True # Print per-trial timing info\n", + ") -> list[float] # Returns list of elapsed times in ms\n", + "```\n", + "\n", + "### Why `discard_first`?\n", + "\n", + "Even after warmup, the first few timing trials can be affected by:\n", + "- PyTorch's lazy tensor allocation finalizing\n", + "- cuDNN autotuning (still settling optimal algorithms)\n", + "- Driver state initialization\n", + "- First access to data structures\n", + "\n", + "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Experiment 2: Comparing All 4 Timing Methods\n", + "\n", + "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:47.008751Z", + "iopub.status.busy": "2025-12-17T21:24:47.008456Z", + "iopub.status.idle": "2025-12-17T21:24:50.238519Z", + "shell.execute_reply": "2025-12-17T21:24:50.237366Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparing all KernelBench timing methods on 4096x4096 matmul:\n", + "======================================================================\n", + "\n", + "Testing cuda_event...\n", + "[Profiling] Using timing method: cuda_event\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " cuda_event: 21.4000 ms (std=0.0169)\n", + "\n", + "Testing host_time...\n", + "[Profiling] Using timing method: host_time\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " host_time: 21.6000 ms (std=0.0159)\n", + "\n", + "Testing do_bench...\n", + "[Profiling] Using timing method: do_bench\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " do_bench: 21.4000 ms (std=0.0150)\n", + "\n", + "Testing do_bench_impl...\n", + "[Profiling] Using timing method: do_bench_impl\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " do_bench_impl: Skipped due to AttributeError (Triton version compatibility)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time is slightly slower due to CPU overhead,\n", + "but it catches ALL work on ALL streams - essential for untrusted code!\n" + ] + } + ], + "source": [ + "# Experiment 2: Compare all 4 timing methods\n", + "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", + "print(\"=\" * 70)\n", + "\n", + "methods = [\"cuda_event\", \"host_time\", \"do_bench\", \"do_bench_impl\"]\n", + "results = {}\n", + "\n", + "for method in methods:\n", + " print(f\"\\nTesting {method}...\")\n", + " try:\n", + " method_fn = get_timing_function(method)\n", + " times = method_fn(\n", + " simple_mm, \n", + " [a, b], \n", + " num_warmup=10, \n", + " num_trials=50, \n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " results[method] = get_timing_stats(times, device=DEVICE)\n", + " print(f\" {method}: {results[method]['mean']:.4f} ms (std={results[method]['std']:.4f})\")\n", + " except Exception as e:\n", + " print(f\" {method}: Skipped due to {type(e).__name__} (Triton version compatibility)\")\n", + " # Remove from list if it failed\n", + " methods = [m for m in methods if m in results]\n", + "\n", + "# Only plot if we have results\n", + "if results:\n", + " # Visualize the comparison\n", + " fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + " # Bar chart of mean times\n", + " available_methods = [m for m in methods if m in results]\n", + " means = [results[m]['mean'] for m in available_methods]\n", + " stds = [results[m]['std'] for m in available_methods]\n", + " colors = ['#2ecc71', '#e74c3c', '#3498db', '#9b59b6'][:len(available_methods)]\n", + "\n", + " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", + " axes[0].set_ylabel('Time (ms)')\n", + " axes[0].set_title('Mean Execution Time by Method')\n", + " axes[0].tick_params(axis='x', rotation=45)\n", + "\n", + " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", + " if 'cuda_event' in results and 'host_time' in results:\n", + " cuda_mean = results['cuda_event']['mean']\n", + " host_mean = results['host_time']['mean']\n", + " \n", + " axes[1].bar(['cuda_event', 'host_time'], \n", + " [cuda_mean, host_mean], \n", + " color=['#2ecc71', '#e74c3c'], alpha=0.8)\n", + " axes[1].set_ylabel('Time (ms)')\n", + " axes[1].set_title('cuda_event vs host_time\\n(host_time catches side-streams)\\n(graph truncated for readability)')\n", + " \n", + " # Truncate y-axis to make the difference easier to see\n", + " min_val = min(cuda_mean, host_mean)\n", + " max_val = max(cuda_mean, host_mean)\n", + " margin = (max_val - min_val) * 2 # Add margin around the data\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n", + " else:\n", + " axes[1].text(0.5, 0.5, 'Comparison unavailable', ha='center', va='center')\n", + " axes[1].set_axis_off()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time is slightly slower due to CPU overhead,\")\n", + "print(\"but it catches ALL work on ALL streams - essential for untrusted code!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `discard_first` Effect\n", + "\n", + "Even after warmup, the first timing trial can be affected by lazy initialization. Let's see this in action." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.241069Z", + "iopub.status.busy": "2025-12-17T21:24:50.240945Z", + "iopub.status.idle": "2025-12-17T21:24:50.348421Z", + "shell.execute_reply": "2025-12-17T21:24:50.347364Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demonstrating the discard_first effect:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", + "\n", + "First trial: 0.3454 ms\n", + "Mean of all trials: 0.3444 ms\n", + "Mean without first: 0.3443 ms\n", + "First trial overhead: 0.3%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The first trial often shows initialization overhead even after warmup.\n", + "Using discard_first=1 (default) gives more consistent measurements.\n" + ] + } + ], + "source": [ + "# Demonstrate the discard_first effect\n", + "# Even after warmup, the first timing trial can have higher overhead\n", + "\n", + "print(\"Demonstrating the discard_first effect:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Create fresh data and clear caches to make initialization overhead more visible\n", + "torch.cuda.empty_cache()\n", + "a_fresh, b_fresh = get_data(2048)\n", + "\n", + "# Collect trials with discard_first=0 to see ALL trials including the first one\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "times_all = timing_fn(\n", + " simple_mm, [a_fresh, b_fresh],\n", + " num_warmup=3,\n", + " num_trials=15,\n", + " discard_first=0, # Keep ALL trials including first\n", + " verbose=False,\n", + " device=DEVICE\n", + ")\n", + "\n", + "# Calculate statistics\n", + "first_trial = times_all[0]\n", + "remaining_trials = times_all[1:]\n", + "mean_all = np.mean(times_all)\n", + "mean_remaining = np.mean(remaining_trials)\n", + "\n", + "print(f\"\\nFirst trial: {first_trial:.4f} ms\")\n", + "print(f\"Mean of all trials: {mean_all:.4f} ms\")\n", + "print(f\"Mean without first: {mean_remaining:.4f} ms\")\n", + "print(f\"First trial overhead: {((first_trial / mean_remaining) - 1) * 100:.1f}%\")\n", + "\n", + "# Visualize the effect with a scatter plot\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_all)), times_all, alpha=0.7, color='blue', s=60)\n", + "plt.scatter([0], [first_trial], color='red', s=100, zorder=5, label=f'First trial: {first_trial:.3f}ms')\n", + "plt.axhline(y=mean_remaining, color='green', linestyle='--', alpha=0.7, \n", + " label=f'Mean (without first): {mean_remaining:.3f}ms')\n", + "plt.axhline(y=mean_all, color='orange', linestyle=':', alpha=0.7,\n", + " label=f'Mean (all): {mean_all:.3f}ms')\n", + "plt.xlabel('Trial Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('First Trial Overhead Effect (after warmup)')\n", + "plt.legend(loc='upper right')\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(\"\\nThe first trial often shows initialization overhead even after warmup.\")\n", + "print(\"Using discard_first=1 (default) gives more consistent measurements.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HwsjlhAazX2j" + }, + "source": [ + "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", + "\n", + "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", + "\n", + "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.351000Z", + "iopub.status.busy": "2025-12-17T21:24:50.350876Z", + "iopub.status.idle": "2025-12-17T21:24:52.778917Z", + "shell.execute_reply": "2025-12-17T21:24:52.777685Z" + }, + "id": "UuwtML39zX2j", + "outputId": "95ebbb26-e415-491a-da30-6a78ce387906" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard benchmark on tricky kernel: 0.0978 ms\n" + ] + } + ], + "source": [ + "def tricky_agent_kernel(a, b):\n", + " \"\"\"A 'clever' kernel that games the benchmarking harness.\"\"\"\n", + " # The agent creates a new stream to \"optimize\"\n", + " s = torch.cuda.Stream()\n", + " with torch.cuda.stream(s):\n", + " # This work happens on a side channel!\n", + " result = torch.matmul(a, b)\n", + " return result\n", + "\n", + "print(f\"Standard benchmark on tricky kernel: {final_benchmark(tricky_agent_kernel, a, b):.4f} ms\")\n", + "# Likely reports ~0.00ms or very close to it!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3HXns_XizX2j" + }, + "source": [ + "**The Issue:**\n", + "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", + "\n", + "1. Benchmark starts timer on Stream A (the default stream).\n", + "2. Agent launches work on Stream B and returns immediately.\n", + "3. Benchmark stops timer on Stream A.\n", + "\n", + "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", + "\n", + "**Why this matters for evals:**\n", + "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", + "\n", + "**Mitigations:**\n", + "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", + "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", + "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", + "\n", + "### How KernelBench Addresses This\n", + "\n", + "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", + "\n", + "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", + "\n", + "```python\n", + "# For trusted code (faster, but can be fooled)\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For untrusted/agent code (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "```\n", + "\n", + "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.782281Z", + "iopub.status.busy": "2025-12-17T21:24:52.782061Z", + "iopub.status.idle": "2025-12-17T21:24:52.830292Z", + "shell.execute_reply": "2025-12-17T21:24:52.829161Z" + }, + "id": "KbAFqiyizX2j", + "outputId": "6bc91db4-935c-4af9-bdc9-be3c50e890c4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Robust benchmark on tricky kernel: 21.5401 ms\n", + "Robust benchmark on normal kernel: 21.4700 ms\n" + ] + } + ], + "source": [ + "def benchmark_untrusted(func, *args):\n", + " \"\"\"Benchmark untrusted code by using wall-clock time with full device sync.\n", + "\n", + " This trades some precision (includes CPU overhead) for correctness\n", + " (catches work on any stream).\n", + " \"\"\"\n", + " torch.cuda.synchronize() # Clear any pending work\n", + " start = time.perf_counter()\n", + " func(*args)\n", + " torch.cuda.synchronize() # Wait for ALL streams\n", + " end = time.perf_counter()\n", + " return (end - start) * 1000\n", + "\n", + "print(f\"Robust benchmark on tricky kernel: {benchmark_untrusted(tricky_agent_kernel, a, b):.4f} ms\")\n", + "print(f\"Robust benchmark on normal kernel: {benchmark_untrusted(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.832854Z", + "iopub.status.busy": "2025-12-17T21:24:52.832734Z", + "iopub.status.idle": "2025-12-17T21:24:53.846639Z", + "shell.execute_reply": "2025-12-17T21:24:53.845578Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Side-Stream Detection Experiment:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Tricky kernel with cuda_event: 0.3070 ms (FOOLED!)\n", + "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", + "Normal kernel with host_time: 21.6000 ms (reference)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time correctly measures the tricky kernel!\n", + "Use host_time for evaluating untrusted/agent-generated code.\n" + ] + } + ], + "source": [ + "# Side-Stream Detection with KernelBench's host_time\n", + "# Let's demonstrate how host_time catches the tricky kernel\n", + "\n", + "print(\"Side-Stream Detection Experiment:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# cuda_event (can be fooled by side-streams)\n", + "cuda_timing = get_timing_function(\"cuda_event\")\n", + "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", + "\n", + "# host_time (catches all streams)\n", + "host_timing = get_timing_function(\"host_time\")\n", + "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "host_stats = get_timing_stats(host_times, device=DEVICE)\n", + "\n", + "# Normal kernel for reference\n", + "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", + "\n", + "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", + "print(f\"Tricky kernel with host_time: {host_stats['mean']:.4f} ms (CORRECT)\")\n", + "print(f\"Normal kernel with host_time: {normal_stats['mean']:.4f} ms (reference)\")\n", + "\n", + "# Visualize the dramatic difference\n", + "plt.figure(figsize=(10, 5))\n", + "methods = ['cuda_event\\n(fooled)', 'host_time\\n(correct)', 'Normal kernel\\n(reference)']\n", + "times = [cuda_stats['mean'], host_stats['mean'], normal_stats['mean']]\n", + "colors = ['red', 'green', 'blue']\n", + "\n", + "plt.bar(methods, times, color=colors, alpha=0.8)\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('Side-Stream Detection: cuda_event vs host_time')\n", + "plt.grid(True, alpha=0.3, axis='y')\n", + "\n", + "# Add annotation\n", + "plt.annotate('Agent trick detected!', xy=(1, host_stats['mean']), \n", + " xytext=(1.3, host_stats['mean'] * 0.7),\n", + " arrowprops=dict(arrowstyle='->', color='green'),\n", + " fontsize=10, color='green')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time correctly measures the tricky kernel!\")\n", + "print(\"Use host_time for evaluating untrusted/agent-generated code.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Uq4qvl8FzX2j" + }, + "source": [ + "## Correctness Before Speed\n", + "\n", + "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.849299Z", + "iopub.status.busy": "2025-12-17T21:24:53.849171Z", + "iopub.status.idle": "2025-12-17T21:24:53.929702Z", + "shell.execute_reply": "2025-12-17T21:24:53.928700Z" + }, + "id": "J9W63Q5czX2k", + "outputId": "312076ee-f089-4276-8b8f-bb7a23575d3d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Correctness verified!\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Kernel time: 0.0648 ms\n" + ] + } + ], + "source": [ + "def my_experimental_kernel(a, b):\n", + " \"\"\"Pretend this is our custom optimized kernel.\"\"\"\n", + " return torch.matmul(a, b) # In reality, this would be your Triton/CUDA code\n", + "\n", + "def verify_correctness(kernel_fn, ref_fn, *args, atol=1e-2, rtol=1e-2):\n", + " \"\"\"Verify kernel produces correct output before benchmarking.\"\"\"\n", + " ref_output = ref_fn(*args)\n", + " kernel_output = kernel_fn(*args)\n", + "\n", + " if not torch.allclose(ref_output, kernel_output, atol=atol, rtol=rtol):\n", + " max_diff = (ref_output - kernel_output).abs().max().item()\n", + " raise AssertionError(\n", + " f\"Kernel output doesn't match reference! \"\n", + " f\"Max difference: {max_diff:.6f}\"\n", + " )\n", + " print(\"✓ Correctness verified!\")\n", + " return True\n", + "\n", + "# Always verify before benchmarking\n", + "a_test, b_test = get_data(1024)\n", + "verify_correctness(my_experimental_kernel, simple_mm, a_test, b_test)\n", + "\n", + "# Only benchmark if correct\n", + "time_ms = final_benchmark(my_experimental_kernel, a_test, b_test)\n", + "print(f\"Kernel time: {time_ms:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", + "\n", + "Now that we have correct, well-measured timings, the natural question is: **\"Is this kernel actually fast?\"** A kernel that runs in 2ms might sound good, but if the hardware could theoretically do it in 0.5ms, you're leaving 75% of performance on the table.\n", + "\n", + "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", + "\n", + "### Understanding Roofline Analysis\n", + "\n", + "The Roofline Model helps you understand whether your kernel is:\n", + "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", + "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", + "\n", + "**Key formulas:**\n", + "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", + "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", + "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", + "\n", + "For matrix multiplication of two $N \\times N$ matrices:\n", + "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", + "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", + "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", + "\n", + "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.932346Z", + "iopub.status.busy": "2025-12-17T21:24:53.932227Z", + "iopub.status.idle": "2025-12-17T21:24:56.741833Z", + "shell.execute_reply": "2025-12-17T21:24:56.740706Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix Multiplication Performance\n", + "=================================================================\n", + "Size Time (ms) TFLOPS % of TF32 Peak \n", + "-----------------------------------------------------------------\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "1024 0.0647 33.19 3.4 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2048 0.3440 49.94 5.0 %\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4096 2.6700 51.48 5.2 %\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8192 21.4000 51.38 5.2 %\n", + "\n", + "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", + "H200 TF32 theoretical peak: 989.0 TFLOPS\n", + "\n", + "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" + ] + } + ], + "source": [ + "def get_tflops(n, time_ms):\n", + " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", + " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", + " tflops = flops / (time_ms * 1e-3) / 1e12\n", + " return tflops\n", + "\n", + "# Theoretical peaks vary by GPU and precision\n", + "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", + "GPU_PEAK_TFLOPS = {\n", + " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", + " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + "}\n", + "\n", + "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", + "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", + "\n", + "# Benchmark at different sizes\n", + "print(\"Matrix Multiplication Performance\")\n", + "print(\"=\" * 65)\n", + "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", + "print(\"-\" * 65)\n", + "\n", + "for size in [1024, 2048, 4096, 8192]:\n", + " a_test, b_test = get_data(size)\n", + " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", + " tflops = get_tflops(size, time_ms)\n", + " efficiency = (tflops / PEAK_TFLOPS) * 100\n", + " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", + "\n", + "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", + "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", + "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zcYVXCkUzX2k" + }, + "source": [ + "## Conclusion\n", + "\n", + "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", + "\n", + "### What We Learned\n", + "\n", + "Through our journey, we discovered that robust GPU benchmarking requires:\n", + "1. **Device Synchronization** - Wait for GPU work to complete\n", + "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", + "3. **Warmup Runs** - Settle compilation and memory allocators\n", + "4. **Multiple Samples** - Build statistical distributions\n", + "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", + "6. **Median Aggregation** - Filter out OS jitter and outliers\n", + "7. **Side-Stream Detection** - Catch work on non-default streams\n", + "\n", + "### What KernelBench Provides\n", + "\n", + "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", + "\n", + "| Function | Purpose |\n", + "|----------|---------|\n", + "| `get_timing_function(method)` | Factory returning timing function by name |\n", + "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", + "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", + "\n", + "**Four timing methods for different use cases:**\n", + "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", + "- **`host_time`** - For untrusted/agent code (catches all streams)\n", + "- **`do_bench`** - Triton-style adaptive trial counts\n", + "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", + "\n", + "**Key parameters:**\n", + "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", + "\n", + "### Recommended Usage\n", + "\n", + "```python\n", + "from src.timing import get_timing_function, get_timing_stats\n", + "\n", + "# For trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For agent evaluations (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "\n", + "# Run benchmark\n", + "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", + "stats = get_timing_stats(times, device=\"cuda:0\")\n", + "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", + "```\n", + "\n", + "Happy optimizing!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7Ah151CHzX2k" + }, + "source": [ + "---\n", + "\n", + "### Footnotes\n", + "\n", + "**On GPU Clock States:** For highly reproducible benchmarks (e.g., publishing papers), consider locking GPU clocks with `nvidia-smi -lgc `. GPUs dynamically adjust clock speeds based on thermals and power, which can introduce variance between runs. For most development work, median-based benchmarking handles this adequately.\n", + "\n", + "**On Warmup Iterations:** We use fixed warmup counts (10-50 iterations) for simplicity, but this can be insufficient or wasteful depending on the kernel. In extremely sensitive environments, you can implement an adaptive stopping criterion: run warmup iterations until the variance of recent samples falls below a threshold, indicating the system has stabilized. This is covered in more detail in the [GPU MODE lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU).\n", + "\n", + "**On Bare Metal vs. Virtualized Environments:** Cloud VMs and containers add layers of abstraction that can introduce variance and overhead. GPU passthrough in virtualized environments adds latency, and shared cloud instances suffer from \"noisy neighbor\" effects where other tenants' workloads impact your measurements. For publishable results or when chasing small performance deltas, prefer bare metal. For day-to-day development, cloud instances are fine as long as you're aware your numbers may not match others exactly." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "include_colab_link": true, + "provenance": [] + }, + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 7a23bb0fe611a300519e72aeb579a333d760e070 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 13:42:16 -0800 Subject: [PATCH 2/6] fix typo --- notebooks/benchmarking.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 5bb7470d..339cf02b 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -868,14 +868,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Experiment 2: Comparing All 4 Timing Methods\n", + "# Comparing All 4 Timing Methods\n", "\n", "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:47.008751Z", @@ -968,7 +968,7 @@ } ], "source": [ - "# Experiment 2: Compare all 4 timing methods\n", + "# Compare all KernelBench timing methods on 4096x4096 matmul\n", "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", "print(\"=\" * 70)\n", "\n", From 35d8d2266270dc68b033bffd548342bdc74ecdcd Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:00:29 -0800 Subject: [PATCH 3/6] fix --- notebooks/benchmarking.ipynb | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 339cf02b..af8be928 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -215,7 +215,7 @@ }, "source": [ "**The Problem:**\n", - "Wait, ~0.5ms? That seems impossibly fast for a 4096² matrix multiplication involving 137 billion floating-point operations.\n", + "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", "\n", "**What happened?**\n", "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", @@ -224,7 +224,12 @@ "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", "\n", - "Let's compare these approaches to see the difference." + "Let's compare these approaches to see the difference.\n", + "\n", + "---\n", + "\n", + "\n", + "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." ] }, { From 7566e41cdcbeeb41f27adf82365bad912637337e Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:06:04 -0800 Subject: [PATCH 4/6] Benchmarking guide --- notebooks/benchmarking.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index af8be928..6b77fd20 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -1480,7 +1480,7 @@ "source": [ "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", "\n", - "Now that we have correct, well-measured timings, the natural question is: **\"Is this kernel actually fast?\"** A kernel that runs in 2ms might sound good, but if the hardware could theoretically do it in 0.5ms, you're leaving 75% of performance on the table.\n", + "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", "\n", "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", "\n", From 57d0ea87302bf4df7eafda73ac79e6d0eb5fead7 Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:39:06 -0800 Subject: [PATCH 5/6] Benchmarking guide --- benchmarking.ipynb | 1561 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1561 insertions(+) create mode 100644 benchmarking.ipynb diff --git a/benchmarking.ipynb b/benchmarking.ipynb new file mode 100644 index 00000000..a9f3ba15 --- /dev/null +++ b/benchmarking.ipynb @@ -0,0 +1,1561 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_PCU0gUyzX2c" + }, + "source": [ + "# A Practical Guide to GPU Benchmarking\n", + "\n", + "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", + "\n", + "## TL;DR — How to Benchmark Correctly\n", + "\n", + "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", + "\n", + "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", + "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", + "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", + "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", + "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", + "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", + "\n", + "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", + "\n", + "-----\n", + "\n", + "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", + "\n", + "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", + "\n", + "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:36.427802Z", + "iopub.status.busy": "2025-12-17T21:24:36.427684Z", + "iopub.status.idle": "2025-12-17T21:24:40.995279Z", + "shell.execute_reply": "2025-12-17T21:24:40.994328Z" + }, + "id": "PKWz_W7uzX2f", + "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using GPU: NVIDIA H200\n" + ] + } + ], + "source": [ + "# @title Environment Setup\n", + "# Ensure we have the necessary libraries and a GPU available\n", + "# !pip install -q triton matplotlib numpy torch\n", + "# !pip install -e .. # Install KernelBench locally for timing utilities\n", + "\n", + "import sys\n", + "import os\n", + "sys.path.insert(0, '..') # Add parent directory to path for imports\n", + "\n", + "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", + "\n", + "import torch\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import triton\n", + "\n", + "# Import KernelBench's timing module\n", + "from src import timing\n", + "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", + "\n", + "if not torch.cuda.is_available():\n", + " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", + "\n", + "# Device configuration\n", + "# The selected GPU will appear as cuda:0\n", + "\n", + "DEVICE = f\"cuda:0\"\n", + "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kjWByrwvzX2f" + }, + "source": [ + "## The Journey: Benchmarking a Matrix Multiplication\n", + "\n", + "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:40.997969Z", + "iopub.status.busy": "2025-12-17T21:24:40.997722Z", + "iopub.status.idle": "2025-12-17T21:24:41.252072Z", + "shell.execute_reply": "2025-12-17T21:24:41.250967Z" + }, + "id": "gxtKes5lzX2g", + "outputId": "5890bae4-5b9a-4366-8947-367146593158" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output shape: torch.Size([8192, 8192])\n", + "Op ran successfully\n" + ] + } + ], + "source": [ + "# A standard size for testing\n", + "N = 8192\n", + "\n", + "def get_data(n=N, device=DEVICE):\n", + " \"\"\"Generate random float32 matrices for benchmarking.\"\"\"\n", + " return torch.randn(n, n, device=device), torch.randn(n, n, device=device)\n", + "\n", + "def simple_mm(a, b):\n", + " \"\"\"Our kernel under test: standard matrix multiplication.\"\"\"\n", + " return torch.matmul(a, b)\n", + "\n", + "# Let's verify it runs\n", + "a, b = get_data()\n", + "res = simple_mm(a, b)\n", + "print(f\"Output shape: {res.shape}\")\n", + "print(\"Op ran successfully\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GWlsBEVyzX2g" + }, + "source": [ + "### Attempt 1: The Naive Timer\n", + "\n", + "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.254622Z", + "iopub.status.busy": "2025-12-17T21:24:41.254499Z", + "iopub.status.idle": "2025-12-17T21:24:41.258106Z", + "shell.execute_reply": "2025-12-17T21:24:41.257414Z" + }, + "id": "LynIxLaRzX2g", + "outputId": "72548dad-6570-4eaa-ce07-923556fe70b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive time: 0.6356 ms\n" + ] + } + ], + "source": [ + "def benchmark_naive(func, *args):\n", + " \"\"\"WRONG: Measures kernel launch time, not execution time.\"\"\"\n", + " start = time.time()\n", + " func(*args)\n", + " end = time.time()\n", + " return (end - start) * 1000 # to ms\n", + "\n", + "t = benchmark_naive(simple_mm, a, b)\n", + "print(f\"Naive time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gw4NGYRmzX2h" + }, + "source": [ + "**The Problem:**\n", + "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", + "\n", + "**What happened?**\n", + "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", + "\n", + "To fix this, we need to:\n", + "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", + "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", + "\n", + "Let's compare these approaches to see the difference.\n", + "\n", + "---\n", + "\n", + "\n", + "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Attempt 2: Synchronizing the Device\n", + "\n", + "To fix this, we need to force the CPU to wait until the GPU has finished its work before we stop the clock. We do this with `torch.cuda.synchronize()`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.260592Z", + "iopub.status.busy": "2025-12-17T21:24:41.260479Z", + "iopub.status.idle": "2025-12-17T21:24:41.460207Z", + "shell.execute_reply": "2025-12-17T21:24:41.459267Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sync time: 21.5368 ms\n" + ] + } + ], + "source": [ + "def benchmark_sync(func, *args):\n", + " \"\"\"Better: Actually waits for GPU to finish.\"\"\"\n", + " torch.cuda.synchronize() # Wait for previous work to finish\n", + " start = time.time()\n", + " func(*args)\n", + " torch.cuda.synchronize() # Wait for THIS work to finish\n", + " end = time.time()\n", + " return (end - start) * 1000\n", + "\n", + "t = benchmark_sync(simple_mm, a, b)\n", + "print(f\"Sync time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dV8AmQi-zX2i" + }, + "source": [ + "### Attempt 3: Removing CPU Overhead (CUDA Events)\n", + "\n", + "To get a precise measurement, we need to bypass the CPU clock entirely. We can ask the GPU driver to record timestamps directly on the device using `torch.cuda.Event`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.463315Z", + "iopub.status.busy": "2025-12-17T21:24:41.463177Z", + "iopub.status.idle": "2025-12-17T21:24:41.532922Z", + "shell.execute_reply": "2025-12-17T21:24:41.531966Z" + }, + "id": "i6PfSdkTzX2i", + "outputId": "8b3e29d1-1789-4bfb-9a44-599016516dd7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.7344 ms\n", + "Run 1: 21.4754 ms\n", + "Run 2: 21.4987 ms\n" + ] + } + ], + "source": [ + "def benchmark_events(func, *args):\n", + " \"\"\"Better: Uses GPU timestamps, avoiding CPU overhead.\"\"\"\n", + " start_event = torch.cuda.Event(enable_timing=True)\n", + " end_event = torch.cuda.Event(enable_timing=True)\n", + "\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " start_event.record()\n", + " func(*args)\n", + " end_event.record()\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " return start_event.elapsed_time(end_event) # Returns ms directly\n", + "\n", + "# Run it a few times\n", + "for i in range(3):\n", + " print(f\"Run {i}: {benchmark_events(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BkfaaDawzX2i" + }, + "source": [ + "### Attempt 4: Handling the \"Cold Start\"\n", + "\n", + "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", + "\n", + "**The Fix:**\n", + "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:41.535509Z", + "iopub.status.busy": "2025-12-17T21:24:41.535387Z", + "iopub.status.idle": "2025-12-17T21:24:42.246476Z", + "shell.execute_reply": "2025-12-17T21:24:42.245382Z" + }, + "id": "j_PsAuJkzX2i", + "outputId": "d6983401-72d3-468c-ffd8-c0833e8d5556" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 0: 21.6478 ms\n", + "Run 1: 21.4837 ms\n", + "Run 2: 21.4852 ms\n" + ] + } + ], + "source": [ + "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", + " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", + " # Warmup phase\n", + " for _ in range(warmup_iters):\n", + " func(*args)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + " # Measurement phase\n", + " measurements = []\n", + " for _ in range(benchmark_iters):\n", + " measurements.append(benchmark_events(func, *args))\n", + " torch.cuda.synchronize(device=DEVICE)\n", + " return measurements\n", + "\n", + "# print(f\"Warmed up time: {benchmark_warmup(simple_mm, a, b):.4f} ms\")\n", + "\n", + "for i, measurement in enumerate(benchmark_warmup(simple_mm, a, b)):\n", + " print(f\"Run {i}: {measurement:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OR3uOh7kzX2i" + }, + "source": [ + "### Attempt 5: The Single Sample Fallacy (Variance)\n", + "\n", + "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", + "\n", + "#### Visualizing the Jitter\n", + "\n", + "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 653 + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:42.248937Z", + "iopub.status.busy": "2025-12-17T21:24:42.248818Z", + "iopub.status.idle": "2025-12-17T21:24:44.484746Z", + "shell.execute_reply": "2025-12-17T21:24:44.483759Z" + }, + "id": "T-7QH4cHzX2i", + "outputId": "c758effd-a810-422d-d3ca-66c128cdb716" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA18AAAIjCAYAAAD80aFnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoDdJREFUeJzs3Xl4U1X+P/B3lmZpk6Z0Cd2AlhbZyi46iAJaBBR1FATXEYRhYCwwwOAo+HNhdOy4bygMfh2KCq7AyKCggBbFgVFBlAoiLRSktKRr2qRN0/be3x+dhoa2aZJm7/v1PH2e5t6Tm3OTk5P7uWeTiKIogoiIiIiIiLxK6u8MEBERERERdQcMvoiIiIiIiHyAwRcREREREZEPMPgiIiIiIiLyAQZfREREREREPsDgi4iIiIiIyAcYfBEREREREfkAgy8iIiIiIiIfYPBFRERERETkAwy+iIhCSG5uLiQSCT788EN/Z8Upjz32GCQSCcrKyhymmz17NlJSUnyTKSekpKRg9uzZ/s5GUCosLIREIkFOTk6naQPtcyci6ioGX0RETsrJyYFEIrH70+v1uPrqq7Fjxw5/Z4+8ZMKECcjIyHCY5ujRo3jsscdQWFjYZt9rr73mVKDhaZWVlViwYAGSkpIQERGBYcOG4ZlnnnHrWFu3bsV1112H2NhYKBQKJCYmYubMmfj88889nGv3CIKAN998E5dffjmio6Oh1WpxySWX4J577sGBAwds6Rx9Tp7gr8+aiIKH3N8ZICIKNn/961+RmpoKURRx/vx55OTk4Prrr8e///1v3HDDDf7OXkh6/fXXIQiCv7Nhc/z4cUilF+5fHj16FKtWrcKECRPatNS89tpriI2N9XlL2ezZs/HJJ59g4cKFGDBgAH744Qds3LgR999/v9PHEEURc+bMQU5ODkaMGIFly5YhPj4excXF2Lp1KzIzM/H111/jiiuu8OKZdG7x4sV49dVX8dvf/hZ33XUX5HI5jh8/jh07dqBv3774zW9+A8Dx5+QJ/vqsiSh4MPgiInLRddddh0svvdT2eO7cuejZsyfeeecdBl9OMpvNiIiIcDp9WFiYF3PjOqVS6dfXb2xshCAIUCgU7e43m83Yvn07FixYgBdeeMG2vb6+3qXXee6555CTk4MlS5bg+eefh0Qise176KGH8NZbb0Eu9++lxPnz5/Haa69h3rx5WLdund2+F198EaWlpV7PQ21tLcLDw73+OkQU/NjtkIioi6KioqBWq9tchAqCgBdffBGDBw+GSqVCz549MX/+fFRWVtqlS0lJwQ033IB9+/bhsssug0qlQt++ffHmm2+2ea2qqiosXboUKSkpUCqVSE5Oxj333NNmzJQgCPjb3/6G5ORkqFQqZGZmIj8/3y5NS3e6H3/8EePHj0d4eDjS09Nt48X27t2Lyy+/HGq1Gv3798fu3bvtnn/69Gncd9996N+/P9RqNWJiYjBjxow2Xbpaumvu3bsX9913H/R6PZKTkzt8P0+fPo309HRkZGTg/PnzANqO/WkZN/Tss89i3bp1SEtLg1KpxOjRo/Htt9+2OeYHH3yAQYMGQaVSISMjA1u3bu3SeKLWY75ycnIwY8YMAMDVV19t65Kam5uLlJQU/PTTT9i7d69t+4QJE2zHqaqqwpIlS9CrVy8olUqkp6fjqaeesmvla32uL774ou1cjx492mH+Wl5LFEW77a4EjXV1dcjOzsaAAQPw7LPP2gVeLX73u9/hsssusz0+efIkZsyYgejoaISHh+M3v/kNPv74Y6de71//+hcyMjLsPiNnnDp1CqIoYuzYsW32tXQNBhx/TgDw0UcfYerUqUhMTIRSqURaWhoef/xxNDU12R2z5Xtz8OBBjBs3DuHh4Vi5cmWnnzUREcCWLyIilxmNRpSVlUEURRgMBrzyyiswmUy4++677dLNnz8fOTk5uPfee7F48WKcOnUKq1evxvfff4+vv/7arjUnPz8ft956K+bOnYtZs2bhn//8J2bPno1Ro0Zh8ODBAACTyYSrrroKx44dw5w5czBy5EiUlZVh27ZtOHv2LGJjY23H+/vf/w6pVIrly5fDaDTi6aefxl133YX//ve/dnmsrKzEDTfcgNtvvx0zZszAmjVrcPvtt2Pjxo1YsmQJFixYgDvvvBPPPPMMbr31Vvz666/QarUAgG+//Rb/+c9/cPvttyM5ORmFhYVYs2YNJkyYgKNHj7ZpCbjvvvsQFxeHRx55BGazud33tqCgANdccw2io6Oxa9cuu3Nqz6ZNm1BTU4P58+dDIpHg6aefxrRp03Dy5Enb+/vxxx/jtttuw5AhQ5CdnY3KykrMnTsXSUlJDo/trHHjxmHx4sV4+eWXsXLlSgwcOBAAMHDgQLz44otYtGgRNBoNHnroIQBAz549ATS3lowfPx5FRUWYP38+evfujf/85z9YsWIFiouL8eKLL9q9zvr162GxWPCHP/wBSqUS0dHRHeYpPDwcM2fORE5ODubNm4cRI0a4fF779u1DRUUFlixZAplM1mn68+fP44orrkBtbS0WL16MmJgYbNiwATfddBM+/PBD3HLLLR0+97PPPsP06dMxaNAgZGdno7y8HPfee6/DIL1Fnz59ADQH2DNmzOiwBcrR5wQ0B2cajQbLli2DRqPB559/jkceeQTV1dVtxsqVl5fjuuuuw+233467774bPXv2xIQJEzr8rImIbEQiInLK+vXrRQBt/pRKpZiTk2OX9quvvhIBiBs3brTbvnPnzjbb+/TpIwIQv/zyS9s2g8EgKpVK8c9//rNt2yOPPCICELds2dImb4IgiKIoil988YUIQBw4cKBYX19v2//SSy+JAMQjR47Yto0fP14EIG7atMm27eeffxYBiFKpVDxw4IBt+6effioCENevX2/bVltb2yYf+/fvFwGIb775Zpv37corrxQbGxvt0j/66KMiALG0tFQ8duyYmJiYKI4ePVqsqKiwSzdr1iyxT58+tsenTp0SAYgxMTF2aT/66CMRgPjvf//btm3IkCFicnKyWFNTY9uWm5srArA7ZkfGjx8vDh482G5bnz59xFmzZtkef/DBByIA8Ysvvmjz/MGDB4vjx49vs/3xxx8XIyIixF9++cVu+4MPPijKZDLxzJkzducaGRkpGgyGTvMriqJYU1MjTpw4UVQoFGLPnj3bvIYzWsrM1q1bnUq/ZMkSEYD41Vdf2eUjNTVVTElJEZuamuzOp3VZGj58uJiQkCBWVVXZtn322WdOf0b33HOPCEDs0aOHeMstt4jPPvuseOzYsTbpHH1O7ZXn+fPni+Hh4aLFYrFta/nerF27tk36jj5rIqIW7HZIROSiV199Fbt27cKuXbvw9ttv4+qrr8bvf/97bNmyxZbmgw8+gE6nw7XXXouysjLb36hRo6DRaPDFF1/YHXPQoEG46qqrbI/j4uLQv39/nDx50rZt8+bNGDZsWLstCBd3Cbv33nvtxgO1HLv18QBAo9Hg9ttvtz3u378/oqKiMHDgQFx++eW27S3/t36+Wq22/d/Q0IDy8nKkp6cjKioKhw4dapPHefPmddiCkpeXh/HjxyMlJQW7d+9Gjx492k13sdtuu80u7cXnee7cORw5cgT33HMPNBqNLd348eMxZMgQp17DWz744ANcddVV6NGjh10ZmThxIpqamvDll1/apZ8+fTri4uKcOvY999yDwsJC/Pzzz4iLi8PEiRNx5swZ2/79+/dDIpFgz549HR6juroaAGwtnZ355JNPcNlll+HKK6+0bdNoNPjDH/6AwsLCDrtJFhcX4/Dhw5g1axZ0Op1t+7XXXotBgwY59drr16/H6tWrkZqaiq1bt2L58uUYOHAgMjMzUVRU5NQxWpfnmpoalJWV4aqrrkJtbS1+/vlnu7RKpRL33nuvU8clImqNwRcRkYsuu+wyTJw4ERMnTsRdd92Fjz/+GIMGDcLChQthtVoBACdOnIDRaIRer0dcXJzdn8lkgsFgsDtm796927xOjx497MaHFRQUdDrleUfHawlQLh5vlpyc3CZw0+l06NWrV5ttFz+/rq4OjzzyiG28UmxsLOLi4lBVVQWj0dgmT6mpqR3m98Ybb4RWq8Wnn36KyMhIJ86wWWfnefr0aQBAenp6m+e2t82XTpw4gZ07d7YpHxMnTgSANmXE0fvX2oEDB7B161Y8+eSTSE1Nxc6dOwEAEydOtI2hy8vLg1wux6hRozo8TsvnUFNT49Trnj59Gv3792+zvaVbX8tn0d7zAKBfv35t9rV3vPZIpVJkZWXh4MGDKCsrw0cffYTrrrsOn3/+ud3NBUd++ukn3HLLLdDpdIiMjERcXJytK/HF5TkpKanDyU6IiBzhmC8ioi6SSqW4+uqr8dJLL+HEiRMYPHgwBEGAXq/Hxo0b233OxS0YHbUIiRdNmOAsZ4/XUTpnnr9o0SKsX78eS5YswZgxY6DT6SCRSHD77be3Oy1865aFi02fPh0bNmzAxo0bMX/+/A7TuZPPQCUIAq699lr85S9/aXf/JZdcYvfY0fvX2n/+8x8AsE2vnpSUhE8//RRXXnklrr32WuTm5mLdunW4/vrrERUV1eFxBgwYAAA4cuQIbr75ZqdeOxDExMTgpptuwk033YQJEyZg7969OH36tG1sWHuqqqowfvx4REZG4q9//SvS0tKgUqlw6NAhPPDAA23Ks7OfBRHRxRh8ERF5QGNjI4DmSTEAIC0tDbt378bYsWM9dqGWlpaGvLw8jxzLEz788EPMmjULzz33nG2bxWJBVVWVy8d65plnIJfLcd9990Gr1eLOO+/0SB5bLrgvnumxo23uam8mwM72paWlwWQy2Vq6PJ2XX3/91daCOWDAAHz88cfIzMzEqFGjcObMGfzjH/9weJwrr7wSPXr0wDvvvIOVK1d2OulGnz59cPz48TbbW7rsdRT8tGw/ceJEm33tHc8Vl156Kfbu3Yvi4mL06dOnw88iNzcX5eXl2LJlC8aNG2fbfurUKZdez1E5ICIC2O2QiKjLGhoa8Nlnn0GhUNi6WM2cORNNTU14/PHH26RvbGx0K0CZPn06fvjhh3an4PZHS49MJmvzuq+88kqbqbmdIZFIsG7dOtx6662YNWsWtm3b5pE8JiYmIiMjA2+++aYtMAaap9E/cuSIR14DgG3NsvY+14iIiHa3z5w5E/v378enn37aZl9VVZUtoHdVZmYmgObFwFsf4/LLL8f/+3//D4WFhejXr1+nXVjDw8PxwAMP4NixY3jggQfaLWNvv/02vvnmGwDA9ddfj2+++Qb79++37TebzVi3bh1SUlI6HL+VkJCA4cOHY8OGDXbd+3bt2uVwOv0WJSUl7aazWq3Ys2cPpFKprYtpR59TS2DZ+hytVitee+21Tl+/tY4+ayKiFmz5IiJy0Y4dO2x38w0GAzZt2oQTJ07gwQcftI2TGT9+PObPn4/s7GwcPnwYkyZNQlhYGE6cOIEPPvgAL730Em699VaXXvf+++/Hhx9+iBkzZmDOnDkYNWoUKioqsG3bNqxduxbDhg3z+Lk6csMNN+Ctt96CTqfDoEGDsH//fuzevRsxMTFuHU8qleLtt9/GzTffjJkzZ+KTTz7BNddc0+V8Pvnkk/jtb3+LsWPH4t5770VlZSVWr16NjIwMu4CsK4YPHw6ZTIannnoKRqMRSqUS11xzDfR6PUaNGoU1a9bgiSeeQHp6OvR6Pa655hrcf//92LZtG2644QbbsgJmsxlHjhzBhx9+iMLCwk6n2m/P0KFDbVOqjx49GnfccQeioqLw1Vdf4d1338VVV12Fffv2Yd68ediwYYPDY91///346aef8Nxzz+GLL77Arbfeivj4eJSUlOBf//oXvvnmG1s3xwcffBDvvPMOrrvuOixevBjR0dHYsGEDTp06hc2bN0Mq7fh+b3Z2NqZOnYorr7wSc+bMQUVFBV555RUMHjy408/o7NmzuOyyy3DNNdcgMzMT8fHxMBgMeOedd/DDDz9gyZIltvexo8/piiuuQI8ePTBr1iwsXrwYEokEb731lss3NTr6rImIbPw2zyIRUZBpb6p5lUolDh8+XFyzZo1tuvfW1q1bJ44aNUpUq9WiVqsVhwwZIv7lL38Rz507Z0vTp08fcerUqW2eO378+DbTVpeXl4sLFy4Uk5KSRIVCISYnJ4uzZs0Sy8rKRFG8MNX8Bx98YPe89qb3bm8KdUf5ASBmZWXZHldWVor33nuvGBsbK2o0GnHy5Mnizz//3GYa9pb37dtvv21zzNZTzbeora0Vx48fL2o0Gtt09x1NNf/MM8+0m89HH33Ubtu7774rDhgwQFQqlWJGRoa4bds2cfr06eKAAQPaPP9i48aNE4cOHWq37eJzFEVRfP3118W+ffuKMpnMbjrzkpIScerUqaJWqxUB2H2mNTU14ooVK8T09HRRoVCIsbGx4hVXXCE+++yzotVq7fRcHXnjjTfEUaNGiSqVStRoNOJVV10lvvvuu6IoiuLKlStFAOKqVaucOtaHH34oTpo0SYyOjhblcrmYkJAg3nbbbWJubq5duoKCAvHWW28Vo6KiRJVKJV522WXi9u3b7dK0VxZFURQ3b94sDhw4UFQqleKgQYPELVu2tPnc21NdXS2+9NJL4uTJk8Xk5GQxLCxM1Gq14pgxY8TXX3+9zfeyo8/p66+/Fn/zm9+IarVaTExMFP/yl7/YllhoPTV9R98bUXT8WRMRiaIoSkQxCEYlExERedjw4cMRFxeHXbt2OUw3cuRIRERE4KuvvvJRzoiIKFRxzBcREYW0hoaGNuOncnNz8cMPP2DChAkOn2symfDzzz87vd4UERGRIxzzRUREIa2oqAgTJ07E3XffjcTERPz8889Yu3Yt4uPjsWDBgnafc/78eWzduhVvvfUW6urqcM899/g410REFIoYfBERUUjr0aMHRo0ahf/7v/9DaWkpIiIiMHXqVPz973/vcHKQY8eOYeHChUhPT8ebb76JsWPH+jjXREQUijjmi4iIiIiIyAc45ouIiIiIiMgHGHwRERERERH5AMd8uUkQBJw7dw5arRYSicTf2SEiIiIiIj8RRRE1NTVITEx0uKg8gy83nTt3Dr169fJ3NoiIiIiIKED8+uuvSE5O7nA/gy83abVaAM1vcGRkpF/zIggCSktLERcX5zDSJmqN5YbcxbJD7mC5IXew3JC7fF12qqur0atXL1uM0BEGX25q6WoYGRkZEMGXxWJBZGQkKyZyGssNuYtlh9zBckPuYLkhd/mr7HQ2HImlmIiIiIiIyAcYfBEREREREfkAgy8iIiIiIiIf4JgvIiIiInKJKIpobGxEU1OTV19HEAQ0NDTAYrFwzBe5xNNlRyaTQS6Xd3mJKQZfREREROQ0q9WK4uJi1NbWev21RFGEIAioqanhuqrkEm+UnfDwcCQkJEChULh9DAZfREREROQUQRBw6tQpyGQyJCYmQqFQeDUoamlh80SLA3Uvniw7oijCarWitLQUp06dQr9+/dxuTWPwRUREREROsVqtEAQBvXr1Qnh4uNdfj8EXucvTZUetViMsLAynT5+G1WqFSqVy6zjsPEtERERELuH4K+qOPFHu+c0hIiIiIiLyAQZfREREREREPsDgi4iIiIjIA3JzcyGRSFBVVQUAyMnJQVRUlF/zRIGFwRcRERERhbzZs2dDIpFgwYIFbfZlZWVBIpFg9uzZHn3N2267Db/88otHj+mMwsJCzJ07F6mpqVCr1UhLS8Ojjz4Kq9VqS2OxWDB79mwMGTIEcrkcN998s0uvUV9fj+HDh0MikeDw4cN2+95//30MHz4c4eHh6NOnD5555pkOj/P1119DLpdj+PDhdtuzs7MxevRoaLVa6PV63HzzzTh+/LhLeQxEDL6IiIiIqFvo1asX3n33XdTV1dm2WSwWbNq0Cb179/b466nVauj1eo8ftzM///wzBEHAP/7xD/z000944YUXsHbtWqxcudKWpqmpCWq1GosXL8bEiRNdfo2//OUvSExMbLN9x44duOuuu7BgwQLk5eXhtddewwsvvIDVq1e3SVtVVYV77rkHmZmZbfbt3bsXWVlZOHDgAHbt2oWGhgZMmjQJZrPZ5bwGEgZfROR3giDiZKkJP/xahZOlJgiC6O8sERGRq8zmjv8sFufTtgqMHKZ1w8iRI9GrVy9s2bLFtm3Lli3o3bs3RowYYZdWEARkZ2fbWo+GDRuGDz/80C7NJ598gksuuQRqtRpXX301CgsL7fZf3O2woKAAv/3tb9GzZ09oNBqMHj0au3fvtntOSkoKnnzyScyZMwdarRa9e/fGunXrXDrPKVOmYP369Zg0aRL69u2Lm266CcuXL7c774iICKxZswbz5s1DfHy8S8ffsWMHPvvsMzz77LNt9r311lu4+eabsWDBAvTt2xdTp07FihUr8NRTT0EU7X/fFyxYgDvvvBNjxoxpc5ydO3di9uzZGDx4MIYNG4acnBycOXMGBw8e7DBfs2fPxs0334wnn3wS8fHxiIuLw1//+lc0Njbi/vvvR3R0NJKTk7F+/Xrbc6xWKxYuXIiEhASoVCr06dMH2dnZLr0frmDwRUR+lVdkxOMfH8Wj237C3z4+hke3/YTHPz6KvCKjv7NGRESu0Gg6/ps+3T6tXt9x2uuus0sq79cPEq22bTo3zZkzx+7i+5///CfuvffeNumys7Px5ptvYu3atfjpp5+wdOlS3H333di7dy8A4Ndff8W0adNw44034vDhw/j973+PBx980OFrm0wmXH/99dizZw++//57TJkyBTfeeCPOnDljl+65557DpZdeiu+//x733Xcf/vjHP9p1uZswYYLLXSSNRiOio6Ndek57zp8/j3nz5uGtt95qd623+vr6NmtgqdVqnD17FqdPn7ZtW79+PU6ePIlHH33Uqdc1GpuvCzo7h88//xznzp3D3r178cwzz+Cxxx7DDTfcgB49euC///0vFixYgPnz5+Ps2bMAgJdffhnbtm3D+++/j+PHj2Pjxo1ISUlxKk/uYPBFRH6TV2TEy3tO4MhZI6LUCqTERiBKrcCRs83bGYAREZGn3X333di3bx9Onz6N06dP4+uvv8bdd99tl6a+vh5PPvkk/vnPf2Ly5Mno27cvZs+ejbvvvhv/+Mc/AABr1qxBWloannvuOfTv3x933XVXpwHRsGHDMH/+fGRkZKBfv354/PHHkZaWhm3bttmlu/7663HfffchPT0dDzzwAGJjY/HFF1/Y9vfu3RsJCQlOn3N+fj5eeeUVzJ8/3+nntEcURcyePRsLFizApZde2m6ayZMnY8uWLdizZw8EQcAvv/yC5557DgBQXFwMADhx4gQefPBBvP3225DL5Z2+riAIWLJkCcaOHYuMjAyHaaOjo/Hyyy+jf//+mD17Nvr374/a2lqsXLkS/fr1w4oVK6BQKLBv3z4AwJkzZ9CvXz9ceeWV6NOnD6688krccccdrrwtLun8bImIvEAQRGw+dBYVZivS9Rrb6vMalRzpSg3yDSZsOVSEQQmRkEq7vjI9ERF5mcnU8T6ZzP6xwdBx2osWsm08cQJyudz2O9FVcXFxmDp1KnJyciCKIqZOnYrY2Fi7NPn5+aitrcW1115rt91qtdq6Jx47dgyXX3653f72us+1ZjKZ8Nhjj+Hjjz9GcXExGhsbUVdX16bla+jQobb/JRIJ4uPjYWj1nr355ptOn29RURGmTJmCGTNmYN68eU4/rz2vvPIKampqsGLFig7TzJs3DwUFBbjhhhvQ0NCAyMhI/OlPf8Jjjz0GqVSKpqYm3HnnnVi1ahUuueQSp143KysLeXl5toDJkcGDB0Mqldq6OPbs2dMuYJPJZIiJibG9n7Nnz8a1116L/v37Y8qUKbjhhhswadIkp/LlDgZfROQXheVm5BtMSNCp2/ygSiQSJOjUOGGoQWG5GX3j3O9eQkREPhIR4b20cjngoeALaO56uHDhQgDAq6++2ma/6X+B5Mcff4ykpCS7fUql0u3XXb58OXbt2oVnn30W6enpUKvVuPXWW+1mIQSAsLAwu8cSiQSCILj8eufOncPVV1+NK664wuVxY+35/PPPsX///jbvwaWXXoq77roLGzZsgEQiwVNPPYUnn3wSJSUliIuLw549ewAAffv2RU1NDb777jt8//33ts9AEASIogi5XI7PPvsM11xzje3YCxcuxPbt2/Hll18iOTm50zy29945ej9HjhyJU6dOYceOHdi9ezdmzpyJiRMnthnf5ykMvojIL2osjahvEKDWydrdr1bIcL5aQI2l0cc5IyKiUDdlyhRYrVZIJBJMnjy5zf5BgwZBqVTizJkzGD9+fLvHGDhwYJvuggcOHHD4ul9//TVmz56NW265BUBzkHfxJB2eUlRUhKuvvhqjRo3C+vXrIZV2fbTRyy+/jCeeeML2+Ny5c5g8eTLee++9Nq2AMpnMFri+8847GDNmDOLi4iAIAo4cOWKX9rXXXsPnn3+ODz/8EKmpqQCauzguWrQIW7duRW5urm27N0RGRuK2227DbbfdhltvvRVTpkxBRUWFR8bIXYzBFxH5hVYlhzJMijprEzSqtlVRnbUJyjAptO3sIyIi6gqZTIZjx47Z/r+YVqvF8uXLsXTpUgiCgCuvvBJGoxFff/01IiMjMWvWLCxYsADPPfcc7r//fvz+97/HwYMHkZOT4/B1+/Xrhy1btuDGG2+ERCLBww8/7FaL1j333IOkpKQOZ+UrKirChAkT0KdPHzz77LMoLS217Ws9s+HRo0dhtVpRUVGBmpoa23pdLWtuffPNN7jnnnuwZ88eJCUltZmOX/O/iU/S0tJsrVJlZWX48MMPMWHCBFgsFqxfvx4ffPCBbaISqVTaZtyWXq+HSqWy256VlYVNmzbho48+glarRUlJCQBAp9NBrVa7+pZ16Pnnn0dCQgJGjBgBqVSKDz74APHx8V5bHJtXNUTkFykxEUjXa3DkrBHpSo1d10NRFFFsrMPQ5CikxLjQNYWIiMhJkZGRDvc//vjjiIuLQ3Z2Nk6ePImoqCiMHDnStlZW7969sXnzZixduhSvvPIKLrvsMtsU8R15/vnnMWfOHFxxxRWIjY3FAw88gOrqapfzfubMGYctWbt27UJ+fj7y8/PbdNVrPd379ddfbzcDYct4tpY0tbW1OH78OBoaGlzK34YNG7B8+XKIoogxY8YgNzcXl112mUvHWLNmDYDmmR1bW79+vUcXw9ZqtXj66adx4sQJyGQyjB49Gp988olHWgrbIxEvnnCfnFJdXQ2dTgej0djpl9fbBEGAwWCAXq/3WkGh0BMI5aZltsMKsxUJOjXUChnqrE0oNtYhOkKBxZn9kJGk80veqGOBUHYo+LDchAaLxYJTp04hNTW1zXTi3iCKIhobGz064QZ1D94oO47Kv7OxAWs/IvKbjCQdFmf2w5BkHarqrCgsM6OqzoqhyVEMvIiIiCjksNshEflVRpIOgxIiUVhuRo2lEVqVHCkxEZxenoiIiEIOgy8i8jupVMLp5ImIiCjksdshERERERGRDzD4IiIiIiIi8gEGX0RERERERD7A4IuIiIiIiMgHGHwRERERERH5AIMvIiIiIiIiH2DwRURERERE5AMMvoiIiIgo5M2ePRsSiQQLFixosy8rKwsSiQSzZ8/2fcY60dDQgAceeABDhgxBREQEEhMTcc899+DcuXN26f72t7/hiiuuQHh4OKKiopw6dst70vpvypQpdmkqKipw1113ITIyElFRUZg7dy5MJpNdmvfffx/Dhw9HeHg4+vTpg2eeeabNa9XX1+Ohhx5Cnz59oFQqkZKSgn/+85+uvRkhgMEXEREREXULvXr1wrvvvou6ujrbNovFgk2bNqF3795+zFnHamtrcejQITz88MM4dOgQtmzZguPHj+Omm26yS2e1WjFjxgz88Y9/dOn4U6ZMQXFxse3vnXfesdt/11134aeffsKuXbuwfft2fPnll/jDH/5g279jxw7cddddWLBgAfLy8vDaa6/hhRdewOrVq+2OM3PmTOzZswdvvPEGjh8/jnfeeQf9+/d38d0Ifgy+iIiIiKjLzFYzzFYzRFG0bbM2WWG2mlHfWN9uWkEUbNsamhpgtpphabQ4ldYdI0eORK9evbBlyxbbti1btqB3794YMWKEXVpBEJCdnY3U1FSo1WoMGzYMH374oW1/U1MT5s6da9vfv39/vPTSS3bHmD17Nm6++WY8++yzSEhIQExMDLKystDQ4Hz+dToddu3ahZkzZ6J///74zW9+g9WrV+PgwYM4c+aMLd2qVauwdOlSDBkyxKX3RKlUIj4+3vbXo0cP275jx45h586d+L//+z9cfvnluPLKK/HKK6/g3XfftbW8vfXWW7j55puxYMEC9O3bF1OnTsWKFSvw1FNP2crCzp07sXfvXnzyySeYOHEiUlJSMGbMGIwdO7bDfOXm5kIikeDTTz/FiBEjoFarcc0118BgMGDHjh0YOHAgIiMjceedd6K2ttb2vA8//BBDhgxBeHg44uPjce2118JsNrv0nngTgy8iIiIi6jJNtgaabA3Kasts2575+hlosjVY+MlCu7T6Z/XQZGtwxngheHj121ehydZg7ra5dmn7vdoP2r9rcaz0mG1bzuEct/M5Z84crF+/3vb4n//8J+6999426bKzs/Hmm29i7dq1+Omnn7B06VLcfffd2Lt3L4Dm4Cw5ORkffPABjh49ikceeQQrV67E+++/b3ecL774AgUFBfjiiy+wYcMG5OTkICfnQv4fe+wxpKSkuHQORqMREonE6e6FjuTm5kKv16N///744x//iPLyctu+/fv3IyoqCpdeeqlt28SJEyGVSvHf//4XQHN3QpVKZXdMtVqNs2fP4vTp0wCAbdu24dJLL8XTTz+NpKQkXHLJJVi+fLldC2RHHnvsMaxevRr/+c9/8Ouvv2LmzJl48cUXsWnTJnz88cf47LPP8MorrwAAiouLcccdd2DOnDk4evQodu3ahVtuucXuhoC/yf2dASIiIiIiX7n77ruxYsUKW2Dw9ddf491330Vubq4tTX19PZ588kns3r0bY8aMAQD07dsX+/btwz/+8Q+MHz8eYWFhWLVqle05qamp2L9/P95//33MnDnTtr1Hjx5YvXo1ZDIZBgwYgKlTp2LPnj2YN28eACA2NhZpaWlO599iseCBBx7AHXfcgcjIyK68FZgyZQqmTZuG1NRUFBQUYOXKlbjuuuuwf/9+yGQylJSUQK/X2z1HLpcjOjoaJSUlAIDJkydj6dKlmD17Nq6++mrk5+fjueeeA9AcDKWkpODkyZPYt28fVCoVtm7dirKyMtx3330oLy+3C4Tb88QTT9hayObOnYsVK1agoKAAffv2BQDceuut+OKLL/DAAw+guLgYjY2NmDZtGnr37o3k5GSMGDECEomkS++TJzH4IiIiIqIuM61onoQhPCzctu3+sfdjyW+WQC61v+Q0LDcAANRhatu2rNFZmDdyHmRSmV3aE1knIJfLEa64cNzZw2e7nc+4uDhMnToVOTk5EEURU6dORWxsrF2a/Px81NbW4tprr7XbbrVa7bonvvrqq/jnP/+JM2fOoK6uDlarFcOHD7d7zuDBgyGTXTinhIQEHDlyxPZ44cKFWLjQvmWwIw0NDZg5cyZEUcSaNWucPeUO3X777bb/hwwZgqFDhyItLQ25ubnIzMx06hjz5s1DQUEBbrjhBjQ0NCAyMhJ/+tOf8Nhjj0Eqbe5kJwgCJBIJNm7cCJ1OBwB4/vnnceutt+K1116DWq3u8PhDhw61/d+zZ0+Eh4fbAq+Wbd988w0AYNiwYcjMzMSQIUMwefJkZGZmYubMmYiOjnb+TfEydjskIiIioi6LUEQgQhFh18qgkCkQoYiAUq5sN61UcuFSNEwWhghFBFRylVNpu2LOnDnIycnBhg0bMGfOnDb7W2bz+/jjj3H48GHb39GjR23jvt59910sX74cc+fOxWeffYbDhw/j3nvvhdVqtTtWWJh9XiUSCQRBgKtaAq/Tp09j165dXW71ak/fvn0RGxuL/Px8AEB8fDwMBoNdmsbGRlRUVCA+Ph5A8/k89dRTMJlMOH36NEpKSnDZZZfZjgc0B5xJSUm2wAsABg4cCFEUcfbsWYd5av3+SSQSh++nTCbDrl27bGPCXn31VQwYMACnTp1y5+3wCgZfRERERNStTJkyBVarFQ0NDZg8eXKb/YMGDYJSqcSZM2eQnp5u99erVy8Azd0Vr7jiCtx3330YMWIE0tPTUVBQ4JX8tgReJ06cwO7duxETE+OV1zl79izKy8uRkJAAABgzZgyqqqpw8OBBW5rPP/8cgiDg8ssvt3uuTCZDUlISFAoF3nnnHYwZMwZxcXEAgLFjx+LcuXN2U9T/8ssvkEqlSE5O9ug5SCQSjB07FqtWrcK3334LhUKBrVu3evQ1uoLBFxERERF1KzKZDMeOHcPRo0ftugS20Gq1WL58OZYuXYoNGzagoKAAhw4dwiuvvIINGzYAAPr164fvvvsOn376KX755Rc8/PDD+Pbbb13Oy+rVqx128WtoaMCtt96K7777Dhs3bkRTUxNKSkpQUlJi18p25swZHD58GGfOnEFTU5Otta51wDNgwABbIGIymXD//ffjwIEDKCwsxJ49e/Db3/4W6enptoB04MCBmDJlCubNm4dvvvkGX3/9NRYuXIjbb78diYmJAICysjKsXbsWP//8Mw4fPow//elP+OCDD/Diiy/aXvfOO+9ETEwM7r33Xhw9ehRffvkl7r//fsyZM8dhl0NX/fe//8WTTz6J7777DmfOnMHWrVtRWlqKgQMHeuw1uopjvoiIiIio2+ms297jjz+OuLg4ZGdn4+TJk4iKisLIkSOxcuVKAMD8+fPx/fff47bbboNEIsEdd9yB++67Dzt27HApH2VlZQ5bzIqKirBt2zYAaDOe7IsvvsCECRMAAI888ogtMARgG5vWOs3x48dhNBoBNAegP/74IzZs2ICqqiokJiZi0qRJePzxx6FUXugmunHjRixcuBCZmZmQSqWYPn06Xn75Zbt8bNiwAcuXL4coihgzZgxyc3NtXQ8BQKPRYNeuXVi0aBEuvfRSxMTEYObMmXjiiSdceq86ExkZiS+//BIvvvgiqqur0bt3bzz77LO47rrrPPo6XSERA2nuxSBSXV0NnU4Ho9HolT63rhAEAQaDAXq93jawkagzLDfkLpYdcgfLTWiwWCw4deoUUlNT20wv7g2iKKKxsRFyuTygZqyjwOeNsuOo/DsbG7D2IyIiIiIi8gEGX0RERERERD7A4IuIiIiIiMgHGHwRERERERH5AIMvIiIiInIJ52uj7sgT5Z7BFxERERE5JSwsDABQW1vr55wQ+V5LuW/5HriD63wRERERkVNkMhmioqJgMBgAAOHh4V6dAp5TzZO7PFl2RFFEbW0tDAYDoqKi2l2Y21kMvoiIiIjIafHx8QBgC8C8SRRFCIIAqVTK4Itc4o2yExUVZSv/7mLwRUREREROk0gkSEhIgF6vR0NDg1dfSxAElJeXIyYmhotzk0s8XXbCwsK61OLVwq/BV3Z2NrZs2YKff/4ZarUaV1xxBZ566in079/flmbdunXYtGkTDh06hJqaGlRWViIqKsrhcVNSUnD69Ok22++77z68+uqrAIAJEyZg7969dvvnz5+PtWvXdv3EiIiIiEKcTCbzyMWoI4IgICwsDCqVisEXuSRQy45fc7J3715kZWXhwIED2LVrFxoaGjBp0iSYzWZbmtraWkyZMgUrV650+rjffvstiouLbX+7du0CAMyYMcMu3bx58+zSPf300545MSIiIiIioov4teVr586ddo9zcnKg1+tx8OBBjBs3DgCwZMkSAEBubq7Tx42Li7N7/Pe//x1paWkYP3683fbw8PAu99skIiIiIiJyRkCN+TIajQCA6Ohojx3TarXi7bffxrJly9oMttu4cSPefvttxMfH48Ybb8TDDz+M8PDwdo9TX1+P+vp62+Pq6moAzU2agiB4LL/uEATBNqiQyFksN+Qulh1yB8sNuYPlhtzl67Lj7OsETPAlCAKWLFmCsWPHIiMjw2PH/de//oWqqirMnj3bbvudd96JPn36IDExET/++CMeeOABHD9+HFu2bGn3ONnZ2Vi1alWb7aWlpbBYLB7LrzsEQYDRaIQoigHVp5UCG8sNuYtlh9zBckPuYLkhd/m67NTU1DiVLmCCr6ysLOTl5WHfvn0ePe4bb7yB6667DomJiXbb//CHP9j+HzJkCBISEpCZmYmCggKkpaW1Oc6KFSuwbNky2+Pq6mr06tULcXFxiIyM9GieXSUIAiQSCeLi4lgxkdNYbshdLDvkDpYbcgfLDbnL12VHpVI5lS4ggq+FCxdi+/bt+PLLL5GcnOyx454+fRq7d+/usDWrtcsvvxwAkJ+f327wpVQqoVQq22yXSqUBURlIJJKAyQsFD5YbchfLDrmD5YbcwXJD7vJl2XH2NfwafImiiEWLFmHr1q3Izc1FamqqR4+/fv166PV6TJ06tdO0hw8fBgAkJCR4NA9ERERERESAn4OvrKwsbNq0CR999BG0Wi1KSkoAADqdDmq1GgBQUlKCkpIS5OfnAwCOHDkCrVaL3r172ybmyMzMxC233IKFCxfaji0IAtavX49Zs2ZBLrc/zYKCAmzatAnXX389YmJi8OOPP2Lp0qUYN24chg4d6otTJyIiIiKibsav7bdr1qyB0WjEhAkTkJCQYPt77733bGnWrl2LESNGYN68eQCAcePGYcSIEdi2bZstTUFBAcrKyuyOvXv3bpw5cwZz5sxp87oKhQK7d+/GpEmTMGDAAPz5z3/G9OnT8e9//9tLZ0pERERERN2dRBRF0d+ZCEbV1dXQ6XQwGo0BMeGGwWCAXq9nf2hyGssNuYtlh9zBckPuYLkhd/m67DgbG7AUExERERER+QCDLyIiIiIiIh9g8EVEREREROQDDL6IiIiIiIh8gMEXERERERGRDzD4IiIiIiIi8gEGX0RERERERD7A4IuIiIiIiMgHGHwRERERERH5AIMvIiIiIiIiH2DwRURERERE5AMMvoiIiIiIiHyAwRcREREREZEPMPgiIiIiIiLyAQZfREREREREPsDgi4iIiIiIyAcYfBEREREREfkAgy8iIiIiIiIfYPBFRERERETkAwy+iIiIiIiIfIDBFxERERERkQ8w+CIiIiIiIvIBBl9EREREREQ+wOCLiIiIiIjIBxh8ERERERER+QCDLyIiIiIiIh9g8EVEREREROQDDL6IiIiIiIh8gMEXERERERGRDzD4IiIiIiIi8gEGX0RERERERD7A4IuIiIiIiMgHGHwRERERERH5AIMvIiIiIiIiH2DwRURERERE5AMMvoiIiIiIiHyAwRcREREREZEPMPgiIiIiIiLyAQZfREREREREPsDgi4iIiIiIyAcYfBEREREREfkAgy8iIiIiIiIfYPBFRERERETkAwy+iIiIiIiIfIDBFxERERERkQ8w+CIiIiIiIvIBBl9EREREREQ+wOCLiIiIiIjIBxh8ERERERER+QCDLyIiIiIiIh9g8EVEREREROQDfg2+srOzMXr0aGi1Wuj1etx88804fvy4XZp169ZhwoQJiIyMhEQiQVVVVafHTUlJgUQiafOXlZVlS2OxWJCVlYWYmBhoNBpMnz4d58+f9/QpEhERERERAfBz8LV3715kZWXhwIED2LVrFxoaGjBp0iSYzWZbmtraWkyZMgUrV650+rjffvstiouLbX+7du0CAMyYMcOWZunSpfj3v/+NDz74AHv37sW5c+cwbdo0z50cERERERFRK3J/vvjOnTvtHufk5ECv1+PgwYMYN24cAGDJkiUAgNzcXKePGxcXZ/f473//O9LS0jB+/HgAgNFoxBtvvIFNmzbhmmuuAQCsX78eAwcOxIEDB/Cb3/zGzTMiIiIiIiJqn1+Dr4sZjUYAQHR0tMeOabVa8fbbb2PZsmWQSCQAgIMHD6KhoQETJ060pRswYAB69+6N/fv3txt81dfXo76+3va4uroaACAIAgRB8Fh+3SEIAkRR9Hs+KLiw3JC7WHbIHSw35A6WG3KXr8uOs68TMMGXIAhYsmQJxo4di4yMDI8d91//+heqqqowe/Zs27aSkhIoFApERUXZpe3ZsydKSkraPU52djZWrVrVZntpaSksFovH8usOQRBgNBohiiKkUs6hQs5huSF3seyQO1huyB0sN+QuX5edmpoap9IFTPCVlZWFvLw87Nu3z6PHfeONN3DdddchMTGxS8dZsWIFli1bZntcXV2NXr16IS4uDpGRkV3NZpcIggCJRIK4uDhWTOQ0lhtyF8sOuYPlhtzBckPu8nXZUalUTqULiOBr4cKF2L59O7788kskJyd77LinT5/G7t27sWXLFrvt8fHxsFqtqKqqsmv9On/+POLj49s9llKphFKpbLNdKpUGRGUgkUgCJi8UPFhuyF0sO+QOlhtyB8sNucuXZcfZ1/BrKRZFEQsXLsTWrVvx+eefIzU11aPHX79+PfR6PaZOnWq3fdSoUQgLC8OePXts244fP44zZ85gzJgxHs0DERERERER4OeWr6ysLGzatAkfffQRtFqtbbyVTqeDWq0G0Dw+q6SkBPn5+QCAI0eOQKvVonfv3raJOTIzM3HLLbdg4cKFtmMLgoD169dj1qxZkMvtT1On02Hu3LlYtmwZoqOjERkZiUWLFmHMmDGc6ZCIiIiIiLzCry1fa9asgdFoxIQJE5CQkGD7e++992xp1q5dixEjRmDevHkAgHHjxmHEiBHYtm2bLU1BQQHKysrsjr17926cOXMGc+bMafe1X3jhBdxwww2YPn06xo0bh/j4+DbdE4mIiIiIiDxFIoqi6O9MBKPq6mrodDoYjcaAmHDDYDBAr9ezPzQ5jeWG3MWyQ+5guSF3sNyQu3xddpyNDViKiYiIiIiIfCAgZjskIiIizxIEEYXlZtRYGqFVyZESEwGpVOLvbBERdWsMvoiIiEJMXpERmw+dRb7BhPoGAcowKdL1GkwfmYyMJJ2/s0dE1G0x+CIiIgoheUVGvLznBCrMViTo1FDrZKizNuHIWSOKKuuwOLMfAzAiIj/hmC8iIqIQIQgiNh86iwqzFel6DTQqOWRSCTQqOdL1GlSYrdhyqAiCwLm2iIj8gcEXERFRiCgsNyPfYEKCTg2JxH58l0QiQYJOjROGGhSWm/2UQyKi7o3BFxERUYiosTSivkGAWiFrd79aIUN9g4AaS6OPc0ZERACDLyIiopChVcmhDJOiztrU7v46axOUYVJoVRzyTUTkDwy+iIiIQkRKTATS9RoUG+sgivbjukRRRLGxDv30WqTERPgph0RE3RuDLyIiohAhlUowfWQyoiMUyDeYYLI0okkQYbI0It9gQnSEAtNGJnG9LyIiP2HwRUREFEIyknRYnNkPQ5J1qKqzorDMjKo6K4YmR3GaeSIiP2OnbyIiohCTkaTDoIRIFJabUWNphFYlR0pMBFu8iIj8jMEXERFRCJJKJegbp/F3NoiIqBV2OyQiIiIiIvIBBl9EREREREQ+wOCLiIiIiIjIBxh8ERERERER+QCDLyIiIiIiIh9g8EVEREREROQDDL6IiIiIiIh8gMEXERERERGRDzD4IiIiIiIi8gG5vzNARERE7RMEEYXlZtRYGqFVyZESEwGpVOLvbBERkZsYfBEREQWgvCIjNh86i3yDCfUNApRhUqTrNZg+MhkZSTp/Z4+IiNzA4IuIiCjA5BUZ8fKeE6gwW5GgU0Otk6HO2oQjZ40oqqzD4sx+DMCIiIIQx3wREREFEEEQsfnQWVSYrUjXa6BRySGTSqBRyZGu16DCbMWWQ0UQBNHfWSUiIhcx+CIiIgogheVm5BtMSNCpIZHYj++SSCRI0KlxwlCDwnKzn3JIRETuYvBFREQUQGosjahvEKBWyNrdr1bIUN8goMbS6OOcERFRVzH4IiIiCiBalRzKMCnqrE3t7q+zNkEZJoVWxWHbRETBhsEXERFRAEmJiUC6XoNiYx1E0X5clyiKKDbWoZ9ei5SYCD/lkIiI3MXgi4iIKIBIpRJMH5mM6AgF8g0mmCyNaBJEmCyNyDeYEB2hwLSRSVzvi4goCDH4IiIiCjAZSToszuyHIck6VNVZUVhmRlWdFUOTozjNPBFREGOHcSIiogCUkaTDoIRIFJabUWNphFYlR0pMBFu8iIiCGIMvIiKiACWVStA3TuPvbBARkYew2yEREREREZEPMPgiIiIiIiLyAQZfREREREREPsDgi4iIiIiIyAcYfBEREREREfkAgy8iIiIiIiIfYPBFRERERETkAwy+iIiIiIiIfIDBFxERERERkQ8w+CIiIiIiIvIBub8zQERERK4TBBGF5WbUWBqhVcmREhMBqVTi72wREZEDDL6IiIiCTF6REZsPnUW+wYT6BgHKMCnS9RpMH5mMjCSdv7NHREQdYPBFREQURPKKjHh5zwlUmK1I0Kmh1slQZ23CkbNGFFXWYXFmPwZgREQBimO+iIiIgoQgiNh86CwqzFak6zXQqOSQSSXQqORI12tQYbZiy6EiCILo76wSEVE7GHwREREFicJyM/INJiTo1JBI7Md3SSQSJOjUOGGoQWG52U85JCIiRxh8ERERBYkaSyPqGwSoFbJ296sVMtQ3CKixNPo4Z0RE5AwGX0REREFCq5JDGSZFnbWp3f111iYow6TQqjikm4goEPk1+MrOzsbo0aOh1Wqh1+tx88034/jx43Zp1q1bhwkTJiAyMhISiQRVVVVOHbuoqAh33303YmJioFarMWTIEHz33Xe2/bNnz4ZEIrH7mzJliidPj4iIyKNSYiKQrteg2FgHUbQf1yWKIoqNdein1yIlJsJPOSQiIkf8Gnzt3bsXWVlZOHDgAHbt2oWGhgZMmjQJZvOFvuq1tbWYMmUKVq5c6fRxKysrMXbsWISFhWHHjh04evQonnvuOfTo0cMu3ZQpU1BcXGz7e+eddzx2bkRERJ4mlUowfWQyoiMUyDeYYLI0okkQYbI0It9gQnSEAtNGJnG9LyKiAOXXfgk7d+60e5yTkwO9Xo+DBw9i3LhxAIAlS5YAAHJzc50+7lNPPYVevXph/fr1tm2pqalt0imVSsTHx7uecSIiIj/JSNJhcWY/2zpf56ub1/kamhyFaSOTOM08EVEAC6hO4UajEQAQHR3dpeNs27YNkydPxowZM7B3714kJSXhvvvuw7x58+zS5ebmQq/Xo0ePHrjmmmvwxBNPICYmpt1j1tfXo76+3va4uroaACAIAgRB6FJ+u0oQBIii6Pd8UHBhuSF3sez436AELQZcNwCnK8yosTRBq5KhT3QEpFJJwH4uLDfkDpYbcpevy46zrxMwwZcgCFiyZAnGjh2LjIyMLh3r5MmTWLNmDZYtW4aVK1fi22+/xeLFi6FQKDBr1iwAzV0Op02bhtTUVBQUFGDlypW47rrrsH//fshkbWeRys7OxqpVq9psLy0thcVi6VJ+u0oQBBiNRoiiCKmUc6iQc1huyF0sO4EjAkCEAoAAlJXV+js7DrHckDtYbshdvi47NTU1TqWTiBeP2PWTP/7xj9ixYwf27duH5OTkNvtzc3Nx9dVXo7KyElFRUQ6PpVAocOmll+I///mPbdvixYvx7bffYv/+/e0+5+TJk0hLS8Pu3buRmZnZZn97LV+9evVCZWUlIiMjnTxL7xAEAaWlpYiLi2PFRE5juSF3seyQO1huyB0sN+QuX5ed6upq9OjRA0aj0WFsEBAtXwsXLsT27dvx5Zdftht4uSohIQGDBg2y2zZw4EBs3ry5w+f07dsXsbGxyM/Pbzf4UiqVUCqVbbZLpdKAqAwkEknA5IWCB8sNuYtlh9zBckPuYLkhd/my7Dj7Gn4NvkRRxKJFi7B161bk5ua2OymGO8aOHdtmyvpffvkFffr06fA5Z8+eRXl5ORISEjySByIiIiIiotb8egshKysLb7/9NjZt2gStVouSkhKUlJSgrq7OlqakpASHDx9Gfn4+AODIkSM4fPgwKioqbGkyMzOxevVq2+OlS5fiwIEDePLJJ5Gfn49NmzZh3bp1yMrKAgCYTCbcf//9OHDgAAoLC7Fnzx789re/RXp6OiZPnuyjsyciIiIiou7Er8HXmjVrYDQaMWHCBCQkJNj+3nvvPVuatWvXYsSIEbaZCseNG4cRI0Zg27ZttjQFBQUoKyuzPR49ejS2bt2Kd955BxkZGXj88cfx4osv4q677gIAyGQy/Pjjj7jppptwySWXYO7cuRg1ahS++uqrdrsWEhERERERdVXATLgRbKqrq6HT6TodVOcLgiDAYDBAr9ezPzQ5jeWG3MWyQ+5guSF3sNyQu3xddpyNDViKiYiIiIiIfIDBFxERERERkQ8w+CIiIiIiIvIBBl9EREREREQ+wOCLiIiIiIjIBxh8ERERERER+YDc3xkgIiKi7ksQRBSWm1FjaYRWJUdKTASkUom/s0VE5BUMvoiIiMgv8oqM2HzoLPINJtQ3CFCGSZGu12D6yGRkJOn8nT0iIo9zKfgSBAF79+7FV199hdOnT6O2thZxcXEYMWIEJk6ciF69enkrn0RERBRC8oqMeHnPCVSYrUjQqaHWyVBnbcKRs0YUVdZhcWY/BmBEFHKcGvNVV1eHJ554Ar169cL111+PHTt2oKqqCjKZDPn5+Xj00UeRmpqK66+/HgcOHPB2nomIukwQRJwsNeGHX6twstQEQRD9nSWibkMQRGw+dBYVZivS9RpoVHLIpBJoVHKk6zWoMFux5VARv5dEFHKcavm65JJLMGbMGLz++uu49tprERYW1ibN6dOnsWnTJtx+++146KGHMG/ePI9nlojIE9jVici/CsvNyDeYkKBTQyKxH98lkUiQoFPjhKEGheVm9I3T+CmXRESe51Tw9dlnn2HgwIEO0/Tp0wcrVqzA8uXLcebMGY9kjojI09jVicj/aiyNqG8QoNbJ2t2vVshwvlpAjaXRxzkjIvIup7oddhZ4tRYWFoa0tDS3M0RE5C3s6kQUGLQqOZRhUtRZm9rdX2dtgjJMCq2K84IRUWhxeZ2vnTt3Yt++fbbHr776KoYPH44777wTlZWVHs0cEZEnudLViYi8JyUmAul6DYqNdRBF+5sdoiii2FiHfnotUmIi/JRDIiLvcDn4uv/++1FdXQ0AOHLkCP785z/j+uuvx6lTp7Bs2TKPZ5CIyFNsXZ0UHXd1qm9gVycib5NKJZg+MhnREQrkG0wwWRrRJIgwWRqRbzAhOkKBaSOTuN4XEYUcl9vzT506hUGDBgEANm/ejBtuuAFPPvkkDh06hOuvv97jGSQi8pTWXZ007XRnYlcnIt/JSNJhcWY/2+Q356ubJ78ZmhyFaSOTOPaSiEKSy1cYCoUCtbW1AIDdu3fjnnvuAQBER0fbWsSIiAJRS1enI2eNSFdq7LoetnR1Gpocxa5ORD6SkaTDoIRIFJabUWNphFYlR0pMBFu8iChkuRx8XXnllVi2bBnGjh2Lb775Bu+99x4A4JdffkFycrLHM0hE5CktXZ2KKutsY7/UiubZDouNdezqROQHUqmE08kTUbfh8piv1atXQy6X48MPP8SaNWuQlJQEANixYwemTJni8QwSEXlSS1enIck6VNVZUVhmRlWdFUOTozjNPBEREXmVyy1fvXv3xvbt29tsf+GFFzySISIib2NXJyIiIvIHt0eVGwwGGAwGCIJgt33o0KFdzhQRkbexqxMRERH5msvB18GDBzFr1iwcO3bMtjaHRCKBKIqQSCRoamp/wUQiIiIiIqLuzOXga86cObjkkkvwxhtvoGfPnm0WKiUiIiIiIqK2XA6+Tp48ic2bNyM9Pd0b+SEiIiIiIgpJLs92mJmZiR9++MEbeSEiIiIiIgpZLrd8/d///R9mzZqFvLw8ZGRkICwszG7/TTfd5LHMERERERERhQqXg6/9+/fj66+/xo4dO9rs44QbREREbQmCyKUNiIjI9eBr0aJFuPvuu/Hwww+jZ8+e3sgTERFRyMgrMmLzobPIN5hQ3yBAGSZFul6D6SOTuah3FzCgJaJg5HLwVV5ejqVLlzLwIiIi6kRekREv7zmBCrMVCTo11DoZ6qxNOHLWiKLKOizO7McAzA0MaIkoWLk84ca0adPwxRdfeCMvREREIUMQRGw+dBYVZivS9RpoVHLIpBJoVHKk6zWoMFux5VARBEH0d1aDSktAe+SsEVFqBVJiIxClVuDI2ebteUVGf2eRiKhDLrd8XXLJJVixYgX27duHIUOGtJlwY/HixR7LHBERUbAqLDcj32BCgk7dZk1MiUSCBJ0aJww1KCw3o2+cxk+5DGwXdy3s3SPcLqBteV81KjnSlRrkG0zYcqgIgxIi2QWRiAKSW7MdajQa7N27F3v37rXbJ5FIGHwREREBqLE0or5BgFona3e/WiHD+WoBNZZGH+csOLTXtTBOq8SpUjOSe4QzoCWioORy8HXq1Clv5IOIiCikaFVyKMOkqLM2QaNq+3NbZ22CMkwKbTv7uruOxsodO1eN4moL4jTKdt9TBrREFOhcHvNFREREnUuJiUC6XoNiYx1E0X5clyiKKDbWoZ9ei5SYCD/l0HWCIOJkqQk//FqFk6Umr4xXczRWLjUuAoIg4oTBBIhtX5sBLREFOqdqp7///e/405/+BLVa3Wna//73vygrK8PUqVO7nDkiIqJgJZVKMH1kMooq62xjv9SK5hacYmMdoiMUmDYyKeDGJnU0hbuvZhh0NFYuUhWGmAgFysz1qLY0IFKtsO1rCWiHJkcFVUBLRN2LU8HX0aNH0bt3b8yYMQM33ngjLr30UsTFxQEAGhsbcfToUezbtw9vv/02zp07hzfffNOrmSYiIgoGGUk6LM7sZwtazlc3By1Dk6MwbWRSwE2L3lGANbxXFD7+sdgnU+Y7GisnkUiQ3lOLylMVOFlqRrpeGhQBLRFRC6eCrzfffBM//PADVq9ejTvvvBPV1dWQyWRQKpWora0FAIwYMQK///3vMXv2bKhUKq9mmoiIKFhkJOkwKCEy4BcE7mic1Y+/VmHPsfPQKOUYmhzl9RkGOxsrp5LLkBobgb6xETCY6gM+oCUias3pTtHDhg3D66+/jn/84x/48ccfcfr0adTV1SE2NhbDhw9HbGysN/NJREQUtKRSSUDPvnfxOKvWAVZPnQonDCbIJFJcHFp5Y4bBlrFyR84aka7U2HU9bOlaOKJ3D6y8bgDOVNYGdEBLRHQxl0ekSqVSDB8+HMOHD/dCdoiIiMjXHI2zamwSIZdKUWttRE19I7Qq+/U9PT3DoLNj5eRyaUAHtERE7eFsh0RERN2cbZyVou04qzCZFGFyCRqaRDQ0Cm32e2OGwZaxckOSdaiqs6KwzIyqOiuGJkd5dHwZEZGvcS5WIiKibs7ROCutSo7wMBnKrFbIZfatYs7OMCgIIk6VmWAoNcEsDUdqrLbTLoLBMlaOiMgVDL6IiIi6OUfjrIDmroU9RAXOV9dDKnFthsGWGRQLDDWIkVpQLpQhTa91aor6QB8rR0TkKgZfRERE3Vxn46ySe4Rj6tAEHP61yqUp81vPoJioU0GvBJrqFV6Zov5iHa1XRkTkT24HX/n5+SgoKMC4ceOgVqshimKbO2VEREQUHJxZk+zGoYlOBzRtZ1AEpLAiwktT1LfmqwWhiYhc5XLwVV5ejttuuw2ff/45JBIJTpw4gb59+2Lu3Lno0aMHnnvuOW/kk4iIiLyss3FWrnQDbDuDomjb540p6lt0tF6ZL1rbiIg64/Jsh0uXLoVcLseZM2cQHh5u237bbbdh586dHs0cERER+VZLgDWsVxT6xmncbpVyNIMi0DyOrL7Bc1PUA21b2zQqOWRSSfOC0HoNKsxWbDlUBEEQOz8YEZEXuNzy9dlnn+HTTz9FcnKy3fZ+/frh9OnTHssYERERBS9HMygC3pmi3tF6Zd5sbSMicpbLLV9ms9muxatFRUUFlEqlRzJFREREwa1lBsViYx1E0b6lqWWK+n56rcMp6l3lj9Y2IiJXuBx8XXXVVXjzzTdtjyUSCQRBwNNPP42rr77ao5kjIiKi4NQyg2J0hAL5BhPMlkYIImC2NCLfYOp0inp3tG5ta483WtuIiFzhcu3z9NNPIzMzE9999x2sViv+8pe/4KeffkJFRQW+/vprb+SRiIiIglDrGRQLDDWQ1VtQJaDTKerd5Wi9MmcXhCYi8iaXg6+MjAz88ssvWL16NbRaLUwmE6ZNm4asrCwkJCR4I49EREQUpFpmUDxVVgPDeQP0PfVIjdV6Zc2tztYr80ZrGxGRK1zudggAOp0ODz30EN5//3188skneOKJJ9wKvLKzszF69GhotVro9XrcfPPNOH78uF2adevWYcKECYiMjIREIkFVVZVTxy4qKsLdd9+NmJgYqNVqDBkyBN99951tvyiKeOSRR5CQkAC1Wo2JEyfixIkTLp8DEREROSaVSpAaq0FqnAapse7PoOiMlta2Ick6VNVZUVhmRlWdFUOTozjNPBH5nVudni0WC3788UcYDAYIgmC376abbnL6OHv37kVWVhZGjx6NxsZGrFy5EpMmTcLRo0cREdHcJaC2thZTpkzBlClTsGLFCqeOW1lZibFjx+Lqq6/Gjh07EBcXhxMnTqBHjx62NE8//TRefvllbNiwAampqXj44YcxefJkHD16FCqVyulzICIiosDS2XplRET+4nLwtXPnTtxzzz0oKytrs08ikaCpqf1Brh0dq7WcnBzo9XocPHgQ48aNAwAsWbIEAJCbm+v0cZ966in06tUL69evt21LTU21/S+KIl588UX8v//3//Db3/4WAPDmm2+iZ8+e+Ne//oXbb7/d6dciIiKiwOPKgtBERL7icvC1aNEizJgxA4888gh69uzp0cwYjUYAQHR0dJeOs23bNkyePBkzZszA3r17kZSUhPvuuw/z5s0DAJw6dQolJSWYOHGi7Tk6nQ6XX3459u/f327wVV9fj/r6etvj6upqAIAgCG1a/3xNEASIouj3fFBwYbkhd7HskDtYbsgdLDfkLl+XHWdfx+Xg6/z581i2bJnHAy9BELBkyRKMHTsWGRkZXTrWyZMnsWbNGixbtgwrV67Et99+i8WLF0OhUGDWrFkoKSkBgDbn0LNnT9u+i2VnZ2PVqlVttpeWlsJisXQpv10lCAKMRiNEUYRU6tYwPuqGWG7IXSw75A6WG3IHyw25y9dlp6amxql0Lgdft956K3Jzc5GWluZyphzJyspCXl4e9u3b1+VjCYKASy+9FE8++SQAYMSIEcjLy8PatWsxa9Yst465YsUKLFu2zPa4uroavXr1QlxcHCIjI7uc564QBAESiQRxcXGsmMhpLDfkLpYdcgfLDbmD5Ybc5euy4+ycES4HX6tXr8aMGTPw1VdfYciQIQgLC7Pbv3jxYlcPiYULF2L79u348ssvkZyc7PLzL5aQkIBBgwbZbRs4cCA2b94MAIiPjwfQ3IrXepbG8+fPY/jw4e0eU6lUQqlUttkulUoDojKQSCQBkxcKHiw35C6WHXIHyw25g+WG3OXLsuPsa7gcfL3zzjv47LPPoFKpkJuba7eAoUQicSn4EkURixYtwtatW5Gbm2s3KUZXjB07ts2U9b/88gv69OkDoHnyjfj4eOzZs8cWbFVXV+O///0v/vjHP3okD0RERERERK25HHw99NBDWLVqFR588MEuR5FZWVnYtGkTPvroI2i1Wtt4K51OB7VaDQAoKSlBSUkJ8vPzAQBHjhyBVqtF7969bRNzZGZm4pZbbsHChQsBAEuXLsUVV1yBJ598EjNnzsQ333yDdevWYd26dQCag8QlS5bgiSeeQL9+/WxTzScmJuLmm2/u0jkRERERERG1x+Xgy2q14rbbbvNI892aNWsAABMmTLDbvn79esyePRsAsHbtWruJLlqmoG+dpqCgwG7q+9GjR2Pr1q1YsWIF/vrXvyI1NRUvvvgi7rrrLluav/zlLzCbzfjDH/6AqqoqXHnlldi5cyfX+CIiIiIiIq+QiKIouvKEpUuXIi4uDitXrvRWnoJCdXU1dDodjEZjQEy4YTAYoNfr2R+anMZyQ+5i2SF3sNyQO1huyF2+LjvOxgYut3w1NTXh6aefxqeffoqhQ4e2mXDj+eefdz23REREREREIc7l4OvIkSMYMWIEACAvL89uX+vJN4iIiIiIiOgCl4OvL774whv5ICIi6pYEQURhuRk1lkZoVXKkxERAKuXNTCKiUORy8EVERESekVdkxOZDZ5FvMKG+QYAyTIp0vQbTRyYjI0nn7+wREZGHORV8TZs2DTk5OYiMjMS0adMcpt2yZYtHMkZERBTK8oqMeHnPCVSYrUjQqaHWyVBnbcKRs0YUVdZhcWY/BmBERCHGqeBLp9PZxnPpdPwhICIi6gpBELH50FlUmK1I12tsv7EalRzpSg3yDSZsOVSEQQmR7IJIRBRCnAq+1q9fj7/+9a9Yvnw51q9f7+08ERERhbTCcjPyDSYk6NRtJquSSCRI0KlxwlCDwnIz+sZp/JRLIiLyNKcnvV+1ahVMJpM380JERNQt1FgaUd8gQK2QtbtfrZChvkFAjaXRxzkjIiJvcjr4cnEtZiIiIuqAViWHMkyKOmtTu/vrrE1QhkmhVXFeLCKiUOLScs9cx4uIiKjrUmIikK7XoNhY1+bmpiiKKDbWoZ9ei5SYCD/lkIiIvMGlW2qXXHJJpwFYRUVFlzJEREQU6qRSCaaPTEZRZZ1t7Jda0TzbYbGxDtERCkwbmcTJNoiIQoxLwdeqVas42yERBQUuXEuBLiNJh8WZ/WzrfJ2vbl7na2hyFKaNTOI080REIcil4Ov222+HXq/3Vl6IiDyCC9dSsMhI0mFQQiRvFBARdRNOB18c70VEwYAL11KwkUolnE6eiKib4GyHRBQyLl64VqOSQyaVNC9cq9egwmzFlkNFEATWZ0REROR7TgdfgiCwyyERBTRXFq4lIiIi8jWXpponIgpkXLiWiIiIAhmDLyIKGVy4loiIiAIZgy8iChlcuJaIiIgCGYMvIgoZLQvXRkcokG8wwWRpRJMgwmRpRL7BxIVriYiIyK8YfBFRSGlZuHZIsg5VdVYUlplRVWfF0OQoTjNPREREfsWBD0QUcrhwLREREQUiBl9EFJK4cC0REREFGnY7JCIiIiIi8gEGX0RERERERD7A4IuIiIiIiMgHOOaLiIi6HUEQOSELERH5HIMvIiLqVvKKjNh86CzyDSbUNwhQhkmRrtdg+shkLkVARERexeCLiIi6jbwiI17ecwIVZisSdGqodTLUWZtw5KwRRZV1XAuOiIi8imO+iIioWxAEEZsPnUWF2Yp0vQYalRwyqQQalRzpeg0qzFZsOVQEQRD9nVUiIgpRDL6IiKhbKCw3I99gQoJODYnEfnyXRCJBgk6NE4YaFJab/ZRDIiIKdQy+iIioW6ixNKK+QYBaIWt3v1ohQ32DgBpLo49zRkRE3QWDLyIi6ha0KjmUYVLUWZva3V9nbYIyTAqtisOhiYjIOxh8ERFRt5ASE4F0vQbFxjqIov24LlEUUWysQz+9FikxEX7KIRERhToGX0RE1C1IpRJMH5mM6AgF8g0mmCyNaBJEmCyNyDeYEB2hwLSRSVzvi4iIvIZ9K4iILsIFeENXRpIOizP72db5Ol/dvM7X0OQoTBuZxGnmiYjIqxh8ERG1wgV4Q19Gkg6DEiIZYBMRkc8x+CIi+h8uwNt9SKUS9I3T+DsbRETUzXDMFxERuAAvEREReR+DLyIicAFeIiIi8j4GX0RE4AK8RERE5H0MvoiIwAV4iYiIyPsYfBERgQvwEhERkfcx+CIiAhfgJSIiIu9j8EVE9D8tC/AOSdahqs6KwjIzquqsGJocxWnmiYiIqMs4eIGIqBUuwEtERETewuCLiOgiXICXiIiIvIHdDomIiIiIiHyALV9BThBEnCozwVBqglkajtRYLbtHEVHAEQSRXTmJiKjbY/AVxPKKjNh86CwKDDWIkVpQLpQhTa/F9JHJnBiAiAJGS12VbzChvkGAMkyKdL2GdRUREXU7DL6CVF6RES/vOYEKsxWJOhX0SqCpXoEjZ40oqqzjzGxEFBBa11UJOjXUOhnqrE2sq4iIqFvy65iv7OxsjB49GlqtFnq9HjfffDOOHz9ul2bdunWYMGECIiMjIZFIUFVV1elxH3vsMUgkEru/AQMG2KWZMGFCmzQLFizw5Ol5jSCI2HzoLCrMVqTrNYhQySGVABEqOdL1GlSYrdhyqAiCIHZ+MCIiL7m4rtKo5JBJJdCwriIiom7Kr8HX3r17kZWVhQMHDmDXrl1oaGjApEmTYDabbWlqa2sxZcoUrFy50qVjDx48GMXFxba/ffv2tUkzb948uzRPP/10l8/JFwrLzcg3mJCgU0MisR8zIZFIkKBT44ShBoXl5g6OQETkfayriIiI7Pm12+HOnTvtHufk5ECv1+PgwYMYN24cAGDJkiUAgNzcXJeOLZfLER8f7zBNeHh4p2kCUY2lEfUNAtQ6Wbv71QoZzlcLqLE0+jhnREQXsK4iIiKyF1BjvoxGIwAgOjq6y8c6ceIEEhMToVKpMGbMGGRnZ6N37952aTZu3Ii3334b8fHxuPHGG/Hwww8jPDy83ePV19ejvr7e9ri6uhoAIAgCBEHocn5doVFKoQqTwGJtRIRKDkBs9QdYrI1QhUmgUUp9njcKHoIgQBRFlhFymbNlp21dZY91VWgRBBGnK8yosTRBq5KhT7T9jJasc8gdLDfkLl+XHWdfJ2CCL0EQsGTJEowdOxYZGRldOtbll1+OnJwc9O/fH8XFxVi1ahWuuuoq5OXlQavVAgDuvPNO9OnTB4mJifjxxx/xwAMP4Pjx49iyZUu7x8zOzsaqVavabC8tLYXFYulSfl2lFkSMiJPidJkRUSo1AEADK4DmH7k6Sx1GxkVA3WiGwVDr07xR8BAEAUajEaIoQirlkn/kPGfLTnt1VWusq0LH6XIz/lNQjmJjHRoaRYTJm7uVXpEWgz4xEQBY55B7WG7IXb4uOzU1NU6lk4iiGBAjnf/4xz9ix44d2LdvH5KTk9vsz83NxdVXX43KykpERUW5dOyqqir06dMHzz//PObOndtums8//xyZmZnIz89HWlpam/3ttXz16tULlZWViIyMdCk/nvDTOSNWf55vm+0wXmlFSb0C54wWREcosPCadAxO5Axi1DFBEFBaWoq4uDj+oJFLXCk7reuqBJ0aKoUMFmsTio11rKtChLOfMesccgfLDbnL12WnuroaPXr0gNFodBgbBETL18KFC7F9+3Z8+eWX7QZeXRUVFYVLLrkE+fn5Haa5/PLLAaDD4EupVEKpVLbZLpVK/VIZDEnugUWZl9jW+ZLW16NSkGBIcg9MG5nEqZvJKRKJxG9lmIKbs2WndV2VbzChvroeyjAp66oQIQgitnx/DuXmBqTrtbaJVSJUUqQp5cg3mLD1+2IMToyCVCoNmDqHi34Hl0ApNxR8fFl2nH0NvwZfoihi0aJF2Lp1K3Jzc5GamuqV1zGZTCgoKMDvfve7DtMcPnwYAJCQkOCVPHhDRpIOgxIicaqsBobzBuh76pEaq+UPCBEFlJa6ihe7oceVGS1TYtofU+1rXPSbiPzJr8FXVlYWNm3ahI8++gharRYlJSUAAJ1OB7W6eXxASUkJSkpKbK1WR44cgVarRe/evW0Tc2RmZuKWW27BwoULAQDLly/HjTfeiD59+uDcuXN49NFHIZPJcMcddwAACgoKsGnTJlx//fWIiYnBjz/+iKVLl2LcuHEYOnSor9+GLpFKJUiN1SBCqIU+VsOLGSIKSFKpBH3jNP7OBnlYsM1oyUW/icjf/Np+u2bNGhiNRkyYMAEJCQm2v/fee8+WZu3atRgxYgTmzZsHABg3bhxGjBiBbdu22dIUFBSgrKzM9vjs2bO444470L9/f8ycORMxMTE4cOAA4uLiAAAKhQK7d+/GpEmTMGDAAPz5z3/G9OnT8e9//9tHZ05ERBT8tCo5lGFS1Fmb2t1fZ22CMkwKbTuzXfoaF/0mokDg926HnXnsscfw2GOPOUxTWFho9/jdd991mL5Xr17Yu3dvp69NREREHUuJiUC6XoMjZ41IV2rsuh6KoohiYx2GJkchJSYCLcuh+IsrXSTZSktE3sKRi0RELhAEESdLTfjh1yqcLDXxLjl1a1KpBNNHJiM6QoF8gwkmSyOaBBEmSyPyDSZERygwbWRSQHSJt3WRVHTcRbK+IXC6SBJRaPJ/PwAioiDBgfpEbWUk6bA4s5/tu3G+uvm7MTQ5KqBmtGzdRVLTTjfIQOoiSUShizUMEZETOFCfqGPBMKOla10kiYi8g8EXEVEnLh6o33LRplHJka7UIN9gwpZDRRiUEBlQF5tEvhToM1q2dJEsqqyzjf1SK5pvorQsCB0oXSSJKHRxzBcRUSdcGahPFAy669jFli6SQ5J1qKqzorDMjKo6K4YmR7H1moh8gi1fRESdCLa1jIgc6e5jF4OhiyQRhS4GX0REneBAfQoVHLvYLNC7SBJR6GK3QyKiTrQM1C821rVZn7BloH4/vZYD9SmgcZFhIiL/Y/BFRNSJYFrLiKgjHLtIROR/DL6IiJzAgfoU7LjIMBGR/3GAAhGRk7oyUF8QRA7wJ7/i2EUiIv9jDUtE5AJ3Bup399nlKDBwkWEiIv9j8EVE5EVdnV2OLWbkKVxkmIjI/xh8ERF5ycWzy7W0NGhUcqQrNcg3mLDlUBEGJUS2e8HLFjPytJaxiy3l6nx1c7kamhyFaSOTWK6IiLyMwRcRkZe4MrvcxV0ZuR4TeQsXGSYi8h8GX0REXmKbXU7X8exy56vbzi7X1RYzos5wkWEiIv/gVPNERF7Sena59nQ0uxzXYyIiIgpNDL6IiLykZXa5YmMdRFG029cyu1w/vbbN7HJcj4mIiCg0MfgiIvKSltnloiMUyDeYYLI0okkQYbI0It9g6nB2OXdbzIiIiCiwMfgiIvKiltnlhiTrUFVnRWGZGVV1VgxNjupw0gx3W8yIiIgosPG2KRGRl7k6u5wn1mPi+mBERESBh8EXEZEPuDq7XFfWY+L6YERERIGJwRcRUYDqrMWsvdato8XVXB+MiIgoQDH4IiIKYB21mLXXupUWF4EKcwPXByMiIgpQDL6IiPzM1fFZeUXGdlu3viusRLHRgsGJkZ2uD8YFdomIiHyPwRcRkR+5Oj5LEERsPnS23datBJ0KheW1KDZakBSlBi4KwNQKGc5Xc30wIiIif2HwRUTkJx21YDkan1VYbrbNgHhx65ZCLoMqTIrKWitq6huhVYXZ7ef6YERERP7Fdb6IiPzg4hYsjUoOmVTSPD5Lr0GF2Yoth4ogCPbrfNVYGlHfIECtkLU5plYlR49wBSwNAqwN9gs0c30wIiIi/2PwRUTkB45asC4en9WaViWHMkyKOqt9cNX6eUq5FOeqLTBZGtEkiDBZGpFvMDm1PhgRBQ9BEHGy1IQffq3CyVJTm5s1RBR42PeEiMgPbC1YurYtWEDH47NSYiKQrtfgyFkj0pUau8BNFEXUWhtxZXosoiMUyC91bX0wIvIObyx6zvX8iIITgy8iIj9o3YKlaWcMVkfjs6RSCaaPTEZRZZ2t5UytaB4rVmysQ3SEAvPG9XW4PhgR+Y43giR3xosSUWBgt0MiIj9oacEqNtZBFO27CnU2PisjSYfFmf0wJFmHqjorCsvMqKqzYmhylO2iq2V9sGG9otA3TsPAi8gPWoKkI2eNiFIrkBIbgSi1AkfONm/PKzK6fEx3x4sSUWBgyxcFPG901yDyN2dasByNz8pI0rF1iyiAOVoWoiuLnrsyXpTr+REFHgZfFNDYp51CWUsLVksZd3V8VkvrFhEFHm8FSe6OFyWiwMDgiwIW+7RTd8AWLKLQ5K0gyd3xokQUGDjmiwIS+7RTd8LxWUShx9GyEID7QVJXxosSkf8x+KKA5O4aSERERIHAW0FSy3jR6AgF8g0mrudHFGQYfFFAsnXXUHTcXaO+gX3aiYgoMHkzSHJmxlMiCkzsEEwBiX3aiYgo2HV1Up3Ojs3xokTBh1euFJBaumscOWtEulJj1/WwpbvG0OQo9mmngMJlEYjoYt4MkhzNeMr6iCgwMfiigNTVNZCIfI3LIhBRR3y9LATrI6LAxeCri8xWM7Si1tYyY22yoqGpAXKpHEq50i4dAKjD1JBKmofaNTQ1wNpkhUwqg0qucittbUMtmpqa0CRcmE2pUWhEfWM9pBIp1GFqu7SiKEIlV0EmlTlMW9dQB0EUoJQrIZc2F5MmoQmWRotLaSUSCcLDwm1pLY0WNAlNUMgUCJOFOUyb3lOJ349LxPYfDThVWo/z1QIUcmBAggI3DU+0+wGpb6xHo9CIMFkYFDIFAEAQBdQ11AEAIhQRDtOKoojahloAQHhYeJvP05W0znz2nign7X2erqRtFBpR21CLuoY6RCgvvD8tn2dXy8nFn2dXy0l7n6cgiDh+vhzGunr0CA9HP30UpFKJ25+9u+Xk+zOlePnzn1FV24TkKJ1tWYTvfy1BYXkFlk0cgiHJUR777LtaTjxSRzTWwWw1Q61Q+62OcLacdPR5so5wr5y4W0dI/zfMvEloQl1jnU/qCFfTequO6OzzdLectPd55hUZ8dyuH1FZa0WyLgrhujDUWZvww6/lKCyvwMKrL8GoPj3d+uz9cR1x8WQlrCNCt47w9HVEQ2MDGpoabNu8XUe0vPed4YQbXZT4XCLKastsj5/5+hlosjVY+MlCu3T6Z/XQZGtwxnjGtu3Vb1+FJluDudvm2qVNeSkFmmwNjpUes23LOZwDTbYGt394u13aQa8OQuRTkThSdsS27b2896DJ1uCmd2+ySzv69dHQZGvw1ZmvbNu2/7IdmmwNJr410S7tuJxx0GRr8Gn+p7Ztn5/6HJpsDca8McYu7XUbr4MmW4Otx7bath04ewCabA2GrR1ml3b6+9OhydZg45GNtm1HDEegydag3yv97NL+buvvcPmGJOh77sOqmwbjoakDce94Nf72w2hMeneQXdr52+dDk63BSwdesm0rrimGJluDqKei7NIu+3QZNNkaPPnVk7ZtxnojNNkaaLI1aBQuTOLx0J6HoMnW4KE9D9m2NQqNtrTGeqNt+5NfPQlNtgbLPl1m93pRT0VBk61BcU2xbdtLB16CJluD+dvn26VNej4JmmwNCioKbNvWHVwHTbYGv9v6O7u0/V7pB022BkcMFz77jUc2QpOtwfT3p9ulHbZ2GDTZGhw4e8C2bevPW5H2zzRMfWeqXdoxb4yBJluDz099btv2af6n0GRrMC5nnF3aiW9NhCZbg+2/bLdt++rMV9BkazD69dF2aW969yZosjV4L+8927ZDxYegydZg0Kv2n+ftH94OTbYGOYdzbNuOlR6DJluDlJdSADRfYDz+8VFc/9ZdGPNWMu569694/OOjyCsy4ozxDDTZGuif1dsdd+EnC6HJ1uCZr5+xbSurLbN9nq09sPsBaLI1WJW7yrattqHWlrblh1MQRPzpk4eQc3ocfhX+z25ZhI9KJyLn9Di8/U2ebVkEf9QRmmwNDhUfsm3zRB1xy7ZbEPlUpN/rCE22BusOrrNtK6gogCZbg6Tnk+zSso5o5lIdcWwrNNkaXLfxOru0wVJHtJi7bS402Rq8+u2rtm2+rCMAYFXuKmiyNXhg9wN2x2hJ66nriJZlWjaduQkflU6ERXLGVh/Vhu1BzulxuHvrnXbLtHirjvDUdcSIdSPs0rKOaMY6opmjOiLyqUi898uFtN6uIxKfS4Qz2PJFAU8iudBd40Q5x3iR/QLcCnnzXTV1mMy2APf0yxQ+y0thuRmVtVYAQEedYE+WmVBYbvZptyMi6n5almmRSgFctLxYy9BpU30j6yMKCYIgoqiy+SZHoyBCEMSgGI4iES9uzyWnVFdXQ6fT4VzpOcTHxPu922F1RTUS4hMglUoDqrsAuxQFbncBa6MVZ4vPoqe+Z1B1OxQEEc/vOt08GYtegybRCgFNkEnCIIUc+QYTMpIi8edJKZBKJV7vUvTDr1V4fPuPSI5RIEwaBrn0QuBnFWrRJIgoKhfw/24YhGG9okKi26EgCDh97jRiY2PZ7TCE6whvdDs0GAyIiY2BVbCy2yE83+3wh1+r8LePjyExWgKZVIIwiQqS/6VtEpvT/lpuwSM3DMewXlEuf/b+6nZoqjRBr9dDKpWyjgjhOsKV64ifi83YfOgsfjlvRF2DBUq5DAPiY23jGlu6HVaVVyEpIQlSqdTrdUR1dTUS4xJhNBoRGRmJjjD4clNL8NXZG+wLgiDAYDDYKiZqxpmeHAvWcnOy1IRHt/2EKLWi3WUITJZGVNVZseqmwT65sxto+fGFYC075F8sN94XivURyw1drHXvl/YmZGtZ687XZcfZ2IDdDikkcaan0GVbgFvX8QLc56t9twA3l0UgIm9x9SYi6yMKdS3jGivMVqTrL5RxjUqOdKUG+QYTthwqwqAE/zaMOMLgi0JOmzsi/5t5rmU8UMsdEQpOgbYAN5dF8J9Aa90OtPxQcHPnJiLrIwp1LeMaE3Rqu5sLQPMcAQk6NU4YalBYbkZKTHgHR/EvBl8UUly5I8Ifn+AUiHd2M5J0WJzZz3ahdL66+UJpaHIUpo1MYrDvBYHWuh1o+aHg1pWbiKyPOtfdb5QE8/kHWu8XdzD4opDiyh2RYOnvTvYC9c5uRpIOgxIig/YHLZgEWut2oOWHgpsnbiKyPupYd79REuznH2i9X9wRuDkjckMo3BEhe+3doQvUO7tSqYRBvZcFWut2oOWHgp+nbiKyPmqru98oCYXzd633S2DOKejX4Cs7OxtbtmzBzz//DLVajSuuuAJPPfUU+vfvb0uzbt06bNq0CYcOHUJNTQ0qKysRFRXl8LiPPfYYVq1aZbetf//++Pnnn22PLRYL/vznP+Pdd99FfX09Jk+ejNdeew09e/a8+HDkIb5o5g6FOyJ0QWd36HhnN/RdXG8IohhQrdtsbSdP401E7+juN0pC5fxd6f3SejHxQOLXK9C9e/ciKysLo0ePRmNjI1auXIlJkybh6NGjiIhoHq9RW1uLKVOmYMqUKVixYoXTxx48eDB2795teyyX25/q0qVL8fHHH+ODDz6ATqfDwoULMW3aNHz99deeOTmy46tm7kAcD0TucfYOHS9oQ1d79YZOHWYrE+3x9YUpL5TJ03gT0Tu6+42SUDr/QO394iy/fnN37txp9zgnJwd6vR4HDx7EuHHjAABLliwBAOTm5rp0bLlcjvj4+Hb3GY1GvPHGG9i0aROuueYaAMD69esxcOBAHDhwAL/5zW9cOxFyyJmLaE+1YATqeCByTajcoSPntNcqfrS4ut1641SZCSVGC2IiFEjq0XYmK19fmPJCuXvxRQ8O3kT0ju5+oyTUzj+Ye78E1K+B0WgEAERHR3f5WCdOnEBiYiJUKhXGjBmD7Oxs9O7dGwBw8OBBNDQ0YOLEibb0AwYMQO/evbF///52g6/6+nrU19fbHldXVwNoXvxPEIQu57crBEGAKIp+z0d7BEHE5oO/otJcf9FFtAzpyggUGEz4vy8L0CNcgYKyC3e30+I0mDYyCYMTXb97MShBi0XXpGHLoSIUlJpgaLkjkqTDLSMTMShBG5Dvla8Fcrk5VWZCgaEGiToVmovMha4DEgmQqFMh31CNU2U1SI0N7Dt0ociTZeenc0bbd7Xl+983NgKVtQ3t1huDE7UorbHgl5JqJOqUkLRaOFMURZQYazEkKQrJOhUKDNWosTRBq5KhT7R3fpR791AjPS4CeUVGpLVzodySn9491AH5XfOlQK5znNFeWe3Kb5Uj00Yk4lxlLQoMNUjQqaFSyGD5303EmAgFbhmRAEAM2G5VnuSpcqNRSqEKk8BibUREOzdDLNZGqMIk0CilQVtGHQnV87efTt7+O+HrOsfZ1wmY4EsQBCxZsgRjx45FRkZGl451+eWXIycnB/3790dxcTFWrVqFq666Cnl5edBqtSgpKYFCoWgzdqxnz54oKSlp95jZ2dltxpEBQGlpKSwWS5fy21WCIMBoNEIUxYBb/b3EWAezsRwZ0XKoJHX2OyVAX00Tzpw/D6tGgTStCgq5DNbGJlSWleK9Lytx47BE9HHj7l6cHJh3aQwMNRGoszZBrZBBr1VBKq2HwWDw0NkFt0AuN4ZSE2KkFuiVgBTWNvsjlYCs3gLDeQMihFo/5LB781TZOV1uxr9/OAeTpRFpGoXt+3/eYECl2Yq+MeHocXG9IQUm9FbiTLkZ1VXl6Nm63jBb0V8nx7BY4NWdh1BsrENDo4gweXOXmivSYtyqTzozJU2NBlMlTMYK9IhQtMnP5DQVyspKPf66wSaQ65zOdFRWu/pb1ZE4OTBnVDT+U1COYmMNGmpEqOQSjE1SY0xaNOLkXfstEwQRhhrLRb+Pgdli4KlyoxZEjIiT4nSZEVGqtt2W6yx1GBkXAXWjGQZD4PyueOqzCtbz7wpf1zk1NTVOpQuY4CsrKwt5eXnYt29fl4913XXX2f4fOnQoLr/8cvTp0wfvv/8+5s6d69YxV6xYgWXLltkeV1dXo1evXoiLi0NkpH9X0RYEARKJBHFxcQH3g1ZiNeK0uRh91BGwwL6yEEUR35daUGKUYEwPLSxhKlgAIAxQ6UQcN5igKLBgZf8Ut38UOuh5SgjscmOWhqNcKENTvaLdO3Tm+kZUCYC+px56tnz5nCfKjiCI+Mc3ZThulCJNHw2LRGL7/jcqwvDT2QqUCyJGhauBi8YniGo1aiRAXHgECkwN/2uFkCE9To9hvXT45EgxKswNSNBpoVI3txj8p6gOP1dVYOE10R5vpdDrgXBd9EWtIs35uWVkosdfL1gFcp3jiKOy6qnfqvbo9cCo/ik4XWH2aAuuL1vwPMGT5WbiSBVWf56P785b27QoRkdokDkyHfHxgfMeePqzCrbz7ypf1zkqlcqpdAERfC1cuBDbt2/Hl19+ieTkZI8fPyoqCpdccgny8/MBAPHx8bBaraiqqrJr/Tp//nyH48SUSiWUSmWb7VKpNCB+RCQSScDkpbVIdRgUYTLUWYU24yFqLI2oqG2AIkyGsDA50Co4k0gkiNeF40SpCWcq6wJ+8GewCtRykxqrRZpe2+GYh3NGC4YmRyE1Vhuwd2tDXVfLTmG5CfmlZsTrwiGR2B8jTC6HIkyGitoG1NQ3QasKs9tfZ21CD40SiydeAqlEYuvv37tHOP624xjKzQ1I12tt5SZCJUWaUo58gwlbvy/G4MQoj5ebIck9MDgxKijHH/hSoNY5jjgqq97+rZJKgTS9527w5hUZ8crnBW3HYBdVo6jKErBTjXuq3AxJ7oFFmZdcmMinuh7KMCmGJPcIuIkavPFZBdP5e4ov6xxnX8OvwZcoili0aBG2bt2K3NxcpKameuV1TCYTCgoK8Lvf/Q4AMGrUKISFhWHPnj2YPn06AOD48eM4c+YMxowZ45U8dFeOBg5bG5tgaRCQoFNBq2xbFINt8Cd5DidOCX2OBn9rVXL0CFeg2GiBtaEJaBV8tZ5woG+sxq4MnCw1+XU2L66rFJpCZaICTmTULBgmavDmZxUM5x/q/Bp8ZWVlYdOmTfjoo49sY7EAQKfTQa1u7o9aUlKCkpISW6vVkSNHoNVq0bt3b9vEHJmZmbjllluwcOFCAMDy5ctx4403ok+fPjh37hweffRRyGQy3HHHHbbjz507F8uWLUN0dDQiIyOxaNEijBkzhjMdepjji2gLlHIpEnSqNt2KAOdmCfPFzFPkH8E+lSw55miWwJZAqcJsxblqC5RhcqeC71C5SKbAEiozWobSVONdFeg3Srz9WQX6+Yc6v9YUa9asAQBMmDDBbvv69esxe/ZsAMDatWvtJrpomYK+dZqCggKUlZXZ0pw9exZ33HEHysvLERcXhyuvvBIHDhxAXFycLc0LL7wAqVSK6dOn2y2y7DKzGZC180MvkwGt+36azR0fQyoF1Gr30tbWAk1NkNTWNj+vdZOnRAKEh9unFTuYGenitHV1gKNZWyIinE7b+iL6dFE5quoboQyT4or4CFRoZSg2miBXiZBIJGhQNedBFEWUlVVhaIIWKSq0+57kVTZg8/dFyDeY0FRrQbhMRN+4CPx2eDt9ocPDLwR49fVAo4OLL7X6wvtotQINDZ5Jq1JdKCuupG1oaE7fEaUSaFnHzpW0jY3tl5sWCgUQFmZLi1azfTpM29QEOJqEJiysOb0TaTPi1Bg0dVBzgF1rRaTYgD4tAfbFZaL1cQWhuVx2RC5vfi+A5u9ErYPBxa6kdeV778s6wtnvvat1REdlB+i0jkhRAQMjpfipqAIRveJsFxhyaz3Q1IimGjOuSY5Aj4gwnCwzoup/4x2G9tJfCL4tluYy9D+RTfWIFOrRVC1CpZKhQXlhvJiswQqruR6RghWRTfVt30PWEW3TuvK9dyZtS36bmhx/P12oI1z63rtZR6REh9vKalRcRJtu0KXlFgxK1TdP/R7AdYS5wgiYzNCqJBBbXf6F1dcBoohIQUSVqbY5Xfj/zjEQriMu3n7R997hcTtL68r33od1RMtnFakUIbNc+L42hikhymRQK2Qoq6i3/6wuFox1hKevIwTB/ly8VEfYvveOvqOtieQWo9EoAhCNzW9527/rr7d/Qnh4++kAURw/3j5tbGzHaS+91D5tnz4dpx00yD7toEEdp+3Txz7tpZd2nDY21j7t+PEdpw0PtyVrahJE88RJHacFxPs/+EFcuPGQOP21r8XvRmc6TJu17ktx+mtfiws3HhK/HX+Tw7SiwXAhv/fd5zjtqVMX0i5f7jhtXt6FtI8+6jjtN99cSPv0047TfvHFhbSrVztOu337hbTr1ztO+/77Fz6Pd991nHb9+gvH3b7dcdrVqy+k/eILx2mffvpC2m++cZz20UcvpM3Lc5x2+fILaU+dcpz2vvsupDUYHKedNetCWpPJcdpbbxXtOEobxHVEU1OTaB02rOO0LtQRFoXK9j2+/4MfxLzhVzp835qahAvHvfVWh2kf3nhAfHDzj+KDm38Uv5vAOkIURZfqCPH99x2ndbGOaGpqEouLi8WmPXscpw2yOuLrK6eKR85WNacNgjqisO8g2/fiwc0/ihVxiR0fNwCuI4Tw8OZy09TUnPb66x2/b611UkeIJtOFtLNmOU4bAHXE6qc2iQ9u/lFcuPGQuOnWhY6PG4R1hI0HryNq/vznC2XHy3WEERABiEajUXQkeEa8UtCTSiUIVzhubC0sM6OqzoqhyVFI1ztuEq/8X19ojUreXq9FIgoCYTIphiTrUFVnRWGZGQ1NjtdJcaVbsdnShCZBhMnSiGqLgzvPRF0wMCEyqLpBNzQ2r30UqvKKjP7OgleJYvO411hN20ngKDhIxFD+BnpRdXU1dDodjOfOtT/VvA+7FAlNTSgtLW07lWYgdBe4OG0HXQAEQcTpcjOqZcoLY7es9e2mPVVqwt8+OQa1LhIadXMTtazBCmlTcxcAs6UJRosVD10/EKktfZrZpahNWsFqRenZsx1Pwerv7gIXp/V2dwFPpO0m3Q4FQYDh9GnoY2M7nt3JhTpCUIfbxm5GohF9ohysY+NEffLTOSM+OlyEY8Ym1DeKUIZJMaCHEjcP0Xc8PTPriLZpPdylSJDJYDAYoI+JgdRRHgK4jmj5rTLVN0KjlDd3g1aEuVVH5BUZsfaTH1FptiI+Ug2VQgqLVUBJdR16RCjwx2suweC0nhee64E64qdzRry29yTON0htY7Aba0w4b/zfa05Is/+OBMB1hCAIMJjN0Ov1zfWNxYKffq3AmtyCdt+7iGjdhZkAg7TbIdD8WV18jjWQ41yNFdERCvzpqj4YrA/v+LhBWEd4+jpCEAQYKiuhT05uLjteriOqq6uhS0yE0Wh0uAwVgy832YKvTt5gXxAEofkHraViCnE//FqFv318DCmxEZC1c4HWJIgoLDPjoakDMaxXlO8z6AZ/TBzS3coNeU4wlB1OxhN4gqHc+IogiHj846PNMwHr2y6nkW8wYWhyFP7f1IEeL7d5RcYLU43/byxlP702YCcyurjc+PO987Vg+6wCja/rHGdjg8CemoeoHaEy81SL9irXdL0G00cms3IlchNn8yJ3uRu4u/I8f848GOxTjXenWRuD/bOi9gXH1SlRK47WDmvpCz00Oap55qkAl1dkxMt7TrRdRPGsEUWVdQG74CURUShy92aYq8/z97IIwXxzwt/vna8F82dF7WPwRUEnVBbg5YKX5E/slkdkz92bYe48L9R6cPgS3zvnsI4PXN27ZFLQCoUFeLtT1wkKLOzqSmTP3Zth7j4vlHpw+Brfu86xjg9sDL4oaAV7X+ju1nWCAgO7uhK15e7NMHefFyo9OPyB751jrOMDX/eeboiCXktf6GG9otA3ThNUlW3rrhPtYdcJ8rSL79JrVHLIpJLmu/R6DSrMVmw5VARB4CS41L3YboYpOr4ZVt/Q9maYu88DLvTgaL3OXcs6l7xAdozvXftYxwcHXtUR+Qm7TpCvsasrUfvcHUfU1fFHwd6Dw5/43rXFOj44MPgi8hN2nSBfY1dXova5ezPMEzfROJud+xy9d91hwomLz9FY18A6Pggw+CLyo1CYOISCB2cJI2qfuzfDeBMtMHWHCSfaO8c4rRINTQLr+ADHd5/Iz9h1gnyFXV2JOubuzTDeRAss3WHCiY7O8XSZGeXmetQ3NmFochTr+ADF4IsoALDbCfkC79ITOebuzTDeRAsM3WH9TEfn2K+nFnUNTTDVN7GOD2AMvoiIuhHepSdyzN2bYbyJ5nmCIOJUmQmGUhPM0nCkxmodBg7dYcKJzs4xLU6Ls5W16BMdDoOpnnV8AGLwRRTEusOAYvI83qUnokDXMqapwFCDGKkF5UIZ0vRah+O2usOkQs6cY5hMirvH9IFOHcY6PgAx+CIKUt1hQDF5D+/SE1Ggaj2mKVGngl4JNNUrOh231R0mFXL2HHXqMNbxAYqLLBMFoZYfpiNnjYhSK5ASG4EodfMP08t7TiCvyOjvLBIREbns4jFNESo5pBIgwomFglsmFSo21kEU7fe3TDjRT68N6gknusM5hjoGX0RBhivYExFRqHJl3NbFWiYVio5QIN9ggsnSiCZBhMnSiHyDKSQmnAi1cxQEESdLTfjh1yqcLDV1i2uX4G13JeqmnP1hOllmglQiYX9vIiIKGl0dt9UdJhUKlXPsrsMnGHyFME7GEJqc+WE6WWrFS7tPoOp/q913lwqNiIiCmyfGbXWHSYW8dY6+unbsDuuxdYTBV4jqrncTQtHFFWGEUubwh6nEaEFJtQUSKZAao+lWFRoREQW3tovBX9jnykLB3WFSIU+fo6+uHbvDemyOMPgKQd35bkKoaa8iTIuLQI9wBc5V1f3vh+lCxSQIAn4uqYZcKkFGQiQk0uZhne1VaERERIHm4sXgE3UqRCoBc30jzhktQTemKVj48tqxO6zH5ggn3AgxnIwhdHQ0o2FeUTUM1RbIZZI2g21/OleNJkFE/3itLfBq0dlAZaKu6o4Dp4moc67WDS1jmoYk61BVZ4Wh2oKqOiuGJkfxBrIX+Pra0TZ8QtHx8In6huBej80RtnyFmO5+NyFUONMknxSlbp7tqPTCYNvUWA1EAPE6dbvHDYUFJsn73Onzz67ORNQed+uGljFNp8pqYDhvgL6nHqmxWrZ4eYGvrx1dGdcXivMXMPgKMd1hdffuwJmKsKLWikWZ6XYzGgqiiFX/PhrSC0ySd7lzocSuzkTUnq7WDVKpBKmxGkQItdDHaoL+ojtQ+frase24vgufa+txfeb6Rjz+8dGQu6nHbochpvXdhPbw4js4ONskb65vQt84DYb1ikLfOA36xmq4+CK5zZ3Fu9nVmYjaw7ohePj62tGZtcqG9dLhlc/zXfo9ChYMvkIMVz4PDe5WhKG2+CL5jrsXSl1ZEJWIQlew1g3dceyqP64dLx7XV1hmto3rW3hNOg7/WhWygTubP0LMxbMEJejUUCuam/mLjXW8+A4SzjbJt1cRhsrii+RbrlwopcSE2/Z1t67OoTj+gMgbgrFu6K5jV/117djRWmWhPn8Bg68QxIvv4NfVirA7LDBJnuXuhZInFkQNFt31wozIHcFWN3hz7Gow3LTx17Vje2uVBWPg7orAKPHkcbz4Dn5drQi7wwKT5DnOXihFKGU4VWaCodQEszQcfaI1brfSBhNOKkLkmq704PA1by7629lNm0AKzALl2jHYAndXBWeuySm8+A5+gVIRUuhz5kIpKUqNjQfOoKC0BjFSC8qFMqTptRjeKyqkuzp788KMKNB4KhgIpmEQ3urm1tlNm6lDE3D416qAak0PhGvHYArc3cHgi8hH3P1BC4SKkEJfZxdKcqkE52ssKKqqQ6JOBb0SaKpXtHsREexdnS/+rgqiGNLjD4haeLprbbAMg/BGN7fObtr8eLYKz332C/RaJVvTLxJMgbs7GHwR+QDHilAw6OhCaUiSDuVmK85V1f3vIgKQwoqIVi0/P/xqxEPXDcSZytqgbqVt77uqU4fZ7ly3J9jHHxAB3utaGww9OLzRzc1Ra1rLMStrrRiSFGl7TbamXxAsgbs7GHwReRnHilAwae9CqWXx7gsXERem923d8nOmsjaoW346+q6eKjOhxGhBTIQCST3C2zwv2McfEHm7a62jHhyBMObJG93cHLWm1VgaUdvQhDCpFI1N9tOlB2trujc+x2AI3N3BXwoiL+JYEQpGF18o/fBrVUjPPAU4/q4OToyEoaYex0tqkKhTQSK9sERmKIw/IPLX1N6B0ivEG93cHLWmNTQJaGgUESaTIEzedsndYKtTvfk5huLQCy6yTORFwbrIJFFr7i76HUwcfVelUikGxEeiURCRV1zNxcsp5NhaaRQd32Cpb/BsMNDS0nzkrBFRagVSYiMQpW4eR/rynhPIKzJ67LWc4WjRX3d6qDhauFguk6BREBCukEOrDO7Z/ALtcwwGgf+pUlAJhO4DgSTU16qg7qFtl5wL+0Kl5aez72q8ToVyUz1SYyJQVWcNqfEHRL6e2tuVXiG+5Mlubo5a084bLYgKD4NaIYUIoPXRg6lOZe8e9zD4Io8JlO4DgSQU16pggN39XHwRkahTIVIJmOsbcc5oCYmWH2e+q9EaBf40sR+kEgnLP4UUX0/t7UqvkJSYtuMsvcmT3dw6mjRiWK8eGNZLh49/LA7q2fz81V012AXPFR8FNE4q0b5QW6uiKwE2g7bg1voiosBQA1m9BVUCQqblx9nvat9YDcsthRxfT+3dnXqFOGpNS4vTBPVsft3pc/QkBl/UZWx27lgorVXRlQCbraKhoeUi4lRZDQznDdD31CM1VhsU5bczofRdJXKHL6f2DsVeIY501JoW7LP5dbfP0VP4blCXBWOzc1daYVx9biisVdGVAJutoqFFKpUgNVaDCKEW+hBrBQqF7ypRV/gqGHCtV4jY8YFCQDDP5ufs59i7RzhOlpqCMsD0BgZf3ZQnu4AFW7NzV1ph3H1usN/dcjfAZqsoBZtg/64SdZUvggFXWpoFIbSDr2DmzOc4rJcOf9txjD1fWmHw1Q15ugtYMDU7d7XrXFdacIL57pa7AXYwtooSBfN3lShYsKU5NDj6HFsmFWHPF3v+vxomn/JGF7BgmVSiK60w3b0Fx90AO9haRYmIyHfY0hwa2vsce/cIx992HOu2102OcJHlbuTiAEKjkkMmlTR/EfQaVJit2HKoCI2NAk6WmvDDr1U4WWrqtMm/pdk5OkKBfIMpYBcg7cqCx919sWRHi0W2BNj99No2AXZ3WJyXiIjc19LSPKxXFPrGhdY40u7k4s/xTGVtt75ucoRXPN2IMwHE92cq8cDmH2Ew1XfYJbG98WLB0H2gK60w3b0Fx92Z4IKlVZSIiIg8p7tfNznC4Ksb6eyLYGlswqkyMywNTUjXa9vtkgjA4XixQO4+0JWxacE0rs1b3AmwOX03ERFR98Prpo51vzPuxhx9EURRRP75GjSJIvrGRdj2t+6b+/qXJ1Hb0ITKTsaLBepA9a60wrAFp5k7AXYwtIoSERF1xpMzRYc6Xjd1jMFXN+Loi1BtaUC52YrYCCUiVWF2z5NIJIiPVOHb0xWIjlAgI1EXlAMnXZ3a9uIKli04zdyZCS7QW0WJiKhrQj0w6Wym6FA/f1ex50vHGHx1I46+CKdKzZBKJein1wCStl+EJrF5Ao202IignjLcmVYYRxUsW3Dcx+m7iYhCk6eXsAk0nc0UPXVoAg7/WhWy5+8u9nxpn1+Dr+zsbGzZsgU///wz1Go1rrjiCjz11FPo37+/Lc26deuwadMmHDp0CDU1NaisrERUVJTTr/H3v/8dK1aswJ/+9Ce8+OKLtu0TJkzA3r177dLOnz8fa9eu7eppBbSOvgiDEnVQhcmgDGt/PJjpfwMiNRe1irUIpoGTjlphnJmK/+Gpg4L+7pYgiDhVZoKh1ASzNBypsdqgOwciIvI/byxhE0g6W2rmx7NVeO6zX6DXKkPy/LuKPV/a8mvwtXfvXmRlZWH06NFobGzEypUrMWnSJBw9ehQREc19QGtrazFlyhRMmTIFK1ascOn43377Lf7xj39g6NCh7e6fN28e/vrXv9oeh4eHu38yQcTRegwd9c2trLVCo5JD3k6rGBB8Ayfba4Vxei2vqZFB3YLTcoeywFCDGKkF5UIZ0vTabn+HjoiIXNMd1sB0NFM00Hz9U1lrxZCkyHbHywf7+bfmbtdK9nyx59cr5Z07d9o9zsnJgV6vx8GDBzFu3DgAwJIlSwAAubm5Lh3bZDLhrrvuwuuvv44nnnii3TTh4eGIj493Od+hoL0vgqO+uQk6FfrGaXCuqg7pKnlIDpx0ZS2vYK1EWt+hTNSpoFcCTfUK3qEjIiKXdYffTUczRddYGlHb0IQwqRSNTfZrYIbK+bcI9a6lvhRQzRRGoxEAEB0d3eVjZWVlYerUqZg4cWKHwdfGjRvx9ttvIz4+HjfeeCMefvjhDlu/6uvrUV9fb3tcXV0NABAEAYIgdDm/XSEIAkRR7HI+BiVoseiaNGw5VISCUhMMLX1zk3S4ZWQiAGD15/koMNQgQaeGSiGD5X/BWUyEAreMSAAgdrooc6CqrmuAtaEJap0UQNtzUCukMFQ34f+3d+9BUZ3nH8C/Z1l2F3e5yGW5hIsEzA8vYFEahthpWmFi4qX1MsnUoIOaidMIqeg0MRdtkknVaGuTSXQ0JtHOtFrbTLWJtGmHKGqsNwQUUINCjVoFNkpgL3Ld8/7+sG5cFyM3z9mF72eGGTjn5exzmIc9+7znPe9rbe28699algUuNjlga3Mi0OCHhFDvubUuywJ/LbuMbxzt/+uhBDQQMBr8kKw3os5ix66y/yIlkotc0ncbqPccGlqYN4PPQFw370XtvDHpNTD4S2jr6ILxjtE9XU4nurpk6Pwk6LQS7vwbDMT5e4PTV1uwYV+ta2ipIfjm57/q/zbj6jc3UDApGWNivK8AUzp3evo6XlN8ybKMwsJCTJw4EWPHju3XsXbu3Iny8nKUlpbetc3TTz+NhIQExMTEoLKyEsuXL0dNTQ127drVbfs1a9bgjTfe8Nj+9ddfo62trV/x9pcsy2hpaYEQAhqNpl/HitACz2aEwWIzorXDiQCdH8yBBmg0NwvPhRNCcbjuOupbbOi0CRi0EiY+EICspFBEaNthsVgG4pTU0dqKBGMnjE47DBrPHq42pxMJxi6gtRkWS7vH/ovXHf/727Sis0vAX3uz1+uRpDAkeMEdwYaWVjharmNsqBYGqRUAYEIHAAmQgLGhgL3lGqrrLiEqOEDdYMmrDeR7Dg0dzJtBqJ/XzZ5QO28CZIH0CA0uXmtBiMH92qjTdeFBUxcCDf6INXQC6HTbPxDnrzZZFvi8/DICuhzIiAwA0HFzhwF4wOCH+mY79pafR5gmzus6bpXOHZvN1qN2XlN85efno7q6GocOHerXcS5fvowlS5aguLgYBoPhru0WLVrk+j41NRXR0dHIzs5GXV0dkpKSPNq//PLLWLZsmetnq9WKuLg4REREICgoqF8x95csy5AkCREREQOWXHcbjWk2AxP+b4TX3t3pj/BwAWONA9VXWpBkDvAYWlnXZEfqA+EYmxTvcb6nr7Zga9llNDk6ER0cCEPAzV6hw1da8WVzEwomhareK9TQ0YKLjnokBBjRhls9dALNCAAgwekncNHhAAJCYDZ7Xw8WeY/78Z5Dgx/zZvDpz3Wzp7whb3LGG7BhXy1ONHa4jfy52tyFr7v0uNGphVncn/NX24VrdlR8LSMkIBjN3ZQNskGH8q87MF1rRGK4dw2tVDp3vqvuuJ1XFF8FBQUoKirCwYMHERsb269jlZWVwWKxYPz48a5tTqcTBw8exIYNG9De3g4/P8/emczMTABAbW1tt8WXXq+HXq/32K7RaLziIiJJkmKxaDRAklndgvN+0GiA2RPicKW5DbUWRzdrUugxa0IstFr3/JFlgV0VV3Hd0Ylkc6Drzddo0CBJr0WtxY7dFfUYExOi6ptvUIA/dP5+aO2Qb1tkW3J9tXY4ofP3Q1CAv1fkNHk3Jd9zaPBg3gwufb1u9pbaeZMaOxzPZz/07TNP1vabj2XEhWJcXDD+Xll/X89fTfZ2GW2dAoZgLW5+XnBn0GnRZm2HvV32yv9rZT8f9+w1VC2+hBB4/vnnsXv3buzfvx+JiYn9PmZ2djaqqqrcti1YsAApKSlYvnx5t4UXAJw8eRIAEB0d3e8YyHf1ZU0KX3ng2HOR7W/3DdSkKVxkkohoaBkqazl915TpSRGmQXv+gQYt9P4atHY4b+u4/ZavzXbtDVT9S+Xn52PHjh345JNPEBgYiIaGBgBAcHAwAgJujqttaGhAQ0MDamtrAQBVVVUIDAxEfHy8a2KO7OxszJw5EwUFBQgMDPR4ZsxoNCIsLMy1va6uDjt27MCUKVMQFhaGyspKLF26FD/84Q/vOi09DR29XZPiu2ZCArxnDbQ7F9mOCTYgSA842rtwtaWt36vNcyYkIqLB7W4dbENlLae7TZk+mM/fs+N28M12rTRVi69NmzYBuLng8e22bduG+fPnAwA2b97sNtHFrSnob29TV1eHa9eu9fh1dTodPv/8c7zzzjtwOByIi4vD7NmzsWLFir6fDA0qvVmTwpd6hW7voayz2ODX3oZmGR49dL29gzXYF9kkIhrq7tXBNtTXchqs539nx63n0Mr+ddwORZIQwjfnBVeZ1WpFcHAwWlpavGLCDYvFArPZ7JXjbQc7WRZ48+9nbvYKmT17hWotdqTFhmDF1FFe8+YkywIXrtlgabTAHGlGYnigK7be3sHyxfOn/uF7DvUF88Z3eXSw3fHh+352sDFvvEN3nw1GmgO9emil0rnT09pA/a54Ih/ni71CGo2ExHATjPINmMNNboVXb+9g+cozb0RE1HuyLPDX8v+iydHh1sFmMmiRrDeh1mLHrvIrGB0d5FXXORpYg3lopdLYhUA0AG4N50uNDUZzawe+uuZAc2sH0mJDfGbI3Z0XWJNBCz+NdPMCazahydGBXeVXPBbRdj3zprv7M2/tneo/80ZERL3Xmw42GtxuDa0cFxeCByNMLLz6iHe+iAaIr/cK9fUOli8980ZERL3jK5NKEfkK3vkiGkC+3CvU1ztYt2ZCqm9pxZ2PkN6aCWmkOZAzIRER+aDbO9i6ww42ot5h8UVEAPp+gb31zFuoUYdaix32ti44ZQF7WxdqLXavfOaNiIh6hh1sRAOLxRcRAejfBXYwPPNGRESe2MFGNLB4j5iIAPR/1kZff+aNiIi6d/sakbUWOxqtN6cav3ONSCK6NxZfROTS3wvsYF1kkohoqGMHG9HAYPFFRG54gSUiou6wg42o/1h8EZEHXmCJiIiIBh4n3CAiIiIiIlIAiy8iIiIiIiIFsPgiIiIiIiJSAIsvIiIiIiIiBbD4IiIiIiIiUgCLLyIiIiIiIgWw+CIiIiIiIlIAiy8iIiIiIiIFsPgiIiIiIiJSAIsvIiIiIiIiBbD4IiIiIiIiUgCLLyIiIiIiIgWw+CIiIiIiIlKAVu0AfJUQAgBgtVpVjgSQZRk2mw0GgwEaDetp6hnmDfUVc4f6gnlDfcG8ob5SOndu1QS3aoS7YfHVRzabDQAQFxenciREREREROQNbDYbgoOD77pfEvcqz6hbsizj6tWrCAwMhCRJqsZitVoRFxeHy5cvIygoSNVYyHcwb6ivmDvUF8wb6gvmDfWV0rkjhIDNZkNMTMx33mnjna8+0mg0iI2NVTsMN0FBQXxjol5j3lBfMXeoL5g31BfMG+orJXPnu+543cLBs0RERERERApg8UVERERERKQAFl+DgF6vx2uvvQa9Xq92KORDmDfUV8wd6gvmDfUF84b6yltzhxNuEBERERERKYB3voiIiIiIiBTA4ouIiIiIiEgBLL6IiIiIiIgUwOKLiIiIiIhIASy+BoGNGzdixIgRMBgMyMzMxPHjx9UOibzImjVr8P3vfx+BgYEwm82YMWMGampq3Nq0tbUhPz8fYWFhMJlMmD17NhobG1WKmLzRW2+9BUmSUFhY6NrGvKHuXLlyBXPnzkVYWBgCAgKQmpqKEydOuPYLIfCrX/0K0dHRCAgIQE5ODs6fP69ixOQNnE4nVq5cicTERAQEBCApKQlvvvkmbp8XjrlDBw8exPTp0xETEwNJkvC3v/3NbX9PcqSpqQm5ubkICgpCSEgInnnmGdjtdsXOgcWXj/vzn/+MZcuW4bXXXkN5eTnGjRuHyZMnw2KxqB0aeYkDBw4gPz8fR48eRXFxMTo7O/HYY4/B4XC42ixduhR79uzBxx9/jAMHDuDq1auYNWuWilGTNyktLcX777+PtLQ0t+3MG7rTN998g4kTJ8Lf3x+fffYZzpw5g/Xr12P48OGuNuvWrcO7776LzZs349ixYzAajZg8eTLa2tpUjJzUtnbtWmzatAkbNmzA2bNnsXbtWqxbtw7vvfeeqw1zhxwOB8aNG4eNGzd2u78nOZKbm4vTp0+juLgYRUVFOHjwIBYtWqTUKQCCfNrDDz8s8vPzXT87nU4RExMj1qxZo2JU5M0sFosAIA4cOCCEEKK5uVn4+/uLjz/+2NXm7NmzAoA4cuSIWmGSl7DZbGLkyJGiuLhYPProo2LJkiVCCOYNdW/58uXiBz/4wV33y7IsoqKixG9+8xvXtubmZqHX68Wf/vQnJUIkLzV16lSxcOFCt22zZs0Subm5QgjmDnkCIHbv3u36uSc5cubMGQFAlJaWutp89tlnQpIkceXKFUXi5p0vH9bR0YGysjLk5OS4tmk0GuTk5ODIkSMqRkberKWlBQAQGhoKACgrK0NnZ6dbHqWkpCA+Pp55RMjPz8fUqVPd8gNg3lD3Pv30U2RkZODJJ5+E2WxGeno6PvjgA9f+CxcuoKGhwS1vgoODkZmZybwZ4h555BHs3bsX586dAwCcOnUKhw4dwhNPPAGAuUP31pMcOXLkCEJCQpCRkeFqk5OTA41Gg2PHjikSp1aRV6H74tq1a3A6nYiMjHTbHhkZiS+//FKlqMibybKMwsJCTJw4EWPHjgUANDQ0QKfTISQkxK1tZGQkGhoaVIiSvMXOnTtRXl6O0tJSj33MG+rOf/7zH2zatAnLli3DK6+8gtLSUvziF7+ATqdDXl6eKze6u24xb4a2l156CVarFSkpKfDz84PT6cSqVauQm5sLAMwduqee5EhDQwPMZrPbfq1Wi9DQUMXyiMUX0RCSn5+P6upqHDp0SO1QyMtdvnwZS5YsQXFxMQwGg9rhkI+QZRkZGRlYvXo1ACA9PR3V1dXYvHkz8vLyVI6OvNlf/vIXbN++HTt27MCYMWNw8uRJFBYWIiYmhrlDgwqHHfqw8PBw+Pn5ecwu1tjYiKioKJWiIm9VUFCAoqIilJSUIDY21rU9KioKHR0daG5udmvPPBraysrKYLFYMH78eGi1Wmi1Whw4cADvvvsutFotIiMjmTfkITo6GqNHj3bbNmrUKFy6dAkAXLnB6xbd6YUXXsBLL72En/3sZ0hNTcW8efOwdOlSrFmzBgBzh+6tJzkSFRXlMSldV1cXmpqaFMsjFl8+TKfTYcKECdi7d69rmyzL2Lt3L7KyslSMjLyJEAIFBQXYvXs39u3bh8TERLf9EyZMgL+/v1se1dTU4NKlS8yjISw7OxtVVVU4efKk6ysjIwO5ubmu75k3dKeJEyd6LGVx7tw5JCQkAAASExMRFRXlljdWqxXHjh1j3gxxN27cgEbj/rHUz88PsiwDYO7QvfUkR7KystDc3IyysjJXm3379kGWZWRmZioTqCLTetB9s3PnTqHX68Xvf/97cebMGbFo0SIREhIiGhoa1A6NvMRzzz0ngoODxf79+0V9fb3r68aNG642P//5z0V8fLzYt2+fOHHihMjKyhJZWVkqRk3e6PbZDoVg3pCn48ePC61WK1atWiXOnz8vtm/fLoYNGyb++Mc/utq89dZbIiQkRHzyySeisrJS/PSnPxWJiYmitbVVxchJbXl5eeKBBx4QRUVF4sKFC2LXrl0iPDxcvPjii642zB2y2WyioqJCVFRUCADid7/7naioqBAXL14UQvQsRx5//HGRnp4ujh07Jg4dOiRGjhwp5syZo9g5sPgaBN577z0RHx8vdDqdePjhh8XRo0fVDom8CIBuv7Zt2+Zq09raKhYvXiyGDx8uhg0bJmbOnCnq6+vVC5q80p3FF/OGurNnzx4xduxYodfrRUpKitiyZYvbflmWxcqVK0VkZKTQ6/UiOztb1NTUqBQteQur1SqWLFki4uPjhcFgEA8++KB49dVXRXt7u6sNc4dKSkq6/UyTl5cnhOhZjly/fl3MmTNHmEwmERQUJBYsWCBsNpti5yAJcdvS4URERERERHRf8JkvIiIiIiIiBbD4IiIiIiIiUgCLLyIiIiIiIgWw+CIiIiIiIlIAiy8iIiIiIiIFsPgiIiIiIiJSAIsvIiIiIiIiBbD4IiIiIiIiUgCLLyIiIpV89dVXkCQJJ0+eVDsUIiJSAIsvIiLyWfPnz4ckSZAkCf7+/khMTMSLL76Itra2+/7aP/rRj1BYWHjfX4eIiAYPrdoBEBER9cfjjz+Obdu2obOzE2VlZcjLy4MkSVi7dq3aoREREbnhnS8iIvJper0eUVFRiIuLw4wZM5CTk4Pi4mLX/hEjRuCdd95x+53vfe97eP31110/S5KEDz/8EDNnzsSwYcMwcuRIfPrpp72KY8SIEVi9ejUWLlyIwMBAxMfHY8uWLW5tjh8/jvT0dBgMBmRkZKCiosLjONXV1XjiiSdgMpkQGRmJefPm4dq1awCA/fv3Q6fT4YsvvnC1X7duHcxmMxobG3sVLxERKY/FFxERDRrV1dU4fPgwdDpdr3/3jTfewFNPPYXKykpMmTIFubm5aGpq6tUx1q9f7yqqFi9ejOeeew41NTUAALvdjmnTpmH06NEoKyvD66+/jl/+8pduv9/c3IxJkyYhPT0dJ06cwD//+U80NjbiqaeeAvDtUMd58+ahpaUFFRUVWLlyJT788ENERkb2+pyJiEhZLL6IiMinFRUVwWQywWAwIDU1FRaLBS+88EKvjzN//nzMmTMHycnJWL16Nex2O44fP96rY0yZMgWLFy9GcnIyli9fjvDwcJSUlAAAduzYAVmW8dFHH2HMmDGYNm2aR5wbNmxAeno6Vq9ejZSUFKSnp2Pr1q0oKSnBuXPnAAC//vWvMXz4cCxatAhz585FXl4efvKTn/T6fImISHl85ouIiHzaj3/8Y2zatAkOhwNvv/02tFotZs+e3evjpKWlub43Go0ICgqCxWLp8zEkSUJUVJTrGGfPnkVaWhoMBoOrTVZWltvvnzp1CiUlJTCZTB7Hrqurw0MPPQSdToft27cjLS0NCQkJePvtt3sVIxERqYfFFxER+TSj0Yjk5GQAwNatWzFu3Dh89NFHeOaZZwAAGo0GQgi33+ns7PQ4jr+/v9vPkiRBluVexdLfY9jtdkyfPr3byUKio6Nd3x8+fBgA0NTUhKamJhiNxl7FSURE6uCwQyIiGjQ0Gg1eeeUVrFixAq2trQCAiIgI1NfXu9pYrVZcuHBB8dhGjRqFyspKt2nwjx496tZm/PjxOH36NEaMGIHk5GS3r1sFVl1dHZYuXYoPPvgAmZmZyMvL63WRSERE6mDxRUREg8qTTz4JPz8/bNy4EQAwadIk/OEPf8AXX3yBqqoq5OXlwc/PT/G4nn76aUiShGeffRZnzpzBP/7xD/z2t791a5Ofn4+mpibMmTMHpaWlqKurw7/+9S8sWLAATqcTTqcTc+fOxeTJk7FgwQJs27YNlZWVWL9+veLnQ0REvcfii4iIBhWtVouCggKsW7cODocDL7/8Mh599FFMmzYNU6dOxYwZM5CUlKR4XCaTCXv27EFVVRXS09Px6quvegwvjImJwb///W84nU489thjSE1NRWFhIUJCQqDRaLBq1SpcvHgR77//PoCbQxG3bNmCFStW4NSpU4qfExER9Y4k7hwIT0RERERERAOOd76IiIiIiIgUwOKLiIiIiIhIASy+iIiIiIiIFMDii4iIiIiISAEsvoiIiIiIiBTA4ouIiIiIiEgBLL6IiIiIiIgUwOKLiIiIiIhIASy+iIiIiIiIFMDii4iIiIiISAEsvoiIiIiIiBTw/2nwMhzKOq6dAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 21.5096 ms\n", + "Median: 21.4942 ms\n", + "Std: 0.0625 ms\n", + "Min: 21.4420 ms\n", + "Max: 21.7808 ms\n" + ] + } + ], + "source": [ + "# Collect 100 samples\n", + "timings = []\n", + "for i in range(100):\n", + " timings.append(benchmark_events(simple_mm, a, b))\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(range(100), timings, alpha=0.6)\n", + "plt.axhline(y=np.median(timings), color='r', linestyle='--', label=f'Median: {np.median(timings):.4f} ms')\n", + "plt.axhline(y=np.mean(timings), color='g', linestyle=':', label=f'Mean: {np.mean(timings):.4f} ms')\n", + "plt.title(\"Benchmarking Jitter & Cold Start\")\n", + "plt.ylabel(\"Time (ms)\")\n", + "plt.xlabel(\"Run Index\")\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(f\"Mean: {np.mean(timings):.4f} ms\")\n", + "print(f\"Median: {np.median(timings):.4f} ms\")\n", + "print(f\"Std: {np.std(timings):.4f} ms\")\n", + "print(f\"Min: {np.min(timings):.4f} ms\")\n", + "print(f\"Max: {np.max(timings):.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hX_-OpftzX2i" + }, + "source": [ + "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", + "\n", + "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", + "\n", + "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", + "\n", + "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", + "\n", + "**The Fix:**\n", + "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.487140Z", + "iopub.status.busy": "2025-12-17T21:24:44.487016Z", + "iopub.status.idle": "2025-12-17T21:24:44.489937Z", + "shell.execute_reply": "2025-12-17T21:24:44.489208Z" + }, + "id": "Kj5azcpxzX2j" + }, + "outputs": [], + "source": [ + "# KernelBench provides utilities to flush the L2 cache\n", + "# This is important for cold cache measurements that simulate real-world inference\n", + "\n", + "def clear_l2_cache(device=DEVICE):\n", + " \"\"\"Flush L2 cache by writing to a large tensor.\n", + " \n", + " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", + " \"\"\"\n", + " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", + " dummy.fill_(1901) # Force write to thrash cache\n", + " del dummy\n", + "\n", + "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", + "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", + "from src.timing import clear_l2_cache_triton" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Why does flushing the cache matter?\n", + "\n", + "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", + "1. **Without** cache flushing between runs (data stays in L2 cache)\n", + "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.492322Z", + "iopub.status.busy": "2025-12-17T21:24:44.492090Z", + "iopub.status.idle": "2025-12-17T21:24:44.507209Z", + "shell.execute_reply": "2025-12-17T21:24:44.506066Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Without cache flushing (warm cache):\n", + "\n", + "With cache flushing (cold cache):\n", + "\n", + "Warm cache median: 0.0280 ms\n", + "Cold cache median: 0.0318 ms\n", + "Difference: 0.0038 ms (13.7% slower with cold cache)\n", + "\n", + "Without cache flushing, you measure artificially fast times!\n" + ] + } + ], + "source": [ + "# Demonstrate why L2 cache flushing matters\n", + "# Use a smaller matrix so the effect is visible (data fits in cache)\n", + "N_SMALL = 512\n", + "a_small, b_small = get_data(N_SMALL)\n", + "\n", + "NUM_SAMPLES = 20\n", + "\n", + "# do warmup runs\n", + "for _ in range(NUM_SAMPLES):\n", + " clear_l2_cache(device=DEVICE)\n", + " benchmark_events(simple_mm, a_small, b_small)\n", + " torch.cuda.synchronize(device=DEVICE)\n", + "\n", + "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", + "print(\"Without cache flushing (warm cache):\")\n", + "times_warm = []\n", + "for i in range(NUM_SAMPLES):\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_warm.append(t)\n", + "\n", + "# Benchmark WITH cache flushing (cold cache - realistic)\n", + "print(\"\\nWith cache flushing (cold cache):\")\n", + "times_cold = []\n", + "for i in range(NUM_SAMPLES):\n", + " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", + " t = benchmark_events(simple_mm, a_small, b_small)\n", + " times_cold.append(t)\n", + "\n", + "print(f\"\\nWarm cache median: {np.median(times_warm):.4f} ms\")\n", + "print(f\"Cold cache median: {np.median(times_cold):.4f} ms\")\n", + "print(f\"Difference: {np.median(times_cold) - np.median(times_warm):.4f} ms ({(np.median(times_cold)/np.median(times_warm) - 1)*100:.1f}% slower with cold cache)\")\n", + "print(\"\\nWithout cache flushing, you measure artificially fast times!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.509465Z", + "iopub.status.busy": "2025-12-17T21:24:44.509344Z", + "iopub.status.idle": "2025-12-17T21:24:44.597419Z", + "shell.execute_reply": "2025-12-17T21:24:44.596500Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA18AAAHrCAYAAAAwgicjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqjpJREFUeJzs3Xl4TNf/B/D3TPY9ISsikYUQIXaxhTYVtYYSW21FF6Wt2EslllZba1vUWtS3aumiSktjay2h9hIUIRSJJCJ7yDLn98f9zcjITDIhM4l4v55nHpk7Z+4985k71/3cc+45MiGEABEREREREemVvKIrQERERERE9CJg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRURVQseOHdGwYcOKroaaq1evonPnzrCzs4NMJsP27dsBACdOnECbNm1gZWUFmUyGs2fPVmg9iZ6WTCZDVFRURVdDZ+vXr4dMJkN8fHypZQ8ePAiZTIaDBw+WeTvx8fGQyWRYv369allUVBRkMlmZ1/WsNNWFiCoOky8iKndxcXF466234OXlBXNzc9ja2qJt27b44osvkJubW9HVeybDhw+HTCbT+DA3N1crO2zYMJw/fx4ff/wxNm7ciObNmyM/Px/9+vVDamoqFi9ejI0bN8LDw6Nc63j37l1ERUVVuqROeeKr6ZGYmKhWdsuWLXj99dfh6+sLmUyGjh07alzniRMnMHbsWPj7+8PKygq1a9dGeHg4rly58tT17Nixo8Y6dunSRa1cVlYWIiMj0aVLF1SrVk3rCa5CocD69evRs2dPuLu7w8rKCg0bNsTcuXPx8OFDnerk6ekJmUyGkJAQja+vXr1aVc+TJ0+W+TMfPXoUUVFRSEtLK/N7y4sy2ZHJZPjf//6nsUzbtm0hk8nK9ULL8uXLq0RismnTJixZsqSiq0FEpTCu6AoQUdWya9cu9OvXD2ZmZhg6dCgaNmyIvLw8HD58GJMmTUJsbCxWrVpV0dV8JmZmZlizZk2x5UZGRqq/c3NzERMTg+nTp2Ps2LGq5ZcvX8bNmzexevVqjBo1Si/1u3v3LmbNmgVPT08EBgbqZRvPYvbs2ahTp47aMnt7e7XnX3/9NU6dOoUWLVrg/v37Wtf12Wef4ciRI+jXrx8aNWqExMRELF26FE2bNsWxY8ee+iS9Vq1amDdvntqyGjVqqD1PSUnB7NmzUbt2bTRu3FhrC0lOTg5GjBiB1q1b4+2334azszNiYmIQGRmJffv2Yf/+/Tq1iJibm+PAgQNITEyEq6ur2mvfffcdzM3NdU7mnnT06FHMmjULw4cPL/ZdlCQ3NxfGxuV7KmFubo5Nmzbh9ddfV1seHx+Po0ePFrvI8ayWL18OR0dHDB8+XG15hw4dkJubC1NT03LZzowZMzB16tRyWZcmmzZtwoULF/DBBx+oLffw8EBubi5MTEz0tm0i0h2TLyIqNzdu3MCAAQPg4eGB/fv3w83NTfXau+++i2vXrmHXrl0VWMPyYWxsXOzE8EnJyckAiicVSUlJGpe/SF599VU0b968xDIbN25EzZo1IZfLS0ygIiIisGnTJrUT5P79+yMgIACffvqp1haU0tjZ2ZX6Hbu5uSEhIQGurq44efIkWrRoobGcqakpjhw5gjZt2qiWjR49Gp6enqoETFuLVlFt27bFiRMnsGXLFrz//vuq5bdv38ahQ4fQu3dv/Pjjjzp+wqenUCiQl5cHc3Pzck+EAKBr167YsWMHUlJS4OjoqFq+adMmuLi4wNfXFw8ePCj37T5JLpeX6+czNjYu90RVF5pa5Ymo4rDbIRGVm88//xxZWVlYu3atWuKl5OPjo3bSuG7dOrz00ktwdnaGmZkZGjRogK+//lrjun///XcEBwfDxsYGtra2aNGiBTZt2lSs3MWLF9GpUydYWlqiZs2a+Pzzz4uVefToESIjI+Hj4wMzMzO4u7tj8uTJePTo0TN8+seioqJUXQknTZoEmUwGT09PDB8+HMHBwQCAfv36FetOd/nyZfTt2xfVqlWDubk5mjdvjh07dhRbf1paGsaPHw9PT0+YmZmhVq1aGDp0KFJSUnDw4EFVEjBixAhVN67SulWdOXMGr776KmxtbWFtbY2XX34Zx44dUyuj7DZ45MgRREREwMnJCVZWVujdu7cq2dRVZmYmCgsLtb7u7u4Oubz0/6LatGlTrGXC19cX/v7+uHTpkmrZ/v37IZfLMXPmTLWymzZtgkwm07jfFRQUICsrS+u2zczMirVAaWJqaqqWeCn17t0bANTqWRJzc3P06dOn2H7//fffw8HBAaGhocXe888//2D48OGqLsCurq5444031FoTo6KiMGnSJABAnTp1VPuM8r4omUyGsWPH4rvvvoO/vz/MzMywe/du1WvKe75yc3Ph5+cHPz8/te7FqampcHNzQ5s2bUr8zpV69eoFMzMzbNu2TW35pk2bEB4ertbCDJR8T1Np96R5enoiNjYWf/75p+pzK3+Tmu75Ut5beurUKbRp0wYWFhaoU6cOVqxYUern0nbP1//+9z+0bNkSlpaWcHBwQIcOHfDHH3+oXv/ll1/QrVs31KhRA2ZmZvD29sacOXPUYtmxY0fs2rULN2/eVH0OT0/PEuOzf/9+tG/fHlZWVrC3t0evXr2K7YvKOl+7dk3VKmpnZ4cRI0YgJyen1M9MRMWx5YuIys2vv/4KLy8vjSeamnz99dfw9/dHz549YWxsjF9//RVjxoyBQqHAu+++qyq3fv16vPHGG/D398e0adNgb2+PM2fOYPfu3Rg0aJCq3IMHD9ClSxf06dMH4eHh+OGHHzBlyhQEBATg1VdfBSBdte/ZsycOHz6MN998E/Xr18f58+exePFiXLlyRTUoRmlSUlKKLTM1NYWtrS369OkDe3t7jB8/HgMHDkTXrl1hbW0NFxcX1KxZE5988gnee+89tGjRAi4uLgCA2NhYtG3bFjVr1sTUqVNhZWWFrVu3IiwsDD/++KPqRD0rKwvt27fHpUuX8MYbb6Bp06ZISUnBjh07cPv2bdSvXx+zZ8/GzJkz8eabb6J9+/YAUOJ3Ehsbi/bt28PW1haTJ0+GiYkJVq5ciY4dO+LPP/9Eq1at1MqPGzcODg4OiIyMRHx8PJYsWYKxY8diy5YtOsWuU6dOyMrKgqmpKUJDQ7Fw4UL4+vrq9F5dCCFw7949+Pv7q5a99NJLGDNmDObNm4ewsDA0bdoUCQkJGDduHEJCQvD222+rrePKlSuwsrJCXl4eXFxcMHr0aMycObNcu24p73Mr2rpTmkGDBqFz586Ii4uDt7c3ACkp6du3r8a6RUdH4/r16xgxYgRcXV1V3X5jY2Nx7NgxyGQy9OnTB1euXMH333+PxYsXq+rj5OSkWs/+/fuxdetWjB07Fo6OjqoT+6IsLCywYcMGtG3bFtOnT8eiRYsASK3e6enpWL9+fbHESRNLS0v06tUL33//Pd555x0AwLlz5xAbG4s1a9bgn3/+0TlepVmyZAnGjRsHa2trTJ8+HQBUv0ltHjx4gK5duyI8PBwDBw7E1q1b8c4778DU1BRvvPFGmbY/a9YsREVFoU2bNpg9ezZMTU1x/Phx7N+/H507dwYgHf+sra0REREBa2tr7N+/HzNnzkRGRgbmz58PAJg+fTrS09Nx+/ZtLF68GABgbW2tdbt79+7Fq6++Ci8vL0RFRSE3NxdfffUV2rZti9OnTxf7fsPDw1GnTh3MmzcPp0+fxpo1a+Ds7IzPPvusTJ+XiAAIIqJykJ6eLgCIXr166fyenJycYstCQ0OFl5eX6nlaWpqwsbERrVq1Erm5uWplFQqF6u/g4GABQHz77beqZY8ePRKurq7itddeUy3buHGjkMvl4tChQ2rrWrFihQAgjhw5UmKdhw0bJgBofISGhqrK3bhxQwAQ8+fPV3v/gQMHBACxbds2teUvv/yyCAgIEA8fPlT7fG3atBG+vr6qZTNnzhQAxE8//VSsbsp4nDhxQgAQ69atK/GzKIWFhQlTU1MRFxenWnb37l1hY2MjOnTooFq2bt06AUCEhISoxX78+PHCyMhIpKWllbidLVu2iOHDh4sNGzaIn3/+WcyYMUNYWloKR0dHcevWLa3v8/f3F8HBwTp9FiGk7xiAWLt2rdry7Oxs4ePjI/z9/cXDhw9Ft27dhK2trbh586ZauTfeeENERUWJH3/8UXz77beiZ8+eAoAIDw/Xus2yxlwIIUJCQoStra148OBBqWU9PDxEt27dREFBgXB1dRVz5swRQghx8eJFAUD8+eefqu/nxIkTqvdp+o19//33AoD466+/VMvmz58vAIgbN24UKw9AyOVyERsbq/G1yMhItWXTpk0Tcrlc/PXXX2Lbtm0CgFiyZEmpn7Hob2Pnzp1CJpOp9otJkyapjgvBwcHC399f9T7lb01T7J+snzJGRT+ntv1LWZ8DBw6olimPMwsXLlQte/TokQgMDBTOzs4iLy9Pa50iIyNF0dOuq1evCrlcLnr37i0KCwvVtl3096XpO3zrrbeEpaWl2vGiW7duwsPDo1hZTXVR1vf+/fuqZefOnRNyuVwMHTq0WJ3feOMNtXX27t1bVK9evdi2iKh07HZIROUiIyMDAGBjY6PzeywsLFR/p6enIyUlBcHBwbh+/TrS09MBSFfuMzMzMXXq1GL3LTzZhcfa2lrtPh1TU1O0bNkS169fVy3btm0b6tevDz8/P6SkpKgeL730EgDgwIEDpdbb3Nwc0dHRxR6ffvqpzp+9qNTUVOzfvx/h4eHIzMxU1en+/fsIDQ3F1atXcefOHQDAjz/+iMaNG6tawkqKhy4KCwvxxx9/ICwsDF5eXqrlbm5uGDRoEA4fPqz6bpXefPNNtW21b98ehYWFuHnzZonbCg8Px7p16zB06FCEhYVhzpw52LNnD+7fv4+PP/64zHXX5PLly3j33XcRFBSEYcOGqb1maWmJ9evX49KlS+jQoQN27dqFxYsXo3bt2mrl1q5di8jISPTp0wdDhgzBL7/8gtGjR2Pr1q3FumI+rU8++QR79+7Fp59+Wqb7/4yMjBAeHo7vv/8egDTQhru7u6qF80lFf2MPHz5ESkoKWrduDQA4ffq0ztsNDg5GgwYNdCobFRUFf39/DBs2DGPGjEFwcDDee+89nbcFAJ07d0a1atWwefNmCCGwefNmDBw4sEzr0BdjY2O89dZbquempqZ46623kJSUhFOnTum8nu3bt0OhUGDmzJnFutgW/X0V/Q6Vx4f27dsjJycHly9fLnP9ExIScPbsWQwfPhzVqlVTLW/UqBFeeeUV/Pbbb8Xe82TLcPv27XH//v1ixwYiKh2TLyIqF7a2tgCkkwNdHTlyBCEhIap7DpycnPDhhx8CgCr5iouLAwCdRq2rVatWsQTEwcFB7eb8q1evIjY2Fk5OTmqPunXrAng8IEZJjIyMEBISUuzxtCMLXrt2DUIIfPTRR8XqFRkZqVavuLi4ch1mOzk5GTk5OahXr16x1+rXrw+FQoH//vtPbfmTyYqDgwMAPNUgCO3atUOrVq2wd+/eMr/3SYmJiejWrRvs7Ozwww8/aOzi1rZtW7zzzjv4+++/ERoaqnM3sQkTJgBAudRzy5YtmDFjBkaOHKnqVlcWgwYNwsWLF3Hu3Dls2rQJAwYM0Jp4p6am4v3334eLiwssLCzg5OSkGmlS+RvTxZOjU5bE1NQU33zzDW7cuIHMzEysW7euzBcGTExM0K9fP2zatAl//fUX/vvvP7UuxhWpRo0asLKyUlumPH7oMn+YUlxcHORyealJbWxsLHr37g07OzvY2trCyclJdZGpLN+hkvIiibbffEpKCrKzs9WWl+dvnuhFx3u+iKhc2NraokaNGrhw4YJO5ePi4vDyyy/Dz88PixYtgru7O0xNTfHbb79h8eLFUCgUZa6DtvtJhBCqvxUKBQICAlT3ozzJ3d29zNt9VsrPOnHiRI2DJgDSYCWVhS5xLgt3d3f8+++/z1IlpKen49VXX0VaWhoOHTpUbFh4pUePHqkGUIiLi0NOTg4sLS11qiMgJTPPIjo6GkOHDkW3bt10GqRBk1atWsHb2xsffPABbty4UWJSEh4ejqNHj2LSpEkIDAyEtbU1FAoFunTpUqbfWNHWF13s2bMHgNTadvXq1TIlb0qDBg3CihUrEBUVhcaNG2tNUrQldroM7lHZpaWlITg4GLa2tpg9eza8vb1hbm6O06dPY8qUKU91nHwa5f2bJ3qRMfkionLTvXt3rFq1CjExMQgKCiqx7K+//opHjx5hx44daldVn+z2pxxU4MKFC+WSgHh7e+PcuXN4+eWXn6qbnj4ou/uZmJiUOuS4t7d3qQluWT6Xk5MTLC0tNSY/ly9fhlwu13tCev36dbXBHcrq4cOH6NGjB65cuYK9e/eW2JIQGRmJS5cuYcGCBZgyZQqmTp2KL7/8Uqc6Animeh4/fhy9e/dG8+bNsXXr1mcadnzgwIGYO3cu6tevr7XF9cGDB9i3bx9mzZqlNsrj1atXi5Utz9/CP//8g9mzZ2PEiBE4e/YsRo0ahfPnz8POzq5M62nXrh1q166NgwcPljiwg7IV5skJokvrBqtU1s9+9+5dZGdnq7V+KSf11jQQiTbe3t5QKBS4ePGi1u/w4MGDuH//Pn766Sd06NBBtfzGjRvFyur6OZQjsWr7zTs6OhZr2SOi8sNuh0RUbiZPngwrKyuMGjUK9+7dK/Z6XFwcvvjiCwCPr6QWvXKanp6OdevWqb2nc+fOsLGxwbx584pNIPs0V13Dw8Nx584drF69uthrubm5xbrbGIKzszM6duyIlStXIiEhodjrRYdxf+2113Du3Dn8/PPPxcop46E8cXryZFQTIyMjdO7cGb/88otal6l79+5h06ZNaNeunapL6bPSNBz9b7/9hlOnTqFLly5Ptc7CwkL0798fMTEx2LZtW4lJ//Hjx7FgwQJ88MEHmDBhAiZNmoSlS5fizz//VJXJyMgoNuWAEAJz584FAK0tk6W5dOkSunXrBk9PT+zcubPMLUlPGjVqFCIjI7Fw4UKtZTT9xgBphL8nlWWfKUl+fj6GDx+OGjVq4IsvvsD69etx7949jB8/vszrkslk+PLLLxEZGYkhQ4ZoLWdrawtHR0f89ddfasuXL1+u03asrKzK9LkLCgqwcuVK1fO8vDysXLkSTk5OaNasmc7rCQsLg1wux+zZs4u1YCm/M03fYV5ensbPZmVlpVM3RDc3NwQGBmLDhg1qn/vChQv4448/0LVrV50/AxGVHVu+iKjceHt7Y9OmTejfvz/q16+PoUOHomHDhsjLy8PRo0exbds2DB8+HICUVJmamqJHjx546623kJWVhdWrV8PZ2VktAbG1tcXixYsxatQotGjRAoMGDYKDgwPOnTuHnJwcbNiwoUx1HDJkCLZu3Yq3334bBw4cQNu2bVFYWIjLly9j69at2LNnT6kTABcUFGidvLd3795PddV42bJlaNeuHQICAjB69Gh4eXnh3r17iImJwe3bt3Hu3DkA0rxhP/zwA/r164c33ngDzZo1Q2pqKnbs2IEVK1agcePG8Pb2hr29PVasWAEbGxtYWVmhVatWWrt+zZ07F9HR0WjXrh3GjBkDY2NjrFy5Eo8ePdI4T9rTatOmDZo0aYLmzZvDzs4Op0+fxjfffAN3d3fVvX5Kf/31l+pkOjk5GdnZ2aoEqEOHDqpWgAkTJmDHjh3o0aMHUlNTi30vyntjHj58iGHDhsHX11c1uMesWbPw66+/YsSIETh//jysrKxw+vRpDBw4EAMHDoSPjw9yc3Px888/48iRI3jzzTfRtGlTtfUvXboUaWlpuHv3LgCpRff27dsApCH57ezskJmZidDQUDx48ACTJk0qNtG4t7d3qS3FT/Lw8Chx/ipA+u106NABn3/+OfLz81GzZk388ccfGltNlEnD9OnTMWDAAJiYmKBHjx5l3pfnzp2Ls2fPYt++fbCxsUGjRo0wc+ZMzJgxA3379i3ziX2vXr3Qq1evUsuNGjUKn376KUaNGoXmzZvjr7/+UrVGlaZZs2b4+uuvMXfuXPj4+MDZ2Vk1AI8mNWrUwGeffYb4+HjUrVsXW7ZswdmzZ7Fq1aoyTUXg4+OD6dOnY86cOWjfvj369OkDMzMznDhxAjVq1MC8efPQpk0bODg4YNiwYXjvvfcgk8mwceNGjReemjVrhi1btiAiIgItWrSAtbU1evTooXHb8+fPx6uvvoqgoCCMHDlSNdS8nZ1dqfsVET2jChljkYiqtCtXrojRo0cLT09PYWpqKmxsbETbtm3FV199pTY08o4dO0SjRo2Eubm58PT0FJ999pn45ptvNA55vWPHDtGmTRthYWEhbG1tRcuWLcX333+vev3J4aeVhg0bVmz45by8PPHZZ58Jf39/YWZmJhwcHESzZs3ErFmzRHp6eomfraSh5ovWu6xDzQshRFxcnBg6dKhwdXUVJiYmombNmqJ79+7ihx9+UCt3//59MXbsWFGzZk1hamoqatWqJYYNGyZSUlJUZX755RfRoEEDYWxsrNMQ6KdPnxahoaHC2tpaWFpaik6dOomjR4+qldE0lHnRz1R0SG5Npk+fLgIDA4WdnZ0wMTERtWvXFu+8845ITEwsVlY5xLWmR9Ghw5VDf2t7KCmHwz9+/Ljadk6ePCmMjY3FO++8I4QQ4vr166Jfv37C09NTmJubC0tLS9GsWTOxYsUKteG/lTw8PHTeF7Q9hg0bVmLclNvp1q1biWU0fT+3b98WvXv3Fvb29sLOzk7069dP3L17V+MQ8XPmzBE1a9YUcrlcrf4AxLvvvqtxm0XXc+rUKWFsbCzGjRunVqagoEC0aNFC1KhRo8Rh9Uv6bRSl6beek5MjRo4cKezs7ISNjY0IDw8XSUlJOg01n5iYKLp16yZsbGwEANWw89qGmvf39xcnT54UQUFBwtzcXHh4eIilS5eq1UeXoeaVvvnmG9GkSRPVsSg4OFhER0erXj9y5Iho3bq1sLCwEDVq1BCTJ08We/bsKVa3rKwsMWjQIGFvby8AqI572obi37t3r2jbtq3qmNqjRw9x8eJFtTLKOicnJ6st1xRHItKNTAjeLUlERERUmo4dOyIlJUXngYWIiJ7Ee76IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgDe80VERERERGQAbPkiIiIiIiIyACZfREREREREBsDki4iokvn888/h5+cHhUKhWpaVlYVRo0bB1dUVMpkMH3zwAeLj4yGTybB+/fqKq+wLaPjw4fD09KzoagAAPD09VROXA8DBgwchk8lw8ODBCqtTWeljP16/fj1kMhni4+NVy1q3bo3JkyeX2zaIiJ4Gky8iokokIyMDn332GaZMmQK5/PEh+pNPPsH69evxzjvvYOPGjRgyZIhetv/JJ59g+/btOpXNzc3FyJEj0bBhQ9jZ2cHa2hqNGzfGF198gfz8fL3Uj+hpTZkyBcuWLUNiYmJFV4WIXmDGFV0BIiJ67JtvvkFBQQEGDhyotnz//v1o3bo1IiMjVcuEEMjNzYWJiUm5bf+TTz5B3759ERYWVmrZ3NxcxMbGomvXrvD09IRcLsfRo0cxfvx4HD9+HJs2bSq3epFuOnTogNzcXJiamlZ0VSqdXr16wdbWFsuXL8fs2bMrujpE9IJi8kVEVImsW7cOPXv2hLm5udrypKQkNGjQQG2ZTCYrVk6T7OxsWFlZlWs9AaBatWo4duyY2rK3334bdnZ2WLp0KRYtWgRXV9dy3y5pJ5fLddonDC0nJweWlpYVWge5XI6+ffvi22+/xaxZsyCTySq0PkT0YmK3QyKiSuLGjRv4559/EBISolqmvIfnxo0b2LVrF2QymepeFk33ygwfPhzW1taIi4tD165dYWNjg8GDBwMArl69itdeew2urq4wNzdHrVq1MGDAAKSnpwOQkrns7Gxs2LBBtZ2i9xPpSnk/VFpaWonl8vPzMWvWLPj6+sLc3BzVq1dHu3btEB0drSrzzz//YPjw4fDy8oK5uTlcXV3xxhtv4P79+2rrioqKgkwmw5UrV/D666/Dzs4OTk5O+OijjyCEwH///adq+XB1dcXChQvV3q+M85YtW/Dhhx/C1dUVVlZW6NmzJ/77779SP7NCocCSJUvg7+8Pc3NzuLi44K233sKDBw/Uyp08eRKhoaFwdHSEhYUF6tSpgzfeeKPU9QshMHfuXNSqVQuWlpbo1KkTYmNji5XTdM9Xad+70v/+9z+0bNkSlpaWcHBwQIcOHfDHH3+oXv/ll1/QrVs31KhRA2ZmZvD29sacOXNQWFiotp6OHTuiYcOGOHXqFDp06ABLS0t8+OGHAKR9Yvjw4bCzs4O9vT2GDRumdT+5fPky+vbti2rVqsHc3BzNmzfHjh07ipWLjY3FSy+9BAsLC9SqVQtz585Vu1+yqFdeeQU3b97E2bNnNb5ORKRvbPkiIqokjh49CgBo2rSpaln9+vWxceNGjB8/HrVq1cKECRMAAE5OTkhOTta4noKCAoSGhqJdu3ZYsGABLC0tkZeXh9DQUDx69Ajjxo2Dq6sr7ty5g507dyItLQ12dnbYuHEjRo0ahZYtW+LNN98EAHh7e5da77y8PGRkZCA3NxcnT57EggUL4OHhAR8fnxLfFxUVhXnz5qm2mZGRgZMnT+L06dN45ZVXAADR0dG4fv06RowYAVdXV8TGxmLVqlWIjY3FsWPHirVe9O/fH/Xr18enn36KXbt2Ye7cuahWrRpWrlyJl156CZ999hm+++47TJw4ES1atECHDh3U3v/xxx9DJpNhypQpSEpKwpIlSxASEoKzZ8/CwsJC62d56623sH79eowYMQLvvfcebty4gaVLl+LMmTM4cuQITExMkJSUhM6dO8PJyQlTp06Fvb094uPj8dNPP5Ua45kzZ2Lu3Lno2rUrunbtitOnT6Nz587Iy8sr8X26fO8AMGvWLERFRaFNmzaYPXs2TE1Ncfz4cezfvx+dO3cGIA1iYW1tjYiICFhbW2P//v2YOXMmMjIyMH/+fLXt3r9/H6+++ioGDBiA119/HS4uLhBCoFevXjh8+DDefvtt1K9fHz///DOGDRtWrN6xsbFo27YtatasialTp8LKygpbt25FWFgYfvzxR/Tu3RsAkJiYiE6dOqGgoEBVbtWqVVq/q2bNmgEAjhw5giZNmpQadyKicieIiKhSmDFjhgAgMjMzi73m4eEhunXrprbsxo0bAoBYt26datmwYcMEADF16lS1smfOnBEAxLZt20qsg5WVlRg2bFiZ6v39998LAKpH8+bNxT///FPq+xo3blzsMz0pJydH6/b++usv1bLIyEgBQLz55puqZQUFBaJWrVpCJpOJTz/9VLX8wYMHwsLCQu1zHjhwQAAQNWvWFBkZGarlW7duFQDEF198oVo2bNgw4eHhoXp+6NAhAUB89913avXcvXu32vKff/5ZABAnTpwo8TM/KSkpSZiamopu3boJhUKhWv7hhx8KABo/x4EDB4QQun3vV69eFXK5XPTu3VsUFhaqvVZ0e5q+i7feektYWlqKhw8fqpYFBwcLAGLFihVqZbdv3y4AiM8//1y1rKCgQLRv377Yfvzyyy+LgIAAtfUqFArRpk0b4evrq1r2wQcfCADi+PHjqmVJSUnCzs5OABA3btwoVmdTU1PxzjvvaI0HEZE+sdshEVElcf/+fRgbG8Pa2vqZ1/XOO++oPVe2cOzZswc5OTnPvP6iOnXqhOjoaGzbtg1vv/02TExMkJ2dXer77O3tERsbi6tXr2otU7QF4+HDh0hJSUHr1q0BAKdPny5WftSoUaq/jYyM0Lx5cwghMHLkSLXt1qtXD9evXy/2/qFDh8LGxkb1vG/fvnBzc8Nvv/2mtY7btm2DnZ0dXnnlFaSkpKgezZo1g7W1NQ4cOKDaLgDs3LmzTKNB7t27F3l5eRg3bpxaS98HH3xQ6nt1+d63b98OhUKBmTNnqo2wCUBte0W/i8zMTKSkpKB9+/bIycnB5cuX1d5nZmaGESNGqC377bffYGxsrLZvGhkZYdy4cWrlUlNTsX//foSHh6u2k5KSgvv37yM0NBRXr17FnTt3VOts3bo1WrZsqXq/k5OTqqutJg4ODkhJSdH6OhGRPjH5IiKqYoyNjVGrVi21ZXXq1EFERATWrFkDR0dHhIaGYtmyZcXu+3kaLi4uCAkJQd++ffH111+je/fueOWVV0od0nv27NlIS0tD3bp1ERAQgEmTJuGff/5RK5Oamor3338fLi4usLCwgJOTE+rUqQMAGuteu3Ztted2dnYwNzeHo6NjseVP3o8FAL6+vmrPZTIZfHx81OaLetLVq1eRnp4OZ2dnODk5qT2ysrKQlJQEAAgODsZrr72GWbNmwdHREb169cK6devw6NEj7UECcPPmTY11c3JygoODQ4nv1eV7j4uLg1wuLzagy5NiY2PRu3dv2NnZwdbWFk5OTnj99dcBFP8uatasWWzExZs3b8LNza3YxYV69eqpPb927RqEEPjoo4+KxVM52qcypjdv3iwWF03rLEoIwcE2iKjC8J4vIqJKonr16igoKEBmZqZa60tZmZmZFWvBAICFCxdi+PDh+OWXX/DHH3/gvffew7x583Ds2LFiydqz6Nu3L6ZPn45ffvkFb731ltZyHTp0QFxcnKo+a9asweLFi7FixQpVC1Z4eDiOHj2KSZMmITAwENbW1lAoFOjSpYvGQRWMjIx0WgZIJ+HlQaFQwNnZGd99953G152cnABIidwPP/yAY8eO4ddff8WePXvwxhtvYOHChTh27Fi5tHhqUh7fe1paGoKDg2Fra4vZs2fD29sb5ubmOH36NKZMmVLsuyjp/rjSKNc1ceJEhIaGaixT2v2EJUlLSyuWjBMRGQqTLyKiSsLPzw+ANOpho0aN9LKNgIAABAQEYMaMGTh69Cjatm2LFStWYO7cuQBQLi0Cubm5ADS3TD2pWrVqGDFiBEaMGIGsrCx06NABUVFRGDVqFB48eIB9+/Zh1qxZmDlzpuo9JXVTfFZPrlsIgWvXrpX4fXh7e2Pv3r1o27atTklH69at0bp1a3z88cfYtGkTBg8ejM2bN6t1mSzKw8NDVTcvLy/V8uTkZI2td5qU9L17e3tDoVDg4sWLCAwM1Pj+gwcP4v79+/jpp5/UBim5ceOGTttXfo59+/YhKytLLdH8999/1copP6OJiYnayJ/a1qlpf3hynUp37txBXl4e6tevr3O9iYjKE7sdEhFVEkFBQQCk4cjLW0ZGBgoKCtSWBQQEQC6Xq3V7s7KyKnWIeKWUlBSNrUdr1qwBADRv3rzE9z85XLy1tTV8fHxU9VG2WD25jSVLluhUv6fx7bffIjMzU/X8hx9+QEJCAl599VWt7wkPD0dhYSHmzJlT7LWCggJVPB88eFDssyiTnZK6HoaEhMDExARfffWV2vt1iYMu33tYWBjkcjlmz55drAVLuT1N30VeXh6WL19eah2UunbtioKCAnz99deqZYWFhfjqq6/Uyjk7O6Njx45YuXIlEhISiq2n6CifXbt2xbFjx/D333+rva6tFfLUqVMAgDZt2uhcbyKi8sSWLyKiSsLLywsNGzbE3r17dZr7qSz279+PsWPHol+/fqhbty4KCgqwceNGGBkZ4bXXXlOVa9asGfbu3YtFixahRo0aqFOnDlq1aqVxnf/73/+wYsUKhIWFwcvLC5mZmdizZw+io6PRo0cPvPTSSyXWqUGDBujYsSOaNWuGatWq4eTJk/jhhx8wduxYAICtrS06dOiAzz//HPn5+ahZsyb++OOPMrW2lFW1atXQrl07jBgxAvfu3cOSJUvg4+OD0aNHa31PcHAw3nrrLcybNw9nz55F586dYWJigqtXr2Lbtm344osv0LdvX2zYsAHLly9H79694e3tjczMTKxevRq2trbo2rWr1vU7OTlh4sSJmDdvHrp3746uXbvizJkz+P3330vtPqfL9+7j44Pp06djzpw5aN++Pfr06QMzMzOcOHECNWrUwLx589CmTRs4ODhg2LBheO+99yCTybBx48Yydd3s0aMH2rZti6lTpyI+Ph4NGjTATz/9pLGFdNmyZWjXrh0CAgIwevRoeHl54d69e4iJicHt27dx7tw5AMDkyZOxceNGdOnSBe+//75qqHkPD49i9w8C0tQFtWvX5jDzRFRxKmaQRSIi0mTRokXC2tq62LDeZRlq3srKqth6r1+/Lt544w3h7e0tzM3NRbVq1USnTp3E3r171cpdvnxZdOjQQVhYWBQbxvxJJ06cEP369RO1a9cWZmZmwsrKSjRt2lQsWrRI5Ofnl/pZ586dK1q2bCns7e2FhYWF8PPzEx9//LHIy8tTlbl9+7bo3bu3sLe3F3Z2dqJfv37i7t27AoCIjIxUlVMONZ+cnKy2DW3xCA4OFv7+/qrnyiHav//+ezFt2jTh7OwsLCwsRLdu3cTNmzeLrbPoUPNKq1atEs2aNRMWFhbCxsZGBAQEiMmTJ4u7d+8KIYQ4ffq0GDhwoCpezs7Oonv37uLkyZOlxqqwsFDMmjVLuLm5CQsLC9GxY0dx4cIF4eHhUeJQ87p+70II8c0334gmTZoIMzMz4eDgIIKDg0V0dLTq9SNHjojWrVsLCwsLUaNGDTF58mSxZ88ete1pim1R9+/fF0OGDBG2trbCzs5ODBkyRDUcftH9WAgh4uLixNChQ4Wrq6swMTERNWvWFN27dxc//PCDWrl//vlHBAcHC3Nzc1GzZk0xZ84csXbt2mJDzRcWFgo3NzcxY8aMUuNNRKQvMiHK6Y5jIiJ6Zunp6fDy8sLnn3+uNjw66dfBgwfRqVMnbNu2DX379q3o6pAebN++HYMGDUJcXBzc3NwqujpE9ILiPV9ERJWInZ0dJk+ejPnz52sczY+Ins5nn32GsWPHMvEiogrFe76IiCqZKVOmYMqUKRVdDaIqJSYmpqKrQETEli8iIiIiIiJD4D1fREREREREBsCWLyIiIiIiIgNg8kVERERERGQAHHDjKSkUCty9exc2NjaQyWQVXR0iIiIiIqogQghkZmaiRo0akMu1t28x+XpKd+/ehbu7e0VXg4iIiIiIKon//vsPtWrV0vo6k6+nZGNjA0AKsK2tbYXWRaFQIDk5GU5OTiVm2vR0GF/9Ynz1i/HVL8ZXvxhf/WJ89Yvx1b/KFOOMjAy4u7urcgRtmHw9JWVXQ1tb20qRfD18+BC2trYVvuNVRYyvfjG++sX46hfjq1+Mr34xvvrF+OpfZYxxabcjVY5aEhERERERVXFMvoiIiIiIiAyAyRcREREREZEB8J4vIiIieqEUFhYiPz+/oqtR4RQKBfLz8/Hw4cNKc79MVcL46p8hY2xkZARjY+NnnmKKyRcRERG9MLKysnD79m0IISq6KhVOCAGFQoHMzEzOWaoHjK/+GTrGlpaWcHNzg6mp6VOvg8kXERERvRAKCwtx+/ZtWFpawsnJ6YU/IRZCoKCgoFyu5lNxjK/+GSrGQgjk5eUhOTkZN27cgK+v71O3tDH5IiIiohdCfn4+hBBwcnKChYVFRVenwjE50C/GV/8MGWMLCwuYmJjg5s2byMvLg7m5+VOthx1QiYiI6IXCE2EiehrlcV8ZW76IqOJkxQPJMUBaPpBrAjgFAdaeFV0rIiIiIr1g8kVEhpebAFxaACQdAvKyAJkf8N9lwNQacO4A1J8AWLhVdC2JiIiIyhW7HRKRYeUmACfGAHd+BWQmgLUXYO4m/SszAe7skF7PTajomhIRUSXn6emJJUuW6GXdH330Ed588029rJsqn9atW+PHH3/U+3aYfBGRYV1aAKTHAlZegFk1QPb/hyGZXHpu5SW9fmlRxdaTiEibrHgg/nvg2hrp36x4vW1qxYoVsLGxQUFBwePNZ2XBxMQEHTt2VCt78OBByGQyxMXF6a0+ZXHt2jWMGDECtWrVgpmZGerUqYOBAwfi5MmTFV21UiUmJuKLL77A9OnTK7oqerNs2TJ4enrC3NwcrVq1wt9//13qe7Zt2wY/Pz+Ym5sjICAAv/32m+q1/Px8TJkyBQEBAbCyskKNGjUwdOhQ3L17V20dV65cQa9eveDo6AhbW1u0a9cOBw4cUL2+fv16yGQyjY+kpKTyC8ATZsyYgalTp0KhUOhtGwCTLyIypKx4qauhqRMgN9FcRm4ivZ70p15PaIiIyiw3ATg9ATgcDpyfBVxeJP17OBw4PVEvLfadOnVCVlaWWsJy6NAhuLq64vjx43j48KFq+YEDB1C7dm14e3uXeTvKUePKy8mTJ9GsWTNcuXIFK1euxMWLF/Hzzz/Dz88PEyZMKLft6MuaNWvQpk0beHh4VHRV9GLLli2IiIhAZGQkTp8+jcaNGyM0NLTE5Obo0aMYOHAgRo4ciTNnziAsLAxhYWG4cOECACAnJwenT5/GRx99hNOnT+Onn37Cv//+i549e6qtp3v37igoKMD+/ftx6tQpNG7cGN27d0diYiIAoH///khISFB7hIaGIjg4GM7OznqLyauvvorMzEz8/vvvetsGwOSLiAwpJQbIzwBM7UsuZ2ovlUs5ZohaERGVrliXae/HDz12ma5Xrx7c3Nxw8OBB1bKDBw+iV69eqFOnDo4dO6a2vFOnTgCAjRs3onnz5rCxsYGrqysGDRqkdmJ98OBByOVy7N69G82bN4eZmRkOHz6Mjh07Yty4cfjggw/g4OAAFxcXrF69GtnZ2RgxYgRsbGzg4+NT4gmqEALDhw+Hr68vDh06hG7dusHb2xuBgYGIjIzEL7/8oio7ZcoU1K1bF5aWlvDy8sJHH32E/Px8tfX9+uuvaNGiBczNzeHo6IjevXurvZ6Tk4M33ngDNjY2qF27NlatWqX2+n///Yfw8HDY29ujWrVq6NWrF+Lj40uM++bNm9GjRw+1ZU8bmwsXLuDVV1+FtbU1XFxcMGTIEKSkpKhe3717N9q1awd7e3tUr14d3bt3V2u9jI+Ph0wmw08//YROnTrB0tISjRs3RkxMTImfoSSLFi3C6NGjMWLECDRo0AArVqyApaUlvvnmG63v+eKLL9ClSxdMmjQJ9evXx5w5c9C0aVMsXboUAGBnZ4fo6GiEh4ejXr16aN26NZYuXYpTp07h1q1bAICUlBRcvXoVU6dORaNGjeDr64tPP/0UOTk5qiTOwsICrq6uqoeRkRH279+PkSNHquoSFRWFwMBAfPPNN/D29oaNjQ3GjBmDwsJCfP7553B1dYWzszM+/vhj1XuEEIiKikLt2rVhZmaGGjVq4L333lO9bmRkhK5du2Lz5s1PHVddMPkiIsMpyJa6F8pKOfQoyxRkGaZeRESlqcAu0506dVLrlnXgwAF07NgRwcHBquW5ubk4fvy4KvnKz8/HnDlzcO7cOWzfvh3x8fEYPnx4sXVPnz4d8+bNw6VLl9CoUSMAwIYNG+Do6Ii///4b48aNwzvvvIN+/fqhTZs2OH36NDp37owhQ4YgJydHY33Pnj2L2NhYTJgwQePQ3Pb29qq/bWxssH79ely8eBFffPEFVq9ejcWLF6te37VrF3r37o2uXbvizJkz2LdvH1q2bKm2voULF6J58+Y4c+YMxowZg3feeQf//vuvKg6hoaGwsbHBoUOHcOTIEVhbW6NLly7Iy8vTWP/U1FRcvHgRzZs3L/ZaWWOTlpaGl19+GU2aNMHJkyexe/du3Lt3D+Hh4ap1ZmdnIyIiAidPnsS+ffsgl8vRu3fvYt3fpk+fjokTJ+Ls2bOoW7cuBg4cqGqtvHXrFqytrUt8fPLJJwCAvLw8nDp1CiEhIap1y+VyhISElJjQxcTEqL0HAEJDQ0t8T3p6OmQymeo7r169OurVq4dvv/0W2dnZKCgowMqVK+Hs7IxmzZppXMe3334LS0tL9O3bV215XFwcdu/ejV9//RWbNm3C2rVr0a1bN9y+fRt//vknPvvsM8yYMQPHjx8HAPz4449YvHgxVq5ciatXr2L79u0ICAhQW2fLli1x6NAhrZ+nXAh6Kunp6QKASE9Pr+iqiMLCQpGQkCAKCwsruipVEuNbjm5sEmJHPSH2dxXiQHchDnQXhft7iIQ/xojC/T1Uy8T+rlK5G99XdI2fe9x/9Yvx1a/yjm9ubq64ePGiyM3NLdsbM28I8XsLIXa3eXyc0vTY3UYql3mjXOqrtHr1amFlZSXy8/NFRkaGMDY2FklJSWLTpk2iQ4cOQggh9u3bJwCImzdvalzHiRMnBACRmZkphBDiwIEDAoD44YcfhEKhUJULDg4W7dq1Uz0vKCgQVlZWYsiQIaplCQkJAoCIiYnRuK0tW7YIAOL06dNl/qzz588XzZo1Uz0PCgoSgwcP1lrew8NDvP7666rnCoVCODs7i6+//loIIcTGjRtFvXr11D7jo0ePhIWFhdizZ4/GdZ45c0YAELdu3VJbXtbYKBQKERUVJTp37qy2nv/++08AEP/++6/G7ScnJwsA4vz580IIIW7cuCEAiDVr1qjKxMbGCgDi0qVLQggh8vPzxdWrV0t83L9/XwghxJ07dwQAcfToUbXtTpo0SbRs2VJjnYQQwsTERGzatElt2bJly4Szs7PG8rm5uaJp06Zi0KBBxT5/s2bNhEwmE0ZGRsLNza3EfaV+/frinXfeUVsWGRkpLC0tRXp6usjLyxMKhUKEhoYKT09PteNFvXr1xLx584QQQixcuFDUrVtX5OXlad3WL7/8IuRyudZjTknHEF1zAw41T0SG4xgEmNgCeWnSlWJt8tKkck5BhqoZEZF2yi7T1qXcS2VqD2TFSV2my3HOwo4dOyI7OxsnTpzAgwcPULduXTg5OSE4OBgjRozAw4cPcfDgQXh5eaF27doAgFOnTiEqKgrnzp3DgwcPVK0ot27dQoMGDVTr1tTaoGwBA6SuWNWrV1drIXBxcQEArfcHCSF0/mxbtmzBl19+ibi4OGRlZaGgoAC2traq18+ePYvRo0eXuI6i9ZXJZHB1dVXV7dy5c7h27RpsbGzU3vPw4UOtA5Pk5uYCAMzNzUvcli6x+eeff3DgwAFYW1sXW1dcXBzq1q2Lq1evYubMmTh+/DhSUlLUvquGDRtq3Labm5tqO35+fjA2NoaPj4/Gz1MR8vPzER4eDiEEvv76a9VyIQTeffddODs749ChQ7CwsMCaNWvQo0cPnDhxQvW5lGJiYnDp0iVs3Lix2DY8PT3VBqNxcXGBkZGRWmuri4uL6rvo168flixZAi8vL3Tp0gVdu3ZFjx49YGz8OB2ysLCAQqHAo0ePYGFhUa4xUWK3QyIyHGtPwLk9kJcMKPI1l1HkA3kpgHMwYFU1b3QmoudMBXeZ9vHxQa1atXDgwAEcOHAAwcHBAIAaNWrA3d0dR48exYEDB/DSSy8BkLqxhYaGwtbWFt999x1OnDiBn3/+GQCKdbWzsrIqtj0TE/UBkWQymdoymUwGAFpHhatbty4A4PLlyyV+rpiYGAwePBhdu3bFzp07cebMGUyfPl2tjrqcAGuqr7JuWVlZaNasGc6ePav2uHLlCgYNGqRxfY6OjgCABw8e6LStkmKTnZ2NHj16FNv+1atX0aFDBwBAjx49kJqaitWrV+P48eOqbnJPflclbacs3Q4dHR1hZGSEe/fuqa3/3r17cHV11RgTAHB1ddXpPcrE6+bNm4iOjlZLpvfv34+dO3di8+bNaNu2LZo2bYrly5fDwsICGzZsKLbNNWvWIDAwUONFgtK+C+UyZYzc3d3x77//qrY3ZswYdOjQQe0ew9TUVFhZWekt8QI4yTIRGVr9iUDWdeneCFMnwMRBWi4UQN4DKfGyawDUj6jYehIRKRlbSccooSg5AVOWMS7eyvGsOnXqhIMHD+LBgweYNGmSanmHDh3w+++/4++//8Y777wDQEp67t+/j08//RTu7u4AYNDh3QMDA9GgQQMsXLgQ/fv3L3bfV1paGuzt7XH06FF4eHioDed+8+ZNtbKNGjXCvn37MGLEiKeqS9OmTbFlyxY4OzurJQEl8fb2hq2tLS5evKhKJJ9WYGAgtm/fDk9PT7UWFqX79+/j33//xerVq9G+fXsAwOHDh8u8nRo1auDs2bMllqlWTepxYmpqimbNmmHfvn0ICwsDICVx+/btw9ixY7W+PygoCPv27cMHH3ygWhYdHY2goMe9VJSJ19WrV3HgwAFUr15dbR3Ke+Ge3CfkcnmxZD4rKwtbt27FvHnzSvxcZWFhYYEePXqgR48eePfdd+Hn54fz58+jadOmAKTBUZo0aVJu29Okwlu+yjrHQEnzCwDS6Cd+fn6wsrKCg4MDQkJCVFcQlEqbX4CI9MjCDWixHKjZCxD5UiL2MEH6V+QDNXtKr1u4lb4uIiJDKNpluiR67DLdqVMnHD58GGfPnlW1fAFAcHAwVq5ciby8PNVgG7Vr14apqSm++uorXL9+HTt27MCcOXPKvU7ayGQyrFu3DleuXEH79u3x22+/4fr16/jnn3/w8ccfo1evXgAAX19f3Lp1C5s3b0ZcXBy+/PJLVQudUmRkJL7//ntERkbi0qVLOH/+PD777DOd6zJ48GA4OjqiV69eOHToEG7cuIGDBw/ivffew+3btzW+Rzn4xNMkQU965513kJqaioEDB+LEiROIi4vDnj17MGLECBQWFsLBwQHVq1fHqlWrcO3aNezfvx8REWW/+KjsdljSQ5l8AUBERARWr16NDRs24NKlS3jnnXdUozYqDR06FNOmTVM9f//997F7924sXLgQly9fRlRUFE6ePKlK2PLz89G3b1+cPHkS3333HQoLC5GYmIjExERVK15QUBAcHBwwbNgwnDt3DleuXMGkSZNw48YNdOvWTe0zbdmyBQUFBXj99dfLHA9N1q9fj7Vr1+LChQu4fv06/ve//8HCwkJtOoFDhw6hc+fO5bI9bSo0+SrrHAOlzS8ASE3dS5cuxfnz53H48GF4enqic+fOSE5OVpUpbX4BItIzCzeg6Xyg3VYgYCZQK0z6t/02aTkTLyKqTCpBl+lOnTohNzcXPj4+qvuKACn5yszMVA1JDwBOTk5Yv349tm3bhgYNGuDTTz/FggULyr1OJWnZsiVOnjwJHx8fjB49GvXr10fPnj0RGxuLJUuWAAB69uyJ8ePHY+zYsQgMDMTRo0fx0Ucfqa2nY8eO2LZtG3bs2IHAwEC89NJLOk0GrGRpaYm//voLtWvXRp8+fVC/fn2MHDkSDx8+LLElbNSoUdi8efMzT7hbo0YNHD58GIWFhejcuTMCAgLwwQcfwN7eHnK5HHK5HJs3b8apU6fQsGFDjB8/HvPnz3+mbeqif//+WLBgAWbOnInAwECcPXsWu3fvVtu3bt26hYSEx1MntGnTBps2bcKqVavQuHFj/PDDD9i+fbvqvrQ7d+5gx44duH37NgIDA+Hm5qZ6HD16FIDU5XH37t3IysrCSy+9hObNm+Pw4cP45Zdf0LhxY7U6rl27Fn369FEbHfNZ2NvbY/Xq1Wjbti0aNWqEvXv34tdff1W1zt25cwdHjx596lZWXclEWe6KLGetWrVCixYtVPMDKBQKuLu7Y9y4cZg6dWqx8v3790d2djZ27typWta6dWsEBgZixYoVGreRkZEBOzs77N27Fy+//DJSUlLg5OSEv/76S9W8m5mZCVtbW0RHRxcbQlMb5XrT09N1bsbWF4VCgaSkJDg7O2sc0pWeDeOrX4yvfjG++sX46ld5x/fhw4e4ceMG6tSpo3EwhRIp5/lSdpk2tZe6IAqF1OKl7DL9HLXci/+fWNnY2Fh1DxFJhBBo1aoVxo8fj4EDBz71Ohhf/SrPGE+ZMgUPHjwoNk9cUSUdQ3TNDSrsni/lHANFmzNLm2MgJiamWFNsaGgotm/frnUbq1atgp2dnSqbLjq/QNOmTWFmZlbq/AIA8OjRIzx69Ej1PCMjA4D0H8OzXhV5VgqFAkKICq9HVcX46hfjq1+Mr34xvvpV3vFVrk/5KBNzV6D5MuDyIiDpL2lUQ2XyZWIL1OwB+EVI5SruunaZKeNQgdfiK62VK1fi/PnzzxQbxlf/yivGTk5OGD9+fInrUR47NJ3/63qcqrDkKyUlBYWFhWrNm4A0JKS20XESExM1ln+yu+DOnTsxYMAA5OTkwM3NDdHR0aqRa2QyGfbu3YuwsDDY2NhALpfD2dkZu3fvhoODg9b6zps3D7NmzSq2PDk5GQ8fPtTpM+uLQqFAeno6hBC88qoHjK9+Mb76xfjqF+OrX+Ud3/z8fCgUChQUFKiGpy4TEycgYB6QHQ/Z/ePSKIjGVhDVWz/uavg0660gQggUFhYCAFtmNGjYsCEaNmz4dPsKGF9DKM8Yv//++wBQ4vddUFAAhUKB+/fvFxtZMTMzU6ftVMnRDjt16oSzZ88iJSUFq1evRnh4OI4fPw5nZ+cyzy+gNG3aNLVWt4yMDLi7u8PJyalSdDuUyWRwcnLif/56wPjqF+OrX4yvfjG++lXe8X348CEyMzNhbGysceQ5ndn5SI8q4smTSCpfjK/+GSrGxsbGkMvlqF69erFuh7p2Za6w5Otp5hjQdX4BKysr1cgurVu3hq+vL9auXYtp06ap5hd48OCBKmlavnw5oqOjsWHDBo33mgGAmZkZzMzMii1X3ixZ0WQyWaWpS1XE+OoX46tfjK9+Mb76VZ7xlcvlkMlkqseLTgihigPjUf4YX/0zdIyVxw5NxyRdj1EV9j9F0TkGlJRzDBSdL6Ao5fwCRT05v4AmypmqgbLNL0BERERERFReKvQyXWlzDJR1foHs7Gx8+OGHOHbsGG7evIlTp07hjTfewJ07d9CvXz8AZZtfgIiIiIiIqLxU6D1f/fv3R3JyMmbOnInExEQEBgaqzTFw69YttRYq5fwCM2bMwIcffghfX1+1+QWMjIxw+fJlbNiwASkpKahevTpatGiBQ4cOwd/fH8Dj+QWmT5+Ol156Cfn5+fD399c4vwAREREREVF5qdB5vp5nnOfrxcH46hfjq1+Mr34xvvpVqeb5qoI4D5V+Mb76Z+gYl8c8X/yfgoiIiIiIyACYfBERERG9AKKiohAYGFhimeHDhyMsLMwg9SnJ+vXrYW9vr5d1379/H87OzoiPj9fL+qly2b17NwIDAyvNwHpMvoiIiIjKID4e+P57YM0a6V9DnMMnJiZi3Lhx8PLygpmZGdzd3dGjR49io0AbghACq1atQqtWrWBtbQ17e3s0b94cS5YsUY0qXZl9/PHH6NWrFzw9PSu6Knpx69YtdOvWDZaWlnB2dsakSZNKnSg6NTUVgwcPhq2tLezt7TFy5EhkZWWpXv/333/RqVMnuLi4wNzcHF5eXpgxYwby8/NVZWJjY/Haa6/B09MTMpkMS5YsKbadqKgotekeZDIZ/Pz8yu2za9KlSxeYmJjgu+++0+t2dFUlJ1kmIiIiKm8JCcCCBcChQ0BGBiCXAwoFYGsLdOgATJgAuLmV/3bj4+PRtm1b2NvbY/78+QgICEB+fj727NmDd999F5cvXy7/jZZgyJAh+OmnnzBjxgwsXboUTk5OOHfuHJYsWQJPT89K0XKmTU5ODtauXYs9e/ZUdFX0orCwEN26dYOrqyuOHj2KhIQEDB06FCYmJvjkk0+0vm/w4MFISEhAdHQ08vPzMWLECLz55pvYtGkTAGkS46FDh6Jp06awt7fHuXPnMHr0aCgUCtV6c3Jy4OXlhX79+mH8+PFat+Xv74+9e/eqnj/ThOc6Gj58OL788ksMGTJE79sqlaCnkp6eLgCI9PT0iq6KKCwsFAkJCaKwsLCiq1IlMb76xfjqF+OrX4yvfpV3fHNzc8XFixdFbm5umd97964QYWFC+PoK0aaNEF27CtG9u/RvmzbS8rAwqVx5e/XVV0XNmjVFVlZWsdcePHig+vvmzZuiZ8+ewsrKStjY2Ih+/fqJxMRE1euRkZGicePGquf5+fni/fffF3Z2dqJatWpi0qRJYujQoaJXr15a67JlyxYBQGzfvr3YawqFQqSlpQkhhPj7779FSEiIqF69urC1tRUdOnQQp06dKlb3N998Uzg7OwszMzPh7+8vfv31VyGEEOvWrRN2dnZi9+7dws/PT1hZWYnQ0FBx94kAr169Wvj5+QkzMzNRr149sWzZMq11F0KIbdu2CScnJ7VlBw4cEADE7t27RWBgoDA3NxedOnUS9+7dE7/99pvw8/MTNjY2YuDAgSI7O1v1vsLCQvHJJ58IT09PYW5uLho1aiS2bdumFt/hw4erXq9bt65YsmSJ2raHDRsmevXqJebPny9cXV1FtWrVxJgxY0ReXl6Jn0Ob3377TcjlcrXv/euvvxa2trbi0aNHGt9z8eJFAUCcOHFCtez3338XMplM3LlzR+u2xo8fL9q1a6fxNQ8PD7F48eJiy5/cBzUBIFasWCG6desmLCwshJ+fnzh69Ki4evWqCA4OFpaWliIoKEhcu3ZNKBQKkZeXJ86cOSM6duworK2thY2NjWjatKna57l586YAIK5du1bitktT0jFE19yA3Q6JiIiISrFgARAbC3h5AdWqSa1egPRvtWrS8thYYNGi8t1uamoqdu/ejXfffRdWVlbFXlfeF6VQKNCrVy+kpqbizz//RHR0NK5fv47+/ftrXffChQvx7bffYu3atTh8+DBSU1Px888/l1if7777DvXq1UOvXr2KvSaTyWBnZwcAyMzMxLBhw3D48GEcO3YMvr6+6Nq1KzIzM1X1ffXVV3HkyBH873//w8WLF/Hpp5/CyMhItb6cnBwsWLAAGzduxF9//YVbt25h4sSJanWZOXMmPv74Y1y6dAmffPIJPvroI2zYsEFr/Q8dOoRmzZppfC0qKgpLly7F0aNH8d9//yE8PBxLlizBpk2bsGvXLvzxxx/46quvVOXnzZuHb7/9FitWrEBsbCzGjx+P119/HX/++afqM9asWRNbt27FxYsXMXPmTHz44YfYunWr2nYPHDiAuLg4HDhwABs2bMD69euxfv161etvv/02rK2tS3woxcTEICAgQDVtEwCEhoYiIyMDsbGxGj93TEyMquuoUkhICORyOY4fP67xPdeuXcPu3bsRHBysJdLaXb16FTVq1ICXlxcGDx6MW7duFSszZ84cDB06FGfPnoWfnx8GDRqEt956C9OmTcPJkychhFDN8wsAr7/+OmrVqoUTJ07g1KlTmDp1KkxMTFSv165dGy4uLjh06FCZ61ve2O2QiIiIqATx8VJXQycnoMj5nBoTE+n1P/+UypfX7UTXrl2DEKLU+2L27duH8+fP48aNG3B3dwcAfPvtt/D398eJEyfQokWLYu/54osvMHnyZPTp0wcymQwrVqwotTve1atXUa9evVLr/dJLL6k9X7VqFezt7fHnn3+ie/fu2Lt3L/7++29cunQJdevWBQB4eXmpvSc/Px8rVqyAt7c3AGDs2LGYPXu26vXIyEgsXLgQffr0AQDUqVMHFy9exMqVKzFs2DCN9bp58yZq1Kih8bW5c+eibdu2AICRI0di2rRpiIuLU9Wrb9++OHDgAKZMmYJHjx7hk08+wd69exEUFKSq/+HDh7Fy5UoEBwfDxMQEkZGRqmHQ69Spg5iYGGzduhXh4eGq7To4OGDp0qUwMjKCn58funXrhn379mH06NEAgNmzZ6slnSVJTExUS7wAqJ4nJiZqfY+zs7PaMmNjY1SrVq3Ye9q0aYPTp0/j0aNHePPNN9W+D120atUK69evR7169ZCQkIBZs2ahffv2uHDhAmxsbFTlRowYoYrRlClTEBQUhI8++gihoaEAgPfffx8jRoxQlb916xYmTZqk+p34+voW23aNGjVw8+bNMtVXH5h8EREREZUgJka6x+v/cwCt7O2BuDjg2LHyS76EjtOxXrp0Ce7u7qrECwAaNGgAe3t7XLp0qVjylZ6ejoSEBLRs2VK1zNjYGM2bNy9xm7rW5969e5gxYwYOHjyIpKQkFBYWIicnR9XKcfbsWdSqVUuVeGliaWmpSrwAwM3NDUlJSQCA7OxsxMXFYeTIkaokBQAKCgpUrW+a5Obmap3jrVGjRqq/XVxcYGlpqZYQuri44O+//wYgJcU5OTl45ZVX1NaRl5eHJk2aqJ5//fXX2LBhA27duoXc3Fzk5eUVG3HS399frcXPzc0N58+fVz13dnYulhxVlC1btiAzMxPnzp3DpEmTsGDBAkyePFnn97/66quqvxs1aoRWrVrBw8MDW7duxciRI9VeU1ImjwEBAWrLHj58iIyMDFhaWmL8+PEYNWoUNm7ciJCQEPTr109t3wEACwuLSjEgDJMvIiIiohJkZ0vdC0ub51lZpsggcc/M19cXMpnM4INqaFO3bl2d6jJs2DDcv38fX3zxBTw8PGBmZoagoCDk5eUBkE6ES2PyRDOjTCZTJX/KkfhWr16NVq1aqZUrmsg8ydHREQ8ePCh1ezKZTOP2lcOVK7e/a9cu1KxZU62cmZkZAGDz5s2YMmUKFixYgDZt2sDGxgbz588v1pWvpO0AUrfD//3vf1o/U9H6uLq6qhJEpXv37qle08TV1VWV1CoVFBQgNTW12HuUyX2DBg1QWFiIN998ExMmTCgx5iWxt7dH3bp1ce3aNbXlT34X2pYp4xQVFYXBgwdj165d+P333xEZGYnNmzejd+/eqvekpqbCycnpqepZnnjPFxEREVEJrKykUQ1LmyZIWabILTjPrFq1aggNDcWyZcuQnZ1d7PW0tDQAQP369fHff//hv//+U7128eJFpKWloUGDBsXeZ2dnBzc3N7UT9YKCApw6darE+gwaNAhXrlzBL7/8Uuw1IQTS09MBAEeOHMF7772Hrl27wt/fH2ZmZkhJSVGVbdSoEW7fvo0rV66UHAAtXFxcUKNGDVy/fh0+Pj5qjzp16mh9X5MmTXDx4sWn2mZRDRo0gJmZGW7dulVs+8oE5ciRIwgKCsKYMWPQpEkT+Pj4IC4urszbmj17Ns6ePVviQykoKAjnz59XS6aio6Nha2urcT9QvictLU3tu9+/fz8UCkWxxLYohUKB/Pz8Z5o/KysrC3FxcXArh2FC69ati/Hjx+OPP/5Anz59sG7dOtVrDx8+RFxcnFqrZEVhyxcRERFRCYKCpOHk09KkwTW0SUuTyv3/LUDlZtmyZWjbti1atmyJ2bNno1GjRigoKEB0dDS+/vprXLp0CSEhIQgICMDgwYOxZMkSFBQUYMyYMQgODlYbSKGo9957D/Pnz0e9evVQv359LFq0SJXMaRMeHo6ff/4ZAwcOxIwZM9C5c2c4OTnh/PnzWLx4McaNG4ewsDD4+vpi48aNaN68OTIyMjBp0iS11q7g4GB06NABr732GhYtWgQfHx9cvnwZMpkMXbp00Skus2bNwnvvvQc7Ozt06dIFjx49wsmTJ/HgwQNERERofE9oaCimTZuGBw8ewMHBQaftaGJjY4OJEydi/PjxUCgUaNeuHdLT03HkyBHY2tpi2LBhqhjs2bMHXl5e2LhxI06cOFFicqhJWboddu7cGQ0aNMCQIUPw+eefIzExETNmzMC7776rapH7+++/MXToUOzbtw81a9ZE/fr10aVLF4wePRorVqxAfn4+xo4diwEDBqjuj/vuu+9gYmKCgIAAmJmZ4eTJk5g2bRr69++vapHKy8tTJbZ5eXm4c+cOzp49C2tra/j4+AAAJk6ciB49esDDwwN3795FZGQkjIyMMHDgwDLFpKjc3FxMmzYN/fr1Q506dXD79m2cOHECr732mqrMsWPHVK2vFY0tX0REREQl8PQE2rcHkpOBInPKqsnPB1JSgOBgwMOjfLfv5eWF06dPo1OnTpgwYQIaNmyIV155Bfv27cPXX38NQOqG9csvv8DBwQEdOnRASEgIvLy8sGXLFq3rnTBhAgYPHozhw4cjKCgINjY2at20NJHJZNi0aRMWLVqE7du3Izg4GI0aNUJUVBR69eqlGhBh7dq1ePDgAZo2bYohQ4bgvffeK5ZA/Pjjj2jRogUGDhyIBg0aYPLkySgsLNQ5LqNGjcKaNWuwbt06BAQEIDg4GOvXry8xuQkICEDTpk2LjTj4NObMmYOPPvoI8+bNUyUwu3btUm3/rbfeQlhYGAYMGIBWrVrh/v37GDNmzDNvtyRGRkbYuXMnjIyMEBQUhNdffx1Dhw5VGxgjJycH//77r9oEyd999x38/Pzw8ssvo2vXrmjXrh1WrVqlet3Y2BifffYZWrZsiUaNGmHWrFkYO3Ys1qxZoypz9+5dNGnSBE2aNEFCQgIWLFiAJk2aYNSoUaoyt2/fxsCBA1GvXj2Eh4ejevXqOHbs2DN1BzQyMkJqaiqGDh2KunXrIjw8HK+++ipmzZqlKvP9999j8ODBsLS0fOrtlBeZ0PXOSVKTkZEBOzs7pKenw9bWtkLrolAokJSUBGdnZ8hL65BOZcb46hfjq1+Mr34xvvpV3vF9+PAhbty4gTp16mgddEGbhARgzBhpOHknJ2lwDeUky2lpUuLVoAGwfLl+JlrWByEECgoKVKPxvSh27dqFSZMm4cKFC3r93b6o8TUkXWKckpKCevXq4eTJk2VudXxSSccQXXMDdjskIiIiKoWbm5RYLVokDScfF/c4+bK1BXr2BCIinp/E60XWrVs3XL16FXfu3FEbHZKqpvj4eCxfvvyZE6/ywuSLiIiISAdubsD8+dI8XseOSaMaWltL93iVd1dD0q8PPvigoqtABtK8eXOt9z1WBCZfRERERGXg6Vl+83gR0YuFHdSJiIiIiIgMgMkXERERvVA41hgRPY3yOHYw+SIiIqIXgpGREQBpDiIiorLKyckBANXcZk+D93wRERHRC8HY2BiWlpZITk6GiYnJCz89AIdC1y/GV/8MFWMhBHJycpCUlAR7e3vVhZynweSLiIiIXggymQxubm64ceMGbt68WdHVqXBCCCgUCsjlciYHesD46p+hY2xvbw9XV9dnWgeTLyIiInphmJqawtfXl10PIU1iff/+fVSvXv2FbwXUB8ZX/wwZYxMTk2dq8VJi8kVEREQvFLlcDnNz84quRoVTKBQwMTGBubk5kwM9YHz173mM8fNRSyIiIiIiouccky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjKACk++li1bBk9PT5ibm6NVq1b4+++/Syy/bds2+Pn5wdzcHAEBAfjtt9/UXo+KioKfnx+srKzg4OCAkJAQHD9+vNh6du3ahVatWsHCwgIODg4ICwsrz49FRERERESkpkKTry1btiAiIgKRkZE4ffo0GjdujNDQUCQlJWksf/ToUQwcOBAjR47EmTNnEBYWhrCwMFy4cEFVpm7duli6dCnOnz+Pw4cPw9PTE507d0ZycrKqzI8//oghQ4ZgxIgROHfuHI4cOYJBgwbp/fMSEREREdGLSyaEEBW18VatWqFFixZYunQpAEChUMDd3R3jxo3D1KlTi5Xv378/srOzsXPnTtWy1q1bIzAwECtWrNC4jYyMDNjZ2WHv3r14+eWXUVBQAE9PT8yaNQsjR4586ror15ueng5bW9unXk95UCgUSEpKgrOzM+TyCm/MrHIYX/1ifPWL8dUvxle/GF/9Ynz1i/HVv8oUY11zA2MD1klNXl4eTp06hWnTpqmWyeVyhISEICYmRuN7YmJiEBERobYsNDQU27dv17qNVatWwc7ODo0bNwYAnD59Gnfu3IFcLkeTJk2QmJiIwMBAzJ8/Hw0bNtRa30ePHuHRo0eq5xkZGQCkL12hUOj0mfVFoVBACFHh9aiqGF/9Ynz1i/HVL8ZXvxhf/WJ89Yvx1b/KFGNd61BhyVdKSgoKCwvh4uKittzFxQWXL1/W+J7ExESN5RMTE9WW7dy5EwMGDEBOTg7c3NwQHR0NR0dHAMD169cBSPeGLVq0CJ6enli4cCE6duyIK1euoFq1ahq3PW/ePMyaNavY8uTkZDx8+FC3D60nCoUC6enpEEJUeNZfFTG++sX46hfjq1+Mr34xvvrF+OoX46t/lSnGmZmZOpWrsORLnzp16oSzZ88iJSUFq1evRnh4OI4fPw5nZ2dVVjp9+nS89tprAIB169ahVq1a2LZtG9566y2N65w2bZpaq1tGRgbc3d3h5ORUKbodymQyODk5VfiOVxUxvvrF+OoX46tfjK9+Mb76xfjqF+Orf5Upxubm5jqVq7Dky9HREUZGRrh3757a8nv37sHV1VXje1xdXXUqb2VlBR8fH/j4+KB169bw9fXF2rVrMW3aNLi5uQEAGjRooCpvZmYGLy8v3Lp1S2t9zczMYGZmVmy5XC6v8C8bAGQyWaWpS1XE+OoX46tfjK9+Mb76xfjqF+OrX4yv/lWWGOu6/QqrpampKZo1a4Z9+/aplikUCuzbtw9BQUEa3xMUFKRWHgCio6O1li+6XuX9Ws2aNYOZmRn+/fdf1ev5+fmIj4+Hh4fH034cIiIiIiKiElVot8OIiAgMGzYMzZs3R8uWLbFkyRJkZ2djxIgRAIChQ4eiZs2amDdvHgDg/fffR3BwMBYuXIhu3bph8+bNOHnyJFatWgUAyM7Oxscff4yePXvCzc0NKSkpWLZsGe7cuYN+/foBAGxtbfH2228jMjIS7u7u8PDwwPz58wFAVYaIiIiIiKi8VWjy1b9/fyQnJ2PmzJmqUQd3796tGlTj1q1bak14bdq0waZNmzBjxgx8+OGH8PX1xfbt21WjFBoZGeHy5cvYsGEDUlJSUL16dbRo0QKHDh2Cv7+/aj3z58+HsbExhgwZgtzcXLRq1Qr79++Hg4ODYQNAREREREQvjAqd5+t5xnm+XhyMr34xvvrF+OoX46tfjK9+Mb76xfjqX2WKsa65AfcEIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIygEqRfC1btgyenp4wNzdHq1at8Pfff5dYftu2bfDz84O5uTkCAgLw22+/qb0eFRUFPz8/WFlZwcHBASEhITh+/LjGdT169AiBgYGQyWQ4e/ZseX0kIiIiIiIiNRWefG3ZsgURERGIjIzE6dOn0bhxY4SGhiIpKUlj+aNHj2LgwIEYOXIkzpw5g7CwMISFheHChQuqMnXr1sXSpUtx/vx5HD58GJ6enujcuTOSk5OLrW/y5MmoUaOG3j4fERERERERUAmSr0WLFmH06NEYMWIEGjRogBUrVsDS0hLffPONxvJffPEFunTpgkmTJqF+/fqYM2cOmjZtiqVLl6rKDBo0CCEhIfDy8oK/vz8WLVqEjIwM/PPPP2rr+v333/HHH39gwYIFev2MRERERERExhW58by8PJw6dQrTpk1TLZPL5QgJCUFMTIzG98TExCAiIkJtWWhoKLZv3651G6tWrYKdnR0aN26sWn7v3j2MHj0a27dvh6WlZal1ffToER49eqR6npGRAQBQKBRQKBSlvl+fFAoFhBAVXo+qivHVL8ZXvxhf/WJ89Yvx1S/GV78YX/2rTDHWtQ4VmnylpKSgsLAQLi4uastdXFxw+fJlje9JTEzUWD4xMVFt2c6dOzFgwADk5OTAzc0N0dHRcHR0BAAIITB8+HC8/fbbaN68OeLj40ut67x58zBr1qxiy5OTk/Hw4cNS369PCoUC6enpEEJALq/wxswqh/HVL8ZXvxhf/WJ89Yvx1S/GV78YX/2rTDHOzMzUqVyFJl/61KlTJ5w9exYpKSlYvXo1wsPDcfz4cTg7O+Orr75CZmamWotbaaZNm6bW4paRkQF3d3c4OTnB1tZWHx9BZwqFAjKZDE5OThW+41VFjK9+Mb76xfjqF+OrX4yvfjG++sX46l9lirG5ublO5So0+XJ0dISRkRHu3buntvzevXtwdXXV+B5XV1edyltZWcHHxwc+Pj5o3bo1fH19sXbtWkybNg379+9HTEwMzMzM1N7TvHlzDB48GBs2bCi2XTMzs2LlAambZEV/2QAgk8kqTV2qIsZXvxhf/WJ89Yvx1S/GV78YX/1ifPWvssRY1+1XaC1NTU3RrFkz7Nu3T7VMoVBg3759CAoK0vieoKAgtfIAEB0drbV80fUq79n68ssvce7cOZw9exZnz55VDVW/ZcsWfPzxx8/ykYiIiIiIiDSq8G6HERERGDZsGJo3b46WLVtiyZIlyM7OxogRIwAAQ4cORc2aNTFv3jwAwPvvv4/g4GAsXLgQ3bp1w+bNm3Hy5EmsWrUKAJCdnY2PP/4YPXv2hJubG1JSUrBs2TLcuXMH/fr1AwDUrl1brQ7W1tYAAG9vb9SqVctQH52IiIiIiF4gFZ589e/fH8nJyZg5cyYSExMRGBiI3bt3qwbVuHXrllozXps2bbBp0ybMmDEDH374IXx9fbF9+3Y0bNgQAGBkZITLly9jw4YNSElJQfXq1dGiRQscOnQI/v7+FfIZiYiIiIiIZEIIoWthhUKBP//8E4cOHcLNmzeRk5MDJycnNGnSBCEhIXB3d9dnXSuVjIwM2NnZIT09vVIMuJGUlARnZ+cK7+9aFTG++sX46hfjq1+Mr34xvvrF+OoX46t/lSnGuuYGOtUyNzcXc+fOhbu7O7p27Yrff/8daWlpMDIywrVr1xAZGYk6deqga9euOHbsWLl9CCIiIiIioqpCp26HdevWRVBQEFavXo1XXnkFJiYmxcrcvHkTmzZtwoABAzB9+nSMHj263CtLRERERET0vNIp+frjjz9Qv379Est4eHhg2rRpmDhxIm7dulUulSMiIiIiIqoqdOp2WFriVZSJiQm8vb2fukJERERERERVUZnvTNu9ezcOHz6ser5s2TIEBgZi0KBBePDgQblWjoiIiIiIqKooc/I1adIkZGRkAADOnz+PCRMmoGvXrrhx4wYiIiLKvYJERERERERVQZnn+bpx4wYaNGgAAPjxxx/RvXt3fPLJJzh9+jS6du1a7hUkIiIiIiKqCsrc8mVqaoqcnBwAwN69e9G5c2cAQLVq1VQtYkRERERERKSuzC1f7dq1Q0REBNq2bYu///4bW7ZsAQBcuXIFtWrVKvcKEhERERERVQVlbvlaunQpjI2N8cMPP+Drr79GzZo1AQC///47unTpUu4VJCIiIiIiqgrK3PJVu3Zt7Ny5s9jyxYsXl0uFiIiIiIiIqqIyJ19KSUlJSEpKgkKhUFveqFGjZ64UERERERFRVVPm5OvUqVMYNmwYLl26BCEEAEAmk0EIAZlMhsLCwnKvJBERERER0fOuzMnXG2+8gbp162Lt2rVwcXGBTCbTR72IiIiIiIiqlDInX9evX8ePP/4IHx8ffdSHiIiIiIioSirzaIcvv/wyzp07p4+6EBERERERVVllbvlas2YNhg0bhgsXLqBhw4YwMTFRe71nz57lVjkiIiIiIqKqoszJV0xMDI4cOYLff/+92GsccIOIiIiIiEizMnc7HDduHF5//XUkJCRAoVCoPZh4ERERERERaVbm5Ov+/fsYP348XFxc9FEfIiIiIiKiKqnMyVefPn1w4MABfdSFiIiIiIioyirzPV9169bFtGnTcPjwYQQEBBQbcOO9994rt8oRERERERFVFU812qG1tTX+/PNP/Pnnn2qvyWQyJl9EREREREQalDn5unHjhj7qQUREREREVKWV+Z4vIiIiIiIiKjudkq9PP/0Uubm5Oq3w+PHj2LVr1zNVioiIiIiIqKrRKfm6ePEiateujTFjxuD3339HcnKy6rWCggL8888/WL58Odq0aYP+/fvDxsZGbxUmIiIiIiJ6Hul0z9e3336Lc+fOYenSpRg0aBAyMjJgZGQEMzMz5OTkAACaNGmCUaNGYfjw4TA3N9drpYmIiIiIiJ43Og+40bhxY6xevRorV67EP//8g5s3byI3NxeOjo4IDAyEo6OjPutJRERERET0XCvzaIdyuRyBgYEIDAzUQ3WIiIiIiIiqJo52SEREREREZABlbvkiosorPh6IiQGyswErKyAoCPD0rOhaERERERHA5IuoSkhIABYsAA4dAjIyALkcUCgAW1ugQwdgwgTAza2ia0lERET0YmPyRfScS0gAxowBYmMBJyfA2/tx8pWWBuzYAcTFAcuXMwEjIiIiqkhPfc/XtWvXsGfPHtXky0KIcqsUEeluwQIp8fLyAqpVkxIvQPq3WjVpeWwssGhRxdaTiIiI6EVX5uTr/v37CAkJQd26ddG1a1ckJCQAAEaOHIkJEyaUewWJSLv4eKmroZMTYGKiuYyJifT6n39K5YmIiIioYpQ5+Ro/fjyMjY1x69YtWFpaqpb3798fu3fvLtfKEVHJYmKke7zs7UsuZ28vlTt2zBC1IiIiIiJNynzP1x9//IE9e/agVq1aast9fX1x8+bNcqsYEZUuO1vqXigv5TKKskxWlmHqRURERETFlbnlKzs7W63FSyk1NRVmZmblUiki0o2VlTSwhkJRcjllGWtrw9SLiIiIiIorc/LVvn17fPvtt6rnMpkMCoUCn3/+OTp16lSulSOikgUFScPJp6WVXC4tTSoXFGSIWhERERGRJmXudvj555/j5ZdfxsmTJ5GXl4fJkycjNjYWqampOHLkiD7qSERaeHoC7dsDv/4K2NhoHnQjPx9ISQF69gQ8PAxeRSIiIiL6f2Vu+WrYsCGuXLmCdu3aoVevXsjOzkafPn1w5swZeHt766OORFSCiRMBf3/g+nUgNfVxF0SFQnp+4wbQoAEQEVGx9SQiIiJ60T3VJMt2dnaYPn16edeFiJ6Cm5s0gfKiRdJw8nFxjydZtrWVWrwiIjjBMhEREVFFe6rk6+HDh/jnn3+QlJQExRN3+vfs2bNcKkZEunNzA+bPl+bxOnZMGtXQ2lq6x4tdDYmIiIgqhzInX7t378bQoUORkpJS7DWZTIbCwsJyqRgRlZ2np/QgIiIiosqnzMnXuHHj0K9fP8ycORMuLi76qBMRERGVs/h4aWL27GxpmoqgIF6soecH91+qKsqcfN27dw8RERFMvIiIiJ4DCQnAggXAoUNARob6PaEdOgATJvCeUKq8uP9SVVPm5Ktv3744ePAgRzYkIiKq5BISgDFjgNhYwMkJ8PZ+fPKalgbs2CEN0rN8OU9gqfLh/kslUbaG5udLU+08L62hZU6+li5din79+uHQoUMICAiAyRMTC7333nvlVjkiIiJ6egsWSCeuXl7q8wDK5UC1atL8gLGx0mip8+dXXD2JNOH+S5oUbQ3NygL8/IDLl6WBxp6H1tAyJ1/ff/89/vjjD5ibm+PgwYOQyWSq12QyGZMvIqqyeM8BPU/i46WTEycnzROwA9JyJydpmor4eO7PVHlw/yVNnmwN9fKSEq28PODBg+ejNbTMydf06dMxa9YsTJ06FXJ5medoJiJ67vCeA3oexcRI+2tpdwnY20snK8eO8eSVKg/uv6TJk62hyjag56k1tMzJV15eHvr378/Ei14Iz2t/Yio/vOeAnlfZ2dK+Wtp/18oyWVmGqReRLrj/0pOqSmtomTOoYcOGYcuWLfqoC1GlkZAgtWaEhwNz5gDbt0v/hocDEydKr9OLoehVtmrVHp8IKK+yeXk9vspGVJlYWUkXCRSKksspy1hbG6ZeRLrg/ktPUraG2tuXXM7eXip37JghalV2ZU6+CgsL8fnnnyM4OBjjxo1DRESE2uNpLFu2DJ6enjA3N0erVq3w999/l1h+27Zt8PPzg7m5OQICAvDbb7+pvR4VFQU/Pz9YWVnBwcEBISEhOH78uOr1+Ph4jBw5EnXq1IGFhQW8vb0RGRmJvLy8p6o/VS3Klo5ff5WuoCj7EyubuHfskF5nAlb1Pc1VNqLKIihI6hqbllZyubQ0qVxQkCFqRaQb7r/0pKrSGlrm5Ov8+fNo0qQJ5HI5Lly4gDNnzqgeZ8+eLXMFtmzZgoiICERGRuL06dNo3LgxQkNDkZSUpLH80aNHMXDgQIwcORJnzpxBWFgYwsLCcOHCBVWZunXrYunSpTh//jwOHz4MT09PdO7cGcnJyQCAy5cvQ6FQYOXKlYiNjcXixYuxYsUKfPjhh2WuP1U9bOkgpapylY1eTJ6eQPv2QHKy1HVak/x8ICUFCA4GPDwMWj2iEnH/pSdVldZQmRBCVGQFWrVqhRYtWmDp0qUAAIVCAXd3d4wbNw5Tp04tVr5///7Izs7Gzp07Vctat26NwMBArFixQuM2MjIyYGdnh7179+Lll1/WWGb+/Pn4+uuvcf36dZ3qrVxneno6bG1tdXqPvigUCiQlJcHZ2Zn34j2j+Hipa6GJiZRoAYBMpoC7exL++88ZQkjxTU2VDvpbt1bO/sTPk8q8/65ZIyXZukxrGBcHREQAo0bpv15lUZnjWxVU9vg+ec+ivb36PYspKUCDBpX3nsXKHt/nXWWPL/dfKqqs52jbthk2Kdc1NyjzgBvlKS8vD6dOncK0adNUy+RyOUJCQhATE6PxPTExMcW6N4aGhmL79u1at7Fq1SrY2dmhcePGWuuSnp6OaspvUoNHjx7h0aNHqucZGRkApB+WorQUXM8UCgWEEBVej6ogJkZqpvbyejyCjkymgEwmIJM9jq+DA3D9utTSUbt2BVW2iqjM+6+VlfSvECV3c1BW3dq69CtyhlaZ41sVVPb4urgAy5YBixcDf/0F3Ljx+OTVxgbo2RMYP14qVxk/QmWP7/OusseX+y8VVbu21Bq6a5fU1VQa7VD9HC0/X0q+uncH3N0Nu1/o+j3rlHz16dMH69evh62tLfr06VNi2Z9++kmnDQNASkoKCgsL4eLiorbcxcUFly9f1viexMREjeUTExPVlu3cuRMDBgxATk4O3NzcEB0dDUdHR43rvHbtGr766issWLBAa13nzZuHWbNmFVuenJyMhw8fan2fvt27B/z7rwIFBekwNhaoV0+OJ8JDZZCfL03Wp34FTQFHx3RIjcSPz8BNTaV5JbT0kCUdKRQKpKdL8a1sVwYbNACaNAGMjKT/6LXJzATs7KTylW1/qMzxrQqeh/jK5dIAQq+/Dvz7L/DwIWBuLh3rnJ2lMpVtv1V6HuL7PHse4sv9l4oaOVI697p1S/p/19paOkdTKASysuTIyABCQoARIwy/X2RmZupUTqfky87OTjWZsp2d3dPXyoA6deqEs2fPIiUlBatXr0Z4eDiOHz8OZ+Uv9f/duXMHXbp0Qb9+/TB69Git65s2bZpai1tGRgbc3d3h5ORUId0OExOBhQuBw4eB7GwF6tWT4d9/nWBlJUf79lL3J1dXg1fruWdiIs2Snpf3uKVDuqoiw+3bTqombYVCavkyNX188Keno1BI8XVycqp0/zk5O0u/o127gDp1NA+6kZ8vdYXo3h1o2NDgVSxVZY5vVfA8xdfZGQgIqOhalM3zFN/n0fMUX+6/BEj7wbRpj1tDnzwH7tBBag2tiHNgc3NzncrplHytW7cOs2fPxsSJE7Fu3bpnqlhRjo6OMDIywr1799SW37t3D65aoubq6qpTeSsrK/j4+MDHxwetW7eGr68v1q5dq9bF8e7du+jUqRPatGmDVatWlVhXMzMzmJmZFVsul8sN/oNKSADeffdxH2hPT8DVVYZHj+R48EDOeYeeQVCQ1HXswYPH/YkBQAgZhJCrkq8HD6RyQUGlj7pDpZPJZBXyW9LFxIlSol3aPQcREZV3X6jM8a0KGF/9Ynz1i/HVL8a3/NWoIU2gHB8v3f6RlyeDqakcQUHyCh14RdfvWOc9YdasWcgq5zEbTU1N0axZM+zbt0+1TKFQYN++fQjSMmZoUFCQWnkAiI6O1lq+6HqL3rN1584ddOzYEc2aNcO6deueqx8FR+PTH46uRE9yc5MuZPTqJX33cXGPH/n50j0HvNBBRERkWJ6e0gAcnTtL/z4v52Q6D7ihr0ERIyIiMGzYMDRv3hwtW7bEkiVLkJ2djREjRgAAhg4dipo1a2LevHkAgPfffx/BwcFYuHAhunXrhs2bN+PkyZOqlqvs7Gx8/PHH6NmzJ9zc3JCSkoJly5bhzp076NevH4DHiZeHhwcWLFigGoIegNYWt8qiqszuXZk92dLh4CAtVyikFq+iLR30YnBzU7/KlpX1uOWzMh/s4+OlQWTy86XjQlAQjwdEREQVqUyjHSrv+ypP/fv3R3JyMmbOnInExEQEBgZi9+7dqkE1bt26pdYq1aZNG2zatAkzZszAhx9+CF9fX2zfvh0N//9mCyMjI1y+fBkbNmxASkoKqlevjhYtWuDQoUPw9/cHILWUXbt2DdeuXUOtWrXU6lPBI++XSjnvUGlDX9vbS1fmjx3jyVZZKVs6Fi2SEljlvV3Xr0sn3D17SokXWzpePJ6ez8fvKSFBaiE/dEhKFP38pHsZra2BDh2km9e5/xIRERmezvN8yeVytYE3tElNTS2XilV2FTXPl6Z5hzTNcQBU3nmHnidSS4cCeXlJMDV1rvD+xFUR50EpX0/Oi+PgoICHRxJu3nTGgwdyJCcD/v7sKlleuP/qF+OrX4yvfjG++leZYqyXeb5mzZr13Ix2WFUVnd27tHmHKvPs3s8LT09pXomkJGmEHR47qbIrek+oNAeKtFx5T6iNzeN7QufPr9i6EhERvWjKlHwNGDCg2FDtZFhBQdLEcmlp6qPxPSktTSpXyjgkRFSF8J5QIiKiyk3n6/j6uN+Lyo6j8RGRNsp7Qu3tSy5nby+VO3bMELUiIqLnQXw88P330i0u338vPafyV+GjHVLZcTQ+ItIkO1vqXlha91hlmXKePYSoXHG0TiLDKDpIU0bG47ksbW05SJM+6Jx8KRQKfdaDyoCj8RGRJrwnlKoCjtZJZDhPDtLk7f04+UpLA3bskAZw4yBN5adM93xR5fHkvEN5eVICVtnnHSIi/eE9ofS8e/JE0MtL+v8uL0/q2cETQaLy9eQgTUocpEl/OHbbc+55nd2biMof7wml513RE8Fq1R634CpPBL28Hp8IEtGzeZpBmujZMfkiIqpCJk6U5vG6fh1ITZW6jgDSv6mpwI0bvCeUKieeCBIZFgdpqhjsdviM8vKkx5PkcsDYWL2cNjKZ+n80ZSmbnw8UFj6uR9H7PDSV1TZuSlnKAlIXx6cpW1Dw+GTwWcsWncNIX2ULC6XPpym+msoWFmpfr7Hx4/dXhrIKhRQLbYyMpIe+yypjqym+RcsKob01p6xli/4+9VUWKPm3rK9jhKOj+j2hcXHSduLipHvCunUD3n8fqF798UAGSjxGlL2stuOvtrIV/buvzMeIQ4eA9HTpnhMlIaT6KhSP9yFbW+niwuHDgLs7jxHAs59HaNt/eR7x7GWVxwht9+FW5DEiPV3adtEBzYXQ/F3IZFKX9aL3FFe28whNMTbkeURJv7uimHw9o4ULATOz4st9fYHBgx8/nz9f+5fo6QkMH/74+ZIlQE6O5rI1agBvvvn4+bJlwIMHMmRnW8PKSqb2A3JyAt599/HzVauk7kia2NsDH3zw+Pm6dcDdu5rLWloCkyc/fv7dd9qvQJqYANOnP36+ZQtw9armsgAQFfX4759+Ai5e1F72ww8fH2R37gTOntVedtIk6cQTAPbsAU6c0F72gw8eXwXatw84ckRzfAHp3gTl1HeHDgEHD2pf7+jRQM2a0t/HjgHR0drLDh/+eFSvU6eA337TXnbQIKBuXenv8+eB7du1l+3XT2oVAYBLl4Bt27SXDQsDAgOlv69dAzZt0l62a1egZUvp71u3gPXrtZd95RWgbVvp74QEYNUq7fHt2FF6ANK+u3y59vW2aSN1vwWk/1CWLNFetkULKQkBpN9aSf3YAwOlWADSb/iTT7SXbdBA6v6rVFJZfR8jlPeEzpwJZGZaw99fhlq1pBPXdeuksjxGPPYsx4i9ezXvvwCPEUq6HCNOn5ZaZx0dH9+z+PAhcOqUNTIyZGonhA8eAFu3ArVq8RgBPNt5xLp1ligs1Lz/8hjx2NMeIw4dMsWlS5rjC1TsMeL8een7dHaW/m8ApBauxET1ckJIv7m9e6Wu7ZXtPOLLL7Ufgw15HvHokfbyRTH5IiKqojw9gSZNgDt3pJMGTtdIlZmJiXSSV9rgysor80VbOIio7NzdpQaEzMzHyZcmDx9K5WrVMlzdqjKZ4AReTyUjIwN2dnZITk6HrYY91rDdDhVISkqCs7Mz5EXaXNld4NnLSt0ONcdXU9mK7iZUmbsUaSubl6c9vux2KHmWY8SjRwrcu6c5vjxGPHvZ/HwFEhI0x/fJspXhd1+ZjxHx8VIrnamp1C32/0ujZs0k3L7tDCGkiqWmSvvU999LA3DwGPH0xwiFQoE7d5Lg5KR5/+Ux4tnKKhTS8aF6dc3xfXK9FfG7nzwZ2LVL6u6rvABS9LvIz5d+m927A59+WvnOIwoKFLh7V/sx2JDnERkZGXByskN6uubcQIktX8/I1FS3q29luUJXlrImJtKOoqxHSXP7aLuB2ZBljcuwx1WGskZG0kFRl/gW/dHqst6KLiuX676v6busLvFVfg+60FvZ7HiYpsQABdmAsRXgGARYe2otr6/ffVmPEbrEV1m2LOvVR9nK8Lsv6zFC1/hWht99ZT5G1K0rjcL566/SVXjlSamRkfQe5QlOaqo0n6Wvr/r7K8UxogxlgcpRVnmMKG3/VZYty3r1UbYy/O6f5hihS3wr4nc/ZQpw8+bj6R3s7dXn+UpJkboZTppUfL+qbOcRpcVY3797Xcsz+SIiKk1uAnBpAZB0CMjPAGRyQCgAE1vAuQNQfwJgwUmHiJ7VxInSYBrKE0EHB2m5QiHdc5KSwtE6icqTm1vxQZqUyZetrXShIyKC8+qVJyZfREQlyU0ATowB0mMBUyfA2vtx8pWXBtzZAWTFAS2WMwF7RvHx0tDH2dnSPWpBQY9vGKcXw5MngtevS1eTr18HrK15IkikD25ujwdpOnYMyMqSfm9BQZwPUh+YfBERleTSAinxsvIC5EX6xsjkgFk1wMRGev3SIqBpCUOikVYJCdLkuocOSSNtFb3q2qEDMGECT7ZfJE+eCOblSQkYTwTLl/Jih3LKCV7sIE9P7gOGwOSLiEibrHipq6Gpk3riVZTcRHo96U+pfAn3gFFxCQnSUMvKbmbe3ur3G+zYIXWDWb6cCdiLxtMTqF0bSEqShsLW5Z4ZKl3Rix1ZWYCfH3D5stTSwYsdRPrHQxkRkTYpMdI9Xqb2JZcztZfKpRwzRK2qlAULpMTLy0ua20l5gi2XS8+9vKTXFy2q2HoSVQXKix2//iq1dnl5SYmWl5f0fMcO6fWEhIquKVHVxeSLiEibgmype6GstCGU/r9MQZZh6lVFxMdLV9+dnLSPdmZiIr3+55/aJ2ElIt3wYgdRxWPyRUSkjbGVNLCGKG3W1/8vY2xtmHpVETEx0j1e9vYll7O3l8odY8Mi0VPjxQ6iyoHJFxGRNo5B0nDyeWkll8tLk8o5BRmiVlVGdrZ0xb20e3mUZbLYsEj01Hixg6hy4IAbZFAcSpqeK9aegHN74M6v0qiGmgbdUOQDeSlAzZ6AFYdiKwsrK2lgDYWi5ARMWcaaDYtET40XO4gqByZfZBAcSpqeW/UnAlnXH8/zZWqvPs9XXgpg1wCoz1lfyyooSDoGpKVJ95tok5YmlQtiwyLRU+PFDqLKgd0OSe+eHF3J2/vxg6MrUaVn4SZNoFyzFyDypQmVlQ+RL7V4cYLlp+LpCbRvDyQnS3MNaZKfD6SkAMHBnOOJ6FkUvdhREl7sINIvtnyR3hUdXanoTb7K0ZVsbB6PrjSfc9S+UJ6bST4t3KQJlLPipeHkC7KkwTWcgtjV8BlNnAhcv/54ni97e/V5vlJSgAYNgAg2LBI9E+XFjl9/lf7f1TTohvJiR8+evNhBpC9MvkivnmZ0pUp58k3l6rmd5NPak5MolzM3N2kC5UWLpGNAXJx6t+SePaXEq1LuD0TPmScvdjg4SMsVCuDBA17sIDIEJl+kV8rRlby9Sy5nby+ddB07xuSrqlN2Q1X+56+c5DMvT/rPf8cOaV9Yvpwn3C8KNzep1Ts+XjoGZGVJiXhQEK++E5WnJy92XL8OmJpK/1pb82IHkSEw+SK94uhK9KQnu6HKZNJydkMlT09efCHStycvduTlSQkYL3YQGQaTL9Irjq5ERbEbKlUlz809i0QaeHoCtWsDSUmAs3PpF0mJqHww+SK94lDSVBS7oVJV8Nzes0hERBWO1zlIrziUNBXFbqj0vHty6gzlPYvKbrScOoOIiErC5Iv0buJEwN9fuqE3NVXqXghI/6amAjducHSlF0XRbqglYTdUqqyK3rNYrdrjCwnKexa9vB7fs0hERPQkJl+kd8rRlXr1klq54uIeP/LzpdGVOLLdi4GTfNLz7GnuWSQiIiqK93yRQXAoaQI4ySc933jPIpVEOQBLdrbUys8BWIhIEyZfZFAcSpo4ySc9r3jPImlSdACWjAz1ScI5AAsRPYndDonIoJ7shnr9unTycv06u6FS5cZ7FulJTw7A4u39+MEBWIhIE7Z8EZHBcZJPeh5x6gx60pOTxitx0ngi0obJFxFVGE7ySc8T3rNIRXHSeCJ6GjzVISIi0hGnziAl5QAs9vYll7O3l8odO2aIWhFRZcfki4iISEe8Z5GUOAALET0NdjskIiIqA96zSID6ACwlJWAcgIWIimLyRURE9BR4z+KLjQOwENHT4H8VRERERGWkHIAlOVnqcqqJcgCW4GC2ihKRhMkXERER0VPgACxEVFZMvoiIiIiewpMDsMTFPX5wABYi0oT3fBERERE9pScHYMnKkgbX4AAsRKQJky8iIiKiZ+TpyUmUiah0TL6IiIiIiMpRfLw0EXd+PmBiIrWEMjkngMkXEREREVG5SEgAFiwADh2SuqD6+QGXL0tdUTt0ACZM4D2ALzoOuEFERERE9IwSEoAxY4Bff5Vau7y8pETLy0t6vmOH9HpCQkXXlCoSky8iIiIiome0YAEQGyslW9WqPZ54XS6Xnnt5Sa8vWlSx9aSKxeSLiIiIiOgZxMdLXQ2dnKRWLk1MTKTX//xTKk8vJiZfRERERETPICYGyMgA7O1LLmdvL5U7dswQtaLKqFIkX8uWLYOnpyfMzc3RqlUr/P333yWW37ZtG/z8/GBubo6AgAD89ttvaq9HRUXBz88PVlZWcHBwQEhICI4fP65WJjU1FYMHD4atrS3s7e0xcuRIZGVllftnIyIiIqKqLTtb6l4oL+XMWlmGp5wvrgpPvrZs2YKIiAhERkbi9OnTaNy4MUJDQ5GUlKSx/NGjRzFw4ECMHDkSZ86cQVhYGMLCwnDhwgVVmbp162Lp0qU4f/48Dh8+DE9PT3Tu3BnJycmqMoMHD0ZsbCyio6Oxc+dO/PXXX3jzzTf1/nmJiIiIqGqxsgIUCulREmUZa2vD1IsqH5kQQlRkBVq1aoUWLVpg6dKlAACFQgF3d3eMGzcOU6dOLVa+f//+yM7Oxs6dO1XLWrdujcDAQKxYsULjNjIyMmBnZ4e9e/fi5ZdfxqVLl9CgQQOcOHECzZs3BwDs3r0bXbt2xe3bt1GjRo1S661cZ3p6OmxtbZ/mo5cbhUKBpKQkODs7Q17aJRcqM8ZXvxhf/WJ89Yvx1S/GV78Y3/ITHw+Eh0v3dVWrJi2TyRRwd0/Cf/85Qwgpvqmp0txf27YBHh4VV9+qojLtw7rmBhVay7y8PJw6dQohISGqZXK5HCEhIYiJidH4npiYGLXyABAaGqq1fF5eHlatWgU7Ozs0btxYtQ57e3tV4gUAISEhkMvlxbonEhERERGVxNMTaN8eSE6WkitN8vOBlBQgOJiJ14usQidZTklJQWFhIVxcXNSWu7i44PLlyxrfk5iYqLF8YmKi2rKdO3diwIAByMnJgZubG6Kjo+Ho6Khah7Ozs1p5Y2NjVKtWrdh6lB49eoRHjx6pnmdkZACQMm5FaW3MeqZQKCCEqPB6VFWMr34xvvrF+OoX46tfjK9+Mb7la8IE4MYN4OJFwNERcHBQQCYTEEKBBw+A+/cBf39g/PjSuyeSbirTPqxrHSo0+dKnTp064ezZs0hJScHq1asRHh6O48ePF0u6dDVv3jzMmjWr2PLk5GQ8fPjwWav7TBQKBdLT0yGEqPAm16qI8dUvxle/GF/9Ynz1i/HVL8a3fMnlwNy5wC+/ABcuALm5Csjl6TAxEfDwkKNbN6BXL6mclqENqIwq0z6cmZmpU7kKTb4cHR1hZGSEe/fuqS2/d+8eXF1dNb7H1dVVp/JWVlbw8fGBj48PWrduDV9fX6xduxbTpk2Dq6trsQE9CgoKkJqaqnW706ZNQ0REhOp5RkYG3N3d4eTkVCnu+ZLJZHBycqrwHa8qYnz1i/HVL8ZXvxhf/WJ89YvxLX/OzoCfH3DzJnD8uAJ5eTK0aeOE1q3lqF27omtX9VSmfdjc3FynchWafJmamqJZs2bYt28fwsLCAEhB3LdvH8aOHavxPUFBQdi3bx8++OAD1bLo6GgEBQWVuC2FQqHqNhgUFIS0tDScOnUKzZo1AwDs378fCoUCrVq10vh+MzMzmJmZFVsul8sr/MsGAJlMVmnqUhUxvvrF+OoX46tfjK9+Mb76xfjqR5060n1dSUkyODszvvpUWfZhXbdf4d0OIyIiMGzYMDRv3hwtW7bEkiVLkJ2djREjRgAAhg4dipo1a2LevHkAgPfffx/BwcFYuHAhunXrhs2bN+PkyZNYtWoVACA7Oxsff/wxevbsCTc3N6SkpGDZsmW4c+cO+vXrBwCoX78+unTpgtGjR2PFihXIz8/H2LFjMWDAAJ1GOiQiIiIiIiqrCk+++vfvj+TkZMycOROJiYkIDAzE7t27VYNq3Lp1Sy2TbNOmDTZt2oQZM2bgww8/hK+vL7Zv346GDRsCAIyMjHD58mVs2LABKSkpqF69Olq0aIFDhw7B399ftZ7vvvsOY8eOxcsvvwy5XI7XXnsNX375pWE/PBERERERvTAqfJ6v5xXn+XpxML76xfjqF+OrX4yvfjG++sX46hfjq3+VKcbPxTxfRERERERELwomX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBmBc0RV47hXmSY8nyeSA3Fi9nDYyGSA3ebqyGVeB5GNAej6QbQI4tQKsPDWXVeQDQui23pLKAoCR6VOWLQCEonzKyk2keuu1bCFQmA8o/v97FvKSy4rCEtZrLO0XlaWsUEix0EZmBMiN9F+2ME97fNXKCmlf02m9pZUt8vvUV1mglN+ygY4RihL2Xx4jyqFsofb4aipb0b/75/EYUVJ8eYz4/7LPeIzQGl8eI565rCjUHt9i660Ev3seI3Qsq+F3X9LvrggmX8/q0kLA2qz4chtfoM7gIuXma/8SrT0Br+GPn/+7BCjI0VzWsgbg8yaQmwBcWgDc2gZZfi6sZY6QiRTpoGPlATgFAdZeQN13H7/32irgYbLm9ZraA34fPH5+fR2Qc1dzWWNLoMHkx8/jvwOy4jWXlZsADac/fn5zC5B5VXNZAGgU9fjv/34C0i9qL+v/4eOD7J2dwIOz2ss2mAQYW0l/J+wB7p/QXtbvAykeAHBvH2RJR2CdnQ1ZstXjA6RS3TGAubP0d/Ih4N5B7ev1GQ1Y1pT+vn8MSIjWXtZruLRfAEDqKeDub9rLeg4CbOtKf6efB/7brr1s7X6Avf//l70E3Nqmvax7GOAQKP2deQ2I36S9bI2ugGNL6e/sW8D19drLur0COLWV/s5NgOzqKu3xdekoPQDgUTJwZbn29Tq1Adw6S3/npwOXl2gvW70FULOb9HdhDnBxvvayDoFSLADpN/x/7d15cBRl+gfwb08mk4k5gWRyICFcCkKAcGVRXDwoUTlEV0GWI+LWbi2GlYCyiBrFWgVBEVZBEFGK3RLX3aoVgXVxA0SEhcgRTuVaCBGBZJJfyDHhyGS6f390JmTIJCTAdPfbfD9VqTAzbzrPPPS8naf7fd/+YU7jbaPuAtqPvvK4qbaB7iO8jn+I8PNn/OfXHss+wusG+ojwgo3+8wuwj/C6gT4i/NT7jeeXfYTqBvqI286shFTs8Z9f9hFXXGcfYSvdCsl52H9+AfYRXmboI1yXG29fD4svEV08B+x6Dij/AUAQYGsFKOGA5AHki0DlUaC6FOg4Ue9IiYiIiIiolqQoTV3npcZUVFQgKioK5aXFiIyMbNggkMMF9r0EnFkHhHUEpCDIigRnze1wWH+GRaq99FmVD7QdAfR978rPcrjAdbT1QPa44Sx2whHrgMXCYYc3u61cU914fjmkqLbt9Q8pkmsuw+ksaiS/HFJ0o23lGjecznP+89tguwb43AvWR8ieGjiLzjaeX/YRtW2vr4+QZRnOwjNwxMY2kl/2ETfSVpZlOIvOwRHTxn9+G2zXAJ979hHNbNvwc19RUYGo1rEoLy/3XxvU4pWvGxVk8/2gN9WuJdtsjOsU4NwK2GLrdXKSusNIFkBSgKAQIMQBFG9T23svO9fvFK8lYG1bsMsZom0QAAmw1P4/N9Z51rUNasF2dW4rWZq/Xwa6bXPyK0kt2K4B2gLGaGsJbl5+vW1bst2AtDXC576FfUSz82uAz72IfURz82uEz72ofURz8utt25LtBqStET73LWgrBbUgvwb43LOPuP62zWzP1Q5FU7IDcFdcmW/QGFu02q4kV4uoiIiIiIjoGlh8iaamqvYK17Wq+9o2NS5t4iIiIiIioiax+BKNNUwdC9vUWGPgShtruDZxERERERFRk1h8iSZmIBAcCVSXNd2uukxtFztQi6iIiIiIiOgaWHyJJjwZcNwLVBc3vgqL7AaqSwDHYPWeX0REREREpDsWXyLq9iIQ1R2oOglcLr0yBFGR1cdV+eqNHLtN1zdOIiIiIiKqw+JLRKEJQP8PgbaPAYobcJ0ELp1TvytuoO1I9fXQBL0jJSIiIiKiWrzPl6hCE4A+76j38SrOBcqqgWgb4BjIoYZERERERAbE4kt04cnAbUlAqBNwOJp3Ez8iIiIiItIciy8iIrNynQKKdwBlbuBisLr6aXiy3lERERHdslh8ERGZzcVzwOF3AedWoNoFSF2B00cAWzjg+CXQ7QXOCSUiItIBiy8iIjO5eA7Y9RxQ/gNgiwXCOwKeBCCoGnCfB86sBVwnuCgPERGRDjhBiIjITA6/qxZeYR2BkNaAVNvNSxb1cVhH9fXD7+kbJxER0S2IV76IiMzCdUodamiLBSzB/ttYgtXXnVvU9kaaA+Y6BZTsAGqqAGsYEMM5akREZC4svoiIzKJkB+CuAMI7Nd3OFq0OPSzJNUZxU3+OmrtCvUqnyEBwpLHnqHFBExIZ918iXeg+7HDJkiVITk6G3W5HWloadu7c2WT7f/zjH+jatSvsdjtSUlLw9ddf173mdrsxc+ZMpKSkICwsDImJiZg4cSLOnj3rs41jx47hscceQ0xMDCIjIzFo0CDk5OQE5P3RVVyngFOfA/9boX53ndI7IiLzqKlSCxfpGl27t02NS5u4muKdo3ZmHSAFq4Wj90sKVueo7XpObWcUF88BeS8A20YDB/8E/LxG/b5tNJD3orFiJe2Icnzj/kukK12vfH3xxReYPn06li1bhrS0NCxatAhDhw7F0aNH4XA4GrTfvn07xo4di7lz52L48OFYvXo1Ro0ahby8PPTo0QMXLlxAXl4esrKy0KtXL5w/fx5Tp07FyJEjsXv37rrtDB8+HF26dMHmzZsRGhqKRYsWYfjw4Thx4gTi4+O1TMGtQ9Qz20QisYapnytFbroA87axhmsXW2Pqz1GrP1TSO0ctOOLKHLU+7+gXpxcXNKGriXR84/5LZiLo1VtJURRFr1+elpaG/v37Y/HixQAAWZbRrl07/OEPf8BLL73UoP2YMWNQVVWF9evX1z33i1/8Ar1798ayZcv8/o5du3ZhwIABKCgoQFJSEkpKShAbG4vvvvsO9957LwCgsrISkZGRyM7OxpAhQ5oVe0VFBaKiolBeXo7IyMiWvvWbSpZlOJ1OOBwOWIx4k+WrO3tb9JWDU3UZUF0MRHU3bGdv+PwKjvm9iVyn1LPXUrBauACQFQnOmnZwWE/DItV295dLAcUN3PsPIKy9oeL1yxvvoL/rf2DNe0G9SldbLDbIr+wGqk4CbR8zRrEoOMP3D6Id30TefwWcE2r4/VdU9U54yNUuOKWucChHYNH5dirNrQ10u/JVXV2NPXv2YNasWXXPWSwWDBkyBDt27PD7Mzt27MD06dN9nhs6dCjWrFnT6O8pLy+HJEmIjo4GALRp0wZ33nkn/vKXv6BPnz4ICQnBRx99BIfDgb59+za6ncuXL+Py5ct1jysqKgCoHyxZlq/1dgNKlmUoiqJ7HI368V2g7DAQ1unKmW0FAIIAWxvAGqm+/uN7QOo8PSP1y/D5FRzzexPdlgTE3guc+Zf6uar940pRJMiKpLaR3Wox03Y4ENoO0DPvxTvU+5CFdwS88fkT3ApwnQSKc9X3qBdXAVC0DQh2AJINUNAwv5JNfb3oO6AiHwjXsbg1AcP3DyId30Tdfy8WAkcWAM5tgLuy3pXFCMBxL9B1OhBqzFFLht9/RXSxENg9BSj/EbDFQA7rBMWTCDnIrV69/Xk9UHkS6LdY8/2iuf/PuhVfJSUl8Hg8iIuL83k+Li4OR44c8fszhYWFftsXFhb6bX/p0iXMnDkTY8eOratAJUnCxo0bMWrUKERERMBiscDhcGDDhg1o1apVo/HOnTsXb7zxRoPni4uLcenSpSbfa6DJsozy8nIoimK8MysXi4DCQsA6AJAjgMb2S2ssUHgWKDgIhMY10kgfhs6vCTC/N1nMb4Dz1UDVT4A1CrI1HOWeGCiQYalxATUVwG1DgJhJgNOpb6xlbvUG0J5mnKGUbEBZNRCqY8xFuwB3ImCPB2rUfVVWUJtfBRZv/WhpC1wqBPJ3AXGh+sVrAobuH0Q7vom4/14uBY4vBS78BFjvBOxhV4qvmirgzHHg/Fygy+Smr57rxND7r6hOrATKPYB9MCBZIXvq7cNBSYC9BigvBPatAjpN0jS0ysrKZrUz7WqHbrcbo0ePhqIoWLp0ad3ziqIgIyMDDocDW7duRWhoKFasWIERI0Zg165dSEjw/0fArFmzfK66VVRUoF27doiNjTXEsENJkhAbG2u8D3dBDuDZq57Zlsoabxckq2e2cRhwpGgVXbMYOr8mwPzebA4gZhZwZCHg/A7yxSpI0p2IrT4Kiy0MaPtLoOs0Y5wpvhgMnD6izje55hy1k0C0DfAzH1gzlRWAdBwI9tQ9JSsSJEiItf58ZVgnAFw+CdxWoW+8V3MVAP+Xe2XYVptfGOPKRhMM3T+IdnwTcf/d+w5wIRsI6wBYygCUXXktGLXDJLOBErv+Vxb9MPT+KyJXAVCxFrAFA8Hq/up3H5ZLgYo1wG1Pa9rH2e32ZrXTrfiKiYlBUFAQioqKfJ4vKipqdNGL+Pj4ZrX3Fl4FBQXYvHmzT3G0efNmrF+/HufPn697/sMPP0R2djZWrVrld64ZAISEhCAkJKTB8xaLxRAfKEmSDBOLD0+VuqamRULtWAz/JElt53EBRnsPMHB+TYL5vcnCEoG+79RORs6FVFYNS7QNFsdAfed4XS12IGALV4eKNHXWuvq82s4xUN/+ITgMQA0Aj0+xKEkKLLVfANRiETVAcLgx+jORFoTww7D9g2jHN9H2X9cpoHgrENIGCLLCb46DrOrrxVvUq2MGnANm2P3XH6PPqyvNBWrKa1fDvbI/NNiHQ6LUhWNKvwciO2gWXnP/j3XbE2w2G/r27YtNmzbVPSfLMjZt2oSBAwf6/ZmBAwf6tAeA7Oxsn/bewuv48ePYuHEj2rRp49P+woULABomyGKxcExuINRffa0pRlp9jcgswpOB9qOBhIfU70YqvAA1Pse96qIEstt/G9kNVJcAjsH6xx8zUC1YqsuablddpraL9X8s05SIS/mLQrTjm2j7r/e+hbboptvZotV2JblaRGVOPrcfeAM48p763Wi3HxDxdip+6FqGT58+HR9//DFWrVqFw4cPY/LkyaiqqsKkSeoYzYkTJ/osyDF16lRs2LABCxYswJEjRzB79mzs3r0bU6ZMAaAWXk8++SR2796Nzz77DB6PB4WFhSgsLER1dTUAtYBr1aoV0tPTsX//fhw7dgwzZsxAfn4+hg0bpn0SzE60zp6ItNXtRXU1uKqTtasa1v4hq8jq46p8IOouoNv0prejBdGKRcB3Kf+Q1lf+aPEu5R/W8cpS/kbjOgUUfAGc+4/63Wj3zRLt+Cba/muSP7QNT6QTNKKd8GiErnO+xowZg+LiYrz22msoLCxE7969sWHDhrpFNX766SefK1R33303Vq9ejVdffRUvv/wyunTpgjVr1qBHjx4AgDNnzmDt2rUAgN69e/v8rpycHNx3332IiYnBhg0b8Morr+CBBx6A2+1G9+7d8dVXX6FXr17avPFbibezP7NOXZmo/n18vLydfduR+nf2RKSt0AR1Ge7D7wHOLepQkfrD4tqOVAsvowyL6/aiOn/Hu7R4cO1CTYqsDo+sLjFOseg6pQ41tMX673sB9XlbbG3uTxljiFH9YZLVLnVRltNHaoeeGmiYpIjHN5H2XxHvWygike61WP+ER5ND1cuMccKjEbre50tkvM9XC1zzPii1nb1R7oNyFcPnV3DMb2AJlV/XKXXoUI1L/UMq1mBz1LwunqsrFhveY2awcYrFU5+rQ4fCO137j1fXCSBlNpD8tGbh+XXV8UIObgWnpz0cQQWwuM8b775ZIh7fRNl/W3ofQL3vW+iH4ftf095rMV894aFxsWj4+3zRLUS0M9tEpI/wZP0P7M0RmqAe1GsXNEFZde1KjAYrFkUctnX1Wfi6+08Z8Cw8IObxTZT9V8Qri6LxzqsL79R0O1u0um+X5OrfR4t09bYRLL5IG/U7exHObBMRXUt4snrT51CnuiS30c5sizZsS9RhkqIe34y+/wIN/9Bu7Mqigf/QNjQRT9A0OOFxsvam4SfVoclGPOFxFRZfpC1RzmyLyujLxBKRdkSbHyHiWfj6eHy7+US8sigS0U7QeIly9bYRLL6IzEDw+/gQUQCINmxLxLPwFHiiXlkUgWgnaK4mwtVbP1h8EYnu6gnf3sn13mEZZ9aqZwuNNOGbiLQh0rAtUc/CkzZEu7LoOgUU7wDK3MDFYLVwMVr8op2gMQkWX0SiE2mZWCLSlkjDtkQ/C08EiHOrBC+RTtCYBIsvIpGJOkGdiLQjyrAtnoUn0TUYidIR8CQAQdWA+7wxR6KIdILGJFh8ETXF6MMGRJ+gTkTaEWHYlgmWkaZbmGi3SvAS5QSNSbD4IvJHlGEDnKBORGZigmWk6RZlhpEoIpygMQEWX0RXE2nYACeoE5HZCL6MNN2iOBKFmonFF9HVRBo2wAnqRGRWgi4jTbcojkShZmJPRlTf9Qwb0JN3gnp1sToR3R/vBHXHYJ41JiIiCoT6I1GawpEotzwWX0T1eYcN2KKbbmeLVtuV5GoRVdO6vQhEdQeqTgKXS690/IqsPq7K5wR1IiKiQKo/EqUpHIlyy2PxRVSfiMMGvBPU2z4GKG51LLn3S3GrE9SNMD+NiIjIrDgShZqJc76I6hN1AQsuE0tERKQv3iqBmoHFF1F9oi9gwWViiYiI9MFbJVAzsPgiqs87bODMOnVVQ3+LbniHDbQdyatKREREdAVvlUDXwOKL6GocNkBEREQ3grdKoEZwTyC6WoMFLE4Cl86p37mABRERERFdJ175IvKHwwaIiIiI6CZj8UXUFA4bICIiIqKbhH9JEhERERERaYDFFxERERERkQZYfBEREREREWmAxRcREREREZEGWHwRERERERFpgMUXERERERGRBlh8ERERERERaYDFFxERERERkQZYfBEREREREWnAqncAolIUBQBQUVGhcySALMuorKyE3W6HxcJ6+mZjfgOL+Q0s5jewmN/AYn4Di/kNLOY38IyUY29N4K0RGsPi6zpVVlYCANq1a6dzJEREREREZASVlZWIiopq9HVJuVZ5Rn7JsoyzZ88iIiICkiTpGktFRQXatWuH06dPIzIyUtdYzIj5DSzmN7CY38BifgOL+Q0s5jewmN/AM1KOFUVBZWUlEhMTm7wKxytf18liseD222/XOwwfkZGRuu94Zsb8BhbzG1jMb2Axv4HF/AYW8xtYzG/gGSXHTV3x8uIAVCIiIiIiIg2w+CIiIiIiItIAiy8TCAkJweuvv46QkBC9QzEl5jewmN/AYn4Di/kNLOY3sJjfwGJ+A0/EHHPBDSIiIiIiIg3wyhcREREREZEGWHwRERERERFpgMUXERERERGRBlh8ERERERERaYDFlwksWbIEycnJsNvtSEtLw86dO/UOyRTmzp2L/v37IyIiAg6HA6NGjcLRo0f1DsuU3n77bUiShMzMTL1DMZUzZ85g/PjxaNOmDUJDQ5GSkoLdu3frHZYpeDweZGVloUOHDggNDUWnTp3wpz/9CVzD6vp89913GDFiBBITEyFJEtasWePzuqIoeO2115CQkIDQ0FAMGTIEx48f1ydYATWVX7fbjZkzZyIlJQVhYWFITEzExIkTcfbsWf0CFsy19t/6fv/730OSJCxatEiz+ETXnPwePnwYI0eORFRUFMLCwtC/f3/89NNP2gfbDCy+BPfFF19g+vTpeP3115GXl4devXph6NChcDqdeocmvC1btiAjIwO5ubnIzs6G2+3GQw89hKqqKr1DM5Vdu3bho48+Qs+ePfUOxVTOnz+Pe+65B8HBwfj3v/+NH3/8EQsWLECrVq30Ds0U5s2bh6VLl2Lx4sU4fPgw5s2bh/nz5+ODDz7QOzQhVVVVoVevXliyZInf1+fPn4/3338fy5Ytw/fff4+wsDAMHToUly5d0jhSMTWV3wsXLiAvLw9ZWVnIy8vDP//5Txw9ehQjR47UIVIxXWv/9fryyy+Rm5uLxMREjSIzh2vl98SJExg0aBC6du2Kb7/9FgcOHEBWVhbsdrvGkTaTQkIbMGCAkpGRUffY4/EoiYmJyty5c3WMypycTqcCQNmyZYveoZhGZWWl0qVLFyU7O1sZPHiwMnXqVL1DMo2ZM2cqgwYN0jsM0xo2bJjy7LPP+jz3xBNPKOPGjdMpIvMAoHz55Zd1j2VZVuLj45V33nmn7rmysjIlJCRE+fzzz3WIUGxX59efnTt3KgCUgoICbYIykcby+/PPPytt27ZVDh06pLRv315ZuHCh5rGZgb/8jhkzRhk/frw+AV0HXvkSWHV1Nfbs2YMhQ4bUPWexWDBkyBDs2LFDx8jMqby8HADQunVrnSMxj4yMDAwbNsxnH6abY+3atejXrx+eeuopOBwOpKam4uOPP9Y7LNO4++67sWnTJhw7dgwAsH//fmzbtg2PPPKIzpGZT35+PgoLC336iaioKKSlpfFYFyDl5eWQJAnR0dF6h2IKsixjwoQJmDFjBrp37653OKYiyzL+9a9/4Y477sDQoUPhcDiQlpbW5NBPvbH4ElhJSQk8Hg/i4uJ8no+Li0NhYaFOUZmTLMvIzMzEPffcgx49eugdjin87W9/Q15eHubOnat3KKZ08uRJLF26FF26dME333yDyZMn4/nnn8eqVav0Ds0UXnrpJTz99NPo2rUrgoODkZqaiszMTIwbN07v0EzHezzjsU4bly5dwsyZMzF27FhERkbqHY4pzJs3D1arFc8//7zeoZiO0+mEy+XC22+/jYcffhj/+c9/8Pjjj+OJJ57Ali1b9A7PL6veARCJICMjA4cOHcK2bdv0DsUUTp8+jalTpyI7O9u4Y7IFJ8sy+vXrhzlz5gAAUlNTcejQISxbtgzp6ek6Rye+v//97/jss8+wevVqdO/eHfv27UNmZiYSExOZXxKW2+3G6NGjoSgKli5dqnc4prBnzx78+c9/Rl5eHiRJ0jsc05FlGQDw2GOPYdq0aQCA3r17Y/v27Vi2bBkGDx6sZ3h+8cqXwGJiYhAUFISioiKf54uKihAfH69TVOYzZcoUrF+/Hjk5Obj99tv1DscU9uzZA6fTiT59+sBqtcJqtWLLli14//33YbVa4fF49A5ReAkJCbjrrrt8nuvWrZthV38SzYwZM+qufqWkpGDChAmYNm0ar+QGgPd4xmNdYHkLr4KCAmRnZ/Oq102ydetWOJ1OJCUl1R3vCgoK8MILLyA5OVnv8IQXExMDq9Uq1PGOxZfAbDYb+vbti02bNtU9J8syNm3ahIEDB+oYmTkoioIpU6bgyy+/xObNm9GhQwe9QzKNBx98EAcPHsS+ffvqvvr164dx48Zh3759CAoK0jtE4d1zzz0Nbo1w7NgxtG/fXqeIzOXChQuwWHwPoUFBQXVnYenm6dChA+Lj432OdRUVFfj+++95rLtJvIXX8ePHsXHjRrRp00bvkExjwoQJOHDggM/xLjExETNmzMA333yjd3jCs9ls6N+/v1DHOw47FNz06dORnp6Ofv36YcCAAVi0aBGqqqowadIkvUMTXkZGBlavXo2vvvoKERERdXMLoqKiEBoaqnN0YouIiGgwdy4sLAxt2rThnLqbZNq0abj77rsxZ84cjB49Gjt37sTy5cuxfPlyvUMzhREjRuCtt95CUlISunfvjr179+K9997Ds88+q3doQnK5XPjf//5X9zg/Px/79u1D69atkZSUhMzMTLz55pvo0qULOnTogKysLCQmJmLUqFH6BS2QpvKbkJCAJ598Enl5eVi/fj08Hk/d8a5169aw2Wx6hS2Ma+2/VxezwcHBiI+Px5133ql1qEK6Vn5nzJiBMWPG4Je//CXuv/9+bNiwAevWrcO3336rX9BN0Xu5RbpxH3zwgZKUlKTYbDZlwIABSm5urt4hmQIAv18rV67UOzRT4lLzN9+6deuUHj16KCEhIUrXrl2V5cuX6x2SaVRUVChTp05VkpKSFLvdrnTs2FF55ZVXlMuXL+sdmpBycnL89rfp6emKoqjLzWdlZSlxcXFKSEiI8uCDDypHjx7VN2iBNJXf/Pz8Ro93OTk5eocuhGvtv1fjUvMt05z8fvLJJ0rnzp0Vu92u9OrVS1mzZo1+AV+DpCiKEvgSj4iIiIiI6NbGOV9EREREREQaYPFFRERERESkARZfREREREREGmDxRUREREREpAEWX0RERERERBpg8UVERERERKQBFl9EREREREQaYPFFRESkk1OnTkGSJOzbt0/vUIiISAMsvoiISFjPPPMMJEmCJEkIDg5Ghw4d8Mc//hGXLl0K+O++7777kJmZGfDfQ0RE5mHVOwAiIqIb8fDDD2PlypVwu93Ys2cP0tPTIUkS5s2bp3doREREPnjli4iIhBYSEoL4+Hi0a9cOo0aNwpAhQ5CdnV33enJyMhYtWuTzM71798bs2bPrHkuShBUrVuDxxx/Hbbfdhi5dumDt2rUtiiM5ORlz5szBs88+i4iICCQlJWH58uU+bXbu3InU1FTY7Xb069cPe/fubbCdQ4cO4ZFHHkF4eDji4uIwYcIElJSUAAC+/fZb2Gw2bN26ta79/Pnz4XA4UFRU1KJ4iYhIeyy+iIjINA4dOoTt27fDZrO1+GffeOMNjB49GgcOHMCjjz6KcePGobS0tEXbWLBgQV1R9dxzz2Hy5Mk4evQoAMDlcmH48OG46667sGfPHsyePRsvvviiz8+XlZXhgQceQGpqKnbv3o0NGzagqKgIo0ePBnBlqOOECRNQXl6OvXv3IisrCytWrEBcXFyL3zMREWmLxRcREQlt/fr1CA8Ph91uR0pKCpxOJ2bMmNHi7TzzzDMYO3YsOnfujDlz5sDlcmHnzp0t2sajjz6K5557Dp07d8bMmTMRExODnJwcAMDq1ashyzI++eQTdO/eHcOHD28Q5+LFi5Gamoo5c+aga9euSE1NxaeffoqcnBwcO3YMAPDmm2+iVatW+N3vfofx48cjPT0dI0eObPH7JSIi7XHOFxERCe3+++/H0qVLUVVVhYULF8JqteJXv/pVi7fTs2fPun+HhYUhMjISTqfzurchSRLi4+PrtnH48GH07NkTdru9rs3AgQN9fn7//v3IyclBeHh4g22fOHECd9xxB2w2Gz777DP07NkT7du3x8KFC1sUIxER6YfFFxERCS0sLAydO3cGAHz66afo1asXPvnkE/zmN78BAFgsFiiK4vMzbre7wXaCg4N9HkuSBFmWWxTLjW7D5XJhxIgRfhcLSUhIqPv39u3bAQClpaUoLS1FWFhYi+IkIiJ9cNghERGZhsViwcsvv4xXX30VFy9eBADExsbi3LlzdW0qKiqQn5+veWzdunXDgQMHfJbBz83N9WnTp08f/PDDD0hOTkbnzp19vrwF1okTJzBt2jR8/PHHSEtLQ3p6eouLRCIi0geLLyIiMpWnnnoKQUFBWLJkCQDggQcewF//+lds3boVBw8eRHp6OoKCgjSP69e//jUkScJvf/tb/Pjjj/j666/x7rvv+rTJyMhAaWkpxo4di127duHEiRP45ptvMGnSJHg8Hng8HowfPx5Dhw7FpEmTsHLlShw4cAALFizQ/P0QEVHLsfgiIiJTsVqtmDJlCubPn4+qqirMmjULgwcPxvDhwzFs2DCMGjUKnTp10jyu8PBwrFu3DgcPHkRqaipeeeWVBsMLExMT8d///hcejwcPPfQQUlJSkJmZiejoaFgsFrz11lsoKCjARx99BEAdirh8+XK8+uqr2L9/v+bviYiIWkZSrh4IT0RERERERDcdr3wRERERERFpgMUXERERERGRBlh8ERERERERaYDFFxERERERkQZYfBEREREREWmAxRcREREREZEGWHwRERERERFpgMUXERERERGRBlh8ERERERERaYDFFxERERERkQZYfBEREREREWmAxRcREREREZEG/h+HCuhQ6066vgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the cache effect\n", + "# Discard first few samples to remove initialization noise\n", + "discard = 3\n", + "times_warm_clean = times_warm[discard:]\n", + "times_cold_clean = times_cold[discard:]\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_warm_clean)), times_warm_clean, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm_clean):.4f}ms)', color='orange', s=60)\n", + "plt.scatter(range(len(times_cold_clean)), times_cold_clean, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold_clean):.4f}ms)', color='blue', s=60)\n", + "plt.axhline(y=np.mean(times_warm_clean), color='orange', linestyle='--', alpha=0.5)\n", + "plt.axhline(y=np.mean(times_cold_clean), color='blue', linestyle='--', alpha=0.5)\n", + "plt.xlabel('Run Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication\\n(first {discard} samples discarded)')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FAaH1cdBzX2j" + }, + "source": [ + "### Putting it all together\n", + "\n", + "We have now discovered that a robust benchmark requires:\n", + "\n", + "1. Device Synchronization\n", + "2. CUDA Events (to avoid CPU overhead)\n", + "3. Warmup Runs (to avoid initialization costs)\n", + "4. Multiple Samples (to handle variance)\n", + "5. Cache Flushing (to simulate VRAM access)\n", + "6. Median/Mean Aggregation (to ignore jitter)\n", + "\n", + "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", + "\n", + "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:44.600123Z", + "iopub.status.busy": "2025-12-17T21:24:44.600004Z", + "iopub.status.idle": "2025-12-17T21:24:47.005899Z", + "shell.execute_reply": "2025-12-17T21:24:47.004654Z" + }, + "id": "3aVFtWt_zX2j", + "outputId": "6cf1e493-86ca-419e-a8e1-e19486814e09" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "KernelBench cuda_event time: 21.5000 ms\n" + ] + } + ], + "source": [ + "# Get the timing function - cuda_event is the default for trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "def final_benchmark(func, *args, num_trials=100):\n", + " \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n", + " elapsed_times = timing_fn(\n", + " kernel_fn=func,\n", + " args=list(args),\n", + " num_warmup=10,\n", + " num_trials=num_trials,\n", + " discard_first=1, # Discard first trial for consistency\n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " stats = get_timing_stats(elapsed_times, device=DEVICE)\n", + " return stats[\"mean\"]\n", + "\n", + "t = final_benchmark(simple_mm, a, b)\n", + "print(f\"KernelBench cuda_event time: {t:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MsZrCYQRzX2j" + }, + "source": [ + "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", + "\n", + "---\n", + "\n", + "## KernelBench's Timing Methods Explained\n", + "\n", + "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", + "- **All 4 timing methods** and when to use each\n", + "- **The `discard_first` parameter** and why it improves measurement consistency\n", + "- **How `host_time` detects side-stream exploits** in untrusted code\n", + "\n", + "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", + "\n", + "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", + "|--------|----------|---------------------|------------|---------------|\n", + "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", + "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", + "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", + "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", + "\n", + "### Method Details\n", + "\n", + "**`cuda_event`** (Default)\n", + "- Uses `torch.cuda.Event` for GPU-side timing\n", + "- Most accurate for pure kernel time measurement\n", + "- Clears L2 cache before each trial for cold-cache performance\n", + "- Use for trusted code where you control the kernel implementation\n", + "\n", + "**`host_time`** (For Untrusted Code)\n", + "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", + "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", + "- Falls back to host time when discrepancy detected, ensuring correctness\n", + "- Waits for ALL streams via `torch.cuda.synchronize()`\n", + "- **Essential for evaluating untrusted/agent-generated code**\n", + "\n", + "**`do_bench`** (Triton's Adaptive Benchmarking)\n", + "- Wraps Triton's `triton.testing.do_bench`\n", + "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", + "- Trial count is automatic based on kernel runtime\n", + "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", + "\n", + "**`do_bench_impl`** (Transparent Implementation)\n", + "- Custom implementation mirroring Triton's do_bench\n", + "- Gives you explicit control over `num_warmup` and `num_trials`\n", + "- Useful when you need do_bench's approach but with specific trial counts\n", + "\n", + "### Key Parameters\n", + "\n", + "All timing functions share a common interface:\n", + "\n", + "```python\n", + "timing_fn(\n", + " kernel_fn, # Function to time\n", + " args, # List of arguments to pass\n", + " num_warmup=3, # Warmup iterations before timing\n", + " num_trials=10, # Number of timing samples to collect\n", + " discard_first=1, # Drop first N trials after warmup\n", + " device=\"cuda:0\", # Explicit GPU device selection\n", + " verbose=True # Print per-trial timing info\n", + ") -> list[float] # Returns list of elapsed times in ms\n", + "```\n", + "\n", + "### Why `discard_first`?\n", + "\n", + "Even after warmup, the first few timing trials can be affected by:\n", + "- PyTorch's lazy tensor allocation finalizing\n", + "- cuDNN autotuning (still settling optimal algorithms)\n", + "- Driver state initialization\n", + "- First access to data structures\n", + "\n", + "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparing All 4 Timing Methods\n", + "\n", + "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:47.008751Z", + "iopub.status.busy": "2025-12-17T21:24:47.008456Z", + "iopub.status.idle": "2025-12-17T21:24:50.238519Z", + "shell.execute_reply": "2025-12-17T21:24:50.237366Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comparing all KernelBench timing methods on 4096x4096 matmul:\n", + "======================================================================\n", + "\n", + "Testing cuda_event...\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " cuda_event: 21.5000 ms (std=0.0572)\n", + "\n", + "Testing host_time...\n", + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " host_time: 21.5000 ms (std=0.0427)\n", + "\n", + "Testing do_bench...\n", + "[Profiling] Using timing method: do_bench\n", + " do_bench: 21.4000 ms (std=0.0030)\n", + "\n", + "Testing do_bench_impl...\n", + "[Profiling] Using timing method: do_bench_impl\n", + " do_bench_impl: 21.4000 ms (std=0.0315)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time is slightly slower due to CPU overhead,\n", + "but it catches ALL work on ALL streams - essential for untrusted code!\n" + ] + } + ], + "source": [ + "# Compare all KernelBench timing methods on 4096x4096 matmul\n", + "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", + "print(\"=\" * 70)\n", + "\n", + "methods = [\"cuda_event\", \"host_time\", \"do_bench\", \"do_bench_impl\"]\n", + "results = {}\n", + "\n", + "for method in methods:\n", + " print(f\"\\nTesting {method}...\")\n", + " try:\n", + " method_fn = get_timing_function(method)\n", + " times = method_fn(\n", + " simple_mm, \n", + " [a, b], \n", + " num_warmup=10, \n", + " num_trials=50, \n", + " verbose=False,\n", + " device=DEVICE\n", + " )\n", + " results[method] = get_timing_stats(times, device=DEVICE)\n", + " print(f\" {method}: {results[method]['mean']:.4f} ms (std={results[method]['std']:.4f})\")\n", + " except Exception as e:\n", + " print(f\" {method}: Skipped due to {type(e).__name__} (Triton version compatibility)\")\n", + " # Remove from list if it failed\n", + " methods = [m for m in methods if m in results]\n", + "\n", + "# Only plot if we have results\n", + "if results:\n", + " # Visualize the comparison\n", + " fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", + "\n", + " # Bar chart of mean times\n", + " available_methods = [m for m in methods if m in results]\n", + " means = [results[m]['mean'] for m in available_methods]\n", + " stds = [results[m]['std'] for m in available_methods]\n", + " colors = ['#2ecc71', '#e74c3c', '#3498db', '#9b59b6'][:len(available_methods)]\n", + "\n", + " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", + " axes[0].set_ylabel('Time (ms)')\n", + " axes[0].set_title('Mean Execution Time by Method\\n(graph truncated for readability)')\n", + " axes[0].tick_params(axis='x', rotation=45)\n", + "\n", + " # Truncate y-axis to make differences easier to see\n", + " min_mean = min(means)\n", + " max_mean = max(means)\n", + " margin = (max_mean - min_mean) * 2\n", + " axes[0].set_ylim(min_mean - margin, max_mean + margin)\n", + "\n", + " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", + " if 'cuda_event' in results and 'host_time' in results:\n", + " cuda_mean = results['cuda_event']['mean']\n", + " host_mean = results['host_time']['mean']\n", + " \n", + " axes[1].bar(['cuda_event', 'host_time'], \n", + " [cuda_mean, host_mean], \n", + " color=['#2ecc71', '#e74c3c'], alpha=0.8)\n", + " axes[1].set_ylabel('Time (ms)')\n", + " axes[1].set_title('cuda_event vs host_time\\n(host_time catches side-streams)\\n(graph truncated for readability)')\n", + " \n", + " # Truncate y-axis to make the difference easier to see\n", + " min_val = min(cuda_mean, host_mean)\n", + " max_val = max(cuda_mean, host_mean)\n", + " margin = (max_val - min_val) * 2 # Add margin around the data\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n", + " else:\n", + " axes[1].text(0.5, 0.5, 'Comparison unavailable', ha='center', va='center')\n", + " axes[1].set_axis_off()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time is slightly slower due to CPU overhead,\")\n", + "print(\"but it catches ALL work on ALL streams - essential for untrusted code!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `discard_first` Effect\n", + "\n", + "Even after warmup, the first timing trial can be affected by lazy initialization. Let's see this in action." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.241069Z", + "iopub.status.busy": "2025-12-17T21:24:50.240945Z", + "iopub.status.idle": "2025-12-17T21:24:50.348421Z", + "shell.execute_reply": "2025-12-17T21:24:50.347364Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demonstrating the discard_first effect:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", + "\n", + "First trial: 0.3660 ms\n", + "Mean of all trials: 0.3455 ms\n", + "Mean without first: 0.3440 ms\n", + "First trial overhead: 6.4%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The first trial often shows initialization overhead even after warmup.\n", + "Using discard_first=1 (default) gives more consistent measurements.\n" + ] + } + ], + "source": [ + "# Demonstrate the discard_first effect\n", + "# Even after warmup, the first timing trial can have higher overhead\n", + "\n", + "print(\"Demonstrating the discard_first effect:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Create fresh data and clear caches to make initialization overhead more visible\n", + "torch.cuda.empty_cache()\n", + "a_fresh, b_fresh = get_data(2048)\n", + "\n", + "# Collect trials with discard_first=0 to see ALL trials including the first one\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "times_all = timing_fn(\n", + " simple_mm, [a_fresh, b_fresh],\n", + " num_warmup=3,\n", + " num_trials=15,\n", + " discard_first=0, # Keep ALL trials including first\n", + " verbose=False,\n", + " device=DEVICE\n", + ")\n", + "\n", + "# Calculate statistics\n", + "first_trial = times_all[0]\n", + "remaining_trials = times_all[1:]\n", + "mean_all = np.mean(times_all)\n", + "mean_remaining = np.mean(remaining_trials)\n", + "\n", + "print(f\"\\nFirst trial: {first_trial:.4f} ms\")\n", + "print(f\"Mean of all trials: {mean_all:.4f} ms\")\n", + "print(f\"Mean without first: {mean_remaining:.4f} ms\")\n", + "print(f\"First trial overhead: {((first_trial / mean_remaining) - 1) * 100:.1f}%\")\n", + "\n", + "# Visualize the effect with a scatter plot\n", + "plt.figure(figsize=(10, 5))\n", + "plt.scatter(range(len(times_all)), times_all, alpha=0.7, color='blue', s=60)\n", + "plt.scatter([0], [first_trial], color='red', s=100, zorder=5, label=f'First trial: {first_trial:.3f}ms')\n", + "plt.axhline(y=mean_remaining, color='green', linestyle='--', alpha=0.7, \n", + " label=f'Mean (without first): {mean_remaining:.3f}ms')\n", + "plt.axhline(y=mean_all, color='orange', linestyle=':', alpha=0.7,\n", + " label=f'Mean (all): {mean_all:.3f}ms')\n", + "plt.xlabel('Trial Index')\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('First Trial Overhead Effect (after warmup)')\n", + "plt.legend(loc='upper right')\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()\n", + "\n", + "print(\"\\nThe first trial often shows initialization overhead even after warmup.\")\n", + "print(\"Using discard_first=1 (default) gives more consistent measurements.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HwsjlhAazX2j" + }, + "source": [ + "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", + "\n", + "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", + "\n", + "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:50.351000Z", + "iopub.status.busy": "2025-12-17T21:24:50.350876Z", + "iopub.status.idle": "2025-12-17T21:24:52.778917Z", + "shell.execute_reply": "2025-12-17T21:24:52.777685Z" + }, + "id": "UuwtML39zX2j", + "outputId": "95ebbb26-e415-491a-da30-6a78ce387906" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Standard benchmark on tricky kernel: 0.1880 ms\n" + ] + } + ], + "source": [ + "def tricky_agent_kernel(a, b):\n", + " \"\"\"A 'clever' kernel that games the benchmarking harness.\"\"\"\n", + " # The agent creates a new stream to \"optimize\"\n", + " s = torch.cuda.Stream()\n", + " with torch.cuda.stream(s):\n", + " # This work happens on a side channel!\n", + " result = torch.matmul(a, b)\n", + " return result\n", + "\n", + "print(f\"Standard benchmark on tricky kernel: {final_benchmark(tricky_agent_kernel, a, b):.4f} ms\")\n", + "# Likely reports ~0.00ms or very close to it!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3HXns_XizX2j" + }, + "source": [ + "**The Issue:**\n", + "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", + "\n", + "1. Benchmark starts timer on Stream A (the default stream).\n", + "2. Agent launches work on Stream B and returns immediately.\n", + "3. Benchmark stops timer on Stream A.\n", + "\n", + "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", + "\n", + "**Why this matters for evals:**\n", + "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", + "\n", + "**Mitigations:**\n", + "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", + "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", + "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", + "\n", + "### How KernelBench Addresses This\n", + "\n", + "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", + "\n", + "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", + "\n", + "```python\n", + "# For trusted code (faster, but can be fooled)\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For untrusted/agent code (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "```\n", + "\n", + "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.782281Z", + "iopub.status.busy": "2025-12-17T21:24:52.782061Z", + "iopub.status.idle": "2025-12-17T21:24:52.830292Z", + "shell.execute_reply": "2025-12-17T21:24:52.829161Z" + }, + "id": "KbAFqiyizX2j", + "outputId": "6bc91db4-935c-4af9-bdc9-be3c50e890c4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Robust benchmark on tricky kernel: 21.6298 ms\n", + "Robust benchmark on normal kernel: 21.5420 ms\n" + ] + } + ], + "source": [ + "def benchmark_untrusted(func, *args):\n", + " \"\"\"Benchmark untrusted code by using wall-clock time with full device sync.\n", + "\n", + " This trades some precision (includes CPU overhead) for correctness\n", + " (catches work on any stream).\n", + " \"\"\"\n", + " torch.cuda.synchronize() # Clear any pending work\n", + " start = time.perf_counter()\n", + " func(*args)\n", + " torch.cuda.synchronize() # Wait for ALL streams\n", + " end = time.perf_counter()\n", + " return (end - start) * 1000\n", + "\n", + "print(f\"Robust benchmark on tricky kernel: {benchmark_untrusted(tricky_agent_kernel, a, b):.4f} ms\")\n", + "print(f\"Robust benchmark on normal kernel: {benchmark_untrusted(simple_mm, a, b):.4f} ms\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:52.832854Z", + "iopub.status.busy": "2025-12-17T21:24:52.832734Z", + "iopub.status.idle": "2025-12-17T21:24:53.846639Z", + "shell.execute_reply": "2025-12-17T21:24:53.845578Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Side-Stream Detection Experiment:\n", + "============================================================\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "\n", + "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", + "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", + "Normal kernel with host_time: 21.5000 ms (reference)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Key insight: host_time correctly measures the tricky kernel!\n", + "Use host_time for evaluating untrusted/agent-generated code.\n" + ] + } + ], + "source": [ + "# Side-Stream Detection with KernelBench's host_time\n", + "# Let's demonstrate how host_time catches the tricky kernel\n", + "\n", + "print(\"Side-Stream Detection Experiment:\")\n", + "print(\"=\" * 60)\n", + "\n", + "# cuda_event (can be fooled by side-streams)\n", + "cuda_timing = get_timing_function(\"cuda_event\")\n", + "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", + "\n", + "# host_time (catches all streams)\n", + "host_timing = get_timing_function(\"host_time\")\n", + "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "host_stats = get_timing_stats(host_times, device=DEVICE)\n", + "\n", + "# Normal kernel for reference\n", + "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", + "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", + "\n", + "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", + "print(f\"Tricky kernel with host_time: {host_stats['mean']:.4f} ms (CORRECT)\")\n", + "print(f\"Normal kernel with host_time: {normal_stats['mean']:.4f} ms (reference)\")\n", + "\n", + "# Visualize the dramatic difference\n", + "plt.figure(figsize=(10, 5))\n", + "methods = ['cuda_event\\n(fooled)', 'host_time\\n(correct)', 'Normal kernel\\n(reference)']\n", + "times = [cuda_stats['mean'], host_stats['mean'], normal_stats['mean']]\n", + "colors = ['red', 'green', 'blue']\n", + "\n", + "plt.bar(methods, times, color=colors, alpha=0.8)\n", + "plt.ylabel('Time (ms)')\n", + "plt.title('Side-Stream Detection: cuda_event vs host_time')\n", + "plt.grid(True, alpha=0.3, axis='y')\n", + "\n", + "# Add annotation\n", + "plt.annotate('Agent trick detected!', xy=(1, host_stats['mean']), \n", + " xytext=(1.3, host_stats['mean'] * 0.7),\n", + " arrowprops=dict(arrowstyle='->', color='green'),\n", + " fontsize=10, color='green')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nKey insight: host_time correctly measures the tricky kernel!\")\n", + "print(\"Use host_time for evaluating untrusted/agent-generated code.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Uq4qvl8FzX2j" + }, + "source": [ + "## Correctness Before Speed\n", + "\n", + "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.849299Z", + "iopub.status.busy": "2025-12-17T21:24:53.849171Z", + "iopub.status.idle": "2025-12-17T21:24:53.929702Z", + "shell.execute_reply": "2025-12-17T21:24:53.928700Z" + }, + "id": "J9W63Q5czX2k", + "outputId": "312076ee-f089-4276-8b8f-bb7a23575d3d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Correctness verified!\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Kernel time: 0.0648 ms\n" + ] + } + ], + "source": [ + "def my_experimental_kernel(a, b):\n", + " \"\"\"Pretend this is our custom optimized kernel.\"\"\"\n", + " return torch.matmul(a, b) # In reality, this would be your Triton/CUDA code\n", + "\n", + "def verify_correctness(kernel_fn, ref_fn, *args, atol=1e-2, rtol=1e-2):\n", + " \"\"\"Verify kernel produces correct output before benchmarking.\"\"\"\n", + " ref_output = ref_fn(*args)\n", + " kernel_output = kernel_fn(*args)\n", + "\n", + " if not torch.allclose(ref_output, kernel_output, atol=atol, rtol=rtol):\n", + " max_diff = (ref_output - kernel_output).abs().max().item()\n", + " raise AssertionError(\n", + " f\"Kernel output doesn't match reference! \"\n", + " f\"Max difference: {max_diff:.6f}\"\n", + " )\n", + " print(\"✓ Correctness verified!\")\n", + " return True\n", + "\n", + "# Always verify before benchmarking\n", + "a_test, b_test = get_data(1024)\n", + "verify_correctness(my_experimental_kernel, simple_mm, a_test, b_test)\n", + "\n", + "# Only benchmark if correct\n", + "time_ms = final_benchmark(my_experimental_kernel, a_test, b_test)\n", + "print(f\"Kernel time: {time_ms:.4f} ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", + "\n", + "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", + "\n", + "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", + "\n", + "### Understanding Roofline Analysis\n", + "\n", + "The Roofline Model helps you understand whether your kernel is:\n", + "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", + "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", + "\n", + "**Key formulas:**\n", + "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", + "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", + "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", + "\n", + "For matrix multiplication of two $N \\times N$ matrices:\n", + "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", + "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", + "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", + "\n", + "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "execution": { + "iopub.execute_input": "2025-12-17T21:24:53.932346Z", + "iopub.status.busy": "2025-12-17T21:24:53.932227Z", + "iopub.status.idle": "2025-12-17T21:24:56.741833Z", + "shell.execute_reply": "2025-12-17T21:24:56.740706Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix Multiplication Performance\n", + "=================================================================\n", + "Size Time (ms) TFLOPS % of TF32 Peak \n", + "-----------------------------------------------------------------\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "1024 0.0648 33.14 3.4 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "2048 0.3440 49.94 5.0 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "4096 2.6800 51.28 5.2 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "8192 21.4000 51.38 5.2 %\n", + "\n", + "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", + "H200 TF32 theoretical peak: 989.0 TFLOPS\n", + "\n", + "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" + ] + } + ], + "source": [ + "def get_tflops(n, time_ms):\n", + " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", + " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", + " tflops = flops / (time_ms * 1e-3) / 1e12\n", + " return tflops\n", + "\n", + "# Theoretical peaks vary by GPU and precision\n", + "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", + "GPU_PEAK_TFLOPS = {\n", + " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", + " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", + "}\n", + "\n", + "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", + "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", + "\n", + "# Benchmark at different sizes\n", + "print(\"Matrix Multiplication Performance\")\n", + "print(\"=\" * 65)\n", + "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", + "print(\"-\" * 65)\n", + "\n", + "for size in [1024, 2048, 4096, 8192]:\n", + " a_test, b_test = get_data(size)\n", + " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", + " tflops = get_tflops(size, time_ms)\n", + " efficiency = (tflops / PEAK_TFLOPS) * 100\n", + " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", + "\n", + "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", + "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", + "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zcYVXCkUzX2k" + }, + "source": [ + "## Conclusion\n", + "\n", + "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", + "\n", + "### What We Learned\n", + "\n", + "Through our journey, we discovered that robust GPU benchmarking requires:\n", + "1. **Device Synchronization** - Wait for GPU work to complete\n", + "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", + "3. **Warmup Runs** - Settle compilation and memory allocators\n", + "4. **Multiple Samples** - Build statistical distributions\n", + "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", + "6. **Median Aggregation** - Filter out OS jitter and outliers\n", + "7. **Side-Stream Detection** - Catch work on non-default streams\n", + "\n", + "### What KernelBench Provides\n", + "\n", + "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", + "\n", + "| Function | Purpose |\n", + "|----------|---------|\n", + "| `get_timing_function(method)` | Factory returning timing function by name |\n", + "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", + "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", + "\n", + "**Four timing methods for different use cases:**\n", + "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", + "- **`host_time`** - For untrusted/agent code (catches all streams)\n", + "- **`do_bench`** - Triton-style adaptive trial counts\n", + "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", + "\n", + "**Key parameters:**\n", + "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", + "\n", + "### Recommended Usage\n", + "\n", + "```python\n", + "from src.timing import get_timing_function, get_timing_stats\n", + "\n", + "# For trusted code\n", + "timing_fn = get_timing_function(\"cuda_event\")\n", + "\n", + "# For agent evaluations (catches side-streams)\n", + "timing_fn = get_timing_function(\"host_time\")\n", + "\n", + "# Run benchmark\n", + "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", + "stats = get_timing_stats(times, device=\"cuda:0\")\n", + "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", + "```\n", + "\n", + "Happy optimizing!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7Ah151CHzX2k" + }, + "source": [ + "---\n", + "\n", + "### Footnotes\n", + "\n", + "**On GPU Clock States:** For highly reproducible benchmarks (e.g., publishing papers), consider locking GPU clocks with `nvidia-smi -lgc `. GPUs dynamically adjust clock speeds based on thermals and power, which can introduce variance between runs. For most development work, median-based benchmarking handles this adequately.\n", + "\n", + "**On Warmup Iterations:** We use fixed warmup counts (10-50 iterations) for simplicity, but this can be insufficient or wasteful depending on the kernel. In extremely sensitive environments, you can implement an adaptive stopping criterion: run warmup iterations until the variance of recent samples falls below a threshold, indicating the system has stabilized. This is covered in more detail in the [GPU MODE lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU).\n", + "\n", + "**On Bare Metal vs. Virtualized Environments:** Cloud VMs and containers add layers of abstraction that can introduce variance and overhead. GPU passthrough in virtualized environments adds latency, and shared cloud instances suffer from \"noisy neighbor\" effects where other tenants' workloads impact your measurements. For publishable results or when chasing small performance deltas, prefer bare metal. For day-to-day development, cloud instances are fine as long as you're aware your numbers may not match others exactly." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "include_colab_link": true, + "provenance": [] + }, + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From f9a7b0999c4ad2c28fef628a79ed3ae1f55c416b Mon Sep 17 00:00:00 2001 From: Sahan Paliskara Date: Wed, 17 Dec 2025 14:45:52 -0800 Subject: [PATCH 6/6] Benchmarking guide --- benchmarking.ipynb | 1561 ---------------------------------- notebooks/benchmarking.ipynb | 354 +++----- 2 files changed, 101 insertions(+), 1814 deletions(-) delete mode 100644 benchmarking.ipynb diff --git a/benchmarking.ipynb b/benchmarking.ipynb deleted file mode 100644 index a9f3ba15..00000000 --- a/benchmarking.ipynb +++ /dev/null @@ -1,1561 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "view-in-github" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_PCU0gUyzX2c" - }, - "source": [ - "# A Practical Guide to GPU Benchmarking\n", - "\n", - "> **Note on outputs:** The outputs in this notebook were generated on an **NVIDIA H200 GPU** (90MB L2 cache, 4.8 TB/s memory bandwidth). Your results may vary depending on your hardware. The H200's large cache means cache effects are less dramatic than on older GPUs like A100 (40MB L2) or consumer cards.\n", - "\n", - "## TL;DR — How to Benchmark Correctly\n", - "\n", - "Benchmarking on GPUs requires a strict protocol to avoid measuring Python overhead or caching artifacts. To get reliable numbers, you must:\n", - "\n", - "1. **Warmup:** Run the kernel ~10-50 times first to settle compilation and memory allocators.\n", - "2. **Sample Extensively:** Don't trust one run. Collect 100+ samples to build a statistical distribution.\n", - "3. **Flush the L2 Cache:** Between *every* sample, flush the cache to force a cold cache state (simulating real-world inference).\n", - "4. **Use Device Timers:** Use `torch.cuda.Event` instead of `time.time()` to measure execution on the GPU, not the CPU driver.\n", - "5. **Aggregate Robustly:** Aggregate over many samples to filter out jitter/outliers.\n", - "6. **Wait for sidestreams to finish:** Ensure no side-streams are running or wait for all of them to finish before reporting a time.\n", - "\n", - "*Pro-Tip:* **KernelBench's timing module** (`src/timing.py`) implements all these best practices. Use `get_timing_function(\"cuda_event\")` for trusted code or `get_timing_function(\"host_time\")` for evaluating untrusted/agent-generated code.\n", - "\n", - "-----\n", - "\n", - "If are using an LLM agent to write GPU kernels (and evaluating against something like say [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), or just trying to optimize a custom GPU kernel, you are eventually going to ask: **\"How fast is this thing?\"**\n", - "\n", - "This notebook is heavily inspired by [this great guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community and the practical \"footguns\" (traps) encountered while building benchmarking harnesses for LLM-generated code. Our goal here is simplicity and keeping things Pythonic—for more advanced techniques, see the footnotes.\n", - "\n", - "We won't just list best practices. Instead, we are going to build a benchmarking harness from scratch, make every common mistake, debug why the numbers are wrong, and iterate our way to a robust solution. So let's start things out by doing the most naive thing by using `time.time()`!" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:36.427802Z", - "iopub.status.busy": "2025-12-17T21:24:36.427684Z", - "iopub.status.idle": "2025-12-17T21:24:40.995279Z", - "shell.execute_reply": "2025-12-17T21:24:40.994328Z" - }, - "id": "PKWz_W7uzX2f", - "outputId": "8751fd78-569b-4080-f21a-60bbb5ee8caf" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using GPU: NVIDIA H200\n" - ] - } - ], - "source": [ - "# @title Environment Setup\n", - "# Ensure we have the necessary libraries and a GPU available\n", - "# !pip install -q triton matplotlib numpy torch\n", - "# !pip install -e .. # Install KernelBench locally for timing utilities\n", - "\n", - "import sys\n", - "import os\n", - "sys.path.insert(0, '..') # Add parent directory to path for imports\n", - "\n", - "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", - "\n", - "import torch\n", - "import time\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import triton\n", - "\n", - "# Import KernelBench's timing module\n", - "from src import timing\n", - "from src.timing import clear_l2_cache, get_timing_stats, get_timing_function\n", - "\n", - "if not torch.cuda.is_available():\n", - " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", - "\n", - "# Device configuration\n", - "# The selected GPU will appear as cuda:0\n", - "\n", - "DEVICE = f\"cuda:0\"\n", - "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kjWByrwvzX2f" - }, - "source": [ - "## The Journey: Benchmarking a Matrix Multiplication\n", - "\n", - "Let's define a simple workload to test. We want to measure the performance of a standard Matrix Multiplication." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:40.997969Z", - "iopub.status.busy": "2025-12-17T21:24:40.997722Z", - "iopub.status.idle": "2025-12-17T21:24:41.252072Z", - "shell.execute_reply": "2025-12-17T21:24:41.250967Z" - }, - "id": "gxtKes5lzX2g", - "outputId": "5890bae4-5b9a-4366-8947-367146593158" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output shape: torch.Size([8192, 8192])\n", - "Op ran successfully\n" - ] - } - ], - "source": [ - "# A standard size for testing\n", - "N = 8192\n", - "\n", - "def get_data(n=N, device=DEVICE):\n", - " \"\"\"Generate random float32 matrices for benchmarking.\"\"\"\n", - " return torch.randn(n, n, device=device), torch.randn(n, n, device=device)\n", - "\n", - "def simple_mm(a, b):\n", - " \"\"\"Our kernel under test: standard matrix multiplication.\"\"\"\n", - " return torch.matmul(a, b)\n", - "\n", - "# Let's verify it runs\n", - "a, b = get_data()\n", - "res = simple_mm(a, b)\n", - "print(f\"Output shape: {res.shape}\")\n", - "print(\"Op ran successfully\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "GWlsBEVyzX2g" - }, - "source": [ - "### Attempt 1: The Naive Timer\n", - "\n", - "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.254622Z", - "iopub.status.busy": "2025-12-17T21:24:41.254499Z", - "iopub.status.idle": "2025-12-17T21:24:41.258106Z", - "shell.execute_reply": "2025-12-17T21:24:41.257414Z" - }, - "id": "LynIxLaRzX2g", - "outputId": "72548dad-6570-4eaa-ce07-923556fe70b4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Naive time: 0.6356 ms\n" - ] - } - ], - "source": [ - "def benchmark_naive(func, *args):\n", - " \"\"\"WRONG: Measures kernel launch time, not execution time.\"\"\"\n", - " start = time.time()\n", - " func(*args)\n", - " end = time.time()\n", - " return (end - start) * 1000 # to ms\n", - "\n", - "t = benchmark_naive(simple_mm, a, b)\n", - "print(f\"Naive time: {t:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gw4NGYRmzX2h" - }, - "source": [ - "**The Problem:**\n", - "Wait, less than 1ms? That seems impossibly fast for a 8192² matrix multiplication involving over 1 trillion floating-point operations.[¹](#footnote-1)\n", - "\n", - "**What happened?**\n", - "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't actually do the math. It simply queues a \"launch kernel\" command to the GPU and moves on immediately. Our timer didn't measure the matrix multiplication; it measured how long it took Python to place an order in the queue.\n", - "\n", - "To fix this, we need to:\n", - "1. **Synchronize** - Force the CPU to wait for the GPU with `torch.cuda.synchronize()`\n", - "2. **Use CUDA Events** - Record timestamps directly on the GPU to avoid CPU overhead\n", - "\n", - "Let's compare these approaches to see the difference.\n", - "\n", - "---\n", - "\n", - "\n", - "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Attempt 2: Synchronizing the Device\n", - "\n", - "To fix this, we need to force the CPU to wait until the GPU has finished its work before we stop the clock. We do this with `torch.cuda.synchronize()`." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.260592Z", - "iopub.status.busy": "2025-12-17T21:24:41.260479Z", - "iopub.status.idle": "2025-12-17T21:24:41.460207Z", - "shell.execute_reply": "2025-12-17T21:24:41.459267Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sync time: 21.5368 ms\n" - ] - } - ], - "source": [ - "def benchmark_sync(func, *args):\n", - " \"\"\"Better: Actually waits for GPU to finish.\"\"\"\n", - " torch.cuda.synchronize() # Wait for previous work to finish\n", - " start = time.time()\n", - " func(*args)\n", - " torch.cuda.synchronize() # Wait for THIS work to finish\n", - " end = time.time()\n", - " return (end - start) * 1000\n", - "\n", - "t = benchmark_sync(simple_mm, a, b)\n", - "print(f\"Sync time: {t:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "dV8AmQi-zX2i" - }, - "source": [ - "### Attempt 3: Removing CPU Overhead (CUDA Events)\n", - "\n", - "To get a precise measurement, we need to bypass the CPU clock entirely. We can ask the GPU driver to record timestamps directly on the device using `torch.cuda.Event`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.463315Z", - "iopub.status.busy": "2025-12-17T21:24:41.463177Z", - "iopub.status.idle": "2025-12-17T21:24:41.532922Z", - "shell.execute_reply": "2025-12-17T21:24:41.531966Z" - }, - "id": "i6PfSdkTzX2i", - "outputId": "8b3e29d1-1789-4bfb-9a44-599016516dd7" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run 0: 21.7344 ms\n", - "Run 1: 21.4754 ms\n", - "Run 2: 21.4987 ms\n" - ] - } - ], - "source": [ - "def benchmark_events(func, *args):\n", - " \"\"\"Better: Uses GPU timestamps, avoiding CPU overhead.\"\"\"\n", - " start_event = torch.cuda.Event(enable_timing=True)\n", - " end_event = torch.cuda.Event(enable_timing=True)\n", - "\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " start_event.record()\n", - " func(*args)\n", - " end_event.record()\n", - " torch.cuda.synchronize(device=DEVICE)\n", - "\n", - " return start_event.elapsed_time(end_event) # Returns ms directly\n", - "\n", - "# Run it a few times\n", - "for i in range(3):\n", - " print(f\"Run {i}: {benchmark_events(simple_mm, a, b):.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BkfaaDawzX2i" - }, - "source": [ - "### Attempt 4: Handling the \"Cold Start\"\n", - "\n", - "Notice Run 0 is noticably slower than the rest. The first time you run a PyTorch function (and similarly launching a cuda kernel), the framework does a lot of heavy lifting which could include: allocating memory, initializing cuBLAS/cuDNN workspaces, lazy kernel loading, and compiling kernels (especially if using `torch.compile` or Triton). This \"Cold Start\" penalty is a one-time cost that shouldn't be included in your performance metrics.\n", - "\n", - "**The Fix:**\n", - "We need to perform **Warmup Runs**—running the kernel a few times to settle the system state before we start measuring." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:41.535509Z", - "iopub.status.busy": "2025-12-17T21:24:41.535387Z", - "iopub.status.idle": "2025-12-17T21:24:42.246476Z", - "shell.execute_reply": "2025-12-17T21:24:42.245382Z" - }, - "id": "j_PsAuJkzX2i", - "outputId": "d6983401-72d3-468c-ffd8-c0833e8d5556" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Run 0: 21.6478 ms\n", - "Run 1: 21.4837 ms\n", - "Run 2: 21.4852 ms\n" - ] - } - ], - "source": [ - "def benchmark_warmup(func, *args, warmup_iters=30, benchmark_iters=3):\n", - " \"\"\"Better: Includes warmup to avoid cold-start penalty.\"\"\"\n", - " # Warmup phase\n", - " for _ in range(warmup_iters):\n", - " func(*args)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - "\n", - " # Measurement phase\n", - " measurements = []\n", - " for _ in range(benchmark_iters):\n", - " measurements.append(benchmark_events(func, *args))\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " return measurements\n", - "\n", - "# print(f\"Warmed up time: {benchmark_warmup(simple_mm, a, b):.4f} ms\")\n", - "\n", - "for i, measurement in enumerate(benchmark_warmup(simple_mm, a, b)):\n", - " print(f\"Run {i}: {measurement:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "OR3uOh7kzX2i" - }, - "source": [ - "### Attempt 5: The Single Sample Fallacy (Variance)\n", - "\n", - "Relying on a single sample after warmup is bad science. Operating systems are noisy; background processes interrupt the CPU, and GPU clocks fluctuate thermally. A single measurement is anecdotal, not statistical.\n", - "\n", - "#### Visualizing the Jitter\n", - "\n", - "Let's run the benchmark 100 times and plot every single run. You will clearly see the \"Cold Start\" spike and the noise floor of the OS." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 653 - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:42.248937Z", - "iopub.status.busy": "2025-12-17T21:24:42.248818Z", - "iopub.status.idle": "2025-12-17T21:24:44.484746Z", - "shell.execute_reply": "2025-12-17T21:24:44.483759Z" - }, - "id": "T-7QH4cHzX2i", - "outputId": "c758effd-a810-422d-d3ca-66c128cdb716" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean: 21.5096 ms\n", - "Median: 21.4942 ms\n", - "Std: 0.0625 ms\n", - "Min: 21.4420 ms\n", - "Max: 21.7808 ms\n" - ] - } - ], - "source": [ - "# Collect 100 samples\n", - "timings = []\n", - "for i in range(100):\n", - " timings.append(benchmark_events(simple_mm, a, b))\n", - "\n", - "plt.figure(figsize=(10, 6))\n", - "plt.scatter(range(100), timings, alpha=0.6)\n", - "plt.axhline(y=np.median(timings), color='r', linestyle='--', label=f'Median: {np.median(timings):.4f} ms')\n", - "plt.axhline(y=np.mean(timings), color='g', linestyle=':', label=f'Mean: {np.mean(timings):.4f} ms')\n", - "plt.title(\"Benchmarking Jitter & Cold Start\")\n", - "plt.ylabel(\"Time (ms)\")\n", - "plt.xlabel(\"Run Index\")\n", - "plt.legend()\n", - "plt.grid(True, alpha=0.3)\n", - "plt.show()\n", - "\n", - "print(f\"Mean: {np.mean(timings):.4f} ms\")\n", - "print(f\"Median: {np.median(timings):.4f} ms\")\n", - "print(f\"Std: {np.std(timings):.4f} ms\")\n", - "print(f\"Min: {np.min(timings):.4f} ms\")\n", - "print(f\"Max: {np.max(timings):.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hX_-OpftzX2i" - }, - "source": [ - "You will see a massive dot at $x=0$ (the cold start), followed by a cloud of dots hovering around the \"true\" time. This visualizes why we need **Warmup** (to skip $x=0$) and **Statistics** (to handle the cloud).\n", - "\n", - "Notice how the **Mean** is pulled upward by the outliers, while the **Median** represents the typical case more accurately. When possible, we should use the **Median** as our final metric.\n", - "\n", - "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n", - "\n", - "Modern GPUs have large L2 caches (40MB-192MB depending on architecture). If your data fits in the cache, subsequent iterations in your loop will skip the slow VRAM access, artificially inflating your speed. In production, data usually streams in from VRAM, so this \"hot cache\" benchmark is misleading.\n", - "\n", - "**The Fix:**\n", - "We must **flush the L2 cache** between *every single sample*. We do this by writing to a tensor large enough to completely evict the cache contents. KernelBench uses a ~256MB tensor to safely cover all GPU architectures, including the largest caches (e.g., Blackwell at ~192MB)." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.487140Z", - "iopub.status.busy": "2025-12-17T21:24:44.487016Z", - "iopub.status.idle": "2025-12-17T21:24:44.489937Z", - "shell.execute_reply": "2025-12-17T21:24:44.489208Z" - }, - "id": "Kj5azcpxzX2j" - }, - "outputs": [], - "source": [ - "# KernelBench provides utilities to flush the L2 cache\n", - "# This is important for cold cache measurements that simulate real-world inference\n", - "\n", - "def clear_l2_cache(device=DEVICE):\n", - " \"\"\"Flush L2 cache by writing to a large tensor.\n", - " \n", - " L2 cache sizes vary by GPU, so we use 256MB to cover all cases.\n", - " \"\"\"\n", - " dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device) # 256MB\n", - " dummy.fill_(1901) # Force write to thrash cache\n", - " del dummy\n", - "\n", - "# KernelBench also provides clear_l2_cache_triton() for cross-platform support\n", - "# (works on both NVIDIA and AMD GPUs via Triton's device abstraction)\n", - "from src.timing import clear_l2_cache_triton" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Why does flushing the cache matter?\n", - "\n", - "Let's see the cache effect in action. We'll benchmark the same operation twice:\n", - "1. **Without** cache flushing between runs (data stays in L2 cache)\n", - "2. **With** cache flushing between runs (data must be fetched from VRAM each time)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.492322Z", - "iopub.status.busy": "2025-12-17T21:24:44.492090Z", - "iopub.status.idle": "2025-12-17T21:24:44.507209Z", - "shell.execute_reply": "2025-12-17T21:24:44.506066Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Without cache flushing (warm cache):\n", - "\n", - "With cache flushing (cold cache):\n", - "\n", - "Warm cache median: 0.0280 ms\n", - "Cold cache median: 0.0318 ms\n", - "Difference: 0.0038 ms (13.7% slower with cold cache)\n", - "\n", - "Without cache flushing, you measure artificially fast times!\n" - ] - } - ], - "source": [ - "# Demonstrate why L2 cache flushing matters\n", - "# Use a smaller matrix so the effect is visible (data fits in cache)\n", - "N_SMALL = 512\n", - "a_small, b_small = get_data(N_SMALL)\n", - "\n", - "NUM_SAMPLES = 20\n", - "\n", - "# do warmup runs\n", - "for _ in range(NUM_SAMPLES):\n", - " clear_l2_cache(device=DEVICE)\n", - " benchmark_events(simple_mm, a_small, b_small)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - "\n", - "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", - "print(\"Without cache flushing (warm cache):\")\n", - "times_warm = []\n", - "for i in range(NUM_SAMPLES):\n", - " t = benchmark_events(simple_mm, a_small, b_small)\n", - " times_warm.append(t)\n", - "\n", - "# Benchmark WITH cache flushing (cold cache - realistic)\n", - "print(\"\\nWith cache flushing (cold cache):\")\n", - "times_cold = []\n", - "for i in range(NUM_SAMPLES):\n", - " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", - " t = benchmark_events(simple_mm, a_small, b_small)\n", - " times_cold.append(t)\n", - "\n", - "print(f\"\\nWarm cache median: {np.median(times_warm):.4f} ms\")\n", - "print(f\"Cold cache median: {np.median(times_cold):.4f} ms\")\n", - "print(f\"Difference: {np.median(times_cold) - np.median(times_warm):.4f} ms ({(np.median(times_cold)/np.median(times_warm) - 1)*100:.1f}% slower with cold cache)\")\n", - "print(\"\\nWithout cache flushing, you measure artificially fast times!\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.509465Z", - "iopub.status.busy": "2025-12-17T21:24:44.509344Z", - "iopub.status.idle": "2025-12-17T21:24:44.597419Z", - "shell.execute_reply": "2025-12-17T21:24:44.596500Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize the cache effect\n", - "# Discard first few samples to remove initialization noise\n", - "discard = 3\n", - "times_warm_clean = times_warm[discard:]\n", - "times_cold_clean = times_cold[discard:]\n", - "\n", - "plt.figure(figsize=(10, 5))\n", - "plt.scatter(range(len(times_warm_clean)), times_warm_clean, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm_clean):.4f}ms)', color='orange', s=60)\n", - "plt.scatter(range(len(times_cold_clean)), times_cold_clean, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold_clean):.4f}ms)', color='blue', s=60)\n", - "plt.axhline(y=np.mean(times_warm_clean), color='orange', linestyle='--', alpha=0.5)\n", - "plt.axhline(y=np.mean(times_cold_clean), color='blue', linestyle='--', alpha=0.5)\n", - "plt.xlabel('Run Index')\n", - "plt.ylabel('Time (ms)')\n", - "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication\\n(first {discard} samples discarded)')\n", - "plt.legend()\n", - "plt.grid(True, alpha=0.3)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "FAaH1cdBzX2j" - }, - "source": [ - "### Putting it all together\n", - "\n", - "We have now discovered that a robust benchmark requires:\n", - "\n", - "1. Device Synchronization\n", - "2. CUDA Events (to avoid CPU overhead)\n", - "3. Warmup Runs (to avoid initialization costs)\n", - "4. Multiple Samples (to handle variance)\n", - "5. Cache Flushing (to simulate VRAM access)\n", - "6. Median/Mean Aggregation (to ignore jitter)\n", - "\n", - "Writing this boilerplate every time is painful. We've packaged all these lessons into **KernelBench's timing module**, which provides multiple timing methods for different use cases. There are also other robust implementations available, such as Triton's `do_bench` [function](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n", - "\n", - "The default `cuda_event` method in KernelBench implements all of the above automatically, plus an additional insight: **`discard_first`** - discarding the first few trials after warmup, which often still have some initialization overhead." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:44.600123Z", - "iopub.status.busy": "2025-12-17T21:24:44.600004Z", - "iopub.status.idle": "2025-12-17T21:24:47.005899Z", - "shell.execute_reply": "2025-12-17T21:24:47.004654Z" - }, - "id": "3aVFtWt_zX2j", - "outputId": "6cf1e493-86ca-419e-a8e1-e19486814e09" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "KernelBench cuda_event time: 21.5000 ms\n" - ] - } - ], - "source": [ - "# Get the timing function - cuda_event is the default for trusted code\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "def final_benchmark(func, *args, num_trials=100):\n", - " \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n", - " elapsed_times = timing_fn(\n", - " kernel_fn=func,\n", - " args=list(args),\n", - " num_warmup=10,\n", - " num_trials=num_trials,\n", - " discard_first=1, # Discard first trial for consistency\n", - " verbose=False,\n", - " device=DEVICE\n", - " )\n", - " stats = get_timing_stats(elapsed_times, device=DEVICE)\n", - " return stats[\"mean\"]\n", - "\n", - "t = final_benchmark(simple_mm, a, b)\n", - "print(f\"KernelBench cuda_event time: {t:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "MsZrCYQRzX2j" - }, - "source": [ - "*Note: KernelBench also wraps Triton's `do_bench` if you prefer adaptive trial counts. See the timing methods comparison below for details.*\n", - "\n", - "---\n", - "\n", - "## KernelBench's Timing Methods Explained\n", - "\n", - "Now that we've built up a robust benchmarking harness from first principles, let's explore KernelBench's timing module in depth. We'll examine:\n", - "- **All 4 timing methods** and when to use each\n", - "- **The `discard_first` parameter** and why it improves measurement consistency\n", - "- **How `host_time` detects side-stream exploits** in untrusted code\n", - "\n", - "KernelBench's timing module provides **4 timing methods**, each designed for different use cases:\n", - "\n", - "| Method | Use Case | Catches Side-Streams | Cold Cache | Trial Control |\n", - "|--------|----------|---------------------|------------|---------------|\n", - "| `cuda_event` | Default, trusted code | No | Yes | Explicit |\n", - "| `host_time` | Untrusted code, agent evals | **Yes** | Yes | Explicit |\n", - "| `do_bench` | Triton-style / robust adaptive | No | Yes | Adaptive (time-budget) |\n", - "| `do_bench_impl` | do_bench implementation for inference and trial control | No | Yes | Explicit |\n", - "\n", - "### Method Details\n", - "\n", - "**`cuda_event`** (Default)\n", - "- Uses `torch.cuda.Event` for GPU-side timing\n", - "- Most accurate for pure kernel time measurement\n", - "- Clears L2 cache before each trial for cold-cache performance\n", - "- Use for trusted code where you control the kernel implementation\n", - "\n", - "**`host_time`** (For Untrusted Code)\n", - "- Uses **both** `time.perf_counter()` (host) and `torch.cuda.Event` (device) timing\n", - "- Compares the two: if they differ significantly, the CUDA event time is likely invalid (e.g., side-stream exploit)\n", - "- Falls back to host time when discrepancy detected, ensuring correctness\n", - "- Waits for ALL streams via `torch.cuda.synchronize()`\n", - "- **Essential for evaluating untrusted/agent-generated code**\n", - "\n", - "**`do_bench`** (Triton's Adaptive Benchmarking)\n", - "- Wraps Triton's `triton.testing.do_bench`\n", - "- Uses fixed time budgets: 25ms warmup, 100ms for repetitions\n", - "- Trial count is automatic based on kernel runtime\n", - "- **Note:** `num_warmup`, `num_trials`, `discard_first` parameters are ignored\n", - "\n", - "**`do_bench_impl`** (Transparent Implementation)\n", - "- Custom implementation mirroring Triton's do_bench\n", - "- Gives you explicit control over `num_warmup` and `num_trials`\n", - "- Useful when you need do_bench's approach but with specific trial counts\n", - "\n", - "### Key Parameters\n", - "\n", - "All timing functions share a common interface:\n", - "\n", - "```python\n", - "timing_fn(\n", - " kernel_fn, # Function to time\n", - " args, # List of arguments to pass\n", - " num_warmup=3, # Warmup iterations before timing\n", - " num_trials=10, # Number of timing samples to collect\n", - " discard_first=1, # Drop first N trials after warmup\n", - " device=\"cuda:0\", # Explicit GPU device selection\n", - " verbose=True # Print per-trial timing info\n", - ") -> list[float] # Returns list of elapsed times in ms\n", - "```\n", - "\n", - "### Why `discard_first`?\n", - "\n", - "Even after warmup, the first few timing trials can be affected by:\n", - "- PyTorch's lazy tensor allocation finalizing\n", - "- cuDNN autotuning (still settling optimal algorithms)\n", - "- Driver state initialization\n", - "- First access to data structures\n", - "\n", - "Setting `discard_first=1` (the default) improves measurement consistency. Let's visualize this effect:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Comparing All 4 Timing Methods\n", - "\n", - "Let's see how the different timing methods compare on the same kernel. Each method has trade-offs between precision, features, and overhead." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:47.008751Z", - "iopub.status.busy": "2025-12-17T21:24:47.008456Z", - "iopub.status.idle": "2025-12-17T21:24:50.238519Z", - "shell.execute_reply": "2025-12-17T21:24:50.237366Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Comparing all KernelBench timing methods on 4096x4096 matmul:\n", - "======================================================================\n", - "\n", - "Testing cuda_event...\n", - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", - " cuda_event: 21.5000 ms (std=0.0572)\n", - "\n", - "Testing host_time...\n", - "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", - " host_time: 21.5000 ms (std=0.0427)\n", - "\n", - "Testing do_bench...\n", - "[Profiling] Using timing method: do_bench\n", - " do_bench: 21.4000 ms (std=0.0030)\n", - "\n", - "Testing do_bench_impl...\n", - "[Profiling] Using timing method: do_bench_impl\n", - " do_bench_impl: 21.4000 ms (std=0.0315)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", - " axes[1].set_ylim(min_val - margin, max_val + margin)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Key insight: host_time is slightly slower due to CPU overhead,\n", - "but it catches ALL work on ALL streams - essential for untrusted code!\n" - ] - } - ], - "source": [ - "# Compare all KernelBench timing methods on 4096x4096 matmul\n", - "print(\"Comparing all KernelBench timing methods on 4096x4096 matmul:\")\n", - "print(\"=\" * 70)\n", - "\n", - "methods = [\"cuda_event\", \"host_time\", \"do_bench\", \"do_bench_impl\"]\n", - "results = {}\n", - "\n", - "for method in methods:\n", - " print(f\"\\nTesting {method}...\")\n", - " try:\n", - " method_fn = get_timing_function(method)\n", - " times = method_fn(\n", - " simple_mm, \n", - " [a, b], \n", - " num_warmup=10, \n", - " num_trials=50, \n", - " verbose=False,\n", - " device=DEVICE\n", - " )\n", - " results[method] = get_timing_stats(times, device=DEVICE)\n", - " print(f\" {method}: {results[method]['mean']:.4f} ms (std={results[method]['std']:.4f})\")\n", - " except Exception as e:\n", - " print(f\" {method}: Skipped due to {type(e).__name__} (Triton version compatibility)\")\n", - " # Remove from list if it failed\n", - " methods = [m for m in methods if m in results]\n", - "\n", - "# Only plot if we have results\n", - "if results:\n", - " # Visualize the comparison\n", - " fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", - "\n", - " # Bar chart of mean times\n", - " available_methods = [m for m in methods if m in results]\n", - " means = [results[m]['mean'] for m in available_methods]\n", - " stds = [results[m]['std'] for m in available_methods]\n", - " colors = ['#2ecc71', '#e74c3c', '#3498db', '#9b59b6'][:len(available_methods)]\n", - "\n", - " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", - " axes[0].set_ylabel('Time (ms)')\n", - " axes[0].set_title('Mean Execution Time by Method\\n(graph truncated for readability)')\n", - " axes[0].tick_params(axis='x', rotation=45)\n", - "\n", - " # Truncate y-axis to make differences easier to see\n", - " min_mean = min(means)\n", - " max_mean = max(means)\n", - " margin = (max_mean - min_mean) * 2\n", - " axes[0].set_ylim(min_mean - margin, max_mean + margin)\n", - "\n", - " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", - " if 'cuda_event' in results and 'host_time' in results:\n", - " cuda_mean = results['cuda_event']['mean']\n", - " host_mean = results['host_time']['mean']\n", - " \n", - " axes[1].bar(['cuda_event', 'host_time'], \n", - " [cuda_mean, host_mean], \n", - " color=['#2ecc71', '#e74c3c'], alpha=0.8)\n", - " axes[1].set_ylabel('Time (ms)')\n", - " axes[1].set_title('cuda_event vs host_time\\n(host_time catches side-streams)\\n(graph truncated for readability)')\n", - " \n", - " # Truncate y-axis to make the difference easier to see\n", - " min_val = min(cuda_mean, host_mean)\n", - " max_val = max(cuda_mean, host_mean)\n", - " margin = (max_val - min_val) * 2 # Add margin around the data\n", - " axes[1].set_ylim(min_val - margin, max_val + margin)\n", - " else:\n", - " axes[1].text(0.5, 0.5, 'Comparison unavailable', ha='center', va='center')\n", - " axes[1].set_axis_off()\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - "print(\"\\nKey insight: host_time is slightly slower due to CPU overhead,\")\n", - "print(\"but it catches ALL work on ALL streams - essential for untrusted code!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### The `discard_first` Effect\n", - "\n", - "Even after warmup, the first timing trial can be affected by lazy initialization. Let's see this in action." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:50.241069Z", - "iopub.status.busy": "2025-12-17T21:24:50.240945Z", - "iopub.status.idle": "2025-12-17T21:24:50.348421Z", - "shell.execute_reply": "2025-12-17T21:24:50.347364Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Demonstrating the discard_first effect:\n", - "============================================================\n", - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", - "\n", - "First trial: 0.3660 ms\n", - "Mean of all trials: 0.3455 ms\n", - "Mean without first: 0.3440 ms\n", - "First trial overhead: 6.4%\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "The first trial often shows initialization overhead even after warmup.\n", - "Using discard_first=1 (default) gives more consistent measurements.\n" - ] - } - ], - "source": [ - "# Demonstrate the discard_first effect\n", - "# Even after warmup, the first timing trial can have higher overhead\n", - "\n", - "print(\"Demonstrating the discard_first effect:\")\n", - "print(\"=\" * 60)\n", - "\n", - "# Create fresh data and clear caches to make initialization overhead more visible\n", - "torch.cuda.empty_cache()\n", - "a_fresh, b_fresh = get_data(2048)\n", - "\n", - "# Collect trials with discard_first=0 to see ALL trials including the first one\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "times_all = timing_fn(\n", - " simple_mm, [a_fresh, b_fresh],\n", - " num_warmup=3,\n", - " num_trials=15,\n", - " discard_first=0, # Keep ALL trials including first\n", - " verbose=False,\n", - " device=DEVICE\n", - ")\n", - "\n", - "# Calculate statistics\n", - "first_trial = times_all[0]\n", - "remaining_trials = times_all[1:]\n", - "mean_all = np.mean(times_all)\n", - "mean_remaining = np.mean(remaining_trials)\n", - "\n", - "print(f\"\\nFirst trial: {first_trial:.4f} ms\")\n", - "print(f\"Mean of all trials: {mean_all:.4f} ms\")\n", - "print(f\"Mean without first: {mean_remaining:.4f} ms\")\n", - "print(f\"First trial overhead: {((first_trial / mean_remaining) - 1) * 100:.1f}%\")\n", - "\n", - "# Visualize the effect with a scatter plot\n", - "plt.figure(figsize=(10, 5))\n", - "plt.scatter(range(len(times_all)), times_all, alpha=0.7, color='blue', s=60)\n", - "plt.scatter([0], [first_trial], color='red', s=100, zorder=5, label=f'First trial: {first_trial:.3f}ms')\n", - "plt.axhline(y=mean_remaining, color='green', linestyle='--', alpha=0.7, \n", - " label=f'Mean (without first): {mean_remaining:.3f}ms')\n", - "plt.axhline(y=mean_all, color='orange', linestyle=':', alpha=0.7,\n", - " label=f'Mean (all): {mean_all:.3f}ms')\n", - "plt.xlabel('Trial Index')\n", - "plt.ylabel('Time (ms)')\n", - "plt.title('First Trial Overhead Effect (after warmup)')\n", - "plt.legend(loc='upper right')\n", - "plt.grid(True, alpha=0.3)\n", - "plt.show()\n", - "\n", - "print(\"\\nThe first trial often shows initialization overhead even after warmup.\")\n", - "print(\"Using discard_first=1 (default) gives more consistent measurements.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HwsjlhAazX2j" - }, - "source": [ - "## The \"Agent\" Trap: Reward Hacking via Hidden Streams\n", - "\n", - "When evaluating LLM-generated kernels (like with [Kernel Bench](https://github.com/ScalingIntelligence/KernelBench)), you're not just fighting measurement noise—you're fighting an optimizer that may inadvertently discover exploits in your harness.\n", - "\n", - "One such exploit: launching work on a **side stream** to make the kernel appear instantaneous." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:50.351000Z", - "iopub.status.busy": "2025-12-17T21:24:50.350876Z", - "iopub.status.idle": "2025-12-17T21:24:52.778917Z", - "shell.execute_reply": "2025-12-17T21:24:52.777685Z" - }, - "id": "UuwtML39zX2j", - "outputId": "95ebbb26-e415-491a-da30-6a78ce387906" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "Standard benchmark on tricky kernel: 0.1880 ms\n" - ] - } - ], - "source": [ - "def tricky_agent_kernel(a, b):\n", - " \"\"\"A 'clever' kernel that games the benchmarking harness.\"\"\"\n", - " # The agent creates a new stream to \"optimize\"\n", - " s = torch.cuda.Stream()\n", - " with torch.cuda.stream(s):\n", - " # This work happens on a side channel!\n", - " result = torch.matmul(a, b)\n", - " return result\n", - "\n", - "print(f\"Standard benchmark on tricky kernel: {final_benchmark(tricky_agent_kernel, a, b):.4f} ms\")\n", - "# Likely reports ~0.00ms or very close to it!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3HXns_XizX2j" - }, - "source": [ - "**The Issue:**\n", - "Standard benchmarking tools (including `do_bench`) record events on the *current default stream*.\n", - "\n", - "1. Benchmark starts timer on Stream A (the default stream).\n", - "2. Agent launches work on Stream B and returns immediately.\n", - "3. Benchmark stops timer on Stream A.\n", - "\n", - "Since Stream A had no work, the timer reports `~0.00ms`, while Stream B is still churning away in the background.\n", - "\n", - "**Why this matters for evals:**\n", - "If your reward signal is \"lower time = better score,\" an agent that discovers this pattern will be rewarded for producing *broken* code. The kernel \"runs\" instantly because you never measured it at all.\n", - "\n", - "**Mitigations:**\n", - "- **Wall-clock + full device sync:** Trade precision for correctness (catches all streams, but includes CPU overhead)\n", - "- **Static analysis:** Reject submissions that create `torch.cuda.Stream()` objects\n", - "- **Manual inspection:** For high-stakes evals, benchmark kernels in isolation outside the automated harness\n", - "\n", - "### How KernelBench Addresses This\n", - "\n", - "KernelBench's timing module provides the **`host_time`** method specifically designed for evaluating untrusted code:\n", - "\n", - "**Use `torch.cuda.synchronize()`** before AND after timing - this waits for ALL streams on the device, not just the default stream\n", - "\n", - "```python\n", - "# For trusted code (faster, but can be fooled)\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "# For untrusted/agent code (catches side-streams)\n", - "timing_fn = get_timing_function(\"host_time\")\n", - "```\n", - "\n", - "The trade-off: `host_time` includes some CPU overhead in the measurement. However, note that host_time should be pretty similar to sync_time. Therefore, if both times are within a some percent of each other, you can be pretty sure that the kernel is running correctly and score using sync_time." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:52.782281Z", - "iopub.status.busy": "2025-12-17T21:24:52.782061Z", - "iopub.status.idle": "2025-12-17T21:24:52.830292Z", - "shell.execute_reply": "2025-12-17T21:24:52.829161Z" - }, - "id": "KbAFqiyizX2j", - "outputId": "6bc91db4-935c-4af9-bdc9-be3c50e890c4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Robust benchmark on tricky kernel: 21.6298 ms\n", - "Robust benchmark on normal kernel: 21.5420 ms\n" - ] - } - ], - "source": [ - "def benchmark_untrusted(func, *args):\n", - " \"\"\"Benchmark untrusted code by using wall-clock time with full device sync.\n", - "\n", - " This trades some precision (includes CPU overhead) for correctness\n", - " (catches work on any stream).\n", - " \"\"\"\n", - " torch.cuda.synchronize() # Clear any pending work\n", - " start = time.perf_counter()\n", - " func(*args)\n", - " torch.cuda.synchronize() # Wait for ALL streams\n", - " end = time.perf_counter()\n", - " return (end - start) * 1000\n", - "\n", - "print(f\"Robust benchmark on tricky kernel: {benchmark_untrusted(tricky_agent_kernel, a, b):.4f} ms\")\n", - "print(f\"Robust benchmark on normal kernel: {benchmark_untrusted(simple_mm, a, b):.4f} ms\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:52.832854Z", - "iopub.status.busy": "2025-12-17T21:24:52.832734Z", - "iopub.status.idle": "2025-12-17T21:24:53.846639Z", - "shell.execute_reply": "2025-12-17T21:24:53.845578Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Side-Stream Detection Experiment:\n", - "============================================================\n", - "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", - "\n", - "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", - "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", - "Normal kernel with host_time: 21.5000 ms (reference)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Key insight: host_time correctly measures the tricky kernel!\n", - "Use host_time for evaluating untrusted/agent-generated code.\n" - ] - } - ], - "source": [ - "# Side-Stream Detection with KernelBench's host_time\n", - "# Let's demonstrate how host_time catches the tricky kernel\n", - "\n", - "print(\"Side-Stream Detection Experiment:\")\n", - "print(\"=\" * 60)\n", - "\n", - "# cuda_event (can be fooled by side-streams)\n", - "cuda_timing = get_timing_function(\"cuda_event\")\n", - "cuda_times = cuda_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", - "cuda_stats = get_timing_stats(cuda_times, device=DEVICE)\n", - "\n", - "# host_time (catches all streams)\n", - "host_timing = get_timing_function(\"host_time\")\n", - "host_times = host_timing(tricky_agent_kernel, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", - "host_stats = get_timing_stats(host_times, device=DEVICE)\n", - "\n", - "# Normal kernel for reference\n", - "normal_times = host_timing(simple_mm, [a, b], num_trials=10, verbose=False, device=DEVICE)\n", - "normal_stats = get_timing_stats(normal_times, device=DEVICE)\n", - "\n", - "print(f\"\\nTricky kernel with cuda_event: {cuda_stats['mean']:.4f} ms (FOOLED!)\")\n", - "print(f\"Tricky kernel with host_time: {host_stats['mean']:.4f} ms (CORRECT)\")\n", - "print(f\"Normal kernel with host_time: {normal_stats['mean']:.4f} ms (reference)\")\n", - "\n", - "# Visualize the dramatic difference\n", - "plt.figure(figsize=(10, 5))\n", - "methods = ['cuda_event\\n(fooled)', 'host_time\\n(correct)', 'Normal kernel\\n(reference)']\n", - "times = [cuda_stats['mean'], host_stats['mean'], normal_stats['mean']]\n", - "colors = ['red', 'green', 'blue']\n", - "\n", - "plt.bar(methods, times, color=colors, alpha=0.8)\n", - "plt.ylabel('Time (ms)')\n", - "plt.title('Side-Stream Detection: cuda_event vs host_time')\n", - "plt.grid(True, alpha=0.3, axis='y')\n", - "\n", - "# Add annotation\n", - "plt.annotate('Agent trick detected!', xy=(1, host_stats['mean']), \n", - " xytext=(1.3, host_stats['mean'] * 0.7),\n", - " arrowprops=dict(arrowstyle='->', color='green'),\n", - " fontsize=10, color='green')\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"\\nKey insight: host_time correctly measures the tricky kernel!\")\n", - "print(\"Use host_time for evaluating untrusted/agent-generated code.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Uq4qvl8FzX2j" - }, - "source": [ - "## Correctness Before Speed\n", - "\n", - "A kernel that runs in 0.1ms but produces garbage is worthless. Before you start optimizing, **always verify correctness** against a reference implementation." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "execution": { - "iopub.execute_input": "2025-12-17T21:24:53.849299Z", - "iopub.status.busy": "2025-12-17T21:24:53.849171Z", - "iopub.status.idle": "2025-12-17T21:24:53.929702Z", - "shell.execute_reply": "2025-12-17T21:24:53.928700Z" - }, - "id": "J9W63Q5czX2k", - "outputId": "312076ee-f089-4276-8b8f-bb7a23575d3d" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Correctness verified!\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "Kernel time: 0.0648 ms\n" - ] - } - ], - "source": [ - "def my_experimental_kernel(a, b):\n", - " \"\"\"Pretend this is our custom optimized kernel.\"\"\"\n", - " return torch.matmul(a, b) # In reality, this would be your Triton/CUDA code\n", - "\n", - "def verify_correctness(kernel_fn, ref_fn, *args, atol=1e-2, rtol=1e-2):\n", - " \"\"\"Verify kernel produces correct output before benchmarking.\"\"\"\n", - " ref_output = ref_fn(*args)\n", - " kernel_output = kernel_fn(*args)\n", - "\n", - " if not torch.allclose(ref_output, kernel_output, atol=atol, rtol=rtol):\n", - " max_diff = (ref_output - kernel_output).abs().max().item()\n", - " raise AssertionError(\n", - " f\"Kernel output doesn't match reference! \"\n", - " f\"Max difference: {max_diff:.6f}\"\n", - " )\n", - " print(\"✓ Correctness verified!\")\n", - " return True\n", - "\n", - "# Always verify before benchmarking\n", - "a_test, b_test = get_data(1024)\n", - "verify_correctness(my_experimental_kernel, simple_mm, a_test, b_test)\n", - "\n", - "# Only benchmark if correct\n", - "time_ms = final_benchmark(my_experimental_kernel, a_test, b_test)\n", - "print(f\"Kernel time: {time_ms:.4f} ms\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Computing TFLOPS: Are We Hitting the Speed of Light?\n", - "\n", - "It is also important to sanity check the results whether it is to see how well we are doing, or to see if our results are physically possible.\n", - "\n", - "To answer this, we convert our millisecond timings into **TFLOPS** (Tera Floating-Point Operations Per Second) and compare against the hardware's theoretical maximum—often called the **\"speed of light\"** or **roofline**.\n", - "\n", - "### Understanding Roofline Analysis\n", - "\n", - "The Roofline Model helps you understand whether your kernel is:\n", - "- **Compute-bound**: Limited by the GPU's arithmetic throughput (FLOPS)\n", - "- **Memory-bound**: Limited by memory bandwidth (GB/s)\n", - "\n", - "**Key formulas:**\n", - "- **Arithmetic Intensity** = FLOPs / Bytes accessed\n", - "- **Theoretical Peak FLOPS** = Clock speed × Cores × FLOPs/cycle\n", - "- **Theoretical Peak Bandwidth** = Memory clock × Bus width × 2 (for DDR)\n", - "\n", - "For matrix multiplication of two $N \\times N$ matrices:\n", - "- **FLOPs** = $2N^3$ (one multiply + one add per output element, summed $N$ times)\n", - "- **Bytes** = $3N^2 \\times \\text{sizeof(dtype)}$ (read A, read B, write C)\n", - "- **Arithmetic Intensity** = $\\frac{2N^3}{3N^2 \\times 4} = \\frac{N}{6}$ for float32\n", - "\n", - "Large matrix multiplications are highly compute-bound (high arithmetic intensity), so we expect to approach the compute roofline. For a deeper dive into roofline analysis and speed-of-light calculations, see the excellent [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/)." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "execution": { - "iopub.execute_input": "2025-12-17T21:24:53.932346Z", - "iopub.status.busy": "2025-12-17T21:24:53.932227Z", - "iopub.status.idle": "2025-12-17T21:24:56.741833Z", - "shell.execute_reply": "2025-12-17T21:24:56.740706Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Matrix Multiplication Performance\n", - "=================================================================\n", - "Size Time (ms) TFLOPS % of TF32 Peak \n", - "-----------------------------------------------------------------\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "1024 0.0648 33.14 3.4 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "2048 0.3440 49.94 5.0 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "4096 2.6800 51.28 5.2 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "8192 21.4000 51.38 5.2 %\n", - "\n", - "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n", - "H200 TF32 theoretical peak: 989.0 TFLOPS\n", - "\n", - "For roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\n" - ] - } - ], - "source": [ - "def get_tflops(n, time_ms):\n", - " \"\"\"Calculate achieved TFLOPS for matrix multiplication.\"\"\"\n", - " flops = 2 * n ** 3 # Multiply-add for each of N^2 output elements\n", - " tflops = flops / (time_ms * 1e-3) / 1e12\n", - " return tflops\n", - "\n", - "# Theoretical peaks vary by GPU and precision\n", - "# PyTorch uses TF32 by default on Ampere+ GPUs for matmul\n", - "GPU_PEAK_TFLOPS = {\n", - " 'A100': {'fp32': 19.5, 'tf32': 156.0, 'fp16': 312.0},\n", - " 'H100': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", - " 'H200': {'fp32': 67.0, 'tf32': 989.0, 'fp16': 1979.0},\n", - "}\n", - "\n", - "# Use TF32 peak since PyTorch defaults to TF32 on Ampere+\n", - "PEAK_TFLOPS = 989.0 # H200 TF32 peak\n", - "\n", - "# Benchmark at different sizes\n", - "print(\"Matrix Multiplication Performance\")\n", - "print(\"=\" * 65)\n", - "print(f\"{'Size':<8} {'Time (ms)':<12} {'TFLOPS':<12} {'% of TF32 Peak':<15}\")\n", - "print(\"-\" * 65)\n", - "\n", - "for size in [1024, 2048, 4096, 8192]:\n", - " a_test, b_test = get_data(size)\n", - " time_ms = final_benchmark(simple_mm, a_test, b_test)\n", - " tflops = get_tflops(size, time_ms)\n", - " efficiency = (tflops / PEAK_TFLOPS) * 100\n", - " print(f\"{size:<8} {time_ms:<12.4f} {tflops:<12.2f} {efficiency:<15.1f}%\")\n", - "\n", - "print(f\"\\nNote: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\")\n", - "print(f\"H200 TF32 theoretical peak: {PEAK_TFLOPS} TFLOPS\")\n", - "print(f\"\\nFor roofline analysis details, see: https://jax-ml.github.io/scaling-book/roofline/\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "zcYVXCkUzX2k" - }, - "source": [ - "## Conclusion\n", - "\n", - "Benchmarking on GPUs is fundamentally different from CPUs. The asynchronous nature of kernel launches, the hidden state of the L2 cache, and the noise of the OS scheduler all conspire to give you the wrong numbers.\n", - "\n", - "### What We Learned\n", - "\n", - "Through our journey, we discovered that robust GPU benchmarking requires:\n", - "1. **Device Synchronization** - Wait for GPU work to complete\n", - "2. **CUDA Events** - Use GPU-side timestamps, not CPU clocks\n", - "3. **Warmup Runs** - Settle compilation and memory allocators\n", - "4. **Multiple Samples** - Build statistical distributions\n", - "5. **L2 Cache Flushing** - Measure cold cache (realistic) performance\n", - "6. **Median Aggregation** - Filter out OS jitter and outliers\n", - "7. **Side-Stream Detection** - Catch work on non-default streams\n", - "\n", - "### What KernelBench Provides\n", - "\n", - "We've implemented all these best practices in **KernelBench's timing module** (`src/timing.py`):\n", - "\n", - "| Function | Purpose |\n", - "|----------|---------|\n", - "| `get_timing_function(method)` | Factory returning timing function by name |\n", - "| `clear_l2_cache(device)` | L2 cache flushing utility |\n", - "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\n", - "\n", - "**Four timing methods for different use cases:**\n", - "- **`cuda_event`** - Default for trusted code (fastest, GPU-side timing)\n", - "- **`host_time`** - For untrusted/agent code (catches all streams)\n", - "- **`do_bench`** - Triton-style adaptive trial counts\n", - "- **`do_bench_impl`** - Transparent do_bench with explicit control\n", - "\n", - "**Key parameters:**\n", - "- `num_warmup`, `num_trials`, `discard_first`, `device`, `verbose`\n", - "\n", - "### Recommended Usage\n", - "\n", - "```python\n", - "from src.timing import get_timing_function, get_timing_stats\n", - "\n", - "# For trusted code\n", - "timing_fn = get_timing_function(\"cuda_event\")\n", - "\n", - "# For agent evaluations (catches side-streams)\n", - "timing_fn = get_timing_function(\"host_time\")\n", - "\n", - "# Run benchmark\n", - "times = timing_fn(kernel, args, num_warmup=10, num_trials=100, device=\"cuda:0\")\n", - "stats = get_timing_stats(times, device=\"cuda:0\")\n", - "print(f\"Mean: {stats['mean']:.4f}ms, Std: {stats['std']:.4f}ms\")\n", - "```\n", - "\n", - "Happy optimizing!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7Ah151CHzX2k" - }, - "source": [ - "---\n", - "\n", - "### Footnotes\n", - "\n", - "**On GPU Clock States:** For highly reproducible benchmarks (e.g., publishing papers), consider locking GPU clocks with `nvidia-smi -lgc `. GPUs dynamically adjust clock speeds based on thermals and power, which can introduce variance between runs. For most development work, median-based benchmarking handles this adequately.\n", - "\n", - "**On Warmup Iterations:** We use fixed warmup counts (10-50 iterations) for simplicity, but this can be insufficient or wasteful depending on the kernel. In extremely sensitive environments, you can implement an adaptive stopping criterion: run warmup iterations until the variance of recent samples falls below a threshold, indicating the system has stabilized. This is covered in more detail in the [GPU MODE lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU).\n", - "\n", - "**On Bare Metal vs. Virtualized Environments:** Cloud VMs and containers add layers of abstraction that can introduce variance and overhead. GPU passthrough in virtualized environments adds latency, and shared cloud instances suffer from \"noisy neighbor\" effects where other tenants' workloads impact your measurements. For publishable results or when chasing small performance deltas, prefer bare metal. For day-to-day development, cloud instances are fine as long as you're aware your numbers may not match others exactly." - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "gpuType": "A100", - "include_colab_link": true, - "provenance": [] - }, - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.9" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb index 6b77fd20..a9f3ba15 100644 --- a/notebooks/benchmarking.ipynb +++ b/notebooks/benchmarking.ipynb @@ -63,7 +63,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/simon/miniconda3/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "/home/simon/palic/KernelBench/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] }, @@ -82,8 +82,12 @@ "# !pip install -e .. # Install KernelBench locally for timing utilities\n", "\n", "import sys\n", + "import os\n", "sys.path.insert(0, '..') # Add parent directory to path for imports\n", "\n", + "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n", + "\n", "import torch\n", "import time\n", "import numpy as np\n", @@ -98,9 +102,9 @@ " raise RuntimeError(\"This notebook requires a GPU. Please enable GPU in your runtime settings.\")\n", "\n", "# Device configuration\n", - "# For multi-GPU systems, set CUDA_VISIBLE_DEVICES=X before running to select a specific GPU\n", "# The selected GPU will appear as cuda:0\n", - "DEVICE = \"cuda:0\"\n", + "\n", + "DEVICE = f\"cuda:0\"\n", "print(f\"Using GPU: {torch.cuda.get_device_name(DEVICE)}\")" ] }, @@ -166,7 +170,7 @@ "id": "GWlsBEVyzX2g" }, "source": [ - "### Attempt 1: The Naive Timer (The Asynchronous Illusion)\n", + "### Attempt 1: The Naive Timer\n", "\n", "The most intuitive way to time code in Python is using `time.time()`. Let's try that first." ] @@ -192,7 +196,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Naive time: 0.5236 ms\n" + "Naive time: 0.6356 ms\n" ] } ], @@ -232,6 +236,15 @@ "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32 Tensor Cores. At that rate: 1.1 TFLOP ÷ 989 TFLOP/s = **1.11ms minimum**. Anything under 1ms is physically impossible." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Attempt 2: Synchronizing the Device\n", + "\n", + "To fix this, we need to force the CPU to wait until the GPU has finished its work before we stop the clock. We do this with `torch.cuda.synchronize()`." + ] + }, { "cell_type": "code", "execution_count": 4, @@ -248,106 +261,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Comparing Synchronized time.time() vs CUDA Events:\n", - "------------------------------------------------------------\n", - "N= 512: sync= 0.0699ms, events= 0.0374ms, overhead=+0.0325ms\n", - "N=1024: sync= 0.0725ms, events= 0.0718ms, overhead=+0.0007ms\n", - "N=2048: sync= 0.3567ms, events= 0.3543ms, overhead=+0.0024ms\n", - "N=4096: sync= 2.7008ms, events= 2.6914ms, overhead=+0.0094ms\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Key insight: Synchronized timing includes 0.009ms of CPU overhead.\n", - "CUDA Events (2.6914ms) measure pure GPU execution time.\n" + "Sync time: 21.5368 ms\n" ] } ], "source": [ - "# Compare: Synchronized time.time() vs CUDA Events\n", - "# This shows why GPU-side timestamps are more accurate\n", - "\n", "def benchmark_sync(func, *args):\n", - " \"\"\"Attempt 2: Synchronized - waits for GPU but uses CPU clock.\"\"\"\n", - " torch.cuda.synchronize(device=DEVICE)\n", + " \"\"\"Better: Actually waits for GPU to finish.\"\"\"\n", + " torch.cuda.synchronize() # Wait for previous work to finish\n", " start = time.time()\n", " func(*args)\n", - " torch.cuda.synchronize(device=DEVICE)\n", + " torch.cuda.synchronize() # Wait for THIS work to finish\n", " end = time.time()\n", " return (end - start) * 1000\n", "\n", - "def benchmark_events(func, *args):\n", - " \"\"\"Attempt 3: CUDA Events - GPU-side timestamps, most accurate.\"\"\"\n", - " start_event = torch.cuda.Event(enable_timing=True)\n", - " end_event = torch.cuda.Event(enable_timing=True)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " start_event.record()\n", - " func(*args)\n", - " end_event.record()\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " return start_event.elapsed_time(end_event)\n", - "\n", - "# Test across different matrix sizes\n", - "sizes = [512, 1024, 2048, 4096]\n", - "sync_times = []\n", - "event_times = []\n", - "\n", - "print(\"Comparing Synchronized time.time() vs CUDA Events:\")\n", - "print(\"-\" * 60)\n", - "for s in sizes:\n", - " a_test, b_test = get_data(s)\n", - " # Warmup\n", - " for _ in range(3):\n", - " simple_mm(a_test, b_test)\n", - " torch.cuda.synchronize(device=DEVICE)\n", - " \n", - " sync_t = benchmark_sync(simple_mm, a_test, b_test)\n", - " event_t = benchmark_events(simple_mm, a_test, b_test)\n", - " \n", - " sync_times.append(sync_t)\n", - " event_times.append(event_t)\n", - " overhead = sync_t - event_t\n", - " print(f\"N={s:4d}: sync={sync_t:7.4f}ms, events={event_t:7.4f}ms, overhead={overhead:+.4f}ms\")\n", - "\n", - "# Create visualization\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", - "\n", - "# Left plot: Both methods across sizes\n", - "axes[0].plot(sizes, sync_times, 's-', label='Synchronized (CPU clock)', linewidth=2, markersize=8, color='orange')\n", - "axes[0].plot(sizes, event_times, '^-', label='CUDA Events (GPU clock)', linewidth=2, markersize=8, color='green')\n", - "axes[0].set_xlabel('Matrix Size (N)')\n", - "axes[0].set_ylabel('Time (ms)')\n", - "axes[0].set_title('CPU Clock vs GPU Clock Timing')\n", - "axes[0].legend()\n", - "axes[0].grid(True, alpha=0.3)\n", - "\n", - "# Right plot: Bar chart showing overhead at largest size\n", - "overhead_ms = sync_times[-1] - event_times[-1]\n", - "axes[1].bar(['Synchronized\\n(time.time + sync)', 'CUDA Events\\n(GPU timestamps)'], \n", - " [sync_times[-1], event_times[-1]], \n", - " color=['orange', 'green'], alpha=0.8)\n", - "axes[1].set_ylabel('Time (ms)')\n", - "axes[1].set_title(f'CPU Overhead at N={sizes[-1]}\\n(Sync includes ~{overhead_ms:.3f}ms CPU overhead)')\n", - "axes[1].axhline(y=event_times[-1], color='green', linestyle='--', alpha=0.5, label='True GPU time')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(f\"\\nKey insight: Synchronized timing includes {overhead_ms:.3f}ms of CPU overhead.\")\n", - "print(f\"CUDA Events ({event_times[-1]:.4f}ms) measure pure GPU execution time.\")" + "t = benchmark_sync(simple_mm, a, b)\n", + "print(f\"Sync time: {t:.4f} ms\")" ] }, { @@ -382,9 +311,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Run 0: 21.9622 ms\n", - "Run 1: 21.6770 ms\n", - "Run 2: 21.4259 ms\n" + "Run 0: 21.7344 ms\n", + "Run 1: 21.4754 ms\n", + "Run 2: 21.4987 ms\n" ] } ], @@ -442,9 +371,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Run 0: 21.4824 ms\n", - "Run 1: 21.4355 ms\n", - "Run 2: 21.4300 ms\n" + "Run 0: 21.6478 ms\n", + "Run 1: 21.4837 ms\n", + "Run 2: 21.4852 ms\n" ] } ], @@ -504,7 +433,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -516,11 +445,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mean: 21.4449 ms\n", - "Median: 21.4454 ms\n", - "Std: 0.0213 ms\n", - "Min: 21.4074 ms\n", - "Max: 21.5199 ms\n" + "Mean: 21.5096 ms\n", + "Median: 21.4942 ms\n", + "Std: 0.0625 ms\n", + "Min: 21.4420 ms\n", + "Max: 21.7808 ms\n" ] } ], @@ -628,9 +557,9 @@ "\n", "With cache flushing (cold cache):\n", "\n", - "Warm cache median: 0.0283 ms\n", - "Cold cache median: 0.0323 ms\n", - "Difference: 0.0040 ms (14.3% slower with cold cache)\n", + "Warm cache median: 0.0280 ms\n", + "Cold cache median: 0.0318 ms\n", + "Difference: 0.0038 ms (13.7% slower with cold cache)\n", "\n", "Without cache flushing, you measure artificially fast times!\n" ] @@ -642,8 +571,10 @@ "N_SMALL = 512\n", "a_small, b_small = get_data(N_SMALL)\n", "\n", + "NUM_SAMPLES = 20\n", + "\n", "# do warmup runs\n", - "for _ in range(10):\n", + "for _ in range(NUM_SAMPLES):\n", " clear_l2_cache(device=DEVICE)\n", " benchmark_events(simple_mm, a_small, b_small)\n", " torch.cuda.synchronize(device=DEVICE)\n", @@ -651,14 +582,14 @@ "# Benchmark WITHOUT cache flushing (warm cache - unrealistic)\n", "print(\"Without cache flushing (warm cache):\")\n", "times_warm = []\n", - "for i in range(10):\n", + "for i in range(NUM_SAMPLES):\n", " t = benchmark_events(simple_mm, a_small, b_small)\n", " times_warm.append(t)\n", "\n", "# Benchmark WITH cache flushing (cold cache - realistic)\n", "print(\"\\nWith cache flushing (cold cache):\")\n", "times_cold = []\n", - "for i in range(10):\n", + "for i in range(NUM_SAMPLES):\n", " clear_l2_cache(device=DEVICE) # Flush cache before each measurement\n", " t = benchmark_events(simple_mm, a_small, b_small)\n", " times_cold.append(t)\n", @@ -683,7 +614,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -694,14 +625,19 @@ ], "source": [ "# Visualize the cache effect\n", + "# Discard first few samples to remove initialization noise\n", + "discard = 3\n", + "times_warm_clean = times_warm[discard:]\n", + "times_cold_clean = times_cold[discard:]\n", + "\n", "plt.figure(figsize=(10, 5))\n", - "plt.scatter(range(len(times_warm)), times_warm, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm):.4f}ms)', color='orange', s=60)\n", - "plt.scatter(range(len(times_cold)), times_cold, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold):.4f}ms)', color='blue', s=60)\n", - "plt.axhline(y=np.mean(times_warm), color='orange', linestyle='--', alpha=0.5)\n", - "plt.axhline(y=np.mean(times_cold), color='blue', linestyle='--', alpha=0.5)\n", + "plt.scatter(range(len(times_warm_clean)), times_warm_clean, alpha=0.7, label=f'Warm Cache (mean={np.mean(times_warm_clean):.4f}ms)', color='orange', s=60)\n", + "plt.scatter(range(len(times_cold_clean)), times_cold_clean, alpha=0.7, label=f'Cold Cache (mean={np.mean(times_cold_clean):.4f}ms)', color='blue', s=60)\n", + "plt.axhline(y=np.mean(times_warm_clean), color='orange', linestyle='--', alpha=0.5)\n", + "plt.axhline(y=np.mean(times_cold_clean), color='blue', linestyle='--', alpha=0.5)\n", "plt.xlabel('Run Index')\n", "plt.ylabel('Time (ms)')\n", - "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication')\n", + "plt.title(f'Cache Effect on {N_SMALL}x{N_SMALL} Matrix Multiplication\\n(first {discard} samples discarded)')\n", "plt.legend()\n", "plt.grid(True, alpha=0.3)\n", "plt.show()" @@ -750,21 +686,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Profiling] Using timing method: cuda_event\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "KernelBench cuda_event time: 21.4000 ms\n" + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "KernelBench cuda_event time: 21.5000 ms\n" ] } ], @@ -880,7 +804,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2025-12-17T21:24:47.008751Z", @@ -898,63 +822,35 @@ "======================================================================\n", "\n", "Testing cuda_event...\n", - "[Profiling] Using timing method: cuda_event\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " cuda_event: 21.4000 ms (std=0.0169)\n", + "[Profiling] Using timing method: cuda_event\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " cuda_event: 21.5000 ms (std=0.0572)\n", "\n", "Testing host_time...\n", - "[Profiling] Using timing method: host_time\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " host_time: 21.6000 ms (std=0.0159)\n", + "[Profiling] Using timing method: host_time\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 50\n", + " host_time: 21.5000 ms (std=0.0427)\n", "\n", "Testing do_bench...\n", - "[Profiling] Using timing method: do_bench\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " do_bench: 21.4000 ms (std=0.0150)\n", + "[Profiling] Using timing method: do_bench\n", + " do_bench: 21.4000 ms (std=0.0030)\n", "\n", "Testing do_bench_impl...\n", - "[Profiling] Using timing method: do_bench_impl\n" + "[Profiling] Using timing method: do_bench_impl\n", + " do_bench_impl: 21.4000 ms (std=0.0315)\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " do_bench_impl: Skipped due to AttributeError (Triton version compatibility)\n" + "/tmp/ipykernel_710987/1660294801.py:64: UserWarning: Attempting to set identical low and high ylims makes transformation singular; automatically expanding.\n", + " axes[1].set_ylim(min_val - margin, max_val + margin)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1012,9 +908,15 @@ "\n", " axes[0].bar(available_methods, means, yerr=stds, capsize=5, color=colors, alpha=0.8)\n", " axes[0].set_ylabel('Time (ms)')\n", - " axes[0].set_title('Mean Execution Time by Method')\n", + " axes[0].set_title('Mean Execution Time by Method\\n(graph truncated for readability)')\n", " axes[0].tick_params(axis='x', rotation=45)\n", "\n", + " # Truncate y-axis to make differences easier to see\n", + " min_mean = min(means)\n", + " max_mean = max(means)\n", + " margin = (max_mean - min_mean) * 2\n", + " axes[0].set_ylim(min_mean - margin, max_mean + margin)\n", + "\n", " # Highlight cuda_event vs host_time with truncated y-axis for readability\n", " if 'cuda_event' in results and 'host_time' in results:\n", " cuda_mean = results['cuda_event']['mean']\n", @@ -1072,15 +974,15 @@ "[Profiling] Using timing method: cuda_event\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 15\n", "\n", - "First trial: 0.3454 ms\n", - "Mean of all trials: 0.3444 ms\n", - "Mean without first: 0.3443 ms\n", - "First trial overhead: 0.3%\n" + "First trial: 0.3660 ms\n", + "Mean of all trials: 0.3455 ms\n", + "Mean without first: 0.3440 ms\n", + "First trial overhead: 6.4%\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA18AAAHWCAYAAACIZjNQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhrpJREFUeJzt3Xl8DOcfB/DP7uaUU+5DJBH3GRU0bnVEUerWOkO16pai/LTuCi2q7rbq1jpKW1cpcRSNo0JRBBFSSuJMJJFrZ35/bHdkZRObSHYnyef9eu2LfebZmWf3uzM73zzPPKMQRVEEERERERERFSmlqRtARERERERUGjD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiomLp5s2bUCgUWLNmjambkm/Tpk2DQqEo0GtbtGiBFi1aFG6DjOzw4cNQKBT48ccfTd0UyZo1a6BQKHDz5s1CW2d8fDy6d+8OZ2dnKBQKLFy4EABw7do1tG3bFg4ODlAoFPj5558LbZuvYsuWLXByckJycnKBXv/FF1+gQoUKUKlUCAwMLNzGUYH07t0bPXv2NHUziCgbJl9EJEvak2F9j4kTJxbJNmfPnm3QiXCLFi1ybVv2x7Rp04qknYbKzMzEokWLUL9+fdjZ2cHW1hb169fHokWLkJmZadK2FVfaxDm3x71796S6Y8eOxb59+zBp0iSsX78e7dq1AwAMGDAAFy5cwGeffYb169cjKCioUNuYmpqKadOm4fDhwwa/Rq1WY+rUqRg5ciRsbW3zvc3ffvsNEyZMQOPGjbF69WrMnj0b//77L6ZNm4Zz587le31UOD7++GNs27YNf/31l6mbQkT/MTN1A4iI8jJjxgz4+/vrlNWsWRO+vr549uwZzM3NC21bs2fPRvfu3fH222/nWW/y5Ml47733pOenT5/GokWL8L///Q/VqlWTymvXrq339Z988kmRJZBaKSkp6NChA44cOYKOHTti4MCBUCqV2Lt3L0aPHo3t27dj9+7dsLGxKdJ2lFTLly/Xm6Q4OjpK/z948CA6d+6McePGSWXPnj1DZGQkJk+ejBEjRhRJ21JTUzF9+nQAMLiXdOfOnYiOjsb7779foG0ePHgQSqUS3333HSwsLAAAf/75J6ZPnw4/Pz/2hJlI3bp1ERQUhPnz52PdunWmbg4RgckXEcncm2++mWvPgJWV1Utfn5KSUugJRps2bXK0Y9GiRWjTpk2eJ7vatpiZmcHMrGgPv2FhYThy5AgWL16sc5L/4YcfYunSpRgxYgTGjRuH5cuXF2k7shNFEWlpaUbbXlHq3r07XFxc8qyTkJCgk4wBwP379wEgR7mprV69Go0bN4a3t3eBXp+QkABra2sp8SpKRbFPvwq5tedFPXv2xNSpU7Fs2bIC9WoSUeHisEMiKpb0XfM1cOBA2NraIiYmBu3bt4ednR369OkDQHOdTbdu3eDh4QErKyuUK1cOvXv3RmJiIgBAoVAgJSUFa9eulYaQDRw4sMDt0w5Pu3TpEt59912ULVsWTZo00VmW3erVq/HGG2/Azc0NlpaWqF69eoETo9u3b+O7777DG2+8obd3Zfjw4WjZsiVWrlyJ27dvA9D0JrZs2TJHXUEQ4O3tje7du+uULVy4EDVq1ICVlRXc3d3xwQcf4PHjxzqv9fPzQ8eOHbFv3z4EBQXB2toaX3/9tc56PvvsM5QrVw5WVlZo1aoVrl+/nqMNJ0+eRLt27eDg4IAyZcqgefPmOH78uE6dW7duYdiwYahSpQqsra3h7OyMHj166L2G6++//8Ybb7wBa2trlCtXDrNmzYIgCHl/qPmgHTIriiKWLl2qMwzV19cXADB+/HgoFAr4+flJr7tz5w4GDRoEd3d3WFpaokaNGli1alWO9aelpWHatGmoXLkyrKys4Onpia5duyImJgY3b96Eq6srAGD69OkGDYFNS0vD3r170bp16xzLDPleKhQKrF69GikpKdL21qxZg/r16wMAQkNDdcq1DIlrXvvRi548eQKVSoVFixZJZQ8ePIBSqYSzszNEUZTKP/zwQ3h4eEjPjx49ih49eqB8+fKwtLSEj48Pxo4di2fPnulsI69jjEKhwIgRI7B161ZUr14d1tbWCA4OxoULFwAAX3/9NSpWrAgrKyu0aNEix3fTz89P7zHnxes8tddMbt68Gf/73//g4eEBGxsbdOrUCf/880+O17dp0wYpKSnYv3+/3s+NiIyLPV9EJGuJiYl48OCBTllePQ5ZWVkICQlBkyZNMG/ePJQpUwYZGRkICQlBeno6Ro4cCQ8PD9y5cwe7du3CkydP4ODggPXr1+O9995DgwYNpKFXAQEBr9z+Hj16oFKlSpg9e7bOyd+Lli9fjho1aqBTp04wMzPDzp07MWzYMAiCgOHDh+drm7/++ivUajX69++fa53+/fvj0KFD2Lt3L9577z306tUL06ZNw71793ROSo8dO4Z///0XvXv3lso++OADrFmzBqGhoRg1ahRiY2OxZMkSnD17FsePH9cZChodHY133nkHH3zwAYYMGYIqVapIy+bMmQOlUolx48YhMTERn3/+Ofr06YOTJ09KdQ4ePIg333wT9erVw9SpU6FUKqWE4OjRo2jQoAEAzdDPP/74A71790a5cuVw8+ZNLF++HC1atMClS5dQpkwZAMC9e/fQsmVLZGVlYeLEibCxscE333wDa2vrfH3Gjx49ylFmZmYGR0dHNGvWDOvXr0e/fv3Qpk0bKQ61a9eGo6Mjxo4di3feeQft27eXeiLi4+Px+uuvSyfwrq6u+PXXXzF48GAkJSVhzJgxADTXZnXs2BERERHo3bs3Ro8ejadPn2L//v24ePEiWrdujeXLl+PDDz9Ely5d0LVrV2nbuTlz5gwyMjLw2muv5VhmyPdy/fr1+Oabb3Dq1CmsXLkSAFCpUiXMmDEDU6ZMwfvvv4+mTZsCABo1apSvuGoZsh85OjqiZs2a+P333zFq1CgAmu+vQqHAo0ePcOnSJdSoUQOAJtnStgkAtm7ditTUVHz44YdwdnbGqVOnsHjxYty+fRtbt27V2Y6+Y4zW0aNHsWPHDumzCQ8PR8eOHTFhwgQsW7YMw4YNw+PHj/H5559j0KBBOHjwYK5xeZnPPvsMCoUCH3/8MRISErBw4UK0bt0a586d0/k+axPB48ePo0uXLgXeHhEVEpGISIZWr14tAtD7EEVRjI2NFQGIq1evll4zYMAAEYA4ceJEnXWdPXtWBCBu3bo1z23a2NiIAwYMyHdbt27dKgIQDx06JJVNnTpVBCC+8847Oeprl2WXmpqao15ISIhYoUIFnbLmzZuLzZs3z7M9Y8aMEQGIZ8+ezbVOVFSUCEAMCwsTRVEUo6OjRQDi4sWLdeoNGzZMtLW1ldp39OhREYC4ceNGnXp79+7NUe7r6ysCEPfu3atT99ChQyIAsVq1amJ6erpU/tVXX4kAxAsXLoiiKIqCIIiVKlUSQ0JCREEQpHqpqamiv7+/2KZNG52yF0VGRooAxHXr1uX4bE6ePCmVJSQkiA4ODiIAMTY2NtfPTBSfx07fo0qVKjp1AYjDhw/XKdN+b7/44gud8sGDB4uenp7igwcPdMp79+4tOjg4SO9v1apVIgBxwYIFOdqm/Yzu378vAhCnTp2a53vRWrlypc7nnp2h38sBAwaINjY2OmWnT5/OsY9q22loXPPaj/QZPny46O7uLj0PCwsTmzVrJrq5uYnLly8XRVEUHz58KCoUCvGrr77K832Gh4eLCoVCvHXrls771HeMEUVNvC0tLXW+Q19//bUIQPTw8BCTkpKk8kmTJuX4vvn6+uo9/ry4z2v3H29vb511btmyRQSg8760KleuLL755ps5yonI+DjskIhkbenSpdi/f7/O42U+/PBDnecODg4AgH379iE1NbVI2pmboUOHGlQv+1+qtb19zZs3x40bN6ShkYZ6+vQpAMDOzi7XOtplSUlJAIDKlSsjMDAQmzdvluqo1Wr8+OOPeOutt6T2bd26FQ4ODmjTpg0ePHggPerVqwdbW1scOnRIZzv+/v4ICQnR24bQ0FCda4S0PRE3btwAAJw7dw7Xrl3Du+++i4cPH0rbSklJQatWrfD7779LwwWzf36ZmZl4+PAhKlasCEdHR0RFRUnL9uzZg9dff12nZ8XV1VUaOmaobdu25fherl69Ol/r0BJFEdu2bcNbb70FURR1PteQkBAkJiZK72Hbtm1wcXHByJEjc6ynoLcvePjwIQCgbNmyOZYV5vdSKz9x1TJ0P2ratCni4+MRHR0NQNMT1axZMzRt2hRHjx4FoOkNE0VRp+cr+/tMSUnBgwcP0KhRI4iiiLNnz+bYzovHGK1WrVrpDCVt2LAhAKBbt246+6O2XPtdL4j+/fvrrLN79+7w9PTEnj17ctQtW7ZsjhEERGQaHHZIRLLWoEGDfE3FbWZmhnLlyumU+fv7IywsDAsWLMDGjRvRtGlTdOrUCX379pUSs6Ly4kyNuTl+/DimTp2KyMjIHAliYmJivtqpPSHTJmH66EvQevXqhf/973+4c+cOvL29cfjwYSQkJKBXr15SnWvXriExMRFubm5615uQkKDzPK/3X758eZ3n2pN/7bVj165dA6CZmj03iYmJKFu2LJ49e4bw8HCsXr0ad+7c0Rmalj1JuHXrlnTim1324ZCGaNas2Usn3DDU/fv38eTJE3zzzTf45ptv9NbRfq4xMTGoUqVKkUzYIuoZzleY30ut/MRVy9D9SJtQHT16FOXKlcPZs2cxa9YsuLq6Yt68edIye3t71KlTR3pdXFwcpkyZgh07duS4dvHFJFPfMUbrxe+09vPx8fHRW/7itvKjUqVKOs8VCgUqVqyo9zpHURQLnJwTUeFi8kVEJYqlpSWUypyd+vPnz8fAgQPxyy+/4LfffsOoUaMQHh6OEydO5HoiVRgMuZYoJiYGrVq1QtWqVbFgwQL4+PjAwsICe/bswZdffpnvySC0092fP38+1ym+z58/D0BzPYhWr169MGnSJGzduhVjxozBli1b4ODgIN2fCtBMkuHm5oaNGzfqXa92sgetvN6/SqXSW65NArTv+4svvsj1fWivmRo5ciRWr16NMWPGIDg4WLqBce/evQt1Mo2ioG1f3759c01I8rpm61U5OzsD0CQC2feFwv5eauUnrlqGXpPn5eUFf39//P777/Dz84MoiggODoarqytGjx6NW7du4ejRo2jUqJF0nFCr1WjTpg0ePXqEjz/+GFWrVoWNjQ3u3LmDgQMH5nifuR1jgNy/0y/7rgO591yq1epcX2+ox48f50jWiMg0mHwRUalRq1Yt1KpVC5988gn++OMPNG7cGCtWrMCsWbMAFHzY1qvauXMn0tPTsWPHDp2/nL84hM9Qb775JlQqFdavX5/rpBvr1q2DmZmZTmLl7++PBg0aYPPmzRgxYgS2b9+Ot99+G5aWllKdgIAAHDhwAI0bN873JBX5pZ3wxN7eXu9MfNn9+OOPGDBgAObPny+VpaWl4cmTJzr1fH19pZ6X7LTD1EzB1dUVdnZ2UKvVL32fAQEBOHnyJDIzM3O9x11+v8dVq1YFAMTGxqJWrVpS+at+L3NrR37iWhBNmzbF77//Dn9/fwQGBsLOzg516tSBg4MD9u7di6ioKOk+aABw4cIFXL16FWvXrtXZX4w9O2DZsmVzfF8BTW9thQoVcpS/+D0WRRHXr1/PkahnZWXhn3/+QadOnQq1vURUMLzmi4hKvKSkJGRlZemU1apVC0qlEunp6VKZjY2N3pOfoqb9q/aLQ+UKeg2Rj48PQkNDceDAAb3T1a9YsQIHDx7E4MGDc/T69erVCydOnMCqVavw4MEDnSGHgOaeQWq1GjNnzsyx3qysrEL9/OrVq4eAgADMmzcPycnJOZZr75kFaD7DF4fNLV68GGq1Wqesffv2OHHiBE6dOqWzntx68oxBpVKhW7du2LZtGy5evJhjefb32a1bNzx48ABLlizJUU/7/rWz7xkai3r16sHCwgJ//vlnjnZlXy+Qv++l9t5XL7YjP3EtiKZNm+LmzZvYvHmzNAxRqVSiUaNGWLBgATIzM3Wu99L3PkVRxFdfffVK7civgIAAnDhxAhkZGVLZrl279E4fD2j+gJJ9aPGPP/6Iu3fv4s0339Spd+nSJaSlpUkzTRKRabHni4hKvIMHD2LEiBHo0aMHKleujKysLKxfv1466dWqV68eDhw4gAULFkjDl/RdH1TY2rZtCwsLC7z11lv44IMPkJycjG+//RZubm64e/dugdb55Zdf4sqVKxg2bBj27t0r9XDt27cPv/zyC5o3b67TS6TVs2dPjBs3DuPGjYOTk1OOnonmzZvjgw8+QHh4OM6dO4e2bdvC3Nwc165dw9atW/HVV1/p3BPsVSiVSqxcuRJvvvkmatSogdDQUHh7e+POnTs4dOgQ7O3tsXPnTgBAx44dsX79ejg4OKB69eqIjIzEgQMHpCF1WhMmTMD69evRrl07jB49Wppq3tfXVxqKaYgff/xR7w1r27RpA3d393y/1zlz5uDQoUNo2LAhhgwZgurVq+PRo0eIiorCgQMHpKnt+/fvj3Xr1iEsLAynTp1C06ZNkZKSggMHDmDYsGHo3LkzrK2tUb16dWzevBmVK1eGk5MTatasiZo1a+rdtpWVFdq2bYsDBw5gxowZUvmrfi8DAgLg6OiIFStWwM7ODjY2NmjYsCH8/f0NjmtBaBOr6OhozJ49Wypv1qwZfv31V1haWkr3IAM0PX8BAQEYN24c7ty5A3t7e2zbtu2VrscqiPfeew8//vgj2rVrh549eyImJgYbNmzI9ZYXTk5OaNKkCUJDQxEfH4+FCxeiYsWKGDJkiE69/fv3o0yZMjluDk9EJmL0+RWJiAygnWr+9OnTepfnNtX8i9Ndi6Io3rhxQxw0aJAYEBAgWllZiU5OTmLLli3FAwcO6NS7cuWK2KxZM9Ha2loEYPC083lNNX///v0c9fVNNb9jxw6xdu3aopWVlejn5yfOnTtXmlY8+3TUhkw1r5Weni5++eWXYr169UQbGxuxTJky4muvvSYuXLhQzMjIyPV1jRs3FgGI7733Xq51vvnmG7FevXqitbW1aGdnJ9aqVUucMGGC+O+//0p1fH19xQ4dOuR4rXaq7Ben/tcXU1HU3Cqga9euorOzs2hpaSn6+vqKPXv2FCMiIqQ6jx8/FkNDQ0UXFxfR1tZWDAkJEa9cuaJ3+u7z58+LzZs3F62srERvb29x5syZ4nfffffKU82/+B1APqaaF0VRjI+PF4cPHy76+PiI5ubmooeHh9iqVSvxm2++0amXmpoqTp48WfT395fqde/eXYyJiZHq/PHHH2K9evVECwsLg6ad3759u6hQKMS4uDidckO/l7nte7/88otYvXp10czMLEdsDYlrXvtRXtzc3EQAYnx8vFR27NgxEYDYtGnTHPUvXboktm7dWrS1tRVdXFzEIUOGiH/99ZfBxxhRzF+8c9sH5s+fL3p7e4uWlpZi48aNxT///DPXqeZ/+OEHcdKkSaKbm5tobW0tdujQQWdafK2GDRuKffv2zfWzIiLjUohiHnf9JCIiohJPrVajevXq6Nmzp94hpSQfhw8fRsuWLbF169aX9jKfO3cOr732GqKionKd3ISIjIvXfBEREZVyKpUKM2bMwNKlS/Veh0XF05w5c9C9e3cmXkQywmu+iIiICL169coxwQoVb5s2bTJ1E4joBez5IiIiIiIiMgJe80VERERERGQE7PkiIiIiIiIyAiZfRERERERERsAJNwpIEAT8+++/sLOzg0KhMHVziIiIiIjIRERRxNOnT+Hl5QWlMvf+LSZfBfTvv//Cx8fH1M0gIiIiIiKZ+Oeff1CuXLlclzP5KiA7OzsAmg/Y3t7epG0RBAH379+Hq6trnpk2GQ9jIi+Mh/wwJvLDmMgL4yE/jIn8yCkmSUlJ8PHxkXKE3DD5KiDtUEN7e3tZJF9paWmwt7c3+RePNBgTeWE85IcxkR/GRF4YD/lhTORHjjF52eVI8mglERERERFRCcfki4iIiIiIyAiYfBERERERERkBr/kiIiIiyidRFJGVlQW1Wl0k6xcEAZmZmUhLS5PNtSylHWMiP8aMiUqlgpmZ2SvfYorJFxEREVE+ZGRk4O7du0hNTS2ybYiiCEEQ8PTpU95PVCYYE/kxdkzKlCkDT09PWFhYFHgdTL6IiIiIDCQIAmJjY6FSqeDl5QULC4siOenT9qwVxl/aqXAwJvJjrJiIooiMjAzcv38fsbGxqFSpUoF72ph8FXeiCDx4ANU//wBKJeDqCvCAQEREVCQyMjIgCAJ8fHxQpkyZItsOT/TlhzGRH2PGxNraGubm5rh16xYyMjJgZWVVoPVwwGpx9eQJ8NVXQKVKULq7w7VBAyjd3YFKlTTlT56YuoVEREQlFq/5ISp9CmO/55GjONq3DyhXDhg7FuKNGzqLxBs3gLFjNcv37TNRA4mIiIiI6EVMvoqbffuADh0gPnsGiCIUoqizWCGKgChqlnfowASMiIhIjv67bAA3b2r+feH3nIhKJiZfxcmTJ0C3bhBFEQpByLOqQhAgiiLQrRuHIBIREclFtssG4OoK+Ptr/jXhZQMtWrTAmDFjjL7dl/Hz88PChQsNrr9mzRo4OjoWWXuICgOTr+Jk7VogNfWliZeWQhCA1FRg3boibhgRERG9VLbLBvDCZQMo4ssGBg4cCIVCkeNx/fp1bN++HTNnznyl9SsUCvz888951rl58yYUCgXOnTtn0DpPnz6N999//5XaZYjDhw/jtddeg6WlJSpWrIg1a9bkWT86OhotW7aEu7s7rKysUKFCBXzyySfIzMzUqffkyRMMHz4cnp6esLS0ROXKlbFnzx6dOnfu3EHfvn3h7OwMa2tr1KpVC3/++Wdhv0WSEc52WFyIIrB4MUQA+ZnLRQSgWLQIGDmSsyASERGZyn+XDeC/ywNy0JZpLxvYtQto1apQm9CuXTusXr1ap8zV1RUqlSrP12VkZLzSfY3yS7s9V1fXIt9WbGwsOnTogKFDh2Ljxo2IiIjAe++9B09PT4SEhOh9jbm5Ofr374/XXnsNjo6O+OuvvzBkyBAIgoDZs2dL76FNmzZwc3PDjz/+CG9vb9y6dUunZ+7x48do3LgxWrZsiV9//RWurq64du0aypYtW+Tvm0yHPV/FxcOHQExMjmu8XkYhikBMDPDoURE1jIiIiPL032UDEEXgZaNXBEFTr3v3Qh+CaGlpCQ8PD52HSqXKMezQz88PM2fORP/+/WFvb4/3338fGRkZGDFiBDw9PWFlZQVfX1+Eh4dL9QGgS5cuUCgU0vMX+fv7AwDq1q0LhUKBFi1aAND0yr399tv47LPP4OXlhSpVqkjrzT7scMGCBahVqxZsbGzg4+ODYcOGITk5+ZU+kxUrVsDf3x/z589HtWrVMGLECHTv3h1ffvllrq+pUKECQkNDUadOHfj6+qJTp07o06cPjh49KtVZtWoVHj16hJ9//hmNGzeGn58fmjdvjjp16kh15s6dCx8fH6xevRoNGjSAv78/2rZti4CAAKmOn58fZs2ahf79+8PW1ha+vr7YsWMH7t+/j86dO8PW1ha1a9fW6S27desW3nrrLZQtWxY2NjaoUaNGjh43Mh0mX8XFKx5c8PRp4bSDiIiI8ue/ywZemnhp/XfZgHLDhqJtVx7mzZuHOnXq4OzZs/j000+xaNEi7NixA1u2bEF0dDQ2btwoJVmnT58GAKxevRp3796Vnr/o1KlTAIADBw7g7t272L59u7QsIiIC0dHR2L9/P3bt2qX39UqlEosWLcLff/+NtWvX4uDBg5gwYUKu70E7zPHw4cO51omMjETr1q11ykJCQhAZGZnra150/fp17N27F82bN5fKduzYgeDgYAwfPhzu7u6oWbMmZs+eDbVarVMnKCgIPXr0gJubG+rWrYtvv/02x/q//PJLNG7cGGfPnkWHDh3Qr18/9O/fH3379kVUVBQCAgLQv39/zbX+AIYPH4709HT8/vvvuHDhAubOnQtbW1uD3w8VLQ47LC5edaexsyucdhAREZHh/rtsoCCUS5YAo0cX2mUDu3bt0jkJf/PNN7F161a9dd944w189NFH0vO4uDhUqlQJTZo0gUKhgK+vr7RMOzzQ0dERHh4euW5fW8/Z2TlHPRsbG6xcuTLP4Y0v9s7NmjULQ4cOxbJly/TWNzc3R5UqVfK8Gfa9e/fg7u6uU+bu7o6kpCQ8e/YM1tbWub62UaNGiIqKQnp6Ot5//33MmDFDWnbjxg0cPHgQffr0wZ49e3D9+nUMGzYMmZmZmDp1qlRn+fLlCAsLw//+9z+cPn0ao0aNgoWFBQYMGCCtq3379vjggw8AAFOmTMHy5ctRv3599OjRAwDw8ccfIzg4GPHx8fDw8EBcXBy6deuGWrVqAdD01JF8MPkqLpydgYAAiDdu5GvooahQQFGhAuDkVISNIyIiIr3+u2wgvxSiCNy4AfHRI8DFpVCa0rJlSyxfvlx6bmNjk2vdoKAgnecDBw5EmzZtUKVKFbRr1w4dO3ZE27ZtC6VdAFCrVq2XXld24MABhIeH48qVK0hKSkJWVhbS0tKQmpqqN8Hy9vbGlStXCq2NL9q8eTOePn2Kv/76C+PHj8e8efOknjhBEODm5oZvvvkGKpUK9erVw507d/DFF19IyZcgCAgKCpKuE6tbty4uXryIFStW6CRftWvXlv6vTRS1iVX2soSEBHh4eGDUqFH48MMP8dtvv6F169bo1q2bzjrItDjssLhQKICRI/M12Qbw3+Qco0Zxsg0iIiJTkNFlAzY2NqhYsaL08PT0zLNudq+99hpiY2Mxc+ZMPHv2DD179kT37t0LtW15uXnzJjp27IjatWtj27ZtOHPmDJYuXQpAM7lFQXl4eCA+Pl6nLD4+Hvb29nn2egGAj48PqlevjnfeeQdz5szBtGnTpGGFnp6eqFy5ss5kJtWqVcO9e/ek9np6eqJ69eo666xWrRri4uJ0yszNzaX/K/47n9NXJvw3rPW9997DjRs30K9fP1y4cAFBQUFYXMDeVyp8TL6KkwEDgDJlICoNC5uoVAJlygD9+xdxw4iIiEivEnTZgL29PXr16oVvv/0WmzdvxrZt2/Dovwm9zM3Nda5n0kfbs/WyevqcOXMGgiBg/vz5eP3111G5cmX8+++/+X8TLwgODkZERIRO2f79+xEcHJyv9QiCgMzMTCkBaty4Ma5fvy49B4CrV6/C09NT+hwaN26M6OhonfVcvXpVZ0hnQfn4+GDo0KHYvn07PvroI73XkpFpMPkqThwdgW3boFAoXpqAiUql5i8h27drXkdERETG999lA/kdgSIqFBBldNnAggUL8MMPP+DKlSu4evUqtm7dCg8PD2nqdD8/P0RERODevXt4/Pix3nW4ubnB2toae/fuRXx8PBITEw3efsWKFZGZmYnFixfjxo0bWL9+PVasWJHna+7cuYOqVatKE33oM3ToUNy4cQMTJkzAlStXsGzZMmzZsgVjx46V6ixZsgStsk37v3HjRmzZsgWXL1/GjRs3sGXLFkyaNAm9evWSeqQ+/PBDPHr0CKNHj8bVq1exe/duzJ49G8OHD5fWM3bsWJw4cQKzZ8/G9evX8f333+Obb77RqVMQY8aMwb59+xAbG4uoqCgcOnQI1apVe6V1UuFh8lXchIQAu3dDYW0NKBQQXziYiwoFoFBolu/ZAxTieGwiIiLKp/8uGygIYcQI2Vw2YGdnh88//xxBQUGoX78+bt68iT179kD53x+D58+fj/3798PHxwd169bVuw4zMzMsWrQIX3/9Nby8vNC5c2eDt1+nTh0sWLAAc+fORc2aNbFx40ZpqvvcZGZmIjo6GqmpqbnW8ff3x+7du7F//37UqVMH8+fPx8qVK3Xu8fXgwQPEZLtuz8zMDHPnzkWDBg1Qu3ZtTJ8+HSNGjMDKlSulOj4+Pti3bx9Onz6N2rVrY9SoURg9ejQmTpwo1alfvz5++ukn/PDDD6hZsyZmzpyJhQsXok+fPgZ/Lvqo1WoMHz4c1apVQ7t27VC5cuVcJyUh41OIYj5vHEUAgKSkJDg4OCAxMRH29vbGb8CTJ8C6dcCiRboX8gYEaK7xGjAAcHAwfrsIgGb4QUJCAtzc3KQfJjIdxkN+GBP5YUwMk5aWhtjYWPj7+8PKysqwFz15ApQrp7mBsiHTzSuVEK2tkRUbCzMXF+maHjItURSRlZUFMzMzxkQmjB2TvPZ/Q3MDHl2LK0dHTZJ17RqEhATcP3UKQkICcO2appyJFxERkTz8d9kAFArgZYmtUqmpt20bLxsgKoGYfBV3CgXg7Ay1j49mXDn/EkNERCQ//102gP8uG8jxe60t42UDRCUaky8iIiIiYwgJAW7fBhYuBF688W2FCpryO3eYeBGVYCZPvpYuXQo/Pz9YWVmhYcOGec5Is337dgQFBcHR0RE2NjYIDAzE+vXrc9S7fPkyOnXqBAcHB9jY2KB+/fo690xo0aIFFAqFzmPo0KFF8v6IiIiIJNkuG8CDB0BsrOZfXjZAVCqYmXLjmzdvRlhYGFasWIGGDRti4cKFCAkJQXR0NNzc3HLUd3JywuTJk1G1alVYWFhg165dCA0NhZubmzQrTUxMDJo0aYLBgwdj+vTpsLe3x99//53jorghQ4ZgxowZ0nN9d0YnIiIiKhL/XTYAZ2dTt4SIjMikydeCBQswZMgQhIaGAgBWrFiB3bt3Y9WqVTpTcWq1aNFC5/no0aOxdu1aHDt2TEq+Jk+ejPbt2+Pzzz+X6gUEBORYV5kyZeDh4VGI74aIiIiIiCh3Jku+MjIycObMGUyaNEkqUyqVaN26NSIjI1/6elEUcfDgQURHR2Pu3LkANNPk7t69GxMmTEBISAjOnj0Lf39/TJo0CW+//bbO6zdu3IgNGzbAw8MDb731Fj799NM8e7/S09ORnp4uPU9KSpK2KRgybWwREgQBoiiavB30HGMiL4yH/DAm8sOYGEb7OWkfRUm7ft4VSD4YE/kxZky0+72+839Dj50mS74ePHgAtVoNd3d3nXJ3d3dcuXIl19clJibC29sb6enpUKlUWLZsGdq0aQMASEhIQHJyMubMmYNZs2Zh7ty52Lt3L7p27YpDhw6hefPmAIB3330Xvr6+8PLywvnz5/Hxxx8jOjoa27dvz3W74eHhmD59eo7y+/fvIy0trSAfQaERBAGJiYkQRZH3ZpEJxkReGA/5YUzkhzExTGZmJgRBQFZWFrKysopsO6IoQq1WAwDvKSUTjIn8GDsmWVlZEAQBDx8+hLm5uc6yp0+fGrQOkw47LAg7OzucO3cOycnJiIiIQFhYGCpUqIAWLVpIGWfnzp0xduxYAEBgYCD++OMPrFixQkq+3n//fWl9tWrVgqenJ1q1aoWYmBi9QxQBYNKkSQgLC5OeJyUlwcfHB66urqa5yXI2giBAoVDA1dWVP5gywZjIC+MhP4yJ/DAmhklLS8PTp09hZmYGM7OiP4168QSPTI8xkR9jxcTMzAxKpRLOzs455pMw9KbrJku+XFxcoFKpEB8fr1MeHx+f57VYSqUSFStWBKBJrC5fvozw8HC0aNECLi4uMDMzQ/Xq1XVeU61aNRw7dizXdTZs2BAAcP369VyTL0tLS1haWuptjxx+pBQKhWzaQhqMibwwHvLDmMgPY/JySqVSZ7bkoiKKorT+0tjL0qxZMwwdOhTvvvtuvl87cOBAPHnyBD///HOudQ4fPoyWLVvi8ePHcDTwZtZFHZOff/4Z48aNQ2xsLEaOHInAwECMGTMGT548KdTtPHjwANWrV0dUVBTKlStXqOs2NmPvJ9r9Xt9x0tDjpsmOrhYWFqhXrx4iIiKkMkEQEBERgeDgYIPXIwiCdC2WhYUF6tevj+joaJ06V69eha+vb67rOHfuHADA09MzH++AiIiIqHgYOHBgrrfWGT58OBQKBQYOHGj8humxY8cOxMfHo3fv3gV6/VdffYU1a9ZIz1u0aIExY8YUTuPy6fDhw1AoFAYlUB988AG6d++Of/75BzNnzkSvXr1w9erVV9r+wIEDc8x74OLigv79+2Pq1KkFWmd+bhMFGH6rKK2hQ4dCoVBg4cKFepenp6cjMDAQCoVCOocvTkz6p62wsDB8++23WLt2LS5fvowPP/wQKSkp0uyH/fv315mQIzw8HPv378eNGzdw+fJlzJ8/H+vXr0ffvn2lOuPHj8fmzZvx7bff4vr161iyZAl27tyJYcOGAdBMRT9z5kycOXMGN2/exI4dO9C/f380a9YMtWvXNu4HQERERGQkPj4+2LRpE549eyaVpaWl4fvvv0f58uVN2DJdixYtQmhoaIF7YB0cHAzuzZKL5ORkJCQkICQkBF5eXrCzs4O1tbXeWy9pZWRkFHh7oaGh2LhxIx49epSv12lvEzV16lRERUWhTp06CAkJQUJCQq6v0d4qKjIyEufPn0doaChCQ0Oxb9++HHV/+uknnDhxAl5eXrmub8KECXkulz3RxBYvXiyWL19etLCwEBs0aCCeOHFCWta8eXNxwIAB0vPJkyeLFStWFK2srMSyZcuKwcHB4qZNm3Ks87vvvpPq1alTR/z555+lZXFxcWKzZs1EJycn0dLSUqxYsaI4fvx4MTExMV/tTkxMFAHk+3VFQa1Wi3fv3hXVarWpm0L/YUzkhfGQH8ZEfhgTwzx79ky8dOmS+OzZM93yzGe5PtKz0vNdVxAEMSMjQ0zNSNVbL78GDBggdu7cWaxZs6a4YcMGqXzjxo1i7dq1xc6dO+ucc6nVanH27Nmin5+faGVlJdauXVvcunWrtDwrK0scNGiQtLxy5criwoUL9W7ziy++ED08PEQnJydx2LBhYkZGRq7tTEhIEBUKhXjx4kWp7KOPPhI7dOggPf/yyy9FAOKvv/4qlQUEBIjffvutzna1/weg84iNjRUPHTokAhAPHDgg1qtXT7S2thaDg4PFK1eu6LRn2bJlYoUKFURzc3OxcuXK4qpVq0RBEERRFMXY2FgRgHj27Fmp/uPHj0UA4qFDh6Tl2R/ZP2MtbVuyPw4dOiSuXr1adHBwkOpNnTpVrFOnjvjtt9+Kfn5+okKhEEVRFLdu3SrWrFlTtLKyEp2cnMRWrVqJycnJ4tSpU/WuV8vf319cuXJlrrHQp0GDBuLw4cOl52q1WvTy8hLDw8PztZ66deuKn3zyiU7Z7du3RW9vb/HixYuir6+v+OWXX+Z43Z49e8SqVauKf//9twhAjIqKEjMyMkRBEKTPa+fOnWLlypVFa2trsVu3bmJKSoq4Zs0a0dfXV3R0dBRHjhwpZmVlSetcunSpWLFiRdHS0lJ0c3MTu3Xrlmu7c9v/RdHw3MDkE26MGDECI0aM0Lvs8OHDOs9nzZqFWbNmvXSdgwYNwqBBg/Qu8/HxwZEjR/LdTiIiIqLc9NjaI9dlQZ5BmNri+RCvvtv7Il2drrduTdeaCG8dLj1/b8d7SMpIylFv5zs7C9TOQYMGYfXq1ejTpw8AYNWqVQgNDc1xzhUeHo4NGzZgxYoVqFSpEn7//Xf07dsXrq6uaN68OQRBQLly5bB161Y4Ozvjjz/+wPvvvw9PT0/07NlTWs+hQ4fg6emJQ4cO4fr16+jVqxcCAwMxZMgQve07duwYypQpg2rVqkllzZs3x8qVK6FWq6FSqXDkyBG4uLjg8OHDaNeuHe7cuYOYmJgc94MFNEMQr169ipo1a2LGjBkAAFdXV9y8eROA5v6w8+fPh6urK4YOHYpBgwbh+PHjADS9MKNHj8bChQvRunVr7Ny5E0OGDIGvry/eeOONl37WPj4+2LZtG7p164bo6GjY29vD2to6R71GjRohOjoaVapUwbZt29CoUSM4OTlJbczu+vXr2LZtG7Zv3w6VSoW7d+/inXfeweeff44uXbrg6dOnOHr0KERRxLhx43D58mUkJSVh9erVADS9UFoNGjTA0aNHMXjwYADAmjVrEBoamuuU7a96myhA/62iAM1lRP369cP48eNRo0YNva+Nj4/HkCFD8PPPP+d6e6jU1FQsWrQImzZtwtOnT9G1a1d06dIFjo6O2LNnD27cuIFu3bqhcePG6NWrF/7880+MGjUK69evR6NGjfDo0SMcPXrUoPdSUCZPvoiIiIjIOPr27YtJkybh1q1bAIDjx49j06ZNOslXeno6Zs+ejQMHDkjX4VeoUAHHjh3D119/jebNm8Pc3FznFjz+/v6IjIzEli1bdJKvsmXLYsmSJVCpVKhatSo6dOiAiIiIXJOvW7duwd3dXWfIYdOmTfH06VOcPXsW9erVw++//47x48dLE2ocPnwY3t7e0oRs2Tk4OMDCwgJlypTRO6HbZ599Js2GPXHiRHTo0AFpaWmwsrLCvHnzMHDgQOnSlbCwMERGRmL+/PkGJV8qlUpKdtzc3HIdCmlhYSENL3Rycspz4rmMjAysW7cOrq6uAICoqChkZWWha9eu0vwGtWrVkupbW1sjPT1d7zq9vLxw9uxZ6bmDgwOqVKmS67YLepsoIO9bRQHA3LlzYWZmhlGjRul9vSiKGDhwIIYOHYqgoCC9iSmguRXE8uXLpQn0unfvjvXr1yM+Ph62traoXr06WrZsiUOHDqFXr16Ii4uDjY0NOnbsCDs7O/j6+qJu3bp5vpdXxeSLiIiI6BVt7bE112VKhe61Sxu6bjC47spOKwt1FjdXV1d06NABa9asgSiK6NChA1xcXHTqXL9+HampqTonx4DmxD/7ienSpUuxatUqxMXF4dmzZ8jIyEBgYKDOa2rUqAGVSiU99/T0xIULF3Jt37Nnz3JM2e3o6Ig6derg8OHDsLCwgIWFBd5//31MnToVycnJOHLkiJRA5Vf26/21E68lJCSgfPnyuHz5ss7tiQBNL9WSJUsKtK3C4OvrKyVeAFCnTh20atUKtWrVQkhICNq2bYvu3bujbNmyL12XtbU1UlNTpeddunRBly5diqTded0q6syZM/jqq68QFRWV63d98eLFePr0qU6vmz5lypTRmbnc3d0dfn5+sLW11SnTXqPWpk0b+Pr6okKFCmjXrh3atWuHLl265NqzVhiYfBERERG9Iiszw+7xU5C6hT2F9qBBg6RLPpYuXZpjeXJyMgBg9+7d8Pb21lmmve3Opk2bMG7cOMyfPx/BwcGws7PDF198gZMnT+rUf/H+SwqFQrovqz4uLi54/PhxjvIWLVrg8OHDsLS0RPPmzeHk5CTdSujIkSP46KOPDHjnOWVvn/Zzzqt92Wl757IP08vMzCxQOwxlY2Oj81ylUmH//v34448/8Ntvv2Hx4sWYPHkyTp48CX9//zzX9ejRI51E7mUKepsoIO9bRR09elRKeLXUajU++ugjLFy4EDdv3sTBgwcRGRmZ47ZP9evXxzvvvIN169YB0P99y+s7aGdnh6ioKBw+fBi//fYbpkyZgmnTpuH06dNFNmkLb+RBREREVIq0a9cOGRkZyMzMREhISI7l1atXh6WlJeLi4lCxYkWdh4+PDwDNcMVGjRph2LBhqFu3LipWrIiYmJhXblvdunVx7969HAlY8+bNcezYMUREREjXdrVo0QI//PADrl69qvd6Ly0LCwuo1ep8t6VatWrS9V9af/zxh3Q/WW3icvfuXWn5i1OfW1hYAECBtm8ohUKBxo0bY/r06Th79iwsLCzw008/SdvPbdsXL17M1xC7wrpNlPZ12ltF9evXD+fPn8e5c+ekh5eXF8aPHy/NiLho0SL89ddf0vI9e/YA0PwRQHstX0GZmZmhdevW+Pzzz3H+/Hkp2Ssq7PkiIiIiKkVUKhUuX74s/f9FdnZ2GDduHMaOHQtBENCkSRMkJibi+PHjsLe3x4ABA1CpUiWsW7cO+/btg7+/P9avX4/Tp0+/tLflZerWrQsXFxccP34cHTt2lMqbNWuGp0+fYteuXZgzZw4ATfLVvXt3eHp6onLlyrmu08/PDydPnsTNmzdha2urM+lEXsaPH4+ePXuibt26aN26NXbs2IGff/4Z+/fvB6AZtvf6669jzpw58Pf3R0JCAj755BOddfj6+kKhUGDXrl1o3749rK2tdYbAvaqTJ08iIiICbdu2hZubG06ePIn79+9LE5b4+flh3759iI6OhrOzMxwcHGBubo7U1FScOXMGs2fPltb1008/YdKkSXlevxUWFoYBAwYgKCgIDRo0wMKFC3VuEwVobhXl7e2N8HDNxDHh4eEICgpCQEAA0tPTsWfPHqxfvx7Lly8HADg7O8PZ2VlnO+bm5vDw8JCuQXvxVgjazzAgIOCVbhS9a9cu3LhxA82aNUPZsmWxZ88eCIKQ57Vvr4o9X0RERESljL29Pezt7XNdPnPmTHz66acIDw9HtWrV0K5dO+zevVtKrj744AN07doVvXr1QsOGDfHw4UNpYopXoVKppHtQZVe2bFnUqlULrq6uqFq1KgBNQiYIwkuv9xo3bhxUKhWqV68OV1dXxMXFGdSWt99+G1999RXmzZuHGjVq4JtvvsG3336r08u2atUqZGVloV69ehgzZkyOWbm9vb0xffp0TJw4Ee7u7rnO8F1Q9vb2+P3339G+fXtUrlwZn3zyCebPn48333wTADBkyBBUqVIFQUFBcHV1lXryfvnlF5QvXx5NmzaV1pWYmIjo6Og8t9erVy/MmzcPU6ZMQWBgIM6dO4e9e/fqTMIRFxen0xuYkpKCYcOGoUaNGmjcuDG2bduGDRs24L333ivMj6JAHB0dsX37drzxxhuoVq0aVqxYgR9++CHXGRcLg0LMbT5JylNSUhIcHByQmJiY58HLGARBQEJCAtzc3Ap8Q0IqXIyJvDAe8sOYyA9jYpi0tDTExsbC398/x8QQhUkURWRlZcHMzKzQr/mSu3v37qFGjRqIioqSZvCTg5IUk9dffx2jRo3Cu+++a+qmvBJjxySv/d/Q3IBHVyIiIiKSDQ8PD3z33XcG91BR/jx48ABdu3bFO++8Y+qmlEq85ouIiIiIZOXtt982dRNKLBcXF0yYMMHUzSi12PNFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiKSlWbNmuH77783uP6aNWvg6OgoPZ82bRoCAwOl5xMnTsTIkSMLsYVEBcPki4iIiKiEGzhwIBQKBYYOHZpj2fDhw6FQKDBw4EDjN0yPHTt2ID4+Hr179y60dY4bNw5r167FjRs38v3auLg4dOjQATY2NvD29sb48eORlZWV52s6deqE8uXLw8rKCp6enujXrx/+/fdfvXWvX78OOzs7neQR0CSUCoVC52FlZZXv9pO8MPkiIiIiKgV8fHywadMmPHv2TCpLS0vD999/j/Lly5uwZboWLVqE0NBQKJWFd5rq4uKCkJAQLF++PF+vU6vV6NChAzIyMnD8+HF89913WLt2LaZMmZLn61q2bIktW7YgOjoa27ZtQ0xMDLp3756jXmZmJt555x00bdpU73rs7e1x9+5d6XHr1q18tZ/kh8kXERER0atSp2keovi8TMjSlAmZhtdVZxhWtwBee+01+Pj4YPv27VLZ9u3bUb58edStW1enriAICA8Ph7+/P6ytrVGnTh38+OOPz5ulVmPw4MHS8ipVquCrr77SWcfAgQPx9ttvY968efD09ISzszOGDx+OzMwXPo9s7t+/j4MHD+Ktt97SKV+wYAFq1aoFGxsb+Pj4YNiwYUhOTs7X+3/rrbewadOmfL3mt99+w6VLl7BhwwYEBgaiXbt2mDFjBpYuXYqMjIxcXzd27Fi8/vrr8PX1RaNGjTBx4kScOHEix3v/5JNPULVqVfTs2VPvehQKBTw8PKSHu7u7znI/Pz/MmjUL/fv3h62tLXx9fbFjxw7cv38fnTt3hq2tLWrXro0///xTes2tW7fw1ltvoWzZsrCxsUGNGjWwZ8+efH0uVHBMvoiIiIhe1dEemkdm0vOyf7Zryq6t0K37R19Nefr952X/7taUXV2kW/fke5ry1H+el92LKHAzBw0ahNWrV0vPV61ahdDQ0Bz1wsPDsW7dOqxYsQJ///03xo4di759++LIkSMANMlZuXLlsHXrVly6dAlTpkzB//73P2zZskVnPYcOHUJMTAwOHTqEtWvXYs2aNVizZk2u7Tt27BjKlCmDatWq6ZQrlUosWrQIf//9N9auXYuDBw9iwoQJ+XrvDRo0wO3bt3Hz5k2pzM/PD9OmTcv1NZGRkahVq5ZO0hMSEoKkpCT8/fffBm330aNH2LhxIxo1agRzc3Op/ODBg9i6dSuWLl2a62uTk5Ph6+sLHx8fdO7cWe82v/zySzRu3Bhnz55Fhw4d0K9fP/Tv3x99+/ZFVFQUAgIC0L9/f4j/JfDDhw9Heno6fv/9d1y4cAFz586Fra2tQe+FXh2TLyIiIqJSom/fvjh27Bhu3bqFW7du4fjx4+jbt69OnfT0dMyePRurVq1CSEgIKlSogIEDB6Jv3774+uuvAQDm5uaYPn06goKC4O/vjz59+iA0NDRH8lW2bFksWbIEVatWRceOHdGhQwdEROSePN66dQvu7u45hhyOGTMGLVu2hJ+fH9544w3MmjUrx7ZexsvLS9qGVkBAAFxcXHJ9zb1793L0Nmmf37t3L8/tffzxx7CxsYGzszPi4uLwyy+/SMsePnyIgQMHYs2aNbC3t9f7+ipVqmDVqlX45ZdfsGHDBgiCgEaNGuH27ds69dq3b48PPvgAlSpVwpQpU5CUlIT69eujR48eqFy5Mj7++GNcvnwZ8fHxADTXsDVu3Bi1atVChQoV0LFjRzRr1izP90KFx8zUDSAiIiIq9ppu1fyrtHxe5tMVKNcJUKh06zbakLOuVwfAMwQ5/i7ecCWgUOjW9WhV4Ga6urqiQ4cOWLNmDURRRIcOHXIkH9evX0dqairatGmjU56RkaEzPHHp0qVYtWoV4uLi8OzZM2RkZOjMMAgANWrUgEr1/P17enriwoULubbv2bNneieVOHDgAMLDw3HlyhUkJSUhKysLaWlpSE1NRZkyZQx679bW1gCA1NRUqSyvRPBVjR8/HoMHD8atW7cwffp09O/fH7t27YJCocCQIUPw7rvv5pn0BAcHIzg4WHreqFEjVKtWDV9//TVmzpwpldeuXVv6vzYxrFWrVo6yhIQEeHh4YNSoUfjwww/x22+/oXXr1ujWrZvOOqhoseeLiIiI6FWprDQPheJ5mdJMU6Y0N7yuysKwuq9g0KBBWLNmDdauXYtBgwblWK69lmr37t04d+6c9Lh06ZJ03demTZswbtw4DB48GL/99hvOnTuH0NDQHNdBZR9mB2iuYRIEIde2ubi44PHjxzplN2/eRMeOHVG7dm1s27YNZ86ckYbq5XXd1YsePXoEQJOAGsrDw0PqMdLSPvfw8MjztS4uLqhcuTLatGmDTZs2Yc+ePThx4gQAzZDDefPmwczMDGZmZhg8eDASExNhZmaGVatW6V2fubk56tati+vXr+co11L89z3RV6b93N977z3cuHED/fr1w4ULFxAUFITFixe/9LOgwsGeLyIiIqJSpF27dsjIyIBCoUBISEiO5dWrV4elpSXi4uLQvHlzves4fvw4GjVqhGHDhkllMTExr9y2unXr4t69e3j8+DHKli0LADhz5gwEQcD8+fOl4Yj5HXIIABcvXoS5uTlq1Khh8GuCg4Px2WefISEhQUra9u/fD3t7e1SvXt3g9WgTn/T0dACaa8nUarW0/JdffsHcuXPxxx9/wNvbW+861Go1Lly4gPbt2xu83dz4+Phg6NChGDp0KCZNmoRvv/2W90EzEiZfRERERKWISqXC5cuXpf+/yM7ODuPGjcPYsWMhCAKaNGmCxMREHD9+HPb29hgwYAAqVaqEdevWYd++ffD398f69etx+vRp+Pv7v1Lb6tatCxcXFxw/fhwdO3YEAFSsWBGZmZlYvHgx3nrrLRw/fhwrVqx4yZpyOnr0KJo2bSoNPwSAVq1aoUuXLhgxYoTe17Rt2xbVq1dHv379MHfuXNy5cweffvophg8fDktLzVDQU6dOoX///oiIiIC3tzdOnjyJ06dPo0mTJihbtixiYmLw6aefIiAgQBpG+OKEIn/++SeUSiVq1qwplc2YMQOvv/46KlasiCdPnuCLL77ArVu38N577+X7vWc3ZswYvPnmm6hcuTIeP36MQ4cO5WgPFR0OOyQiIiIqZezt7XOd6AEAZs6ciU8//RTh4eGoVq0a2rVrh927d0vJ1QcffICuXbuiV69eaNiwIR4+fKjTC1ZQKpUKoaGh2Lhxo1RWp04dLFiwAHPnzkXNmjWxceNGhIeH53vdmzZtwpAhQ3TKYmJi8ODBgzzbs2vXLqhUKjRq1AgDBw5Ev379MGPGDKlOamoqoqOjpWnky5Qpg+3bt6NVq1aoUqUKBg8ejNq1a+PIkSNSwmaIx48fY8iQIahWrRrat2+PpKQk/PHHH/nqcdNHrVZj+PDhUlwrV66MZcuWvdI6yXAKUcx+4wgyVFJSEhwcHJCYmJjnwcsYBEFAQkIC3NzcCvWGhFRwjIm8MB7yw5jID2NimLS0NMTGxsLf31/vxBCFRRRFZGVlwczMTLpmp7S4d+8eatSogaioKPj6+hbKOn/99Vd89NFHOH/+PMzMCjbwqzTHRK6MHZO89n9DcwMeXYmIiIhINjw8PPDdd98hLi6u0NaZkpKC1atXFzjxIios/AYSERERkay8/fbbhbq+7t27F+r6iAqKPV9ERERERERGwOSLiIiIiIjICJh8EREREeUT5ysjKn0KY79n8kVERERkIHNzcwCa6cWJqHTR7vfa40BBcMINIiIiIgOpVCo4OjoiISEBgOaeTkUxxTWnNZcfxkR+jBUTURSRmpqKhIQEODo66r05uaGYfBERERHlg4eHBwBICVhREEURgiBAqVTyRF8mGBP5MXZMHB0dpf2/oJh8EREREeWDQqGAp6cn3NzckJmZWSTbEAQBDx8+hLOzM296LROMifwYMybm5uav1OOlxeSLiIiIqABUKlWhnIzpIwgCzM3NYWVlxRN9mWBM5Kc4xqR4tJKIiIiIiKiYY/JFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjMDkydfSpUvh5+cHKysrNGzYEKdOncq17vbt2xEUFARHR0fY2NggMDAQ69evz1Hv8uXL6NSpExwcHGBjY4P69esjLi5OWp6Wlobhw4fD2dkZtra26NatG+Lj44vk/REREREREQEmTr42b96MsLAwTJ06FVFRUahTpw5CQkKQkJCgt76TkxMmT56MyMhInD9/HqGhoQgNDcW+ffukOjExMWjSpAmqVq2Kw4cP4/z58/j0009hZWUl1Rk7dix27tyJrVu34siRI/j333/RtWvXIn+/RERERERUeilEURRNtfGGDRuifv36WLJkCQBAEAT4+Phg5MiRmDhxokHreO2119ChQwfMnDkTANC7d2+Ym5vr7REDgMTERLi6uuL7779H9+7dAQBXrlxBtWrVEBkZiddff92g7SYlJcHBwQGJiYmwt7c36DVFRRAEJCQkwM3NDUqlyTszCYyJ3DAe8sOYyA9jIi+Mh/wwJvIjp5gYmhuYGbFNOjIyMnDmzBlMmjRJKlMqlWjdujUiIyNf+npRFHHw4EFER0dj7ty5ADQB2L17NyZMmICQkBCcPXsW/v7+mDRpEt5++20AwJkzZ5CZmYnWrVtL66patSrKly+fZ/KVnp6O9PR06XlSUpK0TUEQ8v3+C5MgCBBF0eTtoOcYE3lhPOSHMZEfxkReGA/5YUzkR04xMbQNJku+Hjx4ALVaDXd3d51yd3d3XLlyJdfXJSYmwtvbG+np6VCpVFi2bBnatGkDAEhISEBycjLmzJmDWbNmYe7cudi7dy+6du2KQ4cOoXnz5rh37x4sLCzg6OiYY7v37t3Ldbvh4eGYPn16jvL79+8jLS0tH++88AmCgMTERIiiaPKsnzQYE3lhPOSHMZEfxkReGA/5YUzkR04xefr0qUH1TJZ8FZSdnR3OnTuH5ORkREREICwsDBUqVECLFi2kjLNz584YO3YsACAwMBB//PEHVqxYgebNmxd4u5MmTUJYWJj0PCkpCT4+PnB1dZXFsEOFQgFXV1eTf/FIgzGRF8ZDfhgT+WFM5IXxkB/GRH7kFJPs80vkxWTJl4uLC1QqVY5ZBuPj4+Hh4ZHr65RKJSpWrAhAk1hdvnwZ4eHhaNGiBVxcXGBmZobq1avrvKZatWo4duwYAMDDwwMZGRl48uSJTu/Xy7ZraWkJS0tLve0xdbABQKFQyKYtpMGYyAvjIT+MifwwJvLCeMgPYyI/comJods3WSstLCxQr149RERESGWCICAiIgLBwcEGr0cQBOlaLAsLC9SvXx/R0dE6da5evQpfX18AQL169WBubq6z3ejoaMTFxeVru0RERERERPlh0mGHYWFhGDBgAIKCgtCgQQMsXLgQKSkpCA0NBQD0798f3t7eCA8PB6C57iooKAgBAQFIT0/Hnj17sH79eixfvlxa5/jx49GrVy80a9YMLVu2xN69e7Fz504cPnwYAODg4IDBgwcjLCwMTk5OsLe3x8iRIxEcHGzwTIdERERERET5ZdLkq1evXrh//z6mTJmCe/fuITAwEHv37pUm4YiLi9PpwktJScGwYcNw+/ZtWFtbo2rVqtiwYQN69eol1enSpQtWrFiB8PBwjBo1ClWqVMG2bdvQpEkTqc6XX34JpVKJbt26IT09HSEhIVi2bJnx3jgREREREZU6Jr3PV3HG+3xRXhgTeWE85IcxkR/GRF4YD/lhTORHTjExNDfgN4eIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMwCw/lQVBwJEjR3D06FHcunULqampcHV1Rd26ddG6dWv4+PgUVTuJiIiIiIiKNYN6vp49e4ZZs2bBx8cH7du3x6+//oonT55ApVLh+vXrmDp1Kvz9/dG+fXucOHGiqNtMRERERERU7BjU81W5cmUEBwfj22+/RZs2bWBubp6jzq1bt/D999+jd+/emDx5MoYMGVLojSUiIiIiIiquDEq+fvvtN1SrVi3POr6+vpg0aRLGjRuHuLi4QmkcERERERFRSWHQsMOXJV7ZmZubIyAgoMANIiIiIiIiKonyPdvh3r17cezYMen50qVLERgYiHfffRePHz8u1MYRERERERGVFPlOvsaPH4+kpCQAwIULF/DRRx+hffv2iI2NRVhYWKE3kIiIiIiIqCTI11TzABAbG4vq1asDALZt24aOHTti9uzZiIqKQvv27Qu9gURERERERCVBvnu+LCwskJqaCgA4cOAA2rZtCwBwcnKSesSIiIiIiIhIV757vpo0aYKwsDA0btwYp06dwubNmwEAV69eRbly5Qq9gURERERERCVBvnu+lixZAjMzM/z4449Yvnw5vL29AQC//vor2rVrV+gNJCIiIiIiKgny3fNVvnx57Nq1K0f5l19+WSgNIiIiIiIiKonynXxpJSQkICEhAYIg6JTXrl37lRtFRERERERU0uQ7+Tpz5gwGDBiAy5cvQxRFAIBCoYAoilAoFFCr1YXeSCIiIiIiouIu38nXoEGDULlyZXz33Xdwd3eHQqEoinYRERERERGVKPlOvm7cuIFt27ahYsWKRdEeIiIiIiKiEinfsx22atUKf/31V1G0hYiIiIiIqMTKd8/XypUrMWDAAFy8eBE1a9aEubm5zvJOnToVWuOIiIiIiIhKinwnX5GRkTh+/Dh+/fXXHMs44QYREREREZF++R52OHLkSPTt2xd3796FIAg6DyZeRERERERE+uU7+Xr48CHGjh0Ld3f3QmvE0qVL4efnBysrKzRs2BCnTp3Kte727dsRFBQER0dH2NjYIDAwEOvXr9epM3DgQCgUCp1Hu3btdOr4+fnlqDNnzpxCe09ERERERETZ5XvYYdeuXXHo0CEEBAQUSgM2b96MsLAwrFixAg0bNsTChQsREhKC6OhouLm55ajv5OSEyZMno2rVqrCwsMCuXbsQGhoKNzc3hISESPXatWuH1atXS88tLS1zrGvGjBkYMmSI9NzOzq5Q3hMREREREdGL8p18Va5cGZMmTcKxY8dQq1atHBNujBo1Kl/rW7BgAYYMGYLQ0FAAwIoVK7B7926sWrUKEydOzFG/RYsWOs9Hjx6NtWvX4tixYzrJl6WlJTw8PPLctp2d3UvrEBERERERFYYCzXZoa2uLI0eO4MiRIzrLFApFvpKvjIwMnDlzBpMmTZLKlEolWrdujcjIyJe+XhRFHDx4ENHR0Zg7d67OssOHD8PNzQ1ly5bFG2+8gVmzZsHZ2Vmnzpw5czBz5kyUL18e7777LsaOHQszM/0fSXp6OtLT06XnSUlJACBd72ZKgiBAFEWTt4OeY0zkhfGQH8ZEfhgTeWE85IcxkR85xcTQNuQ7+YqNjc13Y3Lz4MEDqNXqHNePubu748qVK7m+LjExEd7e3khPT4dKpcKyZcvQpk0baXm7du3QtWtX+Pv7IyYmBv/73//w5ptvIjIyEiqVCoCmh+61116Dk5MT/vjjD0yaNAl3797FggUL9G4zPDwc06dPz1F+//59pKWlFeTtFxpBEJCYmAhRFKFU5vsyPioCjIm8MB7yw5jID2MiL4yH/DAm8iOnmDx9+tSgevlOvuTAzs4O586dQ3JyMiIiIhAWFoYKFSpIQxJ79+4t1a1VqxZq166NgIAAHD58GK1atQIAhIWFSXVq164NCwsLfPDBBwgPD9d7fdikSZN0XpOUlAQfHx+4urrC3t6+iN6pYQRBgEKhgKurq8m/eKTBmMgL4yE/jIn8MCbywnjID2MiP3KKiZWVlUH1DEq+5syZg9GjR8Pa2vqldU+ePIkHDx6gQ4cOL63r4uIClUqF+Ph4nfL4+Pg8r8VSKpWoWLEiACAwMBCXL19GeHh4juvBtCpUqAAXFxdcv35dSr5e1LBhQ2RlZeHmzZuoUqVKjuWWlpZ6kzKlUmnyYAOaIZ9yaQtpMCbywnjID2MiP4yJvDAe8sOYyI9cYmLo9g2qdenSJZQvXx7Dhg3Dr7/+ivv370vLsrKycP78eSxbtgyNGjVCr169DJ410MLCAvXq1UNERIRUJggCIiIiEBwcbNA6tK/Jfj3Wi27fvo2HDx/C09Mz1zrnzp2DUqnUO8MiERERERHRqzKo52vdunX466+/sGTJErz77rtISkqCSqWCpaUlUlNTAQB169bFe++9h4EDBxrc7QZohv8NGDAAQUFBaNCgARYuXIiUlBRp9sP+/fvD29sb4eHhADTXXgUFBSEgIADp6enYs2cP1q9fj+XLlwMAkpOTMX36dHTr1g0eHh6IiYnBhAkTULFiRWk2xMjISJw8eRItW7aEnZ0dIiMjMXbsWPTt2xdly5Y1/NMjIiIiIiIykMHXfNWpUwfffvstvv76a5w/fx63bt3Cs2fP4OLigsDAQLi4uBSoAb169cL9+/cxZcoU3Lt3D4GBgdi7d680CUdcXJxON15KSgqGDRuG27dvw9raGlWrVsWGDRvQq1cvAIBKpcL58+exdu1aPHnyBF5eXmjbti1mzpwpDRu0tLTEpk2bMG3aNKSnp8Pf3x9jx47VuaaLiIiIiIioMClEURRN3YjiKCkpCQ4ODkhMTJTFhBsJCQlwc3Mz+XhX0mBM5IXxkB/GRH4YE3lhPOSHMZEfOcXE0NyA3xwiIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREUOPm6fv069u3bh2fPngEAOG8HERERERFR7vKdfD18+BCtW7dG5cqV0b59e9y9excAMHjwYHz00UeF3kAiIiIiIqKSIN/J19ixY2FmZoa4uDiUKVNGKu/Vqxf27t1bqI0jIiIiIiIqKQy+ybLWb7/9hn379qFcuXI65ZUqVcKtW7cKrWFEREREREQlSb57vlJSUnR6vLQePXoES0vLQmkUERERERFRSZPv5Ktp06ZYt26d9FyhUEAQBHz++edo2bJloTaOiIiIiIiopMj3sMPPP/8crVq1wp9//omMjAxMmDABf//9Nx49eoTjx48XRRuJiIiIiIiKvXz3fNWsWRNXr15FkyZN0LlzZ6SkpKBr1644e/YsAgICiqKNRERERERExV6+e74AwMHBAZMnTy7sthAREREREZVYBUq+0tLScP78eSQkJEAQBJ1lnTp1KpSGERERERERlST5Tr727t2L/v3748GDBzmWKRQKqNXqQmkYERERERFRSZLva75GjhyJHj164O7duxAEQefBxIuIiIiIiEi/fCdf8fHxCAsLg7u7e1G0h4iIiIiIqETKd/LVvXt3HD58uAiaQkREREREVHLl+5qvJUuWoEePHjh69Chq1aoFc3NzneWjRo0qtMYRERERERGVFPlOvn744Qf89ttvsLKywuHDh6FQKKRlCoWCyRcREREREZEe+U6+Jk+ejOnTp2PixIlQKvM9apGIiIiIiKhUynf2lJGRgV69ejHxIiIiIiIiyod8Z1ADBgzA5s2bi6ItREREREREJVa+hx2q1Wp8/vnn2LdvH2rXrp1jwo0FCxYUWuOIiIiIiIhKinwnXxcuXEDdunUBABcvXtRZln3yDSIiIiIiInou38nXoUOHiqIdREREREREJRpnzSAiIiIiIjICg3q+unbtijVr1sDe3h5du3bNs+727dsLpWFEREREREQliUHJl4ODg3Q9l4ODQ5E2iIiIiIiIqCQyKPlavXo1ZsyYgXHjxmH16tVF3SYiIiIiIqISx+BrvqZPn47k5OSibAsREREREVGJZXDyJYpiUbaDiIiIiIioRMvXbIe8jxcREREREVHB5Os+X5UrV35pAvbo0aNXahAREREREVFJlK/ka/r06ZztkIiIiIiIqADylXz17t0bbm5uRdUWIiIiIiKiEsvga754vRcREREREVHBcbZDIiIiIiIiIzB42KEgCEXZDiIiIiIiohItX1PNExERERERUcEw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICWSRfS5cuhZ+fH6ysrNCwYUOcOnUq17rbt29HUFAQHB0dYWNjg8DAQKxfv16nzsCBA6FQKHQe7dq106nz6NEj9OnTB/b29nB0dMTgwYORnJxcJO+PiIiIiIjI5MnX5s2bERYWhqlTpyIqKgp16tRBSEgIEhIS9NZ3cnLC5MmTERkZifPnzyM0NBShoaHYt2+fTr127drh7t270uOHH37QWd6nTx/8/fff2L9/P3bt2oXff/8d77//fpG9TyIiIiIiKt1MnnwtWLAAQ4YMQWhoKKpXr44VK1agTJkyWLVqld76LVq0QJcuXVCtWjUEBARg9OjRqF27No4dO6ZTz9LSEh4eHtKjbNmy0rLLly9j7969WLlyJRo2bIgmTZpg8eLF2LRpE/79998ifb9ERERERFQ6mZly4xkZGThz5gwmTZoklSmVSrRu3RqRkZEvfb0oijh48CCio6Mxd+5cnWWHDx+Gm5sbypYtizfeeAOzZs2Cs7MzACAyMhKOjo4ICgqS6rdu3RpKpRInT55Ely5dcmwrPT0d6enp0vOkpCQAgCAIEAQhf2+8kAmCAFEUTd4Oeo4xkRfGQ34YE/lhTOSF8ZAfxkR+5BQTQ9tg0uTrwYMHUKvVcHd31yl3d3fHlStXcn1dYmIivL29kZ6eDpVKhWXLlqFNmzbS8nbt2qFr167w9/dHTEwM/ve//+HNN99EZGQkVCoV7t27Bzc3N511mpmZwcnJCffu3dO7zfDwcEyfPj1H+f3795GWlpaft13oBEFAYmIiRFGEUmnyzkwCYyI3jIf8MCbyw5jIC+MhP4yJ/MgpJk+fPjWonkmTr4Kys7PDuXPnkJycjIiICISFhaFChQpo0aIFAKB3795S3Vq1aqF27doICAjA4cOH0apVqwJtc9KkSQgLC5OeJyUlwcfHB66urrC3t3+l9/OqBEGAQqGAq6uryb94pMGYyAvjIT+MifwwJvLCeMgPYyI/coqJlZWVQfVMmny5uLhApVIhPj5epzw+Ph4eHh65vk6pVKJixYoAgMDAQFy+fBnh4eFS8vWiChUqwMXFBdevX0erVq3g4eGRY0KPrKwsPHr0KNftWlpawtLSUm9bTB1sAFAoFLJpC2kwJvLCeMgPYyI/jIm8MB7yw5jIj1xiYuj2TdpKCwsL1KtXDxEREVKZIAiIiIhAcHCwwesRBEHneqwX3b59Gw8fPoSnpycAIDg4GE+ePMGZM2ekOgcPHoQgCGjYsGEB3gkREREREVHeTD7sMCwsDAMGDEBQUBAaNGiAhQsXIiUlBaGhoQCA/v37w9vbG+Hh4QA0114FBQUhICAA6enp2LNnD9avX4/ly5cDAJKTkzF9+nR069YNHh4eiImJwYQJE1CxYkWEhIQAAKpVq4Z27dphyJAhWLFiBTIzMzFixAj07t0bXl5epvkgiIiIiIioRDN58tWrVy/cv38fU6ZMwb179xAYGIi9e/dKk3DExcXpdOOlpKRg2LBhuH37NqytrVG1alVs2LABvXr1AgCoVCqcP38ea9euxZMnT+Dl5YW2bdti5syZOsMGN27ciBEjRqBVq1ZQKpXo1q0bFi1aZNw3T0REREREpYZCFEXR1I0ojpKSkuDg4IDExERZTLiRkJAANzc3k493JQ3GRF4YD/lhTOSHMZEXxkN+GBP5kVNMDM0N+M0hIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjYPJFRERERERkBEy+iIiIiIiIjIDJFxERERERkREw+SIiIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAiYfBERERERERkBky8iIiIiIiIjMDN1A4iIitLNm0BkJJCZCZibA8HBgJ+fqVtFREREpRGTLyIqke7eBebNA44eBZKTgapVgStXAFtboFkz4KOPAE9PU7eSiIiIShMOOySiEufuXWDYMGDnTk1vV4UKmkSrQgXN8x07NMvv3jV1S4mIiKg0YfJFRCXOvHnA339rki0nJ0D535FOqdQ8r1BBs3zBAtO2k4iIiEoXJl9EVKLcvKkZaujqqunl0sfcXLP8yBFNfSIiIiJj4DVfJAvaSRFSUgAbG06KQAUXGQkkJQEBAXnXc3QEYmKAEyf4XSMiIiLjYPJFJpV9UoSkJM2wMEEA7O05KQIVTEqK5nukfEm/vrZOcrJx2kVERETE5OtVqdMA0Q5QKDTPhSxAzAIUKkBprlsPAJSWOetCCagsClg3HRDUgCg8LxPUgJipvy5EQGkBKJQvqZsBQAAU5oBSpSkTBUDIyGddBaCy1FPXDHfjzTBsGHDpkgAv9wx4uisgwBKCADx5Avy6OwNxsQK+WmQGT+//vqqiCAjpmv+rrLK950xAVAMKM0D5inX1fe75qqsCoMr2nvOI5yt9T/TFMz91XxL7V/6e5Bb7/H1PXhrPF+ra2ACCIEKFdCiVQKbwvK5KkQmFQoRaNEOW2gyCANjaiP99PiiE70k+4mnMY4TBsTfyMUKdptmm0lpP3eyfeyF8T+R2jDDK9ySfxwiDf0uK9zEiz7pF/j3JRzxFBXSUxmOEwbE3xTFCLH3HCLmeRxj8W1LExwjtZ/8SvObrVf3RH8hMev78n+3A0R7AtRUv1OurKU+//7zs392asquLdOueGKwpT/3nedm9CE3Z5c91654eBsXxnlA9u/m87P5RTd2LM3XrRo3VlCf+/bzs0WlN2flPdOuem6gpfxz1vOzJeU3Z2XG6dS9M1ZQ/iHxelhStKftzpG7dS+Ga8oQj0qQIwbVuYu5bPTDq9fcBPJ8U4aMOCzC0Zg/sWbXv+euf3dW8PnKg7nqvLtWU39nxvCzjkabseG/dujErNeVxW56XqVM1ZUd7aHYqrdh1mrLYdc/LRPXzuurU5+VxWzRlMSt1t3e8t6Y849Hzsjs7/ov9Ut26kQM15c+yTcN3d5+m7MoLs0Ocel9TnnLzeVnCEU3ZpXDdun+O1JQnRT8vexCpKbswVbfu2XGa8ifnn5c9jtKUnZuoW/f8J5ryR6eflyX+rSmLGqtb9+JMTfn9o8/LnsZoyk4P0617+XNN+b2I52Wp/2jKTgzWrXt1kab8390ANENWfd3vY9zrPfBRcF+dqu0qfo2JTXqgUbntePJE08PaqEHS83hmd2ONpuzWD8/LhPTndbUHZUBT52gPzWuy09Y18TECR3toPmstmRwjHC++D8WZUbp1sx0jJCk3NWWn3tete2WBpvwujxGFcYxQHO8JVer152Ul9BgBQLOfHe2h2e+yu7ZCU/7P9udlmSY6Rlz/WrduKTxGvOw8QsJjxHOl7TwiOUbzW/LncN26pjhG/NEfhmDyRSZx7x6kSRHMcul/VSkBCwvg4gVOikCG8/MDXn8dyMgABFF/nSw18OAB0Lw5UN7HqM0jIiKiUkwhimIupyeUl6SkJDg4OCDxUTzsHV1NOqRIENRIePAEbu4eUCqVxWK4wKbNZpg2wwwBAYBKKcBMmQERCmQJz+uaKTMgCgKuXTfDp1PN0Ls3is2QIgEqJCQkwM3NDUoxI8+6pX64QBEMKbr7r4jRI9Nx6TLgUNYKZcsK8PVNwO24skhKFBGfYIYq1cywbBng6WGiIUWlfNihoM5Cwr3bcHNzh9Kcww4Lpe4rHiMM/y0p/seI4jDsUBAVSHjwWPM7olSWumOEHIcdCoKg+W13KQulgsMO5XCMyN9vSdEeI5KSkuDg5I7ExETY29sjN7zm61WprJ5/uYH/AqHnY80euEKtawkohOdfbuC/L6RKf90c682trkXOMoVSf9sKUDc5FdKEByKUOtflaGUJmrqiItukCApFLp+POQBz3bJCqavnczekrpDtuomijP0r1c1H7E30PdGtm8vnrqeup5cCXy2xwoIFmunkb9zQ9KJeizGHra0SHd4CwsK0k7kU0fcEkEnd/MTeBMeIF7dZVN8TuR0jspPLMcLg35Lif4yQxfcEyLtu9t+Rl9XNz3pz1JX5MaLQ6xZS7F+c1ak0HCNy1JXRMcKg35IiPkaoMnLW10MWww6XLl0KPz8/WFlZoWHDhjh16lSudbdv346goCA4OjrCxsYGgYGBWL9+fa71hw4dCoVCgYULF+qU+/n5QaFQ6DzmzJlTWG+JXkIzKULO35YXaevY2hqnXVRyeHoCX3wBbNkCTJkCvP225t+tWzXlnEWTiIiIjM3kPV+bN29GWFgYVqxYgYYNG2LhwoUICQlBdHQ03NzcctR3cnLC5MmTUbVqVVhYWGDXrl0IDQ2Fm5sbQkJCdOr+9NNPOHHiBLy8vPRue8aMGRgyZIj03M7OrnDfHOUqOFgz2cGTJ5rJNXKjnRQhONhYLaOSxs8PKF8eSEgA3Nxy/rGSiIiIyFhMfhqyYMECDBkyBKGhoahevTpWrFiBMmXKYNWqVXrrt2jRAl26dEG1atUQEBCA0aNHo3bt2jh27JhOvTt37mDkyJHYuHEjzM3N9a7Lzs4OHh4e0sPGxqbQ3x/p5+cHNG0K3L8PZGbqr5OZ+XxSBF9fozbvldy8CWzeDPz2m+ZfThZCRERERICJe74yMjJw5swZTJo0SSpTKpVo3bo1IiMj83ilhiiKOHjwIKKjozF37lypXBAE9OvXD+PHj0eNGjVyff2cOXMwc+ZMlC9fHu+++y7Gjh0Ls1ym3ktPT0d6+vNpY5OSkqRtCS8bO1fEBEGAKIomb0d+ffQREBsLXLoEuLgAjo6QbrL85Anw8CFQowYwduzLhyfKwb17wPz5wLFjQEqKgCpVRERHC7Cx0SSaYWGAh4epW1k6Fdd9pCRjTOSHMZEXxkN+GBP5kVNMDG2DSZOvBw8eQK1Ww93dXafc3d0dV65cyfV1iYmJ8Pb2Rnp6OlQqFZYtW4Y2bdpIy+fOnQszMzOMGjUq13WMGjUKr732GpycnPDHH39g0qRJuHv3LhYsWKC3fnh4OKZPn56j/P79+0hLM+ymakVFEAQkJiZCFEXNjEjFhFIJzJoF/PILcPEikJqquWZRFDU9XR06AJ07a+olJJi6tXl79AhYvhyIiwOqVAFsbQW4uSXC3V1EcrIS164B4eHAhx/mPcySikZx3UdKMsZEfhgTeWE85IcxkR85xeTp06cG1TP5NV8FYWdnh3PnziE5ORkREREICwtDhQoV0KJFC5w5cwZfffUVoqKioMg+C+ELwsLCpP/Xrl0bFhYW+OCDDxAeHg5Ly5wzukyaNEnnNUlJSfDx8YGrq2ue00kagyAIUCgUcHV1NfkXL7/c3ICqVYFbt4CTJzWzGtraau7TVL68qVtnuC++APbvB/z9Nb12iYkClEoF7txxhSgqkZmpWW5lBWTrpCUjKc77SEnFmMgPYyIvjIf8MCbyI6eYWFnpmR1RD5MmXy4uLlCpVIiPj9cpj4+Ph0ce47OUSiUqVqwIAAgMDMTly5cRHh6OFi1a4OjRo0hISED5bGfuarUaH330ERYuXIibuVyA07BhQ2RlZeHmzZuoUqVKjuWWlpZ6kzKlUmnyYAOAQqGQTVsKwt9f8yiObt7U3DDa2Vlzw2jtnfNEUQFRVEIUlTAz0yw/ckTTO+bnZ8oWl07FfR8piRgT+WFM5IXxkB/GRH7kEhNDt2/SVlpYWKBevXqIiIiQygRBQEREBILzMb2dIAjS9Vj9+vXD+fPnce7cOenh5eWF8ePHY9++fbmu49y5c1AqlXpnWCTKS2QkkJSkuWYtL46OmnonThijVUREhuNEQURExmHyYYdhYWEYMGAAgoKC0KBBAyxcuBApKSkIDQ0FAPTv3x/e3t4IDw8HoLn2KigoCAEBAUhPT8eePXuwfv16LF++HADg7OwMZ2dnnW2Ym5vDw8ND6tGKjIzEyZMn0bJlS9jZ2SEyMhJjx45F3759UbZsWSO+eyoJUlKe3zA6L9o60g2jZe7mTU1imZKiuS9bcDB77IhKmrt3gXnzNL33ycmaYeBXrmiGfzdrppkYiffEIyIqPCZPvnr16oX79+9jypQpuHfvHgIDA7F3715pEo64uDidbryUlBQMGzYMt2/fhrW1NapWrYoNGzagV69eBm/T0tISmzZtwrRp05Ceng5/f3+MHTtW55ouIkNlv2F0XglYcblhdPaTsaSk5zNQ2tvzZIyoJLl7Fxg2DPj7b8DVFahQQbNvZ2QAjx8DO3YAMTHAsmXc54m0f5DMzATMzfkHSSo4hShqr1Ch/EhKSoKDgwMSExNlMeFGQkIC3NzcTD7etTS6eRPo2VNzMNbOZKhQCPDxScA//7hBFDUxefRIc9DeulW+9y178WTsxen/79/XTP9f3E7GuI/ID2Nieh99BOzcqUm6zM1zHrcyM4EbNzSzzn7xhalbW/pwH5EH3d5hAVWrJuDKFTfY2ir5B0kZkNN+YmhuwL2Z6BWVpBtGz5unSbwqVNAkktrjmFKpeV6hgmZ5LndkIKJiQjtRkKurJvHSx9xcs/zIEV4DRqWT9g+SO3dq9gdt77D2DxY7dmiW371r6pZSccLki6gQjBun6RG6cUPTw6W9z54gaJ7HxgLVq2tutCxXPBkjKj04URDRy/EPkvJWXCcKMvk1X0QlgaenZijeggWaxOTGDcDCQvOvrS3QqZMm8ZLz0ATtyVhAQN71HB0114GcOMHx7kTFVUmdKIiosBTkD5L8TTSO4j5REJMvokLi6am5LuLmTU1ikpGhScCCg+U91FCLJ2NkLLxw3fRK2kRBJQ33EdPjHyTlqSRMFMTki6iQ+fkB5csDCQmAm9vLkxm54MkYFbXi/tfKkiQ4WDOD6ZMnzycK0ufJE029fNx6k14B9xH54B8k5Sn7UFDNREGacu1QUDu750NB5TpRUDE5LSSiopb9ZCwvPBmjguCF6/JSkiYKKim4j8hL9j9I5oV/kDSeknJtOnu+XlFaVhossixylCsVSlioLHTq5eZV6qZnpUMtqJGWlYa0rDSdaTYVUMDSzFKnrgj9dxZ4sW6GOgOCmPsRx8rMyuR1LVWWUPz3J49MdSbUorrQ62YJWcgSsvJdVxCEHDGxUFlAqVAatN781DVXmkOlVOW7rlpQI1N4ftblUQ4Ibgrs3g2UsQcszMyg/O8QIUINQZGJzEwg4RHQsSPg7g2k/bcpM6UZzJSauoIoIEOdkWsbClpXFEWkq9MLVPfFeKgUKpirzA1ab37qGmu/z+8xwtD9viiPEXPmCbhwGfAP0Pw4igoBWUiDqEqDk1MZ6a+VXyzIwOzwkn+M0MfYx4gRY4BrscClS9pbSwgQoIYgaIbv3H+oRtUamRg26vm+nl32fe7F40ledeV4jHiRKY4Rc+ZBZx/BC3/RL2OfhguXgc8XAOHhhq/3ZW2QyzFCbucRrzUAbB2BR0lA2bKAUrTUhgQCMiEoNJ/D4yRNvbr1n+8nJeUY8bK6+dnvC+MYceQ48CQZCPA3A6TzE81viVqRBvG/PiW7sppr7n//AyhX3njHiLz2u+x4n68C0s7lH7IyBOZlcqbfQZ5BmNpiqvS8+5buuQaxpmtNhLd+fiTts70PktKT9Nat5FQJC0KeT6sz+JfBiE+JR0Z6BiwsLaQdGAB87H2wrMMy6fmw3cPwT9I/etfrVsYN33X+Tnoeti8M1x5d01vX3tIeG7tulJ5POjAJF+9f1FvXUmWJH3v+KD2ffng6/rz7p966ALDznZ3S/+ccm4Pj/xzPte7WHlulg+zCEwsRERuRa90NXTbAwcoBALD89HLsub4n17rfdfoObjZuAIBVZ1fhpys/5Vp3afulKO9QHgDw/YXv8cPFHwBodsQXY7Kg7QJUcq4EANh+eTtWn1ud63pnvzEbtdxrAQB2X92NFWdW5Fp3SrMpqO9dHwAQcSMCC08uzLXux40/RpPyTQAAx+KOYe7xuTrL09KACxeA5KeA770x8BNaQakEHlmfxmW3GcjI0Px1r1YtwOr57xuG1huKDpU7AAAuxF/A/w7+L9c2hAaGomu1rgCAaw+vIey33KeAfKfmO3i31rsAgLjEOAzfMzzXul2qdsGguoMAAAkpCRi8Y7C07MV4tK/YHh/W/xAAkJiWiL4/9c11va38W2HM62M0n09WGnps7ZFr3cY+jTGxyUTp+Vs/vJVrXWMeIxJSE/TWNdYxYti2Sfg+4iKUyud/rVRAhJV1BjJS7VAvZhsAzcygN/2mo+obf6JMGb2rLjHHCH1McYxIS9OcpDx8CKizRNR9NgQPzrwFW1slAloew4Oqc3X29ezGNByDVhVaAQBO3zmNGb/PyLUNcj9GvMjYx4jUVODMGejsI46p9dDabKh037U/K2iOEYIA1KsHnX2kuB8j5HoecelvID5e81m/dmsDLAQ7+Pgk4OizbYh32AtRAFKfAe7umhmNtUrSMeJFLzuPyK6wjxFxccCNGKDKs1B4PtEcI1KsonGj0kikPbOAiOfnwKkpQIUA4OP2xjtGZKZmYt97+156ny/2fBGRxMpKk1jduAGobwMxsZqTgRRHQHDR/MBUqIBcT8aI9LlzB8jKAmxySai0HB2B9HTgyWPkmnxR4bKy0pw0pqZqPvdm9kDNDpphxf8ogLm5n7dSIXr82LB9xNwMSEnlPmIsFQI0n3fyU02MXO005aKoGZar/YNkhQqmbWdpoVIBIjSff55ETT0zlREaVQDs+Sogbc9X/MN4vdmtsYcd6ru7d2keLlBYdV9l2OGLMSluwwVux5nhz1NmSE4GytioUa9BZq7Xfch9SNGL8eCwQw1jHSNWfJuBhV8JOicoCoWAcuUScPu2G5TC87PI67EZGDVaQGjoy9dbnI8R+pj6GCEIAh4/eAxPD08olUqjDyl61brFedjh6tXAV1/pnsQrFYBvuSdSz5daoal74wYwejR09pHifoyQ83nE3bvAokXAsSOWSEkWUbVqAi5Hl4WNnYimTYFRo3JOglJSjxEv1jX2MeLWLaBPH81lEc5l/+s/UmTBy+c2bt/W7CeAJlHOzAQ2btQMUTTWMSIpKQnuzu7s+SpqVmZWOjt6XvXys05DWZpZQhAEqR3KPKblyX5QfJnsB+biUNdcZQ5z5HL15SvUzb4j5qfuy2JS0PUWZl2VUiUdQPWpWEHz+K/2f4+XUyqUBn+H81NXoVAUuG5e8XiV9b6MHOrmZ78vqmOEg60FkAUo1M9nDlNAgBmsoBKtpFM5QQDELAuUtQOsDPgaF+djhBzrCoKgc0x42TEiu/zUleMxwhR1gef7sqMt9O4j2alEK83kD1l46T5S3I4Rcqib237v7wN8Kd1GRkRGBtDTwhzBwUqDJqKR+37/KnWNfYyoEgA0b6yZlMbe9r/ZDqF8/lsiKpGZCTxK0NxftcoLtwko6v0+wyz3PxRlx+SLiKiY0N77JyVFMxNXcbn3D6c1J8ob9xH5K663kSlpxo3T9P5q7/NVtqymXDtR0IMHmqHUYblfKmpyTL6IiGQu+71/kpI0P/qCoDkJKw73/tFOa75zp+YeLPqmCNZOa96pE6c1p9KH+wiRYTw9NTdQXrBAM538jRuAhYXmX1tbzf4RFibv30QmX0REMqa994/2r3wBAc+TrydPNPf+iYnR/BjJ+cemJPy1kqgocR8hMoynp+YGypqhoJqJTywsND3CxeEPE0y+iIhkbN48zcmY9karWtp7/2jvj7VggebHSK5Kwl8riYoS9xEyhuI6fF2f4joUlMkXEZFM3bypGWro6qp/GBKgKXd11Zys3bwp7x/R4v7XSpK/4n5iyX2EikpxH75ekjD5IiKSqchIzY9kQEDe9RwdNUMPT5woHieaxfWvlSRfJe3EkvsIFaaSMny9pGDyRUQkUykpmh/Il514aeskJxunXURywhNLeSvuvZElQUkZvl5SMPkiIpIpGxvNCaQg5J2AaevY2hqvbcSTSrngiaU8lbTeyOKqpA1fLwmYfBERyRTv/SNPPKmUD55YyhN7I+WjpA5fL844ipiISKa09/65f19zjx99tPf+ad6cF+Qbg/akcudOzUl9QMDzh7m55qRy2DBNPSp62hNLR8e86zk6auqdOGGMVlH23kgnp+c999reyAoVnvdGUtHi8HX5YfJFRCRj48YBNWpoppt+9Ejzl2NA8++jR0BsLO/9Y0w8qZQXnljKT0F6I6noZB++nhcOXzceJl9ERDKmvfdP586aXq6YmOePzEzNvX84dMc4eFIpPzyxlB/2RspL9uHreeHwdePhNV9ERDL34r1/kpM1J5G8949x8doJ+eF1kfLD3kh50Q5f37lTM/mMvj8caYevd+rE3xRjYPJFRFRM+PnxZN6UeFIpPzyxlB/O0io/48Zphq5rJ0BxdNSdAOXBAw5fNyYOOyQiIjIAh7jJE6+LlBcOc5MfDl+XF/Z8ERERGYBD3ORJe2K5YIHmWruYGN3p/zt10iRePLE0DvZGyhOHr8sHky8iIiID8KRSvnhiKS8c5iZfHL5ueky+iIiIDMSTSnnjiaU8sDeSKHdMvoiIiAzEk0oiw7A3kkg/Jl9ERET5wJNKIsOxN5JIF5MvIiKiAuBJJRER5RenmiciIiIiIjICJl9ERERERERGwOSLiIiIiIjICJh8ERERERERGQGTLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgIzUzeguBJFEQCQlJRk4pYAgiDg6dOnsLKyglLJfFoOGBN5YTzkhzGRH8ZEXhgP+WFM5EdOMdHmBNocITdMvgro6dOnAAAfHx8Tt4SIiIiIiOTg6dOncHBwyHW5QnxZekZ6CYKAf//9F3Z2dlAoFCZtS1JSEnx8fPDPP//A3t7epG0hDcZEXhgP+WFM5IcxkRfGQ34YE/mRU0xEUcTTp0/h5eWVZy8ce74KSKlUoly5cqZuhg57e3uTf/FIF2MiL4yH/DAm8sOYyAvjIT+MifzIJSZ59XhpccAqERERERGRETD5IiIiIiIiMgImXyWApaUlpk6dCktLS1M3hf7DmMgL4yE/jIn8MCbywnjID2MiP8UxJpxwg4iIiIiIyAjY80VERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImXyXA0qVL4efnBysrKzRs2BCnTp0ydZNKpfDwcNSvXx92dnZwc3PD22+/jejoaFM3i7KZM2cOFAoFxowZY+qmlGp37txB37594ezsDGtra9SqVQt//vmnqZtVKqnVanz66afw9/eHtbU1AgICMHPmTHAuLuP5/fff8dZbb8HLywsKhQI///yzznJRFDFlyhR4enrC2toarVu3xrVr10zT2FIir5hkZmbi448/Rq1atWBjYwMvLy/0798f//77r+kaXMK9bB/JbujQoVAoFFi4cKHR2pdfTL6Kuc2bNyMsLAxTp05FVFQU6tSpg5CQECQkJJi6aaXOkSNHMHz4cJw4cQL79+9HZmYm2rZti5SUFFM3jQCcPn0aX3/9NWrXrm3qppRqjx8/RuPGjWFubo5ff/0Vly5dwvz581G2bFlTN61Umjt3LpYvX44lS5bg8uXLmDt3Lj7//HMsXrzY1E0rNVJSUlCnTh0sXbpU7/LPP/8cixYtwooVK3Dy5EnY2NggJCQEaWlpRm5p6ZFXTFJTUxEVFYVPP/0UUVFR2L59O6Kjo9GpUycTtLR0eNk+ovXTTz/hxIkT8PLyMlLLCkikYq1Bgwbi8OHDpedqtVr08vISw8PDTdgqEkVRTEhIEAGIR44cMXVTSr2nT5+KlSpVEvfv3y82b95cHD16tKmbVGp9/PHHYpMmTUzdDPpPhw4dxEGDBumUde3aVezTp4+JWlS6ARB/+ukn6bkgCKKHh4f4xRdfSGVPnjwRLS0txR9++MEELSx9XoyJPqdOnRIBiLdu3TJOo0qx3OJx+/Zt0dvbW7x48aLo6+srfvnll0Zvm6HY81WMZWRk4MyZM2jdurVUplQq0bp1a0RGRpqwZQQAiYmJAAAnJycTt4SGDx+ODh066OwrZBo7duxAUFAQevToATc3N9StWxfffvutqZtVajVq1AgRERG4evUqAOCvv/7CsWPH8Oabb5q4ZQQAsbGxuHfvns6xy8HBAQ0bNuTvvIwkJiZCoVDA0dHR1E0plQRBQL9+/TB+/HjUqFHD1M15KTNTN4AK7sGDB1Cr1XB3d9cpd3d3x5UrV0zUKgI0B4IxY8agcePGqFmzpqmbU6pt2rQJUVFROH36tKmbQgBu3LiB5cuXIywsDP/73/9w+vRpjBo1ChYWFhgwYICpm1fqTJw4EUlJSahatSpUKhXUajU+++wz9OnTx9RNIwD37t0DAL2/89plZFppaWn4+OOP8c4778De3t7UzSmV5s6dCzMzM4waNcrUTTEIky+iIjB8+HBcvHgRx44dM3VTSrV//vkHo0ePxv79+2FlZWXq5hA0f5gICgrC7NmzAQB169bFxYsXsWLFCiZfJrBlyxZs3LgR33//PWrUqIFz585hzJgx8PLyYjyIXiIzMxM9e/aEKIpYvny5qZtTKp05cwZfffUVoqKioFAoTN0cg3DYYTHm4uIClUqF+Ph4nfL4+Hh4eHiYqFU0YsQI7Nq1C4cOHUK5cuVM3ZxS7cyZM0hISMBrr70GMzMzmJmZ4ciRI1i0aBHMzMygVqtN3cRSx9PTE9WrV9cpq1atGuLi4kzUotJt/PjxmDhxInr37o1atWqhX79+GDt2LMLDw03dNAKk33L+zsuPNvG6desW9u/fz14vEzl69CgSEhJQvnx56Xf+1q1b+Oijj+Dn52fq5unF5KsYs7CwQL169RARESGVCYKAiIgIBAcHm7BlpZMoihgxYgR++uknHDx4EP7+/qZuUqnXqlUrXLhwAefOnZMeQUFB6NOnD86dOweVSmXqJpY6jRs3znELhqtXr8LX19dELSrdUlNToVTqngqoVCoIgmCiFlF2/v7+8PDw0PmdT0pKwsmTJ/k7b0LaxOvatWs4cOAAnJ2dTd2kUqtfv344f/68zu+8l5cXxo8fj3379pm6eXpx2GExFxYWhgEDBiAoKAgNGjTAwoULkZKSgtDQUFM3rdQZPnw4vv/+e/zyyy+ws7OTxuM7ODjA2traxK0rnezs7HJcc2djYwNnZ2dei2ciY8eORaNGjTB79mz07NkTp06dwjfffINvvvnG1E0rld566y189tlnKF++PGrUqIGzZ89iwYIFGDRokKmbVmokJyfj+vXr0vPY2FicO3cOTk5OKF++PMaMGYNZs2ahUqVK8Pf3x6effgovLy+8/fbbpmt0CZdXTDw9PdG9e3dERUVh165dUKvV0u+9k5MTLCwsTNXsEutl+8iLya+5uTk8PDxQpUoVYzfVMKaebpFe3eLFi8Xy5cuLFhYWYoMGDcQTJ06YukmlEgC9j9WrV5u6aZQNp5o3vZ07d4o1a9YULS0txapVq4rffPONqZtUaiUlJYmjR48Wy5cvL1pZWYkVKlQQJ0+eLKanp5u6aaXGoUOH9P52DBgwQBRFzXTzn376qeju7i5aWlqKrVq1EqOjo03b6BIur5jExsbm+nt/6NAhUze9RHrZPvIiuU81rxBF3saeiIiIiIioqPGaLyIiIiIiIiNg8kVERERERGQETL6IiIiIiIiMgMkXERERERGRETD5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIqFaZNm4bAwMB8vUahUODnn38ukvaYYjtERGRaTL6IiKjYUSgUeT6mTZuW4zXjxo1DREREobZj4MCBePvttwt1nUREVHKZmboBRERE+XX37l3p/5s3b8aUKVMQHR0tldna2kr/F0URarUatra2OuVERETGxp4vIiIqdjw8PKSHg4MDFAqF9PzKlSuws7PDr7/+inr16sHS0hLHjh3LMezw9OnTaNOmDVxcXODg4IDmzZsjKirqldrVokULjBo1ChMmTICTkxM8PDxy9MJdu3YNzZo1g5WVFapXr479+/fnWM8///yDnj17wtHREU5OTujcuTNu3rwJALhy5QrKlCmD77//Xqq/ZcsWWFtb49KlS6/UfiIiKlpMvoiIqESaOHEi5syZg8uXL6N27do5lj99+hQDBgzAsWPHcOLECVSqVAnt27fH06dPX2m7a9euhY2NDU6ePInPP/8cM2bMkBIsQRDQtWtXWFhY4OTJk1ixYgU+/vhjnddnZmYiJCQEdnZ2OHr0KI4fPw5bW1u0a9cOGRkZqFq1KubNm4dhw4YhLi4Ot2/fxtChQzF37lxUr179ldpORERFi8MOiYioRJoxYwbatGmT6/I33nhD5/k333wDR0dHHDlyBB07dizwdmvXro2pU6cCACpVqoQlS5YgIiICbdq0wYEDB3DlyhXs27cPXl5eAIDZs2fjzTfflF6/efNmCIKAlStXQqFQAABWr14NR0dHHD58GG3btsWwYcOwZ88e9O3bFxYWFqhfvz5GjhxZ4DYTEZFxMPkiIqISKSgoKM/l8fHx+OSTT3D48GEkJCRArVYjNTUVcXFxr7TdF3vZPD09kZCQAAC4fPkyfHx8pMQLAIKDg3Xq//XXX7h+/Trs7Ox0ytPS0hATEyM9X7VqFSpXrgylUom///5bStSIiEi+mHwREVGJZGNjk+fyAQMG4OHDh/jqq6/g6+sLS0tLBAcHIyMj45W2a25urvNcoVBAEASDX5+cnIx69eph48aNOZa5urpK///rr7+QkpICpVKJu3fvwtPTs+CNJiIio2DyRUREpdLx48exbNkytG/fHoBmkosHDx4U6TarVauGf/75RydZOnHihE6d1157DZs3b4abmxvs7e31rufRo0cYOHAgJk+ejLt376JPnz6IioqCtbV1kbafiIheDSfcICKiUqlSpUpYv349Ll++jJMnT6JPnz5Fnry0bt0alStXxoABA/DXX3/h6NGjmDx5sk6dPn36wMXFBZ07d8bRo0cRGxuLw4cPY9SoUbh9+zYAYOjQofDx8cEnn3yCBQsWQK1WY9y4cUXadiIienVMvoiIqFT67rvv8PjxY7z22mvo168fRo0aBTc3tyLdplKpxE8//YRnz56hQYMGeO+99/DZZ5/p1ClTpgx+//13lC9fHl27dkW1atUwePBgpKWlwd7eHuvWrcOePXuwfv16mJmZwcbGBhs2bMC3336LX3/9tUjbT0REr0YhiqJo6kYQERERERGVdOz5IiIiIiIiMgImX0REREREREbA5IuIiIiIiMgImHwREREREREZAZMvIiIiIiIiI2DyRUREREREZARMvoiIiIiIiIyAyRcREREREZERMPkiIiIiIiIyAiZfRERERERERsDki4iIiIiIyAj+D5cdec4gBaiHAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1184,14 +1086,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Standard benchmark on tricky kernel: 0.0978 ms\n" + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "Standard benchmark on tricky kernel: 0.1880 ms\n" ] } ], @@ -1270,8 +1166,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Robust benchmark on tricky kernel: 21.5401 ms\n", - "Robust benchmark on normal kernel: 21.4700 ms\n" + "Robust benchmark on tricky kernel: 21.6298 ms\n", + "Robust benchmark on normal kernel: 21.5420 ms\n" ] } ], @@ -1312,37 +1208,19 @@ "Side-Stream Detection Experiment:\n", "============================================================\n", "[Profiling] Using timing method: cuda_event\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", "[Profiling] Using timing method: host_time\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 10\n", "\n", - "Tricky kernel with cuda_event: 0.3070 ms (FOOLED!)\n", + "Tricky kernel with cuda_event: 0.4400 ms (FOOLED!)\n", "Tricky kernel with host_time: 21.8000 ms (CORRECT)\n", - "Normal kernel with host_time: 21.6000 ms (reference)\n" + "Normal kernel with host_time: 21.5000 ms (reference)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1524,42 +1402,12 @@ "Size Time (ms) TFLOPS % of TF32 Peak \n", "-----------------------------------------------------------------\n", "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", - "1024 0.0647 33.19 3.4 %\n", - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2048 0.3440 49.94 5.0 %\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4096 2.6700 51.48 5.2 %\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "1024 0.0648 33.14 3.4 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "2048 0.3440 49.94 5.0 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", + "4096 2.6800 51.28 5.2 %\n", + "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 10, trials 100\n", "8192 21.4000 51.38 5.2 %\n", "\n", "Note: PyTorch uses TF32 tensor cores by default on Ampere+ GPUs.\n",