diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e69de29 diff --git a/README.md b/README.md index 665c419..424b92c 100644 --- a/README.md +++ b/README.md @@ -1 +1,11 @@ -# hipom_data_mapping \ No newline at end of file +# hipom_data_mapping + +## Before we begin + +This repository utilizes `.py` files rather than `.ipynb` for greater clarity. + +If you use vscode, just use the ipython functionality from `.py` files. + +In order to generate `.ipynb` file from `.py` file, you can do the following: + +`jupytext --to notebook your_script.py` diff --git a/data_import/.gitignore b/data_import/.gitignore new file mode 100644 index 0000000..e5538bb --- /dev/null +++ b/data_import/.gitignore @@ -0,0 +1,3 @@ +db_connection_info.txt +exports/* +outputs/* diff --git a/data_import/README.md b/data_import/README.md new file mode 100644 index 0000000..53e2e54 --- /dev/null +++ b/data_import/README.md @@ -0,0 +1,42 @@ +# Data Import + +## What is this folder + +This folder contains the files needed to import files from the remote database +to local csv files. + +This folder contains the following files: + +- `select_db.py`: + - use this to pull the raw datasets `data_mapping.csv` and + `data_model_master_export.csv` +- `make_csv.py`: + - perform basic processing + - produces the following files: + - `raw_data.csv`: `data_mapping.csv` without some fields + - `data_mapping_mdm.csv`: mdm subset of `raw_data.csv` +- `make_figures` sub-directory + - `plot_class_token.ipynb`: get number of thing-property combinations, and + plot the histogram of thing-property counts along with the tag_description + character counts + - `plot_count.ipynb`: get counts of ship-data and platform-data +- `exports` sub-directory: + - this folder stores the files that were produced from import +- `outputs` sub-directory: + - this folder stores the exported figures from `make_figures` + +## Instructions + +Check the following: + +- Remember to activate your python environment +- Ensure that the `db_connection_info.txt` is linked to this directory + - e.g. `ln -s /some/directory/db_connection_info.txt .` + +To import data, execute the following: + +- `cd` into this folder. +- `python select_db.py` +- `python make_csv.py` + +Export files will be found in `exports`. This helps to keep the folder clean. \ No newline at end of file diff --git a/data_import/2.make_csv.py b/data_import/make_csv.py similarity index 84% rename from data_import/2.make_csv.py rename to data_import/make_csv.py index 1ce8787..f6b1861 100644 --- a/data_import/2.make_csv.py +++ b/data_import/make_csv.py @@ -2,9 +2,9 @@ import pandas as pd import re # Load the data_mapping CSV file -data_mapping_file_path = 'data_import/data_mapping.csv' # Adjust this path to your actual file location +data_mapping_file_path = 'exports/data_mapping.csv' # Adjust this path to your actual file location data_mapping = pd.read_csv(data_mapping_file_path, dtype=str) -df_master = pd.read_csv('data_import/data_model_master_export.csv') +df_master = pd.read_csv('exports/data_model_master_export.csv') # Generate patterns data_mapping['thing_pattern'] = data_mapping['thing'].str.replace(r'\d', '#', regex=True) @@ -23,7 +23,7 @@ fields_to_remove = ['equip_type_code', 'tx_period', 'tx_type', 'on_change_yn', ' merged_data = data_mapping.drop(columns=fields_to_remove) # Save the updated DataFrame to a new CSV file -output_file_path = 'data_import/raw_data.csv' +output_file_path = 'exports/raw_data.csv' merged_data.to_csv(output_file_path, index=False, encoding='utf-8-sig') print(f"Updated data saved to {output_file_path}") @@ -32,7 +32,7 @@ print(f"Updated data saved to {output_file_path}") data_mapping_mdm_true = merged_data[merged_data['MDM']] # Save the filtered DataFrame to a new CSV file -mdm_true_output_file_path = 'data_import/data_mapping_mdm.csv' +mdm_true_output_file_path = 'exports/data_mapping_mdm.csv' data_mapping_mdm_true.to_csv(mdm_true_output_file_path, index=False, encoding='utf-8-sig') print(f"MDM TRUE data saved to {mdm_true_output_file_path}") diff --git a/data_import/make_figures/.gitignore b/data_import/make_figures/.gitignore new file mode 100644 index 0000000..5dd4c45 --- /dev/null +++ b/data_import/make_figures/.gitignore @@ -0,0 +1,3 @@ +plot_class_token.ipynb +plot_count.ipynb + diff --git a/data_import/make_figures/plot_class_token.py b/data_import/make_figures/plot_class_token.py new file mode 100644 index 0000000..162cdca --- /dev/null +++ b/data_import/make_figures/plot_class_token.py @@ -0,0 +1,139 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.16.4 +# kernelspec: +# display_name: torch +# language: python +# name: python3 +# --- + +# %% +import pandas as pd +import os +import re +import numpy as np +import matplotlib.pyplot as plt + +# CSV 파일 읽기 +df = pd.read_csv('../exports/raw_data.csv') + +# MDM이 True인 데이터만 필터링 +mdm_true_df = df[df['MDM'] == True] + +# 'thing'과 'property'로 그룹화하여 'tag_description'을 이어붙이기 (NaN을 빈 문자열로 처리) +tag_description_concatenated = mdm_true_df.groupby(['thing', 'property'])['tag_description'].apply(lambda x: ' '.join(x.dropna().astype(str))).reset_index() + +# 'thing'과 'property'로 그룹화하여 'tag_name'을 이어붙이기 (NaN을 빈 문자열로 처리) +tag_name_concatenated = mdm_true_df.groupby(['thing', 'property'])['tag_name'].apply(lambda x: ' '.join(x.dropna().astype(str))).reset_index() + +# 'thing'과 'property'의 매핑 개수 계산 +mapping_count = mdm_true_df.groupby(['thing', 'property']).size().reset_index(name='mapping_count') + +# 세 개의 데이터프레임 병합: mapping_count, tag_description_concatenated, tag_name_concatenated +thing_property_grouped = pd.merge(mapping_count, tag_description_concatenated, on=['thing', 'property']) +thing_property_grouped = pd.merge(thing_property_grouped, tag_name_concatenated, on=['thing', 'property']) + +# 'tag_description'에서 공백으로 분리된 토큰 수 계산 +thing_property_grouped['td_token_count'] = thing_property_grouped['tag_description'].apply(lambda x: len(re.findall(r'\S+', x))) + +# 'tag_description'에서 고유한 토큰 수 계산 (unique_token_count) +thing_property_grouped['unique_token_count'] = thing_property_grouped['tag_description'].apply(lambda x: len(set(re.findall(r'\S+', x)))) + +# 'thing'과 'property'에서 숫자를 '#'으로 대체하여 pattern 생성 +thing_property_grouped['pattern'] = thing_property_grouped['thing'].str.replace(r'\d', '#', regex=True) + " " + thing_property_grouped['property'].str.replace(r'\d', '#', regex=True) + +# 고유한 thing_property 조합의 총 개수 계산 +total_thing_property_count = thing_property_grouped.shape[0] + +# 저장 경로 지정 +output_path = '../outputs/thing_property_grouped.csv' + +# 디렉터리 생성 (존재하지 않으면) +output_dir = os.path.dirname(output_path) +os.makedirs(output_dir, exist_ok=True) + +# 결과를 CSV 파일로 저장 +thing_property_grouped.to_csv(output_path, index=False, encoding='utf-8-sig') + +# 결과 출력 +print(f"Concatenated data saved to {output_path}") +print(f"Total number of unique thing_property combinations: {total_thing_property_count}") + + +# %% + +# Left axis: Plotting the histogram for mapping_count +fig, ax1 = plt.subplots(figsize=(12, 8)) + +# Histogram for mapping_count +ax1.hist(thing_property_grouped['mapping_count'], bins=30, color='skyblue', edgecolor='black', alpha=0.7) +ax1.set_xlabel('Mapping Count', fontsize=24, color='black') # X-axis label with larger font +ax1.set_ylabel('Frequency', fontsize=24, color='black') # Y-axis label with larger font +ax1.grid(True, linestyle='--', alpha=0.7) + +# Set axis color to black +ax1.spines['bottom'].set_color('black') +ax1.spines['top'].set_color('black') +ax1.spines['right'].set_color('black') +ax1.spines['left'].set_color('black') + +# Make tick labels larger +ax1.tick_params(axis='x', colors='black', labelsize=18) +ax1.tick_params(axis='y', colors='black', labelsize=18) + +# Right axis: Plotting unique_token_count min, max, and average +ax2 = ax1.twinx() + +# Group by mapping_count to calculate min, max, and average of unique_token_count +grouped_token_stats = thing_property_grouped.groupby('mapping_count')['unique_token_count'].agg(['min', 'max', 'mean']).reset_index() + +# Plot the min-max range as a shaded area +ax2.fill_between(grouped_token_stats['mapping_count'], + grouped_token_stats['min'], + grouped_token_stats['max'], + color='lightgray', alpha=0.5, label='Min-Max Range') + +# Plot the average unique_token_count as a line +ax2.plot(grouped_token_stats['mapping_count'], + grouped_token_stats['mean'], + color='red', marker='o', linestyle='-', label='Average Unique Token Count') + +ax2.set_ylabel('Unique Token Count (Min/Max/Avg)', fontsize=24, color='black') # Larger font for right Y-axis label +ax2.tick_params(axis='y', colors='black', labelsize=18) + +# Add legends +ax1.legend(['Frequency'], loc='upper left', fontsize=18) +ax2.legend(loc='upper right', fontsize=18) + +# Add a logarithmic trendline +# Applying log to mapping_count for the trendline +log_mapping_count = np.log(grouped_token_stats['mapping_count']) + +# Fit a linear model on the log of the mapping_count +z = np.polyfit(log_mapping_count, grouped_token_stats['mean'], 1) # Linear fit on log-transformed data +p = np.poly1d(z) + +# Generate x values and corresponding y values for the trendline +x_vals = np.linspace(grouped_token_stats['mapping_count'].min(), grouped_token_stats['mapping_count'].max(), 500) +log_x_vals = np.log(x_vals) +y_vals = p(log_x_vals) + +# Plot the logarithmic trendline +ax2.plot(x_vals, y_vals, color='green', linestyle='--', label='Logarithmic Trendline') + +# Add the trendline to the legend +ax2.legend(loc='upper right', fontsize=18) + +plt.tight_layout() + +plt.savefig('../outputs/thing-property_histogram_with_char_count.png') +plt.show() + + +# %% diff --git a/data_import/make_figures/plot_count.py b/data_import/make_figures/plot_count.py new file mode 100644 index 0000000..208c9f9 --- /dev/null +++ b/data_import/make_figures/plot_count.py @@ -0,0 +1,143 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.16.4 +# kernelspec: +# display_name: hug +# language: python +# name: python3 +# --- + +# %% +import pandas as pd +import matplotlib.pyplot as plt +import numpy as np +import os + +# note: we assume that you will execute from the directory of this code +# check your current directory +print("Current Working Directory:", os.getcwd()) + + +# %% + + + +# 전체 글꼴 크기 설정 +plt.rcParams.update({'font.size': 18}) + +# CSV 파일 읽기 +df = pd.read_csv('../exports/raw_data.csv') + +# ships_idx 별 전체 갯수 계산 +total_counts = df['ships_idx'].value_counts().sort_index() + +# ships_idx 별 MDM=True 인 갯수 계산 +mdm_true_counts = df[df['MDM'] == True]['ships_idx'].value_counts().sort_index() + +# 데이터프레임으로 합치기 +summary_df = pd.DataFrame({ + 'SD': total_counts, + 'PD': mdm_true_counts +}).fillna(0) # NaN 값을 0으로 대체 + +# SD와 PD의 총 갯수 계산 +total_SD = summary_df['SD'].sum() +total_PD = summary_df['PD'].sum() + +# 총 갯수 출력 +print(f"Total SD: {total_SD}") +print(f"Total PD: {total_PD}") + +# 시각화 +fig, ax = plt.subplots(figsize=(10, 6)) + +# Total Counts 먼저 그리기 (굵은 막대로 설정) +summary_df['SD'].plot(kind='barh', ax=ax, color='orange', alpha=0.5, label='SD', width=0.8) # 막대 폭을 넓게 설정 + +# MDM=True Counts를 그 위에 겹쳐서 그리기 (굵은 막대로 설정) +summary_df['PD'].plot(kind='barh', ax=ax, color='blue', alpha=0.7, label='PD', width=0.8) # 막대 폭을 넓게 설정 + +# y축 라벨을 10 단위로 설정 +y_labels = ax.get_yticks() +ax.set_yticks(np.arange(min(y_labels), max(y_labels) + 1, 10)) +ax.set_yticklabels([int(label) for label in np.arange(min(y_labels), max(y_labels) + 1, 10)]) + +# 그리드 추가 +ax.grid(True) + +# 범례와 제목 설정 +plt.legend(prop={'size': 18}) # 레전드 글꼴 크기 설정 +plt.xlabel('Counts') +plt.ylabel('Ships') + + +# save to outputs +# Save the plot to the specified folder +plt.savefig('../outputs/count_statistics_of_each_ship.png') + +# 그래프 출력 +plt.show() + + +# %% + +# SD와 PD의 총 갯수 계산 +total_SD = summary_df['SD'].sum() # SD의 총 갯수 +total_PD = summary_df['PD'].sum() # PD의 총 갯수 + +# tag_description의 글자수 계산 +df['tag_description_length'] = df['tag_description'].astype(str).apply(len) + +# tag_description의 평균 글자수 계산 +mean_tag_description_length = df['tag_description_length'].mean() + +# 결과 출력 +print(f"Tag Description의 평균 글자수: {mean_tag_description_length:.2f}") + +# 글자수 분포를 히스토그램으로 시각화 +plt.figure(figsize=(10, 6)) +plt.hist(df['tag_description_length'], bins=30, color='skyblue', edgecolor='black', alpha=0.7) +plt.title('Distribution of Tag Description Lengths') +plt.xlabel('Tag Description Length (characters)') +plt.ylabel('Frequency') +plt.grid(True) +plt.show() + +# tag_description을 ' '로 split한 후 토큰 수 계산 +df['tag_description_tokens'] = df['tag_description'].astype(str).apply(lambda x: len(x.split(' '))) + +# tag_description의 평균 토큰 수 계산 +mean_tag_description_tokens = df['tag_description_tokens'].mean() + +# 결과 출력 +print(f"Tag Description의 평균 토큰 수: {mean_tag_description_tokens:.2f}") + +# 토큰 수 분포를 히스토그램으로 시각화 +plt.figure(figsize=(10, 6)) +plt.hist(df['tag_description_tokens'], bins=30, color='lightgreen', edgecolor='black', alpha=0.7) +plt.title('Distribution of Tag Description Tokens') +plt.xlabel('Number of Tokens') +plt.ylabel('Frequency') +plt.grid(True) +plt.show() + +# 전체 텍스트에서 모든 토큰 수와 고유 토큰 수 계산 +all_tokens = df['tag_description'].astype(str).apply(lambda x: x.split(' ')).sum() # 전체 토큰 리스트 +unique_tokens = set(all_tokens) # 고유 토큰 집합 + +# 전체 토큰 수와 고유 토큰 수 계산 +total_token_count = len(all_tokens) +unique_token_count = len(unique_tokens) + +# 결과 출력 +print(f"전체 토큰 수: {total_token_count}") +print(f"고유 토큰 수: {unique_token_count}") + + +# %% diff --git a/data_import/plot_class_token.ipynb b/data_import/plot_class_token.ipynb deleted file mode 100644 index 8d93891..0000000 --- a/data_import/plot_class_token.ipynb +++ /dev/null @@ -1,176 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Concatenated data saved to output/thing_property_grouped.csv\n", - "Total number of unique thing_property combinations: 691\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import os\n", - "import re\n", - "\n", - "# CSV 파일 읽기\n", - "df = pd.read_csv('raw_data.csv')\n", - "\n", - "# MDM이 True인 데이터만 필터링\n", - "mdm_true_df = df[df['MDM'] == True]\n", - "\n", - "# 'thing'과 'property'로 그룹화하여 'tag_description'을 이어붙이기 (NaN을 빈 문자열로 처리)\n", - "tag_description_concatenated = mdm_true_df.groupby(['thing', 'property'])['tag_description'].apply(lambda x: ' '.join(x.dropna().astype(str))).reset_index()\n", - "\n", - "# 'thing'과 'property'로 그룹화하여 'tag_name'을 이어붙이기 (NaN을 빈 문자열로 처리)\n", - "tag_name_concatenated = mdm_true_df.groupby(['thing', 'property'])['tag_name'].apply(lambda x: ' '.join(x.dropna().astype(str))).reset_index()\n", - "\n", - "# 'thing'과 'property'의 매핑 개수 계산\n", - "mapping_count = mdm_true_df.groupby(['thing', 'property']).size().reset_index(name='mapping_count')\n", - "\n", - "# 세 개의 데이터프레임 병합: mapping_count, tag_description_concatenated, tag_name_concatenated\n", - "thing_property_grouped = pd.merge(mapping_count, tag_description_concatenated, on=['thing', 'property'])\n", - "thing_property_grouped = pd.merge(thing_property_grouped, tag_name_concatenated, on=['thing', 'property'])\n", - "\n", - "# 'tag_description'에서 공백으로 분리된 토큰 수 계산\n", - "thing_property_grouped['td_token_count'] = thing_property_grouped['tag_description'].apply(lambda x: len(re.findall(r'\\S+', x)))\n", - "\n", - "# 'tag_description'에서 고유한 토큰 수 계산 (unique_token_count)\n", - "thing_property_grouped['unique_token_count'] = thing_property_grouped['tag_description'].apply(lambda x: len(set(re.findall(r'\\S+', x))))\n", - "\n", - "# 'thing'과 'property'에서 숫자를 '#'으로 대체하여 pattern 생성\n", - "thing_property_grouped['pattern'] = thing_property_grouped['thing'].str.replace(r'\\d', '#', regex=True) + \" \" + thing_property_grouped['property'].str.replace(r'\\d', '#', regex=True)\n", - "\n", - "# 고유한 thing_property 조합의 총 개수 계산\n", - "total_thing_property_count = thing_property_grouped.shape[0]\n", - "\n", - "# 저장 경로 지정\n", - "output_path = 'output/thing_property_grouped.csv'\n", - "\n", - "# 디렉터리 생성 (존재하지 않으면)\n", - "output_dir = os.path.dirname(output_path)\n", - "os.makedirs(output_dir, exist_ok=True)\n", - "\n", - "# 결과를 CSV 파일로 저장\n", - "thing_property_grouped.to_csv(output_path, index=False, encoding='utf-8-sig')\n", - "\n", - "# 결과 출력\n", - "print(f\"Concatenated data saved to {output_path}\")\n", - "print(f\"Total number of unique thing_property combinations: {total_thing_property_count}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Left axis: Plotting the histogram for mapping_count\n", - "fig, ax1 = plt.subplots(figsize=(12, 8))\n", - "\n", - "# Histogram for mapping_count\n", - "ax1.hist(thing_property_grouped['mapping_count'], bins=30, color='skyblue', edgecolor='black', alpha=0.7)\n", - "ax1.set_xlabel('Mapping Count', fontsize=24, color='black') # X-axis label with larger font\n", - "ax1.set_ylabel('Frequency', fontsize=24, color='black') # Y-axis label with larger font\n", - "ax1.grid(True, linestyle='--', alpha=0.7)\n", - "\n", - "# Set axis color to black\n", - "ax1.spines['bottom'].set_color('black')\n", - "ax1.spines['top'].set_color('black') \n", - "ax1.spines['right'].set_color('black')\n", - "ax1.spines['left'].set_color('black')\n", - "\n", - "# Make tick labels larger\n", - "ax1.tick_params(axis='x', colors='black', labelsize=18)\n", - "ax1.tick_params(axis='y', colors='black', labelsize=18)\n", - "\n", - "# Right axis: Plotting unique_token_count min, max, and average\n", - "ax2 = ax1.twinx()\n", - "\n", - "# Group by mapping_count to calculate min, max, and average of unique_token_count\n", - "grouped_token_stats = thing_property_grouped.groupby('mapping_count')['unique_token_count'].agg(['min', 'max', 'mean']).reset_index()\n", - "\n", - "# Plot the min-max range as a shaded area\n", - "ax2.fill_between(grouped_token_stats['mapping_count'],\n", - " grouped_token_stats['min'],\n", - " grouped_token_stats['max'],\n", - " color='lightgray', alpha=0.5, label='Min-Max Range')\n", - "\n", - "# Plot the average unique_token_count as a line\n", - "ax2.plot(grouped_token_stats['mapping_count'],\n", - " grouped_token_stats['mean'],\n", - " color='red', marker='o', linestyle='-', label='Average Unique Token Count')\n", - "\n", - "ax2.set_ylabel('Unique Token Count (Min/Max/Avg)', fontsize=24, color='black') # Larger font for right Y-axis label\n", - "ax2.tick_params(axis='y', colors='black', labelsize=18)\n", - "\n", - "# Add legends\n", - "ax1.legend(['Frequency'], loc='upper left', fontsize=18)\n", - "ax2.legend(loc='upper right', fontsize=18)\n", - "\n", - "# Add a logarithmic trendline\n", - "# Applying log to mapping_count for the trendline\n", - "log_mapping_count = np.log(grouped_token_stats['mapping_count'])\n", - "\n", - "# Fit a linear model on the log of the mapping_count\n", - "z = np.polyfit(log_mapping_count, grouped_token_stats['mean'], 1) # Linear fit on log-transformed data\n", - "p = np.poly1d(z)\n", - "\n", - "# Generate x values and corresponding y values for the trendline\n", - "x_vals = np.linspace(grouped_token_stats['mapping_count'].min(), grouped_token_stats['mapping_count'].max(), 500)\n", - "log_x_vals = np.log(x_vals)\n", - "y_vals = p(log_x_vals)\n", - "\n", - "# Plot the logarithmic trendline\n", - "ax2.plot(x_vals, y_vals, color='green', linestyle='--', label='Logarithmic Trendline')\n", - "\n", - "# Add the trendline to the legend\n", - "ax2.legend(loc='upper right', fontsize=18)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "torch", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/data_import/plot_count.ipynb b/data_import/plot_count.ipynb deleted file mode 100644 index eaae64a..0000000 --- a/data_import/plot_count.ipynb +++ /dev/null @@ -1,218 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total SD: 62071\n", - "Total PD: 10530\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# 전체 글꼴 크기 설정\n", - "plt.rcParams.update({'font.size': 18})\n", - "\n", - "# CSV 파일 읽기\n", - "df = pd.read_csv('raw_data.csv')\n", - "\n", - "# ships_idx 별 전체 갯수 계산\n", - "total_counts = df['ships_idx'].value_counts().sort_index()\n", - "\n", - "# ships_idx 별 MDM=True 인 갯수 계산\n", - "mdm_true_counts = df[df['MDM'] == True]['ships_idx'].value_counts().sort_index()\n", - "\n", - "# 데이터프레임으로 합치기\n", - "summary_df = pd.DataFrame({\n", - " 'SD': total_counts,\n", - " 'PD': mdm_true_counts\n", - "}).fillna(0) # NaN 값을 0으로 대체\n", - "\n", - "# SD와 PD의 총 갯수 계산\n", - "total_SD = summary_df['SD'].sum()\n", - "total_PD = summary_df['PD'].sum()\n", - "\n", - "# 총 갯수 출력\n", - "print(f\"Total SD: {total_SD}\")\n", - "print(f\"Total PD: {total_PD}\")\n", - "\n", - "# 시각화\n", - "fig, ax = plt.subplots(figsize=(10, 6))\n", - "\n", - "# Total Counts 먼저 그리기 (굵은 막대로 설정)\n", - "summary_df['SD'].plot(kind='barh', ax=ax, color='orange', alpha=0.5, label='SD', width=0.8) # 막대 폭을 넓게 설정\n", - "\n", - "# MDM=True Counts를 그 위에 겹쳐서 그리기 (굵은 막대로 설정)\n", - "summary_df['PD'].plot(kind='barh', ax=ax, color='blue', alpha=0.7, label='PD', width=0.8) # 막대 폭을 넓게 설정\n", - "\n", - "# y축 라벨을 10 단위로 설정\n", - "y_labels = ax.get_yticks()\n", - "ax.set_yticks(np.arange(min(y_labels), max(y_labels) + 1, 10))\n", - "ax.set_yticklabels([int(label) for label in np.arange(min(y_labels), max(y_labels) + 1, 10)])\n", - "\n", - "# 그리드 추가\n", - "ax.grid(True)\n", - "\n", - "# 범례와 제목 설정\n", - "plt.legend(prop={'size': 18}) # 레전드 글꼴 크기 설정\n", - "plt.xlabel('Counts')\n", - "plt.ylabel('Ships')\n", - "\n", - "# 그래프 출력\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Tag Description의 평균 글자수: 27.38\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5EAAAJACAYAAAAUx+KBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACmTElEQVR4nOzdd3xUVf7/8fckpDdCDT0BiVQVRF0EFJAqoKwIoiBIFxRFBVdWpNmW7u6qIEUERKmKLFKCCArYAAuCCAhJiNRISSdt7u8PfpnvhEwmk+Smkdfz8ZjHYzLnfM49c3PmZj45955rMQzDEAAAAAAALnAr6Q4AAAAAAMoOkkgAAAAAgMtIIgEAAAAALiOJBAAAAAC4jCQSAAAAAOAykkgAAAAAgMtIIgEAAAAALiOJBAAAAAC4jCQSAAAAAOAykkigHLBYLLJYLGrfvn1Jd6VAnnjiCdt7iIqKylG+a9cuW/nUqVOLvX9muVHeR3GJiYnRs88+qyZNmsjf39+272677baS7hrKqdDQUFksFoWGhpZ0V3KYOnWq7TOya9euku4OSrm8/u4CFUq6AwCusVgsDl/39PRUYGCggoKCVK9ePbVs2VJ33XWXevToIR8fn2LupWNZCU9oaKieeOKJEu1LaXLlyhW99dZbkqTbbrtNvXv3LtH+3Eh+//133X333bp8+XKB4j/44AMNGTLElL5ERkaWyqTBmbJ8vME1P//8szZs2CBJ6t27d7n/54n9mDYMowR7UjoxXmA2kkiglEtLS9Nff/2lv/76SydOnNCXX34pSapYsaIGDx6sadOmKSgoqET7OG3aNEnSvffeSxJp58qVK7Z9M3jwYJJIE7344ou2BLJnz5568MEHVaVKFUkq8c9DWVYWjje45ueff7YdX0JDQ0kK4BTjBWYjiQRKoU8//dT23DAMxcXF6fLly/r555/19ddfKyoqSleuXNG///1vrV+/Xh9//LHatm2ba3tl/b+yH3zwgT744IOS7kaRa9++fZn/XRWH9PR0bd++XZLUuHFjbdy4MdeZtdx07Ngx2+fsev/5z3+0c+dOSdLYsWPVsWPHXOtWq1YtX9subcw+3pRnpfm0v6lTp3KaPADTkEQCpZCzGSvDMLRlyxaNGzdOx48f159//qmePXtq7969atq0afF1Eighf/31l65evSpJuvXWW/OdQEpS3bp1Vbdu3VzLs077kqSWLVve0LPIHG8AAPnFwjpAGWOxWHT//fdr//79ttmAuLg49e3bV1artYR7BxS91NRU23MvL68S7MmNj+MNAMARkkigjAoMDNSaNWtUsWJFSdKRI0e0evVqh3VdWZ31zJkzmjx5slq3bq1KlSrJw8NDwcHBatiwodq1a6fnn39eu3fvdthulq+++sr2mv3DfiVARyuQHj16VOPGjVPjxo0VGBgoi8WS7fTVgqwS9+uvv2rkyJFq0KCBfHx8VLVqVXXq1Ekff/yx07gPPvjAtq28TqHNrW5UVJQsFovCwsJsry1btszhvrF/P/lZnTU5OVnz5s1Thw4dFBISIi8vL1WrVk1t27bVm2++qbi4OKfxjlZq/O677zRgwADVq1fP1l7Pnj21detWp23l16VLl/Tqq6+qdevWqlq1qjw9PVWjRg116tRJ//3vf22zjNfLGgd57dfiOqUwPj5eK1eu1LBhw9SiRQtVrFhRHh4eqlSpklq2bKkXXnhBJ06ccLm9EydOaMyYMbrpppvk4+OjatWq6Z577tHChQuVmZkpqeRWWs7P8SZLWlqalixZogceeEB16tSRt7e3KlasqFtuuUUvvPCCS7+nghyXrmcYhjZs2KDHH39cDRs2VGBgYLYx98Ybbzjsi6PPyI4dO/Too48qLCxM3t7eOcZbXquzOmpz8+bNevDBB1W7dm15eXmpdu3aevTRR/Xtt986bCPruGO/MNSQIUNyfA6u70N+VmeNiYnRSy+9pJYtW6pSpUry8vJSrVq11KtXL33wwQe28Zib9u3b5/j7sGrVKnXu3Nl2vKpXr56eeOIJ/f77707bKm5Wq1Vr1qzRI488orCwMPn6+iogIECNGjXS6NGj9euvvzqNL4pja1pamt566y397W9/U3BwsPz9/dW4cWNNmDBBp06dkpT738mCjhdHtm3bpt69e9vGas2aNdW3b199//33ecaa8VlGKWMAKBUk2R758eKLL9riOnXq5LTte++912H5pk2bDH9//2x9cPQICgrKtc/OHjt37rTF7Ny50/b6lClTjGXLlhk+Pj45YpYuXWqLGTx4sO31yMjIHP2/vs3ly5cbXl5eufanR48eRkpKisN9sXTpUod9yE/dyMhIl/eN/fu5/n3k5ttvvzVq1qzptN3KlSsb27Zty7WNKVOmZPv9vPbaa4abm1uu7U2ePNnpvnDVhg0bjIoVKzrte926dY0ff/wxR6z9OHB1nxaU/bYcjYPU1FSnYyzrUaFCBePtt9/Oc3sfffSRw8+B/Wf3ypUreX6WXVWUxxvDMIx9+/YZYWFhTveNp6ensWDBglzbKOhxyd4ff/xhtGzZMs82QkNDc8Taf0a+/PJL46mnnspzvNWrV8+QZNSrV89hf67/3I0ZMybXPrm5uRlTp07N0Yb9ccfZ4/o+XL/t3CxYsMDpWJRkNG/e3Onn7N5777XVTUlJMXr37p1rW15eXsbmzZtzbctVBR3T9v744w/jtttuc/re3dzcjFdeeSXXNsw+tv75559G06ZNc40PDg42duzYkevfyYKOF/v2Tpw4YYwePdrpPlm8eHGu78GMzzJKH66JBMq4xx57TDNnzpQkffPNN0pPT5eHh4fL8adPn1b//v2VmJgoSerRo4c6d+6smjVrymq16sKFC/rll1+0ffv2HLNbWQty/P3vf5ckNW3aVK+99lqObTRr1szhtvfu3avXX39d7u7uGjZsmNq0aSNvb28dPXpUISEhLr8He/v27dMbb7whSRo6dKjuueceubu7a9++fVqyZImSkpL0+eefa+DAgVq3bl2BtpGXatWq6dNPP9WFCxc0atQoSVKHDh30zDPPOKybHz/99JM6duyolJQUSVKLFi302GOPqW7dujp37pzWrFmjvXv36uLFi+rZs6ciIiLynLVauHChPv74Y9WqVUtPPPGEmjZtqrS0NG3dulWrV6+WYRiaPn267r33XqcLzORl8+bN6tOnj20W45577tHDDz+s6tWrKzo6WitWrNCvv/6qU6dO6d5779UPP/ygRo0a2eKfeeYZ9e7dO8/9WhwL3VitVqWmpqpmzZrq3LmzbrnlFlWvXl1ubm6KiYnRN998o40bNyojI0NPP/20atasafucXG/Hjh16/PHHbfvl3nvv1cMPP6xq1arp1KlTWrFihb766iuNGDGiyN9XXlw53nz77bfq1KmTkpOTZbFY1LVrV3Xp0kW1atVSSkqKvv32W61YsULJycl68skn5eXllWNV58Icl7IcO3ZMrVu31qVLlyRJNWrU0COPPKJbb71Vfn5+unDhgvbv369NmzbluaDVrFmztGXLFoWEhOiJJ55Qs2bNlJGRoR9++KHAp1T/+9//1oYNG1SlShUNHz5ct9xyi5KTk7V161atX79eVqtVU6dOVeXKlfX000/b4rIWhfryyy/13//+V5LjxZ98fX3z3af33ntPTz75pO3nXr16qUePHqpYsaKOHTumpUuXKjIyUr/++qvatm2rn376SVWrVnXa5tChQ7Vhwwbdfvvt6t+/v+rWrau//vpLK1eu1DfffKPU1FQNHDhQR48eta2wXBJOnDihv/3tb/rrr78kSW3btlXPnj1Vr149ZWZm6sCBA/rggw90+fJlvfrqq3Jzc8vzjJHCHltTUlLUuXNnHTlyRJJUs2ZNDR06VE2bNlVSUpK++OILrVmzRn379lWLFi0c9sGM8TJp0iR9/PHHCg8P16BBg3TTTTcpISFBn3zyibZs2SKr1aoxY8aoTZs22Y7ZkjmfZZRSJZzEAvj/VMD/omZkZBh+fn622J9//jnXth3NXsyaNctWPmPGjFy3Y7Vaja+//tpp312ZHbGfbZNkhISEGIcPH3Yak5+ZSElGQECA8e233+aod+zYsWwzeOvWrctRx4yZyCz2M5KDBw922tb178PRTGRmZma2/0g/++yzRmZmZo5606dPt9WpU6eOw1lX+/+WSzI6d+5sJCYm5qg3d+5cW53u3bvn+R5yExcXZ1SrVs3W1pw5c3LUSU9PN0aMGGGr06pVK4dt5Xe/FkReM5EZGRnGli1bDKvVmmsbv/zyixESEmJIMurXr+/wd5WWlmbUr1/ftq0333wzR5309HRj2LBh2X5fJTUTmdfxJj4+3qhTp44hyahYsaKxa9cuh+0cP37cqFu3riHJ8PPzM2JjY7OVF/a4lJGRYTRv3tzWxoABA4ykpCSHbaSlpRkbN27M8fr1n5G2bdsacXFxufbFMPI3EynJaNq0qXH+/Pkc9T799FOjQoUKhiTD19fXiI6OzlEnP8eq67ftaCYyMjLSNgPp7u5urF69Oked5ORko0ePHrZ2Hn74YYfbsp+JlGS8/PLLOT4rmZmZ2WYonf2eXVHQMZ3Vl6wZay8vL2PNmjUO6507d842U+nm5mYcOnQoRx0zj62TJk2y1bnrrruMK1eu5KizdevWHGdFOPo7md/xcv2ZH4MGDTLS09Nz1HvmmWdsdUaPHp2j3IzvGCiduCYSKOPc3d1Vu3Zt28+xsbH5iv/jjz9sz53NdFgsFrVr1y7/HczDe++9pyZNmpja5qxZs/S3v/0tx+sNGzbUkiVLbD/Pnj3b1O0WtU2bNunw4cOSpL/97W+aN2+e3NxyHsZfeeUV9ejRQ9K1a5s+/PBDp+1WrlxZq1evlp+fX46yZ5991raK6ZdffqmMjIwC9f2DDz7QhQsXJEn9+vXT888/n6NOhQoVNH/+fN1yyy2SpP379+uLL74o0PaKmru7u7p16+Z0ZdhbbrnFNit+8uRJffPNNznqfPbZZzp58qQkqVu3bnrppZdy1KlQoYLeffddNWzY0KTeF1xex5tFixYpJiZGkrR8+XLde++9Dtu56aabtHTpUklSUlKSFi5cmK28sMel1atX265da9u2rZYvX57rTIuHh4d69eqV6zYkyc/PT6tXr1ZgYKDTevlRoUIFrV692uHMee/evfXCCy9Iunb98/z5803bbm7+85//2M5weOGFF9SvX78cdXx8fPTRRx+pRo0akqT169fr+PHjTtvt2LGjXnvttRyfFTc3N82aNcv287Zt2wr7Fgpsw4YN+vHHHyVd+/vRt29fh/WqV6+u1atXy93dXVarVf/+97+dtluYY2tqaqrt9+7t7a3Vq1c7vEdr165dHR43zNSoUSMtWrRIFSrkPIHxtddek4+PjyTHv8OS/o6BokMSCdwAgoODbc8vXryYr1j7L1ZZCUpxqVevXp5f3vIrODg42wIC1+vWrZstaf3uu+907tw5U7dflD755BPb8wkTJjhNYOy/VNjHOTJo0KBsY8iem5ubLRFITU3N10Ix9uz78I9//CPXeu7u7powYYLDuLLo7rvvtj13tPjEZ599Znv+7LPP5tqOp6enRo8ebW7nCsjZ8WbFihWSpPDw8Dw/2x07dlTNmjUlSREREdnKCntcWrlype35a6+95vCfLfnRp08fW1/N0rVrV6e3SRk3bpzc3d0lyek9Tc2S9VmrUKGCLYF1JDAwUGPGjJEkGYaRZ9+cjeubbrpJderUkST99ttv+e2yabLGbWBgYJ6njYeHh+vOO++UlHPcXq8wx9Y9e/bYPl8PPvig6tWrl+t2nnrqKYcJnllGjx4tT09Ph2UBAQFq1aqVJCkyMjLHwmgl+R0DRYtrIoEbgP1S+/m9Z17nzp01b948SdJDDz2kiRMnqm/fvtlmG4pK27ZtC3SPP2fatWuX6x+7LB07drR9Ydm3b5/piWxR+eGHHyRd+x137tzZad27775b/v7+SkxMzHPlPEeztvZq1aple3758mUXe/t/DMPQvn37JElVqlRRy5Ytndbv0qWL7bkrq/6VpKioKC1btky7du3S77//ritXruS6uuyff/6Z47X9+/dLuvaF8p577nG6reJekTU3uR1v4uLidPDgQUnXZmzs77WZG39/f0myXfOVpbDHpT179kiSKlasmOd+dUVRzJDcd999TstDQkLUuHFjHTp0SMeOHVNcXJzDmSgzXLhwQdHR0ZKu3Xs1r+uKu3TpoldeeUVS3p9RV44vMTExBTq2mCVrVdAaNWq4tGJqVnIfHR2tlJQU20zc9QpzbM06NkjXrv12pmrVqmrSpInt82c2V9+HYRi6cuVKtjUNSvI7BooWSSRwA7hy5YrteaVKlfIV2717dz322GP66KOPFBsbq+eff17PP/+8GjZsqLvvvlv33HOPevbsWSSLldj/ATXLTTfdlK86Z86cMb0PReXs2bOSrn25DAgIcFrXzc1NDRo00C+//KJLly4pLS0t1+Q6r8Us7BcOyS1BciY+Pl7JycmS5NIpmdWqVVNQUJDi4uJs77k0euutt/TSSy9lu2+lM/Hx8Tleyxp/ISEheS6EUr9+/fx3sgjkdryJiYmxJZi7d+/O13L913+BLsxxKSEhwbavb775ZlP+UVWSx6pDhw7JMAydO3euyJJI+89ZeHh4nvXt6+T1GXX1+OLq58hsiYmJthm/o0eP5roAVm4uX76caxJZmGOr/d8mVz779evXL7IksjDvoyS/Y6BocTorUMZlZmZmm+HIa6U8Rz788EMtXrw426lVx48f17JlyzRs2DDVrFlTjz32mOlf6HP7w1sYrqxIaH99StaKcWVBQkKCJDm8vsaRrFke+1hHCnuqX17st53fvjvrd0lauXKlnnvuOdsX33bt2mnSpElavHixVq9erU8//VSffvqp3nvvPVuMo3vrJSUlScr/uC0pzo43hVlZMT09PcdrBT0u2Sfr9p+BwrjRj1X5/Yy6emyRiv74UliFXRE0LS0t17LCvPesY4NU8seHwv4OS+o7BooWM5FAGffrr7/aZnn8/PycXmOTG4vFomHDhmnYsGE6efKk9uzZo2+++UZffvmljh8/rszMTH388cfas2eP9u3bp+rVq5v9NkyTtS+csf/jXJgvmfan9RWHgIAAXblyJVv/nbH/0pnXzGVRst92fvtekv12JutUvgoVKmjjxo3q3r27w3p5XQPk5+eXbabWGVf3XVFydryx/ywNGjRIy5YtK9S2Cnpcsl/8pjT/k6g4j1V5ye9ntLQcW8xgv1/vueceffXVVyXYm/9jnxSWleNDbm6k7xj4P6X730MA8vTRRx/Znt99992Fvri+fv36GjRokBYsWKBjx47pwIEDtvtPxcTEZFtNrzSyXwnOlTrXL5Zhf1qOs/8wS7LdT6y4ZK2IeO7cuTy/HBuGYVuooXLlynleJ1qUAgMDbf9Jd+X3Exsba5sdMHsxEzOcPHlSkZGRkq6toplbAinJdp1ZbrLe37lz5/L8opi1imtJcna8sT/l09H1n4WRn+NSQECA7bTPo0eP5nkPyJKSn2OVxWIp8L1zXZF1bJGU52qr19cpjZ/R/AgKCrIlkmaP28Kw36+ufPZLw/HBFWX9Owb+D0kkUIadPXtWixYtsv08bNgw07fRsmVL28p10v8tWGEv65qj0vBlbc+ePQ5PjbO3c+dO2/M77rgjW1nFihVtz/O6XjKvBSXsTwEyY99krQhoGEaet7745ptvbIlmVlxJsVgstv0cGxurn3/+2Wl9+xUPS7rvjpw/f972vEGDBk7r5nXbgqxVDa1Wq77++mundXft2uVaB4tIXsebKlWqZFv52NE1oGbJ67jUtm1bSdeu38xrv5aUL7/80mn5uXPnbAsOhYeH57ge0szjS7Vq1Wyrf/7888953iqqtH9G8ytr8aWTJ0+6lNwXh6xjg5T9b5YjsbGxea5ua/bfI7O48h0DpRNJJFBGJSQkqF+/frZFLho3bpzrva0KKzQ01Pbc0X0Cs/6LWxpOp7l06ZI++OCDXMsjIiJspxi2bt06x3/37e9Z6exLXmRkpP73v/857Yv9aVJm7Js+ffrYns+ePdvpF4EZM2Y4jCsp9n1w9p/mzMzMbPfvLA19v5799UnObnkSExNjuxdibh588EHbc2f3nEtLSyuWewXmxtXjzeDBgyVdO/3uX//6V5H2ydlxaeDAgbbnkyZNKvZTz12xdevWHKvS2vvPf/5ju472oYceylFeVMeXjIwMvfXWW7nWS0hI0Lvvvivp2j+I8rsQTWmUNW4lafLkySXYk//Ttm1bVa5cWdK1WwE5O6vhnXfeyfMevmaPFzPl9R0DpRNJJFDGGIahLVu2qFWrVrb/2AUGBmrt2rUFuvh9+vTp2r59u9MvWVlfGKRry79fLywsTJL0+++/225WXZLGjx9vu6WEvRMnTmjo0KG2nx3dC61evXpq3LixpGsrTDpKFGNjY/Xwww/nOeNZqVIl2+zBzz//XOj//vbo0cN2DdrevXs1YcIEh7+3N954w9bvOnXqaMCAAYXarhmeeOIJ2+p7H330kf7zn//kqJOZmamnn37aNlN5xx135HkbhJLQuHFj2/VKn332me3WK/bOnz+v3r1757noyIMPPmj7/GzdujVb8p8lMzNTY8aMcek0Q7Pl93jz1FNP2Wa0/vWvf2nWrFlOjy1xcXH6z3/+k2NmvbDHpb59++qWW26RdG1mY9CgQbmeLpyRkaHPP/881+0UlYyMDD3yyCMOZ/3+97//2f6Z4uvr6/AeoVnjRpJ+/PHHQvdn7NixtgWEZs6cqfXr1+eoc/XqVQ0cONB2lkafPn1cWnG5tHv44YdtZ0t8/PHHGjdunNPLGVJSUvTBBx9o1apVRdYnLy8v2+/96tWreuSRRxwuArRt2zaX/mFj9nhxlRnfMVA6sbAOUArZ31/NMAwlJCTo0qVL+vnnn/X111/brseSpNq1a+vjjz8u0II60rXZtilTpigkJERdu3bVbbfdppCQEFmtVp05c0YbN260LdXv5eWl559/Pkcb9913nw4ePKikpCT16tVLgwcPVpUqVWynud555535vvVIQd1///3avn272rRpo8GDB6tdu3Zyd3fXvn37tGTJEtspnn369Ml1lmv8+PG2U/X69OmjoUOH6p577pFhGPrpp5+0dOlSXblyRX379tXatWud9qdjx4769NNPdeLECT3yyCN66KGHsp0ye++997q88qObm5s+/PBD3X333UpJSdGcOXO0c+dODRgwQLVr19b58+e1Zs0a25d9Dw8PLV++XN7e3i61X5QCAgK0dOlSPfDAA8rMzNSzzz6rTz/9VA8//LCqVq2qU6dOacWKFbYl6gMCArR8+fIS7rVjnp6eGjVqlObOnav09HTdc889Gjp0qO644w55eHjoxx9/tI2RQYMGOX0fHh4eWrRokbp27arMzEy99NJL2rJli/r27Ztjv9iPNzNXvDTzeOPn56cNGzbo3nvvVXx8vF588UW999576tOnj5o0aSJ/f3/Fx8fr5MmT+uGHH7Rr1y6lpaVlO51NKvxxyd3dXWvXrlXr1q116dIlrVy5Ul9++aX69++vW2+9Vb6+vvrrr7/0448/6n//+5+8vb3Vo0cPk/aoa3r37q0NGzaoadOmGjFihJo3b67k5GRt27ZNa9eutf3TacaMGapTp06O+ObNm6tatWq6cOGCPvzwQ1WtWlV/+9vfbMcTHx8f283sXREaGqp58+bpySefVEZGhh5++GE9+OCDuv/++1WxYkUdP35c77//vu3au1q1amX78l+aTJo0yaV6LVu21EMPPSQ3NzetX79erVu31unTp/Xvf/9ba9asUd++fXXrrbcqKChIiYmJOnXqlPbv368dO3YoKSlJr776apG+j3/+859av369jhw5ou+//15NmjTRsGHD1KRJEyUnJ2v79u1as2aNKlasqDZt2tjOnnF0fDB7vLjKjO8YKKUMAKWCpHw9KlasaDzzzDPG5cuXXW773nvvzVHWvn17l7ZXpUoVY9u2bQ7b//PPP42qVavmGrtz505b3Z07d9penzJlikv7ZvDgwbaYyMjIHOXXt7lixQrDy8sr1/7cf//9RkpKSq7bs1qt2bZ5/cPT09NYtGiRsXTpUttrS5cuddjWTz/9ZPj4+OTalv37cXXffPPNN0aNGjWc/r4qVapkbN26Ndc2pkyZ4vD3U9i6edmwYYMRFBTktO9169Y1Dhw4kGsbkZGRtrqDBw8uVH9yY//7d/S7TUlJMTp06OD0fYwaNco4ceKES3396KOPDG9v71zbuueee4y//vrL9vMDDzxQqPdXlMcbwzCM33//3WjRooVLbXt5eRlbtmzJFm/GcckwDOPYsWNG8+bN82wnLCwsR2xBxn29evUMSUa9evUcll/f5lNPPZVrnywWS57HyPfeey/X+Ov74Or7mT9/vtOxKMlo1qyZw2NxlnvvvddWNy/5qetMfse0o8/kmTNnjPvuu8+lWHd3d2PRokU5+mH2sfXPP/80mjRpkms/goODjR07dhgDBgywvXbp0iWHbeVnvOT1d9fVumZ9llH6MBMJlHIeHh4KDAxUYGCgQkND1bJlS911113q2bOnKfcu27hxo7744gt99dVXOnDggP744w9dvHhRFotFlSpVUtOmTdW9e3cNGzYs2wyavVq1aunHH3/U7NmztWPHDkVFRSkpKanELt4fOHCgbr31Vv3nP//Rl19+qTNnzsjX11e33Xabhg0bpscee8xpvMVi0dKlS9WtWzctWrRIP/30k5KTk1WjRg117NhR48aNU/PmzZ1ee5nltttu04EDBzR37lzt3r1bMTExLi3X7kzr1q11/PhxLVy4UJ999pl+++03XblyRYGBgQoPD1fPnj01ZsyYXH9fJenBBx/UiRMn9O677+rzzz/XH3/8ofj4eAUHB6tZs2Z68MEHNWLEiCK5L5+ZvL29FRERoUWLFmnFihU6dOiQ0tLSFBISorvuukvDhg1Tly5dFBUV5VJ7jz76qO68807Nnj1b27Zt05kzZxQQEKBGjRrp8ccf17Bhw7KtBlxUM/tmHW9uvvlmHThwQP/73//0ySef6Ntvv9W5c+eUlJSkgIAA1atXT7feeqs6duyoBx54QMHBwdnizTguSVLDhg31888/a+3atVq3bp1++OEHxcbGKjMzU1WqVFHTpk3VqVOnbNdQFqe3335b999/vxYsWKADBw7or7/+UpUqVdSuXTs9++yzat26tdP4kSNHql69elqwYIH279+v2NhY271LC+rJJ59Ujx499M4772jbtm2KiopScnKyKleurBYtWqhv3756/PHH5e7uXqjtlEY1atSwjbusW06cPn1aCQkJ8vPzU+3atdW8eXO1b99eDz74YLZVbYtK1t/Xd999V6tWrdLvv/+ujIwM1alTRz179tQzzzyjunXr2q41d3d3z3abG3tFMV7yYtZnGaWPxSipb3kAAMBl//vf//TAAw9IkubOnavnnnuuhHuE/Jo6daqmTZsm6dqKm+3bty/ZDuGGYLVaFRISotjYWN1yyy365ZdfSrpLKAdYWAcAgDLg7bfftj3v0KFDCfYEQGmyevVq2wJNHBtQXEgiAQAoYV999VWuZVarVS+99JLt3nx33nmnbrvttmLqGYCStH//fqe35Ni7d6+eeuopSdcW1BkxYkRxdQ3lHNdEAgBQwu677z6FhYWpW7duat68uSpVqqSrV6/qyJEjWrt2re32Hp6enlqwYEEJ9xZAcVmwYIHWrFmjrl276q677lLt2rXl5uam06dP64svvtCWLVts6w88//zzBV6pHcgvkkgAAEqBP/74I9spq9erVKmS1qxZoxYtWhRjrwCUtISEBK1bt07r1q1zWG6xWPTss886vM8sUFRIIgEAKGFbtmzRxo0btW/fPp07d04XL15UWlqaKlWqpCZNmqhbt24aNWpUrqsuArgxvfzyy2rQoIG++uorRUZG6uLFi4qLi5O/v7/q1Kmje+65RyNGjNCtt95a0l1FOcPqrAAAAAAAlzETWc5ZrVbb/cgsFktJdwcAAABACTEMQwkJCapZs6bc3JyswWqUEUlJScbmzZuNV1991fj73/9u1K1b15BkSDKmTJniNPbPP/803nnnHePhhx82GjRoYHh7exve3t5GaGio0b9/f2PHjh0u9eHcuXPG888/b4SHhxve3t5GcHCw0bZtW2PRokWG1WrNM/6PP/4wRo4caYSGhhpeXl5GlSpVjC5duhjr1q1zafsHDhwwBgwYYNSqVcvw9PQ0QkJCjN69e7vcf0diYmJs+5EHDx48ePDgwYMHDx48YmJinOYQZeZ01l27duV675spU6Zo6tSpDstiYmJUr1492b9NX19fGYahlJQU22tDhw7VwoUL5e7u7rCdAwcOqGvXrrp48aIkyd/fX1evXlVGRoYkqWvXrtq4caM8PT0dxm/evFl9+/ZVcnKyJCkwMFCJiYmyWq2SpCFDhmjJkiW5zgYuXrxYo0ePtm0vKChI8fHxtvflbB84ExcXp4oVKyomJqZQ19qkp6crIiJCXbp0kYeHR4HbAYoS4xRlAeMUpR1jFGUB47Rg4uPjVadOHV25ckVBQUG51itTp7MGBwerZcuWtsdzzz2nc+fOOY3JzMyUYRi67777NGjQIHXq1Ek1a9aU1WrV77//rn/+85/67LPP9P7776tmzZp69dVXc7QRFxennj176uLFi2rUqJFWrFihVq1aKS0tTYsWLdJzzz2nbdu2ady4cXr33XdzxEdGRqpfv35KTk5WmzZt9P777ys8PFyJiYmaNWuWpk+frqVLl6pRo0Z68cUXc8R/++23evLJJ5WZmanevXvrv//9r2rXrq2LFy/q5Zdf1nvvvadp06apSZMm6tevX772aVbSGhgYWOgk0tfXV4GBgXxQUWoxTlEWME5R2jFGURYwTgsnz8vcCnweZDHLyMjI8Vq9evUMyfnprFeuXDEOHDiQa7nVajW6detmSDL8/f2NlJSUHHUmTZpkSDJ8fHyMkydP5ih/4403DEmGu7u7cfTo0RzlAwcONCQZISEhxuXLl3OUjxw50pBkBAYGGpcuXcpR3rZtW0OS0bx5cyMtLS1HedeuXQ1JRmhoqMP95ExcXJwhyYiLi8tX3PXS0tKMDRs2OOwfUFowTlEWME5R2jFGURYwTgvG1dzAydWSpUtup5nmJSgoSC1btsy13GKxaOjQoZKkxMREHTlyJEed5cuXS5L69++vsLCwHOVjx46Vv7+/MjMztXLlymxlSUlJWr9+vSRp9OjRqlixYo74iRMnSro2fbxhw4ZsZSdPntSePXskSePHj3f4n5Ss+KioKH399de5vlcAAAAAKKwyk0QWJW9vb9vzzMzMbGVHjx7VqVOnJEndu3d3GO/v76927dpJkiIiIrKV7dmzx3btZW7xoaGhaty4scP47du3255369bNYXzbtm0VEBDgMB4AAAAAzFSmroksKrt27ZIkeXp6Kjw8PFvZoUOHbM+bNWuWaxvNmjXTli1b9NtvvxU4/siRIzp8+LDD+GrVqqlatWoOY93d3dWoUSPt27cvR/z1UlNTlZqaavs5Pj5e0rXzxtPT053GOpMVW5g2gKLGOEVZwDhFaccYRVnAOC0YV/dXuU8iIyMjtWDBAknSI488kmNxmTNnztie16pVK9d2ssri4+OVmJgof3//bPHBwcHy8fHJM95+e/Y/O9t2Vvm+fftyxF/vzTff1LRp03K8HhERIV9fX6exrrCfOQVKK8YpygLGKUo7xijKAsZp/mTdSSIv5TqJTElJsd12o0qVKvrXv/6Vo05CQoLtubMky74sISHBlkRmxeeVoGWV22/PjPjrTZw4Uc8//7zt56xlfLt06VLo1Vm3b9+uzp07swIWSi3GKcoCxilKO8YoygLGacFknaWYl3KbRGZkZOixxx7TgQMH5OHhoZUrV6pmzZol3a0i5+XlJS8vrxyve3h4mPIBM6sdoCgxTlEWME5R2jFGURYwTvPH1X1VLhfWyczM1IABA7RhwwZVqFBBH330kbp06eKwbtaCNZLz6V37MvuYrOd5TQ1nldvHmhEPAAAAAGYqd0lkZmamBg4cqDVr1sjd3V0ffvihHn744Vzr289Onj59Otd6WWWBgYG2U1nt4y9fvmxbpdVZ/PWzoVk/O9u2s3gAAAAAMFO5SiKzZiBXrVplSyAfeeQRpzH2K6rar7R6vayyJk2aFCq+adOmDuMvXLig2NhYh7GZmZn6/fffHcYDAAAAgJnKTRKZmZmpxx57TKtXr7YlkP37988zLjw8XHXr1pUkbd261WGdpKQk7d69W5JynBbbtm1b26qsucVHR0fryJEjDuM7d+5se55b/N69e20L6uR2Wi4AAAAAmKFcJJFZM5Br1qxRhQoVtHLlSpcSSEmyWCwaNGiQJGnVqlWKiorKUeedd95RYmKi3N3dNWDAgGxlfn5+6tOnjyRp/vz5iouLyxE/Y8YMSdeuZ+zdu3e2svr166tt27aSpDlz5ji8d0vWqrL16tXTPffc49L7AgAAAICCKFNJ5OXLl/XXX3/ZHlarVdK1RWXsX09MTLTFZF0DuXr1atsiOnmdwnq98ePHKyQkRMnJyerRo4cOHDggSUpLS9P8+fP1yiuvSJJGjhyp8PDwHPHTp0+Xn5+fzp49q169eun48eOSrs1gTp8+3XafykmTJik4ODhH/IwZM+Tu7q5ffvlF/fv3t13/eOnSJY0ZM0ZbtmyRJM2cOVPu7u75em8AAAAAkB9lKols0aKFqlatanvExMRIkmbNmpXt9aefftoWs3fvXq1atUrStVnFsWPHKiQkJNfH6tWrc2w3KChImzZtUuXKlfXbb7+pVatWtgV0xowZo7S0NHXp0kXz5s1z2O+wsDCtWbNGvr6+2r17t8LDw1WxYkUFBQVpypQpMgxDQ4YM0YQJExzG33333VqwYIEqVKigTz75RLVr11ZwcLCqVKmi+fPnS5KmTJmifv36FWr/AgAAAEBebvj7RGbNVkrXbjp6/vx5p/VzW0H19ttv1+HDhzVjxgxt2rRJMTEx8vPzU7NmzTR48GANHTpUbm655+T333+/Dh48qBkzZmj79u06e/asgoOD1aJFC40aNcp2ymtuhg8frpYtW2rOnDn66quvFBsbq2rVqql169YaO3asOnbs6DQeAAAAAMxQppJIR9cj5qV9+/YyDMOU7VevXl1z587V3LlzCxTfoEEDLVy4sMDbb9mypVauXFngeAAAAAAorDJ1OisAAAAAoGSRRAIAAAAAXFamTmcFAJQOsbGxio+PL5K2AwMDVbVq1SJpGwAAFB5JJAAgX2JjYzV05JNKSLlaJO0H+Hjr/YULSCQBACilSCIBAPkSHx+vhJSrav/4aFWuUdvUti+e/VO7VsxXfHw8SSQAAKUUSSQAoEAq16itkHphJd0NAABQzFhYBwAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgMpJIAAAAAIDLSCIBAAAAAC6rUNIdAACYLzY2VvHx8UXSdnR0tDIyMoqkbQAAUPqRRALADSY2NlZDRz6phJSrRdJ+SnKSzpw7r/T0tCJpHwAAlG4kkQBwg4mPj1dCylW1f3y0KteobXr7x3/ep/XvzlZmZqbpbQMAgNKPJBIAblCVa9RWSL0w09uNPRNjepsAAKDsYGEdAAAAAIDLSCIBAAAAAC4jiQQAAAAAuKzMJJHJycnasmWLXnvtNT300EOqV6+eLBaLLBaLpk6d6lIb58+f1wsvvKCbb75ZPj4+qlSpktq1a6fFixfLMIw840+cOKFRo0YpLCxM3t7eqlq1qrp27ar169e7tP0ff/xRAwcOVO3ateXl5aUaNWro73//u7788kuX4nfu3Km///3vqlGjhry8vFS7dm0NHDhQP/74o0vxAAAAAFBYZWZhnR9++EH3339/geMPHDigrl276uLFi5Ikf39/JSQkaM+ePdqzZ4/WrVunjRs3ytPT02H85s2b1bdvXyUnJ0uSAgMDdenSJUVERCgiIkJDhgzRkiVLZLFYHMYvXrxYo0ePtt1bLSgoSOfPn9eGDRu0YcMGTZkyxWkyPHXqVE2bNk2SZLFYFBgYqNOnT2vlypVavXq15s+fr+HDhxd09wAAAACAS8rMTKQkBQcH67777tOECRP08ccfKyQkxKW4uLg49ezZUxcvXlSjRo20b98+JSQkKCkpSW+//bY8PDy0bds2jRs3zmF8ZGSk+vXrp+TkZLVp00ZHjx5VXFyc4uLiNHnyZEnS0qVLNWvWLIfx3377rZ588kllZGSod+/eiomJ0ZUrVxQbG6tRo0ZJkqZNm6Y1a9Y4jF+zZo0tgRw1apRiY2N15coVxcTEqHfv3srIyNCTTz6pb7/91qX9AQAAAAAFVWaSyHbt2unSpUv64osvNHPmTPXv319eXl4uxc6ePVvnzp2Tj4+PNm/erFatWkmSPD099dRTT9kStIULF+rYsWM54idPnqykpCSFhIRo06ZNCg8Pl3RtNnPatGkaOXKkJOn111/X5cuXc8S/+OKLyszMVPPmzbVmzRrVrn3tvm2VK1fWggUL1LVrV0nSP/7xjxz3XcvMzNSLL74oSerWrZsWLFigypUrS5Jq166t1atXq1mzZtnqAQAAAEBRKTNJpLu7e4Fjly9fLknq37+/wsJy3jNt7Nix8vf3V2ZmplauXJmtLCkpyXbN4+jRo1WxYsUc8RMnTpR07QbfGzZsyFZ28uRJ7dmzR5I0fvx4eXh45BofFRWlr7/+OlvZV199pejo6Gz17Hl6emr8+PGSpD179igyMjJHHQAAAAAwS5lJIgvq6NGjOnXqlCSpe/fuDuv4+/urXbt2kqSIiIhsZXv27FFKSorT+NDQUDVu3Nhh/Pbt223Pu3Xr5jC+bdu2CggIcBofEBCgNm3aOIy379f18QAAAABgphs+iTx06JDtebNmzXKtl1X222+/FSr+8OHDDuOrVaumatWqOYx1d3dXo0aNnMY3btw419nYatWqqWrVqg7jAQAAAMBMZWZ11oI6c+aM7XmtWrVyrZdVFh8fr8TERPn7+2eLDw4Olo+PT57x9tuz/9nZtrPK9+3bV6j42NjYHPHXS01NVWpqqu3n+Ph4SVJ6errS09OdxjqTFVuYNoCiVl7GaWZmpjw9PGQxrFJmhuntu8mQt5eX3IqgfYthlaeHhzIzM2/431Nuyss4RdnFGEVZwDgtGFf31w2fRCYkJNie+/r65lrPviwhIcGWRGbFO4u1L7ffXmmIv96bb75pW0jIXkRERJ7bcIX96btAaVUexulTw4dIiTHSkRjT224RILV441Up4y/pyB5T266ja30/cuSIjhw5YmrbZU15GKco2xijKAsYp/mTdTvDvNzwSSSymzhxop5//nnbz/Hx8apTp466dOmiwMDAArebnp6u7du3q3Pnzg4XDwJKg/IyTiMjI/X0Cy/qgXGTVb1OPdPbP/zDXq14c5LGzJyvug0bmdr2+ZhobXxrut6eM9PhQmjlQXkZpyi7GKMoCxinBZN1lmJebvgkMmvBGulaZp1bomSfddvHZD3PKyvPKrePLQ3x1/Py8nJ4axQPDw9TPmBmtQMUpRt9nLq7uystPV2GxU1yN/8wb5VFV1NTZS2C9g2Lm9LS0+Xu7n5D/45ccaOPU5R9jFGUBYzT/HF1X93wC+vUrFnT9vz06dO51ssqCwwMtJ3Kah9/+fJl2yqtzuLtt2f/s7NtF2U8AAAAAJjphk8i7VdUtV9p9XpZZU2aNClUfNOmTR3GX7hwQbGxsQ5jMzMz9fvvvzuNP3LkiDIzMx3G27d9fTwAAAAAmOmGTyLDw8NVt25dSdLWrVsd1klKStLu3bslSV26dMlW1rZtW9uqrLnFR0dH2xaAuD6+c+fOtue5xe/du9e2IE5u8QkJCfrmm28cxtu3e308AAAAAJjphk8iLRaLBg0aJElatWqVoqKictR55513lJiYKHd3dw0YMCBbmZ+fn/r06SNJmj9/vuLi4nLEz5gxQ9K16xF79+6drax+/fpq27atJGnOnDkOl83917/+JUmqV6+e7rnnnmxl9957r+rVq5etnr309HTNmTNH0rWEt7wuRAEAAACgeJSpJPLy5cv666+/bA+r1Srp2qIy9q8nJiZmixs/frxCQkKUnJysHj166MCBA5KktLQ0zZ8/X6+88ookaeTIkQoPD8+x3enTp8vPz09nz55Vr169dPz4cUnXZjCnT5+uBQsWSJImTZqk4ODgHPEzZsyQu7u7fvnlF/Xv3992/eKlS5c0ZswYbdmyRZI0c+ZMubu7Z4t1d3fXzJkzJUmbN2/WmDFjdOnSJUnXroPs37+/Dh48mK0eAAAAABSVMpVEtmjRQlWrVrU9YmKu3f9s1qxZ2V5/+umns8UFBQVp06ZNqly5sn777Te1atXKtoDOmDFjlJaWpi5dumjevHkOtxsWFqY1a9bI19dXu3fvVnh4uCpWrKigoCBNmTJFhmFoyJAhmjBhgsP4u+++WwsWLFCFChX0ySefqHbt2goODlaVKlU0f/58SdKUKVPUr18/h/H9+vXTlClTJF2bDa1SpYqCg4NVu3ZtffLJJ6pQoYIWLFig1q1bF2i/AgAAAICrylQSWRi33367Dh8+rOeee04NGzZUenq6/Pz81LZtWy1atEhbtmxxeOuLLPfff78OHjyoESNGKDQ0VFevXlVwcLA6d+6sdevW6f3335fFYsk1fvjw4fr+++/12GOPqVatWkpOTla1atXUu3dv7dixQ1OnTnXa/6lTp2rHjh3q3bu3qlWrpuTkZNWqVUuPPfaYvvvuOw0fPryguwYAAAAAXFam7hPp6HrG/Khevbrmzp2ruXPnFii+QYMGWrhwYYG337JlS61cubLA8R07dlTHjh0LHA8AAAAAhVVuZiIBAAAAAIVHEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxGEgkAAAAAcBlJJAAAAADAZSSRAAAAAACXkUQCAAAAAFxWoaQ7AAClVWxsrOLj44us/cDAQFWtWrXI2gcAACgKJJEA4EBsbKyGjnxSCSlXi2wbAT7een/hAhJJAABQppBEAoAD8fHxSki5qvaPj1blGrVNb//i2T+1a8V8xcfHk0QCAIAyhSQSAJyoXKO2QuqFlXQ3AAAASo1yt7DO9u3b1a9fP9WrV0/e3t7y8fFR/fr1NWDAAH311VdOYxMSEjR16lQ1b95c/v7+CgoK0h133KE5c+YoLS0tz22fP39eL7zwgm6++Wb5+PioUqVKateunRYvXizDMPKMP3HihEaNGqWwsDB5e3uratWq6tq1q9avX+/y+wcAAACAwig3M5GGYWj06NF67733bK/5+PhIkiIjIxUZGamPPvpIzz33nObOnZsjPjo6Wu3bt1dUVJQkydfXV6mpqdq/f7/279+vlStXaseOHQoODna4/QMHDqhr1666ePGiJMnf318JCQnas2eP9uzZo3Xr1mnjxo3y9PR0GL9582b17dtXycnJkq4tyHHp0iVFREQoIiJCQ4YM0ZIlS2SxWAq8jwAAAAAgL+VmJvKDDz6wJZAPP/ywjh07puTkZCUnJ+v333/Xgw8+KEmaN2+ePv3002yxGRkZ6tWrl6KiolSjRg1t375dSUlJSk5O1qpVqxQQEKCffvpJAwcOdLjtuLg49ezZUxcvXlSjRo20b98+JSQkKCkpSW+//bY8PDy0bds2jRs3zmF8ZGSk+vXrp+TkZLVp00ZHjx5VXFyc4uLiNHnyZEnS0qVLNWvWLJP2FgAAAAA4Vm6SyOXLl0uSbrrpJn388cdq2LChrezmm2/W2rVrVb9+fUnSmjVrssUuW7ZMv/76qyRp/fr16tSpkyTJzc1NjzzyiC053bx5s3bs2JFj27Nnz9a5c+fk4+OjzZs3q1WrVpIkT09PPfXUU5o2bZokaeHChTp27FiO+MmTJyspKUkhISHatGmTwsPDJV2bzZw2bZpGjhwpSXr99dd1+fLlAu4hAAAAAMhbuUkiz549K0m69dZbVaFCzrN4PTw8dNttt0mSEhMTs5UtW7ZMktShQwe1bt06R2z//v0VFnZt4Y2sZNVe1mv29eyNHTtW/v7+yszM1MqVK7OVJSUl2a55HD16tCpWrJgjfuLEiZKurSa5YcOGHOUAAAAAYJZyk0RmzTL+8ssvysjIyFGenp6un3/+WZJsM4WSlJycrL1790qSunfv7rBti8Wibt26SZIiIiKylR09elSnTp1yGu/v76927do5jN+zZ49SUlKcxoeGhqpx48YO4wEAAADATOUmiRw9erQk6Y8//tCjjz6qP/74w1Z29OhR9evXTydPnlSDBg303HPP2cqOHDkiq9UqSWrWrFmu7WeVnTt3TpcuXbK9fujQoRx1nMX/9ttv2V7Pb/zhw4dzrQMAAAAAhVVuVmft1auX5s2bp3/84x9at26d1q1bZ1udNSUlRRUrVtTo0aP12muvKTAw0BZ35swZ2/NatWrl2r592ZkzZ1SpUqUCxcfHxysxMVH+/v7Z4oODg239dRZvvz1HUlNTlZqaavs5Pj5e0rWZ2PT0dKexzmTFFqYNoKjlZ5xmZmbK08NDFsMqZeY8e6GwLIZVnh4eyszMNP1zU9R9d5Mhby8vuRVB+0W5X8oKjqco7RijKAsYpwXj6v4qN0mkJI0bN04NGzbU0KFDdeHCBdtpopKUlpamxMRExcXF2RJA6dq9IbP4+vrm2rZ9mX1MQeOzksiseGex9uX223PkzTfftC3kYy8iIiLPbbhi+/bthW4DKGqujtOnhg+REmOkIzGm96HO/2//yJEjOnLkiOntF2XfWwRILd54Vcr4Szqyx9S2i3q/lCUcT1HaMUZRFjBO8yfrdoJ5KTdJZHJysoYMGaI1a9aoVatW+vDDD9WiRQtJ0k8//aR//vOfWrFihbZs2aIdO3bolltuKeEeF42JEyfq+eeft/0cHx+vOnXqqEuXLtlmYPMrPT1d27dvV+fOneXh4WFGVwHT5WecRkZG6ukXXtQD4yarep16pvflfEy0Nr41XW/Pmelwwa3CKOq+H/5hr1a8OUljZs5X3YaNTG27KPdLWcHxFKUdYxRlAeO0YLLOUsxLuUkiJ0yYoDVr1ujmm2/W7t275e3tbSvr3Lmz2rZtq9tuu03Hjh3TU089pd27d0uSAgICbPWcZeb2ZfYx18fnlqjlFZ/XfwWyyu1jHfHy8pKXl1eO1z08PEz5gJnVDlCUXBmn7u7uSktPl2Fxk9zNP1QaFjelpafL3d3d9M9MUffdKouupqbKWgTtF+V+KWs4nqK0Y4yiLGCc5o+r+6pcLKyTkJCghQsXSpKeeuqpbAlkFh8fHz399NOSrq2IeuHCBUlSzZo1bXVOnz6d6zbsy+xj8hsfGBhoO5XVPv7y5cvZTr/NLd5+ewAAAABgtnKRRB47dsx2W48GDRrkWq9hw4a255GRkZKkxo0by83t2m6yXyn1elllISEh2a6ptF9R1ZX4Jk2aZHs9v/FNmzbNtQ4AAAAAFFa5SCKzkkBJio6OzrXe+fPnbc+zTgv19fVVmzZtJElbt251GGcYhrZt2yZJ6tKlS7ay8PBw1a1b12l8UlKS7fTZ6+Pbtm1rW5U1t/jo6GjbAhTXxwMAAACAmcpFEtmoUSNbIrZ48WLbrKS9zMxM2ymvwcHBuvnmm21lgwcPliTt3LlT33//fY7YtWvX6uTJk5KkQYMGZSuzWCy211atWqWoqKgc8e+8844SExPl7u6uAQMGZCvz8/NTnz59JEnz589XXFxcjvgZM2ZIupb49u7dO+cOAAAAAACTlIsk0sfHR8OHD5ck/fjjj+rVq5d+/fVXWa1WWa1WHTx4UPfff7+++eYbSdduBeLu7m6LHzx4sJo3by7DMNSnTx/t2LFDkmS1WrV27VqNGDFCktS9e3fdd999ObY/fvx4hYSEKDk5WT169NCBAwckXbutyPz58/XKK69IkkaOHKnw8PAc8dOnT5efn5/Onj2rXr166fjx45KuzWBOnz5dCxYskCRNmjRJwcHBpuwzAAAAAHCk3KzOOmPGDB0/flxbt261PbJWKU1NTbXVe/TRR/Xyyy9ni61QoYI2btyoDh06KCoqSp06dZKvr6+sVquuXr0qSWrRooVWrlzpcNtBQUHatGmTunbtqt9++02tWrVSQECArl69aruhZ5cuXTRv3jyH8WFhYVqzZo369u2r3bt3Kzw8XEFBQUpMTFRmZqYkaciQIZowYULhdhIAAAAA5KFczERK12YjN2/erLVr1+rBBx9U7dq1ZRiGJKlOnTrq06ePNm3apI8++ijbLGSW0NBQHTx4UJMnT1azZs1ksVjk4eGh22+/XbNnz9Z3333ndBbw9ttv1+HDh/Xcc8+pYcOGSk9Pl5+fn9q2batFixZpy5YtDm+9keX+++/XwYMHNWLECIWGhurq1asKDg5W586dtW7dOr3//vuyWCyF31EAAAAA4ES5mYmUrl2f+PDDD+vhhx8uUHxAQICmTZumadOmFSi+evXqmjt3rubOnVug+AYNGtiu2wQAAACAklBuZiIBAAAAAIVnShI5ffp0283uAQAAAAA3LlOSyKlTpyosLEy9e/fW5s2bbdcaAgAAAABuLKYkkXXr1lVGRoY2btyoXr16KTQ0VK+++qrOnDljRvMAAAAAgFLClCQyMjJSW7Zs0d///ndVqFBBMTExmjp1qkJDQ9W7d29t2bKF2UkAAAAAuAGYkkRaLBZ17dpV69evV0xMjN544w3Vr1/fNjvZs2dPhYWFMTsJAAAAAGWc6auzVqtWTS+99JKOHz+uL774Qv369ZOHh4dOnTrF7CQAAAAAlHFFeouPjh07atWqVTp9+rTmzJmj8PBwZWRk6H//+59tdvKNN97QxYsXi7IbAAAAAACTFMt9IuPi4nThwgVdvnxZFotFhmHIMAydOnVKr7zyisLCwvTWW28VR1cAAAAAAIVQoagazsjI0CeffKKFCxdq165dtsQxJCREw4cPV9++fRUREaEFCxboxIkTeuGFF+Tt7a0nn3yyqLoEAAAAACgk02cijx8/rgkTJqhWrVp69NFH9eWXX8owDHXs2FFr165VTEyMpk+frubNm+uFF17Q0aNH9c9//lOGYei///2v2d0BAAAAAJjIlJnItLQ0rVu3TosWLdLXX38tSTIMQ5UqVdITTzyhUaNGqWHDhg5j3dzc9Oqrr+q///2vTpw4YUZ3AAAAAABFxJQksmbNmrp8+bJttdXWrVvrySefVL9+/eTl5ZVnvMViUXBwsGJiYszoDgAAAACgiJiSRF66dEn+/v4aOHCgnnzySd1yyy35bmPOnDlKTEw0ozsAAAAAgCJiShI5f/58DRgwQP7+/gVuo0+fPmZ0BQAAAABQhExJIkeNGmVGMwAAAACAUs601Vnj4+NdOh01MTFR8fHxZm0WAAAAAFCMTEkiP/nkEwUHB2vkyJF51h04cKCCg4O1ceNGMzYNAAAAAChGpiSRa9eulSQNGzYsz7ojRoyQYRhas2aNGZsGAAAAABQjU5LIn376SW5ubmrTpk2edTt27Cg3Nzf9+OOPZmwaAAAAAFCMTEkiT58+rYoVK8rb2zvPuj4+PqpYsaJOnz5txqYBAAAAAMXIlNVZLRaLkpOTXa6fkpIii8VixqYBAAAAAMXIlJnIOnXq6OrVq/r111/zrPvLL78oJSVFtWrVMmPTAAAAAIBiZEoS2b59exmGoSlTpuRZd+rUqbJYLOrQoYMZmwYAAAAAFCNTksixY8fKzc1Nn332mQYOHKjz58/nqHP+/Hk99thj+uyzz+Tm5qZnnnnGjE0DAAAAAIqRKddENmrUSK+//romTpyojz/+WOvWrdPtt9+uevXqSZKio6O1f/9+ZWRkSJJee+01NWnSxIxNAwAAAACKkSlJpCT94x//UGBgoF566SUlJCTo22+/1XfffSdJMgxDkhQYGKiZM2dq5MiRZm0WAAAAAFCMTEsiJWn06NF69NFHtW7dOn3zzTc6d+6cLBaLQkJCdPfdd6tv374KDAw0c5MAAAAAgGJkahIpSRUrVtTw4cM1fPhws5sGAAAAAJQwUxbWAQAAAACUDySRAAAAAACXmXo664kTJ7RmzRodPHhQly5dUnp6eq51LRaLduzYYebmAQAAAABFzLQkctq0aXrttddktVptq7E6Y7FYzNo0AAAAAKCYmJJErly5UtOmTZMk1axZU127dlXNmjVVoYLp6/YAAAAAAEqQKVneO++8I0l64IEHtGbNGnl6eprRLAAAAACglDFlYZ1Dhw7JYrHo3XffJYEEAAAAgBuYKUmkxWJRYGCgatasaUZzAAAAAIBSypQkslGjRkpOTlZqaqoZzQEAAAAASilTksjhw4crPT1da9euNaM5AAAAAEApZUoSOWLECD3wwAN65pln9PXXX5vRJAAAAACgFDJlddbp06fr1ltv1e7du9WhQwe1adNGd911lwICApzGTZ482YzNAwAAAACKiSlJ5NSpU2WxWCRJhmFoz5492rt3b55xJJEAAAAAULaYkkTec889tiQSAAAAAHDjMiWJ3LVrlxnNAAAAAABKOVMW1gEAAAAAlA8kkQAAAAAAl5lyOqu9gwcPatu2bYqOjlZKSoqWLFliK0tPT1dsbKwsFotq1Khh9qYBAAAAAEXMtCQyLi5OQ4cO1YYNGyRdW6XVYrHkSCJvvfVWXb58Wb/88ouaNm1q1uYBAAAAAMXAlNNZ09PT1b17d23YsEG+vr7q0aOHvL29c9Tz9fXVkCFDZLVatW7dOjM2DQAAAAAoRqYkkUuWLNF3332n+vXr6+jRo9q4caOCgoIc1u3Tp48k6euvvzZj0wAAAACAYmRKEvnxxx/LYrFo3rx5qlmzptO6LVq0kJubm37//XczNg0AAAAAKEamJJG//vqrLBaLunTpkmddT09PBQUF6eLFi2ZsGgAAAABQjExJIpOTkxUQECBPT0+X6qenp6tCBdMXhgUAAAAAFDFTksgqVaooPj5eiYmJedaNjIxUYmJinqe9AgAAAABKH1OSyLvuukuS9Pnnn+dZ97///a8kqV27dmZsGgAAAABQjExJIocOHSrDMPTKK6/ozJkzudZ777339O9//1sWi0UjR440Y9MAAAAAgGJkyoWJPXr0UJ8+fbR+/Xq1atVKjz32mFJSUiRJCxcuVHR0tDZt2qRDhw7JMAyNGDHCNnsJAOVVWlqqoqOjTW83OjpaGRkZprcLAAAgmZREStKKFSvk7e2tlStXat68ebbXR48eLUkyDEPStVnLd955x6zNFkh8fLzmz5+vzz77TMePH1d8fLyqVq2qhg0b6t5779W4ceNUsWLFHHEJCQmaM2eO1q9fr8jISLm7uys8PFz9+/fX2LFj81xY6Pz585o5c6Y2bdqkU6dOycfHR02bNtXgwYM1bNgwWSwWp/EnTpzQzJkzFRERobNnzyogIEAtW7bUyJEjbfffBFA2JFy5pMgTJ/Xyq2/Iy8vL1LZTkpN05tx5paenmdouAACAZGIS6e3trRUrVmjUqFFavHixvvnmG505c0aZmZkKCQlRmzZtNHLkSN1zzz1mbbJAdu7cqUcffVTnz5+XdO2WI76+vjp9+rROnz6tXbt2qXfv3rrtttuyxUVHR6t9+/aKioqSJPn6+io1NVX79+/X/v37tXLlSu3YsUPBwcEOt3vgwAF17drVdmsTf39/JSQkaM+ePdqzZ4/WrVunjRs35pqIbt68WX379lVycrIkKTAwUJcuXVJERIQiIiI0ZMgQLVmyJM9EFEDpcDU5SW4eHrr38dGqFdrA1LaP/7xP69+drczMTFPbBQAAkExMIrO0bdtWbdu2NbtZU+zdu1c9evRQSkqKHnroIU2cOFG33367LBaLkpOTdfjwYX322WcKCgrKFpeRkaFevXopKipKNWrU0PLly9WpUydZrVatXbtWI0aM0E8//aSBAwc6XFwoLi5OPXv21MWLF9WoUSOtWLFCrVq1UlpamhYtWqTnnntO27Zt07hx4/Tuu+/miI+MjFS/fv2UnJysNm3a6P3331d4eLgSExM1a9YsTZ8+XUuXLlWjRo304osvFtn+A2C+yiE1FVIvzNQ2Y8/EmNoeAACAPVMW1ikLkpOTNWjQIKWkpGjs2LG26zezZu58fX11xx136LXXXlNYWPYvdMuWLdOvv/4qSVq/fr06deokSXJzc9Mjjzyi9957T9K12cIdO3bk2Pbs2bN17tw5+fj4aPPmzWrVqpWka7OgTz31lKZNmybp2vWjx44dyxE/efJkJSUlKSQkRJs2bVJ4eLika7OZ06ZNsy1S9Prrr+vy5cuF3lcAAAAAkJtyk0SuWLFCJ0+eVEhIiGbOnJmv2GXLlkmSOnTooNatW+co79+/vy3xXL58eY7yrNfs69kbO3as/P39lZmZqZUrV2YrS0pK0vr16yVdu77U0bWaEydOlHTtWs8NGza4/sYAAAAAIJ9MOZ3VUeLkikGDBpmxeZdk9bFv377y9vZ2OS45OVl79+6VJHXv3t1hHYvFom7dumn+/PmKiIjIVnb06FGdOnXKaby/v7/atWunLVu2KCIiwjYzKUl79uyxrXSbW3xoaKgaN26sI0eO2K6PBAAAAICiYEoS+cQTT+R7QReLxVJsSWTWAjiSdPvtt+vUqVN67bXXtGXLFp0/f17BwcG688479eSTT6pHjx7ZYo8cOSKr1SpJatasWa7byCo7d+6cLl26pEqVKkmSDh06lKNObvFbtmzRb7/9lu31/MQfOXJEhw8fzrUOAAAAABSWKUlk3bp1nSaRcXFxunLliiTJz89PVapUMWOzLouKilJa2rWl7k+ePKmxY8cqISFBnp6e8vPz04ULF7Rp0yZt2rRJw4cP18KFC23v58yZM7Z2atWqles27MvOnDljSyLzGx8fH6/ExET5+/tniw8ODpaPj0+e8fbbcyQ1NVWpqam2n+Pj4yVJ6enpSk9PdxrrTFZsYdoACuKvv/5SQkKCS3WzViv9448/5O7u7rRuTEyM3CwWWQyrlGn+PRfdZMjby0tuRdB+UbZd1O1bDKs8PTyUmZlZbo8nHE9R2jFGURYwTgvG1f1lShKZddsLZ44fP67XXntNa9eu1YwZM9SvXz8zNu0S+8VmXnvtNVWsWFFr167Vgw8+KA8PD506dUrjx4/X2rVrtXjxYjVu3FjPP/+8JGX7curr65vrNuzL7GMKGp+VRGbFO4u1L8/ry/Sbb76Z7XTZLBEREXluwxXbt28vdBtAUXO0gJUjzz45QkqMkY6Yv9ppiwCpxRuvShl/SUf2lJm2i7r9OpKeGj5ER44c0ZEjR0xtu6zheIrSjjGKsoBxmj9ZtxPMi+m3+MhNw4YNtWzZMnl4eGjQoEEKDw/PcS/GopJ1OmrW8yVLlqh379621+rWratVq1bp2LFj+uWXX/TGG2/omWeeUYUKxbZ7is3EiRNtCbJ0bSayTp066tKliwIDAwvcbnp6urZv367OnTvLw8PDjK4CeYqMjNTTL7yotv2HqVJI7jP9WSyGVbWTTutPv1oyLM7XFTtx8EdtXPwfjZk5X3UbNjKryzaHf9irFW9OKpL2i7Ltom7/fEy0Nr41XW/PmelwIbLygOMpSjvGKMoCxmnBZJ2lmJdiz5KmTp2q999/X2+++aZWr15dLNsMCAiwPW/YsGG2BDKLm5ubxo8fr8cff1wXL17UgQMHdNddd2WLdZaZ25fZx1wfn1uilld8Xv8VyCq3j3XEy8tLXl5eOV738PAw5QNmVjuAK9zd3ZWWnq7gGnVU3ZV7LWZmSEdOq1rdMMnd+eHvwtnTupqaKqvFLc+6BWGVpcjaL8q2i7p9w+KmtPR0ubu7l/tjCcdTlHaMUZQFjNP8cXVfFfstPmrXrq2KFSvqq6++KrZt2l+L2KhR7v81b9Kkie15dHS0JKlmzZq2106fPp1rrH2ZfUx+4wMDA22nstrHX7582bZKq7N4++0BAAAAgNmKPYm8evWq4uPjFRcXV2zbrFSpktNFbbIYhmF7nrWwTuPGjeXmdm032a+Uer2sspCQENuiOlL2FVVdibdPZAsS37Rp01zrAAAAAEBhFXsSuXTpUlmtVpeSOjN16dJFkpwu1GB/e42sa3F8fX3Vpk0bSdLWrVsdxhmGoW3btmXbTpbw8HDVrVvXaXxSUpJ2797tML5t27a2VVlzi4+Ojra9r+vjAQAAAMBMpiSRp06dcvo4duyYduzYoTFjxui5556TxWLR3//+dzM27bIhQ4ZIura0/4YNG3KUW61WzZ49W9K1019btmxpKxs8eLAkaefOnfr+++9zxK5du1YnT56UpBz3vrS/H+aqVascrmT7zjvvKDExUe7u7howYEC2Mj8/P/Xp00eSNH/+fIczuDNmzJB07XpIR9d7AgAAAIBZTEkiw8LCnD4aN26sLl266L333lNaWpqaNGmiSZMmmbFpl7Vr104PP/ywJGn48OFav369MjKu3d/s1KlTevTRR3Xw4EFJ0uuvv247hVW6lkQ2b95chmGoT58+2rFjh6RriefatWs1YsQISVL37t1133335dj2+PHjFRISouTkZPXo0UMHDhyQJKWlpWn+/Pl65ZVXJEkjR45UeHh4jvjp06fLz89PZ8+eVa9evXT8+HFJ12Ywp0+frgULFkiSJk2apODg4MLvLAAAAADIhSnL6tlfS+hMgwYN9Oijj+of//iH/Pz8zNh0vnzwwQe6cOGCvv76az388MPy8vKSr69vtvtITpkyxTbzmKVChQrauHGjOnTooKioKHXq1Em+vr6yWq26evWqJKlFixZauXKlw+0GBQVp06ZN6tq1q3777Te1atVKAQEBunr1qu2Gnl26dNG8efMcxoeFhWnNmjXq27evdu/erfDwcAUFBSkxMdF28/QhQ4ZowoQJhd5HAAAAAOCMKUlkZGSk841UqKDg4GBTbmZfGH5+ftq5c6fef/99rVixQocOHVJCQoJq1aqldu3aaezYsbr77rsdxoaGhurgwYOaPXu2PvnkE0VGRsrDw0NNmzbVo48+qrFjx8rT0zPXbd9+++06fPiwZsyYoU2bNikmJkZ+fn5q1qyZBg8erKFDh2ab/bze/fffr4MHD2rGjBnavn27zp49q+DgYLVo0UKjRo2ynfIKAAAAAEXJlCSyXr16ZjRTLNzc3DR8+HANHz4837EBAQGaNm2apk2bVqBtV69eXXPnztXcuXMLFN+gQQMtXLiwQLEAAAAAYIZiX50VAAAAAFB2kUQCAAAAAFxmyums06dPN6MZSdLkyZNNawsAAAAAYC5TksipU6fKYrGY0RRJJAAAAACUYqYkkffcc48sFot+/vlnxcXFSZJq1aql2rVrS5JOnz6tP//8U5JUsWJF3XrrrWZsFgAAAABQzExJInft2qWJEyfqq6++0qOPPqqpU6eqYcOG2er88ccfmjZtmlauXKnWrVvrjTfeMGPTAAAAAIBiZEoSuX79es2cOVNjxozR22+/7bDOTTfdpBUrVigoKEgzZsxQq1at9NBDD5mxeQAAAABAMTFldda3335bFotFU6dOzbNuVp3ckk0AAAAAQOllShJ58OBBBQUFqUqVKnnWrVKliipWrKhffvnFjE0DAAAAAIqRKUlkamqq4uPjlZiYmGfdxMRExcfHKzU11YxNAwAAAACKkSlJ5M033yyr1erSKapvv/22MjMzdfPNN5uxaQAAAABAMTIliXziiSdkGIYmTZqkadOmOZyRTE5O1vTp0zVp0iRZLBYNGTLEjE0DAAAAAIqRKauzPvXUU/r8888VERGh6dOna9asWWrVqpVq1aol6dp9Ivfv36+UlBQZhqHOnTtrzJgxZmwaAAAAAFCMTEki3dzctHHjRr300kt6++23lZycrK+//loWi0WSZBiGJMnd3V1PPfWUZsyYITc3UyZBAQAAAADFyJQkUpI8PT01d+5cTZgwQevWrdP+/ft14cIFSVK1atXUqlUr9enTRzVr1jRrkwAAAACAYmZaEpmlRo0aGjt2rNnNAgAAAABKAc4pBQAAAAC4zPSZyL/++ks7d+5UdHS0kpOTNXnyZLM3AQAAAAAoIaYlkRkZGfrHP/6hd999V2lpabbX7ZPIy5cvq379+kpJSdHvv/+u0NBQszYPAAAAACgGpp3O2rdvX7311ltKS0tT06ZNVaFCzvw0ODhYjz32mNLS0rRmzRqzNg0AAAAAKCamJJGrVq3SZ599pmrVqmn//v06ePCgKlWq5LBu3759JUk7d+40Y9MAAAAAgGJkShK5dOlSWSwWzZo1Sy1atHBa984775TFYtFvv/1mxqYBAAAAAMXIlCTyp59+kiT16dMnz7q+vr4KCgqy3UMSAAAAAFB2mJJExsXFKSgoSD4+Pi7Vt1qtslgsZmwaAAAAAFCMTEkig4ODFRcXp6tXr+ZZ9+zZs4qPj1f16tXN2DQAAAAAoBiZkkS2bNlSkmuL5bz//vuSpNatW5uxaQAAAABAMTIliRwwYIAMw9Arr7yixMTEXOtt3bpVr776qiwWiwYPHmzGpgEAAAAAxSjnzRwL4LHHHtPChQu1e/du/e1vf9OTTz6ptLQ0SdL27dsVFRWl//3vf9q8ebOsVqt69eqlrl27mrFpAAAAAEAxMiWJtFgs2rBhg/7+97/r66+/1rPPPmsr69atm+25YRjq1KmTVq5cacZmAQAAAADFzJTTWaVri+t8+eWXWrZsmdq1aydPT08ZhiHDMOTu7q7WrVvrgw8+0NatW+Xv72/WZgEAAAAAxciUmcgsbm5uevzxx/X444/LarXq0qVLyszMVOXKlVWhgqmbAgAAAACUAFNmIsPCwtSgQQP98ccf/9ewm5uqVKmi6tWrk0ACAAAAwA3ClOzu7Nmz8vT01E033WRGcwAAAACAUsqUmciaNWvKMAwzmgIAAAAAlGKmJJGdOnVScnKyfvrpJzOaAwAAAACUUqYkkS+99JL8/Pz09NNPKzk52YwmAQAAAAClkCnXRFaoUEHvvfeeRo0apWbNmmns2LG6++67Va1aNbm7u+caV7duXTM2DwAAAAAoJqYkkWFhYbbnSUlJGj9+fJ4xFotFGRkZZmweAAAAAFBMTEkiC7KoDgvxAAAAAEDZY0oSGRkZaUYzAAAAAIBSrkBJpJubm2rUqKHTp09LkurVq2crO3LkiNLT03XLLbeY00MAAAAAQKlR4JnI3E5H7dixo2JjY7neEQAAAABuQKbc4uN6XO8IAAAAADemIkkiAQAAAAA3JpJIAAAAAIDLSCIBAAAAAC4jiQQAAAAAuIwkEgAAAADgsgLf4uP8+fNyd3fPtdxZmSRZLBZuAwIAAAAAZYzp94kEAAAAANy4CpRETpkyxex+AAAAAADKAJJIAAAAAIDLWFgHAAAAAOAykkgAAAAAgMtIIgEAAAAALiOJBAAAAAC4rNwnkf/6179ksVhsD2cSEhI0depUNW/eXP7+/goKCtIdd9yhOXPmKC0tLc9tnT9/Xi+88IJuvvlm+fj4qFKlSmrXrp0WL17s0i1TTpw4oVGjRiksLEze3t6qWrWqunbtqvXr17v8fgEAAACgMAp8n8gbwdGjRzVt2jSX6kZHR6t9+/aKioqSJPn6+io1NVX79+/X/v37tXLlSu3YsUPBwcEO4w8cOKCuXbvq4sWLkiR/f38lJCRoz5492rNnj9atW6eNGzfK09PTYfzmzZvVt29fJScnS5ICAwN16dIlRUREKCIiQkOGDNGSJUvyTIQBAAAAoDDK7Uyk1WrV0KFDdfXqVbVu3dpp3YyMDPXq1UtRUVGqUaOGtm/frqSkJCUnJ2vVqlUKCAjQTz/9pIEDBzqMj4uLU8+ePXXx4kU1atRI+/btU0JCgpKSkvT222/Lw8ND27Zt07hx4xzGR0ZGql+/fkpOTlabNm109OhRxcXFKS4uTpMnT5YkLV26VLNmzSrUPgEAAACAvJTbJPK///2vvvnmGw0YMEBdunRxWnfZsmX69ddfJUnr169Xp06dJElubm565JFH9N5770m6Nlu4Y8eOHPGzZ8/WuXPn5OPjo82bN6tVq1aSJE9PTz311FO22dCFCxfq2LFjOeInT56spKQkhYSEaNOmTQoPD5d0bTZz2rRpGjlypCTp9ddf1+XLlwuyOwAAAADAJeXydNbIyEi9/PLLqly5subNm6d33nnHaf1ly5ZJkjp06OBw1rJ///56+eWXFRkZqeXLl+u+++7LVr58+XJbvbCwsBzxY8eO1RtvvKHExEStXLky2ym2SUlJtmseR48erYoVK+aInzhxohYuXKj4+Hht2LBBQ4YMcb4DgGIUGxur+Pj4Imk7OjpaGRkZRdI2AAAAHCuXSeSIESOUlJSkd999V1WrVnVaNzk5WXv37pUkde/e3WEdi8Wibt26af78+YqIiMhWdvToUZ06dcppvL+/v9q1a6ctW7YoIiIiWxK5Z88epaSkOI0PDQ1V48aNdeTIEdv1kUBpEBsbq6Ejn1RCytUiaT8lOUlnzp1XenreC1sBAADAHOUuiVy0aJF27NihTp06adCgQXnWP3LkiKxWqySpWbNmudbLKjt37pwuXbqkSpUqSZIOHTqUo05u8Vu2bNFvv/2W7fX8xB85ckSHDx928m6A4hUfH6+ElKtq//hoVa5R2/T2j/+8T+vfna3MzEzT2wYAAIBj5SqJPH36tCZMmCAfHx/bdYx5OXPmjO15rVq1cq1nX3bmzBlbEpnf+Pj4eCUmJsrf3z9bfHBwsHx8fPKMt9+eI6mpqUpNTbX9nHWaYXp6utLT053GOpMVW5g2cOPJzMyUp4eHqoTUVPXadUxv/+KZU/L28pKbYZUyXTitNauOC3XdZOSv7XwqyvbLct8thlWeHh7KzMwst8cTjqco7RijKAsYpwXj6v4qV0nkqFGjFBcXpxkzZqh+/fouxSQkJNie+/r65lrPvsw+pqDxWUlkVryzWPty++058uabbzq8rUlERESe23DF9u3bC90GbixPDR8iJcZIR2JMb7tFgNTijVeljL+kI3tcjvM89l2Rte2qomy/LPe9jq6NmSNHjujIkSOmtl3WcDxFaccYRVnAOM2frNsJ5qXcJJEffvihPv/8c9122216/vnnS7o7JWbixInZ3n98fLzq1KmjLl26KDAwsMDtpqena/v27ercubM8PDzM6CpuAJGRkXr6hRf1wLjJql6nnuntH/5hr1a8OUljZs5X3YaN8g7IzJDnse+UFv43yd354S/fbedTUbZflvt+PiZaG9+arrfnzHS4EFl5wPEUpR1jFGUB47RgXF0MsVwkkefPn9e4cePk7u6uRYsWqUIF1992QECA7bmzzNy+zD7m+vjcErW84vP6r0BWuX2sI15eXvLy8srxuoeHhykfMLPawY3B3d1daenpMixueSZtBWGVRVdTU2XNb/vuFfKsX+C2XVSU7ZflvhsWN6Wlp8vd3b3cH0s4nqK0Y4yiLGCc5o+r+6pc3CfypZde0sWLFzVy5Eg1atRIiYmJ2R5paf+3suP1r9WsWdNWdvr06Vy3YV9mH5Pf+MDAQNuprPbxly9ftq3S6izefnsAAAAAYLZykURGRkZKkubPn6+AgIAcjzfffNNWN+u1F198UZLUuHFjubld2032K6VeL6ssJCTEtqiOlH1FVVfimzRpku31/MY3bdo01zoAAAAAUFjlIoksDF9fX7Vp00aStHXrVod1DMPQtm3bJEldunTJVhYeHq66des6jU9KStLu3bsdxrdt29a2Kmtu8dHR0bYFKK6PBwAAAAAzlYskcteuXTIMI9fHlClTbHWzXnvrrbdsrw0ePFiStHPnTn3//fc52l+7dq1OnjwpSTnuPWmxWGyvrVq1SlFRUTni33nnHSUmJsrd3V0DBgzIVubn56c+ffpIujaTGhcXlyN+xowZkq7Novbu3TuPvQEAAAAABVcuksjCGjx4sJo3by7DMNSnTx/t2LFDkmS1WrV27VqNGDFCktS9e3fdd999OeLHjx+vkJAQJScnq0ePHjpw4IAkKS0tTfPnz9crr7wiSRo5cqTCw8NzxE+fPl1+fn46e/asevXqpePHj0u6NoM5ffp0LViwQJI0adIkBQcHm78DAAAAAOD/KxersxZWhQoVtHHjRnXo0EFRUVHq1KmTfH19ZbVadfXqVUlSixYttHLlSofxQUFB2rRpk7p27arffvtNrVq1UkBAgK5evWq7oWeXLl00b948h/FhYWFas2aN+vbtq927dys8PFxBQUFKTExUZmamJGnIkCGaMGFCEbx7AAAAAPg/zES6KDQ0VAcPHtTkyZPVrFkzWSwWeXh46Pbbb9fs2bP13XffOZ0FvP3223X48GE999xzatiwodLT0+Xn56e2bdtq0aJF2rJli8Nbb2S5//77dfDgQY0YMUKhoaG6evWqgoOD1blzZ61bt07vv/++LBZLUbx1AAAAALBhJlLS1KlTNXXq1DzrBQQEaNq0aZo2bVqBtlO9enXNnTtXc+fOLVB8gwYNtHDhwgLFAgAAAIAZmIkEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALisQkl3AAAAe2lpqYqOji6y9gMDA1W1atUiax8AgBsdSSQAoNRIuHJJkSdO6uVX35CXl1eRbCPAx1vvL1xAIgkAQAGRRAIASo2ryUly8/DQvY+PVq3QBqa3f/Hsn9q1Yr7i4+NJIgEAKCCSSABAqVM5pKZC6oWVdDcAAIADLKwDAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcRhIJAAAAAHAZSSQAAAAAwGUkkQAAAAAAl5FEAgAAAABcVm6SyIsXL2rp0qUaOHCgmjRpIj8/P3l5eal27drq3bu3Pv300zzbSEhI0NSpU9W8eXP5+/srKChId9xxh+bMmaO0tLQ848+fP68XXnhBN998s3x8fFSpUiW1a9dOixcvlmEYecafOHFCo0aNUlhYmLy9vVW1alV17dpV69evd2kfAAAAAEBhVSjpDhSXkJAQZWRk2H729vaWh4eHTp8+rdOnT+uzzz5T9+7dtW7dOvn6+uaIj46OVvv27RUVFSVJ8vX1VWpqqvbv36/9+/dr5cqV2rFjh4KDgx1u/8CBA+ratasuXrwoSfL391dCQoL27NmjPXv2aN26ddq4caM8PT0dxm/evFl9+/ZVcnKyJCkwMFCXLl1SRESEIiIiNGTIEC1ZskQWi6UwuwkAAAAAnCo3M5EZGRm688479e677+rEiRNKSUlRYmKiIiMjNWzYMEnSli1bNGrUKIexvXr1UlRUlGrUqKHt27crKSlJycnJWrVqlQICAvTTTz9p4MCBDrcdFxennj176uLFi2rUqJH27dunhIQEJSUl6e2335aHh4e2bdumcePGOYyPjIxUv379lJycrDZt2ujo0aOKi4tTXFycJk+eLElaunSpZs2aZc7OAgAAAIBclJsk8ssvv9T333+v0aNHq379+rbXQ0NDtXjxYlvy+OGHHyomJiZb7LJly/Trr79KktavX69OnTpJktzc3PTII4/ovffek3RttnDHjh05tj179mydO3dOPj4+2rx5s1q1aiVJ8vT01FNPPaVp06ZJkhYuXKhjx47liJ88ebKSkpIUEhKiTZs2KTw8XNK12cxp06Zp5MiRkqTXX39dly9fLvhOAgAAAIA8lJskskOHDk7Ls2YjJWn//v3ZypYtW2Zro3Xr1jli+/fvr7CwMEnS8uXLc5RnvWZfz97YsWPl7++vzMxMrVy5MltZUlKS7ZrH0aNHq2LFijniJ06cKEmKj4/Xhg0bcnuLAAAAAFBo5SaJzIu3t7fteWZmpu15cnKy9u7dK0nq3r27w1iLxaJu3bpJkiIiIrKVHT16VKdOnXIa7+/vr3bt2jmM37Nnj1JSUpzGh4aGqnHjxg7jAQAAAMBMJJH/365du2zPmzdvbnt+5MgRWa1WSVKzZs1yjc8qO3funC5dumR7/dChQznqOIv/7bffsr2e3/jDhw/nWgcAAAAACqvcrM7qzJUrV/Tmm29Kktq1a6ebb77ZVnbmzBnb81q1auXahn3ZmTNnVKlSpQLFx8fHKzExUf7+/tnig4OD5ePjk2e8/fYcSU1NVWpqqu3n+Ph4SVJ6errS09OdxjqTFVuYNnDjyczMlKeHhyyGVcrMyDsgn9xkyNvLS26utp9Vx4W6+W47n4qyffqeO4thlaeHhzIzM0vt8YrjKUo7xijKAsZpwbi6vyyGKzcovIFZrVY9+OCD2rRpk7y9vfX999/rlltusZV/9NFHGjBggCTp+PHjuummmxy2s337dnXp0kWS9M0339iunXzjjTf08ssvS7r2S6lQwXHevmjRItsCOWfOnFGNGjUkSSNHjtSiRYtUq1Yt/fnnn7m+j5dffllvvPGGPD09syWJ15s6daptIR97H330kcNbmwAAAAAoH5KTk/XYY48pLi5OgYGBudYr9zORzz77rDZt2iRJeuedd7IlkDeiiRMn6vnnn7f9HB8frzp16qhLly5OB0pe0tPTtX37dnXu3FkeHh5mdBV2/vrrLyUkJBRZ+wEBAapSpYrp7UZGRurpF17UA+Mmq3qdeqa3f/iHvVrx5iSNmTlfdRs2yjsgM0Oex75TWvjfJHfnh798t51PRdk+fc/d+ZhobXxrut6eM9PhQmelAcdTlHaMUZQFjNOCyTpLMS/lOokcP3683n77bUnSvHnzNHTo0Bx1AgICbM+Tk5Nzbcu+zD7m+vjcErW84p1t277cPtYRLy8veXl55Xjdw8PDlA+YWe3g/8TGxmrkmKeVkHK1yLYR4OOt9xcuUNWqVU1t193dXWnp6TIsbnkmbQVhlUVXU1NlzW/77hXyrF/gtl1UlO3T99wZFjelpafL3d291B+rOJ6itGOMoixgnOaPq/uq3CaRL774oubMmSPp2n0cx40b57BezZo1bc9Pnz6d60zl6dOnHcZcH59bEpkVHxgYaLse0j7+8uXLSklJyfW6yKx4++3hxhAfH6+ElKtq//hoVa5R2/T2L579U7tWzFd8fLzpSSQAAABuPOUyiZwwYYJmz54tSZo5c6ZeeOGFXOs2btxYbm5uslqtOnToUK632chaRTUkJMS2qI6UfUXVQ4cO2W7FkVt8kyZNsr1+ffwdd9zhNL5p06a5vheUbZVr1FZIvdJ5+h0AAADKj3KXRI4fP942Azlz5kxNmDDBaX1fX1+1adNGu3fv1tatWx3WNwxD27ZtkyTb4jpZwsPDVbduXZ06dUpbt25V3759c8QnJSVp9+7dDuPbtm0rHx8fpaSkaOvWrQ6TyOjoaB05csRhPACg+MTGxrp8PUlusu5VHBkZKXd392xlgYGBnDEAAChx5SqJtE8gZ8+e7XQG0t7gwYO1e/du7dy5U99//73uuuuubOVr167VyZMnJUmDBg3KVmaxWDRo0CC99tprWrVqlV555RWFhoZmq/POO+8oMTFR7u7utpVgs/j5+alPnz768MMPNX/+fD3zzDMKCgrKVmfGjBmSrl0P2bt3b5feEwDAXLGxsRo68slCX7/s6eGhp4YP0dMvvKi065ZaL6rrlwEAyI9yk0TaXwM5d+5cPffccy7HDh48WP/+97/166+/qk+fPlq2bJnuu+8+Wa1WrV+/XiNGjJAkde/eXffdd1+O+PHjx2vx4sU6d+6cevTooeXLl+v2229XWlqalixZoldeeUXStdt5hIeH54ifPn26Pv30U509e1a9evXSkiVL1LBhQyUlJWnOnDlasGCBJGnSpEkKDg7O974BABSeWdcvWwyrlBijB8ZNvrYo1f/H9csAgNKiXCSRp06d0qxZsyRJbm5umjFjhm32zpHx48dr/Pjxtp8rVKigjRs3qkOHDoqKilKnTp3k6+srq9Wqq1ev/ce5RYsWWrlypcP2goKCtGnTJnXt2lW//fabWrVqpYCAAF29etV2Q88uXbpo3rx5DuPDwsK0Zs0a9e3bV7t371Z4eLiCgoKUmJhoO+1pyJAheZ6aCwAoeoW+fjkzQzoSc+22OEWwQi0AAIVVLv46Wa3WbM/Pnz/vtH5iYmKO10JDQ3Xw4EHNnj1bn3zyiSIjI+Xh4aGmTZvq0Ucf1dixY+Xp6Zlrm7fffrsOHz6sGTNmaNOmTYqJiZGfn5+aNWumwYMHa+jQoXJzc8s1/v7779fBgwc1Y8YMbd++XWfPnlVwcLBatGihUaNGqU+fPi7sCQBAWlqqoqOjTW83OjpaGRkZprcLAEBpUy6SyNDQUBmGUeh2AgICNG3aNE2bNq1A8dWrV9fcuXM1d+7cAsU3aNBACxcuLFAsAEBKuHJJkSdO6uVX33B4z9zCSElO0plz55WenmZquwAAlDblIokEAECSriYnyc3DQ/c+Plq1QhuY2vbxn/dp/buzbZcZAABwoyKJBACUO5VDapp+39XYMzGmtgcAQGmV+0V4AAAAAABchyQSAAAAAOAykkgAAAAAgMtIIgEAAAAALiOJBAAAAAC4jCQSAAAAAOAykkgAAAAAgMtIIgEAAAAALiOJBAAAAAC4rEJJdwBAyUtLS1V0dLTp7UZHRysjI8P0dgEAAFBySCKBci7hyiVFnjipl199Q15eXqa2nZKcpDPnzis9Pc3UdgEAAFBySCKBcu5qcpLcPDx07+OjVSu0galtH/95n9a/O1uZmZmmtgsAAICSQxIJQJJUOaSmQuqFmdpm7JkYU9sDyruiOvVckgIDA1W1atUiaRsAcGMhiQQAoAwoylPPJSnAx1vvL1xAIgkAyBNJJAAAZUBRnnp+8eyf2rVivuLj40kiAQB5IokEAKAMKYpTzwEAyA+SSAAAUKTXW0pccwkANxKSSAAAyrmivt5S4ppLALiRkEQCAFDOFeX1lhLXXALAjYYkEgAASOJ6SwCAa9xKugMAAAAAgLKDJBIAAAAA4DJOZwUAAEWuKFd/ZeVXACheJJEAAKBIFfXqr6z8CgDFiyQSAAAUqaJc/ZWVXwGg+JFEAgCAYsHqrwBwY2BhHQAAAACAy0giAQAAAAAuI4kEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALiMJBIAAAAA4DKSSAAAAACAy0giAQAAAAAuI4kEAAAAALisQkl3ALhRxMbGKj4+3vR2o6OjlZGRYXq7AAAAQEGQRAImiI2N1dCRTyoh5arpbackJ+nMufNKT08zvW0AAAAgv0giARPEx8crIeWq2j8+WpVr1Da17eM/79P6d2crMzPT1HYBAACAgiCJBExUuUZthdQLM7XN2DMxprYHAAAAFAYL6wAAAAAAXEYSCQAAAABwGUkkAAAAAMBlJJEAAAAAAJeRRAIAAAAAXMbqrAAAoExLS0tVdHR0kbUfGBioqlWrFln7AFDWkEQCAIAyK+HKJUWeOKmXX31DXl5eRbINTzeLXps6WZUrVza9bRJUAGURSSQAACizriYnyc3DQ/c+Plq1QhuY3v6po4f14b9e0bP/+GeRJKkBPt56f+ECEkkAZQpJJAAAKPMqh9RUSL0w09uNPRNTZEnqxbN/ateK+YqPjyeJBFCmkEQCAADkoaiSVK7nBFAWkUSWMQkJCZozZ47Wr1+vyMhIubu7Kzw8XP3799fYsWPl6elZ0l0EAAAuKI7rOTldFkBRIIksQ6Kjo9W+fXtFRUVJknx9fZWamqr9+/dr//79WrlypXbs2KHg4OCS7WgpFRsbq/j4+CJpOzo6WhkZGUXSNgDgxlTU13NyuiyAokISWUZkZGSoV69eioqKUo0aNbR8+XJ16tRJVqtVa9eu1YgRI/TTTz9p4MCB+vzzz0u6u6VObGysho58UgkpV4uk/ZTkJJ05d17p6WlF0j4A4MZVVKfKAkBRIYksI5YtW6Zff/1VkrR+/Xq1bt1akuTm5qZHHnlEVqtVjz32mDZv3qwdO3bovvvuK8nuFlhRzRZGR0frckKiOg0Zq8o1apve/vGf92n9u7OVmZlpetsAAABAaUISWUYsW7ZMktShQwdbAmmvf//+evnllxUZGanly5eXySSyKGcLs2YKA6tUK7LV+wAAKG2KYuGerH+Y/vXXX6pRo4apbQMoG0giy4Dk5GTt3btXktS9e3eHdSwWi7p166b58+crIiKiOLtnmvj4eCWkXFX7x0ebPlvITCEAoLwpqoV7PD089NTwIRr+5BhNeXmiKleubFrb9tLS0opswcCibFtiVVzc+Egiy4AjR47IarVKkpo1a5Zrvayyc+fO6dKlS6pUqVKx9M9slWvUNn22kJlCAEB5U1QL91gMq5QYo99+/13P/uOfRbKybFpaqmKiolSvfgNVqGDu19WibDuLp5tFr02dXCQJNgkwSgOSyDLgzJkztue1atXKtZ592ZkzZxwmkampqUpNTbX9HBcXJ0m6dOmS0tPTC9zH9PR0JScn6+LFi/Lw8ChQG3FxcXKTdPbEUV1NNPe6yL9iouRZoYLOR/0hZRT8fZZE+/TdvPYthlW1kpN1+sivMixupradX+Vpv5eWtou6fbPazm2cloW+l0T79D3v9jOuJpv6d9ViWJWcnCxPbx81a99NlaqZf0rr6ZPHdPbMWTVu19n09ouybUmK/TNaO1Z/oOcmviwvD3OTvbSMNJ09FaNa9eqpgnvRfI33cHfTi8+PK/Or/WdmZio5OVk///yz3N3dS7o7eQoKClLFihVLuhtKSEiQJBmG4bSexcirBkrcRx99pAEDBkiSjh8/rptuuslhve3bt6tLly6SpG+++cbhtZNTp07VtGnTiq6zAAAAAMq0mJgY1a6d++VlzESWMxMnTtTzzz9v+9lqterSpUuqXLmyLBZLgduNj49XnTp1FBMTo8DAQDO6CpiOcYqygHGK0o4xirKAcVowhmEoISFBNWvWdFqPJLIMCAgIsD1PTk7OtZ59mX2MPS8vrxzXLpg5dR4YGMgHFaUe4xRlAeMUpR1jFGUB4zT/goKC8qzj/KIglAr2/wk4ffp0rvXsy/L67wEAAAAAFARJZBnQuHFjubld+1UdOnQo13pZZSEhIWV2ZVYAAAAApRtJZBng6+urNm3aSJK2bt3qsI5hGNq2bZsk2RbXKU5eXl6aMmVKkSzzDZiFcYqygHGK0o4xirKAcVq0WJ21jFiyZImGDx8ui8Wib7/9VnfddVe28jVr1uiRRx6RJH3xxRe67777SqKbAAAAAG5wzESWEYMHD1bz5s1lGIb69OmjHTt2SLq2uuratWs1YsQISVL37t1JIAEAAAAUGWYiy5CoqCh16NBBUVFRkq6d5mq1WnX16lVJUosWLbRjx44yf3NYAAAAAKUXSWQZk5CQoNmzZ+uTTz5RZGSk3NzcFB4erkcffVRjx46Vp6dnSXcRAAAAwA2MJBIAAAAA4DKuiUShJCQkaOrUqWrevLn8/f0VFBSkO+64Q3PmzFFaWlpJdw83uIsXL2rp0qUaOHCgmjRpIj8/P3l5eal27drq3bu3Pv300zzbYAyjJPzrX/+SxWKxPZxhjKI4xcfHa8aMGbr77rtVtWpV2zG1Q4cOmjp1qq5cueIwjnGK4rJ9+3b169dP9erVk7e3t3x8fFS/fn0NGDBAX331ldNYxqmJDKCAoqKijNDQUEOSIcnw9fU1vLy8bD+3aNHCuHTpUkl3EzewChUq2MabJMPb29vw8/PL9lr37t2NpKQkh/GMYZSE33//3fD29s42TnPDGEVx+vLLL43q1avbxpenp6dRsWLFbGP1p59+yhHHOEVxsFqtxqhRo7KNRx8fH8PHxyfba88995zDeMapuUgiUSDp6elG8+bNDUlGjRo1jO3btxuGYRiZmZnGqlWrjICAAEOScf/995dwT3Ejk2TceeedxrvvvmucOHHC9npkZKQxbNgw2x+GgQMH5ohlDKMkZGZmGnfffbchyWjdurXTJJIxiuK0Z88e25fxhx56yNi3b59htVoNwzCMpKQk44cffjBefvll4+TJk9niGKcoLu+//77tmPnwww8bx44ds5X9/vvvxoMPPmgr/+STT7LFMk7NRxKJAlm8eLHtg/rNN9/kKP/oo49s5V988UUJ9BDlwZdffum03P4/lqdOncpWxhhGSXjrrbcMScaAAQOMKVOmOE0iGaMoLklJSUb9+vUNScbYsWPzFcs4RXFp3769Icm46aabjPT09BzlaWlptnHcv3//bGWMU/NxTSQKZNmyZZKkDh06qHXr1jnK+/fvr7CwMEnS8uXLi7VvKD86dOjgtHzYsGG25/v3789WxhhGcYuMjNTLL7+sypUra968eXnWZ4yiuKxYsUInT55USEiIZs6cma9YximKy9mzZyVJt956qypUqJCj3MPDQ7fddpskKTExMVsZ49R8JJHIt+TkZO3du1eS1L17d4d1LBaLunXrJkmKiIgotr4B9ry9vW3PMzMzbc8ZwygJI0aMUFJSkubOnauqVas6rcsYRXHK+tLct2/fbMfNvDBOUZzq168vSfrll1+UkZGRozw9PV0///yzJKlVq1a21xmnRYMkEvl25MgRWa1WSVKzZs1yrZdVdu7cOV26dKlY+gbY27Vrl+158+bNbc8ZwyhuixYt0o4dO9SpUycNGjQoz/qMURSX1NRU25kat99+u06dOqWRI0eqTp068vT0VPXq1dWrVy99/vnnOWIZpyhOo0ePliT98ccfevTRR/XHH3/Yyo4ePap+/frp5MmTatCggZ577jlbGeO0aJBEIt/OnDlje16rVq1c69mX2ccAxeHKlSt68803JUnt2rXTzTffbCtjDKM4nT59WhMmTJCPj4/ee+89l2IYoyguUVFRtlsbnDx5Us2aNdOiRYt04cIF+fn56cKFC9q0aZN69uypESNGyLC7vTjjFMWpV69emjdvnjw9PbVu3To1bNhQvr6+8vX1VaNGjbRr1y6NHj1aP/zwgwIDA21xjNOiQRKJfEtISLA99/X1zbWefZl9DFDUrFarHn/8cZ09e1be3t56++23s5UzhlGcRo0apbi4OE2dOtV2OlZeGKMoLpcvX7Y9f+211+Th4aG1a9cqMTFRly9fVnR0tPr27StJWrx4cbbreRmnKG7jxo3TJ598omrVqkmSUlJSlJKSIklKS0tTYmKi4uLissUwTosGSSSAG86zzz6rTZs2SZLeeecd3XLLLSXcI5RXH374oT7//PP/196dh0VV/X8Afw8wwLAPIChg+NVcUJM0f2ouLK64lKYoWm6YmbmFC5rFV3APJdTUr+YGRaa4fjO/5YqmpmVoRm4PVohLioDJrsDw+f3Bc08zzsKAwEB9Xs8zz4Nzz7nnzL2fe72fu5yLF198EbNmzTJ1dxjTIt3mJ/29detWBAcHQy6XAwCee+457Ny5E76+vgCAZcuW6XwejbGaVlhYiJCQEAwaNAjPPfccjhw5gszMTGRmZuLIkSNo3bo1EhIS0KlTJ6SkpJi6u397nESySrO3txd/FxYW6i2nPk29DmM1ac6cOeLK46pVqzBhwgStMhzDrDZkZGQgLCwM5ubm2Lx5s87RBPXhGGW1RT1umjdvjiFDhmiVMTMzw5w5cwAA2dnZuHDhglZdjlNW08LDw7Fr1y60bNkSp0+fRp8+feDq6gpXV1f06dMHp06dQosWLZCVlYWpU6eKehynNYOTSFZpHh4e4u+7d+/qLac+Tb0OYzVl7ty5+OijjwAAMTExCAsL01mOY5jVhvfeew/Z2dmYNGkSWrVqhfz8fI2P9BwaAK3vOEZZbVF/DqxVq1Z6y7Vu3Vr8nZ6eDoDjlNWevLw8bNq0CQAwdepUnaMIKxQKTJs2DQBw5swZPHjwAADHaU3hJJJVmo+PD8zMykPn8uXLestJ0xo2bAhnZ+da6Rv75woPD8fKlSsBACtWrMDs2bP1luUYZrUhLS0NALBhwwbY29trfaSBnwCI7+bOnQuAY5TVHmdnZ4ODjUjUB9SRyWQAOE5Z7UlNTRW3UTdr1kxvuebNm4u/pX0wx2nN4CSSVZqNjQ26desGADh06JDOMkSEw4cPAwD69u1ba31j/0xz5sxBTEwMgPIEMjw83GB5jmFW13GMstokxc+1a9f0lrl69ar4W3opO8cpqy1SEgj8dSVcl4yMDPG3dEsqx2kNIcaqYMuWLQSAZDIZff/991rTExMTCQABoGPHjpmgh+yfYvbs2SLWYmJijK7HMcxMLTIyUsSYLhyjrLacOnVKxNL+/fu1pqtUKmrXrh0BIE9PT1KpVGIaxymrDYWFhaRQKAgAdejQgUpKSrTKlJaWUteuXQkAKZVKKi0tFdM4TqsfJ5GsSkpKSuiFF14Q/6FIG5xKpaJdu3aRg4MDAaD+/fubuKfs7yw8PFzs9GNjYytVl2OYmVpFSSTHKKtNwcHBBIBcXFxoz5494iA9PT2dRowYIWI1Pj5eox7HKast06dPF3EYFBREKSkppFKpSKVS0c8//0x9+/YV0xcuXKhRl+O0+nESyaosLS2NmjRpIjZYGxsbsra2Fv9u3749PXz40NTdZH9T6enpItbMzMzI3d3d4GflypVa8+AYZqZUURJJxDHKak9+fj75+fmJ2LKysiKlUin+DYAiIyN11uU4ZbWhsLCQgoKCNGLSysqKrKysNL4bNWqUxlVICcdp9eJnIlmVNWnSBCkpKViwYAHatm0LmUwGuVyOl156CTExMfj++++hVCpN3U32N/X0u80yMjIMfvLz87XmwTHM6jqOUVZbbG1tceLECWzevBl+fn6wtbVFfn4+PD09MXLkSHz33XeIiorSWZfjlNUGhUKBr7/+Grt378bgwYPh5eUlBnxq3Lgxhg0bhoMHD+KLL76Aubm5Vn2O0+olI1IbbosxxhhjjDHGGDOAr0QyxhhjjDHGGDMaJ5GMMcYYY4wxxozGSSRjjDHGGGOMMaNxEskYY4wxxhhjzGicRDLGGGOMMcYYMxonkYwxxhhjjDHGjMZJJGOMMcYYY4wxo3ESyRhjjDHGGGPMaJxEMsYYY4wxxhgzGieRjDHGGGOMMcaMxkkkY4wxkzh58iRkMhlkMpnJ+jB+/HjIZDKMHz/eZH1g1ac2Y+r69euQy+Vo27YtysrKqmWeTZo0gUwmQ3x8fLXMj9UdQUFBkMlkSEpKMnVXGKsWnEQyxuoM6eCvKp+6eNB18+ZNnX21traGm5sbWrdujZEjRyI2NhZ37941dXf/Vk6ePImoqKg6GRfVIT4+XsTTzZs3Td2dWhEVFYWoqKg683vDw8NRWlqKyMhImJnx4VRNunTpEqKiorB69WpTd6XKoqKiAABz5syptpMOjJmShak7wBhjEnd3d53f5+fno6CgwGAZhUJRY/2qDg4ODqKPKpUKjx49QmZmJq5du4bExETMnTsXISEhWLNmDVxdXU3c29phY2ODli1b1si8T548iYULF8Lf39/gVcZGjRqhZcuWaNSoUY30g1WfhQsXAgACAgLQpEkTk/blxIkTOHjwINq2bYvg4GCT9uWf4NKlS1i4cCG8vb0RFhZm6u5USZcuXdCvXz8cPnwYn3/+OcaOHWvqLjH2TPjUGWOszrh//77Oz5w5cyosExISYsKeV2zNmjWir5mZmSguLsYff/yBvXv3on///lCpVPjiiy/g6+tbZ6601LROnTrh+vXruH79usn6sHz5cly/fh3Lly83WR9Y/RMdHQ0AmDx5sklvx2b1y+TJkwEAK1asMHFPGHt2nEQyxpiJNGrUCEOHDsXXX3+NxMREyOVy/PHHHxg4cCBKS0tN3T3GmA5paWk4cuQI5HJ5nT95xeqWAQMGwNnZGVeuXMF3331n6u4w9kw4iWSM1WslJSU4cOAAJk2ahI4dO6JRo0awtLSEm5sb+vXrhx07doCIDM4jPT0db775Jry8vGBlZQUvLy+Ehobi119/1XiusSavEI4YMQLLli0DAFy9ehWffvqp3rLfffcdRo8eDW9vb1hbW8PR0RGdOnVCdHQ08vPz9dY7fPgwhg4dCi8vL1haWsLBwQFNmzZF3759ERMTg4cPH+qsV1BQgNjYWPj7+8PV1RWWlpbw8vKCv78/PvroI2RkZGiUDwgIgEwmQ1RUFEpKSvDRRx+hY8eOcHJygkwmw8mTJwEYHgRFeuZPum3x6NGj6N+/Pxo0aACFQoE2bdpgyZIlePz4sUY9aX1Jtz5+++23Bp+fNWZgnZMnT2L48OHw9PSElZUVXF1d0atXL8TFxUGlUumsExUVBZlMhoCAAADA8ePHMXDgQDRo0ADW1tbw8fHBwoULtfpfW/73v/9h2LBh4jcplUr4+flhw4YNKC4u1llHfb0SETZv3ozOnTvDwcEB9vb2ePnll/H5558bbLekpASxsbF48cUXYWtrC2dnZwQEBGDPnj1abUikdSQJDAzUWJ+Gbm399ddfMWHCBDRu3Fhs22+99dYzPYO8ZcsWEBH69OlT4a3n2dnZWLRoETp37gxnZ2dYW1ujSZMm6Nu3LzZs2ICcnBy9dYuLi7Fy5Ur4+vrC1tYWjo6O6NmzJw4dOqS3TlpaGqKjoxEUFIQWLVrA1tYWdnZ2aN26NcLCwnDr1i29dY3dbsvKynD8+HHMmDEDXbp0EfsTFxcX+Pv7Y+PGjSgpKTG8EAEcOXIEI0eOhLe3NxQKBZydndGuXTtMnz4d586dE+VkMhlCQ0MBlO+rn96e1WNFkpmZiYiICLRv3x6Ojo6wtrZG06ZN8eabb+LKlSs6+/P0/uinn37CG2+8AS8vL8jlcrEtA0BpaSk2bdqEgIAAuLq6Qi6Xw8XFBS1btkRISAi2bt2qsw1LS0sMGzYMALBp06YKlxFjdRoxxlgdFxkZSQBI1y7rxIkTYhoAcnBwIHt7e43vhg8fTiqVSue8z549q1FeoVCQnZ2dmNeuXbvEtLS0tEr1Oy0tTdSNi4ursHxRURG5uroSAOrRo4fWdJVKRTNmzND4bXZ2dmRubi7+3bJlS7p586ZW3YULF2rUs7GxEb9T+pw4cUKr3oULF6hx48aijJmZGTk7O5OVlZX4btWqVRp1/P39CQDNmzePunbtSgDIwsKClEolyWQy0Y76untaXFwcASBvb29av349yWQyAkBOTk5kYWEh6rVv354ePnwo6t26dYvc3d3J1taWAJBcLid3d3eNz86dO0X5cePGEQAaN26cznUyc+ZM0ZZMJiMnJyeN5d2zZ0/Kzc3VqifFrL+/P61YsYJkMpmoL/0WABQYGEilpaU62zZEWj6VjcvCwkIKDg7W2mbU+9SlSxeNZSqR1mtERAQNHjxYrFcHBweN+S1YsEBn2/n5+eTn5yfKmZubi5gAQPPnzxdtREZGinozZswgd3d3UU+pVGqsz44dO4qy6jGVlJQkYtze3l4jbjw8POjOnTtGLzd1HTp0IAC0fPlyg+UOHz5MSqVStGlhYUEuLi4kl8vFd/v379eo4+3tTQBo7dq11LlzZxHD6tuqTCajrVu36mxTWn4AyNLSklxcXMjMzEx85+joSKdPnzZYt6LtVn2/Ju2DHB0dNb7r0aMHFRYW6mynoKCAhg8frlHe3t5eYx6+vr6ivLu7u4gxMzMzre155cqVGvM/evQoOTk5iXnJ5XKxP5CWy6effqrVL/XY2bNnj1hPDg4OZG1tTf7+/kREVFpaSn369NHov6Ojo8Y+0dDhdUJCAgEgd3d3vWUYqw84iWSM1XmGksgffviB3n77bTp69Cjl5OSI77Ozs2nNmjXi4GPNmjVadf/8809q1KgRAaCmTZtSUlISlZWVERHR+fPnydfXV+MgsKaTSCKiESNGiAOdoqIijWkREREEgNzc3Gj9+vWUnZ1NRETFxcV04sQJat++PQGgDh06aCTNN2/eFAeSs2bNort374ppjx49otOnT9OUKVMoOTlZo71bt26JpLZx48a0c+dOKigoICKisrIyunLlCkVFRdHnn3+uUU86GLWzsyM7OzuKi4sTB5RZWVmi38YkkTY2NiSXy2n48OF069YtIipPhDZs2CAO2l577TWt+upJnCGGksi1a9eK/k2aNInu3btHROXJ0KpVq0RSEhISord9JycnMjMzo/nz51NmZiYREeXk5NCCBQvEvPUlBIZUNYkcPXq0iPft27eLbaaoqIi+/PJLatq0KQGgIUOGaNWV1qtSqSRHR0eKj48X6/X27dv0yiuviAP91NRUrfpvv/22mB4dHU15eXlERJSZmSlOjkgH/+pJpMTQyQ6JekwplUp69dVX6dq1a0RE9OTJE0pMTBQnjcaMGWP0cpPk5OSIkwjHjx/XW+7ixYtkbW1NAKhNmzb09ddfU3FxMRGVJyHJyck0e/ZsOnbsmEY9KYlUKpXk6elJ//3vf0W969evU5cuXcS29ejRI6123333XVq/fj2lpqaKfUBJSQn98MMPFBQUJBJoXQmesdvt7du36Y033qADBw6I74iI8vLyKC4ujjw8PAgAzZw5U+eykfZxZmZmNG/ePLp9+7aYlpmZSdu3b6fJkydr1FE/qWRISkoKKRQKAkBvvfUWXb16VZykSU9PpylTpojk+Mcff9Soqx47dnZ2NGDAABE7RCRiWkoCra2tacuWLSKOy8rKKCMjg/bt20fBwcF6+5iamiraUZ8/Y/UNJ5GMsTrPUBJZkd27dxMAatasmda0xYsXi4OBGzduaE3PzMwUSVRtJZFLly4VddT7lJaWRubm5qRQKOjSpUs66+bm5pKXl5fWFY7ExEQCQC1atKhU/6WEw8XFRSRwxlC/GnLgwAG95YxJIqVEUNeV5C1btogy58+f15j2rElkYWEhOTs7EwAaNWqUzroff/yxaP/pBFw9ZnUlREREQ4cOJQDUu3dvg33UpSpJ5KlTp8RJCH3r8/bt2+KqzU8//aQxTX29JiUladV9/PixSCCWLFmiMS09PV2cyFi8eLHOtqV1UV1JZGBgoM64kdabQqGgkpISvfPS5fjx42L+WVlZest1796dAFDz5s11Jnv6SEmklZWVzgTjwYMHIjl9+uRNRUpLS6ldu3YEgBISErSmG7vdVuTHH38kAGRra6t1IuzYsWOijf/85z9Gz9PYJLJnz54ElF/V1kc6YTF48GCN79Vjp1OnTnrvEHjnnXfEiaWqkq4sb9u2rcrzYMzU+JlIxtjf2sCBAwEAv/32G+7fv68xbffu3QCAkJAQPP/881p1XV1d8c4779R8J9U4OzuLv9WfUYyPj4dKpUJQUBB8fX111rW3t8eQIUMAlD//KHFycgIA5OXliVelVKSgoACJiYkAgPfeew+NGzeuzM8AALRp0wavvPJKpes9LSIiQud7+EJDQ+Hl5QUA2Llz5zO3o+7o0aNi+et65goApkyZIl4N8sUXX+gsY2VlpTG6sLrBgwcDAFJSUp6xt8aRntN644039K5PLy8vBAYGAtCMIXXdunUTZdRZWVmhX79+ALR/0969e1FWVgYbGxvMnDlT53z//e9/G/dDjPT+++/rjBtpuRcVFeHGjRuVmucff/wBADA3N9fYVtXduHEDZ86cAQAsW7YMjo6OlWoDAIKDg9GqVSut7xs0aICXX34ZQOXjxtzcHEFBQQAg+qfLs263HTt2hJubGwoKCnDp0iWNadu2bQMAtG3bttr3rTdv3kRSUhIsLCz0bnMAxKs1jh07pveZ5vDwcJibm+ucJu1Pn/7/pDJcXFwA/BVPjNVHnEQyxuq9vLw8rFy5Ev7+/nBzc4OlpaUYIMHGxkaUu3Pnjvi7uLhYDLDg7++vd97qgymYkjSS35EjR9CwYUO9n7i4OADlA1BIOnXqBFdXV9y7dw+dO3fGunXrcP36dYMDDiUnJ4vBMap6QNmtW7cq1VNnYWGBHj166JxmZmYm1k9ycvIzt6VOml/jxo3RokULnWXMzc3Rs2dPg+23adMGdnZ2Oqd5eHgAgN4BjaqbFENbt241GEPHjh0DoBlD6jp37qy3DX2/6eLFiwDKEwxbW1uddZs1a1alkxX66Oun1Eeg8ss+MzMTAMRgM7qcPXsWQHl89O/fv1Lzl1RlGUtOnz6N8ePHo1WrVrCzs9MYhEZ6tYT6vvBpxmy3xcXF2LhxI/r27QsPDw9YWVlptPPgwQOd7UjLZtCgQRW2UVlSfJeVlaF169Z641tKpAsKCpCdna1zXoaWwYABAyCTyXDgwAH0798fO3bsqHQyKJ2AkOKJsfrIwtQdYIyxZ5GamopevXppHKzY2NjAyclJXIWQRg9Vvwr38OFDcRZa/aDyaZ6enjXRbb3UDwyls9XAX2esCwoKjLqaWFhYKP52cnLCjh078Prrr+PKlSuYPn06AMDR0RF+fn4YMWIEQkJCIJfLRR31s+ze3t5V+i1ubm5VqqfO1dUVVlZWeqdL60c6aK0u0vwqWv/SlVB97dvb2+uta2FR/l9wbb3ORYqh3Nxc5ObmVlhePYbUGfObnh6dUzpYNrStAeXL+/bt2xX2zRj6+in1EdDuZ0Wk0XQNxaS07bi6uupNmCtSlWUMAPPmzdN4B6G5uTmUSiUsLS0BAPn5+RXuQyrabh88eIDevXvjl19+Ed9ZW1vD1dVVXL3LzMxEWVmZVjvSsqnqPsUQKb7Lysq0RozWR1+MG1oG3bt3R3R0NCIiInDo0CExWq6Xlxd69+6NsWPH6rxSr06hUACAyUZnZqw68JVIxli9Fhoaijt37qBJkybYvXs3srOzUVBQgAcPHuD+/fsaQ/nru/JWl14W/vPPPwMoP0hVT2CkhHfevHmg8ufZDX6k4fglvXv3RlpaGj777DOMGzcOzZs3R05ODr766iuMGTMG7du311hW1bFM9N0OxkxDiqENGzYYFUPqr0KpLnVpW6sK6cTOn3/+qbeMqX7j0aNHRQI5ZcoU/PLLL3jy5AkePnyI+/fv4/79++JWYkN3IVS03c6cORO//PILXFxcsG3bNty7dw9FRUXIzMwU7UgnC55upyaXjRTf7u7uRsU3Eel9PUxFyyA8PBxpaWlYtWoVhgwZAjc3N9y5cwfx8fHo2bMnhg8fbvAEhXSyUP1EIWP1DSeRjLF66/bt2+L2qB07diA4OFjrOSV9z604OzuLAwVDtyI9y/vkKuvx48dISkoCAHTp0gXW1tZiWsOGDQHov8XQGLa2thgzZgzi4+ORmpqKO3fuIDo6GtbW1hpXKNXbe9Y2n1VWVpbe9xYCf62f6rjqqU6an6Hb/tSnV3f7NaE6YqiqGjRoAKDiZ8Bqc3urCul3FBUV6b2KJC3nrKwso59Brg7Sc8H9+vXD+vXr0bZtW61k6Fme4wPKr37u27cPALBu3TqEhoZq7CuA8mQuKytLZ/2ajMHaXu4eHh4ICwvD/v37kZGRgZSUFEycOBEAsGfPHmzYsEFvXSmJlOKJsfqIk0jGWL2lfttb+/btdZaRnu96mqWlJdq0aQMAWlft1BmaVt3WrVsnDr7Gjx+vMU16RufYsWPVdguUp6cn5s6di9mzZwMov5Ih6dixo7gF7quvvqqW9qqitLQUp0+f1jmNiPDtt98CKO+vOulWZkNXXAyR5nfnzh2kpqbqLKNSqXDixAkAwP/93/9VqZ3aJMXQwYMHa73tDh06ACh/dlTfAf7vv/9u8FZW6SpWVddpdWjdurX4+/fff9dZpmvXrgDK4+Obb76plX4Bf+0P9e0LiUicpKqqzMxMsf/R186ZM2f07qOkZVPZfYox27MU37W93CUvvPACNm/eLPqhvj9Vl5eXJ/bzPj4+tdY/xqobJ5GMsXpLfdRD6TZQdXl5eViyZIne+sHBwQCAxMRE/Pbbb1rTs7OzsXHjxmroacV27dqF999/H0D5yIWjR4/WmD5hwgRYWFggKysLkZGRBudVXFyM/Px88e8nT54YLC89n6M+kqWNjQ1GjhwJAPjwww+r7Tm1qli6dCnKysq0vv/0009Fv0JCQjSmOTg4AAAePXpUpTb79OkjbjXTNzrrJ598Iq6sjRo1qkrt1KZJkyYBAC5fvmzwKglQ/uytoSvAlTV06FCYmZmhoKAAa9as0Vlm6dKlBufxrOu0OrRs2RLu7u4AgPPnz+ss8/zzz8PPzw9A+Qixxjx/Wh2k/aGufSEAbNy4UW/iaywHBweRzOtqp7S0FB988IHe+m+++SYA4MqVKxXG4NPtAobXffPmzcVAWx988AFycnIMzrOqA1pVZX+qLjk5GWVlZbCwsKiWwccYMxVOIhlj9ZaPjw+ee+45AOVJ1oULF8S0c+fOISAgwOCzS9OmTYO7uzseP36MoKAgfPvtt+JMd3JyMvr06VOjg57cv38f+/btw8CBAxESEoKSkhJ4enri4MGDGoN/AOUjV0qvQFixYgXGjh2Ly5cvi+mlpaW4dOkSFi1ahOeff15jaP3o6Gj0798fCQkJGrdnPnnyBLt27cLKlSsB/PU6FMnSpUvh6uqK7OxsdOvWDbt27UJRURGA8isCly9fRnh4OBISEqp1uaizsbHBmTNn8Prrr4u+P378GJs2bRKvCBg8eDA6deqkUa9t27YAyg9WpVueK0OhUIjkcceOHZg8ebIYrKOwsBAff/wxwsLCAJQnsC+99FJVfl61+PPPP5GVlaX3Ix0s+/v7IzQ0FAAwdepUzJw5UyOpePLkCb7//nvMnTsX3t7e1TpYkbe3t0ggFixYgJiYGHGiIzs7G7NmzcK2bdvE6xN0kdbp9u3b9Q6IUhuk0Zx/+OEHvWXWrFkDa2tr3LhxA926dcOhQ4fEM3IqlQo//vgjJk+erPdOiaqQRh395ptvsHjxYnHF99GjR1i2bBmmT5/+zM/g2dnZicRn1qxZSEpKEid4Ll++jAEDBiA5OVnvgEKBgYHi5NS0adMwf/58jX1SVlYWtmzZImJFIq373Nxc7Nq1S2//1q5dCzs7O6SmpqJLly748ssvNa6K3r17FwkJCejVqxfmzZtXhSUADBkyBBMmTMA333yjkdQ+fPgQS5YswfHjxwFo708lUtx06NBB78jNjNULNfgOSsYYqxbqL25/2ldffUUWFhZiuo2NDdnY2IiXXau/3FrXS8pPnz4tXvws1Zf+7eTkRLt37xbT7t27V6l+p6WliboODg7k7u5O7u7u1KBBA7K0tBTTAJC5uTmNGTOGsrOz9c6vrKyM/v3vf5NMJhP1FAoFubi4kLm5ucb8zpw5o3P5SXWcnZ015uPj46Pz9124cIE8PT01+uni4iJeeA6AVq1apVFHemm5rhfGq1N/uffT1F8uvm7dOtFXpVJJcrlc1PP19dX50veSkhJq2bKlKKdUKsnb25u8vb1p9+7dopz0gvtx48bp7OPMmTPFPGQyGSmVSo14CwwMpNzcXK160jL39/ev0u+viLR8jPk4OjqKek+ePKGJEydqTLezsyOlUklmZmYa39+5c0ejTWPWq6HfnZeXR927d9eIJaVSKdZtREQE+fn5EQBavny5Vv2EhARRVy6Xk6enJ3l7e1O3bt0qvUwN7RMqsn//fgJAjRs3prKyMr3lDh8+TI6Ojhp9dnFx0Yjf/fv3a9Tx9vYmABQXF6d3vvpitri4mHr06KEVr9J6HThwIEVEROhdP8Zut8nJyWRrayvasbKyInt7ewJAFhYW9Nlnnxn8HQUFBTR06FCNWHNwcNBYVr6+vlr1evXqJabb29uL7fnp/c+ZM2eoYcOGWvsshUKh0ebEiRM16hkbO9JyUu+7g4ODxnfBwcGkUql01n/55ZcJAK1evdpgO4zVdXwlkjFWrw0aNAinTp3CwIED4eTkhNLSUri6uiI0NBQXLlxAr169DNbv3r07UlJSEBoaCg8PD5SWlsLJyQkTJkzAxYsX0axZM1HW0FWSiuTm5iIjIwMZGRnIycmBg4MDfHx8EBISgtjYWNy6dQufffaZ3heYA+XPhC1atAgpKSmYMmUKfHx8YG5ujpycHCiVSnTt2hXh4eE4e/asxm1SkyZNwqZNmzBq1Ci0bdsWNjY2yM3NhVKpRI8ePbB69WpcvHhRa4AMoPxs+bVr1/Dhhx+iS5cusLe3R15eHho0aICAgADExsbi9ddfr/JyMcbUqVNx+PBhBAUFwczMDGZmZmjVqhUWLVqEc+fO6by6YmFhgePHj2PixIn417/+hYKCAqSnpyM9PV3jVt+KxMbGIikpCcOGDYO7uzvy8/Nhb2+PwMBAbNu2DUePHjX4Ooa6xtLSEps3b8bZs2cxfvx4NGvWDCqVCvn5+XBzc0NAQAAWLFiAlJSUan+9jZ2dHY4fP46VK1eiXbt2sLS0BBHB398f+/btw+LFi8WVHV3b2ujRo5GQkIDu3bvDxsYG9+7dQ3p6eoWDH1W3QYMGwcPDA7dv3xbP5OrSt29f3LhxAx988AHat28PhUKBgoICeHp6ol+/fvjkk0/Ee0arg1wux5EjRxAZGYkWLVpALpeDiNCpUyds2LABBw4cqJYRk1966SWcP38eI0aMgKurK8rKymBvb48RI0bg7NmzGDNmjMH6NjY22Lt3Lw4ePIjXXnsNHh4eePz4MSwsLNCuXTvMmDEDmzZt0qq3Z88ezJw5Ey1atEBJSYnYnp++xbVbt25ITU1FTEwM/Pz84OTkhEePHsHc3Bw+Pj4YPXo0tm/fjtWrV1fp969duxbR0dEYMGAAmjdvDiJCUVERPDw88Oqrr2Lv3r3YvXu3zttZf//9d5w7dw4KhQJjx46tUvuM1RUyIhM+oc4YY3Xc5s2bMWnSJDRt2lTnc5OsZsTHxyM0NBTe3t64efOmqbvDakF+fj5cXFxQXFyMU6dOoUePHqbukl6LFi1CZGQkQkNDsW3bNlN3h9UTHDfs74SvRDLGmB6PHz8WZ6ul540YYzUjNjYWxcXFcHZ2rvOj3YaFhaFBgwbYvn17rV8JZfVTQUEB1q5dCysrqwoHR2OsPuAkkjH2j7Zz505ERETg8uXLYjTK0tJSnDp1Cj179sTVq1dhbW2Nd99918Q9Zax+y8vLw8iRI3Ho0CGNWxDT09MRHh4uBjIKCwvTeEdqXeTg4IDIyEgUFxdj2bJlpu4OqwekVzjNmDED3t7epu4OY8/MouIijDH293X//n0sXboUS5cuhUwmg1KpRH5+vkgoLS0tERcXhxYtWpi4p4zVbyqVComJiUhMTAQA8SxpXl6eKDNs2DDMnz/fJP2rrLfffhuPHj2CmZkZysrK9L7SgTEAsLW1RVRUlBjVmbH6jpNIxtg/2qBBg5CZmYmTJ08iPT0dWVlZkMvlaNq0KQIDAxEWFsYJJGPVwM7ODuvWrcPRo0dx+fJlZGZmoqioCI0aNULHjh0xduxYDBs2TLyHsK6zsLAw+E5ExtRNmzbN1F1grFrxwDqMMcYYY4wxxozG914wxhhjjDHGGDMaJ5GMMcYYY4wxxozGSSRjjDHGGGOMMaNxEskYY4wxxhhjzGicRDLGGGOMMcYYMxonkYwxxhhjjDHGjMZJJGOMMcYYY4wxo3ESyRhjjDHGGGPMaP8PXY2fQ0Rl+XUAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Tag Description의 평균 토큰 수: 5.29\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5EAAAJACAYAAAAUx+KBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACQJklEQVR4nOzdd3xUVf7/8fckpHdKCAQkQUGqCrq6QABBaSoaRRARRXpR1KUpuwgBsdB010ak2lCpoiJVigiiC6KiCBZIIgsCgZAOqff3B7/c74RMkhuYlIHX8/GYx2Nmzvmce+ae3Ek+OfeeazMMwxAAAAAAABa4VXYHAAAAAACugyQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBKAJMlms8lms+nWW2+t7K5clEcffdT8DPHx8UXKt23bZpbHxMRUeP+c5XL5HBXlyJEjevLJJ9WsWTP5+/ub++6GG26o7K7hChURESGbzaaIiIjK7koRMTEx5jGybdu2yu7OZeXWW2819y1wOahW2R0AYF1xv3w8PT0VGBiooKAgNWjQQK1bt9Ytt9yiO++8Uz4+PhXcS8cKEp6IiAg9+uijldqXqiQ5OVn//ve/JUk33HCDoqOjK7U/l5ODBw+qbdu2OnPmzEXFv/322xo4cKBT+hIXF1clk4aSuPL3Dc774YcftHr1aklSdHT0FffPk/j4eEVGRjqlrcWLF/O7C7BDEglcBrKzs3Xq1CmdOnVKhw4d0pYtWyRJwcHBGjBggKZOnaqgoKBK7ePUqVMlSR07duQXsZ3k5GRz3wwYMIAk0okmTJhgJpB33XWX7rnnHtWsWVOSKv14cGWu8H2D83744Qfz+yUiIuKKSyIBlB+SSMBFffzxx+ZzwzCUkpKiM2fO6IcfftD27dsVHx+v5ORk/ec//9HKlSv14YcfKioqqtj2DMOoiG6Xm7fffltvv/12ZXej3N16660uP1YVIScnR5s2bZIkNW3aVJ9++mmZTyPr3LlzoePsQq+++qq2bt0qSRo9erQ6d+5cbN3Q0NAybbuqcfb3zZXM0en2VUVMTMxldZp8aGhoicfwli1b9Nprr0mSOnXqpCeeeKLYuq1bt3Z6/wBXRhIJuKiSZqwMw9C6dev01FNP6ffff9f//vc/3XXXXdq5c6eaN29ecZ0EKsmpU6d07tw5SdL1119/UdchXXXVVbrqqquKLS84TVA6/wfm5TyLzPcNXJGvr2+JP7vJycnm86uuuuqyPoYBZ2NhHeAyZLPZdMcdd2jPnj3mbEBKSop69+6t/Pz8Su4dUP6ysrLM515eXpXYk8sf3zcAcOUhiQQuY4GBgVq2bJmCg4MlSQcOHNDSpUsd1rWyOuuxY8c0efJktWnTRtWrV5eHh4dCQkLUqFEjtW/fXmPGjNFXX33lsN0CX375pfme/cN+JUBHK5D++uuveuqpp9S0aVMFBgbKZrMVOn21tNVZHfnpp580bNgwXX311fLx8VGtWrV0++2368MPPywx7u233za3VdoptMXVjY+Pl81mK7TowzvvvONw39h/nrKszpqZmalXXnlFnTp1UlhYmLy8vBQaGqqoqCi9+OKLSklJKTHe0UqN33zzjR566CE1aNDAbO+uu+7S+vXrS2yrrJKSkvTcc8+pTZs2qlWrljw9PVWnTh3dfvvteu2118xZxgsV/ByUtl8r6pTC1NRULVmyRIMHD1arVq0UHBwsDw8PVa9eXa1bt9bYsWN16NAhy+0dOnRIo0aN0jXXXCMfHx+FhoaqQ4cOmjdvnvLy8iRV3krLZfm+KZCdna2FCxfq7rvvVv369eXt7a3g4GBdd911Gjt2rKVxupjvpQsZhqHVq1fr4YcfVqNGjRQYGFjoZ+6FF15w2BdHx8jmzZv14IMPKjIyUt7e3kV+3kpbndVRm2vXrtU999yjevXqycvLS/Xq1dODDz6oXbt2OWyj4HvHfmGogQMHFjkOLuxDWVZnPXLkiJ555hm1bt1a1atXl5eXl8LDw9WzZ0+9/fbb5s9jcRytVvrRRx+pS5cu5vdVgwYN9Oijj+rgwYMltlURLvXzWmU/Bi1atNDRo0eL1Dl16pSef/55tW/fXmFhYfL09FStWrXUvn17zZw5U+np6SVu48KfwdzcXM2bN09RUVGqWbOmfHx81KhRIz3++OP63//+V2qf9+7dqxEjRqhly5YKDAyUh4eHQkND1axZM3Xv3l3PPfecfv/994vaH6jCDAAuQ5L5KIsJEyaYcbfffnuJbXfs2NFh+Zo1awx/f/9CfXD0CAoKKrbPJT22bt1qxmzdutV8f8qUKcY777xj+Pj4FIlZvHixGTNgwADz/bi4uCL9v7DNd9991/Dy8iq2P3feeadx9uxZh/ti8eLFDvtQlrpxcXGW943957nwcxRn165dRt26dUtst0aNGsaGDRuKbWPKlCmFxmf69OmGm5tbse1Nnjy5xH1h1erVq43g4OAS+37VVVcZe/fuLRJr/3NgdZ9eLPttOfo5yMrKKvFnrOBRrVo14/XXXy91ex988IHD48D+2E1OTi71WLaqPL9vDMMwdu/ebURGRpa4bzw9PY3Y2Nhi27jY7yV7f/zxh9G6detS24iIiCgSa3+MbNmyxXjsscdK/Xlr0KCBIclo0KCBw/5ceNyNGjWq2D65ubkZMTExRdqw/94p6XFhHy7cdnFiY2NL/FmUZLRs2bLE46xjx45m3bNnzxrR0dHFtuXl5WWsXbu22LYulv1+GjBgQIV9Xkfy8vKMESNGmHXatm1rJCUlOexzQEBAiX2pXbu28fXXXxfbF/ufwcTERKNdu3bFthUSEmLs2bOn2LamTJli2Gy2Un/W7rnnnmLbgGvimkjgCtCvXz/NnDlTkvT1118rJydHHh4eluOPHj2qvn37mv/dvPPOO9WlSxfVrVtX+fn5OnnypH788Udt2rSpyOxWwaIG9957rySpefPmmj59epFttGjRwuG2d+7cqeeff17u7u4aPHiw2rVrJ29vb/36668KCwuz/Bns7d69Wy+88IIkadCgQerQoYPc3d21e/duLVy4UBkZGfr888/Vv39/rVix4qK2UZqCBR9Onjyp4cOHSyp+YYeyLsry/fffq3Pnzjp79qwkqVWrVurXr5+uuuoqHT9+XMuWLdPOnTt1+vRp3XXXXdq4cWOps1bz5s3Thx9+qPDwcD366KNq3ry5srOztX79ei1dulSGYWjatGnq2LFjiQvMlGbt2rXq1auX+V/9Dh066P7771ft2rWVkJCg9957Tz/99JP+/PNPdezYUf/973/VpEkTM/6JJ55QdHR0qfu1Iha6yc/PV1ZWlurWrasuXbrouuuuU+3ateXm5qYjR47o66+/1qeffqrc3Fw9/vjjqlu3rnmcXGjz5s16+OGHzf3SsWNH3X///QoNDdWff/6p9957T19++aWGDh1a7p+rNFa+b3bt2qXbb79dmZmZstls6tatm7p27arw8HCdPXtWu3bt0nvvvafMzEyNGDFCXl5eRVZ1vpTvpQK//fab2rRpo6SkJElSnTp19MADD+j666+Xn5+fTp48qT179mjNmjWlLmg1a9YsrVu3TmFhYXr00UfVokUL5ebm6r///e9Fn1L9n//8R6tXr1bNmjU1ZMgQXXfddcrMzNT69eu1cuVK5efnKyYmRjVq1NDjjz9uxhUsCmW/cIyjxZ98fX3L3Ke33npLI0aMMF/37NlTd955p4KDg/Xbb79p8eLFiouL008//aSoqCh9//33qlWrVoltDho0SKtXr9aNN96ovn376qqrrtKpU6e0ZMkSff3118rKylL//v3166+/missV5Ty+LwXysrK0kMPPaSVK1dKku644w4tX768yPj85z//0VNPPSXp/Njdf//9atu2rWrUqKFTp05p/fr1+vTTT3XixAndfvvt2r17t5o1a1bsdnNzc9WrVy/t3LlTnTp1UnR0tOrUqaOjR49qwYIF2r9/v86cOaO+fftq//798vT0LBT/ySefmKv/+vj46MEHH9Tf//53Va9eXefOndP//vc/7dmzx1zkDJeZys5iAVini5wZyM3NNfz8/MzYH374odi2Hc1ezJo1yyyfMWNGsdvJz883tm/fXmLfrcyO2M+2STLCwsKM/fv3lxhTlplISUZAQICxa9euIvV+++23QjN4K1asKFLHGTORBexnJEv6T7ijz+FoJjIvL89o3ry5WefJJ5808vLyitSbNm2aWad+/foOZ13tZyUkGV26dDHS09OL1Hv55ZfNOj169Cj1MxQnJSXFCA0NNduaM2dOkTo5OTnG0KFDzTo33XSTw7bKul8vRmkzkbm5uca6deuM/Pz8Ytv48ccfjbCwMEOS0bBhQ4djlZ2dbTRs2NDc1osvvlikTk5OjjF48OBC41VZM5Glfd+kpqYa9evXNyQZwcHBxrZt2xy28/vvvxtXXXWVIcnw8/MzEhMTC5Vf6vdSbm6u0bJlS7ONhx56yMjIyHDYRnZ2tvHpp58Wef/CYyQqKspISUkpti+GUbaZSElG8+bNjRMnThSp9/HHHxvVqlUzJBm+vr5GQkJCkTpl+a66cNuOZiLj4uLMGTl3d3dj6dKlRepkZmYad955p9nO/fff73Bb9jNzkox//etfRY6VvLy8QjOUJY3zxShtJrK8Pq+9lJQUo1OnTmbZww8/bOTk5BSJ3717tzneN9xwg8PxNgzD+OyzzwwPDw9DknHLLbc4rFPwM1jweOutt4rUOXv2rHHLLbeYdRx99oLP7e7ubuzcudPhtgra+vbbb4sth2vimkjgCuDu7q569eqZrxMTE8sU/8cff5jPS5rpsNlsat++fdk7WIq33nqrxP+mXoxZs2bp73//e5H3GzVqpIULF5qvZ8+e7dTtlrc1a9Zo//79kqS///3veuWVV+TmVvSr/tlnn9Wdd94p6fy1Pu+//36J7daoUUNLly6Vn59fkbInn3zSXMV0y5Ytys3Nvai+v/322zp58qQkqU+fPhozZkyROtWqVdPcuXN13XXXSZL27NmjL7744qK2V97c3d3VvXv3EleGve6668xZ8cOHD+vrr78uUueTTz7R4cOHJUndu3fXM888U6ROtWrV9Oabb6pRo0ZO6v3FK+37Zv78+Tpy5Igk6d1331XHjh0dtnPNNddo8eLFkqSMjAzNmzevUPmlfi8tXbpUP/30kyQpKipK7777brEzcx4eHurZs2ex25AkPz8/LV26VIGBgSXWK4tq1app6dKlDmfOo6OjNXbsWEnnr3+eO3eu07ZbnFdffdU8w2Hs2LHq06dPkTo+Pj764IMPVKdOHUnSypUrS70ernPnzpo+fXqRY8XNzU2zZs0yX2/YsOFSP0KZlNfnLXDy5Endeuut5q2CxowZo3feeUfVqhU9UXDatGnKzc1VQECA1qxZU+zK0XfddZf5HfHtt986/E6xN2jQIA0bNqzI+97e3oXOGnK07wuOwebNm6tt27bFbsPb21s333xzif2A6yGJBK4QISEh5vPTp0+XKdb+D6uCBKWiNGjQoNQ/3soqJCSk0IITF+revbuZtH7zzTc6fvy4U7dfnlatWmU+Hz9+fIkJjH0yYh/nyCOPPFLoZ8iem5ubmQhkZWWVaaEYe/Z9ePrpp4ut5+7urvHjxzuMc0X2f3x9++23Rco/+eQT8/mTTz5ZbDuenp4aOXKkczt3kUr6vnnvvfckSY0bNy712O7cubPq1q0rSdq4cWOhskv9XlqyZIn5fPr06Q7/2VIWvXr1MvvqLN26dSvxNilPPfWU3N3dJanE+yE6S8GxVq1aNTOBdSQwMFCjRo2SJBmGUWrfSvq5vuaaa1S/fn1J0i+//FLWLl+S8vq80vl/GrVr107ff/+9JOnFF1/UnDlzHH5nnzlzRp9//rkk6cEHH1R4eHiJbffv3998fuFxc6GS9n2HDh3MhNbRvi84Bv/3v/+VulAbLj9cEwlcIeyX2i/rPfO6dOmiV155RZJ03333aeLEierdu3eh2YbyEhUVdVH3+CtJ+/bti1zbcaHOnTubvzR3797t9ES2vPz3v/+VdH6Mu3TpUmLdtm3byt/fX+np6Q6TF3uOZm3t2f9Rc+bMGYu9/T+GYWj37t2SpJo1a5Z6Y++uXbuaz0vre2WLj4/XO++8o23btungwYNKTk4udnVZRysh7tmzR9L5ZL1Dhw4lbquiV2QtTnHfNykpKdq3b58kqXbt2oXutVkcf39/SedXe7V3qd9LO3bskCQFBweXul+tKI+zMG677bYSy8PCwtS0aVP9/PPP+u2335SSkqKgoCCn90M6P2uWkJAg6fy9V0u7rrhr16569tlnJZV+jFr5fjly5MhFfbdcrPL8vD/++KO6d++u48ePy93dXfPmzdOgQYOKrb9z507zmHJ3dy/1uMnJyTGfX3jc2PP19VXLli2LLff09FTNmjV1/Phxh/u+S5cu+v7775WUlKSOHTvq6aef1p133unU2XhUXSSRwBXC/qbK1atXL1Nsjx491K9fP33wwQdKTEzUmDFjNGbMGDVq1Eht27ZVhw4ddNddd5XLYiWl/cf1YlxzzTVlqnPs2DGn96G8/PXXX5LO/3EZEBBQYl03NzddffXV+vHHH5WUlKTs7Oxik+vSFrOwXzikuASpJKmpqcrMzJQkS6dkhoaGKigoSCkpKeZnror+/e9/65lnnil038qSpKamFnmv4OcvLCys1IVQGjZsWPZOloPivm+OHDli/jH81VdflXrrDXsX/hF7Kd9LaWlp5r6+9tprnfKPqsr8rvr5559lGIaOHz9ebkmk/XHWuHHjUuvb1yntGLX6/WL1OHKG8vy8HTt2VEpKiry8vLR06VLdc889Jda3v0XM3Llzy3TqckmJd40aNUr92S/Y946+15955hmtWbNGv/zyi3788Uf169dP7u7uuuGGG9SuXTt16tRJ3bp1k4+Pj+X+wnVwOitwBcjLyys0w1HWleMk6f3339eCBQsKnVr1+++/65133tHgwYNVt25d9evXz+l/0JfHLx8rKxLaX/tX2j23qpK0tDRJcnjtoiMFszz2sY5c6ql+pbHfdln7XlK/K9OSJUv0j3/8w/zDt3379po0aZIWLFigpUuX6uOPP9bHH3+st956y4xxdK+5jIwMSWX/ua0sJX3fXMopb/azKwUu9nvJPlm3PwYuxeX+XVXWY9Tqd4tU/t8vF6M8P2/BdeO5ubmW/ul2KcdNdnZ2sWWXut9DQkL0zTff6F//+pdq164t6fzx/9133+nVV1/Vvffeq9q1a2vy5Mkl9gOuqeodtQCc7qeffjJnefz8/Eq8xqY4NptNgwcP1s8//6xDhw7pnXfe0fDhw81Zo7y8PH344Ye65ZZbdOLECaf239kK9kVJCv5wly7tj0z70/oqQsHso33/S2L/R2dpM5flyX7bZe17Zfa7JAWntlWrVk1r167V9u3b9dxzz2nw4MHq06ePoqOjFR0drXbt2pXYTsEfsGX9ua0sJX3f2B9LjzzyiAzDKNPjQhf7vWR/ul1V/idRRX5Xlaasx2hV+W65WOX5eT///HP5+fkpLy9PDz30kJYuXVpifftxXbRoUZmOmW3btpXa90sREBCg6dOn69ixY9q7d69ee+01PfDAA+bsclpamp577jndfffdpd4mB66FJBK4AnzwwQfm87Zt2zpc+a0sGjZsqEceeUSxsbH67bff9N1336lVq1aSzp+uZr+aXlVkv6qjlToXLpZhf+pmaf9dPXXqVBl7d2kKVgg8fvx4qX8cG4ZhLoJTo0aNUq8TLU+BgYHmrIuV8UlMTDT/O+/sxUyc4fDhw4qLi5N0fhXNHj16FFu34Lqr4hR8vuPHj5eaVBSs4lqZSvq+sT/l09H1n5eiLN9LAQEB5mmfv/76a5X947Ys31U2m+2i751rRcF3iyRLq4/a16mKx2hpyvPzduzYUWvXri2USH700UfF1i/P48ZZ3Nzc1KpVKz3++OP66KOPdOLECX388cfm6ewbNmwwFwfC5YEkErjM/fXXX5o/f775evDgwU7fRuvWrc0VF6X/W7DCXsF1F1Xhj7UdO3Y4PDXOXsGS65L0t7/9rVBZcHCw+by06yVLW2DB/nQiZ+ybgmXUDcMo9dYXX3/9tZloVvby6zabzdzPiYmJ+uGHH0qsb7/iYGX33RH7Wa+rr766xLql3bbgpptuknR+Vnv79u0l1i3vWYfSlPZ9U7NmzUIrHzu6BtRZSvteioqKknT++s3S9mtl2bJlS4nlx48fNxdOady4cZHrIZ35/RIaGqoGDRpIkn744YdSbxVV1Y/R0pT35+3QoYPWrVsnf39/5eXlqX///sUmkh06dDB/h5a22mpV4ebmpujoaE2bNs18z9HfBnBdJJHAZSwtLU19+vQxF7lo2rSpevfuXS7bioiIMJ87uk9gwek4VeF0u6SkJL399tvFlm/cuNG8ZUCbNm2K/Hff/p6VJf2RFxcXp88++6zEvtifpuSMfdOrVy/z+ezZs0v8w3HGjBkO4yqLfR9Kms3Oy8srdP/OqtD3C9lfy1bSLU+OHDli3guxOPaLbvznP/8ptl52dnaF3CuwOFa/bwYMGCDp/KmaL730Urn2qaTvJfvbIEyaNKnCTz23Yv369SWurvnqq6+a19Hed999RcrL6/slNzdX//73v4utl5aWpjfffFPS+X8Q3XvvvZe87cpQ3p+3ffv2Wrt2baFE8sMPPyxSLzQ0VN27d5d0PhFzlURSKv1vA7gukkjgMmQYhtatW6ebbrrJ/M9fYGCgli9fflEX0k+bNk2bNm0q8Y+sgl+g0vnl0C8UGRkpSTp48KB58+bKNG7cOPOWEvYOHTpUaKl1R/cGa9CggZo2bSrp/AqTjhLFxMRE3X///aXOeFavXt2cPfjhhx8uebbgzjvvNK9B27lzp8aPH+9w3F544QWz3/Xr19dDDz10Sdt1hkcffdRcSfODDz7Qq6++WqROXl6eHn/8cXOm8m9/+1upt0GoDE2bNjWvZfzkk0/MW6/YO3HihKKjo0tdhOOee+4xj5/169cXSv4L5OXladSoUZZvcu5MZf2+eeyxx8wZnpdeekmzZs0q8bslJSVFr776apGZ9Uv9Xurdu7euu+46Sef/MH/kkUeKPV04Nze3Uk7Fy83N1QMPPOBwFuyzzz4z/5ni6+vr8B6hBT83krR3795L7s/o0aPNBYRmzpyplStXFqlz7tw59e/f3zxLo1evXpZWXK6KKuLztm/fvtCM5MMPP+wwkZw+fbo8PDwkSX379tX69etLbDchIUHjxo3TyZMnLfelrIYNG6aff/652PLc3NxCZyY4+tsArotbfAAuyv4+UYZhKC0tTUlJSfrhhx+0fft283osSapXr54+/PDDi1pQRzo/2zZlyhSFhYWpW7duuuGGGxQWFqb8/HwdO3ZMn376qblUv5eXl8aMGVOkjdtuu0379u1TRkaGevbsqQEDBqhmzZrmKTo333xzmW89crHuuOMObdq0Se3atdOAAQPUvn17ubu7a/fu3Vq4cKF5imevXr2KneUaN26ceaper169NGjQIHXo0EGGYej777/X4sWLlZycrN69e2v58uUl9qdz5876+OOPdejQIT3wwAO67777Cp0y27FjR8srP7q5uen9999X27ZtdfbsWc2ZM0dbt27VQw89pHr16unEiRNatmyZ+ce+h4eH3n33XXl7e1tqvzwFBARo8eLFuvvuu5WXl6cnn3xSH3/8se6//37VqlVLf/75p9577z3zPoMBAQF69913K7nXjnl6emr48OF6+eWXlZOTow4dOmjQoEH629/+Jg8PD+3du9f8GXnkkUdK/BweHh6aP3++unXrpry8PD3zzDNat26devfuXWS/2P+8OXPFS2d+3/j5+Wn16tXq2LGjUlNTNWHCBL311lvq1auXmjVrJn9/f6Wmpurw4cP673//q23btik7O7vQqanSpX8vubu7a/ny5WrTpo2SkpK0ZMkSbdmyRX379tX1118vX19fnTp1Snv37tVnn30mb29v3XnnnU7ao9ZER0dr9erVat68uYYOHaqWLVsqMzNTGzZs0PLly81/Os2YMUP169cvEt+yZUuFhobq5MmTev/991WrVi39/e9/N79PfHx81LFjR8v9iYiI0CuvvKIRI0YoNzdX999/v+655x7dcccdCg4O1u+//65FixaZ1+aGh4cXSuRdTUV93qioKK1fv17du3dXenq6Hn74YUnSgw8+aNZp3bq15s6dq6FDh+rMmTPq0aOH2rVrpx49eigyMlIeHh5KSkrSwYMHtWPHDvP+sk899dSl74hizJ8/X/Pnz1fz5s3VqVMntWjRQtWrV1dGRoYOHz6sjz76yPzHVuPGjXX//feXW19QCQwALkNSmR7BwcHGE088YZw5c8Zy2x07dixSduutt1raXs2aNY0NGzY4bP9///ufUatWrWJjt27datbdunWr+f6UKVMs7ZsBAwaYMXFxcUXKL2zzvffeM7y8vIrtzx133GGcPXu22O3l5+cX2uaFD09PT2P+/PnG4sWLzfcWL17ssK3vv//e8PHxKbYt+89jdd98/fXXRp06dUocr+rVqxvr168vto0pU6Y4HJ9LrVua1atXG0FBQSX2/aqrrjK+++67YtuIi4sz6w4YMOCS+lMc+/F3NLZnz541OnXqVOLnGD58uHHo0CFLff3ggw8Mb2/vYtvq0KGDcerUKfP13XfffUmfrzy/bwzDMA4ePGi0atXKUtteXl7GunXrCsU743vJMAzjt99+M1q2bFlqO5GRkUViL+bnvkGDBoYko0GDBg7LL2zzscceK7ZPNput1O/It956q9j4C/tg9fPMnTu3xJ9FSUaLFi0cfhcX6Nixo1m3NGWpWxb2388lHXsV9Xl37NhhBAQEGJIMd3d3Y8mSJUXqfPrpp0bt2rUt/ezXqFHDSExMLNJGaT+DVuta/W647rrrStw3cE3MRAKXAQ8PDwUGBiowMFARERFq3bq1brnlFt11111OuXfZp59+qi+++EJffvmlvvvuO/3xxx86ffq0bDabqlevrubNm6tHjx4aPHhwoRk0e+Hh4dq7d69mz56tzZs3Kz4+XhkZGZW20E7//v11/fXX69VXX9WWLVt07Ngx+fr66oYbbtDgwYPVr1+/EuNtNpsWL16s7t27a/78+fr++++VmZmpOnXqqHPnznrqqafUsmXLEq+9LHDDDTfou+++08svv6yvvvpKR44csbS0f0natGmj33//XfPmzdMnn3yiX375RcnJyQoMDFTjxo111113adSoUcWOV2W65557dOjQIb355pv6/PPP9ccffyg1NVUhISFq0aKF7rnnHg0dOrTK38Da29tbGzdu1Pz58/Xee+/p559/VnZ2tsLCwnTLLbdo8ODB6tq1a6EbiZfkwQcf1M0336zZs2drw4YNOnbsmAICAtSkSRM9/PDDGjx4cKHVgMtrZt9Z3zfXXnutvvvuO3322WdatWqVdu3apePHjysjI0MBAQFq0KCBrr/+enXu3Fl33323QkJCCsU743tJkho1aqQffvhBy5cv14oVK/Tf//5XiYmJysvLU82aNdW8eXPdfvvtha6hrEivv/667rjjDsXGxuq7777TqVOnVLNmTbVv315PPvmk2rRpU2L8sGHD1KBBA8XGxmrPnj1KTEw07116sUaMGKE777xTb7zxhjZs2KD4+HhlZmaqRo0aatWqlXr37q2HH35Y7u7ul7SdqqKiPm+7du3MGcm0tDQ98sgjklTo91HPnj0VFxend999V2vXrtX333+vU6dOKS8vT0FBQbrmmmt00003qWvXruratWu5rrp99OhRrV+/Xl999ZX27dunuLg4paamytPTU7Vr11arVq10//3364EHHrhsfhbwf2xGZf0FBwAAnOqzzz7T3XffLUl6+eWX9Y9//KOSe4SyiomJ0dSpUyWdXyX61ltvrdwOAYADLKwDAMBl4vXXXzefd+rUqRJ7AgC4nJFEAgDgAr788stiy/Lz8/XMM8+YS//ffPPNuuGGGyqoZwCAKw3XRAIA4AJuu+02RUZGqnv37mrZsqWqV6+uc+fO6cCBA1q+fLm5CqKnp6diY2MrubcAgMsZSSQAAC7ijz/+KHTK6oWqV6+uZcuWqVWrVhXYKwDAlYYkEgAAF7Bu3Tp9+umn2r17t44fP67Tp08rOztb1atXV7NmzdS9e3cNHz5cgYGBld1VAMBljtVZAQAAAACWMRN5hcvPzzfvNWaz2Sq7OwAAAAAqiWEYSktLU926deXmVvwarCSRV7hjx46pfv36ld0NAAAAAFXEkSNHVK9evWLLSSKvcAEBAZLO/6CUx3U0OTk52rhxo7p27SoPDw+nt4/ywbi5JsbNNTFurolxc02Mm+ti7CpGamqq6tevb+YIxSGJvMIVnMIaGBhYbkmkr6+vAgMDOeBdCOPmmhg318S4uSbGzTUxbq6LsatYpV3mVvyJrgAAAAAAXIAkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYFm1yu4AUFESExOVmppabu0HBgaqVq1a5dY+AAAAUBWQROKKkJiYqEEjBin9XHq5bcPf21+LYheRSAIAAOCyRhKJK0JqaqrSz6Xr9sdvV83wmk5v/9TRU/ri9S+UmppKEgkAAIDLmktdE3n69GktXrxY/fv3V7NmzeTn5ycvLy/Vq1dP0dHR+vjjj4uNffvtt2Wz2Up9fPHFFyX24dChQxo+fLgiIyPl7e2tWrVqqVu3blq5cqWlz7B37171799f9erVk5eXl+rUqaN7771XW7ZssRS/detW3XvvvapTp4752fv376+9e/dair/S1QyvqToN6zj9UR6JKQAAAFAVudRMZFhYmHJzc83X3t7e8vDw0NGjR3X06FF98skn6tGjh1asWCFfX1+Hbbi5uZU4U+Tl5VVs2dq1a9W7d29lZmZKOn8NXFJSkjZu3KiNGzdq4MCBWrhwoWw2m8P4BQsWaOTIkeZnCAoK0okTJ7R69WqtXr1aU6ZMUUxMTLHbj4mJ0dSpUyVJNptNgYGBOnr0qJYsWaKlS5dq7ty5GjJkSLHxAAAAAHCpXGomMjc3VzfffLPefPNNHTp0SGfPnlV6erri4uI0ePBgSdK6des0fPjwYtuoX7++jh8/Xuyjffv2DuPi4uLUp08fZWZmql27dvr111+VkpKilJQUTZ48WZK0ePFizZo1y2H8rl27NGLECOXm5io6OlpHjhxRcnKyEhMTzf5OnTpVy5Ytcxi/bNkyM4EcPny4EhMTlZycrCNHjig6Olq5ubkaMWKEdu3aZW1nAgAAAMBFcKkkcsuWLfr22281cuRINWzY0Hw/IiJCCxYsMJOx999/X0eOHHHqtidPnqyMjAyFhYVpzZo1aty4sSTJ399fU6dO1bBhwyRJzz//vM6cOVMkfsKECcrLy1PLli21bNky1atXT5JUo0YNxcbGqlu3bpKkp59+Wnl5eYVi8/LyNGHCBElS9+7dFRsbqxo1akiS6tWrp6VLl6pFixaF6gEAAABAeXCpJLJTp04llhfMRkrSnj17nLbdjIwM85rHkSNHKjg4uEidiRMnSjq/gMvq1asLlR0+fFg7duyQJI0bN04eHh7FxsfHx2v79u2Fyr788kslJCQUqmfP09NT48aNkyTt2LFDcXFxZfh0AAAAAGCdSyWRpfH29jafXzibdyl27Nihs2fPSpJ69OjhsE5ERISaNm0qSdq4cWOhsk2bNpnPu3fv7jA+KipKAQEBJcYHBASoXbt2DuPt+3VhPAAAAAA4y2WVRG7bts183rJlS4d1EhMTdeONN8rf318+Pj5q2LCh+vfvXyj2Qj///LP5vEWLFsXWKyjbv3+/w/jQ0FCFhoY6jHV3d1eTJk1KjG/atKnc3d0dxoeGhpoLBl0YDwAAAADO4lKrs5YkOTlZL774oiSpffv2uvbaax3Wy8zM1N69exUSEqKMjAzFxcUpLi5OS5Ys0cCBAzVv3jxVq1Z4txw7dkySFBISIh8fn2L7EB4eXqj+hfEF5SXF7969+5LiExMTi8Tby8rKUlZWlvk6NTVVkpSTk6OcnJwS278YBW2WR9tlkZeXJ08PT9nybTJyDae3b8u3ydPDU3l5eZX+WZ2hqowbyoZxc02Mm2ti3FwT4+a6GLuKYXX/XhZJZH5+vh5++GH99ddf8vb21uuvv16kTt26dTVlyhTdd999uvbaa+Xl5aW8vDx9++23mjJlir744gstXrxYfn5+eu211wrFpqWlSVKxtw0pUFBeUL+qxNt78cUXzVVe7W3cuLHU9i+F/Sm9lWXUwFFSgs4/nKy2amvUwFE6cOCADhw44PwNVJKqMG4oO8bNNTFurolxc02Mm+ti7MpXwa0MS3NZJJFPPvmk1qxZI0l64403dN111xWp07VrV3Xt2rXQe+7u7mrbtq02bNig++67T5988onefPNNPfHEE2rUqFGF9L2iTZw4UWPGjDFfp6amqn79+uratasCAwOdvr2cnBxt2rRJXbp0cbigUEWJi4vT6Amj1Suml2pH1HZ6+yfiT2hlzEq9NvM1RUZGOr39ilZVxg1lw7i5JsbNNTFurolxc12MXcUoOEuxNC6fRI4bN86ceXzllVc0aNCgMrfh5uam2bNn65NPPlF+fr4+++yzQolWwYI3pWXmBeUF9atKvD0vLy95eXkVed/Dw6NcD8jybr807u7uys7JluFmyFbN5vT2DTdD2TnZcnd3v6y+2Cp73HBxGDfXxLi5JsbNNTFurouxK19W961LL6wzYcIEzZkzR5I0e/ZsPfXUUxfd1jXXXKOaNWtKOn9LDnt169aVJJ05c8ZcpdWRo0ePFqp/YXxBeUXHAwAAAICzuGwSOX78eM2aNUuSNHPmTI0dO7bctmW/Iqv9Sq0XKihr3ry5w/iTJ08qMTHRYWxeXp4OHjxYYvyBAweKvXWJfdsXxgMAAACAs7hkEjlu3DjNnj1b0vkEcvz48Zfc5qFDh3Tq1ClJKnJNW1RUlLkq6/r16x3GJyQkmAuqXHjtZZcuXcznxcXv3LnTXBCnuPi0tDR9/fXXDuPt270wHgAAAACcxeWSyHHjxhU6hdVKAmkYJd/SwTAMsx03Nzfdddddhcr9/PzUq1cvSdLcuXOVkpJSpI0ZM2ZIOn89YnR0dKGyhg0bKioqSpI0Z84ch0vnvvTSS5KkBg0aqEOHDoXKOnbsqAYNGhSqZy8nJ8fcJ1FRUZfFwi4AAAAAqiaXSiLtr4F8+eWXLZ/CmpCQoJtvvllvvfWWDh8+bCaV+fn5+uabb9SjRw99/PHHkqThw4c7vMfktGnT5Ofnp7/++ks9e/bU77//LknKyMjQtGnTFBsbK0maNGmSQkJCisTPmDFD7u7u+vHHH9W3b1/z+sWkpCSNGjVK69atk3R+ZtXd3b1QrLu7u2bOnClJWrt2rUaNGqWkpCRJ56+D7Nu3r/bt21eoHgAAAACUB5dZnfXPP/80r4F0c3PTjBkzzNk/R8aNG6dx48aZr3fv3q3du3dLOr9CaUBAgNLS0pSVlWXWGThwoF599VWH7UVGRmrZsmXq3bu3vvrqKzVu3FhBQUFKT083r1McOHBgsTOjbdu2VWxsrEaOHKlVq1Zp1apVCg4OVkpKipnUTpkyRX369HEY36dPH/3yyy+aOnWq5s6dq9jYWAUFBSk5OVmSVK1aNc2dO1dt2rQpdp8AAAAAwKVymSQyPz+/0PMTJ06UWD89Pd18Xrt2bb322mvatWuXfvjhByUmJurMmTPy9vZWZGSk2rZtq0GDBqldu3YltnnHHXdo3759mjFjhjZt2qS//vpLISEhatWqlYYPH26e8lqcIUOGqHXr1pozZ46+/PJLJSYmKjQ0VG3atNHo0aPVuXPnEuNjYmLUoUMH87OcOXNG4eHh6tixo8aMGaMbb7yxxHgAAAAAuFQuk0RGRESUem1jcXx8fPT444/r8ccfv+R+XH311Zo3b95Fx7du3VpLliy56PjOnTuXmmwCAAAAQHlxqWsiAQAAAACViyQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCsWmV3ALhcZGdlKyEhoVzaDgwMVK1atcqlbQAAAKAsSCIBJ0hLSlPc4ThNemGSvLy8nN6+v7e/FsUuIpEEAABApSOJBJzgXMY5uXm66bZRt6neNfWc2vapo6f0xetfKDU1lSQSAAAAlY4kEnCiGuE1VKdhncruBgAAAFBuWFgHAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALHOZJPL06dNavHix+vfvr2bNmsnPz09eXl6qV6+eoqOj9fHHH5faRlpammJiYtSyZUv5+/srKChIf/vb3zRnzhxlZ2eXGn/ixAmNHTtW1157rXx8fFS9enW1b99eCxYskGEYpcYfOnRIw4cPV2RkpLy9vVWrVi1169ZNK1eutLQP9u7dq/79+6tevXry8vJSnTp1dO+992rLli2W4gEAAADgUrnMfSLDwsKUm5trvvb29paHh4eOHj2qo0eP6pNPPlGPHj20YsUK+fr6FolPSEjQrbfeqvj4eEmSr6+vsrKytGfPHu3Zs0dLlizR5s2bFRIS4nD73333nbp166bTp09Lkvz9/ZWWlqYdO3Zox44dWrFihT799FN5eno6jF+7dq169+6tzMxMSVJgYKCSkpK0ceNGbdy4UQMHDtTChQtls9kcxi9YsEAjR44090FQUJBOnDih1atXa/Xq1ZoyZYpiYmIs7UsAAAAAuFguMxOZm5urm2++WW+++aYOHTqks2fPKj09XXFxcRo8eLAkad26dRo+fLjD2J49eyo+Pl516tTRpk2blJGRoczMTH300UcKCAjQ999/r/79+zvcdkpKiu666y6dPn1aTZo00e7du5WWlqaMjAy9/vrr8vDw0IYNG/TUU085jI+Li1OfPn2UmZmpdu3a6ddff1VKSopSUlI0efJkSdLixYs1a9Ysh/G7du3SiBEjlJubq+joaB05ckTJyclKTEw0P+/UqVO1bNmysu5WAAAAACgTl0kit2zZom+//VYjR45Uw4YNzfcjIiK0YMECM5l6//33deTIkUKx77zzjn766SdJ0sqVK3X77bdLktzc3PTAAw/orbfeknR+tnDz5s1Ftj179mwdP35cPj4+Wrt2rW666SZJkqenpx577DFNnTpVkjRv3jz99ttvReInT56sjIwMhYWFac2aNWrcuLGk87OZU6dO1bBhwyRJzz//vM6cOVMkfsKECcrLy1PLli21bNky1atXT5JUo0YNxcbGqlu3bpKkp59+Wnl5eZb2JwAAAABcDJdJIjt16lRiecFspCTt2bOnUNk777xjttGmTZsisX379lVkZKQk6d133y1SXvCefT17o0ePlr+/v/Ly8rRkyZJCZRkZGeY1jyNHjlRwcHCR+IkTJ0qSUlNTtXr16kJlhw8f1o4dOyRJ48aNk4eHR7Hx8fHx2r59e5FyAAAAAHAWl0kiS+Pt7W0+t5+Ny8zM1M6dOyVJPXr0cBhrs9nUvXt3SdLGjRsLlf3666/6888/S4z39/dX+/btHcbv2LFDZ8+eLTE+IiJCTZs2dRi/adMm83lBHy8UFRWlgIAAh/EAAAAA4EyXTRK5bds283nLli3N5wcOHFB+fr4kqUWLFsXGF5QdP35cSUlJ5vs///xzkTolxf/yyy+F3i9r/P79+x3Gh4aGKjQ01GGsu7u7mjRp4jAeAAAAAJzJZVZnLUlycrJefPFFSVL79u117bXXmmXHjh0zn4eHhxfbhn3ZsWPHVL169YuKT01NVXp6uvz9/QvFh4SEyMfHp9R4++3Zvy5p2wXlu3fvLhJ/oaysLGVlZZmvU1NTJUk5OTnKyckpMfZiFLRZHm2XRV5enjw9PGXLt8nILf12LGXlZrjJ28u7XNq35dvk6eGpvLy8CtuPVWXcUDaMm2ti3FwT4+aaGDfXxdhVDKv71+WTyPz8fD388MP666+/5O3trddff71QeVpamvnc0a0/HJXZx1xsfEESWRBfUqx9uf32nBF/oRdffNFcCMjexo0bS93GpbA/LbeyjBo4SkrQ+YeTNVdzzZk2Rzqp8w8nqq3aGjVwlA4cOKADBw44t/FSVIVxQ9kxbq6JcXNNjJtrYtxcF2NXvgpuR1gal08in3zySa1Zs0aS9MYbb+i6666r5B5VbRMnTtSYMWPM16mpqapfv766du2qwMBAp28vJydHmzZtUpcuXRwuClRR4uLiNHrCaPWK6aXaEbWd3v7+Hfu16F+LNDp2tCKaRji17RPxJ7QyZqVem/maw4WdykNVGTeUDePmmhg318S4uSbGzXUxdhWj4CzF0rh0Ejlu3Dhz5vGVV17RoEGDitQpWHBGKjmzti+zj7kwvrhEq7T40rL6gnL7WGfEX8jLy0teXl5F3vfw8CjXA7K82y+Nu7u7snOyZbgZslWzOb39fFu+zmWdK5f2DTdD2TnZcnd3r/B9WNnjhovDuLkmxs01MW6uiXFzXYxd+bK6b112YZ0JEyZozpw5ks7fx/Gpp55yWK9u3brm86NHjxbbnn2ZfUxZ4wMDA81TWe3jz5w5Y67SWlK8/fbsX5e07ZLiAQAAAMCZXDKJHD9+vGbNmiVJmjlzpsaOHVts3aZNm8rN7fzHtF8p9UIFZWFhYeaiOlLhFVWtxDdr1qzQ+2WNb968ucP4kydPKjEx0WFsXl6eDh486DAeAAAAAJzJ5ZLIcePGafbs2ZLOJ5Djx48vsb6vr6/atWsnSVq/fr3DOoZhaMOGDZKkrl27Fipr3LixrrrqqhLjMzIy9NVXXzmMj4qKMldlLS4+ISHBXDDlwvguXbqYz4uL37lzp7mgzoXxAAAAAOBMLpVEjhs3rtAprKUlkAUGDBggSdq6dau+/fbbIuXLly/X4cOHJUmPPPJIoTKbzWa+99FHHyk+Pr5I/BtvvKH09HS5u7vroYceKlTm5+enXr16SZLmzp2rlJSUIvEzZsyQdP56xujo6EJlDRs2VFRUlCRpzpw5DpfdfemllyRJDRo0UIcOHYqUAwAAAICzuEwSaX8N5Msvv1ziKawXGjBggFq2bCnDMNSrVy9t3rxZ0vnbgyxfvlxDhw6VJPXo0UO33XZbkfhx48YpLCxMmZmZuvPOO/Xdd99JkrKzszV37lw9++yzkqRhw4apcePGReKnTZsmPz8//fXXX+rZs6d+//13SednMKdNm6bY2FhJ0qRJkxQSElIkfsaMGXJ3d9ePP/6ovn37mtc/JiUladSoUVq3bp2k8zOz7u7ulvcLAAAAAJSVS6zO+ueff5rXQLq5uWnGjBnm7J0j48aN07hx48zX1apV06effqpOnTopPj5et99+u3x9fZWfn69z585Jklq1aqUlS5Y4bC8oKEhr1qxRt27d9Msvv+imm25SQECAzp07Z84Mdu3aVa+88orD+MjISC1btky9e/fWV199pcaNGysoKEjp6enKy8uTJA0cOLDYmdW2bdsqNjZWI0eO1KpVq7Rq1SoFBwcrJSVFhnH+xvZTpkxRnz59StqNAAAAAHDJXGImMj8/v9DzEydOlPhIT08v0kZERIT27dunyZMnq0WLFrLZbPLw8NCNN96o2bNn65tvvnE4C1jgxhtv1P79+/WPf/xDjRo1Uk5Ojvz8/BQVFaX58+dr3bp1Dm+dUeCOO+7Qvn37NHToUEVEROjcuXMKCQlRly5dtGLFCi1atEg2W/G3hhgyZIi+/fZb9evXT+Hh4crMzFRoaKiio6O1efNmxcTEWNuZAAAAAHAJXGImMiIiwpxxuxQBAQGaOnWqpk6delHxtWvX1ssvv6yXX375ouKvvvpqzZs376JiJal169bFzpYCAAAAQEVwiZlIAAAAAEDVQBIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwzClJ5LRp03T06FFnNAUAAAAAqMKckkTGxMQoMjJS0dHRWrt2rQzDcEazAAAAAIAqxilJ5FVXXaXc3Fx9+umn6tmzpyIiIvTcc8/p2LFjzmgeAAAAAFBFOCWJjIuL07p163TvvfeqWrVqOnLkiGJiYhQREaHo6GitW7eO2UkAAAAAuAw4JYm02Wzq1q2bVq5cqSNHjuiFF15Qw4YNzdnJu+66S5GRkcxOAgAAAICLc/rqrKGhoXrmmWf0+++/64svvlCfPn3k4eGhP//8k9lJAAAAAHBx5XqLj86dO+ujjz7S0aNHNWfOHDVu3Fi5ubn67LPPzNnJF154QadPny7PbgAAAAAAnKRC7hOZkpKikydP6syZM7LZbDIMQ4Zh6M8//9Szzz6ryMhI/fvf/66IrgAAAAAALkG18mo4NzdXq1at0rx587Rt2zYzcQwLC9OQIUPUu3dvbdy4UbGxsTp06JDGjh0rb29vjRgxory6BAAAAAC4RE6fifz99981fvx4hYeH68EHH9SWLVtkGIY6d+6s5cuX68iRI5o2bZpatmypsWPH6tdff9U///lPGYah1157zdndAQAAAAA4kVNmIrOzs7VixQrNnz9f27dvlyQZhqHq1avr0Ucf1fDhw9WoUSOHsW5ubnruuef02muv6dChQ87oDgAAAACgnDgliaxbt67OnDljrrbapk0bjRgxQn369JGXl1ep8TabTSEhITpy5IgzugMAAAAAKCdOSSKTkpLk7++v/v37a8SIEbruuuvK3MacOXOUnp7ujO4AAAAAAMqJU5LIuXPn6qGHHpK/v/9Ft9GrVy9ndAUAAAAAUI6ckkQOHz7cGc0AAAAAAKo4p63Ompqaaul01PT0dKWmpjprswAAAACACuSUJHLVqlUKCQnRsGHDSq3bv39/hYSE6NNPP3XGpgEAAAAAFcgpSeTy5cslSYMHDy617tChQ2UYhpYtW+aMTQMAAAAAKpBTksjvv/9ebm5uateuXal1O3fuLDc3N+3du9cZmwYAAAAAVCCnJJFHjx5VcHCwvL29S63r4+Oj4OBgHT161BmbBgAAAABUIKeszmqz2ZSZmWm5/tmzZ2Wz2ZyxaQAAAABABXLKTGT9+vV17tw5/fTTT6XW/fHHH3X27FmFh4c7Y9MAAAAAgArklCTy1ltvlWEYmjJlSql1Y2JiZLPZ1KlTJ2dsGgAAAABQgZySRI4ePVpubm765JNP1L9/f504caJInRMnTqhfv3765JNP5ObmpieeeMIZmwYAAAAAVCCnXBPZpEkTPf/885o4caI+/PBDrVixQjfeeKMaNGggSUpISNCePXuUm5srSZo+fbqaNWvmjE0DAAAAACqQU2YiJenpp5/WG2+8IX9/f2VnZ2vXrl1aunSpli5dql27diknJ0cBAQGKjY3V008/fVHbyMzM1Lp16zR9+nTdd999atCggWw2m2w2m2JiYkqMLTiNtrTHH3/8UWI7e/fuVf/+/VWvXj15eXmpTp06uvfee7VlyxZLn2Hr1q269957VadOHXl5ealevXrq37+/5VuerFq1St26dVNoaKi8vb0VGRmp4cOHl9pvAAAAAHAGp8xEFhg5cqQefPBBrVixQl9//bWOHz8um82msLAwtW3bVr1791ZgYOBFt//f//5Xd9xxxyX10cPDQ9WrVy+2vFq14nfJggULNHLkSHNGNSgoSCdOnNDq1au1evVqTZkypcRkNiYmRlOnTpV0fkXbwMBAHT16VEuWLNHSpUs1d+5cDRkyxGGsYRgaPHiwFi9eLElyc3OTv7+/4uPjNW/ePL3//vtavnz5Je8fAAAAACiJ02YiCwQHB2vIkCFatGiR1q5dq88//1wLFy7U4MGDLymBLBASEqLbbrtN48eP14cffqiwsLAyxbdt21bHjx8v9hEREeEwbteuXRoxYoRyc3MVHR2tI0eOKDk5WYmJiRo+fLgkaerUqVq2bJnD+GXLlpkJ5PDhw5WYmKjk5GQdOXJE0dHRys3N1YgRI7Rr1y6H8bNmzTITyClTpiglJUUpKSk6ePCg2rZtq8zMTPXp00dxcXFl2h8AAAAAUBZOTyLLU/v27ZWUlKQvvvhCM2fOVN++feXl5VUh254wYYLy8vLUsmVLLVu2TPXq1ZMk1ahRQ7GxserWrZuk86f15uXlFYrNy8vThAkTJEndu3dXbGysatSoIUmqV6+eli5dqhYtWhSqZ+/MmTOaPn26pPMJaExMjPz9/SVJ1157rdasWaOwsDBlZGRo8uTJ5bMDAAAAAEAulkS6u7tXynYPHz6sHTt2SJLGjRsnDw+PInUmTpwoSYqPj9f27dsLlX355ZdKSEgoVM+ep6enxo0bJ0nasWNHkdnEjz/+WGlpacXGh4SEaMSIEZKklStXKiMjo0yfDwAAAACscuo1kYcOHdKyZcu0b98+JSUlKScnp9i6NptNmzdvdubmy82mTZvM5927d3dYJyoqSgEBAUpLS9PGjRsL3QezID4gIEDt2rVzGN+jRw/z+caNG81TZO3jmzVrZq546yg+JiZGZ8+e1Y4dO8yZUQAAAABwJqclkVOnTtX06dOVn58vwzBKrW+z2Zy16TLZv3+/WrRoocOHD8vNzU3h4eHq0KGDRo0apVatWjmM+fnnnyVJoaGhCg0NdVjH3d1dTZo00e7du7V//36H8U2bNi12NjU0NFS1atVSYmJisfEtWrQo9nPZl+3fv58kEgAAAEC5cEoSuWTJEnPRmLp166pbt26qW7duiSudVpZTp04pKSlJwcHBSk1N1W+//abffvtNCxcu1D//+U/z2kN7x44dkySFh4eX2HZ4eLh2795t1r+Y+MTExIuK9/X1VXBwsJKTk4vE28vKylJWVpb5OjU1VZKUk5NT4szxxSposzzaLou8vDx5enjKlm+TkVv6PznKys1wk7eXd7m0b8u3ydPDU3l5eRW2H6vKuKFsGDfXxLi5JsbNNTFurouxqxhW969Tsrw33nhDknT33Xdr2bJl8vT0dEazTtWoUSPNnDlT99xzjyIjI+Xh4aHs7Gxt27ZN//znP/Xdd9/p+eefV0hIiMaOHVsotuB6RF9f3xK3UVBeUL8y4pOTk4vE23vxxRfNhN/exo0bS23/UtifElxZRg0cJSXo/MPJmqu55kybI53U+YcT1VZtjRo4SgcOHNCBAwec23gpqsK4oewYN9fEuLkmxs01MW6ui7ErX5mZmZbqOSWJ/Pnnn2Wz2fTmm29WyQRSkh566KEi73l6eqpr167q0KGDOnTooN27dysmJkZDhgxRUFBQJfSy/E2cOFFjxowxX6empqp+/frq2rWrU27BcqGcnBxt2rRJXbp0cbggUUWJi4vT6Amj1Suml2pH1HZ6+/t37Neify3S6NjRimga4dS2T8Sf0MqYlXpt5muKjIx0atvFqSrjhrJh3FwT4+aaGDfXxLi5LsauYhScpVgapySRNptNgYGBqlu3rjOaq3De3t564YUX1KVLF6Wnp2vz5s267777zPKAgABJpWfmBeUF9Z0Zn5SUdNHx9ry8vBzeFsXDw6NcD8jybr807u7uys7JluFmyFbN+dfj5tvydS7rXLm0b7gZys7Jlru7e4Xvw8oeN1wcxs01MW6uiXFzTYyb62LsypfVfeuUW3w0adJEmZmZha61czVt2rQxnx8+fLhQWUFyfPTo0RLbKCi/MJmuiPjMzEwlJyc7jAcAAAAAZ3FKEjlkyBDl5ORo+fLlzmiuyilY+fTkyZNKTEx0WCcvL08HDx6UJDVv3txh/IEDB5SXl+cw3r7t4uILVml1xL7swngAAAAAcBanJJFDhw7V3XffrSeeeELbt293RpMV7ptvvjGfX3jdWZcuXczn69evdxi/c+dOc0Gbrl27OoxPS0vT119/7TDevt3i4g8cOKA///yzxHgfHx9FRUU5rAMAAAAAl8op10ROmzZN119/vb766it16tRJ7dq10y233FLitXmSNHnyZGdsvlSGYZR4X8qsrCz961//kiT5+fnptttuK1TesGFDRUVFaceOHZozZ4769u1b5Hzhl156SZLUoEEDdejQoVBZx44d1aBBAyUkJOill15S+/btC5Xn5ORozpw5kqSoqKgiSey9996rp556SmlpaXrppZf05ptvFipPTk5WbGysJKlXr17y8/MrcX8AAAAAwMVyShIZExNjJmmGYWjHjh3auXNnqXEXk0SeOXOm0Cmh+fn5ks5fE3jq1CnzfW9vb/n7+0uStm/frueee04DBgxQp06dVK9ePUnnk7ft27dr4sSJ2r17t9mn4ODgItudMWOGOnTooB9//FF9+/bVq6++qvDwcCUlJWnSpElat26dJGnmzJlyd3cvFOvu7q6ZM2fqgQce0Nq1azVq1ChNnz5d1atX19GjR/XEE09o3759Zr0LhYSEaNKkSXr66acVGxursLAwjR07Vn5+fvrtt980ePBg/fXXX/Lz89O0adPKvE8BAAAAwCqnJJEdOnQocabPmVq1aqWEhKI3+ps1a5ZmzZplvh4wYIDefvttSecT282bN2vz5s2Szp/y6efnp5SUFPOGmm5ubnrmmWc0YcIEh9tt27atYmNjNXLkSK1atUqrVq1ScHCwUlJSZBjnby4/ZcoU9enTx2F8nz599Msvv2jq1KmaO3euYmNjFRQUZC6GU61aNc2dO7fQAj/2xo8fr4MHD2rx4sWaMmWKpk2bJn9/f6WkpEg6f4/IZcuWVdgtIAAAAABcmZySRG7bts0ZzZSbli1bavbs2dq1a5d++uknnTp1SsnJyfL19VWzZs3Uvn17DRs2TC1btiyxnSFDhqh169aaM2eOvvzySyUmJio0NFRt2rTR6NGj1blz5xLjY2Ji1KFDB7322mvatWuXzpw5o/DwcHXs2FFjxozRjTfeWGyszWbTokWLdOedd+qtt97S999/r7S0NDVo0EBdu3bVhAkTdM0111zU/gEAAAAAq5ySRFak+Pj4MsfUqFFDY8eOdcr2W7durSVLllx0fOfOnUtNNkvSq1cv9erV66LjAQAAAOBSOGV1VgAAAADAlcHpM5H79u3Thg0blJCQoLNnz2rhwoVmWU5OjhITE2Wz2VSnTh1nbxoAAAAAUM6clkSmpKRo0KBBWr16taT/u63GhUnk9ddfrzNnzujHH39U8+bNnbV5AAAAAEAFcMrprDk5OerRo4dWr14tX19f3XnnnfL29i5Sz9fXVwMHDlR+fr5WrFjhjE0DAAAAACqQU5LIhQsX6ptvvlHDhg3166+/6tNPP1VQUJDDugWLwmzfvt0ZmwYAAAAAVCCnJJEffvihbDabXnnlFdWtW7fEuq1atZKbm5sOHjzojE0DAAAAACqQU5LIn376STabTV27di21rqenp4KCgnT69GlnbBoAAAAAUIGckkRmZmYqICBAnp6elurn5OSoWjWXu0UlAAAAAFzxnJJE1qxZU6mpqUpPTy+1blxcnNLT00s97RUAAAAAUPU4JYm85ZZbJEmff/55qXVfe+01SVL79u2dsWkAAAAAQAVyShI5aNAgGYahZ599VseOHSu23ltvvaX//Oc/stlsGjZsmDM2DQAAAACoQE65MPHOO+9Ur169tHLlSt10003q16+fzp49K0maN2+eEhIStGbNGv38888yDENDhw41Zy8BAAAAAK7DaavbvPfee/L29taSJUv0yiuvmO+PHDlSkmQYhqTzs5ZvvPGGszYLAAAAAKhATjmdVZK8vb313nvvafv27Xr44Yd19dVXy8fHR56enrrqqqvUr18/bdu2TQsWLGBlVgAAAABwUU7P5qKiohQVFeXsZgEAAAAAVYDTZiIBAAAAAJc/kkgAAAAAgGVOOZ313Xffvai4Rx55xBmbBwAAAABUEKckkY8++qhsNluZYmw2G0kkAAAAALgYpySRV111VYlJZEpKipKTkyVJfn5+qlmzpjM2CwAAAACoYE5JIuPj40ut8/vvv2v69Olavny5ZsyYoT59+jhj0wAAAACAClRhN2xs1KiR3nnnHXl4eOiRRx5R48aNdcMNN1TU5gEAAAAATlDhq7PGxMQoOztbL774YkVvGgAAAABwiSo8iaxXr56Cg4P15ZdfVvSmAQAAAACXqMJOZy1w7tw5paamysPDo6I3DQAAAAC4RBU+E7l48WLl5+crPDy8ojcNAAAAALhETpmJ/PPPP0ssP3funI4cOaKVK1dq0aJFstlsuvfee52xaQAAAABABXJKEhkZGWm5rmEYat68uSZNmuSMTQMAAAAAKpBTTmc1DMPSo2HDhpo0aZK++eYbBQUFOWPTAAAAAIAK5JSZyLi4uJI3Uq2aQkJC5Ovr64zNAQAAAAAqiVOSyAYNGjijGQAAAABAFVfhq7MCAAAAAFwXSSQAAAAAwDKnnM46bdo0ZzQjSZo8ebLT2gIAAAAAOJdTksiYmBjZbDZnNEUSCQAAAABVmFOSyA4dOshms+mHH35QSkqKJCk8PFz16tWTJB09elT/+9//JEnBwcG6/vrrnbFZAAAAAEAFc0oSuW3bNk2cOFFffvmlHnzwQcXExKhRo0aF6vzxxx+aOnWqlixZojZt2uiFF15wxqYBAAAAABXIKUnkypUrNXPmTI0aNUqvv/66wzrXXHON3nvvPQUFBWnGjBm66aabdN999zlj8wAAAACACuKU1Vlff/112Ww2xcTElFq3oE5xySYAAAAAoOpyShK5b98+BQUFqWbNmqXWrVmzpoKDg/Xjjz86Y9MAAAAAgArklCQyKytLqampSk9PL7Vuenq6UlNTlZWV5YxNAwAAAAAqkFOSyGuvvVb5+fmWTlF9/fXXlZeXp2uvvdYZmwYAAAAAVCCnJJGPPvqoDMPQpEmTNHXqVIczkpmZmZo2bZomTZokm82mgQMHOmPTAAAAAIAK5JTVWR977DF9/vnn2rhxo6ZNm6ZZs2bppptuUnh4uKTz94ncs2ePzp49K8Mw1KVLF40aNcoZmwYAAAAAVCCnJJFubm769NNP9cwzz+j1119XZmamtm/fLpvNJkkyDEOS5O7urscee0wzZsyQm5tTJkEBAAAAABXIKUmkJHl6eurll1/W+PHjtWLFCu3Zs0cnT56UJIWGhuqmm25Sr169VLduXWdtEgAAAABQwZyWRBaoU6eORo8e7exmAQAAAABVAOeUAgAAAAAsc/pM5KlTp7R161YlJCQoMzNTkydPdvYmAAAAAACVxGlJZG5urp5++mm9+eabys7ONt+3TyLPnDmjhg0b6uzZszp48KAiIiKctXkAAAAAQAVw2umsvXv31r///W9lZ2erefPmqlataH4aEhKifv36KTs7W8uWLXPWpgEAAAAAFcQpSeRHH32kTz75RKGhodqzZ4/27dun6tWrO6zbu3dvSdLWrVudsWkAAAAAQAVyShK5ePFi2Ww2zZo1S61atSqx7s033yybzaZffvnFGZsGAAAAAFQgpySR33//vSSpV69epdb19fVVUFCQeQ9JAAAAAIDrcEoSmZKSoqCgIPn4+Fiqn5+fL5vN5oxNAwAAAAAqkFOSyJCQEKWkpOjcuXOl1v3rr7+Umpqq2rVrO2PTAAAAAIAK5JQksnXr1pKsLZazaNEiSVKbNm2csWkAAAAAQAVyShL50EMPyTAMPfvss0pPTy+23vr16/Xcc8/JZrNpwIABztg0AAAAAKACFb2Z40Xo16+f5s2bp6+++kp///vfNWLECGVnZ0uSNm3apPj4eH322Wdau3at8vPz1bNnT3Xr1s0ZmwYAAAAAVCCnJJE2m02rV6/Wvffeq+3bt+vJJ580y7p3724+NwxDt99+u5YsWeKMzQIAAAAAKphTTmeVzi+us2XLFr3zzjtq3769PD09ZRiGDMOQu7u72rRpo7ffflvr16+Xv7+/szYLAAAAAKhATpmJLODm5qaHH35YDz/8sPLz85WUlKS8vDzVqFFD1ao5dVMAAAAAgErglJnIyMhIXX311frjjz/+r2E3N9WsWVO1a9cmgQQAAACAy4RTsru//vpLnp6euuaaa5zRHAAAAACginLKTGTdunVlGIYzmgIAAAAAVGFOSSJvv/12ZWZm6vvvv3dGcwAAAACAKsopSeQzzzwjPz8/Pf7448rMzHRGkwAAAACAKsgpSWS1atX01ltv6aefflKLFi30yiuv6Ntvv1VcXJz+/PPPYh9lkZmZqXXr1mn69Om677771KBBA9lsNtlsNsXExFhq48SJExo7dqyuvfZa+fj4qHr16mrfvr0WLFhg6XTcQ4cOafjw4YqMjJS3t7dq1aqlbt26aeXKlZa2v3fvXvXv31/16tWTl5eX6tSpo3vvvVdbtmyxFL9161bde++9qlOnjry8vFSvXj31799fe/futRQPAAAAAJfKKQvrREZGms8zMjI0bty4UmNsNptyc3Mtb+O///2v7rjjjovqnyR999136tatm06fPi1J8vf3V1pamnbs2KEdO3ZoxYoV+vTTT+Xp6ekwfu3aterdu7c50xoYGKikpCRt3LhRGzdu1MCBA7Vw4ULZbDaH8QsWLNDIkSPNzxwUFKQTJ05o9erVWr16taZMmVJiMhwTE6OpU6dKOr/vAgMDdfToUS1ZskRLly7V3LlzNWTIkIvdPQAAAABgiVNmIg3DKPMjPz+/zNsJCQnRbbfdpvHjx+vDDz9UWFiYpbiUlBTdddddOn36tJo0aaLdu3crLS1NGRkZev311+Xh4aENGzboqaeechgfFxenPn36KDMzU+3atdOvv/6qlJQUpaSkaPLkyZKkxYsXa9asWQ7jd+3apREjRig3N1fR0dE6cuSIkpOTlZiYqOHDh0uSpk6dqmXLljmMX7ZsmZlADh8+XImJiUpOTtaRI0cUHR2t3NxcjRgxQrt27bK0PwAAAADgYjllJjIuLs4ZzZSoffv2SkpKKvTeM888Yyl29uzZOn78uHx8fLR27Vpz5tTT01OPPfaYUlNT9c9//lPz5s3TU089pcaNGxeKnzx5sjIyMhQWFqY1a9YoODhY0vnZzKlTp+r48eOaN2+enn/+eQ0dOlQhISGF4idMmKC8vDy1bNlSy5Ytk4eHhySpRo0aio2NVXx8vDZs2KCnn35avXr1kru7uxmbl5enCRMmSJK6d++u2NhYs6xevXpaunSpbrzxRv3888+aMGGCvvrqK0v7BAAAAAAuxkXNRLq5uSk8PNx83aBBA/ORmZmplJSUQu8V9ygL+8SqrN59911JUt++fQudeltg9OjR8vf3V15enpYsWVKoLCMjw7zmceTIkWYCaW/ixImSpNTUVK1evbpQ2eHDh7Vjxw5J0rhx48wE0lF8fHy8tm/fXqjsyy+/VEJCQqF69jw9Pc3Th3fs2FEhCT0AAACAK9dFn85a3EI0nTt3VuvWrS+6Q87266+/mov49OjRw2Edf39/tW/fXpK0cePGQmU7duzQ2bNnS4yPiIhQ06ZNHcZv2rTJfN69e3eH8VFRUQoICCgxPiAgQO3atXMYb9+vC+MBAAAAwJmcck3khaysdFpRfv75Z/N5ixYtiq1XUPbLL79cUvz+/fsdxoeGhio0NNRhrLu7u5o0aVJifNOmTYudjQ0NDVWtWrUcxgMAAACAMznlmsiq7NixY+Zz+1NwL1RQlpqaqvT0dPn7+xeKDwkJkY+PT6nx9tuzf13StgvKd+/efUnxiYmJReIvlJWVpaysLPN1amqqJCknJ0c5OTklxl6MgjbLo+2yyMvLk6eHp2z5Nhm5zv8nh5vhJm8v73Jp35Zvk6eHp/Ly8ipsP1aVcUPZMG6uiXFzTYyba2LcXBdjVzGs7t/LPolMS0szn/v6+hZbz74sLS3NTCIL4kuKtS+3315ViL/Qiy++aK70am/jxo2lbuNS2J/WW1lGDRwlJej8w8maq7nmTJsjndT5hxPVVm2NGjhKBw4c0IEDB5zbeCmqwrih7Bg318S4uSbGzTUxbq6LsStfBbczLM1ln0SisIkTJ2rMmDHm69TUVNWvX19du3ZVYGCg07eXk5OjTZs2qUuXLg4XFaoocXFxGj1htHrF9FLtiNpOb3//jv1a9K9FGh07WhFNI5za9on4E1oZs1KvzXzN4cJQ5aGqjBvKhnFzTYyba2LcXBPj5roYu4pRcJZiaS77JLJgwRrpfGZdXKJkn3XbxxQ8Ly0rLyi3j60K8Rfy8vKSl5dXkfc9PDzK9YAs7/ZL4+7uruycbBluhmzVbE5vP9+Wr3NZ58qlfcPNUHZOttzd3St8H1b2uOHiMG6uiXFzTYyba2LcXBdjV76s7ttyWVinKqlbt675/OjRo8XWKygLDAw0T2W1jz9z5oy5SmtJ8fbbs39d0rbLMx4AAAAAnOmik8gTJ07I3d29yOPkyfMXhDkqs39Uq1Yxk6D2K6rar7R6oYKyZs2aXVJ88+bNHcafPHlSiYmJDmPz8vJ08ODBEuMPHDigvLw8h/H2bV8YDwAAAADOdEn3ibzUR0Vo3LixrrrqKknS+vXrHdbJyMjQV199JUnq2rVrobKoqChzVdbi4hMSEswFTy6M79Kli/m8uPidO3eaC+IUF5+Wlqavv/7aYbx9uxfGAwAAAIAzXdR04JQpU5zdj3Jjs9n0yCOPaPr06froo4/07LPPKiIiolCdN954Q+np6XJ3d9dDDz1UqMzPz0+9evXS+++/r7lz5+qJJ55QUFBQoTozZsyQdP56xOjo6EJlDRs2VFRUlHbs2KE5c+aob9++Rc41fumllyRJDRo0UIcOHQqVdezYUQ0aNFBCQoJeeukltW/fvlB5Tk6O5syZI+l8wltRC68AAAAAuDK5VBJ55syZQqd05ufnSzq/qMypU6fM9729vQtd1zhu3DgtWLBAx48f15133ql3331XN954o7Kzs7Vw4UI9++yzkqRhw4apcePGRbY7bdo0ffzxx/rrr7/Us2dPLVy4UI0aNVJGRobmzJmj2NhYSdKkSZMUEhJSJH7GjBnq0KGDfvzxR/Xt21evvvqqwsPDlZSUpEmTJmndunWSpJkzZ8rd3b1QrLu7u2bOnKkHHnhAa9eu1ahRozR9+nRVr15dR48e1RNPPKF9+/aZ9QAAAACgPLnUwjqtWrVSrVq1zMeRI0ckSbNmzSr0/uOPP14oLigoSGvWrFGNGjX0yy+/6KabbjIX0Bk1apSys7PVtWtXvfLKKw63GxkZqWXLlsnX11dfffWVGjdurODgYAUFBWnKlCkyDEMDBw7U+PHjHca3bdtWsbGxqlatmlatWqV69eopJCRENWvW1Ny5cyWdT8z79OnjML5Pnz5m4j537lzVrFlTISEhqlevnlatWqVq1aopNjZWbdq0uaj9CgAAAABWuVQSeSluvPFG7d+/X//4xz/UqFEj5eTkyM/PT1FRUZo/f77WrVvn8NYXBe644w7t27dPQ4cOVUREhM6dO6eQkBB16dJFK1as0KJFi2SzFX9rhyFDhujbb79Vv379FB4erszMTIWGhio6OlqbN29WTExMif2PiYnR5s2bFR0drdDQUGVmZio8PFz9+vXTN998oyFDhlzsrgEAAAAAy1zqPpHx8fGXFF+7dm29/PLLevnlly8q/uqrr9a8efMuevutW7fWkiVLLjq+c+fO6ty580XHu4LExETLNzkti4SEBOXm5jq9XQAAAOBK41JJJC5viYmJGjRikNLPpTu97bMZZ3XsxDFlZ2c7vW0AAADgSkISiSojNTVV6efSdfvjt6tmeE2ntv3rnl+1bOayYu+1CQAAAMAakkhUOTXDa6pOwzpObTPxSKJT2wMAAACuVFfMwjoAAAAAgEtHEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLqlV2BwCULjsrWwkJCeXWfmBgoGrVqlVu7QMAAODyQRIJVHFpSWmKOxynSS9MkpeXV7lsw9/bX4tiF5FIAgAAoFRXVBL59ttva+DAgaXW27Rpk26//XaHZYcOHdLMmTO1ceNG/fXXXwoICFDr1q01bNgw9erVq9S29+7dq5dfflnbtm1TYmKiqlevrr///e8aPXq0OnfuXGr81q1b9eqrr+qbb75RUlKSatWqpVtvvVVjxoxR69atS42H6zmXcU5unm66bdRtqndNPae3f+roKX3x+hdKTU0liQQAAECprqgksoCbm1uJfywXN9uzdu1a9e7dW5mZmZLOnwKYlJSkjRs3auPGjRo4cKAWLlwom83mMH7BggUaOXKkcnNzJUlBQUE6ceKEVq9erdWrV2vKlCmKiYkptl8xMTGaOnWqJMlmsykwMFBHjx7VkiVLtHTpUs2dO1dDhgyxsgvggmqE11CdhnUquxsAAAC4wl2RC+vUr19fx48fL/bRvn37IjFxcXHq06ePMjMz1a5dO/36669KSUlRSkqKJk+eLElavHixZs2a5XCbu3bt0ogRI5Sbm6vo6GgdOXJEycnJSkxM1PDhwyVJU6dO1bJlyxzGL1u2zEwghw8frsTERCUnJ+vIkSOKjo5Wbm6uRowYoV27djljFwEAAACAQ1dkEnkxJk+erIyMDIWFhWnNmjVq3LixJMnf319Tp07VsGHDJEnPP/+8zpw5UyR+woQJysvLU8uWLbVs2TLVq3f+tMQaNWooNjZW3bp1kyQ9/fTTysvLKxSbl5enCRMmSJK6d++u2NhY1ahRQ5JUr149LV26VC1atChUDwAAAADKA0mkBRkZGVq5cqUkaeTIkQoODi5SZ+LEiZKk1NRUrV69ulDZ4cOHtWPHDknSuHHj5OHhUWx8fHy8tm/fXqjsyy+/NFfmLKhnz9PTU+PGjZMk7dixQ3FxcWX4dAAAAABgHUmkBTt27NDZs2clST169HBYJyIiQk2bNpUkbdy4sVDZpk2bzOfdu3d3GB8VFaWAgIAS4wMCAtSuXTuH8fb9ujAeAAAAAJzlikwiExMTdeONN8rf318+Pj5q2LCh+vfvr23btjms//PPP5vPW7RoUWy7BWX79+93GB8aGqrQ0FCHse7u7mrSpEmJ8U2bNpW7u7vD+NDQUHOxoAvjAQAAAMBZrsjVWTMzM7V3716FhIQoIyNDcXFxiouL05IlSzRw4EDNmzdP1ar93645duyYJCkkJEQ+Pj7FthseHl6o/oXxBeUlxe/evfuS4hMTE4vE28vKylJWVpb5OjU1VZKUk5OjnJycEtu/GAVtWmk7Ly9Pnh6esuXbZOQaTu2Hm+Emby/vcmm7vNsv777b8m3y9PBUXl5ekfEqj58JlB/GzTUxbq6JcXNNjJvrYuwqhtX9e0UlkXXr1tWUKVN033336dprr5WXl5fy8vL07bffasqUKfriiy+0ePFi+fn56bXXXjPj0tLSJEm+vr4ltl9QXlC/qsTbe/HFF81VXu1t3Lix1PYvhf0pvSUZNXCUlKDzDydqruaaM22OdFLnH05Wnu2Xd99rq7ZGDRylAwcO6MCBA4XKrI4bqhbGzTUxbq6JcXNNjJvrYuzKV8GtDEtzRSWRXbt2VdeuXQu95+7urrZt22rDhg2677779Mknn+jNN9/UE088oUaNGlVST8vPxIkTNWbMGPN1amqq6tevr65duyowMNDp28vJydGmTZvUpUsXhwsK2YuLi9PoCaPVK6aXakfUdmo/9u/Yr0X/WqTRsaMV0TTCqW2Xd/vl3fcT8Se0MmalXpv5miIjIyWVbdxQdTBurolxc02Mm2ti3FwXY1cxCs5SLM0VlUSWxM3NTbNnz9Ynn3yi/Px8ffbZZ2ayVbDgTWmZeUF5Qf0ClR1vz8vLS15eXkXe9/DwKNcD0kr77u7uys7JluFmyFbN5tTt59vydS7rXLm0Xd7tl3ffDTdD2TnZcnd3LzJG5f1zgfLBuLkmxs01MW6uiXFzXYxd+bK6b6/IhXWKc80116hmzZqSzt+Wo0DdunUlSWfOnDFXaXXk6NGjhepfGF9QXtHxAAAAAOAsJJEW2K/Iar9S64UKypo3b+4w/uTJk0pMTHQYm5eXp4MHD5YYf+DAAeXl5TmMt2/7wngAAAAAcBaSSDuHDh3SqVOnJMm8Nkw6fw/HglVZ169f7zA2ISHBXJTkwusuu3TpYj4vLn7nzp3mgjjFxaelpenrr792GG/f7oXxAAAAAOAsV0wSaRgl3xrBMAyNHz9e0vnrI++66y6zzM/PT7169ZIkzZ07VykpKUXiZ8yYIen89YjR0dGFyho2bKioqChJ0pw5cxwunfvSSy9Jkho0aKAOHToUKuvYsaMaNGhQqJ69nJwczZkzR9L5hNc+AQYAAAAAZ7piksiEhATdfPPNeuutt3T48GEzqczPz9c333yjHj166OOPP5YkDR8+XNdee22h+GnTpsnPz09//fWXevbsqd9//12SlJGRoWnTpik2NlaSNGnSJIWEhBTZ/owZM+Tu7q4ff/xRffv2Na9fTEpK0qhRo7Ru3TpJ0syZM+Xu7l4o1t3dXTNnzpQkrV27VqNGjVJSUpKk89dB9u3bV/v27StUDwAAAADKwxW1Ouvu3bu1e/duSedXKQ0ICFBaWpqysrLMOgMHDtSrr75aJDYyMlLLli1T79699dVXX6lx48YKCgpSenq6eZ3iwIEDzdnMC7Vt21axsbEaOXKkVq1apVWrVik4OFgpKSlmQjtlyhT16dPHYXyfPn30yy+/aOrUqZo7d65iY2MVFBSk5ORkSVK1atU0d+5ctWnT5qL3DwAAAACU5oqZiaxdu7Zee+019evXT82aNVNgYKCSk5Pl4eGhJk2aaNCgQdqxY4cWLVqkatUc59Z33HGH9u3bp6FDhyoiIkLnzp1TSEiIunTpohUrVmjRokWy2Yq/BcOQIUP07bffql+/fgoPD1dmZqZCQ0MVHR2tzZs3KyYmpsTPEBMTo82bNys6OlqhoaHKzMxUeHi4+vXrp2+++UZDhgy5lF0EAAAAAKW6YmYifXx89Pjjj+vxxx+/pHauvvpqzZs376LjW7durSVLllx0fOfOndW5c+eLjgcAAACAS3HFzEQCAAAAAC4dSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgGUkkAAAAAMAykkgAAAAAgGUkkQAAAAAAy0giAQAAAACWkUQCAAAAACwjiQQAAAAAWEYSCQAAAACwjCQSAAAAAGAZSSQAAAAAwDKSSAAAAACAZSSRAAAAAADLSCIBAAAAAJaRRAIAAAAALCOJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgAAAABgWbXK7gCAypedla2EhATzdV5eniQpLi5O7u7ul9R2YGCgatWqdUltAAAAoOogiQSucGlJaYo7HKdJL0ySl5eXJMnTw1OjBo7S6AmjlZ2TfUnt+3v7a1HsIhJJAACAywRJpItJS0vTnDlztHLlSnOWqHHjxurbt69Gjx4tT0/Pyu4iXMy5jHNy83TTbaNuU71r6kmSbPk2KUHqFdNLhptx0W2fOnpKX7z+hVJTU0kiAQAALhMkkS4kISFBt956q+Lj4yVJvr6+ysrK0p49e7Rnzx4tWbJEmzdvVkhISOV2FC6pRngN1WlYR5Jk5BpSglQ7orZs1WyV3DMAAABUJSys4yJyc3PVs2dPxcfHq06dOtq0aZMyMjKUmZmpjz76SAEBAfr+++/Vv3//yu4qAAAAgMsYSaSLeOedd/TTTz9JklauXKnbb79dkuTm5qYHHnhAb731liRp7dq12rx5c6X1EwAAAMDljSTSRbzzzjuSpE6dOqlNmzZFyvv27avIyEhJ0rvvvluhfQMAAABw5eCaSBeQmZmpnTt3SpJ69OjhsI7NZlP37t01d+5cbdy4sSK7B5TowtuHOBu3EAEAAKhYJJEu4MCBA8rPz5cktWjRoth6BWXHjx9XUlKSqlevXiH9A4rj6PYhzsYtRAAAACoWSaQLOHbsmPk8PDy82Hr2ZceOHXOYRGZlZSkrK8t8nZKSIklKSkpSTk6OM7pbSE5OjjIzM3X69Gl5eHiUWDclJUVuctOx347pXOo5p/bjZMJJeVbz1PHfj8uW4/zVRsuz/crouy3fplqZtZS4L/GSbvHx5y9/ytvXW9f1uE416tZwVpdNaafT9MMnP2jXrl2qV6+e09t3NXl5ecrMzNQPP/wgd3f3yu4OLGLcXBPj5poYN9d1uY9dUFCQgoODK7sbSktLkyQZRsl//9mM0mqg0n3wwQd66KGHJEm///67rrnmGof1Nm3apK5du0qSvv76a4fXTsbExGjq1Knl11kAAAAALu3IkSMl/oOemcgrzMSJEzVmzBjzdX5+vpKSklSjRg3ZbM6f5UpNTVX9+vV15MgRBQYGOr19lA/GzTUxbq6JcXNNjJtrYtxcF2NXMQzDUFpamurWrVtiPZJIFxAQEGA+z8zMLLaefZl9jD0vL68i16ZVxNR5YGAgB7wLYtxcE+Pmmhg318S4uSbGzXUxduUvKCio1Drc4sMF2P8n4OjRo8XWsy8r7b8HAAAAAHAxSCJdQNOmTeXmdn6ofv7552LrFZSFhYWxMisAAACAckES6QJ8fX3Vrl07SdL69esd1jEMQxs2bJAkc3GdqsDLy0tTpkwpt9s7oHwwbq6JcXNNjJtrYtxcE+Pmuhi7qoXVWV3EwoULNWTIENlsNu3atUu33HJLofJly5bpgQcekCR98cUXuu222yqjmwAAAAAuc8xEuogBAwaoZcuWMgxDvXr10ubNmyWdX111+fLlGjp0qCSpR48eJJAAAAAAyg0zkS4kPj5enTp1Unx8vKTzp7nm5+fr3LlzkqRWrVpp8+bNCgkJqcReAgAAALickUS6mLS0NM2ePVurVq1SXFyc3Nzc1LhxYz344IMaPXq0PD09K7uLAAAAAC5jJJEAAAAAAMu4JhLlIi0tTTExMWrZsqX8/f0VFBSkv/3tb5ozZ46ys7Mru3tXnMzMTK1bt07Tp0/XfffdpwYNGshms8lmsykmJsZSGydOnNDYsWN17bXXysfHR9WrV1f79u21YMEC8b+o8nH69GktXrxY/fv3V7NmzeTn5ycvLy/Vq1dP0dHR+vjjj0ttg2Ox4u3du1dTp07V3XffrSZNmqhGjRry8PBQjRo11K5dOz3//PNKSkoqsQ2Ot6rjpZdeMr8vbTZbiXU53ire22+/XWh8int88cUXxbZx6NAhDR8+XJGRkfL29latWrXUrVs3rVy5sgI/yZUrNTVVM2bMUNu2bVWrVi3z91ynTp0UExOj5ORkh3Ecb5XMAJwsPj7eiIiIMCQZkgxfX1/Dy8vLfN2qVSsjKSmpsrt5Rdm6dau5/y98TJkypdT4PXv2GDVq1DBj/P39jWrVqpmvu3XrZmRlZZX/B7nC2O9jSYa3t7fh5+dX6L0ePXoYGRkZDuM5FivHY489VmTcAgICCr1Xs2ZN4+uvv3YYz/FWdRw8eNDw9vYuNHbF4XirHIsXLzYkGW5ubkbt2rWLfWzfvt1h/Oeff274+vqa4xQYGGi4ubmZrwcOHGjk5+dX8Ke6cmzZssWoXbu2ub89PT2N4ODgQsfc999/XySO463ykUTCqXJycoyWLVsakow6deoYmzZtMgzDMPLy8oyPPvrI/EPqjjvuqOSeXlm2bt1qhISEGLfddpsxfvx448MPPzTCwsIsJZHJyclm3SZNmhi7d+82DMMwsrKyjNdff93w8PAwJBkjR46sgE9yZZFk3Hzzzcabb75pHDp0yHw/Li7OGDx4sPnLsn///kViORYrzzvvvGPMmjXL2LVrl3HmzBnz/bS0NOOdd94xatWqZUgyQkNDjeTk5EKxHG9VR15entG2bVtDktGmTZsSk0iOt8pTkEQ2aNCgzLGHDx82/zHXrl0749dffzUM4/yxOnnyZHPMZ8yY4eRewzAMY8eOHYaPj48hybjvvvuM3bt3mwl7RkaG8d///tf417/+ZRw+fLhQHMdb1UASCadasGCB+aXr6L/sH3zwgVn+xRdfVEIPr0y5ublF3mvQoIGlJHLSpEmGJMPHx6fIF7lhGMYLL7xgSDLc3d3NX8Bwji1btpRYPnz4cPN4+vPPPwuVcSxWXRs2bDD3/fvvv1+ojOOt6vj3v/9tSDIeeughY8qUKSUmkRxvledSksj+/fsbkoywsLBC//ApMGzYMHN2klkt58rIyDAaNmxoSDJGjx5dpliOt6qBayLhVO+8844kqVOnTmrTpk2R8r59+yoyMlKS9O6771Zo365k7u7uFx1bME72Y2dv9OjR8vf3V15enpYsWXLR20FRnTp1KrF88ODB5vM9e/YUKuNYrLr+/ve/m8//97//FSrjeKsa4uLi9K9//Us1atTQK6+8Ump9jjfXk5GRYV7zOHLkSAUHBxepM3HiREnnr9lbvXp1Bfbu8vfee+/p8OHDCgsL08yZM8sUy/FWNZBEwmkyMzO1c+dOSVKPHj0c1rHZbOrevbskaePGjRXWN1ycX3/9VX/++aek4sfU399f7du3l8SYVjRvb2/zeV5envmcY7Fq++qrr8znV199tfmc463qGDp0qDIyMvTyyy+rVq1aJdbleHNNO3bs0NmzZyUVP24RERFq2rSpJMbN2QqSu969exf6XVYajreqgyQSTnPgwAHl5+dLklq0aFFsvYKy48ePl7pCISrXzz//bD63Mqa//PJLufcJ/2fbtm3m85YtW5rPORarnqysLMXHx+v111/Xww8/LEm65ppr1LNnT7MOx1vVMH/+fG3evFm33367HnnkkVLrc7xVDYmJibrxxhvl7+8vHx8fNWzYUP379y/0PWmvrMfb/v37ndrfK1lWVpZ59syNN96oP//8U8OGDVP9+vXl6emp2rVrq2fPnvr888+LxHK8VR0kkXCaY8eOmc/Dw8OLrWdfZh+DqqesY5qamqr09PRy7xek5ORkvfjii5Kk9u3b69prrzXLOBarDm9vb9lsNnl7eysyMlKjR4/WmTNn1K5dO23evFleXl5mXY63ynf06FGNHz9ePj4+euuttyzFcLxVDZmZmdq7d688PT2Vn5+vuLg4LVmyRJ06ddKgQYOUm5tbqH7BGISEhMjHx6fYdgvGjTFznvj4ePMWHIcPH1aLFi00f/58nTx5Un5+fjp58qTWrFmju+66S0OHDi10WyOOt6qDJBJOk5aWZj739fUttp59mX0Mqh7GtGrKz8/Xww8/rL/++kve3t56/fXXC5UzblVHWFiYateuLT8/P/O9Tp066d///reuuuqqQnUZt8o3fPhwpaSkKCYmRg0bNrQUw7hVrrp162rKlCn68ccfde7cOSUlJZmnPN5+++2SpMWLF+sf//hHobiCMShpzOzLGTPnOXPmjPl8+vTp8vDw0PLly5Wenq4zZ84oISFBvXv3liQtWLCg0HXJHG9VB0kkALiYJ598UmvWrJEkvfHGG7ruuusquUcoTnx8vI4fP6709HSdOHFCs2fP1g8//KCbb75ZkydPruzuwc7777+vzz//XDfccIPGjBlT2d2BRV27dlVMTIyuu+46c2bf3d1dbdu21YYNG3TPPfdIkt588039/vvvldlV/H8Fp6MWPF+4cKHuv/9+eXh4SJKuuuoqffTRR7r++uslSS+88EKRmWRUPpJIOE1AQID5PDMzs9h69mX2Mah6GNOqZ9y4cebM4yuvvKJBgwYVqcO4VU2hoaEaO3as1q9fL5vNpueee878Z4DEuFWmEydO6KmnnpK7u7vmz5+vatWqWY5l3KouNzc3zZ49W9L5ZOWzzz4zywrGoKQxsy9nzJzHfl82atRI0dHRReq4ublp3LhxkqTTp0/ru+++KxLL8Va5SCLhNHXr1jWfHz16tNh69mX2Mah6yjqmgYGB8vf3L/d+XakmTJigOXPmSJJmz56tp556ymE9jsWq7eabb1ZUVJQkad68eeb7HG+V55lnntHp06c1bNgwNWnSROnp6YUeBddvSSryHsdb1XbNNdeoZs2aks5ff1egYAzOnDljrtLqSMG4MWbOY3+9YpMmTYqt16xZM/N5QkKCJI63qoQkEk7TtGlTubmd/5GyX/XsQgVlYWFhql69eoX0DRfHfuUzK2Nq/4UP5xo/frxmzZolSZo5c6bGjh1bbF2Oxaqv4I+oP/74w3yP463yxMXFSZLmzp2rgICAIo+CRawkme9NmDBBEsebqyrr8da8efNy79OVonr16iUuilPAfkEdm80mieOtKiGJhNP4+vqqXbt2kqT169c7rGMYhjZs2CDp/HUMqNoaN25sLv5R3JhmZGSY971jTMvHuHHjzFOyZs6cqfHjx5dYn2Ox6iuYEbE/zYrjzTVxvFVthw4d0qlTpyTJvAG9JEVFRZmrshY3bgkJCTpw4IAkxs3ZCvZnwf51xP42RgVjx/FWhRiAEy1YsMCQZNhsNuObb74pUr506VJDkiHJ+OKLLyqhhyjQoEEDQ5IxZcqUEutNmjTJkGT4+voacXFxRcpnzJhhSDLc3d2NX3/9tXw6ewUbO3aseczMnj3bchzHYuXIzc018vPzS6zzxRdfGDabzZBkTJgwoVAZx1vVNGXKFPN4cYTjrXKUdqzl5+cb9957ryHJcHNzMw4ePFiovH///oYko06dOkZycnKR+JEjRxqSjICAACMpKcmpfb/Sbd++3TwmPv744yLleXl5xnXXXWdIMsLDw428vDyzjOOtaiCJhFPl5OQYLVu2NA/6goM3Ly/PWLZsmREYGGhIMnr06FHJPb3yJCUlGYmJieajfv36hiRj/Pjxhd5PS0srFJecnGyEhYUZkoxmzZoZe/bsMQzDMLKysow333zT8PT0NCQZI0eOrIyPdVkbP368+Yvw5ZdfLlMsx2LliIuLM66//nojNjbWOHToUKE/cv/880/jxRdfNPz8/AxJRvXq1Y2//vqrUDzHW9VUWhLJ8VY54uLijL/97W9Fjre8vDxj165dRrdu3cxxc3TMHD582Dwe27dvb/z222+GYRhGenq6MXXqVPOfPTNmzKjQz3WluP/++w1JRo0aNYwVK1YYOTk5hmEYRkJCgtGnTx9z7N5+++1CcRxvVQNJJJwuLi7OiIiIMA9+X19fw9vb23zdqlUr/qNXCQpmHkt7DBgwoEjsnj17jBo1aph1AgICDA8PD/N1165djXPnzlX8h7qMJSQkmPvXzc3NqF27domPWbNmFWmDY7HixcXFFTqePD09jZo1a5p/qBY8IiMjjb179zpsg+Ot6iktiTQMjrfKcOHx5uXlZdSsWdPw8vIq9P7AgQPNBOVCn3/+ueHr62vWDQoKMtzd3QvFljbjiYuTnp5udOjQodD4hYSEFBq74s6W4nirfFwTCaeLiIjQvn37NHnyZLVo0UI2m00eHh668cYbNXv2bH3zzTcKCQmp7G6iDG688Ubt379f//jHP9SoUSPl5OTIz89PUVFRmj9/vtatW2fenwvOceF9tE6cOFHiIz09vUgbHIsVr27dulq+fLkee+wx3XTTTapZs6ZSU1OVn5+vq666Sj179tSCBQu0f/9+tWrVymEbHG+uieOt4tWuXVuvvfaa+vXrp2bNmikwMFDJycny8PBQkyZNNGjQIO3YsUOLFi0q9rYtd9xxh/bt26ehQ4cqIiJC586dU0hIiLp06aIVK1Zo0aJF5qIucC4/Pz9t3bpV8+fPV4cOHeTn56f09HSFh4erb9++2rlzp2JiYhzGcrxVPpth2C19BAAAAABACZiJBAAAAABYRhIJAAAAALCMJBIAAAAAYBlJJAAAAADAMpJIAAAAAIBlJJEAAAAAAMtIIgEAAAAAlpFEAgAAAAAsI4kEAAAAAFhGEgkAAAAAsIwkEgCAi3TrrbfKZrMpJiamsrtSqTIzM/Xss8+qadOm8vHxkc1mk81m0w8//FDZXSvk0Ucflc1m06OPPlrZXQEAl0YSCQBwqpiYGDOJ8PX11bFjx4qtGx8fb9bdtm1bxXUSTvXAAw9o+vTpOnjwoGw2m2rXrq3atWvLw8Oj2Jht27aZY38xj/j4+Ir7gACAQqpVdgcAAJevs2fPaurUqXrrrbcquysoJwcPHtSaNWskSUuXLlWfPn0sxXl6eqp27doOy5KSkpSTkyMPDw9Vr17dYR13d/eL6zAA4JKRRAIAytWiRYs0duxYNW7cuLK7gnLw008/SZJq1KhhOYGUpLZt2+r48eMOy2699VZ9+eWXatu2LTPUAFAFcTorAKBc1K9fX9ddd51yc3P1z3/+s7K7g3KSmZkpSfL396/kngAAKgpJJACgXLi5/b/27jwmqnMNA/gzC8OA4MxIC1VAUDS4UJfWpbXSAa22RmM0VCluxEpbu2gjbaOtEBqrKDWuiS1JrdrWKjSgabRat4BRS9pgS4zG2NRSEbV1qSiozDDw3j/InMsw54yjF6Y39z6/ZBI43/Z+54zG13PO9+mxcuVKAEBpaSl++umnB2rf9n1JX++/xcfHQ6fTYdu2bT7bX7hwAa+88gp69uwJs9mMhIQE5OTk4M6dO0qb06dPY9asWYiNjYXZbEbfvn2xfPlyNDU13Tdep9OJVatWYdCgQejSpQtsNhvGjRuH/fv337ft6dOn8eqrr6Jv374IDQ1FWFgYBg0ahKVLl+L69euqbdzvnqakpABoPcfjx49HZGQk9Hr9Ay/209jYiPXr12PUqFGw2Wwwm82Ii4vDnDlzVBfIcY/vXqTmwoULHu8sdvbiNbt27cKkSZMQFRWlPBo7adIk7N69+6H7PHjwIMLDw5X4XS6XR/mJEycwa9YsxMXFwWw2w2KxYMSIESgoKEBDQ4Nqn+0X8ykpKUFKSgq6deuG0NBQDBkyBBs2bEBLS4tmXMXFxZgwYYLynqnVakXfvn0xefJkbNq0CY2NjQ89ZyKihyJEREQdKC8vTwBIXFyciIjY7XYBIKmpqV51q6urBYAAkLKyMs2y6upqzfHi4uIEgGzdulWzfWlpqVitVgEgXbt2FYPBoJQlJyeL0+mUvXv3SmhoqAAQi8UiOp1OqZOenq46tntu77//viQnJwsAMRqNyljuT15enmb8BQUFotfrlbqhoaFiMpmU37t37y4///yz5nm22+2SnZ0tAESn04nNZhODweBzzPZqa2slKSlJGTMoKEgsFovyu16vl40bN3q0Wb16tURFRUnXrl2VOlFRUcpn4cKFfo/fnvu82u12rzKHwyHp6ekesdlsNo9zmJGRIU6n06ttZmamAJDMzEyvsq+++kqCgoIEgCxevNijrLm5WRYuXOhxTcPCwjy+R4mJifLHH3/4HPPNN99UYm7/HZkzZ47quZg7d67XuO7vqT9/PoiIOgOTSCIi6lDtk8iKigrlH7v79+/3qBuoJNJqtcrYsWPlzJkzIiJy9+5d2bhxo5IE5OTkiMVikfT0dCURqK+vl6VLlyp9HDp0yGtsd7JjsVgkODhYCgsL5d69eyIiUlNTIy+++KLS/ttvv/Vqv3nzZiUxWLFihVy5ckVERFwul1RWVsqYMWMEgMTExEh9fb3qeQ4LC1MSn6tXr4qISGNjo2pCo8blcsnIkSOVeWzfvl0cDoeIiJw/f14mTZqkJKj79u3zar9161aP690RfCWR77zzjhJPbm6u3Lx5U0RE/v77b/nggw+U890+ERTRTiJXr14tOp1OdDqdrF+/3qtdTk6OAJDIyEjZtGmT3LhxQ0REnE6nlJWVydChQwWAPPHEE9Lc3Kw6ps1mE5PJJGvXrpVbt26JiMj169clKytLifnIkSMebY8dO6YknQUFBcq47rYHDhyQzMxMuXTp0n3PKRFRR2ISSUREHap9EikiMnXqVAEgQ4YMkZaWFuV4oJLIgQMHSmNjo1fb2bNnK3XGjRvnEZub+w7jvHnzvMrcyQ4A+fzzz73Km5ub5dlnn1ViaOv27dvK3ajvv/9edW5NTU3y5JNPCgBZt26dR5n7PAOQ7Oxs1fb+KCoqUvo5cOCAagzuJDMpKcmrPJBJZG1trRiNRuXurxr3XdmgoCC5fPmyR1n7JLKlpUUWLVokAMRkMklRUZFXf9XV1WIwGCQkJESqqqpUx7x9+7bExMQIANm9e7fqmGrfUTf3Nc7KyvI4XlBQIABk/Pjxqu2IiP4pfCeSiIg6XX5+PgwGA6qqqrBz586Aj79o0SIEBwd7HX/++eeVn5csWQKdTqdZ59SpU5r9x8bGYu7cuV7H9Xo9cnJyAABnzpxRVjIFWt9hrKurw9ChQz3iaMtoNCIjIwMAcODAAdU6er0eixcv1oztfoqLiwEATz/9NMaPH68aQ15eHoDWdzfbziHQSktL4XK5YDabsWTJEtU6OTk5CA4ORlNTE0pKSjT7cjqdmDlzJtatW4fw8HDs27cP6enpXvW2bduG5uZmvPDCCxg8eLBqX+Hh4ZgyZQoA7esUGxuLzMxM1bLJkycD8P6OWa1WAMC1a9fQ3NysORciokDjFh9ERNTp+vXrh7lz52Lz5s3Izc3FtGnTfG5E39FGjBiherztPoXDhw/3WefmzZua/aekpKgmoACQnJwMo9EIl8uFyspKPP744wBaF2kBgLNnz+Kxxx7T7PvevXsAWheuUdOnTx9ERkZqtr+fyspKAMBzzz2nWSc1NRUGgwHNzc0ecwg0d6zDhw9H165dVevYbDYMGzYMJ06cUOq3V19fj4kTJ+Lw4cOIiorC/v37MXToUNW67ut08OBBn9fJvbCO1nUaPny45nekR48eAFr3x2xr7NixMJvN+OWXX5CcnIx58+ZhzJgx6NWrl2YcRESBwCSSiIgC4sMPP8TXX3+N33//HYWFhViwYEHAxg4PD1c9bjQa/a7ja4XW6OhozTKz2YyIiAj89ddfuHr1qnL88uXLAFpXRfVndU33Vhrt/ScJJAAlpvvN4ZFHHvGaQ6D5EysAxMTEeNRvb9euXcrPe/bs0UwggX9fpzt37nis5KtF6zppfb8A7e9YQkICNm/ejPnz56OiogIVFRUAgEcffRSpqamYMWMGJk+erJmcEhF1Fj7OSkREAREdHa0kjsuXL9fcEuH/hfvxxPT0dEjrGgU+P1rbnBgMhgBG/b/BbrcjNjYWAJCVlYVr165p1nVfp8WLF/t1ncrLyzs01pkzZ+LChQsoLCxEeno6YmNjce3aNXzzzTeYMmUK7HY7bt++3aFjEhHdD5NIIiIKmCVLlsBms+Hq1atYs2aNz7pt7xL6ulN369atDovvYV26dEmzzOFw4MaNGwA87xq6H43UevwxUNwx1dbWatZpbGxUnUOg+RNr23KtWOPj41FeXo64uDicOnUKqampmnct/xuuU7du3fDaa6+hqKgINTU1+O2335R3eI8dO/bAe4ISEf2nmEQSEVHA2Gw2ZUGUNWvW+LwDZLPZlJ8vXryoWufXX39FXV1dh8b4MI4ePQoRUS07duyYsmn9sGHDlOPPPPMMAODkyZO4cuVK5wepwR3TkSNHNOuUl5crc9B6dzQQ3LFWVlZq/udBXV2dx7uTWnr37o3y8nLEx8fjzJkzSElJwZ9//ulVz32dDh8+7Ndjx4GQkJCAlStXYsaMGQCAQ4cO/cMREdH/GyaRREQUUAsWLEBMTAzq6+vx0Ucfadbr0qULEhISALSuyqlmxYoVnRLjg6qpqcEXX3zhdbylpQX5+fkAgAEDBngsSDNt2jRYrVY0NTUhOztbMwl199NZyfJLL70EAKioqMDBgwe9yl0uF5YtWwYASEpKQlJSUqfE4Y+0tDQYjUY0NjaioKBAtU5+fj4cDgeCgoKQlpbms7/4+HgcPXoUvXv3xtmzZ5GSkuKV0L/88sswGo24fv26skqtFqfT2aGPaTscDp/lISEhAFpX6CUiCiT+rUNERAEVEhKiPH63Z88en3Xd21ts2bIFn3zyibJS6cWLF5GVlYXi4mKEhoZ2arz+sFgseP311/HZZ58pd6suXryIjIwMlJWVAWh9D7Qtq9WK9evXAwCKioowceJE/Pjjj2hpaQHQmjiePXsWa9aswcCBA7F3795OiT0tLQ0jR44EAEyfPh07duxQFniprq5GWlqasqDLxx9/3Ckx+Cs6Ohpvv/02AGDVqlXIy8tTkuu6ujrk5uZi9erVAIDs7Gx07979vn327NkTR48eRZ8+fXDu3DnY7XaPx5MTEhKQm5sLoHX+c+bMwenTp5Vyl8uFqqoqLFu2DH369EFVVVUHzRZ46623MH36dJSWlno8btvQ0IDCwkJ8+eWXAICJEyd22JhERH4J7LaURET0vy4vL+++m8+7XC7p16+fsgk7ACkrK/OqV19fLwMGDFDq6PV6sVqtymbyO3fulLi4ONWN3Kurq5V21dXVqnGUlZUpdbRs3bpVcz52u13Z+H706NFKXDabzWNuOTk5mv1/+umnYjKZlLrBwcESEREhQUFBHn1s377do537PNvtds2+/VVbWysDBw5UxjKZTMp5dp/3DRs2qLb1dX4elvu8qs3N4XDI9OnTPWKz2Wyi1+uVYxkZGeJ0Or3aZmZmCgDJzMz0Krt06ZIkJiYKAElISJCamhqlrKWlRXJzc0Wn0yljhISESEREhBgMBo/rdPz4cb/HdNM6h+627k9YWJjHdQEgo0ePloaGBp/nk4ioo/FOJBERBZzBYFAe8/QlLCwMx48fR3Z2Nnr16gWj0ag8plhRUaE8ivlPM5lMOHLkCPLz85GYmAiHwwGLxYKxY8fiu+++8/nY7vz583Hu3Dm8++67GDx4MIKDg1FXV4ewsDAMGzYMCxYswKFDh5S7sp0hOjoalZWVWLt2LZ566imEhITg7t27iI2NxezZs3Hy5EksXLiw08Z/ECaTCcXFxSgpKcGECRMQERGB+vp6REREYMKECdi1axd27NjxwPuQ9ujRA+Xl5ejfvz/Onz8Pu92uLKaj0+mwbNkynDp1Cm+88Qb69+8Pg8GAW7duwWazYdSoUXjvvffwww8/KO9QdoTc3Fxs3LgRU6dORb9+/WA0GtHQ0IDIyEiMGzcOW7ZsQXl5Obp06dJhYxIR+UMn4uMlDCIiIiIiIqI2eCeSiIiIiIiI/MYkkoiIiIiIiPzGJJKIiIiIiIj8xiSSiIiIiIiI/MYkkoiIiIiIiPzGJJKIiIiIiIj8xiSSiIiIiIiI/MYkkoiIiIiIiPzGJJKIiIiIiIj8xiSSiIiIiIiI/MYkkoiIiIiIiPzGJJKIiIiIiIj8xiSSiIiIiIiI/PYvpt9bHn7l1DkAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "전체 토큰 수: 328251\n", - "고유 토큰 수: 8283\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# SD와 PD의 총 갯수 계산\n", - "total_SD = summary_df['SD'].sum() # SD의 총 갯수\n", - "total_PD = summary_df['PD'].sum() # PD의 총 갯수\n", - "\n", - "# tag_description의 글자수 계산\n", - "df['tag_description_length'] = df['tag_description'].astype(str).apply(len)\n", - "\n", - "# tag_description의 평균 글자수 계산\n", - "mean_tag_description_length = df['tag_description_length'].mean()\n", - "\n", - "# 결과 출력\n", - "print(f\"Tag Description의 평균 글자수: {mean_tag_description_length:.2f}\")\n", - "\n", - "# 글자수 분포를 히스토그램으로 시각화\n", - "plt.figure(figsize=(10, 6))\n", - "plt.hist(df['tag_description_length'], bins=30, color='skyblue', edgecolor='black', alpha=0.7)\n", - "plt.title('Distribution of Tag Description Lengths')\n", - "plt.xlabel('Tag Description Length (characters)')\n", - "plt.ylabel('Frequency')\n", - "plt.grid(True)\n", - "plt.show()\n", - "\n", - "# tag_description을 ' '로 split한 후 토큰 수 계산\n", - "df['tag_description_tokens'] = df['tag_description'].astype(str).apply(lambda x: len(x.split(' ')))\n", - "\n", - "# tag_description의 평균 토큰 수 계산\n", - "mean_tag_description_tokens = df['tag_description_tokens'].mean()\n", - "\n", - "# 결과 출력\n", - "print(f\"Tag Description의 평균 토큰 수: {mean_tag_description_tokens:.2f}\")\n", - "\n", - "# 토큰 수 분포를 히스토그램으로 시각화\n", - "plt.figure(figsize=(10, 6))\n", - "plt.hist(df['tag_description_tokens'], bins=30, color='lightgreen', edgecolor='black', alpha=0.7)\n", - "plt.title('Distribution of Tag Description Tokens')\n", - "plt.xlabel('Number of Tokens')\n", - "plt.ylabel('Frequency')\n", - "plt.grid(True)\n", - "plt.show()\n", - "\n", - "# 전체 텍스트에서 모든 토큰 수와 고유 토큰 수 계산\n", - "all_tokens = df['tag_description'].astype(str).apply(lambda x: x.split(' ')).sum() # 전체 토큰 리스트\n", - "unique_tokens = set(all_tokens) # 고유 토큰 집합\n", - "\n", - "# 전체 토큰 수와 고유 토큰 수 계산\n", - "total_token_count = len(all_tokens)\n", - "unique_token_count = len(unique_tokens)\n", - "\n", - "# 결과 출력\n", - "print(f\"전체 토큰 수: {total_token_count}\")\n", - "print(f\"고유 토큰 수: {unique_token_count}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "torch", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/data_import/1.select_db.py b/data_import/select_db.py similarity index 85% rename from data_import/1.select_db.py rename to data_import/select_db.py index eefac28..ff2f4d1 100644 --- a/data_import/1.select_db.py +++ b/data_import/select_db.py @@ -38,7 +38,7 @@ try: results_mapping = cursor.fetchall() columns_mapping = [desc[0] for desc in cursor.description] df_mapping = pd.DataFrame(results_mapping, columns=columns_mapping) - df_mapping.to_csv('data_import/data_mapping.csv', index=False, encoding='utf-8-sig') + df_mapping.to_csv('exports/data_mapping.csv', index=False, encoding='utf-8-sig') # Export data_master_model table query_master = """ @@ -48,9 +48,9 @@ try: results_master = cursor.fetchall() columns_master = [desc[0] for desc in cursor.description] df_master = pd.DataFrame(results_master, columns=columns_master) - df_master.to_csv('data_import/data_model_master_export.csv', index=False, encoding='utf-8-sig') + df_master.to_csv('exports/data_model_master_export.csv', index=False, encoding='utf-8-sig') - print("Data exported successfully to 'data_import/data_mapping.csv' and 'data_import/data_model_master_export.csv'") + print("Data exported successfully to 'exports/data_mapping.csv' and 'exports/data_model_master_export.csv'") except (Exception, psycopg2.DatabaseError) as error: print(f"An error occurred: {error}")