From 7a28e0e0790435f6879df5c3351b00830b0f2f53 Mon Sep 17 00:00:00 2001 From: Matthew Gaughan Date: Thu, 8 May 2025 13:49:50 -0700 Subject: [PATCH] updating things for new key term searches across phabricator tasks --- mgaughan-rstudio-server_25681892.out | 1 + .../031025_phab_comments-checkpoint.ipynb | 282 ++-- .../case1/031025_phab_comments.ipynb | 164 +-- ...olved_phab_comments-Copy1-checkpoint.ipynb | 803 ----------- ...50825_join_resolved_files-checkpoint.ipynb | 487 +++++++ .../c3-resolved-phab-checkpoint.ipynb | 777 +++++++++++ .../coref_resolution-http-checkpoint.ipynb | 532 ++++++-- .../case3/041525_phab_comments.ipynb | 4 +- .../041525_resolved_phab_comments-Copy1.ipynb | 803 ----------- .../case3/050825_join_resolved_files.ipynb | 1176 +++++++++++++++++ text_analysis/case3/c3-resolved-phab.ipynb | 777 +++++++++++ .../case3/coref_resolution-http.ipynb | 459 ++++++- 12 files changed, 4340 insertions(+), 1925 deletions(-) delete mode 100644 text_analysis/case3/.ipynb_checkpoints/041525_resolved_phab_comments-Copy1-checkpoint.ipynb create mode 100644 text_analysis/case3/.ipynb_checkpoints/050825_join_resolved_files-checkpoint.ipynb create mode 100644 text_analysis/case3/.ipynb_checkpoints/c3-resolved-phab-checkpoint.ipynb delete mode 100644 text_analysis/case3/041525_resolved_phab_comments-Copy1.ipynb create mode 100644 text_analysis/case3/050825_join_resolved_files.ipynb create mode 100644 text_analysis/case3/c3-resolved-phab.ipynb diff --git a/mgaughan-rstudio-server_25681892.out b/mgaughan-rstudio-server_25681892.out index 616ff4a..bd7c2ac 100644 --- a/mgaughan-rstudio-server_25681892.out +++ b/mgaughan-rstudio-server_25681892.out @@ -15,3 +15,4 @@ When done using RStudio Server, terminate the job by: 2. Issue the following command on the login node: scancel -f 25681892 +slurmstepd: error: *** JOB 25681892 ON n3439 CANCELLED AT 2025-05-01T23:08:23 DUE TO TIME LIMIT *** diff --git a/text_analysis/case1/.ipynb_checkpoints/031025_phab_comments-checkpoint.ipynb b/text_analysis/case1/.ipynb_checkpoints/031025_phab_comments-checkpoint.ipynb index f0e7fbd..7913a10 100644 --- a/text_analysis/case1/.ipynb_checkpoints/031025_phab_comments-checkpoint.ipynb +++ b/text_analysis/case1/.ipynb_checkpoints/031025_phab_comments-checkpoint.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "e4f0b3f0-5255-46f1-822f-e455087ba315", "metadata": {}, "outputs": [], @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "d449164e-1d28-4580-9eb1-f0f69978f114", "metadata": {}, "outputs": [], @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "942344db-c8f5-4ed6-a757-c97f8454f18b", "metadata": {}, "outputs": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "d226d781-b002-4842-a3ae-92d4851a5878", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559", "metadata": {}, "outputs": [ @@ -110,7 +110,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/3649688126.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/3649688126.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57", "metadata": {}, "outputs": [ @@ -133,7 +133,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/1316816771.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/1316816771.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab", "metadata": {}, "outputs": [], @@ -177,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920", "metadata": {}, "outputs": [ @@ -185,7 +185,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/2805711855.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2805711855.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -200,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "337a528a-5667-4e1f-ac9a-37caabc03a18", "metadata": {}, "outputs": [ @@ -208,7 +208,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/2117289791.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2117289791.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4", "metadata": {}, "outputs": [], @@ -286,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "828fb57a-e152-42ef-9c60-660648898532", "metadata": {}, "outputs": [ @@ -294,25 +294,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/2858732056.py:2: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:2: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n", - "/tmp/ipykernel_5608/2858732056.py:3: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:3: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n", - "/tmp/ipykernel_5608/2858732056.py:4: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:4: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n", - "/tmp/ipykernel_5608/2858732056.py:5: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:5: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -331,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "27e47f6f-0257-4b70-b222-e91ef888c900", "metadata": {}, "outputs": [ @@ -339,19 +339,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/335308388.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/335308388.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", - "/tmp/ipykernel_5608/335308388.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/335308388.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", - "/tmp/ipykernel_5608/335308388.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/335308388.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -367,14 +367,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0", "metadata": {}, "outputs": [], "source": [ "# expand the dependency parser \n", "\n", - "pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", + "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", "#pattern = r'\\b(WMF|Foundation)\\b'\n", "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n", "\n", @@ -389,29 +389,27 @@ " WMFaffil = row['meta.affil']\n", " \n", " for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n", - " if re.search(pattern, token, re.IGNORECASE):\n", - " dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", + " dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", " for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n", - " if re.search(pattern, token, re.IGNORECASE):\n", - " resolved_dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", + " resolved_dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", "\n", "resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations) \n", "dependency_relations_df = pd.DataFrame(dependency_relations)" @@ -419,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "82498686-14f4-40c8-9e33-27b31f115b47", "metadata": {}, "outputs": [], @@ -601,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 53, "id": "b7cfad77-d48a-4708-91f3-89ae1179b90c", "metadata": {}, "outputs": [ @@ -609,14 +607,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/3877447769.py:27: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + "/tmp/ipykernel_5608/1399682200.py:27: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", " comment_counts = affective_comment_phab_df.groupby('date_group').size()\n", - "/tmp/ipykernel_5608/3877447769.py:28: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + "/tmp/ipykernel_5608/1399682200.py:28: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", " speaker_counts = affective_comment_phab_df.groupby('date_group')['speaker'].nunique()\n", - "/tmp/ipykernel_5608/3877447769.py:35: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", - " comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n", - "/tmp/ipykernel_5608/3877447769.py:36: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", - " speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n" + "/tmp/ipykernel_5608/1399682200.py:35: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " comment_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil']).size()\n" ] }, { @@ -625,48 +621,62 @@ "text": [ "Number of comments for each date group:\n", "date_group\n", - "Before announcement 1858\n", - "After announcement, before deployment 1403\n", - "After deployment 4726\n", + "Before announcement 1858\n", + "After announcement, before opt-out deployment 1403\n", + "After opt-out deployment 4726\n", "dtype: int64\n", "\n", "Number of speakers for each date group:\n", "date_group\n", - "Before announcement 104\n", - "After announcement, before deployment 92\n", - "After deployment 184\n", - "Name: speaker, dtype: int64\n", + "Before announcement 104\n", + "After announcement, before opt-out deployment 92\n", + "After opt-out deployment 184\n", + "Name: speaker, dtype: int64\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_5608/1399682200.py:36: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " speaker_counts_engaged = affective_comment_phab_df.groupby(['date_group', 'est_commenter', 'meta.affil'])['speaker'].nunique()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", "Number of comments for each date group and engaged commenter subgroup:\n", - "date_group est_commenter meta.affil\n", - "Before announcement False False 613\n", - " True 84\n", - " True False 836\n", - " True 325\n", - "After announcement, before deployment False False 589\n", - " True 104\n", - " True False 492\n", - " True 218\n", - "After deployment False False 2512\n", - " True 510\n", - " True False 1402\n", - " True 302\n", + "date_group est_commenter meta.affil\n", + "Before announcement False False 613\n", + " True 84\n", + " True False 836\n", + " True 325\n", + "After announcement, before opt-out deployment False False 589\n", + " True 104\n", + " True False 492\n", + " True 218\n", + "After opt-out deployment False False 2512\n", + " True 510\n", + " True False 1402\n", + " True 302\n", "dtype: int64\n", "\n", "Number of speakers for each date group and engaged commenter subgroup:\n", - "date_group est_commenter meta.affil\n", - "Before announcement False False 91\n", - " True 25\n", - " True False 7\n", - " True 7\n", - "After announcement, before deployment False False 77\n", - " True 31\n", - " True False 7\n", - " True 7\n", - "After deployment False False 172\n", - " True 52\n", - " True False 7\n", - " True 7\n", + "date_group est_commenter meta.affil\n", + "Before announcement False False 91\n", + " True 25\n", + " True False 7\n", + " True 7\n", + "After announcement, before opt-out deployment False False 77\n", + " True 31\n", + " True False 7\n", + " True 7\n", + "After opt-out deployment False False 172\n", + " True 52\n", + " True False 7\n", + " True 7\n", "Name: speaker, dtype: int64\n", "\n", "Number of comments for each engaged commenter subgroup, and WMF affiliation:\n", @@ -692,15 +702,15 @@ "'\\nplot1 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"dominant_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'new_commenter\\', scatter=False, legend=False, palette=palette)\\nplot1.set_axis_labels(\"Timestamp\", \"Count of Dominance Polarized Words\")\\nplot1.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot1.fig.subplots_adjust(top=0.9) # Adjust subplots to make room for the title\\nplot1.add_legend(title=\"Comment publication timestamp:\")\\nfig1 = plot1.fig\\n# Plot for arousal_wc\\nplot2 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"arousal_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot2.set_axis_labels(\"Timestamp\", \"Count of Arousal Polarized Words\")\\nplot2.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot2.add_legend(title=\"Comment publication timestamp:\")\\n#plot2.add_legend(title=\"Before/After 07/01/2013 Wide Release\")\\n\\nplot3 = sns.lmplot(data=comment_phab_df, x=\"date_created\", y=\"valence_wc\", hue=\"date_group\", col=\"meta.affil\", row=\\'engaged_commenter\\', scatter=False, legend=False, palette=palette)\\nplot3.set_axis_labels(\"Timestamp\", \"Count of Valence Polarized Words\")\\nplot3.set_titles(row_template=\"Author\\'s 100+ Comment: {row_name}\",col_template=\"WMF Affiliation: {col_name}\")\\nplot3.add_legend(title=\"Comment publication timestamp:\")\\n'" ] }, - "execution_count": 28, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -714,7 +724,7 @@ " pd.Timestamp('2013-07-01 00:00:01+00:00'),\n", " pd.Timestamp('2100-01-01 00:00:01+00:00')\n", "]\n", - "labels = ['Before announcement', 'After announcement, before deployment', 'After deployment']\n", + "labels = ['Before announcement', 'After announcement, before opt-out deployment', 'After opt-out deployment']\n", "\n", "#creating variables of interest\n", "affective_comment_phab_df = comment_phab_df\n", @@ -795,25 +805,15 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 55, "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -823,7 +823,7 @@ "source": [ "sns.set_context(\"talk\", font_scale=0.9)\n", "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n", - "plot2.set_axis_labels(\"Speaker's Nth Comment\", \"Count of Polarized Words\")\n", + "plot2.set_axis_labels(\"Comment Index in Speaker History\", \"Count of Polarized Words\")\n", "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n", "plot2.fig.suptitle(\"Use of Emotional Language in VisualEditor Phabricator Comments\", fontsize=18)\n", "\n", @@ -838,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 21, "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f", "metadata": {}, "outputs": [ @@ -846,21 +846,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_94014/1491274823.py:4: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + "/tmp/ipykernel_43056/387535334.py:5: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", " filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_94014/1491274823.py:5: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + "/tmp/ipykernel_43056/387535334.py:6: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", " resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_94014/1491274823.py:20: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + "/tmp/ipykernel_43056/387535334.py:21: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_43056/387535334.py:22: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_94014/1491274823.py:20: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/387535334.py:22: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_94014/1491274823.py:39: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + "/tmp/ipykernel_43056/387535334.py:43: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_43056/387535334.py:44: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_94014/1491274823.py:39: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/387535334.py:44: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -870,7 +882,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKQAAAMWCAYAAADPhl4gAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FNX79/HPbsomm0YLSUAg9BpBBGlKERUEQUHEgkJAxQJ2FPgpSlGwImLDChYUVOyIBQFRKQoC0qRJUUnoqZu+8/zBk/2ybCoku5Pk/bquva7s1HvOnDkze2fmjMUwDEMAAAAAAACAl1h9HQAAAAAAAACqFhJSAAAAAAAA8CoSUgAAAAAAAPAqElIAAAAAAADwKhJSAAAAAAAA8CoSUgAAAAAAAPAqElIAAAAAAADwKhJSAAAAAAAA8CoSUgAAAAAAAPAqElIAqrx58+bJYrFo3bp15b6u33//XV27dlVISIgsFos2btxYqvl79uypNm3alHj63377TYGBgdq/f79rWGxsrK644opSrbc85Ze/t02ePNkn65Wk+Ph49ezZ0yfrliSLxaLJkyf7bP3FmTNnjurXr6+srKwSTX+2x7Cv6sK+fftksVj07LPPltky87fl6NGjZ7Ucs9cRwJs4HgCgfJCQAlDu8n8s5n+CgoJUp04d9enTR7Nnz1ZqaqpX4njllVc0b948r6yrIDk5Obrmmmt0/PhxPf/883rvvffUoEEDj+kuvfRSDRs2rEzW+fDDD+v6668vcD1l5eDBg5o8eXKpk2sV2apVqzR58mQlJSX5OhTT+uCDDzRr1qwzmjc+Pl7Z2dl67bXXXMPmz58vm82m9PT0Moqw/OQnmvI/fn5+ql+/vgYNGlSljpPC+KrN2Lx5s4YMGaIGDRooKChIdevW1aWXXqoXX3yxXNdb2drIFStWuNVvm82mqKgo9ezZU9OnT9eRI0d8HSJOc+r+KuqzYsUKX4cKoIrx93UAAKqOqVOnqmHDhsrJyVFiYqJWrFihe++9VzNnztSXX36pc889t1zX/8orr6hWrVqKj48v1/UUZs+ePdq/f7/eeOMN3XLLLYVO169fPz3xxBNyOp2yWs/8/wYbN27U0qVLtWrVqjNeRkkcPHhQU6ZMUWxsrNq1a1eu6ypLjzzyiCZMmHBG865atUpTpkxRfHy8qlWrVraBVRIffPCBtmzZonvvvbfU8wYFBWnEiBGaOXOm7rrrLlksFvXt21e5ublaunSprrzyyjKN9WzqQlGuv/569evXT3l5edq+fbteffVVLVmyRGvWrDH9sZKRkSF///K5TPRFm7Fq1Sr16tVL9evX16233qro6Gj9888/WrNmjV544QXddddd5bbuitpGFufuu+9Wx44dlZeXpyNHjmjVqlV67LHHNHPmTH300Ue6+OKLfR0i/r/33nvP7fu7776rH374wWN4y5YtvRkWAJCQAuA9l19+uTp06OD6PnHiRC1btkxXXHGFBg4cqO3btys4ONiHEZavw4cPS1KxCYz+/fvr/vvv15o1a9S1a9czXt/cuXNVv359de7c+YyXURmlp6crJCRE/v7+5faDG2dv6NChevrpp7V8+XJdfPHFqlmzpjp16qTFixeXeUKqvOpC+/btdeONN7q+d+vWTQMHDtSrr77qdveXWTidTmVnZysoKEhBQUG+DqfU8o/tgjzxxBOKiIjQ77//7tEG57fNKJ2LLrpIQ4YMcRu2adMmXXbZZbr66qu1bds2xcTE+Cg6nOrUdkiS1qxZox9++MFj+OkcDofsdnt5hgagiuORPQA+dfHFF2vSpEnav3+/3n//fbdxf/31l4YMGaIaNWooKChIHTp00Jdffuk2Tf7jgCtXrtRtt92mmjVrKjw8XMOHD9eJEydc08XGxmrr1q366aefXLemn96HT1ZWlu6//35FRkYqJCREgwYNKvGjB8uWLdNFF12kkJAQVatWTVdeeaW2b9/uGh8fH68ePXpIkq655poC15+vWbNmaty4sRYvXlzo+tavX6+uXbsqODhYDRs21Jw5czym+fzzz3XxxRcX2jfO999/r3bt2ikoKEitWrXSp59+6jHN33//rWuuuUY1atSQ3W5X586d3eJasWKFOnbsKEkaOXKkq2zzH43ctWuXrr76akVHRysoKEjnnHOOrrvuOiUnJxe6bdLJxxunTJmipk2bKigoSDVr1tSFF16oH374wW26v/76S0OHDlVkZKSCg4PVvHlzPfzww67x+f3pbNu2TTfccIOqV6+uCy+80G3cqSwWi8aOHav58+erefPmCgoK0vnnn6+VK1e6LfPBBx+UJDVs2NC1zfv27ZMk/fDDD7rwwgtVrVo1hYaGqnnz5vq///u/Irc338cff6xWrVopKChIbdq00Weffab4+HjFxsa6Tffss8+qa9euqlmzpoKDg3X++efrk08+8VheVlaW7rvvPkVGRiosLEwDBw7Uv//+W+C6V6xYoQ4dOigoKEiNGzfWa6+9VmjfSu+//77OP/98BQcHq0aNGrruuuv0zz//uMb37NlTixcv1v79+13lc+o2vPjii2rdurXsdruqV6+uDh066IMPPnBbx/nnn68aNWroiy++cA3r16+fvvnmm0LLz+FwFNkOFKaouvD555+rTZs2stlsat26tb799ttil1eY/DtG9u7d6zHu9ddfV+PGjWWz2dSxY0f9/vvvbuP//PNPxcfHq1GjRgoKClJ0dLRGjRqlY8eOFbiuo0ePaujQoQoPD1fNmjV1zz33KDMzs8BtnD9/vlq3bi2bzebavoL6zPnvv/908803q06dOrLZbGrYsKHuuOMOZWdnS5KOHz+ucePGKS4uTqGhoQoPD9fll1+uTZs2uZZRXJshnTwO8utXrVq1dOONN+q///5ziyU+Pl6hoaHas2eP+vXrp7CwsCIfdd6zZ49at25d4D8Eateu7TGsuDou/a9Pv23btqlXr16y2+2qW7eunn766VJt79q1a9W3b19FRETIbrerR48e+vXXX93WlV9Hd+/e7bozMyIiQiNHjpTD4Sgw/gsuuMB1jHXv3l3ff/+92zRLlixxnbfCwsLUv39/bd26tdAyLIm2bdtq1qxZSkpK0ksvveQ27r///tOoUaMUFRXlOp7efvttt2nyHwdcuHCh/u///k/R0dEKCQnRwIEDPcpfKvuyK02bWZrt+eijj/TEE0/onHPOUVBQkHr37q3du3cXuD39+vVT9erVFRISonPPPVcvvPCCpJP/ZLJYLNqwYYPHfNOnT5efn5/HcVIa+fV5/fr16t69u+x2u+vclZWVpccee0xNmjSRzWZTvXr19NBDDxXYz19Jjp0zvTYAUPnwr2EAPnfTTTfp//7v//T999/r1ltvlSRt3bpV3bp1U926dTVhwgSFhIToo48+0lVXXaVFixZp0KBBbssYO3asqlWrpsmTJ2vHjh169dVXtX//ftfF4KxZs3TXXXcpNDTUlbCIiopyW8Zdd92l6tWr67HHHtO+ffs0a9YsjR07VgsXLiwy/qVLl+ryyy9Xo0aNNHnyZGVkZOjFF19Ut27d9Mcffyg2Nla33Xab6tatq+nTp7seczh9/afq37+/Fi9erCeeeMJj3IkTJ9SvXz8NHTpU119/vT766CPdcccdCgwM1KhRoySdvFA+cOCA2rdvX+Dyd+3apWuvvVa33367RowYoblz5+qaa67Rt99+q0svvVSSdOjQIXXt2lUOh0N33323atasqXfeeUcDBw7UJ598okGDBqlly5aaOnWqHn30UY0ePVoXXXSRJKlr167Kzs5Wnz59lJWVpbvuukvR0dH677//9PXXXyspKUkRERGFbv/kyZM1Y8YM3XLLLbrggguUkpKidevW6Y8//nDF9+eff+qiiy5SQECARo8erdjYWO3Zs0dfffWVR7ldc801atq0qaZPny7DMIrYm9JPP/2khQsX6u6775bNZtMrr7yivn376rffflObNm00ePBg7dy5Ux9++KGef/551apVS5IUGRmprVu36oorrtC5556rqVOnymazaffu3R4/kAqyePFiXXvttYqLi9OMGTN04sQJ3Xzzzapbt67HtC+88IIGDhyoYcOGKTs7WwsWLNA111yjr7/+Wv3793dNd8stt+j999/XDTfcoK5du2rZsmVu4/Nt2LBBffv2VUxMjKZMmaK8vDxNnTpVkZGRHtM+8cQTmjRpkoYOHapbbrlFR44c0Ysvvqju3btrw4YNqlatmh5++GElJyfr33//1fPPPy9JCg0NlSS98cYbuvvuuzVkyBBXkuTPP//U2rVrdcMNN7itq3379m5l179/f02aNEkbN24s8NGn4tqB0vrll1/06aef6s4771RYWJhmz56tq6++WgcOHFDNmjVLvbw9e/ZIkse8H3zwgVJTU3XbbbfJYrHo6aef1uDBg/X3338rICBA0slE599//62RI0cqOjpaW7du1euvv66tW7dqzZo1Hts3dOhQxcbGasaMGVqzZo1mz56tEydO6N1333WbbtmyZfroo480duxY1apVyyP5me/gwYO64IILlJSUpNGjR6tFixb677//9Mknn8jhcCgwMFB///23Pv/8c11zzTVq2LChDh06pNdee009evTQtm3bVKdOnSLbDOnkPxlGjhypjh07asaMGTp06JBeeOEF/frrr676lS83N1d9+vTRhRdeqGeffbbIOzkaNGig1atXa8uWLcW+GKIkdTzfiRMn1LdvXw0ePFhDhw7VJ598ovHjxysuLk6XX355sdu7bNkyXX755Tr//PP12GOPyWq1au7cubr44ov1888/64ILLvDYrw0bNtSMGTP0xx9/6M0331Tt2rX11FNPuaaZMmWKJk+erK5du2rq1KkKDAzU2rVrtWzZMl122WWSTj7CNWLECPXp00dPPfWUHA6HXn31VV144YXasGFDofWgJIYMGaKbb75Z33//vastPnTokDp37uxKgkZGRmrJkiW6+eablZKS4vFo7xNPPCGLxaLx48fr8OHDmjVrli655BJt3LjRdSd1eZRdSdvM0m7Pk08+KavVqnHjxik5OVlPP/20hg0bprVr17qm+eGHH3TFFVcoJiZG99xzj6Kjo7V9+3Z9/fXXuueeezRkyBCNGTNG8+fP13nnnee2/Pnz56tnz54Fni9K49ixY7r88st13XXX6cYbb1RUVJScTqcGDhyoX375RaNHj1bLli21efNmPf/889q5c6c+//xz1/wlOXbO5toAQCVkAEA5mzt3riHJ+P333wudJiIiwjjvvPNc33v37m3ExcUZmZmZrmFOp9Po2rWr0bRpU49ln3/++UZ2drZr+NNPP21IMr744gvXsNatWxs9evQoNL5LLrnEcDqdruH33Xef4efnZyQlJRW5fe3atTNq165tHDt2zDVs06ZNhtVqNYYPH+4atnz5ckOS8fHHHxe5PMMwjG+//daQZPz7779uw3v06GFIMp577jnXsKysLFcM+WWwdOlSQ5Lx1VdfeSy7QYMGhiRj0aJFrmHJyclGTEyM2z649957DUnGzz//7BqWmppqNGzY0IiNjTXy8vIMwzCM33//3ZBkzJ071209GzZsKNH25pf/qdq2bWv079+/yPm6d+9uhIWFGfv373cbfuo+fOyxxwxJxvXXX+8xf/64U0kyJBnr1q1zDdu/f78RFBRkDBo0yDXsmWeeMSQZe/fudZv/+eefNyQZR44cKTL2ESNGeNTFuLg445xzzjFSU1Ndw1asWGFIMho0aOA2rcPhcPuenZ1ttGnTxrj44otdwzZu3GhIMu688063aW+44QZDkvHYY4+5hg0YMMCw2+3Gf//95xq2a9cuw9/f362M9u3bZ/j5+RlPPPGE2zI3b95s+Pv7uw3v37+/R9yGYRhXXnml0bp1a4/hBRk9erQRHBzsNiwmJsZj/aVpBwpSWF0IDAw0du/e7Rq2adMmQ5Lx4osvFrm8vXv3GpKMKVOmGEeOHDESExONFStWGOedd57bsZc/Xc2aNY3jx4+75v/iiy88jt/T97lhGMaHH35oSDJWrlzpsS0DBw50m/bOO+80JBmbNm1y20ar1Wps3brVY9mn15Hhw4cbVqu1wHY8/5jLzMx0tQunloXNZjOmTp3qGlZYm5GdnW3Url3baNOmjZGRkeEa/vXXXxuSjEcffdQ1bMSIEYYkY8KECR7xFOT77783/Pz8DD8/P6NLly7GQw89ZHz33Xdu9cUwSlfH89vjd9991zUsKyvLiI6ONq6++upit9fpdBpNmzY1+vTp49ZuORwOo2HDhsall17qGpa/X0eNGuW2jEGDBhk1a9Z0fd+1a5dhtVqNQYMGeeyL/HWkpqYa1apVM2699Va38YmJiUZERITH8NOV5FzWtm1bo3r16q7vN998sxETE2McPXrUbbrrrrvOiIiIcNXv/GXXrVvXSElJcU330UcfGZKMF154wbUtZV12pWkzS7s9LVu2NLKyslzTvfDCC4YkY/PmzYZhGEZubq7RsGFDo0GDBsaJEyfclnnq9l1//fVGnTp13PbtH3/8UWD9KsqYMWM82rz8+jxnzhy34e+9955htVrdrgUMwzDmzJljSDJ+/fVXwzBKfuyU9NoAQNXAI3sATCE0NNT1tr3jx49r2bJlGjp0qFJTU3X06FEdPXpUx44dU58+fbRr1y6P29JHjx7tupNAku644w75+/sX+XjP6UaPHu12l8FFF12kvLw87d+/v9B5EhIStHHjRsXHx6tGjRqu4eeee64uvfTSUq3/VD179lRISEiB8/v7++u2225zfQ8MDNRtt92mw4cPa/369ZLkeoynevXqBS6/Tp06bneZ5T/etGHDBiUmJkqSvvnmG11wwQWuR9ykk/tp9OjR2rdvn7Zt21bkNuT/l/O7774r8JGSolSrVk1bt27Vrl27Chx/5MgRrVy5UqNGjVL9+vXdxhV0J8ztt99e4nV36dJF559/vut7/fr1deWVV+q7775TXl5esXFL0hdffCGn01nidR48eFCbN2/W8OHDXXcSSVKPHj0UFxfnMf2pfa2dOHFCycnJuuiii/THH3+4hufXnbvvvttt3tP/c5+Xl6elS5fqqquuUp06dVzDmzRpossvv9xt2k8//VROp1NDhw51HZdHjx5VdHS0mjZtquXLlxe7rdWqVdO///7r8UhaQapXr66MjAy3+tOvX79CH2cti3bgVJdccokaN27s+n7uuecqPDxcf//9d4nmf+yxxxQZGano6Gj17NlTe/bs0VNPPaXBgwe7TXfttde6Hav5d9Gcup5T93lmZqaOHj3q6h/u1P2eb8yYMW7f8zvtPr0sevTooVatWhW5HU6nU59//rkGDBjg1g9gvvxjzmazuV7EkJeXp2PHjrkeWy0oxtOtW7dOhw8f1p133unWh1X//v3VokWLAvf7HXfcUexypZNvL129erUGDhyoTZs26emnn1afPn1Ut25dt0fBS1vHQ0ND3frhCQwM1AUXXFCiOrJx40bt2rVLN9xwg44dO+ZaV3p6unr37q2VK1d6tCOnt2UXXXSRjh07ppSUFEknH9V2Op169NFHPV6Kkb+ffvjhByUlJen6669320Y/Pz916tSpRMdxcU49pxuGoUWLFmnAgAEyDMNtnX369FFycrJH/Rg+fLjCwsJc34cMGaKYmBhX/S2Psitpm3km2zNy5EgFBga6rVv63zG+YcMG7d27V/fee6/HY6WnntOGDx+ugwcPuu2j+fPnKzg4WFdffbXOls1m08iRI92Gffzxx2rZsqVatGjhtq35jyDnx1LSY+dsrg0AVD48sgfAFNLS0lz9eOzevVuGYWjSpEmaNGlSgdMfPnzY7db0pk2buo0PDQ1VTEyMq1+fkjg9sZH/A7GoPmjyk1XNmzf3GNeyZUt99913RXa0WxibzaaLL75Yixcvdj3GmK9OnToey2vWrJmkk6+bP7UTc6OQx9OaNGnikbg5dRnR0dHav3+/OnXqVOB2SSe3vahHXxo2bKj7779fM2fO1Pz583XRRRdp4MCBuvHGG4u9JX/q1Km68sor1axZM7Vp00Z9+/bVTTfd5HoTY/5FfHGP3pwaS0mdXpekk2XjcDh05MgRRUdHFzrvtddeqzfffFO33HKLJkyYoN69e2vw4MEaMmRIkW9MzK9HTZo08RjXpEkTjx83X3/9tR5//HFt3LjRrQ+PU/fp/v37ZbVa3RIqkmddPXz4sDIyMgpd96l27dolwzAKLCNJbsmgwowfP15Lly7VBRdcoCZNmuiyyy7TDTfcoG7dunlMm19/T92ufv36ae7cuTp27JjHo29l0Q6c6vQ2QTrZLpSkXyrpZILsmmuukdVqVbVq1Vz9NBW3noLanuPHj2vKlClasGCBRyfcBfW7cnpZNG7cWFar1aMsSnJsHDlyRCkpKcUeb06nUy+88IJeeeUV7d271y2BW5JHHItqT1u0aKFffvnFbZi/v7/OOeecYpebr2PHjvr000+VnZ2tTZs26bPPPtPzzz+vIUOGaOPGjWrVqlWp6/g555zj0ZZWr15df/75Z7Hx5CfcR4wYUeg0ycnJbsnKoupKeHi49uzZI6vVWmSSMX+9hb0FLzw8vNjYi5OWluZKKB05ckRJSUl6/fXX9frrrxc4/el1+vTyt1gsatKkiav+lkfZlbTNPJPtKe4Yz3+ct7hj7NJLL1VMTIzmz5+v3r17y+l06sMPP9SVV17plsA7U3Xr1nVLnEkny3r79u0FPsIt/W9bS3rsnM21AYDKh4QUAJ/7999/lZyc7Prxm/9fzXHjxqlPnz4FzlPQj+ez5efnV+DwwpI65a1///564IEHlJ2d7XGBWJz8H38l/eFcXp577jnFx8friy++0Pfff6+7777b1adNUT8ku3fvrj179rjme/PNN/X8889rzpw5uuWWW0odh7fe3hgcHKyVK1dq+fLlWrx4sb799lstXLhQF198sb7//vtC61hp/Pzzzxo4cKC6d++uV155RTExMQoICNDcuXM9OgYva06nUxaLRUuWLClwW069u6swLVu21I4dO/T111/r22+/1aJFi/TKK6/o0Ucf1ZQpU9ymPXHihOx2u9v+u/TSS+Xn56dvv/22yE6sy8LZtglNmzbVJZdcUibrGTp0qFatWqUHH3xQ7dq1U2hoqJxOp/r27Vuiu/EK60OrLI+N6dOna9KkSRo1apSmTZumGjVqyGq16t577y3VHYMldeodWaURGBiojh07qmPHjmrWrJlGjhypjz/+WI899lip6/jZ1JH8MnnmmWcK7BOtrNd3+nrfe++9AhPsZ/vGyZycHO3cudOVXMlf34033lhoAin/nw0l5auyO3Xdpdmeslq3n5+fbrjhBr3xxht65ZVX9Ouvv+rgwYPFvi2vpApqD5xOp+Li4jRz5swC56lXr55rupIeO2d6bQCg8iEhBcDn3nvvPUlyJZ8aNWok6eR/00ryY046+Z+5Xr16ub6npaUpISFB/fr1cw07k06Ni9OgQQNJ0o4dOzzG/fXXX6pVq1ap747K169fP91+++366aefXB15Sycf7zr9rqudO3dKkqsj2hYtWkgq+G1e0v/uQju1TE5fRoMGDQrdrvzxUvHlGhcXp7i4OD3yyCNatWqVunXrpjlz5ujxxx8vcr4aNWpo5MiRGjlypNLS0tS9e3dNnjxZt9xyi6uObNmypchlnImCHhPcuXOn7Ha76z/ERW2z1WpV79691bt3b82cOVPTp0/Xww8/rOXLlxdan/PLsqC3Lp0+bNGiRQoKCtJ3333ndrfN3LlzPZbpdDq1Z88et//wn75Pa9euraCgoBKtu3HjxjIMQw0bNnTdUVeYosooJCRE1157ra699lplZ2dr8ODBeuKJJzRx4kS3R7X27t3ruiMvX1hYmC666CJ98803HgmpkrQDFdGJEyf0448/asqUKXr00Uddwwt7pDV/3Kl3P+3evVtOp/OMOquOjIxUeHh4scfbJ598ol69eumtt95yG56UlOTq/F8qvG6c2p6efvfOjh07XOPLUv4jiAkJCZJKV8dLqrDtzb8TJzw8vMTnuuI0btxYTqdT27ZtKzRRk7/e2rVrl9l6T/XJJ58oIyPDdU7Pf2NdXl5eqc7ppzIMQ7t373Ylesqj7EraZp7J9hQnf3u2bNlS7DKHDx+u5557Tl999ZWWLFmiyMjIQv95V1axbdq0Sb179y6yXS/tsXOm1wYAKhf6kALgU8uWLdO0adPUsGFD14/L2rVrq2fPnnrttddcPxJOdeTIEY9hr7/+unJyclzfX331VeXm5rr1gRMSEqKkpKQyjT8mJkbt2rXTO++847bsLVu26Pvvvz+rH8L16tVTXFycR78pubm5eu2111zfs7Oz9dprrykyMtLV91HdunVVr149rVu3rsBlHzx4UJ999pnre0pKit599121a9fO9R/zfv366bffftPq1atd06Wnp+v1119XbGys65GQ/MTY6WWbkpKi3Nxct2FxcXGyWq0Fvir6VKe/yj40NFRNmjRxzRcZGanu3bvr7bff1oEDB9ymPds72lavXu32iNw///yjL774Qpdddpnrv76FbfPx48c9lpf/o7Coba5Tp47atGmjd999V2lpaa7hP/30kzZv3uw2rZ+fnywWi9vjUPv27XN705EkV92fPXu22/BZs2Z5LO+SSy7R559/roMHD7qG7969W0uWLHGbdvDgwfLz89OUKVM8ytkwDLf9FhISUuCjZKfv28DAQLVq1UqGYbgdw9LJvpHy30Z2qv79++vbb7/16NOrJO1ARZRf704v89P35alefvllt+8vvviiJJ1RWVitVl111VX66quvCmxT8uPy8/PziPHjjz/26POvsOOnQ4cOql27tubMmeN2vCxZskTbt28v8G1nJbV8+fIC24b8foPyExClqeMlVdj2nn/++WrcuLGeffZZt+M+X0HnuuJcddVVslqtmjp1qsddafnb06dPH4WHh2v69Okex9yZrjffpk2bdO+996p69equfsz8/Px09dVXa9GiRQUmNQta37vvvuvqg0o6meRKSEhw1d/yKLvStJml3Z7itG/fXg0bNtSsWbM86snp9fDcc8/VueeeqzfffFOLFi3Sddddd9Z3tRVl6NCh+u+///TGG294jMvIyFB6erqkkh87Z3NtAKDy4Q4pAF6zZMkS/fXXX8rNzdWhQ4e0bNky/fDDD2rQoIG+/PJLtzsjXn75ZV144YWKi4vTrbfeqkaNGunQoUNavXq1/v33X23atMlt2dnZ2erdu7eGDh2qHTt26JVXXtGFF16ogQMHuqY5//zz9eqrr+rxxx9XkyZNVLt27UL70CiNZ555Rpdffrm6dOmim2++WRkZGXrxxRcVERGhyZMnn9Wy+/Xrp0WLFrldENepU0dPPfWU9u3bp2bNmmnhwoXauHGjXn/9dbf+Ta688kp99tlnHndCSSf7RLr55pv1+++/KyoqSm+//bYOHTrkdpfNhAkT9OGHH+ryyy/X3XffrRo1auidd97R3r17tWjRItejMo0bN1a1atU0Z84chYWFKSQkRJ06ddKmTZs0duxYXXPNNWrWrJlyc3P13nvvuS7mi9KqVSv17NlT559/vmrUqKF169bpk08+0dixY13TzJ49WxdeeKHat2+v0aNHq2HDhtq3b58WL16sjRs3nnGZt2nTRn369NHdd98tm82mV155RZLcHifLT/w9/PDDuu666xQQEKABAwZo6tSpWrlypfr3768GDRro8OHDeuWVV3TOOee4dQ5fkOnTp+vKK69Ut27dNHLkSJ04cUIvvfSS2rRp4/aDq3///po5c6b69u2rG264QYcPH9bLL7+sJk2auPVb065dO11//fV65ZVXlJycrK5du+rHH38s8E6oyZMn6/vvv1e3bt10xx13KC8vz7XuU8uycePGevzxxzVx4kTt27dPV111lcLCwrR371599tlnGj16tMaNG+cqo4ULF+r+++9Xx44dFRoaqgEDBuiyyy5TdHS0unXrpqioKG3fvl0vvfSS+vfv79YHyvr163X8+HFdeeWVHvH269dPDzzwgNasWePW91RJ2oGKKDw8XN27d9fTTz+tnJwc1a1bV99//32hd0BKJ+8uGzhwoPr27avVq1e7XmXftm3bM4ph+vTp+v7779WjRw/Xq98TEhL08ccf65dfflG1atV0xRVXaOrUqRo5cqS6du2qzZs3a/78+a47GvMV1mY0bNhQTz31lEaOHKkePXro+uuv16FDh/TCCy8oNjZW99133xnFLp3s1N3hcGjQoEFq0aKFsrOztWrVKi1cuFCxsbGujpxLU8dLqqjtffPNN3X55ZerdevWGjlypOrWrav//vtPy5cvV3h4uL766qtSratJkyZ6+OGHNW3aNF100UUaPHiwbDabfv/9d9WpU0czZsxQeHi4Xn31Vd10001q3769rrvuOkVGRurAgQNavHixunXrppdeeqnYdf3888/KzMx0dWD/66+/6ssvv1RERIQ+++wzt8cBn3zySS1fvlydOnXSrbfeqlatWun48eP6448/tHTpUo9kfo0aNXThhRdq5MiROnTokGbNmqUmTZq4+lS0Wq1lXnalaTNLuz3FsVqtevXVVzVgwAC1a9dOI0eOVExMjP766y9t3bpV3333ndv0w4cPd9XDsnpcrzA33XSTPvroI91+++1avny5unXrpry8PP3111/66KOP9N1336lDhw4lPnaWLVt2xtcGACqhcn2HHwAY/3sle/4nMDDQiI6ONi699FLjhRdecHu186n27NljDB8+3IiOjjYCAgKMunXrGldccYXxySefeCz7p59+MkaPHm1Ur17dCA0NNYYNG2YcO3bMbXmJiYlG//79jbCwMEOS0aNHD7dlnP468/zXNS9fvrzYbVy6dKnRrVs3Izg42AgPDzcGDBhgbNu2rcDlleZVxytXrjQkGTt27DAM4+RrmVu3bm2sW7fO6NKlixEUFGQ0aNDAeOmllzzmzX8V9Omvam7QoIHRv39/47vvvjPOPfdcw2azGS1atCgwrj179hhDhgwxqlWrZgQFBRkXXHCB8fXXX3tM98UXXxitWrUy/P39Xa+f/vvvv41Ro0YZjRs3NoKCgowaNWoYvXr1MpYuXeo2b375n+rxxx83LrjgAqNatWpGcHCw0aJFC+OJJ57weEX7li1bjEGDBrnia968uTFp0iTX+PzXfR85csQj5vxxp5JkjBkzxnj//feNpk2bGjabzTjvvPMKrAPTpk0z6tata1itVkOSsXfvXuPHH380rrzySqNOnTpGYGCgUadOHeP66683du7c6TbviBEjXPXvVAsWLDBatGhh2Gw2o02bNsaXX35pXH311UaLFi3cpnvrrbdc8bVo0cKYO3dugduTkZFh3H333UbNmjWNkJAQY8CAAcY///zj8QpzwzCMH3/80TjvvPOMwMBAo3Hjxsabb75pPPDAA0ZQUJBHnIsWLTIuvPBCIyQkxAgJCTFatGhhjBkzxlVPDcMw0tLSjBtuuMGoVq2aIclo0KCBYRiG8dprrxndu3c3atasadhsNqNx48bGgw8+aCQnJ7utY/z48Ub9+vXdXnl+qkaNGhkTJ040DKN07UBBiqoLp2vQoIExYsSIIpe3d+9eQ5LxzDPPnPF0p++jf//911XXIyIijGuuucY4ePCgx3T527Jt2zZjyJAhRlhYmFG9enVj7NixRkZGRom2saD1G4Zh7N+/3xg+fLgRGRlp2Gw2o1GjRsaYMWNcr7PPzMw0HnjgASMmJsYIDg42unXrZqxevdro0aOHR30vqM3It3DhQuO8884zbDabUaNGDWPYsGHGv//+6zb/iBEjjJCQkEJK1tOSJUuMUaNGGS1atDBCQ0ONwMBAo0mTJsZdd91lHDp0yGP6ktTx/Pb4dCNGjHDV95Js74YNG4zBgwe7jokGDRoYQ4cONX788UfXNIW1Zfl1f+/evW7D3377bVcZVq9e3ejRo4fxww8/uE2zfPlyo0+fPkZERIQRFBRkNG7c2IiPjzfWrVtXZFnmn8vyPwEBAUZkZKTRvXt344knnjAOHz5c4HyHDh0yxowZY9SrV88ICAgwoqOjjd69exuvv/66x7I//PBDY+LEiUbt2rWN4OBgo3///sb+/fs9llnWZVeaNrM023P6+TX/2D+1HhiGYfzyyy/GpZdeaoSFhRkhISHGueeea7z44ose252QkGD4+fkZzZo1K7CsizNmzBiPNq+w+mwYhpGdnW089dRTRuvWrV116vzzzzemTJni0XYXd+yU9NoAQNVgMQwf9dYLAGVg3rx5GjlypH7//fcCX0de0eXl5alWrVp67LHHPF49XRK9e/dWnTp1XP10mVH+PjTD6chisWjMmDElujvgbMTHx2vfvn1asWJFsdO2a9dOkZGR+uGHH8o1poJcddVV2rp1a5F9FZWHrKwsxcbGasKECbrnnnsKnOauu+7Szz//fFZ3wwEwlxUrVqhXr176+OOPNWTIEF+HY1pHjx5VTEyMHn300ULfRgwAFQF9SAGAifn5+Wn27Nln/NaZ6dOna+HCha7XqcO8cnJyPPrVWLFihTZt2qSePXuW+/ozMjLcvu/atUvffPONV9Z9urlz5yogIEC33357odOMHj1agwYNKrAPHACozObNm6e8vDzddNNNvg4FAM4KfUgBgMmdzQVnp06dlJ2dXYbRoLz8999/uuSSS3TjjTeqTp06+uuvvzRnzhxFR0cXmZgpK40aNVJ8fLwaNWqk/fv369VXX1VgYKAeeuihcl/36W6//fZitzn/DU0AUFUsW7ZM27Zt0xNPPKGrrrrqjN6aCQBmQkIKAAATqF69us4//3y9+eabOnLkiEJCQtS/f389+eSTqlmzZrmvv2/fvvrwww+VmJgom82mLl26aPr06WratGm5rxsAULypU6dq1apV6tatm+vNmQBQkdGHFAAAAAAAALyKPqQAAAAAAADgVSSkAAAAAAAA4FWVvg8pp9OpgwcPKiwsTBaLxdfhAAAAAAAAmIZhGEpNTVWdOnVktXrvvqVKn5A6ePCg6tWr5+swAAAAAAAATOuff/7ROeec47X1VfqEVFhYmKSTBRseHu7jaAAAAAAAAMwjJSVF9erVc+VPvKXSJ6TyH9MLDw8nIQUAAAAAAFAAb3dzRKfmAAAAAAAA8CoSUgAAAAAAAPAqElIAAAAAAADwqkrfhxQAAAAAoHLJy8tTTk6Or8MAKoSAgAD5+fn5OgwPJKQAAAAAABWCYRhKTExUUlKSr0MBKpRq1aopOjra6x2XF4WEFAAAAACgQshPRtWuXVt2u91UP64BMzIMQw6HQ4cPH5YkxcTE+Dii/yEhBQAAAAAwvby8PFcyqmbNmr4OB6gwgoODJUmHDx9W7dq1TfP4Hp2aAwAAAABML7/PKLvd7uNIgIon/7gxU99rPk1IrVy5UgMGDFCdOnVksVj0+eefu8bl5ORo/PjxiouLU0hIiOrUqaPhw4fr4MGDvgsYAAAAVUJ6Vq4OJmdpz9EMJSRnKT0r19chAfj/eEwPKD0zHjc+fWQvPT1dbdu21ahRozR48GC3cQ6HQ3/88YcmTZqktm3b6sSJE7rnnns0cOBArVu3zkcRAwAAoLI7lp6jt1YnakuCwzUsLsauUV2iVTMkwIeRAQBQefj0DqnLL79cjz/+uAYNGuQxLiIiQj/88IOGDh2q5s2bq3PnznrppZe0fv16HThwwAfRAgAAoLJLz8r1SEZJ0uYEh95encidUgCqpNdff1316tWT1WrVrFmzChw2efJktWvXzjVPfHy8rrrqKtf3nj176t577/Vq3PlWrFghi8Xik7cz7tu3TxaLRRs3bvT6us2uQvUhlZycLIvFomrVqhU6TVZWllJSUtw+AAAAQEkkZ+Z5JKPybU5wKDkzz8sRAajo5syZo7CwMOXm/i+hnZaWpoCAAPXs2dNt2vzEyZ49eyRJsbGxslgsWrBggcdyW7duLYvFonnz5rmG5U9/6uecc845q/hTUlI0duxYjR8/Xv/9959Gjx5d4LBx48bpxx9/LHQ5n376qaZNm1bi9foyiXSmTk/CoWgVJiGVmZmp8ePH6/rrr1d4eHih082YMUMRERGuT7169bwYJQAAACqyjBznWY0HgNP16tVLaWlpbl3P/Pzzz4qOjtbatWuVmZnpGr58+XLVr19fjRs3dg2rV6+e5s6d67bMNWvWKDExUSEhIR7rmzp1qhISElyfDRs2nFX8Bw4cUE5Ojvr376+YmBjZ7fYCh4WGhhb59sMaNWooLCzsrGLB/2RnZ/s6hLNWIRJSOTk5Gjp0qAzD0KuvvlrktBMnTlRycrLr888//3gpSgAAAFR0wQFFXx4XNx5AxZDjSFfG4USlHtirjMOHlONIL7d1NW/eXDExMVqxYoVr2IoVK3TllVeqYcOGWrNmjdvwXr16uc0/bNgw/fTTT26/bd9++20NGzZM/v6e3UKHhYUpOjra9YmMjCwyvvHjx6tZs2ay2+1q1KiRJk2a5HoT27x58xQXFydJatSokeuOrNOH7du3z+ORvdOd/sjee++9pw4dOrjiveGGG3T48GFJJx9zyy+H6tWry2KxKD4+XpLkdDo1Y8YMNWzYUMHBwWrbtq0++eQTt3V98803atasmYKDg9WrVy/t27evyDKQpJkzZ7peqlavXj3deeedSktLc40vaPtmzZql2NhY1/h33nlHX3zxhevutFP3+d9//61evXrJbrerbdu2Wr16tduyFi1apNatW8tmsyk2NlbPPfec2/jY2FhNmzZNw4cPV3h4uEaPHq3s7GyNHTtWMTExCgoKUoMGDTRjxoxit9UsTH9GzU9G7d+/Xz/88EORd0dJks1mU3h4uNsHAAAAKImIID/FxRT8Svm4GLsigvy8HBGAspaVdEK7PpirTc9O09aXntWmZ6dq9wdzlZV0otzW2atXLy1fvtz1ffny5erZs6d69OjhGp6RkaG1a9d6JKSioqLUp08fvfPOO5JOvgBs4cKFGjVqVJnEFhYWpnnz5mnbtm164YUX9MYbb+j555+XJF177bVaunSpJOm3335TQkKCrrnmGo9hZ/JkUk5OjqZNm6ZNmzbp888/1759+1xJp3r16mnRokWSpB07dighIUEvvPCCpJNPRb377ruaM2eOtm7dqvvuu0833nijfvrpJ0nSP//8o8GDB2vAgAHauHGjbrnlFk2YMKHYeKxWq2bPnq2tW7fqnXfe0bJly/TQQw+VeHvGjRunoUOHqm/fvq6707p27eoa//DDD2vcuHHauHGjmjVrpuuvv971GOf69es1dOhQXXfdddq8ebMmT56sSZMmuT2OKUnPPvus2rZtqw0bNmjSpEmaPXu2vvzyS3300UfasWOH5s+f70qQVQQ+fctecfKTUbt27dLy5cuLvP0PAAAAOFshNn+N6hKtt1cnavNpb9m7uUu0QmymvnwGUIwcR7r2fDJfKTu3uw1P3rldf38yX01uGKkAu+djcGerV69euvfee5Wbm6uMjAxt2LBBPXr0UE5OjubMmSNJWr16tbKysjwSUpI0atQoPfDAA3r44Yf1ySefqHHjxoXejTR+/Hg98sgjru/Tp0/X3XffXWhsp04bGxurcePGacGCBXrooYcUHBzs+h0eGRmp6OhoSSpwWGmdmlBr1KiRZs+erY4dOyotLU2hoaGqUaOGJKl27dqufqSzsrI0ffp0LV26VF26dHHN+8svv+i1115Tjx499Oqrr6px48auO4yaN2+uzZs366mnnioynlPv3oqNjdXjjz+u22+/Xa+88kqJtic0NFTBwcHKysoqsEzGjRun/v37S5KmTJmi1q1ba/fu3WrRooVmzpyp3r17a9KkSZKkZs2aadu2bXrmmWdcSTpJuvjii/XAAw+4vh84cEBNmzbVhRdeKIvFogYNGpQoVrPw6Rk1LS1Nu3fvdn3fu3evNm7cqBo1aigmJkZDhgzRH3/8oa+//lp5eXlKTEyUdPLZ08DAQF+FDQAAgEqsZkiA7rwoRsmZecrIcSo4wKqIID+SUUAlkJuW6pGMype8c7ty01LLJSHVs2dPpaen6/fff9eJEyfUrFkzRUZGqkePHho5cqQyMzO1YsUKNWrUSPXr1/eYv3///rrtttu0cuVKvf3220XeHfXggw+6JTFq1aolSbr99tv1/vvvu4bnP462cOFCzZ49W3v27FFaWppyc3O98qTR+vXrNXnyZG3atEknTpyQ03myj74DBw6oVatWBc6ze/duORwOXXrppW7Ds7Ozdd5550mStm/frk6dOrmNz09eFWXp0qWaMWOG/vrrL6WkpCg3N1eZmZlyOByy2wu+c7Y0zj33XNffMTExkqTDhw+rRYsW2r59u6688kq36bt166ZZs2YpLy9Pfn4n787t0KGD2zTx8fG69NJL1bx5c/Xt21dXXHGFLrvssrOO1Vt8elZdt26dW/b3/vvvlySNGDFCkydP1pdffilJHpnf/NsbAQAAgPIQYvMnAQVUQrmZGcWMzyxy/Jlq0qSJzjnnHC1fvlwnTpxQjx49JEl16tRRvXr1tGrVKi1fvlwXX3xxgfP7+/vrpptu0mOPPaa1a9fqs88+K3RdtWrVUpMmTTyGT506VePGjXMbtnr1ag0bNkxTpkxRnz59FBERoQULFnj0X1TW0tPT1adPH/Xp00fz589XZGSkDhw4oD59+hTZWXd+Em3x4sWqW7eu2zibzXbG8ezbt09XXHGF7rjjDj3xxBOqUaOGfvnlF918883Kzs6W3W6X1WqVYRhu8+X3tVUSAQEBrr8tFoskuZJwJXV6J/bt27fX3r17tWTJEi1dulRDhw7VJZdc4tGnlln59Czbs2dPjx16qqLGAQAAAABQGv5BwcWMDyq3dffq1UsrVqzQiRMn9OCDD7qGd+/eXUuWLNFvv/2mO+64o9D5R40apWeffVbXXnutqlevXur1165dW7Vr13YbtmrVKjVo0EAPP/ywa9j+/ftLvezS+uuvv3Ts2DE9+eSTrv6nTn0LoSTXU1F5eXmuYa1atZLNZtOBAwdcSb3TtWzZ0nVzS75TO44vyPr16+V0OvXcc8/Jaj3Z1fZHH33kNk1kZKQSExNlGIYrobRx40aPmE+Nt6RatmypX3/91W3Yr7/+qmbNmrnujipMeHi4rr32Wl177bUaMmSI+vbtq+PHj7seeTQz/u0DAAAAAKgS/EPDFNGspZILeGwvollL+YeGldu6e/XqpTFjxignJ8ctmdKjRw+NHTtW2dnZBfYfla9ly5Y6evRomTw+lq9p06Y6cOCAFixYoI4dO2rx4sVF3n1VVurXr6/AwEC9+OKLuv3227VlyxZNmzbNbZoGDRrIYrHo66+/Vr9+/RQcHKywsDCNGzdO9913n5xOpy688EIlJyfr119/VXh4uEaMGKHbb79dzz33nB588EHdcsstWr9+vUfn4Kdr0qSJcnJy9OKLL2rAgAH69ddfXX175evZs6eOHDmip59+WkOGDNG3336rJUuWuD3eGBsbq++++047duxQzZo1FRERUaLyeOCBB9SxY0dNmzZN1157rVavXq2XXnqp2P6rZs6cqZiYGJ133nmyWq36+OOPFR0d7epzy+xM/5Y9AAAAAADKQoA9RI2GDFNEs5ZuwyOatVSjIcPKpf+ofL169VJGRoaaNGmiqKgo1/AePXooNTVVzZs3d/UtVJiaNWsqOLjou7xKY+DAgbrvvvs0duxYtWvXTqtWrXJ1rF2eIiMjNW/ePH388cdq1aqVnnzyST377LNu09StW1dTpkzRhAkTFBUVpbFjx0qSpk2bpkmTJmnGjBlq2bKl+vbtq8WLF6thw4aSTia7Fi1apM8//1xt27bVnDlzNH369CLjadu2rWbOnKmnnnpKbdq00fz58zVjxgy3aVq2bKlXXnlFL7/8stq2bavffvvN4xHIW2+9Vc2bN1eHDh0UGRnpcddTYdq3b6+PPvpICxYsUJs2bfToo49q6tSpbn2BFSQsLExPP/20OnTooI4dO2rfvn365ptvXHd5mZ3FqOTPxaWkpCgiIkLJycle6ZgNAAAAAFD2MjMztXfvXjVs2FBBZ/loXY4jXblpqcrNzJR/UJD8Q8PKNRkF+FpRx4+v8iY8sgcAAAAAqFIC7CEkoAAfqxj3cQEAAAAAAKDSICEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAABAFfP666+rXr16slqtmjVrVoHDJk+erHbt2rnmiY+P11VXXeX63rNnT917771ejTvfihUrZLFYlJSU5PV179u3TxaLRRs3bvT6uisTElIAAAAAAJSj+Ph4WSwWPfnkk27DP//8c1ksFq/Hk5KSorFjx2r8+PH677//NHr06AKHjRs3Tj/++GOhy/n00081bdq0Eq/Xl0mkM3V6Eg5lh4QUAAAAAADlLCgoSE899ZROnDjh61B04MAB5eTkqH///oqJiZHdbi9wWGhoqGrWrFnocmrUqKGwsDAvRl65ZWdn+zoEryIhBQAAAACoUtKzcnUwOUt7jmYoITlL6Vm55b7OSy65RNHR0ZoxY0aR0y1atEitW7eWzWZTbGysnnvuObfxsbGxmj59ukaNGqWwsDDVr19fr7/+uts048ePV7NmzWS329WoUSNNmjRJOTk5kqR58+YpLi5OktSoUSNZLJYCh+3bt8/jkb3Tnf7I3nvvvacOHTooLCxM0dHRuuGGG3T48GFJJx9z69WrlySpevXqslgsio+PlyQ5nU7NmDFDDRs2VHBwsNq2batPPvnEbV3ffPONmjVrpuDgYPXq1Uv79u0rshwlaebMmYqLi1NISIjq1aunO++8U2lpaa7xBW3frFmzFBsb6xr/zjvv6IsvvpDFYpHFYtGKFStc0/7999/q1auX7Ha72rZtq9WrV7stqyT7ctq0aRo+fLjCw8M1evRoZWdna+zYsYqJiVFQUJAaNGhQbJ2pqEhIAQAAAACqjGPpOXr55wRN+HKfpiw5oPFf7tMrPyfoWHpOua7Xz89P06dP14svvqh///23wGnWr1+voUOH6rrrrtPmzZs1efJkTZo0SfPmzXOb7rnnnlOHDh20YcMG3Xnnnbrjjju0Y8cO1/iwsDDNmzdP27Zt0wsvvKA33nhDzz//vCTp2muv1dKlSyVJv/32mxISEnTNNdd4DKtXr16ptzEnJ0fTpk3Tpk2b9Pnnn2vfvn2upFO9evW0aNEiSdKOHTuUkJCgF154QZI0Y8YMvfvuu5ozZ462bt2q++67TzfeeKN++uknSdI///yjwYMHa8CAAdq4caNuueUWTZgwodh4rFarZs+era1bt+qdd97RsmXL9NBDD5V4e8aNG6ehQ4eqb9++SkhIUEJCgrp27eoa//DDD2vcuHHauHGjmjVrpuuvv165uSeTmyXdl88++6zatm2rDRs2aNKkSZo9e7a+/PJLffTRR9qxY4fmz5/vSpBVNv6+DgAAAAAAAG9Iz8rVW6sTtSXB4TZ8c4JDb69O1J0XxSjEVn4/kwcNGqR27drpscce01tvveUxfubMmerdu7cmTZokSWrWrJm2bdumZ555xpXYkaR+/frpzjvvlHTybqjnn39ey5cvV/PmzSVJjzzyiGva2NhYjRs3TgsWLNBDDz2k4OBg12N4kZGRio6OlqQCh5XWqFGjXH83atRIs2fPVseOHZWWlqbQ0FDVqFFDklS7dm1Vq1ZNkpSVlaXp06dr6dKl6tKli2veX375Ra+99pp69OihV199VY0bN3bdYdS8eXNt3rxZTz31VJHxnHr3VmxsrB5//HHdfvvteuWVV0q0PaGhoQoODlZWVlaBZTJu3Dj1799fkjRlyhS1bt1au3fvVosWLUq8Ly+++GI98MADru8HDhxQ06ZNdeGFF8pisahBgwYlirUi4g4pAAAAAECVkJyZ55GMyrc5waHkzLxyj+Gpp57SO++8o+3bt3uM2759u7p16+Y2rFu3btq1a5fy8v4X27nnnuv622KxKDo62vVonCQtXLhQ3bp1U3R0tEJDQ/XII4/owIED5bA17tavX68BAwaofv36CgsLU48ePSSpyHXv3r1bDodDl156qUJDQ12fd999V3v27JF0slw6derkNl9+8qooS5cuVe/evVW3bl2FhYXppptu0rFjx+RwFFwHSuvU/RATEyNJrv1Q0n3ZoUMHt2ni4+O1ceNGNW/eXHfffbe+//77MonVjEhIAQAAAACqhIwc51mNLwvdu3dXnz59NHHixDNeRkBAgNt3i8Uip/Nk7KtXr9awYcPUr18/ff3119qwYYMefvjhcu8wOz09XX369FF4eLjmz5+v33//XZ999pmkojvrzu/TafHixdq4caPrs23bNo9+pEpj3759uuKKK3Tuuedq0aJFWr9+vV5++WW3eKxWqwzDcJsvv6+tkjh1P+S/LTF/P5RUSEiI2/f27dtr7969mjZtmjIyMjR06FANGTKkVMusKHhkDwAAAABQJQQHFH1PRnHjy8qTTz6pdu3auR6xy9eyZUv9+uuvbsN+/fVXNWvWTH5+fiVa9qpVq9SgQQM9/PDDrmH79+8/+6CL8ddff+nYsWN68sknXf1PrVu3zm2awMBASXK7Q6hVq1ay2Ww6cOCA646q07Vs2VJffvml27A1a9YUGc/69evldDr13HPPyWo9uV8/+ugjt2kiIyOVmJgowzBcCaWNGzd6xHxqvCV1NvsyPDxc1157ra699loNGTJEffv21fHjx12PPFYW3CEFAAAAAKgSIoL8FBdjL3BcXIxdEUElS/qcrbi4OA0bNkyzZ892G/7AAw/oxx9/1LRp07Rz50698847eumllzRu3LgSL7tp06Y6cOCAFixYoD179mj27NmuO5XKU/369RUYGKgXX3xRf//9t7788ktNmzbNbZoGDRrIYrHo66+/1pEjR5SWlqawsDCNGzdO9913n9555x3t2bNHf/zxh1588UW98847kqTbb79du3bt0oMPPqgdO3bogw8+8Ogc/HRNmjRRTk6OK5733ntPc+bMcZumZ8+eOnLkiJ5++mnt2bNHL7/8spYsWeI2TWxsrP7880/t2LFDR48eLfEdVGe6L2fOnKkPP/xQf/31l3bu3KmPP/5Y0dHRrj63KhMSUgAAAACAKiHE5q9RXaI9klJxMXbd3CW6XDs0P93UqVM9Hu9q3769PvroIy1YsEBt2rTRo48+qqlTp7p1gl2cgQMH6r777tPYsWPVrl07rVq1ytWxdnmKjIzUvHnz9PHHH6tVq1Z68skn9eyzz7pNU7duXU2ZMkUTJkxQVFSUxo4dK0maNm2aJk2apBkzZqhly5bq27evFi9erIYNG0o6mexatGiRPv/8c7Vt21Zz5szR9OnTi4ynbdu2mjlzpp566im1adNG8+fP14wZM9ymadmypV555RW9/PLLatu2rX777TePhNGtt96q5s2bq0OHDoqMjPS466kwZ7ovw8LC9PTTT6tDhw7q2LGj9u3bp2+++cZ1l1dlYjFOf2CykklJSVFERISSk5MVHh7u63AAAAAAAGcgMzNTe/fuVcOGDRUUFHRWy0rPylVyZp4ycpwKDrAqIsjPq8kowNuKOn58lTfhiAMAAAAAVCkhNn8SUICPVb57vgAAAAAAAGBqJKQAAAAAAADgVSSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAABWG0+n0dQhAhWPG44bXCgAAAAAATC8wMFBWq1UHDx5UZGSkAgMDZbFYfB0WYGqGYSg7O1tHjhyR1WpVYGCgr0NyISEFAAAAADA9q9Wqhg0bKiEhQQcPHvR1OECFYrfbVb9+fVmt5nlQjoQUAAAAAKBCCAwMVP369ZWbm6u8vDxfhwNUCH5+fvL39zfdHYUkpAAAAAAAFYbFYlFAQIACAgJ8HQqAs2Cee7UAAAAAAABQJZCQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV/k0IbVy5UoNGDBAderUkcVi0eeff+423jAMPfroo4qJiVFwcLAuueQS7dq1yzfBAgAAAAAAn0jPytXB5CztOZqhhOQspWfl+joknCWfJqTS09PVtm1bvfzyywWOf/rppzV79mzNmTNHa9euVUhIiPr06aPMzEwvRwoAAAAAAHzhWHqOXv45QRO+3KcpSw5o/Jf79MrPCTqWnuPr0HAWLIZhGL4OQpIsFos+++wzXXXVVZJO3h1Vp04dPfDAAxo3bpwkKTk5WVFRUZo3b56uu+66Ei03JSVFERERSk5OVnh4eHmFDwAAAAAAylh6Vq5e/jlBWxIcHuPiYuy686IYhdj8fRBZ5eGrvIlp+5Dau3evEhMTdckll7iGRUREqFOnTlq9enWh82VlZSklJcXtAwAAAAAAKp7kzLwCk1GStDnBoeTMPC9HhLJi2oRUYmKiJCkqKspteFRUlGtcQWbMmKGIiAjXp169euUaJwAAAAAAKB8ZOc6zGg/zMm1C6kxNnDhRycnJrs8///zj65AAAAAAAMAZCA4oOm1R3HiYl2n3XHR0tCTp0KFDbsMPHTrkGlcQm82m8PBwtw8AAAAAAKh4IoL8FBdjL3BcXIxdEUF+Xo4IZcW0CamGDRsqOjpaP/74o2tYSkqK1q5dqy5duvgwMgAAAAAA4A0hNn+N6hLtkZSKi7Hr5i7RdGhegfl0z6WlpWn37t2u73v37tXGjRtVo0YN1a9fX/fee68ef/xxNW3aVA0bNtSkSZNUp04d15v4AAAAAABA5VYzJEB3XhSj5Mw8ZeQ4FRxgVUSQH8moCs6ne2/dunXq1auX6/v9998vSRoxYoTmzZunhx56SOnp6Ro9erSSkpJ04YUX6ttvv1VQUJCvQgYAAAAAAF4WYvMnAVXJWAzDMHwdRHlKSUlRRESEkpOT6U8KAAAAAADgFL7Km5i2DykAAAAAAABUTiSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAAADgVSSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAAADgVSSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAAADgVSSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAAADgVSSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAAADgVSSkAAAAAAAA4FX+vg4AAAAASM/KVXJmnjJynLIHWBUe5KcQG5eqAKoW2kJUJdRsAAAA+NSx9By9tTpRWxIcrmFxMXaN6hKtmiEBPowMALyHthBVDY/sAQAAwGfSs3I9foBJ0uYEh95enaj0rFwfRQYA3kNbiKqIhBQAAAB8Jjkzz+MHWL7NCQ4lZ+Z5OSIA8D7aQlRFJKQAAADgMxk5zrMaDwCVAW0hqiISUgAAAPCZ4ICiL0eLGw8AlQFtIaoiajUAAAB8JiLIT3Ex9gLHxcXYFRHk5+WIAMD7aAtRFZGQAgAAgM+E2Pw1qku0xw+xuBi7bu4SzevOAVQJtIWoiiyGYRi+DqI8paSkKCIiQsnJyQoPD/d1OAAAAChAelaukjPzlJHjVHCAVRFBfvwAA1Dl0BbCF3yVN6FmAwAAwOdCbP786AJQ5dEWoirhkT0AAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHiV/5nM5HQ6tXv3bh0+fFhOp9NtXPfu3cskMAAAAAAAAFROpU5IrVmzRjfccIP2798vwzDcxlksFuXl5ZVZcHl5eZo8ebLef/99JSYmqk6dOoqPj9cjjzwii8VSZusBAAAAAACA95Q6IXX77berQ4cOWrx4sWJiYso1MfTUU0/p1Vdf1TvvvKPWrVtr3bp1GjlypCIiInT33XeX23oBlI8cR7py01KVm5kh/yC7/ENDFWAP8XVYAAAAZSY9K1fJmXnKyHHKHmBVeJCfQmxn9GAKAFRqpW4Zd+3apU8++URNmjQpj3jcrFq1SldeeaX69+8vSYqNjdWHH36o3377rdzXDaBsZSWd0J5P5itl53bXsIhmLdVoyDDZqlX3YWQAAABl41h6jt5anagtCQ7XsLgYu0Z1iVbNkAAfRgYA5lPqTs07deqk3bt3l0csHrp27aoff/xRO3fulCRt2rRJv/zyiy6//HKvrB9A2chxpHskoyQpeed2/f3JfOU40n0UGQAAQNlIz8r1SEZJ0uYEh95enaj0rFwfRQYA5lSiO6T+/PNP19933XWXHnjgASUmJiouLk4BAe6Z/nPPPbfMgpswYYJSUlLUokUL+fn5KS8vT0888YSGDRtW6DxZWVnKyspyfU9JSSmzeACcmdy0VI9kVL7knduVm5bKo3sAAKBCS87M80hG5duc4FByZh6P7gHAKUrUIrZr104Wi8WtE/NRo0a5/s4fV9admn/00UeaP3++PvjgA7Vu3VobN27Uvffeqzp16mjEiBEFzjNjxgxNmTKlzGIAcPZyMzOKGZ/ppUgAAADKR0aO86zGA0BVU6KE1N69e8s7jgI9+OCDmjBhgq677jpJUlxcnPbv368ZM2YUmpCaOHGi7r//ftf3lJQU1atXzyvxAiiYf1BwMeODvBQJAABA+QgOKLo3lOLGA0BVU6KEVIMGDVx/r1y5Ul27dpW/v/usubm5WrVqldu0Z8vhcMhqdW+4/fz85HQW/t8Fm80mm81WZjEAOHv+oWGKaNZSyQU8thfRrKX8Q8N8EBUAAEDZiQjyU1yMXZsLeGwvLsauiCA/H0QFAOZV6jR9r169dPz4cY/hycnJ6tWrV5kElW/AgAF64okntHjxYu3bt0+fffaZZs6cqUGDBpXpegCUrwB7iBoNGaaIZi3dhue/ZY/+owAAQEUXYvPXqC7Riouxuw2Pi7Hr5i7R9B8FAKexGKd2DFUCVqtVhw4dUmRkpNvwnTt3qkOHDmXaiXhqaqomTZqkzz77TIcPH1adOnV0/fXX69FHH1VgYGCJlpGSkqKIiAglJycrPDy8zGIDUHo5jnTlpqUqNzNT/kFB8g8NIxkFAAAqlfSsXCVn5ikjx6ngAKsigvxIRgEwNV/lTUqckBo8eLAk6YsvvlDfvn3dHovLy8vTn3/+qebNm+vbb78tn0jPEAkpAAAAAACAgvkqb1LiVH1ERIQkyTAMhYWFKTj4f50UBwYGqnPnzrr11lvLPkIAAAAAAABUKiVOSM2dO1eSFBsbq3HjxikkhMdsAAAAAAAAUHql7kMq3+HDh7Vjxw5JUvPmzVW7du0yDays8MgeAAAAAABAwXyVNyn1W/ZSU1N10003qW7duurRo4d69OihunXr6sYbb1RycnJ5xAgAAAAAAIBKpNQJqVtuuUVr167V119/raSkJCUlJenrr7/WunXrdNttt5VHjAAAAAAAAKhESv3IXkhIiL777jtdeOGFbsN//vln9e3bV+np6WUa4NnikT0AAAAAAICCVZhH9mrWrOl6496pIiIiVL169TIJCgAAAAAAAJVXqRNSjzzyiO6//34lJia6hiUmJurBBx/UpEmTyjQ4AAAAAAAAVD6lfmTvvPPO0+7du5WVlaX69etLkg4cOCCbzaamTZu6TfvHH3+UXaRniEf2AAAAAAAACuarvIl/aWe46qqryiEMAAAAAAAAVBWlvkOqouEOKQAAAAAAgIJVmE7NJSkpKUlvvvmmJk6cqOPHj0s6+Xjef//9V6bBAQAAAAAAoPIp9SN7f/75py655BJFRERo3759uvXWW1WjRg19+umnOnDggN59993yiBMAAAAAAACVRKnvkLr//vsVHx+vXbt2KSgoyDW8X79+WrlyZZkGBwAAAAAAgMqn1Amp33//XbfddpvH8Lp16yoxMbFMggIAAAAAAEDlVeqElM1mU0pKisfwnTt3KjIyskyCAgAAAAAAQOVV6oTUwIEDNXXqVOXk5EiSLBaLDhw4oPHjx+vqq68u8wABAAAAAABQuVgMwzBKM0NycrKGDBmidevWKTU1VXXq1FFiYqK6dOmib775RiEhIeUV6xnx1esLAaA00rNylZyZp4wcp+wBVoUH+SnEVur3TgBAqdD2VBxJjhylZuXJke2UPdCqMJufqtkDfB0WAHgN56zy46u8San3XkREhH744Qf98ssv+vPPP5WWlqb27dvrkksuKY/4AKDSO5aeo7dWJ2pLgsM1LC7GrlFdolUzhB8bAMoHbU/FcTg1W3PXHNLWxP/tq9bRdo3sHKXaYYE+jAwAvINzVuVU6jukKhrukAJgZulZuXr55wS3k2u+uBi77rwohv/8AChztD0VR5IjR6/9muiWjMrXOtqu27pFc6cUgEqNc1b581XepFR9SDmdTr399tu64oor1KZNG8XFxWngwIF69913VcnzWgBQLpIz8wo8uUrS5gSHkjPzvBwRgKqAtqfiSM3KKzAZJUlbEx1KzWJfAajcOGdVXiVOSBmGoYEDB+qWW27Rf//9p7i4OLVu3Vr79+9XfHy8Bg0aVJ5xAkCllJHjPKvxAHAmaHsqDkd20fuiuPEAUNFxzqq8Snxf27x587Ry5Ur9+OOP6tWrl9u4ZcuW6aqrrtK7776r4cOHl3mQAFBZBQcU/X+B4sYDwJmg7ak47IFF74vixgNARcc5q/Iq8Z778MMP9X//938eyShJuvjiizVhwgTNnz+/TIMDgMouIshPcTH2AsfFxdgVEeTn5YgAVAW0PRVHmM1PraML3leto+0Ks7GvAFRunLMqrxInpP7880/17du30PGXX365Nm3aVCZBAUBVEWLz16gu0R4n2bgYu27uEk0HjQDKBW1PxVHNHqCRnaM8klL5b9mjQ3MAlR3nrMqrxG/ZCwwM1P79+xUTE1Pg+IMHD6phw4bKysoq0wDPFm/ZA1ARpGflKjkzTxk5TgUHWBUR5MfJFUC5o+2pOJIcOUrNypMj2yl7oFVhNj+SUQCqFM5Z5cdXeZMS7728vDz5+xc+uZ+fn3Jzc8skKACoakJs/pxQAXgdbU/FUc0eQAIKQJXGOavyKfHeNAxD8fHxstlsBY43251RAAAAAAAAMKcSJ6RGjBhR7DS8YQ8AAAAAAADFKXFCau7cueUZBwAAAAAAAKqIEr9lDwAAAAAAACgLJKQAAAAAAADgVSSkAAAAAAAA4FUkpAAAAAAAAOBVJKQAAAAAAADgVSV+y96pdu3apeXLl+vw4cNyOp1u4x599NEyCQwAAAAAAACVU6kTUm+88YbuuOMO1apVS9HR0bJYLK5xFouFhBQAAAAAAACKVOqE1OOPP64nnnhC48ePL494AAAAAAAAUMmVug+pEydO6JprrimPWAAAAAAAAFAFlDohdc011+j7778vj1gAAAAAAABQBZT6kb0mTZpo0qRJWrNmjeLi4hQQEOA2/u677y6z4AAAAAAAAFD5WAzDMEozQ8OGDQtfmMWiv//++6yDKkspKSmKiIhQcnKywsPDfR0OAAAAAACAafgqb1LqO6T27t1bHnEAAAAAAACgiih1H1IAAAAAAADA2Sj1HVKS9O+//+rLL7/UgQMHlJ2d7TZu5syZZRJYvv/++0/jx4/XkiVL5HA41KRJE82dO1cdOnQo0/UAAAAAAADAO0qdkPrxxx81cOBANWrUSH/99ZfatGmjffv2yTAMtW/fvkyDO3HihLp166ZevXppyZIlioyM1K5du1S9evUyXQ9KJz0rV8mZecrIccoeYFV4kJ9CbGeU2wQAAEAJmO36y2zxAGcqyZGj1Kw8ObKdsgdaFWbzUzV7QPEzAjhrpT5rTJw4UePGjdOUKVMUFhamRYsWqXbt2ho2bJj69u1bpsE99dRTqlevnubOnesaVlSn6ih/x9Jz9NbqRG1JcLiGxcXYNapLtGqG0HADAACUNbNdf5ktHuBMHU7N1tw1h7Q18X91uXW0XSM7R6l2WKAPIwOqhlL3IbV9+3YNHz5ckuTv76+MjAyFhoZq6tSpeuqpp8o0uC+//FIdOnTQNddco9q1a+u8887TG2+8UabrQMmlZ+V6XHxI0uYEh95enaj0rFwfRQYAAFA5me36y2zxAGcqyZHjkYySpK2JDs1dc0hJjhwfRQZUHaVOSIWEhLj6jYqJidGePXtc444ePVp2kUn6+++/9eqrr6pp06b67rvvdMcdd+juu+/WO++8U+g8WVlZSklJcfugbCRn5nlcfOTbnOBQcmaelyMCAACo3Mx2/WW2eIAzlZqV55GMyrc10aHULOoyUN5K/che586d9csvv6hly5bq16+fHnjgAW3evFmffvqpOnfuXKbBOZ1OdejQQdOnT5cknXfeedqyZYvmzJmjESNGFDjPjBkzNGXKlDKNAydl5DjPajwAAABKx2zXX2aLBzhTjuyi62px4wGcvVLfITVz5kx16tRJkjRlyhT17t1bCxcuVGxsrN56660yDS4mJkatWrVyG9ayZUsdOHCg0HkmTpyo5ORk1+eff/4p05iqsuCAoqtLceMBAABQOma7/jJbPMCZsgcWXVeLGw/g7JX6DqlGjRq5/g4JCdGcOXPKNKBTdevWTTt27HAbtnPnTjVo0KDQeWw2m2w2W7nFVJVFBPkpLsauzQXcph0XY1dEkJ8PogIAAKi8zHb9ZbZ4gDMVZvNT62h7gY/ttY62K8xGXQbKm6nTvvfdd5/WrFmj6dOna/fu3frggw/0+uuva8yYMb4OrUoKsflrVJdoxcXY3YbHxdh1c5doXvULAABQxsx2/WW2eIAzVc0eoJGdo9Q62r0u579lr5qdN0YC5c1iGIZR3EQ1atTQzp07VatWLVWvXl0Wi6XQaY8fP16mAX799deaOHGidu3apYYNG+r+++/XrbfeWuL5U1JSFBERoeTkZIWHh5dpbFVVelaukjPzlJHjVHCAVRFBflx8AAAAlCOzXX+ZLR7gTCU5cpSalSdHtlP2QKvCbH4ko1Dl+CpvUqKzxvPPP6+wsDBJ0qxZs8ozHg9XXHGFrrjiCq+uE0ULsflzwQEAAOBFZrv+Mls8wJmqZg8gAQX4SInukKrIuEMKAAAAAACgYKa+QyolJaXECyTpAwAAAAAAgKKUKCFVrVq1IvuNOlVeXt5ZBQQAAAAAAIDKrUQJqeXLl7v+3rdvnyZMmKD4+Hh16dJFkrR69Wq98847mjFjRvlECQAAAAAAgEqj1H1I9e7dW7fccouuv/56t+EffPCBXn/9da1YsaIs4ztr9CEFAAAAAABQMF/lTaylnWH16tXq0KGDx/AOHTrot99+K5OgAAAAAAAAUHmVOiFVr149vfHGGx7D33zzTdWrV69MggIAAAAAAEDlVaI+pE71/PPP6+qrr9aSJUvUqVMnSdJvv/2mXbt2adGiRWUeIAAAAAAAACqXUt8h1a9fP+3cuVMDBgzQ8ePHdfz4cQ0YMEA7d+5Uv379yiNGAAAAAAAAVCKl7tS8oqFTcwAAAAAAgIJVmE7NJennn3/WjTfeqK5du+q///6TJL333nv65ZdfyjQ4AAAAAAAAVD6lTkgtWrRIffr0UXBwsP744w9lZWVJkpKTkzV9+vQyDxAAAAAAAACVS6kTUo8//rjmzJmjN954QwEBAa7h3bp10x9//FGmwQEAAAAAAKDyKXVCaseOHerevbvH8IiICCUlJZVFTAAAAAAAAKjESp2Qio6O1u7duz2G//LLL2rUqFGZBAUAAAAAAIDKq9QJqVtvvVX33HOP1q5dK4vFooMHD2r+/PkaN26c7rjjjvKIEQAAAAAAAJWIf2lnmDBhgpxOp3r37i2Hw6Hu3bvLZrNp3Lhxuuuuu8ojRgAAAAAAAFQiFsMwjDOZMTs7W7t371ZaWppatWql0NDQso6tTKSkpCgiIkLJyckKDw/3dThAlZbjSFduWqpyMzPkH2SXf2ioAuwhvg7LFI6kZSsjxylHtlMhgVYFBVgVGRro67AAlLH0rFwlZ+YpI8cpe4BV4UF+CrGV+v+DlVKSI0epWXlyZDtlD7QqzOanavaA4mesIvGYre5QPoU7mpYtxynn9OAAq2pxTjctM9Uds8VjpljMGE9l4qu8yRnvvcDAQLVq1aosYwFQiWUlndCeT+YrZed217CIZi3VaMgw2apV92FkvncoNVvz1hzS1kSHa1jraLviO0cpKowLWKCyOJaeo7dWJ2pLwv+O9bgYu0Z1iVbNEN/9kDeDw6nZmltAOziyc5Rq+6AdNFs8Zqs7lE/hOKdXLGaqO2aLx0yxmDEelI0S3yE1atSoEi3w7bffPquAyhp3SAG+l+NI164P5rolo/JFNGupJjeMrLJ3Sh1Jy9bbq90vXPO1jrZrVJco7pQCKoH0rFy9/HOC24V0vrgYu+68KKbK/pc3yZGj135NLLQdvK1btFfvvDFbPGarO5RP4Y6mZeutIs7pN3eJ4k4pEzFT3TFbPGaKxYzxVEamv0Nq3rx5atCggc477zyd4VN+AKqo3LTUApNRkpS8c7ty01KrbEIqI8dZ4IWrJG1NdCgjx+nliACUh+TMvAIvpCVpc4JDyZl5VfZiOjUrr8h2MDUrz6sJDrPFY7a6Q/kUzlHMOd3BOd1UzFR3zBaPmWIxYzwoOyXea3fccYc+/PBD7d27VyNHjtSNN96oGjVqlGdsACqJ3MyMYsZneikS83FkF31xmlHMeAAVQ3HJ5aqcfC6uHSxufFkzWzxmqzuUT+E4p1csZqo7JVmfN+MxUywlWV9VPodWdNaSTvjyyy8rISFBDz30kL766ivVq1dPQ4cO1XfffccdUwCK5B8UXMz4IC9FYj72wKKb4eBixgOoGIIDijnWixlfmRXXDhY3vqyZLR6z1R3Kp3Cc0ysWM9WdkqzPm/GYKZaSrK8qn0MrulLtOZvNpuuvv14//PCDtm3bptatW+vOO+9UbGys0tLSyitGABWcf2iYIpq1LHBcRLOW8g8N83JE5hEcYFXraHuB41pH2znBApVERJCf4mIKPtbjYuyKCPLzckTmEWbzK7IdDLN5t2zMFo/Z6g7lUzh7Med0O+d0UzFT3TFbPGaKxYzxoOyccatotVplsVhkGIby8vLKMiYAlUyAPUSNhgzzSErlv2WvqvYfJUmRoYGK7xzlcQGb/0YeOjQHKocQm79GdYn2uKCOi7Hr5i7RVbrvi2r2AI0spB0c2TnKq/0RmTEes9UdyqdwtYo5p9OhubmYqe6YLR4zxWLGeFB2SvyWPUnKysrSp59+qrffflu//PKLrrjiCo0cOVJ9+/aV1WrOjD9v2QPMI8eRrty0VOVmZso/KEj+oWFVOhl1qiNp2crIcSoj26ngQKuCA6wko4BKKD0rV8mZecrIcSo4wKqIID8upP+/JEeOUrPy5Mh2yh5oVZjNz+vJDTPHY7a6Q/kU7mhathynnNPtAVaSUSZmprpjtnjMFIsZ46lMfJU3KXFC6s4779SCBQtUr149jRo1SsOGDVOtWrXKO76zRkIKAAAAAACgYKZPSFmtVtWvX1/nnXeeLBZLodN9+umnZRZcWSAhBQAAAAAAUDBf5U1KfH/b8OHDi0xEAQAAAAAAACVR4oTUvHnzyjEMAAAAAAAAVBXm7IkcAAAAAAAAlRYJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHhVhUpIPfnkk7JYLLr33nt9HQoAAAAAAADOkL+vAyip33//Xa+99prOPfdcX4cCAGXuaFq2HDlOObKdCgm0KjjAqlqhgb4OC6jw0rNylZyZp4wcp+wBVoUH+SnEVmEuf8qdmcrHTLGYUZIjR6lZeXJkO2UPtCrM5qdq9gBfh2UaZqo/ZorFjMxWPhxbhTPbvjJbPDh7FWLvpaWladiwYXrjjTf0+OOP+zocAChTh1KzNW/NIW1NdLiGtY62K75zlKLCSEoBZ+pYeo7eWp2oLQn/O7biYuwa1SVaNUP4sWGm8jFTLGZ0ODVbcws4T4zsHKXanCdMVX/MFIsZma18OLYKZ7Z9ZbZ4UDYqxCN7Y8aMUf/+/XXJJZf4OhQAKFNH0zyTUZK0NdGheWsO6Whato8iAyq29KxcjwtXSdqc4NDbqxOVnpXro8jMwUzlY6ZYzCjJkePxg1k6eZ6Yu+aQkhw5PorMHMxUf8wUixmZrXw4tgpntn1ltnhQdkx/h9SCBQv0xx9/6Pfffy/R9FlZWcrKynJ9T0lJKa/QAOCsOXKcHhdC+bYmOuTIcXo5IqBySM7M87hwzbc5waHkzLwqfZu/mcrHTLGYUWpWXpHnidSsvCr9eJGZ6o+ZYjEjs5UPx1bhzLavzBYPyo6p75D6559/dM8992j+/PkKCgoq0TwzZsxQRESE61OvXr1yjhIAzpwju+iEU0Yx4wEULKOYZG5x4ys7M5WPmWIxo+LOE8WNr+zMVH/MFIsZma18OLYKZ7Z9ZbZ4UHZMnZBav369Dh8+rPbt28vf31/+/v766aefNHv2bPn7+ysvL89jnokTJyo5Odn1+eeff3wQOQCUjD2w6GY4uJjxAAoWHFDMsVXM+MrOTOVjpljMqLjzRHHjKzsz1R8zxWJGZisfjq3CmW1fmS0elB1T77nevXtr8+bN2rhxo+vToUMHDRs2TBs3bpSfn5/HPDabTeHh4W4fADAre4BVraPtBY5rHW2XnRMscEYigvwUF1PwsRUXY1dEkOc1RFVipvIxUyxmFGbzK/I8EWar2uVjpvpjpljMyGzlw7FVOLPtK7PFg7Jj6l86YWFhatOmjdsnJCRENWvWVJs2bXwdHgCctVqhgYrvHOVxQZT/lr1aoVX7DS/AmQqx+WtUl2iPC9i4GLtu7hJd5fuaMFP5mCkWM6pmD9DIQs4TIztHVdk+bvKZqf6YKRYzMlv5cGwVzmz7ymzxoOxYDMMwfB1EafTs2VPt2rXTrFmzSjR9SkqKIiIilJyczN1SAEzraFq2HDlOZWQ7FRxolT3ASjIKKAPpWblKzsxTRo5TwQFWRQT5ceF6CjOVj5liMaMkR45Ss/LkyHbKHmhVmM2vSv9gPp2Z6o+ZYjEjs5UPx1bhzLavzBZPZeKrvEmFS0iVFgkpAAAAAACAgvkqb2LqR/YAAAAAAABQ+ZCQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFeRkAIAAAAAAIBXkZACAAAAAACAV5GQAgAAAAAAgFf5+zoAVDzpWblKzsxTRo5T9gCrwoP8FGKjKqF41J3CHUnLVkaOU45sp0ICrQoKsCoyNNDXYQGo5JIcOUrNypMj2yl7oFVhNj9Vswf4JJaU9EylZjnlyM6TPdBPYTarwkOCfBKLJB1Lz1Z69v/aZXugVTVDfNcum+08wTm9cGbbV2aTnOpQWrYhR45T9kA/hQZIEWF2n8VjtmPdTMx2nB9Ny5bjlGMrOMCqWrSDFRqlhVI5lp6jt1YnakuCwzUsLsauUV2iVTPENxewqBioO4U7lJqteWsOaWvi/8qmdbRd8Z2jFBXGBRGA8nE4NVtzC2h7RnaOUm0vtz1HUzL11tpD2pqY6RrWJjpIozpFqVa495NSZmuXzRYP5/TCmW1fmc3R5Ay99dsRz2P9gtqqFRHs9XjYX4Uz23Futn1ltvKpqHhkDyWWnpXrcdBJ0uYEh95enaj0rFwfRQazo+4U7kia58lVkrYmOjRvzSEdScv2UWQAKrMkR45HMko62fbMXXNISY4cr8WSku6ZjJKkLYmZenvtIaWkZxYyZ/k4ll50u3ws3bvtstnOE5zTC2e2fWU2yakOvfXb4YKP9d8OKznVUcic5cNsx7qZmO04P1rMsXWUdrDCIiGFEkvOzPM46PJtTnAoOTPPyxGhoqDuFC4jx+lxcs23NdGhjBynlyMCUBWkZuUV2fakZnmvXU7Ncnr8QM23JfHkY3zelJ5ddLucnu3deMx2nuCcXjiz7SuzScs2ijzW07INr8ZjtmPdTMx2nDuKObYctIMVFgkplFhxJ9GqfpJF4ag7hXMUc7GTUYUvhgCUn+LanuLGlyVHdtEX7hnFjC9rZmuXzRYP5/TCmW1fmU1xSQNvJxXYX4Uz23Futn1ltvKpyEhIocSCA4quLsWNR9VF3SmcPbCYsilmPACcieLanuLGlyV7oF+R44OLGV/WzNYumy0ezumFM9u+Mht7MXWjuPFljf1VOLMd52bbV2Yrn4qMkkKJRQT5KS6m4DdgxMXYFRHk3QtGVBzUncIFB1jVOrrgsmkdbeeEBqBchNn8imx7wmzea5fDbFa1iS644/I20UEKs3m3HQwJLLpdDvHBDx8znSc4pxfObPvKbEIDLUUe66GBFq/GY7Zj3UzMdpzbizm2vJ3MNFv5VGRV9yhDqYXY/DWqS7THwRcXY9fNXaJ5xSUKRd0pXGRooOI7R3mcZPPfGsJrogGUh2r2AI0spO0Z2TlK1ezee0NQeMjJt+md/kM1/y174SHefctezZCi22Vvvw7ebOcJzumFM9u+MpuIMLtGXVC74GP9gtqKCCv4B355MduxbiZmO85rFXNs1aIdrLAshmF4t/c4L0tJSVFERISSk5MVHh7u63AqhfSsXCVn5ikjx6ngAKsigvw46FAi1J3CHUnLVkaOUxnZTgUHWhUcYK3yF64Ayl+SI0epWXlyZDtlD7QqzObn1WTUqVLST3ZgnpGdp+BAP4XZrF5PRp3qWHq20rP/1y6HBFp9+gPVbOcJzumFM9u+MpvkVIfSsg05cpyyB1gVGmjxejLqVGY71s3EbMf50bRsOU45tuwBVq8no05ltvI5G77Km5CQAgAAAAAAqKJ8lTfhkT0AAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeBUJKQAAAAAAAHgVCSkAAAAAAAB4FQkpAAAAAAAAeJW/rwMoyowZM/Tpp5/qr7/+UnBwsLp27aqnnnpKzZs393VoXpXkyFFqVp4c2U7ZA60Ks/mpmj3AZ/EcS89WerZTjmynQgKtsgdaVTMk0GfxAJWB2Y5zVCzpWblKzsxTRo5T9gCrwoP8FGIz9Sm+yuJYL5zZ6vHxtCylZRsn4wm0KiTAohqhNp/FY7brr5T0TKVmOeXIzpM90E9hNqvCQ4J8Fo+ZmK0um43Zysds8ZiJ2c5ZR9KylZHzv3YwKMCqyFDftYNmK5+KyNRH2k8//aQxY8aoY8eOys3N1f/93//psssu07Zt2xQSEuLr8LzicGq25q45pK2JDtew1tF2jewcpdph3j/4DqVma14B8cR3jlKUD+IBKgOzHeeoWI6l5+it1YnakvC/+hMXY9eoLtGqGcJFkZlwrBfObPX4cEq25q497LmvOkWpdjjXX0dTMvXW2kPampjpGtYmOkijOkWpVnjVTkqZrS6bjdnKx2zxmInZzllmawfNVj4VlcUwDMPXQZTUkSNHVLt2bf3000/q3r17ieZJSUlRRESEkpOTFR4eXs4Rlq0kR45e+zXRrZLnax1t123dor2agT2Wnq03Vx0qNJ5bukZxpxRQSmY7zlGxpGfl6uWfE9wupPPFxdh150Ux/JfXJDjWC2e2enw8LUtvrD5c6L66tUttr94pZbbrr5T0TL26yj0Zla9NdJBu7xpVZe+UMltdNhuzlY/Z4jETs52zjqRl6+3VhbeDo7pEefVOKbOVT1nwVd6kQvUhlZycLEmqUaNGodNkZWUpJSXF7VNRpWblFVjJJWlrokOpWXlejSc921lkPOnZTq/GA1QGZjvOUbEkZ+YVeCEtSZsTHErOpP6YBcd64cxWj9OyjSL3VVq2d/+Xa7brr9QsZ4HJKEnaknjyMb6qymx12WzMVj5mi8dMzHbOysgpuh3MyPF2O2iu8qnIKkxCyul06t5771W3bt3Upk2bQqebMWOGIiIiXJ969ep5Mcqy5SjmAqO48WWtuPVlkJACSs1sxzkqluIuwLx9gYbCcawXzmz12GzxmO36y5Fd9A+tjGLGV2ZmqztmY7byMVs8ZmK2c5b52kFzlU9FVmESUmPGjNGWLVu0YMGCIqebOHGikpOTXZ9//vnHSxGWPXtg0bunuPFlrbj1BXs5HqAyMNtxjoolOKCYdrmY8fAejvXCma0emy0es11/2QP9ihwfXMz4ysxsdcdszFY+ZovHTMx2zjJfO2iu8qnIKkRJjR07Vl9//bWWL1+uc845p8hpbTabwsPD3T4VVZjNT62j7QWOax1tV5jNuyf8kEBrkfGEcOABpWa24xwVS0SQn+JiCq4/cTF2RQRRf8yCY71wZqvHoYGWIvdVaKDFq/GY7forzGZVm+iC+4hqEx2kMFvVvR40W102G7OVj9niMROznbOCA4puB72dPDRb+VRkpj5jGIahsWPH6rPPPtOyZcvUsGFDX4fkVdXsARrZOcqjsuf33u/tjtJqhgQqvpB44jvToTlwJsx2nKNiCbH5a1SXaI8L6rgYu27uEl1lO2M1I471wpmtHtcItWlkp0L2Vacor3ZoLpnv+is85OTb9E5PSuW/Za+qdmguma8um43Zysds8ZiJ2c5ZkaFFt4Pe7NBcMl/5VGSmfsvenXfeqQ8++EBffPGFmjdv7hoeERGh4ODgEi2jIr9lL1+SI0epWXlyZDtlD7QqzObn00p+LD1b6dlOZWQ7FRxoVUiglWQUcJbMdpyjYknPylVyZp4ycpwKDrAqIsivSl9ImxnHeuHMVo+Pp2UpLdtwxRMaaPF6MupUZrv+Skk/2YF5RnaeggP9FGazVulk1KnMVpfNxmzlY7Z4zMRs56wjadnKyPlfOxgcYPV6MupUZiufs+GrvImpE1IWS8G3RM+dO1fx8fElWkZlSEgBAAAAAACUB1/lTUyd+jVxrgwAAAAAAABnyNR9SAEAAAAAAKDyISEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAr/L3dQCoeJIcOUrNypMj2yl7oFVhNj9Vswf4OiygQjuSlq2MHKcc2U6FBFoVFGBVZGigr8NCBZHjSFduWqpyMzPkH2SXf2ioAuwhvg4LBTDbOTQ9K1fJmXnKyHHKHmBVeJCfQmy+uTw0W9mYzbH0bKVn/+88YQ+0qmaI784Tx9OylJZtnKw7gVaFBFhUI9Tms3jMhHN6xWKmdtBs8ZgpFsl87SDOHgkplMrh1GzNXXNIWxMdrmGto+0a2TlKtcNoDIAzcSg1W/MKOK7iO0cpiuMKxchKOqE9n8xXys7trmERzVqq0ZBhslWr7sPIcDqznUOPpefordWJ2pLwv3jiYuwa1SVaNUO8mwgyW9mYjdnOE4dTsjV37WHP/dUpSrXDq/b+Mtu+QtHM1A6aLR4zxSJxbFVWPLKHEkty5HhcLErS1kSH5q45pCRHjo8iAyquI2meJ1fp5HE1b80hHUnL9lFkqAhyHOkeyShJSt65XX9/Ml85jnQfRYbTme0cmp6V6/FDQ5I2Jzj09upEpWflei0Ws5WN2RxLL/o8cSzdu+eJ42lZmru2kP219pCOp2V5NR4z4ZxesZipHTRbPGaKRTJfO4iyQ0IKJZaalefRCOTbmuhQalaelyMCKr6MHGeRx1VGjtPLEaEiyU1L9UhG5UveuV25aalejgiFMds5NDkzz+OHRr7NCQ4lZ3ovHrOVjdmkZxd9nkjP9u55Ii3bKDKetGzDq/GYCef0isVM7aDZ4jFTLJL52kGUHRJSKDFHMQd6ceMBeCruuMnguEIRcjMzihmf6aVIUByznUOL+2HszR/OZisbszHbecJMdcdszLavUDSz1WUzxWOmWCSOrcqMhBRKzB5YdHUpbjwAT8UdN8EcVyiCf1BwMeODvBQJimO2c2hwQDFtTzHjy5LZysZszHaeMFPdMRuz7SsUzWx12UzxmCkWiWOrMmPPocTCbH5qHW0vcFzraLvCbH5ejgio+IIDrEUeV1X5wh7F8w8NU0SzlgWOi2jWUv6hYV6OCIUx2zk0IshPcTEFxxMXY1dEkPfiMVvZmE1IYNHniRAv/xALDbQUGU9ooMWr8ZgJ5/SKxUztoNniMVMskvnaQZQd9hxKrJo9QCM7R3k0BvlvweHVzEDpRYYGKr6Q4yq+cxSviUaRAuwhajRkmEdSKv8tewH2EB9FhtOZ7RwaYvPXqC7RHj844mLsurlLtFdf6222sjGbmiFFnye8/crzGqE2jexUyP7qFKUaoTavxmMmnNMrFjO1g2aLx0yxSOZrB1F2LIZhVOqeB1NSUhQREaHk5GSFh4f7OpxKIcmRo9SsPDmynbIHWhVm86vyF4vA2TqSlq2MHKcysp0KDrQqOMDKhStKLMeRrty0VOVmZso/KEj+oWEko0zKbOfQ9KxcJWfmKSPHqeAAqyKC/Lz+QyOf2crGbI6lZys9+3/niZBAq09/hB1Py1JatuGqO6GBliqdjDoV5/SKxUztoNniMVMskvnawcrEV3kTElIAAAAAAABVlK/yJjyyBwAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIQUAAAAAAACv8vd1AOXNMAxJUkpKio8jAQAAAAAAMJf8fEl+/sRbKn1CKjU1VZJUr149H0cCAAAAAABgTqmpqYqIiPDa+iyGt1NgXuZ0OnXw4EGFhYXJYrH4OhxUASkpKapXr57++ecfhYeH+zocVFLUM/gC9Q7ljToGX6HuwReod/CGktQzwzCUmpqqOnXqyGr1Xs9Olf4OKavVqnPOOcfXYaAKCg8P58SCckc9gy9Q71DeqGPwFeoefIF6B28orp55886ofHRqDgAAAAAAAK8iIQUAAAAAAACvIiEFlDGbzabHHntMNpvN16GgEqOewReodyhv1DH4CnUPvkC9gzeYuZ5V+k7NAQAAAAAAYC7cIQUAAAAAAACvIiEFAAAAAAAAryIhBQAAAAAAAK8iIYUqY8aMGerYsaPCwsJUu3ZtXXXVVdqxY4fbNJmZmRozZoxq1qyp0NBQXX311Tp06JDbNHfffbfOP/982Ww2tWvXzmM9O3bsUK9evRQVFaWgoCA1atRIjzzyiHJycoqN8eWXX1ZsbKyCgoLUqVMn/fbbbwVOZxiGLr/8clksFn3++eclLgOUr8pQx3r27CmLxeL2uf3220tfGPCaylDvJGn16tW6+OKLFRISovDwcHXv3l0ZGRmlKwyUm4pez/bt2+fRtuV/Pv744zMrFJS7il7vJCkxMVE33XSToqOjFRISovbt22vRokWlLwx4VWWoe3v27NGgQYMUGRmp8PBwDR061CM++I7Z69jKlSs1YMAA1alTp9DfnIZh6NFHH1VMTIyCg4N1ySWXaNeuXaUqBxJSqDJ++uknjRkzRmvWrNEPP/ygnJwcXXbZZUpPT3dNc9999+mrr77Sxx9/rJ9++kkHDx7U4MGDPZY1atQoXXvttQWuJyAgQMOHD9f333+vHTt2aNasWXrjjTf02GOPFRnfwoULdf/99+uxxx7TH3/8obZt26pPnz46fPiwx7SzZs2SxWIpZQmgvFWWOnbrrbcqISHB9Xn66afPoDTgLZWh3q1evVp9+/bVZZddpt9++02///67xo4dK6uVyxSzqOj1rF69em7tWkJCgqZMmaLQ0FBdfvnlZ1EyKE8Vvd5J0vDhw7Vjxw59+eWX2rx5swYPHqyhQ4dqw4YNZ1gq8IaKXvfS09N12WWXyWKxaNmyZfr111+VnZ2tAQMGyOl0nkXJoKyYvY6lp6erbdu2evnllwud5umnn9bs2bM1Z84crV27ViEhIerTp48yMzNLWAqSDKCKOnz4sCHJ+OmnnwzDMIykpCQjICDA+Pjjj13TbN++3ZBkrF692mP+xx57zGjbtm2J1nXfffcZF154YZHTXHDBBcaYMWNc3/Py8ow6deoYM2bMcJtuw4YNRt26dY2EhARDkvHZZ5+VKAZ4X0WsYz169DDuueeeEq0T5lQR612nTp2MRx55pETrhDlUxHp2unbt2hmjRo0qUQwwh4pY70JCQox3333Xbb4aNWoYb7zxRonigDlUtLr33XffGVar1UhOTnZNk5SUZFgsFuOHH34oURzwLrPVsVMV9JvT6XQa0dHRxjPPPOMalpSUZNhsNuPDDz8s8bL51yOqrOTkZElSjRo1JEnr169XTk6OLrnkEtc0LVq0UP369bV69eozXs/u3bv17bffqkePHoVOk52drfXr17ut22q16pJLLnFbt8Ph0A033KCXX35Z0dHRZxwTvKMi1jFJmj9/vmrVqqU2bdpo4sSJcjgcZxwbvK+i1bvDhw9r7dq1ql27trp27aqoqCj16NFDv/zyyxnHhvJX0erZ6davX6+NGzfq5ptvPuPY4H0Vsd517dpVCxcu1PHjx+V0OrVgwQJlZmaqZ8+eZxwfvK+i1b2srCxZLBbZbDbXNEFBQbJarZxfTcpMdawk9u7dq8TERLf4IiIi1KlTp1LFR0IKVZLT6dS9996rbt26qU2bNpJOPuMfGBioatWquU0bFRWlxMTEUq+ja9euCgoKUtOmTXXRRRdp6tSphU579OhR5eXlKSoqqsh133ffferatauuvPLKUscD76qodeyGG27Q+++/r+XLl2vixIl67733dOONN5Y6NvhGRax3f//9tyRp8uTJuvXWW/Xtt9+qffv26t27d6n7IYB3VMR6drq33npLLVu2VNeuXUsdG3yjota7jz76SDk5OapZs6ZsNptuu+02ffbZZ2rSpEmp44NvVMS617lzZ4WEhGj8+PFyOBxKT0/XuHHjlJeXp4SEhFLHh/JltjpWEvkxlObcWxASUqiSxowZoy1btmjBggXlto6FCxfqjz/+0AcffKDFixfr2WeflST9/PPPCg0NdX3mz59fouV9+eWXWrZsmWbNmlVuMaPsVMQ6JkmjR49Wnz59FBcXp2HDhundd9/VZ599pj179pTXZqAMVcR6l9+XxW233aaRI0fqvPPO0/PPP6/mzZvr7bffLrftwJmriPXsVBkZGfrggw+4O6qCqaj1btKkSUpKStLSpUu1bt063X///Ro6dKg2b95cXpuBMlYR615kZKQ+/vhjffXVVwoNDVVERISSkpLUvn17+mc0oYpYx8qKv1fXBpjA2LFj9fXXX2vlypU655xzXMOjo6OVnZ2tpKQkt0z0oUOHzujxuHr16kmSWrVqpby8PI0ePVoPPPCAOnTooI0bN7qmi4qKks1mk5+fn8dbE05d97Jly7Rnzx6PLPnVV1+tiy66SCtWrCh1jCgfFbWOFaRTp06STt7e27hx41LHCO+pqPUuJibGtbxTtWzZUgcOHCh1fChfFbWeneqTTz6Rw+HQ8OHDSx0XfKOi1rs9e/bopZde0pYtW9S6dWtJUtu2bfXzzz/r5Zdf1pw5c0odI7yrotY9Sbrsssu0Z88eHT16VP7+/qpWrZqio6PVqFGjUseH8mPGOlYS+TEcOnTIdS2X/72gt/0VhvQoqgzDMDR27Fh99tlnWrZsmRo2bOg2/vzzz1dAQIB+/PFH17AdO3bowIED6tKly1mt2+l0KicnR06nU8HBwWrSpInrExYWpsDAQJ1//vlu63Y6nfrxxx9d654wYYL+/PNPbdy40fWRpOeff15z5849q/hQNip6HStIfj079UQDc6no9S42NlZ16tTxeNXxzp071aBBg7OKD2WnotezU7311lsaOHCgIiMjzyoulL+KXu/y+2A8/Y4UPz8/3nRmchW97p2qVq1aqlatmpYtW6bDhw9r4MCBZxUfyoaZ61hJNGzYUNHR0W7xpaSkaO3ataWLr8TdnwMV3B133GFEREQYK1asMBISElwfh8Phmub222836tevbyxbtsxYt26d0aVLF6NLly5uy9m1a5exYcMG47bbbjOaNWtmbNiwwdiwYYORlZVlGIZhvP/++8bChQuNbdu2GXv27DEWLlxo1KlTxxg2bFiR8S1YsMCw2WzGvHnzjG3bthmjR482qlWrZiQmJhY6j3jLnqlU9Dq2e/duY+rUqca6deuMvXv3Gl988YXRqFEjo3v37mVcUihLFb3eGYZhPP/880Z4eLjx8ccfG7t27TIeeeQRIygoyNi9e3cZlhTORmWoZ/nrt1gsxpIlS8qoZFCeKnq9y87ONpo0aWJcdNFFxtq1a43du3cbzz77rGGxWIzFixeXcWmhLFX0umcYhvH2228bq1evNnbv3m289957Ro0aNYz777+/DEsJZ8PsdSw1NdW1LEnGzJkzjQ0bNhj79+93TfPkk08a1apVM7744gvjzz//NK688kqjYcOGRkZGRonLgYQUqgxJBX7mzp3rmiYjI8O48847jerVqxt2u90YNGiQkZCQ4LacHj16FLicvXv3GoZx8gTRvn17IzQ01AgJCTFatWplTJ8+vUQH5osvvmjUr1/fCAwMNC644AJjzZo1xW4TCSnzqOh17MCBA0b37t2NGjVqGDabzWjSpInx4IMPur0yGOZT0etdvhkzZhjnnHOOYbfbjS5duhg///zzWZULylZlqWcTJ0406tWrZ+Tl5Z1VecA7KkO927lzpzF48GCjdu3aht1uN84991zj3XffPeuyQfmqDHVv/PjxRlRUlBEQEGA0bdrUeO655wyn03nWZYOyYfY6tnz58gKXO2LECNc0TqfTmDRpkhEVFWXYbDajd+/exo4dO0pVDpb/XxgAAAAAAACAV9CHFAAAAAAAALyKhBQAAAAAAAC8ioQUAAAAAAAAvIqEFAAAAAAAALyKhBQAAAAAAAC8ioQUAAAAAAAAvIqEFAAAAAAAALyKhBQAAAAAAAC8ioQUAAAAAAAAvIqEFAAAAAAAALyKhBQAAAAAAAC8ioQUAAAAAAAAvIqEFAAAAAAAALyKhBQAAAAAAAC8ioQUAAAAAAAAvIqEFAAAAAAAALyKhBQAAAAAAAC8ioQUYELz5s2TxWLRunXryn1dv//+u7p27aqQkBBZLBZt3LixVPP37NlTbdq0KfH0v/32mwIDA7V//37XsNjYWF1xxRWlWm95yi9/b5s8ebJP1itJ8fHx6tmzp0/WLUkWi0WTJ0/22fqLM2fOHNWvX19ZWVklmv5sj2Ff1gVfeOaZZ9SoUSP5+fmpXbt2vg4Hp/BlXYyNjVV8fHyZLc9isWjs2LFltryyOleX9XYCFRnHA1C1kJBClZR/EZn/CQoKUp06ddSnTx/N/n/s3Xl4E9X7NvA76ZKtaQqlKxTKVpa2FgRk3wQFQQQVQUWhIKICP0RBARUVEBCURRSsKwiiICDIF0UU2RQLIlAEVDYpKLaUrVvSJmlz3j94EwlJ0wTSZNren+vqBZ2ZzDyZs8zM05kzixahoKDAJ3EsWbIEy5Yt88m2nDGbzXjggQdw+fJlLFiwACtWrEC9evUclrvjjjswZMgQr2zzxRdfxEMPPeR0O97y77//4tVXX/U4uVaZ/fzzz3j11VeRm5vr71Ak67PPPsPChQtv6LOpqakwmUx47733bNNWrlwJhUIBvV7vpQgrXn5+PqZNm4aUlBSEhIRApVIhKSkJkyZNwr///uuXmL777js8//zz6NixI5YuXYpZs2b5JQ6qvK49nsvlcsTGxuLOO+/Ejh07/B2a3xkMBrz66qs+3xeZmZkYPnw4GjZsCKVSiejoaHTp0gWvvPJKhW7XX9+3omRmZtrV76CgINSqVQsdOnTACy+8gLNnz/o7RLpOfHy8XZmV9ePP838iKQn0dwBE/jR9+nTUr18fZrMZ2dnZ2LFjB8aPH4/58+dj48aNuOWWWyp0+0uWLEGtWrX89pegU6dO4cyZM/jggw8wcuTIMpfr06cPZs6cCYvFArn8xvPYGRkZ2Lp1K37++ecbXoc7/v33X0ybNg3x8fGV6m6Ll156CZMnT76hz/7888+YNm0aUlNTERYW5t3AqojPPvsMR44cwfjx4z3+rFKpxLBhwzB//nz83//9H2QyGXr37o2SkhJs3boV/fv392qsN1MXyvLXX3+hZ8+eOHv2LB544AGMGjUKwcHB+O233/DRRx9h/fr1OH78uFe36Y5t27ZBLpfjo48+QnBwsM+3T1XDHXfcgaFDh0IIgdOnT2PJkiW4/fbb8fXXX+Ouu+7yd3guHTt27KaOra4YDAZMmzYNAHx2F+zJkyfRpk0bqFQqjBgxAvHx8cjKysKBAwcwZ84cWzwVwR/f1xceeugh9OnTBxaLBVeuXMG+ffuwcOFCvPXWW/joo4/w4IMP+jtE+v8WLlyIwsJC2+/ffPMNPv/8cyxYsAC1atWyTe/QoYM/wiOSHCakqFq766670Lp1a9vvU6ZMwbZt23D33XfjnnvuwR9//AGVSuXHCCtWTk4OAJSbwOjbty+effZZ7Nmz56YOoEuXLkXdunXRrl27G15HVaTX66HRaBAYGIjAQHbLUjVo0CDMnTsX27dvx+23347w8HC0bdsWX3/9tdcTUt6uCyUlJbjvvvtw/vx57NixA506dbKbP3PmTMyZM8cr27LWZ3fl5ORApVJ5NRllMBigVqu9tj5/Ky4uRnBwcIUlLaqChIQEPPLII7bf7733Xtxyyy1YuHChJBNSQggUFxdDpVJBoVD4OxyPuWrnCxYsQGFhITIyMhzuhraed5Bnbr31Vrv6DQBnzpzBnXfeiWHDhqFZs2ZISUnxU3R0rQEDBtj9np2djc8//xwDBgxAfHx8mZ/z9NhJVFXwzIboOrfffjumTp2KM2fO4NNPP7Wb9+eff2LgwIGoWbMmlEolWrdujY0bN9otY30ccNeuXXjiiScQHh6O0NBQDB06FFeuXLEtFx8fj6NHj2Lnzp2223ev/2ue0WjEs88+i4iICGg0Gtx77724cOGCW99j27Zt6Ny5MzQaDcLCwtC/f3/88ccftvmpqano2rUrAOCBBx5wun2rhIQENGzYEF9//XWZ29u/fz86dOgAlUqF+vXrIy0tzWGZDRs24Pbbby9zPJLvvvsOLVq0gFKpRPPmzfHll186LPPXX3/hgQceQM2aNaFWq9GuXTu7uHbs2IE2bdoAAIYPH+5wa/SJEydw//33Izo6GkqlEnXq1MGDDz6IvLy8Mr8bcPXxxmnTpqFx48ZQKpUIDw9Hp06d8P3339st9+eff2LQoEGIiIiASqVCkyZN8OKLL9rmW8dj+f333/Hwww+jRo0atuSAs7FarGOerFy5Ek2aNIFSqUSrVq2wa9cuu3U+99xzAID69evbvnNmZiYA4Pvvv0enTp0QFhaGkJAQNGnSBC+88ILL72u1Zs0aNG/eHEqlEklJSVi/fj1SU1MdTqrefPNNdOjQAeHh4VCpVGjVqhXWrl3rsD6j0YhnnnkGERER0Gq1uOeee/DPP/843faOHTvQunVrKJVKNGzYEO+9916Z49l8+umnaNWqFVQqFWrWrIkHH3wQf//9t21+t27d8PXXX+PMmTO2/XPtd3j77beRmJgItVqNGjVqoHXr1vjss8/sttGqVSvUrFkTX331lW1anz598M0335S5/wwGg8t+oCyu6sKGDRuQlJQEhUKBxMREfPvtt+Wub926dTh06BBefPFFh2QUAISGhmLmzJl209asWWPbp7Vq1cIjjzyCc+fO2S2TmpqKkJAQnDp1Cn369IFWq7U93muxWLBw4UIkJiZCqVQiKioKTzzxhN33l8lkWLp0KfR6vdPHGMorV+C/cez279+PLl26QK1W2+q30WjEK6+8gkaNGkGhUCAuLg7PP/+8w1hgnuzbc+fO4bHHHkNsbCwUCgXq16+Pp556CiaTybZMbm4uxo8fj7i4OCgUCjRq1Ahz5syBxWJxVUwArtZ7mUyGVatW4aWXXkLt2rWhVquRn58PANi7dy969+4NnU4HtVqNrl27Yvfu3XbrKCgowPjx4xEfHw+FQoHIyEjccccdOHDggN1y7pTx9ZKSktC9e3eH6RaLBbVr18bAgQPtppVXB4CryZnXXnsNderUgVqtRvfu3XH06NFy95UrycnJqFWrFk6fPu0wr7xyPnPmDEaPHo0mTZpApVIhPDwcDzzwgK1PvZ477dw6VuKWLVvQunVrqFQq2yPAzsbMyc3NxTPPPGMrwzp16mDo0KG4ePEiAMBkMuHll19Gq1atoNPpoNFo0LlzZ2zfvt22jszMTERERAAApk2bZmtj147XV965AuD6uOXMqVOnUKdOHaeP5kdGRjpM27x5sy0GrVaLvn37OpS/ta85d+4cBgwYgJCQEERERGDixIkoLS11+/t6ch63e/dut87BNm/ejK5du0Kr1SI0NBRt2rRxOH640249Va9ePSxbtgwmkwlz5861m+dOH2R9HPDNN9/EggULUK9ePahUKnTt2hVHjhxx2J63950n7d7T7/P++++jYcOGUCgUaNOmDfbt2+f0+5R1vrZ9+3bIZDKsX7/e4XOfffYZZDIZ0tPTncbqjps9dlq503ays7MxfPhw1KlTBwqFAjExMejfv3+Z/RmRzwmiamjp0qUCgNi3b5/T+X///bcAIAYOHGibduTIEaHT6UTz5s3FnDlzxDvvvCO6dOkiZDKZ+PLLLx3WnZycLDp37iwWLVokxowZI+RyuejSpYuwWCxCCCHWr18v6tSpI5o2bSpWrFghVqxYIb777ju7dbRs2VLcfvvt4u233xYTJkwQAQEBYtCgQeV+v++//14EBgaKhIQEMXfuXDFt2jRRq1YtUaNGDXH69GkhhBA///yzeOGFFwQAMW7cOLvtOzNu3DiRkpLiML1r164iNjZWREZGirFjx4pFixaJTp06CQDio48+si33zz//CABi0aJFDuuoV6+eSEhIEGFhYWLy5Mli/vz5Ijk5WcjlcruYsrOzRVRUlNBqteLFF18U8+fPFykpKUIul9vKIDs7W0yfPl0AEKNGjbLt21OnTgmj0Sjq168vYmNjxWuvvSY+/PBDMW3aNNGmTRuRmZnpUIbXeuGFF4RMJhOPP/64+OCDD8S8efPEQw89JF5//XXbMocOHRKhoaEiPDxcTJkyRbz33nvi+eefF8nJybZlXnnlFQFANG/eXPTv318sWbJELF682G7etQCIpKQkUatWLTF9+nQxZ84cUa9ePaFSqcThw4dt233ooYcEALFgwQLbdy4sLBRHjhwRwcHBonXr1uKtt94SaWlpYuLEiaJLly522xk2bJjo2rWr3bRNmzYJmUwmbrnlFjF//nwxdepUUaNGDZGUlCTq1atnt2ydOnXE6NGjxTvvvCPmz58vbrvtNgFAbNq0yW65Rx55RAAQDz/8sHjnnXfEfffdJ2655RYBQLzyyiu25Q4cOCAUCoWIj48Xr7/+upg5c6aIjY0VKSkpDvvotddeEzKZTAwePFgsWbLEVt/j4+PFlStXhBBCfPfdd6JFixaiVq1atv2zfv16IYQQ77//vq29v/fee+Ktt94Sjz32mBg3bpy4Xs+ePUWrVq3s4gQgDh48aLecu/1AWcqqCykpKSImJkbMmDFDLFy4UDRo0ECo1Wpx8eJFl+t7+OGHBQBx9uxZl8tdH3+bNm3EggULxOTJk4VKpbLbp0JcrTcKhUI0bNhQDBs2TKSlpYnly5cLIYQYOXKkCAwMFI8//rhIS0sTkyZNEhqNRrRp00aYTCYhhBArVqwQnTt3FgqFwq6tCuFeuQpxtQ+Kjo4WERER4v/+7//Ee++9JzZs2CBKS0vFnXfeKdRqtRg/frx47733xNixY0VgYKDo37//De3bc+fOidjYWNs609LSxNSpU0WzZs1sMen1enHLLbeI8PBw8cILL4i0tDQxdOhQIZPJxNNPP13uvt++fbutj2jRooWYP3++mD17ttDr9eKHH34QwcHBon379mLevHliwYIF4pZbbhHBwcFi7969duUdHBwsnn32WfHhhx+KOXPmiH79+olPP/3U4zK+vi5Onz5dyOVykZWVZRf3zp07BQCxZs0a2zR36oAQQrz00ksCgOjTp4945513xIgRI0RsbKyoVauWGDZsWLn7DIAYM2aM3bTLly+LgIAA0a5dO7vl3CnnNWvWiJSUFPHyyy+L999/X7zwwguiRo0aol69ekKv1zvsQ3faeb169USjRo1EjRo1xOTJk0VaWprYvn27bd6137OgoEAkJSWJgIAA8fjjj4t3331XzJgxQ7Rp08bW11y4cEHExMSIZ599Vrz77rti7ty5okmTJiIoKMi2TGFhoXj33XcFAHHvvffa2tihQ4eEEO6dKwjh+rjlzKhRo0RAQID44Ycfyi275cuXC5lMJnr37i3efvttMWfOHBEfHy/CwsLsYhg2bJhQKpUiMTFRjBgxQrz77rvi/vvvFwDEkiVL3Pq+np7HuXMOtnTpUiGTyURSUpKYOXOmWLx4sRg5cqR49NFHbcu4226dOX36tAAg3njjjTKXadiwoYiIiLD97m4fZF13cnKyiI+PF3PmzBHTpk0TNWvWFBERESI7O9u2bEXsO3fbvaffp2XLlqJRo0Zizpw5Yu7cuaJWrVqiTp06dn1OeedrFotFxMXFifvvv99hf/fp00c0bNiw7EK7zhtvvCEAONTnmzl2CuF+2+nQoYPQ6XTipZdeEh9++KGYNWuW6N69u9i5c6fb34GoIjEhRdVSeQkpIYTQ6XSiZcuWtt979OghkpOTRXFxsW2axWIRHTp0EI0bN3ZYd6tWrewOHHPnzhUAxFdffWWblpiY6JAEuHYdPXv2tDuhfeaZZ0RAQIDIzc11+f1atGghIiMjxaVLl2zTDh06JORyuRg6dKhtmvXC59oLiLJ8++23AoD4559/7KZ37dpVABDz5s2zTTMajbYYrPtg69atAoD43//+57DuevXqCQBi3bp1tml5eXkiJibGrgzGjx8vAIgff/zRNq2goEDUr19fxMfHi9LSUiGEEPv27RMAxNKlS+22c/DgQbe+r7OEVEpKiujbt6/Lz3Xp0kVotVpx5swZu+nXlqH1xP6hhx5y+HxZSQgA4tdff7VNO3PmjFAqleLee++1TXN2wiOEEAsWLBAAxIULF1zG7iwhlZycLOrUqSMKCgps03bs2CEAOCSkDAaD3e8mk0kkJSWJ22+/3TYtIyNDABCjR4+2W9aaLLk2IdWvXz+hVqvFuXPnbNNOnDghAgMD7fZRZmamCAgIEDNnzrRb5+HDh0VgYKDd9L59+zrELYQQ/fv3F4mJiQ7TnRk1apRQqVR202JiYhy270k/4ExZdSE4OFicPHnSNu3QoUMCgHj77bddrq9ly5ZCp9O5XMbKZDKJyMhIkZSUJIqKimzTN23aJACIl19+2TZt2LBhAoCYPHmy3Tp+/PFHAUCsXLnSbrq1H7l2+rBhw4RGo7FbzpNytfZBaWlpdsuuWLFCyOVyu/5CCCHS0tIEALF7927bNHf37dChQ4VcLnd67LC28xkzZgiNRiOOHz9uN3/y5MkiICCg3KSgtV9u0KCBXbuyWCyicePGolevXnZ9isFgEPXr1xd33HGHbZpOp3NI0FzLkzK+vi4eO3bMaZ0bPXq0CAkJscXsbh3IyckRwcHBom/fvnbfy/oHE3cTUo899pi4cOGCyMnJEXv37hU9evRwODa5W87X92dCCJGeni4A2C4ahfCsnVuPc99++63Duq9PSL388ssCgN2FvpV1H5WUlAij0Wg378qVKyIqKkqMGDHCNu3ChQsO/auVu+cKro5bzhw5ckSoVCoBQLRo0UI8/fTTYsOGDXbJPCGuHr/DwsLE448/bjc9Oztb6HQ6u+nWvmb69Ol2y7Zs2dLujwSuvq+n53HlnYPl5uYKrVYr2rZta9eOrOu1/utuu3XGnYRU//79BQCRl5cnhHC/D7KuW6VS2Z3b7d27VwAQzzzzTIXtO0/avaffJzw8XFy+fNm23FdffeVw/unO+dqUKVOEQqGwO+fOyckRgYGBTutXWcpKSN3MsdPdtnPlypVy6w+Rv/GRPaIyhISE2N62d/nyZWzbtg2DBg1CQUEBLl68iIsXL+LSpUvo1asXTpw44fCYw6hRoxAUFGT7/amnnkJgYKDLx3uuN2rUKLvHdjp37ozS0lKcOXOmzM9kZWUhIyMDqampqFmzpm36LbfcgjvuuMOj7V+rW7du0Gg0Tj8fGBiIJ554wvZ7cHAwnnjiCeTk5GD//v0AgEuXLgEAatSo4XT9sbGxuPfee22/Wx97OHjwILKzswFcHRjytttus3tUICQkBKNGjUJmZiZ+//13l99Bp9MBALZs2QKDweDO17YJCwvD0aNHceLECafzL1y4gF27dmHEiBGoW7eu3Txnj5g9+eSTbm+7ffv2aNWqle33unXron///tiyZYvtUQVXcQPAV1995dbjQlb//vsvDh8+jKFDhyIkJMQ2vWvXrkhOTnZY/tqx1q5cuYK8vDx07tzZ7hEha90ZN26c3WevH2S8tLQUW7duxYABAxAbG2ub3qhRI4exYL788ktYLBYMGjTI1i4vXryI6OhoNG7c2O7xlbKEhYXhn3/+cXpL//Vq1KiBoqIiu/rTp0+fMh9n9UY/cK2ePXuiYcOGtt9vueUWhIaG4q+//nL5ufz8fGi1Wre28euvvyInJwejR4+GUqm0Te/bty+aNm3q9Ls+9dRTdr+vWbMGOp0Od9xxh125tGrVCiEhIeWWi6flqlAoMHz4cIcYmjVrhqZNm9qt4/bbbwcAh3WUt28tFgs2bNiAfv362Y09aGVt52vWrEHnzp1Ro0YNu+327NkTpaWldo/bujJs2DC7dpWRkYETJ07g4YcfxqVLl2zr1ev16NGjB3bt2mVr42FhYdi7d2+Zb068kTK2SkhIQIsWLbB69WrbtNLSUqxduxb9+vWzxexuHdi6dStMJpPtZQFWnr584KOPPkJERAQiIyPRtm1b2yND16/HnTZ07X43m824dOkSGjVqhLCwMIfHHgH323n9+vXRq1evcr/LunXrkJKSYndMtLLuo4CAANu4axaLBZcvX0ZJSQlat27tNMbr3ci5grvHrcTERGRkZOCRRx5BZmYm3nrrLQwYMABRUVH44IMPbMt9//33yM3NxUMPPWRXRwICAtC2bVun/cT1MXTu3Lnc/g+48fM4V+dg33//PQoKCjB58mS7dgT8V06etNsbZT1GW89ZPe2DBgwYgNq1a9t+v+2229C2bVtbHaiIfedJu/f0+wwePNjuXLNz584AYKsn7p6vDR06FEaj0W74gdWrV6OkpMRhPK8bdaPHTnfbjnV8xh07drg1XACRP3D0XKIyFBYW2sY6OHnyJIQQmDp1KqZOnep0+ZycHLsDeuPGje3mh4SEICYmxqNntq8/UFoPsK4OKtaDfZMmTRzmNWvWDFu2bLmhgRMVCoXtjUWPP/643bzY2FiH9SUkJAC4+kz/tYOYCyGcrr9Ro0YOiZtr1xEdHY0zZ86gbdu2Tr8XcPW7JyUllfkd6tevj2effRbz58/HypUr0blzZ9xzzz145JFHbMmqskyfPh39+/dHQkICkpKS0Lt3bzz66KO2NzFaT3Rcbf/6WNx1fV0Cru4bg8GACxcuIDo6uszPDh48GB9++CFGjhyJyZMno0ePHrjvvvswcOBAlwMkW+tRo0aNHOY1atTI4YJn06ZNeO2115CRkWE3Ps+1ZXrmzBnI5XK7i0HAsa7m5OSgqKiozG1f68SJExBCON1HAOwuEssyadIkbN26FbfddhsaNWqEO++8Ew8//DA6duzosKy1/l77vfr06YOlS5fi0qVLCA8Pt1veG/3Ata7vE4Cr/UJ5J5ruJK2sXPUhTZs2xU8//WQ3LTAwEHXq1LGbduLECeTl5TkdLwYof2BjT8u1du3aDoOinzhxAn/88YdtTJnyYihv3164cAH5+fnltvETJ07gt99+K3e7Fy5csEsoh4SE2CV/r+8jrMnwYcOGlbntvLw81KhRA3PnzsWwYcMQFxeHVq1aoU+fPhg6dCgaNGgAwPMyvt7gwYPxwgsv4Ny5c6hduzZ27NiBnJwcDB482C5ed+qANZbryzoiIqLMP2A4079/f4wdOxYymQxarRaJiYlOj3PutKGioiLMnj0bS5cuxblz5+yOW87GG3S3nbvb7586dQr3339/uct98sknmDdvHv7880+YzWaPtnMj5wqeHLcSEhKwYsUKlJaW4vfff8emTZswd+5cjBo1CvXr10fPnj1tddqaJL5eaGio3e9KpdKhXbnT/wE3dh5X3jnYqVOnALg+7nvSbm+U9Y1u1j86uNsHWZV1jvHFF18AqJh950m79/T7lLdtd8/XmjZtijZt2mDlypV47LHHAAArV65Eu3btnJ6feOpmjp3uth2FQoE5c+ZgwoQJiIqKQrt27XD33Xdj6NChLs8diXyJCSkiJ/755x/k5eXZDjjWv15NnDixzL9ueuPgdL2AgACn08tK6lS0vn37YsKECTCZTB6/Ect6oe7vv9DMmzcPqamp+Oqrr/Ddd99h3LhxmD17Nvbs2eNwYnCtLl264NSpU7bPffjhh1iwYAHS0tIwcuRIj+Pw1dsbVSoVdu3ahe3bt+Prr7/Gt99+i9WrV+P222/Hd999V2Yd88SPP/6Ie+65B126dMGSJUsQExODoKAgLF261GFgV2+zWCyQyWTYvHmz0+9y7QV+WZo1a4Zjx45h06ZN+Pbbb7Fu3TosWbIEL7/8ssPrya9cuQK1Wm1XfnfccQcCAgLw7bff2gYlrSg32ic0bdoUBw8exN9//424uDivxqRQKBySmxaLBZGRkVi5cqXTz5R1YXHt5z0pV2ftyWKxIDk5GfPnz3e6jev3g7f6W4vFgjvuuAPPP/+80/nWRHubNm3s7nZ95ZVX7AZfvv47WY9Db7zxBlq0aOF03db9MmjQIHTu3Bnr16/Hd999hzfeeANz5szBl19+6ZU3zg0ePBhTpkzBmjVrMH78eHzxxRfQ6XTo3bu3Xbw3Uwc8VadOHfTs2bPc5dwp5//7v//D0qVLMX78eLRv3x46nQ4ymQwPPvjgTd3N4s1+/9NPP0VqaioGDBiA5557DpGRkQgICMDs2bNtiRJvu5H4AwICkJycjOTkZLRv3x7du3fHypUr0bNnT9u+XLFihdOL4+vfNHozx6sbOY/zRp/gSbu9UUeOHEFkZKQtCeFuH+Quf+27a7fvyffx5raHDh2Kp59+Gv/88w+MRiP27NmDd955x+P1OHMzx05P2s748ePRr18/bNiwAVu2bMHUqVMxe/ZsbNu2DS1btvTKdyG6GUxIETmxYsUKALAdeK1/VQ4KCnLrhBe4+teLa99EVFhYiKysLPTp08c2ray3zd0M61ttjh075jDvzz//RK1atW74tbJ9+vTBk08+iZ07d+KOO+6wTf/3338d/pJ6/PhxALC9yaxp06YA4PSNR8B/f4G7dp9cv4569eqV+b2s84Hy96v15Pill17Czz//jI4dOyItLQ2vvfaay8/VrFkTw4cPx/Dhw1FYWIguXbrg1VdfxciRI211xNmbaW6Ws8cEjx8/DrVabTs5cfWd5XI5evTogR49emD+/PmYNWsWXnzxRWzfvr3M+mzdlydPnnSYd/20devWQalUYsuWLXavL1+6dKnDOi0WC06dOmX3V/nryzQyMhJKpdKtbTds2BBCCNSvX7/ck2xX+0ij0WDw4MEYPHgwTCYT7rvvPsycORNTpkyxexTj9OnTtjvyrLRaLTp37oxvvvnGISHlTj/gC/369cPnn3+OTz/9FFOmTHG57LV9yPV/fT127JjTN2ddr2HDhti6dSs6dux4QxexnpSrq3UcOnQIPXr08EpfGxERgdDQ0HLbeMOGDVFYWFjusWLlypUoKiqy/W7tQ1ytF7j6l293jkMxMTEYPXo0Ro8ejZycHNx6662YOXMm7rrrrpsu4/r16+O2227D6tWrMXbsWHz55ZcYMGCAXft3tw5Yt3XixAm7fXDhwgW//QFj7dq1GDZsGObNm2ebVlxcjNzcXKfLe7udN2zYsNx6tnbtWjRo0ABffvmlXf1+5ZVX7JYrq+5X5LlCWayPumZlZQH4r05HRka6fW5VnrK+742cx5XHGv+RI0fK/KOkp+3WU+np6Th16pTdI2Tu9kFWZZ1jWM+9KmLfedLuPf0+5fHkfO3BBx/Es88+i88//xxFRUUICgqyuxPU29ztNz1tOw0bNsSECRMwYcIEnDhxAi1atMC8efMc3iZO5A8cQ4roOtu2bcOMGTNQv35928VlZGQkunXrhvfee892InUtZ68Bfv/99+1uoX/33XdRUlJi99dpjUZT5gnujYqJiUGLFi3wySef2K37yJEj+O67727qQjguLg7JyckO44uUlJTYXl8NXH0d9XvvvYeIiAjb2Ee1a9dGXFwcfv31V6fr/vfff+1er5ufn4/ly5ejRYsWtr/+9OnTB7/88ovdq3b1ej3ef/99xMfHo3nz5gBgO4m+ft/m5+ejpKTEblpycjLkcrnDa+CvZx0DyyokJASNGjWyfS4iIgJdunTBxx9/jLNnz9ote7N3tKWnp9s9Ivf333/jq6++wp133mn7S2BZ3/ny5csO67P+ldbVd46NjUVSUhKWL19uexwAAHbu3InDhw/bLRsQEACZTGb3+FFmZiY2bNhgt5y17i9atMhu+sKFCx3W17NnT2zYsMFuDJyTJ09i8+bNdsved999CAgIwLRp0xz2sxDCrtw0Go3Tx22uL9vg4GA0b94cQgi7NgwABw4cQIcOHRzW0bdvX3z77bcOY3q50w/4wsCBA5GcnIyZM2c6fVV1QUGB7XXXrVu3RmRkJNLS0uzqyObNm/HHH3+gb9++5W5v0KBBKC0txYwZMxzmlZSUlNvveVKurmI4d+6c3Zg1VkVFRdDr9eWu41pyuRwDBgzA//73P6f9mDXOQYMGIT09HVu2bHFYJjc319YHdezYET179rT9lJeQatWqFRo2bIg333zTrk1aWY9DpaWlDvU8MjISsbGxtvL0RhkPHjwYe/bswccff4yLFy86XKS5Wwd69uyJoKAgvP3223ZlfX2/4EsBAQEO9e7tt98uc8w+b7fz+++/H4cOHXL6ynlrXNa+/9o49+7d69C+1Wo1AMdjQ0WeK/z4448OfSfw3ziC1j9I9OrVC6GhoZg1a5bT5Z2dW5WnrO97I+dx5bnzzjuh1Woxe/ZsFBcX282zlou77fZGnDlzBqmpqQgODsZzzz1nm+5uH2S1YcMGuzGgfvnlF+zdu9dWfyti33nS7j39PuXx5HytVq1auOuuu/Dpp59i5cqV6N27N2rVquXR9jzhbr/pbtsxGAwOdbNhw4bQarXlnvcS+QrvkKJqbfPmzfjzzz9RUlKC8+fPY9u2bfj+++9Rr149bNy40e7OiMWLF6NTp05ITk7G448/jgYNGuD8+fNIT0/HP//8g0OHDtmt22QyoUePHhg0aBCOHTuGJUuWoFOnTrjnnntsy7Rq1QrvvvsuXnvtNTRq1AiRkZFlPg/uiTfeeAN33XUX2rdvj8ceewxFRUV4++23odPp7B4JuRF9+vTBunXr7E4aYmNjMWfOHGRmZiIhIQGrV69GRkYG3n//fbuxXvr374/169c73AkFXL3l+rHHHsO+ffsQFRWFjz/+GOfPn7e7y2by5Mn4/PPPcdddd2HcuHGoWbMmPvnkE5w+fRrr1q2z3frcsGFDhIWFIS0tDVqtFhqNBm3btsWhQ4cwduxYPPDAA0hISEBJSQlWrFiBgICAcsfraN68Obp164ZWrVqhZs2a+PXXX7F27VqMHTvWtsyiRYvQqVMn3HrrrbZxMjIzM/H1118jIyPjhvd5UlISevXqhXHjxkGhUGDJkiUAYPc4mTXx9+KLL+LBBx9EUFAQ+vXrh+nTp2PXrl3o27cv6tWrh5ycHCxZsgR16tSxGxzemVmzZqF///7o2LEjhg8fjitXruCdd95BUlKS3Yl13759MX/+fPTu3RsPP/wwcnJysHjxYjRq1Ai//fabbbkWLVrgoYcewpIlS5CXl4cOHTrghx9+cHon1KuvvorvvvsOHTt2xFNPPYXS0lLbtq/dlw0bNsRrr72GKVOmIDMzEwMGDIBWq8Xp06exfv16jBo1ChMnTrTto9WrV+PZZ59FmzZtEBISgn79+uHOO+9EdHQ0OnbsiKioKPzxxx9455130LdvX7uBwPfv34/Lly+jf//+DvH26dMHEyZMwJ49e+zGnnKnH/CFoKAgfPnll+jZsye6dOmCQYMGoWPHjggKCsLRo0fx2WefoUaNGpg5cyaCgoIwZ84cDB8+HF27dsVDDz2E8+fP46233kJ8fDyeeeaZcrfXtWtXPPHEE5g9ezYyMjJw5513IigoCCdOnMCaNWvw1ltvYeDAgWV+3pNyLcujjz6KL774Ak8++SS2b9+Ojh07orS0FH/++Se++OILbNmyxeng5K7MmjUL3333Hbp27YpRo0ahWbNmyMrKwpo1a/DTTz8hLCwMzz33HDZu3Ii7774bqampaNWqFfR6PQ4fPoy1a9ciMzPzhi5o5HI5PvzwQ9x1111ITEzE8OHDUbt2bZw7dw7bt29HaGgo/ve//6GgoAB16tTBwIEDkZKSgpCQEGzduhX79u2z3fHjjTIeNGgQJk6ciIkTJ6JmzZoOf6V3tw5ERERg4sSJmD17Nu6++2706dMHBw8exObNmyv0ws+Vu+++GytWrIBOp0Pz5s2Rnp6OrVu3OowRZ+Xtdv7cc89h7dq1eOCBBzBixAi0atUKly9fxsaNG5GWloaUlBTcfffd+PLLL3Hvvfeib9++OH36NNLS0tC8eXO7/lmlUqF58+ZYvXo1EhISULNmTSQlJSEpKanCzhXmzJmD/fv347777rONs3jgwAEsX74cNWvWtA1cHRoainfffRePPvoobr31Vjz44IOIiIjA2bNn8fXXX6Njx44ePx7l6vt6eh5XntDQUCxYsAAjR45EmzZt8PDDD6NGjRo4dOgQDAYDPvnkE7fbbXkOHDiATz/9FBaLBbm5udi3bx/WrVsHmUyGFStW2PYzAI/7oEaNGqFTp0546qmnYDQasXDhQoSHh9s9IuftfedJu6+IPtWT87WhQ4fajlfOEkXe5G6/6W7bOX78uK1vat68OQIDA7F+/XqcP38eDz74YIV+FyK3Vfh7/IgkyPpaWutPcHCwiI6OFnfccYd46623RH5+vtPPnTp1SgwdOlRER0eLoKAgUbt2bXH33XeLtWvXOqx7586dYtSoUaJGjRoiJCREDBkyxO7VykJcfT1r3759hVarFQBE165d7dZx/avFra8D3759e7nfcevWraJjx45CpVKJ0NBQ0a9fP/H77787Xd+aNWvc2GtX7dq1SwAQx44dE0JcfeV6YmKi+PXXX0X79u2FUqkU9erVE++8847DZw8cOCAAOLyGvV69eqJv375iy5Yt4pZbbhEKhUI0bdrUaVynTp0SAwcOFGFhYUKpVIrbbrtNbNq0yWG5r776SjRv3lwEBgYKAGLp0qXir7/+EiNGjBANGzYUSqVS1KxZU3Tv3l1s3brV7rPW/X+t1157Tdx2220iLCxMqFQq0bRpUzFz5ky7V30LcfV11/fee68tviZNmoipU6fa5ltfn33hwgWHmK9/vboQV19TPmbMGPHpp5+Kxo0bC4VCIVq2bOm0DsyYMUPUrl1byOVy2yuGf/jhB9G/f38RGxsrgoODRWxsrHjooYccXp88bNgwW/271qpVq0TTpk2FQqEQSUlJYuPGjeL+++8XTZs2tVvuo48+ssXXtGlTsXTpUqffp6ioSIwbN06Eh4cLjUYj+vXrJ/7++2+nr+n+4YcfRMuWLUVwcLBo2LCh+PDDD8WECROEUql0iHPdunWiU6dOQqPRCI1GI5o2bSrGjBljq6dCCFFYWCgefvhhERYWJgCIevXqCSGEeO+990SXLl1EeHi4UCgUomHDhuK5556zvULbatKkSaJu3bp2r4W+VoMGDcSUKVOEEJ71A864qgvXu/6V8a5cuXJFvPzyyyI5OVmo1WqhVCpFUlKSmDJlisjKyrJbdvXq1aJly5ZCoVCImjVriiFDhti9GlyIq/VGo9GUub33339ftGrVSqhUKqHVakVycrJ4/vnnxb///uvWOtwpV2sf5IzJZBJz5swRiYmJQqFQiBo1aohWrVqJadOm2ZWvJ/v2zJkzYujQoSIiIkIoFArRoEEDMWbMGGE0Gm3LFBQUiClTpohGjRqJ4OBgUatWLdGhQwfx5ptvOvQZ1yuvXz548KC47777bPW1Xr16YtCgQeKHH34QQghhNBrFc889J1JSUoRWqxUajUakpKSIJUuWOKzLnTJ2VhetOnbsKACIkSNHlvl93KkDpaWlYtq0aSImJkaoVCrRrVs3ceTIEbfrdlnl5+5y12/nypUrYvjw4aJWrVoiJCRE9OrVS/z5558Oy3nSzq3HOWecfc9Lly6JsWPHitq1a4vg4GBRp04dMWzYMHHx4kUhxNXX08+aNUvUq1fPdlzYtGmTGDZsmK1vs/r5559Fq1atRHBwsENf6865gqvjljO7d+8WY8aMEUlJSUKn04mgoCBRt25dkZqaKk6dOuWw/Pbt20WvXr2ETqcTSqVSNGzYUKSmpopff/3VtkxZ/YSz+unq+3pyHufuOdjGjRtFhw4dbPvwtttuE59//rndMuW127KcPn3a7nw1MDBQ1KxZU7Rt21ZMmTJFnDlzxunn3OmDrOt+4403xLx580RcXJxQKBSic+fO4tChQw7r9Pa+86Tde/p9rufsHKO88zUro9EoatSoIXQ6nSgqKnK6v1154403bOdkVt44dgpRftu5ePGiGDNmjGjatKnQaDRCp9OJtm3bii+++MLj70FUUWRC+Gl0ZKIqatmyZRg+fDj27dvn8V/fK4PS0lLUqlULr7zyisev5QaAHj16IDY21jZOlxRZy1AK3aNMJsOYMWO8NohmWVJTU5GZmYkdO3aUu2yLFi0QERGB77//vkJjcmbAgAE4evSo0zEvKpLRaER8fDwmT56Mp59+2uky//d//4cff/zxpu6GIyIi8oXMzEzUr18fb7zxRrl3nFZnJSUliI2NRb9+/fDRRx/5OxyiKodjSBGRRwICArBo0SKXb6RzZdasWVi9erXd26VImsxms8PYDDt27MChQ4fQrVu3Ct/+tQM+A1cHP/3mm298su3rLV26FEFBQXjyySfLXGbUqFG49957nY7nQERERJXPhg0bcOHCBQwdOtTfoRBVSRxDiog89uijj97wZ9u2bQuTyeTFaKiinDt3Dj179sQjjzyC2NhY/Pnnn0hLS0N0dLTLxIy3NGjQAKmpqWjQoAHOnDmDd999F8HBwWW++rkiPfnkk+V+Z+vbG4mIiKhy27t3L3777TfMmDEDLVu2RNeuXf0dElGVxIQUERE5VaNGDbRq1QoffvghLly4AI1Gg759++L1118vc3Bfb+rduzc+//xzZGdnQ6FQoH379pg1axYaN25c4dsmIiKi6uvdd9/Fp59+ihYtWmDZsmX+DoeoyuIYUkRERERERERE5FMcQ4qIiIiIiIiIiHyKCSkiIiIiIiIiIvIpJqSIiIiIiIiIiMinqvyg5haLBf/++y+0Wi1kMpm/wyEiIiIiIiIikgwhBAoKChAbGwu53Hf3LVX5hNS///6LuLg4f4dBRERERERERCRZf//9N+rUqeOz7VX5hJRWqwVwdceGhob6ORoiIiIiIiIiIunIz89HXFycLX/iK1U+IWV9TC80NJQJKSIiIiIiIiIiJ3w9zBEHNSciIiIiIiIiIp9iQoqIiIiIiIiIiHyKCSkiIiIiIiIiIvKpKj+GFBEREREREVUtpaWlMJvN/g6DqFIICgpCQECAv8NwwIQUERERERERVQpCCGRnZyM3N9ffoRBVKmFhYYiOjvb5wOWuMCFFRERERERElYI1GRUZGQm1Wi2pi2siKRJCwGAwICcnBwAQExPj54j+w4QUERERERERSV5paaktGRUeHu7vcIgqDZVKBQDIyclBZGSkZB7f8+ug5rt27UK/fv0QGxsLmUyGDRs22OaZzWZMmjQJycnJ0Gg0iI2NxdChQ/Hvv//6L2AiIiIiIiLyC+uYUWq12s+REFU+1nYjpbHX/JqQ0uv1SElJweLFix3mGQwGHDhwAFOnTsWBAwfw5Zdf4tixY7jnnnv8ECkREREREVH59MYS/JtnxKmLRcjKM0JvLPF3SFUOH9Mj8pwU241fE1J33XUXXnvtNdx7770O83Q6Hb7//nsMGjQITZo0Qbt27fDOO+9g//79OHv2rB+iJSIiIiIiKtslvRmLf8zC5I2ZmLb5LCZtzMSSH7NwSS+dOxKIbsT777+PuLg4yOVyLFy40Om0V199FS1atLB9JjU1FQMGDLD93q1bN4wfP96ncVvt2LEDMpnML4PhZ2ZmQiaTISMjw+fbljq/JqQ8lZeXB5lMhrCwMH+HQkREREREZKM3luCj9GwcyTLYTT+cZcDH6dm8U6oaS0tLg1arRUnJf3WgsLAQQUFB6Natm92y1sTJqVOnAADx8fGQyWRYtWqVw3oTExMhk8mwbNky2zTr8tf+1KlT56biz8/Px9ixYzFp0iScO3cOo0aNcjpt4sSJ+OGHH8pcz5dffokZM2a4vV1/JpFu1PVJOHKt0iSkiouLMWnSJDz00EMIDQ0tczmj0Yj8/Hy7HyIiIiIiooqUV1zqkIyyOpxlQF5xqY8jIqno3r07CgsL8euvv9qm/fjjj4iOjsbevXtRXFxsm759+3bUrVsXDRs2tE2Li4vD0qVL7da5Z88eZGdnQ6PROGxv+vTpyMrKsv0cPHjwpuI/e/YszGYz+vbti5iYGKjVaqfTQkJCXA42X7NmTWi12puKhf5jMpn8HcJNqxQJKbPZjEGDBkEIgXfffdflsrNnz4ZOp7P9xMXF+ShKIiIiIiKqrorMlpuaT1VXkyZNEBMTgx07dtim7dixA/3790f9+vWxZ88eu+ndu3e3+/yQIUOwc+dO/P3337ZpH3/8MYYMGYLAwECH7Wm1WkRHR9t+IiIiXMY3adIkJCQkQK1Wo0GDBpg6dapt4Otly5YhOTkZANCgQQPbHVnXT8vMzHR4ZO961z+yt2LFCrRu3doW78MPP4ycnBwAVx9zs+6HGjVqQCaTITU1FQBgsVgwe/Zs1K9fHyqVCikpKVi7dq3dtr755hskJCRApVKhe/fuyMzMdLkPAGD+/Pm2l6rFxcVh9OjRKCwstM139v0WLlyI+Ph42/xPPvkEX331le3utGvL/K+//kL37t2hVquRkpKC9PR0u3WtW7cOiYmJUCgUiI+Px7x58+zmx8fHY8aMGRg6dChCQ0MxatQomEwmjB07FjExMVAqlahXrx5mz55d7neVCsknpKzJqDNnzuD77793eXcUAEyZMgV5eXm2n2sbLRERERERUUVQBbm+tCpvPvmW2aBHUU42Cs6eRlHOeZgN+grdXvfu3bF9+3bb79u3b0e3bt3QtWtX2/SioiLs3bvXISEVFRWFXr164ZNPPgFw9QVgq1evxogRI7wSm1arxbJly/D777/jrbfewgcffIAFCxYAAAYPHoytW7cCAH755RdkZWXhgQcecJh2IzeCmM1mzJgxA4cOHcKGDRuQmZlpSzrFxcVh3bp1AIBjx44hKysLb731FoCrN6EsX74caWlpOHr0KJ555hk88sgj2LlzJwDg77//xn333Yd+/fohIyMDI0eOxOTJk8uNRy6XY9GiRTh69Cg++eQTbNu2Dc8//7zb32fixIkYNGgQevfubbs7rUOHDrb5L774IiZOnIiMjAwkJCTgoYcesj3GuX//fgwaNAgPPvggDh8+jFdffRVTp061exwTAN58802kpKTg4MGDmDp1KhYtWoSNGzfiiy++wLFjx7By5UpbgqwycEynSog1GXXixAls377d5e1/VgqFAgqFwgfRERERERERXaVTBiA5Ro3DTh7bS45RQ6cM8ENU5Iwx9wpOrV2J/ON/2KbpEpqhwcAhUITVqJBtdu/eHePHj0dJSQmKiopw8OBBdO3aFWazGWlpaQCA9PR0GI1Gh4QUAIwYMQITJkzAiy++iLVr16Jhw4Zl3o00adIkvPTSS7bfZ82ahXHjxpUZ27XLxsfHY+LEiVi1ahWef/55qFQq23V4REQEoqOjAcDpNE9dm1Br0KABFi1ahDZt2qCwsBAhISGoWbMmACAyMtI2jrTRaMSsWbOwdetWtG/f3vbZn376Ce+99x66du2Kd999Fw0bNrTdYdSkSRMcPnwYc+bMcRnPtXdvxcfH47XXXsOTTz6JJUuWuPV9QkJCoFKpYDQane6TiRMnom/fvgCAadOmITExESdPnkTTpk0xf/589OjRA1OnTgUAJCQk4Pfff8cbb7xhS9IBwO23344JEybYfj979iwaN26MTp06QSaToV69em7FKhV+TdMXFhYiIyPDNtr86dOnkZGRYXsedeDAgfj111+xcuVKlJaWIjs7G9nZ2VXiWUkiIiIiIqo6NIpAjGgfjeQYtd305Bg1HmsfDY1C0vcCVBtmg94hGQUAecf/wF9rV1bYnVLdunWDXq/Hvn378OOPPyIhIQERERHo2rWrbRypHTt2oEGDBqhbt67D5/v27YvCwkLs2rULH3/8scu7o5577jnbdXZGRgaGDh0KAHjyyScREhJi+7FavXo1OnbsiOjoaISEhOCll17yyZvt9+/fj379+qFu3brQarXo2rUrALjc9smTJ2EwGHDHHXfYfZfly5fbBoL/448/0LZtW7vPWZNXrmzduhU9evRA7dq1odVq8eijj+LSpUswGJyPDeepW265xfb/mJgYALA9ovjHH3+gY8eOdst37NgRJ06cQGnpf+PPtW7d2m6Z1NRUZGRkoEmTJhg3bhy+++47r8TqK37tFX/99Ve77O+zzz4LABg2bBheffVVbNy4EQAcMr/W2xuJiIiIiIikIlwThNGdY5BXXIoiswWqIDl0ygAmoySkpLDAIRlllXf8D5QUFiBI7ThQ+M1q1KgR6tSpg+3bt+PKlSu25EtsbCzi4uLw888/Y/v27bj99tudfj4wMBCPPvooXnnlFezduxfr168vc1u1atVCo0aNHKZPnz4dEydOtJuWnp6OIUOGYNq0aejVqxd0Oh1WrVrlMH6Rt+n1evTq1Qu9evXCypUrERERgbNnz6JXr14ub0Cxjun09ddfo3bt2nbzbuZJqczMTNx999146qmnMHPmTNSsWRM//fQTHnvsMZhMJqjVasjlcggh7D5nHWvLHUFBQbb/y2QyAFfHw/LE9YPY33rrrTh9+jQ2b96MrVu3YtCgQejZs6fDmFpS5deesVu3bg4Fei1X84iIiIiIiKRGowhkAkrCSoqLyplf7HL+zejevTt27NiBK1eu4LnnnrNN79KlCzZv3oxffvkFTz31VJmfHzFiBN58800MHjwYNWp4/mhhZGQkIiMj7ab9/PPPqFevHl588UXbtDNnzni8bk/9+eefuHTpEl5//XXb+FPXvoUQAIKDgwHA7g6h5s2bQ6FQ4OzZs7ak3vWaNWtmu7nF6tqB453Zv38/LBYL5s2bB7n86oNkX3zxhd0yERERyM7OhhDCllCyPu11bczXxuuuZs2aYffu3XbTdu/ejYSEBAQEuH7cNzQ0FIMHD8bgwYMxcOBA9O7dG5cvX7Y98ihl7CmJiIiIiIioWghUqsqZr6ywbXfv3h1jxoyB2Wy2S6Z07doVY8eOhclkcjp+lFWzZs1w8eJFqNXqMpfxVOPGjXH27FmsWrUKbdq0wddff+3y7itvqVu3LoKDg/H222/jySefxJEjRzBjxgy7ZerVqweZTIZNmzahT58+UKlU0Gq1mDhxIp555hlYLBZ06tQJeXl52L17N0JDQzFs2DA8+eSTmDdvHp577jmMHDkS+/fvdxgc/HqNGjWC2WzG22+/jX79+mH37t22sb2sunXrhgsXLmDu3LkYOHAgvv32W2zevNnuxWvx8fHYsmULjh07hvDwcOh0Orf2x4QJE9CmTRvMmDEDgwcPRnp6Ot55551yx6+aP38+YmJi0LJlS8jlcqxZswbR0dG2Mbekjq96ICIiIiIiomohMEQLXUIzp/N0Cc0QGKKtsG13794dRUVFaNSoEaKiomzTu3btioKCAjRp0sQ2tlBZwsPDoVK5Tqp54p577sEzzzyDsWPHokWLFvj5559tA2tXpIiICCxbtgxr1qxB8+bN8frrr+PNN9+0W6Z27dqYNm0aJk+ejKioKIwdOxYAMGPGDEydOhWzZ89Gs2bN0Lt3b3z99deoX78+gKvJrnXr1mHDhg1ISUlBWloaZs2a5TKelJQUzJ8/H3PmzEFSUhJWrlyJ2bNn2y3TrFkzLFmyBIsXL0ZKSgp++eUXh0cgH3/8cTRp0gStW7dGRESEw11PZbn11lvxxRdfYNWqVUhKSsLLL7+M6dOn2w1o7oxWq8XcuXPRunVrtGnTBpmZmfjmm29sd3lJnUxU8efi8vPzodPpkJeXZ5e5JCIiIiIiosqjuLgYp0+fRv369aG8iTuZjLlX8Nfalcjz4Vv2iPzNVfvxV96Ej+wRERERERFRtaEIq4FGDw9HSWEBSoqLEahUIjBEWyGDmRNR2ZiQIiIiIiIiomolSK1hAorIzyrHg4VERERERERERFRlMCFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+RQTUkRERERERETVzPvvv4+4uDjI5XIsXLjQ6bRXX30VLVq0sH0mNTUVAwYMsP3erVs3jB8/3qdxW+3YsQMymQy5ubk+33ZmZiZkMhkyMjJ8vu2qhAkpIiIiIiIiogqUmpoKmUyG119/3W76hg0bIJPJfB5Pfn4+xo4di0mTJuHcuXMYNWqU02kTJ07EDz/8UOZ6vvzyS8yYMcPt7foziXSjrk/CkfcwIUVERERERERUwZRKJebMmYMrV674OxScPXsWZrMZffv2RUxMDNRqtdNpISEhCA8PL3M9NWvWhFar9WHkVZvJZPJ3CD7FhBQRERERERFRBevZsyeio6Mxe/Zsl8utW7cOiYmJUCgUiI+Px7x58+zmx8fHY9asWRgxYgS0Wi3q1q2L999/326ZSZMmISEhAWq1Gg0aNMDUqVNhNpsBAMuWLUNycjIAoEGDBpDJZE6nZWZmOjyyd73rH9lbsWIFWrduDa1Wi+joaDz88MPIyckBcPUxt+7duwMAatSoAZlMhtTUVACAxWLB7NmzUb9+fahUKqSkpGDt2rV22/rmm2+QkJAAlUqF7t27IzMz0+V+BID58+cjOTkZGo0GcXFxGD16NAoLC23znX2/hQsXIj4+3jb/k08+wVdffQWZTAaZTIYdO3bYlv3rr7/QvXt3qNVqpKSkID093W5d7pTljBkzMHToUISGhmLUqFEwmUwYO3YsYmJioFQqUa9evXLrTGXFhBQRERERERFVK3pjCf7NM+LUxSJk5RmhN5ZU+DYDAgIwa9YsvP322/jnn3+cLrN//34MGjQIDz74IA4fPoxXX30VU6dOxbJly+yWmzdvHlq3bo2DBw9i9OjReOqpp3Ds2DHbfK1Wi2XLluH333/HW2+9hQ8++AALFiwAAAwePBhbt24FAPzyyy/IysrCAw884DAtLi7O4+9oNpsxY8YMHDp0CBs2bEBmZqYt6RQXF4d169YBAI4dO4asrCy89dZbAIDZs2dj+fLlSEtLw9GjR/HMM8/gkUcewc6dOwEAf//9N+677z7069cPGRkZGDlyJCZPnlxuPHK5HIsWLcLRo0fxySefYNu2bXj++efd/j4TJ07EoEGD0Lt3b2RlZSErKwsdOnSwzX/xxRcxceJEZGRkICEhAQ899BBKSq7WJXfL8s0330RKSgoOHjyIqVOnYtGiRdi4cSO++OILHDt2DCtXrrQlyKqaQH8HQEREREREROQrl/RmfJSejSNZBtu05Bg1RrSPRrgmqEK3fe+996JFixZ45ZVX8NFHHznMnz9/Pnr06IGpU6cCABISEvD777/jjTfesCV2AKBPnz4YPXo0gKt3Qy1YsADbt29HkyZNAAAvvfSSbdn4+HhMnDgRq1atwvPPPw+VSmV7DC8iIgLR0dEA4HSap0aMGGH7f4MGDbBo0SK0adMGhYWFCAkJQc2aNQEAkZGRCAsLAwAYjUbMmjULW7duRfv27W2f/emnn/Dee++ha9euePfdd9GwYUPbHUZNmjTB4cOHMWfOHJfxXHv3Vnx8PF577TU8+eSTWLJkiVvfJyQkBCqVCkaj0ek+mThxIvr27QsAmDZtGhITE3Hy5Ek0bdrU7bK8/fbbMWHCBNvvZ8+eRePGjdGpUyfIZDLUq1fPrVgrI94hRURERERERNWC3ljikIwCgMNZBnycnu2TO6XmzJmDTz75BH/88YfDvD/++AMdO3a0m9axY0ecOHECpaWltmm33HKL7f8ymQzR0dG2R+MAYPXq1ejYsSOio6MREhKCl156CWfPnq2Ab2Nv//796NevH+rWrQutVouuXbsCgMttnzx5EgaDAXfccQdCQkJsP8uXL8epU6cAXN0vbdu2tfucNXnlytatW9GjRw/Url0bWq0Wjz76KC5dugSDwVDuZ91xbTnExMQAgK0c3C3L1q1b2y2TmpqKjIwMNGnSBOPGjcN3333nlViliAkpIiIiIiIiqhbyiksdklFWh7MMyCsudTrPm7p06YJevXphypQpN7yOoCD7O7lkMhksFgsAID09HUOGDEGfPn2wadMmHDx4EC+++GKFD5it1+vRq1cvhIaGYuXKldi3bx/Wr18PwPVg3dYxnb7++mtkZGTYfn7//XeHcaQ8kZmZibvvvhu33HIL1q1bh/3792Px4sV28cjlcggh7D5nHWvLHdeWg/VtidZycJdGo7H7/dZbb8Xp06cxY8YMFBUVYdCgQRg4cKBH66ws+MgeERERERERVQtFZtfJgvLme8vrr7+OFi1a2B6xs2rWrBl2795tN2337t1ISEhAQECAW+v++eefUa9ePbz44ou2aWfOnLn5oMvx559/4tKlS3j99ddt40/9+uuvdssEBwcDgN0dQs2bN4dCocDZs2dtd1Rdr1mzZti4caPdtD179riMZ//+/bBYLJg3bx7k8qv34nzxxRd2y0RERCA7OxtCCFtCKSMjwyHma+N1182UZWhoKAYPHozBgwdj4MCB6N27Ny5fvmx75LGqYEKKiIiIiIiIqgVVkOuHhMqb7y3JyckYMmQIFi1aZDd9woQJaNOmDWbMmIHBgwcjPT0d77zzjttjHgFA48aNcfbsWaxatQpt2rTB119/bbtTqSLVrVsXwcHBePvtt/Hkk0/iyJEjmDFjht0y9erVg0wmw6ZNm9CnTx+oVCpotVpMnDgRzzzzDCwWCzp16oS8vDzs3r0boaGhGDZsGJ588knMmzcPzz33HEaOHIn9+/c7DA5+vUaNGsFsNuPtt99Gv379sHv3bqSlpdkt061bN1y4cAFz587FwIED8e2332Lz5s0IDQ21LRMfH48tW7bg2LFjCA8Ph06nc2t/3GhZzp8/HzExMWjZsiXkcjnWrFmD6Oho25hbVQkf2SMiIiIiIqJqQacMQHKM2um85Bg1dEr37kLyhunTpzs83nXrrbfiiy++wKpVq5CUlISXX34Z06dPtxsEuzz33HMPnnnmGYwdOxYtWrTAzz//bBtYuyJFRERg2bJlWLNmDZo3b47XX38db775pt0ytWvXxrRp0zB58mRERUVh7NixAIAZM2Zg6tSpmD17Npo1a4bevXvj66+/Rv369QFcTXatW7cOGzZsQEpKCtLS0jBr1iyX8aSkpGD+/PmYM2cOkpKSsHLlSsyePdtumWbNmmHJkiVYvHgxUlJS8Msvv2DixIl2yzz++ONo0qQJWrdujYiICIe7nspyo2Wp1Woxd+5ctG7dGm3atEFmZia++eYb211eVYlMXP/AZBWTn58PnU6HvLw8uywnERERERERVR7FxcU4ffo06tevD6VSecPruaQ34+P0bBy+7i17j7WPRs0Kfssekb+4aj/+ypvwkT0iIiIiIiKqNsI1QRjdOQZ5xaUoMlugCpJDpwyARsHLYyJfYosjIiIiIiKiakWjCGQCisjPqt5DiEREREREREREJGlMSBERERERERERkU8xIUVERERERERERD7FhBQRERERERFVGlX8RfFEFUKK7YYJKSIiIiIiIpK8oKAgAIDBYPBzJESVj7XdWNuRFPC1AkRERERERCR5AQEBCAsLQ05ODgBArVZDJpP5OSoiaRNCwGAwICcnB2FhYQgICPB3SDZMSBEREREREVGlEB0dDQC2pBQRuScsLMzWfqSCCSkiIiIiIiKqFGQyGWJiYhAZGQmz2ezvcIgqhaCgIEndGWXFhBQRERERERFVKgEBAZK8wCYi93FQcyIiIiIiIiIi8ikmpIiIiIiIiIiIyKeYkCIiIiIiIiIiIp9iQoqIiIiIiIiIiHyKCSkiIiIiIiIiIvIpJqSIiIiIiIiIiMinmJAiIiIiIiIiIiKfYkKKiIiIiIiIiIh8igkpIiIiIiIiIiLyKb8mpHbt2oV+/fohNjYWMpkMGzZssJsvhMDLL7+MmJgYqFQq9OzZEydOnPBPsERERERERERE5BV+TUjp9XqkpKRg8eLFTufPnTsXixYtQlpaGvbu3QuNRoNevXqhuLjYx5ESERERERGVT28swb95Rpy6WISsPCP0xhJ/h0RUJbBtVT2B/tz4XXfdhbvuusvpPCEEFi5ciJdeegn9+/cHACxfvhxRUVHYsGEDHnzwQV+GSkRERERE5NIlvRkfpWfjSJbBNi05Ro0R7aMRrgnyY2RElRvbVtUk2TGkTp8+jezsbPTs2dM2TafToW3btkhPT/djZERERERERPb0xhKHC2YAOJxlwMfp2bybg+gGsW1VXX69Q8qV7OxsAEBUVJTd9KioKNs8Z4xGI4xGo+33/Pz8igmQiIiIiIjo/8srLnW4YLY6nGVAXnEpNArJXn4RSRbbVtUl2TukbtTs2bOh0+lsP3Fxcf4OiYiIiIiIqrgis+Wm5hORc2xbVZdkE1LR0dEAgPPnz9tNP3/+vG2eM1OmTEFeXp7t5++//67QOImIiIiIiFRBri+typtPRM6xbVVdki25+vXrIzo6Gj/88INtWn5+Pvbu3Yv27duX+TmFQoHQ0FC7HyIiIiIiooqkUwYgOUbtdF5yjBo6ZYCPIyKqGti2qi6/JqQKCwuRkZGBjIwMAFcHMs/IyMDZs2chk8kwfvx4vPbaa9i4cSMOHz6MoUOHIjY2FgMGDPBn2ERERERERHY0ikCMaB/tcOGcHKPGY+2jOcYN0Q1i26q6ZEII4a+N79ixA927d3eYPmzYMCxbtgxCCLzyyit4//33kZubi06dOmHJkiVISEhwexv5+fnQ6XTIy8vj3VJERERERFSh9MYS5BWXoshsgSpIDp0ygBfMRF7AtlVx/JU38WtCyheYkCIiIiIiIiIics5feRPJjiFFRERERERERERVExNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+RQTUkRERERERERE5FNMSBERERERERERkU8xIUVERERERERERD7FhBQREREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+VSgvwMgIiIiItIbS5BXXIoiswXqIDlClQHQKHiqSkTVC/tCqk5Ys4mIiIjIry7pzfgoPRtHsgy2ackxaoxoH41wTZAfIyMi8h32hVTd8JE9IiIiIvIbvbHE4QIMAA5nGfBxejb0xhI/RUZE5DvsC6k6YkKKiIiIiPwmr7jU4QLM6nCWAXnFpT6OiIjI99gXUnXEhBQRERER+U2R2XJT84mIqgL2hVQdMSFFRERERH6jCnJ9OlrefCKiqoB9IVVHrNVERERE5Dc6ZQCSY9RO5yXHqKFTBvg4IiIi32NfSNURE1JERERE5DcaRSBGtI92uBBLjlHjsfbRfN05EVUL7AupOpIJIYS/g6hI+fn50Ol0yMvLQ2hoqL/DISIiIiIn9MYS5BWXoshsgSpIDp0ygBdgRFTtsC8kf/BX3oQ1m4iIiIj8TqMI5EUXEVV77AupOuEje0RERERERERE5FNMSBERERERERERkU8xIUVERERERERERD7FhBQREREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+RQTUkRERERERERE5FNMSBERERERERERkU8xIUVERERERERERD4VeCMfslgsOHnyJHJycmCxWOzmdenSxSuBERERERERERFR1eRxQmrPnj14+OGHcebMGQgh7ObJZDKUlpZ6LTgiIiIiIiIiIqp6PH5k78knn0Tr1q1x5MgRXL58GVeuXLH9XL582avBlZaWYurUqahfvz5UKhUaNmyIGTNmOCTCiKhyMBv0KMrJRsHZ0yjKOQ+zQe/vkCRDbyzBv3lGnLpYhKw8I/TGEn+HREREEsLjBBERVTUe3yF14sQJrF27Fo0aNaqIeOzMmTMH7777Lj755BMkJibi119/xfDhw6HT6TBu3LgK3z4ReY8x9wpOrV2J/ON/2KbpEpqhwcAhUITV8GNk/ndJb8ZH6dk4kmWwTUuOUWNE+2iEa4L8GBkREUkBjxNERFQVeXyHVNu2bXHy5MmKiMXBzz//jP79+6Nv376Ij4/HwIEDceedd+KXX37xyfaJyDvMBr1DMgoA8o7/gb/WrqzWd0rpjSUOFxkAcDjLgI/Ts/kXcCKiao7HCSIiqqrcukPqt99+s/3///7v/zBhwgRkZ2cjOTkZQUH2f5W55ZZbvBZchw4d8P777+P48eNISEjAoUOH8NNPP2H+/PllfsZoNMJoNNp+z8/P91o8RHRjSgoLHJJRVnnH/0BJYQGC1BofRyUNecWlDhcZVoezDMgrLoVGcUPvnyAioiqAxwkiIqqq3Dp6tWjRAjKZzG7sphEjRtj+b53n7UHNJ0+ejPz8fDRt2hQBAQEoLS3FzJkzMWTIkDI/M3v2bEybNs1rMRDRzSspLipnfrGPIpGeIrPlpuYTEVHVxuMEERFVVW4lpE6fPl3RcTj1xRdfYOXKlfjss8+QmJiIjIwMjB8/HrGxsRg2bJjTz0yZMgXPPvus7ff8/HzExcX5KmQiciJQqSpnvtJHkUiPKsj1k9PlzScioqqNxwkiIqqq3EpI1atXz/b/Xbt2oUOHDggMtP9oSUkJfv75Z7tlb9Zzzz2HyZMn48EHHwQAJCcn48yZM5g9e3aZCSmFQgGFQuG1GIjo5gWGaKFLaIY8J4/t6RKaITBE64eopEGnDEByjBqHnTyOkRyjhk4Z4IeoiIhIKnicICKiqsrjP6l0794dly9fdpiel5eH7t27eyUoK4PBALncPsSAgABYLLw1magyCVJr0GDgEOgSmtlNt75lr7qOHwUAGkUgRrSPRnKM2m56cowaj7WP5rggRETVHI8TRERUVXl8BLOOFXW9S5cuQaPx7kVlv379MHPmTNStWxeJiYk4ePAg5s+fbzd+FRFVDoqwGmj08HCUFBagpLgYgUolAkO01ToZZRWuCcLozjHIKy5FkdkCVZAcOmUALzKIiAgAjxNERFQ1uX0Uu++++wBcHcA8NTXV7rG40tJS/Pbbb+jQoYNXg3v77bcxdepUjB49Gjk5OYiNjcUTTzyBl19+2avbISLfCFJrmIAqg0YRyAsLIiIqE48TRERU1bh9VNPpdACu3iGl1WqhUv03SHFwcDDatWuHxx9/3KvBabVaLFy4EAsXLvTqeomIiIiIiIiIyH/cTkgtXboUABAfH4+JEyd6/fE8IiIiIiIiIiKqHmRCCHEjH8zJycGxY8cAAE2aNEFkZKRXA/OW/Px86HQ65OXlITQ01N/hEBERERERERFJhr/yJh6/Za+goACPPvooateuja5du6Jr166oXbs2HnnkEeTl5VVEjEREREREREREVIV4nJAaOXIk9u7di02bNiE3Nxe5ubnYtGkTfv31VzzxxBMVESMREREREREREVUhHj+yp9FosGXLFnTq1Mlu+o8//ojevXtDr9d7NcCbxUf2iIiIiIiIiIicqzSP7IWHh9veuHctnU6HGjVqeCUoIiIiIiIiIiKqujxOSL300kt49tlnkZ2dbZuWnZ2N5557DlOnTvVqcEREREREREREVPV4/Mhey5YtcfLkSRiNRtStWxcAcPbsWSgUCjRu3Nhu2QMHDngv0hvER/aIiIiIiIiIiJzzV94k0NMPDBgwoALCICIiIiIiIiKi6sLjO6QqG94hRURERERERETkXKUZ1BwAcnNz8eGHH2LKlCm4fPkygKuP5507d86rwRERERERERERUdXj8SN7v/32G3r27AmdTofMzEw8/vjjqFmzJr788kucPXsWy5cvr4g4iYiIiIiIiIioivD4Dqlnn30WqampOHHiBJRKpW16nz59sGvXLq8GR0REREREREREVY/HCal9+/bhiSeecJheu3ZtZGdneyUoIiIiIiIiIiKqujxOSCkUCuTn5ztMP378OCIiIrwSFBERERERERERVV0eJ6TuueceTJ8+HWazGQAgk8lw9uxZTJo0Cffff7/XAyQiIiIiIiIioqrF44TUvHnzUFhYiMjISBQVFaFr165o1KgRtFotZs6cWRExEhERERERERFRFeLxW/Z0Oh2+//57/PTTT/jtt99QWFiIW2+9FT179qyI+IiIqoVLehP0JgsMJgs0wXKog+UI1wT7OywiquL0xhLkFZeiyGyBOkiOUGUANAqPTw/JB3INZhQYS2EwWaAOlkOrCECYOshv8bDulI37hqhisG1VPTIhhPB3EBUpPz8fOp0OeXl5CA0N9Xc4REQOzheYsGzPeRzNNtimJUarkdouClFaJqWIqGJc0pvxUXo2jmT91/ckx6gxon00wjX+S3SQo5wCE5Y6OU4MbxeFSD8cJ1h3ysZ9Q1Qx2LYqlr/yJh49smexWPDxxx/j7rvvRlJSEpKTk3HPPfdg+fLlqOJ5LSKiCnFJ75iMAoCj2QYs23Mel/QmP0VGRFWZ3ljicGIPAIezDPg4PRt6Y4mfIqPr5RrMDsko4OpxYume88g1mH0aD+tO2bhviCoG21bV5XZCSgiBe+65ByNHjsS5c+eQnJyMxMREnDlzBqmpqbj33nsrMk4ioipJb7I4XGRYHc02QG+y+DgiIqoO8opLHU7srQ5nGZBXXOrjiKgsBcZSl8eJAqNvy4p1p2zcN0QVg22r6nL7gctly5Zh165d+OGHH9C9e3e7edu2bcOAAQOwfPlyDB061OtBEhFVVYZyEk5FTEgRUQUoMpfT95Qzn3ynvONEefO9jXWnbNw3RBWDbavqcvsOqc8//xwvvPCCQzIKAG6//XZMnjwZK1eu9GpwRERVnTrYdTesKmc+EdGNUAWV0/eUM598p7zjRHnzvY11p2zcN0QVg22r6nK75H777Tf07t27zPl33XUXDh065JWgiIiqC02wHInRaqfzEqPV0DAhRUQVQKcMQHKM874nOUYNnTLAxxFRWbSKAJfHCa3Ct2XFulM27huiisG2VXW5faVz+fJlREVFlTk/KioKV65c8UpQRETVRbgmGKntohwuNqxv2QvX8C17ROR9GkUgRrSPdjjBT45R47H20XyNtoSEqYMwvIzjxPB2UQhT+/btUqw7ZeO+IaoYbFtVl0y4+Xq8gIAAZGdnIyIiwun88+fPIzY2FqWl0hpQzF+vLyQi8sQlvQl6kwVFJgtUwXJoguVMRhFRhdMbS5BXXIoiswWqIDl0ygCe2EtUrsGMAmMpDCYL1MFyaBUBPk9GXYt1p2zcN0QVg22r4vgrb+J26QkhkJqaCoVC4XS+0Wj0WlBERNVNuCYY4Rp/R0FE1Y1GEciT+UoiTB3k1wTU9Vh3ysZ9Q1Qx2LaqHrdLc9iwYeUuwzfsERERERERERFRedxOSC1durQi4yAiIiIiIiIiomqCr28iIiIiIiIiIiKfYkKKiIiIiIiIiIh8igkpIiIiIiIiIiLyKSakiIiIiIiIiIjIp5iQIiIiIiIiIiIin3L7LXvXOnHiBLZv346cnBxYLBa7eS+//LJXAiMiIiIiIiIioqrJ44TUBx98gKeeegq1atVCdHQ0ZDKZbZ5MJmNCioiIiIiIiIiIXPI4IfXaa69h5syZmDRpUkXEQ0REREREREREVZzHY0hduXIFDzzwQEXEQkRERERERERE1YDHCakHHngA3333XUXEQkRERERERERE1YDHj+w1atQIU6dOxZ49e5CcnIygoCC7+ePGjfNacEREREREREREVPXIhBDCkw/Ur1+/7JXJZPjrr79uOihvys/Ph06nQ15eHkJDQ/0dDhERERERERGRZPgrb+LxHVKnT5+uiDiIiIiIiIiIiKia8HgMKSIiIiIiIiIiopvh8R1SAPDPP/9g48aNOHv2LEwmk928+fPneyUwIiIiIiIiIiKqmjxOSP3www+455570KBBA/z5559ISkpCZmYmhBC49dZbvR7guXPnMGnSJGzevBkGgwGNGjXC0qVL0bp1a69vi9yTazCjwFgKg8kCdbAcWkUAwtRB5X+QiMqkN5Ygr7gURWYL1EFyhCoDoFHc0N8MiIjIC6TWL18oNKHIbIHBZIEmWA5lkBwRIcF+i4eoqpBaW5dSPFKKhaomj2vTlClTMHHiREybNg1arRbr1q1DZGQkhgwZgt69e3s1uCtXrqBjx47o3r07Nm/ejIiICJw4cQI1atTw6nbIfTkFJizdcx5Hsw22aYnRagxvF4VILU+KiG7EJb0ZH6Vn40jWf+0qOUaNEe2jEa5hspeIyNek1i+fLzBhmZPzr9R2UYji+RfRDZNaW5dSPFKKhaouj9+yp9VqkZGRgYYNG6JGjRr46aefkJiYiEOHDqF///7IzMz0WnCTJ0/G7t278eOPP97wOviWPe/JNZjx3u5su5Mhq8RoNZ7oGM07pYg8pDeWYPGPWXYHe6vkGDVGd47hX6KIiHxIav3yhUITPk4/X+b514j2UbxTiugGSK2tSykeKcVCvuGvvInHg5prNBrbuFExMTE4deqUbd7Fixe9FxmAjRs3onXr1njggQcQGRmJli1b4oMPPnD5GaPRiPz8fLsf8o4CY6nTkyEAOJptQIGx1McREVV+ecWlTg/2AHA4y4C8YrYrIiJfklq/XGS2uDz/KjJbfBoPUVUhtbYupXikFAtVbR4npNq1a4effvoJANCnTx9MmDABM2fOxIgRI9CuXTuvBvfXX3/h3XffRePGjbFlyxY89dRTGDduHD755JMyPzN79mzodDrbT1xcnFdjqs4MJtcnPOXNJyJH5V1I8EKDiMi3pNYvl3d+VcTzL6IbIrW2LqV4pBQLVW0e32c3f/58FBYWAgCmTZuGwsJCrF69Go0bN/b6G/YsFgtat26NWbNmAQBatmyJI0eOIC0tDcOGDXP6mSlTpuDZZ5+1/Z6fn8+klJeog13nL8ubT0SOVEGu201584mIyLuk1i+Xd36l4vkX0Q2RWluXUjxSioWqNo8TUg0aNLD9X6PRIC0tzasBXSsmJgbNmze3m9asWTOsW7euzM8oFAooFIoKi6k60yoCkBitLnMMA60iwA9REVVuOmUAkmPUOFzGM/o6JdsVEZEvSa1fVgXJXZ5/8cKQ6MZIra1LKR4pxUJVm6SPYB07dsSxY8fsph0/fhz16tXzU0TVW5g6CMPbRSExWm033fqWPQ5oTuQ5jSIQI9pHIznGvl0lx6jxWPtoDhhJRORjUuuXI0KCkVrG+VdqOw5oTnSjpNbWpRSPlGKhqs2tt+zVrFkTx48fR61atVCjRg3IZLIyl718+bLXgtu3bx86dOiAadOmYdCgQfjll1/w+OOP4/3338eQIUPcWgffsud9uQYzCoylMJgsUAfLoVUEMBlFdJP0xhLkFZeiyGyBKkgOnTKAB3siIj+SWr98odCEIrMFRSYLVMFyqILkTEYReYHU2rqU4pFSLFSx/JU3cas2LViwAFqtFgCwcOHCiozHTps2bbB+/XpMmTIF06dPR/369bFw4UK3k1FUMcLUQUxAEXmZRhHIAzwRkYRIrV9m8omoYkitrUspHinFQlWTW3dIVWa8Q4qIiIiIiIiIyDlJ3yGVn5/v9gqZ9CEiIiIiIiIiIlfcSkiFhYW5HDfqWqWlpTcVEBERERERERERVW1uJaS2b99u+39mZiYmT56M1NRUtG/fHgCQnp6OTz75BLNnz66YKImIiIiIiIiIqMrweAypHj16YOTIkXjooYfspn/22Wd4//33sWPHDm/Gd9M4hhQRERERERERkXP+ypvIPf1Aeno6Wrdu7TC9devW+OWXX7wSFBERERERERERVV0eJ6Ti4uLwwQcfOEz/8MMPERcX55WgiIiIiIiIiIio6nJrDKlrLViwAPfffz82b96Mtm3bAgB++eUXnDhxAuvWrfN6gEREREREREREVLV4fIdUnz59cPz4cfTr1w+XL1/G5cuX0a9fPxw/fhx9+vSpiBiJiIiIiIiIiKgK8XhQ88qGg5oTERERERERETlXaQY1B4Aff/wRjzzyCDp06IBz584BAFasWIGffvrJq8EREREREREREVHV43FCat26dejVqxdUKhUOHDgAo9EIAMjLy8OsWbO8HiAREREREREREVUtHiekXnvtNaSlpeGDDz5AUFCQbXrHjh1x4MABrwZHRERERERERERVj8cJqWPHjqFLly4O03U6HXJzc70RExERERERERERVWEeJ6Sio6Nx8uRJh+k//fQTGjRo4JWgiIiIiIiIiIio6vI4IfX444/j6aefxt69eyGTyfDvv/9i5cqVmDhxIp566qmKiJGIiIiIiIiIiKqQQE8/MHnyZFgsFvTo0QMGgwFdunSBQqHAxIkT8X//938VESMREREREREREVUhMiGEuJEPmkwmnDx5EoWFhWjevDlCQkK8HZtX5OfnQ6fTIS8vD6Ghof4Oh4iIiIiIiIhIMvyVN/H4Dimr4OBgNG/e3JuxEFEVZzboUVJYgJLiIgQq1QgMCUGQWuPvsCThQqEJRWYLDCYLNMFyKIPkiAgJ9ndYRORluQYzCoylMJgsUAfLoVUEIEwdVP4HK4jeWIK84lIUmS1QB8kRqgyARnHDp4c35ZLeBL3pv35QHSxHuMZ//aDUyorxuCaluiy1fSM1UiorgOXlitTKSmrx0M1zu/RGjBjh1nIff/zxDQdDRFWXMfcKTq1difzjf9im6RKaocHAIVCE1fBjZP53vsCEZXvO42i2wTYtMVqN1HZRiNIyKUVUVeQUmLDUSVsf3i4KkX5o65f0ZnyUno0jWf/Fkxyjxoj20QjX+PZiTGr9oNTKivG4JqW6LLV9IzVSKiuA5eWK1MpKavGQd7g9qPmyZcuwfft25Obm4sqVK2X+EBFdz2zQOySjACDv+B/4a+1KmA16P0XmfxcKHS/CAOBotgHL9pzHhUKTnyIjIm/KNZgdLnqAq2196Z7zyDWYfRqP3ljicGIPAIezDPg4PRt6Y4nPYrmkd90PXtL7th+UWlkxHtekVJeltm+kRkplBbC8XJFaWUktHvIet++Qeuqpp/D555/j9OnTGD58OB555BHUrFmzImMjoiqipLDAIRlllXf8D5QUFlTbR/eKzBaHEyGro9kGFJktPo6IiCpCgbHUZVsvMJb69BGRvOJShxN7q8NZBuQVl/rsMQi9yXU/qDdZEO7DQ4TUyorxuCaluiy1fSM1UiorgOXlitTKSmrxkPe4fYfU4sWLkZWVheeffx7/+9//EBcXh0GDBmHLli24wXHRiaiaKCkuKmd+sY8ikR6DyXXCqaic+URUOZTX1sub723lJbt9mQyXWj8otbJiPK5Vprrs630jNVIqK4Dl5YrUykpq8ZD3uJ2QAgCFQoGHHnoI33//PX7//XckJiZi9OjRiI+PR2FhYUXFSESVXKBSVc58pY8ikR51sOtuWFXOfCKqHMpr6+XN9zZVUDl9TznzvUlq/aDUyorxuFaZ6rKv943USKmsAJaXK1IrK6nFQ95zwyUnl8shk8kghEBpaak3YyKiKiYwRAtdQjOn83QJzRAYovVxRNKhCpIjMVrtdF5itJoHWKIqQqsIcNnWtYoAn8ajUwYgOcZ5PMkxauiUvotHE+y6H9T4+KJQamXFeFyTUl2W2r6RGimVFcDyckVqZSW1eMh7PDrCG41GfP7557jjjjuQkJCAw4cP45133sHZs2cREhJSUTESUSUXpNagwcAhDkkp61v2quv4UQAQERKM1HZRDidE1rdLRYRU7ze8EFUVYeogDC+jrQ9vF+XzcUo0ikCMaB/tcIKfHKPGY+2jfToWR7jGdT8YrvFtPyi1smI8rkmpLktt30iNlMoKYHm5IrWyklo85D0y4eYAUKNHj8aqVasQFxeHESNGYMiQIahVq1ZFx3fT8vPzodPpkJeXh9DQUH+HQ1StmQ16lBQWoKS4GIFKJQJDtNU6GXWtC4UmFJktKDJZoAqWQxUkZzKKqArKNZhRYCyFwWSBOlgOrSLArxc9emMJ8opLUWS2QBUkh04Z4LcT+0t6E/Sm//pBTbDc58moa0mtrBiPa1Kqy1LbN1IjpbICWF6uSK2spBZPVeKvvInbCSm5XI66deuiZcuWkMlkZS735Zdfei04b2BCioiIiIiIiIjIOX/lTdxOJw4dOtRlIoqIiIiIiIiIiMgdbiekli1bVoFhEBERERERERFRdcHXNxERERERERERkU8xIUVERERERERERD7FhBQREREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+RQTUkRERERERERE5FNMSBERERERERERkU8xIUVERERERERERD7FhBQREREREREREflUoL8D8MTrr7+OKVOm4Omnn8bChQv9HQ4RkddcKDShyGyBwWSBJlgOZZAcESHB/g6LqNLTG0uQV1yKIrMF6iA5QpUB0Cgq1elPhco1mFFgLIXBZIE6WA6tIgBh6iC/xJKvL0aB0QKDqRTq4ABoFXKEapR+iUWKeJxwTUpt/ZLeBL3pv7JSB8sRrmFZWUmtrbO8Kg8ptXPyjkpTevv27cN7772HW265xd+hEBF51fkCE5btOY+j2QbbtMRoNVLbRSFKyxMioht1SW/GR+nZOJL1X9tKjlFjRPtohGv8k3SRkpwCE5Y66XuGt4tCpI/7nov5xfho73kczS62TUuKVmJE2yjUCmVSiscJ16TU1llWrkmtrbO8Kg8ptXPynkrxyF5hYSGGDBmCDz74ADVq1PB3OEREXnOh0PFECACOZhuwbM95XCg0+SkyospNbyxxOHEFgMNZBnycng29scRPkUlDrsHskIwCrvY9S/ecR67B7LNY8vWOF6gAcCS7GB/vPY98fXEZn6weeJxwTUpt/ZLedVld0lfvspJaW2d5VR5SaufkXZUiITVmzBj07dsXPXv2LHdZo9GI/Px8ux8iIqkqMlscToSsjmYbUGS2+Dgioqohr7jU4cTV6nCWAXnFpT6OSFoKjKUu+54Co+/2T4HR4nCBanUk++qjPdUZjxOuSamt602uy0pvqt5lJbW2zvKqPKTUzsm7JP/I3qpVq3DgwAHs27fPreVnz56NadOmVXBURETeYSjnZKeIJ0NEN6S8i/TqfhFfXt9T3nxvMphcX0gUlTO/quNxwjUptXWWlWtSa+ssr8pDSu2cvEvSd0j9/fffePrpp7Fy5Uoole49UzxlyhTk5eXZfv7+++8KjpKI6Mapg113w6py5hORc6qgctpWOfOruvL6nvLme5M6OMDlfFU586s6Hidck1JbZ1m5JrW2zvKqPKTUzsm7JF1y+/fvR05ODm699VYEBgYiMDAQO3fuxKJFixAYGIjSUscsukKhQGhoqN0PEZFUqYLkSIxWO52XGK3mAZboBumUAUiOcd62kmPU0Cmrd5JDqwhw2fdoFb7bP1qFHEnRzv/wmBSthFZRvftBHidck1Jb1wS7LitNNU9wSK2ts7wqDym1c/IuSbeyHj164PDhw8jIyLD9tG7dGkOGDEFGRgYCAljxiKhyiwgJRmq7KIcTIusbXvhKb6Ibo1EEYkT7aIcT2OQYNR5rH13tXxMdpg7C8DL6nuHtohCm9t0bi0I1V9+wdf2FqvXNW/58HbwU8DjhmpTaerjGdVmFa6p3WUmtrbO8Kg8ptXPyLpkQQvg7CE9069YNLVq0wMKFC91aPj8/HzqdDnl5ebxbiogk60KhCUVmC4pMFqiC5VAFyav9RQaRN+iNJcgrLkWR2QJVkBw6ZQBPXK+RazCjwFgKg8kCdbAcWkWAT5NR18rXXx3UuMhUClVwALQKebVPRl2LxwnXpNTWL+lN0Jv+KytNsJzJjWtIra2zvCoPKbXzqsZfeROWHhGRBPCigqhiaBSBPFl1IUwd5LcE1PVCNUqEavwdhXTxOOGalNp6uCYY4azLZZJaW2d5VR5SaufkHZWuNHfs2OHvEIiIiIiIiIiI6CZIegwpIiIiIiIiIiKqepiQIiIiIiIiIiIin2JCioiIiIiIiIiIfIoJKSIiIiIiIiIi8ikmpIiIiIiIiIiIyKeYkCIiIiIiIiIiIp9iQoqIiIiIiIiIiHyKCSkiIiIiIiIiIvIpJqSIiIiIiIiIiMinmJAiIiIiIiIiIiKfYkKKiIiIiIiIiIh8igkpIiIiIiIiIiLyKSakiIiIiIiIiIjIp5iQIiIiIiIiIiIin2JCioiIiIiIiIiIfIoJKSIiIiIiIiIi8qlAfwdAlc8lvQl6kwUGkwWaYDnUwXKEa4L9HRZVAnpjCfKKS1FktkAdJEeoMgAaBbshALhQaEKR+b92pQySIyKE7YqIKlauwYwCYykMJgvUwXJoFQEIUwf5JRapHSMuFhphMAkYzFf7ZVWQDLVCFH6LR2rHCamVl5RcLDTBcE1ZqYLkqMVjuk2+vhgFRgsMplKogwOgVcgRqlH6LR4p9YNSI7V2LrW2JbX9Uxlxb5FHzheYsGzPeRzNNtimJUarkdouClFaHmipbJf0ZnyUno0jWf/VneQYNUa0j0a4pnof9NmuiMgfcgpMWOqk7xneLgqRPu57pHaMOJ9vwrK9OY79ctsoRIX6vl+W2nFCauUlJVIrK6m5mF+Mj/aex9HsYtu0pGglRrSNQq1Q3yelpNQPSo3U2rnU2pbU9k9lxUf2yG2X9I6dAAAczTZg2Z7zuKQ3+Skykjq9scShwwaAw1kGfJyeDb2xxE+R+d+FQtft6kIh2xUReV+uwexwEQZc7XuW7jmPXIPZZ7FI7RhxsdCIZXvL6Jf3nsfFQqNP45HacUJq5SUlF8spq4vV/Jier3dMRgHAkexifLz3PPL1xWV8smJIqR+UGqm1c6m1Lantn8qMCSlym95kcegErI5mG6A3WXwcEVUWecWlDh221eEsA/KKS30ckXQUmV23qyIz2xUReV+BsdRl31Ng9F2/LLVjhMEkXO4bg0n4NB6pHSekVl5SYiinrAzV/JheYLQ4JKOsjmRffYzPt/FIpx+UGqm1c6m1Lantn8qMCSlym6GchFMRE1JUhvJOlqtz0oXtioj8oby+p7z53iS1Y0R5FzY+j0dixwmplZeUSK2spMZgcn2RXlTOfG+TUj8oNVJr51JrW1LbP5UZE1LkNnWw6+qiKmc+VV+qoHLqTjnzqzK2KyLyh/L6nvLme5PUjhFqqcUjseOE1MpLSqRWVlKjDg5wOV9Vznxvk1I/KDVSa+dSa1tS2z+VGfcUuU0TLEditNrpvMRoNTTVuNMm13TKACTHOK87yTFq6JS+PQGRElWQ63bFAxoRVQStIsBl36NV+K5fltoxQh0sc7lv1MEyn8YjteOE1MpLStTllFV5yc6qTquQIyna+cDlSdFKaBW+3T9S6gelRmrtXGptS2r7pzKr3r0ieSRcE4zUdlEOnYH17Qbhmur9Jgoqm0YRiBHtox067uQYNR5rH12tX48aEeK6Xfnzld5EVHWFqYMwvIy+Z3i7KJ++8lxqx4haIQqkti2jX24bhVohCp/GI7XjhNTKS0pqlVNW/nw9vRSEaq6+Te/6pJT1LXuhGt++ZU9K/aDUSK2dS61tSW3/VGYyIYRvR2b0sfz8fOh0OuTl5SE0NNTf4VQJl/Qm6E0WFJksUAXLoQmWMxlFbtEbS5BXXIoiswWqIDl0ygB22P/fhUITisz/tStVkJzJKCKqcLkGMwqMpTCYLFAHy6FVBPjtIkxqx4iLhUYYTMIWjzpY5vNk1LWkdpyQWnlJycVCEwzXlJU6SF7tk1HXytdfHcC8yFQKVXAAtAq5z5NR15JSPyg1UmvnUmtbUts/N8NfeRMmpIiIiIiIiIiIqil/5U34yB4REREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+RQTUkRERERERERE5FNMSBERERERERERkU8xIUVERERERERERD7FhBQREREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5lKQTUrNnz0abNm2g1WoRGRmJAQMG4NixY/4Oi4iIiIiIiIiIbkKgvwNwZefOnRgzZgzatGmDkpISvPDCC7jzzjvx+++/Q6PR+Ds8n8k1mFFgLIXBZIE6WA6tIgBh6iC/xXOx0ASD2QKDyQJNsByqIDlqhQT7LR6iqoDtim6G3liCvOJSFJktUAfJEaoMgEYh6UN8tXVJb4Le9F9bVwfLEa5hWwekV48vFxpRaBJX4wmWQxMkQ80Qhd/ikdr+ydcXo8BogcFUCnVwALQKOUI1Sr/FIyUXCk0ouuaYrgySI4LHdBup1WWpxSMlUrsOlVrbktr+qYxkQgjh7yDcdeHCBURGRmLnzp3o0qWLW5/Jz8+HTqdDXl4eQkNDKzhC78spMGHpnvM4mm2wTUuMVmN4uyhEan3f+M4XmLDMSTyp7aIQ5Yd4iKoCtiu6GZf0ZnyUno0jWf/Vn+QYNUa0j0a4hidFUsK2Xjap1eOcfBOW7nVy/tU2CpGhvi8rqe2fi/nF+GjveRzNLrZNS4pWYkTbKNQKrd5JKbZz16RWl6UWj5TwOtQ1qe2fm+WvvImkH9m7Xl5eHgCgZs2afo7EN3INZodKDgBHsw1Yuuc8cg1mn8ZzsdCxE7DGs2zPeVwsNPk0HqKqgO2KbobeWOJwIg0Ah7MM+Dg9G3pjiZ8io+td0rtu65f01betS60eXy40OiSjgP9//rX3PC4XGn0aj9T2T77eMRkFAEeyi/Hx3vPI1xeX8cmq70I5x/QL1fyYLrW6LLV4pERq16FSa1tS2z+VWaVJSFksFowfPx4dO3ZEUlJSmcsZjUbk5+fb/VRWBcZSh0pudTTbgAJjqU/jMZgtLuMxmC0+jYeoKmC7opuRV1zqcCJtdTjLgLxi3x4nqGx6k+u2rjdV37YutXpcaBIuy6rQ5NuHC6S2fwqMFodklNWR7KuP8VVXReUc04uq+TFdanVZavFIidSuQ6XWtqS2fyqzSpOQGjNmDI4cOYJVq1a5XG727NnQ6XS2n7i4OB9F6H2Gck5Oy5vvbeVtr6gan0wT3Si2K7oZ5Z2AVfeLHylhWy+b1Oox43HNYHJ9oVVUzvyqjO3cNanVZanFIyW8DnVNavunMqsUCamxY8di06ZN2L59O+rUqeNy2SlTpiAvL8/28/fff/soSu9TB7sunvLme1t521P5OB6iqoDtim6GKqic+lPOfPIdtvWySa0eMx7X1MEBLueryplflbGduya1uiy1eKSE16GuSW3/VGaS3lNCCIwdOxbr16/Htm3bUL9+/XI/o1AoEBoaavdTWWkVAUiMVjudlxithlbh2wO+OkjuMh51Ne60iW4U2xXdDJ0yAMkxzutPcowaOmX1vTCUGk2w67auqcYnr1KrxyHBMpdlFRIs82k8Uts/WoUcSdHOBy5PilZCq6i+dVlVzjG9Oic4AOnVZanFIyVSuw6VWtuS2v6pzCTdK44ZMwaffvopPvvsM2i1WmRnZyM7OxtFRUX+Ds0nwtRBGN4uyqGyW0fv9/UrJWuFBCO1jHhS20XxFfVEN4Dtim6GRhGIEe2jHU6ok2PUeKx9NF9bLSHhGtdtPVxTfdu61OpxzRAFhrct4/yrbRRqhih8Go/U9k+o5urb9K5PSlnfsheqqb5v2Yso55juz9fTS4HU6rLU4pESqV2HSq1tSW3/VGYyIYRvR2b0gEzm/C9QS5cuRWpqqlvr8NfrC70p12BGgbEUBpMF6mA5tIoAv1byi4UmGMwWFJksUFFOHMwAABKgSURBVAXLoQ6S86KZ6CaxXdHN0BtLkFdciiKzBaogOXTKgGp9Ii1ll/Qm6E3/tXVNsLxaJ6OuJbV6fLnQiEKTsMUTEizzeTLqWlLbP/n6qwOYF5lKoQoOgFYhr9bJqGtdKDSh6JpjuipIXu2TUdeSWl2WWjxSIrXrUKm1Lantn5vhr7yJpBNS3lAVElJERERERERERBXBX3kTST+yR0REREREREREVQ8TUkRERERERERE5FNMSBERERERERERkU8xIUVERERERERERD7FhBQREREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPsWEFBERERERERER+RQTUkRERERERERE5FNMSBERERERERERkU8xIUVERERERERERD7FhBQREREREREREflUoL8DoMrnkt4EvckCg8kCTbAc6mA5wjXB/g6LqFK7UGhCkfm/dqUMkiMihO2K3GM26FFSWICS4iIEKtUIDAlBkFrj77DIiVyDGQXGUhhMFqiD5dAqAhCmDmI8EotFiqR2/nW50IhCk0CR+Wp5aYJkqBmi8Fs8UsJjeuWiN5Ygr7j0al0OkiNUGQCNwn+XyVKKR0qxSDEeunksPfLI+QITlu05j6PZBtu0xGg1UttFIUrLAy3RjWC7opthzL2CU2tXIv/4H7ZpuoRmaDBwCBRhNfwYGV0vp8CEpU7a+vB2UYj0Q1uXUjxSikWKpHacyMk3YeneHMfyahuFyNDqXV5SKyty7ZLejI/Ss3Ek67/ySo5RY0T7aIRrfJ8Ql1I8UopFivGQd/CRPXLbJb3jARYAjmYbsGzPeVzSm/wUGVHldaHQdbu6UMh2RWUzG/QOySgAyDv+B/5auxJmg95PkdH1cg1mh4QLcLWtL91zHrkGc7WNR0qxSJHUzr8uFxqxdG8Z5bX3PC4XGn0aj5TwmF656I0lDgkOADicZcDH6dnQG0uqbTxSikWK8ZD3MCFFbtObLA4HWKuj2QboTRYfR0RU+RWZXberIjPbFZWtpLDAIRlllXf8D5QUFvg4IipLgbHUZVsvMJZW23ikFIsUSe38q9AkXMZTaBI+jUdKeEyvXPKKSx0SHFaHswzIK/Zt3yOleKQUixTjIe9hQorcZijnhKeICSkij7Fd0c0oKS4qZ36xjyKh8pTX1sub721SikdKsUiR1I4T5SVVqnPSRWplRa5JrS5LKR4pxeLO9qpzv1PZMSFFblMHu64uqnLmE5Ejtiu6GYFKVTnzlT6KhMpTXlsvb763SSkeKcUiRVI7TqiCyomnnPlVmdTKilyTWl2WUjxSisWd7VXnfqeyY8mR2zTBciRGq53OS4xWQ8ODLJHHVEGu2xUPsORKYIgWuoRmTufpEpohMETr44ioLFpFgMu2rlUEVNt4pBSLFEnt/CskWOYynpBgmU/jkRIe0ysXnTIAyTHOyys5Rg2d0rd9j5TikVIsUoyHvIe9IrktXBOM1HZRDgda65tD/PnqYaLKKiLEdbvia6LJlSC1Bg0GDnFISlnfshek1vgpMrpemDoIw8to68PbRSFM7ds3BEkpHinFIkVSO/+qGaLA8LZllFfbKNQMUfg0HinhMb1y0SgCMaJ9tEOiIzlGjcfaR0Oj8O0L6aUUj5RikWI85D0yIUSVHnkwPz8fOp0OeXl5CA0N9Xc4VcIlvQl6kwVFJgtUwXJoguVMRhHdpAuFJhSZ/2tXqiA5T1zJbWaDHiWFBSgpLkagUonAEC2TURKVazCjwFgKg8kCdbAcWkWAXxMuUopHSrFIkdTOvy4XGlFoEigyW6AKkiMkWFatk1HX4jG9ctEbS5BXXGqryzplgF8THFKKR0qxSDGeqsRfeRMmpIiIiIiIiIiIqil/5U34yB4REREREREREfkUE1JERERERERERORTTEgREREREREREZFPMSFFREREREREREQ+xYQUERERERERERH5FBNSRERERERERETkU0xIERERERERERGRTzEhRUREREREREREPhXo7wAqmhACAJCfn+/nSIiIiIiIiIiIpMWaL7HmT3ylyiekCgoKAABxcXF+joSIiIiIiIiISJoKCgqg0+l8tj2Z8HUKzMcsFgv+/fdfaLVayGQyf4dD1UB+fj7i4uLw999/IzQ01N/hUBXFekb+wHpHFY11jPyFdY/8gfWOfMGdeiaEQEFBAWJjYyGX+25kpyp/h5RcLkedOnX8HQZVQ6GhoTywUIVjPSN/YL2jisY6Rv7Cukf+wHpHvlBePfPlnVFWHNSciIiIiIiIiIh8igkpIiIiIiIiIiLyKSakiLxMoVDglVdegUKh8HcoVIWxnpE/sN5RRWMdI39h3SN/YL0jX5ByPavyg5oTEREREREREZG08A4pIiIiIiIiIiLyKSakiIiIiIiIiIjIp5iQIiIiIiIiIiIin2JCioiIiIiIiIiIfIoJKao2Zs+ejTZt2kCr1SIyMhIDBgzAsWPH7JYpLi7GmDFjEB4ejpCQENx///04f/683TLjxo1Dq1atoFAo0KJFC4ftHDt2DN27d0dUVBSUSiUaNGiAl156CWazudwYFy9ejPj4eCiVSrRt2xa//PKL0+WEELjrrrsgk8mwYcMGt/cBVayqUMe6desGmUxm9/Pkk096vjPIZ6pCvQOA9PR03H777dBoNAgNDUWXLl1QVFTk2c6gClPZ61lmZqZD32b9WbNmzY3tFKpwlb3eAUB2djYeffRRREdHQ6PR4NZbb8W6des83xnkU1Wh7p06dQr33nsvIiIiEBoaikGDBjnER/4j9Tq2a9cu9OvXD7GxsWVecwoh8PLLLyMmJgYqlQo9e/bEiRMnPNoPTEhRtbFz506MGTMGe/bswffffw+z2Yw777wTer3etswzzzyD//3vf1izZg127tyJf//9F/fdd5/DukaMGIHBgwc73U5QUBCGDh2K7777DseOHcPChQvxwQcf4JVXXnEZ3+rVq/Hss8/ilVdewYEDB5CSkoJevXohJyfHYdmFCxdCJpN5uAeoolWVOvb4448jKyvL9jN37twb2BvkK1Wh3qWnp6N3796488478csvv2Dfvn0YO3Ys5HKepkhFZa9ncXFxdv1aVlYWpk2bhpCQENx11103sWeoIlX2egcAQ4cOxbFjx7Bx40YcPnwY9913HwYNGoSDBw/e4F4hX6jsdU+v1+POO++ETCbDtm3bsHv3bphMJvTr1w8Wi+Um9gx5i9TrmF6vR0pKChYvXlzmMnPnzsWiRYuQlpaGvXv3QqPRoFevXiguLnZzLwAQRNVUTk6OACB27twphBAiNzdXBAUFiTVr1tiW+eOPPwQAkZ6e7vD5V155RaSkpLi1rWeeeUZ06tTJ5TK33XabGDNmjO330tJSERsbK2bPnm233MGDB0Xt2rVFVlaWACDWr1/vVgzke5WxjnXt2lU8/fTTbm2TpKky1ru2bduKl156ya1tkjRUxnp2vRYtWogRI0a4FQNJQ2WsdxqNRixfvtzuczVr1hQffPCBW3GQNFS2urdlyxYhl8tFXl6ebZnc3Fwhk8nE999/71Yc5FtSq2PXcnbNabFYRHR0tHjjjTds03Jzc4VCoRCff/652+vmnx6p2srLywMA1KxZEwCwf/9+mM1m9OzZ07ZM06ZNUbduXaSnp9/wdk6ePIlvv/0WXbt2LXMZk8mE/fv3221bLpejZ8+edts2GAx4+OGHsXjxYkRHR99wTOQblbGOAcDKlStRq1YtJCUlYcqUKTAYDDccG/leZat3OTk52Lt3LyIjI9GhQwdERUWha9eu+Omnn244Nqp4la2eXW///v3IyMjAY489dsOxke9VxnrXoUMHrF69GpcvX4bFYsGqVatQXFyMbt263XB85HuVre4ZjUbIZDIoFArbMkqlEnK5nMdXiZJSHXPH6dOnkZ2dbRefTqdD27ZtPYqPCSmqliwWC8aPH4+OHTsiKSkJwNVn/IODgxEWFma3bFRUFLKzsz3eRocOHaBUKtG4cWN07twZ06dPL3PZixcvorS0FFFRUS63/cwzz6BDhw7o37+/x/GQb1XWOvbwww/j008/xfbt2zFlyhSsWLECjzzyiMexkX9Uxnr3119/AQBeffVVPP744/j2229x6623okePHh6PQ0C+URnr2fU++ugjNGvWDB06dPA4NvKPylrvvvjiC5jNZoSHh0OhUOCJJ57A+vXr0ahRI4/jI/+ojHWvXbt20Gg0mDRpEgwGA/R6PSZOnIjS0lJkZWV5HB9VLKnVMXdYY/Dk2OsME1JULY0ZMwZHjhzBqlWrKmwbq1evxoEDB/DZZ5/h66+/xptvvgkA+PHHHxESEmL7WblypVvr27hxI7Zt24aFCxdWWMzkPZWxjgHAqFGj0KtXLyQnJ2PIkCFYvnw51q9fj1OnTlXU1yAvqoz1zjqWxRNPPIHhw4ejZcuWWLBgAZo0aYKPP/64wr4H3bjKWM+uVVRUhM8++4x3R1UylbXeTZ06Fbm5udi6dSt+/fVXPPvssxg0aBAOHz5cUV+DvKwy1r2IiAisWbMG//vf/xASEgKdTofc3FzceuutHJ9RgipjHfOWQJ9ujUgCxo4di02bNmHXrl2oU6eObXp0dDRMJhNyc3PtMtHnz5+/ocfj4uLiAADNmzdHaWkpRo0ahQkTJqB169bIyMiwLRcVFQWFQoGAgACHtyZcu+1t27bh1KlTDlny+++/H507d8aOHTs8jpEqRmWtY860bdsWwNXbexs2bOhxjOQ7lbXexcTE2NZ3rWbNmuHs2bMex0cVq7LWs2utXbsWBoMBQ4cO9Tgu8o/KWu9OnTqFd955B0eOHEFiYiIAICUlBT/++CMWL16MtLQ0j2Mk36qsdQ8A7rzzTpw6dQoXL15EYGAgwsLCEB0djQYNGngcH1UcKdYxd1hjOH/+vO1czvq7s7f9lYXpUao2hBAYO3Ys1q9fj23btqF+/fp281u1aoWgoCD88MMPtmnHjh3D2bNn0b59+5vatsVigdlshsVigUqlQqNGjWw/Wu3/a+/uYdldwziO341QKYcSVBrvKYPBQCLpoAY7YTXYvI0SQcJiwOBlMHsJBmIyiMlLYqBJk0qHJqgICzGSEBL9neEcDec45/in9aR1vp/k2e7ez9Urv+ZJrjTP/ZvJyMgwDQ0NH+4djUbN7u5u7N7Dw8MmFAqZk5OT2GWMMXNzc2ZpaSmu+pAYqZ6xz7zl7P2DBskl1XNXUVFh3G733446Pjs7M+Xl5XHVh8RJ9Zy9t7CwYFpbW01hYWFcdeH7pXru3t7B+Nd/pKSlpXHSWZJL9ey9V1BQYJxOp9nb2zN3d3emtbU1rvqQGMmcsa+orKw0xcXFH+q7v783fr//1+r78uvPgRTX19en3NxcHRwc6ObmJnY9Pj7G1vT29qqsrEx7e3sKBALyer3yer0f9jk/P1cwGFRPT49qamoUDAYVDAb1/PwsSVpbW9PGxobC4bAuLi60sbEht9utzs7Of61vfX1ddrtdy8vLCofD6u7ultPp1O3t7T9+xnDKXlJJ9YxFIhGNj48rEAjo8vJSW1tbqqqqks/nS3CnkEipnjtJmpubU05OjjY3N3V+fq7R0VFlZmYqEokksFOIx0/I2dv9bTabdnZ2EtQZfKdUz93Ly4s8Ho+amprk9/sViUQ0PT0tm82m7e3tBHcLiZTq2ZOkxcVFHR0dKRKJaHV1Vfn5+RoYGEhglxCPZM/Yw8NDbC9jjGZnZxUMBnV1dRVbMzU1JafTqa2tLYVCIbW1tamyslJPT09f7gMDKfxvGGM+vZaWlmJrnp6e1N/fr7y8PDkcDrW3t+vm5ubDPs3NzZ/uc3l5KemPB0R9fb2ys7OVlZWl2tpaTUxMfOmHOT8/r7KyMmVkZKixsVHHx8f/+Z0YSCWPVM/Y9fW1fD6f8vPzZbfb5fF4NDg4+OHIYCSfVM/dm8nJSZWUlMjhcMjr9erw8DCuviCxfkrORkZGVFpaqtfX17j6AWv8hNydnZ2po6NDRUVFcjgcqqur08rKSty9wff6CdkbGhqSy+VSenq6qqurNTMzo2g0GndvkBjJnrH9/f1P9+3q6oqtiUajGhsbk8vlkt1uV0tLi05PT3+pD7Y/mwEAAAAAAABYgndIAQAAAAAAwFIMpAAAAAAAAGApBlIAAAAAAACwFAMpAAAAAAAAWIqBFAAAAAAAACzFQAoAAAAAAACWYiAFAAAAAAAASzGQAgAAAAAAgKUYSAEAAAAAAMBSDKQAAAAAAABgKQZSAAAAAAAAsBQDKQAAAAAAAFjqd4iR8DB0CDivAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -880,9 +892,10 @@ } ], "source": [ - "pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", + "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", "#pattern = r'\\b(WMF|Foundation)\\b'\n", - "#pattern = r'\\b(bots)\\b'\n", + "#pattern = r'\\b(contributor|community|volunteer)\\b'\n", + "pattern = r'\\b(bots|scripts|gadgets)\\b'\n", "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", "\n", @@ -899,47 +912,50 @@ "ax0.legend().set_visible(False)\n", "'''\n", "# Calculate the median depth over time\n", + "filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n", - "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n", - "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "# Plot the median depth over time\n", "ax0 = plt.subplot(gs[0])\n", - "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax0.set_title('Median Depth of \"VE\" in Phabricator Sentence Dependency Trees')\n", + "#sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=wmf_filtered_dependencies, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=other_filtered_dependencies, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax0.set_title(f'Depth of {pattern} in Phabricator Sentence Dependency Trees')\n", "ax0.set_ylabel('Median Depth')\n", "ax0.set_xlabel('')\n", "\n", "# Calculate the median depth over time\n", + "resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n", - "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n", - "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "# Plot the median depth over time\n", "ax1 = plt.subplot(gs[1])\n", - "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax1.set_title('Median Depth of \"VE\" in Coreference-resolved Phabricator Sentence Dependency Trees')\n", + "#sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=resolved_wmf_filtered_dependencies, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=resolved_other_filtered_dependencies, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax1.set_title(f'Depth of {pattern} in Coreference-resolved Phabricator Sentence Dependency Trees')\n", "ax1.set_ylabel('Median Depth')\n", "ax1.set_xlabel('')\n", "\n", - "plt.tight_layout()\n", - "#plt.show()\n", - "\n", - "plt.savefig('042125_VE_depth_fig.png')" + "plt.tight_layout()\n" ] } ], @@ -959,7 +975,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/text_analysis/case1/031025_phab_comments.ipynb b/text_analysis/case1/031025_phab_comments.ipynb index af9c226..7913a10 100644 --- a/text_analysis/case1/031025_phab_comments.ipynb +++ b/text_analysis/case1/031025_phab_comments.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "e4f0b3f0-5255-46f1-822f-e455087ba315", "metadata": {}, "outputs": [], @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "d449164e-1d28-4580-9eb1-f0f69978f114", "metadata": {}, "outputs": [], @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "942344db-c8f5-4ed6-a757-c97f8454f18b", "metadata": {}, "outputs": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "d226d781-b002-4842-a3ae-92d4851a5878", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559", "metadata": {}, "outputs": [ @@ -110,7 +110,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/3649688126.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/3649688126.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57", "metadata": {}, "outputs": [ @@ -133,7 +133,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/1316816771.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/1316816771.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab", "metadata": {}, "outputs": [], @@ -177,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920", "metadata": {}, "outputs": [ @@ -185,7 +185,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/2805711855.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2805711855.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -200,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "337a528a-5667-4e1f-ac9a-37caabc03a18", "metadata": {}, "outputs": [ @@ -208,7 +208,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/2117289791.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2117289791.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4", "metadata": {}, "outputs": [], @@ -286,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "828fb57a-e152-42ef-9c60-660648898532", "metadata": {}, "outputs": [ @@ -294,25 +294,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/2858732056.py:2: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:2: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n", - "/tmp/ipykernel_5608/2858732056.py:3: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:3: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n", - "/tmp/ipykernel_5608/2858732056.py:4: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:4: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n", - "/tmp/ipykernel_5608/2858732056.py:5: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/2858732056.py:5: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -331,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "27e47f6f-0257-4b70-b222-e91ef888c900", "metadata": {}, "outputs": [ @@ -339,19 +339,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_5608/335308388.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/335308388.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", - "/tmp/ipykernel_5608/335308388.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/335308388.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", - "/tmp/ipykernel_5608/335308388.py:1: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/335308388.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -367,14 +367,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0", "metadata": {}, "outputs": [], "source": [ "# expand the dependency parser \n", "\n", - "pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", + "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", "#pattern = r'\\b(WMF|Foundation)\\b'\n", "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n", "\n", @@ -389,29 +389,27 @@ " WMFaffil = row['meta.affil']\n", " \n", " for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n", - " if re.search(pattern, token, re.IGNORECASE):\n", - " dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", + " dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", " for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n", - " if re.search(pattern, token, re.IGNORECASE):\n", - " resolved_dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", + " resolved_dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", "\n", "resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations) \n", "dependency_relations_df = pd.DataFrame(dependency_relations)" @@ -419,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "82498686-14f4-40c8-9e33-27b31f115b47", "metadata": {}, "outputs": [], @@ -840,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 21, "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f", "metadata": {}, "outputs": [ @@ -848,21 +846,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_94014/1491274823.py:4: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + "/tmp/ipykernel_43056/387535334.py:5: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", " filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_94014/1491274823.py:5: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + "/tmp/ipykernel_43056/387535334.py:6: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", " resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_94014/1491274823.py:20: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + "/tmp/ipykernel_43056/387535334.py:21: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_43056/387535334.py:22: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_94014/1491274823.py:20: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/387535334.py:22: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_94014/1491274823.py:39: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + "/tmp/ipykernel_43056/387535334.py:43: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_43056/387535334.py:44: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_94014/1491274823.py:39: SettingWithCopyWarning: \n", + "/tmp/ipykernel_43056/387535334.py:44: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -872,7 +882,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -882,9 +892,10 @@ } ], "source": [ - "pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", + "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", "#pattern = r'\\b(WMF|Foundation)\\b'\n", - "#pattern = r'\\b(bots)\\b'\n", + "#pattern = r'\\b(contributor|community|volunteer)\\b'\n", + "pattern = r'\\b(bots|scripts|gadgets)\\b'\n", "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", "\n", @@ -901,47 +912,50 @@ "ax0.legend().set_visible(False)\n", "'''\n", "# Calculate the median depth over time\n", + "filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n", - "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n", - "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "# Plot the median depth over time\n", "ax0 = plt.subplot(gs[0])\n", - "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax0.set_title('Median Depth of \"VE\" in Phabricator Sentence Dependency Trees')\n", + "#sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=wmf_filtered_dependencies, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=other_filtered_dependencies, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax0.set_title(f'Depth of {pattern} in Phabricator Sentence Dependency Trees')\n", "ax0.set_ylabel('Median Depth')\n", "ax0.set_xlabel('')\n", "\n", "# Calculate the median depth over time\n", + "resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n", - "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n", - "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "#resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", "\n", "# Plot the median depth over time\n", "ax1 = plt.subplot(gs[1])\n", - "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax1.set_title('Median Depth of \"VE\" in Coreference-resolved Phabricator Sentence Dependency Trees')\n", + "#sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=resolved_wmf_filtered_dependencies, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=resolved_other_filtered_dependencies, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax1.set_title(f'Depth of {pattern} in Coreference-resolved Phabricator Sentence Dependency Trees')\n", "ax1.set_ylabel('Median Depth')\n", "ax1.set_xlabel('')\n", "\n", - "plt.tight_layout()\n", - "#plt.show()\n", - "\n", - "plt.savefig('042125_VE_depth_fig.png')" + "plt.tight_layout()\n" ] } ], @@ -961,7 +975,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/text_analysis/case3/.ipynb_checkpoints/041525_resolved_phab_comments-Copy1-checkpoint.ipynb b/text_analysis/case3/.ipynb_checkpoints/041525_resolved_phab_comments-Copy1-checkpoint.ipynb deleted file mode 100644 index fa7434b..0000000 --- a/text_analysis/case3/.ipynb_checkpoints/041525_resolved_phab_comments-Copy1-checkpoint.ipynb +++ /dev/null @@ -1,803 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "ba9e5acd-e17d-4318-9272-04c9f6706186", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd \n", - "import spacy" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e4f0b3f0-5255-46f1-822f-e455087ba315", - "metadata": {}, - "outputs": [], - "source": [ - "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case2/041325_coref_rel_phab_comments.csv\"\n", - "phab_df = pd.read_csv(phab_path)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ac5e624b-08a4-4ede-bc96-cfc26c3edac3", - "metadata": {}, - "outputs": [], - "source": [ - "def http_relevant(text):\n", - " if pd.isnull(text):\n", - " return False\n", - " # expanded dictionary for relevancy\n", - " # http, login, SSL, TLS, certificate \n", - " for word in text.split():\n", - " if \"://\" not in word.lower():\n", - " #http\n", - " if \"http\" in word.lower():\n", - " return True\n", - " #login\n", - " if \"login\" in word.lower():\n", - " return True\n", - " #ssl\n", - " if \"ssl\" in word.lower():\n", - " return True\n", - " #tls\n", - " if \"tls\" in word.lower():\n", - " return True\n", - " #cert\n", - " if word.lower().startswith(\"cert\"):\n", - " return True\n", - " return False" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d5925c49-ea1d-4813-98aa-eae10d5879ca", - "metadata": {}, - "outputs": [], - "source": [ - "def is_migrated(comment_text):\n", - " if pd.isnull(comment_text):\n", - " return False\n", - " text = comment_text.strip()\n", - " if text.startswith(\"Originally from: http://sourceforge.net\"):\n", - " return True \n", - " return False" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d449164e-1d28-4580-9eb1-f0f69978f114", - "metadata": {}, - "outputs": [], - "source": [ - "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n", - "#phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n", - "\n", - "#cleaning df\n", - "#phab_df['id'] = phab_df.index + 1\n", - "#may have to build out the reply_to column \n", - "#phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n", - "#phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n", - "\n", - "#phab_df = phab_df.rename(columns={\n", - "# 'AuthorPHID': 'speaker',\n", - "# 'TaskPHID': 'conversation_id',\n", - "# 'WMFaffil':'meta.affil',\n", - "# 'isGerrit': 'meta.gerrit'\n", - "#})\n", - "\n", - "# after 12-1-2012 before 12-1-2013\n", - "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n", - "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1385856000) & (phab_df['date_created'] > 1354320000)]\n", - "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n", - "\n", - "#removing headless conversations\n", - "task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n", - "headed_task_phids = task_phab_df['conversation_id'].unique()\n", - "filtered_phab_df = phab_df[phab_df['conversation_id'].isin(headed_task_phids)]\n", - "\n", - "#removing gerrit comments \n", - "#mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n", - "\n", - "'''\n", - "# filter out the sourceforge migration \n", - "# Originally from: http://sourceforge.net in the task task_summary\n", - "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n", - "\n", - "#cut down to only the data that is relevant (mentions http)\n", - "relevant_conversation_ids = task_phab_df[\n", - " task_phab_df['comment_text'].apply(http_relevant) |\n", - " task_phab_df['task_title'].apply(http_relevant)\n", - "]['conversation_id'].unique()\n", - "\n", - "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", - "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", - "\n", - "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", - "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", - "'''\n", - "#comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n", - "#task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n", - "comment_phab_df = filtered_phab_df" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "942344db-c8f5-4ed6-a757-c97f8454f18b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unique conversation_ids: 382\n", - "Unique ids: 1838\n", - "Unique speakers: 189\n" - ] - } - ], - "source": [ - "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n", - "unique_ids = len(comment_phab_df['id'].unique())\n", - "unique_speakers = len(comment_phab_df['speaker'].unique())\n", - "\n", - "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n", - "print(f\"Unique ids: {unique_ids}\")\n", - "print(f\"Unique speakers: {unique_speakers}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d226d781-b002-4842-a3ae-92d4851a5878", - "metadata": {}, - "outputs": [], - "source": [ - "import re\n", - "\n", - "def preprocess_text(text):\n", - " text = str(text)\n", - " text = text.replace('*', ' ')\n", - " text = text.replace('-', ' ')\n", - " text = re.sub(r'http\\S+', '', text)\n", - " return text" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab", - "metadata": {}, - "outputs": [], - "source": [ - "nlp = spacy.load(\"en_core_web_sm\")\n", - "\n", - "def extract_dependency_tree(text):\n", - " doc = nlp(text)\n", - " dependency_trees = []\n", - " \n", - " for sentence in doc.sents:\n", - " for token in sentence:\n", - " token_info = (\n", - " token.text, \n", - " token.lemma_, \n", - " token.dep_, \n", - " token.head.text, \n", - " list(token.ancestors), \n", - " list(token.subtree), \n", - " list(token.children)\n", - " )\n", - " dependency_trees.append(token_info)\n", - " \n", - " return dependency_trees" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "337a528a-5667-4e1f-ac9a-37caabc03a18", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4", - "metadata": {}, - "outputs": [], - "source": [ - "#get VAD scores\n", - "import numpy as np\n", - "#https://saifmohammad.com/WebPages/nrc-vad.html\n", - "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n", - "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n", - "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n", - "\n", - "def vad_scoring(dependency_tree):\n", - " valence = []\n", - " arousal = []\n", - " dominance = []\n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " valence.append(vad_dict[lemma]['Valence'])\n", - " arousal.append(vad_dict[lemma]['Arousal'])\n", - " dominance.append(vad_dict[lemma]['Domination'])\n", - "\n", - " # Compute average scores across the comment\n", - " avg_valence = np.mean(valence) if valence else 0\n", - " avg_arousal = np.mean(arousal) if arousal else 0\n", - " avg_dominance = np.mean(dominance) if dominance else 0\n", - "\n", - " return [avg_valence, avg_arousal, avg_dominance]\n", - "\n", - "def dominance_prevail(dependency_tree):\n", - " dominant_words = 0 \n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " if vad_dict[lemma]['Domination'] >= 0.75:\n", - " dominant_words += 1\n", - " if vad_dict[lemma]['Domination'] <= 0.25:\n", - " dominant_words += 1\n", - " return dominant_words\n", - "\n", - "def arousal_prevail(dependency_tree):\n", - " arousal_words = 0 \n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " if vad_dict[lemma]['Arousal'] >= 0.75:\n", - " arousal_words += 1\n", - " if vad_dict[lemma]['Arousal'] <= 0.25:\n", - " arousal_words += 1\n", - " return arousal_words\n", - "\n", - "def valence_prevail(dependency_tree):\n", - " valence_words = 0 \n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " if vad_dict[lemma]['Valence'] >= 0.75:\n", - " valence_words += 1\n", - " if vad_dict[lemma]['Valence'] <= 0.25:\n", - " valence_words += 1\n", - " return valence_words\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "828fb57a-e152-42ef-9c60-660648898532", - "metadata": {}, - "outputs": [], - "source": [ - "#establishing per-comment VAD scores \n", - "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n", - "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n", - "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n", - "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "27e47f6f-0257-4b70-b222-e91ef888c900", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", - "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1889034d-bc93-495f-bdc4-961d193d3e08", - "metadata": {}, - "outputs": [], - "source": [ - "def token_http_relevant(word):\n", - " # expanded dictionary for relevancy\n", - " # http, login, SSL, TLS, certificate \n", - " if \"://\" not in word.lower():\n", - " #http\n", - " if \"http\" in word.lower():\n", - " return True\n", - " #login\n", - " if \"login\" in word.lower():\n", - " return True\n", - " #ssl\n", - " if \"ssl\" in word.lower():\n", - " return True\n", - " #tls\n", - " if \"tls\" in word.lower():\n", - " return True\n", - " #cert\n", - " if word.lower().startswith(\"cert\"):\n", - " return True\n", - " return False" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "09ddcbfc-b856-40ca-ad61-13577795d94b", - "metadata": {}, - "outputs": [], - "source": [ - "import datetime" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0", - "metadata": {}, - "outputs": [], - "source": [ - "# expand the dependency parser \n", - "\n", - "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", - "#pattern = r'\\b(WMF|Foundation)\\b'\n", - "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n", - "pattern = r'\\b(http|https)\\b'\n", - "\n", - "dependency_relations = []\n", - "resolved_dependency_relations = []\n", - "\n", - "for index, row in comment_phab_df.iterrows():\n", - " text = row['comment_text']\n", - " timestamp = row['timestamp']\n", - " comment_id = row['id']\n", - " conversation_id = row['conversation_id']\n", - " WMFaffil = row['meta.affil']\n", - " \n", - " for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n", - " if token_http_relevant(token):\n", - " dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", - " \n", - " for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n", - " if token_http_relevant(token):\n", - " resolved_dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", - "\n", - "resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations) \n", - "dependency_relations_df = pd.DataFrame(dependency_relations)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "82498686-14f4-40c8-9e33-27b31f115b47", - "metadata": {}, - "outputs": [], - "source": [ - "#now analysis/plotting \n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from matplotlib.gridspec import GridSpec" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n", - "plot2.set_axis_labels(\"Index of Speaker's Comment\", \"Count of Polarized Words\")\n", - "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n", - "plot2.fig.subplots_adjust(top=0.9) # Adjust subplots to make room for the title\n", - "plot2.add_legend(title=\"Comment publication timestamp:\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "2274795e-c64d-43e4-b0f5-a19b5b8ba2c8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
comment_idtimestampwmfAffiltokendependencyheaddepthchildren
01152013-10-11 09:04:00+00:00Falseuse_api_logindobjuse_api16
11572013-10-07 08:09:00+00:00Falseuse_api_logindobjuse_api14
21772013-10-04 17:56:00+00:00Falsecertainlyadvmodrequire21
32472013-09-27 22:15:00+00:00FalseLoginROOTLogin04
44262013-09-01 11:26:00+00:00FalseHTTPcompoundlogin40
...........................
1463453002013-08-01 17:35:00+00:00Falsecertainamodcommands50
1464453002013-08-01 17:35:00+00:00Falsecertainamodcommands50
1465453732013-07-27 13:30:00+00:00Falsecertainamodelement80
1466460782013-06-18 21:17:00+00:00FalseHTTPcompoundError20
1467460862013-06-19 23:31:02+00:00FalseHTTPcompoundError30
\n", - "

1468 rows × 8 columns

\n", - "
" - ], - "text/plain": [ - " comment_id timestamp wmfAffil token \\\n", - "0 115 2013-10-11 09:04:00+00:00 False use_api_login \n", - "1 157 2013-10-07 08:09:00+00:00 False use_api_login \n", - "2 177 2013-10-04 17:56:00+00:00 False certainly \n", - "3 247 2013-09-27 22:15:00+00:00 False Login \n", - "4 426 2013-09-01 11:26:00+00:00 False HTTP \n", - "... ... ... ... ... \n", - "1463 45300 2013-08-01 17:35:00+00:00 False certain \n", - "1464 45300 2013-08-01 17:35:00+00:00 False certain \n", - "1465 45373 2013-07-27 13:30:00+00:00 False certain \n", - "1466 46078 2013-06-18 21:17:00+00:00 False HTTP \n", - "1467 46086 2013-06-19 23:31:02+00:00 False HTTP \n", - "\n", - " dependency head depth children \n", - "0 dobj use_api 1 6 \n", - "1 dobj use_api 1 4 \n", - "2 advmod require 2 1 \n", - "3 ROOT Login 0 4 \n", - "4 compound login 4 0 \n", - "... ... ... ... ... \n", - "1463 amod commands 5 0 \n", - "1464 amod commands 5 0 \n", - "1465 amod element 8 0 \n", - "1466 compound Error 2 0 \n", - "1467 compound Error 3 0 \n", - "\n", - "[1468 rows x 8 columns]" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "resolved_dependency_relations_df" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_79236/963914566.py:4: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", - " filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_79236/963914566.py:5: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", - " resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_79236/963914566.py:20: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", - " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_79236/963914566.py:20: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_79236/963914566.py:39: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", - " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_79236/963914566.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", - "#pattern = r'\\b(WMF|Foundation)\\b'\n", - "#pattern = r'\\b(bots)\\b'\n", - "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "\n", - "plt.figure(figsize=(12, 8))\n", - "gs = GridSpec(2, 1, height_ratios=[6, 6])\n", - "\n", - "# Main plot: Token depth by timestamp\n", - "'''\n", - "ax0 = plt.subplot(gs[0])\n", - "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n", - "ax0.set_title('VE Depth by Timestamp w/o URLS')\n", - "ax0.set_xlabel('')\n", - "ax0.set_ylabel('Dependency Type')\n", - "ax0.legend().set_visible(False)\n", - "'''\n", - "# Calculate the median depth over time\n", - "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n", - "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n", - "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "# Plot the median depth over time\n", - "ax0 = plt.subplot(gs[0])\n", - "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax0.set_title('Median Depth of Relevant Term in Phabricator Sentence Dependency Trees')\n", - "ax0.set_ylabel('Median Depth')\n", - "ax0.set_xlabel('')\n", - "\n", - "# Calculate the median depth over time\n", - "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n", - "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n", - "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "# Plot the median depth over time\n", - "ax1 = plt.subplot(gs[1])\n", - "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax1.set_title('Median Depth of Relevant Term in Coreference-resolved Phabricator Sentence Dependency Trees')\n", - "ax1.set_ylabel('Median Depth')\n", - "ax1.set_xlabel('')\n", - "\n", - "plt.tight_layout()\n", - "#plt.show()\n", - "\n", - "#plt.savefig('031625_VE_depth_fig.png')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/text_analysis/case3/.ipynb_checkpoints/050825_join_resolved_files-checkpoint.ipynb b/text_analysis/case3/.ipynb_checkpoints/050825_join_resolved_files-checkpoint.ipynb new file mode 100644 index 0000000..62ffad3 --- /dev/null +++ b/text_analysis/case3/.ipynb_checkpoints/050825_join_resolved_files-checkpoint.ipynb @@ -0,0 +1,487 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fcc726a8-44a4-48cf-a1cd-937b05bd4d08", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1fceca29-48c1-4ba3-93ba-88724dea22a7", + "metadata": {}, + "outputs": [], + "source": [ + "first_resolved_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/051725_coref_rel_phab_comments_to_2014.csv\"\n", + "first_resolved_df = pd.read_csv(first_resolved_path)\n", + "second_resolved_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/051725_coref_rel_phab_comments_2014_to_2015.csv\"\n", + "second_resolved_df = pd.read_csv(second_resolved_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f26c31e7-bee1-4100-821f-769e5b1791bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8621" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(second_resolved_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dfa81ca2-4d66-4679-bc3e-192d0cac67fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5007" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(first_resolved_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6dc11bda-f0f6-4eb6-96f5-02ed9a3492ba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13628" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combined_df = pd.concat([first_resolved_df, second_resolved_df])\n", + "unique_df = combined_df.drop_duplicates()\n", + "len(unique_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0c903199-8159-455c-aa7f-e57ef07ce03e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_titlecomment_textdate_createdspeakermeta.affilconversation_idcomment_typestatusmeta.gerritidreply_totimestampis_relevantis_migratedtextresolved_text
0User with unattached accounts unable to login ...User:NickK reported in IRC that they're gettin...1411541280PHID-USER-v7vgzvvcw7v2umf737riFalsePHID-TASK-mio2uq45ny7mms72syuttask_descriptionresolvedFalse243215NaN2014-09-24 06:48:00+00:00TrueFalseUser:NickK reported in IRC that they're gettin...User:NickK reported in IRC that they're gettin...
1User with unattached accounts unable to login ...Revert has been deployed.1411573104PHID-USER-v7vgzvvcw7v2umf737riFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243216243215.02014-09-24 15:38:24+00:00TrueFalseRevert has been deployed.Revert has been deployed.
2User with unattached accounts unable to login ...**gerritadmin** wrote:\\n\\nChange 162550 merged...1411572378PHID-USER-ynivjflmc2dcl6w5ut5vFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243217243216.02014-09-24 15:26:18+00:00TrueFalse**gerritadmin** wrote:\\n\\nChange 162550 merged...**gerritadmin** wrote:\\n\\nChange 162550 merged...
3User with unattached accounts unable to login ...(In reply to Kunal Mehta (Legoktm) from commen...1411545535PHID-USER-v7bwpq3rs3zdxegibdbhFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243218243217.02014-09-24 07:58:55+00:00TrueFalse(In reply to Kunal Mehta (Legoktm) from commen...(In reply to Kunal Mehta (Legoktm) from commen...
4User with unattached accounts unable to login ...**gerritadmin** wrote:\\n\\nChange 162549 merged...1411542640PHID-USER-ynivjflmc2dcl6w5ut5vFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243219243218.02014-09-24 07:10:40+00:00TrueFalse**gerritadmin** wrote:\\n\\nChange 162549 merged...**gerritadmin** wrote:\\n\\nChange 162549 merged...
...................................................
8616OAuth login refers to mediawiki.org:/ instead ...> When I registered, phabricator linked mediaw...1413205650PHID-USER-hgn5uw2jafgjgfvxibhhFalsePHID-TASK-yeaxsfxhhtbn26koo5fitask_subcommentNaNFalse378799378798.02014-10-13 13:07:30+00:00TrueFalse> When I registered, phabricator linked mediaw...> When I registered, phabricator linked mediaw...
8617OAuth login refers to mediawiki.org:/ instead ...See {T574} for a related discussion.1412958953PHID-USER-lluzkul4z7us4sxkayssFalsePHID-TASK-yeaxsfxhhtbn26koo5fitask_subcommentNaNFalse378800378799.02014-10-10 16:35:53+00:00TrueFalseSee {T574} for a related discussion.See {T574} for a related discussion.
8618Improvements to Wikimedia SUL login dialog UI:...Some improvements to the Wikimedia SUL dialog:...1412362816PHID-USER-lluzkul4z7us4sxkayssFalsePHID-TASK-j6czqxlv5fzcx3tmq23ntask_descriptiondeclinedFalse378858NaN2014-10-03 19:00:16+00:00TrueFalseSome improvements to the Wikimedia SUL dialog:...Some improvements to the Wikimedia SUL dialog:...
8619Improvements to Wikimedia SUL login dialog UI:...I guess the same restrictions as in T543 apply...1412415111PHID-USER-lluzkul4z7us4sxkayssFalsePHID-TASK-j6czqxlv5fzcx3tmq23ntask_subcommentNaNFalse378860378859.02014-10-04 09:31:51+00:00TrueFalseI guess the same restrictions as in T543 apply...I guess the same restrictions as in T543 apply...
8620Improvements to Wikimedia SUL login dialog UI:...It's not entirely trivial to change1412366627PHID-USER-fn7qnpccfbitivgtw2rtFalsePHID-TASK-j6czqxlv5fzcx3tmq23ntask_subcommentNaNFalse378861378860.02014-10-03 20:03:47+00:00TrueFalseIt's not entirely trivial to changeIt's not entirely trivial to change
\n", + "

13628 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " task_title \\\n", + "0 User with unattached accounts unable to login ... \n", + "1 User with unattached accounts unable to login ... \n", + "2 User with unattached accounts unable to login ... \n", + "3 User with unattached accounts unable to login ... \n", + "4 User with unattached accounts unable to login ... \n", + "... ... \n", + "8616 OAuth login refers to mediawiki.org:/ instead ... \n", + "8617 OAuth login refers to mediawiki.org:/ instead ... \n", + "8618 Improvements to Wikimedia SUL login dialog UI:... \n", + "8619 Improvements to Wikimedia SUL login dialog UI:... \n", + "8620 Improvements to Wikimedia SUL login dialog UI:... \n", + "\n", + " comment_text date_created \\\n", + "0 User:NickK reported in IRC that they're gettin... 1411541280 \n", + "1 Revert has been deployed. 1411573104 \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... 1411572378 \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... 1411545535 \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... 1411542640 \n", + "... ... ... \n", + "8616 > When I registered, phabricator linked mediaw... 1413205650 \n", + "8617 See {T574} for a related discussion. 1412958953 \n", + "8618 Some improvements to the Wikimedia SUL dialog:... 1412362816 \n", + "8619 I guess the same restrictions as in T543 apply... 1412415111 \n", + "8620 It's not entirely trivial to change 1412366627 \n", + "\n", + " speaker meta.affil \\\n", + "0 PHID-USER-v7vgzvvcw7v2umf737ri False \n", + "1 PHID-USER-v7vgzvvcw7v2umf737ri False \n", + "2 PHID-USER-ynivjflmc2dcl6w5ut5v False \n", + "3 PHID-USER-v7bwpq3rs3zdxegibdbh False \n", + "4 PHID-USER-ynivjflmc2dcl6w5ut5v False \n", + "... ... ... \n", + "8616 PHID-USER-hgn5uw2jafgjgfvxibhh False \n", + "8617 PHID-USER-lluzkul4z7us4sxkayss False \n", + "8618 PHID-USER-lluzkul4z7us4sxkayss False \n", + "8619 PHID-USER-lluzkul4z7us4sxkayss False \n", + "8620 PHID-USER-fn7qnpccfbitivgtw2rt False \n", + "\n", + " conversation_id comment_type status meta.gerrit \\\n", + "0 PHID-TASK-mio2uq45ny7mms72syut task_description resolved False \n", + "1 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "2 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "3 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "4 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "... ... ... ... ... \n", + "8616 PHID-TASK-yeaxsfxhhtbn26koo5fi task_subcomment NaN False \n", + "8617 PHID-TASK-yeaxsfxhhtbn26koo5fi task_subcomment NaN False \n", + "8618 PHID-TASK-j6czqxlv5fzcx3tmq23n task_description declined False \n", + "8619 PHID-TASK-j6czqxlv5fzcx3tmq23n task_subcomment NaN False \n", + "8620 PHID-TASK-j6czqxlv5fzcx3tmq23n task_subcomment NaN False \n", + "\n", + " id reply_to timestamp is_relevant is_migrated \\\n", + "0 243215 NaN 2014-09-24 06:48:00+00:00 True False \n", + "1 243216 243215.0 2014-09-24 15:38:24+00:00 True False \n", + "2 243217 243216.0 2014-09-24 15:26:18+00:00 True False \n", + "3 243218 243217.0 2014-09-24 07:58:55+00:00 True False \n", + "4 243219 243218.0 2014-09-24 07:10:40+00:00 True False \n", + "... ... ... ... ... ... \n", + "8616 378799 378798.0 2014-10-13 13:07:30+00:00 True False \n", + "8617 378800 378799.0 2014-10-10 16:35:53+00:00 True False \n", + "8618 378858 NaN 2014-10-03 19:00:16+00:00 True False \n", + "8619 378860 378859.0 2014-10-04 09:31:51+00:00 True False \n", + "8620 378861 378860.0 2014-10-03 20:03:47+00:00 True False \n", + "\n", + " text \\\n", + "0 User:NickK reported in IRC that they're gettin... \n", + "1 Revert has been deployed. \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... \n", + "... ... \n", + "8616 > When I registered, phabricator linked mediaw... \n", + "8617 See {T574} for a related discussion. \n", + "8618 Some improvements to the Wikimedia SUL dialog:... \n", + "8619 I guess the same restrictions as in T543 apply... \n", + "8620 It's not entirely trivial to change \n", + "\n", + " resolved_text \n", + "0 User:NickK reported in IRC that they're gettin... \n", + "1 Revert has been deployed. \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... \n", + "... ... \n", + "8616 > When I registered, phabricator linked mediaw... \n", + "8617 See {T574} for a related discussion. \n", + "8618 Some improvements to the Wikimedia SUL dialog:... \n", + "8619 I guess the same restrictions as in T543 apply... \n", + "8620 It's not entirely trivial to change \n", + "\n", + "[13628 rows x 16 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unique_df" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0c392d70-6236-4dfe-b6d4-bbe3f422b09e", + "metadata": {}, + "outputs": [], + "source": [ + "unique_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0050825_coref-rel-first.csv\", index=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/text_analysis/case3/.ipynb_checkpoints/c3-resolved-phab-checkpoint.ipynb b/text_analysis/case3/.ipynb_checkpoints/c3-resolved-phab-checkpoint.ipynb new file mode 100644 index 0000000..a3e8016 --- /dev/null +++ b/text_analysis/case3/.ipynb_checkpoints/c3-resolved-phab-checkpoint.ipynb @@ -0,0 +1,777 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ba9e5acd-e17d-4318-9272-04c9f6706186", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd \n", + "import spacy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e4f0b3f0-5255-46f1-822f-e455087ba315", + "metadata": {}, + "outputs": [], + "source": [ + "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref-rel-final.csv\"\n", + "phab_df = pd.read_csv(phab_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d449164e-1d28-4580-9eb1-f0f69978f114", + "metadata": {}, + "outputs": [], + "source": [ + "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n", + "#phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n", + "\n", + "#cleaning df\n", + "#phab_df['id'] = phab_df.index + 1\n", + "#may have to build out the reply_to column \n", + "#phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n", + "#phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n", + "\n", + "#phab_df = phab_df.rename(columns={\n", + "# 'AuthorPHID': 'speaker',\n", + "# 'TaskPHID': 'conversation_id',\n", + "# 'WMFaffil':'meta.affil',\n", + "# 'isGerrit': 'meta.gerrit'\n", + "#})\n", + "\n", + "# after 12-1-2012 before 12-1-2013\n", + "#phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n", + "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1385856000) & (phab_df['date_created'] > 1354320000)]\n", + "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n", + "\n", + "#removing headless conversations\n", + "task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n", + "headed_task_phids = task_phab_df['conversation_id'].unique()\n", + "filtered_phab_df = phab_df[phab_df['conversation_id'].isin(headed_task_phids)]\n", + "\n", + "#removing gerrit comments \n", + "#mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n", + "\n", + "'''\n", + "# filter out the sourceforge migration \n", + "# Originally from: http://sourceforge.net in the task task_summary\n", + "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n", + "\n", + "#cut down to only the data that is relevant (mentions http)\n", + "relevant_conversation_ids = task_phab_df[\n", + " task_phab_df['comment_text'].apply(http_relevant) |\n", + " task_phab_df['task_title'].apply(http_relevant)\n", + "]['conversation_id'].unique()\n", + "\n", + "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", + "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", + "\n", + "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", + "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", + "'''\n", + "#comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n", + "#task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n", + "comment_phab_df = filtered_phab_df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "942344db-c8f5-4ed6-a757-c97f8454f18b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique conversation_ids: 2281\n", + "Unique ids: 14490\n", + "Unique speakers: 634\n" + ] + } + ], + "source": [ + "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n", + "unique_ids = len(comment_phab_df['id'].unique())\n", + "unique_speakers = len(comment_phab_df['speaker'].unique())\n", + "\n", + "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n", + "print(f\"Unique ids: {unique_ids}\")\n", + "print(f\"Unique speakers: {unique_speakers}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d226d781-b002-4842-a3ae-92d4851a5878", + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "def preprocess_text(text):\n", + " text = str(text)\n", + " text = text.replace('*', ' ')\n", + " text = text.replace('-', ' ')\n", + " text = re.sub(r'http\\S+', '', text)\n", + " return text" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab", + "metadata": {}, + "outputs": [], + "source": [ + "nlp = spacy.load(\"en_core_web_sm\")\n", + "\n", + "def extract_dependency_tree(text):\n", + " doc = nlp(text)\n", + " dependency_trees = []\n", + " \n", + " for sentence in doc.sents:\n", + " for token in sentence:\n", + " token_info = (\n", + " token.text, \n", + " token.lemma_, \n", + " token.dep_, \n", + " token.head.text, \n", + " list(token.ancestors), \n", + " list(token.subtree), \n", + " list(token.children)\n", + " )\n", + " dependency_trees.append(token_info)\n", + " \n", + " return dependency_trees" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "337a528a-5667-4e1f-ac9a-37caabc03a18", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4", + "metadata": {}, + "outputs": [], + "source": [ + "#get VAD scores\n", + "import numpy as np\n", + "#https://saifmohammad.com/WebPages/nrc-vad.html\n", + "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n", + "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n", + "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n", + "\n", + "def vad_scoring(dependency_tree):\n", + " valence = []\n", + " arousal = []\n", + " dominance = []\n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " valence.append(vad_dict[lemma]['Valence'])\n", + " arousal.append(vad_dict[lemma]['Arousal'])\n", + " dominance.append(vad_dict[lemma]['Domination'])\n", + "\n", + " # Compute average scores across the comment\n", + " avg_valence = np.mean(valence) if valence else 0\n", + " avg_arousal = np.mean(arousal) if arousal else 0\n", + " avg_dominance = np.mean(dominance) if dominance else 0\n", + "\n", + " return [avg_valence, avg_arousal, avg_dominance]\n", + "\n", + "def dominance_prevail(dependency_tree):\n", + " dominant_words = 0 \n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " if vad_dict[lemma]['Domination'] >= 0.75:\n", + " dominant_words += 1\n", + " if vad_dict[lemma]['Domination'] <= 0.25:\n", + " dominant_words += 1\n", + " return dominant_words\n", + "\n", + "def arousal_prevail(dependency_tree):\n", + " arousal_words = 0 \n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " if vad_dict[lemma]['Arousal'] >= 0.75:\n", + " arousal_words += 1\n", + " if vad_dict[lemma]['Arousal'] <= 0.25:\n", + " arousal_words += 1\n", + " return arousal_words\n", + "\n", + "def valence_prevail(dependency_tree):\n", + " valence_words = 0 \n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " if vad_dict[lemma]['Valence'] >= 0.75:\n", + " valence_words += 1\n", + " if vad_dict[lemma]['Valence'] <= 0.25:\n", + " valence_words += 1\n", + " return valence_words\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "828fb57a-e152-42ef-9c60-660648898532", + "metadata": {}, + "outputs": [], + "source": [ + "#establishing per-comment VAD scores \n", + "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n", + "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n", + "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n", + "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "27e47f6f-0257-4b70-b222-e91ef888c900", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", + "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1889034d-bc93-495f-bdc4-961d193d3e08", + "metadata": {}, + "outputs": [], + "source": [ + "def token_http_relevant(word):\n", + " # expanded dictionary for relevancy\n", + " # http, login, SSL, TLS, certificate \n", + " if \"://\" not in word.lower():\n", + " #http\n", + " if \"http\" in word.lower():\n", + " return True\n", + " #login\n", + " if \"login\" in word.lower():\n", + " return True\n", + " #ssl\n", + " if \"ssl\" in word.lower():\n", + " return True\n", + " #tls\n", + " if \"tls\" in word.lower():\n", + " return True\n", + " #cert\n", + " if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n", + " return True\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "09ddcbfc-b856-40ca-ad61-13577795d94b", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0", + "metadata": {}, + "outputs": [], + "source": [ + "# expand the dependency parser \n", + "dependency_relations = []\n", + "resolved_dependency_relations = []\n", + "\n", + "for index, row in comment_phab_df.iterrows():\n", + " text = row['comment_text']\n", + " timestamp = row['timestamp']\n", + " comment_id = row['id']\n", + " conversation_id = row['conversation_id']\n", + " WMFaffil = row['meta.affil']\n", + " \n", + " for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n", + " dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", + " \n", + " for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n", + " resolved_dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", + "\n", + "resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations) \n", + "dependency_relations_df = pd.DataFrame(dependency_relations)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "82498686-14f4-40c8-9e33-27b31f115b47", + "metadata": {}, + "outputs": [], + "source": [ + "#now analysis/plotting \n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from matplotlib.gridspec import GridSpec" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n", + "plot2.set_axis_labels(\"Index of Speaker's Comment\", \"Count of Polarized Words\")\n", + "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n", + "plot2.fig.subplots_adjust(top=0.9) # Adjust subplots to make room for the title\n", + "plot2.add_legend(title=\"Comment publication timestamp:\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "2274795e-c64d-43e4-b0f5-a19b5b8ba2c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
comment_idtimestampwmfAffiltokendependencyheaddepthchildren
02432152014-09-24 06:48:00+00:00FalseUserdepreported10
12432152014-09-24 06:48:00+00:00False:punctreported10
22432152014-09-24 06:48:00+00:00FalseNickKnsubjreported10
32432152014-09-24 06:48:00+00:00FalsereportedROOTreported07
42432152014-09-24 06:48:00+00:00Falseinprepreported11
...........................
17087444068772014-10-17 09:17:17+00:00Falsen'tnegdo10
17087454068772014-10-17 09:17:17+00:00Falsereallyadvmoddo10
17087464068772014-10-17 09:17:17+00:00FalsedoROOTdo09
17087474068772014-10-17 09:17:17+00:00Falsemuchdobjdo10
17087484068772014-10-17 09:17:17+00:00False.punctdo10
\n", + "

1708749 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " comment_id timestamp wmfAffil token dependency \\\n", + "0 243215 2014-09-24 06:48:00+00:00 False User dep \n", + "1 243215 2014-09-24 06:48:00+00:00 False : punct \n", + "2 243215 2014-09-24 06:48:00+00:00 False NickK nsubj \n", + "3 243215 2014-09-24 06:48:00+00:00 False reported ROOT \n", + "4 243215 2014-09-24 06:48:00+00:00 False in prep \n", + "... ... ... ... ... ... \n", + "1708744 406877 2014-10-17 09:17:17+00:00 False n't neg \n", + "1708745 406877 2014-10-17 09:17:17+00:00 False really advmod \n", + "1708746 406877 2014-10-17 09:17:17+00:00 False do ROOT \n", + "1708747 406877 2014-10-17 09:17:17+00:00 False much dobj \n", + "1708748 406877 2014-10-17 09:17:17+00:00 False . punct \n", + "\n", + " head depth children \n", + "0 reported 1 0 \n", + "1 reported 1 0 \n", + "2 reported 1 0 \n", + "3 reported 0 7 \n", + "4 reported 1 1 \n", + "... ... ... ... \n", + "1708744 do 1 0 \n", + "1708745 do 1 0 \n", + "1708746 do 0 9 \n", + "1708747 do 1 0 \n", + "1708748 do 1 0 \n", + "\n", + "[1708749 rows x 8 columns]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resolved_dependency_relations_df" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_40267/3864244444.py:8: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + " filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "/tmp/ipykernel_40267/3864244444.py:9: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + " resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "/tmp/ipykernel_40267/3864244444.py:24: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_40267/3864244444.py:25: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "/tmp/ipykernel_40267/3864244444.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "/tmp/ipykernel_40267/3864244444.py:46: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_40267/3864244444.py:47: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "/tmp/ipykernel_40267/3864244444.py:47: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", + "pattern = r'\\b(contributor|community|volunteer)\\b'\n", + "#pattern = r'\\b(WMF|Foundation|Wikimedia)\\b'\n", + "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n", + "#pattern = r'\\b(http|https)\\b'\n", + "#pattern = r'\\b(auth)\\b'\n", + "\n", + "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "\n", + "plt.figure(figsize=(12, 8))\n", + "gs = GridSpec(2, 1, height_ratios=[6, 6])\n", + "\n", + "# Main plot: Token depth by timestamp\n", + "'''\n", + "ax0 = plt.subplot(gs[0])\n", + "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n", + "ax0.set_title('VE Depth by Timestamp w/o URLS')\n", + "ax0.set_xlabel('')\n", + "ax0.set_ylabel('Dependency Type')\n", + "ax0.legend().set_visible(False)\n", + "'''\n", + "# Calculate the median depth over time\n", + "filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", + "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n", + "#wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n", + "#other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "# Plot the median depth over time\n", + "ax0 = plt.subplot(gs[0])\n", + "#sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=wmf_filtered_dependencies, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=other_filtered_dependencies, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax0.set_title(f'Depth of {pattern} in Phabricator Sentence Dependency Trees')\n", + "ax0.set_ylabel('Median Depth')\n", + "ax0.set_xlabel('')\n", + "\n", + "# Calculate the median depth over time\n", + "resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", + "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n", + "#resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n", + "#resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "# Plot the median depth over time\n", + "ax1 = plt.subplot(gs[1])\n", + "#sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=resolved_wmf_filtered_dependencies, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=resolved_other_filtered_dependencies, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax1.set_title(f'Depth of {pattern} in Coreference-resolved Phabricator Sentence Dependency Trees')\n", + "ax1.set_ylabel('Median Depth')\n", + "ax1.set_xlabel('')\n", + "\n", + "plt.tight_layout()\n", + "#plt.show()\n", + "\n", + "#plt.savefig('031625_VE_depth_fig.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3e11af2-388a-4112-a71b-82c9fd6d5886", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/text_analysis/case3/.ipynb_checkpoints/coref_resolution-http-checkpoint.ipynb b/text_analysis/case3/.ipynb_checkpoints/coref_resolution-http-checkpoint.ipynb index 2e33ec6..98d3d02 100644 --- a/text_analysis/case3/.ipynb_checkpoints/coref_resolution-http-checkpoint.ipynb +++ b/text_analysis/case3/.ipynb_checkpoints/coref_resolution-http-checkpoint.ipynb @@ -10,9 +10,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n", - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/cuda/__init__.py:497: UserWarning: Can't initialize NVML\n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/torch/cuda/__init__.py:497: UserWarning: Can't initialize NVML\n", " warnings.warn(\"Can't initialize NVML\")\n" ] } @@ -29,7 +29,7 @@ "metadata": {}, "outputs": [], "source": [ - "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0415_http_phab_comments.csv\"\n", + "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0422_http_phab_comments.csv\"\n", "phab_df = pd.read_csv(phab_path)" ] }, @@ -61,7 +61,7 @@ " if \"tls\" in word.lower():\n", " return True\n", " #cert\n", - " if word.lower().startswith(\"cert\"):\n", + " if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n", " return True\n", " return False\n", "\n", @@ -84,12 +84,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:41: SettingWithCopyWarning: \n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:42: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:44: SettingWithCopyWarning: \n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:45: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -114,10 +114,11 @@ " 'isGerrit': 'meta.gerrit'\n", "})\n", "\n", - "# after 04-01-2015 before 10-1-2015\n", + "# after 10-01-2014 before 10-01-2015\n", "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n", - "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443657600) & (phab_df['date_created'] > 1427846400)]\n", - "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n", + "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] >= 1412207999)]\n", + "# after 07-01-2013 before 10-01-2015\n", + "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] > 1372636800)]\n", "\n", "#removing headless conversations\n", "task_phab_df = filtered_phab_df[filtered_phab_df['comment_type']==\"task_description\"]\n", @@ -151,16 +152,383 @@ { "cell_type": "code", "execution_count": 5, + "id": "4241cb0a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_titlecomment_textdate_createdspeakermeta.affilconversation_idcomment_typestatusmeta.gerritidreply_totimestampis_relevantis_migrated
197Creation of instances brokenAfter a replace of old instances, it is not po...1442753295PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_descriptionresolvedFalse198NaN2015-09-20 12:48:15+00:00TrueFalse
198Creation of instances brokenWorks now.1442864673PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse199198.02015-09-21 19:44:33+00:00TrueFalse
199Creation of instances brokenOk, the instances are deleted now, I will recr...1442864271PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse200199.02015-09-21 19:37:51+00:00TrueFalse
200Creation of instances brokenThe new instances have the same names as recen...1442854156PHID-USER-22bsa5u75jz3ci3wnpluFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse201200.02015-09-21 16:49:16+00:00TrueFalse
201Creation of instances brokenThis happens also with jessie and presice inst...1442835238PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse202201.02015-09-21 11:33:58+00:00TrueFalse
.............................................
406887Allow login using mosh as an alternative to pl...*** Bug 49454 has been marked as a duplicate o...1379011061PHID-USER-2nnm76h4ykalvvref2yeFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406888406887.02013-09-12 18:37:41+00:00TrueFalse
406888Allow login using mosh as an alternative to pl...JFTR, on Tools mosh-server processes eat up to...1376245807PHID-USER-vk6mlmacfhx77egryy5iFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406889406888.02013-08-11 18:30:07+00:00TrueFalse
406889Allow login using mosh as an alternative to pl...This is supported on tools, but adding it to t...1376185312PHID-USER-h75guknmwivm6x37iuteFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406890406889.02013-08-11 01:41:52+00:00TrueFalse
406890Allow login using mosh as an alternative to pl...Just found out that mosh already works for too...1376118400PHID-USER-5dqihbanu3caaj7pigifFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406891406890.02013-08-10 07:06:40+00:00TrueFalse
406891Allow login using mosh as an alternative to pl...(In reply to comment #0)\\n> ssh is quite painf...1376118251PHID-USER-6vzzsmi22zem6yttr6vpFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406892406891.02013-08-10 07:04:11+00:00TrueFalse
\n", + "

14490 rows × 14 columns

\n", + "
" + ], + "text/plain": [ + " task_title \\\n", + "197 Creation of instances broken \n", + "198 Creation of instances broken \n", + "199 Creation of instances broken \n", + "200 Creation of instances broken \n", + "201 Creation of instances broken \n", + "... ... \n", + "406887 Allow login using mosh as an alternative to pl... \n", + "406888 Allow login using mosh as an alternative to pl... \n", + "406889 Allow login using mosh as an alternative to pl... \n", + "406890 Allow login using mosh as an alternative to pl... \n", + "406891 Allow login using mosh as an alternative to pl... \n", + "\n", + " comment_text date_created \\\n", + "197 After a replace of old instances, it is not po... 1442753295 \n", + "198 Works now. 1442864673 \n", + "199 Ok, the instances are deleted now, I will recr... 1442864271 \n", + "200 The new instances have the same names as recen... 1442854156 \n", + "201 This happens also with jessie and presice inst... 1442835238 \n", + "... ... ... \n", + "406887 *** Bug 49454 has been marked as a duplicate o... 1379011061 \n", + "406888 JFTR, on Tools mosh-server processes eat up to... 1376245807 \n", + "406889 This is supported on tools, but adding it to t... 1376185312 \n", + "406890 Just found out that mosh already works for too... 1376118400 \n", + "406891 (In reply to comment #0)\\n> ssh is quite painf... 1376118251 \n", + "\n", + " speaker meta.affil \\\n", + "197 PHID-USER-qlodcndtwpolbdhncjis False \n", + "198 PHID-USER-qlodcndtwpolbdhncjis False \n", + "199 PHID-USER-qlodcndtwpolbdhncjis False \n", + "200 PHID-USER-22bsa5u75jz3ci3wnplu False \n", + "201 PHID-USER-qlodcndtwpolbdhncjis False \n", + "... ... ... \n", + "406887 PHID-USER-2nnm76h4ykalvvref2ye False \n", + "406888 PHID-USER-vk6mlmacfhx77egryy5i False \n", + "406889 PHID-USER-h75guknmwivm6x37iute False \n", + "406890 PHID-USER-5dqihbanu3caaj7pigif False \n", + "406891 PHID-USER-6vzzsmi22zem6yttr6vp False \n", + "\n", + " conversation_id comment_type status \\\n", + "197 PHID-TASK-pitdrld6mszruqmc6usf task_description resolved \n", + "198 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "199 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "200 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "201 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "... ... ... ... \n", + "406887 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406888 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406889 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406890 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406891 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "\n", + " meta.gerrit id reply_to timestamp is_relevant \\\n", + "197 False 198 NaN 2015-09-20 12:48:15+00:00 True \n", + "198 False 199 198.0 2015-09-21 19:44:33+00:00 True \n", + "199 False 200 199.0 2015-09-21 19:37:51+00:00 True \n", + "200 False 201 200.0 2015-09-21 16:49:16+00:00 True \n", + "201 False 202 201.0 2015-09-21 11:33:58+00:00 True \n", + "... ... ... ... ... ... \n", + "406887 False 406888 406887.0 2013-09-12 18:37:41+00:00 True \n", + "406888 False 406889 406888.0 2013-08-11 18:30:07+00:00 True \n", + "406889 False 406890 406889.0 2013-08-11 01:41:52+00:00 True \n", + "406890 False 406891 406890.0 2013-08-10 07:06:40+00:00 True \n", + "406891 False 406892 406891.0 2013-08-10 07:04:11+00:00 True \n", + "\n", + " is_migrated \n", + "197 False \n", + "198 False \n", + "199 False \n", + "200 False \n", + "201 False \n", + "... ... \n", + "406887 False \n", + "406888 False \n", + "406889 False \n", + "406890 False \n", + "406891 False \n", + "\n", + "[14490 rows x 14 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "comment_phab_df" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "930c4d9c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "data": { + "text/plain": [ + "862" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0050825_coref-rel-first.csv\"\n", + "prior_df = pd.read_csv(prior_path)\n", + "comment_phab_df['timestamp'] = pd.to_datetime(comment_phab_df['timestamp'], utc=True)\n", + "prior_df['timestamp'] = pd.to_datetime(prior_df['timestamp'], utc=True)\n", + "merged_df = comment_phab_df.merge(prior_df, how='outer', indicator=True)\n", + "len(merged_df)\n", + "only_in_comment_phab_df = merged_df[merged_df['_merge'] == 'left_only']\n", + "len(only_in_comment_phab_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "id": "f32f6eed-3aeb-4b05-8d40-7ed85e7235c5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -181,7 +549,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "id": "a5b062d8-2d26-4a3e-a84c-ba0eaf6eb436", "metadata": {}, "outputs": [], @@ -195,15 +563,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "424d35e0", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "John is frustrated with the VisualEditor project, he thinks it doesn't work." + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "doc" + ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 16, "id": "999e1656-0036-4ba2-bedf-f54493f67790", "metadata": {}, "outputs": [], @@ -249,7 +630,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 17, "id": "be476647-624b-4e95-ab62-9c6b08f85368", "metadata": {}, "outputs": [], @@ -262,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "id": "a9628b54-a1df-49cd-a365-9cba59de3421", "metadata": {}, "outputs": [ @@ -272,7 +653,7 @@ "'i hate ve.interface, ve.interface always messes up i browser'" ] }, - "execution_count": 13, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -283,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 19, "id": "46873641-8e88-4829-9e24-4dd5e6749bd1", "metadata": {}, "outputs": [ @@ -291,73 +672,76 @@ "name": "stderr", "output_type": "stream", "text": [ - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " \"\"\"Entry point for launching an IPython kernel.\n", - "Token indices sequence length is longer than the specified maximum sequence length for this model (712 > 512). Running this sequence through the model will result in indexing errors\n", - "Token indices sequence length is longer than the specified maximum sequence length for this model (712 > 512). Running this sequence through the model will result in indexing errors\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_46935/1097216843.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mcomment_phab_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'text'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcomment_phab_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'comment_text'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcomment_phab_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'resolved_text'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcomment_phab_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'text'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresolving_comment\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/pandas/core/series.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(self, func, convert_dtype, args, **kwargs)\u001b[0m\n\u001b[1;32m 4355\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat64\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4356\u001b[0m \"\"\"\n\u001b[0;32m-> 4357\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mSeriesApply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconvert_dtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4358\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4359\u001b[0m def _reduce(\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/pandas/core/apply.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1041\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_str\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1042\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1043\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_standard\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1044\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1045\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/pandas/core/apply.py\u001b[0m in \u001b[0;36mapply_standard\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1099\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1100\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;31m# type: ignore[arg-type]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1101\u001b[0;31m \u001b[0mconvert\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconvert_dtype\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1102\u001b[0m )\n\u001b[1;32m 1103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/pandas/_libs/lib.pyx\u001b[0m in \u001b[0;36mpandas._libs.lib.map_infer\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m/tmp/ipykernel_46935/2183590073.py\u001b[0m in \u001b[0;36mresolving_comment\u001b[0;34m(text)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mresolving_comment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdoc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnlp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mresolved_text\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresolve_references\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdoc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mresolved_text\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/spacy/language.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, text, disable, component_cfg)\u001b[0m\n\u001b[1;32m 1024\u001b[0m \u001b[0merror_handler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mproc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_error_handler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1025\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1026\u001b[0;31m \u001b[0mdoc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mproc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdoc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mcomponent_cfg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# type: ignore[call-arg]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1027\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1028\u001b[0m \u001b[0;31m# This typically happens if a component is not initialized\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/spacy/pipeline/trainable_pipe.pyx\u001b[0m in \u001b[0;36mspacy.pipeline.trainable_pipe.TrainablePipe.__call__\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/spacy_experimental/coref/coref_component.py\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, docs)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0;32mcontinue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m \u001b[0mscores\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0midxs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdoc\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 154\u001b[0m \u001b[0;31m# idxs is a list of mentions (start / end idxs)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;31m# each item in scores includes scores and a mapping from scores to mentions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/model.py\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 332\u001b[0m \u001b[0monly\u001b[0m \u001b[0mthe\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstead\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 333\u001b[0m \"\"\"\n\u001b[0;32m--> 334\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 335\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 336\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfinish_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptimizer\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/layers/chain.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(model, X, is_train)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mcallbacks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlayer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minc_layer_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 55\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minc_layer_grad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/model.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, X, is_train)\u001b[0m\n\u001b[1;32m 308\u001b[0m \"\"\"Call the model's `forward` function, returning the output and a\n\u001b[1;32m 309\u001b[0m callback to compute the gradients via backpropagation.\"\"\"\n\u001b[0;32m--> 310\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mInT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mOutT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m\"Model\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/layers/chain.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(model, X, is_train)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mcallbacks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlayer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minc_layer_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 55\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minc_layer_grad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/model.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, X, is_train)\u001b[0m\n\u001b[1;32m 308\u001b[0m \"\"\"Call the model's `forward` function, returning the output and a\n\u001b[1;32m 309\u001b[0m callback to compute the gradients via backpropagation.\"\"\"\n\u001b[0;32m--> 310\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mInT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mOutT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m\"Model\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/layers/chain.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(model, X, is_train)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mcallbacks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlayer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minc_layer_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 55\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minc_layer_grad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/model.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, X, is_train)\u001b[0m\n\u001b[1;32m 308\u001b[0m \"\"\"Call the model's `forward` function, returning the output and a\n\u001b[1;32m 309\u001b[0m callback to compute the gradients via backpropagation.\"\"\"\n\u001b[0;32m--> 310\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mInT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mOutT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m\"Model\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/spacy_transformers/layers/transformer_model.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(model, docs, is_train)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0mwordpieces\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malign\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtokenizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel_max_length\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 184\u001b[0m )\n\u001b[0;32m--> 185\u001b[0;31m \u001b[0mmodel_output\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbp_tensors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtransformer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwordpieces\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 186\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m\"logger\"\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 187\u001b[0m \u001b[0mlog_gpu_memory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"logger\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"after forward\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/model.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, X, is_train)\u001b[0m\n\u001b[1;32m 308\u001b[0m \"\"\"Call the model's `forward` function, returning the output and a\n\u001b[1;32m 309\u001b[0m callback to compute the gradients via backpropagation.\"\"\"\n\u001b[0;32m--> 310\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mInT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mOutT\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m\"Model\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/layers/pytorchwrapper.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(model, X, is_train)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0mXtorch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mget_dX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconvert_inputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 225\u001b[0;31m \u001b[0mYtorch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtorch_backprop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshims\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mXtorch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 226\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mget_dYtorch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconvert_outputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mYtorch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 227\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/shims/pytorch.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, inputs, is_train)\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbegin_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 97\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m...\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 98\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/thinc/shims/pytorch.py\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mno_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mamp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautocast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mixed_precision\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 116\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0moutputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1192\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1195\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/transformers/models/roberta/modeling_roberta.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input_ids, attention_mask, token_type_ids, position_ids, head_mask, inputs_embeds, encoder_hidden_states, encoder_attention_mask, past_key_values, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 861\u001b[0m \u001b[0moutput_attentions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput_attentions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 862\u001b[0m \u001b[0moutput_hidden_states\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput_hidden_states\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 863\u001b[0;31m \u001b[0mreturn_dict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreturn_dict\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 864\u001b[0m )\n\u001b[1;32m 865\u001b[0m \u001b[0msequence_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mencoder_outputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1192\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1195\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/transformers/models/roberta/modeling_roberta.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, hidden_states, attention_mask, head_mask, encoder_hidden_states, encoder_attention_mask, past_key_values, use_cache, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 532\u001b[0m \u001b[0mencoder_attention_mask\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 533\u001b[0m \u001b[0mpast_key_value\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 534\u001b[0;31m \u001b[0moutput_attentions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 535\u001b[0m )\n\u001b[1;32m 536\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1192\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1195\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/transformers/models/roberta/modeling_roberta.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, hidden_states, attention_mask, head_mask, encoder_hidden_states, encoder_attention_mask, past_key_value, output_attentions)\u001b[0m\n\u001b[1;32m 453\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 454\u001b[0m layer_output = apply_chunking_to_forward(\n\u001b[0;32m--> 455\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfeed_forward_chunk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchunk_size_feed_forward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseq_len_dim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattention_output\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 456\u001b[0m )\n\u001b[1;32m 457\u001b[0m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlayer_output\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moutputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/transformers/pytorch_utils.py\u001b[0m in \u001b[0;36mapply_chunking_to_forward\u001b[0;34m(forward_fn, chunk_size, chunk_dim, *input_tensors)\u001b[0m\n\u001b[1;32m 244\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput_chunks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mchunk_dim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 245\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 246\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput_tensors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 247\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 248\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/transformers/models/roberta/modeling_roberta.py\u001b[0m in \u001b[0;36mfeed_forward_chunk\u001b[0;34m(self, attention_output)\u001b[0m\n\u001b[1;32m 464\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfeed_forward_chunk\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattention_output\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 466\u001b[0;31m \u001b[0mintermediate_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mintermediate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattention_output\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 467\u001b[0m \u001b[0mlayer_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintermediate_output\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattention_output\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mlayer_output\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1192\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1195\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/transformers/models/roberta/modeling_roberta.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, hidden_states)\u001b[0m\n\u001b[1;32m 362\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 363\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhidden_states\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 364\u001b[0;31m \u001b[0mhidden_states\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdense\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhidden_states\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 365\u001b[0m \u001b[0mhidden_states\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mintermediate_act_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhidden_states\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 366\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mhidden_states\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1192\u001b[0m if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1195\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/nn/modules/linear.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 114\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mextra_repr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + " \"\"\"Entry point for launching an IPython kernel.\n" ] } ], "source": [ - "comment_phab_df['text'] = comment_phab_df['comment_text'].apply(str)\n", - "comment_phab_df['resolved_text'] = comment_phab_df['text'].apply(resolving_comment)" + "only_in_comment_phab_df['text'] = only_in_comment_phab_df['comment_text'].apply(str)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, + "id": "79e3f7e2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Token indices sequence length is longer than the specified maximum sequence length for this model (546 > 512). Running this sequence through the model will result in indexing errors\n", + "Token indices sequence length is longer than the specified maximum sequence length for this model (546 > 512). Running this sequence through the model will result in indexing errors\n", + "Token indices sequence length is longer than the specified maximum sequence length for this model (554 > 512). Running this sequence through the model will result in indexing errors\n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + } + ], + "source": [ + "only_in_comment_phab_df['resolved_text'] = only_in_comment_phab_df['text'].apply(resolving_comment)\n", + "only_in_comment_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref_rel_phab_stragglers.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, "id": "2b583feb-1c62-4c96-9ba0-2996d72e70d3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "7423 [Backport was merged into 1.24wmf16 upon a tim...\n", + "7902 I guess this can be closed now as RESOLVED WOR...\n", + "7905 The upstream issue is https://github.com/jcgre...\n", + "7906 An update on this. In Amsterdam we found at th...\n", + "7907 Yes. It's used by people using pywikibot-as-a-...\n", + " ... \n", + "14465 I amended the title to the range IE8-10 becaus...\n", + "14466 If I remember correctly this problem was at le...\n", + "14467 If I remember correctly this problem was at le...\n", + "14468 After a quick test, autocomplete seems to work...\n", + "14478 Still not merged, so we can't really do much.\n", + "Name: resolved_text, Length: 862, dtype: object" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "comment_phab_df['resolved_text'][46088]" + "only_in_comment_phab_df['resolved_text']" ] }, { @@ -367,7 +751,7 @@ "metadata": {}, "outputs": [], "source": [ - "comment_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/041525_coref_rel_phab_comments.csv\", index=False)" + "only_in_comment_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref_rel_phab_stragglers.csv\", index=False)" ] } ], @@ -387,7 +771,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.12" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/text_analysis/case3/041525_phab_comments.ipynb b/text_analysis/case3/041525_phab_comments.ipynb index 70e912c..3a8be4c 100644 --- a/text_analysis/case3/041525_phab_comments.ipynb +++ b/text_analysis/case3/041525_phab_comments.ipynb @@ -518,7 +518,7 @@ "outputs": [], "source": [ "task_phab_df\n", - "task_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/phab_tasks.csv\", index=False)" + "#task_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/phab_tasks.csv\", index=False)" ] }, { @@ -981,7 +981,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/text_analysis/case3/041525_resolved_phab_comments-Copy1.ipynb b/text_analysis/case3/041525_resolved_phab_comments-Copy1.ipynb deleted file mode 100644 index dbf3dc7..0000000 --- a/text_analysis/case3/041525_resolved_phab_comments-Copy1.ipynb +++ /dev/null @@ -1,803 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "ba9e5acd-e17d-4318-9272-04c9f6706186", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd \n", - "import spacy" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e4f0b3f0-5255-46f1-822f-e455087ba315", - "metadata": {}, - "outputs": [], - "source": [ - "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case2/041325_coref_rel_phab_comments.csv\"\n", - "phab_df = pd.read_csv(phab_path)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ac5e624b-08a4-4ede-bc96-cfc26c3edac3", - "metadata": {}, - "outputs": [], - "source": [ - "def http_relevant(text):\n", - " if pd.isnull(text):\n", - " return False\n", - " # expanded dictionary for relevancy\n", - " # http, login, SSL, TLS, certificate \n", - " for word in text.split():\n", - " if \"://\" not in word.lower():\n", - " #http\n", - " if \"http\" in word.lower():\n", - " return True\n", - " #login\n", - " if \"login\" in word.lower():\n", - " return True\n", - " #ssl\n", - " if \"ssl\" in word.lower():\n", - " return True\n", - " #tls\n", - " if \"tls\" in word.lower():\n", - " return True\n", - " #cert\n", - " if word.lower().startswith(\"cert\"):\n", - " return True\n", - " return False" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d5925c49-ea1d-4813-98aa-eae10d5879ca", - "metadata": {}, - "outputs": [], - "source": [ - "def is_migrated(comment_text):\n", - " if pd.isnull(comment_text):\n", - " return False\n", - " text = comment_text.strip()\n", - " if text.startswith(\"Originally from: http://sourceforge.net\"):\n", - " return True \n", - " return False" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d449164e-1d28-4580-9eb1-f0f69978f114", - "metadata": {}, - "outputs": [], - "source": [ - "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n", - "#phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n", - "\n", - "#cleaning df\n", - "#phab_df['id'] = phab_df.index + 1\n", - "#may have to build out the reply_to column \n", - "#phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n", - "#phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n", - "\n", - "#phab_df = phab_df.rename(columns={\n", - "# 'AuthorPHID': 'speaker',\n", - "# 'TaskPHID': 'conversation_id',\n", - "# 'WMFaffil':'meta.affil',\n", - "# 'isGerrit': 'meta.gerrit'\n", - "#})\n", - "\n", - "# after 12-1-2012 before 12-1-2013\n", - "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n", - "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1385856000) & (phab_df['date_created'] > 1354320000)]\n", - "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n", - "\n", - "#removing headless conversations\n", - "task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n", - "headed_task_phids = task_phab_df['conversation_id'].unique()\n", - "filtered_phab_df = phab_df[phab_df['conversation_id'].isin(headed_task_phids)]\n", - "\n", - "#removing gerrit comments \n", - "#mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n", - "\n", - "'''\n", - "# filter out the sourceforge migration \n", - "# Originally from: http://sourceforge.net in the task task_summary\n", - "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n", - "\n", - "#cut down to only the data that is relevant (mentions http)\n", - "relevant_conversation_ids = task_phab_df[\n", - " task_phab_df['comment_text'].apply(http_relevant) |\n", - " task_phab_df['task_title'].apply(http_relevant)\n", - "]['conversation_id'].unique()\n", - "\n", - "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", - "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", - "\n", - "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", - "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", - "'''\n", - "#comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n", - "#task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n", - "comment_phab_df = filtered_phab_df" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "942344db-c8f5-4ed6-a757-c97f8454f18b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unique conversation_ids: 382\n", - "Unique ids: 1838\n", - "Unique speakers: 189\n" - ] - } - ], - "source": [ - "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n", - "unique_ids = len(comment_phab_df['id'].unique())\n", - "unique_speakers = len(comment_phab_df['speaker'].unique())\n", - "\n", - "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n", - "print(f\"Unique ids: {unique_ids}\")\n", - "print(f\"Unique speakers: {unique_speakers}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d226d781-b002-4842-a3ae-92d4851a5878", - "metadata": {}, - "outputs": [], - "source": [ - "import re\n", - "\n", - "def preprocess_text(text):\n", - " text = str(text)\n", - " text = text.replace('*', ' ')\n", - " text = text.replace('-', ' ')\n", - " text = re.sub(r'http\\S+', '', text)\n", - " return text" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab", - "metadata": {}, - "outputs": [], - "source": [ - "nlp = spacy.load(\"en_core_web_sm\")\n", - "\n", - "def extract_dependency_tree(text):\n", - " doc = nlp(text)\n", - " dependency_trees = []\n", - " \n", - " for sentence in doc.sents:\n", - " for token in sentence:\n", - " token_info = (\n", - " token.text, \n", - " token.lemma_, \n", - " token.dep_, \n", - " token.head.text, \n", - " list(token.ancestors), \n", - " list(token.subtree), \n", - " list(token.children)\n", - " )\n", - " dependency_trees.append(token_info)\n", - " \n", - " return dependency_trees" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "337a528a-5667-4e1f-ac9a-37caabc03a18", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4", - "metadata": {}, - "outputs": [], - "source": [ - "#get VAD scores\n", - "import numpy as np\n", - "#https://saifmohammad.com/WebPages/nrc-vad.html\n", - "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n", - "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n", - "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n", - "\n", - "def vad_scoring(dependency_tree):\n", - " valence = []\n", - " arousal = []\n", - " dominance = []\n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " valence.append(vad_dict[lemma]['Valence'])\n", - " arousal.append(vad_dict[lemma]['Arousal'])\n", - " dominance.append(vad_dict[lemma]['Domination'])\n", - "\n", - " # Compute average scores across the comment\n", - " avg_valence = np.mean(valence) if valence else 0\n", - " avg_arousal = np.mean(arousal) if arousal else 0\n", - " avg_dominance = np.mean(dominance) if dominance else 0\n", - "\n", - " return [avg_valence, avg_arousal, avg_dominance]\n", - "\n", - "def dominance_prevail(dependency_tree):\n", - " dominant_words = 0 \n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " if vad_dict[lemma]['Domination'] >= 0.75:\n", - " dominant_words += 1\n", - " if vad_dict[lemma]['Domination'] <= 0.25:\n", - " dominant_words += 1\n", - " return dominant_words\n", - "\n", - "def arousal_prevail(dependency_tree):\n", - " arousal_words = 0 \n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " if vad_dict[lemma]['Arousal'] >= 0.75:\n", - " arousal_words += 1\n", - " if vad_dict[lemma]['Arousal'] <= 0.25:\n", - " arousal_words += 1\n", - " return arousal_words\n", - "\n", - "def valence_prevail(dependency_tree):\n", - " valence_words = 0 \n", - " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", - " if lemma in vad_dict:\n", - " if vad_dict[lemma]['Valence'] >= 0.75:\n", - " valence_words += 1\n", - " if vad_dict[lemma]['Valence'] <= 0.25:\n", - " valence_words += 1\n", - " return valence_words\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "828fb57a-e152-42ef-9c60-660648898532", - "metadata": {}, - "outputs": [], - "source": [ - "#establishing per-comment VAD scores \n", - "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n", - "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n", - "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n", - "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "27e47f6f-0257-4b70-b222-e91ef888c900", - "metadata": {}, - "outputs": [], - "source": [ - "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", - "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1889034d-bc93-495f-bdc4-961d193d3e08", - "metadata": {}, - "outputs": [], - "source": [ - "def token_http_relevant(word):\n", - " # expanded dictionary for relevancy\n", - " # http, login, SSL, TLS, certificate \n", - " if \"://\" not in word.lower():\n", - " #http\n", - " if \"http\" in word.lower():\n", - " return True\n", - " #login\n", - " if \"login\" in word.lower():\n", - " return True\n", - " #ssl\n", - " if \"ssl\" in word.lower():\n", - " return True\n", - " #tls\n", - " if \"tls\" in word.lower():\n", - " return True\n", - " #cert\n", - " if word.lower().startswith(\"cert\"):\n", - " return True\n", - " return False" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "09ddcbfc-b856-40ca-ad61-13577795d94b", - "metadata": {}, - "outputs": [], - "source": [ - "import datetime" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0", - "metadata": {}, - "outputs": [], - "source": [ - "# expand the dependency parser \n", - "\n", - "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", - "#pattern = r'\\b(WMF|Foundation)\\b'\n", - "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n", - "pattern = r'\\b(http|https)\\b'\n", - "\n", - "dependency_relations = []\n", - "resolved_dependency_relations = []\n", - "\n", - "for index, row in comment_phab_df.iterrows():\n", - " text = row['comment_text']\n", - " timestamp = row['timestamp']\n", - " comment_id = row['id']\n", - " conversation_id = row['conversation_id']\n", - " WMFaffil = row['meta.affil']\n", - " \n", - " for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n", - " if token_http_relevant(token):\n", - " dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", - " \n", - " for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n", - " if token_http_relevant(token):\n", - " resolved_dependency_relations.append({\n", - " 'comment_id': comment_id,\n", - " 'timestamp': timestamp,\n", - " 'wmfAffil':WMFaffil,\n", - " 'token': token,\n", - " 'dependency': dep,\n", - " 'head': head,\n", - " 'depth': len(list(ancestors)), \n", - " 'children': len(list(children)) \n", - " })\n", - "\n", - "resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations) \n", - "dependency_relations_df = pd.DataFrame(dependency_relations)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "82498686-14f4-40c8-9e33-27b31f115b47", - "metadata": {}, - "outputs": [], - "source": [ - "#now analysis/plotting \n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from matplotlib.gridspec import GridSpec" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n", - "plot2.set_axis_labels(\"Index of Speaker's Comment\", \"Count of Polarized Words\")\n", - "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n", - "plot2.fig.subplots_adjust(top=0.9) # Adjust subplots to make room for the title\n", - "plot2.add_legend(title=\"Comment publication timestamp:\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "2274795e-c64d-43e4-b0f5-a19b5b8ba2c8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
comment_idtimestampwmfAffiltokendependencyheaddepthchildren
01152013-10-11 09:04:00+00:00Falseuse_api_logindobjuse_api16
11572013-10-07 08:09:00+00:00Falseuse_api_logindobjuse_api14
21772013-10-04 17:56:00+00:00Falsecertainlyadvmodrequire21
32472013-09-27 22:15:00+00:00FalseLoginROOTLogin04
44262013-09-01 11:26:00+00:00FalseHTTPcompoundlogin40
...........................
1463453002013-08-01 17:35:00+00:00Falsecertainamodcommands50
1464453002013-08-01 17:35:00+00:00Falsecertainamodcommands50
1465453732013-07-27 13:30:00+00:00Falsecertainamodelement80
1466460782013-06-18 21:17:00+00:00FalseHTTPcompoundError20
1467460862013-06-19 23:31:02+00:00FalseHTTPcompoundError30
\n", - "

1468 rows × 8 columns

\n", - "
" - ], - "text/plain": [ - " comment_id timestamp wmfAffil token \\\n", - "0 115 2013-10-11 09:04:00+00:00 False use_api_login \n", - "1 157 2013-10-07 08:09:00+00:00 False use_api_login \n", - "2 177 2013-10-04 17:56:00+00:00 False certainly \n", - "3 247 2013-09-27 22:15:00+00:00 False Login \n", - "4 426 2013-09-01 11:26:00+00:00 False HTTP \n", - "... ... ... ... ... \n", - "1463 45300 2013-08-01 17:35:00+00:00 False certain \n", - "1464 45300 2013-08-01 17:35:00+00:00 False certain \n", - "1465 45373 2013-07-27 13:30:00+00:00 False certain \n", - "1466 46078 2013-06-18 21:17:00+00:00 False HTTP \n", - "1467 46086 2013-06-19 23:31:02+00:00 False HTTP \n", - "\n", - " dependency head depth children \n", - "0 dobj use_api 1 6 \n", - "1 dobj use_api 1 4 \n", - "2 advmod require 2 1 \n", - "3 ROOT Login 0 4 \n", - "4 compound login 4 0 \n", - "... ... ... ... ... \n", - "1463 amod commands 5 0 \n", - "1464 amod commands 5 0 \n", - "1465 amod element 8 0 \n", - "1466 compound Error 2 0 \n", - "1467 compound Error 3 0 \n", - "\n", - "[1468 rows x 8 columns]" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "resolved_dependency_relations_df" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_79236/963914566.py:4: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", - " filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_79236/963914566.py:5: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", - " resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "/tmp/ipykernel_79236/963914566.py:20: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", - " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_79236/963914566.py:20: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_79236/963914566.py:39: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", - " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "/tmp/ipykernel_79236/963914566.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAMWCAYAAAAgRDUeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU9f7H8dfMMAPDDrIriuK+b+S+74llrli5ZC7tmXUru5VaebstVlq3xW5ZuWTu5ZqI+1ak5b7groCAssPADMz5/cEProQLIHAG+Dwfj3koM2fOec+Zc87MfM73fL8aRVEUhBBCCCGEEEIIIYSoQFq1AwghhBBCCCGEEEKI6keKUkIIIYQQQgghhBCiwklRSgghhBBCCCGEEEJUOClKCSGEEEIIIYQQQogKJ0UpIYQQQgghhBBCCFHhpCglhBBCCCGEEEIIISqcFKWEEEIIIYQQQgghRIWTopQQQgghhBBCCCGEqHBSlBJCCCGEEEIIIYQQFU6KUkIIUUJBQUFMmDCh4O8dO3ag0WjYsWOHaplsVc+ePWnevHmFLOuDDz6gXr166HQ6WrduXSHLzDdr1iw0Gk2FLlMUz4QJEwgKCqrw5eYfF1auXFlm85wwYQLOzs73NI+LFy+i0Wj47rvvyiaUEJWY7A9CCKE+KUoJISql7777Do1Gg0ajYc+ePUUeVxSFwMBANBoNoaGhKiSsGD179ixYD1qtFldXVxo1asTYsWMJDw+vkAwxMTHMmjWLv/76q0KWdytbtmzh5ZdfpkuXLixcuJB//etft512woQJBetMo9Fgb29Pw4YNefPNN8nKyqrA1Ooqyft28/q60606FGbzi035N71eT7169Rg3bhznz59XO57qTpw4waxZs7h48WKFLnfPnj0MGjSImjVr4uDgQO3atRkyZAhLly4t1+Wq9XrLy82frRqNBgcHBwICAhgwYADz588nLS1N7YjiJvlFteLcqso2KoSoeuzUDiCEEPfCwcGBpUuX0rVr10L379y5k6tXr2Jvb1/uGbp3747JZMJgMJT7sm6lVq1avPvuuwBkZGRw9uxZVq9ezeLFixk1ahSLFy9Gr9eX2/JjYmKYPXs2QUFBFd5CKd+2bdvQarV88803xXof7O3t+e9//wtASkoKP//8M2+//Tbnzp1jyZIl5R3XJpTkfVu0aFGhv3/44QfCw8OL3N+kSZOyjnnPvv76a6xWa5nP97nnniMkJASLxcKhQ4dYsGABGzZs4OjRowQEBJT58spKnTp1MJlM5XZMOHHiBLNnz6Znz54V1kJtxYoVjB49mtatW/P888/j4eHBhQsX2LVrF19//TUPP/xwuS1bjddbEd566y3q1q2LxWLh2rVr7Nixg2nTpvHRRx/xyy+/0LJlS7UjCsDb27vIcXju3LlcvXqVjz/+uMi0Qghhi6QoJYSo1O6//35WrFjB/PnzsbP73yFt6dKltGvXjuvXr5d7Bq1Wi4ODQ7kv53bc3Nx49NFHC93373//m+eee47PP/+coKAg3nvvPZXSVYz4+HiMRmOxC4N2dnaF1tlTTz1F586d+fHHH/noo4/w9fUtr6iV0t+3rwMHDhAeHl7k/tJQFIWsrCyMRuM9z+tWyqv40q1bN0aMGAHAY489RsOGDXnuuef4/vvvmTFjRrks817k5ORgtVoxGAyqHq9KKzMzE0dHx1s+NmvWLJo2bcqBAweKHAPi4+MrIl6VM2jQINq3b1/w94wZM9i2bRuhoaE88MADnDx5stz2WVF8Tk5ORY7Dy5YtIykp6Y7H5/I+7gohREnI5XtCiEptzJgx3Lhxo9ClamazmZUrV9727LjVauWTTz6hWbNmODg44Ovry9SpU0lKSio0naIovPPOO9SqVQtHR0d69erF8ePHi8zvVn1K7d69m5EjR1K7dm3s7e0JDAzkhRdewGQyFXpufh8x0dHRDB06FGdnZ7y9vXnppZfIzc0t9XrR6XTMnz+fpk2b8tlnn5GSklLo8cWLF9OuXTuMRiOenp6EhYVx5cqVQtPk9wd18OBBOnfujNFopG7dunz55ZeFXntISAiQ98M8/zKBv/fPceLECXr16oWjoyM1a9bk/fffL9bryMnJ4e233yY4OBh7e3uCgoJ47bXXyM7OLphGo9GwcOFCMjIybrv8u9FoNHTt2hVFUYpcgrVp0ya6deuGk5MTLi4uDB48+Jbbwa3cbT0/88wzODs7k5mZWeS5Y8aMwc/Pr2A7+Pnnnxk8eDABAQHY29sTHBzM22+/XWQ7yX/f7rTOi/u+lURx96ugoCBCQ0P59ddfad++PUajka+++qpgP1q+fDmzZ8+mZs2auLi4MGLECFJSUsjOzmbatGn4+Pjg7OzMY489Vmg7uJ2/9ymVf7nLhx9+yIIFCwq2rZCQECIjI0v9+nv37g3AhQsXiqyXOXPmUKtWLRwcHOjTpw9nz54tNE1xjxf5zp8/z4ABA3ByciIgIIC33noLRVFu+Ro/+eSTgtd44sSJ2/ahc+rUKUaNGoW3tzdGo5FGjRrxz3/+s+DxS5cu8dRTT9GoUSOMRiM1atRg5MiRhS4J+u677xg5ciQAvXr1uuVlnZ9//jnNmjXD3t6egIAAnn76aZKTkwtlufnY0717dxwdHXnttdduu+7PnTtHSEjILYvSPj4+hf4u6Xa6Z88e7rvvPhwcHKhXrx4//PBDiV5vcY4fJfkcsFqtzJs3jxYtWuDg4IC3tzcDBw7kjz/+KDRdcY7xJdW7d2/eeOMNLl26xOLFiws9durUKUaMGIGnpycODg60b9+eX375pdA0+ZcG7tq1i6lTp1KjRg1cXV0ZN25ckfUPZb/ukpOTmTBhAm5ubri7uzN+/Pgi215pXs/evXuZPn063t7eODk58dBDD5GQkHDL19OjRw9cXFxwdXUlJCSk4PLSmTNnotfrb/m8KVOm4O7ufk+Xl9/uuJu/XqZNm0ZgYCD29vbUr1+f9957r0gL0+LuO3/88QcDBgzAy8ur4HvDxIkTS51dCFH1SVFKCFGpBQUF0alTJ3788ceC+zZt2kRKSgphYWG3fM7UqVP5xz/+QZcuXZg3bx6PPfYYS5YsYcCAAVgsloLp3nzzTd544w1atWpV0Il2//79ycjIuGuuFStWkJmZyZNPPsmnn37KgAED+PTTTxk3blyRaXNzcxkwYAA1atTgww8/pEePHsydO5cFCxaUYo38j06nY8yYMWRmZhbqd2vOnDmMGzeOBg0a8NFHHzFt2jQiIiLo3r17kS/oSUlJ3H///bRr147333+fWrVq8eSTT/Ltt98CeZdrvfXWW0DeF+dFixaxaNEiunfvXmgeAwcOpFWrVsydO5fGjRvzyiuvsGnTpru+hkmTJvHmm2/Stm1bPv74Y3r06MG7775b6L1dtGgR3bp1w97e/pbLL678H9ceHh6F5j148GCcnZ157733eOONNzhx4gRdu3a9a/8cxVnPo0ePJiMjgw0bNhR6bmZmJuvWrWPEiBHodDog7weQs7Mz06dPZ968ebRr144333yTV199tciy77bOi/O+lVRx9yuA06dPM2bMGPr168e8efMKXT747rvv8uuvv/Lqq68yceJEVq9ezRNPPMHEiRM5c+YMs2bNYtiwYXz33Xf31AJw6dKlfPDBB0ydOpV33nmHixcvMmzYsCJZi+vcuXMA1KhRo9D9//73v1mzZg0vvfQSM2bM4MCBAzzyyCOFpinp8WLgwIH4+vry/vvv065dO2bOnMnMmTOLTLtw4UI+/fRTpkyZwty5c/H09Lxl9iNHjtChQwe2bdvG5MmTmTdvHkOHDmXdunUF00RGRrJv3z7CwsKYP38+TzzxBBEREfTs2bOgqNq9e3eee+45AF577bWC7Sr/ss5Zs2bx9NNPExAQwNy5cxk+fDhfffUV/fv3L7Leb9y4waBBg2jdujWffPIJvXr1uu26r1OnDhEREVy9evW20+QryXZ69uxZRowYQb9+/Zg7dy4eHh5MmDChoDByt9dbkuNHcT8HHn/88YICwnvvvcerr76Kg4MDBw4cKJimJMf4kho7diyQ149fvuPHj9OxY0dOnjzJq6++yty5c3FycmLo0KGsWbOmyDyeeeYZTp48yaxZsxg3bhxLlixh6NChhQqrZb3uFEXhwQcfZNGiRTz66KO88847XL16lfHjxxfJV9LX8+yzz3L48GFmzpzJk08+ybp163jmmWcKTfPdd98xePBgEhMTmTFjBv/+979p3bo1mzdvLlivOTk5/PTTT4Wel3+Sbfjw4ffcwvFWx93MzEx69OjB4sWLGTduHPPnz6dLly7MmDGD6dOnF3p+cfad+Ph4+vfvz8WLF3n11Vf59NNPeeSRRwptn0IIUYQihBCV0MKFCxVAiYyMVD777DPFxcVFyczMVBRFUUaOHKn06tVLURRFqVOnjjJ48OCC5+3evVsBlCVLlhSa3+bNmwvdHx8frxgMBmXw4MGK1WotmO61115TAGX8+PEF923fvl0BlO3btxfcl5/lZu+++66i0WiUS5cuFdw3fvx4BVDeeuutQtO2adNGadeu3V3XQ48ePZRmzZrd9vE1a9YogDJv3jxFURTl4sWLik6nU+bMmVNouqNHjyp2dnaF7u/Ro4cCKHPnzi24Lzs7W2ndurXi4+OjmM1mRVEUJTIyUgGUhQsX3jIfoPzwww+F5uHn56cMHz78jq/tr7/+UgBl0qRJhe5/6aWXFEDZtm1bwX3jx49XnJyc7ji/v0+bkJCgJCQkKGfPnlU+/PBDRaPRKM2bNy94v9PS0hR3d3dl8uTJhZ5/7do1xc3NrdD9M2fOVG7+SC3uerZarUrNmjWLrIvly5crgLJr166C+261TU2dOlVxdHRUsrKyCu4r7jq/0/t2N08//XSh11vc/UpR8vZJQNm8eXOhafP3o+bNmxdsW4qiKGPGjFE0Go0yaNCgQtN36tRJqVOnzl2zjh8/vtB0Fy5cUAClRo0aSmJiYsH9P//8swIo69atu+P88nN+++23SkJCghITE6Ns2LBBCQoKUjQajRIZGVlouiZNmijZ2dkFz583b54CKEePHi24r6THi2effbbgPqvVqgwePFgxGAxKQkJCodfo6uqqxMfHF5pv/mM3v+/du3dXXFxcCi0rf953yrh///4i29qKFSuKHA8V5X/H1P79+yu5ubkF93/22WcF6zNf/jb85ZdfFlnmrXzzzTcKoBgMBqVXr17KG2+8oezevbvQchSldNvpzftgfHy8Ym9vr7z44ot3fb0lOX4U93Ng27ZtCqA899xzRdZB/ntVkmP8rdz82Xo7bm5uSps2bQr+7tOnj9KiRYtCxyGr1ap07txZadCgQZF5t2vXrtA+/v777yuA8vPPPyuKUj7rbu3atQqgvP/++wX35eTkKN26dSuyP5T09fTt27fQvvLCCy8oOp1OSU5OVhRFUZKTkxUXFxelQ4cOislkKpTz5ud16tRJ6dChQ6HHV69efcvt604GDx5c5Nh4u+Pu22+/rTg5OSlnzpwpdP+rr76q6HQ65fLly4qiFH/fyf/OcaftRwgh/k5aSgkhKr1Ro0ZhMplYv349aWlprF+//raX7q1YsQI3Nzf69evH9evXC27t2rXD2dmZ7du3A7B161bMZjPPPvssGo2m4PnTpk0rVqab+2nIyMjg+vXrdO7cGUVR+PPPP4tM/8QTTxT6u1u3bmUyklf+8PH5IyatXr0aq9XKqFGjCr1+Pz8/GjRoUPD689nZ2TF16tSCvw0GA1OnTiU+Pp6DBw8WO8PNfVsYDAbuu+++u76+jRs3AhQ5W/viiy8CFGldVBIZGRl4e3vj7e1N/fr1eemll+jSpQs///xzwfsdHh5OcnIyY8aMKbSudDodHTp0KLKublbc9azRaBg5ciQbN24kPT294Pk//fQTNWvWLNSB/83bVFpaGtevX6dbt25kZmZy6tSpQssv7TovreLuV/nq1q3LgAEDbjmvcePGFeoHqkOHDiiKUuTyjw4dOnDlyhVycnJKlXn06NGFWsV169YNoNjraOLEiXh7exMQEMDgwYPJyMjg+++/L9QPD+RdHnnzZWW3Wk5Jjxc3t8LQaDQ888wzmM1mtm7dWmi64cOH37Vz44SEBHbt2sXEiROpXbt2ocduPvbdnNFisXDjxg3q16+Pu7s7hw4duuMy4H/H1GnTpqHV/u/r5+TJk3F1dS2yP9vb2/PYY4/ddb6Q915s3ryZnj17smfPHt5++226detGgwYN2LdvX8F0Jd1OmzZtWvB+QV5H0Y0aNSrWNlKa48fdPgdWrVqFRqO5Zau4/PeqpMf40nB2di74TElMTGTbtm2MGjWq4Lh0/fp1bty4wYABA4iKiiI6OrrQ86dMmVJoH3/yySexs7MrOOaXx7rbuHEjdnZ2PPnkkwX36XQ6nn322ULPK+3ruXlf6datG7m5uVy6dKng9aSlpRW0arvZzc8bN24cv/32W0GrS4AlS5YQGBhIjx49irzmkrrVcXfFihV069YNDw+PQuu6b9++5ObmsmvXroLpirPvuLu7A7B+/fpStzoVQlQ/0tG5EKLS8/b2pm/fvixdupTMzExyc3MLOiD+u6ioKFJSUor0M5Ivv1Pc/C+TDRo0KLKsm3/I3s7ly5d58803+eWXX4r0t/D3/p3y+wW5mYeHxy372Cip/EKHi4sLkPf6FUUp8rry/b1T6ICAAJycnArd17BhQyDvcreOHTveNUOtWrUKffGGvNd35MiROz7v0qVLaLVa6tevX+h+Pz8/3N3dC96j0nBwcCi4NOnq1au8//77BZ2l54uKigL+11fQ37m6ut52/iVZz6NHj+aTTz7hl19+4eGHHyY9PZ2NGzcyderUQuvt+PHjvP7662zbto3U1NRC8/v7NlXadV5axd2v8tWtW/e28/p7YcTNzQ2AwMDAIvdbrVZSUlKKXDJXHH9fTv5+Xdz97s0336Rbt27odDq8vLxo0qRJocEWSrKckhwvtFot9erVK3Tfzfvkze60nvPl/3Bv3rz5HaczmUy8++67LFy4kOjo6EKXWv09463k76+NGjUqdL/BYKBevXpF9ueaNWuWaETTAQMGMGDAADIzMzl48CA//fQTX375JaGhoZw6dQofH58Sb6d/f++g+Mfmkh4/ivM5cO7cOQICAm57GWb+cktyjC+N9PT0gnV49uxZFEXhjTfe4I033rjl9PHx8dSsWbPg779nc3Z2xt/fv2D7LY91d+nSJfz9/QtO1OT7+/ZYmtdzt308v8h0t31s9OjRTJs2jSVLlvDmm2+SkpLC+vXreeGFF4ocz0vjVseDqKgojhw5ctvidf4+Udx9p0ePHgwfPpzZs2fz8ccf07NnT4YOHcrDDz9cIaMhCyEqJylKCSGqhIcffpjJkydz7do1Bg0aVHC27u+sVis+Pj4sWbLklo+XxZDJubm59OvXj8TERF555RUaN26Mk5MT0dHRTJgwoUjnofl9BpWHY8eOARQUdqxWKxqNhk2bNt1yuX//wl4Wbvf6bv5Reydl8WX873Q6HX379i34e8CAATRu3JipU6cWdGab/z4tWrQIPz+/IvO4VQEiX0nWc8eOHQkKCmL58uU8/PDDrFu3DpPJxOjRowumSU5OpkePHri6uvLWW28RHByMg4MDhw4d4pVXXin2NlXcdV5SJd2v7jTi0+2yl/Vrutf5tWjRotA2VNrllPR4URJlObLWs88+y8KFC5k2bRqdOnXCzc0NjUZDWFjYPWW8ndJmd3R0pFu3bnTr1g0vLy9mz57Npk2bGD9+fIm303vZRkp6/Cirz4HyPsZfvXqVlJSUQp8pAC+99NJtWz/+/cTC3ai17m5edkleT1kdmzw8PAgNDS0oSq1cuZLs7OwyGeUUbr1PWa1W+vXrx8svv3zL5+QXvIu772g0GlauXMmBAwdYt24dv/76KxMnTmTu3LkcOHCgXL5jCCEqPylKCSGqhIceeoipU6dy4MCBIh2F3iw4OJitW7fSpUuXO/7oqVOnDpB3dvDmVgkJCQl3PUt+9OhRzpw5w/fff1+oo+KbRwisCLm5uSxduhRHR8eCy8CCg4NRFIW6desWfNm8k5iYGDIyMgq1ljpz5gxAwYhm5VE0grz3wGq1EhUVVdBxMEBcXBzJyckF71FZ8Pf354UXXmD27NkcOHCAjh07EhwcDOSN3lWc4sPNSrqeR40axbx580hNTeWnn34iKCioUCu0HTt2cOPGDVavXl2oM/K/j/RWEmX5vhV3vxJFlfR4YbVaOX/+fKHt6u/7ZEnkH9/yC9i3s3LlSsaPH8/cuXML7svKyirScfbttqv8/fX06dOFjqlms5kLFy6UeB8rjvxLKWNjY4Hy2U5v93rv5fhxO8HBwfz6668kJibetrVUSY89JbVo0SKAgoJN/nup1+uL/TqjoqIKdVyfnp5ObGws999/P1A+6y6/M/z09PRChZHTp08Xmq40r+du8l/PsWPH7lqgGzduHA8++CCRkZEsWbKENm3a0KxZszLJcbts6enpd32tJd13OnbsSMeOHZkzZw5Lly7lkUceYdmyZUyaNKmsogshqhDpU0oIUSU4OzvzxRdfMGvWLIYMGXLb6UaNGkVubi5vv/12kcdycnIKfmD17dsXvV7Pp59+Wuhs5yeffHLXLPlnTW9+nqIozJs3r5iv5t7l5uby3HPPcfLkSZ577rmCyx2GDRuGTqdj9uzZRc7iKorCjRs3Ct2Xk5NTMGw05P2A/Oqrr/D29qZdu3YABQWrex3V6e/yf6D8fZ1/9NFHAAwePLhMl/fss8/i6OjIv//9byDvR5erqyv/+te/btk3xq2G7s5X0vU8evRosrOz+f7779m8eTOjRo0q9Pittimz2cznn39eshd5k7J834q7X4miSnO8+OyzzwpN+9lnn6HX6+nTp0+Jl+/t7U337t359ttvuXz5cqHHbs6k0+mKbMuffvopubm5he673XbVt29fDAYD8+fPLzSfb775hpSUlHvanyMiIm55f34fRfmXaJXHdnq713svx4/bGT58OIqiMHv27CKP5a/Tkh57SmLbtm28/fbb1K1bt2AESR8fH3r27MlXX31VUPy72a1e54IFCwqtky+++IKcnBwGDRoElM+6u//++8nJyeGLL74ouC83N5dPP/200HSleT13079/f1xcXHj33XfJysoq9Njf36NBgwbh5eXFe++9x86dO8usldTtjBo1iv379/Prr78WeSw5Obmgz77i7jtJSUlFXlP+6KrZ2dllG14IUWVISykhRJVxq6Gd/65Hjx5MnTqVd999l7/++ov+/fuj1+uJiopixYoVzJs3jxEjRuDt7c1LL73Eu+++S2hoKPfffz9//vknmzZtwsvL647LaNy4McHBwbz00ktER0fj6urKqlWryqSPqFtJSUlh8eLFAGRmZnL27FlWr17NuXPnCAsLK/QlMjg4mHfeeYcZM2Zw8eJFhg4diouLCxcuXGDNmjVMmTKFl156qWD6gIAA3nvvPS5evEjDhg356aef+Ouvv1iwYEFB3yTBwcG4u7vz5Zdf4uLigpOTEx06dChWfzZ30qpVK8aPH8+CBQsKLl/7/fff+f777xk6dOgdh4gvjRo1avDYY4/x+eefc/LkSZo0acIXX3zB2LFjadu2LWFhYXh7e3P58mU2bNhAly5dChUHblbS9dy2bVvq16/PP//5T7KzswtdugfQuXNnPDw8GD9+PM899xwajYZFixbd0+V4Zfm+FXe/EkWV9Hjh4ODA5s2bGT9+PB06dGDTpk1s2LCB1157rdSXH8+fP5+uXbvStm1bpkyZQt26dbl48SIbNmzgr7/+AiA0NJRFixbh5uZG06ZN2b9/P1u3bi3Sn1fr1q3R6XS89957pKSkYG9vT+/evfHx8WHGjBnMnj2bgQMH8sADD3D69Gk+//xzQkJC7unH94MPPkjdunUZMmQIwcHBZGRksHXrVtatW0dISEjBiYry2E7v9HpLe/y4nV69ejF27Fjmz59PVFQUAwcOxGq1snv3bnr16sUzzzxT4mPP7WzatIlTp06Rk5NDXFwc27ZtIzw8nDp16vDLL78U6rD7P//5D127dqVFixZMnjyZevXqERcXx/79+7l69SqHDx8uNG+z2UyfPn0YNWpUwTbQtWtXHnjgASCvz6iyXndDhgyhS5cuvPrqq1y8eJGmTZuyevXqW/aHVtLXczeurq58/PHHTJo0iZCQEB5++GE8PDw4fPgwmZmZfP/99wXT6vV6wsLC+Oyzz9DpdIwZM6ZEyyqpf/zjH/zyyy+EhoYyYcIE2rVrR0ZGBkePHmXlypVcvHgRLy+vYu8733//PZ9//jkPPfQQwcHBpKWl8fXXX+Pq6lpwokkIIYoov4H9hBCi/BRn2GpFyRsGefDgwUXuX7BggdKuXTvFaDQqLi4uSosWLZSXX35ZiYmJKZgmNzdXmT17tuLv768YjUalZ8+eyrFjx5Q6deoo48ePL5guf+j3m4dsPnHihNK3b1/F2dlZ8fLyUiZPnqwcPny4yNDT48ePV5ycnIrkmzlzplKcQ3T+0On5N2dnZ6VBgwbKo48+qmzZsuW2z1u1apXStWtXxcnJSXFyclIaN26sPP3008rp06cLzbtZs2bKH3/8oXTq1ElxcHBQ6tSpo3z22WdF5vfzzz8rTZs2Vezs7Aq9xvx5/N348eOLDFl9KxaLRZk9e7ZSt25dRa/XK4GBgcqMGTMKDdWdP79brcdbudO0586dU3Q6XZH3d8CAAYqbm5vi4OCgBAcHKxMmTFD++OOPgmlu934VZz3n++c//6kASv369W+Zbe/evUrHjh0Vo9GoBAQEKC+//LLy66+/Ftn2SrLOb/e+3c3TTz99y9dbnP3qdvtk/n60YsWKQvffbl/PX+cJCQl3zPr3133hwgUFUD744IMi0wLKzJkz7zi/2+Us7nT5y795XZf0eHHu3Dmlf//+iqOjo+Lr66vMnDlTyc3NLdZrvNXyFUVRjh07pjz00EOKu7u74uDgoDRq1Eh54403Ch5PSkpSHnvsMcXLy0txdnZWBgwYoJw6darI8VBRFOXrr79W6tWrp+h0uiLb52effaY0btxY0ev1iq+vr/Lkk08qSUlJhZ5/u234dn788UclLCxMCQ4OVoxGo+Lg4KA0bdpU+ec//6mkpqYWmf5ettMePXooPXr0KPbrLc7xoySfAzk5OcoHH3ygNG7cWDEYDIq3t7cyaNAg5eDBg4WmK8mx52b5+1v+zWAwKH5+fkq/fv2UefPm3XJ9KkresXPcuHGKn5+fotfrlZo1ayqhoaHKypUri8x7586dypQpUxQPDw/F2dlZeeSRR5QbN24UmWdZr7sbN24oY8eOVVxdXRU3Nzdl7Nixyp9//nnL/aEkr+fvx6ZbfSdQFEX55ZdflM6dOytGo1FxdXVV7rvvPuXHH38skv33339XAKV///5FV3QxDB48uMix/nbbs6IoSlpamjJjxgylfv36isFgULy8vJTOnTsrH374oWI2mwtNe7d959ChQ8qYMWOU2rVrK/b29oqPj48SGhpa6D0TQoi/0yhKOfV6KoQQolLr2bMn169fv2tfM0IIIcTdfPfddzz22GNERkYW9Pclijp8+DCtW7fmhx9+YOzYsWrHEUKIcid9SgkhhBBCCCGEDfj6669xdnZm2LBhakcRQogKIX1KCSGEEEIIIYSK1q1bx4kTJ1iwYAHPPPNMoVFvhRCiKpOilBBCCCGEEEKo6NlnnyUuLo7777//liMsCiFEVSV9SgkhhBBCCCGEEEKICid9SgkhhBBCCCGEEEKICidFKSGEEEIIIYQQQghR4Sp1n1JWq5WYmBhcXFzQaDRqxxFCCCGEEEIIIYSo9hRFIS0tjYCAALTa27eHqtRFqZiYGAIDA9WOIYQQQgghhBBCCCH+5sqVK9SqVeu2j1fqopSLiwuQ9yJdXV1VTiOEEEIIIYQQQgghUlNTCQwMLKjb3E6lLkrlX7Ln6uoqRSkhhBBCCCGEEEIIG3K3rpako3MhhBBCCCGEEEIIUeGkKCWEEEIIIYQQQgghKpwUpYQQQgghhBBCCCFEhZOilBBCCCGEEEIIIYSocFKUEkIIIYQQQgghhBAVTopSQgghhBBCCCGEEKLCSVFKCCGEEEIIIYQQQlQ4KUoJIYQQQgghhBBCiAqnalEqKCgIjUZT5Pb000+rGUsIm5eRkYHZbCY+Ph6z2UxGRobakYQQQgghhBBCiBJRtSgVGRlJbGxswS08PByAkSNHqhlLCJumKAqrVq3C19e34LZq1SoURVE7mhBCCCGEEEIIUWyqFqW8vb3x8/MruK1fv57g4GB69OihZiwhbFZGRgaLFi0iNDSUkJAQAEJCQggNDWXRokXSYkoIIYQQQgghRKWhUWykeYXZbCYgIIDp06fz2muv3XKa7OxssrOzC/5OTU0lMDCQlJQUXF1dKyqqEKoxm834+voSEhLC8lWr+WntZkYO7k1YWBiRkZHExcVhMBjUjimEEEIIIYQQohpLTU3Fzc3trvUam+nofO3atSQnJzNhwoTbTvPuu+/i5uZWcAsMDKy4gELYgOTkZJKTkzkel8W+y2amjh3Bwu8XER4eTnJyMikpKWpHFEIIIYQQQgghisVmWkoNGDAAg8HAunXrbjuNtJQS1V1+S6kn5q7gn4/0YtfZFDrX0jNq5HBpKSWEEEIIIYQQwiYUt6WUXQVmuq1Lly6xdetWVq9efcfp7O3tsbe3r6BUQtgei8XCB58vJGxYLz7fHcOx2Ey2bjvGsmXLWL9+PRaLRYpSQgghhBBCCCEqBZu4fG/hwoX4+PgwePBgtaMIYdOcnJx4ZMQQPt8dw97f/wQg1j6Ides3MHbsWJycnFROKIQQQgghhBBCFI/qRSmr1crChQsZP348dnY20XBLCJt1ITqe+TuiORabySeTeuFsAL3RmVotu6LRaNSOJ4QQQgghhBBCFJvqRamtW7dy+fJlJk6cqHYUIWzerCU7OX7NhCXmOHV9XNBePwvAkvA/VE4mhBBCCCGEEEKUjOpNk/r374+N9LUuhE07cf4KOd5N0AGjQvJGnmxTy4mdqZBu9CcnNxc7nU7dkEIIIYQQQgghRDGp3lJKCFE889YcQGenJyv2DA/1DgFgdL+OWLIycHDzZvPev9QNKIQQQgghhBBClIAUpYSoBKLjbpDqGgxA/4YuBfc7OzqgTbwAwOZDF1TJJoQQQgghhBBClIYUpYSoBOYu34HewQlTwiUmPtC90GOtazoCEGd1UyOaEEIIIYQQQghRKlKUEsLGpaRnEK0LACDEOxettvBu+3C/+7DmWDB61+b3o1FqRBRCCCGEEEIIIUpMilJC2LiPfozA3sWTrOQ4nh3Vp8jjNX1rYIk/B8Cq3ccqOp4QQgghhBBCCFEqUpQSwoZlmy2cyHQFoKEhEaO94ZbTNfTI+/dCuuoDagohhBBCCCGEEMUiRSkhbNjnK7dh9PTHnJ7M9LCiraTyjezZCgCDbzAXouMqKp4QQgghhBBCCFFqUpQSwkZZrVb2xSgA+Jqv4OnmcttpWzYMwhR3Aa1Wx4/hf1RURCGEEEIIIYQQotSkKCWEjVq0cS9G37rkZJt4cVSPu05f05AOwNG47PKOJoQQQgghhBBC3DMpSglhozYcTwTAKTmK2v7ed51+8H0NAdB41SM5Nb1cswkhhBBCCCGEEPdKilJC2KANuw/hENAYa46FZ4aEFOs5fe5rTlbSNewMRn7c8ls5JxRCCCGEEEIIIe6NFKWEsEFL910AQBt/klaNgor1HK1Wi5s5HoAD5xPLK5oQQgghhBBCCFEmpCglhI05cOQMWr+mADzWu0mJntu7eU0Asl1qk222lHk2IYQQQgghhBCirEhRSggb89Xmw2i0WswxJ+gV0rxEzx3WOwRzRgoGZ3fW7pBR+IQQQgghhBBC2C4pSglhQ05fjMbs1RiAEe38S/x8e4MeQ8olALYdvVqm2YQQQgghhBBCiLIkRSkhbMi81fvQ6Q2YrkUxom/HUs3jvrruACTaeWO1WsswnRBCCCHEvcnIyMBsNhMfH4/ZbCYjI0PtSEIIIVQkRSkhbMS160kkOdcDoE89Y6nn8/CAjuSaszB6+rPz4ImyiieEEEIIcU8URWHVqlX4+voW3FatWoWiKGpHE0IIoRIpSglhI+b+tB290RlTwmUmDe1Z6vl4urmQe/08AL8cOF1G6YQQQgghSi8jI4NFixYRGhpKSEgIACEhIYSGhrJo0SJpMSWEENWUFKWEsAFpGSYu4wdA2xpm7HS6e5pfcx89AFezHe85mxBCCCHEvdLr9Tz//POEhYWxbNky3n//fZYtW0ZYWBjPP/88er1e7YhCCCFUIEUpIWzAxz9txd61BlnJ8Tw/qu89zy+sTzsUqxWjbz2On71cBgmFEEIIIUovOTmZ5ORkwsPD+eabb/jHP/7BN998Q3h4OMnJyaSkpKgdUQghhAqkKCWEyiyWHI6mOgEQbHcdR6P9Pc+zfm1/suPOAfDT9j/veX5CCCGEEKVlsVhwcXHB3d2dfv368fjjj/PBBx/w+OOP069fP9zd3XFzc1M7phBCCBXYqR1AiOruy9XbMdaojTkjlRfH9Cmz+QY5mbkGnE6UzkOFEEIIoY6MjAxGjhzJ1KlT+fjjj3nggQcICwsjPDyc8PBwli1bxvr167FYLBgMBrXjCiGEqGDSUkoIFVmtVnZdsQDgnXUJL3fXMpv3sG7NAdD71CcmIbHM5iuEEEIIURwJCQn06tWLTZs2sXnzZsaPH8/69euJjIwEIDIykvXr1zN27FicnJxUTiuEEEINUpQSQkU//roPo28wueYspg3vWqbz7tiyIabrV9Da6flxy+9lOm8hhBBCiDs5f/48nTt3JjIyEk9PT1599VU0Gg3Dhw8nLi6OK1eucPXqVZo1a4ZGo1E7rhBCCJVIUUoIFf1y5DoADolnCA70K/P5+5AEwKGr6WU+byGEEEKIWzl48CCdOnXi7Nmz1KlTh71791KnTh0AnJycMBgMnDhxgqCgIMaPH69yWiGEEGqSopQQKvl131/YBzTBmpvD06HtymUZ/dvUBcDqUZf0zKxyWYYQQgghRL4tW7bQs2dP4uPjadWqFfv27aNx48ZFpmvfvj03btzg+PHjxMbGqpBUCCGELZCilBAqWbT7bN5/4k7Stkm9clnG4G5tyE69jt7ozIqtv5XLMoQQQgghABYtWsTgwYNJT0+nT58+7Nq1i4CAgFtO6+npSbt2eSflIiIiKjKmEEIIGyJFKSFU8MeJc+DXFIBx3RuU23LsdDqcMmMA2H06vtyWI4QQQojqS1EU3nvvPcaNG0dOTg5jxoxh48aNuLreeQCXvn37ArB169aKiCmEEMIGSVFKCBV8vuEQWq0Oc8xJ+ndqVa7L6tLQG4B0YwA5ubnluiwhhBBCVC+5ubk8//zzvPrqqwC8+OKLLF68GIPBcNfn3lyUUhSlXHMKIYSwTVKUEqKCnbtyjWzPhgA82Mqn3Jc3ul9HLFkZOLh5sXnvX+W+PCGEEEJUD1lZWYSFhfHpp58CMHfuXD788EO02uL9xOjSpQsODg5ER0dz+vTp8owqhBDCRklRSogK9vGqPegMDpiunWN0/47lvjxnRwe0iRcA2HTwfLkvTwghhBBVX3JyMgMHDmTlypXo9XqWLl3K9OnTSzQPBwcHunbtCkB4eHh5xBRCCGHjpCglRAVKSEzhujFvSOQedfTFPpN4r9rUdAQgXnGvkOUJIYQQouqKjo6mW7du7Ny5ExcXFzZt2sSYMWNKNS/pV0oIIao3KUoJUYE+XLYNg6MrphtXmfpQrwpb7sMDOmDNsWD0rs3vR6MqbLlCCCGEqFpOnDhBp06dOHbsGH5+fuzatYs+ffqUen75Rant27eTk5NTVjGFEEJUElKUEqKCZJqyuWDN63S8lZsJvd6uwpYd4O2JJf4cAKt2H6uw5QohhBCi6tizZw9du3blypUrNGrUiP3799O6det7mmebNm3w9PQkLS2NyMjIsgkqhBCi0pCilBAV5JOftuLg5k1WynWmje5b4ctv6JH374X0iiuGCSGEEKJqWLNmDf369SMpKYmOHTuyZ88egoKC7nm+Wq22oKWVXMInhBDVjxSlhKgAObm5/JlkD0CQJg5nR4cKzzCqV2sADL7BnLtyrcKXL4QQQojK6YsvvmDEiBFkZWUxZMgQIiIi8PLyKrP5S79SQghRfUlRSogK8PWaHRi9ArFkpvFiWG9VMrRoUAdT3AW0Wh3Ltv6hSgYhhBBCVB6KovD666/z1FNPYbVamTx5MqtXr8bR0bFMl5NflNq/fz/p6ellOm8hhBC2TYpSQpQzq9XKtgtZAHhkXsC3hrtqWWoaMgA4Fm9WLYMQQgghbJ/FYuHxxx9nzpw5AMyaNYuvvvoKO7uy7wagXr161K1bF4vFwu7du8t8/kIIIWyXFKWEKGcrtv6G0a8+uZZsXhjWRdUsQzo0BEDrFUxiSpqqWYQQQghhmzIyMnjwwQdZuHAhWq2WBQsWMHPmTDQaTbktM7+1VHh4eLktQwghhO1RvSgVHR3No48+So0aNTAajbRo0YI//pBLi0TVsebPvP6b7G+cpkGdAFWz9AppRlZiLDqDA8u2/KZqFiGEEELYnoSEBHr16sWmTZswGo2sXbuWyZMnl/typV8pIYSonlQtSiUlJdGlSxf0ej2bNm3ixIkTzJ07Fw8PDzVjCVFmtv1+DENAU6zWXJ4Y2FrtOGi1WtwtCQAcOJ+kchohhChbGRkZmM1m4uPjMZvNZGRkqB1JiErl/PnzdO7cmcjISDw9PYmIiGDIkCEVsuzevXuj0Wg4evQo167JgCxCqEk+T0VFUrUo9d577xEYGMjChQu57777qFu3Lv379yc4OFjNWEKUmYXbTwGgXDvJfS0aqJwmT+8WNQEwu9Ym22xROY0QQpQNRVFYtWoVvr6+BbdVq1ahKIra0YSoFA4ePEinTp04e/YsderUYe/evXTq1KnClu/l5UWbNm0A2LZtW4UtVwhRmHyeioqmalHql19+oX379owcORIfHx/atGnD119/rWYkIcrMn6cuoPg2AeCRLvVUTvM/D/UKwZyRgsHZnTXbI9WOI4QQ9ywjI4NFixYRGhpK1179CGzbh/vu60BoaCiLFi2SM7xC3MWWLVvo2bMn8fHxtGrVin379tG4ceMKzyGX8Amhrps/T3sPGUmNei0ICQmRz1NRrjSKiiVPBwcHAKZPn87IkSOJjIzk+eef58svv2T8+PFFps/OziY7O7vg79TUVAIDA0lJScHV1bXCcgtRHJM+XIHZtyXZMaf46ZUH1Y5TyLj3VkBASxzij7DgxZFqxxFCiHtiNpvx9fUlJCSElWt+Yc/FTLoGGRnx0INERkYSFxeHwWBQO6YQNmnx4sU89thj5OTk0Lt3b1avXo2bm5sqWcLDw+nfvz+BgYFcunSpXDtWF0IUlf952nPQUBYt/JodZ5LoXEtP2OhR8nkqSiw1NRU3N7e71mtUbSlltVpp27Yt//rXv2jTpg1Tpkxh8uTJfPnll7ec/t1338XNza3gFhgYWMGJhSieizHxZHrkXa43uLmnymmK6lAvr9+2JDtvrFarymmEEOLeJCcnk5ycTHh4ODvOJHJ/M0/2XDSR6NWW5ORkUlJS1I4ohM1RFIX333+fsWPHkpOTw5gxY9i0aZNqBSmArl27Ym9vz5UrV4iKilIthxDVVXJyMskpKWTW68uus6mEtvBmw76jhIeHy+epKDeqFqX8/f1p2rRpofuaNGnC5cuXbzn9jBkzSElJKbhduXKlImIKUWIfrdiFncGIKe4Cjw7qonacIsb070CuOQujpz87/jihdhwhhLgn7u7uuLu7M2TYKHo39WXDsRt0r+/GqIlPEzJqmqo/soWwRbm5uUybNo1XXnkFgBdffJHFixer3gLCaDTSpUve9ya5hE+Iiufu7k6LAY/Sp2d3utd3ZePxRB7q04nBDw7D3d1dPk9FuVC1KNWlSxdOnz5d6L4zZ85Qp06dW05vb2+Pq6troZsQtiYxJY14+9oAdKmpQatVdTe7JU83F6zXzwGw7rfTd5laCCFsm8ViYd68efzw7dd8vjuGr9bt4/lZc3mqWwAjJk9n+f7zakcUwmZkZWURFhbG/PnzAZg7dy4ffvihzXxfye9XKjw8XOUkQlQ/cYlpjH1hFk91C2DaW/P4z6odfL4nliWLfmDevHlYLDJIkih7qn76vPDCCxw4cIB//etfnD17lqVLl7JgwQKefvppNWMJcU8+/DECg5MbpsQYnh7RR+04t9XMJ+9s6NVsR5WTCCHEvXFycmLs2LEs3XqIY7GZJF46xeov3+X7DXt5qlsAMRYnPli8Se2YQqguOTmZgQMHsnLlSvR6PUuXLmX69Olqxyokvyi1fft2cnJyVE4jRPWy6sBZnuxRhwURp1n95bsc3/A1x2IzWbA/jkfHjsXJyUntiKIKUrUoFRISwpo1a/jxxx9p3rw5b7/9Np988gmPPPKImrGEKDVTtpmzlrw+pJo7p6HX26mc6PbG9G2PYrVi9K3H0ahLascRQoh7otFoiNfUAODp8SOJi4tjfP+2/LAlkjqeDhzOqc2C1dtVTimEeqKjo+nWrRs7d+7ExcWFTZs2MWbMGLVjFdG2bVvc3d1JSUnh4MGDascRotpYumkv/rXr8Z9d0XSu68K12Bh+W/c93k46jsZZWLZV9kdRPlRvpxsaGsrRo0fJysri5MmTTJ48We1IQpTa/OVbcXD3JTvtBtPD+qkd546CA/3Ijsu7hG/59r/UDSOEEGXg+OUEAHSZCRgMBpydnZlyfwjrw3ei1dmxM8mTZb/uUzmlEBXvxIkTdOrUiWPHjuHn58euXbvo08c2W3PrdDp69+4NSL9SQlSU9Mws1pzOYsPxRE7/9RsdmwRiMBjw9fHBMy1v0IG1p0yYss0qJxVVkepFKSGqipzcXP5I0ANQyxqLi5NR5UR3V9c574PlTJKichIhhLg3CYkpOHj4A9Cu4f9G57XT6Vgw7QEsMcfRGRz4+ZI9m/f+pVJKISrenj176Nq1K1euXKFRo0bs37+f1q1bqx3rjvr1yzuxJ0UpISrG6/9dj7FGLbJTb/DOhMIF6+dG9CQ77QYO7j7M+0n2SVH2pCglRBn59uddGL1rYzGl8+LoXmrHKZaHujYHQO9Tn5iERJXTCCFE6e3+6zQarZbs1OsEB/oVesxob2DBM4PIij2N3ujMd0ey2PPnKZWSClFx1qxZQ79+/UhKSqJjx47s2bOHoKAgtWPdVX6/Uvv27SMjI0PlNEJUbQeOnCHBuSEAHTxSCfD2LPS4i5ORWtZYAA5e15OTm1vhGUXVJkUpIcrI1rPpALinny9yMLdVHVs2xJRwGa2dnh+3/K52HCGEKLXD564BoEmPv+XjLk5GPn28O6a48xicPZi/J4EjZy5WYEIhKtYXX3zBiBEjyMrKYsiQIURERODl5aV2rGIJDg6mTp06mM1m9uzZo3YcIaosq9XKx5tOotPbkx1zkmlh/W853Yuje2ExpWP0rs23P++q4JSiqpOilBBlYPW233Hwb0iuxczzD3VSO06J+GiSATh0NV3dIEIIcQ8uJ2UDUMNw+9G6fGu488HD7TBdv4KDuw9vbzzHuSvXKiqiEBVCURRef/11nnrqKaxWK5MnT2b16tU4Olae0XY1Gk1Baym5hE+I8jN36a/YBzQm15zFS6HN0WpvXR4I8PbELf088L8T8UKUFSlKCVEGVkReBUB//RSN69ZSOU3JDGxbDwCrR13SM7NUTiOEEKWTrskbprq+r+sdpwsK8GHWkIZkJcdhrFGLV5f/xbXrSRURUYhyZ7FYmDRpEnPmzAFg1qxZfPXVV9jZ2e5owLeTX5QKDw9XOYkQVVN03A3+SHUHwDfzLCHN6t9x+mkPdSLXYsbBvyGrIn6rgISiupCilBD3aNfBE+gDmqFYrUzp31LtOCU2qGtrslOvozc6s3yrfMAIISofiyUHvWcAAB2aBt11+mb1azO9hx/ZaYkYfery3Ld7SE6VM7+icsvIyGDo0KF8++23aLVaFixYwMyZM9FoNGpHK5X8EfgOHz5MfPytL8sVQpTe699vw97FE9P1K7wzKfSu0zeuWwv99bz+GFf+EV3e8UQ1IkUpIe7Rf7ceByD32gk6t26kcpqSs9PpcMqMAWDPafnSJ4SofH47dhY7g5GcbBMhzYKL9ZyOLRvyeBtHLJlpOPg35Ikvwsk0ZZdzUiHKR0JCAr169WLjxo0YjUbWrl3L5MmT1Y51T3x8fGjVqhUA27ZtUzmNEFXL6m2/k+ufdzJ9RDMnHI32xXrelP4tUaxW9AHN2PHH8fKMKKoRKUoJcQ+ORl3C6tMEgDEdg9QNcw+6NvIBIMMxQEbUEEJUOr+fvAiAJSkavb74lyn179SKEfVzyTGbMAQ0Zcr8dVgst++TSghbdP78eTp37kxkZCSenp5EREQwZMgQtWOVCelXSoiyZ8o28+NfyQBoYo8wun/x+8Pt3LoRuddOAPBtxInyiCeqISlKCXEPPv3ld7R2erJiTzOkRzu145TaqL4dsJjSsXf1YtOev9SOI4QQJXI2Lg0AFzJL/NzhfTrQ1zuF3BwL2oAWTP1kDVartawjClEuDh48SKdOnTh79ix16tRh7969dOpUuQZcuZN+/foBef1KKYqichohqoaZ/12P0bsO5vRkZj/ao8TPH92hDgBWnyYcjbpU1vFENSRFKSFK6cq166S75nUIOLCxm8pp7o2zowPapAsAbD50XuU0QghRMolmPQC1PYp3+cHfTXygB+3to1GsVnL8WvLsvFVlGU+IcrFlyxZ69uxJfHw8rVq1Yt++fTRu3FjtWGWqa9euGAwGLl++zLlz59SOI0Sld/j0Ra7a5w1y1MrxOkEBPiWex4M925MVexqtnZ5Pf/m9rCOKakiKUkKU0kcrdmLn4Igp/iITQrupHeeetamZN3JVvOKubhAhhCghxTnvS3Wrev6lnscLDw+gQc5ZANK8WvLK56vLJJsQ5WHx4sUMHjyY9PR0evfuzc6dOwkICFA7VplzcnKic+fOgFzCJ8S9slqtvLv2T+zsjWTFnuaVsYNKPa/8E/LprvW5cu16WUUU1ZQUpYQoheTUdGLtagLQ0U9Bq638u9LDAzpgzbFg9K7NgSNn1I4jhBDFcvZyLPauNVCsVrq1vbfBJt58fAg+qXkdt8a6NOPtb9eVRUQhyoyiKLz//vuMHTuWnJwcwsLC2LhxI25ulbvF9p1Iv1JClI3PV0ZgCGhKbo6F5/o1vKffLxNCu2GKv4idgyNzl+8sw5SiOqr8v6SFUMHcZREYnD3ISozlmZF91I5TJgK8PbHE5zWNX7PnmMpphBCiePYcjgIgKykGL3fXe57fh08PwynhCACndcHM/2nLPc9TiLJgtVqZNm0ar7zyCgDTp09nyZIl2NuX7rLVyiK/KLVt2zZyZTAWIUolITGFXfFGADxTTtG1zb1d6qvVaungm9f/4jV9TZJT0+85o6i+pCglRAllmy2cznIHoJExBXuDXt1AZaihR96/F9KrzmsSQlRtxy/nXTZgyE4qs3n+Z9pwdLFH0Gp1/JYZwHfrdpXZvIUojaysLMLCwpg/fz4Ac+fOZe7cuVWipfbdtGvXDjc3N5KSkjh06JDacYSolF77dgsObt6YEmN4Z1LpL9u72bOj+pKVdA2Dswdzl0WUyTxF9VT1P8mEKGOfrYjAwcMPc3oSL4ZVjVZS+Ub1ag2AvW99zl25pm4YIYQohtj0vDO1vo6aMpunVqtlwQsPkRtzFJ2dni1xrqzZFllm8xeiJJKTkxk4cCArVqxAr9ezdOlSpk+frnasCmNnZ0evXr0AuYRPiNLYvPcvTN7NAAgNtsPN2alM5mtv0NPIIRmA01nuZJstZTJfUf1IUUqIErBarRy4lvfDx88Sjburs8qJylaLBnUwxZ1Ho9WybOsfascRQoi7ytbn9aXTNLBGmc5Xr7fj6+eGYI45iZ29kZ+iIOK3o2W6DCHuJjo6mm7durFz505cXFzYtGkTY8aMUTtWhZN+pYQoHYslh2/2x6LV6rDGHGV8GQ/O9GJYH8zpSTh4+PHpctk/RelIUUqIEvhu/W6MPkHkZGXy4qgeascpFzUNmQAcizernEQIIe4sJT0D+xp5g050bVW/zOfvaLTn8yf6YLoWhcHRlQUH0/j9aFSZL0eIWzlx4gSdOnXi2LFj+Pn5sWvXLvr0qVottIsrvyi1Z88eMjMzVU4jROUx+9v1GH3rYclMY2ZY5zKfv7urM36WaAB+i9NitVrLfBmi6pOilBAlsPlUCgDOqWcJ9PNSOU35eKBj3uhVWq9gElPSVE4jhBC3t/vQKbRaHeb0JBrWCSiXZXi6ufDJuE6Y4i9i71KDD7fHcOL8lXJZlhD59uzZQ9euXbly5QqNGjVi//79tG7dWu1YqmnYsCGBgYGYzWb27t2rdhwhKoUT569wThMIQENtDA3K6XPyxVE9yMnKxOgTxHfrd5fLMkTVJkUpIYpp3c6DOPg3wppj4dkH7lM7Trnp2b4pWYmx6AwO/LjlN7XjCCHEbf15NgYAJTWuXDt8rulbg3dHtsR0IwYHDz9mrj3F5diEclueqN7WrFlDv379SEpKomPHjuzZs4egoCC1Y6lKo9HIJXxClNCcFb+jNzpjunaWNyYOLrflBPp54Zx6FvjfCXwhSkKKUkIU048HLgKgjT9JiwZ11A1TjrRaLe45eT+2fjtfdqNZCSFEWbt4IwsAD335X25cv7Y/rw0MIislAaN3bV5cHElConz5FmXriy++YMSIEWRlZREaGkpERAReXlWzZXZJSVFKiOL779od6AKaY83NYUq3QOx0unJd3rMP3Ic1x4KDfyN+3iH90oqSkaKUEMWw76/T6PyaAjCpbzOV05S/3s3z+mgxu9WRkTSEEDYrTTECUM+7YgadaNO4Ls908sScnozRL5inv95BWoapQpYtqjZFUXj99dd56qmnsFqtTJo0iTVr1uDo6Kh2NJuR35/Wn3/+yfXr11VOI4TtSk5NZ8vlvIGZnG6coF/HluW+zBYN6qCNPwnAT79dKvfliapFilJCFMOCLUfQaLVYYo7TvV1TteOUu4d6hWBOT8bg5Maa7TIMuhDC9uTk5qJz9wcgpHFghS23e7umPNrMDktWBg4BjZny2SYp3ot7YrFYmDRpEnPmzAFg1qxZLFiwADs7O5WT2RZfX19atGiBoihs27ZN7ThC2KzX/rsJBw8/spLjmfP4gApbbv6Je51fU/b9dbrClisqPylKCXEXpy5cxeLVGICRIbVUTlMx7A16DKmXAdh2NFrlNEIIUdSfpy6gNzqTa8mmY8uGFbrs0O7tGFLLRK4lG31AMyZ/vJac3NwKzSCqhoyMDIYOHcq3336LVqtlwYIFzJw5E41Go3Y0mySX8AlxZ9sjj5Hq0QSA3gFmvNxdK2zZ3ds1xRJzHI1Wy4ItRypsuaLyk6KUEHcxb81+dHoDWbFnGNa76nZw/ncd63kAkKz3luFdhRA258CxCwCYE2Mw2hsqfPkPD+pCV9cErLk5ENCSJz9eLcdKUSIJCQn07t2bjRs3YjQaWbt2LZMnT1Y7lk2TopQQt5eTm8vnOy6itdNjiTnOE8P7VHiG/BP4Fu8mMlKtKDYpSglxBzEJiSQ71wOgb/2K6bPEVoT170CuOQsHT3+2Rx5XO44QQhRyJjavk3FHa5pqGZ4c0Yfm2ry+M7J9WzL9s9WqZRGVy/nz5+nSpQu///47np6eREREMGTIELVj2bzu3buj1+u5cOEC58+fVzuOEDblX99vxOjXAEtWBq8Na6dKhmG97yMr9gw6Oz3z1x5QJYOofKQoJcQdzP1pe95QqgmXmPhgd7XjVChPNxes188BsO63MyqnEUKIwq5n532FCXTTq5rj1XH3E5iZ17lrokcLXv9qrap5hO07ePAgnTp1Iioqijp16rB37146deqkdqxKwdnZuWBdSWspIf7n3JVrnDD7ARCUc0nVkcLzT+SnONcjJiFRtRyi8pCilBC3kZZh4qo2rxPd9t455T6Uqi1q7pN3SUy02UnlJEIIUViuozcALer6qpwE5kwdikfiUQAuOzbh/UWbVE4kbNWWLVvo2bMn8fHxtGrVin379tG4cWO1Y1UqcgmfEEXNXrobg5MrpvgLzHo8VNUsEx/sjinhMnqjM3N/2q5qFlE5SFFKiNv4aFk49i41yEqO47lRfdWOo4qH+4dgteZi9K3L0SgZ3lUIYRuuXLuOg7sPAD3a2sYP+o+fHYZ9XF7Hrkdya/PlqgiVEwlbs3jxYgYPHkx6ejq9e/dm586dBAQEqB2r0skvSkVEREg/bkIASzbtgYCWKFYr49p7Y29QtwWxnU5He++8UWmvav1JSc9QNY+wfVKUEuIWLJYcjqW7AFBfn6hKJ7q2oG5NX8xxeZfwLd/+l7phhBDi/+3+M2+o6azEWPy8PFROk0er1fLFC8Mg5ghanR27U7z5cfM+tWMJG6AoCu+//z5jx44lJyeHsLAwNm7ciJubm9rRKqWQkBBcXFxITEzkzz//VDuOEKpKz8xi7elsAAzxxxjSQ52+pP7uuVF9yUqOw96lBh8vk5M04s6kKCXELfxnZQRGzwDMGSm8NKbiR66wJXWd8850nElSOYgQQvy/oxfjAdBl2VZfFXY6HV+/MBRLzHF0ent+ueLAht2H1I4lVGS1Wpk2bRqvvPIKANOnT2fJkiXY29urnKzysrOzo1evXoBcwifEP79ej7FGLbJTrzPnMdu5ssNob6C+Pu8z+niGCxZLjsqJhC2TopQQf2O1WtkbrQDgk30ZTzcXlROp66GuzQHQ+wRLZ4VCCJsQnZr35dbHwfYu3bE36FnwzCCyYk+jd3Bi0TELuw+dVDuWUEFWVhZhYWHMnz8fgLlz5zJ37ly0Wvn6fa+kXykhYP/h01x3aQRAJ890m2k5nO+lMX0wZ6Rg9AzgPyultZS4PflUFOJvFm/ai9G3LjlmE9NHVq8R926lY8uGmBIuo7XTs/TX39SOI4QQmOxcAWhc07a+gOdzcTLyn0k9MMWdw+Dszqf7bvDnqQtqxxIVKDk5mYEDB7JixQr0ej1Lly5l+vTpaseqMvKLUrt378ZkMqmcRoiKZ7Va+XjzKXR6A+aYkzw3up/akYrwdHPBJ/syAHujFekDTtyWFKWE+JsNx/JaAzkmRREU4KNyGtvgo0kG4M9o6ahQCKGuTFM2Bs+aAHRuEaxymtvz9nRj7iMhmBIu4+Dmzb82X+Ts5Vi1Y4kKEB0dTffu3dm5cycuLi5s2rSJMWPGqB2rSmncuDEBAQFkZ2ezb5/03Saqnw+X/IpDQGNyzVm8NKSFzbbAnD6yOzlmE0bfuizetFftOMJG2ebWK4RKNu75E/uAxlhzc3g6tL3acWzGwLb1ALB61iM9M0vlNEKI6mzPX6fQ2ekxZ6bSokFttePcUW1/b2YPbUxW0jWMNQKYseKIXAZdxZ08eZJOnTpx9OhR/Pz82LVrF336VO++KcuDRqORS/hEtXXl2nUOpuW1FPYznaV9U9s9QRMU4INjUhTwvxP/QvydFKWEuMmSvecB0MSdpE3juiqnsR2DurYmK+U6egcnlm+VS/iEEOo5dOYqANaUWJs9M3yzpvUCealXANlpNzD6BDFt4T6SU9PVjiXKwZ49e+jSpQtXrlyhUaNG7N+/n9atW6sdq8rq1y/vciUpSonq5s0ftmPv4oEp4TJvPx6qdpy7ejq0PdbcHOwDGrNxj4yYKYqy/W9zQlSQ349GofFrAsBjvRqrnMa22Ol0OJtiANhzOl7lNEKI6ux8QiYAbtpslZMU330tGjClnQvmzFQc/BvwxBdbyTRVnvzi7tasWUO/fv1ISkqiY8eO7Nmzh6CgILVjVWn5LdAOHjxIYqK0wBDVw6qI38j1bwnAyBYuOBptfyTPNo3roonLG/AjvwGAEDeTopQQ/+/LzX+h1eowx5yg933N1Y5jc7o1yutfK8MxgJzcXJXTCCGqq2Rr3hfwul6OKicpmT4dWjCqgUJOtglDQBMmz18nQ2RXEV988QUjRowgKyuL0NBQIiIi8PLyUjtWlefv70+zZs1QFIVt27apHUeIcmfKNrPscAoAmtgjjOrXUeVExTehZ94ogRq/Jvx+NErlNMLWSFFKCCDqUgzZNfIOlg+18VM5jW0a2bcDFlM69q5ebNgtTW+FEBXParWidfUHoF3DmiqnKblhve+jn08KuTkWdAEtmPLxGhmNqBJTFIXXX3+dp556CqvVyqRJk1izZg2OjpWrYFqZSb9Sojp547/rMXrXwZyexNtje6odp0T6dGiBOeYEWq2OLzf/pXYcYWOkKCUE8Mnqvej09piunWVk3w5qx7FJzo4OaJPyhjTf8qcMbS6EqHjHzl7G4OSKNcdCl9aV8zLrxx7owX3GGBSrlVz/ljzzySq1I4lSsFgsTJo0iTlz5gAwc+ZMFixYgJ2dncrJqhcpSonq4tDJ88Q45A081NrxBrX9vVVOVHL5J/6zazQi6lKMymmELVG1KDVr1iw0Gk2hW+PGlfNLpqi8EpJSSXLOO8j3rutQKTrOVUvbWs4AxOOhchIhRHW07+g5ALKTYnB2dFA5Tek9H9afBrlnAUj3bslL/1mtciJREhkZGQwdOpRvv/0WrVbLggULCr7TiorVo0cPdDod586d48IFOWEmqiar1cr7vxzGzmAkK/Y0L48dpHakUhnZtwOma2fR6e35ePVeteMIG6L6r+9mzZoRGxtbcNuzZ4/akUQ1kZGRgdlsZuvJG9g5OOOmszDloZ5qx7JpjwzoQG6OBaNXIPsPn1Y7jhCimjkVnQyA0ZKibpAy8ObEIfilHmdwM098GoWwbM9pzGYz8fHxmM1mMjIy1I4obiEhIYHevXuzceNGjEYja9euZfLkyWrHqrZcXFzo2DGvX52IiAiV0whRPj5bsRVDQFNycyw8169hpT2BrtVq6RWU1y9kkmNd4m4kqxtI2AzVt2g7Ozv8/PwKbtIxpKgIiqKwatUq/GvWYtUfecOLN9NXjuHF1eTn5UFOfN7Z/TV7jqucRghR3cSb8v4NcK0al0i9//QwUmLP81S3AC6bjLQe+DC+vr74+vqyatUqFEVRO6K4yfnz5+nSpQu///47np6eREREMGTIELVjVXtyCZ+oyuJuJLMnwQkAz5RTdG1Tua8qmjKsF6brV9A7ujB3mQxQIPKo/gs8KiqKgIAA6tWrxyOPPMLly5fVjiSquIyMDBYtWkRoaCgPjHsWRw8f6jtnM6pPOxYtWiRnp++ikWfe5QkXMwwqJxFCVDcWhxoANK9T+frSuJ2HezRj4eZInupek3GvfEBAi66EhIQQGhoqn0k25NChQ3Tu3JmoqCjq1KnD3r176dSpk9qxBNCvXz8gr6WUDBwgqpp/LgzHwc0L040Y/jV5sNpx7pmdTkcbj2wALuFLemaWyomELdAoKp6G27RpE+np6TRq1IjY2Fhmz55NdHQ0x44dw8XFpcj02dnZZGdnF/ydmppKYGAgKSkpuLq6VmR0UYmZzWZ8fX25774OrFz7C7vPp9OltoGRw4cRGRlJXFwcBoMUXG7n+NnLvLffhGK1MrOXO/Vr+6sdSQhRDcTdSOYfG+MAeKuPB0EBPionKhtmsxlfP38mzl7A7ClD2XH6Bl1q2zN61Ej5TLIRW7ZsYfjw4aSnp9OqVSs2btxIQECA2rHE/7NYLHh6epKens6ff/5J69at1Y4kRJnYsPsQy84b0Wi19PWMZ9zgbmpHKhOZpmwmfBOJg5s3DSxneGOitDitqlJTU3Fzc7trvUbVllKDBg1i5MiRtGzZkgEDBrBx40aSk5NZvnz5Lad/9913cXNzK7gFBgZWcGJRFSQnJ5OcnMzJRCu7z6dzfzNP/vvf/xIeHk5ycjIpKZW/r5Ly1Kx+bUxx59FotSyLOKh2HCFENbH7z1MAZCXHV5mCFPz/Z1JSIp+8MIYN+48R2tKHPRcz+ePUZflMsgGLFy9m8ODBpKen07t3b3bu3CkFKRuj1+vp2bMnAOHh4eqGEaKMZJstfPdbPBqtFmvM0SpTkAJwNNpTV5sAwJFURyyWHJUTCbWpfvnezdzd3WnYsCFnz5695eMzZswgJSWl4HblypUKTiiqAnd3d9zd3Rn73D/pXt+N73/exmPjx9GvXz/c3d1xc3NTO6LNq2WfCcCxeIvKSYQQ1cXh83mtpLSZ11VOUrbyP5P69O5Jv5aBrNxzgl5NfHhh/kpqNmghn0kqURSF999/n7Fjx5KTk0NYWBgbN26U98NGSb9Soqp5a+EGjL51MWemMmtMF7XjlLmXwnpjzkzFWKMWX63ZrnYcoTKbKkqlp6dz7tw5/P1vfTmQvb09rq6uhW5ClJTFYuH9L75nxqiufLr9Ik+MHUlYWBjLli1j3rx5WCxSaLmbIR0aAaDzDuZ6cqrKaYQQ1cGVZDMAXva5KicpWxaLhXnz5rFs2TLCwsJ4eEBH3lt1gBcGNWHa/JVciU9WO2K1Y7VamTZtGq+88goA06dPZ8mSJdjb26ucTNxOflFq9+7dZGVJHzWicjtx/grnNXlXBDWxi62SXWV4e7rhZboEwM5LFukPrporVVHKarVy5swZ9uzZw65duwrdSuKll15i586dXLx4kX379vHQQw+h0+kYM2ZMaWIJUSxOTk48Omwwn++OYdPqn8hKSyQyMpL169czduxYnJyc1I5o83q2b4opMRad3p5lW35TO44QohrI0DoD0NC/ap2QcnJyYuzYsaxfv57IyEgsmWkseHUcX20/yxO9gllx8BoXY+LVjlltZGVlERYWxvz58wH48MMPmTt3rozOa+OaNm2Kn58fJpOJ/fv3qx1HiHvyzorf0RudMV07yz8nVP7OzW/nheFdyTVnYfQLZtmvst9WZyUeU/nAgQM8/PDDXLp0qchQxRqNhtzc4p/BvHr1KmPGjOHGjRt4e3vTtWtXDhw4gLd31RlVR9ieM5diWBuVy7HYDJa++xz2cybj5uaGxWJBo9GoHa9S0Gq1eOQkkIU/v19IVjuOEKKKyzZbMHjWBKBj07oqpyl7Go2G4cOHExYWRkpKCm5ublyKT+bTLaepF+jPP5b+wWePdcK3hrvaUau05ORkhg4dys6dO9Hr9Xz//fdyorSS0Gg09O3bl8WLF7N161Z69eqldiQhSuXrNduxC2iONTeHJ7rXxk6nUztSuQkO9MM+cTc5fi35+UgCDw9SO5FQS4lP+zzxxBO0b9+eY8eOkZiYSFJSUsEtMTGxRPNatmwZMTExZGdnc/XqVZYtW0ZwcHBJIwlRIm8t28ex2EysMceoVcMZb29vDAaDtJAqoT4tagFgdqtDtlkueRRClJ/9R86g09tjycqgbdN6ascpF05OThgMhoLPpAa1fOhWS8ua385h9K3Hs9/sIi3DpHbMKis6Opru3buzc+dOXFxc2LRpkxSkKhnpV0pUdokpaYRfyft57pJ4gj4dWqicqPw9NbgtVmsu9gFN2LL/sNpxhEpKXJSKioriX//6F02aNCnoFPrmmxC27NDJ8+DXFICx3eqrnKZyG9qzPeb0ZAxObqzeFql2HCFEFfbHqcsA5CTHVOmzxn/XtU1jxrWwx2JKx8G/EVM+24Qp26x2rCrn5MmTdOrUiaNHj+Ln58euXbvo06eP2rFECeUXpf744w+SkpJUTiNEyf3zm804ePiRlXSNOY8PVDtOhWjfNBjl2gkAftgVpXIaoZYSF6U6dOhw29HxhLB1/1l/EK1WR3bMSQZ0bq12nErN3qDHPi3vh+L2Y9EqpxFCVGXn4tMBcKX6tRS6v2sbHqyTTa4lG31AM6Z+8jM5JegqQdzZ3r176dKlC1euXKFRo0bs37+f1q1bqx1LlELNmjVp0qQJVquVHTt2qB1HiBLZ9vsx0jyaANC3lhVPNxeVE1WccfkNBfya8seJc+qGEaooVlHqyJEjBbdnn32WF198ke+++46DBw8WeuzIkSPlnVeIUjt35RpZng0BeKCll8ppqoYOdT0ASDb4yKgZQohyk2jRA1DH00HlJOoIG9CZ7u7XsebmQEBLnvh4tRxzy8DatWvp27cvSUlJdOzYkT179hAUFKR2LHEP5BI+URnl5Obyxc5LaO305MQcY8qw6tUn2oDOrcmOOYlWq+OLDYfUjiNUUKyiVOvWrWnTpg2tW7dm+PDhnDx5kokTJxISElLosTZt2pR3XiFK7ZNVe9AZHDDFnWPMgM5qx6kSHh7QkRyzCQcPP7ZHHlc7jhCiCrJareDiB0Cb+gEqp1HP1GG9aanLa51q9m3JtE9Xq5yocvvyyy8ZPnw4WVlZhIaGEhERgZeXnLCq7PKLUuHh4SonEaL4/vXdRox+9bFkZfDP4SFqx1FFfoOBLM+GnLtyTeU0oqIVqyh14cIFzp8/z4ULF255y3/s/Pnz5Z1XiFK5npxKgkMdALoH6mVo5zLi7uqMcj1vv1/322mV0wghqqKoy7HYu3hgtebSrU0jteOo6uWxg6hjOgVAsmcLXvtyrbqBKiFFUXj99dd58sknsVqtTJo0iTVr1uDo6Kh2NFEGevTogU6nIyoqikuXLqkdR4i7Ons5lhM5eSde6uZepln92ionUseYAZ0xxZ1HZ3Dgk1V71I4jKlixfpnXqVOn4Hbp0iVq1qxZ6L46depQs2ZNOfgLmzX3xwgMTq6YbkTzRDVrElveWvjaAxBtdlY5iRCiKtpzOK/j0+zEGNxd5Tjz9pQH8Uw6BsBVpyb8+/sNKieqPCwWC5MmTWLOnDkAzJw5kwULFmBnZ6dyMlFW3NzcuO+++wCIiIhQOY0Qdzf7x70YHF0xxV1g5sTBasdRjVarpVtg3kAmCQ51uJ6cqnIiUZFK3FykV69eJCYmFrk/JSWFXr3kx76wPZmmbM7l5DUJbeGagV4vXz7L0ph+7bFaczH61uXImYtqxxFCVDEnr+R957A3J6sbxIZ89MxDOMTn9eN5TAni8xXSf87dZGRkMHToUL799lu0Wi1fffUVs2bNQqPRqB1NlDHpV0pUFj9s2I0moAWK1cr4+7yxN+jVjqSqJ4f1xnQjGoOTK3N/lKJydVLiopSiKLf8AL9x4wZOTk5lEkqIsjRv+VYc3H3ITr3BC6P7qh2nyqlb0xdzXN5IGSt2HFY5jRCiqonNyOvQ289ZLrvOp9Vq+XzaMDSxR9Dq7Nib5suSTXK5w+0kJCTQu3dvNm7ciNFoZM2aNUyZMkXtWKKc3FyUkgEBhK1KyzCxLsoCgH3CMUK7t1M5kfr0ejtauGYAcC7Xm0xTtsqJREUpdpORYcOGAaDRaJgwYQL29vYFj+Xm5nLkyBE6d5bOo4VtycnN5VCiPUYvqM01XJyMakeqkuo65xALnElSO4kQoqoxGzwwAk0Da6gdxabY6XQsmDaUxz7+BbuA5qy/6ojrzoMM6SE/bG52/vx5Bg4cSFRUFJ6enqxfv55OnTqpHUuUo44dO+Lk5ERCQgLHjh2jZcuWakcSooh//ncDxhotyE69zvsT5KR5vhdG92XSd3/i4ObNvOVbmTG++l7SWJ0U+7Sjm5sbbm5uKIqCi4tLwd9ubm74+fkxZcoUFi9eXJ5ZhSix/67dgdErEIspnRdHy+Wl5WV4t+YA6H2CiY67oXIaIURVkZiShoNn3oh73Vo1UDmN7bE36PnqmfvJjjmF3sGJJSdz2XXwhNqxbMahQ4fo3LkzUVFR1KlTh71790pBqhowGAz06NEDkEv4hG3a99dpbrjkDdzRuUYGfl4eKieyHS5ORgLJG33vUKI9Obm5KicSFaHYLaUWLlwIQFBQEC+99JJcqicqhYjzJox+4JF+Hj8vOXtcXu5r0QBTeDhG79osDf+dfzw6SO1IQogqYPefp9FoXchOu0GDOtV75L3bcXEy8tnknjz1zV6MfsF8tv86zo7nadukntrRVBUeHs6wYcNIT0+nVatWbNy4kYCAALVjiQrSt29fNm7cyNatW5k+fbracYQoYLVa+WTLaRz8G2GOOcGz/3hQ7Ug256XRvXhh9XmMXoH8d+0OnhjeR+1IopyVuIOGmTNn4uTkRHx8PLt372b37t3Ex8eXRzYh7snKrQcw+jUg12Lm+WFyaWl589WmAPBXdKbKSYQQVcVf52Ly/pMm3zPuxNvTjbmPhmBKuIyDmxfvbrlE1KUYtWOpZvHixdx///2kp6fTu3dvdu7cKQWpaia/X6mdO3eSnS390gjb8f7izTj4NyLHbOLlB1qh1Up/iX/n5+WBR/p5ACLOZ0nfcNVAifeCtLQ0xo4dS82aNenRowc9evSgZs2aPProo6SkpJRHRiFKZeXBWAAM10/RKKimymmqvoFt6wJg9axLemaWymmEEFXBpcS8H5OeeovKSWxfbX9v3n6oCVmJsRg9A3ht5dFqdzm1oih88MEHjB07lpycHMLCwti4cSNubm5qRxMVrHnz5vj4+JCZmcmBAwfUjiMEAJdjE/grwxOAAJO0aL2T54d1JtdixuhXn5URv6sdR5SzEhelJk2axG+//cb69etJTk4mOTmZ9evX88cffzB16tTyyChEiW2PPIYhoCmK1crUga3UjlMtDOzSmqyU6+gdnPgpXL4ACiHuXRqOANT3dVE5SeXQuG4t/tG3FtmpNzD6BDHthwMkpqSpHatCWK1WXnjhBV5++WUApk+fzpIlSwoNzCOqD41GU2gUPiFswZuLdmBw9sCUcJm3J4eqHcemNQqqieH6KQBWH4pVOY0obyUuSq1fv55vv/2WAQMG4OrqiqurKwMGDODrr79m3bp15ZFRiBJbuO0kANZrJ+jYsqHKaaoHO50OZ1Pe5SJ7TieonEYIUdlZLDno3fMuubqvSR2V01QeIc3qMzXEFXNGKka/+jz5ZUSVb72alZVFWFgY8+bNA+DDDz9k7ty5cllMNSdFKWFLVm49gNU/byTIsFauGO0NKieyfVMGtESxWjEENGV75DG144hyVOJP6xo1atyyGbSbmxseHjJygFDfkTMXsfo0AeDhznVVTlO9dGvkA0CmU00ZLUMIcU/+OHEOOwdHcs1Z3Ne8vtpxKpXe9zUnrBHkZJuwD2jClPnrsVhy1I5VLpKTkxk4cCArVqxAr9ezZMkSXnzxRbVjCRvQp09e58i///67dDEiVJVpyuanI3mtVrWxRxjep4PKiSqHTq0aYb2WN6JsfoMDUTWVuCj1+uuvM336dK5du1Zw37Vr1/jHP/7BG2+8UabhhCiNT3+JRGunJyvmFIO7tVU7TrUyul9HLKZ07F1rsGH3n2rHEUJUYr+fvASAOSkae4Ne5TSVz9BeIQzwSyM3x4JdzRZM/nhNlessNjo6mu7du7Nz505cXFzYtGkTDz/8sNqxhI2oXbs2DRs2xGq1smPHDrXjiGrszW82YPSuTXZaEm+P66V2nEolv4GB1bcph09fVDeMKDclLkp98cUXHDhwgNq1a1O/fn3q169P7dq12bdvH1999RVt27YtuAlR0S7HJpDh3gCA+5tKy72K5mi0R5t0AYBf/7ygchohRGV2JjavZYOzNUPlJJXX+NBudHSMxWrNxerfkqc/WVVlClMnT56kU6dOHD16FD8/P3bt2lXQMkaIfHIJn1DboZPniTHmdWje1iWRQD8vlRNVLoO7tSUr5hRanR2frYtUO44oJ3YlfcLQoUPLIYYQZWPu8p3YebbAFHeBcY/0VztOtdQu0Jm/ciEBKQoKIUrvhtkOA1DLXfrduBfPju5H6sL1nNY2IMO7JS9/vpYPnxmmdqx7snfvXoYMGUJSUhKNGjVi8+bNBAUFqR1L2KB+/frx+eefS1FKqMJqtfL+L4cxBDQlK+YU//jHELUjVUr3N/VgWzJkuDfgcmwCtf291Y4kyphGURRF7RCllZqaipubGykpKbi6uqodR6gsMSWNp5aewODsThvdRV54eIDakaqla9eTeHFdNDo7PU+2zLseXAghSmrUZ3twcPPmwYBk6X+jDLzy+RpiXZoCUC/7NLMmPaByotJZu3YtY8aMISsri44dO7Ju3Tq8vKTlgbi15ORkatSogdVq5cqVK9SqVUvtSKIambdsCwctdci1mHm6rYHOreU7cWlYrVZGf7QFo29dPBKPMu/5EWpHEsVU3HpNqYYlSU5O5r///S8zZswgMTERgEOHDhEdHV26tEKUgY+WRWBwdseUGMtTI3qrHafa8vPyICf+LABr9hxXOY0QojK6EB2Hg1vemdDubRqrnKZqeO+ph3C9cRSAc/oGfLR0s8qJSu7LL79k+PDhZGVlERoaSkREhBSkxB25u7sTEhICyCV8omJdu57EvhtOANRIOy0FqXug1WrpHKABIM4QSGJKmsqJRFkrcVHqyJEjNGzYkPfee48PP/yQ5ORkAFavXs2MGTPKOp8QxWLKNnPG7AlAU8dU6RRXZY088z44LmTKZTdCiJLb/dcZAEyJMXh7Fh3xV5TO/OeGob92BI1Wy6HsWvx37Q61IxWLoii88cYbPPnkk1itViZNmsSaNWtwdHRUO5qoBKRfKaGG17/bir2rF6Yb0cyZNFjtOJXeUyN6Y0qMxeDsztxlEWrHEWWsxEWp6dOnM2HCBKKionBwcCi4//7772fXrl1lGk6I4vp0eQQO7r5kpyUyfYx0dKq20b3aAODgE8zZy7EqpxFCVDbHL10HQJ+VqHKSqkWr1fLV9GFYY46itdOz7YY7y8MPqB3rjiwWC5MmTeKdd94BYObMmSxYsAA7uxJ3iyqqqZuLUpW41xJRiazfdZBs7+YADGmgx8XJqHKiys/eoKepYyoAUWZPTNlmlROJslTiolRkZCRTp04tcn/NmjW5du1amYQSoiSsViuRCToAaubG4ObspHIi0ax+bUxx59Fotfy49Q+14wghKpmYtFwAfKUhTJmz0+n4etoDmGNOYGcwsuaCnl/3/aV2rFvKyMhg6NChfPvtt3kFta++YtasWWg0GrWjiUqkU6dOGI1G4uLiOH5cuhUQ5SvbbOH73xPQaLUoMUcZN7ib2pGqjOlj+pCdloiDuy+fLpfWUlVJiYtS9vb2pKamFrn/zJkzeHtLT/ii4n37yy6M3nWwZGXw4qieascR/y/QPhOA4wk5KicRQlQ2Wfq8zjAb15RRPMuD0d7Al0/2Iyv2DHqjM9/+lcX+w6fVjlVIQkICvXv3ZuPGjTg4OLBmzRqmTJmidixRCdnb29O9e3dALuET5W/2txsw+tbFnJnKzDFd1I5Tpbg5O1EzNwaAyAQdVqtV5USirJS4KPXAAw/w1ltvYbFYANBoNFy+fJlXXnmF4cOHl3lAIe5my5m8zu5cU89R07eGymlEviEd8zp01HkHcz25aCFbCCFuJS3DhL1HAACdWwSrnKbqcnd1Zv7ErpjiLmDv4sHHu+I4GnVJ7VgAnD9/ni5duvD777/j6elJREQEDzxQOUcLFLZB+pUSFeH42ctc0NUGoKndNerX9lc5UdXz4qieWLIyMHrX4dtfpOugqqLERam5c+eSnp6Oj48PJpOJHj16UL9+fVxcXJgzZ055ZBTittZsi8TBvyG5ORaef6ij2nHETXq0a4opMQad3p5lW35TO44QopLY+9dptHZ6zBkpNAsOVDtOlebn5cG/R7fGdOMqDu6+vLU+igvRcapmOnToEJ07dyYqKoo6deqwd+9eOnfurGomUfn169cPgB07dhScWBeirM1ZFYnewQnTtShem3C/2nGqpJq+NXBNPQf8r2GCqPxKXJRyc3MjPDycdevWMX/+fJ555hk2btzIzp07cXKSvnxExVoeeQUAu4STNK0nP15siVarxTMnr7Pi3y8kqxtGCFFpHDxzFQBr6jW02hJ/TRElFBzoxxv3B5OVHI/RK5CXfzxE3I1kVbKEh4fTo0cP4uLiaNWqFfv27aNx48aqZBFVS4sWLfD29iYjI4MDB2y7c39ROX21eht2Ac2x5lh4skcQdjqd2pGqrOcf6khujgUH/4as2RapdhxRBkr9ba9r16489dRTvPzyywVNYoWoSLsPnUQf0AzFamVyvxZqxxG30KdlXqHQ7BZEtlnOTAoh7u7iDRMA7rpslZNUHy0bBjGtmw/ZaUkYfevx7De7SEnPqNAMixcv5v777yc9PZ3evXuzc+dOAgICKjSDqLq0Wi19+uSNziyX8ImylpiSRkR03oigLkkn6X1fc5UTVW1N6wVil3AS+F8DBVG5lagoZbVa+fbbbwkNDaV58+a0aNGCBx54gB9++EGGWBUV7r9bjwGQc+0kXdvImVRb9FDP9pjTkzA4ubIq4ne14wghKoEUqwMA9byl9XVF6ty6EY+1csBiSsfBvxFTP/u1QobcVhSFDz74gLFjx5KTk0NYWBgbN27Ezc2t3JctqhfpV0qUl9e+2YyDuy9ZSdeY8/hAteNUC5P65hX+9AHN2H3opMppxL0qdlFKURQeeOABJk2aRHR0NC1atKBZs2ZcunSJCRMm8NBDD5VnTiEKOX72MjneTQAYfZ9ctmer9Ho77NPyzmBsPx6jchohhK2zWq3o3PI6hg1pJMf2ijawS2uGBpnJNWdhqNmMKZ/8TE5ubrktz2q18sILL/Dyyy8DMH36dJYsWYK9vX25LVNUX/lFqd9+++2WI4kLURrhB46Q7tkUgH6BVjzdXFROVD10a9sES8xx4H8NFUTlVeyi1HfffceuXbuIiIjgzz//5Mcff2TZsmUcPnyYrVu3sm3bNn744YfyzCpEgfk//4bOTk9W7BmG9gpRO464g471PAFIMfjI0K1CiDs6fOYSekcXcnMsdGrZUO041dLo/p3o6ZmINceCJqAlUz9aVS7H7uzsbMaMGcO8efMA+PDDD5k7d670IybKTZ06dahfvz65ubns3LlT7TiiCsjJzWXB7itodXbkxBxj8kO91I5UreQ3TMjxbsLxs5dVTiPuRbE/+X/88Udee+01evUqurP17t2bV199lSVLlpRpOCFuJTruBqmuecOED2gkZyNs3Zj+Hcgxm3Dw8CPidzmTIYS4vf1H80bUMSdexdEorWXUMvmhXrQxXEWxWrH4teL5+avLdP7JyckMHDiQ5cuXo9frWbJkCS+++GKZLkOIW5FL+ERZmvPdBox+9bGY0nl95H1qx6l2hvYKISv2DDo7PfN/lpG+K7NiF6WOHDnCwIG3v0Z20KBBHD58uExCCXEnc5fvyBtuNf4ijw3prnYccRfurs4o188DsP63MyqnEULYslMxyQA45sowz2p78ZGB1DNHAZBSowUzvlhTJvONjo6me/fu7NixAxcXFzZt2sTDDz9cJvMW4m6kKCXKytnLsZzMybvcvJ5yRUYBV0n/hnkNFFJdg4mOu6FyGlFaxS5KJSYm4uvre9vHfX19SUpKKpNQQtxOSnoG0bqaANzna5Vm/pVEC9+8Fg8xFmeVkwghbFlCVt4xvaarXuUkAmD25AfwSs5r4Rrt3JR/fbf+nuZ38uRJOnXqxNGjR/Hz82PXrl0FI6IJURF69eqFRqPhxIkTxMRIX5ei9Gb9uBeDoyumuPPMmhiqdpxqa+ID3TElXELv4MTc5TvUjiNKqdi/6HNzc7Gzs7vt4zqdjpycnDIJJcTtzP1xK/YuHmQlXeO5UX3VjiOKaUy/9lituRh963LkzEW14wghbFSusQYALYJ8VE4i8n349EMY448AcEJTj/+sKF0Lk71799KlSxeuXLlCw4YN2bdvH61bty7DpELcnaenJ+3btwektZQove/X70Yb0AKrNZfHOvqh19/+N7IoX1qtlvt88gbkiNbVJCU9Q+VEojRKNPrehAkTGDZs2C1vEydOLM+cQpBttnAqM2+I6Ib2Sdgb5Ex6ZVG3pi/muLy+YpZv/0vdMEIImxSTkIiDhx8A3ds0UjmNyKfVavniheFoY4+g1erYl+bLog27SzSPtWvX0rdvX5KSkujYsSN79+6lbt265ZRYiDuTS/jEvUjLMLH+bF5DDGPCce7v2kblROK5UX3JSrqGvYsHc3+U/boyKnZRavz48fj4+ODm5nbLm4+PD+PGjSvPrKKa+8/KCBw8/TGnJ/HSGGklVdnUc8n7AI9K1qicRAhhi3YdOgVAVnIcNX1rqJxG3Eyr1fL1Cw+RE3MMnd7Aphhnft7xR7Ge++WXXzJ8+HCysrIIDQ0lIiICLy+vck4sxO3dXJRSFEXlNKKyee3rDRhrBJCVcp13HuundhwB2Bv0NLTP60boVKYb2WaLyolESRW7reHChQvLM4cQd2S1WtkfC0Yf8LNcxd21o9qRRAkN796CTw/lovetT3TcDfnRKYQo5OjFeHCsgS7zutpRxC3o9XYseHYwj3+6GfuAJvx4KhVXp2P0Cml+y+kVReHNN9/knXfeAWDSpEl88cUXd+wKQoiK0LlzZxwcHIiNjeXkyZM0bdpU7Uiiktjz5ykS3RqjA7p5Z+Jbw13tSOL/TQ/rw1NLT+Dg6c9/VkYw/eHbD9AmbI/0Ei0qhR827MHoU5ecbBPTR/ZQO44ohZBm9TElXEKrs2PF9j/VjiOEsDFXU/LObHo7WFVOIm7H2dGB/0ztjenaWQxOrnz5ewp/nDhXZLqcnBwmTZpUUJCaOXMmCxYskIKUsAkODg5069YNkEv4RPFZrVbmh59BZ6fHHHOCp0fKIA22xNPNBT/LFQD2x+a9X6LysJmi1L///W80Gg3Tpk1TO4oqMjIyMJvNxMfHYzabyciQTtputvFkMgBOyVHU9vdWN4wotf6N3PP+49Ow0m3rso+qQ9Z79ZGpzRvWuaG/m8pJxJ14ubvy0dgOmBIuMaxTQ8LPmbgYe73QfnrgwAEAXnnlFb766itmzZqFRiOXbgvbIf1KiZJ6f9EmHPwbkWM28cqDrWUEcBs0fWQPcrJNGH3q8v36kvV9KNRlE3tTZGQkX331FS1btlQ7iioURWHVqlX4+voW3FatWiXXuf+/9bsO4uDfCGuOhWcfCFE7jrgHEwe1p7m/I7+fu45/rcBKs63LPqoOWe/VhynbjMGzJgAdm9dTOY24m0A/L94Z1ozz0XE8278Jq/9KoFbdBgX76dmzZ/n6668JCwtjypQpascVooj8otSOHTuwWKT/GXFnl2MT+Cszr9uJgKzztGksAzXYotr+3jglRwGw6VSKymlESahelEpPT+eRRx7h66+/xsPDQ+04FS4jI4NFixYRGhpKr/sfAiAkJITQ0FAWLVokrQKApfsvAqCNP0nLhkGqZhGll5GRweLFi3myqx+t63rj16RjpdjWb95HQ0LyiqKVIXdlJ+u9etl/+Aw6vQGLKZ3WjYLUjiOKoVFQTYa18ubLHReY0rshk9/9Hjt7R0JCQnjggQdYvHgxDRo0UDumELfUunVratSoQVpaGpGRkWrHETbujUU7MDh7YEq4xNuTQtWOI+7g2QdCsOZYcPBvxPpdB9WOI4pJ9Yv7n376aQYPHkzfvn0L+h64nezsbLKzswv+Tk1NLe945U6v1/P888+z9dBZfvh2AatGPcKQbm0ICwsjMjKSsLAwtSOqav/h0+j88jqgnNhHOqKszPR6PdOef56DcQr/eu5Rmi1ZTY8Gbny28yrHrO3YtuYqOTk5ascsws7OjhxrO2L+SGX1uo1sP3WDbkFGRo0cIftoOco/Nv64bDkr165jc+QZ+raoRVjYaFnvVVDk6ctAMLnJMdjp2qkdRxRTXT8P5g0YRPb7S5kxuhshTU/Qq7E3T70ymy2rl8h+KmyWVqulT58+LF++nPDwcDp37qx2JGGjlocfQPHPu5pnTGt3jPYGlROJO2nZMAjtmhUQ0JKl+y8S2l2+U1QGpSpKRUVFsX37duLj44t0Ivbmm28Wez7Lli3j0KFDxT5D8e677zJ79uwSZbV1ycnJJCcn89vRKHadTWX8g334duUmwsPDAUhJScHbu/r2ofTVr0fQ+LfEHHOCnmMfUjuOuAf52/qSLz6k/8D7CW3hzcbjiZyIy0ars8OqgFanep28iPxcJ+Ky2XU2lSGtfPn50FV27NmPxZRe7ffR8pK/vcQ6BrPnQgajerRg5d5TbN+9j5ysDFnvVcz5+AzwAVdtltpRRAkkJydz9dSffDJtNC1WbWZo+zpsPJ6IruNEBoSM4+1fr9A60I3m/o4Eexux00q/UsJ29O3bl+XLl7N161ZmzpypdhxhgzJN2aw4lo7RywNd7BGGjR2pdiRRDI/1bsLCU6Dza8q+v07TuXUjtSOJuyjxL8Cvv/6aJ598Ei8vL/z8/Ap1XKnRaIpdlLpy5QrPP/884eHhODg4FOs5M2bMYPr06QV/p6amEhgYWLIXYGPc3d1xd3enju4GXWrbs/F4IqOG9GfnC7P4ZeEnuLlV3w5fT1+MxuKVN+zqiHb+ascR9yh/W29X35/ONXV8PP8/jB/7MF+8/gaRhw5x+PBhUlNTbWq0DK1Wi6urK61atSKkbVs6hn7Fmt8v0K9VbabO+ozF706r1vtoeXJ3d6dWo9aETZ5G9/purD8Sx8D2DXjxs9V8/epYWe9VTHKOAXsgqIZR7SiiBPKP622Cfela254vf/iJMcOG8NvxVC5ku3IpOYdLyTf4+egNHOw0NPJ1pLm/E839HQlwM0jn50JV+f1KHThwgLS0NFxcXFROJGzN6/9dj9GrOdlpSXw4rpfacUQx9Qppzlfb1mAIaMqCLUekKFUJlLgo9c477zBnzhxeeeWVe1rwwYMHiY+Pp23btgX35ebmsmvXLj777DOys7PR6XSFnmNvb4+9vf09LdfWWCwW5s2bR2hoKCOHP0SiV1tGTXya/7z7Ol06hmCxWDAYqmcz0U9W70Pn3RLTtShGjJXrtyu7m7f1sLAwwsPD2bT+Z5YtW8b69etx1oNvbdsrPmZkZPD+22/m5R49mqNXU3lh/greff5RWge6Vet9tDyZzWamz/2ByT1r89Z3m/n2vVeZ/ulqXn+0D/4+mzBlZct6ryKsVisaVz8A2jaoqXIaURK3Oq6vXtyPZcuW8fOmcGq17kVUYg7HYzNJy87lcHQGh6Pz+oPzMNrR1N+R5v6ONPN3wt1oey1lRdVWt25d6tWrx/nz59m1axeDBw9WO5KwIZHHzxLnWB8d0M4liUA/L7UjiRIY0c6fX2LB4tWY0xejaRQk3y9sWYm/ASQlJTFy5L03XezTpw9Hjx4tdN9jjz1G48aNeeWVV4oUpKoqJycnxo4dy6JFi4iMjCQ5ORxn9xpAGE89OICDJ87SvU31q+5eu55EsnM99EDfYEe144gy8PdtHfJG3ly/fj1jx4612TPmRffRZDb/sgoYzjPDh2CnkZHgysOWg2eZ3LcFX+y6wuL3/8GNCyf5dvYT2Bm+5an+rfhm0x88PaQ9dtXks6IqO3UxGoOzO9bcHLq1aax2HFECdzquT/j/43o/wKooXEnK5lhsJsdjMzgdbyLJlMPe86nsPZ/XP2gtdwPN/r8VVWMfR+z1qo/FI6qBvn37smDBArZu3SpFKVHAarXy4fpj2Ac0ITvmFC/9Y4jakUQJjejbkZ8+WI/RrwGfrN7HF9Pl0ktbplFKOLb2448/TkhICE888USZh+nZsyetW7fmk08+Kdb0qampuLm5kZKSgqura5nnqUgZGRno9XpSUlJwdnHl3xtO4+TmQaCrFsfMWB7s2V7tiBXqpf+sJt61GaaEy/z4fG/54VmF3Lytu7nltTRycnJSO9Zd3ZwbgxOvrrtIIz8XWjqnMrBjM7XjVSmXYxPYc9HE1QwNXpo0Hu1Wv2B7iThyhSNJdgTVcGTrth18NX04Wq38eK3Mvl6znd3pAZgSLrNiej+144hSKOlx3ZxrJSreVFCkupSYzc1fRnVaaOBtpLm/E838Hanr6YBW+qMS5WDFihWMGjWK5s2bFzlZLqqvj5f+yp+5QeRazDzTzkCnVtWvgUBV8OWqCPZl1sJiSufjYfXw8/JQO1K1U9x6TYlbStWvX5833niDAwcO0KJFC/R6faHHn3vuuZKnFQVf3vI77v3HoIY8/umvHAtojDlDwdXpGL1CmqsZscKkZZi4ovHDHmhXwywFqSrm79t6ZbkE6++565jPcSy2IX9mZRPodZlm9WurGa9KeWPRDhT/lpgSLvHD0z0xGAwF631Q+2AO/7CRDdeCwbcl0z9bwyfPDVc3sLgnJ68mgnsADpYUtaOIUirpcd2g09LM34lm/k6AN2lZOZy4lllQpLqekcOpOBOn4kys/AscDVqa+jkWFKl8nPU227pWVC69evVCo9Fw7Ngxrl27hp+fn9qRhMpiEhI5kOSCvSt4pZ2mU6sRakcSpTRpaE8i5m3D6F2bD5dt58NnhqkdSdxGiVtK1a1b9/Yz02g4f/78PYcqrqrUUupWrien8uTXuzH61Sc79Tqv9PanbZN6ascqd299s46zhoZkJcfz3aT7cDRWrX7ERNWQk5vLw3M34eDfgJyYYyx9RQojZWF5+AHWX8s7kzW0ZgrDet93y+le+3ItV52aAFA78yTvTB1aURFFGXvkvVXoAprjl3qc95+WL4zVnaIoxKdZOBabwbHYTE5eyyTTUngADC8nPc39HWke4EQTP0dc7OXklSi9du3acejQIRYvXswjjzyidhyhssc/WIHFryWmG1dZOKULzo7FG5BL2KZ/f7+BE9r6ZKfd4L/j2+DiJAOqVKTi1mtKfM3DhQsXbnuryIJUdeDl7spHYztgSriEvasX7265zOmL0WrHKlcWSw5H05wBqK+/IQUpYbPsdDqe7BWENceCXUBzvlq9Te1IlV7+0MtA3tDLtylIAfzriaG4J+ZdanHZsQnvL9pUIRlF2TPb5xUhm9XxVjmJsAUajQZfVwN9GnnwfM+a/GdUfWYOrM3wVl408jGi08L1DAs7zqbw2a4Ynll+ljc3XGT5oQROxGZgzrWdEVxF5ZA/Cl94eLjKSYTa1u08iNkn78qUhxo5SEGqCnhuVF+ykuOxd6nBx8u2qh1H3IZ0xGHjAv28eGdYM0yJsRg9/Xl99XGuXLuudqxy88XqbRhrBGDOSGV6WG+14whxR71CmuOadBKAiGg7ElPSVE5UueUNvRxIdloi74y/+/7/ybPDsI87AsCR3Np8uSqivCOKMpaQmIKDR96om11bNVA5jbBFOq2GYG8jD7aswT8H1OaLUQ14sXdNBjT2oKabAQW4mJjN+uOJ/HvrVZ766Szvb73CxuOJXErMwlqyCwJENdSvX15fdlu3bqWEF5CIKiTbbOGHPxLQaLUQc4SHB3VRO5IoA45Ge4Lt8n47H01zxmLJUTmRuJUSX74HcPXqVX755RcuX76M2Wwu9NhHH31UZuHupqpfvnezP06c44Pt17B39cJ07SxfTO6Gl3vVes1Wq5XRH/2K0bcebjeO8uk0uYZb2L7k1HSmfHcQBw8/HBOO8KWM7lEqkcfP8smBDHQGB1pozvOPRwcV63k5ublM/HA1BLQk15JNaEA6YwZ2Lue0oqys3vY7a6PdyE69zk9Pyw8AUXLJmTkcv5ZR0B9Vsim30OMu9jqa+f+vP6oaTvrbzElUVyaTCQ8PD7Kzszl58iSNG8sooNXRjC/WEO3cFHNGKnMGBxIcKP2LVRXXk1N5ZtlpDE6utDdc4rnR/dWOVG2UW0fnERERPPDAA9SrV49Tp07RvHlzLl68iKIotG3b9p5Ci9tr3zSYJzJMfHUwFaNffZ7+ahvfPDuwSjUrXbp5H0bfeuSYTUwf2U3tOEIUi7urM/1rK+xKg3TPpoQfOEK/ji3VjlWp/H3o5RdLMPSynU7H1y8MZcLH69AHNOOXyxZcdx9icDf5PKoMDp+7Bg5uaNLj1Y4iKil3Rzu61HOjSz03FEUhOsXMsdgMjsdmciouk7TsXA5cTOPAxbyWrP6uBpr5O9LM35Gmvo4YDdIfVXVnNBrp2rUrERERbN26VYpS1dDRqEtcsgvCDmhmuEZwYIjakUQZ8nJ3xTvrEilOLdh9JZdnrFYZudnGlPjdmDFjBi+99BJHjx7FwcGBVatWceXKFXr06MHIkdJCoDz1CmnOmMYacrIysQ9owpRPN1SpJojrjuY1rTQmRlG3pq/KaYQovklDe5ITcwytzo4Fu6+Qk5t79yeJAvOWhWMf0IRcSzYvDGpS4i8K9gY9C54ZRFbsafRGZxYds7D70MlySivK0uWkbABqGKrOZ5lQj0ajoZa7PQObePJi71p8MaoBr/UP5IEWNQj2ckCjgdhUM1tPJzNvRwxPLj/L25svsfrwdU7HZ5JjlUu3qqv8fqW2bpU+Z6qjf60+iJ2DI1mxUcwYf7/acUQ5mD6yGzlmE0bfeizdvE/tOOJvSlyUOnnyJOPGjQPAzs4Ok8mEs7Mzb731Fu+9916ZBxSFPdizPQMD0sm1mLELaM7kj9dgtVb+Tj037/0L+4AmWHNzeDq0ndpxhCix10feh8WUjtGvPu8s3KB2nEojf+hlAO/0M3Rs2bBU83FxMvKfST0wxZ3D4OzOp/tucPj0xTJMKspDusYJgPq+VetydGEb7HQaGvs6MqK1FzMH1eHzUfV5rkcAvRu64+uix6pAVEIWa4/cYM6vV3hq+Vk+3n6VLSeTiE7Jlv6FqpH8otT27dvJyZEieXXy5aoI9AHNsOZYeKp3Xex00nqyKqpb0xdjYhTwv4YQwnaUuCjl5ORU0I+Uv78/586dK3js+nV5gyvCuMHd6OR8Das1F6t/S578eFWlL0wt2nM27z9xJ2nbpJ66YYQohab1AqmnXAHgdG4AUZdiVE5UObzxXQT2rjUwXb/KO5NC72le3p5ufPBwe0zXr+Dg5s07my5w9nJsGSUVZc1iyUHvGQBAh6ZB6oYR1YKTQUf72i5M6ODLB0Pr8dFD9ZjY0ZcOdVxwtteRZbHy59UMFv8Rz4xfLjJt9Xm+3hfLvvOppJikUFGVtWnTBg8PD1JTU/njjz/UjiMqyPXkVLbFGABwTT5Jz/bNVE4kytPToe2w5uZgH9CEzXv/UjuOuEmJi1IdO3Zkz549ANx///28+OKLzJkzh4kTJ9KxY8cyDyhu7ZlR/WiqXADA5NOSl/6zRuVEpRd5/Cwav6YAjO9RulYSQtiCWRNDMcWdR+/owuxl0jT4bgoNvdy4bIZeDgrwYdaQhmQlXcNYI4AZK44Qk5B4z/MVZe+3Y2exMxjJyTYR0uz/2Lvv8Kbqt4/j76RN03TT0k2hhUKBAmWq7D1kqAxZysYFiCB1iywFUUCWDAdTkSFTloKAIIIiskehQAHphNKWzqTNef7o0/yIZbTQNh3367pyQU9OzvnkJCfjzndUsXQcUQaVd9DQqqoLI1v4MP/5KkzuXIk+9csT7GWHRq3idmomBy4lsehgFK//eIkPtkaw6u9YTt5IISOzZP8YKMxZWVnRpk32rK/Sha/s+ODbn7F18SD9djRTh+VtghVRctWvURlisod3MDWIEMVCvotSs2bN4sknnwRg0qRJtG3bljVr1uDv78+3335b4AHF/b0/uAu+yWcBuOlSiwlfb7FwokezcPsx1Gor9JHnZIBoUaJpNNYMecoLozELtU9tlv2039KRiq3CnHo5OLAioa19yLhzC52HP2OW/kFCUnKBbV8UjL/ORQBguH0DjSbf864IUaDUKhX+brZ0CXbjnfZ+LOwTyNttK9Al2JVKrloArt/OYOe528zY8y+vrQln2i/X2XLqFpdvpmGU8ahKvJwufLt27bJwElEUdh0+SYpb9o/iHSoquDg5WDiRKAo5DSBUXjU5ckYKU8WFSinBHebzOsVgaff67B9JdKuNYjRS1/oq417oZOlIeRZ+LYoJu+Ow0mh52v2WTOUuSoWXZqwjw7MOafGRfDPsCZwd7C0dqdh5d+FGIv9/6uVp3SoWyuQGuw6f5NsTGdjYOaGPPMeS0U9jp9MW+H7EoxnxxTqSy9fBOvokS96SiVJE8ZaUnsnZqFTORKdyOiqFWynm3fnsbdTU9LIj2NueWt52eDjaWCipeFSXLl0iMDAQjUZDfHw8Dg5SpCitDIZM+s/+GZ1XIFmRp/n+nZ6WjiSKUN/pm7DxqSGfP4pAXus1MhdiKTBndA800SdRqdUc01fg6417LR0pz75Y/ztWGi1p0eH06SDdP0Xp8PGQ9qQn3kTn6sOH3+ywdJxi5+SFCK5Z+wPZUy8X1myb7Z+qQ++qCpn6NGx8avDS3J9K1YylJV28XgNAxXJSKBTFn5OtNU8FODGssRezuldm+rMBDHzCgwZ+Dug0alL0Ro5cS2bZnzGEbrpC6MbLLD0czV9X75CcITOylgSVK1fG398fg8HAgQMHLB1HFKKPl21H5xWIIS2Z8b2ftHQcUcSeDfEAIMMtSMYeLSbyVJRydXU1DWJerlw5XF1d73sRRU+tVrP4zR4okadQW2vYF+/K2l2HLR3roWJuJXDLzh+AVv7afE8DL0Rx5enmQnP3VADinatz4J9zFk5UvEzb+E+RTb3co80TtHdPJCvTgJVPbV4uJTOWlgaKQ/aHwpDK3hZOIkT+qFQqvJ1saBdUjjda+bKgdyDjO1WkR4gbQR46rFQQm2xg78VE5u+PZOTacCZsv8q6Y3GcjU7FkCWvQcWRSqUydeGTcaVKr4tXI7lgzJ5ko4pyneoBFSycSBS1Ph2eIi36ElYaLV+s/93ScQSQp0EcvvjiCxwds6fsnj17dmHmEY/I2sqKr8Y8w5DZ27DxqcnGK5k4HTxOp6Z1LR3tvmat2YONYzBpN//lldGtLR1HiAI18vm29P98MzY+NZm3O4ymdYOk8Aos/LHop14e8kxLklb/wt8ZfmR512HUnPUsGCvNtS0p/FoUWic3FKOR5vWDLB1HiMdipVZR1V1HVXcdz9WBNIOR8zGpnIlK5UxUCjcS9Vy5lc6VW+n8dDoeGysVQZ46annbE+xth5+LFpVKZem7IcgeV+qbb76RolQpNmn1H2h8apMWc5kJbzzerL+iZFKr1bTyt+HPdIi3CyDmVgKebi6WjlWmyZhSpUxicgovLdiDrXc1Mu7c5o0m5WhSt/h94E9OTWfokqPYOpenWuZFPhwibwqi9Dl2/gqfH0zE2kZHTWM47w7qYulIFnUzIYkRK09g6+KBw82TRV4YmrzkJ8I12QNceiad4fORPYp0/+J/lv20nz0JnqTd+pd1Y9paOo4QhSo+1cDZqFROR6VyJjqFxDTz7nxOtlYEe9lRy8eeYC87XO01Fkoq4uLi8PDIbsUZHR2Np2fhdC8XlpHz3mM0ZvFioL5Y/3gvCldmVhb95u5DV74C3nfOMH2EfCYsDAU6plRSUlKeL8KynB3smTesOWkxV9A6lmP2gVhOXoiwdKxc5qzZja1zedITbzKmTztLxxGiUNSrHoBv+mUAjqe6cS0qzsKJLMs09XJ8lEWmXv5oaDc8k84AEOMUzOQlPxV5BpHtzLXsIQFsMm5bOIkQhc/VTkOzKs682sybuT2rMLWrP/0buFPHxx4bKxVJ6VkcirjD139EM2bDZd7ZfIWVf8Vw7HoyaXoZj6ooubu7U7duXQD27Nlj2TAFLCUlBb1eT2xsLHq9npSUFEtHKlKJySlsu5zddVYXd0YKUmWctZUVIS5pAFwxepKcmm7hRGVbnopSLi4ulCtXLk8XYXmebi581q8eaTf/xdbFgynbL3HperSlY5lkZmVxPEEHQIA6Bgc7WwsnEqLwTB7elbS4q9g4lGP8yn2WjmMxvxw6YZp6uaM/Fpt6+fORPXC4eRKAi1aBzP7hZ4vkKOuikrO/GHjaSZclUbaoVCoqlNPSqaYroW0rsLBPIO938OOZWq5UdrNFpYKoJD27whL4Yt8NRqwNZ8rOa2w8cZOLsWlkGktsB4cSozSOK6UoCuvXr8fT09N0Wb9+PSW4w0y+ffDNDnSu3qQnxjF1aAdLxxHFwJg+7UhPvImtc3nmrCk953tJlKei1N69e9mzZw979uxhyZIleHh48Pbbb7Nx40Y2btzI22+/jaenJ0uWLCnsvCKPAnw9+ahrIOkJMejcKvDumuNE3ywev0h/tWEvuvIVMKTe4c0+bSwdR4hCpdPa0K+uCwCKd50SMQlBQTMYMvn69xuorazJijzNsGdbWTTP/Dd6Yv3/M5YeSfdlyZbfLJqnLMrQOANQ08/NwkmEsCyNlZrqnnb0qufOxM6VWPB8IK+39KFNNWc8HDVkKXAxLo2NJ28x5edrjFgbzhd7b7Dr/G2iEvVlqqhQVHKKUrt27SoVxzclJYWVK1fStWtXGjVqBECjRo3o2rUrK1euLBMtpg78c47bztUBaOGRhrurs4UTieLAwc4Wf1UMAMcTdGRmSctUS8n3mFJt27Zl+PDh9OvXz2z5qlWr+Oqrr9i3b19B5nsgGVPq4Q6dCGP2wdtoHcuRHnWBr0e0wdnB3mJ5jEYjfWbuQOcViOPNk3wpgw2LMmLIZ+vI8q5D2s3rLH+1OXY6raUjFZmPvt5MhG11DGnJTGjvWSxmujEYMhk8axNWPrXJ1KfR0z+Dnm1lWuiikJicwsj1V1GrrXi/mX2xeD4IUVzF3dFzOvp/g6an6M1n7nO1sybY2y570HQvO5x0eZrDSDxAamoq5cqVQ6/XExYWRrVq1Swd6bHo9Xo8vbx5dsgbzPv4XTbvO0Lnp2rSt08fjhw5QkxMDDY2NpaOWWiMRiN9Z2zD1rsa+sizrHrrWZl4RpjE3EpgzI/haOwcedL2OiOfl2FlClKBjil1t0OHDtGwYcNcyxs2bMhff/2V382JQtY4JIihdW0xpCVj612NV778hbQMvcXyrN11GJ1XIFmGDMb2bGaxHEIUtY8HtSHjTjy68n58+M1WS8cpMmERN7ioZBcdAvm32BQgNBprvh7dDX3kOaxtdPwYbsWuwyctHatM+P1YGGq1Ffrk21Sr5GPpOEIUa+6ONrSu6sKoFj58+XwgkzpX4vl65anpZYe1WkV8aiYHLiWx8PcoRv14iQ+3RvDD0VhORqaQkWl8+A5ELnZ2djRt2hQo+V34jEYjB85H0/ytZRjr9uHA5WRefLopf1zXE+dUk5SMTBITEy0ds1BNX7kDW+9qZGak8d5z9aQgJcx4urngmnoFgH0RGRiN8rppCfk+K/38/Pj6669zLf/mm2/w8/MrkFCiYHVsUpeelQ1k6tOw8anJS7O3WKx54qbj2U0ktbfCCKzobZEMQliCr6cbDZ0SAIixC+TImXDLBioiU9YcQqNzIC3mMh8NKV6zD9rptCx6rR3pURfR2DnyzT/JHD55wdKxSr1/Lt4AQEmKkS8HQuSDWq0iwM2WbrXceLe9Hwv7BPJW2wo8XbMcFctlt769djuDHWdvM+PXf3ltTTif7rrOT6dvcflWOkYZjyrPSsO4Uj/uPswLs39h+Yk0XCpUI8hFoWlFLT8ePE+roPL0e3UcPWbu5lCkkTspaZaOWygiImM5kVoegAoZlwkJ8rdsIFEsje3ZjCxDBjqvwDI5zEZxkO/ue9u3b6dnz54EBgby5JPZXR3++usvLl68yPr16+ncuXOhBL0X6b6XP99s2se+2+VRW2vQRJ/k63E9i/QLwa9/nmL5BRuMxixG19fwRO2qRbZvIYoDo9FIv89/QutTnYzIc/zw1jOl+kt5SZl6OTIunjdWHEHn4U/67Wgmdq1MzcryI0thGfb5OgxedbCLO8miN6ULtxAFJSktkzPRqZyOSuFMVCrxqZlm19vbqAn2ts/u7udlh7tj6e2y9bj++usvnnzySZydnbl16xZWVlaWjpRn+/4+w+Jfw9D4BANghZGGDrfo1zKYvn37sGvXLvqPeJtFM6aw8GAMp6NSSU+Iob5zMuP6dUCjKT1dQAd9tg7Fuw5pcVdZMbIVOq0858W9Df18HZleddBHnmX1O90tHafUKLTue507d+bChQt069aN+Ph44uPj6datGxcuXCjSgpTIv+HPtaK+9l8UoxGDVx3emLuhSPe/dF8YAEr0WSlIiTJJrVYz9ukaZBky0PrUYM7qXZaOVGjunnrZrphPvezj7sq05+uQdusGtuW8mLA5jIjIWEvHKrXuKNmzr1Z2t8wMjEKUVk46axoHOPFSE2++6FGZ6c8EMKCRB/UqOGCrUZOiN/LX1TssPRzDuE1XCN10mWV/RnPk6h1SMmSA37s1aNDA9EXq6NGjlo6TJycvRDDos3V8c0aFxicYY1YmVlEnmdLBgxHPNWXr1p84cuQIANtXfcWGdWsY08qXGuWM2Lp4clZVhf7z9vD1xr2logvTml8OoXjXQTEa6V+3nBSkxAO92qkuRmMWNj41+fXPU5aOU+bku6VUcSItpR7NxG+2cFkbBIBP8lk+fa3wq8HHzl9h5uFU1FbW9K+cVqy/oApR2MbM/ZH4crXJSLrFF72r4+PuaulIBW7U7B9JcqtNekIsX75Qp0TMdHMiLIJPdv2LrbM7aTGXWTC0SYnIXZJkZmUx4NvjaHQODKluoHWjWpaOJESZkGVUuHwzPbsVVXQql+LSyLrrG4BKBQGutqZB0wPdbdFYld6WvHnRo0cPNm7cyCeffML7779v6Tj3dS0qjk9W7SO5XBBWmuxunJmRpxnRIZhm9aqb1ktJSUGj0ZCYmIizszMGgwF7e3vSMvR89M1Wrlv7YWOX/X0qPeoC/Rp60b1NI4vcp8eVmpbBoEUH0JX3wzr6JEvekla54uFemP4jVj61MUae4rt3elk6TqmQ13rNIxWlDhw4wOLFi7l8+TLr1q3D19eXlStXEhAQQLNmRTd4tRSlHt24+euJc87+MhCUeZEPhnQt1P0Nn7EOvWcdMiLPs+adZwt1X0IUd8mp6Qz56iA6twpook/ybSn7sHTgn3MsOpGFlbWmxM1kcuCfc3z5ZyI2DuVIjwrj25HtcbTXWTpWqXHkTDjz/skiy5DBNy9Ul1+uhbCQNH0W52PSTEWqyETzSXBsrFRU97QzFakquNigUqkslNYyFixYwMiRI2ndujV79uyxdJxcEpKSmbLiZyI1ldDYOQKQHhXGC0/48Gyr3JNSPcyNmFt8/P0ekpyrYWVjC4Ah8gwj2tegef0aBZq9sL05bz03XWqRcSeeWT2r4evpZulIogTYefA4qy7rMGZlMu4pO+pVD7B0pBKv0LrvrV+/no4dO6LT6fjnn3/IyMgAIDExkalTpz56YlGkPh/RHfu47JmmzqkrM29N4XUjunIjhtRy2d31utWWNwUhHOxs6R6U/YFP71GLn34rGV0D8sJoNDJvdzhW1hoMkWd4rWcbS0fKl+b1azCwtvb/ZywN4uX5O8jQGywdq9Q4fDp7hht9fKQUpISwIJ2NFfX8HBjwhCefPhPA7B6VeamJF439HXGytUKfpXAyMoUfjsbxwdYIRq+/xKLfozhwKZH41LLxmpgz2PnBgwdJTU21cJr/ydAbmPztT7yy8gRxzrXQ2DmSFhtBS6coVod2faSCFGRPyLLwzed5v2U51FEnMRqz0PgEs/iUwuDP1nEm/FoB35PCceRMODF2gQA0ckqQgpTIs05N65IReR61lTVfbv3b0nHKlHy3lKpXrx5jx45l4MCBODo6cuLECSpXrsyxY8d4+umniY6OLqysuUhLqcdjNBoZOmM9Ru86ZBn0dPBIYFDX5gW+n9FzfiTBtTZpMZdZ82bHUj2wsxD5MXD6OvCpQ1rsFb57vS1aG42lIz22qcu2cd4qkMyMNN5p7lJiZ7r5YecfbI10yO4KEXmSJaE9sC5BA90WV6/P/pFEt9qook6y/O3S1UJQiNJCURSuJ2RwJiqVM1GpnI9JRZ9l/nXB19mGYG87gr3tqe5ph05T+j7bKYpCpUqVuH79Ojt37qRjx44WzWM0Gvly3a/sj1Kjc6sAQPrtaBqWS+XN/h0K/D3qwD/nWLDrnGnA9Cx9Ok6JF3i/f2v8vMoX6L4KSvaEMlvQ+tQgI/I8P7zVTb53iHxZse0Au+M9yNSn8UknbwJ8PS0dqUQrtJZSYWFhtGjRItdyZ2dnEhIS8rs5YUFqtZqvx3YnK/I0Vhobfo5yYNPeIwW6j5sJScRqKwHQrIKVvDEIcZcJ/ZujT0lC5xHAhG+3WjrOY4uIjOVkWvYHVT99yZ56uV+nJrRwuYkxKxN86vDaFxtKxcCvlnYzI/s9wM+55BdghSitVCoVFcvZ8nRNV0LbVmBhn0Debe9Ht1quVHazRQXcSNTzy/kEvth7gxFrLvLxz9fYdPImF+PSyDKW2OFqzahUKtq3bw/A7t27LZrlh51/0GfmTo7oK6Jzq4A++TZ+qedYMvxJ3h7wdKH8aNK8fg1+eKcH3X2TSI+6gJWNLSnudXhr8xXe+nIDickpBb7PxzV79S9ofbInlBn7dA353iHy7cWnm5IWcxlrGx2z1h2wdJwyI99nqpeXF+Hh4bmW//7771SuXLlAQomio9FYs/j1LmREnsPa1o7VYbDnr9MFtv1Zq/dgY+9E2q1IRpSwbjxCFLYqfl4E22S3Lr1m7c/JCxGWDfSYJnz3GzYOLqTFRjBxWOGOU1cUXunRhjpW2d0VMjzrMHZe0c5YWhpl2bkDUDtAfnkUoqTQWKmp6WXH8/Xcmdi5El/2DmRUCx9aV3XGw0FDlgIXYtPYcOIWU3ZeY8TacGbvvcHusNtEJekpwXMqmbrwWaootevwSfpO38SOODd0XlXITE/FJf4Uc3pX55NXnsPBzrbQM3Rv04jVoV1o7hBJWtxVbOyciHEK5qVlx5iy5Kdi08U9Mi6ePxOyW2K4J1/gqTrVLJxIlERqtZpmFbKLvHG2lbiZkGThRGVDvrvvTZs2je+++44lS5bQvn17tm/fztWrVxk7dizjx4/n9ddfL6ysuUj3vYITn3iHV77aj84rkIykW7zV2pOGNas81jbTMvQM+upPbF08qKIPY8KwZwoorRClR2ZWFv1n7sDWuyqGyDP88E4PS0d6JKt//oPtsW4oRiM9/JJL7Iw99zL+q81c1WXPYOSXeo5PXnnOsoFKqOvRN/lg1y0APnvaA6/y5SycSAhREGLv6DkdlcqZqBTORqeSojdvVepmb02wlz21vO2o6W2Hk621hZLmX0xMDF5eXgDExsbi7u5eJPv959xlvtjyD3gFo1KrMWYa0N48x3t9mhFY0btIMtyLwZDJzB9+4Z9EB2xdsn9cSLt5nVYV4LWebSzaMmno5+vI9KpD2s1/WfpK0yIp2InSyWDIpP+XB9C5+VAh5RxTX33O0pFKrEKbfU9RFKZOncq0adNMg/5ptVpCQ0OZMmXK46XOJylKFawbMbcY8/1RdO6VSI+PYvIzgVQPqPDI2/t0xXbOqqqQcecW3wyqJzNYCXEf+/4+wzenFNTWGhrr/uW1Xm0tHSlfklPTGbL491I99fKYueuJL5c9Y2lN5RLvDuxs4UQlz6odB9l5szzp8VGsfaOVpeMIIQqB0agQEZ/OmahUTkelcjEujcz/dOerWE5Lrf+f1a+ahw4b6+LdxSokJISTJ0+yevVq+vTpU6j7unIjhqk/7CfVrQZW1tndnI2RpxjdOYQnalct1H3nx52UNKau2MkVfLBxcAEgLTqcXiGu9OnQuMjzbN73Nz9etUelVtOp/E36P920yDOI0mXSt1u4ZBNEekIsy19+UiZneUSFVpTKodfrCQ8PJzk5mZo1a+Lg4PDIYR+VFKUK3sWrkby/KQydqw9pcdeY1b/eIw1mmJmVRb85e9C5V8Qj8QwzRpXM1h9CFJURX6wjuXwd0hNiWTAghPIuJec1bey89dwq5VMvG41GXp21nnTPOhizMmnqEF3iioeW9t7CjdxwqElm5GlWvdPT0nGEEEUgw2AkLDaNM9EpnI5K5frtDLPrNWoVVT10piJVRVctapXKQmnvbdy4ccyaNYvhw4fz9ddfF8o+biYk8fGKX4jRVUZjaw9ARuQ5BjWtROdm9QplnwUh+uZtPv7uV+IdArHWZv/4rI88y0utAmn7ZO0iyZChN/DivD3oPPwh8iQr3il9P4yJoncnJY3hy4+hdXSTHyMfQ6EXpYoDKUoVjn/OXebTX6OwdS5PWnQ4C19qnu8vyIs37OFgii+GtGRmdg/Ax921kNIKUTokJCXz8tK/sXX1Rhd7ksXjSsaHqr9OXWTOkTSsNFrqqC4T+uLTlo5UaDKzshg2cwOKdx2yDBl08b4jv8bmQ85sk+XiTzHnjV6WjiOEsIDEtMzsWf3+v0h1OzXT7HoHrRU1veyo9f8z+7k7WH5ShB07dtC5c2cqVarElStXUBVg0Sw1LYNpK3dyIdMDrWP2Z+W0mMt0q+HAwC4FPyN2YQmLuMH0dX+gd6+J2soaxWhEFX2asc82pF71gELd9zsLNhLlWBN9SiLTulWS2dJEgQmdv4FY52DS4q7xwxttZBbmR1DgRamhQ4fmacdLlizJW8ICIEWpwrPv7zMs+jsFG3tnMiLP8+3rHfPVN7v3Z1ux9a6KfdxJFr5ZMr5cC2Fp327ex29J3hizMhlUPYv2T9WxdKQHKotTL2foDQz+4ic0PsEY0lN4IUiha4sGlo5VIjw/82d0Hv4lsouqEKLgKYpCZJI+u0gVlcK56FTSM82/lng6agj2zh6PqoaXHfY2Rf+lMDk5GVdXVwwGA+Hh4VSp8nhjrkL2jxxz1+zmUJwWnWv2GFFptyJp6qlnVO92JfbL7+GTF5i34yRWPtmtpLIMeuzjz/N+/5b4+3gU+P5OXojg0/0JWGt1VMu8yIdDSv4kK6L4iIyLZ9zGK2h0DjS1v8ErPWTSrvwq8KKUWq2mUqVK1KtX74GzaGzcuDH/aR+RFKUK10+/HWXVBRUaW3syI0+zdOwzaG0e/ovV+l//ZHOkC1kGPeNbl3uscamEKGtemL4eK59apEWHs2pMRzSa4jsg7Mzvd3LCGECWIYM3GumK1XgXhelOShrD5v+CrU919MkJjHjCkRYNalo6VrGWmpbBS6svYmWtYdwTWkKC/C0dSQhRzGQaFS7dTDMVqS7dTOfu4ahUKqjsZmsqUgWW12FtVTRd/Vq2bMn+/ftZuHAhr7766mNta/nWA2w9n4LOM7sFUcadW1TX3OTdgZ1Kzbg12w78w/I/rmPrkz1JiCEtGa+MCMYP7ICrs2OB7aff9A1ofIJJj7rAqnGdS2wxTxRfr81aR4p7HdKjLrL2bSl65leBF6VGjhzJDz/8QKVKlRgyZAgvvvgirq6W7ZIlRanC9/2O39ke5YyVxgZV1Em+HdfjoS/4OW8Q6qiTLHtbWkkJkR/nr/zLpF0xaHQOBKSHMeml4jlrZWRcPGPXnUfr6Ibr7dPMHl22xgiKi09kxLcH0XlVIT0xjvfa+RZ6F4WSbNfhk6y8qEWfmsSqlxqU+hZ1QojHl6rP4nxMGqejUjgTlUpUkt7seq21iuqedgR721HLyx5fF5sC7Vp3tylTpvDRRx/Rs2dPfvzxx0faxrYD/7Dij+to/1Oo+WBA+xI1jmReGY1GVmz7nW1hqf8rwCXdorpNwRTgFqzbzeF0P4yZBobXVtGqYXBBxBbCzPkr/zJl722sNDY865NAz7ZPWjpSiVIoY0plZGSwYcMGlixZwh9//EGXLl0YNmwYHTp0KLQ3gQeRolTRWLBuN3+keKO2ssY29iSLxva87xeKvUdOs/S8BsVoZERdNY1Dgoo4rRAl3/ivNnNVVx1D6h0md/KhaiUfS0fKRaZehmtRcYz74Tg694qk3YpkavegYvlYFQefLt/GWXUg6VFhrH27eBZahRDF260Uw//P6pddpLqTkWV2vYvOimBve4K9ssejKmdXcC2NDx8+TOPGjSlXrhxxcXFY5aNFzv26tL3Xr0WZGP8oMyuLOat3cfimbYF1VYyLT2Tk9yexdfHA8eZJvhwrP4KLwjP4s3UYvetgiDzDD+/I5F35UegDnV+9epVly5axYsUKMjMzOXPmTJHPwCdFqaKT84UCoHzCaWa9fu9WETkD2crsSkI8OoMhk/5zdqHzrIwx8hTfvVO8BoXetPcI6685oFKredr9Fv06NbF0JIs5f+VfPvrpErblvEiLjWDOwEYyscM9vDxjHemeddDGnOTrUPnyIIR4PEZF4d/bGZz+/yJVWGwahizzrzS+zjbU8rYn2NuO6p522GoevYVmZmYmbm5uJCUlceTIERo2bPjQ21y4Gsmnaw+iL18DtbWmSAf/Lo7uN6j7szUdebFzs3xt6+WZ60j3qEN6fBRfDWmIi1PRzwIvyo5DJ8JYcNyISq1mSHUDrRvVsnSkEiOv9ZpHfnVWq9WoVCoURSErK+vhNxAl2ruDulAh5RwAN11qMf6rzbnWOXkhAqNHDQD6PeVflPGEKFU0GmuGNfbGaMxC7VObZT/tt3Qkk7QMPd//E49KrYbIk2W6IAVQPaACb7X1JSPpFjoPf95Y9gfxiXcsHavYSTBqAQgob2fhJEKI0kCtUlHR1ZbOwa683c6PhX0CebddBboGu+LvqkUF3EjU8/P528zae4PX1l7kk5+vsenkTcLj0sgy5u83eWtra1q3bg3A7t27H7huzK0ERs3+kYm7Ysn0qoPaWoM+8iyDq2ey4p3ny2RBCsBOp2XKy88yv29NXG+fwpCegs6zMr/ccqfP9E3sPHg8T9v5+Y/jpJbP7qrXKUAlBSlR6BqHBJEVfRaApXvOWThN6ZSvolRGRgY//PAD7du3p1q1apw6dYr58+dz7dq1Im8lJYre1FefwyX+FABXddX5/LsdZtcv3nEctbWG9KgwurWU2aiEeBydmtbFLu4MANsuG0lMTrFwomwTv92KzsMffUoikwe0tHScYqFRcCCvNHJCn5qEzqsqry36ldS0DEvHKjaMRiNqp+wuGw2q+Vo4jRCiNLKxUlPT257e9d2Z3MWf+b0DGdXCh1aBzpS315BlhLDYNDacuMXkndcYuTacOftusDvsNtFJ+gdO4pSjXbt2ABw5cuSe1yenpvPeok28sTaMJLfaWGt1pEWH08UzntXvdKftk7UL9D6XVO6uzswe3YuPO/mgjTlJVqYBrU8NVl3W8eL0HzlyJvy+tzUYMvnmYCRqtRVZkacY+ox8DhFFI6fBhdGjBicvRFg0S2mU5+57I0aMYPXq1fj5+TF06FBeeOEFypcv/1g7X7hwIQsXLiQiIgKA4OBgPvroI55++uk83V667xU9o9HIy7PW075NKyJupVLPLYtWtSrwb8wtph24Q0aWwpCaCq0bVLd0VCFKvLvHTHC6dYr5Yyzbje9EWATTD2RPvRyUeZEPZOplMxv3HGHdZQ3P1vflxrUrDG9bA1utloSEBFxcXDAYDNjb21s6ZpE7eSGCGX9mYMw0sKhPYJkcf0wIYTmKohCb/L/xqM5Gp5KqN5qtU97eOns8Km87gr3scLTNPR5VVFQUf/31F+3atSMlJcX0uq7V2nLgxEUWHozBtpwXAGk3r9OqArzWs41M7PAQf5+9xJyfjoFXMCq1GmOmAe3Nc0wf3pHy5ZxISUlBo9GQkJDAP7EqVh2Lp2Z5K4Y96Y67q7Ol44sypPdnW7D1DsI25iRfyVAEeVLgY0qp1WoqVqxIvXr1Hjio+YYNG/Ic8qeffsLKyoqqVauiKArLly/n888/59ixYwQHP3wGBSlKWUZmVhbzf/qb4U83ZOH+6yx+fyh2vjWo23M0dd2yGPt0DYsMfC9EafTlut38me5HVqaBV0OsaF6/hsWy3D318urQLvJB+x6Wbz1AlI0fo1r6sXTnET4a/LSpKDVnzhwGDBhQ5l4fF63/lT9SK5AWd5V1b3awdBwhRBlnNCpciU83FakuxqWRdVeNSgVUctWailTVPHTYWKlN31XGjh1rel3/bNF3vNC9E/P3R3I6KpX0xDhq293m7Rc7obXRWOw+lkS/HDrBkv1XsPHJ/pxT092ase0C+OGHHxg7ehQZioZnP9tBvcoejGnli421fAYRRWvplt/Ym+hFZkYan3bxpaK3u6UjFXsFXpQaPHhwnj5IL126NO8p78HV1ZXPP/+cYcOGPXRdKUpZTmLSHZb+dpHhHUKYu/sSJ67dpkFVH15+woUtmzbSs2fPMtkiQIiCZjQaeeHzTRYvBuVMvZyVaeCVOmpaNKhZ5BlKiq1HLnE2QcOIFr68PeMbFn74Ku3bt2f16tVs3bq1zL0+jpm7nvhytSDyJCvekV8WhRDFS4bByPnYVE5HpXI2KoXrCXqz6zVWKqq42eCSHEG/tvXo06c3xy7FMPyDmXzQvxULDkQSFn0H18TzfDioI84OZef1vTCs2nGQjacT0XlVoZa3HSOaefPGpFlcvGND1+d68lpTTzasW0Ovnj3K1HupsDyj0UifL35B5xGA6+1TzB5dvCYiKo4Kffa9gpaVlcW6desYNGgQx44do2bN3F94MjIyyMj43zgdSUlJ+Pn5SVHKAvR6Pd6+frw8/Ts+eKEN+8MTaV7ZkV7dn+GvPw8TExODjY2NpWMKUSrc3W2uelY47w/uUqT7l6mX80ev19Pw2eG8OO4TRjT3Ye1Pv/Bcmyfp27cvR44cKXOvj/2nr8fapxY+yWf59LXulo4jhBAPlJCWyZmolP8vUqVyOy3TdF1OkWT/pSRaBDozf+9VtvywhK3z38fVUSZyKChGo5FDl28zc9NRnqpbgxHNfdgfnkiLQGcGDX+FPVvXl7n3UlE8zPx+JyeMAeiTb7PohVoy0P5DFPrsewXl1KlTODg4oNVqefXVV9m4ceM9C1IA06ZNw9nZ2XTx8/Mr4rQiR0JCAvE3Y5kxsjs7j4bTOdiVNZt38MvPO0lISCAxMdHSEYUoNUKC/KmQcRmAk2nliYiMLdL9f7D0F2xdPEiLj2LqS52LdN8lUUJCAqd2rmT5rInsD09kaK+nWbbiO3bt2lUmXx8Ntm4A1KokzdyFEMWfi86appWdeaWpN7N7VmZaN3+era7j3+P7OHYljv2Xkugc7MrmvX8x5YWmHFrxCVnpxWMyktJCrVZT1SmLTe924ZtPQvn1dBSdg13Z8MvvbPju2zL5XiqKh1HPtyU9Pgobh3LMXP2rpeOUGhYvSgUFBXH8+HH+/PNPXnvtNQYNGsTZs2fvue57771HYmKi6XL9+vUiTityuLi44OLiQuvmTWhT3Z0vv1lBjw7NaN++PS4uLjg7y8CDQhSkScO7khZ3FRsHFyZ891uR7ffuqZefDlBJt4Q8yHl99M28TvPKDmw/E8+wYcPK5OtjzK0EdK7ZM+81q1vNwmmEECJ/VCoVvi5auoV4cWzJu9ze8CGNfa2YPX8RTz8RRNMGtcvc63pRcXFxwdnRAX/NbZoH2DH/m+V0bVq7TL6XiuJDa6MhSJddEA1LdyEtQ/+QW4i8yD21RBGzsbEhMDAQgAYNGnDkyBHmzJnD4sWLc62r1WrRarVFHVHcg8FgYM6cOXTt2pW+ffuya9cuNq/935gpBoNBmtQKUYB0Whv61y3HhutG8K7D6p//oG/HJoW6T4Mhk2/+iETnWSV76uUB0nc+L+5+fRz53sfQ4AX+uZRZJl8fDxw7D5QjPSEWf58gS8cRQohHcvfrep/ez7Nr1y62b9lQJl/Xi8q9vmtske8aohgY17ctr3x3GttyXsxf9ytvvfi0pSOVeBZvKfVfRqPRbNwoUTzZ29szYMAAtm7dypEjRwA4cuQIW7duZcCAATLwoBCFoHubRmhiTwOw/mwqqWmF+1o5eek2dJ5VMKQl81GfxoW6r9Lk7tfHrSsXkBz3LxcSrVmz51iZe308cTkGAHXqTQsnEUKIRyefe4ueHHNRXLk4OeCTdQOAv2LUGI3Gh9xCPIxFi1Lvvfce+/fvJyIiglOnTvHee++xb98+XnjhBUvGEnmkUqno2bMnMTExxMbGEhMTQ8+ePcvcdOdCFKUpA9uQcSceXXk/Pvxma6Ht5/yVfwmnAgCB/EuQv2+h7as0ynl9jI6K5IWmVQA4meGJITPLwsmKVs4sVuW1Zet+CyFKH/ncW/TkmIvi6s3nW5KZnorOw5+lP+23dJwSz6JFqdjYWAYOHEhQUBBt27blyJEj/Pzzz7Rv396SsUQ+2NvbY2Njg7u7OzY2NvKrhRCFzNfTjUZOCQDE2AVy5Ex4oexnytrDaHQOpMVc4qMhRTvbX2mR8/rYrqY7hpREUowa5q3dbelYRSpFnT0rTTVvmSFXCFHyyefeoifHXBRHfl7lcUjK/gz+c1iShdOUfBYtSn377bdERESQkZFBbGwsu3fvloKUEEI8xJv9O5IReR4rG1tmbD1d4M2Gl2z5DSuf2hiNWQxv4oNGY/HhB0s0Z0d7PPXZE3McjlaVmWbeGXoDNq7ZLeyeqhlg4TRCCCGEEAXn9WeewJhpwNY7iE17j1g6TolW7MaUEkII8WBqtZpxnWuSZchA61OD2at/KbBtJyQls/OKAoDdzTN0bFK3wLZdlo3r/b9m3su3HrB0nCLx56mLWGm0GNJTqF+zsqXjCCGEEEIUmNpVK2EVdw6ANX9dt3Cakk2KUkIIUQI9Ubsq7skXAfgzwYnIuPgC2e4H3+7A1tWb9IRYpg7rWCDbFP/fzDsxu5n3jvOJFk5TNP46dxWAzIRIrK2sLJxGCCGEEKJgDW9XCwBrrxr8fuy8hdOUXFKUEkKIEurj4V1Iu/kvWkc3Plz262Nvb9/fZ0h0qQFAK68MyrvIOEAF6fVn/9fM+6ffjlo6TqG7FJsMgBNpFk4ihBBCCFHwmtevgSHyDCq1mq93nbJ0nBJLilJCCFFCOdjZ0qOGDgCDRy027/v7kbeVmZXFgj2XUVtrMESeYcTz7Qoqpvh/tatWQh2b3cz7h8MRlg1TBOINGgAqudpaOIkQQgghROF4vlH2bNWZ7jU4e1m68T0KKUoJIUQJ1q9TE4g8iUqt5rujt8jQGx5pO5+u2IGtdzUy01N5r3v9Ak4pcgxvFwyAlVdN/jgeZuE0hcdoNIKjFwD1An0snEYIIYQQonD0aPME6VEXsLLWMHfTYUvHKZGkKCWEECXc5AEt0ackovPw56Nvtub79lduxHA6wwMAP0MEdar5F3BCkaNFg5qmZt5f/XLS0nEKzcVrUWgdy2E0ZtG8XpCl4wghhBBCFJr2VR0ASHSswo2YWxZOU/JIUUoIIUo4fx8PamtjAbhuE8DJCxH5uv2E7/ZjY+9MWmwEk4d3LYSE4m69GvoCYChfnfNX/rVwmsLx+4nsQfgz4iNxcXKwcBohhBBCiMIz7NmWpMVdRWNrz8y1+ywdp8SRopQQQpQC7w3qTHrUBay1OqZt/CfPt1u14yD41EExGnmxgRtaG00hphQAPds+md3MW2PDnI2HLB2nUJy7nj0bpFafYNkgQgghhBCFTK1W09A9E4AbVj4kJqdYOFHJIkUpIYQoBdRqNaPaViEr04DGJ5gF63Y/9DbJqelsDEsHQBN7mmdbNSzsmOL/tQvMbj2U4FCZyLh4C6cpeFEpRgC8HORjhhBCCCFKv9G925GeEIPW0ZUvVj/+rNhliXxaFEKIUqJFg5q4JGTP7rYvWktcfOID1//wm63o3CqQkXSLjwe3LYqI4v8NfbYFaXHX0OgcmLVmn6XjFDi9TTkAavq5WTiJEEIIIUTh02ltqGqT/UPjmRSnR558qCySopQQQpQiU1/qTFp8FLYuHnyw9Jf7rnf45AXiHKoB8GS5JHzcXYsqogCsraxoUD77w8p1tRd3UtIsnKjgxCfewdY1e8a95iFVLZxGCCGEEKJojOvbFn1yAjpXbxb8uMfScUoMKUoJIUQp4uxgz9MBKgBSywfz8x/Hc61jNBr5Ysc5rDRaMiLPMaZvhyJOKQDe6NOO9IRYtI5uzFq9y9JxCsyBY2Go1Goy7tyiaiUfS8cRQgghhCgSrs6OeOivA/BHpILRaLRwopJBilJCCFHKDH2mJVmRp1Crrfjmj0gMhkyz62et+hmtT3WyDBmM6xyMWi1vBZag09oQqMmeNvj0Hcdcj1NJdfxSZPZ/7sRaNogQQgghRBF78/kWZOrT0HkGsHL7QUvHKRHkm4gQQpRCH/VpjCEtGZ1nFaYs22ZaHhkbz5EkFwA8Ui7yRG3pXmVJof3aok9JROfmw4L1paOZ99X4DABcNTKWghBCCCHKFn8fD+xuXwRg+5nSN5lNYZCilBBClEJB/r4MCbGllrcdN3RViUlIITY2lu0X09A6ulLDSc+nrzxj6ZhlnquzIx4Z1wD4/d+sUtHM+w52AAR6Olo4iRBCCCFE0Xu9WyOMWZlofaqz7cA/lo5T7ElRSgghSqk2DaozqoUPQV6O9J+4lOCmHdl/OZla3na81TUYrY3G0hEFdzfzrsx3O0p2M+/MrCw0LtnjSD1Ro5KF0wghhBBCFL2QIH9UMdkzYq/644qF0xR/UpQSQohSKiMjnR9+3MyI5j507PosLV+fSy1vO15tXJ5V339HSkqKpSMKzJt5bztdspt5/33mEta2dmTp03miVqCl4wghhBBCWMSQ1tUBUHvV5PDJCxZOU7xJUUoIIUopjUZD6MhhvPPFckY092Fo22BGNPOmf/8XeOONN9BopKVUcTGya0NTM+/tvx+zdJxH9ufZCAD0t29ISzwhhBBClFltnqiFPvIsKrWaxTtPWDpOsSZFKSGEKKUSEhJISEjgq4mv8+upG3QOduWHjdvYtmUjCQkJJCYmWjqi+H/1qgeYmnl/f/CShdM8ugtR2c8pB6O0whNCCCFE2da9nhcA+vLVCYu4YeE0xZcUpYQQopRycXHBxcWF1i2a0ryKE4uWr6Znx+a0b98eFxcXnJ2dLR1R3GVwqyAAVF41+evURQuneTS39NYAVHCxsXASIYQQQgjLer7dk6RFh2OlsWHOhj8sHafYkqKUEEKUUgaDgTlz5rB69Wr69unNa4P70bdvX1avXs2cOXMwGAyWjiju0vbJ2ugjz6JWW7Fo53FLx3kkRnt3AOpW8bJwEiGEEEIIy1Kr1bQJsAXgtkNlom/etnCi4kmKUkIIUUrZ29szYMAAtm7dypEjRwA4cuQIW7duZcCAAdjb21s4ofivnGbeGW5BXLwaaeE0+RMRGYutc3ZRqkW96hZOI4QQQghheS91b0XazetodA7MXLPX0nGKJSlKCSFEKaZSqejZsycxMTHExsYSExNDz549UalUlo4m7uF/zby1zN5w0NJx8uX349kzy6TFR+LuKl1DhRBCCCGsrayoVy4DgGt4cSclzcKJih8pSgkhRClnb2+PjY0N7u7u2NjYSAupYkytVtPaXwtAvF0AMbcSLBsoH05FxAGgSY+3cBIhhBBCiOJjTJ92pCfGoXVy44s1uy0dp9iRopQQQghRjLzco3V2M287R2at2WPpOHkWeScLAE87CwcRQgghhChG7HRaKltl/3h3KskegyHTwomKFylKCSGEEMWItZUVdV3SAYhQPElOTbdworxJ1zgBUN23nIWTCCGEEEIUL+P6tEGfmoTOzZdFG2RsqbtJUUoIIYQoZt4wNfMuz+wS0Mz7Tkoa2nI+ADSpXcXCaYQQQgghihd3V2fKp10FYP91A0aj0cKJig8pSgkhhBDFjIOdLQHq7GbeJxJ0ZGZlWTjRgx08HobaWoM+JZHgKn6WjiOEEEIIUeyM7dmMLH06Os8qrP75kKXjFBtSlBJCCCGKodC+/9/Mu3wFFhfzZt5HL/wLgDExCrVaPloIIYQQQvxXFT8vbOOzZyvefDLOwmmKD/nkKIQQQhRD7q7OuKVGALAvQl+sm3lH3Mqe3tjFWm/hJEIIIYQQxddrXepjNGah9anBz38ct3ScYkGKUkIIIUQxNbZnM7IMGei8qrDml8OWjnNfiUZbACq721s4iRBCCCFE8dWwZhWIPgvAygPhFk5TPEhRSgghhCimAit6o70VBsDmE7EWTnNvRqMRK2dvABoFyXhSQgghhBAPMqB5YPZ/vGry99lLlg1TDEhRSgghhCjGRvx/M28bnxrsOnzS0nFyOXHhKho7R7IyDTSuU83ScYQQQgghirWOTeqSEXkOtdqKhdv+sXQci5OilBBCCFGMNaxZBeX/m3kv/+2ChdPkduhU9i98+vh/sdNpLZxGCCGEEKL4e7aOOwDprtW4dD3awmksy9rSAYpCVlYWBoPB0jGEKBE0Gg1WVlaWjiGEuMvA5oF8fwnwrME/5y5Tv0ZlS0cyOR+ZAK5+2GXdsXQUIYQQQogSoW/HxmyctROdZxW+WP8788f0snQkiynVRSlFUYiOjiYhIcHSUYQoUVxcXPDy8kKlUlk6ihCC7GbeSw5sQutTgy+3HuXbYlSUiktXowF8nTSWjiKEEEIIUSKo1Wpa+Gk4ooebukrExSfi7ups6VgWUaqLUjkFKQ8PD+zs7OQLthAPoSgKqampxMZmD6js7e1t4URCiBzP1CnPzzchzbUqV27EEODraelIAGTp3NAAtf09LB1FCCGEEKLEeLVHa/Z/uR+dmy8z1+zh09e6WzqSRZTaolRWVpapIOXm5mbpOEKUGDqdDoDY2Fg8PDykK58QxUS/jk3YNOtndJ6VmbXuAPOKQTPvyLh4bMt5AdCiXpCF0wghhBBClBwajTW1nVIIBy5nuZOallEmx+cstQOd54whZWdnZ+EkQpQ8OeeNjMUmRPGhVqtp7pddJI6zrcTNhCQLJ4IDx8IASE+IwddTfgASQgghhMiPN/u2JyPpJrbO7sxes9vScSzCokWpadOm0ahRIxwdHfHw8OC5554jLCysQPchXfaEyD85b4Qonl7r0Ya0WzewsXdi1uo9lo7DySsxAFil3rRwEiGEEEKIksfBzpaB9Zyp5W1HpE0l0jMyiI2NRa/Xk5KSYul4RcKiRanffvuNkSNHcvjwYXbt2oXBYKBDhw5l5uBb0r59+1CpVKZB4JctW4aLi4tFMxWViIgIVCoVx48ft3QUIYTIF43GmtqO2e+R4QY3UtMyLJrn38Ts1pTutkaL5hBCCCGEKKma1gpgZHMfKno4U7f983h6euLp6cn69etRFMXS8QqdRYtSO3fuZPDgwQQHBxMSEsKyZcu4du0aR48etWQsixs8eDAqlYpXX30113UjR45EpVIxePDgAt1nnz59uHDhQoFu815y7ptKpUKj0eDp6Un79u1ZsmQJRmPBf6kZPHgwzz33XIFvVwghLGVs33ZkJN3C1sWDuWst28w7Ve0IQDXvsjlbjBBCCCHE49JYwdLthxjR3Ieew98EoFGjRnTt2pWVK1eW+kY7xWpMqcTERABcXV3veX1GRgZJSUlml9LKz8+P1atXk5aWZlqWnp7OqlWrqFixYoHvT6fT4eFRNDMnderUiaioKCIiItixYwetW7fmjTfeoGvXrmRmZhZJBiGEKKkc7XX4EQ3A0Vs2ZGZlWSRHWoYeG1dfAJ6qVdkiGYQQQgghSjqNRsPHYwYzf+9V3uvTnPnfrGD16tX07duXN954A41GY+mIharYFKWMRiNjxoyhadOm1KpV657rTJs2DWdnZ9PFz8+vSLKlpKSg1+uLtG9n/fr18fPzY8OGDaZlGzZsoGLFitSrV89sXaPRyLRp0wgICECn0xESEsKPP/5ots727dupVq0aOp2O1q1bExERYXb9f7vvXbp0iWeffRZPT08cHBxo1KgRu3eb/yLv7+/P1KlTGTp0KI6OjlSsWJGvvvrqofdNq9Xi5eWFr68v9evX5/3332fz5s3s2LGDZcuWmdZLSEhg+PDhuLu74+TkRJs2bThx4oTp+okTJ1K3bl0WL16Mn58fdnZ29O7d21TcnDhxIsuXL2fz5s2m1ln79u0z3f7y5cu0bt0aOzs7QkJCOHTo0EOzCyFEcRDapzWGtGR07hX5dvNvFslw6MQFrDQ2GNKSqRvkb5EMQgghhBAlXUJCAjHXLrFpzXfsD09k5LABfPvtt+zatYuEhATT99vSqtgUpUaOHMnp06dZvXr1fdd57733SExMNF2uX79e6LnS09P57LPPTP06PT09+eyzz0hPTy/0fQ8dOpSlS5ea/l6yZAlDhgzJtd60adNYsWIFixYt4syZM4wdO5YXX3yR337L/qJy/fp1evToQbdu3Th+/DjDhw/n3XfffeC+k5OT6dy5M7/++ivHjh2jU6dOdOvWjWvXrpmtN3PmTBo2bMixY8cYMWIEr7322iMNVt+mTRtCQkLMinDPP/88sbGx7Nixg6NHj1K/fn3atm1LfHy8aZ3w8HDWrl3LTz/9xM6dO005AEJDQ+ndu7epZVZUVBRNmjQx3faDDz4gNDSU48ePU61aNfr16ycttYQQJYJX+XK4JF8G4NfwVItkOBKW/X6QlRCJtZWVRTIIIYQQQpR0Li4uuLi44JV6kWb+dsz7ainDhg2jffv2uLi44OxcuodJsLZ0AIBRo0axdetW9u/fT4UKFe67nlarRavVPvJ+FEUhNTXvH96zsrKYOXMmkydPNi1LSEgw/T1u3Dis8vBB3M7O7pFmM3vxxRd57733uHr1KgAHDx5k9erVZq19MjIymDp1Krt376Zx48YAVK5cmd9//53FixfTsmVLFi5cSJUqVZg5cyYAQUFBnDp1iunTp9933yEhIYSEhJj+njJlChs3bmTLli2MGjXKtLxz586mItA777zDF198wd69ewkKCsr3/a1evTonT54E4Pfff+evv/4iNjbW9JjPmDGDTZs28eOPP/Lyyy8D2UXDFStW4Oub3YVk3rx5dOnShZkzZ+Ll5YVOpyMjIwMvL69c+wsNDaVLly4ATJo0ieDgYMLDw6levXq+swshRFEb06MJk/fEY+tdlR93H6ZXu6eKdP+XY1PAA5zUhf8jjRBCCCFEaWUwGJgzZw5du3alV/dn2LVrFz/92J7Vq1ezdetWDAYDNjY2lo5ZaCxalFIUhddff52NGzeyb98+AgICCnV/qampODg45Gnd8uXLExERwdy5c+95/dy5c3n77bfx9/fn5s0HT4WdnJyMvb19vvO6u7vTpUsXli1bhqIodOnShfLly5utEx4eTmpqKu3btzdbrtfrTd38zp07x5NPPml2fU4B60GZJ06cyLZt24iKiiIzM5O0tLRcLaXq1Klj+r9KpcLLy4vY2Nh831fIfj7kFO9OnDhBcnIybm5uZuukpaVx6dIl098VK1Y0FaRy7pfRaCQsLOyehaj7Zff29gYgNjZWilJCiBIhyN8Xm5t/kOVdhx+PRtGrXdHuPyHTBi3g76Yr2h0LIYQQQpQi9vb2DBgwgJUrV3LkyBEAjhw5wtatWxkwYMAjNXApSSxalBo5ciSrVq1i8+bNODo6Eh2dPXCrs7MzOp1lP+TmFFcSEhLueX1CQgJxcXF4eXk9tCj1OIYOHWpqmfTll1/muj45ORmAbdu2mRVngMdqVRYaGsquXbuYMWMGgYGB6HQ6evXqhV6vN1vvv4OuqVSqR55F79y5c6bCZHJyMt7e3matwnLcPfbV47g7e86JXhgzAAohRGF5uWMdFhw3YuNTk71HTtO60b3HZCxoRqMRlVN24b9+Vd+HrC2EEEIIIR5EpVLRs2dP+vbtS2JiIs7OzhgMhlJfkAILF6UWLlwIQKtWrcyWL126lMGDBxf4/uzs7ExFnLzQaDS4uLjcszDl4uKCj48Phw8fztN+H1WnTp3Q6/WoVCo6duyY6/qaNWui1Wq5du0aLVu2vOc2atSowZYtW8yWPSz3wYMHGTx4MN27dweyi0T/HRy9IO3Zs4dTp04xduxYIHug9+joaKytrfH397/v7a5du0ZkZCQ+Pj5A9v1Sq9Wm7oM2NjZkWWhmKiGEKGyNQ4KYt3M91j61WLrnXJEVpc5H3MDGwQVjVibN60nrUiGEEEKIx5XTu8rd3R2gVHfZu5vFu+8VJZVKla9udCkpKYwePdpsTKkco0ePxmAwPFK3vPywsrLi3Llzpv//l6OjI6GhoYwdOxaj0UizZs1ITEzk4MGDODk5MWjQIF599VVmzpzJW2+9xfDhwzl69KjZLHf3UrVqVTZs2EC3bt1QqVSMHz++wFoRZWRkEB0dTVZWFjExMezcuZNp06bRtWtXBg4cCEC7du1o3Lgxzz33HJ999hnVqlUjMjKSbdu20b17dxo2bAiAra0tgwYNYsaMGSQlJTF69Gh69+5t6rrn7+/Pzz//TFhYGG5ubqV+kDghRNnTv7E/a6+C0aMGJy9EUKeaf6Hv8+CJcMCHjPhIHO2DC31/QgghhBCidCo2s+8VR/b29rz33nt89NFHpi5jLi4ufPTRR7z33nuFXpDK4eTkhJOT032vnzJlCuPHj2fatGnUqFGDTp06sW3bNlNXuIoVK7J+/Xo2bdpESEgIixYtYurUqQ/c56xZsyhXrhxNmjShW7dudOzYkfr16xfI/dm5cyfe3t74+/vTqVMn9u7dy9y5c9m8ebOp8KZSqdi+fTstWrRgyJAhVKtWjb59+3L16lU8PT1N2woMDKRHjx507tyZDh06UKdOHRYsWGC6/qWXXiIoKIiGDRvi7u7OwYMHC+Q+CCFEcdG1RQPSI8+jttYwb8uRItnnuX+zZ0G1NZTuKYqFEEIIIUThUilF3VypACUlJeHs7ExiYmKuok16ejpXrlwhICAAW1vbx9pPSkoKGo3GrG9nURWkxP1NnDiRTZs2cfz4cUtHKXUK8vwRQhS+ZT/tZ0+CJ5kZaXzaxZeK3u6Fur8Xpq/HyqcWXkln+Gxkj0LdlxBCCCGEKHkeVK+5m7SUygN7e3tsbGxwd3fHxsZGClJCCCGKlYFdmpEWcwVrrY5Z634r9P3pteUACK5UuMUvIYQQQghRuklRSgghhCjh1Go1jbPneyBa40d84p1C29fNhCRsy3kD0CykaqHtRwghhBBClH5SlBIl1sSJE6XrnhBC/L+RvdqSHh+FjYMLs1b/Wmj7OfBPGCq1moykm1Tx8yq0/QghhBBCiNJPilJCCCFEKaC10VDDLgmACxnlSMvQF8p+jl+KAkCVHFso2xdCCCGEEGWHFKWEEEKIUuLNfm3JuBOPbTkv5q8rnNZS125nAOBmk1ko2xdCCCGEEGWHFKWEEEKIUsLZwR7frEgA/opRYzQaC3wfySo7AAI97z+LihBCCCGEEHkhRSkhhBCiFBnXuxWG9BR0Hv4s/Wl/gW7bYMhE4+oLwJM1/Qt020IIIYQQouyRopQQQghRivh6uuGUdAmAn8MKdha+P0+HY22jIzMjjUbBVQp020IIIYQQouyRopQQQghRyox+9kmyMg3Yeldj094jBbbdI+euAmC4fQONxrrAtiuEEEIIIcomKUqJAvfVV1/h5+eHWq1m9uzZ91w2ceJE6tata7rN4MGDee6550x/t2rVijFjxhRp7hz79u1DpVKRkJBQ5PuOiIhApVJx/PjxIt+3EKL0CA6siHXcOQDW/HW9wLZ7MSZ7dj9HUgtsm0IIIYQQouySolQxs2jRIhwdHcnM/N+sRsnJyWg0Glq1amW2bk7x5NKl7G4a/v7+qFQqVq9enWu7wcHBqFQqli1bZlqWs/7dlwoVKjxW/qSkJEaNGsU777zDjRs3ePnll++5LDQ0lF9/vf/MUBs2bGDKlCl53q8lC0mP6r+FOCGEKEjD29UCwNqrBr8fO18g24zXawCoWE5bINsTQgghhBBlmxSlipnWrVuTnJzM33//bVp24MABvLy8+PPPP0lPTzct37t3LxUrVqRKlf+N6+Hn58fSpUvNtnn48GGio6Oxt7fPtb/JkycTFRVluhw7duyx8l+7dg2DwUCXLl3w9vbGzs7unsscHBxwc3O773ZcXV1xdHR8rCzif/R6vaUjCCGKWPP6NTBEnkGlVvP1rlMFsk3FwQOAulW8C2R7QgghhBCibJOiVDETFBSEt7c3+/btMy3bt28fzz77LAEBARw+fNhseevWrc1u/8ILL/Dbb79x/fr/umssWbKEF154AWvr3ON/ODo64uXlZbq4u7s/MN8777xDtWrVsLOzo3LlyowfPx6DwQDAsmXLqF27NgCVK1c2tcz677KIiIhc3ff+67/d91auXEnDhg1Nefv3709sbCyQ3eUt5ziUK1cOlUrF4MGDATAajUybNo2AgAB0Oh0hISH8+OOPZvvavn071apVQ6fT0bp1ayIiIh54DABmzZpF7dq1sbe3x8/PjxEjRpCcnGy6/l73b/bs2fj7+5uuX758OZs3bza1Urv7Mb98+TKtW7fGzs6OkJAQDh06ZLat9evXExwcjFarxd/fn5kzZ5pd7+/vz5QpUxg4cCBOTk68/PLL6PV6Ro0ahbe3N7a2tlSqVIlp06Y99L4KIUqu3o38AMh0r8GZ8GuPta3wa1FondxQjEZa1K9eEPGEEEIIIUQZV6aKUoqikKXPyN/FoM++nUF/77/zcFEUJV85W7duzd69e01/7927l1atWtGyZUvT8rS0NP78889cRSlPT086duzI8uXLAUhNTWXNmjUMHTr0MY9eNkdHR5YtW8bZs2eZM2cOX3/9NV988QUAffr0Yffu3QD89ddfREVF8fzzz+da5ufnl+/9GgwGpkyZwokTJ9i0aRMRERGmwpOfnx/r168HICwsjKioKObMmQPAtGnTWLFiBYsWLeLMmTOMHTuWF198kd9++w2A69ev06NHD7p168bx48cZPnw477777kPzqNVq5s6dy5kzZ1i+fDl79uzh7bffzvP9CQ0NpXfv3nTq1MnUSq1Jkyam6z/44ANCQ0M5fvw41apVo1+/fqYunUePHqV379707duXU6dOMXHiRMaPH2/WNRNgxowZhISEcOzYMcaPH8/cuXPZsmULa9euJSwsjO+//95UJBNClE7d2zQiPeoCVtYa5m7+87G29fuJiwCk347E1VlasgohhBBCiMdXpqbOMRr0HPnwzXzfzrlqdaq+MJTYI4fwaNSY88sWk3gx7+NzNPp4FlY2eR9/o3Xr1owZM4bMzEzS0tI4duwYLVu2xGAwsGjRIgAOHTpERkZGrqIUwNChQxk3bhwffPABP/74I1WqVLlvq6R33nmHDz/80PT31KlTGT169H2z3b2uv78/oaGhrF69mrfffhudTmfqkufu7o6XlxfAPZfl191FtcqVKzN37lwaNWpEcnIyDg4OuLq6AuDh4YGLiwsAGRkZTJ06ld27d9O4cWPTbX///XcWL15My5YtWbhwIVWqVDG1NAoKCuLUqVNMnz79gXnubsXl7+/Pxx9/zKuvvsqCBQvydH8cHBzQ6XRkZGTc85iEhobSpUsXACZNmkRwcDDh4eFUr16dWbNm0bZtW8aPHw9AtWrVOHv2LJ9//rmpUAfQpk0bxo0bZ/r72rVrVK1alWbNmqFSqahUqVKesgohSrYO1RzZfweSnKpwI+YWvp737zr9IGeu3QQnT2wybhdwQiGEEEIIUVaVqZZSjyrx4nlijxzCp2U7Yo8cyldB6lG0atWKlJQUjhw5woEDB6hWrRru7u60bNnSNK7Uvn37qFy5MhUrVsx1+y5dupCcnMz+/ftZsmTJA1tJvfXWWxw/ftx0GThwIACvvvoqDg4OpkuONWvW0LRpU7y8vHBwcODDDz/k2rXH6xKSF0ePHqVbt25UrFgRR0dHWrZsCfDAfYeHh5Oamkr79u3N7suKFStMg8OfO3eOJ5980ux2OQWsB9m9ezdt27bF19cXR0dHBgwYwK1bt0hNLZgZqerUqWP6v7d39tgtOd0Vz507R9OmTc3Wb9q0KRcvXiQrK8u0rGHDhmbrDB48mOPHjxMUFMTo0aP55ZdfCiSrEKJ4G/pMC9LirqKxtWfm2n2PvJ2oZCMAnnaqAkomhBBCCCHKujLVUkqtsaHRx7Pyf0OVCrW1BmNWJt4t2uLZpAXko0ueWmOTr90FBgZSoUIF9u7dy+3bt00FGB8fH/z8/Pjjjz/Yu3cvbdq0ueftra2tGTBgABMmTODPP/9k48aN991X+fLlCQwMzLV88uTJhIaGmi07dOgQL7zwApMmTaJjx444OzuzevXqXOMZFbSUlBQ6duxIx44d+f7773F3d+fatWt07NjxgQN454zxtG3bNnx9fc2u02offeaoiIgIunbtymuvvcYnn3yCq6srv//+O8OGDUOv12NnZ4darc7VbTNn7K280Gg0pv+rVNlfAI1GY75y/ndg+/r163PlyhV27NjB7t276d27N+3atcs1xpYQonRRq9U0cs/iNHDDyofE5BScHXJPfPEwGRpndEBNv0draSWEEEIIIcR/lamilEqlylc3uly3t8o+XFb5LDI9itatW7Nv3z5u377NW2+9ZVreokULduzYwV9//cVrr71239sPHTqUGTNm0KdPH8qVK5fv/Xt4eODh4WG27I8//qBSpUp88MEHpmVXr17N97bz6/z589y6dYtPP/3UNB7V3bMTAtjYZD8md7cUqlmzJlqtlmvXrpkKe/9Vo0YNtmzZYrbs7sHk7+Xo0aMYjUZmzpyJWp3d2HDt2rVm67i7uxMdHY2iKKai0vHjx3NlvjtvXtWoUYODBw+aLTt48CDVqlXDysrqgbd1cnKiT58+9OnTh169etGpUyfi4+NN3R+FEKXT673bMuirw9i6eDLrh1+Z9NIz+bp9YnIKWrfs4n6zkNw/ZAghhBBCCPEoylRRqiRp3bo1I0eOxGAwmBVUWrZsyahRo9Dr9fccTypHjRo1uHnzJnZ2dgWWqWrVqly7do3Vq1fTqFEjtm3b9sBWWAWlYsWK2NjYMG/ePF599VVOnz7NlClTzNapVKkSKpWKrVu30rlzZ3Q6HY6OjoSGhjJ27FiMRiPNmjUjMTGRgwcP4uTkxKBBg3j11VeZOXMmb731FsOHD+fo0aO5Bgz/r8DAQAwGA/PmzaNbt24cPHjQNNZXjlatWhEXF8dnn31Gr1692LlzJzt27MDJycm0jr+/Pz///DNhYWG4ubnh7Oycp+Mxbtw4GjVqxJQpU+jTpw+HDh1i/vz5Dx3PatasWXh7e1OvXj3UajXr1q3Dy8vLNAaXEKL00mltqGYTzzU8OZvqRIbegNZG8/Ab/r/fj4WhVtujT75NtUpVCzGpEEIIIYQoS2RMqWKqdevWpKWlERgYiKenp2l5y5YtuXPnDkFBQaaxhu7Hzc0NnU5XYJmeeeYZxo4dy6hRo6hbty5//PGHabDtwuTu7s6yZctYt24dNWvW5NNPP2XGjBlm6/j6+jJp0iTeffddPD09GTVqFABTpkxh/PjxTJs2jRo1atCpUye2bdtGQEAAkF3wWr9+PZs2bSIkJIRFixYxderUB+YJCQlh1qxZTJ8+nVq1avH9998zbdo0s3Vq1KjBggUL+PLLLwkJCeGvv/7K1R3ypZdeIigoiIYNG+Lu7p6r9dP91K9fn7Vr17J69Wpq1arFRx99xOTJk80GOb8XR0dHPvvsMxo2bEijRo2IiIhg+/btptZeQojS7c2+bdEnJ6Bz9WbBj3vyddt/Lt4AQEmKkdcMIYQQQghRYFTKfwe+KUGSkpJwdnYmMTHRrAUKQHp6OleuXCEgIABbW1sLJRSiZJLzR4jS6Y05P3LbtTZpMVdY82aHPBeYhn2+DoNXHeziTrLozecLOaUQQgghhCjpHlSvuZv83CmEEEKUEeN6tyQzIw2dZwArt+etdSbAHSW7OF3Z3eEhawohhBBCCJF3UpQSQgghyoiK3u7YJ1wEYNuZ+DzdJjMrCysXHwAaVfcrtGxCCCGEEKLskaKUEEIIUYaM6tYIY6YBW5/qbDvwz0PXP3b+ChqdA1mGDJ6qU60IEgohhBBCiLJCilJCCCFEGRIS5I869hwAq/648tD1/zyTvY4+PhKd1qZQswkhhBBCiLJFilJCCCFEGTOkTQ0A1F41OXzywgPXDYtMBMDOeKfQcwkhhBBCiLJFilJCCCFEGdO6US30kWdRqdUs3nnigevezMj+qODnrCmKaEIIIYQQogyRopQQQghRBvWo7w2Avnx1wiJu3He9LDt3AOpU9iqSXEIIIYQQouyQopQQQghRBvVq+wRp0Rex0tgwZ8Mf91znevRNbF08AGhRL6go4wkhhBBCiDJAilJCCCFEGaRWq2lbWQfAbYfKRN+8nWudA8fCAEiPj8KrfLkizSeEEEIIIUo/KUqJPPnqq6/w8/NDrVYze/bsey6bOHEidevWNd1m8ODBPPfcc6a/W7VqxZgxY4o0d459+/ahUqlISEgo8n1HRESgUqk4fvx4ke9bCCEeZPhzrUiLu4ZG58DMNXtzXX8qIhYA6/RbRR1NCCGEEEKUAVKUKoYGDx6MSqXi008/NVu+adMmVCpVkedJSkpi1KhRvPPOO9y4cYOXX375nstCQ0P59ddf77udDRs2MGXKlDzv15KFpEf130KcEEIUZ9ZWVtR30wNwDS/upKSZXX8jKRMAd1ulyLMJIYQQQojST4pSxZStrS3Tp0/n9u3c3SmK2rVr1zAYDHTp0gVvb2/s7OzuuczBwQE3N7f7bsfV1RVHR8ciTF666fV6S0cQQpQCb/RuR3pCLFonN75Ys9vsujRrJwCq+0rXPSGEEEIIUfCkKFVMtWvXDi8vL6ZNm/bA9davX09wcDBarRZ/f39mzpxpdr2/vz9Tp05l6NChODo6UrFiRb766iuzdd555x2qVauGnZ0dlStXZvz48RgMBgCWLVtG7dq1AahcuTIqleqeyyIiInJ13/uv/3bfW7lyJQ0bNsTR0REvLy/69+9PbGx2V5GIiAhat24NQLly5VCpVAwePBgAo9HItGnTCAgIQKfTERISwo8//mi2r+3bt1OtWjV0Oh2tW7cmIiLigccRYNasWdSuXRt7e3v8/PwYMWIEycnJpuvvdf9mz56Nv7+/6frly5ezefNmVCoVKpWKffv2mda9fPkyrVu3xs7OjpCQEA4dOmS2rbw8llOmTGHgwIE4OTnx8ssvo9frGTVqFN7e3tja2lKpUqWHPmeEEOJudjotVaxvAnAqyR6DIbt1VGpaBjauvgA0qV3FYvmEEEIIIUTpVaaKUoqikGEw5uuizzSiKAr6zHv/nZeLouS/24OVlRVTp05l3rx5/Pvvv/dc5+jRo/Tu3Zu+ffty6tQpJk6cyPjx41m2bJnZejNnzqRhw4YcO3aMESNG8NprrxEWFma63tHRkWXLlnH27FnmzJnD119/zRdffAFAnz592L07+5fzv/76i6ioKJ5//vlcy/z8/PJ9Hw0GA1OmTOHEiRNs2rSJiIgIU+HJz8+P9evXAxAWFkZUVBRz5swBYNq0aaxYsYJFixZx5swZxo4dy4svvshvv/0GwPXr1+nRowfdunXj+PHjDB8+nHffffehedRqNXPnzuXMmTMsX76cPXv28Pbbb+f5/oSGhtK7d286depEVFQUUVFRNGnSxHT9Bx98QGhoKMePH6datWr069ePzMzsL395fSxnzJhBSEgIx44dY/z48cydO5ctW7awdu1awsLC+P77701FMiGEyKtx/dqiT0lC5+bLog3ZY0sdPBGGlbUGfWoStatWtHBCIYQQQghRGllbOkBR0mcqvLT6Yr5vV8vbjhHNfdgfnkiLQGdm77vB6ajUPN/+675V0WryPxZU9+7dqVu3LhMmTODbb7/Ndf2sWbNo27Yt48ePB6BatWqcPXuWzz//3FTcAejcuTMjRowAsltFffHFF+zdu5egoOzpvT/88EPTuv7+/oSGhrJ69WrefvttdDqdqUueu7s7Xl5eAPdcll9Dhw41/b9y5crMnTuXRo0akZycjIODA66urgB4eHjg4uICQEZGBlOnTmX37t00btzYdNvff/+dxYsX07JlSxYuXEiVKlVMLY2CgoI4deoU06dPf2Ceu1tx+fv78/HHH/Pqq6+yYMGCPN0fBwcHdDodGRkZ9zwmoaGhdOnSBYBJkyYRHBxMeHg41atXz/Nj2aZNG8aNG2f6+9q1a1StWpVmzZqhUqmoVKlSnrIKIcTdyrs44Z5+lUT72uy/bmCk0cjRsOugDsSYGIVaXaZ+wxJCCCGEEEVEPmXmwemoVPaHJ9I52JX94Yn5Kkg9runTp7N8+XLOnTuX67pz587RtGlTs2VNmzbl4sWLZGVlmZbVqVPH9H+VSoWXl5epmxzAmjVraNq0KV5eXjg4OPDhhx9y7dq1Qrg35o4ePUq3bt2oWLEijo6OtGzZEuCB+w4PDyc1NZX27dvj4OBguqxYsYJLly4B2cflySefNLtdTgHrQXbv3k3btm3x9fXF0dGRAQMGcOvWLVJTC+bxvvtx8Pb2BjA9Dnl9LBs2bGi2zuDBgzl+/DhBQUGMHj2aX375pUCyCiHKnjE9m5GlT0fnWYXVPx/iclz2a5+zOsPCyYQQQgghRGll0ZZS+/fv5/PPP+fo0aNERUWxcePGQp25zMZaxdd9q+b7dioVaKxUZGYpPF2zHO2CXMhPjzwb60efMa9FixZ07NiR9957z6zFTH5oNBqzv1UqFUajEYBDhw7xwgsvMGnSJDp27IizszOrV6/ONZ5RQUtJSaFjx4507NiR77//Hnd3d65du0bHjh0fOIB3zhhP27Ztw9fX1+w6rVb7yHkiIiLo2rUrr732Gp988gmurq78/vvvDBs2DL1ej52dHWq1OldXzJyxt/Li7schZxbFnMchr+zt7c3+rl+/PleuXGHHjh3s3r2b3r17065du1xjbAkhxMNU8fPCNv4ABq86bD4Zh5W1PdZAVS8nS0cTQgghhBCllEWLUikpKYSEhDB06FB69OhR6PtTqVSP1I0uh7VV9r+PU2R6FJ9++il169Y1dbfLUaNGDQ4ePGi27ODBg1SrVg0rK6s8bfuPP/6gUqVKfPDBB6ZlV69effzQD3H+/Hlu3brFp59+ahqP6u+//zZbx8bGBsCspVDNmjXRarVcu3bN1LLqv2rUqMGWLVvMlh0+fPiBeY4ePYrRaGTmzJmmbipr1641W8fd3Z3o6GgURTEVlY4fP54r89158+pxHksnJyf69OlDnz596NWrF506dSI+Pt7U/VEIIfJq8qA2fHcimTPUwFoNmUbo3q4xKSkpuYriQgghhBBCPC6Ldt97+umn+fjjj+nevbslYxR7tWvX5oUXXmDu3Llmy8eNG8evv/7KlClTuHDhAsuXL2f+/PmEhobmedtVq1bl2rVrrF69mkuXLjF37lw2btxY0Hchl4oVK2JjY8O8efO4fPkyW7ZsYcqUKWbrVKpUCZVKxdatW4mLiyM5ORlHR0dCQ0MZO3Ysy5cv59KlS/zzzz/MmzeP5cuXA/Dqq69y8eJF3nrrLcLCwli1alWuAcP/KzAwEIPBYMqzcuVKFi1aZLZOq1atiIuL47PPPuPSpUt8+eWX7Nixw2wdf39/Tp48SVhYGDdv3sxzS6pHfSxnzZrFDz/8wPnz57lw4QLr1q3Dy8vLNAaXEELkh6+HG2+0qkAtbzsyjWDMNPBU7UDWr1//SJN2CCGEEEII8SAyplQJMXny5FxdverXr8/atWtZvXo1tWrV4qOPPmLy5Mn56ub3zDPPMHbsWEaNGkXdunX5448/TINtFyZ3d3eWLVvGunXrqFmzJp9++ikzZswwW8fX15dJkybx7rvv4unpyahRowCYMmUK48ePZ9q0adSoUYNOnTqxbds2AgICgOyC1/r169m0aRMhISEsWrSIqVOnPjBPSEgIs2bNYvr06dSqVYvvv/+eadOmma1To0YNFixYwJdffklISAh//fVXrqLRSy+9RFBQEA0bNsTd3T1X66f7edTH0tHRkc8++4yGDRvSqFEjIiIi2L59uwxKLIR4JCkpKXy/bhMjmvtQy9uOxMjLNKhXl65du7Jy5UpSUlIsHVEIIYQQQpQiKqWY/PSpUqkeOqZURkYGGRn/G3A1KSkJPz8/EhMTcXIyH/MiPT2dK1euEBAQgK2tbWHFFqJUkvNHiLJJr9fj6enJS5+t4qOBHdjy2990aliVvn37cuTIEWJiYkxdq4UQQgghhLifpKQknJ2d71mvuVuJak4xbdo0nJ2dTZecsYiEEEII8fgSEhJISEhg0Yev8tP+f+jf4Um+/fZbdu3aRUJCAomJiZaOKIQQQgghSpESVZR67733SExMNF2uX79u6UhCCCFEqeHi4oKLiwtPhQTRsUEVPv/8c4YNG0b79u1xcXHB2dnZ0hGFEEIIIUQpYtHZ9/JLq9Wi1WotHUMIIYQolQwGA3PmzKFr16707duXXbt2sWvXLlavXs3WrVsxGAzSfU8IIYQQQhQYixalkpOTCQ8PN/195coVjh8/jqurKxUrVrRgMiGEEKLssbe3Z8CAAaxcuZIjR44AcOTIEbZu3cqAAQNQqVQWTiiEEEIIIUoTixal/v77b1q3bm36+8033wRg0KBBLFu2zEKphBBCiLJLpVLRs2dP+vbtS2JiIs7OzhgMBilICSGEEEKIAmfRolSrVq0o7Mn/isnkgkKUKHLeCFG22dvbA+Du7g4gXfaEEEIIIUShKFEDneeHRqMBIDU11cJJhCh5cs6bnPNICCGEEEIIIYQoaCVqoPP8sLKywsXFhdjYWADs7Oyk64EQD6EoCqmpqcTGxuLi4oKVlZWlIwkhhBBCCCGEKKVKbVEKwMvLC8BUmBJC5I2Li4vp/BFCCCGEEEIIIQpDqS5KqVQqvL298fDwwGAwWDqOECWCRqORFlJCCCGEEEIIIQpdqS5K5bCyspIv2UIIIYQQQgghhBDFSKkd6FwIIYQQQgghhBBCFF9SlBJCCCGEEEIIIYQQRU6KUkIIIYQQQgghhBCiyJXoMaUURQEgKSnJwkmEEEIIIYQQQgghBPyvTpNTt7mfEl2UunPnDgB+fn4WTiKEEEIIIYQQQggh7nbnzh2cnZ3ve71KeVjZqhgzGo1ERkbi6OiISqWydBwhilRSUhJ+fn5cv34dJycnS8cRosSQc0eIRyPnjhAPJueIEI9Gzp3SSVEU7ty5g4+PD2r1/UeOKtEtpdRqNRUqVLB0DCEsysnJSV68hXgEcu4I8Wjk3BHiweQcEeLRyLlT+jyohVQOGehcCCGEEEIIIYQQQhQ5KUoJIYQQQgghhBBCiCInRSkhSiitVsuECRPQarWWjiJEiSLnjhCPRs4dIR5MzhEhHo2cO2VbiR7oXAghhBBCCCGEEEKUTNJSSgghhBBCCCGEEEIUOSlKCSGEEEIIIYQQQogiJ0UpIYQQQgghhBBCCFHkpCglRAGaNm0ajRo1wtHREQ8PD5577jnCwsLM1klPT2fkyJG4ubnh4OBAz549iYmJMVtn9OjRNGjQAK1WS926dXPtJywsjNatW+Pp6YmtrS2VK1fmww8/xGAwPDTjl19+ib+/P7a2tjz55JP89ddfpusiIiJQqVT3vKxbt+7RDooQeVDSzx2A6OhoBgwYgJeXF/b29tSvX5/169fn/2AIkQ+l4dy5dOkS3bt3x93dHScnJ3r37p0rnxCPqrifI/v376dbt274+PigUqnYtGlTrnUUReGjjz7C29sbnU5Hu3btuHjxYr6PhRD5URrOnQ0bNtChQwfc3NxQqVQcP348v4dBFAEpSglRgH777TdGjhzJ4cOH2bVrFwaDgQ4dOpCSkmJaZ+zYsfz000+sW7eO3377jcjISHr06JFrW0OHDqVPnz733I9Go2HgwIH88ssvhIWFMXv2bL7++msmTJjwwHxr1qzhzTffZMKECfzzzz+EhITQsWNHYmNjAfDz8yMqKsrsMmnSJBwcHHj66acf48gI8WAl/dwBGDhwIGFhYWzZsoVTp07Ro0cPevfuzbFjxx7xqAjxcCX93ElJSaFDhw6oVCr27NnDwYMH0ev1dOvWDaPR+BhHRohsxf0cSUlJISQkhC+//PK+63z22WfMnTuXRYsW8eeff2Jvb0/Hjh1JT0/P41EQIv9Kw7mTkpJCs2bNmD59eh7vtbAIRQhRaGJjYxVA+e233xRFUZSEhARFo9Eo69atM61z7tw5BVAOHTqU6/YTJkxQQkJC8rSvsWPHKs2aNXvgOk888YQycuRI099ZWVmKj4+PMm3atPvepm7dusrQoUPzlEGIglISzx17e3tlxYoVZrdzdXVVvv766zzlEKIglLRz5+eff1bUarWSmJhoWichIUFRqVTKrl278pRDiPwobufI3QBl48aNZsuMRqPi5eWlfP7556ZlCQkJilarVX744Yc8b1uIx1XSzp27XblyRQGUY8eO5XmbouhISykhClFiYiIArq6uABw9ehSDwUC7du1M61SvXp2KFSty6NChR95PeHg4O3fupGXLlvddR6/Xc/ToUbN9q9Vq2rVrd999Hz16lOPHjzNs2LBHzibEoyiJ506TJk1Ys2YN8fHxGI1GVq9eTXp6Oq1atXrkfELkV0k7dzIyMlCpVGi1WtM6tra2qNVqfv/990fOJ8T9FKdzJC+uXLlCdHS0WT5nZ2eefPLJx8onRH6VtHNHlBxSlBKikBiNRsaMGUPTpk2pVasWkD3mjI2NDS4uLmbrenp6Eh0dne99NGnSBFtbW6pWrUrz5s2ZPHnyfde9efMmWVlZeHp65nnf3377LTVq1KBJkyb5zibEoyqp587atWsxGAy4ubmh1Wp55ZVX2LhxI4GBgfnOJ8SjKInnzlNPPYW9vT3vvPMOqamppKSkEBoaSlZWFlFRUfnOJ8SDFLdzJC9yMuTn85sQBa0knjui5JCilBCFZOTIkZw+fZrVq1cX2j7WrFnDP//8w6pVq9i2bRszZswA4MCBAzg4OJgu33//fb63nZaWxqpVq6SVlChyJfXcGT9+PAkJCezevZu///6bN998k969e3Pq1KnCuhtCmCmJ5467uzvr1q3jp59+wsHBAWdnZxISEqhfvz5qtXxMFQWrJJ4jQhQHcu6IwmRt6QBClEajRo1i69at7N+/nwoVKpiWe3l5odfrSUhIMPtVISYmBi8vr3zvx8/PD4CaNWuSlZXFyy+/zLhx42jYsKHZ7BKenp5otVqsrKxyzYhxv33/+OOPpKamMnDgwHznEuJRldRz59KlS8yfP5/Tp08THBwMQEhICAcOHODLL79k0aJF+c4oRH6U1HMHoEOHDly6dImbN29ibW2Ni4sLXl5eVK5cOd/5hLif4niO5EVOhpiYGLy9vc3y3WsmMyEKWkk9d0TJIT9BCVGAFEVh1KhRbNy4kT179hAQEGB2fYMGDdBoNPz666+mZWFhYVy7do3GjRs/1r6NRiMGgwGj0YhOpyMwMNB0cXR0xMbGhgYNGpjt22g08uuvv95z399++y3PPPMM7u7uj5VLiLwo6edOamoqQK6WHVZWVjKDmChUJf3cuVv58uVxcXFhz549xMbG8swzzzxWPiGgeJ8jeREQEICXl5dZvqSkJP7888/HzifEg5T0c0eUHNJSSogCNHLkSFatWsXmzZtxdHQ09ad2dnZGp9Ph7OzMsGHDePPNN3F1dcXJyYnXX3+dxo0b89RTT5m2Ex4eTnJyMtHR0aSlpZl+HahZsyY2NjZ8//33aDQaateujVar5e+//+a9996jT58+aDSa++Z78803GTRoEA0bNuSJJ55g9uzZpKSkMGTIELP1wsPD2b9/P9u3by/4gyTEPZT0c6d69eoEBgbyyiuvMGPGDNzc3Ni0aRO7du1i69athXfgRJlX0s8dgKVLl1KjRg3c3d05dOgQb7zxBmPHjiUoKKhwDpooU4r7OZKcnEx4eLjp7ytXrnD8+HFcXV2pWLEiKpWKMWPG8PHHH1O1alUCAgIYP348Pj4+PPfcc4VyzISAkn/uAMTHx3Pt2jUiIyOB7KIZZLfyepTWXKKQWHTuPyFKGeCel6VLl5rWSUtLU0aMGKGUK1dOsbOzU7p3765ERUWZbadly5b33M6VK1cURVGU1atXK/Xr11ccHBwUe3t7pWbNmsrUqVOVtLS0h2acN2+eUrFiRcXGxkZ54oknlMOHD+da57333lP8/PyUrKysxzoeQuRVaTh3Lly4oPTo0UPx8PBQ7OzslDp16igrVqx47GMjxIOUhnPnnXfeUTw9PRWNRqNUrVpVmTlzpmI0Gh/72AihKMX/HNm7d+89tzto0CDTOkajURk/frzi6empaLVapW3btkpYWFhBHSIh7qk0nDtLly695zoTJkwooKMkCoJKURTlcYpaQgghhBBCCCGEEELkl4wpJYQQQgghhBBCCCGKnBSlhBBCCCGEEEIIIUSRk6KUEEIIIYQQQgghhChyUpQSQgghhBBCCCGEEEVOilJCCCGEEEIIIYQQoshJUUoIIYQQQgghhBBCFDkpSgkhhBBCCCGEEEKIIidFKSGEEEIIIYQQQghR5KQoJYQQQgghhBBCCCGKnBSlhBBCCCGEEEIIIUSRk6KUEEIIIYQQQgghhChyUpQSQgghhBBCCCGEEEVOilJCCCGEEEIIIYQQoshJUUoIIYQQQgghhBBCFDkpSgkhhBBCCCGEEEKIIidFKSGEEEIIIYQQQghR5KQoJYQQQgghhBBCCCGKnBSlhCgF/P39GTx4sOnvffv2oVKp2Ldvn8UyFVetWrWiVq1aRbKvzz//nMqVK2NlZUXdunWLZJ85Jk6ciEqlKtJ9irwZPHgw/v7+lo5RJDIzM3n77bfx8/NDrVbz3HPPWTqSuIsln4sqlYqJEycWyLYiIiJQqVTMmDGjQLYH/3sNvXnz5mNtpyDvpxAlnZwPQoh7kaKUEAVk2bJlqFQqVCoVv//+e67rFUXBz88PlUpF165dLZCwaLRq1cp0HNRqNU5OTgQFBTFgwAB27dpVJBkiIyOZOHEix48fL5L93csvv/zC22+/TdOmTVm6dClTp06977qDBw82HTOVSoVWq6VatWp89NFHpKenF2Fqy8rP43b38XrQpSwVZmNiYggNDaV69erY2dlhb29PgwYN+Pjjj0lISLBIpiVLlvD555/Tq1cvli9fztixYy2SQ5RMOcWmnIuVlRUVK1ake/fuFn19Ly4s9V536tQpevXqRaVKlbC1tcXX15f27dszb968Qt1vcXhvL0g5PyDe/d7v6elJq1atmDp1KnFxcZaOKP5DPnsIUTisLR1AiNLG1taWVatW0axZM7Plv/32G//++y9arbbQM7Ro0YK0tDRsbGwKfV/3UqFCBaZNmwZASkoK4eHhbNiwge+++47evXvz3XffodFoCm3/kZGRTJo0CX9//yJvoZRjz549qNVqvv322zw9Dlqtlm+++QaAxMRENm/ezJQpU7h06RLff/99YcctFvLzuK1cudLs7xUrVrBr165cy2vUqFHQMR/b119/jdFoLNBtHjlyhM6dO5OcnMyLL75IgwYNAPj777/59NNP2b9/P7/88kuB7jMv9uzZg6+vL1988UWR71uUHv369aNz585kZWVx7tw5Fi5cyI4dOzh8+LDFXuPzKi0tDWvrwvm4bYn3uj/++IPWrVtTsWJFXnrpJby8vLh+/TqHDx9mzpw5vP7664W27+Lw3l4YRo8eTaNGjcjKyiIuLo4//viDCRMmMGvWLNauXUubNm0sHVH8v5L82UOI4kyKUkIUsM6dO7Nu3Trmzp1r9kF01apVNGjQ4LG7AuSFWq3G1ta20PdzP87Ozrz44otmyz799FNGjx7NggUL8Pf3Z/r06RZKVzRiY2PR6XR5LgxaW1ubHbMRI0bQpEkTfvjhB2bNmoWnp2dhRS2R/vv8Onz4MLt27cq1/FEoikJ6ejo6ne6xt3UvBV2QTUhIoHv37lhZWXHs2DGqV69udv0nn3zC119/XSD7Sk1Nxc7OLs/rx8bG4uLiUiD7hsJ/bCwhJSUFe3t7S8co1urXr292bjdt2pRnnnmGhQsXsnjxYgsmuzej0Yher8fW1tai78WP6kHPyU8++QRnZ2eOHDmS69yOjY0tgnSlT/PmzenVq5fZshMnTtChQwd69uzJ2bNn8fb2tlA6cbdH/eyR3/dOIcoa6b4nRAHr168ft27dMuuqptfr+fHHH+nfv/89b2M0Gpk9ezbBwcHY2tri6enJK6+8wu3bt83WUxSFjz/+mAoVKmBnZ0fr1q05c+ZMru3da0ypAwcO8Pzzz1OxYkW0Wi1+fn6MHTuWtLQ0s9sOHjwYBwcHbty4wXPPPYeDgwPu7u6EhoaSlZX1yMfFysqKuXPnUrNmTebPn09iYqLZ9d999x0NGjRAp9Ph6upK3759uX79utk6OeNBHT16lCZNmqDT6QgICGDRokVm971Ro0YADBkyxNSUetmyZWbbOnv2LK1bt8bOzg5fX18+++yzPN2PzMxMpkyZQpUqVdBqtfj7+/P++++TkZFhWkelUrF06VJSUlLuu/+HUalUNGvWDEVRuHz5stl1O3bsoHnz5tjb2+Po6EiXLl3u+Ty4l4cd51GjRuHg4EBqamqu2/br1w8vLy/T82Dz5s106dIFHx8ftFotVapUYcqUKbmeJzmP24OOeV4ft/zI63nl7+9P165d+fnnn2nYsCE6nY7FixebzqO1a9cyadIkfH19cXR0pFevXiQmJpKRkcGYMWPw8PDAwcGBIUOGmD0P7ue/4/jcPR7OV199ZXpuNWrUiCNHjjx0e4sXL+bGjRvMmjUrV0EKwNPTkw8//NBs2YIFCwgODkar1eLj48PIkSNzdfG7+3xr0aIFdnZ2vP/++wBkZGQwYcIEAgMDTa8nb7/9tun+59ynvXv3cubMmVxdGh73sYHsYtyYMWPw8/NDq9USGBjI9OnTzVqh5ffYnj9/nt69e+Pu7o5OpyMoKIgPPvjAbJ0bN24wdOhQPD090Wq1BAcHs2TJkoc+TvC/bt6//fYbI0aMwMPDgwoVKpiuz8u5HR0dzZAhQ6hQoQJarRZvb2+effZZIiIizNbLy2N8N4PBgKurK0OGDMl1XVJSEra2toSGhpqWPew5cPd6Y8eOxd3dHUdHR5555hn+/fffPB2v+8lpOXLlypVc1z3scT558iSDBw+mcuXK2Nra4uXlxdChQ7l169Y993Xz5k169+6Nk5MTbm5uvPHGG7m6VatUKkaNGsX3339vOuY7d+40XfffMXRu3LjBsGHDTK+dAQEBvPbaa+j1egDi4+MJDQ2ldu3aODg44OTkxNNPP82JEydM28jLa+a6detMr/fly5fnxRdf5MaNG2ZZct7zL126ROfOnXF0dOSFF16436Hn0qVLBAcH37PY7OHhkWtZft7bH/c94s8//6RTp044OztjZ2dHy5YtOXjwoNm+csYKCw8PZ/Dgwbi4uODs7MyQIUPu+b733Xff8cQTT2BnZ0e5cuVo0aJFrlanj/OefD8hISHMnj2bhIQE5s+fb3ZdXl6Dct6/1qxZw/vvv4+Xlxf29vY888wzuY4/FPyxy895n5/7s3btWj755BMqVKiAra0tbdu2JTw8/J73p3PnzpQrVw57e3vq1KnDnDlzAFi6dCkqlYpjx47lut3UqVOxsrLKdZ7kx+O8d94tL+fOxYsX6dmzJ15eXtja2lKhQgX69u2b6zO2EMWeIoQoEEuXLlUA5ciRI0qTJk2UAQMGmK7btGmTolarlRs3biiVKlVSunTpYnbb4cOHK9bW1spLL72kLFq0SHnnnXcUe3t7pVGjRoperzet9+GHHyqA0rlzZ2X+/PnK0KFDFR8fH6V8+fLKoEGDTOvt3btXAZS9e/ealr3++utK586dlalTpyqLFy9Whg0bplhZWSm9evUyyzJo0CDF1tZWCQ4OVoYOHaosXLhQ6dmzpwIoCxYseOhxaNmypRIcHHzf66dMmaIAytatW03LPv74Y0WlUil9+vRRFixYoEyaNEkpX7684u/vr9y+fdts2z4+PoqHh4cyatQoZe7cuUqzZs0UQPn2228VRVGU6OhoZfLkyQqgvPzyy8rKlSuVlStXKpcuXTLbhp+fn/LGG28oCxYsUNq0aaMAyvbt2x96/wYNGqQASq9evZQvv/xSGThwoAIozz33nGmdlStXKs2bN1e0Wm2u/d9vm/b29rmW9+rVSwGUc+fOmZatWLFCUalUSqdOnZR58+Yp06dPV/z9/RUXFxflypUrpvUmTJig/PclPi/Hef/+/QqgrF271uy2KSkpir29vTJy5EjTsueee07p3bu38vnnnysLFy5Unn/+eQVQQkNDzW6bl2P+sMftYUaOHJnr/ub1vKpUqZISGBiolCtXTnn33XeVRYsWKXv37jWdR3Xr1lUaN26szJ07Vxk9erSiUqmUvn37Kv3791eefvpp5csvv1QGDBigAMqkSZMemnXQoEFKpUqVTH9fuXJFAZR69eopgYGByvTp05XPPvtMKV++vFKhQgWzrPfSpEkTRafTKRkZGXk6VjnPjXbt2inz5s1TRo0apVhZWeU6Li1btlS8vLwUd3d35fXXX1cWL16sbNq0ScnKylI6dOig2NnZKWPGjFEWL16sjBo1SrG2tlaeffZZRVEUJTk5WVm5cqVSvXp1pUKFCqbHMzo6ukAem5SUFKVOnTqKm5ub8v777yuLFi1SBg4cqKhUKuWNN954pGN74sQJxcnJSXFzc1Pee+89ZfHixcrbb7+t1K5d27ROdHS0UqFCBcXPz0+ZPHmysnDhQuWZZ55RAOWLL7546LHPeZ+oWbOm0rJlS2XevHnKp59+qihK3s/tJk2aKM7OzsqHH36ofPPNN8rUqVOV1q1bK7/99lu+H+P/PheHDh2quLi45HouLV++3PT+pihKnp4DOV588UUFUPr376/Mnz9f6dGjh1KnTh0FUCZMmPDA45Xz+H3++edmy0+cOKEASt++fc3Wy8vjPGPGDKV58+bK5MmTla+++kp54403FJ1OpzzxxBOK0WjMdQxr166tdOvWTZk/f77pvtz9/q4oigIoNWrUUNzd3ZVJkyYpX375pXLs2DHTdXffzxs3big+Pj6mY7do0SJl/PjxSo0aNUyvw0eOHFGqVKmivPvuu8rixYuVyZMnK76+voqzs7Ny48YNRVEe/pqZ81xr1KiR8sUXXyjvvvuuotPpcr2vDho0SNFqtUqVKlWUQYMGKYsWLVJWrFhx38ekQ4cOiqOjo3Lq1KkHPnaKkv/39sd5j/j1118VGxsbpXHjxsrMmTOVL774QqlTp45iY2Oj/Pnnn7ke13r16ik9evRQFixYoAwfPlwBlLffftss/8SJExVAadKkifL5558rc+bMUfr376+88847pnXyet7eS857zLp16+55vV6vV3Q6ndKwYUPTsry+BuVsu3bt2kqdOnWUWbNmKe+++65ia2urVKtWTUlNTTWtWxjHLq/nfX7vT7169ZQGDRooX3zxhTJx4kTFzs5OeeKJJ8z2/csvvyg2NjZKpUqVlAkTJigLFy5URo8erbRr105RFEVJSkpSdDqdMm7cuFzHvGbNmkqbNm3u/6D9x70+ezzOe2eOvJw7GRkZSkBAgOLj46N8/PHHyjfffKNMmjRJadSokRIREZHn+yBEcSBFKSEKyN1Fqfnz5yuOjo6mN/3nn39ead26taIoSq6i1IEDBxRA+f777822t3PnTrPlsbGxio2NjdKlSxezD87vv/++Ajy0KHX3B5Ac06ZNU1QqlXL16lXTspyiy+TJk83Wzfkg8DAPK0pt3LhRAZQ5c+YoiqIoERERipWVlfLJJ5+YrXfqhePAGwAA3QFJREFU1CnF2trabHnLli0VQJk5c6ZpWUZGhlK3bl3Fw8PD9MXjyJEjCqAsXbr0nvkAsw/dGRkZipeXl9KzZ88H3rfjx48rgDJ8+HCz5aGhoQqg7Nmzx7TsfoWme8lZNy4uTomLi1PCw8OVGTNmKCqVSqlVq5bp8b5z547i4uKivPTSS2a3j46OVpydnc2W/7coldfjbDQaFV9f31zHYu3atQqg7N+/37TsXs+pV155RbGzs1PS09NNy/J6zB/0uD3Mfz8Y5vW8UpTscxJQdu7cabZuznlUq1Ytsy+1/fr1U1QqlfL000+brd+4cWOzL/j3c7+ilJubmxIfH29avnnzZgVQfvrppwdur1y5ckpISMhD96so/3sd6dChg5KVlWVaPn/+fAVQlixZYlqW87gtWrTIbBsrV65U1Gq1cuDAAbPlixYtUgDl4MGDZtv47+tBQTw2U6ZMUezt7ZULFy6YLX/33XcVKysr5dq1a4qi5O/YtmjRQnF0dDR7PVQUxez1dtiwYYq3t7dy8+ZNs3X69u2rODs73/OcuFvO+0SzZs2UzMxM0/K8ntu3b9++Z5Hmbvl5jP/7XPz555/v+Zzr3LmzUrlyZdPfeX0O5Lxmjhgxwmy9/v3756soNWnSJCUuLk6Jjo5W9u3bp9SrV08BlPXr15utl5fH+V6P0Q8//JDr9S3nNfSZZ54xW3fEiBEKoJw4ccK0DFDUarVy5syZXNv+7/0cOHCgolarTQW+u+U819LT080eu5z7qNVqzd6b7/eaqdfrFQ8PD6VWrVpKWlqaafnWrVsVQPnoo49My3Le8999991cee7ll19+UaysrBQrKyulcePGyttvv638/PPPuYrnj/Le/qjvEUajUalatarSsWNHs/M1NTVVCQgIUNq3b29alvO4Dh061Gwb3bt3V9zc3Ex/X7x4UVGr1Ur37t1zPRaP8p58Lw8rSimKooSEhCjlypUz/Z3X16Ccbfv6+ipJSUmm9XLey3M+gxXGscvPeZ/f+1OjRg2zovmcOXMUwFQkzczMVAICApRKlSqZFT5z7muOfv36KT4+PmaP7T///JPvzyD3K0o9zntnXs+dY8eOPfT5I0RJId33hCgEvXv3Ji0tja1bt3Lnzh22bt16365769atw9nZmfbt23Pz5k3TpUGDBjg4OLB3714Adu/ejV6v5/XXX0elUpluP2bMmDxlunsMlpSUFG7evEmTJk1QFOWeTZhfffVVs7+bN2+eqxvZo3BwcADgzp07AGzYsAGj0Ujv3r3N7r+XlxdVq1Y13f8c1tbWvPLKK6a/bWxseOWVV4iNjeXo0aN5znB3/38bGxueeOKJh96/7du3A/Dmm2+aLR83bhwA27Zty9P+7yUlJQV3d3fc3d0JDAwkNDSUpk2bsnnzZtPjvWvXLhISEujXr5/ZsbKysuLJJ5/MdazultfjrFKpeP7559m+fTvJycmm269ZswZfX1+zAfzvfk7duXOHmzdv0rx5c1JTUzl//rzZ/h/1mD+qvJ5XOQICAujYseM9tzVw4ECzcaCefPJJFEVh6NChZus9+eSTXL9+nczMzEfK3KdPH8qVK2f6u3nz5gAPPUZJSUk4OjrmaR85ryNjxoxBrf7fR4CXXnoJJyenXM9hrVabqzvXunXrqFGjBtWrVzc7tjldqh70PMy5/eM+NuvWraN58+aUK1fObBvt2rUjKyuL/fv3m63/sGMbFxfH/v37GTp0KBUrVjS7bc75pygK69evp1u3biiKYrbfjh07kpiYyD///PPA+57jpZdewsrKyvR3Xs/tnHHq9u3bl6urY478PsZ3a9OmDeXLl2fNmjWmZbdv32bXrl306dPHtCyvz4Gc18zRo0eb7Sev71s5JkyYgLu7O15eXrRq1YpLly4xffp0evToYbZeXs6hu1+30tPTuXnzJk899RTAPR+/kSNHmv2dM5B3zn3L0bJlS2rWrPnA+2E0Gtm0aRPdunWjYcOGua7Pea5ptVrTY5eVlcWtW7dwcHAgKCgoT8+xv//+m9jYWEaMGGE2plWXLl2oXr36PZ8Dr7322kO3C9C+fXsOHTrEM888w4kTJ/jss8/o2LEjvr6+bNmyxbReft/bH+c94vjx41y8eJH+/ftz69Yt075SUlJo27Yt+/fvzzW5xL0+49y6dYukpCQANm3ahNFo5KOPPjI7j4ACeU/OKwcHB9PnpUd5DRo4cKDZ+0OvXr3w9vY2PX8L49jl9bx/lPszZMgQs7E6/3uOHzt2jCtXrjBmzJhcXUzv/uw8cOBAIiMjzR6j77//Hp1OR8+ePXlcj/Pemddzx9nZGYCff/75nl1PhShJZKBzIQqBu7s77dq1Y9WqVaSmppKVlZVrEMscFy9eJDEx8Z5jMcD/Bg69evUqAFWrVs21r7s/hN/PtWvX+Oijj9iyZUuuLzP/7Xtua2uLu7u72bJy5crd90tQfuQUOnI+JF28eBFFUXLdrxz/HRTax8cn1wCs1apVA7LHj8n5cvEgFSpUMPtwAtn37+TJkw+83dWrV1Gr1QQGBpot9/LywsXFxfQYPQpbW1t++uknAP79918+++wz02DpOS5evAhw35l4nJyc7rv9/BznPn36MHv2bLZs2UL//v1JTk5m+/btvPLKK2bH7cyZM3z44Yfs2bPH9GE0x3+fU496zB9VXs+rHAEBAffd1n+LFDkfBP38/HItNxqNJCYm4ubmlu/M/91Pznn9sPPOycnJ9KXlYXKeo0FBQWbLbWxsqFy5cq7nsK+vb67B+i9evMi5c+dyvUbkeNhgxwXx2Fy8eJGTJ0/mOcPDjm3OF5patWrdN3dcXBwJCQl89dVXfPXVVw/cb3R0tNlyZ2dns3P5v/cpr+e2Vqvl/9i787Co6v7/48+ZYYBhF0QWA1FwQUXNNBUXJPc1NddyQe/qbjHLtMy7vO/M1OxOKy2zvDOXLNzNJXPXXNPczRUVcWEREZB1hpn5/cGP+Yaggg4clvfjuuZSzpw55zXLOTPzns8yY8YMxo0bh5eXFy1btqRnz54MHz4cb29voPjP8d/Z2Njw3HPP8dNPP5GdnY2dnR2rV6/GYDDkK0oV9TWQd84MDAzMd/292R7m5ZdfZsCAAajVatzc3CzjNt2rKMdQUlISkydPJjIyssDrpLBxWO49ZwYGBqJWqwuM4fWgc0ieW7dukZqa+sDXGeQWr7788kvmzp3LlStX8o3TV5Rzy/1eAwD16tVj7969+ZbZ2NjkG9vsYZo3b87q1avR6/WcOHGCNWvW8Pnnn9O/f3+OHz9O/fr1i/3e/jjvEXnHz4gRI+67TkpKSr7PSg96rbi4uHDp0iXUavUDC42P855cVGlpaZbPS8U5B+W59/FXqVQEBQVZXr8l8dgV9bh/lPvzsGP80qVLwIPP5ZBbXPXx8WHp0qV06NABk8nEzz//zLPPPlvkH3ke5HHeO4t67NSsWZO3336bWbNmsXTpUtq2bUvv3r0ZOnSo5XOKEOWFFKWEKCHPP/88L730EnFxcXTr1u2+M1CZTCaqVavG0qVLC73+fm9exWE0GunUqRNJSUlMmDCBevXq4ejoyI0bN4iIiCjwK9jff8G3ttOnTwNYCjsmkwmVSsWmTZsK3W9eyyprut/9M5vNRbr9vR+crUGj0dCxY0fL3126dKFevXr885//tPz6nPc8LVmyxPIF9O8eNO14cR7nli1bEhAQwPLly3n++edZv349mZmZ+b6UJicnExYWhouLCx999BGBgYHY29tz9OhRJkyYUOTXVFEf8+Iq7nH1oNnc7pfd2vfpUbdXr149jh8/jl6vL/Jsj0VV2ONiMpkICQlh1qxZhd7m3mJdYbd/3OfGZDLRqVMn3n333UK3kVeozmON5yrvNT106ND7foFr1KgRQIGZsn744QciIiIsf997n4pzbL/11lv06tWLtWvXsnnzZiZNmsT06dPZsWMHTz75ZJHvz/0MHjyYb7/9lk2bNtGnTx+WL19OvXr1aNy4cb68j/MaKK7atWvnOz/eT1Ge54EDB7J//37eeecdmjRpgpOTEyaTia5duxY4bxXmfud/a84IOW3aNCZNmsSoUaOYMmUK7u7uqNVq3nrrrSJlLK6/t8wqDltbW5o3b07z5s2pU6cOI0eOZMWKFfznP/8p9nv74xyjeY/Jf//7X5o0aVLoOtbc3737fZT35KIwGAxcuHDBUmApzjmoqJR67P6+7+LcH2vtW6PR8PzzzzN//nzmzp3Lvn37uHnzplVm8IXHe+8szrEzc+ZMIiIi+OWXX9iyZQtjxoxh+vTpHDx4sFiFZiGUJkUpIUpI3759+ec//8nBgwfzdYW4V2BgINu2baN169YP/FBbo0YNIPcXlFq1almW37p166EtKU6dOsWFCxdYtGgRw4cPtyz/+wyBpcFoNPLTTz/h4OBg6QYWGBiI2WymZs2aBb5IFubmzZsFpqu+cOECgGVGs5IoGkHuc2Aymbh48SLBwcGW5fHx8SQnJ1ueI2vw8fFh7NixTJ48mYMHD9KyZUvLr47VqlUr0he0vyvu4zxw4EC+/PJLUlNTWbZsGQEBAflaoe3atYvbt2+zevVq2rVrZ1le2GxYRWXN562ox1VF0KtXLw4cOMCqVasYMmTIA9fNe42eP38+33lEr9dz5cqVIr2uAgMDOXHiBB06dHik58waz01gYCBpaWnFPg7uJ++xyCuaFyZvFimj0fjQ/d57bm3QoMED1y/usR0YGMi4ceMYN24cFy9epEmTJsycOZMff/zxsZ/jdu3a4ePjw7Jly2jTpg07duwoMANhUV8DeefMS5cu5Wslcf78+Yfex5Jw584dtm/fzuTJk/n3v/9tWZ7XWqQwFy9ezNcKKioqCpPJlG8GzaLy9PTExcXlga8zgJUrVxIeHs7333+fb3lycjJVq1a1/H2/x/7vr4F7W/GcP3/equ9VefK6I8bGxgLFf88pivvd37zjx8XFxWrnhMDAQEwmE2fOnLlvseZx3pOLYuXKlWRmZlq6LxfnHJTn3te22WwmKirKUuwpiceuqMf9o9yfh8m7P6dPn37oNocPH87MmTNZv349mzZtwtPT877d+K2VrSjnzeIeOyEhIYSEhPDBBx+wf/9+Wrduzbx58/j444+tGV+IEiVjSglRQpycnPjmm2/48MMP6dWr133XGzhwIEajkSlTphS4LicnxzKFd8eOHdFqtcyZMyffL0JffPHFQ7Pk/dLy99uZzWbL9LilwWg0MmbMGM6ePcuYMWMszdr79euHRqNh8uTJBX7pMpvNBabpzsnJsUwJD7lftL799ls8PT156qmnACwFqwdNf/4ounfvDhR8zPN+9erRo4dV9/fGG2/g4ODAJ598AuS2nnJxcWHatGkYDIYC69+6deu+2yru4zxo0CCys7NZtGgRv/32GwMHDsx3fWGvKb1ez9y5c4t3J//Gms9bUY+riuCVV17Bx8eHcePGWQq0f5eQkGD5cNqxY0dsbW2ZPXt2vufu+++/JyUlpUiv4YEDB3Ljxg3mz59f4LrMzEzS09MfevvHfW4GDhzIgQMH2Lx5c4HrkpOTiz2ul6enJ+3atWPBggXExMTkuy7vcdJoNDz33HOsWrWq0KLC34+/jh075rvc23LqXkU9tjMyMsjKysp3XWBgIM7OzpYpxR/3OVar1fTv35/169ezZMkScnJy8rWShKK/Brp16wbA7Nmz861TlPetklDYeQsenOfrr7/O9/ecOXOA/7tvxaFWq+nTpw/r16/nzz//LHD9319r92ZcsWJFgWnq73fObNasGdWqVWPevHn5pprftGkTZ8+efaz3qp07dxbaKiVvHKG8IkRx33OK4n7396mnniIwMJDPPvss31iIeR703ng/ffr0Qa1W89FHHxVonZZ3fx7nPflhTpw4wVtvvUWVKlUs45oV5xyUZ/Hixfm6d69cuZLY2FjL67ckHruiHvePcn8epmnTptSsWZMvvviiwOvk3tdho0aNaNSoEf/73/9YtWoVgwcPfuzWbQ9S1PNmUY+d1NTUAu91ISEhqNXqfMe9EOWBtJQSogQ9qI9+nrCwMP75z38yffp0jh8/TufOndFqtVy8eJEVK1bw5Zdf0r9/fzw9PRk/fjzTp0+nZ8+edO/enWPHjrFp06Z8v5wWpl69egQGBjJ+/Hhu3LiBi4sLq1atssoYUYVJSUnhxx9/BHK/REVFRbF69WouXbrE4MGD830ZDQwM5OOPP2bixIlER0fTp08fnJ2duXLlCmvWrOHll19m/PjxlvV9fX2ZMWMG0dHR1KlTh2XLlnH8+HG+++47Sz/7wMBA3NzcmDdvHs7Ozjg6OtKiRYsijfnxII0bN2bEiBF89913lu5rhw4dYtGiRfTp04fw8PDH2v69PDw8GDlyJHPnzuXs2bMEBwfzzTffMGzYMJo2bcrgwYPx9PQkJiaGjRs30rp1a7766qtCt1Xcx7lp06YEBQXx/vvvk52dXeBLaWhoKFWqVGHEiBGMGTMGlUrFkiVLHqs7njWft6IeVxVBlSpVWLNmDd27d6dJkyYMHTrUUqA9evQoP//8M61atQJyiy8TJ05k8uTJdO3ald69e3P+/Hnmzp1L8+bNi9R1YdiwYSxfvpxXXnmFnTt30rp1a4xGI+fOnWP58uVs3ry50EGc81jjuXnnnXdYt24dPXv2JCIigqeeeor09HROnTrFypUriY6Ofuh58V6zZ8+mTZs2NG3alJdffpmaNWsSHR3Nxo0bOX78OACffPIJO3fupEWLFrz00kvUr1+fpKQkjh49yrZt20hKSirWPvO4uLgU6di+cOECHTp0YODAgdSvXx8bGxvWrFlDfHw8gwcPBqzzHA8aNIg5c+bwn//8h5CQkHwtQ6Hor4EmTZowZMgQ5s6dS0pKCqGhoWzfvp2oqKhHepwel4uLC+3atePTTz/FYDBQvXp1tmzZ8sAWnleuXKF379507dqVAwcO8OOPP/L888/n685YHNOmTWPLli2EhYXx8ssvExwcTGxsLCtWrGDv3r24ubnRs2dPPvroI0aOHEloaCinTp1i6dKl+Vq+wYPPmTNmzGDkyJGEhYUxZMgQ4uPj+fLLLwkICGDs2LGPlB1yfyzJyMigb9++1KtXD71ez/79+y0tavMGdy7ue05RPOj+/u9//6Nbt240aNCAkSNHUr16dW7cuMHOnTtxcXGxjNlYVHnvf1OmTKFt27b069cPOzs7Dh8+jK+vL9OnTy/ycfswe/bsISsryzKo/b59+1i3bh2urq6sWbMmX9fA4p6D3N3dadOmDSNHjiQ+Pp4vvviCoKAgXnrpJSC3UGrtx644x721z6lqtZpvvvmGXr160aRJE0aOHImPjw/nzp3jr7/+KvBDxvDhwy2vQ2t13bufop43i3rs7Nixg9GjRzNgwADq1KlDTk4OS5YssRT7hChXrD6fnxCVVN5U34VN8/x3NWrUMPfo0aPA8u+++8781FNPmXU6ndnZ2dkcEhJifvfdd803b960rGM0Gs2TJ082+/j4mHU6nbl9+/bm06dPm2vUqGEeMWKEZb28qXN37txpWXbmzBlzx44dzU5OTuaqVauaX3rpJfOJEycKTH87YsQIs6OjY4F8eVMBP0zeVLh5FycnJ3Pt2rXNQ4cONW/ZsuW+t1u1apW5TZs2ZkdHR7Ojo6O5Xr165tdff918/vz5fNtu0KCB+c8//zS3atXKbG9vb65Ro4b5q6++KrC9X375xVy/fn2zjY1NvvtY2BT1eff771Oj34/BYDBPnjzZXLNmTbNWqzX7+fmZJ06caM7KyiqwvcIex8I8aN1Lly6ZNRpNgee3S5cuZldXV7O9vb05MDDQHBERYf7zzz8t69zv+SrK45zn/fffNwPmoKCgQrPt27fP3LJlS7NOpzP7+vpapga/97VXnMf8fs/bwxQ2LbPZXLTj6n7H5P2m677fsZ73mN+6deuBWe+933nT2f/3v/8tsC73TJ/9IDdv3jSPHTvWXKdOHbO9vb3ZwcHB/NRTT5mnTp1qTklJybfuV199Za5Xr55Zq9Wavby8zK+++mqB6bPv97yZzblTzs+YMcPcoEEDs52dnblKlSrmp556yjx58uR8+3rQNh7nuTGbc6djnzhxojkoKMhsa2trrlq1qjk0NNT82WefWaanL+5je/r0aXPfvn3Nbm5uZnt7e3PdunXNkyZNyrdOfHy8+fXXXzf7+fmZtVqt2dvb29yhQwfzd999V2jOv3vY+8TDju3ExETz66+/bq5Xr57Z0dHR7Orqam7RooV5+fLlBbZVlOf4fuc9k8lk9vPzMwPmjz/+uNCsRX0NZGZmmseMGWP28PAwOzo6mnv16mW+du1akV7bD3r+irrevfu5fv265Tl2dXU1DxgwwHzz5s0C6+Udz2fOnDH379/f7OzsbK5SpYp59OjR5szMzAL7eP311wvNVtj9vHr1qnn48OFmT09Ps52dnblWrVrm119/3TLVfVZWlnncuHGW9/rWrVubDxw4YA4LCzOHhYXl29aDzpnLli0zP/nkk2Y7Ozuzu7u7+YUXXjBfv3493+2L815lNpvNmzZtMo8aNcpcr149s5OTk9nW1tYcFBRkfuONN8zx8fEF1i/Oe/u9ivsecezYMXO/fv3MHh4eZjs7O3ONGjXMAwcONG/fvt2yzv3O03nH5pUrV/ItX7BggeUxrFKlijksLMy8devWfOsU5T25MHnvMXkXrVZr9vT0NLdr1848depUc0JCQqG3K8o5KG/bP//8s3nixInmatWqmXU6nblHjx7mq1evFtimtR+74hz3xbk/974f5x37935W2Lt3r7lTp05mZ2dns6Ojo7lRo0bmOXPmFLjfsbGxZo1GY65Tp06hj/XDFPbZwxrvnWbzw4+dy5cvm0eNGmUODAw029vbm93d3c3h4eHmbdu2PdJ9EUJJKrO5hEaZFUIIK2vfvj2JiYkPHY9DCCGEEKKy2rVrF+Hh4axYsaLCtAouCYmJifj4+PDvf/+bSZMmKR1HiEpLxpQSQgghhBBCCFGpLFy4EKPRyLBhw5SOIkSlJmNKCSGEEEIIIYSoFHbs2MGZM2eYOnUqffr0eaTZNIUQ1iNFKSGEEEIIIYQQlcJHH33E/v37ad26tWVGTSGEcmRMKSGEEEIIIYQQQghR6mRMKSGEEEIIIYQQQghR6qQoJYQQQgghhBBCCCFKnRSlhBBCCCGEEEIIIUSpK9cDnZtMJm7evImzszMqlUrpOEIIIYQQQgghhBCVntls5u7du/j6+qJW3789VLkuSt28eRM/Pz+lYwghhBBCCCGEEEKIe1y7do0nnnjivteX66KUs7MzkHsnXVxcFE4jhBBCCCGEEEIIIVJTU/Hz87PUbe6nXBel8rrsubi4SFFKCCGEEEIIIYQQogx52FBLMtC5EEIIIYQQQgghhCh1UpQSQgghhBBCCCGEEKVOilJCCCGEEEIIIYQQotSV6zGlhBBCCCGEEEIIazAajRgMBqVjCFEuaLVaNBrNY29HilJCCCGEEEIIISots9lMXFwcycnJSkcRolxxc3PD29v7oYOZP4gUpYQQQgghhBBCVFp5Balq1arh4ODwWF+whagMzGYzGRkZJCQkAODj4/PI25KilBBCCCGEEEKISsloNFoKUh4eHkrHEaLc0Ol0ACQkJFCtWrVH7sqn6EDnRqORSZMmUbNmTXQ6HYGBgUyZMgWz2axkLCGEEEIIIYQQlUDeGFIODg4KJxGi/Mk7bh5nLDZFW0rNmDGDb775hkWLFtGgQQP+/PNPRo4ciaurK2PGjFEymhBlWnp6OlqtluTkZNzc3DAYDDg6OiodSwghhBBCiHJJuuwJUXzWOG4UbSm1f/9+nn32WXr06EFAQAD9+/enc+fOHDp0SMlYQpRpZrOZVatW4eXlZbmsWrVKWhgKIYQQQgghrGrXrl2oVCrLIPALFy7Ezc1N0UylJTo6GpVKxfHjx5WOUqEpWpQKDQ1l+/btXLhwAYATJ06wd+9eunXrpmQsIcqs9PR0lixZQs+ePWnRshUqjQ3NmzenZ8+eLFmyhPT0dKUjCiGEEEIIIUpBREQEKpWKV155pcB1r7/+OiqVioiICKvuc9CgQZbv7yUp776pVCq0Wi1eXl506tSJBQsWYDKZSmR/ffr0sfp2xcMpWpR67733GDx4MPXq1UOr1fLkk0/y1ltv8cILLxS6fnZ2NqmpqfkuQlQmWq2WN998k6EjRrJizS8s332KyMhIBg8ezJtvvolWq1U6ohBCCCGEEJVSeno6er2ehIQE9Hp9qfxg7OfnR2RkJJmZmZZlWVlZ/PTTT/j7+1t9fzqdjmrVqll9u4Xp2rUrsbGxREdHs2nTJsLDw3nzzTfp2bMnOTk5pZJBlDxFi1LLly9n6dKl/PTTTxw9epRFixbx2WefsWjRokLXnz59Oq6urpaLn59fKScWQlnJyckkJyfzV3w2ey7dpX/reixdsYatW7eSnJxMSkqK0hGFEEIIIYSodLKysvj000/zDbHx6aefkpWVVaL7bdq0KX5+fqxevdqybPXq1fj7+/Pkk0/mW9dkMjF9+nTLRGONGzdm5cqV+db59ddfqVOnDjqdjvDwcKKjo/Ndf2/3vUuXLvHss8/i5eWFk5MTzZs3Z9u2bfluExAQwLRp0xg1ahTOzs74+/vz3XffPfS+2dnZ4e3tTfXq1WnatCn/+te/+OWXX9i0aRMLFy60rJecnMyLL76Ip6cnLi4uPPPMM5w4ccJy/YcffkiTJk349ttv8fPzw8HBgYEDB1q+O3344YcsWrSIX375xdI6a9euXZbbX758mfDwcBwcHGjcuDEHDhx4aHZRdIoWpd555x1La6mQkBCGDRvG2LFjmT59eqHrT5w4kZSUFMvl2rVrpZxYCGW5ubnh5ubGswNfoF2QK7/+lcTw5wfTqVMn3NzccHV1VTqiEEIIIYQQ5ZrZbCY9Pb3Il9TUVKZPn85HH31kGXspOTmZjz76iOnTp5OamlrkbT3KOLGjRo3ihx9+sPy9YMECRo4cWWC96dOns3jxYubNm8dff/3F2LFjGTp0KLt37wbg2rVr9OvXj169enH8+HFefPFF3nvvvQfuOy0tje7du7N9+3aOHTtG165d6dWrFzExMfnWmzlzJs2aNePYsWO89tprvPrqq5w/f77Y9/WZZ56hcePG+YpwAwYMICEhgU2bNnHkyBGaNm1Khw4dSEpKsqwTFRXF8uXLWb9+Pb/99pslB8D48eMZOHCgpWVWbGwsoaGhltu+//77jB8/nuPHj1OnTh2GDBkiLbWsSNHZ9zIyMlCr89fFNBrNffuI2tnZYWdnVxrRhCiTDAYDX375JX0HDGbunpucjs3gwIlEIiMj2bBhAwaDAVtbW6VjCiGEEEIIUW5lZGTg5ORUpHWrVq1KdHQ0s2fPLvT62bNn8+677xIQEEBiYuJDt5eWllbsWbWHDh3KxIkTuXr1KgD79u0jMjIyX2uf7Oxspk2bxrZt22jVqhUAtWrVYu/evXz77beEhYXxzTffEBgYyMyZMwGoW7cup06dYsaMGffdd+PGjWncuLHl7ylTprBmzRrWrVvH6NGjLcu7d+9uKQJNmDCBzz//nJ07d1K3bt1i3VeAevXqcfLkSQD27t3LoUOHSEhIsNQKPvvsM9auXcvKlSt5+eWXgdyWbIsXL6Z69eoAzJkzhx49ejBz5ky8vb3R6XRkZ2fj7e1dYH/jx4+nR48eAEyePJkGDRoQFRVFvXr1ip1dFKRoUapXr15MnToVf39/GjRowLFjx5g1axajRo1SMpYQZZajoyMvDB3GzB3XOXk9FVQqrlKVtZu2MXLYMJnKVgghhBBCiFLk7e1NQkKCpYXUvZKTk7l16xbe3t5FKko9Ck9PT3r06MHChQsxm8306NGDqlWr5lsnKiqKjIwMOnXqlG+5Xq+3dPM7e/YsLVq0yHd9XgHrftLS0vjwww/ZuHEjsbGx5OTkkJmZWaClVKNGjSz/V6lUlsftUZjNZsv3nhMnTpCWloaHh0e+dTIzM7l06ZLlb39/f0tBKu9+mUwmzp8/X2gh6n7ZfXx8AEhISJCilJUoWpSaM2cOkyZN4rXXXiMhIQFfX1/++c9/8u9//1vJWEKUaWt+P87pWAfqVHMgJyeH6BQTNtVDpCAlhBBCCCGEFTg4OJCWllbk9bVaLW5uboUWptzc3PD19eXgwYNF3vejGDVqlKVl0tdff13g+rz7s3HjxnzFGeCxeiONHz+erVu38tlnnxEUFIROp6N///7o9fp86907IZNKpXrkWfTOnj1LzZo1gdz75ePjk69VWJ6/j331OP6ePe87V0nMAFhZKVqUcnZ25osvvuCLL75QMoYQ5cqaPy6h8Q0hNfokrk46UNVgwx8XGN4+WOloQgghhBBClHsqlapYXejS09MZM2YMH330UYHrxowZg8FgKHaXvOLq2rUrer0elUpFly5dClxfv3597OzsiImJISwsrNBtBAcHs27dunzLHlZM27dvHxEREfTt2xfILRLdOzi6Ne3YsYNTp04xduxYIHeg97i4OGxsbAgICLjv7WJiYrh58ya+vr5A7v1Sq9WW7oO2trYYjcYSyy3uT9GilBCieHKMRowuT6ABWtX1xt/bg4tHjdh6BXEtLhE/76oP3YYQQgghhBDCehwdHZk4cSKQO4ZUcnIybm5ujBkzhokTJ2Jvb1/iGTQaDWfPnrX8/17Ozs6MHz+esWPHYjKZaNOmDSkpKezbtw8XFxdGjBjBK6+8wsyZM3nnnXd48cUXOXLkSL5Z7gpTu3ZtVq9eTa9evVCpVEyaNMlqrYiys7OJi4vDaDQSHx/Pb7/9xvTp0+nZsyfDhw8HoGPHjrRq1Yo+ffrw6aefUqdOHW7evMnGjRvp27cvzZo1A8De3p4RI0bw2WefkZqaypgxYxg4cKCl615AQACbN2/m/PnzeHh4yARSpUjR2feEEMWz49BpbJ2qYMhKp3ubJ2neIIjMW1dRa2z4eethpeMJIYQQQghRKdnb2/Puu+8SHx9PQkIC8fHxvPvuu6VSkMrj4uKCi4vLfa+fMmUKkyZNYvr06QQHB9O1a1c2btxo6Qrn7+/PqlWrWLt2LY0bN2bevHlMmzbtgfucNWsWVapUITQ0lF69etGlSxeaNm1qlfvz22+/4ePjQ0BAAF27dmXnzp3Mnj2bX375xVJ4U6lU/Prrr7Rr146RI0dSp04dBg8ezNWrV/Hy8rJsKygoiH79+tG9e3c6d+5Mo0aNmDt3ruX6l156ibp169KsWTM8PT3Zt2+fVe6DeDiV+VHmnCwjUlNTcXV1JSUl5YEHnxAVxbtfrybOpQH6m2eInJDbRPaNL1aS4hFCzs3T/DThOYUTCiGEEEIIUX5kZWVx5coVatasWaoFJFF6PvzwQ9auXcvx48eVjlLhPOj4KWq9RlpKCVGOXE3LPWRruf7foOZdn6qV+x/3WtxNz1QilhBCCCGEEEIIUWxSlBKinLibnommagAAnZvVtizv1roJWSm3sLF3IHJL0Wb1EEIIIYQQQgghlCZFKSHKifW/H8XGVkd2aiLtmv7fTHtqtRrnzFgA9l9MVCqeEEIIIYQQQpQ5H374oXTdK8OkKCVEObHv3E0A7NJuolbnP3TbBefOGpHhVJ0cmcpUCCGEEEIIIUQ5IEUpIcqJhBxHAOr7OBa4bkCHpzFkpmHn7MH63UdLO5oQQgghhBBCCFFsUpQSohy4EX8bu2oBAPRuE1LgegedHZo7VwDYcjy6FJMJIYQQQgghhBCPRopSQpQDa38/hlqtITPxGvVr+RW6zlN+zgAkqtxLM5oQQgghhBBCCPFIpCglRDlwJPoOAK7GO/dd5/kuLTDmGNBVfYK9x86VVjQhhBBCCCGEEOKRSFFKiHLgrtYDgGY1798KysvDjZyEKADW7j9TKrmEEEIIIYQQQohHJUUpIcq4E+ej0XlUx2TMoU9Y0weuG+yRe0hfzbArjWhCCCGEEEII8Ui+++47/Pz8UKvVfPHFF4Uu+/DDD2nSpInlNhEREfTp08fyd/v27XnrrbdKNXeeXbt2oVKpSE5OLvV9R0dHo1KpOH78eKnv29qkKCVEGbdh/2kAsm9F4121ygPXHdwht2hlX60W56NvlHg2IYQQQgghROmbN28ezs7O5OTkWJalpaWh1Wpp3759vnXziieXLl0CICAgAJVKRWRkZIHtNmjQAJVKxcKFCy3L8tb/++WJJ554rPypqamMHj2aCRMmcOPGDV5++eVCl40fP57t27ffdzurV69mypQpRd6vkoWkR3VvIa6ikaKUEGXc2YQsAHxsMx+6br2aT5AZdwmVWs2y7UdLOpoQQgghhBBCAeHh4aSlpfHnn39alu3Zswdvb2/++OMPsrKyLMt37tyJv78/gYGBlmV+fn788MMP+bZ58OBB4uLicHR0LLC/jz76iNjYWMvl2LFjj5U/JiYGg8FAjx498PHxwcHBodBlTk5OeHh43Hc77u7uODs7P1YW8X/0en2p71OKUkKUYTlGIwbn3F8h2tQv2q8Rfva5xasziTkPWVMIIYQQQghRHtWtWxcfHx927dplWbZr1y6effZZatasycGDB/MtDw8Pz3f7F154gd27d3Pt2jXLsgULFvDCCy9gY2NTYH/Ozs54e3tbLp6eng/MN2HCBOrUqYODgwO1atVi0qRJGAwGABYuXEhISAgAtWrVsrTMundZdHR0ge5797q3+96SJUto1qyZJe/zzz9PQkICkNvlLe9xqFKlCiqVioiICABMJhPTp0+nZs2a6HQ6GjduzMqVK/Pt69dff6VOnTrodDrCw8OJjo5+4GMAMGvWLEJCQnB0dMTPz4/XXnuNtLQ0y/WF3b8vvviCgIAAy/WLFi3il19+sbRS+/tzfvnyZcLDw3FwcKBx48YcOHAg37ZWrVpFgwYNsLOzIyAggJkzZ+a7PiAggClTpjB8+HBcXFx4+eWX0ev1jB49Gh8fH+zt7alRowbTp09/6H19VFKUEqIM2/3nGeycq5CTlUHPNk8W6TZ9QoMB0HgGcisppSTjCSGEEEIIUeGYzWaM+uziXQz63NsZ9IX/XcSL2Wwucs7w8HB27txp+Xvnzp20b9+esLAwy/LMzEz++OOPAkUpLy8vunTpwqJFiwDIyMhg2bJljBo1ygqPYG4Ra+HChZw5c4Yvv/yS+fPn8/nnnwMwaNAgtm3bBsChQ4eIjY1lwIABBZb5+fkVe78Gg4EpU6Zw4sQJ1q5dS3R0tKXw5Ofnx6pVqwA4f/48sbGxfPnllwBMnz6dxYsXM2/ePP766y/Gjh3L0KFD2b17NwDXrl2jX79+9OrVi+PHj/Piiy/y3nvvPTSPWq1m9uzZ/PXXXyxatIgdO3bw7rvvFvn+jB8/noEDB9K1a1dLK7XQ0FDL9e+//z7jx4/n+PHj1KlThyFDhli6dB45coSBAwcyePBgTp06xYcffsikSZPydc0E+Oyzz2jcuDHHjh1j0qRJzJ49m3Xr1rF8+XLOnz/P0qVLLUWyklCwBCqEKDO2Ho0Cp/qYkqJx0BWtKNXmyXrM2bMbnYcvP2/9gzGDOpdwSiGEEEIIISoOk0HP4Q/eLvbtXGvXo/YLo0g4fIBqzVtxbuG3pFw8V6xtNP94Fhrbok1aFB4ezltvvUVOTg6ZmZkcO3aMsLAwDAYD8+bNA+DAgQNkZ2cXKEoBjBo1inHjxvH++++zcuVKAgMD79sqacKECXzwwQeWv6dNm8aYMWPum+3v6wYEBDB+/HgiIyN599130el0li55np6eeHt7AxS6rLj+XlSrVasWs2fPpnnz5qSlpeHk5IS7e+5s5tWqVcPNzQ2A7Oxspk2bxrZt22jVqpXltnv37uXbb78lLCyMb775hsDAQEtLo7p163Lq1ClmzJjxwDx/b8UVEBDAxx9/zCuvvMLcuXOLdH+cnJzQ6XRkZ2cX+piMHz+eHj16ADB58mQaNGhAVFQU9erVY9asWXTo0IFJkyYBUKdOHc6cOcN///tfS6EO4JlnnmHcuHGWv2NiYqhduzZt2rRBpVJRo0aNImV9VNJSSogyLDpVBUBNl6LfRq1W425MBOBwdGpJxBJCCCGEEELcI+XiORIOH8A3rCMJhw8UuyBVXO3btyc9PZ3Dhw+zZ88e6tSpg6enJ2FhYZZxpXbt2kWtWrXw9/cvcPsePXqQlpbG77//zoIFCx7YSuqdd97h+PHjlsvw4cMBeOWVV3BycrJc8ixbtozWrVvj7e2Nk5MTH3zwATExMdZ/EO5x5MgRevXqhb+/P87OzoSFhQE8cN9RUVFkZGTQqVOnfPdl8eLFlsHhz549S4sWLfLdLq+A9SDbtm2jQ4cOVK9eHWdnZ4YNG8bt27fJyMh4jHv5fxo1amT5v4+PD4Clu+LZs2dp3bp1vvVbt27NxYsXMRqNlmXNmjXLt05ERATHjx+nbt26jBkzhi1btlgl6/1ISykhyqi0jCzUHgEAdHqqdrFu26mxH+tiweBWg8xsPTo72xJIKIQQQgghRMWj1trS/ONZxb+hSoXaRovJmINPuw54hbaDYnTHy9t3UQUFBfHEE0+wc+dO7ty5YynA+Pr64ufnx/79+9m5cyfPPPNMobe3sbFh2LBh/Oc//+GPP/5gzZo1991X1apVCQoKKrD8o48+Yvz48fmWHThwgBdeeIHJkyfTpUsXXF1diYyMLDCekbWlp6fTpUsXunTpwtKlS/H09CQmJoYuXbo8cADvvDGeNm7cSPXq1fNdZ2dXtFZrhYmOjqZnz568+uqrTJ06FXd3d/bu3cs//vEP9Ho9Dg4OqNXqAl0288beKgqtVmv5v0qV26DBZDIVK+e9A9s3bdqUK1eusGnTJrZt28bAgQPp2LFjgTG2rEWKUkKUURv2HMXGzoPsu0m0b9bi4Tf4m2fDmrFi/p/YOVdh9Y5DvNCtTQmlFEIIIYQQomJRqVRF7kJX6O01uV+zNcUoMD2q8PBwdu3axZ07d3jnnXcsy9u1a8emTZs4dOgQr7766n1vP2rUKD777DMGDRpElSpVir3/atWqUa1atXzL9u/fT40aNXj//fcty65evVrsbRfXuXPnuH37Np988ollPKq/z04IYGub+5z8vaVQ/fr1sbOzIyYmxlLYu1dwcDDr1q3Lt+zvg8kX5siRI5hMJmbOnIlandtJbfny5fnW8fT0JC4uDrPZbCkqHT9+vEDmv+ctquDgYPbt25dv2b59+6hTpw4ajeaBt3VxcWHQoEEMGjSI/v3707VrV5KSkizdH61JilJClFH7zt4EDw+0d29YTmJFpdXaYJ92DbNzFXb+FcsL3UoopBBCCCGEEEIx4eHhvP766xgMhnwFlbCwMEaPHo1ery90PKk8wcHBJCYm4uDgYLVMtWvXJiYmhsjISJo3b87GjRsf2ArLWvz9/bG1tWXOnDm88sornD59milTpuRbp0aNGqhUKjZs2ED37t3R6XQ4Ozszfvx4xo4di8lkok2bNqSkpLBv3z5cXFwYMWIEr7zyCjNnzuSdd97hxRdf5MiRIwUGDL9XUFAQBoOBOXPm0KtXL/bt22cZ6ytP+/btuXXrFp9++in9+/fnt99+Y9OmTbi4/N/4LQEBAWzevJnz58/j4eGBq6trkR6PcePG0bx5c6ZMmcKgQYM4cOAAX3311UPHs5o1axY+Pj48+eSTqNVqVqxYgbe3t2UMLmuTMaWEKKPiDDoA6nvpHun2rQJzq9ipdl7FbsIphBBCCCGEKPvCw8PJzMwkKCgILy8vy/KwsDDu3r1L3bp1LWMN3Y+Hhwc63aN95yhM7969GTt2LKNHj6ZJkybs37/fMth2SfL09GThwoWsWLGC+vXr88knn/DZZ5/lW6d69epMnjyZ9957Dy8vL0aPHg3AlClTmDRpEtOnTyc4OJiuXbuyceNGatasCeQWvFatWsXatWtp3Lgx8+bNY9q0aQ/M07hxY2bNmsWMGTNo2LAhS5cuZfr06fnWCQ4OZu7cuXz99dc0btyYQ4cOFegO+dJLL1G3bl2aNWuGp6dngdZP99O0aVOWL19OZGQkDRs25N///jcfffRRvkHOC+Ps7Mynn35Ks2bNaN68OdHR0fz666/FbihRVCpzceacLGNSU1NxdXUlJSUlXyVRiPIuLvEO4zfGolZreKelPSG1iz/jQUpaOq9GXsTGTscLgZl0CW1i/aBCCCGEEEKUY1lZWVy5coWaNWtib2+vdBwhypUHHT9FrddISykhyqA1u46iVmvITLz+SAUpAFcnR8y3LwOw8XCUNeMJIYQQQgghhBCPTYpSQpRBR6KTAHDJSXqs7TT2zh2gMTbH+bEzCSGEEEIIIYQQ1iRFKSHKoBRN7nhQTwUUfwaMvxvcqTkmkxFdtQCOnbtijWhCCCGEEEIIIYRVSFFKiDLm1MWr6Ko+gclkpE/7po+1rQDfaujjc7vurdh1whrxhBBCCCGEEEIIq5CilBBlzIb9pwHITriCr6f7Y28v0NkIQFSqHO5CCCGEEEIIIcoO+ZYqRBlzJi4TAC9tplW291xYIwBsqwVyLS7RKtsUQgghhBBCCCEelxSlhChDTCYTemdfAFrX87XKNpvVDyTz1lXUGht+2nrIKtsUQgghhBBCCCEelxSlhChDdh85g52zBznZmfRq93jjSf2dtzoVgBM3rdP6SgghhBBCCCGEeFxSlBKiDNl6JHdQctPtaJwc7K223W7NAnP/416LlLR0q21XCCGEEEIIIYR4VFKUEqIMuZxiBqCGs9mq2+0a2pis5ARs7B1YtkW68AkhhBBCCCGs77vvvsPPzw+1Ws0XX3xR6LIPP/yQJk2aWG4TERFBnz59LH+3b9+et956q1Rz59m1axcqlYrk5ORS33d0dDQqlYrjx4+X+r6VJEUpIcqIzGw9avcAADo2DbTqttVqNc5ZcQDsj5LBzoUQQgghhCjvIiIiUKlUfPLJJ/mWr127FpVKVep5UlNTGT16NBMmTODGjRu8/PLLhS4bP34827dvv+92Vq9ezZQpU4q8XyULSY/q3kJcZSZFKSHKiPW/H8XG3oHsu3cIb97A6tsPq+8NQKbTExgMOVbfvhBCCCGEEKJ02dvbM2PGDO7cuaN0FGJiYjAYDPTo0QMfHx8cHBwKXebk5ISHh8d9t+Pu7o6zs3MpJq/Y9Hq90hEeSIpSQpQRe89cB0B79zo2Go3Vtz+gYwsMGXexc3Zn/Z6jVt++EEIIIYQQonR17NgRb29vpk+f/sD1Vq1aRYMGDbCzsyMgIICZM2fmuz4gIIBp06YxatQonJ2d8ff357vvvsu3zoQJE6hTpw4ODg7UqlWLSZMmYTAYAFi4cCEhISEA1KpVC5VKVeiy6OjoAt337nVv970lS5bQrFkznJ2d8fb25vnnnychIQHI7fIWHh4OQJUqVVCpVERERAC5M5tPnz6dmjVrotPpaNy4MStXrsy3r19//ZU6deqg0+kIDw8nOjr6gY8jwKxZswgJCcHR0RE/Pz9ee+010tLSLNcXdv+++OILAgICLNcvWrSIX375BZVKhUqlYteuXZZ1L1++THh4OA4ODjRu3JgDBw7k21ZRnsspU6YwfPhwXFxcePnll9Hr9YwePRofHx/s7e2pUaPGQ18zpUWKUkKUEbH63IHN61Wz3gDnf6ezs0WTHA3A1uNXS2QfQgghhBBClHdms5lsg6lYF32OCbPZjD6n8L+LejGbize2rEajYdq0acyZM4fr168Xus6RI0cYOHAggwcP5tSpU3z44YdMmjSJhQsX5ltv5syZNGvWjGPHjvHaa6/x6quvcv78ecv1zs7OLFy4kDNnzvDll18yf/58Pv/8cwAGDRrEtm3bADh06BCxsbEMGDCgwDI/P79i3T8Ag8HAlClTOHHiBGvXriU6OtpSePLz82PVqlUAnD9/ntjYWL788ksApk+fzuLFi5k3bx5//fUXY8eOZejQoezevRuAa9eu0a9fP3r16sXx48d58cUXee+99x6aR61WM3v2bP766y8WLVrEjh07ePfdd4t8f8aPH8/AgQPp2rUrsbGxxMbGEhoaarn+/fffZ/z48Rw/fpw6deowZMgQcnJye7oU9bn87LPPaNy4MceOHWPSpEnMnj2bdevWsXz5cs6fP8/SpUstRTKl2SgdQAgB8beTsfOsCUCv0IYltp9m/s4czYFEtXuJ7UMIIYQQQojyTJ9j5qXIi8W+XUMfB15r68vvUSm0C3Lli103OB2bUaxtzB9cGztt8caD6tu3L02aNOE///kP33//fYHrZ82aRYcOHZg0aRIAderU4cyZM/z3v/+1FHcAunfvzmuvvQbktor6/PPP2blzJ3Xr1gXggw8+sKwbEBDA+PHjiYyM5N1330Wn01m65Hl6euLtnTt0SGHLimvUqFGW/9eqVYvZs2fTvHlz0tLScHJywt0997tNtWrVcHNzAyA7O5tp06axbds2WrVqZbnt3r17+fbbbwkLC+Obb74hMDDQ0tKobt26nDp1ihkzZjwwz99bcQUEBPDxxx/zyiuvMHfu3CLdHycnJ3Q6HdnZ2YU+JuPHj6dHjx4ATJ48mQYNGhAVFUW9evWK/Fw+88wzjBs3zvJ3TEwMtWvXpk2bNqhUKmrUqFGkrKVBWkoJUQas3X0UtcaGzNs3aFw3oMT2M6RzC4w5BnQeT7D32LkS248QQgghhBCVzenYDH6PSqF7A3d+j0opdkHqccyYMYNFixZx9uzZAtedPXuW1q1b51vWunVrLl68iNFotCxr1KiR5f8qlQpvb29LNzmAZcuW0bp1a7y9vXFycuKDDz4gJiamBO5NfkeOHKFXr174+/vj7OxMWFgYwAP3HRUVRUZGBp06dcLJyclyWbx4MZcuXQJyH5cWLVrku11eAetBtm3bRocOHahevTrOzs4MGzaM27dvk5Fhnef778+Dj48PgOV5KOpz2axZs3zrREREcPz4cerWrcuYMWPYsmWLVbJag6ItpQICArh6tWA3otdee42vv/5agURCKOPPy7fBqzrOhtsluh8vDzeMCbvQ+Aazdt8Z2jxZr0T3J4QQQgghRHlja6Ni/uDaxb6dSgVajYoco5lu9avQsa4bxeyNh63No82a165dO7p06cLEiRPztZgpDq1Wm+9vlUqFyWQC4MCBA7zwwgtMnjyZLl264OrqSmRkZIHxjKwtPT2dLl260KVLF5YuXYqnpycxMTF06dLlgQN4543xtHHjRqpXr57vOjs7u0fOEx0dTc+ePXn11VeZOnUq7u7u7N27l3/84x/o9XocHBxQq9UFumHmjb1VFH9/HvJmUcx7HorK0dEx399NmzblypUrbNq0iW3btjFw4EA6duxYYIwtJShalDp8+HC+at7p06fp1KkTAwYMUDCVEKUvWe2GDmhaw63E91XPQ81l4Grmo5+MhRBCCCGEqKhUKlWxu9D9nc3/n7PoUQtMj+qTTz6hSZMmlu52eYKDg9m3b1++Zfv27aNOnTpoijjB0v79+6lRowbvv/++ZVlhDUys7dy5c9y+fZtPPvnEMh7Vn3/+mW8dW1tbgHy1hfr162NnZ0dMTIylZdW9goODWbduXb5lBw8efGCeI0eOYDKZmDlzJmp1bsez5cuX51vH09OTuLg4zGazpah0/PjxApn/nreoHue5dHFxYdCgQQwaNIj+/fvTtWtXkpKSLN0flaJo9728fqV5lw0bNhAYGHjfF40QFdG5K9fRefpjNpnoG9a0xPc3uEPuPnTeQZyPvlHi+xNCCCGEEEKUvJCQEF544QVmz56db/m4cePYvn07U6ZM4cKFCyxatIivvvqK8ePHF3nbtWvXJiYmhsjISC5dusTs2bNZs2aNte9CAf7+/tja2jJnzhwuX77MunXrmDJlSr51atSogUqlYsOGDdy6dYu0tDScnZ0ZP348Y8eOZdGiRVy6dImjR48yZ84cFi1aBMArr7zCxYsXeeeddzh//jw//fRTgQHD7xUUFITBYLDkWbJkCfPmzcu3Tvv27bl16xaffvoply5d4uuvv2bTpk351gkICODkyZOcP3+exMTEIreketTnctasWfz888+cO3eOCxcusGLFCry9vS1jcCmpzIwppdfr+fHHHxk1apSlmniv7OxsUlNT812EKO/W7jkJQNatK1T38ijx/dWr+QSZcbn9qJdtP1ri+xNCCCGEEEKUjo8++qhAV6+mTZuyfPlyIiMjadiwIf/+97/56KOPitXNr3fv3owdO5bRo0fTpEkT9u/fbxlsuyR5enqycOFCVqxYQf369fnkk0/47LPP8q1TvXp1Jk+ezHvvvYeXlxejR48GYMqUKUyaNInp06cTHBxM165d2bhxIzVr5k4w5e/vz6pVq1i7di2NGzdm3rx5TJs27YF5GjduzKxZs5gxYwYNGzZk6dKlTJ8+Pd86wcHBzJ07l6+//prGjRtz6NChAkWjl156ibp169KsWTM8PT0LtH66n0d9Lp2dnfn0009p1qwZzZs3Jzo6ml9//dXS2ktJKnNx55wsIcuXL+f5558nJiYGX1/fQtf58MMPmTx5coHlKSkpuLi4lHREIUrE8BkrwLcRzokn+Xps6XRdHffVKm65NkR/8wyRE/qWyj6FEEIIIYQoa7Kysrhy5Qo1a9bE3t5e6ThClCsPOn5SU1NxdXV9aL1G+bLY//f999/TrVu3+xakACZOnEhKSorlcu3atVJMKIT1mUwmsp1yX/Oh9XxKbb/PtgoGQOMZxK2klFLbrxBCCCGEEEIIkadMFKWuXr3Ktm3bePHFFx+4np2dHS4uLvkuQpRne4+dw86lKkZ9Fr3bPVVq+23zZD0yb99Ao7Xlpy1/lNp+hRBCCCGEEEKIPGWiKPXDDz9QrVo1evTooXQUIUrV5j8vAJCTeAVnR12p7VetVuNhug3An1dlbDYhhBBCCCGEEKVP8aKUyWTihx9+YMSIEdjY2CgdR4hSdTk5dxDCGk6mh6xpfZ0a+wNgcKtBZra+1PcvhBBCCCGEEKJyU7wotW3bNmJiYhg1apTSUYQoVZnZeqhSA4AOT9Yq9f33bvcU2XfvYOvgwqrth0p9/0IIIYQQQgghKjfFi1KdO3fGbDZTp04dpaMIUao27TuOVueEPi2ZDi1CSn3/Wq0NurTcyQJ2nYkt9f0LIYQQQghRVpSRSemFKFescdwoXpQSorLafSoGAE3qNWw0GkUytAryACDVzhuTqfS7EAohhBBCCKEkrVYLQEZGhsJJhCh/8o6bvOPoUcggTkIoJDbbDnugrqedYhkGd27B7siL2LtVY+vBk3QJbaJYFiGEEEIIIUqbRqPBzc2NhIQEABwcHFCpVAqnEqJsM5vNZGRkkJCQgJubG5rHaGQhRSkhFHArKQVbz5oA9GzVQLEcrk6OcPsS+DZk4+EoKUoJIYQQQohKx9vbG8BSmBJCFI2bm5vl+HlUUpQSQgFrdx9FbeNLZlIsTYPbK5qlkY+OM0BsjrOiOYQQQgghhFCCSqXCx8eHatWqYTAYlI4jRLmg1Wofq4VUHilKCaGAw5cSwcsXp+xbSkfh+U7N+dfmBHTVAjh69jJNg0t/JkAhhBBCCCGUptForPIlWwhRdDLQuRAKuKN2BeDJGq4KJwF/H0/0CZcAWLn7pMJphBBCCCGEEEJUFlKUEqKUXbx6E51nDcwmE33aPal0HACCXHJn3otKlVOCEEIIIYQQQojSId9AhShla/ecACDrVjT+Pp4Kp8nVP6wRALbVAomJVb5LoRBCCCGEEEKIik+KUkKUslM30gDwVKcpnOT/NA2uRWZCNGqNDT9tPax0HCGEEEIIIYQQlYAUpYQoRSaTiSxHHwBa1n28qTOtzVtzF4CTsZkKJxFCCCGEEEIIURlIUUqIUrT/xAXsXT0xGrJ5Nqyp0nHy6dE8KPc/HoGkpKUrG0YIIYQQQgghRIUnRSkhStHmw+cByLl1BVcnR4XT5Ne5VSOykhOwsdOxbMshpeMIIYQQQgghhKjgpCglRCmKumMEwM/RqHCSgtRqNS7ZcQDsj0pUOI0QQgghhBBCiIpOilJClJJsvQGq1AAgvHGAsmHuo11w7jhXmU5PYDDkKJxGCCGEEEIIIURFJkUpIUrJpn3H0eqc0Ken0LllI6XjFGpAxxYYMu5i5+zOut+PKB1HCCGEEBVMeno6er2ehIQE9Ho96ekyjqUQQlRmUpQSopTsPh0DgCblGlqtjcJpCqezs0WTHA3AthMxyoYRQgghRIViNptZtWoVXl5elsuqVaswm81KRxNCCKEQKUoJUUpuZGoBqFNVq3CSB2tewwWARLUHJpNJ4TRCCCGEqAjS09NZsmQJPXv2pHnz5gA0b96cnj17smTJEmkxJYQQlZQUpYQoBYnJqWg9awHQvWV9hdM82POdW2A06NF5VGff8fNKxxFCCCFEBaDVannzzTcZPHgwkZGRfPrpp0RGRjJ48GDefPNNtNqy/aOdEEKIkiFFKSFKwS+7j6Kx0ZJ1J46ngmspHeeBPN1dMd6KAmDt/jMKpxFCCCFERZCcnExycjJbt27l+++/55133uH7779n69atJCcnk5KSonREIYQQCpCilBCl4FDULQAcshJQq8v+YRdcVQNATKa9wkmEEEIIURG4urri5uZGp06d+Mc//sF///tf/vGPf9CpUyfc3NxwdXVVOqIQQggFlM3RloWoYJJwQQc0fsJF6ShFMrjDU0zdk4bOO4jz0TeoG1Bd6UhCCCGEKKdiYmK4cOECn3/+Ob1792bw4MFs3bqVrVu3EhkZyYYNGzAYDNja2iodVQghRCkr+002hCjnomJi0VULAKBPWBNFsxRV3YDqZMblduGL3H5E4TRCCCGEKK9OnTpFaGgoP//8M8OHD2fDhg0cPnwYgMOHD7N+/XqGDRuGo6OjwkmFEEIoQYpSQpSwX/acACAz/go1q3spnKboauiyATibaFQ4iRBCCCHKo127dtG2bVtu3LhBgwYNuHPnDs899xzx8fHcvHmT69ev4+3trXRMIYQQCpKilBAl7OSNuwBUVd9VOEnxPBsaDIDGM4hbSTL4qBBCCCGKbsWKFXTp0oWUlBTatGlDREQEHh4eODo6Ymtri6urKw0bNqRr167s379f6bhCCCEUIkUpIUqQyWQiU5f7C2CL2uWnlRRA6yZ1ybx9HY3Wlp+2/KF0HCGEEEKUE7Nnz2bQoEHo9Xr69u3Lli1bcHd3z7eOg4MD7du3B2DhwoWlH1IIIUSZIEUpIUrQH6cuYu9WDaNBT5+wpkrHKRa1Wk1VUxIAh6+mKpxGCCGEEGWdyWRiwoQJvPnmm5jNZl577TVWrFiBTqcrdP2IiAgAli9fTkZGRikmFUIIUVZIUUqIErTp0DkADIlXcHNxUjhN8XVqUgMAo1sAmdl6hdMIIYQQoqzS6/WMGDGCTz/9FICpU6fy1VdfodFo7nubtm3bEhAQQGpqKmvXri2lpEIIIcoSKUoJUYKiknIAeEJnUDjJo+nVtinZd5PQOjizYpt04RNCCCFEQXfv3qVXr178+OOPaDQafvjhB/71r3+hUqkeeDu1Ws3w4cMBWLRoUWlEFUIIUcZIUUqIEmIw5GB2y21pFN4oQNkwj0irtUGXdh2A38/GKZxGCCGEEGVNfHw87du3Z8uWLTg4OLB+/XpLt7yiyCtKbdu2jRs3bpRQSiGEEGWVFKWEKCG/7T+B1sEZQ8ZduoY2VjrOIwsNqgpAqp03JpNJ4TRCCCGEKCsuXrxIaGgoR48exdPTk127dtGtW7dibSMwMJC2bdtiMplYsmRJCSUVQghRVklRSogSsvNkNACq5KtotTbKhnkMgzo/TU52JvZu1dhy4KTScYQQQghRBhw6dIjQ0FAuX75MrVq12L9/P82bN3+kbY0YMQLI7cJnNputGVMIIUQZJ0UpIUrI9UwtALXdtQoneTyuTo5w+xIAGw9HKZxGCCGEEErbtGkT4eHhJCYm0rRpU/bv309QUNAjb2/AgAHodDrOnTvH4cOHrZhUCCFEWSdFKSFKQHJqGtqqNQHo1qKewmkeXyOf3Kmc44zOCicRQgghhJJ++OEHevXqRUZGBp07d2bXrl14eXk91jZdXFzo168fAAsXLrRCSiGEEOWFFKWEKAFrdh1Bo7UlKzmepxs++i+HZcXznZpjMuagqxbA0bOXlY4jhBBCiFJmNpv5+OOPGTVqFEajkWHDhrF+/Xqcna3zg1VeF77IyEiysrKssk0hhBBlnxSlhCgBf0QlAKDLjEetLv+Hmb+PJ/qE3C58K3fLuFJCCCFEZWI0Gnn99deZNGkSABMmTGDRokXY2tpabR/PPPMMTzzxBHfu3GH9+vVW264QQoiyrfx/WxaiDLptzv3VsFH1itPdLcgld+a9qFQ5bQghhBCVRWZmJgMGDOCbb75BpVIxe/ZsPvnkE1QqlVX3o9FoGDZsGJA74LkQQojKQb5dCmFlV27Eo6uWO57Us20bK5zGega0z70vtl5BxMTeUjiNEEIIIUpaUlISnTp1Ys2aNdja2rJs2TLeeOONEttfXhe+3377jbi4uBLbjxBCiLJDilJCWNna3ccByEyIJsjfR9kwVvRkvZpkJkSjVmv4aavMjCOEEEJUZDExMbRp04Z9+/bh6urKli1bGDBgQInus27durRs2RKj0cjSpUtLdF9CCCHKBilKCWFlJ66nAuBOqsJJrM/H5i4AJ2MzFU4ihBBCiJJy6tQpQkNDOXv2LNWrV2fPnj2EhYWVyr7zWkstWrQIs9lcKvsUQgihHMWLUjdu3GDo0KF4eHig0+kICQnhzz//VDqWEI/EZDKRYV8NgBa1qymcxvp6NP//Mwl6BJKSlq5sGCGEuEd6ejp6vZ6EhAT0ej3p6XKeEqK4du/eTdu2bblx4wb169fnwIEDhISElNr+Bw0ahJ2dHadOneL48eOltl8hxP+R91NRmhQtSt25c4fWrVuj1WrZtGkTZ86cYebMmVSpUkXJWEI8siNnL2NfxRtjjoE+YU2VjmN1nVo2Iis5Hhs7HZFb/lA6jhBCWJjNZlatWoWXl5flsmrVKmlpIUQxrFixgs6dO5OSkkKbNm3Ys2cPfn5+pZqhSpUqPPvsswAsXLiwVPcthJD3U1H6FC1KzZgxAz8/P3744QeefvppatasSefOnQkMDFQylhCPbOOBMwAYbl3G3bXizLyXR61W45IdD8CBqNsKpxFCiFzp6eksWbKEnj170rx5cwCaN29Oz549WbJkifzCK0QRzJkzh0GDBqHX6+nbty9btmzB3d1dkSx5Xfh++ukn9Hq9IhmEqIzk/VQoQdGi1Lp162jWrBkDBgygWrVqPPnkk8yfP/++62dnZ5OamprvIkRZcuG2AYDqOoPCSUpO+/q5g7dnOvlhMOQonEYIIUCr1fLmm28yePBgli1fweKNe4iMjGTw4MG8+eabaLVapSMKUWaZTCbee+89xowZg9ls5rXXXmPFihXodDrFMnXu3Blvb28SExP59ddfFcshRGXz9/fTFavWsGDlb/J+KkqcokWpy5cv880331C7dm02b97Mq6++ypgxY1i0aFGh60+fPh1XV1fLpbSbEwvxIAZDDiZXfwDCGvornKbkPNfhafQZqdg5V2Hd70eUjiOEECQnJ5OcnMzWrVvZcSaeYd3bsGHvCbZu3UpycjIpKSlKRxSiTNLr9YwYMYIZM2YA8PHHH/PVV1+h0WgUzWVjY8PQoUMB7vu9QAhhfXnvp+fuwL6YbEY+14Wf12yQ91NRolRmBTuH2tra0qxZM/bv329ZNmbMGA4fPsyBAwcKrJ+dnU12drbl79TUVPz8/EhJScHFxaVUMgtxPxv3HGVZtCOGzDQWRjTCzrbi/pIwbMZKVL4hONw6yby3S3Z6aCGEeBi9Xo+XlxctW7dlxao1/B6VQrtAFwYOeI4De38nPj4eW1tbpWMKUabcvXuX/v37s2XLFjQaDfPnz2fkyJFKx7I4ffo0ISEh2NjYcPPmTTw9PZWOJESFp9fr8fWvyZhvNvF29wb8HpVCm5oO9O/Tm8OHD8v7qSiW1NRUXF1dH1qvsSnFTAX4+PhQv379fMuCg4NZtWpVoevb2dlhZ2dXGtGEKLadJ6LBtQHcuYqd7VNKxylRzQNc+FMPt9VVMZlMqNWKT+QphKjEDAYDX375Jb2e7cPcPTc5HZvB6dh0fv7pJ35ZswqDwSAfooX4m/j4eLp3787Ro0dxcHBg5cqVdOvWTelY+TRs2JCnnnqKI0eO8PPPPzNmzBilIwlR4RkMBv4zbwUjuzVg1q9/cTFVy+lYJ5YtX876devk/VSUiEf6Jmkymbhw4QJ79+7l999/z3cpjtatW3P+/Pl8yy5cuECNGjUeJZYQirqWntvUPaiKsk3eS8OQTi0wGvToPHzZe+yc0nGEEJWco6Mjw4YN46ftxzkdm0FWahKnYzOYvz+WYcOG4ejoqHREIcqMixcvEhoaytGjR/H09GTXrl1lriCVJ2/Ac+nCJ0TpuHgjkZHdWjB3z01+/PQdYv7cwunYDJb8flHeT0WJKXZR6uDBgwQFBREcHEy7du1o37695RIeHl6sbY0dO5aDBw8ybdo0oqKi+Omnn/juu+94/fXXixtLCEWlpKVj41kTgC7N6yqcpuR5urtivBUFwC8HziqcRgghQKVScc3oBsCAZj5U0Wk4mWBk1e7jiuYSoiw5dOgQoaGhXL58mVq1arF//37LDFtl0ZAhQ9BqtRw9epRTp04pHUeICs1gyOF0XBZz99wk624yp3evZ+Yb/QE4kuLM1Zu3FE4oKqpiF6VeeeUVmjVrxunTp0lKSuLOnTuWS1JSUrG21bx5c9asWcPPP/9Mw4YNmTJlCl988QUvvPBCcWMJoahfdh9Fo7UjKzmB0MZ1lI5TKupXze39G5Op3Ow8QgiRJ1tvICbZCICvvR7X5NxWnMuO35GZQoUANm3aRHh4OImJiTRt2pT9+/cTFBSkdKwHqlq1Kj179gSktZQQJW3ygg1suQrHLsUzpKlH7vjPdaqTkxCFGRVTf96tdERRQRW7KHXx4kWmTZtGcHAwbm5u+WbDc3V1LXaAnj17curUKbKysjh79iwvvfRSsbchhNIOno8DQJcZV2nGVxrUoSkAOu9Azl25rnAaIURlt/3QaWzsHdBnpNKiYSBj+rdDn56KzqM681bvVDqeEIpauHAhvXr1IiMjg86dO7Nr1y68vLyUjlUkeV34fvzxR3JypMAsREk4c/kal1S5M9vXUd+kdg1fy3Wd6zgDkO5Wm5hYaS0lrK/Y355btGhBVFRUSWQRoty6Zco9WTf0dVI4SempG1CdzLjcc0Hk9qMKpxFCVHZ7T1/N/U/ydWw0Gqq6ueCZlbvs92sGTCaTgumEUIbZbGbq1KmMHDkSo9HIsGHDWL9+Pc7OzkpHK7Lu3bvj6elJfHw8mzdvVjqOEBXS1BWH0OqcyIyLYtKoHvmuG96jDZnxV7Cx0zFzubSWEtZXpKLUyZMnLZc33niDcePGsXDhQo4cOZLvupMnT5Z0XiHKnOibCdh75g7O36dtY4XTlK4aumwAzt2WL3tCCGVdTcntulfd8f/OR28PaEuOPhOdVyCRmw8oFU0IRRiNRkaPHs0HH3wAwIQJE1i0aFG5mzlLq9Xy/PPPA9KFT4iS8L+1u9D4NsRkzOHltn7YaPJP2qRWqwn1VQEQb+tHUspdJWKKCqxIRakmTZrw5JNP0qRJE5577jnOnj3LqFGjaN68eb7rnnzyyZLOK0SZ88vvx1Gp1WTeupqvqWtl0Kd1fQA01YKIv52sbBghRKVlMpnIcfIG4Ok6/3cerlndC13SRQB+OSldDkTlkZmZyYABA5g7dy4qlYrZs2fzySefoFKplI72SCIiIgD45ZdfuHPnjrJhhKhAklPT2BKTe15wvH2GTi0bFbrea/2fITMpFlsnN2ZGbi/NiKISKFJR6sqVK1y+fJkrV64Uesm77vLlyyWdV4gy53hMCgBVTCkKJyl9bZ6sR+bt62hstPy85Q+l4wghKqmj565g51IVY46BrqH5P1C/3vMpTMYc7HyD2bz/uDIBhShFSUlJdOrUiTVr1mBra8uyZct44403lI71WJo0aUKjRo3Q6/VERkYqHUeICuNf32/Cvoo3WckJTP1Hl/uuZ2erpb5DKgAX9e5kZutLK6KoBIpUlKpRo4blcvXqVapXr55vWY0aNahevTpXr14t6bxClDlpdp4ANA+sqnASZVQ15c66+WeMNOUVQihj+5HzAOgTr+Lq5JjvuqbBtSD+LABL9siYmKJii4mJoU2bNuzbtw9XV1c2b97MgAEDlI5lFXkDnksXPiGsY+fh06S6BQPwjK+eqm4uD1z/7SEdyL6bhL2bF3OWS2spYT3FHug8PDycpKSkAstTUlIIDw+3Sighyos/z1xC5+6DKcdAn7CmSsdRRKcmueNpGd0C5FcTIYQizsWmA+ChySj0+hFhdXL/412fP89cKq1YQpSqU6dOERoaytmzZ6levTp79uyhffv2SseymhdeeAGNRsMff/zBuXPnlI4jRLmWYzTyzc5o1DZaDDf/4pXnOjz0Nq5OjlQ33gTg8C2NTCAirKbYRSmz2Vxof/Tbt2/j6OhYyC2EqLh+PXgGAP2tK3i6uyqcRhm92jYl++5ttA7OrNgmXfiEEKUvzcYNgMb+7oVe36llI/Q3z6JWa/hmo8wWKiqe3bt307ZtW27cuEH9+vU5cOAAISEhSseyKi8vL7p16wZIaykhHtf0Rb9i71MbQ1Y6/+r3VJFvN25gewxZ6eg8a7Bg3e8lmFBUJkUuSvXr149+/fqhUqmIiIiw/N2vXz+effZZunTpQmhoaElmFaLMOX8rd/Y5X/tshZMoR6u1QZd2A4DdZ+IUTiOEqGyuxSWi8/QHoGurhvdd79nG1QDIcq/DpWtyrhIVx4oVK+jcuTMpKSm0adOGPXv24Ofnp3SsEpHXhW/JkiUYjUaF0whRPl26Fsdf+tzJQQJyrhJSu0aRb1vdywOX1NwWx1suyNAdwjqKXJRydXXF1dUVs9mMs7Oz5W9XV1e8vb15+eWX+fHHH0syqxBlSo7RiNEl90Nfu4b+CqdRVuvaueNp3bX3lqa8QohStWn/KQAyE69Ts7rXfdcb1LklmXGX0Nja8/mqvaUVT4gSNWfOHAYNGoRer6dv375s2bIFd/fCWwxWBL169aJKlSrcuHGD7dtlTBshHsXkn/Zg6+hCZsIVPvxHz2Lf/s2+LTHmGLD3qcOaHYdLIKGobGyKuuIPP/wAQEBAAOPHj5eueqLS23bwFLZObhgy0+jWuonScRQ1uHNLdv50Dnu3avy2/wTd2zypdCQhRCVx/GoiVPXFwVBwvMu/U6vVhNXQcigbEnU1uJWUUmm7XYvyz2w2M3HiRGbMmAHAa6+9xuzZs9FoNAonK1l2dnYMGTKEuXPnsmjRIjp37qx0JCHKlaWb9oJvI8wmE8ObeWJnqy32NurX8sNm5UHMPo1YfvgafZ9pXgJJRWVS7DGl/vOf/+Do6EhCQgJ79uxhz549JCQklEQ2Icq07ccv5/7nzlV0drbKhlGYs6MOknIfj01/yiDCQojSk2iwB6BuNYeHrvvKc8+QmXgdWwcXZi7bUdLRhCgRBoOBESNGWApSH3/8MV999VWFL0jliYiIAGDNmjWkpKQoG0aIciQtI4u153OHHLFNOE2vsKKPJXWvFzvmdpfX+jZgz9GzVsknKq9iF6Xu3r3LsGHDqF69OmFhYYSFhVG9enWGDh0qbwyiUolJyz18arkV+zCqkBr76gCIMz14OlkhhLCWtIwstFVzx8J4pmnth65vo9HQ2C0TgMtGTzIyK+94gKJ8unv3Lj179mTJkiVoNBoWLFjA+++/X+gkRBVVs2bNCA4OJjMzkxUrVigdR4hy4/35G9B5PEF26m2mjuz4WNtq2zQYw82/APjfttPWiCcqsWJ/m37xxRf5448/2LBhA8nJySQnJ7Nhwwb+/PNP/vnPf5ZERiHKnLvpmdhUrQlAl2Z1FE5TNjzf6WlMxhx0njVkynUhRKnYcvAkGq0d2Xfv8HTDoCLd5q1BHclKScTe1ZMvlm0r4YRCWE98fDzh4eFs2bIFBwcH1q1bx8iRI5WOVepUKpVlwHOZhU+Iojlw4jyJznUBaFnlLt5Vqzz2Ngc9nTu2bo5nMH9FxTz29kTlVeyi1IYNG1iwYAFdunTBxcUFFxcXunTpwvz581m/fn1JZBSizFn3+xE0tvZkpSTS5sl6SscpE/y8q6JPyC1Grdp9UuE0QojK4MDZ6wBo7t5ArS7aRxonB3sCVPEAHLtjR47M4CXKgYsXLxIaGsqRI0eoWrUqO3fupHv37krHUszQoUNRq9Xs3buXqKgopeMIUaaZTCY+/+0cGq0t2TfP8ubgTlbZbp/w5mTFXkBjo2X2L39YZZuicip2UcrDwwNX14IDg7q6ulKlyuNXXIUoD/afiwXAPv1mkb8IVQa1XXNn3rt0t3KMayGEUNb1tNx//ZyLdx4eN/gZDBl30VX1Y/6aXdYPJoQVHTp0iNDQUC5fvkytWrXYv38/Tz/9tNKxFFW9enU6dcr9Yr148WKF0whRtn22dDP2vvUw6rN4p1eIVb+7dK7jDECqSyA34m9bbbuicin2K/KDDz7g7bffJi4uzrIsLi6Od955h0mTJlk1nBBlVYIxd/bJBr4yC+XfDWzfBABbryCib8oECEKIkmMymTC7VAcgtL5fsW7r5eGGe8YVAHZcycJkMlk9nxDWsGnTJsLDw0lMTKRp06bs37+f2rUfPn5aZZDXhW/x4sVyDAtxH9fiEjlyN7fhiFdGFM3qB1p1+6N6tyPz1lW09o7MXL7LqtsWlUexi1LffPMNBw8exN/fn6CgIIKCgvD392f//v18++23NG3a1HIRoiK6FpeIvWfueFLPtmmkcJqypXHdADITrqBWa4jceljpOEKICmz/iQvYOrmRo8+kU4uQYt9+7HNtMBqy0XkHsWKbdDsQZc/ChQvp1asXGRkZdO7cmV27duHl5aV0rDKjT58+uLi4cPXqVXbv3q10HCHKpH8v3omdcxUyb8Xw8Ys9rb59tVrN09Vyu8Hf0FQnJS3d6vsQFZ9NcW/Qp0+fEoghRPmxdvcxVGp/Mm/FUK+mdfpkVyQ+NmkkAyfiZFYrIUTJ2XnsImjrkHM7Bgddk2LfPsjfB7vbe8nxbsSaY3EM6mz9jEI8CrPZzLRp0/jggw8AGDZsGP/73/+wtbVVOFnZotPpGDRoEPPnz2fRokWEh4crHUmIMmXV9j8w+uT+gD4gxBkHnV2J7GfMwI4Mm7cf+yrezPx5Gx+99GyJ7EdUXMUuSv3nP/8piRxClBvHYpLB2x83U7LSUcqkHs2DWHoJVFVrkZyahpuLk9KRhBAV0MVbWeAL1Wz1j7yNV7o2YfZRA7a+9dlx6DTPPN3QigmFKD6j0ciYMWOYO3cuABMmTGD69OmoVCqFk5VNERERzJ8/n5UrV/LVV1/h5CSfOYQAyMzWE3kiBZ2nG6rYkwwcNqDE9mVnq6WO3R1i8OZchivZegN2ttoS25+oeB5plLPk5GT+97//MXHiRJKSkgA4evQoN27csGo4Icqiu9qqADSr5aFwkrKpU8tGZCXHY2OrI3KrdIkRQpSMTLvcc3HTWp6PvI2nQ2pjjjsLwA87z1kllxCPKjMzk4EDBzJ37lxUKhWzZ8/mk08+kYLUA7Rq1YratWuTnp7OqlWrlI4jRJkx6X8b0HnWQJ92hynD2pf4/t4e3AF9WjL27j58vXJ7ie9PVCzFLkqdPHmSOnXqMGPGDD777DOSk5MBWL16NRMnTrR2PiHKlGPnrqDz8MVkzKFPmIybVhi1Wo1Ldu506wcuJSmcRghREUXFxKLz8MVsMtE99PHG9nuhdS0AzF7BnDgfbYV0QhTfnTt36Ny5M6tXr8bW1pZly5bxxhtvKB2rzFOpVAwfPhyARYsWKZxGiLLh6NnL3LTPfW9r4nAbf59H//GmqNxdnfE2XAPgQCwy+YAolmIXpd5++20iIiK4ePEi9vb2luXdu3fn999/t2o4IcqajQf+AiD71hW8PNyUDVOGhTfwASDLyQ+DIUfhNEKIiua3g6cByEqMwbtqlcfaVvc2T5J98xxqjQ1z1ssEDaL0Xbt2jTZt2rB3715cXV3ZvHkzAwaUXFebimb48OGoVCp27tzJ1atXlY4jhKJMJhOfrjuBja2OrNjzvDusW6nt++0BYeRkZ6KrVpNFG/aU2n5F+VfsotThw4f55z//WWB59erViYuLs0ooIcqqcwlZAPjYZimcpGzr98zT6DNSsXOuwi+7/1Q6jhCigjl5LRkAZ1OqVbbXo6E7ABlVahN9M8Eq2xSiKE6dOkWrVq04c+YMvr6+7Nmzh/bt2ysdq1zx9/e3DHK+ePFihdMIoayvV2zH1rc+xhwDYzrVQa1+pNF6Hom/jyeOyRcB2HQupdT2K8q/Yr9K7ezsSE0t+CHwwoULeHqWfNNAIZSSYzRicH4CgHYNnlA4Tdmms7NFm5z7a+XWE9cUTiOEqGjumB0BqO9jnUGNh3ZrTWb8FWxsdcxaIa2+RenYvXs3bdu25caNG9SvX58DBw4QEhKidKxyacSIEUBuFz6z2axwGiGUEX87mT23HABwTzlHmyfrlXqGN3o3x5RjwN6nLht+P1Lq+xflU7GLUr179+ajjz7CYDAAuX25Y2JimDBhAs8995zVAwpRVuw4dBo75yoYstLp0VbGk3qY5gEuACRpqkq/ciGE1SSl3MXOwx+Azk8HW2WbarWaNk/kfiRKsPMnKeWuVbYrxP2sWLGCzp07k5KSQps2bdizZw/+/v5Kxyq3nnvuOZycnLh06RL79u1TOo4Qivjgh63Yu1Yl8/ZNpr3UQ5EMjeoEoE7InUDkpwPRimQQ5U+xi1IzZ84kLS2NatWqkZmZSVhYGEFBQTg7OzN16tSSyChEmbD92CUAzElX0dnZKpym7BvSqQVGQzY6D1/2HpNZrYQQ1vHb/pOobbRkJSfQqE6A1bb72nPPkHn7JraOrnz2s8wcJErOnDlzGDRoEHq9nr59+7Jlyxbc3d2VjlWuOTo60r9/f0AGPBeV0697j5Hp2QCAXrVtcHbUKZZl5DO5PxhpvOtz4MR5xXKI8qPYRSlXV1e2bt3K+vXrmT17NqNHj+bXX39l9+7dODo6lkRGIcqE6Lu5h0stV5mauSg83V0x3sot5K3df1bhNEKIiuJwVO74lbYZ8VbdrlZrQ0Pn3BZSUQZ3MrP1Vt2+EGazmffee48xY8ZgNpt57bXXWLFiBTqdcl8eK5KIiAgAli9fTkZGhrJhhChFBkMOPxyMQ63WYLp5iuE92iqaJ7x5Q/Q3z6BSq/l280lFs4jy4ZFHPmvTpg2vvfYa7777Lh07drRmJiHKnLSMLDRVAwDo9FSQsmHKkfqeNgBcy5IP3EII67iZoQGgZhWt1bf99uBOZN+9jb2bF7OXb7P69kXlZTAYGDFiBDNmzADg448/5quvvkKj0SicrOJo27YtAQEBpKamsnbtWqXjCFFqPlywAZ1XLfQZqXw4pLXScQDo/1TuTNyGqvU4H31D4TSirCtWUcpkMrFgwQJ69uxJw4YNCQkJoXfv3ixevFgGFRQV2vrfj2JjqyP77m3CnqqvdJxyY0iHpzCbTOi8Azl35brScYQQ5ZzBkIO6ih8AbUMCrL59Z0cdT5hiAfjzlo2Mhyes4u7du/Ts2ZMlS5ag0WhYsGAB77//PiqVtLy2JrVazfDhwwHpwicqjzOXr3FZlfu+GGwTS5C/j8KJcvXv2JLMuItotLZ8sXq/0nFEGVfkopTZbKZ37968+OKL3Lhxg5CQEBo0aMDVq1eJiIigb9++JZlTCEXtO3cTANu7N0t1atXyrnYNX7ISLgMQuf2owmmEEOXdriNn0OqcMGSmEd6sQYnsY9ygcAyZaeg8a/D9L7tLZB+i8oiPjyc8PJwtW7bg4ODAunXrGDlypNKxKqy8otS2bdu4cUNaZ4iK7+MVh9DqnMiMi+L9CGUGN7+fDrVye0okO9UiLvGOwmlEWVbkb9cLFy7k999/Z/v27Rw7doyff/6ZyMhITpw4wbZt29ixYweLFy8uyaxCKCbekHtSre8t3dCKq4ZDNgBnb0uLAyHE4/n95BUATHeuodXalMg+fD3dcUvLLaZvvZhWIvsQlUNUVBShoaEcOXKEqlWrsnPnTrp37650rAotMDCQtm3bYjKZWLJkidJxhChR89fsxMa3ISZjDq+088emjHUHfrFPezJvxaDVOfHZsp1KxxFlWJGLUj///DP/+te/CA8PL3DdM888w3vvvcfSpUutGk6IsuDmrSTsqtUEoHfrEIXTlD/9Wue2ZrCpFkT87WRlwwghyrUrdwwA+OiMJbqfN/u2wmjQY+9Th9U7DpXovkTFdPjwYUJDQ7l8+TI1a9Zk//79PP3000rHqhRGjBgB5Hbhk+FFREWVlHKXrddyv8o7JZ2hQ4uy9x3FRqPhKY/cSUOuqby5m56pcCJRVhW5KHXy5Em6du163+u7devGiRMnrBJKiLJk7a6jqNUaMhOv0SDIX+k45U5ok7pkJl5HY6Plp81/KB1HCFGO6R28AGhe26tE91Ov5hNoE88BsOKwjIcnimfTpk20b9+eW7du0bRpUw4cOEDt2rWVjlVpDBgwAJ1Ox7lz5zh0SIrKomJ6//vfsK/iTVZyPNP+cf/v6EobM7AjWckJ2Dl78HmkTCAiClfkolRSUhJeXvf/EOjl5cWdO9JXVFQ8R6JzX9euRnl9PypPcxIAR67dVTiJEKK8OnkhGnu3apiMOXQLbVzi+3u5cyPMJhNa3wb8fuRMie9PVAwLFy6kV69eZGRk0LlzZ3bt2vXAz8/C+lxcXOjXrx8gA56LimnHodPcrRIMQIfqObi7Oiuc6P4cdHYE2iQCcOquEwZDjsKJRFlU5KKU0WjExub+4zdoNBpycuRFJiqeVK07AE8FuCucpPzq1CQAAGOVmmRkZisbRghRLm09nNtyKTvxaql8AA9tUhdjXG4x6vvtf5X4/kT5ZjabmTp1KiNHjsRoNDJs2DDWr1+Ps3PZ/bJYkeV14YuMjCQrK0vhNEJYT47RyDe7r6K20ZJz8zT/7PeM0pEeatyQDujTU9F5+PLN6h1KxxFlUJFHCTWbzURERGBnZ1fo9dnZ8kVTVDwnL0Sj83gCk8lI3/ZNlY5TbvUKa0rkt39g5+zBiu2HGNGzrdKRhBDlzJmbd8EbqpBeavsc0jKAFTFg9Azm1MWrhNSuUWr7FuWH0WhkzJgxzJ07F4AJEyYwffp0VCqVwskqr2eeeYYnnniC69evs379egYMGKB0JCGsYtrCX9F518GQlc4HzzVXOk6RVHVzwTPrKimOIey5ZmS0ySSzmYt8ivxqGDFiBNWqVcPV1bXQS7Vq1SzTsApRUWzYn/vreHbCFbyrVlE4Tfllo9HgkJY7NfPvZ+MUTiOEKI9S1S4AhPi5ldo+e4U9RVbsedQ2Wuask7FpREGZmZkMHDiQuXPnolKpmD17Np988okUpBSm0WgYNmwYIF34RMURFRPLmRxvAGoaY8rVWLdvD2hLjj4TnVctfvptv9JxRBlT5JZSP/zwQ0nmEKJMOhOfidoXvLUyW8Tjal3Hk9/vwl2dDyb5hUQIUQxxiXewr5r74btrywaluu+u9VzZlQJpLkFci0vEz7tqqe5flF137tyhd+/e7N27F1tbW3788UdpkVOGjBgxgunTp/Pbb78RFxeHt7e30pGEeCyTf96HrW8ImfFX+M+YHkrHKZaa1b3QJf2OwbsR608lMrS70olEWSLfCoW4D5PJhMG5OgCtg30VTlP+DerUgpysDOxdPdm077jScYQQ5civ+0+iUqvJTLpJ7Rqlez6O6NmWzIRobOwdmLVid6nuW5Rd165do02bNuzduxdXV1c2b94sBakypm7durRs2RKj0cjSpUuVjiPEY1m8cQ8q3xDMJhMjnvbEzlardKRie73nU5iMOdj5BvObfBcQf6NoUerDDz9EpVLlu9SrV0/JSEJY7PrzDHbO7uRkZ9KzrYwn9bicHXWQdBmAbSevKZxGCFGeHLt8CwBdVmKp71utVtPS2wxArE11klPTSj2DKFtOnz5Nq1atOHPmDL6+vuzZs4f27dsrHUsUIm/A84ULF2I2mxVOI8SjuZueyfqLBgDsbp2mZ7unFE70aJoG14L4swAs2RulcBpRlijeUqpBgwbExsZaLnv37lU6khAAbD1yEQDT7Ss4OdgrnKZiGBgaBIDdEw1JSEhAr9eTnl56gxYLIcqneL0tAEGeypyLRw/oQFZSLLZOVZgZuV2RDKJs2L17N23atOHGjRsEBwdz4MABQkJClI4l7mPQoEHY2dlx+vRpjh07pnQcIR7J+//biM6jOtmpiXwc0VHpOI9lRFgdAFTe9Tn8lxSmRC7Fi1I2NjZ4e3tbLlWrylgNomy4kpr7b4CLsjkqkt6tG9HQW8fN1BwCGz6Fl5cXq1atkl8vhRD3lZmtx8Yjdzyp8CZBimSws9VSV5cCwPksN7L1BkVyCGWtXLmSzp07k5KSQuvWrdm7dy/+/uVnoOHKqEqVKjz77LOADHguyqf9x89z27kuAKEe6eV+4qVOLRuhv3kWtVrDN79KoVjkUrwodfHiRXx9falVqxYvvPACMTExSkcSgozMbNQeNQHo1FSZL0EVTXp6Oj/+uIRXWnvR0McBv6YdaN68OT179mTJkiXSYkoIUahtB09hY6tDn55Cq8Z1FMsxbnAH9Gl3sK/izVcrpLVUZTNnzhwGDhyIXq+nb9++bN26FXd3d6VjiSLI68L3008/odfrFU4jRNGZTCa+2HwOjdYW/c0zvDGwfLeSyvNs42oAZHvUJSomVuE0oiwo8ux7f3fx4kV27txJQkICJpMp33X//ve/i7ydFi1asHDhQurWrUtsbCyTJ0+mbdu2nD59Gmdn5wLrZ2dnk52dbfk7NTX1UeIL8VDr9xzFxs6d7LtJhDV7Wuk4FYJWq+XNN99k99lYvvxwPPXcp9K2piODBg3k8OHDDB48WOmIQogyaN+ZGHCqjyrlOjYa5c7Hbi5OeBtukEQVDsapZBbRSsJsNjNx4kRmzJgBwGuvvcbs2bPRaDQKJxNF1blzZ7y9vYmLi+PXX3+lT58+SkcSokj+u/Q37H3rkaPP5N3ejSvMe86gzi1ZPfM3dN6BfL5qL1+PlUkiKrtiv7Lnz59PcHAw//73v1m5ciVr1qyxXNauXVusbXXr1o0BAwbQqFEjunTpwq+//kpycjLLly8vdP3p06fj6upqufj5+RU3vhBFsvfMDQC0d29gIx88rSI5OZnk5GQWf/4Rm49confT6uy+lMK+P0+SnJxMSkqK0hGFEGVQTGruj19POCkcBBg3MIycrAx01QJYuGGP0nFECTMYDIwYMcJSkPr444/56quvpCBVztjY2DB06FBAuvCJ8uNaXCJH7+a2xvTNvJw7SHgFoVaraR+QO1bkbYcA4m8nKxtIKK7YRamPP/6YqVOnEhcXx/Hjxzl27JjlcvTo0ccK4+bmRp06dYiKKnzQs4kTJ5KSkmK5XLsmM3iJkhFn0AEQXE0GOLcWNzc33NzcCG/XmvBgT9YcukLHkCcY/806qlWvgaurq9IRhRBljMlkwujsC0DLetUVTgN+3lVxSs39jPLbOSmkV2R37961dC/XaDQsWLCA999/H5VKpXQ08QjyuvBt2LCBW7duKZxGiIebtHgnds5VyLwVw5SXeiodx+r+2S+czMTr2Dq4MGvZDqXjCIUVuyh1584dBgwomSZ2aWlpXLp0CR8fn0Kvt7Ozw8XFJd9FCGuLS7yDnWcAAL1aN1Q2TAViMBj48ssviYyMZPCgQQzt3ppZG0/zTp+nmPDdRpJSZUwpIUR+h05HYefsjtGQTZdWjZWOA8AbvZ/GlGPA3qcu63cfUTqOKAHx8fGEh4ezZcsWHBwcWLduHSNHjlQ6lngMDRs25KmnniInJ4eff/5Z6ThCPNDKbQcx+TQCYFAjZ3R2tgonsj4bjYbGbpkAXDF5kZaRpXAioaRiF6UGDBjAli1brLLz8ePHs3v3bqKjo9m/fz99+/ZFo9EwZMgQq2xfiEexdvdR1BobMm/foFGdAKXjVBiOjo4MGzaMDRs2cPjwYTJuxzJ/4gi+2RXNyx3qsXjPZVLSpDAlhPg/O49dBMCQGIOTQ9louRpSuwbqhLMA/HwwWtkwwuqioqIIDQ3lyJEjVK1alZ07d9K9e3elYwkryGstJV34RFmWkZnNspN3AVDHnqR/x5YKJyo5bw3qSFZKIvauVfly2Tal4wgFFXug86CgICZNmsTBgwcJCQlBq9Xmu37MmDFF3tb169cZMmQIt2/fxtPTkzZt2nDw4EE8PT2LG0sIq/nzShJ4PYGL4bbSUSoclUrFc889x+DBg0lJScHV1ZWTVxL4akc0NWv488rXm1nwVs8K+YuQEKL4zsdngA9UtclUOko+L3ZswP/OgMa7PvuPnye0SV2lIwkrOHz4MD169ODWrVvUrFmTzZs3U7t2baVjCSsZMmQI48aN4+jRo5w6dYqQkBClIwlRwL+/34jOswH6tDt8Oqy90nFKlJODPQGqeOKoyvFkHTlGo4zlW0mpzGazuTg3qFmz5v03plJx+fLlxw5VVKmpqbi6upKSkiJd+YTVDPh8G7qqfrSwv8brAyrG1Ktl3bItB1h3zQGNrT3mm6f4YXxfeVMSQljOx20cb/Jyv3Cl4+QzZMZqtL4NUMeeZOG7MnNQebdp0yb69+9PRkYGTZs25ddff8XLy0vpWMLK+vXrx5o1axg3bhyfffaZ0nGEyOfo2ct8tj8VG1sd9c2XeG94xW+lGX87mbdWRqF1cKal/TVek+9eFUpR6zXF7r535cqV+15KsyAlREn4KyoGXVU/TCYjfdo9qXScSmNQ51a0d0/ClGNA5RvCK5+vxmQyKR1LCKGgKzfi0VXNnWW3W2jZa9EwoPkTABiq1uPclesKpxGPY+HChfTq1YuMjAw6derErl27pCBVQeV14fvxxx/JyclROI0Q/8dkMvHpuhPY2OrIij3Pu0O7Kh2pVHh5uOGecQWAndHZ8vm/kip2UUqIimz9vlMAZCdEU93LQ+E0lctLfcNpor2G2WRC79WIt+asVjqSEEJBvx04DUDmrRj8vKsqnKagfs88TVbsBTRaW75cc0DpOOIRmM1mpk2bxsiRIzEajQwdOpQNGzbg7OysdDRRQrp3746npyfx8fFs3rxZ6ThCWMxZvg1b3/oYDXre6lwXtbryfE0f+1wbjIZsdN5BLN96UOk4QgGP9Gq/fv06c+fO5b333uPtt9/OdxGiPPsrLnfckmo2MuC2EsYP7UYtfe7AxsnuIfxr3lplAwkhFHMyJgkAp5xkZYM8QMcgJwCSnWpx81aSwmlEcRiNRkaPHs37778PwIQJE1i0aBG2tjKmYUWm1Wp5/vnnARnwXJQdcYl32H/bEQCPu5VvnMIgfx/sbp8HYO3xeIXTCCUUuyi1fft26tatyzfffMPMmTPZuXMnP/zwAwsWLOD48eMlEFGI0mEymdA7+QLQup6vwmkqr8kv9aZqcm4LieuOwXyyaKPCiYQQSkg0OgBQ19tR4ST3N+rZdmTeuopW58TMZTuVjiOKKDMzk4EDBzJ37lxUKhWzZ8/mk08+qVQtEyqziIgIAH755Rfu3LmjbBghgA8WbsPOpSqZt28w9cUeSsdRxCtdm2AyGbH1rc/2P04pHUeUsmK/+06cOJHx48dz6tQp7O3tWbVqFdeuXSMsLIwBA2SgT1F+/X70LHYuHuToM+nVrqnScSq1z17viy7hJACnzQHMXSHTxApRmaSkpWNbtQYAHZuV3V+MbTQamnnmjktzXe3D3fSyNUugKOjOnTt07tyZ1atXY2try7Jly3jjjTeUjiVKUZMmTWjUqBF6vZ7IyEil44hKbsPvR8j2bAhAr9panB11CidSxtMhtTHHnQHgh13nFU4jSluxi1Jnz55l+PDhANjY2JCZmYmTkxMfffQRM2bMsHpAIUrLlj9zu40ZE6Mr7RtCWaFWq/lm7HOoYk+i1tiw764XP/66V+lYQohSsvnAKTQ2WrJTb9O03v1n/S0LxgzsSFZyPHbOHsyK3Kp0HPEA165do02bNuzduxdXV1c2b94sP6hWUnkDnksXPqGkbL2BRYduoVKrMd88xfAebZWOpKhhbYJy/+MVzLFzV5QNI0pVsYtSjo6O6PV6AHx8fLh06ZLlusTEROslE6KUXU4xA1DDSWZ9KAvUajXfvdWHnJun0Wht+fWGI+t3H1E6lhCiFPxx/gYANmmxZb5Llc7OliBt7nhSp+86YzDIjF5l0enTp2nVqhVnzpzB19eXPXv20L59e6VjCYW88MILaDQa/vjjD86dO6d0HFFJTV6wEZ1XTfQZqfxnSGul4yiua+smZN88h1pjw9cb/lQ6jihFxf6k17JlS/buzW2x0L17d8aNG8fUqVMZNWoULVu2tHpAIUpDZrYelfv/7yrSNFDhNCKPna2W797oQfbNc9jYO7D0rJFdf/6ldCwhRAm7kZ778aSGq0bhJEUzfkgH9Okp6Dx8mbtqh9JxxD12795NmzZtuHHjBsHBwRw4cICQkBClYwkFeXl50a1bN0BaSwll/BUVwxWNPwD1beII8vdROFHZ0KOhOwAZVWpz5YYMel5ZFLsoNWvWLFq0aAHA5MmT6dChA8uWLSMgIIDvv//e6gGFKA0b9xxFa++IPu0OzzzdUOk44m+cHOz5+p/hZMZFYevoytyDyRw9e1npWEKIEpJjNILbEwC0buCvcJqicXd1plp2DAB7r5swmaTFbVmxcuVKOnfuTEpKCq1bt2bv3r34+5eP15UoWXld+JYsWYLRaFQ4jahspq46jNbekcy4i/wrorvSccqMod1akxl/GRtbHZ+v3KN0HFFKil2UqlWrFo0aNQJyu/LNmzePkydPsmrVKmrUqGH1gEKUht//ug6AJvU6Npry8ct8ZVLVzYVZw1qQeesq9q5Vmb4lhvPRN5SOJYQoAXuOnsXWwYWcrAw6tig/rVneHtCOHH0mOq+a/Lhpn9JxBPDVV18xcOBA9Ho9ffr0YevWrbi7uysdS5QRvXr1okqVKty4cYPt27crHUdUIt+t3omNb0NMOQZeDQuQ7x5/o1arafNE7uORYFeDxORUhROJ0lC2B2oQopTEZdsDUM/TTuEk4n78vKvycb8GZCbFonP34YPVf3Ej/rbSsYQQVvb7ydyWkDlJMdjZahVOU3QBvtVwuJM7YcbG00kKp6nczGYzEydO5I033sBsNvPqq6+ycuVKdDqZxET8Hzs7O4YMGQJIFz5RepJS7rLtRm7RxfnOWemhUYjXnnuGzNs3sXV0YVakdImvDIpUlHJ3d7cMYl6lShXc3d3vexGivIm/nYxttdzZnXqGyhtDWVY3oDoTOvmRnZqIzrMGby0+SFLKXaVjCSGsKCoxdzIVb3uDwkmK7/WezTAZc7Dzrceve48pHadSMhgMRERE8MknnwDw8ccf8/XXX6ORlgiiEBEREQCsWbOGlJQUZcOISuH973/D3s2LrDtxTP1HV6XjlElarQ0NnXM/30cZPMjM1iucSJQ0m6Ks9Pnnn+Ps7AzAF198UZJ5hCh1v+w+hlrjS2bSTZ6sF650HPEQzeoH8kp6Jt8eSUXnHcSr87bz/RtdcXKwVzqaEMIKsu2rYg88FeildJRie7JeTVS/rATfEJbuu0T3Nk8qHalSuXv3LgMGDGDz5s1oNBrmz5/PyJEjlY4lyrBmzZoRHBzM2bNnWbFiBS+++KLSkUQFtv2PU9x1r48a6ORnwt3VWelIZdbbgzvx4qJj2LtV48tl23hvuIy7VZEVqSiVNxDgvf8XoiI4fDkRvHxx1icqHUUUUXjzhqSm/8myixnY+QbzzzkbWfj2s2i1RTqlCSHKqDOXr2Hv7oPJZKR7aCOl4zySkeH1WHgeVN71OXTqIk+H1FY6UqUQHx9Pjx49OHLkCA4ODqxYsYLu3eVLjHgwlUrFiBEjeO+991i0aJEUpUSJyTEamfd7DDrvIHJunualCc8pHalMc3bU4WeKIwEPjiRqyTEaZeytCqxI3fdSU1OLfBGivMmwrwZAE39XhZOI4ni2fTO6+qZhNOjR+Dbkpc/XyIxXQpRzW/44A0D2rRg83cvnOfmZpxuiv3kGtVrDvN+OKx2nUoiKiiI0NJQjR45QtWpVdu7cKQUpUWRDhw5FrVazd+9eoqKilI4jKqipCzei8w7CkJXOBwOeVjpOufD2oPYYMtPQefrz/S+7lY4jSlCRilJubm5UqVKlSBchyov09HTik9PRuHqjAp4Lb6Z0JFFMw3u0pZVTHCaTEZNPI177YpUUpoQox/66kfvjlivle6y4vk96A5DtUZeLV28qnKZiO3z4MKGhoVy+fJmaNWuyf/9+nn5avvCJoqtevTqdOnUCYPHixQqnERVRVEwsZ3N8AKhpjKF+LT+FE5UPvp7uuKXlTn6yPSpD4TSiJBWpKLVz50527NjBjh07WLBgAdWqVePdd99lzZo1rFmzhnfffRcvLy8WLFhQ0nmFsAqz2cyqVavoODC3mfadq2fY/tsGzGazwslEcY0e2In65isAZHg24p25axROJIR4VMnkjq/RwNdF4SSPZ0DHFmTGRaHR2vHF6n1Kx6mwNm3aRPv27bl16xZNmzblwIED1K4t3SVF8eUNT7J48WL5cUtY3Yc/78PWwYXM+CtM/kdPpeOUK2/2bYXRoMfepzartv+hdBxRQopUlAoLC7NcFi9ezKxZs5g+fTq9e/emd+/eTJ8+nc8++4wffvihpPMK8djS09NZsmQJPXv2pGP3PgA8QQI9e/ZkyZIlpKenKxtQFNu/InpQPS23288t14Z8+L91CicSQhTXraQU7Dz9Aej8dLDCaR6PWq0mPMAOgCSHmsTfTlY2UAW0cOFCevXqRUZGBp06dWLXrl14eZW/wfFF2dCnTx9cXFy4evUqu3dLNyFhPYs27EHtG4LJZCSiRTUZ/7SY6tV8Am3iOQBW/nlD4TSipBSpKPV3Bw4coFmzgt2cmjVrxqFDh6wSSoiSpNVqefPNNxkW8Q+mvPIcg5t6MvWNIQwePJg333wTrVardETxCKa/2hfX26cAuKStzcylvymcSAhRHJsOnESt1pB1J44GQf5Kx3lsL/cLJzPxGloHZ2ZG7lA6ToVhNpuZNm0aI0eOxGg0MnToUDZs2GCZJVqIR6HT6Rg0aBAAixYtUjiNqCjupmeyISoHAPtbf9GjbVOFE5VPL3duhNlkQuvbgJ2HTysdR5SAYhel/Pz8mD9/foHl//vf//Dzk/6xouxLTk4mOTmZJM+m/H4ple4N3Pn+f/PZunUrycnJpKSkKB1RPKIvx/RDG3cSlVrNMf0T/G/tLqUjCSGK6M+oeADsMm8pnMQ6bDQanqySDcBVvEjLyFI4UflnNBoZPXo077//PgDvvvsuixYtwtbWVuFkoiKIiIgAYOXKlaSlpSkbRlQI/5q/EZ2HL1kpiUwd2UnpOOVWaJO6GONye0T8sOOswmlESSh2Uerzzz9nzpw5hISE8OKLL/Liiy/SqFEj5syZw+eff14SGYWwKjc3N2o1DaPvkAjaBbny9feLGTVyJJ06dcLNzQ1X1/I545PI7TLz7dv9MN08hdpGy87bVVi+9aDSsYQQRRCfldtKtZZ7xSkwvDWoI1kpt7BzqcoXy7YpHadcy8rKYuDAgcydOxeVSsWXX37JjBkzUKuL/VFWiEK1atWK2rVrk56ezqpVq5SOI8q5vcfOkeRaD4A2nul4ebgpG6icG9IyAABTtWBOXohWNIuwvmK/k3fv3p0LFy7Qq1cvkpKSSEpKolevXly4cEGm3xXlQnpmFq9/PI/X2vry/tfLGP3iCAYPHkxkZCRffvklBoNB6YjiMdhoNMx/qzf6m2fQ2Nqz5oqWzfuPKx1LCPEA2XoDGvfcLnthjWspnMZ6HHR21FTntvw6kazDYMhROFH5dOfOHTp37szq1auxtbUlMjKSMWPGKB1LVDAqlYrhw4cD0oVPPB6TycTsrRfQ2GjR3zzD6AEdlY5U7vUKe4qs2POobbR8te6w0nGElanM5Xi6sdTUVFxdXUlJScHFpXzP1CNKz6LfDvNceFO+2RXNf0c9w62bMbi5ufHll18ybNgwVCqV0hGFFaSkpfPS3B3Y+9Qh++4d3mpdhVaN6yodSwhRiN/2HeenyzoMGXdZ8uKT2Gg0SkeymltJKbyx4gK2Di48bRfD6IHShaM4rl27RteuXTlz5gyurq6sXbuW9u3bKx1LVFAxMTEEBARgNpu5cuUKAQEBSkcS5dAnizZyRh1Ejj6Td1q78mS9mkpHqhB+WLebnSne5GRl8EnPJ/D38VQ6kniIotZrHqnN8549exg6dCihoaHcuJE7Cv6SJUvYu3fvo6UVopQcPXsZW4/qzN1zk1ouRq5fuUhCQgLx8fE899xzUpCqQFydHJnzj7Zkxl/BzrkKn/+ewKmLV5WOJYQoxJ7T0QCYk69VqIIUgKe7K1Uzc889u68aZLr5Yjh9+jStWrXizJkz+Pr6smfPHilIiRLl7+9PeHg4kPvdRojiiom9xfEMDwB8sy5LQcqKRvRsS2bCFWzsHZi1QmbJrEiKXZRatWoVXbp0QafTcfToUbKzcwfxTElJYdq0aVYPKIS1mEwmPl13gk3n7vLn0WP0bRGEra0tnp6e2Nra4ujoqHREYWVeHm58OuRJMhOvY+9WjY82RHHlRrzSsYQQ94hONgLg61AxCzZjn2uDUZ+FzjuQZVtknLui2L17N23atOHGjRsEBwdz4MABQkJClI4lKoERI0YAuV34ynGHEqGQSUt2YetUhcxbV5nyYk+l41QoarWalt65/4/TPkFyqkxIUFEUuyj18ccfM2/ePObPn49Wq7Usb926NUePHrVqOCGsac7ybdj61sdo0PNW57oyOGolUbO6F//uGURWcjy6qk/w7s/HiEu8o3QsIcT/ZzKZMDjmfsp8uo6PwmlKRqCfN3ZJFwD45USCwmnKvpUrV9K5c2dSUlJo3bo1e/fuxd/fX+lYopJ47rnncHJy4tKlS+zbt0/pOKIcWb71IGafRgAMaeKGzq7iTNxRVowe0IGspFhsnaowM3K70nGElRT7W/n58+dp165dgeWurq4kJydbI5MQVheXeIf9t3NbQnncPU9oExlbqDIJqV2Dse28yL57B51XTcYs2EtKWrrSsYQQwPHz0di7VsWYY6Brq0ZKxykxr/VoislkxNY3mC0HTigdp8z66quvGDhwIHq9nj59+rB161bc3d2VjiUqEUdHR/r37w/IgOei6DIys1lxOrfljib2JP2eeVrhRBWTna2WuroUAM5nuZGtlwmqKoJiF6W8vb2JiooqsHzv3r3UqlVxZswRFcsHC7dh51KVzNs3mPpiD6XjCAW0alyXUU3sMWSmYe9Th39+vYXMbL3SsYSo9Lb9eR4AfeJV3FycFE5TcprVD4S4MwAs/v2iwmnKHrPZzMSJE3njjTcwm828+uqrrFy5Ep1Op3Q0UQlFREQAsHz5cjIyMpQNI8qFSd9vQFfVj+y7d/jo/7V33+FRlekbx7+ZyWQy6SSEFAhSpQdBQUB6FQSlSLGABUUFVMDCuq7r6lrXhgUbi2JDECkKCIiAgAIaUTf0Xk0hEJKQZJKZzMzvj/nJ6ooaIMmZmdyf65pLCWfOuT3mzZw85z3vM6aH0XEC2j2jelF66iShNRJ5+aMvjI4jFeCsi1K33nord999N9988w1BQUFkZGTwwQcfcO+993LHHXdURkaR87Jk3WZK41sCMKixhchwXeBWV/06XcSQ+k5cjhJCkptz67RPKXO5jI4lUq3tzPLeWY41Bf4vfqO7NPL+S2Jzvt+x39gwPsTpdHLjjTfy1FNPAd6lIqZPn445wBa9F//RpUsX6tWrR0FBAYsWLTI6jvi477bvI8vm/fl+ceRJUhJrGpwosMVERZDs8jZb+ybbpAYiAeCsi1J/+ctfuPbaa+nVqxeFhYV07dqVW265hdtuu40777yzMjKKnLNSh5N3vs0hyGTCk7GFMVd0MTqSGGxEnw70iDuJu8yJKbkVtz2/QB9mIgY6ZY4BoHXdGsYGqQL9Ol1EacYOTCYz05dsNjqOTygsLGTQoEG8++67mM1mZs6cyYMPPqhuuGIok8nEmDFjAD3CJ3/M7Xbz7OItmENCKc3Yyb3X9TM6UrUwZXg3ykqKsdWqx9uL1xkdR87TWRelgoKCePDBB8nNzWXr1q1s2rSJnJwc/vnPf1ZGPpHz8shbS7El1MdRXMDD11xmdBzxEbcM7k5b61E8bjfOxFTufmmB0ZFEqqWfsk9gi/cuYN2vQ0uD01SNK1O9d9BLYi9k35Esg9MYKzs7m+7du7NixQrCwsL49NNPufnmm42OJQJwuii1cuVKjh49anAa8VUvzV1JSHIzbyOly5uqkVIVSUmsSUSBd0mhFbsKDE4j5+ucR01ISAjNmzenffv2REQE7hoQ4r+27T3MAbP3l53mwVk0qhuYXZ3k3Ey59nIaOr3ruuTHteIvry00OJFI9fPZhnQA7CeO0jAl0eA0VeOafp2wZ+/HHBLKtPlfGR3HMHv37uWyyy5j8+bN1KxZkzVr1jBgwACjY4mc1rBhQ7p06YLH4+H99983Oo74oKzjJ9mYGwlAzVO76NhajZSq0p1Xtsdd5iQ0qQmL1qQZHUfOQ3B5Nyzvnau33nrrnMOIVKTH56dhSW6JPWsPf52iC135rX/cciX3vDKfnOiWZEQ05/G3l/DgTQONjiVSbfxw8DjUTCbMkWt0lCpjMpnomhJMmgNyQi/geF4BNWOijI5VpdLS0rjiiivIycmhfv36rFixgsaNGxsdS+Q3brjhBtavX88777zD1KlT9Vip/MqDb3+BNTEV+4mjvDpO149VrVXjCzAvnIcnKZW53x5hcI92RkeSc1TumVKzZs1izZo15OXlcfLkyd99ifiCNxasJji5Je4yJ3d0q0ewFkuV3/HM+CGE5Xhna+wwNeCVj1YanEik+jjuDAXgwvjq1YDi9qE9sJ/4iZDwKJ77cJXRcarUsmXL6N69Ozk5ObRt25aNGzeqICU+a/jw4dhsNnbu3Mm3335rdBzxIYvXbsZRy/vY+eAmViLCQg1OVD3d0tv7/yA4sRlf/bDT4DRyrspdlLrjjjvIz8/nwIED9OjRg5kzZ7Jw4cLfvESMlpt/ilU/eScBRp7cQc/21WOdEjk3JpOJVycNw5SZjslkZmNhIu8uXW90LJGAV1hcgqXmBQD0bFu9ihIWSzCtoooA2FdWk2J7qcGJqsasWbMYNGgQxcXF9OnThy+//JKEhASjY4n8rqioKIYOHQpowXP5r1KHk3e/+28jpev6dzY6UrXVpW0znBnbCDKZmLFyi9Fx5ByVuyg1ffp0MjMzuf/++1m8eDEpKSmMGDGCFStW4PF4KjOjyFn568zlhMYkUHIyi8fHXm50HPEDJpOJGZOH4MrYitkSwvKMCD2bLlLJVm7agtlipfTUSS5tVb2KUgCTR/amtOAEoTG1eOmjL4yOU6k8Hg9PPPEEN910Ey6Xi+uvv54lS5YQGRlpdDSRP3XDDTcAMGfOHEpKSgxOI77gHzOXYKtVH0dRAf+4VgUpow1vVweAsvhmbN9/xOA0ci7OaqFzq9XKNddcw8qVK9m+fTstWrRg/Pjx1KtXj8LCwsrKKFJuKzelUxjbHIDeddzERuuCV8rHYgnmjTuvoDRjB8GhYczZBWvSthodSyRgbdzhvXA0ncqolt2KIsNtpODtvrc510qZy2VwosrhcrmYOHEiDz74IAD3338/77zzDiEhIQYnEymfnj17UqdOHU6ePMnixYuNjiMG27LnEIeC6wHQPCSr2jTp8GVDe7anJHM35mALLy3aZHQcOQfnfBVoMpkICgrC4/HgCtALKfEvZS4Xb64/gskcTFnGVsYN7WF0JPEzEWGhvHZ7L+xZewkJj+L1b/P5bvs+o2OJBKQj/38vq25k9V04+N6RPXDaC7HVTOHfi740Ok6FKykpYcSIEbz66qsEBQXx4osv8vTTT1fLIqT4L7PZzOjRowE9wifwxILNBIeGUZK5h7/eoEZKvqJP4wgA8iMb8lP2CYPTyNk6q6uC0tJSPvzwQ/r06cOFF17Ili1beOWVVzh8+DARERGVlVGkXB6ftRRbYiOcJUU8OEzdF+TcxEZHMm1MB+w5h7BG1eRfK4+w88BRo2OJBBS3240nqjYAHZvVMTiNcRJr1qBG4X4AVu23G5ymYp08eZK+ffuyYMECQkJCmDNnDnfddZfRsUTOyc+P8C1fvpysrCyD04hRXp+/CktyC28jpR5qpORLxl7VDXvOISyh4Tz30ZdGx5GzVO6i1Pjx40lKSuKpp55i4MCBHDlyhHnz5jFgwIAKueP11FNPERQUxKRJk857X1L97D2cyY6yJADquw7TolFdgxOJP6udEMdjQ1tgz80gNDaJhxZu50jWcaNjiQSMDf/ZTUhEDC5HCX07pBodx1B3D+2Ey+nAltiYhQGylt2RI0fo0qUL69evJyoqihUrVjBixAijY4mcsyZNmtChQwdcLhcLFiwwOo4Y4HheAaszvI8dR53cQY92aqTkS0wmE5fElwHwkzmZ/MIigxPJ2QjylHOVcpPJRN26dWnTpg1BQb8/1f5cflCnpaUxYsQIoqKi6NGjB9OmTSvX+woKCoiOjiY/P5+oqKizPq4vKSoqwmKxkJeXR0xMDE6nk/DwcKNj+Y3rn/4YU3Ir7NkHmH13byyWYKMjSQD4fsd+dpw08VOxmewTeTw8sDElRQUao1VIPxsD02NvL2F3cGNKMnfz0f2DjI5juJc/2URaQQ1aJYZyQ2ub332v/3KcRkdHs3r1aj7++GMaNGjAlVdeSatWrYyOKHLevvzyS/Lz8+nduzdFRUV+N07l/Nz23DzstVIpOZnFmzdeTEyUnhLyNfZSBze8uYnQmAQalO7iH7dcaXSkaq+89ZpyT3EaM2YMPXr0ICYmhujo6N99na3CwkKuu+46ZsyYQY0aNc76/YHA4/Ewf/58EhISTr/mz5+vrobl9M6S9ZiSW+F2u7jx0loqSEmFadusARclBDOhSzIJcTGMfGIeSbXraIxWEf1sDFx7cryPqsVb1MkKYPyg9rRMtLElq4QmbTv71ff6/47TxMREsrOzmTFjBrfffrsKUhIwunXrxsmTJ6lTp44+k6qZlZvSKYrzNlLqW9ejgpSPsllDaBySC8C2oihKHU6DE0l5lfu391mzZlVKgAkTJnDFFVfQu3dvHnvssUo5hi8rKipi/vz5DBw4kLU7s3n3hUdo164dAwcO5L333mPYsGG6A/MHThXZWbK3DFschOZs44obhhsdSQJMvcQazFmwmPFDBgLdKT71HKG7P9MYrWS//Nn40YJP+GL1Gtq1u0TnPUAUh9TEBrRtEG90FMP9/L1++7ARvL4xhyNX301C8R4GXTWYf89dQqNmrThy1DdbXKfUSWHvji1cfdVgPvvqe9Zu+JZundpz1ZChzPxoKW0u7USmQ49QiP8rKSnhh282cPWQoSzf8COffvwh7S5prc+kasDpLOPN9UewJTbClbGVW6YOMzqS/IF7RvVi/Ozt2GKTePXj1Uy+tp/RkaQcyv34XmWYM2cOjz/+OGlpaYSGhtK9e3cuuuii3318r7S0lNLS0tN/LigoICUlxa8f33M4HCQkJHDd1Od4avINLPtmB71aJjNq1CjS0tLIzs5W2+Q/cOe0j8mPa0VJ/nFevqYFCXExRkeSAPPzGO03bDT/nv486/YW0LmejauHXKUxWol+Pu+9B4/i7ddeZs2uE3S+IJSRI4brvPu5vYczeXRtAR63m6cHJJAcH2t0JEP9/L3ec9Bw3pnxGuv25tO1UTSvrs9ga2ax0fHKpWVSGOO7JPtldpGz8fP3+pe7c+lSP5zrrh/N12tX6zMpgD0841MOhDbBaS/k4T4JNK1ffZtz+Iu7XvyYvFjvsi5zp/RVx1cDlffxPcOeczpy5Ah33303K1euJDQ0tFzvefLJJ3nkkUcqOVnVysvLIy8vjw/ffIF+/a9geNeWzFn9A1+sWo3H7SI/P5/4eN1JPpOvfthJbnRTzEDn+CIVpKRS/DxG5858me5dO3P7mBF8ti2X3JptyctbqTFaSfLy8iCyFqZLb2LdvgIGtU7g0x8zSNt+kLy8PJ13P7Z801agLiUnjpAc38zoOIb7+WfMgvdmcNXV1zDmyh7M37iHdd9sB6B5s2b8lJGB4xc35XxBiNVKcnIyO3bsYN1haBhewrCOjX+VvUWLFgQH65F68X9lzjK2bd/GusPQOKqMIe3r89m2XCIHPEgKiWQfP0lKcoLRMaWC7TmUwW53MhagoecITetfbHQkKYcpw7vy12UZ2BLq895nX3PDwC5GR5I/YdhMqUWLFjFkyBDMv2il6XK5CAoKwmQyUVpa+qu/g8CeKdWuXTvmzpvH14ccdG8Sy0OvzWPWo+PJzsrSnZczcLvdjHp2CaFJTXBkbGf2fVepCi6V4pdjdM6cOcxfsY5rhg7i1fUZfDzjeb5672mN0Upw5Hgh98xN55ImKdzRqRYrfjjA5Zc05oVl23ntnpEc3PGjzruf+nmx2OCsdN66T49c/+/PmJkzZzJ27Fi/mDHtz9lFzsb/fq/P+WQZo0cN57Wvs9maWUyk1UStwt3cd01vwmxWo+NKBflvI6X9zL67j9at9SO3PDsPR0IqpRk7mTv1KqPjVFs+P1OqV69ebNmy5Vdfu+mmm2jatClTp079TUEKwGq1YrUG1g96p9PJiy++yMCBAxk5fDg7jpcx4am3+Ocdw2lQry4Oh0MXdGfwr/eWEZrUhDKHnalXXaSClFSaX47RUaNGsXLlSjb95Wle/Mc9wBTmbdrPdV2bGh0zoGzff4SXN+Z7C1KXJTBq5Ei+WL2GqTOWc//QdoSFLuKn4/nUT9ZMKX+U6w7HBjRL0kKxcOafMStXrmTOnDksWbIEp9Pps9cB/pxd5Gyc6Xt90Zx3+eijj5m5sZj/5Lg5ZWnEDW9upGN8KXeN7E3wGX6XEf8xa/G6042UxnZMUkHKz9w5qB3PbCzCmtyUpeu/54oubY2OJH/AsN/kIyMjadmy5a9e4eHhxMXF0bJlS6NiVbnw8HBGjx7NkiVLSEtL4+gPa/jg2Qd4dX0GN/W/lI/W7zA6os85nJnDj8VxACSX7KdN0/oGJ5JA9r9jFGDB60/yztKvGd8lmaOlYTz7/jKDUwaOw5k5PLxoJ/UTopnQNZmP5y9gw/ovcRTl8+ZfrueNNfu4rUdD5n6bwZGs40bHlbOUV1CItWZdAPq206N7cOafMWlpaSxZsoTRo0f79OLJ/pxd5Gyc8Xv922/59JOFTOl3IQOSCyk9dQJbbBI/uupxzQsreWfJenXm81P5hUUs3e8CwJazjcsvu8jYQHLWWjepR1C29/fo2RsOGJxG/oyhC53/rz9b6Px/lXc6mD8oKirCYrGQn59PdHQ0czfsI7MsggtiQ0lP+5rHbxtsdESfccO/5uFJSsWec4h3J3THZtVdWKl8/ztGHQ4H767ZSlzthixOP0bXqGOMG9rD6Jh+LSc3n/Ezv8aW2JB+Da1cdkEY8THhvzrvB7JOsiD9JA2S4/h41be8Ma4rsdGRRkeXcvpw+QaW5cRRkp/DnPGdNMv1F/73Z4zT6fSboo4/Zxc5G3/0vX48r4DH31tJlrUeFpt3Jmhpxk7GdErRLA0/899GSjlMv7YV8bHRRkeSc7D6263M2mXB43YzoY2ZDqkXGh2p2ilvvcanilJnK5CKUmcy6aWPya3RCoAW7GPq6AEGJzLeRys3sSSrBgCDa+cztGd7gxNJdVbmcnHzswsgORWXo4RBdYoY1a+T0bH80qkiO2Nf+ZzQ5KY4ivIZ3y6Crhc3P+O2a9K28sZmOyHhUZRm7GDmnZcTEVa+hhlirMkvz+dETEtcGVv4YOrVRscREalwB386xhMfrqUotilmi/fGqStjC3f2T9UvxX5g/fc7eP0/LszBFtpbDzNxRB+jI8l5GPX0QkKSm2POTOft+7WOZVUrb71Gtyh92PMTh2LNTgdgi+sCXvt4lcGJjFVsL2Xe1kIAzJnpKkiJ4YLNZt6YdBXOjG2YQ0L55JCV5V//aHQsv1PqcDLulWWEJjfFWVLE9c3Nv1uQAujRriWjmkBZSTHW5GaMe3kpTmdZFSaWc5VZ7F1jpX6M1uYQkcBUr3Yt3rx3OPd2ioDMLXjcbszJrXhls4Obn5nHroM/GR1Rfofb7eblL/ZgDrbgyNjO+Kt7GR1JztOQNokAOGo21djzYSpK+TCTycRrk4dCRjomczBfFcQze9nXRscyzN/+vQRbzRRKT53k0TF6TEp8g80awpsT+1OSuQuLLYJZ6SV89cNOo2P5jTKXi1tfWIQluQUuZymD6tgZ2PXPWy4P7tGOy5MLcTkdBCe35NYXFuJ2u6sgsZwrp7OMoBopAHRpVc/YMCIilaxN0/q8e//V3Ni0DEfGdkzBFsoSU3nkixwmTvuYrOMnjY4o/+Ppnxspldp5YHAbPWIeAIb3vhR71l7MlhBeXLDB6DjyOzTSfFyw2cyMyYO9MzEsVhYftbF0/fdGx6pyadv2kh3WCICLI0+SkljT4EQi/xUZbuPlsV2xZ+8nJKIGL32VQ/rug0bH8nlut5s7XvA+/uh2ldE5Kodr+19W7vePuaILHSOycLtduJNSGT9tvgpTPuzLzdux2CJw2gvpfkkLo+OIiFSJXpe2Ys7UIVyRkIs9ay/BVhsFca2YNG83D7y2kMLiEqMjCnAw4xj/Kfb+flG7dD+tm9QzNpBUCJPJRM/63iUeTkY0UDHYR6ko5QesIRbvTIyMnVhCw3lvq5N1m7cbHavKuN1unl2yFXNIKCUZO7n3un5GRxL5jYS4GJ659mLsx48QGlOLf362j31HsoyO5dOmvLKQ0oRUAFqaDnHHOUyTnziiD8093q4qxfGp3PfqwgrNKBVn/Rbv/yf3ySNYQywGpxERqVoj+3Zk7j39uTT0CPbjRwiJiOGniObcPPNbnnr3Mz2GbrCH319LSEQM9pxDPHrLQKPjSAW6dUh37MePYLFF8NzcNUbHkTNQUcpPRIbbmH5rd+zZ+wiJiOGVjbn8sLN6tLd8cc5KrMnNcDkdTOrXVFNpxWfVS67FPwZdSMnJLGxxdfjL3B91R+Z3/O2NReTWaAlAnaId/GXMuTdy+OuNV1C70Fuoz4luycMzPq2QjFKx9uc6AUiy6RcvEameTCYTE4b35v0J3Wjs3E1Jfg6hMQlsD2rItS+vYcbCNZrxa4C5n2/Ek+S9SXbNRTHq7B1ggs1m2tQoBeAwCZqd6IP0270fiY+N5rnr2mHPOUxodDxPLD/InkMZRseqVBk5uWw66W33HndqF50uamJwIpE/1qJRXaZ0T6L0VC62hPrc9dZX5BUUGh3Lp/zrvWUcDmsGQEzuFp64ffB57/PJO4YQfWILAPtDGvPcB8vPe59SsRxhtQBo1zjR4CQiIsayhlh46OZBzLihDQkF23AUF2CLr8v6wmRGPbuURWvSjI5YbRTbS/l4WxGgRkqBbNLI3pTk52CNqskLc1YaHUf+h4pSfqZuUjyPDG76/zMxkvnrx1vIyMk1OlaleWjWKqxRcdhP/MTjt1xhdByRcumQeiFj24ThLD5FaNKF3P7aSortpUbH8gmvz19FuqsuANbsdKbdObTC9v3iXUOxZKUTZDLxg6MOMxZqiravSN99kNCYBNyuMvp3am10HBERnxAdGc4zE4by7OAGhOek43KWEpp0IQuORnHN0wtY//0OoyMGvP82UsrlsRt6Gh1HKkmYzUoDcw4A6QXhelzWx6go5YeaN0jh3h7JlJ46ga1WPe6etYHc/FNGx6pwi9duxlHL+3jP4CYhRIbbDE4kUn59O7bm6kYuyhx2QpKbM+6lxdX+A/DD5RtYnx+PyRwMGem8NnlohT6OazKZeGPKUNwZWzAFW/gyN5aPVm6qsP3LuVuZ5u1IWXr8MLHRkQanERHxLXUS4nhtynAe6BqDKTMdt9uFJbkFb2zxcOO/5rFt72GjIwakXzZSuiQqj9oJcQYnksp0z8ie3lmJcbV5fYFuXPoSFaX8VPtWjRl3caR3YCU2ZvzrqwJqJkapw8m73+UQZDLhydjCdf07Gx1J5KwN63UpvePzcZU5MSW34rZpC6vtWhFL13/Pp0dCMVusODO2MWPyYILN5go/TrDZzIxJV+LI2I45JJSFByys2PBjhR9Hzs72DO+Nkxj0KKuIyO9p2agus+4fzriW4MzYhslkxp2UyhNrT3LH8/P4KfuE0REDxi8bKZVm7OSea9VIKdDFx0ZT034IgHVHnNX2mtwXqSjlx3pd2ooRjT2UldoJSW7GrQE0E+PhmUuw1aqPo6iAf1yrgpT4r5uv7MYl1p/wuN2UJaZy54vzjY5U5dZ/v4P3tjqxhIZTkrmLNyf2r9TuazZrCG9M6EtJ5m4stgje+rGEDT/uqrTjyZ8rMEUB0Col2uAkIiK+r+vFzflw6lAG186nJHM35pBQiuJTuWfRfu6bvoD8wiKjI/q9aXM+//9GSqVM7t9MjZSqicnDOuNylGBLaMicFRuNjiP/T6PPzw3t2Z4+tbwzMczJrRj3gv/PxEjffZDDwfUAaB6SRcMULYor/m3ytf1oXLYXgFM1U5n66gKDE1Wd/+w6yMsbTnjbLGfvY/ot3arkUdzoiHBeHtsFe/YBrJE1mLb+GFv2HKr048pvZR0/SWhN7zpi/S5tYXAaERH/MbRne+bcewVdIjKw5xwiJCyK7KgW3DrrBx57ewmlDqfREf1SRk4u3+R5b5bEF+6mQ+qFBieSqtIwJZHQ3N0AfJKeY3Aa+ZmKUgHgpiu7cWlYBm63C1dSKhOn+fdMjCcXfk9waBglmXv46w3n3iZexJf8fewgahVsAyAzsgWPvb3E4ESVb+/hTB5bdoDQ6Hjsx4/wzLWXEB9bdTNlEuJi+Nc1bbAfP0poTC0eXbKXfUeyquz44rVsg3fxeXtuJk3q1TY6joiIXzGZTNw6pAez7+xJc88+SvKyCY2OZ3dwY66fvpZX533h9zekq9rfZq3CGhmH/fhRHrtloNFxpIrdcUVb3G4X1uRmWuLBR6goFSDuGtmXJq59ABTGp3LvdP+cifH6/FVYklvgLnNyR496lbLmjIhRnp0wlIicdAB2mhrw0tzPDU5UeTJycnlgXjq2uGRKTmbxj0EXUi+5VpXnqF87gb8PbERJXja2mnX4y9wfyTp+sspzVGff7/feibSV6I6kiMi5sliC+cuYAcy8uR21C7fjKMrHVjOFTSUpjHxuGXM/16NI5fHJl9/h/P9GSkOahhIRFmpwIqlqlzRvCFnbAXhv/V6D0wioKBVQHrp5EEmnvDMxjkW14NGZiw1OdHaO5xWwOiMEgKiTO+jRrqXBiUQq3iuThmHOTMdkMvNNcTKzFq8zOlKFyysoZNLbG7DVqkfpqRPc2yOZFo3qGpanVeMLmNw1gdJTJ7El1Oeut77SehxVKNvh/bneqKYu/EVEzldkuI0n7xjCtKsbE3ViC2UOO7bERizNjmXU0wtZ/e1WoyP6rFKHk/c3nyDIZIKMdK7tf5nRkcQgo7t4uy6S2Jzvtu8zNoyoKBVonh4/lMjj3pkYe4Ib8cLsFQYnKr8HZ64gNKYWJSezeOKW/kbHEakUJpOJNycPwZWxBXOwhc+zo1i4Os3oWBWm2F7K7a99QWhSYxzFBdzSNoL2rRobHYuOrZtw80WhOO2FhCZdyG3TP8de6jA6VsCzlzoIjvMWJLtf1NDgNCIigSOxZg1emXQ1D/eKJzgrHberjJDk5ry9w8yYp+fxn10HjY7oc7yNlOrhKMrnkeu7Gh1HDNSv00WUZuzAZDLz2tLvjY5T7akoFYBevnsYwVneNTy+K63NW5+uNTrSn1q5KZ2iuOYA9K3rISYqwuBEIpXHYglmxl2DcGTsINhqY+4eWPXNFqNjnTens4xbX1pMSHIzyhx2RjT20KdDqtGxTuvX6SKG1HficpQQktycW6d9SpnLZXSsgPbFpi0Eh9hwFOXT6aImRscREQk4TerV5q37hjOhTTCujK3eWUDJqfzr61OMe24euQWFABQVFeFwODh27BgOh4Oiouo1Y/iXjZRaWo9Rv3aCsYHEcFelxgNQEnuh1hw1mIpSAchkMvHGpCG4/38mxhc50cxf9Y3RsX6X01nGm+uPYDJ7P0xvGdzd6EgilS7MZuXV23tRkrmHkLAo3tx8im+37DE61jlzu92Me2Eh5uRWuMqc9InPZ2jP9kbH+o0RfTrQI+4k7jInpuRW3Pb8Ai0QW4k2bD/s/Zf8n7RGoIhIJerYugkfTB3GiAsKKcnYidkSQkmtVN78OovSMjfzFiwkISHh9Gv+/Pl4PB6jY1eZ/zZS2s1fxuiJDIFR/Tpiz96HOSSUF+Z/ZXScak1FqQBlsQTz5l2DcGRsJzjExsd7zXy+8T9Gxzqjx2Z9hi2xEU57IQ+NuNToOCJVJjY6kmk3dcJ+7CDWyDieXZPB9v1HjI51Tia+OB9XUioet5v2tgxuurKb0ZF+1y2Du9PWehSP240zMZW7X/LPxhD+4FCBt+BXJ6L6/OIjImKkgV0vZs59g+gZk4392AG2H3fx4pc/MWz4SIbceh9B5mDatWvHwIEDee+996rFjKnXPv5vI6XxPRvoJokA3okcXVMsABy3XUBObr7BiaovFaUCWJjNyut39KEkczeWsEhm/lDMpvTdRsf6lT2HMtjtTgagoecITevXMTiRSNVKjo/lyeGp2E9kEFojkYcX7eRwpn91Kbtv+gIKa3of02vs2svdo/oanOjPTbn2cho6vTPT8uNa8ZfXFhqcKPC43W5ckUkAdGiSbHAaEZHqw2QyceOgrnw4qQ+3XFqTb7bs5rWvsnjpn1OZv2E3H82bz6hRo7j77ruxWCxGx61Ux/MKWJPpbbgRnbeD7pe0MDiR+JLbh/bAfuInQsKieG7uaqPjVFsqSgW4mKgIpt10GfZjB7BGxvL8l5ls23vY6FinPTJnA5awSOzZ+3n45oFGxxExRKO6Sfz18nqU5Odgi6/LPe+n+c3dmkffWkx2lPcCL7FgG3+/eZDBicrvH7dcSXy+t0tRRkRzHn97icGJAst32/ZhjYzD5XTQr2Nro+OIiFQ7wWYzTWNcLLqvP289/QCrt2cxpH19Nhx1EnzZOEKTm5Kf7x/XG+fqdCOl3EweH6vH9uTXLJZgWkV5Zwvud8VTbC81OFH1pKJUNZAcH8tTIy7CfuIooTUS+cfi3RzMOGZ0LGYtXocpuRVut4ubOiRisQQbHUnEMG2a1mdix1gchXnYEhsyYcaXnCqyGx3rD037cAV7zN6WuhHH0/nXhKEGJzp7z4wfQniOt2PpDlMDXvlopcGJAseq770zc53HDxEZbjM4jYhI9RQTE0NUZDh1g47R+QIbsxZ9QdeGUXS/7FL6/GUWM78v5otvthods1J8vvE/pxspXV4/SI2U5IymjOpDacFxQqPjmTb3C6PjVEsqSlUTDVMSeWhAQ0ryjmGrmcJ9szeTfSLPsDz5hUUs3e9da8SWs40BndsYlkXEV3S9uDnXtwjGWVJEaHJTxr2yjFKH0+hYZ/TWp2tJK6lNkMlEcFY6r9w9zOhI58RkMjF90jBMmemYTGY2Fiby7tL1RscKCLuyiwGIC/bt4qqISCBzOp28+OKLzJkzh1GjRnHTkD6MGjWS2zrE0TIxlO3HSnh3t4Xrn/6YtG17jY5bYZzOMmZ89dPpRko3+/Bal2KsiLBQ6pINwA8nrerMbAAVpaqR1AvrcVfneByFJ7ElNODOmevILzRmccMH/70MW2wSJfnHeeymPoZkEPFFA7tezKA6dlzOUizJLbj1hUU+9+E4f9U3fJETjTnYgitjC29MGoLJ5L8fJyaTiRmTh+DK2IrZEsLyjAgWrUkzOpbfK7LUAOCienEGJxERqb7Cw8MZPXo0S5YsIS3N+9n29drVfLLgY+7pVZe2kXkAmJJb8eK3Jdzy7Dz2Hs40MHHF+OespdgSG6qRkpTLPSN74LQXYquZwoyFXxodp9rx398i5Jx0btOUMa2sOO2FhCY14fbpK7CXOqo0w/rvd3AyuikAXeKLSYiLqdLji/i6a/tfRpfoHNyuMkhO5Y4XFuB2u42OBcDKTel8vNdMcIgNR8Z2Ztw1KCAevbVYgnnjzisozdhBcGgYc3bB6m8D83GGqnAwwzsrF6B/x1YGpxERqd6CgoIYNmwY2dnZHDt2jOzsbIYNG4bZFMSkwZdyfaMSHBk7MAVbcCSk8vcVWdz14sd+s77l/9p18Cf2eLzNkxpxVI2U5E8l1qxBjcL9AKw+UOIz193VhYpS1dCAzm246oJSXI4SLMktuG3aJ1U2E8PtdvPyF3sxB1twZGxnwvBeVXJcEX9z+7BetDIfAqA0IZUprxjfHW5T+m7+/X0hlrBISjL38PodfQizWY2OVWEiwkJ57fZe2LP2EhIexRtpBXy3fZ/RsfzS8o1bALAfP0LdpHiD04iISHh4OCEhIcTHxxMSEkJ4ePjpv+vbsTVzpg7m8prHsWfvIzg0jLzYVkycs4MH31hEYXGJgcnP3qNzN2KxRWDP3s/fb7rC6DjiJ+4e2gmX04EtsREfr/rW6DjViopS1dSofp3oViP39EyM26toJsZT7y4jNOlCyhx2pl51kV8/8iNS2aaOHkBK8Q4Acmu05G9vLDIsy7a9h3n+y0yskXHYjx1g2k2dAnLB0NjoSKaN6YA95xDWqDj+tfIIOw8cNTqW3/nPoVwAIpwnDU4iIiLldW3/y5g75XIuCTmE/cRRrJE1OBLWjJtnbOKZ95f53HICZ/L2p2sx/38jpbEdkwJiNrdUjSb1ahNyfCcAC773/0dY/YkqAtXYuKE9aB18GI/bjSMhlUkvL6jU4x3MOEa6vSYAtUv206Zp/Uo9nkggePy2wdTI9c46ORzWjH+9t6zKMxzMOMY/Fu8mtEYi9hM/8eTw1iTHx1Z5jqpSOyGOJ4a1xJ6bQWhsEg8t3M6RrONGx/Irx13ebntNEsIMTiIiImfDZDJx18i+vHtHFxo6dnm7ksUmscXTgGumfcFbn6712Ueb8guL+OyAB4CwnG1cftlFxgYSv3Pb5a3xuN2EJDfXMg5VSEWpau6+6/tTr9TbtjsvthV/fX1RpR3r4ffXEhIRgz3nEI/eMrDSjiMSaF64cyjW7HQA0l11eX3+qio7dvaJPO6bvRlbzRRK8o7xt/4NaFQ3qcqOb5TGFyTzQN8LKMk/ji3+Aqa89w3H8wqMjuUXThXZCYm7AIBelzQxOI2IiJwLmzWEh8deyWvXp1Izb6t3Eeha9fgyP5FRzy5h8drNRkf8jb/O+MzbSCnvGI/f3NfoOOKHOqReiDtrOwBvr9lpcJrqQ0Up4Z/jriIuz1sJPhrejKfeWVrhx5izYgOepFQArrkoBps1pMKPIRKoTCYTr00eChnpmMzBrM+P58PlGyr9uKeK7Nw5cx22hAY4Ck9yV+d4WjepV+nH9RVtmzVgfIcYHEX52BIbMeGNNX63roYRVmz8D2ZLCKWnTnBxswZGxxERkfMQGx3J83cO4+lBdbEdS8fldBCa1IR5hyO49un5bPhxl9ERAVi3eTt5Mc0A6JZYSnxstMGJxF9d28n7NI8noRn/2XXQ2DDVhIpSAsBzE4YQesw7E2Orpx6vzvuiwvZdWFzC/O3FAJgz0xnas32F7Vukugg2m5kxeTDOjG2YLVY+PRLK0vXfV9rx7KUOxr2yjNCkJjjthYxpZaVzm6aVdjxf1f2SFlzXzIyzpAhrclPGvbyUUofT6Fg+bdPODADMpzK1bqCISIComxTPG/cMZ2rnSIIy0/G43QQnt+TVH8u46V/zDF1/sczl4pVV+zAHW3BmbOOOYT0NyyL+74oubSnN2InJHMwri9OMjlMt6GpRAO9MjNcnDyMo0zsT4+tTCbz/2VcVsu+HZi7FVjOF0lO5PHaDPiREzpU1xMKbE/tTkrkLS2g47211sv77HRV+nDKXi9umfYIluQUuZylXXVDKgM5tKvw4/mJQt4sZWKcYl9NBcHJLxk1b5BeLvRrlaFEQAPWizQYnERGRipZ6YT3euX84Nzd34czYhskcjCsplUdXH2fCC/PIyMmt8kxP/9xIqdTOXwa31Q0ROW8DWnjXTi2q0ZiDGccMThP4NGLlNJPJxJuTBlOWsRWzJYTPfgo/7+fFv92yh2PhjQG4JCqP2glxFRFVpNqKDLcx/ZZu2LP3ERIRw8sbTlTo1GK3283tLyyA5FTcrjK6xhxnVL9OFbZ/f3Vd/85cFpmN21WGJymV8dOqpmOpvylzuSC6DgCdmqcYnEZERCpLj3Yt+XDqUK5MOok9aw/BITZO1Uxlyvy9TH11IaeK7FWS48BP2WwprQVAimN/tVpmQCrP6AGXYc8+QHCIjefnrTM6TsBTUUp+xRpi4c07r6A0YyfBoWF8sMPFl99tO6d9ud1unvvM+6hRacZO7rm2XwWnFame4mOjee66dthzDhMaHc9jyw6w93DFtK6d9PICHAne9d9SzYe5bahmN/5s/PDetAw6CEBJrVTunb7Q2EA+6KsfdhISHkVZqZ1el7YyOo6IiFSyq3t3YO49A+gUdhR7zmFCwqPJjGzO2Le+48l3luJ0llXq8R9+fx0h4dHYjx3kH2PVSEkqhslkolOyd+b3MWtdcvNPGZwosKkoJb8RERbK9Nt6YM/aS0h4NK9uyuP7HfvPej8vfPg51uRmuJylTO7fTFNpRSpQ3aR4HhnclJKTWdjiknlgXvp5T5n/6+uLyIv1FhIusO/k/tH9KyJqQPnLDVdQp8j7yOTxmJY89OYnBifyLev+4/2sKMs9rIYWIiLVhMlk4vZhvZh9Zw+auvZSkneM0Jha7DA14tqX1/DGgtWVMrv4w+UbIDkVj9vNdW1j9bkjFWr81T2x52YSEh7Nc3OqrvN1daQqgZxRzZgonh99KfacQ4RG1+TJzw+x6+BP5X5/Rk4u3+ZHARBfuJsOqRdWVlSRaqt5gxTu7ZFM6akT2GrVY9LbG8grKDynfT31zlKOhnu71sSe3Mo/x11VkVEDyhO3DyYmdwsAh2xNeeb9ZQYn8h17j3u7EyaEOAxOIiIiVc1iCeavN17BjJvaknRqG46iAmzxdfm6qDajnv2M+au+qbBjFRaXsGCHt5GS5dhWBvdoV2H7FgHvE0QtwgsA2OOIxV6qa5vKoqKU/K6UxJr8c0hzSnIzscUm87cF2/gp+0S53vu3WauwRsZhP36Ux27RVFqRytK+VWPGXRyJo7iA0KTG3P7aFxTbS89qH6/O+4KtnnoAhB5L5/mJQyohaWCZdudQQrK9HUv/U1aXNxesMTiRbygJjQfg4oa1DE4iIiJGiY4I5+nxQ3l+WEMijqdT5rATmtSYTzJiuObpBee8NMgv/beR0gkeu7FXBaQW+a3Jo3pReiqX0JgEXvqo4rrTy6+pKCV/qGn9OtzXuw6lBSewxV/ApHc3/ekztZ98+R3OWi0BGNI0lIiw0KqIKlJt9bq0FSMaeygrtROS3IxbX1pc7jUcPlj2FV+fSsBkDiYoM51XJw3Vo7bl4O1YOhQyvB1L156MZc6KDUbHMtTOA0cJjU3C7XbRv1Oq0XFERMRgyfGxvDp5OH/rEYc5Mx23qwxLcgv+vS2IG/41jy17Dp3Tfn/ZSKl9dAHJ8bEVGVvktOiIcGq7MgD4LidYTW4qiX7zkD/VrkUjbm8f5Z2Cm9iIO15fRWFxyRm3LXU4eX/zCYJMJshI59r+l1VxWpHqaWjP9vSplY+rzIk5uRXjXlj4px+ci9duZunRcMyWEMoytvLmpMEEm81VlNj/BZvNvDHpKpwZ2zCHhPLJISvLv/7R6FiGWfHNdgBKjx8mIS7G2DAiIuIzmjdI4e37h3N7azNlGVsxmcx4klJ5an0+tz8/jyNZx8u9r183UtrB5Gv6VmJyEbhnRHecJUXY4i9g5idrjY4TkFSUknLp0a4lo5pAWUkx1uRm3Pbymbtp/P3fS7DVqoejqIBHru9qQFKR6uumK7vR3paB2+3ClZTKxBfn/+626zZv54MdLoJDwyjN2MkbEwdgDbFUYdrAYLOG8ObE/pRk7sJii2BWeglf/bDT6FiG2Ho0H4AotzrUiIjIb3Vu05TZU4cxtE4BJZm7MFusFMencv8nB7n3lQXlWhfzl42U7hnQQrO7pdLVTogjqmAfACv3nNvarfLHDB3Fr732GqmpqURFRREVFUXHjh1ZtkwLxvqqwT3acXlyIS6nA3NyS279n5kYW/ce5khIfQBahGRRv3aCUVFFqq27R/Wlicv7wVlYM5X7pi/4zTbf79jPKxtPelsoZ+1l+m09iAy3VXXUgBEZbmP6Ld2wZ+8nJKIGL32VQ/rug0bHqnJ5RADQonakwUlERMSXDe7Rjjn3DqRbVCb2YwexhEVyLLoF4979D4++tZhSh/OM78s8fvIXjZT20L5V46qMLdXY3UM64CpzEpp0IQtWf2t0nIBjaFGqTp06PPXUU2zevJnvvvuOnj17ctVVV7Ft2/kvfieVY8wVXegYkcWA5jE0b9uBl1dsp7S0lGPHjrH8oIdgq40WkYX89cYrjI4qUm09dPMgEgu2cUWLWOKbtGPOV7twOBwcO3aMY3lF/PuHYi5pWpe+9Uw8d317asZEGR3Z78XHRvPMtRdjP36EYZc1ZenOUxzOOnH6vDscDoqKioyOWWmO5xVgrVkXgH7tmxucRkREfJ3JZGLsVd35cFJvWrKfkpNZhEbXZK/lQq6fvo4N6Xtwu90UFRWd/ixduqsYa2QczaIdPH37lUb/J0g10rxBCsE5OwCYl3bU4DSBx9Ci1KBBgxgwYACNGzfmwgsv5PHHHyciIoJNmzYZGUv+xMQRfbCcymB8l2RKLdF0Hn0/l/S/lvTMElom2rj3yjaYNZVWxFD/mjCUgsz9jO+SzGG7jYsuv5aU+o0Z9/qX1KsVzYSuyfRoEkfdpHijowaMesm1+MegC9n/0zHu7Necj7/PpvYFDUhISCAhIYH58+fj8XiMjlkplm/wLvhekpdNi0Z1jY4jIiJ+Iths5v7R/XnrlkupU7QDR+FJbDXr8NWxUErKPMxe/AUJCQm06NSXtXsLaJkUxn1XtNCSA1Llbu3TCo/bjSW5Bes2bzc6TkDxmcqBy+Vizpw5FBUV0bFjR6PjyJ+4vN2FvLtkLeO7JDN83L10GvcULZPCuK1jTT54//2AnhEg4i+u6daCt5enMb5rbcZMfYa+D75Pp0tSuaNzInPnLSAm3Gp0xIDTolFdrmoVx2tfHmRcrybc8uQ7mENCadeuHQMHDuS9994LyJ+PaXuyAAgpPmZwEhER8UcRYaE8cftgXhzRlOgTW9iZWcgr6zK4ZshAbn36fTqO/Setakdwe8eazP5Av2tI1evcpillWd7ZUjNX6cmuihTkMfi27ZYtW+jYsSMlJSVEREQwe/ZsBgwYcMZtS0tLKS0tPf3ngoICUlJSyM/PJypKj59UJYfDQUJCAqOmPMEz949j3d58ujSIZMTVQ9i04Wuys7MJCQkxOqZIteZwOEhITOLmR97kkXGDWbc3n64NoxgzdhxrPluocVpJHA4Hjdtcxm1Pv89dfRqxdONW+qSmMGrUKNLS0gLyvI98+hOsyU2pV7KTR2+9yug4IiLi53Lyixl67/NccfX1TOyecvoaZtTIEXy9bk1AfpaK71u0Jo0FR6NwlTn5S+dIWjW+wOhIPq2goIDo6Og/rdcYPlOqSZMm/Pjjj3zzzTfccccd3HDDDWzffubpcE8++STR0dGnXykpKVWcVn6Wl5dHXl4er/99PAtWrGdAi1je+3Auyz9bSl5eHvn5+UZHFKn28vLyyDuZy7TJ17B43Q8MaBHLrPc+YOHstzVOK1FeXh6Ht3/HtCnX8OWuE4zs3poVm/fzxRerAvK8lzqcmGK9n8fdUhsYnEZERAKBp7SQr/79EE+M6cbi9d5rmA/mLWLppwsD8rNU/MPgHu28nSODLbz8qRY8ryiGF6VCQkJo1KgRF198MU8++SStW7fmxRdfPOO2DzzwAPn5+adfR44cqeK08rOYmBhiYmLo06cPAzun8swzzzBq8AD69OlDTEwM0dHRRkcUqfZ+Hqe9enan38UNeOaZZ7h22CCN00r283m/qF5NLrsglCVbchjUtQ0Tn54VkOd9Tdo2LKHhOItP0bVtM6PjiIhIAPj5s7RD6yb0a+u9hhl+RU9dw4jh+jXxzvgpjGrEkazjBqcJDMFGB/hfbrf7V4/o/ZLVasVq1RoovsDpdPLiiy8ycOBARo0axcqVK1m5ciVz5sxhyZIlOJ1OTakVMZjGqTF+ed5HDr+a3flm7njsDZ6461qaNKoXcOf9q60HIawZnryjWCyXGB1HREQCgK5hxFfdNKgry19Yia1WPZ6ft5YX7hxmdCS/Z+hMqQceeIB169Zx8OBBtmzZwgMPPMCXX37JddddZ2QsKYfw8HBGjx7NkiVLSEtLAyAtLY0lS5YwevRowsPDDU4oIhqnxvjf837o2+XMfuHvvLo+gxsGdGLB14HVseVAXhkAyWEug5OIiEig0DWM+CqTyUT7BDcAGeba5BUUGpzI/xm60PnYsWNZtWoVmZmZREdHk5qaytSpU+nTp0+53l/ehbOk8hQVFWGxWMjPzyc6Ohqn06kPCREfo3FqjP897++v38txTyQXxIay+8dNPHTzIKMjnje3282oVzcSGl2TAbVOMKpfJ6MjiYhIANE1jPiiUoeT0a9vILRGIhfYd/LPcWryciblrdcY3n3vfKgoJSIi/mT88/MojE/F7XbRPvQod43sa3Sk8/LDzgO8kObAXebklWH1iImKMDqSiIiISKV76M1POGRrSsnJLN67vRPWEIvRkXyO33TfExERqS5emTQMc2Y6JpOZb4qTmbV4ndGRzsvKtJ0AlB4/pIKUiIiIVBv3jOqFo/AkoTUSeWXeKqPj+DUVpURERKqIyWTizclDcGVswRxs4fPsKBauTjM61jnbmeVdRyHWVGxwEhEREZGqExMVQaLzKACbsoJwu90GJ/JfKkqJiIhUIYslmBl3DcKRsYNgq425e2DVN1uMjnVOTpm9LblT69YwOImIiIhI1ZoyvBtlpXZsterxzpL1RsfxWypKiYiIVLEwm5XX7+hNSeYeQsKieHPzKb7dssfoWGflp+wT2OIvAODyDi0NTiMiIiJSteomxROR571+W7Yz3+A0/ktFKREREQPEREUw7aZO2I8dxBoZx7NrMti+/4jRscpt2Ubv7C77iZ9omJJocBoRERGRqnfnVe1xlzkJTWrC4rWbjY7jl1SUEhERMUhyfCxPDk/FfiKD0BqJPLxoJ4czc4yOVS4/HPDmDHOcMDiJiIiIiDFaNb4A07EdAHy46aCxYfyUilIiIiIGalQ3ib9eXo+S/Bxs8XW554M0cnJ9fwp4jjMUgMbxNoOTiIiIiBjn5l7NATAnNmfDj7sMTuN/VJQSERExWJum9bmzUxyOwjxsCQ2ZMONLThXZjY71uwqLS7DE1QWgZ5vGBqcRERERMU73S1rgyNhOkMnEm5+nGx3H76goJSIi4gO6tG3G6JYWnCVFhCY3Zdwryyh1OI2OdUYrN23BHBKKo/AkHVJVlBIREZHqbfglyQA4azZl54GjBqfxLypKiYiI+IgrurTlypQSXM5SLMktuPWFRZS5XEbH+o1NO70LsgcVZGAy6VJCREREqrdhvS6lJHMPZksILy7caHQcv6IrSRERER9yzeWd6BKdg9tVBsmp3PHCAtxut9GxfuXwKe8/60Yam0NERETEV/RqFAZAXkQDMnJyDU7jP1SUEhER8TG3D+tFK/MhAEoTUpnyygKDE/2X2+3GE+Wdot6haYrBaURERER8w9irumHPOYzFFsHzc780Oo7fUFFKRETEB00dPYC6xd4Ww7k1WvG3NxYZG+j/bUrfQ0hEDVyOEvp0aGV0HBERERGfEGw2c3FN73qgR0yJPt20xpeoKCUiIuKjHrttMLEntwBwOKwZT7/3mcGJYPUPewBwnjhMRFiowWlEREREfMfdI3tTkncMa2Qcz89ZaXQcv6CilIiIiA97fuJQrNne9sJbXBfw+vxVhubZk+O96xdvKTE0h4iIiIivsVlDaGQ5AcDWU5E4nWUGJ/J9KkqJiIj4MJPJxGuTh0JGOiZzMOvz4/lw+QbD8hSHxAHQpn68YRlEREREfNWUUT1xFBVgi0vm1fmrjY7j81SUEhER8XHBZjMzJg/GmbENs8XKp0dCWbr++yrPsfdwJra42gD076j1pERERET+V82YKOJLvA1rvjrq8rkuyr5GRSkRERE/YA2x8ObE/pRk7MQSGs57W52s/35HlWZY8c02AOw5h6idEFelxxYRERHxF1OGd6HMYceW0ID3l31tdByfpqKUiIiIn4gMtzH91u7Ys/cREhHDyxtO8MPOA1V2/PTDJ705XPlVdkwRERERf1O/dgJhJ73NYZZuzTU4jW9TUUpERMSPxMdG89x17bDnHCY0Op4nlh9k7+HMKjl2rjsMgKaJEVVyPBERERF/NWHgJbhdZViTm/LZVz8YHcdnqSglIiLiZ+omxfPI4KaUnMzCFpfMA/PSycip3LtweQWFWGteAECfdk0r9VgiIiIi/q5N0/qQ7V1q4YOv9xmcxnepKCUiIuKHmjdI4d4eyZSeOoGtVj3unrWB3PxTlXa8ZRvSMQVbKMk/TusLL6i044iIiIgEihu6XQhAUGJzvt2yx+A0vklFKRERET/VvlVjxl0ciaO4AFtiY8a/vopie2mlHCttj/cRQUtRJiaTLh9ERERE/kyfDqk4MrZjMpl5ffmPRsfxSbqqFBER8WO9Lm3FiMYeykrthCQ349aXFuN0llX4cTKKzQDUjwmu8H2LiIiIBKrBFyUAUBrXhD2HMgxO43tUlBIREfFzQ3u2p0+tfFxlTszJrRj3wkLcbneF7d/pLCMopg4AnVvWq7D9ioiIiAS6EX06YM/ai9liZdqCr42O43NUlBIREQkAN13ZjUvDMnC7XbiSUpk4bX6F7Xvd9zuwhEXiLCmiR7sWFbZfERERkUBnMpnoXs8KQG5YfbJP5BkbyMeoKCUiIhIg7hrZlyYub3eXwvhU7p2+oEL2uzZ9PwDu3CNYQywVsk8RERGR6uK2oT2wHz+KJSyS5+euNjqOT1FRSkREJIA8dPMgkk5tA+BYVAsenbn4vPe5P9cJQGKo87z3JSIiIlLdBJvNXBRjB+CgJ4HC4hKDE/kOFaVEREQCzNPjhxJ5PB2APcGNeGH2ivPanyOsFgDtGieedzYRERGR6ujukb0pyT+ONaom0+Z+YXQcn6GilIiISAB6+e5hBGelE2Qy8V1pbd76dO057WfLnkOExiTgdpVxeafUCk4pIiIiUj1EhIVS35QNwH/ybJS5XAYn8g0qSomIiAQgk8nEG5OG4M7YgjnYwhc50cxf9c1Z72dl2g4ASo8fpmZMVEXHFBEREak2pozsibP4FLaadXhjwRqj4/gEFaVEREQClMUSzJt3DcKRsZ3gEBsf7zWzclP6We1j20+nAIihsDIiioiIiFQbCXExxBYfAODLgw7cbrfBiYynopSIiEgAC7NZef2OPpRk7sYSFsm/vy9iU/rucr+/wBQJQMs60ZUVUURERKTamDysMy5nKbbEhsz9fJPRcQynopSIiEiAi4mKYNpNl2E/dgBrZCzPf5nJtr2H//R92SfysNasC0C/S5tXdkwRERGRgNeobhLWE7sA+OQ/xwxOYzwVpURERKqB5PhYnhpxEfYTRwmtkcg/Fu/mYMYfXwgt25COyWSmJDeTpvXrVFFSERERkcB2x4A2uN0uQpKbnfXSCoFGRSkREZFqomFKIn/r35CSvGPYaqZw3+zNZJ/I+93tN+/zFq1CS3KqKKGIiIhI4GvXohGerO0AvLO2/MsqBCIVpURERKqR1k3qcVfneByFJ7ElNODOmevILyw647bZjhAAGta0VmVEERERkYA3unMj778kNuf7HfuNDWMgFaVERESqmc5tmjKmlRWnvZDQpCbcPn0F9lLHr7axlzoIjvWuJ9WtdUMjYoqIiIgErMsvu4jSjB2YTGamL9lsdBzDqCglIiJSDQ3o3IarLijF5SjBktyC26Z9QpnLdfrvV32zhWCrDUdRAZ3bNDUwqYiIiEhgGtSqJgD22MYc+Cnb4DTGUFFKRESkmhrVrxPdauTidpVBciq3v7AAt9sNQNqeLACCi7IINpuNjCkiIiISkK69vBP27P0Eh9h4ft56o+MYwtCi1JNPPkm7du2IjIykVq1aDB48mF27dhkZSUREpFoZN7QHrYMPA9CnZ3feXv4dRUVFxNRvBcCwnu0oKjrzmlMiIiIicu5MJhN3925Iy6Qw7DWbU1BUwrFjx3A4HNXm+svQotTatWuZMGECmzZtYuXKlTidTvr27VttTr6IiIgvuO/6/lxg38mh3BJG9rqYd5ZvYuOOowDce8so5s+fj8fjMTiliIiISODp0LIhE7smc2FiJD2un0xCQgIJCQnV5vrL0KLU8uXLufHGG2nRogWtW7dm1qxZHD58mM2bq+8iXyIiIkb457iriOEUr67PYMzA7lzSJAWX00HjhHAGDhzIe++9p5tGIiIiIhWstLSEdz9ZzfguyVw1+nZMZgvt2rWrNtdfwUYH+KX8/HwAYmNjz/j3paWllJaWnv5zQUFBleQSERGpDm7o0pCedzwJjGV8l2SWpxXS8/33GDVqFGlpaYwaNcroiCIiIiIBxWKx8OD468mxrGLKFS1Jeu8jhvXrWm2uv3xmoXO3282kSZO47LLLaNmy5Rm3efLJJ4mOjj79SklJqeKUIiIigSs/P58Nbz/Cojnvsm5vPld3bsbMmTNZuXIleXl5p28eiYiIiEjFyMvLI/f4MebOfIl1e/O59ZrB1er6y2eKUhMmTGDr1q3MmTPnd7d54IEHyM/PP/06cuRIFSYUEREJbDExMcTExBBxeC0dk008++xzjB07lj59+hATE0N0dLTREUVEREQCys/XX3XJplOKhWefq17XXz7x+N7EiRNZsmQJ69ato06dOr+7ndVqxWq1VmEyERGR6sPpdPLiiy8ycOBARo4cwcqVK/n88xXMmTOHJUuW4HQ6CQkJMTqmiIiISMD45fXXiKuHea+/VlSf6y9DZ0p5PB4mTpzIwoULWb16NfXr1zcyjoiISLUWHh7O6NGjWbJkCWlpaQCkpaWxZMkSRo8eTXh4uMEJRURERAJLdb/+CvIY2GNw/PjxzJ49m08++YQmTZqc/np0dDQ2m+1P319QUEB0dDT5+flERUVVZlQREZFqo6ioCIvFQn5+PtHR0TidzoC/IBIRERExUqBdf5W3XmNoUSooKOiMX3/77be58cYb//T9KkqJiIiIiIiIiPiW8tZrDF1TysB6mIiIiIiIiIiIGMhnuu+JiIiIiIiIiEj1oaKUiIiIiIiIiIhUORWlRERERERERESkyqkoJSIiIiIiIiIiVU5FKRERERERERERqXIqSomIiIiIiIiISJVTUUpERERERERERKpcsNEBzofH4wGgoKDA4CQiIiIiIiIiIgL/rdP8XLf5PX5dlDp16hQAKSkpBicREREREREREZFfOnXqFNHR0b/790GePytb+TC3201GRgaRkZEEBQUZHUekShUUFJCSksKRI0eIiooyOo6I39DYETk3Gjsif0xjROTcaOwEJo/Hw6lTp0hOTsZk+v2Vo/x6ppTJZKJOnTpGxxAxVFRUlH54i5wDjR2Rc6OxI/LHNEZEzo3GTuD5oxlSP9NC5yIiIiIiIiIiUuVUlBIRERERERERkSqnopSIn7JarTz88MNYrVajo4j4FY0dkXOjsSPyxzRGRM6Nxk715tcLnYuIiIiIiIiIiH/STCkREREREREREalyKkqJiIiIiIiIiEiVU1FKRERERERERESqnIpSIiIiIiIiIiJS5VSUEqlATz75JO3atSMyMpJatWoxePBgdu3a9attSkpKmDBhAnFxcURERDBs2DCys7N/tc1dd93FxRdfjNVq5aKLLvrNcXbt2kWPHj1ISEggNDSUBg0a8Le//Q2n0/mnGadPn069evUIDQ3l0ksv5dtvvz39dwcPHiQoKOiMr3nz5p3bSREpB38fOwBZWVmMHj2axMREwsPDadu2LfPnzz/7kyFyFgJh7Ozbt48hQ4YQHx9PVFQUI0aM+E0+kXPl62Nk3bp1DBo0iOTkZIKCgli0aNFvtvF4PPz9738nKSkJm81G79692bNnz1mfC5GzEQhjZ8GCBfTt25e4uDiCgoL48ccfz/Y0SBVQUUqkAq1du5YJEyawadMmVq5cidPppG/fvhQVFZ3eZvLkySxevJh58+axdu1aMjIyGDp06G/2dfPNNzNy5MgzHsdisTBmzBg+//xzdu3axbRp05gxYwYPP/zwH+abO3cuU6ZM4eGHH+b777+ndevW9OvXj2PHjgGQkpJCZmbmr16PPPIIERER9O/f/zzOjMgf8/exAzBmzBh27drFp59+ypYtWxg6dCgjRozghx9+OMezIvLn/H3sFBUV0bdvX4KCgli9ejVff/01DoeDQYMG4Xa7z+PMiHj5+hgpKiqidevWTJ8+/Xe3+de//sVLL73E66+/zjfffEN4eDj9+vWjpKSknGdB5OwFwtgpKiqic+fOPP300+X8rxZDeESk0hw7dswDeNauXevxeDyevLw8j8Vi8cybN+/0Njt27PAAno0bN/7m/Q8//LCndevW5TrW5MmTPZ07d/7Dbdq3b++ZMGHC6T+7XC5PcnKy58knn/zd91x00UWem2++uVwZRCqKP46d8PBwz7vvvvur98XGxnpmzJhRrhwiFcHfxs6KFSs8JpPJk5+ff3qbvLw8T1BQkGflypXlyiFyNnxtjPwS4Fm4cOGvvuZ2uz2JiYmeZ5555vTX8vLyPFar1fPhhx+We98i58vfxs4vHThwwAN4fvjhh3LvU6qOZkqJVKL8/HwAYmNjAdi8eTNOp5PevXuf3qZp06bUrVuXjRs3nvNx9u7dy/Lly+nWrdvvbuNwONi8efOvjm0ymejdu/fvHnvz5s38+OOPjB079pyziZwLfxw7nTp1Yu7cueTm5uJ2u5kzZw4lJSV07979nPOJnC1/GzulpaUEBQVhtVpPbxMaGorJZOKrr74653wiv8eXxkh5HDhwgKysrF/li46O5tJLLz2vfCJny9/GjvgPFaVEKonb7WbSpElcdtlltGzZEvCuORMSEkJMTMyvtk1ISCArK+usj9GpUydCQ0Np3LgxXbp04dFHH/3dbY8fP47L5SIhIaHcx545cybNmjWjU6dOZ51N5Fz569j56KOPcDqdxMXFYbVaue2221i4cCGNGjU663wi58Ifx06HDh0IDw9n6tSpFBcXU1RUxL333ovL5SIzM/Os84n8EV8bI+Xxc4azuX4TqWj+OHbEf6goJVJJJkyYwNatW5kzZ06lHWPu3Ll8//33zJ49m6VLl/Lss88CsH79eiIiIk6/Pvjgg7Pet91uZ/bs2ZolJVXOX8fOQw89RF5eHl988QXfffcdU6ZMYcSIEWzZsqWy/jNEfsUfx058fDzz5s1j8eLFREREEB0dTV5eHm3btsVk0mWqVCx/HCMivkBjRypTsNEBRALRxIkTWbJkCevWraNOnTqnv56YmIjD4SAvL+9XdxWys7NJTEw86+OkpKQA0Lx5c1wuF+PGjeOee+7hkksu+VV3iYSEBKxWK2az+TcdMX7v2B9//DHFxcWMGTPmrHOJnCt/HTv79u3jlVdeYevWrbRo0QKA1q1bs379eqZPn87rr79+1hlFzoa/jh2Avn37sm/fPo4fP05wcDAxMTEkJibSoEGDs84n8nt8cYyUx88ZsrOzSUpK+lW+M3UyE6lo/jp2xH/oFpRIBfJ4PEycOJGFCxeyevVq6tev/6u/v/jii7FYLKxater013bt2sXhw4fp2LHjeR3b7XbjdDpxu93YbDYaNWp0+hUZGUlISAgXX3zxr47tdrtZtWrVGY89c+ZMrrzySuLj488rl0h5+PvYKS4uBvjNzA6z2awOYlKp/H3s/FLNmjWJiYlh9erVHDt2jCuvvPK88omAb4+R8qhfvz6JiYm/yldQUMA333xz3vlE/oi/jx3xH5opJVKBJkyYwOzZs/nkk0+IjIw8/Tx1dHQ0NpuN6Ohoxo4dy5QpU4iNjSUqKoo777yTjh070qFDh9P72bt3L4WFhWRlZWG320/fHWjevDkhISF88MEHWCwWWrVqhdVq5bvvvuOBBx5g5MiRWCyW3803ZcoUbrjhBi655BLat2/PtGnTKCoq4qabbvrVdnv37mXdunV89tlnFX+SRM7A38dO06ZNadSoEbfddhvPPvsscXFxLFq0iJUrV7JkyZLKO3FS7fn72AF4++23adasGfHx8WzcuJG7776byZMn06RJk8o5aVKt+PoYKSwsZO/evaf/fODAAX788UdiY2OpW7cuQUFBTJo0iccee4zGjRtTv359HnroIZKTkxk8eHClnDMR8P+xA5Cbm8vhw4fJyMgAvEUz8M7yOpfZXFJJDO39JxJggDO+3n777dPb2O12z/jx4z01atTwhIWFeYYMGeLJzMz81X66det2xv0cOHDA4/F4PHPmzPG0bdvWExER4QkPD/c0b97c88QTT3jsdvufZnz55Zc9devW9YSEhHjat2/v2bRp02+2eeCBBzwpKSkel8t1XudDpLwCYezs3r3bM3ToUE+tWrU8YWFhntTUVM+777573udG5I8EwtiZOnWqJyEhwWOxWDyNGzf2PPfccx63233e50bE4/H9MbJmzZoz7veGG244vY3b7fY89NBDnoSEBI/VavX06tXLs2vXroo6RSJnFAhj5+233z7jNg8//HAFnSWpCEEej8dzPkUtERERERERERGRs6U1pUREREREREREpMqpKCUiIiIiIiIiIlVORSkREREREREREalyKkqJiIiIiIiIiEiVU1FKRERERERERESqnIpSIiIiIiIiIiJS5VSUEhERERERERGRKqeilIiIiIiIiIiIVDkVpUREREREREREpMqpKCUiIiIiIiIiIlVORSkREREREREREalyKkqJiIiIiIiIiEiV+z8C+gVXrfEJtAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", - "#pattern = r'\\b(WMF|Foundation)\\b'\n", - "#pattern = r'\\b(bots)\\b'\n", - "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", - "\n", - "plt.figure(figsize=(12, 8))\n", - "gs = GridSpec(2, 1, height_ratios=[6, 6])\n", - "\n", - "# Main plot: Token depth by timestamp\n", - "'''\n", - "ax0 = plt.subplot(gs[0])\n", - "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n", - "ax0.set_title('VE Depth by Timestamp w/o URLS')\n", - "ax0.set_xlabel('')\n", - "ax0.set_ylabel('Dependency Type')\n", - "ax0.legend().set_visible(False)\n", - "'''\n", - "# Calculate the median depth over time\n", - "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n", - "wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n", - "other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "# Plot the median depth over time\n", - "ax0 = plt.subplot(gs[0])\n", - "sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax0.set_title('Median Depth of Relevant Term in Phabricator Sentence Dependency Trees')\n", - "ax0.set_ylabel('Median Depth')\n", - "ax0.set_xlabel('')\n", - "\n", - "# Calculate the median depth over time\n", - "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", - "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n", - "resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n", - "resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", - "\n", - "# Plot the median depth over time\n", - "ax1 = plt.subplot(gs[1])\n", - "sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", - "sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", - "sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", - "ax1.set_title('Median Depth of Relevant Term in Coreference-resolved Phabricator Sentence Dependency Trees')\n", - "ax1.set_ylabel('Median Depth')\n", - "ax1.set_xlabel('')\n", - "\n", - "plt.tight_layout()\n", - "#plt.show()\n", - "\n", - "#plt.savefig('031625_VE_depth_fig.png')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.7.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/text_analysis/case3/050825_join_resolved_files.ipynb b/text_analysis/case3/050825_join_resolved_files.ipynb new file mode 100644 index 0000000..2733270 --- /dev/null +++ b/text_analysis/case3/050825_join_resolved_files.ipynb @@ -0,0 +1,1176 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fcc726a8-44a4-48cf-a1cd-937b05bd4d08", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1fceca29-48c1-4ba3-93ba-88724dea22a7", + "metadata": {}, + "outputs": [], + "source": [ + "first_resolved_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0050825_coref-rel-first.csv\"\n", + "first_resolved_df = pd.read_csv(first_resolved_path)\n", + "second_resolved_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref_rel_phab_stragglers.csv\"\n", + "second_resolved_df = pd.read_csv(second_resolved_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f26c31e7-bee1-4100-821f-769e5b1791bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_titlecomment_textdate_createdspeakermeta.affilconversation_idcomment_typestatusmeta.gerritidreply_totimestampis_relevantis_migratedtextresolved_text
0Special:PasswordReset locks out of account: \"I...[Backport was merged into 1.24wmf16 upon a tim...1412717629PHID-USER-hgn5uw2jafgjgfvxibhhFalsePHID-TASK-7ho223nxpxvlbbyd3ckztask_subcommentNaNFalse243500243499.02014-10-07 21:33:49+00:00TrueFalse[Backport was merged into 1.24wmf16 upon a tim...[Backport was merged into 1.24wmf16 upon a tim...
1login bustedI guess this can be closed now as RESOLVED WOR...1413464793PHID-USER-hgn5uw2jafgjgfvxibhhFalsePHID-TASK-jekgcahti7tcon56pca2task_subcommentNaNFalse250657250656.02014-10-16 13:06:33+00:00TrueFalseI guess this can be closed now as RESOLVED WOR...I guess this can be closed now as RESOLVED WOR...
2SSLError on requesting data from WikidataThe upstream issue is https://github.com/jcgre...1417113110PHID-USER-muirnivxp5hzppn2a3z7FalsePHID-TASK-w4js4xepsmk6fz75gkwetask_subcommentNaNFalse250686250685.02014-11-27 18:31:50+00:00TrueFalseThe upstream issue is https://github.com/jcgre...The upstream issue is https://github.com/jcgre...
3SSLError on requesting data from WikidataAn update on this. In Amsterdam we found at th...1417110306PHID-USER-uu7wg6g3b37dcktbje3aFalsePHID-TASK-w4js4xepsmk6fz75gkwetask_subcommentNaNFalse250687250686.02014-11-27 17:45:06+00:00TrueFalseAn update on this. In Amsterdam we found at th...An update on this. In Amsterdam we found at th...
4SSLError on requesting data from WikidataYes. It's used by people using pywikibot-as-a-...1412595221PHID-USER-muirnivxp5hzppn2a3z7FalsePHID-TASK-w4js4xepsmk6fz75gkwetask_subcommentNaNFalse250688250687.02014-10-06 11:33:41+00:00TrueFalseYes. It's used by people using pywikibot-as-a-...Yes. It's used by people using pywikibot-as-a-...
...................................................
857text input history/autocomplete doesn't work w...I amended the title to the range IE8-10 becaus...1434207367PHID-USER-lhtlnmkdbzlz6pbxaqddFalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406640406639.02015-06-13 14:56:07+00:00TrueFalseI amended the title to the range IE8-10 becaus...I amended the title to the range IE8-10 becaus...
858text input history/autocomplete doesn't work w...If I remember correctly this problem was at le...1434140114PHID-USER-wrimmmr5w2zt7nk2t753FalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406641406640.02015-06-12 20:15:14+00:00TrueFalseIf I remember correctly this problem was at le...If I remember correctly this problem was at le...
859text input history/autocomplete doesn't work w...If I remember correctly this problem was at le...1434116915PHID-USER-wrimmmr5w2zt7nk2t753FalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406642406641.02015-06-12 13:48:35+00:00TrueFalseIf I remember correctly this problem was at le...If I remember correctly this problem was at le...
860text input history/autocomplete doesn't work w...After a quick test, autocomplete seems to work...1434114623PHID-USER-sx63fwaih5kjt7bz4u6zFalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406643406642.02015-06-12 13:10:23+00:00TrueFalseAfter a quick test, autocomplete seems to work...After a quick test, autocomplete seems to work...
861Allow login using mosh as an alternative to pl...Still not merged, so we can't really do much.1413537437PHID-USER-2nnm76h4ykalvvref2yeFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406877406876.02014-10-17 09:17:17+00:00TrueFalseStill not merged, so we can't really do much.Still not merged, so we can't really do much.
\n", + "

862 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " task_title \\\n", + "0 Special:PasswordReset locks out of account: \"I... \n", + "1 login busted \n", + "2 SSLError on requesting data from Wikidata \n", + "3 SSLError on requesting data from Wikidata \n", + "4 SSLError on requesting data from Wikidata \n", + ".. ... \n", + "857 text input history/autocomplete doesn't work w... \n", + "858 text input history/autocomplete doesn't work w... \n", + "859 text input history/autocomplete doesn't work w... \n", + "860 text input history/autocomplete doesn't work w... \n", + "861 Allow login using mosh as an alternative to pl... \n", + "\n", + " comment_text date_created \\\n", + "0 [Backport was merged into 1.24wmf16 upon a tim... 1412717629 \n", + "1 I guess this can be closed now as RESOLVED WOR... 1413464793 \n", + "2 The upstream issue is https://github.com/jcgre... 1417113110 \n", + "3 An update on this. In Amsterdam we found at th... 1417110306 \n", + "4 Yes. It's used by people using pywikibot-as-a-... 1412595221 \n", + ".. ... ... \n", + "857 I amended the title to the range IE8-10 becaus... 1434207367 \n", + "858 If I remember correctly this problem was at le... 1434140114 \n", + "859 If I remember correctly this problem was at le... 1434116915 \n", + "860 After a quick test, autocomplete seems to work... 1434114623 \n", + "861 Still not merged, so we can't really do much. 1413537437 \n", + "\n", + " speaker meta.affil \\\n", + "0 PHID-USER-hgn5uw2jafgjgfvxibhh False \n", + "1 PHID-USER-hgn5uw2jafgjgfvxibhh False \n", + "2 PHID-USER-muirnivxp5hzppn2a3z7 False \n", + "3 PHID-USER-uu7wg6g3b37dcktbje3a False \n", + "4 PHID-USER-muirnivxp5hzppn2a3z7 False \n", + ".. ... ... \n", + "857 PHID-USER-lhtlnmkdbzlz6pbxaqdd False \n", + "858 PHID-USER-wrimmmr5w2zt7nk2t753 False \n", + "859 PHID-USER-wrimmmr5w2zt7nk2t753 False \n", + "860 PHID-USER-sx63fwaih5kjt7bz4u6z False \n", + "861 PHID-USER-2nnm76h4ykalvvref2ye False \n", + "\n", + " conversation_id comment_type status meta.gerrit \\\n", + "0 PHID-TASK-7ho223nxpxvlbbyd3ckz task_subcomment NaN False \n", + "1 PHID-TASK-jekgcahti7tcon56pca2 task_subcomment NaN False \n", + "2 PHID-TASK-w4js4xepsmk6fz75gkwe task_subcomment NaN False \n", + "3 PHID-TASK-w4js4xepsmk6fz75gkwe task_subcomment NaN False \n", + "4 PHID-TASK-w4js4xepsmk6fz75gkwe task_subcomment NaN False \n", + ".. ... ... ... ... \n", + "857 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "858 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "859 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "860 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "861 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN False \n", + "\n", + " id reply_to timestamp is_relevant is_migrated \\\n", + "0 243500 243499.0 2014-10-07 21:33:49+00:00 True False \n", + "1 250657 250656.0 2014-10-16 13:06:33+00:00 True False \n", + "2 250686 250685.0 2014-11-27 18:31:50+00:00 True False \n", + "3 250687 250686.0 2014-11-27 17:45:06+00:00 True False \n", + "4 250688 250687.0 2014-10-06 11:33:41+00:00 True False \n", + ".. ... ... ... ... ... \n", + "857 406640 406639.0 2015-06-13 14:56:07+00:00 True False \n", + "858 406641 406640.0 2015-06-12 20:15:14+00:00 True False \n", + "859 406642 406641.0 2015-06-12 13:48:35+00:00 True False \n", + "860 406643 406642.0 2015-06-12 13:10:23+00:00 True False \n", + "861 406877 406876.0 2014-10-17 09:17:17+00:00 True False \n", + "\n", + " text \\\n", + "0 [Backport was merged into 1.24wmf16 upon a tim... \n", + "1 I guess this can be closed now as RESOLVED WOR... \n", + "2 The upstream issue is https://github.com/jcgre... \n", + "3 An update on this. In Amsterdam we found at th... \n", + "4 Yes. It's used by people using pywikibot-as-a-... \n", + ".. ... \n", + "857 I amended the title to the range IE8-10 becaus... \n", + "858 If I remember correctly this problem was at le... \n", + "859 If I remember correctly this problem was at le... \n", + "860 After a quick test, autocomplete seems to work... \n", + "861 Still not merged, so we can't really do much. \n", + "\n", + " resolved_text \n", + "0 [Backport was merged into 1.24wmf16 upon a tim... \n", + "1 I guess this can be closed now as RESOLVED WOR... \n", + "2 The upstream issue is https://github.com/jcgre... \n", + "3 An update on this. In Amsterdam we found at th... \n", + "4 Yes. It's used by people using pywikibot-as-a-... \n", + ".. ... \n", + "857 I amended the title to the range IE8-10 becaus... \n", + "858 If I remember correctly this problem was at le... \n", + "859 If I remember correctly this problem was at le... \n", + "860 After a quick test, autocomplete seems to work... \n", + "861 Still not merged, so we can't really do much. \n", + "\n", + "[862 rows x 16 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(second_resolved_df)\n", + "second_resolved_df = second_resolved_df.drop(columns=['_merge'])\n", + "second_resolved_df" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dfa81ca2-4d66-4679-bc3e-192d0cac67fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_titlecomment_textdate_createdspeakermeta.affilconversation_idcomment_typestatusmeta.gerritidreply_totimestampis_relevantis_migratedtextresolved_text
0User with unattached accounts unable to login ...User:NickK reported in IRC that they're gettin...1411541280PHID-USER-v7vgzvvcw7v2umf737riFalsePHID-TASK-mio2uq45ny7mms72syuttask_descriptionresolvedFalse243215NaN2014-09-24 06:48:00+00:00TrueFalseUser:NickK reported in IRC that they're gettin...User:NickK reported in IRC that they're gettin...
1User with unattached accounts unable to login ...Revert has been deployed.1411573104PHID-USER-v7vgzvvcw7v2umf737riFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243216243215.02014-09-24 15:38:24+00:00TrueFalseRevert has been deployed.Revert has been deployed.
2User with unattached accounts unable to login ...**gerritadmin** wrote:\\n\\nChange 162550 merged...1411572378PHID-USER-ynivjflmc2dcl6w5ut5vFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243217243216.02014-09-24 15:26:18+00:00TrueFalse**gerritadmin** wrote:\\n\\nChange 162550 merged...**gerritadmin** wrote:\\n\\nChange 162550 merged...
3User with unattached accounts unable to login ...(In reply to Kunal Mehta (Legoktm) from commen...1411545535PHID-USER-v7bwpq3rs3zdxegibdbhFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243218243217.02014-09-24 07:58:55+00:00TrueFalse(In reply to Kunal Mehta (Legoktm) from commen...(In reply to Kunal Mehta (Legoktm) from commen...
4User with unattached accounts unable to login ...**gerritadmin** wrote:\\n\\nChange 162549 merged...1411542640PHID-USER-ynivjflmc2dcl6w5ut5vFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243219243218.02014-09-24 07:10:40+00:00TrueFalse**gerritadmin** wrote:\\n\\nChange 162549 merged...**gerritadmin** wrote:\\n\\nChange 162549 merged...
...................................................
13623OAuth login refers to mediawiki.org:/ instead ...> When I registered, phabricator linked mediaw...1413205650PHID-USER-hgn5uw2jafgjgfvxibhhFalsePHID-TASK-yeaxsfxhhtbn26koo5fitask_subcommentNaNFalse378799378798.02014-10-13 13:07:30+00:00TrueFalse> When I registered, phabricator linked mediaw...> When I registered, phabricator linked mediaw...
13624OAuth login refers to mediawiki.org:/ instead ...See {T574} for a related discussion.1412958953PHID-USER-lluzkul4z7us4sxkayssFalsePHID-TASK-yeaxsfxhhtbn26koo5fitask_subcommentNaNFalse378800378799.02014-10-10 16:35:53+00:00TrueFalseSee {T574} for a related discussion.See {T574} for a related discussion.
13625Improvements to Wikimedia SUL login dialog UI:...Some improvements to the Wikimedia SUL dialog:...1412362816PHID-USER-lluzkul4z7us4sxkayssFalsePHID-TASK-j6czqxlv5fzcx3tmq23ntask_descriptiondeclinedFalse378858NaN2014-10-03 19:00:16+00:00TrueFalseSome improvements to the Wikimedia SUL dialog:...Some improvements to the Wikimedia SUL dialog:...
13626Improvements to Wikimedia SUL login dialog UI:...I guess the same restrictions as in T543 apply...1412415111PHID-USER-lluzkul4z7us4sxkayssFalsePHID-TASK-j6czqxlv5fzcx3tmq23ntask_subcommentNaNFalse378860378859.02014-10-04 09:31:51+00:00TrueFalseI guess the same restrictions as in T543 apply...I guess the same restrictions as in T543 apply...
13627Improvements to Wikimedia SUL login dialog UI:...It's not entirely trivial to change1412366627PHID-USER-fn7qnpccfbitivgtw2rtFalsePHID-TASK-j6czqxlv5fzcx3tmq23ntask_subcommentNaNFalse378861378860.02014-10-03 20:03:47+00:00TrueFalseIt's not entirely trivial to changeIt's not entirely trivial to change
\n", + "

13628 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " task_title \\\n", + "0 User with unattached accounts unable to login ... \n", + "1 User with unattached accounts unable to login ... \n", + "2 User with unattached accounts unable to login ... \n", + "3 User with unattached accounts unable to login ... \n", + "4 User with unattached accounts unable to login ... \n", + "... ... \n", + "13623 OAuth login refers to mediawiki.org:/ instead ... \n", + "13624 OAuth login refers to mediawiki.org:/ instead ... \n", + "13625 Improvements to Wikimedia SUL login dialog UI:... \n", + "13626 Improvements to Wikimedia SUL login dialog UI:... \n", + "13627 Improvements to Wikimedia SUL login dialog UI:... \n", + "\n", + " comment_text date_created \\\n", + "0 User:NickK reported in IRC that they're gettin... 1411541280 \n", + "1 Revert has been deployed. 1411573104 \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... 1411572378 \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... 1411545535 \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... 1411542640 \n", + "... ... ... \n", + "13623 > When I registered, phabricator linked mediaw... 1413205650 \n", + "13624 See {T574} for a related discussion. 1412958953 \n", + "13625 Some improvements to the Wikimedia SUL dialog:... 1412362816 \n", + "13626 I guess the same restrictions as in T543 apply... 1412415111 \n", + "13627 It's not entirely trivial to change 1412366627 \n", + "\n", + " speaker meta.affil \\\n", + "0 PHID-USER-v7vgzvvcw7v2umf737ri False \n", + "1 PHID-USER-v7vgzvvcw7v2umf737ri False \n", + "2 PHID-USER-ynivjflmc2dcl6w5ut5v False \n", + "3 PHID-USER-v7bwpq3rs3zdxegibdbh False \n", + "4 PHID-USER-ynivjflmc2dcl6w5ut5v False \n", + "... ... ... \n", + "13623 PHID-USER-hgn5uw2jafgjgfvxibhh False \n", + "13624 PHID-USER-lluzkul4z7us4sxkayss False \n", + "13625 PHID-USER-lluzkul4z7us4sxkayss False \n", + "13626 PHID-USER-lluzkul4z7us4sxkayss False \n", + "13627 PHID-USER-fn7qnpccfbitivgtw2rt False \n", + "\n", + " conversation_id comment_type status \\\n", + "0 PHID-TASK-mio2uq45ny7mms72syut task_description resolved \n", + "1 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN \n", + "2 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN \n", + "3 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN \n", + "4 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN \n", + "... ... ... ... \n", + "13623 PHID-TASK-yeaxsfxhhtbn26koo5fi task_subcomment NaN \n", + "13624 PHID-TASK-yeaxsfxhhtbn26koo5fi task_subcomment NaN \n", + "13625 PHID-TASK-j6czqxlv5fzcx3tmq23n task_description declined \n", + "13626 PHID-TASK-j6czqxlv5fzcx3tmq23n task_subcomment NaN \n", + "13627 PHID-TASK-j6czqxlv5fzcx3tmq23n task_subcomment NaN \n", + "\n", + " meta.gerrit id reply_to timestamp is_relevant \\\n", + "0 False 243215 NaN 2014-09-24 06:48:00+00:00 True \n", + "1 False 243216 243215.0 2014-09-24 15:38:24+00:00 True \n", + "2 False 243217 243216.0 2014-09-24 15:26:18+00:00 True \n", + "3 False 243218 243217.0 2014-09-24 07:58:55+00:00 True \n", + "4 False 243219 243218.0 2014-09-24 07:10:40+00:00 True \n", + "... ... ... ... ... ... \n", + "13623 False 378799 378798.0 2014-10-13 13:07:30+00:00 True \n", + "13624 False 378800 378799.0 2014-10-10 16:35:53+00:00 True \n", + "13625 False 378858 NaN 2014-10-03 19:00:16+00:00 True \n", + "13626 False 378860 378859.0 2014-10-04 09:31:51+00:00 True \n", + "13627 False 378861 378860.0 2014-10-03 20:03:47+00:00 True \n", + "\n", + " is_migrated text \\\n", + "0 False User:NickK reported in IRC that they're gettin... \n", + "1 False Revert has been deployed. \n", + "2 False **gerritadmin** wrote:\\n\\nChange 162550 merged... \n", + "3 False (In reply to Kunal Mehta (Legoktm) from commen... \n", + "4 False **gerritadmin** wrote:\\n\\nChange 162549 merged... \n", + "... ... ... \n", + "13623 False > When I registered, phabricator linked mediaw... \n", + "13624 False See {T574} for a related discussion. \n", + "13625 False Some improvements to the Wikimedia SUL dialog:... \n", + "13626 False I guess the same restrictions as in T543 apply... \n", + "13627 False It's not entirely trivial to change \n", + "\n", + " resolved_text \n", + "0 User:NickK reported in IRC that they're gettin... \n", + "1 Revert has been deployed. \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... \n", + "... ... \n", + "13623 > When I registered, phabricator linked mediaw... \n", + "13624 See {T574} for a related discussion. \n", + "13625 Some improvements to the Wikimedia SUL dialog:... \n", + "13626 I guess the same restrictions as in T543 apply... \n", + "13627 It's not entirely trivial to change \n", + "\n", + "[13628 rows x 16 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(first_resolved_df)\n", + "first_resolved_df" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6dc11bda-f0f6-4eb6-96f5-02ed9a3492ba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14490" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combined_df = pd.concat([first_resolved_df, second_resolved_df])\n", + "unique_df = combined_df.drop_duplicates()\n", + "len(unique_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0c903199-8159-455c-aa7f-e57ef07ce03e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_titlecomment_textdate_createdspeakermeta.affilconversation_idcomment_typestatusmeta.gerritidreply_totimestampis_relevantis_migratedtextresolved_text
0User with unattached accounts unable to login ...User:NickK reported in IRC that they're gettin...1411541280PHID-USER-v7vgzvvcw7v2umf737riFalsePHID-TASK-mio2uq45ny7mms72syuttask_descriptionresolvedFalse243215NaN2014-09-24 06:48:00+00:00TrueFalseUser:NickK reported in IRC that they're gettin...User:NickK reported in IRC that they're gettin...
1User with unattached accounts unable to login ...Revert has been deployed.1411573104PHID-USER-v7vgzvvcw7v2umf737riFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243216243215.02014-09-24 15:38:24+00:00TrueFalseRevert has been deployed.Revert has been deployed.
2User with unattached accounts unable to login ...**gerritadmin** wrote:\\n\\nChange 162550 merged...1411572378PHID-USER-ynivjflmc2dcl6w5ut5vFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243217243216.02014-09-24 15:26:18+00:00TrueFalse**gerritadmin** wrote:\\n\\nChange 162550 merged...**gerritadmin** wrote:\\n\\nChange 162550 merged...
3User with unattached accounts unable to login ...(In reply to Kunal Mehta (Legoktm) from commen...1411545535PHID-USER-v7bwpq3rs3zdxegibdbhFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243218243217.02014-09-24 07:58:55+00:00TrueFalse(In reply to Kunal Mehta (Legoktm) from commen...(In reply to Kunal Mehta (Legoktm) from commen...
4User with unattached accounts unable to login ...**gerritadmin** wrote:\\n\\nChange 162549 merged...1411542640PHID-USER-ynivjflmc2dcl6w5ut5vFalsePHID-TASK-mio2uq45ny7mms72syuttask_subcommentNaNFalse243219243218.02014-09-24 07:10:40+00:00TrueFalse**gerritadmin** wrote:\\n\\nChange 162549 merged...**gerritadmin** wrote:\\n\\nChange 162549 merged...
...................................................
857text input history/autocomplete doesn't work w...I amended the title to the range IE8-10 becaus...1434207367PHID-USER-lhtlnmkdbzlz6pbxaqddFalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406640406639.02015-06-13 14:56:07+00:00TrueFalseI amended the title to the range IE8-10 becaus...I amended the title to the range IE8-10 becaus...
858text input history/autocomplete doesn't work w...If I remember correctly this problem was at le...1434140114PHID-USER-wrimmmr5w2zt7nk2t753FalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406641406640.02015-06-12 20:15:14+00:00TrueFalseIf I remember correctly this problem was at le...If I remember correctly this problem was at le...
859text input history/autocomplete doesn't work w...If I remember correctly this problem was at le...1434116915PHID-USER-wrimmmr5w2zt7nk2t753FalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406642406641.02015-06-12 13:48:35+00:00TrueFalseIf I remember correctly this problem was at le...If I remember correctly this problem was at le...
860text input history/autocomplete doesn't work w...After a quick test, autocomplete seems to work...1434114623PHID-USER-sx63fwaih5kjt7bz4u6zFalsePHID-TASK-onqydqsd354curr7z7mbtask_subcommentNaNFalse406643406642.02015-06-12 13:10:23+00:00TrueFalseAfter a quick test, autocomplete seems to work...After a quick test, autocomplete seems to work...
861Allow login using mosh as an alternative to pl...Still not merged, so we can't really do much.1413537437PHID-USER-2nnm76h4ykalvvref2yeFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406877406876.02014-10-17 09:17:17+00:00TrueFalseStill not merged, so we can't really do much.Still not merged, so we can't really do much.
\n", + "

14490 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " task_title \\\n", + "0 User with unattached accounts unable to login ... \n", + "1 User with unattached accounts unable to login ... \n", + "2 User with unattached accounts unable to login ... \n", + "3 User with unattached accounts unable to login ... \n", + "4 User with unattached accounts unable to login ... \n", + ".. ... \n", + "857 text input history/autocomplete doesn't work w... \n", + "858 text input history/autocomplete doesn't work w... \n", + "859 text input history/autocomplete doesn't work w... \n", + "860 text input history/autocomplete doesn't work w... \n", + "861 Allow login using mosh as an alternative to pl... \n", + "\n", + " comment_text date_created \\\n", + "0 User:NickK reported in IRC that they're gettin... 1411541280 \n", + "1 Revert has been deployed. 1411573104 \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... 1411572378 \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... 1411545535 \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... 1411542640 \n", + ".. ... ... \n", + "857 I amended the title to the range IE8-10 becaus... 1434207367 \n", + "858 If I remember correctly this problem was at le... 1434140114 \n", + "859 If I remember correctly this problem was at le... 1434116915 \n", + "860 After a quick test, autocomplete seems to work... 1434114623 \n", + "861 Still not merged, so we can't really do much. 1413537437 \n", + "\n", + " speaker meta.affil \\\n", + "0 PHID-USER-v7vgzvvcw7v2umf737ri False \n", + "1 PHID-USER-v7vgzvvcw7v2umf737ri False \n", + "2 PHID-USER-ynivjflmc2dcl6w5ut5v False \n", + "3 PHID-USER-v7bwpq3rs3zdxegibdbh False \n", + "4 PHID-USER-ynivjflmc2dcl6w5ut5v False \n", + ".. ... ... \n", + "857 PHID-USER-lhtlnmkdbzlz6pbxaqdd False \n", + "858 PHID-USER-wrimmmr5w2zt7nk2t753 False \n", + "859 PHID-USER-wrimmmr5w2zt7nk2t753 False \n", + "860 PHID-USER-sx63fwaih5kjt7bz4u6z False \n", + "861 PHID-USER-2nnm76h4ykalvvref2ye False \n", + "\n", + " conversation_id comment_type status meta.gerrit \\\n", + "0 PHID-TASK-mio2uq45ny7mms72syut task_description resolved False \n", + "1 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "2 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "3 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + "4 PHID-TASK-mio2uq45ny7mms72syut task_subcomment NaN False \n", + ".. ... ... ... ... \n", + "857 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "858 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "859 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "860 PHID-TASK-onqydqsd354curr7z7mb task_subcomment NaN False \n", + "861 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN False \n", + "\n", + " id reply_to timestamp is_relevant is_migrated \\\n", + "0 243215 NaN 2014-09-24 06:48:00+00:00 True False \n", + "1 243216 243215.0 2014-09-24 15:38:24+00:00 True False \n", + "2 243217 243216.0 2014-09-24 15:26:18+00:00 True False \n", + "3 243218 243217.0 2014-09-24 07:58:55+00:00 True False \n", + "4 243219 243218.0 2014-09-24 07:10:40+00:00 True False \n", + ".. ... ... ... ... ... \n", + "857 406640 406639.0 2015-06-13 14:56:07+00:00 True False \n", + "858 406641 406640.0 2015-06-12 20:15:14+00:00 True False \n", + "859 406642 406641.0 2015-06-12 13:48:35+00:00 True False \n", + "860 406643 406642.0 2015-06-12 13:10:23+00:00 True False \n", + "861 406877 406876.0 2014-10-17 09:17:17+00:00 True False \n", + "\n", + " text \\\n", + "0 User:NickK reported in IRC that they're gettin... \n", + "1 Revert has been deployed. \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... \n", + ".. ... \n", + "857 I amended the title to the range IE8-10 becaus... \n", + "858 If I remember correctly this problem was at le... \n", + "859 If I remember correctly this problem was at le... \n", + "860 After a quick test, autocomplete seems to work... \n", + "861 Still not merged, so we can't really do much. \n", + "\n", + " resolved_text \n", + "0 User:NickK reported in IRC that they're gettin... \n", + "1 Revert has been deployed. \n", + "2 **gerritadmin** wrote:\\n\\nChange 162550 merged... \n", + "3 (In reply to Kunal Mehta (Legoktm) from commen... \n", + "4 **gerritadmin** wrote:\\n\\nChange 162549 merged... \n", + ".. ... \n", + "857 I amended the title to the range IE8-10 becaus... \n", + "858 If I remember correctly this problem was at le... \n", + "859 If I remember correctly this problem was at le... \n", + "860 After a quick test, autocomplete seems to work... \n", + "861 Still not merged, so we can't really do much. \n", + "\n", + "[14490 rows x 16 columns]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unique_df" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0c392d70-6236-4dfe-b6d4-bbe3f422b09e", + "metadata": {}, + "outputs": [], + "source": [ + "unique_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref-rel-final.csv\", index=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/text_analysis/case3/c3-resolved-phab.ipynb b/text_analysis/case3/c3-resolved-phab.ipynb new file mode 100644 index 0000000..a3e8016 --- /dev/null +++ b/text_analysis/case3/c3-resolved-phab.ipynb @@ -0,0 +1,777 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ba9e5acd-e17d-4318-9272-04c9f6706186", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd \n", + "import spacy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e4f0b3f0-5255-46f1-822f-e455087ba315", + "metadata": {}, + "outputs": [], + "source": [ + "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref-rel-final.csv\"\n", + "phab_df = pd.read_csv(phab_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d449164e-1d28-4580-9eb1-f0f69978f114", + "metadata": {}, + "outputs": [], + "source": [ + "#find gerrit phab PHID: PHID-USER-idceizaw6elwiwm5xshb\n", + "#phab_df['isGerrit'] = phab_df['AuthorPHID'] == 'PHID-USER-idceizaw6elwiwm5xshb'\n", + "\n", + "#cleaning df\n", + "#phab_df['id'] = phab_df.index + 1\n", + "#may have to build out the reply_to column \n", + "#phab_df['reply_to'] = phab_df.groupby('TaskPHID')['id'].shift()\n", + "#phab_df['reply_to'] = phab_df['reply_to'].where(pd.notnull(phab_df['reply_to']), None)\n", + "\n", + "#phab_df = phab_df.rename(columns={\n", + "# 'AuthorPHID': 'speaker',\n", + "# 'TaskPHID': 'conversation_id',\n", + "# 'WMFaffil':'meta.affil',\n", + "# 'isGerrit': 'meta.gerrit'\n", + "#})\n", + "\n", + "# after 12-1-2012 before 12-1-2013\n", + "#phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n", + "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1385856000) & (phab_df['date_created'] > 1354320000)]\n", + "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n", + "\n", + "#removing headless conversations\n", + "task_phab_df = phab_df[phab_df['comment_type']==\"task_description\"]\n", + "headed_task_phids = task_phab_df['conversation_id'].unique()\n", + "filtered_phab_df = phab_df[phab_df['conversation_id'].isin(headed_task_phids)]\n", + "\n", + "#removing gerrit comments \n", + "#mid_comment_phab_df = filtered_phab_df[filtered_phab_df['meta.gerrit'] != True]\n", + "\n", + "'''\n", + "# filter out the sourceforge migration \n", + "# Originally from: http://sourceforge.net in the task task_summary\n", + "migrated_conversation_ids = task_phab_df[task_phab_df['comment_text'].apply(is_migrated)]['conversation_id'].unique()\n", + "\n", + "#cut down to only the data that is relevant (mentions http)\n", + "relevant_conversation_ids = task_phab_df[\n", + " task_phab_df['comment_text'].apply(http_relevant) |\n", + " task_phab_df['task_title'].apply(http_relevant)\n", + "]['conversation_id'].unique()\n", + "\n", + "task_phab_df['is_relevant'] = task_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", + "mid_comment_phab_df['is_relevant'] = mid_comment_phab_df['conversation_id'].isin(relevant_conversation_ids)\n", + "\n", + "task_phab_df['is_migrated'] = task_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", + "mid_comment_phab_df['is_migrated'] = mid_comment_phab_df['conversation_id'].isin(migrated_conversation_ids)\n", + "'''\n", + "#comment_phab_df = mid_comment_phab_df[(mid_comment_phab_df['is_relevant'] == True) & (mid_comment_phab_df['is_migrated'] != True)]\n", + "#task_phab_df = task_phab_df[(task_phab_df['is_relevant'] == True) & (task_phab_df['is_migrated'] != True)]\n", + "comment_phab_df = filtered_phab_df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "942344db-c8f5-4ed6-a757-c97f8454f18b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique conversation_ids: 2281\n", + "Unique ids: 14490\n", + "Unique speakers: 634\n" + ] + } + ], + "source": [ + "unique_conversation_ids = len(comment_phab_df['conversation_id'].unique())\n", + "unique_ids = len(comment_phab_df['id'].unique())\n", + "unique_speakers = len(comment_phab_df['speaker'].unique())\n", + "\n", + "print(f\"Unique conversation_ids: {unique_conversation_ids}\")\n", + "print(f\"Unique ids: {unique_ids}\")\n", + "print(f\"Unique speakers: {unique_speakers}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d226d781-b002-4842-a3ae-92d4851a5878", + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "def preprocess_text(text):\n", + " text = str(text)\n", + " text = text.replace('*', ' ')\n", + " text = text.replace('-', ' ')\n", + " text = re.sub(r'http\\S+', '', text)\n", + " return text" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3ae40d24-bbe8-49c3-a3a9-70bde1b4d559", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['processed_text'] = comment_phab_df['comment_text'].apply(preprocess_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b8eddf40-1fe2-4fce-be74-b32552b40c57", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['processed_resolved_text'] = comment_phab_df['resolved_text'].apply(preprocess_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a8469b16-4ae6-4b06-bf1b-1f2f6c736cab", + "metadata": {}, + "outputs": [], + "source": [ + "nlp = spacy.load(\"en_core_web_sm\")\n", + "\n", + "def extract_dependency_tree(text):\n", + " doc = nlp(text)\n", + " dependency_trees = []\n", + " \n", + " for sentence in doc.sents:\n", + " for token in sentence:\n", + " token_info = (\n", + " token.text, \n", + " token.lemma_, \n", + " token.dep_, \n", + " token.head.text, \n", + " list(token.ancestors), \n", + " list(token.subtree), \n", + " list(token.children)\n", + " )\n", + " dependency_trees.append(token_info)\n", + " \n", + " return dependency_trees" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8b9a12f9-71bf-4bc9-bcfd-c73aab4be920", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['dependency_tree'] = comment_phab_df['processed_text'].apply(extract_dependency_tree)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "337a528a-5667-4e1f-ac9a-37caabc03a18", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df['resolved_dependency_tree'] = comment_phab_df['processed_resolved_text'].apply(extract_dependency_tree)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a3f5d40b-f56e-4e31-a7f9-40b7ddb4d2a4", + "metadata": {}, + "outputs": [], + "source": [ + "#get VAD scores\n", + "import numpy as np\n", + "#https://saifmohammad.com/WebPages/nrc-vad.html\n", + "column_headings = ['Word', 'Valence', 'Arousal', 'Domination']\n", + "vad_lexicon = pd.read_csv('NRC-VAD-Lexicon.txt', delimiter='\\t', header=None, names=column_headings)\n", + "vad_dict = vad_lexicon.set_index('Word').T.to_dict()\n", + "\n", + "def vad_scoring(dependency_tree):\n", + " valence = []\n", + " arousal = []\n", + " dominance = []\n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " valence.append(vad_dict[lemma]['Valence'])\n", + " arousal.append(vad_dict[lemma]['Arousal'])\n", + " dominance.append(vad_dict[lemma]['Domination'])\n", + "\n", + " # Compute average scores across the comment\n", + " avg_valence = np.mean(valence) if valence else 0\n", + " avg_arousal = np.mean(arousal) if arousal else 0\n", + " avg_dominance = np.mean(dominance) if dominance else 0\n", + "\n", + " return [avg_valence, avg_arousal, avg_dominance]\n", + "\n", + "def dominance_prevail(dependency_tree):\n", + " dominant_words = 0 \n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " if vad_dict[lemma]['Domination'] >= 0.75:\n", + " dominant_words += 1\n", + " if vad_dict[lemma]['Domination'] <= 0.25:\n", + " dominant_words += 1\n", + " return dominant_words\n", + "\n", + "def arousal_prevail(dependency_tree):\n", + " arousal_words = 0 \n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " if vad_dict[lemma]['Arousal'] >= 0.75:\n", + " arousal_words += 1\n", + " if vad_dict[lemma]['Arousal'] <= 0.25:\n", + " arousal_words += 1\n", + " return arousal_words\n", + "\n", + "def valence_prevail(dependency_tree):\n", + " valence_words = 0 \n", + " for token, lemma, dep, head, ancestors, subtree, children in dependency_tree:\n", + " if lemma in vad_dict:\n", + " if vad_dict[lemma]['Valence'] >= 0.75:\n", + " valence_words += 1\n", + " if vad_dict[lemma]['Valence'] <= 0.25:\n", + " valence_words += 1\n", + " return valence_words\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "828fb57a-e152-42ef-9c60-660648898532", + "metadata": {}, + "outputs": [], + "source": [ + "#establishing per-comment VAD scores \n", + "comment_phab_df['avg_vad_scores'] = comment_phab_df['dependency_tree'].apply(vad_scoring)\n", + "comment_phab_df['dominant_wc'] = comment_phab_df['dependency_tree'].apply(dominance_prevail)\n", + "comment_phab_df['arousal_wc'] = comment_phab_df['dependency_tree'].apply(arousal_prevail)\n", + "comment_phab_df['valence_wc'] = comment_phab_df['dependency_tree'].apply(valence_prevail)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "27e47f6f-0257-4b70-b222-e91ef888c900", + "metadata": {}, + "outputs": [], + "source": [ + "comment_phab_df[['average_v_score', 'average_a_score', 'average_d_score']] = pd.DataFrame(comment_phab_df['avg_vad_scores'].tolist(), index=comment_phab_df.index)\n", + "comment_phab_df = comment_phab_df.drop(columns=['avg_vad_scores'])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1889034d-bc93-495f-bdc4-961d193d3e08", + "metadata": {}, + "outputs": [], + "source": [ + "def token_http_relevant(word):\n", + " # expanded dictionary for relevancy\n", + " # http, login, SSL, TLS, certificate \n", + " if \"://\" not in word.lower():\n", + " #http\n", + " if \"http\" in word.lower():\n", + " return True\n", + " #login\n", + " if \"login\" in word.lower():\n", + " return True\n", + " #ssl\n", + " if \"ssl\" in word.lower():\n", + " return True\n", + " #tls\n", + " if \"tls\" in word.lower():\n", + " return True\n", + " #cert\n", + " if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n", + " return True\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "09ddcbfc-b856-40ca-ad61-13577795d94b", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "184ccbe6-0a7a-41b8-9b02-bc439ff975d0", + "metadata": {}, + "outputs": [], + "source": [ + "# expand the dependency parser \n", + "dependency_relations = []\n", + "resolved_dependency_relations = []\n", + "\n", + "for index, row in comment_phab_df.iterrows():\n", + " text = row['comment_text']\n", + " timestamp = row['timestamp']\n", + " comment_id = row['id']\n", + " conversation_id = row['conversation_id']\n", + " WMFaffil = row['meta.affil']\n", + " \n", + " for token, lemma, dep, head, ancestors, subtree, children in row['dependency_tree']:\n", + " dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", + " \n", + " for token, lemma, dep, head, ancestors, subtree, children in row['resolved_dependency_tree']:\n", + " resolved_dependency_relations.append({\n", + " 'comment_id': comment_id,\n", + " 'timestamp': timestamp,\n", + " 'wmfAffil':WMFaffil,\n", + " 'token': token,\n", + " 'dependency': dep,\n", + " 'head': head,\n", + " 'depth': len(list(ancestors)), \n", + " 'children': len(list(children)) \n", + " })\n", + "\n", + "resolved_dependency_relations_df = pd.DataFrame(resolved_dependency_relations) \n", + "dependency_relations_df = pd.DataFrame(dependency_relations)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "82498686-14f4-40c8-9e33-27b31f115b47", + "metadata": {}, + "outputs": [], + "source": [ + "#now analysis/plotting \n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from matplotlib.gridspec import GridSpec" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "5a91a59a-0d1c-48b3-93dd-b9df76ca68e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot2 = sns.lmplot(data=affective_comment_phab_df, x=\"speakers_comment\", y=\"polarized_wc\", hue=\"date_group\", col=\"meta.affil\", scatter=False, legend=False, palette=palette)\n", + "plot2.set_axis_labels(\"Index of Speaker's Comment\", \"Count of Polarized Words\")\n", + "plot2.set_titles(col_template=\"WMF Affiliation: {col_name}\")\n", + "plot2.fig.subplots_adjust(top=0.9) # Adjust subplots to make room for the title\n", + "plot2.add_legend(title=\"Comment publication timestamp:\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "2274795e-c64d-43e4-b0f5-a19b5b8ba2c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
comment_idtimestampwmfAffiltokendependencyheaddepthchildren
02432152014-09-24 06:48:00+00:00FalseUserdepreported10
12432152014-09-24 06:48:00+00:00False:punctreported10
22432152014-09-24 06:48:00+00:00FalseNickKnsubjreported10
32432152014-09-24 06:48:00+00:00FalsereportedROOTreported07
42432152014-09-24 06:48:00+00:00Falseinprepreported11
...........................
17087444068772014-10-17 09:17:17+00:00Falsen'tnegdo10
17087454068772014-10-17 09:17:17+00:00Falsereallyadvmoddo10
17087464068772014-10-17 09:17:17+00:00FalsedoROOTdo09
17087474068772014-10-17 09:17:17+00:00Falsemuchdobjdo10
17087484068772014-10-17 09:17:17+00:00False.punctdo10
\n", + "

1708749 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " comment_id timestamp wmfAffil token dependency \\\n", + "0 243215 2014-09-24 06:48:00+00:00 False User dep \n", + "1 243215 2014-09-24 06:48:00+00:00 False : punct \n", + "2 243215 2014-09-24 06:48:00+00:00 False NickK nsubj \n", + "3 243215 2014-09-24 06:48:00+00:00 False reported ROOT \n", + "4 243215 2014-09-24 06:48:00+00:00 False in prep \n", + "... ... ... ... ... ... \n", + "1708744 406877 2014-10-17 09:17:17+00:00 False n't neg \n", + "1708745 406877 2014-10-17 09:17:17+00:00 False really advmod \n", + "1708746 406877 2014-10-17 09:17:17+00:00 False do ROOT \n", + "1708747 406877 2014-10-17 09:17:17+00:00 False much dobj \n", + "1708748 406877 2014-10-17 09:17:17+00:00 False . punct \n", + "\n", + " head depth children \n", + "0 reported 1 0 \n", + "1 reported 1 0 \n", + "2 reported 1 0 \n", + "3 reported 0 7 \n", + "4 reported 1 1 \n", + "... ... ... ... \n", + "1708744 do 1 0 \n", + "1708745 do 1 0 \n", + "1708746 do 0 9 \n", + "1708747 do 1 0 \n", + "1708748 do 1 0 \n", + "\n", + "[1708749 rows x 8 columns]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resolved_dependency_relations_df" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "d2d67d38-f005-4c94-be3c-39eb6b22686f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_40267/3864244444.py:8: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + " filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "/tmp/ipykernel_40267/3864244444.py:9: UserWarning: This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.\n", + " resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "/tmp/ipykernel_40267/3864244444.py:24: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_40267/3864244444.py:25: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "/tmp/ipykernel_40267/3864244444.py:25: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "/tmp/ipykernel_40267/3864244444.py:46: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", + "/tmp/ipykernel_40267/3864244444.py:47: UserWarning: Converting to PeriodArray/Index representation will drop timezone information.\n", + " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "/tmp/ipykernel_40267/3864244444.py:47: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#pattern = r'\\b(ve|VE|visualeditor|VisualEditor)\\b'\n", + "pattern = r'\\b(contributor|community|volunteer)\\b'\n", + "#pattern = r'\\b(WMF|Foundation|Wikimedia)\\b'\n", + "#pattern = r'\\b(bots|scripts|gadgets)\\b'\n", + "#pattern = r'\\b(http|https)\\b'\n", + "#pattern = r'\\b(auth)\\b'\n", + "\n", + "filtered_dependencies = dependency_relations_df[dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "resolved_filtered_dependencies = resolved_dependency_relations_df[resolved_dependency_relations_df['token'].str.contains(pattern, regex=True)]\n", + "\n", + "plt.figure(figsize=(12, 8))\n", + "gs = GridSpec(2, 1, height_ratios=[6, 6])\n", + "\n", + "# Main plot: Token depth by timestamp\n", + "'''\n", + "ax0 = plt.subplot(gs[0])\n", + "sns.scatterplot(data=filtered_dependencies, x='timestamp', y='dependency', hue='wmfAffil', style='dependency', markers=True, s=100, ax=ax0)\n", + "ax0.set_title('VE Depth by Timestamp w/o URLS')\n", + "ax0.set_xlabel('')\n", + "ax0.set_ylabel('Dependency Type')\n", + "ax0.legend().set_visible(False)\n", + "'''\n", + "# Calculate the median depth over time\n", + "filtered_dependencies['timestamp'] = pd.to_datetime(filtered_dependencies['timestamp'], utc=True)\n", + "filtered_dependencies['week'] = filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "median_depth = filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "wmf_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] == True]\n", + "#wmf_median_depth = wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "other_filtered_dependencies = filtered_dependencies[filtered_dependencies['wmfAffil'] != True]\n", + "#other_median_depth = other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "# Plot the median depth over time\n", + "ax0 = plt.subplot(gs[0])\n", + "#sns.lineplot(data=median_depth, x='week', y='depth', ax=ax0, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=wmf_filtered_dependencies, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=wmf_median_depth, x='week', y='depth', ax=ax0, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=other_filtered_dependencies, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=other_median_depth, x='week', y='depth', ax=ax0, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax0.set_title(f'Depth of {pattern} in Phabricator Sentence Dependency Trees')\n", + "ax0.set_ylabel('Median Depth')\n", + "ax0.set_xlabel('')\n", + "\n", + "# Calculate the median depth over time\n", + "resolved_filtered_dependencies['timestamp'] = pd.to_datetime(resolved_filtered_dependencies['timestamp'], utc=True)\n", + "resolved_filtered_dependencies['week'] = resolved_filtered_dependencies['timestamp'].dt.to_period('W').dt.start_time\n", + "resolved_median_depth = resolved_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "resolved_wmf_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] == True]\n", + "#resolved_wmf_median_depth = resolved_wmf_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "resolved_other_filtered_dependencies = resolved_filtered_dependencies[resolved_filtered_dependencies['wmfAffil'] != True]\n", + "#resolved_other_median_depth = resolved_other_filtered_dependencies.groupby('week')['depth'].median().reset_index()\n", + "\n", + "# Plot the median depth over time\n", + "ax1 = plt.subplot(gs[1])\n", + "#sns.lineplot(data=resolved_median_depth, x='week', y='depth', ax=ax1, color='black', label='Median Depth', marker='o')\n", + "sns.scatterplot(data=resolved_wmf_filtered_dependencies, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_wmf_median_depth, x='week', y='depth', ax=ax1, color='#c7756a', label='WMF-affiliated authors', marker='x')\n", + "sns.scatterplot(data=resolved_other_filtered_dependencies, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='o')\n", + "#sns.lineplot(data=resolved_other_median_depth, x='week', y='depth', ax=ax1, color='#5da2d8', label='Nonaffiliated authors', marker='x')\n", + "ax1.set_title(f'Depth of {pattern} in Coreference-resolved Phabricator Sentence Dependency Trees')\n", + "ax1.set_ylabel('Median Depth')\n", + "ax1.set_xlabel('')\n", + "\n", + "plt.tight_layout()\n", + "#plt.show()\n", + "\n", + "#plt.savefig('031625_VE_depth_fig.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3e11af2-388a-4112-a71b-82c9fd6d5886", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/text_analysis/case3/coref_resolution-http.ipynb b/text_analysis/case3/coref_resolution-http.ipynb index 5dd1e52..98d3d02 100644 --- a/text_analysis/case3/coref_resolution-http.ipynb +++ b/text_analysis/case3/coref_resolution-http.ipynb @@ -10,9 +10,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n", - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/torch/cuda/__init__.py:497: UserWarning: Can't initialize NVML\n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/torch/cuda/__init__.py:497: UserWarning: Can't initialize NVML\n", " warnings.warn(\"Can't initialize NVML\")\n" ] } @@ -29,7 +29,7 @@ "metadata": {}, "outputs": [], "source": [ - "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0415_http_phab_comments.csv\"\n", + "phab_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0422_http_phab_comments.csv\"\n", "phab_df = pd.read_csv(phab_path)" ] }, @@ -61,7 +61,7 @@ " if \"tls\" in word.lower():\n", " return True\n", " #cert\n", - " if word.lower().startswith(\"cert\"):\n", + " if word.lower().startswith(\"cert\") and not word.lower().startswith(\"certain\"):\n", " return True\n", " return False\n", "\n", @@ -84,12 +84,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:41: SettingWithCopyWarning: \n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:42: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:44: SettingWithCopyWarning: \n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:45: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -114,10 +114,11 @@ " 'isGerrit': 'meta.gerrit'\n", "})\n", "\n", - "# after 04-01-2015 before 10-1-2015\n", + "# after 10-01-2014 before 10-01-2015\n", "phab_df['timestamp'] = pd.to_datetime(phab_df['date_created'], unit='s', origin='unix', utc=True)\n", - "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443657600) & (phab_df['date_created'] > 1427846400)]\n", - "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1381691276) & (phab_df['date_created'] > 1379975444)]\n", + "#filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] >= 1412207999)]\n", + "# after 07-01-2013 before 10-01-2015\n", + "filtered_phab_df = phab_df[(phab_df['date_created'] < 1443743999) & (phab_df['date_created'] > 1372636800)]\n", "\n", "#removing headless conversations\n", "task_phab_df = filtered_phab_df[filtered_phab_df['comment_type']==\"task_description\"]\n", @@ -156,8 +157,314 @@ "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_titlecomment_textdate_createdspeakermeta.affilconversation_idcomment_typestatusmeta.gerritidreply_totimestampis_relevantis_migrated
197Creation of instances brokenAfter a replace of old instances, it is not po...1442753295PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_descriptionresolvedFalse198NaN2015-09-20 12:48:15+00:00TrueFalse
198Creation of instances brokenWorks now.1442864673PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse199198.02015-09-21 19:44:33+00:00TrueFalse
199Creation of instances brokenOk, the instances are deleted now, I will recr...1442864271PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse200199.02015-09-21 19:37:51+00:00TrueFalse
200Creation of instances brokenThe new instances have the same names as recen...1442854156PHID-USER-22bsa5u75jz3ci3wnpluFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse201200.02015-09-21 16:49:16+00:00TrueFalse
201Creation of instances brokenThis happens also with jessie and presice inst...1442835238PHID-USER-qlodcndtwpolbdhncjisFalsePHID-TASK-pitdrld6mszruqmc6usftask_subcommentNaNFalse202201.02015-09-21 11:33:58+00:00TrueFalse
.............................................
406887Allow login using mosh as an alternative to pl...*** Bug 49454 has been marked as a duplicate o...1379011061PHID-USER-2nnm76h4ykalvvref2yeFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406888406887.02013-09-12 18:37:41+00:00TrueFalse
406888Allow login using mosh as an alternative to pl...JFTR, on Tools mosh-server processes eat up to...1376245807PHID-USER-vk6mlmacfhx77egryy5iFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406889406888.02013-08-11 18:30:07+00:00TrueFalse
406889Allow login using mosh as an alternative to pl...This is supported on tools, but adding it to t...1376185312PHID-USER-h75guknmwivm6x37iuteFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406890406889.02013-08-11 01:41:52+00:00TrueFalse
406890Allow login using mosh as an alternative to pl...Just found out that mosh already works for too...1376118400PHID-USER-5dqihbanu3caaj7pigifFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406891406890.02013-08-10 07:06:40+00:00TrueFalse
406891Allow login using mosh as an alternative to pl...(In reply to comment #0)\\n> ssh is quite painf...1376118251PHID-USER-6vzzsmi22zem6yttr6vpFalsePHID-TASK-hnwvtmwgpm2oisoqaozttask_subcommentNaNFalse406892406891.02013-08-10 07:04:11+00:00TrueFalse
\n", + "

14490 rows × 14 columns

\n", + "
" + ], "text/plain": [ - "5657" + " task_title \\\n", + "197 Creation of instances broken \n", + "198 Creation of instances broken \n", + "199 Creation of instances broken \n", + "200 Creation of instances broken \n", + "201 Creation of instances broken \n", + "... ... \n", + "406887 Allow login using mosh as an alternative to pl... \n", + "406888 Allow login using mosh as an alternative to pl... \n", + "406889 Allow login using mosh as an alternative to pl... \n", + "406890 Allow login using mosh as an alternative to pl... \n", + "406891 Allow login using mosh as an alternative to pl... \n", + "\n", + " comment_text date_created \\\n", + "197 After a replace of old instances, it is not po... 1442753295 \n", + "198 Works now. 1442864673 \n", + "199 Ok, the instances are deleted now, I will recr... 1442864271 \n", + "200 The new instances have the same names as recen... 1442854156 \n", + "201 This happens also with jessie and presice inst... 1442835238 \n", + "... ... ... \n", + "406887 *** Bug 49454 has been marked as a duplicate o... 1379011061 \n", + "406888 JFTR, on Tools mosh-server processes eat up to... 1376245807 \n", + "406889 This is supported on tools, but adding it to t... 1376185312 \n", + "406890 Just found out that mosh already works for too... 1376118400 \n", + "406891 (In reply to comment #0)\\n> ssh is quite painf... 1376118251 \n", + "\n", + " speaker meta.affil \\\n", + "197 PHID-USER-qlodcndtwpolbdhncjis False \n", + "198 PHID-USER-qlodcndtwpolbdhncjis False \n", + "199 PHID-USER-qlodcndtwpolbdhncjis False \n", + "200 PHID-USER-22bsa5u75jz3ci3wnplu False \n", + "201 PHID-USER-qlodcndtwpolbdhncjis False \n", + "... ... ... \n", + "406887 PHID-USER-2nnm76h4ykalvvref2ye False \n", + "406888 PHID-USER-vk6mlmacfhx77egryy5i False \n", + "406889 PHID-USER-h75guknmwivm6x37iute False \n", + "406890 PHID-USER-5dqihbanu3caaj7pigif False \n", + "406891 PHID-USER-6vzzsmi22zem6yttr6vp False \n", + "\n", + " conversation_id comment_type status \\\n", + "197 PHID-TASK-pitdrld6mszruqmc6usf task_description resolved \n", + "198 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "199 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "200 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "201 PHID-TASK-pitdrld6mszruqmc6usf task_subcomment NaN \n", + "... ... ... ... \n", + "406887 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406888 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406889 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406890 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "406891 PHID-TASK-hnwvtmwgpm2oisoqaozt task_subcomment NaN \n", + "\n", + " meta.gerrit id reply_to timestamp is_relevant \\\n", + "197 False 198 NaN 2015-09-20 12:48:15+00:00 True \n", + "198 False 199 198.0 2015-09-21 19:44:33+00:00 True \n", + "199 False 200 199.0 2015-09-21 19:37:51+00:00 True \n", + "200 False 201 200.0 2015-09-21 16:49:16+00:00 True \n", + "201 False 202 201.0 2015-09-21 11:33:58+00:00 True \n", + "... ... ... ... ... ... \n", + "406887 False 406888 406887.0 2013-09-12 18:37:41+00:00 True \n", + "406888 False 406889 406888.0 2013-08-11 18:30:07+00:00 True \n", + "406889 False 406890 406889.0 2013-08-11 01:41:52+00:00 True \n", + "406890 False 406891 406890.0 2013-08-10 07:06:40+00:00 True \n", + "406891 False 406892 406891.0 2013-08-10 07:04:11+00:00 True \n", + "\n", + " is_migrated \n", + "197 False \n", + "198 False \n", + "199 False \n", + "200 False \n", + "201 False \n", + "... ... \n", + "406887 False \n", + "406888 False \n", + "406889 False \n", + "406890 False \n", + "406891 False \n", + "\n", + "[14490 rows x 14 columns]" ] }, "execution_count": 5, @@ -166,22 +473,62 @@ } ], "source": [ - "len(comment_phab_df)" + "comment_phab_df" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, + "id": "930c4d9c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "data": { + "text/plain": [ + "862" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior_path = \"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/0050825_coref-rel-first.csv\"\n", + "prior_df = pd.read_csv(prior_path)\n", + "comment_phab_df['timestamp'] = pd.to_datetime(comment_phab_df['timestamp'], utc=True)\n", + "prior_df['timestamp'] = pd.to_datetime(prior_df['timestamp'], utc=True)\n", + "merged_df = comment_phab_df.merge(prior_df, how='outer', indicator=True)\n", + "len(merged_df)\n", + "only_in_comment_phab_df = merged_df[merged_df['_merge'] == 'left_only']\n", + "len(only_in_comment_phab_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "id": "f32f6eed-3aeb-4b05-8d40-7ed85e7235c5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -202,7 +549,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "a5b062d8-2d26-4a3e-a84c-ba0eaf6eb436", "metadata": {}, "outputs": [], @@ -216,15 +563,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "424d35e0", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "John is frustrated with the VisualEditor project, he thinks it doesn't work." + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "doc" + ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "id": "999e1656-0036-4ba2-bedf-f54493f67790", "metadata": {}, "outputs": [], @@ -270,7 +630,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "id": "be476647-624b-4e95-ab62-9c6b08f85368", "metadata": {}, "outputs": [], @@ -283,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "id": "a9628b54-a1df-49cd-a365-9cba59de3421", "metadata": {}, "outputs": [ @@ -293,7 +653,7 @@ "'i hate ve.interface, ve.interface always messes up i browser'" ] }, - "execution_count": 9, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -304,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 19, "id": "46873641-8e88-4829-9e24-4dd5e6749bd1", "metadata": {}, "outputs": [ @@ -312,7 +672,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/gscratch/scrubbed/mjilg/envs/coref2-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -322,12 +682,12 @@ } ], "source": [ - "comment_phab_df['text'] = comment_phab_df['comment_text'].apply(str)" + "only_in_comment_phab_df['text'] = only_in_comment_phab_df['comment_text'].apply(str)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "79e3f7e2", "metadata": {}, "outputs": [ @@ -335,24 +695,53 @@ "name": "stderr", "output_type": "stream", "text": [ - "Token indices sequence length is longer than the specified maximum sequence length for this model (712 > 512). Running this sequence through the model will result in indexing errors\n", - "Token indices sequence length is longer than the specified maximum sequence length for this model (712 > 512). Running this sequence through the model will result in indexing errors\n", - "Token indices sequence length is longer than the specified maximum sequence length for this model (572 > 512). Running this sequence through the model will result in indexing errors\n" + "Token indices sequence length is longer than the specified maximum sequence length for this model (546 > 512). Running this sequence through the model will result in indexing errors\n", + "Token indices sequence length is longer than the specified maximum sequence length for this model (546 > 512). Running this sequence through the model will result in indexing errors\n", + "Token indices sequence length is longer than the specified maximum sequence length for this model (554 > 512). Running this sequence through the model will result in indexing errors\n", + "/gscratch/scrubbed/mjilg/envs/coref-notebook/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " \"\"\"Entry point for launching an IPython kernel.\n" ] } ], "source": [ - "comment_phab_df['resolved_text'] = comment_phab_df['text'].apply(resolving_comment)" + "only_in_comment_phab_df['resolved_text'] = only_in_comment_phab_df['text'].apply(resolving_comment)\n", + "only_in_comment_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref_rel_phab_stragglers.csv\", index=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "2b583feb-1c62-4c96-9ba0-2996d72e70d3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "7423 [Backport was merged into 1.24wmf16 upon a tim...\n", + "7902 I guess this can be closed now as RESOLVED WOR...\n", + "7905 The upstream issue is https://github.com/jcgre...\n", + "7906 An update on this. In Amsterdam we found at th...\n", + "7907 Yes. It's used by people using pywikibot-as-a-...\n", + " ... \n", + "14465 I amended the title to the range IE8-10 becaus...\n", + "14466 If I remember correctly this problem was at le...\n", + "14467 If I remember correctly this problem was at le...\n", + "14468 After a quick test, autocomplete seems to work...\n", + "14478 Still not merged, so we can't really do much.\n", + "Name: resolved_text, Length: 862, dtype: object" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "comment_phab_df['resolved_text'][46088]" + "only_in_comment_phab_df['resolved_text']" ] }, { @@ -362,7 +751,7 @@ "metadata": {}, "outputs": [], "source": [ - "comment_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/041525_coref_rel_phab_comments.csv\", index=False)" + "only_in_comment_phab_df.to_csv(\"/mmfs1/gscratch/comdata/users/mjilg/mw-repo-lifecycles/case3/050825_coref_rel_phab_stragglers.csv\", index=False)" ] } ], @@ -382,7 +771,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.12" + "version": "3.11.11" } }, "nbformat": 4,