From f36982d5b6c16c33a2c525ad81b2c02826a63e6e Mon Sep 17 00:00:00 2001
From: ConorOBrien-Foxx <conorobrien4god@gmail.com>
Date: Fri, 31 May 2024 02:18:49 -0400
Subject: [PATCH] add outputs to git repo

---
 bleu.py                                       |  16 +-
 bugs2fix.ipynb                                | 273 ++++---
 code2code-trans.ipynb                         | 390 +++++++++
 codexglue-test.ipynb                          | 180 ++---
 commit-message.ipynb                          | 756 ++++++++++++++++++
 model_wrapper.py                              | 218 ++++-
 .../codegen1-multi-2B-0-checkpoint.output     |  15 +
 .../codegen1-multi-350M-0-checkpoint.output   |  15 +
 output/bugs2fix/bugs2fix.tar.gz               | Bin 0 -> 11364 bytes
 .../bugs2fix/old/codegen1-multi-16B-0.output  |  15 +
 .../bugs2fix/old/codegen1-multi-2B-0.output   |  15 +
 .../bugs2fix/old/codegen1-multi-2B-1.output   |  15 +
 .../bugs2fix/old/codegen1-multi-2B-2.output   |  15 +
 .../bugs2fix/old/codegen1-multi-2B-3.output   |  15 +
 .../bugs2fix/old/codegen1-multi-2B-4.output   |  15 +
 .../bugs2fix/old/codegen1-multi-350M-0.output |  15 +
 .../bugs2fix/old/codegen1-multi-350M-1.output |  15 +
 .../bugs2fix/old/codegen1-multi-350M-2.output |  15 +
 .../bugs2fix/old/codegen1-multi-350M-3.output |  15 +
 .../bugs2fix/old/codegen1-multi-350M-4.output |  15 +
 .../bugs2fix/old/codegen1-multi-6B-0.output   |  15 +
 .../bugs2fix/old/codegen1-multi-6B-1.output   |  15 +
 .../bugs2fix/old/codegen1-multi-6B-2.output   |  15 +
 .../bugs2fix/old/codegen1-multi-6B-3.output   |  15 +
 .../bugs2fix/old/codegen1-multi-6B-4.output   |  15 +
 .../codegen1-multi-16B-checkpoint.output      |  95 +++
 .../codegen1-multi-6B-checkpoint.output       |  95 +++
 .../prompt0/codegen1-multi-16B.output         |  95 +++
 .../bugs2fix/prompt0/codegen1-multi-2B.output |  95 +++
 .../prompt0/codegen1-multi-350M.output        |  95 +++
 .../bugs2fix/prompt0/codegen1-multi-6B.output |  95 +++
 .../codegen1-multi-16B-checkpoint.output      |   3 +
 .../codegen1-multi-2B-checkpoint.output       |   0
 .../codegen1-multi-350M-checkpoint.output     |   0
 .../codegen1-multi-6B-checkpoint.output       |  43 +
 .../prompt1/codegen1-multi-16B.output         |  95 +++
 .../bugs2fix/prompt1/codegen1-multi-2B.output |  95 +++
 .../prompt1/codegen1-multi-350M.output        |  95 +++
 .../bugs2fix/prompt1/codegen1-multi-6B.output |  95 +++
 .../codegen1-multi-2B-checkpoint.output       |   3 +
 .../codegen1-multi-350M-checkpoint.output     |   3 +
 .../codegen1-multi-6B-checkpoint.output       |   3 +
 .../prompt0/codegen1-multi-16B.output         |   3 +
 .../prompt0/codegen1-multi-2B.output          |   3 +
 .../prompt0/codegen1-multi-350M.output        |   3 +
 .../prompt0/codegen1-multi-6B.output          |   3 +
 .../codegen1-multi-16B-checkpoint.output      |   0
 .../codegen1-multi-2B-checkpoint.output       |   0
 .../codegen1-multi-350M-checkpoint.output     |   0
 .../codegen1-multi-6B-checkpoint.output       |   0
 .../commit/prompt0/codegen1-multi-16B.output  |  95 +++
 .../commit/prompt0/codegen1-multi-2B.output   |  95 +++
 .../commit/prompt0/codegen1-multi-350M.output |  95 +++
 .../commit/prompt0/codegen1-multi-6B.output   |  95 +++
 render_output.py                              |  72 +-
 timehelp.py                                   |  48 +-
 56 files changed, 3279 insertions(+), 341 deletions(-)
 create mode 100644 code2code-trans.ipynb
 create mode 100644 commit-message.ipynb
 create mode 100644 output/bugs2fix/.ipynb_checkpoints/codegen1-multi-2B-0-checkpoint.output
 create mode 100644 output/bugs2fix/.ipynb_checkpoints/codegen1-multi-350M-0-checkpoint.output
 create mode 100644 output/bugs2fix/bugs2fix.tar.gz
 create mode 100644 output/bugs2fix/old/codegen1-multi-16B-0.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-2B-0.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-2B-1.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-2B-2.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-2B-3.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-2B-4.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-350M-0.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-350M-1.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-350M-2.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-350M-3.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-350M-4.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-6B-0.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-6B-1.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-6B-2.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-6B-3.output
 create mode 100644 output/bugs2fix/old/codegen1-multi-6B-4.output
 create mode 100644 output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
 create mode 100644 output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
 create mode 100644 output/bugs2fix/prompt0/codegen1-multi-16B.output
 create mode 100644 output/bugs2fix/prompt0/codegen1-multi-2B.output
 create mode 100644 output/bugs2fix/prompt0/codegen1-multi-350M.output
 create mode 100644 output/bugs2fix/prompt0/codegen1-multi-6B.output
 create mode 100644 output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
 create mode 100644 output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
 create mode 100644 output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
 create mode 100644 output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
 create mode 100644 output/bugs2fix/prompt1/codegen1-multi-16B.output
 create mode 100644 output/bugs2fix/prompt1/codegen1-multi-2B.output
 create mode 100644 output/bugs2fix/prompt1/codegen1-multi-350M.output
 create mode 100644 output/bugs2fix/prompt1/codegen1-multi-6B.output
 create mode 100644 output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
 create mode 100644 output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
 create mode 100644 output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
 create mode 100644 output/code2code-trans/prompt0/codegen1-multi-16B.output
 create mode 100644 output/code2code-trans/prompt0/codegen1-multi-2B.output
 create mode 100644 output/code2code-trans/prompt0/codegen1-multi-350M.output
 create mode 100644 output/code2code-trans/prompt0/codegen1-multi-6B.output
 create mode 100644 output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
 create mode 100644 output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
 create mode 100644 output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
 create mode 100644 output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
 create mode 100644 output/commit/prompt0/codegen1-multi-16B.output
 create mode 100644 output/commit/prompt0/codegen1-multi-2B.output
 create mode 100644 output/commit/prompt0/codegen1-multi-350M.output
 create mode 100644 output/commit/prompt0/codegen1-multi-6B.output

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\"<h1 style='font-weight: bold;'>{text}</h1>\")\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": [
        "<Figure size 1000x600 with 1 Axes>"
       ]
@@ -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": [
        "<Figure size 1000x600 with 1 Axes>"
       ]
