diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb new file mode 100644 index 00000000..a9f3ba15 --- /dev/null +++ b/notebooks/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": "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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": "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": [ + "
" + ] + }, + "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": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAajxJREFUeJzt3Xd8VFX+//H3pE16I40SEjoJ0kFBBSxAgJWlKc1Cs+wqsIiKi7pCVBbBAmtDRQXUVVERO0X9AiJNQAHpEOkEUiAJ6ZA5vz/4ZZYhARLIMAm8nj54PJxzz73zuXcyJ/POuXOvxRhjBAAAAAAAKpybqwsAAAAAAOBKRegGAAAAAMBJCN0AAAAAADgJoRsAAAAAACchdAMAAAAA4CSEbgAAAAAAnITQDQAAAACAkxC6AQAAAABwEkI3AAAAAABOQugGgHOIjY3V0KFDL9hv9uzZslgs2rt3r9NrwpXjpptu0k033eTqMi47i8WiiRMnuroMSJo4caIsFovS0tJcXcolGzp0qGJjY11dBgCUitAN4Krzxx9/6Pbbb1dMTIy8vb1Vs2ZNdenSRa+++qqrS3PwzTffqFOnToqIiJCvr6/q1q2r/v37a+HChfY+hw8f1sSJE7VhwwbXFeokS5culcVisf+zWq2KjIzUTTfdpH//+99KTU296G1fruO2detWTZw4kT/IQJKUm5uriRMnaunSpa4uxWUu5RhcyeMdgCubh6sLAIDLaeXKlbr55ptVu3Zt3XfffYqKitKBAwe0evVq/ec//9GoUaPsfXfs2CE3N9f8bfLFF1/UY489pk6dOmn8+PHy9fXV7t279eOPP+qTTz5Rt27dJJ3+EJqYmKjY2Fi1aNHCJbU62+jRo9W2bVsVFRUpNTVVK1eu1IQJE/Tyyy/r008/1S233FLubV6u47Z161YlJibqpptuKjELt3jxYqc9Lyqn3NxcJSYmStJVeZaDdGnH4Hzv25kzZ8pms1VQlQBQsQjdAK4qkyZNUlBQkNauXavg4GCHZSkpKQ6PrVbrZazsf06dOqVnn31WXbp0KTWYnV1neeTm5srX1/dSyrvsOnTooNtvv92hbePGjeratav69eunrVu3qnr16i6q7uJ5eXm5ugTgiuHp6enqEgDgnDi9HMBVJSkpSU2aNCkRuCUpIiLC4XFp3+nesmWLbrnlFvn4+KhWrVp67rnnzjm7smDBAnXo0EF+fn4KCAjQX/7yF23ZsuWCNaalpSkrK0s33HBDqcuL61y6dKnatm0rSRo2bJj9NOzZs2dLOj2LdM0112j9+vXq2LGjfH199cQTT0iSCgoKNGHCBNWvX19Wq1XR0dEaN26cCgoKHJ5r1qxZuuWWWxQRESGr1ar4+HjNmDGjRE2xsbG67bbbtHTpUrVp00Y+Pj5q2rSp/RTSL774Qk2bNpW3t7dat26t33///YLH4XyaN2+u6dOnKyMjQ6+99prDskOHDmn48OGKjIyU1WpVkyZN9N5779mXX+i4SdKaNWvUrVs3BQUFydfXV506ddKKFStK1HHo0CGNGDFCNWrUkNVqVZ06dfT3v/9dhYWFmj17tu644w5J0s0332x/nuJjUtp3ulNSUjRixAhFRkbK29tbzZs315w5cxz67N27VxaLRS+++KLefvtt1atXT1arVW3bttXatWsd+p48eVLbt29XcnJymY7r9u3b1b9/f4WHh8vHx0eNGjXSk08+aV9+ru/NFn83+EwFBQV6+OGHFR4eroCAAP31r3/VwYMHS6y7b98+Pfjgg2rUqJF8fHxUrVo13XHHHRd9Sv6HH36o1q1by8fHR6GhoRo4cKAOHDhgXz5y5Ej5+/srNze3xLqDBg1SVFSUioqK7G1leR8PHTpU/v7+OnTokHr37i1/f3+Fh4fr0UcftW9r7969Cg8PlyQlJibafx7O9f32devWyWKxlHj9JWnRokWyWCz69ttvJUknTpzQmDFjFBsbK6vVqoiICHXp0kW//fZbmY5ZRkaGhg4dquDgYAUFBWnYsGEljk/xHwOLf95iY2P1xBNPlBgz1q1bp4SEBIWFhcnHx0d16tTR8OHDL+oYnOlC79uzfzbPfJ+8/vrrqlu3rnx9fdW1a1cdOHBAxhg9++yzqlWrlnx8fNSrVy8dO3asxPNe7DgOAA4MAFxFunbtagICAswff/xxwb4xMTFmyJAh9sfJyckmPDzchISEmIkTJ5oXXnjBNGjQwDRr1sxIMnv27LH3ff/9943FYjHdunUzr776qpkyZYqJjY01wcHBDv1KU1RUZHx8fEzr1q1Nenr6OfsdOXLEPPPMM0aSuf/++80HH3xgPvjgA5OUlGSMMaZTp04mKirKhIeHm1GjRpm33nrLfPnll6aoqMh07drV+Pr6mjFjxpi33nrLjBw50nh4eJhevXo5PEfbtm3N0KFDzbRp08yrr75qunbtaiSZ1157rcSxatSokalevbqZOHGimTZtmqlZs6bx9/c3H374oaldu7Z5/vnnzfPPP2+CgoJM/fr1TVFR0XmPw5IlS4wk89lnn5W6vLCw0Pj4+Jg2bdo4HJNatWqZ6Oho88wzz5gZM2aYv/71r0aSmTZtWpmO208//WS8vLxM+/btzUsvvWSmTZtmmjVrZry8vMyaNWvsz3Xo0CFTo0YN+3F88803zb/+9S8TFxdnjh8/bpKSkszo0aONJPPEE0/Yn+fIkSP216dTp0727eXm5pq4uDjj6elpHn74YfPKK6+YDh06GElm+vTp9n579uwxkkzLli1N/fr1zZQpU8zUqVNNWFiYqVWrliksLCzR98yf43PZuHGjCQwMNNWqVTPjx483b731lhk3bpxp2rSpvc+QIUNMTExMiXUnTJhgzv5IcddddxlJZvDgwea1114zffv2tb9XJkyYYO/32WefmebNm5unn37avP322+aJJ54wISEhJiYmxuTk5Fyw7jM999xzxmKxmAEDBpg33njDJCYmmrCwMBMbG2uOHz9ujDHm559/NpLMp59+6rBuTk6O8fPzMw899JC9razv4yFDhhhvb2/TpEkTM3z4cDNjxgzTr18/I8m88cYbxhhjsrOzzYwZM4wk06dPH/vPw8aNG8+5P3Xr1jU9evQo0T5s2DATEhJif60HDx5svLy8zNixY80777xjpkyZYnr27Gk+/PDD8x6v4tetZcuWpm/fvuaNN94w9957r5Fkxo0b59B3yJAhRpK5/fbbzeuvv27uueceI8n07t3b3ufo0aMmJCTENGzY0Lzwwgtm5syZ5sknnzRxcXEXfQyKXeh9e/bPZvHPfosWLUx8fLx5+eWXzVNPPWW8vLxMu3btzBNPPGGuv/5688orr5jRo0cbi8Vihg0b5vCclzKOA8CZCN0AriqLFy827u7uxt3d3bRv396MGzfOLFq0yCGoFDs7dI8ZM8ZIcgheKSkpJigoyCF0nzhxwgQHB5v77rvPYXtHjhwxQUFBJdpL8/TTTxtJxs/Pz3Tv3t1MmjTJrF+/vkS/tWvXGklm1qxZJZZ16tTJSDJvvvmmQ/sHH3xg3NzczPLlyx3a33zzTSPJrFixwt6Wm5tbYrsJCQmmbt26Dm0xMTFGklm5cqW9bdGiRUaS8fHxMfv27bO3v/XWW0aSWbJkyXmPwYVCtzHGNG/e3ISEhNgfjxgxwlSvXt2kpaU59Bs4cKAJCgqy78+5jpvNZjMNGjQwCQkJxmaz2dtzc3NNnTp1TJcuXext99xzj3FzczNr164tUVfxup999tk59/Xs0D19+nQjySEoFRYWmvbt2xt/f3+TlZVljPlfmKhWrZo5duyYve9XX31lJJlvvvnG3lae0N2xY0cTEBDg8FqduS/GlD10b9iwwUgyDz74oEO/wYMHlwjdpf2MrVq1ykgy77///gXrLrZ3717j7u5uJk2a5ND+xx9/GA8PD3u7zWYzNWvWNP369XPo9+mnnxpJ5ueffzbGlO99XBxIn3nmGYe+LVu2NK1bt7Y/Tk1NLbH/5zN+/Hjj6enp8DoXFBSY4OBgM3z4cHtbUFCQwx8Lyqr4dTtzW8YY06dPH1OtWjX74+LX895773Xo9+ijjxpJ5v/+7/+MMcbMnz/fSCr1PVGsvMfgTOcb784VusPDw01GRoa9ffz48UaSad68uTl58qS9fdCgQcbLy8vk5+cbYypmHAeAYpxeDuCq0qVLF61atUp//etftXHjRk2dOlUJCQmqWbOmvv766/Ou+/3336tdu3a69tpr7W3h4eG68847Hfr98MMPysjI0KBBg5SWlmb/5+7uruuuu05Lliy5YJ2JiYn66KOP1LJlSy1atEhPPvmkWrdurVatWmnbtm1l3l+r1aphw4Y5tH322WeKi4tT48aNHeorviDZmfX5+PjY/z8zM1NpaWnq1KmT/vzzT2VmZjpsNz4+Xu3bt7c/vu666yRJt9xyi2rXrl2i/c8//yzzfpyLv7+/Tpw4IUkyxmjevHnq2bOnjDEO+5aQkKDMzMwLnm67YcMG7dq1S4MHD1Z6erp9/ZycHN166636+eefZbPZZLPZ9OWXX6pnz55q06ZNie2cfap1WXz//feKiorSoEGD7G2enp4aPXq0srOztWzZMof+AwYMUEhIiP1xhw4dJDke19jYWBljHE6dL01qaqp+/vlnDR8+3OG1upR9kU5fBO9MY8aMKdH3zJ+xkydPKj09XfXr11dwcHCZT4+WTn+FwWazqX///g6vfVRUlBo0aGD/ubZYLLrjjjv0/fffKzs7277+3LlzVbNmTd14442SLu59/Le//c3hcYcOHS7p53zAgAE6efKkvvjiC3vb4sWLlZGRoQEDBtjbgoODtWbNGh0+fPiinqe0utPT05WVlSXpf6/n2LFjHfo98sgjkqTvvvvOXockffvttzp58uRF1VLR7rjjDgUFBdkfF48/d911lzw8PBzaCwsLdejQIUkVM44DQDEupAbgqtO2bVt98cUXKiws1MaNGzV//nxNmzZNt99+uzZs2KD4+PhS19u3b5/9A9uZGjVq5PB4165dknTOq2oHBgZKkvLy8koE16ioKPv/Dxo0SIMGDVJWVpbWrFmj2bNn66OPPlLPnj21efNmeXt7X3Bfa9asWeKCXbt27dK2bdvs360825kXaluxYoUmTJigVatWlfiOZ2ZmpsOH2bPDWvGy6OjoUtuPHz9+wfovJDs7WwEBAZJOB8eMjAy9/fbbevvtt0vtf6GL0BW/dkOGDDlnn8zMTBUWFiorK0vXXHPNRVZe0r59+9SgQYMSV8yPi4uzLz/T2ce7OIBfzHEtDoYVtT/79u2Tm5ub6tWr59B+9ntFOv0+mDx5smbNmqVDhw7JGGNfdvb743x27dolY4waNGhQ6vIzL7Q1YMAATZ8+XV9//bUGDx6s7Oxsff/993rggQfsf2Qo6/u4mLe3d4n3VEhIyCX9nDdv3lyNGzfW3LlzNWLECEmn/zgQFhbmUNfUqVM1ZMgQRUdHq3Xr1urRo4fuuece1a1bt0zPc76fpcDAQPvrWb9+fYd+UVFRCg4Otv9sdurUSf369VNiYqKmTZumm266Sb1799bgwYNddmHKix2Xyvv6A8D5ELoBXLW8vLzUtm1btW3bVg0bNtSwYcP02WefacKECZe03eILq33wwQcOIbpY8ezK3LlzS8xCnxk4igUGBqpLly7q0qWLPD09NWfOHK1Zs0adOnW6YC1nziKeWV/Tpk318ssvl7pO8YfRpKQk3XrrrWrcuLFefvllRUdHy8vLS99//72mTZtW4gJy7u7upW7vXO2l7Wt5nDx5Ujt37rQHxeJ67rrrrnOG5mbNmp13m8XbeOGFF855KzF/f/9SL7h0uTnruJ7PuWa9z7zwWHmNGjVKs2bN0pgxY9S+fXsFBQXJYrFo4MCB5boFlM1mk8Vi0YIFC0o9Nv7+/vb/b9eunWJjY/Xpp59q8ODB+uabb5SXl+cwe1zW93Gxc70el2rAgAGaNGmS0tLSFBAQoK+//lqDBg1yeP7+/furQ4cOmj9/vhYvXqwXXnhBU6ZM0RdffKHu3btf8DnK+rN0obMeLBaLPv/8c61evVrffPONFi1apOHDh+ull17S6tWrHV6Dy+Vix6Xyvv4AcD6MGAAg2U8RPt9VnmNiYuyzH2fasWOHw+Pi2b2IiAh17tz5nNtLSEjQDz/8UO4658yZY6/zYk79rVevnjZu3Khbb731vOt/8803Kigo0Ndff+0wW1RZTqv8/PPPlZeXp4SEBEmyXyW7qKjovMddOvdxK37tAgMDz7uN8PBwBQYGavPmzRf1PKWJiYnRpk2bZLPZHGa7t2/fbl/uLMUzohfan5CQEGVkZJRoP3sWPiYmRjabTUlJSQ6z22e/V6TTr+OQIUP00ksv2dvy8/NLfZ7zqVevnowxqlOnjho2bHjB/v3799d//vMfZWVlae7cuYqNjVW7du0ctidd+H1cHhfzfh0wYIASExM1b948RUZGKisrSwMHDizRr3r16nrwwQf14IMPKiUlRa1atdKkSZPKFLovpPj13LVrl/3MC0k6evSoMjIySvxstmvXTu3atdOkSZP00Ucf6c4779Qnn3yie++996KOQbFLWbe8nPH6A7h68Z1uAFeVJUuWlDoTWPydxdJOfy3Wo0cPrV69Wr/++qu9LTU1Vf/9738d+iUkJCgwMFD//ve/S/1eY2pqqqTTH5I7d+7s8E86fS/tVatWlVrDggULHOr08/OTpHIFlP79++vQoUOaOXNmiWV5eXnKycmR9L+ZoLNP9501a1aZn8tZNm7cqDFjxigkJEQPPfSQpNP19uvXT/PmzSs1PBYfd+ncx61169aqV6+eXnzxRYfv+569DTc3N/Xu3VvffPON1q1bV6Jf8TErz+vTo0cPHTlyRHPnzrW3nTp1Sq+++qr8/f3LdGbD2cp6y7Dw8HB17NhR7733nvbv3++w7MzXv169esrMzNSmTZvsbcnJyZo/f77DOsVB75VXXnFonz59eonndnd3L/GefPXVV8s9e963b1+5u7srMTGxxPaMMUpPT3doGzBggAoKCjRnzhwtXLhQ/fv3d1he1vdxefj6+koq3/s1Li5OTZs21dy5czV37lxVr15dHTt2tC8vKioqcRp+RESEatSoUeJ2XherR48ekkq+fsVny/zlL3+RdPrU7LOPffEZI8W1XMwxKHYx493FcsbrD+DqxUw3gKvKqFGjlJubqz59+qhx48YqLCzUypUr7TNdZ5/ufaZx48bpgw8+ULdu3fSPf/xDfn5+evvtt+0zlMUCAwM1Y8YM3X333WrVqpUGDhyo8PBw7d+/X999951uuOGGEveWPlNubq6uv/56tWvXTt26dVN0dLQyMjL05Zdfavny5erdu7datmwp6XQICg4O1ptvvqmAgAD5+fnpuuuuU506dc65/bvvvluffvqp/va3v2nJkiW64YYbVFRUpO3bt+vTTz/VokWL1KZNG3Xt2lVeXl7q2bOnHnjgAWVnZ2vmzJmKiIgo832fK8Ly5cuVn5+voqIipaena8WKFfr6668VFBSk+fPnO5z6+fzzz2vJkiW67rrrdN999yk+Pl7Hjh3Tb7/9ph9//NF+Wvj5jts777yj7t27q0mTJho2bJhq1qypQ4cOacmSJQoMDNQ333wjSfr3v/+txYsXq1OnTrr//vsVFxen5ORkffbZZ/rll18UHBysFi1ayN3dXVOmTFFmZqasVqv9vudnu//++/XWW29p6NChWr9+vWJjY/X5559rxYoVmj59uv276+Vx6NAhxcXFaciQIRe8mNorr7yiG2+8Ua1atdL999+vOnXqaO/evfruu++0YcMGSdLAgQP1+OOPq0+fPho9erRyc3M1Y8YMNWzY0OGiZy1atNCgQYP0xhtvKDMzU9dff71++ukn7d69u8Tz3nbbbfrggw8UFBSk+Ph4rVq1Sj/++KOqVatWrn2tV6+ennvuOY0fP1579+5V7969FRAQoD179mj+/Pm6//779eijj9r7t2rVSvXr19eTTz6pgoICh1PLpUt/H5fGx8dH8fHxmjt3rho2bKjQ0FBdc801F/wu/YABA/T000/L29tbI0aMcDgT4sSJE6pVq5Zuv/12NW/eXP7+/vrxxx+1du1ah7MHLkXz5s01ZMgQvf3228rIyFCnTp3066+/as6cOerdu7duvvlmSdKcOXP0xhtvqE+fPqpXr55OnDihmTNnKjAw0B7cL/YYSBc33l0sZ7z+AK5il/lq6QDgUgsWLDDDhw83jRs3Nv7+/sbLy8vUr1/fjBo1yhw9etSh79m3DDPGmE2bNplOnToZb29vU7NmTfPss8+ad999t8R9uo05fcurhIQEExQUZLy9vU29evXM0KFDzbp1685b48mTJ83MmTNN7969TUxMjLFarcbX19e0bNnSvPDCC6agoMCh/1dffWXi4+ONh4eHw+10OnXqZJo0aVLqcxQWFpopU6aYJk2aGKvVakJCQkzr1q1NYmKiyczMtPf7+uuvTbNmzYy3t7eJjY01U6ZMMe+9916J/Y2JiTF/+ctfSjyPpBK3Miq+lc8LL7xw3uNQfMuw4n+enp4mPDzcdOzY0UyaNMmkpKSUut7Ro0fNQw89ZKKjo42np6eJiooyt956q3n77bfLdNyMMeb33383ffv2NdWqVTNWq9XExMSY/v37m59++slhG/v27TP33HOPCQ8PN1ar1dStW9c89NBDDq/RzJkzTd26dY27u7vD7cPOvmVYce3Dhg0zYWFhxsvLyzRt2rTE7ZHOd/x01q2YynPLMGOM2bx5s+nTp48JDg423t7eplGjRuZf//qXQ5/Fixeba665xnh5eZlGjRqZDz/8sNT7dOfl5ZnRo0ebatWqGT8/P9OzZ09z4MCBEjUeP37cvs/+/v4mISHBbN++vdT3X1nMmzfP3HjjjcbPz8/4+fmZxo0bm4ceesjs2LGjRN8nn3zSSDL169c/5/bK8j4eMmSI8fPzK7Fuacdl5cqVpnXr1sbLy6vMt87atWuX/X3wyy+/OCwrKCgwjz32mGnevLkJCAgwfn5+pnnz5vb7g59PcX2pqakO7bNmzSrxHj958qRJTEw0derUMZ6eniY6OtqMHz/efostY4z57bffzKBBg0zt2rWN1Wo1ERER5rbbbisx5l3MMSh2rvftuW4Zdvb75Fy3Iize57Nvd3ax4zgAnMlijBOvuAIAAAAAwFWM73QDAAAAAOAkfKcbAABUakeOHDnvch8fH4d7xqNqKSwsvOBt+IKCgkq9BSIAVAWcXg4AACq1C90qqiwXikPltXTpUvvF2M5l1qxZGjp06OUpCAAqGDPdAACgUrvQ/exr1KhxmSqBMzRv3vyCr3GTJk0uUzUAUPGY6QYAAAAAwEm4kBoAAAAAAE5yxZ9ebrPZdPjwYQUEBFzwO2EAAAAAAJSFMUYnTpxQjRo15OZ27vnsKz50Hz58WNHR0a4uAwAAAABwBTpw4IBq1ap1zuVXfOgOCAiQdPpABAYGurgaAAAAAMCVICsrS9HR0fbMeS5XfOguPqU8MDCQ0A0AAAAAqFAX+hozF1IDAAAAAMBJCN0AAAAAADgJoRsAAAAAACchdAMAAAAA4CSEbgAAAAAAnITQDQAAAACAkxC6AQAAAABwEkI3AAAAAABOQugGAAAAAMBJCN0AAAAAADgJoRsAAAAAACchdAMAAAAA4CSEbgAAAAAAnITQDQAAAACAkxC6AQAAAABwEkI3AAAAAABOQugGAAAAAMBJPFxdAACg6mnzdhtXlwDgIqy7f52rSwCAqw6hGwAAlOpY3jGdKDyhIGuQrO5WWT2scrNwkhwAAOVB6AYAAKVKy03TicITSstNs7d5unnK6mFViHeIIvwiXFgdAABVA3+uBgAApYoNipXl///nbnFXpF+kqvlWk6ebp2zG5uryAACoEgjdAACgVF4eXoryj5IkeXt462jOURXZihQTFGNvBwAA58fp5QAA4Jwi/SKVlpsmL3cvhfqE6mDWQWUVZCk2OFb+Xv6uLg84rzZc8xGostZdQdd9ZKYbAACck7ubu2oE1NDx/OPy8/RTfHi8PNw8tCN9hw5lHeI0cwAALoDQDQAAzquaTzX5ePgoNTdV3h7ealStkWoE1NDRnKPanrZduSdzXV0iAACVFqEbAACcl8ViUcNqDVUjoIb9cXX/6moc1lhGRtvTtutI9hEZY1xcKQAAlQ+hGwAAXJCHm4e83L0c2nw9fRUXFqcIvwgdOnFIO9J3KP9UvosqBACgciJ0AwCAi+ZmcVOtwFpqVK2RTtlOaVvaNqXkpDDrDQDA/0foBgAAl8zfy19xYXGq5lNNB7IOaPex3SosKnR1WQAAuByhGwAAVAh3N3fVDqqt+qH1lXcqT1tTtyo9L51ZbwDAVY3QDQAAKlSQNUjx4fEKsgZpb8Ze/Znxp07ZTrm6LAAAXILQDQAAKpyHm4fqhNRR3eC6OlFwQltStygjP8PVZQEAcNkRugEAgNOE+ISoSXgT+Xn6Kel4kvZm7FWRrcjVZQEAcNkQugEAgFN5unuqXkg9xQTF6Hj+cW1N26oTBSdcXRYAAJcFoRsAADidxWJRmG+Y4sPi5eXupZ3HdupA1gHZjM3VpQEA4FSEbgAAcNlYPaxqGNpQtQJqKTUnVdtStymnMMfVZQEA4DSEbgAAcFlZLBZF+kcqLixObm5u2p6+XYdPHObWYgCAKxKhGwAAuISPp48aV2us6v7VlZydrO3p25V3Ms/VZQEAUKEI3QAAwGUsFotqBNRQ42qNZbPZtC1tm45mH2XWGwBwxSB0AwAAl/Pz8lNceJzC/cJ18MRB7Ty2UwWnClxdFgAAl4zQDQAAKgU3i5uiA6PVMLShCosKtTVtq9Jy05j1BgBUaYRuAABQqQRYAxQfFq8Q7xDty9ynpONJOll00tVlAQBwUQjdAACg0nF3c1dscKzqhdRTzskcbUndouN5x11dFgAA5ebh6gIAAADOJdg7WH6eftqftV9/Zvyp0PxQRQdFy8ONjzAAgKrBpTPdkydPVtu2bRUQEKCIiAj17t1bO3bscOiTn5+vhx56SNWqVZO/v7/69euno0ePuqhiAABwuXm6e6pucF3FBscqsyBTW1O3KrMg09VlAQBQJi4N3cuWLdNDDz2k1atX64cfftDJkyfVtWtX5eTk2Ps8/PDD+uabb/TZZ59p2bJlOnz4sPr27evCqgEAwOVmsVhUzaea4sPj5e3hrd3Hdmt/5n4V2YpcXRoAAOfl0nOzFi5c6PB49uzZioiI0Pr169WxY0dlZmbq3Xff1UcffaRbbrlFkjRr1izFxcVp9erVateunSvKBgAALuLl7qUGoQ2UlpumgycOKqsgS7HBsfL38nd1aQAAlKpSXUgtM/P0qWKhoaGSpPXr1+vkyZPq3LmzvU/jxo1Vu3ZtrVq1yiU1AgAA17JYLAr3C1dcWJw83Dy0I32HDmYdlM3YXF0aAAAlVJqrkNhsNo0ZM0Y33HCDrrnmGknSkSNH5OXlpeDgYIe+kZGROnLkSKnbKSgoUEFBgf1xVlaWffs2G7+MAaAiWGRxdQmAfDx81LhaYx3JOaLDJw4rqyBLdYLryNfT19WlVVpX22chC0MVUGVVheGqrGNqpQndDz30kDZv3qxffvnlkrYzefJkJSYmlmhPTU1Vfn7+JW0bAHBafa/6ri4BsGtgbaDj/se1Jm2Ntqdt1zXB16hxYGO5WSrVCX2VQkpKiqtLuKzqM1QBVVZVGK5OnDhRpn6VInSPHDlS3377rX7++WfVqlXL3h4VFaXCwkJlZGQ4zHYfPXpUUVFRpW5r/PjxGjt2rP1xVlaWoqOjFR4ersDAQKftAwBcTXYX7nZ1CUAJdavV1eETh7UpY5OScpJUJ7iOvD28XV1WpRIREeHqEi6r3QxVQJVVFYYrb++y/Y5xaeg2xmjUqFGaP3++li5dqjp16jgsb926tTw9PfXTTz+pX79+kqQdO3Zo//79at++fanbtFqtslqtJdrd3Nzk5sZfvAGgIhgZV5cAlGCxWFQzsKaCvIO0N2OvtqZtVc2Amgr3DZeF84wl6ar7LGQYqoAqqyoMV2UdU10auh966CF99NFH+uqrrxQQEGD/nnZQUJB8fHwUFBSkESNGaOzYsQoNDVVgYKBGjRql9u3bc+VyAABQKn8vf8WFxenQiUM6kHVAGfkZig2OlZe7l6tLAwBchVwaumfMmCFJuummmxzaZ82apaFDh0qSpk2bJjc3N/Xr108FBQVKSEjQG2+8cZkrBQAAVYm7m7tqB9VWsHfw6Vnv1K2KDoxWqE8os94AgMvK5aeXX4i3t7def/11vf7665ehIgAAcCUJtAYqPjxeBzIPaG/mXmUUZKh2YG15unu6ujQAwFWiCpwpDwAAcPE83DxUJ6SO6gbX1YmCE9qatlUZ+RmuLgsAcJUgdAMAgKtCiE+ImoQ3kZ+nn5KOJ2lvxl4V2YpcXRYA4ApH6AYAAFcNT3dP1Qupp5igGB3PP66taVt1oqBs91kFAOBiELoBAMBVxWKxKMw3TPFh8fJy99LOYzt1IOuAbMbm6tIAAFcgQjcAALgqWT2sahjaULUCayk1J1XbUrcppzDH1WUBAK4whG4AAHDVslgsivSLVFxYnNzc3LQ9fbsOnzhcpjusAABQFoRuAABw1fPx9FHjao1V3b+6krOTtT1tu/JO5rm6LADAFYDQDQAAoNOz3jUCaqhxtcayyaZtadt0NPsos94AgEtC6AYAADiDn5ef4sLiFO4XroMnDmrnsZ0qOFXg6rIAAFUUoRsAAOAsbhY3RQdGq2FoQxUWFWpr2lal5aYx6w0AKDdCNwAAwDkEWAMUHxavUO9Q7cvcp6TjSTpZdNLVZQEAqhBCNwAAwHm4u7krJjhG9ULqKedkjrakbtGxvGOuLgsAUEV4uLoAAACAqiDYO1j+Xv7al7lPezL2KCM/Q7WDasvDjY9TAIBzY6YbAACgjDzcPFQ3uK7qBNdRVkGWtqZuVWZ+pqvLAgBUYoRuAACAcrBYLAr1CVV8eLx8PH20+/hu7cvcpyJbkatLAwBUQoRuAACAi+Dl7qX6IfVVO7C2juUd09a0rcouzHZ1WQCASobQDQAAcJEsFovC/cIVFxYnTzdP7UjfoYNZB2UzNleXBgCoJAjdAAAAl8jbw1uNqjVSzYCaSslJ0ba0bco9mevqsgAAlQChGwAAoAJYLBZF+UepcVhjWWTR9rTtSj6RLGOMq0sDALgQoRsAAKAC+Xr6qnFYY0X6Repw9mHtSN+h/FP5ri4LAOAihG4AAIAK5mZxU83AmmpUrZFO2U5pa+pWpeSkMOsNAFchQjcAAICT+Hv5Ky4sTmG+YTqQdUC7ju1SYVGhq8sCAFxGhG4AAAAncndzV+2g2moQ2kD5p/K1NXWr0nPTmfUGgKsEoRsAAOAyCLQGKj48XkHeQdqbuVd/Hv9TJ4tOurosAICTEboBAAAuEw83D9UJrqO6wXWVfTJbW9O2KiM/w9VlAQCciNANAABwmYX4hCg+LF5+nn5KOp6kvRl7VWQrcnVZAAAnIHQDAAC4gKe7p+qF1FNMUIyO5x/XltQtyirIcnVZAIAKRugGAABwEYvFojDfMMWHxcvbw1u7ju3SgcwDshmbq0sDAFQQQjcAAICLWT2sahDaQLUCayk1N1VbU7cqpzDH1WUBACoAoRsAAKASsFgsivSLVHx4vNzd3LU9fbsOnzjMrDcAVHGEbgAAgErE28Nbjas1Vg3/GkrOTtb2tO3KO5nn6rIAABeJ0A0AAFDJWCwWVQ+orsZhjWVktC1tm45kH5ExxtWlAQDKidANAABQSfl5+ikuLE4RfhE6dOKQdh7bqYJTBa4uCwBQDoRuAACASszN4qZagbXUMLShCosKtTVtq1JzU5n1BoAqgtANAABQBQRYAxQfFq9Q71Dtz9yv3cd362TRSVeXBQC4AEI3AABAFeHu5q6Y4BjVD6mv3JO52pK6Rcfyjrm6LADAeRC6AQAAqpgg7yA1CW+iQGug9mTs0Z/H/9Qp2ylXlwUAKAWhGwAAoArycPNQ3ZC6qhNcR1kFWdqaulWZ+ZmuLgsAcBZCNwAAQBUW6hOq+PB4+Xj6aPfx3dqXuU9FtiJXlwUA+P8I3QAAAFWcl7uX6ofUV+3A2jqWd0xb07bqROEJV5cFABChGwAA4IpgsVgU7heu+LB4ebp5amf6Th3MOiibsbm6NAC4qhG6AQAAriBWD6saVWukmgE1lZKTom1p25R7MtfVZQHAVYvQDQAAcIWxWCyK8o9SXFicLLJoW9o2JZ9I5grnAOAChG4AAIArlI+njxqHNVaUf5QOZx/WDe/doB1pO1xdFgBcVQjdAAAAVzA3i5tqBtRUo2qNdDzvuFq+1VKvrHmF73oDwGVC6AYAALgK+Hv5a8PfNujeVvfqHwv/oS4fdNH+zP2uLgsArniEbgAAgKuEr6evXun+in68+0ftTN+ppjOaas6GOTLGuLo0ALhiEboBAACuMrfWvVV//P0P9W7cW0O/Gqo+c/soJSfF1WUBwBWJ0A0AAHAVCvYO1pzec/RF/y+08sBKXfPGNZq/bb6rywKAKw6hGwAA4CrWJ66PNj+4WddHX6++n/bVkC+HKCM/w9VlAcAVg9ANAABwlYvwi9D8AfM1u9dsfbn9SzWd0VQ//vmjq8sCgCsCoRsAAACyWCwa0mKI/vj7H2pYraG6fNBFo74fpdyTua4uDQCqNEI3AAAA7GoH1dYPd/+gV7q9ond+f0ct32qpNQfXuLosAKiyCN0AAABw4GZx06jrRmnDAxsU7B2s69+7Xk/931MqLCp0dWkAUOUQugEAAFCqRmGNtGL4CiXelKgpK6bouneu0x9H/3B1WQBQpRC6AQAAcE4ebh56quNT+vXeX3Wy6KTazGyjF1a8oCJbkatLA4AqgdANAACAC2pZvaXW3b9O/7juH3r8x8d105yblHQsydVlAUClR+gGAABAmXh7eGtql6laNnSZDmUdUvM3m+utdW/JGOPq0gCg0iJ0AwAAoFw6xHTQxr9t1J1N79TfvvubenzUQ4eyDrm6LAColAjdAAAAKLcAa4De6vmWvhv8nTYe2aimM5rqk82fuLosAKh0CN0AAAC4aD0a9NDmBzcroX6CBs0bpAGfD1B6brqrywKASoPQDQAAgEsS6hOqj/t9rE/6faIf//xR18y4Rt/t/M7VZQFApUDoBgAAQIUYcM0A/fH3P9QyqqVu+/g2vfPbO64uCQBczsPVBQAAAODKUSOghr4b/J0+3/q5GlRr4OpyAMDlCN0AAACoUBaLRXc0ucPVZQBApcDp5QAAAAAAOAmhGwAAAAAAJyF0AwAAwCksiRZ9uf3LMvWduHSiWrzZ4rI+Z1WxvqdFGVFfuroMABeJ0A0AAOBC2YXZWp+8XruO7XJZDXsz9sqSaNGGIxvO22/p3qWyJFqUkZ9Rpu0mP5Ks7vW7X3qBTrS3xVDtbtu7wrfrzKBc4LNX63talBu4wSnbB1CxCN0AAAAulJabpgjfCGUXZquwqNDV5VSI4v2I8o+S1cPq4moAwLUI3QAAAC5SZCvS8fzjCvcLV5A1SOl56SX6ZORnaHPKZv2W/Jt2pO9Qem661iev1ynbKXuf7MJs7Ujbod+Sf9Omo5u0P3O/imxF9uV/pPyh5OxkDf9quAImB6j2tNp6e/3b9uV1/lNHktTyrZayJFp00+ybStSxN2Ovbp5zsyQpZEqILIkWDf1yqCTpptk3aeT3IzVm4RiFTQ1TwocJkkqe6n0w66AGzRuk0Cmh8vu3n9q83UZrDq4p9dgkHUtS3f/U1cjvR8oYU2qfXem71HFWR3k/56341+P1Q9IPJfoUeh/Qn637a0O3YG1ICNXutr1U4LNXknS44USlR89RZtRXWt/TovU9LTpRbekF1yuWFv2ettzURL/1sGpjl+raf83I08f71tjT+9C2j9b3tNgfS1JG5Ffa2rGVfuvhrT9uqavDDRNlLP97LfP9dmnH9R31Ww9vbbkpXllhJfcJQNXCLcMAAABc5Hj+cXl7eMvbw1uhPqE6mHVQUX5RslgskqSCUwX68/ifivCLUJhvmHJP5upg1kGHbRScKtCuY7tUI6CGYoJjdMp2Svsz9+tA1gHFBsfa+x3NPqo2NdroiQ5P6POtn+vv3/1dnWI6qVFYI/1676+69p1r9ePdP6pJRBN5uXuVqDU6MFrz+s9Tv0/7acfIHQq0BsrHw8e+fM7GOfp7m79rxfAVpe5rdmG2Os3upJoBNfX1oK8V5R+l35J/k83YSvTddHSTEj5M0IiWI/TcLc+Vuj2bsanvp30V6RepNfeuUWZBpsYsHOPQx1hOale7BPkdb69GK5ZLxkNHGjynXe26KX7pJkUmPap8/20q8sxS7IZZkiT3wtALrudmvJQaM0MHmoxVzW3PKyilu4o8MpUdenrfGy9fq00JEYr5fZaCUrtJxl2SdCJ0ufa0vEe1N78i/2MdVOCbpH3N75ck1dg5QUY2JbXpK8+CSDX+ZY2KPDJ14BrHfQJQ9RC6AQAAXCQtN02hPqGSpCBrkPaZfcouzFaANUCSlJqbKquHVbUCa0mSvD28lXcqT0eyj9i3kZydrFCfUEX6RdrbagfV1o70HaodVFtultMnNgZ5B+nBtg9Kkh6/4XFNWz1NS/YuUaOwRgr3C5ckVfOtpij/qFJrdXdzt9ca4RehYO9gh+UNQhtoapep59zXj/74SKk5qVp731r7duqH1i/Rb+WBlbrto9v0ZIcn9cj1j5xzez/++aO2p23XorsWqUZADUnSv2/9t7r/93/fIT9WY66MxaaYje/IotN/yIjZMEsbugcrO2ypAlO7ys3mI5utQJ4F/9vv9JofXnC95AbPKTLpEUXu+Yd9Pb/MtpIkz8LTx9PjVLDDdpMbJipq9z9V7eAQSZI1t65qbH9Wh+LHqcbOCToR/qPy/berwepF8io4vU81t/1bu9tV7u/FAzg/QjcAAIAL5J/KV87JHNULqSdJslgsCvEOUVpemj10F5wqkJ+nn8N6Zz/OO5WnvJN5OpZ3rMRzFJwqkI/n6dnoM2elLRaLovyjlJKTUmH707p66/Mu33Bkg1pWb2kP3KXZn7lfXT7ookm3TNKYdmPOu71tqdsUHRhtD9yS1L5We4c+eYEbVeC7Wxu6Bzi0G7d8FfgmnXPbF1rvpFeKTvocVmDareetsbTtZoeu0JEGk/63TUuRjHu+bO65yvPfJq+8aHvgliT/4+1L2xSAKoTQDQAA4AJpuWmSpE0pmxzaLbKodmBtubu5l2k7NptNYb5hivCLKLHszNPEi09ZP/N5Sju1+2L5efmdd/mZof9cwv3CVSOghj7e/LGGtxyuQGvgJdVU5JEt38zWqvPbf0ssK56Nvqj1zMVdFqnII1s1diQqOLlviWWWIu+L2iaAyo/QDQAAcJkZY5Sel65aAbVKBMuk40k6lndM4X7hsnpYlVWQ5bA852SOw2NfT1/ln8qXt8fFh7bicH7mxdcupV9pmkU20zu/v6NjecfOOdvt4+Gjbwd9qx4f9VDChwlafNdi+6z/2eLC43Qg64CSTySrekB1SdLqg6sd+vhmttLxGnPlWRgh91OlB3iLzUtSUbnX88qNVVbYTwpIv/kc2/WUsZTcbr7/DnnnljytXpJ8suNU6HNAJ63J8iw4vU/ZIatL9LPmxar1N6VfXA5A5cPVywEAAC6zzIJMFdmKFOYbJh9PH4d/wd7BSss7PQse7huu/FP5Oph1UPmn8nUs75jSc09f4bz4u8aR/pHKLszW/sz9yj2Zq/xT+crIz9D+zP1lrifCL0I+Hj5auHuhjmYfVWZ+Zqn9YoJiZJFF3+78Vqk5qcouzC7zcwxqOkhR/lHq/Ulvrdi/Qn8e/1Pzts7TqgOrHPr5efnpu8HfycPNQ93/2/2cz9G5bmc1rNZQQ74coo1HNmr5vuV68v+edOhT7dCd8igM0+62vXQidLkKfPboRLWl2t9ktAq9T1+Qzis3VnmBm5Tvt0OnvNJkLCfLtF6NHRN1tN5LSqnzivL9dik36DelxL5qf26v3FidCPtJJ61HdMrzuCSp+s6nlV7rfR1umKg8/y3K89+mYzU+0aFGT0mSAlI7yzunofa0HKLcwI06Ebpchxs77pMk5QT/qs03N1a+//YyH38ArkPoBgAAuMzSck9/b7u0U8hDvEOUezJXuSdzZfWwqm5IXWXkZ2hr6lal5qaquv/pGdDi08V9PX3VqFoj5Z/K1470HdqWtk2HTxyWp7tnmevxcPPQK91f0Vvr31KNl2uo1ye9Su1XM7CmEm9K1D9/+qciX4zUyO9Hlvk5vNy9tPiuxYrwi1CPj3qo6Yymen7F86UeA38vfy24c4GMjP7y0V+UU5hToo+bxU3zB8xX3qk8XfvOtbr3m3s16ZZJjn2KfNVo5c/yyqutP9v01Zab47S3+QgZ93z7DHbY/vtkzWmkbR3baGNCuLJDV5RpvWoHhyh6y3SlxL6hrTc10e5rb1O+3y77c9fa+pKywn7Qps7R2taxpSQpKDVB9X/9Vlnhi7WtY1ttv7GdjtadJq+8GEmSRW6qt3a+jFuett94rfY1v1c1tjvukyTZ3HNV4L9DNrf8Mh9/AK5jMee68eFl8PPPP+uFF17Q+vXrlZycrPnz56t379725UOHDtWcOXMc1klISNDChQvL/BxZWVkKCgpSZmamAgMv7XtBAIDT2rzdxtUlAFet5BPJSs1NVbPIZuVed93965xQUeXVhqEKqLLWVYHhqqxZ06Uz3Tk5OWrevLlef/31c/bp1q2bkpOT7f8+/vjjy1ghAACAa6XkpCinMEcFpwqUnpuuozlHVc23mqvLAgCUkUsvpNa9e3d1737++w5arVZFRZV+v0gAAIArXUFRgY5kH9Ep2yl5uXsp0i/ynPfSBgBUPpX+6uVLly5VRESEQkJCdMstt+i5555TtWr8dRcAAFwdogOjFR0Y7eoyAAAXqVKH7m7duqlv376qU6eOkpKS9MQTT6h79+5atWqV3N1Lv3dlQUGBCgoK7I+zsk7fZsNms8lmq7h7UQLA1az4qskAqpar7bOQhaEKqLKqwnBV1jG1UofugQMH2v+/adOmatasmerVq6elS5fq1ltvLXWdyZMnKzExsUR7amqq8vO5wiMAVIT6XqXfYxZA5ZaSkuLqEi6r+gxVQJVVFYarEydOlKlfpQ7dZ6tbt67CwsK0e/fuc4bu8ePHa+zYsfbHWVlZio6OVnh4OFcvB4AKsrtwt6tLAHARIiIiXF3CZbWboQqosqrCcOXt7V2mflUqdB88eFDp6emqXr36OftYrVZZrdYS7W5ubnJz47bkAFARjFx2t0kAl+Bq+yzkuhvjArhUVWG4KuuY6tLQnZ2drd1n/Alyz5492rBhg0JDQxUaGqrExET169dPUVFRSkpK0rhx41S/fn0lJCS4sGoAAAAAAMrGpaF73bp1uvnmm+2Pi08LHzJkiGbMmKFNmzZpzpw5ysjIUI0aNdS1a1c9++yzpc5kAwAAAABQ2bg0dN90000y5znvZ9GiRZexGgAAAAAAKlYVOFMeAAAAAICqidANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJB7l6Wyz2bRs2TItX75c+/btU25ursLDw9WyZUt17txZ0dHRzqoTAAAAAIAqp0wz3Xl5eXruuecUHR2tHj16aMGCBcrIyJC7u7t2796tCRMmqE6dOurRo4dWr17t7JoBAAAAAKgSyjTT3bBhQ7Vv314zZ85Uly5d5OnpWaLPvn379NFHH2ngwIF68skndd9991V4sQAAAAAAVCVlCt2LFy9WXFzcefvExMRo/PjxevTRR7V///4KKQ4AAAAAgKqsTKeXXyhwn8nT01P16tW76IIAAAAAALhSlPvq5QsXLtQvv/xif/z666+rRYsWGjx4sI4fP16hxQEAAAAAUJWVO3Q/9thjysrKkiT98ccfeuSRR9SjRw/t2bNHY8eOrfACAQAAAACoqsp1yzBJ2rNnj+Lj4yVJ8+bN02233aZ///vf+u2339SjR48KLxAAAAAAgKqq3DPdXl5eys3NlST9+OOP6tq1qyQpNDTUPgMOAAAAAAAuYqb7xhtv1NixY3XDDTfo119/1dy5cyVJO3fuVK1atSq8QAAAAAAAqqpyz3S/9tpr8vDw0Oeff64ZM2aoZs2akqQFCxaoW7duFV4gAAAAAABVVblnumvXrq1vv/22RPu0adMqpCAAAAAAAK4U5Q7dxVJSUpSSkiKbzebQ3qxZs0suCgAAAACAK0G5Q/f69es1ZMgQbdu2TcYYSZLFYpExRhaLRUVFRRVeJAAAAAAAVVG5Q/fw4cPVsGFDvfvuu4qMjJTFYnFGXQAAAAAAVHnlDt1//vmn5s2bp/r16zujHgAAAAAArhjlvnr5rbfeqo0bNzqjFgAAAAAArijlnul+5513NGTIEG3evFnXXHONPD09HZb/9a9/rbDiAAAAAACoysoduletWqUVK1ZowYIFJZZxITUAAAAAAP6n3KeXjxo1SnfddZeSk5Nls9kc/hG4AQAAAAD4n3KH7vT0dD388MOKjIx0Rj0AAAAAAFwxyh26+/btqyVLljijFgAAAAAArijl/k53w4YNNX78eP3yyy9q2rRpiQupjR49usKKAwAAAACgKruoq5f7+/tr2bJlWrZsmcMyi8VC6AYAAAAA4P8rd+jes2ePM+oAAAAAAOCKU+7vdAMAAAAAgLIpU+h+/vnnlZeXV6YNrlmzRt99990lFQUAAAAAwJWgTKF769atql27th588EEtWLBAqamp9mWnTp3Spk2b9MYbb+j666/XgAEDFBAQ4LSCAQAAAACoKsr0ne73339fGzdu1GuvvabBgwcrKytL7u7uslqtys3NlSS1bNlS9957r4YOHSpvb2+nFg0AAAAAQFVQ5gupNW/eXDNnztRbb72lTZs2ad++fcrLy1NYWJhatGihsLAwZ9YJAAAAAECVU+6rl7u5ualFixZq0aKFE8oBAAAAAODKwdXLAQAAAABwEkI3AAAAAABOQugGAAAAAMBJCN0AAAAAADjJRYfu3bt3a9GiRcrLy5MkGWMqrCgAAAAAAK4E5Q7d6enp6ty5sxo2bKgePXooOTlZkjRixAg98sgjFV4gAAAAAABVVblD98MPPywPDw/t379fvr6+9vYBAwZo4cKFFVocAAAAAABVWbnv07148WItWrRItWrVcmhv0KCB9u3bV2GFAQAAAABQ1ZV7pjsnJ8dhhrvYsWPHZLVaK6QoAAAAAACuBOUO3R06dND7779vf2yxWGSz2TR16lTdfPPNFVocAAAAAABVWblPL586dapuvfVWrVu3ToWFhRo3bpy2bNmiY8eOacWKFc6oEQAAAACAKqncM93XXHONdu7cqRtvvFG9evVSTk6O+vbtq99//1316tVzRo0AAAAAAFRJ5Z7plqSgoCA9+eSTFV0LAAAAAABXlIsK3fn5+dq0aZNSUlJks9kclv31r3+tkMIAAAAAAKjqyh26Fy5cqHvuuUdpaWklllksFhUVFVVIYQAAAAAAVHXl/k73qFGjdMcddyg5OVk2m83hH4EbAAAAAID/KXfoPnr0qMaOHavIyEhn1AMAAAAAwBWj3KH79ttv19KlS51QCgAAAAAAV5Zyf6f7tdde0x133KHly5eradOm8vT0dFg+evToCisOAAAAAICqrNyh++OPP9bixYvl7e2tpUuXymKx2JdZLBZCNwAAAAAA/1+5Q/eTTz6pxMRE/fOf/5SbW7nPTgcAAAAA4KpR7tRcWFioAQMGELgBAAAAALiAcifnIUOGaO7cuc6oBQAAAACAK0q5Ty8vKirS1KlTtWjRIjVr1qzEhdRefvnlMm/r559/1gsvvKD169crOTlZ8+fPV+/eve3LjTGaMGGCZs6cqYyMDN1www2aMWOGGjRoUN6yAQAAAAC47Mo90/3HH3+oZcuWcnNz0+bNm/X777/b/23YsKFc28rJyVHz5s31+uuvl7p86tSpeuWVV/Tmm29qzZo18vPzU0JCgvLz88tbNgAAAAAAl125Z7qXLFlSYU/evXt3de/evdRlxhhNnz5dTz31lHr16iVJev/99xUZGakvv/xSAwcOrLA6AAAAAABwhkp7NbQ9e/boyJEj6ty5s70tKChI1113nVatWuXCygAAAAAAKJsyzXT37dtXs2fPVmBgoPr27Xvevl988UWFFHbkyBFJUmRkpEN7ZGSkfVlpCgoKVFBQYH+clZUlSbLZbLLZbBVSGwBc7SyyuLoEABfhavssZGGoAqqsqjBclXVMLVPoDgoKkuX/j1pBQUEXX9VlMHnyZCUmJpZoT01N5bvgAFBB6nvVd3UJAC5CSkqKq0u4rOozVAFVVlUYrk6cOFGmfmUK3bNmzdIzzzyjRx99VLNmzbqkwsoqKipKknT06FFVr17d3n706FG1aNHinOuNHz9eY8eOtT/OyspSdHS0wsPDFRgY6LR6AeBqsrtwt6tLAHARIiIiXF3CZbWboQqosqrCcOXt7V2mfmW+kFpiYqL+9re/ydfX96KLKo86deooKipKP/30kz1kZ2Vlac2aNfr73/9+zvWsVqusVmuJdjc3N7m5VdqvsANAlWJkXF0CgItwtX0WMgxVQJVVFYarso6pZQ7dxgmjVnZ2tnaf8SfIPXv2aMOGDQoNDVXt2rU1ZswYPffcc2rQoIHq1Kmjf/3rX6pRo4bDvbwBAAAAAKisynXLMEsFX41i3bp1uvnmm+2Pi08LHzJkiGbPnq1x48YpJydH999/vzIyMnTjjTdq4cKFZZ7GBwAAAADAlSymjFPYbm5uDhdUO5djx45VSGEVJSsrS0FBQcrMzOQ73QBQQdq83cbVJQC4COvuX+fqEi6rNgxVQJW1rgoMV2XNmuWa6U5MTKz0Vy8HAAAAAKCyKFfoHjhw4FV31UsAAAAAAC5Wma8JV9Hf5wYAAAAA4EpX5tDtjKuXAwAAAABwJSvz6eU2m82ZdQAAAAAAcMWpArccBwAAAACgaiJ0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJ6nUoXvixImyWCwO/xo3buzqsgAAAAAAKBMPVxdwIU2aNNGPP/5of+zhUelLBgAAAABAUhUI3R4eHoqKinJ1GQAAAAAAlFulPr1cknbt2qUaNWqobt26uvPOO7V//35XlwQAAAAAQJlU6pnu6667TrNnz1ajRo2UnJysxMREdejQQZs3b1ZAQECp6xQUFKigoMD+OCsrS5Jks9lks9kuS90AcKWzyOLqEgBchKvts5CFoQqosqrCcFXWMbVSh+7u3bvb/79Zs2a67rrrFBMTo08//VQjRowodZ3JkycrMTGxRHtqaqry8/OdVisAXE3qe9V3dQkALkJKSoqrS7is6jNUAVVWVRiuTpw4UaZ+lTp0ny04OFgNGzbU7t27z9ln/PjxGjt2rP1xVlaWoqOjFR4ersDAwMtRJgBc8XYXnnscBlB5RUREuLqEy+o8HxkBVHJVYbjy9vYuU78qFbqzs7OVlJSku++++5x9rFarrFZriXY3Nze5uVX6r7ADQJVgZFxdAoCLcLV9FjIMVUCVVRWGq7KOqZV6Vx599FEtW7ZMe/fu1cqVK9WnTx+5u7tr0KBBri4NAAAAAIALqtQz3QcPHtSgQYOUnp6u8PBw3XjjjVq9erXCw8NdXRoAAAAAABdUqUP3J5984uoSAAAAAAC4aJX69HIAAAAAAKoyQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEkI3QAAAAAAOAmhGwAAAAAAJyF0AwAAAADgJIRuAAAAAACchNANAAAAAICTELoBAAAAAHASQjcAAAAAAE5C6AYAAAAAwEk8XF0AztCmjasrAHCx1q1zdQUAAACohJjpBgAAAADASQjdAAAAAAA4SZUI3a+//rpiY2Pl7e2t6667Tr/++qurSwIAAAAA4IIqfeieO3euxo4dqwkTJui3335T8+bNlZCQoJSUFFeXBgAAAADAeVX60P3yyy/rvvvu07BhwxQfH68333xTvr6+eu+991xdGgAAAAAA51WpQ3dhYaHWr1+vzp0729vc3NzUuXNnrVq1yoWVAQAAAABwYZX6lmFpaWkqKipSZGSkQ3tkZKS2b99e6joFBQUqKCiwP87MzJQkZWRkyGazOa/YilDZ6wNwbhkZrq7gsrLlMV4BVVHG1TZWMVQBVVZVGK6ysrIkScaY8/ar1KH7YkyePFmJiYkl2mNiYlxQDYCrRkiIqysAgAsKGcNYBaBqqEofrU6cOKGgoKBzLq/UoTssLEzu7u46evSoQ/vRo0cVFRVV6jrjx4/X2LFj7Y9tNpuOHTumatWqyWKxOLVe4FyysrIUHR2tAwcOKDAw0NXlAECpGKsAVBWMV6gMjDE6ceKEatSocd5+lTp0e3l5qXXr1vrpp5/Uu3dvSadD9E8//aSRI0eWuo7VapXVanVoCw4OdnKlQNkEBgbyiwFApcdYBaCqYLyCq51vhrtYpQ7dkjR27FgNGTJEbdq00bXXXqvp06crJydHw4YNc3VpAAAAAACcV6UP3QMGDFBqaqqefvppHTlyRC1atNDChQtLXFwNAAAAAIDKptKHbkkaOXLkOU8nB6oCq9WqCRMmlPjqAwBUJoxVAKoKxitUJRZzoeubAwAAAACAi+Lm6gIAAAAAALhSEboBAAAAAHASQjcAAAAAAE5C6AbOY/bs2dznHcBlddNNN2nMmDGuLuO8GBsBuNLSpUtlsViUkZFxzj4Wi0VffvnlZauprPbu3SuLxaINGza4uhRcRoRu4CoUGxur6dOnu7oMAJfZxYTl0saLAQMGaOfOnRVXGACXGDp0qCwWi55//nmH9i+//FIWi8VFVQFXHkI3AAAoFx8fH0VERLi6DAAVwNvbW1OmTNHx48crdLuFhYUVuj1Xu9L2B5cXoRtXFJvNpqlTp6p+/fqyWq2qXbu2Jk2aVOppSBs2bJDFYtHevXvtbbNnz1bt2rXl6+urPn36KD093WH7SUlJ6tWrlyIjI+Xv76+2bdvqxx9/LHN9BQUFevTRR1WzZk35+fnpuuuu09KlSyVJWVlZ8vHx0YIFCxzWmT9/vgICApSbmytJOnDggPr376/g4GCFhoaqV69eDvswdOhQ9e7dWy+++KKqV6+uatWq6aGHHtLJkyclnT51dd++fXr44YdlsVj4SzZQCdlsNo0bN06hoaGKiorSxIkT7cv279+vXr16yd/fX4GBgerfv7+OHj1qX75x40bdfPPNCggIUGBgoFq3bq1169Zp6dKlGjZsmDIzM+3v/TO3W5pzjRdnz5hPnDhRLVq00HvvvafatWvL399fDz74oIqKijR16lRFRUUpIiJCkyZNcth+RkaG7r33XoWHhyswMFC33HKLNm7ceMnHD0DZde7cWVFRUZo8efJ5+82bN09NmjSR1WpVbGysXnrpJYflsbGxevbZZ3XPPfcoMDBQ999/v32s+Pbbb9WoUSP5+vrq9ttvV25urubMmaPY2FiFhIRo9OjRKioqsm/rgw8+UJs2bRQQEKCoqCgNHjxYKSkpl7SfEyZMUPXq1bVp0yZJ0i+//KIOHTrIx8dH0dHRGj16tHJycsq0P4sWLVJcXJz8/f3VrVs3JScnOzzXO++8o7i4OHl7e6tx48Z64403Lql2XAEMcAUZN26cCQkJMbNnzza7d+82y5cvNzNnzjRLliwxkszx48ftfX///XcjyezZs8cYY8zq1auNm5ubmTJlitmxY4f5z3/+Y4KDg01QUJB9nQ0bNpg333zT/PHHH2bnzp3mqaeeMt7e3mbfvn1lqu/ee+81119/vfn555/N7t27zQsvvGCsVqvZuXOnMcaY22+/3dx1110O6/Tr18/eVlhYaOLi4szw4cPNpk2bzNatW83gwYNNo0aNTEFBgTHGmCFDhpjAwEDzt7/9zWzbts188803xtfX17z99tvGGGPS09NNrVq1zDPPPGOSk5NNcnLyxRxqAE7SqVMnExgYaCZOnGh27txp5syZYywWi1m8eLEpKioyLVq0MDfeeKNZt26dWb16tWndurXp1KmTff0mTZqYu+66y2zbts3s3LnTfPrpp2bDhg2moKDATJ8+3QQGBtrf+ydOnDhvLecaL2bNmuUwNk6YMMH4+/ub22+/3WzZssV8/fXXxsvLyyQkJJhRo0aZ7du3m/fee89IMqtXr7av17lzZ9OzZ0+zdu1as3PnTvPII4+YatWqmfT09Ao9pgBKN2TIENOrVy/zxRdfGG9vb3PgwAFjjDHz5883Z8aEdevWGTc3N/PMM8+YHTt2mFmzZhkfHx8za9Yse5+YmBgTGBhoXnzxRbN7926ze/duM2vWLOPp6Wm6dOlifvvtN7Ns2TJTrVo107VrV9O/f3+zZcsW88033xgvLy/zySef2Lf17rvvmu+//94kJSWZVatWmfbt25vu3bvbl5f2ue5sksz8+fONzWYzI0eONLGxsWbXrl3GGGN2795t/Pz8zLRp08zOnTvNihUrTMuWLc3QoUPLtD+dO3c2a9euNevXrzdxcXFm8ODB9vU+/PBDU716dTNv3jzz559/mnnz5pnQ0FAze/ZsY4wxe/bsMZLM77//flGvGaomQjeuGFlZWcZqtZqZM2eWWFaW0D1o0CDTo0cPh/UGDBjg8MGyNE2aNDGvvvrqBevbt2+fcXd3N4cOHXJov/XWW8348eONMad/yfn7+5ucnBxjjDGZmZnG29vbLFiwwBhjzAcffGAaNWpkbDabff2CggLj4+NjFi1aZIw5/Qs0JibGnDp1yt7njjvuMAMGDLA/jomJMdOmTbtgzQAuv06dOpkbb7zRoa1t27bm8ccfN4sXLzbu7u5m//799mVbtmwxksyvv/5qjDEmICDA/uHubGeH5bIobbwoLXT7+vqarKwse1tCQoKJjY01RUVF9rZGjRqZyZMnG2OMWb58uQkMDDT5+fkO265Xr5556623ylUjgItTHLqNMaZdu3Zm+PDhxpiSoXvw4MGmS5cuDus+9thjJj4+3v44JibG9O7d26HPrFmzjCSze/due9sDDzxgfH19Hf7ol5CQYB544IFz1rl27Vojyb5OWUP3Z599ZgYPHmzi4uLMwYMH7ctGjBhh7r//fof+y5cvN25ubiYvL69c+/P666+byMhI++N69eqZjz76yGG9Z5991rRv394YQ+i+WnF6Oa4Y27ZtU0FBgW699daLXv+6665zaGvfvr3D4+zsbD366KOKi4tTcHCw/P39tW3bNu3fv/+C2//jjz9UVFSkhg0byt/f3/5v2bJlSkpKkiT16NFDnp6e+vrrryWdPpUrMDBQnTt3lnT6tNHdu3crICDAvn5oaKjy8/Pt25CkJk2ayN3d3f64evXql3xaFoDLp1mzZg6Pi9/D27ZtU3R0tKKjo+3L4uPjFRwcrG3btkmSxo4dq3vvvVedO3fW888/7zA2OFNsbKwCAgLsjyMjIxUfHy83NzeHtuKxaOPGjcrOzla1atUcxsQ9e/ZctpoB/M+UKVM0Z84c+1hypm3btumGG25waLvhhhu0a9cuh9PC27RpU2JdX19f1atXz/44MjJSsbGx8vf3d2g783PK+vXr1bNnT9WuXVsBAQHq1KmTJJXp89aZHn74Ya1Zs0Y///yzatasaW/fuHGjZs+e7TD2JCQkyGazac+ePeXanzM/Y+Xk5CgpKUkjRoxw2PZzzz3HuHaV83B1AUBF8fHxOeey4g99xhh7W/F3nMvj0Ucf1Q8//KAXX3xR9evXl4+Pj26//fYyXVwjOztb7u7uWr9+vUMglmT/xePl5aXbb79dH330kQYOHKiPPvpIAwYMkIeHh30brVu31n//+98S2w8PD7f/v6enp8Myi8Uim81W7v0F4BqX8h6eOHGiBg8erO+++04LFizQhAkT9Mknn6hPnz7OKNWutJrPtx/Z2dmqXr26/boWZ+J2ZMDl17FjRyUkJGj8+PEaOnToRW3Dz8+vRFt5x4acnBwlJCQoISFB//3vfxUeHq79+/crISGh3Bcz69Kliz7++GMtWrRId955p709OztbDzzwgEaPHl1indq1a5d7f4o/X2ZnZ0uSZs6cWWIi5+zPfri6ELpxxWjQoIF8fHz0008/6d5773VYVhxIk5OTFRISIkkl7o8YFxenNWvWOLStXr3a4fGKFSs0dOhQ+4fX7Oxsh4uYnU/Lli1VVFSklJQUdejQ4Zz97rzzTnXp0kVbtmzR//3f/+m5556zL2vVqpXmzp2riIgIBQYGlul5S+Pl5eXwl2kAVUNcXJwOHDigAwcO2Ge7t27dqoyMDMXHx9v7NWzYUA0bNtTDDz+sQYMGadasWerTp89FvfedNV60atVKR44ckYeHh2JjYyt8+wDK7/nnn1eLFi3UqFEjh/a4uDitWLHCoW3FihVq2LBhhYfJ7du3Kz09Xc8//7x9nFu3bt1Fbeuvf/2revbsqcGDB8vd3V0DBw6UdHr82bp1q+rXr19hdUunZ+xr1KihP//80yHkA5xejiuGt7e3Hn/8cY0bN07vv/++kpKStHr1ar377ruqX7++oqOjNXHiRO3atUvfffddiatujh49WgsXLtSLL76oXbt26bXXXtPChQsd+jRo0EBffPGFNmzYoI0bN2rw4MFlnn1q2LCh7rzzTt1zzz364osvtGfPHv3666+aPHmyvvvuO3u/jh07KioqSnfeeafq1Knj8JfSO++8U2FhYerVq5eWL1+uPXv2aOnSpRo9erQOHjxY5mMVGxurn3/+WYcOHVJaWlqZ1wPgWp07d1bTpk1155136rffftOvv/6qe+65R506dVKbNm2Ul5enkSNHaunSpdq3b59WrFihtWvXKi4uTtLp9352drZ++uknpaWl2e+KcD7OGi86d+6s9u3bq3fv3lq8eLH27t2rlStX6sknn7zoD9gALk3x+PLKK684tD/yyCP66aef9Oyzz2rnzp2aM2eOXnvtNT366KMVXkPt2rXl5eWlV199VX/++ae+/vprPfvssxe9vT59+uiDDz7QsGHD9Pnnn0uSHn/8ca1cuVIjR47Uhg0btGvXLn311VcaOXLkJdefmJioyZMn65VXXtHOnTv1xx9/aNasWXr55ZcveduougjduKL861//0iOPPKKnn35acXFxGjBggFJSUuTp6amPP/5Y27dvV7NmzTRlyhSHGWRJateunWbOnKn//Oc/at68uRYvXqynnnrKoc/LL7+skJAQXX/99erZs6cSEhLUqlWrMtc3a9Ys3XPPPXrkkUfUqFEj9e7dW2vXrnU4lclisWjQoEHauHFjib+S+vr66ueff1bt2rXVt29fxcXFacSIEcrPzy/XzPczzzyjvXv3ql69eg6npQOo3CwWi7766iuFhISoY8eO6ty5s+rWrau5c+dKOn36Ynp6uu655x41bNhQ/fv3V/fu3ZWYmChJuv766/W3v/1NAwYMUHh4uKZOnXrB53TWeGGxWPT999+rY8eOGjZsmBo2bKiBAwdq3759ioyMrLDnAVA+zzzzTIkJhVatWunTTz/VJ598omuuuUZPP/20nnnmmYs+Df18wsPDNXv2bH322WeKj4/X888/rxdffPGStnn77bdrzpw5uvvuu/XFF1+oWbNmWrZsmXbu3KkOHTqoZcuWevrpp1WjRo1Lrv/ee+/VO++8o1mzZqlp06bq1KmTZs+erTp16lzytlF1WcyZX3IFAAAAAAAVhpluAAAAAACchNANVJDly5c73B7i7H8AUNkwbgEA4HycXg5UkLy8PB06dOicyyv6CpkAcKkYtwAAcD5CNwAAAAAATsLp5QAAAAAuKD09XREREdq7d+8lbWfFihVq2rSpPD091bt37wqpzZXatWunefPmuboMVGKEbkAlf4k445fB0qVLZbFYlJGRcUnbiY2N1fTp0yVJhYWFio2N5Z62wBWuoj7oVhZvvvmmevbs6eoyAJTTpEmT1KtXL8XGxl7SdsaOHasWLVpoz549mj17doXU5kpPPfWU/vnPf5a41RpQjNANqOQvkaryy8DLy0uPPvqoHn/8cVeXAsCJKuqDritYLBZ9+eWXDm3Dhw/Xb7/9puXLl7umKADllpubq3fffVcjRowodbkxRqdOnSrTtpKSknTLLbeoVq1aCg4Ovqh6CgsLL2o9Z+jevbtOnDihBQsWuLoUVFKEblz1SvslUhG/DC6XO++8U7/88ou2bNni6lIAOMGFPuhWhJMnT5Zoc+YHWi8vLw0ePFivvPKK054DQMX6/vvvZbVa1a5dO0n/O4NvwYIFat26taxWq3755RfZbDZNnjxZderUkY+Pj5o3b67PP/9ckrR3715ZLBalp6dr+PDhslgs9smNzZs3q3v37vL391dkZKTuvvtupaWl2Z//pptu0siRIzVmzBiFhYUpISGhzOuNHj1a48aNU2hoqKKiojRx4kSHfcvIyNADDzygyMhIeXt765prrtG3335rX/7LL7+oQ4cO8vHxUXR0tEaPHq2cnBz7cnd3d/Xo0UOffPJJhR5zXDkI3bjqnflL5Hy/DJYtW6Zrr71WVqtV1atX1z//+U+Hv+gWFBRo9OjRioiIkLe3t2688UatXbv2vM99oUE8JSVFPXv2lI+Pj+rUqaP//ve/JbYREhKiG264gYEeuEKd/UFXkrZs2aLbbrtNgYGBCggIUIcOHZSUlCRJstlseuaZZ1SrVi1ZrVa1aNFCCxcutK9bPM7NnTtXnTp1kre3t/773/9q6NCh6t27tyZNmqQaNWqoUaNGkqQDBw6of//+Cg4OVmhoqHr16lXiNPf33ntPTZo0sY+PI0eOlCT7zHyfPn1ksVgcZup79uypr7/+Wnl5eU44agAq2vLly9W6desS7f/85z/1/PPPa9u2bWrWrJkmT56s999/X2+++aa2bNmihx9+WHfddZeWLVum6OhoJScnKzAwUNOnT1dycrIGDBigjIwM3XLLLWrZsqXWrVunhQsX6ujRo+rfv7/Dc82ZM0deXl5asWKF3nzzzXKt5+fnpzVr1mjq1Kl65pln9MMPP0g6PWZ2795dK1as0IcffqitW7fq+eefl7u7u6TTEzHdunVTv379tGnTJs2dO1e//PKLfZwrdu2113L2Ds7NAFe50aNHm27duhljjDl16pRJTk42gYGBZvr06SY5Odnk5uaagwcPGl9fX/Pggw+abdu2mfnz55uwsDAzYcIEh+3UqFHDfP/992bLli1myJAhJiQkxKSnpxtjjFmyZImRZI4fP26MMWb37t3Gz8/PTJs2zezcudOsWLHCtGzZ0gwdOtS+ze7du5vmzZubVatWmXXr1pnrr7/e+Pj4mGnTpjnsw+OPP246derkzMMEwEXOHKOMMebgwYMmNDTU9O3b16xdu9bs2LHDvPfee2b79u3GGGNefvllExgYaD7++GOzfft2M27cOOPp6Wl27txpjDFmz549RpKJjY018+bNM3/++ac5fPiwGTJkiPH39zd333232bx5s9m8ebMpLCw0cXFxZvjw4WbTpk1m69atZvDgwaZRo0amoKDAGGPMG2+8Yby9vc306dPNjh07zK+//mofo1JSUowkM2vWLJOcnGxSUlLs+5GTk2Pc3NzMkiVLLs+BBHBJevXqZYYPH25/XPy55ssvv7S35efnG19fX7Ny5UqHdUeMGGEGDRpkfxwUFGRmzZplf/zss8+arl27Oqxz4MABI8ns2LHDGGNMp06dTMuWLR36lHW9G2+80aFP27ZtzeOPP26MMWbRokXGzc3N3v9sI0aMMPfff79D2/Lly42bm5vJy8uzt3311VfGzc3NFBUVlbodXN08XBn4gcpg3759qlGjhqTTpwdFRUXJYrEoKChIUVFRkqQ33nhD0dHReu2112SxWNS4cWMdPnxYjz/+uJ5++mnl5eVpxowZmj17trp37y5Jmjlzpn744Qe9++67euyxx0o87+TJk3XnnXdqzJgxkqQGDRrolVdeUadOnTRjxgzt379fCxYs0K+//qq2bdtKkt59913FxcWV2FaNGjW0b98+ZxweAC525hglSa+//rqCgoL0ySefyNPTU5LUsGFD+/IXX3xRjz/+uAYOHChJmjJlipYsWaLp06fr9ddft/cbM2aM+vbt6/Bcfn5+euedd+Tl5SVJ+vDDD2Wz2fTOO+/IYrFIkmbNmqXg4GAtXbpUXbt21XPPPadHHnlE//jHP+zbKR6zwsPDJUnBwcH28bSYr6+vgoKCGLuAKiIvL0/e3t4l2tu0aWP//927dys3N1ddunRx6FNYWKiWLVuec9sbN27UkiVL5O/vX2JZUlKSfYw7e6a9rOs1a9bMYVn16tWVkpIiSdqwYYNq1arlMI6e/RybNm1yONvQGCObzaY9e/bYP5f5+PjIZrOpoKBAPj4+59xXXJ0I3bjqneuXyJm2bdum9u3b2z90StINN9yg7OxsHTx4UBkZGTp58qRuuOEG+3JPT09de+212rZtW6nbvNAgvnPnTnl4eDj8gmncuHGp3zH38fFRbm5uWXcZQBVy9hi1YcMGdejQwR64z5SVlaXDhw87jEXS6fFq48aNDm1nflAu1rRpU3vglk6PU7t371ZAQIBDv/z8fCUlJSklJUWHDx/WrbfeelH7xtgFVB1hYWE6fvx4iXY/Pz/7/2dnZ0uSvvvuO9WsWdOhn9VqPee2s7Oz1bNnT02ZMqXEsurVq5f6XOVZ7+zx0mKx2K80fqGAnJ2drQceeECjR48usax27dr2/z927Jj8/PwI3CgVoRtXvXP9EnG2Cw3iO3fuLPO2jh07Zp9RAnBlOXuMqqgPdGd/eC2tLTs7W61bty71ehLh4eFyc7u0S8MwdgFVR8uWLfXhhx+et098fLysVqv279+vTp06lXnbrVq10rx58xQbGysPj7LHk4td70zNmjXTwYMHtXPnzlJnu1u1aqWtW7eqfv36593O5s2bzzubj6sbF1LDVa9ly5baunXrefvExcVp1apVMsbY21asWKGAgADVqlVL9erVs1/Yo9jJkye1du1axcfHl7rNMwfxs/95eXmpcePGOnXqlNavX29fZ8eOHaXe55uBHrhynT1GNWvWTMuXLy/1iuOBgYGqUaOGw1gknR6vzjUWnU+rVq20a9cuRURElBingoKCFBAQoNjYWP3000/n3Ianp6eKiopKtCclJSk/P5+xC6giEhIStGXLlvNOVAQEBOjRRx/Vww8/rDlz5igpKUm//fabXn31Vc2ZM+ec6z300EM6duyYBg0apLVr1yopKUmLFi3SsGHDSh0/LnW9M3Xq1EkdO3ZUv3799MMPP2jPnj1asGCB/QKUjz/+uFauXKmRI0dqw4YN2rVrl7766qsSF1Jbvny5unbtWqbnxNWH0I2rXll+iTz44IM6cOCARo0ape3bt+urr77ShAkTNHbsWLm5ucnPz09///vf9dhjj2nhwoXaunWr7rvvPuXm5p7zNj8XGsQbNWqkbt266YEHHtCaNWu0fv163XvvvaXOcjHQA1eus8eokSNHKisrSwMHDtS6deu0a9cuffDBB9qxY4ck6bHHHtOUKVM0d+5c7dixQ//85z+1YcMGh+9cl9Wdd96psLAw9erVS8uXL9eePXu0dOlSjR49WgcPHpQkTZw4US+99JJeeeUV7dq1y/4Bu1hxKD9y5IjDOLt8+XLVrVtX9erVu5TDA+Ayadq0qVq1aqVPP/30vP2effZZ/etf/9LkyZMVFxenbt266bvvvlOdOnXOuU7xHwuLiorUtWtXNW3aVGPGjFFwcPB5z6i52PXONm/ePLVt21aDBg1SfHy8xo0bZw/tzZo107Jly7Rz50516NBBLVu21NNPP+1wrY1Dhw5p5cqVGjZsWJmfE1cZF1/IDagUrr32WvPmm2/aH599VU1jjFm6dKlp27at8fLyMlFRUebxxx83J0+etC/Py8szo0aNMmFhYcZqtZobbrjB/Prrr/blZ1+93Bhjfv31V9OlSxfj7+9v/Pz8TLNmzcykSZPsy5OTk81f/vIXY7VaTe3atc37779vYmJiHK5evnLlShMcHGxyc3Mr7oAAqFTOHqM2btxounbtanx9fU1AQIDp0KGDSUpKMsYYU1RUZCZOnGhq1qxpPD09TfPmzc2CBQvs6xZfvfz33393eI4hQ4aYXr16lXju5ORkc88999jHtrp165r77rvPZGZm2vu8+eabplGjRsbT09NUr17djBo1yr7s66+/NvXr1zceHh4mJibG3t61a1czefLkSzwyAC6nb7/91sTFxXGF7rOMGzfO3Hfffa4uA5WYxZgzzpcFrlLfffedHnvsMW3evPmSv6N4uQ0YMEDNmzfXE0884epSADhJVR6jSrNlyxbdcsst2rlzp4KCglxdDoBymD59uvr166fo6GhXl1JpvPTSS7rrrrsUGRnp6lJQSRG6gf+vKv4SKSws1NSpU/XII49wtUzgClcVx6hz+fHHH1VUVKSEhARXlwIAgNMRugEAAAAAcJKqf44aAAAAAACVFKEbAAAAAAAnIXQDAAAAAOAkhG4AAAAAAJyE0A0AAAAAgJMQugEAAAAAcBJCNwAAAAAATkLoBgAAAADASQjdAAAAAAA4yf8DEjWukLxcTxgAAAAASUVORK5CYII=", + "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 +}