Reproducing results from "Beat GPT-4o at Python by Searching with 100 Dumb LLaMAs"

README.md

See rune2e.sh for info on how to run the experiment.

client.py

from datetime import datetime
import json
from pathlib import Path
from dataclasses import dataclass, asdict

import modal

image = modal.Image.debian_slim(python_version="3.11").pip_install(
    "openai==1.38.0", "datasets==2.20.0"
)

app = modal.App("eval-infinite-monkeys", image=image)

volume = modal.Volume.from_name("humaneval", create_if_missing=True)
DATA_DIR = Path("/mnt/humaneval")

default_system_prompt = "Write the body for the Python function provided in the prompt below. Do not write anything else. Your output will be directly concatenated with the prompt and the resulting function executed against tests."

MINUTES = 60  # seconds
HOURS = 60 * MINUTES


@dataclass
class CompletionParams:
    model: str = None
    max_tokens: int = 1024
    temperature: float = 0.7
    top_p: float = 0.9
    frequency_penalty: float = 0
    presence_penalty: float = 0
    n: int = 1
    stop: str = None
    seed: int = None


@dataclass
class ClientParams:
    app_name: str = "example-infinite-monkeys"
    workspace: str = None
    api_key: str = "super-secret-token"

    @property
    def url(self):
        return f"https://{self.workspace}--{self.app_name}-serve.modal.run/v1"


@app.local_entrypoint()
def main(
    app_name: str = "example-infinite-monkeys",
    workspace: str = None,
    api_key: str = "super-secret-token",
    model: str = None,
    max_tokens: int = 1024,
    temperature: float = 0.7,
    top_p: float = 0.9,
    frequency_penalty: float = 0,
    presence_penalty: float = 0,
    n: int = 1,
    stop: str = None,
    seed: int = None,
    data_dir: str = "dev-llm",
    subsample: int = 1,
    system_prompt: str = default_system_prompt,
    dry_run: bool = True,
):
    if workspace is None:
        workspace = modal.config._profile

    client_params = ClientParams(app_name, workspace, api_key)

    completion_params = CompletionParams(
        model=model,
        max_tokens=max_tokens,
        temperature=temperature,
        top_p=top_p,
        frequency_penalty=frequency_penalty,
        presence_penalty=presence_penalty,
        n=n,
        stop=stop,
        seed=seed,
    )

    save_dataset.remote(path=data_dir, subsample=subsample)

    results = run_human_eval.remote(
        client_params=client_params,
        completion_params=completion_params,
        system_prompt=system_prompt,
        data_dir=data_dir,
        dry_run=dry_run,
    )
    if results:
        with open("/tmp/results.jsonl", "w") as f:
            f.writelines(json.dumps(result) + "\n" for result in results)
        print(f"results saved locally to {f.name}")


@app.function(volumes={DATA_DIR: volume}, timeout=1 * HOURS)
def run_human_eval(
    client_params: ClientParams,
    completion_params: CompletionParams,
    data_dir="dev-llm",
    system_prompt: str = default_system_prompt,
    dry_run=True,
):
    dataset = load_dataset(data_dir)

    timestamp = datetime.utcnow().isoformat() + "Z"
    output_dir = Path(DATA_DIR) / data_dir / f"run-{timestamp}"
    output_dir.mkdir(parents=True, exist_ok=True)
    handles = []
    for i, item in enumerate(dataset):
        handles.append(
            run_item.spawn(
                item,
                client_params,
                completion_params,
                system_prompt,
                output_dir,
                dry_run,
            )
        )

    for handle in handles:
        result = handle.get()

    if not dry_run:
        return result


@app.function(volumes={DATA_DIR: volume}, timeout=1 * HOURS)
def run_item(
    item: dict,
    client_params: ClientParams,
    completion_params: CompletionParams,
    system_prompt: str,
    output_dir: Path,
    dry_run: bool,
):
    client = create_client(client_params)
    if completion_params.model:
        print(
            Colors.BOLD,
            f"🧠: Using model {completion_params.model}. This may trigger a model load on first call!",
            Colors.END,
            sep="",
        )
    else:
        print(
            Colors.BOLD,
            f"🔎: Looking up available models on server at {client.base_url}. This may trigger a model load!",
            Colors.END,
            sep="",
        )
        model = client.models.list().data[0]
        model = model.id
        print(
            Colors.BOLD,
            f"🧠: Using {model}",
            Colors.END,
            sep="",
        )
        completion_params.model = model

    prompt = item["prompt"]
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": prompt},
    ]

    per_request = 250
    ct, completions = completion_params.n, []
    if not dry_run:
        while ct > 0:
            response = get_completion(
                client,
                messages=messages,
                **asdict(completion_params) | dict(n=min(ct, per_request)),
            )
            if response:
                completions += [
                    {
                        "task_id": item["task_id"],
                        "completion": choice.message.content,
                    }
                    for choice in response.choices
                ]
            ct -= per_request

        index = item["task_id"].split("/")[-1]
        output_path = output_dir / f"{index}.jsonl"
        output_path.parent.mkdir(parents=True, exist_ok=True)
        with open(output_path, "w") as f:
            f.writelines(json.dumps(completion) + "\n" for completion in completions)

        print(Colors.GREEN + f"Completions saved to {output_path}" + Colors.END)


class Colors:
    """ANSI color codes"""

    GREEN = "\033[0;32m"
    RED = "\033[0;31m"
    BLUE = "\033[0;34m"
    GRAY = "\033[0;90m"
    BOLD = "\033[1m"
    END = "\033[0m"


def get_completion(client, **kwargs):
    try:
        response = client.chat.completions.create(**kwargs)
        return response
    except Exception as e:
        print(Colors.RED, f"Error during API call: {e}", Colors.END, sep="")
        return None


def create_client(client_params: ClientParams):
    from openai import OpenAI

    client = OpenAI(api_key=client_params.api_key)
    client.base_url = client_params.url

    return client


@app.function(volumes={DATA_DIR: volume})
def save_dataset(path="dev-llm", subsample: int = 1):
    import datasets

    path = DATA_DIR / path

    ds = datasets.load_dataset(
        "openai/openai_humaneval",
        split=datasets.ReadInstruction("test", to=subsample, unit="%"),
    )

    ds.to_json(path / "data.jsonl")

    volume.commit()


def load_dataset(path="dev-llm"):
    import datasets

    path = DATA_DIR / path

    ds = datasets.load_dataset(path=str(path), data_files="data.jsonl")

    return ds["train"]

download_llama.py

import modal

MODELS_DIR = "/llamas"

DEFAULT_NAME = "meta-llama/Meta-Llama-3.1-8B-Instruct"
DEFAULT_REVISION = "8c22764a7e3675c50d4c7c9a4edb474456022b16"

volume = modal.Volume.from_name("llamas", create_if_missing=True)

image = (
    modal.Image.debian_slim(python_version="3.10")
    .pip_install(
        [
            "huggingface_hub",  # download models from the Hugging Face Hub
            "hf-transfer",  # download models faster with Rust
        ]
    )
    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
)


MINUTES = 60
HOURS = 60 * MINUTES


app = modal.App(image=image, secrets=[modal.Secret.from_name("huggingface")])


@app.function(volumes={MODELS_DIR: volume}, timeout=4 * HOURS)
def download_model(model_name, model_revision, force_download=False):
    from huggingface_hub import snapshot_download

    volume.reload()

    snapshot_download(
        model_name,
        local_dir=MODELS_DIR,
        ignore_patterns=[
            "*.pt",
            "*.bin",
            "*.pth",
            "original/*",
        ],  # Ensure safetensors
        revision=model_revision,
        force_download=force_download,
    )

    volume.commit()


@app.local_entrypoint()
def main(
    model_name: str = DEFAULT_NAME,
    model_revision: str = DEFAULT_REVISION,
    force_download: bool = False,
):
    download_model.remote(model_name, model_revision, force_download)

eval.py

from pathlib import Path

import modal

app = modal.App("humaneval-sandbox")

volume = modal.Volume.from_name("humaneval", create_if_missing=True)

sandbox_image = (
    modal.Image.debian_slim()
    .apt_install("git")
    .run_commands(
        "git clone https://github.com/modal-labs/human-eval.git",
        "pip install -e human-eval",
    )
)

MINUTES = 60


@app.function(volumes={"/humaneval": volume})
def run_humaneval(sample_file_path: str, problem_file_path: str):
    with modal.Volume.ephemeral() as vol:
        with vol.batch_upload() as batch:
            batch.put_file(sample_file_path, "samples.jsonl")
            batch.put_file(problem_file_path, "problems.jsonl")

        print(f"Starting sandbox for {sample_file_path}")
        sandbox = modal.Sandbox.create(
            "bash",
            "-c",
            "evaluate_functional_correctness vol/samples.jsonl --problem_file=vol/problems.jsonl --n_workers=32",
            image=sandbox_image,
            volumes={"/vol": vol},
            timeout=5 * MINUTES,
            cpu=32,
        )

        try:
            sandbox.wait_for(4 * MINUTES)
            print(f"Finished sandbox for {sample_file_path}")
        except TimeoutError:
            print("Sandbox timed out")

        if sandbox.returncode == 0:
            print(sandbox.stdout.read())
            data = b""
            for chunk in vol.read_file("samples.jsonl_results.jsonl"):
                data += chunk
            with open(f"{sample_file_path}_results.jsonl", "wb") as f:
                f.write(data)
        else:
            print(f"Tests failed with code {sandbox.returncode}")
            print(sandbox.stderr.read())


@app.function(volumes={"/humaneval": volume}, timeout=10 * MINUTES)
def find_missing_files():
    import os

    volume.reload()

    # Find all files matching /humaneval/{env}/{run}/{id}.jsonl
    envs = [element for element in Path("/humaneval").iterdir() if element.is_dir()]
    for env in envs:
        print(f"looking in {env}")
        problem_file = env / "data.jsonl"

        pattern = "*/*.jsonl"
        handles = []
        for file_path in env.glob(pattern):
            # Skip files that end with _results.jsonl
            if str(file_path).endswith("_results.jsonl"):
                continue

            print(f"Checking {file_path}")
            # Check if the corresponding results file exists
            results_file = f"{file_path}_results.jsonl"
            if not os.path.exists(results_file):
                # If it doesn't exist, run run_humaneval
                handles.append(run_humaneval.spawn(file_path, problem_file))

        for handle in handles:
            handle.get()


@app.local_entrypoint()
def main():
    find_missing_files.remote()

inference.py

import modal

vllm_image = modal.Image.debian_slim(python_version="3.10").pip_install(
    "vllm==0.5.3post1"
)


MODELS_DIR = "/llamas"
MODEL_NAME = "meta-llama/Meta-Llama-3.1-8B-Instruct"
MODEL_REVISION = "8c22764a7e3675c50d4c7c9a4edb474456022b16"

try:
    volume = modal.Volume.lookup("llamas", create_if_missing=False)
except modal.exception.NotFoundError:
    raise Exception("Download models first with modal run download_llama.py")

app = modal.App("example-infinite-monkeys")

N_GPU = 1  # tip: for best results, first upgrade to more powerful GPUs, and only then increase GPU count
TOKEN = (
    "super-secret-token"  # auth token. for production use, replace with a modal.Secret
)

MINUTES = 60  # seconds
HOURS = 60 * MINUTES