@@ -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": [
        "<Figure size 1000x600 with 1 Axes>"
       ]
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=\"<h1 style='font-weight: bold;'>Loading 350M (Salesforce/codegen-350M-multi)</h1>\")"
+      ]
+     },
+     "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=\"<h1 style='font-weight: bold;'>Loading 2B (Salesforce/codegen-2B-multi)</h1>\")"
+      ]
+     },
+     "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=\"<h1 style='font-weight: bold;'>Loading 6B (Salesforce/codegen-6B-multi)</h1>\")"
+      ]
+     },
+     "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=\"<h1 style='font-weight: bold;'>Loading 16B (Salesforce/codegen-16B-multi)</h1>\")"
+      ]
+     },
+     "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=\"<h1 style='font-weight: bold;'>Loading 350M (Salesforce/codegen-350M-multi)</h1>\")"
+      ]
+     },
+     "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=\"<h1 style='font-weight: bold;'>Loading 2B (Salesforce/codegen-2B-multi)</h1>\")"
+      ]
+     },
+     "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<Object, T> mIndexMap;\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/src/edu/stanford/nlp/parser/tools/ChangeBaseParserWeight.java b/src/edu/stanford/nlp/parser/tools/ChangeBaseParserWeight.java\n",
+      "index f239265..d6eb5fe 100644\n",
+      "--- a/src/edu/stanford/nlp/parser/tools/ChangeBaseParserWeight.java\n",
+      "+++ b/src/edu/stanford/nlp/parser/tools/ChangeBaseParserWeight.java\n",
+      "@@ -11,6 +11,8 @@ import edu.stanford.nlp.parser.lexparser.LexicalizedParser [ ... 1037 bytes abbreviated ... ] 11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/src/main/java/water/api/SummaryPage.java b/src/main/java/water/api/SummaryPage.java\n",
+      "index e24810b9b..ff98ba352 100644\n",
+      "--- a/src/main/java/water/api/SummaryPage.java\n",
+      "+++ b/src/main/java/water/api/SummaryPage.java\n",
+      "@@ -56,8 +56,8 @@ public class SummaryPage extends Request {\n",
+      "     Response r = Response.done(res);\n",
+      "     r.setBuilder(ROOT_OBJECT, new Builder() {\n",
+      "       @Ov [ ... 1479 bytes abbreviated ... ] 8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java b/src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java\n",
+      "index 9bb2b69..6e2493e 100644\n",
+      "--- a/src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java\n",
+      "+++ b/src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java\n",
+      "@@ - [ ... 1129 bytes abbreviated ... ] 1.53 -1.1.1.54 -1.1.1.55 -1.1.1.56 -1.1.1.57 -1.1.1.58 -1.1.1.59 -1.1.1.60 -1.1.1.61 -1.1.1.62 -1.1.\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "index 6898c93..a0e3346 100644\n",
+      "--- a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "+++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "@@ -35,6 +35,8 @@ import org.jetbrains.jet.cli.common.messages.CompilerMessageLocati [ ... 1842 bytes abbreviated ... ] onment(disposable, configuration);\n",
+      "     }\n",
+      " \n",
+      "     @NotNull\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/java/org/apache/catalina/ha/tcp/SimpleTcpCluster.java b/java/org/apache/catalina/ha/tcp/SimpleTcpCluster.java\n",
+      "index d38a7561c..68fab153c 100644\n",
+      "--- a/java/org/apache/catalina/ha/tcp/SimpleTcpCluster.java\n",
+      "+++ b/java/org/apache/catalina/ha/tcp/SimpleTcpCluster.java\n",
+      "@@ -426,8 +426,7 @@ public class SimpleTcpCluster extends LifecycleMBeanBase\n",
+      "             log.warn(sm.ge [ ... 1152 bytes abbreviated ... ] +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/src/main/java/org/bukkit/event/block/BlockFromToEvent.java b/src/main/java/org/bukkit/event/block/BlockFromToEvent.java\n",
+      "index ab1927de..09bde18c 100644\n",
+      "--- a/src/main/java/org/bukkit/event/block/BlockFromToEvent.java\n",
+      "+++ b/src/main/java/org/bukkit/event/block/BlockFromToEvent.java\n",
+      "@@ -9,14 +9,14 @@ import org.bukkit.event.Event;\n",
+      "  * Holds information for events with [ ... 1371 bytes abbreviated ... ] 8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/bundles/binding/org.openhab.binding.zwave/src/main/java/org/openhab/binding/zwave/internal/protocol/commandclass/ZWaveAlarmSensorCommandClass.java b/bundles/binding/org.openhab.binding.zwave/src/main/java/org/openhab/binding/zwave/internal/protocol/commandclass/ZWaveAlarmSensorCommandClass.java\n",
+      "index bb03efc..8282eee 100644\n",
+      "--- a/bundles/binding/org.openhab.binding. [ ... 3575 bytes abbreviated ... ] import org.slf4j.Logger;\n",
+      " import org.slf4j.LoggerFactory;\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/openid/src/main/java/org/springframework/security/openid/OpenID4JavaConsumer.java b/openid/src/main/java/org/springframework/security/openid/OpenID4JavaConsumer.java\n",
+      "index e9b4f8009..1a803af10 100644\n",
+      "--- a/openid/src/main/java/org/springframework/security/openid/OpenID4JavaConsumer.java\n",
+      "+++ b/openid/src/main/java/org/springframework/security/openid/OpenID4JavaConsum [ ... 1459 bytes abbreviated ... ] 7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,\n",
+      "Done, 6min 39s elapsed.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6e270c767cdb44eebca35554d1fc65be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HTML(value=\"<h1 style='font-weight: bold;'>Loading 6B (Salesforce/codegen-6B-multi)</h1>\")"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Loading 6B (Salesforce/codegen-6B-multi)\n",
+      "[2024-05-22@01:37:47|model.device] Starting timer.\n",
+      "Configuring torch device...\n",
+      "Using device: cuda:0 aka cuda:0\n",
+      "[2024-05-22@01:37:47|model.device] Time elapsed: ~0s\n",
+      "[2024-05-22@01:37:47|model.tokenizer] Starting timer.\n",
+      "[2024-05-22@01:37:47|model.tokenizer] Time elapsed: 309ms\n",
+      "[2024-05-22@01:37:47|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-22@01:39:13|model.model] Time elapsed: 1min 25s\n",
+      "Opening ./data/output/commit/prompt0/codegen1-multi-6B.output...\n",
+      "15 entries found already, skipping that many...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4fe64dddcf894b95b3c2ab8dbfe7709c",
+       "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<Object, T> mIndexMap;\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "index 6898c93..a0e3346 100644\n",
+      "--- a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "+++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "@@ -35,6 +35,8 @@ import org.jetbrains.jet.cli.common.messages.CompilerMessageLocati [ ... 1842 bytes abbreviated ... ] onment(disposable, configuration);\n",
+      "     }\n",
+      " \n",
+      "     @NotNull\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/bundles/binding/org.openhab.binding.zwave/src/main/java/org/openhab/binding/zwave/internal/protocol/commandclass/ZWaveAlarmSensorCommandClass.java b/bundles/binding/org.openhab.binding.zwave/src/main/java/org/openhab/binding/zwave/internal/protocol/commandclass/ZWaveAlarmSensorCommandClass.java\n",
+      "index bb03efc..8282eee 100644\n",
+      "--- a/bundles/binding/org.openhab.binding. [ ... 3575 bytes abbreviated ... ] import org.slf4j.Logger;\n",
+      " import org.slf4j.LoggerFactory;\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "Done, 50min 33s elapsed.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5f8f53c8c2fc446381e6388071933a4b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HTML(value=\"<h1 style='font-weight: bold;'>Loading 16B (Salesforce/codegen-16B-multi)</h1>\")"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# Loading 16B (Salesforce/codegen-16B-multi)\n",
+      "[2024-05-22@02:29:47|model.device] Starting timer.\n",
+      "Configuring torch device...\n",
+      "Using device: cuda:0 aka cuda:0\n",
+      "[2024-05-22@02:29:47|model.device] Time elapsed: ~0s\n",
+      "[2024-05-22@02:29:47|model.tokenizer] Starting timer.\n",
+      "[2024-05-22@02:29:47|model.tokenizer] Time elapsed: 336ms\n",
+      "[2024-05-22@02:29:47|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-22@02:30:27|model.model] Time elapsed: 39s 513ms\n",
+      "Opening ./data/output/commit/prompt0/codegen1-multi-16B.output...\n",
+      "15 entries found already, skipping that many...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1e0414062ba1493ea643da1fdd45e54d",
+       "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<Object, T> mIndexMap;\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "index 6898c93..a0e3346 100644\n",
+      "--- a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "+++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java\n",
+      "@@ -35,6 +35,8 @@ import org.jetbrains.jet.cli.common.messages.CompilerMessageLocati [ ... 1842 bytes abbreviated ... ] onment(disposable, configuration);\n",
+      "     }\n",
+      " \n",
+      "     @NotNull\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "!! max size might be exceeded !!\n",
+      "inputs so far: /* diff of changes\n",
+      "diff --git a/bundles/binding/org.openhab.binding.zwave/src/main/java/org/openhab/binding/zwave/internal/protocol/commandclass/ZWaveAlarmSensorCommandClass.java b/bundles/binding/org.openhab.binding.zwave/src/main/java/org/openhab/binding/zwave/internal/protocol/commandclass/ZWaveAlarmSensorCommandClass.java\n",
+      "index bb03efc..8282eee 100644\n",
+      "--- a/bundles/binding/org.openhab.binding. [ ... 3575 bytes abbreviated ... ] import org.slf4j.Logger;\n",
+      " import org.slf4j.LoggerFactory;\n",
+      "*/\n",
+      "// a summary of the above diff is:\n",
+      "// -\n",
+      "Warning: Model returned no output (prompt may have been too large)\n",
+      "Done, 5hr 4min 50s elapsed.\n"
+     ]
+    }
+   ],
+   "source": [
+    "Model.test_battery(\n",
+    "    family=ModelFamily.CodeGen1.multi,\n",
+    "    family_name=\"codegen1-multi\",\n",
+    "    battery=BATTERY,\n",
+    "    prompt=COMMIT_PROMPT,\n",
+    "    meta_count=META_COUNT,\n",
+    "    output_dir=OUTPUT_DIR,\n",
+    "\n",
+    "    max_size=800,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4addc95-67ae-44ff-8e6e-6ce1a3f10ba5",
+   "metadata": {},
+   "source": [
+    "# Interpret Output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "33696339-2ba0-4676-8c17-6de39f3d09da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from render_output import OutputRenderer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4eedca34-8cd2-4c94-a0ba-cb6cc82af4b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(BATTERY_SRC, \"r\") as truth_file:\n",
+    "    test_cases = json.loads(truth_file.read())[\"cases\"][:CASE_COUNT]\n",
+    "    answer_key = [ obj[\"truth\"].strip() for obj in test_cases ]\n",
+    "\n",
+    "prompt_family_answers = []\n",
+    "for prompt_index in range(len(COMMIT_PROMPTS)):\n",
+    "    output_dir = f\"./data/output/commit/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)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8c970eb-9447-4e78-9ac6-8493523ec8f3",
+   "metadata": {},
+   "source": [
+    "## Metric: BLEU"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "eaaf82d9-c966-4659-8914-516ca3030de4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bleu import _bleu\n",
+    "b_moses_metrics = {}\n",
+    "b_moses_baseline = 0.0\n",
+    "\n",
+    "def b_moses(ref, trans):\n",
+    "    return _bleu(ref, trans, smooth=False, lower=False)\n",
+    "\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(b_moses(answer_key[:len(answers)], answers))\n",
+    "    b_moses_metrics[f\"prompt{idx}\"] = metric_series\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e2f3c3a2-8615-4887-a7d8-969087a67d29",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# AKA: BLEU no smoothing\n",
+    "b_moses_renderer = OutputRenderer(\n",
+    "    baseline=b_moses_baseline,\n",
+    "    metric=\"B-Moses\",\n",
+    ")\n",
+    "\n",
+    "b_moses_renderer.render(ys=b_moses_metrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a719e480-7341-4042-9175-33c3ec7484fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b_norm_metrics = {}\n",
+    "b_norm_baseline = 0.0\n",
+    "\n",
+    "def b_norm(ref, trans):\n",
+    "    return _bleu(ref, trans, smooth=True, lower=True)\n",
+    "\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(b_norm(answer_key[:len(answers)], answers))\n",
+    "    b_norm_metrics[f\"prompt{idx}\"] = metric_series"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "1a51ab67-680a-42e2-9cd9-7e665cb76dd2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# AKA: BLEU no smoothing\n",
+    "b_norm_renderer = OutputRenderer(\n",
+    "    baseline=b_norm_baseline,\n",
+    "    metric=\"B-Norm\",\n",
+    ")\n",
+    "\n",
+    "b_norm_renderer.render(ys=b_norm_metrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "ac9e8acc-bbf4-4add-b24d-83fd01f60728",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# AKA: BLEU no smoothing\n",
+    "b_combined_renderer = OutputRenderer(\n",
+    "    baseline=b_norm_baseline,\n",
+    "    metric=\"Metric\",\n",
+    ")\n",
+    "\n",
+    "b_combined_renderer.render(\n",
+    "    ys={\n",
+    "        \"B-Moses\": b_moses_metrics[\"prompt0\"],\n",
+    "        \"B-Norm\": b_norm_metrics[\"prompt0\"],\n",
+    "    },\n",
+    "    y_max=0.1\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef5cc3a5-a2a6-48a1-87f1-c0c1e133acc6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ad6b6eb-9372-46d8-9ec3-9b3e0822af65",
+   "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/model_wrapper.py b/model_wrapper.py
index 1bdea2d..375e940 100644
--- a/model_wrapper.py
+++ b/model_wrapper.py
@@ -1,8 +1,9 @@
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
-from timehelp import time_start, time_end
+from timehelp import time_start, time_end, display_header, with_progress
 import re
 import gc
+import os
 from math import exp
 from enum import Enum
 
@@ -40,23 +41,65 @@ def abbreviate_string(s, start=30, end=30):
         return s
     return s[:start] + f" [ ... {len(s) - start - end} bytes abbreviated ... ] " + s[-end:]
 
+
+# Note: Aggressive use of `del` to try and coax CUDA memory back to be freed.
+# Note: This is probably not necessary. I think I was just running out of memory
+# because my max_size for generate_until was too large to prevent CUDA memory overflow
+# for larger models - presumably cuz the tensors are larger? I have no idea tbh.
+# max=1000 worked fine for 2B but not 6B; likewise the max=500 might not work for
+# 16B, but I will cross that bridge when I get there.
+
+# MAJOR TODO: truncate all existing output files to 500 tokens for consistency in grading!
+
 def find_contiguous_subtensor_index(a, b):
-    if b.numel() == 0:  # An empty tensor is always a sublist
+    if b.numel() == 0:
         return 0
     if b.numel() > a.numel():
         return None
-    if b.numel() == 1:  # Special case when b has only one element
+    if b.numel() == 1:
         indices = torch.nonzero(a == b.item(), as_tuple=False)
         if indices.numel() > 0:
-            return indices[0].item()
+            item = indices[0].item()
         else:
-            return None
+            item = None
+        del indices
+        return item
     
-    for i in range(a.numel() - b.numel() + 1):
-        if torch.equal(a[i:i + b.numel()], b):
+    for i in range(start, a.numel() - b.numel() + 1):
+        tensor_slice = a[i:i + b.numel()]
+        if torch.equal(tensor_slice, b):
+            del tensor_slice
             return i
+        del tensor_slice
+        
     return None
 
+def find_contiguous_subtensor_index_after_content(a, b):
+    if b.numel() == 0:
+        return 0
+    if b.numel() > a.numel():
+        return None
+    if b.numel() == 1:
+        indices = torch.nonzero(a == b.item(), as_tuple=False)
+        if indices.numel() > 0:
+            index_pointer = 0
+            # ignore found instances at the head of the search range
+            while index_pointer < indices.numel() and indices[index_pointer].item() == index_pointer:
+                index_pointer += 1
+            
+            if index_pointer >= indices.numel():
+                item = None
+            else:
+                item = indices[index_pointer].item()
+            
+            del indices
+            return item
+        else:
+            del indices
+            return None
+    
+    assert False, "Have not yet handled multi-token needle for find_contiguous_subtensor_index_after_content"
+
 class Model:
     CACHE_DIR = "/workspaces/emergent-capabilities/datax"
     DEFAULT_SOFTMAX = torch.nn.Softmax(dim=-1)
@@ -74,16 +117,51 @@ def clean_cache_dir(confirm=False):
     @staticmethod
     def prob_from_logit(logit):
         assert false, "Do not use this function"
-        # TODO: check if this is the correct way to scale CodeGen logits;
-        # it stands to reason that the falloff could be steeper or less steep
-
-        # code from
-        # https://sebastiansauer.github.io/convert_logit2prob/
-        odds = exp(logit)
-        prob = odds / (1 + odds)
-        return prob
 
     
+    @staticmethod
+    def test_battery(family, family_name, battery, prompt, output_dir, meta_count=None, *args, **kwargs):
+        # e.g. family=ModelFamily.CodeGen1.multi
+        for key, model_name in family.items():
+            display_header(f"Loading {key} ({model_name})")
+            torch.cuda.empty_cache()
+            model = Model(model_name)
+            model.configure(time=True)
+            model.verbose = False
+
+            @with_progress(len(battery))
+            def iterate(output_file, *, step=None):
+                test_case = battery[step]
+                specific_prompt = prompt.format(prompt=test_case)
+                output = model.generate_until(specific_prompt, stops=["\n"], **kwargs)
+                
+                if output is None:
+                    print("Warning: Model returned no output (prompt may have been too large)")
+                    decoded = ""
+                else:
+                    decoded = model.decode(output).strip()
+                
+                output_file.write(decoded + "\n")
+        
+                del model.inputs, output
+        
+            for i in range(meta_count or 1):
+                if meta_count is None:
+                    base_name = f"{family_name}-{key}.output"
+                else:
+                    base_name = f"{family_name}-{key}-mc{i}.output"
+                output_path = os.path.join(output_dir, base_name)
+                print(f"Opening {output_path}...")
+                with open(output_path, "a+") as output_file: 
+                    # iterate(output_file)
+                    output_file.seek(0)
+                    to_skip = len(output_file.readlines())
+                    if to_skip > 0:
+                        print(f"{to_skip} entries found already, skipping that many...")
+                    iterate(output_file, skip=to_skip)
+        
+            model.free()
+    
     def __init__(self, name, cache_dir=None, device_name=None, verbose=True, softmax=None):
         self.verbose = verbose
         self.name = name
@@ -93,7 +171,8 @@ def __init__(self, name, cache_dir=None, device_name=None, verbose=True, softmax
         self.device_name = device_name
         self.device = None
         self.softmax = softmax or Model.DEFAULT_SOFTMAX
-
+        self._tokenized_eos_token = None
+    
     
     def yap(self, *args, **kwargs):
         if not self.verbose:
@@ -117,12 +196,23 @@ def configure_device(self):
     
     def configure_tokenizer(self):
         assert self.tokenizer is None, "Tokenizer already exists, cannot re-configure"
-        self.tokenizer = AutoTokenizer.from_pretrained(self.name, cache_dir=self.cache_dir, device_map=self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            self.name,
+            cache_dir=self.cache_dir,
+            device_map=self.device,
+            # padding_side="left",
+        )
         # for padding; doesn't quite work, though
         self.tokenizer.pad_token = self.tokenizer.eos_token
         # alternative suggestion for padding:
         # tokenizer.add_special_tokens({'pad_token': '[PAD]'})
 
+    @property
+    def tokenized_eos_token(self):
+        if self._tokenized_eos_token is None:
+            self._tokenized_eos_token = self.tokenize(self.tokenizer.eos_token)["input_ids"]
+
+        return self._tokenized_eos_token
     
     def configure_model(self, force_device=False):
         assert self.model is None, "Model already exists, cannot re-configure"
@@ -180,9 +270,9 @@ def model_no_grad(self, *args, **kwargs):
         return value
 
     # e.g., max_length=128
-    def generate(self, inputs, time=False, *args, **kwargs):
+    def generate(self, inputs, time=False, auto_tokenize=True, *args, **kwargs):
         if isinstance(inputs, str):
-            # self.yap("Tokenizing input prompt...")
+            assert auto_tokenize, "Cannot generate given string input prompt when auto_tokenize=False"
             inputs = self.tokenize(inputs, time=time)
         self.inputs = inputs
 
@@ -198,14 +288,23 @@ def generate(self, inputs, time=False, *args, **kwargs):
         return sample
 
     # max_size default set comfortably below model max (2048)
-    def generate_until(self, inputs, stops=[], per_step=50, max_size=1000, time=False, truncate=True, *args, **kwargs):
+    def generate_until(
+        self,
+        inputs,
+        stops=[],
+        per_step=50,
+        # TODO: configure max_size based on model family?
+        max_size=500,
+        truncate=True,
+        auto_tokenize=True,
+        time=False,
+        *args, **kwargs
+    ):
         if isinstance(inputs, str):
-            # self.yap("Tokenizing input prompt...")
+            assert auto_tokenize, "Cannot generate given string input prompt when auto_tokenize=False"
             inputs = self.tokenize(inputs, time=time)
-        original_inputs = inputs
         
-        if self.tokenizer.eos_token not in stops:
-            stops.append(self.tokenizer.eos_token)
+        original_inputs = inputs
 
         stops = [
             self.tokenize(stop)["input_ids"] if isinstance(stop, str)
@@ -216,10 +315,12 @@ def generate_until(self, inputs, stops=[], per_step=50, max_size=1000, time=Fals
         base_size = inputs["input_ids"].size(dim=1)
         
         tokens = None
+        # it = 0
         while True:
-            # print("Step...")
-            # print(inputs)
             next_size = inputs["input_ids"].size(dim=1) + per_step
+            # print("GEN ITER", it, next_size, "!!!!!!!!")
+            # it += 1
+            
             if next_size > max_size:
                 print("!! max size might be exceeded !!")
                 print("inputs so far:", abbreviate_string(
@@ -227,51 +328,76 @@ def generate_until(self, inputs, stops=[], per_step=50, max_size=1000, time=Fals
                     start=400,
                     end=100
                 ))
-                print("next outputs:", self.decode(output))
                 break
                 
-            output = self.generate(inputs, max_new_tokens=per_step)
+            output = self.generate(inputs, max_new_tokens=per_step, auto_tokenize=False)
             # remove input given so far from output 
-            output = output[:, inputs["input_ids"].size(dim=1):]
+            output_trimmed = output[:, inputs["input_ids"].size(dim=1):]
+            del output
+            output = output_trimmed
             
             if tokens is None:
                 tokens = output
             else:
-                tokens = torch.cat((tokens, output), dim=1)
+                tokens_together = torch.cat((tokens, output), dim=1)
+                del tokens
+                tokens = tokens_together
 
+            # effectively left-strips the input of stop subsequences before searching
+            # for a stop index
             stop_index = next(
                 (
                     inner_index
                     for stop in stops
-                    if (inner_index := find_contiguous_subtensor_index(tokens[0], stop)) is not None
+                    if (inner_index :=
+                        find_contiguous_subtensor_index_after_content(
+                            tokens[0],
+                            stop,
+                        )
+                    ) is not None
                 ),
                 None
             )
+            ###print("Stop index (before eos search)", stop_index)
+
+            # if the stop was not found, look for the eos token to make sure we
+            # do not generate past it
+            if stop_index is None:
+                stop_index = find_contiguous_subtensor_index(
+                    tokens[0],
+                    self.tokenized_eos_token
+                )
+
+                ###print("Stop index (after eos search)", stop_index)
             
-            # print("STOP_INDEX:", stop_index, stop_found)
-            # print(tokens)
             if stop_index is not None:
                 # truncate to stop index
-                # print("TRUNC")
-                tokens = tokens[:, :stop_index]
-                # print(tokens)
+                ###print("Tokens before truncation", tokens)
+                tokens_truncated = tokens[:, :stop_index]
+                del tokens
+                tokens = tokens_truncated
                 break
             
-            inputs = self.concatenate_tokens(inputs, output)
+            next_inputs = self.concatenate_tokens(inputs, output)
+            del inputs, output
+            inputs = next_inputs
 
         # free running input; we don't need it anymore
         del inputs
+        for _ in range(len(stops)):
+            del stops[0]
 
         self.inputs = original_inputs
         if truncate:
             return tokens
         else:
-            return torch.cat((original_inputs["input_ids"], tokens), dim=1)
+            result = torch.cat((original_inputs["input_ids"], tokens), dim=1)
+            del tokens
+            return result
     
     def multiple_choice_token(self, inputs, targets, time=False):
         assert len(targets) >= 2, "Expected at least 2 targets" 
         if isinstance(inputs, str):
-            # self.yap("Tokenizing input prompt...")
             inputs = self.tokenize(inputs, time=time)
 
         if time:
@@ -306,10 +432,14 @@ def append_token(self, source, extra):
         extra_token = torch.tensor([[extra]], device=self.device)
         extra_attention = torch.tensor([[1]], device=self.device)
         
-        return {
+        result = {
             "input_ids": torch.cat((input_ids, extra_token), dim=1),
             "attention_mask": torch.cat((attention_mask, extra_attention), dim=1),
         }
+        
+        del extra_token, extra_attention
+
+        return result
 
     
     def concatenate_tokens(self, source, extra):
@@ -319,10 +449,14 @@ def concatenate_tokens(self, source, extra):
         
         extra_attention = torch.tensor([[1] * extra.size(dim=1)], device=self.device)
         
-        return {
+        result = {
             "input_ids": torch.cat((input_ids, extra), dim=1),
             "attention_mask": torch.cat((attention_mask, extra_attention), dim=1),
         }
+
+        del extra_attention
+
+        return result
         
     
     def _multiple_choice_prompts_first_branch(self, input_tokens, target_tokens, time=False):
@@ -564,4 +698,4 @@ def free(self):
         # TODO: use a `with` context
         del self.model, self.tokenizer, self.device
         gc.collect()
-        torch.cuda.empty_cache()
\ No newline at end of file
+        torch.cuda.empty_cache()
diff --git a/output/bugs2fix/.ipynb_checkpoints/codegen1-multi-2B-0-checkpoint.output b/output/bugs2fix/.ipynb_checkpoints/codegen1-multi-2B-0-checkpoint.output
new file mode 100644
index 0000000..ac749ca
--- /dev/null
+++ b/output/bugs2fix/.ipynb_checkpoints/codegen1-multi-2B-0-checkpoint.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ;
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/.ipynb_checkpoints/codegen1-multi-350M-0-checkpoint.output b/output/bugs2fix/.ipynb_checkpoints/codegen1-multi-350M-0-checkpoint.output
new file mode 100644
index 0000000..50495c3
--- /dev/null
+++ b/output/bugs2fix/.ipynb_checkpoints/codegen1-multi-350M-0-checkpoint.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/bugs2fix.tar.gz b/output/bugs2fix/bugs2fix.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b461de4d96c97e33fd5f1b73697df0aee3d30fca
GIT binary patch
literal 11364
zcma)?Wl$aOvhH!0;O_43?gR}k!9BPvAUF$m5AGh^-Q6961ZUwA+*vpOea^nM>zuk(
zcdF*?r++=u{nkv?eCTPiXatCV9ncqsK5qNGNqN1u4C$H|%l!Ll(&{Pa)HB*i${rd&
zMwhKTYFk`?rZBtNJ6eo0jdSfQ-fW_i8=>Z3=U1gUus5G!ASBu3&u`k?q5Cza8*f*=
zkcn*UEz|ufuUPLr-~_jTXW$15@qfs0P~YDOlcD8VF7p!6)NFukyT%%<qn~|2m3SRs
z@meC$kK|_=KfT$Tv|p`@TDJ{VFWdKrt(93DsGpSKzw_hskMy3WE!UBNyDBOu=|EmQ
zr^(k>+u+6Bv+?+VTdS^$Mji0WRjvPc<D~cf>1F9mZetMT>(NmF-LTx6Q&qk_a@09<
z*0Ph#{O$RuP5}7uwYLRFY#jIg)Pq9<$5p++?=)RZiRt}%Yx?53DI<b$+wcC=N$jnp
zdQx#K25)E3YosmFH-qPd?xP`Zd@}RbLH*IqMV{sRgT%b1`;lepqLcMKKrb07Afn~Q
zvvqop<i={tAVM4G0B3(~I0*Zm_I9lzx7vHVDc~S0z)j0$m2AZ{PH?tyS*tN*b5Km_
zHMLj#jJwh0?zQ#^*>5%KeE-4evtw(oPhDE@mATVtf9an9G@Dpb&<`@5Xe*C#q4bzk
z>Vh<u+C!)5S^iOd7XqITI)Pj-w$2Q;EG@3Q#8);>{WI%@tmzvj%GS##ys1pKnRTGm
zQl7-bxu-&yWo)3Zxb$EY_p7gH-pW3K@AR1!Z?4smXV=0-gM)AY2Ae=|_R-0CSfiRh
zN@p+!4k((ms3<L#jTHtqLFc#^ZjaSZ9Q^wrYK)Il+jypoC7d`>F#37J^5N<_%cVBs
zvFCZW(lhy`^dfFs8Xm|2wfHLY&<~ywC9lmlw#mzjvrZG4fs6L``n%N(cdI{N`@<21
zU0My6e`yZh$y?8AFB1Hu%!3c6oZuEce-%nWja%z7s)c{5!XdbreH>rv%2D~ukRkDF
z|Hnf~5vheY`LJsMR?|27rw)6|zwg*gg|twU@qvFrbfV|uA$-<2(b!kIee8?HTd2r`
zfzqi_OXegZJ$?ZtSNzzYm(3_0;$u{v?*vo*VJPw&OP~!ap7z3+&*Ac9Qr-cav{FMa
zJLVipmBS9oqEt>eE7j32_vz`l6~10R8f@IM`z-lTf<5NTC=4*$65d*mex@3ZF3xT)
z_IN!6s!n$Ny%!9Ud05Mm29PB=Tkz_l<MYhIj|#DB_dd|k4sK%<$0Ca7(_`S?dYoN=
z%1g)}d_Ve%G>YZX2MG0RzKrde5L-49?%Nq_t)Efo$83(+V*;gz&jIgg^vg$rM@~}L
zz(}^x$`5CnyX<UG?dVb;1nQgS-GFrjCO2pq{Rmt`r%spd*_$1gruZbe#XtL1VXS*+
z@XHV4$xK81)#FOZ`yZt|L(q4iDVrtlTs^U_9$Q35X&9Oy?2D45t}l$7lqfiK->}r%
z&pApySJgiJq<SX9KYr{_^BtjbfL90<5eo@C+(ZaS72g?-Ei4lt;?kjG5nDj#y|~4@
z7rNm$6FKcj5fe8?K1wu$dZ0By(McR(znZ<?Q;!R9bh8oa+WwLpsasuKv!&T>(>Dsn
zvKtA9NiazWn#7&aYvscO804?w>#nGGtxcf{t{jb;>A}Sk+s3$_(4|`6{i16~3`^y!
zyhayf5grduzc@Uj?>BSGd~vwSI{+)~7NX}QFevDg-?W8rbp&#)<Ihq_g}{d|^(#iG
zJZxf7s)9*#M3UH?E%UYI<Kp=EZJOH}5BxJSI^rK?*($e}lfU+*R?B8=>1}Ji%&h69
zVho3-Fb2qYc_^Xk56Z8smwdwzh-tibX9=5gW^|5}6I#R<GL3`s!MOW4JMrzBIONkL
zX$51i>wM7feEmdXRz2C3ZSmDVDSrIGwq5ELO8PTV5fidW<SMcJw!EKlrOvebW{uLP
z!J~5bOdBS|JOlMXMXh1WZgyr{y;I&YWJeV~ND`}`?|pj<Nq8^E-?kWsr0Zc+e^vqA
z*T>54Ro7-E#k0CB1cHjMQ|zQHrazF9pnt&;qPtM_I^5j1Wtb+Xw!|Ix(<F>EG{ZF>
zWbDGCpoEJY%f23?q!Q{|<KAd39Lsaze04Fgz2<XU3WZ@q{rX_l)v-_wDIgYVJWoub
zG`)JpB4zctHQ{rQ9gw=S$gqIGX~D`MnB|dD5W~APy>s3y!}v_-(xXZ4*UCciL%o_;
zUzB;%^+sjseR#Rb6L!aMlu{OlQXDfKft7SnmC@5)sPQap_P00?1`%6H<gxEwSnB1>
zPUwp6T2flvHA+^Q<YN7`S(UhvlCoHX$J9nIn=#{=EdOe=tlh#q=8?!wxNRTh_(P?~
za(E$_u*8^$!u+W*6wp*jM7XvV>-=k9m;dx>A`0A5ku_QQqp4we0OeeA4vJnM2CU~p
zX}dXMWcO%5Q2&tAM3$j@nxo1;vW4}t>X50>`!w1oMr!v|cSx&dGBMT5QD?g8aq~&`
zI|q{PheM-*#A6u1c}GjZsNjH#)1)P;$F+tVIYEHh&jGG^V;Lj8Ld4+=_#wCX*}G(*
z2K&P(WPo|+bi#D3qiL-Et;}kyVf>l$iF7t7q<8!zK}w{$HTtApPIdAG)<dW5(vCF+
z`$8{<ca9dQ#yytrF{cyIH?SOGV>KNWpD<}4%$Xt|cYc6FpvgX>uf#-b6I!KbogKY)
zMR91_<h`1`I#5|Vu5>aB-{V^YSl@H%3Am3w!gao_%rW;dAGmo(?rw=wVGnIfSGf;x
z{G1n3EyhusC=<AcdO|tlZsvW;<y&Z1{9-Nm9<qHw`?i~T)8Z}OYK+qw@tIQ`2YB&F
zX1f=nD05B3p6=-5%wsbVrp+GEqZ@P8258}}5uJ2gr@g^rcB(}T_4}6jXD`fo9F^?j
z>>NbE@HA(Xb-1tup<IeSbkSIN89AV41l5Sd1@b<4{dLRNys2<vCje&-)4Ajnm~IQn
zjnll))sN@zmU(3j{UcH!i}(yRpV9SeM!hzh4)TJPohoh*fy=;=l9I8)c6ak-;T6xr
zA7rwETy``?8Sm3n3iS47#x%3;uh=n!Nc4D`V*Ya4McvoWoX|doD+6b$dmG*MYj1gg
zoD32^8y`Y4^K8>9S;Cn3hd@x3xaiTMmCKFcdYNMu9R5X^y0Fkbh4frYJvaREB;FJE
zzA}y#D+cfZAvkN_y!a0>Q#M4rjE8BMdE#S28Lj$Va!Z_(<0%2p7uKC}W59vLG3?x)
z+IpHThP*~0?5SQigoJ$I7^Z$$i{zfmP|`4`lpk$Hv&$@!ut98RHLzF8E!Y>ux(v|U
zgTCTdO1kq>(YSBmH&7i$UT{a%;X`4IQS*xMQth;(L8ArHyC}qFB#zThEeBm?3&Q2<
zI^U_Ru8f+scy=08DFWBS^E4;;N&DaXyw`$GLvj7bF4Q$skA;JUs#uUEe&;U@-Z+`M
z72uV3BX^6JU(G~BQRmrr^5x?Yo8e*OY1@b!7=$|T%ci4FG}7x98~JhV#{^zZ-b-QY
zV+CIJQl;v-LAF!dR{m+*)cy4Fy8kfk{~}ordr^1Rz*onC`%vG;>-VV@Xnu=*y|OOr
z*OxcWpks7>?W)J7y*;b5t+8uWle>iGRmC)xkeL*DCvji}bgt@T;`bFQB^$Wpc&Rn-
zwDbTFR+b;eju2UA)bIZGhxq#T6}Jk+h+m%gIOGK3RCMvpDXmui0P8SVrzfl>`5Fnj
zNXC~1-&N3tXs(LKp-rBg^&sA!(`p9kmw!Fdg&HSvNc;gi+Q@?d|Eorp53gL*!-*et
z%OEtGFo3IbXNBrdshKIQ>ol-x;>rqZfrqP5*g3vNB!7WBI?B`8C3>Dtkq~tz2oHNO
z9RNr~WjqM!h?_%|D<869QT(2%Zn|v~J=jV7l;`_2JhCGu@iv=p_EhV;bfxp0uon=9
z2yV<`A_ec?FoSHwyBt=BCA?AuarP2TJuXp~=0&RR;1YG2Q*lSQynmAhA=uHR-~Py-
zj4-AA{Ym-7u|R$PfstaBeCR2ZOlU>=e#J#7+dr_*OZq!W{qki)<MT01F<Q@Wu1-w3
zQxjwuKBclbCHX-RY5EKruT>9vf2_n<oXIA_SllX$w?8$n<#&UZ+Xq-VHQojPL_rx`
z*;5n0PF70z8O<zER&*SdJ=-~U-m05KZ|k?Q*h%;gdS`w~p-{YvHYUh<`-WeT*hlCB
z)?`%2BNw6DWXEvZISnELyvMRmjd$rOdcw!0`T0Z-@d@EWAo)(R54iW@oqJTEtt(kM
z?W2w82L#MA3U{r1BU(8eU|~y~=SwESm)O<2ojh4_9#W~7`XF0pwz3m#0hlkb`0DU%
z6#9>d!M1>XdC#y8NglI)F2W3P14mp%XfnW{wN+~i1<?-KMq#p|60(9hY@z@QZnwD`
zw1RnU`X_p2$1y9|5{Bu5xZs60<y}dxP!hrk^>v_DF0QSE28)P<co;UEsMYi#{&70g
zHKK{I9X<j3@5T5y1|?CSs^j!@_r5{N(eHbiYQytXOlfCX*M<H(t(xhi%Jpi}u|@mn
zFltoPdE!fTDo=MPO^zbes6L74GJ~Qdvh(EYP{yocr1mk!{q6m%<!cR6_9)r-i4kdm
zRhi;a9B?zPy)`~v&Z!XTpvP@!@zmHp-KKjK6pan67#Sapp!##n5i`zOrhMrcYv^IK
zrw(+);lkU=G@bq7_`jd;v$f(G?P*(mp@ZZ$I!}ZRsOHz}*Q+(RXn*|O+boY+|5jMN
zdHQ3B3W>c*rD#^5?F!uTpCtaVDT1G)F}S!*uQ$wCog}njBf4CfaFOs*=I4HeogU$l
z1upB9h6bo;5h#T=3Q8L6`ABgw^Asdmfg@iW?Tziv(}e0dAkkaWg(RksD_9U(>taoQ
zNymD|ruFflb#%^;qQ#2}5W}F7PWV-gx-gwYb%;$r0~w4bZwrtf;hJ}`&;jN!>tX&^
zurGf~=Xv|qBv$Yd>SU|!AS<k(1WYllWXvgSS54tujX4$vWmn~+5e)GeT>Qw&QNs#O
z>LU`BZu?z2%Yv(&noOAFiA6@vv$VSLYsbXI-nmZlW!uRJU4l1QyU%UA-i(fcs=8D@
zA=SEwn6WKx@+xtY*>cF^C$1){3HSW!up3Mp<oR$6_I%O2z(!NcH}^*bX7*2f2vVM&
z&}%DE)<;w!lh^0HHIb9^!o_c>y(hAl8Cz6+z~DJE__EWIb;k*~1hM*SO58d*yTr@<
zTd1JABbd9J@tu&p!P<jL&v-1%*d}Mmb|BV(l;HqB#jo}xK^1u+olzjx!pq`~=q}e7
zetDoB;1@)}>Jzfi2kWOgT<@Rrig2z7GI;JuERY8Y1T#;?iBeGDMLWk!tD|0}n$z)G
zKDU9S$?1}is97*Ku_n$i7)5qaZ35gBJ<0U}M{WN!tmxi~#Xl7fW(+GT+<DHE_0o#V
zy^nTfXU6)l!}|pU1z`3R4njo95U1`20(U(gQq>F?E*AV2Sa&~LdcYpKLK%Ef`t{DC
zozqBBjoc_1KmUo?)nqL}{3|p*le=V}H$IbB<!`t*q>Ed3EE-c%Eoxk?)>^+h<|g;=
zwA4EJtvtx{e&{ohIS<lr)@DpoTAHoH4tZ^cA%=~_Ae&SwpEWYX>H%UAMCayjeOhJT
zFku@P#5zT%kn#xoc{_+pa^aPK<9yO>al>t-Y0W#PH*I+19IK;&c4nTWRB>jW4U0+{
zL5y=JcV=FqS1;VWife&A08&*;n-?bGy5r!4qgCslr2qpfdyyNE)K1XqegtsQTP&jh
z5KlO)m=SPZ(pOB;;Z!ZBghY7}zkrNNh9D}KeGOsqPi4ZqLrKxfC;nJ^>*~Q$$(s_^
zgyz>tvtWhZn_$rhq=H)H1Ij<K<;bnbSg%$7yeMky<HHfGG;g5bIAy5*l%yR2B@*;4
z^jrZX*dC6Fi(Jl?Jf4e$Tj{1yfH0*gDSKjvL~?wPlNC?AdWZHf(|Im+(+eLYbR$^B
zizEc~H8<6BiPS!%1SN9vYe5DC6ROnGWa<66t2-#GC%4;8lf|ApHjWAgRZfq(4}An%
zw4Sup+<mp(9fCv^`@&5e5fCU6A2OA~Usnb=nBy>O?<}2%yu?qdn-$(60c>>H5t3ka
zm6ptp=gAZ1oQoc3$M(CP+w)=2LAr;XmUrt3ZN|*<T)>~rnK}3tJtR7tpn*mBQ=Pg;
z;{bfVaVH<_KD~qO%>GlTg+nVdq2`k=^=ml6?Lb*xOoQtPc5ZDSKRGtLB8vixb6UnM
z;Sp{mIYfI%TCCV03<rcllLw&Byx`cXn;U2p@qFZ*3oA|(qtkMr9X;1F3nKNETx)M1
zeA^5Ok#pONZK;K#{sv~PNdeP<0zN+*tAF4H8$uHbg93o$p?_hiQ!vKu@eAL-f?edH
zFmkKR#1#MX&_3Bglzg55CqclM%lZ!mLT~abJR3uRi{IF24|zcW^D!5H6ZGR8@Rz-@
zk&dU`^b%w8lV9FV{HqpXlisq*voYo&#9X82l*9!1ru++9sZ5$(cIHj*-xNecrhiuk
zaP;w|ELkTEyvuh{&E2gXa^Jm@H@4pMPZ(z9e>W|&DnerKR|M;52`3~Sp776oqe*{P
z;6nkM;<Ire(O8SN`bV15aLm7wA=~Kw-S18BljRfbA5PwQCsfhoo8GDykA`>^0?{{}
zqc<`yE!2t-@Y?W?n}FgsGD2UuOe6*{JRgzz2l{WQU`5LSov-gq{L~<@{Il3!Ru)YU
z0)K}J%u-qWFQz1_{45rN$KCIONi4^O(E>Lr5nGr7rUHSVX#VT$b7+x6DF6H{HlWTm
zHDSx8kF@AqodSkNI)+EOp7;8%GzWYCSl#TuT=*tGk;6Bs?2U{8EH?p8ya|ZN^+pOr
zcle_I5&t*N%A@g*{afKrFDnSlu4Oj?zJ_4O*7o@~=bw5blYI-Q?|cF`5NcA9f{jt5
z8%(ajUQyufVH_NAJiS^zlA;EVYyqSKH^j`=uLvn<h->AIM*?FrMt90f_JqJCKlKa;
z7`8g#m&WwATJo2jt<UmG%M_}rJ$NCew?E|!2>1tfpc_%d@zh-yRfd1^<CN`bW=FLe
z_=>MhdZ7C(U1-v6aVQE*?QPnd%{NvPTM<F%2YFoaW$5Kz;44Q8K5Ha3$|W5r^_bzY
zEA7uCc>(gql#H%sDHAXo+PX{N4>lzVxX2_0xrMd8JsIW!#a1R?G#<E*tOgttGS4hj
z6`hq$*oe6615G{}F#|ALu(W7%)1BUlO0j`eteWI-?^RVZgjQ;Es`q{L=jR>{ouV;H
z_M<!DY!NUd&};!BJ(~93?0TMEHs=M1z~KtI{GkCf@{wsPh@zDP)I)2oDPj?YWt$^Y
zYAZL0ZK%QEjYs?*&AgVkb{IDI&jDgx+@3Du@3+kYK?T1;QjrRZCYj<WcnV6iRs@W*
zGTnq=J#6W)_R&Ps6x5PgbmWTcQgd!<BF3o2P?qrPp|aj3B~CFqnnGlc8L8g#9I|iS
zgv5UZg|{q-F7EB=4mWd`<p2JWKIJC{M{66TIl!(aA}XHD7F0k<QM@i3pWuO_Ay|+9
z<Ix{4g~8u8G#$aPzN|(1;}L5(mz2Cpvvs=K-0~@_D|s>LXw#(RC80l587iYR#3>$a
z#WpjfL#E|Nh?7gfcXV{TN<jZn^zc(06O0|%W#d?iGuf?o(*Uv@9DkyK;^JI9Cp7Vv
z=3O1S@tiFL@xDApID38r(9jmefk&AVPYGxA>-lHwGDO$ZbXLpAXb4nmL>}LOrMgKt
z?iTgf+)Y7S{MCC^Y#w`?&e0sIOLopdFWXCO^O&JWvAZtkwGZ}@%<sI=G<#60_R!oW
z{#DU3Ef-`?k^<OY<E`S7w?`gR$yLVCzdS4wM|J6<$Dg|p6x0jm-U>^NZB3h}@zgS3
z<+<MuM;eBtKwnZE25wNc34j6{iPgOyMPrDa6X$HQ+$fjkX-yUrB>`CUr)3#%al5^@
z@h#7&Q8%PoKcK<WAIjI;mc7i;W=~alM_xSMsahNMDQ&sJA6c=zKrmb7hbNH`BzXeZ
zi5vgG_w5xFu?v=aR~rCd?Y$fqog3e7*mspTP97?YOpdH6Yp9;ue+UZoc6W76(p%rz
zl*qIYvIR_MTDD{+^UMgD@vi7~>rUZ~E@@LvP7q8h7`1|upUwKSVb7myz21M_o&Y{l
zD+2UCu6<rV{N?I;8|ZkktL%RceBrOZgqTB71ntkGa<zAC`#4>_zJ3i_zsRX7i|E!U
zvb+cfOgre>G9jPf{Mz+=B|W%%4^Fq}A(sfhl6OgTqWWT-?+EA9iaX`FO_I}-*8@)J
z?G3gF3q_~Y`F=;~yaZqG{CYWh_g?n?{@oxGpe5Rs9lSznlYP}mMD74~^UC_(;<uRE
z13u^lPcW8l<69q1N41z`8^+T0KCIiuWsMg9l#Z`mt)6^-qqJi^<#0Hvb@v-2k|ry;
zV>!!m*_in?-E{eFz-nC0wpz~_lFwzVmJ3~zh4Rz+mwa1z_PvwW*I%?*<7#7?)I)9Z
zLz({a2_f|)%+CdVczDdy>2anh>pec?eqeHbXKVIm=z_<sh*rPF`l~Cc@!`GP;c>x*
zb(8)za|}Gc8Yl9n!c~s8jKFac^50Wz4Zr$5DS%<<pSDYK99UzOaWZL{*C%w#-C_!x
z3Ac4e24DAD0GK&#)qb<{WgmW?qFpu4tQW-eZ26N2KhB^|kYI$;JHB0QX8nC?z1y1^
z%0>APD)T++^rQ&8oztalPKA%}e(<e7u`=6u<lYmw;xvRJ;?A-^sb$AjKqi>*&iZLI
zU0r!jb*{pO0`iOXrh?#+fw$M#A9(dJ7Z(cOYqqyucXHRzk(pl$Vk?pN0u&gu;nw$N
z1kVVD!RMWLi;s`5e+wKtJ-hCR-R#0)iNpON3+^&`CR2=hJ=S<r<(aAs0k001<P>P6
z|ApVyKHz3~n8*Y1B^h`KkT6Ebb33#gujZ@Itz<P=liI!IjxOE1J2H(eoQNpBXYD#Z
zPcOk_9N8PO);wlqsyRM1$I>-~UzSw*xl_8=jJXElb`h`<=KGITulfEkT$0XXiRcrk
zMdUC*ibZTLh7XB4dp_UixE;=J6gv+Y65I0e(PBFwkiWPLsN@wZEM_r^r@OD`#9ZH~
zDuNYpNVI3auowI|cQ@-3b}xRoTVlv~vP9EW?Ur!*3V|wMVv;aaK3}jq5h$bUENfsi
z?NkP+TbH05<TdiIYP?X;YH3TonQO~vrlY8fS5%hS?q7_pa3W`903-y!ltThJ_*Z36
z6BAp3?*w&XT9x6$$1H2Vso%#@creDz9-3BHZTO_eV$ZDFi~VP+={8)lwM{STzrnS!
zt<C5|g2S`EjE*Dw!kAzr;N}n2Xapt6<F*t6l<XJ&1maHD&Bm3WV7sCTEx=@Gj&W0}
zJFlHIe>Xg$J_xGN;x{<O*ob$&ysL=?(XQ_m;w1~qGIveoFSn)FIUFUeIp@CtK}nDc
z7>7yo$%fADdt)?Q4bdu7BE=d4rD#?QfFmuD=VqL$+UM>y*hy#ky!_76Ti6Yj3s~BC
ze84lC`At(}X%4;p$ApS$Lsx91#ar<#lm}G3L+NwrkcFUe3)TQjAK;nA!Y9<8=JgVB
zO%$pW$;z}z{YQne8IN+79@ABdi0K-0wfpe!R(kpG>+`tC9-4PAE;_;|-&0Q6IrK!M
z9=#>SfxLn8$R-_&b38t31OH5ghl)+1g^xLFe_u&#pKgh;7gvrRS)rEdXBWkT^M{u%
zqbAA@BTk~QuBXcD0|lHfxyHPcILQZ2M;AV+Gk6UBs_nYHe}5M$S<fcLqCQ|dT;E+h
z#qnmBVEHY2z>2(1`6_g??QyI~0HT(n?aZtf3q*RUmN)!?v@8YnS2|Y%`isduDG?UC
zj9I=qFUsvPQq%mNXt-43dr&`2eWzE{i^ZhHidghx+bjYoaRMsRYQAYEEC!>DL8&D1
zLvy4bTMTk+m*_I<mgNOsd}2E6Y`D{QM}dXIy{&HGI^o!++v5^3jQ%XHtm&P!aKP}j
zFHKhkvnjJ?l*%=!>yz9fRj%82($ePA=P3$U(=nGap1QVv<WR@(5%#$o#f2%*S!vIz
zvki~=BWuC3A!mq9nRNfKW$rU)$Z@}OyGxYSOOF5c<0CEfU3C}g$LZd==<hF{)fPV?
z9r#0sPP=%1bz|$L_Iot6^Hb-u<Nd@+O1Zs<mePPc`&!KoF#WyJDK<c+K*k>~gQyok
z+RsvKD^XNj#dk0An?5ym>L3A;A66<;f%9Njn$)8D^x0v#h5|&1x0;N=u<bta$v&!4
zUWk*V1o<|V`C^=~w7`eT46$^X@m_zWX9&)`%Xo{55B^s9oj-4jQ)nWcej?8d!FkPb
z;>Lc^>>JxvhGLSUo8R<A@!n0FNK>Q|2IW(!rwRjE8m^Sw?{FEohyo8-ouh(dTMYVG
z5rZevL$#Im+mnSyz;NygHJf?oG|acxzpdh<vSu$Ax6YT-O<Rr;Lk`wdWCZ<F4!v0G
zN}3;P7Q5c_Gl`wg)tHOEbP@~(8F+Mk-)e^N!;_&0%djtq@g>cF3&DpO$2S1Wg55Zb
zVlm_@TLSC_-8hb_Z341k$6?iG88*$Je*p8Oh<x6koZ~^*NPdSwcKWldIyw%<0kqy^
zDH2Y_5a=#>p^+5pmNoGBz>YM8WAPgJ-y5Su=G*_>r0uj0WDnB1lm6u5Q64}mjh}xg
zjWD7RoH*RT$4~q-yLD9l1`fk4==XrDh)o|H44$~g9`RypVt8yZVSTc2*B#e^*S9JN
zceb2nyEOqODb}!05#G~2<q$z}C1toYDad@p(;KTXWp~97K9?XtQb!*((MmIpjzjcM
z`V71Qfw^Ru<7DKI-Z9F#?)%}>Z;)pr=-X@o5T_N!D@y_E-se7>XeVqWn<d*=4~ivR
z?Ozj`sF;Pb86CdKbc4URG<Ui+%!x!llB}fHj7?&IJIDWQo4j4sF+M$C4f;z=-c~Te
zF?@L9rClz3gB`kWD|jGDZV-D{l9EYXOWY{@bZvfdSpQp{L0T7xu=*N_49aU%<qloY
zpY^kBw6flrQEZ{29f~)&_~Y5>X&8*rFDf-?7fa<&C{@{{-3m}~QTOKV*{lBM0ocrc
zL1Z**iBvtfQ0sL2F5U5<B=m8BRe2cQ*dk?^amq*RK@@j2lsYj1Z}?!a_OqR5^s<El
zE<Jo<aOUHEEO6s3xOaK+MEEuD+06SIn5WGq^i81MWKP=H1`zkUmpe!`*9$1Pzi$=u
zo#8y@Xr2}ps<;-mWM6INeH*Nf3-{XPex3YA5dG)N0#`?LR;n%>r6-_~*Vmpo5>yRz
zpL8|aco1^}dct;}*_ine2{C5!<6@K(d6l@M&*EQ2(LVTeb;x0j-sRD3&c(U41$CRs
z%5w50c&Me-GdfXqyizxwRdgD+j8tcg&ey<i6|%r67yi**VfP7ytv=k997xfHsO%AE
zFcd6@F4PlpFSb5^J628rO31Ab8ms#;tFj18XtsGGf<C<rpw(iZ%puryUG1EcuRV+a
zblh=coLHT6=k)f)J<_T65-z0DyWG-lmS0UOf`5%cXDxq8O+BL9idujG4VWJZCTJQD
zM#~Z^OjnJF9V^EaN@phC4E<6IQ+-{fr+>o@)8F;1kL~DO-&E^v|G0mO*z_TOj<Laf
zA3K^+k^N~!JYNNg`h$wlwuqyK2>+|^Zb4G&x&Yv(#Y=%<#Ak~BwIF%W)v(?k?NWt^
zh3`982<kNX;g6%bon~)3O8r}@L)Z=JZK5+_xwje@dT9);%9skChzc#4WkT6yLYZa3
z$O?BtEvBnct?09N;hNXmwvX9;IP!QRps*vtO&iD9J{(0nQ7EM&Hj)6+1_Hy@pW=HG
z_o{#~)1UHZiEMZ69Ag27%hRA`g^WF0GFaKA=y6t1Q}<2+8<Y$5d3~MN<jx`1<iNf{
zq?Z}(!pN2^f^{DS@D%0SxeHA{@3)MpWQyQw`~BW9rLb#bD%#4YS}fY+r&<kKpCNyf
zJY<6Fuku*eS@HGKjyH`s(pfi<crbgO!`59-A_p2@-$<_onEmtqj5GS@-RLpA6wQ|9
zJ+T~SJWUHJUD`A};BbBqCVMAe*QtBJDfEN2Gp6|8lE%)MVO_`do@QO=hDBST&{tmO
zRbiz^y{XpXg6aPy;i~+g=X)S^vJ3s7<D9TAi0U3L?#k^t)g$x5NtWp&I#)HA>kg?-
z;Y&1ON%!6nxKXmUJm$w(1?!_#E(*KiQz*8lkc+FNC*b7uLQ^QD4-jw!BxU2~)W`wY
z2qdtQa=`yBX(Z($=hP?xDF`J0Q*wwO<3kA63FO1^e?4Kk{PH^l5hr?W?0Z6Z6xH?j
z@YAmvWm!TV#Lv^D6vy5lvbn!3$VM}_tueZc$XhQ@UB`W5^@i()UeP_tP#pkOyKSwg
zK2q@7l(-tJS5m>NMdzw-GxE_V!Z)5n`zT(xUU+7bxf_0{^Tt+VjiSPNQQH1tbC8Zv
z08IT|fj?r2KV~xg%b8+bmT;x{`0kaeBflrp`J?CWdQ5V(X0`07pA)PuY?pWP?Euh1
zRfVLr!jp@nF16=Hnr_<!o_}Y{cOrSuT%X*T1m)&Hp~;gT^RB=owcAa|&3`lv5Aha?
z?sWYsDs&*%n(|k3qX6M=s;A5ZA4;;GtrP9($XrIi9@lkiz!{#$g?zVn`Xa=n-!?4V
zk7{xs3M50BgtX_AHK%w}n~Ugzk5q&5Z&aZZgfCJ{Fw&v}pDxhyQMTO81lHH6&Ej;(
zP5(YdlzkUR*CP5eh#Xgi#$Xw~N&*|31kGVr1c>KaAXwvyMoL`iv|DG^NeQ_Rkuyb(
z$45JWjrRTwoj&t-H~=$txdCcX*>PR{jgA!j^_=~q)p-1A`y>DK$l=XN5bVj9R)Z0{
zA3!2m!R}yub=~Xg9`D%i<6y!P#D9b_6iOhWw2eR&5sflZ5Jnjxf+4Z15emJ9$(J|=
zWjq$IdM?VV6hJUt8CO})CE{>IzWF5L6Y<uoD(z%|UQ1GJOZ{a2euARTLh6-pDl#Ct
zuWHbsUEve6c5weOWe14gILB8GemU~xr04Y)7G3#-&N(Ei7TVJbBJYuk*jSWG^dxLO
zx~UCApBUr1^3P;}IF9CiEB;oVsn}qo-CIf5Y695E;OTBOVoPixd6&seki;WjTwst$
z;lR_MDl%tIy=7+IOSotHy@R5RXHH+9rplao!9!OPoLT<Qq(`-O_ygs0Ne|p__558Q
z{ecLCgQVCiOJ6(YNVrvDHvz8aw5Pn|M%ELQ_NMrbr9rG`)3mQq1ky^4JN8e_J;>3f
zbI<Za879=0KCsU49Q|4m#*v6gtVcW^$DnXB1=x_<8&zmzuqmvngileBJ*y!uaC#MD
z0?k_<4dg7S%=C<2eY<84-F9G>d!T(IoCb0Y3Ev}VHs;5aVI0|!#{T&!SVIkl66M9U
zO(Fu4u(J>!dTd!8H^?Ru$PBZK`GXne8Z!wSzmGB!h{2phj6Xn$2*tr1T8scwkFATX
zSU?R^=SM9=9#@ip4HQq6REMF|L;8$?V9D?orv3v>{(*&h3V)$BL;d$ub#)jh{l8v>
z4Fin~d2vY!HZc7k81ye_`wy)82ezdG{}yRMsT)fLW|H^WCt#xnwv#guLd+Ev+d$04
zB^5&QYa6L^f5AqjmVuU;7yn0UB^4^DX?~7kOqiD*E`?0iRo4Vk2~o@7@R!P}YcfPJ
zepZ8RSXPW;lu@H$sKA!_QCzN$jY=aUB{Tm;W*TU~oK#p)XhY9H7-WF`f8}EDj|7c>
zU!~5i`QK7rom(9{R&y?|(1x0UkReJosW9<>O33zVnAZP<$I|M6LV7_pj_9aDtk3h2
zh5ro_v2*C7RH$X>{sTh+64hn@?Q5z7D(D5ZDAJ+|H9pV(EIj@TkW~EAuyYurRA^+%
z{sRjl4XxFSt*cb(#~#%9f%_=xna#vssP^LmL9NWj#aA|~V&^h56k)fasz%LmLe70n
zl0AVWFrC+=FlRiD#+9%{eLB#MTX3>={O8MWWPBD{e`qXG>*MDBB<RDhegt|5P>ZPi
z*;%+6sbp%<6(}3L6Xwd1u-eg&gsC~9AYq0<JE;pNTuI$9?CfN3{7q)nqBT^zO#|$_
zTk6P4jP)MOp)e6xy;@)N$_U5N*<HniypW|Fn)}Y#vpxzv-QX@caS)*pA4yfL6pb+m
zEB>eJlN}cg=a^KamPg?%yt5V1lL&*n>otRNmn9}#s}jqCi~6u~%>KUXaxJB9P*Zb7
zDyBFJ(=reIUJHJ@th_RQAL|Nr`N~uu$5GyNUq^~ZbV=)f)RPtgKH=f>Y`isIxA5n4
zTacTK=Y2pW1aVa`%Dth#^2LG~WS8skV{`9s`)yLhCM#l_``kqCpU57ch$u`gm%*1M
z9orP5Q)J+hzmuzvldkDvXLz8xyt1cSLxb!6JoH{&r>Ee3<AaiPaPUW6@xC$6AooXS
z+g7LC-NuOPIVnk9kne%c+Z)?T&d26K08jC4K*9`oa~enN!!8;;_Y_~@KR)`m5f~H;
zCLagq7|gR$wmv4*MlC$giWT4H?H3I%KF=bINe;=C+~$!P+W6U@{SBSGS!av<wb!+8
z)H&ennE;g|v9jAdj(v_C@NdX^+Rv&-VnR^S58WZEIvoo?Y5*lnh9?UDpHig%3=H|*
MSrQ$B9SY+A0RI|`p#T5?

literal 0
HcmV?d00001

diff --git a/output/bugs2fix/old/codegen1-multi-16B-0.output b/output/bugs2fix/old/codegen1-multi-16B-0.output
new file mode 100644
index 0000000..f8bd26b
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-16B-0.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1, VAR_1 ) ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { intent.setClass ( this, VAR_1 ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) VAR_3. METHOD_1 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 [ ( VAR_1. position ) ] = isEmpty ( ) ; VAR_1. position += 1 ; VAR_3 = METHOD_2 ( VAR_1. position ) ; return VAR_1 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ).toString(); VAR_5.setText(VAR_4); }
+public boolean METHOD_2 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_1 ( TYPE_1 VAR_1 ) {
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-2B-0.output b/output/bugs2fix/old/codegen1-multi-2B-0.output
new file mode 100644
index 0000000..ffd8cb1
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-2B-0.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-2B-1.output b/output/bugs2fix/old/codegen1-multi-2B-1.output
new file mode 100644
index 0000000..ffd8cb1
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-2B-1.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-2B-2.output b/output/bugs2fix/old/codegen1-multi-2B-2.output
new file mode 100644
index 0000000..ffd8cb1
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-2B-2.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-2B-3.output b/output/bugs2fix/old/codegen1-multi-2B-3.output
new file mode 100644
index 0000000..ffd8cb1
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-2B-3.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-2B-4.output b/output/bugs2fix/old/codegen1-multi-2B-4.output
new file mode 100644
index 0000000..ffd8cb1
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-2B-4.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-350M-0.output b/output/bugs2fix/old/codegen1-multi-350M-0.output
new file mode 100644
index 0000000..50495c3
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-350M-0.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-350M-1.output b/output/bugs2fix/old/codegen1-multi-350M-1.output
new file mode 100644
index 0000000..50495c3
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-350M-1.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-350M-2.output b/output/bugs2fix/old/codegen1-multi-350M-2.output
new file mode 100644
index 0000000..50495c3
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-350M-2.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-350M-3.output b/output/bugs2fix/old/codegen1-multi-350M-3.output
new file mode 100644
index 0000000..50495c3
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-350M-3.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-350M-4.output b/output/bugs2fix/old/codegen1-multi-350M-4.output
new file mode 100644
index 0000000..50495c3
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-350M-4.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-6B-0.output b/output/bugs2fix/old/codegen1-multi-6B-0.output
new file mode 100644
index 0000000..b4a7a1a
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-6B-0.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-6B-1.output b/output/bugs2fix/old/codegen1-multi-6B-1.output
new file mode 100644
index 0000000..b4a7a1a
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-6B-1.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-6B-2.output b/output/bugs2fix/old/codegen1-multi-6B-2.output
new file mode 100644
index 0000000..b4a7a1a
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-6B-2.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-6B-3.output b/output/bugs2fix/old/codegen1-multi-6B-3.output
new file mode 100644
index 0000000..b4a7a1a
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-6B-3.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
diff --git a/output/bugs2fix/old/codegen1-multi-6B-4.output b/output/bugs2fix/old/codegen1-multi-6B-4.output
new file mode 100644
index 0000000..b4a7a1a
--- /dev/null
+++ b/output/bugs2fix/old/codegen1-multi-6B-4.output
@@ -0,0 +1,15 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
diff --git a/output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output b/output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
new file mode 100644
index 0000000..e4dc7ce
--- /dev/null
+++ b/output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
@@ -0,0 +1,95 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1, VAR_1 ) ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { intent.setClass ( this, VAR_1 ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) VAR_3. METHOD_1 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 [ ( VAR_1. position ) ] = isEmpty ( ) ; VAR_1. position += 1 ; VAR_3 = METHOD_2 ( VAR_1. position ) ; return VAR_1 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ).toString(); VAR_5.setText(VAR_4); }
+public boolean METHOD_2 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_1 ( TYPE_1 VAR_1 ) {
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
+private static native void METHOD_2 ( long set ) ;
+public java.lang.Boolean METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { int count = VAR_3. METHOD_2 ( VAR_1 ) ; return count > 0 ; }
+public void METHOD_1 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( VAR_1. METHOD_4 ( ) ) ) { TYPE_1. METHOD_3 ( VAR_1, this ) ; } VAR_2 = false ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_2 ( VAR_2, ( STRING_1 + VAR_1 ) ) ; TYPE_3. METHOD_3 ( this, STRING_2, VAR_3 ). show ( ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_3. setText ( TYPE_2. METHOD_2 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! VAR_2 ; }
+private void METHOD_2 ( ) { METHOD_3 ( ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1, boolean VAR_2, boolean VAR_3 ) {
+private void METHOD_1 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 class ) ; int index = TYPE_1. METHOD_2 ( ). METHOD_3 ( ) ; intent. METHOD_4 ( STRING_1, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_1 ( TYPE_1 arg ) { VAR_1. METHOD_2 ( VAR_2. getId ( ), arg. METHOD_3 ( ), arg. METHOD_4 ( ) ) ; METHOD_5 ( ) ; }
+public void METHOD_1 ( ) { if (! ( VAR_1 ) ) { VAR_2. update ( ) ; } VAR_3. METHOD_1 ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_2 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_1 ( android.view.View VAR_1 ) { TYPE_1. METHOD_2 ( STRING_1, STRING_2 ) ; VAR_2. METHOD_3 ( ( ( TYPE_2 ) ( VAR_3. METHOD_4 ( ) ) ). METHOD_5 ( ) ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( this ) ; }
+public int update ( java.lang.Object VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_1 ( java.lang.Throwable VAR_1 ) { VAR_2. METHOD_2 ( ( STRING_1 + ( VAR_3. name ( ) ) ), VAR_1 ) ; METHOD_3 ( ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1 ) { return TYPE_1. METHOD_1 ( VAR_1, num. METHOD_2 ( ) ) ; }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; VAR_1 = this ; METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { if ( VAR_1 ) { VAR_1 = false ; VAR_2. METHOD_2 ( ) ; startTime = ( TYPE_1. METHOD_3 ( ) ) - ( VAR_3 ) ; } }
+public TYPE_1 METHOD_1 ( java.lang.Integer id ) { return VAR_1. METHOD_2 ( id ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.System.out.println ( STRING_1 ) ; VAR_2. METHOD_2 ( new TYPE_2 ( STRING_2, STRING_3 ) ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.Object [ ] VAR_2 = METHOD_2 ( VAR_1 ) ; METHOD_3 ( ) ; TYPE_2. METHOD_4 ( VAR_2 ) ; METHOD_5 ( new TYPE_3 ( VAR_2 ) ) ; }
+public static void main ( java.lang.String [ ] args ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ; java.lang.System.out.println ( VAR_1. METHOD_2 ( ) ) ; }
+public int getId ( ) { return VAR_2. id ; }
+public void METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_3. METHOD_2 ( VAR_2 ). compareTo ( VAR_3. METHOD_2 ( VAR_1 ) ) ; }
+public long METHOD_2 ( int i ) { return i ; }
+private static void METHOD_1 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { for ( java.lang.String key : VAR_1. METHOD_2 ( ) ) VAR_2. METHOD_3 ( key, VAR_1. METHOD_4 ( key ) ) ; }
+public void METHOD_1 ( ) { while ( VAR_1 <= VAR_2 ) { TYPE_1 VAR_3 = TYPE_2. METHOD_2 ( ) ; add ( VAR_3 ) ; VAR_1 ++ ; } }
+public void METHOD_1 ( ) throws java.io.IOException { TYPE_1. METHOD_1 ( VAR_1 ) ; }
+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 ; }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. i ( VAR_1, STRING_1 ) ; METHOD_2 ( ) ; TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_1 ( TYPE_2 VAR_1, double VAR_2, double height ) { return new TYPE_1 ( VAR_1, VAR_2, height ) ; }
+public void METHOD_1 ( TYPE_1 c ) { VAR_1. add ( c ) ; }
+protected void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. i ( VAR_1, STRING_1 ) ; }
+public boolean METHOD_2 ( 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 ; }
+public boolean METHOD_2 ( ) { return! ( this. VAR_1. isEmpty ( ) ) ||! ( this. VAR_2. isEmpty ( ) ) ; }
+public boolean METHOD_2 ( ) { java.lang.System.out.println ( VAR_1 ) ; return this. VAR_1 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_2 ) { return 0 ; }
+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 ) ; }
+public void init ( ) { METHOD_1 ( new TYPE_1 ( ) ) ; add ( VAR_1, VAR_2 ) ; METHOD_2 ( VAR_3 ) ; METHOD_3 ( VAR_3 ) ; METHOD_4 ( VAR_3 ) ; VAR_4 = VAR_5 ; VAR_6 = true ; }
+public java.lang.String METHOD_1 ( ) { switch ( METHOD_2 ( ) ) { case 1 : return null ; case INT_1 : return null ; case INT_2 : return getType ( ). toString ( ) ; default : return null ; } }
+public void METHOD_1 ( java.lang.CharSequence title ) { super. METHOD_1 ( title ) ; if ( ( title!= null ) || ( ( METHOD_2 ( ) )!= null ) ) { METHOD_2 ( ). METHOD_1 ( title. toString ( ) ) ; } }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+public boolean METHOD_1 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_2 ( ) ; if ( VAR_1 == ( VAR_3 ) ) { VAR_4. METHOD_3 ( ) ; VAR_5. METHOD_4 ( VAR_6 ) ; return true ; } return false ; }
+private static double METHOD_2 ( double p ) { double sum = 0 ; for ( double i = p ; i > 0 ; i -= 1 ) { sum -= i * ( TYPE_1. METHOD_2 ( i ) ) ; } return sum ; }
+public void METHOD_1 ( int VAR_1, java.lang.String VAR_2, java.lang.String VAR_3 ) { TYPE_1. METHOD_2 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_2, VAR_3 ) ) ; }
+private TYPE_1 METHOD_1 ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1. METHOD_2 ( ) ) ; }
+public void METHOD_1 ( final boolean VAR_1 ) {
+public int METHOD_3 ( java.lang.String str ) { java.lang.String str1 = java.lang.String. METHOD_2 ( ( ( TYPE_1 ) ( VAR_1 ) ). getText ( ) ) ; METHOD_4 ( str1 ) ; return VAR_2 ; }
+public void METHOD_1 ( ) { android.content.Intent VAR_1 = new android.content.Intent ( VAR_2 ) ; METHOD_2 ( VAR_1, 0 ) ; android.content.Intent i = new android.content.Intent ( this, VAR_3 class ) ; METHOD_3 ( i ) ; }
+public TYPE_1 METHOD_1 ( ) { int VAR_1 = java.lang.Math.abs ( ( ( VAR_2. METHOD_2 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_1 ( final TYPE_1 VAR_1, final TYPE_2 VAR_2 ) { METHOD_2 ( VAR_2 ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( VAR_1. size ( ) ) == 0 ) { return 0 ; } return ( VAR_2 ) + ( VAR_1. size ( ) ) ; }
+public TYPE_1 < TYPE_2 > METHOD_1 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_1. append ( c ) ; return c ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 VAR_1 = new TYPE_1 ( ) ; VAR_2. add ( VAR_1 ) ; for ( TYPE_2 listener : VAR_3 ) listener. METHOD_2 ( ) ; METHOD_3 ( ) ; return VAR_1 ; }
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+public void METHOD_1 ( java.util.List < TYPE_1 > VAR_1 ) { for ( TYPE_1 VAR_2 : VAR_1 ) { if ( VAR_2!= null ) { METHOD_2 ( java.lang.String.format ( STRING_1 ) ) ; } } }
+public void METHOD_1 ( java.lang.String VAR_1 ) { if ( TYPE_1. METHOD_2 ( VAR_1 ) ) { return ; } this. VAR_1 = VAR_1 ; }
+public void METHOD_1 ( ) { for ( Iterator <? > i = VAR_1. iterator ( ) ; i. hasNext ( ) ; ) { i. next ( ). METHOD_2 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_1 ; }
+public java.lang.Object METHOD_1 ( java.lang.Integer VAR_1, java.lang.Integer size, java.lang.Long VAR_2 ) throws java.lang.Exception { return VAR_3. METHOD_1 ( VAR_2, VAR_1, size ) ; }
+public TYPE_1 METHOD_1 ( final TYPE_1 VAR_1 ) { return VAR_3. METHOD_2 ( VAR_1 ) ; }
+public void METHOD_1 ( java.lang.String text ) { VAR_1. METHOD_2 ( 0 ) ; }
+public TYPE_1 METHOD_1 ( java.lang.String text, java.lang.String id, java.lang.String name ) { return TYPE_1. METHOD_2 ( STRING_1, STRING_2, id, STRING_3, text, id, name ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { throw new TYPE_2 ( ) ; } }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. METHOD_2 ( VAR_1, STRING_1 ) ; VAR_2. METHOD_3 ( ) ; }
+public boolean METHOD_1 ( android.view.View VAR_1, TYPE_1 VAR_2 ) { return false ; }
+public void METHOD_1 ( ) throws TYPE_1 { TYPE_2 VAR_1 = new TYPE_2 ( this. VAR_2, STRING_1 ) ; VAR_1. METHOD_2 ( ) ; VAR_1. METHOD_3 ( ) ; TYPE_3. assertNotNull ( VAR_1. METHOD_4 ( ) ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_1 ) ; } else { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_2 ) ; } return true ; }
+public void METHOD_1 ( android.view.View view, TYPE_1 VAR_1 ) { super. METHOD_1 ( view, VAR_1 ) ; TYPE_2 VAR_2 = ( ( TYPE_2 ) ( view. METHOD_2 ( VAR_3 ) ) ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( ) ; }
+private void METHOD_1 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_3 ( VAR_3 ) ; else VAR_2. METHOD_3 ( VAR_4 ) ; }
+private static java.lang.String METHOD_1 ( ) { try { return VAR_1 class. METHOD_2 ( ). METHOD_3 ( ) ; } catch ( java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( STRING_1, VAR_2 ) ; return null ; } }
+void METHOD_1 ( ) { if ( METHOD_2 ( ) ) { VAR_1. METHOD_3 ( ) ; METHOD_4 ( ) ; java.lang.System.out.println ( ( ( STRING_1 + ( VAR_2 ) ) + STRING_2 ) ) ; METHOD_5 ( ) ; } VAR_3 = false ; }
+private synchronized void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_1. METHOD_3 ( VAR_3 ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; METHOD_3 ( ) ; setState ( VAR_3 ) ; METHOD_4 ( ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_2 ( VAR_1 ) ; result. METHOD_3 ( ) ; return true ; }
diff --git a/output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output b/output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
new file mode 100644
index 0000000..87e9bc9
--- /dev/null
+++ b/output/bugs2fix/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
@@ -0,0 +1,95 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+private static void METHOD_2 ( long set )
+public java.lang.Boolean METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return VAR_3. METHOD_2 ( VAR_1 ) > 0 ; }
+public void METHOD_2 ( ) { if ( ( ( VAR_1 )!= null ) && ( VAR_1. METHOD_2 ( ) ) ) { TYPE_1. METHOD_3 ( VAR_1, this ) ; VAR_1. METHOD_4 ( ) ; } VAR_2 = false ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_2 ( VAR_2, ( STRING_1 + VAR_1 ) ) ; TYPE_3. METHOD_3 ( this, STRING_2, VAR_3 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_2 ) { VAR_3. setText ( TYPE_3. METHOD_3 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! ( VAR_2 ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { METHOD_3 ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_1, boolean VAR_2 ) { this. METHOD_2 ( VAR_1, VAR_2, VAR_2 ) ; }
+private void METHOD_2 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 class ) ; int index = TYPE_1. METHOD_2 ( ). METHOD_3 ( ) ; intent. METHOD_4 ( STRING_1, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_1 ( TYPE_1 arg ) { VAR_1. METHOD_2 ( VAR_2. getId ( ), arg. METHOD_3 ( ), arg. METHOD_4 ( ) ) ; METHOD_5 ( ) ; }
+public void METHOD_2 ( ) { if ( VAR_1 ) { VAR_2. update ( ) ; } VAR_3. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_2 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_1 ( android.view.View VAR_1 ) { TYPE_1. METHOD_2 ( STRING_1, STRING_2 ) ; VAR_2. METHOD_3 ( ( ( TYPE_2 ) ( VAR_3. METHOD_4 ( ) ) ). METHOD_5 ( ) ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( this ) ; }
+public int update ( java.lang.Object VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_2 ( java.lang.String STRING_2, java.lang.Throwable VAR_2 ) { METHOD_3 ( ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1 ) { return TYPE_1. METHOD_1 ( VAR_1, num. METHOD_2 ( ) ) ; }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; VAR_2 = this ; }
+public void METHOD_2 ( ) { if ( VAR_1 ) { VAR_1 = false ; VAR_2. METHOD_2 ( ) ; startTime = ( TYPE_1. METHOD_3 ( ) ) - ( VAR_3 ) ; } }
+public TYPE_1 METHOD_1 ( java.lang.Integer id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.System.out.println ( STRING_1 ) ; VAR_2. METHOD_2 ( new TYPE_2 ( TYPE_3. METHOD_3 ( STRING_2, STRING_3 ) ) ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_4 ( METHOD_2 ( VAR_1 ) ) ; TYPE_3. METHOD_5 ( new TYPE_3 ( METHOD_2 ( VAR_1 ) ) ) ; }
+public static void main ( java.lang.String [ ] args ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ; java.lang.System.out.println ( VAR_1. METHOD_2 ( ) ) ; }
+public int getId2 ( ) { return VAR_2. id ; }
+public void METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_3. METHOD_2 ( VAR_1 ). compareTo ( VAR_3. METHOD_2 ( VAR_2 ) ) ; }
+public long METHOD_2 ( int i ) { return i + 1 ; }
+private static void METHOD_1 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { for ( java.lang.String key : VAR_1. METHOD_2 ( ) ) VAR_2. METHOD_3 ( key, VAR_1. METHOD_4 ( key ) ) ; }
+public void METHOD_2 ( ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_2 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_3 = TYPE_2. METHOD_1 ( ) ; add ( VAR_3 ) ; while ( ( VAR_1 ) <= ( VAR_2 ) ) { TYPE_1 VAR_3 = TYPE_2. METHOD_2 ( ) ; add ( VAR_3 ) ; ( VAR_1 ) ++ ; } }
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_2. METHOD_2 ( VAR_2 ) ; }
+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 ; }
+public void METHOD_2 ( ) { TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_2 ( TYPE_2 VAR_1, double VAR_2, double height ) { return new TYPE_1 ( VAR_1, VAR_2, height ) ; }
+public void METHOD_2 ( TYPE_2 c ) { VAR_2. add ( c ) ; }
+protected void METHOD_2 ( ) { TYPE_2. i ( VAR_2, STRING_2 ) ; }
+public boolean METHOD_2 ( 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 ; }
+public boolean METHOD_2 ( ) { return (! ( this. VAR_1. isEmpty ( ) ) ) || (! ( this. VAR_2. isEmpty ( ) ) ) || (! ( this. VAR_3. isEmpty ( ) ) ) ; }
+public boolean METHOD_2 ( ) { return this. VAR_1 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_2 ) { return 0 ; }
+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 ) ; }
+public void init ( ) { METHOD_1 ( new TYPE_1 ( ) ) ; add ( VAR_1, VAR_2 ) ; METHOD_2 ( VAR_3 ) ; METHOD_3 ( VAR_3 ) ; METHOD_4 ( VAR_3 ) ; VAR_4 = VAR_5 ; VAR_6 = false ; }
+public java.lang.String METHOD_2 ( ) { return getType ( ). toString ( ) ; }
+public void METHOD_1 ( java.lang.CharSequence title ) { super. METHOD_1 ( title ) ; if ( ( title!= null ) || ( ( METHOD_2 ( ) )!= null ) ) { METHOD_2 ( ). METHOD_1 ( title. toString ( ) ) ; } }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { return VAR_1. equals ( VAR_2 ) ; }
+public boolean METHOD_1 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_2 ( ) ; if ( VAR_1 == ( VAR_3 ) ) { VAR_4. METHOD_3 ( ) ; VAR_5. METHOD_4 ( VAR_6 ) ; return true ; } return false ; }
+private static double METHOD_2 ( double x ) { return x * x ; }
+public void METHOD_1 ( int VAR_1, java.lang.String VAR_2, java.lang.String VAR_3 ) { TYPE_1. METHOD_2 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_2, VAR_3 ) ) ; }
+public TYPE_1 METHOD_1 ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1. METHOD_2 ( ) ) ; }
+public void METHOD_2 ( final boolean VAR_2 ) { VAR_2. METHOD_2 ( VAR_2 ) ; }
+public int METHOD_2 ( TYPE_1 t ) { return t. getText ( ). length ( ) ; }
+public void METHOD_2 ( android.content.Intent VAR_1, int VAR_2 ) { android.content.Intent VAR_3 = new android.content.Intent ( VAR_1 ) ; METHOD_3 ( VAR_3 ) ; }
+public TYPE_1 METHOD_1 ( ) { int VAR_1 = java.lang.Math.abs ( ( ( VAR_2. METHOD_2 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_1 ( final TYPE_1 VAR_1, final TYPE_2 VAR_2 ) { METHOD_2 ( VAR_2 ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( METHOD_1 ( ) ) == 0 ) { return 0 ; } return ( VAR_1. size ( ) ) + ( VAR_2 ) ; }
+public TYPE_1 < TYPE_2 > METHOD_2 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_1. append ( c ) ; return c ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 VAR_1 = new TYPE_1 ( ) ; VAR_2. add ( VAR_1 ) ; for ( TYPE_2 listener : VAR_3 ) listener. METHOD_2 ( ) ; return VAR_1 ; }
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+public void METHOD_2 ( java.lang.String STRING_2 ) { for ( TYPE_1 VAR_3 : VAR_1 ) { if ( VAR_3!= null ) { METHOD_3 ( STRING_2 ) ; } } }
+public void METHOD_2 ( java.lang.String VAR_2 ) { if ( TYPE_2. METHOD_3 ( VAR_2 ) ) { return ; } this. VAR_2 = VAR_2 ; }
+public void METHOD_2 ( ) { for ( int i = 0 ; i < ( VAR_1. size ( ) ) ; i ++ ) { VAR_1. get ( i ). METHOD_3 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_2 ; }
+public java.lang.Object METHOD_1 ( java.lang.Integer VAR_1, java.lang.Integer size ) throws java.lang.Exception { return VAR_3. METHOD_1 ( VAR_1, size ) ; }
+public TYPE_1 METHOD_1 ( final TYPE_1 VAR_1 ) { return VAR_4. METHOD_3 ( VAR_3. METHOD_2 ( VAR_1 ) ) ; }
+public void METHOD_1 ( java.lang.String text ) { VAR_1. setText ( text ) ; }
+public TYPE_1 METHOD_1 ( java.lang.String text, java.lang.String text2 ) { return TYPE_1. METHOD_2 ( STRING_1, STRING_2, id, STRING_3, text, STRING_4, text2 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_2 ) { throw new TYPE_2 ( ) ; } }
+public void METHOD_2 ( ) { TYPE_1. METHOD_2 ( VAR_1, STRING_1 ) ; }
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_2 VAR_2 ) { return false ; }
+public void METHOD_2 ( ) throws TYPE_2 { TYPE_3 VAR_1 = new TYPE_3 ( this. VAR_2, STRING_1 ) ; VAR_1. METHOD_3 ( ) ; VAR_1. METHOD_4 ( ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_1 ) ; } else { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_2 ) ; } return true ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; TYPE_2 VAR_2 = ( ( TYPE_2 ) ( VAR_1. METHOD_2 ( VAR_3 ) ) ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( ) ; }
+private void METHOD_2 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_3 ( VAR_3 ) ; }
+private static java.lang.String METHOD_2 ( ) { try { return VAR_1 class. METHOD_3 ( ) ; } catch ( java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( STRING_1, VAR_2 ) ; return null ; } }
+void METHOD_2 ( ) { if ( METHOD_3 ( ) ) { VAR_1. METHOD_4 ( ) ; java.lang.System.out.println ( ( ( STRING_1 + ( VAR_2 ) ) + STRING_2 ) ) ; METHOD_5 ( ) ; } VAR_3 = false ; }
+private synchronized void METHOD_2 ( ) { VAR_1. METHOD_3 ( listener ) ; }
+public void METHOD_2 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; METHOD_3 ( ) ; setState ( VAR_3 ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_2 ( VAR_1 ) ; return true ; }
diff --git a/output/bugs2fix/prompt0/codegen1-multi-16B.output b/output/bugs2fix/prompt0/codegen1-multi-16B.output
new file mode 100644
index 0000000..e4dc7ce
--- /dev/null
+++ b/output/bugs2fix/prompt0/codegen1-multi-16B.output
@@ -0,0 +1,95 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1, VAR_1 ) ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { intent.setClass ( this, VAR_1 ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) VAR_3. METHOD_1 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 [ ( VAR_1. position ) ] = isEmpty ( ) ; VAR_1. position += 1 ; VAR_3 = METHOD_2 ( VAR_1. position ) ; return VAR_1 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ).toString(); VAR_5.setText(VAR_4); }
+public boolean METHOD_2 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_1 ( TYPE_1 VAR_1 ) {
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
+private static native void METHOD_2 ( long set ) ;
+public java.lang.Boolean METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { int count = VAR_3. METHOD_2 ( VAR_1 ) ; return count > 0 ; }
+public void METHOD_1 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( VAR_1. METHOD_4 ( ) ) ) { TYPE_1. METHOD_3 ( VAR_1, this ) ; } VAR_2 = false ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_2 ( VAR_2, ( STRING_1 + VAR_1 ) ) ; TYPE_3. METHOD_3 ( this, STRING_2, VAR_3 ). show ( ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_3. setText ( TYPE_2. METHOD_2 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! VAR_2 ; }
+private void METHOD_2 ( ) { METHOD_3 ( ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1, boolean VAR_2, boolean VAR_3 ) {
+private void METHOD_1 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 class ) ; int index = TYPE_1. METHOD_2 ( ). METHOD_3 ( ) ; intent. METHOD_4 ( STRING_1, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_1 ( TYPE_1 arg ) { VAR_1. METHOD_2 ( VAR_2. getId ( ), arg. METHOD_3 ( ), arg. METHOD_4 ( ) ) ; METHOD_5 ( ) ; }
+public void METHOD_1 ( ) { if (! ( VAR_1 ) ) { VAR_2. update ( ) ; } VAR_3. METHOD_1 ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_2 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_1 ( android.view.View VAR_1 ) { TYPE_1. METHOD_2 ( STRING_1, STRING_2 ) ; VAR_2. METHOD_3 ( ( ( TYPE_2 ) ( VAR_3. METHOD_4 ( ) ) ). METHOD_5 ( ) ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( this ) ; }
+public int update ( java.lang.Object VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_1 ( java.lang.Throwable VAR_1 ) { VAR_2. METHOD_2 ( ( STRING_1 + ( VAR_3. name ( ) ) ), VAR_1 ) ; METHOD_3 ( ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1 ) { return TYPE_1. METHOD_1 ( VAR_1, num. METHOD_2 ( ) ) ; }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; VAR_1 = this ; METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { if ( VAR_1 ) { VAR_1 = false ; VAR_2. METHOD_2 ( ) ; startTime = ( TYPE_1. METHOD_3 ( ) ) - ( VAR_3 ) ; } }
+public TYPE_1 METHOD_1 ( java.lang.Integer id ) { return VAR_1. METHOD_2 ( id ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.System.out.println ( STRING_1 ) ; VAR_2. METHOD_2 ( new TYPE_2 ( STRING_2, STRING_3 ) ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.Object [ ] VAR_2 = METHOD_2 ( VAR_1 ) ; METHOD_3 ( ) ; TYPE_2. METHOD_4 ( VAR_2 ) ; METHOD_5 ( new TYPE_3 ( VAR_2 ) ) ; }
+public static void main ( java.lang.String [ ] args ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ; java.lang.System.out.println ( VAR_1. METHOD_2 ( ) ) ; }
+public int getId ( ) { return VAR_2. id ; }
+public void METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_3. METHOD_2 ( VAR_2 ). compareTo ( VAR_3. METHOD_2 ( VAR_1 ) ) ; }
+public long METHOD_2 ( int i ) { return i ; }
+private static void METHOD_1 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { for ( java.lang.String key : VAR_1. METHOD_2 ( ) ) VAR_2. METHOD_3 ( key, VAR_1. METHOD_4 ( key ) ) ; }
+public void METHOD_1 ( ) { while ( VAR_1 <= VAR_2 ) { TYPE_1 VAR_3 = TYPE_2. METHOD_2 ( ) ; add ( VAR_3 ) ; VAR_1 ++ ; } }
+public void METHOD_1 ( ) throws java.io.IOException { TYPE_1. METHOD_1 ( VAR_1 ) ; }
+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 ; }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. i ( VAR_1, STRING_1 ) ; METHOD_2 ( ) ; TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_1 ( TYPE_2 VAR_1, double VAR_2, double height ) { return new TYPE_1 ( VAR_1, VAR_2, height ) ; }
+public void METHOD_1 ( TYPE_1 c ) { VAR_1. add ( c ) ; }
+protected void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. i ( VAR_1, STRING_1 ) ; }
+public boolean METHOD_2 ( 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 ; }
+public boolean METHOD_2 ( ) { return! ( this. VAR_1. isEmpty ( ) ) ||! ( this. VAR_2. isEmpty ( ) ) ; }
+public boolean METHOD_2 ( ) { java.lang.System.out.println ( VAR_1 ) ; return this. VAR_1 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_2 ) { return 0 ; }
+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 ) ; }
+public void init ( ) { METHOD_1 ( new TYPE_1 ( ) ) ; add ( VAR_1, VAR_2 ) ; METHOD_2 ( VAR_3 ) ; METHOD_3 ( VAR_3 ) ; METHOD_4 ( VAR_3 ) ; VAR_4 = VAR_5 ; VAR_6 = true ; }
+public java.lang.String METHOD_1 ( ) { switch ( METHOD_2 ( ) ) { case 1 : return null ; case INT_1 : return null ; case INT_2 : return getType ( ). toString ( ) ; default : return null ; } }
+public void METHOD_1 ( java.lang.CharSequence title ) { super. METHOD_1 ( title ) ; if ( ( title!= null ) || ( ( METHOD_2 ( ) )!= null ) ) { METHOD_2 ( ). METHOD_1 ( title. toString ( ) ) ; } }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+public boolean METHOD_1 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_2 ( ) ; if ( VAR_1 == ( VAR_3 ) ) { VAR_4. METHOD_3 ( ) ; VAR_5. METHOD_4 ( VAR_6 ) ; return true ; } return false ; }
+private static double METHOD_2 ( double p ) { double sum = 0 ; for ( double i = p ; i > 0 ; i -= 1 ) { sum -= i * ( TYPE_1. METHOD_2 ( i ) ) ; } return sum ; }
+public void METHOD_1 ( int VAR_1, java.lang.String VAR_2, java.lang.String VAR_3 ) { TYPE_1. METHOD_2 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_2, VAR_3 ) ) ; }
+private TYPE_1 METHOD_1 ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1. METHOD_2 ( ) ) ; }
+public void METHOD_1 ( final boolean VAR_1 ) {
+public int METHOD_3 ( java.lang.String str ) { java.lang.String str1 = java.lang.String. METHOD_2 ( ( ( TYPE_1 ) ( VAR_1 ) ). getText ( ) ) ; METHOD_4 ( str1 ) ; return VAR_2 ; }
+public void METHOD_1 ( ) { android.content.Intent VAR_1 = new android.content.Intent ( VAR_2 ) ; METHOD_2 ( VAR_1, 0 ) ; android.content.Intent i = new android.content.Intent ( this, VAR_3 class ) ; METHOD_3 ( i ) ; }
+public TYPE_1 METHOD_1 ( ) { int VAR_1 = java.lang.Math.abs ( ( ( VAR_2. METHOD_2 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_1 ( final TYPE_1 VAR_1, final TYPE_2 VAR_2 ) { METHOD_2 ( VAR_2 ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( VAR_1. size ( ) ) == 0 ) { return 0 ; } return ( VAR_2 ) + ( VAR_1. size ( ) ) ; }
+public TYPE_1 < TYPE_2 > METHOD_1 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_1. append ( c ) ; return c ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 VAR_1 = new TYPE_1 ( ) ; VAR_2. add ( VAR_1 ) ; for ( TYPE_2 listener : VAR_3 ) listener. METHOD_2 ( ) ; METHOD_3 ( ) ; return VAR_1 ; }
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+public void METHOD_1 ( java.util.List < TYPE_1 > VAR_1 ) { for ( TYPE_1 VAR_2 : VAR_1 ) { if ( VAR_2!= null ) { METHOD_2 ( java.lang.String.format ( STRING_1 ) ) ; } } }
+public void METHOD_1 ( java.lang.String VAR_1 ) { if ( TYPE_1. METHOD_2 ( VAR_1 ) ) { return ; } this. VAR_1 = VAR_1 ; }
+public void METHOD_1 ( ) { for ( Iterator <? > i = VAR_1. iterator ( ) ; i. hasNext ( ) ; ) { i. next ( ). METHOD_2 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_1 ; }
+public java.lang.Object METHOD_1 ( java.lang.Integer VAR_1, java.lang.Integer size, java.lang.Long VAR_2 ) throws java.lang.Exception { return VAR_3. METHOD_1 ( VAR_2, VAR_1, size ) ; }
+public TYPE_1 METHOD_1 ( final TYPE_1 VAR_1 ) { return VAR_3. METHOD_2 ( VAR_1 ) ; }
+public void METHOD_1 ( java.lang.String text ) { VAR_1. METHOD_2 ( 0 ) ; }
+public TYPE_1 METHOD_1 ( java.lang.String text, java.lang.String id, java.lang.String name ) { return TYPE_1. METHOD_2 ( STRING_1, STRING_2, id, STRING_3, text, id, name ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { throw new TYPE_2 ( ) ; } }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. METHOD_2 ( VAR_1, STRING_1 ) ; VAR_2. METHOD_3 ( ) ; }
+public boolean METHOD_1 ( android.view.View VAR_1, TYPE_1 VAR_2 ) { return false ; }
+public void METHOD_1 ( ) throws TYPE_1 { TYPE_2 VAR_1 = new TYPE_2 ( this. VAR_2, STRING_1 ) ; VAR_1. METHOD_2 ( ) ; VAR_1. METHOD_3 ( ) ; TYPE_3. assertNotNull ( VAR_1. METHOD_4 ( ) ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_1 ) ; } else { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_2 ) ; } return true ; }
+public void METHOD_1 ( android.view.View view, TYPE_1 VAR_1 ) { super. METHOD_1 ( view, VAR_1 ) ; TYPE_2 VAR_2 = ( ( TYPE_2 ) ( view. METHOD_2 ( VAR_3 ) ) ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( ) ; }
+private void METHOD_1 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_3 ( VAR_3 ) ; else VAR_2. METHOD_3 ( VAR_4 ) ; }
+private static java.lang.String METHOD_1 ( ) { try { return VAR_1 class. METHOD_2 ( ). METHOD_3 ( ) ; } catch ( java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( STRING_1, VAR_2 ) ; return null ; } }
+void METHOD_1 ( ) { if ( METHOD_2 ( ) ) { VAR_1. METHOD_3 ( ) ; METHOD_4 ( ) ; java.lang.System.out.println ( ( ( STRING_1 + ( VAR_2 ) ) + STRING_2 ) ) ; METHOD_5 ( ) ; } VAR_3 = false ; }
+private synchronized void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_1. METHOD_3 ( VAR_3 ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; METHOD_3 ( ) ; setState ( VAR_3 ) ; METHOD_4 ( ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_2 ( VAR_1 ) ; result. METHOD_3 ( ) ; return true ; }
diff --git a/output/bugs2fix/prompt0/codegen1-multi-2B.output b/output/bugs2fix/prompt0/codegen1-multi-2B.output
new file mode 100644
index 0000000..f937ce8
--- /dev/null
+++ b/output/bugs2fix/prompt0/codegen1-multi-2B.output
@@ -0,0 +1,95 @@
+private TYPE_1 getType ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { TYPE_3 VAR_3 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_3, VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, intent ) ; }
+public void METHOD_1 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) { VAR_1. METHOD_2 ( ) ; } METHOD_3 ( ) ; if ( ( VAR_3 )!= null ) { VAR_3. METHOD_1 ( ) ; } }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; VAR_1. position += 1 ; V
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_1 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
+private static native void METHOD_2 ( long set ) ;
+public java.lang.Boolean METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { int count = VAR_3. METHOD_2 ( VAR_1 ) ; return count > 0 ; }
+public void METHOD_1 ( ) { if ( ( ( VAR_1 )!= null ) && ( VAR_1. METHOD_2 ( ) ) ) { TYPE_1. METHOD_3 ( VAR_1, this ) ; VAR_1. METHOD_4 ( ) ; } TYPE_1. METHOD_5 ( VAR_1, this ) ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Class <? > VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_2 ( VAR_2, ( STRING_1 + VAR_1 ) ) ; TYPE_3. METHOD_3 ( this, STRING_2, VAR_3 ). show ( ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_3. setText ( TYPE_2. METHOD_2 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! ( VAR_2 ) ; }
+private void METHOD_2 ( ) { METHOD_3 ( ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1, boolean VAR_2, boolean VAR_3 ) { this. METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+private void METHOD_1 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 class ) ; int index = TYPE_1. METHOD_2 ( ). METHOD_3 ( ) ; intent. METHOD_4 ( STRING_1, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_1 ( TYPE_1 arg ) { VAR_1. METHOD_2 ( VAR_2. getId ( ), arg. METHOD_3 ( ), arg. METHOD_4 ( ) ) ; METHOD_5 ( ) ; }
+public void METHOD_2 ( ) { if (! ( VAR_1 ) ) { VAR_2. update ( ) ; } VAR_3. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_2 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_1 ( android.view.View VAR_1, TYPE_1 TYPE_2, TYPE_3 TYPE_4, TYPE_5 TYPE_5 ) { TYPE_1. METHOD_2 ( STRING_1, STRING_2 ) ; VAR_2. METHOD_3 ( ( ( TYPE_2 ) ( VAR_3. METHOD_4 ( ) ) ). METHOD_5 ( ) ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( this ) ; }
+public int update ( java.lang.Object VAR_1, java.lang.Object VAR_2 ) { VAR_3. METHOD_1 ( VAR_1, VAR_2 ) ; METHOD_4 ( ) ; try { return METHOD_5 ( VAR_3. METHOD_6 ( ) ). execute ( ) ; } finally { VAR_3. METHOD_7 ( ) ; } }
+public void METHOD_1 ( java.lang.Throwable VAR_1 ) { VAR_2. METHOD_2 ( ( STRING_1 + ( VAR_3. name ( ) ) ), VAR_1 ) ; METHOD_3 ( ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1, float VAR_2 ) { return TYPE_1. METHOD_1 ( VAR_1, VAR_2 ) ; }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; VAR_1 = this ; METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { if ( VAR_1 ) { VAR_1 = false ; VAR_2. METHOD_2 ( ) ; startTime = ( TYPE_1. METHOD_3 ( ) ) - ( VAR_3 ) ; } }
+public TYPE_1 METHOD_2 ( java.lang.Integer id ) { return VAR_1. METHOD_1 ( id ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { java.lang.System.out.println ( STRING_1 ) ; VAR_1. METHOD_1 ( new TYPE_1 ( TYPE_3. METHOD_3 ( STRING_2, STRING_3 ) ) ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.Object [ ] VAR_2 = METHOD_2 ( VAR_1 ) ; TYPE_2. METHOD_4 ( VAR_2 ) ; TYPE_3. METHOD_5 ( new TYPE_3 ( VAR_2 ) ) ; }
+public static void main ( java.lang.String [ ] args ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ; TYPE_2. METHOD_2 ( ) ; java.lang.System.out.println ( VAR_1. METHOD_2 ( ) ) ; }
+public int getId ( ) { return VAR_1. id ; }
+public void METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_3. METHOD_1 ( VAR_1 ). compareTo ( VAR_3. METHOD_1 ( VAR_2 ) ) ; }
+public long METHOD_2 ( int i ) { return i ; }
+private static void METHOD_2 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { for ( java.lang.String key : VAR_1. METHOD_3 ( ) ) VAR_2. METHOD_4 ( key, VAR_1. METHOD_5 ( key ) ) ; }
+public void METHOD_1 ( ) { while ( ( VAR_1 ) <= ( VAR_2 ) ) { TYPE_1 VAR_3 = TYPE_2. METHOD_2 ( ) ; add ( VAR_3 ) ; ( VAR_1 ) ++ ; } }
+public void METHOD_1 ( ) throws java.io.IOException { TYPE_1. METHOD_1 ( VAR_1 ) ; TYPE_1. VAR_1 = null ; TYPE_1. VAR_2 = null ; }
+private static TYPE_1 METHOD_2 ( TYPE_1 VAR_2 ) { TYPE_1 VAR_1 = VAR_2 ; for ( int i = 2 ; i < VAR_2. getValue () ; i ++ ) { VAR_1 = VAR_1. METHOD_1 ( i ) ; } return VAR_1 ; }
+public void METHOD_1 ( ) { super. METHOD_1 ( ) ; TYPE_1. i ( VAR_1, STRING_1 ) ; TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_1 ( TYPE_2 VAR_1, double VAR_2, double height ) { if ( ( VAR_3 ) == null ) { VAR_3 = new TYPE_1 ( VAR_1, VAR_2, height ) ; } return VAR_3 ; }
+public void METHOD_1 ( TYPE_1 c ) { c. METHOD_2 ( ) ; VAR_1. add ( c ) ; }
+protected void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. i ( VAR_2, STRING_2 ) ; }
+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 ; }
+public boolean METHOD_2 ( ) { return (! ( this. VAR_1. isEmpty ( ) ) ) || (! ( this. VAR_2. isEmpty ( ) ) ) ; }
+public boolean METHOD_2 ( ) { return this. VAR_1 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_1 ( java.lang.Object VAR_1 ) { return 1 ; }
+public void METHOD_1 ( java.lang.String url, TYPE_1 VAR_1, TYPE_2 VAR_2, TYPE_3 status, TYPE_4 VAR_4 ) { VAR_3. id ( VAR_1 ). METHOD_2 ( TYPE_4. METHOD_3 ( TYPE_4. METHOD_4 ( VAR_2 ) ) ). METHOD_5 ( VAR_4 ) ; }
+public void init ( ) { METHOD_1 ( new TYPE_1 ( ) ) ; add ( VAR_1, VAR_2 ) ; METHOD_2 ( VAR_3 ) ; METHOD_3 ( VAR_3 ) ; METHOD_4 ( VAR_3 ) ; VAR_4 = VAR_5 ; VAR_6 = true ; }
+public java.lang.String METHOD_1 ( ) { switch ( METHOD_2 ( ) ) { case 1 : return null ; case INT_1 : return null ; case INT_2 : return getType ( ). toString ( ) ; default : return null ; } }
+public void METHOD_1 ( java.lang.CharSequence title ) { super. METHOD_1 ( title ) ; if ( ( title!= null ) || ( ( METHOD_2 ( ) )!= null ) ) { METHOD_2 ( ). METHOD_1 ( title. toString ( ) ) ; } }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+public boolean METHOD_2 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_2 ( ) ; if ( VAR_1 == ( VAR_3 ) ) { VAR_4. METHOD_3 ( ) ; VAR_5. METHOD_4 ( VAR_6 ) ; return true ; } return false ; }
+private static double METHOD_2 ( java.util.ArrayList < java.lang.Double > p ) { double sum = 0 ; for ( double i : p ) { sum += i * ( TYPE_1. METHOD_3 ( i ) ) ; } return sum ; }
+public void METHOD_1 ( int VAR_1, java.lang.String VAR_2, java.lang.String VAR_3 ) { TYPE_1. METHOD_2 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_2, VAR_3 ) ) ; }
+private TYPE_1 METHOD_1 ( TYPE_2 VAR_1 ) { java.lang.String VAR_2 = VAR_1. METHOD_2 ( ) ; return new TYPE_1 ( VAR_2 ) ; }
+public void METHOD_2 ( final boolean VAR_1 ) { VAR_2. METHOD_2 ( VAR_1 ) ; }
+public int METHOD_1 ( ) { java.lang.String str = java.lang.String. METHOD_2 ( ( TYPE_1 ) ( VAR_1 ) ). getText ( ) ; METHOD_3 ( str ) ; return VAR_2 ; }
+public void METHOD_1 ( ) { android.content.Intent VAR_1 = new android.content.Intent ( VAR_2 ) ; METHOD_2 ( VAR_1, 0 ) ; android.content.Intent i = new android.content.Intent ( this, VAR_3 class ) ; METHOD_3 ( i ) ; }
+public TYPE_1 METHOD_1 ( ) { int VAR_1 = java.lang.Math. abs ( ( ( VAR_2. METHOD_2 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_1 ( final TYPE_1 VAR_1, final TYPE_2 VAR_2 ) { METHOD_2 ( VAR_2 ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_1 ; }
+public int METHOD_1 ( ) { if ( ( METHOD_2 ( ) ) == 0 ) { return 0 ; } return ( VAR_1. size ( ) ) + ( VAR_2 ) ; }
+public TYPE_1 < TYPE_2 > METHOD_1 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_1. append ( c ) ; return c ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 VAR_1 = new TYPE_1 ( ) ; VAR_2. add ( VAR_1 ) ; for ( TYPE_2 listener : VAR_3 ) listener. METHOD_2 ( ) ; METHOD_3 ( ) ; return VAR_1 ; }
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+public void METHOD_1 ( java.util.List < TYPE_1 > VAR_1 ) { for ( TYPE_1 VAR_2 : VAR_1 ) { if ( VAR_2!= null ) { METHOD_2 ( String.format ( STRING_1 ) ) ; } } }
+public void METHOD_1 ( java.lang.String VAR_1 ) { if ( TYPE_1. METHOD_2 ( VAR_1 ) ) { return ; } TYPE_1. METHOD_2 ( VAR_1 ) ; }
+public void METHOD_2 ( ) { for ( int i = 0 ; i < ( VAR_1. size ( ) ) ; i ++ ) { VAR_1. get ( i ). METHOD_1 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_1 ; }
+public java.lang.Object METHOD_1 ( java.lang.Integer VAR_1, java.lang.Integer size ) throws java.lang.Exception { return VAR_3. METHOD_1 ( VAR_1, size ) ; }
+public TYPE_1 METHOD_1 ( final TYPE_1 VAR_1 ) { final TYPE_2 < TYPE_1 > VAR_2 = VAR_3. METHOD_2 ( VAR_1 ) ; return VAR_4. METHOD_3 ( VAR_2 ) ; }
+public void METHOD_1 ( java.lang.String text ) { VAR_1. setText ( text ) ; VAR_1. METHOD_2 ( 0 ) ; }
+public TYPE_1 METHOD_2 ( java.lang.String id, java.lang.String text ) { return TYPE_1. METHOD_3 ( STRING_1, STRING_2, id, STRING_3, text ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { throw new TYPE_2 ( ) ; } }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_1. METHOD_3 ( VAR_1, STRING_1 ) ; VAR_2. METHOD_4 ( ) ; }
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_2 VAR_2 ) { return false ; }
+public void METHOD_1 ( ) throws TYPE_1 { TYPE_2 VAR_1 = new TYPE_2 ( this. VAR_2, STRING_1 ) ; TYPE_3. assertNotNull ( VAR_1. METHOD_4 ( ) ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_1 ) ; } else { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_2 ) ; } return true ; }
+public void METHOD_1 ( android.view.View view, TYPE_1 VAR_1 ) { super. METHOD_1 ( view, VAR_1 ) ; TYPE_2 VAR_2 = ( ( TYPE_2 ) ( view. METHOD_2 ( VAR_3 ) ) ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( ) ; }
+private void METHOD_2 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_3 ( VAR_3 ) ; else VAR_2. METHOD_3 ( VAR_4 ) ; }
+private static java.lang.String METHOD_1 ( ) { try { return VAR_1 class. METHOD_2 ( ). METHOD_3 ( ) ; } catch ( java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( STRING_1, VAR_2 ) ; return null ; } }
+void METHOD_1 ( ) { if ( METHOD_2 ( ) ) { VAR_1. METHOD_3 ( ) ; METHOD_4 ( ) ; java.lang.System.out.println ( ( ( STRING_1 + ( VAR_2 ) ) + STRING_2 ) ) ; METHOD_5 ( ) ; } VAR_3 = false ; }
+private synchronized void METHOD_2 ( ) { VAR_1. METHOD_3 ( listener ) ; VAR_1. METHOD_2 ( VAR_2 ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; METHOD_3 ( ) ; setState ( VAR_3 ) ; METHOD_4 ( ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_2 ( VAR_1 ) ; result. METHOD_3 ( ) ; return true ; }
diff --git a/output/bugs2fix/prompt0/codegen1-multi-350M.output b/output/bugs2fix/prompt0/codegen1-multi-350M.output
new file mode 100644
index 0000000..da78509
--- /dev/null
+++ b/output/bugs2fix/prompt0/codegen1-multi-350M.output
@@ -0,0 +1,95 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 var1 ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+public void METHOD_2 ( ) { TYPE_2. METHOD_3 ( METHOD_4 ( ). getString ( VAR_1 ), VAR_2 ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_1 ( TYPE_1 item ) { switch ( item. METHOD_2 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_1 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_1 ( java.lang.String id, java.lang.String value ) { return VAR_1. METHOD_1 ( id, value ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
+private static native void METHOD_2 ( long set ) ;
+public java.lang.Boolean METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { int count = VAR_3. METHOD_2 ( VAR_1 ) ; return count > 0 ; }
+public void METHOD_2 ( ) { if ( ( ( VAR_2 )!= null ) && ( VAR_2. METHOD_3 ( ) ) ) { TYPE_2. METHOD_4 ( VAR_2, this ) ; VAR_2. METHOD_5 ( ) ; } VAR_3 = false ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_2 ( VAR_2, ( STRING_1 + VAR_1 ) ) ; TYPE_3. METHOD_3 ( this, STRING_2, VAR_3 ). show ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3 ) { VAR_3. setText ( TYPE_1. METHOD_1 ( ( ( TYPE_1 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_3 =! ( VAR_3 ) ; }
+private void METHOD_2 ( ) { }
+public void METHOD_1 ( TYPE_1 VAR_1, boolean VAR_2, boolean VAR_3 ) { this. METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+private void METHOD_2 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 class ) ; int index = TYPE_2. METHOD_3 ( ). METHOD_4 ( ) ; intent. METHOD_5 ( STRING_2, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_2 ( TYPE_1 arg ) { VAR_1. METHOD_2 ( VAR_2. getId ( ), arg. METHOD_3 ( ), arg. METHOD_4 ( ) ) ; METHOD_5 ( ) ; }
+public void METHOD_2 ( ) { if (! ( VAR_2 ) ) { VAR_3. update ( ) ; } VAR_4. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_2 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_2 ( android.view.View VAR_1 ) { TYPE_1. METHOD_2 ( STRING_1, STRING_2 ) ; VAR_2. METHOD_3 ( ( ( TYPE_2 ) ( VAR_3. METHOD_4 ( ) ) ). METHOD_5 ( ) ) ; }
+public void METHOD_2 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( this ) ; }
+public int update ( java.lang.Object VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_2 ( java.lang.String VAR_1, java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( ( STRING_1 + ( VAR_3. name ( ) ) ), VAR_2 ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1, float VAR_2 ) { return TYPE_1. METHOD_1 ( VAR_1, VAR_2 ) ; }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; VAR_2 = this ; METHOD_3 ( ) ; }
+public void METHOD_2 ( ) { if ( VAR_2 ) { VAR_2 = false ; VAR_3. METHOD_3 ( ) ; startTime = ( TYPE_2. METHOD_4 ( ) ) - ( VAR_4 ) ; } }
+public TYPE_1 METHOD_1 ( java.lang.Integer id, java.lang.Integer i ) { return VAR_1. METHOD_2 ( id, i ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { java.lang.System.out.println ( STRING_2 ) ; VAR_1. METHOD_1 ( new TYPE_1 ( TYPE_3. METHOD_3 ( STRING_1, STRING_3 ) ) ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { java.lang.Object [ ] VAR_1 = METHOD_1 ( VAR_2 ) ; METHOD_3 ( ) ; TYPE_1. METHOD_4 ( VAR_1 ) ; METHOD_5 ( new TYPE_3 ( VAR_1 ) ) ; }
+public static void main ( java.lang.String [ ] args ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ; java.lang.System.out.println ( VAR_1. METHOD_2 ( ) ) ; }
+public int getId ( ) { return VAR_2. id ; }
+public void METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_1 ) { return VAR_3. METHOD_2 ( VAR_1 ) ; }
+public long METHOD_2 ( int i ) { return i ; }
+private static void METHOD_2 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { for ( java.lang.String key : VAR_1. METHOD_2 ( ) ) VAR_2. METHOD_3 ( key, VAR_1. METHOD_4 ( key ) ) ; }
+public void METHOD_2 ( ) { while ( ( VAR_1 ) <= ( VAR_2 ) ) { TYPE_1 VAR_3 = TYPE_2. METHOD_2 ( ) ; add ( VAR_3 ) ; ( VAR_1 ) ++ ; } }
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_2. METHOD_2 ( VAR_1 ) ; this. VAR_1 = null ; this. VAR_2 = null ; }
+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 ; }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. i ( VAR_1, STRING_1 ) ; METHOD_1 ( ) ; TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_1 ( TYPE_2 VAR_1, double VAR_2, double height, TYPE_3 VAR_3 ) { if ( ( VAR_3 ) == null ) { VAR_3 = new TYPE_1 ( VAR_1, VAR_2, height ) ; } return VAR_3 ; }
+public void METHOD_2 ( TYPE_2 c ) { c. METHOD_3 ( ) ; VAR_2. add ( c ) ; }
+protected void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. i ( VAR_2, STRING_2 ) ; }
+public boolean METHOD_2 ( 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 ; }
+public boolean METHOD_2 ( ) { return (! ( this. VAR_1. isEmpty ( ) ) ) && (! ( this. VAR_2. isEmpty ( ) ) ) ; }
+public boolean METHOD_2 ( ) { java.lang.System.out.println ( VAR_2 ) ; return this. VAR_2 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_1 ) { return 0 ; }
+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 ) ; }
+public void init ( ) { METHOD_1 ( new TYPE_1 ( ) ) ; add ( VAR_1, VAR_2 ) ; METHOD_2 ( VAR_3 ) ; METHOD_3 ( VAR_3 ) ; METHOD_4 ( VAR_3 ) ; VAR_4 = VAR_5 ; VAR_6 = false ; }
+public java.lang.String METHOD_2 ( ) { switch ( METHOD_1 ( ) ) { case 1 : return null ; case INT_1 : return null ; case INT_2 : return getType ( ). toString ( ) ; default : return null ; } }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+public boolean METHOD_1 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_2 ( ) ; if ( VAR_1 == ( VAR_3 ) ) { VAR_4. METHOD_3 ( ) ; VAR_5. METHOD_4 ( VAR_6 ) ; return true ; } return false ; }
+private static double METHOD_2 ( java.util.ArrayList < java.lang.Double > p ) { double sum = 0 ; for ( double i : p ) { sum -= i * ( TYPE_2. METHOD_1 ( i ) ) ; } return sum ; }
+public void METHOD_2 ( int VAR_1, java.lang.String VAR_2, java.lang.String VAR_3 ) { TYPE_1. METHOD_2 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_2, VAR_3 ) ) ; }
+private TYPE_1 METHOD_1 ( TYPE_2 VAR_1 ) { java.lang.String VAR_2 = VAR_1. METHOD_2 ( ) ; return new TYPE_1 ( VAR_2 ) ; }
+public void METHOD_2 ( final boolean VAR_1 ) { VAR_2. METHOD_2 ( VAR_1 ) ; }
+public int METHOD_1 ( ) { java.lang.String str = java.lang.String. METHOD_2 ( ( ( TYPE_1 ) ( VAR_1 ) ). getText ( ) ) ; METHOD_3 ( str ) ; return VAR_2 ; }
+public void METHOD_2 ( android.content.Intent VAR_1, int VAR_2 ) { android.content.Intent VAR_3 = new android.content.Intent ( VAR_1 ) ; METHOD_4 ( VAR_3, VAR_2 ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) { int VAR_1 = java.lang.Math.abs ( ( ( VAR_2. METHOD_2 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_2 ( final TYPE_1 VAR_1 ) { METHOD_3 ( VAR_1 ) ; METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( METHOD_1 ( ) ) == 0 ) { return 0 ; } return ( VAR_1. size ( ) ) + ( VAR_2 ) ; }
+public TYPE_1 < TYPE_2 > METHOD_1 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b, TYPE_1 < TYPE_2 > c ) { TYPE_3 d = new TYPE_3 ( a, b, c ) ; VAR_1. append ( d ) ; return d ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_1 VAR_2. add ( VAR_1 ) ; for ( TYPE_2 listener : VAR_3 ) listener. METHOD_2 ( ) ; METHOD_3 ( ) ; return VAR_1 ; }
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+public void METHOD_2 ( java.lang.String VAR_1 ) { for ( TYPE_1 VAR_2 : VAR_1 ) { if ( VAR_2!= null ) { METHOD_3 ( VAR_2 ) ; } } }
+public void METHOD_2 ( java.lang.String VAR_1 ) { if ( TYPE_1. METHOD_2 ( VAR_1 ) ) { return ; } this. VAR_1 = VAR_1 ; }
+public void METHOD_2 ( ) { for ( int i = 0 ; i < ( VAR_2. size ( ) ) ; i ++ ) { VAR_2. get ( i ). METHOD_3 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_2 ; }
+public java.lang.Object METHOD_1 ( java.lang.Integer VAR_1, java.lang.Integer size, java.lang.Long VAR_2 ) throws java.lang.Exception { return VAR_3. METHOD_1 ( VAR_2, VAR_1, size ) ; }
+public TYPE_1 METHOD_1 ( final TYPE_1 VAR_1 ) { final TYPE_2 < TYPE_1 > VAR_2 = VAR_3. METHOD_2 ( VAR_1 ) ; return VAR_4. METHOD_3 ( VAR_2 ) ; }
+public void METHOD_2 ( int i ) { VAR_2. setInt ( i ) ; VAR_2. METHOD_3 ( 0 ) ; }
+public TYPE_1 METHOD_1 ( java.lang.String text, java.lang.String id ) { return TYPE_1. METHOD_2 ( STRING_1, STRING_2, id, STRING_3, text ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3 ) { throw new TYPE_3 ( ) ; } }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. METHOD_3 ( ) ; }
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_1 VAR_2 ) { return false ; }
+public void METHOD_2 ( ) throws TYPE_2 { TYPE_3. assertNotNull ( VAR_1. METHOD_4 ( ) ) ; }
+public boolean METHOD_2 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_1. METHOD_2 ( 1 ) ; } else { VAR_1. METHOD_2 ( 1 ) ; } return true ; }
+public void METHOD_1 ( android.view.View view, TYPE_1 VAR_1 ) { super. METHOD_1 ( view, VAR_1 ) ; TYPE_2 VAR_2 = ( ( TYPE_2 ) ( view. METHOD_2 ( VAR_3 ) ) ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( ) ; }
+private void METHOD_2 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_3 ( VAR_3 ) ; else VAR_2. METHOD_3 ( VAR_4 ) ; }
+private static java.lang.String METHOD_2 ( ) { try { return VAR_2 class. METHOD_3 ( ). METHOD_4 ( ) ; } catch ( java.lang.Throwable VAR_3 ) { VAR_4. METHOD_5 ( STRING_1, VAR_3 ) ; return null ; } }
+void METHOD_2 ( ) { if ( METHOD_3 ( ) ) { VAR_1. METHOD_4 ( ) ; VAR_2. METHOD_5 ( ) ; java.lang.System.out.println ( ( ( STRING_1 + ( VAR_2 ) ) + STRING_2 ) ) ; METHOD_5 ( ) ; } VAR_3 = false ; }
+private synchronized void METHOD_2 ( ) { VAR_2. METHOD_3 ( listener ) ; }
+public void METHOD_2 ( ) { VAR_2. METHOD_3 ( VAR_3 ) ; METHOD_4 ( ) ; setState ( VAR_4 ) ; METHOD_5 ( ) ; }
+public boolean METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_1 ( VAR_1 ) ; result. METHOD_3 ( ) ; return true ; }
diff --git a/output/bugs2fix/prompt0/codegen1-multi-6B.output b/output/bugs2fix/prompt0/codegen1-multi-6B.output
new file mode 100644
index 0000000..87e9bc9
--- /dev/null
+++ b/output/bugs2fix/prompt0/codegen1-multi-6B.output
@@ -0,0 +1,95 @@
+private TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_1 METHOD_2 ( ) { TYPE_1 output = VAR_1 [ VAR_2 ] ; VAR_2 = ( VAR_2 ) - 1 ; return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { for ( TYPE_1 VAR_1 : VAR_2 ) VAR_1. METHOD_2 ( ) ; }
+public void METHOD_1 ( ) { TYPE_1. METHOD_2 ( METHOD_3 ( ), METHOD_4 ( ). getString ( VAR_1 ) ). show ( ) ; }
+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 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( int VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public char getColor ( ) throws java.io.IOException { return VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ). METHOD_3 ( 0 ) ; }
+public void METHOD_1 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_2 ( ). METHOD_3 ( VAR_2, VAR_1 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_2 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; case VAR_3 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+private static void METHOD_2 ( long set )
+public java.lang.Boolean METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return VAR_3. METHOD_2 ( VAR_1 ) > 0 ; }
+public void METHOD_2 ( ) { if ( ( ( VAR_1 )!= null ) && ( VAR_1. METHOD_2 ( ) ) ) { TYPE_1. METHOD_3 ( VAR_1, this ) ; VAR_1. METHOD_4 ( ) ; } VAR_2 = false ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_2 ( VAR_2, ( STRING_1 + VAR_1 ) ) ; TYPE_3. METHOD_3 ( this, STRING_2, VAR_3 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_2 ) { VAR_3. setText ( TYPE_3. METHOD_3 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! ( VAR_2 ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { METHOD_3 ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_1, boolean VAR_2 ) { this. METHOD_2 ( VAR_1, VAR_2, VAR_2 ) ; }
+private void METHOD_2 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 class ) ; int index = TYPE_1. METHOD_2 ( ). METHOD_3 ( ) ; intent. METHOD_4 ( STRING_1, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_1 ( TYPE_1 arg ) { VAR_1. METHOD_2 ( VAR_2. getId ( ), arg. METHOD_3 ( ), arg. METHOD_4 ( ) ) ; METHOD_5 ( ) ; }
+public void METHOD_2 ( ) { if ( VAR_1 ) { VAR_2. update ( ) ; } VAR_3. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_1 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_2 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_1 ( android.view.View VAR_1 ) { TYPE_1. METHOD_2 ( STRING_1, STRING_2 ) ; VAR_2. METHOD_3 ( ( ( TYPE_2 ) ( VAR_3. METHOD_4 ( ) ) ). METHOD_5 ( ) ) ; }
+public void METHOD_1 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( this ) ; }
+public int update ( java.lang.Object VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_2 ( java.lang.String STRING_2, java.lang.Throwable VAR_2 ) { METHOD_3 ( ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1 ) { return TYPE_1. METHOD_1 ( VAR_1, num. METHOD_2 ( ) ) ; }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; VAR_2 = this ; }
+public void METHOD_2 ( ) { if ( VAR_1 ) { VAR_1 = false ; VAR_2. METHOD_2 ( ) ; startTime = ( TYPE_1. METHOD_3 ( ) ) - ( VAR_3 ) ; } }
+public TYPE_1 METHOD_1 ( java.lang.Integer id ) { return VAR_1. METHOD_1 ( id ) ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { java.lang.System.out.println ( STRING_1 ) ; VAR_2. METHOD_2 ( new TYPE_2 ( TYPE_3. METHOD_3 ( STRING_2, STRING_3 ) ) ) ; }
+private void METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_4 ( METHOD_2 ( VAR_1 ) ) ; TYPE_3. METHOD_5 ( new TYPE_3 ( METHOD_2 ( VAR_1 ) ) ) ; }
+public static void main ( java.lang.String [ ] args ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ; java.lang.System.out.println ( VAR_1. METHOD_2 ( ) ) ; }
+public int getId2 ( ) { return VAR_2. id ; }
+public void METHOD_1 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_3. METHOD_2 ( VAR_1 ). compareTo ( VAR_3. METHOD_2 ( VAR_2 ) ) ; }
+public long METHOD_2 ( int i ) { return i + 1 ; }
+private static void METHOD_1 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { for ( java.lang.String key : VAR_1. METHOD_2 ( ) ) VAR_2. METHOD_3 ( key, VAR_1. METHOD_4 ( key ) ) ; }
+public void METHOD_2 ( ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_2 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_3 = TYPE_2. METHOD_1 ( ) ; add ( VAR_3 ) ; while ( ( VAR_1 ) <= ( VAR_2 ) ) { TYPE_1 VAR_3 = TYPE_2. METHOD_2 ( ) ; add ( VAR_3 ) ; ( VAR_1 ) ++ ; } }
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_2. METHOD_2 ( VAR_2 ) ; }
+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 ; }
+public void METHOD_2 ( ) { TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_2 ( TYPE_2 VAR_1, double VAR_2, double height ) { return new TYPE_1 ( VAR_1, VAR_2, height ) ; }
+public void METHOD_2 ( TYPE_2 c ) { VAR_2. add ( c ) ; }
+protected void METHOD_2 ( ) { TYPE_2. i ( VAR_2, STRING_2 ) ; }
+public boolean METHOD_2 ( 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 ; }
+public boolean METHOD_2 ( ) { return (! ( this. VAR_1. isEmpty ( ) ) ) || (! ( this. VAR_2. isEmpty ( ) ) ) || (! ( this. VAR_3. isEmpty ( ) ) ) ; }
+public boolean METHOD_2 ( ) { return this. VAR_1 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_2 ) { return 0 ; }
+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 ) ; }
+public void init ( ) { METHOD_1 ( new TYPE_1 ( ) ) ; add ( VAR_1, VAR_2 ) ; METHOD_2 ( VAR_3 ) ; METHOD_3 ( VAR_3 ) ; METHOD_4 ( VAR_3 ) ; VAR_4 = VAR_5 ; VAR_6 = false ; }
+public java.lang.String METHOD_2 ( ) { return getType ( ). toString ( ) ; }
+public void METHOD_1 ( java.lang.CharSequence title ) { super. METHOD_1 ( title ) ; if ( ( title!= null ) || ( ( METHOD_2 ( ) )!= null ) ) { METHOD_2 ( ). METHOD_1 ( title. toString ( ) ) ; } }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { return VAR_1. equals ( VAR_2 ) ; }
+public boolean METHOD_1 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_2 ( ) ; if ( VAR_1 == ( VAR_3 ) ) { VAR_4. METHOD_3 ( ) ; VAR_5. METHOD_4 ( VAR_6 ) ; return true ; } return false ; }
+private static double METHOD_2 ( double x ) { return x * x ; }
+public void METHOD_1 ( int VAR_1, java.lang.String VAR_2, java.lang.String VAR_3 ) { TYPE_1. METHOD_2 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_2, VAR_3 ) ) ; }
+public TYPE_1 METHOD_1 ( TYPE_2 VAR_1 ) { return new TYPE_1 ( VAR_1. METHOD_2 ( ) ) ; }
+public void METHOD_2 ( final boolean VAR_2 ) { VAR_2. METHOD_2 ( VAR_2 ) ; }
+public int METHOD_2 ( TYPE_1 t ) { return t. getText ( ). length ( ) ; }
+public void METHOD_2 ( android.content.Intent VAR_1, int VAR_2 ) { android.content.Intent VAR_3 = new android.content.Intent ( VAR_1 ) ; METHOD_3 ( VAR_3 ) ; }
+public TYPE_1 METHOD_1 ( ) { int VAR_1 = java.lang.Math.abs ( ( ( VAR_2. METHOD_2 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_1 ( final TYPE_1 VAR_1, final TYPE_2 VAR_2 ) { METHOD_2 ( VAR_2 ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( METHOD_1 ( ) ) == 0 ) { return 0 ; } return ( VAR_1. size ( ) ) + ( VAR_2 ) ; }
+public TYPE_1 < TYPE_2 > METHOD_2 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_1. append ( c ) ; return c ; }
+public TYPE_1 METHOD_1 ( ) { TYPE_1 VAR_1 = new TYPE_1 ( ) ; VAR_2. add ( VAR_1 ) ; for ( TYPE_2 listener : VAR_3 ) listener. METHOD_2 ( ) ; return VAR_1 ; }
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+public void METHOD_2 ( java.lang.String STRING_2 ) { for ( TYPE_1 VAR_3 : VAR_1 ) { if ( VAR_3!= null ) { METHOD_3 ( STRING_2 ) ; } } }
+public void METHOD_2 ( java.lang.String VAR_2 ) { if ( TYPE_2. METHOD_3 ( VAR_2 ) ) { return ; } this. VAR_2 = VAR_2 ; }
+public void METHOD_2 ( ) { for ( int i = 0 ; i < ( VAR_1. size ( ) ) ; i ++ ) { VAR_1. get ( i ). METHOD_3 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_2 ; }
+public java.lang.Object METHOD_1 ( java.lang.Integer VAR_1, java.lang.Integer size ) throws java.lang.Exception { return VAR_3. METHOD_1 ( VAR_1, size ) ; }
+public TYPE_1 METHOD_1 ( final TYPE_1 VAR_1 ) { return VAR_4. METHOD_3 ( VAR_3. METHOD_2 ( VAR_1 ) ) ; }
+public void METHOD_1 ( java.lang.String text ) { VAR_1. setText ( text ) ; }
+public TYPE_1 METHOD_1 ( java.lang.String text, java.lang.String text2 ) { return TYPE_1. METHOD_2 ( STRING_1, STRING_2, id, STRING_3, text, STRING_4, text2 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_2 ) { throw new TYPE_2 ( ) ; } }
+public void METHOD_2 ( ) { TYPE_1. METHOD_2 ( VAR_1, STRING_1 ) ; }
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_2 VAR_2 ) { return false ; }
+public void METHOD_2 ( ) throws TYPE_2 { TYPE_3 VAR_1 = new TYPE_3 ( this. VAR_2, STRING_1 ) ; VAR_1. METHOD_3 ( ) ; VAR_1. METHOD_4 ( ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_1 ) ; } else { VAR_1. METHOD_2 ( 1 ). METHOD_3 ( STRING_2 ) ; } return true ; }
+public void METHOD_1 ( TYPE_1 VAR_1 ) { super. METHOD_1 ( VAR_1 ) ; TYPE_2 VAR_2 = ( ( TYPE_2 ) ( VAR_1. METHOD_2 ( VAR_3 ) ) ) ; METHOD_3 ( VAR_2 ) ; METHOD_4 ( ) ; }
+private void METHOD_2 ( ) { if ( ( VAR_1. METHOD_2 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_3 ( VAR_3 ) ; }
+private static java.lang.String METHOD_2 ( ) { try { return VAR_1 class. METHOD_3 ( ) ; } catch ( java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( STRING_1, VAR_2 ) ; return null ; } }
+void METHOD_2 ( ) { if ( METHOD_3 ( ) ) { VAR_1. METHOD_4 ( ) ; java.lang.System.out.println ( ( ( STRING_1 + ( VAR_2 ) ) + STRING_2 ) ) ; METHOD_5 ( ) ; } VAR_3 = false ; }
+private synchronized void METHOD_2 ( ) { VAR_1. METHOD_3 ( listener ) ; }
+public void METHOD_2 ( ) { VAR_1. METHOD_2 ( VAR_2 ) ; METHOD_3 ( ) ; setState ( VAR_3 ) ; }
+public boolean METHOD_1 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_2 ( VAR_1 ) ; return true ; }
diff --git a/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output b/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
new file mode 100644
index 0000000..06766fd
--- /dev/null
+++ b/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
@@ -0,0 +1,3 @@
+
+
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 ) ; }
diff --git a/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output b/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
new file mode 100644
index 0000000..e69de29
diff --git a/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output b/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
new file mode 100644
index 0000000..e69de29
diff --git a/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output b/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
new file mode 100644
index 0000000..f3b11ba
--- /dev/null
+++ b/output/bugs2fix/prompt1/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
@@ -0,0 +1,43 @@
+public static void main ( String[] args )
+public TYPE_2 METHOD_2 ( TYPE_1 input ) { TYPE_2 output = VAR_2 [ VAR_1 ] ; if ( ( VAR_1 ) > 0 ) { VAR_1 = ( VAR_1 ) - 1 ; } else { } return output ;
+private void METHOD_2 ( android.content.Intent intent ) {
+public void METHOD_2 ( ) { }
+public void METHOD_2 ( ) { TYPE_1. METHOD_3 ( ). METHOD_4 ( ). getString ( VAR_1 ). show ( ) ; }
+public TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_1 VAR_2 [ ( ( VAR_1. position ) + 1 ) ] = isEmpty ( ) ; VAR_1. position += 1 ; return VAR_1 ; }
+public static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public static void main ( String[] args ) throws java.io.IOException { java.lang.System.out.println ( "Hello World" ) ; }
+public void METHOD_2 ( ) { }
+public void METHOD_2 ( TYPE_2 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_3 : return true ; case VAR_4 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+private static native void METHOD_2 ( long set ) ;
+public java.lang.Boolean METHOD_2 ( TYPE_1 VAR_1 ) { return VAR_2. METHOD_1 ( VAR_1 ) ; }
+public void METHOD_2 ( ) { VAR_2 = true ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2, STRING_2 STRING_1 ) { TYPE_3. METHOD_3 ( this, STRING_1, VAR_3 ). show ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3. getText ( ). equals ( TYPE_3. METHOD_3 ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) { VAR_3. setText ( TYPE_3. METHOD_3 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! ( VAR_2 ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { METHOD_3 ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_1, TYPE_2 VAR_2, boolean VAR_3 ) { this. METHOD_2 ( VAR_1, VAR_2, VAR_3, VAR_3 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( TYPE_2 arg ) { VAR_2. METHOD_3 ( ) ; }
+public void METHOD_2 ( ) { if (! ( VAR_1 ) ) { VAR_2. update ( ) ; } VAR_3. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_3 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_2 ( VAR_1 ) ; return response ; }
+public void METHOD_2 ( String STRING_1, String STRING_2 ) { }
+public void METHOD_2 ( int i ) { }
+public static void main ( String[] args ) {
+public void METHOD_2 ( java.lang.String STRING_1, java.lang.Throwable VAR_1 ) { }
+public int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1, float VAR_2 ) { return TYPE_2. METHOD_1 ( VAR_1, VAR_2 ) ; }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; VAR_2 = this ; METHOD_3 ( ) ; }
+public void METHOD_2 ( ) { VAR_1 = true ; }
+public TYPE_2 METHOD_2 ( java.lang.Integer id ) { return VAR_2. METHOD_3 ( id ) ; }
+public static void main ( String[] args ) {
+public void METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_2 VAR_2 = new TYPE_2 ( ) ; }
+// Output:
+public String getName ( ) { return VAR_1. name ; }
+public void METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; }
+public static void main ( String[] args ) {
+public long METHOD_2 ( int i ) { return i * i ; }
diff --git a/output/bugs2fix/prompt1/codegen1-multi-16B.output b/output/bugs2fix/prompt1/codegen1-multi-16B.output
new file mode 100644
index 0000000..9a4a98e
--- /dev/null
+++ b/output/bugs2fix/prompt1/codegen1-multi-16B.output
@@ -0,0 +1,95 @@
+private TYPE_2 getType ( TYPE_3 VAR_1 ) { TYPE_4 VAR_2 = new TYPE_4 ( STRING_1 ) ; return new TYPE_2 ( VAR_2, VAR_2 ) ;
+The input to your method will be a string of the form
+private void METHOD_2 ( android.content.Intent intent ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 ) ;
+The bug in the code is that the variable VAR_3 is not declared before the call to METHOD_3.
+public void METHOD_2 ( int a, int b, int c ) { }
+where TYPE_1 is a class/interface, METHOD_1 is a method, VAR_1 is a variable of type TYPE_1, VAR_2 is a variable of type TYPE_2, VAR_3 is a variable of type TYPE_3, and VAR_4 is a variable of type TYPE_4.
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+The bug is that the code is not correct. The method should be called as:
+The input to the method will be a string containing the buggy code. The output should be the corrected code.
+public void METHOD_2 ( ) { if ( VAR_1!= null ) format. METHOD_3 ( VAR_2, VAR_1 ) ; }
+where TYPE_1 is a class, and VAR_1, VAR_2, VAR_3, VAR_4, VAR_5 are variables of that class.
+// The bug is that the default case is missing.
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_1. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; METHOD_5 ( VAR_1 ) ; }
+private static native void METHOD_2 ( long set ) ;
+where TYPE_1 is a class, TYPE_2 is a class, VAR_1 is a class, VAR_2 is a class, VAR_3 is a class.
+public void METHOD_2 ( ) { if ( VAR_1. METHOD_5 ( ) ) { VAR_1. METHOD_6 ( ) ; } }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+where TYPE_1, TYPE_2, TYPE_3, STRING_1, STRING_2, VAR_1, VAR_2, VAR_3 are variables of types TYPE_1, TYPE_2, TYPE_3, STRING_1, STRING_2, TYPE_1, TYPE_2, TYPE_3.
+// The bug is that the method call is not properly indented.
+private void METHOD_2 ( ) { METHOD_4 ( ) ; METHOD_5 ( ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1, boolean VAR_2, boolean VAR_3 ) { this. METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+private void METHOD_2 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_1 class ) ; int index = TYPE_1. METHOD_2 ( ). METHOD_3 ( ) ; intent. METHOD_4 ( STRING_1, index ) ; METHOD_5 ( intent ) ; }
+public void METHOD_2 ( TYPE_2 arg ) { VAR_3. METHOD_6 ( VAR_4. getId ( ), arg. METHOD_7 ( ), arg. METHOD_8 ( ) ) ; METHOD_9 ( ) ; }
+// The bug is that the code is not checking if the condition is true or false.
+where TYPE_1, TYPE_2, TYPE_3, METHOD_1, METHOD_2, VAR_1, VAR_2 are types, and METHOD_2 returns a boolean.
+// The bug in this code is that the method call is not properly closed.
+public void METHOD_2 ( ) { VAR_4. METHOD_3 ( VAR_5 ) ; VAR_6. METHOD_3 ( VAR_5 ) ; VAR_6. METHOD_4 ( VAR_7 ) ; }
+The input to the method is a single line of code. The method should be able to fix as many errors as possible. The output should be a single line of code representing the corrected code.
+public void METHOD_2 ( STRING_2 VAR_4, java.lang.Throwable VAR_5 ) { VAR_6. METHOD_4 ( VAR_4, VAR_5 ) ; }
+private int METHOD_2 ( ) { return this. VAR_2 ; }
+The input to your program is a single line of input: the number of test cases. Each test case consists of two lines of input: the number of variables and the number of operations. The number of variables is always a positive integer. The number of operations is always a positive integer. The input is terminated by a line containing two 0s.
+public void METHOD_2 ( ) { VAR_2 = this ; METHOD_3 ( ) ; }
+// The buggy code is:
+public TYPE_2 METHOD_2 ( java.lang.Integer id ) { return VAR_2. METHOD_3 ( id ) ; }
+// The bug is in the line VAR_2. METHOD_2 ( new TYPE_2 ( TYPE_3. METHOD_3 ( STRING_2, STRING_3 ) ) ) ;
+private void METHOD_2 ( TYPE_1 VAR_1 ) { java.lang.Object [ ] VAR_2 = METHOD_3 ( ) ; METHOD_4 ( VAR_2 ) ; }
+// The bug is in the line: VAR_1 = TYPE_2. METHOD_1 ( STRING_1 ) ;
+public void setId ( int id ) { VAR_1. id = id ; }
+public void METHOD_2 ( TYPE_3 VAR_3, TYPE_4 VAR_4 ) { if ( VAR_3 == null ) { TYPE_5. METHOD_6 ( VAR_5, ( STRING_2 + path ) ) ; METHOD_7 ( ) ; } else { METHOD_8 ( VAR_3. METHOD_9 ( ) ) ; } }
+private static int METHOD_2 ( int VAR_3 ) { return VAR_4. METHOD_3 ( VAR_3 ). compareTo ( VAR_4. METHOD_3 ( VAR_3 ) ) ; }
+public long METHOD_2 ( int i ) { return i + 1 ; }
+private static java.util.List < java.lang.String > METHOD_2 ( ) { return null ; }
+// The bug is that the code is not correct. The code is correct if the following condition is satisfied:
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_2. METHOD_2 ( VAR_2 ) ; this. VAR_1 = null ; this. VAR_2 = null ; }
+private static TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_1 VAR_2 = VAR_1 ; for ( int i = 2 ; i < VAR_1. METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ). METHOD_1 ( 1 ).
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_1. i ( VAR_1, STRING_3 ) ; METHOD_3 ( ) ; TYPE_1. i ( VAR_1, STRING_4 ) ; }
+where TYPE_1, TYPE_2, VAR_1, VAR_2, VAR_3 are all variables of the given types.
+public void METHOD_2 ( ) { METHOD_3 ( ) ; }
+protected void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. i ( VAR_2, STRING_2 ) ; }
+// The bug is that the return type is boolean, but the method returns a java.util.List.
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public boolean METHOD_2 ( ) { java.lang.System.out.println ( VAR_2 ) ; return this. VAR_2 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_2 ) { return 0 ; }
+where TYPE_1, TYPE_2, TYPE_3, TYPE_4, TYPE_5 are all java.lang.String, and VAR_1, VAR_2, VAR_3, VAR_4 are all java.lang.Object.
+// The buggy code is:
+public java.lang.String METHOD_2 ( ) { switch ( METHOD_3 ( ) ) { case 1 : return null ; case INT_1 : return null ; case INT_2 : return getType ( ). toString ( ) ; default : return null ; } }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+The bug is that the value of VAR_1 is used twice, and the value of VAR_3 is used twice.
+private static double METHOD_2 ( double p ) { double sum = 0 ; for ( double i : p ) { sum -= i * ( TYPE_1. METHOD_3 ( i ) ) ; } return sum ; }
+public class Solution {
+where TYPE_1, METHOD_1, TYPE_2, VAR_1, METHOD_2 are strings representing the types of the variables and methods, respectively.
+public void METHOD_2 ( final boolean VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; }
+public int METHOD_2 ( java.lang.String str ) { java.lang.String str1 = java.lang.String. METHOD_3 ( str ) ; java.lang.String str2 = java.lang.String. METHOD_4 ( str1 ) ; java.lang.String str3 = java.lang.String. METHOD_5 ( str2 ) ; return VAR_3 ; }
+public void METHOD_2 ( android.content.Intent VAR_1, int VAR_2 ) { android.content.Intent VAR_3 = new android.content.Intent ( VAR_1 ) ; VAR_3. putExtra ( VAR_4, VAR_5 ) ; }
+where TYPE_1, METHOD_1, VAR_1, VAR_2, VAR_3, VAR_4 are constants defined for you, and VAR_3 is a java.util.ArrayList.
+public void METHOD_2 ( final TYPE_2 VAR_2 ) { METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( METHOD_3 ( ) ) == 0 ) { return 0 ; } return ( VAR_1. size ( ) ) + ( VAR_2 ) ; }
+where TYPE_1, TYPE_2, TYPE_3, VAR_1 are data types, and METHOD_1 is a method.
+where TYPE_1, METHOD_1, METHOD_2, METHOD_3, TYPE_2, VAR_1, VAR_2, VAR_3 are all strings.
+public class Solution {
+public void METHOD_2 ( java.lang.String STRING_1 ) { METHOD_3 ( STRING_1 ) ; }
+public boolean METHOD_2 ( java.lang.String VAR_2 ) { if ( VAR_2. length ( ) > VAR_1. length ( ) ) { return true ; } else { return false ; } }
+public void METHOD_2 ( ) { for ( int i = 0 ; i < ( VAR_1. size ( ) ) ; i ++ ) { VAR_1. get ( i ). METHOD_3 ( ) ; } }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_2 ; }
+public java.lang.Object METHOD_2 ( java.lang.Integer VAR_1, java.lang.Integer size, java.lang.Long VAR_2 ) throws java.lang.Exception { return VAR_3. METHOD_2 ( VAR_2, VAR_1, size ) ; }
+where TYPE_1, TYPE_2, TYPE_3, TYPE_4, METHOD_1, METHOD_2, METHOD_3, VAR_1, VAR_2, VAR_3, VAR_4 are all strings.
+public void METHOD_2 ( int i ) { VAR_2. METHOD_3 ( 0 ) ; }
+public TYPE_2 METHOD_2 ( java.lang.String a, java.lang.String b, int c, java.lang.String d, java.lang.String e ) { return TYPE_2. METHOD_3 ( a, b, c, d, e ) ; }
+public class Solution {
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. METHOD_4 ( VAR_3, STRING_2 ) ; VAR_4. METHOD_5 ( ) ; }
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_1 VAR_2, TYPE_2 VAR_3 ) { return false ; }
+// The bug is that the variable VAR_1 is not initialized.
+// The bug is that the method call is not properly indented.
+// The bug is that the super call is missing.
+private void METHOD_2 ( ) { if ( ( VAR_1. METHOD_3 ( ) ) && ( ( VAR_2 )!= null ) ) VAR_2. METHOD_4 ( VAR_3 ) ; else VAR_2. METHOD_4 ( VAR_4 ) ; }
+private static java.lang.String METHOD_2 ( ) { try { return VAR_1 class. METHOD_3 ( ). METHOD_4 ( ) ; } catch ( java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( STRING_1, VAR_2 ) ; return null ; } }
+// The bug is in the second line.
+private synchronized void METHOD_2 ( ) { VAR_3. METHOD_4 ( VAR_4 ) ; VAR_3. METHOD_5 ( VAR_5 ) ; }
+public void METHOD_2 ( int i ) { if ( i < VAR_4 ) { VAR_5 = i ; } else { VAR_6 = i ; } }
+public class Solution {
diff --git a/output/bugs2fix/prompt1/codegen1-multi-2B.output b/output/bugs2fix/prompt1/codegen1-multi-2B.output
new file mode 100644
index 0000000..bfcb0f3
--- /dev/null
+++ b/output/bugs2fix/prompt1/codegen1-multi-2B.output
@@ -0,0 +1,95 @@
+public TYPE_1 getType ( TYPE_2 VAR_1 ) { TYPE_3 VAR_2 = new TYPE_3 ( STRING_1 ) ; return new TYPE_1 ( VAR_2, VAR_2 ) ; }
+public TYPE_2 METHOD_2 ( ) { TYPE_2 output = VAR_1 [ VAR_2 ] ; if ( ( VAR_2 ) > 0 ) { VAR_2 = ( VAR_2 ) - 1 ; } else { } return output ; }
+private void METHOD_2 ( android.content.Intent intent ) { }
+public void METHOD_2 ( ) { }
+
+public TYPE_2 METHOD_2 ( int VAR_1 ) { TYPE_2 VAR_2 ; VAR_2 = new TYPE_2 ( ) ; VAR_2. position = VAR_1 ; return VAR_2 ; }
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( TYPE_1 VAR_1, TYPE_1 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+
+public void METHOD_2 ( ) { }
+
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_1 ( ) ) { case VAR_1 : return true ; case VAR_2 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+
+private static native void METHOD_2 ( long set ) ;
+public static TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) { return VAR_1 ; }
+
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Class <? > VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+
+public void METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_3 ( VAR_1 ) ; }
+private void METHOD_2 ( ) { }
+public void METHOD_2 ( TYPE_2 VAR_2, boolean VAR_3 ) { this. METHOD_2 ( VAR_2, VAR_3, VAR_3 ) ; }
+
+public void METHOD_5 ( ) { }
+public void METHOD_2 ( ) { if (! ( VAR_1 ) ) { VAR_2. update ( ) ; } VAR_3. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_2 ( ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_3 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_1 ( VAR_1 ) ; return response ; }
+public void METHOD_2 ( String STRING_1, String STRING_2 ) { }
+public void METHOD_2 ( int VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; }
+public int METHOD_1 ( java.lang.Object VAR_1 ) { VAR_2. METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_2 ( java.lang.String VAR_1, java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( VAR_1, VAR_2 ) ; }
+public class Solution {
+public static float TYPE_1. METHOD_1 ( float VAR_1, float VAR_2 ) { return VAR_1 + VAR_2 ; }
+
+public void METHOD_2 ( ) { if ( VAR_1 ) { VAR_1 = false ; VAR_2. METHOD_3 ( ) ; startTime = ( TYPE_1. METHOD_4 ( ) ) - ( VAR_3 ) ; } }
+public TYPE_2 METHOD_2 ( java.lang.Integer id ) { return VAR_2. METHOD_3 ( id ) ; }
+
+private TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_2. METHOD_4 ( VAR_1 ) ; TYPE_3. METHOD_4 ( VAR_1 ) ; return VAR_1 ; }
+public static TYPE_1 TYPE_1 = TYPE_2. METHOD_1 ( STRING_1 ) ;
+public int getId ( int id ) { return VAR_1. id ; }
+
+public static void main ( String[] args ) {
+public long METHOD_2 ( int i ) { return i ; }
+private static void METHOD_2 ( java.lang.String key ) { }
+public void METHOD_2 ( ) { TYPE_1 VAR_3 = TYPE_2. METHOD_3 ( ) ; add ( VAR_3 ) ; }
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_1. METHOD_2 ( VAR_1 ) ; this. VAR_1 = null ; this. VAR_2 = null ; }
+public static void main ( String[] args ) {
+
+public static TYPE_1 METHOD_2 ( TYPE_2 VAR_1, double VAR_2, double height ) { if ( ( VAR_3 ) == null ) { VAR_3 = new TYPE_1 ( VAR_1, VAR_2, height ) ; } return VAR_3 ; }
+public void METHOD_2 ( ) { VAR_2. add ( new TYPE_2 ( ) ) ; }
+protected void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. i ( VAR_2, STRING_2 ) ; }
+public boolean METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2, TYPE_3 VAR_3, TYPE_4 VAR_4, boolean VAR_5 ) { return true ; }
+
+public boolean METHOD_2 ( ) { java.lang.System.out.println ( VAR_2 ) ; return this. VAR_2 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_1, java.lang.Object VAR_2 ) { return 0 ; }
+public void METHOD_2 ( TYPE_4 status ) { TYPE_5. id ( status ). METHOD_6 ( TYPE_6. METHOD_7 ( TYPE_7. METHOD_8 ( TYPE_8. METHOD_9 ( TYPE_9. METHOD_10 ( TYPE_10. METHOD_11 ( TYPE_11. METHOD_12 ( TYPE_12. METHOD_13 ( TYPE_13. METHOD_14 ( TYPE_14. METHOD_15 ( TYPE_15. METHOD_16 ( TYPE_16. METHOD_17 ( TYPE_17. METHOD_18 ( TYPE_18. METHOD_19 ( TYPE_19. METHOD_20 ( TYPE_20. METHOD_21 ( TYPE_21. METHOD_22 ( TYPE_22. METHOD_23 ( TYPE_23. METHOD_24 ( TYPE_24. METHOD_25 ( TYPE_25. METHOD_26 ( TYPE_26. METHOD_27 ( TYPE_27. METHOD_28 ( TYPE_28. METHOD_29 ( TYPE_29. METHOD_30 ( TYPE_30. METHOD_31 ( TYPE_31. METHOD_32 ( TYPE_32. METHOD_33 ( TYPE_33. METHOD_34 ( TYPE_34. METHOD_35 ( TYPE_35. METHOD_36 ( TYPE_36. METHOD_37 ( TYPE_37. METHOD_38 ( TYPE_38. METHOD_39 ( TYPE_39. METHOD_40 ( TYPE_40. METHOD_41 ( TYPE_41. METHOD_42 ( TYPE_42. METHOD_43 ( TYPE_43. METHOD_44 ( TYPE_44. METHOD_45 ( TYPE_45. METHOD_46 ( TYPE_46. METHOD_47 ( TYPE_47. METHOD_48 ( TYPE_48. METHOD_49 ( TYPE_49. METHOD_50 ( TYPE_50. METHOD_51 ( TYPE_51. METHOD_52 ( TYPE_52. METHOD_53 ( TYPE_53. METHOD_54 ( TYPE_54. METHOD_55 ( TYPE_55. METHOD_56 ( TYPE_56. METHOD_57 ( TYPE_57. METHOD_58 ( TYPE_58. METHOD_59 ( TYPE_59. METHOD_60 ( TYPE_60. METHOD_61 ( TYPE_61. METHOD_62 ( TYPE_62. METHOD_63 ( TYPE_63. METHOD_64 ( TYPE_64. METHOD_65 ( TYPE_65. METHOD_66 ( TYPE_66. METHOD_67 ( TYPE_67. METHOD_68 ( TYPE_68. METHOD_69 ( TYPE_69. METHOD_70 ( TYPE_70. METHOD_71 ( TYPE_71. METHOD_72 ( TYPE_72. METHOD_73 ( TYPE_73. METHOD_74 ( TYPE_74. METHOD_75 ( TYPE_75. METHOD_76 ( TYPE_76. METHOD_77 ( TYPE_77. METHOD_78 ( TYPE_78. METHOD_79 ( TYPE_79. METHOD_80 ( TYPE_80. METHOD_81 ( TYPE_81. METHOD_82 ( TYPE_82. METHOD_83 ( TYPE_83. METHOD_84 ( TYPE_84. METHOD_85 ( TYPE_85. METHOD_86 ( TYPE_86. METHOD_87 ( TYPE_87. METHOD_88 ( TYPE_88. METHOD_89 ( TYPE_89. METHOD_90 ( TYPE_90. METHOD_91 ( TYPE_91. METHOD_92 ( TYPE_92. METHOD_93 ( TYPE_93. METHOD_94 ( TYPE_94. METHOD_95 ( TYPE_95. METHOD_96 ( TYPE_96. METHOD_97 ( TYPE_97
+public void METHOD_1 ( TYPE_1 TYPE_1_1 ) { TYPE_1_1 = TYPE_1_1 ; }
+public java.lang.String METHOD_2 ( ) { switch ( INT_1 ) { case 1 : return null ; case INT_2 : return null ; default : return getType ( ). toString ( ) ; } }
+
+public static boolean equals ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+
+private static double METHOD_2 ( java.lang.Double i ) { return i * i ; }
+
+public class Solution {
+public void METHOD_2 ( final boolean VAR_1 ) { VAR_2. METHOD_2 ( VAR_1 ) ; }
+public int METHOD_2 ( TYPE_1 TYPE_2 ) { TYPE_1 TYPE_3 = TYPE_2. getText ( ) ; TYPE_2. setText ( TYPE_3. getText ( ). toUpperCase ( ) ) ; return TYPE_2 ; }
+
+public TYPE_2 METHOD_2 ( ) { int VAR_1 = java.lang.Math. abs ( ( ( VAR_2. METHOD_3 ( ) ) % ( VAR_3. size ( ) ) ) ) ; return VAR_4. get ( VAR_1 ) ; }
+public void METHOD_2 ( final TYPE_2 VAR_2 ) { METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_1 ; }
+
+public TYPE_1 < TYPE_2 > METHOD_2 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_1. append ( c ) ; return c ; }
+
+public static void main ( String[] args ) {
+public void METHOD_2 ( java.lang.String STRING_1 ) { }
+public void METHOD_2 ( java.lang.String VAR_1 ) { if ( TYPE_1. METHOD_3 ( VAR_1 ) ) { return ; } this. VAR_1 = VAR_1 ; }
+public void METHOD_2 ( ) { for ( int i = 0 ; i < ( VAR_1. size ( ) ) ; i ++ ) { VAR_1. get ( i ). METHOD_3 ( ) ; } }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public static final java.lang.Object METHOD_3 ( java.lang.Long VAR_1, java.lang.Integer VAR_2, java.lang.Integer size ) throws java.lang.Exception { return VAR_3. METHOD_3 ( VAR_1, VAR_2, size ) ; }
+public TYPE_2 < TYPE_1 > METHOD_2 ( final TYPE_1 VAR_1 ) { return VAR_2. METHOD_3 ( VAR_1 ) ; }
+public void METHOD_2 ( int i ) { VAR_1. setText ( "Hello" ) ; VAR_1. METHOD_3 ( i ) ; }
+public static class TYPE_1 {
+public void METHOD_2 ( TYPE_1 VAR_1 ) { if ( VAR_2 ) { throw new TYPE_2 ( ) ; } }
+
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_1 VAR_2 ) { return false ; }
+
+public boolean METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3 ) { VAR_2. METHOD_3 ( 1 ). METHOD_4 ( STRING_1 ) ; } else { VAR_2. METHOD_3 ( 1 ). METHOD_4 ( STRING_2 ) ; } return true ; }
+
+
+public static void main ( String[] ARGUMENTS ) {
+
+
+public void METHOD_2 ( int VAR_1 ) { }
+public boolean METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_1 result = TYPE_2. METHOD_3 ( VAR_1 ) ; return true ; }
diff --git a/output/bugs2fix/prompt1/codegen1-multi-350M.output b/output/bugs2fix/prompt1/codegen1-multi-350M.output
new file mode 100644
index 0000000..a1f855c
--- /dev/null
+++ b/output/bugs2fix/prompt1/codegen1-multi-350M.output
@@ -0,0 +1,95 @@
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+private void METHOD_2 ( android.content.Intent VAR_2 ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 ) ; METHOD_3 ( intent ) ; }
+public void METHOD_2 ( ) { for ( TYPE_2 VAR_2 : VAR_3 ) VAR_2. METHOD_1 ( ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+private static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public char getColor ( ) throws java.io.IOException { VAR_1. METHOD_1 ( ( STRING_1 + "\n" ) ) ; java.lang.String response = VAR_2. METHOD_2 ( ) ; java.lang.System.out.println ( response ) ; return response. METHOD_3 ( 0 ) ; }
+public void METHOD_2 ( final java.lang.String... VAR_1 ) { if ( VAR_1!= null ) format. METHOD_3 ( ). METHOD_4 ( VAR_2, VAR_1 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( TYPE_1 VAR_1 ) { super. METHOD_2 ( VAR_1 ) ; VAR_2. METHOD_2 ( VAR_1 ) ; VAR_3. METHOD_3 ( VAR_1 ) ; VAR_4. METHOD_4 ( VAR_1 ) ; VAR_5. METHOD_4 ( VAR_1 ) ; }
+private static native void METHOD_2 ( long set ) ;
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+private void METHOD_2 ( ) { android.content.Intent intent = new android.content.Intent ( this, VAR_2 class ) ; int index = TYPE_2. METHOD_3 ( ). METHOD_4 ( STRING_2, index ) ; METHOD_5 ( intent ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public int update ( java.lang.Object VAR_1 ) { VAR_2. METHOD_1 ( VAR_1 ) ; METHOD_2 ( ) ; try { return METHOD_3 ( VAR_2. METHOD_4 ( ) ). execute ( ) ; } finally { VAR_2. METHOD_5 ( ) ; } }
+public void METHOD_2 ( java.lang.String VAR_1, java.lang.Throwable VAR_2 ) { VAR_3. METHOD_4 ( ( STRING_1 + ( VAR_3. name ( ) ) ), VAR_1 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public float op ( float VAR_1, float VAR_2 ) { return TYPE_1. METHOD_1 ( VAR_1, VAR_2 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// The following code is a bit of a hack. The code is a bit of a hack, but it is a good idea to keep the code in a separate file.
+public void setId ( int id ) { VAR_1. id = id ; }
+public void METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { if ( VAR_1 == null ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; METHOD_3 ( ) ; } else { METHOD_4 ( VAR_1. METHOD_5 ( ) ) ; } }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_2. METHOD_2 ( VAR_1 ) ; this. VAR_1 = null ; this. VAR_2 = null ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_1. i ( VAR_1, STRING_1 ) ; METHOD_3 ( ) ; TYPE_1. i ( VAR_1, STRING_2 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public boolean METHOD_2 ( ) { return (! ( this. VAR_1. isEmpty ( ) ) ) || (! ( this. VAR_2. isEmpty ( ) ) ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void add ( TYPE_1 a, TYPE_2 b ) { a. add ( b ) ; }
+public java.lang.String METHOD_2 ( ) { switch ( METHOD_1 ( ) ) { case 1 : return null ; case INT_1 : return null ; case INT_2 : return getType ( ). toString ( ) ; default : return null ; } }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+public boolean METHOD_2 ( android.content.Intent intent ) { int VAR_1 = VAR_2. METHOD_3 ( ) ; if ( VAR_1 == ( VAR_4 ) ) { VAR_5. METHOD_4 ( ) ; VAR_6. METHOD_5 ( ) ; return true ; } return false ; }
+private static double METHOD_2 ( double p ) { double sum = 0 ; for ( double i : p ) { sum += i * ( TYPE_2. METHOD_3 ( i ) ) ; } return sum ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public int METHOD_2 ( ) { java.lang.String str = java.lang.String. METHOD_3 ( ( ( TYPE_1 ) ( VAR_1 ) ). getText ( ) ) ; METHOD_4 ( str ) ; return VAR_2 ; }
+public void METHOD_2 ( android.content.Intent VAR_1, int VAR_2 ) {
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+protected java.lang.Object METHOD_2 ( java.lang.Object value ) { return value ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( java.lang.String VAR_2 ) { if ( TYPE_2. METHOD_3 ( VAR_2 ) ) { return ; } this. VAR_2 = VAR_2 ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_2 ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( int i ) { VAR_2. setInt ( i ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3 ) { throw new TYPE_3 ( ) ; } }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( ) throws TYPE_2 { TYPE_3. assertNotNull ( VAR_1. METHOD_4 ( ) ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; TYPE_1 VAR_1 = ( ( TYPE_1 ) ( VAR_2. METHOD_1 ( VAR_3 ) ) ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+private static java.lang.String METHOD_2 ( ) { try { return VAR_2 class. METHOD_3 ( ). METHOD_4 ( ) ; } catch ( java.lang.Throwable VAR_3 ) { VAR_4. METHOD_5 ( STRING_2, VAR_3 ) ; return null ; } }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
diff --git a/output/bugs2fix/prompt1/codegen1-multi-6B.output b/output/bugs2fix/prompt1/codegen1-multi-6B.output
new file mode 100644
index 0000000..69b2bbb
--- /dev/null
+++ b/output/bugs2fix/prompt1/codegen1-multi-6B.output
@@ -0,0 +1,95 @@
+public static void main ( String[] args )
+public TYPE_2 METHOD_2 ( TYPE_1 input ) { TYPE_2 output = VAR_2 [ VAR_1 ] ; if ( ( VAR_1 ) > 0 ) { VAR_1 = ( VAR_1 ) - 1 ; } else { } return output ;
+private void METHOD_2 ( android.content.Intent intent ) {
+public void METHOD_2 ( ) { }
+public void METHOD_2 ( ) { TYPE_1. METHOD_3 ( ). METHOD_4 ( ). getString ( VAR_1 ). show ( ) ; }
+public TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_1 VAR_2 [ ( ( VAR_1. position ) + 1 ) ] = isEmpty ( ) ; VAR_1. position += 1 ; return VAR_1 ; }
+public static boolean METHOD_2 ( final byte status ) { return status == ( VAR_2 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_1, TYPE_2 VAR_2 ) { this. VAR_3. add ( VAR_1, VAR_2 ) ; VAR_4. add ( this ) ; }
+public static void main ( String[] args ) throws java.io.IOException { java.lang.System.out.println ( "Hello World" ) ; }
+public void METHOD_2 ( ) { }
+public void METHOD_2 ( TYPE_2 VAR_1 ) { VAR_2 = 0 ; VAR_3 = ( ( double ) ( VAR_2 ) ) / FLOAT_1 ; VAR_4 = new java.lang.Double ( VAR_3 ). toString ( ) ; VAR_5. setText ( VAR_4 ) ; }
+public boolean METHOD_2 ( TYPE_2 item ) { switch ( item. METHOD_3 ( ) ) { case VAR_3 : return true ; case VAR_4 : return true ; default : return super. METHOD_2 ( item ) ; } }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { this. VAR_2 = VAR_2 ; }
+public java.lang.Boolean METHOD_2 ( java.lang.String id ) { return VAR_2. METHOD_2 ( id ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { super. METHOD_2 ( VAR_2 ) ; VAR_3. METHOD_3 ( VAR_2 ) ; VAR_4. METHOD_4 ( VAR_2 ) ; VAR_5. METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+private static native void METHOD_2 ( long set ) ;
+public java.lang.Boolean METHOD_2 ( TYPE_1 VAR_1 ) { return VAR_2. METHOD_1 ( VAR_1 ) ; }
+public void METHOD_2 ( ) { VAR_2 = true ; }
+public < TYPE_1 > TYPE_1 METHOD_1 ( final java.lang.Object VAR_1, final java.lang.Class < TYPE_1 > VAR_2, final java.lang.Object VAR_3 ) { return METHOD_1 ( VAR_1, VAR_2, VAR_3 ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2, STRING_2 STRING_1 ) { TYPE_3. METHOD_3 ( this, STRING_1, VAR_3 ). show ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3. getText ( ). equals ( TYPE_3. METHOD_3 ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) { VAR_3. setText ( TYPE_3. METHOD_3 ( ( ( TYPE_3 ) ( VAR_3. getContext ( ) ) ) ) ) ; } VAR_2 =! ( VAR_2 ) ; }
+private void METHOD_2 ( TYPE_2 VAR_2 ) { METHOD_3 ( ) ; }
+public void METHOD_2 ( TYPE_2 VAR_1, TYPE_2 VAR_2, boolean VAR_3 ) { this. METHOD_2 ( VAR_1, VAR_2, VAR_3, VAR_3 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( TYPE_2 arg ) { VAR_2. METHOD_3 ( ) ; }
+public void METHOD_2 ( ) { if (! ( VAR_1 ) ) { VAR_2. update ( ) ; } VAR_3. METHOD_2 ( ) ; }
+public TYPE_1 METHOD_2 ( TYPE_1 VAR_1 ) throws TYPE_2, TYPE_3 { if ( VAR_1 == null ) return null ; if (! ( METHOD_3 ( ) ) ) return null ; TYPE_1 response = VAR_2. METHOD_2 ( VAR_1 ) ; return response ; }
+public void METHOD_2 ( String STRING_1, String STRING_2 ) { }
+public void METHOD_2 ( int i ) { }
+public static void main ( String[] args ) {
+public void METHOD_2 ( java.lang.String STRING_1, java.lang.Throwable VAR_1 ) { }
+public int METHOD_2 ( ) { return this. VAR_2 ; }
+public float op ( float VAR_1, float VAR_2 ) { return TYPE_2. METHOD_1 ( VAR_1, VAR_2 ) ; }
+public void METHOD_2 ( ) { super. METHOD_2 ( ) ; VAR_2 = this ; METHOD_3 ( ) ; }
+public void METHOD_2 ( ) { VAR_1 = true ; }
+public TYPE_2 METHOD_2 ( java.lang.Integer id ) { return VAR_2. METHOD_3 ( id ) ; }
+public static void main ( String[] args ) {
+public void METHOD_2 ( TYPE_1 VAR_1 ) { TYPE_2 VAR_2 = new TYPE_2 ( ) ; }
+// Output:
+public String getName ( ) { return VAR_1. name ; }
+public void METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { TYPE_3. METHOD_2 ( VAR_3, ( STRING_1 + path ) ) ; }
+public static void main ( String[] args ) {
+public long METHOD_2 ( int i ) { return i * i ; }
+public static void main ( String[] args ) {
+public void METHOD_2 ( ) { TYPE_1 VAR_1 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_2 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_3 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_4 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_5 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_6 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_7 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_8 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_9 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_10 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_11 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_12 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_13 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_14 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_15 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_16 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_17 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_18 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_19 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_20 = TYPE_2. METHOD_1 ( ) ; TYPE_1 VAR_21 = TYPE_
+public void METHOD_2 ( ) throws java.io.IOException { TYPE_2. METHOD_2 ( VAR_2 ) ; }
+public static void main ( String[] args ) {
+public void METHOD_2 ( ) { TYPE_1. i ( VAR_1, STRING_2 ) ; }
+public static TYPE_1 METHOD_2 ( TYPE_2 VAR_1, double VAR_2, double height ) { if ( ( VAR_3 ) == null ) { VAR_3 = new TYPE_1 ( VAR_1, VAR_2, height ) ; } return VAR_3 ; }
+public void METHOD_2 ( TYPE_2 c ) { c. METHOD_3 ( ) ; VAR_2. add ( c ) ; }
+protected void METHOD_2 ( ) { super. METHOD_2 ( ) ; TYPE_2. i ( VAR_2, STRING_2 ) ; }
+public boolean METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2, TYPE_3 VAR_3, TYPE_4 VAR_4, TYPE_5 VAR_5, TYPE_6 VAR_6, TYPE_7 VAR_7, TYPE_8 VAR_8, TYPE_9 VAR_9, TYPE_10 VAR_10, TYPE_11 VAR_11, TYPE_12 VAR_12, TYPE_13 VAR_13, TYPE_14 VAR_14, TYPE_15 VAR_15, TYPE_16 VAR_16, TYPE_17 VAR_17, TYPE_18 VAR_18, TYPE_19 VAR_19, TYPE_20 VAR_20, TYPE_21 VAR_21, TYPE_22 VAR_22, TYPE_23 VAR_23, TYPE_24 VAR_24, TYPE_25 VAR_25, TYPE_26 VAR_26, TYPE_27 VAR_27, TYPE_28 VAR_28, TYPE_29 VAR_29, TYPE_30 VAR_30, TYPE_31 VAR_31, TYPE_32 VAR_32, TYPE_33 VAR_33, TYPE_34 VAR_34, TYPE_35 VAR_35, TYPE_36 VAR_36, TYPE_37 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_
+public boolean METHOD_2 ( ) { return (! ( this. VAR_1. isEmpty ( ) ) ) || (! ( this. VAR_2. isEmpty ( ) ) ) || (! ( this. VAR_3. isEmpty ( ) ) ) ; }
+public boolean METHOD_2 ( ) { return this. VAR_1 ; }
+public int METHOD_2 ( int VAR_1, int VAR_2 ) { return VAR_1 + VAR_2 ; }
+public int METHOD_2 ( java.lang.Object VAR_1 ) { return 0 ; }
+public void METHOD_2 ( TYPE_5 VAR_1 ) { VAR_1. METHOD_1 ( TYPE_6. METHOD_1 ( TYPE_7. METHOD_1 ( TYPE_8. METHOD_1 ( TYPE_9. METHOD_1 ( TYPE_10. METHOD_1 ( TYPE_11. METHOD_1 ( TYPE_12. METHOD_1 ( TYPE_13. METHOD_1 ( TYPE_14. METHOD_1 ( TYPE_15. METHOD_1 ( TYPE_16. METHOD_1 ( TYPE_17. METHOD_1 ( TYPE_18. METHOD_1 ( TYPE_19. METHOD_1 ( TYPE_20. METHOD_1 ( TYPE_21. METHOD_1 ( TYPE_22. METHOD_1 ( TYPE_23. METHOD_1 ( TYPE_24. METHOD_1 ( TYPE_25. METHOD_1 ( TYPE_26. METHOD_1 ( TYPE_27. METHOD_1 ( TYPE_28. METHOD_1 ( TYPE_29. METHOD_1 ( TYPE_30. METHOD_1 ( TYPE_31. METHOD_1 ( TYPE_32. METHOD_1 ( TYPE_33. METHOD_1 ( TYPE_34. METHOD_1 ( TYPE_35. METHOD_1 ( TYPE_36. METHOD_1 ( TYPE_37. METHOD_1 ( TYPE_38. METHOD_1 ( TYPE_39. METHOD_1 ( TYPE_40. METHOD_1 ( TYPE_41. METHOD_1
+public void METHOD_1 ( TYPE_1 t ) { }
+public java.lang.String METHOD_2 ( ) { return null ; }
+public void METHOD_2 ( ) { }
+public static boolean equals ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return ( VAR_1. METHOD_1 ( VAR_2 ) ) && ( VAR_1. toString ( ). equals ( VAR_2. toString ( ) ) ) ; }
+public boolean METHOD_2 ( ) { return true ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public void METHOD_2 ( int VAR_1 ) { TYPE_1. METHOD_3 ( VAR_1 ). remove ( TYPE_2. METHOD_3 ( VAR_1 ) ) ; }
+public static void main ( String[] args ) {
+public void METHOD_2 ( final boolean VAR_1 ) { VAR_2. METHOD_2 ( VAR_1 ) ; }
+public int METHOD_2 ( TYPE_1 t ) { return t. METHOD_3 ( ) ; }
+public void METHOD_2 ( android.content.Intent VAR_1, int VAR_2 ) { android.content.Intent VAR_3 = new android.content.Intent ( VAR_1 ) ; METHOD_3 ( VAR_3 ) ; }
+public TYPE_1 METHOD_2 ( ) { return VAR_5. get ( ( ( VAR_6. METHOD_3 ( ) ) % ( VAR_7. size ( ) ) ) ) ; }
+public void METHOD_2 ( final TYPE_2 VAR_2 ) { METHOD_3 ( VAR_2 ) ; METHOD_4 ( VAR_2 ) ; METHOD_5 ( VAR_2 ) ; }
+public java.lang.String METHOD_2 ( TYPE_1 VAR_1, TYPE_2 VAR_2 ) { return STRING_2 ; }
+public int METHOD_2 ( ) { if ( ( METHOD_1 ( ) ) == 0 ) { return 0 ; } return ( VAR_1 ). size ( ) + ( VAR_2 ) ; }
+public TYPE_1 < TYPE_2 > METHOD_2 ( TYPE_1 < TYPE_2 > a, TYPE_1 < TYPE_2 > b ) { TYPE_3 c = new TYPE_3 ( a, b ) ; VAR_2. append ( c ) ; return c ; }
+public TYPE_2 METHOD_2 ( ) { TYPE_2 VAR_1 = new TYPE_2 ( ) ; VAR_2. add ( VAR_1 ) ; return VAR_1 ; }
+public static void main ( String[] args ) {
+public void METHOD_2 ( java.lang.String STRING_2 ) { }
+public void METHOD_2 ( java.lang.String VAR_2 ) { if ( TYPE_2. METHOD_3 ( VAR_2 ) ) { return ; } this. VAR_2 = VAR_2 ; }
+public void METHOD_2 ( ) { VAR_1. add ( new Object ( ) ) ; }
+public float METHOD_2 ( long VAR_1, long VAR_2 ) { return ( ( ( float ) ( VAR_1 ) ) / ( 0.0F + VAR_2 ) ) * INT_1 ; }
+public java.lang.Object METHOD_2 ( java.lang.Integer VAR_1, java.lang.Integer size, java.lang.Long VAR_2 ) throws java.lang.Exception { return VAR_3. METHOD_2 ( VAR_2, VAR_1, size ) ; }
+public TYPE_1 METHOD_2 ( final TYPE_1 VAR_1 ) { final TYPE_2 < TYPE_1 > VAR_2 = VAR_3. METHOD_2 ( VAR_1 ) ; return VAR_4. METHOD_3 ( VAR_2 ) ; }
+public void METHOD_2 ( int i ) { VAR_1. METHOD_3 ( i ) ; }
+public TYPE_1 METHOD_2 ( TYPE_1 id, TYPE_2 text, TYPE_3 id2, TYPE_4 text2, TYPE_5 id3, TYPE_6 text3 ) {
+public void METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_1 ) { throw new TYPE_1 ( ) ; } }
+public void METHOD_2 ( int VAR_1, String STRING_1 ) { TYPE_1. METHOD_2 ( VAR_1, STRING_1 ) ; }
+public boolean METHOD_2 ( android.view.View VAR_1, TYPE_2 VAR_2 ) { return false ; }
+public void METHOD_2 ( ) { TYPE_3. assertNotNull ( VAR_1. METHOD_4 ( ) ) ; }
+public boolean METHOD_2 ( TYPE_2 VAR_2 ) { if ( VAR_3 ) { VAR_2. METHOD_3 ( 1 ). METHOD_4 ( STRING_1 ) ; } else { VAR_2. METHOD_3 ( 1 ). METHOD_4 ( STRING_2 ) ; } return true ; }
+public void METHOD_2 ( TYPE_2 VAR_1 ) { TYPE_3 VAR_3 = ( TYPE_3 ) ( VAR_1. METHOD_3 ( ) ) ; VAR_1. METHOD_4 ( VAR_3 ) ; }
+// You are given a piece of buggy code. Your task is to fix the error, and generate the corrected code. Fix the following code:
+public static void main ( String[] args ) {
+void METHOD_2 ( ) { VAR_3 = true ; }
+public synchronized void METHOD_2 ( ) { VAR_1. METHOD_3 ( listener ) ; }
+public void METHOD_2 ( int i ) { VAR_1. METHOD_2 ( i ) ; }
+public boolean METHOD_2 ( TYPE_2 VAR_2 ) { TYPE_2 result = TYPE_3. METHOD_3 ( VAR_2 ) ; result. METHOD_4 ( ) ; return true ; }
diff --git a/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output b/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
new file mode 100644
index 0000000..1a5fe97
--- /dev/null
+++ b/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
@@ -0,0 +1,3 @@
+public void deserialize(LittleEndianInput in) {field_1_vcenter=in.readShort();}
+public void addAll(BlockList<T> src, int srcDirIdx, int srcBlkIdx) {if (src.size == 0)return;int srcDirIdx2 = srcDirIdx + 1;for (; srcDirIdx2 < src.tailDirIdx; srcDirIdx2++)addAll(src.directory[srcDirIdx2], srcDirIdx, srcBlkIdx);if (src.tailBlkIdx!= 0)addAll(src.tailBlock, srcDirIdx, srcBlkIdx);}
+public void writeBytes(String s) {if (upto + s.length() > blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];upto = 0;}for (int i = 0; i < s.length(); i++) {currentBlock[upto++] = (byte)s.charAt(i);}}
diff --git a/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output b/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
new file mode 100644
index 0000000..d1ea56d
--- /dev/null
+++ b/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
@@ -0,0 +1,3 @@
+public void deserialize(final LittleEndianInput in) {field_1_vcenter = in.readShort();}
+public void addAll(int srcDirIdx, int srcBlkIdx, int srcBlkSize) {if (srcBlkSize == 0)return;int srcDirIdx = 0;for (; srcDirIdx < srcBlkIdx; srcDirIdx++)addAll(src.directory[srcDirIdx], 0, srcBlkSize);if (srcBlkIdx!= 0)addAll(src.tailBlock, 0, srcBlkIdx);}
+public void writeShort(short s) {if (upto == blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new short[blockSize];upto = 0;}currentBlock[upto++] = s;}
diff --git a/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output b/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
new file mode 100644
index 0000000..3590d0f
--- /dev/null
+++ b/output/code2code-trans/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
@@ -0,0 +1,3 @@
+public void serialize(LittleEndianOutput out) {out.writeShort(field_1_vcenter);}
+public void addAll(BlockList<T> src) {if (src.size == 0)return;int srcDirIdx = 0;for (; srcDirIdx < src.tailDirIdx; srcDirIdx++)addAll(src.directory[srcDirIdx], 0, BLOCK_SIZE);if (src.tailBlkIdx!= 0)addAll(src.tailBlock, 0, src.tailBlkIdx);}
+public void writeByte(byte b, int offset) {if (offset >= blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];offset = 0;}currentBlock[offset++] = b;}
diff --git a/output/code2code-trans/prompt0/codegen1-multi-16B.output b/output/code2code-trans/prompt0/codegen1-multi-16B.output
new file mode 100644
index 0000000..8e68c7a
--- /dev/null
+++ b/output/code2code-trans/prompt0/codegen1-multi-16B.output
@@ -0,0 +1,3 @@
+public void serialize(System.IO.Stream out) throws IOException {
+public void addAll(BlockList<T> src, int srcDirIdx, int srcBlkIdx, int srcOff) {if (src.size == 0)return;int srcOff2 = srcOff;for (; srcDirIdx < src.tailDirIdx; srcDirIdx++)addAll(src.directory[srcDirIdx], srcBlkIdx, srcOff2);if (src.tailBlkIdx!= 0)addAll(src.tailBlock, srcBlkIdx, srcOff2);}
+public void writeByte(byte b) {if (upto == blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];upto = 0;}currentBlock[upto++] = b;}
diff --git a/output/code2code-trans/prompt0/codegen1-multi-2B.output b/output/code2code-trans/prompt0/codegen1-multi-2B.output
new file mode 100644
index 0000000..1a5fe97
--- /dev/null
+++ b/output/code2code-trans/prompt0/codegen1-multi-2B.output
@@ -0,0 +1,3 @@
+public void deserialize(LittleEndianInput in) {field_1_vcenter=in.readShort();}
+public void addAll(BlockList<T> src, int srcDirIdx, int srcBlkIdx) {if (src.size == 0)return;int srcDirIdx2 = srcDirIdx + 1;for (; srcDirIdx2 < src.tailDirIdx; srcDirIdx2++)addAll(src.directory[srcDirIdx2], srcDirIdx, srcBlkIdx);if (src.tailBlkIdx!= 0)addAll(src.tailBlock, srcDirIdx, srcBlkIdx);}
+public void writeBytes(String s) {if (upto + s.length() > blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];upto = 0;}for (int i = 0; i < s.length(); i++) {currentBlock[upto++] = (byte)s.charAt(i);}}
diff --git a/output/code2code-trans/prompt0/codegen1-multi-350M.output b/output/code2code-trans/prompt0/codegen1-multi-350M.output
new file mode 100644
index 0000000..d1ea56d
--- /dev/null
+++ b/output/code2code-trans/prompt0/codegen1-multi-350M.output
@@ -0,0 +1,3 @@
+public void deserialize(final LittleEndianInput in) {field_1_vcenter = in.readShort();}
+public void addAll(int srcDirIdx, int srcBlkIdx, int srcBlkSize) {if (srcBlkSize == 0)return;int srcDirIdx = 0;for (; srcDirIdx < srcBlkIdx; srcDirIdx++)addAll(src.directory[srcDirIdx], 0, srcBlkSize);if (srcBlkIdx!= 0)addAll(src.tailBlock, 0, srcBlkIdx);}
+public void writeShort(short s) {if (upto == blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new short[blockSize];upto = 0;}currentBlock[upto++] = s;}
diff --git a/output/code2code-trans/prompt0/codegen1-multi-6B.output b/output/code2code-trans/prompt0/codegen1-multi-6B.output
new file mode 100644
index 0000000..3590d0f
--- /dev/null
+++ b/output/code2code-trans/prompt0/codegen1-multi-6B.output
@@ -0,0 +1,3 @@
+public void serialize(LittleEndianOutput out) {out.writeShort(field_1_vcenter);}
+public void addAll(BlockList<T> src) {if (src.size == 0)return;int srcDirIdx = 0;for (; srcDirIdx < src.tailDirIdx; srcDirIdx++)addAll(src.directory[srcDirIdx], 0, BLOCK_SIZE);if (src.tailBlkIdx!= 0)addAll(src.tailBlock, 0, src.tailBlkIdx);}
+public void writeByte(byte b, int offset) {if (offset >= blockSize) {if (currentBlock!= null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];offset = 0;}currentBlock[offset++] = b;}
diff --git a/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output b/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-16B-checkpoint.output
new file mode 100644
index 0000000..e69de29
diff --git a/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output b/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-2B-checkpoint.output
new file mode 100644
index 0000000..e69de29
diff --git a/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output b/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-350M-checkpoint.output
new file mode 100644
index 0000000..e69de29
diff --git a/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output b/output/commit/prompt0/.ipynb_checkpoints/codegen1-multi-6B-checkpoint.output
new file mode 100644
index 0000000..e69de29
diff --git a/output/commit/prompt0/codegen1-multi-16B.output b/output/commit/prompt0/codegen1-multi-16B.output
new file mode 100644
index 0000000..42e3b09
--- /dev/null
+++ b/output/commit/prompt0/codegen1-multi-16B.output
@@ -0,0 +1,95 @@
+changed the line "buf.writeBytes(request.getMethod().toString().getBytes(CharsetUtil.US_ASCII))" to "encodeAscii(request.getMethod().toString(), buf)"
+changed the line that was commented out
+changed "new Method" to "new Method(" + methodName + ", " + returnType + ", " + parameterTypes + ")"
+added the import statement for the new class
+the first line is the diff header
+added a call to dispose() in DialogWrapperPeerImpl.dispose()
+changed the import from Http11AprProtocol to AjpAprProtocol
+changed "this.channel" to "this.channel"
+the first line is the diff header
+the first line is a header
+changed to private
+changed the return type of the buildLayout method from RotateLayout to RotateLayout
+removed the if statement that was checking if the container existed
+the first line is a comment
+changed class name
+the diff is applied to the current version of the file,
+
+changed "if (model.containsNonNullValue(property))" to "if (model.hasTransitory(property.getName()))"
+removed the line that called recycleCachedViews()
+the first line is the same
+changed the type of the variable "initiator" from int to a constant
+changed the logic around the title
+changed the line "host = svc.getHost();" to "host = svc.getHost();"
+added Logger class
+changed the order of the if statements
+changed the name of the class from ChangeBaseParserWeight to ChangeBaseOptions
+removed the @Seed annotation
+the diff is about the addition of the new line
+removed the deprecation warning
+the diff is about the "if (_stopping!=null)" line
+added a method showBreakpointsDialog
+the first line was added
+the first line was changed from "public abstract class AbstractEntityManagerImpl implements HibernateEntityManage" to "public class AbstractEntityManagerImpl implements HibernateEntityManage"
+changed the visibility of the map button to visible
+removed the import of Roster
+56,8 +56,8:  StringBuilder pageBldr = new StringBuilder("<div class=container-fluid'><div class='row-fluid'><div class='span2' style='text-align:right;overflow-x:scroll;'><h5>Columns</h5>");
+changed type of parameter "symbol" from Symbol to Symbol
+changed to use SVNPathUtil.tail()
+changed the order of the lines in the diff
+getter should be allowed
+the diff is a change to the url.setText line
+the first line is the diff header
+added ClassLoaderUtils.class
+changed the package name
+changed the order of the if/else blocks
+changed "BinaryBlockWriter" to "BinaryBlockWriter"
+removed the if statement that checks for port being in bounds
+the first time we run a diff, we need to create the index
+the first line is the diff header
+the "withProtection" method was added
+changed the return type from Predicate to Predicate<D>
+changed the method signature to take a timeout parameter
+removed the "name" parameter
+the original method is commented out
+the first line was added
+the first time, the file is found, the md5 is computed, the statements are generated, the md5 is computed again
+
+the first line is the same
+the diff is about the package name of the home activity
+the first line is a comment
+changed the diff to use the new ClusterManager class
+changed the order of the if/then statements
+removed the "if" statement that was checking for the existence of the
+changed type of EXTRA_SKIP_UNINSTALL_CONFIRMATION from boolean to String
+the first line is the same
+removed the deprecated method
+changed the name of the variable
+the diff is about the following lines:
+the superclass method was removed
+changed class name
+the first line is a copy of the original
+changed "this.from = block.getRelative(face.getModX(), face.getModY(), face.getModZ());" to "this.from = block.getRelative(face.getModX(), face.getModY(), face.getModZ());"
+the first line was added
+
+changed type of parameter "moduleClass" from "Class<T>" to "Class<? extends WXModule>
+changed the type of store from HashMap to ConcurrentMap
+changed camelContext to camelContext
+the first line is the diff header
+changed package name
+the first line is the diff header
+removed the @Override annotation
+the diff is a bunch of additions to the end of the file
+the first time we use LuceneTestCase, which has some initialization that
+the first line is removed,
+removed the if statement that was checking if the component was already focused
+the first line was added
+added the permissionAsked variable
+changed the setAvatar method to take a byte[] and a String
+added super.tearDown()
+added a new import
+the first line is the same
+the method name is changed
+57,8 +57,7 is the diff between the lines that start with "//~ Constructors"
+changed the if statement to return false
+changed the return type of isValidBlockType() from boolean to int
diff --git a/output/commit/prompt0/codegen1-multi-2B.output b/output/commit/prompt0/codegen1-multi-2B.output
new file mode 100644
index 0000000..769ab5a
--- /dev/null
+++ b/output/commit/prompt0/codegen1-multi-2B.output
@@ -0,0 +1,95 @@
+35,7 +35,7 = 51,7
+77,7:
+77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9: 77,9:
+39,6 + 39,7 = 39,8
+Filter.java:
+27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:27,10:27,8:
+140,7 +140,7
+613,10:
+80,6 +80,8 = 80,8
+170,8 +170,6 = 170,6
+186,9 +186,9 = 186,9
+38,7 +38,7 @@public class ClockwiseRotate implements LayoutBuilder {
+120,6:
+h generates only a shell
+43,7 +43,7 = 43,7
+242,8 - 242,7 = -1,1 = -242,8 - 242,7
+
+32,8 - 32,8
+2362,7 -2456,18 +2456,18
+193,7 -193,9 -33514d2..cc5b801 100644
+61,6 -> -61,7
+435,7 - 435,11
+453,7 +453,7 @@ public abstract class LoadBalancerContext<T extends ClientRequest, S extends IRe
+5,6 +5,9 = 5,9
+64,9 -> 64,7
+11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11,6 +11,8 = -11
+22,7 +22,6 = 22,7
+51,7 +51,7 @@ import org.junit.runners.model.TestClass;
+717,7 +717,12 = 717,12
+added stopTimeout
+a/platform/xdebugger-api/src/com/intellij/xdebugger/XDebuggerUtil.java
+82,6 - 82,7 = 82,6
+6 lines of code
+311,7 +311,9
+49,7 + 48,7 = 1,822 bytes
+56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@ -56,8 + 56,8 @@
+48,6: a91de4b00f
+119,7 - 119,7
+68,6 +68,11 = 68,11
+Foo.prototype.bar_ is marked as BAD_PRIVATE_PROPERTY_ACCESS
+115,7 +115,9
+added HistoryStrategy
+26,6 +26,7 -26,6 +26,7 +121,6 -121,7
+821,7 +821,7 @@ public abstract class NanoHTTPD {
+66,6 +66,8 = -66,8
+22,7 +22,7 @@public class BinaryBlockWriter<M> {
+90,8 +90,8 @@ -90,8 +90,8
+1.1.1.1 -1.1.1.2 -1.1.1.3 -1.1.1.4 -1.1.1.5 -1.1.1.6 -1.1.1.7 -1.1.1.8 -1.1.1.9 -1.1.1.10 -1.1.1.11 -1.1.1.12 -1.1.1.13 -1.1.1.14 -1.1.1.15 -1.1.1.16 -1.1.1.17 -1.1.1.18 -1.1.1.19 -1.1.1.20 -1.1.1.21 -1.1.1.22 -1.1.1.23 -1.1.1.24 -1.1.1.25 -1.1.1.26 -1.1.1.27 -1.1.1.28 -1.1.1.29 -1.1.1.30 -1.1.1.31 -1.1.1.32 -1.1.1.33 -1.1.1.34 -1.1.1.35 -1.1.1.36 -1.1.1.37 -1.1.1.38 -1.1.1.39 -1.1.1.40 -1.1.1.41 -1.1.1.42 -1.1.1.43 -1.1.1.44 -1.1.1.45 -1.1.1.46 -1.1.1.47 -1.1.1.48 -1.1.1.49 -1.1.1.50 -1.1.1.51 -1.1.1.52 -1.1.1.53 -1.1.1.54 -1.1.1.55 -1.1.1.56 -1.1.1.57 -1.1.1.58 -1.1.1.59 -1.1.1.60 -1.1.1.61 -1.1.1.62 -1.1.
+49,7 +49,18
+21,5 +21,33 = -21,5 +21,33
+436,6 +436,18 = 436,6
+307,12:
+added "name" and "unique" options
+59,6 +59,7 = 59,7
+diff of changes
+a/liquibase-core/src/test/java/liquibase/change/core/SQLFileChangeTest.java
+
+96,7 +96,7 @@ public class AddColumnGenerator extends AbstractSqlGenerator<AddColumnStatement>
+5126,6:
+131,8 +131,7 = 131,8
+4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +4 +
+144,7 +144,9 = 144,9
+112,6 +112,21 = 112,6
+1575,6 +1575,14 100644
+diff of changes
+451,7 +451,10 = 451,7
+73,7 +73,7 @@ public class LiveUpdatesSettingsDialogFragment extends DialogFragment {
+61,6:
+Added onFocusChanged()
+a/jodd-db/src/main/java/jodd/db/connection/ConnectionProvider.java
+80,9 -80,17 +80,17 +80,9
+9,14 +9,14 @@ -9,14 +9,14 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8 +34,8 @@ -34,8
+398,7 +398,7 @@ public abstract class Repository extends RepositoryInfo {
+
+moduleName:
+28,8 +28,8 = 0
+added AggregationStrategy
+topLeftX is now topLeftX - margin
+added CamelOutputStream
+95,6 +95,7
+a/advanced/src/main/java/org/neo4j/kernel/impl/ha/LockStatus.java
+157,7 +157,7 = 172,18
+20,6 +20,7 = 413,7
+62,9 - 62,6 = 1 line
+getFocusedComponent() -> getFocusedComponentImpl()
+346,7 +346,7 @@ public final class SugarDataSource<T> {
+602,7 + 602,7
+add avatar
+479,7..479,8
+21,6 +21,7 = -69,6 +70,7 = 69,6
+61,7 +62,11 = 61,7
+ChangeProvider.getChanges()
+57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,7:57,
+253,7 - 253,9 = -253,7
+670,7 +670,7 = 670,7
diff --git a/output/commit/prompt0/codegen1-multi-350M.output b/output/commit/prompt0/codegen1-multi-350M.output
new file mode 100644
index 0000000..faa95f1
--- /dev/null
+++ b/output/commit/prompt0/codegen1-multi-350M.output
@@ -0,0 +1,95 @@
+http://code.google.com/p/netty/issues/detail?id=35
+a new line
+the first line of the file is commented out
+the contact id
+antProject.getExecutor().executeTargets(antProject, new String[] { "test" });
+the method dispose() is called
+import org.apache.coyote.http11.Http11AprProtocol
+a) if (channel == null) {
+the file is deleted
+diff of changes
+Message: class = 0x00 (0x00), type = 0x00 (0x00), buffer = 0x00
+the difference between the two layouts
+delete container
+h
+a summary of the above diff
+the check below makes sence only for valid PsiElement
+
+the difference between the two lines above
+the difference between the two lines above
+generateHeaderId(0)
+http://www.parosproxy.org/paros/network/HttpSender.java
+the post this comment is on can only be requested if this is a.com blog or a
+diff of changes
+a new line
+a summary of the above diff
+output model
+index 09123fb..fee2f32 100644
+* The user's filename should be included in the config file name,
+mkdir
+a stop timeout of 0 means no stop timeout
+diff --git a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/XDebuggerUtilImpl.java
+if (nameAttributes == null)  nameAttributes = new SimpleTextAttributes(Font.PLAIN, color);
+the first line of the diff is the first line of the class
+the first fragment
+a diff of changes
+a summary of the above diff is:
+a new reference for a symbol
+diff --git a/plugins/svn4idea/src/org/jetbrains/idea/svn/commandLine/CmdStatusClient.java b/plugins/svn4idea/src/org/jetbrains/idea/svn/commandLine/CmdStatusClient.java
+(1) verify(context).unregisterReceiver(dispatcher.receiver);
+a private property access
+diff --git a/app/src/main/java/io/plaidapp/ui/PostNewDesignerNewsStory.java b/app/src/main/java/io/plaidapp/ui/PostNewDesignerNewsStory.java
+the room subject is null
+a classpath provider for the core project
+a) parseBody()
+the parser model
+a summary of the above diff is:
+host = IDN.toASCII(host);
+diff --git a/src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java b/src/main/java/org/elasticsearch/indices/cluster/IndicesClusterStateService.java
+displayProperties = true;
+a/curator-framework/src/main/java/com/netflix/curator/framework/api/ProtectACLCreateModePathAndBytesable.java
+create a predicate
+enter(long, TimeUnit)
+a.ensureIndex( a.keys, a.name, a.unique )
+read the file
+a summary of the above diff is:
+the file is not found
+
+diff --git a/liquibase-core/src/main/java/liquibase/sqlgenerator/core/AddColumnGenerator.java b/liquibase-core/src/main/java/liquibase/sqlgenerator/core/AddColumnGenerator.java
+the package name of the activity
+a list of all tasks
+a.java:
+weighted sum of squared response
+a summary of the above diff
+a summary of the above diff
+index:95e525039
+setOutputURI(conf, OUTPUT_URI)
+download via wifi switch
+diff of changes
+the above diff is the first one
+a.jodd.db.connection.ConnectionProvider.ConnectionProvider()
+the element is the parent of the next element
++    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +    +
+the date formatters are initialized
+
+moduleName: "com.taobao.weex.WXSDKEngine"
+a new core system
+diff of changes
+diff --git a/PreviewAPI/src/org/gephi/preview/PreviewControllerImpl.java b/PreviewAPI/src/org/gephi/preview/PreviewControllerImpl.java
+the first line is the first line of the file
+a new point is added to the target points
+import java.io.Serializable;
+java.lang.RuntimeException:
+diff:
+diff --git a/platform/lang-impl/src/com/intellij/unscramble/AnalyzeStacktraceUtil.java b/platform/lang-impl/src/com/intellij/unscramble/AnalyzeStacktraceUtil.java
+a top component is set if the component is focused
+346: count = future.get();
+if (!permissionDone) {
+setAvatar(byte[] bytes, String mimeType)
+// +    +--- a/plugins/tasks/tasks-tests/test/com/intellij/tasks/vcs/TaskVcsTest.java
+a filter that returns true for the first item
+the file is not null
+Get changes from point of view of VCS
+a) the consumer manager
+diff of changes
+diff --git a/src/main/java/com/sk89q/worldedit/bukkit/BukkitWorld.java b/src/main/java/com/sk89q/worldedit/bukkit/BukkitWorld.java
diff --git a/output/commit/prompt0/codegen1-multi-6B.output b/output/commit/prompt0/codegen1-multi-6B.output
new file mode 100644
index 0000000..7cf095b
--- /dev/null
+++ b/output/commit/prompt0/codegen1-multi-6B.output
@@ -0,0 +1,95 @@
+35,7 +35,7 @@ public class HttpRequestEncoder extends HttpObjectEncoder<HttpRequest> {
+77,7 +77,9
+77,9 +77,9
+39,6 +348,8 = 347
+add a new field to the class
+added a comment
+add a new class
+add a new method to the interface
+80 lines of code added
+add a new method to the class
+Removed the 'private' modifier
+38,7 +38,7 @@ public class ClockwiseRotate implements LayoutBuilder {
+add a new method
+1,7 +1,7 @@
+43,7 +43,7 @@
+the first line is the same
+
+32,8 +32,8 @@ public class JSONPropertySupport {
+2362 lines changed
+add header id
+added the "initiator" constants
+435,7 + 435,11 = 435
+453,7 +453,7 @@ public abstract class LoadBalancerContext<T extends ClientRequest, S extends IRe
+5,6 +5,9
+64,9 +64,7 = -1
+added a new constructor
+added a comment
+if the filename contains a slash, the username is not included in the config file name
+717,7 + 717,12 - 717,7 + 717,12 = +1
+289 lines
+remove 'XDebuggerUtil'
+rename the class
+add a method to AbstractEntityManagerImpl
+311,7 +311,9 @@ public class FirstUsageWizardFragment extends Fragment implements OsmAndLocation
+Removed the import of org.jivesoftware.openfire.roster.Roster;
+56,8 +56,8
+a91de4b00f..e6dac0d284 100644
+added new method to the class
+added a new method to DispatcherTest
+"@private" is removed
+added a new line
+1:1 +1:1
+26,6 +26,7 @@ import org.gradle.internal.classloader.ClassLoaderHierarchy;
+821,7 +821,7 @@ public abstract class NanoHTTPD {
+66,6 +66,8 @@ public class LexicalizedParserServer {
+22,7 +22,7 @@ public class BinaryBlockWriter<M> {
+90,8 +90,8
+if the index meta data didn't change, no need check for refreshed settings
+49,7 +49,18 @@ public class Ls extends NeoApp
+Removed the 'protected' keyword from the interface
+removed the "in"
+307 lines changed
+410,14 +410,15 @@ public abstract class DBCollection {
+remove all the XML-specific stuff
+add a new method onResolveInfoResult()
+diff of changes
+
+96,7 +96,7 @@ public class AddColumnGenerator extends AbstractSqlGenerator<AddColumnStatement>
+5126,6 +5126,11 = +5126
+131,8 +131,7 @@ public class TaskController extends AbstractController {
+426,8 +426,7 @@ public class SimpleTcpCluster extends LifecycleMBeanBase
+diff of changes in the file
+112,6 +112,21
+1575,6 +1575,14 @@ public class Intent implements Parcelable, Cloneable {
+the first line is the old code
+451,7 +451,10
+73 chars
+added the "if (packet.getSubject() == null || "".equals(packet.getSubject().trim()))"
+248,9 +248,11 -248,9 +248,11
+34,7 +34,7 @@ import java.sql.Connection;
+80,9 + 80,17
+9,14 +9,14 @@
+the date pattern is not used in the repository
+
+345,7 +345,7 @@ public class WXSDKEngine {
+28,8+28,8
+add a new field to the class
+Removed the commented out code
+removed the package name
+added a new method to get the y coordinate of the point to navigate to
+added a new enum
+java_major: 1.6.0 -> 1.7.0
+add a new abstract class
+62 chars changed
+89,6 +89,7 @@ public class FocusWatcher implements ContainerListener,FocusListener{
+346,7 +346,7 @@ public final class SugarDataSource<T> {
+add a new method to the class
+356,6 +356,26 @@ public class VCard extends IQ {
+479,7 +479,8 @@ public class TaskVcsTest extends CodeInsightFixtureTestCase {
+21,6 +21,7 -69,6 +70,7
+1,6 +1,7 = -61,7 +62,11 = -1,7 +1,11
+26,9 +26,13 @@
+added a constructor with a ConsumerManager
+add the idempotent check
+added a check for material.getMaterial(type)!= null
diff --git a/render_output.py b/render_output.py
index 1d7dee9..dc6e6ab 100644
--- a/render_output.py
+++ b/render_output.py
@@ -4,21 +4,23 @@
 
 class OutputRenderer:
     def __init__(self, baseline=0.0, metric="(Unspecified metric)"):
-        self.x_values = [0.35, 2.00, 6.00, 16.00]
+        self.x_values = [0.35, 2.70, 6.10, 16.10]
         self.box_color = "Pink"
         self.baseline = baseline
         self.metric = metric
 
     
-    def set_lim(self):
-        # hardcoded based on our problem's specifications
+    def set_lim(self, y_max=None):
+        if y_max is None:
+            y_max = 1
+        # mostly hardcoded based on our problem's specifications
         plt.xlim(-1, 17)
-        plt.ylim(0, 1)
+        plt.ylim(0, y_max)
 
     
-    def draw_box(self, ax):
+    def draw_box(self, ax, ys):
         bplot = ax.boxplot(
-            self.y_values,
+            ys,
             positions=self.x_values,
             widths=1,
             manage_ticks=False,
@@ -30,29 +32,32 @@ def draw_box(self, ax):
         for patch in bplot["boxes"]:
             patch.set_facecolor(self.box_color)
     
-    def draw_line(self, ax):
-        medians = [median(vals) for vals in self.y_values]
+    def draw_line(self, ax, ys, label=None, color="b"):
+        medians = [median(vals) for vals in ys]
         line = ax.plot(
             self.x_values,
             medians,
             marker="o",
-            color="b",
+            color=color,
             linestyle="-",
             markerfacecolor="none",
             markeredgewidth=2,
             markersize=8,
             # alpha=0.5,
             zorder=8,
+            label=label,
         )
 
-    def draw_random_annotation(self):
+    def draw_random_annotation(self, y_max=None):
         plt.axhline(
             y=self.baseline,
             color="r",
             # alpha=0.5,
             zorder=2,
         )
-        offset = (-0.1, 0.02)
+        if y_max is None:
+            y_max = 1
+        offset = (-0.1, 0.02 * y_max)
         plt.text(
             plt.xlim()[0] + offset[0],
             self.baseline + offset[1],
@@ -66,9 +71,9 @@ def meta_info(self):
         plt.ylabel(self.metric)
         plt.title("Model Performance")
     
-    def draw_bands(self, ax):
-        q1 = [np.percentile(val, 25) for val in self.y_values]
-        q3 = [np.percentile(val, 75) for val in self.y_values]
+    def draw_bands(self, ax, ys, color="b"):
+        q1 = [np.percentile(val, 25) for val in ys]
+        q3 = [np.percentile(val, 75) for val in ys]
         iqr = [b - a for a, b in zip(q1, q3)]
         # print(q1, q3)
         ax.fill_between(
@@ -77,7 +82,7 @@ def draw_bands(self, ax):
             list(map(lambda x, y: x + 1.5 * y, q3, iqr)),
             alpha=0.1,
             zorder=5,
-            color="b",
+            color=color,
         )
         ax.fill_between(
             self.x_values,
@@ -85,27 +90,38 @@ def draw_bands(self, ax):
             q3,
             alpha=0.2,
             zorder=5,
-            color="b",
+            color=color,
         )
     
-    def render(self, ys):
-        self.y_values = [
-            y if isinstance(y, list)
-            else [y]
-            for y in ys
-        ]
+    def render(self, ys, y_max=None):
+        y_lines = ys
+        if not isinstance(y_lines, dict):
+            y_lines = { "unnamed": y_lines }
+
+        for key, ys in y_lines.items():
+            ys = [
+                y if isinstance(y, list)
+                else [y]
+                for y in ys
+            ]
+            y_lines[key] = ys
 
         fig = plt.figure(figsize=(10, 6))
     
         ax1 = fig.add_subplot(111)
         plt.grid(True)
-        self.set_lim()
+        self.set_lim(y_max=y_max)
         self.meta_info()
     
-        self.draw_random_annotation()
-        
-        self.draw_bands(ax1)
-        self.draw_line(ax1)
-        self.draw_box(ax1)
+        self.draw_random_annotation(y_max=y_max)
+
+        colors = ["b", "g", "r"]
+        for idx, (key, ys) in enumerate(y_lines.items()):
+            color = colors[idx % len(colors)]
+            self.draw_bands(ax1, ys, color=color)
+            self.draw_line(ax1, ys, label=key, color=color)
+            self.draw_box(ax1, ys)
+
+        plt.legend()
         
         plt.show()
\ No newline at end of file
diff --git a/timehelp.py b/timehelp.py
index 6ca4d7d..32fcdb8 100644
--- a/timehelp.py
+++ b/timehelp.py
@@ -58,25 +58,36 @@ def time_end():
     display_now = datetime.today().strftime("%Y-%m-%d@%H:%M:%S")
     print(f"[{display_now}|{timer_label}] Time elapsed:", fmt_delta(elapsed))
 
-def with_progress(steps=None, label=None):
+def with_progress(steps=None, label="Progress"):
     assert steps is not None, "@with_progress: Missing required parameter steps"
-    label = label or "Progress"
     total_steps = steps
     def decorator(func):
         @wraps(func)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args, skip=None, **kwargs):
             # Create widgets
-            progress = widgets.IntProgress(value=0, min=0, max=total_steps, description=f"{label}:")
+            progress = widgets.IntProgress(
+                value=0, min=0, max=total_steps,
+                **(
+                    dict(description=f"{label}:") if label
+                    else {}
+                )
+            )
             estimated_time = widgets.Label(value="Estimated time remaining: calculating...")
             
-            # Combine progress bar and estimated time in a horizontal box
-            hbox = widgets.HBox([progress, estimated_time])
+            hbox = widgets.VBox([progress, estimated_time])
             display(hbox)
             
-            # Start time
             start_time = time.time()
-            
-            for step in range(total_steps):
+
+            start = 0
+            if skip is not None:
+                assert skip >= 0, f"Cannot skip {skip} lines"
+                start = skip
+
+            my_total_steps = total_steps - start
+            result = None
+            progress.value = start
+            for step in range(start, start + my_total_steps):
                 # Call the wrapped function
                 result = func(*args, **kwargs, step=step)
                 
@@ -86,15 +97,24 @@ def wrapper(*args, **kwargs):
                 # Calculate and update estimated time remaining
                 elapsed_time = time.time() - start_time
                 remaining_steps = total_steps - (step + 1)
-                if step > 0:
-                    time_per_step = elapsed_time / (step + 1)
+                steps_so_far = step + 1 - start
+                if steps_so_far > 1:
+                    time_per_step = elapsed_time / steps_so_far
                     estimated_remaining_time = time_per_step * remaining_steps
-                    estimated_time.value = f"Estimated time remaining: {fmt_delta(estimated_remaining_time)}, {fmt_delta(elapsed_time)} elapsed..."
+                    estimated_time.value = f"[{step + 1}/{total_steps}] ETA: {fmt_delta(estimated_remaining_time)}, {fmt_delta(elapsed_time)} elapsed..."
                 else:
-                    estimated_time.value = f"Estimated time remaining: calculating, {fmt_delta(elapsed_time)} elapsed..."
-            
+                    estimated_time.value = f"[{step + 1}/{total_steps}] ETA: calculating, {fmt_delta(elapsed_time)} elapsed..."
+
+            progress.value = total_steps
             estimated_time.value = f"Done, {fmt_delta(time.time() - start_time)} elapsed."
+            print(estimated_time.value)
             return result
         
         return wrapper
     return decorator
+
+
+def display_header(text):
+    header = widgets.HTML(value=f"<h1 style='font-weight: bold;'>{text}</h1>")
+    display(header)
+    print(f"# {text}")