diff --git a/bleu.py b/bleu.py
index 532fed5..90cfb1e 100644
--- a/bleu.py
+++ b/bleu.py
@@ -6,7 +6,8 @@
# - Abstracted notation of tokenization to function tokenize_line
# - Clean some spacing
# - Removed rounding from _bleu (round(100 * bleu_score,2) ---> bleu_score)
-
+# - Passed smooth through from _bleu
+# - Add lower parameter to _bleu
# Copyright 2017 Google Inc. All Rights Reserved.
#
@@ -56,7 +57,7 @@ def _get_ngrams(segment, max_order):
def compute_bleu(reference_corpus, translation_corpus, max_order=4,
- smooth=False):
+ smooth=False, lower=False):
"""Computes BLEU score of translated segments against one or more references.
Args:
@@ -121,15 +122,16 @@ def compute_bleu(reference_corpus, translation_corpus, max_order=4,
return (bleu, precisions, bp, ratio, translation_length, reference_length)
-def tokenize_line(line):
+def tokenize_line(line, lower=False):
+ if lower:
+ line = line.lower()
return line.strip().split()
-def _bleu(reference_lines, translation_lines, subword_option=None):
+def _bleu(reference_lines, translation_lines, subword_option=None, smooth=True, lower=False):
max_order = 4
- smooth = True
reference_text = [
- tokenize_line(line)
+ tokenize_line(line, lower=lower)
for line in reference_lines
]
per_segment_references = [
@@ -138,7 +140,7 @@ def _bleu(reference_lines, translation_lines, subword_option=None):
]
translations = [
- tokenize_line(line)
+ tokenize_line(line, lower=lower)
for line in translation_lines
]
diff --git a/bugs2fix.ipynb b/bugs2fix.ipynb
index ffbf170..6e0420b 100644
--- a/bugs2fix.ipynb
+++ b/bugs2fix.ipynb
@@ -11,19 +11,26 @@
{
"cell_type": "code",
"execution_count": 1,
- "id": "9425fe51-d422-4569-b1c9-50be7296ca3c",
+ "id": "96dcb753-0341-472e-b082-eca3db8dcc4a",
"metadata": {},
"outputs": [],
"source": [
"import os\n",
+ "CASE_COUNT = 95\n",
+ "META_COUNT = None # number of trials per\n",
+ "BUGS2FIX_PROMPT_INDEX = 1\n",
"\n",
"BATTERY_DIR = \"./data/CodeXGLUE/Code-Code/code-refinement/data/small\"\n",
"BATTERY_SRC = os.path.join(BATTERY_DIR, \"test.buggy-fixed.buggy\")\n",
"TRUTH_SRC = os.path.join(BATTERY_DIR, \"test.buggy-fixed.fixed\")\n",
- "OUTPUT_DIR = \"./data/output/bugs2fix/\"\n",
- "CASE_COUNT = 95\n",
- "META_COUNT = 1 # number of trials per\n",
- "BUGS2FIX_PROMPT = \"// the buggy version of the code\\n{code}\\n// the fixed version of the code\\n\""
+ "OUTPUT_DIR = f\"./output/bugs2fix/prompt{BUGS2FIX_PROMPT_INDEX}\"\n",
+ "\n",
+ "BUGS2FIX_PROMPTS = [\n",
+ " \"// the buggy version of the code\\n{prompt}\\n// the fixed version of the code\\n\",\n",
+ " \"// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:\\n{prompt}\\n\",\n",
+ "]\n",
+ "\n",
+ "BUGS2FIX_PROMPT = BUGS2FIX_PROMPTS[BUGS2FIX_PROMPT_INDEX]"
]
},
{
@@ -44,8 +51,12 @@
"os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
"BATTERY = []\n",
"with open(BATTERY_SRC, \"r\") as battery:\n",
- " BATTERY = battery.readlines()[:CASE_COUNT]\n",
- "print(f\"Loaded {CASE_COUNT} cases!\")"
+ " BATTERY = [\n",
+ " line.strip()\n",
+ " for line\n",
+ " in battery.readlines()[:CASE_COUNT]\n",
+ " ]\n",
+ "print(f\"Loaded {len(BATTERY)} cases!\")"
]
},
{
@@ -55,13 +66,10 @@
"metadata": {},
"outputs": [],
"source": [
- "from timehelp import with_progress\n",
+ "from timehelp import with_progress, display_header\n",
"import time\n",
"import ipywidgets as widgets\n",
- "from IPython.display import display\n",
- "def display_header(text):\n",
- " header = widgets.HTML(value=f\"
{text}
\")\n",
- " display(header)"
+ "from IPython.display import display"
]
},
{
@@ -111,7 +119,7 @@
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "3d420a5ff8e8462fbb3139986dfd8448",
+ "model_id": "544ba5e583e040408f4dca36aa79219d",
"version_major": 2,
"version_minor": 0
},
@@ -126,21 +134,22 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-17@04:13:14|model.device] Starting timer.\n",
+ "# Loading 350M (Salesforce/codegen-350M-multi)\n",
+ "[2024-05-21@07:59:05|model.device] Starting timer.\n",
"Configuring torch device...\n",
"Using device: cuda:0 aka cuda:0\n",
- "[2024-05-17@04:13:14|model.device] Time elapsed: 42ms\n",
- "[2024-05-17@04:13:14|model.tokenizer] Starting timer.\n",
- "[2024-05-17@04:13:14|model.tokenizer] Time elapsed: 235ms\n",
- "[2024-05-17@04:13:14|model.model] Starting timer.\n",
+ "[2024-05-21@07:59:05|model.device] Time elapsed: 63ms\n",
+ "[2024-05-21@07:59:05|model.tokenizer] Starting timer.\n",
+ "[2024-05-21@07:59:05|model.tokenizer] Time elapsed: 242ms\n",
+ "[2024-05-21@07:59:05|model.model] Starting timer.\n",
"Obtaining model...\n",
- "[2024-05-17@04:13:18|model.model] Time elapsed: 3s 322ms\n"
+ "[2024-05-21@07:59:08|model.model] Time elapsed: 3s 447ms\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "d8c6fe753b5c4336ac105f62c31e6379",
+ "model_id": "e47e6fdd1db7482989b9c9f4f8e27188",
"version_major": 2,
"version_minor": 0
},
@@ -151,10 +160,17 @@
"metadata": {},
"output_type": "display_data"
},
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Done, ~0s elapsed.\n"
+ ]
+ },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "580c71499e75468cbeadf3aaee253a5c",
+ "model_id": "7486201976d1464db572accb21f6e446",
"version_major": 2,
"version_minor": 0
},
@@ -169,21 +185,22 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-17@04:18:17|model.device] Starting timer.\n",
+ "# Loading 2B (Salesforce/codegen-2B-multi)\n",
+ "[2024-05-21@07:59:09|model.device] Starting timer.\n",
"Configuring torch device...\n",
"Using device: cuda:0 aka cuda:0\n",
- "[2024-05-17@04:18:17|model.device] Time elapsed: ~0s\n",
- "[2024-05-17@04:18:17|model.tokenizer] Starting timer.\n",
- "[2024-05-17@04:18:17|model.tokenizer] Time elapsed: 199ms\n",
- "[2024-05-17@04:18:17|model.model] Starting timer.\n",
+ "[2024-05-21@07:59:09|model.device] Time elapsed: ~0s\n",
+ "[2024-05-21@07:59:09|model.tokenizer] Starting timer.\n",
+ "[2024-05-21@07:59:09|model.tokenizer] Time elapsed: 286ms\n",
+ "[2024-05-21@07:59:09|model.model] Starting timer.\n",
"Obtaining model...\n",
- "[2024-05-17@04:18:25|model.model] Time elapsed: 8s 455ms\n"
+ "[2024-05-21@07:59:18|model.model] Time elapsed: 8s 712ms\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "063490193a854b59b3d09c28ba1f29f6",
+ "model_id": "9744f5525fe04c4793d9929b1a84a716",
"version_major": 2,
"version_minor": 0
},
@@ -198,18 +215,13 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "!! max size might be exceeded !!\n",
- "inputs so far: // the buggy version of the code\n",
- "public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 [ ( ( VAR_1. position ) + 1 ) ] = isEmpty ( ) ; VAR_1. position += 1 ; VAR_3 = METHOD_2 ( VAR_1. position ) ; return VAR_1 ; }\n",
- "// the fixed version of the code\n",
- "public TYPE_1 METHOD_1 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { VAR_3 = METHOD_2 ( VAR_1. position ) ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += [ ... 2022 bytes abbreviated ... ] += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V\n",
- "next outputs: position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V\n"
+ "Done, ~0s elapsed.\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "559535046d5849dc847eb34cae8f2c11",
+ "model_id": "790fbb9223da4d0db9b05a3de854a91a",
"version_major": 2,
"version_minor": 0
},
@@ -224,13 +236,14 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-17@04:27:07|model.device] Starting timer.\n",
+ "# Loading 6B (Salesforce/codegen-6B-multi)\n",
+ "[2024-05-21@07:59:18|model.device] Starting timer.\n",
"Configuring torch device...\n",
"Using device: cuda:0 aka cuda:0\n",
- "[2024-05-17@04:27:07|model.device] Time elapsed: ~0s\n",
- "[2024-05-17@04:27:07|model.tokenizer] Starting timer.\n",
- "[2024-05-17@04:27:07|model.tokenizer] Time elapsed: 230ms\n",
- "[2024-05-17@04:27:07|model.model] Starting timer.\n",
+ "[2024-05-21@07:59:18|model.device] Time elapsed: ~0s\n",
+ "[2024-05-21@07:59:18|model.tokenizer] Starting timer.\n",
+ "[2024-05-21@07:59:18|model.tokenizer] Time elapsed: 192ms\n",
+ "[2024-05-21@07:59:18|model.model] Starting timer.\n",
"Obtaining model...\n"
]
},
@@ -245,13 +258,13 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-17@04:27:26|model.model] Time elapsed: 19s 421ms\n"
+ "[2024-05-21@07:59:38|model.model] Time elapsed: 19s 528ms\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "b640c24103834636a906300a4221cded",
+ "model_id": "f45c85bf5fff4b37a20877ec26d3f4c7",
"version_major": 2,
"version_minor": 0
},
@@ -262,10 +275,27 @@
"metadata": {},
"output_type": "display_data"
},
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "!! max size might be exceeded !!\n",
+ "inputs so far: // You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:\n",
+ "public boolean METHOD_1 ( TYPE_1 VAR_1, java.util.Map < TYPE_2, java.util.List < TYPE_1 > > VAR_2, java.util.List < TYPE_3 > VAR_3, TYPE_4 VAR_4, boolean VAR_5 ) { return true ; }\n",
+ "\n",
+ "public boolean METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2, TYPE_3 VAR_3, TYPE_4 VAR_4, TYPE_5 VA [ ... 501 bytes abbreviated ... ] VAR_37, TYPE_38 VAR_38, TYPE_39 VAR_39, TYPE_40 VAR_40, TYPE_41 VAR_41, TYPE_42 VAR_42, TYPE_43 VAR_\n",
+ "!! max size might be exceeded !!\n",
+ "inputs so far: // You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:\n",
+ "public void METHOD_1 ( java.lang.String url, TYPE_1 VAR_1, TYPE_2 VAR_2, TYPE_3 status ) { VAR_3. id ( VAR_1 ). METHOD_2 ( TYPE_4. METHOD_3 ( TYPE_4. METHOD_4 ( VAR_2 ) ) ). METHOD_5 ( VAR_4 ) ; }\n",
+ "\n",
+ "public void METHOD_2 ( TYPE_5 VAR_1 ) { VAR_1. METHOD_1 ( TYPE_6. METHOD_1 [ ... 597 bytes abbreviated ... ] ( TYPE_37. METHOD_1 ( TYPE_38. METHOD_1 ( TYPE_39. METHOD_1 ( TYPE_40. METHOD_1 ( TYPE_41. METHOD_1\n",
+ "Done, 51min 34s elapsed.\n"
+ ]
+ },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "f0bdcbf2e8eb47b7a3f97f1537335fb6",
+ "model_id": "9afcc8e3b16f4071a7b8ee950dae3ab9",
"version_major": 2,
"version_minor": 0
},
@@ -280,13 +310,14 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-17@06:04:15|model.device] Starting timer.\n",
+ "# Loading 16B (Salesforce/codegen-16B-multi)\n",
+ "[2024-05-21@08:51:13|model.device] Starting timer.\n",
"Configuring torch device...\n",
"Using device: cuda:0 aka cuda:0\n",
- "[2024-05-17@06:04:15|model.device] Time elapsed: ~0s\n",
- "[2024-05-17@06:04:15|model.tokenizer] Starting timer.\n",
- "[2024-05-17@06:04:16|model.tokenizer] Time elapsed: 238ms\n",
- "[2024-05-17@06:04:16|model.model] Starting timer.\n",
+ "[2024-05-21@08:51:13|model.device] Time elapsed: ~0s\n",
+ "[2024-05-21@08:51:13|model.tokenizer] Starting timer.\n",
+ "[2024-05-21@08:51:13|model.tokenizer] Time elapsed: 309ms\n",
+ "[2024-05-21@08:51:13|model.model] Starting timer.\n",
"Obtaining model...\n"
]
},
@@ -301,13 +332,13 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-17@06:07:30|model.model] Time elapsed: 3min 13s\n"
+ "[2024-05-21@08:54:27|model.model] Time elapsed: 3min 14s\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
- "model_id": "6846f0093c1d42cbaa6fff1fdc2ec808",
+ "model_id": "d50b96203c394b178297e4d76a8f510f",
"version_major": 2,
"version_minor": 0
},
@@ -317,36 +348,28 @@
},
"metadata": {},
"output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "!! max size might be exceeded !!\n",
+ "inputs so far: // You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:\n",
+ "private static TYPE_1 METHOD_1 ( int n ) { TYPE_1 VAR_1 = VAR_2 ; for ( int i = n ; i > 1 ; i -- ) { VAR_1 = VAR_1. METHOD_2 ( new TYPE_1 ( java.lang.Integer.toString ( i ) ) ) ; } return VAR_1 ; }\n",
+ "private static TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_1 VAR_2 = VAR_1 ; f [ ... 535 bytes abbreviated ... ] 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ).\n",
+ "Done, 8hr 52min 19s elapsed.\n"
+ ]
}
],
"source": [
- "for key, model_name in ModelFamily.CodeGen1.multi.items():\n",
- " display_header(f\"Loading {key} ({model_name})\")\n",
- " torch.cuda.empty_cache()\n",
- " model = Model(model_name)\n",
- " model.configure(time=True)\n",
- " model.verbose = False\n",
- " \n",
- " @with_progress(len(BATTERY))\n",
- " def iterate(output_file, *, step=None):\n",
- " buggy = BATTERY[step]\n",
- " specific_prompt = BUGS2FIX_PROMPT.format(code=buggy.strip())\n",
- " output = model.generate_until(specific_prompt, stops=[\"\\n\"])\n",
- " decoded = model.decode(output)\n",
- " output_file.write(decoded + \"\\n\")\n",
- "\n",
- " del model.inputs, output\n",
- "\n",
- " for i in range(META_COUNT):\n",
- " if META_COUNT == 1:\n",
- " base_name = f\"codegen1-multi-{key}.output\"\n",
- " else:\n",
- " base_name = f\"codegen1-multi-{key}-{i}.output\"\n",
- " output_path = os.path.join(OUTPUT_DIR, base_name)\n",
- " with open(output_path, \"w\") as output_file:\n",
- " iterate(output_file)\n",
- " \n",
- " model.free()"
+ "Model.test_battery(\n",
+ " family=ModelFamily.CodeGen1.multi,\n",
+ " family_name=\"codegen1-multi\",\n",
+ " battery=BATTERY,\n",
+ " prompt=BUGS2FIX_PROMPT,\n",
+ " meta_count=META_COUNT,\n",
+ " output_dir=OUTPUT_DIR,\n",
+ ")"
]
},
{
@@ -359,7 +382,7 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 5,
"id": "ea737c59-fff7-4083-804c-5b6afa5e1ae8",
"metadata": {},
"outputs": [],
@@ -370,20 +393,24 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 6,
"id": "57ccd100-c1f6-4311-b812-db06bf946615",
"metadata": {},
"outputs": [],
"source": [
"with open(TRUTH_SRC, \"r\") as truth_file:\n",
- " answer_key = truth_file.readlines()[:CASE_COUNT]\n",
+ " answer_key = truth_file.readlines()\n",
"\n",
- "family_answers = {}\n",
- "for key, model_name in ModelFamily.CodeGen1.multi.items():\n",
- " output_path = os.path.join(OUTPUT_DIR, f\"codegen1-multi-{key}.output\")\n",
- " with open(output_path, \"r\") as output_file:\n",
- " answers = output_file.readlines()\n",
- " family_answers[key] = answers"
+ "prompt_family_answers = []\n",
+ "for prompt_index in range(len(BUGS2FIX_PROMPTS)):\n",
+ " output_dir = f\"./data/output/bugs2fix/prompt{prompt_index}\"\n",
+ " family_answers = {}\n",
+ " for key, model_name in ModelFamily.CodeGen1.multi.items():\n",
+ " output_path = os.path.join(output_dir, f\"codegen1-multi-{key}.output\")\n",
+ " with open(output_path, \"r\") as output_file:\n",
+ " answers = output_file.readlines()\n",
+ " family_answers[key] = answers\n",
+ " prompt_family_answers.append(family_answers)"
]
},
{
@@ -396,29 +423,33 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 7,
"id": "ceca2e5f-2cf1-409f-a3b3-0eed0811ead6",
"metadata": {},
"outputs": [],
"source": [
- "accuracy_em_metric = []\n",
- "for key, answers in family_answers.items():\n",
- " correct = 0\n",
- " for answer, truth in zip(answers, answer_key):\n",
- " if answer.strip() == truth.strip():\n",
- " correct += 1\n",
- " accuracy_em_metric.append(correct)"
+ "accuracy_em_metric = {}\n",
+ "\n",
+ "for idx, family_answers in enumerate(prompt_family_answers):\n",
+ " metric_series = []\n",
+ " for key, answers in family_answers.items():\n",
+ " correct = 0\n",
+ " for answer, truth in zip(answers, answer_key):\n",
+ " if answer.strip() == truth.strip():\n",
+ " correct += 1\n",
+ " metric_series.append(correct)\n",
+ " accuracy_em_metric[f\"prompt{idx}\"] = metric_series"
]
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 8,
"id": "d04208ed-600c-40a5-9574-1c18e5cb321c",
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
""
]
@@ -446,27 +477,30 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 9,
"id": "db35e9e2-4d64-4371-a55b-baf0b032f265",
"metadata": {},
"outputs": [],
"source": [
"from bleu import _bleu\n",
- "bleu_metrics = []\n",
- "bleu_baseline = _bleu(answer_key, BATTERY)\n",
- "for key, answers in family_answers.items():\n",
- " bleu_metrics.append(_bleu(answer_key, answers))"
+ "bleu_metrics = {}\n",
+ "bleu_baseline = 0.0 # _bleu(answer_key[:len(BATTERY)], BATTERY)\n",
+ "for idx, family_answers in enumerate(prompt_family_answers):\n",
+ " metric_series = []\n",
+ " for key, answers in family_answers.items():\n",
+ " metric_series.append(_bleu(answer_key[:len(answers)], answers))\n",
+ " bleu_metrics[f\"prompt{idx}\"] = metric_series"
]
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 10,
"id": "febd5f59-0989-46b1-8763-ec72e848e184",
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAIjCAYAAADxz9EgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7x0lEQVR4nO3dd3hUVf7H8c+kTHqBNFogdFDpTVAEFY2CiAu7KqgUFV0VBVFX8SfVvipihbUALmtb17IqiIsIiIrSRECpSugktBTSZpK5vz+uGRhSSOBOJhPer+eZJ7l3zr3znUNI8sk591ybYRiGAAAAAACWCPB1AQAAAABQmxCyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAANXCZrNpypQpVT4uLS1NNptNc+fOtbymMzFv3jy1adNGwcHBio2N9XU5AIAahJAFAGeRuXPnymazyWaz6dtvvy31vGEYSk5Ols1m01VXXeWDCk/f0qVL3e/NZrMpODhYzZo10/Dhw/X7779b+lqbN2/WyJEj1bx5c73++ut67bXXLD0/AMC/Bfm6AABA9QsNDdU777yjCy+80GP/smXLtGfPHoWEhPiosjN3zz33qFu3bnI6nVq7dq1ee+01zZ8/Xxs2bFCDBg0seY2lS5fK5XLphRdeUIsWLSw5JwCg9mAkCwDOQv3799cHH3ygoqIij/3vvPOOunTponr16vmosjPXu3dv3XjjjRo1apReeuklPfvsszpy5IjeeuutMz53bm6uJCkjI0OSLJ0mmJeXZ9m5AAC+RcgCgLPQ0KFDdfjwYS1atMi9z+Fw6D//+Y+GDRtW5jG5ubm67777lJycrJCQELVu3VrPPvusDMPwaFdYWKh7771XCQkJioqK0tVXX609e/aUec69e/fq5ptvVlJSkkJCQnTuuedq9uzZ1r1RSZdccokkaceOHe59X3zxhXr37q2IiAhFRUVpwIAB+uWXXzyOGzlypCIjI/Xbb7+pf//+ioqK0g033KCUlBRNnjxZkpSQkFDqWrNXX31V5557rkJCQtSgQQPdddddyszM9Dh33759dd5552nNmjW66KKLFB4erocffth9/dmzzz6rV155Rc2aNVN4eLguv/xy7d69W4Zh6NFHH1WjRo0UFhamQYMG6ciRIx7n/u9//6sBAwaoQYMGCgkJUfPmzfXoo4+quLi4zBp+/fVXXXzxxQoPD1fDhg3197//vVQfFhQUaMqUKWrVqpVCQ0NVv359DR48WL/99pu7jcvl0owZM3TuuecqNDRUSUlJuv3223X06NHK/2MBQC3BdEEAOAulpKSoZ8+eevfdd3XllVdKMoNHVlaWrr/+er344ose7Q3D0NVXX60lS5bolltuUceOHfXll1/qgQce0N69e/X888+72956663617/+pWHDhqlXr176+uuvNWDAgFI1pKen6/zzz5fNZtOYMWOUkJCgL774Qrfccouys7M1btw4S95rSRCIi4uTZC5YMWLECKWmpurpp59WXl6eZs6cqQsvvFA//fSTUlJS3McWFRUpNTVVF154oZ599lmFh4dr5MiR+uc//6mPP/5YM2fOVGRkpNq3by9JmjJliqZOnap+/frpjjvu0JYtWzRz5kytWrVK3333nYKDg93nPnz4sK688kpdf/31uvHGG5WUlOR+7u2335bD4dDdd9+tI0eO6O9//7uuvfZaXXLJJVq6dKkefPBBbd++XS+99JLuv/9+j2A6d+5cRUZGavz48YqMjNTXX3+tSZMmKTs7W88884xH3xw9elRXXHGFBg8erGuvvVb/+c9/9OCDD6pdu3bur4vi4mJdddVVWrx4sa6//nqNHTtWOTk5WrRokTZu3KjmzZtLkm6//XbNnTtXo0aN0j333KMdO3bo5Zdf1k8//VTqvQNArWcAAM4ac+bMMSQZq1atMl5++WUjKirKyMvLMwzDMP7yl78YF198sWEYhtGkSRNjwIAB7uM++eQTQ5Lx2GOPeZzvz3/+s2Gz2Yzt27cbhmEY69atMyQZd955p0e7YcOGGZKMyZMnu/fdcsstRv369Y1Dhw55tL3++uuNmJgYd107duwwJBlz5syp8L0tWbLEkGTMnj3bOHjwoLFv3z5j/vz5RkpKimGz2YxVq1YZOTk5RmxsrDF69GiPYw8cOGDExMR47B8xYoQhyXjooYdKvdbkyZMNScbBgwfd+zIyMgy73W5cfvnlRnFxsXv/yy+/7K6rRJ8+fQxJxqxZszzOW/JeExISjMzMTPf+CRMmGJKMDh06GE6n071/6NChht1uNwoKCtz7SvrtRLfffrsRHh7u0a6khn/+85/ufYWFhUa9evWMIUOGuPfNnj3bkGRMnz691HldLpdhGIaxfPlyQ5Lx9ttvezy/cOHCMvcDQG3HdEEAOEtde+21ys/P1+eff66cnBx9/vnn5U4VXLBggQIDA3XPPfd47L/vvvtkGIa++OILdztJpdqdPCplGIY+/PBDDRw4UIZh6NChQ+5HamqqsrKytHbt2tN6XzfffLMSEhLUoEEDDRgwQLm5uXrrrbfUtWtXLVq0SJmZmRo6dKjHawYGBqpHjx5asmRJqfPdcccdlXrdr776Sg6HQ+PGjVNAwPEfr6NHj1Z0dLTmz5/v0T4kJESjRo0q81x/+ctfFBMT497u0aOHJOnGG29UUFCQx36Hw6G9e/e694WFhbk/z8nJ0aFDh9S7d2/l5eVp8+bNHq8TGRmpG2+80b1tt9vVvXt3j9UYP/zwQ8XHx+vuu+8uVafNZpMkffDBB4qJidFll13m0a9dunRRZGRkmf0KALUZ0wUB4CyVkJCgfv366Z133lFeXp6Ki4v15z//ucy2O3fuVIMGDRQVFeWxv23btu7nSz4GBAS4p5CVaN26tcf2wYMHlZmZqddee63c5c9LFpeoqkmTJql3794KDAxUfHy82rZt6w4m27Ztk3T8Oq2TRUdHe2wHBQWpUaNGlXrdkj44+b3a7XY1a9bM/XyJhg0bym63l3muxo0be2yXBK7k5OQy95943dMvv/yiRx55RF9//bWys7M92mdlZXlsN2rUyB2UStSpU0fr1693b//2229q3bq1R7g72bZt25SVlaXExMQynz/df0sA8FeELAA4iw0bNkyjR4/WgQMHdOWVV1bbTXVdLpckc2RmxIgRZbYpuc6pqtq1a6d+/fpV+Lrz5s0rcwXFk4NESEiIx6iUlU4ccTpZYGBglfYbfyw+kpmZqT59+ig6OlrTpk1T8+bNFRoaqrVr1+rBBx90v//Knq+yXC6XEhMT9fbbb5f5fEJCQpXOBwD+jpAFAGexP/3pT7r99tv1ww8/6P333y+3XZMmTfTVV18pJyfHYzSrZPpZkyZN3B9dLpd79KPEli1bPM5XsvJgcXFxuYHIG0pG2BITEy1/3ZI+2LJli5o1a+be73A4tGPHjmp5n0uXLtXhw4f10Ucf6aKLLnLvP3Flxapq3ry5fvzxRzmdznIXr2jevLm++uorXXDBBRWGRwA4W3BNFgCcxSIjIzVz5kxNmTJFAwcOLLdd//79VVxcrJdfftlj//PPPy+bzeZeia7k48mrE86YMcNjOzAwUEOGDNGHH36ojRs3lnq9gwcPns7bOaXU1FRFR0friSeekNPptPR1+/XrJ7vdrhdffNFjJOjNN99UVlZWmSssWq1kZOrE13c4HHr11VdP+5xDhgzRoUOHSv3bn/g61157rYqLi/Xoo4+WalNUVFRqCXsAqO0YyQKAs1x50/VONHDgQF188cX6v//7P6WlpalDhw763//+p//+978aN26ce4SoY8eOGjp0qF599VVlZWWpV69eWrx4sbZv317qnE899ZSWLFmiHj16aPTo0TrnnHN05MgRrV27Vl999VWp+z9ZITo6WjNnztRNN92kzp076/rrr1dCQoJ27dql+fPn64ILLigzTFRGQkKCJkyYoKlTp+qKK67Q1VdfrS1btujVV19Vt27dPBaY8JZevXqpTp06GjFihO655x7ZbDbNmzevytP/TjR8+HD985//1Pjx47Vy5Ur17t1bubm5+uqrr3TnnXdq0KBB6tOnj26//XY9+eSTWrdunS6//HIFBwdr27Zt+uCDD/TCCy+Ue70fANRGhCwAwCkFBATo008/1aRJk/T+++9rzpw5SklJ0TPPPKP77rvPo+3s2bOVkJCgt99+W5988okuueQSzZ8/v9SiDUlJSVq5cqWmTZumjz76SK+++qri4uJ07rnn6umnn/baexk2bJgaNGigp556Ss8884wKCwvVsGFD9e7du9zV/iprypQpSkhI0Msvv6x7771XdevW1W233aYnnniiWu4TFRcXp88//1z33XefHnnkEdWpU0c33nijLr30UqWmpp7WOQMDA7VgwQI9/vjjeuedd/Thhx8qLi5OF154odq1a+duN2vWLHXp0kX/+Mc/9PDDDysoKEgpKSm68cYbdcEFF1j1FgHAL9iMM/nzFgAAAADAA9dkAQAAAICFCFkAAAAAYCFCFgAAAABYyG9C1jfffKOBAweqQYMGstls+uSTT055zNKlS9W5c2eFhISoRYsWmjt3rtfrBAAAAHB285uQlZubqw4dOuiVV16pVPsdO3ZowIABuvjii7Vu3TqNGzdOt956q7788ksvVwoAAADgbOaXqwvabDZ9/PHHuuaaa8pt8+CDD2r+/PkeN7m8/vrrlZmZqYULF1ZDlQAAAADORrX2PlkrVqxQv379PPalpqZq3Lhx5R5TWFiowsJC97bL5dKRI0cUFxcnm83mrVIBAAAA1HCGYSgnJ0cNGjRQQEDFEwJrbcg6cOCAkpKSPPYlJSUpOztb+fn5CgsLK3XMk08+qalTp1ZXiQAAAAD8zO7du9WoUaMK29TakHU6JkyYoPHjx7u3s7Ky1LhxY+3YsUNRUVE+rOzUnE6nlixZoosvvljBwcG+LqdWoW+9g371DvrVO+hX76BfvYN+9Q761Tv8qV9zcnLUtGnTSuWCWhuy6tWrp/T0dI996enpio6OLnMUS5JCQkIUEhJSan/dunUVHR3tlTqt4nQ6FR4erri4uBr/Bepv6FvvoF+9g371DvrVO+hX76BfvYN+9Q5/6teS+ipzGZHfrC5YVT179tTixYs99i1atEg9e/b0UUUAAAAAzgZ+E7KOHTumdevWad26dZLMJdrXrVunXbt2STKn+g0fPtzd/q9//at+//13/e1vf9PmzZv16quv6t///rfuvfdeX5QPAAAA4CzhNyFr9erV6tSpkzp16iRJGj9+vDp16qRJkyZJkvbv3+8OXJLUtGlTzZ8/X4sWLVKHDh303HPP6Y033lBqaqpP6gcAAABwdvCba7L69u2rim7pNXfu3DKP+emnn7xYFQAAAFAxwzBUVFSk4uJiX5dS4zidTgUFBamgoKBG9E9wcLACAwPP+Dx+E7IAAAAAf+NwOLR//37l5eX5upQayTAM1atXT7t3764R96W12Wxq1KiRIiMjz+g8hCwAAADAC1wul3bs2KHAwEA1aNBAdru9RgSJmsTlcunYsWOKjIw85Q1+vc0wDB08eFB79uxRy5Ytz2hEi5AFAAAAeIHD4ZDL5VJycrLCw8N9XU6N5HK55HA4FBoa6vOQJUkJCQlKS0uT0+k8o5Dl+3cCAAAA1GI1ITygcqwaaWQkCwAAAKjB0tKkpUulrCwpJkbq21dKSfFtTagYIQsAAACogVatkqZOlRYskE5cZNtmk/r3lyZPlrp18119KB9jlwAAAEAN89FH0oUXSvPnewYsydyeP998/qOPfFMfKkbIAgAAAGqQVaukoUMlh8PcTk42R63eftv82KiRud/hMNutWuW7WmuKKVOmqGPHjqX2FxQU6K677lJcXJwiIyM1ZMgQpaene70eQhYAAABQg0ydejxgDR8ubd8uTZkiDRtmfvztN+mmm8znHQ5p2jRfVXqco6TgGubee+/VZ599pg8++EDLli3Tvn37NHjwYK+/LiELAAAAqAaGIeXmVvz49VfzGizJHLGaMUNyOj3bOJ3SCy9IDRua7ebPlzZtqvi8J085PJW+fftqzJgxGjNmjGJiYhQfH6+JEyfK+ONEKSkpevTRRzV8+HBFR0frtttukyR9+OGHOvfccxUSEqKUlBQ999xzHudNSUnRY489puHDhysyMlJNmzbVggULdPDgQQ0aNEiRkZFq3769Vq9e7T5m7ty5io2N1SeffKKWLVsqNDRUqamp2r17t/v5qVOn6ueff5bNZpPNZtPcuXOVlZWlN998U9OnT9cll1yiLl26aM6cOfr+++/1ww8/VP0fsAoIWQAAAEA1yMuTIiMrfpx77vFAtGePVLdu2e3q1pX27jXbGYZ0zjkVnzcvr+r1vvXWWwoKCtLKlSv1wgsvaPr06XrjjTfczz/77LPq0KGDfvrpJ02cOFFr1qzRtddeq+uvv14bNmzQlClTNHHiRM2dO9fjvM8//7wuuOAC/fTTT+rfv7/++te/asSIEbrxxhu1du1aNW/eXMOHD3cHOrPv8vT444/rn//8p7777jtlZmbq+uuvlyRdd911uu+++3Tuuedq//792r9/v6677jqtWbNGTqdT/fr1c5+nTZs2aty4sVasWFH1DqkCVhcEAAAAUEpycrKef/552Ww2tW7dWhs2bNDzzz+v0aNHS5IuueQS3Xfffe72N9xwgy699FJNnDhRktSqVSv9+uuveuaZZzRy5Eh3u/79++v222+XJE2cOFGzZs1St27d9Je//EWS9OCDD6pnz55KT09XvXr1JElOp1Mvv/yyevToIckMgG3bttXKlSvVvXt3RUZGKigoyN1ekg4cOCC73a7Y2FiP95WUlKQDBw5Y21knYSQLAAAAqAbh4dKxYxU/Zs063n7ChIrbPvTQ8bb/+EfFbcPDq17v+eef73Fz3p49e2rbtm0qLi6WJHXt2tWj/aZNm3TBBRd47Lvgggs8jpGk9u3buz9PSkqSJJ133nml9mVkZLj3BQUFqdsJ69W3adNGsbGx2rRpU9XfWDVgJAsAAACoBjabFBFRcZvUVLOdYUj/+pe50IXdXrqdw2E+X3Le1NRTn9tqEaf5gsHBwe7PS0JcWftcLtcZVCfVq1dPDodDmZmZHqNZJ46QeQsjWQAAAEANkZJi3mhYknbvlm699fhKgyUcDnP/nj3m9oABUpMm1tfy448/emz/8MMPatmypQIDA8ts37ZtW3333Xce+7777ju1atWq3GMqq6ioyGMxjC1btigzM1Nt27aVJNntdo/RMknq0qWLgoODtXjxYo/jdu3apZ49e55RPafCSBYAAABQg0yeLC1aZIapefOkJUukm2+WWrWStm6VZs8+HrDsdmnSJO/UsWvXLo0fP16333671q5dq5deeqnUaoEnuu+++9StWzc9+uijuu6667RixQq9/PLLevXVV8+4luDgYN1999168cUXFRQUpDFjxuj8889X9+7dJZmrFu7YsUPr1q1To0aNFBUVpZiYGN1yyy0aP3686tatq+joaN19993q2bOnzj///DOuqSKELAAAAKAG6dZNevfd4zck3rOn7Hth2e1muxMuVbLU8OHDlZ+fr+7duyswMFBjx451L9Vels6dO+vf//63Jk2apEcffVT169fXtGnTPBa9OF3h4eF68MEHNWzYMO3du1e9e/fWm2++6X5+yJAh+uijj3TxxRcrMzNTc+bM0ciRI/X8888rICBAQ4YMUWFhoVJTUy0JfadCyAIAAABqmMGDpW+/NcPV/Pme97my2cwpgpMmeS9gSebo0YwZMzRz5sxSz6WlpZV5zJAhQzRkyJByz1nWcUePHlV0dLR7OyUlxWP59hKDBw8u90bCISEh+s9//lNqf2hoqF555RW98sor5dbkDYQsAAAAoAbq1k367DMpLU1atkzKypJiYqS+fb1zDRasQ8gCAAAAarCUFPMB/0HIAgAAAOBh6dKlvi7BbeTIkZZc11WdWMIdAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBALXwAAAAA1WFpmmpamLVVWQZZiQmPUN6WvUmJTfF0WKkDIAgAAAGqgVXtXaeqyqVqwbYEMHb85r0029W/ZX5P7TFa3hl68GzFOG9MFAQAAgBrmo00f6cI5F2r+tvkeAUuSDBmav22+LpxzoT7a9JGPKkRFCFkAAABADbJq7yoN/XCoHMUOSVJydLIm95mstwe/rcl9JqtRdCNJkqPYoaEfDtWqvat8WW6NMGXKFHXs2LHU/tdee019+/ZVdHS0bDabMjMzq6UeQhYAAABQg0xdNtUdsIZ3GK7t92zXlL5TNKzdME3pO0W/3fObbmp/kyQzaE37ZpovyzXrcDh8XUKZ8vLydMUVV+jhhx+u1tclZAEAAADVwDAM5TpyK3z8mvGrFmxbIElqFN1IM1JnyFns9GjjLHbqhSteUMOohpKk+Vvna9PBTRWe1zCMikorpW/fvhozZozGjBmjmJgYxcfHa+LEie7zpKSk6NFHH9Xw4cMVHR2t2267TZL04Ycf6txzz1VISIhSUlL03HPPeZw3JSVFjz32mIYPH67IyEg1bdpUCxYs0MGDBzVo0CBFRkaqffv2Wr16tfuYuXPnKjY2Vp988olatmyp0NBQpaamavfu3e7np06dqp9//lk2m002m01z586VJI0bN04PPfSQzj///Kr/g50BFr4AAAAAqkGeM0+RT0ZWuv2e7D2q+/e6p2xnyNA5r55TYZtjE44pwh5R6deWpLfeeku33HKLVq5cqdWrV+u2225T48aNNXr0aEnSs88+q0mTJmny5MmSpDVr1ujaa6/VlClTdN111+n777/XnXfeqbi4OI0cOdJ93ueff15PPPGEJk6cqOnTp+uvf/2revXqpVtuuUXPPPOMHnzwQQ0fPly//PKLbDabJHNE6vHHH9c///lP2e123Xnnnbr++uv13Xff6brrrtPGjRu1cOFCffXVV5KkmJiYKr1XqxGyAAAAAJSSnJys559/XjabTa1bt9aGDRv0/PPPu0PWJZdcovvuu8/d/oYbbtCll16qiRMnSpJatWqlX3/9Vc8884xHyOrfv79uv/12SdLEiRM1a9YsdevWTX/5y18kSQ8++KB69uyp9PR01atXT5LkdDr18ssvq0ePHpLMANi2bVutXLlS3bt3V2RkpIKCgtztfY2QBQAAAFSD8OBwHZtwrMI2/1r/L/11/l8lSRMunKD/6/1/5bZ97JvH9NR3T0mS/jHgH7qh/Q0VvnZVnX/++e6RJEnq2bOnnnvuORUXF0uSunbt6tF+06ZNGjRokMe+Cy64QDNmzFBxcbECAwMlSe3bt3c/n5SUJEk677zzSu3LyMhwh6agoCB163Z8ufo2bdooNjZWmzZtUvfu3av83ryNkAUAAABUA5vNdsope6ktUmWTTYYM/Wv9vzSl7xTZA+2l2jmKHfrXhn+Z55VNqS1Sqzwd8ExFRJze6wUHB7s/LwlxZe1zuVxnUJ1vsfAFAAAAUEOkxKaof8v+kqTd2bt166e3ulcaLOEodujWT2/Vnuw9kqQBrQaoSWwTy2v58ccfPbZ/+OEHtWzZ0j0idbK2bdvqu+++89j33XffqVWrVuUeU1lFRUUei2Fs2bJFmZmZatu2rSTJbre7R9hqAkayAAAAgBpkcp/JWvT7IjmKHZq3fp6WpC3RzR1vVqu4Vtp6eKtmr5vtDlj2QLsmXTTJK3Xs2rVL48eP1+233661a9fqpZdeKrVa4Inuu+8+devWTY8++qiuu+46rVixQi+//LJeffXVM64lODhYd999t1588UUFBQVpzJgxOv/8891TBVNSUrRjxw6tW7dOjRo1UlRUlEJCQnTgwAEdOHBA27dvlyRt2LBBUVFRaty4serWPfWiIqeLkAUAAADUIN0adtO7Q95135B4T/aeMu+FZQ+0690h76pbw25lnOXMDR8+XPn5+erevbsCAwM1duxY91LtZencubP+/e9/a9KkSXr00UdVv359TZs2zWPRi9MVHh6uBx98UMOGDdPevXvVu3dvvfnmm+7nhwwZoo8++kgXX3yxMjMzNWfOHI0cOVKzZs3S1KlT3e0uuugiSXI/7y2ELAAAAKCGGdx2sL4d9a2mfTNN87fOl6Hj97myyaYBrQZo0kWTvBawJHP0aMaMGZo5c2ap59LS0so8ZsiQIRoyZEi55yzruKNHjyo6Otq9nZKSUuZ9vQYPHqzBgweXed6QkBD95z//KbV/ypQpmjJlSrn1eAshCwAAAKiBujXsps+Gfqa0zDQtS1umrMIsxYTEqG9KX69cgwXrELIAAACAGiwlNkUpHVN8XQaqgJAFAAAAwMPSpUt9XYLbyJEjvXr9lDewhDsAAAAAWIiQBQAAAHhRWYs4oGay6t+KkAUAAAB4QXBwsCQpLy/Px5WgshwO88bPZ3rzZK7JAgAAALwgMDBQsbGxysjIkGTe68lms/m4qprF5XLJ4XCooKBAAQG+Hf9xuVw6ePCgwsPDFRR0ZjGJkAUAAAB4Sb169STJHbTgyTAM5efnKywsrEYE0ICAADVu3PiMayFkAQAAAF5is9lUv359JSYmyul0+rqcGsfpdOqbb77RRRdd5J5e6Ut2u92SETVCFgAAAOBlgYGBZ3ydT20UGBiooqIihYaG1oiQZRUWvgAAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALOR3IeuVV15RSkqKQkND1aNHD61cubLC9jNmzFDr1q0VFham5ORk3XvvvSooKKimagEAAACcbfwqZL3//vsaP368Jk+erLVr16pDhw5KTU1VRkZGme3feecdPfTQQ5o8ebI2bdqkN998U++//74efvjhaq4cAAAAwNnCr0LW9OnTNXr0aI0aNUrnnHOOZs2apfDwcM2ePbvM9t9//70uuOACDRs2TCkpKbr88ss1dOjQU45+AQAAAMDpCvJ1AZXlcDi0Zs0aTZgwwb0vICBA/fr104oVK8o8plevXvrXv/6llStXqnv37vr999+1YMEC3XTTTWW2LywsVGFhoXs7OztbkuR0OuV0Oi18N9Yrqa+m1+mP6FvvoF+9g371DvrVO+hX76BfvYN+9Q5/6teq1GgzDMPwYi2W2bdvnxo2bKjvv/9ePXv2dO//29/+pmXLlunHH38s87gXX3xR999/vwzDUFFRkf76179q5syZZbadMmWKpk6dWmr/O++8o/DwcGveCAAAAAC/k5eXp2HDhikrK0vR0dEVtvWbkazTsXTpUj3xxBN69dVX1aNHD23fvl1jx47Vo48+qokTJ5ZqP2HCBI0fP969nZ2dreTkZF1++eWn7EhfczqdWrRokS677DIFBwf7upxahb71DvrVO+hX76BfvYN+9Q761TvoV+/wp34tmeVWGX4TsuLj4xUYGKj09HSP/enp6apXr16Zx0ycOFE33XSTbr31VklSu3btlJubq9tuu03/93//p4AAz0vSQkJCFBISUuo8wcHBNf4fvYQ/1epv6FvvoF+9g371DvrVO+hX76BfvYN+9Q5/6Neq1Oc3C1/Y7XZ16dJFixcvdu9zuVxavHixx/TBE+Xl5ZUKUoGBgZIkP5klCQAAAMDP+M1IliSNHz9eI0aMUNeuXdW9e3fNmDFDubm5GjVqlCRp+PDhatiwoZ588klJ0sCBAzV9+nR16tTJPV1w4sSJGjhwoDtsAQAAAICV/CpkXXfddTp48KAmTZqkAwcOqGPHjlq4cKGSkpIkSbt27fIYuXrkkUdks9n0yCOPaO/evUpISNDAgQP1+OOP++otAAAAAKjl/CpkSdKYMWM0ZsyYMp9bunSpx3ZQUJAmT56syZMnV0NlAAAAAOBH12QBAAAAgD8gZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICF/C5kvfLKK0pJSVFoaKh69OihlStXVtg+MzNTd911l+rXr6+QkBC1atVKCxYsqKZqAQAAAJxtgnxdQFW8//77Gj9+vGbNmqUePXpoxowZSk1N1ZYtW5SYmFiqvcPh0GWXXabExET95z//UcOGDbVz507FxsZWf/EAAAAAzgp+FbKmT5+u0aNHa9SoUZKkWbNmaf78+Zo9e7YeeuihUu1nz56tI0eO6Pvvv1dwcLAkKSUlpTpLBgAAAHCW8ZuQ5XA4tGbNGk2YMMG9LyAgQP369dOKFSvKPObTTz9Vz549ddddd+m///2vEhISNGzYMD344IMKDAws1b6wsFCFhYXu7ezsbEmS0+mU0+m0+B1Zq6S+ml6nP6JvvYN+9Q761TvoV++gX72DfvUO+tU7/Klfq1KjzTAMw4u1WGbfvn1q2LChvv/+e/Xs2dO9/29/+5uWLVumH3/8sdQxbdq0UVpamm644Qbdeeed2r59u+68807dc889mjx5cqn2U6ZM0dSpU0vtf+eddxQeHm7tGwIAAADgN/Ly8jRs2DBlZWUpOjq6wrZ+M5J1OlwulxITE/Xaa68pMDBQXbp00d69e/XMM8+UGbImTJig8ePHu7ezs7OVnJysyy+//JQd6WtOp1OLFi3SZZdd5p4aCWvQt95Bv3oH/eod9Kt30K/eQb96B/3qHf7UryWz3CrDb0JWfHy8AgMDlZ6e7rE/PT1d9erVK/OY+vXrKzg42GNqYNu2bXXgwAE5HA7Z7XaP9iEhIQoJCSl1nuDg4Br/j17Cn2r1N/Std9Cv3kG/egf96h30q3fQr95Bv3qHP/RrVerzmyXc7Xa7unTposWLF7v3uVwuLV682GP64IkuuOACbd++XS6Xy71v69atql+/fqmABQAAAABW8JuQJUnjx4/X66+/rrfeekubNm3SHXfcodzcXPdqg8OHD/dYGOOOO+7QkSNHNHbsWG3dulXz58/XE088obvuustXbwEAAABALec30wUl6brrrtPBgwc1adIkHThwQB07dtTChQuVlJQkSdq1a5cCAo7nxuTkZH355Ze699571b59ezVs2FBjx47Vgw8+6Ku3AAAAAKCW86uQJUljxozRmDFjynxu6dKlpfb17NlTP/zwg5erAgAAAACTX00XBAAAAICajpAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWMjvVhcEAAAAUDulpUlLl0pZWVJMjNS3r5SS4tuaTgchCwAAAIBPrV5t0+OPSwsWSIZxfL/NJvXvL02eLHXr5rv6qorpggAAAAB8ZsWK+urbN1Dz53sGLMncnj9fuvBC6aOPfFPf6WAkCwAAAIBPrF5t03PPdVFRkU2SlJws3Xyz1KqVtHWr9Oab0p49ksMhDR0qffutf4xoEbIAAAAA+MRjjwWoqMicXDd8uPT665Ldfvz5hx+Wbr1VmjfPDFrTpkmffeajYquA6YIAAAAAql1amvTFFyUjWIZHwCoqMj/a7dIbb0iNGpnb8+dLO3dWf61VxUgWAAAAgCrLy8vT8uXLdejQoVO2zcnJ0fr162UYksMRqtzcOtq06XwZxmV/nGu3WrTIUW5urI4dq6Pk5E26/PI33ccnJQ3Qnj0DZBjSqFFvqU2bH93PtW/fXlFRUaesIT4+Xr1791Z4ePhpvNuqIWQBAAAAqLLNmzfriiuuOGlvXUmNyng0l9Tnj89LB6LDhxvr8OHj27/9VqCZM2ee0CJL0gBJ0pIla7RkyUydjjVr1qhz586ndWxVELIAAAAAVMjlkg4eNBehKHns2NFOl1yyV/v3B+jIkXAdORIup7Ny8SI4OFeBgQ4VFNSRJNWps0XJySsVFpapqKijSkrKVHT0He72K1cO0Jo15ucXX9xFbdocf64qI1lt2rSpwrs+fYQsAAAA4CxWXCwdOOAZoE5+7N0rOZ0nHxksqUGp88XESPHxpR/16klNm0otWkgNGkQoMzNCrVsbMgybIiNbadWq1h6LXpRwOKTmzc3PbTZpzpwRatJkhNXdYClCFgAAAFBLOZ3Svn0VB6j9+82gdSo2m1S3bunwFBcn1a8vNWsmtWwpJSWZQSswsOLzJSRIV15paMECm3bvtunWW81FLk4MWg6Hubrgnj3m9oABUpMmp98f1YWQBQAAAPihggJzhKmiAJWeXvoGv2UJCCh79Ck+XmrY0AxQzZqZASoqymxvhUcecel//zNUVBSoefOkJUs875M1e/bxgGW3S5MmWfO63kbIAgAAAGqY3NyKw9OePVIlFvWTJAUFlR+gkpPNqXjNmpkjS5GR3n1fJ+va1dB9963V8893k8Nh05495r2wTma3S+++6x83IpYIWQAAAEC1MQwpO/vUASozs3LnCwkpP0A1aXI8QNWpI0VEePWtnbaePfdr0KBiPfFEkObP9xx5s9nMKYKTJvlPwJIIWQAAAIAlDEM6cuTUAerYscqdLzy87PCUkCClpJgLSDRpYgao0FCvvjWv69rV0GefmTcoXrZMysoyr+vq29c/rsE6GSELAAAAOAWXS8rMDNHatRWvxFdQULnzRUWVHaASE80V+Fq2NK+FqlNHZa64V1ulpJgPf0fIAgAAwFmtckuYB8npPPnGu2WLja14CfNWrczPY2PN66VQ+/DPCgAAgFrL4TCXKD/zJcxtkgzVrSslJNhKBagGDcxrn5o3r/wS5qi9CFkAAADwS9W5hHnjxk7t3r1Uf/lLX9WtG2zZEuaonbwasrKzs8vcHxERoUCiPQAAAMpx7NipA5QVS5g3bnz8HlAVLWHudEoLFuQpJsa6e0Sh9vJqyIqNjZXNZiu1PzAwUE2bNtX999+v0aNHe7MEAAAA1CDVuYR5Soo5fa9pU6luXXO1PqA6eDVkLVmypMz9mZmZWrNmjR544AEFBQVp1KhR3iwDAAAA1YAlzAGTV0NWnz59yn1u0KBBSklJ0UsvvUTIAgAAqOFcLungwVMHKJYwB3y88EWfPn00btw4X5YAAABw1isq8lzCvKxrofbuNa9LqgyWMMfZzqdf1llZWYqJifFlCQAAALWawyHt23fqJcxdrlOfy2Yzr20qK0CxhDlwnM9CltPp1DPPPKMePXr4qgQAAAC/lp9fetRp164ArVnTXdOmBWrvXnMJ88oIDJTi4spfwrx5czNEJSaaU/1YYQ8on1dD1uDBg8vcn5WVpV9++UU2m03Lly/3ZgkAAAB+6dixU1//dPhwWUcGSqrvsceKJcwBVJ5XQ1Z5UwGTk5M1ZMgQ3XDDDUwXBAAAZxXDkLKyTh2gsrIqd76TlzCvW7dYubk71aVLYzVrFsQS5oAPeDVkzZkzx5unB2qttDRp6VLzB2xMjNS3r7lULQCgZjMMc3TpVAEqN7dy5zudJcydTpcWLNig/v2TFRzstbcKoAJeDVkZGRlKTEws9/mioiKtXbtW3bt392YZgN9YtUqaOlVasMD8QV3CZpP695cmT5a6dfNdfQBwNnO5pIyMUweowsLKnS86unR4iotjCXOgNvBqyKpfv77279/vDlrt2rXTggULlJycLEk6fPiwevbsqeLiYm+WAfiFjz6Shg41V4E6mWFI8+dLixZJ774rlXO5IwDgNJ28hHlZj337Kr+EeZ06ZY9AJSWZ1z61bMkS5kBt5tX/1saJf4qXlJaWJudJ351ObgOcjVat8gxYycnSzTeb9xHZulV6803zB7zDYbb79ltGtACgsqxcwjwgoPwA1bDh8QUkWMIcOLv5/G8nNpvN1yWc9bj+x/emTj0esIYPl15/3XNqyMMPS7feKs2bZ7abNk367DPf1AoANUlZS5if/LBqCfMWLY6vwMcS5gAq4vOQBd/h+p+aIS3N/DeQzBGskwOWZG6/8Ya0ZIn5C8P8+dLOnebFzgBQW53+EualBQdXbgnz+HiWMAdw5rwasmw2m3JychQaGirDMGSz2XTs2DFlZ2dLkvsjqh/X/1jDMKSjR/P09dc/aN++TDkcQXI4AuVwBKmwMPCPbXNfYWGgcnKKtXv3IRUV2f94BOvIkQYyjGaSpKNHD6tRo2Pu58LCjikq6rCiow8pOvqQwsJaSOohw5BGjXpLbdr86FFP+/btFRUVVWHN8fHx6t27t8JZxxeAj5QsYb5jh7R2baIOHLBp//4zW8I8IaHsANWkiTkClZLCEuYAqo/Xr8lq1aqVx3anTp08tpkuWP3Ohut/XC6poMCcRpKX5/mo6r7c3EDt3XuhpkwJUkFB6TaGES7pEkvqPnYsTseOxbm3c3LilZGRUmbbJUsGasmSJpJ2SPr9j4/z/vh4QFL51zuuWbNGnTt3tqRmADhR1ZYwD5bUs8LzRUScegnzxo09lzAHAF/zashasmSJN0+P0+TL639cLs9AY0UIKms7P9+aek0BkuJO3SqgWMHBxQoKKlZwcFGZH222fOXnZygw0KGAAKcCAx3Kyamv/fvNFFuv3ho1bvyDgoMdCgoqUkFBtLKz45SfH6e8vHgdPZoip7NkpKqupL5/PDwFBxcpPj5XiYnHlJCQq8TEHCUk5Coh4ZjatAlRmzZtLOobAGcTq5cwj4oyFB6ep+TkMCUmBrgDVMkS5i1asIQ5AP/k1ZDVp0+fCp/Py8vTunXrvFkCTlLe9T/FxZ4hZfx46csvzR+m8+dL//iHOUf9dALPifsKCqr/PQcFmX/dDAkxH3a7+bGifSXbISFmYNmzZ7vatWuh6OggRUbK/YiKMu9zEhUlRUQEym4PlN1uzv0v/xeC1h5baWnmdQCGIQUHd9Hy5V3KPNbhkJo3N3+Bsdmk554z/1q8e7e57HB6uvnx4EHJ6QzS/v0x2r8/pswKYmPN12za1Hyc+HmTJvw1GDgbVWYJ8717zXaVcaolzFu1kurWLdL333+lq6/ur+BgVpEAUHv4dOGLbdu2qXfv3twnqwry8vK0fPlyHTp0yGN/cXGx1q1bp6ysLAX+sV5sTk6O1q9f79Fu8+bzZRjDJUlJSfM1btx8rVo1QKtXDyj3NQ1D+utfLX4jMkNIZQJPRSEoNNQMOxER5uPk4BMVZbYpaW+3V/1+JE6noQULtqh//+YKDra+H1JSzIVG5s83A9Ott5qLXJwYtBwOc/+ePeb2gAHSvfeWfb4jR6QNG6RffzWnf+7fb/7iVBLEMjPNx9q15qMs9eubge7kANa0qdSgAUsSA/6mupcwb97cHI061RLmTif3iAJQO/Gtzc9s3rxZV1xxxRmcIViSGbJWr35bq1e/KylG0okhK++PhyTF//Hxd0m//bE//4Q2eeXsO749ZcrrateurSIjj4ef6Ojj4afkcTb/4j55srnQiMNhTtNcssTzOrnZs48HLLtdmjSp/HPVrSv16WM+TlZcbJ5nwwZp0ybp99+PB7CSEJafb/6ytX+/eT3eyez24ytxlRXC6tY1R9oAVA+WMAeAmoeQ5WfatGmjhQsXljuS1bFjx1OMZHVRyaVyXbveoG7dYuV0FsjpfEAFBQ7Z7UUKCjJks0nr1g3Q2rVm+Lr44uUeK9mZq9jVkVSnwnrNleyasJrTKXTrZq7kWLIgyZ495rVwJ7PbzXanuxBJYKA5HbBJE+mqq0o/X1gobdtmhrAtW6Rdu8ywVTIVMSPDrG/7dvNRlqgoz/B1YghLSWFlL6AqWMIcAPwTIcvPhIeHKzU1tdR+p9OpmJgY9e/fX8EVzGk78fqf9PQBmjFjQIXX/0jmqMScOSPUpMkIi94FyjJ4sDlyNG2aOXXw5HuXDRhgjmB5c6XHkBDpvPPMR1mys6X1681RsK1bzb+en3g92JEjUk6O2eakfO9Wcj1GkyaBKi5uo4wMm1q0MENYo0ZMHcLZoWQJ81MFKJYwBwD/5NVfZz799NMKn9+xY4c3Xx5lON3rf7jpbfXo1s1cyTEtTVq2zPwFKyZG6tu3ZvwbREdLF15oPk7mcplB6+efpc2bzZGuk6ci5uaaH9PTpRUrAiS11gcfHD9HUJC5IEt5i3IkJDAVETVf1ZYwPzWWMAcA/+PVkHXNNdecsg33yap+Vl7/A+9ISTEf/iQgwFwUo0ED6corSz/vdJrXgP38szkVcceOYm3YcFAuV6LS0wOUnm6uWrZjh/koS3h46eB14udMcYK3lfwxwaolzKOjy1+BryRAJSebf2xhCXMA8B9eDVmuyixThGpXXdf/ACcKDpZatzYfkuR0urRgwY9/THENUG6u9Msv0saN5nVhJaudlUxFPHzYvBXAL7+Yj7LExR2/ruTkENa4sbyyOiRqj4qWMN+9O1Dbtl2mo0eDzngJ83r1zK/Lli3NMBUbyzRZAKhtquXb+uHDhxUXZ97Mdffu3Xr99ddVUFCggQMHqnfv3tVRAk5SE67/AU4UESF1724+TmYY5v2/NmwwA9b27ceXpi8JYTk5ZhA7fFhatar0OQICzNXRSpamPzmE1avHVMTa7MyXMA+QZF7MVJklzFu0MJcwj44+u1dOBYCzlVdD1oYNGzRw4EDt3r1bLVu21HvvvacrrrhCubm5CggI0PTp0/Wf//ynUtMKYb2afv0PUMJmM39hvfRS83Gy4mLz67hkUY60tNLXgzkc5nWIu3dLS5eWPkdIiDk968QQduKIWEzZ93VGDVAdS5jXrVuko0c36uqrz1WrVsFKSDADFMEcAFAWr4asv/3tb2rXrp3efvttzZs3T1dddZUGDBig119/XZJ0991366mnniJk+Zg/Xv8DnCgw0AxHzZtLf/pT6efz883FOEqWpt+zxzOEHTpkXkOzZYv5KEtsbPmjYE2amCGtpklLMwPliX9A8bf/6zk55QenkmBl1RLmJatcxsWVvr7PvCn5Tl122blMOwUAnJJXQ9aqVav09ddfq3379urQoYNee+013XnnnQr44+6Fd999t84//3xvlgAACguTOnUyH2U5fNgMYL/+ai7+cuCA5/VgWVlSZqa0Zo35OJnNJtWvX34Ia9Cgem/aum1brK65JlBffFF6KnD//ubiN76eCmwYZp+eagGJ7OzKnS80tOwlzOPijo9QpqSY22FhXnxjAADIyyHryJEjqlevniQpMjJSERERqlPn+M1r69Spo5ycHG+WAACnFBdnjvL07Vv6ueJic4rhhg3maNhvv3lOQzxwQCooMK/32bdPWr689DnsdnOkpLwQVqeOddPOPv7YpgkTLlRRUelUZxjmNZiLFpmL2gwebM1rlvU6hw6dOkDl5VXufJGR5Y9AlVz/1KgRS5gDAGoOry98cfIS7SzZDsCfBAYen1I7cGDp5wsLzdGvkqmIu3Z5TkU8eNC8Hmz7dvNRlqgoM2yVFcJSUio/8rJqlXTTTYEqKjK/zyYne96e4c03zXDjcJiri377bdVHtFwuM1xWFJ727rVmCfOmTY8HKJYwBwD4E6+HrJEjRyrkj4sVCgoK9Ne//lURERGSpMLK/hQGgBoqJERq1858lCUz01yWvmQq4r59nlMRjx41rztav958lCUpqfTS9CUhrFGj46vXTZ0qORxmwLrxRpfefDPAI5g8/LB5o/F588ygNW2aufhNiaIis7aKAtS+fTrjJczr1z8+AsUS5gCA2sirP9ZGjBjhsX3jjTeWajN8+HBvlgAAPhUbK114ofk4mctlhpYNG8xVEbdvN8PXiSEsL8/8PD1dWrGi9DmCgswRq/r1pe+/N/dFRRXqllsClZUVoPh4cypiYaH5WiNHmlMGjxyRPv/cvHH0kSPHFwOpzO0NAwKkunXLDlANGrCEOQAAXg1Zc+bM8ebpAcCvBQSYI1GNGplhJy8vT8uXL9ehQ4ckmSNG6el27d4dqX37InX4cKSysiJ0+HCYjhyxKz+/roqKgrVjh7Rjx/Hz5uSE6OKLzc+DggoUFORUQUFUmTUsXOi5bbMVKTIyTzExBYqMzFNU1PFH3bp5SkrKU3x8gaKjDTVuHK/evXsrPDzcG90DAIDfYoIGANQQmzdv1hVXXFGFI2ySGkhqJuk2SSWzBTZLipTUQEVFoSoqKlkNIl/SHklOSef8se8DSf/6Y/8eGcZB5eQYquyaRGvWrFHnzp2rUDMAALUfIQsAaog2bdpo4cKF7pGs8uTk5Gj9SRdwbd7s0pIl5ufNm6/WpZd+q4ICu44cqauCgmBFRmYqKipXYWHSmjUDtGaNGbIuvjhPbdo0lNRQUg9JUvv27RUVVfbI14ni4+PVpk2bKr9PAABqO0IWANQQ4eHhSk1NPa1j09LMa6EMQ8rKGqzp069TRETpu+Y6HOYqhpJ5rdacOSPUpMmIUu0AAMDpq8bbYwIAvCUlxbzRsCQdOhSu228PlMPh2cbhMFcX3LPH3B4wQGrSpFrLBADgrMBIFgDUEpMnS4sWGXI4bHr77QAtW+Z5n6zZs48HLLtdmjTJt/UCAFBbEbIAoJbo1k2aN69YN9xgU1FRoPbsMe+FdTK7XXr33arfiBgAAFQO0wUBoBb5058MPfnkt+rf3yWbzfM5m0266irp22+lwYN9Ux8AAGcDRrIAoJZp2TJTY8cWa+9ec8pgVpYUEyP17cs1WAAAVAdCFgDUUikp5gMAAFQvpgsCAAAAgIUIWQAAAABgIUIWAAAAAFiIkAUAAAAAFiJkAQAAAICFCFkAAAAAYCFCFgAAAABYiJAFAAAAABYiZAEAAACAhQhZAAAAAGAhQhYAAAAAWIiQBQAAAAAWImQBAAAAgIX8LmS98sorSklJUWhoqHr06KGVK1dW6rj33ntPNptN11xzjXcLBAAAAHBW86uQ9f7772v8+PGaPHmy1q5dqw4dOig1NVUZGRkVHpeWlqb7779fvXv3rqZKAQAAAJyt/CpkTZ8+XaNHj9aoUaN0zjnnaNasWQoPD9fs2bPLPaa4uFg33HCDpk6dqmbNmlVjtQAAAADORkG+LqCyHA6H1qxZowkTJrj3BQQEqF+/flqxYkW5x02bNk2JiYm65ZZbtHz58gpfo7CwUIWFhe7t7OxsSZLT6ZTT6TzDd+BdJfXV9Dr9EX3rHfSrd9Cv3kG/egf96h30q3fQr97hT/1alRr9JmQdOnRIxcXFSkpK8tiflJSkzZs3l3nMt99+qzfffFPr1q2r1Gs8+eSTmjp1aqn9//vf/xQeHl7lmn1h0aJFvi6h1qJvvYN+9Q761TvoV++gX72DfvUO+tU7/KFf8/LyKt3Wb0JWVeXk5Oimm27S66+/rvj4+EodM2HCBI0fP969nZ2dreTkZF1++eWKjo72VqmWcDqdWrRokS677DIFBwf7upxahb71DvrVO+hX76BfvYN+9Q761TvoV+/wp34tmeVWGX4TsuLj4xUYGKj09HSP/enp6apXr16p9r/99pvS0tI0cOBA9z6XyyVJCgoK0pYtW9S8eXOPY0JCQhQSElLqXMHBwTX+H72EP9Xqb+hb76BfvYN+9Q761TvoV++gX72DfvUOf+jXqtTnNwtf2O12denSRYsXL3bvc7lcWrx4sXr27FmqfZs2bbRhwwatW7fO/bj66qt18cUXa926dUpOTq7O8gEAAACcJfxmJEuSxo8frxEjRqhr167q3r27ZsyYodzcXI0aNUqSNHz4cDVs2FBPPvmkQkNDdd5553kcHxsbK0ml9gMAAACAVfwqZF133XU6ePCgJk2apAMHDqhjx45auHChezGMXbt2KSDAbwbnAAAAANRCfhWyJGnMmDEaM2ZMmc8tXbq0wmPnzp1rfUEAAAAAcAKGfQAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACwU5OsCAADekZaZpqVpS5VVkKWY0Bj1TemrlNgUX5cFAECtR8gCgFpmW942XfPva/TF9i9kyHDvt8mm/i37a3KfyerWsJsPKwQAoHZjuiAA1CIfb/5YE7ZN0ILtCzwCliQZMjR/23xdOOdCfbTpIx9VCABA7UfIAoBaYtXeVbrpvzepyCiSJCVHJ2tyn8l6e/DbmtxnshpFN5IkOYodGvrhUK3au8qX5QIAUGsxXRAAaompy6bKUeyQJN3Y7ka9OehN2QPt7ucf7v2wbv30Vs1bP0+OYoemfTNNnw39zFflAgBQazGSBQC1QFpmmhZsWyBJig+O16z+szwCliTZA+164+o33CNa87fO187MndVeKwAAtR0jWQBQQ+Tl5Wn58uU6dOhQhe1ycnK0fv16j32bQzfLiDGvwYreEa2b779ZR4OP6nDQYRUGFMpu2GV32WU37Aq2B0uh5jVa1z5+rVrltzKfN+yyyab27dsrKirqlPXGx8erd+/eCg8PP/03DQBALUTIAoAaYvPmzbriiiuqdlCEpCRJ3STFmLt+r/+7fg/8vVKHr4xcqZWRK4/vKJS09Y+PBaf++MbLb6hb+26KCYlRTGiMouxRCgwIrNp7AACgliFkAUAN0aZNGy1cuLDMkSyHy6F9zn3aVbhLvx37TVuObtHhoMPKD8wvfaJAKdAVqKjCKEUVRim0OFRFAUVyBjhVFFCkrJAs5dvN4wKLA2XYDLkCXOaxIX88KunW72+VvvfcF2mPVExIjGJDYxUTGuMOYDEhJ31ezsfokGiCGgDArxGyAKCGCA8P1+WXX67d2bu1Pn29+7EhY4O2HNqiYqP4eOM/gpBNNtWPqq/6kfW1Zv8aSVJUYJR+uP0HtUhoUeq6LEexQ81fbK492Xtkk02bx25WYkSiMgsylZGXoUN5h3Q477COFBzR0byjyizMVK4zV3mOPOU6c82HI1d5zjz35yUfnS6nJOmY45iOOY5pb87e0+6LiOAIxYTGKDbkj6AW+kdoI6gBAPwAIQsAfCSnMEcbMzYeD1QZ67UhfYOyCrPKbB9pj1TT2KZqWqepmsY2Vau4VurRsIda1m2p6NBoXfXOVZq/bb5yinP0xHdPaPY1sz2OdxQ7dOunt2pP9h5J0oBWA9QiroUkKTo0Wo1jG5/W+3AWO5XvzD+joFbyecnqiCXt9uXsO62apLKDWmVDWkyoGdSCAvgxCQCoOn56AICXFbuKtf3Idm3I2OAxQrUjc0eZ7QNtgUqOSVZKbIoZqmKbqmuDrmqf2F71ouqVO0Izuc9kLfp9kRzFDr298W0t27VMN3e8Wa3iWmnr4a2avW62O2DZA+2adNEkS95fcGCwggODLQlqWYVZysg9KajlH1VmQaZHQKvuoBYTEiNXnkszs2cqNiyWoAYAqBDf+QHAQofyDplT/NI3uEenfsn4RflFZVw7JSkuLE5NY5uagapOU7WNb6vzG52vJjFNFG6v2qp93Rp207xB83TDxzeoyCjSnuw9mvbNtFLt7IF2vTvkXXVr2O203qM3nBjUkmOST+scVQlqpxpVKywulFQ6qG35fUuV6woPDq/SNWontyOoAYD/4bs2AJyGwqJCbT602X3NVMno1P5j+8tsHxIYoiaxTdyBqllsM/Vo1EPnJJyj+PB42Ww2S+r6U5s/6cmWT2qJa4m+2P6FDBnu52yyaUCrAZp00aQaFbCsYkVQKyouUn5RvrIKsjymPqbnpGvl+pVKbJKoguKCKgW1PGee8px55X5tVEZVg1pZHwlqAFB9/O477iuvvKJnnnlGBw4cUIcOHfTSSy+pe/fuZbZ9/fXX9c9//lMbN26UJHXp0kVPPPFEue0B4GSGYWhvzl6PRSjWp6/X5kObVeQqKvOYepH13NdOpcSmqENSB3Wp30XJMcmlFqLwhpbhLTW2/1jtzd2rZWnLlFWYpZiQGPVN6asmsU28/vr+LCgwSFGBUYoKiVKjmEbu/U6nU00PNlX/fv0VHBxc4TlKglp2QbbS89KPj6jlmyNqRwuPegS0isKapUEtKFzRodFlXqNWZngjqAHAafOr75bvv/++xo8fr1mzZqlHjx6aMWOGUlNTtWXLFiUmJpZqv3TpUg0dOlS9evVSaGionn76aV1++eX65Zdf1LBhQx+8AwA1Wa4j12MhipJAdbTgaJntI4IjPMJUy7ot1aNhD7WOb62Y0Jhqrr60lNgUpXRM8XUZZ50Tg1rDmNP7WVPsKnYHtYy8DB3KPaTD+YePh7XTCWpFeco7lqcDxw6c9nurKKhVJqTFhMQoOLDikAoAtYFfhazp06dr9OjRGjVqlCRp1qxZmj9/vmbPnq2HHnqoVPu3337bY/uNN97Qhx9+qMWLF2v48OHVUjOAmsdluPT70d9LLZP+25HfPKbXlQiwBahRdCP3IhRN6zRV5/qd1TGpo+pH1WepcFguMCBQkfZIRdoj1SC6wWmd48SgdjDvoA7lHtKhguOjalkFWTrmPFYqoHk7qIUFhblXfYwOiZYjx6F5H81TnbA6BDUAtYbfhCyHw6E1a9ZowoQJ7n0BAQHq16+fVqxYUalz5OXlyel0qm7dumU+X1hYqMLCQvd2dna2JHOaiNPpPIPqva+kvppepz+ib72juvr1SP4RbczYqA0ZG7Th4AZtyNigXw7+ojxnXpnt64TWUZOYJuZCFDFN1Tqutbo36K6mdZoqwh5Rqr2r2CVXscur76Eq+Hr1Dn/t1xBbiBLCEpQQliDFVf34E4PaofxDOph3sMzFREoCWUUfC4oKJEn5RfnKP5bvEdTWbV5XpbpCg0JLjaBFh0S797k/Dz3+eWxorEeb2hzU/PXrtaajX73Dn/q1KjXaDMMo/WfbGmjfvn1q2LChvv/+e/Xs2dO9/29/+5uWLVumH3/88ZTnuPPOO/Xll1/ql19+UWhoaKnnp0yZoqlTp5ba/8477yg8vGqrfAGoXkVGkfYW7FVaQZp25u9UWn6adhbs1GHn4TLbB9oClRicqER7opLsSUoMSVTLsJZKCUtRdFC0ZQtRAGe7YlexHIZD+cX5yi7OVpYzSzlFOcopztGx4mPKLc5VgatABa4CFboKVegqdH9+8j6nYd0vYXabXeGB4QoPDFdEYIT5MSCi1L7wgBM+P2l/cEDtDWoASsvLy9OwYcOUlZWl6OjoCtv6zUjWmXrqqaf03nvvaenSpWUGLEmaMGGCxo8f797Ozs5WcnKyLr/88lN2pK85nU4tWrRIl1122SkvykbV0Lfecbr9ahiG9h/br40H/xid+uOx+dBmOV1l/wKWGJGopjFN1SS2iVJiUnRewnnqWr+rkmOSFRIUYtVbqhH4evUO+tU7KtuvJSNqOYU5OpT3x4ha/h/XpxWctDy/M89juuOJH/Ocee7bKTgMhxxFDmUWZZ52/SGBIaVWeowOifaYDnnyiNrJI23eWAyHr1fvoF+9w5/6tWSWW2X4TciKj49XYGCg0tPTPfanp6erXr16FR777LPP6qmnntJXX32l9u3bl9suJCREISGlf+EKDg6u8f/oJfypVn9D33pHRf2a58zTLxm/lLqJ7+H8skenwoLC1LROU/cy6S3qtlCPhj3UJr6N6oTV8ebbqHH4evUO+tU7TtWvwQpWaEio6kTUUeO6p3fD62JXsQqKCpRTmKODeQfN69TyDrlXfTySf6TMhUTKWlSkJKgVFhcqIy9DGXkZp1WTZE59PHFK4+ksJlLeH4v4evUO+tU7/KFfq1Kf34Qsu92uLl26aPHixbrmmmskSS6XS4sXL9aYMWPKPe7vf/+7Hn/8cX355Zfq2rVrNVULoCpchktpmWnHb+KbYYapbYe3lbsQRcOohmaYqpOiprFN1bFeR3Wu11kNohooKNBvvrUBqCaBAYGKsEcowh6helEV/3G2PCVB7VjhMfd91EqC2pGCI8rMz9Qxx7HSAa1kQZEyglpBUYEKigqUkXv6QS0kMMTjZtbR9mjlHc3TJ/M/MRcUOYOgBuD0+NVvIuPHj9eIESPUtWtXde/eXTNmzFBubq57tcHhw4erYcOGevLJJyVJTz/9tCZNmqR33nlHKSkpOnDAvMg2MjJSkZGRPnsfwNkssyBTG9I36Kd9P2nB7gV66q2ntPHgRh1zHCuzfXRItJrVaeZe2a9VfCv1bNhTzeo2U6Sd/8cAqs+JQS0pKum0znHaQa2MUTWPEbXcjFJBbcXPlVsYTDKDmnuqY2hspW54fXI7ghpwnF+FrOuuu04HDx7UpEmTdODAAXXs2FELFy5UUpL5jW7Xrl0KCAhwt585c6YcDof+/Oc/e5xn8uTJmjJlSnWWDpx1ilxF2np4a6l7Tu3K2lVm+6CAIDWOaexeIr1pbFN1a9BN7RLbKTEi0eP/NgD4KyuCmsvlUn5Rvo4VHnNPezyUb95L7Wj+UR3OPaxftv2i+Abxyi/Or3RQK5lGebpOJ6id/DE0qOzr5gF/41chS5LGjBlT7vTApUuXemynpaV5vyAASj+WfvyaqT+m+m06uMl9b52TJYQnqElME4Xkh6hX215qX6+9ujXopiYxTRQazA9YAKhIQEBAhUHN6XRqQcEC9e/fv9xrSE4V1DIL/hhRO2GqY3lhreSWGFYENXugXdEhZdzw+oTpkAQ1+AO/C1kAfKegqEC/HvzVYxGK9enry/2BGhYUpiaxTdxT/ZrVbabzG52vtvFtFRUUpQULFqj/xeX/EgAA8I5TBbXKcLlcKigqUK4zVwdzD3qEtaoGtXxnvgwZchQ73FMoT1dJUCu1mEgVRtVCg0K5lQfOCCELQCmGYWhn1k5zEYoTRqe2Ht4ql1H6xrs22dQgqoF5A98/pvp1TOqozg06q2FUwzJv+ukPNx0EAJQvICBA4fZwhdvDlRCRcFrnKC+olYyoHS04qmOOY+6l+cub9mh1UAsOCHZPfawTWkcxoTGKCo5SzqEcLV602FxQhKDmFWmZaVqatlRZBVmKCY1R35S+SolN8XVZVUbIAmqg6vwGk12YrQ3pGzyWSd+QsUHZhWXfCyLKHqVmdZqZgSq2qVrHtVaPRj3UvE5zRYfW7PvJAQBqFquCWmFxoTuoHco7pIzcjCoFtZLP85x5MmTI6XLqcP7hMm8Z8vWRrytV14lBrarXqJW0P5uC2up9q/X4d49rwbYFHisL22RT/5b9NbnPZHVr2M2HFVYNIQuoQVbtXaWpy6Z65RtMkatI249sL7VMelpmWpntgwKClByd7F6IIiU2RV3rd1WHeh2UGJGowIDA06oDAAArBQQEKCwgTGHBYYoPjz+tc5wY1A7lHvK4j9rh/MPKzM9UVkGWtuzYorpJdZVXlHdGQa2yziSolXwMCwqr8UFtReYKPT/veTmKHaWeM2Ro/rb5WvT7Ir075F0NbjvYBxVWHSELqCE+2vSRhn441JJvMAdzD5Za1e+Xg7+ooKigzPZxYXHuaX5NY5vqnIRz1L1hd6XEpigsOMyS9wcAQE11clBrozal2jidTvNa4nIWFKlMUMtx5LiDWLmjas485Tnz5DJclgS1oICgU16jVub+agpqq/et1nM7n1ORUSRJSo5O1s2dblaruFbaenir3vzpTe3J3iNHsUNDPxyqb0d96xcjWoQsoAZYtXeVR8Cq7DeYwqJCbTq0qVSgOnDsQJmvExIY4p7ml1InRc1ijy9EERceV+P/0gUAQE1VmaB2KoZhqKCoQHnOPB3KO+RxjdqRvCM6WnBUOYVVC2pFriLzPmz5R077vVUmqJ1qVC08OLzM3zMe+/Yxd8Aa3mG4Xh/4uuyBdvfzD/d+WLd+eqvmrZ8nR7FD076Zps+Gfnba76W6ELKAGmDqsqnugFXWN5gJF07QsI+G6aNNH8lR7NA171+jOqF1tPnQZhUbxWWes35kfY/RqZJl0htENfA4NwAAqBlsNpvCgs2gFhcep9ZqXeVzVBTUjuaZ16jlOHLcAa1UWDth2+qgFmWP8lhMJDggWIt+XyRJirZHq218W7217i3FhMaocUxjnd/ofNkD7Xrj6je0JG2J9mTv0fyt87Uzc6eaxDY57VqqAyEL8LG0zDQt2LZAktQoupHuPf9efb3ja6Vlpmljxkb36FRmQab7mH05+7QvZ58kKdIe6R6dalqnqVrVbaUejXqoZd2WigmN8cVbAgAAPmJVUCssKiwV1A7lH/IIall5Wdq5a6ey87NVaBSaDxXKYTg8tg0ZKnIV6WiBeWya0kq9ZrYjWxMWT3BvJ+Ynakj2EPd2UkSS9kTukSFDo6aNUpuC4yOF7du3V1RU1CnfV3x8vHr37q3w8PAq90lVEbKAM5SXl6fly5fr0KGKl4o1DEMHsg/ox80/KicwRzmBOToWcEz77PtkBJuLXOzJ3qNO/+hU5vE2w6bg4mA5gswRr6ZHm6ptdlvFBcQpwh4hm2xq276tog5Hacu2LdqiLWWepzq/wQAAAP9js9kUGhyq0OBQ1Q2vq1ZqVWa7tWvXqsufu5z6hHZJIZJCT/rYVtJ5f7TZLin3+HMZ+zI0838zj5+jnaQ/MteS75doyY9LTuOdSWvWrFHnzp1P69iqIGQBZ2jz5s264oorJJukKEkxfzxiy/holxR3ihMWSMqSlCnpkKR082EcMuQ4x+H+BrPjhx3a8eOO06q5ur7BAACA2qtNmzZauHDhKf/QLEk5OTlav369x77NoZu1RGZY6pLURd3zuh9/srmkO45vroxYqTVaI0m6uNfFatP59Eay2rSp+rVyp4OQBVRSYVGhdubs1M7MndqZdfzjjiM7VO/JejpYeFDFKvv6qBOFFIUozBmmsKIwhTpDVRhUqH3R5tS/Nllt1COnh0KCQhQYG2gGsxbHj63oG4xUuW8y1fkNBgAA1F7h4eFKTU097ePTMtPU7IVmMmQoo2GGZtwzo8zrxh3FDjV/sbmUbd7WZs6kOVyTBfiL7MJs7craVSpEpWWmaWv6VmWuy/S4d1VZAmwBig+PV2JEopIikpQYkWh+HpmklnVbqm18W9WPqq/YkFgFBARI8vwGk5ucq9fuea3WfIMBAAAoT0psiq5scaUWbF+g3dm7deunt+qNq9/w+D3IUezQrZ/eqj3ZeyRJA1oN8IvffwhZOCsYhqGDeQdLBagTPz9xYYnyhASGuINTYkSiEiISlBSRpIZRDdUqrpVaxrVUUkSSokJOPWRdIiU2Rf1b9tf8bfNr3TcYAACAijxy4SP632//U5FRpHnr52lJ2hLd3PH4bWxmr5vt/v3HHmjXpIsm+bjiyiFkoVYochVpX86+ckPUrqxdyi/KP+V5Iu2RpUah4kLjlLUzS3/u+2e1TmituPA4hQaHWlr/5D6Ttej3RXIUO2rVNxgAAICKdG3QVfc1uU/P735ejmKH9mTv0bRvppVqZw+0690h7/rFjYglQhZkTldbmrZUWQVZigmNUd+UvkqJTfF1WR7ynfnmVL5yRqH2Zu8t935RJWyyqW5YXY+RqJJH8zrN1Sa+jRrHNFad0DoKCjz+X6PkDu+9m/Qu8w7vVujWsJveHfKu+4bEteUbDAAAwKn0jO2pQX0H6Ynvn9D8rfM9Ls+wyaYBrQZo0kWT/Or3H0LWWWzV3lWaumyqFmxbUOqLuX/L/prcZ3K1fTFnFmRWOJUvIzfjlOcICghSfHi8xyhUYkSi6kfWV6u4VmoV10r1I+srOiTafT1UTTK47WB9O+pbTftmWq35BgMAAFAZXRt01WdDP1NaZpqWpS1TVmGWYkLMP/774yUShKyz1EebPnKPmpzMkKH52+Zr0e+L9O6QdzW47eAzei2X4VL6sXTPAHVCkNqVtUvZhdmnPE9YUFiZo1CNohqpdXxrtYxrqYTwBEXYI86oXl/q1rBbrfoGAwAAUBUpsSlK6Zji6zLOGCHrLLRq7yqPgJUcnaybOx2//ufNn97Unuw9chQ7NPTDofp21LcVjp44i53ak72nwhBVVpg7WXRIdKlRqMSIRDWNbarWca3VtE5TxYXHlbnyXm1TW77BAAAAnI0IWWehqcumukPP8A7D9frA1z2Cy8O9H9atn96qeevnyVHs0OSlk/Xs5c+WG6D25eyTy3BV+JoBtgDFhcWVClBJEUlqUbeF2sS3UcOohqoTVkeBAYFeff8AAACANxGyzjJpmWlasG2BJHME6/WBryvfma+NGRs9QlR2YbaCA4LldDn1xfYv9MX2Lyo8b3BAcJlT+RpENVDruNZqWbel6kXWU1RIlGw2W3W8VQAAAMAnCFl+Ji8vT8uXL9ehQ4c89hcXF2vdunXKyspSYKA5EpSTk6P169d7tNscullGjLmgQtK+JI27e5y+j/xeP0f8XOHrBrgCFOGMUJgzTGHOMDWs21DxIfGKC4pT/ZD6SrInKSo06viIWJ75iDfi1btDb4WHh1vTAQAAAEANR8jyM5s3b9YVV1xx+ifoIelK89PVX67W6g2rpW6SLpKU9ccj84+PsZJ6mW1dX7qU82OOcpQjSdqpnZV+yTVr1qhz586nXzMAAADgRwhZfqZNmzZauHBhuSNZHTt2POVI1hItkSR1Te2qbhd2kyFDtjybFCwp/o+HpJURK7VGayRJF/e6WG06t3Gfp3379oqKijplvfHx8WrTps0p2wEAAAC1BSHLz4SHhys1NbXUfqfTqZiYGPXv37/CG+amZaap2QvNZMhQeoN0zbhnRpmr9TmKHWr+YnMp27xH05xJc1hCHAAAAKiEmndHVnhVSmyK+rfsL0nanb1bt356a6nl1R3FDt366a3ak71HkjSg1QACFgAAAFBJjGSdhSb3maxFvy+So9iheevnaUnaEt3c8fh9smavm+0OWPZAuyZdNMnHFQMAAAD+g5B1FurWsJveHfKu+4bEe7L3aNo300q1swfa9e6Qdyu8ETEAAAAAT0wXPEsNbjtY3476Vle1uko2ed63yiabrmp1lb4d9a0Gtx3sowoBAAAA/8RI1lmsW8Nu+mzoZ0rLTNOytGXKKsxSTEiM+qb05RosAAAA4DQRsqCU2BSldEzxdRkAAABArcB0QQAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAsRMgCAAAAAAsRsgAAAADAQlULWX37SuPGeaWQShk5UrrmmuPbvq4HAAAAAE4S5OsCzshHH0nBwb6uAgAAAADc/Dtk1a3r6woAAAAAwEPVr8kqKpLGjJFiYqT4eGniRMkwzOfmzZO6dpWioqR69aRhw6SMjOPHHj0q3XCDlJAghYVJLVtKc+Ycf373bunaa6XYWDNADRokpaWVX8vJ0wVTUqQnnpBuvtmsoXFj6bXXPI+p6msAAAAAQBVUPWS99ZYUFCStXCm98II0fbr0xhvmc06n9Oij0s8/S598YoaXkSOPHztxovTrr9IXX0ibNkkzZ5pBreTY1FQzHC1fLn33nRQZKV1xheRwVL6+554zg95PP0l33indcYe0ZYu1rwEAAAAA5aj6dMHkZOn55yWbTWrdWtqwwdwePdocQSrRrJn04otSt27SsWNmmNm1S+rUyQxBkjnyVOL99yWXywxsNpu5b84cc8Rp6VLp8ssrV1///ma4kqQHHzRrW7LErNWq1wAAAACAclR9JOv8848HFEnq2VPatk0qLpbWrJEGDjSn6UVFSX36mG127TI/3nGH9N57UseO0t/+Jn3//fHz/PyztH27eVxkpPmoW1cqKJB++63y9bVvf/xzm82ctlgyZdGq1wAAAACAcli38EVBgTkVLzVVevtt87qrXbvM7ZKpeFdeKe3cKS1YIC1aJF16qXTXXdKzz5qjXV26mMeeLCGh8nWcvNqgzWaOXknWvQYAAAAAlKPqIevHHz23f/jBXMBi82bp8GHpqafMKYWStHp16eMTEqQRI8xH797SAw+YIatzZ3M6X2KiFB19Gm+lEqrjNQAAAACc1ao+XXDXLmn8eHMxiXfflV56SRo71pwiaLeb27//Ln36qbkIxokmTZL++19zyt4vv0iffy61bWs+d8MN5iIYgwaZi1Ls2GFeJ3XPPdKePWf+TqvrNQAAAACc1aoesoYPl/Lzpe7dzal+Y8dKt91mjlDNnSt98IF0zjnmiNazz3oea7dLEyaY101ddJEUGGheoyVJ4eHSN9+YYW3wYDN83XKLOQ3RqlGn6ngNAAAAAGe1qk0XXLr0+OczZ5Z+fuhQ83GikntoSdIjj5iP8tSrZy4RX565c8uvRyr7flfr1lXtNQAAAADgDFR9JAsAAAAAUC5CFgAAAABYiJAFAAAAABYiZAEAAACAhc6OkDVlitSxo6+rAAAAAHAW8N+Q1bevNG5c5dref7+0eLE3qwEAAAAASVVdwt3fGIZUXCxFRpoPAAAAAPCy6hnJ6ttXuvtuc+SpTh0pKUl6/XUpN1caNUqKipJatJC++OL4MRs3SldeaYajpCTpppukQ4fM50aOlJYtk154QbLZzEdamnnfLJvNPE+XLlJIiPTtt2VPF5w9Wzr3XLNN/frSmDHV0BEAAAAAarvqmy741ltSfLy0cqUZuO64Q/rLX6RevaS1a6XLLzeDVF6elJkpXXKJ1KmTtHq1tHChlJ4uXXutea4XXpB69pRGj5b27zcfycnHX+uhh6SnnpI2bZLaty9dy8yZ0l13SbfdJm3YIH36qRnyAAAAAOAMVd90wQ4dpEceMT+fMMEMQfHxZlCSpEmTzPCzfr301VdmwHriiePHz55tBqmtW6VWrSS7XQoPl+rVK/1a06ZJl11Wfi2PPSbdd580duzxfd26nfl7BAAAAHDWq76QdeKIUmCgFBcntWt3fF9SkvkxI0P6+WdpyZKyr6P67TczZFWka9fyn8vIkPbtky69tPK1AwAAAEAlVV/ICg723LbZPPfZbOZHl0s6dkwaOFB6+unS56lf/9SvFRFR/nNhYac+HgAAAABOU81cXbBzZ+nDD6WUFCmonBLtdnPlwKqKijLPu3ixdPHFZ1IlAAAAAJRSM++Tdddd0pEj0tCh0qpV5hTBL780VyIsCVYpKdKPP5qrCh46ZI6AVdaUKdJzz0kvviht22YuvPHSS154IwAAAADONjUzZDVoIH33nRmoLr/cvHZr3DgpNlYK+KPk++83r+065xwpIUHatavy5x8xQpoxQ3r1VXMZ96uuMsMWAAAAAJyh6pkuuHRp6X1paaX3Gcbxz1u2lD76qPxztmolrVjhuS8lxfMcJaZMMR8nuv128wEAAAAAFqqZI1kAAAAA4KcIWQAAAABgIUIWAAAAAFiIkAUAAAAAFvK7kPXKK68oJSVFoaGh6tGjh1auXFlh+w8++EBt2rRRaGio2rVrpwULFlRTpQAAAADORn4Vst5//32NHz9ekydP1tq1a9WhQwelpqYqIyOjzPbff/+9hg4dqltuuUU//fSTrrnmGl1zzTXauHFjNVcOAAAA4GxRPUu4W2T69OkaPXq0Ro0aJUmaNWuW5s+fr9mzZ+uhhx4q1f6FF17QFVdcoQceeECS9Oijj2rRokV6+eWXNWvWrMq/cG6ueU+umszpVGBBgVlrcLCvq6ld6FvvoF+9g371DvrVO+hX76BfvYN+9Q5/6tfc3Eo39ZuQ5XA4tGbNGk2YMMG9LyAgQP369dOKk++X9YcVK1Zo/PjxHvtSU1P1ySeflNm+sLBQhYWF7u2srCxJUnaDBmdYffW4SFL+Hw9Yi771DvrVO+hX76BfvYN+9Q761TvoV+/wl37N/uOjUdZ9eU/iNyHr0KFDKi4uVlJSksf+pKQkbd68ucxjDhw4UGb7AwcOlNn+ySef1NSpU0vtTz7NmgEAAADULjk5OYqJiamwjd+ErOowYcIEj5Evl8ulI0eOKC4uTjabzYeVnVp2draSk5O1e/duRUdH+7qcWoW+9Q761TvoV++gX72DfvUO+tU76Ffv8Kd+NQxDOTk5alCJWW5+E7Li4+MVGBio9PR0j/3p6emqV69emcfUq1evSu1DQkIUEhLisS82Nvb0i/aB6OjoGv8F6q/oW++gX72DfvUO+tU76FfvoF+9g371Dn/p11ONYJXwm9UF7Xa7unTposWLF7v3uVwuLV68WD179izzmJ49e3q0l6RFixaV2x4AAAAAzpTfjGRJ0vjx4zVixAh17dpV3bt314wZM5Sbm+tebXD48OFq2LChnnzySUnS2LFj1adPHz333HMaMGCA3nvvPa1evVqvvfaaL98GAAAAgFrMr0LWddddp4MHD2rSpEk6cOCAOnbsqIULF7oXt9i1a5cCAo4PzvXq1UvvvPOOHnnkET388MNq2bKlPvnkE5133nm+egteExISosmTJ5ea7ogzR996B/3qHfSrd9Cv3kG/egf96h30q3fU1n61GZVZgxAAAAAAUCl+c00WAAAAAPgDQhYAAAAAWIiQBQAAAAAWImQBAAAAgIUIWbXEK6+8opSUFIWGhqpHjx5auXKlr0vya08++aS6deumqKgoJSYm6pprrtGWLVt8XVat89RTT8lms2ncuHG+LsXv7d27VzfeeKPi4uIUFhamdu3aafXq1b4uy68VFxdr4sSJatq0qcLCwtS8eXM9+uijYr2oqvvmm280cOBANWjQQDabTZ988onH84ZhaNKkSapfv77CwsLUr18/bdu2zTfF+pGK+tXpdOrBBx9Uu3btFBERoQYNGmj48OHat2+f7wr2E6f6ej3RX//6V9lsNs2YMaPa6vNXlenXTZs26eqrr1ZMTIwiIiLUrVs37dq1q/qLtQAhqxZ4//33NX78eE2ePFlr165Vhw4dlJqaqoyMDF+X5reWLVumu+66Sz/88IMWLVokp9Opyy+/XLm5ub4urdZYtWqV/vGPf6h9+/a+LsXvHT16VBdccIGCg4P1xRdf6Ndff9Vzzz2nOnXq+Lo0v/b0009r5syZevnll7Vp0yY9/fTT+vvf/66XXnrJ16X5ndzcXHXo0EGvvPJKmc///e9/14svvqhZs2bpxx9/VEREhFJTU1VQUFDNlfqXivo1Ly9Pa9eu1cSJE7V27Vp99NFH2rJli66++mofVOpfTvX1WuLjjz/WDz/8oAYNGlRTZf7tVP3622+/6cILL1SbNm20dOlSrV+/XhMnTlRoaGg1V2oRA36ve/fuxl133eXeLi4uNho0aGA8+eSTPqyqdsnIyDAkGcuWLfN1KbVCTk6O0bJlS2PRokVGnz59jLFjx/q6JL/24IMPGhdeeKGvy6h1BgwYYNx8880e+wYPHmzccMMNPqqodpBkfPzxx+5tl8tl1KtXz3jmmWfc+zIzM42QkBDj3Xff9UGF/unkfi3LypUrDUnGzp07q6eoWqC8ft2zZ4/RsGFDY+PGjUaTJk2M559/vtpr82dl9et1111n3Hjjjb4pyAsYyfJzDodDa9asUb9+/dz7AgIC1K9fP61YscKHldUuWVlZkqS6dev6uJLa4a677tKAAQM8vm5x+j799FN17dpVf/nLX5SYmKhOnTrp9ddf93VZfq9Xr15avHixtm7dKkn6+eef9e233+rKK6/0cWW1y44dO3TgwAGP7wcxMTHq0aMHP8cslpWVJZvNptjYWF+X4tdcLpduuukmPfDAAzr33HN9XU6t4HK5NH/+fLVq1UqpqalKTExUjx49KpyqWdMRsvzcoUOHVFxcrKSkJI/9SUlJOnDggI+qql1cLpfGjRunCy64QOedd56vy/F77733ntauXasnn3zS16XUGr///rtmzpypli1b6ssvv9Qdd9yhe+65R2+99ZavS/NrDz30kK6//nq1adNGwcHB6tSpk8aNG6cbbrjB16XVKiU/q/g55l0FBQV68MEHNXToUEVHR/u6HL/29NNPKygoSPfcc4+vS6k1MjIydOzYMT311FO64oor9L///U9/+tOfNHjwYC1btszX5Z2WIF8XANR0d911lzZu3Khvv/3W16X4vd27d2vs2LFatGiR/86xroFcLpe6du2qJ554QpLUqVMnbdy4UbNmzdKIESN8XJ3/+ve//623335b77zzjs4991ytW7dO48aNU4MGDehX+BWn06lrr71WhmFo5syZvi7Hr61Zs0YvvPCC1q5dK5vN5utyag2XyyVJGjRokO69915JUseOHfX9999r1qxZ6tOnjy/LOy2MZPm5+Ph4BQYGKj093WN/enq66tWr56Oqao8xY8bo888/15IlS9SoUSNfl+P31qxZo4yMDHXu3FlBQUEKCgrSsmXL9OKLLyooKEjFxcW+LtEv1a9fX+ecc47HvrZt2/rtikw1xQMPPOAezWrXrp1uuukm3XvvvYzCWqzkZxU/x7yjJGDt3LlTixYtYhTrDC1fvlwZGRlq3Lix++fYzp07dd999yklJcXX5fmt+Ph4BQUF1aqfZYQsP2e329WlSxctXrzYvc/lcmnx4sXq2bOnDyvzb4ZhaMyYMfr444/19ddfq2nTpr4uqVa49NJLtWHDBq1bt8796Nq1q2644QatW7dOgYGBvi7RL11wwQWlbjGwdetWNWnSxEcV1Q55eXkKCPD8MRkYGOj+iyus0bRpU9WrV8/j51h2drZ+/PFHfo6doZKAtW3bNn311VeKi4vzdUl+76abbtL69es9fo41aNBADzzwgL788ktfl+e37Ha7unXrVqt+ljFdsBYYP368RowYoa5du6p79+6aMWOGcnNzNWrUKF+X5rfuuusuvfPOO/rvf/+rqKgo93UBMTExCgsL83F1/isqKqrUdW0RERGKi4vjerczcO+996pXr1564okndO2112rlypV67bXX9Nprr/m6NL82cOBAPf7442rcuLHOPfdc/fTTT5o+fbpuvvlmX5fmd44dO6bt27e7t3fs2KF169apbt26aty4scaNG6fHHntMLVu2VNOmTTVx4kQ1aNBA11xzje+K9gMV9Wv9+vX15z//WWvXrtXnn3+u4uJi98+yunXrym63+6rsGu9UX68nh9Xg4GDVq1dPrVu3ru5S/cqp+vWBBx7Qddddp4suukgXX3yxFi5cqM8++0xLly71XdFnwtfLG8IaL730ktG4cWPDbrcb3bt3N3744Qdfl+TXJJX5mDNnjq9Lq3VYwt0an332mXHeeecZISEhRps2bYzXXnvN1yX5vezsbGPs2LFG48aNjdDQUKNZs2bG//3f/xmFhYW+Ls3vLFmypMzvqSNGjDAMw1zGfeLEiUZSUpIREhJiXHrppcaWLVt8W7QfqKhfd+zYUe7PsiVLlvi69BrtVF+vJ2MJ98qpTL+++eabRosWLYzQ0FCjQ4cOxieffOK7gs+QzTC4dT0AAAAAWIVrsgAAAADAQoQsAAAAALAQIQsAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAA4A4cPH1ZiYqLS0tIkSUuXLpXNZlNmZuZpn7My55g7d65iY2Pd21OmTFHHjh3d2yNHjtQ111zj3u7bt6/GjRt32jVV1axZszRw4MBqez0AqEkIWQBwFhk5cqRsNptsNpvsdrtatGihadOmqaioyNelnTabzaZPPvnEZ6//+OOPa9CgQUpJSZEk9erVS/v371dMTIxXX/e6667T1q1bK93+o48+0qOPPurFijzdfPPNWrt2rZYvX15trwkANQUhCwDOMldccYX279+vbdu26b777tOUKVP0zDPPnNa5iouL5XK5LK7QN5xOZ5WPycvL05tvvqlbbrnFvc9ut6tevXqy2WxWlldKWFiYEhMTK92+bt26ioqK8mJFnux2u4YNG6YXX3yx2l4TAGoKQhYAnGVCQkJUr149NWnSRHfccYf69eunTz/9VJI0ffp0tWvXThEREUpOTtadd96pY8eOuY8tmaL26aef6pxzzlFISIh27dqlVatW6bLLLlN8fLxiYmLUp08frV271uN1bTab/vGPf+iqq65SeHi42rZtqxUrVmj79u3q27evIiIi1KtXL/32228ex/33v/9V586dFRoaqmbNmmnq1KnukbeS0aM//elPstls7u1THVdSz8yZM3X11VcrIiJCjz/+uI4ePaobbrhBCQkJCgsLU8uWLTVnzpxy+3LBggUKCQnR+eef79538lS/kj778ssv1bZtW0VGRrqD7ql89913at++vUJDQ3X++edr48aNpf4tKuvk6YJHjx7V8OHDVadOHYWHh+vKK6/Utm3bSp2/orqXLl2q7t27KyIiQrGxsbrgggu0c+dO9/MDBw7Up59+qvz8/ErXCQC1ASELAM5yYWFhcjgckqSAgAC9+OKL+uWXX/TWW2/p66+/1t/+9jeP9nl5eXr66af1xhtv6JdfflFiYqJycnI0YsQIffvtt/rhhx/UsmVL9e/fXzk5OR7HPvrooxo+fLjWrVunNm3aaNiwYbr99ts1YcIErV69WoZhaMyYMe72y5cv1/DhwzV27Fj9+uuv+sc//qG5c+fq8ccflyStWrVKkjRnzhzt37/fvX2q40pMmTJFf/rTn7RhwwbdfPPNmjhxon799Vd98cUX2rRpk2bOnKn4+Phy+2758uXq0qXLKfs4Ly9Pzz77rObNm6dvvvlGu3bt0v3333/K4x544AE999xzWrVqlRISEjRw4MDTGnEry8iRI7V69Wp9+umnWrFihQzDUP/+/T3OX1HdRUVFuuaaa9SnTx+tX79eK1as0G233eYxgte1a1cVFRXpxx9/tKRmAPAbBgDgrDFixAhj0KBBhmEYhsvlMhYtWmSEhIQY999/f5ntP/jgAyMuLs69PWfOHEOSsW7dugpfp7i42IiKijI+++wz9z5JxiOPPOLeXrFihSHJePPNN9373n33XSM0NNS9femllxpPPPGEx7nnzZtn1K9f3+O8H3/8sUebyh43btw4jzYDBw40Ro0aVeF7O9GgQYOMm2++2WPfkiVLDEnG0aNHDcM43mfbt293t3nllVeMpKSkcs9bco733nvPve/w4cNGWFiY8f7777vPGxMT435+8uTJRocOHdzbJ/5bG4Zh9OnTxxg7dqxhGIaxdetWQ5Lx3XffuZ8/dOiQERYWZvz73/+uVN2HDx82JBlLly6toIcMo06dOsbcuXMrbAMAtU2Qj7IdAMBHPv/8c0VGRsrpdMrlcmnYsGGaMmWKJOmrr77Sk08+qc2bNys7O1tFRUUqKChQXl6ewsPDJZnX2rRv397jnOnp6XrkkUe0dOlSZWRkqLi4WHl5edq1a5dHuxOPS0pKkiS1a9fOY19BQYGys7MVHR2tn3/+Wd99953HCFRxcXGpmk5W2eO6du3qcdwdd9yhIUOGaO3atbr88st1zTXXqFevXuX2ZX5+vkJDQ8t9vkR4eLiaN2/u3q5fv74yMjJOeVzPnj3dn9etW1etW7fWpk2bTnncqWzatElBQUHq0aOHe19cXFyp81dUd926dTVy5EilpqbqsssuU79+/XTttdeqfv36Hq8VFhamvLy8M64ZAPwJ0wUB4Cxz8cUXa926ddq2bZvy8/P11ltvKSIiQmlpabrqqqvUvn17ffjhh1qzZo1eeeUVSXJPJ5TMX5pPXtRhxIgRWrdunV544QV9//33WrduneLi4jyOk6Tg4GD35yXnKGtfyWIax44d09SpU7Vu3Tr3Y8OGDdq2bVuF4aayx0VERHgcd+WVV2rnzp269957tW/fPl166aUVTuuLj4/X0aNHy32+rPdd8j4Nwzjlcb52qrrnzJmjFStWqFevXnr//ffVqlUr/fDDDx7HHDlyRAkJCdVSLwDUFIxkAcBZJiIiQi1atCi1f82aNXK5XHruuecUEGD+De7f//53pc753Xff6dVXX1X//v0lSbt379ahQ4fOuNbOnTtry5YtZdZbIjg4WMXFxVU+rjwJCQkaMWKERowYod69e+uBBx7Qs88+W2bbTp066V//+leVX6OyfvjhBzVu3FiSuVDF1q1b1bZt2zM+b9u2bd3XSpWM1B0+fFhbtmzROeecU6VzderUSZ06ddKECRPUs2dPvfPOO+6FQH777TcVFBSoU6dOZ1wzAPgTQhYAQJLUokULOZ1OvfTSSxo4cKC+++47zZo1q1LHtmzZUvPmzVPXrl2VnZ2tBx54QGFhYWdc06RJk3TVVVepcePG+vOf/6yAgAD9/PPP2rhxox577DFJ5gqDixcv1gUXXKCQkBDVqVOnUseV93pdunTRueeeq8LCQn3++ecVhprU1FRNmDBBR48eVZ06dc74/Z5s2rRpiouLU1JSkv7v//5P8fHxHjcYPl0tW7bUoEGDNHr0aP3jH/9QVFSUHnroITVs2FCDBg2q1Dl27Nih1157TVdffbUaNGigLVu2aNu2bRo+fLi7zfLly9WsWTOPKYcAcDZguiAAQJLUoUMHTZ8+XU8//bTOO+88vf3223ryyScrdeybb76po0ePqnPnzrrpppt0zz33VOkeTuVJTU3V559/rv/973/q1q2bzj//fD3//PNq0qSJu81zzz2nRYsWKTk52T1iUpnjymK32zVhwgS1b99eF110kQIDA/Xee++V275du3bq3LlzpUf8quqpp57S2LFj1aVLFx04cECfffaZ7Ha7JeeeM2eOunTpoquuuko9e/aUYRhasGBBqSmC5QkPD9fmzZs1ZMgQtWrVSrfddpvuuusu3X777e427777rkaPHm1JvQDgT2yGP0wKBwCghpo/f74eeOABbdy40T3NEtIvv/yiSy65RFu3blVMTIyvywGAasV0QQAAzsCAAQO0bds27d27V8nJyb4up8bYv3+//vnPfxKwAJyVGMkCAAAAAAsxrwEAAAAALETIAgAAAAALEbIAAAAAwEKELAAAAACwECELAAAAACxEyAIAAAAACxGyAAAAAMBChCwAAAAAsBAhCwAAAAAs9P/vYM0mAr8IIgAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
@@ -494,29 +528,17 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 11,
"id": "ec46e1ec-62cb-4a5c-8e4a-717206a1d59f",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Requirement already satisfied: codebleu in /usr/local/lib/python3.8/dist-packages (0.6.1)\n",
- "Requirement already satisfied: tree-sitter<0.22.0,>=0.20.0 in /usr/local/lib/python3.8/dist-packages (from codebleu) (0.21.3)\n",
- "Requirement already satisfied: setuptools>=61.0.0 in /usr/local/lib/python3.8/dist-packages (from codebleu) (65.3.0)\n",
- "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
- "\u001b[0m"
- ]
- }
- ],
+ "outputs": [],
"source": [
"!#pip install codebleu"
]
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 12,
"id": "bb2ad578-3026-4c4e-a9fb-c927f2163f92",
"metadata": {},
"outputs": [
@@ -536,22 +558,25 @@
" result = calc_codebleu(references, predictions, lang=\"java\")\n",
" return result[\"codebleu\"]\n",
"\n",
- "codebleu_baseline = _codebleu(answer_key, BATTERY)\n",
+ "codebleu_baseline = 0.0 #_codebleu(answer_key[:len(BATTERY)], BATTERY)\n",
"\n",
- "codebleu_metrics = []\n",
- "for key, answers in family_answers.items():\n",
- " codebleu_metrics.append(_codebleu(answer_key, answers))"
+ "codebleu_metrics = {}\n",
+ "for idx, family_answers in enumerate(prompt_family_answers):\n",
+ " metric_series = []\n",
+ " for key, answers in family_answers.items():\n",
+ " metric_series.append(_codebleu(answer_key[:len(answers)], answers))\n",
+ " codebleu_metrics[f\"prompt{idx}\"] = metric_series"
]
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 13,
"id": "d47d82e4-4533-4c4c-a749-8b2cf0f5c582",
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
""
]
diff --git a/code2code-trans.ipynb b/code2code-trans.ipynb
new file mode 100644
index 0000000..a5f1706
--- /dev/null
+++ b/code2code-trans.ipynb
@@ -0,0 +1,390 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e540f709-7008-4f6a-a447-a3353bbfaf87",
+ "metadata": {},
+ "source": [
+ "# Common Constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "57085bbc-2f9e-4f37-9bb3-1ff1c3381988",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "CASE_COUNT = 3\n",
+ "META_COUNT = None # number of trials per\n",
+ "PROMPT_INDEX = 0\n",
+ "\n",
+ "BATTERY_DIR = \"./data/CodeXGLUE/Code-Code/code-to-code-trans/data/\"\n",
+ "BATTERY_SRC = os.path.join(BATTERY_DIR, \"test.java-cs.txt.java\")\n",
+ "TRUTH_SRC = os.path.join(BATTERY_DIR, \"test.java-cs.txt.cs\")\n",
+ "OUTPUT_DIR = f\"./output/code2code-trans/prompt{PROMPT_INDEX}\"\n",
+ "\n",
+ "PROMPTS = [\n",
+ " \"// original code.java\\n{prompt}\\n// code.cs version of code.java\\n\",\n",
+ " \"// code.java\\n{prompt}\\n// code.cs\\n\",\n",
+ "]\n",
+ "\n",
+ "PROMPT = PROMPTS[PROMPT_INDEX]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "c3592d92-e7d3-485a-bfb2-921e8c323055",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loaded 3 cases!\n"
+ ]
+ }
+ ],
+ "source": [
+ "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+ "BATTERY = []\n",
+ "with open(BATTERY_SRC, \"r\") as battery:\n",
+ " BATTERY = [\n",
+ " line.strip()\n",
+ " for line\n",
+ " in battery.readlines()[:CASE_COUNT]\n",
+ " ]\n",
+ "print(f\"Loaded {len(BATTERY)} cases!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "be41b613-acfa-4ad9-99a5-778a0555b12e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timehelp import with_progress, display_header\n",
+ "import time\n",
+ "import ipywidgets as widgets\n",
+ "from IPython.display import display"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "63630ff5-96ad-4a42-89cc-8b9214332656",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Importing torch...\n",
+ "Importing HF...\n",
+ "Importing python modules...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Importing torch...\")\n",
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "print(\"Importing HF...\")\n",
+ "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+ "print(\"Importing python modules...\")\n",
+ "from timehelp import time_start, time_end\n",
+ "from model_wrapper import Model, ModelFamily, MultipleChoiceStrategy\n",
+ "import re\n",
+ "print(\"Done!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "120a72c3-76fd-4060-aa8b-c8a4a5e8ecf0",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d1fc129f8ee24dc99392d26a630760f4",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Loading 350M (Salesforce/codegen-350M-multi)
\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# Loading 350M (Salesforce/codegen-350M-multi)\n",
+ "[2024-05-31@05:35:23|model.device] Starting timer.\n",
+ "Configuring torch device...\n",
+ "Using device: cuda:0 aka cuda:0\n",
+ "[2024-05-31@05:35:23|model.device] Time elapsed: 62ms\n",
+ "[2024-05-31@05:35:23|model.tokenizer] Starting timer.\n",
+ "[2024-05-31@05:35:23|model.tokenizer] Time elapsed: 228ms\n",
+ "[2024-05-31@05:35:23|model.model] Starting timer.\n",
+ "Obtaining model...\n",
+ "[2024-05-31@05:35:26|model.model] Time elapsed: 3s 272ms\n",
+ "Opening ./output/code2code-trans/prompt0/codegen1-multi-350M.output...\n",
+ "3 entries found already, skipping that many...\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "94eaaf14382c442286996623277e4a01",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(IntProgress(value=0, description='Progress:', max=3), Label(value='Estimated time remaining: ca…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Done, ~0s elapsed.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "c65dfe3135294291b1fe04bc80a6b344",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Loading 2B (Salesforce/codegen-2B-multi)
\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# Loading 2B (Salesforce/codegen-2B-multi)\n",
+ "[2024-05-31@05:35:26|model.device] Starting timer.\n",
+ "Configuring torch device...\n",
+ "Using device: cuda:0 aka cuda:0\n",
+ "[2024-05-31@05:35:26|model.device] Time elapsed: ~0s\n",
+ "[2024-05-31@05:35:26|model.tokenizer] Starting timer.\n",
+ "[2024-05-31@05:35:27|model.tokenizer] Time elapsed: 169ms\n",
+ "[2024-05-31@05:35:27|model.model] Starting timer.\n",
+ "Obtaining model...\n",
+ "[2024-05-31@05:35:35|model.model] Time elapsed: 8s 602ms\n",
+ "Opening ./output/code2code-trans/prompt0/codegen1-multi-2B.output...\n",
+ "3 entries found already, skipping that many...\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a57faebcd0d24916a3fa6a09dcf28497",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(IntProgress(value=0, description='Progress:', max=3), Label(value='Estimated time remaining: ca…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Done, ~0s elapsed.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "f112223bf454474d83437d74a27f2c13",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Loading 6B (Salesforce/codegen-6B-multi)
\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# Loading 6B (Salesforce/codegen-6B-multi)\n",
+ "[2024-05-31@05:35:35|model.device] Starting timer.\n",
+ "Configuring torch device...\n",
+ "Using device: cuda:0 aka cuda:0\n",
+ "[2024-05-31@05:35:35|model.device] Time elapsed: ~0s\n",
+ "[2024-05-31@05:35:35|model.tokenizer] Starting timer.\n",
+ "[2024-05-31@05:35:36|model.tokenizer] Time elapsed: 126ms\n",
+ "[2024-05-31@05:35:36|model.model] Starting timer.\n",
+ "Obtaining model...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:Some parameters are on the meta device device because they were offloaded to the cpu.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2024-05-31@05:35:55|model.model] Time elapsed: 19s 379ms\n",
+ "Opening ./output/code2code-trans/prompt0/codegen1-multi-6B.output...\n",
+ "1 entries found already, skipping that many...\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "9069875e402a490e9fc7ea1a42c0b078",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(IntProgress(value=0, description='Progress:', max=3), Label(value='Estimated time remaining: ca…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Done, 3min 35s elapsed.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "8189eb04ad5d4718a1bb907540e5afa0",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Loading 16B (Salesforce/codegen-16B-multi)
\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# Loading 16B (Salesforce/codegen-16B-multi)\n",
+ "[2024-05-31@05:39:31|model.device] Starting timer.\n",
+ "Configuring torch device...\n",
+ "Using device: cuda:0 aka cuda:0\n",
+ "[2024-05-31@05:39:31|model.device] Time elapsed: ~0s\n",
+ "[2024-05-31@05:39:31|model.tokenizer] Starting timer.\n",
+ "[2024-05-31@05:39:31|model.tokenizer] Time elapsed: 127ms\n",
+ "[2024-05-31@05:39:31|model.model] Starting timer.\n",
+ "Obtaining model...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "WARNING:root:Some parameters are on the meta device device because they were offloaded to the cpu.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2024-05-31@05:40:11|model.model] Time elapsed: 39s 900ms\n",
+ "Opening ./output/code2code-trans/prompt0/codegen1-multi-16B.output...\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "980e010c358e429897b8122a27e00acc",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(IntProgress(value=0, description='Progress:', max=3), Label(value='Estimated time remaining: ca…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Done, 23min 17s elapsed.\n"
+ ]
+ }
+ ],
+ "source": [
+ "Model.test_battery(\n",
+ " family=ModelFamily.CodeGen1.multi,\n",
+ " family_name=\"codegen1-multi\",\n",
+ " battery=BATTERY,\n",
+ " prompt=PROMPT,\n",
+ " meta_count=META_COUNT,\n",
+ " output_dir=OUTPUT_DIR,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "18c34646-1061-4d69-ab56-a557580e796b",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "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.8.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/codexglue-test.ipynb b/codexglue-test.ipynb
index bb2892c..b3a28c0 100644
--- a/codexglue-test.ipynb
+++ b/codexglue-test.ipynb
@@ -32,7 +32,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 2,
"id": "c9fe02f4-5e7e-4429-ba46-714175bb7549",
"metadata": {},
"outputs": [
@@ -40,134 +40,16 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-14@19:37:33|model.device] Starting timer.\n",
+ "[2024-05-20@21:30:21|model.device] Starting timer.\n",
"Configuring torch device...\n",
"Using device: cuda:0 aka cuda:0\n",
- "[2024-05-14@19:37:33|model.device] Time elapsed: ~0s\n",
- "[2024-05-14@19:37:33|model.tokenizer] Starting timer.\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "6806e79be6e3428d912b48b5e3c68540",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "tokenizer_config.json: 0%| | 0.00/240 [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "4d14c34dbd8c407bbc738d0a6cf04692",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "vocab.json: 0%| | 0.00/798k [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "d89ba2a36c4946b8b2ba1cb2dce292bb",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "merges.txt: 0%| | 0.00/456k [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "95a72f66a90741e8911d8ac523164265",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "tokenizer.json: 0%| | 0.00/2.11M [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "c14ae16cf52a4fcf95a539fc9714f7e5",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "added_tokens.json: 0%| | 0.00/1.00k [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "02af455877ff445492530b9f78e38075",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "special_tokens_map.json: 0%| | 0.00/90.0 [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[2024-05-14@19:37:33|model.tokenizer] Time elapsed: 686ms\n",
- "[2024-05-14@19:37:33|model.model] Starting timer.\n",
+ "[2024-05-20@21:30:21|model.device] Time elapsed: 80ms\n",
+ "[2024-05-20@21:30:21|model.tokenizer] Starting timer.\n",
+ "[2024-05-20@21:30:21|model.tokenizer] Time elapsed: 197ms\n",
+ "[2024-05-20@21:30:21|model.model] Starting timer.\n",
"Obtaining model...\n"
]
},
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "d022b93b21ab4bf7a8f4a6bba85c4437",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "config.json: 0%| | 0.00/999 [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "c6b855ddf3644dbe838e903dffab56a2",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "pytorch_model.bin: 0%| | 0.00/32.2G [00:00, ?B/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
{
"name": "stderr",
"output_type": "stream",
@@ -179,7 +61,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "[2024-05-14@19:48:52|model.model] Time elapsed: 11min 18s\n"
+ "[2024-05-20@21:31:01|model.model] Time elapsed: 39s 342ms\n"
]
}
],
@@ -190,7 +72,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 3,
"id": "be8f686a-19ee-47f4-8f0b-1423fd1862d6",
"metadata": {},
"outputs": [
@@ -210,6 +92,52 @@
"print(fixed)"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "59861102-ce83-4a1e-8810-73457f26cd68",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code.\n",
+ "// Fix the following code:\n",
+ "private void METHOD_1 ( java.lang.Class VAR_1 ) { android.content.Intent intent = new android.content.Intent ( this , VAR_1 ) ; METHOD_2 ( intent ) ; } \n",
+ "\n",
+ "------------------------------\n",
+ "[2024-05-20@22:36:52|model.tokenize] Starting timer.\n",
+ "[2024-05-20@22:36:52|model.tokenize] Time elapsed: 109ms\n",
+ "Generating...\n",
+ "[2024-05-20@22:36:52|model.generate] Starting timer.\n",
+ "[2024-05-20@22:47:35|model.generate] Time elapsed: 10min 43s\n",
+ "private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 ) ; } \n",
+ "\n",
+ "// The buggy code is:\n",
+ "private void METHOD_1 ( java.lang.Class VAR_1 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 ) ; METHOD_2 ( intent ) ; } \n",
+ "private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent =\n"
+ ]
+ }
+ ],
+ "source": [
+ "BUGS2FIX_PROMPT_2 = \"// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code.\\n// Fix the following code:\\n{code}\\n\"\n",
+ "#BUGS2FIX_PROMPT_2 = \"This code has at least one error. Your task is to fix the error(s) and return corrected code. Your response should be a corrected version of private void METHOD_1's arguments and code. The error(s) might be in either the arguments, code, or both. You may not change the method publicity, return type, or name. In your response, do not reference METHOD_2. Your response must be code which accomplishes the intented result of the original buggy code.\\n```\\n{code}\\n```\\n\\n```\"\n",
+ "case_prompt = BUGS2FIX_PROMPT_2.format(code=buggy)\n",
+ "print(case_prompt)\n",
+ "print(\"-\"*30)\n",
+ "tokens = model.generate(case_prompt, time=True, max_new_tokens=128)\n",
+ "print(model.decode(tokens, inputs=model.inputs))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1ce8f974-5024-4c12-a8be-8b7477c50ea1",
+ "metadata": {},
+ "source": [
+ "## Other prompts"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 15,
diff --git a/commit-message.ipynb b/commit-message.ipynb
new file mode 100644
index 0000000..9464934
--- /dev/null
+++ b/commit-message.ipynb
@@ -0,0 +1,756 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "264797cf-c1d0-4041-aa49-842324522403",
+ "metadata": {},
+ "source": [
+ "# Common Constants"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "30c905ae-b80d-4d65-ac58-c39afdcb196a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "CASE_COUNT = 95\n",
+ "META_COUNT = None # number of trials per\n",
+ "COMMIT_PROMPT_INDEX = 0\n",
+ "\n",
+ "BATTERY_DIR = \"./data/commits/\"\n",
+ "BATTERY_SRC = os.path.join(\n",
+ " BATTERY_DIR,\n",
+ " \"commit_message_generation_codisum.json\"\n",
+ ")\n",
+ "OUTPUT_DIR = f\"./output/commit/prompt{COMMIT_PROMPT_INDEX}\"\n",
+ "\n",
+ " # \"{prompt}\\n// \",\n",
+ " # \"// diff of changes\\n{prompt}\\n// summary: \",\n",
+ "COMMIT_PROMPTS = [\n",
+ " \"/* diff of changes\\n{prompt}\\n*/\\n// a summary of the above diff is:\\n// -\"\n",
+ "]\n",
+ "\n",
+ "COMMIT_PROMPT = COMMIT_PROMPTS[COMMIT_PROMPT_INDEX]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "0659b8a4-71d9-4e8c-aba0-d58cb62e60ce",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Loaded 95 cases!\n"
+ ]
+ }
+ ],
+ "source": [
+ "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+ "BATTERY = []\n",
+ "import json\n",
+ "with open(BATTERY_SRC, \"r\") as battery:\n",
+ " test_cases = json.loads(battery.read())[\"cases\"][:CASE_COUNT]\n",
+ " BATTERY = [ obj[\"prompt\"].strip() for obj in test_cases ]\n",
+ "print(f\"Loaded {len(BATTERY)} cases!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0f0a6c8c-a366-48de-8348-5a019cd0222e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timehelp import with_progress, display_header\n",
+ "import time\n",
+ "import ipywidgets as widgets\n",
+ "from IPython.display import display"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "2dec0f80-ce37-4fb0-b706-b9a7e9c06a46",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Importing torch...\n",
+ "Importing HF...\n",
+ "Importing python modules...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Importing torch...\")\n",
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "print(\"Importing HF...\")\n",
+ "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+ "print(\"Importing python modules...\")\n",
+ "from timehelp import time_start, time_end\n",
+ "from model_wrapper import Model, ModelFamily, MultipleChoiceStrategy\n",
+ "import re\n",
+ "print(\"Done!\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "750f419d-f179-42bc-ae6d-1476d01d4299",
+ "metadata": {
+ "jp-MarkdownHeadingCollapsed": true
+ },
+ "source": [
+ "# Generate Output"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "6b9f4ab3-f30e-473c-8e5b-3543e750c791",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "80f9334051b14b188aa069cb7ee1807f",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Loading 350M (Salesforce/codegen-350M-multi)
\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# Loading 350M (Salesforce/codegen-350M-multi)\n",
+ "[2024-05-22@01:30:55|model.device] Starting timer.\n",
+ "Configuring torch device...\n",
+ "Using device: cuda:0 aka cuda:0\n",
+ "[2024-05-22@01:30:55|model.device] Time elapsed: 40ms\n",
+ "[2024-05-22@01:30:55|model.tokenizer] Starting timer.\n",
+ "[2024-05-22@01:30:55|model.tokenizer] Time elapsed: 266ms\n",
+ "[2024-05-22@01:30:55|model.model] Starting timer.\n",
+ "Obtaining model...\n",
+ "[2024-05-22@01:30:58|model.model] Time elapsed: 3s 357ms\n",
+ "Opening ./data/output/commit/prompt0/codegen1-multi-350M.output...\n",
+ "95 entries found already, skipping that many...\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "9a97231c37674cb2abddfb44f26621f5",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(IntProgress(value=0, description='Progress:', max=95), Label(value='Estimated time remaining: c…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Done, ~0s elapsed.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a7eb7662dba545aba3884ac0c45e3875",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Loading 2B (Salesforce/codegen-2B-multi)
\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# Loading 2B (Salesforce/codegen-2B-multi)\n",
+ "[2024-05-22@01:30:59|model.device] Starting timer.\n",
+ "Configuring torch device...\n",
+ "Using device: cuda:0 aka cuda:0\n",
+ "[2024-05-22@01:30:59|model.device] Time elapsed: ~0s\n",
+ "[2024-05-22@01:30:59|model.tokenizer] Starting timer.\n",
+ "[2024-05-22@01:30:59|model.tokenizer] Time elapsed: 154ms\n",
+ "[2024-05-22@01:30:59|model.model] Starting timer.\n",
+ "Obtaining model...\n",
+ "[2024-05-22@01:31:07|model.model] Time elapsed: 8s 761ms\n",
+ "Opening ./data/output/commit/prompt0/codegen1-multi-2B.output...\n",
+ "15 entries found already, skipping that many...\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "bd3e1052c59d4ead81733f730f5d9096",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(IntProgress(value=0, description='Progress:', max=95), Label(value='Estimated time remaining: c…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "!! max size might be exceeded !!\n",
+ "inputs so far: /* diff of changes\n",
+ "diff --git a/core/common/src/main/java/alluxio/collections/IndexDefinition.java b/core/common/src/main/java/alluxio/collections/IndexDefinition.java\n",
+ "index 6eaaade..fdab7ca 100644\n",
+ "--- a/core/common/src/main/java/alluxio/collections/IndexDefinition.java\n",
+ "+++ b/core/common/src/main/java/alluxio/collections/IndexDefinition.java\n",
+ "@@ -11,6 +11,8 @@\n",
+ " \n",
+ " package alluxio.collections;\n",
+ " \n",
+ "+imp [ ... 2244 bytes abbreviated ... ] \n",
+ " private final ConcurrentHashMap