fetalhc-classification-with-unet.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":9166121,"sourceType":"datasetVersion","datasetId":5299006}],"dockerImageVersionId":30746,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport torch\nimport os\nfrom PIL import Image\nfrom sklearn.metrics import classification_report\nimport torch.utils.data\nfrom torch.utils.data import DataLoader, Dataset, random_split, Subset\nfrom torchvision import transforms\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport torchvision.transforms.functional as Func\nimport timm\nimport cv2\nimport math","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-08-14T09:17:46.765431Z","iopub.execute_input":"2024-08-14T09:17:46.765791Z","iopub.status.idle":"2024-08-14T09:17:53.798549Z","shell.execute_reply.started":"2024-08-14T09:17:46.765762Z","shell.execute_reply":"2024-08-14T09:17:53.797644Z"},"trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"code","source":"# Set flags True to include Test set and GAN set\ninclude_test_set = True\ninclude_gan_set = False\n\n# Load dataframes\ntrain_csv = pd.read_csv(\"/kaggle/input/fetalhcdata/training_set/training_set_circumference.csv\")\nif include_test_set:\n    test_csv = pd.read_csv(\"/kaggle/input/fetalhcdata/test_set/test_set_circumference.csv\")\nif include_gan_set:\n    gan_csv = pd.read_csv(\"/kaggle/input/fetalhcdata/gan_set/measured_circumference.csv\")\n    #gan_csv_new = pd.read_csv(\"/kaggle/input/fetalhcdata/gan_set_without_masks/measured_circumference.csv\")\n\n# Add 'dataset' column\ntrain_csv['dataset'] = 'train'\nif include_test_set:\n    test_csv['dataset'] = 'test'\nif include_gan_set:\n    gan_csv['dataset'] = 'gan'\n    #gan_csv_new['dataset'] = 'gan_new'\n\n# Concatenate the dataframes\ndfs_to_concat = [train_csv]\nif include_test_set:\n    dfs_to_concat.append(test_csv)\nif include_gan_set:\n    dfs_to_concat.append(gan_csv)\n    #dfs_to_concat.append(gan_csv_new)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:53.800013Z","iopub.execute_input":"2024-08-14T09:17:53.800318Z","iopub.status.idle":"2024-08-14T09:17:53.835574Z","shell.execute_reply.started":"2024-08-14T09:17:53.800292Z","shell.execute_reply":"2024-08-14T09:17:53.834693Z"},"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"code","source":"## Concatenate the dataframes\nmerged_df = pd.concat(dfs_to_concat)\n\n# Select classification based on one type of diameter or non to classify head circumference.\nclassify_ofd = False\nclassify_bpd = False\n\n# Define parameters based on classification type\nif classify_ofd:\n    column_name = 'OFD'\n    lowest_value_cm, highest_value_cm, limit_per_class = 3, 16, 375\n    gan_samples_limit, oversample_limit = 1000, 0\nelif classify_bpd:\n    column_name = 'BPD'\n    lowest_value_cm, highest_value_cm, limit_per_class = 2, 14, 410\n    gan_samples_limit, oversample_limit = 1000, 0\nelse:\n    column_name = 'Head_Circumference_mm'\n    lowest_value_cm, highest_value_cm, limit_per_class = 6, 33, 230\n    gan_samples_limit, oversample_limit = 1000, 0\n\n# Calculate class based on the scale factor\nmerged_df['class'] = np.round(merged_df[column_name]/10)\n\n# Generate the classes list\nclasses = list(range(lowest_value_cm, highest_value_cm + 1))\n\n# Priority order\npriority = ['gan_new', 'gan', 'test', 'train']\n\nmerged_df.loc[(merged_df['class'] <= lowest_value_cm), 'class'] = lowest_value_cm\nmerged_df.loc[(merged_df['class'] > highest_value_cm), 'class'] = highest_value_cm","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:53.836663Z","iopub.execute_input":"2024-08-14T09:17:53.836988Z","iopub.status.idle":"2024-08-14T09:17:53.852155Z","shell.execute_reply.started":"2024-08-14T09:17:53.836958Z","shell.execute_reply":"2024-08-14T09:17:53.851272Z"},"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"# Extract 20% of samples from all datasets and 20% from 'train' dataset\nextracted_samples_test = []\nextracted_samples_train = []\nextracted_samples_gan = []\nfor cir_class in classes:\n    samples_in_class = merged_df[merged_df['class'] == cir_class]\n    sample_count_gan = len(samples_in_class[samples_in_class['dataset'] == 'gan'])\n    sample_count_train = len(samples_in_class[samples_in_class['dataset'] == 'train'])\n    sample_count_test = len(samples_in_class[samples_in_class['dataset'] == 'test'])\n    \n    if sample_count_train > 1:\n        extract_count_train = max(1, int(sample_count_train * 0.2))\n        extracted_samples_train.append(samples_in_class[samples_in_class['dataset'] == 'train'].sample(n=extract_count_train, random_state=42))\n    else:\n        print(f\"{cir_class}:{sample_count_train}\")\n        \n    if sample_count_gan > 1:\n        extract_count_gan = max(1, int(sample_count_gan * 0.2)) \n        extracted_samples_gan.append(samples_in_class[samples_in_class['dataset'] == 'gan'].sample(n=extract_count_gan, random_state=42))\n        \n    if sample_count_test > 1:\n        extract_count_test = max(1, int(sample_count_test * 0.2))\n        extracted_samples_test.append(samples_in_class[samples_in_class['dataset'] == 'test'].sample(n=extract_count_test, random_state=42))\n\n# Combine the extracted samples into a single DataFrame\nextracted_samples = extracted_samples_test + extracted_samples_train + extracted_samples_gan\nif extracted_samples:\n    extracted_df = pd.concat(extracted_samples)\n    # Remove the extracted samples from the merged_df\n    indices_to_keep = ~merged_df.set_index(['dataset', 'filename']).index.isin(extracted_df.set_index(['dataset', 'filename']).index)\n    merged_df = merged_df.loc[indices_to_keep]\nelse:\n    extracted_df = pd.DataFrame()","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:53.854195Z","iopub.execute_input":"2024-08-14T09:17:53.854620Z","iopub.status.idle":"2024-08-14T09:17:53.980587Z","shell.execute_reply.started":"2024-08-14T09:17:53.854584Z","shell.execute_reply":"2024-08-14T09:17:53.979754Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"# Iterate over each class and limit the number of samples\nfor cir_class in classes:\n    samples_in_class = merged_df[merged_df['class'] == cir_class]\n    gan_samples_in_class = samples_in_class[(samples_in_class['dataset'] == 'gan')]\n    \n    if len(gan_samples_in_class) <= gan_samples_limit:\n        continue\n        \n    samples_to_remove = len(gan_samples_in_class) - gan_samples_limit\n    excess_samples = gan_samples_in_class.sample(n=samples_to_remove, random_state=42)\n    indices_to_keep = ~merged_df.set_index(['dataset', 'filename']).index.isin(excess_samples.set_index(['dataset', 'filename']).index)\n    merged_df = merged_df.loc[indices_to_keep]","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:53.981761Z","iopub.execute_input":"2024-08-14T09:17:53.982063Z","iopub.status.idle":"2024-08-14T09:17:54.014182Z","shell.execute_reply.started":"2024-08-14T09:17:53.982037Z","shell.execute_reply":"2024-08-14T09:17:54.013231Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"code","source":"for cir_class in classes:\n    samples_in_class = merged_df[merged_df['class'] == cir_class]\n    \n    if len(samples_in_class) == 0:\n        print(f\"Class {cir_class - lowest_value_cm} has no samples\")\n\n    if len(samples_in_class) <= limit_per_class:\n        continue\n\n    excess_count = len(samples_in_class) - limit_per_class\n    \n    for dataset in priority:\n        if excess_count <= 0:\n            break\n        dataset_samples = samples_in_class[(samples_in_class['dataset'] == dataset)]\n        if len(dataset_samples) > 0:\n            samples_to_remove = min(len(dataset_samples), excess_count)\n            excess_samples = dataset_samples.sample(n=samples_to_remove, random_state=42)\n            indices_to_keep = ~merged_df.set_index(['dataset', 'filename']).index.isin(excess_samples.set_index(['dataset', 'filename']).index)\n            merged_df = merged_df.loc[indices_to_keep]\n            excess_count -= samples_to_remove\n\n# Oversample samples in each class until reaching limit_per_class amount of samples\nfor cir_class in classes:\n    samples_in_class = merged_df[merged_df['class'] == cir_class]\n    \n    if len(samples_in_class) < oversample_limit:\n        needed_samples = oversample_limit - len(samples_in_class)\n        oversampled_samples = samples_in_class.sample(n=needed_samples, replace=True, random_state=42)\n        merged_df = pd.concat([merged_df, oversampled_samples])\n\n# Create a new merged_df with the filtered data\nmerged_df = merged_df.drop(columns=['class'])\n\nval_df = pd.concat(extracted_samples_train)\nval_df = val_df.drop(columns=['class'])\n\nfiltered_df = merged_df.copy()\n\n# Display the filtered dataframe\nfiltered_df.head()","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:54.015358Z","iopub.execute_input":"2024-08-14T09:17:54.015666Z","iopub.status.idle":"2024-08-14T09:17:54.068267Z","shell.execute_reply.started":"2024-08-14T09:17:54.015640Z","shell.execute_reply":"2024-08-14T09:17:54.067479Z"},"trusted":true},"execution_count":6,"outputs":[{"execution_count":6,"output_type":"execute_result","data":{"text/plain":"      filename  Head_Circumference_cm  Head_Circumference_mm  pixel size(mm)  \\\n0   000_HC.png                  4.430                  44.30        0.069136   \n1   001_HC.png                  5.681                  56.81        0.089659   \n2   012_HC.png                  5.940                  59.40        0.083460   \n3   004_HC.png                  5.981                  59.81        0.061240   \n4  014_3HC.png                  6.026                  60.26        0.077308   \n\n    OFD   BPD     mask_filename dataset  \n0  23.9  15.4   000_HC_Mask.png   train  \n1  25.7  23.3   001_HC_Mask.png   train  \n2  29.3  22.7   012_HC_Mask.png   train  \n3  30.7  21.6   004_HC_Mask.png   train  \n4  28.1  24.1  014_3HC_Mask.png   train  ","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>filename</th>\n      <th>Head_Circumference_cm</th>\n      <th>Head_Circumference_mm</th>\n      <th>pixel size(mm)</th>\n      <th>OFD</th>\n      <th>BPD</th>\n      <th>mask_filename</th>\n      <th>dataset</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>000_HC.png</td>\n      <td>4.430</td>\n      <td>44.30</td>\n      <td>0.069136</td>\n      <td>23.9</td>\n      <td>15.4</td>\n      <td>000_HC_Mask.png</td>\n      <td>train</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>001_HC.png</td>\n      <td>5.681</td>\n      <td>56.81</td>\n      <td>0.089659</td>\n      <td>25.7</td>\n      <td>23.3</td>\n      <td>001_HC_Mask.png</td>\n      <td>train</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>012_HC.png</td>\n      <td>5.940</td>\n      <td>59.40</td>\n      <td>0.083460</td>\n      <td>29.3</td>\n      <td>22.7</td>\n      <td>012_HC_Mask.png</td>\n      <td>train</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>004_HC.png</td>\n      <td>5.981</td>\n      <td>59.81</td>\n      <td>0.061240</td>\n      <td>30.7</td>\n      <td>21.6</td>\n      <td>004_HC_Mask.png</td>\n      <td>train</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>014_3HC.png</td>\n      <td>6.026</td>\n      <td>60.26</td>\n      <td>0.077308</td>\n      <td>28.1</td>\n      <td>24.1</td>\n      <td>014_3HC_Mask.png</td>\n      <td>train</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"cell_type":"code","source":"device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nworkers = 4 if torch.cuda.is_available() else 0\nprint(device)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:54.069695Z","iopub.execute_input":"2024-08-14T09:17:54.070060Z","iopub.status.idle":"2024-08-14T09:17:54.109948Z","shell.execute_reply.started":"2024-08-14T09:17:54.070029Z","shell.execute_reply":"2024-08-14T09:17:54.108992Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"cuda\n","output_type":"stream"}]},{"cell_type":"code","source":"def filter_by_age_range(df, cir_cm_column_name, range_start, range_end, include=True):\n    conditions = [\n        (df[cir_cm_column_name] < 8.00),\n        (df[cir_cm_column_name] >= 8.00) & (df[cir_cm_column_name] <= 9.00),  # week 13\n        (df[cir_cm_column_name] > 9.00) & (df[cir_cm_column_name] <= 10.49),  # week 14\n        (df[cir_cm_column_name] > 10.49) & (df[cir_cm_column_name] <= 12.49), # week 15\n        (df[cir_cm_column_name] > 12.49) & (df[cir_cm_column_name] <= 13.49), # week 16\n        (df[cir_cm_column_name] > 13.49) & (df[cir_cm_column_name] <= 14.99), # week 17\n        (df[cir_cm_column_name] > 14.99) & (df[cir_cm_column_name] <= 16.49), # week 18\n        (df[cir_cm_column_name] > 16.49) & (df[cir_cm_column_name] <= 17.49), # week 19\n        (df[cir_cm_column_name] > 17.49) & (df[cir_cm_column_name] <= 18.99), # week 20\n        (df[cir_cm_column_name] > 18.99) & (df[cir_cm_column_name] <= 19.99), # week 21\n        (df[cir_cm_column_name] > 19.99) & (df[cir_cm_column_name] <= 20.99), # week 22\n        (df[cir_cm_column_name] > 20.99) & (df[cir_cm_column_name] <= 22.49), # week 23\n        (df[cir_cm_column_name] > 22.49) & (df[cir_cm_column_name] <= 22.99), # week 24\n        (df[cir_cm_column_name] >= 23.00) & (df[cir_cm_column_name] <= 23.99),# week 25\n        (df[cir_cm_column_name] > 23.99) & (df[cir_cm_column_name] <= 24.79), # week 26\n        (df[cir_cm_column_name] > 24.79) & (df[cir_cm_column_name] <= 25.60), # week 27\n        (df[cir_cm_column_name] > 25.60) & (df[cir_cm_column_name] <= 26.75), # week 28\n        (df[cir_cm_column_name] > 26.75) & (df[cir_cm_column_name] <= 27.75), # week 29\n        (df[cir_cm_column_name] > 27.75) & (df[cir_cm_column_name] <= 28.85), # week 30\n        (df[cir_cm_column_name] > 28.85) & (df[cir_cm_column_name] <= 29.60), # week 31\n        (df[cir_cm_column_name] > 29.60) & (df[cir_cm_column_name] <= 30.40), # week 32\n        (df[cir_cm_column_name] > 30.40) & (df[cir_cm_column_name] <= 31.20), # week 33\n        (df[cir_cm_column_name] > 31.20) & (df[cir_cm_column_name] <= 31.80), # week 34\n        (df[cir_cm_column_name] > 31.80) & (df[cir_cm_column_name] <= 32.50), # week 35\n        (df[cir_cm_column_name] > 32.50) & (df[cir_cm_column_name] <= 33.00), # week 36\n        (df[cir_cm_column_name] > 33.00) & (df[cir_cm_column_name] <= 33.70), # week 37\n        (df[cir_cm_column_name] > 33.70) & (df[cir_cm_column_name] <= 34.20), # week 38\n        (df[cir_cm_column_name] > 34.20) & (df[cir_cm_column_name] <= 35.00), # week 39\n        (df[cir_cm_column_name] > 35.00) & (df[cir_cm_column_name] <= 36.00), # week 40\n        (df[cir_cm_column_name] > 36)\n    ]\n\n    values = [\n        'Fetus is less than 8 Menstrual Weeks', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22',\n        '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', 'Abnormal'\n    ]\n    \n    # Create a new column 'Age' based on conditions and values\n    df['Age'] = np.select(conditions, values, default='Unknown')\n\n    # Forward fill 'Unknown' ages with the last known age\n    df['Age'] = df['Age'].replace('Unknown', np.nan).ffill()\n\n    # Filter the DataFrame to keep or exclude rows with ages within the specified range\n    age_range = range(range_start, range_end + 1)  # +1 to include the end value in the range\n    if include:\n        filtered_df = df[df['Age'].isin(map(str, age_range))]\n    else:\n        filtered_df = df[~df['Age'].isin(map(str, age_range))]\n\n    return filtered_df\n\n#filtered_df = filter_by_age_range(merged_df.copy(), 'Head_Circumference_cm', 21, 40, include = False)\n#val_df= filter_by_age_range(val_df.copy(), 'Head_Circumference_cm', 21, 40, include = False)\n\n#print(filtered_df['Age'])","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:54.111690Z","iopub.execute_input":"2024-08-14T09:17:54.112084Z","iopub.status.idle":"2024-08-14T09:17:54.132292Z","shell.execute_reply.started":"2024-08-14T09:17:54.112046Z","shell.execute_reply":"2024-08-14T09:17:54.131276Z"},"trusted":true},"execution_count":8,"outputs":[]},{"cell_type":"code","source":"def classify_head_measurements(df, column_name):\n    def round_classification(value):\n        rounded_value = int(np.round(value/10))\n        if rounded_value <= lowest_value_cm:\n            return lowest_value_cm\n        elif rounded_value > highest_value_cm:\n            return highest_value_cm\n        else:\n            return rounded_value\n\n    df['classes'] = df[column_name].apply(round_classification)\n    \n    # Normalize class labels to start from 0\n    unique_classes = sorted(df['classes'].unique())\n    class_mapping = {old_class: new_class for new_class, old_class in enumerate(unique_classes)}\n    df['classes'] = df['classes'].map(class_mapping)\n    \n    num_classes = df['classes'].nunique()\n\n    return num_classes, class_mapping\n\nnum_classes, class_mapping = classify_head_measurements(filtered_df, column_name)\nclassify_head_measurements(val_df, column_name)\nbalanced_df = filtered_df.copy()\n\nprint(\"Class Mapping:\", class_mapping)\nprint(\"Number of Classes:\", num_classes)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:54.133600Z","iopub.execute_input":"2024-08-14T09:17:54.133946Z","iopub.status.idle":"2024-08-14T09:17:54.161435Z","shell.execute_reply.started":"2024-08-14T09:17:54.133914Z","shell.execute_reply":"2024-08-14T09:17:54.160453Z"},"trusted":true},"execution_count":9,"outputs":[{"name":"stdout","text":"Class Mapping: {6: 0, 7: 1, 8: 2, 9: 3, 10: 4, 11: 5, 12: 6, 13: 7, 14: 8, 15: 9, 16: 10, 17: 11, 18: 12, 19: 13, 20: 14, 21: 15, 22: 16, 23: 17, 24: 18, 25: 19, 26: 20, 27: 21, 28: 22, 29: 23, 30: 24, 31: 25, 32: 26, 33: 27}\nNumber of Classes: 28\n","output_type":"stream"}]},{"cell_type":"code","source":"def plot_class_distribution(df, dataset_colors=None):\n    # Make a copy of the DataFrame to avoid altering the original\n    df_copy = df.copy()\n    \n    # Identify unique datasets in the 'dataset' column\n    unique_datasets = df_copy['dataset'].unique()\n\n    # Initialize a dictionary to hold class counts for each dataset\n    class_counts_dict = {}\n\n    # Loop through each unique dataset and count class occurrences\n    for dataset in unique_datasets:\n        dataset_data = df_copy[df_copy['dataset'] == dataset]\n        class_counts = dataset_data['classes'].value_counts().sort_index()\n        class_counts_dict[dataset] = class_counts\n\n    # Combine the counts into a single DataFrame\n    class_counts = pd.DataFrame(class_counts_dict).fillna(0)\n\n    # Plotting\n    fig, ax = plt.subplots(figsize=(12, 6))\n\n    # Default colors if dataset_colors is not provided\n    default_colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']\n    if dataset_colors is None:\n        dataset_colors = {}\n    \n    # Bar width\n    bar_width = 0.35\n\n    # Initialize bottom for stacked bars\n    bottom = None\n\n    for i, dataset in enumerate(class_counts.columns):\n        if bottom is None:\n            bottom = np.zeros_like(class_counts[dataset])\n\n        # Get color for current dataset\n        color = dataset_colors.get(dataset, default_colors[i % len(default_colors)])\n\n        ax.bar(class_counts.index, class_counts[dataset], bottom=bottom, color=color, edgecolor='grey', label=dataset)\n        bottom += class_counts[dataset]\n\n    # Add labels\n    ax.set_xlabel('Class')\n    ax.set_ylabel('Occurrences')\n    ax.set_title('Occurrences of Each Class in Different Datasets')\n    ax.legend()\n\n    # Set x-axis tick labels with class numbers\n    ax.set_xticks(range(len(class_counts)))\n    ax.set_xticklabels(class_counts.index)\n\n    # Increase y-axis limit a little more than the top value\n    max_count = class_counts.sum(axis=1).max()\n    ax.set_ylim(0, max_count * 1.1)\n\n    # Show plot\n    plt.show()\n\ndataset_colors = {'train': '#1f77b4', 'test': '#ff7f0e', 'gan': '#d62728', 'gan_new': '#9467bd'}\nplot_class_distribution(balanced_df, dataset_colors)\nplot_class_distribution(val_df, dataset_colors)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:54.165026Z","iopub.execute_input":"2024-08-14T09:17:54.165407Z","iopub.status.idle":"2024-08-14T09:17:55.003078Z","shell.execute_reply.started":"2024-08-14T09:17:54.165367Z","shell.execute_reply":"2024-08-14T09:17:55.002217Z"},"trusted":true},"execution_count":10,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x600 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAA+0AAAIjCAYAAAB20vpjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABqgUlEQVR4nO3deVxUZf//8fewyo4oCLggLuWSW1hupaaGW5ZmmWauZeUNlZpmVqZZZlamWaZ33abedntXmpjZnWauaS655ZKamksuiEqAiLGe3x/9mK8jqAgzzAFez8eDx8M558z1uc4wc5w31znnshiGYQgAAAAAAJiOi7M7AAAAAAAA8kdoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwDg/zt06JCio6MVEBAgi8WiJUuWOLtLNgYOHChfX99iqbV27VpZLBatXbu2WOoVVNu2bdW2bVun9mH8+PGyWCw2y7KysvTCCy+oatWqcnFxUffu3SVJqampeuKJJxQaGiqLxaJhw4YVf4cBACUaoR0ACmHfvn167LHHVLlyZXl6eio8PFx9+/bVvn37nN01FMGAAQO0Z88eTZw4UfPnz1fTpk3z3e7YsWOyWCzX/HnrrbeKuec3Jy4uTp07d1bFihXl4eGh8PBw9erVS6tXr3Z214rd3LlzbX535cqVU3h4uDp27Kjp06fr4sWLBWrn008/1TvvvKOHHnpI8+bN0/DhwyVJb775pubOnauhQ4dq/vz56tevnyN3p0gWLFigadOmFXj76tWrW183FxcXBQYGqkGDBnryySe1ZcuWIvXlzTffNM0fzX799VeNHz9ex44dc3ZXAJRRFsMwDGd3AgBKksWLF6tPnz4KCgrS448/rsjISB07dkyzZ8/WhQsX9Pnnn6tHjx7O7iZu0uXLl+Xt7a2XX35Zb7zxxnW3PXbsmCIjI9WnTx916dIlz/omTZqofv36du/jwIEDtWjRIqWmphbq+YZhaPDgwZo7d66aNGmihx56SKGhoTpz5ozi4uK0fft2bdy4US1bttTatWt1zz33aM2aNU4f2b5SRkaGJMnDw8Mu7c2dO1eDBg3ShAkTFBkZqczMTMXHx2vt2rVauXKlqlWrpqVLl6phw4bW52RlZSkrK0vlypWzLuvdu7c2bNigkydP2rTfvHlzubm5acOGDXbpryPdd9992rt3b4HDafXq1VW+fHk9//zzkqSLFy9q//79WrhwoeLj4zV8+HC99957heqLr6+vHnroIc2dO7dQz7enRYsW6eGHHzbdZwFA2eHm7A4AQEly5MgR9evXTzVq1ND69esVHBxsXffcc8/p7rvvVr9+/bR7927VqFHDiT3NKy0tTd7e3nmWZ2VlKScnx24hqKQ6d+6cJCkwMLDAz7n99tv12GOPOahH9jdlyhTNnTtXw4YN03vvvWdzivfLL7+s+fPny83N3F8NHPU+7dy5s82ZFWPGjNHq1at133336f7779f+/fvl5eUlSXJzc8vzOiUkJOT73klISFC9evXs1s+cnBxlZGTY/MHAmSpXrpznMzB58mQ9+uijmjp1qmrXrq2hQ4c6qXcAUDpwejwA3IR33nlHaWlp+vjjj20CuyRVrFhR//znP3Xp0iW9/fbbNutOnTqlxx9/XOHh4fL09FRkZKSGDh1qHTWUpKSkJA0fPlzVq1eXp6enqlSpov79++v8+fOS/u803qtHwfK79rht27a67bbbtH37drVu3Vre3t566aWXrKd1v/vuu5o2bZpq1qwpT09P/frrr5KkAwcO6KGHHlJQUJDKlSunpk2baunSpTb1cvuxceNGjRgxQsHBwfLx8VGPHj2swfdK3333ndq0aSM/Pz/5+/vrjjvu0IIFC2y22bJlizp16qSAgAB5e3urTZs22rhxo802Fy9e1LBhw6yvT0hIiO69917t2LHjOr+xv+3cuVOdO3eWv7+/fH191b59e23evNm6fvz48YqIiJAkjRo1ShaLRdWrV79huwXx9ddfq2vXrtbffc2aNfX6668rOzs7z7ZbtmxRly5dVL58efn4+Khhw4Z6//3382x36tQpde/eXb6+vgoODtbIkSPzbe9Kly9f1qRJk1SnTh29++67ea7JlqR+/frpzjvvvGYbP/74ox5++GFVq1ZNnp6eqlq1qoYPH67Lly/bbBcfH69BgwapSpUq8vT0VFhYmB544AGb9+62bdvUsWNHVaxYUV5eXoqMjNTgwYOvuw9S3mvac9//X375pSZOnKgqVaqoXLlyat++vQ4fPnzD9q6nXbt2Gjt2rI4fP67PPvvMuvzKa9pzP1Nr1qzRvn37rKeL5/br6NGj+vbbb63Lc1+D9PR0jRs3TrVq1bK+li+88ILS09Nt+mCxWBQbG6v//Oc/ql+/vjw9PbV8+XJJf78PBg8erEqVKsnT01P169fXp59+avP8gr4+bdu21bfffqvjx49b+1rYz4CXl5fmz5+voKAgTZw4UVee1Pnuu++qZcuWqlChgry8vBQVFaVFixbl2edLly5p3rx51r4MHDhQknT8+HH94x//0K233iovLy9VqFBBDz/8cJ7jYmZmpl577TXVrl1b5cqVU4UKFXTXXXdp5cqVNtvd6Jg3d+5cPfzww5Kke+65x+b3KxX+fQwAN8Pcf04HAJP55ptvVL16dd199935rm/durWqV6+ub7/91rrs9OnTuvPOO5WUlKQnn3xSderU0alTp7Ro0SKlpaXJw8NDqampuvvuu7V//34NHjxYt99+u86fP6+lS5fq5MmTqlix4k339cKFC+rcubN69+6txx57TJUqVbKumzNnjv766y89+eST8vT0VFBQkPbt26dWrVqpcuXKevHFF+Xj46Mvv/xS3bt311dffZXnlP9nnnlG5cuX17hx43Ts2DFNmzZNsbGx+uKLL6zbzJ07V4MHD1b9+vU1ZswYBQYGaufOnVq+fLkeffRRSdLq1avVuXNnRUVFady4cXJxcdGcOXPUrl07/fjjj9YQ+fTTT2vRokWKjY1VvXr1dOHCBW3YsEH79+/X7bfffs3XYd++fbr77rvl7++vF154Qe7u7vrnP/+ptm3bat26dWrWrJkefPBBBQYGavjw4dZT3gtyw7e0tDTrH1WuFBgYaB2JnTt3rnx9fTVixAj5+vpq9erVevXVV5WSkqJ33nnH+pyVK1fqvvvuU1hYmJ577jmFhoZq//79WrZsmZ577jnrdtnZ2erYsaOaNWumd999Vz/88IOmTJmimjVrXndEc8OGDUpMTNSwYcPk6up6w33Lz8KFC5WWlqahQ4eqQoUK2rp1qz744AOdPHlSCxcutG7Xs2dP7du3T88884yqV6+uhIQErVy5UidOnLA+jo6OVnBwsF588UUFBgbq2LFjWrx4caH6JUlvvfWWXFxcNHLkSCUnJ+vtt99W3759i3xtdb9+/fTSSy/p+++/15AhQ/KsDw4O1vz58zVx4kSlpqZq0qRJkqS6detq/vz5Gj58uKpUqWI9hTw4OFg5OTm6//77tWHDBj355JOqW7eu9uzZo6lTp+q3337Lcy336tWr9eWXXyo2NlYVK1ZU9erVdfbsWTVv3twa6oODg/Xdd9/p8ccfV0pKSp4b3t3o9Xn55ZeVnJyskydPaurUqZJUpJse+vr6qkePHpo9e7Z+/fVX6+Ui77//vu6//3717dtXGRkZ+vzzz/Xwww9r2bJl6tq1qyRp/vz5euKJJ3TnnXfqySeflCTVrFlTkvTzzz/rp59+Uu/evVWlShUdO3ZMM2fOVNu2bfXrr79azyYaP368Jk2aZG0nJSVF27Zt044dO3TvvfdKUoGOea1bt9azzz6r6dOn66WXXlLdunWtv19HvI8BIF8GAKBAkpKSDEnGAw88cN3t7r//fkOSkZKSYhiGYfTv399wcXExfv755zzb5uTkGIZhGK+++qohyVi8ePE1t5kzZ44hyTh69KjN+jVr1hiSjDVr1liXtWnTxpBkzJo1y2bbo0ePGpIMf39/IyEhwWZd+/btjQYNGhh//fWXTe2WLVsatWvXti7L7UeHDh2sfTMMwxg+fLjh6upqJCUlGYbx9+vl5+dnNGvWzLh8+XK++5STk2PUrl3b6Nixo01baWlpRmRkpHHvvfdalwUEBBgxMTF5Xp8b6d69u+Hh4WEcOXLEuuz06dOGn5+f0bp16zyvzTvvvHPDNnO3vdbPpk2bbPblak899ZTh7e1tfa2zsrKMyMhIIyIiwvjzzz9ttr3ydRkwYIAhyZgwYYLNNk2aNDGioqKu2+f333/fkGTExcXdcP8MI//3VX77MmnSJMNisRjHjx83DMMw/vzzzxu+jnFxcYakfD8TN9KmTRujTZs2efpZt25dIz093bo8d3/37Nlz3fZy38/X60tAQIDRpEkT6+Nx48YZV3+FatOmjVG/fv08z42IiDC6du1qs2z+/PmGi4uL8eOPP9osnzVrliHJ2Lhxo3WZJMPFxcXYt2+fzbaPP/64ERYWZpw/f95mee/evY2AgADr7+pmXp+uXbsaERER13wdCrJvV5o6daohyfj666+ty65+D2VkZBi33Xab0a5dO5vlPj4+xoABA/K0md97cNOmTYYk49///rd1WaNGja7bN8Mo+DFv4cKFeT4LhlG09zEA3AxOjweAAsq9i7Sfn991t8tdn5KSopycHC1ZskTdunXL907kuafYfvXVV2rUqFG+N7DL7zTmgvD09NSgQYPyXdezZ0+b0/sTExO1evVq9erVSxcvXtT58+d1/vx5XbhwQR07dtShQ4d06tQpmzaefPJJm77dfffdys7O1vHjxyX9PXJ88eJFvfjii3muv8193q5du3To0CE9+uijunDhgrXupUuX1L59e61fv145OTmS/h693rJli06fPl3g1yA7O1vff/+9unfvbnOPgbCwMD366KPasGGDUlJSCtze1Z588kmtXLkyz8+V1zDnXgctyfra3n333UpLS9OBAwck/X36/tGjRzVs2LA810Xn9/t/+umnbR7ffffd+v3336/b19z9vNH793qu3JdLly7p/PnzatmypQzD0M6dO63beHh4aO3atfrzzz/zbSd3H5ctW6bMzMxC9+dKgwYNsrnePfdsmBu9LgXh6+tb4LvIF8TChQtVt25d1alTx/qeP3/+vNq1aydJWrNmjc32bdq0sXlPGYahr776St26dZNhGDZtdOzYUcnJyXkuG3Hk63MtuSP1V752V76H/vzzTyUnJ+vuu+8u0GUuVz8/MzNTFy5cUK1atRQYGGjTRmBgoPbt26dDhw7l205hjnlXc8T7GADyw+nxAFBAuWHnRl/erwz3586dU0pKim677bbrPufIkSPq2bOnfTr6/1WuXPmaN+2KjIy0eXz48GEZhqGxY8dq7Nix+T4nISFBlStXtj6uVq2azfry5ctLkjWoHTlyRJKuu++5X6gHDBhwzW2Sk5NVvnx5vf322xowYICqVq2qqKgodenSRf3797/uDf/OnTuntLQ03XrrrXnW1a1bVzk5Ofrjjz8Kfaf32rVrq0OHDtfdZt++fXrllVe0evXqPH8gSE5OllSw1ypXuXLl8txPoXz58tcMyLn8/f0l3fj9ez0nTpzQq6++qqVLl+apl7svnp6emjx5sp5//nlVqlRJzZs313333af+/fsrNDRU0t8htGfPnnrttdc0depUtW3bVt27d9ejjz4qT0/PQvXtRu/HokhNTVVISEiR28l16NAh7d+/P8/vMVdCQoLN46s/r+fOnVNSUpI+/vhjffzxxwVqw5Gvz7XkznJw5R+Kli1bpjfeeEO7du2yuX6/oH+czL03w5w5c3Tq1Cmb6+Vz34OSNGHCBD3wwAO65ZZbdNttt6lTp07q16+fdRaAwhzzruaI9zEA5IfQDgAFFBAQoLCwMO3evfu62+3evVuVK1eWv79/nht0FcW1vtRe6wZkV45I3Whd7mj2yJEj1bFjx3yfU6tWLZvH17ou2riJmURz677zzjtq3Lhxvtvkjtb16tVLd999t+Li4vT999/rnXfe0eTJk7V48WJ17ty5wDWLU1JSktq0aSN/f39NmDBBNWvWVLly5bRjxw6NHj3auv83o7DXo9epU0eStGfPHnXv3v2mn5+dna17771XiYmJGj16tOrUqSMfHx+dOnVKAwcOtNmXYcOGqVu3blqyZIlWrFihsWPHatKkSVq9erWaNGkii8WiRYsWafPmzfrmm2+0YsUKDR48WFOmTNHmzZsLdS21Pd6P+Tl58qSSk5PzvP+LIicnRw0aNLjmdGhVq1a1eXytz+tjjz12zT94XTlFneS41+d69u7dK+n/jh0//vij7r//frVu3VofffSRwsLC5O7urjlz5uS5OeW1PPPMM5ozZ46GDRumFi1aKCAgQBaLRb1797Z5D7Zu3VpHjhzR119/re+//17/+te/NHXqVM2aNUtPPPFEoY55V3PE+xgA8kNoB4CbcN999+mTTz7Rhg0bdNddd+VZ/+OPP+rYsWN66qmnJP190yl/f3/rl9drqVmz5g23yR0ZS0pKslmeezp6UeSOVru7u99w5Ligcm8ctXfv3mt++c3dxt/fv0B1w8LC9I9//EP/+Mc/lJCQoNtvv10TJ068ZmgPDg6Wt7e3Dh48mGfdgQMH5OLikicg2dPatWt14cIFLV68WK1bt7YuP3r0qM12V75W9nr9r3bXXXepfPny+u9//6uXXnrppsP/nj179Ntvv2nevHnq37+/dfnVd+POVbNmTT3//PN6/vnndejQITVu3FhTpkyxuQt78+bN1bx5c02cOFELFixQ37599fnnn+uJJ54o3E46wPz58yXpmsGuMGrWrKlffvlF7du3L9TlL8HBwfLz81N2drZd3y+FvRQnP6mpqYqLi1PVqlWtN2/76quvVK5cOa1YscJmJHrOnDkF7suiRYs0YMAATZkyxbrsr7/+ynNclKSgoCANGjRIgwYNUmpqqlq3bq3x48friSeeuKlj3o1el5LwPgZQsnFNOwDchFGjRsnLy0tPPfWULly4YLMuMTFRTz/9tLy9vTVq1ChJkouLi7p3765vvvlG27Zty9Ne7ihXz5499csvvyguLu6a2+QGu/Xr11vXZWdnX/P02JsREhKitm3b6p///KfOnDmTZ31+U7ndSHR0tPz8/DRp0iT99ddfNuty9ykqKko1a9bUu+++az2VNr+62dnZNqe+5vY5PDw8zxRZV3J1dVV0dLS+/vprmymhzp49qwULFuiuu+6ynjbuCLnB+MrRzIyMDH300Uc2291+++2KjIzUtGnT8oQPe42Eent7a/To0dq/f79Gjx6db7ufffaZtm7dmu/z89sXwzDyTEmXlpaW5/dds2ZN+fn5WX9Xf/75Z576uWdaXO/3WdxWr16t119/XZGRkerbt6/d2u3Vq5dOnTqlTz75JM+6y5cv69KlS9d9vqurq3r27Kmvvvoq3z/2FebzKkk+Pj55PmeFcfnyZfXr10+JiYl6+eWXraHX1dVVFovF5uygY8eO5blbfm5f8gvirq6ued47H3zwQZ4zjq4+Pvv6+qpWrVrW99fNHPN8fHwk5f2DaUl5HwMo+RhpB4CbULt2bc2bN099+/ZVgwYN9PjjjysyMlLHjh3T7Nmzdf78ef33v/+1BmxJevPNN/X999+rTZs21umdzpw5o4ULF2rDhg0KDAzUqFGjtGjRIj388MMaPHiwoqKilJiYqKVLl2rWrFlq1KiR6tevr+bNm2vMmDFKTExUUFCQPv/8c2VlZdll32bMmKG77rpLDRo00JAhQ1SjRg2dPXtWmzZt0smTJ/XLL7/cVHv+/v6aOnWqnnjiCd1xxx169NFHVb58ef3yyy9KS0vTvHnz5OLion/961/q3Lmz6tevr0GDBqly5co6deqU1qxZI39/f33zzTe6ePGiqlSpooceekiNGjWSr6+vfvjhB/388882I275eeONN7Ry5Urddddd+sc//iE3Nzf985//VHp6ut5+++2ivGTasWOHzchxrpo1a6pFixZq2bKlypcvrwEDBujZZ5+VxWLR/Pnz83zRd3Fx0cyZM9WtWzc1btxYgwYNUlhYmA4cOKB9+/ZpxYoVRepnrlGjRmnfvn2aMmWK1qxZo4ceekihoaGKj4/XkiVLtHXrVv3000/5PrdOnTqqWbOmRo4cqVOnTsnf319fffVVnmuif/vtN7Vv3169evVSvXr15Obmpri4OJ09e1a9e/eWJM2bN08fffSRevTooZo1a+rixYv65JNP5O/vry5duthlX2/Wd999pwMHDigrK0tnz57V6tWrtXLlSkVERGjp0qV5bqZYFP369dOXX36pp59+WmvWrFGrVq2UnZ2tAwcO6Msvv9SKFSvyvXHlld566y2tWbNGzZo105AhQ1SvXj0lJiZqx44d+uGHH5SYmHjT/YqKitIXX3yhESNG6I477pCvr6+6det23eecOnXK+hlITU3Vr7/+qoULFyo+Pl7PP/+89awjSeratavee+89derUSY8++qgSEhI0Y8YM1apVK89lR1FRUfrhhx/03nvvKTw8XJGRkWrWrJnuu+8+zZ8/XwEBAapXr542bdqkH374QRUqVLB5fr169dS2bVtFRUUpKChI27Zts04Zmaugx7zGjRvL1dVVkydPVnJysjw9PdWuXTstWLDAdO9jAKVUsd6rHgBKid27dxt9+vQxwsLCDHd3dyM0NNTo06fPNaeXOn78uNG/f38jODjY8PT0NGrUqGHExMTYTMF04cIFIzY21qhcubLh4eFhVKlSxRgwYIDNlE5HjhwxOnToYHh6ehqVKlUyXnrpJWPlypX5TvmW3/RTN5rW7MiRI0b//v2N0NBQw93d3ahcubJx3333GYsWLbJuc60psvKbIswwDGPp0qVGy5YtDS8vL8Pf39+48847jf/+97822+zcudN48MEHjQoVKhienp5GRESE0atXL2PVqlWGYRhGenq6MWrUKKNRo0aGn5+f4ePjYzRq1Mj46KOP8t2Pq+3YscPo2LGj4evra3h7exv33HOP8dNPP93Ua5Pfttf6uXKqqo0bNxrNmzc3vLy8jPDwcOOFF14wVqxYke9rtWHDBuPee++17mPDhg2NDz74wLp+wIABho+PT57+5DcF2fUsWrTIiI6ONoKCggw3NzcjLCzMeOSRR4y1a9dat8nv9/nrr78aHTp0MHx9fY2KFSsaQ4YMMX755RdDkjFnzhzDMAzj/PnzRkxMjFGnTh3Dx8fHCAgIMJo1a2Z8+eWX1nZ27Nhh9OnTx6hWrZrh6elphISEGPfdd5+xbdu2G/b9WlO+LVy40Ga73N9Rbr+uJff9nPvj4eFhhIaGGvfee6/x/vvvW6duvFJRp3wzjL+nOps8ebJRv359w9PT0yhfvrwRFRVlvPbaa0ZycrJ1O0nXnOrw7NmzRkxMjFG1alXrcah9+/bGxx9/XKjXJzU11Xj00UeNwMBAQ9INp3+LiIiwvm4Wi8Xw9/c36tevbwwZMsTYsmVLvs+ZPXu2Ubt2bcPT09OoU6eOMWfOnHxfzwMHDhitW7c2vLy8bD5Tf/75pzFo0CCjYsWKhq+vr9GxY0fjwIEDRkREhM3n7o033jDuvPNOIzAw0PDy8jLq1KljTJw40cjIyLCpU5BjnmEYxieffGLUqFHDcHV1tX4uivI+BoCbYTEMB96BBAAAAAAAFBrXtAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKaeG9kmTJumOO+6Qn5+fQkJC1L17dx08eNBmm7Zt28pisdj8PP300zbbnDhxQl27dpW3t7dCQkI0atQou02BBAAAAACAszh1nvZ169YpJiZGd9xxh7KysvTSSy8pOjpav/76q3x8fKzbDRkyRBMmTLA+9vb2tv47OztbXbt2VWhoqH766SedOXNG/fv3l7u7u958881i3R8AAAAAAOzJVFO+nTt3TiEhIVq3bp1at24t6e+R9saNG2vatGn5Pue7777Tfffdp9OnT6tSpUqSpFmzZmn06NE6d+6cPDw8blg3JydHp0+flp+fnywWi932BwAAAACA/BiGoYsXLyo8PFwuLtc+Cd6pI+1XS05OliQFBQXZLP/Pf/6jzz77TKGhoerWrZvGjh1rHW3ftGmTGjRoYA3sktSxY0cNHTpU+/btU5MmTfLUSU9PV3p6uvXxqVOnVK9ePUfsEgAAAAAA1/THH3+oSpUq11xvmtCek5OjYcOGqVWrVrrtttusyx999FFFREQoPDxcu3fv1ujRo3Xw4EEtXrxYkhQfH28T2CVZH8fHx+dba9KkSXrttdfyLP/jjz/k7+9vr10CAAAAACBfKSkpqlq1qvz8/K67nWlCe0xMjPbu3asNGzbYLH/yySet/27QoIHCwsLUvn17HTlyRDVr1ixUrTFjxmjEiBHWx7kvlr+/P6EdAAAAAFBsbnSJtimmfIuNjdWyZcu0Zs2a654WIEnNmjWTJB0+fFiSFBoaqrNnz9psk/s4NDQ03zY8PT2tAZ2gDgAAAAAwK6eGdsMwFBsbq7i4OK1evVqRkZE3fM6uXbskSWFhYZKkFi1aaM+ePUpISLBus3LlSvn7+3OdOgAAAACgRHPq6fExMTFasGCBvv76a/n5+VmvQQ8ICJCXl5eOHDmiBQsWqEuXLqpQoYJ2796t4cOHq3Xr1mrYsKEkKTo6WvXq1VO/fv309ttvKz4+Xq+88opiYmLk6enpzN0DAAAAAKBInDrl27XO3Z8zZ44GDhyoP/74Q4899pj27t2rS5cuqWrVqurRo4deeeUVm1Pajx8/rqFDh2rt2rXy8fHRgAED9NZbb8nNrWB/k0hJSVFAQICSk5M5VR4AAAAA9PeZ0VlZWcrOznZ2V0okV1dXubm5XTP3FjSHmmqedmchtAMAAADA/8nIyNCZM2eUlpbm7K6UaN7e3goLC5OHh0eedQXNoaa5ezwAAAAAwPlycnJ09OhRubq6Kjw8XB4eHje8wzlsGYahjIwMnTt3TkePHlXt2rXl4lK4W8oR2gEAAAAAVhkZGcrJyVHVqlXl7e3t7O6UWF5eXnJ3d9fx48eVkZGhcuXKFaodU0z5BgAAAAAwl8KODOP/2OM15LcAAAAAAIBJcXo8AAAAAKBAkpOTi/XmdN7e3goICCi2emZEaAcAAAAA3FBycrKmf/ChcrKziq2mi6ubnn0m1inBvXr16ho2bJiGDRtW7LWvRGgHAAAAANxQWlqacrKztC4jUsk5hbup2s0IcPlLbTyOKi0trcChvW3btmrcuLGmTZtW5Po///yzfHx8itxOURHaAQAAAAAFlpxTTheMYgizOfZv0jAMZWdny83txlE4ODjY/h0oBG5EBwAAAAAo8QYOHKh169bp/fffl8VikcVi0dy5c2WxWPTdd98pKipKnp6e2rBhg44cOaIHHnhAlSpVkq+vr+644w798MMPNu1Vr17dZsTeYrHoX//6l3r06CFvb2/Vrl1bS5cudfh+EdoBAAAAACXe+++/rxYtWmjIkCE6c+aMzpw5o6pVq0qSXnzxRb311lvav3+/GjZsqNTUVHXp0kWrVq3Szp071alTJ3Xr1k0nTpy4bo3XXntNvXr10u7du9WlSxf17dtXiYmJDt0vQjsAAAAAoMQLCAiQh4eHvL29FRoaqtDQULm6ukqSJkyYoHvvvVc1a9ZUUFCQGjVqpKeeekq33Xabateurddff101a9a84cj5wIED1adPH9WqVUtvvvmmUlNTtXXrVofuF6EdAAAAAFCqNW3a1OZxamqqRo4cqbp16yowMFC+vr7av3//DUfaGzZsaP23j4+P/P39lZCQ4JA+5+JGdAAAAACAUu3qu8CPHDlSK1eu1LvvvqtatWrJy8tLDz30kDIyMq7bjru7u81ji8WinBwH3DHvCoR2AAAAAECp4OHhoezs7Btut3HjRg0cOFA9evSQ9PfI+7Fjxxzcu8IhtAMAAAAACizA5S+HTMeWb52bVL16dW3ZskXHjh2Tr6/vNUfBa9eurcWLF6tbt26yWCwaO3asw0fMC4vQDgAAAAC4IW9vb7m4uqmNx9Fiq+ni6iZvb+8Cbz9y5EgNGDBA9erV0+XLlzVnzpx8t3vvvfc0ePBgtWzZUhUrVtTo0aOVkpJir27blcUwDMPZnXC2lJQUBQQEKDk5Wf7+/s7uDgAAAAA4zV9//aWjR48qMjJS5cqVs1mXnJystLS0YuuLt7e3AgICiq2evV3vtSxoDmWkHQAAAABQIAEBASU6RJdETPkGAAAAAIBJEdoBAAAAADApQjsAAAAAACZFaAcAAAAAwKQI7QAAAAAAmBShHQAAAAAAkyK0AwAAAABgUszTDgAAAAAokOTkZKWlpRVbPW9v7zI/LzyhHQAAAABwQ8nJyZrx4XRlZuUUW013NxfFxD5bpoM7oR0AAAAAcENpaWnKzMpRD+N/Claiw+udU5DisrooLS2twKG9bdu2aty4saZNm2aXPgwcOFBJSUlasmSJXdorDEI7AAAAAKDAgpWoMCU4uxtlBjeiAwAAAACUeAMHDtS6dev0/vvvy2KxyGKx6NixY9q7d686d+4sX19fVapUSf369dP58+etz1u0aJEaNGggLy8vVahQQR06dNClS5c0fvx4zZs3T19//bW1vbVr1xb7fhHaAQAAAAAl3vvvv68WLVpoyJAhOnPmjM6cOSM/Pz+1a9dOTZo00bZt27R8+XKdPXtWvXr1kiSdOXNGffr00eDBg7V//36tXbtWDz74oAzD0MiRI9WrVy916tTJ2l7Lli2Lfb84PR4AAAAAUOIFBATIw8ND3t7eCg0NlSS98cYbatKkid58803rdp9++qmqVq2q3377TampqcrKytKDDz6oiIgISVKDBg2s23p5eSk9Pd3anjMQ2gEAAAAApdIvv/yiNWvWyNfXN8+6I0eOKDo6Wu3bt1eDBg3UsWNHRUdH66GHHlL58uWd0Nv8EdoBAKVaccwnyxyyAACYU2pqqrp166bJkyfnWRcWFiZXV1etXLlSP/30k77//nt98MEHevnll7VlyxZFRkY6ocd5EdoBAKVWcc0nyxyyAACYg4eHh7Kzs62Pb7/9dn311VeqXr263Nzyj78Wi0WtWrVSq1at9OqrryoiIkJxcXEaMWJEnvacgdAOACi1imM+2cLMIQsAQEl2TkGmrVO9enVt2bJFx44dk6+vr2JiYvTJJ5+oT58+euGFFxQUFKTDhw/r888/17/+9S9t27ZNq1atUnR0tEJCQrRlyxadO3dOdevWtba3YsUKHTx4UBUqVFBAQIDc3d3tvavXRWgHAJR6zCcLAEDReXt7y93NRXFZXYqtprubi7y9vQu8/ciRIzVgwADVq1dPly9f1tGjR7Vx40aNHj1a0dHRSk9PV0REhDp16iQXFxf5+/tr/fr1mjZtmlJSUhQREaEpU6aoc+fOkqQhQ4Zo7dq1atq0qVJTU7VmzRq1bdvWQXubP0I7AAAAAOCGAgICFBP7rMPvFXOlm71vzC233KJNmzblWb548eJ8t69bt66WL19+zfaCg4P1/fffF7i+IxDaAQAAAAAFEhAQwOVgxczF2R0AAAAAAAD5I7QDAAAAAGBShHYAAAAAAEyK0A4AAAAAyMMwDGd3ocSzx2tIaAcAAAAAWOXOQ16cd4kvrXJfw6LM7c7d4wEAAAAAVq6urgoMDFRCQoKkv6dds1gsTu5VyWIYhtLS0pSQkKDAwEC5uroWui1COwAAAADARmhoqCRZgzsKJzAw0PpaFhahHQAAAABgw2KxKCwsTCEhIcrMzHR2d0okd3f3Io2w5yK0AwAAAADy5erqapfgicLjRnQAAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJiUU0P7pEmTdMcdd8jPz08hISHq3r27Dh48aLPNX3/9pZiYGFWoUEG+vr7q2bOnzp49a7PNiRMn1LVrV3l7eyskJESjRo1SVlZWce4KAAAAAAB259TQvm7dOsXExGjz5s1auXKlMjMzFR0drUuXLlm3GT58uL755hstXLhQ69at0+nTp/Xggw9a12dnZ6tr167KyMjQTz/9pHnz5mnu3Ll69dVXnbFLAAAAAADYjZsziy9fvtzm8dy5cxUSEqLt27erdevWSk5O1uzZs7VgwQK1a9dOkjRnzhzVrVtXmzdvVvPmzfX999/r119/1Q8//KBKlSqpcePGev311zV69GiNHz9eHh4eztg1AAAAAACKzFTXtCcnJ0uSgoKCJEnbt29XZmamOnToYN2mTp06qlatmjZt2iRJ2rRpkxo0aKBKlSpZt+nYsaNSUlK0b9++fOukp6crJSXF5gcAAAAAALMxTWjPycnRsGHD1KpVK912222SpPj4eHl4eCgwMNBm20qVKik+Pt66zZWBPXd97rr8TJo0SQEBAdafqlWr2nlvAAAAAAAoOtOE9piYGO3du1eff/65w2uNGTNGycnJ1p8//vjD4TUBAAAAALhZTr2mPVdsbKyWLVum9evXq0qVKtbloaGhysjIUFJSks1o+9mzZxUaGmrdZuvWrTbt5d5dPnebq3l6esrT09POewEAAAAAgH05daTdMAzFxsYqLi5Oq1evVmRkpM36qKgoubu7a9WqVdZlBw8e1IkTJ9SiRQtJUosWLbRnzx4lJCRYt1m5cqX8/f1Vr1694tkRAAAAAAAcwKkj7TExMVqwYIG+/vpr+fn5Wa9BDwgIkJeXlwICAvT4449rxIgRCgoKkr+/v5555hm1aNFCzZs3lyRFR0erXr166tevn95++23Fx8frlVdeUUxMDKPpAAAAAIASzamhfebMmZKktm3b2iyfM2eOBg4cKEmaOnWqXFxc1LNnT6Wnp6tjx4766KOPrNu6urpq2bJlGjp0qFq0aCEfHx8NGDBAEyZMKK7dAAAAAADAIZwa2g3DuOE25cqV04wZMzRjxoxrbhMREaH//e9/9uwaAAAAAABOZ4ob0QEAUBolJycrLS3NYe17e3srICDAYe0DAADnI7QDAOAAycnJmvHhdGVm5Tishrubi2JinyW4AwBQihHaAQBwgLS0NGVm5aiH8T8FK9Hu7Z9TkOKyuigtLY3QDgBAKUZoBwDAgYKVqDAl3HhDAACAfDh1nnYAAAAAAHBthHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYlJuzOwAAgKOdU1CJbBsAAIDQDgAotbKysmRRjuIsXRxax6IcZWVlObQGAAAomwjtAIBSy83NTYZctD0zXKk5Hg6p4euSoSj303Jz479UAABgf3zDAACUeqeyA3TB8HFI2xWMS4pyP+2QtgEAALgRHQAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYlFND+/r169WtWzeFh4fLYrFoyZIlNusHDhwoi8Vi89OpUyebbRITE9W3b1/5+/srMDBQjz/+uFJTU4txLwAAAAAAcAynhvZLly6pUaNGmjFjxjW36dSpk86cOWP9+e9//2uzvm/fvtq3b59WrlypZcuWaf369XryyScd3XUAAAAAABzOzZnFO3furM6dO193G09PT4WGhua7bv/+/Vq+fLl+/vlnNW3aVJL0wQcfqEuXLnr33XcVHh6e7/PS09OVnp5ufZySklLIPQAAAAAAwHFMf0372rVrFRISoltvvVVDhw7VhQsXrOs2bdqkwMBAa2CXpA4dOsjFxUVbtmy5ZpuTJk1SQECA9adq1aoO3QcAAAAAAArD1KG9U6dO+ve//61Vq1Zp8uTJWrdunTp37qzs7GxJUnx8vEJCQmye4+bmpqCgIMXHx1+z3TFjxig5Odn688cffzh0PwAAAAAAKAynnh5/I71797b+u0GDBmrYsKFq1qyptWvXqn379oVu19PTU56envboIgAAAAAADmPq0H61GjVqqGLFijp8+LDat2+v0NBQJSQk2GyTlZWlxMTEa14HDwBAcTqnoBLVLgAAMJcSFdpPnjypCxcuKCwsTJLUokULJSUlafv27YqKipIkrV69Wjk5OWrWrJkzuwoAKOOysrJkUY7iLF0cVsOiHGVlZTmsfQAA4HxODe2pqak6fPiw9fHRo0e1a9cuBQUFKSgoSK+99pp69uyp0NBQHTlyRC+88IJq1aqljh07SpLq1q2rTp06aciQIZo1a5YyMzMVGxur3r17X/PO8QAAFAc3NzcZctH2zHCl5njYvX1flwxFuZ+Wm1uJ+vs7AAC4SYX6n37Hjh1yd3dXgwYNJElff/215syZo3r16mn8+PHy8CjYl5Nt27bpnnvusT4eMWKEJGnAgAGaOXOmdu/erXnz5ikpKUnh4eGKjo7W66+/bnM9+n/+8x/Fxsaqffv2cnFxUc+ePTV9+vTC7BYAAHZ3KjtAFwwfu7dbwbikKPfTdm8XAACYS6FC+1NPPaUXX3xRDRo00O+//67evXurR48eWrhwodLS0jRt2rQCtdO2bVsZhnHN9StWrLhhG0FBQVqwYEFBuw4AAAAAQIlRqCnffvvtNzVu3FiStHDhQrVu3VoLFizQ3Llz9dVXX9mzfwAAAAAAlFmFCu2GYSgnJ0eS9MMPP6hLl79vslO1alWdP3/efr0DAAAAAKAMK1Rob9q0qd544w3Nnz9f69atU9euXSX9fSO5SpUq2bWDAAAAAACUVYUK7dOmTdOOHTsUGxurl19+WbVq1ZIkLVq0SC1btrRrBwEAAAAAKKsKdSO6hg0bas+ePXmWv/POO3J1dS1ypwAAAAAAQCFH2iUpKSlJ//rXvzRmzBglJiZKkn799VclJCTYrXMAAAAAAJRlhRpp3717t9q3b6/AwEAdO3ZMQ4YMUVBQkBYvXqwTJ07o3//+t737CQAAAABAmVOokfYRI0Zo0KBBOnTokMqVK2dd3qVLF61fv95unQMAAAAAoCwrVGj/+eef9dRTT+VZXrlyZcXHxxe5UwAAAAAAoJCh3dPTUykpKXmW//bbbwoODi5ypwAAAAAAQCFD+/33368JEyYoMzNTkmSxWHTixAmNHj1aPXv2tGsHAQAAAAAoqwoV2qdMmaLU1FSFhITo8uXLatOmjWrVqiU/Pz9NnDjR3n0EAAAAAKBMKtTd4wMCArRy5Upt3LhRv/zyi1JTU3X77berQ4cO9u4fAAAAAABlVqFCe65WrVqpVatW9uoLAAAAAAC4QqFOj3/22Wc1ffr0PMs//PBDDRs2rKh9AgAAAAAAKmRo/+qrr/IdYW/ZsqUWLVpU5E4BAAAAAIBChvYLFy4oICAgz3J/f3+dP3++yJ0CAAAAAACFDO21atXS8uXL8yz/7rvvVKNGjSJ3CgAAAAAAFPJGdCNGjFBsbKzOnTundu3aSZJWrVqlKVOmaNq0afbsHwAAAAAAZVahQvvgwYOVnp6uiRMn6vXXX5ckVa9eXTNnzlT//v3t2kEAAAAAAMqqQk/5NnToUA0dOlTnzp2Tl5eXfH197dkvAAAAAADKvCLN0y5JwcHB9ugHAAAAAAC4SqFuRHf27Fn169dP4eHhcnNzk6urq80PAAAAAAAoukKNtA8cOFAnTpzQ2LFjFRYWJovFYu9+AQAAAABQ5hUqtG/YsEE//vijGjdubOfuAAAAAACAXIU6Pb5q1aoyDMPefQEAAAAAAFcoVGifNm2aXnzxRR07dszO3QEAAAAAALkKdXr8I488orS0NNWsWVPe3t5yd3e3WZ+YmGiXzgEAAAAAUJYVKrRPmzbNzt0AAAAAAABXK1RoHzBggL37AQAAAAAArlKoa9ol6ciRI3rllVfUp08fJSQkSJK+++477du3z26dAwAAAACgLCtUaF+3bp0aNGigLVu2aPHixUpNTZUk/fLLLxo3bpxdOwgAAAAAQFlVqND+4osv6o033tDKlSvl4eFhXd6uXTtt3rzZbp0DAAAAAKAsK1Ro37Nnj3r06JFneUhIiM6fP1/kTgEAAAAAgEKG9sDAQJ05cybP8p07d6py5cpF7hQAAAAAAChkaO/du7dGjx6t+Ph4WSwW5eTkaOPGjRo5cqT69+9v7z4CAAAAAFAmFSq0v/nmm6pTp46qVq2q1NRU1atXT61bt1bLli31yiuv2LuPAAAAAACUSTc9T7thGIqPj9f06dP16quvas+ePUpNTVWTJk1Uu3ZtR/QRAAAAAIAyqVChvVatWtq3b59q166tqlWrOqJfAAAAAACUeTd9eryLi4tq166tCxcuOKI/AAAAAADg/yvUNe1vvfWWRo0apb1799q7PwAAAAAA4P+76dPjJal///5KS0tTo0aN5OHhIS8vL5v1iYmJdukcAAAAAABlWaFC+7Rp0+zcDQAAAAAAcLWbDu2ZmZlat26dxo4dq8jISEf0CQAAAAAAqBDXtLu7u+urr75yRF8AAAAAAMAVCnUjuu7du2vJkiV27goAAAAAALhSoa5pr127tiZMmKCNGzcqKipKPj4+NuufffZZu3QOAAAAAICyrFChffbs2QoMDNT27du1fft2m3UWi4XQDgAAAACAHRQqtB89etTe/QAAAAAAAFcp1DXtAAAAAADA8Qo10j548ODrrv/0008L1RkAAAAAAPB/ChXa//zzT5vHmZmZ2rt3r5KSktSuXTu7dAwAAAAAgLKuUKE9Li4uz7KcnBwNHTpUNWvWLHKnAAAAAACAHa9pd3Fx0YgRIzR16lR7NQkAAAAAQJlm1xvRHTlyRFlZWfZsEgAAAACAMqtQp8ePGDHC5rFhGDpz5oy+/fZbDRgwwC4dAwAAAACgrCtUaN+5c6fNYxcXFwUHB2vKlCk3vLM8AAAAAAAomEKF9jVr1ti7HwAAAAAA4CqFuqb96NGjOnToUJ7lhw4d0rFjx4raJwAAAAAAoEKG9oEDB+qnn37Ks3zLli0aOHBgUfsEAAAAAABUyNC+c+dOtWrVKs/y5s2ba9euXUXtEwAAAAAAUCFDu8Vi0cWLF/MsT05OVnZ2dpE7BQAAAAAAChnaW7durUmTJtkE9OzsbE2aNEl33XWX3ToHAAAAAEBZVqi7x0+ePFmtW7fWrbfeqrvvvluS9OOPPyolJUWrV6+2awcBAAAAACirCjXSXq9ePe3evVu9evVSQkKCLl68qP79++vAgQO67bbb7N1HAAAAAADKpEKNtEtSeHi43nzzTXv2BQAAAAAAXKFQI+1z5szRwoUL8yxfuHCh5s2bV+ROAQAAAACAQob2SZMmqWLFinmWh4SEMPoOAAAAAICdFCq0nzhxQpGRkXmWR0RE6MSJE0XuFAAAAAAAKGRoDwkJ0e7du/Ms/+WXX1ShQoUidwoAAAAAABQytPfp00fPPvus1qxZo+zsbGVnZ2v16tV67rnn1Lt3b3v3EQAAAACAMqlQd49//fXXdezYMbVv315ubn83kZ2drQEDBnBNOwAAAAAAdlKo0O7h4aEvvvhCI0eO1LFjx+Tl5aUGDRooIiLC3v0DAAAAAKDMuunQnpSUpJdffllffPGF/vzzT0lS+fLl1bt3b73xxhsKDAy0dx8BAAAAACiTbiq0JyYmqkWLFjp16pT69u2runXrSpJ+/fVXzZ07V6tWrdJPP/2k8uXLO6SzAAAAAACUJTcV2idMmCAPDw8dOXJElSpVyrMuOjpaEyZM0NSpU+3aSQAAAAAAyqKbunv8kiVL9O677+YJ7JIUGhqqt99+W3FxcXbrHAAAAAAAZdlNhfYzZ86ofv3611x/2223KT4+vsidAgAAAAAANxnaK1asqGPHjl1z/dGjRxUUFFTUPgEAAAAAAN1kaO/YsaNefvllZWRk5FmXnp6usWPHqlOnTnbrHAAAAAAAZdlN34iuadOmql27tmJiYlSnTh0ZhqH9+/fro48+Unp6uubPn++ovgIAAAAAUKbc1Eh7lSpVtGnTJtWrV09jxoxR9+7d1aNHD7388suqV6+eNm7cqKpVqxa4vfXr16tbt24KDw+XxWLRkiVLbNYbhqFXX31VYWFh8vLyUocOHXTo0CGbbRITE9W3b1/5+/srMDBQjz/+uFJTU29mtwAAAAAAMKWbCu2SFBkZqe+++07nz5/X5s2btXnzZp07d07Lly9XrVq1bqqtS5cuqVGjRpoxY0a+699++21Nnz5ds2bN0pYtW+Tj46OOHTvqr7/+sm7Tt29f7du3TytXrtSyZcu0fv16Pfnkkze7WwAAAAAAmM5NnR5/pfLly+vOO+8sUvHOnTurc+fO+a4zDEPTpk3TK6+8ogceeECS9O9//1uVKlXSkiVL1Lt3b+3fv1/Lly/Xzz//rKZNm0qSPvjgA3Xp0kXvvvuuwsPDi9Q/AAAAAACc6aZH2ovL0aNHFR8frw4dOliXBQQEqFmzZtq0aZMkadOmTQoMDLQGdknq0KGDXFxctGXLlmu2nZ6erpSUFJsfAAAAAADMxrShPXe+90qVKtksr1SpknVdfHy8QkJCbNa7ubkpKCjouvPFT5o0SQEBAdafm7kOHwAAAACA4mLa0O5IY8aMUXJysvXnjz/+cHaXAAAAAADIw7ShPTQ0VJJ09uxZm+Vnz561rgsNDVVCQoLN+qysLCUmJlq3yY+np6f8/f1tfgAAAAAAMBvThvbIyEiFhoZq1apV1mUpKSnasmWLWrRoIUlq0aKFkpKStH37dus2q1evVk5Ojpo1a1bsfQYAAAAAwJ4Kffd4e0hNTdXhw4etj48ePapdu3YpKChI1apV07Bhw/TGG2+odu3aioyM1NixYxUeHq7u3btLkurWratOnTppyJAhmjVrljIzMxUbG6vevXtz53gAAAAAQInn1NC+bds23XPPPdbHI0aMkCQNGDBAc+fO1QsvvKBLly7pySefVFJSku666y4tX75c5cqVsz7nP//5j2JjY9W+fXu5uLioZ8+emj59erHvCwAAAAAA9ubU0N62bVsZhnHN9RaLRRMmTNCECROuuU1QUJAWLFjgiO4BAAAAAOBUpr2mHQAAAACAso7QDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJiUm7M7ANxIcnKy0tLSHNa+t7e3AgICHNY+AAAAABQWoR2mlpycrBkfTldmVo7Dari7uSgm9lmCOwAAAADTIbTD1NLS0pSZlaMexv8UrES7t39OQYrL6qK0tDRCOwAAAADTIbSjRAhWosKU4OxuAAAAAECx4kZ0AAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMCk3Z3cAAFA2JCcnKy0tzWHte3t7KyAgwGHtAwAAOAOhHQDgcMnJyZrx4XRlZuU4rIa7m4tiYp8luAMAgFKF0A4AcLi0tDRlZuWoh/E/BSvR7u2fU5DisrooLS2N0C7Hn9UgcWYDAADFhdAOACg2wUpUmBKc3Y1SrTjOapA4swEAgOJCaAcAoBRx9FkNEmc2AABQnAjtAACUQpzVAABA6cCUbwAAAAAAmBShHQAAAAAAkyK0AwAAAABgUlzTjgJh+iAAAAAAKH6EdtwQ0wcBAAAAgHMQ2nFDZpg+6JyCHFYXAAAAAMyK0I4Cc8b0QVlZWbIoR3GWLg6rYVGOsrKyHNY+AAAAABQWoR2m5ubmJkMu2p4ZrtQcD7u37+uSoSj303Jz46MAAAAAwHxIKigRTmUH6ILhY/d2KxiXFOV+2u7tAgAAAIA9MOUbAAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAm5ebsDgAAyo5zCipR7QIAADibqUP7+PHj9dprr9ksu/XWW3XgwAFJ0l9//aXnn39en3/+udLT09WxY0d99NFHqlSpkjO6CwC4hqysLFmUozhLF4fVsChHWVlZDmsfAADAGUwd2iWpfv36+uGHH6yP3dz+r8vDhw/Xt99+q4ULFyogIECxsbF68MEHtXHjRmd0FQBwDW5ubjLkou2Z4UrN8bB7+74uGYpyP23zfwQAAEBpYPpvN25ubgoNDc2zPDk5WbNnz9aCBQvUrl07SdKcOXNUt25dbd68Wc2bNy/urgIAbuBUdoAuGD52b7eCcUlR7qft3i4AAICzmf5GdIcOHVJ4eLhq1Kihvn376sSJE5Kk7du3KzMzUx06dLBuW6dOHVWrVk2bNm26bpvp6elKSUmx+QEAAAAAwGxMHdqbNWumuXPnavny5Zo5c6aOHj2qu+++WxcvXlR8fLw8PDwUGBho85xKlSopPj7+uu1OmjRJAQEB1p+qVas6cC8AAAAAACgcU58e37lzZ+u/GzZsqGbNmikiIkJffvmlvLy8Ct3umDFjNGLECOvjlJQUgjsAAAAAwHRMHdqvFhgYqFtuuUWHDx/Wvffeq4yMDCUlJdmMtp89ezbfa+Cv5OnpKU9PTwf3tvRx5JRKTNcEAAAAAHmVqNCempqqI0eOqF+/foqKipK7u7tWrVqlnj17SpIOHjyoEydOqEWLFk7uaelSHFM1SUzXBAAAAABXM3VoHzlypLp166aIiAidPn1a48aNk6urq/r06aOAgAA9/vjjGjFihIKCguTv769nnnlGLVq04M7xduboqZokpmsCAAAAgPyYOiGdPHlSffr00YULFxQcHKy77rpLmzdvVnBwsCRp6tSpcnFxUc+ePZWenq6OHTvqo48+cnKvSy9HTdUkMV0TAAAAAOTH1KH9888/v+76cuXKacaMGZoxY0Yx9QgAAAAAgOJj6infAAAAAAAoywjtAAAAAACYFKEdAAAAAACTMvU17QAAoHDOKahEtg0AAGwR2gEAKEWysrJkUY7iLF0cWseiHGVlZTm0BgAAILQDAFCquLm5yZCLtmeGKzXHwyE1fF0yFOV+Wm5ufI0AAMDR+N8WAIBS6FR2gC4YPg5pu4JxSVHupx3SNgAAsMWN6AAAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMCk3Z3cAQF7JyclKS0tzWPve3t4KCAhwWPsAAAAA7IPQDphMcnKyZnw4XZlZOQ6r4e7mopjYZwnuAAAAgMkR2gGTSUtLU2ZWjnoY/1OwEu3e/jkFKS6ri9LS0gjtAAAAgMkR2gGTClaiwpTg7G4AAAAAcCJuRAcAAAAAgEkR2gEAAAAAMClCOwAAAAAAJkVoBwAAAADApAjtAAAAAACYFKEdAAAAAACTIrQDAAAAAGBShHYAAAAAAEyK0A4AAAAAgEkR2gEAAAAAMCk3Z3cAQP7OKahEtQsAAADA/gjtgMlkZWXJohzFWbo4rIZFOcrKynJY+wAAAADsg9AOmIybm5sMuWh7ZrhSczzs3r6vS4ai3E/LzY2PPwAAyF9ycrLS0tIc1r63t7cCAgIc1j5QmvCtHTCpU9kBumD42L3dCsYlRbmftnu7AACgdEhOTtaMD6crMyvHYTXc3VwUE/sswR0oAEI7AAAAAKu0tDRlZuWoh/E/BSvR7u2fU5DisrooLS0tT2h39Ai/xCg/Sh5COwAAAIA8gpWoMCUUW73iGOGXGOVHyUNoBwAAAOB0jh7hl64/yg+YFaEdAAAAgGkU9wg/YHYuzu4AAAAAAADIH6EdAAAAAACT4vR4AAAAAHmcU1CJahcorQjtwDU4esoRphsBUBpx7ATsyxmfqaysLFmUozhLF4fVtShHWVlZDmsfKE0I7UA+imPKEaYbAVDacOwE7MtZnyk3NzcZctH2zHCl5njYvaavS4ai3E/LzY0oAhQEnxQgH46ecoTpRgCURhw7Afty9mfqVHaALhg+dq9bwbikKPfTdm8XKK0I7cB1MOUIANw8jp2AffGZAso27h4PAAAAAIBJEdoBAAAAADApTo8HAAAAYBqOnBKO6eZQEhHaAQAAADhdcUw1JzHdHEoeQjsAAAAAp3P0VHPS9aebS05OVlpamkPqSpK3t3e+d+l3dN3r1UbJQGgHAAAAYBqOmmpOuvZ0c8nJyZrx4XRlZuU4pK4kubu5KCb2WZvwXBx1r1UbJQehHQAAAECZlpaWpsysHPUw/qdgJdq9/XMKUlxWF6WlpdkEZ0fXvV5tlByEdgAAYFeOutETN5Cy5axTeYHSLFiJClNCmanLcaRkILQDAAC7KI6bSHEDqb8561ReAKUHx5GSg9BewvDXMABFxXEEjuLom0iZ8QZSzuKsU3nLqrL2/kLZwHGk5CC0lyD8NQxAUXEcQXFw1E2kzHYDKTNw1im1ZUlZfn+hbOA4Yn6E9hKEv4YVP67LRGmTexy529isQKXYvf0k+evHrOYcR1CsnP3/I6OwpZuz31+52zgC30fMw5G/C37PJR+hvQTir2GOx3WZKK1y39s/Wpo7rAbvbTiLM/5/ZBS27HDG+4vvI6VfcfyOJX7PJR2hHciHM6/LLIscPUolMVKVi/c2YF/OHoVlBLb4OOO15phd+jn6dyzxey4N+M0B11Hc12WWRcUxSiUxUnU13tuAfRX3KCwjsMXHDK81x+zSz1G/Y4nfc2lAaAfgVI6+xlriOmsAjlfco7BldQTWGfcPKKuvNQDz4OgAwKmK4xpriREjAI7h7FHYsjQC6+z7B5Sl1xqAuRDaAViVxhEMibmdgbKCa45LN2ffPwBlA/eJgBnxP0AJxMEEjlBaRzAk5nYGSjtnj3ZLjMIWJ2bRgSOY4TjiLM7IFgya3BxCewlSlg8mcLyyOIJRFvcZKI0Y7QZQVGXxOOKsbMGgyc0zz7sGN1QWDyYofmVxBKMs7jNQGjHaXTyYphOlWVk6jjgrWzj6JsSl8QbEpLMSqCwdTAAAgHkwTSdQ+hR3tiiOmxCXtrOHCe0AAAAoEEdfViRxaRFQ2nH28M0rPXsCAACAYsFlRQCKirOHC47QDqDMY0YGACg5OGYDKGsI7QDKLGZkAICSg2M2gLKK0A6gzOKaKgAoHEeOSl+rbY7ZAMoqjkoAyjyuqQKAgimO0W7p+iPeHLMBlDWEdgA2uFYQAHAtjh7tlhjxBoCrcTQEIIlrBQEABeeo0W6JEW8AuBqhHYAkrhUsbsnJyUpLS3NoDW9vb+Y4BgAAKOH49gzABtcKOl5ycrI+/GC6srJzHFrHzdVFsc88S3AHAAAowVyc3QEAKGtSUlKUne34ywSys7OUkpLi8DoAAABwHEbaAaCYcSMnAAAAFBTf5gDASbiREwAAAG6E0+MBAAAAADCpUhPaZ8yYoerVq6tcuXJq1qyZtm7d6uwuAQAAAABQJKUitH/xxRcaMWKExo0bpx07dqhRo0bq2LGjEhISnN01AAAAAAAKrVSE9vfee09DhgzRoEGDVK9ePc2aNUve3t769NNPnd01AAAAAAAKrcTfiC4jI0Pbt2/XmDFjrMtcXFzUoUMHbdq0Kd/npKenKz093fo4OTlZkkw/NdLFixf1119/ySfzT2XnpNm9fR+XdP2lv3Tx4kX5+PzfzbEcXdeZtc1W15m1S2tdZ9Zmn0t/XWfWZp+dX9eZtUtrXWfWNltdZ9YurXWdWZt9dn5dM8rNn4ZhXHc7i3GjLUzu9OnTqly5sn766Se1aNHCuvyFF17QunXrtGXLljzPGT9+vF577bXi7CYAAAAAAHn88ccfqlKlyjXXl/iR9sIYM2aMRowYYX2ck5OjxMREVahQQRaLxYk9s6+UlBRVrVpVf/zxh/z9/ctE7bJW15m12efSX9eZtdnn0l/XmbXZZ/a5NNZ1Zm32ufTXdWZtZ+6zoxmGoYsXLyo8PPy625X40F6xYkW5urrq7NmzNsvPnj2r0NDQfJ/j6ekpT09Pm2WBgYGO6qLT+fv7O+0N7qzaZa2uM2uzz6W/rjNrs8+lv64za7PPZaN2WavrzNrsc+mv68zaztxnRwoICLjhNiX+RnQeHh6KiorSqlWrrMtycnK0atUqm9PlAQAAAAAoaUr8SLskjRgxQgMGDFDTpk115513atq0abp06ZIGDRrk7K4BAAAAAFBopSK0P/LIIzp37pxeffVVxcfHq3Hjxlq+fLkqVark7K45laenp8aNG5fnUoDSXLus1XVmbfa59Nd1Zm32ufTXdWZt9rl4lbV95rUuXmVtn3mty6YSf/d4AAAAAABKqxJ/TTsAAAAAAKUVoR0AAAAAAJMitAMAAAAAYFKEdgAAAAAATIrQXorNmDFD1atXV7ly5dSsWTNt3brV4TXXr1+vbt26KTw8XBaLRUuWLHF4TUmaNGmS7rjjDvn5+SkkJETdu3fXwYMHHV535syZatiwofz9/eXv768WLVrou+++c3jdq7311luyWCwaNmyYw2uNHz9eFovF5qdOnToOrytJp06d0mOPPaYKFSrIy8tLDRo00LZt2xxet3r16nn22WKxKCYmxqF1s7OzNXbsWEVGRsrLy0s1a9bU66+/ruK4f+jFixc1bNgwRUREyMvLSy1bttTPP/9s9zo3OmYYhqFXX31VYWFh8vLyUocOHXTo0CGH1128eLGio6NVoUIFWSwW7dq1q8g1C1I7MzNTo0ePVoMGDeTj46Pw8HD1799fp0+fdmhd6e/Pdp06deTj46Py5curQ4cO2rJlS5HrFqT2lZ5++mlZLBZNmzbN4XUHDhyY53PdqVMnh9eVpP379+v+++9XQECAfHx8dMcdd+jEiRMOr53fscxiseidd95xaN3U1FTFxsaqSpUq8vLyUr169TRr1qwi1Sxo7bNnz2rgwIEKDw+Xt7e3OnXqZJfjSEG+e/z111+KiYlRhQoV5Ovrq549e+rs2bMOr/vxxx+rbdu28vf3l8ViUVJSUpFqFqRuYmKinnnmGd16663y8vJStWrV9Oyzzyo5OdnhtSXpqaeeUs2aNeXl5aXg4GA98MADOnDggMPr5jIMQ507d7bb99+C1G7btm2ez/LTTz/t8LqStGnTJrVr104+Pj7y9/dX69atdfnyZYfVPXbs2DWPXwsXLix03ZKC0F5KffHFFxoxYoTGjRunHTt2qFGjRurYsaMSEhIcWvfSpUtq1KiRZsyY4dA6V1u3bp1iYmK0efNmrVy5UpmZmYqOjtalS5ccWrdKlSp66623tH37dm3btk3t2rXTAw88oH379jm07pV+/vln/fOf/1TDhg2LrWb9+vV15swZ68+GDRscXvPPP/9Uq1at5O7uru+++06//vqrpkyZovLlyzu89s8//2yzvytXrpQkPfzwww6tO3nyZM2cOVMffvih9u/fr8mTJ+vtt9/WBx984NC6kvTEE09o5cqVmj9/vvbs2aPo6Gh16NBBp06dsmudGx0z3n77bU2fPl2zZs3Sli1b5OPjo44dO+qvv/5yaN1Lly7prrvu0uTJk4tU52Zrp6WlaceOHRo7dqx27NihxYsX6+DBg7r//vsdWleSbrnlFn344Yfas2ePNmzYoOrVqys6Olrnzp1zeO1ccXFx2rx5s8LDw4tcs6B1O3XqZPP5/u9//+vwukeOHNFdd92lOnXqaO3atdq9e7fGjh2rcuXKObz2lft65swZffrpp7JYLOrZs6dD644YMULLly/XZ599pv3792vYsGGKjY3V0qVLi1T3RrUNw1D37t31+++/6+uvv9bOnTsVERGhDh06FPk7QkG+ewwfPlzffPONFi5cqHXr1un06dN68MEHHV43LS1NnTp10ksvvVSkWjdT9/Tp0zp9+rTeffdd7d27V3PnztXy5cv1+OOPO7y2JEVFRWnOnDnav3+/VqxYIcMwFB0drezsbIfWzTVt2jRZLJZC1yps7SFDhth8pt9++22H1920aZM6deqk6Ohobd26VT///LNiY2Pl4lL4aHmjulWrVs1z/Hrttdfk6+urzp07F2mfSwQDpdKdd95pxMTEWB9nZ2cb4eHhxqRJk4qtD5KMuLi4Yqt3pYSEBEOSsW7dumKvXb58eeNf//pXsdS6ePGiUbt2bWPlypVGmzZtjOeee87hNceNG2c0atTI4XWuNnr0aOOuu+4q9rr5ee6554yaNWsaOTk5Dq3TtWtXY/DgwTbLHnzwQaNv374OrZuWlma4uroay5Yts1l+++23Gy+//LLD6l59zMjJyTFCQ0ONd955x7osKSnJ8PT0NP773/86rO6Vjh49akgydu7cabd6Ba2da+vWrYYk4/jx48VaNzk52ZBk/PDDD3are73aJ0+eNCpXrmzs3bvXiIiIMKZOnerwugMGDDAeeOABu9YpSN1HHnnEeOyxxxxa91q1r/bAAw8Y7dq1c3jd+vXrGxMmTLBZ5ohjytW1Dx48aEgy9u7da12WnZ1tBAcHG5988olda1/93SMpKclwd3c3Fi5caN1m//79hiRj06ZNDqt7pTVr1hiSjD///NNu9QpSN9eXX35peHh4GJmZmcVe+5dffjEkGYcPH3Z43Z07dxqVK1c2zpw547Dvv/nVLo7vfvnVbdasmfHKK68Ue92rNW7cOM/3pNKKkfZSKCMjQ9u3b1eHDh2sy1xcXNShQwdt2rTJiT0rPrmnYgUFBRVbzezsbH3++ee6dOmSWrRoUSw1Y2Ji1LVrV5vfdXE4dOiQwsPDVaNGDfXt29cup3TeyNKlS9W0aVM9/PDDCgkJUZMmTfTJJ584vO7VMjIy9Nlnn2nw4MF2/Yt6flq2bKlVq1bpt99+kyT98ssv2rBhg8P/opyVlaXs7Ow8o35eXl7FclZFrqNHjyo+Pt7m/R0QEKBmzZqVmWOZ9PfxzGKxKDAwsNhqZmRk6OOPP1ZAQIAaNWrk8Ho5OTnq16+fRo0apfr16zu83pXWrl2rkJAQ3XrrrRo6dKguXLjg0Ho5OTn69ttvdcstt6hjx44KCQlRs2bNiu1ysiudPXtW3377rV1GQm+kZcuWWrp0qU6dOiXDMLRmzRr99ttvio6Odmjd9PR0SbI5nrm4uMjT09Pux7Orv3ts375dmZmZNsewOnXqqFq1anY9hjnjO09B6yYnJ8vf319ubm7FWvvSpUuaM2eOIiMjVbVqVYfWTUtL06OPPqoZM2YoNDTUbrUKUluS/vOf/6hixYq67bbbNGbMGKWlpTm0bkJCgrZs2aKQkBC1bNlSlSpVUps2bRz+ebra9u3btWvXrmI5fpkBob0UOn/+vLKzs1WpUiWb5ZUqVVJ8fLyTelV8cnJyNGzYMLVq1Uq33Xabw+vt2bNHvr6+8vT01NNPP624uDjVq1fP4XU///xz7dixQ5MmTXJ4rSs1a9bMesrbzJkzdfToUd199926ePGiQ+v+/vvvmjlzpmrXrq0VK1Zo6NChevbZZzVv3jyH1r3akiVLlJSUpIEDBzq81osvvqjevXurTp06cnd3V5MmTTRs2DD17dvXoXX9/PzUokULvf766zp9+rSys7P12WefadOmTTpz5oxDa18p93hVVo9l0t/Xw44ePVp9+vSRv7+/w+stW7ZMvr6+KleunKZOnaqVK1eqYsWKDq87efJkubm56dlnn3V4rSt16tRJ//73v7Vq1SpNnjxZ69atU+fOnYt0Ou2NJCQkKDU1VW+99ZY6deqk77//Xj169NCDDz6odevWOaxufubNmyc/P78in65dEB988IHq1aunKlWqyMPDQ506ddKMGTPUunVrh9bNDcljxozRn3/+qYyMDE2ePFknT5606/Esv+8e8fHx8vDwyPMHN3sew4r7O8/N1D1//rxef/11Pfnkk8VW+6OPPpKvr698fX313XffaeXKlfLw8HBo3eHDh6tly5Z64IEH7FLnZmo/+uij+uyzz7RmzRqNGTNG8+fP12OPPebQur///rukv++DMmTIEC1fvly333672rdvb5d7RVyr7tVmz56tunXrqmXLlnapaXb2/bMXYAIxMTHau3dvsY0I3nrrrdq1a5eSk5O1aNEiDRgwQOvWrXNocP/jjz/03HPPaeXKlXa5BvJmXDnK27BhQzVr1kwRERH68ssvHfrXzpycHDVt2lRvvvmmJKlJkybau3evZs2apQEDBjis7tVmz56tzp072+2a2+v58ssv9Z///EcLFixQ/fr1tWvXLg0bNkzh4eEO3+f58+dr8ODBqly5slxdXXX77berT58+2r59u0Pr4v9kZmaqV69eMgxDM2fOLJaa99xzj3bt2qXz58/rk08+Ua9evawjKo6yfft2vf/++9qxY4fDz165Wu/eva3/btCggRo2bKiaNWtq7dq1at++vUNq5uTkSJIeeOABDR8+XJLUuHFj/fTTT5o1a5batGnjkLr5+fTTT9W3b99i+X/kgw8+0ObNm7V06VJFRERo/fr1iomJUXh4uEPPFnN3d9fixYv1+OOPKygoSK6ururQoYM6d+5s15t6Fvd3D7PXTUlJUdeuXVWvXj2NHz++2Gr37dtX9957r86cOaN3331XvXr10saNG+3yHs+v7tKlS7V69Wrt3LmzyO3fbG1JNn8QadCggcLCwtS+fXsdOXJENWvWdEjd3GPYU089pUGDBkn6+zvZqlWr9Omnn9plMOlG76/Lly9rwYIFGjt2bJFrlRSMtJdCFStWlKura567k549e9ahp+2YQWxsrJYtW6Y1a9aoSpUqxVLTw8NDtWrVUlRUlCZNmqRGjRrp/fffd2jN7du3KyEhQbfffrvc3Nzk5uamdevWafr06XJzc3PoKNHVAgMDdcstt+jw4cMOrRMWFpbnDyF169YtllPzcx0/flw//PCDnnjiiWKpN2rUKOtoe4MGDdSvXz8NHz68WM6uqFmzptatW6fU1FT98ccf2rp1qzIzM1WjRg2H186Ve7wqi8ey3MB+/PhxrVy5slhG2SXJx8dHtWrVUvPmzTV79my5ublp9uzZDq35448/KiEhQdWqVbMez44fP67nn39e1atXd2jtq9WoUUMVK1Z06PGsYsWKcnNzc/rx7Mcff9TBgweL5Xh2+fJlvfTSS3rvvffUrVs3NWzYULGxsXrkkUf07rvvOrx+VFSUdu3apaSkJJ05c0bLly/XhQsX7HY8u9Z3j9DQUGVkZOS5c7u9jmHO+M5TkLoXL15Up06d5Ofnp7i4OLm7uxdb7YCAANWuXVutW7fWokWLdODAAcXFxTms7urVq3XkyBEFBgZaj1+S1LNnT7Vt27bIda9XOz/NmjWTJLscw65VNywsTJIcdgwryP4uWrRIaWlp6t+/f5HrlRSE9lLIw8NDUVFRWrVqlXVZTk6OVq1aVWzXWhc3wzAUGxuruLg4rV69WpGRkU7rS05OjvUaOkdp37699uzZo127dll/mjZtqr59+2rXrl1ydXV1aP0rpaam6siRI9aDuKO0atUqz5Qjv/32myIiIhxa90pz5sxRSEiIunbtWiz10tLS8tyJ1dXV1fpX7uLg4+OjsLAw/fnnn1qxYoVDT/+7WmRkpEJDQ22OZSkpKdqyZUupPZZJ/xfYDx06pB9++EEVKlRwWl+K43jWr18/7d692+Z4Fh4erlGjRmnFihUOrX21kydP6sKFCw49nnl4eOiOO+5w+vFs9uzZioqKKpZ7FmRmZiozM9Ppx7OAgAAFBwfr0KFD2rZtW5GPZzf67hEVFSV3d3ebY9jBgwd14sSJIh3DnPWdpyB1U1JSFB0dLQ8PDy1dutRuZ3EUZp8Nw5BhGEU6ht2o7osvvpjn+CVJU6dO1Zw5cwpdtyC185NbvyjHsBvVrV69usLDw+1+DLuZ/Z09e7buv/9+BQcHF7peScPp8aXUiBEjNGDAADVt2lR33nmnpk2bpkuXLllPY3GU1NRUm7/uHT16VLt27VJQUJCqVavmsLoxMTFasGCBvv76a/n5+VmvFQsICJCXl5fD6o4ZM0adO3dWtWrVdPHiRS1YsEBr1651+BdNPz+/PNf4+Pj4qEKFCg6/pm3kyJHq1q2bIiIidPr0aY0bN06urq7q06ePQ+vmXjP25ptvqlevXtq6das+/vhjffzxxw6tmysnJ0dz5szRgAED7H5DnWvp1q2bJk6cqGrVqql+/frauXOn3nvvPQ0ePNjhtXOny7n11lt1+PBhjRo1SnXq1LH7MeRGx4xhw4bpjTfeUO3atRUZGamxY8cqPDxc3bt3d2jdxMREnThxwjo/eu6Xk9DQ0CKPkF2vdlhYmB566CHt2LFDy5YtU3Z2tvV4FhQUVKRrM69Xt0KFCpo4caLuv/9+hYWF6fz585oxY4ZOnTpll6kNb/R6X/2HCXd3d4WGhurWW291WN2goCC99tpr6tmzp0JDQ3XkyBG98MILqlWrljp27OiwutWqVdOoUaP0yCOPqHXr1rrnnnu0fPlyffPNN1q7dm2R6haktvR3sFq4cKGmTJlS5HoFrdumTRuNGjVKXl5eioiI0Lp16/Tvf/9b7733nsNrL1y4UMHBwapWrZr27Nmj5557Tt27dy/yTfBu9N0jICBAjz/+uEaMGKGgoCD5+/vrmWeeUYsWLdS8eXOH1ZX+vp4+Pj7e+rrs2bNHfn5+qlatWqFvWHejurmBPS0tTZ999plSUlKUkpIiSQoODi7SgMKNav/+++/64osvFB0dreDgYJ08eVJvvfWWvLy81KVLF4fVvdb/CdWqVSvyH1NuVPvIkSNasGCBunTpogoVKmj37t0aPny4WrduXaRpgG9U12KxaNSoURo3bpwaNWqkxo0ba968eTpw4IAWLVrksLq5Dh8+rPXr1+t///tfoWuVSE64Yz2KyQcffGBUq1bN8PDwMO68805j8+bNDq+ZO7XI1T8DBgxwaN38akoy5syZ49C6gwcPNiIiIgwPDw8jODjYaN++vfH99987tOa1FNeUb4888ogRFhZmeHh4GJUrVzYeeeQRu06ncj3ffPONcdtttxmenp5GnTp1jI8//rhY6hqGYaxYscKQZBw8eLDYaqakpBjPPfecUa1aNaNcuXJGjRo1jJdfftlIT093eO0vvvjCqFGjhuHh4WGEhoYaMTExRlJSkt3r3OiYkZOTY4wdO9aoVKmS4enpabRv394uv4Mb1Z0zZ06+68eNG+fQ2rlTzOX3s2bNGofVvXz5stGjRw8jPDzc8PDwMMLCwoz777/f2Lp1a5H390a182OvKd+uVzctLc2Ijo42goODDXd3dyMiIsIYMmSIER8f79C6uWbPnm3UqlXLKFeunNGoUSNjyZIlRa5b0Nr//Oc/DS8vL7t+pm9U98yZM8bAgQON8PBwo1y5csatt95qTJkyxS5TZ96o9vvvv29UqVLFcHd3N6pVq2a88sordjmOFuS7x+XLl41//OMfRvny5Q1vb2+jR48expkzZxxed9y4cXb/XnSjutf6PUgyjh496tB9PnXqlNG5c2cjJCTEcHd3N6pUqWI8+uijxoEDBxxa91rPsceUbzeqfeLECaN169ZGUFCQ4enpadSqVcsYNWqUkZyc7NC6uSZNmmRUqVLF8Pb2Nlq0aGH8+OOPxVJ3zJgxRtWqVY3s7Owi1StpLIZhx7twAAAAAAAAu+GadgAAAAAATIrQDgAAAACASRHaAQAAAAAwKUI7AAAAAAAmRWgHAAAAAMCkCO0AAAAAAJgUoR0AAAAAAJMitAMAAAAAYFKEdgAAcF0Wi0VLlixxdjcAACiTCO0AAJRx8fHxeuaZZ1SjRg15enqqatWq6tatm1atWuXsrgEAUOa5ObsDAADAeY4dO6ZWrVopMDBQ77zzjho0aKDMzEytWLFCMTExOnDggLO7CABAmcZIOwAAZdg//vEPWSwWbd26VT179tQtt9yi+vXra8SIEdq8eXO+zxk9erRuueUWeXt7q0aNGho7dqwyMzOt63/55Rfdc8898vPzk7+/v6KiorRt2zZJ0vHjx9WtWzeVL19ePj4+ql+/vv73v/8Vy74CAFASMdIOAEAZlZiYqOXLl2vixIny8fHJsz4wMDDf5/n5+Wnu3LkKDw/Xnj17NGTIEPn5+emFF16QJPXt21dNmjTRzJkz5erqql27dsnd3V2SFBMTo4yMDK1fv14+Pj769ddf5evr67B9BACgpCO0AwBQRh0+fFiGYahOnTo39bxXXnnF+u/q1atr5MiR+vzzz62h/cSJExo1apS13dq1a1u3P3HihHr27KkGDRpIkmrUqFHU3QAAoFTj9HgAAMoowzAK9bwvvvhCrVq1UmhoqHx9ffXKK6/oxIkT1vUjRozQE088oQ4dOuitt97SkSNHrOueffZZvfHGG2rVqpXGjRun3bt3F3k/AAAozQjtAACUUbVr15bFYrmpm81t2rRJffv2VZcuXbRs2TLt3LlTL7/8sjIyMqzbjB8/Xvv27VPXrl21evVq1atXT3FxcZKkJ554Qr///rv69eunPXv2qGnTpvrggw/svm8AAJQWFqOwf2YHAAAlXufOnbVnzx4dPHgwz3XtSUlJCgwMlMViUVxcnLp3764pU6boo48+shk9f+KJJ7Ro0SIlJSXlW6NPnz66dOmSli5dmmfdmDFj9O233zLiDgDANTDSDgBAGTZjxgxlZ2frzjvv1FdffaVDhw5p//79mj59ulq0aJFn+9q1a+vEiRP6/PPPdeTIEU2fPt06ii5Jly9fVmxsrNauXavjx49r48aN+vnnn1W3bl1J0rBhw7RixQodPXpUO3bs0Jo1a6zrAABAXtyIDgCAMqxGjRrasWOHJk6cqOeff15nzpxRcHCwoqKiNHPmzDzb33///Ro+fLhiY2OVnp6url27auzYsRo/frwkydXVVRcuXFD//v119uxZVaxYUQ8++KBee+01SVJ2drZiYmJ08uRJ+fv7q1OnTpo6dWpx7jIAACUKp8cDAAAAAGBSnB4PAAAAAIBJEdoBAAAAADApQjsAAAAAACZFaAcAAAAAwKQI7QAAAAAAmBShHQAAAAAAkyK0AwAAAABgUoR2AAAAAABMitAOAAAAAIBJEdoBAAAAADApQjsAAAAAACb1/wBhVu4ri4XmhgAAAABJRU5ErkJggg=="},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x600 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"class NUDataset(torch.utils.data.Dataset):\n  def __init__(self, df, img_paths, mask_paths, transform_X=None,transform_Y = None):\n    self.X = [\n            os.path.join(img_paths[dataset], filename) \n            for filename, dataset in zip(df['filename'], df['dataset'])\n        ]\n    self.Y = [\n            os.path.join(mask_paths[dataset], mask_filename) \n            for mask_filename, dataset in zip(df['mask_filename'], df['dataset'])\n        ]\n    self.dataset = df['dataset'].tolist()\n    self.transform_X = transform_X\n    self.transform_Y = transform_Y\n\n  def __len__(self):\n      return len(self.X)\n\n  def __getitem__(self,idx):\n    X_path = self.X[idx]\n    Y_path = self.Y[idx]\n    \n    image_name = os.path.basename(X_path)\n\n    X = Image.open(X_path).convert(\"L\")\n    Y = Image.open(Y_path).convert(\"L\")\n\n    if self.transform_X is not None:\n        X = self.transform_X(X)\n\n    if self.transform_Y is not None:\n        Y = self.transform_Y(Y)\n        \n    # Extract dataset type\n    Dataset_type = self.dataset[idx]\n\n    return X, Y, Dataset_type, image_name","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:55.004237Z","iopub.execute_input":"2024-08-14T09:17:55.004496Z","iopub.status.idle":"2024-08-14T09:17:55.014036Z","shell.execute_reply.started":"2024-08-14T09:17:55.004473Z","shell.execute_reply":"2024-08-14T09:17:55.013180Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"img_size = 512\n\ntrain_img_path='/kaggle/input/fetalhcdata/training_set/training_set'\ntest_img_path='/kaggle/input/fetalhcdata/test_set/test_set'\ngan_img_path='/kaggle/input/fetalhcdata/gan_set/gan_images'\ngan_new_img_path='/kaggle/input/fetalhcdata/gan_set/gan_images'\n\ntrain_mask_path='/kaggle/input/fetalhcdata/training_set/images_mask'\ntest_mask_path='/kaggle/input/fetalhcdata/test_set/test_masks'\ngan_mask_path='/kaggle/input/fetalhcdata/gan_set/gan_masks'\ngan_new_mask_path='/kaggle/input/fetalhcdata/gan_set/gan_masks'\n\ntransform_X = transforms.Compose([\n    transforms.Resize((img_size, img_size)),\n    transforms.ToTensor(),\n    transforms.Normalize((0.5,), (0.5,))\n])\n\ntransform_Y = transforms.Compose([\n    transforms.Resize((img_size, img_size)),\n    transforms.ToTensor()\n])\n\nimg_paths = {\n    'train': train_img_path\n}\n\nmask_paths = {\n    'train': train_mask_path\n}\n\nif include_test_set:\n    img_paths['test'] = test_img_path\n    mask_paths['test'] = test_mask_path\n    \nif include_gan_set:\n    img_paths['gan'] = gan_img_path\n    mask_paths['gan'] = gan_mask_path\n\nunet_dataset = NUDataset(balanced_df, img_paths, mask_paths, transform_X, transform_Y)\nunet_val = NUDataset(val_df, img_paths, mask_paths, transform_X, transform_Y)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:55.015238Z","iopub.execute_input":"2024-08-14T09:17:55.015566Z","iopub.status.idle":"2024-08-14T09:17:55.038055Z","shell.execute_reply.started":"2024-08-14T09:17:55.015536Z","shell.execute_reply":"2024-08-14T09:17:55.037144Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"print(len(unet_dataset))\nprint(len(unet_val))","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:55.039281Z","iopub.execute_input":"2024-08-14T09:17:55.039566Z","iopub.status.idle":"2024-08-14T09:17:55.053586Z","shell.execute_reply.started":"2024-08-14T09:17:55.039542Z","shell.execute_reply":"2024-08-14T09:17:55.052632Z"},"trusted":true},"execution_count":13,"outputs":[{"name":"stdout","text":"1081\n187\n","output_type":"stream"}]},{"cell_type":"code","source":"class double_conv(nn.Module):\n    def __init__(self, in_ch, out_ch):\n        super(double_conv, self).__init__()\n        self.conv = nn.Sequential(\n            nn.Conv2d(in_ch, out_ch, 3, padding=1),\n            nn.BatchNorm2d(out_ch),\n            nn.ReLU(inplace=True),\n            nn.Conv2d(out_ch, out_ch, 3, padding=1),\n            nn.BatchNorm2d(out_ch),\n            nn.ReLU(inplace=True)\n        )\n\n    def forward(self, x):\n        x = self.conv(x)\n        return x\n\n\nclass NestedUNet(nn.Module):\n    def __init__(self, n_channels, n_classes, deep_supervision=False):\n        super(NestedUNet, self).__init__()\n        self.deep_supervision = deep_supervision\n        nb_filter = [32, 64, 128, 256, 512]\n\n        self.conv0_0 = double_conv(n_channels, nb_filter[0])\n        self.conv1_0 = double_conv(nb_filter[0], nb_filter[1])\n        self.conv2_0 = double_conv(nb_filter[1], nb_filter[2])\n        self.conv3_0 = double_conv(nb_filter[2], nb_filter[3])\n        self.conv4_0 = double_conv(nb_filter[3], nb_filter[4])\n\n        self.conv0_1 = double_conv(nb_filter[0]+nb_filter[1], nb_filter[0])\n        self.conv1_1 = double_conv(nb_filter[1]+nb_filter[2], nb_filter[1])\n        self.conv2_1 = double_conv(nb_filter[2]+nb_filter[3], nb_filter[2])\n        self.conv3_1 = double_conv(nb_filter[3]+nb_filter[4], nb_filter[3])\n\n        self.conv0_2 = double_conv(nb_filter[0]*2+nb_filter[1], nb_filter[0])\n        self.conv1_2 = double_conv(nb_filter[1]*2+nb_filter[2], nb_filter[1])\n        self.conv2_2 = double_conv(nb_filter[2]*2+nb_filter[3], nb_filter[2])\n\n        self.conv0_3 = double_conv(nb_filter[0]*3+nb_filter[1], nb_filter[0])\n        self.conv1_3 = double_conv(nb_filter[1]*3+nb_filter[2], nb_filter[1])\n\n        self.conv0_4 = double_conv(nb_filter[0]*4+nb_filter[1], nb_filter[0])\n\n        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\n\n        if self.deep_supervision:\n            self.final1 = nn.Conv2d(nb_filter[0], n_classes, kernel_size=1)\n            self.final2 = nn.Conv2d(nb_filter[0], n_classes, kernel_size=1)\n            self.final3 = nn.Conv2d(nb_filter[0], n_classes, kernel_size=1)\n            self.final4 = nn.Conv2d(nb_filter[0], n_classes, kernel_size=1)\n        else:\n            self.final = nn.Conv2d(nb_filter[0], n_classes, kernel_size=1)\n\n        self.sigmoid = nn.Sigmoid()  # Sigmoid activation\n\n    def forward(self, x):\n        x0_0 = self.conv0_0(x)\n        x1_0 = self.conv1_0(F.max_pool2d(x0_0, 2))\n        x2_0 = self.conv2_0(F.max_pool2d(x1_0, 2))\n        x3_0 = self.conv3_0(F.max_pool2d(x2_0, 2))\n        x4_0 = self.conv4_0(F.max_pool2d(x3_0, 2))\n\n        x0_1 = self.conv0_1(torch.cat([x0_0, self.up(x1_0)], 1))\n        x1_1 = self.conv1_1(torch.cat([x1_0, self.up(x2_0)], 1))\n        x2_1 = self.conv2_1(torch.cat([x2_0, self.up(x3_0)], 1))\n        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))\n\n        x0_2 = self.conv0_2(torch.cat([x0_0, x0_1, self.up(x1_1)], 1))\n        x1_2 = self.conv1_2(torch.cat([x1_0, x1_1, self.up(x2_1)], 1))\n        x2_2 = self.conv2_2(torch.cat([x2_0, x2_1, self.up(x3_1)], 1))\n\n        x0_3 = self.conv0_3(torch.cat([x0_0, x0_1, x0_2, self.up(x1_2)], 1))\n        x1_3 = self.conv1_3(torch.cat([x1_0, x1_1, x1_2, self.up(x2_2)], 1))\n\n        x0_4 = self.conv0_4(torch.cat([x0_0, x0_1, x0_2, x0_3, self.up(x1_3)], 1))\n\n        if self.deep_supervision:\n            output1 = self.sigmoid(self.final1(x0_1))\n            output2 = self.sigmoid(self.final2(x0_2))\n            output3 = self.sigmoid(self.final3(x0_3))\n            output4 = self.sigmoid(self.final4(x0_4))\n            return [output1, output2, output3, output4]\n\n        else:\n            output = self.sigmoid(self.final(x0_4))\n            return output","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:55.980515Z","iopub.execute_input":"2024-08-14T09:17:55.980833Z","iopub.status.idle":"2024-08-14T09:17:56.006460Z","shell.execute_reply.started":"2024-08-14T09:17:55.980809Z","shell.execute_reply":"2024-08-14T09:17:56.005495Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"# Define batch size\nbatch_size = 5\n\n# Create data loaders\ntrain_loader_unet = DataLoader(unet_dataset, batch_size=batch_size, shuffle=True, num_workers=workers)\nval_loader_unet = DataLoader(unet_val, batch_size=batch_size, num_workers=workers)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:17:57.784736Z","iopub.execute_input":"2024-08-14T09:17:57.785404Z","iopub.status.idle":"2024-08-14T09:17:57.790318Z","shell.execute_reply.started":"2024-08-14T09:17:57.785373Z","shell.execute_reply":"2024-08-14T09:17:57.789348Z"},"trusted":true},"execution_count":15,"outputs":[]},{"cell_type":"code","source":"def dice_coeff(y_pred, y_targets):\n    smooth = 1\n    num = y_targets.size(0)\n    m1 = y_pred.view(num, -1)\n    m2 = y_targets.view(num, -1)\n    intersection = (m1 * m2)\n\n    score = 2. * (intersection.sum(1) + smooth) / (m1.sum(1) + m2.sum(1) + smooth)\n    score = score.sum() / num\n    return score.item()\n\n\ndef dice_loss(y_predict, y_train):\n    \n    dice_loss = 1 -(dice_coeff(y_predict, y_train))\n    return dice_loss","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:18:00.201813Z","iopub.execute_input":"2024-08-14T09:18:00.202722Z","iopub.status.idle":"2024-08-14T09:18:00.209712Z","shell.execute_reply.started":"2024-08-14T09:18:00.202683Z","shell.execute_reply":"2024-08-14T09:18:00.208510Z"},"trusted":true},"execution_count":16,"outputs":[]},{"cell_type":"code","source":"from torch.optim.lr_scheduler import CosineAnnealingLR\n\ndef train_and_validate(model, train_loader, validation_loader, criterion, optimizer, epochs=5, model_type = \"classification\", train_loss_threshold=None):\n    train_running_loss_history = []\n    validation_running_loss_history = []\n    lr_history = []\n    prev_val_loss = float('inf')\n    early_stop = False\n    \n    scheduler = CosineAnnealingLR(optimizer, T_max=epochs)\n\n    for e in range(epochs):\n\n        train_running_loss = 0.0\n        validation_running_loss = 0.0\n        \n        if early_stop:\n            break\n\n        model.train()\n        # Training loop\n        for ith_batch, sample_batched in enumerate(train_loader):\n            x_train, y_train = sample_batched[:2]\n            X_train = x_train.to(device)\n            \n            if model_type == \"classification\":\n                Y_train = F.one_hot(y_train, num_classes=num_classes).to(torch.float32).to(device)\n            else:\n                Y_train= y_train.to(device)\n\n            optimizer.zero_grad()\n            y_pred = model(X_train)\n\n            # Calculate losses\n            if model_type == \"classification\":\n                loss = criterion(y_pred, Y_train)\n            elif model_type == \"segmentation\":\n                loss = 0.3 * dice_loss(y_pred, Y_train) + 0.7 * criterion(y_pred, Y_train)\n\n            # Backward and optimize\n            loss.backward()\n            optimizer.step()\n\n            train_running_loss += loss.item()\n        \n        scheduler.step()\n        lr_history.append(optimizer.param_groups[0]['lr'])\n\n        # Validation loop\n        with torch.no_grad():\n            model.eval()\n            for ith_batch, sample_batched in enumerate(validation_loader):\n                x_val, y_val = sample_batched[:2]\n                X_val = x_val.to(device)\n\n                if model_type == \"classification\":\n                    Y_val = F.one_hot(y_val, num_classes=num_classes).to(torch.float32).to(device)\n                else:\n                    Y_val = y_val.to(device)\n\n                pred_val = model(X_val)\n                \n                # Calculate losses\n                if model_type == \"classification\":\n                    val_loss = criterion(pred_val, Y_val)\n                elif model_type == \"segmentation\":\n                    val_loss = 0.3 * dice_loss(pred_val, Y_val) + 0.7 * criterion(pred_val, Y_val)\n                \n                validation_running_loss += val_loss.item()\n\n            train_epoch_loss = train_running_loss / len(train_loader)\n            validation_epoch_loss = validation_running_loss / len(validation_loader)\n\n            train_running_loss_history.append(train_epoch_loss)\n            validation_running_loss_history.append(validation_epoch_loss)\n            \n            print(\"================================================================================\")\n            print(f\"Epoch {e + 1} completed\")\n            print(f\"Average train loss: {train_epoch_loss}\")\n            print(f\"Average validation loss: {validation_epoch_loss}\")\n            print(\"================================================================================\")\n            \n            if train_loss_threshold is not None:\n                if train_epoch_loss < train_loss_threshold and validation_epoch_loss >= prev_val_loss:\n                    print(\"Stopping training as training loss is below threshold and validation loss has stopped decreasing.\")\n                    early_stop = True\n                prev_val_loss = validation_epoch_loss\n\n        torch.cuda.empty_cache()\n\n    # Plot loss history\n    plt.figure(figsize=(12, 5))\n\n    # Plot loss\n    plt.subplot(1, 2, 1)\n    plt.plot(train_running_loss_history, label='Train Loss')\n    plt.plot(validation_running_loss_history, label='Validation Loss')\n    plt.xlabel('Epoch')\n    plt.ylabel('Loss')\n    plt.title('Training and Validation Loss')\n    plt.legend()\n\n    \n    # Plot learning rate\n    plt.subplot(1, 2, 2)\n    plt.plot(lr_history, label='Learning Rate')\n    plt.xlabel('Step')\n    plt.ylabel('Learning Rate')\n    plt.title('Learning Rate Schedule')\n    plt.legend()\n\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:18:00.860255Z","iopub.execute_input":"2024-08-14T09:18:00.860621Z","iopub.status.idle":"2024-08-14T09:18:00.879307Z","shell.execute_reply.started":"2024-08-14T09:18:00.860591Z","shell.execute_reply":"2024-08-14T09:18:00.878443Z"},"trusted":true},"execution_count":17,"outputs":[]},{"cell_type":"code","source":"epochs = 5\nlearning_rate = 0.0005\nweight_decay = 0.01\n\ncriterion = nn.BCELoss()\n\nunet_model = NestedUNet(n_channels=1, n_classes=1)\n\n# Use DataParallel for multi-GPU training\nif torch.cuda.device_count() > 1:\n    model = nn.DataParallel(unet_model)\n\nunet_model.to(device)\n\noptimizer = optim.AdamW(unet_model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n\ntrain_and_validate(unet_model, train_loader_unet, val_loader_unet, criterion, optimizer, epochs, \"segmentation\", 0.015)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:18:01.561747Z","iopub.execute_input":"2024-08-14T09:18:01.562114Z","iopub.status.idle":"2024-08-14T09:29:31.053945Z","shell.execute_reply.started":"2024-08-14T09:18:01.562082Z","shell.execute_reply":"2024-08-14T09:29:31.052843Z"},"trusted":true},"execution_count":18,"outputs":[{"name":"stdout","text":"================================================================================\nEpoch 1 completed\nAverage train loss: 0.33611515645057927\nAverage validation loss: 0.27225880285626963\n================================================================================\n================================================================================\nEpoch 2 completed\nAverage train loss: 0.20248190687823406\nAverage validation loss: 0.19052384499656527\n================================================================================\n================================================================================\nEpoch 3 completed\nAverage train loss: 0.13285591357177304\nAverage validation loss: 0.12276619359066612\n================================================================================\n================================================================================\nEpoch 4 completed\nAverage train loss: 0.09910912549097417\nAverage validation loss: 0.10226273791570413\n================================================================================\n================================================================================\nEpoch 5 completed\nAverage train loss: 0.07904000971723811\nAverage validation loss: 0.08093378869326491\n================================================================================\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x500 with 2 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAABKUAAAHqCAYAAADVi/1VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADd10lEQVR4nOzdd3gUVd/G8e9ueiEJJaRA6L33KoISDFVCkSLSRFAUFAG7dCy0R0QEpBdFqVKVKigC0nvvvUMSEiAh2Xn/yMO+TwwlgSQTwv25rr0ks2dm7lmic/ztmXMshmEYiIiIiIiIiIiIpCGr2QFEREREREREROTZo6KUiIiIiIiIiIikORWlREREREREREQkzakoJSIiIiIiIiIiaU5FKRERERERERERSXMqSomIiIiIiIiISJpTUUpERERERERERNKcilIiIiIiIiIiIpLmVJQSEREREREREZE0p6KUyFOiQ4cO5MmT57H27d+/PxaLJWUDpTMnT57EYrEwderUND+3xWKhf//+9p+nTp2KxWLh5MmTj9w3T548dOjQIUXzPMnvioiIiKQfqdFPkIe716ccPnx4qp8rOX3Gf1u7di0Wi4W1a9emeC6RtKSilMgTslgsSXrphmG+d999F4vFwtGjRx/Y5rPPPsNisbB79+40TJZ858+fp3///uzcudPsKHZp2YkTERFJqnv/479161azozxV/t2X9fLyombNmixduvSxjzlz5kxGjhyZciH/x+LFi6lZsybZs2fH3d2dfPny0aJFC5YtW5Yq5xORlOFodgCRp92MGTMS/Dx9+nRWrlyZaHvRokWf6DwTJkzAZrM91r6ff/45H3/88ROdPyNo06YN3333HTNnzqRv3773bfPzzz9TsmRJSpUq9djnadu2La1atcLFxeWxj/Eo58+fZ8CAAeTJk4cyZcokeO9JfldEREQk/Th06BBWq3njCOrUqUO7du0wDINTp04xduxYGjVqxO+//05ISEiyjzdz5kz27t1Ljx49UjTn8OHD+eCDD6hZsyaffPIJ7u7uHD16lFWrVvHLL79Qt27dFD2fiKQcFaVEntBrr72W4Od//vmHlStXJtr+b7du3cLd3T3J53FycnqsfACOjo44Oupf98qVK1OgQAF+/vnn+xalNm7cyIkTJ/j666+f6DwODg44ODg80TGexJP8roiIiEjqiI2NxWaz4ezsnOR9UvMLrqQoVKhQgj5ts2bNKFasGN9+++1jFaVSQ2xsLIMGDaJOnTqsWLEi0fuXL182IZWIJJUe3xNJA7Vq1aJEiRJs27aN559/Hnd3dz799FMAFi5cSIMGDQgMDMTFxYX8+fMzaNAg4uLiEhzj3/ME/e+jUuPHjyd//vy4uLhQsWJFtmzZkmDf+80pZbFY6NatGwsWLKBEiRK4uLhQvHjx+w5xXrt2LRUqVMDV1ZX8+fPzww8/JHmeqnXr1vHKK6+QK1cuXFxcCAoK4v333+f27duJrs/T05Nz584RGhqKp6cnvr6+9O7dO9FnERYWRocOHfD29sbHx4f27dsTFhb2yCwQP1rq4MGDbN++PdF7M2fOxGKx0Lp1a2JiYujbty/ly5fH29sbDw8PatSowZo1ax55jvvND2AYBoMHDyZnzpy4u7vzwgsvsG/fvkT7Xr9+nd69e1OyZEk8PT3x8vKiXr167Nq1y95m7dq1VKxYEYCOHTvah9Xfm0/rfnNKRUVF0atXL4KCgnBxcaFw4cIMHz4cwzAStEvO78Xjunz5Mp06dcLPzw9XV1dKly7NtGnTErX75ZdfKF++PJkyZcLLy4uSJUvy7bff2t+/e/cuAwYMoGDBgri6upI1a1aee+45Vq5cmWJZRUTk2XHu3Dlef/11/Pz87Pe/yZMnJ2iT1P7B//bTRo4cae+n7d+/396HOnr0KB06dMDHxwdvb286duzIrVu3Ehzn33NK3etjrF+/np49e+Lr64uHhwdNmjThypUrCfa12Wz079+fwMBAe99j//79TzRPVdGiRcmWLRvHjh1LsD0p/dlatWqxdOlSTp06Ze+7/G9/JTo6mn79+lGgQAF7n/HDDz8kOjr6oZmuXr1KREQE1atXv+/72bNnT/DznTt36N+/P4UKFcLV1ZWAgACaNm2a6JqAR/axAQ4ePEjz5s3JkiULrq6uVKhQgUWLFiVqt2/fPl588UXc3NzImTMngwcPvu/I9n/PVXpPUv/eNm3aRN26dfH29sbd3Z2aNWuyfv36R+4nYhYNnRBJI9euXaNevXq0atWK1157DT8/PyC+c+Hp6UnPnj3x9PTkjz/+oG/fvkRERDBs2LBHHnfmzJncvHmTN998E4vFwtChQ2natCnHjx9/5IiZv//+m/nz5/P222+TKVMmRo0aRbNmzTh9+jRZs2YFYMeOHdStW5eAgAAGDBhAXFwcAwcOxNfXN0nXPWfOHG7dukXXrl3JmjUrmzdv5rvvvuPs2bPMmTMnQdu4uDhCQkKoXLkyw4cPZ9WqVYwYMYL8+fPTtWtXIL6407hxY/7++2/eeustihYtyq+//kr79u2TlKdNmzYMGDCAmTNnUq5cuQTnnj17NjVq1CBXrlxcvXqViRMn0rp1azp37szNmzeZNGkSISEhbN68OdEjc4/St29fBg8eTP369alfvz7bt2/npZdeIiYmJkG748ePs2DBAl555RXy5s3LpUuX+OGHH6hZsyb79+8nMDCQokWLMnDgQPr27UuXLl2oUaMGANWqVbvvuQ3D4OWXX2bNmjV06tSJMmXKsHz5cj744APOnTvHN998k6B9Un4vHtft27epVasWR48epVu3buTNm5c5c+bQoUMHwsLCeO+99wBYuXIlrVu3pnbt2gwZMgSAAwcOsH79enub/v3789VXX/HGG29QqVIlIiIi2Lp1K9u3b6dOnTpPlFNERJ4tly5dokqVKvYvZ3x9ffn999/p1KkTERER9sfNIiIiktU/mDJlCnfu3KFLly64uLiQJUsW+3stWrQgb968fPXVV2zfvp2JEyeSPXt2+33vYbp3707mzJnp168fJ0+eZOTIkXTr1o1Zs2bZ23zyyScMHTqURo0aERISwq5duwgJCeHOnTuP/TmFh4dz48YN8ufPn2B7Uvqzn332GeHh4Zw9e9be9/D09ATiC2gvv/wyf//9N126dKFo0aLs2bOHb775hsOHD7NgwYIHZsqePTtubm4sXryY7t27J/iM/y0uLo6GDRuyevVqWrVqxXvvvcfNmzdZuXIle/fuTXBdSelj79u3j+rVq5MjRw4+/vhjPDw8mD17NqGhocybN48mTZoAcPHiRV544QViY2Pt7caPH4+bm1vy/xIe4o8//qBevXqUL1+efv36YbVamTJlCi+++CLr1q2jUqVKKXo+kRRhiEiKeuedd4x//6tVs2ZNAzDGjRuXqP2tW7cSbXvzzTcNd3d3486dO/Zt7du3N3Lnzm3/+cSJEwZgZM2a1bh+/bp9+8KFCw3AWLx4sX1bv379EmUCDGdnZ+Po0aP2bbt27TIA47vvvrNva9SokeHu7m6cO3fOvu3IkSOGo6NjomPez/2u76uvvjIsFotx6tSpBNcHGAMHDkzQtmzZskb58uXtPy9YsMAAjKFDh9q3xcbGGjVq1DAAY8qUKY/MVLFiRSNnzpxGXFycfduyZcsMwPjhhx/sx4yOjk6w340bNww/Pz/j9ddfT7AdMPr162f/ecqUKQZgnDhxwjAMw7h8+bLh7OxsNGjQwLDZbPZ2n376qQEY7du3t2+7c+dOglyGEf937eLikuCz2bJlywOv99+/K/c+s8GDBydo17x5c8NisST4HUjq78X93PudHDZs2APbjBw50gCMH3/80b4tJibGqFq1quHp6WlEREQYhmEY7733nuHl5WXExsY+8FilS5c2GjRo8NBMIiIi9+7LW7ZseWCbTp06GQEBAcbVq1cTbG/VqpXh7e1t788ktX9w757o5eVlXL58OUH7e/2yf/cnmjRpYmTNmjXBtty5cyfoJ9y7luDg4AR9ivfff99wcHAwwsLCDMMwjIsXLxqOjo5GaGhoguP1798/Ud/jQQCjU6dOxpUrV4zLly8bW7duNerWrXvfe31S+7MNGjRI0Ee5Z8aMGYbVajXWrVuXYPu4ceMMwFi/fv1Ds/bt29cADA8PD6NevXrGF198YWzbti1Ru8mTJxuA8Z///CfRe/c+z+T0sWvXrm2ULFkywTXabDajWrVqRsGCBe3bevToYQDGpk2b7NsuX75seHt7J+gzGkbifuU9//5dWLNmjQEYa9assZ+3YMGCRkhISILfjVu3bhl58+Y16tSpc59PTsR8enxPJI24uLjQsWPHRNv/9xuSmzdvcvXqVWrUqMGtW7c4ePDgI4/bsmVLMmfObP/53qiZ48ePP3Lf4ODgBN8IlSpVCi8vL/u+cXFxrFq1itDQUAIDA+3tChQoQL169R55fEh4fVFRUVy9epVq1aphGAY7duxI1P6tt95K8HONGjUSXMtvv/2Go6OjfeQUxM/h1L179yTlgfh5wM6ePctff/1l3zZz5kycnZ155ZVX7Me8N+eDzWbj+vXrxMbGUqFChfs++vcwq1atIiYmhu7duyd45PF+k3y6uLjYJzSNi4vj2rVreHp6Urhw4WSf957ffvsNBwcH3n333QTbe/XqhWEY/P777wm2P+r34kn89ttv+Pv707p1a/s2Jycn3n33XSIjI/nzzz8B8PHxISoq6qGP4vn4+LBv3z6OHDnyxLlEROTZZRgG8+bNo1GjRhiGwdWrV+2vkJAQwsPD7ffg5PYPmjVr9sDR5ffr81y7do2IiIhHZu7SpUuCPkWNGjWIi4vj1KlTAKxevZrY2FjefvvtBPslp78EMGnSJHx9fcmePTsVKlRg9erVfPjhh/Ts2TNBuyftz86ZM4eiRYtSpEiRBJ//iy++CPDI6RPujYIvW7Ysy5cv57PPPqN8+fKUK1eOAwcO2NvNmzePbNmy3fdz+Pe0FI/qY1+/fp0//viDFi1a2K/56tWrXLt2jZCQEI4cOcK5c+eA+P5PlSpVEoxU8vX1pU2bNo/8bJJq586dHDlyhFdffZVr167Z80RFRVG7dm3++usvLYQj6ZKKUiJpJEeOHPed2HLfvn00adIEb29vvLy88PX1tU8oGR4e/sjj5sqVK8HP926eN27cSPa+9/a/t+/ly5e5ffs2BQoUSNTuftvu5/Tp03To0IEsWbLY54mqWbMmkPj6XF1dE3Xc/jcPwKlTpwgICLAP976ncOHCScoD0KpVKxwcHJg5cyYQP7fAr7/+Sr169RJ0PqZNm0apUqXs8xX5+vqydOnSJP29/K97HcSCBQsm2O7r65vgfBDfwf3mm28oWLAgLi4uZMuWDV9fX3bv3p3s8/7v+QMDA8mUKVOC7fdWhLyX755H/V48iVOnTlGwYMFEKwn9O8vbb79NoUKFqFevHjlz5uT1119PNK/VwIEDCQsLo1ChQpQsWZIPPviA3bt3P3FGERF5tly5coWwsDDGjx+Pr69vgte9LxT/d7Ls5PQP8ubN+8DzpmQf7t/73ruf/ru/liVLlkR9j4dp3LgxK1euZOnSpfa5sG7dupXoPv6k/dkjR46wb9++RJ9/oUKFgKRNVt66dWvWrVvHjRs3WLFiBa+++io7duygUaNG9kcWjx07RuHChZO0ANCjPuOjR49iGAZ9+vRJlLtfv34Jct/r//xbcvqvj3LvS7r27dsnyjNx4kSio6Mfuy8pkpo0p5RIGrnfM+NhYWHUrFkTLy8vBg4cSP78+XF1dWX79u189NFHSfo240GrvBn/msA6pfdNiri4OOrUqcP169f56KOPKFKkCB4eHpw7d44OHTokur60WrEue/bs1KlTh3nz5vH999+zePFibt68meDbqh9//JEOHToQGhrKBx98QPbs2XFwcOCrr76670SYKeXLL7+kT58+vP766wwaNIgsWbJgtVrp0aNHmn27ldq/F0mRPXt2du7cyfLly/n999/5/fffmTJlCu3atbNPiv78889z7NgxFi5cyIoVK5g4cSLffPMN48aN44033kizrCIi8nS7d3997bXXHjhHZalSpYDk9w8eNmdQeu7D3ZMzZ06Cg4MBqF+/PtmyZaNbt2688MILNG3aFEiZ/qzNZqNkyZL85z//ue/7QUFBSc7s5eVFnTp1qFOnDk5OTkybNo1NmzbZvxRNqkd9xveuq3fv3g9ciTCpX+Imxb8X/vm3e3mGDRv2wLlP//2lrkh6oKKUiInWrl3LtWvXmD9/Ps8//7x9+4kTJ0xM9f+yZ8+Oq6srR48eTfTe/bb92549ezh8+DDTpk2jXbt29u1Psjpa7ty5Wb16NZGRkQlurIcOHUrWcdq0acOyZcv4/fffmTlzJl5eXjRq1Mj+/ty5c8mXLx/z589PMJz73jdfyc0M8d9g5cuXz779ypUrib4NnTt3Li+88AKTJk1KsD0sLIxs2bLZf07Kyof/e/5Vq1Zx8+bNBKOl7g2nv5cvLeTOnZvdu3djs9kSfMt6vyzOzs40atSIRo0aYbPZePvtt/nhhx/o06ePvZOXJUsWOnbsSMeOHYmMjOT555+nf//+KkqJiEiS+fr6kilTJuLi4uwFmAdJyf5Barp3Pz169GiC0VrXrl17opHPb775Jt988w2ff/45TZo0wWKxJKs/+6D+S/78+dm1axe1a9dOVh/nUSpUqMC0adO4cOGC/TybNm3i7t27j1wQ6FHu9emcnJwe+XuTO3fu+043cL/+a+bMmROtKh0TE2O/hge5N/WCl5fXI/OIpCd6fE/ERPe+gfnfb7ViYmIYM2aMWZEScHBwIDg4mAULFnD+/Hn79qNHjyaah+hB+0PC6zMMg2+//faxM9WvX5/Y2FjGjh1r3xYXF8d3332XrOOEhobi7u7OmDFj+P3332natCmurq4Pzb5p0yY2btyY7MzBwcE4OTnx3XffJTjeyJEjE7V1cHBI9C3nnDlz7HMS3OPh4QGQqNNyP/Xr1ycuLo7Ro0cn2P7NN99gsViSPD9YSqhfvz4XL15MsDpQbGws3333HZ6envZvMa9du5ZgP6vVav+W+t7S0P9u4+npSYECBR65dLSIiMj/cnBwoFmzZsybN4+9e/cmev/KlSsJ2kLK9A9SU+3atXF0dEzQXwIS9QWSy9HRkV69enHgwAEWLlwIJK8/6+Hhcd9HyFq0aMG5c+eYMGFCovdu375NVFTUAzPdunXrgZ//vf7qvcfkmjVrxtWrV+/7OSR3lFn27NmpVasWP/zww30LRv/7e1O/fn3++ecfNm/enOD9n376KdF++fPnTzDvKcD48eMfOVKqfPny5M+fn+HDhxMZGfnQPCLpiUZKiZioWrVqZM6cmfbt2/Puu+9isViYMWNGmj4m9Sj9+/dnxYoVVK9ena5du9qLGyVKlGDnzp0P3bdIkSLkz5+f3r17c+7cOby8vJg3b94TfUPXqFEjqlevzscff8zJkycpVqwY8+fPT/Yz8p6enoSGhtrnlfr3RJMNGzZk/vz5NGnShAYNGnDixAnGjRtHsWLF7nujfxhfX1969+7NV199RcOGDalfvz47duzg999/TzD66d55Bw4cSMeOHalWrRp79uzhp59+SjDCCuI7LD4+PowbN45MmTLh4eFB5cqV7zt3RaNGjXjhhRf47LPPOHnyJKVLl2bFihUsXLiQHj16JFrW+UmtXr36vstNh4aG0qVLF3744Qc6dOjAtm3byJMnD3PnzmX9+vWMHDnSPpLrjTfe4Pr167z44ovkzJmTU6dO8d1331GmTBn7/FPFihWjVq1alC9fnixZsrB161bmzp1Lt27dUvR6REQkY5g8eXKi+QkB3nvvPb7++mvWrFlD5cqV6dy5M8WKFeP69ets376dVatWcf36dSBl+wepyc/Pj/fee48RI0bw8ssvU7duXXbt2mXvezzJaKQOHTrQt29fhgwZQmhoaLL6s+XLl2fWrFn07NmTihUr4unpSaNGjWjbti2zZ8/mrbfeYs2aNVSvXp24uDgOHjzI7NmzWb58ORUqVLhvnlu3blGtWjWqVKlC3bp1CQoKIiwsjAULFrBu3TpCQ0MpW7YsAO3atWP69On07NmTzZs3U6NGDaKioli1ahVvv/02jRs3TtZn8f333/Pcc89RsmRJOnfuTL58+bh06RIbN27k7Nmz7Nq1C4APP/yQGTNmULduXd577z08PDwYP368fQT5/3rjjTd46623aNasGXXq1GHXrl0sX748UZ/x36xWKxMnTqRevXoUL16cjh07kiNHDs6dO8eaNWvw8vJi8eLFybo+kTSRlkv9iTwL3nnnHePf/2rVrFnTKF68+H3br1+/3qhSpYrh5uZmBAYGGh9++KGxfPnyBEu8GoZhtG/fPsESuveWq/33kryGkXgp2XtLD/+7zTvvvJNo338vN2sYhrF69WqjbNmyhrOzs5E/f35j4sSJRq9evQxXV9cHfAr/b//+/UZwcLDh6elpZMuWzejcubOxa9cuAzCmTJmS4Po8PDwS7X+/7NeuXTPatm1reHl5Gd7e3kbbtm2NHTt2JDrmoyxdutQAjICAACMuLi7Bezabzfjyyy+N3LlzGy4uLkbZsmWNJUuWJPp7MIzEn/e95Zr/d3nfuLg4Y8CAAUZAQIDh5uZm1KpVy9i7d2+iz/vOnTtGr1697O2qV69ubNy40ahZs6ZRs2bNBOdduHChUaxYMcPR0THBtd8v482bN43333/fCAwMNJycnIyCBQsaw4YNS7Bk8L1rServxb/d+5180GvGjBmGYRjGpUuXjI4dOxrZsmUznJ2djZIlSyb6e5s7d67x0ksvGdmzZzecnZ2NXLlyGW+++aZx4cIFe5vBgwcblSpVMnx8fAw3NzejSJEixhdffGHExMQ8NKeIiDxb7t2XH/Q6c+aMYRjx96d33nnHCAoKMpycnAx/f3+jdu3axvjx4+3HSmr/4GH9tHt9mytXrtw35//2H/59/73XZsuWLQn2XbNmTaK+Y2xsrNGnTx/D39/fcHNzM1588UXjwIEDRtasWY233nrrkZ/bg/oEhmEY/fv3T3C+pPZnIyMjjVdffdXw8fExgASfWUxMjDFkyBCjePHihouLi5E5c2ajfPnyxoABA4zw8PAH5rx7964xYcIEIzQ01P734u7ubpQtW9YYNmyYER0dnaD9rVu3jM8++8zImzev/e+5efPmxrFjxwzDSF4f2zAM49ixY0a7du0Mf39/w8nJyciRI4fRsGFDY+7cuQna7d6926hZs6bh6upq5MiRwxg0aJAxadKk+/YZP/roIyNbtmyGu7u7ERISYhw9ejTR78L9/s4NwzB27NhhNG3a1MiaNavh4uJi5M6d22jRooWxevXqB36GImayGEY6GpIhIk+N0NBQ9u3bd9/n40VEREQk/QkLCyNz5swMHjyYzz77zOw4IiKaU0pEHu327dsJfj5y5Ai//fYbtWrVMieQiIiIiDzUv/tv8P/zWaoPJyLphUZKicgjBQQE0KFDB/Lly8epU6cYO3Ys0dHR7Nixg4IFC5odT0RERET+ZerUqUydOpX69evj6enJ33//zc8//8xLL73E8uXLzY4nIgJoonMRSYK6devy888/c/HiRVxcXKhatSpffvmlClIiIiIi6VSpUqVwdHRk6NChRERE2Cc/Hzx4sNnRRETsNFJKRERERERERETSnOaUEhERERERERGRNKeilIiIiIiIiIiIpDnNKXUfNpuN8+fPkylTJiwWi9lxREREJJUYhsHNmzcJDAzEatV3dalNfSwREZFnQ1L7WCpK3cf58+cJCgoyO4aIiIikkTNnzpAzZ06zY2R46mOJiIg8Wx7Vx1JR6j4yZcoExH94Xl5eJqcRERGR1BIREUFQUJD93i+pS30sERGRZ0NS+1gqSt3HveHkXl5e6jCJiIg8A/QoWdpQH0tEROTZ8qg+liZPEBERERERERGRNKeilIiIiIiIiIiIpDkVpUREREREREREJM1pTikREUkX4uLiuHv3rtkxJINxcnLCwcHB7BgiIiLpkvpf8rhSqo+lopSIiJjKMAwuXrxIWFiY2VEkg/Lx8cHf31+TmYuIiPyX+l+SElKij6WilIiImOpehyh79uy4u7urcCApxjAMbt26xeXLlwEICAgwOZGIiEj6oP6XPImU7GOpKCUiIqaJi4uzd4iyZs1qdhzJgNzc3AC4fPky2bNn16N8IiLyzFP/S1JCSvWxNNG5iIiY5t4cBu7u7iYnkYzs3u+X5swQERFR/0tSTkr0sVSUEhER02nIuKQm/X6JiIgkpvujPKmU+B1SUUpERERERERERNKcilIiIiLpRJ48eRg5cqTZMUREREQkmdSPezwqSomIiCSTxWJ56Kt///6PddwtW7bQpUuXJ8pWq1YtevTo8UTHEBEREUmPOnToQGhoqNkx7isl+nFJkSdPHnuf093dnZIlSzJx4sRkH8disbBgwYKUD5hMWn1PREQkmS5cuGD/86xZs+jbty+HDh2yb/P09LT/2TAM4uLicHR89C3X19c3ZYOKiIiIyBO5e/cuTk5Oj2yXlv24gQMH0rlzZ27dusWcOXPo3LkzOXLkoF69emmWIaVopJSIiEgy+fv721/e3t5YLBb7zwcPHiRTpkz8/vvvlC9fHhcXF/7++2+OHTtG48aN8fPzw9PTk4oVK7Jq1aoEx/33sG+LxcLEiRNp0qQJ7u7uFCxYkEWLFj1R9nnz5lG8eHFcXFzIkycPI0aMSPD+mDFjKFiwIK6urvj5+dG8eXP7e3PnzqVkyZK4ubmRNWtWgoODiYqKeqI8IiIiIill79691KtXD09PT/z8/Gjbti1Xr161v79s2TKee+45fHx8yJo1Kw0bNuTYsWP290+ePInFYmHWrFnUrFkTV1dXfvrpJ/sIreHDhxMQEEDWrFl55513Eqw69zj9uEWLFtn7XS+88ALTpk3DYrEQFhb20OvMlCkT/v7+5MuXj48++ogsWbKwcuVK+/tbtmyhTp06ZMuWDW9vb2rWrMn27dsTZAVo0qQJFovF/jPAwoULKVeuHK6uruTLl48BAwYQGxublI//sagolcZOXI1i4rrjZscQEUm3DMPgVkysKS/DMFLsOj7++GO+/vprDhw4QKlSpYiMjKR+/fqsXr2aHTt2ULduXRo1asTp06cfepwBAwbQokULdu/eTf369WnTpg3Xr19/rEzbtm2jRYsWtGrVij179tC/f3/69OnD1KlTAdi6dSvvvvsuAwcO5NChQyxbtoznn38eiB8d1rp1a15//XUOHDjA2rVradq0aYp+ZiJP4kZUDN+uOkJsnM3sKCIiT52M0P8KCwvjxRdfpGzZsmzdupVly5Zx6dIlWrRoYW8TFRVFz5492bp1K6tXr8ZqtdKkSRNstoT3jo8//pj33nuPAwcOEBISAsCaNWs4duwYa9asYdq0aUydOtXeh3qQh/XjTpw4QfPmzQkNDWXXrl28+eabfPbZZ8m6ZpvNxrx587hx4wbOzs727Tdv3qR9+/b8/fff/PPPPxQsWJD69etz8+ZNIL5oBTBlyhQuXLhg/3ndunW0a9eO9957j/379/PDDz8wdepUvvjii2TlSg49vpeGrtyMpt63f3Hnro2SObypnC+r2ZFERNKd23fjKNZ3uSnn3j8wBHfnlLk1Dhw4kDp16th/zpIlC6VLl7b/PGjQIH799VcWLVpEt27dHnicDh060Lp1awC+/PJLRo0axebNm6lbt26yM/3nP/+hdu3a9OnTB4BChQqxf/9+hg0bRocOHTh9+jQeHh40bNiQTJkykTt3bsqWLQvEF6ViY2Np2rQpuXPnBqBkyZLJziCSGmw2gy4ztrLl5A32nAtjVOuyKfbvsojIsyAj9L9Gjx5N2bJl+fLLL+3bJk+eTFBQEIcPH6ZQoUI0a9YswT6TJ0/G19eX/fv3U6JECfv2Hj160LRp0wRtM2fOzOjRo3FwcKBIkSI0aNCA1atX07lz5wdmelg/7ocffqBw4cIMGzYMgMKFC7N3794kFYA++ugjPv/8c6Kjo4mNjSVLliy88cYb9vdffPHFBO3Hjx+Pj48Pf/75Jw0bNrQ/aujj44O/v7+93YABA/j4449p3749APny5WPQoEF8+OGH9OvX75G5HodGSqUh30wuNC2XE4A+C/dyV9/kiYhkWBUqVEjwc2RkJL1796Zo0aL4+Pjg6enJgQMHHjlSqlSpUvY/e3h44OXlxeXLlx8r04EDB6hevXqCbdWrV+fIkSPExcVRp04dcufOTb58+Wjbti0//fQTt27dAqB06dLUrl2bkiVL8sorrzBhwgRu3LjxWDlEUprVauH16nlxcbSy6sBlWo//hys3o82OJSIiaWjXrl2sWbMGT09P+6tIkSIA9kf0jhw5QuvWrcmXLx9eXl72x9b+3R/7dz8OoHjx4jg4ONh/DggIeGSf7GH9uEOHDlGxYsUE7StVqpSka/3ggw/YuXMnf/zxB5UrV+abb76hQIEC9vcvXbpE586dKViwIN7e3nh5eREZGfnIfueuXbsYOHBggs+wc+fOXLhwwd4nTGn6CimNfRhSmGV7L3L4UiRT15+k8/P5zI4kIpKuuDk5sH9giGnnTikeHh4Jfu7duzcrV65k+PDhFChQADc3N5o3b05MTMxDj/PviTUtFkuiIeYpJVOmTGzfvp21a9eyYsUK+vbtS//+/dmyZQs+Pj6sXLmSDRs2sGLFCr777js+++wzNm3aRN68eVMlj0hy1CsZQHYvF96YtpVdZ8NpOnY90zpWIp+v56N3FhF5xmWE/ldkZCSNGjViyJAhid4LCAgAoFGjRuTOnZsJEyYQGBiIzWajRIkSifpj/+7HweP1yVKrH5ctWzYKFChAgQIFmDNnDiVLlqRChQoUK1YMgPbt23Pt2jW+/fZbcufOjYuLC1WrVn1kvzMyMpIBAwYkGiUG4Orq+sS570dFqTTm4+7Mx3WL8OG83YxcdZhGpQPx906dv1wRkaeRxWLJkI/drF+/ng4dOtCkSRMg/qZ/8uTJNM1QtGhR1q9fnyhXoUKF7N/8OTo6EhwcTHBwMP369cPHx4c//viDpk2bYrFYqF69OtWrV6dv377kzp2bX3/9lZ49e6bpdYg8SPncWZjXtRodpmzh9PVbNBu7gYntK1A+dxazo4mIpGsZof9Vrlw55s2bR548ee676vG1a9c4dOgQEyZMoEaNGgD8/fffaR3TrnDhwvz2228Jtt2b2yk5goKCaNmyJZ988gkLFy4E4vt3Y8aMoX79+gCcOXMmwYTvEF8wi4uLS7CtXLlyHDp0KMGoq9Smx/dM0Lx8Tsrl8iEqJo5BS/ebHUdERNJAwYIFmT9/Pjt37mTXrl28+uqrqTbi6cqVK+zcuTPB69KlS/Tq1YvVq1czaNAgDh8+zLRp0xg9ejS9e/cGYMmSJYwaNYqdO3dy6tQppk+fjs1mo3DhwmzatIkvv/ySrVu3cvr0aebPn8+VK1coWrRoqlyDyOPK5+vJ/LerUTqnNzdu3eXVCZv4fc8Fs2OJiEgKCQ8PT9TPOXPmDO+88w7Xr1+ndevWbNmyhWPHjrF8+XI6duxIXFwcmTNnJmvWrIwfP56jR4/yxx9/mPrF2ptvvsnBgwf56KOPOHz4MLNnz7ZPnG6xWJJ1rPfee4/FixezdetWIL7fOWPGDA4cOMCmTZto06YNbm5uCfbJkycPq1ev5uLFi/YpGfr27cv06dMZMGAA+/bt48CBA/zyyy98/vnnT37BD6CilAmsVguDQktgtcDS3Rf4+8jVR+8kIiJPtf/85z9kzpyZatWq0ahRI0JCQihXrlyqnGvmzJmULVs2wWvChAmUK1eO2bNn88svv1CiRAn69u3LwIED6dChAxA/2eX8+fN58cUXKVq0KOPGjePnn3+mePHieHl58ddff1G/fn0KFSrE559/zogRI6hXr16qXIPIk8jm6cLPXaoQXDQ70bE23p65nUl/nzA7loiIpIC1a9cm6ucMGDCAwMBA1q9fT1xcHC+99BIlS5akR48e+Pj4YLVasVqt/PLLL2zbto0SJUrw/vvv2ycZN0PevHmZO3cu8+fPp1SpUowdO9a++p6Li0uyjlWsWDFeeukl+vbtC8CkSZO4ceMG5cqVo23btrz77rtkz549wT4jRoxg5cqVBAUF2Re2CQkJYcmSJaxYsYKKFStSpUoVvvnmG/siN6nBYmgt50QiIiLw9vYmPDwcLy+vVDtP/0X7mLrhJPmyefB7jxq4OKbcXCYiIk+DO3fucOLECfLmzZtqz6mLPOz3LK3u+RIvrT/vOJtBv0V7+fGf+IldX6+el88bFMVqTd430CIiGYn6X+nXF198wbhx4zhz5ozZUZIkJfpYGillop4vFSKbpwvHr0YxcZ2+vRMRERFJSQ5WC4Mal+CjuvGrL01ef4JuP2/nzt24R+wpIiKS+saMGcOWLVs4fvw4M2bMYNiwYbRv397sWGlKRSkTebk68VmD+E7Sd38c4eyN1FliUURERORZZbFY6ForP9+2KoOzg5Xf9lzktYmbuBH18BWIREREUtuRI0do3LgxxYoVY9CgQfTq1Yv+/fubHStNqShlstAyOaicNwt37toYuFiTnouIiIikhsZlcjC9UyW8XB3ZeuoGzcZu4PQ1fSEoIiLm+eabbzh//jx37tzh8OHD9OnT574rB2ZkKkqZzGKJn/Tc0Wphxf5LrDl42exIIiIiIhlSlXxZmdu1GoHerhy/GkXTsevZdSbM7FgiIiLPLBWl0oFCfpl4/bm8APRbtE/zHIiIiIikkkJ+mfj1neoUC/DiamQMrcb/w+oDl8yOJSIi8kxSUSqdeK92Qfy9XDl9/RZj1x4zO46IiIhIhuXn5crst6ryfCFfbt+No/P0rfz4zymzY4mIpCmbzWZ2BHnKpcTv0LP1sGI65uHiSJ+GxXhn5nbG/nmMpuVykDurh9mxRERERDIkTxdHJrWvwGe/7mH21rN8vmAv58Ju88FLhbFaLWbHExFJNc7OzlitVs6fP4+vry/Ozs5YLPrvniSdYRjExMRw5coVrFYrzs7Oj30sFaXSkfol/alRMBvrjlyl36J9TOlQUf9xEBEREUklTg5WhjQrRaCPGyNXHWHs2mNcCLvN0OalcXbUAwUikjFZrVby5s3LhQsXOH/+vNlx5Cnm7u5Orly5sFof/56polQ6YrFY6P9yceqO/Iu1h66wYv8lQor7mx1LREREJMOyWCz0CC5EDh83Ppm/hwU7z3MpIppxbcvj7eZkdjwRkVTh7OxMrly5iI2NJS5OcxpL8jk4OODo6PjEA2lUlEpn8vt60uX5fHy/5hgDF++nRsFsuDvrr0lEJCOqVasWZcqUYeTIkQDkyZOHHj160KNHjwfuY7FY+PXXXwkNDX2ic6fUcUQyilcqBOHn5crbP21n4/FrvDJuA1M6ViKHj5vZ0UREUoXFYsHJyQknJxXgxTwal5wOdXuhIDl83DgXdpvRfxw1O46IiPxLo0aNqFu37n3fW7duHRaLhd27dyf7uFu2bKFLly5PGi+B/v37U6ZMmUTbL1y4QL169VL0XP82depUfHx8UvUcIinp+UK+zHqzCtkzuXD4UiRNx6xn3/lws2OJiIhkWCpKpUNuzg70a1QMgAnrjnP0cqTJiURE5H916tSJlStXcvbs2UTvTZkyhQoVKlCqVKlkH9fX1xd3d/eUiPhI/v7+uLi4pMm5RJ4mxQO9+fWd6hTy8+RSRDQtf/iHvw5fMTuWiIhIhqSiVDpVp5gfLxbJzt04g36L9mIYhtmRRETkvxo2bIivry9Tp05NsD0yMpI5c+bQqVMnrl27RuvWrcmRIwfu7u6ULFmSn3/++aHHzZMnj/1RPoAjR47w/PPP4+rqSrFixVi5cmWifT766CMKFSqEu7s7+fLlo0+fPty9exeIH6k0YMAAdu3ahcViwWKx2DNbLBYWLFhgP86ePXt48cUXcXNzI2vWrHTp0oXIyP//UqRDhw6EhoYyfPhwAgICyJo1K++88479XI/j9OnTNG7cGE9PT7y8vGjRogWXLl2yv79r1y5eeOEFMmXKhJeXF+XLl2fr1q0AnDp1ikaNGpE5c2Y8PDwoXrw4v/3222NnEflfOXzcmPNWNarmy0pkdCyvT93CnK1nzI4lIiKS4WiyonTKYrHQv1Fx1h+9yvqj11iy+wKNSgeaHUtEJPUZBty9Zc65ndwhCZM1Ojo60q5dO6ZOncpnn31mn+Bxzpw5xMXF0bp1ayIjIylfvjwfffQRXl5eLF26lLZt25I/f34qVar0yHPYbDaaNm2Kn58fmzZtIjw8/L5zTWXKlImpU6cSGBjInj176Ny5M5kyZeLDDz+kZcuW7N27l2XLlrFq1SoAvL29Ex0jKiqKkJAQqlatypYtW7h8+TJvvPEG3bp1S1B4W7NmDQEBAaxZs4ajR4/SsmVLypQpQ+fOnR95Pfe7vnsFqT///JPY2FjeeecdWrZsydq1awFo06YNZcuWZezYsTg4OLBz5077vBfvvPMOMTEx/PXXX3h4eLB//348PT2TnUPkQbzdnJj6ekU+mrubBTvP88Hc3ZwLu817tQtqdWQREZEUoqJUOpYrqztv1yrAN6sOM3jpfl4okh1PF/2ViUgGd/cWfGlSEf7T8+DskaSmr7/+OsOGDePPP/+kVq1aQPyje82aNcPb2xtvb2969+5tb9+9e3eWL1/O7Nmzk1SUWrVqFQcPHmT58uUEBsZ/Hl9++WWieaA+//xz+5/z5MlD7969+eWXX/jwww9xc3PD09MTR0dH/P0fvJrrzJkzuXPnDtOnT8fDI/76R48eTaNGjRgyZAh+fn4AZM6cmdGjR+Pg4ECRIkVo0KABq1evfqyi1OrVq9mzZw8nTpwgKCgIgOnTp1O8eHG2bNlCxYoVOX36NB988AFFihQBoGDBgvb9T58+TbNmzShZsiQA+fLlS3YGkUdxcXTgPy3KEOjjxpi1xxi56gjnw27zRZOSODnogQMREZEnpbtpOvdmzXzkzurOpYhoRq48bHYcERH5ryJFilCtWjUmT54MwNGjR1m3bh2dOnUCIC4ujkGDBlGyZEmyZMmCp6cny5cv5/Tp00k6/oEDBwgKCrIXpACqVq2aqN2sWbOoXr06/v7+eHp68vnnnyf5HP97rtKlS9sLUgDVq1fHZrNx6NAh+7bixYvj4OBg/zkgIIDLly8n61z/e86goCB7QQqgWLFi+Pj4cODAAQB69uzJG2+8QXBwMF9//TXHjh2zt3333XcZPHgw1atXp1+/fo81sbxIUlitFj6sW4QvmpTAaoHZW8/SadpWIqNjzY4mIiLy1NOwm3TO1cmBAS8Xp8OULUzZcJJXKgRR2D+T2bFERFKPk3v8iCWzzp0MnTp1onv37nz//fdMmTKF/PnzU7NmTQCGDRvGt99+y8iRIylZsiQeHh706NGDmJiYFIu7ceNG2rRpw4ABAwgJCcHb25tffvmFESNGpNg5/te/l4y2WCzYbLZUORfErxz46quvsnTpUn7//Xf69evHL7/8QpMmTXjjjTcICQlh6dKlrFixgq+++ooRI0bQvXv3VMsjz7Y2lXPj7+VKt5k7+OvwFVqM28iUjhXx83I1O5qIiMhTSyOlngK1CmcnpLgfcTaDPgs16bmIZHAWS/wjdGa8kjlPTIsWLbBarcycOZPp06fz+uuv2+eaWb9+PY0bN+a1116jdOnS5MuXj8OHkz7itWjRopw5c4YLFy7Yt/3zzz8J2mzYsIHcuXPz2WefUaFCBQoWLMipU6cStHF2diYuLu6R59q1axdRUVH2bevXr8dqtVK4cOEkZ06Oe9d35sz/Tx69f/9+wsLCKFasmH1boUKFeP/991mxYgVNmzZlypQp9veCgoJ46623mD9/Pr169WLChAmpklXkntpF/filSxWyeTqz/0IETcds4PClm2bHEhEReWqpKPWU6NuoOG5ODmw+cZ1fd5wzO46IiACenp60bNmSTz75hAsXLtChQwf7ewULFmTlypVs2LCBAwcO8OabbyZYWe5RgoODKVSoEO3bt2fXrl2sW7eOzz77LEGbggULcvr0aX755ReOHTvGqFGj+PXXXxO0yZMnDydOnGDnzp1cvXqV6OjoROdq06YNrq6utG/fnr1797JmzRq6d+9O27Zt7fNJPa64uDh27tyZ4HXgwAGCg4MpWbIkbdq0Yfv27WzevJl27dpRs2ZNKlSowO3bt+nWrRtr167l1KlTrF+/ni1btlC0aFEAevTowfLlyzlx4gTbt29nzZo19vdEUlPpIB/md61OvmwenAu7TbOxG9h47JrZsURERJ5KKko9JXL4uNG9dgEAvvztAOG3H38JbhERSTmdOnXixo0bhISEJJj/6fPPP6dcuXKEhIRQq1Yt/P39CQ0NTfJxrVYrv/76K7dv36ZSpUq88cYbfPHFFwnavPzyy7z//vt069aNMmXKsGHDBvr06ZOgTbNmzahbty4vvPACvr6+/Pzzz4nO5e7uzvLly7l+/ToVK1akefPm1K5dm9GjRyfvw7iPyMhIypYtm+DVqFEjLBYLCxcuJHPmzDz//PMEBweTL18+Zs2aBYCDgwPXrl2jXbt2FCpUiBYtWlCvXj0GDBgAxBe73nnnHYoWLUrdunUpVKgQY8aMeeK8IkmRK6s787pWo0LuzNy8E0v7yZtZuFNfGoqIiCSXxdCzYIlERETg7e1NeHg4Xl5eZsexi4m1Ue/bvzh2JYr2VXMzoHEJsyOJiDyRO3fucOLECfLmzYurq+ZlkdTxsN+z9HrPz6gy2ud9524c78/aye97LwLwUd0ivFUzn/0xXhERkWdVUu/5Gin1FHF2tDLov4WoGf+cYu+5cJMTiYiIiDy7XJ0c+P7VcnR6Li8AQ5YdpM/CvcTZ9J2viIhIUqgo9ZSpViAbjUoHYjPg8wV7sanTIyIiImIaq9VCn4bF6NuwGBYL/PjPad6csZVbMbFmRxMREUn3VJR6Cn3eoCieLo7sPBPG7K1nHr2DiIiIiKSq15/Ly5hXy+HiaGXVgcu0Hv8PVyMTLywgIiIi/09FqaeQn5crPYILAvHDxG9ExZicSERERETqlQxgZufKZHZ3YtfZcJqO2cDxK5FmxxIREUm3VJR6SrWvlofCfpm4cesuQ5cfMjuOiIiIiADlc2dhXtdq5Mrizunrt2g2dgPbTl03O5aIiEi6pKLUU8rJwcqg0PhJz3/ZcpqdZ8LMDSQi8gRsNpvZESQD0++XpLV8vp7Mf7sapXN6c+PWXV6dsIlley+YHUtERCTdcTQ7gDy+Snmz0LRcDuZvP8fnC/aw8J3ncLBqCWIReXo4OztjtVo5f/48vr6+ODs7ayl1STGGYRATE8OVK1ewWq04OzubHUmeIdk8Xfi5SxXe/XkHqw5cputP2+nToBiv/3elPhEREVFR6qn3Sb2irNx/ib3nIpi56RRtq+YxO5KISJJZrVby5s3LhQsXOH/+vNlxJINyd3cnV65cWK0aIC5py93ZkR/aVqDfor38+M9pBi7Zz7mw23xWvyhWfZEoIiKiotTTzjeTCx+EFKbvwn0MW36IeiUDyObpYnYsEZEkc3Z2JleuXMTGxhIXF2d2HMlgHBwccHR01Ag8MY2D1cKgxiXI4ePOkGUHmfT3CS6E3+Y/Lcrg6uRgdjwRERFTqSiVAbSpnJvZW8+w91wEX/12kBEtSpsdSUQkWSwWC05OTjg5OZkdRUQkxVksFrrWyk+gjyu95+zitz0XuRyxiQntKpDZQ4+ViojIs0vj2DOAe9/AWSwwb/tZtpzUCi8iIiIi6U3jMjmY/nplMrk6svXUDZqN28CZ67fMjiUiImIaFaUyiLK5MtOqYhAAfRbsJTZOKw2JiIg8rb7//nvy5MmDq6srlStXZvPmzQ9tP2fOHIoUKYKrqyslS5bkt99+S/C+YRj07duXgIAA3NzcCA4O5siRIwnaXL9+nTZt2uDl5YWPjw+dOnUiMjLyvuc7evQomTJlwsfH54mu81lUNX9W5nWtRqC3K8evRNFkzHp2nw0zO5aIiIgpVJTKQD4IKYKPuxMHL95k2sZTZscRERGRxzBr1ix69uxJv3792L59O6VLlyYkJITLly/ft/2GDRto3bo1nTp1YseOHYSGhhIaGsrevXvtbYYOHcqoUaMYN24cmzZtwsPDg5CQEO7cuWNv06ZNG/bt28fKlStZsmQJf/31F126dEl0vrt379K6dWtq1KiR8hf/jCjkl4lf36lOsQAvrkbG0PKHf1h94JLZsURERNKcxTAMw+wQ6U1ERATe3t6Eh4fj5eVldpxk+XnzaT6ZvwdPF0dW96qJn5er2ZFERETSrfR4z69cuTIVK1Zk9OjRANhsNoKCgujevTsff/xxovYtW7YkKiqKJUuW2LdVqVKFMmXKMG7cOAzDIDAwkF69etG7d28AwsPD8fPzY+rUqbRq1YoDBw5QrFgxtmzZQoUKFQBYtmwZ9evX5+zZswQGBtqP/dFHH3H+/Hlq165Njx49CAsLS/K1pcfP20yR0bG8/dN2/jp8BasFBoWWoE3l3GbHEhEReWJJvedrpFQG07JCEGWCfIiMjuWLpQfMjiMiIiLJEBMTw7Zt2wgODrZvs1qtBAcHs3Hjxvvus3HjxgTtAUJCQuztT5w4wcWLFxO08fb2pnLlyvY2GzduxMfHx16QAggODsZqtbJp0yb7tj/++IM5c+bw/fffJ+l6oqOjiYiISPCS/+fp4sik9hVoUSEnNgM++3UvQ5cdxGbTd8YiIvJsUFEqg7FaLQwOLYHVAot2nWfD0atmRxIREZEkunr1KnFxcfj5+SXY7ufnx8WLF++7z8WLFx/a/t4/H9Ume/bsCd53dHQkS5Ys9jbXrl2jQ4cOTJ06NcmjnL766iu8vb3tr6CgoCTt9yxxcrAypFkpegQXBGDM2mP0nL2TmFjNDyoiIhmfilIZUIkc3rxWJX7od5+Fe9WpERERkSfWuXNnXn31VZ5//vkk7/PJJ58QHh5uf505cyYVEz69LBYLPYILMax5KRytFhbsPE/7yZsJv33X7GgiIiKpSkWpDKrXS4XJ5unMsStRTPr7hNlxREREJAmyZcuGg4MDly4lnPT60qVL+Pv733cff3//h7a/989Htfn3ROqxsbFcv37d3uaPP/5g+PDhODo64ujoSKdOnQgPD8fR0ZHJkyffN5uLiwteXl4JXvJgr1QIYnKHini6OLLx+DVeGbeB82G3zY4lIiKSalSUyqC83Zz4pF5RAEatPsI5dWhERETSPWdnZ8qXL8/q1avt22w2G6tXr6Zq1ar33adq1aoJ2gOsXLnS3j5v3rz4+/snaBMREcGmTZvsbapWrUpYWBjbtm2zt/njjz+w2WxUrlwZiJ93aufOnfbXwIEDyZQpEzt37qRJkyYp8wEIzxfyZdabVcieyYXDlyJpMmY9+89rLi4REcmYVJTKwJqWy0GlPFm4fTeOQYv3mx1HREREkqBnz55MmDCBadOmceDAAbp27UpUVBQdO3YEoF27dnzyySf29u+99x7Lli1jxIgRHDx4kP79+7N161a6desG/PfRsB49GDx4MIsWLWLPnj20a9eOwMBAQkNDAShatCh169alc+fObN68mfXr19OtWzdatWplX3mvaNGilChRwv7KkSMHVquVEiVKkDlz5rT9kDK44oHe/PpOdQr5eXIpIpoWP2xk3ZErZscSERFJcemiKPX999+TJ08eXF1dqVy5Mps3b35g2/nz51OhQgV8fHzw8PCgTJkyzJgxI0EbwzDo27cvAQEBuLm5ERwczJEjR1L7MtIdi8XCwNDiOFgtLNt3kbWHLj96JxERETFVy5YtGT58OH379qVMmTLs3LmTZcuW2ScqP336NBcuXLC3r1atGjNnzmT8+PGULl2auXPnsmDBAkqUKGFv8+GHH9K9e3e6dOlCxYoViYyMZNmyZbi6utrb/PTTTxQpUoTatWtTv359nnvuOcaPH592Fy4J5PBxY85b1aiSLwuR0bF0nLKFOVs1J5eIiGQsFsMwTF1zdtasWbRr145x48ZRuXJlRo4cyZw5czh06FCiVWAA1q5dy40bNyhSpAjOzs4sWbKEXr16sXTpUkJCQgAYMmQIX331FdOmTSNv3rz06dOHPXv2sH///gSdrweJiIjA29ub8PDwDDH3waAl+5n09wnyZHVnWY/ncXVyMDuSiIhIupDR7vnpnT7v5IuOjeOjubtZsPM8AO8HF+Ld2gWwWCwmJxMREXmwpN7zTS9KVa5cmYoVKzJ69Gggft6EoKAgunfvzscff5ykY5QrV44GDRowaNAgDMMgMDCQXr160bt3bwDCw8Px8/Nj6tSptGrV6pHHy2gdppt37lJ7xJ9cvhlNzzqFeLd2QbMjiYiIpAsZ7Z6f3unzfjw2m8HwFYcYs/YYAC0q5OSLJiVxckgXDz2IiIgkktR7vql3spiYGLZt20ZwcLB9m9VqJTg4mI0bNz5yf8MwWL16NYcOHbIvT3zixAkuXryY4Jje3t5Urlz5gceMjo4mIiIiwSsjyeTqxOcNiwHw/ZqjnLl+y+REIiIiIpJUVquFD+sWYXBoCawWmL31LJ2mbSUyOtbsaCIiIk/E1KLU1atXiYuLs8+RcI+fnx8XL1584H7h4eF4enri7OxMgwYN+O6776hTpw6Afb/kHPOrr77C29vb/goKCnqSy0qXGpUKoFr+rETH2ui/aJ/ZcUREREQkmV6rkpsJ7Srg5uTAX4ev0PKHjVyOuGN2LBERkcf2VI75vbf88JYtW/jiiy/o2bMna9eufezjffLJJ4SHh9tfZ85kvEkkLRYLAxuXwMnBwuqDl1m5/5LZkUREREQkmWoX9eOXLlXI5unMvvMRNBmzgSOXbpodS0RE5LGYWpTKli0bDg4OXLqUsEBy6dIl/P39H7if1WqlQIEClClThl69etG8eXO++uorAPt+yTmmi4sLXl5eCV4ZUYHsnrxRIx8A/Rft43ZMnMmJRERERCS5Sgf5ML9rdfJl8+Bc2G2ajt3AxmPXzI4lIiKSbKYWpZydnSlfvjyrV6+2b7PZbKxevZqqVasm+Tg2m43o6GgA8ubNi7+/f4JjRkREsGnTpmQdM6Pq/mIBcvi4cS7sNt+vOWp2HBERERF5DLmyujOvazUq5M7MzTuxtJ+8mUW7zpsdS0REJFlMf3yvZ8+eTJgwgWnTpnHgwAG6du1KVFQUHTt2BKBdu3Z88skn9vZfffUVK1eu5Pjx4xw4cIARI0YwY8YMXnvtNSD+MbUePXowePBgFi1axJ49e2jXrh2BgYGEhoaacYnpiruzI33+O+n5+L+Oc/xKpMmJRERERORxZPZw5sc3KlOvhD8xcTbe/XkH4/48hsmLa4uIiCSZo9kBWrZsyZUrV+jbty8XL16kTJkyLFu2zD5R+enTp7Fa/792FhUVxdtvv83Zs2dxc3OjSJEi/Pjjj7Rs2dLe5sMPPyQqKoouXboQFhbGc889x7Jly3B1dU3z60uPQor7UbOQL38evkK/RfuY/nolLBaL2bFEREREJJlcnRz4/tVyfPHbASb9fYKvfz/I2Ru3GPByCRys6t+JiEj6ZjH0VUoiEREReHt7Ex4enmHnlzp5NYqXRv5FTKyNMW3KUb9kgNmRRERE0tyzcM9PT/R5p65Jf59g8NL9GAYEF/Xju9ZlcXN2MDuWiIg8g5J6zzf98T0xR55sHrxVMz8AAxfvJyo61uREIiIiIvIkOj2XlzGvlsPF0cqqA5doNeEfrkZGmx1LRETkgVSUeoa9XSs/QVncuBhxh1Grj5gdR0RERESeUL2SAczsXBkfdyd2nQmj6ZgNmkNURETSLRWlnmGuTg4MeLk4ED/c+/ClmyYnEhEREZEnVT53FuZ3rUauLO6cvn6LZmM3sO3UdbNjiYiIJKKi1DPuxSJ+1CnmR6zNoM+CvVqtRURERCQDyOfryfy3q1E6pzc3bt3l1QmbWLb3otmxREREElBRSujXqBiuTlY2nbjOwp3nzY4jIiIiIikgm6cLP3epQnDR7ETH2uj60zamrD9hdiwRERE7FaWEnJnd6f5iQQAGLz1AxJ27JicSERERkZTg7uzIuNfK81qVXBgGDFi8n0FL9mOzaXS8iIiYT0UpAeCNGnnJl82Dq5HR/GfFYbPjiIiIiEgKcXSwMqhxCT6qWwSIn0u0+887uHM3zuRkIiLyrFNRSgBwcXRgQOP4Sc+nbzzJ/vMRJicSERERkZRisVjoWis/37Yqg5ODhaV7LtB20ibCbsWYHU1ERJ5hKkqJXY2CvjQoGYDNgD4L92pYt4iIiEgG07hMDqa/XplMro5sOXmDpmM3cOb6LbNjiYjIM0pFKUng84ZFcXd2YNupG8zdftbsOCIiIiKSwqrmz8q8rtUI9Hbl+JUomoxZz+6zYWbHEhGRZ5CKUpJAgLcbPYLjJz3/+veDGtItIiIikgEV8svEr+9Up1iAF1cjY2j5wz/8cfCS2bFEROQZo6KUJNKxel4K+XlyPSqGYcsPmR1HRERERFKBn5crs9+qSo2C2bh9N443pm1l5qbTZscSEZFniIpSkoiTg5WBjUsAMHPzaXadCTM3kIiIiIikCk8XRyZ3qMgr5XNiM+DTX/cwdNlBDENzi4qISOpTUUruq0q+rDQpmwPjv5Oex2nScxEREZEMycnBytDmpexTOIxZe4z3Z+0kJtZmcjIREcnoVJSSB/qkfhEyuTiy+2w4P2/WUG4RERGRjMpisdAjuBBDm5fC0Wphwc7ztJ+8mfDbd82OJiIiGZiKUvJA2TO50vOlQgAMW36Ia5HRJicSERERkdTUokIQkztUxMPZgY3Hr/HKuA2cD7ttdiwREcmgVJSSh2pbJTfFArwIv32XIcsOmh1HRERERFLZ84V8mf1WVbJncuHwpUiajFnP/vMRZscSEZEMSEUpeShHByuDQuMnPZ+99SzbTl03OZGIiIiIpLbigd78+k51Cvl5cikimhY/bGTdkStmxxIRkQxGRSl5pPK5M9OiQk4APl+wj9g4TXopIiIiktHl8HFjzlvVqJIvC5HRsXScsoU5W8+YHUtERDIQFaUkST6qWwRvNycOXIhgxj+nzI4jIiIiImnA282Jaa9XonGZQGJtBh/M3c23q45gGFqZWUREnpyKUpIkWT1d+LBuYQD+s+IwlyPumJxIRERERNKCi6MD37Qow9u18gPwzarDfDxvD3c1el5ERJ6QilKSZK0q5qJ0Tm9uRsfy5W8HzI4jIiIiImnEarXwYd0iDA4tgdUCs7ae4Y1pW4mMjjU7moiIPMVUlJIkc7BaGBRaAosFFuw8z8Zj18yOJCIiIiJp6LUquZnQrgJuTg78efgKLX/YqBH0IiLy2FSUkmQpldOHNpVzAdB34V4N2xYRERF5xtQu6scvXaqQzdOZfecjaDJmA0cu3TQ7loiIPIVUlJJk6/1SYbJ4OHPkciRT1p8wO46IiIiIpLHSQT7M71qdfNk8OBd2m2ZjN/DPcY2iFxGR5FFRSpLNx92Zj+sVAWDkqiNcCL9tciIRERERSWu5srozr2s1yufOTMSdWNpN2syiXefNjiUiIk8RFaXksTQvl5PyuTNzKyaOwUs06bmIiIjIsyizhzM/vVGZeiX8iYmz8e7POxj35zEMwzA7moiIPAVUlJLHYrVaGNQ4fvWVpXsu8NfhK2ZHEhERERETuDo58P2r5ej0XF4Avv79IH0X7iPOpsKUiIg8nIpS8tiKBXrRvloeAPot2kd0bJy5gURERETEFFarhT4Ni9GnYTEsFpjxzynenLGN2zHqH4qIyIOpKCVP5P06hfDN5MKJq1FM+Ou42XFERERExESdnsvLmFfL4eJoZdWBS7Sa8A9XI6PNjiUiIumUilLyRLxcnfi8QVEARq85ypnrt0xOJCIiIiJmqlcygJmdK+Pj7sSuM2E0HbOBE1ejzI4lIiLpkIpSaS0mCq4cNjtFinq5dCBV8mXhzl0bAxbvNzuOiIiIiJisfO4szOtajaAsbpy+foumY9az7dQNs2OJiEg6o6JUWoqOhJ9egSl14dI+s9OkGIslftJzR6uFVQcusfrAJbMjiYiIiIjJ8vt6Mr9rdUrn9ObGrbu8OuEflu29aHYsERFJR1SUSktGHNy9DbeuwbSX4fIBsxOlmIJ+mewrrvRfvI87dzWppYiIiMizzjeTCz93qUJw0exEx9ro+tM2pqw/YXYsERFJJ1SUSkuu3tB2PgSUhltXYVojuHzQ7FQp5t3aBQnwduXM9duMWXvM7DgiIiIikg64Ozsy7rXyvFYlF4YBAxbvZ/CS/dhshtnRRETEZCpKpTW3zNB2AfiXhKgr8YWpDDLHlIeLI30aFgNg3J/HOKkJLUVEREQEcHSwMqhxCT6qWwSAiX+foPvPOzS6XkTkGaeilBncs0C7ReBXEqIuxxemrh41O1WKqFfCnxoFsxETa6Pfon0Yhr4BExEREZH4eUi71srPt63K4ORgYemeC7SdtImwWzFmRxMREZOoKGUW9yzQbiFkLw6RF2FaQ7j29D/yZrFYGNi4BM4OVv48fIXl+zSZpYiIiIj8v8ZlcjD99cpkcnVky8kbNB27gTPXb5kdS0RETKCilJk8skL7RZC9GNy8AFMzRmEqbzYP3qyZD4CBi/dzKybW5EQiIiIikp5UzZ+VeV2rEejtyvErUTQZs4HdZ8PMjiUiImlMRSmzeWSLf5TPtwjcPB//KN/1p39FkrdrFSBnZjfOh99h1OqM8WiiiIiIiKScQn6Z+PWd6hQL8OJqZDQtf/iHPw5eMjuWiIikIRWl0gNPX2i/GLIVgohz8YWpG6fMTvVE3Jwd6NeoOAAT1x3n6OWbJicSERERkfTGz8uV2W9VpUbBbNy+G8cb07Yyc9Nps2OJiEgaUVEqvfDMHl+YyloQws/EP8oX9nTfkOsU86N2kezE2gz6LtSk5yIiIiKSmKeLI5M7VOSV8jmxGfDpr3sYtvyg+o4iIs8AFaXSk0z+8YWpLPkh/DRMbQBhZ8xO9UT6v1wcF0crG45dY/HuC2bHEREREZF0yMnBytDmpegRXBCA79cco9ecXcTZVJgSEcnIVJRKb7wCoMMSyJIvfqTUtIYQftbsVI8tKIs777xQAIDBS/Zz885dkxOJiIiISHpksVjoEVyIoc1L4Wi1MH/7OT5fsFcjpkREMjAVpdIjr0BovwQy54EbJ+Mf5Ys4b3aqx9bl+XzkyerO5ZvRjFx1xOw4IiIiIpKOtagQxHety2K1wM+bTzNixWGzI4mISCpRUSq98s4RX5jyyQ03Tvy3MPV0Pv7m6uTAgMYlAJi64SQHL0aYnEhERERE0rN6JQP4oklJAEavOcrEdcdNTiQiIqlBRan0zCco/lE+n1xw/Vj8qnw3L5qd6rHULORLvRL+xNkM+mgYtoiIiIg8QutKufggpDAAg5ceYN62p3dKCxERuT8VpdI7n1zxI6a8g+Dakf8Wpi6Zneqx9GlYDHdnB7acvMG87efMjiMiIiIi6dzbtfLzxnN5Afhw3m5W7X86+8EiInJ/Kko9DTLnjl+VzysnXD0M01+GyCtmp0q2QB833q0dv6LKV78dIPyWJj0XERERkQezWCx8Wr8oTcvlIM5m8M7M7Ww+cd3sWCIikkJUlHpaZMkLHRZDpkC4cjB+xFTUVbNTJdvr1fNSILsn16JiGLHykNlxRERERCSds1otDGlWiuCi2YmOtdFp6hb2n9ccpSIiGYGKUk+TLPni55jKFABXDsC0lyHqmtmpksXZ0crAxsUB+PGfU+w9F25yIhERERFJ75wcrIx+tRyV8mThZnQs7SZv5tS1KLNjiYjIE1JR6mmTNX/8HFOe/nB5X/yjfLeeriHM1fJn4+XSgdgM+HzBXmw2TXouIiIiIg/n6uTAxA4VKBrgxdXIaF6btInLEXfMjiUiIk9ARamnUbYC8XNMeWSHS3ufysLU5w2K4uniyM4zYczaesbsOCIiIiLyFPBydWLa6xXJndWdM9dv027yZs1TKiLyFFNR6mnlWyj+UT4PX7i4B2aEwu0bZqdKsuxerrxfpxAAQ5Yd5HpUjMmJRERERORpkD2TKz92qkz2TC4cvHiTTtO2cDsmzuxYIiLyGFSUepr5Fo4fMeWeDS7sghlN4HaY2amSrH3V3BTxz0TYrbsMXXbQ7DgiIiIi8pQIyuLO9E6V8HJ1ZOupG7z90zbuxtnMjiUiIsmkotTTLnvR/xamssL5HfGFqTtPx+Thjg5WBoeWAOCXLWfYfvrpGeklIiIiIuYq4u/F5A4VcXWysubQFT6Ys0tzlYqIPGVUlMoI/IpBu0XglgXOb4cfm8Gdp2OZ3Ap5stC8fE4A+izYS5w6EiIiIiKSRBXyZGFsm/I4Wi0s2HmegUv2YxjqT4qIPC1UlMoo/EtAu4XglhnOboGfmkP0TbNTJcnH9Yrg5erIvvMR/PjPKbPjiIiIiMhT5IUi2Rn+SmkApm44yeg/jpqcSEREkkpFqYwkoBS0XQCuPnBmE/z0CkRHmp3qkbJ5uvBBSGEAhq84xJWb0SYnEhEREZGnSWjZHPRrVAyAESsPM0NfdIqIPBVUlMpoAstAuwXg6g2nNz41halXK+emZA5vbt6J5avfD5gdR0RERESeMh2r5+XdFwsA0HfhXpbsPm9yIhEReZR0UZT6/vvvyZMnD66urlSuXJnNmzc/sO2ECROoUaMGmTNnJnPmzAQHBydq36FDBywWS4JX3bp1U/sy0o/AstD2V3DxhtMbYGZLiIkyO9VDOVgtDAotgcUC87efY/OJ62ZHEhEREZGnzPt1CvFalVwYBrw/ayd/Hb5idiQREXkI04tSs2bNomfPnvTr14/t27dTunRpQkJCuHz58n3br127ltatW7NmzRo2btxIUFAQL730EufOnUvQrm7duly4cMH++vnnn9PictKPHOWh7Xxw8YJTf/+3MHXL7FQPVSbIh1YVcwHxk55rWV8REXlWJecLO4A5c+ZQpEgRXF1dKVmyJL/99luC9w3DoG/fvgQEBODm5kZwcDBHjhxJ0Ob69eu0adMGLy8vfHx86NSpE5GR/z/a+tChQ7zwwgv4+fnh6upKvnz5+Pzzz7l7927KXbjIE7JYLAx4uQQNSwVwN87gzRnb2KEVnkVE0i3Ti1L/+c9/6Ny5Mx07dqRYsWKMGzcOd3d3Jk+efN/2P/30E2+//TZlypShSJEiTJw4EZvNxurVqxO0c3Fxwd/f3/7KnDlzWlxO+pKzArw2D5w94eQ6+KU13L1tdqqH+jCkMJndnTh06SbTNpw0O46IiEiaS+4Xdhs2bKB169Z06tSJHTt2EBoaSmhoKHv37rW3GTp0KKNGjWLcuHFs2rQJDw8PQkJCuHPnjr1NmzZt2LdvHytXrmTJkiX89ddfdOnSxf6+k5MT7dq1Y8WKFRw6dIiRI0cyYcIE+vXrl3ofhshjcLBa+E+LMtQomI3bd+PoOHULRy49HQsAiYg8ayyGiWumxsTE4O7uzty5cwkNDbVvb9++PWFhYSxcuPCRx7h58ybZs2dnzpw5NGzYEIh/fG/BggU4OzuTOXNmXnzxRQYPHkzWrFmTlCsiIgJvb2/Cw8Px8vJ6rGtLV07/Az82g5hIyPcCtP4ZnNzMTvVAs7ac5qN5e/BwdmB1r1r4e7uaHUlERDKo9HjPr1y5MhUrVmT06NEA2Gw2goKC6N69Ox9//HGi9i1btiQqKoolS5bYt1WpUoUyZcowbtw4DMMgMDCQXr160bt3bwDCw8Px8/Nj6tSptGrVigMHDlCsWDG2bNlChQoVAFi2bBn169fn7NmzBAYG3jdrz5492bJlC+vWrUvStaXHz1syrqjoWNpM3MTOM2H4e7kyt2tVcmZ2NzuWiMgzIan3fFNHSl29epW4uDj8/PwSbPfz8+PixYtJOsZHH31EYGAgwcHB9m1169Zl+vTprF69miFDhvDnn39Sr1494uLi7nuM6OhoIiIiErwylFxVoM1ccPKA42vglzZw986j9zPJK+WDKJfLh6iYOAYv3W92HBERkTQTExPDtm3bEvRrrFYrwcHBbNy48b77bNy4MUF7gJCQEHv7EydOcPHixQRtvL29qVy5sr3Nxo0b8fHxsRekAIKDg7FarWzatOm+5z169CjLli2jZs2aD7yeDN/HknTNw8WRKR0qUjC7Jxcj7tBu0mauRWqVZxGR9MT0x/eexNdff80vv/zCr7/+iqvr/4+madWqFS+//DIlS5YkNDSUJUuWsGXLFtauXXvf43z11Vd4e3vbX0FBQWl0BWkod1VoMwec3OHYapjdFmLT503ZarUwsHEJrBZYsvsC649eNTuSiIhImnicL+wuXrz40Pb3/vmoNtmzZ0/wvqOjI1myZEl03mrVquHq6krBggWpUaMGAwcOfOD1PBN9LEnXMns4M71TJXL4uHH8ahQdpmzh5h3NgyYikl6YWpTKli0bDg4OXLp0KcH2S5cu4e/v/9B9hw8fztdff82KFSsoVarUQ9vmy5ePbNmycfTo0fu+/8knnxAeHm5/nTlzJnkX8rTIUx1enQ2ObnBkBcxul24LUyVyeNO2Sm4A+izcS3Ts/Ue5iYiISNqaNWsW27dvZ+bMmSxdupThw4c/sO0z08eSdC3A240ZnSqR1cOZPefC6TJ9G3fuqm8pIpIemFqUcnZ2pnz58gkmKb83aXnVqlUfuN/QoUMZNGgQy5YtSzDM/EHOnj3LtWvXCAgIuO/7Li4ueHl5JXhlWHlrwKuzwNEVDi+DOR0gNsbsVPfV86XCZPN04fiVKCb9fcLsOCIiIqnucb6w8/f3f2j7e/98VJt/T6QeGxvL9evXE503KCiIYsWK0bp1a77++mv69+//wCkSnqk+lqRr+Xw9mdqxEp4ujmw8fo33ftlBrFZ6FhExnemP7/Xs2ZMJEyYwbdo0Dhw4QNeuXYmKiqJjx44AtGvXjk8++cTefsiQIfTp04fJkyeTJ08eLl68yMWLF+1LFkdGRvLBBx/wzz//cPLkSVavXk3jxo0pUKAAISEhplxjupOvJrT+Jb4wdeg3mNsR4tLfMGZvNyc+rV8EgO9WH+VcWPpeOVBERORJPc4XdlWrVk20CvHKlSvt7fPmzYu/v3+CNhEREWzatMnepmrVqoSFhbFt2zZ7mz/++AObzUblypUfmNdms3H37l1sNv3PvaR/JXN6M75deZwdrCzfd4nPft2LiWs+iYgI6aAo1bJlS4YPH07fvn0pU6YMO3fuZNmyZfZ5D06fPs2FCxfs7ceOHUtMTAzNmzcnICDA/ro3dNzBwYHdu3fz8ssvU6hQITp16kT58uVZt24dLi4uplxjupT/BWg1Exxc4OCSdFuYalI2B5XyZuH23TgGLt5ndhwREZFUl9wv7N577z2WLVvGiBEjOHjwIP3792fr1q1069YNAIvFQo8ePRg8eDCLFi1iz549tGvXjsDAQPvqx0WLFqVu3bp07tyZzZs3s379erp160arVq3sK+/99NNPzJ49mwMHDnD8+HFmz57NJ598QsuWLXFyckrbD0nkMVXLn41RrctitcCsrWcYsuyQ2ZFERJ5pFkNfDyTyTC1XfGQV/NIa4mKgWCg0mwQOjmanSuDQxZvUH7WOOJvBlI4VeaFw9kfvJCIikgTp9Z4/evRohg0bxsWLFylTpgyjRo2yj1iqVasWefLkYerUqfb2c+bM4fPPP+fkyZMULFiQoUOHUr9+ffv7hmHQr18/xo8fT1hYGM899xxjxoyhUKFC9jbXr1+nW7duLF68GKvVSrNmzRg1ahSenp5A/FxSQ4cO5fDhwxiGQe7cuXnttdd4//33Eyw48zDp9fOWZ8/sLWf4cN5uAD6tX4Quz+c3OZGISMaS1Hu+ilL38cx1mA4vh1/agO0uFG8KTSeku8LUF0v3M2HdCXJndWd5j+dxdXIwO5KIiGQAz9w932T6vCU9GffnMb7+/SAAQ5uXokUFrQ4pIpJSknrPN/3xPUkHCoVAyxlgdYJ98+HXNyEu1uxUCbwXXAg/LxdOXbvFuD+PmR1HRERERJ5yb9XMz5vP5wPg43m7WbHvosmJRESePSpKSbzC9aDFNLA6wt65sKAr2NLPUrmeLo70aVgMgDFrj3HqWpTJiURERETkafdxvSK0qJATmwHdft7BP8evmR1JROSZoqKU/L8iDeCVqfGFqT2zYeE76aow1aBkAM8VyEZMrI3+i/ZptRQREREReSIWi4Uvm5TkpWJ+xMTaeGPaVvaeCzc7lojIM0NFKUmoaCNoPhksDrDrZ1jUHdLJMs8Wi4UBjYvj5GBhzaErrNx/yexIIiIiIvKUc3SwMqp1WSrnzUJkdCztJ2/mxFWNyhcRSQsqSklixRpD80nxhamdP8Hid9NNYSq/ryeda8Q/+z9g8X5ux6SfkVwiIiIi8nRydXJgYvsKlMjhxbWoGF6buImL4XfMjiUikuGpKCX3V7wJNJsAFivsmAFLeqSbwlS3FwuQw8eNc2G3Gb3miNlxRERERCQDyOTqxNSOlcibzYNzYbdpN3kTYbdizI4lIpKhqSglD1aiGTQZH1+Y2j4NfusF6WAeJ3dnR/o2ip/0fPxfxzl2JdLkRCIiIv/vzh2NrhB5WmXzdGH665Xw83Lh8KVIOk7dwq2Y9LUqtYhIRqKilDxcqVcgdBxgga2T4bfe6aIw9VIxP14o7MvdOIN+CzXpuYiImMtmszFo0CBy5MiBp6cnx48fB6BPnz5MmjTJ5HQikhxBWdyZ0aky3m5O7DgdRtcftxMTmz6eGBARyWhUlJJHK90SQscAFtgyEX7/yPTClMViof/LxXF2tPL30ass3XPB1DwiIvJsGzx4MFOnTmXo0KE4Ozvbt5coUYKJEyeamExEHkchv0xM6VgRNycH/jx8hV5zdmGz6UtQEZGUpqKUJE2ZV6HxaMACm3+AZZ+YXpjKndWDt2vlB2DQkv1ERmtotYiImGP69OmMHz+eNm3a4ODgYN9eunRpDh48aGIyEXlc5XJlZlzb8jg5WFi86zz9F2t0vohISlNRSpKu7Gvw8qj4P28aCys+N70w9VbN/OTK4s6liGi+XXXY1CwiIvLsOnfuHAUKFEi03WazcffuXRMSiUhKqFnIlxEtymCxwPSNp/h2tRbZERFJSSpKSfKUawcNR8b/eeNoWNnX1MKUq5MDA14uDsDk9Sc5dPGmaVlEROTZVaxYMdatW5do+9y5cylbtqwJiUQkpbxcOpCB/+1vjlx1hGkbTpobSEQkA3E0O4A8hSp0BCMOlvaCDaPA6gC1+4HFYkqcF4pk56VifqzYf4k+C/cyq0sVLCZlERGRZ1Pfvn1p3749586dw2azMX/+fA4dOsT06dNZsmSJ2fFE5Am1rZqH61F3+WbVYfot2oePuxONy+QwO5aIyFNPI6Xk8VR8A+oPj//z39/AH4NMHTHVt1ExXJ2sbD5xnQU7z5mWQ0REnk2NGzdm8eLFrFq1Cg8PD/r27cuBAwdYvHgxderUMTueiKSAd2sXoEO1PAD0mr2LtYcumxtIRCQDUFFKHl+lzlBvaPyf142ANV+aFiVnZne6v1gQgC+WHiT8tubvEBGRtFWjRg1WrlzJ5cuXuXXrFn///TcvvfSS2bFEJIVYLBb6NixG4zKBxNoM3vpxG9tOXTc7lojIU01FKXkyld+EkK/i//zXUFj7tWlROtfIRz5fD65GRvPNSk16LiIiaSdfvnxcu3Yt0fawsDDy5ctnQiIRSQ1Wq4VhzUtTq7Avd+7a6Dhli+Y0FRF5AipKyZOr+ja8NDj+z2u/gj+HmRLD2dHKoMYlAJi+8SR7z4WbkkNERJ49J0+eJC4uLtH26Ohozp3TY+UiGYmzo5WxbcpTPndmIu7E0nbSJs5cv2V2LBGRp5ImOpeUUa07GLb41fjWDAarFWr0SvMY1Qtko2GpAJbsvkCfhXuZ91Y1rFZNei4iIqlj0aJF9j8vX74cb29v+89xcXGsXr2aPHnymJBMRFKTm7MDk9tXpMUPGzl06SZtJ21izlvV8M3kYnY0EZGnisUwTJydOp2KiIjA29ub8PBwvLy8zI7zdFn3H1g9IP7Pwf3huffTPMLF8DvUHrGWqJg4hjQrScuKudI8g4iIPB2e9J5vtcYPOrdYLPy7S+Xk5ESePHkYMWIEDRs2TJG8Tzv1sSSjuRRxh2ZjN3D2xm2KBXjxy5tV8HJ1MjuWiIjpknrP1+N7krJq9IQXP4//86r+sH5Umkfw93alR3AhAL7+/SA3omLSPIOIiDwbbDYbNpuNXLlycfnyZfvPNpuN6OhoDh06pIKUSAbm5+XKj50qk83Tmf0XInhj2lbu3E38KK+IiNyfilKS8p7/AGp9Gv/nlX1g4/dpHqFD9TwU8vPkxq27DFtxKM3PLyIiz5YTJ06QLVs2s2OIiAnyZPNg2uuVyOTiyOYT1+k2cwexcTazY4mIPBU0p5Skjlofxc8x9efXsPxTsFihStc0O72TQ/yk5y3H/8PPm0/TskIQpYN80uz8IiLy7ImKiuLPP//k9OnTxMQkHKX77rvvmpRKRNJC8UBvJravQLvJm1l14BIfz9/DsOalsFg0t6mIyMOoKCWpp9bHYMTBX8Ng2cdgcYDKXdLs9JXzZaVp2RzM33GOzxfsZcE71XHQpOciIpIKduzYQf369bl16xZRUVFkyZKFq1ev4u7uTvbs2VWUEnkGVM6XldGvluOtH7cxd9tZMrs78Wn9oipMiYg8hB7fk9RjscALn8FzPeN//v0D2DwhTSN8Ur8omVwd2XMunJmbT6fpuUVE5Nnx/vvv06hRI27cuIGbmxv//PMPp06donz58gwfPtzseCKSRuoU82NIs1IATFh3gnF/Hjc5kYhI+qailKQuiwVq94Xq78X//Ftv2Do5zU7vm8mF3i8VBmDYsoNcjYxOs3OLiMizY+fOnfTq1Qur1YqDgwPR0dEEBQUxdOhQPv30U7PjiUgaal4+J583KArAkGUH+UVfjIqIPJCKUpL6LBYIHgBVu8X/vOR92DY1zU7/WpXcFA/0IuJOLF//fjDNzisiIs8OJycnrNb4blX27Nk5fTr+f0K9vb05c+aMmdFExARv1MhH11r5Afj01z0s23vB5EQiIumTilKSNiwWeGkwVHkn/ufF78H2GWlyagerhUGhJQCYu+0sW09eT5PziojIs6Ns2bJs2bIFgJo1a9K3b19++uknevToQYkSJUxOJyJm+DCkMK0qBmEz4N2fd7Lh6FWzI4mIpDsqSknasVgg5Auo/N9V+BZ1hx0/pcmpy+XKTMsKQQB8vmCvlukVEZEU9eWXXxIQEADAF198QebMmenatStXrlzhhx9+MDmdiJjBYrHwRZOS1C3uT0ycjc7Tt7L7bJjZsURE0hWLYRiG2SHSm4iICLy9vQkPD8fLy8vsOBmPYcDvH8Lm8YAFQsdCmdapftrrUTG8OGItYbfu0qdhMTo9lzfVzykiIumb7vlpS5+3PIuiY+PoOGULG45dI4uHM3Peqkp+X0+zY4mIpKqk3vM1UkrSnsUC9YZChU6AAQu6wu7ZqX7aLB7OfBhSBIBvVh7mcsSdVD+niIg827Zv307Dhg3NjiEiJnJxdGB8uwqUyunN9agY2k7cxPmw22bHEhFJF1SUEnNYLFB/OJTvCBjw65uwZ26qn7ZVxSBKB/kQGR3LF78dSPXziYhIxrd8+XJ69+7Np59+yvHj8cu/Hzx4kNDQUCpWrIjNpkfGRZ51ni6OTOlQkXy+HpwPv0O7yZu5ERVjdiwREdOpKCXmsVqhwX+gXDswbDC/M+ydl8qntDC4cQksFli48zwbjmnCSREReXyTJk2iXr16TJ06lSFDhlClShV+/PFHqlatir+/P3v37uW3334zO6aIpANZPV2Y0akyAd6uHL0cSYepW4iKjjU7loiIqVSUEnNZrdDwWyj7Wnxhal5n2Pdrqp6yZE5vXqucG4C+C/cRE6tvsEVE5PF8++23DBkyhKtXrzJ79myuXr3KmDFj2LNnD+PGjaNo0aJmRxSRdCSHjxszOlUis7sTu86E8daP24iOjTM7loiIaVSUEvNZrdDoOyj9KhhxMLcT7F+Uqqfs/VJhsno4c/RyJJPXn0jVc4mISMZ17NgxXnnlFQCaNm2Ko6Mjw4YNI2fOnCYnE5H0qkD2TEzpWAl3ZwfWHblKz1m7iLNp7SkReTapKCXpg9UKjUdDqVb/LUx1hANLUu103u5OfFI//tvrb1cd0WSTIiLyWG7fvo27uzsQv/y7i4sLAQEBJqcSkfSuTJAP49tWwMnBwtI9F+izcC9aFF1EnkWOZgcQsbM6QOiY+KLUnjkwpwO0mA5F6qfK6ZqVy8GsLafZcvIGg5bsZ+xr5VPlPCIikrFNnDgRT8/45d1jY2OZOnUq2bJlS9Dm3XffNSOaiKRjzxXMxsiWZen283ZmbjpNVg9ner1U2OxYIiJpymKoJJ9IREQE3t7ehIeH4+XlZXacZ09cLPzaJX7Sc6sTtPwRCtdNlVMduBBBw+/+Js5mMO31StQs5Jsq5xERkfTpSe/5efLkwWKxPLSNxWKxr8r3rFMfSySxnzad4rNf9wLQt2ExXn8ur8mJRESeXFLv+RopJemPgyM0GR8/8fm+X2F2W2j5ExR6KcVPVTTAi/ZV8zB5/Qn6LdzL8vefx8XRIcXPIyIiGdPJkyfNjiAiT7k2lXNzIyqG4SsOM3DJfjJ7ONGkrOalE5Fng+aUkvTJwRGaToCiL0NcDMx6DY6uSpVTvV+nINkzuXDy2i3G/6lvskVEREQkbb3zQgFerx4/Qqr3nN38cfCSyYlERNKGilKSfjk4QfPJUKQhxEXDz6/CsT9S/DSZXJ34rEH8pOej1xzlzPVbKX4OEREREZEHsVgsfN6gKE3L5iDOZtD1x+1sOXnd7FgiIqlORSlJ3xycoPkUKNzgv4Wp1nB8bYqf5uXSgVTNl5XoWBsDFu9L8eOLiIiIiDyM1WphSPNSvFgkO9GxNl6fuoUDFyLMjiUikqpUlJL0z9EZXpkKhepB7B2Y2QqO/5mip7BYLAwKLY6Tg4VVBy6zar+GTIuIiIhI2nJysPL9q+WomCczN+/E0m7yZk5f0yh+Ecm4HqsodebMGc6ePWv/efPmzfTo0YPx48enWDCRBBydocU0KBgCsbdhZks4+XeKnqJA9kx0ei4fAP0X7+N2TFyKHl9ERERE5FHcnB2Y2L4iRfwzceVmNK9N2sTlm3fMjiUikioeqyj16quvsmbNGgAuXrxInTp12Lx5M5999hkDBw5M0YAido4u0GI6FKgTX5j66RU4tSFFT/Fu7QIEerty9sZtxqw9mqLHFhGRjCsiIuK+r5s3bxITE2N2PBF5yni7OTG9UyVyZXHn9PVbtJu0mfDbd82OJSKS4h6rKLV3714qVaoEwOzZsylRogQbNmzgp59+YurUqSmZTyQhJ1do+SPkrw13b8GPzeHUxhQ7vLuzI30aFgPghz+Pc+JqVIodW0REMi4fHx8yZ86c6OXj44Obmxu5c+emX79+2Gw2s6OKyFMieyZXfuxUGd9MLhy8eJM3pm3RSH4RyXAeqyh19+5dXFxcAFi1ahUvv/wyAEWKFOHChQspl07kfpxcodVPkO8FuBsFPzWH05tS7PB1S/jzfCFfYuJs9F24F8MwUuzYIiKSMU2dOpXAwEA+/fRTFixYwIIFC/j000/JkSMHY8eOpUuXLowaNYqvv/7a7Kgi8hTJldWd6a9XIpOrI1tO3qDbzO3cjVNxW0QyjscqShUvXpxx48axbt06Vq5cSd26dQE4f/48WbNmTdGAIvfl5AatZkLe5yEmEn5sBme2pMihLRYLA14ujrODlXVHrrJs78UUOa6IiGRc06ZNY8SIEQwaNIhGjRrRqFEjBg0axPDhw5k1axafffYZo0aNYvr06WZHFZGnTNEALyZ3qIiLo5XVBy/z4dzd2Gz60lREMobHKkoNGTKEH374gVq1atG6dWtKly4NwKJFi+yP9YmkOmd3aD0L8tSAmJvwY1M4uy1FDp03mwdv1Yyf9Hzgkv1ERcemyHFFRCRj2rBhA2XLlk20vWzZsmzcGP+Y+XPPPcfp06fTOpqIZAAV82Rh7GvlcLBa+HXHOQYvPaDR/CKSITxWUapWrVpcvXqVq1evMnnyZPv2Ll26MG7cuBQLJ/JIzu7w6izIXR2iI2BGEzi3PUUO/fYLBQjK4saF8DuM+uNIihxTREQypqCgICZNmpRo+6RJkwgKCgLg2rVrZM6cOa2jiUgG8WIRP4a/UgqAyetPMGbtMZMTiYg8uccqSt2+fZvo6Gh7x+rUqVOMHDmSQ4cOkT179hQNKPJIzh7w6mzIVQ2iw2FGKJzf+cSHdXVyoH+j4gBMWneCI5duPvExRUQkYxo+fDjffPMNpUuX5o033uCNN96gTJkyjBw5khEjRgCwZcsWWrZsaXJSEXmaNSmbk77/XZRn2PJD/LTplMmJRESezGMVpRo3bmyfEyEsLIzKlSszYsQIQkNDGTt2bIoGFEkSF09oMxuCqsCdcJjeGC7seuLD1i7qR3BRP2JtBn006bmIiDzAyy+/zMGDB6lXrx7Xr1/n+vXr1KtXj4MHD9KwYUMAunbtyn/+8x+Tk4rI0+715/LS/cUCAHy+YC9Ld2uhKRF5ej1WUWr79u3UqFEDgLlz5+Ln58epU6eYPn06o0aNStGAIknmkgnazIGcleBOWHxh6uKeJz5sv0bFcHWy8s/x6yzadf7Jc4qISIaUN29evv76a+bPn8/8+fP56quvyJMnj9mxRCQD6lmnEG0q58IwoMesHaw7csXsSCIij8XxcXa6desWmTJlAmDFihU0bdoUq9VKlSpVOHVKQ0jFRK5e8NpcmNEUzm2FaS9DhyXgV/yxDxmUxZ1uLxRg+IrDDF56gBeKZMfL1SkFQ4uISEYQFhbG5s2buXz5MjZbwiXb27VrZ1IqEcmILBYLAxuXIOz2XZbuvsCbM7Yxs3MVygT5mB1NRCRZHqsoVaBAARYsWECTJk1Yvnw577//PgCXL1/Gy8srRQOKJJurN7SdD9ND4fx2mNYI2i8Bv2KPfcjOz+dj3vZznLgaxTcrD9Ov0eMXuUREJONZvHgxbdq0ITIyEi8vLywWi/09i8WiopSIpDgHq4X/tChNxO27rDtylQ5TNjP3raoUyJ7J7GgiIkn2WI/v9e3bl969e5MnTx4qVapE1apVgfhRU/dbDlkkzbl6Q9tfIaAM3LoWX5i6fPCxD+fi6MCAl+MLUdM2nGT/+YgUCioiIhlBr169eP3114mMjCQsLIwbN27YX9evXzc7nohkUC6ODox7rTylg3wIu3WXtpM2cy7sttmxRESS7LGKUs2bN+f06dNs3bqV5cuX27fXrl2bb775JsXCiTwRN5/4wpR/Kbh1Nb4wdeXwYx/u+UK+1C/pj82Avgv3YrNp0nMREYl37tw53n33Xdzd3c2OIiLPGA8XR6Z2qEiB7J5cCL9D20mbuBYZbXYsEZEkeayiFIC/vz9ly5bl/PnznD17FoBKlSpRpEiRFAsn8sTcs0C7heBXEqIuw7SGcPXIYx+uT8NiuDs7sPXUDeZtP5uCQUVE5GkWEhLC1q1bzY4hIs+ozB7OzOhUiRw+bhy/EkXHqVuIjI41O5aIyCM9VlHKZrMxcOBAvL29yZ07N7lz58bHx4dBgwYlmthTxHT2wlQJiLwEUxvC1aOPdagAbzfeq10QgK9/P0j4rbspmVRERJ5SDRo04IMPPqB///7MmzePRYsWJXiJiKS2AG83pneqRBYPZ3afDafL9K1Ex8aZHUtE5KEshmEk+xmkTz75hEmTJjFgwACqV68OwN9//03//v3p3LkzX3zxRYoHTUsRERF4e3sTHh6uidszkqj/PsJ3eT9kCoAOSyFr/mQf5m6cjfrfruPI5Uheq5KLwaElUyGsiIikhZS651utD/6ez2KxEBen/zEE9bFE0sKes+G0Gr+RqJg46hb35/s25XCwWh69o4hICkrqPf+xRkpNmzaNiRMn0rVrV0qVKkWpUqV4++23mTBhAlOnTn3czCKpyyMbtFsEvkXg5oX4AtX148k+jJODlYGNSwDw06bT7D4blsJBRUTkaWOz2R74UkFKRNJSyZzeTGhXAWcHK8v2XeSzX/fwGOMQRETSxGMVpa5fv37fuaOKFCnyWCvMfP/99+TJkwdXV1cqV67M5s2bH9h2woQJ1KhRg8yZM5M5c2aCg4MTtTcMg759+xIQEICbmxvBwcEcOfL48whJBuLpC+0XQ7bCEHEOpjaCGyeTfZiq+bMSWiYQw4BuM3dw4mpUymcVEREREXkM1QpkY1TrMlgt8MuWMwxbfsjsSCIi9/VYRanSpUszevToRNtHjx5NqVKlknWsWbNm0bNnT/r168f27dspXbo0ISEhXL58+b7t165dS+vWrVmzZg0bN24kKCiIl156iXPnztnbDB06lFGjRjFu3Dg2bdqEh4cHISEh3LlzJ3kXKhmTZ/b/FqYKQcTZ/xamTiX7MJ82KErOzG6cvn6LJmPWs/mElvwWEXmWjBo1yt63GDVq1ENfIiJprW6JAL5sEj/NxJi1x5jwV/KfEBARSW2PNafUn3/+SYMGDciVKxdVq1YFYOPGjZw5c4bffvuNGjVqJPlYlStXpmLFivYil81mIygoiO7du/Pxxx8/cv+4uDgyZ87M6NGjadeuHYZhEBgYSK9evejduzcA4eHh+Pn5MXXqVFq1avXIY2q+g2fEzYswtQFcOwo+uaDDb+ATlKxDXLkZzRvTt7LrTBjODlaGNi9FaNkcqRRYRERS2pPc8/PmzcvWrVvJmjUrefPmfWA7i8XC8eP6n0FQH0vEDGPXHmPIsoMADH+lNM3L5zQ5kYg8C1J1TqmaNWty+PBhmjRpQlhYGGFhYTRt2pR9+/YxY8aMJB8nJiaGbdu2ERwc/P+BrFaCg4PZuHFjko5x69Yt7t69S5YsWQA4ceIEFy9eTHBMb29vKleu/MBjRkdHExERkeAlz4BM/vEjprLkg7DT8QWq8LPJOoRvJhd+6VyFusX9iYmz0WPWTkatPqLn9kVEngEnTpwga9as9j8/6KWClIiY6a2a+ehcI75w/tG83azcf8nkRCIi/++xilIAgYGBfPHFF8ybN4958+YxePBgbty4waRJk5J8jKtXrxIXF4efn1+C7X5+fly8eDFJx/joo48IDAy0F6Hu7ZecY3711Vd4e3vbX0FByRstI08xr0BovwQy54WwUzC1IYSfe/R+/8PN2YExbcrR5fl8APxn5WF6z9lNTKwtNRKLiIiIiCSZxWLh0/pFaV4+J3E2g3dmbuef49fMjiUiAjxBUSo9+Prrr/nll1/49ddfcXV1fezjfPLJJ4SHh9tfZ86cScGUku5554AOSyBzHrhxIn5VvogLyTqE1Rp/sx8cWgIHq4V528/SfvJmwm/dTZ3MIiKSrsTFxTFp0iReffVVgoODefHFFxO8RETMZLFY+LppSYKL+hETa6PztK3sPRdudiwREXOLUtmyZcPBwYFLlxIOIb106RL+/v4P3Xf48OF8/fXXrFixIsHk6vf2S84xXVxc8PLySvCSZ4x3zvgRUz654PoxmNYwfs6pZHqtSm4mta+Ah7MDG49fo+nY9Zy+disVAouISHry3nvv8d577xEXF0eJEiUoXbp0gpeIiNkcHayMfrUslfJm4WZ0LB2mbNYK0iJiOlOLUs7OzpQvX57Vq1fbt9lsNlavXm2fQP1+hg4dyqBBg1i2bBkVKlRI8F7evHnx9/dPcMyIiAg2bdr00GOK4BMUX5jyDoqf/HxqQ7iZ/GfuaxXOzpy3quHv5cqxK1E0GbOe7advpEJgERFJL3755Rdmz57NrFmzGDlyJN98802Cl4hIeuDq5MDE9hUoFuDF1cgY2k7axKUIrVAuIuZxTE7jpk2bPvT9sLCwZAfo2bMn7du3p0KFClSqVImRI0cSFRVFx44dAWjXrh05cuTgq6++AmDIkCH07duXmTNnkidPHvs8UZ6ennh6emKxWOjRoweDBw+mYMGC5M2blz59+hAYGEhoaGiy88kzJnPu+Ef5pjSAa0fiH+XrsAQ8syfrMMUCvVjwTnU6TdvCvvMRtB7/D9+0LEP9kgGpFFxERMzk7OxMgQIFzI4hIvJIXq5OTHu9Eq+M28DJa7doN2kzs9+sire7k9nRROQZlKyRUv87Gfj9Xrlz56Zdu3bJCtCyZUuGDx9O3759KVOmDDt37mTZsmX2icpPnz7NhQv/P7/P2LFjiYmJoXnz5gQEBNhfw4cPt7f58MMP6d69O126dKFixYpERkaybNmyJ5p3Sp4hmfNAh8XglQOuHoJpL0PklWQfxt/bldlvVqV2kexEx9p4+6ft/PDnMa3MJyKSAfXq1Ytvv/1W/40XkaeCbyYXZnSqTPZMLhy6dJPXp23hVkys2bFE5BlkMdR7SiQiIgJvb2/Cw8M1v9Sz7NoxmNoAbl6A7MWh/SLwyJbsw8TZDAYu3se0jacAaF0pFwMbF8fJ4aleZ0BEJENIqXt+kyZNWLNmDVmyZKF48eI4OSUccTB//vxkHe/7779n2LBhXLx4kdKlS/Pdd99RqVKlB7afM2cOffr04eTJkxQsWJAhQ4ZQv359+/uGYdCvXz8mTJhAWFgY1atXZ+zYsRQsWNDe5vr163Tv3p3FixdjtVpp1qwZ3377LZ6engCsXbuWb775hs2bNxMREUHBggX54IMPaNOmTZKvS30skfTl0MWbvDJuAxF3YqlZyJcJ7Srg7Kg+qog8uaTe8/VfHJEHyZofOiwFT3+4vA+mN4ao5C+f62C1MKBxCfo1KobFAj9vPs3rU7dw845W5hMRySh8fHxo0qQJNWvWJFu2bIlGkyfHrFmz6NmzJ/369WP79u2ULl2akJAQLl++fN/2GzZsoHXr1nTq1IkdO3YQGhpKaGgoe/futbcZOnQoo0aNYty4cWzatAkPDw9CQkK4c+f/55Jp06YN+/btY+XKlSxZsoS//vqLLl26JDhPqVKlmDdvHrt376Zjx460a9eOJUuWJPPTEpH0orB/JqZ0rISbkwN/Hr5C7zm7sNk0ZkFE0o5GSt2HvsWTBK4eiR8xFXkJ/EtCu0XgnuWxDrVy/yXe/XkHt+/GUcQ/E5M7VCTQxy2FA4uISFKlxD0/NjaWmTNn8tJLLz1y9eCkqFy5MhUrVmT06NFA/CIwQUFBdO/enY8//jhR+5YtWxIVFZWgOFSlShXKlCnDuHHjMAyDwMBAevXqRe/evQEIDw/Hz8+PqVOn0qpVKw4cOECxYsXYsmWLfRGZZcuWUb9+fc6ePUtgYOB9szZo0AA/Pz8mT56cpGtTH0skfVp76DJvTNtKrM2gfdXc9H+5OBaLxexYIvIU00gpkZSSrSC0Xwwe2eHinvgRU7cfbzW9OsX8mP1mVXwzuXDw4k1Cv1/PnrPhKRxYRETSkqOjI2+99RbR0dFPfKyYmBi2bdtGcHCwfZvVaiU4OJiNGzfed5+NGzcmaA8QEhJib3/ixAkuXryYoI23tzeVK1e2t9m4cSM+Pj4JVjUODg7GarWyadOmB+YNDw8nS5bH+6JGRNKPWoWzM6JFaSwWmLbxFKNWHzU7kog8I1SUEkkK38LxhSn3bHBxN0wPhdthj3Wokjm9WfBOdQr7ZeLyzWha/PB/7d13fFRV+sfxz0x6CAkJgRQIKUjvNYQiKrgo6AqiAiJVZUVxcV3XFde++1tE3dV1UUCUYkEBCxYQCy5FCJ1AaCKQhJYESEiF1Lm/PwYmjhRJm8kk3/frNa/s3Dlz5jn3Opxnn7n33Hi+25tepeGKiIhj9ezZkx07dlS6n9OnT1NaWmq74csFISEhtjsO/1paWtoV21/4+1ttGje2v9Osu7s7QUFBl/3cJUuWsGXLFtsdky+lsLCQnJwcu4eI1Ey3dW7Cc7e2A+DV7w/wXnyycwMSkTpBRSmRq9W49fnCVENITYD3hkFBxc5yatLAh6WT4+jXIphzxaVMem8r89cnVW28IiLiMA8++CB//vOfmTlzJvHx8ezatcvuUdv873//Y8KECcydO5d27dpdtt306dPt1taKiIhwYJQiUl7jekcxdYD1BgjPfLGHL3aecHJEIlLbqSglUh4hba2FKZ8gOLEd3rsdCir2q6+/twfzxvdgVM8IDAOe/3Ivz32xh1ItLiki4nJGjhxJUlISf/zjH+nTpw+dO3emS5cutr9XKzg4GDc3N9LT7c+gTU9Pv+x6VaGhoVdsf+Hvb7X59ULqJSUlZGZmXvS5a9as4dZbb+XVV19l7NixVxzPtGnTyM7Otj2OHj16xfYi4nyPDGzB2LhIDAMeXZzA6p8ufZMFEZGqoKKUSHmFtINxX4BPIBzfCgtvhZyK/Yrk4Wbmn8M68MTNrQFYsCGZSe9uJb+wpCojFhGRapaUlHTR4/Dhw7a/V8vT05Nu3bqxatUq2zaLxcKqVauIi4u75Hvi4uLs2gN89913tvbR0dGEhobatcnJyWHTpk22NnFxcWRlZbFt2zZbmx9++AGLxUJsbKxt2+rVqxkyZAgzZsywuzPf5Xh5eeHv72/3EJGazWQy8dyt7fh9p3BKLAaT39/OtpSKracqIvJbdPe9S9CdYeSqpO60XsJ3NgPqh8GoDyH86n8N/7UVian8aXEChSUW2oX7M298D0L8vaswYBER+bWaOOcvXryYcePGMWfOHHr27Mlrr73GkiVL2L9/PyEhIYwdO5YmTZowffp0ADZs2ED//v158cUXGTJkCB999BH//Oc/2b59O+3btwdgxowZvPjiiyxcuJDo6Giefvppdu3axd69e/H2ts41N998M+np6cyePZvi4mImTJhA9+7dWbRoEWC9ZO+WW25h6tSp/PGPf7TF6+npedWLndfE/S0il1ZUYuG+d7ey9sApAnw8WPpAHC1D6js7LBFxEVc756sodQlKmOSqZSbBhyPh1H5w94Fhs6Hd0Ap3t/3IGe5fuJWM/CLCAryZN74HbcL036CISHWp6jl/7969HDlyhKKiIrvtv//978vVz8yZM3n55ZdJS0ujc+fOvP7667Yzlq677jqioqJYsGCBrf3SpUt56qmnSE5OpkWLFrz00ksMHjzY9rphGDz77LO89dZbZGVl0bdvX958801atmxpa5OZmcmUKVP48ssvMZvNDB8+nNdffx0/Pz8Axo8fz8KFCy+KtX///qxevfqqxqUcS8S1nC0qYfTbm9hxJIsQfy8+fqA3EUG+zg5LRFyAilKVoIRJyqUgGz6eCAe/tz6/4Sno9xiYTBXq7kjGWSYs2MyhU/n4ebkz8+4uXNeq8W+/UUREyq2q5vzDhw8zbNgwEhMTMZlMXEivTOfngtLS0iqJ19UpxxJxPVlni7hrTjwH0vOIaujLx5N7E+zn5eywRKSGu9o5X2tKiVSWdwCMWgyxk63Pf/gHfDoJigsq1F2zhr58OrkPvWKCyCss4d6FW/lgU0oVBiwiIlVt6tSpREdHc/LkSXx9fdmzZw9r166le/fuV30WkYhITdTA15N3J8bSpIEPyRlnGTdvM7kFxc4OS0RqCRWlRKqCmzvc/CLc8iqY3CBxiXUB9LyK3a0kwNeDdyfGMrxrU0otBn/7bDf/XLEPi+7MJyJSI8XHx/PCCy8QHByM2WzGbDbTt29fpk+fbrf+koiIKwoN8Ob9+2JpWM+TPSdyuG/hVgqKdQaoiFSeilIiVan7RBjzqfXsqWObYe4NkLa7Ql15upt55c6OPHqjdb2Pt9Ye5qFF25UAiIjUQKWlpdSvb10AODg4mBMnrHdljYyM5KeffnJmaCIiVSI6uB4LJ/akvpc7m5IyefjDHZSUWpwdloi4OBWlRKpazHVw3w8Q1Byyj8K8QfDT1xXqymQy8ccBLXhtRGc83cx8vTuNkW9t5FRuYdXGLCIildK+fXt27twJQGxsLC+99BLr16/nhRdeICYmxsnRiYhUjfZNApg7rjue7ma+25vOtE8T0RLFIlIZKkqJVIfga+C+7yH6WijKgw9HwfrXoYKT9tAuTXjv3p408PUg4WgWw95cz8/puVUctIiIVNRTTz2FxWI9Y+CFF14gKSmJfv36sWLFCl5//XUnRyciUnV6xTRk5qgumE2wdNsxXvx6v7NDEhEXprvvXYLuDCNVprQYVvwFts23Pu9yDwx5Fdw9K9Td4VN5TFywheSMs9T3dmfOPd3ofU1wFQYsIlK3VOecn5mZSWBgoO0OfKIcS6Q2WbL1KI9/vAuAJ25uzQP9mzs5IhGpSXT3PZGawM3Duvj5TTPAZIYd78N7QyE/o0LdxTTy49MH+9A9MpDcghLGztvMkq1HqzZmERGpsIMHD/LNN99w7tw5goKCnB2OiEi1uat7BE8Obg3Ai1/vZ/GWI06OSERckYpSItXNZIJeD8DdS8CzPqSsh7dvgJMVO9U5qJ4n798Xy62dwimxGDz+8S5e+eYnXc8vIuJEGRkZDBgwgJYtWzJ48GBSU1MBuPfee/nzn//s5OhERKrHpGub286QmvZpIit3pzk5IhFxNSpKiThKixvhvu+gQSScSYZ3boSD31eoK28PN/4zojNTrr8GgJn/O8jUjxJ0Zz4RESf505/+hIeHB0eOHMHX19e2fcSIEaxcudKJkYmIVK+/3tSKEd0jsBjwx492sOHQaWeHJCIuREUpEUdq3Abu/wGaxUFhDnxwJ2yaU6EF0M1mE48NasVLd3TE3Wzii50nGPPOJjLzi6ohcBERuZJvv/2WGTNm0LRpU7vtLVq0ICUlxUlRiYhUP5PJxP8Na8+gdiEUlViY9O42Eo9lOzssEXERKkqJOFq9YBj7OXQeDYYFvn4clv/Zuih6BdzVPYKFE3tS39udLclnuP3N9SSdzq/ioEVE5Ery8/PtzpC6IDMzEy8vLydEJCLiOO5uZv4zsgtxMQ3JKyxh/PzNHD6V5+ywRMQFqCgl4gzuXnDbG3DjC4AJtr4DH9wB585UqLs+1wTz6eTeNGngQ3LGWYa9uZ7NSZlVG7OIiFxWv379ePfdd23PTSYTFouFl156ieuvv96JkYmIOIa3hxtvje1GhyYBZOQXMeadzaRmn3N2WCJSw6koJeIsJhP0mQojPwCPenB4Nbw9EDIOVai7FiH1WfZQHzpFNCDrbDH3vL2JzxOOV23MIiJySS+99BJvvfUWN998M0VFRTz++OO0b9+etWvXMmPGDGeHJyLiEPW9PVgwoQcxwfU4nnWOse9s5oyWlhCRK1BRSsTZWg+Be78B/6aQcRDm3gBJayvUVaP6Xnx0fy9uahdKUamFqR8l8N9VP+vOfCIi1ax9+/YcOHCAvn37ctttt5Gfn8/tt9/Ojh07aN68ubPDExFxmIZ+Xrx7b09C/b35+WQeExZsIb+wxNlhiUgNZTL0/1YvkpOTQ0BAANnZ2fj7+zs7HKkrctPho7vh+FYwu8PgV6D7hAp1ZbEYvLhyP2+tPQzAHd2a8s9hHfB0Vx1aROSXqnvOP3bsGC+88AJvvfVWlfftipRjidQdP6fncueceLLOFtOvRTDvjOuhXFSkDrnaOV//KojUFPVDYPxyaH8HWErgq0dg5TSwlJa7K7PZxJOD2/CPoe1xM5v4eNsxxs3bTPbZii2mLiIiFZORkcE777zj7DBERByuRUh95o/vga+nG+t+Ps3k97dxtkhnTImIPRWlRGoSD28Y/jZc/zfr841vwocjoSCnQt3d0yuSd8Z1p56nG/GHM7h91nqOZp6twoBFRERERC6tS7NA5ozphpe7mVX7TzLqrY2cyi10dlgiUoOoKCVS05hM0P9xuHMBuPvAz9/CO7+DM8kV6u66Vo1Z+kBvQv29OXQqn6FvrGfHkYrd5U9EREREpDz6tWjEovt7Eejrwc5j2dw+az2HT+U5OywRqSFUlBKpqdoNgwkrwC8UTu2zLoCeEl+hrtqG+7PsoT60C/cnI7+IkW9t5OvE1CoOWERERETkYt0iA/n0wT5ENvTlaOY5bp+1ga3Jmc4OS0RqAC10fglahFNqlJwT1kv4UneCmyfc+jp0HlWhrvILS3j4wx38sP8kANNubs2ka2MwmUxVGbGIiMuo7Jx/++23X/H1rKws1qxZQ2lp+dcHrI2UY4nUbafzCrl34VZ2Hs3C093Mf0Z05uYOYc4OS0SqgRY6F6kt/MNhwtfQ5lYoLYJlD8D3z4HFUu6u6nm5M3dsd8bFRQIw/ev9/G3ZbkpKy9+XiIhAQEDAFR+RkZGMHTvW2WGKiNQIwX5efHR/Lwa2CaGoxMKDi7bzzo9Jzg5LRJxIZ0pdgn7FkxrJYoH//R+se8X6vPUtMGwOePlVqLt5Pybx9+V7MQy4tmUj3ri7C/W9PaowYBGRmk9zvmNpf4sIQKnF4Lkv9vDexhQAJvaJ5qkhbTCbdfa+SG2hM6VEahuzGQY8DcPesl7Gt/8rmH8TZB+rUHcT+0Yz555u+Hi4sfbAKe6cHc+JrHNVHLSIiIiIiD03s4kXbmvHtJtbAzBvfRIPLdpOQbEudRapa1SUEnE1nUbA+OVQrxGkJVoXQD+2rUJd/a5dKEv+EEej+l7sT8tl6BvrSTyWXcUBi4iIiIjYM5lM/KF/c14f1QVPNzNf705j9NubOJNf5OzQRMSBVJQScUURPeH+H6BxO8hLhwWDIfHjCnXVoWkAyx7qQ6uQ+pzMLeSuOfF8vze9igMWEREREbnY7zuF8+69PfH3dmdbyhmGz9rAkYyzzg5LRBxERSkRV9WgGdz7DbS8CUoK4JN74X//hAosE9ekgQ9LJ8fRr0Uw54pLmfTeVuav16KTIiIiIlL9esU05JPJvWnSwIfDp/O5fdZ6dh7NcnZYIuIAKkqJuDKv+jByEfR+2Pp8zQz4eAIUl39tKH9vD+aN78GonhFYDHj+y70898UeSi26F4KIiIiIVK8WIfX57MHetAv353ReESPf2siqfTp7X6S2U1FKxNWZ3eB3/4DfzwSzB+z5DOYPhty0cnfl4Wbmn8M68MT5RScXbEjmD+9tJb+wpKqjFhERERGx09jfm8V/iKN/y0acKy7l/ne38v75O/SJSO2kopRIbdF1DIxdBj6BcGI7vHU9pO4sdzcmk4kH+jfnjbu74ulu5vt9JxnxVjzpOQVVH7OIiIiIyC/4ebnz9rjujOhuPXv/qWW7mbFyPxadvS9SK6koJVKbRPW1LoAe3BJyT8C8m2DvFxXqakjHMD68vxcN63my+3gOw95Yz77UnCoOWERERETEnoebmReHd+DRG1sCMGv1If60JIHCklInRyYiVU1FKZHaJigG7vsemt8AxWdhyRhY968KLYDeLTKQzx7sQ/NG9TiRXcCds+NZc+BUNQQtIiIiIlLGZDLxxwEteOXOTribTXyecIJx8zaTfa7Y2aGJSBVSUUqkNvIOgLuXQs9J1uerXoDPHoCSwnJ31ayhL59O7kOvmCDyCkuYuGALH2zStf0iIiIiUv3u6NaU+RN64OflzsbDmdw5ewPHs8p/Ux8RqZlUlBKprdzcYfDLMPgVMLnBro9g4a2QV/4znQJ8PXh3Yiy3d21CqcXgb5/tZvqKfbq2X0RERESqXb8WjVjyhzhC/L04kJ7H7W+uZ8+JbGeHJSJVQEUpkdqu5/1wz8fgFQBHN8HcGyB9T7m78XQ38687O9mu7Z+z9jAPLdpOQbGu7RcRERGR6tU23J/PHuxDq5D6pOcUctfseNZqWQkRl6eilEhd0PwG6zpTQTGQfQTe+R0c+Kbc3Vy4tv+1EZ3xdDPz9e40Rr61kVO55b8sUERERESkPMIb+LDkgTjiYhqSX1TKxAVbWLr1qLPDEpFKUFFKpK5o1BLuWwVR/aAoDxaNgA0zK7QA+tAuTXjv3p408PUg4WgWw95cz8GTudUQtIiIiIhImQAfDxZO7MmwLk0osRj85eNdvPb9AYwK5LQi4nwqSonUJb5BcM+n0HUcYMC3f4Mv/wglReXuKjamIZ9O7k1kQ1+OnTnHsDc3sOHg6aqPWURERETkFzzdzfz7rk48dH1zAF77/mce/3gXxaUWJ0cmIuWlopRIXePuCbf+BwZNB5MZtr8L798OZzPL3VVMIz8+e7AP3SMDyS0oYey8zTqFWkRERESqnclk4i+DWvPPYR0wm2DptmPcu3AreYUlzg5NRMpBRSmRushkgrgHYdRH4FkfktdZF0A/daDcXQXV8+T9+2K5tVO47RTqf337k06hFhEREZFqd3dsM94e1x0fDzfWHjjFXbPjSc8pcHZYInKVVJQSqctaDoJ7v4UGzeBMErw9EA79UO5uvD3c+M+IzrZTqP/7w0EeWZxAYYnuzCciIiIi1euG1iEs/kMvgv082Zuaw7A31nMgXeudirgCFaVE6rqQtnDfDxDRCwqz4f07YPPccndjNltPoX5peEfczSY+TzjBPW9vIjO//OtViYiIiIiUR8emDfjswT7ENKrHiewChs/aQPyhDGeHJSK/QUUpEQG/RjDuC+g0CoxSWPEYLH8MSst/Tf5dPSJYOLEn9b3d2ZJ8htvfXE/S6fxqCFpEREREpExEkC+fPNDbtt7puHmb+TzhuLPDEpErUFFKRKzcvWDoLBj4HGCCLXPhgzvgXFa5u+pzTTCfTu5NkwY+JGecZdib69mSXP6F1EVEREREyiPw/HqnQzqEUVRqYepHCcxafUjrnYrUUCpKiUgZkwn6/glGvA8evnD4f/DOjZBxqNxdtQipz7KH+tCpaQBZZ4sZPXeTfqkSERERkWrn7eHGf0d14b6+0QDMWLmfpz/fTUmpxcmRicivqSglIhdrcwtMXAn+TeD0AXh7ACStK3c3jep78dGkOAa1C7H9UjXzh5/1S5WIiIiIVCuz2cRTt7Tl2VvbYjLB+xuP8MD72zhbVP7lKUSk+qgoJSKXFtYJ7v8BmnSDc2fgvaGw/d1yd+Pj6cas0d2YdG0MAK98e4C/fLyLohL9UiUiIiIi1WtCn2hmje6Kl7uZ7/edZNRbGzmVW+jssETkPBWlROTy6ofC+OXQ7nawlMAXD8M3fwNLabm6MZtNPDm4DX8f2h6zCT7edozx8zeTfa64mgIXEREREbG6qX0Yi+6PJdDXg53Hsrl91noOn8pzdlgigopSIvJbPHzgjnlw3TTr8/iZ8NHdUJhb7q7G9IrknfE9qOfpxoZDGQyftYGjmWerOGAREREREXvdIoP4ZHJvmgX5cjTzHMNnbWBbim7EI+JsKkqJyG8zmeC6J6zFKXdvOLAS3vkdnEkpd1fXt2rM0gd6E+rvzcGTeQx7cz07jpyphqBFRERERMrENPLj0wd70ymiAWfOFnP33E18nZjq7LBE6jQVpUTk6rUfDuNXgF8InNwLc2+AI5vK3U3bcH+WPdSHduH+nM4rYuRbG5UQiIiIiEi1C/bz4sP7YxnYJoTCEgsPLtrOOz8mOTsskTrL6UWpN954g6ioKLy9vYmNjWXz5s2Xbbtnzx6GDx9OVFQUJpOJ11577aI2zz33HCaTye7RunXrahyBSB3TtBvc/z8I7QBnT8PCW2DnR+XuJjTAmyV/iOOG1o1tCcFbaw/pznwiIiIiUq18Pd2ZM6YbY3pFYhjw96/28sKXe7FYlIeKOJpTi1KLFy/m0Ucf5dlnn2X79u106tSJQYMGcfLkyUu2P3v2LDExMbz44ouEhoZett927dqRmppqe/z444/VNQSRuimgCUz8BlrfAqVF8Nkf4PvnwVK+O+rV83LnrTHdGBdnTQj+uWI/f1u2m5JS3ZlPRERERKqPm9nEC7e144mbrScwzFufxEOLtlNQXL4b+ohI5Ti1KPXvf/+b+++/nwkTJtC2bVtmz56Nr68v8+bNu2T7Hj168PLLLzNy5Ei8vLwu26+7uzuhoaG2R3BwcHUNQaTu8qwHd70HfR+1Pv/x37B0LBTll6sbdzczz9/WnmduaYvJBIs2HWHiwq3kFujOfCIiIiJSfUwmEw/0b85/RnbG083M17vTGP32Js7kFzk7NJE6w2lFqaKiIrZt28bAgQPLgjGbGThwIPHx8ZXq++effyY8PJyYmBhGjx7NkSNHKhuuiFyK2QwDn4Vhc8DNE/Z9CfNuguzj5e5qYt9o5tzTDR8PN9YeOMWds+M5kXWuGoIWERERESlzW+cmvHtvT/y93dmWcobhszZwJEN3iBZxBKcVpU6fPk1paSkhISF220NCQkhLS6twv7GxsSxYsICVK1cya9YskpKS6NevH7m5l799fWFhITk5OXYPESmHTiNh3JfgGwxpu6wLoB/fVu5uftculMV/6EWj+l7sT8tl6Bvr2X08uxoCFhEREREp0yumIZ9M7k2TBj4cPp3P7bPWs/NolrPDEqn1nL7QeVW7+eabufPOO+nYsSODBg1ixYoVZGVlsWTJksu+Z/r06QQEBNgeERERDoxYpJZo1gvu/wEat4W8NJg/GHZ/Wu5uOjZtwGcP9qZVSH1O5hZy15x4vt+bXg0Bi4iIiIiUaRFSn08f7E3bsLI7RK/apzxUpDo5rSgVHByMm5sb6en2X/L09PQrLmJeXg0aNKBly5YcPHjwsm2mTZtGdna27XH06NEq+3yROiUw0roAeotBUFIAH0+A1TOgnHfUaxroy9LJcfRrEczZolImvbeVBet1q14RERERqV4h/t4seSCOa1s24lxxKfe/u5X3N6Y4OyyRWstpRSlPT0+6devGqlWrbNssFgurVq0iLi6uyj4nLy+PQ4cOERYWdtk2Xl5e+Pv72z1EpIK8/WHUhxA3xfp89T/hk3uhuHzrQ/l7ezBvfA9G9YzAYsBzX+7luS/2UKpb9YqIiIhINfLzcuedcd0Z0d2ahz61bDczVu7HojxUpMo59fK9Rx99lLlz57Jw4UL27dvH5MmTyc/PZ8KECQCMHTuWadOm2doXFRWRkJBAQkICRUVFHD9+nISEBLuzoB577DHWrFlDcnIyGzZsYNiwYbi5uTFq1CiHj0+kzjK7waD/g1tfB7M77P4EFgyB3PKtF+fhZuafwzrYbtW7YEMyf3hvG2eLSqojahERERERwJqHvji8A38a2BKAWasP8aclCRSWlDo5MpHaxalFqREjRvDKK6/wzDPP0LlzZxISEli5cqVt8fMjR46Qmppqa3/ixAm6dOlCly5dSE1N5ZVXXqFLly7cd999tjbHjh1j1KhRtGrVirvuuouGDRuyceNGGjVq5PDxidR53cbBmGXgE2hd+HzuDZC6q1xdXLhV7xt3d8XT3cz3+9K5a0486TkF1ROziIiIiAjWPHTqwBa8cmcn3M0mPk84wbh5m8k+V+zs0ERqDZNhlHOxlzogJyeHgIAAsrOzdSmfSFXIOASLRkDGz+DhC7fPhTa3lLubbSlnmPTuVjLyiwgP8GbehB60DtV3VEQqTnO+Y2l/i4irWvfzKSa/v528whJahvgxf0JPmjTwcXZYIjXW1c75te7ueyJSAzVsDvd9BzHXQfFZWHwP/PhquRdA7xYZyGcP9iGmUT1OZBdwx6x41hw4VT0xi4iIiIic169FI5b8IY4Qfy8OpOdx+5vr2XMi29lhibg8FaVExDF8AmH0x9DjPsCA75+DZQ9CSWG5umnW0JfPJvehV0wQeYUlTFywhUWbjlRLyCIiIiIiF7QN9+ezB/vQMsSP9JxC7podz1r9QCpSKSpKiYjjuHnAkH/B4FfA5AY7F8G7t0H+6XJ1E+DrwbsTY7m9axNKLQZPfpbI9K/36Y4oIiIiIlKtwhv4sPSB3sTFNCS/qJSJC7awdOtRZ4cl4rJUlBIRx+t5P4xeCl4BcCQe5l4PJ/eVqwtPdzP/urOT7Y4oc9Yc5qFF2yko1h1RRERERKT6BPh4sHBiT4Z2DqfEYvCXj3fx2vcH0HLNIuWnopSIOMc1A6zrTAVGQ9YRePtG+Pm7cnVx4Y4or47ohKebma93pzHyrY2czivfJYEiIiIiIuXh6W7m1RGdefC65gC89v3P/PWTXRSXWpwcmYhrUVFKRJynUSu4/weI7AtFubDoLoh/s9wLoA/r0pT37u1JA18PEo5mMezN9Rw8mVtNQYuIiIiIWH8gffym1vzfsPaYTbBk6zHuXbiVvMISZ4cm4jJUlBIR5/INgjGfQZcxYFjgm2nw1SNQWlyubmJjGvLp5N5ENvTlaOY5bn9zAxsOlW+tKhERERGR8hodG8nb47rj4+HG2gOnuGt2POk5Bc4OS8QlqCglIs7n7gm//y/87v8AE2xbAO8Ng7OZ5eomppEfnz3Yh26RgeQUlDD2nc18vO1YtYQsIiIiInLBDa1DWPyHXgT7ebI3NYfb39zAgXSduS/yW1SUEpGawWSC3lNg1Efg6QfJ6+DtgXD653J1E1TPkw/ui+WWjmGUWAweW7qTf3/7kxaeFBEREZFq1bFpAz6d3IeY4HoczzrH8FkbiD+U4eywRGo0FaVEpGZpdRPc+y0ENIPMQ/D2ADj0v3J14e3hxusju/DQ9daFJ1//4SCPLE6gsER35hMRERGR6tOsoS+fTO5N98hAcgtKGDdvM58nHHd2WCI1lopSIlLzhLSzLoDetCcUZMP7w2HLO+Xqwmw28ZdBrXlpeEfczSY+TzjBPW9v4kx+UTUFLSJSdd544w2ioqLw9vYmNjaWzZs3X7H90qVLad26Nd7e3nTo0IEVK1bYvW4YBs888wxhYWH4+PgwcOBAfv7Z/kzUzMxMRo8ejb+/Pw0aNODee+8lLy/P9npBQQHjx4+nQ4cOuLu7M3To0Cobr4hIbRJYz5P374tlcIdQikotTP0ogVmrD+nMfZFLUFFKRGomv0Yw7kvoOAKMUlj+KKx4HErLdzeTu3pEsGBCT+p7ubMl+Qy3z9pA8un8agpaRKTyFi9ezKOPPsqzzz7L9u3b6dSpE4MGDeLkyZOXbL9hwwZGjRrFvffey44dOxg6dChDhw5l9+7dtjYvvfQSr7/+OrNnz2bTpk3Uq1ePQYMGUVBQthDv6NGj2bNnD9999x1fffUVa9euZdKkSbbXS0tL8fHx4Y9//CMDBw6svh0gIlILeHu4MXNUV+7tGw3AjJX7efrz3ZSUWpwcmUjNYjJUrr1ITk4OAQEBZGdn4+/v7+xwROo2w4B1/4If/m593nwA3DkfvAPK1c2B9FwmzN/C8axzBPp68NbY7vSICqqGgEXEldTEOT82NpYePXowc+ZMACwWCxERETz88MM88cQTF7UfMWIE+fn5fPXVV7ZtvXr1onPnzsyePRvDMAgPD+fPf/4zjz32GADZ2dmEhISwYMECRo4cyb59+2jbti1btmyhe/fuAKxcuZLBgwdz7NgxwsPD7T5z/PjxZGVlsWzZsnKNrSbubxGR6jbvxyT+vnwvhgED2zTm9VFd8PV0d3ZYItXqaud8nSklIjWbyQTXPgZ3vQvuPnBoFbx9I2QeLlc3LUPqs+yhPnRqGsCZs8WMnrtJ1/eLSI1TVFTEtm3b7M5EMpvNDBw4kPj4+Eu+Jz4+/qIzlwYNGmRrn5SURFpaml2bgIAAYmNjbW3i4+Np0KCBrSAFMHDgQMxmM5s2barweAoLC8nJybF7iIjUNRP7RjNrdFe83M18v+8ko97ayKncQmeHJVIjqCglIq6h7W0wcSXUD4fTP8HcAZC8vlxdNKrvxUeT4hjULsR2ff/MH37W9f0iUmOcPn2a0tJSQkJC7LaHhISQlpZ2yfekpaVdsf2Fv7/VpnHjxnavu7u7ExQUdNnPvRrTp08nICDA9oiIiKhwXyIiruym9mEsuj+WQF8Pdh7L5vZZ6zl8Ku+33yhSy6koJSKuI7yzdQH08C5wLhPevQ12vF+uLnw83XhzdDfu72e9vv+Vbw/w+Me7KCrR9f0iIlVt2rRpZGdn2x5Hjx51dkgiIk7TLTKITyb3plmQL0czzzF81ga2pWQ6OywRp1JRSkRci38YjF8BbYeCpRg+fwi+fQospVfdhZvZxN+GtOXvQ9tjNsHSbccYP38z2eeKqy9uEZGrEBwcjJubG+np6Xbb09PTCQ0NveR7QkNDr9j+wt/favPrhdRLSkrIzMy87OdeDS8vL/z9/e0eIiJ1WUwjPz59sLdtSYm7525i5e5UZ4cl4jQqSomI6/H0hTvmQ/+/Wp9v+C8svgcKc8vVzZhekbwzvgf1PN3YcCiD4bM28L+fTmKx6HI+EXEOT09PunXrxqpVq2zbLBYLq1atIi4u7pLviYuLs2sP8N1339naR0dHExoaatcmJyeHTZs22drExcWRlZXFtm3bbG1++OEHLBYLsbGxVTY+ERGBYD8vPpzUi4FtGlNYYmHyB9uZ92OSs8MScQoVpUTENZnNcP2TMPwdcPOCn1bAvJsg60i5urm+VWOWPtCbUH9vDp7MY8L8LVz/r9XMXXuYrLNF1RS8iMjlPfroo8ydO5eFCxeyb98+Jk+eTH5+PhMmTABg7NixTJs2zdZ+6tSprFy5kn/961/s37+f5557jq1btzJlyhQATCYTjzzyCP/4xz/44osvSExMZOzYsYSHhzN06FAA2rRpw0033cT999/P5s2bWb9+PVOmTGHkyJF2d97bu3cvCQkJZGZmkp2dTUJCAgkJCQ7bNyIitYWvpztzxnTnnl7NMAx44au9vPDlXv04KnWOydAKvxfR7YpFXMyxrfDhKMg/CfUawchFENGzXF2czC1g9urDLN12lNyCEgC83M38vlM4Y+Oi6NA0oDoiFxEnq6lz/syZM3n55ZdJS0ujc+fOvP7667Yzlq677jqioqJYsGCBrf3SpUt56qmnSE5OpkWLFrz00ksMHjzY9rphGDz77LO89dZbZGVl0bdvX958801atmxpa5OZmcmUKVP48ssvMZvNDB8+nNdffx0/Pz9bm6ioKFJSUi6K92rTyZq6v0VEnMUwDOasPcyLX+8HYHCHUP59V2e8PdycHJlI5VztnK+i1CUoYRJxQVlHrYWp9ETrmVO3zYSOd5W7m7NFJXyecIJ341PYl1p26/LOEQ0YGxfJ4A5hShJEahHN+Y6l/S0icmmfJxznL0t3UVRqoXtkIHPHdiewnqezwxKpMBWlKkEJk4iLKsyDTyfBT8utz6/9C1z3pPVSv3IyDIPtR87wbnwKKxJTKS61/lMZVM+TET0iuLtnMyKCfKsyehFxAs35jqX9LSJyeRsPZzDp3a3kFJQQE1yPBRN60qyh8k1xTSpKVYISJhEXZrHAqudh/WvW521vg6GzrYujV9Cp3EIWbznCB5uOkJpdAIDZBDe0bsyYuCj6XROM2WyqguBFxNE05zuW9reIyJUdSM9lwvwtHM86R7CfJ++M60GniAbODkuk3FSUqgQlTCK1wI4P4MupYCmGsM4w6kPwD//Nt11JSamF7/ed5P2NKfx48LRte3RwPUbHNuPObhEE+HpUMnARcSTN+Y6l/S0i8tvScwqYMH8Le1Nz8PFwY+bdXRjQJsTZYYmUi4pSlaCESaSWSImHxaPhbAbUD7MWpsK7VEnXB0/m8f7GFD7ZdozcQuvC6N4eZoZ2bsI9vSJp30QLo4u4As35jqX9LSJydfIKS3jwg+2sPXAKswleuK099/SKdHZYIldNRalKUMIkUotkJsGHI+HUfnD3gWGzod3QKus+v7CEZQnHeS8+hf1pubbtXZs1YGxcFDd3CMXLXQuji9RUmvMdS/tbROTqFZda+NtniSzZegyAydc15y+/a6VlI8QlqChVCUqYRGqZghz4eCIc/M76/Pqn4NrHwFR1E7phGGxJPsN7G1P4OjGVEov1n9Zgv/MLo8dG0qSBT5V9nohUDc35jqX9LSJSPoZh8Pqqg7z6/QEAhnYO56U7OuHpXv4b+Yg4kopSlaCESaQWKi2B756GjW9an3e4E34/Ezy8q/yjTuYW8NHmoyzadIS0nLKF0Qe0CWFsXCR9rwnGVIUFMRGpOM35jqX9LSJSMUu3HmXap4mUWAziYhoye0w3Any0lqnUXCpKVYISJpFabOs8WPEXsJRAk+4wchHUr56FI0tKLXy3N51341OIP5xh2x4TXI97ekUyvFtTJRMiTqY537G0v0VEKm7tgVM8+MF28gpLaBnix/wJPXUmvtRYKkpVghImkVru8BpYMhYKssC/Kdz9EYR2qNaPPHgyl/fiU/hk+3Hyzi+M7uPhxtAuTRgbF0mbMP1bI+IMmvMdS/tbRKRy9pzIZuKCLaTnFBLi78W88T1oF64b7EjNo6JUJShhEqkDTh+ED0dAxkHwqAfD34bWg6v9Y/MKS/hsx3Hei0/mQHqebXv3yEDGxEVyc/swrREg4kCa8x1L+1tEpPJOZJ1j/PzNHEjPw8/LnTdHd+Xalo2cHZaIHRWlKkEJk0gdce4MLBkHSWsAEwx8Dno9CO6e1f7RhmGwKSmT9+JT+GZP2i8WRvdiVM8I7o5tRliATscWqW6a8x1L+1tEpGpknyvmgfe2EX84A3eziem3d+DO7hHODkvERkWpSlDCJFKHlBbD149b15oCcPeBZrEQ1Q+ir4XwLuBWves+pecU8OHmIyzadISTuYUAuJlN3NgmhDFxkfRu3lALo4tUE835jqX9LSJSdQpLSvnrx7tYlnACgEcGtmDqgBbKG6VGUFGqEpQwidQxhgFb3oY1MyD/lP1rHvWgWS+I7gdR10JYJ3Bzr5YwikstfLsnnXfjk9mUlGnb3rxRPcacXxi9vrcWRhepSprzHUv7W0SkalksBq98+xNvrj4EwF3dm/J/wzrg4ablIMS5VJSqBCVMInWUYcCp/ZC0DpLXQvKP1kv8fsnLH5rFnS9S9bMukG52q/JQfkrL5f2NKXy6/Rj5RaUA+Hq6MaxLE8bGRdEqtH6Vf6ZIXaQ537G0v0VEqscHm1J4etluLAZc27IRb47uip9X9fyQKnI1VJSqBCVMIgKAxQIn91iLU0nrIOVHKMi2b+MdAJF9y4pUjduCuep+mcotKOazHcd5Nz6FgyfLFkbvGR3EmF6R3NQ+VL+EiVSC5nzH0v4WEak+q/alM2XRDs4Vl9I2zJ/5E3oQ4u/t7LCkjlJRqhKUMInIJVlKIS0RktedL1JtgKJc+zY+QRDV9/yaVP2gUWuoguv6DcMg/nAG78Wn8O3edErPL4zeqL4Xo3o24+6ezQgNUNIhUl6a8x1L+1tEpHrtPJrFvQu3cDqviCYNfJg/oQctQ3SGvTieilKVoIRJRK5KaQmk7rRe6pe0Do5shOJ8+zb1Gv2iSHUtNLym0kWq1OxzfLj5KB9uPsKpXyyMPqhdCGN6RdErJkgLXIpcJc35jqX9LSJS/Y5knGX8/M0cPp1PfW933hrTnbjmDZ0dltQxKkpVghImEamQ0mI4vr1sPaojm6DknH0bv9CyS/2i+0FgdIWLVEUlFr7Zk8Z78SlsTi5bGL1FYz/GxEVye9emWktA5Ddozncs7W8REcc4k1/E/e9uZWvKGTzdzLx8Z0du69zE2WFJHaKiVCUoYRKRKlFSCMe3nV84fR0c3QylhfZt/JuWFami+kJgZIU+al9qDu9tTGHZjuOcPb8wej1PN27v2pSxcZG00GnbIpekOd+xtL9FRBynoLiUR5cksCIxDYC/3tSaB/rH6Ix6cQgVpSpBCZOIVIviAji2uaxIdWwrWIrt2zRoBlHXlhWqAsr3i1ZOQTGfbjvGuxtTOHyq7FLCXjFBjI2L4sa2IVoYXeQXNOc7lva3iIhjWSwG/7diH+/8mATAPb2a8dyt7XBXPijVTEWpSlDCJCIOUZQPRzeVFamObwej1L5NUEzZelRRfaF+6FV1bRgGGw5l8G58Mt/tTef8uuiE+JctjN5Yd2MR0ZzvYNrfIiLOMe/HJP6+fC+GAQPbNOb1UV3w9dQyD1J9VJSqBCVMIuIUhbnWdaguLJyemgCGxb5NcMuy9agi+4Jfo9/s9kTWORZtOsJHW45wOq8IAHeziUHtQxnbK5Ke0VoYXeouzfmOpf0tIuI8Xyem8sjiBApLLHRqGsA743sQ7Ofl7LCkllJRqhKUMIlIjVCQDSnx1rOoktZCWiLwq3+yG7WxX5PKN+iy3RWVWPh6dyrvxaewNeWMbXvr0Prc0yuSYV2aUE8Lo0sdoznfsbS/RUSca1tKJvct3MqZs8U0C/JlwYQexDTyc3ZYUgupKFUJSphEpEY6mwkpG84XqdbByT2/amCCkPZlRarI3uDT4JJd7TmRzfsbU1i24wTniq2XDPp5uTO8axPGxEVyTWMtjC51g+Z8x9L+FhFxvsOn8hg/fwtHMs8S6OvB2+O60y3y8j9silSEilKVoIRJRFxCfgak/Fi2JtWp/favm8wQ2vF8kepaiIwDL/tiU/a5Yj7edoz3N6aQdLpsYfTezRsyNi6SgW1CtBCm1Gqa8x1L+1tEpGY4nVfIvQu2sPNYNl7uZv4zsjM3tQ9zdlhSi6goVQlKmETEJeWdLDuLKnkdZBy0f93kBuFdrJf5RfeDZnHgWQ+w3pll/aHTvBufwqp9ZQujhwV4c3fPZozoGUHj+loYXWofzfmOpf0tIlJznC0q4Y8f7uD7fScxmeDpIW2Z2Dfa2WFJLaGiVCUoYRKRWiHnBCT/aF2PKnkdnEm2f93sDk26lS2cHhELHj4cO3OWRZuOsHjLUTLyrQuje7iZuKl9GGPjIukeGaiF0aXW0JzvWNrfIiI1S6nF4NkvdvP+xiMATOwTzVND2mA2K9eTylFRqhKUMIlIrZR11P5Mquyj9q+7eULTHrYiVWFoV1bsy+S9+BS2H8myNWsdWp+xcVEM7RKuWwmLy9Oc71ja3yIiNY9hGMxec5gZK61LQQzuEMq/7+qMt4ebkyMTV6aiVCUoYRKRWs8wICulrECVtA5yT9i3cfeGiJ4QdS2H/brw9qFAPk08SUGxBYD63u7c0a0p9/SKpLnu2iIuSnO+Y2l/i4jUXJ8nHOexpTspLjXoHhnI3LHdCazn6eywxEWpKFUJSphEpM4xDMg8XHapX9I6yD9p38bDl+ImPUlwa8+84xF8mxVOKdZf0PpeE8yYuEgGtG6shdHFpWjOdyztbxGRmi3+UAaT3ttKbkEJMY3qsWB8T5o19HV2WOKCVJSqBCVMIlLnGQacPlBWpEr+Ec5m2DUpca/HPo92fJXbnA2l7dhjRBEa4MvoXpGM6BFBsJ+Xk4IXuXqa8x1L+1tEpOY7kJ7L+HmbOZFdQLCfJ++M60GniAbODktcjIpSlaCESUTkVywWOLX//FlUa61FqoIsuya5+LKxtDUbLW3ZSnti2vfknt7RdG2mhdGl5tKc71ja3yIiriE9p4AJ87ewNzUHHw83Zt7dhQFtQpwdlrgQFaUqQQmTiMhvsFggfXfZpX4pG6Aw265JllGPTZY2JPl1JbLbIK7r1x8fLw8nBSxyaZrzHUv7W0TEdeQVlvDgB9tZe+AUZhP8fWh7RsdGOjsscREqSlWCEiYRkXKylELqTluRqjRlA27F+XZNMqlPWmB3Gne8keD2AyG4JegMKnEyzfmOpf0tIuJaikst/O2zRJZsPQbA5Oua85fftcJsVg4nV6aiVCUoYRIRqaTSYjiRwNmfV5Ox+3uCM3fgQ6Fdk0LvRng0vxZzdD+IvhaCYlSkEofTnO9Y2t8iIq7HMAz+s+pnXvv+ZwBu7RTOIwNb6O7LckUqSlWCEiYRkaplKS4kYeMPJG9dSciZLXQzHcDbVGzfqH44RPeDqL4Q1Q8Co1SkkmqnOd+xtL9FRFzXkq1HefLTREos1hJC69D63NIxjMEdwohRgUp+RUWpSlDCJCJSfY5knOWj+AP8tO1/dCjeRZx5L11MB/E0ldg3DIiwFqei+1n/NohwTsBSq2nOdyztbxER17bxcAZz1hxi3c+nbcUpgDZh/tzSMYwhHcKICq7nxAilplBRqhKUMImIVL+C4lK+3HmC9zam8NOxU3QzH6CXeS8DvQ/QuvQAZuNXRarAqPNFqmutf/3DnBK31C6a8x1L+1tEpHbIOlvEt3vTWb4rlfUH7QtU7cL9GXK+QBXZUAWqukpFqUpQwiQi4lgJR7N4Nz6Zr3alUlRiwYcC+nsfZkxoCt2NPXid3AlGqf2bGl5jfyaVX2PnBC8uTXO+Y2l/i4jUPmfyi/h2bxpf7Uplw6EMSn9RoOrQJMBWoIoI8nVilOJoKkpVghImERHnyMwvYsnWo7y/MYVjZ84B1mWlBl3jy+Tok3QoTsScvA7SdoFhsX9zcKuyAlVUP6jX0AkjEFejOd+xtL9FRGq3zPwivtmTxorEiwtUnZpaC1SDO4TRNFAFqtrOZYpSb7zxBi+//DJpaWl06tSJ//73v/Ts2fOSbffs2cMzzzzDtm3bSElJ4dVXX+WRRx6pVJ+XooRJRMS5Si0Gq386ybvxKaw5cMq2PSLIh9GxkYxs70+DU1sgeR0krYP0xIs7CWkP0f0h5jqI7A1eWoBTLqY537G0v0VE6o6MvEK+2ZPO8sQTxB/K4Bf1KTpHNOCWjmHc3CGMJg18nBekVBuXKEotXryYsWPHMnv2bGJjY3nttddYunQpP/30E40bX3wZxpYtW1iyZAndunXjT3/6E3/9618vKkqVt89LUcIkIlJzJJ/O5/2NKSzZepScAus6U57uZm7tGM7YuEg6RTSAs5mQst5aoEpeByf32ndidoemPawFquj+0LQ7uHk4fCxS82jOdyztbxGRuul0XiErd6exfFcqm5LsC1RdmjVgSAfrGVThKlDVGi5RlIqNjaVHjx7MnDkTAIvFQkREBA8//DBPPPHEFd8bFRXFI488clFRqjJ9XqCESUSk5jlXZF0Y/d2Nyew+nmPb3qlpAGPiorilYxjeHm7WjXmnIHktHF4Dh1dDVop9Z55+1rOnLhSpGrcFs9lhY5GaQ3O+Y2l/i4jIydwCvtltXYNqc3Imv6xIdIsMtBWoQgO8nRekVFqNL0oVFRXh6+vLxx9/zNChQ23bx40bR1ZWFp9//vkV33+polRF+ywsLKSwsND2PCcnh4iICCVMIiI1kGEY7DiaxXvxKSzflUpRqXVtqUBfD+7qHsE9vSIvXkgzMwmS1liLVElr4GyG/ev1Glnv6nehSBUY6ZjBiNOpSOJY2t8iIvJLJ3MK+Pr8GVRbUuwLVD2irAWqmzuEEeKvApWrudo5392BMdk5ffo0paWlhISE2G0PCQlh//79Du1z+vTpPP/88xX6TBERcSyTyUTXZoF0bRbI34a0YfGWoyzadITjWeeYs/Ywb607zPWtGnNnt6bENW9IA19PCIq2PrqNB4sFTu6xnkF1eDWkbID8U7D7E+sDIDAaYs6vRxV1rRZNFxEREakGjf29Gdc7inG9o0jLLuDr3amsSExlS/IZ2+P5r/bSIyqIWzqGcVP7UBrXV4GqNnFaUaommTZtGo8++qjt+YUzpUREpGYL9vPioeuv4YH+zflh/0nejU9m3c+n+WH/SX7YfxKA1qH16RXTkF4xQfSMbkhQPU8I7WB99H4YSorg2JbzZ1KthmNb4UwSbEuCbQsAk7VtzHXWQlWz3uCpO8aIiIiIVKXQAG8m9IlmQp9oUrPP8XViGssTU9mWcobNSZlsTsrk2S/2EBsdxJAOYdzUPoxG9b2cHbZUktOKUsHBwbi5uZGenm63PT09ndDQUIf26eXlhZeX/mMWEXFVbmYTN7YN4ca2IRw+lceiTUdYfeAUB0/msT8tl/1puSzYkAxAq5D69IoJIjamIbHRQTT084KoPtbH9U9CQY717KkLRaqTeyFtl/Wx4XVw84SmPcuKVOFdwU2/8YiIiIhUlbAAHyb2jWZi32hOZJ1jRWIqyxNT2XEki42HM9l4+EKBqiFDzp9BFeyn/0/vipy+0HnPnj3573//C1gXJW/WrBlTpkyp1ELnFe3zAq13ICJSO5zKLWRzUiYbD2ewKSmDA+l5F7Vp0diPXjENiY0JIja64cW/uOWmQ9Lassv9co7Zv+7lD5F9yopUjVqDyVRdQ5IqpjnfsbS/RUSkMo6dOcvXiWl8lZjKzqNZtu1mE8Q1b8iQDuEMahdi/dFRnKrGL3QOsHjxYsaNG8ecOXPo2bMnr732GkuWLGH//v2EhIQwduxYmjRpwvTp0wHrQuZ791pv8z148GBGjx7N6NGj8fPz45prrrmqPq+GEiYRkdopI++XRapM9qflXtSmeaN65y/3sxaq7NYtMAzIPFxWoEpeB+fO2HfgF2JdLP1CkSqgaXUOSSpJc75jaX+LiEhVOZp51nYG1a5j2bbtbmYTvZs3ZEiHMAa1CyWwnqcTo6y7XKIoBTBz5kxefvll0tLS6Ny5M6+//jqxsbEAXHfddURFRbFgwQIAkpOTiY6OvqiP/v37s3r16qvq82ooYRIRqRsy84tsRaqNhzMuWaSKaVSP2GjrmlS9Yhra3/3FUmq9rO/w+Uv9jsRDSYF9Bw2vKburX3Q/8Ams1jFJ+WjOdyztbxERqQ5HMs6yPDGV5Ykn2H08x7bdzWyizzXB3NIhjN+1C7HeAEccwmWKUjWREiYRkbrpTH4Rm5Mz2XTYWqjal5bDr2fJ6OB61jWpoq1nUoUF+JS9WFwAxzaXFalObAfD8ot3myC8c1mRqlkv8PBBnEdzvmNpf4uISHVLPp1vLVDtSmVvalmByt1som+LYAZ3CGNQ21ACfD2cGGXtp6JUJShhEhERgOyzxeeLVBlsTMpg74kcLL+aNSMb+tLrfIGqV0xDwhv8osh0LgtS1pcVqU7/ZP9mNy9oFnu+SHWdtWBldqvOIcmvaM53LO1vERFxpKTT+axITOWrXans+0WBysPNRN9rghnSMZwb24YQ4KMCVVVTUaoSlDCJiMilZJ8rZmty2ZpUu49nX1SkigjyOV+ksl7y1zTQt+zFnBO/WDR9DeSesH+zdwBE9Ss7kyq4hRZNr2aa8x1L+1tERJzl0Kk8VuyyrkH1yyUbPNxMXNuiEUM6hjGwbQj+3ipQVQUVpSpBCZOIiFyNnIJitiWfsa5Jdb5IVfqrKlXTQB+7NamaBvpgMpmsi6af/hmSzp9FlbQOCrPtP6B+uHWx9AtFKv8wh42trtCc71ja3yIiUhMcPJnL8l1pLE88YXd3Zk83M9e2bMQtHcMY0KYx9VWgqjAVpSpBCZOIiFREXmHJ+TOpMtmUlMGuYxcXqZo08CE2Osh2h7+IoPNFqtISSN0JSavPL5q+CUoL7T8guFXZXf2i+lrPrJJK0ZzvWNrfIiJS0xxIz2X5rlS+2nWCQ6fybds93c1c19J6BtWANiH4ebk7MUrXo6JUJShhEhGRqpBfWMK2lDO2u/vtOpZNya+KVGEB3vSKaWgrVEU29LUWqYrPwZGN58+iWgMnEoBfvNdkhvCuZUWqiFhw93Lg6GoHzfmOpf0tIiI1lWEYHEjPY/muE3yVmMrhXxSovNzNXN+qMUM6hnFD68bUU4HqN6koVQlKmEREpDqcLbIWqS7c3W/nsSyKS+2n4RB/r/NFKuslf9HB9axFqrOZkPxjWZEq46B95+4+1rv5XShShXbUoulXQXO+Y2l/i4iIKzAMg/1pubZF0pNOlxWovD3sC1S+nipQXYqKUpWghElERBzhXFEp24+csd7d73AmCUezKCq12LVpVN/L7kyq5o3OF6myj5Xd1S9pDeSl23fuE1i2aHrMdRAUo0XTL0FzvmNpf4uIiKsxDIN9qbksTzzBV7tSSck4a3vN28PMgNYhDOkYxvWtGuPjqR8EL1BRqhKUMImIiDMUFFuLVBsPZ7LpcAY7jmZRVGJfpAr28yL2/KLpvaKDuKaxHyaAU/vLilTJP0JRrn3nARHWM6iir7P+9WvsmEHVcJrzHUv7W0REXJlhGOw5kcPyxFSW70rlSGZZgcrHw40BbRpzS8cwrmvVGG+Pul2gUlGqEpQwiYhITVBQXErC0Sw2Hs5g0+FMth85Q+FFRSpPev5i4fQWjf0wWUrhxHZrgerwGji6CSzF9p03blt2V7+oPuBV32Hjqkk05zuW9reIiNQWhmGw+3gOXyWeYPmuVI6dOWd7zdfTjYFtrGdQ9W/ZqE4WqFSUqgQlTCIiUhMVlpSy82i2tUiVlMG2lDMUFNsXqYLqeRIbHWS93K95Q1o2ro+55CwciS8rUqXtsu/Y7A5NupUVqZr2AHdPh43LmTTnO5b2t4iI1EaGYbDrWLbtDKrjWWUFqnqebtzYNoQhHcPp1yK4zhSoVJSqBCVMIiLiCgpLStl1LNu2JtW2lDOcKy61a9PA1+N8kcp6JlXr0PqYz2VC8tqyItWZJPuOPXwhsnfZelSN24HZ7KhhOZTmfMfS/hYRkdrOMAwSjmaxfFcqKxJTOZFdYHvNz8vdWqDqEEa/lsF4udfeApWKUpWghElERFxRUYmFxONZbDx/d79tKWc4W2RfpArw8bBd7hcbHUSbMH/cso9YF0u/UKQ6e9q+Y9+G1jOoYvpbi1SBUY4aUrXTnO9Y2t8iIlKXWCwGO45mseL8GVRpOWUFqvpe7tzYLoRbOobR95pGeLrXrh8AVZSqBCVMIiJSGxSXWkg8ns2m80WqrcmZ5P+qSOXv7f6LIlVD2ob54XZqX9ld/ZLXQ3G+fccNIs+fRdXfWqyqF+ywMVU1zfmOpf0tIiJ1lbVAdYavzp9BlZ5TaHvN39ud37ULZUjHMPo0D64VBSoVpSpBCZOIiNRGJaUWdp/IOb9wegZbks+QV1hi16a+tzs9ooLoFWO95K9diDfuqTvKilTHtoDF/j2EdCg7i6pZHHj5OWxMlaU537G0v0VERKwFqm1HzrB8VyrLE1M5lVtWoArw8WBQO+saVL2bN8TDzTULVCpKVYISJhERqQtKSi3sTc2x3d1vc1Imub8qUvl5udMjKpDY83f3a9/QhPuxTWVFqvTd9p2aPawLpV84k6pJN3DzcNiYyktzvmNpf4uIiNgrtRhsTc5keWIqKxLTOJ1XVqBq4OvBoLbWM6jiXKxApaJUJShhEhGRuqjUYrDvfJFq4+EMNidlklNgX6Sq5+lG96ggYmOsl/x1aFCER8q6svWoso/Yd+rpB5F9yopUjduCyeSwMf0WzfmOpf0tIiJyeaUWg81JmSxPPMHK3WmcziuyvRbo68FN7UMZ0iGcXjFBuNfwApWKUpWghElERKSsSLUpKdNWpMo+V2zXxtfTjW6RgfSKaUiv6EA6+GbheWSNtUCVtAbOnbHvtF7jsrWoYq6DBhGOG9AlaM53LO1vERGRq1NSamFzUiZfJabyze40MvLLClRB9Ty5qX0ot3QIo2d0zSxQqShVCUqYRERELmaxGOxPy2VTUtmZVGfO2hepfDwuFKmCiI0OpLPHMTxSzhepUjZAyTn7ToNirMWp6P4QfS34BjluQGjOdzTtbxERkfIrKbWwKSmTr3alsnJ3ql3+FeznaTuDqmd0EG7mmnFGuopSlaCESURE5LdZLAYHTuba7u63KSmTzF/8igfg7WGma7PzZ1I1q0dn80E8U9Zai1THt4Hxy7sBmiCsY1mRqlkcePpW6xg05zuW9reIiEjlFJda2Hg4g+W7Ulm5J40suwKVF4M7hDKkQxjdo5xboFJRqhKUMImIiJSfxWJw8FSebeH0jYcz7E41B/BytxapYmOC6NPUg06le/A8cn5NqlP77Tt084SIWOvlfs1vsC6aXsVq6pz/xhtv8PLLL5OWlkanTp3473//S8+ePS/bfunSpTz99NMkJyfTokULZsyYweDBg22vG4bBs88+y9y5c8nKyqJPnz7MmjWLFi1a2NpkZmby8MMP8+WXX2I2mxk+fDj/+c9/8PMru5virl27eOihh9iyZQuNGjXi4Ycf5vHHH7/qcdXU/S0iIuKKikstbDiUwfJdJ/hmT7rdMguN63txc/tQhnQMp3tkIGYHF6hUlKoEJUwiIiKVZxgGh07lEX84k02HM9h4ONPujjIAnu5mukQ0IDamIf1CS+hUvLOsSJVzvKxh9LUw7ssqj7EmzvmLFy9m7NixzJ49m9jYWF577TWWLl3KTz/9ROPGjS9qv2HDBq699lqmT5/OLbfcwqJFi5gxYwbbt2+nffv2AMyYMYPp06ezcOFCoqOjefrpp0lMTGTv3r14e3sDcPPNN5OamsqcOXMoLi5mwoQJ9OjRg0WLFgHWfdWyZUsGDhzItGnTSExMZOLEibz22mtMmjTpqsZWE/e3iIhIbVBUYmH9odMs35XKN3vSyP3FzWpC/L24uX0Yt3QMo2szxxSoVJSqBCVMIiIiVc8wDA6fzj9/dz9roepk7q+KVG5mOkc0oFd0IP0b5dKhcAeeR9ZCVD+I/UOVx1QT5/zY2Fh69OjBzJkzAbBYLERERPDwww/zxBNPXNR+xIgR5Ofn89VXX9m29erVi86dOzN79mwMwyA8PJw///nPPPbYYwBkZ2cTEhLCggULGDlyJPv27aNt27Zs2bKF7t27A7By5UoGDx7MsWPHCA8PZ9asWfztb38jLS0NT09PAJ544gmWLVvG/v37L4rrUmri/hYREaltikos/HjwFF/tSuW7vel2BapQf28GdwhjSMcwukQ0qLYC1dXO+e7V8ukiIiIiv2IymWjeyI/mjfwYHRuJYRgknc633d1v0+FM0nIK2JycyebkTF4HPNya0qnpgwwKC+V+Zw/AAYqKiti2bRvTpk2zbTObzQwcOJD4+PhLvic+Pp5HH33UbtugQYNYtmwZAElJSaSlpTFw4EDb6wEBAcTGxhIfH8/IkSOJj4+nQYMGtoIUwMCBAzGbzWzatIlhw4YRHx/PtddeaytIXficGTNmcObMGQIDAy+KrbCwkMLCssJjTk5O+XaIiIiIlJunu5kbWodwQ+sQCktK+fFn6xlU3+5NJy2ngHnrk5i3PonwAGuBaurAFtT39nBKrCpKiYiIiFOYTCZiGvkR08iPUT2bYRgGKRlnz9/dz1qoSs0uYGvKGUICvJ0drkOcPn2a0tJSQkJC7LaHhIRc9myktLS0S7ZPS0uzvX5h25Xa/PrSQHd3d4KCguzaREdHX9THhdcuVZSaPn06zz///OUHLCIiItXKy92NAW1CGNAmhILiUtb9fJrlu07w3d50TmQXsCzhONMGt3FafCpKiYiISI1gMpmICq5HVHA9RvSwFqmOZp5jY1IGTRr4ODs8qYBp06bZncWVk5NDRESEEyMSERGpu7w93LixbQg3trUWqNYcOEX2uWKn3qVPRSkRERGpkUwmE80a+tKsoa+zQ3GY4OBg3NzcSE9Pt9uenp5OaGjoJd8TGhp6xfYX/qanpxMWFmbXpnPnzrY2J0+etOujpKSEzMxMu34u9Tm//Ixf8/LywsvL67LjFREREefw9nBjULtLz9+OZHZ2ACIiIiJi5enpSbdu3Vi1apVtm8ViYdWqVcTFxV3yPXFxcXbtAb777jtb++joaEJDQ+3a5OTksGnTJlubuLg4srKy2LZtm63NDz/8gMViITY21tZm7dq1FBcX231Oq1atLnnpnoiIiMhvUVFKREREpAZ59NFHmTt3LgsXLmTfvn1MnjyZ/Px8JkyYAMDYsWPtFkKfOnUqK1eu5F//+hf79+/nueeeY+vWrUyZMgWwnnH2yCOP8I9//IMvvviCxMRExo4dS3h4OEOHDgWgTZs23HTTTdx///1s3ryZ9evXM2XKFEaOHEl4eDgAd999N56entx7773s2bOHxYsX85///OeiRdZFRERErpYu3xMRERGpQUaMGMGpU6d45plnSEtLo3PnzqxcudK2qPiRI0cwm8t+V+zduzeLFi3iqaee4sknn6RFixYsW7aM9u3b29o8/vjj5OfnM2nSJLKysujbty8rV67E27tsAfkPPviAKVOmMGDAAMxmM8OHD+f111+3vR4QEMC3337LQw89RLdu3QgODuaZZ55h0qRJDtgrIiIiUhuZDMMwnB1ETZOTk0NAQADZ2dn4+/s7OxwRERGpJprzHUv7W0REpG642jlfl++JiIiIiIiIiIjDqSglIiIiIiIiIiIOp6KUiIiIiIiIiIg4nIpSIiIiIiIiIiLicCpKiYiIiIiIiIiIw6koJSIiIiIiIiIiDqeilIiIiIiIiIiIOJyKUiIiIiIiIiIi4nAqSomIiIiIiIiIiMOpKCUiIiIiIiIiIg6nopSIiIiIiIiIiDicu7MDqIkMwwAgJyfHyZGIiIhIdbow11+Y+6V6KccSERGpG642x1JR6hJyc3MBiIiIcHIkIiIi4gi5ubkEBAQ4O4xaTzmWiIhI3fJbOZbJ0E+DF7FYLJw4cYL69etjMpmqtO+cnBwiIiI4evQo/v7+Vdp3TaJx1i51YZx1YYygcdY2GmflGYZBbm4u4eHhmM1a1aC6KceqPI2zdtE4a4+6MEbQOGubmpBj6UypSzCbzTRt2rRaP8Pf379W/8d9gcZZu9SFcdaFMYLGWdtonJWjM6QcRzlW1dE4axeNs/aoC2MEjbO2cWaOpZ8ERURERERERETE4VSUEhERERERERERh1NRysG8vLx49tln8fLycnYo1UrjrF3qwjjrwhhB46xtNE6RMnXlvxONs3bROGuPujBG0Dhrm5owTi10LiIiIiIiIiIiDqczpURERERERERExOFUlBIREREREREREYdTUUpERERERERERBxORalq8MYbbxAVFYW3tzexsbFs3rz5iu2XLl1K69at8fb2pkOHDqxYscJBkVZOeca5YMECTCaT3cPb29uB0Zbf2rVrufXWWwkPD8dkMrFs2bLffM/q1avp2rUrXl5eXHPNNSxYsKDa46ys8o5z9erVFx1Lk8lEWlqaYwKugOnTp9OjRw/q169P48aNGTp0KD/99NNvvs/VvpsVGacrfjdnzZpFx44d8ff3x9/fn7i4OL7++usrvsfVjiWUf5yueCx/7cUXX8RkMvHII49csZ0rHk+pGsqxLuaq3/26kGfVhRwLlGddiat9P5VjXZqrHcfLqal5lopSVWzx4sU8+uijPPvss2zfvp1OnToxaNAgTp48ecn2GzZsYNSoUdx7773s2LGDoUOHMnToUHbv3u3gyMunvOME8Pf3JzU11fZISUlxYMTll5+fT6dOnXjjjTeuqn1SUhJDhgzh+uuvJyEhgUceeYT77ruPb775ppojrZzyjvOCn376ye54Nm7cuJoirLw1a9bw0EMPsXHjRr777juKi4v53e9+R35+/mXf44rfzYqME1zvu9m0aVNefPFFtm3bxtatW7nhhhu47bbb2LNnzyXbu+KxhPKPE1zvWP7Sli1bmDNnDh07drxiO1c9nlJ5yrFqT44FdSPPqgs5FijPqk15lnKs2pljQQ3PswypUj179jQeeugh2/PS0lIjPDzcmD59+iXb33XXXcaQIUPstsXGxhp/+MMfqjXOyirvOOfPn28EBAQ4KLqqBxifffbZFds8/vjjRrt27ey2jRgxwhg0aFA1Rla1rmac//vf/wzAOHPmjENiqg4nT540AGPNmjWXbeOq381fuppxuvp384LAwEDj7bffvuRrteFYXnClcbrysczNzTVatGhhfPfdd0b//v2NqVOnXrZtbTqeUj7KsWpnjmUYdSPPqis5lmEoz/ql2vD9VI7l+sexpudZOlOqChUVFbFt2zYGDhxo22Y2mxk4cCDx8fGXfE98fLxde4BBgwZdtn1NUJFxAuTl5REZGUlERMRvVqJdkSsey8ro3LkzYWFh3Hjjjaxfv97Z4ZRLdnY2AEFBQZdtUxuO59WME1z7u1laWspHH31Efn4+cXFxl2xTG47l1YwTXPdYPvTQQwwZMuSi43QpteF4Svkpx6rbORa45vGsKFfOsUB51q+56vdTOZY9Vz2OUPPzLBWlqtDp06cpLS0lJCTEbntISMhlrwVPS0srV/uaoCLjbNWqFfPmzePzzz/n/fffx2Kx0Lt3b44dO+aIkB3icscyJyeHc+fOOSmqqhcWFsbs2bP55JNP+OSTT4iIiOC6665j+/btzg7tqlgsFh555BH69OlD+/btL9vOFb+bv3S143TV72ZiYiJ+fn54eXnxwAMP8Nlnn9G2bdtLtnXlY1mecbrqsfzoo4/Yvn0706dPv6r2rnw8peKUY9XtHAvqRp7l6jkWKM/6NVf8firHupgrHscLXCHPcq+2nkV+IS4uzq7y3Lt3b9q0acOcOXP4+9//7sTIpLxatWpFq1atbM979+7NoUOHePXVV3nvvfecGNnVeeihh9i9ezc//vijs0OpVlc7Tlf9brZq1YqEhASys7P5+OOPGTduHGvWrLlsMuGqyjNOVzyWR48eZerUqXz33XcuuWCoSE3git99uTRXz7FAedavueL3UzlW7cixwHXyLBWlqlBwcDBubm6kp6fbbU9PTyc0NPSS7wkNDS1X+5qgIuP8NQ8PD7p06cLBgwerI0SnuNyx9Pf3x8fHx0lROUbPnj1dIvmYMmUKX331FWvXrqVp06ZXbOuK380LyjPOX3OV76anpyfXXHMNAN26dWPLli385z//Yc6cORe1deVjWZ5x/porHMtt27Zx8uRJunbtattWWlrK2rVrmTlzJoWFhbi5udm9x5WPp1Sccqy6nWNB3c2zXCXHAuVZV8MVvp/KsWpHjgWuk2fp8r0q5OnpSbdu3Vi1apVtm8ViYdWqVZe9PjUuLs6uPcB33313xetZna0i4/y10tJSEhMTCQsLq64wHc4Vj2VVSUhIqNHH0jAMpkyZwmeffcYPP/xAdHT0b77HFY9nRcb5a6763bRYLBQWFl7yNVc8lpdzpXH+miscywEDBpCYmEhCQoLt0b17d0aPHk1CQsJFiRLUruMpV085Vt3OscA1j2dVqOk5FijPKg9X/H4qx7qYqxxHl8mzqm0J9Trqo48+Mry8vIwFCxYYe/fuNSZNmmQ0aNDASEtLMwzDMMaMGWM88cQTtvbr16833N3djVdeecXYt2+f8eyzzxoeHh5GYmKis4ZwVco7zueff9745ptvjEOHDhnbtm0zRo4caXh7ext79uxx1hB+U25urrFjxw5jx44dBmD8+9//Nnbs2GGkpKQYhmEYTzzxhDFmzBhb+8OHDxu+vr7GX/7yF2Pfvn3GG2+8Ybi5uRkrV6501hCuSnnH+eqrrxrLli0zfv75ZyMxMdGYOnWqYTabje+//95ZQ/hNkydPNgICAozVq1cbqamptsfZs2dtbWrDd7Mi43TF7+YTTzxhrFmzxkhKSjJ27dplPPHEE4bJZDK+/fZbwzBqx7E0jPKP0xWP5aX8+q4wteV4SuUpx6o9OZZh1I08qy7kWIahPKs25VnKsWp3jmUYNTPPUlGqGvz3v/81mjVrZnh6eho9e/Y0Nm7caHutf//+xrhx4+zaL1myxGjZsqXh6elptGvXzli+fLmDI66Y8ozzkUcesbUNCQkxBg8ebGzfvt0JUV+9C7fl/fXjwrjGjRtn9O/f/6L3dO7c2fD09DRiYmKM+fPnOzzu8irvOGfMmGE0b97c8Pb2NoKCgozrrrvO+OGHH5wT/FW61PgAu+NTG76bFRmnK343J06caERGRhqenp5Go0aNjAEDBtiSCMOoHcfSMMo/Tlc8lpfy62SpthxPqRrKsWrPd78u5Fl1IccyDOVZtSnPUo5l5erH8UpqYp5lMgzDqPrzr0RERERERERERC5Pa0qJiIiIiIiIiIjDqSglIiIiIiIiIiIOp6KUiIiIiIiIiIg4nIpSIiIiIiIiIiLicCpKiYiIiIiIiIiIw6koJSIiIiIiIiIiDqeilIiIiIiIiIiIOJyKUiIiIiIiIiIi4nAqSomIVJLJZGLZsmXODkNERERERMSlqCglIi5t/PjxmEymix433XSTs0MTERERqXVOnTrF5MmTadasGV5eXoSGhjJo0CDWr18P6Mc6ESkfd2cHICJSWTfddBPz58+32+bl5eWkaERERERqr+HDh1NUVMTChQuJiYkhPT2dVatWkZGR4ezQRMQF6UwpEXF5F36l++UjMDAQsP5aN2vWLG6++WZ8fHyIiYnh448/tnt/YmIiN9xwAz4+PjRs2JBJkyaRl5dn12bevHm0a9cOLy8vwsLCmDJlit3rp0+fZtiwYfj6+tKiRQu++OKL6h20iIiIiINlZWWxbt06ZsyYwfXXX09kZCQ9e/Zk2rRp/P73vycqKgqAYcOGYTKZbM8BPv/8c7p27Yq3tzcxMTE8//zzlJSU2F6/mpxNRGofFaVEpNZ7+umnGT58ODt37mT06NGMHDmSffv2AZCfn8+gQYMIDAxky5YtLF26lO+//96u6DRr1iweeughJk2aRGJiIl988QXXXHON3Wc8//zz3HXXXezatYvBgwczevRoMjMzHTpOERERkerk5+eHn58fy5Yto7Cw8KLXt2zZAsD8+fNJTU21PV+3bh1jx45l6tSp7N27lzlz5rBgwQL+7//+z+79V8rZRKR2MhmGYTg7CBGRiho/fjzvv/8+3t7edtuffPJJnnzySUwmEw888ACzZs2yvdarVy+6du3Km2++ydy5c/nrX//K0aNHqVevHgArVqzg1ltv5cSJE4SEhNCkSRMmTJjAP/7xj0vGYDKZeOqpp/j73/8OWAtdfn5+fP3111rbSkRERGqVTz75hPvvv59z587RtWtX+vfvz8iRI+nYsSNgzYs+++wzhg4danvPwIEDGTBgANOmTbNte//993n88cc5ceKE7X1XytlEpHbSmlIi4vKuv/56uwQGICgoyPa/4+Li7F6Li4sjISEBgH379tGpUydbQQqgT58+WCwWfvrpJ0wmEydOnGDAgAFXjOFCIgZQr149/P39OXnyZEWHJCIiIlIjDR8+nCFDhrBu3To2btzI119/zUsvvcTbb7/N+PHjL/menTt3sn79erszo0pLSykoKODs2bP4+voCV87ZRKR2UlFKRFxevXr1Lrqcrqr4+PhcVTsPDw+75yaTCYvFUh0hiYiIiDiVt7c3N954IzfeeCNPP/009913H88+++xli1J5eXk8//zz3H777ZfsS0TqLq0pJSK13saNGy963qZNGwDatGnDzp07yc/Pt72+fv16zGYzrVq1on79+kRFRbFq1SqHxiwiIiLiKtq2bWvLpTw8PCgtLbV7vWvXrvz0009cc801Fz3M5rL/S3qlnE1EaiedKSUiLq+wsJC0tDS7be7u7gQHBwOwdOlSunfvTt++ffnggw/YvHkz77zzDgCjR4/m2WefZdy4cTz33HOcOnWKhx9+mDFjxhASEgLAc889xwMPPEDjxo25+eabyc3NZf369Tz88MOOHaiIiIiIE2VkZHDnnXcyceJEOnbsSP369dm6dSsvvfQSt912G4Dtx7w+ffrg5eVFYGAgzzzzDLfccgvNmjXjjjvuwGw2s3PnTnbv3m23ZueVcjYRqZ1UlBIRl7dy5UrCwsLstrVq1Yr9+/cD1jvjffTRRzz44IOEhYXx4Ycf0rZtWwB8fX355ptvmDp1Kj169MDX15fhw4fz73//29bXuHHjKCgo4NVXX+Wxxx4jODiYO+64w3EDFBEREakB/Pz8iI2N5dVXX+XQoUMUFxcTERHB/fffz5NPPgnAv/71Lx599FHmzp1LkyZNSE5OZtCgQXz11Ve88MILzJgxAw8PD1q3bs19991n1/+VcjYRqZ109z0RqdUudQcYEREREalZlLOJ1E1aU0pERERERERERBxORSkREREREREREXE4Xb4nIiIiIiIiIiIOpzOlRERERERERETE4VSUEhERERERERERh1NRSkREREREREREHE5FKRERERERERERcTgVpURERERERERExOFUlBIREREREREREYdTUUpERERERERERBxORSkREREREREREXE4FaVERERERERERMTh/h+RTsZnT119KgAAAABJRU5ErkJggg=="},"metadata":{}}]},{"cell_type":"code","source":"use_head_zone = True\n\n# Define paths for saving predictions\ntrain_predictions_dir = '/kaggle/working/train/'\nval_predictions_dir = '/kaggle/working/validate/'\n\n# Create directories if they do not exist\nos.makedirs(train_predictions_dir, exist_ok=True)\nos.makedirs(val_predictions_dir, exist_ok=True)\n\ndef test_ellipse(imgray):\n    ret, thresh = cv2.threshold(imgray, 127, 255, 0)\n    contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n    if not contours:\n        return None\n    largest_contour = max(contours, key=cv2.contourArea)\n    if len(largest_contour) < 5:\n        return None\n    ellipse = cv2.fitEllipse(largest_contour)\n    return ellipse\n\n# Function to run inference and save predictions\ndef save_predictions(loader, model, output_dir):\n    single_batch_validation_loader = DataLoader(loader.dataset, batch_size=1, shuffle=False, num_workers=workers)\n    \n    model.eval()\n    with torch.no_grad():\n        for batch_idx, batch in enumerate(single_batch_validation_loader):\n            image, _, dataset, image_name = batch\n            \n            x = image.to(device)\n            \n            # Get prediction mask\n            pred_mask = model(x)\n            pred_mask = (pred_mask > 0.5).float().cpu().squeeze().numpy()\n            \n            # Apply the ellipse fitting function\n            ellipse = test_ellipse((pred_mask * 255).astype(np.uint8))\n            im_mask = np.zeros_like((pred_mask * 255).astype(np.uint8))\n            \n            if ellipse is not None:\n                im_mask = cv2.ellipse(im_mask, ellipse, (255, 255, 255), -1)\n            \n            if use_head_zone:\n                # Convert original image to numpy array\n                original_image = image.cpu().squeeze().numpy()\n                \n                original_image = (original_image - original_image.min()) / (original_image.max() - original_image.min()) * 255\n\n                # Apply the mask to the original image\n                original_image[im_mask == 0] = 0\n                \n                # Convert image to uint8\n                original_image = original_image.astype(np.uint8)\n                \n                # Save the modified image\n                image_filepath = os.path.join(output_dir, f\"{image_name[0]}_{dataset[0]}\")\n                cv2.imwrite(image_filepath, original_image)\n            else:\n                # Save the mask\n                mask_filepath = os.path.join(output_dir, f\"{image_name[0]}_{dataset[0]}\")\n                cv2.imwrite(mask_filepath, im_mask)\n            \n\n# Save predictions for training and validation sets\nsave_predictions(train_loader_unet, unet_model, train_predictions_dir)\nsave_predictions(val_loader_unet, unet_model, val_predictions_dir)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:32:54.677755Z","iopub.execute_input":"2024-08-14T09:32:54.678473Z","iopub.status.idle":"2024-08-14T09:33:52.385451Z","shell.execute_reply.started":"2024-08-14T09:32:54.678435Z","shell.execute_reply":"2024-08-14T09:33:52.384334Z"},"trusted":true},"execution_count":19,"outputs":[]},{"cell_type":"code","source":"class FHCDataset(Dataset):\n    def __init__(self, df, transform_X, images_dir):\n        self.X = [os.path.join(images_dir, f\"{filename}_{dataset}\") for filename, dataset in zip(df['filename'], df['dataset'])]\n        self.Y = df['classes'].astype(int).tolist()\n        self.dataset = df['dataset'].tolist()\n        self.transform_X = transform_X\n\n    def __len__(self):\n        return len(self.X)\n\n    def __getitem__(self, idx):\n         # Extract the image in grayscale\n        img_path = self.X[idx]\n        image_name = os.path.basename(img_path)\n        img_gray = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)\n\n        # Convert the processed image to PIL Image\n        img_gray_np = Image.fromarray(img_gray)\n\n        # Normalize and turn to tensor\n        tensor_img = self.transform_X(img_gray_np)\n\n        # Extract class label\n        class_label = self.Y[idx]\n\n        # Extract dataset type\n        dataset_type = self.dataset[idx]\n\n        return tensor_img, class_label, dataset_type, image_name","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:35:48.889658Z","iopub.execute_input":"2024-08-14T09:35:48.890458Z","iopub.status.idle":"2024-08-14T09:35:48.899318Z","shell.execute_reply.started":"2024-08-14T09:35:48.890423Z","shell.execute_reply":"2024-08-14T09:35:48.898357Z"},"trusted":true},"execution_count":20,"outputs":[]},{"cell_type":"code","source":"img_size = 512\n\n# Define the transform pipeline including the noise addition\ntransform_X = transforms.Compose([\n    transforms.Resize((img_size, img_size)),\n    transforms.ToTensor(),\n    transforms.Normalize((0.5,), (0.5,)),\n])","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:35:49.336389Z","iopub.execute_input":"2024-08-14T09:35:49.336981Z","iopub.status.idle":"2024-08-14T09:35:49.342026Z","shell.execute_reply.started":"2024-08-14T09:35:49.336950Z","shell.execute_reply":"2024-08-14T09:35:49.341114Z"},"trusted":true},"execution_count":21,"outputs":[]},{"cell_type":"code","source":"train_dataset = FHCDataset(balanced_df, transform_X, train_predictions_dir)\nval_dataset = FHCDataset(val_df, transform_X, val_predictions_dir)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:35:49.774578Z","iopub.execute_input":"2024-08-14T09:35:49.775292Z","iopub.status.idle":"2024-08-14T09:35:49.783623Z","shell.execute_reply.started":"2024-08-14T09:35:49.775262Z","shell.execute_reply":"2024-08-14T09:35:49.782652Z"},"trusted":true},"execution_count":22,"outputs":[]},{"cell_type":"code","source":"print(len(train_dataset))\nprint(len(val_dataset))","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:35:50.042155Z","iopub.execute_input":"2024-08-14T09:35:50.042500Z","iopub.status.idle":"2024-08-14T09:35:50.047476Z","shell.execute_reply.started":"2024-08-14T09:35:50.042475Z","shell.execute_reply":"2024-08-14T09:35:50.046507Z"},"trusted":true},"execution_count":23,"outputs":[{"name":"stdout","text":"1081\n187\n","output_type":"stream"}]},{"cell_type":"code","source":"# Get the unique dataset types from the balanced_df\nunique_dataset_types = balanced_df['dataset'].unique()\n\n# Dictionary to hold one sample from each dataset type\nsamples = {}\n\n# Get indices to iterate over in random order\nindices = np.arange(len(train_dataset))\nnp.random.shuffle(indices)\n\n# Create a subplot with a single row\nplt.figure(figsize=(15, 5))\n\n# Counter to keep track of the current position in the subplot\npos = 1\n\n# Iterate through the shuffled indices\nfor idx in indices:\n    batch = train_dataset[idx]\n    img, label, dataset_type = batch[:3]\n    if dataset_type not in samples:\n        samples[dataset_type] = (img, label)\n        # Plot the sample\n        plt.subplot(1, len(unique_dataset_types), pos)\n        plt.imshow(img.squeeze(), cmap='gray')\n        plt.title(f'{dataset_type.capitalize()} Sample: Class {label}')\n        plt.axis('off')\n        pos += 1\n    \n    # If all dataset types are found, exit the loop\n    if len(samples) == len(unique_dataset_types):\n        break\n\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:35:50.632796Z","iopub.execute_input":"2024-08-14T09:35:50.633524Z","iopub.status.idle":"2024-08-14T09:35:51.000587Z","shell.execute_reply.started":"2024-08-14T09:35:50.633481Z","shell.execute_reply":"2024-08-14T09:35:50.999565Z"},"trusted":true},"execution_count":24,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1500x500 with 2 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"# Define batch size\nbatch_size = 5\n\n# Create data loaders\ntrain_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=workers)\nval_loader = DataLoader(val_dataset, batch_size=batch_size, num_workers=workers)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:36:54.649029Z","iopub.execute_input":"2024-08-14T09:36:54.649881Z","iopub.status.idle":"2024-08-14T09:36:54.655128Z","shell.execute_reply.started":"2024-08-14T09:36:54.649849Z","shell.execute_reply":"2024-08-14T09:36:54.654100Z"},"trusted":true},"execution_count":25,"outputs":[]},{"cell_type":"code","source":"# Define your hyperparameters\nclassifier_epochs = 6\nfull_epochs = 6\nlearning_rate = 0.0001\nweight_decay = 0.01\n\n# Define loss function\ncriterion = nn.CrossEntropyLoss()\n\n# Load pre-trained model\nmodel = timm.create_model('efficientnet_b0', pretrained=True, num_classes=num_classes, in_chans=1)\n\n# Reset the parameters of the classifier\nmodel.classifier = nn.Linear(model.classifier.in_features, num_classes)\n\n# Freeze all layers except the classifier\nfor param in model.parameters():\n    param.requires_grad = False\nfor param in model.classifier.parameters():\n    param.requires_grad = True\n    \n# Optimizer for training the classifier\nclassifier_opt = optim.AdamW(model.classifier.parameters(), lr=learning_rate * 10)\n\n# Use DataParallel for multi-GPU training if available\nif torch.cuda.device_count() > 1:\n    model = nn.DataParallel(model)\n\nmodel.to(device)\n\n# Train and validate classifier\ntrain_and_validate(model, train_loader, val_loader, criterion, classifier_opt, classifier_epochs, \"classification\")\n\n# Unfreeze all layers\nfor param in model.parameters():\n    param.requires_grad = True\n\n# Adjust optimizer to include only unfrozen parameters\nfull_opt = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=weight_decay)\n\n# Train and validate the entire model\ntrain_and_validate(model, train_loader, val_loader, criterion, full_opt, full_epochs, \"classification\", 1)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T09:58:29.250778Z","iopub.execute_input":"2024-08-14T09:58:29.251161Z","iopub.status.idle":"2024-08-14T10:00:32.989028Z","shell.execute_reply.started":"2024-08-14T09:58:29.251125Z","shell.execute_reply":"2024-08-14T10:00:32.988046Z"},"trusted":true},"execution_count":35,"outputs":[{"output_type":"display_data","data":{"text/plain":"model.safetensors:   0%|          | 0.00/21.4M [00:00<?, ?B/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"ad7d4f10ad974a818d10dd7708adc8f7"}},"metadata":{}},{"name":"stdout","text":"================================================================================\nEpoch 1 completed\nAverage train loss: 2.5674664298510224\nAverage validation loss: 2.226667195558548\n================================================================================\n================================================================================\nEpoch 2 completed\nAverage train loss: 2.1892695580759356\nAverage validation loss: 2.1841149455622624\n================================================================================\n================================================================================\nEpoch 3 completed\nAverage train loss: 2.0038442238135272\nAverage validation loss: 2.144115010374471\n================================================================================\n================================================================================\nEpoch 4 completed\nAverage train loss: 1.9266782795778616\nAverage validation loss: 2.092932756009855\n================================================================================\n================================================================================\nEpoch 5 completed\nAverage train loss: 1.8446588763443557\nAverage validation loss: 2.065452763908788\n================================================================================\n================================================================================\nEpoch 6 completed\nAverage train loss: 1.80217471402911\nAverage validation loss: 2.033991294471841\n================================================================================\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x500 with 2 Axes>","image/png":"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"},"metadata":{}},{"name":"stdout","text":"================================================================================\nEpoch 1 completed\nAverage train loss: 1.8165043120010658\nAverage validation loss: 1.8563365889222998\n================================================================================\n================================================================================\nEpoch 2 completed\nAverage train loss: 1.4583663849786679\nAverage validation loss: 1.7637348622083664\n================================================================================\n================================================================================\nEpoch 3 completed\nAverage train loss: 1.182399124319103\nAverage validation loss: 1.8262045720690174\n================================================================================\n================================================================================\nEpoch 4 completed\nAverage train loss: 0.8858565208824\nAverage validation loss: 1.8939634655651294\n================================================================================\nStopping training as training loss is below threshold and validation loss has stopped decreasing.\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x500 with 2 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"from collections import defaultdict\nfrom sklearn.metrics import classification_report, f1_score, accuracy_score\n\ndef evaluate_F1(validation_data):\n    # Create a DataLoader with a specified batch size\n    single_batch_validation_loader = DataLoader(validation_data, batch_size=1, shuffle=False, num_workers=workers)\n\n    with torch.no_grad():\n        model.eval()\n\n        actual_values = []\n        predicted_values = []\n\n        # Iterate over batches\n        for batch in single_batch_validation_loader:\n            X_val, y_val = batch[:2]\n            X_val = X_val.to(device).to(torch.float32)\n\n            # Forward pass\n            y_pred = model(X_val)\n\n            actual_value = y_val.cpu().numpy()\n            predicted_value = np.argmax(y_pred.cpu().numpy(), axis=1)\n\n            actual_values.extend(actual_value)\n            predicted_values.extend(predicted_value)\n\n    # Calculate classification report\n    report = classification_report(actual_values, np.array(predicted_values), output_dict=True, zero_division=1)\n\n    print(\"Classification Report:\")\n    print(classification_report(actual_values, np.array(predicted_values), zero_division=1))\n\n    # Calculate final F1 score and Accuracy\n    final_f1_score = f1_score(actual_values, predicted_values, average='weighted')\n    final_accuracy = accuracy_score(actual_values, predicted_values)\n\n    print(f\"\\nFinal F1 Score (Weighted): {final_f1_score:.4f}\")\n    print(f\"Final Accuracy: {final_accuracy:.4f}\")\n\n    # Find the three classes with the lowest F1 scores\n    f1_scores = {int(k): v['f1-score'] for k, v in report.items() if k.isdigit()}\n    sorted_f1_scores = sorted(f1_scores.items(), key=lambda item: item[1])\n\n    print(\"\\nThree classes with the lowest F1 scores:\")\n    for class_label, score in sorted_f1_scores[:3]:\n        print(f\"Class {class_label}: F1 score = {score:.4f}\")\n\n    # Count the number of wrong predictions for each distance\n    distance_counts = defaultdict(int)\n    for actual, predicted in zip(actual_values, predicted_values):\n        if actual != predicted:\n            distance = abs(predicted - actual)\n            distance_counts[distance] += 1\n\n    print(\"\\nNumber of wrong predictions for each distance:\")\n    for distance, count in sorted(distance_counts.items()):\n        print(f\"Distance {distance}: {count} wrong predictions\")","metadata":{"execution":{"iopub.status.busy":"2024-08-14T10:02:34.218477Z","iopub.execute_input":"2024-08-14T10:02:34.219310Z","iopub.status.idle":"2024-08-14T10:02:34.232606Z","shell.execute_reply.started":"2024-08-14T10:02:34.219276Z","shell.execute_reply":"2024-08-14T10:02:34.231567Z"},"trusted":true},"execution_count":36,"outputs":[]},{"cell_type":"code","source":"# Evaluate only on the train dataset\nevaluate_F1(val_loader.dataset)","metadata":{"execution":{"iopub.status.busy":"2024-08-14T10:02:34.423366Z","iopub.execute_input":"2024-08-14T10:02:34.423751Z","iopub.status.idle":"2024-08-14T10:02:37.054596Z","shell.execute_reply.started":"2024-08-14T10:02:34.423721Z","shell.execute_reply":"2024-08-14T10:02:37.053442Z"},"trusted":true},"execution_count":37,"outputs":[{"name":"stdout","text":"Classification Report:\n              precision    recall  f1-score   support\n\n           0       0.00      0.00      0.00         2\n           1       0.46      0.50      0.48        12\n           2       0.53      0.64      0.58        14\n           3       0.00      0.00      0.00         3\n           4       0.50      0.43      0.46         7\n           5       1.00      0.00      0.00         1\n           6       0.50      0.33      0.40         3\n           7       0.00      0.00      0.00         1\n           8       1.00      0.00      0.00         1\n           9       1.00      0.00      0.00         3\n          10       0.29      0.15      0.20        13\n          11       0.36      0.46      0.40        41\n          12       0.36      0.39      0.37        36\n          13       0.11      0.09      0.10        11\n          14       0.00      0.00      0.00         4\n          15       0.00      0.00      0.00         2\n          16       1.00      0.33      0.50         3\n          17       1.00      0.00      0.00         3\n          18       1.00      0.00      0.00         1\n          19       1.00      0.00      0.00         1\n          20       1.00      0.00      0.00         3\n          21       0.00      0.00      0.00         3\n          22       0.33      0.40      0.36         5\n          23       0.00      0.00      0.00         4\n          24       0.33      0.33      0.33         3\n          25       0.33      0.33      0.33         3\n          26       0.00      0.00      0.00         2\n          27       0.33      0.50      0.40         2\n\n    accuracy                           0.33       187\n   macro avg       0.44      0.18      0.18       187\nweighted avg       0.38      0.33      0.31       187\n\n\nFinal F1 Score (Weighted): 0.3110\nFinal Accuracy: 0.3262\n\nThree classes with the lowest F1 scores:\nClass 0: F1 score = 0.0000\nClass 3: F1 score = 0.0000\nClass 5: F1 score = 0.0000\n\nNumber of wrong predictions for each distance:\nDistance 1: 77 wrong predictions\nDistance 2: 22 wrong predictions\nDistance 3: 8 wrong predictions\nDistance 4: 7 wrong predictions\nDistance 5: 3 wrong predictions\nDistance 6: 3 wrong predictions\nDistance 7: 1 wrong predictions\nDistance 9: 1 wrong predictions\nDistance 10: 1 wrong predictions\nDistance 11: 1 wrong predictions\nDistance 12: 1 wrong predictions\nDistance 17: 1 wrong predictions\n","output_type":"stream"}]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}