diff --git a/.env.example b/.env.example
index 2150e6d9..b31c503f 100644
--- a/.env.example
+++ b/.env.example
@@ -9,7 +9,7 @@ OPENAI_API_KEY=sk-...
 ANTHROPIC_API_KEY=sk-ant-api03-...
 
 # Google Gemini
-GEMINI_API_KEY=...
+GEMINI_API_KEY=
 
 # DeepSeek
 DEEPSEEK_API_KEY=sk-...
diff --git a/.gitignore b/.gitignore
index 3956bf85..a6aab0db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,5 @@ cache/*
 !results/timing/
 .env
 _build_cache/
+uv.lock
+CLAUDE.md
\ No newline at end of file
diff --git a/EVAL.md b/EVAL.md
new file mode 100644
index 00000000..faebda6f
--- /dev/null
+++ b/EVAL.md
@@ -0,0 +1,57 @@
+# Evaluation
+[WIP] More notes on Benchmarking Guide
+To be updated more comprehensively with the benchmarking guide (ongoing PRs) & blog that we have been working on this quarter.
+
+You should be **extra CAREFUL!** , be always paranoid about suspiciously good results — kernel engineers and existing compilers are already pretty good, so a >2x speedup for anything is highly unlikely. 
+
+
+> “if you beat cudnn by more than 10%, think again” -- 
+from [itsclivetime](https://x.com/itsclivetime/status/1992155951630307633?s=46)
+
+
+If the model can reward hack, it will find ways to reward hack! This can especially happen during RL training or evolutionary search.
+
+Check out resources here:
+- KernelBench [v0.1 Release](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) 
+- Cognition and Stanford's [Kevin](https://arxiv.org/abs/2507.11948) project on various hacking behaviors observed in RL training
+- Jiwei Li's awesome [blogpost 1](https://deep-reinforce.com/defense_kernel_hack.html) and [blogpost 2](https://deep-reinforce.com/correctness_check.html) on Hacks and Defenses in Automatic GPU Kernel Generations
+
+Our ongoing blogpost and PRs try to systematize and list out these behaviors and provide tests, detection, and mitigation toolings.
+
+**Disclaimer**: KernelBench is an open-source evaluation framework. Due to limited bandwidth, the KernelBench team does not inspect, validate, or endorse any third-party kernels or reported results. Users are welcome to use the software infrastructure for evaluation, but should independently verify all results.
+
+
+## Methodology
+More on that coming.
+
+To ensure **consistency and reproducibility**, we recommend using `modal` and we have provided / are adding more various modal cloud functions to standardize the evaluation environment.
+
+### Correctness
+More coming. We also want to highlight community effort such as [BackendBench](https://www.youtube.com/watch?v=BTfjdyZOKww).
+
+### Performance
+We highly recommend watching this [lecture](https://www.youtube.com/watch?v=1i7dxoAfKOU) from GPU mode on kernel profiling. 
+
+We have (and continue to) implement various approaches to conduct kernel timing to understand the tradeoffs.
+
+Check out `timing.py` to see available timing methods and `src/unit_tests/test_eval_timing.py` to test out various timing methods (including leveraging `cuda_event` marker, Triton `do_bench`, `host_time` E2E time). @palic and team is working on a blogpost explaining the different tradeoffs soon. 
+
+### Profiling
+We have experimental profiling support leveraging NVIDIA NCU in `profile.py`.
+
+### Checkers
+There are potentially many ways model might reward hack and we would like to catch the known ways through checkers [experimental and WIP]. We start with `kernel_static_checker.py`, which is a regex-based checker on the genenrated code against set of rules. We plan to add AST-based, LM-as-a-judge, and more runtime checks in the future. We welcome suggestions and contributions here.
+
+### Unit Tests with Adversarial Examples
+We've included some unit tests for the eval script in `src/unit_tests/test_eval_adversarial.py`. These tests run adversarial kernels (see `src/unit_tests/test_kernels/`) that contain examples of reward hacking that we've seen from LLMs and ensures that the eval script catches them, either by failing their correctness checks or flagging them for excessive speedups. Examples include:
+- Reusing computations cached during the PyTorch reference
+- Modifying inputs to cheat correctness checks
+- Moving computation to a non-default CUDA stream
+
+We will continue to add more tests as we explore additional adversarial scenarios.
+
+
+Note: KernelBench is an ongoing open-source effort — please help us with issues and PRs!
+
+
+Shoutout to @bkal01, @palic, @miru_why, @ngc92, @itsclivetime, for their suggestions and feedback. 
\ No newline at end of file
diff --git a/KernelBench/changelog/v0.1 b/KernelBench/changelog/v0.1
new file mode 100644
index 00000000..62c0f938
--- /dev/null
+++ b/KernelBench/changelog/v0.1
@@ -0,0 +1,2 @@
+Please refer to KernelBench v0.1 release note
+https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/ 
\ No newline at end of file
diff --git a/KernelBench/changelog/v0.2 b/KernelBench/changelog/v0.2
new file mode 100644
index 00000000..a36b9de1
--- /dev/null
+++ b/KernelBench/changelog/v0.2
@@ -0,0 +1,5 @@
+Ongoing Effort
+
+Updated Level1/12_Matmul_with_diagonal_matrices_.py - More efficient PyTorch implementation
+Updated Level1/92_cumsum_exclusive.py - Fix exclusive cumsum implementation
+Updated Level1/97_ScaledDotProductAttention.py - remove device and precision definition setting, harness should handle it
\ No newline at end of file
diff --git a/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py b/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py
index 41369a3b..0e36c275 100644
--- a/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py
+++ b/KernelBench/level1/12_Matmul_with_diagonal_matrices_.py
@@ -20,7 +20,9 @@ def forward(self, A, B):
         Returns:
             torch.Tensor: The result of the matrix multiplication. Shape: (N, M).
         """
-        return torch.diag(A) @ B
+        # Logically equivalent to torch.diag(A) @ B 
+        # more efficient as no need to materialize a full N×N matrix
+        return A.unsqueeze(1) * B
 
 M = 4096
 N = 4096
diff --git a/KernelBench/level1/92_cumsum_exclusive.py b/KernelBench/level1/92_cumsum_exclusive.py
index 0c819da7..e68dacad 100644
--- a/KernelBench/level1/92_cumsum_exclusive.py
+++ b/KernelBench/level1/92_cumsum_exclusive.py
@@ -14,8 +14,8 @@ def __init__(self, dim):
         self.dim = dim
 
     def forward(self, x):
-        exclusive_cumsum = torch.cat((torch.zeros_like(x.select(self.dim, 0).unsqueeze(self.dim)), x), dim=self.dim)[:-1]
-        return torch.cumsum(exclusive_cumsum, dim=self.dim)
+        cumsum = torch.cumsum(x.narrow(dim=self.dim, start=0, length=x.size(self.dim)-1), dim=self.dim)
+        return torch.cat((torch.zeros_like(x.select(self.dim, 0).unsqueeze(self.dim)), cumsum), dim=self.dim)
 
 batch_size = 32768
 input_shape = (32768,)
diff --git a/KernelBench/level1/97_ScaledDotProductAttention.py b/KernelBench/level1/97_ScaledDotProductAttention.py
index feff1490..ba4bd02b 100644
--- a/KernelBench/level1/97_ScaledDotProductAttention.py
+++ b/KernelBench/level1/97_ScaledDotProductAttention.py
@@ -15,9 +15,9 @@ def forward(self, Q: torch.Tensor, K: torch.Tensor, V: torch.Tensor) -> torch.Te
 embedding_dimension = 1024
 
 def get_inputs():
-    Q = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension, device='cuda', dtype=torch.float16)
-    K = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension, device='cuda', dtype=torch.float16)
-    V = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension, device='cuda', dtype=torch.float16)
+    Q = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension)
+    K = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension)
+    V = torch.rand(batch_size, num_heads, sequence_length, embedding_dimension)
     return [Q, K, V]
 
 def get_init_inputs():
diff --git a/README.md b/README.md
index 91e24d8d..36e2edfe 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # KernelBench: Can LLMs Write Efficient GPU Kernels? [ICML '25]
-A benchmark for evaluating LLMs' ability to generate efficient GPU kernels
+A benchmark and environment for evaluating LLMs' ability to generate efficient GPU kernels
+
+Specifically we task LLM to generate correct and efficient CUDA / DSL kernels for PyTorch programs on a target GPU.
 
 [arXiv](https://arxiv.org/html/2502.10517v1) | [blog post](https://scalingintelligence.stanford.edu/blogs/kernelbench/) | [HuggingFace Dataset](https://huggingface.co/datasets/ScalingIntelligence/KernelBench) 
 
@@ -16,7 +18,7 @@ The Huggingface [dataset](https://huggingface.co/datasets/ScalingIntelligence/Ke
 This repo provides core functionality for KernelBench and an easy-to-use set of scripts for evaluation. It is not intended to provide complex agentic scaffolds that solve this task; we recommend cloning and modifying this repo for your experiment, or using it as a git submodule.
 
 ## 👋 Task Description
-We structure the problem for LLM to transpile operators described in PyTorch to CUDA kernels, at whatever level of granularity it desires to.
+We structure the problem for LLMs to transpile operators described in PyTorch to CUDA kernels, at whatever level of granularity they desire.
 ![KernelBenchMascot](./assets/figures/KernelBenchWorkFlow.png)
 
 We construct KernelBench to have 4 Levels of categories:
@@ -29,15 +31,15 @@ We construct KernelBench to have 4 Levels of categories:
 - **Level 4 🤗**:  Level Hugging Face 
     Optimize whole model architectures from HuggingFace
 
-We are actively extending KernelBench to other DSLs beyond `cuda` as well (see below).
+We are actively extending KernelBench to other DSLs beyond `cuda` as well (see below), as well as AMD GPU support.
 
 ## ⚖️ Evaluation
 #### Methodology
 To evaluate model-generated kernels, we need to check if they:
-- **is correct ✅**: check against reference torch operators `n_correctness` times on randomized inputs.
-- **is performant ⏱️**: compare against reference torch operators `n_trial` times to measure speedup between runtimes.
+- **are correct ✅**: check against reference torch operators `n_correctness` times on randomized inputs.
+- **are performant ⏱️**: compare against reference torch operators `n_trial` times to measure speedup between runtimes.
 
-Check out `src/eval.py` for details on how we implement correctness check and timing. 
+Check out `src/eval.py` for details on how we implement correctness check and timing and `EVAL.md` for notes on evaluation and benchmarking guidelines [WIP].
 
 We provide a convenient script `scripts/run_and_check.py` to evaluate one single sample source code against a reference source code, check correctness and compute speedup. You can use this to evaluate a kernel either locally or remotely by setting `eval_mode=local` or `eval_mode=modal`.
 
@@ -66,27 +68,43 @@ We organize the repo into the following structure:
 KernelBench/
 ├── assets/
 ├── KernelBench/ # Benchmark dataset files
-├── src/ # KernelBench logic code
+├── src/kernelbench/ # KernelBench logic code
 │   ├── unit_tests/  
 │   ├── prompts/
 │   ├── ....
 ├── scripts/ # helpful scripts to run the benchmark
 ├── results/ # baseline times across hardware 
 ├── runs/ # where your runs will be stored
+├── notebooks/ # example notebooks for analysis
+├── pyproject.toml # Project configuration and dependencies
 ```
 
 ## 🔧 Set up
-```
-conda create --name kernel-bench python=3.10
-conda activate kernel-bench
-pip install -r requirements.txt
-pip install -e . 
+
+We have transitioned to using `pyproject.toml` and `uv` for dependency management. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already
+
+```bash
+# Install base dependencies (works without a local GPU)
+uv sync
+
+# Install with AMD ROCm backend (ROCm>=7.1 is required)
+uv add torch --index pytorch=https://download.pytorch.org/whl/rocm7.1
+
+# Install with GPU dependencies (for local GPU evaluation)
+uv sync --extra gpu
+
+# Run commands with uv (which invoke the right env)
+uv run python scripts/<script_name>.py ...
 ```
 
+For AMD GPU aka ROCm backend (ROCm>=7.1), please add `uv remove torch && uv add torch --index pytorch=https://download.pytorch.org/whl/rocm7.1` for RoCm compatible PyTorch to configure your dependencies. Running in a docker image is recommended for this due to complexity of ROCm setup.
+
+You can still use `conda (python=3.10)` to create your environment and install dependencies with `requirements.txt`.
+
 We use `litellm` for API calls. Please set your keys by creating a `.env` following our `.env.example`.
 
-Running and profiling kernels require a GPU. 
-If you don't have GPU available locally, you can set up [Modal](https://modal.com/). Set up your modal token after creating an account by running `modal token new`. Then, use the `generate_and_eval_single_sample_modal.py` script.  
+Running and profiling kernels require a GPU.
+If you don't have a GPU available locally, you can set up [Modal](https://modal.com/) for cloud serverless GPU evaluation. Set up your modal token after creating an account by running `modal token new`. Then, use the `generate_and_eval_single_sample_modal.py` script.
 
 You can also try out our [tutorial notebook](https://bit.ly/kernelbench-neurips-colab) (also in notebooks/tutorial.ipynb) with Google Colab.
 
@@ -94,52 +112,70 @@ You can also try out our [tutorial notebook](https://bit.ly/kernelbench-neurips-
 ### Run on a single problem 
 It is easier to get started with a single problem. This will fetch the problem, generate a sample, and evaluate the sample. 
 
-```
-# for example, run level 2 problem 40 from huggingface
+```bash
+# for example, run level 2 problem 40 from huggingface and use google gemini 2.5 flash for generation
 
-python3 scripts/generate_and_eval_single_sample.py dataset_src="huggingface" level=2 problem_id=40
+uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=2 problem_id=40 server_type=google model_name=gemini/gemini-2.5-flash
 
 # dataset_src could be "local" or "huggingface"
-# add .verbose_logging for more visbility
+# add .verbose_logging for more visibility
 ```
 
 **What you might need to modify**
-* **`gpu_arch`** - Depend on your GPU, you might need to adjust the `gpu_arch` argument to reflect your hardware.
+* **`gpu_arch`** - Depending on your GPU, you might need to adjust the `gpu_arch` argument to reflect your hardware.
 * **`precision`** - You can specify the precision of tensor by `precision=fp32`. Currently all of our reported results are `fp32` but we added support for `fp16` & `bf16`.
-*  **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. Simply specify `backend=triton`. For now we support DSLs: `cuda`, `triton`, `cute`, `tilelang`.
+*  **`backend`** - We are also supporting other GPU programming languages beyond `cuda`. For example, simply specify `backend=triton` or `backend=hip`. For now we support NVIDIA GPUs with programming frameworks and DSLs: `cuda`, `triton`, `cute`, `tilelang`, `thunderkittens`. 
 
-Check the config fields for comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`.
+Note for AMD GPUs: Use `hip` backend, `gpu_arch` currently supported: `gfx942`, `gfx950`.
+
+Note on setting up ThunderKittens (TK) locally: to use `backend=thunderkittens`, you need to git clone the ThunderKittens repo and set the following environment variable to point to your local ThunderKittens directory, `export THUNDERKITTENS_ROOT=<PATH to ThunderKittens folder>`, and all ThunderKitten programs as shown in the [example](src/kernelbench/prompts/model_new_ex_add_thunderkittens.py), should contain `tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens")`, which enable the kernel to include the right TK primitives. In addition, we only support BF16 for TK right now.
+
+Check the config fields for a comprehensive set of options. Note we provide the model with a one-shot example by default along with the minimum set of info; you can check out other prompt settings or construct your own in `src/prompt_constructor_toml.py`.
 
 ### Run on all problems 
 
-```
+```bash
 # 1. Generate responses and store kernels locally to runs/{run_name} directory
-python3 scripts/generate_samples.py run_name=test_hf_level_1 dataset_src=huggingface level=1 num_workers=50 server_type=deepseek model_name=deepseek-chat temperature=0
+uv run python scripts/generate_samples.py run_name=test_hf_level_1 dataset_src=huggingface level=1 num_workers=50 server_type=deepseek model_name=deepseek-chat temperature=0
 
 # 2. Evaluate on all generated kernels in runs/{run_name} directory
-python3 scripts/eval_from_generations.py run_name=test_hf_level_1 dataset_src=local level=1 num_gpu_devices=8 timeout=300
+uv run python scripts/eval_from_generations.py run_name=test_hf_level_1 dataset_src=local level=1 num_gpu_devices=8 timeout=300
 
-# If you like to speedup evaluation, you can use parallelize compilation on CPUs before getting to evluation on GPUs
+# If you like to speedup evaluation, you can use parallelize compilation on CPUs before getting to evaluation on GPUs
 # add build_cache=True and num_cpu_workers=<num_cpu_workers> to the command
 ```
 ### Analyze the eval results to compute Benchmark Performance
 We provide `scripts/benchmark_eval_analysis.py` to analyze the eval results to compute success rate, timing metric, and overall benchmark performance  `fast_p`. 
 
-```
-python3 scripts/benchmark_eval_analysis.py run_name=test_hf_level_1 level=1 hardware=L40S_matx3 baseline=baseline_time_torch
+```bash
+uv run python scripts/benchmark_eval_analysis.py run_name=test_hf_level_1 level=1 hardware=L40S_matx3 baseline=baseline_time_torch
 ```
 If you are using a different hardware, you can generate the baseline time with `scripts/generate_baseline_time.py` script.
-We provide some reference baseline times a variety of NVIDIA GPUs across generations in `results/timing`, but we recommend you to generate your own baseline time for more accurate results (cluster power, software version, all affects timing result). See `results/timing/README.md` for more details.
-
-### Multi-Turn Framework
-We have also releaed the test-time framework [Caesar](https://github.com/ScalingIntelligence/caesar) that are used in the multi-turn / iterative refinement experiments in our paper. You can use or modify this framework for high-throughput test-time scaling (both sequential and parallel) targeting KernelBench problems. 
+We provide some reference baseline times for a variety of NVIDIA GPUs across generations in `results/timing`, but we recommend you generate your own baseline time for more accurate results (cluster power, software version, all affect timing results). See `results/timing/README.md` for more details.
 
 ## 🛣️ Upcoming Roadmap
-Check out our [roadmap](https://github.com/ScalingIntelligence/KernelBench/issues/74) for what we plan to add as features. We welcome community contirbutions in these directions. 
+Check out our [roadmap](https://github.com/ScalingIntelligence/KernelBench/issues/74) for what we plan to add as features. We welcome community contributions and discussions in these directions. 
+
+## 🔌 Integration 
+You can also use KernelBench as a library for your projects, for example: `from kernelbench import timing`, `from kernelbench import eval as kb_eval`, or `from kernelbench.utils import set_gpu_arch`.
+
+- **Adapter with Harbor** — We are integrating with [Harbor](https://harborframework.com/docs) to enable higher-throughput eval and richer evaluation of agentic performance beyond model pass@1/k. *([Ongoing](https://github.com/harbor-framework/harbor/pull/999))*
+
+- **Multi-Turn / Test-Time Scaling** — [Caesar](https://github.com/ScalingIntelligence/caesar) is our throughput-oriented multi-turn inference engine (ICML '25), used for the iterative refinement experiments in the paper. It runs generation trajectories in batch, feeding back correctness, runtime, and profiling signals across turns for sequential test-time scaling.
+
+- **Reinforcement Learning (RLVR)** — [kernelbench-tinker](https://github.com/ScalingIntelligence/kernelbench-tinker) is an end-to-end integration with Thinking Machines Lab's [Tinker RL library](https://github.com/thinking-machines-lab/tinker). The pipeline has the policy model generate kernels, evaluates them on cloud GPUs via Modal, and converts results into RL rewards — a minimal playground for experimenting with RLVR on GPU kernel optimization.
+
+- **Evolutionary Search** — Evolutionary search like AlphaEvolve has shown promise for discovering innovative solutions for optimization problems. We are working on an integration for [OpenEvolve](https://github.com/algorithmicsuperintelligence/openevolve). Releasing soon.
+
+- **Roofline / Max Speedup Analysis** —   *(Experimental, WIP)* [simple-torchroofline](https://github.com/simonguozirui/simple-torchroofline) provides analytical roofline analysis for PyTorch programs, estimating the speed-of-light (SoL) compute and memory bounds for a target GPU — no hardware required. Combined with hardware counter-based profiling for empirical roofline analysis, this helps sanity-check whether a reported speedup is physically realistic. 
+
 
 ## 🔍 Known Usage
 Since release, we have gotten a lot of interest from researchers, research labs, and companies that use KernelBench to explore this direction. We have documented [known usage](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub) of KernelBench and related efforts towards automated kernel generations. If you are using KernelBench, we love to hear more about it!
 
+Disclaimer: KernelBench is designed as an **open-source** evaluation framework and toolkit. The KernelBench team does not review, validate, or endorse individual kernels or reported results. Users are responsible for independently verifying any results obtained using the framework. Please check out `EVAL.md` for more guidance on benchmarking and evaluating kernels.
+
+
 ## 🪪 License
 MIT. Check `LICENSE.md` for more details.
 
@@ -156,3 +192,5 @@ MIT. Check `LICENSE.md` for more details.
       url={https://arxiv.org/abs/2502.10517}, 
 }
 ```
+
+We are grateful for the support from [GPU Mode](https://gpu-mode.github.io/popcorn/), [PyTorch](https://pytorch.org/), [Modal Labs](https://modal.com/blog/accelerating-ai-research-case-study) and the broader open-source community that made this project possible.
diff --git a/notebooks/benchmarking.ipynb b/notebooks/benchmarking.ipynb
new file mode 100644
index 00000000..3b66e8f5
--- /dev/null
+++ b/notebooks/benchmarking.ipynb
@@ -0,0 +1,1414 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/gist/PaliC/084fb5b4ee9ce904bc7791ad4aa51e75/benchmarking_guide.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_PCU0gUyzX2c"
+   },
+   "source": [
+    "# A Practical Guide to GPU Benchmarking\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:** Use median to filter out jitter and outliers.\n",
+    "6.  **Wait for side-streams:** Ensure all CUDA streams finish before stopping the clock. (Launching work in another stream is a very common reward hack, so waiting for all streams is essential for evaluating LLM-generated code. If you aren't using a LLM to generate your kernel, this almost certainly isn't something you need to worry about.)\n",
+    "\n",
+    "*Pro-Tip:* Off-the-shelf solutions like [Triton's do_bench](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html) handle most of this. KernelBench also provides a [timing module](https://github.com/ScalingIntelligence/KernelBench/blob/main/src/kernelbench/timing.py) implementing these best practices.\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 will 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",
+    "-----\n",
+    "\n",
+    "Whether you're using an LLM to write GPU kernels or hand-optimizing CUDA, you'll eventually ask: **\"How fast is this thing?\"**\n",
+    "\n",
+    "This notebook is based on [this excellent guide](https://www.youtube.com/watch?v=1i7dxoAfKOU) from the **GPU MODE** community. We'll build a benchmarking harness from scratch, make every common mistake, and iterate toward a robust solution.\n",
+    "\n",
+    "Let's learn by doing it wrong first."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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": "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",
+    "\n",
+    "import sys\n",
+    "import importlib.util\n",
+    "import os\n",
+    "sys.path.insert(0, '..')  # Add parent directory to path for imports\n",
+    "\n",
+    "path_to_timing = os.path.abspath(\"../src/kernelbench/timing.py\")\n",
+    "\n",
+    "spec = importlib.util.spec_from_file_location(\"timing\", path_to_timing)\n",
+    "timing = importlib.util.module_from_spec(spec)\n",
+    "spec.loader.exec_module(timing)\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",
+    "from src.kernelbench import timing\n",
+    "from src.kernelbench.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": [
+    "## Setup: A Matrix Multiplication\n",
+    "\n",
+    "We need a workload to benchmark. Matrix multiplication is ideal: `torch.matmul` calls cuBLAS under the hood, and is easy to understand."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "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": 12,
+   "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.3312 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": [
+    "Less than 1ms for an 8192² matmul? That's over 1 trillion FLOPs. Something's wrong.[¹](#footnote-1)\n",
+    "\n",
+    "GPUs are **asynchronous**. When you call `torch.matmul`, the CPU doesn't do the math instead it queues a \"launch kernel\" command and moves on immediately. We didn't measure the matrix multiplication; we measured how long it took Python to place an order.\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",
+    "---\n",
+    "\n",
+    "<a id=\"footnote-1\"></a>\n",
+    "¹ **Why impossible?** The [H200](https://www.nvidia.com/en-us/data-center/h200/) peaks at 989 TFLOPS for TF32. 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": 13,
+   "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.5464 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": 14,
+   "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.8027 ms\n",
+      "Run 1: 21.4768 ms\n",
+      "Run 2: 21.5505 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 slower. The first execution triggers one-time initialization: memory allocation, cuBLAS/cuDNN workspace setup, lazy kernel loading, JIT compilation, etc. This \"cold start\" penalty shouldn't be included in your performance metrics.\n",
+    "\n",
+    "**The Fix:** Run the kernel a few times first (**warmup**) to settle the system state before measuring."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "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.4893 ms\n",
+      "Run 1: 21.4485 ms\n",
+      "Run 2: 21.4284 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "def benchmark_warmup(func, *args, warmup_iters=3, 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",
+    "A single sample isn't reliable. Operating systems are noisy: background processes interrupt the CPU, GPU clocks fluctuate with temperature. One measurement is anecdotal, not statistical.\n",
+    "\n",
+    "Let's run the benchmark 100 times and visualize the jitter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "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": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean:   21.4580 ms\n",
+      "Median: 21.4497 ms\n",
+      "Std:    0.0294 ms\n",
+      "Min:    21.4270 ms\n",
+      "Max:    21.6775 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": [
+    "The plot shows a spike at $x=0$ (cold start) and a cloud of variance around the true time. The **Mean** gets pulled up by outliers; the **Median** is more robust. Prefer median as your final metric.\n",
+    "\n",
+    "### Attempt 6: The \"Robust\" Harness (Flushing Cache)\n",
+    "\n",
+    "GPUs have L2 caches (40-192MB) that can hide slow global memory access. If your data fits in the cache, subsequent iterations in your loop will skip the slow global memory access, artificially inflating your speed. In production (inference), data streams in fresh each time.\n",
+    "\n",
+    "**The Fix:** Flush the L2 cache between *every* sample by writing to a large tensor (~256MB covers all GPU architectures right now)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "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 clear_l2_cache() which we imported earlier.\n",
+    "# Here's what it does under the hood:\n",
+    "\n",
+    "def clear_l2_cache(device=DEVICE):\n",
+    "    \"\"\"Flush L2 cache by writing to a large tensor.\"\"\"\n",
+    "    dummy = torch.empty((32, 1024, 1024), dtype=torch.int64, device=device)  # 256MB\n",
+    "    dummy.fill_(1901)  # Force write to evict cache\n",
+    "    del dummy\n",
+    "\n",
+    "# KernelBench also provides clear_l2_cache_triton() for AMD GPU support\n",
+    "# from src.kernelbench.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 global memory each time)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "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.0284 ms\n",
+      "Cold cache median: 0.0322 ms\n",
+      "Difference: 0.0039 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": 42,
+   "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": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "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": {},
+   "source": [
+    "You might notice the warm cache's occasional spikes on certain runs, which can happen due to deferred optimization or other OS noise. This is another reason why you care more about cold cache performance: these spikes are much less likely to occur when processing fresh data each time."
+   ]
+  },
+  {
+   "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 global memory access)\n",
+    "6.  Median/Mean Aggregation (to ignore jitter)\n",
+    "\n",
+    "Writing this boilerplate every time is tedious. KernelBench's timing module packages all these best practices, as does Triton's [`do_bench`](https://triton-lang.org/main/python-api/generated/triton.testing.do_bench.html).\n",
+    "\n",
+    "KernelBench's `cuda_event` method handles all of the above automatically—plus **`discard_first`**, which drops the first few post-warmup trials that often still have initialization overhead."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "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 3, trials 100\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "KernelBench cuda_event time: 21.4000 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get the timing function - cuda_event is the default for trusted code\n",
+    "timing_fn = get_timing_function(\"cuda_event\")\n",
+    "\n",
+    "def final_benchmark(func, *args, num_trials=100):\n",
+    "    \"\"\"Production-ready benchmarking using KernelBench's timing module.\"\"\"\n",
+    "    elapsed_times = timing_fn(\n",
+    "        kernel_fn=func,\n",
+    "        args=list(args),\n",
+    "        num_warmup=3,\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": [
+    "---\n",
+    "\n",
+    "## KernelBench's Timing Methods\n",
+    "\n",
+    "KernelBench provides **4 timing methods** 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 adaptive | No | Yes | Adaptive (time-budget) |\n",
+    "| `do_bench_impl` | do_bench with explicit trial control | No | Yes | Explicit |\n",
+    "\n",
+    "**Key difference:** `host_time` waits for ALL streams via `torch.cuda.synchronize()`, catching side-stream exploits. Use it for evaluating LLM-generated code.\n",
+    "\n",
+    "### 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=100,       # Number of timing samples to collect\n",
+    "    discard_first=1,     # Drop first N trials after warmup\n",
+    "    device=\"cuda:0\",     # GPU device\n",
+    "    verbose=True         # Print per-trial timing info\n",
+    ") -> list[float]         # Returns elapsed times in ms\n",
+    "```\n",
+    "\n",
+    "**Note:** `do_bench` ignores `num_warmup`, `num_trials`, and `discard_first`—it uses fixed time budgets instead.\n",
+    "\n",
+    "### Why `discard_first`?\n",
+    "\n",
+    "Even after warmup, the first few trials can have residual initialization overhead (lazy allocation, cuDNN autotuning, etc.). Setting `discard_first=1` (default) improves consistency."
+   ]
+  },
+  {
+   "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": 21,
+   "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 3, trials 100\n",
+      "  cuda_event: 21.4000 ms (std=0.0200)\n",
+      "\n",
+      "Testing host_time...\n",
+      "[Profiling] Using timing method: host_time\n",
+      "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n",
+      "  host_time: 21.5000 ms (std=0.0181)\n",
+      "\n",
+      "Testing do_bench...\n",
+      "[Profiling] Using timing method: do_bench\n",
+      "  do_bench: 21.4000 ms (std=0.0156)\n",
+      "\n",
+      "Testing do_bench_impl...\n",
+      "[Profiling] Using timing method: do_bench_impl\n",
+      "  do_bench_impl: 21.4000 ms (std=0.0194)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x500 with 2 Axes>"
+      ]
+     },
+     "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=3, \n",
+    "            num_trials=100, \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": 22,
+   "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.3688 ms\n",
+      "Mean of all trials:  0.3454 ms\n",
+      "Mean without first:  0.3438 ms\n",
+      "First trial overhead: 7.3%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA18AAAHWCAYAAACIZjNQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAirBJREFUeJzs3Xl8DOcfB/DP7OYUOeQ+RBJxxB0EdUfRqKvuaJ2patUtjlKto1RoUbSOtupoaKnSVlFK3MRRkR9VooKkVBJnIomcM78/tjusHDaR7E7i83698mKffWbmmf3uzs53n2eeESRJkkBERERERESlSmXsBhAREREREb0ImHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBFRmXT9+nUIgoB169YZuylFNmvWLAiCUKxlAwMDERgYWLINMrCDBw9CEAT8+OOPxm6KbN26dRAEAdevXy+xdSYmJqJPnz5wcHCAIAhYsmQJAODvv//GK6+8AltbWwiCgJ9//rnEtvk8fvjhB9jb2yM1NbVYy3/66aeoWrUq1Go1/P39S7ZxVCz9+/dHv379jN0MInoCky8iUiTtyXB+f1OnTi2Vbc6bN0+vE+HAwMAC2/bk36xZs0qlnfrKzs7GsmXL0KRJE1hbW6NixYpo0qQJli1bhuzsbKO2razSJs4F/SUkJMh1J0yYgD179mDatGkIDw9Hp06dAABDhgzB+fPn8fHHHyM8PBwBAQEl2sb09HTMmjULBw8e1HuZ3NxczJw5E2PGjEHFihWLvM3ff/8dU6ZMQcuWLbF27VrMmzcP//77L2bNmoXo6Ogir49KxnvvvYetW7fif//7n7GbQkT/MTF2A4iICvPRRx/Bx8dHp6xu3brw8vLCo0ePYGpqWmLbmjdvHvr06YMePXoUWm/69Ol466235MenT5/GsmXL8P7776NWrVpyef369fNd/oMPPii1BFIrLS0NXbp0waFDh9C1a1cMHToUKpUKu3fvxrhx47Bt2zbs3LkTVlZWpdqO8mrlypX5Jil2dnby//fv34/XXnsNkyZNkssePXqEyMhITJ8+HaNHjy6VtqWnp2P27NkAoHcv6a+//oqYmBi8/fbbxdrm/v37oVKp8M0338DMzAwA8Mcff2D27Nnw9vZmT5iRNGzYEAEBAVi0aBG+/fZbYzeHiMDki4gU7tVXXy2wZ8DCwuKZy6elpZV4gtGxY8c87Vi2bBk6duxY6Mmuti0mJiYwMSndw29oaCgOHTqEzz//XOck/91338Xy5csxevRoTJo0CStXrizVdjxJkiRkZGQYbHulqU+fPnB0dCy0TlJSkk4yBgC3b98GgDzlxrZ27Vq0bNkSHh4exVo+KSkJlpaWcuJVmkrjM/08lNaep/Xr1w8zZ87EihUritWrSUQli8MOiahMyu+ar6FDh6JixYqIjY1F586dYW1tjQEDBgDQXGfTu3dvuLq6wsLCApUrV0b//v2RnJwMABAEAWlpaVi/fr08hGzo0KHFbp92eNpff/2FN954A5UqVUKrVq10nnvS2rVr8fLLL8PZ2Rnm5uaoXbt2sROjGzdu4JtvvsHLL7+cb+/KqFGj0K5dO6xevRo3btwAoOlNbNeuXZ66oijCw8MDffr00SlbsmQJ6tSpAwsLC7i4uOCdd97B/fv3dZb19vZG165dsWfPHgQEBMDS0hJffvmlzno+/vhjVK5cGRYWFmjfvj2uXLmSpw0nT55Ep06dYGtriwoVKqBt27Y4duyYTp24uDiMHDkSNWvWhKWlJRwcHNC3b998r+G6cOECXn75ZVhaWqJy5cqYO3cuRFEs/EUtAu2QWUmSsHz5cp1hqF5eXgCAyZMnQxAEeHt7y8vdvHkTb775JlxcXGBubo46depgzZo1edafkZGBWbNmoUaNGrCwsICbmxt69eqF2NhYXL9+HU5OTgCA2bNn6zUENiMjA7t370aHDh3yPKfP+1IQBKxduxZpaWny9tatW4cmTZoAAEJCQnTKtfSJa2Gfo6c9ePAAarUay5Ytk8vu3LkDlUoFBwcHSJIkl7/77rtwdXWVHx85cgR9+/ZFlSpVYG5uDk9PT0yYMAGPHj3S2UZhxxhBEDB69Ghs2bIFtWvXhqWlJZo3b47z588DAL788ktUq1YNFhYWCAwMzPPe9Pb2zveY8/R1ntprJjdv3oz3338frq6usLKyQvfu3fHPP//kWb5jx45IS0vD3r17833diMiw2PNFRIqWnJyMO3fu6JQV1uOQk5ODoKAgtGrVCgsXLkSFChWQlZWFoKAgZGZmYsyYMXB1dcXNmzexY8cOPHjwALa2tggPD8dbb72Fpk2bykOvfH19n7v9ffv2RfXq1TFv3jydk7+nrVy5EnXq1EH37t1hYmKCX3/9FSNHjoQoihg1alSRtvnbb78hNzcXgwcPLrDO4MGDceDAAezevRtvvfUWgoODMWvWLCQkJOiclB49ehT//vsv+vfvL5e98847WLduHUJCQjB27Fhcu3YNX3zxBc6ePYtjx47pDAWNiYnB66+/jnfeeQfDhw9HzZo15efmz58PlUqFSZMmITk5GZ988gkGDBiAkydPynX279+PV199FY0bN8bMmTOhUqnkhODIkSNo2rQpAM3Qz+PHj6N///6oXLkyrl+/jpUrVyIwMBB//fUXKlSoAABISEhAu3btkJOTg6lTp8LKygpfffUVLC0ti/Qa37t3L0+ZiYkJ7Ozs0KZNG4SHh2PQoEHo2LGjHIf69evDzs4OEyZMwOuvv47OnTvLPRGJiYl46aWX5BN4Jycn/Pbbbxg2bBhSUlIwfvx4AJprs7p27YqIiAj0798f48aNw8OHD7F37178+eef6NChA1auXIl3330XPXv2RK9eveRtF+TMmTPIyspCo0aN8jynz/syPDwcX331FU6dOoXVq1cDAKpXr46PPvoIM2bMwNtvv43WrVsDAFq0aFGkuGrp8zmys7ND3bp1cfjwYYwdOxaA5v0rCALu3buHv/76C3Xq1AGgSba0bQKALVu2ID09He+++y4cHBxw6tQpfP7557hx4wa2bNmis538jjFaR44cwfbt2+XXJiwsDF27dsWUKVOwYsUKjBw5Evfv38cnn3yCN998E/v37y8wLs/y8ccfQxAEvPfee0hKSsKSJUvQoUMHREdH67yftYngsWPH0LNnz2Jvj4hKiEREpEBr166VAOT7J0mSdO3aNQmAtHbtWnmZIUOGSACkqVOn6qzr7NmzEgBpy5YthW7TyspKGjJkSJHbumXLFgmAdODAAbls5syZEgDp9ddfz1Nf+9yT0tPT89QLCgqSqlatqlPWtm1bqW3btoW2Z/z48RIA6ezZswXWiYqKkgBIoaGhkiRJUkxMjARA+vzzz3XqjRw5UqpYsaLcviNHjkgApI0bN+rU2717d55yLy8vCYC0e/dunboHDhyQAEi1atWSMjMz5fKlS5dKAKTz589LkiRJoihK1atXl4KCgiRRFOV66enpko+Pj9SxY0edsqdFRkZKAKRvv/02z2tz8uRJuSwpKUmytbWVAEjXrl0r8DWTpMexy++vZs2aOnUBSKNGjdIp075vP/30U53yYcOGSW5ubtKdO3d0yvv37y/Z2trK+7dmzRoJgLR48eI8bdO+Rrdv35YASDNnzix0X7RWr16t87o/Sd/35ZAhQyQrKyudstOnT+f5jGrbqW9cC/sc5WfUqFGSi4uL/Dg0NFRq06aN5OzsLK1cuVKSJEm6e/euJAiCtHTp0kL3MywsTBIEQYqLi9PZz/yOMZKkibe5ubnOe+jLL7+UAEiurq5SSkqKXD5t2rQ87zcvL698jz9Pf+a1nx8PDw+ddf7www8SAJ390qpRo4b06quv5iknIsPjsEMiUrTly5dj7969On/P8u677+o8trW1BQDs2bMH6enppdLOgowYMUKvek/+Uq3t7Wvbti2uXr0qD43U18OHDwEA1tbWBdbRPpeSkgIAqFGjBvz9/bF582a5Tm5uLn788Ud069ZNbt+WLVtga2uLjh074s6dO/Jf48aNUbFiRRw4cEBnOz4+PggKCsq3DSEhITrXCGl7Iq5evQoAiI6Oxt9//4033ngDd+/elbeVlpaG9u3b4/Dhw/JwwSdfv+zsbNy9exfVqlWDnZ0doqKi5Od27dqFl156SadnxcnJSR46pq+tW7fmeV+uXbu2SOvQkiQJW7duRbdu3SBJks7rGhQUhOTkZHkftm7dCkdHR4wZMybPeop7+4K7d+8CACpVqpTnuZJ8X2oVJa5a+n6OWrdujcTERMTExADQ9ES1adMGrVu3xpEjRwBoesMkSdLp+XpyP9PS0nDnzh20aNECkiTh7Nmzebbz9DFGq3379jpDSZs1awYA6N27t87nUVuufa8Xx+DBg3XW2adPH7i5uWHXrl156laqVCnPCAIiMg4OOyQiRWvatGmRpuI2MTFB5cqVdcp8fHwQGhqKxYsXY+PGjWjdujW6d++OgQMHyolZaXl6psaCHDt2DDNnzkRkZGSeBDE5OblI7dSekGmTsPzkl6AFBwfj/fffx82bN+Hh4YGDBw8iKSkJwcHBcp2///4bycnJcHZ2zne9SUlJOo8L2/8qVaroPNae/GuvHfv7778BaKZmL0hycjIqVaqER48eISwsDGvXrsXNmzd1hqY9mSTExcXJJ75PenI4pD7atGnzzAk39HX79m08ePAAX331Fb766qt862hf19jYWNSsWbNUJmyR8hnOV5LvS62ixFVL38+RNqE6cuQIKleujLNnz2Lu3LlwcnLCwoUL5edsbGzQoEEDebn4+HjMmDED27dvz3Pt4tNJZn7HGK2n39Pa18fT0zPf8qe3VRTVq1fXeSwIAqpVq5bvdY6SJBU7OSeiksXki4jKFXNzc6hUeTv1Fy1ahKFDh+KXX37B77//jrFjxyIsLAwnTpwo8ESqJOhzLVFsbCzat28PPz8/LF68GJ6enjAzM8OuXbvw2WefFXkyCO109+fOnStwiu9z584B0FwPohUcHIxp06Zhy5YtGD9+PH744QfY2trK96cCNJNkODs7Y+PGjfmuVzvZg1Zh+69Wq/Mt1yYB2v3+9NNPC9wP7TVTY8aMwdq1azF+/Hg0b95cvoFx//79S3QyjdKgbd/AgQMLTEgKu2breTk4OADQJAJPfhZK+n2pVZS4aul7TZ67uzt8fHxw+PBheHt7Q5IkNG/eHE5OThg3bhzi4uJw5MgRtGjRQj5O5ObmomPHjrh37x7ee+89+Pn5wcrKCjdv3sTQoUPz7GdBxxig4Pf0s97rQME9l7m5uQUur6/79+/nSdaIyDiYfBHRC6NevXqoV68ePvjgAxw/fhwtW7bEqlWrMHfuXADFH7b1vH799VdkZmZi+/btOr+cPz2ET1+vvvoq1Go1wsPDC5x049tvv4WJiYlOYuXj44OmTZti8+bNGD16NLZt24YePXrA3NxcruPr64t9+/ahZcuWRZ6koqi0E57Y2NjkOxPfk3788UcMGTIEixYtkssyMjLw4MEDnXpeXl5yz8uTtMPUjMHJyQnW1tbIzc195n76+vri5MmTyM7OLvAed0V9H/v5+QEArl27hnr16snlz/u+LKgdRYlrcbRu3RqHDx+Gj48P/P39YW1tjQYNGsDW1ha7d+9GVFSUfB80ADh//jwuX76M9evX63xeDD07YKVKlfK8XwFNb23VqlXzlD/9PpYkCVeuXMmTqOfk5OCff/5B9+7dS7S9RFQ8vOaLiMq9lJQU5OTk6JTVq1cPKpUKmZmZcpmVlVW+Jz+lTfur9tND5Yp7DZGnpydCQkKwb9++fKerX7VqFfbv349hw4bl6fULDg7GiRMnsGbNGty5c0dnyCGguWdQbm4u5syZk2e9OTk5Jfr6NW7cGL6+vli4cCFSU1PzPK+9ZxageQ2fHjb3+eefIzc3V6esc+fOOHHiBE6dOqWznoJ68gxBrVajd+/e2Lp1K/788888zz+5n71798adO3fwxRdf5Kmn3X/t7Hv6xqJx48YwMzPDH3/8kaddT64XKNr7Unvvq6fbUZS4Fkfr1q1x/fp1bN68WR6GqFKp0KJFCyxevBjZ2dk613vlt5+SJGHp0qXP1Y6i8vX1xYkTJ5CVlSWX7dixI9/p4wHNDyhPDi3+8ccfcevWLbz66qs69f766y9kZGTIM00SkXGx54uIyr39+/dj9OjR6Nu3L2rUqIGcnByEh4fLJ71ajRs3xr59+7B48WJ5+FJ+1weVtFdeeQVmZmbo1q0b3nnnHaSmpuLrr7+Gs7Mzbt26Vax1fvbZZ7h06RJGjhyJ3bt3yz1ce/bswS+//IK2bdvq9BJp9evXD5MmTcKkSZNgb2+fp2eibdu2eOeddxAWFobo6Gi88sorMDU1xd9//40tW7Zg6dKlOvcEex4qlQqrV6/Gq6++ijp16iAkJAQeHh64efMmDhw4ABsbG/z6668AgK5duyI8PBy2traoXbs2IiMjsW/fPnlIndaUKVMQHh6OTp06Ydy4cfJU815eXvJQTH38+OOP+d6wtmPHjnBxcSnyvs6fPx8HDhxAs2bNMHz4cNSuXRv37t1DVFQU9u3bJ09tP3jwYHz77bcIDQ3FqVOn0Lp1a6SlpWHfvn0YOXIkXnvtNVhaWqJ27drYvHkzatSoAXt7e9StWxd169bNd9sWFhZ45ZVXsG/fPnz00Udy+fO+L319fWFnZ4dVq1bB2toaVlZWaNasGXx8fPSOa3FoE6uYmBjMmzdPLm/Tpg1+++03mJuby/cgAzQ9f76+vpg0aRJu3rwJGxsbbN269bmuxyqOt956Cz/++CM6deqEfv36ITY2Fhs2bCjwlhf29vZo1aoVQkJCkJiYiCVLlqBatWoYPny4Tr29e/eiQoUKeW4OT0RGYvD5FYmI9KCdav706dP5Pl/QVPNPT3ctSZJ09epV6c0335R8fX0lCwsLyd7eXmrXrp20b98+nXqXLl2S2rRpI1laWkoA9J52vrCp5m/fvp2nfn5TzW/fvl2qX7++ZGFhIXl7e0sLFiyQpxV/cjpqfaaa18rMzJQ+++wzqXHjxpKVlZVUoUIFqVGjRtKSJUukrKysApdr2bKlBEB66623Cqzz1VdfSY0bN5YsLS0la2trqV69etKUKVOkf//9V67j5eUldenSJc+y2qmyn576P7+YSpLmVgG9evWSHBwcJHNzc8nLy0vq16+fFBERIde5f/++FBISIjk6OkoVK1aUgoKCpEuXLuU7ffe5c+ektm3bShYWFpKHh4c0Z84c6Ztvvnnuqeaffg+gCFPNS5IkJSYmSqNGjZI8PT0lU1NTydXVVWrfvr301Vdf6dRLT0+Xpk+fLvn4+Mj1+vTpI8XGxsp1jh8/LjVu3FgyMzPTa9r5bdu2SYIgSPHx8Trl+r4vC/rs/fLLL1Lt2rUlExOTPLHVJ66FfY4K4+zsLAGQEhMT5bKjR49KAKTWrVvnqf/XX39JHTp0kCpWrCg5OjpKw4cPl/73v//pfYyRpKLFu6DPwKJFiyQPDw/J3NxcatmypfTHH38UONX8999/L02bNk1ydnaWLC0tpS5duuhMi6/VrFkzaeDAgQW+VkRkWIIkFXLXTyIiIir3cnNzUbt2bfTr1y/fIaWkHAcPHkS7du2wZcuWZ/YyR0dHo1GjRoiKiipwchMiMixe80VERPSCU6vV+Oijj7B8+fJ8r8Oismn+/Pno06cPEy8iBeE1X0RERITg4OA8E6xQ2bZp0yZjN4GInsKeLyIiIiIiIgPgNV9EREREREQGoIier+XLl8Pb2xsWFhZo1qyZzv1XnrZt2zYEBATAzs4OVlZW8Pf3R3h4uE4dQRDy/fv000/lOvfu3cOAAQNgY2MDOzs7DBs2jOPciYiIiIio1Bg9+dq8eTNCQ0Mxc+ZMREVFoUGDBggKCkJSUlK+9e3t7TF9+nRERkbi3LlzCAkJQUhICPbs2SPXuXXrls7fmjVrIAiCzv18BgwYgAsXLmDv3r3YsWMHDh8+jLfffrvU95eIiIiIiF5MRh922KxZMzRp0gRffPEFAEAURXh6emLMmDGYOnWqXuto1KgRunTpUuD0uD169MDDhw8REREBALh48SJq166N06dPIyAgAACwe/dudO7cGTdu3IC7u/sztymKIv79919YW1tDEAS92klEREREROWPJEl4+PAh3N3doVIV3L9l1NkOs7KycObMGUybNk0uU6lU6NChAyIjI5+5vCRJ2L9/P2JiYrBgwYJ86yQmJmLnzp1Yv369XBYZGQk7Ozs58QKADh06QKVS4eTJk+jZs2ee9WRmZiIzM1N+fPPmTdSuXVuv/SQiIiIiovLvn3/+QeXKlQt83qjJ1507d5CbmwsXFxedchcXF1y6dKnA5ZKTk+Hh4YHMzEyo1WqsWLECHTt2zLfu+vXrYW1tjV69esllCQkJcHZ21qlnYmICe3t7JCQk5LuesLAwzJ49O095VFQUKlasWGBbDUEURaSkpMDGxqbQTJsMhzFRFsZDeRgT5WFMlIXxUB7GRHmUFJPU1FQ0atQI1tbWhdYrk/f5sra2RnR0NFJTUxEREYHQ0FBUrVoVgYGBeequWbMGAwYMgIWFxXNtc9q0aQgNDZUfp6SkwNPTEz4+PrCxsXmudT8vURRx+/ZtODk5Gf2NRxqMibIwHsrDmCgPY6IsjIfyMCbKo6SYpKSkAMAzL0cyavLl6OgItVqNxMREnfLExES4uroWuJxKpUK1atUAAP7+/rh48SLCwsLyJF9HjhxBTEwMNm/erFPu6uqaZ0KPnJwc3Lt3r8Dtmpubw9zcPN+2GDvYgCbQSmkLaTAmysJ4KA9jojyMibIwHsrDmCiPUmKi7/aN2kozMzM0btxYnggD0GSwERERaN68ud7rEUVR53osrW+++QaNGzdGgwYNdMqbN2+OBw8e4MyZM3LZ/v37IYoimjVrVow9ISIiIiIiKpzRhx2GhoZiyJAhCAgIQNOmTbFkyRKkpaUhJCQEADB48GB4eHggLCwMgObaq4CAAPj6+iIzMxO7du1CeHg4Vq5cqbPelJQUbNmyBYsWLcqzzVq1aqFTp04YPnw4Vq1ahezsbIwePRr9+/fXa6ZDIiIiIiKiojJ68hUcHIzbt29jxowZSEhIgL+/P3bv3i1PwhEfH6/TjZeWloaRI0fixo0bsLS0hJ+fHzZs2IDg4GCd9W7atAmSJOH111/Pd7sbN27E6NGj0b59e6hUKvTu3RvLli0rvR0lIiKickOSJOTk5CA3N7dU1i+KIrKzs5GRkWH04VSkwZgojyFjolarYWJi8ty3mDL6fb7KqpSUFNja2iI5OVkRE24kJSXB2dmZBwOFYEyUhfFQHsZEeRgT/WVlZeHWrVtIT08vtW1IkgRRFKFSqXg/UYVgTJTH0DGpUKEC3NzcYGZmluc5fXMDo/d8EREREZUVoiji2rVrUKvVcHd3h5mZWamc9Gl71kril3YqGYyJ8hgqJpIkISsrC7dv38a1a9dQvXr1Yv9IxeSrrJMk4M4dqP/5B1CpACcngAcEIiKiUpGVlQVRFOHp6YkKFSqU2nZ4oq88jInyGDImlpaWMDU1RVxcHLKysop9GyuOKyirHjwAli4FqleHysUFTk2bQuXiAlSvril/8MDYLSQiIiq3ODST6MVTEp97HjnKoj17gMqVgQkTIF29qvOUdPUqMGGC5vk9e4zUQCIiIiIiehqTr7Jmzx6gSxdIjx4BkgThqflSBEkCJEnzfJcuTMCIiIiU6L/LBnD9uuZfzn9G9EJg8lWWPHgA9O4NSZIgiGKhVQVRhCRJQO/eHIJIRESkFE9cNgAnJ8DHR/OvES8bCAwMxPjx4w2+3Wfx9vbGkiVL9K6/bt062NnZlVp7iEoCk6+yZP16ID39mYmXliCKQHo68O23pdwwIiIieqYnLhvAU5cNoJQvGxg6dCgEQcjzd+XKFWzbtg1z5sx5rvULgoCff/650DrXr1+HIAiIjo7Wa52nT5/G22+//Vzt0sfBgwfRqFEjmJubo1q1ali3bl2h9WNiYtCuXTu4uLjAwsICVatWxQcffIDs7Gydeg8ePMCoUaPg5uYGc3Nz1KhRA7t27ZKff/jwIcaPHw8vLy9YWlqiRYsWOH36dGnsIikIZzssKyQJ+PxzSACKMpeLBEBYtgwYM4azIBIRERnLf5cN4L/LA/LQlmkvG9ixA2jfvkSb0KlTJ6xdu1anzMnJCWq1utDlsrKy8r2vUWnRbs/JyanUt3Xt2jV06dIFI0aMwMaNGxEREYG33noLbm5uCAoKyncZU1NTDB48GI0aNYKdnR3+97//Yfjw4RBFEfPmzZP3oWPHjnB2dsaPP/4IDw8PxMXF6fTMvfXWW/jzzz8RHh4Od3d3bNiwAR06dMBff/0FDw+PUt93Mg72fJUVd+8CsbF5rvF6FkGSgNhY4N69UmoYERERFeq/ywYgScCzRq+IoqZenz4lPgTR3Nwcrq6uOn9qtTrPsENvb2/MmTMHgwcPho2NDd5++21kZWVh9OjRcHNzg4WFBby8vBAWFibXB4CePXtCEAT58dN8fHwAAA0bNoQgCAgMDASg6ZXr0aMHPv74Y7i7u6NmzZryep8cdrh48WLUq1cPVlZW8PT0xMiRI5Gamvpcr8mqVavg4+ODRYsWoVatWhg9ejT69OmDzz77rMBlqlatipCQEDRo0ABeXl7o3r07BgwYgCNHjsh11qxZg3v37uHnn39Gy5Yt4e3tjbZt26JBgwYAgEePHmHr1q345JNP0KZNG1SrVg2zZs1CtWrVsHLlSnk93t7emDt3LgYPHoyKFSvCy8sL27dvx+3bt/Haa6+hYsWKqF+/Pv744w95mbi4OHTr1g2VKlWClZUV6tSpo9PjRsbF5KuseM6DCx4+LJl2EBERUdH8d9nAMxMvrf8uG1Bt2FC67SrEwoUL0aBBA5w9exYffvghli1bhu3bt+OHH35ATEwMNm7cKCdZ2qFya9euxa1btwocOnfq1CkAwL59+3Dr1i1s27ZNfi4iIgIxMTHYu3cvduzYke/yKpUKy5Ytw4ULF7B+/Xrs378fU6ZMKXAftMMcDx48WGCdyMhIdOjQQacsKCgIkZGRBS7ztCtXrmD37t1o27atXLZ9+3Y0b94co0aNgouLC+rWrYt58+YhNzcXAJCTk4Pc3Nw894qytLTE0aNHdco+++wztGzZEmfPnkWXLl0waNAgDB48GAMHDkRUVBR8fX0xePBgzbX+AEaNGoXMzEwcPnwY58+fx4IFC1CxYkW994dKF4cdlhXP+6Gxti6ZdhAREZH+/rtsoDhUX3wBjBtXYpcN7NixQ+ck/NVXX8WWLVvyrfvyyy9j4sSJ8uP4+HhUr14drVq1giAI8PLykp/TDg+0s7ODq6trgdvX1nNwcMhTz8rKCqtXry50eOPTvXNz587FiBEjsGLFinzrm5qaombNmoXeDDshIQEuLi46ZS4uLkhJScGjR49gaWlZ4LItWrRAVFQUMjMz8fbbb+Ojjz6Sn7t69Sr279+PAQMGYNeuXbhy5QpGjhyJ7OxszJw5E9bW1mjevDnmzJmDWrVqwcXFBd9//z0iIyNRrVo1ne107twZ77zzDgBgxowZWLlyJZo0aYK+ffsCAN577z00b94ciYmJcHV1RXx8PHr37o169eoB0PTUkXKw56uscHAAfH0hFfEALAkC4OsL2NuXUsOIiIioQP9dNlDUqeQFSYJw9WqJXjbQrl07REdHy3/Lli0rsG5AQIDO46FDhyI6Oho1a9bE2LFj8fvvv5dYuwCgXr16z7yubN++fWjfvj08PDxgbW2NQYMG4e7du0hPT8+3voeHBy5duoSmTZuWaFu1Nm/ejKioKHz33XfYuXMnFi5cKD8niiKcnZ3x1VdfoXHjxggODsb06dOxatUquU54eDgkSYKHhwfMzc2xbNkyvP7663lu5Fu/fn35/9pEUZtYPVmWlJQEABg7dizmzp2Lli1bYubMmTh37lzJ7zwVG5OvskIQgDFjijTZBvDf5Bxjx3KyDSIiImNQ0GUDVlZWqFatmvzn5uZWaN0nNWrUCNeuXcOcOXPw6NEj9OvXD3369CnRthXm+vXr6Nq1K+rXr4+tW7fizJkzWL58OQDN5BbF5erqisTERJ2yxMRE2NjYFNrrBQCenp6oXbs2Xn/9dcyfPx+zZs2ShxW6ubmhRo0aOpOZ1KpVCwkJCXJ7fX19cejQIaSmpuKff/7BqVOnkJ2dnaenytTUVP6/8N/5XH5l4n/DWt966y1cvXoVgwYNwvnz5xEQEIDPi9n7SiWPyVdZMmQIUKECJJV+YZNUKqBCBWDw4FJuGBEREeWrHF02YGNjg+DgYHz99dfYvHkztm7dinv/9cyZmprKiUdBtD1bz6qXnzNnzkAURSxatAgvvfQSatSogX///bfoO/GU5s2bIyIiQqds7969aN68eZHWI4oisrOz5QSoZcuWuHLlivwYAC5fvgw3N7c8PXxWVlZwc3PD/fv3sWfPHrz22mvF3JvHPD09MWLECGzbtg0TJ07E119//dzrpJLB5KsssbMDtm6FIAjPTMAklUrzS8i2bZrliIiIyPD+u2ygqCNQJEGAVLWqYi4bWLx4Mb7//ntcunQJly9fxpYtW+Dq6ipPne7t7Y2IiAgkJCTg/v37+a7D2dkZlpaW2L17NxITE5GcnKz39qtVq4bs7Gx8/vnnuHr1KsLDw3WG8OXn5s2b8PPzkyf6yM+IESNw9epVTJkyBZcuXcKKFSvwww8/YMKECXKdL774Au2fmPZ/48aN+OGHH3Dx4kVcvXoVP/zwA6ZNm4bg4GC5R+rdd9/FvXv3MG7cOFy+fBk7d+7EvHnzMGrUKHk9e/bswe7du3Ht2jXs3bsX7dq1g5+fH0JCQvR+XfIzfvx47NmzB9euXUNUVBQOHDiAWrVqPdc6qeQw+SprgoKAnTshWFoCgpDnGjBJEABB0Dy/axfwyitGaigRERFpLxsoDnH0aMVcNmBtbY1PPvkEAQEBaNKkCa5fv45du3bJ1yctWrQIe/fuhaenJxo2bJjvOkxMTLBs2TJ8+eWXcHd3L1IPT4MGDbB48WIsWLAAdevWxcaNG+Wp7guSnZ2NmJiYAq8JAzTT3+/cuRN79+5FgwYNsGjRIqxevVrnHl937txBbGyszn4sWLAATZs2Rf369TF79myMHj0aq1evlut4enpiz549OH36NOrXr4+xY8di3LhxmDp1qlwnOTkZo0aNgp+fHwYPHoxWrVphz549OkMKiyM3NxejRo1CrVq10KlTJ9SoUaPASUnI8ARJKuIVoAQASElJga2tLZKTk2FjY2P4Bjx4AHz7LbBsmeZCXi1fX801XkOGALa2hm8XAdAMP0hKSoKzs3OeC2fJ8BgP5WFMlIcx0U9GRgauXbsGHx+fPNOEF+jBA6ByZc0NlPWZbl6lgmRpiZxr12Di6Chf00PGJUkScnJyYGJiwpgohKFjUtjnX9/cgEfXssrOTpNk/f03xKQk3D51CmJSEvD335pyJl5ERETK8N9lAxAE4FmJrUqlqbd1Ky8bICqHmHyVdYIAODgg19NTM66cv8QQEREpz3+XDeC/ywbyfF9ry3jZAFG5xuSLiIiIyBCCgoAbN4AlS4Cnb3xbtaqm/OZNJl5E5ZiJsRtARERE9MLQXjYwZozmBsoPH2qmk7e35+gVohcAky8iIiIiQ/vvsgE4OBi7JURkQBx2SEREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfRERERKQobdq0wXfffVesZYcOHYoePXoUWufgwYMQBAEPHjwo1jZKw88//4xq1apBrVZj/PjxWLduHexK4Ubbd+7cgbOzM27cuFHi66ZnY/JFREREVM4NHToUgiBgxIgReZ4bNWoUBEHA0KFDDd+wfGzfvh2JiYno379/sZZfunQp1q1bJz8ODAzE+PHjS6ZxRVSUJO+dd95Bnz598M8//2DOnDkIDg7G5cuXn2v7+SWijo6OGDx4MGbOnFmsdS5fvhze3t6wsLBAs2bNcOrUqULrb9u2DQEBAbCzs4OVlRX8/f0RHh5eYP0RI0ZAEAQsWbIk3+czMzPh7+8PQRAQHR1drH0wJiZfRERERC8AT09PbNq0CY8ePZLLMjIy8N1336FKlSpGbJmuZcuWISQkBCpV8U5TbW1tS6XHqDSlpqYiKSkJQUFBcHd3h7W1NSwtLeHs7FzgMllZWcXeXkhICDZu3Ih79+4VabnNmzcjNDQUM2fORFRUFBo0aICgoCAkJSUVuIy9vT2mT5+OyMhInDt3DiEhIQgJCcGePXvy1P3pp59w4sQJuLu7F7i+KVOmFPq80jH5IiIiInpOGTkZBf5l5WaVeN3iaNSoETw9PbFt2za5bNu2bahSpQoaNmyoU1cURYSFhcHHxweWlpZo0KABfvzxR/n53NxcDBs2TH6+Zs2aWLp0qc46tL0uCxcuhJubGxwcHDBq1ChkZ2cX2Mbbt29j//796Natm1w2adIkdO3aVX68ZMkSCIKA3bt3y2XVqlXD6tWrdbar/f+hQ4ewdOlSCIIAQRBw/fp1ebkzZ84gICAAFSpUQIsWLRATE6PTnpUrV8LX1xdmZmbw8/PDhg0b5OeuX7+ep/flwYMHEAQBBw8exPXr19GuXTsAQKVKlQrsXTx48CCsra0BAC+//LK8/NPDDmfNmgV/f3+sXr0aPj4+sLCwAAD8+OOPqFevHiwtLeHg4IAOHTogLS0Ns2bNwvr16/HLL7/I+37w4EEAQJ06deDu7o6ffvqpwFjkZ/HixRg+fDhCQkJQu3ZtrFq1ChUqVMCaNWsKXCYwMBA9e/ZErVq14Ovri3HjxqF+/fo4evSoTr2bN29izJgx2LhxI0xNTfNd12+//Ybff/8dCxcuzPOc9vXasWMHatasiQoVKqBPnz5IT0/H+vXr4e3tjUqVKmHs2LHIzc2Vl1uxYgWqV68OCwsLuLi4oE+fPkV6TYqKN1kmIiIiek59t/Qt8LkAtwDMDHw8xGvgtoHIzM3Mt25dp7oI6xAmP35r+1tIyUrJU+/X138tVjvffPNNrF27FgMGDAAArFmzBiEhIfJJuVZYWBg2bNiAVatWoXr16jh8+DAGDhwIJycntG3bFqIoonLlytiyZQscHBxw/PhxvP3223Bzc0O/fv3k9Rw4cABubm44cOAArly5guDgYPj7+2P48OH5tu/o0aOoUKECatWqJZe1bdsWq1evRm5uLtRqNQ4dOgRHR0ccPHgQnTp1ws2bNxEbG4vAwMA861u6dCkuX76MunXr4qOPPgIAODk5yQnY9OnTsWjRIjg5OWHEiBF48803cezYMQCaXphx48ZhyZIl6NChA3799VcMHz4cXl5eePnll5/5Wnt6emLr1q3o3bs3YmJiYGNjA0tLyzz1tElfzZo1sXXrVrRo0QL29vY6SaLWlStXsHXrVmzbtg1qtRq3bt3C66+/jk8++QQ9e/bEw4cPceTIEUiShEmTJuHixYtISUnB2rVrAWh6obSaNm2KI0eOYNiwYQA0yUtISAgkScp3f7KysnDmzBlMmzZNLlOpVOjQoQMiIyOf+XoAgCRJ2L9/P2JiYrBgwQK5XBRFDBo0CJMnT0adOnXyXTYxMRHDhw/Hzz//jAoVKuRbJz09HcuWLcOmTZvw8OFD9OrVCz179oSdnR127dqFq1evonfv3mjZsiWCg4Pxxx9/YOzYsQgPD0eLFi1w7949HDlyRK99KS4mX0REREQviIEDB2LatGmIi4sDABw7dgybNm3SSb4yMzMxb9487Nu3D82bNwcAVK1aFUePHsWXX36Jtm3bwtTUFLNnz5aX8fHxQWRkJH744Qed5KtSpUr44osvoFar4efnhy5duiAiIqLA5CsuLg4uLi46Qw5bt26Nhw8f4uzZs2jcuDEOHz6MyZMn4+effwag6Tny8PBAtWrV8qzP1tYWZmZmqFChAlxdXfM8//HHH6Nt27YAgKlTp6JLly7IyMiAhYUFFi5ciKFDh2LkyJEAgNDQUERGRmLRokV6JV9qtVpOdpydnQscCmlmZiYPL7S3t8+3nVpZWVn49ttv4eTkBACIiopCTk4OevXqBS8vLwBAvXr15PqWlpbIzMzMd53u7u44e/as/NjW1hY1a9YscNt37txBbm4uXFxcdMpdXFxw6dKlApcDgOTkZHh4eCAzMxNqtRorVqxAx44d5ecXLFgAExMTjB07Nt/lJUnC0KFDMWLECAQEBOSbmAJAdna23FsJAH369EF4eDgSExNRsWJF1K5dG+3atcOBAwcQHByM+Ph4WFlZoWvXrrC2toaXl1eeXuCSxuSLiIiI6Dlt6bulwOdUgu5VHht6bSigZt66q7uvhiAIz9e4Jzg5OaFLly5Yt24dJElCly5d4OjoqFPnypUrSE9P1zk5BjQn/k+emC5fvhxr1qxBfHw8Hj16hKysLPj7++ssU6dOHajVavmxm5sbzp8/X2D7Hj16JA+n07Kzs0ODBg1w8OBBmJmZwczMDG+//TZmzpyJ1NRUHDp0SE6giqp+/fo6bQOApKQkVKlSBRcvXsTbb7+tU79Fixb44osvirWtkuDl5SUnXgDQoEEDtG/fHvXq1UNQUBBeeeUV9OnTB5UqVXrmuiwtLZGeni4/7tmzJ3r27Fkq7ba2tkZ0dDRSU1MRERGB0NBQVK1aFYGBgThz5gyWLl2KqKioAt/rn3/+OR4+fKjT65afChUqyIkXoEkMvb29UbFiRZ0y7TVqHTt2hJeXF6pWrYpOnTqhU6dO6NmzZ4E9ayWByRcRERHRc7IwsXh2pWLWLcnkC9AMPRw9ejQATQL1tNTUVADAzp074eHhofOcubk5AGDTpk2YNGkSFi1ahObNm8Pa2hqffvopTp48qVP/6Wt3BEGAKIoFts3R0RH379/PUx4YGIiDBw/C3Nwcbdu2hb29PWrVqoWjR4/i0KFDmDhxoh57nteT7dO+zoW170na3rknh+kVdj1bSbCystJ5rFarsXfvXhw/fhy///47Pv/8c0yfPh0nT56Ej49Poeu6d++eTiL3LI6OjlCr1UhMTNQpT0xMLLS3DtC8VtqeSX9/f1y8eBFhYWEIDAzEkSNH5IRXKzc3FxMnTsSSJUtw/fp17N+/H5GRkfL7T6tJkyZ4/fXX8e233wLI//1W2HvQ2toaUVFROHjwIH7//XfMmDEDs2bNwunTp0tt0hZOuEFERET0AunUqROysrKQnZ2NoKCgPM/Xrl0b5ubmiI+PR7Vq1XT+PD09AWiGK7Zo0QIjR45Ew4YNUa1aNcTGxj532xo2bIiEhIQ8CVjbtm1x9OhRREREyNd2BQYG4vvvv8fly5fzvd5Ly8zMTGeCBX3VqlVLvv5L6/jx46hduzYAyInLrVu35OefnvrczMwMAIq1fX0JgoCWLVti9uzZOHv2LMzMzOSJNArb9z///LNIQ+zMzMzQuHFjREREyGWiKCIiIkIenqovURSRmam57nHQoEE4d+4coqOj5T93d3dMnjxZnhFx2bJl+N///ic/v2vXLgCaHwG01/IVl4mJCTp06IBPPvkE586dk5O90sKeLyIiIqIXiFqtxsWLF+X/P83a2hqTJk3ChAkTIIoiWrVqheTkZBw7dgw2NjYYMmQIqlevjm+//RZ79uyBj48PwsPDcfr06Wf2tjxLw4YN4ejoiGPHjunMcNimTRs8fPgQO3bswPz58wFokq8+ffrAzc0NNWrUKHCd3t7eOHnyJK5fv46KFSvqTDpRmMmTJ6Nfv35o2LAhOnTogO3bt+Pnn3/G3r17AWiG7b300kuYP38+fHx8kJSUhA8++EBnHV5eXhAEATt27EDnzp1haWmpMwTueZ08eRIRERF45ZVX4OzsjJMnT+L27dvyhCXe3t7Ys2cPYmJi4ODgAFtbW5iamiI9PR1nzpzBvHnz5HX99NNPmDZtWqHXb4WGhmLIkCEICAhA06ZNsWTJEqSlpSEkJESuM3jwYHh4eCAsTDNxTFhYGAICAuDr64vMzEzs2rUL4eHhWLlyJQDAwcEBDg4OOtsxNTWFq6urfA3a07dC0L6Gvr6+qFy5cnFfPuzYsQNXr15FmzZtUKlSJezatQuiKBZ67dvzYs8XERER0QvGxsYGNjY2BT4/Z84cfPjhhwgLC0OtWrXQqVMn7Ny5U06u3nnnHfTq1QvBwcFo1qwZ7t69K09M8TzUarV8D6onVapUCfXq1YOTkxP8/PwAaBIyURSfeb3XpEmToFarUbt2bTg5OSE+Pl6vtvTo0QNLly7FwoULUadOHXz11Vf4+uuvdXrZ1qxZg5ycHDRu3Bjjx4/H3Llzddbh4eGB2bNnY+rUqXBxcZGHe5YUGxsbHD58GJ07d0aNGjXwwQcfYNGiRXj11VcBAMOHD0fNmjUREBAAJycnuSfvl19+QZUqVdC6dWt5XcnJyXmm2n9acHAwFi5ciBkzZsDf3x/R0dHYvXu3ziQc8fHxOr2BaWlpGDlyJOrUqYOWLVti69at2LBhA956662SfCmKxc7ODtu2bcPLL7+MWrVqYdWqVfj+++8LnHGxJAhSQfNJUqFSUlJga2uL5OTkQg9ehiCKIpKSkuDs7FzsGxJSyWJMlIXxUB7GRHkYE/1kZGTg2rVrOvdZKg2SJCEnJwcmJiYlfs2X0iUkJKBOnTqIioqSZ/BTgvIUk5deegljx47FG2+8YeymPBdDx6Swz7++uQGPrkRERESkGK6urvjmm2/07qGiorlz5w569eqF119/3dhNeSHxmi8iIiIiUpQePXoYuwnllqOjI6ZMmWLsZryw2PNFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiJSlDZt2uC7777Tu/66detgZ2cnP541axb8/f3lx1OnTsWYMWNKsIVExcPki4iIiKicGzp0KARBwIgRI/I8N2rUKAiCgKFDhxq+YfnYvn07EhMT0b9//xJb56RJk7B+/XpcvXq1yMvGx8ejS5cusLKygoeHByZPnoycnJxCl+nevTuqVKkCCwsLuLm5YdCgQfj333/zrXvlyhVYW1vrJI+AJqEUBEHnz8LCosjtJ2Vh8kVERET0AvD09MSmTZvw6NEjuSwjIwPfffcdqlSpYsSW6Vq2bBlCQkKgUpXcaaqjoyOCgoKwcuXKIi2Xm5uLLl26ICsrC8eOHcM333yD9evXY8aMGYUu165dO/zwww+IiYnB1q1bERsbiz59+uSpl52djddffx2tW7fOdz02Nja4deuW/BcXF1ek9pPyMPkiIiIiel65GZo/SXpcJuZoysRs/evmZulXtxgaNWoET09PbNu2TS7btm0bqlSpgoYNG+rUFUURYWFh8PHxgaWlJRo0aIAff/zxcbNyczFs2DD5+Zo1a2Lp0qU66xg6dCh69OiBhQsXws3NDQ4ODhg1ahSys596PZ5w+/Zt7N+/H926ddMpX7x4MerVqwcrKyt4enpi5MiRSE1NLdL+d+vWDZs2bSrSMr///jv++usvbNiwAf7+/ujUqRM++ugjLF++HFlZWQUuN2HCBLz00kvw8vJCixYtMHXqVJw4cSLPvn/wwQfw8/NDv3798l2PIAhwdXWV/1xcXHSe9/b2xty5czF48GBUrFgRXl5e2L59O27fvo3XXnsNFStWRP369fHHH3/Iy8TFxaFbt26oVKkSrKysUKdOHezatatIrwsVH5MvIiIioud1pK/mLzvlcdk/2zRlf6/SrXt8oKY88/bjsn93asouL9Ote/ItTXn6P4/LEiKK3cw333wTa9eulR+vWbMGISEheeqFhYXh22+/xapVq3DhwgVMmDABAwcOxKFDhwBokrPKlStjy5Yt+OuvvzBjxgy8//77+OGHH3TWc+DAAcTGxuLAgQNYv3491q1bh3Xr1hXYvqNHj6JChQqoVauWTrlKpcKyZctw4cIFrF+/Hvv378eUKVOKtO9NmzbFjRs3cP36dbnM29sbs2bNKnCZyMhI1KtXTyfpCQoKQkpKCi5cuKDXdu/du4eNGzeiRYsWMDU1lcv379+PLVu2YPny5QUum5qaCi8vL3h6euK1117Ld5ufffYZWrZsibNnz6JLly4YNGgQBg8ejIEDByIqKgq+vr4YPHgwpP8S+FGjRiEzMxOHDx/G+fPnsWDBAlSsWFGvfaHnx+SLiIiI6AUxcOBAHD16FHFxcYiLi8OxY8cwcOBAnTqZmZmYN28e1qxZg6CgIFStWhVDhw7FwIED8eWXXwIATE1NMXv2bAQEBMDHxwcDBgxASEhInuSrUqVK+OKLL+Dn54euXbuiS5cuiIgoOHmMi4uDi4tLniGH48ePR7t27eDt7Y2XX34Zc+fOzbOtZ3F3d5e3oeXr6wtHR8cCl0lISMjT26R9nJCQUOj23nvvPVhZWcHBwQHx8fH45Zdf5Ofu3r2LoUOHYt26dbCxscl3+Zo1a2LNmjX45ZdfsGHDBoiiiBYtWuDGjRs69Tp37ox33nkH1atXx4wZM5CSkoImTZqgb9++qFGjBt577z1cvHgRiYmJADTXsLVs2RL16tVD1apV0bVrV7Rp06bQfaGSY2LsBhARERGVea23aP5VmT8u8+wFVO4OCGrdui025K3r3gVwC0Ke38WbrQYEQbeua/tiN9PJyQldunTBunXrIEkSunTpkif5uHLlCtLT09GxY0ed8qysLJ3hicuXL8eaNWsQHx+PR48eISsrS2eGQQCoU6cO1OrH++/m5obz588X2L5Hjx7lO6nEvn37EBYWhkuXLiElJQU5OTnIyMhAeno6KlSooNe+W1paAgDS09PlssISwec1efJkDBs2DHFxcZg9ezYGDx6MHTt2QBAEDB8+HG+88UahSU/z5s3RvHlz+XGLFi1Qq1YtfPnll5gzZ45cXr9+ffn/2sSwXr16ecqSkpLg6uqKsWPH4t1338Xvv/+ODh06oHfv3jrroNLFni8iIiKi56W20PwJwuMylYmmTGWqf121mX51n8Obb76JdevWYf369XjzzTfzPK+9lmrnzp2Ijo6W//766y/5uq9NmzZh0qRJGDZsGH7//XdER0cjJCQkz3VQTw6zAzTXMImiWGDbHB0dcf/+fZ2y69evo2vXrqhfvz62bt2KM2fOyEP1Crvu6mn37t0DoElA9eXq6ir3GGlpH7u6uha6rKOjI2rUqIGOHTti06ZN2LVrF06cOAFAM+Rw4cKFMDExgYmJCYYNG4bk5GSYmJhgzZo1+a7P1NQUDRs2xJUrV/KUawn/vU/yK9O+7m+99RauXr2KQYMG4fz58wgICMDnn3/+zNeCSgZ7voiIiIheIJ06dUJWVhYEQUBQUFCe52vXrg1zc3PEx8ejbdu2+a7j2LFjaNGiBUaOHCmXxcbGPnfbGjZsiISEBNy/fx+VKlUCAJw5cwaiKGLRokXycMSiDjkEgD///BOmpqaoU6eO3ss0b94cH3/8MZKSkuSkbe/evbCxsUHt2rX1Xo828cnMzASguZYsNzdXfv6XX37BggULcPz4cXh4eOS7jtzcXJw/fx6dO3fWe7sF8fT0xIgRIzBixAhMmzYNX3/9Ne+DZiBMvoiIiIheIGq1GhcvXpT//zRra2tMmjQJEyZMgCiKaNWqFZKTk3Hs2DHY2NhgyJAhqF69Or799lvs2bMHPj4+CA8Px+nTp+Hj4/NcbWvYsCEcHR1x7NgxdO3aFQBQrVo1ZGdn4/PPP0e3bt1w7NgxrFq16hlryuvIkSNo3bq1PPwQANq3b4+ePXti9OjR+S7zyiuvoHbt2hg0aBAWLFiAmzdv4sMPP8SoUaNgbq4ZCnrq1CkMHjwYERER8PDwwMmTJ3H69Gm0atUKlSpVQmxsLD788EP4+vrKwwifnlDkjz/+gEqlQt26deWyjz76CC+99BKqVauGBw8e4NNPP0VcXBzeeuutIu/7k8aPH49XX30VNWrUwP3793HgwIE87aHSY/Rhh8uXL4e3tzcsLCzQrFkznDp1qsC627ZtQ0BAAOzs7GBlZQV/f3+Eh4fnqXfx4kV0794dtra2sLKyQpMmTRAfHy8/HxgYmOemdfnddJCIiIioPLKxsSlwogcAmDNnDj788EOEhYWhVq1a6NSpE3bu3CknV++88w569eqF4OBgNGvWDHfv3tXpBSsutVqNkJAQbNy4US5r0KABFi9ejAULFqBu3brYuHEjwsLCirzuTZs2Yfjw4TplsbGxuHPnTqHt2bFjB9RqNVq0aIGhQ4di0KBB+Oijj+Q66enpiImJkaeRr1ChArZt24b27dujZs2aGDZsGOrXr49Dhw7JCZs+7t+/j+HDh6NWrVro3LkzUlJScPz48SL1uOUnNzcXo0aNkuNao0YNrFix4rnWSfoTJOnJG0cY1ubNmzF48GCsWrUKzZo1w5IlS7BlyxbExMTA2dk5T/2DBw/i/v378PPzg5mZGXbs2IGJEydi586dcrd5bGwsmjZtimHDhuH111+HjY0NLly4gJdeekleZ2BgIGrUqKHzwalQoUKhB6GnpaSkwNbWFsnJyUVarjSIooikpCQ4OzuX6A0JqfgYE2VhPJSHMVEexkQ/GRkZuHbtGnx8fPKdGKKkSJKEnJwcmJiYyNfsvCgSEhJQp04dREVFwcvLq0TW+dtvv2HixIk4d+4cTEyKN/DrRY6JUhk6JoV9/vXNDYw67HDx4sUYPny4fH+JVatWYefOnVizZg2mTp2ap35gYKDO43HjxmH9+vU4evSonHxNnz4dnTt3xieffCLX8/X1zbOuChUqPPNCSSIiIiIyLFdXV3zzzTeIj48vseQrLS0Na9euLXbiRVRSjPYOzMrKwpkzZzBt2jS5TKVSoUOHDoiMjHzm8pIkYf/+/YiJicGCBQsAaH6127lzJ6ZMmYKgoCCcPXsWPj4+mDZtGnr06KGz/MaNG7Fhwwa4urqiW7du+PDDDwudqjQzM1O+SBLQZLfabRY2a48hiKIISZKM3g56jDFRFsZDeRgT5WFM9KN9nbR/pUm7fiMOUjKa1157DUDJ7Xvv3r1LZH0vckyUypAx0X7u8zv/1/fYabTk686dO8jNzc33xnWXLl0qcLnk5GR4eHggMzMTarUaK1askO9DkZSUhNTUVMyfPx9z587FggULsHv3bvTq1QsHDhyQZ+x544034OXlBXd3d5w7dw7vvfceYmJisG3btgK3GxYWhtmzZ+cpv337NjIyMorzEpQYURSRnJwMSZI4VEQhGBNlYTyUhzFRHsZEP9nZ2RBFETk5OcjJySm17UiSJM+GxyFuysCYKI+hY5KTkwNRFHH37t08t1F4+PChXusoc32v1tbWiI6ORmpqKiIiIhAaGoqqVasiMDBQzjhfe+01TJgwAQDg7++P48ePY9WqVXLy9fbbb8vrq1evHtzc3NC+fXvExsbmO0QRAKZNm4bQ0FD5cUpKCjw9PeHk5KSIa74EQYCTkxO/MBWCMVEWxkN5GBPlYUz0k5GRgYcPH8r3ZyptT5/gkfExJspjqJiYmJhApVLBwcEhzzVf+l4DarTky9HREWq1Ot8b1xV2LZZKpUK1atUAaBKrixcvIiwsDIGBgXB0dISJiUmeWWBq1aqFo0ePFrjOZs2aAdDc0b2g5Mvc3DzfGWpUKpUivqQEQVBMW0iDMVEWxkN5GBPlYUyeTaVSyb+wl+Yv7ZIkGWQ7pD/GRHmMEZOCjpP6HjeNdnQ1MzND48aNERERIZeJooiIiAj5Hgj6EEVRvhbLzMwMTZo0QUxMjE6dy5cvF3rBZnR0NADAzc2tCHtARERELxrtL+zp6elGbgkRGZr2c/88PW1GHXYYGhqKIUOGICAgAE2bNsWSJUuQlpYmz344ePBgeHh4yPdyCAsLQ0BAAHx9fZGZmYldu3YhPDwcK1eulNc5efJkBAcHo02bNmjXrh12796NX3/9FQcPHgSgmYr+u+++Q+fOneHg4IBz585hwoQJaNOmDerXr2/w14CIiIjKDrVaDTs7OyQlJQHQzJ5cGr+4c1pz5WFMlMdQMZEkCenp6UhKSoKdnV2+NyfXl1GTr+DgYNy+fRszZsxAQkIC/P39sXv3bnkSjvj4eJ0uvLS0NIwcORI3btyApaUl/Pz8sGHDBgQHB8t1evbsiVWrViEsLAxjx45FzZo1sXXrVrRq1QqApnds3759cqLn6emJ3r1744MPPjDszhMREVGZpL08QpuAlQbtjGpPDnMk42JMlMfQMbGzs3vuW1UZ9SbLZRlvskyFYUyUhfFQHsZEeRiTosvNzUV2dnaprFs7o5qDgwPjoRCMifIYMiampqaF9niViZssExEREZVVarX6uYYfFUYURZiamsLCwoIn+grBmChPWYxJ2WglERERERFRGcfki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGYPTka/ny5fD29oaFhQWaNWuGU6dOFVh327ZtCAgIgJ2dHaysrODv74/w8PA89S5evIju3bvD1tYWVlZWaNKkCeLj4+XnMzIyMGrUKDg4OKBixYro3bs3EhMTS2X/iIiIiIiIACMnX5s3b0ZoaChmzpyJqKgoNGjQAEFBQUhKSsq3vr29PaZPn47IyEicO3cOISEhCAkJwZ49e+Q6sbGxaNWqFfz8/HDw4EGcO3cOH374ISwsLOQ6EyZMwK+//ootW7bg0KFD+Pfff9GrV69S318iIiIiInpxCZIkScbaeLNmzdCkSRN88cUXAABRFOHp6YkxY8Zg6tSpeq2jUaNG6NKlC+bMmQMA6N+/P0xNTfPtEQOA5ORkODk54bvvvkOfPn0AAJcuXUKtWrUQGRmJl156Sa/tpqSkwNbWFsnJybCxsdFrmdIiiiKSkpLg7OwMlcronZkExkRpGA/lYUyUhzFRFsZDeRgT5VFSTPTNDUwM2CYdWVlZOHPmDKZNmyaXqVQqdOjQAZGRkc9cXpIk7N+/HzExMViwYAEATQB27tyJKVOmICgoCGfPnoWPjw+mTZuGHj16AADOnDmD7OxsdOjQQV6Xn58fqlSpUmjylZmZiczMTPlxSkqKvE1RFIu8/yVJFEVIkmT0dtBjjImyMB7Kw5goD2OiLIyH8jAmyqOkmOjbBqMlX3fu3EFubi5cXFx0yl1cXHDp0qUCl0tOToaHhwcyMzOhVquxYsUKdOzYEQCQlJSE1NRUzJ8/H3PnzsWCBQuwe/du9OrVCwcOHEDbtm2RkJAAMzMz2NnZ5dluQkJCgdsNCwvD7Nmz85Tfvn0bGRkZRdjzkieKIpKTkyFJktGzftJgTJSF8VAexkR5GBNlYTyUhzFRHiXF5OHDh3rVM1ryVVzW1taIjo5GamoqIiIiEBoaiqpVqyIwMFDOOF977TVMmDABAODv74/jx49j1apVaNu2bbG3O23aNISGhsqPU1JS4OnpCScnJ0UMOxQEAU5OTkZ/45EGY6IsjIfyMCbKw5goC+OhPIyJ8igpJk/OL1EYoyVfjo6OUKvVeWYZTExMhKura4HLqVQqVKtWDYAmsbp48SLCwsIQGBgIR0dHmJiYoHbt2jrL1KpVC0ePHgUAuLq6IisrCw8ePNDp/XrWds3NzWFubp5ve4wdbAAQBEExbSENxkRZGA/lYUyUhzFRFsZDeRgT5VFKTPTdvtFaaWZmhsaNGyMiIkIuE0URERERaN68ud7rEUVRvhbLzMwMTZo0QUxMjE6dy5cvw8vLCwDQuHFjmJqa6mw3JiYG8fHxRdouERERERFRURh12GFoaCiGDBmCgIAANG3aFEuWLEFaWhpCQkIAAIMHD4aHhwfCwsIAaK67CggIgK+vLzIzM7Fr1y6Eh4dj5cqV8jonT56M4OBgtGnTBu3atcPu3bvx66+/4uDBgwAAW1tbDBs2DKGhobC3t4eNjQ3GjBmD5s2b6z3TIRERERERUVEZNfkKDg7G7du3MWPGDCQkJMDf3x+7d++WJ+GIj4/X6cJLS0vDyJEjcePGDVhaWsLPzw8bNmxAcHCwXKdnz55YtWoVwsLCMHbsWNSsWRNbt25Fq1at5DqfffYZVCoVevfujczMTAQFBWHFihWG23EiIiIiInrhGPU+X2UZ7/NFhWFMlIXxUB7GRHkYE2VhPJSHMVEeJcVE39yA7xwiIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgATIpSWRRFHDp0CEeOHEFcXBzS09Ph5OSEhg0bokOHDvD09CytdhIREREREZVpevV8PXr0CHPnzoWnpyc6d+6M3377DQ8ePIBarcaVK1cwc+ZM+Pj4oHPnzjhx4kRpt5mIiIiIiKjM0avnq0aNGmjevDm+/vprdOzYEaampnnqxMXF4bvvvkP//v0xffp0DB8+vMQbS0REREREVFbplXz9/vvvqFWrVqF1vLy8MG3aNEyaNAnx8fEl0jgiIiIiIqLyQq9hh89KvJ5kamoKX1/fYjeIiIiIiIioPCrybIe7d+/G0aNH5cfLly+Hv78/3njjDdy/f79EG0dERERERFReFDn5mjx5MlJSUgAA58+fx8SJE9G5c2dcu3YNoaGhJd5AIiIiIiKi8qBIU80DwLVr11C7dm0AwNatW9G1a1fMmzcPUVFR6Ny5c4k3kIiIiIiIqDwocs+XmZkZ0tPTAQD79u3DK6+8AgCwt7eXe8SIiIiIiIhIV5F7vlq1aoXQ0FC0bNkSp06dwubNmwEAly9fRuXKlUu8gUREREREROVBkXu+vvjiC5iYmODHH3/EypUr4eHhAQD47bff0KlTpxJvIBERERERUXlQ5J6vKlWqYMeOHXnKP/vssxJpEBERERERUXlU5ORLKykpCUlJSRBFUae8fv36z90oIiIiIiKi8qbIydeZM2cwZMgQXLx4EZIkAQAEQYAkSRAEAbm5uSXeSCIiIiIiorKuyMnXm2++iRo1auCbb76Bi4sLBEEojXYRERERERGVK0VOvq5evYqtW7eiWrVqpdEeIiIiIiKicqnIsx22b98e//vf/0qjLUREREREROVWkXu+Vq9ejSFDhuDPP/9E3bp1YWpqqvN89+7dS6xxRERERERE5UWRk6/IyEgcO3YMv/32W57nOOEGERERERFR/oo87HDMmDEYOHAgbt26BVEUdf6YeBEREREREeWvyMnX3bt3MWHCBLi4uJRGe4iIiIiIiMqlIidfvXr1woEDB0qjLUREREREROVWka/5qlGjBqZNm4ajR4+iXr16eSbcGDt2bIk1joiIiIiIqLwo1myHFStWxKFDh3Do0CGd5wRBYPJFRERERESUjyInX9euXSuNdhAREREREZVrRb7mi4iIiIiIiIpOr+Rr/vz5ePTokV4rPHnyJHbu3PlcjSIiIiIiIipv9Eq+/vrrL1SpUgUjR47Eb7/9htu3b8vP5eTk4Ny5c1ixYgVatGiB4OBgWFtbl1qDiYiIiIiIyiK9rvn69ttv8b///Q9ffPEF3njjDaSkpECtVsPc3Bzp6ekAgIYNG+Ktt97C0KFDYWFhUaqNJiIiIiIiKmv0nnCjQYMG+Prrr/Hll1/i3LlziIuLw6NHj+Do6Ah/f384OjqWZjuJiIiIiIjKtCLPdqhSqeDv7w9/f/9SaA4REREREVH5xNkOiYiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGUOzk68qVK9izZ49882VJkkqsUUREREREROVNkZOvu3fvokOHDqhRowY6d+6MW7duAQCGDRuGiRMnlngDiYiIiIiIyoMiJ18TJkyAiYkJ4uPjUaFCBbk8ODgYu3fvLtHGERERERERlRdFvs/X77//jj179qBy5co65dWrV0dcXFyJNYyIiIiIiKg8KXLPV1pamk6Pl9a9e/dgbm5eIo0iIiIiIiIqb4qcfLVu3Rrffvut/FgQBIiiiE8++QTt2rUr0cYRERERERGVF0UedvjJJ5+gffv2+OOPP5CVlYUpU6bgwoULuHfvHo4dO1YabSQiIiIiIirzitzzVbduXVy+fBmtWrXCa6+9hrS0NPTq1Qtnz56Fr69vsRqxfPlyeHt7w8LCAs2aNcOpU6cKrLtt2zYEBATAzs4OVlZW8Pf3R3h4uE6doUOHQhAEnb9OnTrp1PH29s5TZ/78+cVqPxERERER0bMUuecLAGxtbTF9+vQSacDmzZsRGhqKVatWoVmzZliyZAmCgoIQExMDZ2fnPPXt7e0xffp0+Pn5wczMDDt27EBISAicnZ0RFBQk1+vUqRPWrl0rP87verSPPvoIw4cPlx9bW1uXyD4RERERERE9rVjJV0ZGBs6dO4ekpCSIoqjzXPfu3Yu0rsWLF2P48OEICQkBAKxatQo7d+7EmjVrMHXq1Dz1AwMDdR6PGzcO69evx9GjR3WSL3Nzc7i6uha6bWtr62fWISIiIiIiKglFTr52796NwYMH486dO3meEwQBubm5eq8rKysLZ86cwbRp0+QylUqFDh06IDIy8pnLS5KE/fv3IyYmBgsWLNB57uDBg3B2dkalSpXw8ssvY+7cuXBwcNCpM3/+fMyZMwdVqlTBG2+8Id/DLD+ZmZnIzMyUH6ekpAAARFHMk4AamiiKkCTJ6O2gxxgTZWE8lIcxUR7GRFkYD+VhTJRHSTHRtw1FTr7GjBmDvn37YsaMGXBxcSlyw550584d5Obm5lmPi4sLLl26VOByycnJ8PDwQGZmJtRqNVasWIGOHTvKz3fq1Am9evWCj48PYmNj8f777+PVV19FZGQk1Go1AGDs2LFo1KgR7O3tcfz4cUybNg23bt3C4sWL891mWFgYZs+enaf89u3byMjIKM7ulxhRFJGcnAxJkqBSFfkyPioFjImyMB7Kw5goD2OiLIyH8jAmyqOkmDx8+FCvekVOvhITExEaGvrcidfzsLa2RnR0NFJTUxEREYHQ0FBUrVpVHpLYv39/uW69evVQv359+Pr64uDBg2jfvj0AIDQ0VK5Tv359mJmZ4Z133kFYWFi+14dNmzZNZ5mUlBR4enrCyckJNjY2pbSn+hFFEYIgwMnJyehvPNJgTJSF8VAexkR5GBNlYTyUhzFRHiXFxMLCQq96RU6++vTpg4MHDxZ7ZsMnOTo6Qq1WIzExUac8MTGx0GuxVCoVqlWrBgDw9/fHxYsXERYWlud6MK2qVavC0dERV65ckZOvpzVr1gw5OTm4fv06atasmed5c3PzfJMylUpl9GADmiGfSmkLaTAmysJ4KA9jojyMibIwHsrDmCiPUmKi7/aLnHx98cUX6Nu3L44cOYJ69erB1NRU5/mxY8fqvS4zMzM0btwYERER6NGjBwBNBhsREYHRo0frvR5RFHWux3rajRs3cPfuXbi5uRVYJzo6GiqVKt8ZFomIiIiIiJ5XkZOv77//Hr///jssLCxw8OBBCIIgPycIQpGSL0Az/G/IkCEICAhA06ZNsWTJEqSlpcmzHw4ePBgeHh4ICwsDoLn2KiAgAL6+vsjMzMSuXbsQHh6OlStXAgBSU1Mxe/Zs9O7dG66uroiNjcWUKVNQrVo1eTbEyMhInDx5Eu3atYO1tTUiIyMxYcIEDBw4EJUqVSrqS0JERERERPRMRU6+pk+fjtmzZ2Pq1Kkl0r0XHByM27dvY8aMGUhISIC/vz92794tX1MWHx+vs520tDSMHDkSN27cgKWlJfz8/LBhwwYEBwcDANRqNc6dO4f169fjwYMHcHd3xyuvvII5c+bIwwbNzc2xadMmzJo1C5mZmfDx8cGECRN0rukiIiIiIiIqSYIkSVJRFrC3t8fp06dL5JqvsiwlJQW2trZITk5WxIQbSUlJcHZ2Nvp4V9JgTJSF8VAexkR5GBNlYTyUhzFRHiXFRN/coMitHDJkCDZv3vxcjSMiIiIiInrRFHnYYW5uLj755BPs2bMH9evXzzPhRkH3ySIiIiIiInqRFTn5On/+PBo2bAgA+PPPP3Wee3LyDSIiIiIiInqsyMnXgQMHSqMdRERERERE5RqvFiQiIiIiIjIAvXq+evXqhXXr1sHGxga9evUqtO62bdtKpGFERERERETliV7Jl62trXw9l62tbak2iIiIiIiIqDzSK/lau3YtPvroI0yaNAlr164t7TYRERERERGVO3pf8zV79mykpqaWZluIiIiIiIjKLb2TL0mSSrMdRERERERE5VqRZjvkfbyIiIiIiIiKp0j3+apRo8YzE7B79+49V4OIiIiIiIjKoyIlX7Nnz+Zsh0RERERERMVQpOSrf//+cHZ2Lq22EBERERERlVt6X/PF672IiIiIiIiKj7MdEhERERERGYDeww5FUSzNdhAREREREZVrRZpqnoiIiIiIiIqHyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMQBHJ1/Lly+Ht7Q0LCws0a9YMp06dKrDutm3bEBAQADs7O1hZWcHf3x/h4eE6dYYOHQpBEHT+OnXqpFPn3r17GDBgAGxsbGBnZ4dhw4YhNTW1VPaPiIiIiIjI6MnX5s2bERoaipkzZyIqKgoNGjRAUFAQkpKS8q1vb2+P6dOnIzIyEufOnUNISAhCQkKwZ88enXqdOnXCrVu35L/vv/9e5/kBAwbgwoUL2Lt3L3bs2IHDhw/j7bffLrX9JCIiIiKiF5vRk6/Fixdj+PDhCAkJQe3atbFq1SpUqFABa9asybd+YGAgevbsiVq1asHX1xfjxo1D/fr1cfToUZ165ubmcHV1lf8qVaokP3fx4kXs3r0bq1evRrNmzdCqVSt8/vnn2LRpE/79999S3V8iIiIiInoxmRhz41lZWThz5gymTZsml6lUKnTo0AGRkZHPXF6SJOzfvx8xMTFYsGCBznMHDx6Es7MzKlWqhJdffhlz586Fg4MDACAyMhJ2dnYICAiQ63fo0AEqlQonT55Ez54982wrMzMTmZmZ8uOUlBQAgCiKEEWxaDtewkRRhCRJRm8HPcaYKAvjoTyMifIwJsrCeCgPY6I8SoqJvm0wavJ1584d5ObmwsXFRafcxcUFly5dKnC55ORkeHh4IDMzE2q1GitWrEDHjh3l5zt16oRevXrBx8cHsbGxeP/99/Hqq68iMjISarUaCQkJcHZ21lmniYkJ7O3tkZCQkO82w8LCMHv27Dzlt2/fRkZGRlF2u8SJoojk5GRIkgSVyuidmQTGRGkYD+VhTJSHMVEWxkN5GBPlUVJMHj58qFc9oyZfxWVtbY3o6GikpqYiIiICoaGhqFq1KgIDAwEA/fv3l+vWq1cP9evXh6+vLw4ePIj27dsXa5vTpk1DaGio/DglJQWenp5wcnKCjY3Nc+3P8xJFEYIgwMnJyehvPNJgTJSF8VAexkR5GBNlYTyUhzFRHiXFxMLCQq96Rk2+HB0doVarkZiYqFOemJgIV1fXApdTqVSoVq0aAMDf3x8XL15EWFiYnHw9rWrVqnB0dMSVK1fQvn17uLq65pnQIycnB/fu3Stwu+bm5jA3N8+3LcYONgAIgqCYtpAGY6IsjIfyMCbKw5goC+OhPIyJ8iglJvpu36itNDMzQ+PGjRERESGXiaKIiIgING/eXO/1iKKocz3W027cuIG7d+/Czc0NANC8eXM8ePAAZ86ckevs378foiiiWbNmxdgTIiIiIiKiwhl92GFoaCiGDBmCgIAANG3aFEuWLEFaWhpCQkIAAIMHD4aHhwfCwsIAaK69CggIgK+vLzIzM7Fr1y6Eh4dj5cqVAIDU1FTMnj0bvXv3hqurK2JjYzFlyhRUq1YNQUFBAIBatWqhU6dOGD58OFatWoXs7GyMHj0a/fv3h7u7u3FeCCIiIiIiKteMnnwFBwfj9u3bmDFjBhISEuDv74/du3fLk3DEx8frdOOlpaVh5MiRuHHjBiwtLeHn54cNGzYgODgYAKBWq3Hu3DmsX78eDx48gLu7O1555RXMmTNHZ9jgxo0bMXr0aLRv3x4qlQq9e/fGsmXLDLvzRERERET0whAkSZKM3YiyKCUlBba2tkhOTlbEhBtJSUlwdnY2+nhX0mBMlIXxUB7GRHkYE2VhPJSHMVEeJcVE39yA7xwiIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SIiIiIiIjIAJl9EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAbA5IuIiIiIiMgAmHwREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBERERERERkAky8iIiIiIiIDMDF2A4gA4Pp1IDISSEsDrKyA5s0Bb29jt4qIiIiIqOQw+SKjunULWLgQOHIESEkBVCpAFAEbG6BNG2DiRMDNzditJCIiIiJ6fky+yGhu3QJGjgQuXACcnABf38fJ14MHwPbtQGwssGIFEzAiIiIiKvt4zRcZzcKFmsSralXA3l6TeAGaf+3tNeUXLgCLFxu3nUREREREJYE9X88rNwOQrAFB0DwWcwApBxDUgMpUtx4AqMzz1oUKUJsVs24mIOYCkvi4TMwFpOz860ICVGaAoHpG3SwAIiCYAiq1pkwSATGriHUFQG2ep+71eBMcOWICJyfAzFSEiSoLEgTkiI/rWppnwcNVxNHDJrh+3URzDZgkAWKmpoLa4ol9zgakXEAwAVT/va2LWze/171IddUA1E/scyHxfK73SX7xLErdZ8T+ud8n+ce+aHX1iGdR6orZmudK7X1ShHga8hihd+wNfIzIzdBsU2WZT90nX/cSeJ8o7RhhkPdJEY8Ren+XlPdjRGm+T4oQT0mAjhfxGKF37I1xjCjku6S8HiOUeh6h93dJKR8jtK/9M7Dn63kdHwxkpzx+/M824Ehf4O9VT9UbqCnPvP247N+dmrLLy3TrnhimKU//53FZQoSm7OInunVPj4RwrB/Uj64/Lrt9RFP3zzm6daMmaMqTLzwuu3daU3buA9260VM15fejHpc9OKcpOztJt+75mZryO5GPy1JiNGV/jNGt+1cYcKQvrkYeQkoKYGcHOFtdx9RWfTG66ds6VXvUXIz5XfuivvMenDjxX+GjW5r1Rg7VXe/l5Zrym9sfl2Xd05Qd669bN3a1pjz+h8dluemasiN9NR8qrWvfasquffu4TMp9XDc3/XF5/A+astjVuts71l9TnnXvcdnN7f/Ffrlu3cihmvJHtx6X3dqjKbv0VBfgqbc15WnXH5clHdKU/RWmW/ePMZrylJjHZXciNWXnZ+rWPTtJU/7g3OOy+1GasuipunXPfaApv3f6cVnyBU1Z1ATdun/O0ZTfPvK47GGspuz0SN26Fz/RlCdEPC5L/0dTdmKYbt3LyzTl/+58XJZ5W1N2fKBu3Stfasr/2fa4LDvlcTyfdHWdpizu+8dlYubjutqDMqCpc6SvZpknaesa+RiBI301r7WWQo4Rdn++DeHMWN26/x0jkHTocVnadU3ZKd1jBC4t1pTf2vO4jMeIx4p4jBCO9YM6/crjshfxGPH3KuUcI658qVv3BTxGFHYewWMEzyMAAKmxmu+SP0bp1jXGMeL4YOiDyRcZRUaGZnih6hnvQEHQ/KWmGqZdRERERESlRZAkSTJ2I8qilJQU2NraIvleImzsnIw6pEgUc5F05wGcXVyhUqnKxHCBTZtNMOsjE/j6AmpV/sMOTVRZkEQRf18xwYczTdC/P8rMkCIRaiQlJcHZ2RkqKavQui/8cAEDDCkSRVETD8dKUAkcdqiEY4SYm4OkhBtwdnaBypTDDkuk7nMeI/T/Lil/xwiZgoYdipKApDv3Nd8jKtULd4xQ4rBDvb9LyukxQonnEUX7LindY0RKSgps7V2QnJwMGxsbFITXfD0vtcXjNzfwXyDyeVmfDFyJ1jUHBPHxmxv47w2pzr9unvUWVNcsb5mgyr9txaj7UgvNdPIPHgD29ipki3nr5ohmuHcPsLLW3PdLs16hgNfHFICpblmJ1M3nddenrvjEdROlGfvnqluE2BvpfaJbt4DXvSh1VaZ5u1tL630CKKRuUWJvhGPE09ssrfeJ0o4RT1LKMULv75Jyfoww1PsEKLzuk98jz6pblPXmqavwY0SJ1y2h2Ov9XVKOjhF56iroGKHXd0kpHyPUWXnr50MRww6XL18Ob29vWFhYoFmzZjh16lSBdbdt24aAgADY2dnBysoK/v7+CA8PL7D+iBEjIAgClixZolPu7e0NQRB0/ubPn19Su0TP4O0NtG4N3L4NZGfnXyc7G7hzB2jbFvDyMmjziIiIiIhKnNF7vjZv3ozQ0FCsWrUKzZo1w5IlSxAUFISYmBg4OzvnqW9vb4/p06fDz88PZmZm2LFjB0JCQuDs7IygoCCduj/99BNOnDgBd3f3fLf90UcfYfjw4fJja2vrkt05KtSkScDVq4/v82VnB537fN25A9SuDYSGGrulRERERETPz+jJ1+LFizF8+HCEhIQAAFatWoWdO3dizZo1mDp1ap76gYGBOo/HjRuH9evX4+jRozrJ182bNzFmzBjs2bMHXbp0yXfb1tbWcHV11audmZmZyMx8PHNRSopmZiJRFCE+PTTAwERRhCRJRm9HUbm4AMuXA599Bhw+DFy79jj5srYGuncHJkzQ1Ctju1ZmY1JeMR7Kw5goD2OiLIyH8jAmyqOkmOjbBqMmX1lZWThz5gymTZsml6lUKnTo0AGRkZGFLKkhSRL279+PmJgYLFiwQC4XRRGDBg3C5MmTUadOnQKXnz9/PubMmYMqVargjTfewIQJE2Bikv9LEhYWhtmzZ+cpv337NjIy9JvXv7SIoojk5GRIkqS5KLcMUamAiROBgQOBmBjNLIgWFoCfH6Dt+ExKMm4bi6Msx6Q8YjyUhzFRHsZEWRgP5WFMlEdJMXn48KFe9YyafN25cwe5ublwcXHRKXdxccGlS5cKXC45ORkeHh7IzMyEWq3GihUr0LFjR/n5BQsWwMTEBGPHji1wHWPHjkWjRo1gb2+P48ePY9q0abh16xYWL16cb/1p06Yh9InxbykpKfD09ISTk1OhM5oYgiiKEAQBTk5ORn/jFZezM1CvnrFbUXLKQ0zKE8ZDeRgT5WFMlIXxUB7GRHmUFBMLi3wm6MiH0YcdFoe1tTWio6ORmpqKiIgIhIaGomrVqggMDMSZM2ewdOlSREVFQXhyFsKnPJlI1a9fH2ZmZnjnnXcQFhYGc/O8M7qYm5vnW65SqYwebAAQBEExbSENxkRZGA/lYUyUhzFRFsZDeRgT5VFKTPTdvlFb6ejoCLVajcTERJ3yxMTEQq/FUqlUqFatGvz9/TFx4kT06dMHYWGaO3EfOXIESUlJqFKlCkxMTGBiYoK4uDhMnDgR3t7eBa6zWbNmyMnJwfXr10ti14iIiIiIiHQYNfkyMzND48aNERERIZeJooiIiAg0l2/s9GyiKMqTYQwaNAjnzp1DdHS0/Ofu7o7Jkydjz549Ba4jOjoaKpUq3xkWiYiIiIiInpfRhx2GhoZiyJAhCAgIQNOmTbFkyRKkpaXJsx8OHjwYHh4ecs9WWFgYAgIC4Ovri8zMTOzatQvh4eFYuXIlAMDBwQEODg462zA1NYWrqytq1qwJAIiMjMTJkyfRrl07WFtbIzIyEhMmTMDAgQNRqVIlA+49ERERERG9KIyefAUHB+P27duYMWMGEhIS4O/vj927d8uTcMTHx+uMoUxLS8PIkSNx48YNWFpaws/PDxs2bEBwcLDe2zQ3N8emTZswa9YsZGZmwsfHBxMmTNC5DoyIiIiIiJTp+nUgMhLIzgZMTYHmzYFCrjBSDEGSJMnYjSiLUlJSYGtri+TkZEXMdpiUlARnZ2ejX2xIGoyJsjAeysOYKA9joiyMh/IwJspw6xawcCFw5AiQmirCzy8Jly45o2JFFdq00dzCyM3N8O3SNzfgO4eIiIiIiBTv1i1g5Ejg1181vV1Vq2oSrapVNY+3b9c8f+uWsVtaMCZfRERERESkeAsXAhcuaJIte3tA2wGpUmkeV62qeb6A2/YqgtGv+SIiZdKOpU5LA6ysys5YaiIiIip/rl/XDDV0ctL0cuXH1FTz/KFDmvpKPG9h8kVEOp4cS52Sovk1SRQBGxsYdSw1MSEmIqLnU5a/RyIjNeclvr6F17OzA2JjgRMnlLlvTL6ISKYdS33hguaXI1/fx8nXgweasdSxscCKFWUnASursyE9iQkxERE9j/LwPZKWpmn3s+Y60dZJTTVMu4qKyRdRCSvLJ/tPjqV+sktfO5ba2vrxWOpPPzVeO/WhOxsS4OcHXLoEVKxYdr5ogPKZEJcXZfkXZCJ6cZSX7xErK02bRbHwBExbp2JFw7WtKJh8EZWQsn6yX17GUgN5v2i0syFlZQH375edLxqgfCXE5UV5+AWZyFD4I4XxlZfvkebNNcfZBw807S7Igweaes2bG6plRcPk6zll5GTALMcsT7lKUMFMbaZTryDPUzczJxO5Yi4ycjKQkZOhc98JAQLMTcx16krI/7ZuT9fNys2CKIkFtsPCxMLodc3V5hAEAQCQnZuNXCm3xOvmiDnIEXOeWffWLWDEyBxcuJgDJyfAy0WEk1sGHmVn4MEDFX7eAVyJNcPKFSq4uT17vWZqM6gElV5tMFWZQq1SF7lurpiLbDFbfu7QMeBBqubgnCsAgmQC1X+HCAm5EAVNXetKwNWrwOHjgGtlzbImKhOYqDR1RUlEVm5WgW0obl1JkpCZm6lX3U8XSjh/MRM+vpovGkkQkYMMSOoM2DqoYGWjxoULpli8GPjkk8LXqxbUMFWb6tWGkv7cx8Vp4uLgrIKp6eO6ucLjuiozwMEFOHAEiIkFfLzzHiP0/dwb6hgRFwecOCEiOzsDpqYZaNuygnwypvRjxK1bwISx5vjrggAnJ8DHNweCOgeiCCQnAz/vAC5fBZYu1SRgRTmeFOVzXxrHCFEUkSs+3u+njxFPe/IzV5S6SjhGPKtuUT73pXWMePqjWJrnEaVxjIi7kYXFn4k4dizvjxStWgHvTbSQf6QoC+cRt/4xx4kTmlEtgkk2mjaT4OX17PXqex6hT93iHCOuXwcOH82Bg0sOVGZAfntoYmoKJyc1Dh0CrlzNQeUqxTuPyLPeEj5GuFYGmrcGdu0wgbW1ieb7HZrv91whAxJUyM4Gku4BXbsCLh5Ajmi4Y0Shn+cn8CbLxaS9kVrQ6iCYVsjbTRDgFoCZgTPlx31+6FNgEOs61UVYhzD58YBtA5CSmZJv3er21bE46PH8mcN+GYbEtERkZWbBzNxM/gADgKeNJ1Z0WSE/HrlzJP5J+Sff9TpXcMY3r30jPw7dE4q/7/2db10bcxts7LVRfjxt3zT8efvPfOuaq83xY78f5cezD87GH7f+yLcuAPz6+q/y/+cfnY9j/xwrsO6Wvlvkg+ySE0sQcS2iwLobem6ArYUtAGDl6ZXYdWVXgXW/6f4NnK2cAQBrzq7BT5d+KrDu8s7LUcW2CiZOBDae/w5ire8hqAABEiwss5DxyAwSBEgiUOHoYvR9uTo+/RTYdnEb1kavLXC9816eh3ou9QAAOy/vxKozqwqsO6PNDDTxaAIAiLgagSUnlxRY972W76FVlVYAgKPxR7Hg2AL5ufh44GosUMFK87hq4ng4PmwPAHhQ4TQuu38k101PA6r6AlWqaB6PaDwCXWp0AQCcTzyP9/e/X2AbQvxD0KtWLwDA33f/RujvoQXWfb3u63ij3hua9iXHY9SuUQXW7enXE282fBPXrwM9ByYhzn+Y/Avf0/FwTu4Mm5h3kZ0NrN6QjOlnBha43vY+7TH+pfEANCc0fbf0LbBuS8+WmNpqqvy42/fdCqyrzzHi5k3g8mXARaiL2v8+PkZE+QxAjvqJY4QEpKUDNWsAbevlPUYkpSfl2wZDHyMyMjTvsbv3gNwcCRUrZiEtxRp+57bKPUZfxSj7GPHXBUD65RvU8HCGqSkQ77AGCZUeHyMkEUhPB1xcgdq1Hx8jAOC789/h+z+/L7ANi19ZjOoO1QEY5xghSRKG1xqObg26QaVS5TlGPG18s/FoX1VzjDh98zQ+OvxRgXUNdYwI+XEU7t8HcnMBtRqoVAmoUEFTV3uMAICktCQM2z6swPV2rtYZ7zZ5FwCQnJGMgT8Z9hiRng5UetQY3W1GwNTUGc2bqzDpVOmdR5T0MeLWLaD13FAkZP0NM3PA1ASAAEACsnOAnFQbtE/eKI8+UPJ5hPa4Zbt/AzIeWMPPLwmR2VvxyHM3HBw0P1haWOguU5zzCKB0jhHffw9M/nonsuuv0sQgHzX+nQGb1CaIjQX6TI7A/yosKXC9hZ1HPK00jhEZGUDKoRDcP94LTk6AmWsMrtUcg0ePzJCdLSArSzPiqF49TVyKcx4BFO8YkZ2ejT1v7XnmTZbZ80X0nLTD9Ww8geQCxiAL/3Xta4frKZFa/d8PrRIKPEDjv+clACZqgzSryCIjgYcP//uyL4R2NqQ/TkOxdzzMzdWEQigsHgAgaOrlFPyjrdFlZADnzwOpDwEzc8DcCjC3AJD7+MaYsbGAb8HfdUaXnq5JHKs7Fjw0V1Bp9u/uXU19Moxbt4A5i4Az6UBOjnyeDxMTyCfIZcGTP1CY3gbE3MfD1x+8Anj55j3RV6KFCzWfgQoums+ETNB8diwqAheOK3+Y25PHLUdTwP2/IeyO6cBNFZCYoBlOqT3RV6K0tP++Q57xPaKdpOLRIwAVDNGy4rGwAPq/DVz67xKIxH+ATC/Nj8JqE8DFJf+EWEnY81VM2p6vxLuJ+Wa3hh52mJSUBGdnZw47LOG6+gwX2LRJwOzZj4cfAYAgiKhcOQk3bjhDkv6LSa4ZrsaqMGsW0Kef8oYdxsUBAwZovhgrVSp42OH9+5phFxs3Qh5yoaQhRatXA4sWS/Cp9rju0/EQoIZKMkVsLDBhgoRBIcocdrh5M/Dxx4BvVRVMhPyHHQKaoTxXrwIffAD0D1bmsMPJU0Ts3An4+GjeY0/GRCVWQHa2Zh+6vpaFeWHKPEZo41HNxxxqlaauiBxIgu5n7sl4DHq9bAw71A4FlXLuw9zMDc2bq+BZpWwMO7ydaIKRI4E/L0hwdMmEre3jIW7JycDt2//1Qn5uAk8P5Q47vHULGDcO+OsvzbWqlewAnyoPEBfnjPv3VUi8m4HatR8PadV3vc9qQ0kfI65fB/r1A9RmWahkX/DnM/muBbKzgR9+ANw9lXke8d57kI9b5ibmUAkSPD2TEPdPJYiQkJ0NXLsGdOsGhIXlv15jDzv8/ntg1kc58PHNKXCSCpVkCklUIzYW+HBmDnr3Veaww6frXr8OHI/MQXrmDZiZOaNZM1WeoaCGHJqckpICFwcX9nyVNgsTC50PemH1irJOfZmbmEMURbkdqkKmf3nyAPosTx6Yy0JdU7UpTFHAT9HPUffJD2JBtFOfmqhMAElTV4AIE1hALVk8Tr6emPpUn/UWpQ3FqatWqeUDKADU9AXatgR+/RWwtdL9ZV+AGmpJjexs4F4S0L27pn5+VIJK7/dwUeoKgqBXXSsrQBIFCLkW8hdNfvHQzoZkba3feovSBq3nrdu2JbC8IpByX/fiYrWkWzf5PmBXUVPf7KkeyaJ87kvrGPHvP2aIPAK4OAAWJgCkp2KCx5O5HD1khoQb+l2Qb+hjRPYjzZem+onDrAqPP/daakFTLytdt9dSCZ/7p+vqThQkws9P/cREQWpMnKjWa/KQp48nhSnpY4R2MgHfqgJMTf+rK2ni4GinOZ5d+hNYtuRxL0tRPsulVRfQ/dx/sUTTzmpVH/9AATw5KYIFLv0JrFj27N6iop5HlGTdx/diMoOqkJ/3n7wXU39v5Z1HXL8O3eMWAO2FeCqYQpBUmp4WB+DYIRR43DL25755c8DW2gQP75sUOknF/Qf/XY/XwgQWJsU7jyipuvoeI7y9gSpVVEhKsoCzc+HnwEDpf+6zTApOGJ+k0ME2RGXHk1OfFkbpU58CwKRJQJ06ml/t7917vE+iqHl87ZrmF+TQgi/BMLonZ0MqjNJnQwI0XyytW2t+uc8u4AfD7Gzgzh2gbVsUePG3sWlPxuzsCq9nZ6epd+KEIVpVdOXpsw48nhX01181J/vaWUG1M6Jt3655/tYtY7e0YMWZpVWJyst+AOXnXkzl5bhVXr5HyhMmX0TPqTyd7Lu5aaZff+01zcE4NvbxX3a2psdL6dOzl7cvmvKQEJeXk7Hy9FkHdKeftrd/HB9tT0vVqo+nn1aq8nKCXF72Ayg/P1KUl+MWUD6+R8oTDjskek7ak/1ff9XcKyO/Xy21J/vduyv/ZN/NTTOk5fp1zRd8aqrmy7F5c+W3XWvSJM2XjPY+X5UqacpFUXPN2p07ZeeLRpsQL16s+cU7NlZ3yubu3TX7oeSEuLzcGLM8fdbLy339yssJcnnZD6D83IupvBy3gPLxPVKeMPkiKgHl6WRfy9tbmSdb+nj6i+bqVcDMTPNvxYpl74umrCfE5eVkDMj7Wbeze3wS8+BB2fmsP74up/B6T16Xo8TjQXk5QS4v+wGUnx8pytNxCyj73yPlCZMvohJQ3k72y4Onv2iysjQxKctfNGU1IS4vJ2NA+fkFubz0tJSXE+Tysh9a5eFHivJ03HpSWf0eKU+YfBGVkPJ4sl8eaGZDApKSAGfnZ59sUukoT73D5eEX5PLS01JeTpDLy35olZcfKcrTcYuUg8kXUQnjyT5RXuWxd7gs/4JcnnpaykMvC1D+TvTLw48U5fG4RcbH5IuIiAyCvcPKUZ56WspLL0t5PdEvyz9SADxuUclj8kVERAbF3mFlKE89LeWhlwXgib6S8bhFJYXJFxER0QuoPPa0lPVeFi2e6BOVX0y+iIiIXlDsaSEiMiwmX0RERC849rQQERkGD69EREREREQGwOSLiIiIiIjIAJh8ERERERERGQCTLyIiIiIiIgNg8kVERERERGQATL6IiIiIiIgMgMkXERERERGRATD5IiIiIiIiMgAmX0RERERERAZgYuwGlFWSJAEAUlJSjNwSQBRFPHz4EBYWFlCpmE8rAWOiLIyH8jAmysOYKAvjoTyMifIoKSbanECbIxSEyVcxPXz4EADg6elp5JYQEREREZESPHz4ELa2tgU+L0jPSs8oX6Io4t9//4W1tTUEQTBqW1JSUuDp6Yl//vkHNjY2Rm0LaTAmysJ4KA9jojyMibIwHsrDmCiPkmIiSRIePnwId3f3Qnvh2PNVTCqVCpUrVzZ2M3TY2NgY/Y1HuhgTZWE8lIcxUR7GRFkYD+VhTJRHKTEprMdLiwNWiYiIiIiIDIDJFxERERERkQEw+SoHzM3NMXPmTJibmxu7KfQfxkRZGA/lYUyUhzFRFsZDeRgT5SmLMeGEG0RERERERAbAni8iIiIiIiIDYPJFRERERERkAEy+iIiIiIiIDIDJFxERERERkQEw+SoHli9fDm9vb1hYWKBZs2Y4deqUsZv0QgoLC0OTJk1gbW0NZ2dn9OjRAzExMcZuFj1h/vz5EAQB48ePN3ZTXmg3b97EwIED4eDgAEtLS9SrVw9//PGHsZv1QsrNzcWHH34IHx8fWFpawtfXF3PmzAHn4jKcw4cPo1u3bnB3d4cgCPj55591npckCTNmzICbmxssLS3RoUMH/P3338Zp7AuisJhkZ2fjvffeQ7169WBlZQV3d3cMHjwY//77r/EaXM496zPypBEjRkAQBCxZssRg7SsqJl9l3ObNmxEaGoqZM2ciKioKDRo0QFBQEJKSkozdtBfOoUOHMGrUKJw4cQJ79+5FdnY2XnnlFaSlpRm7aQTg9OnT+PLLL1G/fn1jN+WFdv/+fbRs2RKmpqb47bff8Ndff2HRokWoVKmSsZv2QlqwYAFWrlyJL774AhcvXsSCBQvwySef4PPPPzd2014YaWlpaNCgAZYvX57v85988gmWLVuGVatW4eTJk7CyskJQUBAyMjIM3NIXR2ExSU9PR1RUFD788ENERUVh27ZtiImJQffu3Y3Q0hfDsz4jWj/99BNOnDgBd3d3A7WsmCQq05o2bSqNGjVKfpybmyu5u7tLYWFhRmwVSZIkJSUlSQCkQ4cOGbspL7yHDx9K1atXl/bu3Su1bdtWGjdunLGb9MJ67733pFatWhm7GfSfLl26SG+++aZOWa9evaQBAwYYqUUvNgDSTz/9JD8WRVFydXWVPv30U7nswYMHkrm5ufT9998boYUvnqdjkp9Tp05JAKS4uDjDNOoFVlA8bty4IXl4eEh//vmn5OXlJX322WcGb5u+2PNVhmVlZeHMmTPo0KGDXKZSqdChQwdERkYasWUEAMnJyQAAe3t7I7eERo0ahS5duuh8Vsg4tm/fjoCAAPTt2xfOzs5o2LAhvv76a2M364XVokULRERE4PLlywCA//3vfzh69CheffVVI7eMAODatWtISEjQOXbZ2tqiWbNm/J5XkOTkZAiCADs7O2M35YUkiiIGDRqEyZMno06dOsZuzjOZGLsBVHx37txBbm4uXFxcdMpdXFxw6dIlI7WKAM2BYPz48WjZsiXq1q1r7Oa80DZt2oSoqCicPn3a2E0hAFevXsXKlSsRGhqK999/H6dPn8bYsWNhZmaGIUOGGLt5L5ypU6ciJSUFfn5+UKvVyM3Nxccff4wBAwYYu2kEICEhAQDy/Z7XPkfGlZGRgffeew+vv/46bGxsjN2cF9KCBQtgYmKCsWPHGrspemHyRVQKRo0ahT///BNHjx41dlNeaP/88w/GjRuHvXv3wsLCwtjNIWh+mAgICMC8efMAAA0bNsSff/6JVatWMfkygh9++AEbN27Ed999hzp16iA6Ohrjx4+Hu7s740H0DNnZ2ejXrx8kScLKlSuN3ZwX0pkzZ7B06VJERUVBEARjN0cvHHZYhjk6OkKtViMxMVGnPDExEa6urkZqFY0ePRo7duzAgQMHULlyZWM354V25swZJCUloVGjRjAxMYGJiQkOHTqEZcuWwcTEBLm5ucZu4gvHzc0NtWvX1imrVasW4uPjjdSiF9vkyZMxdepU9O/fH/Xq1cOgQYMwYcIEhIWFGbtpBMjf5fyeVx5t4hUXF4e9e/ey18tIjhw5gqSkJFSpUkX+no+Li8PEiRPh7e1t7Obli8lXGWZmZobGjRsjIiJCLhNFEREREWjevLkRW/ZikiQJo0ePxk8//YT9+/fDx8fH2E164bVv3x7nz59HdHS0/BcQEIABAwYgOjoaarXa2E184bRs2TLPLRguX74MLy8vI7XoxZaeng6VSvdUQK1WQxRFI7WInuTj4wNXV1ed7/mUlBScPHmS3/NGpE28/v77b+zbtw8ODg7GbtILa9CgQTh37pzO97y7uzsmT56MPXv2GLt5+eKwwzIuNDQUQ4YMQUBAAJo2bYolS5YgLS0NISEhxm7aC2fUqFH47rvv8Msvv8Da2loej29rawtLS0sjt+7FZG1tneeaOysrKzg4OPBaPCOZMGECWrRogXnz5qFfv344deoUvvrqK3z11VfGbtoLqVu3bvj4449RpUoV1KlTB2fPnsXixYvx5ptvGrtpL4zU1FRcuXJFfnzt2jVER0fD3t4eVapUwfjx4zF37lxUr14dPj4++PDDD+Hu7o4ePXoYr9HlXGExcXNzQ58+fRAVFYUdO3YgNzdX/r63t7eHmZmZsZpdbj3rM/J08mtqagpXV1fUrFnT0E3Vj7GnW6Tn9/nnn0tVqlSRzMzMpKZNm0onTpwwdpNeSADy/Vu7dq2xm0ZP4FTzxvfrr79KdevWlczNzSU/Pz/pq6++MnaTXlgpKSnSuHHjpCpVqkgWFhZS1apVpenTp0uZmZnGbtoL48CBA/l+dwwZMkSSJM108x9++KHk4uIimZubS+3bt5diYmKM2+hyrrCYXLt2rcDv+wMHDhi76eXSsz4jT1P6VPOCJPE29kRERERERKWN13wREREREREZAJMvIiIiIiIiA2DyRUREREREZABMvoiIiIiIiAyAyRcREREREZEBMPkiIiIiIiIyACZfREREREREBsDki4iIiIiIyACYfBER0Qth1qxZ8Pf3L9IygiDg559/LpX2GGM7RERkXEy+iIiozBEEodC/WbNm5Vlm0qRJiIiIKNF2DB06FD169CjRdRIRUfllYuwGEBERFdWtW7fk/2/evBkzZsxATEyMXFaxYkX5/5IkITc3FxUrVtQpJyIiMjT2fBERUZnj6uoq/9na2kIQBPnxpUuXYG1tjd/+387dhETdrnEc/zqUppM2iEkG1mokXbjQCtxURNOLBIKLNlNMUAsRmlVUoBAIRUUEQUT0SlmBbdopUcHUKDgEwixqhIpCBUl6WdiLGE5ncUCY4zkPhwbnebDvZzX3XPf9v67tj/vPf2CA5uZmSkpKGBwcXPDa4YsXL4hEIlRVVbFq1Sq2bt3KyMhIXnNt27aNeDzOsWPHqKysZM2aNQtu4V6/fs2WLVtYsWIFDQ0NPH78eMFzxsfH2bdvH6FQiMrKStra2nj//j0Ao6OjlJWVcf/+/fn9Dx48oLS0lFevXuU1vyRpcRm+JElL0okTJzhz5gyZTIbGxsYF9enpaWKxGIODgwwPDxMOh2ltbWV6ejqvvrdv3yYYDJJKpTh37hw9PT3zASubzdLe3k5xcTGpVIorV65w/PjxnPM/f/5k165dlJeXk0wmGRoaYuXKlezevZvZ2Vk2bNjA+fPn6ezsZGxsjImJCTo6Ojh79iwNDQ15zS5JWly+dihJWpJ6enqIRCL/s759+/ac9dWrVwmFQjx79oy9e/f+dt/GxkZOnjwJQDgc5tKlSzx9+pRIJMKTJ08YHR3l0aNHrF27FoDTp0+zZ8+e+fN9fX1ks1muX79OUVERALdu3SIUCpFIJNi5cyednZ309/ezf/9+iouL2bRpE0eOHPntmSVJhWH4kiQtSRs3bvzL+ocPH+ju7iaRSDA1NcXc3Bzfv39nbGwsr77/ectWU1PD1NQUAJlMhtra2vngBdDS0pKzP51O8+bNG8rLy3P+n5mZ4e3bt/PrmzdvUldXRyAQ4OXLl/NBTZL0z2X4kiQtScFg8C/rsViMT58+cfHiRdavX09JSQktLS3Mzs7m1Xf58uU566KiIrLZ7P99/uvXrzQ3N3Pv3r0FtdWrV8//TqfTfPv2jUAgwOTkJDU1Nb8/tCSpIAxfkqQ/0tDQEJcvX6a1tRX490cuPn78uKg96+vrGR8fzwlLw8PDOXuampro6+ujurqaioqK//qcz58/c/DgQbq6upicnCQajTIyMkJpaemizi9Jyo8f3JAk/ZHC4TC9vb1kMhlSqRTRaHTRw8uOHTuoq6sjFouRTqdJJpN0dXXl7IlGo1RVVdHW1kYymeTdu3ckEgni8TgTExMAdHR0UFtbS3d3NxcuXGBubo6jR48u6uySpPwZviRJf6QbN27w5csXmpqaOHDgAPF4nOrq6kXtGQgEePjwIT9+/GDz5s0cPnyYU6dO5ewpKyvj+fPnrFu3jvb2durr6zl06BAzMzNUVFRw584d+vv76e3tZdmyZQSDQe7evcu1a9cYGBhY1PklSfkp+vXr16+/ewhJkiRJWuq8+ZIkSZKkAjB8SZIkSVIBGL4kSZIkqQAMX5IkSZJUAIYvSZIkSSoAw5ckSZIkFYDhS5IkSZIKwPAlSZIkSQVg+JIkSZKkAjB8SZIkSVIBGL4kSZIkqQD+BeHOZe4Fu9yHAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "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 Side-Stream Exploit\n",
+    "\n",
+    "When evaluating LLM-generated kernels, you're not just fighting measurement noise—you're fighting an optimizer that may discover exploits in your benchmarking harness.\n",
+    "\n",
+    "The exploit: launch work on a **side stream** to make the kernel appear instantaneous."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "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 3, trials 100\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Standard benchmark on tricky kernel: 0.1530 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": [
+    "**What happened:**\n",
+    "\n",
+    "Standard benchmarking tools (including `do_bench`) only record events on the default stream. So:\n",
+    "\n",
+    "1.  Benchmark starts timer on Stream A (the default)\n",
+    "2.  Kernel launches work on Stream B and returns immediately\n",
+    "3.  Benchmark stops timer on Stream A\n",
+    "\n",
+    "Stream A had no work, so the timer reports `~0ms`. Stream B is still running in the background.\n",
+    "\n",
+    "**Why this matters:** If your reward signal is \"lower time = better score,\" an agent that discovers this pattern gets rewarded for *broken* code.\n",
+    "\n",
+    "### How KernelBench Addresses This\n",
+    "\n",
+    "KernelBench's `host_time` method catches this exploit:\n",
+    "- Uses `torch.cuda.synchronize()` to wait for ALL streams, not just the default\n",
+    "- Compares host and device timings to detect discrepancies\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 CPU overhead. If `host_time` and `cuda_event` agree within a few percent, the kernel is likely honest.\n",
+    "\n",
+    "**Other mitigations:** Static analysis to reject submissions that create `torch.cuda.Stream()` objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "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.5905 ms\n",
+      "Robust benchmark on normal kernel: 21.5177 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": 25,
+   "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 100\n",
+      "[Profiling] Using timing method: host_time\n",
+      "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n",
+      "[Profiling] Using device: cuda:0 NVIDIA H200, warm up 3, trials 100\n",
+      "\n",
+      "Tricky kernel with cuda_event:  0.1310 ms (FOOLED!)\n",
+      "Tricky kernel with host_time:   21.6000 ms (CORRECT)\n",
+      "Normal kernel with host_time:   21.5000 ms (reference)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "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=100, 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=100, 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=100, 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 blazing-fast kernel that returns nonsense is just a very efficient bug. Always verify your kernel produces correct outputs before benchmarking."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "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 3, trials 100\n",
+      "Kernel time: 0.0646 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": [
+    "Fully ensuring kernel correctness is complex due to a range of factors (quantization being the most notable), meaning that \"matching\" a baseline isn't always binary. To avoid false negatives, one approach is to scale your error margins based on data precision. as lower precision typically requires a wider tolerance (this is a technique we use at KernelBench).\n",
+    "\n",
+    "For an in-depth discussion of this topic, see [Towards a Reliable Kernel Correctness Check in Matrix Multiplication](https://deep-reinforce.com/correctness_check.html)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sanity Checking: Roofline Analysis\n",
+    "\n",
+    "Once you have reliable timing numbers, you'll want to sanity-check them: Are these results physically possible? How close am I to the hardware's theoretical maximum?\n",
+    "\n",
+    "This is where **roofline analysis** comes in. It helps you understand whether your kernel is **compute-bound** (limited by FLOPS) or **memory-bound** (limited by bandwidth), and how much headroom you have left.\n",
+    "\n",
+    "We won't cover it in detail here, but the [JAX Scaling Book chapter on Roofline](https://jax-ml.github.io/scaling-book/roofline/) is an excellent resource."
+   ]
+  },
+  {
+   "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 wrong numbers if you're not careful.\n",
+    "\n",
+    "### KernelBench's Timing Module\n",
+    "\n",
+    "We've packaged all these best practices in `src/timing.py`:\n",
+    "\n",
+    "| Function | Purpose |\n",
+    "|----------|---------|\n",
+    "| `get_timing_function(method)` | Returns timing function by name |\n",
+    "| `clear_l2_cache(device)` | L2 cache flushing |\n",
+    "| `get_timing_stats(times)` | Statistical aggregation (mean, std, min, max) |\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=3, 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 <freq>`. 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.10.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/notebooks/tutorial.ipynb b/notebooks/tutorial.ipynb
index ccb6a0fe..0d388168 100644
--- a/notebooks/tutorial.ipynb
+++ b/notebooks/tutorial.ipynb
@@ -1 +1,697 @@
-{"cells":[{"cell_type":"markdown","metadata":{"id":"DrHLiPZrHUGL"},"source":["# KernelBench: Tutorial [NeurIPS '25 Tutorial]\n","\n","\n","In this tutorial we will walk through the basics of KernelBench and let you try an example!\n","You can even do this in a Google Colab on T4 GPU.\n","\n","**ACTION: Make a copy of this Google Colab**\n","\n","We will use the open-source repo of [KernelBench](https://github.com/ScalingIntelligence/KernelBench) from Stanford's [Scaling Intelligence Lab](https://scalingintelligence.stanford.edu/).\n","\n","Made by Simon Guo, William Hu, Omar Abul-Hassan. Last updated Dec '25.\n","\n","Run this on Google Colab or your local machine with GPU.\n","\n","Contact: {simonguo, willhu}@stanford.edu"]},{"cell_type":"markdown","metadata":{"id":"S1YcMhdPdzgr"},"source":["### Set up\n","KernelBench needs to run on GPU (as we need to evaluate GPU kernels).\n","\n","We first check our runtime to confirm that we have a GPU."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"OfQmvwxRnAsn"},"outputs":[],"source":["!nvidia-smi"]},{"cell_type":"markdown","metadata":{"id":"hd6vWzvlel9I"},"source":["Next, let's set up KernelBench 🍿"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ovSHH67nhqAv"},"outputs":[],"source":["!git clone https://github.com/ScalingIntelligence/KernelBench.git"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"X9fxf6dokOsY"},"outputs":[],"source":["%cd /content/KernelBench"]},{"cell_type":"markdown","metadata":{"id":"BansUz9GetpW"},"source":["Download dependencies! Ignore if you are running this locally, only follow those if you are on Colab."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TiUQHO5FKJ58"},"outputs":[],"source":["# Latest KernelBench uses PyTorch 2.9.0 (latest version that supports Blackwell)\n","# !pip install -r requirements.txt\n","\n","# However, for this exercise, we will use the latest pytorch that ship with Google colab\n","import torch\n","torch.__version__"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"iDmolJHgK0pY"},"outputs":[],"source":["# here is a min set of our requirements\n","!pip install pydra_config\n","!pip install modal\n","!pip install litellm\n","!pip install ninja\n","!pip install tomli"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1tNgE_0EkJa4"},"outputs":[],"source":["# install repo package\n","!pip install -e ."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"L18KV1JIlr3d"},"outputs":[],"source":["import os\n","# temporary directory for storing kernels\n","directory = \"tmp\"\n","if not os.path.exists(directory):\n","  os.makedirs(directory)"]},{"cell_type":"markdown","metadata":{"id":"TJWcEPbFH_X1"},"source":["## KernelBench Task Format\n","\n","KernelBench is a benchmark and environment for evaluating LLM's ability to generate efficient GPU kernels. You can read more from our [paper](https://arxiv.org/abs/2502.10517).\n","\n","\n","Concretely, KernelBench tasks LMs with generating optimized CUDA kernels for a given target PyTorch model architecture and conducts automated evaluation\n","\n","* Input: `Model` as PyTorch reference\n","* Output: `ModelNew` of PyTorch + inline CUDA kernel.\n","\n","The model has freedom to choose which part of the input PyTorch ops it would optimize and generate CUDA kernels."]},{"cell_type":"markdown","metadata":{"id":"7RR_AKLEIH9s"},"source":["![KernelBench Flow.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"vPks2ppBe0fz"},"source":["As a minimum example, we show the case for **Element-wise Addition**.\n","\n","KernelBench relies on comparing two implementations:\n","1.  **Reference (`Model`):** The ground-truth PyTorch code.\n","2.  **Generation (`ModelNew`):** The LLM-generated code containing an inline C++/CUDA kernel.\n","\n","Here we save them to locally to demonstrate a minimum evaluation flow.\n","\n","First, we show the PyTorch reference for element-wise addition."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"X08GwJoTkSVL"},"outputs":[],"source":["ex_add_model_ref = '''\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F\n","\n","\n","class Model(nn.Module):\n","    def __init__(self) -> None:\n","        super().__init__()\n","\n","    def forward(self, a, b):\n","        return a + b\n","\n","\n","def get_inputs():\n","    # randomly generate input tensors based on the model architecture\n","    a = torch.randn(1, 128).cuda()\n","    b = torch.randn(1, 128).cuda()\n","    return [a, b]\n","\n","\n","def get_init_inputs():\n","    # randomly generate tensors required for initialization based on the model architecture\n","    return []\n","'''\n","\n","\n","with open(\"tmp/ex_add_model_ref.py\", \"w\") as f:\n","  f.write(ex_add_model_ref)"]},{"cell_type":"markdown","metadata":{"id":"5HlxdGxLfC-x"},"source":["Here, we have a PyTorch module `ModelNew` with **inline `cuda` kernel**. This would be typically be the AI-generated kernel."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TzBlFv4EmBXj"},"outputs":[],"source":["ex_add_model_generation = '''\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F\n","from torch.utils.cpp_extension import load_inline\n","\n","# Define the custom CUDA kernel for element-wise addition\n","elementwise_add_source = \"\"\"\n","#include <torch/extension.h>\n","#include <cuda_runtime.h>\n","\n","__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) {\n","    int idx = blockIdx.x * blockDim.x + threadIdx.x;\n","    if (idx < size) {\n","        out[idx] = a[idx] + b[idx];\n","    }\n","}\n","\n","torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b) {\n","    auto size = a.numel();\n","    auto out = torch::zeros_like(a);\n","\n","    const int block_size = 256;\n","    const int num_blocks = (size + block_size - 1) / block_size;\n","\n","    elementwise_add_kernel<<<num_blocks, block_size>>>(a.data_ptr<float>(), b.data_ptr<float>(), out.data_ptr<float>(), size);\n","\n","    return out;\n","}\n","\"\"\"\n","\n","elementwise_add_cpp_source = (\n","    \"torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b);\"\n",")\n","\n","# Compile the inline CUDA code for element-wise addition\n","elementwise_add = load_inline(\n","    name=\"elementwise_add\",\n","    cpp_sources=elementwise_add_cpp_source,\n","    cuda_sources=elementwise_add_source,\n","    functions=[\"elementwise_add_cuda\"],\n","    verbose=True,\n","    extra_cflags=[\"\"],\n","    extra_ldflags=[\"\"],\n",")\n","\n","\n","class ModelNew(nn.Module):\n","    def __init__(self) -> None:\n","        super().__init__()\n","        self.elementwise_add = elementwise_add\n","\n","    def forward(self, a, b):\n","        return self.elementwise_add.elementwise_add_cuda(a, b)\n","'''\n","\n","with open(\"tmp/ex_add_model_generation.py\", \"w\") as f:\n","  f.write(ex_add_model_generation)"]},{"cell_type":"markdown","metadata":{"id":"qvAh7qSJfG4Z"},"source":["Run `run_and_check.py`\\ with the generation (with inline cuda, here `ex_add_model_generation`) against refernece (pure PyTorch, here `ex_add_model_ref`)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"imK4xekPmMTH"},"outputs":[],"source":["!python3 scripts/run_and_check.py ref_origin=local gpu_arch=\"['Turing']\"  ref_arch_src_path=tmp/ex_add_model_ref.py kernel_src_path=tmp/ex_add_model_generation.py"]},{"cell_type":"markdown","metadata":{"id":"e2t6qmqQP-rv"},"source":["Note PyTorch `torch.compile` has some runtime (beyond compile!) overhead. Note it also has many modes for compilation, while performance varies based on hardware SM generation and PyTorch version.\n","\n","For Level 1, we recommend compare against Torch Eager.\n","For Level 2/3, we recommend compare against `torch.compile`."]},{"cell_type":"markdown","metadata":{"id":"hk4pRkSTLIhH"},"source":["# Evaluating a generated KernelBench kernel example"]},{"cell_type":"markdown","metadata":{"id":"O_udy-5YMz_a"},"source":["We designed KernelBench with 3 levels (total 250 tasks), each challenging in a distinct way:\n","\n","\n","* **Level 1 Single Operators** (100): e.g., matmul, conv; this is actually quite hard since we would be competing against highly-optimized libraries\n","* **Level 2 Sequence of Operators** (100): help test model’s ability to conduct kernel fusion, a key technique used by graph compilers\n","* **Level 3 End-to-end architectures** (50): like a Vision Transformer or Mamba block, evaluate model’s ability to identify optimization opportunities within whole model architecture\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"uwiPLh0OW9QS"},"outputs":[],"source":["# @title Select KernelBench Problem Configuration 🎛️\n","# @markdown Select the difficulty level (1-3) and specific problem ID.\n","# @markdown * **Level 1 & 2:** 100 Problems\n","# @markdown * **Level 3:** 50 Problems\n","\n","level = 1 # @param {type:\"slider\", min:1, max:3, step:1}\n","problem_id = 1 # @param {type:\"slider\", min:1, max:100, step:1}\n","\n","# Input Validation Logic\n","max_problems = 50 if level == 3 else 100\n","\n","if problem_id > max_problems:\n","    print(f\"⚠️ Warning: Level {level} only has {max_problems} problems.\")\n","    print(f\"   -> Automatically adjusting Problem ID from {problem_id} to {max_problems}.\")\n","    problem_id = max_problems\n","\n","print(f\"Selected: Level {level}, Problem ID {problem_id}\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1FE37L7AXbgY"},"outputs":[],"source":["from datasets import load_dataset\n","import os\n","\n","# Load the dataset based on the sliders above\n","dataset = load_dataset(\"ScalingIntelligence/KernelBench\")\n","level_string = \"level_\" + f\"{level}\"\n","\n","try:\n","    # Fetch the problem\n","    target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n","    problem_name = dataset[level_string][problem_id][\"name\"]\n","\n","    print(f\"✅ Successfully loaded: {problem_name}\")\n","    print(\"=\"*80)\n","    print(target_kernel_reference)\n","\n","    # Save to file for the next steps\n","    with open(\"tmp/reference.py\", \"w\") as f:\n","      f.write(target_kernel_reference)\n","\n","except IndexError:\n","    print(f\"❌ Error: Problem ID {problem_id} does not exist in Level {level}. Please adjust the slider to a lower number.\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"FFs0B2H7NJQU"},"outputs":[],"source":["target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n","print(target_kernel_reference)\n","\n","with open(\"tmp/reference.py\", \"w\") as f:\n","  f.write(target_kernel_reference)"]},{"cell_type":"markdown","metadata":{"id":"fiSSqpKgXfwy"},"source":["\n","Now we construct the context to condition the LM for generation.\n","\n","The context consists of:\n","1.  **PyTorch Source:** We take the reference PyTorch code of the KernelBench problem.\n","2.  **Few-Shot Examples [Optional]:** We include a few examples of hand-written pairs of `Model`, `ModelNew`. By default, we use the pair of element-wise add example to show model the correct syntax and class structure, (aka how to use   `torch.utils.cpp_extension.load_inline`).\n","3.  **Hardware Context [Optional]:** We inject specific GPU specs (e.g., **SRAM size, memory bandwidth**) into the prompt. This allows the LLM to potentially calculate adjust tile sizes (e.g., `BLOCK_SIZE`) for your specific hardware (T4 vs A100).\n","4. **Backend & Precision**: You can specify which backend (`cuda` or other DSLs) and numerical percision.\n","\n","Of course you can also customize your prompt, or plug in your favorite agentic systems. For this tutorial, you will **copy** (or modify) the generated prompt below, send it to your favorite model / coding agent, and **paste** the result back!"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ShZPHpnR5axP"},"outputs":[],"source":["from src.prompt_constructor_toml import get_prompt_for_backend\n","\n","# Here is an example of a constructed context with hardware context\n","# This injects specs (memory bandwidth, cache size) from src/prompts/hardware/gpu_specs.py\n","# helping the LLM optimize tile sizes for your specific GPU.\n","\n","prompt = get_prompt_for_backend(\n","    ref_arch_src=target_kernel_reference,\n","    backend=\"cuda\",   # You can also try \"triton\" or \"tilelang\" here!\n","    option=\"one_shot\", # <--- show example of generation format via minimum example\n","    include_hardware=True, # <--- Enable hardware specific context\n","    gpu_name=\"T4\"          # <--- Specify your GPU (matches keys in gpu_specs.py)\n",")\n","\n","print(\"=\"*40)\n","print(\"  ⬇️ COPY THIS PROMPT TO YOUR LLM ⬇️  \")\n","print(\"=\"*40)\n","print(prompt)\n","print(\"=\"*40)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"MIbCOK5GXh_U"},"outputs":[],"source":["target_kernel_generation = \"paste the output here\""]},{"cell_type":"markdown","source":["For this tutorial, we have pre-generated a solution for the Matrix Multiplication problem (level=1, problem=1) using a standard LLM.\n","\n","**Note:** The kernel below is a naive CUDA implementation. While functionally correct, it's *slower* than PyTorch (which uses highly optimized cuBLAS). This is expected in Level 1. The challenge is to prompt the LLM to write tiled/shared-memory implementations to beat cuBLAS."],"metadata":{"id":"8yKcKFlV87PC"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"364q0fwGLE2r"},"outputs":[],"source":["# Here is an example model-generated kernel if you chose to optimize Level 1 Problem 1\n","\n","# By the way, this is a very slow and naive implementation in cuda; lots of room for improvement, try how you can beat this with your own generation!\n","\n","level_1_problem_1_sample_0_kernel = '''import torch\n","import torch.nn as nn\n","from torch.utils.cpp_extension import load_inline\n","\n","# Define the custom CUDA kernel for matrix multiplication\n","matrix_multiply_source = \"\"\"\n","#include <torch/extension.h>\n","#include <cuda_runtime.h>\n","\n","__global__ void matrix_multiply_kernel(const float* A, const float* B, float* C, int N) {\n","    int row = blockIdx.x * blockDim.x + threadIdx.x;\n","    int col = blockIdx.y * blockDim.y + threadIdx.y;\n","\n","    if (row < N && col < N) {\n","        float sum = 0.0f;\n","        for (int i = 0; i < N; i++) {\n","            sum += A[row * N + i] * B[i * N + col];\n","        }\n","        C[row * N + col] = sum;\n","    }\n","}\n","\n","torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B) {\n","    auto N = A.size(0);\n","    auto C = torch::zeros_like(A);\n","\n","    const int block_size = 16;\n","    const int num_blocks_x = (N + block_size - 1) / block_size;\n","    const int num_blocks_y = (N + block_size - 1) / block_size;\n","\n","    dim3 block(block_size, block_size);\n","    dim3 grid(num_blocks_x, num_blocks_y);\n","\n","    matrix_multiply_kernel<<<grid, block>>>(A.data_ptr<float>(), B.data_ptr<float>(), C.data_ptr<float>(), N);\n","\n","    return C;\n","}\n","\"\"\"\n","\n","matrix_multiply_cpp_source = (\n","    \"torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B);\"\n",")\n","\n","# Compile the inline CUDA code for matrix multiplication\n","matrix_multiply = load_inline(\n","    name=\"matrix_multiply\",\n","    cpp_sources=matrix_multiply_cpp_source,\n","    cuda_sources=matrix_multiply_source,\n","    functions=[\"matrix_multiply_cuda\"],\n","    verbose=True,\n","    extra_cflags=[\"\"],\n","    extra_ldflags=[\"\"],\n",")\n","\n","\n","class ModelNew(nn.Module):\n","    def __init__(self):\n","        super(ModelNew, self).__init__()\n","        self.matrix_multiply = matrix_multiply\n","\n","    def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:\n","        return self.matrix_multiply.matrix_multiply_cuda(A, B)\n","'''\n","\n","# uncomment if you want to use this example\n","target_kernel_generation = level_1_problem_1_sample_0_kernel"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"7R9mvYJ3NVr7"},"outputs":[],"source":["with open(\"tmp/generation.py\", \"w\") as f:\n","  f.write(target_kernel_generation)"]},{"cell_type":"markdown","metadata":{"id":"HkbNLSZLNs7t"},"source":["## Check your Generated Kernel Performance\n"]},{"cell_type":"markdown","metadata":{"id":"UFxnQx9mRR8K"},"source":["Note some of the KernelBench problem sizes are quite big! This is too ensure [CPU overhead](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) is not too significant. As our tensor sizes are calibrated on NVIDIA H100, you might run into OOM on a small GPU for some problems; reduce the problem sizes for those!\n","\n","Adjust `precision`, `num_trials`, `backend` etc as needed!"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"OrtiIIM4Lw2p"},"outputs":[],"source":["!python scripts/run_and_check.py ref_origin=kernelbench gpu_arch=\"['Turing']\" level={level} problem_id={problem_id} kernel_src_path=tmp/generation.py"]},{"cell_type":"markdown","source":["When you run the command above, look for these lines in the logs for evaluation result:\n","\n","1.  **`[Eval] Correctness: True/False`**:\n","    *   This runs the kernel against the reference with random inputs with `num_correct_trials`.\n","    *   For **FP32**, we enforce `atol=1e-4`. Following PyTorch guideline, we have different tolerance for various precisions.\n","    *   If this fails, the kernel is functionally invalid, and speedup metrics are ignored.\n","\n","2.  **`[Speedup] Speedup over eager: X.XXx`**:\n","    * For Speedup we run both the reference and generated kernel `num_trials` time (100 typically), and compute speedup!\n","    *   `< 1.0x`: The generated kernel is slower than PyTorch (common for naive implementations).\n","    *   `> 1.0x`: The generated kernel is faster.\n","\n","3.  **`[Speedup] Speedup over torch.compile: Y.YYx`**:\n","    *   This compares against `torch.compile(mode=\"inductor\")`. This is the harder boss to beat for Level 2/3 problems involving kernel fusions!"],"metadata":{"id":"zn3PRPti-IJK"}},{"cell_type":"markdown","source":["## Next Steps\n","\n","Congrats on finishing this tutorial! We show the minimum usage of KernelBench. Beyond acting as a benchmark, KernelBench tasks also serve as an environment to develop many techniques to tackle AI-generating GPU kernels. We have noted down many of the developments we are aware [here](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub), from building agentic systems to applying reinforcement learning.\n","\n","As a pro tip, you should be always **careful about speedup numbers**; kernel engineers and existing compilers are already pretty good, so a >2x speedup for anything is highly unlikely. While we are constantly improving our eval to be more robust and comprehensive, you should always **read the generated kernel in detail** to avoid reward hacking!  \n","\n","As a KernelBench is an open-soruce project, you are welcome to contribute to our [Github](https://github.com/ScalingIntelligence/KernelBench) to add new features or make it better!\n","\n","Have fun playing with KernelBench! Can't wait to see what you find out!\n"],"metadata":{"id":"sr4VfQBheBYP"}},{"cell_type":"code","source":[],"metadata":{"id":"KGFQiYxAeoZM"},"execution_count":null,"outputs":[]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"kernel-bench","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.10.18"}},"nbformat":4,"nbformat_minor":0}
\ No newline at end of file
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DrHLiPZrHUGL"
+   },
+   "source": [
+    "# KernelBench: Tutorial [NeurIPS '25 Tutorial]\n",
+    "\n",
+    "\n",
+    "In this tutorial we will walk through the basics of KernelBench and let you try an example!\n",
+    "You can even do this in a Google Colab on T4 GPU.\n",
+    "\n",
+    "**ACTION: Make a copy of this Google Colab**\n",
+    "\n",
+    "We will use the open-source repo of [KernelBench](https://github.com/ScalingIntelligence/KernelBench) from Stanford's [Scaling Intelligence Lab](https://scalingintelligence.stanford.edu/).\n",
+    "\n",
+    "Made by Simon Guo, William Hu, Omar Abul-Hassan. Last updated Dec '25.\n",
+    "\n",
+    "Run this on Google Colab or your local machine with GPU.\n",
+    "\n",
+    "Contact: {simonguo, willhu}@stanford.edu"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "S1YcMhdPdzgr"
+   },
+   "source": [
+    "### Set up\n",
+    "KernelBench needs to run on GPU (as we need to evaluate GPU kernels).\n",
+    "\n",
+    "We first check our runtime to confirm that we have a GPU."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "OfQmvwxRnAsn"
+   },
+   "outputs": [],
+   "source": [
+    "!nvidia-smi"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hd6vWzvlel9I"
+   },
+   "source": [
+    "Next, let's set up KernelBench 🍿"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ovSHH67nhqAv"
+   },
+   "outputs": [],
+   "source": [
+    "!git clone https://github.com/ScalingIntelligence/KernelBench.git"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "X9fxf6dokOsY"
+   },
+   "outputs": [],
+   "source": [
+    "%cd /content/KernelBench"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "BansUz9GetpW"
+   },
+   "source": [
+    "Download dependencies! Ignore if you are running this locally, only follow those if you are on Colab."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TiUQHO5FKJ58"
+   },
+   "outputs": [],
+   "source": [
+    "# Latest KernelBench uses PyTorch 2.9.0 (latest version that supports Blackwell)\n",
+    "# !pip install -r requirements.txt\n",
+    "\n",
+    "# However, for this exercise, we will use the latest pytorch that ship with Google colab\n",
+    "import torch\n",
+    "torch.__version__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iDmolJHgK0pY"
+   },
+   "outputs": [],
+   "source": [
+    "# here is a min set of our requirements\n",
+    "!pip install pydra_config\n",
+    "!pip install modal\n",
+    "!pip install litellm\n",
+    "!pip install ninja\n",
+    "!pip install tomli"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1tNgE_0EkJa4"
+   },
+   "outputs": [],
+   "source": [
+    "# install repo package\n",
+    "!pip install -e ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "L18KV1JIlr3d"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "# temporary directory for storing kernels\n",
+    "directory = \"tmp\"\n",
+    "if not os.path.exists(directory):\n",
+    "  os.makedirs(directory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TJWcEPbFH_X1"
+   },
+   "source": [
+    "## KernelBench Task Format\n",
+    "\n",
+    "KernelBench is a benchmark and environment for evaluating LLM's ability to generate efficient GPU kernels. You can read more from our [paper](https://arxiv.org/abs/2502.10517).\n",
+    "\n",
+    "\n",
+    "Concretely, KernelBench tasks LMs with generating optimized CUDA kernels for a given target PyTorch model architecture and conducts automated evaluation\n",
+    "\n",
+    "* Input: `Model` as PyTorch reference\n",
+    "* Output: `ModelNew` of PyTorch + inline CUDA kernel.\n",
+    "\n",
+    "The model has freedom to choose which part of the input PyTorch ops it would optimize and generate CUDA kernels."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7RR_AKLEIH9s"
+   },
+   "source": [
+    "![KernelBench Flow.png](data:image/png;base64,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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vPks2ppBe0fz"
+   },
+   "source": [
+    "As a minimum example, we show the case for **Element-wise Addition**.\n",
+    "\n",
+    "KernelBench relies on comparing two implementations:\n",
+    "1.  **Reference (`Model`):** The ground-truth PyTorch code.\n",
+    "2.  **Generation (`ModelNew`):** The LLM-generated code containing an inline C++/CUDA kernel.\n",
+    "\n",
+    "Here we save them to locally to demonstrate a minimum evaluation flow.\n",
+    "\n",
+    "First, we show the PyTorch reference for element-wise addition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "X08GwJoTkSVL"
+   },
+   "outputs": [],
+   "source": [
+    "ex_add_model_ref = '''\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "\n",
+    "class Model(nn.Module):\n",
+    "    def __init__(self) -> None:\n",
+    "        super().__init__()\n",
+    "\n",
+    "    def forward(self, a, b):\n",
+    "        return a + b\n",
+    "\n",
+    "\n",
+    "def get_inputs():\n",
+    "    # randomly generate input tensors based on the model architecture\n",
+    "    a = torch.randn(1, 128).cuda()\n",
+    "    b = torch.randn(1, 128).cuda()\n",
+    "    return [a, b]\n",
+    "\n",
+    "\n",
+    "def get_init_inputs():\n",
+    "    # randomly generate tensors required for initialization based on the model architecture\n",
+    "    return []\n",
+    "'''\n",
+    "\n",
+    "\n",
+    "with open(\"tmp/ex_add_model_ref.py\", \"w\") as f:\n",
+    "  f.write(ex_add_model_ref)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5HlxdGxLfC-x"
+   },
+   "source": [
+    "Here, we have a PyTorch module `ModelNew` with **inline `cuda` kernel**. This would be typically be the AI-generated kernel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TzBlFv4EmBXj"
+   },
+   "outputs": [],
+   "source": [
+    "ex_add_model_generation = '''\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torch.utils.cpp_extension import load_inline\n",
+    "\n",
+    "# Define the custom CUDA kernel for element-wise addition\n",
+    "elementwise_add_source = \"\"\"\n",
+    "#include <torch/extension.h>\n",
+    "#include <cuda_runtime.h>\n",
+    "\n",
+    "__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) {\n",
+    "    int idx = blockIdx.x * blockDim.x + threadIdx.x;\n",
+    "    if (idx < size) {\n",
+    "        out[idx] = a[idx] + b[idx];\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b) {\n",
+    "    auto size = a.numel();\n",
+    "    auto out = torch::zeros_like(a);\n",
+    "\n",
+    "    const int block_size = 256;\n",
+    "    const int num_blocks = (size + block_size - 1) / block_size;\n",
+    "\n",
+    "    elementwise_add_kernel<<<num_blocks, block_size>>>(a.data_ptr<float>(), b.data_ptr<float>(), out.data_ptr<float>(), size);\n",
+    "\n",
+    "    return out;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "elementwise_add_cpp_source = (\n",
+    "    \"torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b);\"\n",
+    ")\n",
+    "\n",
+    "# Compile the inline CUDA code for element-wise addition\n",
+    "elementwise_add = load_inline(\n",
+    "    name=\"elementwise_add\",\n",
+    "    cpp_sources=elementwise_add_cpp_source,\n",
+    "    cuda_sources=elementwise_add_source,\n",
+    "    functions=[\"elementwise_add_cuda\"],\n",
+    "    verbose=True,\n",
+    "    extra_cflags=[\"\"],\n",
+    "    extra_ldflags=[\"\"],\n",
+    ")\n",
+    "\n",
+    "\n",
+    "class ModelNew(nn.Module):\n",
+    "    def __init__(self) -> None:\n",
+    "        super().__init__()\n",
+    "        self.elementwise_add = elementwise_add\n",
+    "\n",
+    "    def forward(self, a, b):\n",
+    "        return self.elementwise_add.elementwise_add_cuda(a, b)\n",
+    "'''\n",
+    "\n",
+    "with open(\"tmp/ex_add_model_generation.py\", \"w\") as f:\n",
+    "  f.write(ex_add_model_generation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qvAh7qSJfG4Z"
+   },
+   "source": [
+    "Run `run_and_check.py`\\ with the generation (with inline cuda, here `ex_add_model_generation`) against refernece (pure PyTorch, here `ex_add_model_ref`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "imK4xekPmMTH"
+   },
+   "outputs": [],
+   "source": [
+    "!python3 scripts/run_and_check.py ref_origin=local gpu_arch=\"['Turing']\"  ref_arch_src_path=tmp/ex_add_model_ref.py kernel_src_path=tmp/ex_add_model_generation.py"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "e2t6qmqQP-rv"
+   },
+   "source": [
+    "Note PyTorch `torch.compile` has some runtime (beyond compile!) overhead. Note it also has many modes for compilation, while performance varies based on hardware SM generation and PyTorch version.\n",
+    "\n",
+    "For Level 1, we recommend compare against Torch Eager.\n",
+    "For Level 2/3, we recommend compare against `torch.compile`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hk4pRkSTLIhH"
+   },
+   "source": [
+    "# Evaluating a generated KernelBench kernel example"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "O_udy-5YMz_a"
+   },
+   "source": [
+    "We designed KernelBench with 3 levels (total 250 tasks), each challenging in a distinct way:\n",
+    "\n",
+    "\n",
+    "* **Level 1 Single Operators** (100): e.g., matmul, conv; this is actually quite hard since we would be competing against highly-optimized libraries\n",
+    "* **Level 2 Sequence of Operators** (100): help test model’s ability to conduct kernel fusion, a key technique used by graph compilers\n",
+    "* **Level 3 End-to-end architectures** (50): like a Vision Transformer or Mamba block, evaluate model’s ability to identify optimization opportunities within whole model architecture\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uwiPLh0OW9QS"
+   },
+   "outputs": [],
+   "source": [
+    "# @title Select KernelBench Problem Configuration 🎛️\n",
+    "# @markdown Select the difficulty level (1-3) and specific problem ID.\n",
+    "# @markdown * **Level 1 & 2:** 100 Problems\n",
+    "# @markdown * **Level 3:** 50 Problems\n",
+    "\n",
+    "level = 1 # @param {type:\"slider\", min:1, max:3, step:1}\n",
+    "problem_id = 1 # @param {type:\"slider\", min:1, max:100, step:1}\n",
+    "\n",
+    "# Input Validation Logic\n",
+    "max_problems = 50 if level == 3 else 100\n",
+    "\n",
+    "if problem_id > max_problems:\n",
+    "    print(f\"⚠️ Warning: Level {level} only has {max_problems} problems.\")\n",
+    "    print(f\"   -> Automatically adjusting Problem ID from {problem_id} to {max_problems}.\")\n",
+    "    problem_id = max_problems\n",
+    "\n",
+    "print(f\"Selected: Level {level}, Problem ID {problem_id}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1FE37L7AXbgY"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "import os\n",
+    "\n",
+    "# Load the dataset based on the sliders above\n",
+    "dataset = load_dataset(\"ScalingIntelligence/KernelBench\")\n",
+    "level_string = \"level_\" + f\"{level}\"\n",
+    "\n",
+    "try:\n",
+    "    # Fetch the problem\n",
+    "    target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n",
+    "    problem_name = dataset[level_string][problem_id][\"name\"]\n",
+    "\n",
+    "    print(f\"✅ Successfully loaded: {problem_name}\")\n",
+    "    print(\"=\"*80)\n",
+    "    print(target_kernel_reference)\n",
+    "\n",
+    "    # Save to file for the next steps\n",
+    "    with open(\"tmp/reference.py\", \"w\") as f:\n",
+    "      f.write(target_kernel_reference)\n",
+    "\n",
+    "except IndexError:\n",
+    "    print(f\"❌ Error: Problem ID {problem_id} does not exist in Level {level}. Please adjust the slider to a lower number.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "FFs0B2H7NJQU"
+   },
+   "outputs": [],
+   "source": [
+    "target_kernel_reference = dataset[level_string][problem_id][\"code\"]\n",
+    "print(target_kernel_reference)\n",
+    "\n",
+    "with open(\"tmp/reference.py\", \"w\") as f:\n",
+    "  f.write(target_kernel_reference)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fiSSqpKgXfwy"
+   },
+   "source": [
+    "\n",
+    "Now we construct the context to condition the LM for generation.\n",
+    "\n",
+    "The context consists of:\n",
+    "1.  **PyTorch Source:** We take the reference PyTorch code of the KernelBench problem.\n",
+    "2.  **Few-Shot Examples [Optional]:** We include a few examples of hand-written pairs of `Model`, `ModelNew`. By default, we use the pair of element-wise add example to show model the correct syntax and class structure, (aka how to use   `torch.utils.cpp_extension.load_inline`).\n",
+    "3.  **Hardware Context [Optional]:** We inject specific GPU specs (e.g., **SRAM size, memory bandwidth**) into the prompt. This allows the LLM to potentially calculate adjust tile sizes (e.g., `BLOCK_SIZE`) for your specific hardware (T4 vs A100).\n",
+    "4. **Backend & Precision**: You can specify which backend (`cuda` or other DSLs) and numerical percision.\n",
+    "\n",
+    "Of course you can also customize your prompt, or plug in your favorite agentic systems. For this tutorial, you will **copy** (or modify) the generated prompt below, send it to your favorite model / coding agent, and **paste** the result back!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ShZPHpnR5axP"
+   },
+   "outputs": [],
+   "source": [
+    "from kernelbench.prompt_constructor_toml import get_prompt_for_backend\n",
+    "\n",
+    "# Here is an example of a constructed context with hardware context\n",
+    "# This injects specs (memory bandwidth, cache size) from kernelbench/prompts/hardware/gpu_specs.py\n",
+    "# helping the LLM optimize tile sizes for your specific GPU.\n",
+    "\n",
+    "prompt = get_prompt_for_backend(\n",
+    "    ref_arch_src=target_kernel_reference,\n",
+    "    backend=\"cuda\",   # You can also try \"triton\" or \"tilelang\" here!\n",
+    "    option=\"one_shot\", # <--- show example of generation format via minimum example\n",
+    "    include_hardware=True, # <--- Enable hardware specific context\n",
+    "    gpu_name=\"T4\"          # <--- Specify your GPU (matches keys in gpu_specs.py)\n",
+    ")\n",
+    "\n",
+    "print(\"=\"*40)\n",
+    "print(\"  ⬇️ COPY THIS PROMPT TO YOUR LLM ⬇️  \")\n",
+    "print(\"=\"*40)\n",
+    "print(prompt)\n",
+    "print(\"=\"*40)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MIbCOK5GXh_U"
+   },
+   "outputs": [],
+   "source": [
+    "target_kernel_generation = \"paste the output here\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8yKcKFlV87PC"
+   },
+   "source": [
+    "For this tutorial, we have pre-generated a solution for the Matrix Multiplication problem (level=1, problem=1) using a standard LLM.\n",
+    "\n",
+    "**Note:** The kernel below is a naive CUDA implementation. While functionally correct, it's *slower* than PyTorch (which uses highly optimized cuBLAS). This is expected in Level 1. The challenge is to prompt the LLM to write tiled/shared-memory implementations to beat cuBLAS."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "364q0fwGLE2r"
+   },
+   "outputs": [],
+   "source": [
+    "# Here is an example model-generated kernel if you chose to optimize Level 1 Problem 1\n",
+    "\n",
+    "# By the way, this is a very slow and naive implementation in cuda; lots of room for improvement, try how you can beat this with your own generation!\n",
+    "\n",
+    "level_1_problem_1_sample_0_kernel = '''import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.cpp_extension import load_inline\n",
+    "\n",
+    "# Define the custom CUDA kernel for matrix multiplication\n",
+    "matrix_multiply_source = \"\"\"\n",
+    "#include <torch/extension.h>\n",
+    "#include <cuda_runtime.h>\n",
+    "\n",
+    "__global__ void matrix_multiply_kernel(const float* A, const float* B, float* C, int N) {\n",
+    "    int row = blockIdx.x * blockDim.x + threadIdx.x;\n",
+    "    int col = blockIdx.y * blockDim.y + threadIdx.y;\n",
+    "\n",
+    "    if (row < N && col < N) {\n",
+    "        float sum = 0.0f;\n",
+    "        for (int i = 0; i < N; i++) {\n",
+    "            sum += A[row * N + i] * B[i * N + col];\n",
+    "        }\n",
+    "        C[row * N + col] = sum;\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B) {\n",
+    "    auto N = A.size(0);\n",
+    "    auto C = torch::zeros_like(A);\n",
+    "\n",
+    "    const int block_size = 16;\n",
+    "    const int num_blocks_x = (N + block_size - 1) / block_size;\n",
+    "    const int num_blocks_y = (N + block_size - 1) / block_size;\n",
+    "\n",
+    "    dim3 block(block_size, block_size);\n",
+    "    dim3 grid(num_blocks_x, num_blocks_y);\n",
+    "\n",
+    "    matrix_multiply_kernel<<<grid, block>>>(A.data_ptr<float>(), B.data_ptr<float>(), C.data_ptr<float>(), N);\n",
+    "\n",
+    "    return C;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "matrix_multiply_cpp_source = (\n",
+    "    \"torch::Tensor matrix_multiply_cuda(torch::Tensor A, torch::Tensor B);\"\n",
+    ")\n",
+    "\n",
+    "# Compile the inline CUDA code for matrix multiplication\n",
+    "matrix_multiply = load_inline(\n",
+    "    name=\"matrix_multiply\",\n",
+    "    cpp_sources=matrix_multiply_cpp_source,\n",
+    "    cuda_sources=matrix_multiply_source,\n",
+    "    functions=[\"matrix_multiply_cuda\"],\n",
+    "    verbose=True,\n",
+    "    extra_cflags=[\"\"],\n",
+    "    extra_ldflags=[\"\"],\n",
+    ")\n",
+    "\n",
+    "\n",
+    "class ModelNew(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(ModelNew, self).__init__()\n",
+    "        self.matrix_multiply = matrix_multiply\n",
+    "\n",
+    "    def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:\n",
+    "        return self.matrix_multiply.matrix_multiply_cuda(A, B)\n",
+    "'''\n",
+    "\n",
+    "# uncomment if you want to use this example\n",
+    "target_kernel_generation = level_1_problem_1_sample_0_kernel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7R9mvYJ3NVr7"
+   },
+   "outputs": [],
+   "source": [
+    "with open(\"tmp/generation.py\", \"w\") as f:\n",
+    "  f.write(target_kernel_generation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HkbNLSZLNs7t"
+   },
+   "source": [
+    "## Check your Generated Kernel Performance\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UFxnQx9mRR8K"
+   },
+   "source": [
+    "Note some of the KernelBench problem sizes are quite big! This is too ensure [CPU overhead](https://scalingintelligence.stanford.edu/blogs/kernelbenchv01/) is not too significant. As our tensor sizes are calibrated on NVIDIA H100, you might run into OOM on a small GPU for some problems; reduce the problem sizes for those!\n",
+    "\n",
+    "Adjust `precision`, `num_trials`, `backend` etc as needed!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "OrtiIIM4Lw2p"
+   },
+   "outputs": [],
+   "source": [
+    "!python scripts/run_and_check.py ref_origin=kernelbench gpu_arch=\"['Turing']\" level={level} problem_id={problem_id} kernel_src_path=tmp/generation.py"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zn3PRPti-IJK"
+   },
+   "source": [
+    "When you run the command above, look for these lines in the logs for evaluation result:\n",
+    "\n",
+    "1.  **`[Eval] Correctness: True/False`**:\n",
+    "    *   This runs the kernel against the reference with random inputs with `num_correct_trials`.\n",
+    "    *   For **FP32**, we enforce `atol=1e-4`. Following PyTorch guideline, we have different tolerance for various precisions.\n",
+    "    *   If this fails, the kernel is functionally invalid, and speedup metrics are ignored.\n",
+    "\n",
+    "2.  **`[Speedup] Speedup over eager: X.XXx`**:\n",
+    "    * For Speedup we run both the reference and generated kernel `num_trials` time (100 typically), and compute speedup!\n",
+    "    *   `< 1.0x`: The generated kernel is slower than PyTorch (common for naive implementations).\n",
+    "    *   `> 1.0x`: The generated kernel is faster.\n",
+    "\n",
+    "3.  **`[Speedup] Speedup over torch.compile: Y.YYx`**:\n",
+    "    *   This compares against `torch.compile(mode=\"inductor\")`. This is the harder boss to beat for Level 2/3 problems involving kernel fusions!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sr4VfQBheBYP"
+   },
+   "source": [
+    "## Next Steps\n",
+    "\n",
+    "Congrats on finishing this tutorial! We show the minimum usage of KernelBench. Beyond acting as a benchmark, KernelBench tasks also serve as an environment to develop many techniques to tackle AI-generating GPU kernels. We have noted down many of the developments we are aware [here](https://docs.google.com/document/d/e/2PACX-1vTjS-UMH1HB5n_PENq2k-3YRfXIXkqKIKeNC2zcWMyLPdl4Jrwvdk4dNDVSsM8ybKrCxZB7GJq1slZF/pub), from building agentic systems to applying reinforcement learning.\n",
+    "\n",
+    "As a pro tip, you should be always **careful about speedup numbers**; kernel engineers and existing compilers are already pretty good, so a >2x speedup for anything is highly unlikely. While we are constantly improving our eval to be more robust and comprehensive, you should always **read the generated kernel in detail** to avoid reward hacking!  \n",
+    "\n",
+    "As a KernelBench is an open-soruce project, you are welcome to contribute to our [Github](https://github.com/ScalingIntelligence/KernelBench) to add new features or make it better!\n",
+    "\n",
+    "Have fun playing with KernelBench! Can't wait to see what you find out!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KGFQiYxAeoZM"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "kernel-bench",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..f3f98ae2
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+# this should be our single source of truth for versioning
+
+[project]
+name = "kernelbench"
+version = "0.2.0.dev0"
+requires-python = "==3.10.*"
+dependencies = [
+    # Frameworks
+    "torch>=2.9.0",
+
+    "transformers",
+    "datasets>=2.19.0",
+    "modal",
+
+    # helper
+    "tqdm",
+    "packaging",
+    "setuptools",
+    "pydra-config",
+    "ninja",
+    "tomli",
+    "tabulate",
+
+    # Numerics
+    "einops",
+    "python-dotenv",
+    "numpy",
+
+    # LLM providers
+    "openai",
+    "litellm[proxy]",
+]
+
+[project.optional-dependencies]
+gpu = [
+    # GPU-specific dependencies (requires CUDA)
+    "triton",
+    "nvidia-cutlass-dsl",
+    "tilelang",
+    "cupy-cuda12x",
+    "nsight-python",
+]
+dev = [
+    "pytest",
+    "ruff",
+]
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["kernelbench*"]
+
+[tool.setuptools.package-data]
+kernelbench = ["prompts/**/*"]
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 253e57da..07603a86 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,31 +1,35 @@
+# ARCHIVED: We are transitioning to pyproject.toml and uv-based project management
+# However, we provide this as a backup for now
+
 # Frameworks
 # we use latest PyTorch stable release
-torch==2.9.0
+torch==2.9.*
+triton==3.5.*
 
 # we shall upgrade torch for blackwell when it is stable
-transformers
-datasets
-modal
+transformers>=4.57.3
+datasets>=4.4.2
+modal>=1.3.0
 
 # DSLs
 nvidia-cutlass-dsl
 tilelang
-triton
 
 # helper
-tqdm
+tqdm>=4.67.1
 packaging
-pydra_config
-pytest
-ninja
-cupy-cuda12x
+pydra-config
+ninja>=1.13.0
+cupy-cuda12x==13.6.0
+tomli>=2.3.0
+tabulate>=0.9.0
+nsight-python
 
 # Numerics
-einops
-dotenv
-numpy
+einops>=0.8.1
+python-dotenv>=1.2.1
+numpy==2.4.0
 
 # use litellm for cloud providers and openai for local
-openai 
-litellm[proxy]
-
+openai>=2.14.0
+litellm[proxy]>=1.80.10
\ No newline at end of file
diff --git a/results/timing/H100_Modal/baseline_time_torch.json b/results/timing/H100_Modal/baseline_time_torch.json
new file mode 100644
index 00000000..14a3f7bd
--- /dev/null
+++ b/results/timing/H100_Modal/baseline_time_torch.json
@@ -0,0 +1,2258 @@
+{
+    "level1": {
+        "1_Square_matrix_multiplication_.py": {
+            "mean": 2.66,
+            "std": 0.0199,
+            "min": 2.65,
+            "max": 2.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "2_Standard_matrix_multiplication_.py": {
+            "mean": 2.61,
+            "std": 0.0112,
+            "min": 2.61,
+            "max": 2.72,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "3_Batched_matrix_multiplication.py": {
+            "mean": 5.33,
+            "std": 0.0467,
+            "min": 5.32,
+            "max": 5.79,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "4_Matrix_vector_multiplication_.py": {
+            "mean": 2.77,
+            "std": 0.0012,
+            "min": 2.77,
+            "max": 2.78,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "5_Matrix_scalar_multiplication.py": {
+            "mean": 2.85,
+            "std": 0.115,
+            "min": 2.82,
+            "max": 3.98,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "6_Matmul_with_large_K_dimension_.py": {
+            "mean": 1.3,
+            "std": 0.00314,
+            "min": 1.29,
+            "max": 1.31,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "7_Matmul_with_small_K_dimension_.py": {
+            "mean": 4.06,
+            "std": 0.103,
+            "min": 4.04,
+            "max": 5.08,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "8_Matmul_with_irregular_shapes_.py": {
+            "mean": 6.38,
+            "std": 0.0174,
+            "min": 6.37,
+            "max": 6.54,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "9_Tall_skinny_matrix_multiplication_.py": {
+            "mean": 2.59,
+            "std": 0.142,
+            "min": 2.57,
+            "max": 4.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "10_3D_tensor_matrix_multiplication.py": {
+            "mean": 1.04,
+            "std": 0.000954,
+            "min": 1.03,
+            "max": 1.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "11_4D_tensor_matrix_multiplication.py": {
+            "mean": 11.0,
+            "std": 1.02,
+            "min": 9.96,
+            "max": 13.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "12_Matmul_with_diagonal_matrices_.py": {
+            "mean": 2.68,
+            "std": 0.00374,
+            "min": 2.68,
+            "max": 2.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "13_Matmul_for_symmetric_matrices.py": {
+            "mean": 2.66,
+            "std": 0.00343,
+            "min": 2.65,
+            "max": 2.66,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "14_Matmul_for_upper_triangular_matrices.py": {
+            "mean": 2.7,
+            "std": 0.00519,
+            "min": 2.7,
+            "max": 2.75,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "15_Matmul_for_lower_triangular_matrices.py": {
+            "mean": 2.69,
+            "std": 0.00892,
+            "min": 2.68,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "16_Matmul_with_transposed_A.py": {
+            "mean": 2.62,
+            "std": 0.0106,
+            "min": 2.62,
+            "max": 2.72,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "17_Matmul_with_transposed_B.py": {
+            "mean": 2.68,
+            "std": 0.00948,
+            "min": 2.66,
+            "max": 2.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "18_Matmul_with_transposed_both.py": {
+            "mean": 2.74,
+            "std": 0.00171,
+            "min": 2.74,
+            "max": 2.75,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "19_ReLU.py": {
+            "mean": 4.28,
+            "std": 0.194,
+            "min": 4.24,
+            "max": 6.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "20_LeakyReLU.py": {
+            "mean": 4.28,
+            "std": 0.194,
+            "min": 4.24,
+            "max": 6.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "21_Sigmoid.py": {
+            "mean": 4.32,
+            "std": 0.276,
+            "min": 4.27,
+            "max": 7.05,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "22_Tanh.py": {
+            "mean": 4.31,
+            "std": 0.495,
+            "min": 4.24,
+            "max": 9.23,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "23_Softmax.py": {
+            "mean": 8.52,
+            "std": 0.189,
+            "min": 8.46,
+            "max": 10.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "24_LogSoftmax.py": {
+            "mean": 8.48,
+            "std": 0.194,
+            "min": 8.43,
+            "max": 10.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "25_Swish.py": {
+            "mean": 10.5,
+            "std": 0.0767,
+            "min": 10.5,
+            "max": 10.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "26_GELU_.py": {
+            "mean": 4.3,
+            "std": 0.191,
+            "min": 4.24,
+            "max": 6.17,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "27_SELU_.py": {
+            "mean": 4.3,
+            "std": 0.188,
+            "min": 4.24,
+            "max": 6.14,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "28_HardSigmoid.py": {
+            "mean": 4.34,
+            "std": 0.188,
+            "min": 4.27,
+            "max": 6.17,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "29_Softplus.py": {
+            "mean": 4.31,
+            "std": 0.193,
+            "min": 4.27,
+            "max": 6.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "30_Softsign.py": {
+            "mean": 14.8,
+            "std": 0.0927,
+            "min": 14.7,
+            "max": 15.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "31_ELU.py": {
+            "mean": 4.3,
+            "std": 0.188,
+            "min": 4.24,
+            "max": 6.13,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "32_HardTanh.py": {
+            "mean": 4.34,
+            "std": 0.187,
+            "min": 4.27,
+            "max": 6.16,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "33_BatchNorm.py": {
+            "mean": 8.77,
+            "std": 0.166,
+            "min": 8.67,
+            "max": 10.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "34_InstanceNorm.py": {
+            "mean": 9.61,
+            "std": 0.409,
+            "min": 9.51,
+            "max": 13.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "35_GroupNorm_.py": {
+            "mean": 10.1,
+            "std": 0.569,
+            "min": 9.89,
+            "max": 15.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "36_RMSNorm_.py": {
+            "mean": 14.2,
+            "std": 0.271,
+            "min": 14.1,
+            "max": 16.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "37_FrobeniusNorm_.py": {
+            "mean": 8.53,
+            "std": 0.116,
+            "min": 8.39,
+            "max": 8.67,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "38_L1Norm_.py": {
+            "mean": 15.6,
+            "std": 0.275,
+            "min": 15.5,
+            "max": 17.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "39_L2Norm_.py": {
+            "mean": 10.1,
+            "std": 0.185,
+            "min": 10.0,
+            "max": 11.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "40_LayerNorm.py": {
+            "mean": 8.12,
+            "std": 0.00745,
+            "min": 8.1,
+            "max": 8.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "41_Max_Pooling_1D.py": {
+            "mean": 10.7,
+            "std": 0.179,
+            "min": 10.6,
+            "max": 12.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "42_Max_Pooling_2D.py": {
+            "mean": 10.8,
+            "std": 1.02,
+            "min": 10.7,
+            "max": 21.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "43_Max_Pooling_3D.py": {
+            "mean": 3.93,
+            "std": 0.0736,
+            "min": 3.92,
+            "max": 4.66,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "44_Average_Pooling_1D.py": {
+            "mean": 5.47,
+            "std": 0.147,
+            "min": 5.45,
+            "max": 6.93,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "45_Average_Pooling_2D.py": {
+            "mean": 6.4,
+            "std": 0.0914,
+            "min": 6.26,
+            "max": 6.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "46_Average_Pooling_3D.py": {
+            "mean": 8.69,
+            "std": 0.257,
+            "min": 8.65,
+            "max": 11.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "47_Sum_reduction_over_a_dimension.py": {
+            "mean": 3.11,
+            "std": 0.0173,
+            "min": 3.07,
+            "max": 3.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "48_Mean_reduction_over_a_dimension.py": {
+            "mean": 2.88,
+            "std": 0.0128,
+            "min": 2.85,
+            "max": 2.93,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "49_Max_reduction_over_a_dimension.py": {
+            "mean": 3.14,
+            "std": 0.00513,
+            "min": 3.14,
+            "max": 3.19,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "50_conv_standard_2D__square_input__square_kernel.py": {
+            "mean": 2.2,
+            "std": 0.0362,
+            "min": 2.18,
+            "max": 2.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "51_Argmax_over_a_dimension.py": {
+            "mean": 3.14,
+            "std": 0.00258,
+            "min": 3.13,
+            "max": 3.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "52_Argmin_over_a_dimension.py": {
+            "mean": 3.24,
+            "std": 0.00398,
+            "min": 3.23,
+            "max": 3.27,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "53_Min_reduction_over_a_dimension.py": {
+            "mean": 3.14,
+            "std": 0.00249,
+            "min": 3.13,
+            "max": 3.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "54_conv_standard_3D__square_input__square_kernel.py": {
+            "mean": 1.87,
+            "std": 0.225,
+            "min": 1.84,
+            "max": 4.11,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "55_conv_standard_2D__asymmetric_input__square_kernel.py": {
+            "mean": 4.12,
+            "std": 0.0694,
+            "min": 3.92,
+            "max": 4.19,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "56_conv_standard_2D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 2.93,
+            "std": 0.103,
+            "min": 2.7,
+            "max": 3.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "57_conv_transposed_2D__square_input__square_kernel.py": {
+            "mean": 6.56,
+            "std": 1.84,
+            "min": 6.35,
+            "max": 24.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "58_conv_transposed_3D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 7.66,
+            "std": 0.00422,
+            "min": 7.65,
+            "max": 7.67,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "59_conv_standard_3D__asymmetric_input__square_kernel.py": {
+            "mean": 2.84,
+            "std": 0.00974,
+            "min": 2.8,
+            "max": 2.84,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "60_conv_standard_3D__square_input__asymmetric_kernel.py": {
+            "mean": 7.64,
+            "std": 0.00693,
+            "min": 7.64,
+            "max": 7.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "61_conv_transposed_3D__square_input__square_kernel.py": {
+            "mean": 9.15,
+            "std": 0.00909,
+            "min": 9.13,
+            "max": 9.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "62_conv_standard_2D__square_input__asymmetric_kernel.py": {
+            "mean": 2.43,
+            "std": 0.0586,
+            "min": 2.39,
+            "max": 3.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "63_conv_standard_2D__square_input__square_kernel.py": {
+            "mean": 7.11,
+            "std": 0.124,
+            "min": 7.06,
+            "max": 8.29,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "64_conv_transposed_1D.py": {
+            "mean": 5.48,
+            "std": 2.93,
+            "min": 5.16,
+            "max": 34.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "65_conv_transposed_2D__square_input__asymmetric_kernel.py": {
+            "mean": 2.62,
+            "std": 0.00976,
+            "min": 2.59,
+            "max": 2.65,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "66_conv_standard_3D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 3.78,
+            "std": 0.127,
+            "min": 3.76,
+            "max": 5.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "67_conv_standard_1D.py": {
+            "mean": 2.63,
+            "std": 0.0737,
+            "min": 2.62,
+            "max": 3.36,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "68_conv_transposed_3D__square_input__asymmetric_kernel.py": {
+            "mean": 36.8,
+            "std": 0.00606,
+            "min": 36.8,
+            "max": 36.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "69_conv_transposed_2D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 2.84,
+            "std": 0.0156,
+            "min": 2.81,
+            "max": 2.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "70_conv_transposed_3D__asymmetric_input__square_kernel.py": {
+            "mean": 29.3,
+            "std": 0.0133,
+            "min": 29.3,
+            "max": 29.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "71_conv_transposed_2D__asymmetric_input__square_kernel.py": {
+            "mean": 1.58,
+            "std": 0.00415,
+            "min": 1.57,
+            "max": 1.59,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "72_conv_transposed_3D_asymmetric_input_asymmetric_kernel___strided_padded_grouped_.py": {
+            "mean": 2.82,
+            "std": 0.0193,
+            "min": 2.8,
+            "max": 2.94,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "73_conv_transposed_3D_asymmetric_input_square_kernel__strided_padded__grouped.py": {
+            "mean": 2.09,
+            "std": 0.0067,
+            "min": 2.08,
+            "max": 2.11,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "74_conv_transposed_1D_dilated.py": {
+            "mean": 2.1,
+            "std": 0.177,
+            "min": 2.06,
+            "max": 3.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "75_conv_transposed_2D_asymmetric_input_asymmetric_kernel_strided__grouped____padded____dilated__.py": {
+            "mean": 6.66,
+            "std": 0.0161,
+            "min": 6.63,
+            "max": 6.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "76_conv_standard_1D_dilated_strided__.py": {
+            "mean": 12.2,
+            "std": 0.153,
+            "min": 12.1,
+            "max": 13.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "77_conv_transposed_3D_square_input_square_kernel___padded____dilated____strided__.py": {
+            "mean": 1.96,
+            "std": 0.036,
+            "min": 1.92,
+            "max": 2.26,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "78_conv_transposed_2D_asymmetric_input_asymmetric_kernel___padded__.py": {
+            "mean": 2.4,
+            "std": 0.162,
+            "min": 2.38,
+            "max": 4.01,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "79_conv_transposed_1D_asymmetric_input_square_kernel___padded____strided____dilated__.py": {
+            "mean": 1.94,
+            "std": 0.00719,
+            "min": 1.91,
+            "max": 1.95,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "80_conv_standard_2D_square_input_asymmetric_kernel___dilated____padded__.py": {
+            "mean": 2.41,
+            "std": 0.284,
+            "min": 2.35,
+            "max": 5.23,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "81_conv_transposed_2D_asymmetric_input_square_kernel___dilated____padded____strided__.py": {
+            "mean": 1.84,
+            "std": 0.00848,
+            "min": 1.82,
+            "max": 1.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "82_conv_depthwise_2D_square_input_square_kernel.py": {
+            "mean": 2.55,
+            "std": 0.14,
+            "min": 2.54,
+            "max": 3.94,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "83_conv_depthwise_2D_square_input_asymmetric_kernel.py": {
+            "mean": 1.53,
+            "std": 0.857,
+            "min": 1.45,
+            "max": 10.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "84_conv_depthwise_2D_asymmetric_input_square_kernel.py": {
+            "mean": 10.1,
+            "std": 0.103,
+            "min": 10.1,
+            "max": 11.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "85_conv_depthwise_2D_asymmetric_input_asymmetric_kernel.py": {
+            "mean": 2.27,
+            "std": 0.174,
+            "min": 2.26,
+            "max": 4.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "86_conv_depthwise_separable_2D.py": {
+            "mean": 3.91,
+            "std": 2.34,
+            "min": 3.65,
+            "max": 27.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "87_conv_pointwise_2D.py": {
+            "mean": 4.66,
+            "std": 0.259,
+            "min": 4.6,
+            "max": 7.22,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "88_MinGPTNewGelu.py": {
+            "mean": 1.65,
+            "std": 0.00148,
+            "min": 1.65,
+            "max": 1.66,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "89_cumsum.py": {
+            "mean": 4.68,
+            "std": 0.0795,
+            "min": 4.66,
+            "max": 5.47,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "90_cumprod.py": {
+            "mean": 4.69,
+            "std": 0.152,
+            "min": 4.67,
+            "max": 6.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "91_cumsum_reverse.py": {
+            "mean": 11.4,
+            "std": 0.0649,
+            "min": 11.4,
+            "max": 11.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "92_cumsum_exclusive.py": {
+            "mean": 12.9,
+            "std": 0.176,
+            "min": 12.8,
+            "max": 14.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "93_masked_cumsum.py": {
+            "mean": 8.72,
+            "std": 0.0326,
+            "min": 8.68,
+            "max": 8.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "94_MSELoss.py": {
+            "mean": 8.4,
+            "std": 0.0835,
+            "min": 8.35,
+            "max": 8.59,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "95_CrossEntropyLoss.py": {
+            "mean": 0.477,
+            "std": 0.00152,
+            "min": 0.474,
+            "max": 0.481,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "96_HuberLoss.py": {
+            "mean": 5.66,
+            "std": 0.171,
+            "min": 5.6,
+            "max": 7.21,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "97_ScaledDotProductAttention.py": {
+            "mean": 8.45,
+            "std": 0.353,
+            "min": 8.13,
+            "max": 9.63,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "98_KLDivLoss.py": {
+            "mean": 3.86,
+            "std": 0.00163,
+            "min": 3.85,
+            "max": 3.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "99_TripletMarginLoss.py": {
+            "mean": 4.27,
+            "std": 0.0342,
+            "min": 4.25,
+            "max": 4.45,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "100_HingeLoss.py": {
+            "mean": 10.5,
+            "std": 0.0775,
+            "min": 10.4,
+            "max": 10.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        }
+    },
+    "level2": {
+        "1_Conv2D_ReLU_BiasAdd.py": {
+            "mean": 4.35,
+            "std": 0.0172,
+            "min": 4.33,
+            "max": 4.39,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py": {
+            "mean": 12.7,
+            "std": 0.0991,
+            "min": 12.7,
+            "max": 13.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "3_ConvTranspose3d_Sum_LayerNorm_AvgPool_GELU.py": {
+            "mean": 10.1,
+            "std": 0.0705,
+            "min": 10.1,
+            "max": 10.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "4_Conv2d_Mish_Mish.py": {
+            "mean": 8.49,
+            "std": 0.213,
+            "min": 8.39,
+            "max": 9.54,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "5_ConvTranspose2d_Subtract_Tanh.py": {
+            "mean": 9.22,
+            "std": 0.202,
+            "min": 9.17,
+            "max": 11.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "6_Conv3d_Softmax_MaxPool_MaxPool.py": {
+            "mean": 0.864,
+            "std": 0.0131,
+            "min": 0.86,
+            "max": 0.993,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "7_Conv3d_ReLU_LeakyReLU_GELU_Sigmoid_BiasAdd.py": {
+            "mean": 6.43,
+            "std": 0.186,
+            "min": 6.4,
+            "max": 8.28,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py": {
+            "mean": 2.53,
+            "std": 0.0307,
+            "min": 2.51,
+            "max": 2.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "9_Matmul_Subtract_Multiply_ReLU.py": {
+            "mean": 2.73,
+            "std": 0.00118,
+            "min": 2.73,
+            "max": 2.74,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "10_ConvTranspose2d_MaxPool_Hardtanh_Mean_Tanh.py": {
+            "mean": 9.68,
+            "std": 0.0559,
+            "min": 9.65,
+            "max": 10.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "11_ConvTranspose2d_BatchNorm_Tanh_MaxPool_GroupNorm.py": {
+            "mean": 2.62,
+            "std": 0.0131,
+            "min": 2.59,
+            "max": 2.65,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "12_Gemm_Multiply_LeakyReLU.py": {
+            "mean": 2.73,
+            "std": 0.00146,
+            "min": 2.73,
+            "max": 2.74,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "13_ConvTranspose3d_Mean_Add_Softmax_Tanh_Scaling.py": {
+            "mean": 9.89,
+            "std": 0.02,
+            "min": 9.87,
+            "max": 9.95,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "14_Gemm_Divide_Sum_Scaling.py": {
+            "mean": 2.75,
+            "std": 0.00372,
+            "min": 2.75,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "15_ConvTranspose3d_BatchNorm_Subtract.py": {
+            "mean": 2.04,
+            "std": 0.101,
+            "min": 2.02,
+            "max": 3.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "16_ConvTranspose2d_Mish_Add_Hardtanh_Scaling.py": {
+            "mean": 10.9,
+            "std": 0.0718,
+            "min": 10.9,
+            "max": 11.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "17_Conv2d_InstanceNorm_Divide.py": {
+            "mean": 4.94,
+            "std": 0.0166,
+            "min": 4.91,
+            "max": 4.96,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py": {
+            "mean": 2.77,
+            "std": 0.000935,
+            "min": 2.77,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "19_ConvTranspose2d_GELU_GroupNorm.py": {
+            "mean": 12.3,
+            "std": 0.646,
+            "min": 12.2,
+            "max": 18.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "20_ConvTranspose3d_Sum_ResidualAdd_Multiply_ResidualAdd.py": {
+            "mean": 3.55,
+            "std": 0.00209,
+            "min": 3.54,
+            "max": 3.55,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "21_Conv2d_Add_Scale_Sigmoid_GroupNorm.py": {
+            "mean": 6.45,
+            "std": 0.0137,
+            "min": 6.44,
+            "max": 6.53,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "22_Matmul_Scale_ResidualAdd_Clamp_LogSumExp_Mish.py": {
+            "mean": 2.84,
+            "std": 0.00888,
+            "min": 2.83,
+            "max": 2.85,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "23_Conv3d_GroupNorm_Mean.py": {
+            "mean": 1.27,
+            "std": 0.00104,
+            "min": 1.27,
+            "max": 1.27,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "24_Conv3d_Min_Softmax.py": {
+            "mean": 0.969,
+            "std": 0.00266,
+            "min": 0.965,
+            "max": 0.984,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "25_Conv2d_Min_Tanh_Tanh.py": {
+            "mean": 6.48,
+            "std": 0.0143,
+            "min": 6.45,
+            "max": 6.54,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "26_ConvTranspose3d_Add_HardSwish.py": {
+            "mean": 5.09,
+            "std": 0.122,
+            "min": 5.07,
+            "max": 6.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "27_Conv3d_HardSwish_GroupNorm_Mean.py": {
+            "mean": 9.92,
+            "std": 0.0179,
+            "min": 9.91,
+            "max": 10.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "28_BMM_InstanceNorm_Sum_ResidualAdd_Multiply.py": {
+            "mean": 2.79,
+            "std": 0.0041,
+            "min": 2.79,
+            "max": 2.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "29_Matmul_Mish_Mish.py": {
+            "mean": 2.73,
+            "std": 0.00551,
+            "min": 2.73,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "30_Gemm_GroupNorm_Hardtanh.py": {
+            "mean": 2.83,
+            "std": 0.0131,
+            "min": 2.82,
+            "max": 2.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "31_Conv2d_Min_Add_Multiply.py": {
+            "mean": 5.06,
+            "std": 0.0138,
+            "min": 5.03,
+            "max": 5.08,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "32_Conv2d_Scaling_Min.py": {
+            "mean": 7.84,
+            "std": 0.0234,
+            "min": 7.8,
+            "max": 7.91,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "33_Gemm_Scale_BatchNorm.py": {
+            "mean": 2.76,
+            "std": 0.00164,
+            "min": 2.76,
+            "max": 2.78,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "34_ConvTranspose3d_LayerNorm_GELU_Scaling.py": {
+            "mean": 10.0,
+            "std": 0.275,
+            "min": 9.98,
+            "max": 12.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "35_Conv2d_Subtract_HardSwish_MaxPool_Mish.py": {
+            "mean": 5.11,
+            "std": 0.0175,
+            "min": 5.09,
+            "max": 5.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "36_ConvTranspose2d_Min_Sum_GELU_Add.py": {
+            "mean": 1.46,
+            "std": 0.00328,
+            "min": 1.44,
+            "max": 1.47,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "37_Matmul_Swish_Sum_GroupNorm.py": {
+            "mean": 8.55,
+            "std": 0.00795,
+            "min": 8.54,
+            "max": 8.59,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "38_ConvTranspose3d_AvgPool_Clamp_Softmax_Multiply.py": {
+            "mean": 5.68,
+            "std": 0.025,
+            "min": 5.67,
+            "max": 5.93,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "39_Gemm_Scale_BatchNorm.py": {
+            "mean": 11.4,
+            "std": 0.101,
+            "min": 11.3,
+            "max": 11.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "40_Matmul_Scaling_ResidualAdd.py": {
+            "mean": 11.4,
+            "std": 0.0147,
+            "min": 11.4,
+            "max": 11.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "41_Gemm_BatchNorm_GELU_ReLU.py": {
+            "mean": 11.5,
+            "std": 0.152,
+            "min": 11.4,
+            "max": 12.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "42_ConvTranspose2d_GlobalAvgPool_BiasAdd_LogSumExp_Sum_Multiply.py": {
+            "mean": 7.17,
+            "std": 0.0118,
+            "min": 7.14,
+            "max": 7.22,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "43_Conv3d_Max_LogSumExp_ReLU.py": {
+            "mean": 2.66,
+            "std": 0.0151,
+            "min": 2.63,
+            "max": 2.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "44_ConvTranspose2d_Multiply_GlobalAvgPool_GlobalAvgPool_Mean.py": {
+            "mean": 1.74,
+            "std": 0.0027,
+            "min": 1.74,
+            "max": 1.76,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "45_Gemm_Sigmoid_LogSumExp.py": {
+            "mean": 8.5,
+            "std": 0.00916,
+            "min": 8.49,
+            "max": 8.55,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "46_Conv2d_Subtract_Tanh_Subtract_AvgPool.py": {
+            "mean": 5.65,
+            "std": 0.017,
+            "min": 5.62,
+            "max": 5.68,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "47_Conv3d_Mish_Tanh.py": {
+            "mean": 2.56,
+            "std": 0.0127,
+            "min": 2.54,
+            "max": 2.62,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "48_Conv3d_Scaling_Tanh_Multiply_Sigmoid.py": {
+            "mean": 3.35,
+            "std": 0.0361,
+            "min": 3.34,
+            "max": 3.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "49_ConvTranspose3d_Softmax_Sigmoid.py": {
+            "mean": 2.89,
+            "std": 0.127,
+            "min": 2.86,
+            "max": 4.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "50_ConvTranspose3d_Scaling_AvgPool_BiasAdd_Scaling.py": {
+            "mean": 5.71,
+            "std": 0.0255,
+            "min": 5.68,
+            "max": 5.76,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "51_Gemm_Subtract_GlobalAvgPool_LogSumExp_GELU_ResidualAdd.py": {
+            "mean": 5.62,
+            "std": 0.00244,
+            "min": 5.61,
+            "max": 5.63,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "52_Conv2d_Activation_BatchNorm.py": {
+            "mean": 3.73,
+            "std": 2.34,
+            "min": 3.48,
+            "max": 27.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "53_Gemm_Scaling_Hardtanh_GELU.py": {
+            "mean": 5.53,
+            "std": 0.0106,
+            "min": 5.52,
+            "max": 5.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "54_Conv2d_Multiply_LeakyReLU_GELU.py": {
+            "mean": 6.08,
+            "std": 0.0744,
+            "min": 6.03,
+            "max": 6.82,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "55_Matmul_MaxPool_Sum_Scale.py": {
+            "mean": 5.27,
+            "std": 0.00764,
+            "min": 5.25,
+            "max": 5.29,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "56_Matmul_Sigmoid_Sum.py": {
+            "mean": 5.29,
+            "std": 0.0132,
+            "min": 5.28,
+            "max": 5.34,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "57_Conv2d_ReLU_HardSwish.py": {
+            "mean": 2.99,
+            "std": 0.00463,
+            "min": 2.98,
+            "max": 3.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "58_ConvTranspose3d_LogSumExp_HardSwish_Subtract_Clamp.py": {
+            "mean": 6.84,
+            "std": 0.0241,
+            "min": 6.81,
+            "max": 7.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "59_Matmul_Swish_Scaling.py": {
+            "mean": 5.3,
+            "std": 0.00878,
+            "min": 5.29,
+            "max": 5.34,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "60_ConvTranspose3d_Swish_GroupNorm_HardSwish.py": {
+            "mean": 7.7,
+            "std": 0.0146,
+            "min": 7.68,
+            "max": 7.78,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "61_ConvTranspose3d_ReLU_GroupNorm.py": {
+            "mean": 3.79,
+            "std": 0.052,
+            "min": 3.77,
+            "max": 4.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "62_Matmul_GroupNorm_LeakyReLU_Sum.py": {
+            "mean": 3.09,
+            "std": 0.00155,
+            "min": 3.08,
+            "max": 3.09,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "63_Gemm_ReLU_Divide.py": {
+            "mean": 2.73,
+            "std": 0.000961,
+            "min": 2.73,
+            "max": 2.73,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "64_Gemm_LogSumExp_LeakyReLU_LeakyReLU_GELU_GELU.py": {
+            "mean": 2.78,
+            "std": 0.00126,
+            "min": 2.78,
+            "max": 2.79,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "65_Conv2d_AvgPool_Sigmoid_Sum.py": {
+            "mean": 12.0,
+            "std": 0.00688,
+            "min": 12.0,
+            "max": 12.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "66_Matmul_Dropout_Softmax.py": {
+            "mean": 1.44,
+            "std": 0.00272,
+            "min": 1.43,
+            "max": 1.46,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "67_Conv2d_GELU_GlobalAvgPool.py": {
+            "mean": 6.48,
+            "std": 0.0133,
+            "min": 6.46,
+            "max": 6.57,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "68_Matmul_Min_Subtract.py": {
+            "mean": 1.44,
+            "std": 0.00578,
+            "min": 1.44,
+            "max": 1.46,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "69_Conv2d_HardSwish_ReLU.py": {
+            "mean": 1.81,
+            "std": 0.00875,
+            "min": 1.79,
+            "max": 1.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "70_Gemm_Sigmoid_Scaling_ResidualAdd.py": {
+            "mean": 2.77,
+            "std": 0.00184,
+            "min": 2.77,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "71_Conv2d_Divide_LeakyReLU.py": {
+            "mean": 1.8,
+            "std": 0.00387,
+            "min": 1.79,
+            "max": 1.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "72_ConvTranspose3d_BatchNorm_AvgPool_AvgPool.py": {
+            "mean": 12.3,
+            "std": 0.0156,
+            "min": 12.2,
+            "max": 12.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "73_Conv2d_BatchNorm_Scaling.py": {
+            "mean": 2.59,
+            "std": 0.00487,
+            "min": 2.58,
+            "max": 2.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "74_ConvTranspose3d_LeakyReLU_Multiply_LeakyReLU_Max.py": {
+            "mean": 1.47,
+            "std": 0.00462,
+            "min": 1.46,
+            "max": 1.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "75_Gemm_GroupNorm_Min_BiasAdd.py": {
+            "mean": 3.09,
+            "std": 0.00233,
+            "min": 3.08,
+            "max": 3.09,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "76_Gemm_Add_ReLU.py": {
+            "mean": 2.78,
+            "std": 0.00408,
+            "min": 2.78,
+            "max": 2.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "77_ConvTranspose3d_Scale_BatchNorm_GlobalAvgPool.py": {
+            "mean": 5.42,
+            "std": 0.035,
+            "min": 5.33,
+            "max": 5.51,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "78_ConvTranspose3d_Max_Max_Sum.py": {
+            "mean": 47.4,
+            "std": 0.0213,
+            "min": 47.3,
+            "max": 47.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "79_Conv3d_Multiply_InstanceNorm_Clamp_Multiply_Max.py": {
+            "mean": 0.965,
+            "std": 0.00863,
+            "min": 0.961,
+            "max": 1.03,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "80_Gemm_Max_Subtract_GELU.py": {
+            "mean": 2.72,
+            "std": 0.00535,
+            "min": 2.71,
+            "max": 2.74,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "81_Gemm_Swish_Divide_Clamp_Tanh_Clamp.py": {
+            "mean": 2.83,
+            "std": 0.00763,
+            "min": 2.82,
+            "max": 2.84,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "82_Conv2d_Tanh_Scaling_BiasAdd_Max.py": {
+            "mean": 9.79,
+            "std": 0.013,
+            "min": 9.76,
+            "max": 9.82,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "83_Conv3d_GroupNorm_Min_Clamp_Dropout.py": {
+            "mean": 3.68,
+            "std": 0.00569,
+            "min": 3.68,
+            "max": 3.73,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "84_Gemm_BatchNorm_Scaling_Softmax.py": {
+            "mean": 2.8,
+            "std": 0.00658,
+            "min": 2.78,
+            "max": 2.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "85_Conv2d_GroupNorm_Scale_MaxPool_Clamp.py": {
+            "mean": 2.51,
+            "std": 0.00366,
+            "min": 2.49,
+            "max": 2.51,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "86_Matmul_Divide_GELU.py": {
+            "mean": 2.73,
+            "std": 0.0087,
+            "min": 2.71,
+            "max": 2.75,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "87_Conv2d_Subtract_Subtract_Mish.py": {
+            "mean": 8.57,
+            "std": 0.0101,
+            "min": 8.55,
+            "max": 8.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "88_Gemm_GroupNorm_Swish_Multiply_Swish.py": {
+            "mean": 3.03,
+            "std": 0.00526,
+            "min": 3.03,
+            "max": 3.07,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "89_ConvTranspose3d_MaxPool_Softmax_Subtract_Swish_Max.py": {
+            "mean": 5.68,
+            "std": 0.0259,
+            "min": 5.65,
+            "max": 5.75,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "90_Conv3d_LeakyReLU_Sum_Clamp_GELU.py": {
+            "mean": 11.4,
+            "std": 0.00224,
+            "min": 11.4,
+            "max": 11.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "91_ConvTranspose2d_Softmax_BiasAdd_Scaling_Sigmoid.py": {
+            "mean": 9.28,
+            "std": 0.258,
+            "min": 9.14,
+            "max": 11.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "92_Conv2d_GroupNorm_Tanh_HardSwish_ResidualAdd_LogSumExp.py": {
+            "mean": 4.25,
+            "std": 0.00599,
+            "min": 4.24,
+            "max": 4.29,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "93_ConvTranspose2d_Add_Min_GELU_Multiply.py": {
+            "mean": 5.73,
+            "std": 0.139,
+            "min": 5.69,
+            "max": 7.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "94_Gemm_BiasAdd_Hardtanh_Mish_GroupNorm.py": {
+            "mean": 2.96,
+            "std": 0.00305,
+            "min": 2.95,
+            "max": 2.97,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "95_Matmul_Add_Swish_Tanh_GELU_Hardtanh.py": {
+            "mean": 2.85,
+            "std": 0.00396,
+            "min": 2.84,
+            "max": 2.87,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "96_ConvTranspose3d_Multiply_Max_GlobalAvgPool_Clamp.py": {
+            "mean": 5.35,
+            "std": 0.0217,
+            "min": 5.33,
+            "max": 5.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "97_Matmul_BatchNorm_BiasAdd_Divide_Swish.py": {
+            "mean": 2.83,
+            "std": 0.00592,
+            "min": 2.82,
+            "max": 2.87,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "98_Matmul_AvgPool_GELU_Scale_Max.py": {
+            "mean": 2.71,
+            "std": 0.00995,
+            "min": 2.7,
+            "max": 2.72,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "99_Matmul_GELU_Softmax.py": {
+            "mean": 2.75,
+            "std": 0.00399,
+            "min": 2.75,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "100_ConvTranspose3d_Clamp_Min_Divide.py": {
+            "mean": 13.6,
+            "std": 1.05,
+            "min": 13.5,
+            "max": 24.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        }
+    },
+    "level3": {
+        "1_MLP.py": {
+            "mean": 3.79,
+            "std": 0.0217,
+            "min": 3.78,
+            "max": 4.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "2_ShallowWideMLP.py": {
+            "mean": 11.0,
+            "std": 0.463,
+            "min": 10.7,
+            "max": 12.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "3_DeepNarrowMLP.py": {
+            "mean": 1.81,
+            "std": 0.0139,
+            "min": 1.8,
+            "max": 1.94,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "4_LeNet5.py": {
+            "mean": 0.821,
+            "std": 0.00086,
+            "min": 0.819,
+            "max": 0.823,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "5_AlexNet.py": {
+            "mean": 23.7,
+            "std": 0.109,
+            "min": 23.5,
+            "max": 23.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "6_GoogleNetInceptionModule.py": {
+            "mean": 8.77,
+            "std": 0.0346,
+            "min": 8.75,
+            "max": 9.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "7_GoogleNetInceptionV1.py": {
+            "mean": 2.65,
+            "std": 0.0259,
+            "min": 2.55,
+            "max": 2.72,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "8_ResNetBasicBlock.py": {
+            "mean": 1.68,
+            "std": 0.00463,
+            "min": 1.68,
+            "max": 1.73,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "9_ResNet18.py": {
+            "mean": 1.67,
+            "std": 0.0492,
+            "min": 1.61,
+            "max": 1.96,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "10_ResNet101.py": {
+            "mean": 8.79,
+            "std": 0.0645,
+            "min": 8.6,
+            "max": 9.01,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "11_VGG16.py": {
+            "mean": 3.39,
+            "std": 0.0176,
+            "min": 3.35,
+            "max": 3.43,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "12_VGG19.py": {
+            "mean": 3.88,
+            "std": 0.0234,
+            "min": 3.8,
+            "max": 3.92,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "13_DenseNet121TransitionLayer.py": {
+            "mean": 7.33,
+            "std": 0.0161,
+            "min": 7.3,
+            "max": 7.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "14_DenseNet121DenseBlock.py": {
+            "mean": 7.47,
+            "std": 0.0274,
+            "min": 7.44,
+            "max": 7.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "15_DenseNet121.py": {
+            "mean": 6.68,
+            "std": 0.116,
+            "min": 6.24,
+            "max": 7.07,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "16_DenseNet201.py": {
+            "mean": 10.4,
+            "std": 0.239,
+            "min": 9.83,
+            "max": 10.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "17_SqueezeNetFireModule.py": {
+            "mean": 13.3,
+            "std": 0.035,
+            "min": 13.2,
+            "max": 13.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "18_SqueezeNet.py": {
+            "mean": 28.0,
+            "std": 0.0384,
+            "min": 28.0,
+            "max": 28.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "19_MobileNetV1.py": {
+            "mean": 1.73,
+            "std": 0.0508,
+            "min": 1.68,
+            "max": 2.08,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "20_MobileNetV2.py": {
+            "mean": 3.56,
+            "std": 0.0898,
+            "min": 3.45,
+            "max": 4.12,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "21_EfficientNetMBConv.py": {
+            "mean": 5.43,
+            "std": 0.00673,
+            "min": 5.41,
+            "max": 5.44,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "22_EfficientNetB0.py": {
+            "mean": 3.03,
+            "std": 0.0741,
+            "min": 2.95,
+            "max": 3.52,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "23_EfficientNetB1.py": {
+            "mean": 1.62,
+            "std": 0.0357,
+            "min": 1.49,
+            "max": 1.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "24_EfficientNetB2.py": {
+            "mean": 1.64,
+            "std": 0.0319,
+            "min": 1.57,
+            "max": 1.75,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "25_ShuffleNetUnit.py": {
+            "mean": 8.17,
+            "std": 0.014,
+            "min": 8.14,
+            "max": 8.22,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "26_ShuffleNet.py": {
+            "mean": 8.23,
+            "std": 0.0498,
+            "min": 8.14,
+            "max": 8.52,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "27_RegNet.py": {
+            "mean": 2.37,
+            "std": 0.0166,
+            "min": 2.36,
+            "max": 2.52,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "28_VisionTransformer.py": {
+            "mean": 1.81,
+            "std": 0.0516,
+            "min": 1.73,
+            "max": 2.17,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "29_SwinMLP.py": {
+            "mean": 4.33,
+            "std": 0.177,
+            "min": 4.02,
+            "max": 5.41,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "30_SwinTransformerV2.py": {
+            "mean": 9.75,
+            "std": 0.0864,
+            "min": 9.6,
+            "max": 10.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "31_VisionAttention.py": {
+            "mean": 21.7,
+            "std": 0.14,
+            "min": 21.6,
+            "max": 22.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "32_ConvolutionalVisionTransformer.py": {
+            "mean": 2.21,
+            "std": 0.0297,
+            "min": 2.15,
+            "max": 2.29,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "33_VanillaRNN.py": {
+            "mean": 6.84,
+            "std": 0.00737,
+            "min": 6.82,
+            "max": 6.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "34_VanillaRNNHidden.py": {
+            "mean": 16.1,
+            "std": 0.379,
+            "min": 15.6,
+            "max": 19.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "35_LSTM.py": {
+            "mean": 27.2,
+            "std": 0.259,
+            "min": 26.1,
+            "max": 28.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "36_LSTMHn.py": {
+            "mean": 35.8,
+            "std": 0.411,
+            "min": 35.3,
+            "max": 39.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "37_LSTMCn.py": {
+            "mean": 28.0,
+            "std": 2.55,
+            "min": 26.2,
+            "max": 35.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "38_LSTMBidirectional.py": {
+            "mean": 54.1,
+            "std": 1.98,
+            "min": 51.6,
+            "max": 57.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "39_GRU.py": {
+            "mean": 39.1,
+            "std": 0.145,
+            "min": 38.9,
+            "max": 39.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "40_GRUHidden.py": {
+            "mean": 38.5,
+            "std": 2.74,
+            "min": 35.2,
+            "max": 50.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "41_GRUBidirectional.py": {
+            "mean": 77.5,
+            "std": 0.683,
+            "min": 76.2,
+            "max": 79.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "42_GRUBidirectionalHidden.py": {
+            "mean": 82.6,
+            "std": 0.889,
+            "min": 81.0,
+            "max": 84.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "43_MinGPTCausalAttention.py": {
+            "mean": 13.1,
+            "std": 2.57,
+            "min": 12.8,
+            "max": 38.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "44_MiniGPTBlock.py": {
+            "mean": 30.3,
+            "std": 0.00841,
+            "min": 30.3,
+            "max": 30.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "45_UNetSoftmax.py": {
+            "mean": 5.04,
+            "std": 0.0131,
+            "min": 5.01,
+            "max": 5.06,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "46_NetVladWithGhostClusters.py": {
+            "mean": 1.58,
+            "std": 0.0027,
+            "min": 1.58,
+            "max": 1.59,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "47_NetVladNoGhostClusters.py": {
+            "mean": 1.64,
+            "std": 2.02,
+            "min": 1.43,
+            "max": 21.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "48_Mamba2ReturnY.py": {
+            "mean": 7.98,
+            "std": 0.0239,
+            "min": 7.97,
+            "max": 8.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "49_Mamba2ReturnFinalState.py": {
+            "mean": 5.94,
+            "std": 0.0103,
+            "min": 5.92,
+            "max": 5.97,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "50_ReLUSelfAttention.py": {
+            "mean": 5.02,
+            "std": 0.00426,
+            "min": 5.01,
+            "max": 5.05,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        }
+    }
+}
\ No newline at end of file
diff --git a/results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json b/results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json
new file mode 100644
index 00000000..f2d2486a
--- /dev/null
+++ b/results/timing/H100_Modal/baseline_time_torch_compile_inductor_default.json
@@ -0,0 +1,2258 @@
+{
+    "level1": {
+        "1_Square_matrix_multiplication_.py": {
+            "mean": 2.67,
+            "std": 0.0519,
+            "min": 2.66,
+            "max": 3.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "2_Standard_matrix_multiplication_.py": {
+            "mean": 2.66,
+            "std": 0.0307,
+            "min": 2.64,
+            "max": 2.94,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "3_Batched_matrix_multiplication.py": {
+            "mean": 5.35,
+            "std": 0.0569,
+            "min": 5.32,
+            "max": 5.87,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "4_Matrix_vector_multiplication_.py": {
+            "mean": 2.79,
+            "std": 0.014,
+            "min": 2.78,
+            "max": 2.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "5_Matrix_scalar_multiplication.py": {
+            "mean": 2.85,
+            "std": 0.122,
+            "min": 2.82,
+            "max": 4.05,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "6_Matmul_with_large_K_dimension_.py": {
+            "mean": 1.38,
+            "std": 0.0618,
+            "min": 1.32,
+            "max": 1.64,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "7_Matmul_with_small_K_dimension_.py": {
+            "mean": 4.07,
+            "std": 0.105,
+            "min": 4.04,
+            "max": 5.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "8_Matmul_with_irregular_shapes_.py": {
+            "mean": 6.43,
+            "std": 0.0467,
+            "min": 6.41,
+            "max": 6.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "9_Tall_skinny_matrix_multiplication_.py": {
+            "mean": 2.62,
+            "std": 0.137,
+            "min": 2.58,
+            "max": 3.97,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "10_3D_tensor_matrix_multiplication.py": {
+            "mean": 1.05,
+            "std": 0.0359,
+            "min": 1.04,
+            "max": 1.36,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "11_4D_tensor_matrix_multiplication.py": {
+            "mean": 10.9,
+            "std": 1.07,
+            "min": 10.0,
+            "max": 15.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "12_Matmul_with_diagonal_matrices_.py": {
+            "mean": 2.69,
+            "std": 0.00913,
+            "min": 2.68,
+            "max": 2.73,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "13_Matmul_for_symmetric_matrices.py": {
+            "mean": 2.67,
+            "std": 0.04,
+            "min": 2.65,
+            "max": 3.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "14_Matmul_for_upper_triangular_matrices.py": {
+            "mean": 2.75,
+            "std": 0.0084,
+            "min": 2.74,
+            "max": 2.79,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "15_Matmul_for_lower_triangular_matrices.py": {
+            "mean": 2.73,
+            "std": 0.0358,
+            "min": 2.71,
+            "max": 2.99,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "16_Matmul_with_transposed_A.py": {
+            "mean": 2.64,
+            "std": 0.00899,
+            "min": 2.63,
+            "max": 2.71,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "17_Matmul_with_transposed_B.py": {
+            "mean": 2.71,
+            "std": 0.0445,
+            "min": 2.7,
+            "max": 3.14,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "18_Matmul_with_transposed_both.py": {
+            "mean": 2.79,
+            "std": 0.0138,
+            "min": 2.78,
+            "max": 2.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "19_ReLU.py": {
+            "mean": 4.35,
+            "std": 0.287,
+            "min": 4.24,
+            "max": 7.02,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "20_LeakyReLU.py": {
+            "mean": 4.28,
+            "std": 0.203,
+            "min": 4.23,
+            "max": 6.26,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "21_Sigmoid.py": {
+            "mean": 4.3,
+            "std": 0.192,
+            "min": 4.23,
+            "max": 6.13,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "22_Tanh.py": {
+            "mean": 4.33,
+            "std": 0.283,
+            "min": 4.24,
+            "max": 7.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "23_Softmax.py": {
+            "mean": 6.55,
+            "std": 0.191,
+            "min": 6.49,
+            "max": 8.37,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "24_LogSoftmax.py": {
+            "mean": 6.68,
+            "std": 1.43,
+            "min": 6.5,
+            "max": 20.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "25_Swish.py": {
+            "mean": 4.28,
+            "std": 0.297,
+            "min": 4.23,
+            "max": 7.22,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "26_GELU_.py": {
+            "mean": 4.27,
+            "std": 0.195,
+            "min": 4.23,
+            "max": 6.19,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "27_SELU_.py": {
+            "mean": 4.3,
+            "std": 0.19,
+            "min": 4.23,
+            "max": 6.16,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "28_HardSigmoid.py": {
+            "mean": 4.3,
+            "std": 0.19,
+            "min": 4.23,
+            "max": 6.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "29_Softplus.py": {
+            "mean": 4.3,
+            "std": 0.194,
+            "min": 4.23,
+            "max": 6.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "30_Softsign.py": {
+            "mean": 4.3,
+            "std": 0.191,
+            "min": 4.23,
+            "max": 6.15,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "31_ELU.py": {
+            "mean": 4.38,
+            "std": 1.02,
+            "min": 4.23,
+            "max": 14.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "32_HardTanh.py": {
+            "mean": 4.29,
+            "std": 0.178,
+            "min": 4.23,
+            "max": 6.03,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "33_BatchNorm.py": {
+            "mean": 4.38,
+            "std": 0.219,
+            "min": 4.19,
+            "max": 6.07,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "34_InstanceNorm.py": {
+            "mean": 7.6,
+            "std": 0.196,
+            "min": 7.48,
+            "max": 9.46,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "35_GroupNorm_.py": {
+            "mean": 8.22,
+            "std": 0.101,
+            "min": 8.08,
+            "max": 8.43,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "36_RMSNorm_.py": {
+            "mean": 7.84,
+            "std": 0.0539,
+            "min": 7.77,
+            "max": 8.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "37_FrobeniusNorm_.py": {
+            "mean": 7.45,
+            "std": 0.204,
+            "min": 7.3,
+            "max": 8.01,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "38_L1Norm_.py": {
+            "mean": 13.1,
+            "std": 0.303,
+            "min": 12.8,
+            "max": 15.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "39_L2Norm_.py": {
+            "mean": 13.1,
+            "std": 0.285,
+            "min": 12.9,
+            "max": 15.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "40_LayerNorm.py": {
+            "mean": 0.46,
+            "std": 0.0302,
+            "min": 0.45,
+            "max": 0.738,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "41_Max_Pooling_1D.py": {
+            "mean": 2.85,
+            "std": 0.155,
+            "min": 2.8,
+            "max": 4.29,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "42_Max_Pooling_2D.py": {
+            "mean": 4.33,
+            "std": 0.0106,
+            "min": 4.3,
+            "max": 4.37,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "43_Max_Pooling_3D.py": {
+            "mean": 5.65,
+            "std": 0.00607,
+            "min": 5.65,
+            "max": 5.68,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "44_Average_Pooling_1D.py": {
+            "mean": 3.13,
+            "std": 0.0119,
+            "min": 3.12,
+            "max": 3.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "45_Average_Pooling_2D.py": {
+            "mean": 6.34,
+            "std": 0.0946,
+            "min": 6.26,
+            "max": 6.73,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "46_Average_Pooling_3D.py": {
+            "mean": 8.7,
+            "std": 0.172,
+            "min": 8.66,
+            "max": 10.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "47_Sum_reduction_over_a_dimension.py": {
+            "mean": 3.38,
+            "std": 0.023,
+            "min": 3.34,
+            "max": 3.56,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "48_Mean_reduction_over_a_dimension.py": {
+            "mean": 3.57,
+            "std": 0.273,
+            "min": 3.49,
+            "max": 6.24,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "49_Max_reduction_over_a_dimension.py": {
+            "mean": 3.53,
+            "std": 0.142,
+            "min": 3.47,
+            "max": 4.47,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "50_conv_standard_2D__square_input__square_kernel.py": {
+            "mean": 1.74,
+            "std": 0.0298,
+            "min": 1.7,
+            "max": 1.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "51_Argmax_over_a_dimension.py": {
+            "mean": 3.33,
+            "std": 0.0153,
+            "min": 3.32,
+            "max": 3.47,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "52_Argmin_over_a_dimension.py": {
+            "mean": 3.37,
+            "std": 0.354,
+            "min": 3.32,
+            "max": 6.84,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "53_Min_reduction_over_a_dimension.py": {
+            "mean": 3.34,
+            "std": 0.0322,
+            "min": 3.31,
+            "max": 3.57,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "54_conv_standard_3D__square_input__square_kernel.py": {
+            "mean": 1.86,
+            "std": 0.114,
+            "min": 1.84,
+            "max": 2.97,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "55_conv_standard_2D__asymmetric_input__square_kernel.py": {
+            "mean": 4.38,
+            "std": 0.00925,
+            "min": 4.36,
+            "max": 4.42,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "56_conv_standard_2D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 2.99,
+            "std": 0.135,
+            "min": 2.78,
+            "max": 3.56,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "57_conv_transposed_2D__square_input__square_kernel.py": {
+            "mean": 6.47,
+            "std": 0.386,
+            "min": 6.39,
+            "max": 10.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "58_conv_transposed_3D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 7.74,
+            "std": 0.018,
+            "min": 7.72,
+            "max": 7.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "59_conv_standard_3D__asymmetric_input__square_kernel.py": {
+            "mean": 2.89,
+            "std": 0.0129,
+            "min": 2.87,
+            "max": 2.95,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "60_conv_standard_3D__square_input__asymmetric_kernel.py": {
+            "mean": 7.71,
+            "std": 0.0184,
+            "min": 7.66,
+            "max": 7.76,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "61_conv_transposed_3D__square_input__square_kernel.py": {
+            "mean": 9.08,
+            "std": 0.00805,
+            "min": 9.06,
+            "max": 9.11,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "62_conv_standard_2D__square_input__asymmetric_kernel.py": {
+            "mean": 2.46,
+            "std": 0.0206,
+            "min": 2.43,
+            "max": 2.51,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "63_conv_standard_2D__square_input__square_kernel.py": {
+            "mean": 12.7,
+            "std": 0.139,
+            "min": 12.6,
+            "max": 13.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "64_conv_transposed_1D.py": {
+            "mean": 5.33,
+            "std": 0.209,
+            "min": 5.2,
+            "max": 7.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "65_conv_transposed_2D__square_input__asymmetric_kernel.py": {
+            "mean": 2.65,
+            "std": 0.0405,
+            "min": 2.62,
+            "max": 2.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "66_conv_standard_3D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 3.8,
+            "std": 0.00863,
+            "min": 3.79,
+            "max": 3.84,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "67_conv_standard_1D.py": {
+            "mean": 2.65,
+            "std": 0.0146,
+            "min": 2.63,
+            "max": 2.71,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "68_conv_transposed_3D__square_input__asymmetric_kernel.py": {
+            "mean": 36.9,
+            "std": 0.146,
+            "min": 36.8,
+            "max": 38.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "69_conv_transposed_2D__asymmetric_input__asymmetric_kernel.py": {
+            "mean": 2.83,
+            "std": 0.0309,
+            "min": 2.78,
+            "max": 3.02,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "70_conv_transposed_3D__asymmetric_input__square_kernel.py": {
+            "mean": 29.3,
+            "std": 0.0182,
+            "min": 29.3,
+            "max": 29.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "71_conv_transposed_2D__asymmetric_input__square_kernel.py": {
+            "mean": 1.6,
+            "std": 0.0117,
+            "min": 1.58,
+            "max": 1.64,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "72_conv_transposed_3D_asymmetric_input_asymmetric_kernel___strided_padded_grouped_.py": {
+            "mean": 2.82,
+            "std": 0.00789,
+            "min": 2.8,
+            "max": 2.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "73_conv_transposed_3D_asymmetric_input_square_kernel__strided_padded__grouped.py": {
+            "mean": 2.2,
+            "std": 0.193,
+            "min": 2.11,
+            "max": 3.98,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "74_conv_transposed_1D_dilated.py": {
+            "mean": 2.35,
+            "std": 2.41,
+            "min": 2.09,
+            "max": 26.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "75_conv_transposed_2D_asymmetric_input_asymmetric_kernel_strided__grouped____padded____dilated__.py": {
+            "mean": 6.75,
+            "std": 0.129,
+            "min": 6.66,
+            "max": 7.76,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "76_conv_standard_1D_dilated_strided__.py": {
+            "mean": 12.3,
+            "std": 0.25,
+            "min": 12.1,
+            "max": 14.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "77_conv_transposed_3D_square_input_square_kernel___padded____dilated____strided__.py": {
+            "mean": 1.96,
+            "std": 0.0339,
+            "min": 1.92,
+            "max": 2.25,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "78_conv_transposed_2D_asymmetric_input_asymmetric_kernel___padded__.py": {
+            "mean": 2.36,
+            "std": 0.0277,
+            "min": 2.34,
+            "max": 2.57,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "79_conv_transposed_1D_asymmetric_input_square_kernel___padded____strided____dilated__.py": {
+            "mean": 1.91,
+            "std": 0.0754,
+            "min": 1.87,
+            "max": 2.65,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "80_conv_standard_2D_square_input_asymmetric_kernel___dilated____padded__.py": {
+            "mean": 2.68,
+            "std": 0.0636,
+            "min": 2.63,
+            "max": 2.95,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "81_conv_transposed_2D_asymmetric_input_square_kernel___dilated____padded____strided__.py": {
+            "mean": 1.88,
+            "std": 0.021,
+            "min": 1.85,
+            "max": 2.05,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "82_conv_depthwise_2D_square_input_square_kernel.py": {
+            "mean": 2.48,
+            "std": 0.098,
+            "min": 2.45,
+            "max": 3.43,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "83_conv_depthwise_2D_square_input_asymmetric_kernel.py": {
+            "mean": 7.63,
+            "std": 0.0811,
+            "min": 7.52,
+            "max": 8.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "84_conv_depthwise_2D_asymmetric_input_square_kernel.py": {
+            "mean": 9.83,
+            "std": 0.21,
+            "min": 9.78,
+            "max": 11.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "85_conv_depthwise_2D_asymmetric_input_asymmetric_kernel.py": {
+            "mean": 13.8,
+            "std": 0.0502,
+            "min": 13.8,
+            "max": 14.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "86_conv_depthwise_separable_2D.py": {
+            "mean": 4.18,
+            "std": 0.0915,
+            "min": 4.16,
+            "max": 4.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "87_conv_pointwise_2D.py": {
+            "mean": 13.3,
+            "std": 0.179,
+            "min": 13.3,
+            "max": 13.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "88_MinGPTNewGelu.py": {
+            "mean": 0.214,
+            "std": 0.0401,
+            "min": 0.182,
+            "max": 0.457,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "89_cumsum.py": {
+            "mean": 4.7,
+            "std": 0.671,
+            "min": 4.6,
+            "max": 11.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "90_cumprod.py": {
+            "mean": 4.66,
+            "std": 0.154,
+            "min": 4.61,
+            "max": 6.13,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "91_cumsum_reverse.py": {
+            "mean": 7.45,
+            "std": 0.0784,
+            "min": 7.39,
+            "max": 7.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "92_cumsum_exclusive.py": {
+            "mean": 3.15,
+            "std": 0.173,
+            "min": 3.11,
+            "max": 4.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "93_masked_cumsum.py": {
+            "mean": 3.84,
+            "std": 4.14,
+            "min": 3.42,
+            "max": 45.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "94_MSELoss.py": {
+            "mean": 2.81,
+            "std": 0.0698,
+            "min": 2.78,
+            "max": 3.09,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "95_CrossEntropyLoss.py": {
+            "mean": 0.292,
+            "std": 0.00691,
+            "min": 0.287,
+            "max": 0.324,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "96_HuberLoss.py": {
+            "mean": 2.71,
+            "std": 0.0124,
+            "min": 2.7,
+            "max": 2.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "97_ScaledDotProductAttention.py": {
+            "mean": 8.15,
+            "std": 0.176,
+            "min": 8.02,
+            "max": 8.98,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "98_KLDivLoss.py": {
+            "mean": 0.779,
+            "std": 0.0124,
+            "min": 0.764,
+            "max": 0.874,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "99_TripletMarginLoss.py": {
+            "mean": 1.06,
+            "std": 0.0148,
+            "min": 1.05,
+            "max": 1.16,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "100_HingeLoss.py": {
+            "mean": 1.38,
+            "std": 0.00479,
+            "min": 1.37,
+            "max": 1.41,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        }
+    },
+    "level2": {
+        "1_Conv2D_ReLU_BiasAdd.py": {
+            "mean": 1.96,
+            "std": 0.0439,
+            "min": 1.94,
+            "max": 2.34,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py": {
+            "mean": 3.44,
+            "std": 0.0889,
+            "min": 3.41,
+            "max": 4.23,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "3_ConvTranspose3d_Sum_LayerNorm_AvgPool_GELU.py": {
+            "mean": 2.53,
+            "std": 0.0199,
+            "min": 2.52,
+            "max": 2.66,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "4_Conv2d_Mish_Mish.py": {
+            "mean": 4.78,
+            "std": 0.0456,
+            "min": 4.66,
+            "max": 4.91,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "5_ConvTranspose2d_Subtract_Tanh.py": {
+            "mean": 3.6,
+            "std": 0.383,
+            "min": 3.55,
+            "max": 7.41,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "6_Conv3d_Softmax_MaxPool_MaxPool.py": {
+            "mean": 0.621,
+            "std": 0.0151,
+            "min": 0.617,
+            "max": 0.768,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "7_Conv3d_ReLU_LeakyReLU_GELU_Sigmoid_BiasAdd.py": {
+            "mean": 3.01,
+            "std": 0.113,
+            "min": 2.99,
+            "max": 4.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py": {
+            "mean": 2.51,
+            "std": 0.0181,
+            "min": 2.48,
+            "max": 2.61,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "9_Matmul_Subtract_Multiply_ReLU.py": {
+            "mean": 2.75,
+            "std": 0.0277,
+            "min": 2.73,
+            "max": 2.99,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "10_ConvTranspose2d_MaxPool_Hardtanh_Mean_Tanh.py": {
+            "mean": 6.41,
+            "std": 0.0426,
+            "min": 6.39,
+            "max": 6.72,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "11_ConvTranspose2d_BatchNorm_Tanh_MaxPool_GroupNorm.py": {
+            "mean": 1.42,
+            "std": 0.0375,
+            "min": 1.4,
+            "max": 1.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "12_Gemm_Multiply_LeakyReLU.py": {
+            "mean": 2.77,
+            "std": 0.0199,
+            "min": 2.75,
+            "max": 2.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "13_ConvTranspose3d_Mean_Add_Softmax_Tanh_Scaling.py": {
+            "mean": 8.37,
+            "std": 0.0256,
+            "min": 8.34,
+            "max": 8.54,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "14_Gemm_Divide_Sum_Scaling.py": {
+            "mean": 2.77,
+            "std": 0.0197,
+            "min": 2.75,
+            "max": 2.92,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "15_ConvTranspose3d_BatchNorm_Subtract.py": {
+            "mean": 1.47,
+            "std": 0.211,
+            "min": 1.42,
+            "max": 3.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "16_ConvTranspose2d_Mish_Add_Hardtanh_Scaling.py": {
+            "mean": 3.49,
+            "std": 0.0753,
+            "min": 3.46,
+            "max": 4.05,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "17_Conv2d_InstanceNorm_Divide.py": {
+            "mean": 5.18,
+            "std": 0.067,
+            "min": 5.13,
+            "max": 5.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py": {
+            "mean": 2.71,
+            "std": 0.0101,
+            "min": 2.69,
+            "max": 2.74,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "19_ConvTranspose2d_GELU_GroupNorm.py": {
+            "mean": 8.14,
+            "std": 0.0421,
+            "min": 8.11,
+            "max": 8.49,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "20_ConvTranspose3d_Sum_ResidualAdd_Multiply_ResidualAdd.py": {
+            "mean": 1.13,
+            "std": 0.188,
+            "min": 1.1,
+            "max": 2.97,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "21_Conv2d_Add_Scale_Sigmoid_GroupNorm.py": {
+            "mean": 2.97,
+            "std": 0.0319,
+            "min": 2.9,
+            "max": 3.06,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "22_Matmul_Scale_ResidualAdd_Clamp_LogSumExp_Mish.py": {
+            "mean": 2.77,
+            "std": 0.0125,
+            "min": 2.76,
+            "max": 2.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "23_Conv3d_GroupNorm_Mean.py": {
+            "mean": 2.65,
+            "std": 0.00985,
+            "min": 2.64,
+            "max": 2.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "24_Conv3d_Min_Softmax.py": {
+            "mean": 0.867,
+            "std": 0.00983,
+            "min": 0.856,
+            "max": 0.953,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "25_Conv2d_Min_Tanh_Tanh.py": {
+            "mean": 2.68,
+            "std": 0.0178,
+            "min": 2.66,
+            "max": 2.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "26_ConvTranspose3d_Add_HardSwish.py": {
+            "mean": 2.47,
+            "std": 0.0541,
+            "min": 2.45,
+            "max": 3.0,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "27_Conv3d_HardSwish_GroupNorm_Mean.py": {
+            "mean": 8.22,
+            "std": 0.0204,
+            "min": 8.2,
+            "max": 8.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "28_BMM_InstanceNorm_Sum_ResidualAdd_Multiply.py": {
+            "mean": 2.82,
+            "std": 0.0149,
+            "min": 2.8,
+            "max": 2.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "29_Matmul_Mish_Mish.py": {
+            "mean": 2.76,
+            "std": 0.0137,
+            "min": 2.74,
+            "max": 2.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "30_Gemm_GroupNorm_Hardtanh.py": {
+            "mean": 2.75,
+            "std": 0.00965,
+            "min": 2.74,
+            "max": 2.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "31_Conv2d_Min_Add_Multiply.py": {
+            "mean": 3.54,
+            "std": 0.0711,
+            "min": 3.48,
+            "max": 4.19,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "32_Conv2d_Scaling_Min.py": {
+            "mean": 4.73,
+            "std": 0.0626,
+            "min": 4.62,
+            "max": 4.85,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "33_Gemm_Scale_BatchNorm.py": {
+            "mean": 2.8,
+            "std": 0.0209,
+            "min": 2.79,
+            "max": 2.96,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "34_ConvTranspose3d_LayerNorm_GELU_Scaling.py": {
+            "mean": 2.35,
+            "std": 0.357,
+            "min": 2.29,
+            "max": 5.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "35_Conv2d_Subtract_HardSwish_MaxPool_Mish.py": {
+            "mean": 4.32,
+            "std": 0.0263,
+            "min": 4.27,
+            "max": 4.43,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "36_ConvTranspose2d_Min_Sum_GELU_Add.py": {
+            "mean": 0.987,
+            "std": 0.0279,
+            "min": 0.974,
+            "max": 1.22,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "37_Matmul_Swish_Sum_GroupNorm.py": {
+            "mean": 6.07,
+            "std": 0.0683,
+            "min": 6.05,
+            "max": 6.74,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "38_ConvTranspose3d_AvgPool_Clamp_Softmax_Multiply.py": {
+            "mean": 2.76,
+            "std": 0.0726,
+            "min": 2.74,
+            "max": 3.48,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "39_Gemm_Scale_BatchNorm.py": {
+            "mean": 11.1,
+            "std": 0.0397,
+            "min": 11.0,
+            "max": 11.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "40_Matmul_Scaling_ResidualAdd.py": {
+            "mean": 11.0,
+            "std": 0.08,
+            "min": 10.9,
+            "max": 11.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "41_Gemm_BatchNorm_GELU_ReLU.py": {
+            "mean": 11.1,
+            "std": 0.0426,
+            "min": 11.1,
+            "max": 11.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "42_ConvTranspose2d_GlobalAvgPool_BiasAdd_LogSumExp_Sum_Multiply.py": {
+            "mean": 5.54,
+            "std": 0.0282,
+            "min": 5.5,
+            "max": 5.76,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "43_Conv3d_Max_LogSumExp_ReLU.py": {
+            "mean": 2.35,
+            "std": 0.0167,
+            "min": 2.33,
+            "max": 2.44,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "44_ConvTranspose2d_Multiply_GlobalAvgPool_GlobalAvgPool_Mean.py": {
+            "mean": 0.949,
+            "std": 0.0109,
+            "min": 0.939,
+            "max": 1.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "45_Gemm_Sigmoid_LogSumExp.py": {
+            "mean": 8.42,
+            "std": 0.0526,
+            "min": 8.38,
+            "max": 8.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "46_Conv2d_Subtract_Tanh_Subtract_AvgPool.py": {
+            "mean": 2.4,
+            "std": 0.0684,
+            "min": 2.37,
+            "max": 3.07,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "47_Conv3d_Mish_Tanh.py": {
+            "mean": 1.96,
+            "std": 0.628,
+            "min": 1.86,
+            "max": 8.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "48_Conv3d_Scaling_Tanh_Multiply_Sigmoid.py": {
+            "mean": 1.96,
+            "std": 0.0412,
+            "min": 1.95,
+            "max": 2.36,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "49_ConvTranspose3d_Softmax_Sigmoid.py": {
+            "mean": 1.5,
+            "std": 0.0558,
+            "min": 1.48,
+            "max": 2.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "50_ConvTranspose3d_Scaling_AvgPool_BiasAdd_Scaling.py": {
+            "mean": 4.64,
+            "std": 0.041,
+            "min": 4.59,
+            "max": 4.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "51_Gemm_Subtract_GlobalAvgPool_LogSumExp_GELU_ResidualAdd.py": {
+            "mean": 5.49,
+            "std": 0.0264,
+            "min": 5.46,
+            "max": 5.69,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "52_Conv2d_Activation_BatchNorm.py": {
+            "mean": 3.47,
+            "std": 0.0735,
+            "min": 3.42,
+            "max": 4.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "53_Gemm_Scaling_Hardtanh_GELU.py": {
+            "mean": 5.45,
+            "std": 0.0261,
+            "min": 5.44,
+            "max": 5.67,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "54_Conv2d_Multiply_LeakyReLU_GELU.py": {
+            "mean": 2.79,
+            "std": 0.0742,
+            "min": 2.76,
+            "max": 3.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "55_Matmul_MaxPool_Sum_Scale.py": {
+            "mean": 5.33,
+            "std": 0.019,
+            "min": 5.3,
+            "max": 5.39,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "56_Matmul_Sigmoid_Sum.py": {
+            "mean": 5.31,
+            "std": 0.0128,
+            "min": 5.29,
+            "max": 5.35,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "57_Conv2d_ReLU_HardSwish.py": {
+            "mean": 0.814,
+            "std": 0.0219,
+            "min": 0.801,
+            "max": 0.985,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "58_ConvTranspose3d_LogSumExp_HardSwish_Subtract_Clamp.py": {
+            "mean": 3.62,
+            "std": 0.0232,
+            "min": 3.59,
+            "max": 3.71,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "59_Matmul_Swish_Scaling.py": {
+            "mean": 5.31,
+            "std": 0.0196,
+            "min": 5.28,
+            "max": 5.41,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "60_ConvTranspose3d_Swish_GroupNorm_HardSwish.py": {
+            "mean": 4.56,
+            "std": 0.105,
+            "min": 4.51,
+            "max": 5.53,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "61_ConvTranspose3d_ReLU_GroupNorm.py": {
+            "mean": 3.68,
+            "std": 0.0648,
+            "min": 3.62,
+            "max": 4.27,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "62_Matmul_GroupNorm_LeakyReLU_Sum.py": {
+            "mean": 2.76,
+            "std": 0.037,
+            "min": 2.74,
+            "max": 3.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "63_Gemm_ReLU_Divide.py": {
+            "mean": 2.77,
+            "std": 0.0124,
+            "min": 2.76,
+            "max": 2.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "64_Gemm_LogSumExp_LeakyReLU_LeakyReLU_GELU_GELU.py": {
+            "mean": 2.73,
+            "std": 0.00902,
+            "min": 2.72,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "65_Conv2d_AvgPool_Sigmoid_Sum.py": {
+            "mean": 8.78,
+            "std": 0.0425,
+            "min": 8.74,
+            "max": 9.01,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "66_Matmul_Dropout_Softmax.py": {
+            "mean": 1.5,
+            "std": 0.013,
+            "min": 1.49,
+            "max": 1.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "67_Conv2d_GELU_GlobalAvgPool.py": {
+            "mean": 4.62,
+            "std": 0.0176,
+            "min": 4.59,
+            "max": 4.74,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "68_Matmul_Min_Subtract.py": {
+            "mean": 1.43,
+            "std": 0.00848,
+            "min": 1.42,
+            "max": 1.47,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "69_Conv2d_HardSwish_ReLU.py": {
+            "mean": 0.837,
+            "std": 0.0158,
+            "min": 0.81,
+            "max": 0.94,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "70_Gemm_Sigmoid_Scaling_ResidualAdd.py": {
+            "mean": 2.77,
+            "std": 0.0495,
+            "min": 2.74,
+            "max": 3.24,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "71_Conv2d_Divide_LeakyReLU.py": {
+            "mean": 1.56,
+            "std": 0.0617,
+            "min": 1.53,
+            "max": 2.14,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "72_ConvTranspose3d_BatchNorm_AvgPool_AvgPool.py": {
+            "mean": 8.82,
+            "std": 0.0687,
+            "min": 8.76,
+            "max": 9.18,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "73_Conv2d_BatchNorm_Scaling.py": {
+            "mean": 1.25,
+            "std": 2.15,
+            "min": 1.02,
+            "max": 22.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "74_ConvTranspose3d_LeakyReLU_Multiply_LeakyReLU_Max.py": {
+            "mean": 0.816,
+            "std": 0.016,
+            "min": 0.8,
+            "max": 0.916,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "75_Gemm_GroupNorm_Min_BiasAdd.py": {
+            "mean": 2.76,
+            "std": 0.00917,
+            "min": 2.74,
+            "max": 2.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "76_Gemm_Add_ReLU.py": {
+            "mean": 2.77,
+            "std": 0.00986,
+            "min": 2.76,
+            "max": 2.82,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "77_ConvTranspose3d_Scale_BatchNorm_GlobalAvgPool.py": {
+            "mean": 4.92,
+            "std": 0.0343,
+            "min": 4.82,
+            "max": 5.03,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "78_ConvTranspose3d_Max_Max_Sum.py": {
+            "mean": 47.0,
+            "std": 0.0278,
+            "min": 46.9,
+            "max": 47.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "79_Conv3d_Multiply_InstanceNorm_Clamp_Multiply_Max.py": {
+            "mean": 0.508,
+            "std": 0.0102,
+            "min": 0.49,
+            "max": 0.563,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "80_Gemm_Max_Subtract_GELU.py": {
+            "mean": 2.73,
+            "std": 0.0146,
+            "min": 2.71,
+            "max": 2.82,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "81_Gemm_Swish_Divide_Clamp_Tanh_Clamp.py": {
+            "mean": 2.77,
+            "std": 0.018,
+            "min": 2.76,
+            "max": 2.92,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "82_Conv2d_Tanh_Scaling_BiasAdd_Max.py": {
+            "mean": 6.54,
+            "std": 0.0194,
+            "min": 6.52,
+            "max": 6.68,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "83_Conv3d_GroupNorm_Min_Clamp_Dropout.py": {
+            "mean": 6.43,
+            "std": 0.0199,
+            "min": 6.41,
+            "max": 6.55,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "84_Gemm_BatchNorm_Scaling_Softmax.py": {
+            "mean": 2.76,
+            "std": 0.0121,
+            "min": 2.73,
+            "max": 2.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "85_Conv2d_GroupNorm_Scale_MaxPool_Clamp.py": {
+            "mean": 1.4,
+            "std": 0.0121,
+            "min": 1.38,
+            "max": 1.48,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "86_Matmul_Divide_GELU.py": {
+            "mean": 2.77,
+            "std": 0.00717,
+            "min": 2.76,
+            "max": 2.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "87_Conv2d_Subtract_Subtract_Mish.py": {
+            "mean": 6.98,
+            "std": 0.33,
+            "min": 6.91,
+            "max": 10.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "88_Gemm_GroupNorm_Swish_Multiply_Swish.py": {
+            "mean": 2.72,
+            "std": 0.0451,
+            "min": 2.71,
+            "max": 3.17,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "89_ConvTranspose3d_MaxPool_Softmax_Subtract_Swish_Max.py": {
+            "mean": 4.76,
+            "std": 0.0361,
+            "min": 4.72,
+            "max": 5.04,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "90_Conv3d_LeakyReLU_Sum_Clamp_GELU.py": {
+            "mean": 10.0,
+            "std": 0.122,
+            "min": 9.96,
+            "max": 11.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "91_ConvTranspose2d_Softmax_BiasAdd_Scaling_Sigmoid.py": {
+            "mean": 3.81,
+            "std": 0.111,
+            "min": 3.77,
+            "max": 4.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "92_Conv2d_GroupNorm_Tanh_HardSwish_ResidualAdd_LogSumExp.py": {
+            "mean": 3.44,
+            "std": 0.0195,
+            "min": 3.42,
+            "max": 3.58,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "93_ConvTranspose2d_Add_Min_GELU_Multiply.py": {
+            "mean": 2.54,
+            "std": 0.178,
+            "min": 2.48,
+            "max": 4.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "94_Gemm_BiasAdd_Hardtanh_Mish_GroupNorm.py": {
+            "mean": 2.79,
+            "std": 0.0192,
+            "min": 2.77,
+            "max": 2.94,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "95_Matmul_Add_Swish_Tanh_GELU_Hardtanh.py": {
+            "mean": 2.76,
+            "std": 0.0441,
+            "min": 2.75,
+            "max": 3.2,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "96_ConvTranspose3d_Multiply_Max_GlobalAvgPool_Clamp.py": {
+            "mean": 4.6,
+            "std": 0.0242,
+            "min": 4.57,
+            "max": 4.71,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "97_Matmul_BatchNorm_BiasAdd_Divide_Swish.py": {
+            "mean": 2.75,
+            "std": 0.0434,
+            "min": 2.73,
+            "max": 3.17,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "98_Matmul_AvgPool_GELU_Scale_Max.py": {
+            "mean": 2.72,
+            "std": 0.0114,
+            "min": 2.71,
+            "max": 2.77,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "99_Matmul_GELU_Softmax.py": {
+            "mean": 2.78,
+            "std": 0.0113,
+            "min": 2.76,
+            "max": 2.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "100_ConvTranspose3d_Clamp_Min_Divide.py": {
+            "mean": 8.29,
+            "std": 0.224,
+            "min": 8.23,
+            "max": 10.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        }
+    },
+    "level3": {
+        "1_MLP.py": {
+            "mean": 3.79,
+            "std": 0.0141,
+            "min": 3.77,
+            "max": 3.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "2_ShallowWideMLP.py": {
+            "mean": 11.0,
+            "std": 0.568,
+            "min": 10.7,
+            "max": 12.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "3_DeepNarrowMLP.py": {
+            "mean": 1.72,
+            "std": 0.00618,
+            "min": 1.71,
+            "max": 1.75,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "4_LeNet5.py": {
+            "mean": 0.769,
+            "std": 0.0104,
+            "min": 0.75,
+            "max": 0.822,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "5_AlexNet.py": {
+            "mean": 16.7,
+            "std": 0.0755,
+            "min": 16.5,
+            "max": 16.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "6_GoogleNetInceptionModule.py": {
+            "mean": 5.16,
+            "std": 0.0509,
+            "min": 5.14,
+            "max": 5.64,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "7_GoogleNetInceptionV1.py": {
+            "mean": 2.01,
+            "std": 0.0709,
+            "min": 1.97,
+            "max": 2.59,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "8_ResNetBasicBlock.py": {
+            "mean": 0.875,
+            "std": 0.04,
+            "min": 0.851,
+            "max": 1.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "9_ResNet18.py": {
+            "mean": 1.47,
+            "std": 0.0297,
+            "min": 1.45,
+            "max": 1.71,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "10_ResNet101.py": {
+            "mean": 8.02,
+            "std": 0.0601,
+            "min": 7.93,
+            "max": 8.42,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "11_VGG16.py": {
+            "mean": 2.12,
+            "std": 0.0126,
+            "min": 2.1,
+            "max": 2.16,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "12_VGG19.py": {
+            "mean": 2.43,
+            "std": 0.0107,
+            "min": 2.41,
+            "max": 2.48,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "13_DenseNet121TransitionLayer.py": {
+            "mean": 3.15,
+            "std": 0.874,
+            "min": 3.06,
+            "max": 11.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "14_DenseNet121DenseBlock.py": {
+            "mean": 4.62,
+            "std": 0.0174,
+            "min": 4.6,
+            "max": 4.73,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "15_DenseNet121.py": {
+            "mean": 8.93,
+            "std": 0.372,
+            "min": 8.0,
+            "max": 9.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "16_DenseNet201.py": {
+            "mean": 21.8,
+            "std": 0.334,
+            "min": 21.0,
+            "max": 22.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "17_SqueezeNetFireModule.py": {
+            "mean": 6.24,
+            "std": 0.0755,
+            "min": 6.2,
+            "max": 6.83,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "18_SqueezeNet.py": {
+            "mean": 12.8,
+            "std": 0.0246,
+            "min": 12.8,
+            "max": 12.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "19_MobileNetV1.py": {
+            "mean": 1.81,
+            "std": 0.0576,
+            "min": 1.77,
+            "max": 2.34,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "20_MobileNetV2.py": {
+            "mean": 3.2,
+            "std": 0.0397,
+            "min": 3.15,
+            "max": 3.5,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "21_EfficientNetMBConv.py": {
+            "mean": 3.62,
+            "std": 0.0123,
+            "min": 3.61,
+            "max": 3.71,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "22_EfficientNetB0.py": {
+            "mean": 3.21,
+            "std": 0.0773,
+            "min": 3.14,
+            "max": 3.81,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "23_EfficientNetB1.py": {
+            "mean": 2.19,
+            "std": 0.0314,
+            "min": 2.13,
+            "max": 2.32,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "24_EfficientNetB2.py": {
+            "mean": 1.66,
+            "std": 0.0512,
+            "min": 1.6,
+            "max": 1.93,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "25_ShuffleNetUnit.py": {
+            "mean": 6.72,
+            "std": 0.0185,
+            "min": 6.7,
+            "max": 6.86,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "26_ShuffleNet.py": {
+            "mean": 8.34,
+            "std": 0.0852,
+            "min": 8.25,
+            "max": 9.07,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "27_RegNet.py": {
+            "mean": 1.17,
+            "std": 0.0177,
+            "min": 1.16,
+            "max": 1.27,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "28_VisionTransformer.py": {
+            "mean": 1.37,
+            "std": 0.238,
+            "min": 1.28,
+            "max": 3.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "29_SwinMLP.py": {
+            "mean": 3.17,
+            "std": 0.151,
+            "min": 3.12,
+            "max": 4.65,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "30_SwinTransformerV2.py": {
+            "mean": 4.86,
+            "std": 0.011,
+            "min": 4.84,
+            "max": 4.89,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "31_VisionAttention.py": {
+            "mean": 14.4,
+            "std": 0.109,
+            "min": 14.2,
+            "max": 14.8,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "32_ConvolutionalVisionTransformer.py": {
+            "mean": 1.45,
+            "std": 0.0212,
+            "min": 1.4,
+            "max": 1.53,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "33_VanillaRNN.py": {
+            "mean": 6.85,
+            "std": 0.023,
+            "min": 6.8,
+            "max": 6.93,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "34_VanillaRNNHidden.py": {
+            "mean": 11.2,
+            "std": 0.276,
+            "min": 10.8,
+            "max": 13.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "35_LSTM.py": {
+            "mean": 37.4,
+            "std": 1.34,
+            "min": 36.0,
+            "max": 39.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "36_LSTMHn.py": {
+            "mean": 35.4,
+            "std": 0.517,
+            "min": 34.8,
+            "max": 38.4,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "37_LSTMCn.py": {
+            "mean": 25.5,
+            "std": 1.0,
+            "min": 24.8,
+            "max": 31.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "38_LSTMBidirectional.py": {
+            "mean": 49.7,
+            "std": 0.0826,
+            "min": 49.6,
+            "max": 50.1,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "39_GRU.py": {
+            "mean": 41.3,
+            "std": 0.144,
+            "min": 40.9,
+            "max": 41.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "40_GRUHidden.py": {
+            "mean": 49.3,
+            "std": 1.59,
+            "min": 48.4,
+            "max": 59.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "41_GRUBidirectional.py": {
+            "mean": 82.1,
+            "std": 0.341,
+            "min": 81.4,
+            "max": 82.9,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "42_GRUBidirectionalHidden.py": {
+            "mean": 76.5,
+            "std": 2.67,
+            "min": 64.1,
+            "max": 77.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "43_MinGPTCausalAttention.py": {
+            "mean": 10.4,
+            "std": 0.33,
+            "min": 10.2,
+            "max": 11.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "44_MiniGPTBlock.py": {
+            "mean": 23.8,
+            "std": 0.62,
+            "min": 23.4,
+            "max": 26.6,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "45_UNetSoftmax.py": {
+            "mean": 5.1,
+            "std": 0.018,
+            "min": 5.06,
+            "max": 5.17,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "46_NetVladWithGhostClusters.py": {
+            "mean": 1.33,
+            "std": 1.05,
+            "min": 1.12,
+            "max": 11.7,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "47_NetVladNoGhostClusters.py": {
+            "mean": 0.953,
+            "std": 0.036,
+            "min": 0.941,
+            "max": 1.27,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "48_Mamba2ReturnY.py": {
+            "mean": 4.65,
+            "std": 0.0209,
+            "min": 4.63,
+            "max": 4.84,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "49_Mamba2ReturnFinalState.py": {
+            "mean": 1.64,
+            "std": 2.19,
+            "min": 1.4,
+            "max": 23.3,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        },
+        "50_ReLUSelfAttention.py": {
+            "mean": 3.23,
+            "std": 0.0162,
+            "min": 3.22,
+            "max": 3.36,
+            "num_trials": 100,
+            "hardware": "NVIDIA H100 80GB HBM3",
+            "device": "cuda:0"
+        }
+    }
+}
\ No newline at end of file
diff --git a/results/timing/README.md b/results/timing/README.md
index 934d1699..11434770 100644
--- a/results/timing/README.md
+++ b/results/timing/README.md
@@ -5,6 +5,22 @@ This folder contains a set of baseline timing results for the KernelBench proble
 
 Since KernelBench measures the speedup between Runtime(refernece architecture) and Runtime(LLM-generated architecture), it is important to measure the baseline reference module runtime.
 
+## When are these baseline JSONs used?
+
+Baseline timing JSONs in this folder are primarily used for **offline analysis / scoring** where you want a consistent reference runtime without re-timing the PyTorch reference on every run.
+
+In contrast, some workflows compute speedup using **live timing**:
+
+- **`scripts/run_and_check.py`**
+  - Measures the PyTorch reference runtime by calling `kernelbench.timing.measure_ref_program_time(...)` (eager and optionally `torch.compile`).
+  - Measures the candidate kernel runtime via `kernelbench.eval.eval_kernel_against_ref(...)`.
+  - Prints speedup as reference_time / kernel_time.
+
+- **`kernelbench.eval.eval_kernel_against_ref(...)`** (library API)
+  - Measures candidate kernel runtime directly.
+  - May also time the reference model runtime for additional checks (e.g. excessive speedup detection).
+  - Does **not** read baseline JSONs from this folder.
+
 We have provided a set of baseline results for the KernelBench problems on a variety of hardware as well as various PyTorch configurations.
 All (current) baseline are ran with PyTorch `2.5.0+cu124` and CUDA `12.4`.
 
@@ -14,10 +30,10 @@ For timing, we measure wall clock time. We warm up 3 times and collect runtime s
 
 ### Run on your own cluster
 Since your cluster might be different from ours (different GPU, different power setting, etc.), you can create the baseline results on your own cluster.
-Take a look at `python3 scripts/generate_baseline_time.py` to see how to set and run timing results.
+Take a look at `uv run python scripts/generate_baseline_time.py` to see how to set and run timing results.
 
 ### Run on modal
-To gather baseline on modal, take a look at `python3 scripts/generate_baseline_time_modal.py` to see how we are doing it.
+To gather baseline on modal, take a look at `uv run python scripts/generate_baseline_time_modal.py` to see how we are doing it.
 
 ### Hardware
 
diff --git a/scripts/benchmark_eval_analysis.py b/scripts/benchmark_eval_analysis.py
index e2bea005..ee1b9753 100644
--- a/scripts/benchmark_eval_analysis.py
+++ b/scripts/benchmark_eval_analysis.py
@@ -2,7 +2,7 @@
 
 import pydra
 from pydra import Config, REQUIRED
-from src.dataset import construct_kernelbench_dataset
+from kernelbench.dataset import construct_kernelbench_dataset
 from tabulate import tabulate
 
 """
@@ -17,9 +17,17 @@
 
 Usage:
 ```
-python3 scripts/benchmark_eval_analysis.py run_name=<run_name> level=<level> hardware=<hardware> baseline=<baseline>
+uv run python scripts/benchmark_eval_analysis.py run_name=<run_name> level=<level> hardware=<hardware> baseline=<baseline>
+```
+hardware + baseline should correspond to the results/timing/hardware/baseline.json file
+
+Optional path overrides (for external tools like leaderboards):
+```
+uv run python scripts/benchmark_eval_analysis.py run_name=<run_name> level=<level> hardware=<hardware> baseline=<baseline> \
+    baseline_file=/path/to/baseline.json \
+    eval_results_dir=/path/to/runs \
+    output_file=/path/to/output.json
 ```
-hardware + baseline should correspond to the results/timing/hardware/baseline.json file   
 
 """
 
@@ -32,6 +40,11 @@ def __init__(self):
         self.hardware = REQUIRED  # hardware to evaluate
         self.baseline = REQUIRED  # baseline to compare against
 
+        # Optional path overrides (defaults to standard KernelBench paths)
+        self.baseline_file = None      # Override: direct path to baseline JSON
+        self.eval_results_dir = None   # Override: path to runs directory
+        self.output_file = None        # Write JSON output to file
+
     def __repr__(self):
         return f"AnalysisConfig({self.to_dict()})"
 
@@ -40,7 +53,7 @@ def patch(eval_results, dataset):
     """
     Patch the eval results with the dataset
     """
-    for pid in range(1, len(dataset) + 1):
+    for pid in dataset.get_problem_ids():
         if str(pid) not in eval_results:
             eval_results[str(pid)] = {
                 "sample_id": 0,
@@ -54,24 +67,36 @@ def patch(eval_results, dataset):
     return eval_results
 
 
-def analyze_greedy_eval(run_name, hardware, baseline, level):
+def analyze_greedy_eval(run_name, hardware, baseline, level,
+                        baseline_file=None, eval_results_dir=None) -> dict:
     """
-    Analyze the greedy eval results for a run of a particular level
+    Analyze the greedy eval results for a run of a particular level.
+
+    Returns a dict with all computed metrics.
     """
 
     dataset = construct_kernelbench_dataset(level)
 
-    # load json
-    eval_file_path = f"runs/{run_name}/eval_results.json"
+    # Resolve eval results path (use override if provided)
+    if eval_results_dir:
+        eval_file_path = os.path.join(eval_results_dir, run_name, "eval_results.json")
+        pass_at_k_file_path = os.path.join(eval_results_dir, run_name, "pass_at_k_results.json")
+    else:
+        eval_file_path = f"runs/{run_name}/eval_results.json"
+        pass_at_k_file_path = f"runs/{run_name}/pass_at_k_results.json"
+
     assert os.path.exists(
         eval_file_path
     ), f"Eval file does not exist at {eval_file_path}"
 
-    # Check if pass@k results exist
-    pass_at_k_file_path = f"runs/{run_name}/pass_at_k_results.json"
     has_pass_at_k_results = os.path.exists(pass_at_k_file_path)
 
-    baseline_file_path = f"results/timing/{hardware}/{baseline}.json"
+    # Resolve baseline path (use override if provided)
+    if baseline_file:
+        baseline_file_path = baseline_file
+    else:
+        baseline_file_path = f"results/timing/{hardware}/{baseline}.json"
+
     assert os.path.exists(
         baseline_file_path
     ), f"Baseline file does not exist at {baseline_file_path}"
@@ -129,26 +154,47 @@ def analyze_greedy_eval(run_name, hardware, baseline, level):
     import numpy as np
 
     # Calculate speedup metrics
-    from src.score import (
+    from kernelbench.score import (
         fastp,
         geometric_mean_speed_ratio_correct_and_faster_only,
         geometric_mean_speed_ratio_correct_only,
     )
 
     # Extract the speedup values
-    is_correct = np.array([entry["correctness"] for entry in eval_results.values()])
-    baseline_speed = np.array(
-        [entry["mean"] for entry in baseline_results[f"level{level}"].values()]
-    )
-    actual_speed = np.array([entry["runtime"] for entry in eval_results.values()])
+    is_correct_list = []
+    baseline_speed_list = []
+    actual_speed_list = []
+
+    # Sort problem IDs to ensure consistent order
+    sorted_pids = sorted(dataset.get_problem_ids())
+
+    for pid in sorted_pids:
+        # Get eval result
+        if str(pid) not in eval_results:
+            print(f"Warning: Problem {pid} not found in eval results")
+            continue
+        eval_entry = eval_results[str(pid)]
+        
+        # Get baseline result
+        problem = dataset.get_problem_by_id(pid)
+        problem_name = problem.name
+        
+        if problem_name not in baseline_results[f"level{level}"]:
+            print(f"Warning: Problem {problem_name} not found in baseline results")
+            continue
+            
+        baseline_entry = baseline_results[f"level{level}"][problem_name]
+        
+        is_correct_list.append(eval_entry["correctness"])
+        actual_speed_list.append(eval_entry["runtime"])
+        baseline_speed_list.append(baseline_entry["mean"])
+
+    is_correct = np.array(is_correct_list)
+    baseline_speed = np.array(baseline_speed_list)
+    actual_speed = np.array(actual_speed_list)
     n = len(is_correct)
 
-    assert (
-        len(baseline_speed) == n
-    ), "Baseline speedup values do not match the number of eval results"
-    assert (
-        len(actual_speed) == n
-    ), "Actual speedup values do not match the number of eval results"
+    print(f"Aligned {n} problems for analysis")
 
     # Calculate the metrics
     gmsr_correct = geometric_mean_speed_ratio_correct_only(
@@ -157,7 +203,7 @@ def analyze_greedy_eval(run_name, hardware, baseline, level):
 
     # list of speedup thresholds p
     p_values = [0.0, 0.5, 0.8, 1.0, 1.5, 2.0]
-    results = [
+    fast_p_results = [
         [p, fastp(is_correct, baseline_speed, actual_speed, n, p)] for p in p_values
     ]
 
@@ -169,7 +215,7 @@ def analyze_greedy_eval(run_name, hardware, baseline, level):
     print("\nFast_p Results:")
     print(
         tabulate(
-            results, headers=["Speedup Threshold (p)", "Fast_p Score"], tablefmt="grid"
+            fast_p_results, headers=["Speedup Threshold (p)", "Fast_p Score"], tablefmt="grid"
         )
     )
 
@@ -193,10 +239,49 @@ def analyze_greedy_eval(run_name, hardware, baseline, level):
             avg_table = [[k, v] for k, v in averages.items()]
             print(tabulate(avg_table, headers=["Metric", "Value"], tablefmt="grid"))
 
+    # Build and return results dict
+    results = {
+        "run_name": run_name,
+        "level": level,
+        "hardware": hardware,
+        "total_count": total_count,
+        "total_eval": total_eval,
+        "compiled_count": compiled_count,
+        "correct_count": correct_count,
+        "compilation_rate": compiled_count / total_count if total_count > 0 else 0.0,
+        "correctness_rate": correct_count / total_count if total_count > 0 else 0.0,
+        "geo_mean_speedup": float(gmsr_correct),
+        "fast_p": {str(p): float(score) for p, score in fast_p_results},
+    }
+
+    # Include pass@k if available
+    if pass_at_k_results:
+        results["pass_at_k"] = {
+            "metadata": pass_at_k_results.get("metadata", {}),
+            "averages": pass_at_k_results.get("averages", {})
+        }
+
+    return results
+
 
 @pydra.main(base=AnalysisConfig)
 def main(config: AnalysisConfig):
-    analyze_greedy_eval(config.run_name, config.hardware, config.baseline, config.level)
+    results = analyze_greedy_eval(
+        config.run_name,
+        config.hardware,
+        config.baseline,
+        config.level,
+        baseline_file=config.baseline_file,
+        eval_results_dir=config.eval_results_dir
+    )
+
+    # Write JSON output if requested
+    if config.output_file:
+        with open(config.output_file, 'w') as f:
+            json.dump(results, f, indent=2)
+        print(f"\nResults written to: {config.output_file}")
+
+    return results
 
 
 if __name__ == "__main__":
diff --git a/scripts/debug_stddout.py b/scripts/debug_stddout.py
index b3eb81f0..9de30023 100644
--- a/scripts/debug_stddout.py
+++ b/scripts/debug_stddout.py
@@ -3,8 +3,8 @@
 import os
 import ninja
 
-from src.utils import set_gpu_arch
-from src.eval import build_compile_cache_with_capturing
+from kernelbench.utils import set_gpu_arch
+from kernelbench.eval import build_compile_cache_with_capturing
 
 ################################################################################
 # Test for checking if we can capture nvcc errors
diff --git a/scripts/eval_from_generations.py b/scripts/eval_from_generations.py
index b28a3be0..6fac151b 100644
--- a/scripts/eval_from_generations.py
+++ b/scripts/eval_from_generations.py
@@ -12,14 +12,13 @@
 import pydra
 import torch
 
-from datasets import load_dataset
 from pydra import Config, REQUIRED
 
 # Import only what we need
-from src import compile, eval, utils
+from kernelbench import compile, eval, utils
 
-from src.dataset import construct_kernelbench_dataset
-from src.eval import (
+from kernelbench.dataset import construct_kernelbench_dataset
+from kernelbench.eval import (
     build_compile_cache,
     get_error_name,
     check_metadata_serializable_all_types,
@@ -27,7 +26,7 @@
     KernelExecResult,
 )
 
-from src.utils import read_file, set_gpu_arch
+from kernelbench.utils import read_file, set_gpu_arch
 from tqdm import tqdm
 
 # Modal support
@@ -47,7 +46,6 @@
 """
 
 REPO_TOP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-KERNEL_BENCH_PATH = os.path.join(REPO_TOP_DIR, "KernelBench")
 
 torch.set_printoptions(precision=4, threshold=10)
 
@@ -55,11 +53,15 @@
 app = modal.App("eval_from_generations_modal")
 gpu_arch_mapping = {"L40S": ["Ada"], "H100": ["Hopper"], "A100": ["Ampere"], "L4": ["Ada"], "T4": ["Turing"], "A10G": ["Ampere"]}
 
-cuda_version = "12.8.0"  # should be no greater than host CUDA version
+cuda_version = "13.0.0"  # should be no greater than host CUDA version
 flavor = "devel"  #  includes full CUDA toolkit
 operating_sys = "ubuntu22.04"
 tag = f"{cuda_version}-{flavor}-{operating_sys}"
 
+SRC_DIR = os.path.join(REPO_TOP_DIR, "src")
+
+KERNELBENCH_DIR = os.path.join(REPO_TOP_DIR, "KernelBench")
+
 image = (
     modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10")
     .apt_install("git",
@@ -67,12 +69,15 @@
                 "g++-10",
                 "clang"
                 )
-    .pip_install_from_requirements(os.path.join(REPO_TOP_DIR, "requirements.txt"))
-    .add_local_dir(
-        KERNEL_BENCH_PATH,
-        remote_path="/root/KernelBench"
-    )
-    .add_local_python_source("src")
+
+    .uv_sync(uv_project_dir=REPO_TOP_DIR)
+    .run_commands("git clone -b main https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens")
+    .env({
+        "THUNDERKITTENS_ROOT": "/root/ThunderKittens",
+        "PYTHONPATH": "/root/src:/root"
+    })
+    .add_local_dir(SRC_DIR, remote_path="/root/src")
+    .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench")  # must be last
 )
 
 
@@ -92,6 +97,9 @@ def __init__(self):
         # subset of problems to evaluate
         self.subset = (None, None)  # (start_id, end_id), these are the logical index
 
+        # specific problem IDs to evaluate (overrides subset if provided)
+        self.problem_ids = None  # e.g., [71, 86, 95] for specific problems
+
         # Evaluation Mode: local (requires GPU), modal (cloud GPU)
         self.eval_mode = "local"
 
@@ -183,8 +191,8 @@ def evaluate_single_sample_modal(
         Evaluate a single sample on Modal GPU with automatic retries for GPU attachment failures
         and proper GPU corruption handling via stop_fetching_inputs()
         """
-        from src.eval import eval_kernel_against_ref, get_torch_dtype_from_string
-        from src.utils import set_gpu_arch
+        from kernelbench.eval import eval_kernel_against_ref, get_torch_dtype_from_string
+        from kernelbench.utils import set_gpu_arch
         import torch
         import time
         import modal.experimental
@@ -246,36 +254,17 @@ def evaluate_single_sample_modal(
 
 
 def fetch_ref_arch_from_problem_id(
-    dataset, problem_id: int, dataset_src: str
+    dataset, problem_id: int, dataset_src: str = None
 ) -> str | None:
     """
-    Fetch reference architecture from problem directory
-    Either from Hugging Face or Local Dataset
+    Fetch reference architecture from problem directory.
+    Uses the unified dataset interface.
+    
+    Note: dataset_src parameter is kept for backward compatibility but ignored
+    since the dataset object already handles both sources.
     """
-    if dataset_src == "huggingface":
-        curr_problem_row = dataset.filter(
-            lambda x: x["problem_id"] == problem_id, num_proc=None, desc=None
-        )
-        ref_arch_src = curr_problem_row["code"][0]
-        problem_name = curr_problem_row["name"][0]
-
-    elif dataset_src == "local":
-        problem_idx_in_dataset = (
-            problem_id - 1
-        )  # due to dataset list being 0-indexed locally
-        ref_arch_path = dataset[problem_idx_in_dataset]
-
-        problem_name = os.path.basename(ref_arch_path)
-        ref_arch_src = read_file(ref_arch_path)
-
-    # verify
-    # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py")
-    problem_number = int(problem_name.split("_")[0])
-    assert (
-        problem_number == problem_id
-    ), f"Problem number in filename ({problem_number}) does not match config problem_id ({problem_id})"
-
-    return ref_arch_src
+    problem = dataset.get_problem_by_id(problem_id)
+    return problem.code
 
 
 def fetch_kernel_from_disk(
@@ -338,6 +327,10 @@ def evaluate_single_sample(
         )
         return eval_result
     except Exception as e:
+        # INNER CATCH: Handles errors during kernel execution
+        # - CUDA errors (illegal memory access, kernel launch failures)
+        # - Runtime errors from the custom kernel
+        # - Any exception from eval_kernel_against_ref()
         print(
             f"[WARNING] Last level catch on {sample_id}: Some issue evaluating for kernel: {e} "
         )
@@ -518,22 +511,43 @@ def batch_eval_modal(
                 results = []
                 for i, future in enumerate(futures):
                     problem_id, sample_id = curr_work_batch[i]
-                    
+
                     if future is None:
-                        results.append((problem_id, sample_id, None))
+                        # Create a failure result for None futures
+                        fail_result = KernelExecResult(
+                            compiled=False,
+                            correctness=False,
+                            metadata={"error": "Future was None - evaluation did not complete"},
+                            runtime=-1.0,
+                            runtime_stats={},
+                        )
+                        results.append((problem_id, sample_id, fail_result))
                     else:
                         try:
                             result = future.get()
                             results.append((problem_id, sample_id, result))
                         except Exception as e:
+                            # OUTER CATCH: Modal infrastructure or remote execution failures
+                            # - GPU attachment failures after retries
+                            # - Network/container issues
+                            # - Import errors in the kernel (can't even start evaluation)
+                            # - Any exception from future.get()
                             error_msg = str(e)
                             # Check if it's a GPU attachment failure that exhausted retries
                             if "GPU not attached" in error_msg or "CUDA is not available" in error_msg:
                                 print(f"[ERROR] Modal GPU attachment FAILED after retries for Problem ID: {problem_id}, Sample ID: {sample_id}")
-                                print(f"        This is a Modal infrastructure issue. Sample will be skipped.")
+                                print(f"        This is a Modal infrastructure issue. Sample will be recorded as failed.")
                             else:
                                 print(f"[ERROR] Modal evaluation FAILED for Problem ID: {problem_id}, Sample ID: {sample_id}: {error_msg}")
-                            results.append((problem_id, sample_id, None))
+                            # Create a failure result instead of None
+                            fail_result = KernelExecResult(
+                                compiled=False,
+                                correctness=False,
+                                metadata={"error": error_msg},
+                                runtime=-1.0,
+                                runtime_stats={},
+                            )
+                            results.append((problem_id, sample_id, fail_result))
                 
                 end_time = time.time()
                 
@@ -542,12 +556,10 @@ def batch_eval_modal(
                     print("-" * 128)
                     print(f"[Eval Result] Problem ID: {problem_id}, Sample ID: {sample_id}")
                     print(result)
-                    
-                    if result is not None:
-                        print(f"Adding Eval Result to file for problem {problem_id} sample {sample_id}")
-                        add_to_eval_results_file(
-                            problem_id, sample_id, result, eval_file_path
-                        )
+                    print(f"Adding Eval Result to file for problem {problem_id} sample {sample_id}")
+                    add_to_eval_results_file(
+                        problem_id, sample_id, result, eval_file_path
+                    )
                 
                 print("-" * 128)
                 print(f"[Modal Batch] Evaluation took {end_time - start_time:.2f} seconds")
@@ -625,10 +637,19 @@ def batch_eval(
                         results.append((problem_id, sample_id, result))
 
                     except mp.TimeoutError:
+                        # OUTER CATCH: Evaluation exceeded timeout (config.timeout seconds)
+                        # - Kernel hangs, infinite loops, very slow compilation
                         print(
                             f"[WARNING] Evaluation TIMED OUT for Problem ID: {problem_id}, Sample ID: {sample_id}"
                         )
-                        results.append((problem_id, sample_id, None))
+                        fail_result = KernelExecResult(
+                            compiled=False,
+                            correctness=False,
+                            metadata={"error": "Evaluation timed out"},
+                            runtime=-1.0,
+                            runtime_stats={},
+                        )
+                        results.append((problem_id, sample_id, fail_result))
 
                         remove_cache_dir(
                             config.kernel_eval_build_dir,
@@ -637,10 +658,21 @@ def batch_eval(
                             sample_id,
                         )
                     except Exception as e:
+                        # OUTER CATCH: Multiprocessing-level failures
+                        # - Process crashes, pickling errors
+                        # - Errors that escape the inner handler
+                        error_msg = str(e)
                         print(
-                            f"[ERROR] Evaluation FAILED for Problem ID: {problem_id}, Sample ID: {sample_id}: {str(e)}"
+                            f"[ERROR] Evaluation FAILED for Problem ID: {problem_id}, Sample ID: {sample_id}: {error_msg}"
                         )
-                        results.append((problem_id, sample_id, None))
+                        fail_result = KernelExecResult(
+                            compiled=False,
+                            correctness=False,
+                            metadata={"error": error_msg},
+                            runtime=-1.0,
+                            runtime_stats={},
+                        )
+                        results.append((problem_id, sample_id, fail_result))
                         remove_cache_dir(
                             config.kernel_eval_build_dir,
                             config.run_name,
@@ -659,14 +691,12 @@ def batch_eval(
                     print(result)
 
                     # add all the batch results here to avoid file race condition
-                    # add to eval result if valid result
-                    if result is not None:
-                        print(
-                            f"Adding Eval Result to file for problem {problem_id} sample {sample_id}"
-                        )
-                        add_to_eval_results_file(
-                            problem_id, sample_id, result, eval_file_path
-                        )
+                    print(
+                        f"Adding Eval Result to file for problem {problem_id} sample {sample_id}"
+                    )
+                    add_to_eval_results_file(
+                        problem_id, sample_id, result, eval_file_path
+                    )
 
                 print("-" * 128)
                 print(
@@ -716,12 +746,13 @@ def add_to_eval_results_file(
         }
     )
 
-    # Write updated results back to file
+    # Write updated results back to file (sorted by numeric key)
     if not os.path.exists(eval_file_path):
         os.makedirs(os.path.dirname(eval_file_path), exist_ok=True)
 
+    sorted_results = dict(sorted(eval_results.items(), key=lambda x: int(x[0])))
     with open(eval_file_path, "w") as f:
-        json.dump(eval_results, f, indent=4)
+        json.dump(sorted_results, f, indent=4)
 
 
 def single_eval_example(
@@ -746,6 +777,15 @@ def main(config: EvalConfig):
     """
     print(f"Starting Batch Eval with config: {config}")
 
+    # Handle backend-specific settings
+    backend = config.backend.lower()
+    
+    # thunderkittens requires bf16 and H100 GPU
+    if backend == "thunderkittens":
+        config.precision = "bf16"
+        config.gpu = "H100"
+        print(f"[ThunderKittens] Auto-configured: precision=bf16, gpu=H100")
+
     # Check if CUDA is available (only for local mode)
     if config.eval_mode == "local":
         if not torch.cuda.is_available():
@@ -762,51 +802,48 @@ def main(config: EvalConfig):
     if mp.get_start_method(allow_none=True) is None:
         mp.set_start_method("spawn")
 
-    # Dataset Configurations
-    if config.dataset_src == "huggingface":
-        dataset = load_dataset(config.dataset_name)
-        curr_level_dataset = dataset[f"level_{config.level}"]
-    elif config.dataset_src == "local":
-        curr_level_dataset = construct_kernelbench_dataset(config.level)
+    # Dataset Configurations - Unified loading
+    dataset = construct_kernelbench_dataset(
+        level=config.level,
+        source=config.dataset_src,
+        dataset_name=config.dataset_name,
+    )
 
-    num_problems_in_level = len(curr_level_dataset)
+    all_problem_ids = dataset.get_problem_ids()
 
     if config.subset == (None, None):
-        problem_id_range = range(1, num_problems_in_level)
+        problem_ids_to_run = all_problem_ids
     else:
-        assert (
-            config.subset[0] >= 1 and config.subset[1] <= num_problems_in_level
-        ), f"Subset range {config.subset} out of range for Level {config.level}"
-        problem_id_range = range(config.subset[0], config.subset[1])
+        start, end = config.subset
+        problem_ids_to_run = [pid for pid in all_problem_ids if start <= pid <= end]
+        if not problem_ids_to_run:
+            print(f"Warning: No problems found in subset range {config.subset}")
 
     print(
-        f"Evaluating {config.num_samples_per_problem} sample(s) each for level {config.level} problems: {problem_id_range}"
+        f"Evaluating {config.num_samples_per_problem} sample(s) each for level {config.level} problems: {problem_ids_to_run}"
     )
 
     run_dir = os.path.join(config.runs_dir, config.run_name)
     eval_file_path = os.path.join(run_dir, f"eval_results.json")
 
     # To Debug
-    # single_eval_example(config, curr_level_dataset, run_dir, eval_file_path)
+    # single_eval_example(config, dataset, run_dir, eval_file_path)
 
     total_work = []
-    for problem_id in range(
-        problem_id_range.start, problem_id_range.stop + 1
-    ):  # end index is inclusive
+    for problem_id in problem_ids_to_run:
         for sample_id in range(config.num_samples_per_problem):
             if not check_if_eval_exists_local(problem_id, sample_id, eval_file_path):
                 total_work.append((problem_id, sample_id))
 
     print(
         f"Start evaluation on {len(total_work)} unevaluated samples"
-        f" in range: {problem_id_range}"
+        f" in range: {problem_ids_to_run}"
     )
     # Build Cache on CPU as that is faster (only for local mode)
     if config.build_cache and config.eval_mode == "local":
         compile.batch_compile(total_work, config.to_dict())
 
-    # Batch Eval on multiple GPUs in parallel
-    batch_eval(total_work, config, curr_level_dataset, run_dir, eval_file_path)
+    batch_eval(total_work, config, dataset, run_dir, eval_file_path)
 
     # Calculate pass@k metrics if multiple samples per problem were evaluated
     if config.num_samples_per_problem > 1:
diff --git a/scripts/generate_and_eval_single_sample.py b/scripts/generate_and_eval_single_sample.py
index 2e110932..78ed1ef7 100644
--- a/scripts/generate_and_eval_single_sample.py
+++ b/scripts/generate_and_eval_single_sample.py
@@ -5,25 +5,21 @@
 import json
 import modal
 
-from datasets import load_dataset
-
-from src.dataset import construct_kernelbench_dataset
-from src.eval import eval_kernel_against_ref
-from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
-from src.utils import (
+from kernelbench.eval import eval_kernel_against_ref
+from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
+from kernelbench.utils import (
     create_inference_server_from_presets,
     extract_first_code,
     query_server,
-    read_file,
     set_gpu_arch,
 )
-from src.eval import get_torch_dtype_from_string
+from kernelbench.eval import get_torch_dtype_from_string
 """
 Generate and evaluate a single sample
 Easiest way to get started, to test a single problem for experimentation or debugging
 
 Example usage:
-python3 scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=1 problem_id=1 eval_mode=local server_type=google model_name=gemini/gemini-2.5-flash max_tokens=8192 temperature=0.0
+uv run python scripts/generate_and_eval_single_sample.py dataset_src=huggingface level=1 problem_id=1 eval_mode=local server_type=google model_name=gemini/gemini-2.5-flash max_tokens=8192 temperature=0.0
 """
 
 REPO_TOP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -46,15 +42,17 @@ def __init__(self):
 
         # Evaluation
         # local (requires a GPU), modal (cloud GPU) coming soon
-        self.eval_mode = "local"
+        self.eval_mode = "local" 
+        # only support local for now
+        # see scripts/eval_from_generations_modal.py for modal evaluation
         # Construct this from mapping from architecture name to torch cuda arch list in the future
         # you can either specify SM version or just use the name
         self.gpu_arch = ["Ada"]
         self.precision = "fp32" # options ["fp32", "fp16", "bf16"]
 
         # Inference config
-        self.server_type = None
-        self.model_name = None
+        self.server_type = REQUIRED
+        self.model_name = REQUIRED
         self.max_tokens = None
         self.temperature = None
         
@@ -81,6 +79,8 @@ def __init__(self):
         self.hardware_gpu_name = None
         self.custom_prompt_key = None
 
+        self.check_kernel = True  # [experimental] optional static checker catching potential hacking patterns
+
     def verbose_logging(self):
         self.log = True
         self.log_prompt = True
@@ -97,7 +97,7 @@ def main(config: EvalConfig):
     Keep it simple: Generate and evaluate a single sample
     Note: will shorten code logic to make this as simple as possible
     """
-    from src.utils import SERVER_PRESETS
+    from kernelbench.utils import SERVER_PRESETS
     
     if config.server_type and config.server_type in SERVER_PRESETS:
         preset = SERVER_PRESETS[config.server_type]
@@ -114,56 +114,34 @@ def main(config: EvalConfig):
     
     print(f"Starting Eval with config: {config}")
 
-    # Configurations
-
-    if config.dataset_src == "huggingface":
-        dataset = load_dataset(config.dataset_name)
-        curr_level_dataset = dataset[f"level_{config.level}"]
-    elif config.dataset_src == "local":
-        curr_level_dataset = construct_kernelbench_dataset(config.level)
+    # Configurations - Unified dataset loading (works for both HF and local)
+    from kernelbench.dataset import construct_kernelbench_dataset
+    
+    dataset = construct_kernelbench_dataset(
+        level=config.level,
+        source=config.dataset_src,
+        dataset_name=config.dataset_name,
+    )
 
     if config.gpu_arch:
+        if (type(config.gpu_arch) is not list): # normalization to list
+            config.gpu_arch = [config.gpu_arch]
         set_gpu_arch(config.gpu_arch)  # otherwise build for all architectures
 
     if config.log:
         os.makedirs(config.logdir, exist_ok=True)
 
     # Problem Checks
-    num_problems = len(curr_level_dataset)
+    num_problems = len(dataset)
     print(f"Number of problems in Level {config.level}: {num_problems}")
     print(
         f"Start Generation + Evaluation for Level {config.level} Problem {config.problem_id}"
     )
 
-    assert (
-        config.problem_id <= num_problems
-    ), f"Problem ID {config.problem_id} out of range for Level {config.level}"
-
-    # TODO: refactor dataset fetching logic to be as clean as posisble.
-    # 1. Fetch Problem
-    if config.dataset_src == "huggingface":
-
-        curr_problem_row = curr_level_dataset.filter(
-            lambda x: x["problem_id"] == config.problem_id
-        )
-        ref_arch_src = curr_problem_row["code"][0]
-        problem_name = curr_problem_row["name"][0]
-
-    elif config.dataset_src == "local":
-        problem_idx_in_dataset = (
-            config.problem_id - 1
-        )  # due to dataset list being 0-indexed locally
-        ref_arch_path = curr_level_dataset[problem_idx_in_dataset]
-
-        problem_name = os.path.basename(ref_arch_path)
-        ref_arch_src = read_file(ref_arch_path)
-    # import pdb; pdb.set_trace()
-
-    # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py")
-    problem_number = int(problem_name.split("_")[0])
-    assert (
-        problem_number == config.problem_id
-    ), f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})"
+    # Fetch problem - unified interface, no branching needed
+    problem = dataset.get_problem_by_id(config.problem_id)
+    ref_arch_src = problem.code
+    problem_name = problem.name
 
     # 2. Generate Sample
     # Create inference function with config parameters
@@ -198,7 +176,7 @@ def main(config: EvalConfig):
         include_hardware = include_hardware.lower() in ["true", "1", "yes"]
     config.include_hardware_info = include_hardware
 
-    supported_backends = {"cuda", "triton", "tilelang", "cute"}
+    supported_backends = {"cuda", "hip", "triton", "tilelang", "cute", "thunderkittens"}
     backend = config.backend.lower()
     if backend not in supported_backends:
         raise ValueError(
@@ -208,6 +186,9 @@ def main(config: EvalConfig):
     if backend == "tilelang":
         config.precision = "fp16" # tilelang only operates with fp16
         config.hardware_gpu_name = config.hardware_gpu_name or getattr(config, "gpu", None)
+    
+    if backend == "thunderkittens":
+        config.precision = "bf16"
 
     if not custom_prompt_key:
         if prompt_option not in valid_prompt_options:
@@ -255,6 +236,19 @@ def main(config: EvalConfig):
         custom_kernel is not None
     ), f"Custom {config.backend} kernel code generation failed"
 
+    # Optional: static code checker for kernel code using regex matching
+    # NOTE: by no means is this checker complete, but it could help catch some potential hacks
+    if config.check_kernel:
+        from kernelbench.kernel_static_checker import validate_kernel_static
+        static_check_status, errors, warnings = validate_kernel_static(
+            custom_kernel,
+            backend=config.backend,
+            precision=config.precision,
+        )
+        assert static_check_status, f"Static check failed for level {config.level} problem {config.problem_id}. Errors: {errors}. Warnings: {warnings}"
+        if warnings:
+            print(f"Static check warnings for level {config.level} problem {config.problem_id}: {warnings}")
+
     # this should be optional
     if config.log:
         with open(os.path.join(config.logdir, f"generated_kernel_level_{config.level}_problem_{config.problem_id}.py"), "w") as f:
diff --git a/scripts/generate_and_eval_single_sample_modal.py b/scripts/generate_and_eval_single_sample_modal.py
index f41ba95f..783076d9 100644
--- a/scripts/generate_and_eval_single_sample_modal.py
+++ b/scripts/generate_and_eval_single_sample_modal.py
@@ -1,7 +1,7 @@
 '''
 Example Usage:
-python scripts/generate_and_eval_single_sample_modal.py dataset_src=huggingfac level=1 problem_id=1 eval_mode=modal gpu=L40S 
-    server_type=deepseek model_name=deepseek-coder max_tokens=4096 temperature=0.0
+uv run python scripts/generate_and_eval_single_sample_modal.py dataset_src=huggingface level=1 problem_id=1 eval_mode=modal gpu=L40S 
+    server_type=gemini model_name=gemini-2.5-flash max_tokens=4096 temperature=0.0
 '''
 
 import pydra
@@ -11,11 +11,8 @@
 import json
 import modal
 
-from datasets import load_dataset
-
-#from src.dataset import construct_kernelbench_dataset
-from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
-from src.utils import extract_first_code, query_server, set_gpu_arch, read_file, create_inference_server_from_presets
+from kernelbench.dataset import construct_kernelbench_dataset
+from kernelbench.utils import extract_first_code, query_server, set_gpu_arch, create_inference_server_from_presets
 
 app = modal.App("eval_single_sample")
 
@@ -81,6 +78,8 @@ def __init__(self):
         self.hardware_gpu_name = None
         self.custom_prompt_key = None
 
+        self.check_kernel = True  # [experimental] optional static checker catching potential hacking patterns
+
     def verbose_logging(self):
         self.log = True
         self.log_prompt = True
@@ -90,11 +89,13 @@ def verbose_logging(self):
     def __repr__(self):
         return f"EvalConfig({self.to_dict()})"
 
-cuda_version = "12.8.0"  # should be no greater than host CUDA version
+cuda_version = "13.0.0"  # should be no greater than host CUDA version
 flavor = "devel"  #  includes full CUDA toolkit
 operating_sys = "ubuntu22.04"
 tag = f"{cuda_version}-{flavor}-{operating_sys}"
 
+SRC_DIR = os.path.join(REPO_TOP_DIR, "src")
+
 image = (
     modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10")
     .apt_install("git",
@@ -102,8 +103,14 @@ def __repr__(self):
                 "g++-10",
                 "clang" # note i skip a step
                 )
-    .pip_install_from_requirements(os.path.join(REPO_TOP_DIR, "requirements.txt"))
-    .add_local_python_source("src")
+
+    .uv_sync(uv_project_dir=REPO_TOP_DIR, extras=["gpu"])
+    .run_commands("git clone -b main https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens")
+    .env({
+        "THUNDERKITTENS_ROOT": "/root/ThunderKittens",
+        "PYTHONPATH": "/root:/root/src"
+    })
+    .add_local_dir(SRC_DIR, remote_path="/root/src")  # must be last
 )
 
 @app.cls(image=image)
@@ -114,10 +121,10 @@ def eval_single_sample_modal(self, ref_arch_src, custom_kernel, verbose, gpu_arc
         # 3. Evaluate Kernel
         # NOTE: no need to wrap around process here as only a single sample
         # see batch eval for examples of process isolation
-        from src.eval import eval_kernel_against_ref
-        from src.eval import get_torch_dtype_from_string
+        from kernelbench.eval import eval_kernel_against_ref
+        from kernelbench.eval import get_torch_dtype_from_string
         # Use utility function to set the GPU architecture in the modal environment
-        from src.utils import set_gpu_arch as modal_set_gpu_arch
+        from kernelbench.utils import set_gpu_arch as modal_set_gpu_arch
         modal_set_gpu_arch(gpu_arch)
         return eval_kernel_against_ref(
             ref_arch_src, custom_kernel, verbose=verbose, measure_performance=True, 
@@ -131,7 +138,7 @@ def main(config: EvalConfig):
     """
     Keep it simple: Generate and evaluate a single sample
     """
-    from src.utils import SERVER_PRESETS
+    from kernelbench.utils import SERVER_PRESETS
     
     if config.server_type and config.server_type in SERVER_PRESETS:
         preset = SERVER_PRESETS[config.server_type]
@@ -148,41 +155,25 @@ def main(config: EvalConfig):
     
     print(f"Starting Eval with config: {config}")
 
-    # Configurations
-    
-    if config.dataset_src == "huggingface":
-        dataset = load_dataset(config.dataset_name)
-        curr_level_dataset = dataset[f"level_{config.level}"]
+    # Configurations - Unified dataset loading (works for both HF and local)
+    dataset = construct_kernelbench_dataset(
+        level=config.level,
+        source=config.dataset_src,
+        dataset_name=config.dataset_name,
+    )
 
     if config.log:
         os.makedirs(config.logdir, exist_ok=True)
         
     # Problem Checks
-    num_problems = len(curr_level_dataset)
+    num_problems = len(dataset)
     print(f"Number of problems in Level {config.level}: {num_problems}")
     print(f"Start Generation + Evaluation for Level {config.level} Problem {config.problem_id}")
 
-    assert config.problem_id <= num_problems, f"Problem ID {config.problem_id} out of range for Level {config.level}"
-
-
-    # 1. Fetch Problem
-    if config.dataset_src == "huggingface":
-
-        curr_problem_row = curr_level_dataset.filter(lambda x: x["problem_id"] == config.problem_id)
-        ref_arch_src = curr_problem_row["code"][0]
-        problem_name = curr_problem_row["name"][0]
-
-    elif config.dataset_src == "local":
-        problem_idx_in_dataset = config.problem_id - 1 # due to dataset list being 0-indexed locally
-        ref_arch_path = curr_level_dataset[problem_idx_in_dataset]
-
-        problem_name = os.path.basename(ref_arch_path)
-        ref_arch_src = read_file(ref_arch_path)
-    # import pdb; pdb.set_trace()
-
-    # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py")
-    problem_number = int(problem_name.split("_")[0])
-    assert problem_number == config.problem_id, f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})"
+    # Fetch problem - unified interface, no branching needed
+    problem = dataset.get_problem_by_id(config.problem_id)
+    ref_arch_src = problem.code
+    problem_name = problem.name
     
     
     # 2. Generate Sample
@@ -216,7 +207,7 @@ def main(config: EvalConfig):
         include_hardware = include_hardware.lower() in ["true", "1", "yes"]
     config.include_hardware_info = include_hardware
 
-    supported_backends = {"cuda", "triton", "tilelang", "cute"}
+    supported_backends = {"cuda", "triton", "tilelang", "cute", "thunderkittens"}
     backend = config.backend.lower()
     if backend not in supported_backends:
         raise ValueError(
@@ -227,6 +218,11 @@ def main(config: EvalConfig):
     if backend == "tilelang":
         config.precision = "fp16"
         config.hardware_gpu_name = config.hardware_gpu_name or getattr(config, "gpu", None)
+    
+    # thunderkittens can use bf16 or fp16 by default, also set default GPU to H100
+    if backend == "thunderkittens":
+        config.precision = "bf16"
+        config.gpu = "H100"
 
     if not custom_prompt_key:
         if prompt_option not in valid_prompt_options:
@@ -238,6 +234,9 @@ def main(config: EvalConfig):
                 "include_hardware_info is True but hardware_gpu_name is not provided."
             )
 
+    # Lazy import prompt constructor
+    from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
+
     if custom_prompt_key:
         custom_prompt = get_custom_prompt(
             custom_prompt_key,
@@ -268,6 +267,19 @@ def main(config: EvalConfig):
     # check LLM is able to generate custom kernel code
     assert custom_kernel is not None, f"Custom {config.backend} kernel code generation failed"
     
+    # Optional: static code checker for kernel code using regex matching
+    # NOTE: by no means is this checker complete, but it could help catch some potential hacks
+    if config.check_kernel:
+        from kernelbench.kernel_static_checker import validate_kernel_static
+        static_check_status, errors, warnings = validate_kernel_static(
+            custom_kernel,
+            backend=config.backend,
+            precision=config.precision,
+        )
+        assert static_check_status, f"Static check failed for level {config.level} problem {config.problem_id}. Errors: {errors}. Warnings: {warnings}"
+        if warnings:
+            print(f"Static check warnings for level {config.level} problem {config.problem_id}: {warnings}")
+    
     # this should be optional
     if config.log:
         with open(os.path.join(config.logdir, f"generated_kernel_level_{config.level}_problem_{config.problem_id}.py"), "w") as f:
diff --git a/scripts/generate_baseline_time.py b/scripts/generate_baseline_time.py
index 0a1f608b..e53fd915 100644
--- a/scripts/generate_baseline_time.py
+++ b/scripts/generate_baseline_time.py
@@ -1,16 +1,8 @@
 import torch
 import numpy as np
-from src.eval import (
-    load_original_model_and_inputs,
-    set_seed,
-    fetch_ref_arch_from_problem_id,
-)
-from src.timing import (
-    get_timing_function,
-    get_timing_stats,
-)
-from src.dataset import construct_problem_dataset_from_problem_dir
-from src.utils import read_file
+from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset
+from kernelbench.timing import measure_ref_program_time
+from kernelbench.utils import read_file
 import os
 import json
 from tqdm import tqdm
@@ -48,98 +40,12 @@
 TIMING_DIR = os.path.join(REPO_TOP_PATH, "results", "timing")
 
 
-def fetch_ref_arch_from_dataset(dataset: list[str], 
-                                problem_id: int) -> tuple[str, str, str]:
-    """
-    Fetch the reference architecture from the problem directory
-    problem_id should be logical index (1-indexed), matching the problem_id in the problem_name
-
-    Returns:
-        ref_arch_path: str, the path to the reference architecture
-        ref_arch_name: str, the name of the reference architecture
-        ref_arch_src: str, the source code of the reference architecture
-    """
-    ref_arch_path = None
-    
-    for file in dataset:
-        if file.split("/")[-1].split("_")[0] == str(problem_id):
-            ref_arch_path = file
-            break
-    if ref_arch_path is None:
-        raise ValueError(f"No reference architecture found for problem_id {problem_id}")
-    
-    ref_arch_src = read_file(ref_arch_path)
-
-    ref_arch_name = ref_arch_path.split("/")[-1]
-    return (ref_arch_path, ref_arch_name, ref_arch_src)
-
-
-def measure_program_time(
-        ref_arch_name: str,
-        ref_arch_src: str, 
-        num_trials: int = 100,
-        use_torch_compile: bool = False,
-        torch_compile_backend: str="inductor", 
-        torch_compile_options: str="default",
-        device: torch.device="cuda:0",
-        verbose: bool = False,
-        timing_method: str = "cuda_event",
-) -> dict:
-    """
-    Measure the time of a KernelBench reference architecture
-    """
-    context = {}
-    Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
-        ref_arch_src, context
-    )
-    try:
-        with torch.no_grad():
-            torch.cuda.synchronize(device=device)
-            set_seed(42)
-            inputs = get_inputs()
-            set_seed(42)
-            init_inputs = get_init_inputs()
-            inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in inputs
-            ]
-            init_inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in init_inputs
-            ]
-
-            # Initialize PyTorch model, use this for eager mode execution
-            model = Model(*init_inputs)
-            
-            if use_torch_compile:
-                print(f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode")
-                model = torch.compile(model, backend=torch_compile_backend, mode=torch_compile_options)
-            else:
-                print(f"Using PyTorch Eager Execution on {ref_arch_name}")
-            
-            model = model.cuda(device=device)
-            torch.cuda.synchronize(device=device)
-
-            # run chosen timing function
-            timing_fn = get_timing_function(timing_method)
-            elapsed_times = timing_fn(
-                model, inputs, num_trials=num_trials, verbose=verbose, device=device
-            )
-            runtime_stats = get_timing_stats(elapsed_times, device=device)
-
-            if verbose:
-                print(f"{ref_arch_name} {runtime_stats}")
-            
-            return runtime_stats
-    except Exception as e:
-        print(f"[Eval] Error in Measuring Performance: {e}")
-
-
 
 def record_baseline_times(use_torch_compile: bool = False, 
                           torch_compile_backend: str="inductor", 
                           torch_compile_options: str="default",
-                          file_name: str="baseline_time.json"):
+                          file_name: str="baseline_time.json",
+                          precision: str="fp32"):
     """
     Generate baseline time for KernelBench, 
     configure profiler options for PyTorch
@@ -149,21 +55,21 @@ def record_baseline_times(use_torch_compile: bool = False,
     json_results = {}
     
     for level in [1, 2, 3]:
-        PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level))
-        dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR)
+        dataset = construct_kernelbench_dataset(level)
         json_results[f"level{level}"] = {}
 
         num_problems = len(dataset)
-        for problem_id in tqdm(range(1, num_problems + 1)):
+        for problem_id in tqdm(dataset.get_problem_ids()):
             ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(dataset, problem_id)
-            runtime_stats = measure_program_time(
+            runtime_stats = measure_ref_program_time(
                 ref_arch_name=ref_arch_name,
                 ref_arch_src=ref_arch_src,
                 use_torch_compile=use_torch_compile,
                 torch_compile_backend=torch_compile_backend,
                 torch_compile_options=torch_compile_options,
                 device=device,
-                verbose=False # do not print 
+                verbose=False, # do not print 
+                precision=precision,
             )
             json_results[f"level{level}"][ref_arch_name] = runtime_stats
 
@@ -180,19 +86,19 @@ def test_measure_particular_program(level_num: int, problem_id: int):
     """
     device = torch.device("cuda:0")
 
-    PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level_num))
-    dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR)
+    dataset = construct_kernelbench_dataset(level_num)
 
     ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(dataset, problem_id)
 
-    exec_stats = measure_program_time(
+    exec_stats = measure_ref_program_time(
         ref_arch_name=ref_arch_name,
         ref_arch_src=ref_arch_src,
         use_torch_compile=True,
         torch_compile_backend="inductor",
         torch_compile_options="default",
         device=device,
-        verbose=False
+        verbose=False, 
+        precision="bf16"
     )
 
     print(f"Execution time for {ref_arch_name}: {exec_stats}")
@@ -216,20 +122,23 @@ def test_measure_particular_program(level_num: int, problem_id: int):
     record_baseline_times(use_torch_compile=False, 
                           torch_compile_backend=None,
                           torch_compile_options=None, 
-                          file_name=f"{hardware_name}/baseline_time_torch.json")
+                          file_name=f"{hardware_name}/baseline_time_torch.json",
+                          precision="bf16")
     
     # 2. Record Torch Compile using Inductor
     for torch_compile_mode in ["default", "reduce-overhead", "max-autotune", "max-autotune-no-cudagraphs"]:
         record_baseline_times(use_torch_compile=True, 
                               torch_compile_backend="inductor",
                               torch_compile_options=torch_compile_mode, 
-                              file_name=f"{hardware_name}/baseline_time_torch_compile_inductor_{torch_compile_mode}.json")
+                              file_name=f"{hardware_name}/baseline_time_torch_compile_inductor_{torch_compile_mode}.json",
+                              precision="bf16")
  
     # 3. Record Torch Compile using cudagraphs
     record_baseline_times(use_torch_compile=True, 
                           torch_compile_backend="cudagraphs",
                           torch_compile_options=None, 
-                          file_name=f"{hardware_name}/baseline_time_torch_compile_cudagraphs.json")
+                          file_name=f"{hardware_name}/baseline_time_torch_compile_cudagraphs.json",
+                          precision="bf16")
     
 
 
@@ -244,52 +153,3 @@ def test_measure_particular_program(level_num: int, problem_id: int):
 
 
 
-
-################################################################################
-# Deprecated
-################################################################################
-
-
-def get_time_old(level_num, problem_id, num_trials=100, torch_compile=False):
-    raise DeprecationWarning("Use New measure_program_time instead")
-    ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id(
-        level_num, problem_id, with_name=True
-    )
-    ref_arch_name = ref_arch_name.split("/")[-1]
-    context = {}
-    Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
-        ref_arch_src, context
-    )
-    try:
-        with torch.no_grad():
-            torch.cuda.synchronize(device=device)
-            set_seed(42)
-            inputs = get_inputs()
-            set_seed(42)
-            init_inputs = get_init_inputs()
-            inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in inputs
-            ]
-            init_inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in init_inputs
-            ]
-            model = Model(*init_inputs)
-            
-            if torch_compile:
-                model = torch.compile(model)
-                print("Compiled model Done")
-            model = model.cuda(device=device)
-            torch.cuda.synchronize(device=device)
-            elapsed_times = time_execution_with_cuda_event(
-                model, *inputs, num_trials=num_trials, verbose=False, device=device
-            )
-            runtime_stats = get_timing_stats(elapsed_times, device=device)
-            # json_results[f"level{level_num}"][ref_arch_name] = runtime_stats
-            print(f"{ref_arch_name} {runtime_stats}")
-            return (ref_arch_name, runtime_stats)
-    except Exception as e:
-        print(f"[Eval] Error in Measuring Performance: {e}")
-
-
diff --git a/scripts/generate_baseline_time_modal.py b/scripts/generate_baseline_time_modal.py
index a0039193..8cc409fa 100644
--- a/scripts/generate_baseline_time_modal.py
+++ b/scripts/generate_baseline_time_modal.py
@@ -1,18 +1,19 @@
 import torch
 import numpy as np
-from src.eval import (
+from kernelbench.eval import (
     load_original_model_and_inputs,
-    time_execution_with_cuda_event,
-    get_timing_stats,
     set_seed,
     fetch_ref_arch_from_problem_id,
 )
-from src.dataset import construct_problem_dataset_from_problem_dir
-from src.utils import read_file
+from kernelbench.timing import (
+    get_timing_function,
+    get_timing_stats,
+)
+from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset
+from kernelbench.utils import read_file
 import os
 import json
 from tqdm import tqdm
-import multiprocessing as mp
 import time
 import einops
 import pydra
@@ -46,7 +47,7 @@
         "..",
     )
 )
-KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench")
+KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench")  # Dataset directory
 
 TIMING_DIR = os.path.join(REPO_TOP_PATH, "results", "timing")
 
@@ -62,8 +63,8 @@ def __init__(self):
         # Hardware name for saving results
         self.hardware_name = REQUIRED
 
-        # Batch size for parallel processing
-        self.batch_size = 10
+        # Number of parallel GPU containers to use
+        self.num_gpu_devices = 8
 
         # Timeout for each batch in seconds
         self.timeout = 1800
@@ -71,19 +72,22 @@ def __init__(self):
         # Number of trials for timing
         self.num_trials = 100
 
+        # Precision for timing
+        self.precision = "fp32"
+
 
 # Modal Infra
 import modal
 app = modal.App("generate_baseline_modal")
 gpu_arch_mapping = {"L40S": ["Ada"], "H100": ["Hopper"], "A100": ["Ampere"], "A100-80GB": ["Ampere"], "L4": ["Ada"], "T4": ["Turing"], "A10G": ["Ampere"]}
-batch_size = 10
-gpu = "L40S"
-timeout = 1800
-cuda_version = "12.8.0"  # should be no greater than host CUDA version
+cuda_version = "13.0.0"  # should be no greater than host CUDA version
 flavor = "devel"  #  includes full CUDA toolkit
 operating_sys = "ubuntu22.04"
 tag = f"{cuda_version}-{flavor}-{operating_sys}"
 
+SRC_DIR = os.path.join(REPO_TOP_PATH, "src")
+KERNELBENCH_DIR = os.path.join(REPO_TOP_PATH, "KernelBench")
+
 image = (
     modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10")
     .apt_install("git",
@@ -91,12 +95,10 @@ def __init__(self):
                 "g++-10",
                 "clang" # note i skip a step
                 )
-    .pip_install_from_requirements(os.path.join(REPO_TOP_PATH, "requirements.txt"))
-    .add_local_dir(
-        KERNEL_BENCH_PATH,
-        remote_path="/root/KernelBench"
-    )
-    .add_local_python_source("src")
+    .uv_sync(uv_project_dir=REPO_TOP_PATH, extras=["gpu"])
+    .env({"PYTHONPATH": "/root/src"})
+    .add_local_dir(SRC_DIR, remote_path="/root/src")
+    .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench")  # must be last
 )
 
 def write_batch_to_json(entries_to_write: list, f_path: str):
@@ -126,31 +128,6 @@ def write_batch_to_json(entries_to_write: list, f_path: str):
     
     print(f"[INFO] Wrote {len(entries_to_write)} entries to {f_path}")
 
-def fetch_ref_arch_from_dataset(dataset: list[str], 
-                                problem_id: int) -> tuple[str, str, str]:
-    """
-    Fetch the reference architecture from the problem directory
-    problem_id should be logical index (1-indexed), matching the problem_id in the problem_name
-
-    Returns:
-        ref_arch_path: str, the path to the reference architecture
-        ref_arch_name: str, the name of the reference architecture
-        ref_arch_src: str, the source code of the reference architecture
-    """
-    ref_arch_path = None
-    
-    for file in dataset:
-        if file.split("/")[-1].split("_")[0] == str(problem_id):
-            ref_arch_path = file
-            break
-    if ref_arch_path is None:
-        raise ValueError(f"No reference architecture found for problem_id {problem_id}")
-    
-    ref_arch_src = read_file(ref_arch_path)
-
-    ref_arch_name = ref_arch_path.split("/")[-1]
-    return (ref_arch_path, ref_arch_name, ref_arch_src)
-
 @app.cls(image=image, scaledown_window=5)
 class EvalFunc:
 
@@ -160,130 +137,82 @@ def measure_program_time(
             ref_arch_name: str,
             ref_arch_src: str, 
             num_trials: int = 100,
+            timing_method: str="cuda_event",
             use_torch_compile: bool = False,
             torch_compile_backend: str="inductor", 
             torch_compile_options: str="default",
             device: torch.device = torch.cuda.current_device() if torch.cuda.is_available() else None,
             verbose: bool = False,
+            precision: str = "fp32",
     ):
-        """
-        Measure the time of a KernelBench reference architecture
-        """
-        context = {}
-        Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
-            ref_arch_src, context
+        from kernelbench.timing import measure_ref_program_time
+        return measure_ref_program_time(
+            ref_arch_name=ref_arch_name,
+            ref_arch_src=ref_arch_src,
+            num_trials=num_trials,
+            num_warmup=3,
+            discard_first=1,
+            timing_method=timing_method,
+            use_torch_compile=use_torch_compile,
+            torch_compile_backend=torch_compile_backend,
+            torch_compile_options=torch_compile_options,
+            device=device,
+            verbose=verbose,
+            precision=precision,
         )
-        try:
-            with torch.no_grad():
-                torch.cuda.synchronize(device=device)
-                set_seed(42)
-                inputs = get_inputs()
-                set_seed(42)
-                init_inputs = get_init_inputs()
-                inputs = [
-                    x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                    for x in inputs
-                ]
-                init_inputs = [
-                    x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                    for x in init_inputs
-                ]
-
-                # Initialize PyTorch model, use this for eager mode execution
-                model = Model(*init_inputs)
-                
-                if use_torch_compile:
-                    print(f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode")
-                    model = torch.compile(model, backend=torch_compile_backend, mode=torch_compile_options)
-                else:
-                    print(f"Using PyTorch Eager Execution on {ref_arch_name}")
-                
-                model = model.cuda(device=device)
-                torch.cuda.synchronize(device=device)
-                elapsed_times = time_execution_with_cuda_event(
-                    model, *inputs, num_trials=num_trials, verbose=verbose, device=device
-                )
-                runtime_stats = get_timing_stats(elapsed_times, device=device)
-
-                if verbose:
-                    print(f"{ref_arch_name} {runtime_stats}")
-                
-                return runtime_stats
-        except Exception as e:
-            print(f"[Eval] Error in Measuring Performance: {e}")
-
-def measure_program_time_wrapper(gpu_type, *args, **kwargs):
-    with app.run():
-        return EvalFunc.with_options(gpu=gpu_type)().measure_program_time.remote(*args, **kwargs)
 
 def record_baseline_times(config: BaselineConfig,
                           use_torch_compile: bool = False,
                           torch_compile_backend: str="inductor",
                           torch_compile_options: str="default",
-                          file_name: str="baseline_time.json"):
+                          file_name: str="baseline_time.json",
+                          precision: str = "fp32"):
     """
-    Generate baseline time for KernelBench,
-    configure profiler options for PyTorch
-    save to specified file
+    Generate baseline time for KernelBench using Modal's native parallelization.
+    Spawns multiple GPU containers in parallel for faster processing.
     """
     json_results = []
 
     level = config.level
-    PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level))
-    dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR)
+    dataset = construct_kernelbench_dataset(level)
     num_problems = len(dataset)
-    total_work = [(i, *fetch_ref_arch_from_dataset(dataset, i)) for i in list(range(1, num_problems + 1))]
-
-    with tqdm(total=len(total_work), desc="Processing batches") as pbar:
-        while len(total_work) > 0:
-            curr_work_batch = total_work[:config.batch_size]
-            total_work = total_work[config.batch_size:]  # pop the first batch_size elements
-
-            with mp.Pool() as pool:
-
-                work_args = [
-                    (
-                        config.gpu,
-                        ref_arch_name,
-                        ref_arch_src,
-                        config.num_trials,
-                        use_torch_compile,
-                        torch_compile_backend,
-                        torch_compile_options,
-                        torch.device(f"cuda:0"),
-                        False # do not print
-                    )
-                    for i, (p_id, ref_arch_path, ref_arch_name, ref_arch_src) in enumerate(curr_work_batch)
-                ]
+    total_work = [(i, *fetch_ref_arch_from_dataset(dataset, i)) for i in dataset.get_problem_ids()]
 
-                start_time = time.time()
+    batch_size = config.num_gpu_devices
+    print(f"[Modal] Processing {len(total_work)} problems in parallel batches of {batch_size}")
 
-                async_results = []
-                for work_arg in work_args:
-                    async_results.append(
-                        pool.apply_async(measure_program_time_wrapper, work_arg)
+    with app.run():
+        evaluator_cls = EvalFunc.with_options(gpu=config.gpu) if config.gpu != "L40S" else EvalFunc
+
+        with tqdm(total=len(total_work), desc="Processing") as pbar:
+            while len(total_work) > 0:
+                curr_work_batch = total_work[:batch_size]
+                total_work = total_work[batch_size:]
+
+                # Spawn all tasks in parallel using Modal
+                futures = []
+                for p_id, ref_arch_path, ref_arch_name, ref_arch_src in curr_work_batch:
+                    future = evaluator_cls().measure_program_time.spawn(
+                        ref_arch_name=ref_arch_name,
+                        ref_arch_src=ref_arch_src,
+                        num_trials=config.num_trials,
+                        timing_method="cuda_event",
+                        use_torch_compile=use_torch_compile,
+                        torch_compile_backend=torch_compile_backend,
+                        torch_compile_options=torch_compile_options,
+                        device=torch.device("cuda:0"),
+                        verbose=False,
+                        precision=precision,
                     )
+                    futures.append((p_id, ref_arch_name, future))
 
-                batch_timeout = config.timeout
-                for i, async_result in enumerate(async_results):
-                    problem_id, _, ref_arch_name, _ = curr_work_batch[i]
-
+                # Collect results
+                for p_id, ref_arch_name, future in futures:
                     try:
-                        elapsed_time = time.time() - start_time
-                        remaining_time = max(0, batch_timeout - elapsed_time)
-                        result = async_result.get(timeout=remaining_time)
+                        result = future.get(timeout=config.timeout)
                         json_results.append((f"level{level}", ref_arch_name, result))
-
-                    except mp.TimeoutError:
-                        print(
-                            f"[WARNING] Evaluation TIMED OUT for Problem ID: {problem_id}"
-                        )
-                        json_results.append((f"level{level}", ref_arch_name, None))
-
                     except Exception as e:
-                        print(
-                            f"[ERROR] Evaluation FAILED for Problem ID: {problem_id}: {str(e)}"
-                        )
+                        print(f"[ERROR] Problem {p_id} ({ref_arch_name}): {str(e)}")
                         json_results.append((f"level{level}", ref_arch_name, None))
 
                 pbar.update(len(curr_work_batch))
@@ -300,7 +229,7 @@ def main(config: BaselineConfig):
     """
     print(f"Generating baseline time for level {config.level} on {config.gpu} Modal")
     print(f"Hardware name: {config.hardware_name}")
-    print(f"Batch size: {config.batch_size}, Timeout: {config.timeout}s, Num trials: {config.num_trials}")
+    print(f"Parallel GPUs: {config.num_gpu_devices}, Timeout: {config.timeout}s, Num trials: {config.num_trials}")
 
     # 1. Record Torch Eager
     print("\n[1/2] Recording baseline times with PyTorch Eager execution...")
@@ -316,6 +245,7 @@ def main(config: BaselineConfig):
     print("\n[2/2] Recording baseline times with Torch Compile (inductor, default mode)...")
     record_baseline_times(
         config=config,
+        precision=config.precision,
         use_torch_compile=True,
         torch_compile_backend="inductor",
         torch_compile_options="default",
@@ -340,54 +270,3 @@ def main(config: BaselineConfig):
     # get_time(2, 43, torch_compile=False)
     # get_time(2, 43, torch_compile=True)
 
-
-
-
-################################################################################
-# Deprecated
-################################################################################
-
-
-def get_time_old(level_num, problem_id, num_trials=100, torch_compile=False):
-    raise DeprecationWarning("Use New measure_program_time instead")
-    ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id(
-        level_num, problem_id, with_name=True
-    )
-    ref_arch_name = ref_arch_name.split("/")[-1]
-    context = {}
-    Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
-        ref_arch_src, context
-    )
-    try:
-        with torch.no_grad():
-            torch.cuda.synchronize(device=device)
-            set_seed(42)
-            inputs = get_inputs()
-            set_seed(42)
-            init_inputs = get_init_inputs()
-            inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in inputs
-            ]
-            init_inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in init_inputs
-            ]
-            model = Model(*init_inputs)
-            
-            if torch_compile:
-                model = torch.compile(model)
-                print("Compiled model Done")
-            model = model.cuda(device=device)
-            torch.cuda.synchronize(device=device)
-            elapsed_times = time_execution_with_cuda_event(
-                model, *inputs, num_trials=num_trials, verbose=False, device=device
-            )
-            runtime_stats = get_timing_stats(elapsed_times, device=device)
-            # json_results[f"level{level_num}"][ref_arch_name] = runtime_stats
-            print(f"{ref_arch_name} {runtime_stats}")
-            return (ref_arch_name, runtime_stats)
-    except Exception as e:
-        print(f"[Eval] Error in Measuring Performance: {e}")
-
-
diff --git a/scripts/generate_samples.py b/scripts/generate_samples.py
index e47c6e87..2c01ee8d 100644
--- a/scripts/generate_samples.py
+++ b/scripts/generate_samples.py
@@ -5,19 +5,18 @@
 import pydra
 import torch
 
-from datasets import load_dataset
 from pydra import Config, REQUIRED
 
-from src.dataset import construct_kernelbench_dataset
-from src.eval import eval_kernel_against_ref
-from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
-from src.utils import (
+from kernelbench.dataset import construct_kernelbench_dataset
+from kernelbench.eval import eval_kernel_against_ref
+from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
+from kernelbench.utils import (
     create_inference_server_from_presets,
     extract_first_code,
     maybe_multithread,
-    read_file,
     set_gpu_arch,
 )
+from kernelbench.kernel_static_checker import validate_kernel_static
 
 """
 Batch Generate Samples for Particular Level
@@ -45,7 +44,7 @@ def __init__(self):
         self.subset = (
             None,
             None,
-        )  # (problem_id, problem_name), these are the logical index
+        )  # (start_id, end_id), both inclusive - logical 1-indexed IDs
 
         self.run_name = REQUIRED  # name of the run
 
@@ -84,6 +83,8 @@ def __init__(self):
         self.hardware_gpu_name = None
         self.custom_prompt_key = None
 
+        self.check_kernel = True  # [experimental] optional static checker catching potential hacking patterns
+
     def greedy(self):
         # For greedy decoding, epsecially baseline eval
         self.greedy_sample = True
@@ -105,29 +106,10 @@ def generate_sample_single(
     inference_server: callable,
     run_dir: str,
 ) -> bool:
-    # 1. Fetch Problem
-    if config.dataset_src == "huggingface":
-        curr_problem_row = dataset.filter(
-            lambda x: x["problem_id"] == work.problem_id, desc=None
-        )
-
-        ref_arch_src = curr_problem_row["code"][0]
-        problem_name = curr_problem_row["name"][0]
-
-    elif config.dataset_src == "local":
-        problem_idx_in_dataset = (
-            work.problem_id - 1
-        )  # due to dataset list being 0-indexed locally
-        ref_arch_path = dataset[problem_idx_in_dataset]
-
-        problem_name = os.path.basename(ref_arch_path)
-        ref_arch_src = read_file(ref_arch_path)
-
-    # Extract problem number from problem name (e.g. "1" from "1_Square_matrix_multiplication_.py")
-    problem_number = int(problem_name.split("_")[0])
-    assert (
-        problem_number == work.problem_id
-    ), f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})"
+    # 1. Fetch Problem - unified interface
+    problem = dataset.get_problem_by_id(work.problem_id)
+    ref_arch_src = problem.code
+    problem_name = problem.name
 
     if config.custom_prompt_key:
         custom_prompt = get_custom_prompt(
@@ -162,6 +144,19 @@ def generate_sample_single(
     # check LLM is able to generate custom CUDA code
     assert custom_kernel is not None, "Custom CUDA code generation failed"
 
+    # Optional: we provide a static code checker for kernel code using regex matching
+    # NOTE: by no means, is this checker complete, but it might could help catch some potential hacks and issues
+    if config.check_kernel:
+        static_check_status, error, warnings = validate_kernel_static(custom_kernel,
+            backend=config.backend,
+            precision=config.precision, 
+            # uses the default set of forbidden and warning patterns, 
+            # you could adapt the patterns to your own setting (degree of banning cuda stream, allowing some torch ops)
+        )
+        assert static_check_status, f"Static check failed for sample {work.sample_id} for problem {problem_number}: {problem_name}. Error: {error}. Warnings: {warnings}"
+        if warnings:
+            print(f"Static check warnings for sample {work.sample_id} for problem {problem_number}: {problem_name}. Warnings: {warnings}")
+
     if config.verbose:
         print(
             f"Generated sample {work.sample_id} for problem {problem_number}: {problem_name}"
@@ -210,7 +205,7 @@ def main(config: GenerationConfig):
     Batch Generate Samples for Particular Level
     Store generated kernels in the specified run directory
     """
-    from src.utils import SERVER_PRESETS
+    from kernelbench.utils import SERVER_PRESETS
     
     if config.server_type and config.server_type in SERVER_PRESETS:
         preset = SERVER_PRESETS[config.server_type]
@@ -239,7 +234,7 @@ def main(config: GenerationConfig):
         include_hardware = include_hardware.lower() in ["true", "1", "yes"]
     config.include_hardware_info = include_hardware
 
-    supported_backends = {"cuda", "triton", "cute", "tilelang"}
+    supported_backends = {"cuda", "triton", "cute", "tilelang", "thunderkittens"}
     backend = config.backend.lower()
     if backend not in supported_backends:
         raise ValueError(
@@ -248,6 +243,8 @@ def main(config: GenerationConfig):
     config.backend = backend
     if backend == "tilelang":
         config.precision = "fp16"
+    if backend == "thunderkittens":
+        config.precision = "bf16"
 
     config.prompt_option = str(config.prompt_option).lower()
     valid_prompt_options = {"zero_shot", "one_shot", "few_shot"}
@@ -263,25 +260,25 @@ def main(config: GenerationConfig):
 
     print(f"Starting Batch Generation with config: {config}")
 
-    # Dataset Configurations
-    if config.dataset_src == "huggingface":
-        dataset = load_dataset(config.dataset_name)
-        curr_level_dataset = dataset[f"level_{config.level}"]
-    elif config.dataset_src == "local":
-        curr_level_dataset = construct_kernelbench_dataset(config.level)
+    # Dataset Configurations - Unified loading
+    dataset = construct_kernelbench_dataset(
+        level=config.level,
+        source=config.dataset_src,
+        dataset_name=config.dataset_name,
+    )
 
-    num_problems_in_level = len(curr_level_dataset)
+    all_problem_ids = dataset.get_problem_ids()
 
     if config.subset == (None, None):
-        problem_id_range = range(1, num_problems_in_level)
+        problem_ids_to_run = all_problem_ids
     else:
-        assert (
-            config.subset[0] >= 1 and config.subset[1] <= num_problems_in_level
-        ), f"Subset range {config.subset} out of range for Level {config.level}"
-        problem_id_range = range(config.subset[0], config.subset[1])
+        start, end = config.subset
+        problem_ids_to_run = [pid for pid in all_problem_ids if start <= pid <= end]
+        if not problem_ids_to_run:
+            print(f"Warning: No problems found in subset range {config.subset}")
 
     print(
-        f"Generating {config.num_samples} sample(s) each for level {config.level} problems: {problem_id_range}"
+        f"Generating {config.num_samples} sample(s) each for level {config.level} problems: {problem_ids_to_run}"
     )
 
     # set up run directory
@@ -300,9 +297,7 @@ def main(config: GenerationConfig):
     problems_to_run = []
     total_problems = 0
     already_completed = 0
-    for problem_id in range(
-        problem_id_range.start, problem_id_range.stop + 1
-    ):  # end index is inclusive
+    for problem_id in problem_ids_to_run:
         for sample_id in range(config.num_samples):
             total_problems += 1
             if not check_kernel_exists(run_dir, config.level, problem_id, sample_id):
@@ -336,7 +331,7 @@ def main(config: GenerationConfig):
         time_interval=config.api_query_interval,
         # extra args
         config=config,
-        dataset=curr_level_dataset,
+        dataset=dataset,
         inference_server=inference_server,
         run_dir=run_dir,
     )
diff --git a/scripts/get_baseline_time_single_problem.py b/scripts/get_baseline_time_single_problem.py
index 476fe2fd..9d0e8816 100644
--- a/scripts/get_baseline_time_single_problem.py
+++ b/scripts/get_baseline_time_single_problem.py
@@ -1,68 +1,6 @@
 import torch
 import numpy as np
-from src.eval import (
-    load_original_model_and_inputs,
-    time_execution_with_cuda_event,
-    get_timing_stats,
-    set_seed,
-    fetch_ref_arch_from_problem_id,
-)
-
-def measure_program_time(
-        ref_arch_name: str,
-        ref_arch_src: str, 
-        num_trials: int = 100,
-        use_torch_compile: bool = False,
-        torch_compile_backend: str="inductor", 
-        torch_compile_options: str="default",
-        device: torch.device="cuda:0",
-        verbose: bool = False,
-) -> dict:
-    """
-    Measure the time of a KernelBench reference architecture
-    """
-    context = {}
-    Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
-        ref_arch_src, context
-    )
-    try:
-        with torch.no_grad():
-            torch.cuda.synchronize(device=device)
-            set_seed(42)
-            inputs = get_inputs()
-            set_seed(42)
-            init_inputs = get_init_inputs()
-            inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in inputs
-            ]
-            init_inputs = [
-                x.cuda(device=device) if isinstance(x, torch.Tensor) else x
-                for x in init_inputs
-            ]
-
-            # Initialize PyTorch model, use this for eager mode execution
-            model = Model(*init_inputs)
-            
-            if use_torch_compile:
-                print(f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode")
-                model = torch.compile(model, backend=torch_compile_backend, mode=torch_compile_options)
-            else:
-                print(f"Using PyTorch Eager Execution on {ref_arch_name}")
-            
-            model = model.cuda(device=device)
-            torch.cuda.synchronize(device=device)
-            elapsed_times = time_execution_with_cuda_event(
-                model, *inputs, num_trials=num_trials, verbose=verbose, device=device
-            )
-            runtime_stats = get_timing_stats(elapsed_times, device=device)
-
-            if verbose:
-                print(f"{ref_arch_name} {runtime_stats}")
-            
-            return runtime_stats
-    except Exception as e:
-        print(f"[Eval] Error in Measuring Performance: {e}")
+from kernelbench.timing import measure_ref_program_time
 
 if __name__ == "__main__":
     ref_arch_name = "softmax"
@@ -87,5 +25,4 @@ def get_inputs():
 def get_init_inputs():
     return []  # No special initialization inputs needed
     """
-    print(measure_program_time(ref_arch_name, ref_arch_src, use_torch_compile=False))
-    print(measure_program_time(ref_arch_name, ref_arch_src, use_torch_compile=True))
\ No newline at end of file
+    print(measure_ref_program_time(ref_arch_name, ref_arch_src, use_torch_compile=False, timing_method="cuda_event", precision="fp32"))
\ No newline at end of file
diff --git a/scripts/inspect_baseline.py b/scripts/inspect_baseline.py
index e7811f64..aeac959d 100644
--- a/scripts/inspect_baseline.py
+++ b/scripts/inspect_baseline.py
@@ -3,14 +3,12 @@
 import os
 import sys
 import numpy as np
-from src.eval import (
+from kernelbench.eval import (
     load_original_model_and_inputs,
-    time_execution_with_cuda_event,
-    get_timing_stats,
     set_seed,
     fetch_ref_arch_from_problem_id,
 )
-from src.dataset import construct_problem_dataset_from_problem_dir
+from kernelbench.dataset import construct_kernelbench_dataset
 import os, sys
 import logging
 import json
@@ -93,15 +91,15 @@ def emit(self, record):
     separator("")
     
 def fetch_ref_arch_from_level_problem_id(level_num, problem_id, with_name=False):
-    PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level_num))
-    dataset = construct_problem_dataset_from_problem_dir(PROBLEM_DIR)
+    dataset = construct_kernelbench_dataset(level_num)
     return fetch_ref_arch_from_problem_id(problem_id, dataset, with_name)
 
 def inspect_torch_compile_triton(level_num, problem_id):
     ref_arch_name, ref_arch_src = fetch_ref_arch_from_level_problem_id(
         level_num, problem_id, with_name=True
     )
-    ref_arch_name = ref_arch_name.split("/")[-1]
+    # Extract filename from path (works for both full paths and filenames)
+    ref_arch_name = os.path.basename(ref_arch_name)
     context = {}
     Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
         ref_arch_src, context
@@ -116,7 +114,8 @@ def inspect_baseline_torch_compile(level_num, problem_id):
         level_num, problem_id, with_name=True
     )
 
-    ref_arch_name = ref_arch_name.split("/")[-1]
+    # Extract filename from path (works for both full paths and filenames)
+    ref_arch_name = os.path.basename(ref_arch_name)
     context = {}
     Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
         ref_arch_src, context
diff --git a/scripts/inspect_kernel_pytorch_profiler.py b/scripts/inspect_kernel_pytorch_profiler.py
index 3e93637c..b63563a9 100644
--- a/scripts/inspect_kernel_pytorch_profiler.py
+++ b/scripts/inspect_kernel_pytorch_profiler.py
@@ -16,8 +16,8 @@
 device = "cuda:0"
 
 
-from src.utils import read_file
-from src.eval import (
+from kernelbench.utils import read_file
+from kernelbench.eval import (
     load_custom_model,
     load_original_model_and_inputs,
     set_seed,
@@ -103,8 +103,8 @@ def get_torch_profiler_info(ref_arch_src: str,
 def __main__():
     # run_profile(dataset, problem_id, num_trials=10)
 
-    ref_arch_src_path = os.path.join(REPO_ROOT, "src/prompts/few_shot/model_ex_mnist2.py")
-    kernel_src_path = os.path.join(REPO_ROOT, "src/prompts/few_shot/model_new_ex_mnist2.py")
+    ref_arch_src_path = os.path.join(REPO_ROOT, "src/kernelbench/prompts/few_shot/model_ex_mnist2.py")
+    kernel_src_path = os.path.join(REPO_ROOT, "src/kernelbench/prompts/few_shot/model_new_ex_mnist2.py")
 
     ref_arch_src = read_file(ref_arch_src_path)
     kernel_src = read_file(kernel_src_path)
diff --git a/scripts/inspect_triton.py b/scripts/inspect_triton.py
index 4f13c8af..3333dd91 100644
--- a/scripts/inspect_triton.py
+++ b/scripts/inspect_triton.py
@@ -17,45 +17,32 @@
 device = "cuda:0"
 
 
-from src.utils import read_file
-from src.eval import (
+from kernelbench.utils import read_file
+from kernelbench.eval import (
     load_custom_model,
     load_original_model_and_inputs,
-    time_execution_with_cuda_event,
     get_timing_stats,
     set_seed,
 )
 
-def fetch_ref_arch_from_dataset(dataset: list[str], 
-                                problem_id: int) -> tuple[str, str, str]:
-    """
-    Fetch the reference architecture from the problem directory
-    problem_id should be logical index (1-indexed), matching the problem_id in the problem_name
+from kernelbench.timing import time_execution_with_cuda_event
+from kernelbench.dataset import construct_kernelbench_dataset, fetch_ref_arch_from_dataset, BaseDataset
 
-    Returns:
-        ref_arch_path: str, the path to the reference architecture
-        ref_arch_name: str, the name of the reference architecture
-        ref_arch_src: str, the source code of the reference architecture
-    """
-    ref_arch_path = None
-    
-    for file in dataset:
-        if file.split("/")[-1].split("_")[0] == str(problem_id):
-            ref_arch_path = file
-            break
-    if ref_arch_path is None:
-        raise ValueError(f"No reference architecture found for problem_id {problem_id}")
-    
-    ref_arch_src = read_file(ref_arch_path)
-
-    ref_arch_name = ref_arch_path.split("/")[-1]
-    return (ref_arch_path, ref_arch_name, ref_arch_src)
-
-
-def run_profile_and_save_trace(dataset: list[str], problem_id: int, num_trials=10):
-    """
-    Helper function to get Torch Profile of a problem
-    # TODO: Fix up this function
+
+def run_profile_and_save_trace(
+    dataset: BaseDataset,
+    problem_id: int,
+    num_trials: int = 10
+) -> None:
+    """Helper function to get Torch Profile of a problem.
+
+    Args:
+        dataset: BaseDataset object
+        problem_id: Problem ID to profile
+        num_trials: Number of profiling trials to run (default: 10)
+
+    Note:
+        Saves trace files to 'trace_non_compiled.json' and 'trace_compiled.json'
     """
     ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(
         dataset, problem_id
@@ -120,12 +107,19 @@ def run_profile_and_save_trace(dataset: list[str], problem_id: int, num_trials=1
     # except Exception as e:
         # print(f"[Eval] Error in Measuring Performance: {e}")
 
-def get_torch_compile_triton(level_num, problem_id):
-    """
-    Get the triton code generated by torch compile for a particular problem
+def get_torch_compile_triton(level_num: int, problem_id: int) -> str:
+    """Get the triton code generated by torch compile for a particular problem.
+
+    Args:
+        level_num: KernelBench level (1, 2, or 3)
+        problem_id: Problem ID to inspect
+
+    Returns:
+        str: Name of the reference architecture
     """
+    dataset = construct_kernelbench_dataset(level_num)
     ref_arch_path, ref_arch_name, ref_arch_src = fetch_ref_arch_from_dataset(
-        dataset, problem_id, with_name=True
+        dataset, problem_id
     )
     context = {}
     # import pdb; pdb.set_trace()
@@ -167,7 +161,9 @@ def get_torch_compile_triton(level_num, problem_id):
             
 
             torch.cuda.synchronize(device=device)
-            elapsed_times = time_execution_with_cuda_event(
+            timing_method = "cuda_event" # use cuda event for timing here
+            time_func_cuda_event = get_timing_function(timing_method)
+            elapsed_times = time_func_cuda_event(
                 model, *inputs, num_trials=1, verbose=False, device=device
             )
             runtime_stats = get_timing_stats(elapsed_times, device=device)
diff --git a/scripts/run_and_check.py b/scripts/run_and_check.py
index e0492938..c6f852a6 100644
--- a/scripts/run_and_check.py
+++ b/scripts/run_and_check.py
@@ -3,13 +3,13 @@
 import pydra
 from pydra import REQUIRED, Config
 import os
-from datasets import load_dataset
 import modal
 
-from src import eval as kernel_eval
-from src import utils as kernel_utils
-from scripts.generate_baseline_time import measure_program_time
-from src.utils import read_file
+from kernelbench import eval as kernel_eval
+from kernelbench import utils as kernel_utils
+from kernelbench.timing import measure_ref_program_time
+from kernelbench.utils import read_file
+from kernelbench.kernel_static_checker import validate_kernel_static
 
 # Modal setup
 app = modal.App("run_and_check")
@@ -25,20 +25,28 @@
 }
 
 REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench")
 
-cuda_version = "12.8.0"
+cuda_version = "13.0.0"
 flavor = "devel"
 operating_sys = "ubuntu22.04"
 tag = f"{cuda_version}-{flavor}-{operating_sys}"
 
+SRC_DIR = os.path.join(REPO_TOP_PATH, "src")
+SCRIPTS_DIR = os.path.join(REPO_TOP_PATH, "scripts")
+KERNELBENCH_DIR = os.path.join(REPO_TOP_PATH, "KernelBench")
+
 image = (
     modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.10")
     .apt_install("git", "gcc-10", "g++-10", "clang")
-    .pip_install_from_requirements(os.path.join(REPO_TOP_PATH, "requirements.txt"))
-    .add_local_dir(KERNEL_BENCH_PATH, remote_path="/root/KernelBench")
-    .add_local_python_source("src")
-    .add_local_python_source("scripts")
+    .uv_sync(uv_project_dir=REPO_TOP_PATH, extras=["gpu"])
+    .run_commands("git clone -b main https://github.com/HazyResearch/ThunderKittens.git /root/ThunderKittens")
+    .env({
+        "THUNDERKITTENS_ROOT": "/root/ThunderKittens",
+        "PYTHONPATH": "/root:/root/src:/root/scripts"
+    })
+    .add_local_dir(SRC_DIR, remote_path="/root/src")
+    .add_local_dir(SCRIPTS_DIR, remote_path="/root/scripts")
+    .add_local_dir(KERNELBENCH_DIR, remote_path="/root/KernelBench")  # must be last
 )
 
 """
@@ -47,7 +55,7 @@
 You will need two files
 1. Reference: PyTorch reference (module Model) implementation with init and input shapes
 2. Solution: PyTorch solution (module ModelNew) with inline CUDA Code
-Please see examples in src/prompts
+Please see examples in src/kernelbench/prompts
 
 The Reference could be either
 1. a local file: specify the path to the file
@@ -56,18 +64,18 @@
 ====================================================
 Usage:
 1. PyTorch reference is a local file (local eval)
-python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/prompts/model_ex_add.py kernel_src_path=src/prompts/model_new_ex_add.py eval_mode=local
-python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/prompts/few_shot/model_ex_tiled_matmul.py kernel_src_path=src/prompts/few_shot/model_new_ex_tiled_matmul.py eval_mode=local
+uv run python scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=local
+uv run python scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py kernel_src_path=src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py eval_mode=local
 
 
 2. PyTorch reference is a kernelbench problem (local eval)
-python3 scripts/run_and_check.py ref_origin=kernelbench level=<level> problem_id=<problem_id> kernel_src_path=<path to model-generated kernel> eval_mode=local
+uv run python scripts/run_and_check.py ref_origin=kernelbench level=<level> problem_id=<problem_id> kernel_src_path=<path to model-generated kernel> eval_mode=local
 
 3. PyTorch reference is a local file (modal eval on cloud GPU)
-python3 scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/prompts/model_ex_add.py kernel_src_path=src/prompts/model_new_ex_add.py eval_mode=modal gpu=H100
+uv run python scripts/run_and_check.py ref_origin=local ref_arch_src_path=src/kernelbench/prompts/model_ex_add.py kernel_src_path=src/kernelbench/prompts/model_new_ex_add.py eval_mode=modal gpu=H100
 
 4. PyTorch reference is a kernelbench problem (modal eval on cloud GPU)
-python3 scripts/run_and_check.py ref_origin=kernelbench level=<level> problem_id=<problem_id> kernel_src_path=<path to model-generated kernel> eval_mode=modal gpu=L40S
+uv run python scripts/run_and_check.py ref_origin=kernelbench level=<level> problem_id=<problem_id> kernel_src_path=<path to model-generated kernel> eval_mode=modal gpu=L40S
 ====================================================
 
 """
@@ -83,6 +91,7 @@ def __init__(self):
         # ref_origin is local, specify local file path
         self.ref_arch_src_path = ""
         # ref_origin is kernelbench, specify level and problem id
+        self.dataset_src = "huggingface" # either huggingface or local
         self.dataset_name = "ScalingIntelligence/KernelBench"
         self.level = ""
         self.problem_id = ""
@@ -112,6 +121,8 @@ def __init__(self):
         self.precision = "fp32"
         self.backend = "cuda"
 
+        self.check_kernel = True  # [experimental] optional static checker catching potential hacking patterns
+
     def __repr__(self):
         return f"ScriptConfig({self.to_dict()})"
 
@@ -178,8 +189,8 @@ class EvalFunc:
     @modal.method()
     def evaluate_single_sample_src_modal(self, ref_arch_src: str, kernel_src: str, configs: dict, gpu_arch: list):
         """Evaluate a single sample source code against a reference source code on Modal"""
-        from src.utils import set_gpu_arch
-        from src.eval import eval_kernel_against_ref, get_torch_dtype_from_string
+        from kernelbench.utils import set_gpu_arch
+        from kernelbench.eval import eval_kernel_against_ref, get_torch_dtype_from_string
 
         set_gpu_arch(gpu_arch)
         device = torch.device("cuda:0")
@@ -214,23 +225,26 @@ def measure_program_time_modal(
         use_torch_compile: bool,
         torch_compile_backend: str,
         torch_compile_options: str,
-        gpu_arch: list
+        gpu_arch: list,
+        precision: str,
     ):
         """Measure the execution time of a reference program on Modal"""
-        from scripts.generate_baseline_time import measure_program_time
-        from src.utils import set_gpu_arch
+        from kernelbench.timing import measure_ref_program_time
+        from kernelbench.utils import set_gpu_arch
 
         set_gpu_arch(gpu_arch)
         device = torch.device("cuda:0")
 
-        return measure_program_time(
+        return measure_ref_program_time(
             ref_arch_name="Reference Program",
             ref_arch_src=ref_arch_src,
             num_trials=num_trials,
             use_torch_compile=use_torch_compile,
             torch_compile_backend=torch_compile_backend,
             torch_compile_options=torch_compile_options,
-            device=device
+            verbose=False,
+            device=device,
+            precision=precision,
         )
 
 
@@ -247,30 +261,38 @@ def main(config: ScriptConfig):
     if config.ref_origin == "local":
         assert config.ref_arch_src_path != "", "ref_arch_src_path is required"
         ref_arch_src = read_file(config.ref_arch_src_path)
+        print(f"Loaded reference from local file: {config.ref_arch_src_path}")
     elif config.ref_origin == "kernelbench":
-        assert config.dataset_name != "", "dataset_name is required"
+        from kernelbench.dataset import construct_kernelbench_dataset
+        
         assert config.level != "", "level is required"
         assert config.problem_id != "", "problem_id is required"
-
-        # for now use the HuggingFace dataset
-        dataset = load_dataset(config.dataset_name)
-        curr_level_dataset = dataset[f"level_{config.level}"]
-
-        curr_problem_row = curr_level_dataset.filter(lambda x: x["problem_id"] == config.problem_id)
-        ref_arch_src = curr_problem_row["code"][0]
-        problem_name = curr_problem_row["name"][0]
-
-        problem_number = int(problem_name.split("_")[0])
-        assert problem_number == config.problem_id, f"Problem number in filename ({problem_number}) does not match config problem_id ({config.problem_id})"
-
-        print(f"Fetched problem {config.problem_id} from KernelBench level {config.level}: {problem_name}")
-
-
-    else:
-        raise ValueError("Invalid ref_origin")
+        
+        # Unified interface - same code for huggingface and local!
+        dataset = construct_kernelbench_dataset(
+            level=int(config.level),
+            source=config.dataset_src,
+            dataset_name=config.dataset_name,
+        )
+        problem = dataset.get_problem_by_id(int(config.problem_id))
+        ref_arch_src = problem.code
+        
+        print(f"Fetched problem {problem.problem_id} from KernelBench level {problem.level}: {problem.name}")
     
     kernel_src = read_file(config.kernel_src_path)
 
+    # Optional: static code checker for kernel code using regex matching
+    # NOTE: by no means is this checker complete, but it could help catch some potential hacks
+    if config.check_kernel:
+        static_check_status, errors, warnings = validate_kernel_static(
+            kernel_src,
+            backend=config.backend,
+            precision=config.precision,
+        )
+        assert static_check_status, f"Static check failed. Errors: {errors}. Warnings: {warnings}"
+        if warnings:
+            print(f"[WARN] Static check warnings: {warnings}")
+
     # Start Evaluation
     assert config.eval_mode in ["local", "modal"], "eval_mode must be either 'local' or 'modal'"
 
@@ -292,21 +314,27 @@ def main(config: ScriptConfig):
         # Measure baseline time
         print("[INFO] Measuring reference program time")
         # Default using PyTorch Eager here
-        ref_time_eager_result = measure_program_time(ref_arch_name="Reference Program",
+        ref_time_eager_result = measure_ref_program_time(ref_arch_name="Reference Program",
                                                     ref_arch_src=ref_arch_src,
                                                     num_trials=config.num_perf_trials,
                                                     use_torch_compile=False,
-                                                    device=device)
+                                                    timing_method=config.timing_method,
+                                                    device=device,
+                                                    verbose=False,
+                                                    precision=config.precision,
+                                                    )
         ref_exec_eager_time = ref_time_eager_result.get("mean", None)
 
         # Measure Torch Compile time
-        ref_time_compile_result = measure_program_time(ref_arch_name="Reference Program",
+        ref_time_compile_result = measure_ref_program_time(ref_arch_name="Reference Program",
                                                     ref_arch_src=ref_arch_src,
                                                     num_trials=config.num_perf_trials,
                                                     use_torch_compile=True,
-                                                    torch_compile_backend="inductor",
-                                                    torch_compile_options="default",
-                                                    device=device)
+                                                    timing_method=config.timing_method,
+                                                    device=device,
+                                                    verbose=False,
+                                                    precision=config.precision,
+                                                    )
         ref_exec_compile_time = ref_time_compile_result.get("mean", None)
 
     elif config.eval_mode == "modal":
@@ -337,7 +365,8 @@ def main(config: ScriptConfig):
                 use_torch_compile=False,
                 torch_compile_backend=None,
                 torch_compile_options=None,
-                gpu_arch=gpu_arch
+                gpu_arch=gpu_arch,
+                precision=config.precision,
             )
             ref_exec_eager_time = ref_time_eager_result.get("mean", None)
 
@@ -351,7 +380,8 @@ def main(config: ScriptConfig):
                 use_torch_compile=True,
                 torch_compile_backend="inductor",
                 torch_compile_options="default",
-                gpu_arch=gpu_arch
+                gpu_arch=gpu_arch,
+                precision=config.precision,
             )
             ref_exec_compile_time = ref_time_compile_result.get("mean", None)
 
diff --git a/scripts/verify_bench.py b/scripts/verify_bench.py
index 5fdc6862..369a25e2 100644
--- a/scripts/verify_bench.py
+++ b/scripts/verify_bench.py
@@ -71,37 +71,46 @@ def run(Model, NewModel, get_inputs, get_init_inputs, seed=1012):
     return check_correctness(Model, NewModel, get_inputs, get_init_inputs, seed)
 
 
-def run_all(directory):
-    print(f"Running {directory}")
+from kernelbench.dataset import construct_kernelbench_dataset
+
+def run_all(level):
+    print(f"Running Level {level}")
+    dataset = construct_kernelbench_dataset(level)
     total = 0
     passed = 0
     fail_tests = []
-    abs_path = os.path.abspath(directory)
-    for filename in os.listdir(abs_path):
-        if filename.endswith(".py"):
-            total += 1
-            module_name = filename[:-3]  # Remove .py extension
-            try:
-                # Dynamically import the module
-                spec = importlib.util.spec_from_file_location(
-                    module_name, os.path.join(abs_path, filename)
+    
+    for problem in dataset:
+        total += 1
+        module_name = problem.name.replace(".py", "")
+        try:
+            problem_path = getattr(problem, "path", None)
+            if not problem_path:
+                raise ValueError(
+                    f"Problem '{module_name}' does not have a local file path; "
+                    "verify_bench.py only supports local datasets."
                 )
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)
-                # Get the required attributes from the module
-                Model = getattr(module, "Model")
-                get_inputs = getattr(module, "get_inputs")
-                get_init_inputs = getattr(module, "get_init_inputs")
-                assert run(Model, Model, get_inputs, get_init_inputs)
-                passed += 1
-            except Exception as e:
-                fail_tests.append(module_name)
-    print(f"{directory}: {passed}/{total} passed")
+            # Dynamically import the module
+            spec = importlib.util.spec_from_file_location(
+                module_name, problem_path
+            )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            # Get the required attributes from the module
+            Model = getattr(module, "Model")
+            get_inputs = getattr(module, "get_inputs")
+            get_init_inputs = getattr(module, "get_init_inputs")
+            assert run(Model, Model, get_inputs, get_init_inputs)
+            passed += 1
+        except Exception as e:
+            print(f"Failed {module_name}: {e}")
+            fail_tests.append(module_name)
+    print(f"Level {level}: {passed}/{total} passed")
     if len(fail_tests) > 0:
         print(f"Failed tests: {fail_tests}")
 
 
 if __name__ == "__main__":
-    run_all(KERNEL_BENCH_PATH + "/level1")
-    run_all(KERNEL_BENCH_PATH + "/level2")
-    run_all(KERNEL_BENCH_PATH + "/level3")
+    run_all(1)
+    run_all(2)
+    run_all(3)
diff --git a/scripts/verify_generation.py b/scripts/verify_generation.py
index 61c150c7..78791b6f 100644
--- a/scripts/verify_generation.py
+++ b/scripts/verify_generation.py
@@ -1,7 +1,7 @@
 import sys, os
-import src.utils as utils
+import kernelbench.utils as utils
 import time
-from src.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
+from kernelbench.prompt_constructor_toml import get_prompt_for_backend, get_custom_prompt
 """
 For testing infernece and quickly iterate on prompts 
 Uses functions in prompt_constructor
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 220b79d1..00000000
--- a/setup.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from setuptools import setup
-
-if __name__ == "__main__":
-    setup(
-        name="src",
-        version="0.0.1",
-        packages=["src"],
-    )
diff --git a/src/dataset.py b/src/dataset.py
deleted file mode 100644
index cb429dc1..00000000
--- a/src/dataset.py
+++ /dev/null
@@ -1,146 +0,0 @@
-################################################################################
-# Helpers for Dataset
-################################################################################
-
-import os
-import random
-import re
-import hashlib
-
-REPO_TOP_PATH = os.path.abspath(
-    os.path.join(
-        os.path.dirname(__file__),
-        "..",
-    )
-)
-KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench")
-
-
-def assign_problem_hash(problem_path: str) -> list[int]:
-    """
-    Assign a unique hash to a problem in the dataset
-    """
-    with open(problem_path, "r") as f:
-        problem_src = f.read()
-    return get_code_hash(problem_src)
-
-
-def get_code_hash(problem_src: str) -> str:
-    """
-    Assign a unique hash to some piece of code
-    Important to strip out the comments and whitespace as they are not functionally part of the code
-    """
-    # Remove multi-line comments first
-    problem_src = re.sub(r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'', "", problem_src)
-    # Remove inline comments and all whitespace
-    cleaned_problem_src = re.sub(r"#.*$|\s+", "", problem_src, flags=re.MULTILINE)
-    # hash only on code
-    return hashlib.md5(cleaned_problem_src.encode()).hexdigest()
-
-
-def construct_problem_dataset_from_problem_dir(problem_dir: str) -> list[str]:
-    """
-    Construct a list of relative paths to all the python files in the problem directory
-    Sorted by the numerical prefix of the filenames
-    """
-    DATASET = []
-
-    for file_name in os.listdir(problem_dir):
-        if file_name.endswith(".py"):
-            # TODO: revisit later to satisfy eval harnes
-            relative_path = os.path.join(problem_dir, file_name)
-            DATASET.append(relative_path)
-
-    # Sort the DATASET based on the numerical prefix of the filenames
-    DATASET.sort(key=lambda x: int(os.path.basename(x).split("_")[0]))
-
-    return DATASET
-
-
-def construct_kernelbench_dataset(level: int) -> list[str]:
-    return construct_problem_dataset_from_problem_dir(
-        os.path.join(KERNEL_BENCH_PATH, f"level{level}")
-    )
-
-
-KERNELBENCH_LEVEL_1_DATASET = construct_kernelbench_dataset(level=1)
-KERNELBENCH_LEVEL_2_DATASET = construct_kernelbench_dataset(level=2)
-KERNELBENCH_LEVEL_3_DATASET = construct_kernelbench_dataset(level=3)
-
-################################################################################
-# Eval on Subsets of KernelBench
-################################################################################
-
-
-def get_kernelbench_subset(
-    level: int, num_subset_problems: int = 10, random_seed: int = 42
-) -> tuple[list[str], list[int]]:
-    """
-    Get a random subset of problems from the KernelBench dataset
-    """
-
-    full_dataset = construct_kernelbench_dataset(level)
-
-    random.seed(random_seed)
-    num_subset_problems = min(num_subset_problems, len(full_dataset))
-    subset_indices = random.sample(range(len(full_dataset)), num_subset_problems)
-
-    subset = sorted([full_dataset[i] for i in subset_indices])
-    return subset, subset_indices
-
-
-################################################################################
-# Representative subsets of KernelBench
-# use this if you want to iterate on methods without the hassle of running the full dataset
-# problem_ids are 1-indexed (logical index)
-################################################################################
-
-level1_representative_subset = [
-    "1_Square_matrix_multiplication_.py",
-    "3_Batched_matrix_multiplication.py",
-    "6_Matmul_with_large_K_dimension_.py",
-    "18_Matmul_with_transposed_both.py",
-    "23_Softmax.py",
-    "26_GELU_.py",
-    "33_BatchNorm.py",
-    "36_RMSNorm_.py",
-    "40_LayerNorm.py",
-    "42_Max_Pooling_2D.py",
-    "48_Mean_reduction_over_a_dimension.py",
-    "54_conv_standard_3D__square_input__square_kernel.py",
-    "57_conv_transposed_2D__square_input__square_kernel.py",
-    "65_conv_transposed_2D__square_input__asymmetric_kernel.py",
-    "77_conv_transposed_3D_square_input_square_kernel___padded____dilated____strided__.py",
-    "82_conv_depthwise_2D_square_input_square_kernel.py",
-    "86_conv_depthwise_separable_2D.py",
-    "87_conv_pointwise_2D.py",
-]
-
-level1_representative_subset_problem_ids = [1, 3, 6, 18, 23, 26, 33, 36, 40, 42, 48, 54, 57, 65, 77, 82, 86, 87]
-
-level2_representative_subset = [
-    "1_Conv2D_ReLU_BiasAdd.py",
-    "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py",
-    "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py",
-    "18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py",
-    "23_Conv3d_GroupNorm_Mean.py",
-    "28_BMM_InstanceNorm_Sum_ResidualAdd_Multiply.py",
-    "33_Gemm_Scale_BatchNorm.py",
-    "43_Conv3d_Max_LogSumExp_ReLU.py",
-]
-
-level2_representative_subset_problem_ids = [1, 2, 8, 18, 23, 28, 33, 43]
-
-level3_representative_subset = [
-    "1_MLP.py",
-    "5_AlexNet.py",
-    "8_ResNetBasicBlock.py",
-    "11_VGG16.py",
-    "20_MobileNetV2.py",
-    "21_EfficientNetMBConv.py",
-    "33_VanillaRNN.py",
-    "38_LTSMBidirectional.py",
-    "43_MinGPTCausalAttention.py",
-]
-
-level3_representative_subset_problem_ids = [1, 5, 8, 11, 20, 33, 38, 43]
\ No newline at end of file
diff --git a/src/__init__.py b/src/kernelbench/__init__.py
similarity index 100%
rename from src/__init__.py
rename to src/kernelbench/__init__.py
diff --git a/src/analysis.py b/src/kernelbench/analysis.py
similarity index 100%
rename from src/analysis.py
rename to src/kernelbench/analysis.py
diff --git a/src/compile.py b/src/kernelbench/compile.py
similarity index 98%
rename from src/compile.py
rename to src/kernelbench/compile.py
index 41fd8c3b..2ce7c143 100644
--- a/src/compile.py
+++ b/src/kernelbench/compile.py
@@ -5,8 +5,8 @@
 from tqdm import tqdm
 
 import shutil
-from src.eval import build_compile_cache
-from src import utils as utils
+from kernelbench.eval import build_compile_cache
+from kernelbench import utils as utils
 import torch
 import os
 import multiprocessing as mp
diff --git a/src/kernelbench/dataset.py b/src/kernelbench/dataset.py
new file mode 100644
index 00000000..7f0e8b22
--- /dev/null
+++ b/src/kernelbench/dataset.py
@@ -0,0 +1,581 @@
+################################################################################
+# Unified Dataset Abstraction for KernelBench
+#
+# Supports both local filesystem and HuggingFace datasets through a unified
+# interface. All problem access is by logical problem_id (1-indexed).
+################################################################################
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Iterator, Optional
+import os
+import random
+import re
+import hashlib
+
+REPO_TOP_PATH = os.path.abspath(
+    os.path.join(
+        os.path.dirname(__file__),
+        "../..",
+    )
+)
+KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench")
+
+
+################################################################################
+# Problem Dataclass
+################################################################################
+
+@dataclass
+class Problem:
+    """Unified representation of a KernelBench problem.
+    
+    Attributes:
+        problem_id: 1-indexed logical ID (matches filename prefix)
+        name: Filename, e.g., "1_Square_matrix_multiplication_.py"
+        code: The actual source code
+        level: KernelBench level (1, 2, 3, or custom)
+        path: Local filesystem path (None if from HuggingFace)
+        metadata: Extra metadata for future use (e.g., categories, difficulty)
+    
+    Note:
+        Code is loaded eagerly when the dataset is constructed (~500KB for level 1).
+        If memory becomes a concern for very large datasets, this could be refactored
+        to lazy loading where code is only read when Problem.code is accessed.
+    """
+    problem_id: int
+    name: str
+    code: str
+    level: int
+    path: Optional[str] = None
+    metadata: Optional[dict] = None
+
+    @property
+    def hash(self) -> str:
+        """Compute code hash for problem identification.
+        
+        The hash ignores comments and whitespace, so functionally
+        equivalent code produces the same hash. Useful for:
+        - Deduplication across dataset versions
+        - Tracking problem identity when code formatting changes
+        - Comparing local vs HuggingFace versions
+        """
+        return get_code_hash(self.code)
+
+
+################################################################################
+# Hash Utilities
+################################################################################
+
+def get_code_hash(code: str) -> str:
+    """Compute a unique hash for code, ignoring comments and whitespace."""
+    # Remove multi-line comments
+    code = re.sub(r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'', "", code)
+    # Remove inline comments and all whitespace
+    cleaned = re.sub(r"#.*$|\s+", "", code, flags=re.MULTILINE)
+    return hashlib.md5(cleaned.encode()).hexdigest()
+
+
+################################################################################
+# Base Dataset Abstract Class
+################################################################################
+
+class BaseDataset(ABC):
+    """Abstract base for all KernelBench datasets.
+    
+    Provides a unified interface for accessing problems by ID,
+    iteration, and length.
+    """
+
+    @property
+    @abstractmethod
+    def level(self) -> int:
+        """Return the KernelBench level."""
+        pass
+
+    @abstractmethod
+    def __len__(self) -> int:
+        """Return the number of problems in the dataset."""
+        pass
+
+    @abstractmethod
+    def __iter__(self) -> Iterator[Problem]:
+        """Iterate over Problem objects in the dataset."""
+        pass
+
+    @abstractmethod
+    def get_problem_by_id(self, problem_id: int) -> Problem:
+        """Get problem by 1-indexed logical ID."""
+        pass
+
+    @abstractmethod
+    def get_problem_ids(self) -> list[int]:
+        """Get sorted list of all problem IDs in the dataset."""
+        pass
+
+
+    def subset(
+        self,
+        problem_ids: Optional[list[int]] = None,
+        id_range: Optional[tuple[int, int]] = None,
+    ) -> "BaseDataset":
+        """Create a subset by problem IDs.
+        
+        Args:
+            problem_ids: Specific problem IDs to include (e.g., [1, 3, 5])
+            id_range: (start_id, end_id) inclusive range of problem IDs
+            
+        Returns:
+            New dataset with only the specified problems
+            
+        Example:
+            >>> dataset.subset(problem_ids=[1, 3, 5])
+            >>> dataset.subset(id_range=(1, 10))
+        """
+        raise NotImplementedError("Subclasses should implement subset()")
+
+    def sample(self, n: int, seed: int = 42) -> "BaseDataset":
+        """Get a random sample of N problems.
+        
+        Args:
+            n: Number of problems to sample
+            seed: Random seed for reproducibility
+            
+        Returns:
+            New dataset with N randomly selected problems
+        """
+        all_ids = self.get_problem_ids()
+        n = min(n, len(all_ids))
+        random.seed(seed)
+        sampled_ids = random.sample(all_ids, n)
+        return self.subset(problem_ids=sorted(sampled_ids))
+
+    def get_representative_subset(self) -> "BaseDataset":
+        """Get a curated representative subset for quick iteration.
+        
+        Returns a diverse subset covering different problem categories
+        (matmul, conv, norms, etc.). Useful for testing.
+        """
+        rep_ids = {
+            1: [1, 3, 6, 18, 23, 26, 33, 36, 40, 42, 48, 54, 57, 65, 77, 82, 86, 87],
+            2: [1, 2, 8, 18, 23, 28, 33, 43],
+            3: [1, 5, 8, 11, 20, 21, 33, 38, 43],
+        }
+        
+        if self.level not in rep_ids:
+            raise ValueError(f"No representative subset for level {self.level}")
+        
+        available_ids = set(self.get_problem_ids())
+        subset_ids = [pid for pid in rep_ids[self.level] if pid in available_ids]
+        
+        return self.subset(problem_ids=subset_ids)
+
+
+################################################################################
+# Local Filesystem Dataset
+################################################################################
+
+class LocalKernelBenchDataset(BaseDataset):
+    """Dataset backed by local filesystem.
+    
+    Loads problems from KernelBench/level{N}/*.py
+    Flexible for any level number (1, 2, 3, or custom levels).
+    """
+
+    def __init__(
+        self,
+        level: int,
+        base_path: str = KERNEL_BENCH_PATH,
+        problem_ids: Optional[list[int]] = None,
+        id_range: Optional[tuple[int, int]] = None,
+    ):
+        """Initialize local dataset.
+        
+        Args:
+            level: KernelBench level (any positive integer)
+            base_path: Path to KernelBench directory
+            problem_ids: Optional list of specific problem IDs to include
+            id_range: Optional (start_id, end_id) inclusive range
+        """
+        if level < 1:
+            raise ValueError(f"level must be >= 1, got {level}")
+
+        self._level = level
+        self._base_path = base_path
+        self._problems: dict[int, Problem] = {}
+        
+        # Build filter set from problem_ids and/or id_range
+        self._filter_ids = self._build_filter_set(problem_ids, id_range)
+        self._load_problems()
+
+    def _build_filter_set(
+        self,
+        problem_ids: Optional[list[int]],
+        id_range: Optional[tuple[int, int]],
+    ) -> Optional[set[int]]:
+        """Build a set of IDs to filter by, or None for no filtering."""
+        if problem_ids is None and id_range is None:
+            return None
+        
+        filter_set = set()
+        if problem_ids:
+            filter_set.update(problem_ids)
+        if id_range:
+            start, end = id_range
+            filter_set.update(range(start, end + 1))
+        return filter_set
+
+    @property
+    def level(self) -> int:
+        return self._level
+
+    def _load_problems(self):
+        problem_dir = os.path.join(self._base_path, f"level{self._level}")
+        
+        if not os.path.exists(problem_dir):
+            raise FileNotFoundError(f"Problem directory not found: {problem_dir}")
+
+        for file_name in os.listdir(problem_dir):
+            if not file_name.endswith(".py"):
+                continue
+
+            try:
+                problem_id = int(file_name.split("_")[0])
+            except (ValueError, IndexError):
+                continue
+
+            # Apply filter if specified
+            if self._filter_ids is not None and problem_id not in self._filter_ids:
+                continue
+
+            path = os.path.join(problem_dir, file_name)
+            with open(path, "r") as f:
+                code = f.read()
+
+            self._problems[problem_id] = Problem(
+                problem_id=problem_id,
+                name=file_name,
+                code=code,
+                level=self._level,
+                path=path,
+            )
+
+    def get_problem_by_id(self, problem_id: int) -> Problem:
+        if problem_id not in self._problems:
+            raise ValueError(f"Problem ID {problem_id} not found in dataset")
+        return self._problems[problem_id]
+
+    def get_problem_ids(self) -> list[int]:
+        return sorted(self._problems.keys())
+
+    def __len__(self) -> int:
+        return len(self._problems)
+
+    def __iter__(self) -> Iterator[Problem]:
+        for pid in self.get_problem_ids():
+            yield self._problems[pid]
+
+    def __repr__(self) -> str:
+        return f"LocalKernelBenchDataset(level={self._level}, problems={len(self)})"
+
+    def subset(
+        self,
+        problem_ids: Optional[list[int]] = None,
+        id_range: Optional[tuple[int, int]] = None,
+    ) -> "LocalKernelBenchDataset":
+        """Create a subset of this dataset."""
+        return LocalKernelBenchDataset(
+            level=self._level,
+            base_path=self._base_path,
+            problem_ids=problem_ids,
+            id_range=id_range,
+        )
+
+
+################################################################################
+# HuggingFace Dataset
+################################################################################
+
+class HuggingFaceKernelBenchDataset(BaseDataset):
+    """Dataset backed by HuggingFace datasets."""
+
+    def __init__(
+        self,
+        level: int,
+        dataset_name: str = "ScalingIntelligence/KernelBench",
+        problem_ids: Optional[list[int]] = None,
+        id_range: Optional[tuple[int, int]] = None,
+    ):
+        """Initialize HuggingFace dataset.
+        
+        Args:
+            level: KernelBench level (1, 2, or 3)
+            dataset_name: HuggingFace dataset identifier
+            problem_ids: Optional list of specific problem IDs to include
+            id_range: Optional (start_id, end_id) inclusive range
+        """
+        if level not in [1, 2, 3]:
+            raise ValueError(f"HuggingFace dataset only has levels 1, 2, 3, got {level}")
+
+        self._level = level
+        self._dataset_name = dataset_name
+        self._problems: dict[int, Problem] = {}
+        self._filter_ids = self._build_filter_set(problem_ids, id_range)
+        self._load_dataset()
+
+    def _build_filter_set(
+        self,
+        problem_ids: Optional[list[int]],
+        id_range: Optional[tuple[int, int]],
+    ) -> Optional[set[int]]:
+        """Build a set of IDs to filter by, or None for no filtering."""
+        if problem_ids is None and id_range is None:
+            return None
+        
+        filter_set = set()
+        if problem_ids:
+            filter_set.update(problem_ids)
+        if id_range:
+            start, end = id_range
+            filter_set.update(range(start, end + 1))
+        return filter_set
+
+    @property
+    def level(self) -> int:
+        return self._level
+
+    def _load_dataset(self):
+        from datasets import load_dataset
+
+        split_name = f"level_{self._level}"
+        hf_dataset = load_dataset(self._dataset_name, split=split_name)
+
+        for row in hf_dataset:
+            problem_id = row["problem_id"]
+
+            if self._filter_ids is not None and problem_id not in self._filter_ids:
+                continue
+
+            self._problems[problem_id] = Problem(
+                problem_id=problem_id,
+                name=row["name"],
+                code=row["code"],
+                level=self._level,
+                path=None,
+            )
+
+    def get_problem_by_id(self, problem_id: int) -> Problem:
+        if problem_id not in self._problems:
+            raise ValueError(f"Problem ID {problem_id} not found in dataset")
+        return self._problems[problem_id]
+
+    def get_problem_ids(self) -> list[int]:
+        return sorted(self._problems.keys())
+
+    def __len__(self) -> int:
+        return len(self._problems)
+
+    def __iter__(self) -> Iterator[Problem]:
+        for pid in self.get_problem_ids():
+            yield self._problems[pid]
+
+    def __repr__(self) -> str:
+        return f"HuggingFaceKernelBenchDataset(level={self._level}, problems={len(self)})"
+
+    def subset(
+        self,
+        problem_ids: Optional[list[int]] = None,
+        id_range: Optional[tuple[int, int]] = None,
+    ) -> "HuggingFaceKernelBenchDataset":
+        """Create a subset of this dataset."""
+        return HuggingFaceKernelBenchDataset(
+            level=self._level,
+            dataset_name=self._dataset_name,
+            problem_ids=problem_ids,
+            id_range=id_range,
+        )
+
+
+################################################################################
+# Factory Function
+################################################################################
+
+def construct_kernelbench_dataset(
+    level: int,
+    source: str = "local",
+    dataset_name: str = "ScalingIntelligence/KernelBench",
+    base_path: str = KERNEL_BENCH_PATH,
+    problem_ids: Optional[list[int]] = None,
+    id_range: Optional[tuple[int, int]] = None,
+) -> BaseDataset:
+    """Construct a KernelBench dataset for a specific level.
+    
+    Args:
+        level: KernelBench level (1, 2, 3, or custom for local)
+        source: "local" for filesystem, "huggingface" for HF datasets
+        dataset_name: HuggingFace dataset identifier (if source="huggingface")
+        base_path: Path to KernelBench directory (if source="local")
+        problem_ids: Optional list of specific problem IDs to include
+        id_range: Optional (start_id, end_id) inclusive range
+        
+    Returns:
+        BaseDataset instance for the specified level
+        
+    Examples:
+        # Local filesystem (default)
+        >>> dataset = construct_kernelbench_dataset(level=1, source="local")
+        >>> len(dataset)
+        100
+        
+        # HuggingFace
+        >>> dataset = construct_kernelbench_dataset(level=1, source="huggingface")
+        >>> len(dataset)
+        100
+        
+        # Filter by specific IDs
+        >>> dataset = construct_kernelbench_dataset(level=1, problem_ids=[1, 3, 5])
+        >>> dataset.get_problem_ids()
+        [1, 3, 5]
+        
+        # Filter by range
+        >>> dataset = construct_kernelbench_dataset(level=1, id_range=(1, 10))
+        >>> dataset.get_problem_ids()
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        
+        # Access problems
+        >>> problem = dataset.get_problem_by_id(1)
+        >>> problem.name
+        '1_Square_matrix_multiplication_.py'
+        >>> problem.code[:50]
+        'import torch...'
+    """
+    if source == "local":
+        return LocalKernelBenchDataset(level, base_path, problem_ids, id_range)
+    elif source == "huggingface":
+        return HuggingFaceKernelBenchDataset(level, dataset_name, problem_ids, id_range)
+    else:
+        raise ValueError(f"Unknown source: {source}. Must be 'local' or 'huggingface'")
+
+
+################################################################################
+# Convenience Functions
+################################################################################
+
+def fetch_ref_arch_from_dataset(
+    dataset: BaseDataset,
+    problem_id: int,
+) -> tuple[Optional[str], str, str]:
+    """Fetch reference architecture from dataset.
+
+    Returns:
+        (path, name, code) - path is None for HuggingFace datasets
+    """
+    problem = dataset.get_problem_by_id(problem_id)
+    return (problem.path, problem.name, problem.code)
+
+
+def get_kernelbench_subset(
+    level: int,
+    num_subset_problems: int = 10,
+    random_seed: int = 42,
+    source: str = "local",
+) -> tuple[BaseDataset, list[int]]:
+    """Get a random subset of problems.
+    
+    Returns:
+        (subset_dataset, subset_problem_ids)
+    """
+    full_dataset = construct_kernelbench_dataset(level, source=source)
+    all_ids = full_dataset.get_problem_ids()
+
+    random.seed(random_seed)
+    num_subset_problems = min(num_subset_problems, len(all_ids))
+    subset_ids = sorted(random.sample(all_ids, num_subset_problems))
+
+    subset_dataset = construct_kernelbench_dataset(
+        level=level,
+        source=source,
+        problem_ids=subset_ids,
+    )
+    return subset_dataset, subset_ids
+
+
+################################################################################
+# Representative Subsets of KernelBench
+# Use these for quick iteration without running the full dataset
+################################################################################
+
+# Level 1: Basic operators - matmul, activations, norms, pooling, convolutions
+LEVEL1_REPRESENTATIVE_SUBSET = [
+    "1_Square_matrix_multiplication_.py",
+    "3_Batched_matrix_multiplication.py",
+    "6_Matmul_with_large_K_dimension_.py",
+    "18_Matmul_with_transposed_both.py",
+    "23_Softmax.py",
+    "26_GELU_.py",
+    "33_BatchNorm.py",
+    "36_RMSNorm_.py",
+    "40_LayerNorm.py",
+    "42_Max_Pooling_2D.py",
+    "48_Mean_reduction_over_a_dimension.py",
+    "54_conv_standard_3D__square_input__square_kernel.py",
+    "57_conv_transposed_2D__square_input__square_kernel.py",
+    "65_conv_transposed_2D__square_input__asymmetric_kernel.py",
+    "77_conv_transposed_3D_square_input_square_kernel___padded____dilated____strided__.py",
+    "82_conv_depthwise_2D_square_input_square_kernel.py",
+    "86_conv_depthwise_separable_2D.py",
+    "87_conv_pointwise_2D.py",
+]
+LEVEL1_REPRESENTATIVE_IDS = [1, 3, 6, 18, 23, 26, 33, 36, 40, 42, 48, 54, 57, 65, 77, 82, 86, 87]
+
+# Level 2: Fused operators - multi-op fusion patterns
+LEVEL2_REPRESENTATIVE_SUBSET = [
+    "1_Conv2D_ReLU_BiasAdd.py",
+    "2_ConvTranspose2d_BiasAdd_Clamp_Scaling_Clamp_Divide.py",
+    "8_Conv3d_Divide_Max_GlobalAvgPool_BiasAdd_Sum.py",
+    "18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py",
+    "23_Conv3d_GroupNorm_Mean.py",
+    "28_BMM_InstanceNorm_Sum_ResidualAdd_Multiply.py",
+    "33_Gemm_Scale_BatchNorm.py",
+    "43_Conv3d_Max_LogSumExp_ReLU.py",
+]
+LEVEL2_REPRESENTATIVE_IDS = [1, 2, 8, 18, 23, 28, 33, 43]
+
+# Level 3: Full models - MLP, CNN architectures, RNNs, Transformers
+LEVEL3_REPRESENTATIVE_SUBSET = [
+    "1_MLP.py",
+    "5_AlexNet.py",
+    "8_ResNetBasicBlock.py",
+    "11_VGG16.py",
+    "20_MobileNetV2.py",
+    "21_EfficientNetMBConv.py",
+    "33_VanillaRNN.py",
+    "38_LTSMBidirectional.py",
+    "43_MinGPTCausalAttention.py",
+]
+LEVEL3_REPRESENTATIVE_IDS = [1, 5, 8, 11, 20, 21, 33, 38, 43]
+
+
+def get_representative_dataset(level: int, source: str = "local") -> BaseDataset:
+    """Get a representative subset dataset for quick iteration.
+    
+    Args:
+        level: 1, 2, or 3
+        source: "local" or "huggingface"
+        
+    Returns:
+        Dataset containing only representative problems
+    """
+    id_map = {
+        1: LEVEL1_REPRESENTATIVE_IDS,
+        2: LEVEL2_REPRESENTATIVE_IDS,
+        3: LEVEL3_REPRESENTATIVE_IDS,
+    }
+    if level not in id_map:
+        raise ValueError(f"No representative subset for level {level}")
+    
+    return construct_kernelbench_dataset(
+        level=level,
+        source=source,
+        problem_ids=id_map[level],
+    )
\ No newline at end of file
diff --git a/src/eval.py b/src/kernelbench/eval.py
similarity index 84%
rename from src/eval.py
rename to src/kernelbench/eval.py
index 5f1fe8d8..3557dc94 100644
--- a/src/eval.py
+++ b/src/kernelbench/eval.py
@@ -21,12 +21,12 @@
 import torch.nn as nn
 from pydantic import BaseModel
 
-from . import utils, timing
+from . import timing, dataset
 
 REPO_TOP_PATH = os.path.abspath(
     os.path.join(
         os.path.dirname(__file__),
-        "..",
+        "../..",
     )
 )
 KERNEL_BENCH_PATH = os.path.join(REPO_TOP_PATH, "KernelBench")
@@ -39,30 +39,27 @@ def get_error_name(e: Exception) -> str:
     return f"{e.__class__.__module__}.{e.__class__.__name__}"
 
 
-def fetch_ref_arch_from_problem_id(problem_id, problems, with_name=False) -> str:
+def fetch_ref_arch_from_problem_id(problem_id: int, dataset: "BaseDataset", with_name=False) -> Union[str, tuple[str, str]]:
     """
-    Fetches the reference architecture in string for a given problem_id
+    Fetches the reference architecture for a given problem_id from the dataset.
     """
     if isinstance(problem_id, str):
         problem_id = int(problem_id)
 
-    problem_path = problems[problem_id]
-
-    # problem_path = os.path.join(REPO_ROOT_PATH, problem)
-    if not os.path.exists(problem_path):
-        raise FileNotFoundError(f"Problem file at {problem_path} does not exist.")
-
-    ref_arch = utils.read_file(problem_path)
+    problem = dataset.get_problem_by_id(problem_id)
+    ref_arch = problem.code
+    
     if not with_name:
         return ref_arch
     else:
-        return (problem_path, ref_arch)
+        # Use problem.name as fallback when path is None (e.g., for HuggingFace datasets)
+        name = problem.path if problem.path is not None else problem.name
+        return (name, ref_arch)
 
 
 def fetch_ref_arch_from_level_problem_id(level, problem_id, with_name=False):
-    PROBLEM_DIR = os.path.join(KERNEL_BENCH_PATH, "level" + str(level))
-    dataset = utils.construct_problem_dataset_from_problem_dir(PROBLEM_DIR)
-    return fetch_ref_arch_from_problem_id(problem_id, dataset, with_name)
+    kb_dataset = dataset.construct_kernelbench_dataset(level)
+    return fetch_ref_arch_from_problem_id(problem_id, kb_dataset, with_name)
 
 
 def set_seed(seed: int):
@@ -109,13 +106,20 @@ class KernelExecResult(BaseModel):
     """
     Single Kernel Execution
     """
-
+    # Execution
     compiled: bool = False
     correctness: bool = False
-    metadata: dict = {}
+    metadata: dict = {} # NOTE: to include warning if any
+
+    # Timing
     runtime: float = -1.0  # in us, only recorded if we decide to measure performance
     runtime_stats: dict = {}  # only recorded if we decide to measure performance
 
+    # new: added ref time either through fetching prev runs or through execution
+    # could do eager for level 1 and compile for level 2 and 3
+    ref_runtime: float = -1.0  # in us, only recorded if we decide to measure performance
+    ref_runtime_stats: dict = {} # only recorded if we decide to measure performance
+
 
 def load_original_model_and_inputs(
     model_original_src: str, context: dict
@@ -402,6 +406,10 @@ def eval_kernel_against_ref(
     ),  # have to run on GPU
     backend: str = "cuda",  # can be 'cuda', 'triton', 'tilelang', or 'cute'
     precision: torch.dtype = torch.float32,
+
+    # Guard against potential reward hacking [optional but ongoing enhancement]
+    check_for_excessive_speedup: bool = True,
+    excessive_speedup_threshold: float = 10, # flag if the kernel is more than <excessive_speedup_threshold>x faster than the reference
 ) -> KernelExecResult:
     """
     Evaluate the custom kernel against the original model
@@ -415,11 +423,24 @@ def eval_kernel_against_ref(
     backend: str, one of 'cuda', 'triton', 'tilelang', or 'cute'
     precision: torch.dtype for computation (note: tilelang only supports fp16)
     timing_method: str, method to time kernel, see timing.py for more details 
+
+    ONGOING EFFORT to refactor and modularize this, and adding more tests for eval.
     """
     # TODO: check device is busy
     assert torch.cuda.is_available(), "CUDA is not available, cannot run Eval"
     
-    if backend.lower() == "tilelang":
+    # Backend-GPU vendor validation
+    from .utils import get_gpu_vendor
+    vendor = get_gpu_vendor(device)
+    backend_lower = backend.lower()
+    # HIP is AMD-only
+    if backend_lower == "hip" and vendor != "amd":
+        raise ValueError(f"HIP backend requires AMD GPU, got {vendor}")
+    # cuda/cute/thunderkittens are NVIDIA-only (triton/tilelang work on both)
+    if backend_lower in ["cuda", "cute", "thunderkittens"] and vendor == "amd":
+        raise ValueError(f"{backend} backend requires NVIDIA GPU, got AMD")
+    
+    if backend_lower == "tilelang":
         assert precision == torch.float16 or precision == torch.bfloat16, "TileLang only supports fp16 or bfloat16"
     
     torch.set_printoptions(
@@ -453,7 +474,11 @@ def eval_kernel_against_ref(
             raise ValueError(
                 f"device must be an int or torch.device, got {type(device)}"
             )
-        os.environ["CUDA_VISIBLE_DEVICES"] = str(device_num)
+        # NVIDIA uses CUDA_VISIBLE_DEVICES, AMD uses HIP_VISIBLE_DEVICES
+        if vendor == "amd":
+            os.environ["HIP_VISIBLE_DEVICES"] = str(device_num)
+        else:
+            os.environ["CUDA_VISIBLE_DEVICES"] = str(device_num)
     context = {}
 
     if verbose:
@@ -518,6 +543,18 @@ def eval_kernel_against_ref(
                 compiled=False, metadata=metadata
             )  # skip further steps
 
+    # Check if ModelNew was successfully loaded (load_custom_model returns None on syntax errors)
+    if ModelNew is None:
+        print(
+            "Failed to load custom model: Syntax error or ModelNew not found in generated code. Record as compilation failure."
+        )
+        metadata["compilation_error_name"] = "SyntaxError"
+        metadata["compilation_error"] = "Syntax error in custom generated code or ModelNew not found"
+        graceful_eval_cleanup(context, device, tempfile)
+        return KernelExecResult(
+            compiled=False, metadata=metadata
+        )  # skip further steps
+
     # at this point we passed compilation
     try:
         with torch.no_grad():
@@ -598,11 +635,66 @@ def eval_kernel_against_ref(
                     print(f"[Eval] Performance Stats: {runtime_stats}")
                 kernel_exec_result.runtime = runtime_stats["mean"]
                 kernel_exec_result.runtime_stats = runtime_stats
+
         except Exception as e:
             if verbose:
                 print(f"[Eval] Error in Measuring Performance: {e}")
             kernel_exec_result.metadata["error_during_performance"] = e
 
+    # To get base PyTorch time (eager, various compile modes)
+    # please use timing.measure_ref_program_time()   
+
+
+    ###############################################################
+    # [Experimental] to be modularized
+    # Condition: custom kernel ModelNew is correct and we are able to time it correctly with kernel_exec_result
+    # We are working on preventing excessive speedup issues
+    ##############################################################
+
+    if measure_performance and check_for_excessive_speedup:  # experimental: hence able to shut off codepath if needed
+    
+        if verbose:
+            print("[Eval] Additional checks to flag excessive speedup")
+
+        torch.cuda.synchronize(device=device)
+        set_seed(seed_num)
+        inputs = get_inputs()
+        # Convert inputs for performance measurement
+        inputs = [_process_input_tensor(x, device, backend, precision) for x in inputs]
+        
+        model_new = custom_model.to(device=device, dtype=precision)
+        torch.cuda.synchronize(device=device)
+
+        # time PyTorch reference function
+        # same timing_fn as specified from before
+        timing_fn = timing.get_timing_function(timing_method)
+        reference_elapsed_times = timing_fn(
+            original_model,
+            inputs, # ideally cloned for extra safety but handled already in correctness check
+            num_trials=num_perf_trials,
+            verbose=verbose,
+            device=device,
+        )
+        reference_runtime_stats = timing.get_timing_stats(reference_elapsed_times, device=device)
+        kernel_exec_result.ref_runtime = reference_runtime_stats["mean"]
+        kernel_exec_result.ref_runtime_stats = reference_runtime_stats
+
+        # Compute Effective Speedup
+        effective_speedup = kernel_exec_result.ref_runtime / kernel_exec_result.runtime
+
+        # TODO: integrate SoL estimation for each unique program on designated hardware
+        # for now, we will use a heuristics such as 5-10x which is very hard to achieve
+
+        if verbose:
+            print(f"[Eval] Effective Speedup is {effective_speedup:.2f}x using timing method {timing_method}")
+
+        if effective_speedup > excessive_speedup_threshold:
+            kernel_exec_result.metadata["excessive_speedup"] = True
+            
+            print(f"[WARNING] Excessive speedup {effective_speedup:.2f}x over {excessive_speedup_threshold}x threshold detected")
+            print(f"[WARNING] Double check your kernel carefully to ensure it is not reward hacking.")
+
+
     graceful_eval_cleanup(context, device, tempfile)
     return kernel_exec_result
 
@@ -814,8 +906,7 @@ def convert_to_serializable(obj):
         return converted_metadata
 
 
-
 # if __name__ == "__main__":
 # fetch_kernel_from_database("kernelbench_prompt_v2_level_2", 1, 1, "http://localhost:9091")
 # print(fetch_ref_arch_from_level_problem_id("2", 1, with_name=True))
-# fetch_baseline_time("level1", 0, ["1_Square_matrix_multiplication_.py"], "tests/baseline_time_matx3.json")
\ No newline at end of file
+# Note: fetch_baseline_time is available in kernelbench.timing module
\ No newline at end of file
diff --git a/src/frameworks.py b/src/kernelbench/frameworks.py
similarity index 98%
rename from src/frameworks.py
rename to src/kernelbench/frameworks.py
index cb3795f9..a7f1a2a0 100644
--- a/src/frameworks.py
+++ b/src/kernelbench/frameworks.py
@@ -24,7 +24,6 @@
 from dotenv import load_dotenv
 load_dotenv()
 
-# from datasets import load_dataset
 import numpy as np
 from contextlib import contextmanager
 from collections import defaultdict
@@ -32,7 +31,6 @@
 import shutil
 import concurrent
 from functools import cache
-from transformers import AutoTokenizer
 import hashlib
 
 from concurrent.futures import ProcessPoolExecutor, as_completed
diff --git a/src/kernelbench/kernel_static_checker.py b/src/kernelbench/kernel_static_checker.py
new file mode 100644
index 00000000..7d97effa
--- /dev/null
+++ b/src/kernelbench/kernel_static_checker.py
@@ -0,0 +1,684 @@
+"""
+Kernel Static Checker - Pattern-based validation for GPU kernel code.
+
+The goal is flag reward hacking patterns (both strictly prohibited and possible ones).
+through statically examining the code.
+
+In the future we can add 
+- AST-based detections 
+- LM as a judge checker
+
+Warning: This list is by no means complete and nor this is not a replacement for runtime checks.
+We welcome feedback and contributions as community find new ways of hacks.
+
+- Bypass hacks (PyTorch wrapping, try-except fallback, inheritance bypass)
+- Disallow some high-level torch operations (depends on the settings)
+- Backend implementation requirements, that CUDA or DSL features must be used
+
+Usage:
+    result = validate_kernel_static(code, backend="cuda")
+    will return a tuple (valid, errors, warnings) 
+"""
+
+import re
+from typing import List, Tuple, Dict, Any, Optional, Callable, Union
+
+def _strip_comments(code: str) -> str:
+    """Remove # and // comments from code."""
+    lines = []
+    for line in code.split('\n'):
+        if '#' in line:
+            line = line[:line.index('#')]
+        if '//' in line:
+            line = line[:line.index('//')]
+        lines.append(line)
+    return '\n'.join(lines)
+
+
+# =============================================================================
+# BYPASS CHECKS - Strictly Prohibited 
+# some of this is from Kevin RL Paper (arxiv:2507.11948)
+# =============================================================================
+
+# --- Try-Except Fallback ---
+# Rationale: Models wrap incomplete CUDA in exception handlers that fall back to PyTorch.
+# This allows them to pass tests without actually implementing the kernel.
+TRY_EXCEPT_PATTERNS = [r"\btry\s*:", r"\bexcept\s*:", r"\bexcept\s+\w+"]
+
+# --- Pass Statement / Inheritance Bypass ---
+# Rationale: Model inherits from reference class and uses 'pass' to do nothing,
+# effectively just calling the parent implementation.
+PASS_PATTERN = r"\bpass\b"
+
+def check_code_bypass(code: str) -> Tuple[bool, str]:
+    """
+    Check for code bypass patterns (strictly prohibited).
+    1. Try-Except Fallback: Models wrap incomplete CUDA in exception handlers
+       that fall back to PyTorch when custom code fails.
+    2. Pass Statement: Models inherit from reference and use 'pass' to do nothing,
+       effectively calling parent implementation.
+        Uses word boundary for 'pass' to avoid matching 'passed', 'bypass', etc.
+    """
+    code = _strip_comments(code)
+    
+    # Check for try-except fallback
+    for pattern in TRY_EXCEPT_PATTERNS:
+        if re.search(pattern, code):
+            return (True, "Contains try-except block (potential fallback bypass)")
+    
+    # Check for pass statement
+    if re.search(PASS_PATTERN, code):
+        return (True, "Contains 'pass' statement (inheritance bypass)")
+    
+    return (False, "")
+
+# Since KernelBench problems uses PyTorch as a reference, there could be settigs where
+# Model generated code
+# 1. Replaces some (not all) ops with custom kernels, others are kept in Torch
+# --> More practical from a performance perspective (ie. make better systems) as you want to use whatever makes the best system for your use case. 
+# 2. All compuational ops must be replaced with custom kernels
+# --> Could be helpful from an eval (model ability on transpile + optimization) / RL training perspective 
+# Depends the setting you use, you can move the checks below (pytorch_wrap, torch_computation_ops) 
+# from WARNING to STRICT
+
+# --- PyTorch NN Module Wrapping ---
+# Allows: nn.Module, nn.Parameter, nn.ParameterList, nn.ParameterDict, 
+#         nn.ModuleList, nn.ModuleDict, nn.init (needed for model structure)
+# Blocks: nn.Linear, nn.Conv2d, nn.ReLU, etc. (compute layers)
+PYTORCH_DISALLOWED_NN_PATTERN = r'torch\.nn\.(?!(Module|parameter|Parameter|ParameterList|ParameterDict|ModuleList|ModuleDict|init)\b)'
+
+def check_pytorch_wrap(code: str) -> Tuple[bool, str]:
+    """
+    Check for PyTorch nn module usage (nn.Linear, nn.Conv2d, etc.).
+    
+    Allows containers (nn.Module, nn.Parameter, nn.init) needed for model structure.
+    Blocks compute layers (nn.Linear, nn.Conv2d, nn.ReLU, etc.).
+    """
+    code = _strip_comments(code)
+    if re.search(PYTORCH_DISALLOWED_NN_PATTERN, code):
+        return (True, "Uses torch.nn compute layer (only containers, Parameter, init allowed)")
+    return (False, "")
+
+
+# --- Torch Computation Operations ---
+# Rationale: These are high-level PyTorch ops that conduct computation.
+# Using them directly defeats the purpose of writing custom kernels.
+# Includes both torch.* and F.* (torch.nn.functional) patterns.
+TORCH_COMPUTATION_OPS = [
+    # Matrix operations
+    "torch.mm", "torch.bmm", "torch.matmul", "torch.einsum",
+    # Convolutions
+    "torch.conv1d", "torch.conv2d", "torch.conv3d", "torch.conv",
+    "torch.conv_transpose1d", "torch.conv_transpose2d", "torch.conv_transpose3d",
+    # Pooling
+    "torch.avg_pool1d", "torch.avg_pool2d", "torch.avg_pool3d",
+    "torch.max_pool1d", "torch.max_pool2d", "torch.max_pool3d",
+    "torch.adaptive_avg_pool1d", "torch.adaptive_avg_pool2d", "torch.adaptive_avg_pool3d",
+    "torch.adaptive_max_pool1d", "torch.adaptive_max_pool2d", "torch.adaptive_max_pool3d",
+    # Activations
+    "torch.relu", "torch.hardtanh", "torch.elu", "torch.selu",
+    "torch.leaky_relu", "torch.gelu", "torch.softsign", "torch.softplus",
+    "torch.softmax", "torch.log_softmax", "torch.tanh", "torch.sigmoid",
+    "torch.hardsigmoid", "torch.silu", "torch.mish",
+    # Normalization
+    "torch.batch_norm", "torch.group_norm", "torch.layer_norm",
+    "torch.instance_norm", "torch.rms_norm", "torch.normalize",
+    # Linear & Loss
+    "torch.linear", "torch.cross_entropy", "torch.kl_div", "torch.mse_loss",
+    "torch.huber_loss", "torch.triplet_margin_loss", "torch.cosine_similarity",
+    # Others
+    "torch.logsumexp", "torch.clamp", "torch.dropout",
+]
+
+# F.* patterns (torch.nn.functional equivalents)
+TORCH_FUNCTIONAL_PATTERNS = [
+    r"torch\.nn\.functional\.\w+",       # torch.nn.functional.*
+    r"\bnn\.functional\.\w+",            # nn.functional.*
+    r"\bF\.(conv|linear|relu|gelu|softmax|batch_norm|layer_norm|dropout|max_pool|avg_pool)",
+]
+
+def check_torch_computation_ops(code: str) -> Tuple[bool, str]:
+    """
+    Check for high-level torch computation operations.
+    
+    Matches both torch.* ops (torch.matmul) and F.* ops (F.relu).
+    This check is optional/taste-based. Configure as needed.
+    """
+    code = _strip_comments(code)
+    
+    # Check torch.* ops
+    torch_pattern = r'\b(' + '|'.join(re.escape(f) for f in TORCH_COMPUTATION_OPS) + r')(?=\s*\(|\s|$)'
+    match = re.search(torch_pattern, code)
+    if match:
+        return (True, f"Uses torch computation op: {match.group(0)}")
+    
+    # Check F.* / nn.functional ops
+    for pattern in TORCH_FUNCTIONAL_PATTERNS:
+        match = re.search(pattern, code)
+        if match:
+            return (True, f"Uses torch.nn.functional op: {match.group(0)}")
+    
+    return (False, "")
+
+# =============================================================================
+# Backend Specific Checks
+# =============================================================================
+
+# <========= CUDA CHECKS =========>
+# Rationale: Valid CUDA kernels must have __global__ (kernel definition) and
+# use load_inline or cpp_extension (PyTorch's inline compilation).
+CUDA_COMPILE_PATTERNS = ["load_inline", "cpp_extension"]
+
+def check_cuda_impl(code: str) -> Tuple[bool, str]:
+    """
+    Check for valid CUDA kernel implementation.
+    
+    Requirements:
+    - Must have __global__ void kernel_name (kernel definition)
+    - Must have load_inline or cpp_extension (PyTorch inline compilation)
+    """
+    code = _strip_comments(code)
+    if "__global__" not in code:
+        return (True, "Missing __global__ kernel definition")
+    if not any(p in code for p in CUDA_COMPILE_PATTERNS):
+        return (True, "Missing load_inline or cpp_extension for compilation")
+    return (False, "")
+
+# <========= HIP CHECKS =========>
+# Rationale: Valid HIP kernels must have __global__ (kernel definition),
+# use load_inline or cpp_extension (PyTorch's inline compilation) and
+# use hipcc compiler
+HIP_COMPILE_PATTERNS = ["load_inline", "cpp_extension"]
+
+def check_hip_impl(code: str) -> Tuple[bool, str]:
+    """
+    Check for valid HIP kernel implementation.
+    
+    Requirements:
+    - Must have __global__ void kernel_name (kernel definition)
+    - Must have load_inline or cpp_extension (PyTorch inline compilation)
+    """
+    code = _strip_comments(code)
+    if "__global__" not in code:
+        return (True, "Missing __global__ kernel definition")
+    if not any(p in code for p in HIP_COMPILE_PATTERNS):
+        return (True, "Missing load_inline or cpp_extension for compilation")
+    if "hipcc" not in code:
+        return (True, "Missing hipcc compiler")
+    return (False, "")
+
+# <========= TRITON CHECKS =========>
+# Rationale: Triton kernels are compiled from @triton.jit decorated functions.
+# They must use tl.* operations (tl.load, tl.store, etc.) for actual kernel work.
+TRITON_JIT_PATTERN = r"@triton\.(jit|autotune)"
+TRITON_OPS_PATTERN = r"\btl\.\w+"
+
+def check_triton_impl(code: str) -> Tuple[bool, str]:
+    """
+    Check for valid Triton kernel implementation.
+    
+    Requirements:
+    - Must have @triton.jit or @triton.autotune decorator
+    - Must have tl.* operations (enforces actual Triton code, not wrapper)
+    
+    Note: Triton's compiler itself prevents PyTorch ops inside @triton.jit.
+    """
+    code = _strip_comments(code)
+    if not re.search(TRITON_JIT_PATTERN, code):
+        return (True, "Missing @triton.jit or @triton.autotune")
+    if not re.search(TRITON_OPS_PATTERN, code):
+        return (True, "No tl.* operations found in Triton kernel")
+    return (False, "")
+
+
+# <========= THUNDERKITTENS CHECKS =========>
+# Rationale: ThunderKittens uses warp/warpgroup primitives and tile abstractions.
+# Valid TK code must have namespace patterns and tile declarations.
+TK_WARP_PATTERNS = [
+    r"kittens::warp\b", r"kittens::warpgroup\b",
+    r"::warpgroup::", r"::warp::", r"warpgroup::", r"warp::"
+]
+TK_TILE_PATTERN = r"(?:kittens::)?(?:st|rt)_\w+\s*<[^>]+>"
+
+def check_tk_impl(code: str) -> Tuple[bool, str]:
+    """
+    Check for valid ThunderKittens kernel implementation.
+    
+    Requirements:
+    - Must have warp/warpgroup namespace patterns (kittens::warp, etc.)
+    - Must have tile declarations (st_bf<...>, rt_fl<...>, etc.)
+    
+    TODO: Add producer-consumer pattern check for complex kernels.
+    """
+    code = _strip_comments(code)
+    if not any(re.search(p, code) for p in TK_WARP_PATTERNS):
+        return (True, "Missing ThunderKittens warp/warpgroup patterns")
+    if not re.search(TK_TILE_PATTERN, code):
+        return (True, "Missing ThunderKittens tile declarations (st_*/rt_*)")
+    return (False, "")
+
+
+# <========= CUTE/CUTLASS CHECKS =========>
+# CUTLASS uses cute:: namespace for tensor operations
+# Check: https://github.com/NVIDIA/cutlass 
+CUTE_PATTERNS = [
+    r"cute::",           # cute:: namespace (CuTe library)
+    r"cutlass::",        # cutlass:: namespace
+    r"from cutlass",     # Python CUTLASS bindings
+]
+
+def check_cute_impl(code: str) -> Tuple[bool, str]:
+    """Check for valid CUTLASS/CuTe kernel implementation."""
+    code = _strip_comments(code)
+    if not any(p in code for p in ["cute::", "cutlass::", "from cutlass"]):
+        return (True, "Missing cute:: or cutlass:: namespace")
+    return (False, "")
+
+
+# <========= TILELANG CHECKS =========>
+# TileLang uses TVM's T.prim_func decorator
+# https://github.com/tile-ai/tilelang
+TILELANG_PATTERNS = [
+    r"@T\.prim_func",    # TVM primitive function decorator
+    r"tvm\.build",       # TVM build call
+    r"T\.grid",          # TileLang grid
+]
+
+def check_tilelang_impl(code: str) -> Tuple[bool, str]:
+    """Check for valid TileLang kernel implementation."""
+    code = _strip_comments(code)
+    if not re.search(r"@T\.prim_func", code):
+        return (True, "Missing @T.prim_func decorator")
+    return (False, "")
+
+
+# =============================================================================
+# TIMING MANIPULATION CHECKS - Reward Hacking Patterns
+# From adversarial hack PR and DeepReinforce blog
+# =============================================================================
+
+# <========= STREAM INJECTION CHECKS =========>
+# Rationale: Models may use CUDA streams to defer computation, manipulate timing,
+# or execute operations asynchronously to cheat benchmark measurements.
+STREAM_PATTERNS = [
+    r"torch\.cuda\.Stream\s*\(",       # torch.cuda.Stream()
+    r"cuda\.Stream\s*\(",               # cuda.Stream() (if imported)
+    r"with\s+torch\.cuda\.stream",      # with torch.cuda.stream(...)
+    r"\.wait_stream\s*\(",              # .wait_stream() method
+    r"\.record_stream\s*\(",            # .record_stream() method
+]
+
+def check_stream_injection(code: str) -> Tuple[bool, str]:
+    """
+    Check for CUDA stream injection patterns.
+    
+    Detects code that uses CUDA streams to potentially manipulate timing:
+    1. Stream creation: torch.cuda.Stream(), cuda.Stream()
+    2. Stream context managers: with torch.cuda.stream(...)
+    3. Stream synchronization: .wait_stream(), .record_stream()
+    
+    Rationale: Streams can defer computation or change execution order,
+    potentially affecting benchmark timing measurements.
+    """
+    code = _strip_comments(code)
+    
+    for pattern in STREAM_PATTERNS:
+        if re.search(pattern, code):
+            if "wait_stream" in pattern or "record_stream" in pattern:
+                return (True, "Uses stream synchronization (potential timing manipulation)")
+            elif "with" in pattern:
+                return (True, "Uses stream context manager (potential timing manipulation)")
+            else:
+                return (True, "Uses CUDA streams (potential timing manipulation)")
+    
+    return (False, "")
+
+
+# <========= THREAD INJECTION CHECKS =========>
+# Rationale: Models may use threading to parallelize work or manipulate execution
+# order in ways that could affect benchmark timing.
+THREAD_PATTERNS = [
+    r"threading\.Thread\s*\(",          # threading.Thread()
+    r"import\s+threading",              # import threading
+    r"from\s+threading\s+import",       # from threading import ...
+    r"multiprocessing\.(Process|Pool|Manager|Queue|Pipe)",
+    r"import\s+multiprocessing",        # import multiprocessing
+    r"concurrent\.futures",             # concurrent.futures (thread pools)
+    r"ThreadPoolExecutor",              # ThreadPoolExecutor
+    r"ProcessPoolExecutor",             # ProcessPoolExecutor
+]
+
+def check_thread_injection(code: str) -> Tuple[bool, str]:
+    """
+    Check for thread/multiprocessing injection patterns.
+    
+    Detects code that uses threading or multiprocessing:
+    1. Thread creation: threading.Thread()
+    2. Threading imports: import threading
+    3. Multiprocessing: Process, Pool, Manager, Queue, Pipe
+    4. Concurrent futures: ThreadPoolExecutor, ProcessPoolExecutor
+    
+    Rationale: Threading can defer computation or change execution order,
+    affecting timing measurements.
+    
+    Note: ProcessPoolExecutor might be legitimate in eval code but should
+    not appear in kernel implementations.
+    """
+    code = _strip_comments(code)
+    
+    for pattern in THREAD_PATTERNS:
+        if re.search(pattern, code):
+            if "multiprocessing" in pattern:
+                return (True, "Uses multiprocessing (potential timing manipulation)")
+            elif "concurrent" in pattern or "Executor" in pattern:
+                return (True, "Uses concurrent futures (potential timing manipulation)")
+            else:
+                return (True, "Uses threading (potential timing manipulation)")
+    
+    return (False, "")
+
+
+# <========= LAZY EVALUATION CHECKS =========>
+# Rationale: Models may create fake/lazy tensors that don't actually compute
+# anything, passing correctness checks without real implementation.
+LAZY_TENSOR_PATTERNS = [
+    r"_make_subclass",                  # torch.Tensor._make_subclass (common lazy hack)
+    r"class\s+\w+.*\(torch\.Tensor\)",  # Custom tensor subclasses
+    r"class\s+\w+.*\(Tensor\)",         # Custom tensor subclasses (imported Tensor)
+    r"torch\.Tensor\.__new__",          # Direct tensor construction (potential lazy)
+]
+
+def check_lazy_eval(code: str) -> Tuple[bool, str]:
+    """
+    Check for lazy tensor creation patterns.
+    
+    Detects patterns commonly used to create lazy/fake tensors:
+    1. _make_subclass: Common way to create custom tensor subclasses
+    2. Custom tensor subclasses: Classes inheriting from torch.Tensor
+    3. Direct tensor construction: torch.Tensor.__new__ manipulation
+    
+    Rationale: Lazy tensors can pass correctness checks without actually
+    computing anything, which is a form of reward hacking.
+    """
+    code = _strip_comments(code)
+    
+    for pattern in LAZY_TENSOR_PATTERNS:
+        if re.search(pattern, code):
+            if "_make_subclass" in pattern:
+                return (True, "Uses _make_subclass (potential lazy tensor hack)")
+            elif "class" in pattern:
+                return (True, "Defines custom tensor subclass (potential lazy tensor hack)")
+            else:
+                return (True, "Uses direct tensor construction (potential lazy tensor hack)")
+    
+    return (False, "")
+
+
+# <========= Timing Monkey Patch CHECKS =========>
+# Rationale: Models may monkey-patch torch timing functions to fake benchmark results.
+# This detects static patterns where timing functions are reassigned.
+# especially when relying on timing markers like cuda.Event or time.perf_counter.
+TIMING_EVENT_PATCH_PATTERNS = [
+    r"torch\.cuda\.Event\.record\s*=",      # torch.cuda.Event.record = ...
+    r"torch\.cuda\.Event\.elapsed_time\s*=", # torch.cuda.Event.elapsed_time = ...
+    r"torch\.cuda\.synchronize\s*=",         # torch.cuda.synchronize = ...
+    r"torch\.cuda\.Event\s*=",               # torch.cuda.Event = ... (replacing class)
+    r"time\.perf_counter\s*=",               # time.perf_counter = ...
+    r"time\.time\s*=",                       # time.time = ...
+]
+
+def check_timing_event_patch(code: str) -> Tuple[bool, str]:
+    """
+    Check for monkey patching of timing functions (static analysis).
+    
+    Detects code that reassigns torch or time functions used for benchmarking:
+    1. torch.cuda.Event.record = ...
+    2. torch.cuda.Event.elapsed_time = ...
+    3. torch.cuda.synchronize = ...
+    4. time.perf_counter = ...
+    
+    Rationale: Monkey patching timing functions can fake benchmark results,
+    making slow code appear fast.
+    """
+    code = _strip_comments(code)
+    
+    for pattern in TIMING_EVENT_PATCH_PATTERNS:
+        if re.search(pattern, code):
+            return (True, "Reassigns timing function (monkey patch detected)")
+    
+    return (False, "")
+
+
+# <========= PRECISION DOWNGRADE CHECKS =========>
+# Rationale: Models may downgrade precision internally (FP32 -> FP16)
+# to make kernels faster while still returning FP32 output. This is a reward
+# hacking pattern where models cheat on timing while appearing correct.
+# This might be a valid optimization, but is still worth flagging as a warning.
+#
+# We use explicit, high-confidence patterns that indicate intentional precision
+# downgrading. These patterns have minimal false positives and clear semantic intent.
+
+# Specific patterns that indicate FP32 -> FP16 precision downgrading
+FP32_TO_FP16_PATTERNS = [
+    # ========== CUDA / CUDA C++ ==========
+    # 1.1 Explicit float -> half intrinsics (⭐ gold standard)
+    # __float2half(f), __float2half_rn(f)
+    r"__float2half(_rn)?\s*\(",
+    
+    # 1.2 Explicit C-style cast to __half
+    # (__half)f
+    r"\(\s*__half\s*\)\s*[\w\->\.]+",
+    
+    # 1.3 static_cast<half> / static_cast<__half>
+    # static_cast<half>(f), static_cast<__half>(f)
+    r"static_cast\s*<\s*(__half|half)\s*>\s*\(",
+    
+    # ========== Triton (Python) ==========
+    # 2.1 Explicit tl.astype(..., tl.float16) (⭐ best signal)
+    # tl.astype(x, tl.float16)
+    r"tl\.astype\s*\(\s*[^,]+,\s*tl\.float16\s*\)",
+    
+    # ========== CUTLASS ==========
+    # 3.1 NumericConverter float -> half (⭐ extremely reliable)
+    # NumericConverter<half_t, float>
+    r"NumericConverter\s*<\s*half_t\s*,\s*float\s*>",
+    
+    # 3.2 Epilogue output type = FP16
+    # LinearCombination<half_t, ...>
+    r"LinearCombination\s*<\s*half_t",
+    
+    # ========== CUTE (when used directly) ==========
+    # 4.1 Explicit type conversion utility
+    # type_convert<half_t>(x)
+    r"type_convert\s*<\s*half_t\s*>\s*\(",
+    
+    # ========== ThunderKittens ==========
+    # 5.1 Explicit half types in cast contexts
+    # tk::half(x)
+    r"tk::half\s*\(",
+    
+    # ========== Additional gaping patterns ==========
+    # PyTorch explicit casts (common in inline CUDA contexts)
+    r"\.half\s*\(",                              # .half() -> FP16
+    r"\.float16\s*\(",                           # .float16() -> FP16
+    r"\.to\s*\(\s*torch\.(float16|half)\b",      # .to(torch.float16)
+    r"\.to\s*\(\s*dtype\s*=\s*torch\.(float16|half)\b",  # .to(dtype=torch.float16)
+]
+
+def check_precision_downgrade(code: str, precision: str = "fp32") -> Tuple[bool, str]:
+    """
+    Check for FP32 -> FP16 precision downgrading patterns in kernel code.
+    
+    Detects code that downgrades precision from FP32 to FP16 internally,
+    which can make kernels faster but with reduced precision. This is a reward
+    hacking pattern where models cheat on timing while appearing correct.
+    
+    Currently only checks for FP32 -> FP16 downgrades. Other precision combinations
+    (e.g., FP16 -> BF16) are not flagged.
+    
+    Args:
+        code: Kernel source code
+        precision: Required precision - only checks when "fp32" or "float32"
+    
+    Returns:
+        (True, error_message) if FP32 -> FP16 downgrade detected
+        (False, "") if no downgrade detected
+    
+    Examples of detected patterns:
+    - .half(), .float16()
+    - .to(torch.float16), .to(torch.half)
+    - dtype=torch.float16
+    - __half, half2 (CUDA)
+    - tl.float16 (Triton)
+    """
+    code = _strip_comments(code)
+    precision = precision.lower()
+    
+    # Normalize precision to standard form
+    precision_map = {"fp32": "fp32", "float32": "fp32", "fp16": "fp16", "bf16": "bf16", "bfloat16": "bf16"}
+    precision = precision_map.get(precision, precision)
+    
+    # Only check for FP32 -> FP16 downgrades
+    if precision != "fp32":
+        return (False, "")
+    
+    # Check for FP16 patterns
+    for pattern in FP32_TO_FP16_PATTERNS:
+        if re.search(pattern, code):
+            return (True, "Precision downgrade detected: required FP32 but code uses FP16")
+    
+    return (False, "")
+
+# =============================================================================
+# In the future, we can add a AST-based checker and a LM-as-a-judge checker
+# =============================================================================
+
+
+# =============================================================================
+# REGISTRY & PRESETS
+# =============================================================================
+
+# Check functions can take either (code) or (code, precision) arguments
+# Most checks take only code, but precision-dependent checks take both
+CHECK_FUNCTIONS: Dict[str, Union[Callable[[str], Tuple[bool, str]], Callable[[str, str], Tuple[bool, str]]]] = {
+    # Bypass checks (strict)
+    "code_bypass": check_code_bypass,
+    "pytorch_wrap": check_pytorch_wrap,
+    "timing_event_patch": check_timing_event_patch,  # clearly malicious
+    
+    # Torch ops (depends on your setups)
+    "torch_computation_ops": check_torch_computation_ops,
+    
+    # Timing manipulation checks (usually warnings)
+    "stream_injection": check_stream_injection,
+    "thread_injection": check_thread_injection,
+    "lazy_eval": check_lazy_eval,
+    "precision_downgrade": check_precision_downgrade,  # precision-dependent
+    
+    # Backend-specific implementation checks
+    # should be strict
+    "cuda_impl": check_cuda_impl,
+    "hip_impl": check_hip_impl,
+    "triton_impl": check_triton_impl,
+    "tk_impl": check_tk_impl,
+    "cute_impl": check_cute_impl,
+    "tilelang_impl": check_tilelang_impl,
+}
+
+# Checks that require additional parameters beyond just code
+PRECISION_DEPENDENT_CHECKS = {"precision_downgrade"}
+
+# Here are some presets for you to use
+# You are welcome to adapt them to your settings
+# These checks are NECESSARY for all kernels (strict = error)
+STRICT_CHECKS = [
+    "code_bypass",
+    "timing_event_patch",
+    "thread_injection",  
+    "lazy_eval",         
+]
+
+# Backend-specific checks are added later at entry point
+# per backend implementation check, usually strict
+BACKEND_IMPL_CHECK = {
+    "cuda": "cuda_impl",
+    "hip": "hip_impl",
+    "triton": "triton_impl",
+    "thunderkittens": "tk_impl",
+    "cute": "cute_impl",
+    "cutlass": "cute_impl",  # alias
+    "tilelang": "tilelang_impl",
+}
+
+# These are optional checks (by user's decision) - flagged as warnings
+# Move to STRICT_CHECKS if you want to enforce them
+WARNING_CHECKS: List[str] = [
+    # up to user to allow program to still have some torch computation ops
+    "pytorch_wrap",
+    "torch_computation_ops",  
+    "stream_injection",       # could have legitimate uses (async ops), but should be careful!
+    "precision_downgrade",    # precision downgrading - can be intentional but often a hack
+]
+
+
+# =============================================================================
+# MAIN ENTRY POINT
+# =============================================================================
+
+def validate_kernel_static(
+    code: str,
+    backend: str = "cuda",
+    precision: str = "fp16",
+    forbidden: Optional[List[str]] = None,
+    warnings: Optional[List[str]] = None,
+) -> Tuple[bool, List[str], List[str]]:
+    """
+    Validate kernel code through statically inspecting the code
+    We configure the checks against check groups that we have provided for common hacks.
+    Note we do not guarantee that all checks are exhaustive. This is also only on the static level.
+    
+    Args:
+        code: Kernel source code
+        backend: "cuda", "hip", "triton", or "thunderkittens"
+        precision: "fp16", "fp32", or "bf16" (for future precision checks)
+        forbidden: Check categories that cause errors (default: STRICT_CHECKS)
+        warnings: Check categories that cause warnings (default: WARNING_CHECKS)
+        
+    Returns:
+        (valid, errors, warnings)
+        valid: bool
+        errors: List[str]
+        warnings: List[str]
+    """
+    # Copy defaults to avoid mutating global lists
+    forbidden_checks = list(forbidden) if forbidden is not None else list(STRICT_CHECKS)
+    warning_checks = list(warnings) if warnings is not None else list(WARNING_CHECKS)
+    
+    # Add backend implementation check if specified
+    if backend in BACKEND_IMPL_CHECK:
+        impl_check = BACKEND_IMPL_CHECK[backend]
+        if impl_check not in forbidden_checks:
+            forbidden_checks.append(impl_check)
+    
+    # Aggregate results
+    errors: List[str] = []
+    warnings_list: List[str] = []
+    
+    for check_name in set(forbidden_checks + warning_checks):
+        if check_name not in CHECK_FUNCTIONS:
+            continue
+        
+        # Handle precision-dependent checks
+        if check_name in PRECISION_DEPENDENT_CHECKS:
+            has_issue, msg = CHECK_FUNCTIONS[check_name](code, precision)
+        else:
+            has_issue, msg = CHECK_FUNCTIONS[check_name](code)
+        
+        if has_issue:
+            if check_name in forbidden_checks:
+                errors.append(msg)
+            else:
+                warnings_list.append(msg)
+    
+    valid = len(errors) == 0 # valid if no errors
+    return valid, errors, warnings_list
diff --git a/src/make_hf_dataset.py b/src/kernelbench/make_hf_dataset.py
similarity index 100%
rename from src/make_hf_dataset.py
rename to src/kernelbench/make_hf_dataset.py
diff --git a/src/kernelbench/profile.py b/src/kernelbench/profile.py
new file mode 100644
index 00000000..a4960438
--- /dev/null
+++ b/src/kernelbench/profile.py
@@ -0,0 +1,445 @@
+"""
+Nsight Profiling Module for KernelBench
+========================================
+
+This module provides GPU profiling capabilities using NVIDIA Nsight Compute (ncu).
+It allows collecting hardware-level metrics from kernels.
+
+NOTE: this is an experimental module, not part of the default eval pass. 
+You need hardware counter access (usually requires sudo) to accesss hardware counter.
+We only support local mode with this feature, not avaliable on Modal.
+
+Key Features:
+- Profile arbitrary PyTorch functions with hardware metrics
+- Profile KernelBench models (ModelNew) with automatic setup/teardown
+- Combine metrics from multi-kernel operations (common in PyTorch)
+
+Requirements:
+- NVIDIA Nsight Compute CLI (ncu) must be installed and in PATH
+- nsight-python package
+
+Common Metrics:
+- gpu__time_duration.sum: Total GPU time in nanoseconds
+- sm__cycles_elapsed.sum: Total SM cycles elapsed
+- sm__cycles_active.avg: Average active cycles per SM
+
+Reference: https://docs.nvidia.com/nsight-python
+"""
+
+import os
+from shutil import which
+
+import torch
+
+# =============================================================================
+# Nsight Availability Check
+# =============================================================================
+
+try:
+    import nsight
+    NSIGHT_AVAILABLE = True
+except ImportError:
+    NSIGHT_AVAILABLE = False
+
+
+# =============================================================================
+# Utility Functions
+# =============================================================================
+
+def check_ncu_available() -> bool:
+    """
+    Check if NVIDIA Nsight Compute CLI (ncu) is available in PATH.
+    
+    The ncu command-line tool is required for collecting GPU hardware metrics.
+    It's typically installed with the CUDA Toolkit or NVIDIA Nsight Compute.
+    
+    Returns:
+        True if ncu is found in PATH, False otherwise.
+    """
+    return which('ncu') is not None
+
+
+# =============================================================================
+# Core Profiling Functions
+# =============================================================================
+
+def profile_with_nsight(func, metrics=None, num_trials=1):
+    """
+    Profile a PyTorch function and collect hardware metrics.
+    
+    Handles complexity:
+    - Setting up the Nsight kernel analyzer
+    - Combining metrics when PyTorch ops launch multiple CUDA kernels
+    - Extracting results from Nsight's DataFrame format
+    
+    Args:
+        func: A callable (no arguments) that executes the code to profile.
+              Typically a closure that captures the model and inputs.
+        metrics: List of Nsight metric names to collect. If None, defaults to
+                 ['sm__cycles_active.avg']. Can also pass a single string.
+        num_trials: Number of times to run the function for averaging.
+    
+    Returns:
+        Dictionary mapping metric names to their values (float).
+        Returns None for metrics that couldn't be collected.
+    
+    Example:
+        >>> def my_kernel():
+        ...     return torch.matmul(a, b)
+        >>> results = profile_with_nsight(my_kernel, ['gpu__time_duration.sum'])
+        >>> print(results['gpu__time_duration.sum'])  # Time in nanoseconds
+    
+    Raises:
+        RuntimeError: If nsight-python is not installed or not on NVIDIA GPU.
+    """
+    if not NSIGHT_AVAILABLE:
+        raise RuntimeError(
+            "nsight-python not available."
+        )
+    
+    # NSight is NVIDIA-only
+    from kernelbench.utils import get_gpu_vendor
+    if get_gpu_vendor() != "nvidia":
+        raise RuntimeError(
+            "NSight profiling requires NVIDIA GPU. Not available on AMD."
+        )
+    
+    # Normalize metrics to a list
+    if metrics is None:
+        metrics = ['sm__cycles_active.avg']
+    elif isinstance(metrics, str):
+        metrics = [metrics]
+    
+    # Define the profiled function with Nsight decorator
+    # NOTE: PyTorch operations often launch multiple CUDA kernels (e.g., a matmul
+    # might have separate kernels for the computation and memory operations).
+    # We use combine_kernel_metrics to sum these together for a single measurement.
+    @nsight.analyze.kernel(
+        metrics=metrics,
+        runs=num_trials,
+        configs=[(0,)],  # Use default GPU config
+        combine_kernel_metrics=lambda a, b: (0 if a is None else a) + (0 if b is None else b),
+    )
+    def profiled(_):
+        # The nsight.annotate context marks the region we care about
+        with nsight.annotate("kernel"):
+            return func()
+    
+    try:
+        # Run profiling - this invokes ncu under the hood
+        result = profiled()
+        
+        # Convert results to DataFrame
+        df = result.to_dataframe() if result else None
+        if df is None or df.empty:
+            return {m: None for m in metrics}
+        
+        # Nsight returns a DataFrame with columns like:
+        # - 'Metric': The metric name (e.g., 'gpu__time_duration.sum')
+        # - 'AvgValue': The measured value
+        # We need to find these columns (names may vary slightly)
+        metric_col = next((c for c in df.columns if c.lower() == 'metric'), None)
+        value_col = next((c for c in df.columns if 'value' in c.lower()), None)
+        
+        if not metric_col or not value_col:
+            return {m: None for m in metrics}
+        
+        # Build a dictionary of all metrics in the DataFrame
+        metric_dict = {
+            row[metric_col]: float(row[value_col]) 
+            for _, row in df.iterrows()
+        }
+        
+        # Return only the requested metrics (None if not found)
+        return {m: metric_dict.get(m) for m in metrics}
+        
+    except Exception as e:
+        print(f"Error profiling: {e}")
+        return {m: None for m in metrics}
+
+
+def profile_kernelbench_model_with_nsight(
+    custom_model_src: str,
+    ref_model_src: str = None,
+    metrics: list = None,
+    num_trials: int = 1,
+    seed: int = 42,
+    device: torch.device = None,
+    backend: str = "cuda",
+    precision: torch.dtype = torch.float32,
+    build_dir: str = None,
+    verbose: bool = False,
+) -> dict:
+    """
+    Profile a KernelBench model (ModelNew) using Nsight hardware metrics.
+    
+    This is the high-level profiling function designed for KernelBench workflows.
+    It handles the full lifecycle:
+    1. Load and compile the custom model from source code
+    2. Generate inputs using the model's get_inputs() function
+    3. Profile the forward pass with Nsight
+    4. Clean up resources
+    
+    IMPORTANT: This function assumes the model has already been validated for
+    correctness via eval. No correctness checking is performed here.
+    
+    Args:
+        custom_model_src: Python source code string containing the ModelNew class.
+        ref_model_src: Optional source code for the reference model. Used to get
+                       get_inputs() and get_init_inputs() if they're not in
+                       custom_model_src. If None, uses custom_model_src.
+        metrics: List of Nsight metrics to collect. Defaults to ['sm__cycles_active.avg'].
+        num_trials: Number of profiling runs for averaging. Default: 1.
+        seed: Random seed for reproducible input generation. Default: 42.
+        device: CUDA device to run on. Default: cuda:0.
+        backend: Compilation backend ('cuda', 'triton', 'tilelang', 'cute').
+        precision: torch.dtype for computation. Default: torch.float32.
+        build_dir: Directory for compiled kernel artifacts. Default: None.
+        verbose: Print progress messages. Default: False.
+    
+    Returns:
+        Dictionary mapping metric names to their measured values.
+        Values are None if the metric couldn't be collected.
+    
+    Example:
+        >>> results = profile_kernelbench_model_with_nsight(
+        ...     custom_model_src=my_model_code,
+        ...     ref_model_src=ref_model_code,
+        ...     metrics=['gpu__time_duration.sum', 'sm__cycles_elapsed.sum'],
+        ...     verbose=True
+        ... )
+        >>> print(f"GPU time: {results['gpu__time_duration.sum']} ns")
+    """
+    # Import eval utilities (deferred to avoid circular imports)
+    from kernelbench.eval import (
+        load_custom_model,
+        load_custom_model_with_tempfile,
+        load_original_model_and_inputs,
+        _process_input_tensor,
+        set_seed,
+        graceful_eval_cleanup,
+    )
+    
+    # Set defaults
+    device = device or torch.device("cuda:0")
+    if metrics is None:
+        metrics = ['sm__cycles_active.avg']
+    elif isinstance(metrics, str):
+        metrics = [metrics]
+    
+    torch.cuda.set_device(device)
+    
+    # -------------------------------------------------------------------------
+    # Step 1: Load input generation functions from model source
+    # -------------------------------------------------------------------------
+    # The model source should define get_inputs() and get_init_inputs() functions
+    # that return the tensors needed to run the model.
+    input_source = ref_model_src or custom_model_src
+    context = {}
+    _, get_init_inputs, get_inputs = load_original_model_and_inputs(input_source, context)
+    
+    # Generate initialization inputs (for model constructor)
+    set_seed(seed)
+    init_inputs = [
+        _process_input_tensor(x, device, backend, precision) 
+        for x in get_init_inputs()
+    ]
+    
+    # -------------------------------------------------------------------------
+    # Step 2: Load and compile the custom model
+    # -------------------------------------------------------------------------
+    if verbose:
+        print("[Profile] Loading and compiling custom model...")
+    
+    # Enable CUDA Device-Side Assertions for better error messages
+    os.environ["TORCH_USE_CUDA_DSA"] = "1"
+    tempfile = None
+    
+    # Different backends require different loading mechanisms
+    if backend.lower() in ["triton", "tilelang", "cute"]:
+        # These backends need a temp file for proper module loading
+        ModelNew, tempfile = load_custom_model_with_tempfile(
+            custom_model_src, entry_point="ModelNew"
+        )
+    else:
+        # Standard CUDA backend
+        ModelNew = load_custom_model(custom_model_src, {}, build_dir)
+    
+    torch.cuda.synchronize(device=device)
+    
+    # -------------------------------------------------------------------------
+    # Step 3: Instantiate the model
+    # -------------------------------------------------------------------------
+    with torch.no_grad():
+        set_seed(seed)
+        custom_model = ModelNew(*init_inputs)
+        custom_model = custom_model.to(device=device, dtype=precision)
+        torch.cuda.synchronize(device=device)
+    
+    if verbose:
+        print("[Profile] Model instantiated successfully")
+    
+    # -------------------------------------------------------------------------
+    # Step 4: Profile the forward pass
+    # -------------------------------------------------------------------------
+    # Generate forward pass inputs
+    set_seed(seed)
+    inputs = [
+        _process_input_tensor(x, device, backend, precision) 
+        for x in get_inputs()
+    ]
+    
+    if verbose:
+        print(f"[Profile] Profiling with nsight (metrics: {metrics})...")
+    
+    # Create a closure for the forward pass
+    def model_forward():
+        with torch.no_grad():
+            return custom_model(*inputs)
+    
+    # Run profiling
+    metric_values = profile_with_nsight(
+        model_forward, 
+        metrics=metrics, 
+        num_trials=num_trials
+    )
+    
+    if verbose:
+        print("[Profile] Profiling completed successfully")
+    
+    # -------------------------------------------------------------------------
+    # Step 5: Cleanup
+    # -------------------------------------------------------------------------
+    graceful_eval_cleanup(context, device, tempfile)
+    
+    return metric_values
+
+
+# =============================================================================
+# Examples and Tests
+# =============================================================================
+
+def example_ncu_python_profile():
+    """
+    Simple example demonstrating how to profile a basic matrix multiplication.
+    
+    This shows the minimal setup needed to use profile_with_nsight().
+    """
+    print("Creating test tensors...")
+    a = torch.randn(256, 256, device="cuda")
+    b = torch.randn(256, 256, device="cuda")
+    
+    # Create a closure that captures the tensors
+    def matmul_kernel():
+        return a @ b
+    
+    print("Running nsight profiling...")
+    
+    metric_values = profile_with_nsight(
+        matmul_kernel,
+        metrics=[
+            'sm__cycles_active.avg',           # Average active cycles per SM
+            'sm__cycles_elapsed.sum',          # Total cycles elapsed
+            'smsp__inst_executed_pipe_tensor_op_hmma.sum',  # Tensor core ops
+        ],
+        num_trials=1,
+    )
+    
+    print("\nProfiling results:")
+    for metric_name, value in metric_values.items():
+        print(f"  {metric_name}: {value}")
+
+
+def test_flash_attention_profile():
+    """
+    Test profiling a Flash Attention model from the KernelBench examples.
+    
+    This demonstrates the full workflow of profiling a KernelBench model
+    using profile_kernelbench_model_with_nsight().
+    """
+    from kernelbench.utils import read_file
+    
+    # Locate the example model files
+    REPO_ROOT = os.path.dirname(__file__)
+    ref_model_path = os.path.join(
+        REPO_ROOT, "prompts/few_shot/model_ex_flash_attn.py"
+    )
+    custom_model_path = os.path.join(
+        REPO_ROOT, "prompts/few_shot/model_new_ex_flash_attn.py"
+    )
+    
+    print("[Test] Reading model source files...")
+    ref_model_src = read_file(ref_model_path)
+    custom_model_src = read_file(custom_model_path)
+    
+    print("[Test] Starting profiling with nsight...")
+    
+    metrics = profile_kernelbench_model_with_nsight(
+        custom_model_src=custom_model_src,
+        ref_model_src=ref_model_src,
+        metrics=[
+            'gpu__time_duration.sum',   # Total GPU execution time (ns)
+            'sm__cycles_elapsed.sum',   # Total SM cycles
+        ],
+        seed=42,
+        backend="cuda",
+        precision=torch.float32,
+        verbose=True
+    )
+    
+    print("\n[Test] Profiling results:")
+    print("=" * 60)
+    for metric_name, value in metrics.items():
+        if value is not None:
+            print(f"  {metric_name}: {value:,.0f}")
+        else:
+            print(f"  {metric_name}: <not available>")
+    print("=" * 60)
+    
+    return metrics
+
+
+# Optional: Decorated benchmark function for direct use with nsight
+if NSIGHT_AVAILABLE:
+    @nsight.analyze.kernel
+    def benchmark_matmul(n):
+        """
+        Standard benchmark following nsight-python documentation style.
+        
+        This shows how to use the @nsight.analyze.kernel decorator directly
+        for simple benchmarking scenarios.
+        """
+        a = torch.randn(n, n, device="cuda")
+        b = torch.randn(n, n, device="cuda")
+        with nsight.annotate("matmul"):
+            c = a @ b
+        return c
+
+
+# =============================================================================
+# Main Entry Point
+# =============================================================================
+
+if __name__ == "__main__":
+    # Verify prerequisites
+    if not check_ncu_available():
+        print("ERROR: ncu not found in PATH.")
+        print("Install NVIDIA Nsight Compute from:")
+        print("  https://developer.nvidia.com/nsight-compute")
+        exit(1)
+    
+    if not torch.cuda.is_available():
+        print("ERROR: CUDA is not available.")
+        exit(1)
+    
+    print("=" * 60)
+    print("Running Nsight Profiling Examples")
+    print("=" * 60)
+    
+    # Run the simple example first
+    print("\n--- Example: Basic Matrix Multiplication ---\n")
+    example_ncu_python_profile()
+    
+    # Run the full KernelBench model test
+    print("\n--- Test: Flash Attention Model ---\n")
+    test_flash_attention_profile()
diff --git a/src/prompt_constructor_toml.py b/src/kernelbench/prompt_constructor_toml.py
similarity index 94%
rename from src/prompt_constructor_toml.py
rename to src/kernelbench/prompt_constructor_toml.py
index fc074494..4349a74d 100644
--- a/src/prompt_constructor_toml.py
+++ b/src/kernelbench/prompt_constructor_toml.py
@@ -5,7 +5,7 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 
-from src.utils import read_file 
+from kernelbench.utils import read_file, get_package_resource_path, resolve_path, REPO_TOP_PATH
 
 """
 TOML-based prompt constructor for managing prompt templates and configurations.
@@ -14,11 +14,9 @@
 You can easily check some of the prompt templates we have provided and create your own.
 """
 
-REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-PROMPTS_TOML = os.path.join(REPO_TOP_PATH, "src/prompts/prompts.toml")
-
-assert os.path.exists(PROMPTS_TOML), f"Prompts.toml not found at {PROMPTS_TOML}" 
-GPU_SPECS_PY = "src/prompts/hardware/gpu_specs.py"
+# Resolve paths using the helper from utils
+PROMPTS_TOML = get_package_resource_path("prompts/prompts.toml")
+GPU_SPECS_PY = get_package_resource_path("prompts/hardware/gpu_specs.py")
 HARDWARE_COMPONENT_KEYS = [
     "hardware_header",
     "hardware_specs",
@@ -26,12 +24,6 @@
     "hardware_best_practices",
 ]
 
-def _abs_path(rel: str) -> str:
-    """Convert relative path to absolute path from repo root."""
-    if os.path.isabs(rel):
-        return rel
-    return os.path.join(REPO_TOP_PATH, rel)
-
 @dataclass
 class PromptConfig:
     """
@@ -255,17 +247,17 @@ def render_example_entry(input_code: str, output_code: str, example_label: str)
                 # Use multiple examples (true few-shot)
                 examples_intro = intro_few_shot
                 for i, (input_path, output_path) in enumerate(few_shot_examples, 1):
-                    input_code = read_file(_abs_path(input_path))
-                    output_code = read_file(_abs_path(output_path))
+                    input_code = read_file(resolve_path(input_path))
+                    output_code = read_file(resolve_path(output_path))
                     examples_entries.append(
                         render_example_entry(input_code, output_code, f"Example {i}:")
                     )
             else:
                 # Fall back to one-shot
-                ex_arch_path = _abs_path(
+                ex_arch_path = resolve_path(
                     backend_data.get("few_shot_example_arch") or shared.get("few_shot_example_arch")
                 )
-                ex_new_path = _abs_path(backend_data["one_shot_new_arch"])
+                ex_new_path = resolve_path(backend_data["one_shot_new_arch"])
                 input_code = read_file(ex_arch_path)
                 output_code = read_file(ex_new_path)
                 examples_entries.append(
@@ -274,10 +266,10 @@ def render_example_entry(input_code: str, output_code: str, example_label: str)
 
         elif requires_example == "one_shot":
             # Always use one-shot
-            ex_arch_path = _abs_path(
+            ex_arch_path = resolve_path(
                 backend_data.get("few_shot_example_arch") or shared.get("few_shot_example_arch")
             )
-            ex_new_path = _abs_path(backend_data["one_shot_new_arch"])
+            ex_new_path = resolve_path(backend_data["one_shot_new_arch"])
             input_code = read_file(ex_arch_path)
             output_code = read_file(ex_new_path)
             examples_entries.append(
@@ -296,7 +288,7 @@ def render_example_entry(input_code: str, output_code: str, example_label: str)
             raise ValueError(
                 f"Hardware info requested for option '{option}'; provide gpu_specs_py and gpu_name"
             )
-        context = {**context, **_gpu_context_from_gpu_specs(_abs_path(gpu_specs_py), gpu_name)}
+        context = {**context, **_gpu_context_from_gpu_specs(resolve_path(gpu_specs_py), gpu_name)}
     
     # Builds the prompt from the components in the toml file. 
     prompt_parts = []
@@ -416,10 +408,10 @@ def test_prompt():
     generation. Customize the reference architecture or custom_prompt_key
     if you want to try different inputs.
     """
-    REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
     ref_arch_src = read_file(os.path.join(REPO_TOP_PATH, "KernelBench", "level1", "1_Square_matrix_multiplication_.py"))
     assert len(ref_arch_src) > 0, "ref_arch_src is empty"   
-    
+
+    print("Testing prompt construction...")
     scratch_dir = os.path.join(REPO_TOP_PATH, "scratch")
     # baseline prompt
     baseline_prompt = get_prompt_for_backend(
diff --git a/src/prompts/README.md b/src/kernelbench/prompts/README.md
similarity index 100%
rename from src/prompts/README.md
rename to src/kernelbench/prompts/README.md
diff --git a/src/prompts/cot/model_cot_fuse_gelu.py b/src/kernelbench/prompts/cot/model_cot_fuse_gelu.py
similarity index 100%
rename from src/prompts/cot/model_cot_fuse_gelu.py
rename to src/kernelbench/prompts/cot/model_cot_fuse_gelu.py
diff --git a/src/prompts/cot/model_cot_mnist2.py b/src/kernelbench/prompts/cot/model_cot_mnist2.py
similarity index 100%
rename from src/prompts/cot/model_cot_mnist2.py
rename to src/kernelbench/prompts/cot/model_cot_mnist2.py
diff --git a/src/prompts/cot/model_cot_tiled_matmul.py b/src/kernelbench/prompts/cot/model_cot_tiled_matmul.py
similarity index 100%
rename from src/prompts/cot/model_cot_tiled_matmul.py
rename to src/kernelbench/prompts/cot/model_cot_tiled_matmul.py
diff --git a/src/prompts/few_shot/model_ex_add.py b/src/kernelbench/prompts/few_shot/model_ex_add.py
similarity index 100%
rename from src/prompts/few_shot/model_ex_add.py
rename to src/kernelbench/prompts/few_shot/model_ex_add.py
diff --git a/src/prompts/few_shot/model_ex_flash_attn.py b/src/kernelbench/prompts/few_shot/model_ex_flash_attn.py
similarity index 100%
rename from src/prompts/few_shot/model_ex_flash_attn.py
rename to src/kernelbench/prompts/few_shot/model_ex_flash_attn.py
diff --git a/src/prompts/few_shot/model_ex_fuse_gelu.py b/src/kernelbench/prompts/few_shot/model_ex_fuse_gelu.py
similarity index 100%
rename from src/prompts/few_shot/model_ex_fuse_gelu.py
rename to src/kernelbench/prompts/few_shot/model_ex_fuse_gelu.py
diff --git a/src/prompts/few_shot/model_ex_mnist2.py b/src/kernelbench/prompts/few_shot/model_ex_mnist2.py
similarity index 100%
rename from src/prompts/few_shot/model_ex_mnist2.py
rename to src/kernelbench/prompts/few_shot/model_ex_mnist2.py
diff --git a/src/prompts/few_shot/model_ex_tiled_matmul.py b/src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py
similarity index 100%
rename from src/prompts/few_shot/model_ex_tiled_matmul.py
rename to src/kernelbench/prompts/few_shot/model_ex_tiled_matmul.py
diff --git a/src/prompts/few_shot/model_new_ex_add.py b/src/kernelbench/prompts/few_shot/model_new_ex_add.py
similarity index 100%
rename from src/prompts/few_shot/model_new_ex_add.py
rename to src/kernelbench/prompts/few_shot/model_new_ex_add.py
diff --git a/src/prompts/few_shot/model_new_ex_flash_attn.py b/src/kernelbench/prompts/few_shot/model_new_ex_flash_attn.py
similarity index 100%
rename from src/prompts/few_shot/model_new_ex_flash_attn.py
rename to src/kernelbench/prompts/few_shot/model_new_ex_flash_attn.py
diff --git a/src/prompts/few_shot/model_new_ex_fuse_gelu.py b/src/kernelbench/prompts/few_shot/model_new_ex_fuse_gelu.py
similarity index 100%
rename from src/prompts/few_shot/model_new_ex_fuse_gelu.py
rename to src/kernelbench/prompts/few_shot/model_new_ex_fuse_gelu.py
diff --git a/src/prompts/few_shot/model_new_ex_mnist2.py b/src/kernelbench/prompts/few_shot/model_new_ex_mnist2.py
similarity index 100%
rename from src/prompts/few_shot/model_new_ex_mnist2.py
rename to src/kernelbench/prompts/few_shot/model_new_ex_mnist2.py
diff --git a/src/prompts/few_shot/model_new_ex_tiled_matmul.py b/src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py
similarity index 100%
rename from src/prompts/few_shot/model_new_ex_tiled_matmul.py
rename to src/kernelbench/prompts/few_shot/model_new_ex_tiled_matmul.py
diff --git a/src/prompts/hardware/gpu_specs.py b/src/kernelbench/prompts/hardware/gpu_specs.py
similarity index 65%
rename from src/prompts/hardware/gpu_specs.py
rename to src/kernelbench/prompts/hardware/gpu_specs.py
index 800f20ef..7fde700e 100644
--- a/src/prompts/hardware/gpu_specs.py
+++ b/src/kernelbench/prompts/hardware/gpu_specs.py
@@ -118,6 +118,91 @@
         "Maximum number of thread blocks per SM": "32",
         "Shared memory capacity per SM": "164 KB",
         "Maximum shared memory per thread block": "163 KB",
+    },
+    # NOTE: In the future we will have a more unified format for various GPUs
+    "MI300X": {
+        "GPU Architecture": "gfx942",
+        "GPU Memory": "192GB",
+        "Memory Bandwidth": "5.3 TB/s",
+        "FP64 TFLOPS": "81.7",
+        "FP64 Matrix Core TFLOPS": "163.4",
+        "FP32 TFLOPS": "163.4",
+        "TF32 Matrix Core TFLOPS": "653.7 (1307.4 with sparsity)",
+        "BFLOAT16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)",
+        "FP16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)",
+        "FP8 Matrix Core TFLOPS": "2614.9 (5229.8 with sparsity)",
+        "INT8 Matrix Core TOPS": "2614.9 (5229.8 with sparsity)",
+        "Number of CU": "304",
+        "SIMDs per CU": "4",
+        "Wavefront Size": "64",
+        "Workgroup Max Size": "1024",
+        "Max Waves Per CU": "32",
+        "Max Threads per CU": "2048",
+        "Maximum number of registers per thread": "256",
+        "Shared memory capacity per CU": "64 KB",
+    },
+    "MI325X": {
+        "GPU Architecture": "gfx942",
+        "GPU Memory": "256GB",
+        "Memory Bandwidth": "6TB/s",
+        "FP64 TFLOPS": "81.7",
+        "FP64 Matrix Core TFLOPS": "163.4",
+        "FP32 TFLOPS": "163.4",
+        "TF32 Matrix Core TFLOPS": "653.7 (1307.4 with sparsity)",
+        "BFLOAT16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)",
+        "FP16 Matrix Core TFLOPS": "1307.4 (2614.9 with sparsity)",
+        "FP8 Matrix Core TFLOPS": "2614.9 (5229.8 with sparsity)",
+        "INT8 Matrix Core TOPS": "2614.9 (5229.8 with sparsity)",
+        "Number of CU": "304",
+        "SIMDs per CU": "4",
+        "Wavefront Size": "64",
+        "Workgroup Max Size": "1024",
+        "Max Waves Per CU": "32",
+        "Max Threads per CU": "2048",
+        "Maximum number of registers per thread": "256",
+        "Shared memory capacity per CU": "64 KB",
+    },
+    "MI350X": {
+        "GPU Architecture": "gfx950",
+        "GPU Memory": "288GB",
+        "Memory Bandwidth": "8TB/s",
+        "FP64 TFLOPS": "72.1",
+        "FP64 Matrix Core TFLOPS": "72.1",
+        "FP32 TFLOPS": "144.2",
+        "BFLOAT16 Matrix Core TFLOPS": "2300 (4600 with sparsity)",
+        "FP16 Matrix Core TFLOPS": "2300 (4600 with sparsity)",
+        "FP8 Matrix Core TFLOPS": "4600",
+        "MXFP6, MXFP4 Matrix Core TFLOPS": "9200",
+        "INT8 Matrix Core TOPS": "4600 (9200 with sparsity)",
+        "Number of CU": "256",
+        "SIMDs per CU": "4",
+        "Wavefront Size": "64",
+        "Workgroup Max Size": "1024",
+        "Max Waves Per CU": "32",
+        "Max Threads per CU": "2048",
+        "Maximum number of registers per thread": "256",
+        "Shared memory capacity per CU": "160 KB",
+    },
+    "MI355X": {
+        "GPU Architecture": "gfx950",
+        "GPU Memory": "288GB",
+        "Memory Bandwidth": "8TB/s",
+        "FP64 TFLOPS": "78.6",
+        "FP64 Matrix Core TFLOPS": "78.6",
+        "FP32 TFLOPS": "157.3",
+        "BFLOAT16 Matrix Core TFLOPS": "2500 (5000 with sparsity)",
+        "FP16 Matrix Core TFLOPS": "2500 (5000 with sparsity)",
+        "FP8 Matrix Core TFLOPS": "5000",
+        "MXFP6, MXFP4 Matrix Core TFLOPS": "10000",
+        "INT8 Matrix Core TOPS": "5000 (10000 with sparsity)",
+        "Number of CU": "256",
+        "SIMDs per CU": "4",
+        "Wavefront Size": "64",
+        "Workgroup Max Size": "1024",
+        "Max Waves Per CU": "32",
+        "Max Threads per CU": "2048",
+        "Maximum number of registers per thread": "256",
+        "Shared memory capacity per CU": "160 KB",
     }
 }
 
diff --git a/src/prompts/model_ex_0.py b/src/kernelbench/prompts/model_ex_0.py
similarity index 100%
rename from src/prompts/model_ex_0.py
rename to src/kernelbench/prompts/model_ex_0.py
diff --git a/src/prompts/model_ex_1.py b/src/kernelbench/prompts/model_ex_1.py
similarity index 100%
rename from src/prompts/model_ex_1.py
rename to src/kernelbench/prompts/model_ex_1.py
diff --git a/src/prompts/model_ex_2.py b/src/kernelbench/prompts/model_ex_2.py
similarity index 100%
rename from src/prompts/model_ex_2.py
rename to src/kernelbench/prompts/model_ex_2.py
diff --git a/src/prompts/model_ex_add.py b/src/kernelbench/prompts/model_ex_add.py
similarity index 100%
rename from src/prompts/model_ex_add.py
rename to src/kernelbench/prompts/model_ex_add.py
diff --git a/src/kernelbench/prompts/model_ex_add_thunderkittens.py b/src/kernelbench/prompts/model_ex_add_thunderkittens.py
new file mode 100644
index 00000000..8575537b
--- /dev/null
+++ b/src/kernelbench/prompts/model_ex_add_thunderkittens.py
@@ -0,0 +1,22 @@
+import torch
+import torch.nn as nn
+
+
+class Model(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def forward(self, a, b):
+        return a + b
+
+
+def get_inputs():
+    # Use shapes compatible with ThunderKittens 16x16 tiles, bf16 dtype
+    a = torch.randn(128, 128, dtype=torch.bfloat16).cuda()
+    b = torch.randn(128, 128, dtype=torch.bfloat16).cuda()
+    return [a, b]
+
+
+def get_init_inputs():
+    return []
+
diff --git a/src/prompts/model_new_ex_0.py b/src/kernelbench/prompts/model_new_ex_0.py
similarity index 100%
rename from src/prompts/model_new_ex_0.py
rename to src/kernelbench/prompts/model_new_ex_0.py
diff --git a/src/prompts/model_new_ex_1.py b/src/kernelbench/prompts/model_new_ex_1.py
similarity index 100%
rename from src/prompts/model_new_ex_1.py
rename to src/kernelbench/prompts/model_new_ex_1.py
diff --git a/src/prompts/model_new_ex_2.py b/src/kernelbench/prompts/model_new_ex_2.py
similarity index 100%
rename from src/prompts/model_new_ex_2.py
rename to src/kernelbench/prompts/model_new_ex_2.py
diff --git a/src/prompts/model_new_ex_add.py b/src/kernelbench/prompts/model_new_ex_add.py
similarity index 100%
rename from src/prompts/model_new_ex_add.py
rename to src/kernelbench/prompts/model_new_ex_add.py
diff --git a/src/prompts/model_new_ex_add_cute.py b/src/kernelbench/prompts/model_new_ex_add_cute.py
similarity index 100%
rename from src/prompts/model_new_ex_add_cute.py
rename to src/kernelbench/prompts/model_new_ex_add_cute.py
diff --git a/src/kernelbench/prompts/model_new_ex_add_hip.py b/src/kernelbench/prompts/model_new_ex_add_hip.py
new file mode 100644
index 00000000..806aa876
--- /dev/null
+++ b/src/kernelbench/prompts/model_new_ex_add_hip.py
@@ -0,0 +1,46 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.cpp_extension import load_inline
+
+# Must include this line so PyTorch could use HIP compiler for AMD GPUs
+os.environ["CXX"] = "hipcc"
+
+elementwise_add_cpp_source = """
+#include <hip/hip_runtime.h>
+
+__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < size) {
+        out[idx] = a[idx] + b[idx];
+    }
+}
+
+torch::Tensor elementwise_add_hip(torch::Tensor a, torch::Tensor b) {
+    auto size = a.numel();
+    auto out = torch::zeros_like(a);
+
+    const int block_size = 256;
+    const int num_blocks = (size + block_size - 1) / block_size;
+
+    elementwise_add_kernel<<<num_blocks, block_size>>>(a.data_ptr<float>(), b.data_ptr<float>(), out.data_ptr<float>(), size);
+
+    return out;
+}
+"""
+
+elementwise_add = load_inline(
+    name="elementwise_add",
+    cpp_sources=elementwise_add_cpp_source,
+    functions=["elementwise_add_hip"],
+    verbose=True,
+)
+
+class ModelNew(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.elementwise_add = elementwise_add
+
+    def forward(self, a, b):
+        return self.elementwise_add.elementwise_add_hip(a, b)
\ No newline at end of file
diff --git a/src/kernelbench/prompts/model_new_ex_add_thunderkittens.py b/src/kernelbench/prompts/model_new_ex_add_thunderkittens.py
new file mode 100644
index 00000000..33cc3ef9
--- /dev/null
+++ b/src/kernelbench/prompts/model_new_ex_add_thunderkittens.py
@@ -0,0 +1,122 @@
+import os
+import torch
+import torch.nn as nn
+from torch.utils.cpp_extension import load_inline
+
+tk_root = os.environ.get("THUNDERKITTENS_ROOT", "/root/ThunderKittens")
+tk_include_path = os.path.join(tk_root, "include")
+tk_prototype_path = os.path.join(tk_root, "prototype")
+
+extra_include_paths = [tk_root, tk_include_path]
+if os.path.isdir(tk_prototype_path):
+    extra_include_paths.append(tk_prototype_path)
+
+thunderkittens_add_source = """
+#include "kittens.cuh"
+#include <torch/extension.h>
+
+using namespace kittens;
+
+constexpr int BLOCK_SIZE = 16;
+
+#define NUM_WORKERS (1)
+#define NUM_THREADS (NUM_WORKERS * kittens::WARP_THREADS)
+
+struct add_globals {
+    using sub_tile = st_bf<BLOCK_SIZE, BLOCK_SIZE>;
+    using tile_gl = gl<bf16, 1, 1, -1, -1, sub_tile>;
+    tile_gl A;
+    tile_gl B;
+    tile_gl C;
+};
+
+__global__ void add_tk(const __grid_constant__ add_globals g) {
+    extern __shared__ alignment_dummy __shm[];
+    shared_allocator al((int*)&__shm[0]);
+    st_bf<BLOCK_SIZE, BLOCK_SIZE> &As = al.allocate<st_bf<BLOCK_SIZE, BLOCK_SIZE>>();
+    st_bf<BLOCK_SIZE, BLOCK_SIZE> &Bs = al.allocate<st_bf<BLOCK_SIZE, BLOCK_SIZE>>();
+    rt_bf<BLOCK_SIZE, BLOCK_SIZE> A_reg;
+    rt_bf<BLOCK_SIZE, BLOCK_SIZE> B_reg;
+    rt_bf<BLOCK_SIZE, BLOCK_SIZE> C_reg;
+    int col = blockIdx.x;
+    int row = blockIdx.y;
+    // Load A and B tiles from global to shared
+    kittens::warp::load(As, g.A, {0, 0, row, col});
+    kittens::warp::load(Bs, g.B, {0, 0, row, col});
+    __syncthreads();
+    // Load from shared to register
+    kittens::warp::load(A_reg, As);
+    kittens::warp::load(B_reg, Bs);
+    __syncthreads();
+    // Element-wise add: C = A + B
+    kittens::warp::add(C_reg, A_reg, B_reg);
+    __syncthreads();
+    // Store result back to global
+    kittens::warp::store(g.C, C_reg, {0, 0, row, col});
+}
+
+torch::Tensor thunderkittens_add_cuda(torch::Tensor A, torch::Tensor B) {
+    TORCH_CHECK(A.is_cuda(), "A must be a CUDA tensor");
+    TORCH_CHECK(B.is_cuda(), "B must be a CUDA tensor");
+    TORCH_CHECK(A.dtype() == torch::kBFloat16, "A must be bfloat16");
+    TORCH_CHECK(B.dtype() == torch::kBFloat16, "B must be bfloat16");
+    
+    int M = A.size(0);
+    int N = A.size(1);
+    
+    auto C = torch::empty_like(A);
+    
+    using tile_gl = add_globals::tile_gl;
+    tile_gl a_arg{(bf16*)A.data_ptr(), nullptr, nullptr, (size_t)M, (size_t)N};
+    tile_gl b_arg{(bf16*)B.data_ptr(), nullptr, nullptr, (size_t)M, (size_t)N};
+    tile_gl c_arg{(bf16*)C.data_ptr(), nullptr, nullptr, (size_t)M, (size_t)N};
+    add_globals g{a_arg, b_arg, c_arg};
+    
+    dim3 blocks((N + BLOCK_SIZE - 1) / BLOCK_SIZE, (M + BLOCK_SIZE - 1) / BLOCK_SIZE);
+    unsigned long mem_size = 50480;
+    cudaFuncSetAttribute(add_tk, cudaFuncAttributeMaxDynamicSharedMemorySize, mem_size);
+    add_tk<<<blocks, NUM_THREADS, mem_size>>>(g);
+    
+    return C;
+}
+"""
+
+thunderkittens_add_cpp_source = """
+torch::Tensor thunderkittens_add_cuda(torch::Tensor A, torch::Tensor B);
+"""
+
+thunderkittens_add = load_inline(
+    name="thunderkittens_add",
+    cpp_sources=thunderkittens_add_cpp_source,
+    cuda_sources=thunderkittens_add_source,
+    functions=["thunderkittens_add_cuda"],
+    verbose=True,
+    extra_include_paths=extra_include_paths,
+    extra_cflags=["-std=c++20", "-O3", "-DNDEBUG"],
+    extra_ldflags=["-lcuda"],
+    extra_cuda_cflags=[
+        "-std=c++20",
+        "-O3",
+        "-DNDEBUG",
+        "-arch=sm_90a",
+        "--expt-relaxed-constexpr",
+        "--expt-extended-lambda",
+        "-DKITTENS_HOPPER",
+        "-DKITTENS_BLACKWELL",
+        "-diag-suppress=20012",
+        "-Xcompiler", "-fPIC",
+        "-U__CUDA_NO_HALF_OPERATORS__",
+        "-U__CUDA_NO_HALF_CONVERSIONS__",
+        "-U__CUDA_NO_BFLOAT16_CONVERSIONS__",
+        "-U__CUDA_NO_HALF2_OPERATORS__",
+    ],
+)
+
+
+class ModelNew(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.thunderkittens_add = thunderkittens_add
+
+    def forward(self, a, b):
+        return self.thunderkittens_add.thunderkittens_add_cuda(a, b)
diff --git a/src/prompts/model_new_ex_add_tilelang.py b/src/kernelbench/prompts/model_new_ex_add_tilelang.py
similarity index 100%
rename from src/prompts/model_new_ex_add_tilelang.py
rename to src/kernelbench/prompts/model_new_ex_add_tilelang.py
diff --git a/src/prompts/model_new_ex_add_triton.py b/src/kernelbench/prompts/model_new_ex_add_triton.py
similarity index 100%
rename from src/prompts/model_new_ex_add_triton.py
rename to src/kernelbench/prompts/model_new_ex_add_triton.py
diff --git a/src/prompts/prompts.toml b/src/kernelbench/prompts/prompts.toml
similarity index 86%
rename from src/prompts/prompts.toml
rename to src/kernelbench/prompts/prompts.toml
index bcf4e4ed..6a7dfcaa 100644
--- a/src/prompts/prompts.toml
+++ b/src/kernelbench/prompts/prompts.toml
@@ -18,7 +18,7 @@ Optimize the architecture named Model with custom {backend_display}! Name your o
 """
 
 # Shared example architecture (same for all backends)
-few_shot_example_arch = "src/prompts/model_ex_add.py"
+few_shot_example_arch = "src/kernelbench/prompts/model_ex_add.py"
 
 # -------------------------------------------------------------------------
 # Backends: Backend-specific configuration (minimal, just what varies)
@@ -26,27 +26,37 @@ few_shot_example_arch = "src/prompts/model_ex_add.py"
 [backends.cuda]
 backend_display = "CUDA operators"
 # One-shot example (baseline, always available)
-one_shot_new_arch = "src/prompts/model_new_ex_add.py"
+one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add.py"
 # Few-shot examples (optional, multiple example pairs)
 few_shot_examples = [
-    ["src/prompts/few_shot/model_ex_add.py", "src/prompts/few_shot/model_new_ex_add.py"],
-    ["src/prompts/few_shot/model_ex_fuse_gelu.py", "src/prompts/few_shot/model_new_ex_fuse_gelu.py"],
-    ["src/prompts/few_shot/model_ex_flash_attn.py", "src/prompts/few_shot/model_new_ex_flash_attn.py"],
+    ["src/kernelbench/prompts/few_shot/model_ex_add.py", "src/kernelbench/prompts/few_shot/model_new_ex_add.py"],
+    ["src/kernelbench/prompts/few_shot/model_ex_fuse_gelu.py", "src/kernelbench/prompts/few_shot/model_new_ex_fuse_gelu.py"],
+    ["src/kernelbench/prompts/few_shot/model_ex_flash_attn.py", "src/kernelbench/prompts/few_shot/model_new_ex_flash_attn.py"],
 ]
 
 [backends.triton]
 backend_display = "Triton kernels"
-one_shot_new_arch = "src/prompts/model_new_ex_add_triton.py"
+one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_triton.py"
 # No few_shot_examples - will use one-shot when few_shot option is selected
 
 [backends.cute]
 backend_display = "CuTe (CUTLASS) kernels"
-one_shot_new_arch = "src/prompts/model_new_ex_add_cute.py"
+one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_cute.py"
 # No few_shot_examples - will use one-shot when few_shot option is selected
 
 [backends.tilelang]
 backend_display = "TileLang kernels"
-one_shot_new_arch = "src/prompts/model_new_ex_add_tilelang.py"
+one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_tilelang.py"
+# No few_shot_examples - will use one-shot when few_shot option is selected
+
+[backends.thunderkittens]
+backend_display = "ThunderKittens kernels"
+one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_thunderkittens.py"
+# No few_shot_examples - will use one-shot when few_shot option is selected
+
+[backends.hip]
+backend_display = "AMD HIP kernels"
+one_shot_new_arch = "src/kernelbench/prompts/model_new_ex_add_hip.py"
 # No few_shot_examples - will use one-shot when few_shot option is selected
 
 # -------------------------------------------------------------------------
diff --git a/src/score.py b/src/kernelbench/score.py
similarity index 100%
rename from src/score.py
rename to src/kernelbench/score.py
diff --git a/src/timing.py b/src/kernelbench/timing.py
similarity index 68%
rename from src/timing.py
rename to src/kernelbench/timing.py
index 8a36522b..f22920b4 100644
--- a/src/timing.py
+++ b/src/kernelbench/timing.py
@@ -2,13 +2,118 @@
 import json
 import numpy as np
 import time
-from typing import Any
+from typing import Any, Optional, Union
 import os
 
 
-# we leverage triton's testing functionality for some timing methods
-from triton import runtime as triton_runtime
-from triton import testing as triton_testing    
+def measure_ref_program_time(
+    ref_arch_name: str,
+    ref_arch_src: str, # PyTorch program code string
+    num_warmup: int = 5,
+    num_trials: int = 100,
+    discard_first: int = 1,
+    timing_method: str = "cuda_event",
+    # Torch eager or torch.compile configuration
+    use_torch_compile: bool = False,
+    torch_compile_backend: str = "inductor",
+    torch_compile_options: str = "default",
+    device: torch.device = torch.device("cuda:0"),
+    verbose: bool = False,
+    precision: Union[str, torch.dtype] = "fp32", # fp16, fp32, bf16 or torch.dtype
+) -> dict:
+    """Measure the runtime of a KernelBench *reference* program.
+
+    This measures the execution time of the reference `Model` defined in
+    `ref_arch_src` (i.e., *not* `ModelNew`). It can optionally run the reference
+    model under `torch.compile`.
+
+    NOTE: This function is for PyTorch-only reference models, so no `backend` parameter is needed.
+    For pure PyTorch program, we assume it operates all on main stream (as torch operators execute on the default cuda stream).
+    Standard PyTorch ops do NOT spawn extra streams.
+    """
+    from kernelbench.eval import load_original_model_and_inputs, set_seed
+
+    context = {}
+    Model, get_init_inputs, get_inputs = load_original_model_and_inputs(
+        ref_arch_src, context
+    )
+
+    try:
+        with torch.no_grad():
+            if isinstance(device, str):
+                device = torch.device(device)
+            elif isinstance(device, int):
+                device = torch.device(f"cuda:{device}")
+            torch.cuda.set_device(device)
+
+            torch.cuda.synchronize(device=device)
+            set_seed(42)
+            inputs = get_inputs()
+            set_seed(42)
+            init_inputs = get_init_inputs()
+
+            from kernelbench.eval import get_torch_dtype_from_string
+            if isinstance(precision, str):
+                precision_dtype = get_torch_dtype_from_string(precision)
+            else:
+                precision_dtype = precision
+
+
+            # set model weights and inputs to specified precision
+            inputs = [
+                x.to(device=device, dtype=precision_dtype) if isinstance(x, torch.Tensor) else x
+                for x in inputs
+            ]
+            init_inputs = [
+                x.to(device=device, dtype=precision_dtype) if isinstance(x, torch.Tensor) else x
+                for x in init_inputs
+            ]
+
+            model = Model(*init_inputs)
+            model = model.to(device=device, dtype=precision_dtype)
+
+            # convert all precision so torch compile can target specific dtype
+            if use_torch_compile:
+                torch._dynamo.reset() # reset torch dynamo cache (clear memory and reset graph)
+                print(
+                    f"Using torch.compile to compile model {ref_arch_name} with {torch_compile_backend} backend and {torch_compile_options} mode"
+                )
+                # NOTE: torch compile uses lazy compilation (triggered by first forward pass)
+                # the warmup in the timing function handles that and should not affect timed trials
+                model = torch.compile(
+                    model,
+                    backend=torch_compile_backend,
+                    mode=torch_compile_options,
+                )
+            else:
+                print(f"Using PyTorch Eager Execution on {ref_arch_name}")
+
+            torch.cuda.synchronize(device=device)
+
+            timing_fn = get_timing_function(timing_method)
+            elapsed_times = timing_fn(
+                model,
+                inputs,
+                num_warmup=num_warmup,
+                num_trials=num_trials,
+                discard_first=discard_first,
+                verbose=verbose,
+                device=device,
+            )
+            runtime_stats = get_timing_stats(elapsed_times, device=device)
+
+            if verbose:
+                print(f"{ref_arch_name} {runtime_stats}")
+
+            return runtime_stats
+    except Exception as e:
+        print(f"[Eval] Error in Measuring Performance: {e}")
+        return None
+
+
+def measure_program_time(*args, **kwargs):
+    """Alias for backwards compatibility. See `measure_ref_program_time`."""
+    return measure_ref_program_time(*args, **kwargs)
 
 ################################################################################
 # timing.py
@@ -40,6 +145,7 @@ def clear_l2_cache_triton(cache=None, device: str = "cuda"):
     """
     Thrash the cache by making a large dummy tensor, using triton runtime's functionality
     """
+    from triton import runtime as triton_runtime
     with torch.cuda.device(device):
         cache = triton_runtime.driver.active.get_empty_cache_for_benchmark()
         # this effectively thrashes L2 cache under the hood too
@@ -81,6 +187,8 @@ def get_timing_function(
             return time_execution_with_do_bench_impl
         case "host_time":
             return time_execution_with_host_time 
+        case "nsight_python_time":
+            return time_execution_with_nsight_python
         # we might add other methods in the future
         case _: 
             raise ValueError(f"Unsupported timing method: {method}")
@@ -90,7 +198,6 @@ def get_timing_function(
 NOTE: we have a WIP blogpost on this topic covering the various timing approaches   
 """
 
-
 def time_execution_with_cuda_event(
     kernel_fn: callable,
     args: list[Any],
@@ -212,6 +319,7 @@ def time_execution_with_do_bench_interface(
         device = torch.cuda.current_device()
 
 
+    from triton import testing as triton_testing
     do_bench_fn = lambda : kernel_fn(*args) # wrap function with arguments
     with torch.cuda.device(device):
         return triton_testing.do_bench(fn=do_bench_fn,
@@ -253,6 +361,7 @@ def time_execution_with_do_bench_impl(
         List of elapsed times in milliseconds (length = num_trials)
     """
 
+    from triton import runtime as triton_runtime
     device = device if device is not None else torch.cuda.current_device()
     if verbose: 
         print(f"Using do_bench to evaluate kernel on {device}")
@@ -390,13 +499,86 @@ def time_execution_with_host_time(
 
     return elapsed_times
 
+def time_execution_with_nsight_python(
+    kernel_fn: callable,
+    args: list[Any],
+    num_warmup: int = 3,
+    num_trials: int = 10,
+    discard_first: int = 1, # not used here
+    verbose: bool = True,
+    device: torch.device | None = None) -> list[float]:
+    """
+    Time a CUDA kernel function using nsight-python.
+    
+    NOTE: NVIDIA-only. NSight Compute (ncu) does not work on AMD GPUs.
+    
+    Returns a list with a single value (average time) for API consistency.
+    GPU time from nsight is in nanoseconds, converted to milliseconds.
+    """
+    from kernelbench.profile import profile_with_nsight
+    from kernelbench.utils import get_gpu_vendor
+    
+    if device is None:
+        if verbose:
+            print(f"Using current device: {torch.cuda.current_device()}")
+        device = torch.cuda.current_device()
+    
+    # NSight is NVIDIA-only
+    if get_gpu_vendor(device) != "nvidia":
+        raise RuntimeError(
+            "NSight profiling requires NVIDIA GPU. "
+            "Use timing_method='cuda_event' or 'do_bench' for AMD."
+        )
+
+    with torch.cuda.device(device):
+        # Warm ups
+        for _ in range(num_warmup):
+            kernel_fn(*args)
+            torch.cuda.synchronize(device=device)
+        
+        # Clear cache for cold start
+        torch.cuda.empty_cache()
+        clear_l2_cache(device=device)
+        
+        if verbose:
+            print(f"[Profiling] Using device: {device} {torch.cuda.get_device_name(device)}, warm up {num_warmup}, trials {num_trials}")
+        
+        # Profile with nsight - returns average time in nanoseconds
+        # Wrap kernel function
+        def wrapped_kernel():
+            return kernel_fn(*args)
+        
+        # Profile with nsight, use gpu_time_duration.sum metric for GPU time
+        metric_values = profile_with_nsight(
+            wrapped_kernel,
+            metrics=["gpu__time_duration.sum"],
+            num_trials=num_trials
+        )
+        
+        # Convert from nanoseconds to milliseconds
+        gpu_time_ns = metric_values.get("gpu__time_duration.sum")
+        if gpu_time_ns is None:
+            raise RuntimeError("Failed to get GPU time from nsight")
+        
+        # Convert nanoseconds to milliseconds
+        # nsight returns average across num_trials, so we return a single value in a list
+        gpu_time_ms = gpu_time_ns / 1_000_000.0
+        
+        if verbose:
+            print(f"Average GPU time: {gpu_time_ms:.3f} ms (across {num_trials} trials)")
+        
+        # NOTE: nsight only returns average time across num_trials, so we return a single value in a list
+        # it did run num_trials times, but we only return the average (1 item)
+        # Return list with single average value for API consistency
+        return [gpu_time_ms]
+
 ########################################################
 # Timing stats
 # tools to help compute speedup and other time
 #########################################################
 def fetch_baseline_time(
-    level_name: str, problem_id: int, dataset: list[str], baseline_time_filepath: str
-) -> dict:
+    level_name: str, problem_id: int, dataset: "BaseDataset", baseline_time_filepath: str
+) -> Optional[float]:
     """
     Fetch the baseline time from the time
 
@@ -411,8 +593,8 @@ def fetch_baseline_time(
     with open(baseline_time_filepath, "r") as f:
         baseline_json = json.load(f)
 
-    # TODO: replace with the new Dataset object that Omar will merge in
-    problem_name = dataset[problem_id].split("/")[-1]
+    problem = dataset.get_problem_by_id(problem_id)
+    problem_name = problem.name
     baseline_time = baseline_json[level_name].get(problem_name, None)
     return baseline_time
 
@@ -441,3 +623,4 @@ def get_timing_stats(elapsed_times: list[float], device: torch.device = None) ->
         stats["device"] = str(device)  # for debugging
 
     return stats
+
diff --git a/src/kernelbench/unit_tests/test_dataset.py b/src/kernelbench/unit_tests/test_dataset.py
new file mode 100644
index 00000000..b8468503
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_dataset.py
@@ -0,0 +1,331 @@
+"""
+Unit tests for the KernelBench dataset module.
+
+Usage:
+    pytest src/kernelbench/unit_tests/test_dataset.py -v
+"""
+
+import pytest
+from kernelbench.dataset import (
+    get_code_hash,
+    construct_kernelbench_dataset,
+    fetch_ref_arch_from_dataset,
+    Problem,
+    BaseDataset,
+    LocalKernelBenchDataset,
+    LEVEL1_REPRESENTATIVE_IDS,
+)
+
+
+################################################################################
+# Hash Tests
+################################################################################
+
+def test_get_code_hash_ignores_comments():
+    """Hash should be equal for semantically equivalent code with different comments."""
+    code_v1 = """
+    import torch 
+    # This is for a single batch
+    '''
+    Some random multi-line comment
+    '''
+    B = 1
+    """
+    
+    code_v2 = """
+    import torch 
+    '''
+    More problem descriptions (updated)
+    '''
+    # low batch setting
+
+    B = 1
+    """
+    
+    assert get_code_hash(code_v1) == get_code_hash(code_v2)
+
+
+def test_get_code_hash_different_for_different_code():
+    """Hash should differ for code with actual differences."""
+    code_batch_1 = """
+    import torch 
+    B = 1
+    """
+    
+    code_batch_64 = """
+    import torch 
+    B = 64
+    """
+    
+    assert get_code_hash(code_batch_1) != get_code_hash(code_batch_64)
+
+
+################################################################################
+# Dataset Construction Tests
+################################################################################
+
+def test_construct_local_dataset():
+    """Test constructing a local dataset."""
+    dataset = construct_kernelbench_dataset(level=1, source="local")
+    
+    assert isinstance(dataset, BaseDataset)
+    assert isinstance(dataset, LocalKernelBenchDataset)
+    assert dataset.level == 1
+    assert len(dataset) > 0
+
+
+def test_construct_dataset_invalid_level():
+    """Test that invalid level raises ValueError."""
+    with pytest.raises(ValueError):
+        construct_kernelbench_dataset(level=0, source="local")
+    
+    with pytest.raises(ValueError):
+        construct_kernelbench_dataset(level=-1, source="local")
+
+
+def test_construct_dataset_invalid_source():
+    """Test that invalid source raises ValueError."""
+    with pytest.raises(ValueError):
+        construct_kernelbench_dataset(level=1, source="invalid")
+
+
+################################################################################
+# Problem Access Tests
+################################################################################
+
+def test_get_problem_by_id():
+    """Test getting a problem by its logical ID."""
+    dataset = construct_kernelbench_dataset(level=1)
+    
+    problem = dataset.get_problem_by_id(1)
+    
+    assert isinstance(problem, Problem)
+    assert problem.problem_id == 1
+    assert problem.name.startswith("1_")
+    assert problem.level == 1
+    assert len(problem.code) > 0
+    assert problem.path is not None
+
+
+def test_get_problem_by_id_not_found():
+    """Test that non-existent ID raises ValueError."""
+    dataset = construct_kernelbench_dataset(level=1)
+    
+    with pytest.raises(ValueError, match="not found"):
+        dataset.get_problem_by_id(9999)
+
+
+def test_get_problem_ids():
+    """Test getting list of all problem IDs."""
+    dataset = construct_kernelbench_dataset(level=1)
+    
+    ids = dataset.get_problem_ids()
+    
+    assert isinstance(ids, list)
+    assert len(ids) > 0
+    assert ids == sorted(ids)  # should be sorted
+    assert 1 in ids
+
+
+def test_problem_hash():
+    """Test that Problem.hash property works."""
+    dataset = construct_kernelbench_dataset(level=1)
+    problem = dataset.get_problem_by_id(1)
+    
+    hash_value = problem.hash
+    
+    assert isinstance(hash_value, str)
+    assert len(hash_value) == 32  # MD5 hex digest length
+
+
+################################################################################
+# Subset Tests
+################################################################################
+
+def test_subset_by_ids():
+    """Test creating a subset by specific problem IDs."""
+    dataset = construct_kernelbench_dataset(level=1)
+    subset = dataset.subset(problem_ids=[1, 3, 5])
+    
+    assert len(subset) == 3
+    assert subset.get_problem_ids() == [1, 3, 5]
+
+
+def test_subset_by_range():
+    """Test creating a subset by ID range."""
+    dataset = construct_kernelbench_dataset(level=1)
+    subset = dataset.subset(id_range=(1, 5))
+    
+    assert len(subset) == 5
+    assert subset.get_problem_ids() == [1, 2, 3, 4, 5]
+
+
+def test_sample_random():
+    """Test random sampling from dataset."""
+    dataset = construct_kernelbench_dataset(level=1)
+    
+    sample1 = dataset.sample(n=5, seed=42)
+    sample2 = dataset.sample(n=5, seed=42)
+    sample3 = dataset.sample(n=5, seed=123)
+    
+    assert len(sample1) == 5
+    assert sample1.get_problem_ids() == sample2.get_problem_ids()  # same seed
+    assert sample1.get_problem_ids() != sample3.get_problem_ids()  # different seed
+
+
+def test_get_representative_subset():
+    """Test getting the representative subset."""
+    dataset = construct_kernelbench_dataset(level=1)
+    rep = dataset.get_representative_subset()
+    
+    assert len(rep) == len(LEVEL1_REPRESENTATIVE_IDS)
+    assert rep.get_problem_ids() == LEVEL1_REPRESENTATIVE_IDS
+
+
+################################################################################
+# Iterator Tests
+################################################################################
+
+def test_dataset_iteration():
+    """Test iterating over dataset."""
+    dataset = construct_kernelbench_dataset(level=1, problem_ids=[1, 2, 3])
+    
+    problems = list(dataset)
+    
+    assert len(problems) == 3
+    assert all(isinstance(p, Problem) for p in problems)
+    assert [p.problem_id for p in problems] == [1, 2, 3]
+
+
+
+def test_dataset_len():
+    """Test len() on dataset."""
+    dataset = construct_kernelbench_dataset(level=1, problem_ids=[1, 2, 3])
+    assert len(dataset) == 3
+
+
+################################################################################
+# Compatibility Tests
+################################################################################
+
+def test_fetch_ref_arch_from_dataset():
+    """Test the backward-compatible fetch function."""
+    dataset = construct_kernelbench_dataset(level=1)
+    
+    path, name, code = fetch_ref_arch_from_dataset(dataset, problem_id=1)
+    
+    assert path is not None
+    assert name.startswith("1_")
+    assert len(code) > 0
+    
+    # Should match direct problem access
+    problem = dataset.get_problem_by_id(1)
+    assert path == problem.path
+    assert name == problem.name
+    assert code == problem.code
+
+
+################################################################################
+# Multiple Levels Tests
+################################################################################
+
+def test_all_levels_load():
+    """Test that all standard levels can be loaded."""
+    for level in [1, 2, 3]:
+        dataset = construct_kernelbench_dataset(level=level)
+        assert len(dataset) > 0
+        assert dataset.level == level
+
+
+################################################################################
+# HuggingFace Tests (requires network)
+################################################################################
+
+@pytest.mark.slow
+def test_huggingface_dataset_loads():
+    """Test that HuggingFace dataset can be loaded."""
+    dataset = construct_kernelbench_dataset(level=1, source="huggingface")
+    
+    assert len(dataset) > 0
+    assert dataset.level == 1
+    
+    problem = dataset.get_problem_by_id(1)
+    assert problem.problem_id == 1
+    assert problem.name.startswith("1_")
+    assert len(problem.code) > 0
+    assert problem.path is None  # HF has no local path
+
+
+@pytest.mark.slow
+def test_local_and_huggingface_parity():
+    """Test that local and HuggingFace datasets have the same content."""
+    local_ds = construct_kernelbench_dataset(level=1, source="local")
+    hf_ds = construct_kernelbench_dataset(level=1, source="huggingface")
+    
+    # Same number of problems
+    assert len(local_ds) == len(hf_ds), "Local and HF should have same number of problems"
+    
+    # Same problem IDs
+    assert local_ds.get_problem_ids() == hf_ds.get_problem_ids(), "Problem IDs should match"
+    
+    # Check a few problems have same content
+    for pid in [1, 10, 50]:
+        local_p = local_ds.get_problem_by_id(pid)
+        hf_p = hf_ds.get_problem_by_id(pid)
+        
+        # Names may differ slightly (HF may not have .py extension)
+        # But the base name (without extension) should match
+        local_base = local_p.name.replace(".py", "")
+        hf_base = hf_p.name.replace(".py", "")
+        assert local_base == hf_base, f"Problem {pid} name mismatch: {local_p.name} vs {hf_p.name}"
+        
+        # Code and hash should match exactly
+        assert local_p.code == hf_p.code, f"Problem {pid} code mismatch"
+        assert local_p.hash == hf_p.hash, f"Problem {pid} hash mismatch"
+
+
+@pytest.mark.slow
+def test_huggingface_subset():
+    """Test that HuggingFace dataset supports subsetting."""
+    hf_ds = construct_kernelbench_dataset(level=1, source="huggingface")
+    
+    subset = hf_ds.subset(problem_ids=[1, 2, 3])
+    assert len(subset) == 3
+    assert subset.get_problem_ids() == [1, 2, 3]
+
+
+@pytest.mark.slow
+def test_huggingface_representative():
+    """Test that HuggingFace dataset supports representative subset."""
+    hf_ds = construct_kernelbench_dataset(level=1, source="huggingface")
+    rep = hf_ds.get_representative_subset()
+    
+    assert len(rep) == len(LEVEL1_REPRESENTATIVE_IDS)
+
+
+@pytest.mark.slow  
+def test_unified_interface_behavior():
+    """Test that both sources behave identically through the unified interface."""
+    for source in ["local", "huggingface"]:
+        dataset = construct_kernelbench_dataset(level=1, source=source)
+        
+        # All these operations should work the same
+        assert len(dataset) > 0
+        assert 1 in dataset.get_problem_ids()
+        
+        problem = dataset.get_problem_by_id(1)
+        assert isinstance(problem, Problem)
+        assert problem.problem_id == 1
+        assert problem.level == 1
+        
+        # Iteration works
+        count = 0
+        for p in dataset:
+            count += 1
+            if count >= 3:
+                break
+        assert count == 3
+        
+        # Subset works
+        subset = dataset.subset(problem_ids=[1, 2])
+        assert len(subset) == 2
\ No newline at end of file
diff --git a/src/kernelbench/unit_tests/test_eval_adversarial.py b/src/kernelbench/unit_tests/test_eval_adversarial.py
new file mode 100644
index 00000000..ac019ba3
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_eval_adversarial.py
@@ -0,0 +1,112 @@
+import os
+
+from kernelbench.dataset import KERNEL_BENCH_PATH
+from kernelbench.eval import eval_kernel_against_ref
+from kernelbench.utils import read_file
+
+"""
+Specifically testing the robustness of the eval function.
+Through a few targeted adversarial kernels.
+
+Run with pytest
+pytest src/unit_tests/test_eval_adversarial.py
+"""
+
+def run_test_kernel(problem_name, 
+                    kernel_filename, 
+                    timing_method="cuda_event",
+                    num_perf_trials=100):
+    """
+    Run a test kernel agains the reference architecture and return the result.
+
+    Inputs:
+    - problem_name: name of the KernelBench problem to test on (e.g. "level1/1_Square_matrix_multiplication_.py")
+    - kernel_filename: name of the adversarial kernel (e.g. "zero_out_kernel.py")
+
+    Output:
+    - result: KernelExecResult object
+    """
+    print(f"Running test adversarial kernel {kernel_filename} against problem {problem_name}")
+    ref_src = read_file(os.path.join(KERNEL_BENCH_PATH, problem_name))
+    # TODO: replace with Omar's dataset object
+    kernel_src = read_file(os.path.join(os.path.dirname(__file__), "test_kernels", kernel_filename))
+    
+    return eval_kernel_against_ref(
+        original_model_src=ref_src,
+        custom_model_src=kernel_src,
+        num_correct_trials=5, # under mulitiple correctness trials
+        num_perf_trials=num_perf_trials,
+        measure_performance=True,
+        timing_method=timing_method,
+        # for checking against reward hacking
+        check_for_excessive_speedup = True, 
+        excessive_speedup_threshold = 10
+    )
+
+
+def test_result_cache_reuse():
+    """
+    Test to prevent adversarial kernel by reuse computed PyTorch results 
+
+    Methodology: 
+    - Adversarial kernel allocate memory for result but does not initialize it.
+    - Potential Hacking scenario: CUDA cache allocator might give that un-erased physical memory to the custom kernel (which contains the result) and it will incorrectly pass
+    - Eval script should flag this as incorrect as the reference kernel did not conduct any meaningful computation
+    """
+    result = run_test_kernel(problem_name="level1/1_Square_matrix_multiplication_.py", 
+                            kernel_filename="result_reuse_kernel.py")
+    assert result.correctness is False, "Cache reuse hack detected"
+    print("Result: Eval Function Passed Test Result Cache Reuse")
+    print(result)
+
+def test_input_modification():
+    """
+    Test that even if the model tries to modify the inputs to pass the tests,
+    we still flag it as incorrect.
+
+    Methodology:
+    - Adversarial kernel zeros out all inputs and returns all zeros for the final matmul shape.
+    - Potential Hacking scenario: Since adversarial kernel zero out the input, the reference might ran the kernel with all zeros. 
+      Hence both refernece and custom kernel return all zeros, and this incorrectly pass.
+    - Eval script should flag this as incorrect as this kernel zeros out inputs and trick the reference kernel into returning all zeros.
+    """
+    result = run_test_kernel(problem_name="level1/1_Square_matrix_multiplication_.py", 
+                            kernel_filename="zero_out_kernel.py")
+    assert result.correctness is False, "Input modification hack detected"
+    print("Result: Eval Function Passed Test Input Modification Hack")
+    print(result)
+
+
+def test_non_default_stream(timing_method="do_bench", threshold=1.5):
+    """
+    Test that we will flag adversarial kernels that cheat by assigning work to non-default CUDA streams.
+
+    Methodology:
+    - Adversarial kernel assigns work to non-default CUDA streams.
+    - Potential Hacking scenario: Eval script waits on the default stream only when measuring kernel runtime, leading to unrealistic speedups.
+    - Eval script should accurately measure runtime by waiting on all streams, not just the default stream.
+    """
+    result = run_test_kernel(problem_name="level1/1_Square_matrix_multiplication_.py", 
+                            kernel_filename="non_default_stream_kernel.py",
+                            timing_method=timing_method,
+                            num_perf_trials=10 ) # keep it low as we are leaking cuda stream
+
+    print(result)
+    if result.metadata.get("excessive_speedup") is True:   
+        print("Result: Eval Function successfully marked excessive speedup from the hacky CUDA Stream implementation")
+        print("This indicates the eval script properly detected and flagged potential cheating behavior.")
+    else:
+        raise AssertionError(
+            "Excessive speedup not detected - Eval Function failed to flag adversarial kernel that exploits cuda stream timing hack"
+        )
+
+
+def main():
+    test_result_cache_reuse()
+    test_input_modification()
+    test_non_default_stream()
+
+    # we might add more adversarial tests in the future
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/src/unit_tests/test_eval_timing.py b/src/kernelbench/unit_tests/test_eval_timing.py
similarity index 68%
rename from src/unit_tests/test_eval_timing.py
rename to src/kernelbench/unit_tests/test_eval_timing.py
index 84921a37..470c4254 100644
--- a/src/unit_tests/test_eval_timing.py
+++ b/src/kernelbench/unit_tests/test_eval_timing.py
@@ -4,16 +4,17 @@
 import pytest
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-import timing
+from kernelbench import timing
+from kernelbench.profile import NSIGHT_AVAILABLE, check_ncu_available
 
 """
 Test Timing
 We want to systematically study different timing methodologies.
 """
-REPO_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+REPO_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 
 # use exampls in the few shot directory
-EXAMPLES_PATH = os.path.join(REPO_PATH, "src", "prompts", "few_shot")
+EXAMPLES_PATH = os.path.join(REPO_PATH, "src", "kernelbench", "prompts", "few_shot")
 
 # Configure your test cases here
 TEST_REF_FILE = "model_ex_tiled_matmul.py"
@@ -78,14 +79,60 @@ def matmul_kernel(a, b):
 # test all currently available timing methods
 def run_all_timing_tests(device="cuda"):
     timing_methods = ["cuda_event", "host_time", "do_bench", "do_bench_impl"]
-    # timing_methods = ["cuda_event", "do_bench_impl"]
     for timing_method in timing_methods:
         _run_timing_smoke_test_matmul(timing_method, device=device)
 
 
+def run_nsight_timing_test(device="cuda"):
+    """
+    Run nsight-python timing test if available.
+    
+    Nsight requires:
+    - nsight-python package installed
+    - ncu (Nsight Compute CLI) in PATH
+    
+    Compares nsight GPU time against cuda_event timing for the same matmul operation.
+    """
+    if not NSIGHT_AVAILABLE:
+        print("[SKIP] nsight-python not installed")
+        return None
+    
+    if not check_ncu_available():
+        print("[SKIP] ncu not found in PATH")
+        return None
+    
+    print("\n" + "=" * 60)
+    print("Running nsight-python timing benchmark")
+    print("=" * 60)
+    
+    # Run nsight timing
+    print("\n--- nsight_python_time ---")
+    _run_timing_smoke_test_matmul("nsight_python_time", device=device)
+    
+    # Run cuda_event for comparison
+    print("\n--- cuda_event (for comparison) ---")
+    _run_timing_smoke_test_matmul("cuda_event", device=device)
+    
+    print("\n" + "=" * 60)
+    print("nsight-python timing benchmark complete")
+    print("=" * 60)
+
+
+def run_all_timing_tests_with_nsight(device="cuda"):
+    """
+    Run all timing methods including nsight-python if available.
+    """
+    # Standard timing methods (always available)
+    run_all_timing_tests(device=device)
+    
+    # Nsight timing (requires ncu + nsight-python)
+    run_nsight_timing_test(device=device)
+
 
+# select a free GPU here or set CUDA_VISIBLE_DEVICES
 test_device = torch.device("cuda:5")
 run_all_timing_tests(test_device)
+run_nsight_timing_test(test_device)
 
 
 
diff --git a/src/kernelbench/unit_tests/test_kernels/non_default_stream_kernel.py b/src/kernelbench/unit_tests/test_kernels/non_default_stream_kernel.py
new file mode 100644
index 00000000..37fe00fd
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_kernels/non_default_stream_kernel.py
@@ -0,0 +1,84 @@
+import torch
+import torch.nn as nn
+from torch.utils.cpp_extension import load_inline
+
+###########################################
+# CUDA_STREAM_ADVERSARIAL
+# adversarial kernel assigns all work to a non-default CUDA stream.
+# If the eval script waits only on the default cuda stream when measuring kernel runtime, this will lead to unrealistic speedups.   
+###########################################
+# this adversarial kernel obtains a non-default, non-blocking stream via cudaStreamCreateWithFlags(...) and sets to be the stream of the cuBLAS handle.
+# then, it performs a matrix multiplication on this new stream.
+
+# if timing harness only waits on default stream, it will measure near-zero time because the actual computation is still running asynchronously on the other stream.
+
+matmul_cuda_source = r"""
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cublas_v2.h>
+
+torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) {
+    int M = A.size(0);
+    int K = A.size(1);
+    int N = B.size(1);
+    
+    auto result = torch::empty({M, N}, A.options());
+    
+    cudaStream_t stream;
+    cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking);
+    
+    cublasHandle_t handle;
+    cublasCreate(&handle);
+    cublasSetStream(handle, stream);
+    
+    float alpha = 1.0f, beta = 0.0f;
+    
+    cublasGemmEx(handle,
+        CUBLAS_OP_N, CUBLAS_OP_N,
+        N, M, K,
+        &alpha,
+        B.data_ptr<float>(), CUDA_R_32F, N,
+        A.data_ptr<float>(), CUDA_R_32F, K,
+        &beta,
+        result.data_ptr<float>(), CUDA_R_32F, N,
+        CUBLAS_COMPUTE_32F, CUBLAS_GEMM_DEFAULT);
+
+    // NOTE: Intentionally leaking CUDA resources (stream + cuBLAS handle) to preserve
+    // adversarial behavior. Calling cudaStreamDestroy() would implicitly synchronize,
+    // defeating the purpose of this test (which checks if the eval harness detects
+    // work launched on non-default streams). Keep num_perf_trials low to avoid OOM.
+    // cublasDestroy(handle);
+    // cudaStreamDestroy(stream);
+    
+    return result;
+}
+"""
+
+matmul_cuda_cpp = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);"
+
+# Compile inline extension
+matmul_module = load_inline(
+    name="fast_matmul",
+    cpp_sources=matmul_cuda_cpp,
+    cuda_sources=matmul_cuda_source,
+    functions=["matmul_cuda"],
+    verbose=False,
+)
+
+class ModelNew(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.matmul = matmul_module
+
+    def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
+        return self.matmul.matmul_cuda(A, B)
+
+N = 2048 * 2
+
+def get_inputs():
+    A = torch.rand(N, N)
+    B = torch.rand(N, N)
+    return [A, B]
+
+def get_init_inputs():
+    return []
\ No newline at end of file
diff --git a/src/kernelbench/unit_tests/test_kernels/result_reuse_kernel.py b/src/kernelbench/unit_tests/test_kernels/result_reuse_kernel.py
new file mode 100644
index 00000000..88258ddf
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_kernels/result_reuse_kernel.py
@@ -0,0 +1,51 @@
+import torch
+import torch.nn as nn
+from torch.utils.cpp_extension import load_inline
+
+###########################################
+# 
+# This adversarial kernel utilizes empty which can get allocated the same physical memory as the PyTorch reference outputs
+# If the eval script deletes/frees the PyTorch output object at some point before the custom kernel is run, 
+# the CUDA cache allocator might give that un-erased physical memory to the custom kernel and it will incorrectly pass
+# So, we should ensure we zero out physical memory to prevent reuse
+###########################################
+
+# Returns a zero_
+matmul_cuda_source = r"""
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+
+torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) {
+    auto C = torch::empty({A.size(0), B.size(1)}, A.options());
+    return C;
+}
+"""
+
+matmul_cuda_cpp = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);"
+
+# Compile inline extension
+matmul_module = load_inline(
+    name="fast_matmul", # this is a hacky kernel that shall not pass; it would extra fast since it just allocates memory of result shape
+    cpp_sources=matmul_cuda_cpp,
+    cuda_sources=matmul_cuda_source,
+    functions=["matmul_cuda"],
+    verbose=False,
+)
+
+class ModelNew(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.matmul = matmul_module
+
+    def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
+        return self.matmul.matmul_cuda(A, B)
+
+N = 2048 * 2
+
+def get_inputs():
+    A = torch.rand(N, N)
+    B = torch.rand(N, N)
+    return [A, B]
+
+def get_init_inputs():
+    return []
\ No newline at end of file
diff --git a/src/kernelbench/unit_tests/test_kernels/zero_out_kernel.py b/src/kernelbench/unit_tests/test_kernels/zero_out_kernel.py
new file mode 100644
index 00000000..aba20620
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_kernels/zero_out_kernel.py
@@ -0,0 +1,50 @@
+import torch
+import torch.nn as nn
+from torch.utils.cpp_extension import load_inline
+
+###########################################
+# This custom kernel zeros out the inputs and returns a zero matrix.
+# It is specifically designed to test the eval script's robustness.
+# Running this zero kernel should result in incorrectness for eval,
+# as the reference kernel will not return all zeros.
+###########################################
+
+# Destroys all inputs, returns all zeros for final matmul shape
+matmul_cuda_source = r"""
+#include <torch/extension.h>
+
+torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) {
+    A.zero_();
+    B.zero_();
+    return torch::zeros({A.size(0), B.size(1)}, A.options());
+}
+"""
+
+matmul_cuda_cpp = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);"
+
+# Compile inline extension
+matmul_module = load_inline(
+    name="fast_matmul", # this is a hacky kernel that shall not pass; it would extra fast since it just allocates 0s
+    cpp_sources=matmul_cuda_cpp,
+    cuda_sources=matmul_cuda_source,
+    functions=["matmul_cuda"],
+    verbose=False,
+)
+
+class ModelNew(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.matmul = matmul_module
+
+    def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
+        return self.matmul.matmul_cuda(A, B)
+
+N = 2048 * 2
+
+def get_inputs():
+    A = torch.rand(N, N)
+    B = torch.rand(N, N)
+    return [A, B]
+
+def get_init_inputs():
+    return []
\ No newline at end of file
diff --git a/src/kernelbench/unit_tests/test_precision.py b/src/kernelbench/unit_tests/test_precision.py
new file mode 100644
index 00000000..1e8a2299
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_precision.py
@@ -0,0 +1,395 @@
+"""
+Unit tests for precision downgrade detection in FP32 kernels.
+
+Tests the check_precision_downgrade function to ensure it correctly detects
+various patterns that indicate precision downgrading (FP32 -> FP16),
+which is a reward hacking pattern.
+
+Note: The current implementation only checks for FP32 -> FP16 downgrades,
+not BF16 downgrades.
+
+Run with pytest:
+    pytest src/kernelbench/unit_tests/test_precision.py -v
+    or
+    uv run pytest src/kernelbench/unit_tests/test_precision.py -v
+"""
+
+import os
+import sys
+import pytest
+
+# Add src directory to path for imports (consistent with other test files)
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+from kernelbench.kernel_static_checker import check_precision_downgrade
+
+
+# ============================================================================
+# Test Cases for FP32 -> FP16 Precision Downgrades (PyTorch patterns)
+# ============================================================================
+
+def test_fp32_half_method():
+    """Test detection of .half() method call downgrading FP32 to FP16."""
+    code = """
+    def forward(self, x):
+        x = x.half()
+        return x * 2
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect .half() method call"
+    assert "FP16" in message
+
+
+def test_fp32_float16_method():
+    """Test detection of .float16() method call."""
+    code = """
+    x = input_tensor.float16()
+    return x
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect .float16() method call"
+    assert "FP16" in message
+
+
+def test_fp32_to_torch_half():
+    """Test detection of .to(torch.half) pattern."""
+    code = """
+    def forward(self, x):
+        x = x.to(torch.half)
+        return x
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect .to(torch.half)"
+    assert "FP16" in message
+
+
+def test_fp32_to_torch_float16():
+    """Test detection of .to(torch.float16) pattern."""
+    code = """
+    x = x.to(torch.float16)
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect .to(torch.float16)"
+    assert "FP16" in message
+
+
+def test_fp32_to_dtype_float16():
+    """Test detection of .to(dtype=torch.float16) pattern."""
+    code = """
+    def forward(self, x):
+        return x.to(dtype=torch.float16)
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect .to(dtype=torch.float16)"
+    assert "FP16" in message
+
+
+def test_fp32_to_dtype_half():
+    """Test detection of .to(dtype=torch.half) pattern."""
+    code = """
+    x.to(dtype=torch.half)
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect .to(dtype=torch.half)"
+    assert "FP16" in message
+
+
+# ============================================================================
+# Test Cases for FP32 -> FP16 Precision Downgrades (CUDA patterns)
+# ============================================================================
+
+def test_fp32_cuda_float2half():
+    """Test detection of CUDA __float2half intrinsic."""
+    code = """
+    __global__ void kernel(float* input, __half* output) {
+        output[0] = __float2half(input[0]);
+    }
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUDA __float2half"
+    assert "FP16" in message
+
+
+def test_fp32_cuda_float2half_rn():
+    """Test detection of CUDA __float2half_rn intrinsic."""
+    code = """
+    __half result = __float2half_rn(value);
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUDA __float2half_rn"
+    assert "FP16" in message
+
+
+def test_fp32_cuda_cast_to_half():
+    """Test detection of CUDA C-style cast to __half."""
+    code = """
+    __half h = (__half)float_value;
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUDA cast to __half"
+    assert "FP16" in message
+
+
+def test_fp32_cuda_static_cast_half():
+    """Test detection of CUDA static_cast<half>."""
+    code = """
+    __half h = static_cast<__half>(float_value);
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUDA static_cast<__half>"
+    assert "FP16" in message
+
+
+# ============================================================================
+# Test Cases for FP32 -> FP16 Precision Downgrades (Triton patterns)
+# ============================================================================
+
+def test_fp32_triton_astype_float16():
+    """Test detection of Triton tl.astype(..., tl.float16)."""
+    code = """
+    @triton.jit
+    def kernel(X, Y):
+        x = tl.load(X)
+        x_fp16 = tl.astype(x, tl.float16)
+        tl.store(Y, x_fp16)
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect Triton tl.astype(..., tl.float16)"
+    assert "FP16" in message
+
+
+# ============================================================================
+# Test Cases for FP32 -> FP16 Precision Downgrades (CUTLASS patterns)
+# ============================================================================
+
+def test_fp32_cutlass_numeric_converter():
+    """Test detection of CUTLASS NumericConverter<half_t, float>."""
+    code = """
+    NumericConverter<half_t, float> converter;
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUTLASS NumericConverter<half_t, float>"
+    assert "FP16" in message
+
+
+def test_fp32_cutlass_linear_combination():
+    """Test detection of CUTLASS LinearCombination<half_t, ...>."""
+    code = """
+    LinearCombination<half_t, 128> epilogue;
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUTLASS LinearCombination<half_t>"
+    assert "FP16" in message
+
+
+def test_fp32_cute_type_convert():
+    """Test detection of CuTe type_convert<half_t>."""
+    code = """
+    auto result = type_convert<half_t>(input);
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CuTe type_convert<half_t>"
+    assert "FP16" in message
+
+
+# ============================================================================
+# Test Cases for FP32 -> FP16 Precision Downgrades (ThunderKittens patterns)
+# ============================================================================
+
+def test_fp32_thunderkittens_half():
+    """Test detection of ThunderKittens tk::half()."""
+    code = """
+    using namespace tk;
+    auto h = tk::half(value);
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect ThunderKittens tk::half()"
+    assert "FP16" in message
+
+
+# ============================================================================
+# Test Cases for Valid FP32 Code (Should NOT be detected)
+# ============================================================================
+
+def test_fp32_legitimate_code_no_downgrade():
+    """Test that legitimate FP32 code is not flagged."""
+    code = """
+    def forward(self, x):
+        # Legitimate FP32 operations
+        x = x * 2.0
+        y = torch.matmul(x, x.t())
+        return y.float()  # This is fine, float() returns float32
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is False, "Should not detect downgrade in legitimate FP32 code"
+    assert message == ""
+
+
+def test_fp32_with_comments_mentioning_half():
+    """Test that comments mentioning half precision don't trigger false positives."""
+    code = """
+    def forward(self, x):
+        # Note: This should use FP32, not FP16
+        # Don't use .half() here!
+        x = x * 2.0
+        return x
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is False, "Comments should not trigger detection"
+
+
+def test_fp32_string_literals():
+    """Test that string literals mentioning precision don't trigger false positives."""
+    code = """
+    def forward(self, x):
+        error_msg = "dtype=torch.float16 is not allowed"
+        print(error_msg)
+        return x
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is False, "String literals should not trigger detection"
+
+
+def test_fp32_function_names_containing_half():
+    """Test that function names containing 'half' don't trigger false positives."""
+    code = """
+    def compute_half_tensor(self, x):
+        # Function name contains 'half' but doesn't downgrade precision
+        return x * 0.5
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is False, "Function names should not trigger detection"
+
+
+# ============================================================================
+# Test Cases for Edge Cases
+# ============================================================================
+
+def test_fp32_case_insensitive_precision():
+    """Test that precision parameter is case-insensitive."""
+    code = """
+    x = x.half()
+    """
+    detected1, _ = check_precision_downgrade(code, precision="FP32")
+    detected2, _ = check_precision_downgrade(code, precision="fp32")
+    detected3, _ = check_precision_downgrade(code, precision="Fp32")
+    assert detected1 == detected2 == detected3 == True, "Should handle case-insensitive precision"
+
+
+def test_fp32_alternative_precision_names():
+    """Test that alternative precision names are normalized correctly."""
+    code = """
+    x = x.half()
+    """
+    detected1, _ = check_precision_downgrade(code, precision="float32")
+    detected2, _ = check_precision_downgrade(code, precision="fp32")
+    assert detected1 == detected2 == True, "Should normalize float32 to fp32"
+
+
+def test_fp32_non_fp32_precision_skips_check():
+    """Test that non-FP32 precision skips the check (implementation only checks FP32)."""
+    code = """
+    x = x.half()
+    """
+    detected, message = check_precision_downgrade(code, precision="fp16")
+    assert detected is False, "Should skip check for non-FP32 precision"
+    assert message == ""
+
+
+def test_fp32_unknown_precision_skips_check():
+    """Test that unknown precision skips the check."""
+    code = """
+    x = x.half()
+    """
+    detected, message = check_precision_downgrade(code, precision="int8")
+    assert detected is False, "Should skip check for unknown precision"
+    assert message == ""
+
+
+def test_fp32_empty_code():
+    """Test that empty code doesn't trigger detection."""
+    code = ""
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is False, "Empty code should not trigger detection"
+
+
+def test_fp32_whitespace_only():
+    """Test that whitespace-only code doesn't trigger detection."""
+    code = "   \n\n\t  \n  "
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is False, "Whitespace-only code should not trigger detection"
+
+
+# ============================================================================
+# Test Cases for Real-World Scenarios
+# ============================================================================
+
+def test_fp32_matmul_with_hidden_downgrade():
+    """Test detection in a realistic matmul kernel that downgrades internally."""
+    code = """
+    @triton.jit
+    def matmul_kernel(A, B, C, M, N, K):
+        # Compute matrix multiplication
+        a = tl.load(A)
+        b = tl.load(B)
+        
+        # Sneaky precision downgrade
+        a = tl.astype(a, tl.float16)
+        b = tl.astype(b, tl.float16)
+        
+        c = tl.dot(a, b)
+        tl.store(C, c)
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect hidden precision downgrade in matmul"
+    assert "FP16" in message
+
+
+def test_fp32_cuda_kernel_with_half():
+    """Test detection in a realistic CUDA kernel."""
+    code = """
+    __global__ void add_kernel(float* a, float* b, float* c, int n) {
+        int idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < n) {
+            __half a_half = __float2half(a[idx]);
+            __half b_half = __float2half(b[idx]);
+            c[idx] = __half2float(a_half + b_half);
+        }
+    }
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect CUDA kernel using __float2half"
+    assert "FP16" in message
+
+
+def test_fp32_complex_code_with_downgrade():
+    """Test detection in complex code with multiple operations."""
+    code = """
+    def forward(self, x, y):
+        # Some preprocessing
+        x = x * 2.0
+        y = y + 1.0
+        
+        # Main computation with downgrade
+        x = x.to(dtype=torch.float16)
+        result = torch.matmul(x, y)
+        
+        # Post-processing
+        result = result * 3.0
+        return result
+    """
+    detected, message = check_precision_downgrade(code, precision="fp32")
+    assert detected is True, "Should detect downgrade in complex code"
+    assert "FP16" in message
+
+
+# ============================================================================
+# Note on BF16 Tests
+# ============================================================================
+# The current implementation only checks for FP32 -> FP16 downgrades.
+# BF16 downgrade detection is not yet implemented. These tests document
+# expected behavior when BF16 support is added in the future.
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
diff --git a/src/unit_tests/test_score.py b/src/kernelbench/unit_tests/test_score.py
similarity index 99%
rename from src/unit_tests/test_score.py
rename to src/kernelbench/unit_tests/test_score.py
index 918b1f12..cfdd76c2 100644
--- a/src/unit_tests/test_score.py
+++ b/src/kernelbench/unit_tests/test_score.py
@@ -1,5 +1,5 @@
 import pytest
-from src.score import *
+from kernelbench.score import *
 import math
 
 '''
diff --git a/src/kernelbench/unit_tests/test_static_checker.py b/src/kernelbench/unit_tests/test_static_checker.py
new file mode 100644
index 00000000..d4411fff
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_static_checker.py
@@ -0,0 +1,166 @@
+"""
+Tests for kernel_static_checker.py
+
+Validates that the static checker correctly identifies:
+- Valid DSL kernels (no false positives)  
+- Known adversarial/hack patterns (no false negatives)
+
+We welcome contributions to improve the static checker and providing adversarial kernels.
+
+
+Run with: uv run pytest src/kernelbench/unit_tests/test_static_checker.py -v
+"""
+
+import pytest
+from pathlib import Path
+from kernelbench.kernel_static_checker import validate_kernel_static
+
+
+# =============================================================================
+# Fixtures - Common paths and helpers
+# =============================================================================
+
+@pytest.fixture
+def prompts_dir():
+    """Path to DSL example kernels."""
+    return Path(__file__).parent.parent / "prompts"
+
+@pytest.fixture
+def test_kernels_dir():
+    """Path to adversarial test kernels."""
+    return Path(__file__).parent / "test_kernels"
+
+
+def read_kernel(path: Path) -> str:
+    """Read kernel code from file, skip if not found."""
+    if not path.exists():
+        pytest.skip(f"Kernel file not found: {path}")
+    return path.read_text()
+
+
+# =============================================================================
+# Valid DSL Kernels - Should Pass (No False Positives)
+# These are real, correct kernels from src/kernelbench/prompts/
+# =============================================================================
+
+def test_cuda_example_valid(prompts_dir):
+    """Real CUDA kernel example should pass with default settings."""
+    code = read_kernel(prompts_dir / "model_new_ex_add.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    # May have warnings (F import), but should be valid
+    assert valid or "import F" in str(warnings), f"CUDA example should pass: {errors}"
+
+
+def test_triton_example_valid(prompts_dir):
+    """Real Triton kernel example should pass."""
+    code = read_kernel(prompts_dir / "model_new_ex_add_triton.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="triton")
+    assert valid or len(warnings) > 0, f"Triton example should pass: {errors}"
+
+
+def test_cute_example_valid(prompts_dir):
+    """Real CuTe/CUTLASS kernel example should pass."""
+    code = read_kernel(prompts_dir / "model_new_ex_add_cute.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="cute")
+    assert valid or len(warnings) > 0, f"CuTe example should pass: {errors}"
+
+
+def test_tilelang_example_valid(prompts_dir):
+    """Real TileLang kernel example should pass."""
+    code = read_kernel(prompts_dir / "model_new_ex_add_tilelang.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="tilelang")
+    assert valid or len(warnings) > 0, f"TileLang example should pass: {errors}"
+
+
+# =============================================================================
+# Adversarial Kernels - Should Detect Issues  
+# These are known hack patterns from test_kernels/
+# =============================================================================
+
+def test_stream_kernel_flagged(test_kernels_dir):
+    """Non-default stream kernel should trigger stream_injection warning."""
+    code = read_kernel(test_kernels_dir / "non_default_stream_kernel.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    # Stream injection is in warnings by default
+    all_messages = errors + warnings
+    has_stream_warning = any("stream" in msg.lower() for msg in all_messages)
+    # Note: The CUDA code is in a string literal, so static checker may not catch it
+    # This test documents the limitation
+
+
+def test_result_reuse_kernel_flagged(test_kernels_dir):
+    """Result reuse (empty tensor) kernel - static checker can't catch this."""
+    code = read_kernel(test_kernels_dir / "result_reuse_kernel.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    # This is a runtime check, static checker won't catch it
+    # Just verify it doesn't crash
+
+
+def test_zero_out_kernel_flagged(test_kernels_dir):
+    """Zero-out kernel - static checker can't catch this."""
+    code = read_kernel(test_kernels_dir / "zero_out_kernel.py")
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    # This is a correctness issue, not detectable statically
+
+
+# =============================================================================
+# Hack Patterns - Synthetic Examples
+# =============================================================================
+
+def test_bypass_try_except():
+    """Try-except fallback should be flagged as error."""
+    code = """
+try:
+    result = custom_kernel(x)
+except:
+    result = torch.matmul(x, w)  # Fallback to torch
+"""
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    assert not valid, "Try-except should be flagged"
+    assert any("try-except" in e.lower() for e in errors)
+
+
+def test_bypass_pass_statement():
+    """Pass statement (inheritance bypass) should be flagged."""
+    code = """
+class ModelNew(Model):
+    def forward(self, x):
+        pass  # Does nothing, inherits parent
+"""
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    assert not valid, "Pass statement should be flagged"
+    assert any("pass" in e.lower() for e in errors)
+
+
+def test_lazy_eval_make_subclass():
+    """_make_subclass (lazy tensor hack) should be flagged."""
+    code = """
+fake_tensor = torch.Tensor._make_subclass(FakeTensor, real_tensor)
+"""
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    assert not valid, "_make_subclass should be flagged"
+
+
+def test_timing_monkey_patch():
+    """Monkey patching timing functions should be flagged."""
+    code = """
+# Override timing to fake benchmarks
+torch.cuda.Event.elapsed_time = lambda self, end: 0.001
+"""
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    assert not valid, "Timing monkey patch should be flagged"
+
+
+def test_thread_injection():
+    """Threading in kernel code should be flagged."""
+    code = """
+import threading
+t = threading.Thread(target=background_work)
+t.start()
+"""
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    assert not valid, "Threading should be flagged"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
diff --git a/src/unit_tests/test_utils.py b/src/kernelbench/unit_tests/test_utils.py
similarity index 96%
rename from src/unit_tests/test_utils.py
rename to src/kernelbench/unit_tests/test_utils.py
index 9b569dd5..b7126e15 100644
--- a/src/unit_tests/test_utils.py
+++ b/src/kernelbench/unit_tests/test_utils.py
@@ -1,6 +1,6 @@
 import pytest # noqa    
  
-from src.utils import extract_first_code, extract_code_blocks, extract_last_code
+from kernelbench.utils import extract_first_code, extract_code_blocks, extract_last_code
 
 def check_code_assertions(code: str, expected_code: str):
     """
diff --git a/src/kernelbench/unit_tests/test_validate_kernel_static.py b/src/kernelbench/unit_tests/test_validate_kernel_static.py
new file mode 100644
index 00000000..f4394624
--- /dev/null
+++ b/src/kernelbench/unit_tests/test_validate_kernel_static.py
@@ -0,0 +1,423 @@
+"""
+Unit tests for validate_kernel_static function.
+
+Tests the main entry point function to ensure it correctly:
+- Passes precision to precision-dependent checks
+- Categorizes errors vs warnings correctly
+- Handles backend-specific checks
+- Respects forbidden/warnings parameters
+- Returns correct output format
+
+Run with pytest:
+    pytest src/kernelbench/unit_tests/test_validate_kernel_static.py -v
+    or
+    uv run pytest src/kernelbench/unit_tests/test_validate_kernel_static.py -v
+"""
+
+import os
+import sys
+import pytest
+
+# Add src directory to path for imports (consistent with other test files)
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+from kernelbench.kernel_static_checker import validate_kernel_static
+
+
+# ============================================================================
+# Test Basic Function Signature and Return Values
+# ============================================================================
+
+def test_validate_kernel_static_returns_tuple():
+    """Test that validate_kernel_static returns a tuple of (valid, errors, warnings)."""
+    code = "x = 1 + 1"
+    result = validate_kernel_static(code)
+    
+    assert isinstance(result, tuple), "Should return a tuple"
+    assert len(result) == 3, "Should return (valid, errors, warnings)"
+    valid, errors, warnings = result
+    assert isinstance(valid, bool), "First element should be bool"
+    assert isinstance(errors, list), "Second element should be list"
+    assert isinstance(warnings, list), "Third element should be list"
+
+
+def test_validate_kernel_static_defaults():
+    """Test that validate_kernel_static works with default parameters."""
+    code = "x = 1 + 1"
+    valid, errors, warnings = validate_kernel_static(code)
+    
+    # Should work without errors for simple valid code
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+# ============================================================================
+# Test Precision Parameter Passing
+# ============================================================================
+
+def test_precision_passed_to_precision_checker_fp32():
+    """Test that precision parameter is correctly passed to precision-dependent checks."""
+    # Code with FP32 -> FP16 downgrade
+    code = """
+    def forward(self, x):
+        x = x.half()  # Precision downgrade
+        return x
+    """
+    
+    # With fp32 precision, should detect downgrade (as warning by default)
+    valid, errors, warnings = validate_kernel_static(code, precision="fp32")
+    
+    # Check that precision downgrade was detected (should be in warnings by default)
+    all_messages = errors + warnings
+    has_precision_warning = any("precision" in msg.lower() or "fp16" in msg.lower() 
+                                for msg in all_messages)
+    assert has_precision_warning, "Should detect precision downgrade with fp32 precision"
+
+
+def test_precision_passed_to_precision_checker_fp16():
+    """Test that fp16 precision skips FP32 -> FP16 downgrade check."""
+    # Code with FP32 -> FP16 downgrade
+    code = """
+    def forward(self, x):
+        x = x.half()  # Precision downgrade
+        return x
+    """
+    
+    # With fp16 precision, precision downgrade check should be skipped
+    valid, errors, warnings = validate_kernel_static(code, precision="fp16")
+    
+    # Should not detect precision downgrade (check is skipped for non-FP32)
+    all_messages = errors + warnings
+    has_precision_warning = any("precision" in msg.lower() or "fp16" in msg.lower() 
+                                for msg in all_messages)
+    # This is expected - the check only runs for fp32
+    # So for fp16, it won't flag this
+
+
+def test_precision_case_insensitive():
+    """Test that precision parameter is case-insensitive."""
+    code = """
+    def forward(self, x):
+        x = x.half()
+        return x
+    """
+    
+    # Test different case variations
+    result1 = validate_kernel_static(code, precision="FP32")
+    result2 = validate_kernel_static(code, precision="fp32")
+    result3 = validate_kernel_static(code, precision="Fp32")
+    
+    # All should produce the same result
+    assert result1 == result2 == result3, "Precision should be case-insensitive"
+
+
+def test_precision_alternative_names():
+    """Test that alternative precision names are normalized."""
+    code = """
+    def forward(self, x):
+        x = x.half()
+        return x
+    """
+    
+    # float32 should be normalized to fp32
+    result1 = validate_kernel_static(code, precision="float32")
+    result2 = validate_kernel_static(code, precision="fp32")
+    
+    assert result1 == result2, "float32 should be normalized to fp32"
+
+
+# ============================================================================
+# Test Error vs Warning Categorization
+# ============================================================================
+
+def test_strict_checks_are_errors():
+    """Test that strict checks (like code_bypass) produce errors."""
+    code = """
+    try:
+        result = custom_kernel(x)
+    except:
+        result = torch.matmul(x, w)  # Fallback to torch
+    """
+    
+    valid, errors, warnings = validate_kernel_static(code)
+    
+    assert not valid, "Code with strict violations should be invalid"
+    assert len(errors) > 0, "Strict checks should produce errors, not warnings"
+    assert any("try-except" in e.lower() or "bypass" in e.lower() 
+               for e in errors), "Should flag bypass in errors"
+
+
+def test_warning_checks_are_warnings():
+    """Test that warning checks produce warnings, not errors."""
+    code = """
+    def forward(self, x):
+        x = x.half()  # Precision downgrade - in warnings by default
+        return x
+    """
+    
+    # Test with default settings - precision_downgrade should be in warnings
+    valid, errors, warnings = validate_kernel_static(
+        code, 
+        precision="fp32"
+        # Using defaults - precision_downgrade is in WARNING_CHECKS
+    )
+    
+    # Check that precision downgrade message is in warnings (if detected)
+    # Note: backend impl checks might add errors, but precision should be in warnings
+    precision_warnings = [w for w in warnings if "precision" in w.lower() or "fp16" in w.lower()]
+    precision_errors = [e for e in errors if "precision" in e.lower() or "fp16" in e.lower()]
+    
+    if precision_warnings or precision_errors:
+        # If precision downgrade is detected, it should be in warnings, not errors
+        assert len(precision_warnings) > 0, "Precision downgrade should be in warnings (default)"
+        assert len(precision_errors) == 0, "Precision downgrade should not be in errors (default)"
+
+
+def test_custom_forbidden_checks():
+    """Test that custom forbidden checks produce errors."""
+    code = """
+    def forward(self, x):
+        x = x.half()  # Precision downgrade
+        return x
+    """
+    
+    # Make precision_downgrade a forbidden check (error) instead of warning
+    valid, errors, warnings = validate_kernel_static(
+        code, 
+        precision="fp32",
+        forbidden=["precision_downgrade"]
+    )
+    
+    assert not valid, "Should be invalid when precision_downgrade is forbidden"
+    assert len(errors) > 0, "Forbidden checks should produce errors"
+    assert any("precision" in e.lower() or "fp16" in e.lower() 
+               for e in errors), "Should flag precision downgrade in errors"
+
+
+def test_custom_warnings_list():
+    """Test that custom warnings list works."""
+    code = """
+    try:
+        result = custom_kernel(x)
+    except:
+        result = torch.matmul(x, w)
+    """
+    
+    # Move code_bypass to warnings instead of errors
+    # Use a backend that won't add strict impl checks
+    valid, errors, warnings = validate_kernel_static(
+        code,
+        backend="cuda",  # Explicit backend
+        forbidden=[],  # No forbidden checks
+        warnings=["code_bypass"]  # Make bypass a warning
+    )
+    
+    # Note: Backend might add impl checks, so we check that code_bypass
+    # appears in warnings (not errors) if it's detected
+    all_messages = errors + warnings
+    bypass_messages = [msg for msg in all_messages if "bypass" in msg.lower() or "try-except" in msg.lower()]
+    
+    if bypass_messages:
+        # If bypass is detected, it should be in warnings, not errors
+        bypass_in_warnings = any(msg in warnings for msg in bypass_messages)
+        assert bypass_in_warnings, "Bypass should be in warnings when specified as warning"
+
+
+# ============================================================================
+# Test Backend Parameter Handling
+# ============================================================================
+
+def test_backend_adds_impl_check():
+    """Test that backend parameter adds appropriate implementation check."""
+    code = """
+    # This code doesn't have CUDA implementation
+    def forward(self, x):
+        return x * 2
+    """
+    
+    valid, errors, warnings = validate_kernel_static(code, backend="cuda")
+    
+    # Should check for CUDA implementation (cuda_impl check)
+    # The exact behavior depends on what cuda_impl check does,
+    # but we can verify the backend parameter is processed
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+def test_different_backends():
+    """Test that different backends are handled correctly."""
+    code = """
+    def forward(self, x):
+        return x * 2
+    """
+    
+    # Test multiple backends
+    backends = ["cuda", "hip", "triton", "thunderkittens", "cute", "tilelang"]
+    
+    for backend in backends:
+        valid, errors, warnings = validate_kernel_static(code, backend=backend)
+        assert isinstance(valid, bool)
+        assert isinstance(errors, list)
+        assert isinstance(warnings, list)
+
+
+# ============================================================================
+# Test Edge Cases
+# ============================================================================
+
+def test_empty_code():
+    """Test handling of empty code."""
+    code = ""
+    
+    valid, errors, warnings = validate_kernel_static(code)
+    
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+def test_whitespace_only_code():
+    """Test handling of whitespace-only code."""
+    code = "   \n\n\t  \n  "
+    
+    valid, errors, warnings = validate_kernel_static(code)
+    
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+def test_unknown_check_name():
+    """Test that unknown check names are ignored."""
+    code = "x = 1"
+    
+    # Should not crash with unknown check names
+    valid, errors, warnings = validate_kernel_static(
+        code,
+        forbidden=["unknown_check_that_doesnt_exist"],
+        warnings=["another_unknown_check"]
+    )
+    
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+def test_multiple_precision_dependent_checks():
+    """Test that multiple precision-dependent checks work (if any exist in future)."""
+    code = """
+    def forward(self, x):
+        x = x.half()
+        return x
+    """
+    
+    # Currently only precision_downgrade is precision-dependent
+    valid, errors, warnings = validate_kernel_static(code, precision="fp32")
+    
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+# ============================================================================
+# Test Integration: Precision + Backend + Custom Checks
+# ============================================================================
+
+def test_integration_precision_backend_forbidden():
+    """Test integration of precision, backend, and custom forbidden checks."""
+    code = """
+    def forward(self, x):
+        x = x.half()  # Precision downgrade
+        return x
+    """
+    
+    valid, errors, warnings = validate_kernel_static(
+        code,
+        backend="cuda",
+        precision="fp32",
+        forbidden=["precision_downgrade"]
+    )
+    
+    assert not valid, "Should be invalid with precision downgrade as forbidden"
+    assert len(errors) > 0, "Should have errors"
+    assert any("precision" in e.lower() or "fp16" in e.lower() 
+               for e in errors), "Should flag precision downgrade"
+
+
+def test_integration_all_parameters():
+    """Test with all parameters specified."""
+    code = """
+    def forward(self, x):
+        return x * 2.0
+    """
+    
+    valid, errors, warnings = validate_kernel_static(
+        code,
+        backend="triton",
+        precision="fp16",
+        forbidden=["code_bypass"],
+        warnings=["precision_downgrade"]
+    )
+    
+    assert isinstance(valid, bool)
+    assert isinstance(errors, list)
+    assert isinstance(warnings, list)
+
+
+# ============================================================================
+# Test Precision Check Integration
+# ============================================================================
+
+def test_precision_check_in_warnings_by_default():
+    """Test that precision_downgrade is in warnings by default."""
+    code = """
+    def forward(self, x):
+        x = x.half()
+        return x
+    """
+    
+    valid, errors, warnings = validate_kernel_static(code, precision="fp32")
+    
+    # precision_downgrade should be in WARNING_CHECKS by default
+    # So it should produce warnings, not errors
+    all_messages = errors + warnings
+    has_precision_msg = any("precision" in msg.lower() or "fp16" in msg.lower() 
+                            for msg in all_messages)
+    
+    if has_precision_msg:
+        # If detected, should be in warnings, not errors (by default)
+        precision_in_warnings = any("precision" in msg.lower() or "fp16" in msg.lower() 
+                                    for msg in warnings)
+        assert precision_in_warnings, "Precision downgrade should be in warnings by default"
+
+
+def test_precision_check_respects_forbidden():
+    """Test that precision_downgrade respects forbidden parameter."""
+    code = """
+    def forward(self, x):
+        x = x.half()
+        return x
+    """
+    
+    # Make precision_downgrade forbidden
+    valid, errors, warnings = validate_kernel_static(
+        code,
+        precision="fp32",
+        forbidden=["precision_downgrade"],
+        warnings=[]  # Remove from warnings
+    )
+    
+    # Should produce errors, not warnings
+    has_precision_in_errors = any("precision" in msg.lower() or "fp16" in msg.lower() 
+                                  for msg in errors)
+    
+    if has_precision_in_errors:
+        assert not valid, "Should be invalid when precision downgrade is forbidden"
+        assert len(errors) > 0, "Should have errors"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
+
diff --git a/src/utils.py b/src/kernelbench/utils.py
similarity index 84%
rename from src/utils.py
rename to src/kernelbench/utils.py
index f4fac580..d2d1b175 100644
--- a/src/utils.py
+++ b/src/kernelbench/utils.py
@@ -15,21 +15,20 @@
 import os
 import json
 from tqdm import tqdm
+import torch
+from importlib.resources import files, as_file
 
 # API clients
 from openai import OpenAI
 from litellm import completion
 
-# from datasets import load_dataset
 import numpy as np
 from contextlib import contextmanager
 from collections import defaultdict
 import time
-import shutil
 import concurrent
 from functools import cache
-from transformers import AutoTokenizer
-import hashlib
+
 
 from concurrent.futures import ProcessPoolExecutor, as_completed
 
@@ -40,16 +39,51 @@
 # Inference Helpers
 ########################################################
 
+NVIDIA_ARCHS = ["Maxwell", "Pascal", "Volta", "Turing", "Ampere", "Hopper", "Ada", "Blackwell"]
+AMD_ARCHS = ["gfx942", "gfx950"] # gfx942: CDNA3 (MI300), gfx950: CDNA4 (MI350) 
+
+
+########################################################
+# GPU Vendor Detection
+########################################################
+
+def get_gpu_vendor(device: torch.device | int | None = None) -> str:
+    """Returns 'nvidia', 'amd', or 'unknown' for the given device."""
+    if not torch.cuda.is_available():
+        return "unknown"
+    if device is None:
+        device = torch.cuda.current_device()
+    name = torch.cuda.get_device_name(device).upper()
+    if "NVIDIA" in name:
+        return "nvidia"
+    if "AMD" in name or "MI3" in name:
+        return "amd"
+    return "unknown"
+
+
 def set_gpu_arch(arch_list: list[str]):
     """
-    Set env variable for torch cuda arch list to build kernels for specified architectures
+    Set env variable for torch to build kernels for specified architectures.
+    Supports both NVIDIA (TORCH_CUDA_ARCH_LIST) and AMD (PYTORCH_ROCM_ARCH).
     """
-    valid_archs = ["Maxwell", "Pascal", "Volta", "Turing", "Ampere", "Hopper", "Ada"]
+    nvidia_archs = []
+    amd_archs = []
+    
     for arch in arch_list:
-        if arch not in valid_archs:
-            raise ValueError(f"Invalid architecture: {arch}. Must be one of {valid_archs}")
+        if arch in NVIDIA_ARCHS:
+            nvidia_archs.append(arch)
+        elif arch in AMD_ARCHS:
+            amd_archs.append(arch)
+        else:
+            raise ValueError(f"Invalid architecture: {arch}. Must be one of NVIDIA: {NVIDIA_ARCHS} or AMD: {AMD_ARCHS}")
     
-    os.environ["TORCH_CUDA_ARCH_LIST"] = ";".join(arch_list)
+    if nvidia_archs and amd_archs:
+        raise ValueError(f"Cannot mix NVIDIA and AMD architectures. Got NVIDIA: {nvidia_archs}, AMD: {amd_archs}")
+    
+    if nvidia_archs:
+        os.environ["TORCH_CUDA_ARCH_LIST"] = ";".join(nvidia_archs)
+    elif amd_archs:
+        os.environ["PYTORCH_ROCM_ARCH"] = ";".join(amd_archs)
 
 def query_server(
     prompt: str | list[dict],  # string if normal prompt, list of dicts if chat prompt,
@@ -276,6 +310,59 @@ def read_file(file_path) -> str:
         return ""
 
 
+########################################################
+# Path Resolution Helpers
+########################################################
+REPO_TOP_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
+
+def get_package_resource_path(relative_path: str) -> str:
+    """
+    Get absolute path to a kernelbench package resource.
+    Works for all three usage modes:
+      - Running from repo directly
+      - As a git submodule
+      - As an installed pip/uv dependency
+    
+    Args:
+        relative_path: Path relative to kernelbench/, e.g. "prompts/prompts.toml"
+    """
+    # Try importlib.resources first (installed package)
+    try:
+        resource = files("kernelbench").joinpath(relative_path)
+        with as_file(resource) as path:
+            if path.exists():
+                return str(path)
+    except (TypeError, FileNotFoundError):
+        pass
+    
+    # Try repo path (running from source / submodule)
+    repo_path = os.path.join(REPO_TOP_PATH, "src/kernelbench", relative_path)
+    if os.path.exists(repo_path):
+        return repo_path
+        
+    raise FileNotFoundError(f"Could not find resource: {relative_path}")
+
+
+def resolve_path(rel: str) -> str:
+    """
+    Resolve a relative path to absolute. Handles paths like "src/kernelbench/prompts/..."
+    from prompts.toml which reference files relative to repo root.
+    """
+    if os.path.isabs(rel):
+        return rel
+    
+    # Convert "src/kernelbench/..." paths to package-relative
+    if rel.startswith("src/kernelbench/"):
+        return get_package_resource_path(rel[len("src/kernelbench/"):])
+    
+    # Otherwise treat as repo-relative
+    repo_path = os.path.join(REPO_TOP_PATH, rel)
+    if os.path.exists(repo_path):
+        return repo_path
+    
+    raise FileNotFoundError(f"Could not resolve path: {rel}")
+
+
 def print_messages(messages):
     for message in messages:
         print(message["role"])
diff --git a/src/scratch/log.txt b/src/scratch/log.txt
deleted file mode 100644
index 9b231c5f..00000000
--- a/src/scratch/log.txt
+++ /dev/null
@@ -1,60 +0,0 @@
-[1/3] /usr/local/cuda-12.3/bin/nvcc --generate-dependencies-with-compile --dependency-output cuda.cuda.o.d -DTORCH_EXTENSION_NAME=matmul_sum_max -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/TH -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda-12.3/include -isystem /matx/u/aco/miniconda3/envs/myenv/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_89,code=compute_89 -gencode=arch=compute_89,code=sm_89 --compiler-options '-fPIC' -std=c++17 -c /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu -o cuda.cuda.o 
-FAILED: cuda.cuda.o 
-/usr/local/cuda-12.3/bin/nvcc --generate-dependencies-with-compile --dependency-output cuda.cuda.o.d -DTORCH_EXTENSION_NAME=matmul_sum_max -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/TH -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda-12.3/include -isystem /matx/u/aco/miniconda3/envs/myenv/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_89,code=compute_89 -gencode=arch=compute_89,code=sm_89 --compiler-options '-fPIC' -std=c++17 -c /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu -o cuda.cuda.o 
-/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: identifier "dtype" is undefined
-      auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device);
-                                            ^
-
-/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: namespace "torch" has no member "float32"
-      auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device);
-                                                         ^
-
-/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: identifier "device" is undefined
-      auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device);
-                                                                  ^
-
-/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(24): error: a pointer to a bound function may only be used to call the function
-      auto out = torch::zeros({batch_size}, dtype=torch::float32, device=a.device);
-                                                                           ^
-
-/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu(30): error: no instance of overloaded function "at::Tensor::view" matches the argument list
-            argument types are: (int, int)
-            object type is: at::Tensor
-      return out.view(-1, 1);
-                 ^
-
-5 errors detected in the compilation of "/sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/cuda.cu".
-[2/3] c++ -MMD -MF main.o.d -DTORCH_EXTENSION_NAME=matmul_sum_max -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\"_gcc\" -DPYBIND11_STDLIB=\"_libstdcpp\" -DPYBIND11_BUILD_ABI=\"_cxxabi1011\" -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/TH -isystem /matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda-12.3/include -isystem /matx/u/aco/miniconda3/envs/myenv/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -fPIC -std=c++17  -c /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/main.cpp -o main.o 
-ninja: build stopped: subcommand failed.
-Using /sailhome/aco/.cache/torch_extensions/py311_cu121 as PyTorch extensions root...
-Creating extension directory /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max...
-Detected CUDA files, patching ldflags
-Emitting ninja build file /sailhome/aco/.cache/torch_extensions/py311_cu121/matmul_sum_max/build.ninja...
-/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py:1965: UserWarning: TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. 
-If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'].
-  warnings.warn(
-Building extension module matmul_sum_max...
-Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)
-Traceback (most recent call last):
-  File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 2105, in _run_ninja_build
-    subprocess.run(
-  File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/subprocess.py", line 571, in run
-    raise CalledProcessError(retcode, process.args,
-subprocess.CalledProcessError: Command '['ninja', '-v']' returned non-zero exit status 1.
-
-The above exception was the direct cause of the following exception:
-
-Traceback (most recent call last):
-  File "/matx/u/aco/KernelBenchInternal/src/scratch/model_new.py", line 40, in <module>
-    matmul_sum_max = load_inline(
-                     ^^^^^^^^^^^^
-  File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 1647, in load_inline
-    return _jit_compile(
-           ^^^^^^^^^^^^^
-  File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 1722, in _jit_compile
-    _write_ninja_file_and_build_library(
-  File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 1834, in _write_ninja_file_and_build_library
-    _run_ninja_build(
-  File "/matx/u/aco/miniconda3/envs/myenv/lib/python3.11/site-packages/torch/utils/cpp_extension.py", line 2121, in _run_ninja_build
-    raise RuntimeError(message) from e
-RuntimeError: Error building extension 'matmul_sum_max'
diff --git a/src/scratch/model.py b/src/scratch/model.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/scratch/model_new.py b/src/scratch/model_new.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/scratch/prompt.txt b/src/scratch/prompt.txt
deleted file mode 100644
index 78dbb009..00000000
--- a/src/scratch/prompt.txt
+++ /dev/null
@@ -1,137 +0,0 @@
-
-    You write custom CUDA kernels to replace the pytorch operators in the given architecture to get speedups. 
-
-    You have complete freedom to choose the set of operators you want to replace. You may make the decision to replace some operators with custom CUDA kernels and leave others unchanged. You may replace multiple operators with custom implementations, consider operator fusion opportunities (combining multiple operators into a single kernel, for example, combining matmul+relu), or algorithmic changes (such as online softmax). You are only limited by your imagination.
-
-    
-        Here's an example to show you the syntax of inline embedding custom CUDA operators in torch: The example given architecture is: 
-
-        ```
-        import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-class Model(nn.Module):
-    def __init__(self) -> None:
-        super().__init__()
-
-    def forward(self, a, b):
-        return a + b
-
-def get_inputs():
-    # randomly generate input tensors based on the model architecture
-    a = torch.randn(1, 128).cuda()
-    b = torch.randn(1, 128).cuda()
-    return [a, b]
-
-def get_init_inputs():
-    # randomly generate tensors required for initialization based on the model architecture
-    return []
-        ``` 
-
-        The example new arch with custom CUDA kernels looks like this: 
-        ```
-        import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.utils.cpp_extension import load_inline
-
-# Define the custom CUDA kernel for element-wise addition
-elementwise_add_source = """
-#include <torch/extension.h>
-#include <cuda_runtime.h>
-
-__global__ void elementwise_add_kernel(const float* a, const float* b, float* out, int size) {
-    int idx = blockIdx.x * blockDim.x + threadIdx.x;
-    if (idx < size) {
-        out[idx] = a[idx] + b[idx];
-    }
-}
-
-torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b) {
-    auto size = a.numel();
-    auto out = torch::zeros_like(a);
-
-    const int block_size = 256;
-    const int num_blocks = (size + block_size - 1) / block_size;
-
-    elementwise_add_kernel<<<num_blocks, block_size>>>(a.data_ptr<float>(), b.data_ptr<float>(), out.data_ptr<float>(), size);
-
-    return out;
-}
-"""
-
-elementwise_add_cpp_source = "torch::Tensor elementwise_add_cuda(torch::Tensor a, torch::Tensor b);"
-
-# Compile the inline CUDA code for element-wise addition
-elementwise_add = load_inline(
-    name='elementwise_add',
-    cpp_sources=elementwise_add_cpp_source,
-    cuda_sources=elementwise_add_source,
-    functions=['elementwise_add_cuda'],
-    verbose=True,
-    extra_cflags=[''],
-    extra_ldflags=['']
-)
-
-class ModelNew(nn.Module):
-    def __init__(self) -> None:
-        super().__init__()
-        self.elementwise_add = elementwise_add
-
-    def forward(self, a, b):
-        return self.elementwise_add.elementwise_add_cuda(a, b)
-
-def get_inputs():
-    # randomly generate input tensors based on the model architecture
-    a = torch.randn(4096).cuda()
-    b = torch.randn(4096).cuda()
-    return [a, b]
-
-def get_init_inputs():
-    # randomly generate tensors required for initialization based on the model architecture
-    return []
-        ``` 
-
-        
-    You are given the following architecture: 
-
-    ```
-    import torch
-import torch.nn as nn
-
-class Model(nn.Module):
-    """
-    Simple model that performs a single matrix multiplication (C = A * B)
-    """
-    def __init__(self):
-        super(Model, self).__init__()
-    
-    def forward(self, A: torch.Tensor, B: torch.Tensor) -> torch.Tensor:
-        """
-        Performs matrix multiplication.
-
-        Args:
-            A: Input tensor of shape (M, K).
-            B: Input tensor of shape (K, N).
-
-        Returns:
-            Output tensor of shape (M, N).
-        """
-        return torch.matmul(A, B)
-
-M = 1024
-K = 4096
-N = 2048
-
-def get_inputs():
-    A = torch.randn(M, K)
-    B = torch.randn(K, N)
-    return [A, B]
-
-def get_init_inputs():
-    return []  # No special initialization inputs needed
-    ```
-    Optimize the architecture named Model with custom CUDA operators! Name your optimized output architecture ModelNew. Output the new code in codeblocks. Please generate real code, NOT pseudocode, make sure the code compiles and is fully functional.
-
-    
\ No newline at end of file
diff --git a/src/scratch/test.py b/src/scratch/test.py
deleted file mode 100644
index dbead51c..00000000
--- a/src/scratch/test.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import random
-import numpy as np
-
-# load model and the modified model
-from model import Model
-from model import get_inputs
-from model import get_init_inputs
-from model_new import ModelNew
-
-torch.cuda.synchronize()
-
-
-def set_seed(seed):
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed(seed)
-    random.seed(seed)
-    np.random.seed(seed)
-
-
-def check_correctness():
-    # run the model and check correctness
-    with torch.no_grad():
-
-        # generate inputs and init_inputs, and instantiate models
-        set_seed(42)
-        inputs = get_inputs()
-        set_seed(42)
-        init_inputs = get_init_inputs()
-
-        # move to GPU
-        inputs = [x.cuda() if isinstance(x, torch.Tensor) else x for x in inputs]
-        init_inputs = [
-            x.cuda() if isinstance(x, torch.Tensor) else x for x in init_inputs
-        ]
-
-        set_seed(42)
-        model = Model(*init_inputs).cuda()
-        set_seed(42)
-        model_new = ModelNew(*init_inputs).cuda()
-
-        # forward pass
-        output = model(*inputs)
-        output_new = model_new(*inputs)
-
-        # move to CPU
-        torch.cuda.synchronize()
-        output = output.cpu()
-        output_new = output_new.cpu()
-
-        # check correctness
-        assert output.shape == output_new.shape
-        assert torch.allclose(output, output_new, atol=1e-02)
-
-    return "PASS"
-
-
-def run(random_seed=42):
-
-    # run both models and check correctness
-    check_correctness()
-
-    return "PASS"
-
-
-if __name__ == "__main__":
-    print(run())
diff --git a/src/unit_tests/test_dataset.py b/src/unit_tests/test_dataset.py
deleted file mode 100644
index a23768e0..00000000
--- a/src/unit_tests/test_dataset.py
+++ /dev/null
@@ -1,48 +0,0 @@
-
-import pytest
-from src.dataset import get_code_hash
-
-"""
-Usage 
-pytest test_dataset.py
-"""
-
-
-def test_get_code_hash():
-    """
-    Test collision and equivalence checking
-    """
-
-    code_snippet_batch_1_v1 = """
-    import torch 
-    # This is for a single batch
-    '''
-    Some random multi-line comment
-    '''
-    B = 1
-    """
-    
-    code_snippet_batch_1_v2 = """
-    import torch 
-    '''
-    More problem descriptions (updated)
-    '''
-    # low batch setting
-
-    B = 1
-    """
-
-    code_snippet_batch_64 = """
-    import torch 
-    # This is for a single batch
-    '''
-    Some random multi-line comment
-    '''
-    B = 64
-    """
-
-    assert get_code_hash(code_snippet_batch_1_v1) == get_code_hash(code_snippet_batch_1_v2), \
-        "Hash should be equal for semantically equivalent code with different comments"
-    
-    assert get_code_hash(code_snippet_batch_1_v1) != get_code_hash(code_snippet_batch_64), \
-        "Hash should differ for code with different batch sizes"
\ No newline at end of file