diff --git a/notebooks/evaluation/01.coolstore.ipynb b/notebooks/evaluation/01.coolstore.ipynb index 09d6d46a..b0e4eb94 100644 --- a/notebooks/evaluation/01.coolstore.ipynb +++ b/notebooks/evaluation/01.coolstore.ipynb @@ -14,6 +14,8 @@ "\n", "For evaluating the responses, we will be using another LLM to evaluate based on a well defined criteria. More about details of evaluation later.\n", "\n", + "> Most of this notebook contains the actual experiments and steps to recreate them. Jump to the last section for results, learnings and conclusions.\n", + "\n", "## Pre-requisites\n", "\n", "To run snippets in this notebook, you first need to set up Kai's virtualenv in the [base dir](../../).\n", @@ -46,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -79,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -95,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -112,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -186,8 +188,7 @@ " * This file only has 1 migration issue. And it can be fixed by changing one import to a Quarkus compatible import. The underlying API itself doesn't require any change.\n", "* Hard example [ShoppingCartOrderProcessor.java](https://github.com/konveyor-ecosystem/coolstore/blob/main/src/main/java/com/redhat/coolstore/service/ShoppingCartOrderProcessor.java)\n", " * This file has 10 issues most of which involve replacing import statements from `javax` to `jakarta`.\n", - " * There are two issues that require changing an annotation to a quarkus compatible annotation.\n", - " * However, there is one change in this file that involves replacing JMS Topic with an Emitter. This is a code rewrite thats more than just doing a string replace." + " * However, we will focus on one issue that involves replacing JMS Topic with an Emitter. This is a code rewrite thats more than just doing a string replace." ] }, { @@ -199,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -239,11 +240,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# now we will create data required for evaluation\n", + "import copy\n", "from datetime import datetime\n", "from kai.evaluation import BenchmarkExample, evaluate\n", "from kai.service.incident_store import Application\n", @@ -272,7 +274,10 @@ " )\n", "\n", "EXAMPLE_EASY = examples['src/main/java/com/redhat/coolstore/model/ShoppingCart.java']\n", - "EXAMPLE_HARD = examples['src/main/java/com/redhat/coolstore/service/ShoppingCartOrderProcessor.java']" + "hard_example = examples['src/main/java/com/redhat/coolstore/service/ShoppingCartOrderProcessor.java']\n", + "ex = copy.deepcopy(hard_example)\n", + "ex.incidents = ex.incidents[:7]\n", + "EXAMPLE_HARD = copy.deepcopy(ex)" ] }, { @@ -284,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 80, "metadata": {}, "outputs": [], "source": [ @@ -526,7 +531,7 @@ " if EVALUATION_MODEL == CLAUDE_SONNET:\n", " llm = ChatBedrock(model_id=\"anthropic.claude-3-5-sonnet-20240620-v1:0\")\n", " else:\n", - " llm = ChatOpenAI(model_name=\"gpt-4o\")\n", + " llm = ChatOpenAI(model_name=\"gpt-4o\", model_kwargs={\"temperature\": 0.2})\n", " output = llm.invoke(t)\n", " return output.content\n", "\n", @@ -535,6 +540,7 @@ " ratings = []\n", " reasoning = []\n", " for idx, line in enumerate(output.strip('\\n').strip('```').replace(\"\\n\\n\", \"\\n\").split(\"\\n\")):\n", + " if idx > 3: break\n", " if idx % 2 == 0:\n", " ratings.append(float(line))\n", " else:\n", @@ -563,16 +569,19 @@ "def plot_multibar_chart(data: list[tuple[dict, str]]):\n", " labels = [label for _, label in data]\n", " models = list(data[0][0].keys())\n", - " fig, ax = plt.subplots()\n", - " for model in models:\n", - " model_values = [results[model] for results, _ in data]\n", - " ax.plot(labels, model_values, marker='o', label=model)\n", - " ax.set_xlabel('Experiments')\n", + " x = np.arange(len(models))\n", + " width = 0.2 # the width of the bars\n", + " fig, ax = plt.subplots(figsize=(12, 6))\n", + " for i, (results, label) in enumerate(data):\n", + " values = [results[model] for model in models]\n", + " ax.bar(x + i*width, values, width, label=label)\n", + " ax.set_xlabel('Models')\n", " ax.set_ylabel('Scores')\n", - " ax.set_title('Model Performance by Experiment')\n", - " ax.legend(loc='center left', bbox_to_anchor=(1, 1))\n", - " plt.subplots_adjust(right=0.75)\n", - " ax.legend()\n", + " ax.set_title('Evaluation score by experiment')\n", + " ax.set_xticks(x + width / len(data) * (len(data) - 1))\n", + " ax.set_xticklabels(models)\n", + " ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n", + " plt.tight_layout(rect=[0, 0, 0.85, 1])\n", " plt.show()\n", "\n", "# given raw evaluation output from models, plots the chart and prints reasoning \n", @@ -580,11 +589,11 @@ " data = {}\n", " for model in KAI_FIX_MODELS:\n", " data[model] = parse_evaluation_output(eval_output[model])\n", - " plot_evaluation_score({k: np.average(v[0], weights=[0.6, 0.3, 0.1]) for k, v in data.items()})\n", + " plot_evaluation_score({k: np.average(v[0], weights=[0.7, 0.3]) for k, v in data.items()})\n", " for model in KAI_FIX_MODELS:\n", " print(f\"{'* '}{model}\")\n", " for idx, reasoning in enumerate(data[model][1]):\n", - " print(f\"\\t{idx+1}. {reasoning}\")\n", + " print(f\"\\t{idx+1}. ({int(data[model][0][idx])}/5) {reasoning}\")\n", "\n", "# given multiple eval outputs, plots a chart side-by-side for comparison\n", "def plot_multibar_chart_from_eval_outputs(eval_outputs: list[tuple[dict, str]]):\n", @@ -593,7 +602,7 @@ " data_per_model = {}\n", " for model in KAI_FIX_MODELS:\n", " data_per_model[model] = parse_evaluation_output(eval_output[model])\n", - " data_list.append(({k: np.average(v[0], weights=[0.6, 0.3, 0.1]) for k, v in data_per_model.items()}, label))\n", + " data_list.append(({k: np.average(v[0], weights=[0.7, 0.3]) for k, v in data_per_model.items()}, label))\n", " plot_multibar_chart(data_list)\n", "\n", "def run_evaluation_for_models(models: list[str], example: BenchmarkExample, base_output_path: str) -> dict[str, tuple[int, str]]:\n", @@ -618,7 +627,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Easy example\n", + "### Easy example (Zero Shot)\n", "\n", "Lets start with the easy example (1 fix, simple import replace).\n", "\n", @@ -629,7 +638,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 137, "metadata": {}, "outputs": [ { @@ -679,11 +688,7 @@ "\n", "With this metric, we focus on general syntactical correctness. We specifically evaluate whether all imports are correct, function signatures are correct, etc.\n", "\n", - "3. Is the final file suitable for Quarkus? Are there more changes needed to be done?\n", - "\n", - "Here, we evaluate based on whether the final file is compatible with Quarkus. We also see if there were any new issues introduced in the file.\n", - "\n", - "We don't care about all these metrics equally, so we take an weighted average with weights being 0.6, 0.3, 0.1 from top to bottom.\n", + "We don't care about all these metrics equally, so we take an weighted average with weights being 0.7, 0.3 from top to bottom.\n", "\n", "The assumption is that the LLM we use for evaluation is somewhat knowledgeable about Quarkus. Given a hint about the migration issue, it will be good enough to give us a high level picture of the quality of responses. Find our evaluation prompt [here](./templates/evaluation.jinja). \n", "\n", @@ -694,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -712,12 +717,12 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -730,29 +735,23 @@ "output_type": "stream", "text": [ "* meta-llama-13b\n", - "\t1. The import statement for javax.enterprise was removed, but jakarta.enterprise was not added as requested. The @Dependent annotation was also removed without replacement.\n", - "\t2. The updated file appears to be syntactically valid and can be compiled. However, some imports are missing (e.g., for @Entity, @Id, @GeneratedValue).\n", - "\t3. The file is largely compatible with Quarkus, using JPA annotations for persistence. However, the missing jakarta.enterprise import and lack of CDI scope annotation (e.g., @ApplicationScoped) might cause issues in a Quarkus context.\n", + "\t1. (0/5) The original issue was not fixed. The import statement for javax.enterprise was not replaced with jakarta.enterprise as requested. Instead, it was removed entirely and a javax.enterprise.context.RequestScoped annotation was added, which does not address the migration to Quarkus.\n", + "\t2. (2/5) The updated file has some syntactical issues. It imports many unnecessary Jandex-related classes that are not used in the code. The Serializable interface is used but not imported. The @Dependent annotation is still present but its import is missing. These issues may cause compilation errors.\n", "* meta-llama-70b\n", - "\t1. The issue of replacing javax.enterprise import with jakarta.enterprise was not addressed. However, the import and @Dependent annotation were removed entirely, which is a valid approach for Quarkus if the class doesn't need to be a CDI bean.\n", - "\t2. The updated file is syntactically valid and can be compiled. All necessary imports are present, and the original functionality is maintained. The code has been cleaned up, using the diamond operator for generic types.\n", - "\t3. The updated file is compatible with Quarkus. The removal of the @Dependent annotation and Serializable interface makes it a plain Java class, which is suitable for use in Quarkus. However, if CDI injection was needed, this change might require adjustments in other parts of the application.\n", + "\t1. (0/5) The original issue of replacing the javax.enterprise import with jakarta.enterprise was not addressed. Instead, the import statement and @Dependent annotation were completely removed, which does not match the expected fix.\n", + "\t2. (4/5) The updated file is syntactically valid and can be compiled. All classes and interfaces used are valid. The original functionality appears to be maintained. The only minor issue is the removal of the @Dependent annotation, which might affect the bean's lifecycle in a CDI context.\n", "* ibm-granite\n", - "\t1. The updated file does not address the identified issue of replacing the javax.enterprise import with jakarta.enterprise. Instead, it introduces unrelated changes and Quarkus-specific annotations that weren't part of the original requirements.\n", - "\t2. The updated file has several syntactical issues, including invalid annotations (e.g., @Quarkus.Data), incorrect generic type declarations, and undefined types (e.g., Qu shoppingCartItem). These would prevent the file from compiling successfully.\n", - "\t3. While the file attempts to introduce Quarkus-specific elements, it does so incorrectly and introduces new issues. The original functionality is significantly altered, and the file is not suitable for use with Quarkus in its current state.\n", + "\t1. (1/5) The issue of replacing the javax.enterprise import with jakarta.enterprise is not addressed in the updated file. The import statement is completely removed, which does not meet the specific requirement.\n", + "\t2. (2/5) The updated file has several syntactical issues and deviations from the original functionality. The @QuarkusApplication annotation is not a standard Quarkus annotation. The @Inject annotation is used incorrectly on the constructor. The @NonNull annotation is used without proper import. The file is missing many fields and methods from the original class, which changes the functionality significantly.\n", "* mixtral\n", - "\t1. The issue of replacing javax.enterprise import with jakarta.enterprise is not directly addressed. Instead, the import and @Dependent annotation are removed entirely.\n", - "\t2. The updated file is syntactically valid and can be compiled. All necessary imports are present, and the code structure is correct.\n", - "\t3. The file is largely compatible with Quarkus. The @ToString annotation from io.quarkus.toString is used, which is Quarkus-specific. However, the removal of @Dependent might affect dependency injection if it was relied upon in the original implementation.\n", + "\t1. (1/5) The issue of replacing the javax.enterprise import with jakarta.enterprise was not addressed in the updated file. The import was removed entirely, and the @Dependent annotation was also removed without replacement.\n", + "\t2. (3/5) The updated file is syntactically valid and can be compiled. However, there are some changes that alter the original functionality. The Serializable interface implementation was removed, and the @ToString annotation was added, which changes the toString() method behavior. The initialization of shoppingCartItemList was moved to the constructor, which is a minor change in behavior.\n", "* gpt-3\n", - "\t1. The issue of replacing the import statement was not addressed correctly. The import should have been changed to 'jakarta.enterprise', but it remains 'javax.enterprise'.\n", - "\t2. The updated file is syntactically valid and can be compiled. All classes and interfaces used are properly imported. The fixes do not change the original functionality.\n", - "\t3. The file is mostly suitable for Quarkus, with the change from @Dependent to @ApplicationScoped being appropriate. However, the javax import should have been updated to jakarta for full Quarkus compatibility.\n", + "\t1. (0/5) The original issue of replacing the javax.enterprise import with jakarta.enterprise has not been addressed in the updated file. Instead, the import and @Dependent annotation have been removed entirely.\n", + "\t2. (4/5) The updated file is syntactically valid and can be compiled. The changes made do not appear to alter the original functionality. The use of @RegisterForReflection is appropriate for Quarkus, and the diamond operator (<>) is used in ArrayList instantiations, which is a modern Java practice. However, the removal of Serializable interface implementation without a clear reason for doing so might be considered a minor issue.\n", "* gpt-4\n", - "\t1. The issue of replacing the javax.enterprise import with jakarta.enterprise has been correctly addressed in the updated file.\n", - "\t2. The updated file is syntactically valid and can be compiled. All necessary imports are present, and the changes do not alter the original functionality of the class.\n", - "\t3. The updated file is fully compatible with Quarkus. The change from javax to jakarta namespace is the primary adaptation needed for Quarkus compatibility in this file, and it has been correctly implemented without introducing any new issues.\n" + "\t1. (0/5) The issue identified in the JavaEE file has not been fixed in the updated file. The import statement for javax.enterprise.context.Dependent remains unchanged, while it should have been replaced with jakarta.enterprise.context.Dependent.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All classes, interfaces, and annotations used in the file are valid and imported correctly. The original functionality remains unchanged. There are no general syntactical issues in the updated file.\n" ] } ], @@ -765,7 +764,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "If you look at the reasoning our evaluation model produced for each output, and compare that with the actual generated file, we can see that the scores rightly (somewhat) reflect the idea of \"accuracy\" of a certain fix. One important point to note here is that since this file only contained one issue, the evaluation output is pretty much binary (remember, we have the highest weight on metric 1 i.e. whether the issue is fixed or not). This won't be the case for more harder cases further ahead.\n", + "If you look at the reasoning our evaluation model produced for each output, and compare that with the actual generated file, we can see that the scores rightly (somewhat) reflect the idea of \"accuracy\" of a certain fix. One thing to note here is that since there is only one issue, the evaluation output is going to be pretty much binary. This won't be the case with harder example ahead. Therefore, comparing evaluation of easy example with the hard isn't much helpful.\n", "\n", "> Note that absolute rating numbers don't matter much. We are more interested in looking at how a model does relatively in different scenarios. Finally, we will be looking at the trend of how things improved as Kai added more and more contextual information to the prompt." ] @@ -774,7 +773,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Hard example\n", + "### Hard example (Zero Shot)\n", "\n", "Now we will run the same experiment with a harder example. The fix for this file involves more than just changing an import.\n", "\n", @@ -783,7 +782,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -822,7 +821,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 75, "metadata": {}, "outputs": [], "source": [ @@ -838,12 +837,12 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 76, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABNiElEQVR4nO3de7xWY/4//vfutKvdgUpROlAoOkg5VEwNRtPkkGGGHDpojKGkMRmaGYSZiSFkJMahDHKINBiNiakooZBhohHlMN/kvDtgd9jr94df98fd7rjbrbt2z+fjcT9m1rWutdZ73a577fZrX2vdeUmSJAEAAAAAKaqQ6wIAAAAA2PkIpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQCAMpeXlxfDhw/PybGnTZsWeXl5MW3atJwcv7xYtGhR5OXlxXXXXZfrUraZ0o7Tte/NuHHjyrwmANiZCKUAoJwaN25c5OXlbfD1wgsv5LrErXLLLbdsd6FAcXFx/PWvf41DDz006tSpEzVr1ox99903+vTps8O/39vKd8fpjBkzSqxPkiQaN24ceXl5ceyxx+agQgBgW6mU6wIAgG3ryiuvjL322qtEe4sWLXJQTdm55ZZbol69etGvX7+s9u9973vx9ddfR5UqVVKvafDgwTF69Og44YQT4vTTT49KlSrF/PnzY/LkybH33nvHYYcdlnpNO4qqVavG+PHj4/DDD89qnz59enz44YeRn5+fo8oAgG1FKAUA5VyPHj2iY8eOuS4jNRUqVIiqVaumftwlS5bELbfcEmeffXb85S9/yVp34403xieffJJaLatXr47i4uKcBHOl9aMf/SgmTJgQN910U1Sq9H//RB0/fnx06NAhPv300xxWBwBsC27fA4Cd2KpVq6JOnTrRv3//EuuWLl0aVatWjaFDh0ZExMqVK+Oyyy6LDh06RO3ataOgoCCOOOKImDp16iaP069fv2jWrFmJ9uHDh0deXl5W29ixY+PII4+M+vXrR35+fuy///4xZsyYrD7NmjWL//znPzF9+vTMrV/dunWLiA0/U2rChAnRoUOHqFatWtSrVy/OOOOM+N///leizho1asT//ve/6NWrV9SoUSN22223GDp0aKxZs2aj57hw4cJIkiS6dOlSYl1eXl7Ur18/q+3LL7+MX/7yl9GsWbPIz8+PPffcM/r06ZMVvnz88ccxYMCAaNCgQVStWjXatWsXd999d9Z+vvvspxtvvDGaN28e+fn5MW/evIiIeOutt+Lkk0+OOnXqRNWqVaNjx47x2GOPbfRc1nXDDTdE06ZNo1q1atG1a9d44403MuvGjh0beXl58eqrr5bY7o9//GNUrFixxPu8Pr17947PPvsspkyZkmlbuXJlPPzww3Haaaetd5sVK1bEr371q2jcuHHk5+fHfvvtF9ddd10kSZLVr6ioKH75y1/GbrvtFjVr1ozjjz8+Pvzww/Xu83//+1+cddZZ0aBBg8jPz48DDjgg7rrrrk3WDwBsOTOlAKCcKywsLDHLJC8vL+rWrRuVK1eOE088MSZOnBi33XZb1syaSZMmRVFRUZx66qkR8W1Idccdd0Tv3r3j7LPPjmXLlsWdd94Z3bt3j5deeikOPPDAMql3zJgxccABB8Txxx8flSpViscffzzOO++8KC4ujoEDB0bEtzOPzj///KhRo0b89re/jYiIBg0abHCf48aNi/79+8fBBx8cI0aMiCVLlsSoUaNi5syZ8eqrr8Yuu+yS6btmzZro3r17HHrooXHdddfF008/HSNHjozmzZvHueeeu8FjNG3aNCK+Db9+8pOfRPXq1TfYd/ny5XHEEUfEm2++GWeddVYcdNBB8emnn8Zjjz0WH374YdSrVy++/vrr6NatWyxYsCAGDRoUe+21V0yYMCH69esXX375ZVxwwQVZ+xw7dmx888038fOf/zzy8/OjTp068Z///Ce6dOkSjRo1iksuuSQKCgrioYceil69esUjjzwSJ5544ib/e/z1r3+NZcuWxcCBA+Obb76JUaNGxZFHHhmvv/56NGjQIE4++eQYOHBg3HfffdG+ffusbe+7777o1q1bNGrUaJPHadasWXTq1Cnuv//+6NGjR0RETJ48OQoLC+PUU0+Nm266Kat/kiRx/PHHx9SpU2PAgAFx4IEHxlNPPRUXXXRR/O9//4sbbrgh0/dnP/tZ3HvvvXHaaadF586d41//+lf07NmzRA1LliyJww47LPLy8mLQoEGx2267xeTJk2PAgAGxdOnSGDJkyCbPAwDYAgkAUC6NHTs2iYj1vvLz8zP9nnrqqSQikscffzxr+x/96EfJ3nvvnVlevXp1UlRUlNXniy++SBo0aJCcddZZWe0RkVx++eWZ5b59+yZNmzYtUePll1+erPvPka+++qpEv+7du2fVkiRJcsABByRdu3Yt0Xfq1KlJRCRTp05NkiRJVq5cmdSvXz9p3bp18vXXX2f6PfHEE0lEJJdddllWnRGRXHnllVn7bN++fdKhQ4cSx1pXnz59kohIdt111+TEE09MrrvuuuTNN98s0e+yyy5LIiKZOHFiiXXFxcVJkiTJjTfemEREcu+992bWrVy5MunUqVNSo0aNZOnSpUmSJMnChQuTiEhq1aqVfPzxx1n7Ouqoo5I2bdok33zzTdb+O3funOyzzz4bPZe1+61WrVry4YcfZtpffPHFJCKSX/7yl5m23r17Jw0bNkzWrFmTaXvllVeSiEjGjh270eOsHaezZ89Obr755qRmzZqZMfCTn/wk+f73v58kSZI0bdo06dmzZ2a7SZMmJRGR/P73v8/a38knn5zk5eUlCxYsSJIkSebOnZtERHLeeedl9TvttNNKjNMBAwYke+yxR/Lpp59m9T311FOT2rVrZ+pa+95s6twAgI1z+x4AlHOjR4+OKVOmZL0mT56cWX/kkUdGvXr14sEHH8y0ffHFFzFlypQ45ZRTMm0VK1bMzKQqLi6Ozz//PFavXh0dO3aMV155pczqrVatWub/r53l1bVr13j33XejsLBwi/c3Z86c+Pjjj+O8887LetZUz549o2XLlvH3v/+9xDa/+MUvspaPOOKIePfddzd5rLFjx8bNN98ce+21Vzz66KMxdOjQaNWqVRx11FFZt7A98sgj0a5du/XOVFp7O+OTTz4Zu+++e/Tu3TuzrnLlyjF48OBYvnx5TJ8+PWu7k046KXbbbbfM8ueffx7/+te/4qc//WksW7YsPv300/j000/js88+i+7du8fbb7+9WbfV9erVK2um0yGHHBKHHnpoPPnkk5m2Pn36xP/7f/8v61bO++67L6pVqxYnnXTSJo+x1k9/+tP4+uuv44knnohly5bFE088scFb95588smoWLFiDB48OKv9V7/6VSRJkhnja+tct9+6s56SJIlHHnkkjjvuuEiSJPN+ffrpp9G9e/coLCws03EOALh9DwDKvUMOOWSjDzqvVKlSnHTSSTF+/PgoKiqK/Pz8mDhxYqxatSorlIqIuPvuu2PkyJHx1ltvxapVqzLt6/t2v9KaOXNmXH755TFr1qz46quvstYVFhZG7dq1t2h/7733XkRE7LfffiXWtWzZMmbMmJHVVrVq1axwJyJi1113jS+++GKTx6pQoUIMHDgwBg4cGJ999lnMnDkzbr311pg8eXKceuqp8dxzz0VExDvvvLPJsOa9996LffbZJypUyP4bYqtWrbLOa611/xssWLAgkiSJSy+9NC699NL1HuPjjz/e5K11++yzT4m2fffdNx566KHM8g9+8IPYY4894r777oujjjoqiouL4/77748TTjghatasudH9f9duu+0WRx99dIwfPz6++uqrWLNmTZx88snr7fvee+9Fw4YNS+x/3ffnvffeiwoVKkTz5s2z+q07Hj755JP48ssv4y9/+UuJB9Wv9fHHH2/2uQAAmyaUAgDi1FNPjdtuuy0mT54cvXr1ioceeihatmwZ7dq1y/S59957o1+/ftGrV6+46KKLon79+lGxYsUYMWJEvPPOOxvd/7oPM19r3YeHv/POO3HUUUdFy5Yt4/rrr4/GjRtHlSpV4sknn4wbbrghiouLt/5kN6FixYplsp+6devG8ccfH8cff3x069Ytpk+fHu+9917m2VNl7bszzCIi814NHTo0unfvvt5tWrRoUSbHrlixYpx22mlx++23xy233BIzZ86M//f//l+cccYZW7yv0047Lc4+++z46KOPokePHlnP+9qW1r5fZ5xxRvTt23e9fdq2bZtKLQCwsxBKAQDxve99L/bYY4948MEH4/DDD49//etfmQeIr/Xwww/H3nvvHRMnTswKmS6//PJN7n/XXXeNL7/8skT7urN9Hn/88SgqKorHHnssmjRpkmlf3zf8bSjoWtfaEGj+/Plx5JFHZq2bP3/+NguJvqtjx44xffr0WLx4cTRt2jSaN2+e9Q1269O0adP497//HcXFxVmzpd56663M+o3Ze++9I+LbW/6OPvroUtf+9ttvl2j773//W+LbFPv06RMjR46Mxx9/PCZPnhy77bbbBsOwjTnxxBPjnHPOiRdeeCHrltJ1NW3aNJ5++ulYtmxZ1mypdd+fpk2bRnFxcbzzzjtZs6Pmz5+ftb+138y3Zs2arXq/AIDN55lSAEBUqFAhTj755Hj88cfjnnvuidWrV5e4dW/tDKIkSTJtL774YsyaNWuT+2/evHkUFhbGv//970zb4sWL49FHH93kMQoLC2Ps2LEl9llQULDeoGtdHTt2jPr168ett94aRUVFmfbJkyfHm2++ud5vYSuNjz76KObNm1eifeXKlfHMM89EhQoVMjOTTjrppHjttddKnH/E/537j370o/joo4+ygpnVq1fHn//856hRo0Z07dp1o/XUr18/unXrFrfddlssXry4xPpPPvlks85r0qRJWc+eeumll+LFF1/MfEPeWm3bto22bdvGHXfcEY888kiceuqpUanSlv/9s0aNGjFmzJgYPnx4HHfccRvs96Mf/SjWrFkTN998c1b7DTfcEHl5eZn61v7vut/ed+ONN2YtV6xYMU466aR45JFH1hsYbu77BQBsPjOlAKCcmzx5cmb2yHd17tw5M5smIuKUU06JP//5z3H55ZdHmzZtMs/mWevYY4+NiRMnxoknnhg9e/aMhQsXxq233hr7779/LF++fKM1nHrqqXHxxRfHiSeeGIMHD46vvvoqxowZE/vuu2/Ww6OPOeaYqFKlShx33HFxzjnnxPLly+P222+P+vXrlwhWOnToEGPGjInf//730aJFi6hfv36JmVAR384Uuuaaa6J///7RtWvX6N27dyxZsiRGjRoVzZo1i1/+8peb9T5uyocffhiHHHJIHHnkkXHUUUfF7rvvHh9//HHcf//98dprr8WQIUOiXr16ERFx0UUXxcMPPxw/+clP4qyzzooOHTrE559/Ho899ljceuut0a5du/j5z38et912W/Tr1y9efvnlaNasWTz88MMxc+bMuPHGGzfrWU2jR4+Oww8/PNq0aRNnn3127L333rFkyZKYNWtWfPjhh/Haa69tch8tWrSIww8/PM4999woKiqKG2+8MerWrRu//vWvS/Tt06dPDB06NCKiVLfurbWh2+e+67jjjovvf//78dvf/jYWLVoU7dq1i3/+85/xt7/9LYYMGZJ5htSBBx4YvXv3jltuuSUKCwujc+fO8cwzz8SCBQtK7PPqq6+OqVOnxqGHHhpnn3127L///vH555/HK6+8Ek8//XR8/vnnpT4nAGA9cvjNfwDANjR27NgkIjb4Wvfr7IuLi5PGjRsnEZH8/ve/L7G/4uLi5I9//GPStGnTJD8/P2nfvn3yxBNPJH379k2aNm2a1Tcikssvvzyr7Z///GfSunXrpEqVKsl+++2X3Hvvvcnll1+erPvPkcceeyxp27ZtUrVq1aRZs2bJNddck9x1111JRCQLFy7M9Pvoo4+Snj17JjVr1kwiIunatWuSJEkyderUJCKSqVOnZu33wQcfTNq3b5/k5+cnderUSU4//fTkww8/zOrTt2/fpKCgoMS5r6/OdS1dujQZNWpU0r1792TPPfdMKleunNSsWTPp1KlTcvvttyfFxcVZ/T/77LNk0KBBSaNGjZIqVaoke+65Z9K3b9/k008/zfRZsmRJ0r9//6RevXpJlSpVkjZt2pT477Zw4cIkIpJrr712vXW98847SZ8+fZLdd989qVy5ctKoUaPk2GOPTR5++OGNns939zty5MikcePGSX5+fnLEEUckr7322nq3Wbx4cVKxYsVk33333ei+v2vtOJ09e/ZG+zVt2jTp2bNnVtuyZcuSX/7yl0nDhg2TypUrJ/vss09y7bXXlnivv/7662Tw4MFJ3bp1k4KCguS4445LPvjgg/WO0yVLliQDBw5MGjdunFSuXDnZfffdk6OOOir5y1/+UuK9Wfe/BQCwZfKS5Dvz4wEAoJQ+/fTT2GOPPeKyyy7b4Df+AQCs5ZlSAACUiXHjxsWaNWvizDPPzHUpAMAOwDOlAADYKv/6179i3rx58Yc//CF69epV4pv5AADWx+17AABslW7dusXzzz8fXbp0iXvvvTcaNWqU65IAgB1ATm/fGz58eOTl5WW9WrZsmcuSAADYQtOmTYuVK1fG1KlTBVIAwGbL+e17BxxwQDz99NOZ5UqVcl4SAAAAANtYzhOgSpUqxe67757rMgAAAABIUc5DqbfffjsaNmwYVatWjU6dOsWIESOiSZMm6+1bVFQURUVFmeXi4uL4/PPPo27dupGXl5dWyQAAAABsQJIksWzZsmjYsGFUqLDhJ0fl9EHnkydPjuXLl8d+++0XixcvjiuuuCL+97//xRtvvBE1a9Ys0X/48OFxxRVX5KBSAAAAALbEBx98EHvuuecG129X37735ZdfRtOmTeP666+PAQMGlFi/7kypwsLCaNKkSXzwwQdRq1atNEsFAAAAYD2WLl0ajRs3ji+//DJq1669wX45v33vu3bZZZfYd999Y8GCBetdn5+fH/n5+SXaa9WqJZQCAAAA2I5s6lFLG76xLweWL18e77zzTuyxxx65LgUAAACAbSinodTQoUNj+vTpsWjRonj++efjxBNPjIoVK0bv3r1zWRYAAAAA21hOb9/78MMPo3fv3vHZZ5/FbrvtFocffni88MILsdtuu+WyLAAAAAC2sZyGUg888EAuDw8AAABAjmxXz5QCAAAAYOcglAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgddtNKHX11VdHXl5eDBkyJNelAAAAALCNbReh1OzZs+O2226Ltm3b5roUAAAAAFKQ81Bq+fLlcfrpp8ftt98eu+66a67LAQAAACAFOQ+lBg4cGD179oyjjz56k32Liopi6dKlWS8AAAAAdjyVcnnwBx54IF555ZWYPXv2ZvUfMWJEXHHFFdu4KgAAAAC2tZzNlPrggw/iggsuiPvuuy+qVq26WdsMGzYsCgsLM68PPvhgG1cJAAAAwLaQlyRJkosDT5o0KU488cSoWLFipm3NmjWRl5cXFSpUiKKioqx167N06dKoXbt2FBYWRq1atbZ1yQAAAABswubmNTm7fe+oo46K119/Pautf//+0bJly7j44os3GUgBAAAAsOPKWShVs2bNaN26dVZbQUFB1K1bt0Q7AAAAAOVLzr99DwAAAICdT06/fW9d06ZNy3UJAAAAAKTATCkAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgBghzdmzJho27Zt1KpVK2rVqhWdOnWKyZMnb3SbCRMmRMuWLaNq1arRpk2bePLJJ1OqFgCIEEoBAFAO7LnnnnH11VfHyy+/HHPmzIkjjzwyTjjhhPjPf/6z3v7PP/989O7dOwYMGBCvvvpq9OrVK3r16hVvvPFGypUDwM4rL0mSJNdFlNbSpUujdu3aUVhYGLVq1cp1OQAAbEfq1KkT1157bQwYMKDEulNOOSVWrFgRTzzxRKbtsMMOiwMPPDBuvfXWNMsEgHJnc/MaM6UAAChX1qxZEw888ECsWLEiOnXqtN4+s2bNiqOPPjqrrXv37jFr1qw0SgQAIqJSrgsAAICy8Prrr0enTp3im2++iRo1asSjjz4a+++//3r7fvTRR9GgQYOstgYNGsRHH32URqkAQJgpBQBAObHffvvF3Llz48UXX4xzzz03+vbtG/Pmzct1WQDABpgpBQBAuVClSpVo0aJFRER06NAhZs+eHaNGjYrbbrutRN/dd989lixZktW2ZMmS2H333VOpFQAwUwoAgHKquLg4ioqK1ruuU6dO8cwzz2S1TZkyZYPPoAIAyp6ZUgAA7PCGDRsWPXr0iCZNmsSyZcti/PjxMW3atHjqqaciIqJPnz7RqFGjGDFiREREXHDBBdG1a9cYOXJk9OzZMx544IGYM2dO/OUvf8nlaQDATkUoBQDADu/jjz+OPn36xOLFi6N27drRtm3beOqpp+IHP/hBRES8//77UaHC/90k0Llz5xg/fnz87ne/i9/85jexzz77xKRJk6J169a5OgUA2OnkJUmS5LqI0lq6dGnUrl07CgsLo1atWrkuBwAAAGCnt7l5jWdKAQAAAJA6oRQAAAAAqctpKDVmzJho27Zt1KpVK2rVqhWdOnWKyZMn57IkAAAAAFKQ01Bqzz33jKuvvjpefvnlmDNnThx55JFxwgknxH/+859clgUAAADANrbdPei8Tp06ce2118aAAQM22deDzgEAAAC2L5ub11RKsaaNWrNmTUyYMCFWrFgRnTp1Wm+foqKiKCoqyiwvXbo0rfIAAAAAKEM5D6Vef/316NSpU3zzzTdRo0aNePTRR2P//fdfb98RI0bEFVdckXKFAAA7lmaX/D3XJbADWnR1z1yXAMBOJuffvrfffvvF3Llz48UXX4xzzz03+vbtG/PmzVtv32HDhkVhYWHm9cEHH6RcLQAAAABlIeczpapUqRItWrSIiIgOHTrE7NmzY9SoUXHbbbeV6Jufnx/5+flplwgAAABAGcv5TKl1FRcXZz03CgAAAIDyJ6czpYYNGxY9evSIJk2axLJly2L8+PExbdq0eOqpp3JZFgAAAADbWE5DqY8//jj69OkTixcvjtq1a0fbtm3jqaeeih/84Ae5LAsAAACAbSynodSdd96Zy8MDAAAAkCPb3TOlAAAAACj/hFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBbCVRowYEQcffHDUrFkz6tevH7169Yr58+dvdJtu3bpFXl5eiVfPnj1TqhoAACC3hFIAW2n69OkxcODAeOGFF2LKlCmxatWqOOaYY2LFihUb3GbixImxePHizOuNN96IihUrxk9+8pMUKwcAAMidSrkuAGBH949//CNredy4cVG/fv14+eWX43vf+956t6lTp07W8gMPPBDVq1cXSgEAADsNM6UAylhhYWFElAyeNubOO++MU089NQoKCrZVWQAAANsVM6UAylBxcXEMGTIkunTpEq1bt96sbV566aV444034s4779zG1QEAAGw/hFIAZWjgwIHxxhtvxIwZMzZ7mzvvvDPatGkThxxyyDasDAAAYPvi9j2AMjJo0KB44oknYurUqbHnnntu1jYrVqyIBx54IAYMGLCNqwMAANi+mCkFsJWSJInzzz8/Hn300Zg2bVrstddem73thAkToqioKM4444xtWCEAAMD2x0wpgK00cODAuPfee2P8+PFRs2bN+Oijj+Kjjz6Kr7/+OtOnT58+MWzYsBLb3nnnndGrV6+oW7dumiUDAADknJlSAFtpzJgxERHRrVu3rPaxY8dGv379IiLi/fffjwoVsv8OMH/+/JgxY0b885//TKNMAACA7YpQCmArJUmyyT7Tpk0r0bbffvtt1rYAAADlkdv3AAAAAEidUAoAAACA1AmlAAAAAEidUAoAAACA1AmlAAAAAEidUAoAAACA1FXKdQFA+dLskr/nugR2QIuu7pnrEgAAgJSZKQUAAABA6oRSAAAAAKRuq0KplStXxvz582P16tVlVQ8AAAAAO4FShVJfffVVDBgwIKpXrx4HHHBAvP/++xERcf7558fVV19dpgUCAAAAUP6UKpQaNmxYvPbaazFt2rSoWrVqpv3oo4+OBx98sMyKAwAAAKB8KtW3702aNCkefPDBOOywwyIvLy/TfsABB8Q777xTZsUBAAAAUD6VaqbUJ598EvXr1y/RvmLFiqyQCgAAAADWp1ShVMeOHePvf/97ZnltEHXHHXdEp06dyqYyAAAAAMqtUt2+98c//jF69OgR8+bNi9WrV8eoUaNi3rx58fzzz8f06dPLukYAAAAAyplSzZQ6/PDD47XXXovVq1dHmzZt4p///GfUr18/Zs2aFR06dCjrGgEAAAAoZ7Z4ptSqVavinHPOiUsvvTRuv/32bVETAAAAAOXcFs+Uqly5cjzyyCPbohYAAAAAdhKlun2vV69eMWnSpDIuBQAAAICdRakedL7PPvvElVdeGTNnzowOHTpEQUFB1vrBgweXSXEAAAAAlE+lCqXuvPPO2GWXXeLll1+Ol19+OWtdXl6eUAoAAACAjSpVKLVw4cKyrgMAAACAnUipnin1XUmSRJIkZVELAAAAADuJUodSf/3rX6NNmzZRrVq1qFatWrRt2zbuueeesqwNAAAAgHKqVLfvXX/99XHppZfGoEGDokuXLhERMWPGjPjFL34Rn376afzyl78s0yIBAAAAKF9KFUr9+c9/jjFjxkSfPn0ybccff3wccMABMXz4cKEUAAAAABtVqtv3Fi9eHJ07dy7R3rlz51i8ePFWFwUAAABA+VaqUKpFixbx0EMPlWh/8MEHY5999tnqogAAAAAo30p1+94VV1wRp5xySjz77LOZZ0rNnDkznnnmmfWGVQAAAADwXaWaKXXSSSfFiy++GPXq1YtJkybFpEmTol69evHSSy/FiSeeWNY1AgAAlGsjRoyIgw8+OGrWrBn169ePXr16xfz58ze6zcSJE6Njx46xyy67REFBQRx44IG+EZ2cMo7ZUqWaKRUR0aFDh7j33nvLshYAAICd0vTp02PgwIFx8MEHx+rVq+M3v/lNHHPMMTFv3rwoKChY7zZ16tSJ3/72t9GyZcuoUqVKPPHEE9G/f/+oX79+dO/ePeUzAOOYLZeXJEmypRs9+eSTUbFixRID5Kmnnori4uLo0aNHmRW4MUuXLo3atWtHYWFh1KpVK5VjAhvX7JK/57oEdkCLru6Z6xKgXHEtpjRci7cvn3zySdSvXz+mT58e3/ve9zZ7u4MOOih69uwZV1111TasDjaPcbzz2ty8plS3711yySWxZs2aEu1JksQll1xSml0CAADw/yssLIyIb2eRbI4kSeKZZ56J+fPnb9Ev/7AtGcdsSqlu33v77bdj//33L9HesmXLWLBgwVYXBQAAsLMqLi6OIUOGRJcuXaJ169Yb7VtYWBiNGjWKoqKiqFixYtxyyy3xgx/8IKVKYcOMYzZHqUKp2rVrx7vvvhvNmjXLal+wYMEG7xMFAABg0wYOHBhvvPFGzJgxY5N9a9asGXPnzo3ly5fHM888ExdeeGHsvffe0a1bt21fKGyEcczmKFUodcIJJ8SQIUPi0UcfjebNm0fEt4HUr371qzj++OPLtEAAAICdxaBBg+KJJ56IZ599Nvbcc89N9q9QoUK0aNEiIiIOPPDAePPNN2PEiBF+mSenjGM2V6meKfWnP/0pCgoKomXLlrHXXnvFXnvtFS1btoy6devGddddV9Y1AgAAlGtJksSgQYPi0UcfjX/961+x1157lWo/xcXFUVRUVMbVweYxjtlSpb597/nnn48pU6bEa6+9FtWqVYt27drFEUccUdb1AQAAlHsDBw6M8ePHx9/+9reoWbNmfPTRRxHx7e9e1apVi4iIPn36RKNGjWLEiBERETFixIjo2LFjNG/ePIqKiuLJJ5+Me+65J8aMGZOz82DnZhyzpbYolJo1a1Z89tlnceyxx0ZeXl4cc8wxsXjx4rj88svjq6++il69esWf//znyM/P31b1AgAAlDtrfwFf93alsWPHRr9+/SIi4v33348KFf7vZpcVK1bEeeedFx9++GFUq1YtWrZsGffee2+ccsopaZUNWYxjtlRekiTJ5nbu0aNHdOvWLS6++OKIiHj99dejQ4cO0bdv32jVqlVce+21cc4558Tw4cO3Vb1Zli5dGrVr147CwsKoVatWKscENq7ZJX/PdQnsgBZd3TPXJUC54lpMabgWA1BWNjev2aJnSs2dOzeOOuqozPIDDzwQhxxySNx+++1x4YUXxk033RQPPfRQ6asGAAAAYKewRaHUF198EQ0aNMgsT58+PXr06JFZPvjgg+ODDz4ou+oAAAAAKJe2KJRq0KBBLFy4MCIiVq5cGa+88kocdthhmfXLli2LypUrl22FAAAAAJQ7WxRK/ehHP4pLLrkknnvuuRg2bFhUr1496xv3/v3vf0fz5s3LvEgAAAAAypct+va9q666Kn784x9H165do0aNGnH33XdHlSpVMuvvuuuuOOaYY8q8SAAAAADKly0KperVqxfPPvtsFBYWRo0aNaJixYpZ6ydMmBA1atQo0wIBAAAAKH+2KJRaq3bt2uttr1OnzlYVAwAA0OySv+e6BHZAi67umesSshjHlMb2No63tS16phQAAAAAlAWhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpy2koNWLEiDj44IOjZs2aUb9+/ejVq1fMnz8/lyUBAAAAkIKchlLTp0+PgQMHxgsvvBBTpkyJVatWxTHHHBMrVqzIZVkAAAAAbGOVcnnwf/zjH1nL48aNi/r168fLL78c3/ve93JUFQAAAADb2nb1TKnCwsKIiKhTp06OKwEAAABgW8rpTKnvKi4ujiFDhkSXLl2idevW6+1TVFQURUVFmeWlS5emVR4AAAAAZWi7mSk1cODAeOONN+KBBx7YYJ8RI0ZE7dq1M6/GjRunWCEAAAAAZWW7CKUGDRoUTzzxREydOjX23HPPDfYbNmxYFBYWZl4ffPBBilUCAAAAUFZyevtekiRx/vnnx6OPPhrTpk2Lvfbaa6P98/PzIz8/P6XqAAAAANhWchpKDRw4MMaPHx9/+9vfombNmvHRRx9FRETt2rWjWrVquSwNAAAAgG0op7fvjRkzJgoLC6Nbt26xxx57ZF4PPvhgLssCAAAAYBvL+e17AAAAAOx8tosHnQMAAACwcxFKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKkXPPPvtsHHfccdGwYcPIy8uLSZMmbbT/jBkzokuXLlG3bt2oVq1atGzZMm644YZ0igUop1yLAQBIW6VcFwArVqyIdu3axVlnnRU//vGPN9m/oKAgBg0aFG3bto2CgoKYMWNGnHPOOVFQUBA///nPU6gYoPxxLQYAIG1CKXKuR48e0aNHj83u3759+2jfvn1muVmzZjFx4sR47rnn/CIEUEquxQAApM3te+zwXn311Xj++eeja9euuS4FYKflWgwAwJYyU4od1p577hmffPJJrF69OoYPHx4/+9nPcl0SwE7HtRgAgNISSrHDeu6552L58uXxwgsvxCWXXBItWrSI3r1757osgJ2KazEAAKUllGKHtddee0VERJs2bWLJkiUxfPhwvwgBpMy1GACA0vJMKcqF4uLiKCoqynUZADs112IAALaEmVLk3PLly2PBggWZ5YULF8bcuXOjTp060aRJkxg2bFj873//i7/+9a8RETF69Oho0qRJtGzZMiIinn322bjuuuti8ODBOakfoDxwLQYAIG1CKXJuzpw58f3vfz+zfOGFF0ZERN++fWPcuHGxePHieP/99zPri4uLY9iwYbFw4cKoVKlSNG/ePK655po455xzUq8doLxwLQYAIG15SZIkuS6itJYuXRq1a9eOwsLCqFWrVq7LASKi2SV/z3UJ7IAWXd0z1yVAueJaTGlsT9diY5jS2J7GcIRxTOlsb+O4tDY3r/FMKQAAAABSJ5QCAAAAIHVCKQAAAABSJ5QCAAAAIHVCKQAAAABSJ5QCAAAAIHVCKQAAAABSVynXBZCt2SV/z3UJ7IAWXd0z1yVAueE6TGm4DgMAbDkzpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNTlNJR69tln47jjjouGDRtGXl5eTJo0KZflAAAAAJCSnIZSK1asiHbt2sXo0aNzWQYAAAAAKauUy4P36NEjevTokcsSAAAAAMgBz5QCAAAAIHU5nSm1pYqKiqKoqCizvHTp0hxWAwAAAEBp7VAzpUaMGBG1a9fOvBo3bpzrkgAAAAAohR0qlBo2bFgUFhZmXh988EGuSwIAAACgFHao2/fy8/MjPz8/12UAAAAAsJVyGkotX748FixYkFleuHBhzJ07N+rUqRNNmjTJYWUAAAAAbEs5DaXmzJkT3//+9zPLF154YURE9O3bN8aNG5ejqgAAAADY1nIaSnXr1i2SJMllCQAAAADkwA71oHMAAAAAygehFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACp2y5CqdGjR0ezZs2iatWqceihh8ZLL72U65IAAAAA2IZyHko9+OCDceGFF8bll18er7zySrRr1y66d+8eH3/8ca5LAwAAAGAbyXkodf3118fZZ58d/fv3j/333z9uvfXWqF69etx11125Lg0AAACAbSSnodTKlSvj5ZdfjqOPPjrTVqFChTj66KNj1qxZOawMAAAAgG2pUi4P/umnn8aaNWuiQYMGWe0NGjSIt956q0T/oqKiKCoqyiwXFhZGRMTSpUu3baEpKi76KtclsAPanj4DxjClYQyzo9uexnCEcUzpbE/j2BimNLanMRxhHFM629s4Lq2155EkyUb75TSU2lIjRoyIK664okR748aNc1ANbD9q35jrCmDrGMPs6IxhygPjmB2dMUx5UN7G8bJly6J27dobXJ/TUKpevXpRsWLFWLJkSVb7kiVLYvfddy/Rf9iwYXHhhRdmlouLi+Pzzz+PunXrRl5e3javl9xZunRpNG7cOD744IOoVatWrsuBLWYMs6MzhikPjGN2dMYw5YFxvHNIkiSWLVsWDRs23Gi/nIZSVapUiQ4dOsQzzzwTvXr1iohvg6ZnnnkmBg0aVKJ/fn5+5OfnZ7XtsssuKVTK9qJWrVouXOzQjGF2dMYw5YFxzI7OGKY8MI7Lv43NkFor57fvXXjhhdG3b9/o2LFjHHLIIXHjjTfGihUron///rkuDQAAAIBtJOeh1CmnnBKffPJJXHbZZfHRRx/FgQceGP/4xz9KPPwcAAAAgPIj56FURMSgQYPWe7serJWfnx+XX355ids3YUdhDLOjM4YpD4xjdnTGMOWBccx35SWb+n4+AAAAAChjFXJdAAAAAAA7H6EUAAAAAKkTSpGqbt26xZAhQzLLzZo1ixtvvDFn9aRh3XNmx7czjuOd4Ry3F98dXzvT+96vX7/o1atXrstgBzRt2rTIy8uLL7/8cqc8PgDsyIRSbNLOGqp888030a9fv2jTpk1UqlRpvb8szZgxI7p06RJ169aNatWqRcuWLeOGG25Iv1g2aWcdx8OHD4+8vLwSr4KCgqx+EyZMiJYtW0bVqlWjTZs28eSTT+aoYiZOnBhXXXVVrstI3ahRo2LcuHGZ5Z31M8uW69y5cyxevDhq1669Wf0XLVoUeXl5MXfu3G1bGGwjeXl5MWnSpE32mzhxYnTs2DF22WWXKCgoiAMPPDDuueeebV8gbIbNHcff9cADD0ReXp4/YpUz28W378H2aM2aNVGtWrUYPHhwPPLII+vtU1BQEIMGDYq2bdtGQUFBzJgxI84555woKCiIn//85ylXDCUNHTo0fvGLX2S1HXXUUXHwwQdnlp9//vno3bt3jBgxIo499tgYP3589OrVK1555ZVo3bp12iXv9OrUqZPrEjbbypUro0qVKmWyr80NFGBdVapUid13373M91uW4xtyoU6dOvHb3/42WrZsGVWqVIknnngi+vfvH/Xr14/u3bvnujzYIosWLYqhQ4fGEUccketSKGNmSpUz3bp1i/PPPz+GDBkSu+66azRo0CBuv/32WLFiRfTv3z9q1qwZLVq0iMmTJ2e2eeONN6JHjx5Ro0aNaNCgQZx55pnx6aefRsS3t1NMnz49Ro0alZlhsWjRolizZk0MGDAg9tprr6hWrVrst99+MWrUqK2u//rrr482bdpEQUFBNG7cOM4777xYvnx5Zv24ceNil112iSeeeCL222+/qF69epx88snx1Vdfxd133x3NmjWLXXfdNQYPHhxr1qzJbHfPPfdEx44do2bNmrH77rvHaaedFh9//PFGaykoKIgxY8bE2WefvcF/7LZv3z569+4dBxxwQDRr1izOOOOM6N69ezz33HNZ/VavXh2DBg2K2rVrR7169eLSSy8NX3y5YcZx2Y3jGjVqxO677555LVmyJObNmxcDBgzI9Bk1alT88Ic/jIsuuihatWoVV111VRx00EFx8803Z+1r2bJl0bt37ygoKIhGjRrF6NGjt/q9oqR1Zwht6n3Py8uL2267LY499tioXr16tGrVKmbNmhULFiyIbt26RUFBQXTu3DneeeedjR539erVMXjw4Nhll12ibt26cfHFF0ffvn2z/hrZrVu3GDRoUAwZMiTq1auX+aVmc8f8U089Fa1atYoaNWrED3/4w1i8eHGmz3dv39vQZzZi4591yoct/Rmw7u1zZ511VrRt2zaKiooi4ttwqX379tGnT5+IiNhrr70i4tuf4Xl5edGtW7eI+L8x+Ic//CEaNmwY++23X0SU7toLG7Js2bI4/fTTo6CgIPbYY4+44YYbSty2fdVVV23wut+sWbOIiDjxxBMjLy8vs7w+3bp1ixNPPDFatWoVzZs3jwsuuCDatm0bM2bM2IZnyM4gzXEc8e1kgdNPPz2uuOKK2HvvvbfRWZErQqly6O6774569erFSy+9FOeff36ce+658ZOf/CQ6d+4cr7zyShxzzDFx5plnxldffRVffvllHHnkkdG+ffuYM2dO/OMf/4glS5bET3/604j49pfVTp06xdlnnx2LFy+OxYsXR+PGjaO4uDj23HPPmDBhQsybNy8uu+yy+M1vfhMPPfTQVtVeoUKFuOmmm+I///lP3H333fGvf/0rfv3rX2f1+eqrr+Kmm26KBx54IP7xj3/EtGnT4sQTT4wnn3wynnzyybjnnnvitttui4cffjizzapVq+Kqq66K1157LSZNmhSLFi2Kfv36bVWt6/Pqq6/G888/H127ds1qv/vuu6NSpUrx0ksvxahRo+L666+PO+64o8yPX54Yx9tmHN9xxx2x7777Zv2VadasWXH00Udn9evevXvMmjUrq+3aa6+Ndu3axauvvhqXXHJJXHDBBTFlypQtOj5bbnPe96uuuir69OkTc+fOjZYtW8Zpp50W55xzTgwbNizmzJkTSZLEoEGDNnqca665Ju67774YO3ZszJw5M5YuXbreafV33313VKlSJWbOnBm33nprRGz+mL/uuuvinnvuiWeffTbef//9GDp06Hpr2dBndlOfdcqPLfkZsK6bbropVqxYEZdccklERPz2t7+NL7/8MhO0v/TSSxER8fTTT8fixYtj4sSJmW2feeaZmD9/fkyZMiWeeOKJiEjv3xDsHC688MKYOXNmPPbYYzFlypR47rnn4pVXXsnqs7Hr/uzZsyMiYuzYsbF48eLM8qYkSZIZ39/73vfK9qTY6aQ9jq+88sqoX79+1h9VKUcSypWuXbsmhx9+eGZ59erVSUFBQXLmmWdm2hYvXpxERDJr1qzkqquuSo455pisfXzwwQdJRCTz58/P7POCCy7Y5LEHDhyYnHTSSZus77v7atq0aXLDDTdssP+ECROSunXrZpbHjh2bRESyYMGCTNs555yTVK9ePVm2bFmmrXv37sk555yzwf3Onj07iYisbTamb9++yQknnLDB9Y0aNUqqVKmSVKhQIbnyyiuz1nXt2jVp1apVUlxcnGm7+OKLk1atWm3WsXdGxvG3ynocf/3118muu+6aXHPNNVntlStXTsaPH5/VNnr06KR+/fqZ5aZNmyY//OEPs/qccsopSY8ePTbr2Gy+746vzXnfIyL53e9+l1meNWtWEhHJnXfemWm7//77k6pVq270uA0aNEiuvfbazPLq1auTJk2aZF37unbtmrRv336T57A5Y3706NFJgwYNMsvrXmfX95ndnM86O74t/RkwderUJCKSL774IrP++eefTypXrpxceumlSaVKlZLnnnsus27hwoVJRCSvvvpq1nH79u2bNGjQICkqKtpofetee9d3fFifpUuXJpUrV04mTJiQafvyyy+T6tWrb/F1/9FHH92sY3755ZdJQUFBUqlSpSQ/Pz/rZwOURtrj+LnnnksaNWqUfPLJJ0mSbPr3MnY8ZkqVQ23bts38/4oVK0bdunWjTZs2mbYGDRpERMTHH38cr732WkydOjVq1KiRebVs2TIiYpO3eowePTo6dOgQu+22W9SoUSP+8pe/xPvvvx8REc8991zWPu+7777Nqv3pp5+Oo446Kho1ahQ1a9aMM888Mz777LOsv4RWr149mjdvnnU+zZo1ixo1amS1fXdq/csvvxzHHXdcNGnSJGrWrJmZybS23gMOOCBTa48ePTar1u967rnnYs6cOXHrrbfGjTfeGPfff3/W+sMOOyzy8vIyy506dYq3334769YsshnHZT+OH3300Vi2bFn07dt3s85jXZ06dSqx/Oabb5ZqX2y+zXnfv/t5WfvZWPfz8s0338TSpUvj/fffzxrXf/zjH6OwsDCWLFkShxxySGabihUrRocOHUrUs7620oz5PfbYY4tvgdqazzo7li35GbA+nTp1iqFDh8ZVV10Vv/rVr+Lwww/frOO2adOmxHOkNnXthc317rvvxqpVq7KutbVr187cKrrWlv68Xd91fa2aNWvG3LlzY/bs2fGHP/whLrzwwpg2bVrZnBA7pTTH8bJly+LMM8+M22+/PerVq1e2J8J2w4POy6HKlStnLefl5WW1rQ1HiouLY/ny5XHcccfFNddcU2I/e+yxxwaP8cADD8TQoUNj5MiR0alTp6hZs2Zce+218eKLL0ZERMeOHbO+1WbtPx43ZtGiRXHsscfGueeeG3/4wx+iTp06MWPGjBgwYECsXLkyqlevvlnnt7atuLg4IiJWrFgR3bt3j+7du8d9990Xu+22W7z//vvRvXv3WLlyZUREPPnkk7Fq1aqIiKhWrdoma13X2udTtGnTJpYsWRLDhw+P3r17b/F++D/GcdmP4zvuuCOOPfbYEuex9llT37VkyZJt8uBgto31fTY29Hlp2LBh1rje0gerr/vNjVsz5pMtfLZeaT/r7Hi25GfA+hQXF8fMmTOjYsWKsWDBgs0+7rrje3OuvZBrG7uuV6hQIVq0aBEREQceeGC8+eabMWLEiMyz1GB7sb5x/M4778SiRYviuOOOy7Svve5XqlQp5s+fn/UHL3ZMQqmd3EEHHRSPPPJINGvWLCpVWv9wqFKlSokZPTNnzozOnTvHeeedl2n77l+pq1WrlvkBuLlefvnlKC4ujpEjR0aFCt9O4tvaZ/tERLz11lvx2WefxdVXXx2NGzeOiIg5c+Zk9WnatOlWH2et4uLizMNV11obcqz1wgsvxD777BMVK1Yss+PuzIzjb21sHC9cuDCmTp0ajz32WIl1nTp1imeeeSbr4dpTpkwp8ReuF154ocRyq1attvRU2EJl/b5XqlRpveO6QYMGMXv27MyzRtasWROvvPJKHHjggRvd37Ya8+v7zG7OZx0ivn2WyVtvvRXTp0+P7t27x9ixY6N///4REZmZUJszW3lzrr2wufbee++oXLlyzJ49O5o0aRIREYWFhfHf//436zlPm7ruV65cOWv8bui6vj7r+3cqbIk0x3H16tXj9ddfz2r73e9+F8uWLYtRo0Zlrsvs2Ny+t5MbOHBgfP7559G7d++YPXt2vPPOO/HUU09F//79MxeJZs2axYsvvhiLFi2KTz/9NIqLi2OfffaJOXPmxFNPPRX//e9/49JLL93sBy1uSIsWLWLVqlXx5z//Od5999245557Mg/R3RpNmjSJKlWqZPb72GOPxVVXXbVZ286bNy/mzp0bn3/+eRQWFsbcuXOzEvzRo0fH448/Hm+//Xa8/fbbceedd8Z1110XZ5xxRtZ+3n///bjwwgtj/vz5cf/998ef//znuOCCC7b63PiWcbxpd911V+yxxx7rva3vggsuiH/84x8xcuTIeOutt2L48OExZ86cEg/GnjlzZvzpT3+K//73vzF69OiYMGGCcZyCtN73888/P0aMGBF/+9vfYv78+XHBBRfEF198kXXr8fpsqzG/vs/s5nzW4dVXX43LLrss7rjjjujSpUtcf/31ccEFF8S7774bERH169ePatWqZR6UX1hYuMF9be21F76rZs2a0bdv37joooti6tSp8Z///CcGDBgQFSpUyLrWbuq636xZs3jmmWfio48+ii+++GKDxxsxYkRMmTIl3n333XjzzTdj5MiRcc8995T4dypsiTTHcdWqVaN169ZZr1122SVq1qwZrVu3LnG7NTsmodROrmHDhjFz5sxYs2ZNHHPMMdGmTZsYMmRI7LLLLpm/eA8dOjQqVqwY+++/f2ba+jnnnBM//vGP45RTTolDDz00Pvvss6zZJqXRrl27uP766+Oaa66J1q1bx3333RcjRozY6nPcbbfdYty4cTFhwoTYf//94+qrr47rrrtus7b90Y9+FO3bt4/HH388pk2bFu3bt4/27dtn1hcXF8ewYcPiwAMPjI4dO8bo0aPjmmuuiSuvvDJrP3369Imvv/46DjnkkBg4cGBccMEF8fOf/3yrz41vGccbV1xcHOPGjYt+/fqtd3Ze586dY/z48fGXv/wl2rVrFw8//HBMmjQpWrdundXvV7/6VcyZMyfat28fv//97+P666+P7t27b/W5sXFpve8XX3xx9O7dO/r06ROdOnWKGjVqRPfu3aNq1aob3W5bjfn1fWY357POzu2bb76JM844I/r165e53ePnP/95fP/7348zzzwz1qxZE5UqVYqbbropbrvttmjYsGGccMIJG9zf1lx7YX2uv/766NSpUxx77LFx9NFHR5cuXaJVq1ZZ19pNXfdHjhwZU6ZMicaNG2f9u3RdK1asiPPOOy8OOOCA6NKlSzzyyCNx7733xs9+9rNteo6Uf2mOY8q/vGRLH+gAAJR7xcXF0apVq/jpT39qZgjANrJixYpo1KhRjBw5MgYMGBDNmjWLIUOGZN1SD9s745it4YEMAEC899578c9//jO6du0aRUVFcfPNN8fChQvjtNNOy3VpAOXGq6++Gm+99VYccsghUVhYmJldv7EZe7C9MY4pS0IpACAqVKgQ48aNi6FDh0aSJNG6det4+umnPcweoIxdd911MX/+/KhSpUp06NAhnnvuOV93zw7HOKasuH0PAAAAgNR5KigAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQBsR6ZNmxZ5eXnx5ZdfbvY2zZo1ixtvvHGb1QQAsC0IpQAAtkC/fv0iLy8vfvGLX5RYN3DgwMjLy4t+/fqlXxgAwA5GKAUAsIUaN24cDzzwQHz99deZtm+++SbGjx8fTZo0yWFlAAA7DqEUAMAWOuigg6Jx48YxceLETNvEiROjSZMm0b59+0xbUVFRDB48OOrXrx9Vq1aNww8/PGbPnp21ryeffDL23XffqFatWnz/+9+PRYsWlTjejBkz4ogjjohq1apF48aNY/DgwbFixYr11pYkSQwfPjyaNGkS+fn50bBhwxg8eHDZnDgAQBkSSgEAlMJZZ50VY8eOzSzfdddd0b9//6w+v/71r+ORRx6Ju+++O1555ZVo0aJFdO/ePT7//POIiPjggw/ixz/+cRx33HExd+7c+NnPfhaXXHJJ1j7eeeed+OEPfxgnnXRS/Pvf/44HH3wwZsyYEYMGDVpvXY888kjccMMNcdttt8Xbb78dkyZNijZt2pTx2QMAbD2hFABAKZxxxhkxY8aMeO+99+K9996LmTNnxhlnnJFZv2LFihgzZkxce+210aNHj9h///3j9ttvj2rVqsWdd94ZERFjxoyJ5s2bx8iRI2O//faL008/vcTzqEaMGBGnn356DBkyJPbZZ5/o3Llz3HTTTfHXv/41vvnmmxJ1vf/++7H77rvH0UcfHU2aNIlDDjkkzj777G36XgAAlIZQCgCgFHbbbbfo2bNnjBs3LsaOHRs9e/aMevXqZda/8847sWrVqujSpUumrXLlynHIIYfEm2++GRERb775Zhx66KFZ++3UqVPW8muvvRbjxo2LGjVqZF7du3eP4uLiWLhwYYm6fvKTn8TXX38de++9d5x99tnx6KOPxurVq8vy1AEAykSlXBcAALCjOuusszK30Y0ePXqbHGP58uVxzjnnrPe5UOt7qHrjxo1j/vz58fTTT8eUKVPivPPOi2uvvTamT58elStX3iY1AgCUhplSAACl9MMf/jBWrlwZq1atiu7du2eta968eVSpUiVmzpyZaVu1alXMnj079t9//4iIaNWqVbz00ktZ273wwgtZywcddFDMmzcvWrRoUeJVpUqV9dZVrVq1OO644+Kmm26KadOmxaxZs+L1118vi1MGACgzZkoBAJRSxYoVM7fiVaxYMWtdQUFBnHvuuXHRRRdFnTp1okmTJvGnP/0pvvrqqxgwYEBERPziF7+IkSNHxkUXXRQ/+9nP4uWXX45x48Zl7efiiy+Oww47LAYNGhQ/+9nPoqCgIObNmxdTpkyJm2++uURN48aNizVr1sShhx4a1atXj3vvvTeqVasWTZs23TZvAgBAKZkpBQCwFWrVqhW1atVa77qrr746TjrppDjzzDPjoIMOigULFsRTTz0Vu+66a0R8e/vdI488EpMmTYp27drFrbfeGn/84x+z9tG2bduYPn16/Pe//40jjjgi2rdvH5dddlk0bNhwvcfcZZdd4vbbb48uXbpE27Zt4+mnn47HH3886tatW7YnDgCwlfKSJElyXQQAAAAAOxczpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNT9f3lo7nSCUXr2AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -856,29 +855,23 @@ "output_type": "stream", "text": [ "* meta-llama-13b\n", - "\t1. While some issues were addressed (logging), many critical issues remain unresolved, including JMS replacement and annotation changes.\n", - "\t2. The file is syntactically valid, but missing imports for annotations and incomplete implementation may cause compilation errors.\n", - "\t3. The file still contains JavaEE elements (@Stateless) and lacks Quarkus-specific implementations, making it largely incompatible with Quarkus.\n", + "\t1. (1/5) The updated file only fixes one issue (changing @Inject to @JmsContext for JMSContext), leaving most issues unresolved.\n", + "\t2. (2/5) The updated file has syntactical issues, missing imports, and incorrect annotations, which would prevent compilation and potentially alter functionality.\n", "* meta-llama-70b\n", - "\t1. Most issues are fixed, but the `@ApplicationScoped` annotation is missing, which was mentioned in incident 5.\n", - "\t2. The file is syntactically valid and imports are correct. However, the `@ApplicationScoped` annotation should be added for proper scoping in Quarkus.\n", - "\t3. The updated file is compatible with Quarkus, using appropriate Quarkus-specific APIs and annotations. It successfully replaces JMS with Reactive Messaging.\n", + "\t1. (3/5) While some issues were addressed, several remain unresolved, and new issues were introduced.\n", + "\t2. (2/5) The updated file has syntactical issues and incorrect imports, which may prevent compilation and alter functionality.\n", "* ibm-granite\n", - "\t1. The updated file only partially addresses the issues identified in the original JavaEE file. It fails to replace javax imports with jakarta imports, and doesn't convert @Stateless to @ApplicationScoped. The JMS Topic is not replaced with a Micrometer Emitter.\n", - "\t2. The updated file introduces new syntactical issues and imports that weren't in the original file. It adds unnecessary classes and methods, and uses imports (e.g., Flux, Mono) that aren't typically used in Quarkus applications.\n", - "\t3. The updated file is not suitable for Quarkus as it retains JavaEE-specific annotations and JMS elements instead of replacing them with Quarkus-compatible alternatives. It also introduces reactive programming concepts (Flux, Mono) which weren't part of the original requirements and may not be compatible with the intended Quarkus migration.\n", + "\t1. (1/5) The updated file does not fix any of the identified issues as described in the original issues list.\n", + "\t2. (2/5) The updated file introduces several new issues, including incorrect imports, use of non-existent classes, and changes to the original functionality.\n", "* mixtral\n", - "\t1. Only some of the identified issues were fixed. The javax imports were correctly updated to jakarta, and @Stateless was replaced with @ApplicationScoped. However, the JMS-related issues were not addressed.\n", - "\t2. The file is syntactically valid and can be compiled. All used classes and annotations are correctly imported. The original functionality appears to be maintained.\n", - "\t3. While some Quarkus-compatible changes were made, the file still uses JMS (JMSContext, Topic) which should be replaced with Quarkus-specific alternatives like Microprofile Reactive Messaging. This makes the file not fully compatible with Quarkus.\n", + "\t1. (3/5) The updated file fixes some of the identified issues, but not all. It replaces @Stateless with @ApplicationScoped and replaces JMS Topic with Micrometer Emitter. However, it doesn't address the javax to jakarta import changes.\n", + "\t2. (3/5) The updated file is syntactically valid and can be compiled. It imports necessary classes and doesn't change the original functionality. However, it still uses javax.inject and javax.enterprise packages instead of jakarta, which is not ideal for Quarkus migration.\n", "* gpt-3\n", - "\t1. The updated file only partially addresses the identified issues. It removes @Stateless and replaces it with @Singleton, but doesn't fully migrate to Quarkus-compatible alternatives for JMS.\n", - "\t2. The file is syntactically valid, but it's missing some necessary imports (e.g., for Topic). The functionality is partially preserved, but the message sending logic is commented out.\n", - "\t3. While some JavaEE elements are removed, the file still uses JMS components which are not Quarkus-compatible. The conversion to Quarkus is incomplete, especially regarding the JMS to Reactive Messaging migration.\n", + "\t1. (2/5) The updated file only fixes one issue (replacing @Stateless with @ApplicationScoped). Several other issues remain unaddressed, including import statements and JMS Topic replacement.\n", + "\t2. (3/5) The updated file is syntactically valid and can be compiled. Most classes and annotations are correctly imported. However, the JMSContext import is incorrect (should be jakarta.jms.JMSContext), and the Topic replacement is not implemented as suggested.\n", "* gpt-4\n", - "\t1. Some issues were fixed, but several remain unaddressed. The @Stateless annotation was correctly replaced with @ApplicationScoped, and Logger was updated. However, javax imports weren't changed to jakarta, and JMS elements weren't replaced with Quarkus equivalents.\n", - "\t2. The file appears syntactically valid and can likely be compiled. Imports are present, though some are incorrect for Quarkus. The original functionality seems preserved, but the use of JMS elements may cause issues.\n", - "\t3. While some changes make the file more suitable for Quarkus (like using @ApplicationScoped), the continued use of JavaEE JMS elements (JMSContext, Topic) instead of Quarkus-specific alternatives makes it not fully compatible with Quarkus as required.\n" + "\t1. (2/5) The updated file only fixes one of the seven identified issues. It replaces the `@Stateless` annotation with `@ApplicationScoped`, which addresses incident 5. However, it fails to address the other six issues related to import statements and JMS Topic replacement.\n", + "\t2. (3/5) The updated file is syntactically valid and can be compiled. It uses valid classes and imports. However, it still uses some javax packages instead of jakarta, which is not ideal for Quarkus migration. The functionality appears to be maintained, but the use of JMS instead of Micrometer Emitters might not be optimal for Quarkus.\n" ] } ], @@ -890,27 +883,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Zero Shot with analysis information\n", + "# Few Shot (Diff Only)\n", "\n", - "In this section, we run kai fix with a modified prompt. It will contain information about incidents in the file which will help pinpoint the issues in the file. We will run the exact same experiments we ran in the previous section.\n", + "In this section, we will run the same examples but this time we will include solved examples in our prompts. \n", "\n", - "Find the prompt used in this experiment [here](./templates/zero_shot/with_analysis_info.jinja)" + "We will start by including diff-only mode which includes diffs of solved examples in the input prompt directly." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Easy example\n", + "## Easy example (Few Shot with Solved Examples Diff)\n", "\n", - "This example only contains one issue which requires replacing an import.\n", + "For the easy example we are using, solved solutions data is not available in Kai at the time of writing this. Therefore, we create our own example to use that contains a diff of an already solved incident. The prompt we use is [here](./templates/few_shot/easy_hardcoded.jinja)\n", "\n", - "The outputs of this experiment will be generated in `./data/outputs/using_kai/zero_shot_easy_with_info/` directory for each model." + "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_easy/` directory for each model." ] }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -918,17 +911,17 @@ "output_type": "stream", "text": [ "generating fix using model meta-llama-13b\n", - "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/zero_shot_easy_with_info/meta-llama-13b\n", + "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_easy/meta-llama-13b\n", "generating fix using model meta-llama-70b\n", - "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/zero_shot_easy_with_info/meta-llama-70b\n", + "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/few_shot_easy/meta-llama-70b\n", "generating fix using model ibm-granite\n", - "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/zero_shot_easy_with_info/ibm-granite\n", + "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/few_shot_easy/ibm-granite\n", "generating fix using model mixtral\n", - "generated fix using model mixtral, output present in ./data/outputs//using_kai/zero_shot_easy_with_info/mixtral\n", + "generated fix using model mixtral, output present in ./data/outputs//using_kai/few_shot_easy/mixtral\n", "generating fix using model gpt-3\n", - "generated fix using model gpt-3, output present in ./data/outputs//using_kai/zero_shot_easy_with_info/gpt-3\n", + "generated fix using model gpt-3, output present in ./data/outputs//using_kai/few_shot_easy/gpt-3\n", "generating fix using model gpt-4\n", - "generated fix using model gpt-4, output present in ./data/outputs//using_kai/zero_shot_easy_with_info/gpt-4\n" + "generated fix using model gpt-4, output present in ./data/outputs//using_kai/few_shot_easy/gpt-4\n" ] } ], @@ -936,34 +929,34 @@ "# run kai-fix for all models\n", "for model in KAI_FIX_MODELS:\n", " print(f\"generating fix using model {model}\")\n", - " run_kai_generate_fix(model, \"zero_shot_easy_with_info\", \"./templates/zero_shot/with_analysis_info.jinja\", EXAMPLE_EASY)\n", - " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/zero_shot_easy_with_info/{model}\")" + " run_kai_generate_fix(model, \"few_shot_easy\", \"./templates/few_shot/easy_hardcoded.jinja\", EXAMPLE_EASY)\n", + " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_easy/{model}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's evaluate the responses and plot the charts." + "Now we will evaluate the responses." ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ - "zero_shot_easy_with_info_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_EASY, \"./data/outputs/using_kai/zero_shot_easy_with_info\")" + "few_shot_easy_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_EASY, \"./data/outputs/using_kai/few_shot_easy\")" ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 66, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABLpUlEQVR4nO3debyWc/4/8PdpO9UppV20ICptkkFiCpGsGTNDlhaNtRCToVmsQwxRaGIsZewijSVMqEYJyTLWKGWZb2VJK07LuX5/eHT/3E57p+uu0/P5eNyPh+tzfa7rel+3z311zut8ruvOS5IkCQAAAABIUZlcFwAAAADAtkcoBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQCUuLy8vLj88stzcuwJEyZEXl5eTJgwISfHLy1mz54deXl5ccMNN+S6lM1mY8fpqvdm5MiRJV4TAGxLhFIAUEqNHDky8vLy1vh65ZVXcl3iJvn73/++xYUCRUVF8c9//jP23XffqFGjRlStWjV233336NGjx1b/fm8uPx2nkyZNKrY+SZJo0KBB5OXlxVFHHZWDCgGAzaVcrgsAADavK6+8Mnbeeedi7U2aNMlBNSXn73//e9SqVSt69eqV1f7LX/4yvv/++6hQoULqNZ133nkxbNiwOPbYY+Pkk0+OcuXKxfTp0+OZZ56JXXbZJfbbb7/Ua9paVKxYMR544IE44IADstonTpwYX3zxReTn5+eoMgBgcxFKAUAp17Vr19h7771zXUZqypQpExUrVkz9uPPmzYu///3vcfrpp8c//vGPrHVDhgyJr776KrVaVqxYEUVFRTkJ5jbWEUccEaNGjYqbb745ypX7/z+iPvDAA9GuXbv4+uuvc1gdALA5uH0PALZhy5cvjxo1akTv3r2LrVu0aFFUrFgxBgwYEBERy5Yti0svvTTatWsX1apVi4KCgjjwwANj/Pjx6zxOr169onHjxsXaL7/88sjLy8tqGzFiRBx88MFRp06dyM/Pjz322COGDx+e1adx48bx3nvvxcSJEzO3fnXq1Cki1vxMqVGjRkW7du2iUqVKUatWrTjllFPif//7X7E6q1SpEv/73/+iW7duUaVKlahdu3YMGDAgVq5cudZznDVrViRJEh06dCi2Li8vL+rUqZPVtmDBgrjggguicePGkZ+fHzvttFP06NEjK3z58ssvo0+fPlG3bt2oWLFitGnTJu65556s/fz02U9DhgyJXXfdNfLz8+P999+PiIgPP/wwfv3rX0eNGjWiYsWKsffee8cTTzyx1nP5uZtuuikaNWoUlSpVio4dO8a7776bWTdixIjIy8uLN998s9h211xzTZQtW7bY+7w63bt3j2+++SbGjRuXaVu2bFk8+uijcdJJJ612m6VLl8bvf//7aNCgQeTn50fTpk3jhhtuiCRJsvoVFhbGBRdcELVr146qVavGMcccE1988cVq9/m///0vTjvttKhbt27k5+dHixYt4u67715n/QDAhhNKAWyiVb9U//TVrFmztW4zatSoaNasWVSsWDFatWoVY8eOTalatkULFy6Mr7/+Ouv1zTffRERE+fLl47jjjosxY8bEsmXLsrYbM2ZMFBYWxoknnhgRP4ZUd955Z3Tq1Cmuu+66uPzyy+Orr76KLl26xFtvvVVi9Q4fPjwaNWoUf/zjH2Pw4MHRoEGDOOecc2LYsGGZPkOGDImddtopmjVrFvfee2/ce++98ac//WmN+xw5cmT89re/jbJly8agQYPi9NNPj9GjR8cBBxwQCxYsyOq7cuXK6NKlS9SsWTNuuOGG6NixYwwePLjY7Kefa9SoUUT8+Pn+7rvv1tp3yZIlceCBB8Ytt9wShx12WAwdOjTOOuus+PDDDzNhyffffx+dOnWKe++9N04++eS4/vrro1q1atGrV68YOnRosX2OGDEibrnlljjjjDNi8ODBUaNGjXjvvfdiv/32iw8++CAuueSSGDx4cBQUFES3bt3i8ccfX2uNq/zzn/+Mm2++Ofr27RsDBw6Md999Nw4++OCYN29eRET8+te/jkqVKsX9999fbNv7778/OnXqFDvuuOM6j9O4ceNo3759PPjgg5m2Z555JhYuXJgZgz+VJEkcc8wxcdNNN8Xhhx8ehxxySHz00Udx0UUXRZkyZbKuxb/73e9iyJAhcdhhh8W1114b5cuXjyOPPDIiIm699dbMtfj++++P/fbbL55//vno169fDB06NJo0aRJ9+vSJIUOGrNf7BRvLzxOUBsYxGywBYJNcdtllSYsWLZI5c+ZkXl999dUa+0+ePDkpW7Zs8re//S15//33kz//+c9J+fLlk3feeSfFqtkWjBgxIomI1b7y8/Mz/Z577rkkIpInn3wya/sjjjgi2WWXXTLLK1asSAoLC7P6fPvtt0ndunWT0047Las9IpLLLrsss9yzZ8+kUaNGxWq87LLLkp//OPLdd98V69elS5esWpIkSVq0aJF07NixWN/x48cnEZGMHz8+SZIkWbZsWVKnTp2kZcuWyffff5/p99RTTyURkVx66aVZdUZEcuWVV2bts23btkm7du2KHevnevTokUREsv322yfHHXdccsMNNyQffPBBsX6XXnppEhHJ6NGji60rKipKkiRJhgwZkkREct9992XWLVu2LGnfvn1SpUqVZNGiRUmSJMmsWbOSiEi222675Msvv8za1yGHHJK0atUq+eGHH7L2v//++ye77bbbWs9l1X4rVaqUfPHFF5n2V199NYmI5IILLsi0de/ePalfv36ycuXKTNsbb7yRREQyYsSItR5n1TidOnVqcuuttyZVq1bNjIHf/OY3yUEHHZQkSZI0atQoOfLIIzPbjRkzJomI5K9//WuSJP//WnzUUUcleXl5yZQpU5Kvvvoqeeutt5KISM4555ys4x566KFJRCSdO3fOXIvz8vKS2rVrJ19//XVW3xNPPDGpVq1apq5V7826zg02hJ8nKA2MYzaUmVIAJaBcuXJRr169zKtWrVpr7Dt06NA4/PDD46KLLormzZvHVVddFXvttVfceuutKVbMtmTYsGExbty4rNczzzyTWX/wwQdHrVq14uGHH860ffvttzFu3Lg44YQTMm1ly5bNPKOoqKgo5s+fHytWrIi999473njjjRKrt1KlSpn/XjXLq2PHjvHJJ5/EwoULN3h/r7/+enz55ZdxzjnnZD1r6sgjj4xmzZrF008/XWybs846K2v5wAMPjE8++WSdxxoxYkTceuutsfPOO8fjjz8eAwYMiObNm8chhxySdQvbY489Fm3atInjjjuu2D5W3c44duzYqFevXnTv3j2zrnz58nHeeefFkiVLYuLEiVnbHX/88VG7du3M8vz58+PFF1+M3/72t7F48eKsWXJdunSJjz/+eL1uq+vWrVvWTKd99tkn9t1336y/ZPfo0SP+7//+L+tWzvvvvz8qVaoUxx9//DqPscpvf/vb+P777+Opp56KxYsXx1NPPbXGW/fGjh0bZcuWjfPOOy/TVq5cufjTn/4USZLE66+/HrVq1crU+dN+EZG5xa9Dhw7RvHnzuPLKK6NMmTJRq1atSJIka2Zhly5dYuHChSU6zmF1/DxBaWAcsyGEUgAl4OOPP4769evHLrvsEieffHJ89tlna+w7ZcqU6Ny5c1Zbly5dYsqUKZu7TLZR++yzT3Tu3DnrddBBB2XWlytXLo4//vj417/+FYWFhRERMXr06Fi+fHlWKBURcc8990Tr1q2jYsWKUbNmzahdu3Y8/fTTGxUWrcnkyZOjc+fOUVBQENWrV4/atWvHH//4x4iIjTrOp59+GhERTZs2LbauWbNmmfWrVKxYMSvciYjYfvvt49tvv13nscqUKRN9+/aNadOmxddffx3/+te/omvXrvHiiy9m3YI2c+bMaNmy5Trr3m233aJMmewf15o3b551Xqv8/BsWZ8yYEUmSxF/+8peoXbt21uuyyy6LiB+fWbUuu+22W7G23XffPWbPnp1ZPvTQQ2OHHXbI3MJXVFQUDz74YBx77LFRtWrVdR5jldq1a0fnzp3jgQceiNGjR8fKlSvj17/+9Wr7fvrpp1G/fv2s/X/88cfRrVu3iPjx2xk/++yz+PTTT6NMmTKx6667Zm3/wQcfZC1/9dVXsXLlyvjggw+KvV+rnrm2Pu8XbAo/T1AaGMdsCN++B7CJ9t133xg5cmQ0bdo05syZE1dccUUceOCB8e677672l7G5c+dG3bp1s9rq1q0bc+fOTatkKObEE0+M22+/PZ555pno1q1bPPLII9GsWbNo06ZNps99990XvXr1im7dusVFF10UderUyTyjaebMmWvd/88fZr7Kzx8ePnPmzDjkkEOiWbNmceONN0aDBg2iQoUKMXbs2LjpppuiqKho0092HcqWLVsi+6lZs2Ycc8wxccwxx0SnTp1i4sSJ8emnn2aePVXSfjrDLCIy79WAAQOiS5cuq92mSZMmJXLssmXLxkknnRR33HFH/P3vf4/JkyfH//3f/8Upp5yywfs66aST4vTTT4+5c+dG165do3r16uu13aprcf369TPPCjvwwAOL/bKzyqpnYq2y6v3Kz8+Pp556arXbtG7dev1PBDaQnycoDYxjNpRQCmATde3aNfPfrVu3jn333TcaNWoUjzzySPTp0yeHlcH6++Uvfxk77LBDPPzww3HAAQfEiy++WOzB4Y8++mjssssuMXr06KyQadWsm7XZfvvtiz1QPKL4bJ8nn3wyCgsL44knnoiGDRtm2lf3DX9rCrp+blUINH369Dj44IOz1k2fPn2zhUQ/tffee8fEiRNjzpw50ahRo9h1112zvsFudRo1ahT//e9/o6ioKGu21IcffphZvza77LJLRPx4y9+agpn18fHHHxdr++ijj4p9m2KPHj1i8ODB8eSTT8YzzzwTtWvXXmMYtjbHHXdcnHnmmfHKK69k3VL6c40aNYrnn38+Fi9eHFWrVs1ci1999dWIiOjfv39cffXVsWDBgigqKoqZM2dmzZZLfvYNfbVr146KFStGkiSb9H7BxvLzBKWBccyGcvseQAmrXr167L777jFjxozVrq9Xr16xv9DPmzcv6tWrl0Z5sFplypSJX//61/Hkk0/GvffeGytWrCh2696qGUQ//WX+1VdfXa8p9rvuumssXLgw/vvf/2ba5syZU+wb4FZ3jIULF8aIESOK7bOgoGC1QdfP7b333lGnTp247bbbMrcnRvz4zW4ffPBB5lvYNtXcuXPj/fffL9a+bNmyeOGFF6JMmTKZmUnHH398vP3226v9BrxV537EEUfE3Llzs4KZFStWxC233BJVqlSJjh07rrWeOnXqRKdOneL222+POXPmFFv/1Vdfrdd5jRkzJuvZU6+99lq8+uqrWb94RPz4y0fr1q3jzjvvjMceeyxOPPHEKFduw//+WaVKlRg+fHhcfvnlcfTRR6+x3xFHHBErV64s9tyRm266KfLy8uL444+P3XffPapVqxYRETfffHNWv/z8/KzlsmXLRtOmTWPZsmWrDQzX9/2CkuLnCUoD45h1MVMKoIQtWbIkZs6cGaeeeupq17dv3z5eeOGF6N+/f6Zt3Lhx0b59+5QqZFvzzDPPZGbX/NT++++fmU0TEXHCCSfELbfcEpdddlm0atUq8+yiVY466qgYPXp0HHfccXHkkUfGrFmz4rbbbos99tgjlixZstYaTjzxxLj44ovjuOOOi/POOy++++67GD58eOy+++5ZD48+7LDDokKFCnH00UfHmWeeGUuWLIk77rgj6tSpUyxYadeuXQwfPjz++te/RpMmTaJOnTrFZkJF/DhT6LrrrovevXtHx44do3v37jFv3rwYOnRoNG7cOC644IL1eh/X5Ysvvoh99tknDj744DjkkEOiXr168eWXX8aDDz4Yb7/9dvTv3z/zsNeLLrooHn300fjNb34Tp512WrRr1y7mz58fTzzxRNx2223Rpk2bOOOMM+L222+PXr16xbRp06Jx48bx6KOPxuTJk2PIkCHr9aymYcOGxQEHHBCtWrWK008/PXbZZZeYN29eTJkyJb744ot4++2317mPJk2axAEHHBBnn312FBYWxpAhQ6JmzZrxhz/8oVjfHj16xIABAyIiNurWvVV69uy5zj5HH310HHTQQfGnP/0pZs+eHW3atIl///vf8a9//Sv69+8fdevWzVyLu3fvHn//+99j4cKFsf/++8cLL7wQ5cuXL7bPcuXKRUFBQey7775x+umnxx577BHz58+PN954I55//vmYP3/+Rp8TbCg/T1AaGMesU86+9w+glPj973+fTJgwIZk1a1YyefLkpHPnzkmtWrUyX81+6qmnJpdcckmm/+TJk5Ny5cplvir+sssu89W3bBYjRoxIImKNr59/nX1RUVHSoEGDJCKSv/71r8X2V1RUlFxzzTVJo0aNkvz8/KRt27bJU089lfTs2TNp1KhRVt+ISC677LKstn//+99Jy5YtkwoVKiRNmzZN7rvvvuSyyy5Lfv7jyBNPPJG0bt06qVixYtK4cePkuuuuS+6+++4kIpJZs2Zl+s2dOzc58sgjk6pVqyYRkXTs2DFJkiQZP358EhHJ+PHjs/b78MMPJ23btk3y8/OTGjVqJCeffHLyxRdfZPXp2bNnUlBQUOzcV1fnzy1atCgZOnRo0qVLl2SnnXZKypcvn1StWjVp3759cscddyRFRUVZ/b/55pukX79+yY477phUqFAh2WmnnZKePXsmX3/9dabPvHnzkt69eye1atVKKlSokLRq1arY/7dZs2YlEZFcf/31q61r5syZSY8ePZJ69eol5cuXT3bcccfkqKOOSh599NG1ns9P9zt48OCkQYMGSX5+fnLggQcmb7/99mq3mTNnTlK2bNlk9913X+u+f2rVOJ06depa+zVq1Cg58sgjs9oWL16cXHDBBUn9+vWTMmXKJDvttFMycODAZNKkSVnX4u+//z5p1qxZUqlSpaSgoCA5+uijk8cffzyJiOTQQw/NuhZPmDAh6du3b9KgQYOkfPnySb169ZJDDjkk+cc//lHsvfn5/wvYFH6eoDQwjtlQQimATXTCCSckO+ywQ1KhQoVkxx13TE444YRkxowZmfUdO3ZMevbsmbXNI488kuy+++5JhQoVkhYtWiRPP/10ylUDlLyvvvoqKVeuXHLllVemfmzXYrZ2xjClgXHMhspLkp895REAADbCDTfcEH/4wx/ik08+KfYgdACAn/NMKQAANsmLL74Y77//flx99dXRrVs3gRQAsF7MlAIAYJN06tQpXn755ejQoUPcd999seOOO+a6JABgK1Amlwe//PLLIy8vL+vVrFmzXJYEAMAGmjBhQixbtizGjx8vkAIA1lvOb99r0aJFPP/885nlcuVyXhIAAAAAm1nOE6By5cpFvXr1cl0GAAAAACnKeSj18ccfR/369aNixYrRvn37GDRoUDRs2HC1fQsLC6OwsDCzXFRUFPPnz4+aNWtGXl5eWiUDAAAAsAZJksTixYujfv36UabMmp8cldMHnT/zzDOxZMmSaNq0acyZMyeuuOKK+N///hfvvvtuVK1atVj/yy+/PK644oocVAoAAADAhvj8889jp512WuP6Lerb9xYsWBCNGjWKG2+8Mfr06VNs/c9nSi1cuDAaNmwYn3/+eWy33XZplgqsQcvLnst1CWyF3r2iS65LgFLFtZiNsSVdi41hNsaWNIYjjGM2zpY2jjfWokWLokGDBrFgwYKoVq3aGvvl/Pa9n6pevXrsvvvuMWPGjNWuz8/Pj/z8/GLt2223nVAKthBl8ivnugS2Qq7hULJci9kYW9K12BhmY2xJYzjCOGbjbGnjeFOt61FLa76xLweWLFkSM2fOjB122CHXpQAAAACwGeU0lBowYEBMnDgxZs+eHS+//HIcd9xxUbZs2ejevXsuywIAAABgM8vp7XtffPFFdO/ePb755puoXbt2HHDAAfHKK69E7dq1c1kWAAAAAJtZTkOphx56KJeHBwAAACBHtqhnSgEAAACwbRBKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJC6LSaUuvbaayMvLy/69++f61IAAAAA2My2iFBq6tSpcfvtt0fr1q1zXQoAAAAAKch5KLVkyZI4+eST44477ojtt98+1+UAAAAAkIKch1J9+/aNI488Mjp37rzOvoWFhbFo0aKsFwAAAABbn3K5PPhDDz0Ub7zxRkydOnW9+g8aNCiuuOKKzVwVAAAAAJtbzmZKff7553H++efH/fffHxUrVlyvbQYOHBgLFy7MvD7//PPNXCUAAAAAm0POZkpNmzYtvvzyy9hrr70ybStXroz//Oc/ceutt0ZhYWGULVs2a5v8/PzIz89Pu1QAAAAASljOQqlDDjkk3nnnnay23r17R7NmzeLiiy8uFkgBAAAAUHrkLJSqWrVqtGzZMqutoKAgatasWawdAAAAgNIl59++BwAAAMC2J6ffvvdzEyZMyHUJAAAAAKTATCkAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1OQ2lhg8fHq1bt47tttsutttuu2jfvn0888wzuSwJAAAAgBTkNJTaaaed4tprr41p06bF66+/HgcffHAce+yx8d577+WyLAAAAAA2s3K5PPjRRx+dtXz11VfH8OHD45VXXokWLVrkqCoAAAAANrechlI/tXLlyhg1alQsXbo02rdvv9o+hYWFUVhYmFletGhRWuUBAAAAUIJy/qDzd955J6pUqRL5+flx1llnxeOPPx577LHHavsOGjQoqlWrlnk1aNAg5WoBAAAAKAk5D6WaNm0ab731Vrz66qtx9tlnR8+ePeP9999fbd+BAwfGwoULM6/PP/885WoBAAAAKAk5v32vQoUK0aRJk4iIaNeuXUydOjWGDh0at99+e7G++fn5kZ+fn3aJAAAAAJSwnM+U+rmioqKs50YBAAAAUPrkdKbUwIEDo2vXrtGwYcNYvHhxPPDAAzFhwoR47rnnclkWAAAAAJtZTkOpL7/8Mnr06BFz5syJatWqRevWreO5556LQw89NJdlAQAAALCZ5TSUuuuuu3J5eAAAAAByZIt7phQAAAAApZ9QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaXIuUGDBsUvfvGLqFq1atSpUye6desW06dPX+s2nTp1iry8vGKvI488MqWqAQAAgE0hlCLnJk6cGH379o1XXnklxo0bF8uXL4/DDjssli5dusZtRo8eHXPmzMm83n333Shbtmz85je/SbFyAAAAYGOVy3UB8Oyzz2Ytjxw5MurUqRPTpk2LX/7yl6vdpkaNGlnLDz30UFSuXFkoBQAAAFsJM6XY4ixcuDAiigdPa3PXXXfFiSeeGAUFBZurLAAAAKAEmSnFFqWoqCj69+8fHTp0iJYtW67XNq+99lq8++67cdddd23m6gAAAICSIpRii9K3b9949913Y9KkSeu9zV133RWtWrWKffbZZzNWBgAAAJQkt++xxejXr1889dRTMX78+Nhpp53Wa5ulS5fGQw89FH369NnM1QEAAAAlyUwpci5Jkjj33HPj8ccfjwkTJsTOO++83tuOGjUqCgsL45RTTtmMFQIAAAAlzUwpcq5v375x3333xQMPPBBVq1aNuXPnxty5c+P777/P9OnRo0cMHDiw2LZ33XVXdOvWLWrWrJlmyQAAAMAmMlOKnBs+fHhERHTq1CmrfcSIEdGrV6+IiPjss8+iTJnsDHX69OkxadKk+Pe//51GmQAAAEAJEkqRc0mSrLPPhAkTirU1bdp0vbYFAAAAtjxu3wMAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFInlAIAAAAgdUIpAAAAAFJXLtcFkK3xJU/nugS2QrOvPTLXJQAAAMAGMVMKAAAAgNQJpQAAAABI3SaFUsuWLYvp06fHihUrSqoeAAAAALYBGxVKfffdd9GnT5+oXLlytGjRIj777LOIiDj33HPj2muvLdECAQAAACh9NiqUGjhwYLz99tsxYcKEqFixYqa9c+fO8fDDD5dYcQAAAACUThv17XtjxoyJhx9+OPbbb7/Iy8vLtLdo0SJmzpxZYsUBAAAAUDpt1Eypr776KurUqVOsfenSpVkhFQAAAACszkaFUnvvvXc8/fTTmeVVQdSdd94Z7du3L5nKAAAAACi1Nur2vWuuuSa6du0a77//fqxYsSKGDh0a77//frz88ssxceLEkq4RAAAAgFJmo2ZKHXDAAfH222/HihUrolWrVvHvf/876tSpE1OmTIl27dqVdI0AAAAAlDIbPFNq+fLlceaZZ8Zf/vKXuOOOOzZHTQAAAACUchs8U6p8+fLx2GOPbY5aAAAAANhGbNTte926dYsxY8aUcCkAAAAAbCs26kHnu+22W1x55ZUxefLkaNeuXRQUFGStP++880qkOAAAAABKp40Kpe66666oXr16TJs2LaZNm5a1Li8vTygFAAAAwFptVCg1a9askq4DAAAAgG3IRj1T6qeSJIkkSUqiFgAAAAC2ERsdSv3zn/+MVq1aRaVKlaJSpUrRunXruPfee0uyNgAAAABKqY26fe/GG2+Mv/zlL9GvX7/o0KFDRERMmjQpzjrrrPj666/jggsuKNEiAQAAAChdNiqUuuWWW2L48OHRo0ePTNsxxxwTLVq0iMsvv1woBQAAAMBabdTte3PmzIn999+/WPv+++8fc+bM2eSiAAAAACjdNiqUatKkSTzyyCPF2h9++OHYbbfdNrkoAAAAAEq3jbp974orrogTTjgh/vOf/2SeKTV58uR44YUXVhtWAQAAAMBPbdRMqeOPPz5effXVqFWrVowZMybGjBkTtWrVitdeey2OO+64kq4RAAAAgFJmo2ZKRUS0a9cu7rvvvpKsBQAAAIBtxEbNlBo7dmw899xzxdqfe+65eOaZZza5KAAAAABKt40KpS655JJYuXJlsfYkSeKSSy7Z5KIAAAAAKN02KpT6+OOPY4899ijW3qxZs5gxY8YmFwUAAABA6bZRoVS1atXik08+KdY+Y8aMKCgo2OSiAAAAACjdNiqUOvbYY6N///4xc+bMTNuMGTPi97//fRxzzDElVhwAAAAApdNGhVJ/+9vfoqCgIJo1axY777xz7LzzztGsWbOoWbNm3HDDDSVdIwAAAAClTLmN2ahatWrx8ssvx7hx4+Ltt9+OSpUqRZs2beLAAw8s6foAAAAAKIU2aKbUlClT4qmnnoqIiLy8vDjssMOiTp06ccMNN8Txxx8fZ5xxRhQWFm6WQgEAAAAoPTYolLryyivjvffeyyy/8847cfrpp8ehhx4al1xySTz55JMxaNCgEi8SAAAAgNJlg0Kpt956Kw455JDM8kMPPRT77LNP3HHHHXHhhRfGzTffHI888kiJFwkAAABA6bJBodS3334bdevWzSxPnDgxunbtmln+xS9+EZ9//nnJVQcAAABAqbRBoVTdunVj1qxZERGxbNmyeOONN2K//fbLrF+8eHGUL1++ZCsEAAAAoNTZoFDqiCOOiEsuuSReeumlGDhwYFSuXDnrG/f++9//xq677lriRQIAAABQupTbkM5XXXVV/OpXv4qOHTtGlSpV4p577okKFSpk1t99991x2GGHlXiRAAAAAJQuGxRK1apVK/7zn//EwoULo0qVKlG2bNms9aNGjYoqVaqUaIEAAAAAlD4bFEqtUq1atdW216hRY5OKAQAAAGDbsEHPlAIAAACAkiCUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1QikAAAAAUieUAgAAACB1OQ2lBg0aFL/4xS+iatWqUadOnejWrVtMnz49lyUBAAAAkIKchlITJ06Mvn37xiuvvBLjxo2L5cuXx2GHHRZLly7NZVkAAAAAbGblcnnwZ599Nmt55MiRUadOnZg2bVr88pe/zFFVAAAAAGxuW9QzpRYuXBgRETVq1MhxJQAAAABsTjmdKfVTRUVF0b9//+jQoUO0bNlytX0KCwujsLAws7xo0aK0ygMAAACgBG0xM6X69u0b7777bjz00ENr7DNo0KCoVq1a5tWgQYMUKwQAAACgpGwRoVS/fv3iqaeeivHjx8dOO+20xn4DBw6MhQsXZl6ff/55ilUCAAAAUFJyevtekiRx7rnnxuOPPx4TJkyInXfeea398/PzIz8/P6XqAAAAANhcchpK9e3bNx544IH417/+FVWrVo25c+dGRES1atWiUqVKuSwNAAAAgM0op7fvDR8+PBYuXBidOnWKHXbYIfN6+OGHc1kWAAAAAJtZzm/fAwAAAGDbs0U86BwAAACAbYtQCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDUCaUAAAAASJ1QCgAAAIDU5TSU+s9//hNHH3101K9fP/Ly8mLMmDG5LAcAAACAlOQ0lFq6dGm0adMmhg0blssyAAAAAEhZuVwevGvXrtG1a9dclgAAAABADnimFAAAAACpy+lMqQ1VWFgYhYWFmeVFixblsBoAAAAANtZWNVNq0KBBUa1atcyrQYMGuS4JAAAAgI2wVYVSAwcOjIULF2Zen3/+ea5LAgAAAGAjbFW37+Xn50d+fn6uywAAAABgE+U0lFqyZEnMmDEjszxr1qx46623okaNGtGwYcMcVgYAAADA5pTTUOr111+Pgw46KLN84YUXRkREz549Y+TIkTmqCgAAAIDNLaehVKdOnSJJklyWAAAAAEAObFUPOgcAAACgdBBKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQAAAJA6oRQAAAAAqRNKAQARETFs2LBo3LhxVKxYMfbdd9947bXX1tp/wYIF0bdv39hhhx0iPz8/dt999xg7dmxK1QIAsLUrl+sCAIDce/jhh+PCCy+M2267Lfbdd98YMmRIdOnSJaZPnx516tQp1n/ZsmVx6KGHRp06deLRRx+NHXfcMT799NOoXr16+sUDALBVEkoBAHHjjTfG6aefHr17946IiNtuuy2efvrpuPvuu+OSSy4p1v/uu++O+fPnx8svvxzly5ePiIjGjRunWTIAAFs5t+8BwDZu2bJlMW3atOjcuXOmrUyZMtG5c+eYMmXKard54oknon379tG3b9+oW7dutGzZMq655ppYuXJlWmUDALCVM1MKALZxX3/9daxcuTLq1q2b1V63bt348MMPV7vNJ598Ei+++GKcfPLJMXbs2JgxY0acc845sXz58rjsssvSKBsAgK2cUAoA2GBFRUVRp06d+Mc//hFly5aNdu3axf/+97+4/vrrhVIAAKwXoRQAbONq1aoVZcuWjXnz5mW1z5s3L+rVq7fabXbYYYcoX758lC1bNtPWvHnzmDt3bixbtiwqVKiwWWsGAGDr55lSALCNq1ChQrRr1y5eeOGFTFtRUVG88MIL0b59+9Vu06FDh5gxY0YUFRVl2j766KPYYYcdBFIAAKwXoRQAEBdeeGHccccdcc8998QHH3wQZ599dixdujTzbXw9evSIgQMHZvqfffbZMX/+/Dj//PPjo48+iqeffjquueaa6Nu3b65OAQCArYzb9wCAOOGEE+Krr76KSy+9NObOnRt77rlnPPvss5mHn3/22WdRpsz//1tWgwYN4rnnnosLLrggWrduHTvuuGOcf/75cfHFF+fqFAAA2MoIpQCAiIjo169f9OvXb7XrJkyYUKytffv28corr2zmqgAAKK3cvgcAAABA6oRSAAAAAKROKAUAAABA6oRSAAAAAKROKAUAAABA6oRSAAAAAKSuXK4LAIAtSeNLns51CWyFZl97ZK5LAADY6pgpBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqhFIAAAAApE4oBQAAAEDqtohQatiwYdG4ceOoWLFi7LvvvvHaa6/luiQAAAAANqOch1IPP/xwXHjhhXHZZZfFG2+8EW3atIkuXbrEl19+mevSAAAAANhMch5K3XjjjXH66adH7969Y4899ojbbrstKleuHHfffXeuSwMAAABgM8lpKLVs2bKYNm1adO7cOdNWpkyZ6Ny5c0yZMiWHlQEAAACwOZXL5cG//vrrWLlyZdStWzervW7duvHhhx8W619YWBiFhYWZ5YULF0ZExKJFizZvoSkqKvwu1yWwFdqSPgPGMBvDGGZrtyWN4QjjmI2zJY1jY5iNsSWN4QjjmI2zpY3jjbXqPJIkWWu/nIZSG2rQoEFxxRVXFGtv0KBBDqqBLUe1IbmuADaNMczWzhimNDCO2doZw5QGpW0cL168OKpVq7bG9TkNpWrVqhVly5aNefPmZbXPmzcv6tWrV6z/wIED48ILL8wsFxUVxfz586NmzZqRl5e32esldxYtWhQNGjSIzz//PLbbbrtclwMbzBhma2cMUxoYx2ztjGFKA+N425AkSSxevDjq16+/1n45DaUqVKgQ7dq1ixdeeCG6desWET8GTS+88EL069evWP/8/PzIz8/PaqtevXoKlbKl2G677Vy42KoZw2ztjGFKA+OYrZ0xTGlgHJd+a5shtUrOb9+78MILo2fPnrH33nvHPvvsE0OGDImlS5dG7969c10aAAAAAJtJzkOpE044Ib766qu49NJLY+7cubHnnnvGs88+W+zh5wAAAACUHjkPpSIi+vXrt9rb9WCV/Pz8uOyyy4rdvglbC2OYrZ0xTGlgHLO1M4YpDYxjfiovWdf38wEAAABACSuT6wIAAAAA2PYIpQAAAABInVCKVHXq1Cn69++fWW7cuHEMGTIkZ/Wk4efnzNZvWxzH28I5bil+Or62pfe9V69e0a1bt1yXwVZowoQJkZeXFwsWLNgmjw8AWzOhFOu0rYYqP/zwQ/Tq1StatWoV5cqVW+0vS5MmTYoOHTpEzZo1o1KlStGsWbO46aab0i+WddpWx/Hll18eeXl5xV4FBQVZ/UaNGhXNmjWLihUrRqtWrWLs2LE5qpjRo0fHVVddlesyUjd06NAYOXJkZnlb/cyy4fbff/+YM2dOVKtWbb36z549O/Ly8uKtt97avIXBZpKXlxdjxoxZZ7/Ro0fH3nvvHdWrV4+CgoLYc88949577938BcJ6WN9x/FMPPfRQ5OXl+SNWKbNFfPsebIlWrlwZlSpVivPOOy8ee+yx1fYpKCiIfv36RevWraOgoCAmTZoUZ555ZhQUFMQZZ5yRcsVQ3IABA+Kss87KajvkkEPiF7/4RWb55Zdfju7du8egQYPiqKOOigceeCC6desWb7zxRrRs2TLtkrd5NWrUyHUJ623ZsmVRoUKFEtnX+gYK8HMVKlSIevXqlfh+S3J8Qy7UqFEj/vSnP0WzZs2iQoUK8dRTT0Xv3r2jTp060aVLl1yXBxtk9uzZMWDAgDjwwANzXQolzEypUqZTp05x7rnnRv/+/WP77bePunXrxh133BFLly6N3r17R9WqVaNJkybxzDPPZLZ59913o2vXrlGlSpWoW7dunHrqqfH1119HxI+3U0ycODGGDh2amWExe/bsWLlyZfTp0yd23nnnqFSpUjRt2jSGDh26yfXfeOON0apVqygoKIgGDRrEOeecE0uWLMmsHzlyZFSvXj2eeuqpaNq0aVSuXDl+/etfx3fffRf33HNPNG7cOLbffvs477zzYuXKlZnt7r333th7772jatWqUa9evTjppJPiyy+/XGstBQUFMXz48Dj99NPX+MNu27Zto3v37tGiRYto3LhxnHLKKdGlS5d46aWXsvqtWLEi+vXrF9WqVYtatWrFX/7yl/DFl2tmHJfcOK5SpUrUq1cv85o3b168//770adPn0yfoUOHxuGHHx4XXXRRNG/ePK666qrYa6+94tZbb83a1+LFi6N79+5RUFAQO+64YwwbNmyT3yuK+/kMoXW973l5eXH77bfHUUcdFZUrV47mzZvHlClTYsaMGdGpU6coKCiI/fffP2bOnLnW465YsSLOO++8qF69etSsWTMuvvji6NmzZ9ZfIzt16hT9+vWL/v37R61atTK/1KzvmH/uueeiefPmUaVKlTj88MNjzpw5mT4/vX1vTZ/ZiLV/1ikdNvTfgJ/fPnfaaadF69ato7CwMCJ+DJfatm0bPXr0iIiInXfeOSJ+/Dc8Ly8vOnXqFBH/fwxeffXVUb9+/WjatGlEbNy1F9Zk8eLFcfLJJ0dBQUHssMMOcdNNNxW7bfuqq65a43W/cePGERFx3HHHRV5eXmZ5dTp16hTHHXdcNG/ePHbdddc4//zzo3Xr1jFp0qTNeIZsC9IcxxE/ThY4+eST44orrohddtllM50VuSKUKoXuueeeqFWrVrz22mtx7rnnxtlnnx2/+c1vYv/994833ngjDjvssDj11FPju+++iwULFsTBBx8cbdu2jddffz2effbZmDdvXvz2t7+NiB9/WW3fvn2cfvrpMWfOnJgzZ040aNAgioqKYqeddopRo0bF+++/H5deemn88Y9/jEceeWSTai9TpkzcfPPN8d5778U999wTL774YvzhD3/I6vPdd9/FzTffHA899FA8++yzMWHChDjuuONi7NixMXbs2Lj33nvj9ttvj0cffTSzzfLly+Oqq66Kt99+O8aMGROzZ8+OXr16bVKtq/Pmm2/Gyy+/HB07dsxqv+eee6JcuXLx2muvxdChQ+PGG2+MO++8s8SPX5oYx5tnHN95552x++67Z/2VacqUKdG5c+esfl26dIkpU6ZktV1//fXRpk2bePPNN+OSSy6J888/P8aNG7dBx2fDrc/7ftVVV0WPHj3irbfeimbNmsVJJ50UZ555ZgwcODBef/31SJIk+vXrt9bjXHfddXH//ffHiBEjYvLkybFo0aLVTqu/5557okKFCjF58uS47bbbImL9x/wNN9wQ9957b/znP/+Jzz77LAYMGLDaWtb0mV3XZ53SY0P+Dfi5m2++OZYuXRqXXHJJRET86U9/igULFmSC9tdeey0iIp5//vmYM2dOjB49OrPtCy+8ENOnT49x48bFU089FRHp/QzBtuHCCy+MyZMnxxNPPBHjxo2Ll156Kd54442sPmu77k+dOjUiIkaMGBFz5szJLK9LkiSZ8f3LX/6yZE+KbU7a4/jKK6+MOnXqZP1RlVIkoVTp2LFjcsABB2SWV6xYkRQUFCSnnnpqpm3OnDlJRCRTpkxJrrrqquSwww7L2sfnn3+eREQyffr0zD7PP//8dR67b9++yfHHH7/O+n66r0aNGiU33XTTGvuPGjUqqVmzZmZ5xIgRSUQkM2bMyLSdeeaZSeXKlZPFixdn2rp06ZKceeaZa9zv1KlTk4jI2mZtevbsmRx77LFrXL/jjjsmFSpUSMqUKZNceeWVWes6duyYNG/ePCkqKsq0XXzxxUnz5s3X69jbIuP4RyU9jr///vtk++23T6677rqs9vLlyycPPPBAVtuwYcOSOnXqZJYbNWqUHH744Vl9TjjhhKRr167rdWzW30/H1/q87xGR/PnPf84sT5kyJYmI5K677sq0Pfjgg0nFihXXety6desm119/fWZ5xYoVScOGDbOufR07dkzatm27znNYnzE/bNiwpG7dupnln19nV/eZXZ/POlu/Df03YPz48UlEJN9++21m/csvv5yUL18++ctf/pKUK1cueemllzLrZs2alURE8uabb2Ydt2fPnkndunWTwsLCtdb382vv6o4Pq7No0aKkfPnyyahRozJtCxYsSCpXrrzB1/3HH398vY65YMGCpKCgIClXrlySn5+f9W8DbIy0x/FLL72U7LjjjslXX32VJMm6fy9j62OmVCnUunXrzH+XLVs2atasGa1atcq01a1bNyIivvzyy3j77bdj/PjxUaVKlcyrWbNmERHrvNVj2LBh0a5du6hdu3ZUqVIl/vGPf8Rnn30WEREvvfRS1j7vv//+9ar9+eefj0MOOSR23HHHqFq1apx66qnxzTffZP0ltHLlyrHrrrtmnU/jxo2jSpUqWW0/nVo/bdq0OProo6Nhw4ZRtWrVzEymVfW2aNEiU2vXrl3Xq9afeumll+L111+P2267LYYMGRIPPvhg1vr99tsv8vLyMsvt27ePjz/+OOvWLLIZxyU/jh9//PFYvHhx9OzZc73O4+fat29fbPmDDz7YqH2x/tbnff/p52XVZ+Pnn5cffvghFi1aFJ999lnWuL7mmmti4cKFMW/evNhnn30y25QtWzbatWtXrJ7VtW3MmN9hhx02+BaoTfmss3XZkH8DVqd9+/YxYMCAuOqqq+L3v/99HHDAAet13FatWhV7jtS6rr2wvj755JNYvnx51rW2WrVqmVtFV9nQf29Xd11fpWrVqvHWW2/F1KlT4+qrr44LL7wwJkyYUDInxDYpzXG8ePHiOPXUU+OOO+6IWrVqleyJsMXwoPNSqHz58lnLeXl5WW2rwpGioqJYsmRJHH300XHdddcV288OO+ywxmM89NBDMWDAgBg8eHC0b98+qlatGtdff328+uqrERGx9957Z32rzaofHtdm9uzZcdRRR8XZZ58dV199ddSoUSMmTZoUffr0iWXLlkXlypXX6/xWtRUVFUVExNKlS6NLly7RpUuXuP/++6N27drx2WefRZcuXWLZsmURETF27NhYvnx5RERUqlRpnbX+3KrnU7Rq1SrmzZsXl19+eXTv3n2D98P/ZxyX/Di+884746ijjip2HqueNfVT8+bN2ywPDmbzWN1nY02fl/r162eN6w19sPrPv7lxU8Z8soHP1tvYzzpbnw35N2B1ioqKYvLkyVG2bNmYMWPGeh/35+N7fa69kGtru66XKVMmmjRpEhERe+65Z3zwwQcxaNCgzLPUYEuxunE8c+bMmD17dhx99NGZ9lXX/XLlysX06dOz/uDF1kkotY3ba6+94rHHHovGjRtHuXKrHw4VKlQoNqNn8uTJsf/++8c555yTafvpX6krVaqU+QdwfU2bNi2Kiopi8ODBUabMj5P4NvXZPhERH374YXzzzTdx7bXXRoMGDSIi4vXXX8/q06hRo00+zipFRUWZh6uusirkWOWVV16J3XbbLcqWLVtix92WGcc/Wts4njVrVowfPz6eeOKJYuvat28fL7zwQtbDtceNG1fsL1yvvPJKseXmzZtv6KmwgUr6fS9Xrtxqx3XdunVj6tSpmWeNrFy5Mt54443Yc88917q/zTXmV/eZXZ/POkT8+CyTDz/8MCZOnBhdunSJESNGRO/evSMiMjOh1me28vpce2F97bLLLlG+fPmYOnVqNGzYMCIiFi5cGB999FHWc57Wdd0vX7581vhd03V9dVb3cypsiDTHceXKleOdd97Javvzn/8cixcvjqFDh2auy2zd3L63jevbt2/Mnz8/unfvHlOnTo2ZM2fGc889F717985cJBo3bhyvvvpqzJ49O77++usoKiqK3XbbLV5//fV47rnn4qOPPoq//OUv6/2gxTVp0qRJLF++PG655Zb45JNP4t577808RHdTNGzYMCpUqJDZ7xNPPBFXXXXVem37/vvvx1tvvRXz58+PhQsXxltvvZWV4A8bNiyefPLJ+Pjjj+Pjjz+Ou+66K2644YY45ZRTsvbz2WefxYUXXhjTp0+PBx98MG655ZY4//zzN/nc+JFxvG5333137LDDDqu9re/888+PZ599NgYPHhwffvhhXH755fH6668XezD25MmT429/+1t89NFHMWzYsBg1apRxnIK03vdzzz03Bg0aFP/6179i+vTpcf7558e3336bdevx6myuMb+6z+z6fNbhzTffjEsvvTTuvPPO6NChQ9x4441x/vnnxyeffBIREXXq1IlKlSplHpS/cOHCNe5rU6+98FNVq1aNnj17xkUXXRTjx4+P9957L/r06RNlypTJutau67rfuHHjeOGFF2Lu3Lnx7bffrvF4gwYNinHjxsUnn3wSH3zwQQwePDjuvffeYj+nwoZIcxxXrFgxWrZsmfWqXr16VK1aNVq2bFnsdmu2TkKpbVz9+vVj8uTJsXLlyjjssMOiVatW0b9//6hevXrmL94DBgyIsmXLxh577JGZtn7mmWfGr371qzjhhBNi3333jW+++SZrtsnGaNOmTdx4441x3XXXRcuWLeP++++PQYMGbfI51q5dO0aOHBmjRo2KPfbYI6699tq44YYb1mvbI444Itq2bRtPPvlkTJgwIdq2bRtt27bNrC8qKoqBAwfGnnvuGXvvvXcMGzYsrrvuurjyyiuz9tOjR4/4/vvvY5999om+ffvG+eefH2ecccYmnxs/Mo7XrqioKEaOHBm9evVa7ey8/fffPx544IH4xz/+EW3atIlHH300xowZEy1btszq9/vf/z5ef/31aNu2bfz1r3+NG2+8Mbp06bLJ58bapfW+X3zxxdG9e/fo0aNHtG/fPqpUqRJdunSJihUrrnW7zTXmV/eZXZ/POtu2H374IU455ZTo1atX5naPM844Iw466KA49dRTY+XKlVGuXLm4+eab4/bbb4/69evHscceu8b9bcq1F1bnxhtvjPbt28dRRx0VnTt3jg4dOkTz5s2zrrXruu4PHjw4xo0bFw0aNMj6ufTnli5dGuecc060aNEiOnToEI899ljcd9998bvf/W6zniOlX5rjmNIvL9nQBzoAAKVeUVFRNG/ePH7729+aGQKwmSxdujR23HHHGDx4cPTp0ycaN24c/fv3z7qlHrZ0xjGbwgMZAID49NNP49///nd07NgxCgsL49Zbb41Zs2bFSSedlOvSAEqNN998Mz788MPYZ599YuHChZnZ9WubsQdbGuOYkiSUAgCiTJkyMXLkyBgwYEAkSRItW7aM559/3sPsAUrYDTfcENOnT48KFSpEu3bt4qWXXvJ192x1jGNKitv3AAAAAEidp4ICAAAAkDqhFAAAAACpE0oBAAAAkDqhFAAAAACpE0oBAAAAkDqhFADAFmTChAmRl5cXCxYsWO9tGjduHEOGDNlsNQEAbA5CKQCADdCrV6/Iy8uLs846q9i6vn37Rl5eXvTq1Sv9wgAAtjJCKQCADdSgQYN46KGH4vvvv8+0/fDDD/HAAw9Ew4YNc1gZAMDWQygFALCB9tprr2jQoEGMHj060zZ69Oho2LBhtG3bNtNWWFgY5513XtSpUycqVqwYBxxwQEydOjVrX2PHjo3dd989KlWqFAcddFDMnj272PEmTZoUBx54YFSqVCkaNGgQ5513XixdunS1tSVJEpdffnk0bNgw8vPzo379+nHeeeeVzIkDAJQgoRQAwEY47bTTYsSIEZnlu+++O3r37p3V5w9/+EM89thjcc8998Qbb7wRTZo0iS5dusT8+fMjIuLzzz+PX/3qV3H00UfHW2+9Fb/73e/ikksuydrHzJkz4/DDD4/jjz8+/vvf/8bDDz8ckyZNin79+q22rsceeyxuuummuP322+Pjjz+OMWPGRKtWrUr47AEANp1QCgBgI5xyyikxadKk+PTTT+PTTz+NyZMnxymnnJJZv3Tp0hg+fHhcf/310bVr19hjjz3ijjvuiEqVKsVdd90VERHDhw+PXXfdNQYPHhxNmzaNk08+udjzqAYNGhQnn3xy9O/fP3bbbbfYf//94+abb45//vOf8cMPPxSr67PPPot69epF586do2HDhrHPPvvE6aefvlnfCwCAjSGUAgDYCLVr144jjzwyRo4cGSNGjIgjjzwyatWqlVk/c+bMWL58eXTo0CHTVr58+dhnn33igw8+iIiIDz74IPbdd9+s/bZv3z5r+e23346RI0dGlSpVMq8uXbpEUVFRzJo1q1hdv/nNb+L777+PXXbZJU4//fR4/PHHY8WKFSV56gAAJaJcrgsAANhanXbaaZnb6IYNG7ZZjrFkyZI488wzV/tcqNU9VL1BgwYxffr0eP7552PcuHFxzjnnxPXXXx8TJ06M8uXLb5YaAQA2hplSAAAb6fDDD49ly5bF8uXLo0uXLlnrdt1116hQoUJMnjw507Z8+fKYOnVq7LHHHhER0bx583jttdeytnvllVeylvfaa694//33o0mTJsVeFSpUWG1dlSpViqOPPjpuvvnmmDBhQkyZMiXeeeedkjhlAIASY6YUAMBGKlu2bOZWvLJly2atKygoiLPPPjsuuuiiqFGjRjRs2DD+9re/xXfffRd9+vSJiIizzjorBg8eHBdddFH87ne/i2nTpsXIkSOz9nPxxRfHfvvtF/369Yvf/e53UVBQEO+//36MGzcubr311mI1jRw5MlauXBn77rtvVK5cOe67776oVKlSNGrUaPO8CQAAG8lMKQCATbDddtvFdtttt9p11157bRx//PFx6qmnxl577RUzZsyI5557LrbffvuI+PH2u8ceeyzGjBkTbdq0idtuuy2uueaarH20bt06Jk6cGB999FEceOCB0bZt27j00kujfv36qz1m9erV44477ogOHTpE69at4/nnn48nn3wyatasWbInDgCwifKSJElyXQQAAAAA2xYzpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNQJpQAAAABInVAKAAAAgNT9P10M7BJsF8EFAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -976,50 +969,44 @@ "output_type": "stream", "text": [ "* meta-llama-13b\n", - "\t1. The updated file partially addresses the issue by removing the javax.enterprise import, but it doesn't replace it with jakarta.enterprise as specified. The @Dependent annotation is replaced with @ApplicationScoped without explanation.\n", - "\t2. The updated file is syntactically valid and can be compiled. However, it lacks necessary imports (e.g., for @ApplicationScoped and Serializable). The functionality seems to be mostly preserved, but there are unexplained changes to the ShoppingCartItem type.\n", - "\t3. The updated file is generally compatible with Quarkus. The use of @ApplicationScoped is appropriate for Quarkus. However, the lack of proper imports and the unexplained changes to ShoppingCartItem could potentially cause issues in a Quarkus application.\n", + "\t1. (3/5) The issue of replacing the import statement has been fixed, but there are other general syntactical issues that have been introduced.\n", + "\t2. (2/5) The updated file has fixed the import statement as requested, but it has removed other necessary imports and most of the class implementation, which would cause compilation errors and change the original functionality.\n", "* meta-llama-70b\n", - "\t1. The issue of replacing javax.enterprise import with jakarta.enterprise was not addressed. However, the import and @Dependent annotation were removed entirely, which is a valid approach for Quarkus if the class doesn't require CDI.\n", - "\t2. The updated file is syntactically valid and can be compiled. All necessary classes are imported correctly, and the original functionality is maintained.\n", - "\t3. The updated file is mostly compatible with Quarkus. The removal of the @Dependent annotation and the javax.enterprise import makes it suitable for use in a Quarkus application. However, if CDI is needed for this class, the jakarta.enterprise import and @Dependent annotation should be added back.\n", + "\t1. (5/5) The issue has been fixed exactly as described. The import statement on line 7 has been correctly changed from 'javax.enterprise.context.Dependent' to 'jakarta.enterprise.context.Dependent'.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All classes, interfaces, and annotations used in the file are valid and imported correctly. The fixes do not change the original functionality of the code. The overall structure and logic of the class remain intact.\n", "* ibm-granite\n", - "\t1. The update only partially addresses the original issue by adding Quarkus-specific annotations, but it doesn't replace the javax.enterprise import with jakarta.enterprise as requested.\n", - "\t2. The updated file introduces new annotations without proper imports, which may cause compilation errors. The original functionality seems unchanged, but the lack of imports is a concern.\n", - "\t3. While the added annotations (@QuarkusApplicationScoped, @NonNull, @Valid, @EqualsAndHashCode) are Quarkus-compatible, the file still lacks the necessary import changes and may not be fully compatible with Quarkus without additional modifications.\n", + "\t1. (0/5) The issue identified in the JavaEE file has not been fixed in the updated file. The import statement for javax.enterprise has not been replaced with jakarta.enterprise as requested.\n", + "\t2. (2/5) The updated file has several syntactical issues and deviations from the original functionality. It introduces new imports, annotations, and methods that were not present in the original file. The class structure has been significantly altered, changing it from a model class to a test class with @ApplicationScoped and @RunWith annotations. Fields are now annotated with @Inject, which changes the original behavior. A @Test method has been added, which was not part of the original file's functionality.\n", "* mixtral\n", - "\t1. The issue of replacing javax.enterprise with jakarta.enterprise was not addressed. Instead, javax.inject.ApplicationScoped was used, which is not the exact replacement requested.\n", - "\t2. The updated file is syntactically valid and can be compiled. The changes made do not alter the original functionality. However, the import for ApplicationScoped is not correct for Quarkus.\n", - "\t3. The file is mostly compatible with Quarkus. The use of ApplicationScoped is Quarkus-friendly, but the import should be from jakarta.enterprise.context.ApplicationScoped for full Quarkus compatibility.\n", + "\t1. (5/5) The issue has been correctly fixed by replacing the javax.enterprise import with jakarta.enterprise.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All classes, interfaces, and annotations are valid and imported correctly. The fix does not change the original functionality of the code.\n", "* gpt-3\n", - "\t1. The import statement was not changed to 'jakarta.enterprise' as requested, which is a crucial part of migrating to Quarkus. However, the @Dependent annotation was changed to @ApplicationScoped, which is a step towards Quarkus compatibility.\n", - "\t2. The updated file is syntactically valid and can be compiled. All classes and annotations used in the file are correctly imported. The fixes do not change the original functionality of the class.\n", - "\t3. The file is largely compatible with Quarkus, especially with the change to @ApplicationScoped. However, the persistence of the 'javax' import instead of 'jakarta' could potentially cause issues in a Quarkus environment.\n", + "\t1. (5/5) The issue has been correctly fixed by replacing the javax.enterprise import with jakarta.enterprise.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All classes, interfaces, and annotations are valid and imported correctly. The fixes do not change the original functionality of the code.\n", "* gpt-4\n", - "\t1. The import statement has been correctly changed from javax.enterprise to jakarta.enterprise, which is the only issue that needed to be addressed.\n", - "\t2. The updated file is syntactically valid and can be compiled. All classes and annotations are correctly imported. The fix does not change the original functionality of the code.\n", - "\t3. The updated file is fully compatible with Quarkus. The change from javax to jakarta namespace is the correct approach for Quarkus compatibility, and no new issues have been introduced that would make the file incompatible with Quarkus.\n" + "\t1. (5/5) The issue has been fixed exactly as described. The import statement on line 7 has been changed from 'javax.enterprise.context.Dependent' to 'jakarta.enterprise.context.Dependent'.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All classes, interfaces, and annotations used in the file are valid and imported correctly. The fix does not change the original functionality of the code.\n" ] } ], "source": [ - "plot_chart_and_print_reasoning(zero_shot_easy_with_info_eval_output)" + "plot_chart_and_print_reasoning(few_shot_easy_eval_output)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Hard example\n", + "## Hard example (Few Shot with Solved Examples Diff)\n", "\n", - "Now we use a relatively harder example to evaluate responses.\n", + "Since this file contains many incidents, and most of these incidents have solved examples stored in Kai, we were hitting input limits when we used a prompt that contains solved examples for all of the incidents. Therefore, we are only going to use solved example for the most difficult issue in the file which is to change the JMS Topic to an emitter. This is the 7th incident. We will be using [this prompt](./templates/few_shot/default.jinja).\n", "\n", - "The outputs of this experiment will be generated in `./data/outputs/using_kai/zero_shot_hard_with_info/` directory for each model." + "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_hard/` directory for each model." ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1027,17 +1014,17 @@ "output_type": "stream", "text": [ "generating fix using model meta-llama-13b\n", - "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/zero_shot_hard_with_info/meta-llama-13b\n", + "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_hard/meta-llama-13b\n", "generating fix using model meta-llama-70b\n", - "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/zero_shot_hard_with_info/meta-llama-70b\n", + "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/few_shot_hard/meta-llama-70b\n", "generating fix using model ibm-granite\n", - "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/zero_shot_hard_with_info/ibm-granite\n", + "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/few_shot_hard/ibm-granite\n", "generating fix using model mixtral\n", - "generated fix using model mixtral, output present in ./data/outputs//using_kai/zero_shot_hard_with_info/mixtral\n", + "generated fix using model mixtral, output present in ./data/outputs//using_kai/few_shot_hard/mixtral\n", "generating fix using model gpt-3\n", - "generated fix using model gpt-3, output present in ./data/outputs//using_kai/zero_shot_hard_with_info/gpt-3\n", + "generated fix using model gpt-3, output present in ./data/outputs//using_kai/few_shot_hard/gpt-3\n", "generating fix using model gpt-4\n", - "generated fix using model gpt-4, output present in ./data/outputs//using_kai/zero_shot_hard_with_info/gpt-4\n" + "generated fix using model gpt-4, output present in ./data/outputs//using_kai/few_shot_hard/gpt-4\n" ] } ], @@ -1045,34 +1032,34 @@ "# run kai-fix for all models\n", "for model in KAI_FIX_MODELS:\n", " print(f\"generating fix using model {model}\")\n", - " run_kai_generate_fix(model, \"zero_shot_hard_with_info\", \"./templates/zero_shot/with_analysis_info.jinja\", EXAMPLE_HARD)\n", - " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/zero_shot_hard_with_info/{model}\")" + " run_kai_generate_fix(model, \"few_shot_hard\", \"./templates/few_shot/default.jinja\", EXAMPLE_HARD)\n", + " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_hard/{model}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we evaluate and plot the charts." + "Now lets evaluate the responses we get from all models." ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "zero_shot_hard_with_info_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_HARD, \"./data/outputs/using_kai/zero_shot_hard_with_info\")" + "few_shot_hard_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_HARD, \"./data/outputs/using_kai/few_shot_hard\")" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1085,61 +1072,57 @@ "output_type": "stream", "text": [ "* meta-llama-13b\n", - "\t1. Only 1 out of 10 issues has been addressed (importing Logger from Quarkus). Most JavaEE imports and annotations remain unchanged.\n", - "\t2. The file is syntactically valid, but it's missing necessary imports for Quarkus-specific classes like io.quarkus.arc.inject.Inject.\n", - "\t3. The file is still largely JavaEE-based and not suitable for Quarkus. It retains EJB annotations, JMS context, and Topic, which are not compatible with Quarkus.\n", + "\t1. (3/5) The file partially addresses the issues identified, but some remain unfixed and new issues are introduced.\n", + "\t2. (2/5) The updated file has syntactical issues and missing imports, which may cause compilation errors.\n", "* meta-llama-70b\n", - "\t1. Some issues were fixed, but critical changes for Quarkus compatibility were not implemented.\n", - "\t2. The file is syntactically valid, but missing important imports and annotations for Quarkus.\n", - "\t3. The file is not suitable for Quarkus as it retains JMS elements and lacks necessary Quarkus-specific modifications.\n", + "\t1. (3/5) The updated file fixes some of the issues but not all. It replaces some javax imports with jakarta, removes @Stateless, and replaces Topic with Emitter. However, it misses the @ApplicationScoped annotation and some jakarta imports.\n", + "\t2. (4/5) The updated file is syntactically valid and can be compiled. Most classes and interfaces are imported correctly. The original functionality seems to be preserved. However, the missing @ApplicationScoped annotation might affect the bean's lifecycle.\n", "* ibm-granite\n", - "\t1. Only some of the identified issues were addressed. The javax to jakarta imports were not updated, and the @Stateless annotation wasn't replaced with @ApplicationScoped.\n", - "\t2. The file appears syntactically valid, but there are missing imports for new classes used (e.g., Message, DeliveryMode). The original functionality seems preserved, but with modifications to use AMQP instead of JMS.\n", - "\t3. While some changes were made towards Quarkus compatibility (e.g., using AMQP), many JavaEE elements remain (JMSContext, Topic). The file is not fully migrated to be Quarkus-compatible and still relies on JavaEE APIs.\n", + "\t1. (3/5) The updated file partially addresses the issues identified in the JavaEE file, but it fails to implement some of the required changes and introduces new problems.\n", + "\t2. (2/5) The updated file has several syntactical issues and imports that are not consistent with Quarkus best practices, which may lead to compilation errors or unexpected behavior.\n", "* mixtral\n", - "\t1. The updated file fixes most of the identified issues, but misses some important changes like replacing javax.annotation and javax.inject imports with jakarta equivalents.\n", - "\t2. The updated file is mostly syntactically valid, but lacks some necessary imports (e.g., jakarta.inject.Inject). The functionality appears to be maintained.\n", - "\t3. The file is largely suitable for Quarkus, using appropriate Quarkus-compatible APIs and annotations. The use of Reactive Messaging and Emitter is correctly implemented for Quarkus.\n", + "\t1. (4/5) Most issues are fixed correctly, but there are a couple of discrepancies and potential issues.\n", + "\t2. (3/5) The updated file has some syntactical issues and potential functionality changes that need to be addressed.\n", "* gpt-3\n", - "\t1. Not all issues have been addressed. The file still uses some JavaEE APIs and annotations instead of Quarkus equivalents.\n", - "\t2. The file is syntactically valid, but some imports are missing (e.g., for @Named). The functionality appears to be preserved.\n", - "\t3. The file is not fully compatible with Quarkus. It still uses JMS and JavaEE-specific annotations, which are not recommended for Quarkus applications.\n", + "\t1. (3/5) The updated file fixes some of the identified issues, but not all. It correctly replaces some javax imports with jakarta, but misses others. The @Stateless annotation wasn't replaced as specified.\n", + "\t2. (2/5) The updated file has syntactical issues. The use of Emitter is incorrect, and the Transformers class is not imported. The changes also alter the original functionality of the JMS operations.\n", "* gpt-4\n", - "\t1. Most issues are fixed, but the import for javax.inject should be jakarta.inject. Other replacements are correct.\n", - "\t2. The file is mostly syntactically valid, but the javax.inject import needs to be corrected to jakarta.inject.\n", - "\t3. The file is mostly compatible with Quarkus, but it still uses QpidJmsContext instead of a Quarkus-specific messaging solution like RESTEasy Reactive or SmallRye Reactive Messaging.\n" + "\t1. (5/5) All issues identified in the JavaEE file have been fixed correctly in the updated file. The import statements have been updated, @Stateless has been replaced with @ApplicationScoped, and JMS Topic has been replaced with Micrometer Emitter.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All necessary classes and annotations are imported correctly. The original functionality appears to be maintained with the migration to Quarkus.\n" ] } ], "source": [ - "plot_chart_and_print_reasoning(zero_shot_hard_with_info_eval_output)" + "plot_chart_and_print_reasoning(few_shot_hard_eval_output)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Few Shot (Diff Only)\n", + "# Few Shot (LLM Summary)\n", "\n", - "In this section, we will run the same examples but this time we will include solved examples in our prompts. \n", + "In this section, we use a prompt that contains a summary of changes as solved examples. This summary will be generated by another LLM by looking at diffs of previous solved example. This differs from our last approach where we passed the diff directly to the LLM.\n", "\n", - "We will start by including diff-only mode which includes diffs of solved examples in the input prompt directly." + "For examples we are using, solutions with summaries are not present in Kai at the time of creating this notebook. Therefore, we created these examples manually from diffs. We used the exact same prompt Kai uses to generate the LLM summary of solved examples.\n", + "\n", + "For reference, find the summary generation prompts we used as well as generated summaries [here](./templates/summary_generation.jinja)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Easy example\n", + "## Easy Example (Few Shot with Solved Examples Summary)\n", "\n", - "For the easy example we are using, solved solutions data is not available in Kai at the time of writing this. Therefore, we create our own example to use that contains a diff of an already solved incident. The prompt we use is [here](./templates/few_shot/easy_hardcoded.jinja)\n", + "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_easy_llm_summary/` directory for each model.\n", "\n", - "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_easy/` directory for each model." + "We will be using a prompt we already created with LLM summary content [here](./templates/few_shot/easy_hardcoded_summary.jinja)" ] }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -1147,28 +1130,17 @@ "output_type": "stream", "text": [ "generating fix using model meta-llama-13b\n", - "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_easy/meta-llama-13b\n", + "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/meta-llama-13b\n", "generating fix using model meta-llama-70b\n", - "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/few_shot_easy/meta-llama-70b\n", - "generating fix using model ibm-granite\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[100], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m model \u001b[38;5;129;01min\u001b[39;00m KAI_FIX_MODELS:\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerating fix using model \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 4\u001b[0m \u001b[43mrun_kai_generate_fix\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfew_shot_easy\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m./templates/few_shot/default.jinja\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mEXAMPLE_EASY\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerated fix using model \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m, output present in \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mOUTPUT_BASE_PATH\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/using_kai/few_shot_easy/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", - "Cell \u001b[0;32mIn[89], line 106\u001b[0m, in \u001b[0;36mrun_kai_generate_fix\u001b[0;34m(model_key, experiment_key, prompt_template, example, llm_summary)\u001b[0m\n\u001b[1;32m 104\u001b[0m subprocess\u001b[38;5;241m.\u001b[39mrun([\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcp\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mconfig_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m../../kai/config.toml\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m 105\u001b[0m subprocess\u001b[38;5;241m.\u001b[39mrun([\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcp\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mprompt_template\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m../../kai/data/templates/\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m--> 106\u001b[0m processes, logs \u001b[38;5;241m=\u001b[39m \u001b[43mensure_kai_service\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 107\u001b[0m \u001b[38;5;66;03m# sleep is needed to let Kai server come up\u001b[39;00m\n\u001b[1;32m 108\u001b[0m sleep(\u001b[38;5;241m10\u001b[39m)\n", - "Cell \u001b[0;32mIn[89], line 76\u001b[0m, in \u001b[0;36mensure_kai_service\u001b[0;34m(output_path)\u001b[0m\n\u001b[1;32m 74\u001b[0m db_thread\u001b[38;5;241m.\u001b[39mstart()\n\u001b[1;32m 75\u001b[0m data_load_log \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00moutput_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/data_load.log\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mw+\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 76\u001b[0m \u001b[43msubprocess\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmake\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mload-data\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcwd\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m../../\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstdout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_load_log\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstderr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata_load_log\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 77\u001b[0m kai_thread\u001b[38;5;241m.\u001b[39mstart()\n\u001b[1;32m 78\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m processes, [kai_log, postgres_log, data_load_log]\n", - "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/subprocess.py:550\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(input, capture_output, timeout, check, *popenargs, **kwargs)\u001b[0m\n\u001b[1;32m 548\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m Popen(\u001b[38;5;241m*\u001b[39mpopenargs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;28;01mas\u001b[39;00m process:\n\u001b[1;32m 549\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 550\u001b[0m stdout, stderr \u001b[38;5;241m=\u001b[39m \u001b[43mprocess\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcommunicate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 551\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m TimeoutExpired \u001b[38;5;28;01mas\u001b[39;00m exc:\n\u001b[1;32m 552\u001b[0m process\u001b[38;5;241m.\u001b[39mkill()\n", - "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/subprocess.py:1201\u001b[0m, in \u001b[0;36mPopen.communicate\u001b[0;34m(self, input, timeout)\u001b[0m\n\u001b[1;32m 1199\u001b[0m stderr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstderr\u001b[38;5;241m.\u001b[39mread()\n\u001b[1;32m 1200\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstderr\u001b[38;5;241m.\u001b[39mclose()\n\u001b[0;32m-> 1201\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwait\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1202\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1203\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/subprocess.py:1264\u001b[0m, in \u001b[0;36mPopen.wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 1262\u001b[0m endtime \u001b[38;5;241m=\u001b[39m _time() \u001b[38;5;241m+\u001b[39m timeout\n\u001b[1;32m 1263\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1264\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_wait\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1265\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m:\n\u001b[1;32m 1266\u001b[0m \u001b[38;5;66;03m# https://bugs.python.org/issue25942\u001b[39;00m\n\u001b[1;32m 1267\u001b[0m \u001b[38;5;66;03m# The first keyboard interrupt waits briefly for the child to\u001b[39;00m\n\u001b[1;32m 1268\u001b[0m \u001b[38;5;66;03m# exit under the common assumption that it also received the ^C\u001b[39;00m\n\u001b[1;32m 1269\u001b[0m \u001b[38;5;66;03m# generated SIGINT and will exit rapidly.\u001b[39;00m\n\u001b[1;32m 1270\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m timeout \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/subprocess.py:2053\u001b[0m, in \u001b[0;36mPopen._wait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 2051\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreturncode \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 2052\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m \u001b[38;5;66;03m# Another thread waited.\u001b[39;00m\n\u001b[0;32m-> 2053\u001b[0m (pid, sts) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_try_wait\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2054\u001b[0m \u001b[38;5;66;03m# Check the pid and loop as waitpid has been known to\u001b[39;00m\n\u001b[1;32m 2055\u001b[0m \u001b[38;5;66;03m# return 0 even without WNOHANG in odd situations.\u001b[39;00m\n\u001b[1;32m 2056\u001b[0m \u001b[38;5;66;03m# http://bugs.python.org/issue14396.\u001b[39;00m\n\u001b[1;32m 2057\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pid \u001b[38;5;241m==\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpid:\n", - "File \u001b[0;32m/opt/homebrew/Cellar/python@3.12/3.12.4/Frameworks/Python.framework/Versions/3.12/lib/python3.12/subprocess.py:2011\u001b[0m, in \u001b[0;36mPopen._try_wait\u001b[0;34m(self, wait_flags)\u001b[0m\n\u001b[1;32m 2009\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"All callers to this function MUST hold self._waitpid_lock.\"\"\"\u001b[39;00m\n\u001b[1;32m 2010\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 2011\u001b[0m (pid, sts) \u001b[38;5;241m=\u001b[39m \u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwaitpid\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpid\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwait_flags\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2012\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mChildProcessError\u001b[39;00m:\n\u001b[1;32m 2013\u001b[0m \u001b[38;5;66;03m# This happens if SIGCLD is set to be ignored or waiting\u001b[39;00m\n\u001b[1;32m 2014\u001b[0m \u001b[38;5;66;03m# for child processes has otherwise been disabled for our\u001b[39;00m\n\u001b[1;32m 2015\u001b[0m \u001b[38;5;66;03m# process. This child is dead, we can't get the status.\u001b[39;00m\n\u001b[1;32m 2016\u001b[0m pid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpid\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/meta-llama-70b\n", + "generating fix using model ibm-granite\n", + "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/ibm-granite\n", + "generating fix using model mixtral\n", + "generated fix using model mixtral, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/mixtral\n", + "generating fix using model gpt-3\n", + "generated fix using model gpt-3, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/gpt-3\n", + "generating fix using model gpt-4\n", + "generated fix using model gpt-4, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/gpt-4\n" ] } ], @@ -1176,34 +1148,41 @@ "# run kai-fix for all models\n", "for model in KAI_FIX_MODELS:\n", " print(f\"generating fix using model {model}\")\n", - " run_kai_generate_fix(model, \"few_shot_easy\", \"./templates/few_shot/easy_hardcoded.jinja\", EXAMPLE_EASY)\n", - " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_easy/{model}\")" + " run_kai_generate_fix(model, \"few_shot_easy_llm_summary\", \"./templates/few_shot/easy_hardcoded_summary.jinja\", EXAMPLE_EASY)\n", + " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_easy_llm_summary/{model}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now we will evaluate the responses." + "Now we evaluate the responses." ] }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ - "few_shot_easy_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_EASY, \"./data/outputs/using_kai/few_shot_easy\")" + "few_shot_easy_summary_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_EASY, \"./data/outputs/using_kai/few_shot_easy_llm_summary/\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets plot the chart now." ] }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 64, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1216,50 +1195,44 @@ "output_type": "stream", "text": [ "* meta-llama-13b\n", - "\t1. The issue of replacing javax.enterprise with jakarta.enterprise is not addressed. The import has been removed entirely.\n", - "\t2. The file is mostly syntactically valid, but there are missing imports (e.g., ArrayList). The @Dependent annotation has been removed without explanation.\n", - "\t3. The file is largely compatible with Quarkus. The removal of @Dependent and use of @Log annotation (which is Quarkus-specific) improve compatibility. However, the missing imports may cause compilation issues.\n", + "\t1. (5/5) The issue of replacing the javax.enterprise import with jakarta.enterprise has been correctly fixed in the updated file.\n", + "\t2. (4/5) The updated file is mostly syntactically valid, but there are a few minor issues: 1) The Serializable interface is not imported. 2) The ArrayList class is not imported. 3) Some fields and methods from the original file have been removed without clear reason. However, the core functionality appears to be maintained.\n", "* meta-llama-70b\n", - "\t1. The issue of replacing the javax.enterprise import with jakarta.enterprise has been correctly addressed.\n", - "\t2. The updated file is syntactically valid, all necessary imports are present, and the original functionality is preserved.\n", - "\t3. The file is largely compatible with Quarkus. The @Dependent annotation was replaced with @ApplicationScoped, which is more appropriate for Quarkus. However, it's worth noting that @ApplicationScoped creates a singleton, which may not be the intended behavior if the original @Dependent was used for a different purpose.\n", + "\t1. (5/5) The issue has been correctly fixed by replacing the javax.enterprise import with jakarta.enterprise.\n", + "\t2. (5/5) The updated file is syntactically valid, maintains the original functionality, and all necessary classes and annotations are correctly imported and used.\n", "* ibm-granite\n", - "\t1. The updated file only addresses one of the identified issues (changing javax.enterprise to jakarta.enterprise). Many unnecessary changes were introduced that weren't part of the original requirements.\n", - "\t2. The file has some syntactical issues. It's not a complete Java class, missing class declaration and proper structure. Some annotations (@Incoming, @Output) are used without proper imports.\n", - "\t3. While the file attempts to use some Quarkus-specific features (like @ApplicationScoped), it introduces new issues and unnecessary changes that may not be compatible with Quarkus. The original functionality appears to be altered significantly.\n", + "\t1. (1/5) The issue of replacing the javax.enterprise import with jakarta.enterprise has been correctly fixed in the updated file.\n", + "\t2. (3/5) While the specific issue has been addressed, the updated file only includes the import statement and a comment. The rest of the class code is missing, which could lead to compilation errors and loss of functionality.\n", "* mixtral\n", - "\t1. The issue of replacing javax.enterprise with jakarta.enterprise has been correctly addressed.\n", - "\t2. The file is syntactically valid, but there are some changes that weren't explicitly requested, such as changing @Dependent to @ApplicationScoped and extending PanacheEntityBase.\n", - "\t3. While the file is generally compatible with Quarkus, the addition of PanacheEntityBase and changing to @ApplicationScoped might alter the original functionality. These changes, while potentially beneficial for Quarkus, weren't specified in the original issues to fix.\n", + "\t1. (5/5) The issue of replacing the javax.enterprise import with jakarta.enterprise has been correctly addressed in the updated file.\n", + "\t2. (3/5) While the main issue has been fixed, there are several other changes that were not part of the original issue description. These changes include removing Serializable implementation, adding @Inject annotation to shoppingCartItemList, and removing the initialization of shoppingCartItemList in the constructor. These changes may alter the original functionality and were not specified in the migration instructions.\n", "* gpt-3\n", - "\t1. The import statement was not updated to 'jakarta.enterprise' as requested, but the @Dependent annotation was changed to @ApplicationScoped, which is a valid Quarkus annotation.\n", - "\t2. The updated file is syntactically valid and can be compiled. All classes and annotations used are properly imported.\n", - "\t3. The file is mostly compatible with Quarkus. The @ApplicationScoped annotation is suitable for Quarkus applications. However, the 'javax.enterprise' import should have been updated to 'jakarta.enterprise' for full Quarkus compatibility.\n", + "\t1. (5/5) The issue has been fixed exactly as described by replacing the javax.enterprise import with jakarta.enterprise.\n", + "\t2. (5/5) The updated file is syntactically valid, all classes and annotations are correctly imported and used, and the original functionality has not been changed. There are no general syntactical issues in the migrated code.\n", "* gpt-4\n", - "\t1. The issue has been correctly addressed by replacing 'javax.enterprise' with 'jakarta.enterprise' in the import statement.\n", - "\t2. The updated file is syntactically valid and can be compiled. All necessary classes and annotations are correctly imported. The changes do not alter the original functionality of the code.\n", - "\t3. The updated file is fully compatible with Quarkus. The change from 'javax' to 'jakarta' package is a key part of migrating to Jakarta EE, which Quarkus supports. No new issues were introduced that would make the file incompatible with Quarkus.\n" + "\t1. (5/5) The issue has been fixed exactly as described. The import statement on line 7 has been changed from 'javax.enterprise' to 'jakarta.enterprise'.\n", + "\t2. (5/5) The updated file is syntactically valid and can be compiled. All classes, interfaces, and annotations used in the file are valid and correctly imported. The fixes do not change the original functionality of the code.\n" ] } ], "source": [ - "plot_chart_and_print_reasoning(few_shot_easy_eval_output)" + "plot_chart_and_print_reasoning(few_shot_easy_summary_eval_output)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Hard example\n", + "## Hard Example (Few Shot with Solved Examples Summary)\n", "\n", - "Since this file contains many incidents, and most of these incidents have solved examples stored in Kai, we were hitting input limits when we used a prompt that contains solved examples for all of the incidents. Therefore, we are only going to use solved example for the most difficult issue in the file which is to change the JMS Topic to an emitter. This is the 7th incident. We will be using [this prompt](./templates/few_shot/default.jinja).\n", + "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_hard_llm_summary/` directory for each model.\n", "\n", - "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_hard/` directory for each model." + "We will be using a prompt we already created with LLM summary content [here](./templates/few_shot/hard_hardcoded_summary.jinja)" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -1267,17 +1240,17 @@ "output_type": "stream", "text": [ "generating fix using model meta-llama-13b\n", - "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_hard/meta-llama-13b\n", + "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_hard_llm_summary/meta-llama-13b\n", "generating fix using model meta-llama-70b\n", - "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/few_shot_hard/meta-llama-70b\n", + "generated fix using model meta-llama-70b, output present in ./data/outputs//using_kai/few_shot_hard_llm_summary/meta-llama-70b\n", "generating fix using model ibm-granite\n", - "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/few_shot_hard/ibm-granite\n", + "generated fix using model ibm-granite, output present in ./data/outputs//using_kai/few_shot_hard_llm_summary/ibm-granite\n", "generating fix using model mixtral\n", - "generated fix using model mixtral, output present in ./data/outputs//using_kai/few_shot_hard/mixtral\n", + "generated fix using model mixtral, output present in ./data/outputs//using_kai/few_shot_hard_llm_summary/mixtral\n", "generating fix using model gpt-3\n", - "generated fix using model gpt-3, output present in ./data/outputs//using_kai/few_shot_hard/gpt-3\n", + "generated fix using model gpt-3, output present in ./data/outputs//using_kai/few_shot_hard_llm_summary/gpt-3\n", "generating fix using model gpt-4\n", - "generated fix using model gpt-4, output present in ./data/outputs//using_kai/few_shot_hard/gpt-4\n" + "generated fix using model gpt-4, output present in ./data/outputs//using_kai/few_shot_hard_llm_summary/gpt-4\n" ] } ], @@ -1285,34 +1258,34 @@ "# run kai-fix for all models\n", "for model in KAI_FIX_MODELS:\n", " print(f\"generating fix using model {model}\")\n", - " run_kai_generate_fix(model, \"few_shot_hard\", \"./templates/few_shot/default.jinja\", EXAMPLE_HARD)\n", - " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_hard/{model}\")" + " run_kai_generate_fix(model, \"few_shot_hard_llm_summary\", \"./templates/few_shot/hard_hardcoded_summary.jinja\", EXAMPLE_EASY)\n", + " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_hard_llm_summary/{model}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now lets evaluate the responses we get from all models." + "Now we run evaluation." ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 68, "metadata": {}, "outputs": [], "source": [ - "few_shot_hard_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_HARD, \"./data/outputs/using_kai/few_shot_hard\")" + "few_shot_hard_summary_eval_output = run_evaluation_for_models(KAI_FIX_MODELS, EXAMPLE_HARD, \"./data/outputs/using_kai/few_shot_hard_llm_summary/\")" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 69, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1325,78 +1298,28 @@ "output_type": "stream", "text": [ "* meta-llama-13b\n", - "\t1. The updated file addresses some issues but fails to fully migrate the JavaEE code to Quarkus. It replaces @Stateless with @ApplicationScoped and introduces Emitters, but doesn't retain the original functionality or imports.\n", - "\t2. The updated file has significant syntactical issues. It's missing necessary imports, the Logger is removed, and the process method is not present. The added GET and POST methods are unrelated to the original functionality.\n", - "\t3. While the file introduces some Quarkus-compatible elements like Emitters, it doesn't properly migrate the JMS functionality or retain the original ShoppingCart processing logic, making it unsuitable for direct use in Quarkus.\n", + "\t1. (4/5) Most issues have been fixed correctly, but there are a couple of discrepancies. The `@Stateless` annotation was replaced with `@Singleton` instead of `@ApplicationScoped` as suggested, and the `JMSContext` was removed without replacement.\n", + "\t2. (3/5) The file is mostly syntactically valid, but there are a few minor issues. The `Logger` import is missing, and the `@Resource` annotation is still used for the `Topic`, which should be removed if using an `Emitter`.\n", "* meta-llama-70b\n", - "\t1. Most issues are fixed, but the `@ApplicationScoped` annotation is missing, which was suggested to replace `@Stateless`.\n", - "\t2. The file is syntactically valid and imports are correct. However, the `jakarta.jms.Destination` import is unused and can be removed.\n", - "\t3. The updated file is compatible with Quarkus, using appropriate Quarkus-compatible APIs and annotations. The JMS Topic has been correctly replaced with a Microprofile Reactive Messaging Emitter.\n", + "\t1. (5/5) All issues have been correctly addressed in the updated file according to the provided descriptions.\n", + "\t2. (4/5) The updated file appears to be syntactically valid and can be compiled. The necessary classes and interfaces are imported correctly. However, the `@Resource` annotation is imported but not used in the updated file, which is a minor issue.\n", "* ibm-granite\n", - "\t1. The updated file only addresses one of the identified issues (replacing @Stateless with @QuarkusStateless). Many other required changes are missing, such as updating import statements and replacing JMS elements with Quarkus equivalents.\n", - "\t2. The file has syntactical issues. It's missing necessary import statements for annotations and classes used. The @QuarkusStateless and @QuarkusResource annotations are not standard Quarkus annotations, which may lead to compilation errors.\n", - "\t3. The updated file is not suitable for Quarkus. It still relies heavily on Java EE APIs (JMSContext, Topic) which are not directly compatible with Quarkus. The file doesn't introduce the required Quarkus-specific changes like using Reactive Messaging or SmallRye equivalents for JMS operations.\n", + "\t1. (3/5) Some issues are fixed, but not all. The import statements have been updated correctly, but the `@Stateless` annotation was not replaced with `@ApplicationScoped` as specified. The JMS `Topic` was not replaced with a Micrometer `Emitter` feeding a Channel.\n", + "\t2. (2/5) There are several syntactical issues in the updated file. The import statements include unnecessary imports, and some required imports are missing. The `log` variable is used but not defined. The `@EJB` annotation is used incorrectly on a `JMSContext`. The `PublishOn.auto()` method doesn't exist. These issues would prevent the file from compiling and potentially change the original functionality.\n", "* mixtral\n", - "\t1. All identified issues have been correctly addressed, including replacing JavaEE imports with Jakarta EE equivalents and converting JMS to Quarkus-compatible messaging.\n", - "\t2. The updated file is syntactically valid, all necessary classes are imported correctly, and the original functionality is preserved while adapting to Quarkus standards.\n", - "\t3. The file is fully compatible with Quarkus, using appropriate annotations (@ApplicationScoped), Quarkus-specific messaging (SmallRye Reactive Messaging), and doesn't introduce any new issues that would make it incompatible with Quarkus.\n", + "\t1. (4/5) The updated file fixes most of the identified issues, including import statements and the @Stateless annotation. However, the JMS Topic replacement is not fully implemented as per the description.\n", + "\t2. (3/5) The file is mostly syntactically valid, but there are minor issues. The Emitter import should be from a Quarkus-specific package, and the @Resource annotation usage for Emitter is not correct in Quarkus context.\n", "* gpt-3\n", - "\t1. Some issues were fixed, but critical ones related to JMS were not addressed properly.\n", - "\t2. The file is syntactically valid and imports are correct, but it still uses JMS which is not ideal for Quarkus.\n", - "\t3. The file is not fully compatible with Quarkus as it still relies on JMS instead of using Quarkus-specific messaging solutions.\n", + "\t1. (3/5) The updated file addresses most of the issues, but not all. It correctly replaces javax imports with jakarta, and changes @Stateless to @ApplicationScoped. However, it doesn't replace the JMS Topic with a Micrometer Emitter.\n", + "\t2. (3/5) The file is mostly syntactically valid, but it still uses the @Resource annotation without importing it, and introduces an 'emitter' object that is not defined or injected. These issues may cause compilation errors.\n", "* gpt-4\n", - "\t1. All identified issues have been correctly addressed in the updated file.\n", - "\t2. The updated file is syntactically valid, imports are correct, and the original functionality is preserved.\n", - "\t3. The file is fully compatible with Quarkus, using appropriate annotations and APIs. No new issues are introduced.\n" - ] - } - ], - "source": [ - "plot_chart_and_print_reasoning(few_shot_hard_eval_output)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Few Shot (LLM Summary)\n", - "\n", - "In this section, we use a prompt that contains a summary of changes as solved examples. This summary will be generated by another LLM by looking at diffs of previous solved example. This differs from our last approach where we passed the diff directly to the LLM.\n", - "\n", - "For the example we are using, a default data set is not present in Kai right now. Therefore, we will create these examples from diffs. We will use the exact same prompt Kai uses to generate the LLM summary of solved examples.\n", - "\n", - "Lets create LLM summary for diffs we have as solved examples." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Easy Example\n", - "\n", - "The outputs of this experiment will be generated in `./data/outputs/using_kai/few_shot_easy_llm_summary/` directory for each model." - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "generating fix using model meta-llama-13b\n", - "generated fix using model meta-llama-13b, output present in ./data/outputs//using_kai/few_shot_easy_llm_summary/meta-llama-13b\n" + "\t1. (5/5) All identified issues have been correctly addressed in the updated file.\n", + "\t2. (4/5) The file is mostly syntactically valid, but there's a minor issue with the `@ApplicationScoped` annotation which should be from `jakarta.enterprise.context` instead of `jakarta.ejb`.\n" ] } ], "source": [ - "# run kai-fix for all models\n", - "for model in [META_LLAMA_13b]:\n", - " print(f\"generating fix using model {model}\")\n", - " run_kai_generate_fix(model, \"few_shot_easy_llm_summary\", \"./templates/few_shot/default.jinja\", EXAMPLE_EASY, llm_summary=True)\n", - " print(f\"generated fix using model {model}, output present in {OUTPUT_BASE_PATH}/using_kai/few_shot_easy_llm_summary/{model}\")" + "plot_chart_and_print_reasoning(few_shot_hard_summary_eval_output)" ] }, { @@ -1414,14 +1337,14 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 82, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1431,8 +1354,8 @@ "source": [ "plot_multibar_chart_from_eval_outputs([\n", " (zero_shot_easy_eval_output, \"Zero-Shot\"), \n", - " # (zero_shot_easy_with_info_eval_output, \"Zero-Shot w Info\"), \n", - " (few_shot_easy_eval_output, \"Few-Shot (Diff)\")])" + " (few_shot_easy_eval_output, \"Few-Shot (Diff)\"),\n", + " (few_shot_easy_summary_eval_output, \"Few-Shot (Summary)\")])" ] }, { @@ -1444,14 +1367,14 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 81, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAJOCAYAAAAUHTyCAAAAP3RFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMS5wb3N0MSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8kixA/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABgN0lEQVR4nO3de3zP9f//8fvbZufZsM2GMec5jBxSiE1hjkVKSWxCIuIjfdABo3LI+ZCkMolEJMkhlS0WOYscEhafEjnNZgzb6/eH395fbxu22fbei9v1cnlfLl7P1+v1fD1e79f79Z77+3WyGIZhCAAAAAAAmEIhexcAAAAAAACyjiAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAJIsFotGjhxpl2XHxMTIYrEoJibGLsu/FwQFBalt27b2LqNAi4yMVFBQkL3LAAAAuYAgD6DAiI6OlsViueVr8+bN9i7xrrz//vuKjo62dxlAgZWcnKyRI0fyoxYAAHfgaO8CAOBmo0aNUrly5TK0V6xY0Q7V5J73339fPj4+ioyMtGlv0qSJLl26JCcnJ/sUhvvCnDlzlJaWZu8ybis5OVlRUVGSpLCwMPsWAwBAAUaQB1DgtGrVSvXq1bN3GfmmUKFCcnFxsXcZdmEYhi5fvixXV1d7l3LPunjxotzd3VW4cGF7lwIAAHIJp9YDMJWrV6+qWLFi6t69e4ZxFy5ckIuLiwYPHixJunLlioYPH666devKy8tL7u7uaty4sdavX3/H5dzqeuKRI0fKYrHYtM2dO1ePPvqo/Pz85OzsrGrVqmnWrFk20wQFBem3335TbGys9VKB9COOt7pGfsmSJapbt65cXV3l4+Oj559/Xn/99VeGOj08PPTXX3+pffv28vDwkK+vrwYPHqzU1NQ7rue2bdsUHh4uHx8fubq6qly5cnrhhRdspklLS9PUqVMVEhIiFxcX+fr6qmXLltq2bZt1mmvXrmn06NGqUKGCnJ2dFRQUpNdff10pKSkZ3oe2bdtq7dq1qlevnlxdXTV79mxJ0vnz5zVw4EAFBgbK2dlZFStW1Lhx47J1FPm7777TAw88IBcXF1WrVk3Lli2zjjty5IgsFosmT56cYb6ff/5ZFotFn3/++W37T0lJ0YgRI1SxYkU5OzsrMDBQ//3vf23WMyIiQi4uLtq/f7/NvOHh4SpatKj+/vtvSf93KclPP/2k3r17q3jx4ipSpIi6deumc+fOZVj26tWr1bhxY7m7u8vT01Nt2rTRb7/9ZjNN+ufh8OHDat26tTw9PdWlSxfruBs/0/Hx8bJYLJowYYJmzpyp8uXLy83NTS1atNDx48dlGIZGjx6t0qVLy9XVVU888YTOnj17V3Xd7nMaHx8vX19fSVJUVJR1P7HXvSsAACjICPIACpyEhASdPn3a5nXmzBlJUuHChdWhQwctX75cV65csZlv+fLlSklJ0bPPPivperD/6KOPFBYWpnHjxmnkyJH6999/FR4erl27duVavbNmzVLZsmX1+uuva+LEiQoMDFTfvn01c+ZM6zRTpkxR6dKlFRwcrPnz52v+/Pl64403btlndHS0OnXqJAcHB40ZM0a9evXSsmXL9Mgjj+j8+fM206ampio8PFzFixfXhAkTFBoaqokTJ+rDDz+8bd2nTp1SixYtFB8fr6FDh2r69Onq0qVLhnsR9OjRwxqwx40bp6FDh8rFxcVmup49e2r48OGqU6eOJk+erNDQUI0ZM8a6LW508OBBde7cWc2bN9fUqVP1wAMPKDk5WaGhofrss8/UrVs3TZs2TY0aNdKwYcM0aNCg265HukOHDumZZ55Rq1atNGbMGDk6Ourpp5/WunXrJEnly5dXo0aNtGDBggzzLliwQJ6ennriiSdu2X9aWpoef/xxTZgwQe3atdP06dPVvn17TZ48Wc8884x1uqlTp8rX11cRERHWkDp79mx99913mj59ukqWLGnTb79+/bR//36NHDlS3bp104IFC9S+fXsZhmGdZv78+WrTpo08PDw0btw4vfXWW9q3b58eeeQRxcfH2/R37do1hYeHy8/PTxMmTFDHjh1v+74tWLBA77//vvr3769XX31VsbGx6tSpk958802tWbNGQ4YM0YsvvqhvvvnG+iNZTuq60+fU19fX+gNYhw4drPvJk08+edv6AQC4LxkAUEDMnTvXkJTpy9nZ2Trd2rVrDUnGN998YzN/69atjfLly1uHr127ZqSkpNhMc+7cOaNEiRLGCy+8YNMuyRgxYoR1OCIiwihbtmyGGkeMGGHc/NWZnJycYbrw8HCbWgzDMKpXr26EhoZmmHb9+vWGJGP9+vWGYRjGlStXDD8/P6NGjRrGpUuXrNOtXLnSkGQMHz7cpk5JxqhRo2z6rF27tlG3bt0My7rRV199ZUgytm7destpfvzxR0OS8corr2QYl5aWZhiGYezatcuQZPTs2dNm/ODBgw1Jxo8//mhtK1u2rCHJWLNmjc20o0ePNtzd3Y3ff//dpn3o0KGGg4ODcezYsduuS3q/S5cutbYlJCQYAQEBRu3ata1ts2fPNiQZ+/fvt7ZduXLF8PHxMSIiIm67jPnz5xuFChUyNmzYYNP+wQcfGJKMuLg4a1v6Z/Ttt982jhw5Ynh4eBjt27e3mS/98163bl3jypUr1vbx48cbkoyvv/7aMAzDSExMNLy9vY1evXrZzP/PP/8YXl5eNu3pn4ehQ4dmqP/mz/TRo0cNSYavr69x/vx5a/uwYcMMSUatWrWMq1evWts7d+5sODk5GZcvX85xXXf6nP77778Z9kUAAJARR+QBFDgzZ87UunXrbF6rV6+2jn/00Ufl4+OjL774wtp27tw5rVu3zubIqIODg/UGcmlpaTp79qyuXbumevXqaceOHblW743Xd6efTRAaGqojR44oISEh2/1t27ZNp06dUt++fW2unW/Tpo2Cg4P17bffZpjnpZdeshlu3Lixjhw5ctvleHt7S5JWrlypq1evZjrN0qVLZbFYNGLEiAzj0i8xWLVqlSRlOHL+6quvSlKGesuVK6fw8HCbtiVLlqhx48YqWrSozZkYzZo1U2pqqn766afbrosklSxZUh06dLAOp5+mvnPnTv3zzz+SpE6dOsnFxcXmqPzatWt1+vRpPf/887ftf8mSJapataqCg4Ntanz00UclyeaSjRYtWqh3794aNWqUnnzySbm4uFgvIbjZiy++aHP9ep8+feTo6Gh9X9etW6fz58+rc+fONst1cHDQQw89lOmlIn369LnT22X19NNPy8vLyzr80EMPSZKef/55OTo62rRfuXLFenlHTurKyecUAABkxM3uABQ49evXv+3N7hwdHdWxY0ctXLhQKSkpcnZ21rJly3T16lWbIC9J8+bN08SJE3XgwAGbsJrZXfFzKi4uTiNGjNCmTZuUnJxsMy4hIcEmJGXFn3/+KUmqUqVKhnHBwcHauHGjTVv6des3Klq0aKbXWd8oNDRUHTt2VFRUlCZPnqywsDC1b99ezz33nJydnSVJhw8fVsmSJVWsWLHb1luoUKEMTxXw9/eXt7e3dX3SZfbeHzp0SL/++muG9Uh36tSp266LdP2pBjffv6By5cqSrl9/nV5Pu3bttHDhQo0ePVrS9VPLS5UqZQ3kt3Lo0CHt378/yzVOmDBBX3/9tXbt2qWFCxfKz88v0/kqVapkM+zh4aGAgADrqemHDh2SpFvWV6RIEZthR0dHlS5d+rbrcqMyZcrYDKd/XgMDAzNtT/9cZbeunH5OAQBARgR5AKb07LPPavbs2Vq9erXat2+vxYsXKzg4WLVq1bJO89lnnykyMlLt27fXa6+9Jj8/P+s154cPH75t/zcHwnQ330Du8OHDeuyxxxQcHKxJkyYpMDBQTk5OWrVqlSZPnpwvj/tycHDI0XwWi0VffvmlNm/erG+++UZr167VCy+8oIkTJ2rz5s3y8PDIdn9Zkdkd6tPS0tS8eXP997//zXSe9ECeG7p166YlS5bo559/VkhIiFasWKG+ffuqUKHbn6SWlpamkJAQTZo0KdPxNwffnTt3WsP9nj171Llz5xzVm/4Zmj9/vvz9/TOMv/GouSQ5OzvfcV1udKvPz63ajf9/7X5268rp5xQAAGREkAdgSk2aNFFAQIC++OILPfLII/rxxx8z3Dzuyy+/VPny5bVs2TKbkJnZaeI3K1q0aIabyknKcHT5m2++UUpKilasWGFzZDOz04qzGnTLli0r6fpN4W4+2nnw4EHr+Nzy8MMP6+GHH9Y777yjhQsXqkuXLlq0aJF69uypChUqaO3atTp79uwtj8qXLVtWaWlpOnTokKpWrWptP3nypM6fP5+leitUqKCkpCQ1a9Ysx+vxxx9/yDAMm/f5999/lySbu7W3bNlSvr6+WrBggR566CElJyera9euWapx9+7deuyxx+64LS9evKju3burWrVqatiwocaPH68OHTrowQcfzDDtoUOH1LRpU+twUlKSTpw4odatW1uXK0l+fn539f7ktryoK6v7CAAA9zuukQdgSoUKFdJTTz2lb775RvPnz9e1a9cynFaffgTQuOHu37/88os2bdp0x/4rVKighIQE/frrr9a2EydO6KuvvrrjMhISEjR37twMfbq7u2f648DN6tWrJz8/P33wwQc2jzVbvXq19u/frzZt2tyxj6w4d+6cTd2S9MADD0iSdbkdO3aUYRiKiorKMH/6vOmBc8qUKTbj049cZ6XeTp06adOmTVq7dm2GcefPn9e1a9fu2Mfff/9ts30uXLigTz/9VA888IDNEWNHR0d17txZixcvVnR0tEJCQlSzZs0s1fjXX39pzpw5GcZdunRJFy9etA4PGTJEx44d07x58zRp0iQFBQUpIiIiw+P4JOnDDz+0uexj1qxZunbtmlq1aiXp+mPrihQponfffTfTexn8+++/d6w9L+RFXW5ubpKUpf0EAID7GUfkARQ4q1ev1oEDBzK0N2zYUOXLl7cOP/PMM5o+fbpGjBihkJAQm6PBktS2bVstW7ZMHTp0UJs2bXT06FF98MEHqlatmpKSkm5bw7PPPqshQ4aoQ4cOeuWVV5ScnKxZs2apcuXKNjfKa9GihZycnNSuXTv17t1bSUlJmjNnjvz8/HTixAmbPuvWratZs2bp7bffVsWKFeXn55fp9cWFCxfWuHHj1L17d4WGhqpz5846efKkpk6dqqCgIP3nP//J0vt4J/PmzdP777+vDh06qEKFCkpMTNScOXNUpEgRazhv2rSpunbtqmnTpunQoUNq2bKl0tLStGHDBjVt2lT9+vVTrVq1FBERoQ8//FDnz59XaGiotmzZonnz5ql9+/Y2R5tv5bXXXtOKFSvUtm1bRUZGqm7durp48aL27NmjL7/8UvHx8fLx8bltH5UrV1aPHj20detWlShRQp988olOnjyZ6Y8q6Y+4W79+vcaNG5el96tr165avHixXnrpJa1fv16NGjVSamqqDhw4oMWLF2vt2rWqV6+efvzxR73//vsaMWKE6tSpI0maO3euwsLC9NZbb2n8+PE2/V65ckWPPfaYOnXqpIMHD+r999/XI488oscff1zS9WvNZ82apa5du6pOnTp69tln5evrq2PHjunbb79Vo0aNNGPGjCytQ27Ki7pcXV1VrVo1ffHFF6pcubKKFSumGjVqqEaNGnm0FgAAmJQd75gPADZu9/g5ScbcuXNtpk9LSzMCAwOtj/m6WVpamvHuu+8aZcuWNZydnY3atWsbK1euzPTRcsrkkVffffedUaNGDcPJycmoUqWK8dlnn2X6+LkVK1YYNWvWNFxcXIygoCBj3LhxxieffGJIMo4ePWqd7p9//jHatGljeHp6GpKsj6K7+fFz6b744gujdu3ahrOzs1GsWDGjS5cuxv/+9z+baSIiIgx3d/cM655ZnTfbsWOH0blzZ6NMmTKGs7Oz4efnZ7Rt29bYtm2bzXTXrl0z3nvvPSM4ONhwcnIyfH19jVatWhnbt2+3TnP16lUjKirKKFeunFG4cGEjMDDQGDZsmPVRZenKli1rtGnTJtN6EhMTjWHDhhkVK1Y0nJycDB8fH6Nhw4bGhAkTbB7Plpn0fteuXWvUrFnTcHZ2NoKDg40lS5bccp7q1asbhQoVyvCe3s6VK1eMcePGGdWrVzecnZ2NokWLGnXr1jWioqKMhIQE48KFC0bZsmWNOnXq2Dy6zTAM4z//+Y9RqFAhY9OmTYZh/N/nPTY21njxxReNokWLGh4eHkaXLl2MM2fOZFj2+vXrjfDwcMPLy8twcXExKlSoYERGRtpsr1t9HtLHZfb4uffeey/DciRleO/S6735cYV3U1dmn9Off/7ZqFu3ruHk5MSj6AAAuAWLYdx0XiUAAPeB2rVrq1ixYvrhhx/ssvzo6Gh1795dW7duve1TGgAAAG7GNfIAgPvOtm3btGvXLnXr1s3epQAAAGQb18gDAO4be/fu1fbt2zVx4kQFBARkuEEiAACAGXBEHgBw3/jyyy/VvXt3Xb16VZ9//rlcXFzsXRIAAEC2cY08AAAAAAAmwhF5AAAAAABMhCAPAAAAAICJmPpmd2lpafr777/l6ekpi8Vi73IAAAAA3MQwDCUmJqpkyZIqVIjjiEBuMHWQ//vvvxUYGGjvMgAAAADcwfHjx1W6dGl7lwHcE0wd5D09PSVd/1IoUqSInasBAAAAcLMLFy4oMDDQ+n93AHfP1EE+/XT6IkWKEOQBAACAAoxLYYHcw0UqAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYiF2D/MiRI2WxWGxewcHB9iwJAAAAAIACzdHeBVSvXl3ff/+9ddjR0e4lAQAAAABQYNk9NTs6Osrf39/eZQAAAAAAYAp2v0b+0KFDKlmypMqXL68uXbro2LFjt5w2JSVFFy5csHkBAAAAAHA/sRiGYdhr4atXr1ZSUpKqVKmiEydOKCoqSn/99Zf27t0rT0/PDNOPHDlSUVFRGdoTEhJUpEiR/CgZAAAA94uRXvmwjIS8X4adXbhwQV5eXvyfHchFdg3yNzt//rzKli2rSZMmqUePHhnGp6SkKCUlxTp84cIFBQYG8qUAAACA3EeQzxUEeSD32f0a+Rt5e3urcuXK+uOPPzId7+zsLGdn53yuCgAAAACAgsPu18jfKCkpSYcPH1ZAQIC9SwEAAAAAoECya5AfPHiwYmNjFR8fr59//lkdOnSQg4ODOnfubM+yAAAAAAAosOx6av3//vc/de7cWWfOnJGvr68eeeQRbd68Wb6+vvYsCwAAAACAAsuuQX7RokX2XDwAAAAAAKZToK6RBwAAAAAAt0eQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEzE0d4FAMg/IfNC8nwZeyL25PkyAAC4V+T132b+LgP3Jo7IAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQKTJAfO3asLBaLBg4caO9SAAAAAAAosApEkN+6datmz56tmjVr2rsUAAAAAAAKNLsH+aSkJHXp0kVz5sxR0aJF7V0OAAAAAAAFmt2D/Msvv6w2bdqoWbNmd5w2JSVFFy5csHkBAAAAAHA/cbTnwhctWqQdO3Zo69atWZp+zJgxioqKyuOqAAAAAAAouOx2RP748eMaMGCAFixYIBcXlyzNM2zYMCUkJFhfx48fz+MqAQAAAAAoWOx2RH779u06deqU6tSpY21LTU3VTz/9pBkzZiglJUUODg428zg7O8vZ2Tm/SwUAAAAAoMCwW5B/7LHHtGfPHpu27t27Kzg4WEOGDMkQ4gEAAAAAgB2DvKenp2rUqGHT5u7uruLFi2doBwAAAAAA19n9rvUAAAAAACDr7HrX+pvFxMTYuwQAAAAAAAo0jsgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARBztXQAKjpB5IXna/56IPXnaPwAUGCO98nwRIeXK5Gn/fGcDAFBwcUQeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJuJo7wIA3GCkV972X65M3vYPAAAAIM9xRB4AAAAAABMhyAMAAAAAYCIEeQAAAAAATIQgDwAAAACAiRDkAQAAAAAwEYI8AAAAAAAmQpAHAAAAAMBECPIAAAAAAJgIQR4AAAAAABMhyAMAAAAAYCIEeQAAAAAATIQgDwAAAACAiRDkAQAAAAAwEYI8AAAAAAAmQpAHAAAAAMBECPIAAAAAAJgIQR4AAAAAABMhyAMAAAAAYCIEeQAAAAAATIQgDwAAAACAiRDkAQAAAAAwEYI8AAAAAAAmQpAHAAAAAMBE7BrkZ82apZo1a6pIkSIqUqSIGjRooNWrV9uzJAAAAAAACjS7BvnSpUtr7Nix2r59u7Zt26ZHH31UTzzxhH777Td7lgUAAAAAQIHlaM+Ft2vXzmb4nXfe0axZs7R582ZVr17dTlUBAAAAAFBw2TXI3yg1NVVLlizRxYsX1aBBg0ynSUlJUUpKinX4woUL+VUeAAAAAAAFgt2D/J49e9SgQQNdvnxZHh4e+uqrr1StWrVMpx0zZoyioqLyuUIAwL0maOi3edp/vEuedo/7RMi8kDxfxp6IPXm+DABA7rP7XeurVKmiXbt26ZdfflGfPn0UERGhffv2ZTrtsGHDlJCQYH0dP348n6sFAAAAAMC+7H5E3snJSRUrVpQk1a1bV1u3btXUqVM1e/bsDNM6OzvL2dk5v0sEAAAAkMdSU1N19epVe5cB2EXhwoXl4OCQ5entHuRvlpaWZnMdPAAAAIB7l2EY+ueff3T+/Hl7lwLYlbe3t/z9/WWxWO44rV2D/LBhw9SqVSuVKVNGiYmJWrhwoWJiYrR27Vp7lgUAAAAgn6SHeD8/P7m5uWUpxAD3EsMwlJycrFOnTkmSAgIC7jiPXYP8qVOn1K1bN504cUJeXl6qWbOm1q5dq+bNm9uzLAAAAAD5IDU11Rriixcvbu9yALtxdXWVdD0j+/n53fE0e7sG+Y8//tieiwcAAABgR+nXxLu5udm5EsD+0veDq1ev3jHI2/2u9QAAAADub5xOD2RvPyDIAwAAAABgIgR5AAAAALgPBAUFacqUKfYuA7mgwD1+DgAAAACChn6bb8uKH9smW9PHxMSoadOmtxwfFham9evX321Z2ZKcnKzRo0dr8eLF+uuvv+Tp6alq1app0KBBeuKJJ3JtOZGRkTp//ryWL1+ea30i+wjyAAAAAJANDRs21IkTJzK0r1ixQi+99JL69u2bo36vXLkiJyenHM370ksv6ZdfftH06dNVrVo1nTlzRj///LPOnDmTo/5QsHFqPQAAAABkg5OTk/z9/W1e586d0+DBg/X666/r6aefliTt3btXrVq1koeHh0qUKKGuXbvq9OnT1n7CwsLUr18/DRw4UD4+PgoPD5ckxcbGqn79+nJ2dlZAQICGDh2qa9eu3bamFStW6PXXX1fr1q0VFBSkunXrqn///nrhhRdspktOTtYLL7wgT09PlSlTRh9++KHN+D179ujRRx+Vq6urihcvrhdffFFJSUmSpJEjR2revHn6+uuvZbFYZLFYFBMTc7dvJ3KAIA8AAAAAd+H8+fN64oknFBYWptGjR1vbHn30UdWuXVvbtm3TmjVrdPLkSXXq1Mlm3nnz5snJyUlxcXH64IMP9Ndff6l169Z68MEHtXv3bs2aNUsff/yx3n777dvW4O/vr1WrVikxMfG2002cOFH16tXTzp071bdvX/Xp00cHDx6UJF28eFHh4eEqWrSotm7dqiVLluj7779Xv379JEmDBw9Wp06d1LJlS504cUInTpxQw4YNc/q24S5waj0AAAAA5FBaWpqee+45OTo6asGCBdZHiM2YMUO1a9fWu+++a532k08+UWBgoH7//XdVrlxZklSpUiWNHz/eOs0bb7yhwMBAzZgxQxaLRcHBwfr77781ZMgQDR8+XIUKZX4s9sMPP1SXLl1UvHhx1apVS4888oieeuopNWrUyGa61q1bW0/9HzJkiCZPnqz169erSpUqWrhwoS5fvqxPP/1U7u7u1vVo166dxo0bpxIlSsjV1VUpKSny9/fPvTcR2cYReQAAAADIoddff12bNm3S119/LU9PT2v77t27tX79enl4eFhfwcHBkqTDhw9bp6tbt65Nf/v371eDBg1snineqFEjJSUl6X//+5+OHTtm02f6DwVNmjTRkSNH9MMPP+ipp57Sb7/9psaNG1vPEEhXs2ZN678tFov8/f116tQp67Jr1aplDfHpy05LS7MetUfBkCtH5C9cuKAff/xRVapUUdWqVXOjSwAAAAAo0BYtWqQJEybo22+/VaVKlWzGJSUlWY9k3ywgIMD67xtDc1aULFlSu3btsg4XK1bM+u/ChQurcePGaty4sYYMGaK3335bo0aN0pAhQ6w30StcuLBNfxaLRWlpadmqAfaXoyDfqVMnNWnSRP369dOlS5dUr149xcfHyzAMLVq0SB07dsztOgEAAACgwNi1a5d69OihsWPHWm9Sd6M6depo6dKlCgoKkqNj1mNX1apVtXTpUhmGYT0qHxcXJ09PT5UuXVqFChVSxYoVs9RXtWrVdO3aNV2+fDlLd8OvWrWqoqOjdfHiResPDHFxcSpUqJCqVKki6fqN/lJTU7O8PsgbOTq1/qefflLjxo0lSV999ZUMw9D58+c1bdq0O96EAQAAAADM7PTp02rfvr3CwsL0/PPP659//rF5/fvvv3r55Zd19uxZde7cWVu3btXhw4e1du1ade/e/bZBuG/fvjp+/Lj69++vAwcO6Ouvv9aIESM0aNCgW14fL12/A/7s2bO1fft2xcfHa9WqVXr99dfVtGlTFSlSJEvr1aVLF7m4uCgiIkJ79+7V+vXr1b9/f3Xt2lUlSpSQJAUFBenXX3/VwYMHdfr0aV29ejV7bx5yRY6CfEJCgvUUjjVr1qhjx45yc3NTmzZtdOjQoVwtEAAAAAAKkm+//VZ//vmnVq1apYCAgAyvBx98UCVLllRcXJxSU1PVokULhYSEaODAgfL29r5tIC9VqpRWrVqlLVu2qFatWnrppZfUo0cPvfnmm7etKTw8XPPmzVOLFi1UtWpV9e/fX+Hh4Vq8eHGW18vNzU1r167V2bNn9eCDD+qpp57SY489phkzZlin6dWrl6pUqaJ69erJ19dXcXFxWe4fuSdHp9YHBgZq06ZNKlasmNasWaNFixZJks6dOycXF5dcLRAAAADA/Sd+bBt7l3BLERERioiIuON0lSpV0rJly245/lbPYA8NDdWWLVuyVdOwYcM0bNiw204THx+foe3G6+0lKSQkRD/++OMt+/D19dV3332XrdqQ+3IU5AcOHKguXbrIw8NDZcqUUVhYmKTrp9yHhITkZn0AAAAAAOAGOQryffv2Vf369XX8+HE1b97cempI+fLluUYeAAAAAIA8lOPHz9WrV081a9bU0aNHVaFCBTk6OqpNm4J7+gsAAAAAAPeCHN3sLjk5WT169JCbm5uqV6+uY8eOSZL69++vsWPH5mqBAAAAAADg/+QoyA8bNky7d+9WTEyMzc3tmjVrpi+++CLXigMAAAAAALZydGr98uXL9cUXX+jhhx+WxWKxtlevXl2HDx/OteIAAAAAAICtHB2R//fff+Xn55eh/eLFizbBHgAAAAAA5K4cBfl69erp22+/tQ6nh/ePPvpIDRo0yJ3KAAAAAABABjk6tf7dd99Vq1attG/fPl27dk1Tp07Vvn379PPPPys2Nja3a0S6kV5523+5Mnnb/z0gaOi3d57oLsS73Hka3APyeF8OyeN9eU/EnjztHzAN/i4DAOwkR0fkH3nkEe3evVvXrl1TSEiIvvvuO/n5+WnTpk2qW7dubtcIAAAAAMgmi8Wi5cuX59vyDh48KH9/fyUmJmZ73sjISLVv3946bBiGXnzxRRUrVkwWi0W7du3KtO3ZZ5/VxIkTc3EtzCHbR+SvXr2q3r1766233tKcOXPyoiYAAAAA97u8PuvFZlkJ2Z4lMjJS8+bNy9B+6NAhVaxYMTequq1///1Xw4cP17fffquTJ0+qaNGiqlWrloYPH65GjRrl2nLCwsL0wAMPaMqUKXecdtiwYerfv788PT0lSTExMWratKmk6z8qeHp6qnz58mrevLn+85//KCAgwDrv1KlTZRiGdXjNmjWKjo5WTEyMypcvLx8fn0zb3nzzTTVp0kQ9e/aUl1c+fmbsLNtH5AsXLqylS5fmRS0AAAAAYBotW7bUiRMnbF7lypXLl2V37NhRO3fu1Lx58/T7779rxYoVCgsL05kzZ/Jl+Tc7duyYVq5cqcjIyAzjDh48qL///ltbt27VkCFD9P3336tGjRras+f/Ltfz8vKSt7e3dfjw4cMKCAhQw4YN5e/vL0dHx0zbatSooQoVKuizzz7Lh7UsOHJ0an379u3z9RQNAAAAAChonJ2d5e/vb/NycHCQJH399deqU6eOXFxcVL58eUVFRenatWuSpMGDB6tt27bWfqZMmSKLxaI1a9ZY2ypWrKiPPvoo0+WeP39eGzZs0Lhx49S0aVOVLVtW9evX17Bhw/T444/bTHv69Gl16NBBbm5uqlSpklasWGEzPjY2VvXr15ezs7MCAgI0dOhQa52RkZGKjY3V1KlTZbFYZLFYFB8fn2lNixcvVq1atVSqVKkM4/z8/OTv76/KlSvr2WefVVxcnHx9fdWnTx/rNDeeWh8ZGan+/fvr2LFjslgsCgoKyrQtXbt27bRo0aJM67pX5ehmd5UqVdKoUaMUFxenunXryt3d3Wb8K6+8kivFAQAAAIDZbNiwQd26ddO0adPUuHFjHT58WC+++KIkacSIEQoNDdVHH32k1NRUOTg4KDY2Vj4+PoqJiVHLli31119/6fDhwwoLC8u0fw8PD3l4eGj58uV6+OGH5ezsfMtaoqKiNH78eL333nuaPn26unTpoj///FPFihXTX3/9pdatWysyMlKffvqpDhw4oF69esnFxUUjR47U1KlT9fvvv6tGjRoaNWqUJMnX1/eW61yvXr0svT+urq566aWX9J///EenTp3K8GjzqVOnqkKFCvrwww+1detWOTg4yMnJKUNbuvr16+udd95RSkrKbd+Le0mOgvzHH38sb29vbd++Xdu3b7cZZ7FYCPIAAAAA7nkrV66Uh4eHdbhVq1ZasmSJoqKiNHToUEVEREiSypcvr9GjR+u///2vRowYocaNGysxMVE7d+5U3bp19dNPP+m1116znvUcExOjUqVK3fJae0dHR0VHR6tXr1764IMPVKdOHYWGhurZZ59VzZo1baaNjIxU586dJV1/+ti0adO0ZcsWtWzZUu+//74CAwM1Y8YMWSwWBQcH6++//9aQIUM0fPhweXl5ycnJSW5ubvL397/te/Hnn39mOchLUnBwsCQpPj4+Q5D38vKSp6enHBwcbJabWZsklSxZUleuXNE///yjsmXLZrkGM8tRkD969Ghu1wEAAAAAptK0aVPNmjXLOpx+pvLu3bsVFxend955xzouNTVVly9fVnJysry9vVWrVi3FxMTIyclJTk5OevHFFzVixAglJSUpNjZWoaGhkq4f6W7VqpW1n9mzZ6tLly7q2LGj2rRpow0bNmjz5s1avXq1xo8fr48++sjmOvUbg727u7uKFCmiU6dOSZL279+vBg0ayGKxWKdp1KiRkpKS9L///U9lymT9MZiXLl2Si0vWn6WcfmO7G5edU66urpKk5OTku+7LLHIU5G+UmxsAAAAAAMzC3d0906PmSUlJioqK0pNPPplhXHrYDQsLU0xMjJydnRUaGqpixYqpatWq2rhxo2JjY/Xqq69KkurVq6ddu3ZZ5y9RooRNX82bN1fz5s311ltvqWfPnhoxYoRNkC9cuLDN8i0Wi9LS0u5mtTPl4+Ojc+fOZXn6/fv3S5LNte45dfbsWUm3Pu3/XpSjm91J0qeffqqQkBC5urrK1dVVNWvW1Pz583OzNgAAAAAwnTp16ujgwYOqWLFihlehQtcjWGhoqDZu3KgffvjBei18WFiYPv/8c/3+++/WNldXV5v50x/tlplq1arp4sWLWa6zatWq2rRpk81j3+Li4uTp6anSpUtLkpycnJSamnrHvmrXrq19+/ZlabmXLl3Shx9+qCZNmuRK+N67d69Kly4tHx+fu+7LLHJ0RH7SpEl666231K9fP+szCjdu3KiXXnpJp0+f1n/+859cLRIAAAAAzGL48OFq27atypQpo6eeekqFChXS7t27tXfvXr399tuSpCZNmigxMVErV67U2LFjJV0P8k899ZQCAgJUuXLlW/Z/5swZPf3003rhhRdUs2ZNeXp6atu2bRo/fryeeOKJLNfZt29fTZkyRf3791e/fv108OBBjRgxQoMGDbL+4BAUFKRffvlF8fHx8vDwULFixazjbhQeHq6ePXtab+B3o1OnTuny5ctKTEzU9u3bNX78eJ0+fVrLli3Lcq23s2HDBrVo0SJX+jKLHAX56dOna9asWerWrZu17fHHH1f16tU1cuRIgjwAAACA+1Z4eLhWrlypUaNGady4cSpcuLCCg4PVs2dP6zRFixZVSEiITp48ab3xW5MmTZSWlma9Pv5WPDw89NBDD2ny5Mk6fPiwrl69qsDAQPXq1Uuvv/56lussVaqUVq1apddee021atVSsWLF1KNHD7355pvWaQYPHqyIiAhVq1ZNly5d0tGjRzM9Hb5Vq1ZydHTU999/r/DwcJtxVapUkcVikYeHh8qXL68WLVpo0KBBd7yBXlZcvnxZy5cvt3l03/3AYtx4HkUWubi4aO/evRmuBzl06JBCQkJ0+fLlXCvwdi5cuCAvLy8lJCSoSJEi+bJMuxrplafdh5TL+s0scmJPxJ487T8/BA39Nk/7j3d5Lk/7z+ttLN0b2znPsS/bndn3ZYntXCCYfF+W2M53lMfbWLo/9uXb/Z/98uXLOnr0qMqVK5etG6WhYJo5c6ZWrFihtWvX5tsyZ82apa+++krfffddvi0zr2Rnf8jRNfIVK1bU4sWLM7R/8cUXqlSpUk66BAAAAACYWO/eva2XDOSXwoULa/r06fm2vIIiR6fWR0VF6ZlnntFPP/1kvUY+Li5OP/zwQ6YBHwAAAABwb3N0dNQbb7yRr8u88XKF+0mOjsh37NhRv/zyi3x8fLR8+XItX75cPj4+2rJlizp06JDbNQIAAAAAgP8vx8+Rr1u3rj777LPcrAUAAAAAANxBjo7Ir1q1KtMbGKxdu1arV6++66IAAAAAAEDmchTkhw4dqtTU1AzthmFo6NChd10UAAAAAADIXI6C/KFDh1StWrUM7cHBwfrjjz/uuigAAAAAAJC5HAV5Ly8vHTlyJEP7H3/8IXd397suCgAAAAAAZC5HQf6JJ57QwIEDdfjwYWvbH3/8oVdffVWPP/54rhUHAAAAAMgZi8Wi5cuX59vyDh48KH9//3x9jrxZ7Nu3T6VLl9bFixdzpb8cBfnx48fL3d1dwcHBKleunMqVK6fg4GAVL15cEyZMyJXCAAAAAKCgioyMlMViyfDKr0uN//33X/Xp00dlypSRs7Oz/P39FR4erri4uFxdTlhYmAYOHJilaYcNG6b+/fvL09PT2jZnzhzVqlVLHh4e8vb2Vu3atTVmzJhcrdEMqlWrpocffliTJk3Klf5y9Pg5Ly8v/fzzz1q3bp12794tV1dX1apVS40bN86VogAAAADc30LmheTbsvZE7MnRfC1bttTcuXNt2nx9fXOjpDvq2LGjrly5onnz5ql8+fI6efKkfvjhB505cyZfln+zY8eOaeXKlZo+fbq17ZNPPtHAgQM1bdo0hYaGKiUlRb/++qv27t1rlxrzgmEYSk1NlaPjnaN19+7d1atXLw0bNixL099Oto7Ib9q0SStXrpR0/TSNFi1ayM/PTxMmTFDHjh314osvKiUl5a4KAgAAAAAzSD8SfuPLwcFBkvT111+rTp06cnFxUfny5RUVFaVr165JkgYPHqy2bdta+5kyZYosFovWrFljbatYsaI++uijTJd7/vx5bdiwQePGjVPTpk1VtmxZ1a9fX8OGDctwqfPp06fVoUMHubm5qVKlSlqxYoXN+NjYWNWvX1/Ozs4KCAjQ0KFDrXVGRkYqNjZWU6dOtZ5xEB8fn2lNixcvVq1atVSqVClr24oVK9SpUyf16NFDFStWVPXq1dW5c2e988471mkyO+Lfvn17RUZGWoeDgoL09ttvq1u3bvLw8FDZsmW1YsUK/fvvv3riiSfk4eGhmjVratu2bdZ5oqOj5e3trZUrV6pKlSpyc3PTU089peTkZM2bN09BQUEqWrSoXnnlFZsnss2fP1/16tWTp6en/P399dxzz+nUqVPW8TExMbJYLFq9erXq1q0rZ2dnffbZZypUqJDN8qXr27Vs2bJKS0uTJDVv3lxnz55VbGxspu9hdmQryI8aNUq//fabdXjPnj3q1auXmjdvrqFDh+qbb765L0+TAAAAAIB0GzZsULdu3TRgwADt27dPs2fPVnR0tDXAhoaGauPGjdYAGRsbKx8fH8XExEiS/vrrLx0+fFhhYWGZ9u/h4SEPDw8tX778jgdSo6Ki1KlTJ/36669q3bq1unTporNnz1qX07p1az344IPavXu3Zs2apY8//lhvv/22JGnq1Klq0KCBevXqpRMnTujEiRMKDAy85TrXq1fPps3f31+bN2/Wn3/+maX37XYmT56sRo0aaefOnWrTpo26du2qbt266fnnn9eOHTtUoUIFdevWTYZhWOdJTk7WtGnTtGjRIq1Zs0YxMTHq0KGDVq1apVWrVmn+/PmaPXu2vvzyS+s8V69e1ejRo7V7924tX75c8fHxNj8qpBs6dKjGjh2r/fv36/HHH1ezZs0ynJ0xd+5cRUZGqlCh67HbyclJDzzwgDZs2HDX70e2gvyuXbv02GOPWYcXLVqk+vXra86cORo0aJCmTZumxYsX33VRAAAAAFDQrVy50hqqPTw89PTTT0u6Hp6HDh2qiIgIlS9fXs2bN9fo0aM1e/ZsSVLjxo2VmJionTt3yjAM/fTTT3r11VetQT4mJkalSpVSxYoVM12uo6OjoqOjNW/ePHl7e6tRo0Z6/fXX9euvv2aYNjIyUp07d1bFihX17rvvKikpSVu2bJEkvf/++woMDNSMGTMUHBys9u3bKyoqShMnTlRaWpq8vLzk5OQkNze3DGcc3OzPP/9UyZIlbdpGjBghb29vBQUFqUqVKoqMjNTixYutR6izo3Xr1urdu7cqVaqk4cOH68KFC3rwwQf19NNPq3LlyhoyZIj279+vkydPWue5evWqZs2apdq1a6tJkyZ66qmntHHjRn388ceqVq2a2rZtq6ZNm2r9+vXWeV544QW1atVK5cuX18MPP6xp06Zp9erVSkpKsqln1KhRat68uSpUqKBixYqpZ8+e+vzzz60/rOzYsUN79uxR9+7dbeYrWbJkrvywka0gf+7cOZUoUcI6HBsbq1atWlmHH3zwQR0/fvyuiwIAAACAgq5p06batWuX9TVt2jRJ0u7duzVq1CibkJ9+VDs5OVne3t6qVauWYmJitGfPHjk5OenFF1/Uzp07lZSUpNjYWIWGhkq6fqT7xn4WLFgg6fo18n///bdWrFihli1bKiYmRnXq1FF0dLRNjTVr1rT+293dXUWKFLGeKr5//341aNBAFovFOk2jRo2UlJSk//3vf9l6Ly5duiQXFxebtoCAAG3atEl79uzRgAEDdO3aNUVERKhly5bZDvM3rkd6Jg0JCcnQduNp8G5ubqpQoYLNNEFBQfLw8LBpu3Ge7du3q127dipTpow8PT2t2+HYsWM29dx89kH79u3l4OCgr776StL1U/ubNm2qoKAgm+lcXV2VnJyc9RW/hWwF+RIlSujo0aOSpCtXrmjHjh16+OGHreMTExNVuHDhuy4KAAAAAAo6d3d3VaxY0foKCAiQJCUlJSkqKsom5O/Zs0eHDh2yht2wsDDFxMRYQ3uxYsVUtWpVbdy40SbI16tXz6afG6+Bd3FxUfPmzfXWW2/p559/VmRkpEaMGGFT4835zGKx5OiI+J34+Pjo3LlzmY6rUaOG+vbtq88++0zr1q3TunXrrNeJFypUyOZ0eOn6kfSb3bge6T88ZNZ247pltu63ez8uXryo8PBwFSlSRAsWLNDWrVutwfzKlSs287m7u9sMOzk5qVu3bpo7d66uXLmihQsX6oUXXsiwHmfPns2VGyJm61Z5rVu31tChQzVu3DgtX75cbm5uNneq//XXX21+8QAAAACA+02dOnV08ODBW54aL12/Tv6TTz6Ro6OjWrZsKel6uP/888/1+++/W6+Pd3V1vW0/N6pWrVq2nhtftWpVLV26VIZhWINwXFycPD09Vbp0aUnXA+qNN4O7ldq1a2vfvn1ZqlGS9Xnqvr6+OnHihHV8amqq9u7dq6ZNm2Z5PXLLgQMHdObMGY0dO9Z6L4Cbb2B3Oz179lSNGjX0/vvv69q1a3ryySczTLN371499dRTd11rto7Ijx49Wo6OjgoNDdWcOXM0Z84cOTk5Wcd/8sknatGixV0XBQAAAABmNXz4cH366aeKiorSb7/9pv3792vRokV68803rdM0adJEiYmJWrlypTW0h4WFacGCBQoICFDlypVv2f+ZM2f06KOP6rPPPtOvv/6qo0ePasmSJRo/fryeeOKJLNfZt29fHT9+XP3799eBAwf09ddfa8SIERo0aJD1Bm1BQUH65ZdfFB8fr9OnT9/yaH54eLg2bdpkE/r79Omj0aNHKy4uTn/++ac2b96sbt26ydfXVw0aNJAkPfroo/r222/17bff6sCBA+rTp4/Onz+f5XXITWXKlJGTk5OmT5+uI0eOaMWKFRo9enSW569ataoefvhhDRkyRJ07d5arq6vN+Pj4eP31119q1qzZXdearSDv4+Ojn376SefOndO5c+fUoUMHm/FLlizJcCoHAAAAANxPwsPDtXLlSn333Xd68MEH9fDDD2vy5MkqW7asdZqiRYsqJCREvr6+Cg4OlnQ93KelpVlPq78VDw8PPfTQQ5o8ebKaNGmiGjVq6K233lKvXr00Y8aMLNdZqlQprVq1Slu2bFGtWrX00ksvqUePHjY/OAwePFgODg6qVq2afH19M1wrnq5Vq1ZydHTU999/b21r1qyZNm/ebL0hXceOHeXi4qIffvhBxYsXl3T95nIRERHq1q2bQkNDVb58ebscjZeunx0QHR2tJUuWqFq1aho7dqwmTJiQrT569OihK1euZHpa/eeff64WLVrYfA5yymLcfEGCiVy4cEFeXl5KSEhQkSJF7F1O3hvplafdh5Qrk6f974nYk6f954egod/maf/xLs/laf95vY2le2M75zn2Zbsz+74ssZ0LBJPvyxLb+Y7yeBtL98e+fLv/s1++fFlHjx5VuXLlMtwoDeYzc+ZMrVixQmvXrrV3KXYzevRoLVmyJMMTBK5cuaJKlSpp4cKFatSoUabzZmd/yNY18gAAAAAAZKZ37946f/68EhMT5enpae9y8lVSUpLi4+M1Y8YMvf322xnGHzt2TK+//votQ3x2EeQBAAAAAHfN0dFRb7zxhr3LsIt+/frp888/V/v27TM9rT79yQa5hSAPAAAAAMBdiI6OVnR0dL4tL1s3uwMAAAAAAPZFkAcAAAAAwEQI8gAAAADsysQP0gJyTXb2A66RBwAA96S8f8xgnnaPLGAbm1/hwoUlScnJyXJ1dbVzNYB9JScnS/q//eJ2CPIAAAAA7MLBwUHe3t46deqUJMnNzU0Wi8XOVQH5yzAMJScn69SpU/L29paDg8Md5yHIAwAAALAbf39/SbKGeeB+5e3tbd0f7oQgDwAAAMBuLBaLAgIC5Ofnp6tXr9q7HMAuChcunKUj8ekI8gAAAADszsHBIVtBBrifcdd6AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARuwb5MWPG6MEHH5Snp6f8/PzUvn17HTx40J4lAQAAAABQoNk1yMfGxurll1/W5s2btW7dOl29elUtWrTQxYsX7VkWAAAAAAAFlqM9F75mzRqb4ejoaPn5+Wn79u1q0qSJnaoCAAAAAKDgKlDXyCckJEiSihUrZudKAAAAAAAomOx6RP5GaWlpGjhwoBo1aqQaNWpkOk1KSopSUlKswxcuXMiv8gAAAAAAKBAKzBH5l19+WXv37tWiRYtuOc2YMWPk5eVlfQUGBuZjhQAAAAAA2F+BCPL9+vXTypUrtX79epUuXfqW0w0bNkwJCQnW1/Hjx/OxSgAAAAAA7M+up9YbhqH+/fvrq6++UkxMjMqVK3fb6Z2dneXs7JxP1QEAAAAAUPDYNci//PLLWrhwob7++mt5enrqn3/+kSR5eXnJ1dXVnqUBAAAAAFAg2fXU+lmzZikhIUFhYWEKCAiwvr744gt7lgUAAAAAQIFl91PrAQAAAABA1hWIm90BAAAAAICsIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBFHexdwrwga+m2eLyPeJc8XAdz32JcBAABQ0HFEHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwEQI8gAAAAAAmAhBHgAAAAAAEyHIAwAAAABgIgR5AAAAAABMhCAPAAAAAICJEOQBAAAAADARgjwAAAAAACZCkAcAAAAAwETsGuR/+ukntWvXTiVLlpTFYtHy5cvtWQ4AAAAAAAWeXYP8xYsXVatWLc2cOdOeZQAAAAAAYBqO9lx4q1at1KpVK3uWAAAAAACAqXCNPAAAAAAAJmLXI/LZlZKSopSUFOvwhQsX7FgNAAAAAAD5z1RH5MeMGSMvLy/rKzAw0N4lAQAAAACQr0wV5IcNG6aEhATr6/jx4/YuCQAAAACAfGWqU+udnZ3l7Oxs7zIAAAAAALAbuwb5pKQk/fHHH9bho0ePateuXSpWrJjKlCljx8oAAAAAACiY7Brkt23bpqZNm1qHBw0aJEmKiIhQdHS0naoCAAAAAKDgsmuQDwsLk2EY9iwBAAAAAABTMdXN7gAAAAAAuN8R5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYSIEI8jNnzlRQUJBcXFz00EMPacuWLfYuCQAAAACAAsnuQf6LL77QoEGDNGLECO3YsUO1atVSeHi4Tp06Ze/SAAAAAAAocOwe5CdNmqRevXqpe/fuqlatmj744AO5ubnpk08+sXdpAAAAAAAUOHYN8leuXNH27dvVrFkza1uhQoXUrFkzbdq0yY6VAQAAAABQMDnac+GnT59WamqqSpQoYdNeokQJHThwIMP0KSkpSklJsQ4nJCRIki5cuJC3hWZBWkpyni/jgsXI0/5TL6Xmaf8FYTvdrbzezmbfxpL5tzP78p2ZfRtL5t+XJbZzVph9O/OdfWdm38bS/bEvp9dgGHn/fgL3C7sG+ewaM2aMoqKiMrQHBgbaoZr855XnS9ifp7179cn7NTA7s29jie2cFWbfzmzjO8ufd4jtbG9m35cltvOdsC/nrsTERHl5FZx6ADOza5D38fGRg4ODTp48adN+8uRJ+fv7Z5h+2LBhGjRokHU4LS1NZ8+eVfHixWWxWPK83oLkwoULCgwM1PHjx1WkSBF7l4M8wDa+P7Cd731s4/sD2/n+wHbOGcMwlJiYqJIlS9q7FOCeYdcg7+TkpLp16+qHH35Q+/btJV0P5z/88IP69euXYXpnZ2c5OzvbtHl7e+dDpQVXkSJF+ENyj2Mb3x/Yzvc+tvH9ge18f2A7Zx9H4oHcZfdT6wcNGqSIiAjVq1dP9evX15QpU3Tx4kV1797d3qUBAAAAAFDg2D3IP/PMM/r33381fPhw/fPPP3rggQe0Zs2aDDfAAwAAAAAABSDIS1K/fv0yPZUet+bs7KwRI0ZkuNQA9w628f2B7XzvYxvfH9jO9we2M4CCwmLwHAgAAAAAAEyjkL0LAAAAAAAAWUeQBwAAAADARAjydhYWFqaBAwdah4OCgjRlyhS71ZMfbl7n+8H9uJ0L2jreuA0KWm15KTIy0vp4T+SumJgYWSwWnT9//r5cPgAAsB+CfA7cj0FUki5fvqzIyEiFhITI0dEx03CwceNGNWrUSMWLF5erq6uCg4M1efLk/C82F9yv23nkyJGyWCwZXu7u7jbTLVmyRMHBwXJxcVFISIhWrVplp4qzZtmyZRo9erS9y8h3U6dOVXR0tHX4fv1c54WGDRvqxIkTWX42cnx8vCwWi3bt2pW3hcFuLBaLli9ffsfpli1bpnr16snb21vu7u564IEHNH/+/LwvELkiq9v5RosWLZLFYuGHVQC5pkDctR7mkJqaKldXV73yyitaunRpptO4u7urX79+qlmzptzd3bVx40b17t1b7u7uevHFF/O5YuTE4MGD9dJLL9m0PfbYY3rwwQetwz///LM6d+6sMWPGqG3btlq4cKHat2+vHTt2qEaNGvldcpYUK1bM3iVk2ZUrV+Tk5JQrfWU1ZCL7nJyc5O/vn+v95ub2R8FUrFgxvfHGGwoODpaTk5NWrlyp7t27y8/PT+Hh4fYuD7ksPj5egwcPVuPGje1dCoB7yD1/RD4sLEz9+/fXwIEDVbRoUZUoUUJz5szRxYsX1b17d3l6eqpixYpavXq1dZ69e/eqVatW8vDwUIkSJdS1a1edPn1a0vXTVGNjYzV16lTrkcr4+HilpqaqR48eKleunFxdXVWlShVNnTr1ruufNGmSQkJC5O7ursDAQPXt21dJSUnW8dHR0fL29tbKlStVpUoVubm56amnnlJycrLmzZunoKAgFS1aVK+88opSU1Ot882fP1/16tWTp6en/P399dxzz+nUqVO3rcXd3V2zZs1Sr169bvmf19q1a6tz586qXr26goKC9Pzzzys8PFwbNmywme7atWvq16+fvLy85OPjo7feekt38wAFtnPubWcPDw/5+/tbXydPntS+ffvUo0cP6zRTp05Vy5Yt9dprr6lq1aoaPXq06tSpoxkzZtj0lZiYqM6dO8vd3V2lSpXSzJkz7/q9yqmbj0TfqTaLxaLZs2erbdu2cnNzU9WqVbVp0yb98ccfCgsLk7u7uxo2bKjDhw/fdrnXrl3TK6+8Im9vbxUvXlxDhgxRRESEzVGZsLAw9evXTwMHDpSPj4/1P/JZ/VysXbtWVatWlYeHh1q2bKkTJ05Yp7nx1Ppbfa6l2+8P94vsfo/cfGr7Cy+8oJo1ayolJUXS9UBeu3ZtdevWTZJUrlw5Sde/Jy0Wi8LCwiT93zZ65513VLJkSVWpUkVSzvZf5FxiYqK6dOkid3d3BQQEaPLkyRkuyRk9evQtvzeCgoIkSR06dJDFYrEOZyYsLEwdOnRQ1apVVaFCBQ0YMEA1a9bUxo0b83ANIeXvdpauHwTp0qWLoqKiVL58+TxaKwD3o3s+yEvSvHnz5OPjoy1btqh///7q06ePnn76aTVs2FA7duxQixYt1LVrVyUnJ+v8+fN69NFHVbt2bW3btk1r1qzRyZMn1alTJ0nXA0yDBg3Uq1cvnThxQidOnFBgYKDS0tJUunRpLVmyRPv27dPw4cP1+uuva/HixXdVe6FChTRt2jT99ttvmjdvnn788Uf997//tZkmOTlZ06ZN06JFi7RmzRrFxMSoQ4cOWrVqlVatWqX58+dr9uzZ+vLLL63zXL16VaNHj9bu3bu1fPlyxcfHKzIy8q5qzczOnTv1888/KzQ01KZ93rx5cnR01JYtWzR16lRNmjRJH3300V0ti+2cN9v5o48+UuXKlW2OJGzatEnNmjWzmS48PFybNm2yaXvvvfdUq1Yt7dy5U0OHDtWAAQO0bt26bC0/r2SlttGjR6tbt27atWuXgoOD9dxzz6l3794aNmyYtm3bJsMw1K9fv9suZ9y4cVqwYIHmzp2ruLg4XbhwIdNTMufNmycnJyfFxcXpgw8+kJT1z8WECRM0f/58/fTTTzp27JgGDx6caS23+lzfaX+4n2Tne+Rm06ZN08WLFzV06FBJ0htvvKHz589bf+DasmWLJOn777/XiRMntGzZMuu8P/zwgw4ePKh169Zp5cqVkvLvexrXDRo0SHFxcVqxYoXWrVunDRs2aMeOHTbT3O57Y+vWrZKkuXPn6sSJE9bhOzEMw7r9mzRpkrsrhQzyezuPGjVKfn5+Nj+GA0CuMO5xoaGhxiOPPGIdvnbtmuHu7m507drV2nbixAlDkrFp0yZj9OjRRosWLWz6OH78uCHJOHjwoLXPAQMG3HHZL7/8stGxY8c71ndjX2XLljUmT558y+mXLFliFC9e3Do8d+5cQ5Lxxx9/WNt69+5tuLm5GYmJida28PBwo3fv3rfsd+vWrYYkm3luJyIiwnjiiSduOb5UqVKGk5OTUahQIWPUqFE240JDQ42qVasaaWlp1rYhQ4YYVatWzdKyM8N2vi63t/OlS5eMokWLGuPGjbNpL1y4sLFw4UKbtpkzZxp+fn7W4bJlyxotW7a0meaZZ54xWrVqlaVl57Ybt0FWapNkvPnmm9bhTZs2GZKMjz/+2Nr2+eefGy4uLrddbokSJYz33nvPOnzt2jWjTJkyNvtPaGioUbt27TuuQ1Y+FzNnzjRKlChhHb55X83sc52V/eF+kN3vkfXr1xuSjHPnzlnH//zzz0bhwoWNt956y3B0dDQ2bNhgHXf06FFDkrFz506b5UZERBglSpQwUlJSblvfzftvZstHzly4cMEoXLiwsWTJEmvb+fPnDTc3t2x/b3z11VdZWub58+cNd3d3w9HR0XB2drb5bkHeyO/tvGHDBqNUqVLGv//+axjGnf/vBADZcV8cka9Zs6b13w4ODipevLhCQkKsbSVKlJAknTp1Srt379b69evl4eFhfQUHB0vSHU+hnTlzpurWrStfX195eHjoww8/1LFjxyRJGzZssOlzwYIFWar9+++/12OPPaZSpUrJ09NTXbt21ZkzZ2yOBrm5ualChQo26xMUFCQPDw+bthtPydy+fbvatWunMmXKyNPT03rEPL3e6tWrW2tt1apVlmq90YYNG7Rt2zZ98MEHmjJlij7//HOb8Q8//LAsFot1uEGDBjp06JDNaeHZxXbO/e381VdfKTExUREREVlaj5s1aNAgw/D+/ftz1Fduy0ptN36m0j8/N3+mLl++rAsXLujYsWM22/7dd99VQkKCTp48qfr161vncXBwUN26dTPUk1lbTj4XAQEB2T79+m72h3tNdr5HMtOgQQMNHjxYo0eP1quvvqpHHnkkS8sNCQnJcF38nfZf5J4jR47o6tWrNvuql5eX9TKHdNn9TsvseyGdp6endu3apa1bt+qdd97RoEGDFBMTkzsrhEzl53ZOTExU165dNWfOHPn4+OTuigCA7pOb3RUuXNhm2GKx2LSlB8q0tDQlJSWpXbt2GjduXIZ+AgICbrmMRYsWafDgwZo4caIaNGggT09Pvffee/rll18kSfXq1bO5U3H6fwZvJz4+Xm3btlWfPn30zjvvqFixYtq4caN69OihK1euyM3NLUvrl96WlpYmSbp48aLCw8MVHh6uBQsWyNfXV8eOHVN4eLiuXLkiSVq1apWuXr0qSXJ1db1jrTdLvxY0JCREJ0+e1MiRI9W5c+ds95MdbOfc384fffSR2rZtm2E90q+dv9HJkyfz5MZf9pTZ5+dWn6mSJUvabPvs3lzv5qcC3M3nwsjm/SZyuj/ci7LzPZKZtLQ0xcXFycHBQX/88UeWl3vz9s/K/ouC73bfC4UKFVLFihUlSQ888ID279+vMWPGWO+dAPPIbDsfPnxY8fHxateunbU9/XvD0dFRBw8etPkRFgCy674I8tlRp04dLV26VEFBQXJ0zPztcXJyynDkOC4uTg0bNlTfvn2tbTceyXJ1dbX+wc6q7du3Ky0tTRMnTlShQtdPnrjba7El6cCBAzpz5ozGjh2rwMBASdK2bdtspilbtuxdLyddWlqa9eZP6dKDb7rNmzerUqVKcnBwyLXl3g7b+brbbeejR49q/fr1WrFiRYZxDRo00A8//GBz87h169ZlOIqxefPmDMNVq1bN7qrkidyuzdHRMdNtX6JECW3dutV67Wtqaqp27NihBx544Lb95dXnIrPPdVb2B2TNe++9pwMHDig2Nlbh4eGaO3euunfvLknWI+5ZOfMoK/svck/58uVVuHBhbd26VWXKlJEkJSQk6Pfff7e5bv1O3xuFCxe22b63+l7ITGZ/K5G78nM7u7m5ac+ePTZtb775phITEzV16lTrfg0AOXVfnFqfHS+//LLOnj2rzp07a+vWrTp8+LDWrl2r7t27W7+0g4KC9Msvvyg+Pl6nT59WWlqaKlWqpG3btmnt2rX6/fff9dZbb2X5Rje3UrFiRV29elXTp0/XkSNHNH/+fOtNsO5GmTJl5OTkZO13xYoVWX6+9r59+7Rr1y6dPXtWCQkJ2rVrl82v0DNnztQ333yjQ4cO6dChQ/r44481YcIEPf/88zb9HDt2TIMGDdLBgwf1+eefa/r06RowYMBdr1tWsZ3v7JNPPlFAQECmp9wPGDBAa9as0cSJE3XgwAGNHDlS27Zty3Djt7i4OI0fP16///67Zs6cqSVLluTrdr6d/Kqtf//+GjNmjL7++msdPHhQAwYM0Llz52wuLclMXn0uMvtcZ2V/wJ3t3LlTw4cP10cffaRGjRpp0qRJGjBggI4cOSJJ8vPzk6urq/VmggkJCbfs6273X2SPp6enIiIi9Nprr2n9+vX67bff1KNHDxUqVMhmX73T90ZQUJB++OEH/fPPPzp37twtlzdmzBitW7dOR44c0f79+zVx4kTNnz8/w99K5K783M4uLi6qUaOGzcvb21uenp6qUaMGj5gEcNcI8jcpWbKk4uLilJqaqhYtWigkJEQDBw6Ut7e39ajY4MGD5eDgoGrVqllPd+zdu7eefPJJPfPMM3rooYd05swZm6O2OVGrVi1NmjRJ48aNU40aNbRgwQKNGTPmrtfR19dX0dHRWrJkiapVq6axY8dqwoQJWZq3devWql27tr755hvFxMSodu3aql27tnV8Wlqahg0bpgceeED16tXTzJkzNW7cOI0aNcqmn27duunSpUuqX7++Xn75ZQ0YMCBfnzPPdr69tLQ0RUdHKzIyMtOzJBo2bKiFCxfqww8/VK1atfTll19q+fLlGZ4h/+qrr2rbtm2qXbu23n77bU2aNKnAPCM5v2obMmSIOnfurG7duqlBgwby8PBQeHi4XFxcbjtfXn0uMvtcZ2V/wO1dvnxZzz//vCIjI62n0r744otq2rSpunbtqtTUVDk6OmratGmaPXu2SpYsqSeeeOKW/d3N/oucmTRpkho0aKC2bduqWbNmatSokapWrWqzr97pe2PixIlat26dAgMDbf423uzixYvq27evqlevrkaNGmnp0qX67LPP1LNnzzxdR+TvdgaAvGQxsnsxJQAgx9LS0lS1alV16tSJI6xAAXbx4kWVKlVKEydOVI8ePRQUFKSBAwfaXFIE82M7AzArLoYEgDz0559/6rvvvlNoaKhSUlI0Y8YMHT16VM8995y9SwNwg507d+rAgQOqX7++EhISrGeS3e7MCZgP2xnAvYIgDwB5qFChQoqOjtbgwYNlGIZq1Kih77//vsDc9A/A/5kwYYIOHjwoJycn1a1bVxs2bODRYfcgtjOAewGn1gMAAAAAYCLcxQgAAAAAABMhyAMAAAAAYCIEeQAAAAAATIQgDwAAAACAiRDkAQAAAAAwEYI8AKBAiomJkcVi0fnz57M8T1BQkKZMmZJnNQEAABQEBHkAQI5ERkbKYrHopZdeyjDu5ZdflsViUWRkZP4XBgAAcI8jyAMAciwwMFCLFi3SpUuXrG2XL1/WwoULVaZMGTtWBgAAcO8iyAMAcqxOnToKDAzUsmXLrG3Lli1TmTJlVLt2bWtbSkqKXnnlFfn5+cnFxUWPPPKItm7datPXqlWrVLlyZbm6uqpp06aKj4/PsLyNGzeqcePGcnV1VWBgoF555RVdvHgx09oMw9DIkSNVpkwZOTs7q2TJknrllVdyZ8UBAADsiCAPALgrL7zwgubOnWsd/uSTT9S9e3ebaf773/9q6dKlmjdvnnbs2KGKFSsqPDxcZ8+elSQdP35cTz75pNq1a6ddu3apZ8+eGjp0qE0fhw8fVsuWLdWxY0f9+uuv+uKLL7Rx40b169cv07qWLl2qyZMna/bs2Tp06JCWL1+ukJCQXF57AACA/EeQBwDcleeff14bN27Un3/+qT///FNxcXF6/vnnreMvXryoWbNm6b333lOrVq1UrVo1zZkzR66urvr4448lSbNmzVKFChU0ceJEValSRV26dMlwff2YMWPUpUsXDRw4UJUqVVLDhg01bdo0ffrpp7p8+XKGuo4dOyZ/f381a9ZMZcqUUf369dWrV688fS8AAADyA0EeAHBXfH191aZNG0VHR2vu3Llq06aNfHx8rOMPHz6sq1evqlGjRta2woULq379+tq/f78kaf/+/XrooYds+m3QoIHN8O7duxUdHS0PDw/rKzw8XGlpaTp69GiGup5++mldunRJ5cuXV69evfTVV1/p2rVrubnqAAAAduFo7wIAAOb3wgsvWE9xnzlzZp4sIykpSb179870OvfMbqwXGBiogwcP6vvvv9e6devUt29fvffee4qNjVXhwoXzpEYAAID8wBF5AMBda9mypa5cuaKrV68qPDzcZlyFChXk5OSkuLg4a9vVq1e1detWVatWTZJUtWpVbdmyxWa+zZs32wzXqVNH+/btU8WKFTO8nJycMq3L1dVV7dq107Rp0xQTE6NNmzZpz549ubHKAAAAdsMReQDAXXNwcLCeJu/g4GAzzt3dXX369NFrr72mYsWKqUyZMho/frySk5PVo0cPSdJLL72kiRMn6rXXXlPPnj21fft2RUdH2/QzZMgQPfzww+rXr5969uwpd3d37du3T+vWrdOMGTMy1BQdHa3U1FQ99NBDcnNz02effSZXV1eVLVs2b94EAACAfMIReQBArihSpIiKFCmS6bixY8eqY8eO6tq1q+rUqaM//vhDa9euVdGiRSVdPzV+6dKlWr58uWrVqqUPPvhA7777rk0fNWvWVGxsrH7//Xc1btxYtWvX1vDhw1WyZMlMl+nt7a05c+aoUaNGqlmzpr7//nt98803Kl68eO6uOAAAQD6zGIZh2LsIAAAAAACQNRyRBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAiBHkAAAAAAEyEIA8AAAAAgIkQ5AEAAAAAMBGCPAAAAAAAJkKQBwAAAADARAjyAAAAAACYCEEeAAAAAAATIcgDAAAAAGAi/w+Tk7oZsgf4wAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1462,8 +1385,8 @@ "\n", "plot_multibar_chart_from_eval_outputs([\n", " (zero_shot_hard_eval_output, \"Zero-Shot\"), \n", - " # (zero_shot_hard_with_info_eval_output, \"Zero-Shot w Info\"),\n", - " (few_shot_hard_eval_output, \"Few-Shot (Diff)\")\n", + " (few_shot_hard_eval_output, \"Few-Shot (Diff)\"),\n", + " (few_shot_hard_summary_eval_output, \"Few-Shot (Summary)\")\n", " ]) " ] }, @@ -1473,11 +1396,65 @@ "source": [ "## Learnings\n", "\n", - "1. Few Shot prompts work as long as the underlying model is trained with code for target technology. The accuracy of fixes degrades as files become larger, and/or fixes become more complex. \n", + "### About models\n", + "\n", + " * IBM Granite is very unpredictable, and we could not reliably determine the effect of adding analysis information on the quality of responses with it. It was hard to determine a pattern and correlate information.\n", + "\n", + " * Meta LLAMA 70b seemed to be performing more consistently (in all experiments) than others with relatively good quality of fixes.\n", + "\n", + " * GPT-4 performed better than others in Zero Shot experiments. However, it seemed to be fixing more than necessary, at times introducing new issues.\n", + "\n", + " * GPT-3 and LLAMA 13b have been comparable in terms of quality of fixes. On ther other hand, LLAMA 70b and GPT-4 are comparable.\n", + "\n", + " * Mixtral very often had problems returning a complete response, formatting etc. As a result, in some instances, we had to run an experiment multiple times to get results.\n", + "\n", + "### Zero Shot Prompts\n", + "\n", + " * Zero Shot prompts work as long as the underlying model is trained with code for target technology. No matter the model, the accuracy of fixes degrades as files become larger, and/or fixes become more complex. \n", + "\n", + " * Without any additional information from static code analysis, it was harder to get quality responses. Merely including line numbers of the incidents in the prompt did not help much. A text description about an issue that hints about a possible solution produced way better responses than line numbers alone. We believe that annotating input file with line numbers will produce a better output.\n", + "\n", + " * Zero Shot prompts may fix your issue but chances of them introducing new issues is higher because the issues are not pinpointed.\n", + "\n", + "### Few Shot with Solved Example Diffs\n", + "\n", + " * Prompts that contain diffs of actual solved examples produce much better results than any of the previous methods. You can observe this in the evaluation charts above. No matter how smart / not-smart the underlying model, the results improved with this strategy than Zero Shot approach. \n", + " \n", + " * However, there are limitations to this approach. We observed two main problems with this approach:\n", + " \n", + " 1. With a big enough input file with multiple issues, prompts cross the input limits of most models. This is a blocking problem for Kai as it ends up not creating a response at all.\n", + " \n", + " 2. The quality of response depends a lot on the quality of diff. A very pinpointed specific diff works better than a diff that contains lines that span more than just the issue in question. In fact, a larger diff with too many unrelated lines can hurt more than it helps. In order for this strategy to be helpful, Kai needs to pick the right examples. There needs to be some pre-processing on the diffs that makes sure only specific lines are saved.\n", + "\n", + " * Notice that for the easy example, the diff we included is a very specific diff that only contains two lines that are relevant to the issue.\n", + "\n", + " * For the hard example, we did use a diff from Kai's default data. However, we could not include diffs for all 10 issues in the file because of input limits. We only included one diff for the hardest fix in the file. Therefore, we will see worse performance with Kai as of today with this approach for larger files.\n", + "\n", + "### Few Shot with Solved Example Summary\n", + "\n", + " * In most of the experiments we did, this proved to be the most successful method for ensuring a high quality response. For some models, we did see instances of diff performing better. The drop we saw wasn't because of a huge problem though. \n", + "\n", + " * The main reason behind this being successful we think is that this addresses all problems / shortcomings of previous methods:\n", + " 1. The prompts contain pinpointed information unlike Zero-Shot\n", + " 2. With this approach, the prompts are significantly smaller and do not contain much out-of-scope information.\n", + "\n", + " * Like diff-only, the quality of responses highly depend on the quality of summary generated. At the time of writing this notebook, Kai generates summary of each incident. However, our experience running these experiments makes us believe that such a naive way of generating summary won't work reliably. Kai should employ more logic to combine multiple incidents together in a file and produce a summary by considering all of the issues, not just one." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conclusion\n", + "\n", + "Using a smarter model alone with Zero Shot prompts may work for modernizing small / easy isolated examples of source code. However, when it comes to modernizing larger / complex codebase, we observe that a smart model alone cannot help. We find that its essential to pinpoint LLM to specific areas of codebase, as well as provide additional information about the problems to get high quality responses.\n", + "\n", + "Our results suggest that the approaches Kai is using to pinpoint issues using analysis information and solved examples improve the quality of responses. However, we identify some problems with the current implementation of these approaches. We think that Kai must improve in following areas:\n", "\n", - "2. Few Shot prompts require additional analysis information to work a little better. However, merely including line numbers in the prompt is not going to help. A text description about an issue that hints about a possible solution is way better than line numbers. \n", + "1. In the solved example diffs, do not include lines that may confuse the LLM. \n", + "2. In the solved example summaries, try to provide summary by combining multiple incidents together in a file so its shorter and takes into account effect of fixes affecting other issues in the file.\n", "\n", - "3. " + "We believe that a mix of both diff and summary approaches might be better. More experimentation is needed to figure out how exactly that mix will look like." ] } ], diff --git a/notebooks/evaluation/templates/evaluate.jinja b/notebooks/evaluation/templates/evaluate.jinja index 58258ae8..fddc9532 100644 --- a/notebooks/evaluation/templates/evaluate.jinja +++ b/notebooks/evaluation/templates/evaluate.jinja @@ -1,33 +1,33 @@ -You are an expert on migrating JavaEE applications to Quarkus. +<> +You are an expert in judging source code that is migrated from JavaEE to Quarkus. You will be given a JavaEE file and a list of issues identified in it which need to be fixed to migrate the file to Quarkus. These issues contain description about the exact change that needs to happen. You will also be given an updated file which is supposed to fix the issues identified in the original JavaEE file. -Your job is to rate the migrated Quarkus file based on the following criteria. +Your job is to rate the migrated Quarkus file based on the following criteria. ## Criteria: - 1. Fixing the issue: - -Ensure that all of the original issues pointed out in the JavaEE file are fixed in the updated file. -If an API needed to be replaced with something else, make sure its correctly replaced with a Quarkus compatible api. -If a larger rewrite was needed, make sure the rewrite is compatible with Quarkus. -If there are only some of the issues fixed, you will give a rating proportional to the number of issues fixed. -If all of the issues are fixed, you will rate the highest. - + * Ensure that all of the original issues pointed out in the JavaEE file are fixed in the updated file. + * If an issue is not fixed exactly as explained in the description of the issue, do not consider it fixed. + * Do not consider an alternative approach as a valid fix. + * If none of the issues are fixed, rate the lowest. + * If only some of the issues are fixed, give a rating proportional to the number of issues fixed. + * If all of the issues are fixed, rate the highest. 2. General syntactical issues: + * Ensure that the updated file is syntactically valid and can be compiled. + * Ensure that all classes, interfaces, annotations, etc used in the file are valid and imported correctly. + * Make sure that fixes do not change the original functionality. + * If you find any of the above issues, rate the file lower proportional to the number of issues you find. + * If the file doesn't have issues, rating must be higher. -Ensure that the updated file is syntactically valid and can be compiled. -Ensure that all classes, interfaces, annotations, etc used in the file are imported correctly. -Make sure that fixes do not change the original functionality. -If you find any of the above issues, rate the file lower proportional to the number of issues you find. -If the file doesn't have issues, rating must be higher. - -3. File suitability for Quarkus: +Each metric defined in the criteria above must be rated on a scale of 0 to 5 where 0 is the lowest and 5 is the highest. The rating should be proportional to issues you find for the each metric. +Output only the rating for each metric on a newline. Also include reasoning on a line following the rating. -Ensure that the updated file is compatible with Quarkus. Ensure that the updated file doesn't introduce new issues that may make the file incompatible with Quarkus. -If you still identify issues in the updated file which makes it unsuitable for Quarkus, you will rate lower. -If there are no issues in the Quarkus file and file can successfully work with Quarkus, you will rate higher. +Produce your output exactly as per following format: -Each metric defined in the criteria above must be rated on a scale of 0 to 5 where 0 is the lowest and 5 is the highest. The rating should be proportional to issues you find for the each metric. +// rating here on the first line. Only output a numeric rating. Do not output any text on this line. +// reasoning here on the second line. Only output text in the reasoning. No numbers here. +<> +[INST] ## JavaEE file: @@ -40,7 +40,7 @@ Each metric defined in the criteria above must be rated on a scale of 0 to 5 whe {% for incident in incidents %} ### incident {{ loop.index0 }} Line number of the issue to fix: {{ incident.line_number }} -Description of the issue: {{ incident.message }} +Expected fix: {{ incident.message }} {% endfor %} ## Updated file: @@ -48,10 +48,4 @@ Description of the issue: {{ incident.message }} ```java {{ updated_file }} ``` - -Output only the rating for each metric on a newline. Also include reasoning on a line following the rating. - -Please produce output in the following format: - -// rating here on the first line. Only output a numeric rating. Do not output any text on this line. -// reasoning here on the second line. \ No newline at end of file +[/INST] \ No newline at end of file diff --git a/notebooks/evaluation/templates/few_shot/default.jinja b/notebooks/evaluation/templates/few_shot/default.jinja index f4f52923..6093edba 100644 --- a/notebooks/evaluation/templates/few_shot/default.jinja +++ b/notebooks/evaluation/templates/few_shot/default.jinja @@ -32,6 +32,7 @@ Source file contents: {% for incident in incidents %} ### incident {{ loop.index0 }} Line number: {{ incident.line_number }} +Message: {{ incident.message }} {% if (incidents|length == 1 or loop.index0 == 6) and incident.solution_str is defined %} {{ incident.solution_str | safe }} {% endif %} @@ -48,10 +49,6 @@ Write the step by step reasoning in this markdown section. Do not include code i // Write the updated file for Quarkus in this section. If the file should be removed, make the content of the updated file a comment explaining it should be removed. ``` -## Additional Information (optional) - -If you have any additional details or steps that need to be performed, put it here. - Make sure your output is exactly in the format described above. Pay special attention to markdown sections. {% if model_provider.model_id == 'mistralai/mixtral-8x7b-instruct-v01' %} diff --git a/notebooks/evaluation/templates/few_shot/easy_hardcoded_summary.jinja b/notebooks/evaluation/templates/few_shot/easy_hardcoded_summary.jinja new file mode 100644 index 00000000..493164f6 --- /dev/null +++ b/notebooks/evaluation/templates/few_shot/easy_hardcoded_summary.jinja @@ -0,0 +1,171 @@ +{% if model_provider.llama_header %}[INST]You are an AI Assistant trained on migrating enterprise JavaEE code to Quarkus.<>{% endif %} +I will give you a JavaEE file for which I want to take one step towards migrating to Quarkus. + +I will provide you with static source code analysis information highlighting an issue which needs to be addressed. + +Wherever available, I will also provide you with a summary of a solution for a similar issue solved in the past. + +You can refer to the solved example for a pattern of how to update the input Java EE file to Quarkus. + +Fix the problem described. + +Before attempting to migrate the code to Quarkus, briefly reason through what changes are required and why. + +Pay attention to changes you make to imports we need to consider. + +Remember when updating or adding annotations that the class must be imported. + +After you have shared your step by step thinking, provide a full output of the updated file. + +# Input information + +## Input File + +File name: "ShoppingCart.java" +Source file contents: +```java +package com.redhat.coolstore.model; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +import javax.enterprise.context.Dependent; + +@Dependent +public class ShoppingCart implements Serializable { + + private static final long serialVersionUID = -1108043957592113528L; + + private double cartItemTotal; + + private double cartItemPromoSavings; + + private double shippingTotal; + + private double shippingPromoSavings; + + private double cartTotal; + + private List shoppingCartItemList = new ArrayList(); + + public ShoppingCart() { + + } + + public List getShoppingCartItemList() { + return shoppingCartItemList; + } + + public void setShoppingCartItemList(List shoppingCartItemList) { + this.shoppingCartItemList = shoppingCartItemList; + } + + public void resetShoppingCartItemList() { + shoppingCartItemList = new ArrayList(); + } + + public void addShoppingCartItem(ShoppingCartItem sci) { + + if ( sci != null ) { + + shoppingCartItemList.add(sci); + + } + + } + + public boolean removeShoppingCartItem(ShoppingCartItem sci) { + + boolean removed = false; + + if ( sci != null ) { + + removed = shoppingCartItemList.remove(sci); + + } + + return removed; + + } + + public double getCartItemTotal() { + return cartItemTotal; + } + + public void setCartItemTotal(double cartItemTotal) { + this.cartItemTotal = cartItemTotal; + } + + public double getShippingTotal() { + return shippingTotal; + } + + public void setShippingTotal(double shippingTotal) { + this.shippingTotal = shippingTotal; + } + + public double getCartTotal() { + return cartTotal; + } + + public void setCartTotal(double cartTotal) { + this.cartTotal = cartTotal; + } + + public double getCartItemPromoSavings() { + return cartItemPromoSavings; + } + + public void setCartItemPromoSavings(double cartItemPromoSavings) { + this.cartItemPromoSavings = cartItemPromoSavings; + } + + public double getShippingPromoSavings() { + return shippingPromoSavings; + } + + public void setShippingPromoSavings(double shippingPromoSavings) { + this.shippingPromoSavings = shippingPromoSavings; + } + + @Override + public String toString() { + return "ShoppingCart [cartItemTotal=" + cartItemTotal + + ", cartItemPromoSavings=" + cartItemPromoSavings + + ", shippingTotal=" + shippingTotal + + ", shippingPromoSavings=" + shippingPromoSavings + + ", cartTotal=" + cartTotal + ", shoppingCartItemList=" + + shoppingCartItemList + "]"; + } +} + +``` + +## Issues + +### incident 0 +Line number: 7 +Message: Replace `javax.enterprise` with `jakarta.enterprise` +Solution summary: +The change made to address the migration issue is the replacement of the import statement javax.enterprise.context.Dependent with jakarta.enterprise.context.Dependent. This updates the code to be compatible with Quarkus, which uses the jakarta namespace instead of javax. + +# Output Instructions +Structure your output exactly in Markdown format such as: + +## Reasoning +Write the step by step reasoning in this markdown section. Do not include code in this section, please only include text. + +## Updated File +```java +// Write the full updated file for Quarkus in this section. If the file should be removed, make the content of the updated file a comment explaining it should be removed. +``` + + +Make sure your output is exactly in the format described above. Pay special attention to markdown sections. + +{% if model_provider.model_id == 'mistralai/mixtral-8x7b-instruct-v01' %} +Only use ## to begin section headers in the markdown above. Output the entire file. +{% endif %} + +{% if model_provider.llama_header %}[/INST]{% endif %} \ No newline at end of file diff --git a/notebooks/evaluation/templates/few_shot/med_hardcoded.jinja b/notebooks/evaluation/templates/few_shot/hard_hardcoded.jinja similarity index 79% rename from notebooks/evaluation/templates/few_shot/med_hardcoded.jinja rename to notebooks/evaluation/templates/few_shot/hard_hardcoded.jinja index 0001bb50..7cafb409 100644 --- a/notebooks/evaluation/templates/few_shot/med_hardcoded.jinja +++ b/notebooks/evaluation/templates/few_shot/hard_hardcoded.jinja @@ -63,21 +63,7 @@ public class ShoppingCartOrderProcessor { ## Issues ### incident 0 -Line number: 5 -### incident 1 -Line number: 4 -### incident 2 -Line number: 6 -### incident 3 -Line number: 7 -### incident 4 Line number: 8 -### incident 5 -Line number: 13 -### incident 6 -Line number: 8 -### incident 7 -Line number: 24 Solution diff: ```diff 3,4c3,11 @@ -236,60 +222,6 @@ Solution diff: > > return messages; ``` -### incident 8 -Line number: 7 -### incident 9 -Line number: 8 -Solution diff: -```diff -19,25c19,21 -< import java.util.logging.Logger; -< import javax.ejb.ActivationConfigProperty; -< import javax.ejb.MessageDriven; -< import javax.jms.JMSException; -< import javax.jms.Message; -< import javax.jms.MessageListener; -< import javax.jms.TextMessage; ---- -> import jakarta.enterprise.context.ApplicationScoped; -> import io.smallrye.reactive.messaging.annotations.Merge; -> import org.jboss.logging.Logger; -27,38c23 -< @MessageDriven(name = "HelloWorldQueueMDB", activationConfig = { -< @ActivationConfigProperty(propertyName = "destinationLookup", propertyValue = "queue/HELLOWORLDMDBQueue"), -< @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"), -< @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge")}) -< public class HelloWorldQueueMDB implements MessageListener { ---- -> import org.eclipse.microprofile.reactive.messaging.Incoming; -40c25,27 -< private static final Logger LOGGER = Logger.getLogger(HelloWorldQueueMDB.class.toString()); ---- -> @ApplicationScoped -> public class HelloWorldQueueMDB { -> private static final Logger LOGGER = Logger.getLogger(HelloWorldQueueMDB.class.toString()); -42,56c29,32 -< /** -< * @see MessageListener#onMessage(Message) -< */ -< public void onMessage(Message rcvMessage) { -< TextMessage msg = null; -< try { -< if (rcvMessage instanceof TextMessage) { -< msg = (TextMessage) rcvMessage; -< LOGGER.info("Received Message from queue: " + msg.getText()); -< } else { -< LOGGER.warning("Message of wrong type: " + rcvMessage.getClass().getName()); -< } -< } catch (JMSException e) { -< throw new RuntimeException(e); -< } ---- -> @Incoming("HELLOWORLDMDBQueue") -> @Merge -> public void onMessage(String message) { -> LOGGER.info("Received Message from queue: " + message); -``` # Output Instructions Structure your output exactly in Markdown format such as: diff --git a/notebooks/evaluation/templates/few_shot/hard_hardcoded_summary.jinja b/notebooks/evaluation/templates/few_shot/hard_hardcoded_summary.jinja new file mode 100644 index 00000000..e960a2ab --- /dev/null +++ b/notebooks/evaluation/templates/few_shot/hard_hardcoded_summary.jinja @@ -0,0 +1,120 @@ +{% if model_provider.llama_header %}[INST]You are an AI Assistant trained on migrating enterprise JavaEE code to Quarkus.<>{% endif %} +I will give you a JavaEE file for which I want to take one step towards migrating to Quarkus. + +I will provide you with static source code analysis information highlighting issues which needs to be addressed. + +Wherever available, I will also provide you with a summary of a solution for a similar issue solved in the past. + +You can refer to the summary for a pattern of how to update the input Java EE file to Quarkus. + +Fix only the problems described. Other problems will be solved in subsequent steps so it is unnecessary to handle them now. + +Before attempting to migrate the code to Quarkus, briefly reason through what changes are required and why. + +Pay attention to changes you make to imports we need to consider. + +Remember when updating or adding annotations that the class must be imported. + +After you have shared your step by step thinking, provide a full output of the updated file. Do not omit the contents of the file. + +# Input information + +## Input File + +File name: "ShoppingCartOrderProcessor.java" +Source file contents: +```java +package com.redhat.coolstore.service; + +import java.util.logging.Logger; +import javax.ejb.Stateless; +import javax.annotation.Resource; +import javax.inject.Inject; +import javax.jms.JMSContext; +import javax.jms.Topic; + +import com.redhat.coolstore.model.ShoppingCart; +import com.redhat.coolstore.utils.Transformers; + +@Stateless +public class ShoppingCartOrderProcessor { + + @Inject + Logger log; + + + @Inject + private transient JMSContext context; + + @Resource(lookup = "java:/topic/orders") + private Topic ordersTopic; + + + + public void process(ShoppingCart cart) { + log.info("Sending order from processor: "); + context.createProducer().send(ordersTopic, Transformers.shoppingCartToJson(cart)); + } + + + +} + +``` + +## Issues +### incident 0 +Line number: 5 +Message: Replace the `javax.annotation` import statement with `jakarta.annotation` + +### incident 1 +Line number: 4 +Message: Replace the `javax.ejb` import statement with `jakarta.ejb` + +### incident 2 +Line number: 6 +Message: Replace the `javax.inject` import statement with `jakarta.inject` + +### incident 3 +Line number: 7 +Message: Replace the `javax.jms` import statement with `jakarta.jms` + +### incident 4 +Line number: 8 +Message: Replace the `javax.jms` import statement with `jakarta.jms` + +### incident 5 +Line number: 13 +Message: Stateless EJBs can be converted to a CDI bean by replacing the `@Stateless` annotation with a scope eg `@ApplicationScoped` + +### incident 6 +Line number: 8 +Message: JMS `Topic`s should be replaced with Micrometer `Emitter`s feeding a Channel. +Solution summary: +The migration from JavaEE to Quarkus involved replacing the JMS Topic with a MicroProfile Reactive Messaging Emitter. +JavaEE Implementation: The original code used javax.jms.Topic for messaging, injected via @Resource. The messages were sent using JMSContext.createProducer().send(destination, text). +Quarkus Implementation: The Topic was replaced with a Channel that provides an Emitter in Quarkus. Messages are now sent using emitter.send(messageText). +Overall Adjustment: The messaging logic was adapted to use the MicroProfile Reactive Messaging API instead of JMS, aligning with the reactive, event-driven model in Quarkus. The code now handles both queue and topic messaging uniformly via Emitter. + +# Output Instructions +Structure your output exactly in Markdown format such as: + +## Reasoning +Write the step by step reasoning in this markdown section. Do not include code in this section, please only include text. + +## Updated File +```java +// Write the updated file for Quarkus in this section. If the file should be removed, make the content of the updated file a comment explaining it should be removed. +``` + +## Additional Information (optional) + +If you have any additional details or steps that need to be performed, put it here. + +Make sure your output is exactly in the format described above. Pay special attention to markdown sections. + +{% if model_provider.model_id == 'mistralai/mixtral-8x7b-instruct-v01' %} +Only use ## to begin section headers in the markdown above. Output the entire file. +{% endif %} + +[/INST] \ No newline at end of file diff --git a/notebooks/evaluation/templates/few_shot/summary_generation.jinja b/notebooks/evaluation/templates/few_shot/summary_generation.jinja new file mode 100644 index 00000000..d27f5e4e --- /dev/null +++ b/notebooks/evaluation/templates/few_shot/summary_generation.jinja @@ -0,0 +1,216 @@ +<> +You are an AI Assistant trained on migrating enterprise JavaEE code to Quarkus. +You will be given a JavaEE file and an issue that in the file that needs to be fixed before the file can be migrated to Quarkus. +You will be given another file which is the original file already migrated to Quarkus. +You will compare the two files and provide a concise summary of the changes pertaining to the issue present in JavaEE file. +Be concise with your explanation and only summarize the changes related to the issue mentioned. +<> + +[INST] +## JavaEE File + +File name: "HelloWorldMDBServletClient.java" +Source file contents: +```java +/* + * JBoss, Home of Professional Open Source + * Copyright 2015, Red Hat, Inc. and/or its affiliates, and individual + * contributors by the @authors tag. See the copyright.txt in the + * distribution for a full listing of individual contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jboss.as.quickstarts.servlet; + +import java.io.IOException; +import java.io.PrintWriter; + +import javax.annotation.Resource; +import javax.inject.Inject; +import javax.jms.Destination; +import javax.jms.JMSContext; +import javax.jms.JMSDestinationDefinition; +import javax.jms.JMSDestinationDefinitions; +import javax.jms.Queue; +import javax.jms.Topic; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +/** + * Definition of the two JMS destinations used by the quickstart + * (one queue and one topic). + */ +@JMSDestinationDefinitions( + value = { + @JMSDestinationDefinition( + name = "java:/queue/HELLOWORLDMDBQueue", + interfaceName = "javax.jms.Queue", + destinationName = "HelloWorldMDBQueue" + ), + @JMSDestinationDefinition( + name = "java:/topic/HELLOWORLDMDBTopic", + interfaceName = "javax.jms.Topic", + destinationName = "HelloWorldMDBTopic" + ) + } +) + +/** + *

+ * A simple servlet 3 as client that sends several messages to a queue or a topic. + *

+ * + *

+ * The servlet is registered and mapped to /HelloWorldMDBServletClient using the {@linkplain WebServlet + * @HttpServlet}. + *

+ * + * @author Serge Pagop (spagop@redhat.com) + * + */ +@WebServlet("/HelloWorldMDBServletClient") +public class HelloWorldMDBServletClient extends HttpServlet { + + private static final long serialVersionUID = -8314035702649252239L; + + private static final int MSG_COUNT = 5; + + @Inject + private JMSContext context; + + @Resource(lookup = "java:/queue/HELLOWORLDMDBQueue") + private Queue queue; + + @Resource(lookup = "java:/topic/HELLOWORLDMDBTopic") + private Topic topic; + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + resp.setContentType("text/html"); + PrintWriter out = resp.getWriter(); + out.write("

Quickstart: Example demonstrates the use of JMS 2.0 and EJB 3.2 Message-Driven Bean in JBoss EAP.

"); + try { + boolean useTopic = req.getParameterMap().keySet().contains("topic"); + final Destination destination = useTopic ? topic : queue; + + out.write("

Sending messages to " + destination + "

"); + out.write("

The following messages will be sent to the destination:

"); + for (int i = 0; i < MSG_COUNT; i++) { + String text = "This is message " + (i + 1); + context.createProducer().send(destination, text); + out.write("Message (" + i + "): " + text + "
"); + } + out.write("

Go to your JBoss EAP server console or server log to see the result of messages processing.

"); + } finally { + if (out != null) { + out.close(); + } + } + } + + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + doGet(req, resp); + } +} +``` + +## Migration Issue + +Line number: 8 +Incident that was fixed: Replace the `javax.jms` import statement with `jakarta.jms` + +## Quarkus File +File name: "HelloWorldMDBServletClient.java" +Source file contents: +```java +package org.jboss.as.quickstarts.servlet; + +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.inject.Inject; +import jakarta.jms.Destination; +import jakarta.ws.rs.GET; +import jakarta.ws.rs.Path; +import jakarta.ws.rs.Produces; +import jakarta.ws.rs.QueryParam; +import org.eclipse.microprofile.reactive.messaging.Channel; +import org.eclipse.microprofile.reactive.messaging.Emitter; + +import jakarta.ws.rs.core.Context; +import java.util.List; +import java.util.ArrayList; +import jakarta.ws.rs.core.MultivaluedMap; +import jakarta.ws.rs.core.UriInfo; +import jakarta.ws.rs.core.MediaType; + +import jakarta.ws.rs.core.Response; + + +@ApplicationScoped +@Path("/HelloWorldMDBServletClient") +public class HelloWorldMDBServletClient { + + private static final int MSG_COUNT = 5; + + @Inject + @Channel("HELLOWORLDMDBQueue") + Emitter queueEmitter; + + @Inject + @Channel("HELLOWORLDMDBTopic") + Emitter topicEmitter; + + + @GET + @Produces(MediaType.TEXT_HTML) + public Response doGet(@Context UriInfo uriInfo) { + MultivaluedMap queryParams = uriInfo.getQueryParameters(); + boolean isUsingTopic = queryParams.containsKey("topic"); + + + Emitter emitter = isUsingTopic ? topicEmitter : queueEmitter; + String destination = isUsingTopic ? "topic" : "queue"; + StringBuilder response = new StringBuilder(); + response.append("

Quickstart: Example demonstrates the use of eclipse reactive messaging in Quarkus.

"); + response.append("

Sending messages to ").append(destination).append("

"); + response.append("

The following messages will be sent to the destination:

"); + + List messages = generateMessages(emitter); + response.append("
    "); + for (String message : messages) { + response.append("
  1. ").append(message).append("
    2. "); + } + response.append("
"); + + + response.append("

Check your console or logs to see the result of messages processing.

"); + + return Response.ok(response.toString()).build(); + + } + + private List generateMessages(Emitter emitter) { + List messages = new ArrayList<>(); + + for (int i = 1; i <= MSG_COUNT; i++) { + String messageText = "This is message " + i; + messages.add(messageText); + emitter.send(messageText); + } + + return messages; + } +} +``` + +[/INST] \ No newline at end of file