{"cells":[{"cell_type":"code","execution_count":1,"metadata":{"application/vnd.databricks.v1+cell":{"cellMetadata":{},"inputWidgets":{},"nuid":"0ea8b46b-839b-445b-8043-ccdf4e920ace","showTitle":false,"title":""},"id":"YLH80COBzi_F"},"outputs":[],"source":["%load_ext autoreload\n","%autoreload 2"]},{"cell_type":"code","execution_count":2,"metadata":{"id":"63B5exAuzq4M"},"outputs":[],"source":["from pathlib import Path\n","\n","try:\n","    from google.colab import drive\n","    drive.mount('/content/drive')\n","    workding_dir = \"/content/drive/MyDrive/logical-reasoning/\"\n","except ModuleNotFoundError:\n","    workding_dir = str(Path.cwd().parent)"]},{"cell_type":"code","execution_count":3,"metadata":{"executionInfo":{"elapsed":368,"status":"ok","timestamp":1719461634865,"user":{"displayName":"Donghao Huang","userId":"00463591218503521679"},"user_tz":-480},"id":"zFulf0bg0H-9","outputId":"debdd535-c828-40b9-efc0-8a180e5830dd"},"outputs":[{"name":"stdout","output_type":"stream","text":["workding dir: /Users/inflaton/code/engd/projects/logical-reasoning\n"]}],"source":["import os\n","import sys\n","\n","os.chdir(workding_dir)\n","sys.path.append(workding_dir)\n","print(\"workding dir:\", workding_dir)"]},{"cell_type":"code","execution_count":4,"metadata":{"application/vnd.databricks.v1+cell":{"cellMetadata":{},"inputWidgets":{},"nuid":"9f67ec60-2f24-411c-84eb-0dd664b44775","showTitle":false,"title":""},"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":589,"status":"ok","timestamp":1719462011879,"user":{"displayName":"Donghao Huang","userId":"00463591218503521679"},"user_tz":-480},"id":"DIUiweYYzi_I","outputId":"e16e9247-9077-4b0c-f8ea-17059f05a1c4"},"outputs":[{"name":"stdout","output_type":"stream","text":["loading env vars from: /Users/inflaton/code/engd/projects/logical-reasoning/.env\n"]},{"data":{"text/plain":["True"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["from dotenv import find_dotenv, load_dotenv\n","\n","found_dotenv = find_dotenv(\".env\")\n","\n","if len(found_dotenv) == 0:\n","    found_dotenv = find_dotenv(\".env.example\")\n","print(f\"loading env vars from: {found_dotenv}\")\n","load_dotenv(found_dotenv, override=True)"]},{"cell_type":"code","execution_count":5,"metadata":{"id":"W2QyVreqhOGM","outputId":"68b9590e-1ac6-4c6f-e0c4-e273ec816419"},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>text</th>\n","      <th>label</th>\n","      <th>title</th>\n","      <th>puzzle</th>\n","      <th>truth</th>\n","      <th>internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_m3</th>\n","      <th>internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_nv4080_lf</th>\n","      <th>internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40</th>\n","      <th>internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40_lf</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>甄加索是自杀吗</td>\n","      <td>不是</td>\n","      <td>海岸之谜</td>\n","      <td>在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...</td>\n","      <td>甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>甄加索有身体上的疾病吗</td>\n","      <td>是</td>\n","      <td>海岸之谜</td>\n","      <td>在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...</td>\n","      <td>甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>画作是甄的</td>\n","      <td>是</td>\n","      <td>海岸之谜</td>\n","      <td>在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...</td>\n","      <td>甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>甄有心脏病吗</td>\n","      <td>是</td>\n","      <td>海岸之谜</td>\n","      <td>在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...</td>\n","      <td>甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>车轮是凶手留下的</td>\n","      <td>不是</td>\n","      <td>海岸之谜</td>\n","      <td>在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...</td>\n","      <td>甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","    </tr>\n","    <tr>\n","      <th>...</th>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","    </tr>\n","    <tr>\n","      <th>2995</th>\n","      <td>哭泣者必须在晚上祭奠吗</td>\n","      <td>是</td>\n","      <td>甄庄哭声</td>\n","      <td>在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...</td>\n","      <td>原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...</td>\n","      <td>不重要</td>\n","      <td>不重要</td>\n","      <td>不是</td>\n","      <td>不重要</td>\n","    </tr>\n","    <tr>\n","      <th>2996</th>\n","      <td>尸体在湖里吗</td>\n","      <td>不是</td>\n","      <td>甄庄哭声</td>\n","      <td>在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...</td>\n","      <td>原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","      <td>不是</td>\n","    </tr>\n","    <tr>\n","      <th>2997</th>\n","      <td>哭泣者和死者有特殊关系吗</td>\n","      <td>是</td>\n","      <td>甄庄哭声</td>\n","      <td>在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...</td>\n","      <td>原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","    </tr>\n","    <tr>\n","      <th>2998</th>\n","      <td>是帽子的主人去世了吗</td>\n","      <td>不是</td>\n","      <td>甄庄哭声</td>\n","      <td>在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...</td>\n","      <td>原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","      <td>是</td>\n","    </tr>\n","    <tr>\n","      <th>2999</th>\n","      <td>死者受伤了吗</td>\n","      <td>不是</td>\n","      <td>甄庄哭声</td>\n","      <td>在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...</td>\n","      <td>原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...</td>\n","      <td>不是</td>\n","      <td>不重要</td>\n","      <td>不是</td>\n","      <td>不重要</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>3000 rows × 9 columns</p>\n","</div>"],"text/plain":["              text label title  \\\n","0          甄加索是自杀吗    不是  海岸之谜   \n","1      甄加索有身体上的疾病吗     是  海岸之谜   \n","2            画作是甄的     是  海岸之谜   \n","3           甄有心脏病吗     是  海岸之谜   \n","4         车轮是凶手留下的    不是  海岸之谜   \n","...            ...   ...   ...   \n","2995   哭泣者必须在晚上祭奠吗     是  甄庄哭声   \n","2996        尸体在湖里吗    不是  甄庄哭声   \n","2997  哭泣者和死者有特殊关系吗     是  甄庄哭声   \n","2998    是帽子的主人去世了吗    不是  甄庄哭声   \n","2999        死者受伤了吗    不是  甄庄哭声   \n","\n","                                                 puzzle  \\\n","0     在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...   \n","1     在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...   \n","2     在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...   \n","3     在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...   \n","4     在远离城市喧嚣的海边小屋，一天清晨，邻居发现甄加索僵卧在沙滩上，已无生命迹象。现场没有发现任...   \n","...                                                 ...   \n","2995  在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...   \n","2996  在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...   \n","2997  在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...   \n","2998  在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...   \n","2999  在一个安静的夜晚，小村庄的湖边突然传来了阵阵哭泣声。第二天早晨，村长甄锐发现湖边的石头上放着...   \n","\n","                                                  truth  \\\n","0     甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...   \n","1     甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...   \n","2     甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...   \n","3     甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...   \n","4     甄加索是一位热爱自然的画家，他每年都会来到这个海边小屋寻找灵感。在他生命的最后几天，他一直在...   \n","...                                                 ...   \n","2995  原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...   \n","2996  原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...   \n","2997  原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...   \n","2998  原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...   \n","2999  原来，这顶破旧的帽子属于一个小男孩，他小时候与爷爷在湖边生活。爷爷教他钓鱼、游泳，还告诉他湖...   \n","\n","     internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_m3  \\\n","0                                                    不是                                                          \n","1                                                     是                                                          \n","2                                                     是                                                          \n","3                                                     是                                                          \n","4                                                    不是                                                          \n","...                                                 ...                                                          \n","2995                                                不重要                                                          \n","2996                                                 不是                                                          \n","2997                                                  是                                                          \n","2998                                                  是                                                          \n","2999                                                 不是                                                          \n","\n","     internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_nv4080_lf  \\\n","0                                                    不是                                                                 \n","1                                                     是                                                                 \n","2                                                     是                                                                 \n","3                                                     是                                                                 \n","4                                                    不是                                                                 \n","...                                                 ...                                                                 \n","2995                                                不重要                                                                 \n","2996                                                 不是                                                                 \n","2997                                                  是                                                                 \n","2998                                                  是                                                                 \n","2999                                                不重要                                                                 \n","\n","     internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40  \\\n","0                                                  不是   \n","1                                                   是   \n","2                                                   是   \n","3                                                   是   \n","4                                                  不是   \n","...                                               ...   \n","2995                                               不是   \n","2996                                               不是   \n","2997                                                是   \n","2998                                                是   \n","2999                                               不是   \n","\n","     internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40_lf  \n","0                                                    不是   \n","1                                                     是   \n","2                                                     是   \n","3                                                     是   \n","4                                                    不是   \n","...                                                 ...   \n","2995                                                不重要   \n","2996                                                 不是   \n","2997                                                  是   \n","2998                                                  是   \n","2999                                                不重要   \n","\n","[3000 rows x 9 columns]"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["import pandas as pd\n","\n","df = pd.read_csv(\"results/mgtv-results_internlm_best.csv\")\n","df"]},{"cell_type":"code","execution_count":6,"metadata":{},"outputs":[],"source":["import matplotlib.pyplot as plt\n","from matplotlib import rcParams\n","\n","def plot_value_counts(df, column):\n","    font_family = rcParams[\"font.family\"]\n","    # Set the font to SimHei to support Chinese characters\n","    rcParams[\"font.family\"] = \"STHeiti\"\n","    rcParams[\"axes.unicode_minus\"] = False  # This is to support the minus sign in Chinese.\n","\n","    plt.figure(figsize=(12, 6))\n","    df[column].value_counts().plot(kind=\"bar\")\n","    # add values on top of bars\n","    for i, v in enumerate(df[column].value_counts()):\n","        plt.text(i, v + 0.1, str(v), ha=\"center\")\n","    plt.show()\n","    \n","    rcParams[\"font.family\"] = font_family\n"]},{"cell_type":"code","execution_count":7,"metadata":{},"outputs":[{"data":{"text/plain":["['text',\n"," 'label',\n"," 'title',\n"," 'puzzle',\n"," 'truth',\n"," 'internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_m3',\n"," 'internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_nv4080_lf',\n"," 'internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40',\n"," 'internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40_lf']"]},"execution_count":7,"metadata":{},"output_type":"execute_result"}],"source":["df.columns.to_list()"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["********** internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_m3 **********\n","internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_m3\n","不是      1505\n","是       1140\n","不重要      264\n","问法错误      53\n","回答正确      38\n","Name: count, dtype: int64\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 1200x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["********** internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_nv4080_lf **********\n","internlm/internlm2_5-7b-chat-1m_llama-factory/saves/internlm2_5_7b/lora/sft_bf16_p2_full/checkpoint-88_nv4080_lf\n","不是      1480\n","是       1105\n","不重要      321\n","问法错误      52\n","回答正确      42\n","Name: count, dtype: int64\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 1200x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["********** internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40 **********\n","internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40\n","不是      1505\n","是       1145\n","不重要      257\n","问法错误      53\n","回答正确      40\n","Name: count, dtype: int64\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 1200x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["********** internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40_lf **********\n","internlm/internlm2_5-7b-chat-1m/LoRA-Adapter_l40_lf\n","不是      1477\n","是       1109\n","不重要      319\n","问法错误      53\n","回答正确      42\n","Name: count, dtype: int64\n"]},{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAA94AAAI2CAYAAACmDVBwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABfM0lEQVR4nO3dd1xW9f//8SdDuC5AQHGloubClZU5KkfmKJNKUbNP6Sdy5SBzVJap1FdL2zbUTMuVlqWW5mw4cqRmjvKTYZooaIIyZMm4gPP7wxvXzytwX4cL9HG/3c5NeL/f57peB94qT8457+NmGIYhAAAAAABgCndXFwAAAAAAwPWM4A0AAAAAgIkI3gAAAAAAmIjgDQAAAACAiQjeAAAAAACYiOANAAAAAICJCN4AAAAAAJjI09UFOEt+fr7++ecflS1bVm5ubq4uBwAAAABwnTMMQ2lpaapatarc3S98Xvu6Cd7//POPgoODXV0GAAAAAOAGExsbq+rVq1+w/7oJ3mXLlpV07oD9/f1dXA0AAAAA4HqXmpqq4OBgex69kOsmeBdcXu7v70/wBgAAAAAUm0vd7sziagAAAAAAmIjgDQAAAACAiQjeAAAAAACYiOANAAAAAICJCN4AAAAAAJiI4A0AAAAAgIkI3gAAAAAAmIjgDQAAAACAiQjesLv33nvl7u6ut99++4JjbDabJkyYYP98wIAB8vT0dNjc3Nw0depUSVLdunWL7N+zZ4/pxwMAAAAAJQHBG3YbN25UZGTkRcdERkZq79699s8//fRT5ebm2rcjR46oWrVqGjx4sCTp8OHDDv0LFy5UaGiomjVrZuqxAAAAAEBJQfDGZdu2bZvefffdi4554403NHz4cPn4+BTqMwxDr732msMZcwAAAAC43nm6ugCUDunp6QoPD9dzzz2n3377rcgxJ0+e1PLlyxUVFVVk//Lly3XTTTepVatWZpYKAAAAACUKZ7xxWUaMGKHQ0FB17tz5gmPeeustDRkyRGXLli2y/9VXX+VsNwAAAIAbDme8cUkrVqzQjh07tHv3bu3YsaPIMadPn9aXX36pAwcOFNm/Zs0alS1bVm3btjWzVAAAAAAocQjeuKhTp04pIiJCK1eulMViueC4d999V/3791dAQECR/a+++qomTZpkVpkAAAAAUGIRvHFRQ4cOVXx8vO666y5JUn5+vvLy8lSlShXFxcVJkpKTk7VgwQL9/vvvRb7G+vXrJUkdO3YsnqIBAAAAoAThHm9c1LJly2Sz2ZSVlaWsrCx9//33euCBB+yhW5I++OAD9enTR0FBQUW+xquvvqrx48cXV8kAAAAAUKJwxhvXJC0tTbNnz9bu3buL7N+2bZvS0tLUtWvXYq4MAAAAAEoGznjjmhw4cEADBw5U5cqVi+z/7bffFBkZWcxVAQAAAEDJ4WYYhuHqIpwhNTVVAQEBSklJkb+/v6vLuSK1Xlzt6hJuOEdfD3V1CQAAAABKucvNoZzxBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwERXFbzvvfdeubu76+23377gGJvNpgkTJji0zZo1SzVq1JCvr6/CwsIUHx/vMP6ZZ55RuXLlFBQUpOeff165ublXUx4AAAAAACXGVQXvjRs3KjIy8qJjIiMjtXfvXvvn69at0+TJk7Vq1SolJCSoSZMmCgsLs/dPmDBBf/31l6KiohQVFaUDBw4UCu4AAAAAAJQ2plxqvm3bNr377rsObVOnTtU777yjpk2bymq1atKkScrPz9eGDRuUk5Oj2bNna968eapcubIqVqyoBQsW6JNPPlFGRoYZJQIAAAAAUCycHrzT09MVHh6u5557zt5mGIZ27typ0NBQh7G9evXS+vXrtW/fPjVs2FBVqlSx9wUFBalVq1b6+eefnV0iAAAAAADFxunBe8SIEQoNDVXnzp3tbYmJiQoMDJTFYnEYGxISoiNHjigmJkZ169Yt9FoF/UXJzs5WamqqwwYAAAAAQEnj1OC9YsUK7dixQ2+88YZDe2Zmpnx8fAqNt1qtyszMvGR/UaZMmaKAgAD7Fhwc7JyDAAAAAADAiZwWvE+dOqWIiAgtXLiw0Jltq9WqrKysQvskJibKx8fnkv1FGTt2rFJSUuxbbGyscw4EAAAAAAAn8nTWCw0dOlTx8fG66667JEn5+fnKy8tTlSpVdPLkSZ05c0Y2m01lypSx7xMdHa3atWurRo0aio6OLvSa0dHR6tmzZ5Hv5+3tLW9vb2eVDwAAAACAKZx2xnvZsmWy2WzKyspSVlaWvv/+ez3wwAOKi4uTm5ubmjdvrg0bNjjss3TpUnXq1Em33XabDhw4oOTkZHtfUlKSdu7cqbvvvttZJQIAAAAAUOxMeZxYUUaPHq2RI0cqKipKWVlZmjRpkqxWq9q3by8vLy/169dPgwYNUmJiohISEtS/f389/fTTF7zUHAAAAACA0qDYgneXLl00cuRIde7cWeXLl9eePXu0bNkye//EiRN10003qU6dOqpfv77q1aunV155pbjKAwAAAADAFG6GYRiuLsIZUlNTFRAQoJSUFPn7+7u6nCtS68XVri7hhnP09dBLDwIAAACAi7jcHFpsZ7wBAAAAALgREbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAw0VUF73vvvVfu7u56++23Hdq3bt2qVq1ayd/fX3feead27Njh0D9x4kRVrlxZ/v7+6t+/v9LT0+19qamp6tOnj/z8/FS1alW98cYbV1MaAAAAAAAlylUF740bNyoyMtKh7dChQ+rdu7dee+01xcfHa8yYMerevbuOHz8uSZo5c6aWL1+uHTt26Pjx43Jzc9OgQYPs+z/11FMqU6aMTpw4oe3bt2vp0qX6+OOPr+HQAAAAAABwPU9nvdC0adM0evRoderUSZLUo0cP7dy5U1999ZVGjx6tqVOn6vPPP9fNN98s6VwQr1Onjv7++29ZLBZt3LhRx44dk8ViUUBAgBYsWKAHHnhAgwcPdlaJAAAAAAAUO6cF75tvvlmhoaEObcHBwYqNjdWpU6eUkZGhO+64w95XpkwZPfzww9qwYYMCAgLUuXNnWSwWe3/Dhg3l5+enQ4cOqV69es4qEwAAAACAYuW0xdVGjhxZKCCvWrVKzZs3V0xMjOrWrVton5CQEB05cuSS/UXJzs5WamqqwwYAAAAAQElj2qrm8+bNU1xcnMLCwpSZmSkfH59CY6xWqzIzMy/ZX5QpU6YoICDAvgUHBzv9GAAAAAAAuFamBO9du3bphRde0BdffCFPT09ZrVZlZWUVGpeYmCgfH59L9hdl7NixSklJsW+xsbFOPw4AAAAAAK6V0+7xLhATE6OwsDB9+umnatiwoSSpRo0aio6OLjQ2OjpazZs3l7+/v9auXVtkf+3atYt8H29vb3l7ezu3eAAAAAAAnMypZ7zT0tL04IMP6vnnn9eDDz5ob69UqZK8vLx08OBBe1tubq5WrFihjh07qnXr1lq/fr1yc3Pt/f/73/+UnZ1d5L3fAAAAAACUFk4L3nl5eerdu7fatWunESNGFOofNWqUBg4cqOPHjystLU3Dhw9Xp06ddPPNN6tatWq6++67NWrUKKWnpys2NlaDBg3S+PHjnVUeAAAAAAAu4bTgPXz4cK1bt04zZ86Up6enfevYsaMkaciQIercubOaNWumatWqKScnRzNnzrTv//HHHyspKUlVqlRRy5Yt1aNHDw0YMMBZ5QEAAAAA4BJuhmEYri7CGVJTUxUQEKCUlBT5+/u7upwrUuvF1a4u4YZz9PXQSw8CAAAAgIu43Bxq2uPEAAAAAAAAwRsAAAAAAFMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBG8AN5d5775W7u7vefvtth/aoqCj5+PjIzc1NCQkJhfabOHGiKleuLH9/f/Xv31/p6en2vsOHD6tr164KCAhQSEiIFi1aZPpxAAAAoPQgeAO4oWzcuFGRkZGF2hs0aKCzZ8+qZs2ahfpmzpyp5cuXa8eOHTp+/Ljc3Nw0aNAgSVJGRoa6dOmiHj16KC4uTosXL9b//d//af369aYfCwAAAEoHT1cXAAAl3dSpU/X555/r5ptvlnQuiNepU0d///23Dh8+rCZNmmjgwIGSpNtvv11vvPGG5s2bp44dO7qybAAAAJQQnPEGgIs4deqUMjIydMcdd9jbypQpo4cfflgbNmxQXl5ekfslJycXV4kAAAAo4QjeAHARMTExqlu3bqH2kJAQHTlyRG3atNGuXbs0d+5cZWZmau/evXrhhRfUrl07F1QLAACAkojgDQAXkZmZKR8fn0LtVqtVmZmZ8vf318qVKzV79mxVrVpVHTt21JkzZ/TUU0+5oFoAAACURARvALgIq9WqrKysQu2JiYn2QN6sWTP9/PPPOnbsmCwWi6ZOnarAwMBirhQAAAAlFcEbAC6iRo0aio6OLtQeHR2t2rVrO7SNGzdOzZo1U58+fYqrPAAAAJQCBG8AuIhKlSrJy8tLBw8etLfl5uZqxYoVDquW7969W4sWLdLMmTNdUSYAAABKMII3AFzCqFGjNHDgQB0/flxpaWkaPny4OnXqZH+8WH5+voYMGaLXX39d1atXd3G1AAAAKGkI3gBwCUOGDFHnzp3VrFkzVatWTTk5OQ5ntjMzM9WtWzcWVAMAAECR3AzDMFxdhDOkpqYqICBAKSkp8vf3d3U5V6TWi6tdXcIN5+jroa4u4YbDPC9+zHMAAABzXW4O5Yw3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGCiqwre9957r9zd3fX22287tG/btk233XabrFarWrRooV9++cWhf9asWapRo4Z8fX0VFham+Ph4e5/NZtMzzzyjcuXKKSgoSM8//7xyc3OvpjwAAAAAAEqMqwreGzduVGRkpENbfHy8wsLCFBkZqdTUVI0bN07dunVTXFycJGndunWaPHmyVq1apYSEBDVp0kRhYWH2/SdMmKC//vpLUVFRioqK0oEDBzRhwoRrODQAAAAAAFzPaZeaz5kzR48++qh69OihMmXKqHv37goPD9eMGTMkSVOnTtU777yjpk2bymq1atKkScrPz9eGDRuUk5Oj2bNna968eapcubIqVqyoBQsW6JNPPlFGRoazSgQAAAAAoNg5LXhv2bJF3bp1c2jr1auX1q9fL8MwtHPnToWGhhbZv2/fPjVs2FBVqlSx9wUFBalVq1b6+eefnVUiAAAAAADFzmnBOyYmRnXr1nVoCwkJ0ZEjR5SYmKjAwEBZLJYi+4va9/z+omRnZys1NdVhAwAAAACgpHFa8M7MzJSPj49Dm9VqVWZmZpF9V9JflClTpiggIMC+BQcHO+dAAAAAAABwIqcFb6vVqqysLIe2xMRE+fj4FNl3Jf1FGTt2rFJSUuxbbGyscw4EAAAAAAAnclrwrlGjhqKjox3aoqOjVbt2bQUFBenMmTOy2WxF9he17/n9RfH29pa/v7/DBgAAAABASeO04N2mTRutW7fOoW3p0qXq1KmT3Nzc1Lx5c23YsKHI/ttuu00HDhxQcnKyvS8pKUk7d+7U3Xff7awSAQAAAAAodk4L3gMGDND8+fO1du1a5ebmatWqVVq8eLGGDRsmSRo9erRGjhypqKgoZWVladKkSbJarWrfvr28vLzUr18/DRo0SImJiUpISFD//v319NNPX/BScwAAAAAASgOnBe/KlStryZIlGjt2rPz8/PTKK69o+fLlqlSpkiSpS5cuGjlypDp37qzy5ctrz549WrZsmX3/iRMn6qabblKdOnVUv3591atXT6+88oqzygMAAAAAwCXcDMMwXF2EM6SmpiogIEApKSml7n7vWi+udnUJN5yjr4deehCcinle/JjnAAAA5rrcHOq0M94AAAAAAKAwgjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmcmrwTkxMVN++fVW+fHnVqFFD77zzjr3vzz//VJs2bWS1WtW4cWOtWbPGYd/ly5erfv36slqt6tChgw4dOuTM0gAAAAAAcAmnBu/w8HDVrVtXsbGx2rVrl7Zs2aL58+crOztbXbt21WOPPaaUlBTNnDlTAwcO1P79+yVJ+/fv1+DBgzV79mylpKSod+/e6tKli7KyspxZHgAAAAAAxc6pwXvz5s166aWX5Ovrq8qVK2v48OH65ptv9PXXX6tJkyaKiIiQl5eX2rZtq8jISL311luSpGnTpmnMmDG655575OXlpSFDhqhFixb6/PPPnVkeAAAAAADFzqnBOzQ0VGPGjFFqaqpiY2M1efJkVa5cWVu2bFG3bt0cxvbq1Uvr16+XpEv2AwAAAABQWjk1eE+fPl3Lli1TQECAatSooZMnT+rll19WTEyM6tat6zC2QoUKysrKUnZ2tk6cOKHatWs79IeEhOjIkSMXfK/s7GylpqY6bAAAAAAAlDROC965ubl66KGH9PjjjysxMVHHjh1Tly5ddOrUKWVmZsrHx6fQPlarVZmZmcrPz5e7u3uRfRcyZcoUBQQE2Lfg4GBnHQoAAAAAAE7jtOC9atUqWa1WvfHGG/ZVzSdNmqR+/frJy8uryIXSkpKS5OPjI3d3dxmG4dCXmJhYZFgvMHbsWKWkpNi32NhYZx0KAAAAAABO47TgffDgQbVt29ahzdfXV4GBgZKk6Ohoh764uDiVL19eXl5eqlatmmJiYhz6o6OjC11+fj5vb2/5+/s7bAAAAAAAlDROC961a9dWVFSUQ1tWVpb+/PNP9e3bV+vWrXPoW7p0qTp16iRJatOmzUX7AQAAAAAorZwWvB966CHt2bNH06dPV1pamk6cOKHw8HDddddd6tmzp3755RctWLBANptN27dv15tvvqnnn39ekjR8+HC9+uqr2rlzp2w2m+bMmaPff/9djz32mLPKAwAAAADAJZwWvC0Wi1atWqVvv/1WlStXVqtWrVSpUiUtWLBAFotFK1eu1KxZs1S2bFkNGDBAs2bNUuPGjSVJt9xyiz788EP997//lb+/vxYuXKg1a9bI29vbWeUBAAAAAOASns58sXr16um7774rsq9Ro0baunXrBfft3r27unfv7sxyAAAAAABwOac+xxsAAAAAADgieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIlOD97FjxzR//nwz3wIAAAAAgBLN1OA9YsQIxcfH2z/ftm2bbrvtNlmtVrVo0UK//PKLw/hZs2apRo0a8vX1VVhYmMO+AAAAAACURqYF7zVr1ujvv//W6NGjJUnx8fEKCwtTZGSkUlNTNW7cOHXr1k1xcXGSpHXr1mny5MlatWqVEhIS1KRJE4WFhZlVHgAAAAAAxcKU4J2dna2RI0dq5syZ8vT0lCTNmTNHjz76qHr06KEyZcqoe/fuCg8P14wZMyRJU6dO1TvvvKOmTZvKarVq0qRJys/P14YNG8woEQAAAACAYmFK8H7zzTfVrl07tW7d2t62ZcsWdevWzWFcr169tH79ehmGoZ07dyo0NLTIfgAAAAAASiunB+/Y2FhNmTJF3333ncqVK6dnn31W+fn5iomJUd26dR3GhoSE6MiRI0pMTFRgYKAsFkuR/UXJzs5WamqqwwYAAAAAQEnj9OA9adIkde7cWbt379aePXu0detWTZ8+XZmZmfLx8XEYa7ValZmZWWTf+f1FmTJligICAuxbcHCwsw8FAAAAAIBr5unsF1yxYoWioqJUrlw5SdKnn36q3r17y2q1Kisry2FsYmKifHx8iuw7v78oY8eOtS/cJkmpqamEbwAAAABAiePUM96nT5+Wr6+vPXRLUuPGjXX8+HHVqFFD0dHRDuOjo6NVu3ZtBQUF6cyZM7LZbEX2F8Xb21v+/v4OGwAAAAAAJY1Tg3dQUJCSk5OVnJxsbztw4IBq1KihNm3aaN26dQ7jly5dqk6dOsnNzU3NmzcvtIJ5QT8AAAAAAKWVU4O3u7u7nnzyST355JM6deqUoqOjNXDgQI0YMUIDBgzQ/PnztXbtWuXm5mrVqlVavHixhg0bJkkaPXq0Ro4cqaioKGVlZWnSpEmyWq1q3769M0sEAAAAAKBYOf0e79dff10vvPCCmjRpIl9fXz3zzDMaNGiQJGnJkiWKiIhQWFiYmjRpouXLl6tSpUqSpC5duujYsWPq3LmzEhMTdf/992vZsmXOLg8AAAAAgGLlZhiG4eoinCE1NVUBAQFKSUkpdfd713pxtatLuOEcfT300oPgVMzz4sc8BwAAMNfl5lCnP04MAAAAAAD8fwRvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATGRq8H7rrbeUkJAgSfrzzz/Vpk0bWa1WNW7cWGvWrHEYu3z5ctWvX19Wq1UdOnTQoUOHzCwNAAAAAIBiYVrw/v333zVhwgRJUnZ2trp27arHHntMKSkpmjlzpgYOHKj9+/dLkvbv36/Bgwdr9uzZSklJUe/evdWlSxdlZWWZVR4AAAAAAMXClOCdk5Oj//73v8rNzZUkff3112rSpIkiIiLk5eWltm3bKjIyUm+99ZYkadq0aRozZozuueceeXl5aciQIWrRooU+//xzM8oDAAAAAKDYmBK8x40bp1tuuUXVq1eXJG3ZskXdunVzGNOrVy+tX7/+svoBAAAAACitnB68N2/erKVLl2r69On2tpiYGNWtW9dhXIUKFZSVlaXs7GydOHFCtWvXdugPCQnRkSNHLvg+2dnZSk1NddgAAAAAAChpnBq8U1NT9eSTT2ru3LkKCAiwt2dmZsrHx6fQeKvVqszMTOXn58vd3b3IvguZMmWKAgIC7FtwcLDzDgQAAAAAACdxavB+5pln1LNnT7Vv396h3Wq1FrlQWlJSknx8fOTu7i7DMBz6EhMTiwzrBcaOHauUlBT7Fhsb65RjAAAAAADAmTyd9UIrVqzQokWL5OHhoQ8//FDSucvBq1evrptuuknR0dFq166dfXxcXJzKly8vLy8vVatWTTExMapZs6a9Pzo6utDl5+fz9vaWt7e3s8oHAAAAAMAUTjvj3a1bN9lsNmVlZdm3mjVr6vjx43rttde0bt06h/FLly5Vp06dJElt2rS5aD8AAAAAAKWVac/xPl+PHj30yy+/aMGCBbLZbNq+fbvefPNNPf/885Kk4cOH69VXX9XOnTtls9k0Z84c/f7773rssceKozwAAAAAAExTLMHbYrFo5cqVmjVrlsqWLasBAwZo1qxZaty4sSTplltu0Ycffqj//ve/8vf318KFC7VmzRouJQcAAAAAlHpOu8e7KEePHrV/3KhRI23duvWCY7t3767u3bubWQ4AAAAAAMWuWM54AwAAAABwoyJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAA17Ho6Gh16dJFZcuWVUhIiBYvXmzvi4qKko+Pj9zc3JSQkOCwX1pamoYOHarKlSuratWqGjt2rGw2W3GXDwDAdYHgDQDAdcowDD388MPq0KGDEhIS9NVXX2ns2LHasWOHJKlBgwY6e/asatasWWjfgQMHKj8/X1FRUfr111/1v//9T5MmTSruQwAA4LpA8AYA4Dp15swZPf300xozZoy8vb116623qlu3btq6detF9zt79qw2btyoGTNmqFy5cqpatarmz5+v+fPnF1PlAABcXwjeAABcp8qVK6fBgwdLknJycvTDDz9o2bJl6tChw0X3y8/Pl2EYhdqTkpJMqRMAgOsdwRsAgBtAq1atdN9996l9+/a6/fbbLzrWz89PLVq00PDhw5WcnKx//vlH4eHhatu2bTFVCwDA9YXgDQDADWD79u3avn27Dh48qMmTJ19y/Pz585WQkKC6deuqWbNmWr16tV566aViqBQAgOuPp6sLAAAA5rNYLLrzzjv1zTffqGnTpho3btxFx1esWFFfffWVJCk0NFRVq1ZVmzZtiqNUAACuOwRvAACuU0ePHpW3t7duuukme1u1atXk4eGhzMxMWa3WS77GsmXLtG/fPn3++edmlgoAwHWNS80BALhObdu2Tc8995xD29GjR1W2bNnLCt3p6ekaOXKkZs6cqYCAALPKBADgukfwBgDgOtW9e3f98ssvmj9/vjIzMxUVFaX//Oc/mjBhwmXtHxkZqbZt2+qhhx4yuVIAAK5vBG8AAK5Tvr6+WrVqlRYuXKiKFSvqvvvu0+OPP64nn3zysvavWrWqPvjgA3OLBADgBuBmFPWgzlIoNTVVAQEBSklJkb+/v6vLuSK1Xlzt6hJuOEdfD3V1CTcc5nnxY54XP+Z58WOeAwBc6XJzKGe8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMBHBGwAAAAAAExG8AQAAAAAwEcEbAAAAAAATEbwBAAAAADARwRsAAAAAABMRvAEAAAAAMJFTg3dycrLCw8NVsWJF1apVS6+//rry8/MlSdu2bdNtt90mq9WqFi1a6JdffnHYd9asWapRo4Z8fX0VFham+Ph4Z5YGAAAAAIBLODV49+rVS9WqVdPff/+tH374QcuXL9e0adMUHx+vsLAwRUZGKjU1VePGjVO3bt0UFxcnSVq3bp0mT56sVatWKSEhQU2aNFFYWJgzSwMAAAAAwCWcFrz37t2rU6dO6bXXXpO/v7/q1aunuXPn6pNPPtGcOXP06KOPqkePHipTpoy6d++u8PBwzZgxQ5I0depUvfPOO2ratKmsVqsmTZqk/Px8bdiwwVnlAQAAAADgEk4L3nl5eRo9erTc3NzsbcHBwYqPj9eWLVvUrVs3h/G9evXS+vXrZRiGdu7cqdDQ0CL7AQAAAAAozZwWvJs3b65+/fo5tK1atUrNmzdXTEyM6tat69AXEhKiI0eOKDExUYGBgbJYLEX2AwAAAABQmpm2qnlcXJyeffZZRUZGKjMzUz4+Pg79VqtVmZmZRfad338h2dnZSk1NddgAAAAAAChpTAne2dnZ6tmzp4YNG6ZWrVrJarUqKyvLYUxiYqJ8fHyK7Du//0KmTJmigIAA+xYcHOz04wAAAAAA4FqZErwHDBig4OBgvfTSS5KkGjVqKDo62mFMdHS0ateuraCgIJ05c0Y2m63I/gsZO3asUlJS7FtsbKzzDwQAAAAAgGvk9OD9yiuv6MiRI5o3b559obU2bdpo3bp1DuOWLl2qTp06yc3NTc2bNy+0gnlB/4V4e3vL39/fYQMAAAAAoKTxdOaLLVq0SJ999pm2b9/usFjagAEDdPvtt6tdu3bq3Lmz1q1bp8WLF2vPnj2SpNGjR2vkyJH65ptvVKtWLb311luyWq1q3769M8sDAAAAAKDYOS14b9myRf3795fNZlPVqlUd+v7++28tWbJEERERCgsLU5MmTbR8+XJVqlRJktSlSxcdO3ZMnTt3VmJiou6//34tW7bMWaUBAAAAAOAyTgvebdu2VXZ29gX7a9asqX379l2wf/DgwRo8eLCzygEAAAAAoEQw7XFiAAAAAACA4A0AAAAAgKkI3gAAAAAAmIjgDQAAAACAiQjeAAAAAACYiOANAAAAAICJCN4AAAAAAJiI4A0AAAAAgIkI3gAAAAAAmIjgDQAAAACAiQjeAAAAAACYiOANAAAAAICJCN4AAAAAAJiI4A0AAAAAgIkI3gAAAAAAmIjgDQAAAACAiQjeAAAAAACYiOANAAAAAICJCN4AAAAAAJiI4A0AAAAAgIkI3gAAAAAAmIjgDQAAAACAiQjeAAAAAACYiOANAAAAAICJCN4AAAAAAJiI4A0AAAAAgIkI3gAAALjujBs3Th4eHvL09JSnp6eaNGkiSVq/fr1uu+02+fn5qU2bNtq7d6+LKwVwIyB4AwAA4Lrzxx9/aMOGDcrNzVVubq7+97//6dixY3rsscf01ltvKSkpSaNGjdJDDz2kjIwMV5cL4DpH8AYAAMB1548//lCDBg0c2lJSUjRv3jx17txZXl5e6tmzpypUqKA///zTRVUCuFEQvAEAAHBdycrKUnJysipXruzQ3rRpU3Xt2lWSlJaWphkzZiglJUWNGjVyRZmA07z11ltKSEiQJB04cEAdOnSQv7+/mjZtqtWrV7u4OkgEbwAAAFxnoqKilJGRoeDgYFWvXl0vvPCCbDabvT8lJUX+/v6KiIjQSy+9JB8fHxdWC1yb33//XRMmTJAkJSUl6b777tPQoUMVHx+v999/X4MGDWItgxKA4A0AAIDriq+vr3788Uf99ddf2r59u/744w+98sor9v6AgACdOXNGS5cu1SuvvKLNmze7rljgGuTk5Oi///2vcnNzJUnz589X9+7d9cgjj8hqteree+/VhAkTNHfuXBdXCk9XFwAAAAA4U7169VSvXj1JUnBwsD777DOFhITotddes48JCAhQz549lZ2dralTp6pdu3auKhe4auPGjdMtt9yilJQUSVLFihV15513OowJDg7Wpk2bXFAdzscZbwAAAFzXypUrJ8Mw9Ntvv+ns2bMOfbfeeqtOnjzposqAq7d582YtXbpU06dPt7f17dtXd911l8O4VatWqXnz5sVdHv6F4A0AAIDrxu7duzVkyBCHtqioKFksFk2bNk2LFi1y6Nu1axeLq6HUSU1N1ZNPPqm5c+cqICDgguM2bNigNWvW6KmnnirG6lAULjUHAADAdaNRo0Zat26dZsyYof79++vgwYN64okn9MILL6ht27Z6+OGH1bhxY91xxx3aunWrIiMj9cMPP7i6bOCKPPPMM+rZs6fat29/wTFHjx5V37599fnnn180nKN4cMYbAAAA1w2r1arVq1dryZIlCgoK0oMPPqjHHntMERERuvXWW/XRRx9pyJAhCgwM1HPPPae5c+cqJCTE1WUDl23FihVatGiRPvzwQ1ksFlksFh07dkzVq1fXypUrJZ1buT80NFQTJky4aDhH8eGMNwAAAC5brRdLyTOBWz2niq3OfTjzjDRz7Jr/39d1iipLSpY04Ics6YeSfUxHXw91dQkoQbp16+bweDxJqlWrln799VdVqFBBubm56tWrl/2xYigZOOMNAAAAANeJoUOHysfHR++8846rS8F5OOMNAAAAANeBN998U5988onc3d3l5eVlb69Vq5YOHz7swsrAGW8AAAAAKMWOHj2qChUqaMyYMTIMQ3l5ecrNzbVvhG7X44w3AAAAAJyn1KxlcB253tcy4Iw3AAAAAAAmIngDAAAAAGAigjcAAAAAACYieAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgohIVvFNTU9WnTx/5+fmpatWqeuONN1xdEgAAAAAA16REPcf7qaeeksVi0YkTJ3TmzBn16tVLgYGBGjx4sKtLAwAAAADgqpSY4H3ixAlt3LhRx44dk8ViUUBAgBYsWKAHHniA4A0AAAAAKLVKzKXm27ZtU+fOnWWxWOxtDRs2lJ+fnw4dOuTCygAAAAAAuHol5ox3TEyM6tatW6g9JCRER44cUb169Rzas7OzlZ2dbf88JSVF0rn7xEub/Oyzri7hhlMa50lpxzwvfszz4sc8L37M8+LHPC9+zPPixzwvfqV1nhfUbRjGRceVmOCdmZkpHx+fQu1Wq1WZmZmF2qdMmaL/+7//K9QeHBxsSn24vgS85+oKAPMxz3EjYJ7jRsA8x42gtM/ztLQ0BQQEXLC/xARvq9Wqs2cL/2YpMTGxyEA+duxYjR492v55fn6+kpKSFBQUJDc3N1NrxTmpqakKDg5WbGys/P39XV0OYArmOW4EzHPcCJjnuBEwz4ufYRhKS0tT1apVLzquxATvGjVqaO3atYXao6OjVbt27ULt3t7e8vb2dmgLDAw0qzxchL+/P3+xcd1jnuNGwDzHjYB5jhsB87x4XexMd4ESs7ha69attX79euXm5trb/ve//yk7O7vIe78BAAAAACgNSkzwrlatmu6++26NGjVK6enpio2N1aBBgzR+/HhXlwYAAAAAwFUrMcFbkj7++GMlJSWpSpUqatmypXr06KEBAwa4uixcgLe3t15++eVCl/wD1xPmOW4EzHPcCJjnuBEwz0suN+NS654DAAAAAICrVqLOeAMAAAAAcL0heAMAAAAAYCKCNwAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjeuWkZGhpo2barc3Fx726ZNmzRu3DiHNqA0S09Pl7+/v8OcXrNmjfr06aOcnBwXVgZcmZSUFI0YMeKC/b6+vjp9+rT984yMjOIoCwCAGwLP8cZVy83NlcViUWZmpj7//HOFh4dr06ZN6tixo1JSUuTn5+fqEoFrlpeXJ29vb2VkZOjNN9/UhAkTtGXLFrVv3555jlIlNTVVjRs3VmxsrGbPnq2zZ8/Kzc1NVqtVgwYNUoUKFRQTEyMfHx/Fx8erWbNm+vnnn1WzZk1Xlw44RW5urp566im9//77Klu2rPbv3y93d3c1btzY1aUB12zNmjXy8fGRu3vh86pubm6qUqWK6tWr54LKUIDgjUvKyMjQfffdJ29vb0mSYRgKCAjQ8uXL5efnp6SkJFWpUkVJSUnat2+f7rjjDqWmpsrX19fFlQOXLz09XSEhIQ7zPCgoSL/++qvKli1rn+eJiYn67bff1KxZM+Y5SpXs7Gw1adJEhw4dUoMGDdS2bVtJ0saNG3X48GHVrFlTx44dkyRNnz5dn376qfbs2ePKkoErlp2drY8++khWq1UeHh46e/aswsLC1LFjR+3Zs0eBgYE6c+aM/Pz89Pjjj+vnn3/WoUOHVKZMGVeXDlyVmJgY1ahRQzfddJNatGghwzD0008/6Z577tHu3bvVpEkTeXl5acuWLdq/f79q1Kjh6pJvWFxqjkvy9vZWbGysBgwYoMOHD2vgwIH666+/JEkWi0VeXl7y9PS0fy5JXl5eLqsXuBpWq1UWi0WfffaZ3NzctHDhQp09e1bSub8DZcqUsc/zgvldENKB0sDT09NhDs+ePVuzZ8+Wh4eHve3hhx9WfHy8li1bpueee86V5QJXxTAMjR49WosWLdL8+fM1evRoZWdn68iRI7JYLPL29pa3t7dWrlypZcuW6ZNPPiF0o1S76667tHDhQvn4+Ojbb7/VypUrVb16da1cuVKtWrXSvHnztGrVKvXr18/+cw1cw9PVBaDk8/T0VGBgoPr06aM33nhDffr00ZQpU+x9kuz/adlsNpUpU4b/xFDqeHh4yNfXV61bt7b/WXC51r8Dd05OjiwWi70dKA08PDwUHx+vYcOGKS4uTsOGDZMkh3neoUMHtW3bVsnJyerZs6crywWuire3tzw8PLR582ZJko+Pj8MvT93d3TV37lyNHz9en3/+uTp16uTiioFrY7VatWLFCh07dkwTJ06UJCUkJGjixIk6ePCg3n33Xfn7+8vHx0cNGjRwcbU3Nn5qxFUp+EEtOztbEydOVHp6uiZOnKgTJ06oSpUqLq4OcI6CeZ6Zman+/fsrOTlZ/fv31+nTp3XTTTe5uDrgylmtVrVu3Vpr1qxR69atZRiGNm7cKOncPYAjR45UWlqa1qxZwxUdKJXc3Nzk5ubm0Obh4SF3d3eNHz9eNptN27Zt0y+//KJatWq5pkjACX799VetXLlS3t7eWrJkiWrWrGm/gsnNzU0eHh72P93d3ZWdne3iisGl5rgqBUsD5Ofn69ChQ3r44Yd16NAh7du3T7feequLqwOco2Ceu7u7q1q1aho1apSqVaumnJwcNW/e3MXVAVcuICBAffr0Ubly5dSnTx/17dtXkjRy5EilpqZKkv755x/9/vvv2rt3rytLBa7av5cvys/Pl2EY+vvvv5WXl6cVK1Zo4cKFhcYBpYnNZtP333+vY8eO6fjx43Jzc1P//v315JNPKiAgQP369VPNmjX19NNPa/z48XrnnXdcXfINjzPeuCoF/1lZrVZ99tln9vauXbvaf5ADSruCee7l5aVJkybZ21q3bq3Ro0e7sjTgqhw9elQtW7bUoUOH1LJlS3t7pUqVlJycrLVr1+qnn37SoEGDtHTpUt1+++0urBa4cvn5+YXOeOfm5iovL09ffPGFvv32W23atElPPPGEDh06pPnz57uoUuDa3HXXXdq+fbumTp2qLl26yNPTU3feeaf9ar277rpLSUlJCgkJUceOHTVx4kT+TXcxznjjkvLy8pSTk6O//vrL/mfBM41zc3O1f/9+/fnnn3r99deVlZWlRx55xMUVA1cuLy9P6enp+v777+1/FszzvLw8/fzzz/ruu+8UERGhm2++Wffff7+LKwauXJUqVfTZZ5+pRo0aWrhwoRYsWCDDMPTSSy+patWqGj9+vCwWi7p166Zt27a5ulzgimVlZSk3N9fh8tq0tDTZbDbl5OTIZrOpQYMG2rRpkzZu3KhZs2a5umTgqp0+fVpRUVGaMWOGDh8+rGPHjik6OlrR0dE6duyY0tLS9Oeff6ply5bq0KGDdu3a5eqSb2ic8cYlZWVl6a+//lLDhg1lGIYaNGig6tWrSzp3j/fevXs1ePBg+fn5aceOHS6uFrg6mZmZysrK0uDBgyVJgwcPVvny5SWd+ztQsBhVXl6e1q1b58pSgauSn58vT09PhYSE2O/9c3NzU35+vqRzv0jdsmWLfvjhB1WtWlW//fabiysGrpy3t7f2799vn+N5eXmqXr26PvzwQ+Xk5Cg3N1cZGRmyWq2aPn26+vXrpz59+vBoSJRK7u7u+vbbb/Xxxx9Lklq1aqX4+HiHZ3lnZ2erS5cuWrp0KesauBjP8cZlKVitvEBOTo48PT1lsViUk5OjxMRETZ06VR999JHGjx+vUaNGubBawHny8vJksVhks9mUl5enuXPn6sUXX1SfPn305ptvsgAVSo2srCw1bNhQ0dHRateuneLj42Wz2VS5cmVt375d1atX19GjR+Xp6amEhARVqlRJiYmJKleunKtLB67Yl19+qbCwsEKPN42Pj9fWrVs1YsQIrV27Vn/88Yf+85//uKhK4Nqkp6erRo0amjdvnu69917dd999uueeezR8+HBJ526Pa9mypQ4cOKDAwEDXFguCN67e2bNn5efnJ5vNZl9Fcfv27erfv7+2bt2qoKAgF1cIXLv09HT5+/vbf9kkSX///bcGDBig1atXc5YEpUZSUpLq1Kmj5OTkIvsDAgIUGxsrf39/paWlacGCBXrqqad4PCRKlZiYGPXs2VP79u3T0qVLdfbsWU2ZMkUWi8U+xjAM/fXXX/L09NRXX32ljh07urBi4OqlpqaqatWqatOmjX777TelpaWpadOmDgvAzp07V/369ZMkffDBB64qFeJSc1ymvLw8nThxQsHBwfZFSywWi/bv3+9wOctdd92l3bt3y8fHx1WlAk7l5+entLQ0h2d216lTRxs3biy0gA9QkpUvX/6CoVuSFi9eLKvVKkkqW7asIiIiiqs0wGmqVKmi5s2ba/HixapTp44+//xznT17Vs8++6zDuLy8PO3cudN+qwVQGmVkZMjb21vr1q1TXl6eNmzYoGnTpmnatGkKDQ1V9+7d9d577yk9PV2JiYmuLveGxxlvXJbY2FjVqlVLcXFxqlixokPfwIEDdcstt2jEiBEuqg4AAKCw7777TqtWrdKHH37o6lIAp8vKytKePXt09913O7Rv3LhRCxcu1IcffsjJsBKE4I3LkpSUpAoVKigtLc3h0tohQ4Zo7ty5+uijj9S/f38XVggAuBynT5/WHXfcod9+++2C92/HxsZqwIAB+v7774u5OgAArk88TgyXxdvbW25ubg6LlDzzzDNaunSpfvzxR0I3AJQCaWlpslqtOn78uKxWq2JjY5WQkKDTp08rJiZGp0+f1uTJk+Xh4aFff/3V1eUCVy0zM1Nff/21JKlGjRqKjY11cUWAa5w6dUrNmjXTwYMHXV3KDY/gjctSsLhOwX2uX3/9tebOnas1a9aobdu2riwNAHAZ5s+fr+eee04Wi0Vubm6yWCyqX7++KleurCpVqujmm2/WihUrNGXKFPn7+zssRgWUNjabTU8//bQkycvLSxUqVNC2bdt0//33q2vXruratas6d+6sBx980MWVAldv37598vf31z///CNJSklJ0ZgxY5SQkGAfY7VatW/fPtalKQEI3rgsHh4eMgxDixYtkiR169ZNP/74o1q2bOniygAAl+Ovv/6yP8u7YFHMWrVqKS8vTy1bttScOXPk6+uroKAgeXt7OywoCJQWeXl5aty4sR5++GElJyerQ4cOOnnypLy9vWW1WpWcnKwGDRqoQ4cO2rt3r1566SVXlwxcNR8fH6Wnp9tvA/Xy8tI777yjs2fP2scU/BL134/WQ/Hjf1VckREjRujdd99VkyZNJEnTp0936M/NzdWZM2e0Zs0aV5QHALiApk2bavXq1ZL+/w9g5z+HvuB2orJly8rT05PgjVLJZrNp/Pjx8vX11bBhw/TCCy9owIABcnd3l9VqVVBQkBo0aKA6derIy8ur0KJUQGlScAVTwRMprFarDMNw+Pe74OOCR//CdTjjjcvm5uamgwcPqmXLllq0aJF27Nghm83msOXk5CgnJ8fVpQIA/qV27dqKjo7W5s2bJUmbN2/W2bNntXnzZqWmpioqKkqHDh1SVlaWtmzZ4vCoSKC0sFgs6tChg0JDQ+Xj46P777/fvqozl9rielNwK2jBn9K5eX7+XC/4mH/TXY9fZ+OyFCx+X6FCBc2cOVNt2rRRRESEBg4cqI4dO7q4OgDApVSuXFl79+7Vs88+q5ycHD377LM6ceKEnn32WcXExGjx4sXy9PTUyZMn9eyzz/JDGkolm82mm266SZ6ensrLy1OZMmWUn58vm82mrKwsZWZmKjExUX5+fsrLy1NsbKyCg4NdXTZwVdzd3WUYhsPP4oZhqFevXoWuaILrEbxxWXJzcyWdu3fKw8NDffv2lb+/v8LCwvTDDz+oVatWLq4QAHAx5cuXV40aNbRr1y75+flp165duu2227Rr1y7dddddGjp0qMqVK6dx48Zp165dqlOnjqtLBq6Yu7u7YmNj7WsX/P3336pXr57S09OVmJioEydOaMGCBZKkcuXKqXXr1oqJiXFx1cC1Of/n8H//TG4Yhn766SfCdwlA8MZlsdlsks4F8IJ7RB5++GE9/fTTeuSRRy76PFgAgOtZrVadOXNG0rlfop7/Z4H8/HydPXtWhmEoPz+/uEsErpmHh4eqVaumzMxMzZo1S76+vho4cKA9iL/99tvq0qWLtm3bpg4dOri6XOCaGIYhNzc3TZky5aLj3nzzTfvVq3AdriPDZcnKypIkZWdnO7RPmjRJVqtV4eHhrigLAHCZPDw8lJmZKcMw7L9MTUpKUmRkpI4fP66vv/5amZmZSk5OVnZ2tv1KJ6A0MgxD/fr104kTJ5SRkaEKFSooLy9PI0eOlLe3tyZPnqwlS5a4ukzgmpx/Raokbd++XTExMYU2Nzc3gncJwBlvXJacnBw1atTI/sNaAQ8PD0VGRmrt2rXKz8/nnkAAKKFsNpvy8/OVlZUlwzCUl5enJ598Um5uburfv7+ysrLs98amp6cX+kUrUBrk5+erQ4cOGjNmjL1t69atWrBggfLy8pSVlaUFCxbojjvu0IABA9SoUSM1btzYhRUDV6/g3+ns7GxlZ2erdevWDiG74GM3N7dCVzih+BG8cVmqVaum/fv3F9n3+OOPq3fv3oRuACjBDMPQ0qVLlZGRIcMwlJGRoddee63QuPj4eB07dkwZGRkuqBK4Nunp6br99tvVu3dveXh4KCMjQ7Gxsfrmm29kGIbS09P1zTffSJJuuukmffzxx/rggw9cXDVwddLT0+3zunz58jp8+LDDomrSuV+61qlTh6uYSgA3g+sOAAC4IeTl5engwYPaunWrwsPDC/2AViAjI0Pbtm3TfffdV8wVAs5x/PhxDRgwQCkpKRo8eLD69eunkydPqkWLFjp+/Likc1fzFTzTHiiNMjIy9L///U/NmjVzeKTY+RITE1WxYkX9/vvvatKkSTFXiPMRvAEAuEHExsaqVq1aiouLU8WKFR36Bg4cqFtuuUUjRoxwUXWA873//vsaMGCA/Pz8lJWVpYMHD+rWW291dVlAsbHZbPrrr79Ut27dC/6yFcWDa4MBALhB+Pr6yjAM+fj4OLQPGTJEn332mcqWLeuiygBzjBgxQn5+fpIki8VC6MYNp0yZMmrcuDGhuwQgeAMAcIPw9vaWm5ubw+W1zzzzjJYuXaoff/xR/fv3d2F1gPPk5eXpyJEjkqTU1FT5+/srLi7OYczx48cVGxvrivIApylfvnyhtl69emnz5s0uqAYXQ/AGAOAGUXAPoKfnubVVv/76a82dO1dr1qxR27ZtXVka4FSpqamqV6+ecnNz5ePjo/T0dIcrOj755BM1adJEr7zyiuuKBJwgMDBQhmEoJiZGkpSZmak1a9YUehIRXI97vAEAuEHk5eWpTJkyWrBggfr27au8vDz9+uuvatWqlatLA5zKZrPJz8/P/rglT09PZWVlKT09Xf3799eaNWtUt25d7d69m0twUWqlpaWpXr168vLyUuPGjbV27VrNnTtXkydP1i+//KInn3xSHh4eMgxDgYGBmjt3rqtLvqHxODEAAG4wI0aM0Lvvvmtf4Xb69OkO/bm5uTpz5ozWrFnjivKAa3L27Fn5+Pg43FLh7u4uT09PxcbGKjc3V9u3b9eDDz5I6EapFR8fr9atW0uS1q1bp0aNGik5OVmRkZGKiIiQm5ubtm7dqnfffVdjx47VjBkzXFwxuNQcAIAbiJubmw4ePKiWLVtq0aJF2rFjh2w2m8OWk5OjnJwcV5cKXDHDMHTzzTerZcuWysrKUsuWLdWyZUvl5eVp48aNslgs+vbbb3X77bcrMTFRmZmZri4ZuCq+vr569tln5eXlpcWLFystLU29evXSk08+qa+++kqJiYny9fVVeHi4AgIC1L17d1eXfMPjjDcAADeIgrvLKlSooJkzZ6pNmzaKiIjQwIED1bFjRxdXB1w7m82mF198UWXLllVERIQiIiJkGIYGDBig9957Tz///LPmzZun0NBQValSRYcPH9Ytt9zi6rKBK+bn56ehQ4fqlltu0fTp03XzzTdr3LhxGjVqlFatWsXVHCUQwRsAgBtEbm6upHP3ent4eKhv377y9/dXWFiYfvjhB+71Rqnn5eWlUaNGKTc3VxEREQoPD7cH76+++kpLly7V8OHDtW7dOpUvX14HDx4keKNU69evn1atWqWDBw9qx44dMgxDbm5ucnNzc3Vp+BcuNQcA4AZRsMptQQCXpIcfflhPP/20HnnkESUnJ7uqNMCpUlJSZLPZlJ2dbZ/3NptNffr00YEDB+Tp6al9+/Zpx44dLq4UuDYWi0VxcXF66623lJqaqrFjx0oStwuVQARvAABuEFlZWZJkX+m5wKRJk2S1WhUeHu6KsgCns1qtOnbsmLy9vZWZmamqVavq7Nmzks4FlalTp2rRokUaOnSoiysFrt73338vSRo6dKiioqK0ZMkSLV26VC1atJCvr68yMzP17bffKj09XStXrnRxteBxYgAA3CBOnDihLl26aNOmTQoKCnLoW7RokdauXasFCxbI3Z3fy6N0e+KJJ5SYmKjVq1dry5YtCgkJka+vr9577z098sgjql+/vqtLBK7J2bNnVblyZWVlZen06dMKDAyUJK1evVpDhgzRzz//rMcee0xlypRRXl6ezp49q19//dW1Rd/gCN4AAECGYSg3N1dlypRxdSnANVmxYoUGDRqknTt36uabb9att96qgQMHqlWrVoqMjNSmTZtUu3ZtPfjgg+rYsaPuv/9+V5cMXJWTJ0/q2Wef1Y4dO7RixQr7egWdO3dW8+bNNWXKFBdXiPMRvAEAAHDdyM3NVVRUlJo0aaLff/9dDz30kI4cOSIPDw9JUmJioubMmaNp06apf//+evnll11cMXBtPvroI3322Wf6+eefJZ17rvcTTzyhkydP2uc9XI/gDQAAgOvW4cOHVbdu3ULtNptNHh4e3FqB60JSUpLKly9v/3z37t264447XFgR/o3gDQAAgOtCXl6e3nvvvcu6ZcLd3V1NmzZVu3btiqEywPnS09O1ceNGlS1b9qK/QLLZbLLZbOrSpUsxVod/I3gDAADguuHp6amWLVvK29v7ouPi4uJ04sQJJScnczkuSqW4uDhVrVq10GKZ/5aUlKT69evrzz//LKbKUBSCNwAAAK4bPj4+Onz4sKpWrXrRcQcPHlTDhg0VFRXFKucolVJSUlSuXDmlp6fLx8enyDFZWVny8fFRfn5+MVeHf/N0dQEAAACAs5x/9jo7O1sfffSR3Nzc5ObmpoLzTRERESpfvry2b99O6Eap5enpKTc3N0nnLjv/4osv7Fd6ZGVl6YknnrDPfbgeZ7wBAABw3fD19dWhQ4dUtWpVZWdny2q1qm/fvvLw8JBhGPrss8+UnZ0tT0/OP6F0KzibnZ6erry8PAUGBmrw4MEyDENz5sxRSkqK3Nzc5OPjo7y8PFeXe8MjeAMAAOC64eXlpf379yskJESGYcjDw8N+KW5ubq68vLy47BbXhYJfLKWnp8tiscjb21s2m02SVLZsWaWlpSk7O5vgXULw/AQAAABcF3Jzc1W5cmVlZmZKkv0y24JLbbnsFtcrd3d3h7l9/q0VKBm4xgYAAADXBU9PT8XGxtrPaOfk5MgwDI0ZM0ZlypSxt+fm5nKpOUq984N1VlaW8vLy9Pjjj8swDGVnZyszM5MV+0sQ/sUBAADAdSE9PV3/93//p/Xr12vXrl3Ky8vThAkT5O3tLXd3d+Xn52v8+PFcao7rQl5env0st2EYmjZtmn1183vvvfeiz/ZG8eMebwAAAFwXBg8erJ9++knPP/+8+vTpI4vF4uqSANOkpKSofPnyOnDggKxWa5FjsrOz1aBBAx09elTBwcHFXCHOR/AGAADAdSE5OVlly5aVp6enfvnlFz3wwAPy9fW96D4xMTHFVB3gXP/884+qV69+Wfdzu7m5scCai3GpOQAAAK4L5cqVs39cq1YtLViw4IL3cmdnZys5Obm4SgOcrlKlSkpISJCfn99F7+XOyclRUlJSMVaGonDGGwAAAAAAE3HHPQAAAAAAJiJ4AwAAAABgIoI3AAAAAAAmIngDAAAAAGAigjcAXIPdu3erYsWK+ueffy5rfK1atZSQkGBqTa+88orefvttp7zWmjVrdM8990iSWrRooQ8//NAldVzI0aNH1aRJk2t6ja1bt6pVq1by9/fXnXfeqR07dlz2vj/88IPc3d3l6elp3+Lj44scW7C68vmbu7u7unXrJsncr5czX7t9+/b69ddfLzomISFBFStWlJub2yXHXqnz5+S8efP09NNPX/Vr1apVS56envLy8pKfn5/atm17we+/zWbTY489dlXvk5iYqMGDB1/RPs6Y2xeyadMmPfjgg6a89qVe32azacKECQ5ts2bNUo0aNeTr66uwsLAL/h36Nz8/P/vH27dvV8WKFdWgQYOrLxwATETwBoBrULZsWdWvX19Wq9XVpZhiyZIleuSRRyRJ9erVU6VKlVxckXMdOnRIvXv31muvvab4+HiNGTNG3bt31/Hjxy9r/z/++EMvv/yycnNz7VvlypWLHPvEE084jMvJyVHDhg01fvx4Zx5SiVChQgWdPn3aHpCd6fw56QxxcXHKycnRyZMnNWjQIIWFhSkxMbHQuKVLl2rx4sX6/fffr/g9Zs2apfnz5+v06dPOKLlUi4yM1N69e+2fr1u3TpMnT9aqVauUkJCgJk2aKCws7Ipf94svvtD48eO1detWZ5YLAE5D8AaAa1C/fn1t27bN4dmx1wubzaaVK1eqZ8+ekqTPP/9cjz76qIurcq5p06Zp9OjR6tSpk6xWq3r06KHw8HB99dVXl7X/H3/8cdVn2JYtW6YaNWqoRYsWV7X/jejfc9KZypYtqyeeeELNmjXTpk2bCvV/8MEHeuqppzRt2rQret3c3FzNnj1bjz/+uGbPnu2kakunbdu26d1333Vomzp1qt555x01bdpUVqtVkyZNUn5+vjZs2HBFr52amqpq1aqpQoUKziwZAJyG4A0A1yAhIUG1atWyXxZ64MABtW/fXj4+PmrevLn27Nkj6VxA8/T01LFjx1SlShWNGDHC/hoLFy5Uo0aN5O3trTp16uidd96RYRiSzl2yGRoaqr59+6pKlSrKyMhQ+/bttW3bNo0aNUpBQUGqXLlyoR9mCzz55JNauHChhg4dKn9/f9WuXVurV69WTk6OnnnmGZUrV0516tTR2rVrC+37448/qlGjRrrpppskSQ8++KA9kFyqhjvvvFMTJ07UCy+8oMDAQHv7oUOH9NBDD8nPz0/lypVTnz59dPLkSXt/rVq19MknnyggIEBfffWV/VLi5cuXq1GjRvLz81P37t2LPCNZcHnrkiVLVKdOHfn7+2v48OHKz8/XN998owYNGigwMFAjRoxQXl6eJOnmm2+2X+pdIDg4+LIvdT1w4IBCQkIua+z5DMPQa6+9VuiSW0maM2eOGjRoIIvFoltvvVXffPPNZb3md999p9atW8vHx0cVKlTQ448/rqNHjzqMmTVrlmrXri1/f3/1799fWVlZDv0ffvih6tatK6vVqhYtWmj9+vXq1auXNm3apIyMDHl6euqnn37SnXfeWejrdrmcOScvJj8/X6+99ppq1qwpi8WiZs2aafXq1ZfczzAMlS1b1qHt119/VV5ent577z2tW7dOZ86cuezj/eabb9S8eXNNmjRJn376qX3une/o0aPq0aOHypYtq6CgIA0ZMkSpqamFxl3s+yP9/1sKZs2apXr16slisej222/XqlWr7K/xwgsvqGPHjlqzZo08PT21e/duSVJaWpqGDRumihUrysfHR/fee6927txp3+/JJ5/U66+/rtq1aysiIuKyj79Aenq6wsPD9dxzz9nbDMPQzp07FRoa6jC2V69eWr9+/WW/9ogRI7RgwQI9+uijqlu37hXXBgDFgeANAE6SmJio8PBwvfHGG0pMTNSQIUPUrVs32Ww2NW7cWLm5uapZs6bi4uL0/vvvSzoXhGbOnKnFixcrPT1dK1as0A8//KAxY8bYX3fjxo1q2LChjh07Jl9fX0nS008/rerVq+v48eP68ccfNX369CKDinTu0s5GjRrp1KlTmj17tp544gkNHjxYISEhOnnypObOnavw8HBlZGQ47LdkyRL16tXrgsd7sRp27NihyMhIvfHGG/aQcvz4cd1///3q27evTp06pcOHD6tp06Zq3769Q8iYP3++jhw5Yn/vTZs2acaMGfr+++8VGxurSpUqadiwYUXW9Ntvv2nBggXavHmzDh06pN27d2vYsGGaM2eONmzYoEOHDmnfvn1auHChJGnkyJGqV6+ew2usWrVKzZs3v+Bxn++PP/5Qjx49FBQUpF69eunUqVOXtd/KlSsVFBSku+++26H9k08+0XfffaeVK1cqKSlJU6ZM0TPPPKPFixdf9PW+/PJLDR48WGPGjNGpU6d06NAhtW7dWu3atVNycrKkc/eYb9q0STt37tShQ4eUmJiol19+2f4aEyZM0Jw5c7Ro0SIlJSXpgw8+0Isvvqh9+/ZJknx9fZWbm6t77rlHO3bs0IoVKy7rWIti1pw831NPPaUffvhBq1atUmJioiZOnKghQ4bo66+/LnJ8Wlqa5s2bp4MHDxb6vrz//vsaPny4rFarHn30Uc2ZM+eyj/WDDz7Q8OHDVa1aNTVr1qzQ1+3kyZNq166dmjdvrr///lsHDx5UvXr19N///tdh3KW+PwXmzJmjdevWafXq1UpKStKrr76qYcOGacmSJZKkN954Q+vXr1fXrl2Vm5urO+64Q3l5eQoNDVXFihX1559/KiEhQcOHD1evXr3swVyS3nvvPa1atUrvvffeZR9/gREjRig0NFSdO3e2tyUmJiowMFAWi8VhbEhIiI4cOXLZr/3+++/riSee0JdffqnDhw9fcW0AUCwMAMBVO336tFGzZk0jOjrakGTs2LHDob9FixbGL7/8Yv+8Zs2axunTpw3DMIysrCyjevXq9s8LZGdnG9WrVzdOnTplbNy40QgMDDRycnLs/ffcc48xZMgQh32mT59uDBs2zDAMw3j55ZeNt956yzAMwwgPDzceffRRh7H33Xef8Z///MehrWvXrsbmzZvtn9tsNqNChQrG8ePH7W2hoaHGxo0bL6uGf9dhGIYxbNgwY8aMGca/jRo1ynj33XftX5+vvvrK3jd37lwjKCjISE9Pt7elpKQYgYGBRn5+vhEdHW00btzYMAzD2Lhxo2GxWIzk5GT72M8//9ywWq1GUlKSve2rr74y+vfvX6iOgve79dZbDZvNVmT/+TIzM42vv/7aSE5ONs6cOWNMmDDBaN269SX3M4xz86Lga1ng5ZdfNpo3b27k5eU5tO/cudOoVq1aofYCOTk5RrVq1Yz9+/cX6jt58qT9tRs1amTk5+fb+6KiooxGjRoZhmEYJ06cMCpWrGjExcU57B8bG2uULVvWodZ77rnH2LVr12UdZ1FjnTkn586da0RERBR63927dxu1atVymDeGYRjbt283goOD7V/LmjVrGl5eXoanp6dRpUoVIywszDh48KDDPnFxcUZwcLCRnZ1tGIZhHDlyxKhfv77D1/JC9u7da9x22232zzdt2mTce++9DmMiIiKMF198sdC+r7zyin1uX+735+WXXzZuv/12Izc312HcL7/8YlSvXt1+3Bs3bjRCQ0Pt/V999ZXRu3fvQjWsWLHCePjhhw3DOPd9O//v98X8+/WXL19uNGrUyMjMzHToi4mJMRo2bFho/x9++MHo1q3bJd/H19fX/nF4eLixZMmSy6oPAFyBM94A4CRVq1ZVq1atHNrq1q2ruLi4Isfv379fJ06cUPXq1WWxWOybv7+/4uPj9dtvv0mSGjVqpDJlyjjs26NHj8t+n/bt2zt8XrFiRbVt29ahLSgoyOHy7fXr1yskJETVqlW74PFeSQ2S9NNPP2nkyJEOx2qxWDR9+nSHxZZuu+02h/3uv/9++5l+SfL395fValV6enqh97j11lsdLm2vWLGimjRp4nAP/r+PtcCuXbv0wgsv6IsvvpCnp+cFj6OAxWJRWFiYAgMDFRAQoIkTJ+rs2bPav3//Rff77rvv5O3tXej7IkndunWTu7vjf80tW7aUn5+fDh06VOTr7d+/X1WrVi1yBewqVarYP+7evbvc3Nzsn9euXdv+/fr55591zz33FFoYrnr16mrduvVFj+dqmDUnC2zcuFE9evRwmDfSuVsgrFarw1nRgq/fvHnz9PXXX6t+/foO+3z88cf6559/VL58efn5+emWW27RoUOHLniFyfk++OAD/e9//5Ofn5/8/PwUGhqqjRs36sCBA/YxP/30k/r27Vto3//85z/2j6/k+9OrVy95eHg4tLVo0UK+vr4XnEM//fSTvv7660J/N3v37u1wRv3ffzcvx6lTpxQREaGFCxcWOrNttVoL3e4gnTsT7uPjc8XvBQAlGcEbAJwkICCgUJuXl5eys7MvuE/Lli2VlZVVaMvJyVGnTp0knQual3qvi73Pvxd+8/T0VPny5R3a3N3dlZuba//8claOvpIaCvz222+FjjU7O1sLFiywj/n38V7J1/VqjlWSYmJiFBYWpk8//VQNGza86DFcTO3atXX8+HG98MILDo8N++OPP+xjLnRvt6RCdf3bo48+6vC6GRkZysvLu+R+UuGvY5kyZexfQzc3N/u6AldixowZDvWsWbPmsvYza04WyM/Pv+AvTzw8PJSfn2//vHz58vrss8/Uv3//QrcK2Gw2zZ49W9u2bdO+ffvs27x58+yLrBXc+16wFSxAmJCQoLVr1+r333932Hfy5MkOC7QZhlHk1/78tiv5/lzN91E6d/94Uf8WHTt2zD6mqH+LLmXo0KGKj4/XXXfdJYvFovvuu09r165VlSpVFBQUpDNnzshmsznsEx0drdq1a1/VcQBASUXwBgAn+feZyktp0qSJjh07ppiYGIf29PR0DR061B4O/n326krfq6j9L3ZGNzc3VytWrLjkytFXerxt2rTRypUrC7W/+eab9rP7UuF6zTxW6dy9vQ8++KCef/75y362cU5Ojjp37qzMzEx7W3Z2tnbt2qX69evrjTfecHh0WOPGjSWdO7OYnZ2t++67r8jXXbp0aaEQsmPHDmVkZKhevXr68ssvHV7X19dXt9xyi2JjYx3uxS1w/sJ1F/s6tm7dWps3by50xcKJEye0bdu2C+43bNgwh3q6du16wbHnM2tOFrjnnnv07bffKicnx6F97969SktLK3RWu127dho4cKD69evn0L5kyRLdeuutatWqlerWrWvf+vbtqz///FN///23/d73gu3LL7+UdG79hp49e6phw4YO+0ZEROjrr7+2r2vQvn17h188FTj/vv4r+f4sW7as0C9idu3aZZ9DRbnQ3801a9bY10OQiv6+XcqyZctks9nsQf7777/XAw88oLi4OLm5ual58+aFVjBfunSp/RePAHC9IHgDQDFyd3e3ByuLxaLIyEh1795du3btUk5Ojn777Td17dpVFSpUuOJg6ywbNmxQvXr1VL169Wt6nfOPVZLGjRunadOm6ZNPPlFqaqoSEhL08ssva+7cuS5biTgvL0+9e/dWu3btHFaavxQvLy8FBgYqIiJCycnJ+ueffxQeHq4WLVqoTp06F9xv0qRJF31ut5eXl3r06KGDBw/q7NmzWrVqlXr16qV33333gvPBYrFoypQp6tatm7755hulpaUpOTlZ77//vu6+++7LWoG7SpUqGjZsmB544AHt3LlTWVlZ2r59u3r06OFwubpU+PtaHK50TrZs2VJ33HGHevXqZf9arlu3Tj169NBbb71V5NcyMjJSqamp9oUPpXOXig8ePLjQWHd3dw0YMEDTp08v8v1zc3P10UcfFbmvv7+/HnzwQc2bN0+S9NJLL2nRokWaNGmSTp8+rdOnT+v11193WIn8Sr4/ubm56t27t/766y/7HOrRo4fefvtt+3H/+3vYq1cvnTlzRqNGjdLJkyd19uxZffHFFxo4cKCaNm16ka/0tRs9erRGjhypqKgoZWVladKkSbJarUXeigEApRnBGwCK0b333qu6detq+/btks5dhjlixAiFh4erbNmy6tmzp3r27KlJkya5rMalS5de9iW9F3PXXXdp8uTJ9kAbHBys7777TsuXL1fVqlVVv359/f3339q0aVOhe3GLy/Dhw7Vu3TrNnDnT4XLhjh07XnLf2bNnKy8vT3Xq1FHjxo3l4+Nz0dWu09LSFBQUpIceeuiCYx5//HH17t1bDz/8sMqVK6cJEyboo48+uuT3Y+DAgXr//ff16quvqmLFigoJCdGePXu0ZcsWh3veL+aVV17RwIED1bdvXwUGBmrUqFF67733CgWv9u3bq2PHjpf9rHNnuNic/Pfl7jNmzJAkzZs3T3fccYc6deqkcuXK6cUXX9TUqVMd7p0+n4eHhxYtWqTXX39dv//+u3bt2qUTJ05c8Cz+gAEDtHDhQp09e7ZQ3zfffKPq1avrlltuKXLfIUOGaMaMGTIMQ1WrVtXmzZu1e/du3XzzzWrYsKHi4uIKnQW/3O/PE088oV69eql79+4qV66cxo0bpw8//NB+CbwkNWjQQH/88Yf9nm1PT0+tXbtWmZmZatq0qSpVqqTZs2drxYoVpgfvLl26aOTIkercubPKly+vPXv2aNmyZaa+JwC4gptxtTcDAQCuO3l5ebrpppu0e/duBQcHu7ocgDl5BV555RX5+fk5PCsbAFAycMYbAGCXkJCg8ePHE3AkdezY0eFM6vnb+fekw1zMyZLn2LFjF/y70bx5c6e9T926dS/4PikpKU57HwAoDpzxBgAAuA5wxhsASi6CNwAAAAAAJuJScwAAAAAATETwBgAAAADARARvAAAAAABMRPAGAAAAAMBEBG8AAAAAAExE8AYAAAAAwEQEbwAAAAAATETwBgAAAADARP8PK1esSE7SizcAAAAASUVORK5CYII=","text/plain":["<Figure size 1200x600 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["for col in df.columns[5:]:\n","    print(\"*\" * 10, col, \"*\" * 10)\n","    print(df[col].value_counts())\n","    plot_value_counts(df, col)"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n","\n","\n","def calc_metrics_for_col(df, col):\n","    y_true = df[\"label\"]\n","    y_pred = df[col]\n","\n","    accuracy = accuracy_score(y_true, y_pred)\n","    precision = precision_score(y_true, y_pred, average=\"weighted\", labels=np.unique(y_pred))\n","    recall = recall_score(y_true, y_pred, average=\"weighted\", labels=np.unique(y_pred))\n","    f1 = f1_score(y_true, y_pred, average=\"weighted\", labels=np.unique(y_pred))\n","\n","    return accuracy, float(precision), float(recall), float(f1)"]},{"cell_type":"code","execution_count":10,"metadata":{},"outputs":[{"name":"stderr","output_type":"stream","text":["/var/folders/7x/56svhln929zdh2xhr3mwqg4r0000gn/T/ipykernel_3443/4138294296.py:9: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n","  perf_df = pd.concat([perf_df, pd.DataFrame([new_model_metrics])], ignore_index=True)\n"]},{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>run</th>\n","      <th>accuracy</th>\n","      <th>precision</th>\n","      <th>recall</th>\n","      <th>f1</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>checkpoint-88_m3</td>\n","      <td>0.783667</td>\n","      <td>0.809455</td>\n","      <td>0.783667</td>\n","      <td>0.794048</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>checkpoint-88_nv4080_lf</td>\n","      <td>0.775000</td>\n","      <td>0.814224</td>\n","      <td>0.775000</td>\n","      <td>0.790234</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>LoRA-Adapter_l40</td>\n","      <td>0.786667</td>\n","      <td>0.810298</td>\n","      <td>0.786667</td>\n","      <td>0.796053</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>LoRA-Adapter_l40_lf</td>\n","      <td>0.774667</td>\n","      <td>0.813416</td>\n","      <td>0.774667</td>\n","      <td>0.789748</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["                       run  accuracy  precision    recall        f1\n","0         checkpoint-88_m3  0.783667   0.809455  0.783667  0.794048\n","1  checkpoint-88_nv4080_lf  0.775000   0.814224  0.775000  0.790234\n","2         LoRA-Adapter_l40  0.786667   0.810298  0.786667  0.796053\n","3      LoRA-Adapter_l40_lf  0.774667   0.813416  0.774667  0.789748"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["import pandas as pd\n","\n","perf_df = pd.DataFrame(columns=[\"run\", \"accuracy\", \"precision\", \"recall\", \"f1\"])\n","for i, col in enumerate(df.columns[5:]):\n","    accuracy, precision, recall, f1 = calc_metrics_for_col(df, col)\n","    new_model_metrics = {\"run\": col.split(\"/\")[-1], \"accuracy\": accuracy, \"precision\": precision, \"recall\": recall, \"f1\": f1}\n","\n","    # Convert the dictionary to a DataFrame and concatenate it with the existing DataFrame\n","    perf_df = pd.concat([perf_df, pd.DataFrame([new_model_metrics])], ignore_index=True)\n","\n","perf_df"]},{"cell_type":"code","execution_count":11,"metadata":{},"outputs":[{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAABE0AAAHACAYAAABXiZaAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABf4UlEQVR4nO3deVwV9eL/8fdh3wQzFFBR3HIpBZMwtNKK0vJalvdmtkhk2iKV0aLmgpWJ5YaVaZmk95Zpllrd/FpeykrFLJTSRMy9DFArRVFB4fP7wx8nTwzKQRbR1/PxOI8HZ+YzM5/PgQ9z5j0zn7EZY4wAAAAAAADgwKWmKwAAAAAAAHAuIjQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALLjVdAXKo7i4WL/99pvq1Kkjm81W09UBAAAAAJznjDE6dOiQGjZsKBcXrje4UNWK0OS3335TaGhoTVcDAAAAAHCB+eWXX9S4ceOargZqSK0ITerUqSPp5B+rv79/DdcGAAAAAHC+y8vLU2hoqP14FBemWhGalNyS4+/vT2gCAAAAAKg2DBFxYePGLAAAAAAAAAuEJgAAAAAAABYITQDgHDR9+nSFhYXJy8tLnTt31tq1a09bPjk5Wa1bt5a3t7dCQ0P1xBNP6NixY/b5X3/9tXr37q2GDRvKZrNpyZIlp13fQw89JJvNpuTk5EpoDQAAAFA7EZoAwDlmwYIFSkhIUGJiotatW6fw8HD16NFDe/futSw/b948DR8+XImJicrMzNTs2bO1YMECPfvss/Yy+fn5Cg8P1/Tp08+4/cWLF2vNmjVq2LBhpbUJAIDqUhMnHsaOHas2bdrI19dXF110kWJiYvTtt99WdtMA1ABCkwtYZe9QyrPObdu26bbbblP9+vXl7++vO+64Q7m5uZXeNqA2mzJligYNGqS4uDi1a9dOM2fOlI+Pj1JSUizLr169Wl27dtVdd92lsLAw3Xjjjerfv79D/7vppps0btw43Xbbbafd9p49e/Too4/q3Xfflbu7e6W2Czif1MRBmTFGY8aMUUhIiLy9vRUTE6Off/65spsG1Go1deLhkksu0WuvvaYNGzZo5cqV9v3xvn37Kr2NAKqZqQUOHjxoJJmDBw/WdFXOG/PnzzceHh4mJSXF/PTTT2bQoEGmbt26Jjc317L8u+++azw9Pc27775rduzYYT777DMTEhJinnjiiXKv8/Dhw6Z58+bmtttuMz/++KP58ccfza233mquuOIKU1RUVC3tBs51BQUFxtXV1SxevNhh+oABA8wtt9xiucy7775rAgICzLfffmuMMWbbtm2mTZs25sUXX7QsL6nU+o0xpqioyFx77bUmOTnZGGNM06ZNzdSpUyvcFuB8VRX70KVLl5qRI0eaRYsWldlHJ0yYYAICAsySJUvMDz/8YG655RbTrFkzc/To0apqKlDrREVFmSFDhtjfFxUVmYYNG5qkpCTL8kOGDDHXXXedw7SEhATTtWtXy/Jl9c+/Kzl++d///lf+yuOcw3EojDGG0OQCVRU7lDOt87PPPjMuLi4Ov8cDBw4Ym81mli9fXintAmq7PXv2GElm9erVDtOffvppExUVVeZy06ZNM+7u7sbNzc1IMg899FCZZcv6wjd+/Hhzww03mOLiYmMMoQlQlpo4KCsuLjbBwcFm4sSJ9mkHDhwwnp6e5r333qtgS4DzS02eePh7PSZOnGgCAgLMvn37nG4Hzh0ch8IYY7g95wJUWFio9PR0xcTE2Ke5uLgoJiZGaWlplst06dJF6enp9suPt2/frqVLl+rmm28u9zoLCgpks9nk6elpL+Pl5SUXFxetXLmy0tsJXChWrFih8ePH6/XXX9e6deu0aNEiffrpp3rhhRfKvY709HRNmzZNc+bMkc1mq8LaArVbVexDy2PHjh3Kyclx2G5AQIA6d+5c5naBC83+/ftVVFSkoKAgh+lBQUHKycmxXOauu+7S888/r6uuukru7u5q0aKFunfv7nB7Tnn997//lZ+fn7y8vDR16lQtX75cgYGBFWoLgHMHockFqCp2KOVZ55VXXilfX18NGzZMR44cUX5+vp566ikVFRUpOzu7CloK1D6BgYFydXUtNdZPbm6ugoODLZcZPXq07r33Xj3wwANq3769brvtNo0fP15JSUkqLi4u13a/+eYb7d27V02aNJGbm5vc3Ny0a9cuPfnkkwoLCzvbZgHnjZo6KCtZtzPbBXBmlXHiocS1116rjIwMrV69Wj179tQdd9xR5lgqAGoPQhOUS2XsUOrXr6+FCxfqk08+kZ+fnwICAnTgwAFdfvnlcnHhTxGQJA8PD3Xq1Empqan2acXFxUpNTVV0dLTlMkeOHCnVh1xdXSWdHDiyPO699179+OOPysjIsL8aNmyop59+Wp999lkFWwNAqtyDMgBlq6kTDyV8fX3VsmVLXXnllZo9e7bc3Nw0e/bsCrcHwLnBraYrgOp3tjsUSWrfvr3y8/M1ePBgjRw5stzrvPHGG7Vt2zbt379fbm5uqlu3roKDg9W8efNKbiVQeyUkJCg2NlaRkZGKiopScnKy8vPzFRcXJ0kaMGCAGjVqpKSkJElS7969NWXKFHXs2FGdO3fW1q1bNXr0aPXu3dsenhw+fFhbt261b2PHjh3KyMhQvXr11KRJE1188cW6+OKLHerh7u6u4OBgtW7duppaDpz7qmIfWp4TByXrzs3NVUhIiMN2IyIiKtga4Pxy6omHPn36SPrrxEN8fLzlMpVx4qEsxcXFKigoOKt1AKh5nN6/AFXFmWxn1xkYGKi6devqiy++0N69e3XLLbdURtMsOfNYyO7du8tms5V69erVy14mNzdX9913nxo2bCgfHx/17NmzzEc+GmN00003lfn4SMBKv379NGnSJI0ZM0YRERHKyMjQsmXL7Jfl79692+GWtlGjRunJJ5/UqFGj1K5dOw0cOFA9evTQG2+8YS/z/fffq2PHjurYsaOkk8FMx44dNWbMmOptHFDL1dTVYM2aNVNwcLDDdvPy8vTtt9+Wud3KUFP70LS0NF133XXy9fWVv7+/rrnmGh09erRK2ojzS0JCgmbNmqW5c+cqMzNTDz/8cKkTDyNGjLCX7927t2bMmKH58+drx44dWr58ueWJh5KrMKW/Tjzs3r1b0slHEj/77LNas2aNdu3apfT0dN1///3as2eP/vWvf1XvBwCg8tXoMLTlxKjFlW/+/PnG09PTzJkzx2zatMkMHjzY1K1b1+Tk5BhjjLn33nvN8OHD7eUTExNNnTp1zHvvvWe2b99uPv/8c9OiRQtzxx13lHudxhiTkpJi0tLSzNatW81//vMfU69ePZOQkFCl7XTmsZC///67yc7Otr82btxoXF1dzdtvv22MOfn0giuvvNJcffXVZu3atWbz5s1m8ODBpkmTJubw4cOl1jdlyhRz0003lfvxdACAc19V7EMPHTpk1q9fb9avX28kmSlTppj169ebXbt22ctMmDDB1K1b13z00Ufmxx9/NLfeemuVPnK4pvahq1evNv7+/iYpKcls3LjRbN682SxYsMAcO3asStqJ88+rr75qmjRpYjw8PExUVJRZs2aNfV63bt1MbGys/f3x48fN2LFjTYsWLYyXl5cJDQ01jzzyiPnzzz/tZb788ksjqdSrZD1Hjx41t912m2nYsKHx8PAwISEh5pZbbjFr166tphajqnAcCmN45PAFrbJ3KGdapzHGDBs2zAQFBRl3d3fTqlUrM3nyZPvjTauCs4+F/LupU6eaOnXq2L/MZWVlGUlm48aNDuusX7++mTVrlsOy69evN40aNTLZ2dmEJkAZXnvtNdO0aVPj6elpoqKi7I98tNKtWzfLL60333yzvUxOTo6JjY01ISEhxtvb2/To0cNs2bLFYT1Hjx41jzzyiKlXr57x9fU1t99+u0O4C5RHdR+UGXMydBg9erQJCgoynp6e5vrrrzdZWVlV1saa2od27tzZjBo1qpJaAZy/2IdWPY5DYQyhCc5jBQUFxtXVtVRYMWDAAHPLLbeUax2XXXaZGTRokP39jz/+aCSZrVu3OpRr3Lixwxfb/Px807ZtW7NkyRJjjCE0ASzU1Fnshx56yISGhprU1FTz/fffmyuvvNJ06dKlOpoM1Bo1tQ/Nzc01kswrr7xioqOjTYMGDcw111xjvvnmm7NqD3C+YR9aPTgOhTGEJjiP7dmzx0gyq1evdpj+9NNPm6ioqDMu/+233xpJDql9YWGhadKkifnXv/5l/vjjD1NQUGAmTJhgJJkbb7zRXm7w4MFm4MCB9veEJqiwRP/qf1WTmjiLfeDAAePu7m4WLlxoL5OZmWkkmbS0tMpoFmpAZZ9tPXTokBkyZIhp1KiR8fLyMm3btjUzZsywz9+xY4flOiSZ999//7xoZ8k+tKLtrOg+NC0tzUgy9erVMykpKWbdunVm6NChxsPDo9QZb+CM2IeWiX1o+XAcCmOMYSDYc0RlD7R2+PBhxcfHq3HjxvL29la7du00c+ZMy/WZahys9Fxo58SJE/Xnn3+esa6zZ89W+/btFRUVZZ/m7u6uRYsWacuWLapXr558fHz05Zdf6qabbrIP8vfxxx/riy++UHJycjk/FeDCU1hYqPT0dMXExNinubi4KCYmRmlpaeVax+zZs3XnnXfK19dXkuxPKPDy8nJYp6enp1auXClJSk9P1/Hjxx2226ZNGzVp0qTc28W5ZcGCBUpISFBiYqLWrVun8PBw9ejRQ3v37rUsv2jRImVnZ9tfGzdulKurq8NgjQkJCVq2bJneeecdZWZmaujQoYqPj9fHH38sSQoNDXVYR3Z2tp577jn5+fnppptuOm/aKUmffPKJw3q6du0qFxeXM7azovvQkke8Pvjgg4qLi1PHjh01depUtW7dWikpKRX+/IDzCftQoHpV6JHD06dP18SJE5WTk6Pw8HC9+uqrDjvFv0tOTtaMGTO0e/duBQYG6p///KeSkpIcOuWFrOSL0MyZM9W5c2clJyerR48eysrKUoMGDUqVX7RokQoLC+3vf//9d4WHh5f6IvTFF1/onXfeUVhYmD7//HM98sgjatiwYakn1ST39JZte9HJN/PvkjLcq6adG48rYclRzezlpc5L11V5O3v27OnwWMjk5GTZbDZJUt26dU9b1/z8fM2fP1/PP/98qXmdOnVSRkaGDh48qMLCQtWvX1+dO3dWZGSkJOmLL77Qtm3bSm2jb9++uvrqq7VixYryfFzAeW3//v0qKiqyPxGoRFBQkDZv3nzG5deuXauNGzdq9uzZ9mklX9xGjBihN954Q76+vpo6dap+/fVX+9OGcnJy5OHhUap/BgUFKScn5+wbhmo3ZcoUDRo0yP5kjJkzZ+rTTz9VSkqKhg8fXqp8vXr1HN7Pnz9fPj4+DvuW1atXKzY2Vt27d5ckDR48WG+88YbWrl2rW265Ra6urn89XnhsgCRp8RuHdUdLV/lNalQFrZSmvHVYg8JdFbdrqBR3sMrbWbIPPXHihMOjlDdt2qTGjRvLz8+vzLqezT605HHK7dq1c1iubdu29ieVABc69qFA9XL6ShNnz3TMmzdPw4cPV2JiojIzMzV79mwtWLBAzz777FlX/nxx6he+kislfHx8yjyjUq9ePQUHB9tfy5cvP+0XobCwMA0ePFjh4eGlruzIyMjQ5LRCpdxa9QHWlDUFGnS5u+I6elRLO099LGRGRoYmT56st956S5LUunXr09Z14cKFKigo0D333FNmmYCAANWvX18///yzvv/+e916662SpOHDh+vHH3+0P5qu5PF0U6dO1dtvv+3MRwagDBU9i43zS1WcbZWkLl266OOPP9aePXtkjNGXX36pLVu26MYbb7RcR/pvRcrIKdbAy6vmpENhkVH6b8WKaf7Xua6qbqfVo5W/++47/fnnn7r55ptPu62z2YeGhYWpYcOGysrKcii/ZcsWNW3atFxtBXB67EMB5zjdA5w9wF+9erW6du2qu+66S2FhYbrxxhvVv3//096WcSGpyS98R44c0V133aXpN3sp2K9q/xnWxBc+6eSVKLNmzdLNN9+s4cOH67nnnpMkXX/99ZKkAQMGaMSIEZbb6tOnjy6++OJS8xYuXKgVK1Zo+/bt+uijj3TDDTeoT58+9m0GBwfrsssuc3hJUpMmTdSsWbNytRU43wUGBjpcCVYiNzfX4ay2lZKz2AMHDiw1r+Qs9oEDB5Sdna1ly5bp999/V/PmzSWd7J+FhYU6cOCA09vFued0Z1vLc9az5GzrAw884DD91VdfVbt27dS4cWN5eHioZ8+emj59uq655hrL9cxeX6i2gS7qElqhC3jPaP8RoyIjBfnaHKZXdTtL9qFz585VZmam7rvvPrm4uGjs2LGSqmYfarPZ9PTTT+uVV17RBx98oK1bt2r06NHavHmzZZ8HLkTsQ4Hq5dSRckUO8Lt06aL09HR7SLJ9+3YtXbr0tGcpCgoKlJeX5/A6X9XkF74nnnhCXbp00a1tqubM2Klq6gtfv3791KlTJ+Xl5enJJ5+0X/VRclnh7t277ZcclsjKytLKlSvL/HKWnZ2te++9V23atNFjjz2me++9V++99155PgbUUpU9Fo/VfJvNpokTJ9rLhIWFnZz+XJ79NWFlQdW2c22hwpIPVUs7S85iDxgwwGHev//9b/t91WU5m7PYnTp1kru7u8PZ86ysLO3evVvR0dHl/ahwnrA62yqd3LesWbNGH3/8sdLT0zV58mQNGTJE//vf/0qt4+hxo3kbjmtgx6rfl1ZURdvZr18/TZo0SWPGjFFERISysrI0ZMgQ+3eWqtqHDh06VCNGjNATTzyh8PBwpaamavny5WrRokVlfSSoRuxDK7+d7EOB6uXUKZGK3D931113af/+/brqqqtkjNGJEyf00EMPnfb2nKSkJPsVATi98nwRatq0qb7++msNGTJEDRs2VExMjH2w0vXr10uTFtZQ7cvvbNq5d+9e5eTk2O+/LhnXRJLl+CKtW7eWMabMujz22GN67LHHnKr/6daHc1tVjDn094OM//u//9PAgQPVt29fh+nPP/+8Bh182f6+jodj6FiZFmw8roTPj50ccygpvVramZCQoDvvvFO33Xabhg4dqlmzZumTTz7R66+/LunkWexGjRopKSnJYT1nOotdv359NWnSRBs2bNDjjz/ucBY7ICBAAwcOVEJCgurVqyd/f389+uijio6O1pVXXlnBTw81pTLOtv593I2jR4/q2Wef1eLFi+0HMB06dFBGRoYmTZrkcOJIkj7YdFxHjksDwqsuNAn0scnVJuXmO+5LqqOd8fHxio+P13/+8x8NHDhQo0ePtq+jKvehw4cPtxyrBbUL+1D2ocD5oMpvUFuxYoXGjx+v119/XevWrdOiRYv06aef6oUXXihzmREjRujgwYP21y+//FLV1awxVXF5XckXoSlTpqh3797q0KGD4uPj7WeMJMfBSt2ez5Pb8yev5un7/lF1n5NfiS08qTK+8J11O93c5OZ2Mifs27evfeA74HSqYsyhU+cHBwfro48+0rXXXmu//LVEnTp1FOznYn/5VuEXvqoYc+hM7ezXr58uuugirVixQjfccIO2bNmizz77zD6/qs5iT506Vf/4xz/Ut29fXXPNNQoODtaiRYsq/Nmh5liNu1FcXKzU1NQznvUs62zr8ePHdfz48VL38Lu6utqf7HKq2euP65bWbqrvW3VfqTxcberU0EWp20/Yp1V7O2fP1i233KL69eufRUtwoWEfyj4UOB84daVJRQ7wR48erXvvvdd+W0X79u2Vn5+vwYMHa+TIkZYDC3l6esrT09OZqtVap37h69Onj6S/vgjFx8efdtmz+SI0fPjwv251ef1kMtx+Rr6m9vBU70sq/2zZqV/4+vz/24GqvZ3/X/v27TV16lT17t37bJuF81zJLYmn3rNfGWPxnCo3N1effvqp5s6dW2rehAkT9ELeITUJsOmuy9z1RLSH3Fwq/0tfyZhDI6766/9udbXT399fx44dk81mU2Fhob7++mt16tRJbm5uVXYW28vLS9OnT9f06dPP3DCc8xISEhQbG6vIyEhFRUUpOTlZ+fn59qfpOHu21d/fX926ddPTTz8tb29vNW3aVF999ZX+/e9/a8qUKQ5lt27dqq93FWnp3T5V20hJCVd6KnbJUUU2dFVUZmb1t/OrrzSzcWNltmlbtQ09RdvNmdW2LVQ+9qHsQ4HzhVOhSUUO8I8cOWJ5UCtxy0KJmvjCV5JaS5IauNqXbRLgomYXVc3Zspr4wndqO0/9omd76WUde32GqvrrGF/4areqeKTf382dO1d16tTR7bff7jD9scce0+WXX656C/6h1b8UaUTqMWUfNprSo/KfdHW6MYeqrZ316mn16tUaMWKEsrOzSx20AWXp16+f9u3bpzFjxignJ0cRERFatmyZw7gbf/8eUnK29fPPP7dc5/z58zVixAjdfffd+uOPP9S0aVO9+OKLeuihhxzKpaSkqLG/TTe2cLVcT2Xqd5m79h0xGrOiQDkREdXeziA3N3X1sT6gA6ywD2UfCpwvnB7m3dkD/N69e2vKlCnq2LGjOnfubB8FvXfv3vbw5EJXk1/4qlNNfuEDakJZY/GcKiUlRXfffbe8vBy/yCUkJJz8YYWrOgS5ysNVevC/x5R0vac83aruEuOKqJR26uR4Ch4eHnrwwQeVlJR0wVxxiLNXMu6GlYqcbQ0ODi7XI+LHjx+v8R7Vd7Y1PspD8VEe0tiDpeZVdTvvXbTYqboCZ4t96F/YhwI1y+nQxNkD/FGjRslms2nUqFHas2eP6tevr969e+vFF1+svFacB2rqC9+pTKK/U+Uroqa+8J1qU+s2TpXHhasqBpk81TfffKOsrCwtWLDgjHXp3MhVJ4qlnQeK1TqwcgPnqhhk8lTlbWdmm7YKLCjQiRMnlNq2rZp5VP0XPq4GA4CqwT6UfShwvnA6NJGcO8B3c3NTYmKiEhMTK7IpAKgxVTHm0Klmz56tTp06KTw8/Ix1ycgplotNalAFg01WxZhDp3KmnZsLjslFUj3XCu2ecIELG/5ptW9zZ+Vf7X9G7ee2r/Ztvl/tW0Rtxz6UfShwvqBHAcBpVPaYQyXy8vK0cOFCTZ48udS8tLQ0ffvtt7r22mtV589ipf1SpCc+O6Z7OrjrIu+quay4ssccKlHudtapo0/yDuqlvXvV299fAdy+CQC1HvtQ9qHA+YDQ5BzDWbKqw1kyVERVjDkknRyPxxij/v37l5rn6emp+fPna+zYsSrIP6xmdV30xJUeSoj2qNzGnaIqxhySnGhnQYEaFhdrwEX1dN9FF1Vu4wAANYJ9KPtQ4HxgM7XgETZ5eXkKCAjQwYMH5e9f9eNu1KSaCU3uqvZttm/WpNq3+X7SiWrfJvd64qyNDaiBbZYec6g6VOejTEvQR88v7EOrDvtQ1ErsQ6vUhdBHL6TjUJStap4tCwAAAAAAUMsRmgAAAAAAAFhgTBMAKCfGHKpajDsEAOcv9qFVi30oUHW40gQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWCA0AQAAAAAAsEBoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWKhSaTJ8+XWFhYfLy8lLnzp21du3aMst2795dNput1KtXr14VrjQAAAAAAEBVczo0WbBggRISEpSYmKh169YpPDxcPXr00N69ey3LL1q0SNnZ2fbXxo0b5erqqn/9619nXXkAAAAAAICq4nRoMmXKFA0aNEhxcXFq166dZs6cKR8fH6WkpFiWr1evnoKDg+2v5cuXy8fHh9AEAAAAAACc05wKTQoLC5Wenq6YmJi/VuDiopiYGKWlpZVrHbNnz9add94pX1/fMssUFBQoLy/P4QUAAAAAAFCdnApN9u/fr6KiIgUFBTlMDwoKUk5OzhmXX7t2rTZu3KgHHnjgtOWSkpIUEBBgf4WGhjpTTQAAAAAAgLNWrU/PmT17ttq3b6+oqKjTlhsxYoQOHjxof/3yyy/VVEMAAAAAAICT3JwpHBgYKFdXV+Xm5jpMz83NVXBw8GmXzc/P1/z58/X888+fcTuenp7y9PR0pmoAAAAAAACVyqkrTTw8PNSpUyelpqbapxUXFys1NVXR0dGnXXbhwoUqKCjQPffcU7GaAgAAAAAAVCOnrjSRpISEBMXGxioyMlJRUVFKTk5Wfn6+4uLiJEkDBgxQo0aNlJSU5LDc7Nmz1adPH1188cWVU3MAAAAAAIAq5HRo0q9fP+3bt09jxoxRTk6OIiIitGzZMvvgsLt375aLi+MFLFlZWVq5cqU+//zzyqk1AAAAAABAFXM6NJGk+Ph4xcfHW85bsWJFqWmtW7eWMaYimwIAAAAAAKgR1fr0HAAAAAAAgNqC0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWCA0AQAAAAAAsEBoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAQoVCk+nTpyssLExeXl7q3Lmz1q5de9ryBw4c0JAhQxQSEiJPT09dcsklWrp0aYUqDAAAAAAAUB3cnF1gwYIFSkhI0MyZM9W5c2clJyerR48eysrKUoMGDUqVLyws1A033KAGDRrogw8+UKNGjbRr1y7VrVu3MuoPAAAAAABQJZwOTaZMmaJBgwYpLi5OkjRz5kx9+umnSklJ0fDhw0uVT0lJ0R9//KHVq1fL3d1dkhQWFnZ2tQYAAAAAAKhiTt2eU1hYqPT0dMXExPy1AhcXxcTEKC0tzXKZjz/+WNHR0RoyZIiCgoJ02WWXafz48SoqKipzOwUFBcrLy3N4AQAAAAAAVCenQpP9+/erqKhIQUFBDtODgoKUk5Njucz27dv1wQcfqKioSEuXLtXo0aM1efJkjRs3rsztJCUlKSAgwP4KDQ11ppoAAAAAAABnrcqfnlNcXKwGDRrozTffVKdOndSvXz+NHDlSM2fOLHOZESNG6ODBg/bXL7/8UtXVBAAAAAAAcODUmCaBgYFydXVVbm6uw/Tc3FwFBwdbLhMSEiJ3d3e5urrap7Vt21Y5OTkqLCyUh4dHqWU8PT3l6enpTNUAAAAAAAAqlVNXmnh4eKhTp05KTU21TysuLlZqaqqio6Mtl+natau2bt2q4uJi+7QtW7YoJCTEMjABAAAAAAA4Fzh9e05CQoJmzZqluXPnKjMzUw8//LDy8/PtT9MZMGCARowYYS//8MMP648//tDjjz+uLVu26NNPP9X48eM1ZMiQymsFAAAAAABAJXP6kcP9+vXTvn37NGbMGOXk5CgiIkLLli2zDw67e/duubj8lcWEhobqs88+0xNPPKEOHTqoUaNGevzxxzVs2LDKawUAAAAAAEAlczo0kaT4+HjFx8dbzluxYkWpadHR0VqzZk1FNgUAAAAAAFAjqvzpOQAAAAAAALURoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWCA0AQAAAAAAsEBoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFt5quAAAAAAAAtVFxcbEKCwtruhpwkru7u1xdXctVltAEAAAAAAAnFRYWaseOHSouLq7pqqAC6tatq+DgYNlsttOWIzQBAAAAAMAJxhhlZ2fL1dVVoaGhcnFh5IvawhijI0eOaO/evZKkkJCQ05YnNAEAAAAAwAknTpzQkSNH1LBhQ/n4+NR0deAkb29vSdLevXvVoEGD096qQxwGAAAAAIATioqKJEkeHh41XBNUVEnYdfz48dOWIzQBAAAAAKACzjQeBs5d5f3dEZoAAAAAAABYIDQBAAAAAACwUKGBYKdPn66JEycqJydH4eHhevXVVxUVFWVZds6cOYqLi3OY5unpqWPHjlVk0wAAAAAAnJPChn9ardvbOaFXtW7vQuT0lSYLFixQQkKCEhMTtW7dOoWHh6tHjx72x/VY8ff3V3Z2tv21a9eus6o0AAAAAACo/c40EGtNczo0mTJligYNGqS4uDi1a9dOM2fOlI+Pj1JSUspcxmazKTg42P4KCgo6q0oDAAAAAADnLVu2TFdddZXq1q2riy++WP/4xz+0bds2+/xff/1V/fv3V7169eTr66vIyEh9++239vmffPKJrrjiCnl5eSkwMFC33XabfZ7NZtOSJUsctle3bl3NmTNHkrRz507ZbDYtWLBA3bp1k5eXl9599139/vvv6t+/vxo1aiQfHx+1b99e7733nsN6iouL9fLLL6tly5by9PRUkyZN9OKLL0qSrrvuOsXHxzuU37dvnzw8PJSamnpWn5dToUlhYaHS09MVExPz1wpcXBQTE6O0tLQylzt8+LCaNm2q0NBQ3Xrrrfrpp59Ou52CggLl5eU5vAAAAAAAwNnJz89XQkKCvv/+e6WmpsrFxUW33XabiouLdfjwYXXr1k179uzRxx9/rB9++EHPPPOMiouLJUmffvqpbrvtNt18881av369UlNTyxyq43SGDx+uxx9/XJmZmerRo4eOHTumTp066dNPP9XGjRs1ePBg3XvvvVq7dq19mREjRmjChAkaPXq0Nm3apHnz5tkvyHjggQc0b948FRQU2Mu/8847atSoka677rqz+rycGtNk//79KioqKnWlSFBQkDZv3my5TOvWrZWSkqIOHTro4MGDmjRpkrp06aKffvpJjRs3tlwmKSlJzz33nDNVAwAAAAAAZ9C3b1+H9ykpKapfv742bdqk1atXa9++ffruu+9Ur149SVLLli3tZV988UXdeeedDsfr4eHhTtdh6NChuv322x2mPfXUU/afH330UX322Wd6//33FRUVpUOHDmnatGl67bXXFBsbK0lq0aKFrrrqKknS7bffrvj4eH300Ue64447JJ0cX/W+++4768dCV/nTc6KjozVgwABFRESoW7duWrRokerXr6833nijzGVGjBihgwcP2l+//PJLVVcTAAAAAIDz3s8//6z+/furefPm8vf3V1hYmCRp9+7dysjIUMeOHe2Byd9lZGTo+uuvP+s6REZGOrwvKirSCy+8oPbt26tevXry8/PTZ599pt27d0uSMjMzVVBQUOa2vby8dO+999qHDVm3bp02btyo++6776zr6tSVJoGBgXJ1dVVubq7D9NzcXAUHB5drHe7u7urYsaO2bt1aZhlPT095eno6UzUAAAAAAHAGvXv3VtOmTTVr1iw1bNhQxcXFuuyyy1RYWChvb+/TLnum+TabTcYYh2lWA736+vo6vJ84caKmTZum5ORktW/fXr6+vho6dKgKCwvLtV3p5C06ERER+vXXX/X222/ruuuuU9OmTc+43Jk4daWJh4eHOnXq5DCQSnFxsVJTUxUdHV2udRQVFWnDhg0KCQlxrqYAAAAAAKDCfv/9d2VlZWnUqFG6/vrr1bZtW/3555/2+R06dFBGRob++OMPy+U7dOhw2oFV69evr+zsbPv7n3/+WUeOHDljvVatWqVbb71V99xzj8LDw9W8eXNt2bLFPr9Vq1by9vY+7bbbt2+vyMhIzZo1S/PmzdP9999/xu2Wh9O35yQkJGjWrFmaO3euMjMz9fDDDys/P19xcXGSpAEDBmjEiBH28s8//7w+//xzbd++XevWrdM999yjXbt26YEHHqiUBgAAAAAAgDO76KKLdPHFF+vNN9/U1q1b9cUXXyghIcE+v3///goODlafPn20atUqbd++XR9++KH9wS+JiYl67733lJiYqMzMTG3YsEEvvfSSffnrrrtOr732mtavX6/vv/9eDz30kNzd3c9Yr1atWmn58uVavXq1MjMz9eCDDzrc4eLl5aVhw4bpmWee0b///W9t27ZNa9as0ezZsx3W88ADD2jChAkyxjg81edsOB2a9OvXT5MmTdKYMWMUERGhjIwMLVu2zD447O7dux2SpT///FODBg1S27ZtdfPNNysvL0+rV69Wu3btKqUBAAAAAADgzFxcXDR//nylp6frsssu0xNPPKGJEyfa53t4eOjzzz9XgwYNdPPNN6t9+/aaMGGCXF1dJUndu3fXwoUL9fHHHysiIkLXXXedwxNuJk+erNDQUF199dW666679NRTT8nHx+eM9Ro1apQuv/xy9ejRQ927d7cHN6caPXq0nnzySY0ZM0Zt27ZVv379tHfvXocy/fv3l5ubm/r37y8vL6+z+KT+YjN/v+HoHJSXl6eAgAAdPHhQ/v7+NV2dKhU2/NNq3+ZOr7uqfZvtmzWp9m2+n3Si2rfZdnNmtW8TVYf+WbXoozhb9NGqQ//E2aJ/Vi36aNU43XHosWPHtGPHDjVr1qzSDs5x9nbu3KkWLVrou+++0+WXX37asuX9HTo1ECwAAAAAAMC55Pjx4/r99981atQoXXnllWcMTJxR5Y8cBgAAAAAAqCqrVq1SSEiIvvvuO82cObNS182VJgAAAAAAoNbq3r17qUcdVxauNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAECVWLFihWw2mw4cOFCpZauLW01XAAAAAACA88LYgGre3sHq3V4FdOnSRdnZ2QoIOPNn40zZ6sKVJgAAAAAAoJTCwsKzXoeHh4eCg4Nls9kqtWx1ITQBAAAAAOAC0L17d8XHxys+Pl4BAQEKDAzU6NGjZYyRJIWFhemFF17QgAED5O/vr8GDB0uSVq5cqauvvlre3t4KDQ3VY489pvz8fPt6CwoKNGzYMIWGhsrT01MtW7bU7NmzJZW+5WbXrl3q3bu3LrroIvn6+urSSy/V0qVLLctK0ocffqhLL71Unp6eCgsL0+TJkx3aFBYWpvHjx+v+++9XnTp11KRJE7355puV9pkRmgAAAAAAcIGYO3eu3NzctHbtWk2bNk1TpkzRW2+9ZZ8/adIkhYeHa/369Ro9erS2bdumnj17qm/fvvrxxx+1YMECrVy5UvHx8fZlBgwYoPfee0+vvPKKMjMz9cYbb8jPz89y+0OGDFFBQYG+/vprbdiwQS+99FKZZdPT03XHHXfozjvv1IYNGzR27FiNHj1ac+bMcSg3efJkRUZGav369XrkkUf08MMPKysr6+w/LDGmCQAAAAAAF4zQ0FBNnTpVNptNrVu31oYNGzR16lQNGjRIknTdddfpySeftJd/4IEHdPfdd2vo0KGSpFatWumVV15Rt27dNGPGDO3evVvvv/++li9frpiYGElS8+bNy9z+7t271bdvX7Vv3/6MZadMmaLrr79eo0ePliRdcskl2rRpkyZOnKj77rvPXu7mm2/WI488IkkaNmyYpk6dqi+//FKtW7d2/gP6G640AQAAAADgAnHllVc6jBkSHR2tn3/+WUVFRZKkyMhIh/I//PCD5syZIz8/P/urR48eKi4u1o4dO5SRkSFXV1d169atXNt/7LHHNG7cOHXt2lWJiYn68ccfyyybmZmprl27Okzr2rWrQ30lqUOHDvafbTabgoODtXfv3nLV50wITQAAAAAAgCTJ19fX4f3hw4f14IMPKiMjw/764Ycf9PPPP6tFixby9vZ2av0PPPCAtm/frnvvvVcbNmxQZGSkXn311bOqs7u7u8N7m82m4uLis1pnCUITAAAAAAAuEN9++63D+zVr1qhVq1ZydXW1LH/55Zdr06ZNatmyZamXh4eH2rdvr+LiYn311VflrkNoaKgeeughLVq0SE8++aRmzZplWa5t27ZatWqVw7RVq1bpkksuKbO+lY3QBAAAAACAC8Tu3buVkJCgrKwsvffee3r11Vf1+OOPl1l+2LBhWr16teLj45WRkaGff/5ZH330kX0g2LCwMMXGxur+++/XkiVLtGPHDq1YsULvv/++5fqGDh2qzz77TDt27NC6dev05Zdfqm3btpZln3zySaWmpuqFF17Qli1bNHfuXL322mt66qmnzv6DKCcGggUAAAAA4AIxYMAAHT16VFFRUXJ1ddXjjz9uf7SwlQ4dOuirr77SyJEjdfXVV8sYoxYtWqhfv372MjNmzNCzzz6rRx55RL///ruaNGmiZ5991nJ9RUVFGjJkiH799Vf5+/urZ8+emjp1qmXZyy+/XO+//77GjBmjF154QSEhIXr++ecdBoGtaoQmAAAAAABUhrEHa7oGZ+Tu7q7k5GTNmDGj1LydO3daLnPFFVfo888/L3OdXl5emjJliqZMmVJqXvfu3WWMsb8/3fglfy8rSX379lXfvn3LXMaqzhkZGWWWdxa35wAAAAAAAFggNAEAAAAAALDA7TkAAAAAAFwAVqxYUdNVqHW40gQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAABVYuzYsYqIiLC/v++++9SnT58aq4+z3Gq6AgAAAAAAnA/az21frdvbELuhWrd3IeJKEwAAAAAALkCFhYU1XYVzHqEJAAAAAAAXgO7duys+Pl5Dhw5VYGCgevTooY0bN+qmm26Sn5+fgoKCdO+992r//v32ZYqLi/Xyyy+rZcuW8vT0VJMmTfTiiy/a5w8bNkyXXHKJfHx81Lx5c40ePVrHjx+vieZViQqFJtOnT1dYWJi8vLzUuXNnrV27tlzLzZ8/XzabrVbdvwQAAAAAwPli7ty58vDw0KpVqzRhwgRdd9116tixo77//nstW7ZMubm5uuOOO+zlR4wYoQkTJmj06NHatGmT5s2bp6CgIPv8OnXqaM6cOdq0aZOmTZumWbNmaerUqTXRtCrh9JgmCxYsUEJCgmbOnKnOnTsrOTlZPXr0UFZWlho0aFDmcjt37tRTTz2lq6+++qwqDAAAAAAAKqZVq1Z6+eWXJUnjxo1Tx44dNX78ePv8lJQUhYaGasuWLQoJCdG0adP02muvKTY2VpLUokULXXXVVfbyo0aNsv8cFhamp556SvPnz9czzzxTTS2qWk5faTJlyhQNGjRIcXFxateunWbOnCkfHx+lpKSUuUxRUZHuvvtuPffcc2revPlZVRgAAAAAAFRMp06d7D//8MMP+vLLL+Xn52d/tWnTRpK0bds2ZWZmqqCgQNdff32Z61uwYIG6du2q4OBg+fn5adSoUdq9e3eVt6O6OBWaFBYWKj09XTExMX+twMVFMTExSktLK3O5559/Xg0aNNDAgQPLtZ2CggLl5eU5vAAAAAAAwNnx9fW1/3z48GH17t1bGRkZDq+ff/5Z11xzjby9vU+7rrS0NN199926+eab9d///lfr16/XyJEjz6sBZp26PWf//v0qKipyuH9JkoKCgrR582bLZVauXKnZs2crIyOj3NtJSkrSc88950zVAAAAAACAEy6//HJ9+OGHCgsLk5tb6XigVatW8vb2Vmpqqh544IFS81evXq2mTZtq5MiR9mm7du2q0jpXtyp9es6hQ4d07733atasWQoMDCz3ciNGjNDBgwftr19++aUKawkAAAAAwIVnyJAh+uOPP9S/f39999132rZtmz777DPFxcWpqKhIXl5eGjZsmJ555hn9+9//1rZt27RmzRrNnj1b0slQZffu3Zo/f762bdumV155RYsXL67hVlUup640CQwMlKurq3Jzcx2m5+bmKjg4uFT5bdu2aefOnerdu7d9WnFx8ckNu7kpKytLLVq0KLWcp6enPD09nakaAAAAAABwQsOGDbVq1SoNGzZMN954owoKCtS0aVP17NlTLi4nr7EYPXq03NzcNGbMGP32228KCQnRQw89JEm65ZZb9MQTTyg+Pl4FBQXq1auXRo8erbFjx9ZgqyqXU6GJh4eHOnXqpNTUVPtjg4uLi5Wamqr4+PhS5du0aaMNGzY4TBs1apQOHTqkadOmKTQ0tOI1BwAAAADgHLIhdsOZC9WgFStWlJrWqlUrLVq0qMxlXFxcNHLkSIdbcE718ssv25/GU2Lo0KH2n8eOHesQosyZM8eZKtc4px85nJCQoNjYWEVGRioqKkrJycnKz89XXFycJGnAgAFq1KiRkpKS5OXlpcsuu8xh+bp160pSqekAAAAAAADnEqdDk379+mnfvn0aM2aMcnJyFBERoWXLltkHh929e7f9Mh4AAAAAAIDayunQRJLi4+Mtb8eRrC/3OVVtuxQHAAAAAABcmLgkBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAA4AJgjNHgwYNVr1492Ww2ZWRk1HSVznluNV0BAAAAAADOB5lt2lbr9tpuznSq/LJlyzRnzhytWLFCzZs315YtW9S7d2+lp6crOztbixcvVp8+faqmsrUUV5oAAAAAAHAB2LZtm0JCQtSlSxcFBwcrPz9f4eHhmj59ek1X7ZzFlSYAAAAAAJzn7rvvPs2dO1eSZLPZ1LRpU+3cuVM33XRTDdfs3EZoAgAAAADAeW7atGlq0aKF3nzzTX333XdydXWt6SrVCoQmAAAAAACc5wICAlSnTh25uroqODi4pqtTazCmCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYY0wQAAAAAgAvQ4cOHtXXrVvv7HTt2KCMjQ/Xq1VOTJk1qsGbnDkITAAAAAAAqQdvNmTVdBad8//33uvbaa+3vExISJEmxsbGaM2dODdXq3EJoAgAAAADABWDo0KEaOnSo/X337t1ljKm5CtUCjGkCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAABUAIOo1l7l/d0RmgAAAAAA4ARXV1dJUmFhYQ3XBBV15MgRSZK7u/tpy/HIYQAAAAAAnODm5iYfHx/t27dP7u7ucnHheoTawhijI0eOaO/evapbt649ACsLoQkAAAAAAE6w2WwKCQnRjh07tGvXrpquDiqgbt26Cg4OPmM5QhMAAAAAAJzk4eGhVq1acYtOLeTu7n7GK0xKEJoAAAAAAFABLi4u8vLyqulqoApx4xUAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwUKHQZPr06QoLC5OXl5c6d+6stWvXlll20aJFioyMVN26deXr66uIiAj95z//qXCFAQAAAAAAqoPTocmCBQuUkJCgxMRErVu3TuHh4erRo4f27t1rWb5evXoaOXKk0tLS9OOPPyouLk5xcXH67LPPzrryAAAAAAAAVcXp0GTKlCkaNGiQ4uLi1K5dO82cOVM+Pj5KSUmxLN+9e3fddtttatu2rVq0aKHHH39cHTp00MqVK8+68gAAAAAAAFXFqdCksLBQ6enpiomJ+WsFLi6KiYlRWlraGZc3xig1NVVZWVm65ppryixXUFCgvLw8hxcAAAAAAEB1cio02b9/v4qKihQUFOQwPSgoSDk5OWUud/DgQfn5+cnDw0O9evXSq6++qhtuuKHM8klJSQoICLC/QkNDnakmAAAAAADAWauWp+fUqVNHGRkZ+u677/Tiiy8qISFBK1asKLP8iBEjdPDgQfvrl19+qY5qAgAAAAAA2Lk5UzgwMFCurq7Kzc11mJ6bm6vg4OAyl3NxcVHLli0lSREREcrMzFRSUpK6d+9uWd7T01Oenp7OVA0AAAAAAKBSOXWliYeHhzp16qTU1FT7tOLiYqWmpio6Orrc6ykuLlZBQYEzmwYAAAAAAKhWTl1pIkkJCQmKjY1VZGSkoqKilJycrPz8fMXFxUmSBgwYoEaNGikpKUnSyfFJIiMj1aJFCxUUFGjp0qX6z3/+oxkzZlRuSwAAAAAAACqR06FJv379tG/fPo0ZM0Y5OTmKiIjQsmXL7IPD7t69Wy4uf13Akp+fr0ceeUS//vqrvL291aZNG73zzjvq169f5bUCAAAAAACgkjkdmkhSfHy84uPjLef9fYDXcePGady4cRXZDAAAAAAAQI2plqfnAAAAAAAA1DaEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWCA0AQAAAAAAsEBoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWKhSaTJ8+XWFhYfLy8lLnzp21du3aMsvOmjVLV199tS666CJddNFFiomJOW15AAAAAACAc4HTocmCBQuUkJCgxMRErVu3TuHh4erRo4f27t1rWX7FihXq37+/vvzyS6WlpSk0NFQ33nij9uzZc9aVBwAAAAAAqCpOhyZTpkzRoEGDFBcXp3bt2mnmzJny8fFRSkqKZfl3331XjzzyiCIiItSmTRu99dZbKi4uVmpq6llXHgAAAAAAoKo4FZoUFhYqPT1dMTExf63AxUUxMTFKS0sr1zqOHDmi48ePq169es7VFAAAAAAAoBq5OVN4//79KioqUlBQkMP0oKAgbd68uVzrGDZsmBo2bOgQvPxdQUGBCgoK7O/z8vKcqSYAAAAAAMBZq9an50yYMEHz58/X4sWL5eXlVWa5pKQkBQQE2F+hoaHVWEsAAAAAAAAnQ5PAwEC5uroqNzfXYXpubq6Cg4NPu+ykSZM0YcIEff755+rQocNpy44YMUIHDx60v3755RdnqgkAAAAAAHDWnApNPDw81KlTJ4dBXEsGdY2Oji5zuZdfflkvvPCCli1bpsjIyDNux9PTU/7+/g4vAAAAAACA6uTUmCaSlJCQoNjYWEVGRioqKkrJycnKz89XXFycJGnAgAFq1KiRkpKSJEkvvfSSxowZo3nz5iksLEw5OTmSJD8/P/n5+VViUwAAAAAAACqP06FJv379tG/fPo0ZM0Y5OTmKiIjQsmXL7IPD7t69Wy4uf13AMmPGDBUWFuqf//ynw3oSExM1duzYs6s9AAAAAABAFXE6NJGk+Ph4xcfHW85bsWKFw/udO3dWZBMAAAAAAAA1qlqfngMAAAAAAFBbEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWCA0AQAAAAAAsEBoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWKhQaDJ9+nSFhYXJy8tLnTt31tq1a8ss+9NPP6lv374KCwuTzWZTcnJyResKAAAAAABQbZwOTRYsWKCEhAQlJiZq3bp1Cg8PV48ePbR3717L8keOHFHz5s01YcIEBQcHn3WFAQAAAAAAqoPTocmUKVM0aNAgxcXFqV27dpo5c6Z8fHyUkpJiWf6KK67QxIkTdeedd8rT0/OsKwwAAAAAAFAdnApNCgsLlZ6erpiYmL9W4OKimJgYpaWlVXrlAAAAAAAAaoqbM4X379+voqIiBQUFOUwPCgrS5s2bK61SBQUFKigosL/Py8urtHUDAAAAAACUxzn59JykpCQFBATYX6GhoTVdJQAAAAAAcIFxKjQJDAyUq6urcnNzHabn5uZW6iCvI0aM0MGDB+2vX375pdLWDQAAAAAAUB5OhSYeHh7q1KmTUlNT7dOKi4uVmpqq6OjoSquUp6en/P39HV4AAAAAAADVyakxTSQpISFBsbGxioyMVFRUlJKTk5Wfn6+4uDhJ0oABA9SoUSMlJSVJOjl47KZNm+w/79mzRxkZGfLz81PLli0rsSkAAAAAAACVx+nQpF+/ftq3b5/GjBmjnJwcRUREaNmyZfbBYXfv3i0Xl78uYPntt9/UsWNH+/tJkyZp0qRJ6tatm1asWHH2LQAAAAAAAKgCTocmkhQfH6/4+HjLeX8PQsLCwmSMqchmAAAAAAAAasw5+fQcAAAAAACAmkZoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAAAAAACABUITAAAAAAAAC4QmAAAAAAAAFghNAAAAAAAALBCaAAAAAAAAWCA0AQAAAAAAsEBoAgAAAAAAYIHQBAAAAAAAwAKhCQAAAAAAgAVCEwAAAAAAAAuEJgAAAAAAABYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMBChUKT6dOnKywsTF5eXurcubPWrl172vILFy5UmzZt5OXlpfbt22vp0qUVqiwAAAAAAEB1cTo0WbBggRISEpSYmKh169YpPDxcPXr00N69ey3Lr169Wv3799fAgQO1fv169enTR3369NHGjRvPuvIAAAAAAABVxenQZMqUKRo0aJDi4uLUrl07zZw5Uz4+PkpJSbEsP23aNPXs2VNPP/202rZtqxdeeEGXX365XnvttbOuPAAAAAAAQFVxc6ZwYWGh0tPTNWLECPs0FxcXxcTEKC0tzXKZtLQ0JSQkOEzr0aOHlixZUuZ2CgoKVFBQYH9/8OBBSVJeXp4z1a2ViguOVPs282ym2rdZdLSo2rd5uKj6t3kh/M1eSOifVYs+irNFH6069E+cLfpn1aKPVo2SNhpT/X9LOHc4FZrs379fRUVFCgoKcpgeFBSkzZs3Wy6Tk5NjWT4nJ6fM7SQlJem5554rNT00NNSZ6qKcAmpkq5nVvsWoat+ipICa+XRx/rhQ+qdEH0XtdKH0UfonaqMLpX9K9NGqdujQIQVcQO2FI6dCk+oyYsQIh6tTiouL9ccff+jiiy+WzWarwZqhMuTl5Sk0NFS//PKL/P39a7o6AE5B/wTObfRR4NxF/zz/GGN06NAhNWzYsKarghrkVGgSGBgoV1dX5ebmOkzPzc1VcHCw5TLBwcFOlZckT09PeXp6OkyrW7euM1VFLeDv788OBThH0T+Bcxt9FDh30T/PL1xhAqcGgvXw8FCnTp2Umppqn1ZcXKzU1FRFR0dbLhMdHe1QXpKWL19eZnkAAAAAAIBzgdO35yQkJCg2NlaRkZGKiopScnKy8vPzFRcXJ0kaMGCAGjVqpKSkJEnS448/rm7dumny5Mnq1auX5s+fr++//15vvvlm5bYEAAAAAACgEjkdmvTr10/79u3TmDFjlJOTo4iICC1btsw+2Ovu3bvl4vLXBSxdunTRvHnzNGrUKD377LNq1aqVlixZossuu6zyWoFaxdPTU4mJiaVuwQJQ8+ifwLmNPgqcu+ifwPnJZnh+EgAAAAAAQClOjWkCAAAAAABwoSA0AQAAAAAAsEBoAgAAAAAAYIHQ5By1c+dO2Ww2ZWRkVNk2VqxYIZvNpgMHDlTZNiSpe/fuGjp0aJVuA/g7+hBqQlhYmJKTk+3vc3JydMMNN8jX11d169atsXqhdhk7dqwiIiJquhoVNmfOHP7eUavRB51ns9m0ZMkS+/vNmzfryiuvlJeXV63+LAGJ0ATVYNGiRXrhhRfKXd6Zg92ioiKNHj1azZo1k7e3t1q0aKEXXnhBp45vfPjwYcXHx6tx48by9vZWu3btNHPmzIo0pdxWrlyprl276uKLL5a3t7fatGmjqVOnVuk2cf66EPtQWYwxuummm0p9OZNOPr2tV69e8vHxUYMGDfT000/rxIkTDmXeffddhYeHy8fHRyEhIbr//vv1+++/O5RZuHCh2rRpIy8vL7Vv315Lly6tcH2nTp2q7OxsZWRkaMuWLRVeD07vvvvuU58+fSq8rM1mk81mk7u7u5o1a6ZnnnlGx44dK1X2119/lYeHh9NPAExLS5Orq6t69epVoTpWhuoIkstj1apVcnNzszyImj59usLCwuTl5aXOnTtr7dq11V9BVAh98MwutD6YmJgoX19fZWVlKTU19SxqDNQ8QhNUuXr16qlOnTpVsu6XXnpJM2bM0GuvvabMzEy99NJLevnll/Xqq6/ayyQkJGjZsmV65513lJmZqaFDhyo+Pl4ff/xxldRJknx9fRUfH6+vv/5amZmZGjVqlEaNGqU333yzyraJ89eF2IfKkpycLJvNVmp6UVGRevXqpcLCQq1evVpz587VnDlzNGbMGHuZVatWacCAARo4cKB++uknLVy4UGvXrtWgQYPsZVavXq3+/ftr4MCBWr9+vfr06aM+ffpo48aNFarvtm3b1KlTJ7Vq1UoNGjSo0DpQ9Xr27Kns7Gxt375dU6dO1RtvvKHExMRS5ebMmaM77rhDeXl5+vbbb8u9/tmzZ+vRRx/V119/rd9++60yq14jjh8/XqHlDhw4oAEDBuj6668vNW/BggVKSEhQYmKi1q1bp/DwcPXo0UN79+492+qiFqAPOqc29MFt27bpqquuUtOmTXXxxRdXaB3AOcOgRhUVFZmXXnrJtGjRwnh4eJjQ0FAzbtw4s2PHDiPJfPjhh6Z79+7G29vbdOjQwaxevdph+W+++cZcddVVxsvLyzRu3Ng8+uij5vDhw/b5x44dM88884xp3Lix8fDwMC1atDBvvfWWMcaYL7/80kgyf/75pzHGmPz8fNOzZ0/TpUsX8+eff9rr8N5775no6Gjj6elpLr30UrNixQqHOqxYscJcccUVxsPDwwQHB5thw4aZ48eP2+d369bNPP744/b3TZs2NS+++KKJi4szfn5+JjQ01Lzxxhv2+ZIcXt26dSvz8+vVq5e5//77Habdfvvt5u6777a/v/TSS83zzz/vUObyyy83I0eOLHO9p5JkZs6caXr16mW8vb1NmzZtzOrVq83PP/9sunXrZnx8fEx0dLTZunXraddz2223mXvuuadc20T50YdqRx+aNWuW6dOnj/H29jYtW7Y0H330kTHm5O+vUaNG5vXXX3dYZt26dcZms5mdO3fap61fv940atTIZGdnG0lm8eLF9nlLly41Li4uJicnxz5txowZxt/f3xQUFBhjjJk4caJp3ry5w3ZeeeUV06hRI/v7O+64w/Tq1cuhTOfOnc2DDz5YrrY2bdrUTJ061f7zqb+H2NjYcq0DzouNjTW33nqr5bwz9S+rZW+//XbTsWNHh2nFxcWmefPmZtmyZWbYsGFm0KBB5arboUOHjJ+fn9m8ebPp16+fefHFF0uVSUpKMg0aNDB+fn7m/vvvN8OGDTPh4eH2+WvXrjUxMTHm4osvNv7+/uaaa64x6enpDuuQZF5//XXTs2dP4+XlZZo1a2YWLlzoML+s/wuzZs0ybdq0MZ6enqZ169Zm+vTp9nkl/8fmz59vrrnmGuPp6Wnefvvt07b57bffNgEBAaWm9+vXz4waNcokJiY6tM8YY6KiosyQIUPs74uKikzDhg1NUlLSabeFcwN9kD546n75721NTEws1zqAcxWhSQ175plnzEUXXWTmzJljtm7dar755hsza9Ys+z/INm3amP/+978mKyvL/POf/zRNmza172i2bt1qfH19zdSpU82WLVvMqlWrTMeOHc19991nX/8dd9xhQkNDzaJFi8y2bdvM//73PzN//nxjjOMB359//mm6dOlibrzxRpOfn2+M+eufdOPGjc0HH3xgNm3aZB544AFTp04ds3//fmOMMb/++qvx8fExjzzyiMnMzDSLFy82gYGBDv8crQ746tWrZ6ZPn25+/vlnk5SUZFxcXMzmzZuNMSd3TJLM//73P5OdnW1+//33Mj+/F1980TRt2tRkZWUZY4zJyMgwDRo0MO+88469zKBBg0xkZKT59ddfTXFxsfniiy+Mn5+f+eqrr8r1O5JkGjVqZBYsWGCysrJMnz59TFhYmLnuuuvMsmXLzKZNm8yVV15pevbsWeY61q1bZ4KCgsysWbPKtU2UH32odvShxo0bm3nz5pmff/7ZPPbYY8bPz89er6eeespcddVVDss8+eSTDtPy8/NN27ZtzZIlS+zrPDU0GT16dKkvgNu3bzeSzLp164wxxqxcudK4u7ubTz/91BQXF5ucnBxzzTXXOHzxDg0NtYceJcaMGWM6dOhQrraeGprs3bvX9OzZ09xxxx0mOzvbHDhwoFzrgPPKOmArT//6+7IbNmwwwcHBpnPnzg7rSk1NNcHBwebEiRNmw4YNpk6dOg4Ba1lmz55tIiMjjTHGfPLJJ6ZFixamuLjYPn/BggXG09PTvPXWW2bz5s1m5MiRpk6dOg5/z6mpqeY///mPyczMNJs2bTIDBw40QUFBJi8vz15Gkrn44ovNrFmzTFZWlhk1apRxdXU1mzZtMsaU/X/hnXfeMSEhIebDDz8027dvNx9++KGpV6+emTNnjjHmr/9jYWFh9jK//fbbadtsdcCWkpJirrjiCnP8+PFSB2wFBQXG1dXVoU8bY8yAAQPMLbfccsbPGDWPPkgfPHW/nJ2dbS699FLz5JNPmuzsbHPo0KFyrQM4VxGa1KC8vDzj6elpeSBd8g+y5Iy2Mcb89NNPRpLJzMw0xhgzcOBAM3jwYIflvvnmG+Pi4mKOHj1qsrKyjCSzfPlyy+2XHPBlZmaaDh06mL59+9rPyJ5ahwkTJtinHT9+3DRu3Ni89NJLxhhjnn32WdO6dWuHnc/06dONn5+fKSoqMsZYH/CdesVFcXGxadCggZkxY4bDdtevX3/az8+Ykyn4sGHDjM1mM25ubsZms5nx48c7lDl27JgZMGCAkWTc3NyMh4eHmTt37hnXXUKSGTVqlP19WlqakWRmz55tn/bee+8ZLy+vUss2atTIeHh4GBcXl1Jn6nH26EMn1bY+dPjwYSPJ/N///Z8x5uQVJDabzezatctep0aNGtnbY4wxgwcPNgMHDnRY56lf7gYNGmRuvPFGh+3m5+cbSWbp0qX2ae+//77x8/Mzbm5uRpLp3bu3KSwstM93d3c38+bNc1jP9OnTTYMGDcrV1lNDE2OMufXWW7nCpBqUdcBWnv4VGxtrXF1dja+vr/H09DSSjIuLi/nggw8c1nXXXXeZoUOH2t+Hh4ef8WyvMcZ06dLFJCcnG2NO9v/AwEDz5Zdf2udHR0ebRx55xGGZzp07lwoBT1VUVGTq1KljPvnkE/s0Seahhx4qtZ6HH37YGFP2/4UWLVqU+pt/4YUXTHR0tMNyJW0oj78fsG3ZssU0aNDAHs7+/YBtz549RlKpKwGffvppExUVVe7toubQB+mDf98vh4eHc4UJzhuMaVKDMjMzVVBQYHlfYYkOHTrYfw4JCZEk+72FP/zwg+bMmSM/Pz/7q0ePHiouLtaOHTuUkZEhV1dXdevW7bT1uOGGG9SyZUstWLBAHh4epeZHR0fbf3Zzc1NkZKQyMzPtbYiOjnYYY6Br1646fPiwfv3113K1y2azKTg4+LT3TH7zzTcO7Xz33XclSe+//77effddzZs3T+vWrdPcuXM1adIkzZ07177sq6++qjVr1ujjjz9Wenq6Jk+erCFDhuh///vfaT+XsuobFBQkSWrfvr3DtGPHjikvL69Uvb///nvNnDlTycnJeu+998q9TZwZfeik2taHfH195e/vb69vRESE2rZtq3nz5kmSvvrqK+3du1f/+te/JEkff/yxvvjiC4en0lTEpk2b9Pjjj2vMmDFKT0/XsmXLtHPnTj300ENntV6cu8rbv6699lplZGTo22+/VWxsrOLi4tS3b1/7/AMHDmjRokW655577NPuuecezZ492/7+1P5V8jeVlZWltWvXqn///pJO9v9+/fo5LJeZmanOnTs71PvU/xmSlJubq0GDBqlVq1YKCAiQv7+/Dh8+rN27d592uejoaPv/Giv5+fnatm2bBg4c6FD/cePGadu2bQ5lIyMjy1zP6RQVFemuu+7Sc889p0suuaRC60DtRR+kDwLnA7earsCFzNvb+4xl3N3d7T+X7HCKi4slnXyixYMPPqjHHnus1HJNmjTR1q1by1WPXr166cMPP9SmTZscgoCqdGq7pJNtK2mXlcjISIfRxkuCi6efflrDhw/XnXfeKelkkLFr1y4lJSUpNjZWR48e1bPPPqvFixfbR0zv0KGDMjIyNGnSJMXExDhd35Lfw+l+NyWaNWtmr1dubq7Gjh1r33Hj7NGH/lKb+pBVfe+++27NmzdPw4cP17x589SzZ0/7wHFffPGFtm3bVurxiX379tXVV1+tFStWKDg4uNQo/7m5uZKk4OBgSVJSUpK6du2qp59+2t4OX19fXX311Ro3bpxCQkIUHBxsX+7U9ZSsA+cnX19ftWzZUpKUkpKi8PBwzZ49WwMHDpQkzZs3T8eOHXM4sDLGqLi4WFu2bNEll1zi0L/8/f0lnRx88sSJE2rYsKHDcp6ennrttdcUEBBQrvrFxsbq999/17Rp09S0aVN5enoqOjpahYWFZ9Xuw4cPS5JmzZpV6qDR1dXV4b2vr2+FtnHo0CF9//33Wr9+veLj4yWd/B9sjJGbm5s+//xzXXXVVXJ1daXvXcDog/RB4FzGlSY1qFWrVvL29q7wY7guv/xybdq0SS1btiz18vDwUPv27VVcXKyvvvrqtOuZMGGCYmNjdf3112vTpk2l5q9Zs8b+84kTJ5Senq62bdtKktq2bau0tDSHx5OuWrVKderUUePGjSvUrpIz9UVFRfZp3t7eDu0reZLIkSNH5OLi+Gfs6upqPxg7fvy4jh8/ftoy1aW4uFgFBQXVus3zHX3IWm3sQ3fddZc2btyo9PR0ffDBB7r77rvt84YPH64ff/xRGRkZ9pd08nG+b7/9tqSTZ/M2bNjgcLXN8uXL5e/vr3bt2p22rZLsn390dHSpv6fly5eXOnuI2qEi/cvFxUXPPvusRo0apaNHj0o6eeD15JNPOvwN/vDDD7r66quVkpIiSQ79q0GDBjpx4oT+/e9/a/LkyaWWa9iwof3Kw7Zt25Z6Csip/zNK6vzYY4/p5ptv1qWXXipPT0/t37+/VN3/vtyaNWvs/2us/i8EBQWpYcOG2r59e6n/gSWh/9ny9/fXhg0bHD6Dhx56SK1bt1ZGRoY6d+4sDw8PderUyaHvFRcXKzU1lb5Xy9EH6YPAeaGGbgvC/zd27Fhz0UUXmblz55qtW7eatLQ089Zbb1ne9/jnn38aSfb7MH/44Qfj7e1thgwZYtavX2+2bNlilixZ4jDy9X333WdCQ0PN4sWLzfbt282XX35pFixYYIwp/eSPoUOHmqCgIPt4DyV1aNKkiVm0aJHJzMw0gwcPNn5+fmbfvn3GmL8G+BoyZIjJzMw0S5YsKdcgln8faPHU+x6PHz9uvL29zbhx40xOTs5pB0+MjY01jRo1Mv/973/Njh07zKJFi0xgYKB55plnHLZ/6aWXmi+//NJs377dvP3228bLy6vU0zrKor/do2n1u/n7Z/naa6+Zjz/+2GzZssVs2bLFvPXWW6ZOnTrlftoIyo8+dFJt6kPGGBMQEFDqXvSuXbua8PBwU6dOHXPkyBGn1nnixAlz2WWXmRtvvNFkZGSYZcuWmfr165sRI0bYy7z99tvGzc3NvP7662bbtm1m5cqVJjIy0uF+7VWrVhk3NzczadIkk5mZaRITE427u7vZsGFDudrKmCY1IzY21nTv3t2sX7/e4bVz584z9i+rsRiOHz9uGjVqZCZOnGjWr1/vMBbSqV5//XUTHBzs8CSQEosXLzYeHh6W/e+ZZ56xD0w5f/584+XlZVJSUkxWVpYZM2ZMqUEoO3bsaG644QazadMms2bNGnP11Vcbb29vh781SSYwMNDMnj3bvh4XFxfz008/2dtk9X9h1qxZxtvb20ybNs1kZWWZH3/80aSkpJjJkycbY5wbI6lEWU/uKGH15I758+cbT09PM2fOHLNp0yYzePBgU7duXYcnYuHcRR+kD/59v8yYJjifEJrUsKKiIjNu3DjTtGlT4+7ubpo0aWLGjx9frgM+Y06OxH3DDTcYPz8/4+vrazp06ODwKLWjR4+aJ554woSEhBgPDw/TsmVLk5KSYowpfcBnjDGPPvqoCQkJMVlZWfY6zJs3z0RFRRkPDw/Trl0788UXXzi0oSKPSz3dAZ8xJ3cgoaGhxsXF5bSPS83LyzOPP/64adKkifHy8jLNmzc3I0eOdBiMMzs729x3332mYcOGxsvLy7Ru3dpMnjzZYVCy06lIaPLKK6+YSy+91Pj4+Bh/f3/TsWNH8/rrr9sHPUPloQ+dVJv6kDHWocnrr79uJJkBAwZUaJ07d+40N910k/H29jaBgYHmySefLPVF+pVXXjHt2rUz3t7eJiQkxNx9993m119/dSjz/vvvm0suucR4eHiYSy+91Hz66aflaqcxhCY1JTY2ttQjLiWZgQMHVuhxp8acfARp/fr1zQMPPGDatWtnud3s7Gzj4uJif4T2qf7xj3+Ym2++2XK5b7/91kgyP/zwgzHm5FOsAgMDjZ+fn4mNjTXPPPOMwwHNunXrTGRkpPHy8jKtWrUyCxcuLPW3JslMnz7d3HDDDcbT09OEhYXZA94SZf1fePfdd01ERITx8PAwF110kbnmmmvMokWLjDHVd8BmjDGvvvqqadKkifHw8DBRUVFmzZo15d4mahZ9kD5IaILzmc2YU66XA06xc+dONWvWTOvXr1dERERNVweodehDAKqLzWbT4sWL1adPn5quCnBBog8C5y/GNAEAAAAAALBAaIIL2rvvvuvwiLdTX5deemlNVw84511Ifejvj23++wu4UNx0001l9oPx48fXdPWA815198ELaV8PWOH2HFzQDh06VOrxaiXc3d3VtGnTaq4RULtcSH3o6NGj2rNnT5nzSx6XCZzv9uzZY3+qyd/Vq1dP9erVq+YaAReW6u6DF9K+HrBCaAIAAAAAAGCB23MAAAAAAAAsEJoAAAAAAABYIDQBAAAAAACwQGgCAAAAAABggdAEAAAAAADAAqEJAADngcLCwpquAgAAwHmH0AQAgFqoe/fuio+P19ChQxUYGKgePXrIZrMpIyPDXubAgQOy2WxasWKFJGnFihWy2WxKTU1VZGSkfHx81KVLF2VlZdVMIwAAAM5xhCYAANRSc+fOlYeHh1atWqWZM2eWe7mRI0dq8uTJ+v777+Xm5qb777+/CmsJAABQe7nVdAUAAEDFtGrVSi+//LIkaefOneVe7sUXX1S3bt0kScOHD1evXr107NgxeXl5VUU1AQAAai2uNAEAoJbq1KlThZbr0KGD/eeQkBBJ0t69eyulTgAAAOcTQhMAAGopX19f+88uLid36cYY+7Tjx49bLufu7m7/2WazSZKKi4uroooAAAC1GqEJAADngfr160uSsrOz7dNOHRQWAAAAzmNMEwAAzgPe3t668sorNWHCBDVr1kx79+7VqFGjarpaAAAAtRpXmgAAcJ5ISUnRiRMn1KlTJw0dOlTjxo2r6SoBAADUajZz6s3PAAAAAAAAkMSVJgAAAAAAAJYITQAAAAAAACwQmgAAAAAAAFggNAEAAAAAALBAaAIAAAAAAGCB0AQAAAAAAMACoQkAAAAAAIAFQhMAAAAAAAALhCYAAAAAAAAWCE0AAAAAAAAsEJoAAAAAAABYIDQBAAAAAACw8P8Aehkem+eVMMsAAAAASUVORK5CYII=","text/plain":["<Figure size 1200x500 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# plot metrics for each model\n","import matplotlib.pyplot as plt\n","\n","fig, ax = plt.subplots(1, 1, figsize=(12, 5))\n","\n","perf_df.plot(x=\"run\", y=[\"accuracy\", \"precision\", \"recall\", \"f1\"], kind=\"bar\", ax=ax)\n","\n","# add values on top of bars\n","for p in ax.patches:\n","    ax.annotate(\n","        f\"{p.get_height():.3f}\",\n","        (p.get_x() + p.get_width() / 2, p.get_height()),\n","        ha=\"center\",\n","        va=\"bottom\",\n","        fontsize=10,\n","    )\n","\n","# add title and labels\n","# ax.set_title(\"Metrics for different settings\")\n","# ax.set_ylabel(\"Value\")\n","# ax.set_xlabel(\"Epoch (0: base model, 1-4: fine-tuned models)\")\n","# rotate x labels\n","plt.xticks(rotation=0)\n","\n","# set legend at the right to avoid overlapping with bars\n","plt.legend(loc=\"center left\", bbox_to_anchor=(1.0, 0.5))\n","# plt.tight_layout()\n","\n","plt.show()"]}],"metadata":{"accelerator":"GPU","application/vnd.databricks.v1+notebook":{"dashboards":[],"environmentMetadata":null,"language":"python","notebookMetadata":{"pythonIndentUnit":4},"notebookName":"07_MAC_+_Qwen2-7B-Instructi_Unsloth_train","widgets":{}},"colab":{"gpuType":"T4","provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.11.9"}},"nbformat":4,"nbformat_minor":0}