@app.function(
    image=vllm_image,
    gpu=modal.gpu.A100(count=N_GPU, size="40GB"),
    container_idle_timeout=5 * MINUTES,
    timeout=24 * HOURS,
    allow_concurrent_inputs=2,
    volumes={MODELS_DIR: volume},
    concurrency_limit=10,
)
@modal.asgi_app()
def serve():
    import fastapi
    import vllm.entrypoints.openai.api_server as api_server
    from vllm.engine.arg_utils import AsyncEngineArgs
    from vllm.engine.async_llm_engine import AsyncLLMEngine
    from vllm.entrypoints.logger import RequestLogger
    from vllm.entrypoints.openai.serving_chat import OpenAIServingChat
    from vllm.entrypoints.openai.serving_completion import (
        OpenAIServingCompletion,
    )
    from vllm.usage.usage_lib import UsageContext

    volume.reload()  # ensure we have the latest version of the weights

    # create a fastAPI app that uses vLLM's OpenAI-compatible router
    web_app = fastapi.FastAPI(
        title=f"OpenAI-compatible {MODEL_NAME} server",
        description="Run an OpenAI-compatible LLM server with vLLM on modal.com",
        version="0.0.1",
        docs_url="/docs",
    )

    # security: CORS middleware for external requests
    http_bearer = fastapi.security.HTTPBearer(
        scheme_name="Bearer Token",
        description="See code for authentication details.",
    )
    web_app.add_middleware(
        fastapi.middleware.cors.CORSMiddleware,
        allow_origins=["*"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

    # security: inject dependency on authed routes
    async def is_authenticated(api_key: str = fastapi.Security(http_bearer)):
        if api_key.credentials != TOKEN:
            raise fastapi.HTTPException(
                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                detail="Invalid authentication credentials",
            )
        return {"username": "authenticated_user"}

    router = fastapi.APIRouter(dependencies=[fastapi.Depends(is_authenticated)])

    # wrap vllm's router in auth router
    router.include_router(api_server.router)
    # add authed vllm to our fastAPI app
    web_app.include_router(router)

    engine_args = AsyncEngineArgs(
        model=MODELS_DIR + "/" + MODEL_NAME,
        tensor_parallel_size=N_GPU,
        gpu_memory_utilization=0.90,
        max_model_len=2048,
        enforce_eager=False,  # capture the graph for faster inference, but slower cold starts (30s > 20s)
    )

    engine = AsyncLLMEngine.from_engine_args(
        engine_args, usage_context=UsageContext.OPENAI_API_SERVER
    )

    model_config = get_model_config(engine)

    request_logger = RequestLogger(max_log_len=2048)

    api_server.openai_serving_chat = OpenAIServingChat(
        engine,
        model_config=model_config,
        served_model_names=[MODEL_NAME],
        chat_template=None,
        response_role="assistant",
        lora_modules=[],
        prompt_adapters=[],
        request_logger=request_logger,
    )
    api_server.openai_serving_completion = OpenAIServingCompletion(
        engine,
        model_config=model_config,
        served_model_names=[MODEL_NAME],
        lora_modules=[],
        prompt_adapters=[],
        request_logger=request_logger,
    )

    return web_app


def get_model_config(engine):
    import asyncio

    try:  # adapted from vLLM source -- https://github.com/vllm-project/vllm/blob/507ef787d85dec24490069ffceacbd6b161f4f72/vllm/entrypoints/openai/api_server.py#L235C1-L247C1
        event_loop = asyncio.get_running_loop()
    except RuntimeError:
        event_loop = None

    if event_loop is not None and event_loop.is_running():
        # If the current is instanced by Ray Serve,
        # there is already a running event loop
        model_config = event_loop.run_until_complete(engine.get_model_config())
    else:
        # When using single vLLM without engine_use_ray
        model_config = asyncio.run(engine.get_model_config())

    return model_config

plot-results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4352855e-430c-44db-8c6c-27fdf9bc6a7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -qqq pandas numpy matplotlib seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9c30fccc-767e-4b9a-bb9f-b1c76659e2f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dev  dev-llm  test\n"
     ]
    }
   ],
   "source": [
    "!ls volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "75f3dfe7-f1fb-4d96-85b7-700992ae54a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9d85a131-e2c1-421a-88cb-3576f2dc0e4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data.jsonl\t\t\t run-2024-08-05T00:07:06.573957Z\n",
      "run-2024-08-04T23:51:56.654826Z  run-2024-08-05T10:49:47.347535Z\n",
      "run-2024-08-05T00:00:13.523706Z  run-2024-08-05T15:36:01.972189Z\n"
     ]
    }
   ],
   "source": [
    "!ls volume/test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bfa2f045-5691-4a5a-a6f3-f123a75b5a17",
   "metadata": {},
   "outputs": [],
   "source": [
    "run_dirs = list(sorted((Path(\"volume\") / \"test\").glob(\"run-*\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6a12b168-cc8a-43ae-8a7d-ba8a59bb7090",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PosixPath('volume/test/run-2024-08-04T23:51:56.654826Z'),\n",
       " PosixPath('volume/test/run-2024-08-05T00:00:13.523706Z'),\n",
       " PosixPath('volume/test/run-2024-08-05T00:07:06.573957Z'),\n",
       " PosixPath('volume/test/run-2024-08-05T10:49:47.347535Z'),\n",
       " PosixPath('volume/test/run-2024-08-05T15:36:01.972189Z')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_dirs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "72b67762-9060-4b29-88b8-e11116ed42d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "skipping incomplete run volume/test/run-2024-08-05T15:36:01.972189Z\n"
     ]
    }
   ],
   "source": [
    "for run_dir in reversed(run_dirs):\n",
    "    if len(list(run_dir.iterdir())) < 150:\n",
    "        print(f\"skipping incomplete run {run_dir}\")\n",
    "    else:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "418fa199-906c-473b-8c6f-d76a1f826049",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "164"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_result_paths = list(run_dir.glob(\"*.jsonl_results.jsonl\"))\n",
    "len(all_result_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "037da950-f4a2-4f1f-bfdd-cb777c6b80e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "data = []\n",
    "for path in all_result_paths:\n",
    "    data += [json.loads(line) for line in path.read_text(encoding='utf-8').splitlines()]\n",
    "\n",
    "for element in data:\n",
    "    del element[\"completion\"]\n",
    "\n",
    "df = pd.DataFrame.from_records(data)\n",
    "\n",
    "df.sample(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b8758e35-477c-498f-b26f-4a4aa7b20b4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "gb = df.groupby(\"task_id\")\n",
    "gb.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5ecf6b40-6289-46aa-952c-247e81ceaf65",
   "metadata": {},
   "outputs": [],
   "source": [
    "passes = gb[\"passed\"].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0bafd6f4-c367-4ffb-a92e-0954e3cc7a35",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "from typing import List, Union\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "def estimate_pass_at_k(\n",
    "    num_samples: Union[int, List[int], np.ndarray],\n",
    "    num_correct: Union[List[int], np.ndarray],\n",
    "    k: int\n",
    ") -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Estimates pass@k of each problem and returns them in an array.\n",
    "    \"\"\"\n",
    "\n",
    "    def estimator(n: int, c: int, k: int) -> float:\n",
    "        \"\"\"\n",
    "        Calculates 1 - comb(n - c, k) / comb(n, k).\n",
    "        \"\"\"\n",
    "        if n - c < k:\n",
    "            return 1.0\n",
    "        return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))\n",
    "\n",
    "    if isinstance(num_samples, int):\n",
    "        num_samples_it = itertools.repeat(num_samples, len(num_correct))\n",
    "    else:\n",
    "        assert len(num_samples) == len(num_correct)\n",
    "        num_samples_it = iter(num_samples)\n",
    "\n",
    "    return np.array([estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a0db7a1a-696b-44dd-8ee5-84e39cdd2013",
   "metadata": {},
   "outputs": [],
   "source": [
    "pass_at_ks = {}\n",
    "\n",
    "for k in [1, 10, 100, 1000]:\n",
    "    pass_at_ks[k] = estimate_pass_at_k(1000, passes, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "65b8b318-a5cf-4149-b2bb-50dd83c22982",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: np.float64(0.6636280487804879),\n",
       " 10: np.float64(0.8401978876608354),\n",
       " 100: np.float64(0.9059827093679016),\n",
       " 1000: np.float64(0.9512195121951219)}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pass_at_k = {k: np.mean(v) for k, v in pass_at_ks.items()}\n",
    "pass_at_k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0236e572-7047-4288-b88a-1801862e9e1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_df = pd.DataFrame(\n",
    "    {\"k\": pass_at_k.keys(),\n",
    "     \"pass@k\": pass_at_k.values()}\n",
    ")\n",
    "plot_df[\"fail@k\"] = 1 - plot_df[\"pass@k\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "557a66c8-9217-4c13-91cf-e93ed91853e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sns.set_theme(style='dark')\n",
    "plt.style.use(\"dark_background\")\n",
    "\n",
    "plt.rcParams['font.sans-serif'] = [\"Inter\", \"Arial\", \"DejaVu Sans\", \"Liberation Sans\", \"Bitstream Vera Sans\", \"sans-serif\"]\n",
    "\n",
    "sns.despine()\n",
    "\n",
    "sns.set_context(\"talk\", rc={\"lines.linewidth\": 2.5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "56a8cd53-60d8-45a1-b242-e74f8e615d0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "gpt4o_benchmark = 0.902"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "aa9d0fdd-85c5-4d02-9995-d2d2593ee817",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fg = sns.lineplot(\n",
    "    x=\"k\",\n",
    "    y=\"pass@k\",\n",
    "    data=plot_df,\n",
    "    color=\"#7FEE64\",\n",
    "    linewidth=6,\n",
    "    alpha=0.9,\n",
    "    label=\"LLaMA 3.1 8B pass@k\"\n",
    "  )\n",
    "\n",
    "initial_lim = fg.axes.get_xlim()\n",
    "fg.axes.hlines(\n",
    "      gpt4o_benchmark, *initial_lim,\n",
    "      linestyle=\"--\",\n",
    "      alpha=0.6,\n",
    "      zorder=-1,\n",
    "      label=\"GPT-4o fail@1\"\n",
    "  )\n",
    "fg.axes.set_xlim(*initial_lim);\n",
    "fg.axes.set_ylabel(\"\");\n",
    "fg.axes.set_ylim(0, 1);\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "7d406876-6ff2-4b7a-9464-1f638c9e3aba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkoAAAHXCAYAAABDM3WZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABjqUlEQVR4nO3dd3hUVf4/8Pek94SE9F5IQgqQUEInCYS2dBBQQawIgot+sbAKIl3dn6tYVgFXmoooHVFDSYBAEEgBkpBCeu+9t/v7I2YkJgNJZpJJeb+e5zxr7tx77pnZa/L23jPnIwIggIiIiIhaUZD3AIiIiIh6KgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCTo00HJwsICP//8M4qLi1FSUoLjx4/D0tJS3sMiIiKiXkKEPrrgpLq6Ou7evYuamhps3LgRgiBg+/bt0NDQwJAhQ1BZWSnvIRIREVEvIPTF9s9//lOor68X7O3txdtsbGyEuro64fXXX5f7+NjY2NjY2Nh6fuuzd5QuXrwINTU1jB8/vsX2y5cvAwC8vb27f1BERETUq3TbHCVjY2MsW7YMu3fvRnBwMCorKyEIAgIDA9t1vLe3N86ePYvc3FxUVlYiOjoaW7duhYaGRpv7u7q6IjIystX2qKgouLi4SPVeiIiIqH9Q6q4TLV26FJ9++mmnjl27di12794NBQUFpKWlIS0tDS4uLti0aRMWLlyI8ePHo6ioqMUx+vr6rbYBQGFhIQYMGNCpcRAREVH/0m13lEpLS3HhwgXs3LkT8+fPx9atW9t1nKenpzhgrVy5ElZWVhg+fDjs7OwQEhICFxcX7Nu3rwtHTkRERP2ZXCZHrVmzRhAEQQgMDHzkfidPnhQEQRAOHDjQ6jUHBwehvr5eEARBcHd3b/Fadna28PXXX7c65ssvvxRyc3PlPjmMjY2NjY2Nree3Hr2OkqamJqZPnw4A2Lt3b6vX4+PjERAQAAB44oknWrwWFRUFV1fXVse4uLjg/v37XTBaIiIi6mt6dFDy8PCAmpoaqqurcevWrTb3CQoKAgCMHj26xfYzZ85g9OjRsLW1FW+ztrbGuHHjcObMma4bNBEREfUZ3TaZuzMcHR0BAKmpqaivr29zn4SEBACAk5NTi+379u3D2rVrcfr0afGCk9u2bUNaWhr27NkjszEmJibCyMgI1dXVSE5Ollm/RERE1HVsbGygpqaG3Nxc2NnZSdyvRwclfX19AE3fVJOk+bW/f5OtsrISvr6++OSTT3D48GGIRCJcunQJr732GioqKmQ2RiMjI2hqakJTUxMGBgYy65eIiIi6npGR0SNf79FBSU1NDQBQW1srcZ+amhoATSVL/i4tLQ2LFi3qmsH9qbq6GpqamqioqEBMTEyXnouIiIhkw9nZGZqamqiurn7kfj06KDUPXkVFReI+qqqqAICqqqpuGdPfJScnw8DAADExMRgxYoRcxkBEREQdExISguHDhz922kyPnszdvGBk8yO4tjS/1tbikkRERETS6NFBKS4uDgBgZWUFJaW2b37Z29u32JeIiIhIVnp0UAoPD0dNTQ3U1NQwatSoNveZMGECAODGjRvdOTQiIiLqB3p0UCovL4e/vz+ApvIlf+fg4ABfX18AwLFjx7p1bERERNT39eigBADbtm1DY2Mjli9fjpdeekm83cTEBEeOHIGioiJOnjyJe/fuyXGURERE1Fd1S60UCwsLIS8vT9zKysoEQRCE2traFtvffPPNVseuW7dOaGhoEARBEFJSUoTQ0FChqqpKEARBiI6OFgwMDORWAyYkJEQQBEEICQmRez0aNjY2NjY2tva19v797rblARQVFTFw4MBW25WVlVts19DQaLXP7t27ERERgfXr18PLywtGRkZISUnBsWPHsGvXLpkuIElERETUrNuCUkpKCkQiUaePDwgIEBfAJaLOUVBQgLKysryHQUQkE3V1dWhsbOzSc/ToBSeJSHoaGhqYOXMmRo0aBRMTE3kPh4hIprKzs3Hr1i38+uuvqKyslHn/DEpEfZiGhgbefvtt2NraynsoRERdwsTEBHPmzIG7uzs+/PBDmYclBiWiPmzmzJmwtbVFeXk5vvvuO0RGRorrIxIR9Xaqqqpwc3PDsmXLYGtri5kzZ8p8uSAGJaI+rHmh1u+++w7BwcFyHg0RkWzV1NSIf7etWrUKo0aNknlQ6vHrKBFR5ygqKornJEVGRsp5NEREXaf5d5yJiQkUFGQbbRiUiPqoh+sj8nEbEfVlD/+Ok/U3exmUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIi6oFUVFSwbds2PHjwADU1NRAEAeHh4VL1uXnzZgiCgM2bN7fYPmnSJAiCgMDAQKn67whra2sIggBBELrtnJ3BoERE9KfAwMA2/4g8SvMv+kmTJnXhyP76Q9bcpk6d+sj9t23b1mL/x3nhhRfE+3700UdSjdXPzw+fffYZgoODkZaWhqqqKpSXlyMyMhKffPIJLC0tO9WvsbExli1bht27dyM4OBiVlZUy++NuaWmJ3bt3Izo6GhUVFaiqqkJiYiK+/fZbuLm5tXnMihUrWnzGza2urg55eXkICAjACy+80Ol1ffbs2YONGzfC0tISUVFRuHbtmtRBSVYUFBQwceJE7Ny5E0eOHMHFixdx7tw5fPbZZ1i4cCHU1NTkPUSZ4crcRES90DPPPIPz589LfH358uUd6u/ZZ58V//OyZcuwYcOGTldlf+WVVzBv3jzU1dUhKysLERERMDAwgJOTE1xdXfHCCy9g/vz5uHTpUof6Xbp0KT799NNOjelRRo8eDX9/f+jo6KC2thaJiYmora2Fg4MDnnvuOSxbtgxPPfWUxBWfq6urERISIv5ZTU0NNjY28PHxgY+PDxYvXoyZM2eioaGh3WPS1dXFsmXL0NjYiHHjxiE0NFTq9wkA+fn5iImJQX5+fqeOV1BQwIoVK/D+++/DysqqzX1effVVFBQU4L333sN///tfaYbbI/COEhFRL1JUVITs7GzMnz8fWlpabe7j4+MDa2trREdHt6tPe3t7jB8/Hg0NDSgtLYWpqSmmTZvW6TH++OOPmDp1KnR0dGBtbY1Ro0bB3t4egwYNQmBgILS1tXHkyBGoq6t3qN/S0lJcuHABO3fuxPz587F169ZOj/Fhhw4dgo6ODoKDg+Hg4IDBgwdj6NChMDU1xffffw9lZWV888030NHRafP47OxsTJgwQdxGjhwJIyMjrFixAg0NDZg6dSpefPHFDo3J0dERSkpKyMvLk1lIAoAvv/wSgwcPxpdfftnhY3V1dfHbb7/h22+/ha6uLr744gv4+fnByMgIysrKMDY2xpgxY/Dhhx+ipqYGX375JS5fvgw9PT2ZjV8eeEeJqJ9T0VaGtrGGvIfRKWU5lagtq5P3MLpVQ0MDvv/+e6xfvx5PPPEE9u/f32qfFStWAAAOHjyIDz744LF9Nt9NunTpEpKTk7Fy5Uo8++yz+O233zo1xqNHj7a5PTk5GUuXLkVOTg4MDQ0xadIk/P777+3ud//+/S3er7m5eafG9zAXFxcMGjQIALB69WqkpaWJXystLcXzzz+PuXPnQldXFxMmTMC5c+fa1a8gCDh06BBmz56NRYsWwc/PD3v27Gn3uJpDZFVVVQfeTdfR0tJCUFAQ3N3dcfz4caxevRp5eXkt9snNzUVubi7++OMPbN++HR988AHWrFmDc+fOwc/PD5WVlXIavXQYlIj6KTOPgZj83kgYOurJeyidJghA/oNiXNxyG1l3Ovcoobupqalh7ty5mD17Njw8PGBhYQElJSWkpqbit99+w0cffYTs7OxH9nHo0CGsX78eK1asaBWUNDU1sXDhQuTk5OD3339vV1Bqfkx3+PBhJCUlYeXKlZgzZw709PRQXFzc6ffaltzcXBQUFMDAwAAaGvIP6A/f1UpISGj1em1tLdLT0+Hs7Nyp0hjJyckAmiZmt4e1tbX4GACwsbFpMcfM29sbV65cga6uLhYsWIBZs2bBzc0N5ubmEAQBCQkJOH36ND7++GOUlpa26n/z5s14//338f7772PLli3tfh+HDx+Gu7s7PvzwQ2zYsOGx+5eXl2Pt2rXIysrC9u3b8dVXX4kDfHutXbsWu3fvRnl5OebNm9etE80fxkdvRP2Q1RgTPHFgcq8OSQAgEgGGjnpYfHAyrMaYyHs47TJ8+HD8+OOPWLJkCXR1dfHgwQMkJyfDysoKr7/+OsLCwmBnZ/fIPu7du4c7d+5gwoQJsLGxafHawoULoaWlhR9++AH19fWPHY+vry+sra1RUVGBkydP4vr160hMTISamhqWLl0qzVttk7OzMwwMDNDQ0NAjJibHxsaK73SMHTu21esmJiaws7NDfX09wsLCOtz/yJEjAQAxMTHt2r+6uhrXrl1DREREi5+bW0lJCQBg1qxZ+PbbbzFr1iyoqanh/v37yMzMhLOzM9577z3cvHkTAwYM6PB42zJ79mzMmzcPp0+fbldIetiOHTvwww8/4JlnnsGoUaPafdzWrVvx+eefIz8/H97e3nILSQCDElG/NP61oVBU6jv/+isqKWDcuiHyHka7pKWlYcmSJdDX14eFhQVGjBgBV1dXGBkZ4f3334epqWm7JsAePHgQCgoKrSZtP/zYrT2aH7udPHkSFRUVAJruHjzclywYGhpi/vz5OHPmDADg//2//4ekpCSZ9d9Z5eXl2LZtG4CmR3sLFy6Evr4+tLS04O3tjV9//RUqKirYtWsXUlNT29WnqqoqnJ2d8dVXX2HSpEkoKirCF1980a5jc3JyMGHCBLz66qsAWs9/unPnDoCmsDx79mzo6uqK54E5OTnBzMwMX3/9NZydnbFr166OfyBt2Lx5M8rKyvDSSy+12D5mzBhcunQJ5eXlKCwsxKlTp+Ds7IzPP/+8xV2wf/3rX2hoaMDq1asfey6RSISvvvoKmzZtQnJyMsaNGyf3QN13flMSUbuoaCvDxE1f3sOQOVN3A6hoy7ZqeFdITU3FTz/9hLKyshbbKyoqsGXLFly7dg3Tpk2DsbHxI/v54YcfUFdXh2eeeUa8zcrKCt7e3rh37x7u3r372LFoaWlhwYIFAP4KRw//8+jRo+Hk5NTu9/Z3c+fOFX9lPjc3FydOnEB9fT2eeuqpDt+Z6EoffPABnn32WRQXF+PYsWMoKChAWVkZAgMDoaGhgSVLluC9996TeHzz47HmVl1djejoaKxatQpHjhyBl5dXu0NWe0VEROCXX35BdXV1i+2FhYXiuVZPP/10p5cmaGZjY4Phw4fj559/bjEnycfHB4GBgfD19UV5eTlSU1MxdepU3Lx5s9VyCqmpqQgODn7skhYqKio4evQoVq1ahYiICIwdOxbx8fFSjV8WOEeJiEgO/Pz8MHPmTDg4OEBHR0f8B615YvGwYcPg7+8v8fjc3Fz4+/tj1qxZGDduHK5fv47ly5dDQUGh3XeTnnjiCWhqaiIrKwsXL14Ub09ISEBwcDDGjh2LFStW4J133unUeywoKMC1a9egoKAAc3NzWFhYwNHREcuWLUNQUBDS09M71a+sKSkpwc7ODvr6+qirq0NSUpJ4eYBBgwbhhRdewPXr15GRkdHm8X9fHkBRUREWFhYwNzfHnDlzkJ2djTfffLNDywO0h6KiIubMmYMpU6bA1tYWmpqa4utIR0cHWlpaGDRoEGJjYzt9Dj8/PwBN32R82Ndffw1VVVWsXr0aX3/9NQBAX18fR44caTMQhYeHY8KECdDW1m71HwlAU2g/efIkpkyZguvXr2PWrFkynx/XWQxKRP1MbVkdsiML+9xdpayIgl7xDTgtLS2cOnUKkydPfuR+BgYGj+3r4MGDmDVrFp555hlcv34dzzzzDOrr6/H999+3ayzNj92OHDnSas2kw4cPY+zYsVi+fDnefffdTq2efO3aNUyYMEH8s42NDf7zn/9g/vz5uHHjBlxdXduccNzdTp48iVmzZuHXX3/Fiy++iKysLACAnp4ePvvsMyxfvhw3btyAi4sLysvLWx3f/Hjs71xcXPDdd9/h9ddfh76+fou1qqRlamqKX3/9FcOGDXvkfu25jh6leQ5cXFyceJuHhwccHR1x8uRJcUgCmu5mrVixAsnJyVBVVW3RT/NjXS0trTaDUmBgIEaMGIFff/0VixYt6jHf9gP46I2oX7r26V001HduMcGeqKG+Edc/ffyjpp7g448/xuTJk5GQkIClS5fCysoKqqqqEIlEEIlEOHToEAC06xtWZ86cQWFhIRYvXgxfX184OjrC398fOTk5jz3W1tYW48ePBwB89913rV7/8ccfUVNTAwsLC0yZMqWD77JtycnJWLRoEaKiomBhYYG1a9fKpF9pzJo1C7NmzUJeXh6efPJJcUgCgOLiYjz//POIjo6GpaUl1qxZ06G+79+/L57ntXz5cokrfHfGgQMHMGzYMISFhWH27NkwMzODioqK+Dq6evUqgPZdR48ycOBAAGjxuTTf9QwKCmq1f3Z2dotQ1ax5NfaioqI2z+Pg4ACg6TPrSSEJYFAi6pdSb2TjpxWXkBdXjB5eZumRBAHIiyvGTysuIfWPx4cDeVNUVMSTTz4JAJgzZw6OHj2KtLQ01NbWivfpyB2A2tpa/PTTT9DT08P//vc/ABAHrcd59tlnxY9pwsLCWpXhKCoqEt8VkOWdkMbGRvH6TMOHD5dZv53VfCfo1q1bbd7dqq+vF3/jasSIER3uPyIiAqWlpVBQUICXl5d0g/2TiYkJpk6disrKSkydOhW//PILsrKyUFf31x1Vae8kNWv+TLS1tTvdh0gkgpeXF6Kjo1vNqWo2bdo0FBcX44033sCHH37Y6XN1BT56I+qnsu7k4/D837jgZDcyNDSEtrY2CgoKcP/+/VavKyoqdviP8cGDB7Fq1SrY2NiguLgYp0+fbtdxzd+WKyoqQk1NTZv7KCoqwtDQEPPmzZM4t6QzlJSUWvyvPHUkAHS2fplIJAIgu/DS/DgsOjoaBQUFrV7X09ODo6OjTM7VfCfJzs5OfK4HDx4AAMaPH49PPvmkxf6GhobiO07NlixZgkGDBj1yQvytW7cwbdo0+Pv746233oIgCD1mwr/8r1IikqvasjoUlJXIexj9QvN6PTo6OlBXV2/1iOGZZ5557Lfd/u6PP/7A0aNHYWBggICAAImh52He3t6wtbVFQ0MDhgwZInFStZKSEjIzM2FoaIglS5bgm2++6dDY2qKsrIxZs2YBgNy/9g38Nfdm1KhR0NHRaXVXSUlJCT4+PgDQqUnRw4YNE4extha07Izm60jStfL6669L/cit2fXr1wE03fG5ffs2AODOnTuIi4vDggUL8NJLL2Hfvn0Amkqc7N+/v0WgXLBgAfbs2YOEhITH1um7desWpk6divPnz+Ptt98GgB4RlvjojYiom5SWluLu3btQVlbGF1980WLC68KFC/H55593an7G0qVL4efn1+51c5ofpQUGBj7ym2f19fX44YcfALR/TSVHR0d8+OGHGDx4cKvXHBwccObMGTg4OKC8vFz8B/ZhQUFBSEpKwrp169p1Pmn9/PPPqK6uhqGhIY4cOQJTU1Pxa3p6evj2228xePBgNDY2tjmX61Hc3Nxw4MABAE1zdzpSruVR7t+/j/z8fFhYWGDr1q3iR6gikQivvPIK3nnnHZnN87l16xZycnLw3HPPie8ACoKAVatWoba2Fnv37kVWVhbCw8ORmZmJ8ePHix9Vpqam4vjx48jMzMSMGTPadUfy9u3b8PPzQ3FxMd5++22ZrQUlLYGt8y0kJEQQBEEICQmR+1jY2B5uqqqqwqFDh4RDhw4Jqqqqch9Pb2iBgYGCIAhCRUWFkJeXJ7F99tln4mOaFRcXP/KYJUuWCACEadOmCXV1dYIgCEJRUZFw+/ZtIS0tTRAEQfD39xcOHTokCIIgrFixosXYJk2aJAiCIOTl5bX7/bi6uorH17xNU1NTKCsrEwRBEJYtW/bYPjw8PMR92NvbP3b/oUOHivfPz88XQkJChBs3bghJSUni7QUFBcKUKVPaPL55v82bN7d6zcLCosVn2vw+amtrW2x/8803O/T/+/Lly4Xa2lpxXzExMUJERIRQVVUlCIIgNDQ0CG+88Uar41asWCEIgiBUVVUJQUFB4hYcHCykpqYKDQ0N4mtj4sSJHRpT8//fSUlJbb7+4osvij/PnJwc4datW0JOTo4gCILwv//9T3wtT5o0qcVxmzdvbvPzbT5fYGBgq3O9/fbbgiAIrT6DcePGCYGBgUJFRYVQVFQknDlzRhg8eLDw6aefCrm5ucKlS5eEV155RVBTU2vzPVhbW7e6PpvbiBEjhKKiIkEQBGHXrl2P/bw68/uuvX+/+eiNiOhvNDQ0HlmHrK15Lbq6uo/ss/lxhL+/P/z8/LBp0yaMGjUKgwcPRkJCAr744gt8/PHHbd5lkaVFixaJv6J94sSJx+4fHh6OiIgIuLu749lnn8WmTZseuX98fDxWr14NHx8fDB06FPb29tDU1ERpaSmuX7+O33//HXv27GlVULU9FBUVxd/CepiysnKL7R2tIXf48GHcvXsX69atw8SJE2FtbQ2RSITs7GwEBwfjiy++QHBwsMTj1dTUxN8gbFZWVoaIiAj4+/tj9+7dyMzM7NCYHuebb75BYWEh3nrrLQwZMgROTk6IiYnBpk2bsHfvXpmW/Pj888/x8ssvY+fOnQgLC0NAQACApsdyzY8lH/baa6/htddek+qcISEh8PPzw/nz57FhwwYIgtDp9bxkoUMpl61ziZSNrbsb7yixsbHJqg0dOlQoLy8XKisrhaeffrpdxzz55JOCurp6t4yvK+8ocY4SERERPdLdu3cxffp0lJeX47vvvkNAQABmzpzZ6puA2traWLp0KW7evIkffvjhsXcgewM+eiMiIqLHunbtGkaOHIlPPvkE8+fPh4+PD6qqqpCWloaioiIMGDAAdnZ2UFJSQkVFBXbs2IEtW7bIe9hSY1AiIiKidklJScGCBQvg6emJxYsXY/LkybCysoKNjQ0KCgpw5coV/P777zhw4ADy8/PlPVyZYFAiIiKiDgkLC0NYWJi8h9EtOEeJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiom6hoqKCbdu24cGDB6ipqYEgCAgPD5eqz82bN0MQBGzevLnF9kmTJkEQBAQGBkrVPxGDEhFRG5ycnPDRRx/h1q1byM3NRW1tLYqLixEZGYkDBw5gwYIFUFFRaXWctbU1BEFo1SorKxEfH4/9+/dj2LBh4v3379/f5v6Pa38PBu119OhRqfvorD179mDjxo2wtLREVFQUrl27JnVQkhUFBQVMnDgRO3fuxJEjR3Dx4kWcO3cOn332GRYuXAg1NbV29TN48GCsXr0a3377LSIiIlBfXy+Xz5pkR0neAyAi6kmUlZXxySefYNWqVVBUVERjYyOSk5ORlJQETU1NWFlZwdXVFStWrEB6ejoWLlyIW7dutdnX7du3UVNTAwAwNDSEnZ0dnn32WTz99NN46aWXcPDgQcTFxeHatWutjnV3d4euri5SU1ORmpra6vW2tj3OrFmzsHjx4g4fJwu6urpYtmwZGhsbMW7cOISGhsqk3/z8fMTExCA/P79TxysoKGDFihV4//33YWVl1eY+r776KgoKCvDee+/hv//97yP727lzJ+bNm9epsVDPJbB1voWEhAiCIAghISFyHwsb28NNVVVVOHTokHDo0CFBVVVV7uPpDU1BQUH49ddfBUEQhPLycmHDhg3CwIEDW+yjqKgoTJgwQTh69KhQX18vrFixosXr1tbWQjNra+sWr1lYWAiBgYGCIAhCVVWVYG5uLnEszftt3rxZJu9NW1tbSE1NFVJTU4Xbt2/LtO/2tJEjRwqCIAjZ2dndcr5JkyYJgiAIgYGBEvfR1dUV/P39BUEQhOLiYuHzzz8XpkyZIhgaGgpKSkqCkZGRMHr0aOGDDz4QMjIyBEEQhMuXLwt6enoS+/ziiy+EY8eOCRs2bBAmT54snDt3rts/6/7YOvP7rr1/v3lHiYjoT//6178wY8YMVFZWwtvbGyEhIa32aWhoQFBQEIKCgjB+/Hioqqq2u//09HQ89dRTSEpKgpqaGhYtWoTdu3fL8i1I9MEHH8DS0hLz5s3Da6+91i3nfJi6ujoAoKqqqtvP3RYtLS0EBQXB3d0dx48fx+rVq5GXl9din9zcXOTm5uKPP/7A9u3b8cEHH2DNmjU4d+4c/Pz8UFlZ2arftWvXtvh51apVXfo+qOtxjhIREQBtbW288cYbAIAtW7a0GZL+7tq1a7h06VKHzpOVlYW4uDgAgKOjY8cH2gljx47FqlWrcOrUKZw+fbpdx6ioqOC1117DzZs3UVJSgsrKSkRHR+Ojjz7CwIED233u5jlbV65cAQDY2Ni0mGs1adIkAE2P5p577jkcP34csbGxKC8vR1lZGe7cuYMtW7ZAR0enzf4lTeZ+nMOHD8Pd3R0ffvghFi1a1Cok/V15eTnWrl2LjRs3YuzYsfjqq686dD7qvXhHiYgIwIwZM6Cnp4e6ujrs3bu3S8+loNB9/42qrKyMffv2oaKiAq+++mq7jtHV1YW/vz+8vLwAADExMaisrISbmxvefPNNLFu2DFOnTkVkZORj+6qursa1a9egq6sLd3d3VFdXtwihJSUlAJrmT3377beora1FdnY27t+/D11dXTg7O2Po0KFYvHgxxo4di6Kiok58Ci3Nnj0b8+bNw+nTp7Fhw4YOHbtjxw64uLjgmWeewZdffilxfhr1HQxKRIQBAwZAX1+/Q8fk5OSgvLy8xTZFRUXY2Nh0qJ+qqipkZma22m5iYgJNTc1HHltYWCiTP5wAMH78eABAZGQkiouLZdJnW0xNTeHg4AAA4jtLXWnjxo1wcXHB66+/jvT09HYd88UXX8DLywupqamYN2+e+JtpxsbGOHr0KCZNmoRjx45hyJAhqK2tfWRfOTk5mDBhAiZNmoTLly8jOzsbEyZMaLXfvXv3MHv2bFy8eBHV1dXi7fr6+tixYwdWrVqFXbt2yeRR1ubNm1FWVoaXXnqpxfYxY8Zg+/bt8PLyQm1tLa5evYoNGzZgzZo1WLt2LUQiEYCmR7RLlizB6tWrGZT6AQYlIsK4ceMwa9asDh3zzTfftHo8pampiTfffLND/cTFxeE///lPq+0LFizAkCFDHnnsL7/8gl9++aVD55PE3NwcAJCUlCST/tpiYWGBw4cPQ1VVFdXV1Th+/HiXnQsAXFxcsGHDBoSGhuKzzz5r1zE2NjZ48sknAQAvvvhii6/v5+Tk4IknnkBSUhKcnJywZMkSHD58WCZjjYiIQERERKvthYWFWL16Nf7xj3/g6aefxiuvvILGxsZOn8fGxgbDhw/Ht99+2+Jxm4+PD3777TeoqqoiJycH2dnZmDp1Knx8fBAWFtaij9TUVAQHB2Pq1KmdHgf1HgxKRERomqMEABUVFW2+bmBg0OZX0ENCQjBy5Mg2j/n555/FywMMHDgQ9vb2UFZWRn19PdasWdPuOzydIRKJ8M0330BRUREvv/xyu8PFtGnToKioiKioKFy4cKHV63l5efjuu+/w8ssvY/r06TILSkDTHck5c+ZgypQpsLW1haampvgxpY6ODrS0tDBo0CDExsZ2+hx+fn4AgB9//LHF9q+//hqqqqpYvXo1vv76awBNd7OOHDnSZiAKDw/HhAkToK2tjbKysk6Ph3o+BiUiIkD8x07S4766uroW6x0ZGRk9djL2wwGquroaaWlpuHbtGnbv3t3qLoWsrV27FmPGjMFnn33WoTWLnJycAABRUVES92m+8+Ps7CzdIB9iamqKX3/9tcVinG0xMDCQ6jzNj4Yffuzp4eEBR0dHnDx5UhySgKa7WStWrEBycnKrbzc2B2otLS0GpT6OQYmIcP36dURHR3fomJycnFbbKioq8O9//7tD/Uj6uviJEyfg7+//yGMLCws7dK5HycjIAACJc6xKS0tbzK1ZsWIFDhw48Mg+bWxskJKSIqshij333HN4/vnnW23/9ttvsX//fpiammLHjh1IT0/Hu+++26G+m++stfX/b7Ps7OwW+8rCgQMHMGzYMISFhWHz5s0IDQ1Ffn4+6urqAABXrlzBxIkToaysLNV5mr+xl5WVJd42aNAgAEBQUFCr/bOzsxEXFwd3d/cW2y0tLQFAZnPkqOdiUCIiFBUVyeQXfkNDAxISEmQwor/+GHeXa9eu4dVXX4W7uzsGDBjQo/8AWllZiSefP+zixYsAmpYd0NbWhqKiIh48eNBqv+aJ+2+88QZWrVqFtLQ0jBo1CsBfd9aMjY0lnt/ExKTFvtIyMTHB1KlTUVlZialTp6KgoKDVPtLeSWpWWloKoCnktXWe9hCJRPDy8kJ0dHSLiefUN3EdJSIiAL/99htKSkqgrKyMl19+Wd7DeaQtW7ZAJBK1alu2bGmxn4aGBkxMTFq15hp1WlpaMDExgaGhofiY5vk/bm5uEs/f/FpMTIxM3k/zXbzo6Og2w4uenp7M1pxqvpNkZ2cn3tYcJtsKn4aGhuI7Ts2WLFmCQYMG4ciRIzIZE/VsDEpERGi6O/Lxxx8DAN577z3xHZbe6MqVK20GqeZ2+fJlAMD7778PkUgEW1tb8bH+/v5oaGiAi4uLeOLzwwwMDLB8+XIATeFSFppXuJZ0F+v111+X+pFbs+vXrwNomrTe7M6dO4iLi8OCBQtaLBmgq6uL/fv3tyiIu2DBAuzZswcJCQn49NNPZTIm6tkYlIiI/rRjxw6cP38e6urqCAwMxLvvvtvibkszDw8PLFiwQA4j7HrJycniOyX79u3D0KFDxa8ZGRnhp59+gqamJmJjY/HTTz/J5Jz3799Hfn4+LCwssHXrVvE33UQiEV555RW88847Mit9cuvWLeTk5OC5556DklLT7BNBELBq1SrU1tZi7969yMrKQnh4ODIzMzF+/HgEBgYCaFoW4Pjx48jMzMSMGTM4ibufYFAiIvpTY2MjZs+ejT179kBNTQ3bt29Hbm4uEhIS8Mcff+D27dvIzMxEWFgY5syZg8zMzDbXgOrt1q5di5s3b8La2hp37txBVFQUQkNDkZaWBl9fX2RnZ2PRokWPXWyyverr6/Gvf/0LALBp0yZkZWXh1q1byM7OxpdffolDhw7h5s2bMjmXIAj45JNPYGdn16LmXWBgIHx9fXH58mXo6OjAxsYGly5dwpgxY3Dv3j3k5eXhwYMHWLNmDTw8PNqc+wU0PZbLy8sTt9mzZwMA3nrrrRbbx44dK5P3Q12Pk7mJiB5SW1uLVatWYffu3Xj++efh4+MDa2trWFpaoqKiApmZmTh//jzOnj2Ls2fPyiws9CQlJSWYOHEiXnnlFTz11FNwdnaGsrIykpKScPbsWXz00UePrY3WUd988w0KCwvx1ltvYciQIXByckJMTAw2bdqEvXv3iu/qyMLnn3+Ol19+GTt37kRYWBgCAgIAND2W8/HxabX/a6+91u5Cwmpqam3WwtPQ0ICGhob4Z1k9SqTuIbB1voWEhAiCIAghISFyHwsb28NNVVVVOHTokHDo0CFBVVVV7uNhY+tJbejQoUJ5eblQWVkpPP300+065sknnxTU1dXlPna21q0zv+/a+/ebj96IiKjfuXv3LqZPn47y8nJ89913CAgIwMyZM1tM3AaalhFYunQpbt68iR9++AGbNm2S04hJXvjojYiI+qVr165h5MiR+OSTTzB//nz4+PigqqoKaWlpKCoqwoABA2BnZwclJSVUVFRgx44drZZgoL6PQYmIiPqtlJQULFiwAJ6enli8eDEmT54MKysr2NjYoKCgAFeuXMHvv/+OAwcOtFnrj/o+BiUiIur3wsLCurz+HvVOnKNEREREJAGDEhEREZEEDEpEREREEjAoEREREUnAydx9nKKKAsw9DaFlrIHcmCLkxxU3LaFFfV59fb34n5WUlFBTUyPH0RARdZ3mun1Ay999Mulbpr1Rj2I+whBzP58INR0V8bbitHKEfx+HqJOJqC2vk+PoqKs1NDSgrKwM2traMDMzk1ibioiotzMzMwMAlJWVoaGhQaZ989FbHzXARhuL/ufbIiQBgJ6lFnw2eGJlwDz4vDMcupZachohdYfo6GgAwIgRI+Q8EiKirtP8O+7+/fsy75t3lPooz+VOUFSSnINVNJXg8bQjhj3liMQrGQg/HIvUP3K6cYTUHW7fvo1Ro0Zh+vTpKC0tRXBwMCorK+U9LCIimdDQ0MDYsWMxffp0AEBISIjMz8Gg1EcNdNRr134iEWDvbQ57b3Pkx5cg/Ls4RJ9NQn21bG9dknzcvHkT7u7umDhxIpYsWYIlS5bIe0hERF3iypUruHnzpsz7ZVDqo2orOz6ZbaCDLvzeH4kJ/zcUET8nIPyHOJRn8+5Db3fgwAEkJCRg8uTJsLS0hEgkkveQiIhkQhAEpKWl4dKlSwgKCuqSczAo9VH3TyfBdrxpp45V01HByBcGY/hzzoi/kIaww7HIDGeNo96qvr4egYGBCAwMhIKCApSVleU9JCIimairq0NjY2OXnoNBqY+K/S0FTjOt4eBj3uk+FBREcJxmBcdpVsi5X4iww7GI/TUFjfVcX6C3amxs5DIBREQdwG+99VUCcGbtVQTsCEF5XpXU3Rm76GPGrjF46dI8jH7FDRoGajIYJBERUc/GoNTH3fnhAb6Zchq/vhWMrIgCqfvTHKiGsWvc8VLAXEzbORqGgwfIYJREREQ9Ex+99QON9QJizqUg5lwKTIcawHO5MwZNtYSCYucn9SoqKcB1ri1c59oiPTQP4YdjER+QDqGBj+WIiKjvYFDqZ7LuFuDc3evQNFLHsCcHYciSQVDXVXn8gY9gMdwQFsMNUZpViTs/xCHi53jUlHHVbyIi6v346K2fqsitwvXd97DX5xTOb7qJvLhiqfvUMdXAxPXDsPLyfEx+byT07XSkHygREZEc8Y5SP9dQ04DIE4mIPJEISy9jeC53gp23OaRZakdZTRFDlzhg6BIHJAdnI/xwLJKCMlmMl4iIeh0GJRJLu5mDtJs50LXUgsfTjnCdbwdVLenW3LEZawKbsSYoSilD+HexiDqVhLpOLIZJREQkD3z0Rq2UpJXj8gdh2Ot7CgE7Q1GUWi51nwOsteH77gisDJyHSW97QsdcUwYjJSIi6lq8o0QS1VXU4873cbjzQxxsJ5rBc7kTrMeYSNWnqpYyhj/jBM/lTkgITEfY4Vik38qV0YiJiIhki0GJHk8Akq5kIulKJvTtdeC5zAkuc22hpKrY6S5FIsDB1wIOvhbIiytG2OFYxPySjIbarl2KnoiIqCP46I06pDChFBe33MYe71O4+vEdlMmgaK6hox6mbfPCysB5GPfPIdA0VJfBSImIiKTHoESdUlNai5Bvo/HN1DM4+/o1ZITlSd2nup4qvF52xUuX5mLmv8fCZIiBDEZKRETUeXz0RlIRGgQ8OJ+GB+fTYOSiD8/ljnCaaQ1Fpc5ncAVFEZxnWsN5pjWy7hUg7HAsHpxPZTFeIiLqdryjRDKTe78Qv//rD+ybfBo3/huJykLpq9SbDjHAP/49Fi9enAuvl12hPkBVBiMlIiJqHwYlkrnK/Grc+DICe31P4fd3/kBOdJHUfWoZqmPcP4dgZeA8TN3uhYGOetIPlIiI6DH46I26TGNdI+6fTsL900kw8zSE53InOEyxgIKCFMV4lRXgNt8ObvPtkHY7F2GHYpB4ORNCIx/LERGR7DEoUbfIDMtDZlgetE01MOwpR7g/4QA1belW/bYcaQTLkUYoyahA+PexiDyRiFoW4yUiIhniozfqVmVZlQj6+A72+pzExS23UZBQKnWfuuaa8H7LEysD5sH33RHQs9aWwUiJiIh4R4nkpL6qAfd+ise9n+JhNcakqRjvJDOp+lTRUMKwpwZh2FODkHg1E+GHY5ESnC2jERMRUX/EoERyl3ojG6k3sqFnpQWPZU5wnW8HFQ3pLk27iWawm2iGgsRShH8Xi/tnklBf1SCjERMRUX/BR2/UYxSnliNwZyj2+p7C5Q/DUJwufTFeAzsdTHlvJF4OnI8J64dB20xDBiMlIqL+gneUqMepLatD2KFYhH8XB9tJZvB8xglWo4yl6lNVWxkjnx+MEc8NRvzFNIQdjkVGqPSriRMRUd/GoEQ9ltAoIDEwA4mBGRjoqAfP5U5wnmUDJZXO3wgViYBBfpYY5GeJ3JiipmK851LQWMdivERE1BofvVGvkB9XjPObbmKvzylc230P5blVUvdp5DwA03eMxsqAeRiz1h0aA9VkMFIiIupLGJSoV6kursGtvVH4xu80zr1xHZl3C6TuU0NfFWNWu+GlS3Mx44MxMHbVl8FIiYioL+CjN+qVGusFxP6WitjfUmHibgDP5U5wnG4FBUUpVv1WUsDg2TYYPNsGmXfym4rxXkiD0MBVv4mI+isGJer1siMK8Otbwbjy73AMXToIQ5c6QF1PuuK5ZsMGwmzYQJRlV+LOD3G493MCakprZTRiIiLqLfjojfqMirwqBH9+D3t9TsF/403kxRZL3ae2iQYm/N8wvHx5Hqa8PwoGDrrSD5SIiHoN3lGiPqehthFRJxMRdTIRFiON4LncCfa+FhB1/qkclFQVMeQJewx5wh4pf+Qg/HAsEq9kAHwqR0TUpzEoUZ+WfjsX6bdzoWOuCY+nHeG2wB6qUhbjtR5tDOvRxihOK0f4d7GIPJmIuop6GY2YiIh6Ej56o36hNKMCVz4Kx17fUwjYEYKilDKp+9Sz1ILPv4bj5cD58P6XJ3QttWQwUiIi6kl4R4n6lbrKetz54QHuHHkAm/Gm8FzuBJtxplL1qaKpBM9lTvB42gmJVzIQdigWaTdzZDRiIiKSJwYl6p8EIDkoC8lBWRhgqwPPZY5wmWcHZTXFTncpEgH23uaw9zZH/oOSpmK8Z5PRUMNivEREvRUfvVG/V5RUikvbQrDX+ySu/r87KM2skLrPgYN04bdlFF6+PA/jXx8KLWN1GYyUiIi6G4MS0Z9qyuoQsj8a/5t+FmfWBSE9RPqiuWo6Khj1ogtevDgX//h4HEyHGshgpERE1F346I3ob4QGAfEX0xF/MR2GgwfAc5kjnGfZQFGp8/9doaAggtN0KzhNt0J2ZCHCDsci7vcUNNZzfQEiop6Md5SIHiEvugj+7zYV4w3+IgIV+dVS92nipo+ZH47BixfnYvRqN6jrS7eKOBERdR0GJaJ2qCqswR9fRWLf5FP4bcMNZEcVSt2nlqE6xq51x8qAeZi2wwuGznrSD5SIiGSKj96IOqCxXkD02WREn02G6bCB8FzuhEFTLaGgIEUxXmUFuM6zg+s8O6SH5CHscAwSAjIgNPKxHBGRvDEoEXVS1p18nLuTDy1jdQx70hFDljhATUdFqj4tRhjCYoQhSjMrcOeHB4g4Fo+asjoZjZiIiDqKj96IpFSeU4Vrn97FXp9TuLD5FvLjS6TuU8dMExPfGIaVl+dj8qYRGGCrI4OREhFRR/GOEpGM1Fc3IOJYAiKOJcDSyxiezzjBbpK5VMV4ldUUMXTpIAxdOgjJ17MQdjgWydeyWIyXiKibMCgRdYG0mzlIu5kDXUsteCxzhNt8e6hoSvevm804U9iMM0VhclnTqt+nk1BXyWK8RERdiY/eiLpQSVo5Lu8Kw17fUwjcFYritHKp+9S30cbkjSOwMmAeJr7pAR1zTRmMlIiI2sI7SkTdoLa8DuHfxSH8+zjYTTKHx3InWI82lqpPVW1ljHjWGcNXOCMhMB1hh2KRfjtXRiMmIiKAQYmoewlA4uUMJF7OgMEgXXguc8LgObZQUun8zV2RCHDwtYCDrwXyYosRdjgWMeeS0VDbKMOBExH1T3z0RiQnBQ9KcGHzLez1Pomg/9xBWU6V1H0aOulh2nYvvBQwD2NfHQJNQxbjJSKSBoMSkZxVl9Ti9v+i8Y3fafzyf9eReSdf6j41Bqhi9CpXvHRpLmZ+NBYm7izGS0TUGXz0RtRDCA0C4vxTEeefCmNXfXgud4LjDCvpivEqiuD8D2s4/8MamXcLEH44Bg8upLEYLxFROzEoEfVAOVGF+G3DDVz9+A6GLHHA0CWDoCFl8VyzoQYwGzoO5blVuHPkAe79FI/q4hoZjZiIqG/iozeiHqwirwo3vojAXt9T+P3dP5AbUyR1n1pG6hi/bghWBs7D1G1eGOioJ/1AiYj6KN5RIuoFGusacf9UEu6fSoL5cEN4LneCwxRLqVb9VlJRgNsCO7gtsEPqrRyEH45F4uVMFuMlInoIgxJRL5MRmoeM0Dxom2k0FeN9wgGq2spS9Wk1yhhWo4xRnF6Oe0fj8eBCGkpksDgmEVFvx6BE1EuVZVYi6OM7uPHfCLjOtYPHMkfoS1k8V89CCxPXD8PE9cOQ/6AECQHpiA9IR05UIevLEVG/xKBE1MvVVzXg7o8PcPfoA1iPNYXHMkfYTTSTut+Bg3QxcJAuvF52RXleFRICMpAQkI7UmzlorONilkTUPzAoEfUVApByPQsp17OgZ60Nz2VOcJ1vC2V16f811zJUx9AlDhi6xAG1FfVICspEQkA6Eq9morasTgaDJyLqmRiUiPqg4pQyBOwIwbXP7sJ9gT2GLXOErplsiueqaCrBaboVnKZbobFBQHpILuIvpSMhIB1lWZUyOQcRUU/BoETUh9WW1SH0YAzCDsfCzsccnsudYDnSSGb9KyiKYOVlDCsvY/i+Mxy5scVIuJSO+EtpyIspltl5iIjkhUGJqB8QGgUkXEpHwqV0DHTSg+dyJwyeZQNFZdkupWbkpAcjJz2MecUNpZkVSAjMQPyldGSE5nI1cCLqlRiUiPqZ/NhinN94E0Ef38GQxQ4Y+uQgaHVB8VwdM014PO0Ij6cdUVNWh8QrGUgIyEDStUzUVdTL/HxERF2BQYmon6oqqsHNPVG4/b/7cJhiCceplrCZYAYVDdn/WlDVVsbgWTYYPMsGDfWNSP0jBwkB6UgIyEBFXpXMz0dEJCsMSkT9XGO9gLjfUxH3eyoUlBVg5WUMe18L2Puad8mdJkUlBdiON4XteFNMeW8ksiMLxZPBC+JLZH4+IiJpMCgRkVhjXSOSr2Uh+VoWLm27DRM3A9j7msPe1wIDHXS75JwmbvowcdPH+HVDUJxWLl7kMjMsn+VUiEjuGJSIqG0CkB1RgOyIAlzffQ+6llpw8LWAva8FzIcbSlVnThI9Sy0MX+GM4SucUVVSi8TLTZPBU4KzUF/VIPsTEhE9BoMSEbVLSVo5Qg/GIPRgDNT0VGHvYw57X3PYjDOFkqqizM+nrqsC17m2cJ1ri/raRqQEZzV9c+9yBqoKa2R+PiKitjAoEVGHVRfXIOpkIqJOJkJRVRHWY0zgMNkCdj7m0BigKvPzKakowN7bHPbe5hAEIOtuPuIvpSP+UjqKU8pkfj4iomYMSkQklYaaBiRezkDi5QyIFEQwHWoAe18LOEy2wABrbZmfTyQCzIYNhNmwgZi4fhgKk0qREJCB+EtpyLpXwOK9RCRTDEpEJDNCo4DM8Hxkhucj6OM7GGCrAwdfc9hPtoTpEIMumdekb6sD/Rd0MPKFwagoqBbPa0q9kY2GWhbvJSLpMCgRUZcpSirF7f+V4vb/oqExUK3p8ZmvBazHmsh8VXAA0DRQg/tCe7gvtEddVT2Sr2c3Fe+9nIHqklqZn4+I+j4GJSLqFpX51Yg4loCIYwlQ1lCC9dg/5zV5m0NNR0Xm51NWV8KgKRYYNMUCjY0CMsLymha5vJSBkvRymZ+PiPomBiUi6nZ1lfWIv5iO+IvpECmKYD7cULz0gK65pszPp6AgguUII1iOMIL3W57IiytGQkAGEgLSkRNVKPPzEVHfwaBERHIlNAhIv5WL9Fu5uPxBGAY66okXuTRx1e+Scxo66sHQUQ+jV7miPLeqaZHLS+lIu5XD4r1E1AKDEhH1KPlxxciPK8bNr6OgZaz+ZzkVC1iOMoKikuznNWkZqWPo0kEYunQQasrrkHwtC/GX0pEUlInasjqZn4+IehcGJSLqscpzqnD3yAPcPfIAKtrKsBlnCofJFrCdYAZVbWWZn09VSxlO063gNN0KjQ0C0m7nIuFSGuIDMlCeXSnz8xFRz8egRES9Qm1Z3V/Fe5VEsBhp3DSvabIFtI1lX7xXQVEE69HGsB5tDN93RyAnukj8iC4/tljm5yOinolBiYh6ncZ6Aak3spF6IxsBO0JgNHgA7CdbwMHXAoZOel1yTuPBA2A8eADGrnFHSWYFEgOb1mvKCM3lvCaiPoxBiYh6vdzoIuRGF+HGFxHQMdf8c16TOSxGGEFBQfarXOqaacLjaUd4PO2I6rI6JF3OQHxAOpKvZ6Guol7m5yMi+WFQIqI+pTSjAuGHYxF+OBaqOiqwm2QGe18L2Iw3hYqG7H/lqWkrY/BsGwyebYOG+kak3shpWq8pMAMVeVUyPx8RdS8GJSLqs2pKaxF9NhnRZ5OhqKIAq9EmTXebfMyhOVBN5udTVFKA7QRT2E4wxZTNI5F1r6BpXlNAOgoTSmV+PiLqegxKRNQvNNQ2IulqJpKuZuLiFsDE3UC8yKWBvU6XnNN0iAFMhxhg/GtDUZxWjvhL6UgISEdmeD6ERs5rIuoNGJSIqP8RgOx7Bci+V4Brn96FnpUWHCZbwt7XHGYehl1SvFfPUgsjnnXGiGedUVlUg6QrTZPBU4KzUV/dIPsTEpFMMCgRUb9XnFqOkP3RCNkfDfUBqrDzNof9ZAvYjDWBkqqizM+nMUAVrvPs4DrPDvU1DUgJzkZ8QDoSAzNQVVQj8/MRUecxKBERPaSqqAZRJxMRdTIRSmqKLYr3quupyvx8SqqKsPcxh72POQQByAzPQ0JABuIvpaE4lcV7ieStzwYlc3NzvP322xgxYgSGDh0KDQ0N2NjYICUlRd5DI6Jeor664c/iuRkQKYhgOmwgHHzN4TDFEnqWWjI/n0gEmHsawtzTEBPfGIaCxNKmb9AFpCPrXgHAaU1E3a7PBiUHBwcsXrwYoaGhCAoKwrRp0+Q9JCLqxYRGAZlhecgMy8PV/3cH+vY64sngpkMMuuScBnY6MLBzwagXXVCRX42EwAwkBKQj9Y9sNNQ2dsk5iailPhuUrl69ChMTEwDACy+8wKBERDJVmFCKWwn3cWvffWgaqjfNa/I1h/VYky4p3qs5UA1DnrDHkCfsUVdV31S8NyAdiZczUVNaK/PzEVGTPhuUBIH3qImoe1TkVSHi53hE/BwPZU2lpuK9vhaw9TaHWhcU71VWV8IgP0sM8rNEY6OA9JDcPx8RpqM0o0Lm5yPqzzoVlIyNjeHn54eRI0di5MiRGDZsGNTV1XH58mX4+Pg89nhvb2+sX78eXl5e0NLSQkpKCn7++Wd88MEHqKxkhW4i6r3qKurx4HwaHpxPg4KSCObDjWDvaw57XwvommnK/HwKCiJYjTKG1Shj+GzwRF5c8Z/FezOQe79Q5ucj6m86FZSWLl2KTz/9tFMnXLt2LXbv3g0FBQWkpaUhLS0NLi4u2LRpExYuXIjx48ejqKioU30TEfUkjfUC0m7mIO1mDi7vCsNAJz04TG6a12Q8eECXnNPQUQ+GjnoYvcoNZTlVSLjUtDJ4+u0cFu8l6oROBaXS0lJcuHABt2/fxu3bt+Hh4YH33nvvscd5enqKA9bKlSuxb98+AICpqSnOnDmDESNGYN++fVi0aFGL4yZPnoyLFy8+tv/23tEiIpKH/Nhi5McW44//RkLLRAMOf95pshxlDAVF2a9yqW2sjmFPDcKwpwahprwOyUFZiL+UhqRrWagtq5P5+Yj6ok4Fpf3792P//v3in83Nzdt13KZNm6CoqIiDBw+KQxIAZGVl4cknn0RMTAwWLlwId3d3REREiF8PDg6Gs7PzY/vnYzsi6i3Ksytx54cHuPPDA6hoK8N2ghkcJjcV71XVkv28JlUtZTjNsILTDCs01Dci/XauuKRKeQ6L9xJJ0m2TuTU1NTF9+nQAwN69e1u9Hh8fj4CAAPj5+eGJJ55oEZSqqqoQGxvbXUMlIupWtWV1iP01BbG/pkBBSQTLUcaw97WAw2QLaBmpy/x8ikoKsB5jAusxJpi8cQRy7hf+uchlOvLjimV+PqLerNuCkoeHB9TU1FBdXY1bt261uU9QUBD8/PwwevTo7hoWEVGP0lgvICU4GynB2QjYHgJjV33Y+1rA3tccho56XXJOYxd9GLvoY+xad5RkVDRNBg9IR0ZoHoQGzmui/q3bgpKjoyMAIDU1FfX19W3uk5CQAABwcnKSyTkXLlwIABg+fDgAYMaMGcjLy0NeXh6uXr0qk3MQEXWlnKhC5EQVIvjze9C10BJ/g858uCEUFGQ/r0nXXBOey53gudwJ1aW1SLyciYSAdCRfz0JdZdu/u4n6sm4LSvr6+gCAwkLJX1dtfm3AANl8G+TYsWMtfv7qq68AdM2kb1VVVdjb2wNoWsMpMTGx1T4DBgwQfw7tlZOTg/LylvWeFBQUYGtr26F+qqurkZGR0Wq7iYkJNDU79pXltLQ01Na2XOBOXV0dZmZmHeqnpKQE+fn5rbZbW1tDSan9l6akz1tPTw8GBh1bMTk3NxdlZWUttvX1z9vKygrKyh2bE9P8HzUPk9XnLRKJYGdn16F+ampqkJ6e3mq7sbExtLQ6Vmqkrc9bTU2t3XMxm5WWliIvL6/Vdmk+75L0coQdikXYoVgYWQ6E6wwHmI3Wh/FwPSiqPb54b2NjI4TGv63oLQIUFdv+901TXwnuCxzgvsABjXWNyL1TgswbhUgJykb8vdb/zhkZGUFbW7tD7y09PR01NS0LAcvy87a0tISKikqH+mrr+tbV1cXAgQM71E9+fj5KSkpabW/+W9FetbW1SEtLa7VdVp+3qqoqLCwsOtRPWVkZcnNzW21v6/MuLCzs1d9m77agpKamBgCtfgE9rPn/PHV12TyTF4lk/19bkhgbG+PNN98E0PQe//nPf7baZ/To0Zg7d26H+v32229bParU0NAQn6u9EhIS8O9//7vV9rlz58LDw6NDfW3ZsgVZWVktttna2rb5nh8lMDAQR48ebbV95cqVHfqDW19fj7Vr17baPnr0aMybN69DYzp48CBu3LjRYpuamlqHP+/ExER89NFHrbbPmTMHnp6eHepr27ZtrUKXtbU1XnvttQ71c/nyZfz444+ttr/00kswNDRsdz+NjY145ZVXWm0fOXKk+C5uex0+fBjXr19vsU1FRaXDn3dKSgp27drVavusWbMwcuTIDvW1Y8eOVn+ULC0tsX79+g71ExQUhO+//77V9hdeeAHGxsYd6mvVqlWttrk7DsUTnk8AtYBwsxG1A8tRY1KCGpNSNKq2feenqqoKtX/7IwmI2h0mdXx04OBjiYZ6N0QHJiDyRAIenE9DfXUDAOAf//gHvLy8OvTedu3a1aoGp7m5eYevgevXr+Pw4cOttj///PMwNTXtUF+rV69utWixp6cnlixZ0qF+jhw5gitXrrTYpqio2OH3lpGRgW3btrXaPmPGDIwZM6ZDfX344YdISkpqsc3MzKzDY7px4wYOHjzYavuzzz7bKuT+8ssv+OWXXzrUf0/SbUGpuroaAB6Z7FVVmypzV1XxGxhERO0lalSAaq4OVHN1INwTUD+gEtUmJag1KUW91t+DkSxOCFiONILlSCP4vjsCsb+lIvJE67swRH1BtwWl5ttuj3r01Pxab75FR0QkTyKIoFykCeUiTSDaDPWaNeI7TVVqsl9CRVVLWVyDTrlCARUluVBLHwDFGtkvcUAkDyIAUn+lYc2aNfjiiy8eOfdnwoQJuHr1Kqqrq6Gtrd3mhO5NmzZh69atuHjxIvz8/KQdVrcICQnB8OHDERkZKX7MwzlK7cM5Su3DOUqP11/mKD2sM3NmyhtKYeipDfvJFrAeawolFYVHzlGSRBAENDY0tNquoKgIkUgEoUFA1q0iJPvnICe0+JHfnOMcpcfjHKWu0fz3OzQ0FCNGjJC4X7fdUQoPD0dNTQ3U1NQwatQoBAcHt9pnwoQJANBqjkhvUFNT0+a/XA8rKiqSycXS2Nj42HO1V3Z2tkz6qaqqktmY/j5fobOKi4tRXFwsdT99/fNOTU2VST+y+rwFQZDZe8vJyUFOTo7U/VRXV/e4z7ukpKTNP8KPk5Och8gTiVBSV4T1WFM4+JrDzscC6rodCxNteTg8GY/UgfFIHVQUVOP+6SREnUxEYWJpu/qR5efdVsDojM5+3m2R1XvLzc1tM6x0VHv+frWXrD7vnqTbglJ5eTn8/f0xZ84crFy5slVQcnBwgK+vL4DW31YjIiLZqq9qQMKldCRcSodI4RbMPAaK69DpWXbsLtyjaBqoYeTzgzHy+cHIvFuAyOMJiPNPRW05S6hQ79BtQQlo+vbOrFmzsHz5cly/fl1cxsTExARHjhyBoqIiTp48iXv37nXnsIiI+jWhUUBGaB4yQvNw5aNwGDjoihe5NHXv2OPURzEbagCzoQbweWc44vybJoBnhLR+XEbUk3RqjpKFhQXCw8PFP6upqUFLSwt1dXUtbk1+9NFHrb6Svm7dOvznP/+BgoICUlNTkZ+fDxcXF6ipqSEmJgbjx49HQUFB599RN2vvM04iot5I01Ad9j7msJ9sAavRxlBUUpBp/8Vp5Yg8kYj7pxNZc466VZfOUVJUVGxzUpuysnKL7RoaGq322b17NyIiIrB+/Xp4eXnByMgIKSkpOHbsGHbt2oWKiorODImIiLpARV4V7v0Uj3s/xUNVWxnOs2zgtsAOxi4d+2KKJHqWWhi/bgjG/XMIkq9nIepEIuID0tFY1/j4g4m6QaeCUkpKilSLOQYEBCAgIKDTxxMRUferKavD3SMPcPfIAwx00oPbAjsMnm0rk4ngIhFgO94UtuNNUV1ai+izyYg4noD82GLpB04khW6do0RERH1DfmwxLu8Kw9X/dwf2PuZwW2APm/GmkEVBBDUdFXg87QiPpx2RE12EqBMJiP4lBTWlkis7EHUVBiUiIuq0xrpGPDifhgfn06BppA7XubZwW2gvs2/OGQ8eAON3R2DSW56Iv5iOiOMJSLuZA6FR6iUAidqFQYmIiGSiIrcKt/bdx61992E+3BBuC+zgON0ayu0o2Ps4isoKcJphBacZVijLrkTUqUREnUxCSXr54w8mkgKDEhERyVzzcgMBO0PhNM0KbgvtYTasYytbS6JtooHRq9wwepUbUm/lIOpEIh5c+Ks4L5EsMSgREVGXqauoR+SJRESeSMQAWx24LbCDyxxbaA5Uk0n/VqOMYTXKGL4bRyD21xREnkhEdkTvWWKGej4GJSIi6hZFSaUI+vgOrn16F7YTzOC2wA523uZQUJR+BriqljKGLHbAkMUOyI8vQdSJRNw/m4SqwprHH0z0CAxKRETUrYQGAYmXM5B4OQPq+qpwmd00AdzAXkcm/Q900MWktzwwYf0wJF7JQOTxRCQFZT6yOC+RJAxKREQkN1WFNQg9GIPQgzEwcTeA2wI7OM20hqqWstR9KyiK4OBrAQdfC1TkV+P+mSREnkhEUVL7ivMSAQxKRETUQ2RHFCA7ogCXPwzDID9LuM63g5WXsUz61hz4UHHeO/mIPJ6AWP9U1FXUy6R/6rsYlIiIqEepr25A9NlkRJ9Nho65Jlzn28Ftvh20TVqXxeoMs2EDYTZsIHzeHYG435smgGeEsjgvtY1BiYiIeqzSjArc+CICf/w3EpZexnBfaA+HKRZQVJa+OK+ymiJc59nBdZ5dU3He4wmIOp2EilwW56W/MCgREVGPJzQKSL2RjdQb2VDVUcHgWdZwXWAP48EDZNK/nqUWxr82FOPWDUXytSxEnkhAQmAGi/MSgxIREfUuNaW1uPPDA9z5oYuK804whe0EU1SV1CL6bBIijyciP65Y+oFTr8SgREREvVZXFudV11WB5zIneC5zQs79QkSeSETML8moKauTvnPqNRiUiIio13u4OK+WsTpc5trBbYGd7IrzuujD2EUf3m//VZw39Y9sgEsz9XkMSkRE1KeU51Th1t4o3NobBfMRhnBbYA/HaVYyL85bmtVcnDcRpRkVMhg59UQMSkRE1GdlhOQhIyQPATtCZF6cV8dUA2NWu2HMajek3sxB5J/FeRtqWJy3L2FQIiKiPq/N4rxzbaFpIKPivF7GsPIyRs3GEYj5NQWRJxKQE1kok75JvhiUiIioX2kuznt9913YjDeD20I72E2SUXFebWUMXeKAoUsckP+gBJEnExB9JhlVRSzO21sxKBERUb/UWP9XcV4NAzUMnm0DtwUyLM47SBfeb3li4noPJF7OQOQJFuftjRiUiIio36ssqEbogRiEHuii4ryTLeAw+c/ivKeTEHkiAUXJZTIYOXU1BiUiIqKHtCrOu8AOVqNkWJz3hcEY+cJgZITnI/JEAuJYnLdHY1AiIiJqw8PFeXUttOA63xau82RXnNfcYyDMPQbC953hiPNPZXHeHopBiYiI6DFK0ssR/HkEbnwZCavRxnBrLs6rJIPivOpK4uK8RanliDrB4rw9CYMSERFROwmNAlKCs5ES3DXFeQdY/VWcNykoE1EnEpEQmI7Gek4AlxcGJSIiok54uDivobMe3BbYY/BsG6jpyKY4r91EM9hNNENVcQ2izyYj8gSL88oDgxIREZGU8mKKEbgzFFf+HQ4HXwu4LrCDzTgZFefVU4Xncid4LndCdlQhok4kIvpcMmpZnLdbMCgRERHJSGNdI+L8UxHnnwotEw24zrWF63zZFec1cdWHias+Jr3tifiLaYg8noDUmzksztuFGJSIiIi6QHl2JW7uicLNPbIvzqukogDnmdZwnmmN0swKRJ1KQtQpFuftCgxKREREXay5OG/gzlA4NhfnHWogk751zDQx5hU3jHnlz+K8xxPw4GI6i/PKCIMSERFRN6ktr0Pk8QREHk+Avp0OXOd3UXHesjrEnEtG5MlEFueVEoMSERGRHBQmPlScd4IZ3BbIuDjv0kEYunQQi/NKiUGJiIhIjhrrBSQGZiAx8KHivAvtYWAn2+K8E/5vGBIvZyLyRAKSr2WxOG87MSgRERH1EC2K8w4xgNsCezjPtIaKpvR/rhWVFDBoigUGTbFAeV7Vn8V5E1GcwuK8j8KgRERE1ANl3ytA9r0CXP4gFIOmWsJtgT0sRxrJpG8tQ3WMetEFo150QUZYHiJPJDYV561kcd6/Y1AiIiLqweqrGxB9JhnRZx4qzjvfHtrG6jLp39zTEOaehvB9t6k4b8TxRGSGsThvMwYlIiKiXqI7i/NGHk/A/dNJqMjr38V5GZSIiIh6mbaK87ottIeRs+yK8054fSjGvzYUSVebJoAnXs7ol8V5GZSIiIh6sRbFeQcPgNt8O9kW551kBrtJTcV5759JRtTJ/lWcl0GJiIioj8iLLkJgdNcV5x3+jBOGP9O/ivMyKBEREfUxbRbnXWAHPYsuKM57IQ0RxxOQdqtvFudlUCIiIurDxMV590bBYoQR3BbYwXGaFZRUZVSc9x/WcP7HX8V5I08moCyzUgYj7xkYlIiIiPoDAUi/nYv027kI2BEKp+lWcF0g++K8o1f/VZw3zj+1168AzqBERETUz9SW1yHiWAIijsm+OK9IBFiPNob1aGN4LnfCbxtu9OrVv6VfeIGIiIh6rebivPt8T+HU2quID8xAY6Ns7gKZDjHA7E/HQySDQr/ywjtKRERE1LI470A1uMxumgAubXFeQ0c9DPKzRNzvqTIaafdiUCIiIqIWKvOrEbI/GiH7o2VSnFdXRt+2kwcGJSIiIpJIXJz3w1AM8utccd76moYuGl3XY1AiIiKix6qveqg4r6VWU124+XaPLc7b2Cgg9teUbhql7DEoERERUYeUpJUj+PN7uPFlBKzGmMBtgV2bxXkFATi/6SYqC6rlNFLpMSgRERFRpwiNAlKuZyHlehbUdFXgPMsGFiOMoGuhibyYYkSdSkRGaJ68hykVBiUiIiKSWnVJLe58H4c738fJeygyxXWUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIiIiIgkYlIiIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISII+G5QWLlyIY8eOITk5GZWVlYiJicHOnTuhpaUl76ERERFRL9Fng9Ibb7yBhoYGvPPOO5g+fTq++uorrF69GhcuXIBIJJL38IiIiKgXUJL3ALrK7NmzkZ+fL/756tWrKCwsxKFDh+Dt7Y3AwEA5jo6IiIh6gz57R+nhkNTs9u3bAABzc/PuHg4RERH1Qp0KSsbGxli2bBl2796N4OBgVFZWQhCEdt+l8fb2xtmzZ5Gbm4vKykpER0dj69at0NDQ6Mxw2m3SpEkAgOjo6C49DxEREfUdQkfbunXrhLYEBgY+9ti1a9cKDQ0NgiAIQmpqqhAaGipUVVUJgiAIUVFRwoABAzo8nvY0MzMzIScnRzh//rxM+w0JCREEQRBCQkK6ZNxsbGxsbGxssm/t/fvdqTtKpaWluHDhAnbu3In58+dj69at7TrO09MTn376KQBg5cqVsLKywvDhw2FnZ4eQkBC4uLhg3759rY6bPHkyBEF4bJN0R0tTUxOnT59GfX09nnvuuc68ZSIiIuqHOjWZe//+/di/f7/45/bO+dm0aRMUFRVx8ODBFoEoKysLTz75JGJiYrBw4UK4u7sjIiJC/HpwcDCcnZ0f239lZWWrbWpqajh79izs7OwwadIkZGRktGusRERERN32rTdNTU1Mnz4dALB3795Wr8fHxyMgIAB+fn544oknWgSlqqoqxMbGdvicSkpKOHbsGEaMGAE/Pz9ERkZ2/g0QERFRv9Nt33rz8PCAmpoaqqurcevWrTb3CQoKAgCMHj1a6vOJRCJ8//338PX1xbx583Dz5k2p+yQiIqL+pdvuKDk6OgIAUlNTUV9f3+Y+CQkJAAAnJyepz/fll19i8eLF2L59OyoqKuDl5SV+LT09XWaP4GxsbAAAzs7OCAkJkUmfRERE1LWap/Q0/x2XpNuCkr6+PgCgsLBQ4j7Nrw0YMEDq882YMQMAsHHjRmzcuLHFa++//z62bNki9TmApjlQQNOjxeHDh8ukTyIiIuoezX/HJem2oNQ8kNraWon71NTUAADU1dWlPp+tra3UfbRHbm4ujIyMUF1djeTk5G45JxEREUnHxsYGampqyM3NfeR+3RaUqqurAQAqKioS91FVVQXQNHm7t7Czs5P3EIiIiKiLdNtk7qKiIgB/PYJrS/NrzfsSERERyVO3BaW4uDgAgJWVFZSU2r6RZW9v32JfIiIiInnqtqAUHh6OmpoaqKmpYdSoUW3uM2HCBADAjRs3umtYRERERBJ1W1AqLy+Hv78/gKbyJX/n4OAAX19fAMCxY8e6a1hEREREEnVbUAKAbdu2obGxEcuXL8dLL70k3m5iYoIjR45AUVERJ0+exL1797pzWEREREQSdbjiroWFhZCXlyduZWVlgiAIQm1tbYvtb775Zqtj161bJzQ0NAiCIAgpKSlCaGioUFVVJQiCIERHRwsGBgZyryjMxsbGxsbGxgZA6NTyAIqKihg4cGCr7crKyi22a2hotNpn9+7diIiIwPr16+Hl5QUjIyOkpKTg2LFj2LVrFyoqKjozJCIiIiKZE6EpMRERERHR33TrHCUiIiKi3oRBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJ2mRhYYGff/4ZxcXFKCkpwfHjx2FpaSnvYVEPYm5ujs8++wzBwcGoqKiAIAiwtraW97Coh1m4cCGOHTuG5ORkVFZWIiYmBjt37oSWlpa8h0Y9xNSpU3Hp0iVkZWWhuroaaWlpOHr0KAYPHizvoQHg8gDUBnV1ddy9exc1NTXYuHEjBEHA9u3boaGhgSFDhqCyslLeQ6QeYNKkSTh69ChCQ0OhqKiIadOmwcbGBikpKfIeGvUgN27cQGpqKk6fPo309HR4eHjg/fffR0xMDMaOHQtB4J+g/m7p0qXw9PTEzZs3kZeXBysrK2zYsAGWlpZwd3dHamqqvIco/1Uv2XpW++c//ynU19cL9vb24m02NjZCXV2d8Prrr8t9fGw9o4lEIvE/v/DCC4IgCIK1tbXcx8XWs9rAgQNbbVu+fLkgCILg4+Mj9/Gx9czm6OgoCIIg/N///Z/cx8JHb9TKnDlz8McffyAhIUG8LTk5GdevX8fcuXPlODLqSXgngNojPz+/1bbbt28DaHp8S9SWgoICAEB9fb2cR8I5Sr2CsbExli1bht27dyM4OBiVlZUQBAGBgYHtOt7b2xtnz55Fbm4uKisrER0dja1bt7ZZYgYAXF1dERkZ2Wp7VFQUXFxcpHov1HW6+zqh3qknXCeTJk0CAERHR3fqPVDXktc1oqCgAGVlZTg4OGDPnj3IysrCkSNHZPGWpCb321psj27r1q0T2hIYGPjYY9euXSsuQpyamtqiCHFUVJQwYMCAVsfU1NQIu3btarV927ZtQl1dndw/D7aecZ083Pjorfc0eV4nAAQzMzMhJydHOH/+vNw/C7aedY3cvn1bfK64uDjB2dlZ7p8FwEdvvUJpaSkuXLiAnTt3Yv78+di6dWu7jvP09MSnn34KAFi5ciWsrKwwfPhw2NnZISQkBC4uLti3b18Xjpy6E68Tag95Xieampo4ffo06uvr8dxzz0n7VqiLyOsaWb58Oby8vPDkk0+Kx9BTvkkr97TG1rG2Zs2adqX7kydPCoIgCAcOHGj1moODg1BfXy8IgiC4u7u3eC07O1v4+uuvWx3z5ZdfCrm5uXJ//2w94zp5uPGOUu9t3XWdqKmpCQEBAUJBQYHg5uYm9/fN1vOukYebrq6uUFRUJHz11Vdyf/+8o9RHaWpqYvr06QCAvXv3tno9Pj4eAQEBAIAnnniixWtRUVFwdXVtdYyLiwvu37/fBaMleZHmOqH+Q9rrRElJCceOHcOIESMwc+bMNudAUu8m698lJSUliI+Ph4ODg2wH2gkMSn2Uh4cH1NTUUF1djVu3brW5T1BQEABg9OjRLbafOXMGo0ePhq2trXibtbU1xo0bhzNnznTdoKnbSXOdUP8hzXUiEonw/fffw9fXF/PmzcPNmze7fLzU/WT9u8TIyAjOzs4tvn0tL0ryHgB1DUdHRwBAamqqxK9XNl+ATk5OLbbv27cPa9euxenTp8ULTm7btg1paWnYs2dP1w6cupU01wnQtOoyAAwfPhwAMGPGDOTl5SEvLw9Xr17tiiGTHEhznXz55ZdYvHgxtm/fjoqKCnh5eYlfS09PR0ZGRheNmrqTNNfIiRMnEBYWhnv37qG0tBSOjo54/fXXUV9fj48//rhrB94ODEp9lL6+PgCgsLBQ4j7Nrw0YMKDF9srKSvj6+uKTTz7B4cOHIRKJcOnSJbz22muoqKjoukFTt5PmOgGAY8eOtfj5q6++AgBcvnwZPj4+shomyZk018mMGTMAABs3bsTGjRtbvPb+++9jy5YtshwqyYk018gff/yBxYsXY/369VBRUUFaWhouX76MXbt29YiV/hmU+ig1NTUAQG1trcR9ampqADSVLPm7tLQ0LFq0qGsGRz2GtNeJSCTqmoFRjyLNdfLwI3zqu6S5Rj766CN89NFHXTc4KXGOUh9VXV0NAFBRUZG4j6qqKgCgqqqqW8ZEPQ+vE2oPXif0OH35GmFQ6qOKiooA/HU7tC3NrzXvS/0PrxNqD14n9Dh9+RphUOqj4uLiAABWVlZQUmr7Cau9vX2Lfan/4XVC7cHrhB6nL18jDEp9VHh4OGpqaqCmpoZRo0a1uc+ECRMAADdu3OjOoVEPwuuE2oPXCT1OX75GGJT6qPLycvj7+wNoWkr+7xwcHODr6wug9TeXqP/gdULtweuEHqevXyNyXx6crWOtvcvJjxgxQmhoaBAaGhqEl156SbzdxMREXHzwxIkTcn8/bLxO2HidsPXcxmtE/gNge0yzsLAQ8vLyxK2srEwQBEGora1tsf3NN99sdey6devElZxTUlJaVHKOjo4WDAwM5P7+2HidsPE6Yes5jddIqyb3AbA9pllbWwvtsXnz5jaP9/X1Fc6dOyfk5+cLVVVVQkxMjLB9+3ZBU1NT7u+NjdcJG68Ttp7VeI20bKI//4GIiIiI/oaTuYmIiIgkYFAiIiIikoBBiYiIiEgCBiUiIiIiCRiUiIiIiCRgUCIiIiKSgEGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIiIhIAgYlIqI/BQYGQhAEbN68Wd5DIaIegkGJiIiISAIGJSIiIiIJGJSIiIiIJGBQIiIiIpKAQYmIqJ2eeeYZ1NbWQhAEbN++Xd7DIaJuwKBERNQOb7/9Ng4ePAgFBQWsWbMGGzdulPeQiKgbKMl7AEREPd2nn36KdevWobq6GsuWLcPx48flPSQi6iYMSkREEigrK+Pw4cNYsmQJiouLMW/ePFy5ckXewyKibsSgRETUBm1tbZw6dQq+vr7IzMzE9OnTERERIe9hEVE3Y1AiIvobU1NTXLlyBR4eHoiNjcW0adOQkpIi72ERkRyIAAjyHgQRUU8QGBgIb29v8c9VVVVwdHREenq6/AZFRHLFb70REf3N2bNnUVxcDHV1dezfvx/q6uryHhIRyQmDEhHR34SGhmLKlCkoLCzElClTcO7cOWhoaMh7WEQkBwxKRERtCA0NxeTJk1FQUAAfHx/89ttv0NTUlPewiKibMSgREUlw584d+Pr6Ii8vDxMnTsTvv/8OLS0teQ+LiLoRgxIR0SPcu3cPvr6+yM3Nxfjx4+Hv7w9tbW15D4uIugmDEhHRY0RGRsLb2xvZ2dkYO3YsLly4AF1dXXkPi4i6AYMSEVE7REdHw9vbG5mZmfDy8sLFixehp6cn72ERURfjOkpEREREEvCOEhEREZEEDEpEREREEjAoEREREUnAoEREREQkAYMSERERkQQMSkREREQSMCgRERERScCgRERERCQBgxIRERGRBAxKRERERBIwKBERERFJwKBEREREJAGDEhEREZEE/x/MK6hwrOh9nwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fg = sns.lineplot(\n",
    "    x=\"k\",\n",
    "    y=\"fail@k\",\n",
    "    data=plot_df,\n",
    "    color=\"#7FEE64\",\n",
    "    linewidth=6,\n",
    "    alpha=0.9,\n",
    "    label=\"LLaMA 3.1 8B fail@k\"\n",
    "  )\n",
    "\n",
    "initial_lim = fg.axes.get_xlim()\n",
    "fg.axes.hlines(\n",
    "      1 - gpt4o_benchmark, *initial_lim,\n",
    "      linestyle=\"--\",\n",
    "      alpha=0.6,\n",
    "      zorder=-1,\n",
    "      label=\"GPT-4o fail@1\"\n",
    "  )\n",
    "fg.axes.set_xlim(*initial_lim);\n",
    "fg.axes.set_ylabel(\"\");\n",
    "fg.axes.set_yscale(\"log\")\n",
    "fg.axes.set_xscale(\"log\")\n",
    "fg.axes.set_xlim(0.5, 2000);\n",
    "fg.axes.set_ylim(1e-2, 1e0);\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d99e643-f3c2-487b-8259-4938489a67c0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}

rune2e.sh

#!/bin/bash
set -euo pipefail
IFS=$'\n\t'

command -v modal >/dev/null 2>&1 || { echo >&2 "modal command not found. Install modal first! Aborting."; exit 1; }

echo 'downloading LLaMA 3.1 8B'
echo 'make sure to create a Secret called huggingface on Modal and accept the LLaMA 3.1 license'
modal run download_llama.py
echo 'deploying vLLM inference server'
modal deploy inference.py
echo 'running HumanEval generation'
modal run client.py --data-dir test --no-dry-run --n 1000 --subsample 100
echo 'running HumanEval evaluation'
modal run eval.py::find_missing_files
echo 'run "modal launch jupyter --volume humaneval" and upload the notebook to run the analysis'