From 3bafc214a85c9b2418a1a3a3fab9201ee8feeebc Mon Sep 17 00:00:00 2001 From: balbir Date: Sat, 18 Oct 2025 12:29:12 +0530 Subject: [PATCH] fix: put checks on data generation & minor cleanup --- generate_data.ipynb | 605 +++++++++++++++++++++++++------------------- requirements.txt | 5 + 2 files changed, 353 insertions(+), 257 deletions(-) create mode 100644 requirements.txt diff --git a/generate_data.ipynb b/generate_data.ipynb index dcc19a7..06bf560 100644 --- a/generate_data.ipynb +++ b/generate_data.ipynb @@ -1,239 +1,366 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, - "id": "5031f567", + "cell_type": "markdown", + "id": "c5f18644", "metadata": {}, - "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", - "%config InlineBackend.figure_format = 'retina'" + "### imports" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "ee222844", + "execution_count": 1, + "id": "c077aa85", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cloning into 'matplotlib'...\n", - "remote: Enumerating objects: 224, done.\u001b[K\n", - "remote: Counting objects: 100% (224/224), done.\u001b[K\n", - "remote: Compressing objects: 100% (203/203), done.\u001b[K\n", - "remote: Total 224 (delta 0), reused 91 (delta 0), pack-reused 0 (from 0)\u001b[K\n", - "Receiving objects: 100% (224/224), 137.45 KiB | 3.71 MiB/s, done.\n", - "remote: Enumerating objects: 23, done.\u001b[K\n", - "remote: Counting objects: 100% (23/23), done.\u001b[K\n", - "remote: Compressing objects: 100% (21/21), done.\u001b[K\n", - "remote: Total 23 (delta 0), reused 7 (delta 0), pack-reused 0 (from 0)\u001b[K\n", - "Receiving objects: 100% (23/23), 18.50 KiB | 1.85 MiB/s, done.\n", - "/home/nipun.batra/git/plot2code/matplotlib\n", - "remote: Enumerating objects: 539, done.\u001b[K\n", - "remote: Counting objects: 100% (539/539), done.\u001b[K\n", - "remote: Compressing objects: 100% (520/520), done.\u001b[K\n", - "remote: Total 539 (delta 15), reused 82 (delta 15), pack-reused 0 (from 0)\u001b[K\n", - "Receiving objects: 100% (539/539), 481.36 KiB | 6.88 MiB/s, done.\n", - "Resolving deltas: 100% (15/15), done.\n", - "Updating files: 100% (540/540), done.\n", - "/home/nipun.batra/git/plot2code\n" - ] - } - ], + "outputs": [], "source": [ - "!git clone --depth 1 --filter=blob:none --sparse https://github.com/matplotlib/matplotlib.git\n", - "%cd matplotlib\n", - "!git sparse-checkout init --cone\n", - "!git sparse-checkout set galleries/examples\n", - "%cd ..\n" + "import shutil, os, subprocess\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "from tqdm import tqdm\n", + "import json\n", + "import random\n", + "from PIL import Image\n", + "from IPython.display import display, Markdown\n" ] }, { "cell_type": "code", - "execution_count": 1, - "id": "888c3101", + "execution_count": 2, + "id": "5031f567", "metadata": {}, "outputs": [], "source": [ - "import shutil, os\n", - "from pathlib import Path" + "%config InlineBackend.figure_format = 'retina'" ] }, { "cell_type": "code", "execution_count": null, - "id": "0d57e8c9", + "id": "502ae55c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🗑️ deleted matplotlib/galleries/examples/event_handling\n", - "🗑️ deleted matplotlib/galleries/examples/subplots_axes_and_figures\n", - "🗑️ deleted matplotlib/galleries/examples/misc\n", - "🗑️ deleted matplotlib/galleries/examples/animation\n", - "🗑️ deleted matplotlib/galleries/examples/widgets\n", - "🗑️ deleted matplotlib/galleries/examples/specialty_plots\n", - "🗑️ deleted matplotlib/galleries/examples/style_sheets\n", - "🗑️ deleted matplotlib/galleries/examples/axisartist\n", - "🗑️ deleted matplotlib/galleries/examples/images_contours_and_fields\n", - "🗑️ deleted matplotlib/galleries/examples/spines\n", - "🗑️ deleted matplotlib/galleries/examples/ticks\n", - "🗑️ deleted matplotlib/galleries/examples/color\n", - "🗑️ deleted matplotlib/galleries/examples/axes_grid1\n", - "🗑️ deleted matplotlib/galleries/examples/showcase\n", - "🗑️ deleted matplotlib/galleries/examples/shapes_and_collections\n", - "🗑️ deleted matplotlib/galleries/examples/text_labels_and_annotations\n", - "🗑️ deleted matplotlib/galleries/examples/units\n", - "🗑️ deleted matplotlib/galleries/examples/user_interfaces\n", - "🗑️ deleted matplotlib/galleries/examples/pyplots\n", - "🗑️ deleted matplotlib/galleries/examples/scales\n" - ] - } - ], + "outputs": [], "source": [ + "def generate_matplotlib_data(limit=100):\n", + " if os.path.exists(\"plot2code_exec.jsonl\") and len(open(\"plot2code_exec.jsonl\").readlines()) > 0:\n", + " print(f\"⚠️ dataset already exists, skipping data generation\")\n", + " return\n", + " \n", + " print(\"dataset not found, generating new data...\")\n", + " # download matplotlib examples\n", + " !git clone --depth 1 --filter=blob:none --sparse https://github.com/matplotlib/matplotlib.git\n", + " %cd matplotlib\n", + " !git sparse-checkout init --cone\n", + " !git sparse-checkout set galleries/examples\n", + " %cd ..\n", + " \n", + " root = Path(\"matplotlib/galleries/examples\")\n", + " keep = [\"lines_bars_and_markers\", \"pie_and_polar_charts\", \"statistics\", \"mplot3d\"]\n", + "\n", + " for p in root.iterdir():\n", + " if p.is_dir() and p.name not in keep:\n", + " shutil.rmtree(p)\n", + " print(\"🗑️ deleted\", p)\n", + " \n", + " \n", + " \n", + " gallery_dir = Path(\"plot_gallery_exec\")\n", + " gallery_dir.mkdir(exist_ok=True)\n", "\n", + " dataset = []\n", "\n", - "root = Path(\"matplotlib/galleries/examples\")\n", - "keep = [\n", - " \"lines_bars_and_markers\",\n", - " \"statistics\",\n", - " \"pie_and_polar_charts\",\n", - " \"mplot3d\"\n", - "]\n", + " examples = list(root.rglob(\"*.py\"))\n", "\n", - "for p in root.iterdir():\n", - " if p.is_dir() and p.name not in keep:\n", - " shutil.rmtree(p)\n", - " print(\"🗑️ deleted\", p)\n" + " for f in tqdm(examples[:min(limit,len(examples))]):\n", + " out_png = gallery_dir / (f.stem + \".png\")\n", + " try:\n", + " code = open(f).read()\n", + " # run safely in isolated process using non-interactive backend\n", + " cmd = f\"\"\"import matplotlib; matplotlib.use('Agg');\n", + "import matplotlib.pyplot as plt;\n", + "exec(open(r'{f}').read());\n", + "plt.savefig(r'{out_png}');\"\"\"\n", + " subprocess.run([\"python\", \"-c\", cmd], check=True, timeout=20)\n", + " dataset.append({\"image\": str(out_png), \"code\": code})\n", + " except Exception as e:\n", + " pass\n", + "\n", + " print(f\"✅ Generated {len(dataset)} plots\")\n", + " with open(\"plot2code_exec.jsonl\", \"w\") as f:\n", + " for d in dataset:\n", + " f.write(json.dumps(d) + \"\\n\")\n", + " \n", + "\n", + "# TODO: give function args examples categories?" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "720ac3b5", + "execution_count": 6, + "id": "5ea7546f", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " 1%| | 1/100 [00:00<01:36, 1.03it/s]" + "dataset not found, generating new data...\n", + "fatal: destination path 'matplotlib' already exists and is not an empty directory.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "0.136 sec. elapsed\n", - "0.087 sec. elapsed\n" + "/mnt/bdrv/slab/plt2cd/plot2code/matplotlib\n", + "/mnt/bdrv/slab/plt2cd/plot2code\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 20/100 [00:18<01:09, 1.15it/s]Traceback (most recent call last):\n", - " File \"\", line 4, in \n", + " 0%| | 0/100 [00:00:45: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 1%| | 1/100 [00:01<02:45, 1.67s/it]:66: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 2%|▏ | 2/100 [00:03<02:35, 1.58s/it]:55: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":96: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 3%|▎ | 3/100 [00:05<03:17, 2.04s/it]:35: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 4%|▍ | 4/100 [00:06<02:35, 1.62s/it]:75: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":189: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":234: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":246: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 5%|▌ | 5/100 [00:08<02:28, 1.56s/it]:152: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":185: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":216: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 6%|▌ | 6/100 [00:09<02:14, 1.43s/it]Traceback (most recent call last):\n", + " File \"\", line 3, in \n", " File \"\", line 47, in \n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/_api/deprecation.py\", line 453, in wrapper\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/_api/deprecation.py\", line 453, in wrapper\n", " return func(*args, **kwargs)\n", " ^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/__init__.py\", line 1524, in inner\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/__init__.py\", line 1524, in inner\n", " return func(\n", " ^^^^^\n", "TypeError: Axes.violinplot() got an unexpected keyword argument 'facecolor'\n", - " 42%|████▏ | 42/100 [00:36<00:48, 1.20it/s]Traceback (most recent call last):\n", - " File \"\", line 4, in \n", - " File \"\", line 23, in \n", - "AttributeError: 'Axes' object has no attribute 'grouped_bar'\n", - " 54%|█████▍ | 54/100 [00:44<00:31, 1.46it/s]Traceback (most recent call last):\n", - " File \"\", line 4, in \n", + " 7%|▋ | 7/100 [00:10<02:03, 1.33s/it]:105: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 8%|▊ | 8/100 [00:12<02:25, 1.58s/it]:49: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":78: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":92: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":106: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":122: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":137: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 9%|▉ | 9/100 [00:14<02:26, 1.61s/it]:39: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 10%|█ | 10/100 [00:15<02:24, 1.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.225 sec. elapsed\n", + "0.105 sec. elapsed\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":93: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 11%|█ | 11/100 [00:19<03:21, 2.27s/it]:62: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 12%|█▏ | 12/100 [00:20<02:47, 1.90s/it]:34: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 13%|█▎ | 13/100 [00:22<02:43, 1.88s/it]:76: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 14%|█▍ | 14/100 [00:23<02:21, 1.65s/it]:20: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 15%|█▌ | 15/100 [00:24<02:01, 1.43s/it]:47: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 16%|█▌ | 16/100 [00:26<02:05, 1.49s/it]:50: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 17%|█▋ | 17/100 [00:27<02:04, 1.50s/it]:53: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 18%|█▊ | 18/100 [00:28<01:53, 1.39s/it]:70: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 19%|█▉ | 19/100 [00:30<01:47, 1.32s/it]:63: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 20%|██ | 20/100 [00:31<01:42, 1.28s/it]:242: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 21%|██ | 21/100 [00:33<02:11, 1.67s/it]:55: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 22%|██▏ | 22/100 [00:35<02:05, 1.61s/it]:42: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 23%|██▎ | 23/100 [00:37<02:16, 1.78s/it]:45: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":79: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 24%|██▍ | 24/100 [00:38<02:06, 1.66s/it]:24: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 25%|██▌ | 25/100 [00:40<01:56, 1.56s/it]:94: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":112: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":124: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 26%|██▌ | 26/100 [00:41<01:51, 1.50s/it]:62: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":118: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 27%|██▋ | 27/100 [00:42<01:42, 1.40s/it]:72: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 28%|██▊ | 28/100 [00:43<01:38, 1.36s/it]:28: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 29%|██▉ | 29/100 [00:45<01:34, 1.34s/it]:22: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":32: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":42: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 30%|███ | 30/100 [00:46<01:34, 1.35s/it]:21: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 31%|███ | 31/100 [00:47<01:30, 1.31s/it]:15: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":16: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 32%|███▏ | 32/100 [00:48<01:24, 1.24s/it]:98: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 33%|███▎ | 33/100 [00:53<02:22, 2.12s/it]:36: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 34%|███▍ | 34/100 [00:55<02:21, 2.14s/it]:26: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 35%|███▌ | 35/100 [00:57<02:11, 2.03s/it]:100: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 36%|███▌ | 36/100 [00:59<02:14, 2.10s/it]:31: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":64: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":100: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 37%|███▋ | 37/100 [01:01<02:12, 2.11s/it]:54: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 38%|███▊ | 38/100 [01:02<01:58, 1.90s/it]:26: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 39%|███▉ | 39/100 [01:04<01:43, 1.70s/it]:43: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":69: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":87: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 40%|████ | 40/100 [01:05<01:35, 1.59s/it]:115: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 41%|████ | 41/100 [01:08<01:56, 1.97s/it]:81: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 42%|████▏ | 42/100 [01:09<01:49, 1.88s/it]:242: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 43%|████▎ | 43/100 [01:12<01:53, 1.98s/it]:34: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 44%|████▍ | 44/100 [01:13<01:40, 1.79s/it]:15: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":16: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 45%|████▌ | 45/100 [01:14<01:28, 1.60s/it]:33: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 46%|████▌ | 46/100 [01:16<01:23, 1.55s/it]:37: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 47%|████▋ | 47/100 [01:17<01:16, 1.44s/it]:53: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 48%|████▊ | 48/100 [01:20<01:34, 1.83s/it]:77: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 49%|████▉ | 49/100 [01:21<01:24, 1.66s/it]Traceback (most recent call last):\n", + " File \"\", line 3, in \n", " File \"\", line 54, in \n", " File \"\", line 36, in hat_graph\n", "AttributeError: 'Axes' object has no attribute 'grouped_bar'\n", - " 62%|██████▏ | 62/100 [00:50<00:30, 1.26it/s]Traceback (most recent call last):\n", - " File \"\", line 4, in \n", + " 50%|█████ | 50/100 [01:22<01:12, 1.45s/it]:35: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":102: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":140: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":180: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 51%|█████ | 51/100 [01:23<01:12, 1.49s/it]:47: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 52%|█████▏ | 52/100 [01:25<01:07, 1.41s/it]Traceback (most recent call last):\n", + " File \"\", line 3, in \n", + " File \"\", line 23, in \n", + "AttributeError: 'Axes' object has no attribute 'grouped_bar'\n", + " 53%|█████▎ | 53/100 [01:26<01:00, 1.29s/it]:62: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 54%|█████▍ | 54/100 [01:27<00:57, 1.24s/it]:93: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":107: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":180: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 55%|█████▌ | 55/100 [01:28<00:54, 1.22s/it]:16: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":29: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 56%|█████▌ | 56/100 [01:29<00:53, 1.20s/it]:139: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 57%|█████▋ | 57/100 [01:30<00:53, 1.24s/it]:24: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 58%|█████▊ | 58/100 [01:32<00:54, 1.29s/it]:50: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 59%|█████▉ | 59/100 [01:33<00:54, 1.32s/it]:28: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 60%|██████ | 60/100 [01:35<00:53, 1.34s/it]Traceback (most recent call last):\n", + " File \"\", line 3, in \n", " File \"\", line 22, in \n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/__init__.py\", line 1524, in inner\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/__init__.py\", line 1524, in inner\n", " return func(\n", " ^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/axes/_axes.py\", line 3067, in broken_barh\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/axes/_axes.py\", line 3067, in broken_barh\n", " col = mcoll.PolyCollection(np.array(vertices), **kwargs)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/collections.py\", line 1201, in __init__\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/collections.py\", line 1201, in __init__\n", " super().__init__(**kwargs)\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/collections.py\", line 209, in __init__\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/collections.py\", line 209, in __init__\n", " self._internal_update(kwargs)\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/artist.py\", line 1233, in _internal_update\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/artist.py\", line 1233, in _internal_update\n", " return self._update_props(\n", " ^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/artist.py\", line 1206, in _update_props\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/artist.py\", line 1206, in _update_props\n", " raise AttributeError(\n", "AttributeError: PolyCollection.set() got an unexpected keyword argument 'align'\n", - " 87%|████████▋ | 87/100 [01:16<00:25, 1.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average FPS: 26.543936\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 89%|████████▉ | 89/100 [01:18<00:15, 1.42s/it]Traceback (most recent call last):\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/texmanager.py\", line 250, in _run_checked_subprocess\n", - " report = subprocess.check_output(\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.local/share/uv/python/cpython-3.12.12-linux-x86_64-gnu/lib/python3.12/subprocess.py\", line 466, in check_output\n", - " return run(*popenargs, stdout=PIPE, timeout=timeout, check=True,\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.local/share/uv/python/cpython-3.12.12-linux-x86_64-gnu/lib/python3.12/subprocess.py\", line 548, in run\n", - " with Popen(*popenargs, **kwargs) as process:\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.local/share/uv/python/cpython-3.12.12-linux-x86_64-gnu/lib/python3.12/subprocess.py\", line 1026, in __init__\n", - " self._execute_child(args, executable, preexec_fn, close_fds,\n", - " File \"/home/nipun.batra/.local/share/uv/python/cpython-3.12.12-linux-x86_64-gnu/lib/python3.12/subprocess.py\", line 1955, in _execute_child\n", - " raise child_exception_type(errno_num, err_msg, err_filename)\n", - "FileNotFoundError: [Errno 2] No such file or directory: 'latex'\n", - "\n", - "The above exception was the direct cause of the following exception:\n", - "\n", - "Traceback (most recent call last):\n", - " File \"\", line 4, in \n", + " 61%|██████ | 61/100 [01:36<00:51, 1.33s/it]:32: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 62%|██████▏ | 62/100 [01:37<00:50, 1.33s/it]:40: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 63%|██████▎ | 63/100 [01:39<00:53, 1.45s/it]:42: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":75: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 64%|██████▍ | 64/100 [01:40<00:49, 1.38s/it]:32: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 66%|██████▌ | 66/100 [01:44<00:54, 1.59s/it]:73: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 67%|██████▋ | 67/100 [01:45<00:56, 1.71s/it]:31: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":44: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 68%|██████▊ | 68/100 [01:47<00:52, 1.64s/it]:62: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":77: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 69%|██████▉ | 69/100 [01:49<00:50, 1.64s/it]:53: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 70%|███████ | 70/100 [01:50<00:48, 1.60s/it]:45: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":82: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 71%|███████ | 71/100 [01:52<00:50, 1.74s/it]:69: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 72%|███████▏ | 72/100 [01:54<00:52, 1.88s/it]:49: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 73%|███████▎ | 73/100 [01:56<00:49, 1.83s/it]:40: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 74%|███████▍ | 74/100 [01:58<00:45, 1.76s/it]:37: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + ":55: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 75%|███████▌ | 75/100 [02:00<00:44, 1.78s/it]:62: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 76%|███████▌ | 76/100 [02:02<00:44, 1.85s/it]:36: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 77%|███████▋ | 77/100 [02:04<00:49, 2.14s/it]:51: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 78%|███████▊ | 78/100 [02:08<00:58, 2.67s/it]:44: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 79%|███████▉ | 79/100 [02:13<01:10, 3.35s/it]:88: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 80%|████████ | 80/100 [02:15<00:56, 2.85s/it]:46: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 81%|████████ | 81/100 [02:17<00:47, 2.49s/it]:51: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 82%|████████▏ | 82/100 [02:37<02:19, 7.75s/it]:46: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 83%|████████▎ | 83/100 [02:38<01:38, 5.78s/it]:21: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 84%|████████▍ | 84/100 [02:39<01:10, 4.41s/it]:78: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 85%|████████▌ | 85/100 [02:42<00:58, 3.90s/it]:29: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 86%|████████▌ | 86/100 [02:43<00:45, 3.22s/it]:33: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 87%|████████▋ | 87/100 [02:45<00:34, 2.68s/it]:29: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 88%|████████▊ | 88/100 [02:46<00:27, 2.30s/it]:34: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 89%|████████▉ | 89/100 [02:48<00:22, 2.07s/it]:89: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 90%|█████████ | 90/100 [02:53<00:30, 3.06s/it]:32: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 91%|█████████ | 91/100 [02:54<00:22, 2.54s/it]:45: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 92%|█████████▏| 92/100 [02:56<00:17, 2.16s/it]:31: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 93%|█████████▎| 93/100 [02:57<00:13, 1.91s/it]:35: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 94%|█████████▍| 94/100 [02:58<00:10, 1.69s/it]:28: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 95%|█████████▌| 95/100 [03:00<00:08, 1.76s/it]:19: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 96%|█████████▌| 96/100 [03:01<00:06, 1.58s/it]:47: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 97%|█████████▋| 97/100 [03:03<00:04, 1.53s/it]:37: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 98%|█████████▊| 98/100 [03:05<00:03, 1.71s/it]:34: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " 99%|█████████▉| 99/100 [03:07<00:01, 1.85s/it]Traceback (most recent call last):\n", + " File \"\", line 3, in \n", " File \"\", line 61, in \n", " File \"\", line 36, in text3d\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/textpath.py\", line 355, in __init__\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/textpath.py\", line 355, in __init__\n", " *text_to_path.get_text_path(prop, s, ismath=ismath),\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/textpath.py\", line 109, in get_text_path\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/textpath.py\", line 109, in get_text_path\n", " glyph_info, glyph_map, rects = self.get_glyphs_tex(prop, s)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/textpath.py\", line 219, in get_glyphs_tex\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/textpath.py\", line 219, in get_glyphs_tex\n", " dvifile = TexManager().make_dvi(s, self.FONT_SCALE)\n", " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/texmanager.py\", line 293, in make_dvi\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/texmanager.py\", line 293, in make_dvi\n", " cls._run_checked_subprocess(\n", - " File \"/home/nipun.batra/.uv/nb-base/lib/python3.12/site-packages/matplotlib/texmanager.py\", line 254, in _run_checked_subprocess\n", + " File \"/home/balbir/ba/slab/plt2cd/plot2code/.venv/lib/python3.12/site-packages/matplotlib/texmanager.py\", line 258, in _run_checked_subprocess\n", " raise RuntimeError(\n", - "RuntimeError: Failed to process string with tex because latex could not be found\n", - "100%|██████████| 100/100 [01:25<00:00, 1.16it/s]" + "RuntimeError: latex was not able to process the following string:\n", + "b'$\\\\\\\\displaystyle G_{\\\\\\\\mu\\\\\\\\nu} + \\\\\\\\Lambda g_{\\\\\\\\mu\\\\\\\\nu} = \\\\\\\\frac{8\\\\\\\\pi G}{c^4} T_{\\\\\\\\mu\\\\\\\\nu} $'\n", + "\n", + "Here is the full command invocation and its output:\n", + "\n", + "latex -interaction=nonstopmode --halt-on-error file.tex\n", + "\n", + "This is pdfTeX, Version 3.141592653-2.6-1.40.25 (TeX Live 2023/Debian) (preloaded format=latex)\n", + " restricted \\write18 enabled.\n", + "entering extended mode\n", + "(./file.tex\n", + "LaTeX2e <2023-11-01> patch level 1\n", + "L3 programming layer <2024-01-22>\n", + "(/usr/share/texlive/texmf-dist/tex/latex/base/article.cls\n", + "Document Class: article 2023/05/17 v1.4n Standard LaTeX document class\n", + "(/usr/share/texlive/texmf-dist/tex/latex/base/size10.clo))\n", + "(/usr/share/texlive/texmf-dist/tex/latex/type1cm/type1cm.sty)\n", + "\n", + "! LaTeX Error: File `type1ec.sty' not found.\n", + "\n", + "Type X to quit or to proceed,\n", + "or enter new name. (Default extension: sty)\n", + "\n", + "Enter file name: \n", + "! Emergency stop.\n", + " \n", + " \n", + "l.8 \\usepackage\n", + " [utf8]{inputenc}^^M\n", + "No pages of output.\n", + "Transcript written on file.log.\n", + "\n", + "\n", + "\n", + "100%|██████████| 100/100 [03:08<00:00, 1.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "✅ Generated 95 plots\n" + "✅ Generated 94 plots\n" ] }, { @@ -245,44 +372,12 @@ } ], "source": [ - "import os, subprocess, matplotlib.pyplot as plt\n", - "from pathlib import Path\n", - "from tqdm import tqdm\n", - "import json\n", - "\n", - "root = Path(\"matplotlib/galleries/examples\")\n", - "gallery_dir = Path(\"plot_gallery_exec\")\n", - "gallery_dir.mkdir(exist_ok=True)\n", - "\n", - "dataset = []\n", - "\n", - "examples = list(root.rglob(\"*.py\"))\n", - "\n", - "for f in tqdm(examples[:100]): # limit to 100 for demo\n", - " out_png = gallery_dir / (f.stem + \".png\")\n", - " try:\n", - " code = open(f).read()\n", - " # run safely in isolated process using non-interactive backend\n", - " cmd = f\"\"\"\n", - "import matplotlib; matplotlib.use('Agg');\n", - "import matplotlib.pyplot as plt;\n", - "exec(open(r'{f}').read());\n", - "plt.savefig(r'{out_png}');\n", - "\"\"\"\n", - " subprocess.run([\"python\", \"-c\", cmd], check=True, timeout=20)\n", - " dataset.append({\"image\": str(out_png), \"code\": code})\n", - " except Exception as e:\n", - " pass\n", - "\n", - "print(f\"✅ Generated {len(dataset)} plots\")\n", - "with open(\"plot2code_exec.jsonl\", \"w\") as f:\n", - " for d in dataset:\n", - " f.write(json.dumps(d) + \"\\n\")\n" + "generate_matplotlib_data()" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 7, "id": "6ed9e220", "metadata": {}, "outputs": [ @@ -290,13 +385,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "✅ Loaded 95 samples\n" + "✅ Loaded 94 samples\n" ] }, { "data": { "text/markdown": [ - "### 🖼️ `scatter_hist.png`" + "### 🖼️ `step_demo.png`" ], "text/plain": [ "" @@ -307,7 +402,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -320,17 +415,21 @@ "text/markdown": [ "```python\n", "\"\"\"\n", - "============================\n", - "Scatter plot with histograms\n", - "============================\n", + "=========\n", + "Step Demo\n", + "=========\n", "\n", - "Add histograms to the x-axes and y-axes margins of a scatter plot.\n", + "This example demonstrates the use of `.pyplot.step` for piece-wise constant\n", + "curves. In particular, it illustrates the effect of the parameter *where*\n", + "on the step position.\n", "\n", - "This layout features a central scatter plot illustrating the relationship\n", - "between x and y, a histogram at the top displaying the distribution of x, and a\n", - "histogram on the right showing the distribution of y.\n", + ".. note::\n", "\n", - "For a nice alignment of the mai...\n", + " For the common case that you know the edge positions, use `.pyplot.stairs`\n", + " instead.\n", + "\n", + "The circular markers created with `.pyplot.plot` show the actual data\n", + "positions so that ...\n", "```" ], "text/plain": [ @@ -343,7 +442,7 @@ { "data": { "text/markdown": [ - "### 🖼️ `histogram_cumulative.png`" + "### 🖼️ `scatter_with_legend.png`" ], "text/plain": [ "" @@ -354,7 +453,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASwAAADICAYAAABS39xVAABhXUlEQVR4Ae2dB2BVRdbH/6mkEHoCofcmVYqISJEmoNjQxd7buquurm1Xdy3oquu39t57A5WigqBUKdKV3nvvLR2++U244RES8l5yQ16Se/TxXm4598yZuf85c+bMmZAjhuSRpwFPA54GioEGQouBjJ6Ip1AD6enpSktLy/GJnEtJScnxXE4HHV7JycnKq19MSkqyz83t2Q7/w4cPC34elU4NeIBVAut9xIgR+u9//6vVq1cHXLqpU6fql19+Oe6+bdu2ae/evVq6dKnGjRt33LmT/TFz5kzLa+jQodq3b1/Wpbt27dL27duz/ubHV199pZ9//lljx4497rjzB/fs2LFDO3futNc6x73v0qUBD7BKWH0DKOPHj1etWrU0b968LGsEywiL59ChQ9q/f7+wVBwQcSwWrsHC4cMxAAICSMaMGaPatWurS5cuWVaWcx984OtLBw8etPy55rzzzlO5cuUs6HHtjBkzBKhyDef37NmjCy64QKGhoVa2nOSaPn26hg8frujoaA0cONA+ChDLyMiwZcFCgw/EMUCW8npUsjQQXrKK45Vm8uTJuvPOO1WvXj07DHv55Zd166236v3331eTJk3sd0REhBo1aqSFCxfq8ccf1w8//KCbbrrJnqtbt64iIyOFVTRq1Cj9+c9/1pIlSzR37lxxHwADUNx+++16++231b17d73yyisWSOAFMGEF3X///fYbvgBNy5Yt7XXNmjVTeHi4Ro8erapVq+rTTz9Vp06dFBMTY0H266+/ts995JFHrDV344036sMPP7RgBBhXr17d/q5fv76eeuop9ejRQ3379rW/AeF///vfFrDRw1133aUOHTp4jaIEacADrBJUmRQlNTVVFSpUsKUKCQkRlgcE0GDRtG3b1oLZ2rVrdckll1grzLFEuAbi7wsvvFCAwqRJk+xLDzBUrFhRy5YtsxbYqlWr7HW//fab+vXrpxUrVojfvXr10q+//qoBAwZYqwvLC5kAR4DpuuuuE2ACoLZu3Vo//fSTBcVXX33Vyti5c2d17NjRDiUdfxY8ALrGjRurffv2Fkyx+l544QULeMjUvHlzC55Yb+vXr9fTTz+tGjVq2PJ4/5QcDXhDwpJTl1klwdJwCNBiqMUHatiwoapUqWKtrUqVKlkwcc5zrfPBInvvvfeslcT5sLAwywMrq06dOhZQGHbii2K4uHHjRmsx8YwDBw7Y4SNWXFRUlAU4gAjQApggrCyeBQjB03kufyMjPCBHNn5zD38z5OMbOapVq2aHmjwrISHBysmzHnjgAfs87vOo5GjAA6ySU5e2JImJiZo2bZq1VrCisJYAkw0bNtiXHDDjw0vPh+Efviuu2bRpk71m9+7d1v/ESw9IcB3Wl3Mv4MAwEmABMAYPHmwtGoacUNmyZbVu3TotX7486z6GfAzh8C1t3brVPhN+zuwh33xw7GOtYc1hYSEXH+TAWuQewJNvyrdlyxaVL1/eysgx5Ozdu7cYSgYyQWAF9/4Jeg14gBX0VRSYgJdddplGjhxp/VaLFi2yFgz+IF5+rB0ACouGb0CA4WPlypX18MMPWyDgOJZKmTJlrH+LbwDqk08+sQDE3wwVATmc8AwBP/jgA919990WiJD2rLPO0vfff6/vvvvOgklcXJwWLFhg/V7IwHnOMYTkHMRxgG7WrFl64403dO6551qLDbkA3aZNm1pfGEM+AKpnz572mbGxscLvRlkAMvj873//s9YhQ0uPSpYGQkyv5gWOlqw6tVYGM4Hx8fHWamH2DAuHYRTE8Itq59v5m5k5Xn5naMZ5fF7cB4jhaAcMADs++JWYseN6hm/4qRhiOuQM6bgHCw0wwXIDbODHbwc4+RsARD6AFYDCec99yIUMACX3cK1zHzLBD+JaQIt74YGlBRB7VLI04AFWyapPrzSeBkq0BrwhYYmuXq9wngZKlgY8wCpZ9emVxtNAidaAB1glunq9wnkaKFka8ACrZNWnVxpPAyVaA3kCFrMtLHz1JZZeeORpwNOAp4FTrYE8AWvKlCn65z//aaeNEY6gxH/84x8nrOg/1YJ7z/M04Gmg9Gkgz7WE3c3iVha/EmdD3M0ff/yhe+65xwLWOeeckxUlnZPqnHifnM4FeszjFajGjsVbBX7niXfkpv8QEzsVFm4CUcNN9LmJhSIOKtTEXKWmm+VBh8mrlRnrBUdiuwgUJTAVIq6KT3biWXxCw8zynSMmGp7/TLQgsVwKCdXh9FTzFWririLsrampKYqMiLRxXBkm2j3dxGFFmrgtYrP4EAGPFDz/MIzySbnpIJ/sbBmRyQ1yU7Zg5EWMHWtD8wQsJ4LYUSoKJiDRIRrcsGHDNH/+fJ122mm2EjhH8B4gRzBiQclNXshCMCKBiW6Qm7wI1HQCIwsqm5s6y+JV1kSlG8AAPSxghIVqx7ZN2rpgskbPWqkaNWurlVnQvG71cnVpUVdlarYyoJWRVRTaDm2CjArQ4sWLbWYG1iMSTQ+wQOhh3/692r9+kVJiqlkwjI6O0tqVy3TowH7VaNVVO7dv0+zZs3TE3HP+wAs07qcx2rZls+qaRdXtOpyhcT+MUJ3aNVW/yWkmw0OiDJzawNfYqExgQxbzvymLeSYfPyjo68eFdw01uNmm3eBFQDHLs+699968AcupR1CXxsbNvsnXWEt233336YsvvrBrypzrnShl1oQVlNzkhSysZSO1iRvkJi/AHyC1lkQBhXNTZ5bX/oOqWCFa+vUFI5kBodRk/bZij7ambNXzG7frcK0OSm7XV0satlWVxIV66NIqimx96QmlIJ0MYEF7YpEyy2pYQsQSH4d27tqtQ7vW643Pvta4yJ4qE2LyWoVGqFK1tfrnkc91IHa/0muH6bJGzQ2vw6YD3aOOfapo/44MxcaFqVL1bYqtc0Cr969Q25jy2rRxs4bP3ayGdWvpxztPV0ZasiLMaEFlDPg2HySVb+w8+qTfQV0/phN2411DAW62abd4kZ0D/MnTwmK9F7mLWHPGMghSgrBWizVrDtEAGQo4DZHjMOfjBrnJy5HNDbkKgxdLVFiKUlCCj1v6t7wyDGjs32he8hjN2lZWDz/ymGZsTNVN9/9bX435r0LKGqub4ZoZgoXtrKSIfUtOKEKmVXP8EAgZaTu+dCgpWTXLR+rBfqfp7uZdjlpARxSqTqqccqbBS5MyB0vPgJ4lLDOGi6YzNWM+a9UN/ssTOphmkhQaCzBVEWr92wK9Puo33Tmzssa8+6yqxYbovC4tdFaHg9pco69iw9KVlJyiStFh6t6upULKJfqKZH8ja9DWj0vvGgV1q924yYs2QieXJ2AxzHvrrbfsWi7WhfFp0KBBruu0aJT0RE4eJKwxjhWEGJLQUNzghRzMfJI1wA3KixfWEmvsUHZxJWQvExGuaTP+0PYN5qWtWltdr7pXFaNaqv0ZjVQlwfflNqCREmnGFQUrLdqKi45QXGy2Jlq2kd+McUbsOlxedWok6obWZ6tuj8s1YclWXfNUa+1fMVtJISnatGGRXvhXTw3qXE8Xn9dXi7Yd0o7dY3W495NmEGl8aYZH5bJm/WTxrT6/9VUcLszWGk4UGR9Udj9UbotKadjOoleuYSiBD6ygBOC5xQtZmDxgAa0blBcvgBvfB5kIiiuFmTp86tHHNPa7z9Wu90AtqtfRjKbaKCrtiM5vYSyr7ISV4wYVsKOzIhw+Zr2d07CC+EikwTnLnt534JB2JZjsEcNHqGeLm/TFmEVaM/lj1V//FyWnZijNTB6c3aCCqjU/Q6HV+hgjzkMuq7gi+qfgaJJNcBynvJwAgpsgg0noBvghLlaPW4CVFy98flhhxZUWGcd4mehYhUVG6703X9TSNWvVoVEdXdomQby7MZGuN6FTqqpyZWN02y036aYbrrNWcJWPP9aL387Rw3c019UmvfPEhds0ycQdnrd1kbZEm3z4GREqfyTDDh096DqlVWUfVmitLSd/hb/FIzAVQOFlJ2gVBzn8cODxzd8FGWLBwy3Ki1de592Sw20+Gcn79OWLj+jpd77Rh3/pqifPrquZv3+tObsbqeeZsaoUa4Z9JYiczvC/zz5jUz4vXbZcK3ZF6qcF2zV2f3VFapSO/PaADodEKsqA9AAsy8RWUsvBJUgLwV+UQgOsUHw2+TCfcfIz40iSOLJJYqUBUOQIf+6552xe8Kuvvto1ayv4q6hoJFyyeIle+3Ks9V+2alJDQ4bP1ZHoVnrk+nMVHVuuaIQ6BU/FYu7dq6f9EDYx9MWH1ePcger10CPSnnUqayZEhoxZaXxhSRq4eIwS0qqpSU2TdyvDdIKER8SZ2ec4X5/eKRC6FD2i0ABrz6FUHUxJM5bSSR5h6riccaxGRZgZnqPEvnTsuIKjml1Z2J3lnXfe0Zw5c2ymyosuusgDK0dZhfDNDNFrb7ylwb1O18i3HlPF9v20cMtBTUjer/vPbWICP8sXwlODk2W7du012qSC/s9TT2rbQTP5GF5HDWvWUYez6mnyil0KNVbo0p8/UJ3TaijKBM4qI8V00qa993kicxYzOItVrKU6CZrkv1wRJqDwv98v0ZiFm83s0jEwys4xNS1DT13SSr2bZcZEYU0xDMRhz5AQMx2fGDusrFmzxu5nxyylb0hFdp7e3/nXAMNvtvU6EhKuWwd1VbTR9ZTV+3Tju1N0WftaOrdZlfwzL6Z30vbeevsduxkHneWDDz6k/v37qW/TyjqQ2kjnvjBJv6UnaEj/pqaEpgee/kampUXYhUeua6BQACst47Du69NIf+5W1y8LyykV5jgAhQ8LCwtHOwDGDsYEVLKBprOJpnOP9+2eBtislAmTV8zONhGH1mnMlHV6ffcy/aVrHV3WJofZQPceHfScaI/s93j33XeZEJ9Im1O+rHHjvXdtW932yRyNXVzJdLylW0enohILBbAQvEJMpMpFma2hzHqwQIgdT5599lm7I8vmzZvtwmt8WGeffbbdBCEQXt61/mmAjuGjTz43+xRepN5mU9I9ZmSTtjtJSzftU+vG5cyLWFERpdxgYJKHtsnWZnSev//+u1q1aqUG8WWNfhL0yfQ1Nvwhyj+Ve1flUwOBoUkAD2GRaYaJxwnNfUSYIzd2OiEwNfssIZYXxz1yVwPo9Z+P/Eurx7ylq6ou1JHQSP26YLMiknaoY6v+6tS/sVKSzTbwewsYCequ2EXCjfCUdu3aWVfFpZdeajd1ZSu0e/o0UZ/nJ2nIyIUaUt+8UvixPCoUDQSlZn0DUxmiEBrAx63YqULRZDFlOmnKVP0xaaQ++79HFNmit7buOqBV29fpLvMSpperZ0tFx+NRpgaYlMC3yoz1lVdeqZo1a9rvt69przs+mam15r861eaYi4++Wt7MoatNJygBK3sJi2ssU/ZyBNvfbJxKloQP3npVFcL2SPHNFR57WBsXmqj8BPM72AQOInnYdfrzzz+325+xZKxx1XgTKV9To5dE6taFw8yU4tExdIZZT+vNHLpWc4XcJr1YYNdqymVGzLrefPPN+vizz5VQs5a0YbvW7k7Ri2MXK9ksGvYobw3gz+LDztc333Sj7urVW7dsGqBre7STcd8eo+mvezOHx7RRoF+F50plWjdQB9bRohAw6rtiHIcns4W5EVuic49DhEfgm2Er8x07djiHs76dKHly9eA8hZiZXLVqVdY1LLj2h04mlz/3F8U1rG+86667NGjQIFWNr8LyfLNeKVTTV+/Vyu0HdHHbGkUhVrF95m233WbDHZYvXmhyd4Vq94HkY2XxyQd27KD3K78aKBwLywBVyOa5Cpv3uRRh5k1yWgpDJDzmcqvBUvU2Vn6Gfu+++66dDcT5ft5551m/FeAFgABExGEBRuwEDHGMfEr4EvAt4PMiyJQZxh49eth1g1zPB3BhF2QnSR5xR1OnTrU5mVjgTViFs4sxW62TqYJ0OtyDXw05OM8skZNBgmMsgCaTJrstA4aUAzmD1ecGOOM8vvXWW60O7T9G7hmrd+qO7g3Vq3nVY8e9X3lqoHv37vq7yQm3beN61U1orDDadhZ5/r8sVbjwo3AAK8TYw9sX63DNjgpNaJI7YO1cIW1bnAVYgAxpX55++mkLDCzRIZxh5syZWrBggU1ZQ04uQKlly5Y21S7WFaDF1Pw333xjgQlAmTx5chZAATrwBeTIUZ+YmKgbb7zRAgpLgXhuv3797DWkgwb8eB73EANG8jCunzt3rri+T58+Vib4QgyvCGYlTxjARz6rhg0biiVEwUaUgYDQf/3rX8dEM1bBmi37tGTLfv29Z91jx71ffmvgT3/6k5IOHdRTf3tOzeNv1CWn1/T7Xu9C/zVQOIDF802GSCW0lKoawMqNImKkTXOzzpJHiwymWClYLEwjY60whCEPOHEvODixlhgCkqoZC4frsa6qVKkilvZgmd1www0W9DjugBpDQHiSl578WgDdWWedJRyoXINFBD+sD3536tRJWFoPPvigvvzyS7um8Sazgp/UvoAejRQwAwQBujPOOMNaVtWrV7dWHwVzhp9ZhSzCH1iU9977d91vku9VrJ05bCYRXtShdE1euk11Kp+u+LgyRShhMX+00WXYmulmlBCqc5o9pLgyYd7EhctVWniAlQ9BSfEKEDkgBTABMoAIVhUghiXFEI1rOM4wjCjkhQsXWhAiUT1gxHXcD7CMGzfOAiGWF0PN5s2bW2sLHvBkiMj1AN7ll1+uzz77zIIh5x3Ayf6NrMgxe/ZsNWnSxAIh1h9Ax7dzfT7UUGi3PPPcC+rSsbWqbR2tyS+9o3BWFpgUdRWO7NaClJa6pEctsazKo/xpANfAG6+9ou7nXarO/6ir124foB6NK+SPmXdXjhooPMBix5Stf5jhoPFTmRf/BGKcz5Aw45hzG3DBasKi6dq1q03LzMJnLB6Gc/igsJj4MOQaOnSo/c0QDuDBHwWInHvuuTatMxkfyBnOvaR4hs+rZtnJrl27bBAq/AAr+OFzwi/1448/2mEdVtfw4cPNBgbV7RAVy4qNNliQzTDVuScpKckOKQkPAOAALPjCr8gJve9cbsLWk4wvMVKNYg+o/5nNNXzyLF18xd2qUtYM3W3dhKh9dC3FlC1X5CIXdwEIbh76weuatNk4300CAGNjF/ciBZX8hQNYJsGZ4pspFKf7VjMLlxtgOU73oyrBKgEYyHuFk5u/AR98QlhAjsPdAYZmzZrZYzjLARCGcHxjjQFWABW93h133JEFdmSCYCgIqDD87N+/v/3dvn17+zyGTTyPDzOMWFLdunWz1he8GJICZgz/4M9sGyDF9cgFwRsAg5xj9o9T+Q8ztHs3SEve0SGV05iJ03T9BX20ePU8hTQyOq3X5rh3yYMq9yqHtrFk2A9aMG66Lm7zV/cYe5wKaYhtpnKPJLZVRtU2JrIhsB4GkAJIHAIweOkBJefje875zTdWlEMMEx3CinLIWVTN346F5Zzjm2GhQ85v5xsAQzaA0eHJ8A+QzE7IWrRk9J52UGp9kd75cYOWpKXqom6P6I2tC9T3tATFBFYtRVuUYvj0KtVr6e8PPKQ/9euuJqZD88gdDRSew4IlCQa43CAAy01LBd9Wfoih4DXXXJMFVvDIL6/8PD/Qe9hodL2ZIPhm2Ff654P3aV9yurFU09QysWygrLzrA9RAh9YtVO3MC/XiC89n3ul1EAFqMOfLTzQNcr4un0dz8F3lk5N3W+AaiDBJ5fbv26s7TBLEhOo11N/kbjLIr/ImaaJHhauB9LQU9ew/UNc1MZ1j+hwz/C4826BwSxJc3INai8wCepQ/DYQbsPpj+TqTrbehLr3kQi1cv0e1KkZr2O2dbZbX/HH17vJXA0fMgvEYs1t1m9M7aMgXv5mYvh3+3upddxINFLKFdZIn53CKWChm5hj+4WvCcd7DRKvj18Kx7ZH/GggxOhzy3Mu65coLVbZ9mmas2aVmieU8sPJfhQW+8pBJEZ5hkllm7F6vF198SU8+OaTAPEs7g0KzsACZQB3PhBDUrl3bzsy1aNFCEydO1MiRI62fiJXxRK8TRvD666/bQM958+bpvffe06RJk2zsFUtyPMrUwKjRY1UtOkNLdiWr78vT9caElepQt5KnnlOkgbJR4Zq9Zremrtimh244V/PmzNKyFauOPT2f62yPMSidv/K0sAgB+OSTT+xSmNNPP93GKhH1zWxZz549cw2QBFhYs8YMGrNsRKvz4W+sJ85hSRF3xWwdxLIWwgGIpeI4oMeyl9GjR9tYJ5bJrFixwoYQ/PLLL/Y6gjaXLl1qLbCNGzcKGUslGV3amKtUE3MVGaHFE75W147NlVgzTjecd4bCzPkKJWxrrmCuZ/yEN3errxd+Xq77ym7T6Z3aK33bEqlicuZi89A449cqF8xFCErZ8rSwZs2aZaPJx48fb2OhCJ5keQvfAAvka005w7cJEybYAMvOnTvbdXlDhgwRv1nOwho9tu0i5SyR7L4EQPIh7urMM88UsVYshVm3bp0NWyCy/ZJLLrExUMQ+9erVywaBAmBYZcFI6MQfArgd8Pbn+uOu2b9JmvSctHS49k54S3d3raJK4QdVv+npqmqSj1cxS27C87HtGs8IWC46oBzKjB6y68IJCPYti70mFx6+1/nzO/vz/Lknt2sC1cM5Taqqbb1qiouvq0H1DmjaV//TvE8eN7Fx3ypk2qtmFzz/2kVu8jjHA5XLuS+3bzd15hYvh0+eFhYLg/uaPN/Tpk2zwMWwjUXJWEkABkGeH3zwgV1Sw7IXgIblMYAT6+xQJhbW3//+d7sjCxYWS2SGDRtmLSzimQBAiCEkv7HO+GCRETbAs4hkJ/6JJTgMDzmPXwvAI0KeNDEEiLIsJ68QCADRrXCEk/FCyUwckCgPPZyMuBYwRh+8xHmV4TheJkFcpNksIqp8W+2o0VePvfEP3f7Xu/VadIr+E5mglSuWK79JQ5ELnVIOgmrzlMvKstrIs1n7o1crxGereHROGR1iZcKIESNsIC6pgJxJlj37Dpht/rbnyMO5199vZKatFJTyUz9hpoO4vrlZ/hTaX98vPVvjl/yi0ZPG66kB1yh2zwfatm610emevHV6EuEDrp+T8HJOuaUz+LnBC8wAhxh95QlYTiH4BiCwdJyUK6RaIbCTvEoM2wCOgwcP2mGfk3IFEKKhAjgO8Te+KojfzkvAS81SGoabBGTCg/M8AwuKoR9ZFQBMQJQXyVkLSKQ693C9P+SmEz83XjQm5HHA/WRycS1R9AyLKXdAZKbMQyP2Kjz6oL4xlm0c2Sp2lVXNimFqVq+GkaFg4SW88NQrw3SnrnKV76gsodqucqY9iFUPR4l7fZcssaaTDo6AXDYaAfyhkLDtSjAtMyceR1n5/YVeaZcFpYLUT5hp1+U2pCu5elstnvijZk+fogtrVVa6Wc1RJaFa3jrNQ/iA6icPXpx2S2du8QJDnADyPAGLyh4zZoxtWMuWLcvyPTn5qbAIWD8FQywuGh3AQ6H5zcOyWxe+f/v+poCsC3SIF8QhFiU7xOaqvoRjvm3btvaZPC8vcuTK6zp/zufFi/LxkgJEeRFAlS/AgrHhn7orzUxUjNftd92r/0zbrds71zDgZzJiFJAoA8BL/fpFXGfKXCYm6oTL6S0dYmUC+/7xwvkCWVTUfkVH5s7Dud+fb3917w+vgtTPWY2r6fetKdp79qWqVC7GlNeUOaas/zo9iYAB189JeHHKTZ25xQs+dHjHWk8uhcByIXUKVhWNtkOHDtaMx1/kAAqMHMsmzx44l+ec7DC8AYbcLBn8Yb4W3Ml4FcU5f3XCdf5ee0I5zMqCSBN79ei/HlGFxDpqunyezmnojlM3YLlMOUxBThQxh2PUa/Yy279z4XEC0zwOZOedx+UnPR2wHny41akco3/0bagrNuzRtHSzVGzqOHUo28joKcEMM9CXGRnkc5v7gsjlI2LWT7d1lsW4AD8cmfIELCyWa6+99rhHsTwlL8LC4uMG5cWLoWAg5JZcPDMvXnmdD0Tuk12blB6qT4aN183/HqQlWw8oxeRlT8s4ETROxsM7V7gaiDK7oA9sk6iFi5fpqfd/0NsVpXLVq8qOCbxt7v1SfhZgEWaAJYOZnpsl4w9HzFN8W5jP9J6+QwB/7s/pGtDVLV7wd4azOT0r0GN58WLiwFkoHSjvQK7/cco8zVx7QFebjvq2j2erVVXS8bjTYQQih3dt7hog3/stXepK5jNoUm+d8U0ljXrlAXWujbvAdC7eNve5K+/oGQtYzMyx2zJOUNK6kLEzPwSw4INhtgcA5JuhmmPO5Ycn9wAKjoO9oLzgx8xFoFYZ9+VEefHCQvXHf5UTb3+PJSWn6MO3Xtbjf71Sy7cnq2F8rJ64sKlSkg76y8K77hRr4JF7/qLJtzysF8YsVNLZ9dSzaZVTLEHxfJwFLOKpmJ0jHCGnXWYCKRpDIGbFcJIxhe34uQLhkf1arBS3eMEb8CPlshvkJq/8ygNgdWvf3Gwrn6AvN+21S3DKR0dqq8kx7lFwaoD4wo9feEJjN0fqkxlrdVb98jpxiiI4ZS9KqWxwENYGcQ7ENzGk86j4aIBhfJrJdXXPvfcaoY3f0Pxbz1hYh3NwcBefUpV8SUlN3aR6RcUtHanlm/fpyVGLpDLGfvC2uT9p5Vt0wt/EDi9EjZPh06PiowF2wXn88SeIurVCEz3tbS0f/PWHayMqJlbLFi3QtfUPae6mQ1q7aq20eY75/J752TRP2r85+AtzCiW0gMVuNficiHViKY5HxUcDH374oc1/D2Alm+wAuw6m5hRRUHwKVEoktYBl3CbXm92dxg//Qt3MMp6RayN0ZMFQ6Y+vMz/zTYrxqa9khjyUEr3kVUwLWATurV+/3l7ru/txXjd754tWA6w64HP+eQNMo07Xi2OW6n/jltmtutyYnCja0pX8p+P/7Natu/r0Oke3damlcTH9tLvLEKmPsZj59HtGKm8CqYnR8shqwAIWM4PkomK3Gid/uaef4NcAy1mefPJJmyjOjAOVbgIQv7r1THVtVEUp6V4jD/YapFMh7Oe6628wu0avU8PKZZRkQCyLXEoxnsWvBPywgMViW3ar6WGS5ZEyxqPg1wBblf3000867bTTjgprNpM1G34kmKwMLLr1qPhoAEvr3/96WBvXmwyx0WV8BPcCf32UYX9awCJe6v3337fJ8tju3aPg18CoUaNsQkNH0r0HU7TfbDLhBbc7Gik+3xgMnc/spJ9GDNOQH5Zq3KKtxUf4UyypBSx6a9IRv/TSS3ZXmFMsg/e4ADWQkpKq70Z+r6uvvU5pphPedjDDZLfco04mo2ilKFulAXL0Li9qDVx62Z/UyGSpIN3M0DkbiXv3KAcN2MBRVuH/9ttvNrdU48aNbeK9HK71DgWJBrZs2qAG6cvUcssX2rwoSZNX7lLZtJ3qd8HVCrM1GiSCemL4rYH4qon68t2XVbVGXV3xznTtNrO9lWLC/L6/tFxomzdR6ey5xzKTgqwjLC1KK+pyJkYla8jfrpea99Qf8zeqYiWpd6vqZifZekUtmvf8AmigVu26+vSTj1WzXHMlM2kS4gFWdnXa8QOLc0nQRjZRltV4FLwaWLVmnZ5+6imVqVZPyRVP06rIJtpZoaUU38JkWGQRrUfFWQPjTZbe2TN/M5ZyRHEuRqHJbgGLoFHir8iyQOS0R8GrAVJLx8REm40mwvXkj8v0wk+LlBDr9cTBW2P+S8ayuCuuGKyZ40Zo0ca95kb7evrPoBRcmaURZipI0csUq0fBqQE6lAkTJ5oVCYOVciBJq7Yf1NDbOqtb4/jgFNiTKmANdO3eQ52a1dbslSzJ8cJTsivQAhY5sAgYZWecNm3aZL/G+ztINED+8z9ddqlq1K2jPXvNJhxhoWpSLc6LuwqS+nFDjMgy0Xru6ae0ZgeZNry5wuw6tYBFShnysn/66adq1apV9mu8v4NAA2RlIM3ONVddaVPqbtxzyO7iDGh5VLI0UKdSGa3+4U0lH9hvRoWeleVbu7a1E9aAb+Ttt9+2uyj7XuD9Dg4NsIHsww8/bAJDTa9rQGrJlv1mVxwvg1Jw1I67UoRFxWre2h2aMOEX46v0jXx39znFkVtW98wSD8Ib/Nl1pjgWtLjLPPSbb3V6B7ODM3nyzfqzxZv3q0X18sW9WJ78OWgg0nRI5Vv20GdffCVlpJsrPCvLUZONwyJFMpHu3jpCRy1B9G0sqkMbF+i3n4frzf8+qt2r5mjevJmmIaeqRc0KQSSoJ4pbGoiLDLG7Uy2dukvpScn53rHbLXmCiY+1sEjg9+677+r++++3m5QGk4ClXpa9GxTz28t66LJOit8xRUvHvauoLbPU75weivfCGUpk88CeuvqsRirforumrd6jbQfStOOQ2Q6tRJY2sEJZCwvAevzxx21Ig1ubMwQmhnd1rhpIT9bE3VXV7eYnNHHFbt08caZeu6qdejWpnOst3onir4FezRL0y7xoXf/EFxqydrniYspoQKtEY1mnSQkmSLitmXwphWQtLGKvPvroI7388st2y/lSqIegLfKanUl68dvpZpuzdM1cvV1/79NQPRpVClp5PcHc08C/BnVUr65dVKVOa/1RpZ/+u7GlUptdbLZ9WmciHjLce1Ax4mQBCwvrb3/7m+677z7reM8uP7vqsNWWQ0yvEx3vUeFr4JtRP6lL585mMiRcK7buV4c6lby4q8JXe1A8gY1XL7/8Cg3/bY06nNlTY/fW1O4KJuwo1nRYzBaXQrKARUDismXLbNZRFkD70qZNm/Tvf//b5sviONHWr776qn788ces7el9r/d+u6cBNpNY9NtEXdKxlg6YyaJt+5JVr0qsew/wOAW9Bjp16qRbbr1VPRuVV4facUo3OySVVrCisixgsasym0/MmzfvhF1zOHbFFVfYisWyWrx4sbZs2aJ69eplbdPOXoSEQ/huy866KLe2DHOTFwXxldMWrAD/uMkreznJHPr0ow+qZnw5rdyRpDpVyqpCjH+LYrPzKkARbT0GVJdsFUf4RTZCV9n1xZKw7LztNbnwyMYyzz+zPy/PG05yQVHoFP3UNPuFzpg2VUdM9oYjhDigW/RzlNyUC5Zu6swtXg4f63Qnt/SAAQPsZqpLlixx9GC/CXkg5zvDRiwx9i9kKQ/5s1q0aGEd9WQrBcQ6duxorS6Y4xcjkykWW0E2RHCTl1MwZGLjDTfILV6Uk81iyZzhvMTf/zhGfVokaKbZIOSe4TPUq0641qxaobQ80oq6qbOAeZl99SJ3rzafzdofvVohh4kjyiSi9SmjQ1OnTtWIESNUp04drV271rYXzu3Zd8AEyG7PkYdzr7/fhVU/p6pNYwisXr1azz/3rCpd8JAmzEvWgNRt2rF0qQGtCItdbr1rjk7d0hn83OBF3ntwp1GjRrKAhT9q/vz5FrCmT5+upk2bOrJboOI8LzgNjq3nOxufyrZt2+zwkJ2dBw0aZJ311apVy7qP60lZw/mCVC4M3eQFP17CxEQz4+ICucULPiw+j40tq5jYGG3bulWjvv9eV/X5h76Zvkh39migq9vFK8RPZ6ubOguIV4ixrCP2GtN9u8qhYx95aQcEJzvUvHlz2wmyNIwNNbD0oRCTeTPBtMyceDj3+vvtfv3E2nfC3+fndp2/OnXkH1arlg5uX6FfY1rq4jpxqm6sLidflr+8cpMl+3HnmdmP5+dvN3gB2hUrVrQ4YgGLUIZFixZZgHEajSNc69at9cwzz4jviSZTQNu2bfXmm2/avFmAERYB6xBhGBt7zL+CmQrAseynoOQmL2ThpfGVtSDyuckrOjpGsXHlFW12AP5lwkSd2bmLYqvVMhsThKtP83iVjTn2sucls5s6C5gXdW50XCYHeektHcJSx7XAC+cLZFFR+xUdmTsP535/vt2tn2jbbhhtFJQC1emFF1+iYWN/1TYT0rA3+YgSy5Y1ImQOCwPllZfsburMLV7wocOzrQer6ZxzztG0adPsDtC+BSKp32OPPWYrCjDjxgceeMBmJgWsIBgBTnyDqM4x/naD4OMWL0c2N+Rym1dI6j7p5xelmHDtnfKLrj6zidZ+8U+1rt1FDSr7D1aOXG7pLGD9U+851H1O8tCmsh+3f+fCI9B6y8470Pt9r4eXW/wC5dWjZy+TFbiLnhi9Sku3HlDiUbCyde34tnyFLcBvt8poZcuhHeRHNEcmC1j79u2zQHT33XdrxowZ1mfly5SeEHLSJ5crV87+7f3jrgbCDm5XWJlYpTY5T6E9T9dHJufVuh0H9PRFF7n7II9bsdMA797SRQu1ZcE0rYvaoikTx6hzo2rG9x6iUDMZFh4aZ8pU8vOiWZsSR6iz4/PChQuLXWWWHIGPKDKxmV4fOUfvTduisJrt1P6snqpkhtseeRo4bFSwYMpotWvZQrtnfq79s74wW9oPVfjCrxU7/z1z1p0RTTBr2lpY+J8AKmKxatasGczylmjZQkxvud9McLz98VD1uPZe/atfwxJdXq9wgWmgRctWalK1rELqnK0JyT0U1qCy+p8WbxZIJylpwv8UxZb2JXzjCmth4Ri/8sorVcvMRFx22WWBadG72jUN4BOc+Mt47Q4pr3M6tnKNr8eoZGgA5/r5Ay/QujVr1Ll+JS1YvyuzYMZ/bJCqZBQyj1JYCwuHOdueL1iwwMbEnHXWWXnc5p0uFA0Yiz40PEx/uvxS0/xKvnlfKDos4UwJIWKi4vdNBzRpSWYsYUhI6Wkr1sIipoqp2qfM9lGAlkdFo4H9B5PUq3df1WrW1gTephaNEN5Tg1oDWFlffv65ls7+VWv3pOrNSauUmnHYBpAGteAuCWcBi8hqQOvXX391ia3HJj8a+GHqH/ps2nqt2rZfDROIs/HI08CJGkgwQbbjfhiuC1onapjZ1n77/hST+r10DAktYOF0b9++vebMmWOX6JyoIu9IYWuAhc6TRn+nnQcPaZFJf9zYOFc98jSQkwa6duumndu36cL6oWpbp7LmrttdarKSWh8WSunevbv95KQg71jha2CBmaU9uH2dko+cqas61VFclH+LnAtfMu8JwaYBgreZJNt34JDa162khas3qH+5UmJh4XBnUbNHRauBuLhyuua6683WXZHq2rBi0QrjPT3oNcBsfqX4BNWrGKlVZg/DjFIyUxiK7+rjjz+2/ityXZGdwaNTq4Fk42AvUyZSTc7sq6ZmY9RAl+GcWmm9pwWLBp54YogObFqhPcmHtd3kfZdZeF7SKZyFzwSNfv311zZ9A4ubr7vuupJe7qIvH2usdi43m6Kmmr0gZ+qnn8ebXYvOVvuanu+q6CuneEjQ3GzNN+Xn0arVcKC2moDjelvmmmD3sEzhCSKNq2o+7mQlCRaNhBPOwAad5CMCvHxTxASLkCVSDrMbjiY+K1WurRHvD1XXM1orbeUEVep4d4ksrlco9zXQv39/3X7bLRrQdbBmz6miM/742qQfOgpYZhs4E9Qn9XmiRFle1ukOUE2ZMkW///67Bg8erB49erivXY/j8RpIOyg1O09bqvXU7nKLFNZ/iL74bbUGVG97/HXeX54GctFAQkKCbr7lVrU+LUG3LOilK87upIpRPs736a8bi8tYWiVoqGgHvWQLJSPDSy+9ZPO656If77CrGjANyzSmyuVj9eBDDyk9JMIMB2P9TtDnqiges2KrgXPP7addm9ep3JGD2n3Ax/98uGTuqmMBi2HhepOGl3S1Tj6rYluDxUjwdJNCevr0GWrZqrVmrtqp8tERruVbKkZq8EQtgAZIQ/7E449p25bNevfX1T6cSuZyHQtYWFfEYbFDzsCBA30K7f0sNA2Y/EaLTZbXN99624LUjgMpalOrgtJNAKlHngb81QAL5lu3PV1tI7do0ZZDWmNCHEoyZc2Dsp3QXXfdZXNrl+QCB03ZTKrgb0b+oO5my/mVu1PNpgtHVLVclA67lKExaMrpCVLoGhh4wQXauHSeSZscqmnGUi/JlAVYJbmQwVi2tKR0bdx/RLH12+mClyapvtlvMC4q3FhbwSitJ1Mwa6BOnbq6847bdWnHuppeGgCLjKNs1cXuJR6dGg1EhB3Rkw/+WetTonTnOfX1UL8mSkkvmY7SU6PR0vsUNvaomlhdmxfPUowJQC7JZC0sdpAheR+743z22WfHbUtfkgtflGX7/IuvFG3WhK3dmaSOdSuLbck966ooa6T4PpuJsoMHDuqlF543+z7uK74F8UNyC1jk2GnSpIndwHP8+PEWtPy417sknxrYtGW7vv7qKx1MTtdWkxrE234+n4r0brMaIKFfLbMZbfsWjTV23M8yi3Qyg0YNkJU0soGjrCFkPeFFZneWdu3aeXmx3K5lTCeW4aSaDJER4Rr5+QjFV4jST0t2qLzZ0qu8n9vPuy2Wx6/kaIAkBlcNHqSvHnhN//xuiSpGpOma0EOqUcJAywIWCH3xxRfbHZ9nzZolL0Wyyw3ZWYZTrrpkUiAvnzlZrRrXVFyNphpUt7pKXj/osv48dnlqgHisTp06641nqmjJvlDNX7NHi82GtDVK2KYUFrB++eUX8WHhM3sUkszPIxc1wDKcJv2kFpdYprc32603ft2gO/q3dPEhHqvSrAG70WhomFpUkmqkr1f7bi219wezDdimOZnDQ2afWaZTzBdEWx8WgaMNGza0289n3zUH6+vDDz+02UidBrFx40aNHTvW+dP7zlMDLMPJjFd4843XtWDxMoWZxuWRpwG3NZBm8rs//+qbapRQTtvDq2nH9E/t3oUyC6M1/3Np6iuZwOX2g08Rv/CDBw+qbt26Yj3h9u3btWTJErE9vUMMEQl7wBl/mklnQf7377//3kbF9+7d217GLAWOe99lPfz2/dvhl59vN3nxfLfk8psXfoSwMJshctxPoxWd0cBkxYg9QRVulrNIeVFePtkoJ72HGb1kP27/zoVHNpZ5/pmdd543nOQCeLnFr7B48Y5GlonW/jV/aE39wXomLVX/7X3asVKxIDqPHZncKiMPdYuXwyecBsPW84Q14HyvUqXKscKZX5s3b1bfvn01bdo0AW67d++2O+w0btzYXpeSkqINGzbY45x3KInNHc3nkNlG25qrzol8fLvJi8eTpNBX1nyIlHVLnrzMSnm7lbhxin43fLjiE2srKS5e13SoanRz0DG8bMVSToAfB2pByU2dBcTraHlDjY7TD5nFuEeOxZbRDnyz2+7Zs0erV6+2dYEeseYhfielH1JOPALVS5714ydDXpjiUD+0n969e2n2vPm6deCfdONHs/XGhJW6vF01RYRkKNz4utLMe25Tz+RSdrd0Bns3eIFR8KEOwmE6bNgws61Uin1RONiqVSsOn0Dkkp46dapmzJhhwY11h7z4Q4cOtRYaVhovGzzghyMwLS2tQIDlJi+nQHv37i2QTA4fvvPkZXISRe7eprhDu5R0KFTtzz5Hv+xPVnjKXmOl7jkOsLBk6TSwYgsC8m7qLGBeR8sbaTq2/aazCzl8LP02bYOG59Ais5byhx9+sHthbt261bYXzu3Zd0ARR7YbvZ3Iw7nX3+8868dPRuihONQPxenYsaMyTNrzlN1bdEGrBH09a51alE9RdbN0J860/T1mzbBCI8yVOS+rcEtnyOIGLwJjMZSoA2thNW/e3AINL0lVs4WQLyUmJmrMmDG2Z2TPQpRB/iw2XgXAypYtqwceeECfm73SGjRokHUrDZMKjo+PzzqW3x9u8kIGLMKaNWvmV5zj7vOL164MpazarhtvGKz9qUe0cvRiNW3U8Dg+/MGQPC4uzur1hJMBHnBTZwHz2mlAysxQJTaod4LUuBgc6ty5s+rVq6c//vjDgpZzfMOmLapZxgyZc+HhXOfPt1/14w8jc01xqp/vvvtOEWaB/V0DBmjNrlQlRcWrfiPzLu5KULyJuTSIlWup3dSZW7yWL19uMSoUSwhQobf77bfftGzZsuMKwowhL1H37t2NGybMgtWZZ56pSy65RCAfBNBhzvtaBfSmbgxt4O8mL0devt0g3zLnys8sl3j9zbc1avRYvT9tndnKy2SDzIHcLGeR8mJIe3SSwbeY6Cq7vhzLPvt1ptJz5OF7nT+/sz/Pn3tyu6ZIdZqbUOZ4TnLxTn/xhZklNNSxXmV9M2e9eUePWrvo9iTkps7c4uXwCSU9BX6rM844w4YztGjR4riiAFLXXnut2rRpY4NKGa4AVPztUd4awOjesjNZYxdsVZn4Ohr9xyZdfHrNvG/0rvA0UAAN8D7jc1u08A91blhZq7cf1EqzQW9xD/oLB7AqV65sk/fNnj1b11xzjerXr18AVZXyW1NMo5j6UmZUu3GAHgkN0ZufTdVsNda/ft6mfs0rq0/z44fdpVxjXvELQQMYFRgaScmpal4pxuxfWFE3fThL33dKVZxpl8WV7JjOydLw2GOPWQc6fiqP8qmBfZtNNHuUydc+0A5p1u5O1toaFTTyLz1Vv0kzRYefON2fzyd5t3kaOKkGzj//fOv0ZuLr4QHNdO/+Q9q0N0k1Uw8rNrJ4glY4viccWoQvYGE5Y8WTasI7eRINmEFgRWOhVmupA8ZlMPjNkepQu7U6tG11knu8U54GCkcDr7zyil3Bwg47FeJiNH3u72qx9Q61q2+sfLLbMotb1biB2l5ZOAK4zNU63dkxh/AEvhkeelRADRyNPVq7K1lLJnyjtlpZQIbe7Z4G8qcBJsgIO4IeHtBc3a97XJOje5llYoOklpdmfu9Za0YDx+Ll8vekU3NXeExMjO677z4bgsAMYcWKFU/Nk0vBUxav3qhok6Xh/AFDSkFpvSIGowa6dOmiV1991c7+E+wdXrGW1kUn60i104753zfOzJyRLQbeCjuQJc5myJAh+s9//qNvv/02GPVeLGVK2rBIF3Q9XQmJNYql/J7QxV8DTKrdf//9dp0wpYk2Xus12/Zo76G0zMIxJMwhBCVYS27EN5HFZokEAXyklcFB55E7GtgcWVPdLr3JHWYeF08D+dQAIQ5z5861S+oqmuzCCWazk9Vmd522tSvkk2PR3WYtLFIkE+0+ffp0L6+7G3VhppTXrl2nb378RS2aNHSDo8fD00CBNECCznHjxtlhYIP4svpt9U4lpxUPv5Vvwa2FRSS7E9HetGlT3/Pe7/xowJjhb777vtnccr8axMfkh4N3j6cBVzVAgs633nrL7jvasV4l3frxLK3bnaQnL2zu6nMKm1mWD+v555/Xu+++a9cNFvZDSzT/sFDtWLdWYyZNV+8B5yvWdgklusRe4YqBBhgWQuzw3qVhFX1165lKsRYWazGKD1nAIgVMs2bNRMwGq6I9KoAGwsxwcM1q9erVS4nVEgvAyLvV04B7GmAh9LPPPqsaNWqY5JEhii8bpTJmpyaTqM2sgzYwYLJsOHTE57dzLFi+w5khJMXH5MmT7dQnBfMo/xo4kpqmVqd30LJWXTRxsUnj4ZGngSDRQLVq1ewo6iKzU3REdHnNXbtHjw3/XdeblMq1a80xUmaCVuQ2s1qjnPkzLvg63HByzJAiBouA/FWNGjUKEvUWTzF+nr1Mc2cv0PJ6TdWzSULxLIQndYnVwIoVK0QiyetvvFEXtEnUoq2H9N26cN1R9muFhWQCVsyendK2SVKfJ8xiaTsICxp9hJJ94cILLxR53SlM9nxYQSNpMRHkq08/1KgFm7V21yGd3zr4eqhiokZPzELSAMkNho8YoWSTyeHWbg307MXN9eURk1Syzr2ZAGVAak+nB42FZWIH2bQiyMjCJ4ufFy9ebGcQRo8eHWQiFh9x5v2+QDvXL9NDF7TSFze1U0zkMb9A8SmFJ2lJ1gC+6k6dOtndsShnGbPt3M1n1daeg8lZxQ4JQqByhLOAxQJohoVkF/Uo/xogN/5dd96puJgoVYzywCr/mvTuLEwNPPTQQzarrZPoIDYyTLsPpvjEZQXvzKEFLBL4sTnAo48+apP0FaayShrvI0e369q+fYdZ4XBYtVt31oFDKSWtmF55SpgGeNdJTQ1VLltG/xu7TE+MWhT0pbRmAENCAkZvueWWoBc4qAQ0ABW5e4Wxq/fo3ZfeV3pGqho3a6pz6scGlZieMJ4GsmugdevW+uijj/Tcc8+pW+N4G5f10TSTtSHIyVpYZGz45ptv9Pbbb2vSpElBLnIQibd3oyrMf0tbx76u8d8PVctKSap3cJ4q128TREJ6ongaOFEDgwYNsnuQsikycVkJcVEKN9/BTtbCYqawXbt2dhsdcrh75KcGzBb0qXV7av6hOlpQJUn/Trta/9fDpO1IrOQnA+8yTwNFowF81o888oiNDkCCDJPML/jh6uheP8wMspUXO+OQscEjfzXA/ovJat/pTPW57Hp9fG1rdW9U0d+bves8DRSpBliuw05Z+/btVahZUpZGBtIgJzskZLPDv/3tbza0IcjlDS7xosro+5HD1f+ht7TRbJJar1K0Na+DS8jiLE3wv0DFWbvIzv6iX5rtwCoYx/vK7Qd0MDU9qNuwHRKy6y6O97Vr19rpzrPPPru418MpkT855Yhe+XGhdp0zSJ9d2UZlo7xlTQVRPGta2Xw3OemQtpmNEhQSb3YvNVHXBUjfy9Kzbdu2FUQsey8rQkgjzmw6u3MXlMg7x56MbM7qhBfkl2cgvHgWGyCzGTJ0o4l4/8tf/qIrLr/c5MmK1gvjluuKZmWCdjswC1jswLtq1SolJCSYdZDW6Mqv7krFfWmm49+bdFiffvWT0mudoYev6qPaFaNKRdkLs5AAAqmOyM8WLgNYlczSpjJlzSPzb2lFR0fbHZDdkBte+HgBr4ISwEH8o7MZcUH4Bcpr3759NlEn64YbNmxo3UArV67U4I519OSoBepdI171XChjQcqU271ZgAVoeXQSDbDf4K8vmZ4nVfv2JOnX1fsVvnCmHvjT5bq8c+2T3Oid8lcDgAEz1mlp6YoIMcnl0g1omWF3QYiX0q2JJKyrkgBYrBlmt2iHCCRNSkpWq7iyGlWrgn7fuFcdE4LTcLGA5Qie0ze9wCeffKKWLVvq9NNPF8NHduEguT2xHKWG2G+wTIzGpp+lr1auVb20tfrrff+nfVHVS40KTkVBsRb4WKvKfvv/VCaPcGswZf/rr79q586d6tq1q0aNGmUtt8vNsOf333+3u0N169bNJq30n7uR6KhsbllYmeUMRIKcr3Xkyvls3kex8j7++CPVql5NXZqerWGT5+vaihmm0yi4JZn30wO7Ik8YnTVrlvUrjB8/3o656WXYzp5ZRSf/OxWYvedhaOnW8NJNXqgnXw2OGJX4hhq5s6ZCKjfR5yMnaW85swuJSdPhFrlZziLlhVshh8aO3rPrnpAap5045yPNUhGRqykiz+aZpfo5c+aIT6tWrTRy5Ejr4iAYmj03eSFxdxAouWTJEjsEYgeZ0kyOzh0dMMJ697331SI+QnszIrVjn1mt4UKmhuz17Twv0G+HT54WFhus9u3bV9OmTbMLJkkARl6defPm2Wdu2bJFH374ofhmx2hMTZjjUMT0ZAayID2Jm7wcJSFTklmtnivxsh1NtUFPHxYeoag9GxRrPuFptRQ6f6jOblVfGWmp2rJpu50WzpWXnycoJw5ndjnhJQ4WnQWsf5P8LXL3avPZrP3RqxXCrixHibZBGR2aOnWqRpjMAXXq1NGaNWts4OKavRn6es5GlTF4pcNmWBhuhoTZXFjphk/zxDgNapto44cAJCyn7t27i3342BC4d+/eOu200+zyEzZZYSNRorrxk9HZVqpUyQ4/6YD9JeTnenRSUHKsIkYwBaVAeCE7ExGbNm2yQO60M/QRHVtWE7/7THXLtda8NduVZhJRpmQc7TQoMouiqZMAKM93zQ9e1C84ROqrPAHLlx83QjSytm3bWmcm+xhigmOOA2QOAQg0jvj4+AK9fPBzkxf8qLSTLvROPSjtWpn5opj6WrD+gDav+sPMXiXr9+Qk1TJTv48++JDttbEyT8qLB/pByMSMEQ5nnLsFJTd1FhAv0yuHRpi4Hm1XORbT+8zw8XIwQ+UQG58AAMxQ03aSDuzXziSQylhizkUWHLIhljmGhRBu/FOhJnaI31j4Tvvkt5OI0jnHNx90ixVGGqXsowLnkbl9I2ug9+TGC10UhdOddoZuKD+do0OU68knnzQbQacredkebZqzTW33rVZl0x7NC2yAyoBVnHm/4wJzgeT5rjkCnOQb2cAZdJYnYPEy0iNRWcwkUEiyk959992WAdZAgwYNLENeNodoHPRIOFELSm7yQhZeGl9ZT5BvzU/SirFSrJmlMu/PoQVb1KZKlOZU7qV2uzP06PP/VXSZzBCGPHmdwDz3A7xMbgGWmzoLmBd1bnRcxmStyE4OqHCcHGxsLwcgokfCGlrXqmg+DLNNT55+yFhY/M6dTFu2BPjRaQICtLnvv/9eu3btslvYEdbA384MJC4NZ1qfl8Ffoj2jCz4FJXjxAgby/NyeGSgvnom+fQEL3vXr19cKs5ny9qWz1LFBC9PuR6ha7SoSud9NgLRNo9xnSG5i5HjcrfcDPugrT807u+l0N+Y2yEyDoDfEqQkDiG9HaY7UHHPOO8fy++0mL2TIUy6GMWfdI/V6VKtbP6j/hlyj8pe8oJYNG2jnz2+ZXNjH1JYnrwAK7WY5i5QX7eJo2/Atfk66oj35Hud3aqp5QXhJ0o7NZPnyyek3S8uYFCIDwXnnnWdfPvxV+KrobJksuvrqq+1EkRudaE4yFKdjvjo/Tm6TfWTez8O1pca5euDQ1Xp832Uam/hX6dynM5P6+Qzxj7svlz9yfU4u1+d22OGTp4UFGl977bXH8WE4WLLJDEiODmVmrtpuI9jjwjL0l8efMEkOLzA9rP+9csnWU3CVrl+/flkCXWDylkMA4l133ZV1nNluj3LXQEPTKTdqdpomD31XZ1xwm9bv2q8vZqzROY0rMNgocsoTsIpcwiIWwNgK6t+6ptasWGbM6BjrrytikbzHB6ABAMuNYVcAjyz2lw6+/Aot+ON3Xde7gVIzDqvn/03UlGVb1Y3Z2yKmY2ObIhYkWB9P6o2du/eqevVEvfjiC17jD9aK8uRyTQP4ra+7/gZNnDhRkWZR9C1dG+i18Su10Wxvb2asXHtOfhh5gJWH1sLMtPpzz/xHEyZMtGmk87jcO+2GBtgXz/m4wc/jEZAG8Bcx+/3iiy9qyuRJOqdpVeMGCdHC9Xs8wApIk0Vw8egxP+nwliU6s8vZRfD00vZIfIcmL9P2xTLz6tLm+dKW3813ts+medJ+s/LAhwihIVbHcc46p5hWzw/hsCfMxJfg5Q8/JqBmzpzpe6sFAI4TL+ZQTryYNGCtH7Ro0SI7c+pc7wRqO38738xa5sTLOR/oNzpkgu1Osz/BkCefUuXINLPDTsOjs6OhgbJz9XrPh5WbOo829J1/TNCzjz1swjYq5Xald9wtDTCZsXeDwqY8Z2akTMxPRpqJdjcxaeYFOo5MKurMKfYnTI+f+QK9++67NuzmnHPOsbs/sSyHYEiClwmlwJdFMDOgQfI6QIGXEqAjxIGXlLAK4n0IbiVPFDPkThwh4MXsIqEADjhwPX/zDEImmI3kWfAk0JqlawStwuOtt97Sueeea2fYkYNnE8DJdD3XsK8CNH/+fMuHyQHu4zqeDe8vv/xSN998s70OeSkH9+Kjc54LeBEmAj/KSlkIleGYE8phGfjxT/fu3TVjxgxt3bZdberW1rSxO7V3xXSVLxdr6sQwIJC0bFXzMXV1isgDrJwUbcAq3Tgb167dqGo9rtbpZ3XM6SrvWGFowGRxzWjUV6Ft/mRif4ylUaZczk+Z/nrmC3MUsACTgQMHWsuG+K5x48bZLLpYJcRdEUO4fv16C0qEPwwbNswGP7P28LLLLhNL0DhPEPQXJj8UkfdOQgCuxTJidhwQAewAQHJJAQaABSmZiPsiKR4vOeCwzMQ0ff311+rRo4e9H/BBToCEjYt/+eUXCzo8GxkIaAWYADfWOnItYDR9+nTLl5UBgCBpzAHNK664wqY1B4zgN3bsWF100UU20p9lSQDiZBMziSzogT0biLUKhB544AG7zGnHlo0qm9hIi8a+p8aJFU0ZDGKZjiMKwO71lCrFhh8L9g3kAQFe6wFWTgozGQJGfP+j/vzGz2p71UMmSNRTU05qKpxjmcNCa1WZFztHymF5CEtAPvjgAwtaAAEvOoCBA5mhFS8sf2MRMew6//zz7RAH4MFSAWQAOsCpT58+9iUFPDi/bt06PfbYY/YacmHBC5AYMGCAvY7lQKxjBESwfLCgILZ943mcYxE2FtZ3331nrR+GjAAd8YwEDPM3gIXcWFFz58614AU/4h6x9rCmAEyWwAF+7MPAgm4AjXMsP+Icw1mOEUx75ZVXWmuPOLXVq1cHDFiUA/19/flnuu6x13Tnl3MVeyAs08AyEHVv+juKWXGTep1W0yz/NNYuVnHVFlLbK7nVdfLexBxUumnzHj30xHP6x5Nv6vqLz1Cct8dgDloqxEMhZmhoXn6Ttzfnh3Cc8z7E8O/RRx+1oAJIEJNVs2ZN/fzzz3bdK2BB8ChAxYvL0Il04FhFWFR169bVxRdfbM8xxAMo+ABCTmQ7YMI5wAGQAegAOX5zDeAGcAJorAD54YcfLF+eyzGHJytD3njjDWshYfmx87qz4zrPAOh4LsCH3AxPP//8cwtWPkXO+sm1ABjDwAkTJlirz1nJwVAVGZEHiys/hC4Zjv7+w8f6+Z7bDJAe7UjMcyuk1dfLI381Q8Y6Sqxghu/pBrCWjzHWrwn8pR5dJgOJHmXXwLw1u7W9Zg+1PuNsD6yyK6fQ/zaO7T2rjdN9Xu5O9w2zzXqpXceBFi8s1gegULt2bZsCiaSULNbHUsLCwLc0fPhwCyz4jhYsWGB9Rpxj2MRLWb16dfvSM5TiGoAI4GPDBsCEYRnWEIDA34Aj1wAyHMOXhiyAWOXKle1QEz4M77CIAI5atWpZ3xKLswGvzz77zC5GRrWcB4D4hh/WIBZakyZNbIIBkgwAYMgBwJLqCWvMAU10wPCVMjvHkBFrju/8EOXEwswwYFQpOsLssFMm81M2UpEVa2h1mWaae7iBVK2VVLOdFFPJAFY2v2N+HpzDPZ6FlU0pP/40Tk0SInTHdYPUpV65bGe9PwtVAzhxyyUqJN1YAvO/yOylc3K6szyEYYdPD37ppZfaF5JvXjAWVGNZAGAMkwAN9i1gSMdxQAGLCEDDusFntHv3brugnewRkGOlXHLJJdZHxX34gHj5HWAB7HgeFhrAhUWE5cVz+ZtJAMAMwvfFOe597bXX7De+q+7GuQ24QViA8AfUIPxd+M4cGeHLEJRvysRQc8qUKVY+QJd7ySKK7Dwf2ZCZ39yTX4LHPffcY4e0vmWC35l1y5mQh53q37yKEdjUTQGek5d8HmD5aIge9u33PtBbf79QHetWCOpk/D5il5yfAFZUBWV0/5fCQszQIj0pd6d7tlIDApBjRThDLIZiWDwQFgcfh3i5neu4z/nNMMqXADfOYbUAWjkRwAAxy+hLDhBxzPc3gIJsAIlvlhNHfueb+wAmyAFQ+4f5hyEeEwUM2XguvCDf5/C3Ixu/C0r43LDunn322SxWzaqV089LtmlfcprKRR4/VM+6yKUf3pDwqCIXL12u/3v+Rb38yqvGFxCvWl6OdpeaWIBs6J0PG7DC4Z6b0z0AlgWxKrI/Bl5YPG6QG3wAMjaRwOLCWjwV9PDDD9tZyG+//TbrcY2qljVrDg/p4tenmb0OTN0ZgC8s8gDrcLJ2rZqn2H0r9fZjt6tGmQOa8dt0MwtSeEovrMosWXwZvuR/CFOydHHy0rgBfid/wrGzDDtff/11m3SRCQgozuwWNey2zjapYhKZNkxUvEEte87tf0o9YC39+Utd1q+7zX/VOnqtFv34hqLMcKRWHeNE9KhYasAJKyiWwhcDoUnZQ8gEcV2EfEDljDO+THiYtuxLVkqqsbKODk+P+PgZ3ShaqfZhrTFBg1fe+7Ruu+c/qn357Zq8ao9uGPub3riqvapUruSGfj0ep0AD+HLef/9969QmdzvDo5tuusk+2fFfnQIxStUj8BkyGXDdddfZWU78cJFhIbruo3l6osxsnZ/0T+M8i1SFXXtMyl7jN3QpNqtUWlg4NImNSU0/on9ecbZuuvo8rd2drJd+WqwH+zbytpsvwlcPB3dkpHGSRxhH81FneV7iAErEVLEMhdk+8pUDYMwIEhDKrk+AGCENxEaRgZRjRKEDdoQFEAjqkf8aoJ7IM8aMIaEX0CPnt9DYv3XV5PjBumdhE4093Fmpjc6TWlwi7VmbOevr/yNyvLJUWlg0XALxvh35vRpfcr518s7fsM8qqHdzk+vbjsFz1Jd3sBA1wCwXIDNkyBAlHzqgnj26qWHTFnrzzTftU3lBACCiuOnZ27RpY48zC8Ywhfgrpt8ZEgJQLJ1hiQ3OcnbMAZT4TeAns2ssXyGmauHChXb5TiEWrcSyxglPR/H000/rL3fcoXgzw9qr0+kaMX+LRuyQOrSpZqYt46WNszLDHQro2ip1Fhb56V944QU9+uijqlDW5B43U9Xj5m3Ue1NW6+oz66h2JXPMo2KnAQAK5zOhB8RE9ejRw1rRLMeBcBCzvIW4KWK0sMScGCaCLb2hY/6rnFCRDRs2aLBZJsTIpU+zeD11odlibfNuvTV1gwk4zXTO5/8Jx+4sNRbWKrMEYuqM38wi0jP12htmcWnXLtqRbNJomGnYL2eYjVHrtFWrmuWPacb7dco1AOAQWElvbSn9gNmEoqztYBxh2LRi8ODBzp9Z31hOxDVBfANQ+FmwvAAnzhM/hDWGnwtri3ilFStW2GFNFiPvR8AaIJ7t5Zdf1oMPPmiDWInAL2dmDi9sW0PDzJZtF20/qEYFtKwcoUoFYH07fKQeffxxXdWtiRrVWq5GZomGxo3VtPmbFJdi1nlFX2t6hNMUXSq04VR9cH5nAk+6Iu1W9QaA/KwTwIl4JIaVnTp1sst0yKDA8I8hJCBHviwAi6Gks66O5TGAoEcF0wA+rWeeecZ2FPfee68Gmoj924yVu3LrXt344Sz92DldsSRlLCAVnEMBBSi82zM0a/J4s/ZJWj1tuM7p2V09WkXqlfkx2hRS32zIcsSsH2uqhy9sp7YxdTywKryKOCWcGdIx5INIHwOxGBgA7NChg/2bZS++RBYCAIwhoUfuaIAJLdLy3P7nP+vhf/5T953bXw8nH9a4OUtU8fBodW1SPTNOi4wb5NKKSwzowSUSsLbv3K1//O1WfT92sl65+zxd1rGKfl+3R7XiEjS5Ui8l7ztsljnEqH2DKrRqeQPBgNpMsbqY4aHvMhdf4bGsiCXCOvDIPQ2QUwzdMuGxaP4ctYiLUpPE07V0pskztrmS4kzMVvkIsymq2VFdfZ4wMab+u9JLBmDtWKiUX9/VzyuTtWzLIQ1uFaPY9RNU/4pH9b+wlkpakq4+Zvav/wXN9TdTL9s3b1R8Yg33asjj5JoGAA8LIICIC0ByMjDyXVfoTwGyZPPn4jyuCVZeeYjt92kmN/i89NJLeuetN1Tp/ge0sNH9embFHhtY+vyg5uq6/xszc2iWOpU0wCIBPh9LGcmaYJyn2/elKulIhDZv2ar2KTP00qejNGLBIdXsdK421DxTVW4YoFGD+phYq8y1X2V9kvAlO/l8/Fa/d+Gp0ABOd1LAMIwzc34mGZxZ+a8U88n/Eh0sLGYQ3SBmIBlCngwE/X2OLaORC4d1QSlQXvjvsi+kLqgMud1P9gyypH766Se676Ee6hS5UZuj62ro7A3qXO+wwo3PMRDyS1s4LimgM/VLkjJ6p9xMbUcAOsiDaUe0Nzk915VFpj81CHv0DtMuASYaRIZpvOHmd2R4iA4lpWvHgXQdCd+rFWPe1aapX6pK9Qa67/mRCourqtZ39lfve980ykhQWHScDiSbKez6lVTBmJ4eFR8NMENI29q3/4DKhxmgOrjNREi3NHiVf8CBH+vfCkq0SeKNcO4770FBeAKkxIuRGQLAKQgFwotn8S4DvKeCAHlmafnsNOEkrzz3lDbsTVFSi4t0/+XhKm8yPKQawyMt3ewAbgSKNYbFyTI+5AlYRA3j/Wc2hfE+UcJMO5N47M/GsXay3ibUhOb/OPoHRS37RhFlom0FoajIiEhbSUwth5keJt0IS+96xJiHBw4l6YABqIrlYrR0W4rGLN6ng0nJuuucRL09ap62GYuq/9V36NGb/6aPzrpdp7dprbJx5U6F7r1nFLIGyD7AB6s4wezUogPbpfjKBXoqoEAYgxtEGyW3VaBDyZyeTdsnP5YbDn83eeUkq1vHKht/8bcjRuq7YV/p88UpuvvtH7T00W910enxJmNpeWOchCmxYRu1G3hHro/ME7DmzZtnU7mymwe7hJClkTgL8kaTXpZYFkAL09YXvOiJ0o+EKnTXCu0/kKHktAidP+BCLV++XL+YtLVloqL117/+Rf/9v+e1dNkKs7Sis/r07qUrr7vFAFaK3nr5OUXvOqBNB2bb6OWBF3VT3yvLq1zFyiqbUMfkSzJt2Uxb54eQzS1ym5db/ODjrKYvaFkD5mWX1pzYtGgfvm0EubDSsw+LrA5YluPn0pyTlc8tffIMeOU1qjiZLL7n4OOWbG7ycsrpK2tBfmcvI1b0VdfeoKsM05mz2uuTD97XvIWzdM9f79Q7772vKhFzcnwcbQTr8MRWle1yxruAEr0K5h09FsnMMCsxRdmCiOT/ABq5sp0GyXVp5vq5vy/QlEkTjQVlAvdWp5ik/SvtTh6kjN0ZVVff/bLQBvHti9mojRlzVa9DbzsdPfaPrYowiNu4eSsj0RG98MV4Va7Ebh3GGjNj/4KY0WwBlT3JWbZi+/2nW7zQG0NvLIzsley3MD4Xon/qjoRzBdEVLAPjZXqSQ2ZNxkFjHSWYKHOcqkcJOQBRp40QyDlq1CjbhkgDjAUD7dy1W5XLmN+HTuRxlJXfX179+K2qrAvd0hkMc+NlmrvpqCJVu35Dla1QWf/7cqJe+eBH9W1dQ5OTnjEuoWPDZGLrNm7cKOK7QkwjOnYmS+RjP3788Ue7vxuARDrX2bNn25cKC4vk+YzBCcv3JRokaSewptjJgwdCNHyGhPgAeCymLC8n1wOGfEBSGm7mEDEzzSxbMcGLrYycRu37vEB+81x2RiHtrfPiBHK/77Vu8kJHbE3VqFEjuyYuj2rxFeOE3776L6jO8sWL1sjMD7E2PkSZaC/OEI2UxHx8KUungy41LE7k4XttXr+zeLlQ1yWqfk6iODd15i8vdMu1GEW4A9JSk7Pc2o6o4ALprPO0sPDw48Ny9kPDl0UCL+Is2KmEBs2C0+zEA+hNSepfUALk4MUaMTeIfNn44NwgN3mRSxxdOvm8CyKfo383dOYmL98ykdY3e0phzlud1q/ne2m+f3v1E7jq3NSZm7woSZ4WFhc5s4RMDzNk8WeWEOuJKWpnR1v45Jfc5IUMTCS4AaRu82JRLkNtt5y6war/vNqBVz95aej486Xl/aDUfgHW8erx/vI04GnA00DRaCDTueTSs9l3jT3TWGRKhCt+J4ZybL3N70AIn9mnn35qb8H3RQ4rxrnff/+9TcKWX17kPnrnnXesP418SSNGjAiElbU2KQ8zpCw9ePXVV22oB7/J24RV4y9hSbDKnTVt+O+Qa+nSpdZZDi8mMfwl7kdfOLFxtpPAjq3L0Rm7DfPbX3J4oRvupwdH/1CgvPx5JnXN3nzUM3mr8JvyXMpCwr1AiNEA9UP4DYRfkPZIVoa3337blsVffg4vLF/ydMGXjU/xqQZa1zyT94OF2Oj3vffes9kjnHpfvHixv2LZ+6nrkSNHWj2RMslpx/mpH3bCoTyUcfz48XZvRSbUaJfss8g77C85vAjZgJAN/VG+QHnl9EzXAIsGhj+LTRwZOpLzGWFRAI7y0aNHW+XmJEROxxh6EkIBX0IrqBwaC/mNUCSN0F+CF0BFAwTw2LcNJZIpkYZMA/SXKCMzo4ANIIADmXLyYiAr5fWX0FOLFi3svRMmTLCzrtwPPwid+Us0MHxglIcJEdKqUBckvGMCBB1SZn/I4YW+mZ0hIyfAge4B5kB4+fM8p64Be3x4NG7kpiyB1rVTP7QP+AGElIH6ARzYINVfcniR44m6YGYbvy26CLSunfeDuiFpII7mWbNmWb7IRefpb0S+Uz9sFAsAoi86N9pQoHWNLigXs8m0O77xWdIOJ06caDsRZnP9JYcX9xNoS6JMJuX4mw4pEF45PdM1wKJyWaXNrB875ZLqg/gQKpvFkPymp/aX2OkWhzH+MgpMCly+nSRsAIa/BC9eBF5YXj6UBhiSk5pNNgPhRdQ0MlBegv54AThGA2QZgtOz+yMbDknKhc54wYhv4+WlITIjC/nbu+H36tKli5WFkA340vjYKfiMM85Qy5Yt7W9/5HJ44RCn0VEm6hP9k7olEF7+PI/6IVsojZ0yAArInZ+6duqH+qCu4YcO0Sszw/mpazpcRg6EXgA2tOVA69p5P5CD/OdYlUwm0YledNFFtuz+WudO/VDPvF9MiFE/ACD1Hmj98B7QiTN7z2/eO6wtZnQvuOCCgHTmywv9E+FO/CbxV4HyyqntuAZYMKdiqQQI05TGTcPJL6FArB/QmR6S3h30zw/RYOjBeHn79u1rASu/vOgtIRpYjx6ZmS2dY4HKhp5If8JLACFnfonemzoACHm5eHmZXOAYFIiM8KLuuBdLEv2TVtip30B4+VMeyg1w05HwDYD5a3HkxB+rBbmxQPhQlvzolnJyH7r861//ai2+/JYdXdLmiE2io6R90yHkRzanrpntzklPgciIC2HSpEk2AyvyYEFjfGDJBUrwohNn4TOjGYwDgLQgOOArQ/7RxJfL0d8MIbAOEJLhVmJiog3QJO6Jwgcy+4U1xHCASmUJEA2YkAqnpwtklg9eVDDKpNGA/AxZqRj4BcKLFwETHJ8cfGmAzos9dOjQrBijHNRzwiF0xPOJL2E2FR8HVijWILwgB8hOuDnbAe7Dx0K5nGBehoX0wgyvAALfHYaz3X7cnw4vel30jv6xmuE9bdq0gHgdxziXP9Aj+qS+8e0gN/oAdPnkp35oizfffLO1NrDgqHvaYX540aa5jy3hcQEABoHWNUVHJnyUWKoQQyTqhHqn82OG2B9y6sepX6w1QBmL1Bk9+FvXPI8NOXg2bRk/EyMHliABXvguA9EZvLCUsSRvv/1222bQf3545aQLVwELXwEvGA5pGhwOuO7du9seCqsmkB6OSuVlozHzojBEArXpUZo1a2bBMKcC5XQMXgwzMHMxmakc5EGRvJT4fvwlGhaghSnfu3dvawEOGDDA/oYHFpe/hD5YNUCPhFyAM/pCNnrNc889119W9iUCVABjZMOsR/90GsTMMWzwd90aLyS8CBJmOEVHgf55IQCwQHj5UwCnrnmhqQtePoaj1E+gdU390DniSqAMAwcOtNYMu7tgHZKF1F9y6hqLiLrmb+qE31Agdc31vB/IQHsGdBg+kVSQY/B0rFeuPRk59cPwFHBo1aqVrW/aDtZ1oPWD9UjZ8FECdLgAqJM+ffpYaxdry19yeOF/pA0yDKTdIBuWcyC8cnqmF9aQk1a8Y54GPA0EpQZctbCCsoSeUJ4GPA2UGA14gFViqtIriKeBkq8BD7DyWcf4dpzZt+wsOI5PwJe4Ht+SQ/jBOMbHIXwvufF0ruHb3+t87/F+B4cG8D/hbM+NOJf9PA5rfF4OOe2GNuSQbztyjuX07e91Od0bDMdKPWAxS8fMTaDEzA4xMDkRjSJ7MCozVATiOcTMDgGI3377rT2Ek50QBxp0XkQQLA5xj4pOA9QT0/bEGAVCzFY6Kzhyug+Ht28GC9oSq0Z82xpR7QSy4nSHcJAT+uMPsYrAl78/9wTTNfkLagqmEhRQFiqamS9m6wAQZjmYjSSGh+lcZiWZ3SBUgEBMKpyZIno3xxoiQpiGxXVYUaTUoUEzS0cIBDNUNO7rr79eX331lZ25Y3bHtzdlJgp+TlQ2MvFM0sMATpxnlo+ZJPbVo8E621cVUAXe7fnQAPVMnTKLCQgR7kHwJu2AuCNmxbCymbUjWJVr6GjOO++8LAuKmUx4UNfEGDZt2tS2OSwqwhNoQ8x0ch/XErbCjDRtj3NY2hAhIbQN2hudL2ExLI0hDpJ2TLsFWIn9YvaV2Vhm7oojlWrAohEw9QrQ0GAAF4AL85tei/P0bEyvE7MF8BBqwRo3J7UOlQ7QXXvttRZMABcaL/cRv0OMFXFQTDUzZU/owgSzhILGBPg4oR5cD08aJ2EhxE0RTkDIA6EKhIkQDc89TGNnH3IWx8ZXnGVmKQxhDUTkEw4AIBGnBTAQNkMdAyrEHmIJEU5BiA4hG7Q3CGuKttG1a1d7P+BCZ0TdEn8GkHEt4AIgEXkOwAE6tBun7SADYAeg0X4J8iWcBauddk04D3nWkI92SABwcaVSPSRk2PazSddMBQMSLCOgYml09JD0bo7lRMOhYdKQaCA0RocANNYEAi40BkxugvDoXXv27GkbDg2IAFOuwYqigTsNDj40Lv6mgXMPoESPTU8Jf+K0sKhokFhmvs935PC+T50GcCXQMTHMZ9lJv379bGcEqBC/RF3TuRCXyDdARQcGaPnWO22OTgzriA6J9sb1gBTgQrugo3PWCHJNduIaiPZGp8p9tBmACjAEBFmi5LQZZ2SQnU9x+LtUAxbWDOu4qFQsGioUM5sGwDfAwNCNxob1RYOjIUA0LKcBcD3AQgPBHAeMMNs5znX8hh+NDvOcj3OccxCWG/c7z+Z4bh8ANZBVA/YB3j+uaYC6o76vvvpq2z7ogJx68/0GGLCaGBIyvGf4SJty6pzztCE6TjoigI92wnm+nTbCb4Z93M89TrvgWRDWNx0u53zvd2ThmHOc4SZuj+JKpXpIiH+Kbc0xwRnKATY0BkxxzG5ABFMcHxUWDkM0fmMBcY7lCxDDO/6mJ2Nox3pFp4HQmHgGjYnnMdQkmhgLymmY8KDBAnQ8gyEFPTPXYVXRI8MfnlzHUBUZPSoaDVBvDAeJVGcJCnVOPeMjAoCoK35Tj/hI8XniZqCDpK1wP0TbIuqdlQgsS8KipkN0gIz7aQMAD22N4SA+TccdAcBBtCuGfo4FjoXFiAB3BODEciLaDb5ZhrLF1X9FWb1Id7QQJMRQk4blO2TISTSGnAAaDdojTwMAIENNwC0vwtrDPZFXG8uLT1Gd9wCrqDTvPdfTgKeBgDVQqn1YAWvLu8HTgKeBItXA/wPCYGQ/fjsw4wAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "" ] @@ -367,16 +466,19 @@ "text/markdown": [ "```python\n", "\"\"\"\n", - "========================\n", - "Cumulative distributions\n", - "========================\n", + "==========================\n", + "Scatter plot with a legend\n", + "==========================\n", + "\n", + "To create a scatter plot with a legend one may use a loop and create one\n", + "`~.Axes.scatter` plot per item to appear in the legend and set the ``label``\n", + "accordingly.\n", "\n", - "This example shows how to plot the empirical cumulative distribution function\n", - "(ECDF) of a sample. We also show the theoretical CDF.\n", + "The following also demonstrates how transparency of the markers\n", + "can be adjusted by giving ``alpha`` a value between 0 and 1.\n", + "\"\"\"\n", "\n", - "In engineering, ECDFs are sometimes called \"non-exceedance\" curves: the y-value\n", - "for a given x-value gives probability that an observation from the sample is\n", - "below that x-value. For exampl...\n", + "import matplotlib.py...\n", "```" ], "text/plain": [ @@ -389,7 +491,7 @@ { "data": { "text/markdown": [ - "### 🖼️ `hist3d.png`" + "### 🖼️ `timeline.png`" ], "text/plain": [ "" @@ -400,7 +502,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -413,24 +515,18 @@ "text/markdown": [ "```python\n", "\"\"\"\n", - "==============================\n", - "Create 3D histogram of 2D data\n", - "==============================\n", + "====================================\n", + "Timeline with lines, dates, and text\n", + "====================================\n", "\n", - "Demo of a histogram for 2D data as a bar graph in 3D.\n", - "\"\"\"\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Fixing random state for reproducibility\n", - "np.random.seed(19680801)\n", + "How to create a simple timeline using Matplotlib release dates.\n", "\n", + "Timelines can be created with a collection of dates and text. In this example,\n", + "we show how to create a simple timeline using the dates for recent releases\n", + "of Matplotlib. First, we'll pull the data from GitHub.\n", + "\"\"\"\n", "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(projection='3d')\n", - "x, y = np.random.rand(2, 100) * 4\n", - "hist, xedges, yedges = np.histo...\n", + "from...\n", "```" ], "text/plain": [ @@ -443,7 +539,7 @@ { "data": { "text/markdown": [ - "### 🖼️ `tricontour3d.png`" + "### 🖼️ `stackplot_demo.png`" ], "text/plain": [ "" @@ -454,7 +550,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASwAAADICAYAAABS39xVAAAvBklEQVR4Ae1dCXxU1dX/ZzKZbBASwr5jAAGRHVFQlEVlE2VxrxW3ajdt+9W2dvGrn7bSqrhXrFrqWlEBpRTQKoLIoiC7hLAkIQsh+55Zssx3zh1ehJBlJpmZ997kHH7DTN677917//e+/zv33HPPDXOTQEQQEAQEARMgYDFBGaWIgoAgIAgoBISwpCMIAoKAaRAQwjJNU0lBBQFBQAhL+oAgIAiYBgEhLNM0lRRUEBAEhLCkDwgCgoBpEBDCMk1TSUEFAUFACEv6gCAgCJgGASEs0zSVFFQQEASEsKQPCAKCgGkQEMIyTVNJQQUBQUAIS/qAICAImAYBISzTNJUUVBAQBISwpA8IAoKAaRAQwjJNU0lBBQFBQAhL+oAgIAiYBgEhLNM0lRRUEBAEhLCkDwgCgoBpEBDCMk1TSUEFAUFACEv6gCAgCJgGASEs0zSVFFQQEASEsKQPCAKCgGkQsBqxpDU1NXA4HJAdyIzYOlKm9o5AWFgYoqKiYLUGnz6Cn6MXrf33v/8dxcXFiIuLE9LyAi9JIggECwEmq5KSEvTo0QP33HNPsLKtz8eQhGW327F48WL07t27vqDyQxAQBIyBQFpaGtasWaNLYQxpw7JYLKitrdUFEMlUEBAEmkegrq4O/IzqIfrkqkdNJU9BQBAwPQJCWKZvQqmAINB+EBDCaj9tLTUVBEyPgBCWgZuwzFWGQnsh6tx1Bi6lFE0QCB4ChpwlDF71jZvTyqMr8fK+l+GsdWLWwFn41YRfwRIm7xfjtpiULBgICGEFA2Uf8/j0xKf4044/obK6UpHU8oPLEW2Nxk/H/FRIy0csJXloISCvbIO15/GS43h428Ow19hhC7fBarEiwhKBl/a9hI/TPzZYaaU4gkBwERDCCi7eLeb2xqE3kFeVp4hKS8zexbxM6c1Db6ohonZcvgWB9oaAEJaBWjytNE1pUZHhkeeUKiI8Avvy92Fb9rZzzskBQaC9ICCEZaCWfvfwuyhyFDVqpwpDGGrqavDO4XfUt4GKLUURBIKGgBBW0KBuPqOs8iz8J/U/yl7VVEq2ZX116ivsydvTVBI5LgiENAJCWAZp3k8zPkWePa9R7UorItuy2Bi/Pm29dki+BYF2hYAubg2ZmZnYvHkzIiMjMXnyZPTq1atdgd6wsjzU25S5iQZ9YQ1PnfO3NcyKr099jXJXOTraOp5zXg4IAqGMgC4a1p49e7Bx40YV7yohIaEeX47QwMH7eDV4e5LU0lQcLDjY7HBQw4PdHNLL0vFt4bfaIfkWBNoNAroQ1qhRozB79mwwcW3YsKEe7M8//xx/+9vfsHPnTthstvrjof5jc+ZmlDnLwEM+b8RV61IamTdpJY0gEEoI6EJYHK1w0aJFmDJlCnbt2lWP54wZM3D//fdj4sSJcLlc9cdD+QcPBz/P/LxZ21XD+oeHhWP7ye2oqq5qeEr+FgRCGgFdbFj79+9XQ0J2huTIou1ZDhcfxuGiwwi3hHsNA6flYeShokMY332819dJQkHA7AjoQlgTJkzA+PHjvR4CmR3k5sq/4+QOZUCPskY1l+ysc2ycd9Q68GXWl0JYZyEjf4Q6AroMCRlUb+01od4AX+V85dNwUMPDAovyfK+tk1DSGibyHfoI6EZYoQ9tyzXMqcxBclGyT8NB7a48W5hSlKJ8t7Rj8i0IhDoCQlg6tvD+/P0osBe0SsNiDbXUVYoDBQd0rIFkLQgEFwEhrODifVZuO3J2gId03jiMnnUh/cHXcHC/PbmyTKchNvJ36CIghKVT2zpqHNidu7tVw0GtyDws5HWF7BohIgi0BwSEsHRq5aPFR5FZnnlW3Ctfi8L+WGllaciuyPb1UkkvCJgSASEsnZptd95ulFeXt2o4qBVZ2bGcpWBbmIgg0B4QEMLSqZV3ntpJjgltg5/tWGwD25u/V6daSLaCQHARaNsTE9yyhkxuxY5i8JDQH7vgsNc7a1i1bvHHCpkOIhVpEgEhrCahCdwJDoV8svJkmwzuWumY9E5WnFQf7Zh8CwKhioAQlg4tyzN77JLQGneGhsVlw3uxsxjHio81PCV/CwIhh4AQVpCb1A03vsn7xq+5VtdWS3wsvyIqNzMqAkJYQW4ZzX7FPlT+EovFs67QX/eT+wgCRkVACCvILaPsV2Rz4qGcvyQc5I9FdjHecUdEEAhlBHQjLA6FvGrVKuTm5oYyvufUbVfuLlTXVZ9zvC0H2PCeb89Heml6W24j1woChkdAN8Jau3YtXn/9dZw4caIepFCP6c72q0A4ebIDKUcf5cgPIoJAKCOgC2FxHPfCwkK1Y055eXk9vqEe073UUar8r3jnG38Lk9bevL3+vq3cTxAwFAL+f3K8qB6TFH+2bNmiYrdPnz5dXcUx3fnDmlYoxnQ/UX4CHAOLjeT+Fh4WHis5Bl5U7Uv0Un+XQ+4nCAQSAV0I6/rrr1d16tu3L4YPHx7I+hnq3ux/xTve2ML9vyMQG/GZDPkzsNNAQ9VbCiMI+AsBXQhLK/zChQu1n+3i+0D+AfDGG4EQ1rDYZYJnC4WwAoGw3NMICPh/bGKEWhmwDBWuCs/uOOH+c2doWE026vOGrCKCQKgiIIQVpJbNKM9AdmU2eUwFjrC4KrwjNBOXiCAQiggIYQWpVTn2OhvEeTYvUMJ2rIyyDJRSjCwRQSAUERDCClKrsv0q0FtycagZjgLBhncRQSAUERDCCkKr8qanbFvy5/rBxorN0R9Yi+OdpEUEgVBEQAgrCK3KMdf5wzN5gRYxvAcaYbm/nggE/gnSs3YGyfvbgm9RUV0RUPuVVlXWsjiaqb/XK2r3l29BQE8EhLCCgD4b3JlA/BGwr6Xish0rvSxd+WS1lFbOCwJmQ0AIK8AtxrHW2eAeaPuVVg0ednKYGZ4tFBEEQg0BIawAt2hORQ7YBysY9iuuCmtxrM2xP5aIIBBqCAhhBbhFecauxFkSNMLi6tS562SmMMDtKrfXBwEhrADjruxXFHM9GPYrrSrsQKpFbtCOybcgEAoICGEFuBX35e8LqnbF1dE83gsdhQGundxeEAguAkJYAcQ7tzJXRU/gmbtgCi//qaypxJHiI8HMVvISBAKOgC6ExXHc33//faxevRolJSUBr6ReGTBhFNgLgq5h8fCT9z1MLpSQyXq1veQbGAR0ISyr1YqhQ4eiqKgIb775Zn3NQi2m+/6C/SpgXzDtVxqYnCcTpkRu0BCR71BAQBfCSkxMVGS1c+dOJCUl1eMYajHdd+fuDrp2pYHJdqyU4hTYa+zaIfkWBEyPgC4RR+12OyZOnIhwCma3bt06zJ49WwEZSjHdedstjv4ZbPuV1iPZ7yu/Kh9ZZVkY0nmIdli+BQFTI6ALYSUnJ2Pjxo0qXPCiRYtMDWBThT9efBy5Vbl+3TC1qbwaO86Gd16/yH5gQliNISTHzIiALoQ1duxYjBkzJiiLgfVqlL35e+GqcyEqPEqXIrANq6auBoeKDmEe/RMRBEIBAV1sWAxcICNv6t0wbOjmHXIs9E9P4fWLhwoPBWzjCz3rJnm3TwT0faJCFPNCe6HyNNfLfqXBynYsjtxQ4CjQDsm3IGBqBISwAtB8x4qPqTDFPFOnpzBhlThKcLzkuJ7FkLwFAb8hIITlNyi/u9HO3J3KfvTdEX1+sR2L3RpSilL0KYDkKgj4GQEhLD8DyvGv9ubtJaoI3O44vhSZbYW8AFtEEAgFBISw/NyK7PvEIYr1tl9p1eJh6ZGiI8rjXjsm34KAWREQwvJzy7HfU74jXzf/q4bVYTsW+4Ox8V1EEDA7AkJYfm7Bnad2Bnz/QV+KzIRV7CyWyA2+gCZpDYuAEJYfm4ZDE+/P329IHzO2q4kIAmZHQAjLjy14qvIUjpQcgTVMlwUETdaEtSw2vLPnu4ggYGYEhLD82Hq783aj1FmqW4SGpqrChves8iycrDjZVBI5LgiYAgEhLD8201c5XxnKfqVVjTUsDiTIcd5FBAEzIyCE5afW48gIbCcK1v6Dvhab1zeyBigiCJgZASEsP7Uee5NnV2Qbxp2hYbXYkZU3dOUtwEQEAbMioIt1OCMjA9u3b0dsbCymT5+O6Ohos+JXX+6vT32NquoqRFn1CSdTX5AmfrAjK/ti5VXloUdsjyZSyWFBwNgI6KJhVVdXY9CgQcjJycHbb79dj5BZY7qz1sL+V2wrMqqw4Z3JSuxYRm0hKZc3COjyhHEc93HjxqG4uFgRl1ZQs8Z0z6nMUZE9jbIcR8Oz4Tevc9xxckfDw/K3IGAaBHQZEjJRLVu2DBdeeCGuuOKKerDMGtN9Z85OFDmKDGtw1wDmhdAcCZUdXCMsEdph+RYETIOALhrW1q1bcfToUaSnp2Pbtm2mAaupgn6R/YUyZhslQkNT5YwIi1ALs8UfqymE5LjREdBFw5o7dy74U1dXZ8hlLL40Gu+Ow9t5Gc27vbE6sIZV4ixR7hf94/o3lkSOCQKGRkAXDUtDxGKxmJ6wmKzU7jhB3o5ew9DXb7fbDZ7RFBEEzIiAroRlRsAalnlz5mbUuM2zRo8nBnhdYWV1ZcOqyN+CgOEREMJqQxPx8GpX7i5TDAe1ajJhnSg7gfTSdO2QfAsCpkFACKsNTbUndw+yKrIME13Um6rwxICjxoGtJ7d6k1zSCAKGQkAIqw3NsS5tnQrZYvTZwcaquCV7i4SbaQwYOWZoBISwWtk87BqwI2eH4X2vGqse+2AlFyYjrTStsdNyTBAwLAK6uDUYFg0fCrYpc5OaHYwMj/ThKmMkZfeGMlcZvsz+EoMTBvutUAcLDqodrzPKMpAUn4SRXUdiWOdhPs0EV5I3fiHFoHeXnUSssxKRzgpExHaDNb4frB26+62sciNzIiCE1Yp2Y0/xDekbfHoQW5FNQC/hYeyWrC24/YLb27wGktdSvnrgVby07yWUu8rV/dh9oqOtI8Z2H4v5g+ZjUq9JSIhKaLROTJ77aPOOfRRPLCF9B0bkHEa/ogxE1rpgq6UZ2IhohNG1tYOmImz0rbAMvLzR+8jB0EdACKsVbXy48LCK3W7m5S0ct+tg4UE1Yziw08BWoOC5hMMuP7L9EbyX8p4aHkdbv4u84ax1KlJkTa5Phz64uNfFGN55OHp26KlWBnAU1GQiql2FB9C7NBf35uXgkvIShHEIHOXXRns78neNEyinaKm7/gn3vvfgvnARwqb9HkgY0Opyy4XmREAIqxXt9v6R91FVUwUzDge16nJkCXbL2Jy1GW0hLNas3k15V2HRcPKB87CF21SWbPNjUmPR0tWiDm6yp93tDMcvCnJp+Gc/TVREUmcKDWHBkTCIZBWZ7X4DSPsCmP0EMPzaM1PK7xBHQIzuPjYwb0q6Pn19SCweZkJZe3ytcnPwEQaV/IusL7Bs/zLYLLZ6EmrqPuz/xQTPHyax8PAIdLDF4VF7OB46lYVIF5OVF92RyYuGiCjNAt6/A/jiSUCCEjYFe8gd96KHhFyd21ShNw69oTQTI8e+8raCPCxMLkrG9pzt3l5Sn453CHpsx2OK7HzFgvQqGj7a8PsyF245lUGEU+vRoOrv7sUPIjyQLRGf0NBw3YMADT9FQh8BISwf2ph3dWZjO2sUoSA8NOMJhFVHV/lUHY4P//ye55VbhK92PL42jDSs31TWYVFeJhGVm/Imrak1wsNEHnJufwFYcz/gqmrNXeQaEyEghOVlYxU7irHk6yUor/bMgnl5meGTMeFsP7ndp52hPz3xKT489iFsVt+Im6mpmrS6e+1u0qxO0F8cX76VZKUhy0NEayQZ5JcDH/2YMhDS0qAJxW9dCKukpAQrVqwwZCwsdqj874n/qm2xtAYvtBfiV1/8Si1nCRXtSqsbD+dKXaV49/C72qFmvzkyxVO7ngJHL7XQP1/ESeRyba0NPySblRoGtpWs6jMn0oqgWPp73wZW/5A0rcr6M/IjtBDQZZaQfXQ4rvtHH32ESZMm1SPKMd35HMfJCrawL9Bj2x/DxsyNKpJBrw69MCRhiJqq90y/JyMqnB6KEJRISyRWHVuFmQNn4qIeFzVZQyapv3z9F6SWpvo8Q+qiu45FFH6bkwUrrWVUs35N5tSaE0xaZIzfR8TLRvjrXgIiO7TmRnKNgRHw7RXpp4okJCTgsssuO2e3HD1jur916C18cPQD2GvsajEzx2n/LOMzfJz+sYrX7qutxk9QBeU27Plur7Zj6a6lauefpjJljNalrqt3VWgqXcPj9BpCFyL7RwoKEW8vDwBZnZFjBA0P968AVt4FOErPOCE/QwEBXTQsBq6iogIOhwOsVYWHe/xu9IrpnlaShreT31YalDbjxbvMaOUKhYZuqQ7sarAnb4/yWL9/LBmwGwgTFRvaVdBFH4ZyyshOkxS/LnNgaGm+d64LDfL27c/Tmtah1eRwSprc/GVAx56+3UJSGxYBXTSswsJCrFy5Evn5+fj44491BYeXlbAvEW+BZfRdbwINFGuRL+9/GQ9vfVi5bnB+HIqGnUMf+vIh5SzLRO6LOCn9LdUWzMsnuxVxSdCEPe5TNgDv3AjkpwQtW8kosAjoomElJibi4YcfVjVjm5WewtE3edhnZq91f+HHQ0MW9lzn3XXiI+PVbkBaVAffycqNCWS3uv9UJk0I1gR2KNgYCGyIz6Rw0G9eR17xTwFDZzeWSo6ZCAFdCOtMfLSH5Mxjwfy9+uhq0y+z8Sde7JvF5H20+Kha78dDZNY8teU03ual7FaWaPwhrwAdneXBJyutoOzyUHwCeO97wOSf0+cBICpOOyvfJkNAlyGhUTDSDOvs8S1yNgKMCdu1+NtXsmK7Fchu9WC5A8PYbsUOnnoKe8XXklf8548Br80go/x74vqgZ3u0Ie92/aSuT1tv2phWbWjzgF/qJIJa7LJgfn52cO1WzdWMSdNKQ8RTB4AP7gS6XwBccB0wYArQZTC5QHT0OKAqciXCZdcaXvpTR8uG1FpFGi6zoyx71ovohkC7Jawq8ohec3xNm2NB6dZyBs3YQc/1JHcUfpZLdivWavTWrhripAiHCImJK2evh8QoQCA6difSoqEia2O8tpHjcJGrBygmV72Tqy2WhpPxRHCDgF5jgb4Tgc4DG+YgfwcQgXZLWOxjlVKUUh91gbqokvAAgh3qt6ZHG4PCovFYbi5iHRVBcGFoLaLEqkxMYHIi8irPAcqyPL95OKtNZ6pJCEpbL3SOta3D9M3nmOj6XQyM+T4w5CqPhlafVn4EAoF2SVisXb1+6HXqmsraAhd1voFhkRydCZluJyK4z4r4hEA1YdclPBpLCkrQt6LIwGTVoFpMPMpVoxWvKlpfiuQ15D6xHugznlTLn3ric4lNtAHI/vuTBvbtT9h2dSD/AM1+Wck51Io7XFa8k52Dl3ILkUTT8K4zX6rtDx6fa1xDZNXJEoXHiyowqpi0FaMNA32ukZcXMNGxXYzjeGXuoJlI0rTenA+c2OblDSSZrwi0O8LiHY85phW7U7iow93msOCh7DQk2ksxqKwAz+UXoT8iQRYMES8QcBFZdSbNamlJFaYUZrcfsjoLG3rD8WYkHM756CfAG/OA//yShpknz0olf7QdgXZFWDwA/NvevyGl+DCF5rXSYtxI3JdHnUpzaqQ3ZVJpHu6qdKGWO59IkwjwqJkN7Enka/VcYTkm52d67DpNXtEeThAgrHFxDPrtzwGvXglwOGc23Iv4BYF2RVgv7HkBrx18jUYsVsTRYtyHCkvQgbaROmsIQ5rX7JICnA+baFlNdDEeAlbTUHoWhYp5LScX44pIs/ImvHET9wu5w8qFgpYGFadRuJv7SOO6Fji+MeSqqUeFQtrozuFQOAoBRwplFwYOoWKhYaCbnBp/VlGN0bRTy1lkxS1AhNWRZrhuqHLi0ZhwWNkPR0QhwJMSLnoY+5C96t5yJxYVZFKoGNIm2ovNytd+oGYi6aLjnwMZZOMacjUw4R6AtykjwhfxHQGTo+ZGdmUmEdK3NMxLQVZ5JvLsBXDV1KK2jrQAGupVkc2KN/Z01DrIazsCTjayV1txS14qoeWmD6nxjcg1RQV4J6YX0knPYl/v9iw8lOaZVDas3+Rw466iXPSqLPFAImTVctfg5UH84vt2tWdGsfd4Wtc4h8bTU4HEwc3H7WK3C3Zgpf0e4SzyRFStraNRZg2cYRHULtH0odEA/a4Ns8LNL2T6hJHG6+YAi9RuFJRalVFbtsv223BLGKzhYYiyhiPKFo6IcAs9H8bv56YmrHLaGfh/P38FO9JzYK+KoYZxIy4qEnEd86kBs+CwlKOUiMtCGpWbbAuRRFgLaArwFzkZCFNOjU00EDVovKOctKxqPK60rLqWO2UIpmA6p0eFwu7YMI8iLtxBExIXlNNDw46VQlS+tTj1KWXfoj6KDJpFTN9CwHbyhL5JHETfPTxOqUwa7LTqqgCqCgF7HhFVJU5Vd8TBuv7Y5+yFk2HdcLiyI4pqbERSRFQIRx21BxOUm9tFtQ3dR5EVF/O7fs5tyn9ppMXEZbNaEEuk9bMZQzD7wp58gWHF1IRVSzaU1JRpKD3lVEM9RrnM4kalpRa9YkowOX4Pzo/cDkd4Jci7CjPINjWqvPi0kf27Rmy8ddy4ltL/K7YXMlHV7rQs9qsKI4K/tJZisBeU4qLSAs+bvv6BaBw1OdoSAtTv2Nue53Q4XlfRcaDgiMchlcmMGYWtp8Q7hRH9sMlyMdbWzME31QNQXBcDZx0HpnYjnDbvOEN3apAp3+T0S1bd7/Rpypp7vaZpaRdxEmd1LbJL7Nohw37rQlgctO+TTz5BZWUlZs2ahdhYWvLQSnG7udlq6OGitz4JNxNpzEgtj0da2QxMiBmBv0S+ikGOndRSVF02DvPbriWhB7NzVRkWVXXBk9FsyzrdAVq6zuTnWUvltYDssX5fWSXmFFFI42p6sPjNr97cJq+gkYqvkb/maMqaK71wMyIuwAr3VVjlvAjp9k6KzCLCOIZ+HWIs3vbD0328sa7eyLE6GhKytmV0oac3+PLvf/8bKSkpKtroK6+8Ul8AJrKampo2x3Rn2MPD6oibqrHN3h3X2/8H/42aTQe9bWytSG7MLy5EHzVjeOarSjsfWt88+8dbcN1SHYF/nszBtbQeUBnV1Qyg8TuzeVuD+6ULRbbeeNr6Q1xn/yOeLLsSmc5YcrxxITKsRmlV0gJK8Qx+MycnJ2P69OmYM2cOMjPJf+e0BCKmOzd2rjMSv6hajGTbOMrJB58YegN2rSrFrfYa8svSRRnVoAn4t5Oeht7kU/V0iQOPZKWie1XJaa1KHpPAgl+NOnKxWRm5CPOcj2JJ+dXId0UiOswFK710Rc5GQJensHPnzkhNTSUNyIKoqKj6EgUqpruN1OkClw2/tS7GmxEZ6FBN9hhlRKjPutkft+afxJd9+2Mr7PTGCy1hvdFF7TCtjna0OZWDfhUlnteYDP8C29C8iJrMGEciRuLxmu/hk7LzlW2VieoMG3lgy2DCu+syJFywYAEOHz6s4rrfdtttQYGNNa1t9r54PuxWj+ZAwx+vhOxdUc4q/Ca/EIn0JuRhU6gIRwWtI4/+u51WPJOVTmRVfBob0aoC2sbuatTSlmSv275PNtLfYn0lbSfndiFCNKoWYddFw+ratSt+/etft1g4fyewUUd5s+oS3BC7EUnOfXT7CO+yIA3kfFpn+GB0NP4YRz4vtNSCgwabWZh4o8nd4zfkQHtDXoZ6u6sJCTNXyvBlp5ddWDUybMPwfzWLsa5yGCzkKxhFx0S8Q0AXDcu7ovk/FU8FF1bb8HrdLNIkeF7ZB22Jrl2Qm4HHaOo3mqb7edrfrMKPR2faPPVJqssNVCe4aRrdm5lTs1bYCOVWM4DABts8mgT6HdZWDoWNtCqxU/nWOO2KsBgaXiG4yj4GaRHDPQ+qN3ix40oNxSWgMLrzKux4pqwO/d3hcJDGxm4AZhKecuhNZPVCQRmmFWSrKXPlhc1LbNgvSIuyKUuS/NisLlTaEvGI5QHcV34XslwxolW1El1dhoStLKtfLmMtK786Ev8kLeuR8EP1/nVN3pyMo3W01KFmzJ0Iv+wBhEfH4TLygv9n1g48m/Ux1hTuIUc8t9qsocl7GOSEk8iVoys8RUH2hhdxlArStWwxQFw/oOvQ057WpHkWp5NDYypF4uQ0ZBzmWOYmHwLr0wT0MqPh3uGIsfh99Z3YYu+n3BQizG1N0AfK07m2O8LierOW9aFjLO6OGYK+jmTqVE3Ysk6TlWPOC4ic8L3v5hVpJ+GeXYdgyYhFuOzYv/EMbcSaXplN22PZ6LE2Zm/koISDLR3wzKlcDCZnUMT1ouiY84CRNwI9RnjISuuKPINVSTOpxz/zhEdJ2+LRxLTFvFo6+W4aAR5mE9G/a7kOj5TNRw67KlgccJ12M+e1e2Zw1Gy6gvqcaZeExVrWqepovEPexL+2HKaHsQnwybheefGDiDmTrM5MGhGDOcNuxNjek7F099NYm/YfMgVRRySNzEiiyCosBs9mZyLJXgVc8iPP/nydz2u8mOzS0KEbMOpm4MIbgAPvAxsfo7UiR0+vh2v8MjnKCHBnqkZ2eB88UbcYn4VNxvjzO2BY91h06xiJElqfmlFUha3HCnCylBfkexYiC3beIdAuCYuhsdEbcKVjAu6MGoCurhN0pAHJ1DpR1ncqrNN+0/DMOcj2jOuDv17+BMZ1H49n9jyLYor1zXv6GUHIMoVBpFM+S24LSZ2IoG74C4U3meJ90XhyYtRNtB3WpcB6mtk9+AFBRXUTP61zMSSbZo3bgk1RV2Nd9/tw4QWj8ODQePSOjz4nbXaxHR/uzcZLm46jkAJGRtICZJGWEWhXKLE27qTQM86aOhq41SLD2RErMYMePs86xHq4iMzsUT3gvPpJxMR0qD/c3A/WrG4adjP+fuXfMaLLCDiJ8PQ2yLOBfQCFHnkmj2LVD1sE3LHON7I6s8Kd+gDXLwem/tZzVIzy36FDtkA3TVhkR52P9SOehmXRa3j09pm46+KejZIVX9g7IRo/njoIb909ERMGJKg++d0N5VdTCLQbwqqhMDMsi8b2wdyRPSkMTQRFSXHhDcelOBlxPmny/HiTEKvx4ums8Q8hYcAIzzEf/h/ZdaQirXlJ81BNIWzq2B6kg7DrQh+KMfEMuS4MmUya0XUvAtEJbSsJa1bT/xeY+4xHy+LQ0u1SqC+xmwKRlJtmV8vjBiNt4qOwf+8/mHH9PZg2JBGxXo5dRveNxz/vuAhXDe8OB0VMEGkeAS9hbf4mRj/LZJXYwYY/zBmOReNIUyA5mleBP3x4ABsOh+FX1vvwiu3PiHblUkesQ0rPG5A4aTE97q2TxOhELLlsCQbEDcAyMsjX0IPNW74HS9jZontdGJa6ojD86seB82f6N+sJd5GRPg5Y81MK7F5G5NXEpIV/c/X/3fhlwpqiRrzKF02bNGFS4pccfzShczwUpvrWxnSDq+cEOIfMhYXw7ZfQtdX9pXOsDc/fMga/WLEXa/efQlREu9EjNGC9/g7eU+R1kfybkF0OOEDZ0utHYfqw7vU3H9ytA168dRx+8s5ufHTIgl6df4AbbRvwOS7B2Et/hOFkIG2LMEH9ZMxP0D+uPx7b8RhKXaX1m7a25b4tXctk1YVC7iylWEqjrvoTjT1Gt3RJ685feD0ZAjtQzPIfeGYUDWKz86oyTFAcJC+qI3nQnkfb1o8AeMgbk+iZVODz7JdG0WrBoXX4byIzd2QnuGO7orbLUFgSz0NEp1441zrlVQnOScQa/9IbRsPu2o3PDucJaZ2DkOdAyBMW26vuvzzpLLLSsEikN9uLt4zFsI3HsOKbcGyxXoxfzhmDK0ZSx/WTXJN0DXrE9sDvvvwd0svSyfWhbUTYXLEUWZHS8FTcaIyb+ojnYWzugraeO38W2bXeBFaSxsVbWil/rbbeNIDXs0ZFDsDoPAC4YCEwYgGR1XBaoRXjVaase/EnUPpPXHQEnr5pFO5YvhO7T5QgUjStc9olUNifk5EeB5isLklKxAPTBzeZPavjD18zHGt+PAnv3DMJC4ms/A3KhB4TlF3roh4XqdjygTDGe8jKjaXdp2Li1UsDT1YaoklXALesALoQxuwpb1ThrbZowTEu/RlwzyZg5p89uzV7SVbBqla3jlF4/uaxGNS9A+1NQAQrchYC/n42z7q5nn/wJhSsQf3ftSMQG9myIpnUNRYDu3j3pm1NvQZ0GoAXpr+ABYMW+N0Y7yLNoTfZrJ477yZcNGMJ+VB1bU0RW38Nb9P+vQ9o+DnBs7Sn9XcKzJU1dnKOHQnc9iEw6y/kNNszMPn46a7nUV98/qYx6B4XSX1FSOtMWE1NWGwOrVOG0TOr5DGTMmH98qohuLB3p7NP6vhXfGQ8/nzZn/HL8b9U9qxqXhrTRnGQfWUw7Wbz4uifY+xlvyW7Umwb79jKy7sM8ZAWe8/zesRG2qWVd279ZVwG1vpG3gzc/m+g/6TW3yvIV47uF69sWmzbEtL6DvygExYbwTmy6L/+9S8VDvm7ovj+i53tOtG4/8wGZRKroi2Qrh3dC7ddMsD3mwb4CvaCv2fkPXhu2nMYGDcQDp4aP2smyrsC8B6BDiK8K2L74eXJSzCU1jp6IlB4d31AUvHOLze85fGi52l/PX211AwgGcsv/R/yZXnN47kfkEoH7qZTh3bDMzeNPt3HuWeLBJ2weHuhyMhIcFx33oTiTPE1pnuMzYolC0figt5xqHCSsyf5sbAvyw3j++LxBRcaeq3WlD5TsHzmcswfNF8tnnaRjcVb4nKRVsWbYtzd50o8O+Ml9E668kwY9f0dEQXMfgKY9zztt0ezcDzbFmxhsmK58lGPrSqILiWejP33/9UX9MCzNDxk8wbbZAMlrIw2NloJVH6tvW/Lxp3W3pmu4w0lvvjiC5SVldXf5fLLL8ekSZOwevXq+mPaD9a8Dh06hJ07d+LWW2/VDjf7PbxnHJYvvoiWOBxDfoUTI2kI+CPyIObFpUYXnj386+V/xcyBV2PZvpexv2C/cjRllwgL+ftoC6n53eqmh7CGtJYw6lmjOyXhgQvuxKRBNPwy6szceNL4ug0jX60HgJy9ZPAmIgvGwnDW6thXauYSz5pJo3cCL8p3JTmVvnXPRPx+9QHsSC2iZV+06SltgtpWYYLiYBw19B/fs1O0ra23DPj1ASUs1qa6dOmCaIrUyb9ZIiJo92WnE3a7HS4XzdycIa2N6d4/MUZpWmfcylQ/p/Wbjkm9JmFz5iZ8ePRDHCg8gGJnKc0oerQTGxFYfEQHDCWiWnTeXEwbcDWiyB/I8NLvErIdraGodb8B9r3rcTBlMgmUMFmxNjXrr8DEHwQqF13uyy/it+6aiNe2puGDXVlILahUmrn2XGmFYpNLS8IpeNF1B5qM6h4XhYsGdsZCWgEyrn9CS5fqfj6ghBUeHo6RI0eeU0m2X1VUVOCtt97CvffeS+v1Ys5J094ORFmjcfXAWepzqjwbqaWpKKjIIdWqBp2iEmnh8kD0ISdU8LbnZhK2ay18Feg5Gvj8T54djQPhZKoielJ3nvMkMOFuMyHkdVnZT+vntDvz9y/ujy8p2sOBrFIcJ+Ji9wdWBzpGWZEQY0OnmAjEU9qoCM8W9Kwr8CQUExWn4+PxlKYHkdV5XWIR48UsuteFDHDCgBJWU2W/6aabcPPNNzd1ut0f79GxN/gTMsJaD/s/9RwFrH0AyDvs8YnyVwVZs+LlQXOeAngoGuKS2CGSJpV6q0+IV/Wc6gVQPz8nr/oDDdXY+hPyI7QRSJrqcS+od33wgxGZFpgrh9BrX2wXZBXaHaTl2ulCWC0XS1KELALxNKy98W1gxh9JKyIjL3ugt1bYxsfr/xb9Axh9S2vvIteZCAEhLBM1VsgUle1wHFfr5n9RLPlhpx1NfdG2yBpTXUWzkCPIWXUVMOyakIFGKtI8AkJYzeMjZwOJwOCrgDs3kPvBTzyze+yVrvlQNZovERVrZGyz4vDNPAPZd0KjKeVgaCKgi9E9NKGUWrUKAY4dP3epJ3LCtueAY59SWNgKj9e+coWheS0mMf6w8Z7XBE55kGLNL6TseM5LpD0hIITVnlrbyHXlmPH8ydhB0RU/AVI3A/ZC8mokjSo6noaO59MuP9dRgPrpnjhcRq6LlC1gCAhhBQxauXGrEOh3McAf4iW4yE7FkRai4j0aV6tuKBeFEgJCWKHUmqFWF97klT8igsBpBMToLl1BEBAETIOAEJZpmkoKKggIAkJY0gcEAUHANAgYkrB46Y7VKuY10/QiKWi7QkDPZ9OQrFBVVYX9+/ejsLCQ4vWQ/00TohEbx93yJqxGE7cJymEOq2OGcnJnZCw5mKKRhSOBcPszpkYWi8UCLmt1Na15NLBoz1JL5eT6pKenw+EgJ18dhOLBeRFAJ8gF++abb3D8+HEwOM0Jk9mqVaswf/581SmaS6vnOa7HmjVrMHnyZHTu3Nmw5MoP1ubNm9GjRw8MGTKk2ZeF3nhyoMfi4mJceumlhiVXJoH8/Hx8/fXXuOaaawxbTm5LJiruowsXskNu88LPHfeP0aNHN58wAGcNqWGNGzcO/PFGjh49ihtvvNGbpLqmyczMVJ2BCcvIwh138ODBGDNmjJGLid69e+PkyZPqZWXkgubm5iotkF+qRpe0tDQsWrTI0MU0pIblC2InTpxAv3796iOa+nJtMNNmZWWhW7dusNlswczW57zy8mjX4agoxMXF+XxtMC8oLS1VEWu7du0azGx9zouj67KW1adPH5+vDeYFrDXxS7V/f4qmYWAxPWEZGFspmiAgCPgZAUMOCb2t4/bt27Fnzx5lx2gsFLO39wlEOn6rrl+/XtmBrrzySjWE4Q05Dh48iKlTp2LYMAqrYiDhCQ62B/LmHzw0YFsW2yh4wxCjCNusPvnkEzWDPHfuXLCW9dFHH4G1LLYRsQ3OCJKdnY1PP/1UadNz5sxR3x988IGyXS5YsACxsbG6F5OfnV27dqnIv4mJifjss8/A5pWrrroKSUlJ2Lp1K/bt24cpU6ZgxIgRupdXK0DzVm0tlQG/eSj43nvvKUP2a6+9pmYUjVRMNrSPHTsWAwYMwMsvv4xjx45h7dq1igCWLVuG8vJywxSXNwPhB4ofMiarf/zjH6qcTGA8+WEE4SHL008/rYYt8fHxajOTF198UdnbuIwbNmwwQjFVGXivgg4dOoCH17wT1IoVK9QEEpsDXn/9dUOUs3v37khJSUFOTg6+/fZbVc6JEyeqvsoTGvwi4JfVK6+8ol4Mhig0FcK0hKWNt0eNGqVm3ti4aSThtxa/mY4cOYIJEyaoB5+1KtZauDMbqbyvvvqqwnDgwIHYu3cvmBC4nOeddx5SU1MNASuTKmuoXEZ++2/btk3ta3nFFVeAHzR+IRhFeAaNy8hl4skBxnDatGlKW+F+awThtmXbL7uxsGbFIxR+wfKeoTyrOWjQINUHuC+wxmgUMS1hsQGbZ4n4LVZUVISEhASjYKrKwZvEPvHEE6oDzJo1SxncueOeOnVK7dNolPKyVwt3Sh5u8RCBh4a8jyQTKk8U9OzZ0xC48nCPieCSSy5RWHJ5efs41hL4w64YRpEvv/wSixcvBpsCvvrqK1W2AwcOIDk52TD9lF8APKTmD2PH5MraFvfboUOHIiMjQ/UBxtlIExumNbrzEIHVVlZn+Q3LncNIwmr1s88+q7QsfpvNnDlTDbtY42K7AG8oazR5//33lQ2D7YJbtmzB8OHDwTYX9icygrD2x0M/foDY1sYP1cqVKxXh3n777YbZLo6Jf9OmTUp7Yb8mtlktX75c2bBuu+028HBMb9m4caPafZ1HAnfccYeyWfILlZ8jfp4YV+7D7DvI2qFRxLSEZRQApRyCgCAQPARMOyQMHkSSkyAgCBgFASEso7SElEMQEARaREAIq0WIJIEgIAgYBQEhLKO0hJRDEBAEWkRACKtFiCSBICAIGAUBISyjtISUQxAQBFpEQAirRYgkgSAgCBgFASEso7SElEMQEARaREAIq0WIJIEgIAgYBQEhLKO0hJRDEBAEWkRACKtFiCSBICAIGAUBISyjtISUQxAQBFpE4P8BKLq8qGHkcuAAAAAASUVORK5CYII=", "text/plain": [ "" ] @@ -467,25 +563,26 @@ "text/markdown": [ "```python\n", "\"\"\"\n", - "==========================\n", - "Triangular 3D contour plot\n", - "==========================\n", + "===========================\n", + "Stackplots and streamgraphs\n", + "===========================\n", + "\"\"\"\n", "\n", - "Contour plots of unstructured triangular grids.\n", + "# %%\n", + "# Stackplots\n", + "# ----------\n", + "#\n", + "# Stackplots draw multiple datasets as vertically stacked areas. This is\n", + "# useful when the individual data values and additionally their cumulative\n", + "# value are of interest.\n", "\n", - "The data used is the same as in the second plot of :doc:`trisurf3d_2`.\n", - ":doc:`tricontourf3d` shows the filled version of this example.\n", - "\"\"\"\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "import matplotlib.tri as tri\n", + "import matplotlib.ticker as mticker\n", "\n", - "n_angles = 48\n", - "n_radii = 8\n", - "min_radius = 0.25\n", - "...\n", + "# data fro...\n", "```" ], "text/plain": [ @@ -498,7 +595,7 @@ { "data": { "text/markdown": [ - "### 🖼️ `barh.png`" + "### 🖼️ `boxplot_color.png`" ], "text/plain": [ "" @@ -509,7 +606,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -522,24 +619,22 @@ "text/markdown": [ "```python\n", "\"\"\"\n", - "====================\n", - "Horizontal bar chart\n", - "====================\n", + "=================================\n", + "Box plots with custom fill colors\n", + "=================================\n", "\n", - "This example showcases a simple horizontal bar chart.\n", + "To color each box of a box plot individually:\n", + "\n", + "1) use the keyword argument ``patch_artist=True`` to create filled boxes.\n", + "2) loop through the created boxes and adapt their color.\n", "\"\"\"\n", + "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "# Fixing random state for reproducibility\n", "np.random.seed(19680801)\n", - "\n", - "fig, ax = plt.subplots()\n", - "\n", - "# Example data\n", - "people = ('Tom', 'Dick', 'Harry', 'Slim', 'Jim')\n", - "y_pos = np.arange(len(people))\n", - "performance = 3 + 10 * np.random....\n", + "fruit_weights = [\n", + " np.random.n...\n", "```" ], "text/plain": [ @@ -551,10 +646,6 @@ } ], "source": [ - "import json, random\n", - "from PIL import Image\n", - "from IPython.display import display, Markdown\n", - "\n", "# Load dataset\n", "data = [json.loads(l) for l in open(\"plot2code_exec.jsonl\")]\n", "\n", @@ -925,7 +1016,7 @@ ], "metadata": { "kernelspec": { - "display_name": "nb-base", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -939,7 +1030,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..e4d9f5d --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +matplotlib==3.10.7 +numpy==2.3.4 +pillow==12.0.0 +tqdm==4.67.1 +