diff --git a/beamsim-local-aggregation-only.ipynb b/beamsim-local-aggregation-only.ipynb index 7a37e0b..e54e92e 100644 --- a/beamsim-local-aggregation-only.ipynb +++ b/beamsim-local-aggregation-only.ipynb @@ -2,33 +2,19 @@ "cells": [ { "cell_type": "code", - "execution_count": null, - "id": "3ec545b7", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import pandas as pd\n", - "import numpy as np\n", - "import beamsim\n", - "\n", - "# Set seaborn style for beautiful plots\n", - "sns.set_style(\"whitegrid\")\n", - "sns.set_palette(\"husl\")\n", - "plt.rcParams[\"figure.figsize\"] = (12, 8)\n", - "plt.rcParams[\"font.size\"] = 11" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 135, "id": "2622e07d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", @@ -62,6 +48,7 @@ " 'global_aggregator_count': 102,\n", " 'mesh_n': 8,\n", " 'non_mesh_n': 4,\n", + " 'idontwant': True,\n", " 'signature_time': '20ms',\n", " 'signature_size': 3072,\n", " 'snark_size': 131072,\n", @@ -133,6 +120,7 @@ "gossip:\n", " mesh_n: {config['mesh_n']}\n", " non_mesh_n: {config['non_mesh_n']}\n", + " idontwant: {str(config['idontwant']).lower()}\n", "\n", "# Cryptographic Constants\n", "consts:\n", @@ -188,15 +176,35 @@ " # Get simulation info\n", " _, _, validator_count, snark1_threshold, _ = beamsim.filter_report(items, \"info\")[0]\n", " \n", + " # Extract signature duplicate information\n", + " try:\n", + " signature_duplicates, avg_duplicates = beamsim.get_signature_duplicates(items)\n", + " except:\n", + " signature_duplicates = 0\n", + " avg_duplicates = 0.0\n", + " \n", + " # Determine topology display name - handle idontwant variants for gossip\n", + " base_topology_display = beamsim.topology_name[topology]\n", + " if \" (idontwant=\" in param_display and topology == \"gossip\":\n", + " # Extract idontwant status from param_display and create enhanced topology display\n", + " if \"(idontwant=True)\" in param_display:\n", + " topology_display = f\"{base_topology_display} (idontwant=True)\"\n", + " else:\n", + " topology_display = f\"{base_topology_display} (idontwant=False)\"\n", + " else:\n", + " topology_display = base_topology_display\n", + " \n", " return {\n", " 'topology': topology,\n", - " 'topology_display': beamsim.topology_name[topology],\n", + " 'topology_display': topology_display,\n", " 'parameter_name': parameter_name,\n", " 'parameter_value': param_value,\n", " 'parameter_display': param_display,\n", " 'snark1_completion_time': snark1_completion_time,\n", " 'validator_count': validator_count,\n", " 'snark1_threshold': snark1_threshold,\n", + " 'signature_duplicates': signature_duplicates,\n", + " 'avg_signature_duplicates': avg_duplicates,\n", " 'success': True\n", " }\n", " else:\n", @@ -291,13 +299,36 @@ " \n", " # Prepare all simulation parameters\n", " simulation_params = []\n", + " \n", + " # Check if idontwant flag is set in config_overrides\n", + " idontwant_flag = config_overrides.get('idontwant', None)\n", + " \n", " for topology in topologies:\n", " for param_value in parameter_values:\n", " param_display = f\"{param_value} {display_unit}\".strip() if param_value is not None else \"Default/Unlimited\"\n", - " simulation_params.append((\n", - " topology, param_value, parameter_name, param_display,\n", - " config_overrides, run_kwargs, display_name, display_unit\n", - " ))\n", + " \n", + " # Handle idontwant flag specially for gossip topology\n", + " if topology == \"gossip\" and idontwant_flag is True:\n", + " # Run gossip with both idontwant=True and idontwant=False\n", + " for idontwant_value in [True, False]:\n", + " # Create separate config overrides for each idontwant value\n", + " gossip_config = config_overrides.copy()\n", + " gossip_config['idontwant'] = idontwant_value\n", + " \n", + " # Create display name that includes idontwant status\n", + " idontwant_suffix = \" (idontwant=True)\" if idontwant_value else \" (idontwant=False)\"\n", + " gossip_param_display = param_display + idontwant_suffix\n", + " \n", + " simulation_params.append((\n", + " topology, param_value, parameter_name, gossip_param_display,\n", + " gossip_config, run_kwargs, display_name, display_unit\n", + " ))\n", + " else:\n", + " # For grid topology or when idontwant flag is not True, run once with original config\n", + " simulation_params.append((\n", + " topology, param_value, parameter_name, param_display,\n", + " config_overrides, run_kwargs, display_name, display_unit\n", + " ))\n", " \n", " results = []\n", " \n", @@ -359,7 +390,7 @@ "\n", "\n", "def plot_parameter_analysis(results_df, parameter_name, display_name=None, display_unit=\"\", \n", - " title_suffix=\"\", figure_size=(14, 8), include_theoretical=True,\n", + " title_suffix=\"\", figure_size=(14, 12), include_theoretical=True,\n", " **base_config):\n", " \"\"\"\n", " Plot the results of a parameter analysis.\n", @@ -378,23 +409,29 @@ " if display_name is None:\n", " display_name = parameter_name.replace('_', ' ').title()\n", " \n", - " # Create the plot\n", - " plt.figure(figsize=figure_size)\n", + " # Create subplots - one for SNARK1 time, one for signature duplicates\n", + " fig, (ax1, ax2) = plt.subplots(2, 1, figsize=figure_size)\n", " \n", - " # Plot lines for each topology\n", - " topologies = results_df['topology'].unique()\n", - " colors = sns.color_palette(\"husl\", len(topologies))\n", + " # Plot lines for each topology display (handles idontwant variations)\n", + " topology_displays = results_df['topology_display'].unique()\n", + " colors = sns.color_palette(\"husl\", len(topology_displays))\n", " \n", " # Get parameter order from the dataframe (preserves original input order)\n", - " if 'parameter_order' in results_df.columns:\n", + " # Remove idontwant suffixes for parameter ordering\n", + " results_df_clean = results_df.copy()\n", + " results_df_clean['parameter_display_clean'] = results_df_clean['parameter_display'].str.replace(r' \\(idontwant=(?:True|False)\\)', '', regex=True)\n", + " \n", + " if 'parameter_order' in results_df_clean.columns:\n", " # Use the preserved order\n", - " ordered_params = results_df.sort_values('parameter_order')['parameter_display'].unique()\n", + " ordered_params = results_df_clean.sort_values('parameter_order')['parameter_display_clean'].unique()\n", " else:\n", " # Fallback to original behavior\n", - " ordered_params = results_df['parameter_display'].unique()\n", + " ordered_params = results_df_clean['parameter_display_clean'].unique()\n", " \n", - " for i, topology in enumerate(topologies):\n", - " topo_data = results_df[results_df['topology'] == topology].copy()\n", + " # Plot 1: SNARK1 Aggregation Time\n", + " plt.sca(ax1) # Set current axis\n", + " for i, topology_display in enumerate(topology_displays):\n", + " topo_data = results_df[results_df['topology_display'] == topology_display].copy()\n", " \n", " # Sort by parameter order to maintain input sequence\n", " if 'parameter_order' in topo_data.columns:\n", @@ -409,14 +446,14 @@ " x_values = list(range(len(topo_data)))\n", " y_values = topo_data['snark1_completion_time'].tolist()\n", " \n", - " plt.plot(\n", + " ax1.plot(\n", " x_values,\n", " y_values,\n", " marker='o',\n", " linewidth=3,\n", " markersize=8,\n", " color=colors[i],\n", - " label=f'{topo_data.iloc[0][\"topology_display\"]} Topology',\n", + " label=topology_display,\n", " alpha=0.8\n", " )\n", " \n", @@ -478,7 +515,7 @@ " \n", " # Plot theoretical minimum line\n", " x_values = list(range(len(theoretical_times)))\n", - " plt.plot(\n", + " ax1.plot(\n", " x_values,\n", " theoretical_times,\n", " linestyle='--',\n", @@ -488,37 +525,101 @@ " alpha=0.8\n", " )\n", " \n", - " # Set axis labels and title\n", - " plt.xlabel(f'{display_name} {display_unit}'.strip(), fontweight='bold', fontsize=12)\n", - " plt.ylabel('SNARK1 Aggregation Time (ms)', fontweight='bold', fontsize=12)\n", + " # Set axis labels and title for first plot\n", + " ax1.set_xlabel(f'{display_name} {display_unit}'.strip(), fontweight='bold', fontsize=12)\n", + " ax1.set_ylabel('SNARK1 Aggregation Time (ms)', fontweight='bold', fontsize=12)\n", " \n", " title = f'Effect of {display_name} on SNARK1 Aggregation Time'\n", " if title_suffix:\n", " title += f'\\n{title_suffix}'\n", " title += '\\n(Local Aggregation Only Mode)'\n", - " plt.title(title, fontweight='bold', fontsize=14)\n", + " ax1.set_title(title, fontweight='bold', fontsize=14)\n", " \n", " # Set x-axis tick labels using preserved parameter order\n", - " plt.xticks(range(len(ordered_params)), ordered_params, rotation=45)\n", + " ax1.set_xticks(range(len(ordered_params)))\n", + " ax1.set_xticklabels(ordered_params, rotation=45)\n", " \n", - " plt.legend(frameon=True, fancybox=True, shadow=True, fontsize=11)\n", - " plt.grid(True, alpha=0.3)\n", + " ax1.legend(frameon=True, fancybox=True, shadow=True, fontsize=11)\n", + " ax1.grid(True, alpha=0.3)\n", " \n", - " # Add performance annotations\n", + " # Add performance annotations for first plot\n", " if len(results_df) > 0:\n", " min_time = results_df['snark1_completion_time'].min()\n", " max_time = results_df['snark1_completion_time'].max()\n", " time_diff = max_time - min_time\n", " improvement = (time_diff / max_time) * 100\n", " \n", - " plt.text(0.02, 0.98, \n", + " ax1.text(0.02, 0.98, \n", " f'Max time difference: {time_diff:.1f}ms\\n'\n", " f'Performance improvement: {improvement:.1f}%',\n", - " transform=plt.gca().transAxes,\n", + " transform=ax1.transAxes,\n", " verticalalignment='top',\n", " bbox=dict(boxstyle='round', facecolor='lightgreen', alpha=0.8),\n", " fontsize=10)\n", " \n", + " # Plot 2: Average Signature Duplicates per Validator\n", + " plt.sca(ax2) # Set current axis\n", + " if 'avg_signature_duplicates' in results_df.columns:\n", + " for i, topology_display in enumerate(topology_displays):\n", + " topo_data = results_df[results_df['topology_display'] == topology_display].copy()\n", + " \n", + " # Sort by parameter order to maintain input sequence\n", + " if 'parameter_order' in topo_data.columns:\n", + " topo_data = topo_data.sort_values('parameter_order')\n", + " else:\n", + " try:\n", + " topo_data = topo_data.sort_values('parameter_value')\n", + " except:\n", + " pass\n", + " \n", + " x_values = list(range(len(topo_data)))\n", + " y_values = topo_data['avg_signature_duplicates'].tolist()\n", + " \n", + " ax2.plot(\n", + " x_values,\n", + " y_values,\n", + " marker='s', # Square markers to differentiate from time plot\n", + " linewidth=3,\n", + " markersize=8,\n", + " color=colors[i],\n", + " label=topology_display,\n", + " alpha=0.8\n", + " )\n", + " \n", + " # Set axis labels and title for second plot\n", + " ax2.set_xlabel(f'{display_name} {display_unit}'.strip(), fontweight='bold', fontsize=12)\n", + " ax2.set_ylabel('Average Signature Duplicates per Validator', fontweight='bold', fontsize=12)\n", + " ax2.set_title(f'Effect of {display_name} on Average Signature Duplicates per Validator', fontweight='bold', fontsize=14)\n", + " \n", + " # Set x-axis tick labels\n", + " ax2.set_xticks(range(len(ordered_params)))\n", + " ax2.set_xticklabels(ordered_params, rotation=45)\n", + " \n", + " ax2.legend(frameon=True, fancybox=True, shadow=True, fontsize=11)\n", + " ax2.grid(True, alpha=0.3)\n", + " \n", + " # Add duplicate message statistics\n", + " if len(results_df) > 0:\n", + " min_dups = results_df['avg_signature_duplicates'].min()\n", + " max_dups = results_df['avg_signature_duplicates'].max()\n", + " avg_dups = results_df['avg_signature_duplicates'].mean()\n", + " \n", + " ax2.text(0.02, 0.98, \n", + " f'Min avg duplicates: {min_dups:.3f}\\n'\n", + " f'Max avg duplicates: {max_dups:.3f}\\n'\n", + " f'Overall avg: {avg_dups:.3f}',\n", + " transform=ax2.transAxes,\n", + " verticalalignment='top',\n", + " bbox=dict(boxstyle='round', facecolor='lightcoral', alpha=0.8),\n", + " fontsize=10)\n", + " else:\n", + " # If no duplicate data is available, show a message\n", + " ax2.text(0.5, 0.5, 'Average signature duplicate data not available',\n", + " transform=ax2.transAxes, ha='center', va='center',\n", + " fontsize=14, style='italic')\n", + " ax2.set_xlim(0, 1)\n", + " ax2.set_ylim(0, 1)\n", + " \n", " plt.tight_layout()\n", " plt.show()\n", " \n", @@ -534,21 +635,33 @@ " print(f\" Time difference: {max(theoretical_times) - min(theoretical_times):.1f} ms\")\n", " \n", " # Show theoretical minimum for each parameter value\n", - " sample_data = results_df.sort_values('parameter_order' if 'parameter_order' in results_df.columns else 'parameter_value')\n", - " unique_param_displays = sample_data['parameter_display'].unique()\n", + " sample_data = results_df_clean.sort_values('parameter_order' if 'parameter_order' in results_df_clean.columns else 'parameter_value')\n", + " unique_param_displays = sample_data['parameter_display_clean'].unique()\n", " for i, param_display in enumerate(unique_param_displays):\n", " print(f\" {param_display:>12}: {theoretical_times[i]:.1f} ms\")\n", " \n", - " for topology in topologies:\n", - " topo_data = results_df[results_df['topology'] == topology]\n", + " for topology_display in topology_displays:\n", + " topo_data = results_df[results_df['topology_display'] == topology_display]\n", " if len(topo_data) > 0:\n", - " print(f\"\\n{topo_data.iloc[0]['topology_display']} Topology:\")\n", + " print(f\"\\n{topology_display}:\")\n", " print(f\" SNARK1 time range: {topo_data['snark1_completion_time'].min():.1f} - {topo_data['snark1_completion_time'].max():.1f} ms\")\n", " print(f\" Time difference: {topo_data['snark1_completion_time'].max() - topo_data['snark1_completion_time'].min():.1f} ms\")\n", " \n", + " # Add signature duplicate statistics if available\n", + " if 'avg_signature_duplicates' in topo_data.columns:\n", + " print(f\" Avg duplicates per validator range: {topo_data['avg_signature_duplicates'].min():.3f} - {topo_data['avg_signature_duplicates'].max():.3f}\")\n", + " print(f\" Overall avg duplicates per validator: {topo_data['avg_signature_duplicates'].mean():.3f}\")\n", + " if 'signature_duplicates' in topo_data.columns:\n", + " print(f\" Total signature duplicates range: {topo_data['signature_duplicates'].min():.0f} - {topo_data['signature_duplicates'].max():.0f} messages\")\n", + " \n", " # Show performance for each parameter value\n", " for _, row in topo_data.iterrows():\n", - " print(f\" {row['parameter_display']:>12}: {row['snark1_completion_time']:.1f} ms\")\n", + " dup_info = \"\"\n", + " if 'avg_signature_duplicates' in row:\n", + " dup_info = f\" (avg dups: {row['avg_signature_duplicates']:.3f})\"\n", + " # Clean up parameter display for output (remove idontwant suffix)\n", + " clean_param_display = row['parameter_display'].replace(' (idontwant=True)', '').replace(' (idontwant=False)', '')\n", + " print(f\" {clean_param_display:>12}: {row['snark1_completion_time']:.1f} ms{dup_info}\")\n", "\n", "\n", "def analyze_parameter_effect(parameter_name, parameter_values, topologies=[\"gossip\", \"grid\"], \n", @@ -590,42 +703,7 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "cfe08729", - "metadata": {}, - "outputs": [], - "source": [ - "def analyze_signature_size_effect(signature_sizes, topologies=[\"gossip\", \"grid\"], \n", - " parallel=True, max_workers=None, **base_config):\n", - " \"\"\"\n", - " Analyze how signature size affects SNARK1 aggregation time using the refactored framework.\n", - " \n", - " Args:\n", - " signature_sizes: List of signature sizes to test (in bytes)\n", - " topologies: List of network topologies to test\n", - " parallel: Whether to run simulations in parallel (default: True)\n", - " max_workers: Maximum number of parallel workers (default: cpu_count())\n", - " **base_config: Base configuration parameters\n", - " \n", - " Returns:\n", - " DataFrame with results\n", - " \"\"\"\n", - " return analyze_parameter_effect(\n", - " parameter_name='signature_size',\n", - " parameter_values=signature_sizes,\n", - " topologies=topologies,\n", - " display_name='Signature Size',\n", - " display_unit='bytes',\n", - " title_suffix='',\n", - " parallel=parallel,\n", - " max_workers=max_workers,\n", - " **base_config\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 136, "id": "dee17544", "metadata": {}, "outputs": [], @@ -670,18 +748,19 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "78ef22b2", + "execution_count": 137, + "id": "9911dec7", "metadata": {}, "outputs": [], "source": [ - "def analyze_mesh_n_effect(mesh_n_values, topologies=[\"gossip\"], parallel=True, max_workers=None, **base_config):\n", + "def analyze_signature_size_effect(signature_sizes, topologies=[\"gossip\", \"grid\"], \n", + " parallel=True, max_workers=None, **base_config):\n", " \"\"\"\n", - " Analyze how mesh_n (gossip mesh size) affects SNARK1 aggregation time.\n", + " Analyze how signature size affects SNARK1 aggregation time and signature duplicates.\n", " \n", " Args:\n", - " mesh_n_values: List of mesh_n values to test\n", - " topologies: List of network topologies to test (typically just \"gossip\")\n", + " signature_sizes: List of signature sizes to test (in bytes)\n", + " topologies: List of network topologies to test\n", " parallel: Whether to run simulations in parallel (default: True)\n", " max_workers: Maximum number of parallel workers (default: cpu_count())\n", " **base_config: Base configuration parameters\n", @@ -690,24 +769,24 @@ " DataFrame with results\n", " \"\"\"\n", " return analyze_parameter_effect(\n", - " parameter_name='mesh_n',\n", - " parameter_values=mesh_n_values,\n", + " parameter_name='signature_size',\n", + " parameter_values=signature_sizes,\n", " topologies=topologies,\n", - " display_name='Mesh N',\n", - " display_unit='peers',\n", - " title_suffix='Gossip Network Configuration',\n", + " display_name='Signature Size',\n", + " display_unit='bytes',\n", + " title_suffix='Network Performance and Efficiency Analysis',\n", " parallel=parallel,\n", " max_workers=max_workers,\n", " **base_config\n", " )\n", "\n", "\n", - "def analyze_non_mesh_n_effect(non_mesh_n_values, topologies=[\"gossip\"], parallel=True, max_workers=None, **base_config):\n", + "def analyze_mesh_n_effect(mesh_n_values, topologies=[\"gossip\"], parallel=True, max_workers=None, **base_config):\n", " \"\"\"\n", - " Analyze how non_mesh_n (gossip non-mesh connections) affects SNARK1 aggregation time.\n", + " Analyze how mesh_n (gossip mesh size) affects SNARK1 aggregation time and signature duplicates.\n", " \n", " Args:\n", - " non_mesh_n_values: List of non_mesh_n values to test\n", + " mesh_n_values: List of mesh_n values to test\n", " topologies: List of network topologies to test (typically just \"gossip\")\n", " parallel: Whether to run simulations in parallel (default: True)\n", " max_workers: Maximum number of parallel workers (default: cpu_count())\n", @@ -717,12 +796,12 @@ " DataFrame with results\n", " \"\"\"\n", " return analyze_parameter_effect(\n", - " parameter_name='non_mesh_n',\n", - " parameter_values=non_mesh_n_values,\n", + " parameter_name='mesh_n',\n", + " parameter_values=mesh_n_values,\n", " topologies=topologies,\n", - " display_name='Non-Mesh N',\n", + " display_name='Mesh N',\n", " display_unit='peers',\n", - " title_suffix='Gossip Network Configuration',\n", + " title_suffix='Gossip Network Configuration Analysis',\n", " parallel=parallel,\n", " max_workers=max_workers,\n", " **base_config\n", @@ -732,7 +811,7 @@ "def analyze_group_validator_count_effect(validator_counts, topologies=[\"gossip\", \"grid\"], \n", " parallel=True, max_workers=None, **base_config):\n", " \"\"\"\n", - " Analyze how group_validator_count affects SNARK1 aggregation time.\n", + " Analyze how group_validator_count affects SNARK1 aggregation time and signature duplicates.\n", " \n", " Args:\n", " validator_counts: List of validator counts per group to test\n", @@ -760,7 +839,7 @@ "def analyze_local_aggregator_count_effect(aggregator_counts, topologies=[\"gossip\", \"grid\"], \n", " parallel=True, max_workers=None, **base_config):\n", " \"\"\"\n", - " Analyze how group_local_aggregator_count affects SNARK1 aggregation time.\n", + " Analyze how group_local_aggregator_count affects SNARK1 aggregation time and signature duplicates.\n", " \n", " Args:\n", " aggregator_counts: List of local aggregator counts per group to test\n", @@ -782,43 +861,109 @@ " parallel=parallel,\n", " max_workers=max_workers,\n", " **base_config\n", - " )\n", - "\n", - "\n", - "def analyze_aggregation_rate_effect(aggregation_rates, topologies=[\"gossip\", \"grid\"], \n", - " parallel=True, max_workers=None, **base_config):\n", - " \"\"\"\n", - " Analyze how aggregation_rate_per_sec affects SNARK1 aggregation time.\n", - " \n", - " Args:\n", - " aggregation_rates: List of aggregation rates to test (signatures per second)\n", - " topologies: List of network topologies to test\n", - " parallel: Whether to run simulations in parallel (default: True)\n", - " max_workers: Maximum number of parallel workers (default: cpu_count())\n", - " **base_config: Base configuration parameters\n", - " \n", - " Returns:\n", - " DataFrame with results\n", - " \"\"\"\n", - " return analyze_parameter_effect(\n", - " parameter_name='aggregation_rate_per_sec',\n", - " parameter_values=aggregation_rates,\n", - " topologies=topologies,\n", - " display_name='Aggregation Rate',\n", - " display_unit='sig/sec',\n", - " title_suffix='Processing Speed Analysis',\n", - " parallel=parallel,\n", - " max_workers=max_workers,\n", - " **base_config\n", " )" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 138, "id": "308510c4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing the effect of signature size on SNARK1 aggregation time...\n", + "Using the refactored analysis framework for cleaner code.\n", + "\n", + "Testing Signature Size: [96, 1024, 2048, 3072, 4096]\n", + "Topologies: ['gossip', 'grid']\n", + "Running simulations in parallel with 5 workers (ThreadPoolExecutor)...\n", + "\n", + " [1/15] Gossip - 96 bytes (idontwant=False): 1291.0 ms\n", + " [2/15] Gossip - 2048 bytes (idontwant=True): 2349.0 ms\n", + " [3/15] Gossip - 2048 bytes (idontwant=False): 2326.0 ms\n", + " [4/15] Gossip - 1024 bytes (idontwant=True): 2043.0 ms\n", + " [5/15] Gossip - 96 bytes (idontwant=True): 1371.0 ms\n", + " [6/15] Gossip - 1024 bytes (idontwant=False): 2006.0 ms\n", + " [7/15] Gossip - 3072 bytes (idontwant=True): 3070.0 ms\n", + " [8/15] Gossip - 3072 bytes (idontwant=False): 2980.0 ms\n", + " [9/15] Gossip - 4096 bytes (idontwant=True): 3601.0 ms\n", + " [10/15] Gossip - 4096 bytes (idontwant=False): 3639.0 ms\n", + " [11/15] Grid - 2048 bytes: 1794.0 ms\n", + " [12/15] Grid - 96 bytes: 1277.0 ms\n", + " [13/15] Grid - 1024 bytes: 1422.0 ms\n", + " [14/15] Grid - 3072 bytes: 2313.0 ms\n", + " [15/15] Grid - 4096 bytes: 2547.0 ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "SIGNATURE SIZE EFFECT SUMMARY\n", + "============================================================\n", + "\n", + "Theoretical Minimum:\n", + " SNARK1 time range: 935.1 - 1497.6 ms\n", + " Time difference: 562.5 ms\n", + " 96 bytes: 935.1 ms\n", + " 1024 bytes: 1065.6 ms\n", + " 2048 bytes: 1209.6 ms\n", + " 3072 bytes: 1353.6 ms\n", + " 4096 bytes: 1497.6 ms\n", + "\n", + "Gossip (idontwant=False):\n", + " SNARK1 time range: 1291.0 - 3639.0 ms\n", + " Time difference: 2348.0 ms\n", + " Avg duplicates per validator range: 1.069 - 3.326\n", + " Overall avg duplicates per validator: 1.741\n", + " Total signature duplicates range: 991 - 3060 messages\n", + " 96 bytes: 1291.0 ms (avg dups: 3.326)\n", + " 1024 bytes: 2006.0 ms (avg dups: 1.561)\n", + " 2048 bytes: 2326.0 ms (avg dups: 1.480)\n", + " 3072 bytes: 2980.0 ms (avg dups: 1.270)\n", + " 4096 bytes: 3639.0 ms (avg dups: 1.069)\n", + "\n", + "Gossip (idontwant=True):\n", + " SNARK1 time range: 1371.0 - 3601.0 ms\n", + " Time difference: 2230.0 ms\n", + " Avg duplicates per validator range: 1.018 - 2.747\n", + " Overall avg duplicates per validator: 1.568\n", + " Total signature duplicates range: 937 - 2527 messages\n", + " 96 bytes: 1371.0 ms (avg dups: 2.747)\n", + " 1024 bytes: 2043.0 ms (avg dups: 1.575)\n", + " 2048 bytes: 2349.0 ms (avg dups: 1.089)\n", + " 3072 bytes: 3070.0 ms (avg dups: 1.018)\n", + " 4096 bytes: 3601.0 ms (avg dups: 1.410)\n", + "\n", + "Grid:\n", + " SNARK1 time range: 1277.0 - 2547.0 ms\n", + " Time difference: 1270.0 ms\n", + " Avg duplicates per validator range: 0.463 - 0.746\n", + " Overall avg duplicates per validator: 0.540\n", + " Total signature duplicates range: 426 - 686 messages\n", + " 96 bytes: 1277.0 ms (avg dups: 0.746)\n", + " 1024 bytes: 1422.0 ms (avg dups: 0.543)\n", + " 2048 bytes: 1794.0 ms (avg dups: 0.472)\n", + " 3072 bytes: 2313.0 ms (avg dups: 0.475)\n", + " 4096 bytes: 2547.0 ms (avg dups: 0.463)\n" + ] + } + ], "source": [ "topologies = [\"gossip\", \"grid\"]\n", "\n", @@ -847,53 +992,459 @@ "print(\"Using the refactored analysis framework for cleaner code.\\n\")\n", "\n", "# Run the signature size effect analysis using the new framework\n", - "results_df = analyze_signature_size_effect(signature_sizes, topologies, max_workers=5, **base_config)" + "results_df = analyze_signature_size_effect(signature_sizes, topologies, max_workers=5, idontwant=True, **base_config)" ] }, { "cell_type": "code", "execution_count": null, - "id": "54c17057", + "id": "80eb93d3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Analyzing the effect of max incoming bandwidth on SNARK1 aggregation time...\n", + "Testing Max Incoming Bandwidth: ['5Mbps', '25Mbps', '50Mbps', '100Mbps', '200Mbps']\n", + "Topologies: ['gossip', 'grid']\n", + "Running simulations in parallel with 5 workers (ThreadPoolExecutor)...\n", + "\n", + " [1/15] Gossip - 5Mbps (idontwant=False): 11678.0 ms\n", + " [2/15] Gossip - 25Mbps (idontwant=True): 4722.0 ms\n", + " [3/15] Gossip - 25Mbps (idontwant=False): 4605.0 ms\n", + " [4/15] Gossip - 5Mbps (idontwant=True): 12496.0 ms\n", + " [5/15] Gossip - 50Mbps (idontwant=False): 2980.0 ms\n", + " [6/15] Gossip - 50Mbps (idontwant=True): 3070.0 ms\n", + " [7/15] Gossip - 100Mbps (idontwant=True): 2441.0 ms\n", + " [8/15] Gossip - 200Mbps (idontwant=False): 2306.0 ms\n", + " [9/15] Gossip - 200Mbps (idontwant=True): 2336.0 ms\n", + " [10/15] Grid - 25Mbps: 2838.0 ms\n", + " [11/15] Grid - 100Mbps: 1830.0 ms\n", + " [12/15] Grid - 5Mbps: 9055.0 ms\n", + " [13/15] Grid - 50Mbps: 2313.0 ms\n", + " [14/15] Gossip - 100Mbps (idontwant=False): 2404.0 ms\n", + " [15/15] Grid - 200Mbps: 1394.0 ms\n", + " [8/15] Gossip - 200Mbps (idontwant=False): 2306.0 ms\n", + " [9/15] Gossip - 200Mbps (idontwant=True): 2336.0 ms\n", + " [10/15] Grid - 25Mbps: 2838.0 ms\n", + " [11/15] Grid - 100Mbps: 1830.0 ms\n", + " [12/15] Grid - 5Mbps: 9055.0 ms\n", + " [13/15] Grid - 50Mbps: 2313.0 ms\n", + " [14/15] Gossip - 100Mbps (idontwant=False): 2404.0 ms\n", + " [15/15] Grid - 200Mbps: 1394.0 ms\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABWsAAASjCAYAAAAIHGiEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdYFNfXwPEvS++IoGCPqNhQsffeYu8djb0n9hKNsSX23mPsGsVewa7YxYJd7KhYUSnSYXffP3h3wko3GjW/88nDk92ZO3fuzM4ucvbMuQZarVaLEEIIIYQQQgghhBBCiC9K9aUHIIQQQgghhBBCCCGEEEKCtUIIIYQQQgghhBBCCPFVkGCtEEIIIYQQQgghhBBCfAUkWCuEEEIIIYQQQgghhBBfAQnWCiGEEEIIIYQQQgghxFdAgrVCCCGEEEIIIYQQQgjxFZBgrRBCCCGEEEIIIYQQQnwFJFgrhBBCCCGEEEIIIYQQXwEJ1gohhBBCCCGEEEIIIcRXQIK1QgghvimjRo3C1dU1zZ9+/frpbXfw4EGaNGmCm5sbZcqUYdCgQQCEhoYyatQoypUrh5ubG7Vr1+bcuXOf9Rg0Gg3379//LH2/ePGC/v37U6pUKYoVK0aDBg148OBBsm0XLFigd87q1auXpM3OnTuTnNsvITAwUNn/mDFjvsgY/g01a9bE1dWVOnXqfNFxnD9/Ptn3VcGCBSlevDi1atVi3LhxvHnz5ouOU6dw4cK4urri4eHxSfpL/N64ePFimu0XL16stD9//rzeuuTe74k/x16+fPlJxvxvOn/+PD/++CNVqlShaNGiuLu707RpU+bMmUNYWFiStrpjbdWqFRqNJkl/uus+tddv9uzZSj8NGjRIsd327dtT/L1QrFgxqlevzsCBA7l161aK41y8eHGSfg8fPqxcZ66urvz555/J7n/evHm4urpSuHDhFMeYkvfv31O8eHFlH15eXhnu43/R3bt39Z4nvgZ27dr1hUYFHh4e6fr3iu5z42sZtxBCiC9PgrVCCCH+8549e8bgwYO5c+cOsbGxhIWFERUVBcCMGTPYsWMHISEhxMbG8vTpUywtLT/bWE6fPk2LFi1S/EP/n/r55585fPgw4eHhxMTE8ODBAzJlypSubQMCAnj+/LnesrNnz36OYYpvlFarJTo6msDAQDw9PWnXrl2S4Jz42+d+v38Ja9asoXPnzhw4cIDXr18TFxdHZGQk/v7+LF26lObNmxMUFJTsttevX2fz5s0Z3qdarWbHjh3K8wcPHqQriP6hmJgYXrx4wcGDB2nXrh3Xrl1L13YXLlxgyJAhqNVqAAYOHEiPHj2StLt48SKrVq3K8Lh09uzZQ3R0tPL8Y87V/5JHjx4xYMAA+vTp86WHIoQQQnxSRl96AEIIIcTH2rp1K46OjsmuMzU1VR5fv36d+Ph4AFq2bEnv3r0xNDQE4MqVK0r79evXY2JigouLy2cZ76tXr+jWrRsABQsW/Cz70B2Po6MjK1euRK1WY29vn+7tz5w5Q6tWrZTnnzvLWOjz9PRErVYr1+fXoHv37nTu3BlICJqFhYWxdOlS9u/fz9OnT1m3bh39+/f/wqP8tLp27Urr1q0BMvT+SezfeL//24KCgpg5cyYALi4uDB06lHz58hEaGsry5cs5ePAggYGBzJ07l99++y3ZPubMmUO9evXS/SUSwIkTJ3j9+rXess2bN1O6dOlUtxs7dqySpa7VaomMjGTNmjV4enoSExPD3LlzWblyZap9+Pv707dvX2JiYgDo0aMHAwYMSNJux44dTJw4Ufki8GNs3bpV7/m5c+d48uQJuXLl+ug+/8t69+7N48ePyZ49u97y77//nooVKwJga2v7JYYGJGRZx8bGKs+nTJnC/v37gaT/frG3t6dYsWJfxbiFEEJ8eRKsFUII8c1ydHTEyckpzXaJ/3guW7YsuXPnVp5HRkYCkCVLFooVK/bpB5mIVqv9rP3D38fj4uJCgQIF0r1d9uzZefbsGWfPnlWCtQ8fPlRu0c6RIweBgYGffsBCT0pfPnxJVlZWeu+z7NmzM27cOCXocP369S81tM/GysoKKyurf9THv/F+/7f5+fkpwaeOHTtSq1YtZd2sWbOoXLkyoaGhqWbkh4SEMGvWLCZPnpzu/eqCmIaGhjg7OxMYGMj+/fsZM2ZMqkEtGxubJL8jxo0bx969e4mIiODq1aup7vfp06f06NGD9+/fA9CpUyeGDx+u1yYoKIgBAwYoX5QZGBh81Gvv7+/PzZs3AciTJw8BAQFotVo2b97MsGHDMtzf/4KUzrO5uTnm5ub/8miS+vCLnsRjSunfL1/DuIUQQnx5UgZBCCHEf1rNmjUZNWqU8nzkyJG4uroqteGePXsGJPxR/mHNxKtXr9KrVy9Kly5NsWLFaNasGRs2bEi25uK1a9cYMGAAFSpUUGrfjh8/nlevXgEJ9RCrVaumtN+xYweurq4sWLAgzWM4e/Ysffr0oWLFihQtWpTatWvz+++/69UL1dXY1Dl37hyurq56x56acuXKKfvS/QGsC7iYmppSvHjxZLd7/vw5v/zyCzVr1qRYsWKULFmSRo0asXDhQiUT7f79+0odxuLFi/PkyRMgIbBcp04dpb7j5cuX0zXWxHQ1AVu0aMGrV68YPnw45cqVo3jx4nTp0iXZQGJar1ViN27cYOjQoUptzmrVqjFmzBiePn2q1y5xrcG7d+8ye/ZsqlatSvHixfHw8ODu3btEREQwZcoUKlWqRIkSJWjfvj1+fn56/SRXszZx3/7+/qxevZp69epRtGhR6tWrx+rVq5OMOzAwkCFDhlC2bFnc3d3p2bMnDx8+VM7XP63tamBgoDz+MCCRnmviY4/r0aNHDBw4kDJlyuDu7s6AAQOS/RJBd5xNmzbVW964cWOldmnisfz000+4urpSrlw54uPjU6xZq9VqWbt2Ld9//70yzg0bNiTZf0be74mvi+LFi9O+fXt8fX2TtEvJ/v37+eGHH5S62w0aNGDevHmEh4frtUt8TMHBwcydO5caNWrg5uZG48aN2bNnT5r7MjExUR4vX74cb29v5TyamJhw5MgRzp49y/bt25PdXnfdbN26Nd0lCN68ecPx48cBqFChAm3btgUSShp8TF1PAwMDVKqEP4FSC4y9ffuW7t27KyUdWrZsydixY5Md35UrVzA0NOTHH3+kVKlSGR4T6GfVTpgwARsbGyDh2omLi0t2m4MHD9KyZUuKFStGlSpVmD17No8ePVJe5w9fB09PTxo3boybmxu1atVi5cqVnD17Nkm95cT1e7dv307Pnj0pWrQoFStW5N69e0BC5viYMWOoXLmy8ntp2rRpSmA7MX9/f3r37k3JkiUpVaoUQ4YM4fXr18rn3Ye/p3bu3Em7du0oV66cst8+ffooAXEAV1dX5XfJs2fP9D7XUqv9GhQUxO+//07dunVxc3OjXLly9OnTJ9n3nK6PadOmcfXqVbp06YK7uzvlypVjxIgRn7xmd0rj1i2bM2cOx44do2XLlsrvro0bNwLg5eWl1OWvVasWy5cvTxLMzshrJoQQ4suSzFohhBDfrJTqIgJkzpwZY2Pjj+77yJEj/PTTT3p/JN++fZuJEydy9epVpk+friw/dOgQgwcP1mv79OlTNm7cyIkTJ5Q/pj7GH3/8wezZs/X+6Hr69Clr1qzBy8uLNWvWfJKyDWXLlmX79u28ffuWO3fuULBgQaUEQokSJfSCNDrv37/Hw8NDL1gWExPDvXv3uHfvHs+fP+f3338nX758jBo1ivHjxxMdHc2YMWNYu3Yt06dPV/7Y7t+/PyVLlvzo8YeEhNC2bVtevHihLDt37hzdunXj6NGjWFtbA+l7rbJmzQrArl27GDNmjF7bly9fsnXrVvbv38+yZcuSvQ176NChehPe+Pr60q1bN5ycnPSCx5cvX6Z79+7s37+fLFmypOs4J02apBc8DAgIYMqUKdjZ2dGsWTMgIXDRunVr3r17p7Q7ceIE169fV87Dx1Kr1bx580a5Fd7AwIAWLVoo69N7TXzMcQUEBNCmTRu9GrmHDh3iypUrSb5AqVOnDr6+vvj7+/Pq1SuyZs3KmzdvlNclJiaGy5cvU6FCBeLj4zl9+jSQECw3Mkr5n8eTJk3SC84GBAQwceLEdL9+yenfvz+PHj1Snuuui0OHDqV558D48eOTfL48ePCAxYsXs3//ftatW4eDg0OS7QYMGKB3vu/evcuwYcPImjUrZcuWTXF/5cqVw9HRkaCgIF68eMGgQYMwMzOjZMmSVKhQgXr16undufCh5s2bs337drRaLePHj2fr1q1K4DQlO3fuVMrYNGzYkAoVKiifiZs3b1ZKdKQlPj6ekJAQFi1apASndF9SfSgiIoIePXrw+PFjAJydnZk0aZLelxQ6RkZGNGrUiJ49e+p9bmZEbGysEizPnj075cuXp27dumzdupU3b95w5MgR6tevr7fNhg0bmDhxovL89evXLFu2LMX9T58+nRUrVijPAwMDmTZtWopfxOlMmTJFec8ZGRnh4uLC06dPad++vd7v4KdPn7Jy5UpOnjzJpk2blMz069ev4+HhoXeHy759+7h+/bpyJ0hia9euTVJC4+3btxw7dowzZ86we/du8uTJk+qYU3L37l26dOmi99kYGxvLsWPHOH78OKNGjeKHH35Ist2lS5dYt26d8rsgMjKSXbt28fLlS9auXftRY/kYR44cYdmyZcq/B54+fcr48eM5ceIER48eVdoFBgYyc+ZMLCws6Nixo9I2va+ZEEKIL08ya4UQQnyzWrVqRbVq1ZL90c2+7unpyejRo5Vtxo4di4+PD3Xq1MHHx0cJhmTPnh0fHx/mzZtHVFQUY8eOJS4ujjx58rBy5Uq8vb3p168fkBDE0/1hFBERobS1tbVl9uzZ7N+/nxEjRgAJgbMlS5bg7u6ulzlVv359fHx86Nq1a4rHd+XKFebMmYNWqyVnzpwsWbKEffv2MXjwYIyMjAgKCuLHH39ErVbTtWtXfHx8lG1LlSqFj4+P3rGnpnjx4kqd3zNnzqDRaJRMo5QCGocPH1aCo+PHj+fw4cNs2LCBbNmyAej98di+fXtq164NJAQvR40apQSZypQp848niHn27Bl2dnZs2LCBLVu2KFnGYWFhHD58GEj/a6V7PG7cOOLi4rC3t2fmzJl4eXnx66+/YmFhQXh4OAMHDkySvQgJmaXz589n165dSiAkKCiIu3fvMm3aNLy8vKhRo4YyppMnT6b7OK9du8akSZPw8vLSu3a2bdumPJ49e7YSjGjWrBm7du1i9erVODg4KMHxjNDNbq/LgK5atSq7d+/GxMSEyZMn6wWsM3JNZPS4Zs6cqQSNWrRowa5du1ixYgXm5uZJMsgSZyafOHECSLiuE9MFtS5duqQE7+rWrZviefD391cCtQ4ODixYsIB9+/bRo0ePJPVUM/J+j4+PZ+XKlezatUu5LmJjY9PMGvXy8lLeQ0WKFGH16tXs3r1bCTY9fPiQkSNHJrvtvXv3mDdvHnv27KFRo0bK8sSTeCXH3Nyc+fPnY2dnpyyLjo7mzJkzzJo1i3r16jF06NBk3xeQ8F5v0qQJADdv3mTTpk2p7g/+vgZMTU2pW7cuzs7OlClTRjmO1DLyR4wYoVy7RYoUoVKlSvz1118A5MyZM8XyAmvWrOHWrVvK8xcvXqT4euTPn59Zs2b9o7rEBw8eJCQkBEB5PXTnCZJONBYaGsqMGTMAsLCwYPLkyXh5eTF27Fi9ces8fPhQqc1rb2/PvHnz2LdvHwMHDkyzFER4eDjTpk1j3759TJkyBZVKxaRJkwgKCsLMzIxp06Zx4MABJTh47949Fi5cqGz/22+/KYHaHj16sHfvXhYtWkRsbCzBwcF6+9JoNMp7rESJEuzYsYMDBw7Qs2dPIOFLFt0XKz4+PkqtWicnJ+X3d0q0Wi1Dhgzh3bt3GBkZMWjQIPbt28eSJUvImTMnWq2WqVOnJns9Xb16lbp167J7926WLl2KhYUFkJCBrLs7599w7949OnbsiJeXFwMHDlSWHz16lGbNmuHl5cWECROU5d7e3srjjLxmQgghvjwJ1gohhPhPc3R0VG4nhb9rGFpbW+Pk5KRM5GRoaIiTkxP29vacPn1aCXZ16tQJFxcXLCwsaNu2rZI1tnPnTiAhAKT7I7tHjx40bNiQ7777ju7duzN69GhmzJiBh4cHJiYmevVIzc3NcXJySjWTJXHJhXnz5lGzZk3y5ctHnz59aNeuHZBQYuDs2bNJ6oqamJjg5OSU7klKTExMKFGiBJAwg/2tW7eU40opWNu8eXP8/Pzw8vKiffv25MyZk0yZMinjCA0N1Ws/efJkJWtVd/5sbW2ZMWPGJ5lQSxc4LFasmF7wV5dJlN7XCmDLli3KrOwTJkygcePGuLi40KFDB+WP5Hfv3rFv374k42jTpg316tWjYMGCerfhN2vWjGbNmuHi4qJMXgUJWWPp1aZNG9q0aYOLiwsjRoxQbuPW3Y6r0Wg4duwYkPAFxG+//UbBggWpUKGCkg37qcTGxrJ161Yl+xAyfk2k97jUajWnTp0CIFeuXEyePJmCBQtSuXJlxo8fn6Q/Z2dnihYtCqB8iaEL1lpaWgIot3zrbrG3tLSkUqVKKR5v4i9Dhg0bRt26dcmXLx/Dhw/H3d1dr21G3u/Dhw+nUqVKFCxYUC8Ao6sXnZL169cDCUHMJUuWUKFCBVxdXRk9erQS9D116pRe1q5Onz59qF+/PgUKFND7Qie1uxV0SpYsyYEDBxgyZAiFCxfWyzbVarXs3bs31RqrI0eOVDK8586dq5fl+KGLFy/y8OFDAKpXr66cv9QCmWnJnz8/w4cPZ+fOnTg7OyfbRpdBWbp0aeX4pk6d+slve9dJHNjXBWvLli2rjO/MmTN6pVfOnDmjBEC7dOlC69atcXFxwcPDQ8mkTOzo0aPKFxpDhgyhfv365MuXjwEDBuh9sZGccuXK0axZM/Lly0elSpUICwtTvmCqXbs25cuXx8zMjDJlyih96T7f3717p5R6KVWqFMOHDyd//vzUrl2bcePGJdmXSqXiwIED+Pj4sGTJEgoXLoyDgwN58+ZV2ug+w1P6/Z2Sc+fOKSUc2rdvT9++fcmXLx81a9Zk7ty5QML1m1xZEzs7O6ZOnYqrqys1atTQu/4+1zWRnMyZM/Pzzz/j4uKiTF4ICTW2J02ahIuLC+3atVN+7+t+t2TkNRNCCPF1kDIIQgghvlmJM2M/pYCAAOXx5MmTk50I58aNG0naFipUSK9NcrdTZoS/vz+QENAsUqSI3rqKFSsqwZo7d+5QuXLlf7QvSAgOnD9/nkuXLimBKTMzM4oVK5ZklnKdoKAgvL298fX15fbt23q3qH94a3qmTJmYOnWqXnbh6NGjUwyYZFTiCdUSzzSvu4U6I6+V7twDyuzcyT2/c+dOknF89913ymNdYBDQqymceLlufOmR+BhVKhW2trZERUUpfbx7946IiAgA3Nzc9G7pL1iwIFZWVilmPaake/fuyq3marWa9+/f4+vry4wZM/Dz86Nr167s379fKZWRkWsiI8elC04VLVpUL7if0m3cdevW5caNG5w5c4bY2FilBnO3bt1YsGAB169fJyIiQrnWa9SokWy5D53EGXQfTkZYokSJJPWH0yvxdZH4i6WU6pTq3L59G0iYTFD3JYhOxYoVlaD9nTt39K5JSPu9khY7Ozt69+5N7969effuHefOnePQoUN4e3uj1Wo5duwYDx48SLZEi4ODA4MGDWLSpEmEhoam+iVC4szqbNmyKVnSid8/3t7e/Pzzz3rnTmfs2LFUq1aNK1euMGnSJMLCwnj27BnZs2dP85bvGjVqMH/+fH799Ve2b99OaGgokyZNSjV782MEBgYqWd6ZM2fm5cuXSqC+YMGCvHjxAq1Wy5YtWxgyZAiAXuD2wy8KSpcunaTec1rtDx06lOL48ufPr/c8ICBAeR/v3buXvXv3JtkmODiYZ8+e6QUydV8GJt5vcjQaDVevXuXYsWNcuXKFx48f631upPQZkhbd+wUSah8nVrRoUezs7AgJCUnxMz3xZ0Pi90xa79NPKVeuXMpnn4WFBSqVCo1GQ548efTGZ2lpSWhoqN7vvvS+ZrpsZSGEEF+WZNYKIYQQH0itZqWO7vbNxLdfZyTolh66P8qSq5OYeL/Jrf8YugzaqKgo1q1bB6RcrxYSJiBr0KABCxYs4M2bN7Rt25aFCxcq5Q6Sowty6xw4cOCTjN3Q0FBvnMnVwczIa5XeTN/kzr2unMSH6xNPZvSxr5mZmZne8w/HmbhOc3IzpX/MfnVZ205OTmTPnp2CBQvSuXNnJWv42bNnSsmMj7km0nNcicf9YbAmpddKlzEWERHBli1bePnyJSqVio4dO5IlSxbi4+PZuXMnDx480Gufkg8zSBNLq+5qahIfe2r7+JDuc+pjPh8S7zMjWe3Lly/nxx9/pEuXLsTGxgIJt9U3aNCAOXPm0KtXL6Wt7rwmp3379soXUNu3b082ozc8PJz9+/crz1etWkXPnj3p2bMngwcPVpZHR0eze/fuZPdjY2NDrly5aNKkCfPmzcPAwIDIyEiGDRuW6iRu5cqVY/78+ZiYmDB06FAlsLt//36lrMqnsm3bNuX1evv2rXKMPXv2VALukHCedJ9biT/r0rpOIO3PhdR8WOc6Pb8fIeELlozuV6vV0qtXL3788Uf27t1LwYIFGTNmzCe5RT/xdZ7aeyat98uHff2bPhyHbqy6sgwfLtfJyGsmhBDi6yDBWiGEEOIDuXLlUh7PmTOHO3fuKD+bN2/m/PnzShZd4olOPgxEjhw5kj59+ih/aGYkEAMoWWkhISFJ6hDqsgQhaZboxypevLjyx6AuGJ1SCQSARYsWERMTg62tLTt37mTYsGHUqVMnxUyjW7duMX/+fODvc3Hs2LF/NAFbRmTktUqcEZj4XIN+7dN/Uqfyc7C1tVUyDG/cuKEXlL558+YnnfU7cQBAl82b0Wsivezt7ZWA2Y0bN/TePynVLM2bN6/yOupe10KFCpEpUyYlO1q33MzMjKpVq6Y6hsSfC9euXdNbl9wYMvp+zyjdsd2/f59Xr17prfscnw+QkKF34MABzp07h5eXV5L1iY85tRIshoaG/Prrr6hUKrRarRL4TczLyyvZCaiS4+npmWabihUrKhn08fHxjBw5MsUs8/LlyysBUQcHB/r376+smzBhwid7H2k0mjTrBOsEBQUpNZ9z5MihLP8wo1tX3iOxnDlzKo+vXLmity6tCdE+DPQlfh+0a9dO7/fjnj178PHx4c6dO7i5uaW63+TGef78eeV2/UGDBjF37lw6deqUJHNcR3e9ZeT3KSStX33jxg2lRMvX9pn+KWTkNRNCCPF1kGCtEEKIb1ZQUJByy+iHPx8GLzKiYsWKSr3JmTNncvz4cR48eMCSJUto06YN5cqVY9q0aQBUqlRJCUqsXr2anTt3EhAQwNq1a9m1axfHjh3j+fPngH42VEBAAA8fPtS7Nf9DrVq1Uh4PGjRIubX4jz/+UCbmKVCgQKoB1YxIXLdWJ7WZ4XUBuvfv37Nv3z4ePXrE0qVL9SbM0gULo6OjGTZsGHFxcRgbG7N06VIlY2vatGlKXcrPKSOvVdOmTZUgxfjx49m3bx8PHjxg06ZNLFiwAEi4Zfn777//7OPOqIYNGwIJGa9jx47lzp07nDp1iqFDh35Uf+Hh4XrvrYCAALZu3arUODQ0NFSum4xcExmhUqmU7NzAwEBGjBjB7du3OXnyZLK1L3V02bK6jDHd7c+6YK1ueZUqVZJkpyXXly6Ddtq0aXh7e3P//n2mTZuWbAmEjL7fM6ply5ZAwqRL/fr149y5c8okdrqMzKpVq+oFav6ptm3bKgGyiRMnsm7dOu7fv8+dO3dYsWIFK1asABJqhX94u/2Hihcvrle7+UOJS6/s2rVLL8B0584d/P39lRrid+/eTRIMTM7gwYOVL22eP3/O7Nmz09wGwMPDQykl8fr1a6ZPn56u7dJy6tQpZUK+OnXqJDnGO3fuKL9r4O+gdKVKlZRb8deuXcu2bdt48OABq1atSnbStnr16ilZrrNnz+bgwYPcv3+f2bNn62XvpoeVlZVSE3n79u14enry6NEjvL29adu2LdWqVaNly5ZotVqsra2VL0EuX77MzJkzuX//PgcOHGDixIlJ+tZ9fkBCLem7d+9y7tw5vbrUiT8/dHcxhISEcPv27WQnV9OpUKGCcov/xo0b+eOPP3jw4AHHjx9XyksYGBjQqVOnDJ2Pb0FGXjMhhBBfB6lZK4QQ4puVOJj5IWtray5evPhR/ZqZmTF69GiGDRvGs2fP6N27t976HDlyKHVXLS0tmThxojID+oezrzs7O/PTTz8BCXUenZ2defHiBVeuXOH777+nQ4cO/Prrr8mOo0KFCvTp04elS5fy+PFjvUmzICEgMnfu3H90C/aHypYtq2Ra6erVpqRu3brcunULjUbDqFGjkm3z5s0bnJycmDZtmnJbdN++falevTqjRo1izJgxREVFMWzYMDw9PfVum/3UMvJaubi4MHbsWCZNmsSbN2+UP+Z1rKysmD9/fpp1L7+Evn37cujQId68ecOOHTuUzL1s2bJhYWGR7mxFncRBuOT06NFDyXzLyDWRUUOGDOHMmTO8fv2a3bt3K7e+Z8qUiWzZsimB9sTq1KnD0qVLlee6IO2HdYjr1q2b5v5z5cpFv379WLhwISEhIQwaNEhZV6RIEW7evKnXPqPv94xq1aoVvr6+7N69mxs3btClSxe99Xnz5mXKlCmfZF86xYoV46effmLu3LlEREQkW8/bxMSE6dOnp1r/V2fIkCEcPHhQyeTXuXfvHlevXgUSzm1y2Y4GBga0adOGGTNmAAmBzA+/bPqQqakpU6ZMoWPHjmg0GjZu3EizZs1S/ZyDhDICP//8Mz179gQSJiBs1KjRP/6iLHFAukWLFsm2adCgAVOmTCEkJIQzZ84QGBhIjhw5GDp0KGPHjiUyMpKff/5Zae/i4qJ81uoC605OTnTv3p2lS5fy7t07vYnskmufluHDh+Pn50dISEiSL0vMzMwYPny40tfQoUO5cOECUVFRLF++nOXLlyv71ZW/0LUtVaoUmTNn5u3bt1y4cIHGjRsn2XfiOrgFCxbk7t27REZGKpOgJTfpIyR8qTR37lx69OhBaGgos2bNYtasWcp6AwMDRo0alWIN7G9dRl4zIYQQX55k1gohhBDJaNiwIWvWrKF69erY2dlhbGxMjhw58PDwYNOmTWTJkkVpW79+fdavX0+NGjWws7PDxMSE3Llz07FjRzw9PZVAloGBARMnTqRIkSKYmppib29P5syZUx3H4MGDWbVqFbVq1SJz5swYGxuTPXt2OnfuzM6dO5OdwOefSBx8cHd3TzXg0qtXL4YMGUKuXLkwNTUle/bsNGvWTCl1AHDkyBF8fHz466+/gITAiy743apVK2VitJs3byozcn9O6X2tIKGupqenJ40aNSJLliwYGxuTNWtWWrZsyc6dO1OcIOdLy5o1Kxs3bqROnTpYWVlhaWlJvXr12LBhg/J6pieQlhIjIyOsrKwoXrw4kyZN0gtkp/ea+Njj2rx5M40aNcLa2hpLS0vq1q2Lp6enkgn/oaJFiyrZdCYmJpQqVQpI+KJDN8mWsbGxknWWloEDB/Lbb7+RL18+jI2NyZMnD7/88osS5E/sY97vGWFgYMCMGTOYO3culSpVUj6nvvvuO/r168eWLVtwcHD4ZPvT6du3L2vWrKFevXpkzZoVY2NjLCwsyJMnD+3atWPv3r1JguEpsbOzY9iwYUmWpyeIqVunu5a9vb3TVZ6gZMmSSmBbo9Ewfvx41Gp1mttVrVpVuU60Wi2//PIL0dHRaW6Xknfv3illDRwcHFIsw2FiYqKcA41Gw5YtWwBo3bo1s2fPpmDBgpiYmJAtWzYGDx6s935M/D4fNGgQv/zyC3ny5FGu3YkTJ9KhQ4dk26fGxcWFrVu30qJFC5ycnDA2NsbR0ZF69erx119/Ub58eaVtwYIF2bBhAxUrVsTCwgJbW1tatWrFn3/+qbTRfUlnZ2fHypUrqVy5MjY2NlhbW+Pm5sb06dOpVKkSkDCxqO71GjhwIJUqVcLKygorKyuyZcuW6riLFSvG3r176dKlizIpl62tLdWrV2fNmjX/eFLQr1lGXjMhhBBfnoFW7ncQQgghhPjPOH36NCYmJjg5OeHs7KyUc9BoNJQoUYKYmBgaNmyY7lvAhRBfl/fv33P+/HmyZs1KtmzZ9L4E2Lt3r1Ly5M8//6RKlSq8evWKmzdv4uzsjLOzM3Z2dkr7ZcuWKZ8F3t7e5M2b95OO9ciRI0qWuZOTk3InyOvXr6lSpQqQ8CXPx5ZpEUIIIf6LpAyCEEIIIcR/yLp165Q6lK1bt6Znz57Exsayfft2YmJiAGQiGSG+YXFxcQwYMACtVotKpWLhwoUUKFCAV69esWrVKiDhtv8iRYoACfXd+/btCySUCFq8eDHOzs48fvyYzZs3A2BjY6PUAP6U5s6dy927dwHo378/zZs3Jzw8XBknyOeREEII8SHJrBVCCCGE+A85deoUPXv2RKPRJLve2dmZXbt2KZOtCSG+PcOHD1fqNienY8eOSm1SrVZLp06dUq3jPmLECLp37/7Jx7llyxbGjh2b4vpChQqxdetW5Q4AIYQQQkiwVgghhBDiP+fcuXOsXr2aGzduEBwcjEqlwsnJiYoVK9KvXz+92rxCiG9PXFwca9aswdvbm0ePHhEVFYW5uTkuLi40a9aM9u3b600+GR4ezvLlyzl69ChPnz4lJiYGKysrChYsSNu2bWnUqNFnG+uBAwfYuHEj/v7+hIWFYWRkRPbs2alRowZ9+/bF2tr6s+1bCCGE+BZJsFYIIYQQQgghhBBCCCG+Aqq0mwghhBBCCCGEEEIIIYT43CRYK4QQQgghhBBCCCGEEF8BqeQuhBBCCPEfEBsby19//aXUsIyIiMDGxobChQvTsmVLGjRooNfew8MDX19fDA0NuXXr1hcaddqePXuGnZ0dlpaWX3ooqTp//jwbNmzAz8+P4OBgjI2NyZUrF9WrV6d79+7Y2Ngobbdv387o0aMBmD59Ok2bNv1Sw04iODiYhQsXcvjwYd6+fYuTkxNNmzald+/emJiYpKuPq1evMmfOHK5evQpAiRIlGDRoEMWLF09z21GjRrFjxw4AfHx8cHJyUtZpNBoGDx7M/v37AciUKRPr168nX758yvX8IWNjYywtLcmbNy8eHh5J3gdCCCGEEF8bCdYKIYQQQnzjoqOj+eGHH/Dz89Nb/u7dO06dOsWpU6c4f/48EyZM+EIjzLjQ0FCWLl3K+vXr8fb2/qqDtWvWrOH333/XWxYXF4e/vz/+/v7s3buXTZs24ejo+IVGmD7v37+nffv2PHr0SFn29OlTFi5cyJ07d1i4cGGafVy7dg0PDw9iYmKUZWfOnOHSpUusX7+eYsWKffT4Jk6cqARqbW1tWbVqFfny5Ut1m7i4OEJCQrh8+TKXL1/mzZs3dO7c+aPHIIQQQgjxuUkZBCGEEEKIb9ymTZuUQG2LFi3YsmULBw8eZNGiRTg7OyttLl68qGwzb948fHx8OHbs2BcZc1pmzJjBypUriY2N/dJDSVVQUBAzZ84EwMXFhcWLF3Pw4EG2bNlC3bp1AQgMDGTu3LnKNt9//z0+Pj74+Pgobb4G69evVwK1I0eOZN++fdSsWROAQ4cOcfz48TT7mD59OjExMdjZ2bF27VrWrFmDjY0NMTExTJ8+/aPHtmDBAjZu3AiApaUly5cvp1ChQknaGRoaKuf2+PHjHDp0iDlz5ijB/rlz5xIZGfnR4xBCCCGE+Nwks1YIIYQQ4ht37tw55fEvv/yChYUFALlz5yYuLo5BgwYBcPbsWUqXLg2Avb39vz7OjNBqtV96COni5+enBJQ7duxIrVq1lHWzZs2icuXKhIaGcvbsWWW5ubk55ubm//pY03L79m0MDAwoUaIE3bp1A+DHH3/k6NGjAFy4cIHq1aunuP2rV6+ULwRatGhBuXLlAGjVqhUrV67k4sWLvHr1iqxZs2ZoXH/99ZeS1Wtubs6yZctSLamQuHQCQK5cufD19WXjxo1ERETw6NEjihQpkqExCCGEEEL8WyRYK4QQQgjxjUtcS3TEiBH069ePwoULA1C3bl0lUGhmZqa0S6lmbWRkJAsXLsTLy4u3b9+SP39+fvzxR65fv64EzO7cuQPo117dtWsX586dY+PGjTx79ozs2bPTvn17fvjhB72xXrp0ieXLl3Pz5k2Cg4OxsLDAxcWFtm3b0qxZM72x6egCoHfu3CEwMFB53qpVK3777TelXXL1Ts+fP6/c9j5lyhS8vb05e/YsNjY2rFmzhvz58/Pq1Svmz5+Pj48PISEhODk5UadOHfr164e1tXW6z/3y5cuxt7enZs2amJqaYmJiwpEjR4iLi0Ol+vuGtuRq1i5YsCDVMgPZs2dXgqYajYb169ezZcsWAgICsLCwwN3dnf79++Pm5qa3XUZqE8+fP5/w8HCCg4OVZeHh4ckea3Ju3LihBNkTB0OLFi0KJATgb968maFgrbe3N5MmTVL2v2jRIsqUKZPu7XUSn/9MmTJleHshhBBCiH+LBGuFEEIIIb5xjRs35sCBA0DC7eqHDh0ia9aslCtXjqpVq1KrVi0l2zY1cXFxdO/encuXLyvLbt68Sd++fdPMRJw0aZJemYWAgACmTJmCnZ2dEoS9du0aXbt21atnGhoaqtQTBZS2n8OUKVMICwsDwMjICBcXF54+fUr79u0JCgpS2j19+pSVK1dy8uRJNm3ahJWVVYp9litXDkdHR4KCgnjx4gWDBg3CzMyMkiVLUqFCBerVq0fu3Ln/8dgNDQ2Vx8OGDWPfvn3K89jYWI4dO8apU6dYvHgxVatW/ej9WFlZYWVlhUaj4eHDh0ybNg1ICJQ2btw41W2fPXumPE4cELWzs1MeP3/+PN1jOXfuHGPHjkWj0QDQrVs3KlWqlO7tAWJiYvD19WX37t0AVKpUiWzZsmWoDyGEEEKIf5PUrBVCCCGE+MbVqVOH3r176y179eoVu3fvZtiwYVSrVo2tW7em2c/27duVoGnRokXZsGEDO3bsoHbt2ly/fj3Vba9du8akSZPw8vKia9euyvJt27Ypjz09PYmJiSFTpkysXLmSw4cPM2fOHCXrUZc5Om/ePBo1aqS3nY+PT5rjT0t4eDjTpk1j3759TJkyBZVKxaRJkwgKCsLMzIxp06Zx4MABZs6ciYWFBffu3UtzUi1zc3Pmz5+vF5CMjo7mzJkzzJo1i3r16jF06FC9DNXkdO3aVam16uPjw7p165Q6qyqVipEjRwIJmaa6QG2LFi3Ys2cPnp6euLu7ExcXx88//6xX5/djaxNv2rSJhg0bcv36dezs7FiwYAF58+ZNdZvEtWBNTU2Vx4kzciMiItI9hrFjxxIXF6c89/T05N27d6luo1arcXV1VX6KFStGjx49eP/+PSVLlmTGjBnp3r8QQgghxJcgwVohhBBCiP+AIUOGsHXrVlq1aoWDg4PeurCwMMaMGaNk36bkyJEjyuPZs2dTunRpChcuzMyZM3F0dEx12zZt2tCmTRtcXFwYMWKEUpP1zZs3SpvffvuNCxcusGXLFipVqoSTkxPOzs5K5mpoaCiQUE83cckGBweHJHVIP0a5cuVo1qwZ+fLlo1KlSoSFhXHy5EkAateuTfny5TEzM6NMmTLUqVMHgJ07d6bZb8mSJTlw4ABDhgyhcOHCGBgYKOu0Wi179+5l2LBhqfZhZWWFk5MTTk5OmJiYMHbsWCWwOXz4cGrXrg3A3r17gYRg6IABA7CxscHJyUkJ1gcFBXH69GmlX3t7e5ycnDJcJzYwMFB5rFarOXnyJFFRUalu86nrDMfFxWFoaEjJkiUBCA4O1it7kVH37t3T+/JACCGEEOJrJGUQhBBCCCH+I9zc3HBzc0Or1XLv3j3OnDnDtm3buHv3LgB//vkn9erVS3H7p0+fAgkBvsS37puamuLm5qZkvianQIECymOVSoWtrS1RUVHEx8frtXv48CH79u3j8uXL3Lt3T68kgu5294+VVrAwf/78es8DAgKUfe7du1cJhCYWHBys1OBNjZ2dHb1796Z37968e/eOc+fOcejQIby9vdFqtRw7dowHDx7g4uKSaj+xsbH069ePx48fA9C2bVtlsi/dmCHh9v6aNWsm28fNmzepUaNGqvtJS5s2bWjdujXnz59nwoQJrF+/nqCgIObPn5/iNolLbSTO7k38GuuyhdNDpVIxdepUqlWrRt26dQkJCWHv3r00adKEatWqJbuNoaGhcp1qtVpiY2N5/vw5ixcvxtfXl1mzZmFra0vbtm3TPQ4hhBBCiH+TZNYKIYQQQnzD3rx5w5gxY+jTp49yy76BgQEFChTghx9+YNu2bUqg8cGDB6n2ZWxsDHxchmTiTFjQr7Gqs3TpUtq2bcvatWuxtLSkX79+rF69OsNZnzofBncTBwWT8+FkYUZG6ctbSO3W++XLl/Pjjz/SpUsXJUBpb29PgwYNmDNnDr169VLapnX+tVoto0ePxs/PD0iorzpu3Di9Nsmd14yMN73y5MnDd999R7t27ZTA6MGDB/VKHXzI2dlZeRwSEqI8TjxhWVpB78QmTJhAkyZNsLW1ZdCgQcryX3/9NdWyEroMZWdnZ3Lnzk2FChWYOXOmsl43CZ0QQgghxNdIMmuFEEIIIb5hNjY2eHl5ERkZyZUrV+jUqZNe/VSVSqUEXxMvT07OnDm5c+cOwcHBBAQEkCdPHgCioqLSrFmblujoaBYtWgRAtWrV+OOPPwCIj49Pto7ph6UEdBLXP/0wYPfixYtUx/BhcDZXrlzK43bt2jFhwgTl+d27d5USA6kJCAhQykt4eXklmSAt8XHY2tqm2te8efOU7N4CBQowb968JGPOnTs3d+7cwdLSEl9fX2X9mzdvePfuHXny5NE7R+ml0WiYNGkSL168oHDhwvz444/KOl3dWK1Wq1dD9kOFCxdWHt+4cYMGDRoAcOvWLSDhXCRuk5bEE6W1bduWTZs24e/vz4sXL5g1axa//vpruvtKfB4zUjdXCCGEEOLfJpm1QgghhBDfMBMTE5o3bw4kZDD26NEDHx8fHj9+zMWLF/nxxx95/vw5QKolEAAaNmyoPB46dCiXL1/m+vXrDB48mKCgoH80zri4OCXz9NatW1y4cAF/f39GjhypBF0Tl0xIPEGVn5+fkm1qZ2enBCNPnz6Nv78/cXFxbNiwgStXrmRoTFZWVkq5gO3bt+Pp6cmjR4/w9vambdu2VKtWjZYtW6aaady2bVslIDtx4kTWrVvH/fv3uXPnDitWrGDFihUAODo64u7unmI/O3fuZMmSJcoxTp48mYiICF6+fKn8qNVqGjduDCQEHEeMGMHt27e5cuUKgwcPpnHjxri7uyvBUUjIsn358iWvXr1K9VyoVCpu377NsWPH+OOPP9i+fTuPHj1i9erVSg3cEiVKKAHn8PBwZVy61zVHjhwULVoUSJhY7sKFC/j6+rJ9+3YAypQp89FZ1CqVirFjxyrPN27cyMWLF5Ntm/icPX/+nKtXrzJ69GhlfWqvgxBCCCHElyaZtUIIIYQQ37ghQ4Zw9epVbty4wfXr1/VuvdcpXLgw/fv3T7Wf+vXr89dff3HhwgVu3LhB+/btgYTyCDlz5lRq2n4Ma2trKlasyJkzZwgKCqJTp05J2iSejKxgwYLK4+HDhwNw9uxZ7O3tqVu3Lnv37iUiIoKmTZtiYGCAVqulePHiXL16NUPjGj58OH5+foSEhCQpOWBmZsbw4cP1smM/VKxYMX766Sfmzp1LREQEkydPTtLGxMSE6dOnp5rxmrgWbEhICG3atEnS5siRI9SpU4dq1arh4+PDvn372Ldvn16bli1b6mWv/vTTT/j6+mJoaKgXxE3OL7/8goeHBxEREXrBTUgIIE+cOFF5vmrVKqXsxoYNGyhdujQAY8eOpUuXLoSEhOi9xmZmZowaNSrV/aelTJkyNGjQAC8vL7RaLWPHjmX37t1651WtVqdYzxYSSlT069fvH41DCCGEEOJzksxaIYQQQohvnJWVFRs3bmT06NG4u7tjbW2NkZERdnZ2uLu7M2rUKDw9PbGyskq1H5VKxbJly+jSpQuOjo6Ympri7u7O6tWrlQDgx9xirzNr1ixatWqFo6Mj5ubm5M2bl379+jFgwAAAnjx5wv379wFo3LgxLVq0UMZRoEABoqOjgYQM1o4dO5I5c2bMzMwoUaIEf/zxB02aNMnwmFxcXNi6dSstWrTAyckJY2NjHB0dqVevHn/99Rfly5dPs4++ffuyZs0a6tWrR9asWTE2NsbCwoI8efLQrl079u7dS8WKFTM8tuQYGBiwcOFCRo4cSaFChTA3N8fKyoqiRYsyadIkvVIOGVWkSBH27NlDmzZtyJkzJ8bGxmTJkoVWrVqxY8cOXF1d0+zD3d2dDRs2ULlyZSwsLLCwsKBChQqsW7eOIkWKfPTYdEaMGIG5uTkAjx49UkprpESlUmFiYoKzszPNmzdn8+bNaZa2EEIIIYT4kgy0HzODhBBCCCGE+M+5ffs27969w8nJiWzZsilBMYDu3btz6tQpHB0dOXXq1BccpRBCCCGEEP9dUgZBCCGEEEIACWUGpk2bBoCbmxuTJ0/G3NycS5cucf78eQClJqkQQgghhBDi05PMWiGEEEIIAUBQUBCNGzcmODg42fXGxsasW7dOJmgSQgghhBDiM5FgrRBCCCGEUDx9+pTFixfj6+vL69ev0Wg0ZMqUCXd3d3r27EmxYsW+9BCFEEIIIYT4z5JgrRBCCCGEEEIIIYQQQnwFVF96AEIIIYQQQgghhBBCCCEkWCuEEEIIIYQQQgghhBBfBQnWCiGEEEKkw549e3B1dWXy5MkABAYG4urqiqurK2PGjPnCo0u/mjVr4urqSp06ddK9jUajoVq1asrxLl++/DOO8L/j7t27es/Pnz+vnMPFixd/oVHpi4uLY8uWLXTv3p1KlSpRtGhRypUrR/v27VmxYgURERH/eB+jRo1Sjvvly5efYNQJdNey7mfZsmVJ2nTu3FmvzahRoz7Z/nUuXryo9L9gwYIMb//777/j6urK7t27P/nYhBBCCPHtkWCtEEIIIUQawsPDmTZtGgAdOnT4wqP59508eVIvyLZlyxZk2oOUvXr1ip9//pmmTZt+6aGk6s2bN7Rr146xY8dy6tQp3rx5Q1xcHCEhIVy+fJnp06fTsGFDbt68+aWHmi6nT5/Wex4TE4Ofn98XGk36dejQAQMDA6ZMmUJISMiXHo4QQgghvjAJ1gohhBBCpGHjxo0EBQVRvnx58ubN+6WH86/btm2b3vPHjx9z7ty5LzSar9+oUaPYtm0bGo1Gb7m7uzs+Pj74+PjQuXPnLzS6BPHx8fTt25cbN24AULZsWZYvX87hw4fx9PRUAogvXrygR48evHjx4ouONz38/PyIjo5Wnl+6dInY2NgvOKL0yZMnDxUqVODdu3esWLHiSw9HCCGEEF+YBGuFEEIIIVIRFxfHunXrAPj++++/8Gj+fe/evePo0aNAQlBJZ/PmzV9oRF+/lLKOTUxMcHJywsnJCSsrq395VPq2bt3KtWvXAKhevTqrV6+matWq5MyZkxIlSvDrr78yfPhwIOEamDNnzpccbqpy5MgBQGxsLBcvXlSWnz17Vm/916x+/foAeHp6EhUV9YVHI4QQQogvSYK1QgghhBCpuHjxIq9evcLAwIBatWr94/7279/PDz/8QLly5XBzc6NBgwbMmzeP8PDwJG3DwsKYMWMG9erVw83NjYoVK9K1a1dOnTqVpO3OnTtp164d5cqVo2jRolSsWJE+ffpw5cqVfzTeXbt2ERcXB8DAgQOVzOJDhw7x7t27ZLfx9fXFw8OD4sWLU65cOcaNG0d4eHiKdT0PHjxIy5YtKVasGFWqVGH27Nk8evRIab99+3ZAv07wn3/+ybBhwyhWrBjlypVTboEPCwtjypQp1KhRg6JFi1K1alXGjRvH69evk4wzMDCQIUOGULZsWdzd3enZsycPHz7Ew8MDV1dXPDw89NofP36cLl26ULFiRaW2a9euXfHx8VHa1KxZUwkSAri6ulKzZk0g9Zq14eHhzJs3j4YNG1K8eHFKly5Nly5dOHToUJJx62q1/vjjjzx8+JC+fftSqlQpSpYsSb9+/QgICEj2dUlsz549yuMRI0ZgaGiYpE3Xrl1xdnYGwMvLSwkiLliwQDmO4OBg5s6dS40aNXBzc6Nx48Z6fSfn3r17yva6gLCOWq2mfPnyuLq60qxZszSPAyBbtmxkz54d0C+FoHsdypYtm+K2sbGxrFixgubNm+Pu7o67uztt27Zl69atyQbdT506Rbt27ShevDgVK1ZkypQpetm8Hzpx4gQeHh5K3+3atWPv3r1J2tWsWRMDAwNCQ0M5cOBAuo5bCCGEEP9NRl96AEIIIYQQXzNdYDRHjhw4Ojr+o77Gjx/Pxo0b9ZY9ePCAxYsXs3//ftatW4eDgwMAwcHBtGvXTi/w9vbtW86cOcPZs2eZNm2aUhN17dq1/Pbbb3r9vn37lmPHjnHmzBl2796tlxWbEVu3bgXAwsKCmjVr8uTJE+bNm0dcXBw7duyge/fueu2PHj3KgAEDUKvVAERHR+Pp6cmdO3eS7X/Dhg1MnDhRef769WuWLVuWZpmFZcuWERYWpjwvVqwYoaGhtGvXjocPHyrLX716haenJ8ePH8fT01MJPj579ozWrVvrBZxPnDjB9evXsba2TrK/w4cPM3DgQL3SBiEhIcrrsW7dOsqUKZPqmFPy+vVrOnTowNOnT5Vl0dHRnDt3jnPnztGlSxd+/vnnJNs9evSINm3a8P79e2XZkSNHuH//Pt7e3skGYCEh81cXxHd2dsbFxSXZdiqVinLlyrFz507i4uK4efMmpUuX1mszYMAAvWzWu3fvMmzYMLJmzZpikDR//vy4ublx/fp1jhw5QkxMDKampkBCoD84OBgg3cFagHLlyrF9+3YlQBsWFsatW7f01n0oMjISDw8PpRSEzpUrV7hy5QonTpxgzpw5ynn08vJi6NChyjUQHR3N6tWr8fLySnZMf/31FxMnTtQL+vr5+eHn58eDBw/46aeflOWOjo5kz56dwMBATp06laFjF0IIIcR/i2TWCiGEEEKk4tKlSwAUKFDgH/Xj5eWlBGqLFCnC6tWr2b17Nz/88AMADx8+ZOTIkUr7OXPmKIFaDw8P9u7dy+rVq8mWLRtarZbff/+dqKgoNBoNGzZsAKBEiRLs2LGDAwcO0LNnTyBhkqUPJ15KLz8/P+7fvw8kZP5ZWFjQuHFjDAwMgKSlENRqNRMnTkStVmNoaMiIESPw8vJi+vTpegFUndDQUGbMmAEkBIMnT56Ml5cXY8eOVQJtKQkLC2PYsGF4e3szZ84crK2tmTt3Lg8fPkSlUjF69Gj279/PkiVLcHR05NWrV/z+++/K9rNnz1YCtc2aNWPXrl2sXr0aBwcHnjx5kmR/69evR6PRkDt3bjZt2sShQ4cYM2YMkBD81JWK8PT0pFSpUsp2Pj4+eHp6pnosY8aMUQK1P/zwA7t372b16tUUKVIEgDVr1rBv374k2929e5eiRYuydetW1q1bR5YsWYCEmsK66zY5ISEhxMfHA+Dk5JTq2HR9AgQFBSVZf+/ePebNm8eePXto1KiRsnzHjh2p9tuyZUsAIiIi9DKTvb29ATAyMqJx48ap9pFYuXLlAPD39+fdu3f4+voqXxikFDSePn26Eqht1KgR27dvZ9OmTVSqVAmAAwcOKDVk4+Li+O2339BoNBgaGjJy5Ei8vLz47bff9ILlOrrrTavVUqxYMf766y/27dtH69atAViyZAn+/v5627i6ugIJAWshhBBC/O+SzFohhBBCiFTobp/PmjXrP+pn/fr1AJiamrJkyRKlv9GjR/P48WOOHTvGqVOnePToEblz51aCVi4uLowZMwYDAwPy58/P77//zoMHDyhQoACGhoaoVCoOHDjAy5cvMTExwd7envDwcL2J0D52hnldVi2gBOJy5syJu7s7ly9fJiAggPPnzyuBsps3byoTUTVs2FDJunVxcSE0NDRJ9u+ZM2eUW+u7dOmiBLJcXFwIDAxk9erVKY4tV65cSkA6b968aLVaJcOxZMmSSg3QwoUL07JlS5YuXcqRI0cICwvDysqKY8eOAZA9e3Z+++03jIwS/lk8c+ZMJWM5sdWrV/P27Vvi4+PJmjUrMTExehmpoaGhQEKGpImJibI8rWDo48ePOXHiBAA1atRg9OjRyrolS5ZQp04dYmJiWLduHQ0bNtTbVqVSMXv2bOzt7YGEoP6sWbMAePPmTYr71AVqIeX6ujqJM4mTa9unTx/lXI8ePVq5xT+5wG5ijRo1YurUqURHR+Pl5UXdunVRq9UcPnwYgCpVqpA5c+ZU+0hMdw1qtVrOnj3L5cuXgYTrNVu2bEnaR0REKAFlV1dXZsyYgUqVkMeycOFC6tatS1BQEOvWraNXr17cuHFDOadNmzalW7duQMK1+vTpU5YuXarX//79+5XyIb1791bKNPTr14+9e/cSFRXFrl27KFiwoLKNLjAeFBSkfOEhhBBCiP89EqwVQgghhEiFLvvyn04Idfv2bSAhuPNh4LdixYpK8PDOnTvY2Ngot/gXLFhQyWQFqFChAhUqVNDbXqPRcPXqVY4dO8aVK1d4/PixXpAt8eP0ioyMVIKfxsbGaLVaJaiYN29eJRi2efNmJVAWGBiobF+iRAm9/j68fR7Qu+3f3d09SfvUgrX58+fXex4cHKwEpS9evEi1atWSbKNWq/H39ydv3rxEREQA4ObmpgRqIeF8W1lZJVtD+Pbt2xw8eBA/Pz8ePXqkBOPg484xoJddWbFiRb11WbNmxcXFhVu3biVbRiJz5sxKoBYgU6ZMyuPEY/uQnZ0dhoaGqNVqnj9/nur4dMF3QCnRkVjijPPE+08cEE6OtbU1derUYc+ePRw/fpzIyEiuXbvG27dvAWjevHmq23/I2dmZHDlyEBgYyJkzZ/Dz8wNSzqp99OiRUmu2QoUKSqAWErK8S5QowaFDh3j9+jXv3r3TO0/FihXT66t48eJJ+k9cvqR///7JjuHD8gu6zxiNRkNwcHCy51sIIYQQ/30SrBVCCCGESIfEwZyPoQsIJg686iTOWDQwMNB7nlbQS6vV0qtXL06ePImxsTG1a9emU6dOZM2alQEDBnz0eL28vIiMjAQSAn99+/ZNtt3BgwcJDg4mU6ZMGBsbZ2gfiTNQ08rw/NCHdWXTm4X47t075XbzlPab3Gs0btw4PD09UalUVKtWjebNm1OsWDE6duyYoXF/KPG407o2PmRubp5iX6kxNjamSJEiXLt2jdevX+Pv76+X4akTFxen1A42MjKiaNGiSdqYmZlleP86LVu2ZM+ePURFRXHs2DGl9q2dnR01atTIUF+QEJgNDAzk8OHDSuA+pWBt4gB9et6Tidt8GJhP7rjTcy50tXnTGp8QQggh/rdIzVohhBBCiFToMhd1mZgfS3fL/P3793n16pXeOt2kSACFChXC3t5eCUbevHlTLzh04MABOnbsyC+//MLjx485f/48J0+eBGDQoEHMnTtXCdb+E4lLIKQmNjaWnTt3Agm3nOvoMht1zp8/n2TbHDlyZKh9Yh8Gs2xtbbGzswMSbqG/c+eO8rN//34OHz7M7du3qV+/Pra2ttjY2AAJ2Y2JA+I3b95MUoP06dOnSt3Zdu3asXTpUrp166ZXaiKxxIG9tILQiUspnDlzRm/dq1evlFq/hQoVSrWfjEo8gdXvv/9ObGxskjaLFy9WMl3r16+PhYXFJx1D+fLllfIAe/fu5dChQ0BCCY3Egfz00mV4Jy77oVv2oRw5cij7OHv2rN57LDIykqtXrwIJZSwyZcqkd21fv35dry9dlnliuXPnVh5v3rxZuRZv3LjB5s2buXTpklIyQkeXTW9oaIitrW2axyuEEEKI/yYJ1gohhBBCpCJXrlwAqd4u/vr1a86cOZPsj+42d92ESjExMfTr149z585x9+5dpk2bppRAqFq1Krly5UKlUil1QAMDAxk/fjx3797F19eXGTNmcPHiRfbt24ejo6NeEPn48ePcvXuXc+fOMX78eGV5Wtm5H3rw4IESPC1cuLBe4FP3o5vUDP6eaMzV1VUpT+Dl5cXKlSt58OAB27ZtY8GCBUn2U6lSJeXW+bVr17Jt2zYePHjAqlWr2LRpU4bGDCgTUp06dYqlS5fy4MEDfHx86Ny5M7Vr16ZGjRrKre+6+q/Pnj1j7Nix3Llzh1OnTjF06NAk/SY+x76+vly/fp2rV68ybNgwZXnic2xqaqo8vnDhAteuXUtxzN99950yIdnRo0eZNm0ad+7c4fz58/Tr14+YmBgAOnXqlOHzkZrWrVvj5uYGJATGPTw8OHbsGE+fPsXPz4/Ro0ezePFiICEQPnjw4E+6f0gIardo0QJIOHZdndvEgeSMKF++vN7zXLly4ezsnGxbKysr5T3m7+/PyJEjuXXrFleuXGHgwIHKWHTnvUiRIsqXC7t27eKPP/7g/v37bNmyJdlyHXXr1lWug/Hjx+u939u0aUOpUqVYt26d3ja6+tguLi7JZvsKIYQQ4n+D3F8jhBBCCJGK0qVLc/bsWe7evZtimxMnTij1XD9Uq1YtFi9eTKtWrfD19WX37t3cuHGDLl266LXLmzcvU6ZMUZ4PGTIEX19fHj9+jKenp5LZqfPLL79gYWFBqVKlyJw5M2/fvuXChQtKwDKx1CabSk7irFpdMO1DpUuXJn/+/Ny7d4+HDx9y4cIFypQpw8iRI+nduzdqtZpp06Yxbdo0ICEA9eDBA+DvzFNzc3OGDh3K2LFjiYyM5Oeff1b6T659Wvr06cPRo0d59uwZc+bMYc6cOco6lUrF0KFDldv2+/bty6FDh3jz5g07duxQJpvKli0bFhYWSgkIgHz58injuX//Pq1atUqy78TnuGDBgkoA3sPDA3Nzc65cuZLiuKdNm0anTp14+fIlK1euZOXKlXrru3TpQoMGDdJ1DtLLxMSEpUuXMmDAAPz8/Lhy5Qp9+vRJ0s7R0ZFFixbpZUF/Si1atGDRokVKZquLi0uSmrDp5eTkRM6cOZVayCmVQNAZO3Ys/v7+3L17l927d7N792699fXq1VMmElOpVEycOJHevXsTFxfHrFmzlMncihQpws2bN/W2zZo1KwMHDmTmzJncunUryfu9SJEiyhc4Orovdj6s3yyEEEKI/y2SWSuEEEIIkQrdZF5Pnz7l2bNnH92PgYEBM2bMYO7cuVSqVAk7OzuMjY357rvv6NevH1u2bNGbUMje3p7NmzfTtWtXcubMibGxMY6OjlSuXJlVq1YpEzDZ2dmxcuVKKleujI2NDdbW1ri5uTF9+nQqVaoEgI+PD2q1Ol3jjIuLY9euXUBCbdNGjRql2LZdu3bKY10wuUqVKvz555+4u7tjamqKg4MD3bp1Y+rUqUrbxLe4t27dmtmzZ1OwYEFMTEzIli0bgwcPZsiQIcm2T42DgwNbtmyhc+fOyjmzt7dXzlmTJk2UtlmzZmXjxo3UqVMHKysrLC0tqVevHhs2bFD2p/u/kZERy5cvp379+tjb22NhYYGrqyujR49WAreXLl0iNDQUgM6dO1OnTh3s7OywsLAgX758SkZvcnLmzMnevXvp168f+fPnx8zMDEtLS8qVK8fChQv1gtifkoODAxs2bGDGjBlUrVqVzJkzY2xsjI2NDSVKlGDIkCF4e3snO4HWp5ItWza9jNiPzarVSVz2IK1gra2tLdu2bWPEiBEUKVIECwsLzM3NKV68OJMnT2bevHl6tWcrVarEmjVrKFu2LKampjg6OtKlSxf+/PPPZPvv2bMnixYtoly5ctjY2GBqakqePHno06cPa9eu1Ssr8e7dO2Uyt+QmxxNCCCHE/w4DbUZncxBCCCGE+B9Tr149AgIC+P3335Nkw4m/qdVqDh06hLOzM05OTnp1c/38/JTg7oQJE2jXrh3v37/n/PnzZM2alWzZspE5c2al/d69e5WSBH/++SdVqlT5pGM9ffo0JiYmODk54ezsrNTA1Wg0lChRgpiYGBo2bMjs2bM/6X5FUt27d+fUqVOoVCqOHTuGk5PTlx7Sv87Ly4vBgwfj6OjI8ePHZYIxIYQQ4n+Y/CtACCGEECIN7dq1Y+rUqRw7dkyCtakwNDTk559/Vmq8TpgwgUqVKhEcHMyiRYuUdrpaqXFxcQwYMACtVotKpWLhwoUUKFCAV69esWrVKqXPIkWKfPKxrlu3TilV0Lp1a3r27ElsbCzbt29X6sTqxik+vVevXmFgYIC3tzenTp0CoGLFiv+TgVqA/fv3Awm1rSVQK4QQQvxvk8xaIYQQQog0REVFUa9ePd6+fcvRo0f1MkaFvrlz57JkyZIU11evXp1ly5Ypz4cPH56kVmhiHTt2ZNy4cZ90jJAwCVnPnj2VWqkfcnZ2ZteuXdja2n7yfQsYNmwYe/bsUZ4bGxuzYcOGz1py4Wv1+vVratasia2tLQcOHMDKyupLD0kIIYQQX5DUrBVCCCGESIO5uTlDhgwhPj6eDRs2fOnhfNV++uknJk2aRMmSJbGxscHQ0BALCwsKFizI4MGDWbBggV7733//neHDh1O0aFEsLS1RqVRYWlpSrFgxxo0bx9ixYz/LOHV1bGvUqIGjoyNGRkaYmJiQK1cu2rVrh6enpwRqPyNXV1csLS2xtLTE3d2dZcuW/U8GagHWr19PXFwcgwcPlkCtEEIIISSzVgghhBBCCCGEEEIIIb4GklkrhBBCCCGEEEIIIYQQXwEJ1gohhBBCCCGEEEIIIcRXQKYa/UQ0Gg3x8fGoVCoMDAy+9HCEEEIIIYQQQgghhBBfAa1Wi0ajwcjICJUq9dxZCdZ+IvHx8Vy/fv1LD0MIIYQQQgghhBBCCPEVcnNzw8TEJNU2Eqz9RHRRcTc3NwwNDb/waD4vrVZLWFgYNjY2kkUshPgqyOeSEOJrI59LQoivjXwuCSG+Nv9Ln0tqtZrr16+nmVULEqz9ZHQXlaGh4f9EsFalUmFoaPiffzMJIb4N8rkkhPjayOeSEOJrI59LQoivzf/i51J6jlMmGBNCCCGEEEIIIYQQQoivgGTWfkPitfFo0HzpYYAWTK1MidPGfemRCPGPGWKIocF/OxteCCGEEEIIIYQQ3wYJ1n4D4rXxhGnCCIwL5L3mPVq0X3pIaDSadNXZEOJrZmhgiIOhA9mMsmFhYPE/c9uFEEIIIYQQQgghvk4SrP0GBKuDOR11miht1JceikKtVv/na/OK/w0BcQFkN8pOGbMymBuYf+nhCCGEEEIIIYQQ4n+YBGu/cnHaOJ7EP/mqArVC/Nc8i39GAU0BzFUSrBVCCCGEEEJ8e+Lj44mNjf3SwxAiQ7RaLTExMURGRn7Td7qamJhgZPTpQqwSrP3KabQaQtWhX3oYCo1aQ+jLUGycbL70UIT4pN6p35HFMAsqAynvIYQQQgghhPg2aLVanjx5wps3b770UIT4n+bg4ECuXLk+SdBZgrVfOS3aZCcVG19mPAADtgzAIY+D3rozG85wcO5BqvWsRo1eNT7peLaO2YpjXkeqdq9KyMsQFrVZRP/N/bFzsvuk+0nLo0uPWNNnDeMvjE8yjoDLAWwft53o99HUGViH+Nh4fP70AeCHpT/gVMDpXx3r5xYbHcvafmsp1bwU7o3d9da9ffqWP7v+Sa+1vciULZPeultHb3Fw3kEG7Rqkt/zU2lOc9zxPdFg02Qpno/Hoxso1Fvw8mANzDvDkyhO0Wi25SuSi/uD6ZMqu37dO4I1AvGd68/rhaywzWVK1W1VKNi356Q7+E9Kg+SrqQQshhBBCCCFEeukCtdmzZ8fKykrmlhHiX6bRaAgPD+fZs2dERESQK1curKys/lGfEqz9hlnYWXBl7xVqD6itt/zKniuYWpp+ln1GBEfgiCMAdk52jDkx5rPsJyM+HMc1r2s4uzrTflZ7AOa3mE/V7lWp2LHilxriZ/P6wWt2TNjBi9svKNW8lN46fx9/9vy+h6hQ/RIa6ng1Z/86y9HFR7HOYq237sreK5z3PI/HfA8y5cjE0cVH8RzpSb9N/TAwMGDTsE1kK5yNQbsHodVq2T9rPxuHbqTfpn5JxhYVFsWGQRuo0asGpVqU4rHfYzYN30SWfFnIUSTHpz8ZQgghhBBCCPE/JD4+XgnUOjn9t5KShPiW6IKzz549Y9OmTdSsWZO8efN+dH8SrP2GudV346r3VWr2q6l8exZ4MxB1nBon178/qKPDozk49yABlwN4H/QeM2szyrQuQ9WuVXn79C3LOi2j9oDalG1dlpiIGJZ2WkqRWkWSBIF3Td7FkytPeHrtKc9vPafBiAbMazqPn3b9RKZsmRhfZjyNRjfizIYzhL0KI2+ZvFTvVR3vmd68vPcSxzyOtPytJZlzZgbg+sHrnFx1ktAXodjntKdW/1rkK58v2WN9/+Y9e37fQ8DlACxsLShat6iyLvh5sDKOQ/MP4X/cH4Dfqv6GoZEh0eHRHFl8hLun7vLDkh947v+cg3MP8vLuSyzsLCjTqgzl25fHwMCAY38c4+m1p0SHRfPu2TvazWiHs6szhxcd5o7PHeLj4vmu9Hd8P/R7rDJbKftuMrYJPit8iA6LJnuR7DQd1xTbrLYAXNt/jZOrThLyIgTbrLZU71WdonWKpnkOrnlfY8+UPSkGxB9eeMi2sduo2q0qkcGReuuOLz/OzUM3qdWvFrsn79Zbt27AOoxMjKjcpTJXva/qrbu08xJlWpUhi0sWAGoPrM2lXZcIuBSAUwEnrDJbUbNPTUzMTQAo164cSzssJSosCnMb/Xqvt47ewtzWnLJtygKQt0xeitUvxoUtF8hRJAc7xu/AxMKEkBchBFwKwCqzFY1/boz/cX+ueV/D0NiQWv1qKZm4x/44ht8uP2KjY7HPbk/V7lUpWK1gsudGCCGEEEIIIf7rdDVq/2kWnxDin9O9D+Pi4vD29qZRo0bkzp37o/qS/PhvWIHKBVDHqXno+1BZ5rfbD/em+rfCH154mODnwfRc05OfT/zM98O+5+jio7x9+pbMOTPTYEQDDi04xLvAd+yZsgdrR2tq9q2ZZH9NxzYlV4lcVOlahXaz2iU7puv7r9NjZQ9+2vkTT64+YeOwjTT5pQnDDwzH0MSQk6tOAnD39F32TtlLg+ENGHlkJNV7VWfzyM28fvA62X63/LwFlaGKofuG0nVZV+6fuZ9suzZT2+BW3w23+m6MOTGGUUdHYetkS6NRjfhhyQ+EBYWxpu8aCtcszPCDw2k3sx0Xtl7g0o5LSh+PLjyi9sDaDN4zmJzFcrJr0i7ePX1Hr3W9+GnnT5hamrJp+Ca02r9vmb976i59NvRh4LaBhL8L58TKEwl9XXrErkm7qPNjHUYfH029wfXYPm47rx++TvMcFPu+WKqZy075nRi0exDl2paDD0qilGxakn6e/fiuzHdJtms+oTmd5nciU46kpQuCHgaR1SWr8tzQyJDMOTPz8u5LzG3M8VjggbXD39m4t47cwi6bXZJAbXJ9ATh+58jLuy+V5367/ajcpTKjj48me5HsrBu4jsy5MjP84HCqdK3Cvun7iI+L59HFR1zacYmea3oy8vBISjYrye7Ju1HHq1M8P0IIIYQQQgjxv0BKHwjx5eneh46OjoSEhPDgwYOP7+tTDUr8+1RGKorVL8aVvVcAiIuO49aRWxRvUFyvXfVe1Wk9pTWmlqaEvQrDyCQhofp90HsASjQsQaHqhVjTbw0PfR/SanIrVIYfd2mUbVsWC1sLrB2syeKShcI1CuOYxxETcxO+K/0dIS9CAPDd7EuZlmXIUzIPKkMVrlVcKVClABe3X0zSZ8iLEJ74PaHOwDqYWppi65SQnfoxrnlfw/E7R8q2KYuhkSFZ8mahYqeK+G72Vdpkyp6JvGXyYmphSlRYFLeO3ErIpLW3wtTClPpD6/P81nNe+L9QtqnUuRLm1uZYZbbCtYorb5+8BeDq3qsUqlGIApUKoFKpyF8xP93/7I5NFpsMnYPkWNhZYGxqnOw6myw2KRa11mX8JicmMgZjc/0+jc2MiY1KOqvohW0XOLP+DI1/bvzRfX1X5jtyl8iNSqUib5m8mJibUK5tOQyNDBO+jIhVE/42HCMTI6LCori04xIv7rygZNOSDD84HEMjwxSPRQghhBBCCCFE+mjj1ahvPSBuz3FiN+8nbs9x1LceoJUEGSEyxMDAAFNTU0JDQz+6DymD8I0r0bgEf3b9k+jwaO6cuEOu4rn0Mh8BIt5FsH/Wfl7ceYFdNjuyFcoGoJcZWrZtWa55X6N4w+LYZLFJdl9atGi0aqLiIngT/ZLI6MgkbSxsLZTHBioDzGzM9J5rNQn71N36fmHbBWW9Rq0hb5mkNT3CXocBYOv0d5AxpQmt0hLyPITnt58zpcaUv49Lq9X7JjLx+dMFl5d3Xa7Xj8pIRfDzYMxtEzJKrTJb6a3THef7N+9xdnXW2zZ7kexK3+k9B/8WEzMT4qLj9JbFRcdhavF3DeT4uHgOzD7AjUM36Di3I9+VTpq9q+sr7H1Yqn0luV6s9a8XAK1GS85iOWk7rS3nPc9zeu1pjM2MKde2HFW6VZFvkYUQQgghhBDiH9A8eErcPh+078JAo0m4c1ML6ku3MLC3wbhhNVQuOT/7OLRaLTt27GDHjh3cu3eP8PBwnJycqFq1Kr179yZr1qxpd/IJBAYGUqtWLdauXUu5cuU+uh+1Wk379u0ZN24cRYsWxdXVlSlTptCiRYtk248aNYpnz56xbt26j97nh+7du8ezZ8+oXr36J+szI54/f46fnx8NGzZM9zajRo1ix44dya6rVasWixcvTrOPT/Ua6ly/fp0JEyawadMmjIzSDqUaGBig0Wg+en8SrP3GOeV3wiGPAzcP3+T6geuUb1c+SZsto7fgWtWVTgs6YWhkSGRIJJd3XlbWx8fFs/f3vbjVc+PWkVsUqVOEApUK6PURFR/J2+jXxGpiidFEExUfQXh8OAAvIwMxi///AFzyyZxJ2GSxoXiD4lT5oYqyLORlSLKZojZZE4LHwc+CcfwuYXIzXQA3o2yy2vBd6e/wWOChLIsMiSQmMubvRomOQRe4HrBlgF4Q9/XD12TKnonwt+Gp7s82qy2hL/W/TTmz/gw53HJk6Bz8W7K4ZCHoYRCuVVyBhMnI3j59q9SwjQiJYOOQjcTHxtNrTa9Ug+ZZXLLw4Lx+2n/QoyClr4wIeRmCpb0lHgs8iI+L56HvQzxHeOJc0JkClQuk3YEQQgghhBBCiCQ0D54St3k/2uhYsDTHINHdi9p4Ndq3ocRt3o9xm/qfNWCrVqvp378/ly9fpk+fPowbNw5LS0vu3bvH4sWLadmyJTt37sTBweGzjUHH2dmZU6dOYWub8l2p6bFixQpy585N0aIJc9acOnUKa2vrNLb6tHr37k3z5s2/WLB25MiRZM+ePUPBWgB3d3cWLFiQZLmpqWkyrT8/Nzc38ubNy/Lly+nbt+9n35+kpP0HuDd259xf53j7+C35K+VPsj46PBojUyNUhioigiPwmukFgDou4XaGwwsOo1FraDquKbX612LnhJ28f/Ne2T4qPpKgyBfEa2IxMjFCHaHGUGWEkUFCUDFeE0dQ5Isk+01NqealOO95nmc3nwHw7NYz/vD4g+sHridpa+dkh0t5Fw7MOUBUWBTv37zn+PLjGdqfTrH6xQi8Hsg172uo49W8f/Oev4b8xYE5B5Jtb+NoQ/7K+dk/az+RIZGo49WcWHmC5V2WE/0+Os39lWhcgtvHb3P/3H00Gg33z97n2B/HMLMyy9A5+Le4N3Hn/ObzvLz7kriYOA4vOIyVvRW5S+ZGHa9m/cD1mFqa0v3P7mlmNxeqUYjwt+Gc/ess6ng1jy4+4tr+a7g3cU91u+Q8v/Wc9T+u5+XdlxgZG2Fln5DJbGFnkcaWQgghhBBCCPG/RavRoo2MTvNHExZB3O5jaKNiwMoCA5UKNFrlx0ClAisLtFExxO0+hiYsIu1+Ndq0B5iMVatWcfLkSVatWkW3bt3Inz8/2bJlo1q1aqxevRpjY2NWrlz5ic9U8gwNDXF0dMTExOSj+3j//j3Lli2je/fuyjJHR0fMzMxS2UroGBsb4+jomOTHxib5O8H/Dd26dWP58uX/qLxBeklm7X+AWz03Ds47SPn25ZOt4dlsXDP2z97P2Q1nMbM2o2jdoji5OvH6/mu0Gi0Xtl6gx6oeGJkYUa5tOfx9/Nk5YSed5ncCA3gb/RoNagwNjMhf14XTc88RdPct1UcnZIQaGhihIWN1bIrUKkJsZCw7J+4k9FUo5jbmlO9QPmGyrGS0nNySfdP2MafJHEwtTXFv5M6zG88yfK7snO3oNL8ThxYewmumFypDFQUqF6D+kPopbtNiQgsOLzzM0o5LiYmIwTGvI50WdMLawZrg58Gp7i9X8Vw0H9+cg/MOEvIiBDsnO1r91oosLlnI4pIl1XNwzfsae6bsSXWSsU/NvYk70e+j2TR8E5EhkWQrnI0OczpgaGTIraO3eOH/AiNTI6bXna63Xf/N/bFzsmNRm0W4fe9G1a5VsbCzwGOhB/tn7efYH8ewtLPk+6Hfp1g2ITWFaxbm7eO3bBy6kciQSCztLak/pD45iub4VIcuhBBCCCGEEN889d0A1Ed90UZGpdlWGxUDwWGgMoCYWFIMs2q1aJ+9JnbBBgzMU89sNLAwx7BmWQwL5En3mLVaLRs2bKBJkyYUKVIkyXpzc3PWr1+Po6OjsuzFixfMmjWLs2fPEhERQalSpRgxYgSurgl3ib59+5YJEyZw/vx5oqKiKFy4MEOGDKFs2bIAXLt2jalTp3L79m2MjIwoX748o0ePJlu2bEluoffw8KBQoUKEhIRw8OBBbGxs6NSpEz179kxxrhhPT0+yZs1KwYIFlWWJyyBotVqWLFnCpk2bCAsLo2HDhsTExOj1kdYxjho1CrVajYODAzt37iQyMpJKlSoxYcIEHB0dqVmzJs+ePWPhwoX4+voSHh5OqVKlGDt2LACHDx+mf//+zJ49W8l8nT59OleuXOGvv/7i3r17zJkzh0uXLhEREYGzszOdOnWiS5cuACxYsABfX1+qVq3KunXrCA4Oxt3dnfHjx5M3b148PDzw9U2YH8jX15ejR48qY09ORkoWxMbGsmDBAry9vXn58iWWlpZUqlSJX375hUyZkiaWpXU9xMbGMm/ePHbv3k14eDj58+fnxx9/pHLlykofBQsWJGvWrHh6etKrV690jfNjGWgTFy4VH02tVnPlyhVKlCiBoeGnm/QoWhPNqahTBKmDPlmfGREZF87rqBcYGhhigAEarRq1VoMBBhiqEpZBQj1btVZNFnNnLIyt0uhViK+Pm6kbhUwKYWggk5Z9i7RaLaGhodja2qb4DyYhhPg3yeeSEOJrI59L/z2RkZHcvn2bQoUKYWGRcNdhzKKNEJN0gujkaEPeQ2QUpCeGoVaDhTkGdum4jd/UBNP+7dM1BoCnT59Su3ZtZs6cSePGyU9gnVh4eDiNGjUiZ86cDB8+HBMTExYtWsS5c+fYtWsX2bJlY+DAgcTExCjrly5dyqFDhzhx4gRmZmZUqlSJNm3a0KpVK8LCwhg3bhzW1tasXr062WCtn58fLVu2pHPnzly7do3x48fTv3//FIN27dq1o1SpUgwfPlxZljhYu2zZMpYtW8bEiRMpXLgwnp6erF69mrJly7Ju3bp0HeOoUaPYu3cvjRs3pkePHjx//pxhw4ZRq1Ytfv/9d969e0fz5s1p0KABvXv3Zt26dXh5eeHt7Q3ApEmT2LBhA61bt2bSpEkANGzYkBYtWtChQwfq1KlD+fLl6du3L0ZGRmzbto1ly5axc+dOChUqxIIFC1i2bBkVK1ZkyJAhREREKGUP1qxZQ0hICH369MHJyYlx48Zhb29PUFDKsS1bW1tMTEzSVbt38uTJHDlyhKlTp5IjRw7u3bvHyJEjadq0KT///HOS1zC168HCwoKhQ4dy7949fv75Z5ycnDh27BizZs1i4cKFeiUkpk2bhp+fH5s2bUoyJt37MSAggICAAPLkyUPLli2V9RmJG0pmrUhVVHwEoMUAA7RoidfGA6AFtBoNRipjDP7/P7RaouIjJFgrhBBCCCGEEEJ87TKau/eZcv3evHkDgL29vd7yPn36cP78eeV5tmzZ2LdvH7t37yY4OJjt27cr28ycOZPatWuzYcMGhg8fzpMnTyhQoAC5cuXC1NSUMWPG0LhxYwwNDXn//j3BwcFkyZKFHDlyYGBgwNy5c3n79m2KY8ybNy/jx4/HwMAAFxcXHjx4wNq1a5PNrtVoNNy4cYP27ZMPWGu1WtatW0fnzp1p1KgRAKNHj9Y71vQcI4CVlRUTJ07E2NgYFxcXmjZtio+Pj3I+DQ0NsbCwwM7Ojho1arBw4UJevHiBs7MzZ86coU6dOsp+AwMDuX//PrVr1yYqKorOnTvToUMHrKwSYjwDBgxg2bJl3Llzh0KFCgEQHx/P9OnTsbOzA8DDw4MZM2YAYGdnh7GxMWZmZsoxJM6OTs3Fixdxd9cvoZglSxYOHEgoYenm5kbdunWVzNjs2bNTuXJl7ty5k2x/qV0Pjx8/Zu/evWzduhU3NzcAunbtir+/PytWrNAL1rq6urJ27Vo0Gs1nnexcgrUiVRrt37PXaT+4KUKLlnhNnBKwxUC/vRBCCCGEEEIIIf49RnUqpLsMAhnNsE5He10ZhIzQ3bYeEhKit3zChAlERyfMFbNu3TqOHj0KwN27d8mTJ49ecNfU1JRixYopwboBAwYwfPhwDh06ROnSpalcuTINGjTA1NQUU1NTevTowaRJk1i4cCEVK1akatWq1KtXL8Uxli1bVi8oW6JECZYvX05wcHCSIHNISAhxcXFJlusEBwcTFBSkBAYT9/ngwYN0HyNA7ty5MTb+e5Jya2tr4uLikt1v0aJFyZo1K6dPn6ZKlSo8efKEmTNn0qJFC168eIGPjw/58uUjd+7cAHTo0AEvLy/8/f15/Pgxt2/fBhKC0ToODg5KoDat/QNJArCJLV++nNKlSytjnTlzpt76xNmoTZs25ezZs8yePZuAgAAePHjAw4cPle0/lNr1cOvWLQA6d+6st01cXFySGrn29vbEx8cTEhKS4uv7KUiwVqRKZfD3NwW6DNrEQVstWuI0sRirjEGr314IIYQQQgghhBD/HsMCeVDlyw3RMWm2Vd8JIH7nETA3wyCZ+W90tPFqiIrGqFktDF3zpN6pmSkGqowFgXPmzImjoyO+vr5K7VSArFmzKo9tbW3/Ho9Wm2wpD7VajZFRQpirTp06nDx5kpMnT3LmzBn+/PNP5s2bx+bNm8mfPz/Dhg2jQ4cO+Pj4cPbsWcaPH6/c4p8cXb+JxwCkejt74qBmcj6sSpp4H+k5RiDDk6BVr16d06dPY2hoSNGiRSlSpAjZs2fn/PnzHD9+nNq1awMJ2c5t2rQhU6ZM1KpViwoVKuDm5ka1atX0+svo/lM6v6D/epuZmSlB4+SMHz8eLy8vmjVrRvXq1enbty8rVqzg1atXybZP7XrQvQ4bNmzA0tJSb7sPs2d1r+nnzKoFCdaKNJgbWfI+Lgzt/5dCMFIZE6+JS5JlG6eJwwAV5kaWKfQk/kviYuKIDInENqtt2o2FEEIIIYQQQvxrDFQGYGGWZjtDt/yoT15E+zYUrY1lssFBrVYLUdEYZLbF0C1/qkHdj2VoaEjnzp1ZtGgR7du315uUS+fFixfK4wIFCrBz507evn1L5syZAYiJieHGjRs0a9aM2NhYZs2aRdOmTWnQoAENGjQgKiqKypUrc/z4cQwNDVmzZg0///wz7du3p3379ly6dIkOHTrg7++fbMbk9evX9Z5fvnyZHDly6AWRdezt7TExMSE4OPkJye3t7XF2dubSpUtKcBTgxo0bSpZsWsf4sWrVqsXIkSMxNDSkfPnyAJQvX57jx49z/vx5Bg4cCMCePXsICQnhwIEDyph0Gb3/ZOqr1AKw6RUcHMzGjRuZM2cODRo0UJY/fPhQqd2cWFrXg67MwevXr/VKHsyZMwcDAwMGDRqkLHv37h0mJiZ62cSfgwRrv1Fzmswh/G04KkMVBgYGaDVaTK1MKVa/GLUH1v7oKP/BeQe5uP0ihsaGDNw2EHNbS4xijInXxGJoYJRiwFar1YKBBtU3ODnTiVUneOL3hE7zO33poXwzVvVcRZnWZXBvnPItDImd23iOc5vOERkaiZ2zHdV7VqdwzcIAxEXHsX/OfvyP+6OOU+Ps6ky9IfVwyu+UbF/P/Z+zf/Z+Xt17hbGpMUVqF6HOj3UwMjEiJjKGLaO38OTKEzLnykyLSS1wzJNQE+fJ1SccXXKUH5b+8EnOgRBCCCGEEEJ8ywyMDDFuWI24zfvRhkWgtTTXC8Zq49UQEYWBmQnGDat9lkCtTo8ePbh16xYdOnSgV69eVK9eHSsrK+7evcv69es5ffq0MllT48aNWbp0KYMGDVImjFq8eDGRkZG0bdsWExMTrl69ysWLF/nll19wcHDAx8eHiIgI3N3dsbOzY+/evURHR9OrVy9UKhXbtm3D1taWvHnzJinHAAk1VOfPn0/jxo25dOkSGzZsYPTo0SkeT7FixVINrPbs2ZNp06aRN29eSpcuza5du7h27RqlSpVK1zGml6WlJQEBAbx58wYHBwfKly9PTEwMBw4c4I8//gCgQoUKjBgxAgcHB6U0g5OTE1FRUXh7e1O6dGkePnzIlClTgITgZ0b2/+zZM16+fImTU/J/42eUtbU11tbWHDlyhCJFihAdHc369eu5efMmxYsXT9I+reshf/781KhRg19//ZVx48ZRoEABDh48yLJly/jtt9/0+rp161ay+/jUJFj7DWs0qpFesOzV/Ves6bcGYzNjavSu8VF9ntt4jla/t1ICaQCZzbIQFPkCtTb+74CtgTHx2oSAbUJ6PhgZGPMm+hWZzbJgbpT024yvVdWuVaHrlx7FtyUiJCLdbe+dvsfJ1SfpuqwrDnkcuHX0FltGb+HHHT+SKVsmji8/ztsnb+m/uT8mFiYcXngYz+Ge/LTzpyR9aTQa/hr8F5W7VOaHpT/wPug9a/uvxcLOgmo9qnF131ViImIY6j2U438c5/gfx2n9e2s0ag37Z+2n2fhmn/AsCCGEEEIIIcS3TeWSE+M29Ynb54P2XRhajQYMSJhVXKXCILMtxg2roXLJ+XnHoVIxd+5cvL292bZtG2vXriUsLAwHBwdKly7N+vXrKVOmDAA2NjasX7+eadOm8cMPPwBQqlQpNm7cSM6cCeOcN28eU6ZMoW/fvrx//568efMya9Yspabpn3/+yaxZs2jTpg1qtZoSJUqwatUqrKyskg3W1qpVi3v37tG0aVOyZMnCqFGjUpxADKB27dps3749xfUdO3ZEo9GwZMkS3rx5Q5UqVWjVqhWPHj1K9zGmh4eHB9OmTePevXvs3r0bU1NTKlasyIkTJyhZsiSQEKzVarXUrFlTya6uX78+N2/eZNq0aYSHh5M9e3Zat27NkSNHuHbtWqrHnli7du0YOXIkTZo04ezZs6mWjUgvIyMj5s2bx9SpU2ncuDG2traUK1eOIUOGsHTpUiIjI5Nsk9b1MGfOHObMmcOvv/5KaGgoOXPmZNKkScoXBDrnzp1LsuxzMND+k/xloVCr1Vy5coUSJUp8kotPJ1oTzamoUwSpg/SWz2kyh+o9qyfJbPQc6Yk6Vk2HOR2Ij4vnxIoTXPO+RnR4NDmK5uD7Yd+TOWdCCv34MuMp27Ys1/dfJ6dbTh5dekRcVBxGpkYUqV2E5uObc/v4bU6sOMHbJ28xz2xGgcb5KdysAAYqA05OP0t8dDwhAaHEhMbQZGEDNnvsoPKQCtzc4s/71+/JWyYv1XtVx3umNy/vvcQxjyMtf2tJ5pyZiY+L5+jio9w9dZew12EYmRpRtE5Rvh/2PQYGBqzqvYqcbjl5cu0JL/xfYJvVluq9qlO0TlEA3gW+Y/+s/Tz2e4yhiSGFaxam/pD6GJkYKeueXn+KibkJxb4vRrWe1TAyTvr9xLE/jhFwKYCuy7rit8cPv91+ZC+SHb89fqhUKqr1qIaRiREnVp4g+n00ResVpfHoxsrr4N7Ynev7rxMWFIZzQWcajWpElrxZeHTpETvG7SCXey7unb5HlR+qUNGjIqfXnubyzstEhkSSOXdmavapSb4K+bi8+zLHlh1j8J7BSmb0ha0X8N3sS//N/YmJiOHwosPc8blDfFw835X+ju+Hfo9VZiuCnwczr+k8mo1vxrGlx4gMiaRI7SK4N3XHa7oX7wLfkaNIDlpNaYWlnSVarZbznue5sOUC4e/CyZovK/WH1CdboWzKcZVuXpqbh2/y9ulbMufMTL3B9fiu9HesHbCWh74PMTQ2pGTTkjQc0ZBFbRbh9r1bQuD7A2c2nOHUmlNKsNbfx59tY7cxcNtAbLPa8teQv4iJiKHttLaYWJhwdMlR7p+9T79N/ZL0FRkSyfQ606k3uB7l2pbj/Zv3rBu4jpJNSlKxU0Uubr/IVa+rdJrXiePLjxP+JpyWk1ty9q+zhL8Np87AOim+19xM3ShkUgjDbzA7XCRk94eGhmJra5vs7VtCCPFvk88lIcTXRj6X/nsiIyO5ffs2hQoVSvb274zQxqvR3A1A8+Ap2qhoDMzNULnkRFUgz2fNqP0WeHh4kD17dqZOnZrubUJDQ6lZsyarV69OMpGY+DZdu3aNrl27cvTo0WTLX+jejwEBAQQEBJAnTx69wG5G4oaSWfsfoY5X8+TqEx5dfESNXglZtUcXH+XhhYd0WdwFKwcrTq89zboB6+i/uT/Gpgk1R4IDgxm8dzDqODXm1uaMLzOejvM68l2p73h08RFbRm+hxcQWFKpRiFf3X7Fx6EZMVaa4tSqCscqEJxcDabW4OUb2hphaJRSWvn/4IQ0X1MNKZcPqjmvZOGwjnRd1xjarLesGruPkqpM0G9eMcxvPce/MPbos6YK1gzVPrz1lVa9VFKxWkLxl8wJwaeclOi/qjGNeR3z+9GHP73twreqKylDF+h/Xk6dUHoZ4DSEuOo71A9dz/I/jVO1elTX91uBW143WU1sTGRzJ5lGb0Wq01B5QO/kTmMiTK08oVKMQIw6N4NL2S3jN9KJo7aL039KfoIdB/NntT9zquZGnZJ6EMe64RIc5HXDI7cD+OfvZOGQjA7YOACDsdRiOeRxpPr458THx+Pzpg98uP9rNakfWfFm5few2G4dtpNsf3Shapyj7Z+/n0YVHuJRzAeDK3iu4N00IyO+atIuYiBh6reuFsZkxB+YcYNPwTXRf0V0Z+73T9+i/pT/BgcEs7bSUF3de0HFuRwxNDFnRbQUXtlyges/qXNhygbMbztJ+dnscv3PkqtdV1vZfy4AtA7DKbAWA3x4/Os7riLWjNfum7mPv1L0M3DqQzgs7J/myoP/m/imeT7d6blzZc4VFbRZhYJgwSV2LiS2UercVO1bEc6Qn0+tMx8DQAAtbixRLFVjYWVC+Q3kOzjvIwfkH0aq1uFZzpXyHhFo7xRoU48G5B8xtOheHPA40H9+c92/e47fbjx6reqT52gshhBBCCCHE/yIDI0MMC7tgWNjlSw/lP8HW1pbu3buzevVqZs2a9aWHIz6B1atX061bt2QDtZ/a552+THxW+6btY0qNKUypMYXpdabjNd2Lih0rUrZNWbRaLRe2XaB2/9pkyp4JY1NjqvWohjpezb3T95Q+3Oq5YWJmgrm1eZL+/fb4UbB6QYrWKYqhkSHZCmajyg9VuL3nDg5mTpgampGzaE4KFClEpkx/F+Au0rwgZjamxFvFkPk7ewrXKIxjHkdMzE34rvR3hLwIAaBUs1IJgeTMVrx/8564mDhMLE0ICwpT+ipcqzDOrs4YGRtRomEJYsJjiAiO4OnVp4Q8D6H+0PqYWphiZW9F2xltKdmsJHdP3UUdp6ZW/1oYmxpj62RLjT418N3qm67zamJhQvn25VGpVLiUd0Gr1lLRoyImZiZkL5wdawdr5RgAKnaqiLOrM8ZmxtQbXI/Ql6E8ufpEWe/exB1DI0NMLU3x2+1H5R8qk61gNgyNDClapyiuVV25vPsyJuYmuNV14+q+qwAEBQTx8u5LijcoTvi7cG4duZWQSWtvhamFKfWH1uf5ree88H+hNxYTMxOy5suKdWZrSjQqgU0WGyztLMnhlkMZt+9WX6p0rYJTficMjQwp2aQkDnkcuOZ9TW/cmXNmxsQsITP57ZO36Tp/H1LHqXEq4ETP1T0Zc3IMjX9uzK7Ju3h1P2GWRo1aQ+GahRmybwijjoyiYPWCbBy2kbiYuCR9aTQajE2NaTC8AWNOjKHfpn4EPQri+LLjCa+dmQltp7dl5OGRdP+zO/Y57Dkw9wA1etcg8EYgy39Yzh+d/+D2sdsfdSxCCCGEEEIIIUR69OzZk8ePH3Pt2rW0G4uv2rVr1wgICKBXr17/yv4ks/Yb1nBkwxQneAp/F05cVBybR2/Wu8VFHacm5HmI8tza0TrF/iPeReBUQL8AdKZsmfQCldaO1hhggL2ZIyqDhNi/qY3p3/szUGNg8XelDQNVwmRoALFRsXjN8OLx5cfYZLHBuaAzaFHWA0qWJ4DKKKF/rUbL+7fvsbCzwMTMRG9sALeO3iIiOIKpNRPdoqBNOPbwd+FY2f/dZ3LMbcyVc2agSvi/mfXfM2kmPgYA+5x/B6pNzEwwtzUn/E04Vg5WyjnSiXgXQabsmfT2lylbJl7efQlAyWYlWd1nNTGRMVzZcwXXqq5YZrIk8GYgAMu7LtfbVmWkIvh5MOa2CcF2C9u/b30xMDTQH7fB3+MOeR7CgbkHOLTgkLJeE68hW+FsyvMk5/4jC6Z4TfciZ/GcZC+SHUgIAl8/cJ0re65Qe2BtNo/eTMe5HbHJYgNAg+ENmFpjKg/PP8S1qqteX/7H/bl19BYDtybMUJnFJQvVe1THe5Y3NfvWTLLvRxcfERMeg2s1V2Z9P4t2M9ph7WjNkvZLyF0yt975EkIIIYQQQgghPrRu3bqP2s7Y2JitW7d+4tGIL6FYsWKp1iD+1CRY+x9lYWeBkakRHgs8yOn2d/HpNwFvsM6SKECbSqkiO2c7gp8F6y179+wd1g7JB3jtTDP/f5/6ncaoYwiOfkMmMwe95Xt+24O5jTlDvYdibGqMRqNhWs1p6Tg6sM1qS2RIJLHRsUrA9rHfY57ffo5NFhvsc9grAT2AmIgYwt+FY5nJMu3OM1i+6X3Q+7/3ExlDZGgktk62qOPVCd0lOh92znYEB35wTgP/PqfZC2cnc87M+B/359r+azQZ0wRACWQO2DJA7/y/fviaTNkzEf42PENjt8lqQ43eNXCr+3ftnHeB75Sg76cU+iqUbHHZ9JapjFQYGhsSGxlLdFg06li1ss5AZYCBygBD46Q1XEJfhqKOU+stUxmpMEymhpI6Xs3BeQdpPSWhFEbEuwicCyVkaRubGxMcGCzBWiGEEEIIIYQQQnxVpAzCf5RKpcK9iTuHFx4m9FUoGo2GK3uvsKjdIt49fZeuPtybuOPv48/NwzfRqDW8uPOC02tOp5jNq2NlbJNkWUTce95Gv9ZbFh0ejZGpESpDFTERMRyad4iYiJgkwbjkZC+Sncy5MnNw7kFio2MJfxvOgTkHiAiOoEDlAsRGxnJ63WniY+OJeh/FjvE72Prz1s9SSP/MhjO8ffqW2OhYDsw+gENuB3K45Ui2bclmJTm15hTP/Z+jUWu4efgmd07coUSjEn+3aVqSo0uPYmBggEv5hHpBNo425K+cn/2z9hMZEok6Xs2JlSdY3mU50e+jMzzmUs1KcWLFCYICEiauu3/2PovaLuLx5cfp2t7IxIiY8Jh0tXWt4orvZt+EY9ZouHnkJgGXAihSpwjmNubkKpGLQwsPJWSDx8RxeMFhLOwsyFUiV5K+XMq78P7Ne06sOoFGreFd4DtOrDxBse+LJWl7dsNZClYriH0OeywyWWBmbcbTa095+/Qt0e+jsXX+/HVmhBBCCCGEEEIIITJCMmv/w+r+VJfjfxxnVa9VRIZGkilbJtpOa4uzq3O6ts9RNAdtprbB508fdk3ahbmtOaVblaZy58poU7kn3tzYgkxmDgRHv9FbHhUXQWRcuPK8wfAG7Pl9D1NrTsXU0pQClQqQr0I+Xj94/WGXSRgaGdJhTgf2z97PnEZzUBmqKFa/GDV618DQyJDOizpzYO4BTq89jUaj4btS39F+Vvt0HXdG5S6Rm03DNhH6KpTc7rnpOK8jKlXy34NU6FABjVrD1p+38v7NezLnzEyr31qRp1QepY3b924cnH+QSh6V9PppMaEFhxceZmnHpcRExOCY15FOCzph7WBN8PPgZPaWsgodKgCwcehGwt+EY+1oTYPhDShYrWC6ti/ZtCRHFh/h2a1ntJzUkkVtFuH2vRtVu1ZN0rZaz2oYGBqweeRmokKjsM9lT7sZ7ZTrsM3UNhycf5Al7ZegUWvIUTQHneZ3wsQ8IWN6z5Q9hL4IpdP8TmTJm4UOsztwdOlRTq89jZmVGcW+L0a1ntX09hn6MpQbB28ok4qpVCqajG3C9nHb0aq1Su1fIYQQQgghhBBCiK+JgVar/chKlJ/e4sWLOXv2rF49kKNHj7Jo0SIePnxIpkyZqFevHj/99BNmZgm1ODUaDQsXLmTLli2EhYVRqlQpfv31V3Lnzq30cfv2bX777Tdu3LiBnZ0dHh4edO/eXVmfnj7SolaruXLlCiVKlMDQMOkt2R8rWhPNqahTBKmDPlmfn4JarU7zOKPiIxKyaT+4wkwNzchsnlWpcfstm9NkDtV7Vk8z21h8/dxM3ShkUghDg0/3/hX/Hq1WS2hoKLa2tp8lg14IITJKPpeEEF8b+Vz674mMjOT27dsUKlQICwsp8SbEl6R7PwYEBBAQEECePHlo2bKlsj4jccOvJlq2evVq5s+fr7fs4sWLDBgwgHr16rFz507Gjx+Pt7c3EyZMUNosXryYTZs2MXnyZDw9PTEwMKBnz57ExsYCEBwcTNeuXcmTJw/btm1j4MCBzJs3j23btqW7D/FxzI0scTB3SvIPgRh1NEFRL9Bo0y53IIQQQgghhBBCCCHE/4ovHqx99eoVPXr0YN68eXz33Xd66zZt2kT58uXp1asXuXPnpmrVqgwePJjdu3cTGxtLbGwsK1euZODAgVSrVo2CBQsyZ84cXr16xaFDCbPcb968GRMTE8aPH4+LiwstW7bkhx9+YPny5QDp6kN8PDND8/8P2OpfanHqWF5HvkCtjf9CIxNCCCGEEEIIIYQQ4uvyxYO1N2/exNbWlt27d1O8eHG9dd26dWPEiBFJtomPjyc8PBx/f38iIiIoX768ss7GxobChQtz4cIFICE7t0yZMhgZ/V2et3z58jx69Ii3b9+mq48vyQADVF/+ZfpHTA3NyGLhjOqD28vjNXG8jnxBvCbuC43snxu8e7CUQPiPUKHCALkdTAghhBBCCPG/J04Tx6VXp1hzcy6Lr0xizc25XHp1irh/8e91rVbL9u3b8fDwoHz58hQtWpTatWszceJEXr169a+NIzAwEFdXV86fP/+P+lGr1bRp04YbN24A4Orqyvbt21NsP2rUKDw8PP7RPj907949jh8//kn7zIjnz5+zb9++dLdfsGABrq6uqf4EBgZ+lrFqNBpatmzJ9evXP0v/GfHFJxirWbMmNWvWTHZd4cKF9Z7HxsayatUqihQpgr29PRcvXgTA2Vl/wqwsWbLw4sULAF6+fEmBAgWSrIeEi+bly5dp9vElqQxUWKuseaX+9z6YPgdjlQlZLJwJinqBWvN3+QO1Jp7XkS9wtHDCWGXyBUco/tdlMsz0n6ijLIQQQgghhBAZcfPtJdbdWkBQ5AvUqDHAAC1aTgR642jhjEfhgRTJXOqzjkGtVtO/f38uX75Mnz59GDduHJaWlty7d4/FixfTsmVLdu7ciYODw2cdByTEh06dOoWtre0/6mfFihXkzp2bokWLAnDq1Cmsra0/xRDTrXfv3jRv3pzq1av/q/vVGTlyJNmzZ6dhw4bpat+tWzfatWunPG/VqhUNGjSgW7duyjJ7e/tPPk5ImJh82LBhjB49mu3bt2Ni8uViVF88WJte8fHxjBgxgvv377NhwwYAoqKiAJKcQFNTU0JDQwGIjo5Odj1ATExMuvrICK1Wy6ecs80II3Ib5+Zp/FNitDGfrN8vwUhljKN5Nt5EvSBe83f5A41WnRCwNXfCxND0C45Q/K9yMnTCVmX7Sd+74t+l++yV11AI8bWQzyUhxNdGPpf+ez7Fa3nz7SUWX5lMVHw41iaZMFYZK+viNHG8jnzG4iuT6Vdi7GcN2K5atYqTJ0+yefNmihQpoizPli0bZcuWpUGDBqxcuTLZu68/NUNDQxwdHf9RH+/fv2fZsmVK/Ar4x33+L7C0tMTS0lJ5bmhoiIWFxb927ipUqICxsTG7du2idevW/7i/xO/RjLxfv4lgbXh4OIMGDeL8+fPMnz9fKZdgZmYGJGTc6h5DQhDW3NxcafPhRGExMQlBTwsLi3T1kRFhYWGoVJ8uO8/AwABrc2sqm1XmadxT3mveo9FqPln/H0ur0n7cDKKG4GzlzPvYkKT1atUGWKtsJcNW/GuMDIxwMHIgh1EODGIMCI3J+Bc04uug1WqJjIwEkNmNhRBfBflcEkJ8beRz6b9HF9v4kEarITIuPM3t4zVxrL45l4i492QyzYyBgYHeROCGBipsTewJjnnLmptz+bnsXIwSBXOTY2FsleE7FrVaLRs2bKBJkyZ6gVodc3Nz1q9frxewe/HiBbNmzeLs2bNERERQqlQpRowYgaurKwBv375lwoQJnD9/nqioKAoXLsyQIUMoW7YsANeuXWPq1Kncvn0bIyMjypcvz+jRo8mWLRuBgYHUqlWLtWvXUq5cOTw8PChUqBAhISEcPHgQGxsbOnXqRM+ePVN8L3l6epI1a1YKFiyoLHN1dWXKlCm0aNECrVbLkiVL2LRpE2FhYTRs2DDJ65nWMY4aNQq1Wo2DgwM7d+4kMjKSSpUqMWHCBBwdHalZsybPnj1j4cKF+Pr6Eh4eTqlSpRg7diwAhw8fpn///syePVvJfJ0+fTpXrlzhr7/+4t69e8yZM4dLly4RERGBs7MznTp1okuXLkBCyQJfX1+qVq3KunXrCA4Oxt3dnfHjx5M3b148PDzw9fUFwNfXl6NHjypjT47ufKfl/PnzdO7cmWHDhvHnn3+SLVs25s2bR506dZL0kficAxw7dowFCxZw//59smbNSsOGDenXr59eAuf333/PihUrPjpYq5tjKzo6Wi8JVKNJfyzvqw/Wvn79mp49exIYGMjy5cv1asvqShe8fv2aXLly6W2je0M4OTnx+vXr/2PvzuOiqtc/gH/OOTMwrAMCiuK+oKgsppjmkmmmUm7ZtTS165ben3nrtlwtb96sm2WrZWKmpd7KLTXL0szS1ExNLcQNcVdEUZFtBgbmLL8/vKDHQWFgwAE+7/vi9crvc873PMM43/vyme95jsOcAFCnTh3IslziHM7w9/eHJEklH+gkE0wIlAKh/e9/d5qqquUqSms+GrLyMyCrBTdFBPh7BHCHLVUKAQIkQbrWF1qC7gsbqloKv6U0m838xwcRuQWuS0TkbrguVT+Fxfcb7b+8G18fXwJLQckbUax2Cy7nXYAkSLApjnMV0jQNJ7OO4sVfx8DH6HvbOX09zBjc/AlEh5RcdCuUkpKC1NRU3HPPPbc8JiwsrOi/LRYLhg0bhgYNGmDevHnw8PDA3LlzMWLECHzzzTeoV68eXnnlFeTn5+OLL76Ah4cHPv74Y/zf//0ftm3bBpPJhAkTJmDo0KGYNWsWsrOzMX36dLz00ktYvHhxsddfunQphgwZgtWrVyMxMRGvvPIKAODJJ58s9viffvoJ99133y1fzyeffIKFCxfi1VdfRevWrbFixQqsWrWqqJhcmtcIABs2bED//v3xxRdfIDU1Fc8//zzef/99zJw5E6tWrcLgwYMRFxeHCRMm4PPPP8f69euLcti5cycEQcCuXbuKirVbt27Fww8/jLy8PIwePRqdOnXC0qVLYTAYsHr1asycORMdO3ZEREQEAODPP/+El5cXPvnkE1itVkyZMgUzZszAkiVLMGfOHEycOBGhoaGYPn06gGutIG7F2bYTv/zyC1asWIG8vLxS1ae2bduGp59+Gi+++CK6dOmCs2fP4rXXXsOpU6fwwQcfFB1333334d1338WpU6fQpEkTp3ICrt257+HhAZPJpHtNiqLc5iw9ty7WZmVl4YknnoDFYsHSpUsdKvCtWrWCr68vdu/eXVRozc7OxuHDhzFixAgAQGxsLJYvXw5FUYqKqDt37kSTJk0QFBQEPz+/EudwhiAIFfZ/fEbh9t9gVRZN05BlySr3/8kLHoH4/PCHOJZxUD8uiBga/iTuqnPrhZqI6GaF6y//8UFE7oLrEhG5G65L1Utx7+NXyQthk29deL2RTbYCKPmuWUEQAE2DTbaWWKy1FGThq+SFThVrr1y5AsCxF+nEiRN1D/mqV68evv/+e3z77bfIyMjAmjVris555513cP/99+PLL7/ECy+8gLNnzyI8PBwNGzaEp6cnpk2bhv79+0OSJOTk5CAjIwO1a9dG/fr1IQgCZs+ejfT09Fvm2LRpU7zyyisQBAHNmjXDiRMn8N///rfY3bWqquLgwYMYNmxYsXNpmobPP/8co0aNwkMPPQQAePHFF3WvtTSvEQB8fX3x6quvwmg0olmzZhg4cCC2bt1a9PssbCMQEBCA++67Dx999BEuXLiAunXr4rfffkPv3r2LrpuSkoLjx4/j/vvvR15eHkaNGoXhw4fD1/fae/7UU09h/vz5OHr0aFGxVpZlvPXWWwgICAAAjBw5Em+//TYAICAgAEajESaTqeg1uLKdwZgxY9C4ceOi3Evy8ccf45FHHil6Xxo2bIgZM2bgiSeeQEpKCurXrw/g2nttNBqxf//+MhVrb3Tj3w1n1l23Lta+8cYbOHfuHBYuXIhatWrh8uXLRbFatWrBw8MDI0aMwDvvvINatWohLCwMb7/9NkJDQ9G7d28AwJAhQ7Bw4UJMmzYN48aNQ2JiIpYsWYIZM2YAQKnmoIrhKZnwRJt/YOmRuThwZc/1gKZg2dF45ClWdKnH94CIiIiIiIjI1RSt9Dv9ynJ8aQUGBgIAMjMzdeMzZsyAzWYDAHz++efYvHkzACA5ORmNGzfWFXc9PT0RFRWFo0ePArhWWHzhhRewadMmdOjQAV27dkVcXBw8PT3h6emJcePG4bXXXsNHH32Ee+65B927d0efPn1umWPHjh11xbaYmBgsWLAAGRkZDkXmzMxM2O32Wz4IKyMjA5cvX0ZkZKRuPCYmBidOnCj1awSARo0awWi8vrHPz88Pdru92Ou2bdsWderUwY4dO9CtWzecPXsW77zzDh5++GFcuHABW7duRfPmzdGoUSMAwPDhw7F+/XokJSXhzJkzOHLkCAD97fzBwcFFhdqSrg8A7dq1u2VswYIF6NChwy3jNyss1JbW4cOHkZiYiK+//rporPCOgxMnThQVayVJgtlsLvoS4U5w22KtqqpYv3497HZ7UT+MG/3888+oX78+/v73v0OWZfzrX/+CzWZDbGwsPv3006J+E0FBQVi4cCFef/11DB48GCEhIfjnP/+JwYMHF81V0hxUcYyiESNaT8aq5E+x5+LWonFN0/D1scWwybno1XDgHcyQiIiIiIiIqGr4S/i4UrdBkATnWjiW5vjCNgjOaNCgAUJCQvD7778X3Y4PXGtdWejG28k1rfjdwIqiwGC4Vubq3bs3tm/fju3bt+O3337DwoUL8cEHH2DlypVo0aIFnn/+eQwfPhxbt27Fzp078corr2D+/PlYu3ZtsTkWzntjDgBu2wazpB6lNz9w6sZrlOY1AnC6btWjRw/s2LEDkiShbdu2aNOmDcLCwrB792788ssvuP/++wFc2+08dOhQBAYGolevXujcuTMiIyNx77336uZz9vq3+v0C+ve7NDw9Hdtn3vg7vblorKoqxo0bp6sHFrp5x++Nd+ffCW5VrH3zzTeL/lsURSQmJpZ4jiRJeOGFF4q2gBcnKioKK1asKNccBGiyAjX5NNTjZ2HIyoFs9oPYvCHE8MYQDGX/SywJEoaGj4fJ4I3tKRt0sQ2nVsIm5yGuyaO8VYeIiIiIiIjoNqJD7kZkcGypHjCWcHkXPj34NvyM/rd9cJhdtcNiz8bYti8gJqTTLY8DyvaAMUmSMGrUKMydOxfDhg0r9vlBFy5cKPrv8PBwrF27Funp6QgKCgJw7WFrBw8exKBBg1BQUIB3330XAwcORFxcHOLi4pCXl4euXbvil19+gSRJWLJkCV566SUMGzYMw4YNw759+zB8+HAkJSUVuyP2wIEDuj//8ccfqF+/frF9VgvvBM/IyCj29daqVQt169bFvn37ioqjAHDw4MGiXbIlvcay6tWrF6ZMmQJJkoqeCdWpUyf88ssv2L17NyZPngwAWLduHTIzM7Fx48ainAp39N5cZHZG4a5dVyvM0WK5/vf+7NmzumNatGiBkydP6nL4/fffsWTJErzyyivw9vYGcK1Qm52d7dKWDc4q+xOiqEZRT5xDQfwy2FduhLL3EKTkM1D2HoJ95UYUxC+DeuJcueYXBAEDmj6OPo0fcYhtObcOq499BlUr/ZPziIiIiIiIiGoiURDh6+Ff4s/dde9DHe8wWOzZECBCFCSHHwEirPZs1PEOw9117ytxTmcLtYXGjRuH++67D8OHD8fHH3+MpKQkpKSkYPPmzRgzZgxWr15dVFzs378//P398cwzzyAxMRFJSUl44YUXkJubi0cffRQeHh7Yv38/Xn75ZSQkJCAlJQVr1qyB1WpFu3btEBAQgO+++w7Tp0/HiRMncOrUKaxevRpmsxlNmzYtNr+9e/fiww8/xKlTp7Bq1Sp8+eWXGDdu3C1fT1RUFA4ePHjL+Pjx4/Hll1/iq6++wqlTpzB79mzdhsWSXmNp+fj44PTp00W39Hfq1An5+fnYuHFj0e+zc+fO2LhxI8xmc1FrhtDQUOTl5WHDhg1ITU3Fr7/+imeffRYAUFBw84Pib3/98+fP4+LFi6U+pyxq166NBg0aYNGiRTh+/DgOHDiAl19+Wbfzd/z48fjxxx8xZ84cnDp1Cjt37sSLL77oUJhNSkqCoiiIjo6u0Jxvh8VaKpF64hzsK3+Alp4FeJsgBPhB8/eBEOAHeJugpWfBvvIHlxRsezcajIHNRznEdl3YjKVJ8VBUuVzXICIiIiIiIqJrbQlHtp4ML4MvMvIvw67qbxu3q3Zk5F+Gl8EXI1tPhvE2u2/LSxRFzJ49G6+//jr27t2LMWPGoG/fvnj11VdRq1YtfPHFF5g5cyYAwN/fH1988QX8/Pzw17/+FcOHD0deXh6WLVuGBg0aAAA++OADNGjQAH/729/Qt29frFixAu+++y46dOiAWrVqYeHChTh//jyGDh2KwYMHIzU1FYsWLSp6mNbNevXqhWPHjmHgwIH4+OOPMXXq1Fs+QAwA7r//ft0Dw272+OOP44UXXsC8efMwcOBAHDt2DI88cn3zWmleY2mMHDkSv/zyC8aMGQPgWuuAe+659jD3u+66C8C1Yq2maejZs2fRHc19+/bF2LFjMWvWLPTr1w8zZ87EI488gtjY2FLdBV/oscceQ3JyMgYMGABFqZiex8C1etLbb7+N/Px8DBo0CM899xyGDx+O0NDQomP69u2L999/Hz///DP69++P559/Hp07d8ZHH32km2vXrl0IDw936vfsaoJWnv3LVERRFCQkJCAmJuaO9rVwNU1WUBC/7Fqh1t+n6IN7Y/8OTdOAbCuEIDM8/m9YuVoiFNpzcRtWJi+AdtNu2oigGIyKeBpGif2Eieg6TdOQlZUFs9nMlilE5Ba4LhGRu+G6VP3k5ubiyJEjiIiIKLqFuywOpe/D54fn4HLeBSiqAkEQoGkaJFFCiFddjGw9GW2C2rsw86pl5MiRCAsL07XuLElWVhZ69uyJxYsXOzxIjNzbgw8+iNGjR+uK56VR+Hk8ffo0Tp8+jcaNG2PIkCFFcWfqhm7Vs5bcj5p8GtrVbMDH69r/oecXQMvLB0QB8PUBROHaQu7jBe1qNtTk05BaNyv3dWNDu8NTMuHLpLm63bRH0hOw4OAsjGnzPEwGr3Jfh4iIiIiIiKgmaxPUHq91WYDEy7tx8MpeWO058DH6oW1wB0SF3F2hO2qrK7PZjLFjx2Lx4sV4991373Q6VErbt2+Hoijl6gvsCizW0m2pJ84Bqnptt6yiQMuyAJoGAYBWIEMI9AMkCYJBgqaqUE+cc0mxFgCiQjrCZPDCokPvw67kF42fzEzCx4mvY3zkFPgY/VxyLSIiIiIiIqKayiga0b5OV7Sv0/VOp1JtjB8/HsOGDUNiYiKioqLudDpUAlVV8d5772HWrFkwGO5suZTFWrotLc8GFN4ho6jAjV0zFAXa1WwIZj/AwwAI/zvehcIDIzEhcio+PfgO8mRr0XhKzinMTXgNT0ZNRYCn45MaiYiIiIiIiIjK6/PPPy/TeUajEatWrXJxNlRRRFHE119/fafTAMAHjFEJBC8TUFifNRqBm/vRqiq0zGzAlg9o/zvexRqbwzExehp8Pcy68Uu55xGf8Cqu5KW5/JpERERERERERESVjcVaui2xWQNAFKHJCiAAQqA/YLxpQ7amQcvMAWQFQtOKeVpemG8jTIp+GQGeQbrxq7bLmJswAxes5yrkukRERERERERERJWFxVq6LTG8MYRa/oA1D5qmAaJ4rWDrcUODcU0DVA1QVagnzkKT5VtPWA4h3nUxKWY6gr1CdeM5BVmI3/8azmafqJDrEhERERERERERVQYWa+m2BIME44P3QjB5ANnW/+2wFaD5+wDeXtcLtaIAmH2hHT8L+1c/QrPmVUg+gaZgTIqZjnq+jXTjeXYr5ifOxPHMwxVyXSIiIiIiIiIioorGYi2VSGzWAMahfSEEmYFcG7TMHAjZVkBRrvexDfSH4OkBANAuXIZ92Xqo6ZkVko+fhxl/i56GxuZw3Xi+YsPCA2/hUPq+CrkuERERERERERFRRWKxlkpFbNYAHv83DMahfSB1aAMlvBGkDm1gfPxBGMc/AsHPR3e8lm25VrA9nVoh+XgZfDA+cgrCAyN147Jqx+JDs7EvbUeFXJeIiIiIiIiIiKiisFhLpSYYJEitm8HQvwfk/t1h6N8DUutmkJo1gHFYHAR/X/0JBXbYv/4JSmJyheTjKZkwuu1ziAyO1Y1rmorlR+dhR+qmCrkuERERERERERFRRWCxllxCDAq4VrCtG6IPaBrkn3ZC3roHmqq5/LpG0YgRrScjNvTemy6r4etji/Hz2W9cfk0iIiIiIiKi6sSuaNh5vgDxf1gxa5cF8X9YsfN8AeyK6/8dfyuapmHNmjUYOXIkOnXqhLZt2+L+++/Hq6++irS0tNue27JlS6xZs+aW8alTp2LkyJGuTpmoQhjudAJUfQg+XjD+5QHIP+yAmnxaF1P2HYaWmQNDv24QPIwuva4kSBgaPh4mgze2p2zQxTacWgmbnIe4Jo9CEASXXpeIiIiIiIioqktIs+PjP3Nx0apA0QABgAbgx1P5CPWRMLGdN2LquPbf8TdTFAWTJk3CH3/8gYkTJ2L69Onw8fHBsWPHEB8fjyFDhmDt2rUIDg4u9vxff/0Vfn5+FZojUWXhzlpyKcFggCGuO6S7oxxi6olzsK/cCM2S6/rrCgIGNH0cfRo/4hDbcm4dVh/7DKqmuvy6RERERERERFVVQpods3ZZkGpR4O8hoLa3iBBvEbW9Rfh7CEi1KJi1y4KENHuF5rFo0SJs374dixYtwpgxY9CiRQvUq1cP9957LxYvXgyj0YjPPvvslueHhITAZDJVaI5ElYXFWnI5QRRg6NIOhj5dAFH/V0y7lA770vVQL111/XUFAb0bDcbA5qMcYrsubMbSpHgoquzy6xIRERERERG5C1XTkJ2vlviTnqdg7h9WWOwaAk0CRFGAoqHoRxQFBJoEWOwa5v5hRXqeUuKcquZ82wRN0/Dll19iwIABaNOmjUPcy8sLX3zxBZ555hmkpKSgZcuWiI+PR5cuXdCzZ09kZ2fr2iBomob4+Hh0794dMTExmDZtGvLz88v9eyWqLGyDQBVGatMcgr8v5HW/QLNdXxg1ixX2FT/A+GA3iE0buPy63cL6wCR5YWXyAmg37KZNuLQT+UoeRkU8DaPk4fLrEhEREREREd1Jey4UYOlhG7LzS76z1FKg4aJVhSQAufZbF1k1DTiWr+D/NmbD1+P27QX9PUUMb21CbN3S/5s7JSUFqampuOeee255TFhYmO7P3377LZYsWYK8vDz4+/vrYp988gkWLlyIV199Fa1bt8aKFSuwatUqdOzYsdQ5Ed1J3FlLFUpsEHrtwWMB+sUTdjvs32yB8sdhaGX45q0ksaHdMTJiMiRR/33EkfQELDg4CzY5z+XXJCIiIiIiIrqTlhzIK1WhFgBy5Wv/Fi/p8S6CcK2HbeHxt5Odr2LJAef+vX3lyhUAQK1atXTjEydORLt27Yp+HnzwwaLY8OHD0bx5c0RGRurO0TQNn3/+OUaNGoWHHnoITZs2xYsvvoiIiAinciK6k1ispQonBPrDOKwfxLA6+oCmQf5lD5Qtv0NTXd9PNiqkI8a2fR5GyVM3fjIzCR8nvg6rPcfl1yQiIiIiIiKqClTVuY1Tzh5fWoGBgQCAzMxM3fiMGTOwdu1arF27FkOGDEFe3vUicKNGjYqdKyMjA5cvX3Yo4sbExLg0Z6KKxGItVQrBywTDkN4QI5o6xJSEJMhrN0PLL3D5dcMDIzEhciq8DD668ZScU5ib8Boy813fO5eIiIiIiIjoTngi0gv+nqUr9YhiCVtqy3C8v6eIJyK9nJq3QYMGCAkJwe+//64br1OnDho1aoRGjRrBbDbrYiU9TOzmO3gNBnYBpaqDf1up0ggGCYa+XaEE+kP5LUEXU0+fv9bHdlBPCP6+Lr1uY3M4JkZPw4IDs2ApyCoav5R7HvEJr+LJqBcR7FXnNjMQERERERERub/Yuh5oH2qEpaDkXbB7LtjxwV4r/DwFGG9TiLUrGnIKNDzdwQexdY23ndPXQ4BYUl+Fm0iShFGjRmHu3LkYNmwYWrVq5XDMhQsXSjVXrVq1ULduXezbtw/3339/0fjBgwdhNN4+dyJ3wZ21VKkEQYChUzQMcd0BSdLFtCsZsC9dD/XiFZdfN8y3ESZFv4wAzyDd+FXbZcxNmIEL1nMuvyYRERERERFRZRMFAf6eYok/3Rt4oJ6vhJx8DSI0SAIcfkRcK9TW85XQvYFHiXM6W6gtNG7cONx3330YPnw4Pv74YyQlJSElJQWbN2/GmDFjsHr1anTq1KlUc40fPx5ffvklvvrqK5w6dQqzZ89GYmJimfIiuhO4s5buCKlVEwh+PpC/3QItz1Y0ruXmwb5yIwz9ukJqUXwPmrIK8a6LSTHTMT/xDVzJu1g0nlOQhfj9r2F82ylo6N/MpdckIiIiIiIickdGScDEdt6YtcuCK3kaAjyvjRWyKxoy8zX4GK8dd2PM1URRxOzZs7FhwwasXr0a//3vf5GdnY3g4GB06NABX3zxBWJjY5GSklLiXI8//jhUVcW8efNw5coVdOvWDY888ghOnTpVYfkTuZKg3dzIg8pEURQkJCQgJiYG0k07RqsbTdOQlZUFs9kMoYzfmhXNlZkD+9qfoV3NcogZurWH2KFNua9xs5yCLCw4MAupljO6cU/JhNFtn0PzgNYuvR4RVTxXrktERK7AdYmI3A3XpeonNzcXR44cQUREBLy9vcs8T0KaHR//mYuLVgWKBggANFzbWRvqI2FiO2/E1GELAaLbKfw8nj59GqdPn0bjxo0xZMiQorgzdUO2QaA7Sgjwg/GxfhAb1nWIydv3Qdm0E5qiuvSafh5m/C16Ghqbw3Xj+YoNCw+8hUPp+1x6PSIiIiIiIiJ3FVPHiDm9/TGlky/6NfVEl/oe6NfUE1M6+WJOb38WaokqGYu1dMcJJk8YBt8PqW0Lh5hy8Bjkr3+CZst36TW9DD4YHzkF4YGRunFZtWPxodnYl7bDpdcjIiIiIiIicldGSUDnMA/8310+mNLJF/93lw86h3lUaOsDIioei7XkFgRJhNS7Mwzd2jvE1LMXYF++AVpmjkuvWdj2IDI4VjeuaSqWH52HHambXHo9IiIiIiIiIiKi22GxltyGIAiQYtvC0L8HYNA/+067mgX7svVQUy+59JpG0YgRrScjNvRe/fU0DV8fW4yfz37j0usRERERERERERHdCou15HakFo1gHNoHgo+XblzLs8G+6kcoSa59gqMkSBgaPh7d6vdziG04tRLfn1wOPoePiIiIiIiIiIgqGou15JbE0GAYh8VBCA7UB2QF8vptkHftd2kBVRAEDGj6OPo0fsQhtuXcOqw+9hlUzbUPOiMiIiIiIiIiIroRi7XktgR/Xxgf7QuxcZhDTPktAfIPv0KTFdddTxDQu9FgDGw+yiG268JmLE2Kh6LKLrseERERERERERHRjVisJbcmeHrAMKgnpJhWDjH1yEnIqzdBy7O59Jrdwvrg0ZYTIAj6j0fCpZ1YfPh92JUCl16PiIiIiIiIiIgIYLGWqgBBFGHoeTcM93UEBEEXU8+nwb5sPbSrWS69Zmxod4yMmAxJ1D/o7Eh6AhYcnAWbnOfS6xEREREREREREbFYS1WG1C4CxoH3AUajblzLzIF9+Qao5y669HpRIR0xtu3zMEqeuvGTmUmYnzgTVnuOS69HREREREREREQ1G4u1VKWITRvA+GhfCL4+unHNlg/76k1QDh136fXCAyMxIXIqvAz6653LOYm5Ca8hM/+qS69HREREREREVJNMnToVLVu2vO0PAIwcORJTp069w9kWz263Y/HixUV/njNnDnr27Omy+Vu2bIk1a9YUG0tJSSn6PR06dKjYY/r164eWLVti9+7dAK79zkeOHFnq67vz7746YrGWqhyxdi0Yh8dBqB2kD6gq5I07IO/4E5qquex6jc3hmBg9Db4eZt34pdzziE94FVfy0lx2LSIiIiIiIqKaZNq0afj111+LfgDgpZdechhzZ9999x3eeOONoj+PGTMGq1atqtQcjEYjfvjhB4fxpKQknDp1Sjc2bdo0zJkzp9Rzz5kzB9OmTSt3jlQ6LNZSlST4esM4tA/EZg0cYsruRMjrt0GTZZddL8y3ESZFv4wAT32B+KrtMuYmzMAF6zmXXYuIiIiIiIiopvDz80NISEjRz63G3Jmm6TeM+fj4oFatWpWaQ+fOnYst1q5fvx4dOnTQjfn5+SEgIKDUcwcEBMDPz6+8KVIpsVhLVZbgYYSh/32Q2rdxiKnJp2H/6kdoVtc9CCzEuy4mxUxHsFeobjynIAvx+1/D2ewTLrsWEREREREREelZrVa89NJL6NChA9q3b4+pU6ciNze3KH7ixAmMHz8e7dq1Q9euXfHcc8/h8uXLRXFFUbB48WL06dMHkZGR6NOnD1auXFkU3717N1q2bIkFCxbg7rvvxuDBg6EoCtLS0vCPf/wDHTp0wN13342JEyfi9OnTAIA1a9bgxRdfBICiVgM3t0G4evUqpkyZgrvvvhvt27fH+PHji87XNA0LFy5Ev3790LZtW7Rv3x4TJkzAuXPObQrr168fzp4969AKYcOGDYiLi9ON3dgGofA1b926FQ899BDatm2LBx98EFu2bCk6/sY2CGvWrEHv3r2xfv169OzZE1FRURg7dizS0tLw+uuvIzY2Fvfccw/mz59f7PUK3fw7atmyJb777juMGjUKUVFR6N27NzZv3ozNmzejT58+iImJwbhx43D1avVvR8liLVVpgijAcG8HGO7vDAiCLqZduAz78vVQ0zNddr1AUzAmxUxHPd9GuvE8uxXzE2fieOZhl12LiIiIiIiIqEy+/BKIiyv559lnHc999tnSnfvll/rzcnMdx1zsxx9/RHBwMNasWYO33noL69evx4IFCwAAaWlpGD58OBo0aIBVq1bh448/hsViwWOPPVZU0H3zzTcRHx+Pp556CuvWrcOoUaPw6quv4vPPP9dd55dffsGKFSswc+ZM5OfnY+TIkVAUBV988QU+//xzBAYGYujQoUhLS0NcXBxeeuklAMCvv/6Kdu3a6eaSZRljxoxBcnIy5s6di5UrV0KSJIwZMwayLGPJkiWYP38+XnjhBWzcuBHx8fE4deoU3nzzTad+N2FhYYiKitLtrk1MTER2dja6dOlS4vlvv/02pk2bhjVr1qBBgwZ4/vnnYbVaiz32woULWLZsGeLj47Fo0SIcOHAAAwYMgMFgwMqVK/HYY4/hvffeQ3JyslOv4T//+Q8ef/xxfPfdd2jevDmee+45zJs3D2+//TY+/vhjJCYmFr3f1RmLtVQtSFHhMA6+H/Aw6sa1LAvsy9ZDPZ3qsmv5eZjxt+hpaGwO143nKzYsPPAWDqXvc9m1iIiIiIiIiJxmtQKXLpX8k5HheG5GRunOvbmQp2mOYy4WGRmJZ599Fg0bNkSvXr3QpUsXHDx4EACwbNky1K5dG9OnT0ezZs3Qtm1bzJ49G1euXMEPP/wAi8WCZcuW4e9//zv69++Pxo0b4/HHH8eIESPw8ccf61oZjBkzBo0bN0ZERAS+//57ZGRk4N1330WrVq0QHh6O119/Hb6+vli5ciVMJlNRi4CQkBB4eHjoct61axeOHDmCd999Fx06dECzZs3w2muv4YEHHkBmZiYaNmyIN998Ez179kRYWBjuvvtu9OvXD0ePHnX699OvXz9dsXbDhg3o06cPJEkq8dxnnnkGnTt3Rnh4OJ555hlYLJZbFlvtdjtefvlltGrVCu3bt0fnzp1hMpnwz3/+E02aNMGECRMAAMeOHXMq/8GDB6NPnz5o2LBhUZH9H//4B6KiotCpUyd06dLF6QJwVWS40wkQuYrYuB6Mw+Igf/0ztGzL9UCBHfavf4KhVydIUeG3nsAJXgYfjI+cgiWHZiM540DRuKzasfjQbDzWciLa1yn5mysiIiIiIiIil/PxAWrXLvm4wMDix0pzro+P/s+C4DjmYk2aNNH92Ww24/z58wCAw4cP48SJEw47W/Pz83HixAmcPHkSdrsd7du318U7dOiARYsWIT09vWiscePGRf99+PBhWCwWdOzYsdh5S3L06FH4+/ujadOmRWMhISFFbQV69uyJ/fv348MPP8SZM2dw4sQJHDt2DHXq1Clx7pv169cPb731Fg4dOoTWrVtjw4YNmDVrVqnOvTE/X19fANeKsrdy43vh5eWF+vXrQ/jfHc+enp4Arv2OnHHjnCaTCQDQoMH1ZxV5enqioKDAqTmrIhZrqVoRgwJgHBYH+7dboF243pcGmgb5p53QMrIgdesAQRRuPUkpeUomjG77HJYemYsDV/bccCkVy4/Og03JRZd6vct9HSIiIiIiIiKnPP74tZ+yeO+9sp3n7V32a5bS7XaIqqqKTp064d///rdDzM/Pr6gHrHBTC0VVVQEABsP1EllhsbEw3qRJE8ybN89hXm9v7xJzNhgMDte80YIFCzBnzhw8/PDD6NixI0aOHImff/4Z33//fYlz36xu3bqIiYnBDz/8gPz8fMiyjNjYWKSmlny38c07ggHHB6fdyGjU39ksire/ef/mueRiHgp/43tQ6Ha/u+qKbRCo2hF8vGD8ywMQwxs7xJR9hyGv2wKt4NbfDjnDKBoxovVkxIbeqxvXNA1fH1uMn89+45LrEBEREREREdGttWjRAidOnEDdunXRqFEjNGrUCGazGTNnzkRycjKaNm0Kg8GAvXv36s7bu3cvQkJCYDabi503PDwcqamp8PPzK5o3LCwM7777LvbsubZx63YFxebNmyMrKwtnzpwpGrt69SpiY2Oxb98+zJs3D0899RReeeUVPProo4iJicHp06dvWyi9nb59++LHH3/Ehg0b0K9fvxKLqJXBaDQiJydHN3bj74P07vw7RlQBBIMBhrjukO6OcoipJ87BvnIjNEtuMWc6TxIkDA0fj271+znENpxaie9PLi/zIktEREREREREJRs+fDhycnLw7LPP4siRI0hKSsJzzz2HxMREtGjRAn5+fhg6dCg+/PBDrFu3DmfOnMGXX36JpUuXYsyYMbcsuA4YMABmsxlPPfUUEhIScOLECbz44ovYunUrWrRoAeD6DtuDBw/CZrPpzu/cuTPatm2Lf/7zn9i/fz+OHTuGF198EUFBQYiMjETdunWxY8cOHD9+HCdPnsT777+PH3/8scy3+/fr1w9nzpzBmjVr8OCDD5ZpDle76667cPToUaxZswYpKSn44osvsHXr1judlttisZaqLUEUYOjSDoY+XYCbvknSLqXDvnQ91EtXXXMtQcCApo+jT+NHHGJbzq3D6mOfQdVUl1yLiIiIiIiIiPQaNGiAL774Anl5eRg+fDhGjBgBQRCwZMkSBAUFAQCmTZuGESNG4N1338WDDz6IpUuXYvr06RgzZswt5/Xz88MXX3yBoKAgjBs3Do888gjOnz+PTz/9tKhY26lTJ0RHR+Oxxx7Dli1bdOeLooj4+HjUq1cPY8eOxbBhw2AwGPDpp5/Cw8MDb731Fmw2G4YMGYIRI0YgOTkZM2bMQHp6OlJSUpz+PdSpUwd33XUXzGYzYmJinD6/IvTv3x+jRo3CrFmz0L9/f+zZswdPP/30nU7LbQkat/y5hKIoSEhIQExMTKmesleVaZqGrKwsmM3mKtM7RD13EfK6X6DZbmpubTTC+GB3iE3ru+xa289vxDfH/+swHlO7M4a1nAhJZKtoIleriusSEVVvXJeIyN1wXap+cnNzceTIEURERJSqdyoRVZzCz+Pp06dx+vRpNG7cGEOGDCmKO1M35M5aqhHEBqEwDouDEOCvD9jtsH+zGcqfR1x2rW5hffBoywkQBP3HK+HSTiw+/D7sSvV/ciERERERERERETmPxVqqMYRAfxiH9YMYVkcf0DTIW36HvHk3NNU1rQpiQ7tjZMRkh120R9ITsODgLNjkPJdch4iIiIiIiIiIqg8Wa6lGEbxMMAzpDTGiqUNMSUiCvHYztHzX7HyNCumIsW2fh1Hy1I2fzEzC/MSZsNpzbnEmERERERERERHVRCzWUo0jGCQY+naFdE+MQ0w9fR72FT9Ay7a45FrhgZGYEDkVXgYf3fi5nJOYm/AaMvNd84AzIiIiIiIiIiKq+lispRpJEAQYOkXDENcduKmxs3YlA/al66FevOKSazU2h2Ni9DT4eph145dyzyM+4VVcyUtzyXWIiIiIiIiIiKhqY7GWajSpVRMYH3kAgpdJN67l5sG+ciOUY2dccp0w30aYFP0yAjyDdONXbZcxN2EGLljPueQ6REREREREVLOoLnr2ChGVnSs/hyzWUo0nhtWGcVgchFr6na+QZcjrfoGy5yA0TSv3dUK862JSzHQEe4XqxnMKshC//zWczT5R7msQERERERFRzeDh4QEAsFhc08aPiMqu8HNot9vLPZeh5ENunURaWhpycnJgNpsRFhZWtFAQVTVCgB+Mj/WD/N1WqGcv6GLy9n2QMrMh9ewEQSrf9xuBpmBMipmOBQdmIdVyfddunt2K+YkzMbrtc2ge0Lpc1yAiIiIiIqLqz2AwIDg4GOfPnwcA+Pr6QhS5J4+oMqmqCovFgvPnzyMzMxOqqkLTNEg3tdx0hlPF2vT0dCxbtgybN29GUlKSbrehwWBA69at0a9fPwwaNAgBAQFlToroThBMnjAMvh/Kz7ugHDymiykHjkHLssDw0L0QTJ7luo6fhxl/i56GTw++g9NZyUXj+YoNCw+8hZGtJ6NNUPtyXYOIiIiIiIiqv4YNG0JV1aKCLRHdGZmZmUhLS4OqqrDZbAgMDCzzXIJWivu78/LyMHv2bCxfvhwFBQW3vSVcEAQYjUaMHDkSkyZNgre3d5mTq0oURUFCQgJiYmLKVT2vCjRNQ1ZWFsxmMwRBuNPpuJymaVD3HoK8fZ9DTKhlhnFQLwgBfuW+Tr5iw5JDs5GccUB/DUHEYy0non2dLuW+BlFNUd3XJSKqerguEZG74bpUvf3xxx/4/fffIUkSvLy8+B5TlVFQUFDl79QvKCiAoihQFAUZGRkICQlB//79Ubt27aJjnKkblqpY27NnT6SmpiIkJAS9evVCp06d0LJlSwQHB8Pb2xsWiwVXrlxBUlIS/vzzT2zZsgXnz59HnTp1sHXr1vK/6iqAxdrqRzl2BvKGXwFZ1o0LXiYYBt4HsV7tW5xZenbVjqVH5uLAlT36awgCBjV/Al3q9S73NYhqgpqyLhFR1cF1iYjcDdel6k3TNCQkJGD37t3Iz893yXNXiCpDdSjWFpIkCWazGX369EGdOnV0MZcXa8eOHYsRI0agR48epV7U9+zZg8WLF2Pu3LmlOr6qY7G2elIvXoH8zWZo1jx9wCDB8EAXSK2alPsaiqZgVfKn2HPR8YuNfk2GolfDgeW+BlF1V5PWJSKqGrguEZG74bpUM9jtdlitVhZrqUrQNA3Z2dnw9/evFuuS0WiEt7d3sb2jnakblqpn7aeffup0grGxsYiNjXXqnPj4eOzcuROff/550diRI0fw+uuv4+DBgwgICMDIkSMxduzYoriqqvjoo4/w1VdfITs7G+3bt8e///1vNGrUyKVzUM0khgbDOCwO9rWboV3JuB6QFcjrt0HLzIZ0d1S5FhVJkDA0fDxMBm9sT9mgi204tRI2OQ9xTR6tFgsXERERERERVRyj0chnCFGVoWkaRFHkl0g3KdNjArOysnD06FEA1xrovvrqq3j66aexbdu2MieyePFifPjhh7qxjIwMjB49Go0bN8bq1asxefJkfPDBB1i9enXRMfHx8Vi+fDn+85//YMWKFRAEAePHj0dBQYHL5qCaTfD3hfHRvhAbhznElN8SIP/wKzRZKd81BAEDmj6OPo0fcYhtObcOq499BlVTy3UNIiIiIiIiIiJyb04Xa48ePYq+ffti0aJFAIDnnnsOy5Ytw8aNGzFx4kTs2LHDqfnS0tIwbtw4fPDBB2jSRH9L+cqVK+Hh4YFXXnkFzZo1w5AhQ/DXv/4VCxYsAHCtr8Vnn32GyZMn495770WrVq3w/vvvIy0tDZs2bXLZHESCpwcMg3pCimnlEFOPnIS8ehO0vPzyXUMQ0LvRYAxsPsohtuvCZixNioeiysWcSURERERERERE1YHTxdr3338fGRkZyMjIQGpqKnbs2IGgoCD06NEDqqpi/vz5Ts136NAhmM1mfPvtt4iOjtbF9u7di9jYWBgM17s1dOrUCadOnUJ6ejqSkpJgtVrRqVOnori/vz9at26NPXv2uGwOIgAQRBGGnnfDcF9H4Kbt+er5NNiXrYeWkV3u63QL64NHW06AIOg/ngmXdmLx4fdhV7jjm4iIiIiIiIioOnK6WHvgwAEYjUbMmjULO3fuBAA89thj+Oijj2AymXD8+HGn5uvZsyfeffddNGjQwCF28eJFhIaG6sZq164NAEhNTcXFixcBAHXr1nU45sKFCy6bg+hGUrsIGAfeBxiNunEtMxv2Zeuhplws9zViQ7tjZMRkSKK+rfSR9AQsODgLNjnvFmcSEREREREREVFVVaoHjN3IYrHA398fAQEB2Lt3LwRBQPv27WEwGODp6Ym8PNcVkWw2Gzw8PHRjnp6eAID8/PyiaxV3TFZWlsvmcIamadX+qYuFr7G6v87bEZrUh+HRPlDWboZmyS0a12z5sK/aBOn+TpDaNC/XNSKDYzGmzXNYfOh92NXru2lPZibh48SZGNf2BfgY/cp1DaLqgusSEbkbrktE5G64LhGRu6lJ65Izr9HpYm3t2rWRmpqKbdu2YevWrfD09MRdd92FdevWISsrCy1atHB2ylsymUwOD/nKz7/WF9Tb2xsmkwnAtb6zhf9deIyXl5fL5nBGdnY2RLFMz22rMjRNQ27utQJljX5an4cEPNgVxh93QriSeX1cUaBs2A7lwiUoHVo7tExwRh2xIYY3eQpLT8yFTbleFD6TeQwf7v03RjT/O/w9AsvxIoiqB65LRORuuC4RkbvhukRE7qYmrUuqWvqHxjtdrO3VqxcWL16MCRMmAADi4uIgyzJeeOEFCIKAgQMHOjvlLYWGhuLSpUu6scI/16lTB7IsF401bNhQd0yrVq1cNocz/P39IUmS0+dVJYXfBpjN5mr/YSqR2Qzt8YegrN8O9WSKLiQdOA4xX4bU5x4IBqc/ajdc4i48ZZ6OBQdmwWK/3hP3qv0SPj/1AZ6MnIpgrzplnp+oOuC6RETuhusSEbkbrktE5G5q0rqkKEqpj3W6gvTUU0/hwoUL2LZtG1q3bo2pU6fCx8cHwcHBuPvuuzF69Ghnp7yl2NhYLF++HIqiFBVAd+7ciSZNmiAoKAh+fn7w9fXF7t27iwqt2dnZOHz4MEaMGOGyOZwhCEK1/wsGXH+dNeG1lkTw8IAwoCeU7Xuh7Dusi6nJp6HlWGEccB8EH+d3ahcK82uMSTHTMT/xDWTmpxeNZ9guI37/q3gy6kXU9XHs+0xUk3BdIiJ3w3WJiNwN1yUicjc1ZV1y5vU5fb++r68vPvjgA/z555/48ssvERISAgD46quv8O6777p0V+mQIUNgsVgwbdo0HD9+HGvWrMGSJUuKdvV6eHhgxIgReOedd/Dzzz8jKSkJ//jHPxAaGorevXu7bA6ikgiiAMO9sTD06uTQ9kC7cBn25euhpmeW6xoh3nUxKWY6gr30D8zLKchC/P7XcDb7RLnmJyIiIiIiIiKiO6vM92bn5OTAarXqei6kpqYCAOrVq1f+zAAEBQVh4cKFeP311zF48GCEhITgn//8JwYPHlx0zN///nfIsox//etfsNlsiI2Nxaefflr0wDBXzEFUWlJ0SwhmP9i/+wUosBeNa1kW2Jeth7F/D4iNyv75CDQFY1LMtZYIqZYzReN5divmJ87E6LbPoXlA6/K8BCIiIiIiIiIiukMEzclHrp0+fRpPP/00kpOTi59QEHD48OFiY9WZoihISEhATExMjehZm5WVVSN6ipSVmp4J+eufoWVb9AFBgKFXJ0hR4eWaP0+24tOD7+B0lv5zaBCNGNl6MtoEtS/X/ERVDdclInI3XJeIyN1wXSIid1OT1iVn6oZOt0GYPn06jh49Ck3TbvlDVNOJQQEwDouDUDdEH9A0yD/thLx1LzS17J8VL4MPxkdOQXhgpG5cVu1YfGg29qXtKPPcRERERERERER0ZzjdBiExMRGCIOCZZ55Bu3bt4OnpWRF5EVV5go8XjH95APIPO6Amn9bFlH2HoGVmw9CvGwQPY5nm95RMGN32OSw9MhcHruwpGtc0FcuPzoNNyUWXeuy7TERERERERERUVThdrA0ODkZ2dnbRA7qI6NYEgwGGuO5QAv2h7E7UxdQT52BfuRHGQT0h+HqXaX6jaMSI1pOxKvlT7Lm4tWhc0zR8fWwxbHIuejUcWK7XQERERERERERElcPpNggTJkxAdnY2li5dypYHRKUgiAIMXdrB0KcLIOo/ctqldNiXrod66WqZ55cECUPDx6Nb/X4OsQ2nVuL7k8v5WSUiIiIiIiIiqgKcfsCY1WrFX/7yF5w6dQqenp4IDAyEeEMBShAE/PTTTy5P1N3xAWNUGuq5i5DX/QLNlq8PGI0wPtgdYtP6ZZ5b0zT8dHYtNp5e5RDrVLcnHm4xGqLg9PczRFUC1yUicjdcl4jI3XBdIiJ3U5PWJWfqhk63QZg+fTpOnToFTdNgs9lw4cIFXby6/3KJykNsEArjY/1gX/sztMyc6wG7HfZvNsPQIxZSu4gyzS0IAno3GgyTwRvfHP+vLrbrwmbYlDwMazkRkuj0x56IiIiIiIiIiCqB01WbzZs3AwC6d++O6OhoGI1lezgSUU0l1DLDOCwO8re/QD2fdj2gaZC3/A4tIxtSj1gIYtl2wXYL6wOT5IWVyQugaWrReMKlnchX8jAq4mkYJY/yvgwiIiIiIiIiInIxp4u1/v7+kCQJn3zySUXkQ1QjCF4mGIb0hrzpN6hHTupiSkIStMwcGB7sDsGzbEXV2NDu8JRM+DJpLhRVLho/kp6ABQdnYUyb52EyeJXrNRARERERERERkWs5vXXvr3/9K3Jzc7F///6KyIeoxhAMEgx9u0K6J8Yhpp4+D/uKH6BlW8o8f1RIR4xt+zyMkqdu/GRmEuYnzoTVnnOLM4mIiIiIiIiI6E5wemft1atXERgYiMcffxwtW7ZEQECAwwPGuOuWqHQEQYChUzSEAH/IG3cAilIU065kwL5sPQwDe0IMDS7T/OGBkZgQORWfHnwHebK1aPxczknE7/8PxkdOQYBnrXK/DiIiIiIiIiIiKj+ni7ULFiyAIAjQNA2HDh1yiPMBY0TOk1o1geDnA/nbLdDybEXjmjUP9pUbYejXFVKLRmWau7E5HBOjp2HBgVmwFGQVjadZUxCf8CqejHoRwV51yv0aiIiIiIiIiIiofJwu1g4aNIgFWaIKIIbVhnFYHOxrf4Z29XpRFbIMed0vQLf2EDu0KdPnL8y3ESZFv4z5iW8gMz+9aPyq7TLmJszAk1Evoq5Pg/K/CCIiIiIiIiIiKjNB0zTtTidRHSiKgoSEBMTExECSpDudToXSNA1ZWVkwm80s3FcAzZYP+butUM9ecIhJkS0g9ewEQXK63TQAIMN2BfMT38CVvIu6cS+jD8a3nYKG/s3KNC/RncZ1iYjcDdclInI3XJeIyN3UpHXJmbphqSo+L7/8Mo4ePepUEikpKZg5c6ZT5xARIJg8YRh8P6S2LRxiyoFjkL/+CZotv0xzB5qCMSlmOur56lsq5NmtmJ84E8czD5dpXiIiIiIiIiIiKr9SFWu///57DBo0CEOHDsXChQtx8OBBFBQU6I6xWCw4cOAAPvnkEzzxxBPo06cPVq1aVSFJE1V3giRC6t0Zhm7tHWLq2QuwL98ALTOnTHP7eZjxt+hpaGwO143nKzYsPPAWDqXvK9O8RERERERERERUPqXqWbt+/Xq8+uqr2Lx5Mw4cOAAAEEURvr6+8PLyQlZWFmy2Gx6KpGno3bs3XnrppYrJmqgGEAQBUmxbIMAP8oZfAVkuimlXs2Bfvh6GAfdBrFfb6bm9DD4YHzkFSw7NRnLGgaJxWbVj8aHZeKzlRLSv08Ulr4OIiIiIiIiIiEqnVDtrQ0NDER8fj9WrV2PgwIEICAiAoijIysrCxYsXkZeXB03TEBQUhEceeQTffPMN5syZg7p161Z0/kTVntSiEYxD+0Dw8dKNa7k22Ff9COXoqTLN6ymZMLrtc4gMjtXPq6lYfnQedqRuKnPORERERERERETkvFLtrC3Upk0bvPnmm9A0DcnJyUhLS0N2djb8/f0RFhaGZs34cCKiiiCGBsM4LA72tZuhXcm4HpAVyN9vg5aRDenuKKcbchtFI0a0noxVyZ9iz8WtReOapuHrY4thk3PRq+FAV70MIiIiIiIiIiK6DaeKtYUEQUDLli3RsmVLV+dDRLcg+PvC+GhfyN9vg3r6vC6m/JYALSMbht73QDDc/qmCN5MECUPDx8Nk8Mb2lA262IZTK2GT8xDX5NFq/2RGIiIiIiIiIqI7rVRtEIjIPQieHjAM6gkpupVDTD1yEvLqTdDy8p2fVxAwoOnj6NP4EYfYlnPrsPrYZ1A1tUw5ExERERERERFR6bBYS1TFCKIIqWdHGHrEAjftdlXPp8G+bD20jGzn5xUE9G40GAObj3KI7bqwGUuT4qGocjFnEhERERERERGRK5SpDQLVTHZFw96Ldvxx0Y6rFgW1fHNxV6gRHUKNMEq8Rb4yCYIA6a7WEMx+sK/fDtjtRTEtMxv2ZethGNADYv1Qp+fuFtYHJskLK5MXQLthN23CpZ3IV/IwKuJpGCUPl7wOIiIiIiIiIiK6jjtrqVQS0uyYvCkbs3ZZ8MOpfPx+CfjhVD5m7bJg8qZsJKTZS56EXE5s1gDGR/tC8PXRjWu2fNhXbYJy6HiZ5o0N7Y6REZMhifrvc46kJ2DBwVmwyXllzpmIiIiIiIiIiIpX5mLtpUuXsG7dOixYsAAAcO7cOZclRe4lIc2OWbssSLUo8PcQUNtbRJAJqO0twt9DQKpFwaxdFhZs7xCxdi0Yh8dBqB2kD6gq5I07IO/4E5qqOT1vVEhHjG37PIySp278ZGYS5ifOhNWeU560iYiIiIiIiIjoJmUq1r711lvo2bMn/vnPf+L9998HADzxxBN45plnYLezYFed2BUNH/+ZC6tdQ7CX4NDuwCgJCPYSYLVfO86uOF8UpPITfL1hHNoHYrMGDjFldyLkDduhyc73mw0PjMSEyKnwMuh37p7LOYn4/f9BZv7VMudMRERERERERER6ThdrFy9ejM8++wySJEEURWiahtzcXKSmpmLjxo2Ij4+viDzpDtl70Y6LVgUBngIEQUCerOFyroqsfKBws6YgCAjwFHDRqmDvRRbr7xTBwwhD//sgtW/tEFOPnoL81Y/QrM63L2hsDsfE6Gnw9TDrxtOsKYhPeBXpeZfKnDMREREREREREV3ndLF2xYoVEEURX331FYKDgwEA3t7e+PjjjwEA3377rWszpDvqzzQ7FO3aDlpZBS7lqrDaNWTbgVSLinzl2nFGSYCiXTue7hxBFGC4NxaGXp0AQb8LWr1wGfbl66GmZzo9b5hvI0yKfhkBnvpWC1dtlzE3YQYuWNkGhYiIiIiIiIiovJwu1qakpMBsNiM8PFw33qNHD/j7++Py5csuS47uvJwCDYUlP7uqQbuhy4GsarhoUZCdf21Q+N/xdOdJ0S1hHHw/4GHUjWtZFtiXrYd6JtXpOUO862JSzHQEe4XqxrMLMhG//zWczT5RrpyJiIiIiIiIiGo6p4u1QUFByM7ORkpKim58y5YtyMrKKtptS9WDn4eAwvKrySDAKOp3a2oArtpUXMpVoWrXjif3IDauB+Nj/SD4++oDBXbY1/wEJTHZ6TkDTcGYFDMd9Xwb6cbz7FbMT5yJ45mHy5MyEREREREREVGN5nSx9qGHHoKiKBg6dCgyMjIAAH/5y18wadIkCIKAfv36uTxJunPa1TFCEq49aEwAEOorwmRwLMhaCzRY7RpCfcr0zDqqIGJwIIzD4iDUDdEHNA3yTzshb90LTXVuN7Sfhxl/i56Gxmb97vp8xYaFB97CofR95U2biIiIiIiIiKhGcrqy9ve//x09evTA1atXUVBQAE3TcODAAaiqinvuuQdPPfVUReRJd0iHUCNCfSRk5mvQNA2SANTxEeFvRFF7BE0DFA2QBGD9iXxsPJkPTWM7BHch+HjB+JcHIIY3dogp+w5B/u4XaAXO9Rr2MvhgfOQUhAdG6sZl1Y7Fh2ZjX9qO8qRMRERERERERFQjCVoZq2o7d+7Erl27kJGRgZCQEMTGxqJTp06uzq/KUBQFCQkJiImJgSRJdzodl0pIs2PWLgusdg0BnsK1h4kpCgo0EZesKuwqIApAqI8Ib+O1Em5MbSPGRHnBx4M7bd2FpmpQdiZA2Z3oEBPqBME4sCcEX2+n5rSrdiw9MhcHruzRzycIGNT8CXSp17tcOROVlqZpyMrKgtlshiCwHQsR3Xlcl4jI3XBdIiJ3U5PWJWfqhmUu1pJedS7WAtcKth//mYuLVgWKdu0DJQgCBFzbWevrIRQVagsFeYl4MsYbzQMNdyZpKpZy6DjkTTsBVdWNC74+MAzqCbF2Lefm0xSsSv4Uey5udYj1azIUvRoOLFe+RKVRk/5PnoiqBq5LRORuuC4RkbupSeuSM3VDp6toiqLg888/x549e2C1WqHeXPARBCxZssTZacnNxdQxYk5vf+y9aMcfF+24arGhlq8n7go1ol1tAzacKsD3x224sfKfnqdi1i4rHmlpwgNNPKr9B6+qkNo0h+DvC3ndL9Bs+UXjmsUK+8ofYIzrDrFp/dLPJ0gYGj4eJoM3tqds0MU2nFoJm5yHuCaP8v0nIiIiIiIiIiqB08Xad955B4sXLwaAYvuSsiBTfRklAZ3DPNCpnhFZWXaYzd5F7/fgcBNaBEpYuD8POQXXC/iqpmFlUh6OXpUxJsoLvmyL4BbEBqEwPtYP9rU/Q8vMuR4osMP+zWYYesRCahdR6vkEQcCApo/D2+CDjadX6WJbzq1DnmzFwy1GQxT4/hMRERERERER3YrTxdq1a9cCAJo3b462bdvCw8PD1TlRFdU2xIh/d5XwSUIukq/Kutj+S3bM+FXBhHZsi+AuhFpmGIfFQf52C9Tzl64HNA3ylt+hZWRD6hELQSxdgVUQBPRuNBgmgze+Of5fXWzXhc2wKXkY1nIiJJHvPxERERERERFRcZyumhQUFMDLywtr1qyB0WisiJyoCgs0iXi+ow++PZ7v0Bbhqo1tEdyN4GWCYcgDkDf9BvXISV1MSUiClpkDw4PdIXiW/kuZbmF9YJK8sDJ5ATTt+i7rhEs7ka/kYVTE0zBK/JKHiIiIiIiIiOhmTt+T/MADD6CgoACXLl0q+WCqkSRRwOBwE56J9YHfTW0PCtsizNmXC0uBeosZqDIJBgmGvl0h3RPjEFNPn4d9xQ/Qsi1OzRkb2h0jIyY77KI9kp6ABQdnwSbnlSdlIiIiIiIiIqJqSdCKazx7Gzk5ORg6dCiys7PRq1cvBAcHQ7zpNumnnnrKpUlWBc481a2qc+ZpfRk2tdi2CABQyySyLYKbUZJOQd64A1AU3bjg4wXDwJ4QQ4Odmi854wAWHXofdiVfN97ArynGRf4TPka/cudMBNSsp4gSUdXAdYmI3A3XJSJyNzVpXXKmbuh0sXbFihV45ZVXbnvMkSNHnJmyWmCx9tYUVSu2LQIAiIKAIf9riyBW8w9mVaGevwT52y3Q8mz6gMEAQ7+ukFo0cmq+01nJ+PTgO8iTrbrxOj71MT5yCgI8a5U3ZaIa9X/yRFQ1cF0iInfDdYmI3E1NWpecqRs63QYhPj4eACBJEsLCwtC4cWOHH6IbFbZF+EfH4tsifJWUh4/YFsFtiGG1YRwWB6GWWR+QZcjfbYWy5yCc+Y6nsTkcE6OnwddDP1+aNQXxCa8iPY8tVYiIiIiIiIiIgDLsrG3Xrh1kWcaPP/6IunXrVlReVQ531pYO2yJUHZotH/J3W6GeveAQkyLDIfW8G4JU+u97LudewPzEN5CZn64b9/cIwPioqajr06DcOVPNVZO+kSWiqoHrEhG5G65LRORuatK6VKE7a++9914YDAYEBASUNT+qwQJNIp7v6IP+zU24+WN41aZi1i4rfjiZD9W57xCoAggmTxgG3w+pbQuHmHIgGfLXP0Gz5RdzZvFCvOtiUsx0BHuF6sazCzIRv/81nM0+Ue6ciYiIiIiIiIiqMqd31u7duxdPP/00wsLCMHDgQJjNZocHjMXFxbk0yaqAO2udd+iKHQsS8pBTTPuD6NpGjInygq+H098nkItpmgZ17yHI2/c5xIRaZhgH9YIQUPoHheUUZGHBgVlItZzRjXtKJoxu+xyaB7Qud85U89Skb2SJqGrgukRE7obrEhG5m5q0LlXoA8YiIiJuP6Eg4PDhw85MWS2wWFs2bItQdSjHzkDe8Csg698rwdsEw4D7INarXeq58mQrPj34Dk5nJevGDaIRI1tPRpug9i7JmWqOmvR/8kRUNXBdIiJ3w3WJiNxNTVqXKrQNgqZpt/1RVT4kikqPbRGqDqlFIxiH9oHg46Ub13JtsK/6EcrRU6Wey8vgg/GRUxAeGKkbl1U7Fh+ajX1pO1ySMxERERERERFRVeL0lsWkpKSKyINqMEkUMCjchBa1JIe2CKqm4aukPCRfldkWwQ2IocEwDouDfe1maFcyrgdkBfL326Bl5EC6O7JU34gVtj1YlhSPxMu/F41rmorlR+fBpuSiS73eFfEyiIiIiIiIiIjcEitf5DbaBBvx766+aFnL8TuE/ZfsmPGrBcczHNslUOUS/H1hfLQvxMZhDjHltz8h//ArNFkp1VxG0YgREZMRG3qvblzTNHx9bDF+PvuNS3ImIiIiIiIiIqoKSrWzNi4uDiEhIViyZEmJDw8TBAHff/+9S5KjmifQJOL5u33w7bF8fHfchhubHxS2RXi4pQl9mnhArOb9TNyZ4OkBw6CeULbsgbJfv9tePXISco4Vhv73QfDyLHEuURAxNHw8TAZvbE/ZoIttOLUSNjkPcU0erfb9a4iIiIiIiIiISlWsPXnyJHJzc4v++3ZYUKHyEoXbt0VY9b+2CGPZFuGOEkQRUs+OEAL9IG/dC9zQV1hNSYN92XoYB/eCEOhf8lyCgAFNH4e3wQcbT6/SxbacW4c82YqHW4yGKPD9JiIiIiIiIqLqq1TF2kmTJsHPzw8A8NRTT1VoQkSFrrVFkLAgIRdHr+rbHyResmPGrwomtPNG80CnWy+TiwiCAOmu1hDMfrCv3w7Y7UUxLTMb9mXrYRjQA2L90FLN1bvRYJgM3vjm+H91sV0XNsOm5GFYy4mQRL7fRERERERERFQ9CZqmaSUdlJqaCkmSUKdOncrIqUpSFAUJCQmIiYmBJEl3Op0KpWkasrKyYDabK2UntappxbZFAABRAB5u6cW2CG5AvZQOee0WaBarPiCKMPTuDKlN81LPtefiNqxMXgBNU3XjEUExGBXxNIyShytSpmqkstclIqKScF0iInfDdYmI3E1NWpecqRuW6p7inj174rHHHnNJckTOKmyL8GxHH/h76v/KqhqwKikPc/blwlKg3mIGqgxi7SAYh/WDULuWPqCqkDfugLzjT2hqid8NAQBiQ7tjZMRkh120R9ITsODgLNjkPFelTURERERERETkNkrdALIUG3CJKlTrYCP+3cUXLWs53gafeMmOV3614HiGXMyZVFkEPx8Yh/aF2KyBQ0zZnQh5w3Zocuneo6iQjhjb9nkYJf1Dyk5mJmF+4kxY7TkuyZmIiIiIiIiIyF3waT1UpQSYRDx/tw/6Nzfh5g3yGTYVs3ZZsOFkPlR+uXDHCB5GGPrfB6l9a4eYevQU5K9+hGYt3c7Y8MBITIicCi+Dj278XM5JxO//DzLzr7okZyIiIiIiIiIid1DqJ/VYrVYsWLCgVMeOHz++zAkRlaSwLUJ4LQkL9uchO/96+4PCtgjJV2WMjfKCrwe/j7gTBFGA4d5YCAH+kDfvBm4onqsXLsO+fD0Mg3pBDAooca7G5nBMjJ6GBQdmwVKQVTSeZk1BfMKrmBD1EoK8alfEyyAiIiIiIiIiqlSlesBYq1atnGr0e+TIkXIlVRXxAWN3RqZNxScJuTh61fHW+kCTiIntvNE8sNTfSVAFUE+nwv7dL0CBXR/wMMLYvwfERvVKNc/l3AuYn/gGMvPTdeP+HgEYHzUVdX0cWy9QzeFO6xIREcB1iYjcD9clInI3NWldcvkDxgBAkiTUrVu3VD9ElYVtEdyf2LgejI/1g+Dvqw8U2GFf8xOUxORSzRPiXReTYqYj2CtUN55dkIn4/a/hbPYJV6VMRERERERERHRHlHrLYXBwMDZv3lyRuRCVCdsiuD8xOBDGYXGwf7sF2oXL1wOaBvmnndAysyF1bQ9BvP03aYGmYEyKmY4FB2Yh1XKmaDzPbsX8xJkY3fY5NA9w7JVLRERERERERFQVVInKld1ux/vvv48ePXqgXbt2GD58OP7444+i+JEjRzBixAjExMSgR48e+PTTT3Xnq6qKDz/8EN26dUN0dDTGjBmDM2fO6I4paQ5yf62Djfh3F1+0CnL8DiLxkh2v/GrB8QzHdglUOQQfLxj/8gDE8MYOMWXvIcjf/QLt5lYJxfDzMONv0dPQ2ByuG89XbFh44C0cSt/nqpSJiIiIiIiIiCpVlSjWzps3D6tXr8Z//vMfrF27Fk2bNsX48eORlpaGjIwMjB49Go0bN8bq1asxefJkfPDBB1i9enXR+fHx8Vi+fDn+85//YMWKFRAEAePHj0dBQQEAlGoOqhoCTCKe68i2CO5KMBhgiOsO6e4oh5h6/CzsX22EZsktcR4vgw/GR05BeGCkblxW7Vh8aDb2pe1wWc5ERERERERERJWlVMXaN954A1OnTq3oXG7p559/xkMPPYSuXbuiUaNGmDp1KiwWCxISErBy5Up4eHjglVdeQbNmzTBkyBD89a9/xYIFCwAABQUF+OyzzzB58mTce++9aNWqFd5//32kpaVh06ZNAFDiHFS1FLZFeLajD/w99X/FC9sifLg3FzkF6i1moIokiAIMXdrB0KcLIOrfHy0tHfal66FeulriPJ6SCaPbPoeokI76OTQVy4/Ow47UTS7Nm4iIiIiIiIioopWqWDt48GD07du3onO5pYCAAGzZsgUpKSlQFAUrVqyAh4cHIiIisHfvXsTGxsJguH7re6dOnXDq1Cmkp6cjKSkJVqsVnTp1Kor7+/ujdevW2LNnDwCUOAdVTbdri3Dgsh0zfrXgGNsi3DFSm+YwDukNweSpG9csVthX/gD1ZEqJcxhFI0ZETEZs6L36OTQNXx9bjJ/PfuPSnImIiIiIiIiIKlKVaIMwbdo0GAwG9OrVC5GRkXj//fcxe/ZsNGzYEBcvXkRoqP7p8LVr1wYApKam4uLFiwCAunXrOhxz4cIFAChxDqq6CtsiDGhRfFuEt9gW4Y4SG4TC+Fg/CAF++kCBHfZvNkP580jJcwgihoaPR7f6/RxiG06txPcnl0Pj+0tEREREREREVYDjlkM3dOLECfj7+2Pu3LmoU6cOvvrqK0yZMgVffPEFbDYbPDw8dMd7el7bqZefn4+8vDwAKPaYrKwsAChxDmdomlbtC0OFr7GqvE4BwIDmnmgeIGHh/lxkF1zPu7AtwtF0O8ZEecHPo0p8f1G9BPrD8Fg/yN/+Ai310vVxTYO85XeoV7Mg9YiFIN7+venfZDi8JG/8eEbfa3rLuXXIla14uPlfIQp8f6urqrYuEVH1x3WJiNwN1yUicjc1aV1y5jW6fbH2/PnzeOGFF7B48WJ06NABABAZGYnjx49jzpw5MJlMRQ8KK1RYYPX29obJZAJwrXdt4X8XHuPl5QUAJc7hjOzsbIglFJWqOk3TkJt77SFQgnDzflX3FWYEnonS8HmShuNZ+g9JwkUFL1/NxxMRIpr6V53XVK307gjDtj8hHj+rG1b+OIz8y1ch9+oIGG+/ZHUM6AmtAPghZaVu/LeUTci2ZmJQ479CEiSXp053XlVdl4io+uK6RETuhusSEbmbmrQuqWrpn5vk9sXaxMRE2O12REbqn/oeHR2Nbdu2oV69erh06ZIuVvjnOnXqQJblorGGDRvqjmnVqhUAIDQ09LZzOMPf3x+SVL2LQYXfBpjN5ir3YTIDeDFYw3fH87HueD5uLNlaFGDeIeDhcBMeaOIBsYq9tupAG9gT6u5EKDv368al1Mvw2PAbDAPvg+Dve9s5HjAPRi3/IKxMXghNu74YHsn+A1qKilERf4dR8rjNDFQVVeV1iYiqJ65LRORuuC4RkbupSeuSoiilPrZMxdqTJ09i+/btsFqtxVaGn3rqqbJMW6zCXrNHjx5FVFRU0XhycjIaNWqEmJgYLF++HIqiFBVJd+7ciSZNmiAoKAh+fn7w9fXF7t27i4q12dnZOHz4MEaMGAEAiI2Nve0czhAEodr/BQOuv86q+FolQcDAcC+0qGXAgv15yM6//ndY1YBVR204elXB2Gi2RahsgiBA7BwDIcAf8o+/ATcsZtqVDMjLN8AwsCfE0ODbzhMbei88JS98mTQXinr9IXJJVxOw8NBbGNPmeZgMXhX2OujOqMrrEhFVT1yXiMjdcF0iIndTU9YlZ16f08XatWvX4qWXXrptrwVXFmujoqLQoUMHTJkyBf/+978RGhqKtWvXYufOnVi6dCkaNGiAhQsXYtq0aRg3bhwSExOxZMkSzJgxA8C1XrUjRozAO++8g1q1aiEsLAxvv/02QkND0bt3bwDAkCFDbjsHVU+tg414pauETxJykZQu62IHLtsx41cFE9p5o0Wg229Ar3akiKYQ/H0hf7sFWp6taFyz5sG+ciMM/bpCatHotnNEhXSEyeCFRYfeh1253nv6ZGYS5ifOxLjIf8LH6HebGYiIiIiIiIiIKpegOdnFt3fv3jh37hxEUUTt2rVhMpkcqsMbNmxwaZJZWVmYPXs2fvnlF2RlZSE8PBzPPvssOnbsCOBaq4TXX38dhw8fRkhICMaMGVO0axa4ttX4vffew5o1a2Cz2RAbG4vp06ejfv36RceUNEdJFEVBQkICYmJiakQbhKysrGqzTV3VNKw7no91x2y4+cMgCsDDLb3Qh20R7ggtMwf2tT9Du5qlDwgCDF3vgtihTYl/B09nJePTg+8gT7bqxuv41Mf4yCkI8Kzl6rTpDqhu6xIRVX1cl4jI3XBdIiJ3U5PWJWfqhk4Xa6Ojo1FQUIDly5cjOjq6XIlWJyzWVn2Hr9gd2iIUigwxsi3CHaLZ8iF/txXq2QsOMSkyHFLPuyFIt39fzlvOYMGBWbAU6Iu+tUwhmBD1EoK8ars0Z6p81XVdIqKqi+sSEbkbrktE5G5q0rrkTN3Q6cpTREQEfHx8WKilaudaWwRftApybHtwrS2CBccy5GLOpIokmDxhGHw/pLYtHGLKgWTIX/8EzZZfzJnXhfk2wqTolxHgqe9BfdV2GXMTZuCC9ZxLcyYiIiIiIiIiKguni7UvvfRSUVuBrKyskk8gqkLMniKe6+iDAS1MuPk7nQybird2WbDhZD5U5zakUzkJkgipd2cYurV3iKlnL8C+4gdoWTm3nSPEuy4mxUxHsFeobjy7IBPx+1/D2ewTLs2ZiIiIiIiIiMhZTrdBeOSRR3Dx4kWkp6cDACRJ0m3fFQQBCQkJLk2yKmAbhOqHbRHck3LsDOQN2wFZ0Y0L3iYYBtwHsd7tWxrkFGRhwYFZSLWc0Y17SiaMbvscmge0dnnOVPFqyrpERFUH1yUicjdcl4jI3dSkdalC2yAcPHgQV65cgaZp0DQNsiwjPz9f90NUHRS2RYhgWwS3IrVoBOPQvhC8vXTjWq4N9lU/Qjl66rbn+3mY8bfoaWhsDteN5ys2LDzwFg6l73N5zkREREREREREpeFYhSrBG2+8URF5ELkls6eIZzv6YN3xfKw7ZsON29AL2yI8HG5Cn6aeEKv5t0DuRAwNhnF4HOxrN0O7knE9ICuQv98GLSMH0t2Rt/xmzsvgg/GRU7Dk0GwkZxy4frpqx+JDs/FYy4loX6dLRb8MIiIiIiIiIiIdp4u1gwcProg8iNyWKAgY2MKEFoGSQ1sEVQNWHbXh6FWFbREqmeDvC+OjfSF/vw3q6fO6mPLbn9AysmDofQ8EQ/G3FxS2PViWFI/Ey78XjWuaiuVH58Gm5KJLvd4V+hqIiIiIiIiIiG5UpsqS3W7H4sWLMWLECPTt2xcjR47El19+CUVRSj6ZqIoqVVuEq2yLUJkETw8YBvWEFN3KIaYeOQl5zSZoebduzWIUjRgRMRmxoffqxjVNw9fHFuPns9+4PGciIiIiIiIioltxemdtfn4+Ro8ejT///BOFzyY7ffo09u7di02bNuGTTz6Bh4eHyxMlcgcltkXYzbYIlU0QRUg9O0II9IO8dS9wwzMT1ZQ02Jeth3FwLwiB/sWeLwoihoaPh8ngje0pG3SxDadWwibnIa7Jo9W+2TkRERERERER3XlO76yNj4/HH3/8AYPBgIEDB2LSpEkYMGAADAYDdu/ejfnz51dEnkRuo7AtwnMdfeHvqf8IFbZF+HBvLnIK1FvMQK4mCAKku1rDOOA+wGjUxbTMbNiXrYeacvG25w9o+jj6NH7EIbbl3DqsPvYZVI3vJxERERERERFVLKeLtevXr4cgCFiwYAFmzZqFyZMn46233sInn3wCTdPw7bffVkSeRG4nItjAtghuRmzWAMZH+0Dw9dGNa7Z82FdtgnL4xC3PFQQBvRsNxsDmoxxiuy5sxtKkeCgq308iIiIiIiIiqjhOF2svXrwIX19fdOrUSTfeuXNn+Pr6Ii0tzWXJEbm7wrYIA1uYcPNN8oVtETacsEHVtGLPJ9cTawfBOKwfhNq19AFVhfzDr5B3/AlNvfX70S2sDx5tOQGCoF8eEy7txOLD78OuFFRE2kREREREREREzhdrQ0JCYLFYkJSUpBs/cuQILBYLgoODXZYcUVUgCgIGsC2CWxH8fGAc2hdiswYOMWV3IuQN26HJt94lGxvaHSMjJkMS9bumj6QnYMHBWbDJeS7PmYiIiIiIiIjI6WJtz549oWkaRo8ejTlz5mDt2rWYM2cOxowZA0EQ0LNnz4rIk8jtFbVFCGZbBHcgeBhh6H8fpPatHWLq0VOQv/oRmvXWRdeokI4Y2/Z5GCVP3fjJzCTMT5wJqz3H5TkTERERERERUc0maJpz92dnZWVhyJAhSElJ0T0dXdM01K1bF2vWrEFgYKDLE3V3iqIgISEBMTExkCTpTqdToTRNQ1ZWFsxms+7vAF2jahq+O56Pb4/ZcPOHSxSAweEm9G3qCZG/u0qj7D8KefNu4KblTjD7wjCoF8SggFueezorGZ8efAd5slU3XsenPsZHTkGAZ61bnEmViesSEbkbrktE5G64LhGRu6lJ65IzdUOnd9aazWasWbMGo0aNQt26dWEwGFC3bl0MGzYMq1evrpGFWqIbldQWYTXbIlQ6KboljIPvBzyMunEtywL7svVQz6Te8tzG5nBMjJ4GXw+zbjzNmoL4hFeRnnepQnImIiIiIiIioprH6Z21VDzurKXiZOWrWLA/F0euOLY/CDSJmBDjjRa1HNsmUMVQr2RAXrsZWrZFHxAEGHp1ghQVfstzL+dewPzEN5CZn64b9/cIwPioqajr49gflyoP1yUicjdcl4jI3XBdIiJ3U5PWJWfqhqUq1iYmJsLDwwOtWrVCYmJiiQlERUWVPttqgsVauhW2RXAvmjUP9m+3QLtw2SEmdWgDqWt7CGLx70WG7QrmJ76BK3kXdeNeRh+MbzsFDf2bVUjOVDKuS0TkbrguEZG74bpERO6mJq1LLi/WtmrVCnXr1sWWLVvQqlWr2/4CBUHA4cOHnc+6imOxlkpy5IqMT/bnIjvfsf1BZIgRY6K8HNomUMXQZBnyDzugJp92iInNG8LQtyuEm1omFMopyMKCA7OQajmjG/eUTBjd9jk0D3B8oBlVPK5LRORuuC4RkbvhukRE7qYmrUsV0rP2xpqupmm3/FFV9uEkKk5EsAGvdPVFRLBj24MDl+14dYcFx646tksg1xMMBhjiukPqGOkQU4+fhf2rjdAsucWe6+dhxt+ip6GxWd8yIV+xYeGBt3AofV+F5ExERERERERE1V+pdtaeP38eBoMBderUwfnz50ucNCwszCXJVSXcWUulxbYI7kU5eAzyT7uAm75oEnx9YBjUE2LtWsWel6/YsOTQbCRnHNCfJ4h4rOVEtK/TpcJyJkdcl4jI3XBdIiJ3w3WJiNxNTVqXXL6zNiwsDHXq1AEApKam4sqVKwgLC9P9hIaGIikpCcePHy//KyCqxkRBwIAWJjx/ty/MN7U9UDVg9VEbPtxbfLsEcj2pbQsYh/SGYPLUjWsWK+wrf4B6MqXY8wrbHkSFdNSfp6lYfnQedqRuqrCciYiIiIiIiKh6crpB5siRI/HMM884jEuShClTpuDll192RV5E1V6rILZFcBdig1AYH+sHIcBPHyiww/7NZih/Hin2PKNoxIiIyYgNvVc3rmkavj62GD+f/aaiUiYiIiIiIiKiasixSnQTTdPw3HPP4cqVK0Vj6enpGDVqlO643NxcWCwWKIri+iyJqil/TxHPxvrg++P5+Pa4DeoNfREybCre2m1hW4RKItQywzgsDvK3W6Cev3Q9oGmQt/wOLSMbUo9YCKL+Oy5REDE0fDxMBm9sT9mgi204tRI2OQ9xTR6t9rd0EBEREREREVH5lVisFQQB99xzD/71r38V/dlut+P3338v9vjY2FjXZkhUzYmCgP4tTGhRy4BPEnKRdUP7g8K2CMlXFYyJ8oK/p9Ob4ckJgpcJhiEPQN70G9QjJ3UxJSEJWpYFhge7Q/Aw6s8TBAxo+ji8DT7YeHqVLrbl3DrkyVY83GI0RIHvHxERERERERHdWonFWgB45JFHcOrUKVgsFqxYsQLe3t7o379/UVwQBBgMBtSvXx+DBg2qqFyJqrXCtgif7M/FkSv69gfX2iIoeDLGG+G1SvWxpTISDBIMfbtCCfCHsjNBF1NPpcC+YgOMg3pB8PPRnycI6N1oMEwGb3xz/L+62K4Lm2FT8jCs5URIIt8/IiIiIiIiIipeqasGL7zwAgAgPz8fAQEBmDp1aoUlRVRTldQW4e3dFgwKN6Ef2yJUKEEQYOgcDSHAD/KPvwE3tHfRLmfAvvR7GAb2hBga7HBut7A+MEleWJm8AJp2fZd0wqWdyFfyMCriaRglj0p5HURERERERERUtTh9T+6bb755y0JtVlYWNmzYUGyMiEqnsC3Ccx19Yb6p7YGqAWuO2vDh3lxk39AugSqGFNEUxkcegOBl0o1r1jzYV26EcvxssefFhnbHyIjJDrtoj6QnYMHBWbDJeRWWMxERERERERFVXU4Xa69cuYInn3wSsbGxaN26NSIiIop+OnXqhOeee64i8iSqcQrbIkQEO26AP3DZjhk7LEi+KhdzJrmSGFYbxmFxEGqZ9QFZhrzuFyh7D0HTNIfzokI6Ymzb52GUPHXjJzOTMD9xJqz2nArMmoiIiIiIiIiqIqeLtbNmzcK2bduQk5MDVVWhaZrup1atWhWRJ1GNVNgWYVALE8Sbuh5k/q8twvcnbFCLKRaS6wgBfjA+1g9iw7r6gKZB3rYXyk+7oCmOO53DAyMxIXIqvAz6/rbnck4ifv9/kJl/tSLTJiIiIiIiIqIqxuli7c6dOyEIAl5++WV07NgR7du3x8KFC/HAAw9AEAQ8//zzFZEnUY3FtgjuQTB5wjD4fkhtWzjElAPJkL/+CZot3yHW2ByOidHT4Ouh35mbZk1BfMKrSM+7VGE5ExEREREREVHV4nSxNjMzE4GBgXj88cdx//334/z58+jatStmzZoFDw8PLFmypCLyJKrx2BbhzhMkEVLvzjB0a+8QU89egH3FD9CyHNsbhPk2wqTolxHgGaQbv2q7jLkJM3DBeq7CciYiIiIiIiKiqsPpYm1AQACsVitycnIQFRWFtLQ0nD59GoqiQBAEnD59ugLSJCKAbRHcgSAIkGLbwtC/B2CQdDEtPRP2Zeuhpjrulg3xrotJMdMR7BWqG88uyET8/tdwNvtERaZNRERERERERFWA08Xau+66C/n5+Rg7dizatm0Lb29vPPHEExg0aBBsNhsCAgIqIE0iKlSatggfsC1ChZNaNIJxaF8I3l66cS3XBvuqH6EcPeVwTqApGJNipqOebyPdeJ7divmJM3E883CF5kxERERERERE7s3pYu3zzz+PevXqISAgAAaDAY899hjS0tKQkpICAHj00UddniQRObpdW4SDbItQKcTQYBiHx0EIDtAHZAXy99sg70qEdtMuZz8PM/4WPQ2NzeG68XzFhoUH3sKh9H0VnDURERERERERuStBu7mSUAp2ux3nzp1D06ZNoWkaVqxYgeTkZNx111146KGHKiJPt6coChISEhATEwNJkko+oQrTNA1ZWVkwm80QBKHkE6hCqZqG9Sfy8c0xG9SbPs2iAAwKN6FfU0+IfK8qjJZfAPn7bVBPn3eIia2bwXB/Zwg3tUzIV2xYcmg2kjMO6MYFQcRjLSeifZ0uFZpzdcN1iYjcDdclInI3XJeIyN3UpHXJmbphmYq15IjFWrrTktJlfJKQi6xi2h+0DTFibJQX/D2d3kxPpaSpKpQte6DsT3KIifXrwND/Pghenrpxu2rHsqR4JF7+XTcuCAIGNX8CXer1rtCcqxOuS0TkbrguEZG74bpERO6mJq1LztQNHe+fLsGLL754y5ggCPDy8kJYWBj69euHunXrOjs9EZVRYVuET/bn4sgVffuDa20RFDwZ7Y2WQU5/7KkUBFGE1LMjhEA/yFv3Ajd8D6ampMG+bD2Mg3tBCPQvGjeKRoyImIyvpIXYc3Fr0bimafj62GLY5Fz0ajiwUl8HEREREREREd05Tu+sbdWqla7arWlasX82mUxYsmQJoqKiXJetG+POWnIXJbVFGNjChLhmbItQkdQT52Bfvx2w23XjgskThgE9INYP1Y1rmoZvT36J7SkbHOa6r0F/xDV5lJ+1EnBdIiJ3w3WJiNwN1yUicjc1aV1ypm7o9D3RU6dORZ06dSCKInr06IHHH38cPXr0gCiKqFWrFoYOHYrWrVsjLy8Pc+bMKfOLIKKyEQUBDzU34bmOvjDf1PZA1YCvk22YvceK7GLaJZBriM0awPhoHwi+PrpxzZYP+6pNUA6f0I0LgoABTR9Hn8aPOMy15dw6rD72GVSN7xcRERERERFRded0sdZisSAtLQ0LFy7EvHnz8PLLL2PevHmYN28e0tPT0bx5c3z++ecwGo1ITEysiJyJqBQK2yJEBDu2PTh0RcaMHRYcTZeLOZNcQawdBOOwfhBq19IHVBXyD79C3vEntBu2PguCgN6NBmNg81EOc+26sBlLk+KhqHy/iIiIiIiIiKozp4u1y5cvh6+vLzp37qwb7969O3x9fbFo0SJ4e3vDbDbDYrG4LFEicp6/p4hnY30wONwE8aY7CjJtKt753YLvjtug8jmDFULw84FxaF+IzRo4xJTdiZA3bIcmK7rxbmF98GjLCRAE/fKccGknFh9+H3aloEJzJiIiIiIiIqI7x+lirdVqhcViwa5du3Tju3btgsViQWZmJs6cOYPMzEx4e3u7LFEiKhu2RbizBA8jDP3vg9S+tUNMPXoK8qofoVnzdOOxod0xMmIyJFG/K/pIegIWHJwFm6w/noiIiIiIiIiqB6eLtffccw80TcO4ceMwbtw4vPTSSxg7dizGjh0LQRDQsWNHrF+/HrIso0WLFhWRMxGVQWFbhNZsi1DpBFGA4d5YGHp1Am5qmq6mXoJ9+Xqo6Zm68aiQjhjb9nkYJU/d+MnMJMxPnAmrPaei0yYiIiIiIiKiSuZ0sfZf//oXwsLCIMsyfv31V3z99dfYsWMHFEVB/fr18fLLL+Pq1auQJAnjxo2riJyJqIz8PUX8g20R7hgpuiWMg+8HPIy6cS3LAvvyDVDPXNCNhwdGYkLkVHgZ9A8qO5dzEvH7/4PM/KsVnjMRERERERERVR5B05yvylitVqxevRp//PEHcnJyEBwcjA4dOmDAgAHw9PTEzp07ERAQgIiIiIrI2S0pioKEhATExMRAkqQ7nU6F0jQNWVlZMJvNEG7aJUhVx9F0GfMTcpFVTPuDNsEGjIv2hr+n09/nUCmoVzIgr90MLfumvt6CAEOvTpCiwnXD5y1nsODALFgKsnTjtUwhmBD1EoK8ald0ym6P6xIRuRuuS0TkbrguEZG7qUnrkjN1wzIVa8kRi7VUFWXnq1iwPxeHrzi2PwgwiXgy2hstgxzbJlD5adY82L/dAu3CZYeY1KENpK7tIdyw/fly7gXMT3wDmfnpumP9PQIwPmoq6vo4PsSsJuG6RETuhusSEbkbrktE5G5q0rrkTN2wTNvmLl68iBkzZqBPnz6IiYkBALz55ps4cOBAWaYjojuEbRHuHMHHC8a/PAAxvLFDTNl7CPJ3v0ArsBeNhXjXxaSY6Qj2CtUdm12Qifj9r+Fs9omKTpmIiIiIiIiIKpjTxdpTp05h0KBBWL58Oc6cOYP8/HwAwIoVKzBq1Cjs37/f5UkSUcURBQEPNTfh+Y6+MN/U9kDVgK+TbZi9x4rsYtolUPkIBgMMcd0hdYx0iKnHz8L+1UZoltyisUBTMCbFTEc930a6Y/PsVsxPnInjmYcrPGciIiIiIiIiqjhOF2vfe+89ZGVlYdCgQTCbzQCA/Px8REREIC8vD7Nnz3Z1jkRUCVoGGfBKV1+0DnZse3DoiowZOyw4mu7YLoHKRxAFGLreBcMD9wCifknW0tJhX7oe6qXrDxLz8zDjb9HT0Nis72ubr9iw8MBbOJS+r1LyJiIiIiIiIiLXc7pYu3v3bnh5eeG1116DyWQCAHh6emLRokXw8vLCwYMHXZ4kEVUOtkW4c6S2LWAccj8ETw/duGaxwr7yB6inUorGvAw+GB85BeGB+h25smrH4kOz8celHZWSMxERERERERG5ltPF2vz8fIiiCINBv/tOlmXIsgxV5a3SRFUZ2yLcOWKDujAOi4MQ4KcPFNhhX7sZSkJS0ZCnZMLots8hKqSj7lBNU7EsaR5+S/2pMlImIiIiIiIiIhdyulgbFRUFq9WKt99+GwUFBQCArVu3YtKkSZBlGW3atHF5kkRU+Upqi/DKr2yLUBGEWmYYh8VBDKutD2ga5M27IW/eDe1/X4oZRSNGRExGbOi9Nx2qYc2xRfj57DeVlTYRERERERERuYDTxdp//OMfMBgM+Oyzz5CZmQkAmDhxInbt2gVJkjBp0iRX50hEd8jt2iJk5bMtQkURvEwwDHkAYkRTh5iSkAT5my3QCuwAAFEQMTR8PLrV7+dw7IZTK/H9yeXQ+P4QERERERERVQlOF2vvuusu/Pe//0W7du0giiI0TYMoiujQoQMWLVqEu+++uyLyJKI7hG0R7gzBIMHQtyukzjEOMfVUCuwrNkDLsV47VhAwoOnj6NP4EYdjt5xbh9XHPoOq8f0hIiIiIiIicneO9zeXYNOmTYiJicHSpUuRn5+PrKwsBAUFQZKkisiPiNxEYVuEhftzceiKvv1BYVuECTHeaBnk9LJCtyAIAgydoyEE+EH+8TdAUYpi2uUM2Jd+D8PAnhBDgyEIAno3GgyTwRvfHP+vbp5dFzbDpuRhWMuJkES+P0RERERERETuyumdtS+//DJ69uyJq1evwtPTE7Vr12ahlqiG8PcU8QzbIlQ6KaIpjI88AMHLpBvXrHmwr9wI5fjZorFuYX3waMsJEAT98p5waScWH34fdqWgUnImIiIiIiIiIuc5Xaz19fWFyWRCQEBABaRDRO6uNG0R3mdbBJcTw2rDOCwOQqBZH5BlyOt+gbL3UFFv2tjQ7hgZMdlhF+2R9AQsODgLNjmvkrImIiIiIiIiImc4Xax99tlnYbPZMHHiRHz33XfYvXs39u/fj8TExKIfIqr+CtsitAl2vK3+8P/aIhxNl4s5k8pKCPCDcVg/iA1C9QFNg7xtL5Sfd0FTrhXJo0I6Ymzb52GUPHWHnsxMwvzEmbDacyorbSIiIiIiIiIqJUFz8jHhERERt59QEHD48OFyJVUVKYqChIQExMTEVPu2EJqmISsrC2azGYIglHwCVWuqpmH9iXx8c8wG9abVRBSAgS1MiGvmCZF/V1xGUxQoP++GcvCYQ0xsWBeGh+6FYLpWpD2dlYxPD76DPNmqO66OT32Mj5yCAM9alZJzReO6RETuhusSEbkbrktE5G5q0rrkTN3Q6Z21mqbd9kdVK+bW57Vr1yIuLg6RkZF48MEHsWHDhqLYkSNHMGLECMTExKBHjx749NNPdeeqqooPP/wQ3bp1Q3R0NMaMGYMzZ87ojilpDiIqHtsiVD5BkiD17gxDt/YOMfXsBdhX/AAt69rO2cbmcEyMngZfD337hDRrCuITXkV63qVKyZmIiIiIiIiISuZ0sfbnn38u8cfVvvnmG7z00kt49NFH8d133yEuLg7PPvss/vzzT2RkZGD06NFo3LgxVq9ejcmTJ+ODDz7A6tWri86Pj4/H8uXL8Z///AcrVqyAIAgYP348CgquPWinNHMQ0e2xLULlEgQBUmxbGPr3AAz6b+W09EzYl62HmnqtEBvm2wiTol9GgGeQ7rirtsuYmzADF6znKittIiIiIiIiIroNp9sgVDZN09CrVy/06dMHU6ZMKRofO3YsOnbsCAD48ssvsXnzZhgM14pE7733Hn788Uf88MMPKCgoQKdOnfDCCy9g2LBhAIDs7Gx069YNM2fOxIMPPoj58+ffdo7SYBsEomvYFqHyqRevQF67GVruTQ8OM0gw9OkCqWUTAECG7QrmJ76BK3kXdYd5GX0wvu0UNPRvVlkpuxzXJSJyN1yXiMjdcF0iIndTk9YlZ+qGjlvgSvDiiy/eMiYIAry8vBAWFoZ+/fqhbt26zk7v4OTJkzh//jz69++vGy9sUzB+/HjExsYWFVkBoFOnTpg/fz7S09Nx/vx5WK1WdOrUqSju7++P1q1bY8+ePXjwwQexd+/e284RFKTfjUZEt1bYFqFFoAGf7M9Fpu16+4PCtghHr8oYH+0Nf0+nN/dTMcTQYBiHx8G+9mdoVzKvB2QF8vfboGXkQLo7EoGmYEyKmY4FB2Yh1XK9FUye3Yr5iTMxuu1zaB7QuvJfABEREREREREBKEOx9uuvv9ZVuzVNK/bPc+bMwZIlSxAVFVWuBE+fPg0AyM3NxdixY3H48GHUr18ff/vb39CzZ09cvHgR4eHhunNq164NAEhNTcXFi9d2kN1cOK5duzYuXLgAACXOwWItkfNaBhnw7y6+WLg/F4eu6NsfFLZFeDLGG62CnF6GqBiCvy+Mj/aD/P02qKfP62LKb39Cy8yG4f7O8PMw42/R0/DpwXdwOiu56Jh8xYaFB97CyNaT0SbIsRcuEREREREREVU8p6skU6dOxeLFi3H58mV0794d9erVQ2pqKrZt24aAgAD06tULhw4dwqFDhzBnzhwsWLCgXAlaLBYAwJQpU/DUU0/h+eefx8aNG/F///d/WLRoEWw2Gzw8PHTneHpeewp6fn4+8vKu3RZc3DFZWVkAUOIczih80Fp1duMD5Yhux89DwNMdvLHhZIFDW4SsfBXv/m7BgOYmxDXzYFsEV/AwQhp4H7BlD9TEo7qQevgE7NkWGB7qAZOXN8a1/Sf+e/gDJGccKDpGVu1YfGg2Hms5EXfVvqeysy8XrktE5G64LhGRu+G6RETupiatS868RqeLtRaLBWlpafjss8/QuXPnovFt27bhySefRPPmzTF16lTcfffdSExMdHZ6B0ajEcC1HrWDBw8GAERERODw4cNYtGgRTCZT0YPCChUWWL29vWEymQAABQUFRf9deIyXlxcAlDiHM7KzsyGK1fvWbk3TkJubCwDVvqcIuUbXYCDUqOHzJBVZN3zUFACrk6w4eDEXI1oK8PPg3yeXaN8SoskAw64DwI3/h3AmFfYvvoW9zz2A2RcP1x+LNfIiHMn844aTFXxx6CNczb6C2JB7Kz31suK6RETuhusSEbkbrktE5G5q0rqkqmrJB/2P08Xa5cuXw9fXV1eoBYDu3bvD19cXixYtwqhRo2A2m5GRkeHs9A5CQ0MBwKFNQfPmzfHLL78gLCwMly5d0sUK/1ynTh3Islw01rBhQ90xrVq1KrrG7eZwhr+/f414wBiAGtEAmlynvRkIr6NiYWKeQ1uE4znA+wdEPBnthZZsi+AaXdpDDa0NecN2wH7D79uSB8P3v8LQvwfE+nUwNuA5rDq2EHsubtOdvjF1JQQPoFfDAZWceNlwXSIid8N1iYjcDdclInI3NWldUhSl1Mc6XRWxWq2w2WzYtWuX7qFdu3btgsVigaIoOHPmDDIzM53elVqc1q1bw8fHB/v370eHDh2KxpOTk9GwYUPcddddWL58ORRFKSqS7ty5E02aNEFQUBD8/Pzg6+uL3bt3FxVrs7OzcfjwYYwYMQIAEBsbe9s5nCEIQrX/CwZcf5014bWS6/ibJDwT64MNJ/OxNrmYtgh7rBjYwoS4Zp5si+ACUvOGEB7tC3ntFmgW6/WALR/y6k0wPHAPpNbNMDT8SZgMPtieskF3/g+nVyJfyUNck0erxGed6xIRuRuuS0TkbrguEZG7qSnrkjOvz+n79e+55x5omoZx48Zh3LhxeOmllzB27FiMHTsWgiCgY8eOWL9+PWRZRosWLZyd3oHJZMK4ceMwd+5cfPfddzh79izmzZuHHTt2YPTo0RgyZAgsFgumTZuG48ePY82aNViyZAkmTJgA4Fqv2hEjRuCdd97Bzz//jKSkJPzjH/9AaGgoevfuDQAlzkFEriMKAh5sZsLzHX0RYNIvQaoGfJ1sw/t7rMjOL/0tAnRrYu0gGIf1g1C7lj6gqpB/+BXyjj8BDRjQ9HH0afyIw/lbzq3D6mOfQdX4fhARERERERFVNEFzsovvhQsXMGLECJw/f+1p44IgFG1bbtCgARYtWoQlS5Zg6dKlmDNnDnr27OmSRBctWoQvvvgCaWlpaNasGSZPnoz7778fAJCYmIjXX38dhw8fRkhICMaMGVO0axa4ttX4vffew5o1a2Cz2RAbG4vp06ejfv36RceUNEdJFEVBQkICYmJiakQbhKysrBqxTZ0qVna+ik8T83Dwst0hZvYU8WSMN1qxLYJLaAV2yBu2Qz1xziEmtmwCQ58uEAwStp/fiG+O/9fhmJjanTGs5URIonu+H1yXiMjdcF0iInfDdYmI3E1NWpecqRs6XawFrrVCWL16Nf744w/k5OQgODgYHTp0wIABA+Dp6YmdO3ciICAAERERZX4RVQ2LtURlo2pasW0RAEAUwLYILqSpGpTte6HsO+wQE+vVhqF/Dwg+XthzcRtWJi+AdtNu2oigGIyKeBpGyaOyUi41rktE5G64LhGRu+G6RETupiatSxVerCVHLNYSlU/yVRnzE3KRaXO83T4i2IAno73h7+l05xYqhrL/KOTNu4Gbln/B7AvDoF4QgwKQePl3fJk0F4qqfxhc04BWGNPmeZgMXpWZcom4LhGRu+G6RETuhusSEbmbmrQuOVM3dPp+1o8++uiWMUEQ4OXlhbCwMHTv3h1eXu71j3kicl/htQz4dxffYtsiHLki45VfLWyL4CJSdEsIZl/Yv9sKFFz/XWtZFtiXb4DxoR6IatQRJoMXFh16H3Ylv+iYk5lJmJ84E+Mi/wkfo9+dSJ+IiIiIiIio2nJ6Z22rVq1KVe0ODg7GkiVL0LRp0zInV5VwZy2Ra5TUFmFAcxMebM62CK6gXsmAvHYztGyLPiAIMPTqBCkqHKezkvHpwXeQJ1t1h9TxqY/xkVMQ4HnTg8vuEK5LRORuuC4RkbvhukRE7qYmrUvO1A2dvqd45MiRqFOnDjRNQ4sWLXDvvfeiRYsW0DQNAQEBuOeeexAaGorLly9j9uzZZX0NRDXxpbwAAQAASURBVFRDiYKAB5uZ8MLdvggw6ZcoVQPWHrPhvT1WZOc7tksg54jBgTAOi4NQN0Qf0DTIP+2EvG0fGvm1wMToafD1MOsOSbOmID7hVaTnXarEjImIiIiIiIiqN6eLtU2aNEFaWhrefPNNfPvtt/j444/x7bff4rXXXkNWVhYefvhhfPXVV5AkCXv37q2InImoBihsi9A2xOgQK2yLkJQuF3MmOUPw8YLxLw9ADG/sEFP2HoT83S+o51EPk6JfRoBnkC5+1XYZcxNm4IL1XCVlS0RERERERFS9OV2sXbhwIXx8fDBo0CDd+F/+8hd4eXnhww8/RHBwMAIDA5Gdne2qPImoBvL3FPF0B28MaWmCeNMdEVn5Kt793YJ1x2xQ+ZzEchEMBhjiukPqGOkQU4+fhf2rjQhWzZgUMx3BXqG6eHZBJuL3v4az2ScqK10iIiIiIiKiasvpYm16ejqsViuSk5N148nJybBarUhLS0N6ejqysrLg4eHhskSJqGYSBQFx/2uLEMi2CBVGEAUYut4FwwP3AKL+96ylpcO+dD3M2SImxUxHPd9Gunie3Yr5iTNxPPNwZaZMREREREREVO04XayNiYmBpml4/PHH8e9//xtz587F9OnTMXz4cAiCgDZt2mD16tWw2+015uFiRFTxwmsZML2LLyLZFqFCSW1bwDjkfgie+i/bNIsV9pU/wOd8Dv4WPQ2NzeG6eL5iw8IDb+FQ+r7KTJeIiIiIiIioWnG6WPvSSy/B398fOTk5WLlyJT766CN89dVXsFgs8Pf3x8svv4yrV68CAIYNG+byhImo5vL3FPF3tkWocGKDutcePBbgpw8U2GFfuxkeB89hfOQUhAfq2ybIqh2LD83GH5d2VGK2RERERERERNWHoGnOVzUuXryIxYsXY9++fcjOzkZISAjat2+PESNGICQkBBs2bIDJZMJ9991XETm7JUVRkJCQgJiYGEiSdKfTqVCapiErKwtmsxmCIJR8AlEFSL4q45OEXGTYHNsfRAQb8GS0N/w9nf4+im6g5dkgf7MFauolh5gU0wpq93ZYnjwPiZd/18UEQcDg5n/FPfXur6xUuS4RkdvhukRE7obrEhG5m5q0LjlTNyxTsfZ2du7cic6dO7tyyiqBxVqiypedr+KzxDwcuGx3iJk9RTwZ441WQYY7kFn1ockK5E2/QT1y0iEmNqkPMa4rVp1egj0XtzrE45o8ip4NB1RGmlyXiMjtcF0iInfDdYmI3E1NWpecqRu6ZNvZ1atXsWDBAvTp0wdjx451xZRERCUqTVuEb9kWoVwEgwRD366QOsc4xNRTKVBW/oi/1B2ObvX7OcTXn1qB708uh4u/EyQiIiIiIiKqtsq15ey3337DihUrsHnzZsiyDE3Tqn0lnIjciygIiGtmQvNAg0NbBFUDvjlmQ3KGzLYI5SAIAgydoyEE+EH+8TdAUYpi2uWrkJdtwEMD+8K7sQ82nl6lO3fLuXXIk614uMVoiAJ//0RERERERES343SxNj09HatXr8ZXX32FlJQUANe2LXt4eODee+/Fgw8+6PIkiYhKEl7LgOldfItti3DkioxXfrWwLUI5SRFNIfj7Qv52C7Q8W9G4Zs2FvHIjesZ1g6m5N745/l/debsubIZNycOwlhMhifz9ExEREREREd1Kqf/V/Ouvv2LlypXYvHkzFEXR3dYqCAK2bNmCoKCgCkmSiKg0Ctsi/HAyH18n26DecPd9YVuE/s1NeKi5J0TeBVAmYlhtGIfFwf71z9Aysq4HZBnyul9wT7f2MLV8EiuTF0LTru9yTri0E/lKHkZFPA2j5FH5iRMRERERERFVAaW6J7VXr14YP348Nm3aBFmWERQUhDFjxuD7778vOsbb27vCkiQiKq3Ctgj/vNsXgSb9ElfYFuG9PVZk56u3mIFKIgT4wTisH8QGofqApkHethftDnpgZMunHHbRHklPwIKDs2CT8yoxWyIiIiIiIqKqo1TF2vPnzwMAPD09MWPGDPw/e/cdH0Wd/3H8NdvSCwm9I6jYUUBRz4blsJxnA7t3IpzlLKc/5dQ7C7Y7FVFPFLGX01NQbGA/21kRFbGjFBVCS69bZ35/THazu9kkm5CQTfJ+Ph577M7OTGZz+GXz3k8+n3fffZcZM2YwcuTIDr04EZG22rbAxTW/yWaXPu5Gz4XbInxfEuyEK+sejPQ0XMcdgnOnUY2eCy1fwQ7/q2DqthfhdqbFPLeq/HvmLb+JmkDV1rpUERERERERkS4jqbDW5XJhWRY+n4/rr7+e8847j1dffRW/39/R1yci0mY5Hrstwgnbp+OI63oQbovw4o9ezKi2LpI8w+nEedg+uPYb2+g585f1jHjtV/404kIyXFkxz/1atYp7vryBcl/p1rpUERERERERkS4hqbD2f//7H5dffjmjRo0iGAzy7rvvcvHFF7PffvtF9jHU/1FEUpDDMDhcbRE6jGEYOMfvjOt3B4LLGfOcVVLOoJd+4OwB55DtyYt5bmPNWu5Zdh0ldZu24tWKiIiIiIiIpLakwtpevXrxxz/+kZdeeon58+czefJksrKyqKhoGC5z+OGH889//pNly5Z11LVKqrAsPA88ACtWdPaViCRNbRE6lnPbYbinTMLIzIjZbtV66bPoW87J+SP5abFDKEu9m7l72UzW1/y6NS9VREREREREJGUZltW23//1er28/PLLPPvss3z22Wf2yQwDwzD49ttv2/Uiu4JQKMSyZcsYM2YMTqez5QO6MOuTTwidcw5OpxNj111h8mQ4+GDwaMK7pD7TsnhtlY+FK7yYcaufw4DfjUrnqFFpOPTbAm1iVVYTeP6/WMXljZ6rnDCCB10vUFy3IWZ7hjuL6Tv/laG5be+DblkWFRUV5OXl6Tc9RCQlaF0SkVSjdUlEUk1PWpdakxsmVVmbSHp6OscddxxPPPEEr776KmeddRaFhYW0MfuVruSFFxruL18OV10FRx0F99wDGzY0fZxIClBbhI5l5GbjPvFwHMMHNXou9+PVnF1yGAMzh8ZsrwvUMG/5TfxU3vM+6BMRERERERGJ1ubK2kRCoRDvvPMOBx98cHudssvoUZW1NTXUPvssmYsXY6xcGfukwwH77QdTpsD48fZjkRRV5Td58Ms6vtocaPRcXpqDP43JZHShqxOurOuzTJPQ20sIfflDo+d8g/N5bJvPWFMTu364HG5O3/ECdipsPLCsxa/Xgz6RFZGuQeuSiKQarUsikmp60rq0VSprE3E6nT0yqO1xMjMJHH00/Oc/cN99cNhhEP6LZprw7rvw5z/DnDmde50iLcjxOLhwXCYnbJ+OI+7fhQqfyW1LqnnxRy+mfmOg1QyHA+fEvXAdMB7i/tFNW1vOH7/ame0yt4/ZHjQDPPLNHXy+6YOteakiIiIiIiIiKUNlj9J2hgF77AE33QSLF8M550Dfvg3PH3JI7P4KvCQFqS1CxzEMA+fYHXEffRC4Ywe7ucvqOO3TkeySvlPMdssy+c/3c/mw6M2teakiIiIiIiIiKUFhrbSP3r1h2jR48UW45RZ76NiOO8bu8/zzMHUqvPoq+P2dcpkiTdm2wMU1v8lmlz7uRs99Vxzk2ver+a442AlX1vU5Rg7BfeJvMbKzYrY7vUGmfDSYcc5dYrZblsXCHx/mrV9e3JqXKSIiIiIiItLpFNZK+3K5YOJE+OtfY7dbFixYYA8k+/vfNZBMUlIybRFeUFuENnH0LcR98uEYfQtit5sWxyzpz77BXRod8/Lqp1m86ikNrhQREREREZEeQ2GtbB0VFRCMqkosLYWHHoKjj4ZLL4UlS9QmQVJCpC3ChMZtESzgxR+9zF5SQ4XaIrSakZOFe8okHCOHxG7H4PAv+3NI5a72NznK27++xLM/PoRp6fstIiIiIiIi3Z/CWtk68vPh6aftgWSHHho7kOydd+C88+D44+2hZbW1nXmlIgBs26uZtgglaovQVobHjet3B+EcG9smxcDgoB/7c9TmXe11IcrH69/iye/vIWTq+y0iIiIiIiLdmyuZnY444oikT2gYBosXL27zBUk3Fh5ItsceUFwMzz0HCxfC5s3287/8AnfcYYe5mZmdeqki0NAW4bXVfhb+UIcZVfVZWd8W4XfbpvO7UWk4DKPpE0kMw2HgOmA8Rn4uwbc+iamq3/vX/qR5d2PhoC+xnA2fJy7b9BG+UB1n7HARbqenMy5bREREREREpMMlFdauWrUKwzCS6htoKLCQZPTuDdOnw5lnwnvvwfz5sHQpHHyw/Vy0FStgxIhG0+RFtgaHYXD4NmmM6uVk3he1lHkbqj7DbRF+LA0yfUwmeWn6ZYXWcO62PUZeNoFF74I/ENm+x+YBeHwwf/hyQu6Gf1O+K1nG/V/fzNSdLiXdldEZlywiIiIiIiLSoZIKa2fPns0NN9xAWVkZY8aMYd999+3o65KeIjyQbOJEWLWqoT1CmN9vt0hwOOCYY+xWCf36dcqlSs8Wbovw4Jd1fLU5EPNcuC3Cn3bLZIfeSS2rUs8xfBDukw4n+Px/sSprItt3rhxA2gqDJ0YuIxDVO3hV+ffMW34T03aZQZY7pzMuWURERERERKTDGFaSY7Z//PFHTjzxRACeffZZRowY0aEX1tWEQiGWLVvGmDFjcMYHjt2MZVlUVFSQl5fX8ZXUL78MV1/d8NjhgP33hylTYPx4u7WCyFZkWlbCtggABqgtQhtZNXUEXngLa0NxzPafPZt5bJvP8GbFVi33yxrM9F3+Sn5agX381lyXRESSoHVJRFKN1iURSTU9aV1qTW6Y9O/sbrvttlx88cXU1tYye/bsLb5IkaSMGNH0QLITTrAHklVVdeolSs8SboswY0I2vdJjl9BwW4TZS2qo8JmJTyAJGVkZuKf8Fsd2w2O2D/P34ayVe5FVEYrpbbuxZi33LLuOjTXr+Gzj+zz27Z08suI2Hvv2Tj7b+D4BM4CIiIiIiIhIV5N0ZS2A3+/nqaeewuFwcOqpp3b71Ls1VFnbwTZvtgeSPfdcw0CysPR0OOkkOP/8rXMtIvWq/GbCtggAuWkOtUVoA8u0CH34BaElX8VsL3ZV8uDgD6jsZdgV9kBdsJZyXwluh8cuazYBBzhx0idzAKfveAE7FY7d+i9CRISeVSkiIl2D1iURSTU9aV3qkMpaAI/HwxlnnMFpp53W5DcxGAy25pQiyenTB/70J3jpJbj5ZhgbFcB4vWqHIJ0ix+PgwnGZnDA6A0fcX8FKn8ltS6p54UcvZvKfifV4hsPA9Zs9cB22TySUBegdzOXsX/enYLMFwRB1wVo2163HF6rDG6ol151Pr7Te9E7vR7Ynj02167hn2Q18U/JZJ74aERERERERkdZJKqy9//77kzrZsmXLOOaYY7bkekSa53LBwQfDvHkwf77duzYnxx48Fm3zZrjnHtiwoXOuU3oMtUXoGM6dt8V9/CEYaZ7ItvxQFmcXHUSfTQYltRswrRBOw65ctoNbLwBuh5teaX2oC1bz+Ld3qSWCiIiIiIiIdBlJhbW33XYbc+bMafL5uro6brzxRk499VRWrlzZbhcn0qxttoEZM+C116B//9jnnnsOHnoIjj4aLr0UliyJ6Xcp0t627eXimt9ks0sfd6PnvisJcu371XxbrNCwNRxDBuA++QiM/JzItmwznQmVI7FCIRyWAwMDyzQxQ0FKatezseJnyqo3UhusJt2VxabaIpZv/qQTX4WIiIiIiIhI8pJug3D33Xcza9asRts/+OADjjrqKP79738TCoW6fY8JSUEeT+xj07TbJYTvhweSHX+8BpJJh2qpLcLsJTVqi9BKRkEe7pOPwDGwb2TbyvSNpJtuMoJOrEAQgiaETDBN/CEf1f5KSqs3UFq7kUp/GY9+cwfPrHiQj9e/xdqq1QRVaSsiIiIiIiIpKqnJN/vssw8ffvghDz74IF6vl7///e9UVlZy00038cILLwB2U+BddtmFv//97x16wSItcjjsqtrnnoOFC6G42N7+yy9w221w991wxBEweTJsu23nXqt0O+G2CKN6OZn3RS1l3ob2B+G2CCtKg/xpTCZ5aa1qG95jGRnpuE44jOAbH2J+t4oahxfDggJfBqWeOuqcgcZ9qy2wQiFwQLmvhI/XvwXr7aecDhcDsoYwOHsEg7KHMzhnBP2zhuB2NK6KFhEREREREdmaDMtqucQrEAgwY8YMXnnlFQzD4MADD+Srr76ipKQEy7Lo3bs3F198McfH9w3tQVoz1a2r61LT+oJBu7J2wQL4LMGgoVmz4MADt/ZVSQ9R7Td54Ms6vtrcuJIzN83B9N0y2LG3AsJkWZZF6OPlPPrDXfwv+1sKfJkAVHq8VLv8WPHLkQUhR4ictF4UZvRr9txOh5P+mUMYnDOCwdkjFOCKyBbrUu+XRKRH0LokIqmmJ61LrckNk6qsdbvd3H777RQUFPDEE0/wzjvvYFkWLpeL008/nT//+c9kZ2e3y8WLtCuXCw45xL6tWgXPPAOLFkFtrT2YbMKE2P1NM2YCvciWyK5vi/Daaj8Lf6jDjPpoLNwW4XfbpvO7UWk4uvk/TO3BMAxce+/GzmV78kHNdwSNEC6c5AbSyQ6kEXCECDhN/I6Qfd8IgWWQbnpaPHfIDLGueg3rqtfwCW8DCnBFRERERERk60sqrA276qqrKCgo4K677sIwDPbZZx8uu+wyHAq3pCsIDyQ7/3xYvBgCAUhPj93nhhugshKmTIHx4xv/arVIK4XbImzby8m9aovQLnYNbkNvfzab06rI92dgYODAIM10kVb/7bWwKPPUketP54jiXdg0Ip11zs2UWOU0aijchEQBrsNw0j9rcCS8HZw9ggHZQxXgioiIiIiISLtIqg1CvKeffpqZM2diWRaHHXYYs2fP7va/+t8StUHoBsrK7F62gfpfWR82DE44AY46yq7CFdlC1X6TB5fXsXyT2iJsCf/8V/nm5/e5f/iH1BlecgJpuKyGdTdghKh2+8gIupn+457s4B+K0SsXgDrDz/peXooKvKzLrKTIVUKxVbZFFfXhADfc/3Zw9ggGZg3F7Wy5oldEuq9u+35JRLosrUsikmp60rrUmtwwqbD2iCOOaLStqKgIr9eLYRj079+fjIwM+4SGweLFi9t46V2XwtpuYNkyuPzyhoFkYenpGkgm7ca0rIRtEQAMUFuEJAReeofQp1/zff9K/lP4PpudlZg0VCw7LIPevixO/nl3dijrDZkZGPlNf+DiNfysz61jXaGXdVlVrHOVUMKWBbiG4WiowK0PcQdmDVOAK9KDdNv3SyLSZWldEpFU05PWpXYPa0ePHp30FzcMg++++y7p/bsLhbXdRHgg2fz58PnnjZ/fbTe7RcKhh6q3rWyRn8qCzPuiltKotghhowtdaovQjNC3KwnMfw0y0wm54KvMX/g27VeqqSMr6GbH8n7sUtoXV8gA04JeuRgZaa36Gl4jwPqcGooKfKzLtgPcYsrAuYUBbuagSPXtoOzhDMwehsfZumsTka6hW79fEpEuSeuSiKSanrQutfuAsfPPP79dLkwk5cUPJFuwwO5vW1trP//ll3ZP28MO69zrlC5vVC8X1/wmO2FbhO9Lglz7frXaIjTBsd1wjIJcrJIKnLlZ7F47gt1rRxAKhex/9Jxg9bagvAojKwPH2B2xisuxNpdCMJTU10i33IyozGdEJUA/YBQ+I0BRVjXrC32sy65mnbuEza0IcC3LZH3Nr6yv+ZVPeQ+wA9x+mQNjeuAqwBUREREREem52tSztjl+vx+Pp+f9mqcqa7uxmhp4+WU7uF21yh5SNmVK7D5ffw077aSBZNJqLbVFOGpUOkdvq7YI8cyVvxKY/yqW1w9ZGRguZySstYIhqKnDSPfgnjIJx8ghAFimiVVagbWpFGtTCdbGEsxNZQ19qtvAZwQoyqhife9wgFtqB7iuLavA7Zs5sL59wjb1Ae5Q0pzpLR8sIimjx71fEpGUp3VJRFJNT1qX2r0NQtj69espLS1lxIgRZGZmNnr+3Xff5frrr+fNN99s/VV3cQprewDLgi++gO23h6yshu0rVsApp9gDySZPhiOP1EAyabWW2iJM3y2T/HS1RYhmrvyVwOJ3sUorwTSxLMtekxwOjIJc3EceEAlqm2KZFpRXYoYD3E2lWBtLsHz+Nl+XzwiwPqPSbqGQU02Rp4zNlGE5HXYC3wbhAHdQ9nCG1FfhDswaSporo83XKSIdq8e+XxKRlKV1SURSTU9al9o9rK2urmbGjBm8/fbbAGRkZHDVVVdx7LHHAlBSUsLMmTN54403ANSzVmFtz3LjjfDccw2PNZBM2qjabyZsiwCQm+ZQW4QErGAIc8UazJ9+wVdRRVpeDo5RQ+1WCa62rcWWZUFFdeMAt87b5uv0G0HWp1WwrsBLUU4N69JK2WyEA9y2raOGYdAnY2B9+wR7iNmgrGEKcEVShN4viUiq0bokIqmmJ61L7R7W3nTTTTz22GMx21wuFy+88AJlZWVccMEFlJeXY1kWBQUFfPjhh1v2CroghbU92LvvwhNPND+QbOJEcCtkk5aZlsXrq/08q7YIrdLR65JlWVBdW986ISrEra5t8zn9RpD1nnKKCrysy6mhKK2MTUYZlmtLA9wBMUPMBmcPV4Ar0gn0fklEUo3WJRFJNT1pXWr3sPbQQw9l7dq1nHjiiey333785z//4YMPPuCYY47h9ddfp6amBoAjjjiCv//97xQUFLTPK+lCFNYKK1fafW1ffrlhIFlYQQFccglMmtQ51yZdjtoitE5nrUtWTR3WphLMjVEBbmV1m88XDnDX53tZl1fDOk8ZmxxbHuD2zugfM8RsUPZw0hXginQovV8SkVSjdUlEUk1PWpfaPazdbbfdcLlcLF26FMMw2Lx5M/vttx+GYWBZFr1792bmzJkcfPDB7fYiuhqFtRJRUwOLF8Mzz9gDycL+9S/YZ5/Ouy7pctQWIXmptC5Zdb7IEDNzY32AW17Z5vP5jSAb3OUU5ddRlFvDuvRyNhqlWC4nONr+Wntn9I+Et0NyRjAoe4QCXJF2lErrkogIaF0SkdTTk9al1uSGrmRO6PP5yM/Pj3zjCgsLI89NmDCB22+/nV69em3BJYt0I1lZduuDyZPt1gjz58NPP8GECbH7LVlih7lHHQXZ2Z1zrZLSsj0OLhibmbAtQqXPZPaSGrVFSEFGRhrGsAEwbADhf4Itnx9rcynWxlLMcAVuaYU9uLAFHsvFUH9vhm4CNtnbAgTZ4ClnXW4tRXk1rEuvYJOjFNPlAEdyFdfFdRsortvAsk0fRbbZAe7w+ircbRiUPZwMV+OBoiIiIiIiItIxkgprgZiE21H/g6DT6eSOO+4gPz+/3S9MpMszDBg71r4FAo0DlEcesQPbOXM0kEya5DAMJm2TxqhezkZtESzgpZ+8/FgWVFuEFGekeTAG94fB/RsCXH8Aq7gsMsDM3FSCVVyeVIDrxsUQf2+GFAPF9rYgIbsHbk416/JqWZdewUZHqd1CwdnaAPfjyLZwgDsoe0R9iDucDFdW674BIiIiIiIikpSkw9pECgoKFNSKJCN+uNj69XZQC+D1wsKF9m3MGLsq96CDNJBMYozq5eKa32QnbIvwfUmQmR9Uqy1CF2N43BgD+8LAvpFtVjDUEOBuqh9mtrkMQqEWz+fCyRB/IUNKCqHE3hYkZLdQyK6yA9zMCjY4yrBcBiTZsidRgFuY0S/SAzc8xCzTrd8QEBERERER2VJJ9awdPXo0LpeLoUOHRratWrWq0TawK3AXL17c/lea4tSzVlpt1Sp7INnixYkHkh17LBx/PPTtm/h46ZFMy6pvi+DFjFu+DeixbRG687pkhUJYJRUNA8w2lWJuKoVgsE3niwS4mZUU5dfZAa6zDNNpgKvt/34VZPS1A9zIIDMFuNKzded1SUS6Jq1LIpJqetK61O4DxkaPHp30FzcMg++++y7p/bsLhbXSZk0NJAO78m3RIujTp3OuTVLWT2XBRm0RwrYvcPGnMT2rLUJPW5cs08Qqq8QKDzCrr8LF33gYXTKChNjormBdRkVUgFvfA3dLAtz0PpEhZuE/FeBKT9HT1iURSX1al0Qk1fSkdandB4ydf/757XJhIpJAooFkb78Npmn3u40Pak0z6QFC0n011xbhh1K1RejuDIcDozAfCvNhx5EAWKYFFVV279uNpQ2VuF5fi+dz4WRQoIBBgQKotLc1BLjlFOXVUZRZyQZXGSEn4HLZpdwtKPVuptS7meWbl0S2FaT3sVsnRIW4We6c1n8TREREREREuqGkKmtbo7q6muwOmmy/evVqjjvuOK666iqOO+44AL777jtuvPFGvv76a/Lz8zn99NM566yzIseYpsmcOXNYsGABlZWVjB07lmuuuYZhw4ZF9mnpHMlQZa20q02b4PnnYeedYZ99GrabJpx2mr19yhQYNarTLlFSg9oi2LQuJWZZFlRW271v6weZWZtKsGq9bTpfkBCb3JWsSytjXX5tfYBbTsiFXYHbxu99r/TeDM4ewaCc4QzOHsGQnG0U4EqXp3VJRFKN1iURSTU9aV1q98raZCxfvpynn36aV155hc8//7y9ThsRCAS49NJLqY3q7VlWVsaZZ57JIYccwsyZM1m2bBkzZ84kPz+f448/HoB77rmHp556in/84x/069ePW2+9lenTp7No0SI8Hk9S5xDZ6vr2hT/9qfH2jz+GFSvsmwaSCeAwDCZtk8aoXs5GbREs4KWfvKwoDfa4tghiMwwD8nJw5uXAtvaHlJZlQXVtfe/b+urbjaVY1TUtns+Fk4GBXgwM9GJ8tb0thMlGdwVFnjJ7iFlWJRvc5YRcVn0Fbstvusq8xZR5i/mq+NPItvz0wpj2CYOzR5DtyW3bN0JERERERKSL2KKwtrq6mhdeeIH58+ezYsWK9rqmhO666y6ysrJits2fPx+Px8O1116Ly+Vi5MiR/Pzzz9x///0cf/zx+P1+HnroIS677DIOOOAAAG6//Xb2228/3njjDY488sgWzyGSUjZsgMzMhoFky5bZNw0k6/HCbREeWl7Hl2qLIM0wDANysjBysnCMHBLZbtXUxQa4m0qwKqpbPJ8TRyTAHVef90YCXHcZRXk1rMuuYr2rzK7AdScX4JZ7Syj3lvB18dLItvy0wpj2CYOyh5PjyWv190BERERERCRVtSmsXbZsGU8//TSvvvoqXq+XcCeFgoICJk2a1K4XCPDpp5/y9NNP8/zzz3PggQdGti9dupTx48fjcjW8jAkTJjBv3jxKSkpYt24dNTU1TJgwIfJ8bm4uO+64I59++ilHHnlki+coLCxs99cj0mbHHQe//a09kGzBAli92t5eWgoPPggPPwwHHggnnQR77NGplypbX7bHwQVjM3l9tZ9n4toiVPpMZi+p6TFtEaT1jKwMjBGDcIwYFNlmeX2R/rdmOMAtq2zxXNEBLvWfLYUw2eSuYJ27jKLcGoqyqyhylzW0UEiiF3e5r4RyX2yAm5dWEFuBmzNCAa6IiIiIiHRZSYe1VVVVvPDCCzz99NP89NNPAJGQ1jAM7rnnHvbff/9279daWVnJjBkz+Pvf/86AAQNintuwYQPbbbddzLa+9VWFRUVFbNiwAaDRcX379mX9+vVJnUNhraSc5gaSmSa89Rbk5Sms7aEMw+C326QxUm0RpB0Y6WkYwwbAsAGE/3W3fH6szXbrhEgVbmkFtNAC34mDAYFeDIgKcE1Muweuu5R1OdUUZVez3l1G0GXZFbhJBLgVvlIqfKV8U/JZZFteWkGjIWa5nvw2fhdERERERES2nqTC2ssvv5xXX30Vn88XCWh33nlnjj/+eGbOnAnY1agdMVjr2muvZcyYMfzud79r9JzX68Xj8cRsS0tLA8Dn81FXVweQcJ+KioqkztFalmXRzjPbUk74NXb319kl7LGHfdu0CZ57zr6VlMAJJ8QGJ7W1UFSkgWQ9yMh8J9f8JpsHl9eyfFMw5rkfSoPMfL+Ks3bLZKfe7da6vFNpXdqKPG6MQf0wBvUjHKVagaAd4G6KupWU2x8gNcOBg/6BfPoH8hlbC2ysD3BdlazzlFKUVcW6nGrWe8oJuCwMlwucyQe435Y09NDP9fSKtE6we+AOJzetV9u/DyIt0LokIqlG65KIpJqetC615jUm9VP6888/D0B6ejonn3wyxx13HNtuuy1AJKztCM8//zxLly7lpZdeSvh8eno6fr8/Zls4YM3MzCQ9PR0Av98fuR/eJyMjI6lztFZlZSWOJCqBujLLsiKD3rr7tL4uIy3Nbn1wwgk4v/iCUL9+UP+BBID7uedI+9e/CO26K4Hf/57gfvtpIFkPccZIi3fSLV5aY2FG/dtQVge3fVzJoUMNJg01unxbBK1LKSArDUYMsG8AoRBGaSVGcTlGcTmOknKM0koIhVo8VZ9QDn18OYypAjaAiUWxu5J1njLWZVZGBbimPcQsiQC3rK6YsrpivtrUMMQs253HwMyhDMgcxoCMIQzIHKYKXGk3WpdEJNVoXRKRVNOT1iWzhUKWaEmXVBmGgc/n47333qN379706tWL3r17t+kCk/Xss89SUlIS06cW4JprruHBBx9k4MCBbNq0Kea58ON+/foRDAYj24YOHRqzz+jRowHo379/s+dordzc3A6pME4l4U8D8vLyuv1/TF3SIYfEPrYsePllcDpxfvMNnm++gcJCOOYYuweuBpJ1e8fkw84Dg8xbVkeZN/YfiP+ug7V1LqbvltGl2yJoXUpRBQUQVdBvhUys0gq79+3G+hYKm8sgGGz6HIATGGAWMMBbwDgvUGoHuJtdlRR5SlmXUcG6nBrWp5Xjd5l2Ba6r5X+L68xqVlZ/y8rqbyPbcjx5DMqOHWKW5+mlv1fSalqXRCTVaF0SkVTTk9alUBJFK2FJhbV33303zz77LO+99x4rV65k1qxZ3H777eyzzz5tvshkzJo1C6/XG7PtsMMO48ILL+SII45g8eLFPPXUU4RCoUhA+tFHHzFixAgKCwvJyckhOzubTz75JBLWVlZW8u2333LaaacBMH78+GbP0VqGYXT7v2DQ8Dp7wmvt8kzT7m8bPZCspCR2INnkyTBuXFIT2qVr2rbAzczfOHloeR3LNgVinvuhNMh1H9YwbbcMdurddSuutS6lPsPlhL4F9m1n+zd0LNPCKquwg9uNJZFhZvgDzZ7LgUG/YB79gnnsXguU1FfghlsopFewLreG9Z5yfC4Tw51cgFvlr+D70mV8X7ossi3bk9doiJkCXEmG1iURSTVal0Qk1fSUdak1r8+wWtE0obi4mIULF7Jw4ULWrFkT88WOPPJIjjjiCH7zm9806gHbnrbffnv+8Y9/cNxxx1FSUsLhhx/OxIkTmTZtGsuXL+faa69l5syZHHvssQDcfvvtPPXUU9x0000MGjSIW2+9lbVr1/LSSy/h8XiSOkcyQqEQy5YtY8yYMT2israioqJHfPLRrVhW44Fk0YYPh+uvhx126JTLk63DsizeWONnwfdezLjl3wCOGpXO0dumdbm2CFqXuhfLtKCiCnNTqV2FGw5yva3vJW8HuFV2gJtWTlFuDUVpZfhclh0eu1z2X/5WsgPc4TEhbl5agf7+SYTWJRFJNVqXRCTV9KR1qTW5YavC2mhLly7lmWee4bXXXqOuri7yTc3OzubTTz9t4ei2iw5rAZYvX86NN97It99+S58+fZg6dWqkahbsb8bs2bNZuHAhXq+X8ePHc/XVVzN48ODIPi2dIxkKa6VLCQ8kW7jQrrIFu4ftyy9DLw3c6QlWlgWZt6yWkrrGfXO2L3DxpzGZXaotgtal7s+yLKiqwQy3TwgHuLV1rT6XiUVJfYC7Lq2copwqitIq8LmjWii04e9Rtju3YYhZfYCbn1aov5M9lNYlEUk1WpdEJNX0pHVpq4S1YTU1NSxatIhnn32W5cuXYxgG33333ZacsktSWCtdUjBoV9kuWAD9+8N118U+/+yzkJMDBx2kgWTdUI3fTNgWASA3zdGl2iJoXeq5rOpau3XCxqgq3KqaVp/HxKLUVWUPMfOUsi6nmqL0ivoWCuEK3Nb/3cpy50SC23CI2yutt/6e9gBal0Qk1WhdEpFU05PWpa0a1kZbsWIFzz77LFdccUV7nbLLUFgrXV4waIcRYV4vHH44VFXZA8mOPVYDybqh7tIWQeuSRLNq6rA2l9ptFMKVuBVVrT5PJMB12wFuUXY1RRkVeN2h+gpcFzha//ct053dqAeuAtzuR+uSiKQarUsikmp60rrUaWFtT6awVrqd11+HK6+M3eZwaCBZN9VcW4Tt6tsi9Erhtghal6QllteHtbkUa2Mp5qYSrI2lWOWVdj/vVrAD3GrWuUsp8pRRlFXFuswKvK5QwxAzR+v/W8l0ZzMoezhDIgHuNgpwuzitSyKSarQuiUiq6UnrUruHtQcffHDSX9wwDN58882k9+8uFNZKt2NZ8Nln9kCyd95pPJBsxAg7tD3ySMjK6pRLlPbVXFuEHI+D6WNSty2C1iVpC8sfsAPcTaX1vXBLsEoqWh3gWliUOqvt9gmeMoqyKinKqKTOHbQrcN2uNgW4Ge4sO7iNqsItSO+jv+NdhNYlEUk1WpdEJNX0pHWp3cPa0aNHJ/3F1bNWYa10Q4kGkoUNHWr3ttXfhW6hpbYIR45K5+hRaTjb8KvfHUnrkrQXKxDEKi6rH2JWYoe4xeWNP7Bq6TxYlDlr6gPcUtZlNgS4uF12iOtse4A7KHt4JMQtTO+rv/cpSOuSiKQarUsikmp60rrUmtzQ1eyz9f7xj380+dx///tf3nzzTQzDwLIsRo0a1bqrFZHU17cvnH02TJ1qV9kuWACff24/N2lS46DWNNtURSadzzAMDhuRxsh8Z6O2CBaw6CcvK0qDKd8WQaStDLcLY0AfGNAnss0KhrBKyuMC3DIIhpo+DwYFoWwK6rLZpW4oVMQHuGUUpZezLquSOncIXC57kFkLb9zqAjX8WPY1P5Z9HdmW4cqKDC8bXP9nYXq/bv+GV0RERESkO2pzz9qioiKuu+463n33XSzLIj09nfPOO4+pU6ficiWVAXcrqqyVHuenn+CZZ+Css6BPQ6jBhg12qPv739tDyTSQrMvqSm0RtC7J1maFTKzSCrt1QjjE3VQGgcb/vTR7nvoAt8hjDzFbl15OUWYltdEVuK7Wv69Id2VGAtwh9ZW4hRn9cBj6kGVr0bokIqlG65KIpJqetC516ICxYDDIQw89xNy5c/F6vViWxYEHHshVV13FoEGDtujCuzKFtSL17r4bHn7Yvh8eSDZlCowdq1YJXVBXaYugdUlSgWVaWOWVWBujA9xS8Plbdx4syp21rPOUUuS2A9x1WfUBbrgCtw0fjKe5MuzK26geuApwO47WJRFJNVqXRCTV9KR1qd3bIIR98sknXHfddaxatQrLsujfvz9XXnklhx122BZdsIh0IxUVdkhrmvbtrbfsmwaSdUlqiyCSPMNhYBTkQUEe7LANYL8BpaIac1MJ1sbS+krcEqw6X9PnwaBXKItedVnsXDcEKu0At6I+wF3nLqUozQ5wa9yB2ArcZt7k+oJ1rCz/jpXlDbMF0lwZDMoeFhPg9s7orwBXRERERKSTJFVZW1JSwj/+8Q8WL16MZVk4nU5OP/10LrroIjIyMrbGdaY8VdaKRNm0yR5GtnAhlJbGPpeRAUccAaecAsOGdc71SZu01BZh2m4Z7Nync9oiaF2SrsSyLKiuxdpYEhXilmLV1LbuPJEAt8wOcD1lFGVVUu0J1FfgthzgJpLmTGdQznAGZdvh7ZAcBbhtoXVJRFKN1iURSTU9aV1q9zYI48ePp7q6GsuyMAyDHXfcke222y7xCQ2Dm266qW1X3oUprBVJIBCAt9+2B5J98UXsczNn2lW20qWkalsErUvSHVjVtVibSzGjK3Ara1p3DiwqnXWsc5c2DDLLqqQ6UoHrBLerTQHuwOghZtkj6JM5QAFuM7QuiUiq0bokIqmmJ61L7R7Wjh49Ovag+m9g9KGGYUTC3O+++46eRmGtSAt++skObV9+GdLS7D89nobn160Dt1sDybqIVeVB7v0iti1C2HYFrq3eFkHrknRXVp23vv9tKebG+gC3vKp156gPcIvc9UPMPKWsy6yk2uOPqsB1QSs/ZPE40+whZvUtFAZlD6dv5kAFuPW0LolIqtG6JCKppietS+3es/bYY49tlwsTkR5s1Ci44gq48EJYuTI2qAV7MNmbb8JBB9m9bTWQLKVtk+/imn2zE7ZFWFEaZOb71Z3aFkGkuzAy0jGGDYRhAwm/pbO8PqzNZZEBZtamUqzSCmji83cDg7xQJnmhTHbwNgyDrXTUt1CoD3CLMiqpSqsPcF0ucDvtHuRN8Id8rK74gdUVP0S2eZxpDIzrgasAV0REREQkeUlV1krLVFkrsgWKi+2WCKFQwzYNJOsSWmqLcMTIdH6/bce3RdC6JD2d5Q9EAlxrU6ndC7e4vMkAtymVjrqG8NZTRlF6BZVpfju4DYe4ztYFr25nGgOzhkbC28E5doDrNPR+SURka9K6JCKppietS+3eBqE569evp7i4mBEjRpCdnb0lp+rSFNaKbIGKCvjPfxIPJMvMtAeSTZ4MI0d2zvVJizq7LYLWJZHGrGAQq7gca2NcgBv9wVgSqiIBrl2FW5ReQaXHZ/e+dbcxwHV46itwhzdU4GYN6lYBrtYlEUk1WpdEJNX0pHWpQ8La5cuXM2fOHPbYYw/OOeccamtrufTSS3n77bcBSE9P54ILLmDq1Klb/gq6IIW1Iu2guYFkAHvsAbNmQW7u1r82aVGN30zYFgEgx+Po0LYIWpdEkmOFQlgl5XbrhPpBZubmMggGW3Weaoe3of+tu5R16eWxFbhuF7Ty/ZAd4A5lcPYIBtUHuP26cICrdUlEUo3WJRFJNT1pXWr3nrXffvstp512GoFAgBEjRgAwe/Zs3nrrrcg+dXV13HrrrQwZMoRDDz10Cy5fRHostxsOO8y+/fgjPPOMPYisrs5+vqoKcnI69xqlSVkeB+ePzUzYFqHKb3LHpzVbrS2CiCRmOJ0YfQuhbyHsbG+zTBOrrLK+ArcEa2Mp5uZS8Df+4CUs20xne+9AtvcOjGyLBLhuuwq3KK2MirS4ClxX029MA6afnyt/4ufKnyLbXA53TA/cQdnD6Z85CKcjqbewIiIiIiJdTlLvdO+99178fj+DBw9mn332oba2lmeffRbDMDjggAO49NJLefDBB3nuued48sknFdaKyJbbdlt7INkFF8DixXa17eTJjYeO3XUX7L23BpKlCMMwOGxEGqN6ORu1RbCAxSu9/FgW7PC2CCKSPMPhwCjMh8J82NFuN2OZFlRU2a0T6itwrY0lWD5/k+dpLsAtctcPMosOcF0uDLcTnC67yXUCQTPAL5U/8UtcgDsgrgeuAlwRERER6S6SaoPwm9/8htLSUv773/8yYMAA3n77bc4991wMw2D+/Pnssssu1NbWMn78eHJycvj444+3xrWnFLVBEOlglgWmGftrtd9+C2ecYd/XQLKUszXbImhdEul4lmVBZTXmptL6Ngr1lbi13ladp9rhpchTxjq3PcRsnaeU8nSfXXUbXYHbiv+W7QB3SEyA2y9zEC5Hx7ReSYbWJRFJNVqXRCTV9KR1qd3bIJSXl5Ofn8+AAQMA+PDDDwHIzc1ll112ASAzM5OcnByqq6u35NpFRBIzjMb9Dxctari/ejXccgvMmWMPJJsyBbbZZuteo8RQWwSR7sUwDMjLwZmXA9sOA+oD3OrahgFm4RC3urbJ82Sb6WznHcB23gGRbTUOH0Xu0sggsyJPGWVpdVEVuM0HuEEzwK9Vq/i1alVkm9PhYmDWUAZFDTHrnzW4UwNcEREREZGWJBXWZmVlUVVVhd/vx+Px8M4772AYBnvuuWdkn02bNkXScBGRreLii2HMGJg/H5Yts7fV1tq9bp95xh5INnkyHHQQuPTrsZ1BbRFEujfDMCAnCyMnC8fIIZHtVk1dbIC7qQSroukP9LPMNLb1DWBbX0OAW+vwsS7cPsFT2hDgusI9cO1K3KYC3JAZbAhw19vbnA6XXYGbPSIS4vbPGoJbAa6IiIiIpIik0oudd96ZDz/8kGuuuYacnBx+/fVXDMOI9KZdvXo111xzDUCk0lZEpMPFDyRbsABeeaVhINnnn9u3o4+Gq6/u3Gvt4bbJd3HNvtk89FUdyzbGtkVYURpk5vvV7doWQUQ6l5GVgTFiEI4RgyLbLK8v0v/WDAe4ZZVNniPTTGNbX3+29fWPbKs1fJHWCfYwszLK0mrjKnBd0ES1fsgMsrZqNWurVke2OR1O+mfGtlBQgCsiIiIinSWpnrXvvfcef/rTnyL9IyzLYvjw4SxatIjy8nL222+/yL733XdfzOOeQj1rRVJEdXXDQLI1a+xt99wDUb8JgGnalVj6+7vVWZaVsC0C2POF2toWQeuSSNdk+fxYm0uxNkZV4ZZW2H3KkxQOcCMhrruU0rTa+gpcp90D1+0CR/LV+1sS4AbMAMs3f8LXxUspqymhV1YhO/cex6599lIALCKdSu+XRCTV9KR1qTW5YVJhLcBLL73EXXfdxcaNG9lrr7249tprGThwIKZpstNOO5GZmcn111/PEUcc0S4voqtRWCuSYiwLli6Ft9+Gyy6LDWZffx0eeABOOEEDyTrJqvJgo7YIYdsVuFrdFkHrkkj3YfkDWMVlkf635qZSrJJy+4O2JNUaPtZ7ylgXNcisxFMDbmdUGwUXOJNfZxyGk/5ZgyPh7eDsEQzIHhoTwH5T8hmPf3sXm2vXEyIEJuAAJ076ZA7g9B0vYKfCsa34boiItB+9XxKRVNOT1qUOCWub8+mnn7Lbbrvh8Xi29FRdlsJakS5k+nT44gv7fmamBpJ1khq/mbAtAkCOx9Gqtghal0S6NysYaghww20UNpdBKJT0OeoMf0z1rR3gVkfCW7uNgrPxMMtmhAPcQdnDsbB465cXCZh+cj29cDvchEIhnE4nATNAlb+MDFc25435uwJbEekUer8kIqmmJ61LWz2sFYW1Il2G1wvnn98wkCyaBpJtdc21RQA4Msm2CFqXRHoeK2RilZTbvW83ldYPNCuFYDDpc3jDAW7UILMSd3V9eOtsqMB1Nf/ezrIs1tX8TND04zRcuHHhMZ04Qw6cTidOdxqGx0NVoIJ+mQO5ft8HSHOmbem3QESkVfR+SURSTU9alxTWdgKFtSJdzIoV8MwzsQPJwnr3huOOs6tt8/M75fJ6mi1ti6B1SUQALNPCKqvA2lgSU4WLv3EFf1O8RsBuoeAujQS4xe7qSHjbMMis4f1eTaCazXXrcVoOu12DBfX/U8+wG3M7HIQMk76ZA+md0Y8sdw6Zrmyy3DmRm/3Y3pbpzibLZf+Z6c7GaXTv95gi0rH0fklEUk1PWpcU1nYChbUiXVR1NSxaZA8k+/nn2Oeefx4GD+6Uy+qJtqQtgtYlEWmKZVpQUWUPMNtY2lCJ6/UlfY7YALesPsCtigS4JVRQbVbhNB12RptoGarfHnJY5HjyKMzo1+rXkuHKsgPcqFA3051jh7uunIaQ12Vvz3Rna6iZiETo/ZKIpJqetC61JjfU7/mKSM+WnQ0nnQQnngiffmpX277zDkyY0Dio/e47GDpUA8k6SJbHwfl7ZPLGGj/P/OAlZDZ8lljlN7n905qk2yKIiIQZDgN65eLslQvbjwDsHwyorLZ739YPMrM2lWLV1iU8R7rlZoSvLyN8fSPbfEaAovr2CYvyP6fWDZFqWqt+jYpeqgz7acsyCVnJ99qNVhesoS5YQ0ndxqSPSXOmN1TpRoLc+mpeV7iCtyHwzXRn41GLBhEREZFOo7BWRATAMGDPPe3bpk1QUxP7vGnCpZdCVRUceaTd21YDydqdYRgcNiKNUb2cCdsiLF7p5ceyYIttEUREmmMYBuTl4MzLgW2HAfUBbk0d1sYSuwp3U6ldiVtdk/AcaZabEf6+jPD3ZY1zA2V5VfTyZxBwhPA7QgQMk5BhYhpW5GZhgQWOugCWtwIcDnAY9r9BDgMM+7HhcDTa1la+kBdfyEupd3PSx7gdnoZAN6pVQ3xVb6R9gysbjzO921fEiIiIiGwNCmtFROL17dt42//+BxvrK5kWLLBvGkjWYbbJd3HNvtkJ2yKsKA1y7fvVTN8tg+0LXCzdEODzDQFKq0MUZNeyR3834/q7cTsVGohI8gzDgOxMjOxMHCOHRLZbNXVYm0sxo/rgWhXVMcfuWN6XD3JXEDJMPKYLj5n434SAEaLK5WPy+jEMdw6h1uGj1uGn1mn/WePwUefwUePwRbb5jED4Au3QNjrIjdxv2GZEB7xG/a2VAqafCl8pFb7SpI9xOpwx/XXttgw5kZC3oTdvQ+Cb7srEYeiDNxEREZFoShdERJIxfLg9dOzll8Hrtbd9/rl9Cw8kO+aYxEGvtEm4LcKba/wsiGuLUO03ufHDaoIm+E0L08L+7ePNPt5Y46N/lpNzds9kTD/1ahSRLWNkZWBkDcIxfFBkm+X11Qe3doi7yxfV9PZmsTmjmnx/BkaCprUWFtVuH33rsjmgeBTu/F5Jff0gIerCQa7T/rO2/maHuv7I41qHn1qHlzqHP+oFRFXuRge5MaGuoz7kNWKrfVshZIao9JdT6S9P+hjDcJAV1ZYhvoI3dgCb/WeGK0sBr4iIiHRrGjDWTjRgTKSHaG4gmcMBRx0FV1/dOdfWja0qDzLvi1qK69si1AYsNtSYmBZkuqFfphOsEE6nk0DIotxnkeU2+OuEbAW2ItLhAi+9w9ffvcn9Iz6kzuEjJ5COy3QQ7mEbMEJUu31kBN1M/3FPdggMw8jP6bDrMTHrg9u4INfpiwl7ax1+apx2NW+tw2+3aYjWVLgb3bIhrrIXw5F4wFo7MQyDdFdmgoFq2XHhbkNVb5YrG6dDNSoi+jlORFJNT1qXNGBMRKSjxA8kW7AA3n3X7mlrmpCe3tlX2C1tk+/i6n2zefirOj7f4GdzrR3UOg3wh6CoOkR+GqQDDodBYQaU1Fnc+0Utdx2aq5YIItKhHCOHsMNnA5m+4SCe6vsxmz2VmIRL/g0clkHfQD4nbdyLHfwFOPcfi6NfIZbXB14/eH2R+5bPB3X1fwaCbbseHGSb6WSbyf+bZGLhNRpaMoQrd+vqA91IuBsOeuv3MzEbnywS3MZV6ka3bYgEvXFtG1pgWRZ1gRrqAjUUJ54Hl1CaKyMyUK0hxI3vwxtb1et26MM+ERER2foU1oqItEX0QLKNG+HZZ+H55+GEE2L3q6yEe++1t2sg2RbJ8jj48x6ZzP0cVlV4cUb9XB+yoMQLEDth/YfSIBe+WcmQXCeZLoMMt0GmyyDTXX9zEXW/YXuGy8C1BQN9RKRncWw3HKMglx2KLa7yH8fXWb/ybcY6qo06sq0MdqwbxM41Q3BVejH65OE6aE8MV8u/iWUFQ+Dz1we59WFuoj/j9/H5oZW/POfAINNKIzOYlvQxFhY+I9jQliEq6I3cnA3Bb/jPkBGqPz6OQWxw244D2HzBOnzButYNWnOm2dW7kVC3oRdvZoKqXg1aExERkfagsFZEZEv16wfnnQdnnw3xv86waBHMn2/f9tgDpkyBAw/UQLI2MgwDDDtgDZkQNJsPI0wL1laF8Ida3/EnzWk0GeRmRW3PcNc/doWfhwy3gUM/rIv0GIbLifvIAwjMfxVXpZcxoaHsXjuCUMhuz2IFQ1BTh5HuwX3kAUkFteHz4srAyMpo1fVYpgV+f1So68OKVPBGVfL64rf5IRRq+QuErw+DdMtNeshNQSgbAi0fA+CPBLxRQa6zoZK3IdwNV/r68BsNVcYJV/QOGMAWCPkoD/kopyTp74nL4Y60XsiMG6gW34c3HPKmOzMU8IqIiEiE0gIRkfaSqO/MokUN9+MHkh17LPTps/Wur5uo8lu4DOiX7aC4zqQ20EJg20Kg2xRfyMIXsijztulwMuIC3syoUDe6wjcr6vnwLd2JfnAX6WIcI4fgnjKJwOJ3sUorsUwTw7Kw6sNCozAP95EH4Bg5pMOvxXAYkJ4G6WkYJN8b17IsCIZi2zKEQ926+jDX58Oqi67mrf/Tn2RSC3gsF56Qi/xQVtLHBAlFKnXj++429OL1x1T5+ozGC3jjal6jiaC3bQPYgmaASl8Zlb6ypF+bw3DGtWNoGKqWGR36RlX1atCaiIhI96WwVkSkI82bB4sXxw4kKy6G++6DBx6Agw6yq2332KPVk7d7qhyPgYX9s3LfTAdVfosqv0Ug1Gg0DmD3sO0MdUGLuqBFSSt6KoY5jKiw19VEhW8zz3kcCntFOoNj5BA8552MuWIN5k+/4KuoIi0vB8eooXarhCQrajuLYRjgdoHbhZGTfJAKYIXMqErdBC0a6nx2e4b4Hr1eX1ItG1w4yTUzyTUzk76mEKbdczeuz274cXQ/3uhtCV9foo1tGcDmaBywmlaIan8F1f6KpF+bYRhkuLKaHKgW36rB/jNLg9ZERES6AMOyWtnQShJqzVS3rq4nTesTaTeWZQ8kmz8f3nvPHkYW7e9/h2OO6ZRL62o+Wufn5o+ryfUYMYPDQqEQDqcT07LbH/hDdog7ZXQ6w/Oc1AahNmBSG4DagB2k1gYsagIWtfX3W2qr0FU4HU335k3UxiEzaluGy9BANpF2oPdLybEsy67KjbRjqB+u5k3UqzdunzYOYGuOiYU3rhVDTVTQWxtX1RsOexN/XNiE+H67zQ5gi+7Pu+V/j9JdmU0MVAtX7tqVvNHPa9Ba96F1SURSTU9al1qTG+qjVRGRraGpgWSlpZCWBhMnxu5vmgmrbwTG9XfTP8tJUXWI3hmxFaQG4DTAgUV5wGJIjpNTdsxIOnwMhOzgtiZgxQS64VA38jhqu33fDoJTJesNmVZ9xXHbjnc7YtsyxIe6GRrOJiLtxDAMSPNAmgcjr3XHWuGWDfVtGqIHrUVC3fDj6H2aGcDmwCDTTCPTTKN3steBhc8I1Ie6Ua0Yooas2f14fdSEA1+njxDNh80dMYDNG6zFG6ylhI1JvjpIc6Y3OVAtpqI3KuT1OJMfVCciIiKxFNaKiGxt4YFk06bB22/Dpk2Qmxu7z6xZsHIlTJ6sgWRx3E6Dc3bP5OaPqymus8hPIyaMDYQsyn0WWW57v9ZUibqdBnlOg7w2/IxpWRa+EDEBb0yomzDkjQ2FUyTrJWBaVPgsKnxtO76p4Wzx9zWcTUS2hOFyQnYmRnbyrREgagBbpDVD3OC1+F694X3qfI1/M4bwoDUP6SEPhUnOZ7Ow6getRVXrxvXjTVTRGzBC0PgS4s6dQKPq3eQHsPlCXnwhL2Xe4uReHPagtaYGqmVFB75R+6Q507t9VZWIiEgy9NO/iEhn8Xjgt79tvL221h5MVlsLn31mDyE79lgNJIsypp+bv07I5t4vatlQEyJkWVgWGIaJ04CB2U7O2T2TMf223q9uGoZBugvSXQa90lt/vGlZeINEgty6uBYNdfUVv3VNBL/eYKpEvVs2nM3A/h62pm1DeN8st0GahrOJSAtiB7Alz7Isu/WCz99oyFok8I0ewBa9T9wANgODNMtNWshNr1YMWgsQbHLIWrhlQ11c0OszAnZ/ICwINZ/0ttcAtqAZoMJXSoWvNOnX5nQ4mxyo1tCbN7aCN92VqUFrIiLS7SisFRFJNUVFdigbHki2ebM9kOzBBxsGku2+e48fSDamn5u7Ds1l6YYAn28IUFrtpSA7jT36uxnX393l+q46DINMt91aoC1Cph3YxrZxIMk2Dhb+UGqEvRbtPJzNU/+nhrOJyBYyDAM8bvC42zaAzdtQpZuoRYMVV8mbaACbGxd5IRd5oeSriYOEIoPW6hJW7/pjg9/oQWuWZd9MgKbLhttjAFvIYVJlVlDVqkFrDjJdWVHD1XJiqnYThbyZ7mwFvCIiktIU1oqIpJpRo+CZZ+yBZAsWwLvv2r92GQrBm2/at222sVsk/P73doVuD+V2Guw9yMOEgW4qKgLk5WX22KDN6TDI8hhkeaAt9ddBs+n2DLG9eROHvakynM20oKY+nG6L1g5ni23joOFsIpKY4XRAVgZGVkarjrNMCwKBpvvwen0J2jnU7xO0e+K6cJJjZpBjZtBCm9wIE7M+uPU3VOrWV/DGV/XWOO1q3lqHP3bQmmkBoeYy3sQhb3MD2OKCXsvhoCZYQY2/slUfYme4s6IGqmXHtmpw5UQC3syotg0uDVoTEZGtRGGtiEgqam4gGcCqVfDII3DccZ15ldKNuBwGuWkGuW2cCeMPxYa3dVEVvtHBb7i1Q11c6JsiWW+HDWfLimnjQKRtQ4aGs4lIMwzHlgxgC9rBbXi4Wrgnr88f1aPXHzuArf6+AwfZZjrZZvJ9fUwsvIY/ps9uTX2Vbo0zKtyN9Oi1H5vxTXgtC0IWLTXn3ZIBbHWBCuoclRTHDWBrTpozvcmBanbIG27hkBPpzet2psYH6gEzwPLNn/B18VLKakrolVXIzr3HsWufvXArhBYRSTkKa0VEUl30QLK33rKrbb/8Eo4/HpzO2H0//xx23VUDyWSr8zgNPE6D/DYcGz+crSZBZW9zbRzqutFwtnSXEdvGIYlBbeH76S40nE1EIgyXC7JdbRvA5osNcRtC3tgWDtFhsMPrI9NMIzOY/Kd+FhY+I9jQliFuoFpDP96Git4ah5+QkaBc1wIss8MGsHkdfnyOKkrjBrA1x+1MixuoFtuqIbYfrx3wetp50No3JZ/x+Df/YlPVWsxQff9ih8G7a16ib85gTt/pQnYqHNtuX09ERLacfpoXEekqPB6YNMm+rVgBffvGPr92LZx9NvTubQ8jO+44+75Iimvv4WzxLRqiQ91UH87mrb+e9hjOFh/qJmrbEK7wzdRwNhGpZzgMyEiDjC0dwNbQliFS1RsOeuv3MXw+0r1+0v1uCkLZEGj56wD4IwGvP6r3bmzQWxMX9vqNZnpAdNAANr/Di9+oojxRtW8TnA4XWdEVuzG9dxP15s0m3Zm4DdQ3JZ9xz6fXUFtbTo4/DZfVEKQHDZONvpXc8+k1nDd+pgJbEZEUorBWRKQr2m67xtueecb+1UENJJMepj2Gs8VX7dYFSbqNQ3cczpYVPYhNw9lEJAlbNoAt1FClG+7JG9+qIaplQ5rXR5rXR77XHzOArTlBQvXtF/yN+u429OKNrer1OlroidMBA9iCDoMKo5oKx8aYAWyRQDgBw3A0GqiW5szgndXPU11XTnbQQ9BpYWLZ3SIwwHKQ7fdQaZXy8Gc3c+V+c3A703AYDvuGA4fhxDAM+08MrfEiIluJwloRke5i//3t6tr33mt6INmRR0Jm634dUqS7czoMsj0G2W1sLRgI1Ye50RW7cW0bagIWdQEaVfXWBCxCKdKwN3o42+Y2HN/ccLZkqny7y3C2QMhi6YYAn28IUFodoiC7lj36uxnX391tXqNIezOcznYawBb9p6+hqtfnx+P14fb6yItU9zYz+axeeNBafJ/dxP14G7YlpR0HsFmGQZWjmqqo7bVmLSW+YhwGlHuarhi2LIs1dav42/vTyfJkN3vJRkyQGxvmRm+P7Gc4cWBgGA6chhPDcGAQtX/9zcAR8zhy7vh9sc8dPr8z6tiGa3PiiLomI+Z6o665Poy29zHqj3PUX2v0ca1/jY76644+TkRiqZd28wzLSvKjSGlWKBRi2bJljBkzBmd8D8luxrIsKioqyMvL06erIqlowwZYuDB2IFlYZib8+c9w4omdcmkdReuSdFWWZREwW27h0Fw7hxTJereYxxk7cC1RwJvpgiy3g0w3jfZ1psBwtmUbA9z7RS0bakL2fCTLAsPAaUD/LCfn7J7JmH76AUQkFUQGsEX3343rwxuu9G3Uo7cZJhbe6PYM4fuN+vHWD1yrD3vbu/t6ibOKKqcXl9VyUBg0THKsDArDnefj30sZkf+hoTeGQWyfjPjHcecx4u4YMRubeBx73oZN8deX5Hmavf4E521H8eFuUyFwzHZiQ2cDA6fD2Sjcbhx2Nx10R67BMDCICtEjgXWioLthe3SwHQ66nYarvvLaDrqjv35rX6MDA4fDFQnAFXR3T0310nY43d26l3ZrckNV1oqIdDf9+8cOJJs/H5Yvt5+rrYVevTr3+kQkwjAMPE62eDhbfKhbF7SSauOQSsPZ/CG7pUR7DWfLaqFtQ3sPZ1u2McDNH1dTE7DIT7MrhUOhEE6ng0DIoqg6xM0fV/PXCdkKbEVSQLsMYEvQh9fp8+Hy+smOD4BrfPZvPiU6JxY+I1Dfeze+725D64a6cMBbX+UbamaaWnPPJWKaIQg109c3BWz1f6+aC5SbDarjHhtgYTT8P9JU+B1/3uZC86Svr/nrNdrt68SeN/HjtmkU5kY/blWld0Ow7azf1yA2wG4q6I49d2wldnRgnTgwj7rmJoL1cGW2I676fEuq2VM16FYv7eQorBUR6a7iB5ItWABLlth9bKMtW2Zv10AykS4nejhbQRuOb3I4W/TjcB/fHjycLf5+hssgy9Pw2IHFvV/UUhOw6J3RuK+j22nQOwOK6+z97jo0Vy0RRLqoLR7AFm7VEB7AVmcHva46H1m+hkrfmH38jSevWVj1g9aiqnWj+vG+n/4NqzOL8ZguTMOK3Jr6iM5haU1qxIr8T+LH3cDWD8BbX/UcAkLNVVNHjm1D9XSL5+mA6u/mrjfuS2xJAB4dRkcH1uEqa6eRqCVIfDjcsC1R0B1p/RGplG78taIDZsuyWLTicaq8pWSGPNS5gnbYbRmkmx5cloN8n4Nyq4zHP7+N6w9+tMe2RFBYKyLSE2y3Hfztb3Yf2/hfuXjiCXj7bXsg2cSJdm9bDSQT6RE6YjhbbYLevPFtHGrqq327y3C22oDFhhoTtwM21IDDsHAY9omdTrO+CgfcDvilMsTCFXXsOcATqfztTj17RSSxmAFsua07NjKArb6CNxzmuut8ZPrCFbxR1b4+PwXFbu4f9B7ZQQ8uK/Gv21pA0AhS7fLzh7V7s4uxHSamHexiB7uWYRGq/zO8zTRMTOof128PB8FmU8/X37ewCBlm1L5WgvtR1xB1vGmYWJDwHNH7Rl+jFfV8U+eI/Rr217eg4RxR55UtZMWH3zF3urxUqv4Of/4SCj/R6rYlbasiby7grjVrKQkW4wCqXLG/SuVx+ugTyMVwOskOpLOp6le+3PAR4wbuT0+ksFZEpCeJD2orK+H99+37oRC88YZ9GznSDm2POEIDyUSkSR05nK0mJuAlMpAt+vlUGc5WXd87OGRBKD6ADtqxQOShCf/+xsvrq2P7Xrodht3KwU0kwM2o79WbEdXiIXw/vX6AW/R+Hgfq2y3SDbVlANvu3+xA7y+/YHNaNb1CHoz6ZciyrKh1wqLaFaCPN4e9tj8Kz+BBdpgWvpkN9y3TbLzdjN7XtJc6y4w8ZyU4D6bZ9DaLhq9jJriOyHMtfJ3wfu0sHNeGY+CmAuX2DLotGs7RaJ92CrpjXouC7q6li1V/1zmrsJwW9kfYsdfpJ0DQCOG2nLgNF6ZVx9c/vaWwVkREeqDcXHjuucYDyVauhH/+E/71LzjqKDjhBNhmm069VBHpftxOu6I0N63lfeOFh7NFB7jhcLemibYNHTWczWzliRLtHzAtAn6LqiQHyScSrpTOiAt7M11GpKdveFBbU0FwmlOBr0h3kLb9tpzy/oHc53qVMmcNuaEMXDgjlW4BQlQ568gIuTml+iDST9wfw9W9BmVbCQPh5oJmq4mwuPmg2ooOqqOPayaoThxkh+83HVhbUdea+Loab7ManZu2v6a2/n+xVYLu+rC6HYPuhmCaRtfQ1qA7PsjuSUF3c720nZYDZ305sGEYYEF1+aatdWkpR2GtiEhPFz+QbMEC+PJL+7naWntA2fz59vYRIzr3WkVE6kUPZ+uV3vrjmxrOlqh1Q1NtHMIc4Z4HSbL3b3+mZVHth2p/23+wcxgNw9riq3nD4W6mi5igNz74bY+BbSKyZQyXk10POZU/LfLxZJ+PKE6rwTTClf4GDsugjy+bUzbvza5Hndrtglqo7y8c+RXs5F6fVq6mWfXVz82FyfEhcEMo3dwx0QG3GXtco3PT5PkaQumGSu2mv27c12mx+jvu67TXa0oiAG9L0B3THiRBkN0xQXf9NTYTdH/pWc2v6aWkm+7612b/r9NykBXy4HDEDkXLDPbMfrWgsFZERMISDSR75RXwemHHHRsHtYn634qIdBHtOZztg3V+7ltWS2Z9SGnW/xwWNE2IehwyLSwLCjMcOB1GyrRxiGZaRMLptgoPbIsPce37NKr6bfzYDoMV+IpsGcfIIex61FS2XTyc5cHv+Ta7iBqHjywzjR2rB7KrazQZR03EMXJIZ1+qdAGGEe5Pmvz7f63izWtdqxCaqf6Orpy2km8V0ihYTlRhnSiIblv196gN/+M+9xtkh9Ia9dI2ooLaACEcONjJtf1W/f8jlSisFRGRxsIDyS68EBYtgoEDY5+3LDjzTBg0SAPJRKRHih7OdsQ2abyy0kdRdYjeGQ1tBOzPtOwfPizLorgOhuc5uevQXFwOu39tuGdvXX21bl2QSAuHupjt0fsReS6QgoGvRcPANrxtP096VPuGzPiwN0HQ21Dp21D56+qgKmaRrsIxcgiZ553GnivWMO6nX/BVVJGWl4Nj1FAc2w3vlhW1Il2FHYAb4Gh538gxHXc5HW7MN4Po/eXH9b20szDCw9DqK/7D96ucdfTxZbPbDhM78Wo7l8JaERFpWk4OnHxy4+3Ll8O339o3DSQTkR7O7TQ4Z/dMbv64muI6i/w0e1tYIGRR7rPIctv7hZ9zO2lzz96woNnQs7eufhhb5H5U2Bsb/hLp8VsXtPDHD0VLEd6ghTdoUb4F5/A4E1f2Rvr4ulsOg6P/vxTpigyXE+eOI3HssA01FRVk5eWpN7WIbHVN9tKu19BL28UpVQeStv22nXi1nUthrYiItN7mzdCrF5SV2Y/jB5JNnqz+tiLSo4zp5+avE7K594taNtSECFl2ywPDMHEaMDDbyTm7ZzKmX/v2X3M5DHLTtizwDZl2KFoXJK7KN77qtyEMjt/uDaZm4OsP2WF0ha/t53A7wsEuTVbzxvb2bTzkzePQ4DYREenZ1Es7eYZlbcFIv62kvLyc2bNn884771BdXc3222/P//3f/zFu3DgAvvvuO2688Ua+/vpr8vPzOf300znrrLMix5umyZw5c1iwYAGVlZWMHTuWa665hmHDhkX2aekcLQmFQixbtowxY8bg7OY9HC3LoqKigjx9IivSs/n99kCy+fPtStt448bZVbkHHNDhl6J1SURSRSBksXRDgM83BCit9lKQnc4e/d2M6+/u1hWa0T18Yyp748Pf6MrfmO124JvyP5i0UbhtRnyIG6nwjTymySA4zanAV7aM3i+JSCowV/5K3eK3mu6lfWT37KXdmtywS1TWXnLJJZSUlDB79mwKCgp48sknOeuss1i4cCEFBQWceeaZHHLIIcycOZNly5Yxc+ZM8vPzOf744wG45557eOqpp/jHP/5Bv379uPXWW5k+fTqLFi3C4/FQVlbW4jlERCROcwPJAJYuhYKCrRLWioikCrfTYO9BHiYMdFNRESAvL7NHhCLRPXzbyrQs/KHYFg2xrRyIq/JN3Ns3Bdv4YloW1X6o9rf94hyGHeSmJ6zmDbdzIK5/b2zwm14/BE9ERKSzqJd2y1I+rP3555/54IMP+M9//sMee+wBwN/+9jfee+89Fi1aRHp6Oh6Ph2uvvRaXy8XIkSP5+eefuf/++zn++OPx+/089NBDXHbZZRxQHxjcfvvt7LfffrzxxhsceeSRzJ8/v9lziIhIC+IHki1YAL/8AiecELuf3w/ffANjxmggmYiIxHAYdpiY7jLold62c1j1gW+iELcuKuxt3N4hKhAOWoRSMPE1LagJWNQE2n5tBsRU8jau8m16gFtm1PA2Bb4iIrIl1Eu7eSkf1vbq1Yv77ruPnXfeObLNMIzIr3B8/fXXjB8/Hper4aVMmDCBefPmUVJSwrp166ipqWHChAmR53Nzc9lxxx359NNPOfLII1m6dGmz5ygsLNw6L1ZEpKsLDyQ78URYtgx23z32+TffhKuvhlGj7L62hx+ugWQiItJuDMMgzQVpLoNeW3CeQChRqEuT1bwN+xF5LpCCga9FQxsKvG0/T3p0hW8zw9kahcJRlb8uh34oFxERSSTlw9rc3NxIRWzYK6+8wi+//MJvfvMbbr/9drbbbruY5/v27QtAUVERGzZsAGDAgAGN9lm/fj0AGzZsaPYcCmtFRFrJ4YD634aIMX++/edPP8E//tEwkOyEEzSQTEREUobbaeB2btngtqAZ384hql9vTDVv9OOGNhDeoIUvlHqBL4C3fqhc+Racw+OMD3SJhL/pMa0dmg6Du3MfaBER6blSPqyN99lnn3HllVdy8MEHM3HiRP7xj3/g8Xhi9klLs99V+Xw+6urqABLuU1FRAYDX6232HK1hWRZdYGbbFgm/xu7+OkWknVmWXXFrGPDVV/a2mhp4+mn7Nm6cXW17wAHQykGNWpdEJNVoXRKnATkegxxP2wPFkGnhDTVd0duo2jdBha83RQNff8jCH7KoaN2PWzHcDjvEjW/tYAe8jQe6Rap7o7Z5HD1ncJvWJRFJNT1pXWrNa+xSYe2bb77JpZdeym677cbs2bMBSE9Px+/3x+wXDlgzMzNJT7cbXvn9/sj98D4ZGRlJnaM1KisrcTgcrTqmq7Esi9raWqDnvLERkXay996w9944fvoJ9/PP437jDbuPLcAnn8Ann2D17o33iisIJarMbYLWJRFJNVqXpD25gTwgzwm0cu6KadmBrzcIdUHs+zGPrYbtQaiL+bPh2FT8MToUAm9gy87hMCDdiR36OsPhL2Q47T/TneHHRsz2yPMuSEvxwDdgWizbDF+VmJTXBcnPKGOXQgdj+tiBt4hIZ+lJ75dM00x63y4T1v773//mxhtv5NBDD2XWrFmRStj+/fuzadOmmH3Dj/v160cwGIxsGzp0aMw+o0ePTuocrZGbm4uzlRVhXU3404A8NYAWkbYaO9a+zZgBL70Ezz5rDyQDqKgge/RoyMtL+nRal0Qk1Whdku7Esix8oYZq3dq4yt5I794mBrqFbynYxhcAnwW+ANDG4Ndh2NW66TGVvDTRu7e+3YM7dv90Fx0yuG3ZxgD3LqtlY41JyDLAcoFh8N56i35ZDs4Zk8mYfu52/7oiIsnoSe+XQqFQ0vt2ibD2ySef5Prrr+f000/nyiuvjKlcHT9+PE899RShUCgSkn700UeMGDGCwsJCcnJyyM7O5pNPPomEtZWVlXz77becdtppSZ2jNQzD6PZ/waDhdfaE1yoiHSg3F0491R5K9umndk9bhwMGDozd7/nn7fKZZgaSaV0SkVSjdUm6C8MwyHBAhhvIaNs5LMvCH6LZdg6Nh7rFDXgLWgRTMPE1LagJWNQE2n5tBo3bOUT36E1vZoBbZtTwtujAd9nGALd8UkNNwCI/ze7xa//M6yAQslhfbXLLJzX8dUK2AlsR6TQ95f1Sa15fyoe1q1ev5qabbuLQQw/l7LPPpqSkJPJceno6xx9/PA888AB/+9vfmDZtGsuXL+fRRx9l5syZgN2r9rTTTmPWrFkUFBQwaNAgbr31Vvr378+hhx4K0OI5RESkgzkcsNde9i3+10OCQbj3Xigu1kAyERGRLsowDNJckOYy6LUF5wmEEoW6Tff1rU3QxzeQgoGvRcMAOrxtP0848PU4YfmmIN6gRYYLKv12BTAWOB0WDgMyXVDhs7jj0xpm7pdNtsdR3/bBwKn2CCIincawUryL77333svtt9+e8Lljjz2Wf/7znyxfvpwbb7yRb7/9lj59+jB16tRI1SzYpcazZ89m4cKFeL1exo8fz9VXX83gwYMj+7R0jpaEQiGWLVvGmDFjekQbhIqKih5Rpi4iKeCTT+DPf268ffz4yEAyy+HQuiQiKUXvl0RSV9CMbdngDRLbwiG6yjcu7K0NWHiDFr4UHdwWVu232FBj4jTs2a5NsSy7MrhfloPsqGF4HqfdpiHcrzetfnBbWlSVb7qzoZVDeN+Yxwp+RaQFPen9Umtyw5QPa7sKhbUiIh3ohx9gwQJ45RXwxY2N7tsX65hjqNprL3J23VXrkoikBL1fEuneQqYd2tYFadS6oXErBxJu9wY77kfxTbUmlT4LVxKzr4Mm5KYZ9M3smEHZ0cFvooC3peA3LTL4TcGvSHfTk94vtSY3TPk2CCIiImy/Pfz973DhhbBoETzzTMNAsk2b4L778HzzDdxxR+xxU6ZAVRVkZdm9brOyEt/ff38YNarhOL8f1q6N3cfRMT/AiIiISNfjdBhkeQyyPG0/h2nFVvV6G1Xzhge30ajqNzrwTdTVwWxlq4fW7t8a/pCFP2RR6Wt535a0FPymu4y4SuDY4W8KfkWkK1BYKyIiXUduLpxyCpx0EixZYg8ke/99ME2srKzG+2/aBNXVsHlz8+cdMCA2rF21CuJb4aSnJw57Z86EnJyG/b7/HlasaDogzswEl/75FRER6ekchkGmGzLdbQ8NLcvCF2po0RAOced/V8en6wNkexyRVgemZREyLSzDaNiG3RbC0UWCy/YMft0Oe0BbuF1DJNB1NQS6TQW/6fXVwBn1fZhdXeT7JyJdg35aFBGRrsfhgAkT7Nv69fDKK4QKC2P3sSzo2xcyMqCmBurq7G2JxAe9tbWN9/F67VvUoEsA4n+F5d134f77m79+jwd23x3uvjt2+/3328Fyc1XAWVn268rLa/5riIiISLdnGA0Vpb3SG7ZX+y2+2hwk0wVuZzhINAiFQjidDb8tFAhZVPrhsr2y2KO/p761g12xG27z0HC/fnuIyGNfVN/fuvpevh3Z3qE9BUyLgM+ish3OlUzwG1sJHN/fV8GviDRQWCsiIl3bgAFw5pkEKypitxuGXXkbZpp22FpTY4exNTUN93faKfbYvDw46qjG+0XfN037a2RkxB5bU9PyNfv99vHx3n7brsptyXnnwdSpDY8rK+1K4JbaPWRlwcSJkJ/fcGxdnX3LyrJD5G7eK0pERKQnGNffTf8sJ0XVIXpnkLAXpGVZlPssBmY72XOAB7fTDg97beHXNuurfZsMfkN2OwdfqGGbgt8Gbkc41KU+7DWiAuCmg9/IYwW/Il2ewloREekZHA47sMzMbHnfkSPh2mubft6y7EFntbWNw83DDoPhw+32C82FvUOGND5vdXVyryW+ErimBoqKkjt2zJjYsPaNN+C66+z7DgdkZzd8n6Lv9+sH//d/sef68ksoL28Ig6P3z8hQ8CsiItJJ3E6Dc3bP5OaPqymus8hPi66wtStqy30WWW57v+jntpTDsMPCjgx+w4FuMsGvN9RwXFcQMC0Cfosq/5afq8Xg12nEBr0KfkVSgsJaERGR1jIMu4dtenrj53be2b61xbx59kC0ROFu9P1tt409zu+HXr3s5/0tvLOPD6ujA2LTtKt0KxPUhQwe3DisffRReO+9xF/H4bAD26wsOPpoOOec2Odvvx3c7uargLOy7Nfldjf/mkRERKSRMf3c/HVCNvd+UcuGmhAhy8KywDBMnAYMzHZyzu6ZjOmXuv/Obu3gt9G2mBYQCn7Tm2rh4G4++E13xm5T8CvSPIW1IiIiqWLAAPvWWsOG2RWyAMFg43A3XOVbW2uHn/Ffc//9EwfDXm/Dfokqkptr+WCaDeepq2v83BNPJPfa7rgDfvObhsdffQW33NJyu4esLDjoIDs0DvP77R7D8X2GRUREuqkx/dzcdWguSzcE+HxDgNJqLwXZaezR3824/u52rahNde0d/PpDDYFuXVTI6w1a1DUV/EYqgWPD4K5gawe/0ZXAGQp+pYdRWCsiItKduFyQm2vfknHQQfYtkVCoIeQNhRo/f8IJsNdezVcB19Q0Dojjw9vmxIfEJSXw3XctH+d0wscfx27717/gqafs3rxNtXvIzoYddoBjj4099osv7Irq+P09nuRfi4iISCdwOw32HuRhwkA3FRUB8vIyE/awleQ5oga7bankg9+4YW8KfoHEwW9aVKDbMOhNwa90HQprRUREJDGnE3Jy7Fsihx7atvOmp8Njj7Xc7qGmBvr0iT3W77erZRMNaIuWldW4Z264Etjvh9JS+5bIxImNw9q//x02bmy8r9sdW807fbp9fFhZmT3oLplKYA14ExER6XE6MviNaeHQRPDbsD02DPYFLbpC9NvewW9aVKDbUvCb7oQMd+KBbwp+ZUsorBUREZGty+mEHXds27GHHWaHxOEBb9EtHqLvWwl+vBgyBHbdtfH+wWDsfvED3MDeL5FAACoq7BvEto4A2LQJ7r8/udf28svQt2/D49dfhxdfbDnoLSxs3CfZbkqY3NcVERGRbmFrBb++kEVtZJBb9wt+qzsg+E0U6KY3EfymuQwyXQZp9QFxdwx+AyErqj1LiILs2h7ZnqUpCmtFRESka4ke8FZQkPxxU6fat3h+f2w1b6L+vKedZg9ea6kSOP7Y5vr6xosPidesadzKIZEdd7QrlaOdcw58/33zlbyZmTBhAowb13CcadptJqL3y8iI7f0rIiIi3V5HBb++qNC3Lmi1KvgN33pa8OtytFzJ21AJTFTLh9QMfpdtDEQNPgQsYLOPN9b46J+V+oMPtwaFtSIiItKzeTz2Lb63brSzzkruXPEVvaNGwV13JdfyISMj9thkg95E4XJVVcP5m5ORERvWVlfDH/6QeL/osDczE664AoYPb9gnHC631O5Bwa+IiEiPsjWD3+iev3XdJPgNmhbVfotqgFaMfkgkOviNruzNiAp0mwt+oyuF21IBu2xjgJs/rqYmYJGfZp8jFArhdDoIhCyKqkPc/HE1f52Q3aMDW4W1IiIiIu0lvvVAbi7svXfbznXhhTBtWsshb79+jY8dNKihVUR430SSrQSuq2s8GC6+fcTy5TBrVsuvq18/WLw4dtuTT8I337Qc9PbtCwMGtPw1REREpFvqiOC3UX/fUONhb+H7DZXAsWFwlwx+t5Ad/BJX6ds4+LWfB7cD5n5RS6XfoleagWEYhCwi3ze306B3BhTXWdz7RS13HZrbY1siKKwVERERSUUtDXhrzq23xj42TbufbnzQO2RI7H5paTBlSuO+vtHH1dba54tv29BUIJzodcX77DN4992Wj/397+Gqqxpvs6zYcDc72/4z+v4BB8S+Xq8XiosbwmANeBMREelR2jP4tSwLXwvBb3Srh7puE/xCdZJXW+232FBj4jTs70GYA8hPt8itD3Dz02BDTYilGwLsPcjTQVef2hTWioiIiHR3DkdDeNmnT9P7FRTAjBnNn8uy7KAzLS12+z77wPXXt1wJ3Lt343MmG/TGB8SWBUVFiQfKxRs2LDas/fpru7dvmNPZuJI3/PjGG8EV9bb5m2/gl1+argJOT0/u9YiIiEi3YLRz8BsZ7hayqAvYQXBdsPngNxIQx1QFp07wW1sf0MZ/Nm4CZV6TTLcTl8OusA1ZFl9sVFgrIiIiItIyw2jcXxdg6FD71hY335zcALc99og9zu+HgQMb9vE3M8WjpUrgUMi+hsrK2O0OR+Nq4Fdegaeeavpr1Yfj6Xvuab+2aFdcAaWldiWv223fEt0/6CDYZZeG42pq4L//bXr/6PsDB8aGy+EwW5XDIiIiKc8w7DYCaVsh+G2oBK6vCg7FVQZHBb++kIW5Bcmv2czB8c8YQJU/VWLmrU9hrYiIiIh0rtxc+9ZaaWnwwgsNjwOB2D690WHvNtvEHltYCJMmNR0Oe732fllZjUPOliqBTdNuIRE+R7SvvoING1p+bYMHx4a1xcVw3XUtHwf292TQoIbHCxbYrTEShbsejx3sejz2MTfeGHuu//wHVq9uOhwOHztqFOy8c+yxy5fbzyfaP3zf7VaILCIi0kE6Ivj1xg1yi6/kTRT8+oJQG7CoDZo4DPtz5OgoNj/NgStqBq0F5Hh67vsDhbUiIiIi0j243ZCXZ99astNOcMMNTT8fCsWGttGOPBK23775KuCaGqxELR8CgeReiyvubXpzVcPx3HHTk/1++6civ7/58yQKoT/4AD7+uOWvecopsWGtZcHUqcld77/+ZbfRCFu2zG6p0VIFsdsNf/ubXckc9umn8P33LR/bqxeMGBF7HZWVdnAc3if6vCIiIj1cdPCbl9by/vE+Wufn5o+ryfUYuJ0GlmW3QLBCIVxRYXIgZOE0YPd+7qZP1s0prBURERERidfcgLexY+1bcywLX0UFjbrXvvKKHdj6/bF/xt+PbynRpw9ceWXTx0Rvy8yMPbagAHbcsfmvFwg0Dogh+ZA4/thgMLnjEh1bVQU//9zycQ5H44Fz77wDTz/d8rH77GOHxNGmToU1a2LPH1997PHY+x11VMN+ZWV21XNLlcsejz0QL/rDhKIi+PHHlttbpKW1bdigiIhIihjX303/LCdF1SF6Z9jhrxMIRRXQWpZFuc9iYLaTcf0V1oqIiIiISEdzOOzgLX5AW0vy8+G449r2NY84wr41x7LsauJ4115rt3RIFPD6/XYo6/fbbRDinXZa0+Fw9LGJKqGzsxv2b2qAXKJwua2Vy9A4mDZNu7I6vro6vgK5uhr+97/kvu6BB8a+3g8+aNzXOJGBA+HFF2O3XXWVXfXcUvXxfvvBCSfEHjtnjl1F3NKxu+wSOxSwrs5u45Fof5dL1cgiItIkt9PgnN0zufnjaorrLPLT7G1hgZAd1Ga57f2in+tpFNaKiIiIiPR0hpE4wBw4sG3nc7vhL39p27H77WdXyIId1Jpm4tA3UfXu8cfDXns1X0Hs9zdugQAwbhxs3tz6yuVkA2Kwg822HBvf2gKgosKu6m1JdP/isMces7+vLZk9G/bfv+Hx11/Duec2vb/T2RDevvZa7HXPnw+vvtpy9fHw4Y0/mHjrLTsUb6762OOxg+Xo/tfhvz/xQwJFRKRTjOnn5q8Tsrn3i1o21IQIWRaWBYZh4jRgYLaTc3bPZEwPboEACmtFRERERCRVGYYdtGVk2LeWbL+9fWuLq69u23HDhsEbbzSEutFVw/H3e/WKPXa33eDPf05ceRx9bJ8+jb9u7952EJvo2GjxAbFpJhfUJjq2pXA5FLKrb+vqGof/a9faQ+dastdejcPae++FVataPvbCC+GMMxoeFxfD4YfbFb/NVRF7PHYriyFDGo79/HO7mjk+TI4/NifHHlYYbdUqu51HS5XLLpcG7IlIjzOmn5u7Ds1l6YYAn28IUFrtpSA7jT36uxnX392jK2rDFNaKiIiIiIi0ldPZOIRN1k472be2aCpctiw75A2Ht4mqch98sPkWFU31Tu7dG373u5Yrl6FxCJlsH+NE15tsBXJT4bJpgs9n35oS3wZkzRpYtKjlr9mvX+Ow9t577Wrglhx9dOP/H08+ueH/t/hwN/rxSSfZvajDNm2yr7e56mOXC6fXa1evR1cbl5TYldoOh31zOu1b/H23O7kPTUREWuB2Guw9yMOEgW4qKgLk5WVi6MOrCIW1IiIiIiIi3UV0L9pEHA67orctttsOrrmmbcfOmAGXXtpy0JuV1fjYP/8ZKitbrlzeZpvY45xO+7W2VLkcDLZvi4q2hstgh8TJHD9xYmxYu3Yt3HNPi4dlhEJ2r+PosPY//4FHHmn5a+6xB9x3X+y2M86AFSuaDnjD9884I7Z3cmUlnH9+8+Fw+P5FF8W28/j6a7vqubljHQ7779Kpp8Ze75Il9vcqev9Ex/frZ/99j/bdd/aHIS0dm5sb25fcNO0PA5xO+79PBVIi0gKFtSIiIiIiItLxHA5IT7dvrXHIIW37ev362VXELTHNxgHaEUc03/84fD/RaznoILs9RkvHxlcuW5bdVsHna9i3qQF78UFvfPuL5sT38E22LUaiAXLh/tEtVU7X1DQ+7ttvk/u606bFPv75Z1i4sOXjevVqHNa+8ILdT7klRxxht8aIdv75dgVyS667Lnao4w8/wOmnNzxuLmResCB2COHChfDUU433jX88bBhcdlnsdTz4oP29Cg//czhi74ePHTcOJkxoOC4UsgP8pvaPvj92bOxvFpSVwcqVLYfwLlfjftp1dfbXThS8i/QwCmtFRERERESk50oUBuXk2Le2OProth1nGPD66w2PLcsOr+KrjwMBuyVFtO22swfCNRcQ+/34q6vJiH+9O+4Iv/+9/bXCVaDR98N/brtt42seMcL+/iXaP/p+fPsE07SPSyYojr/e+JYVTUk0WC7ZYLo9j40/Ltw3OlEFdfyHBqWlyfVrrqxsvO3DD+HLL1s+1uGIDWv9frjjjpaPA7j//tiwdtmyxqFxIh6PfX3Rbr+96RA+Orw94AC48cbY56dNswdENleh7XDYofkBBzQct3kz3Hxz8xXa4cB6+vTYIP2bb+Cjj5reP3w/J8f+ACfa119DeXni/aPv9+rVuGf5pk1Nv8bwY1Vvd3kKa0VERERERERSjWHYgY3L1XKv2IIC2H//5vexLPwVFWTEBzmHHNL26uWbbmrbcX362C0JLKuhz3I4xIy/X1AQe+yBB8Lo0U3vH76fKHCdPBn23jtxoBz9OFEwfdxxdvVnS8f26xd7XEaG3UIi0XXGHxs/mC88YDF6n0TV1ok+cEg2XI7/mskeF76+aFsSpDd3bPj1Q+KQe/162Lix5a8bXfEMUF0N77zT8nFgV2lHh7Vffmn3p27JsGGNw9r77mscVidy0kl2+5hoRx7ZdMV9mGHAnXfCPvs0bPv8c/jrX1sOep1OePTR2L9TCxfC22+3fOyoUXDKKbHX8uSTdsV1U1/L4cDYe+/Y760orBURERERERGRThDu4Zqof29TcnPtW1vssYd9a4sLLmjbcdts07jXb7LOPNO+RQsHvtFhb6JKyptvBq83cbAcfX/gwNjjPB745z+b3j+6gnrAgNhjhw+HP/6x+QrtUChxr+eRI+0K3+YqtEOhxl8T7KDP7286RA9ra7ic6NgtqdJO9uvGh/DhDzdaYlmN/074fHZomoz4Y9essauIWzJhQuOw9vnnW6wON+691w61JUJhrYiIiIiIiIhIV5BsH9e+fdt2fre77ZXWo0bZvX3b4pRTGgd9yXryyeafD4fb8d+34cPh1Vebr9AO349u9wB2tezw4c0fGwpBdnbj6/nd72D33RPvHx02xw+DtCx7uGBTFdrR9+PbuHg8dp/g8H5NHZso6G1ruJzssYkC7R7OsKxkYnlpSSgUYtmyZYwZMwZnN/+LZlkWFRUV5OXlYagXioikAK1LIpJqtC6JSKrRuiQibVLf87pR2474++npjSu1v/kGamubPMYKBqnYZRfyBg3q9utSa3JDVdaKiIiIiIiIiIhIYx5P61qVRNtpp+aftyyoqGjbubuxJGrnRURERERERERERKSjKawVERERERERERERSQEKa0VERERERERERERSgMJaERERERERERERkRSgsFZEREREREREREQkBSisFREREREREREREUkBCmtFREREREREREREUoDCWhEREREREREREZEUoLBWREREREREREREJAUorBURERERERERERFJAQprRURERERERERERFKAwloRERERERERERGRFKCwVkRERERERERERCQFKKwVERERERERERERSQEKa0VERERERERERERSgMJaERERERERERERkRTg6uwL6C4sywIgFAp18pV0PMuyME2TUCiEYRidfTkiIlqXRCTlaF0SkVSjdUlEUk1PWpfCeWE4P2yOwtp2YpomAF999VUnX4mIiIiIiIiIiIikmnB+2BzDSibSlRaZpkkwGMThcHT7TwNEREREREREREQkOeEqYpfLhcPRfFdahbUiIiIiIiIiIiIiKUADxkRERERERERERERSgMJaERERERERERERkRSgsFZEREREREREREQkBSisFREREREREREREUkBCmtFREREREREREREUoDCWhEREREREREREZEUoLBWREREREREREREJAUorBURERERERERERFJAQprRURERERERERERFKAwloRERERERERERGRFKCwVjqEaZoJt1uWtZWvRESksabWKBGRzqJ1SURSXfTPcvq5TkQ6W3fOnVydfQHS/ZimicNhfw7wxhtvUFRURCAQYNq0aRiG0clXJyI9XfQa9eabb/LDDz8wZMgQJk2ahMfj6eSrE5GeSOuSiKS66HUKoK6ujszMzE68IhHpyaLXpFdffZWioiJ8Ph/nnntut8idFNZKuwv/B3PzzTfz0ksv0bdvX/bee2/8fr9+4BCRThe/Rg0YMIAddtiBSZMmdfKViUhPpXVJRFJZdCjy6KOPsmTJEkpLS7nmmmsYPXp0J1+diPRE8e+d+vfvz4QJE7pN7qSwVjrEk08+yYsvvsgjjzzCyJEjqaioYMOGDSxZsoSJEydSUFCAZVnd4hMPEel6FixYwOLFi7nnnnvYddddKS8vZ926dXz//fcMGjSIXXfdtbMvUUR6GK1LIpKqwqHIrbfeyvPPP89RRx3F+PHjGTJkSCdfmYj0ZE899RQvvfQSjzzyCKNGjaK0tJR169bx8ccfM3HiRPr169dlcyeFtdIh1q9fz5QpU9h222356quvWLBgAf/9738pLy/nwQcf5JlnniErK6uzL1NEeqgVK1Zw2GGHseuuu/LZZ5/x3HPP8dZbb+Hz+Rg2bBjXXXcdO++8c2dfpoj0IFqXRCSVffTRR7zyyivce++97LLLLqxfv54lS5bw3HPPsdNOO3H66aerLYKIbFUbN27kuOOOY9SoUSxfvpwFCxbw1ltvUVlZyQMPPMBzzz1Hbm5uZ19mmyislS0W/UlF+Fdk1q9fz3vvvUdFRQULFy5kwoQJnHvuueyzzz4cf/zxvP/++/z2t7/t5CsXkZ4g0aepeXl5LFy4kOrqal5//XX23HNPLrnkEoYOHcoFF1xAaWlpJ12tiPQEWpdEpKupq6tj0KBBDBo0iPfff59HHnmEn3/+mcLCQt544w2cTifTpk3r7MsUkW4qUe60ceNGXnnlFSoqKnj++efZZ599OO+889h///055phj+N///seRRx7ZyVfeNgprZYtE9y+yLAufz0dGRgY33ngjM2bMYMWKFcyYMYNDDjmEvn37snHjRoYPH07v3r07+cpFpCeIXqO8Xi9OpxO3282kSZMoKSlh+fLlzJgxg4kTJ9K3b1+8Xi+DBg3qFhNERSQ1aV0SkVQXP0wMoG/fvnz66adMnTqV77//nqOPPprJkyfz29/+losuuogNGzZ00tWKSHcXvSaFQiG8Xi9ZWVnccMMNBINB1qxZw5VXXskhhxxCYWEhxcXFDB06lD59+nTylbedYemdn7SDhx56iE8++YS1a9cyfvx4zjzzTIYNGwZARUUFbreb8vJyrr/+ekpKSvjPf/6D0+ns5KsWke4s+tPXBx54gC+++IJff/2VcePGcfrppzNixAgA/H5/pDLksssuo7KykqeeekprlIi0O61LIpLqokORNWvWEAqFyMrKon///ixbtoyPP/6Y3Xbbjb333jtyzJQpUzj44IM5++yzO+uyRaQHeOCBB/joo49Yt24du+++O9OmTWPkyJEAlJWV4Xa7KSsr46abbqK4uLhLv3dSWCttEv2P+N13382jjz7KSSedhGmaPPvsswwcOJCLLrqI3XbbjVmzZvHaa6/Rt29fsrOzefzxx3G73YRCoS77H46IpLboNeq+++7j/vvvZ/r06axevZpVq1axevVq7r33XvbYY4/IsIzCwkLS09N54okntEaJSLvTuiQiXcntt9/O4sWLqaqqwu/3M3XqVE488UT69u3LypUrWbFiBS6XiwULFrB+/Xqee+45XC794q6ItJ/o905z587l4Ycf5rTTTgPswawFBQX85S9/YY899uD222/nxRdfZODAgd0id1JYK1tk+fLlvPrqq+y5554ceOCBABQVFTFt2jT69OnDnDlzCAQCvPnmmwwePJi99toLp9NJMBjUP+Yi0uF++uknbr/9do4++uhIn+yvvvqKu+++m5UrV/L000+zadMmVq9eTVpaGgcccIDWKBHpUFqXRCQVRVf+v/3221x++eXccsst5OTksHTpUubOncvvfvc7zjnnHL7//nsuvfRShg8fTt++fbnrrru6dCgiIqlt2bJlvPnmm4wZM4ZDDjkEgOLiYs466ywyMzOZO3cuLpeL1157jcGDBzNu3Lgu/95JYa202ZIlS5g2bRrBYJC5c+dywAEH4Pf78Xg8/Pzzzxx11FFce+21HH/88THH6R9xEdkaXnvtNa6//nqCwSCzZs3iN7/5TeS5Tz75hGuuuYZLL7008g9+mNYoEekoWpdEJNU9++yzrF69GrfbzUUXXRTZvmDBAmbOnMk///lPjjrqKH799Veys7PJz8/HMIwuHYqISOpaunQpZ511Fj6fj3vuuYeJEydGcqcNGzYwadIkZsyYwSmnnBJzXFd/7+RoeRcRW3yu379/f84880ycTierVq0CwO12EwwGGTBgANtssw3V1dWNztOV/4MRkdQVv0b99re/Zd9996W8vJylS5dSV1cXeW6vvfYiEAjw008/NTqP1igRaS9al0SkKwm3M3jggQeoqqoC7B7aAJMnT+bwww/n3//+N4FAgMGDB9OrVy8Mw8A0TQW1ItIuEuVO06dPJy0tjR9++AEAj8dDMBiksLCQbbbZJub9VFhXf++kFVWSEggEcLvdkfsul4uhQ4cyffp0vF4vd955J7169eKYY47B5XLh9/sxDIPc3NxOvnIR6Qmi1yiA2tpaMjMzufnmmzEMg1dffZXtttuOww47DJfLRVVVFYWFhQwZMqQTr1pEujOtSyKS6qL7QYIdilx88cXcddddvPbaa5xzzjn07t07sp4VFhZSV1cXs7YBMecQEWmr6PdOfr8fp9PJ4MGDI5W18+bNo6CggBNPPDGSO1mW1S1zJ7VBkGb973//Y/fddyc7Oxuwp+999913/Prrr4wdO5ZTTjmFwYMHc8stt/DEE08wZcoU8vLy+PLLLykqKuKll17q8p9oiEjq+uCDD9h3330jjx966CE+++wz1q5dy9ixY5k2bRoDBw7k0ksvZdmyZYwfP56RI0eydOlS1q5dy/PPP69KEBFpV1qXRKSrKSoqoqamhsLCQgoKClixYgVXXXUVtbW1PPTQQxQWFhIKhZg+fTojRozgmmuu6exLFpFu5N1332XMmDHk5eUB9iDWb775hl9++YVx48Zx0kknMXLkSG6//XYefvhhjjnmGPLz8yPZ1KJFi7rdeyd9BCZNuu+++/jLX/7CokWLAPuHjblz57L99tszbNgwPv/8c0499VRWr17NpZdeyimnnML8+fN5/fXXmTx5Mi+88AJOp5NQKNTJr0REuqNnn32Ws846i/nz5wMwZ84c7rnnHrbddlsOPPBAXnnlFS666CK++uorZs2axbhx43juued47bXX2GabbSL/qGuNEpH2onVJRFLd3Llzee+99yKPb775Zs4++2xOOOEEzjrrLK677jq22247rr/+ejIyMjj88MOZMmUKM2bMYP369Vx55ZVA419VFhFpi4ceeoi//OUvvPTSSwA88sgjzJs3j1133ZUddtiBb775htNPP53vv/+eiy++mDPPPJMXX3yRN954gxNPPLHbvnfqXtGztKvp06fz5Zdf8vDDD+P1evn444+59dZbmThxImBP5Lv77ru56KKLePTRRznrrLNIS0tj3rx5lJWV4Xa7Iy0TRETak9/v55BDDuHHH3/k6quvprq6mpqaGm677TYOOOAAAE488UTOOussbrnlFh5//HH++c9/YpomX3/9Nf37949MPdav7olIe9C6JCKpbuXKldx3332MHz+enJwcfvnlFxYtWsQNN9yAx+Phiy++4Mknn6S8vJzZs2dz3XXXMWvWLD788EOmT5/O7bffDqBhYiLSbqZOncpXX33Fo48+is/nY8mSJdx8882RYatfffUVc+fO5eKLL+aRRx7hD3/4A263mzlz5rB27dpIUNvd3jt1r1cj7eKss87i3//+N4ZhMGfOHEaMGMFjjz3GsmXLyMnJiew3ZswYzjjjDPx+Pz/88AN9+vTh5JNP5swzz+S6667jkUcewe12YxhGJ74aEelu/va3v/HAAw/g8Xg4//zz+cMf/sCsWbN47LHHIj84+P1+Bg4cyNy5c/nyyy9ZuHAhALfccgs77LADTzzxBPfffz81NTVao0Rki2ldEpFUV1ZWxsiRI7n//vtZs2YNDz74IO+99x6nnnoqBxxwAHvvvTd//OMfueyyy/j888954oknGD16NOeeey677rorN9xwA6WlpQBao0Rki/3xj3/k/vvvB+D2229nhx124PHHH2fp0qVkZWVF9ttll104/fTTsSyLFStWUFBQwOTJkzn77LO59dZbmTt3Lk6ns9utSwprJcbrr7/OBx98wA033MCTTz6JYRjce++97LHHHlRWVrJ06VJ8Pl9k/3322Ye6ujq+/vprwG5KP3XqVCZPnsycOXOorKzUr8iISLtZtGgRzz77LIsXL+bpp5/G4XBw3nnnMX36dCzL4scffwTA7XYTDAYZOHAgw4cPp7q6OnKO2267jeHDh/PKK68QDAY766WISDehdUlEUt3xxx/PQQcdxIYNGxg3bhw33HADP/zwA4sXL2bjxo2R/TIzM5k0aRKjR4/myy+/BGDs2LFcccUVDBo0iAMOOIDi4mLNJBGRLfLWW2/x8ccfc9ttt/HII48A8K9//Yt99tmHmpoali5dSl1dXWT/vffeG7/fH8md+vXrxxlnnMEpp5zCgw8+SHl5ebfLnRTWSozx48ez7777MnDgQK677rrIJx2zZs3i0EMP5eWXX+btt9+O/IdQXV1NYWEhAwYMiJyjT58+XHDBBbz22mvk5uZ2u084RKTz7LbbbvTp04eff/6ZxYsXM3/+fDweD1OnTuWMM87gzjvv5Pnnn8cwDFwuF5ZlYZomGRkZAJEQZN68edx7772RJvYiIm2ldUlEUllNTQ3FxcV4vV5OPvlkfv31V/bcc09mzZrF0KFD+eabb1i+fHlk/7S0NEaMGEFZWRl+vx+w17nLLruMsWPHxnzQJCLSFuPGjWP//fdnyJAh/POf/2TOnDkA3HTTTRxxxBG88sorvPXWW5H3SJWVleTn58fkToWFhZx77rm8/vrr5Ofnd7vcybC6W/wsW8Q0TW699VaWLl3KoYceyh133MEll1zCtGnTADjnnHNYvXo1e+65J0OHDmXJkiUUFRXxwgsvRH4A6W7/kYhIajBNE4fDwfPPP8+iRYvw+XwUFRVx+umnc9JJJ+H3+5k7dy7//ve/OfHEE8nIyODbb79l3bp1MRNCQ6GQKkJEpF1oXRKRVBb+2WzevHm88cYbmKbJunXreOaZZxgyZAhLly7l8ssvZ/fdd+fUU09lzJgxVFZWcvbZZ7PDDjtw9dVXx/x85/P5SEtL6+RXJSLdwW233cYHH3zAUUcdxezZszn33HP585//DMAFF1zADz/8wNixYxk6dCiff/55j8udFNZK5AeN8J8VFRVMnjyZo446CofDwZw5c5gxYwZTp04F4C9/+QuvvvoqY8aMYc899+TCCy+MNHXWDxoi0hHC6xPA8uXLeeCBBzjzzDNZtGgRb7zxBlOnTo0JRp566in69u3Lueeey1FHHaU1SkTandYlEekqvv32W8466yxOO+00vvnmGz777LNIYLtkyRKuvPJKwP7V4rS0NMrLy3n66adxu909IhQRkY4XXkvC759qamqYPHkyhx56KFlZWcyePZuLLrqIc889F4DLLruMl156id122429996b888/v0e9d9IIxx6uvLyc/Px8ABwOB36/n7y8PE455RTWrl3LH/7wB2pra7nlllswDIMzzzyTO+64gzPOOIMRI0Zw8cUXYxhGj/kPRkS2rlWrVrHNNtvEfKC066670qtXL2bPns3jjz9OIBDg0UcfBeCkk07i7LPPJhAIsG7dOn7/+99rjRKRdqV1SUS6guiarB133JGzzjqLjz/+mFNPPZWKigqmTJnC/Pnz2XPPPbnlllu48sorWbVqFX/961/53e9+h9PpJBgMRn4DQESkrYqLi+nduzfQkDtlZWVx0kknsWbNGk444QRqa2u58847ATj33HO59dZbKSsrY8CAAVx00UU97r2TKmt7sNNPP53ly5fz17/+ldGjR7PHHntEnvvss8+49NJLufXWWxk7diyzZs3iwQcf5PLLL+ePf/wj0FBRok9bRaQjnHPOOfz888/sv//+XHDBBWRkZET+cS4rK+P//u//OO2005g4cSKXXnopn3/+OX/84x+ZPHkywWCQ7OzsmE9vRUS2lNYlEUl1Cxcu5Mgjj8ThcEQGG7pcLr744gvmzZvHeeedR3Z2Nn/9619Zu3Yt8+fPZ8iQIXz00Uc89dRT3HHHHT0uFBGRjnPGGWdEWq7ssMMOjB8/PvLc8uXLueiii7jxxhvZZ599uPPOO5k7dy4XX3wxZ599NtBzcyeFtT3UkiVLuPjiiykpKWH8+PH4fD523313zjzzTAoLC3G73dx555188cUX/Otf/yIYDPLoo48yb948brvtNo488kgA/bAhIh3i/fffZ9q0aXg8HhwOBwMHDmTSpEkccsgh7LjjjgQCAWbPnk1RUVHkE9jLL7+cxYsXc/PNN3PEEUcA9Lh/1EWk43z00UeceeaZWpdEJGVddNFFvPbaa+y9996MHz+eo446iqFDh0aev+SSSyguLuaxxx7j+++/59prr2Xt2rX8+9//Zvjw4ZH99DOeiLSHpUuX8pe//IXi4mLGjRtHIBBghx12YPr06fTp0wePx8O9997LBx98wJ133onT6eTxxx9nzpw5/OMf/+DYY48Feuaa1LNerQDwr3/9C8MwmDFjBsOGDWPz5s1MnTqV//73v1x44YXcdNNNVFVVMWnSJPLz81m5ciUFBQVMmTKFa665ht/+9reRc/W0/2BEZOv4zW9+w/XXX09ubi6///3v2X777fnxxx/5wx/+wNy5cykqKuLPf/4zX3/9NQsWLADgn//8J+eee27MGqVARETay957783MmTO1LolISiouLiY/Px+Px8PKlSv5+eefOe6443jkkUf4+uuvAbj22mtxOp28+eabjB49miuvvJKsrCxuuukmwA5EQD/jiUj72H777bniiisYMWIEGzduZNq0aSxZsoQLL7yQG264gdLSUg455BAKCwtZtWoVeXl5nHDCCVx//fX87ne/i5ynJ65JqqztYaZMmUJtbS2LFi2irq6O119/nRtvvJFDDz2U66+/nscee4wXX3yRTZs2cfbZZzN//ny23XZbZs+eHXMe9S8SkY4wefJkJk6cGGks/8gjj/D444/z29/+lv3335+NGzdyzz33kJWVxfjx48nJyWHTpk1cfvnlZGZmRs6jX90Tkfbi9/txOp2RNeXBBx/kiSeeYNKkSVqXRCSlrF69mqeffppHH32USy65hEGDBnHHHXeQk5PDPvvsw6mnnsqcOXMoKCjgkksuAWDlypUMHz5c65OItCu/34/H48Hv9/Pmm28yc+ZM9ttvP2bNmsWTTz7J888/z88//8y5557LwoULGTp0KHPmzIk5R0/OnRTW9iAnn3wyfr+fxx57jKysLIBIYHvVVVdxxBFH8M9//hOA2267jdWrV/P999+zdu1aHn74Yfbee+/OvHwR6eZOOeUUfD4fjz/+eEzA8cgjj/Dggw9y6KGHcumll1JVVcVHH33Evffey88//4xlWbz44otst912nXj1ItId3XDDDaxatYrMzExGjhzJxRdfDNjr0gMPPMBhhx2mdUlEOlVRURHV1dWR9Wbz5s3cddddzJ8/n8cee4zRo0fz4osvctddd7H77rvjcDh45513eOCBB9hnn30i59EHSiLSHmbOnMn69evZuHEjJ554Ivvuuy9Dhgzh5Zdf5sorr2TixImRYsC77rqLFStWsGLFCn7++WcefPBB9t13305+BalBYW0PcfLJJxMMBiO/lgcNlSI1NTW89dZb3Hrrrey2227cc889AHz//ff8+OOPvPTSS8ydO1f/eItIhznppJMAeOCBB8jOzm70/COPPMK8efOYNGkS06dPZ+DAgYRCIR5++GFWrlzJDTfcoDVKRNrV9OnTKSkp4aCDDmLjxo18+OGH5Ofnc8cddzB06FAef/xx5s6dy29/+1utSyLSKc477zxWrVrFxo0b2WabbTj55JM5/PDDsSyLG2+8keeee445c+ZwyCGHUF5ezgMPPMC6det45ZVXOP/88zn//PM7+yWISDdy1llnRd47lZaW8t///pedd96Z008/nX333ZeXX36Zv/3tb+y1117ce++9APz444+sWrWK559/njlz5ui9Uz2FtT2Az+dj8uTJFBYW8vDDDwP2fxDz5s1jxYoV9OvXj2HDhrHzzjsze/ZsdtllF+6+++5G59GnrSLSEcI/TLz66qv07t0bsKeql5aWsmHDBiZMmIDT6eTJJ59kzpw5HH744ZxyyimMHDky5jw9+ddkRKR9ffnll1xxxRXcfffdjBgxAoDvvvuOyy+/nLq6OubMmcN2223Ho48+yn333cekSZO0LonIVjVjxgxWr17NJZdcQn5+PnPnzmXNmjXsuuuuXHbZZTidTm666SYWLlzILbfcwtFHH00gEMDn8/HKK69w7LHHan0SkXazdOlSrrvuOu6//3769esHwFtvvcXjjz9OZWUlF154IQcccAAvv/wyV199NWPHjmXevHmNzqPcydbzuvT2QGlpaVx55ZUUFxczb9481q5dG/kU9fDDD6ewsJAlS5bwv//9j0suuYSlS5fyhz/8odF59B+MiHSE7OxshgwZwooVKwBYsWIF5557LmeffTbnn38+Rx55JB9++CGnnHIK55xzDm+88Qbz5s2jqKgo5jz6gUNE2kt1dTUlJSX07ds3sm2HHXbggQceIDc3l4suuojKykr+8Ic/MG3aNK1LIrJVlZeXs2bNGs4++2z23ntvdthhB+68806OOOIIvv76a66//npM0+SKK65g8uTJzJgxg8WLF+N2u8nOzmby5Mm4XC6CwWBnvxQR6SYMw6C4uJjy8vLItokTJ/LnP/+ZPn36MG/ePD7//HOOOOIIrrvuOr788ktOPPHERudR7mRTWNtD7LLLLhx88MG899573HzzzUyaNCkyofjaa6/lsMMOY+3atYwdO5ZLLrkEh8MRmQYqItKRLrroIvr27cutt97KmjVruOaaa9h99925/vrreeaZZ+jXrx8zZsygtLSUM844g5NPPpnKykr69+/f2ZcuIt3M7NmzWblyJTvssAMej4f58+dHnjNNkz59+vCvf/0L0zS58MILATjzzDM55ZRTtC6JyFbjcrnwer1s3LgRgEAggGEYnHPOOfz+979n5cqVzJs3j7S0NM4//3xOOukk/u///o+PPvqo0XlERNqD2+0G7EGHYK9LAOPGjePMM8/ENE2eeeYZ/H4/Bx54IDNmzCAnJ0e5UxPUBqEH2bBhA5deeilLly7lmmuu4eSTT8Y0TRwOB6tXr+bwww/n6aefZscdd4z8hxZ+XkSkPT3wwAOsX78egOOOO46hQ4dyyimn4PV6Ofjggzn//PMjvWuDwSCHHXYYkydP5txzzwXAsiwMw9AaJSLtZsqUKdTV1fHMM89E+j2uWbOG6dOns//++wMNa8+7777LTTfdxA033MD48eNjntO6JCIdLRQKMW3aNAKBAI888ggulysyeR1g1qxZvPHGG9x2223svPPO/Pzzz7zxxhv88Y9/VEArIu0met0BuOKKK3jrrbd45plnGDJkCIFAIJItLV68mMsvv5wFCxYwevTomGP13qkxfTd6kP79+3PFFVdw4IEHcsIJJwBE/oPw+/3suOOOZGdnR/5jin5eRKS9nHnmmbz44otUVlby/vvvM2PGDN577z3+7//+j19//ZWKioqYoDYUCtG7d++YX4kxDAPLsrRGiUi7OPnkkwmFQjz99NOkpaWRnp7OaaedRk1NDf/+978j1WiGYQCw7bbbUlpaSklJSeQcWpdEpCOtXr2aoqIiiouLcTqdXHXVVaxYseL/2bvv+JjvP4Djr7vL3iKREDtIyCD2qr1HrZoVrVWj6KIoVdWWailqK61ZexNaM1ZQqzYxgsQMiex1d78/4r6/O0lINBrq/Xw88njkvvPznXf3vvf3/WHMmDEAWFhYkJKSAsDQoUMxMzNTOpcuVqwYffr0kdIHQohc8+2339K/f38GDRrElClTABg+fDhlypShW7du3Lt3D3Nzc+We07JlS1xcXLh48SKASZBXPjtlJHvkDePj48OcOXMwNzfn9OnThIeHExERwZQpU7CyslI60RBCiJdh5syZJCYm8vvvv/Pjjz+yadMmNBoN27Zto2LFikyYMIGvvvpKmd7MzAzDAyAODg4myzIETYQQ4p/o2rUraWlprF27FhsbGyC9c1YvLy9GjhzJjRs3WL58OVu2bFHmsbW1pUiRIlhbW5ssS+5LQoiXYeDAgQwZMoR27doxcOBA1qxZQ8mSJRk9ejRbtmwxCdgaPjeVK1cu02VJZq0Q4p/q27cvJ06cICAgACcnJzZt2kSnTp149OgRw4cPx8PDgw4dOnD+/HnlnvPw4UOsrKxwcnLK28a/JuRO/YYKDQ2lU6dO2Nvb4+7ujoODA4sWLVJq1covG0KIl+H27duUKVMGOzs7UlJSsLS0pFu3bkyaNIm0tDTatWsHQFBQEJcuXcLPz4/ly5eTnJysPBEghBC5JTk5mfj4ePLnz68MCw0NZc6cOVy+fBkvLy/c3d2Jiori999/Z8+ePfj4+LBnzx50Oh21a9fOw9YLId4En332Gffv32fcuHHcuXOHM2fOMHr0aG7dukW3bt0YPXo048ePJy4ujtGjR2NjY4NGo+HWrVtUrVo1r5svhPiPOX36NBEREcycOVNJ9rtw4QLDhw9nyJAh/Pjjj3z77bf88MMPdOvWja5du2JlZcXff/+NtbU1b731Vh5vwetBgrVvqNKlS7NhwwbCw8NxcHCgcuXKqNVq0tLS5NdWIUSu0+v16PV67t27p9xjDI++2Nvbk5SUpGSCREdHs2vXLg4cOEBISAhubm6sWbMGMzMztFqt9BAqhMg1lpaWfPHFF3z33XfMnTuXli1bMmjQIPz8/GjevDlhYWGkpqZiZmZG69at2bBhA9HR0RQoUIBff/0VjUYj9yUhxEuTkJDAvXv3+OCDDwgICCAgIIBGjRrh6enJV199RWpqKgMGDMDV1ZXRo0fTo0cPLCws0Gg0JCUlKR0hCiFEbomKiuLhw4cUKFBAGVa2bFkWLFhAv379GDFiBAsXLmTevHnMmTOH48ePk5SUhIeHB3PnzpXPTtkkUbk3mLe3N97e3sprrVYrgVohxEuhUqlQqVR06dKFdevW8ejRI5ydnYH0YAmk16fV6/U4OTnxzTffkJSUhJWVFdbW1qhUKvkxSQjxUvj5+dGwYUP27dvH2bNnadasGYMHD1Z6W58/fz4HDhygRYsWSm1bwxcMuS8JIV4WnU5HUlISFy9eJCYmRhluYWHBO++8g6WlJcOHDydfvnz07duXP/74g9WrVxMfH4+trS2BgYHyQ7cQItf5+flha2vL8uXL6dOnD5B+v3J1dWXGjBn07NmToUOHsmDBAvr3709ycjIWFhZKqSj57JQ98qy7UMibuBDiZWvUqBHfffedEqiF9A4ODQFZQwc9EyZM4ODBg9jY2CjD5E1dCPEy2Nra0qVLF1QqFTt27MDd3R0zMzN0Oh1WVla0bNmSU6dOcf78eeD/n5fkviSEeJnUajXOzs40b96ctWvXcu3aNZPxrVu35vPPP2fatGns378fOzs7evbsyaBBg+jZs6cEaoUQuWb+/Pl88803fPfdd5w4cYKaNWsSEhJCcHAwkH6/0uv1FCpUiC+++ILw8HCOHTsGgLm5uRKolc9O2SfBWiGEEP+qfPnyAem/wAKEh4ej0WiUmpF9+/YlJCSE5s2bK/NIpz1CiJfJ3d2dkSNHUq9ePaU+tqF+f0pKCuXKlTN53A/kviSEeDmmTJnCggULlNc1atQgISGB1atXc+/ePZNp27RpQ9WqVTl9+jSQ/qSkMQnUCiH+qZ49e7Jp0yYeP35McHAwv/32Gw4ODjx69IilS5dy+PBh4P+fi0qXLs2jR4+IjIwEMOkPST47ZZ+EtIUQQuQJ40CIpaUlqampfPjhh0RERLBt2zbJCBFC/Kt8fHyYM2cOkN55hrOzMyqViilTpmBlZaV0oiGEEC9LSkoKf//9N9euXcPOzo7OnTvTokULrly5woYNG7C0tKRz584ULFgQSP8B3MLCgoiICECCs0KI3DVz5kwSExP5/fffsbOzIykpiY4dOxITE8PXX3/N559/zi+//EJUVJSSaGNra0uRIkWwtrbO49a/3iRYK4QQIk/o9XpUKhX29vbodDq6detGbGwsQUFBmJubSz0jIUSeCA0NpVOnTtjb2+Pu7o6DgwOLFi1CrVaj0+lMMkSEECK3aLVaLCwssLKyQqfTsWzZMlJSUggMDGTIkCEkJyezdetWHj16xPvvv0/JkiWJj48nLi4Of3//vG6+EOI/6Pbt25QpUwY7OztSUlKwsrKiW7duTJo0ia+++ooJEyYwZcoUZs+eze7duylbtix79uxBp9NRu3btvG7+a02+BQshhMgThsdgvL29efDgAa6urhKoFULkudKlS7NhwwbCw8NxcHCgcuXKqNVquS8JIV4qQw/p169fp2HDhiQlJbFq1SoAAgMDGTZsGM7OzuzevZvu3bvj6elJTEwMOp2ODz74II9bL4T4L9Hr9ej1eu7du6d89rGwsADAwcGB5ORkoqKiCAgI4Ntvv+XQoUOsXbuWyMhIChQowK+//qrc0yTj/8XIJ04hhBB5qly5cgwePJh+/fphZmYmAREhRJ7z9vbG29tbea3VauW+JIR46SIiIrC3tycwMBC1Ws3MmTNNAra9e/emVq1aXLhwgatXr+Li4kL37t2ldJQQIlcZOn7u0qUL69at49GjR0oH0ZaWlkB6QFen01G0aFGKFi1Kly5dTJYh3+n+GZVer9fndSOEEEIIkDd1IYQQQry5UlJS2LZtG40aNcLW1pbQ0FDmzp3LpUuX6Ny5M927d890PgnUCiFelqioKKWDaICgoCC++uortm7dqnS+OmrUKKpUqULbtm2B/5e7Ey9Oim4JIYR4ZUigVgghhBBvKgsLC95++21sbW3RarWULl2a/v374+XlxapVq1i+fHmm80mgVgjxshgCtTqdDoDw8HA0Gg358+cHoE+fPhw5coRWrVop80ig9p+TYK0QQgghhBBCCPEKMAQ5DAHYUqVK0b9/f7y9vZkxYwY7duzIy+YJId5Qhg5WU1JSsLS0JDU1lf79+xMREcG2bduUciwid0gKkxBCCCGEEEII8YoqVaoUvXr1omjRojRo0CCvmyOEeAMZShvY29uj0+no1q0bsbGx0kH0SyJ7UgghhBBCCCGEeIUZd3woNWqFEP82Q9a/t7c3Dx48wNXVVQK1L5F0MCaEEEIIIYQQQgghhHim2NhYFi9eTL9+/TAzM5NA7UsiwVohhBBCCCGEEEIIIUS2SaD25ZFgrRBCCCGEEEIIIYQQQrwC1HndACGEEEIIIYQQQgghhBASrBVCCCGEEEIIIYQQQohXggRrhRBCCCGEEEIIIYQQ4hUgwVohhBBCCCGEEEIIIYR4BUiwVgghhBBCCCGEEEIIIV4BEqwVQgghhBBCvHZ0Ol1eN0EIIYQQItdJsFYIIYQQ4j+kQYMGeHl54eXlRaNGjUzG3blzRxnn5eXFiBEj/tU2zZs3719Z38sQGBiIl5cXY8aM+dfWGR4ebnK8DH++vr7UqVOHUaNGERMT86+1x8DQjq1bt77wMtatW4eXlxd+fn7PnM54H5w6dUoZvnPnTnr27Pnc6YQQQgghXjcSrBVCCCGE+I+6desW4eHhyuuQkJA8bM3rLV++fLi5ueHo6Jgn63d2dsbNzY0CBQpgZWXFvXv3WLNmDYMHD86T9vxT1tbWuLm54e7unuN5ly1bxocffsitW7deQsuEEEIIIfKWWV43QAghhBBC5D5zc3NSU1MJCQmhY8eOABw+fNhknMi+n3/+OU/XP3v2bCpUqKC8XrRoEePHj+fw4cNcu3aNkiVL5l3jXkDz5s1p3rz5C80bHx+fy60RQgghhHh1SGatEEIIIcR/kOHxcuNsWkOw1t/fP8P0N27cYMiQIdSqVQtfX19q1arF0KFDuX//PgC7d+9WHjP/7bffALh37x6VK1fGy8uLkSNHZrtthkfg27dvz99//02XLl3w9/enUaNGrF+/3mTalJQUpkyZQsOGDfH19aVevXp8++23xMbGmkx37Ngx+vTpQ5UqVahQoQJdunRh9+7dJtMYyjFs376dMWPGULlyZapXr86MGTNISUlh4sSJVKtWjUqVKjFixAiToODTZRCMH7sPCwvjo48+IiAggBo1ajBx4kS0Wq0yb3JyMt999x01atQgICCAzz77jMOHD+Pl5UWDBg2yvd+e3haDpKQk5f/nHUfjbVmyZAnz58+nXr16+Pv78/777xMWFmayni1bttC8eXP8/Pxo3749J0+eNBm/cuVKvLy8aNeunck8hn1z7949AKKjoylbtixeXl5cvnw5yzIIixYtokGDBvj5+REYGMi1a9dMxk+fPp3JkycDEBERgZeXF+vWrTOZJioqis8++4yAgABq1qzJ5MmTpb6tEEIIIV4bklkrhBBCCPEfVLVqVU6cOMHhw4fR6/Vcv36de/fu4e7uTtGiRTl+/LgybUpKCj179iQiIgILCwvs7OyIjIxk8+bNREdHM3/+fBo0aECHDh1Yu3YtP//8M82aNePrr78mNjaWggUL8sUXX+S4jXfv3uX9999HpVKRnJzMrVu3GDlyJP7+/nh6egIwaNAggoODAXBwcODu3bssWbKES5cusWTJEgD+/PNPPv74Y7RaLebm5mg0Gk6ePMmAAQMYPXo0gYGBJusdN24cMTExqNVqYmNjmT59Olu3buX69evY2NgQHx/P+vXrsbOzY/To0c/djt69e/PgwQN0Oh0JCQn8+uuvFCtWjC5dugAwbNgw/vjjDwBsbGzYunUrx44dy/H+MoiJiWHRokUAFClSBC8vLyB7x9HYwoULiYiIwMbGhuTkZEJCQhg+fDgrV64EICgoiM8++wwAMzMzrl27Rq9evUyWUb9+fVQqFRcuXCAyMhIXFxeOHj2qjP/rr79o1aoVBw8eRKfTUaRIEcqUKcPZs2czbNcvv/zCpEmTALCwsODkyZMMGTLEZBo7Ozvs7OyIi4tDo9Hg4uKCtbW1yTQjRowgKSkJrVZLQkIC8+bNw9PTk7Zt2+Z0VwshhBBC/Osks1YIIYQQ4j+oWLFiuLm58fDhQy5duqRk2FapUiXDtLdu3aJkyZL4+vqyf/9+Dh8+rGSQGmdSfvHFF3h4eJCQkECPHj3Ys2cPKpWKCRMmYG9vn+M2Pnz4kG7dunHs2DFWrlyJWq1Gr9ezf/9+AA4ePKgEamfNmsVff/3FqlWrUKvVnDlzhrNnz5KSksLYsWPRarXUr1+fI0eOcOzYMTp37gzADz/8oGR3GlhZWbF3714OHTpE/vz5gfRM2TVr1nD8+HFq164NYBJ0fJZChQoREhLCvn37KFiwIIDS7osXLyqB2sGDB3PixAl27tyJRqPJ0b7q3Lmzkq1apUoVlixZgouLC7NmzVKWld3jaBAZGcmqVas4duwY7777LgCnTp3i8ePHQPo+B/Dx8eHAgQMcO3aMxo0bmyyjQIEC+Pr6otfrOXjwIABHjhxRxv/1118AyjFt2LBhptuXmpqqdEBXp04djh49ytGjRwkICDCZrmfPnvTr1w8Ad3d39u3bl6GcQrly5Th8+DAhISEUL14cIEOWtRBCCCHEq0qCtUIIIYQQ/1GGwOzhw4eVAFq1atUyTOfp6cn8+fNZsWIFYWFhLF68mO3btwOm9UHt7OyYMGECKpWKmzdvAtC9e3dq1Kjxwm3s06cParWaChUqUKBAAQDi4uKA/5dwKFOmjBLk8/f3Z8eOHZw4cQJfX19OnDjBw4cPARg1ahS2traYm5szcuRILCwsSElJYd++fSbrbNKkCS4uLtjZ2VGqVCllX/n6+qJSqZTasNmtjdq9e3dsbW1xdnZW9rlhXkMGs42NDf3790elUlG4cOEM2b7PY9zBmCEwHhkZyTfffENUVBSQ/eNoUKNGDfz9/VGr1SZB2Pj4eOLi4ggNDQXSj1G+fPkwMzNj0KBBGZZjKMlw8OBB7t27R1hYGMWLF0etVivB2gMHDphM+7Rr164RExMDpGdTW1tbY2NjwwcffJCj/QTQrVs3rK2tsbe3p2LFigBKAFoIIYQQ4lUnwVohhBBCiP+oqlWrAulBNEOwNrPMWp1Ox48//ki1atXo3Lkz8+fPJy0tDQC9Xp9hmYYSBUCGTMuc0Gg05MuXT3ltZWVlss7o6GgAk2kAChcujFqd/jE2MjISAJVKhYeHhzKNtbU1Li4uAEow18DR0VH539zcHEDJsAWwtLQ0acfzGM9reCTfMK+htq4h2GlgyMDNrtmzZ7Nv3z7279/PsWPHWLNmDc7Ozhw9epSffvoJyNlxfLrdhn1vWI4hYA7g6uqq/O/u7p5hOcbBWkNd5AYNGlC2bFmuXr3KwYMHefDgAU5OTlSqVCnT7TOuQWy8Pjc3t2fslcwZb5fh+ErNWiGEEEK8LiRYK4QQQgjxH2UI1h44cIDo6GgKFCigPBZubNWqVcyfPx9bW1uCgoLYt28fAwcOzHSZS5cu5cqVK8rrsWPHkpyc/ELte7oUgEqlMnltCKo+XcYgKCiI/fv3ExUVpQRk9Xo9ERERyjSJiYlKINc4+JfZerMall3GQdinGdr36NEjUlNTleF37tx54fVBegdyhizpEydOADk7jmC6zU/vewcHB2WY8f5/+lgAeHt74+HhQWRkpFJHuFq1alSvXh2AKVOmAFC3bt0s95WTk1Om68hsfc9jCOQLIYQQQryO5JOMEEIIIcR/VIkSJXB1dVWyCg3B26ddunQJSM9CdHNzIzExkdWrVyvjDfPfuHGDyZMnA9CmTRvMzc25du0aU6dOfSntN5RXCAsLY+vWrQCcO3eOzz//nD59+nD69GkqVqyoBHXHjx9PfHw8qampTJgwgZSUFKysrKhbt+5LaV92VKxYEZVKRWJiInPnzkWv13Pz5k0WL178j5YbERGhBGkN2afZPY7ZYWNjg4+PDwC//vorUVFRpKamMm3atEynr1+/PgBnzpxBo9FQuXJlJZh85swZIOsSCAAlS5ZUAtuzZ88mMTGR+Ph45syZk2FaQ8A3MTERnU6nZA8LIYQQQvwXSLBWCCGEEOI/zDhAm1Ww1lDXMyIiglq1alGtWjWlUyxIr/ep0+kYOXIkiYmJlCpVim+//ZbevXsDsHDhQqU2a26qVauW0tnXp59+SuXKlXnnnXdITU2lUqVK1K5dGwsLC0aPHo1KpWL37t1Uq1aNypUrs3LlSlQqFV988YUSBMwLJUuWpEWLFgBMnz6dihUr0qRJE5KSknK0nAEDBlCnTh3q1KlDjRo1aNiwIffu3UOlUvHee+8B2TuOOTFkyBDUajXnzp2jVq1aVKlShR07dpiUkTAwDsT6+PhgZ2dH5cqVlTIEFhYWyrHMjFqtZsiQIUB652xVqlShevXqXL58WVmGQZEiRYD0bOUqVaqwbNmyHG2XEEIIIcSrTIK1QgghhBD/YcY1ajOrVwvQunVrPvroI9zd3VGpVBQvXpzvv/9eqf0ZEhLCokWLOH78OCqVinHjxmFhYcGHH35I8eLFTQK5uUmlUjFr1iz69u1LoUKFSEpKomDBgrz33nvMmTNHeYz/7bffZtGiRbz11ltKzdiAgADmzp1L586dc7VNL+K7777j3XffxdHREbVaTadOnfj000+B/9e4fZ5Hjx5x79497t27R3R0NNbW1vj7+/Pzzz8rmcPZOY45UbduXaZPn07p0qXRaDSUKlWKBQsWKB3BGatatSp2dnbA/zuxs7W1xdfXVxlmGJ+Vzp078+233yo1iQMCAli8eHGGYG2dOnVo2bIltra2mJmZYWNjk6PtEkIIIYR4lan02e05QQghhBBCCJEjd+/eZe7cuTg5OVGlShVq1qyJTqdj3LhxLF++nLp16zJv3ry8bqYQQgghhHhFZN0bghBCCCGEEOIfcXZ2ZseOHTx48ACA/Pnzk5iYSEJCAgDt2rXLy+YJIYQQQohXjGTWCiGEEEII8RKFhoby008/cerUKaKjo7GwsMDT05PAwEAJ1gohhBBCCBMSrBVCCCGEEEIIIYQQQohXgHQwJoQQQgghhBBCCCGEEK8ACdYKIYQQQgghhBBCCCHEK0CCtUIIIYQQQgghhBBCCPEKkGCtEEIIIYQQQgghhBBCvAIkWCuEEEIIIYQQQgghhBCvAAnWCiGEEEIIIYQQQgghxCtAgrVCCCGEEEIIIYQQQgjxCpBgrRBCCCGEEEIIIYQQQrwCJFgrhBBCCCGEEEIIIYQQrwAJ1gohhBBCCCGEEEIIIcQrQIK1QgghhBBCCCGEEEII8QqQYK0QQgghhBBCCCGEEEK8AiRYK4QQQgghhBBCCCGEEK8ACdYKIYQQQgghhBBCCCHEK0CCtUIIIYQQQgghhBBCCPEKkGCtEEIIIYQQQgghhBBCvAIkWCuEEK+AESNG4OXl9dy/gQMHmsz3559/8vbbb+Pn50eVKlX4+OOPAXj8+DEjRoygWrVq+Pn50ahRIw4fPvxSt0Gn03HlypWXsuw7d+7w4YcfUqlSJfz9/WnRogVXr17NdNrp06eb7LOmTZtmmGbDhg0Z9m1eCA8PV9Y/atSoPGnDv6FBgwZ4eXnRuHHjPG3HkSNHMr2uvL29KV++PA0bNmTMmDFERkbmaTsNypUrh5eXF4GBgbmyPONr49ixY8+dftasWcr0R44cMRmX2fVufB+7e/durrT533b9+nWTc+P06dN53aTXyo4dO/jggw+oWbMmPj4+VKpUiY4dOzJ//nySk5NNps3p+ZhX4uPjCQ8Pz+tmPFNm9zUfHx+qVavGu+++y6pVq9DpdHnWrvfff18ZlhfH/XU4hv+G+/fvU7ZsWby8vKhcuTIpKSmZTvfrr78qx2jKlCnZXn5Wn2ly+t4watQoZfp/ctzkuAshXmcSrBVCiNdUREQEn3zyCZcuXSIlJYWYmBgSExMB+PHHH1m/fj3R0dGkpKRw69YtbG1tX1pbDh48SPv27Zk/f/5LWf4XX3zBzp07iYuLIzk5matXr5IvX75szRsWFsbt27dNhoWEhLyMZorXlF6vJykpifDwcFauXEmXLl2IiYnJ62a9sl729Z6X1qxZY/J65cqVedSS18/48eMZNGgQwcHBPHz4kLS0NOLi4jh9+jQ//vgj3bp1IyEhIa+bmW1paWksX76cJk2acPTo0bxuTo6lpaURHR3NsWPH+PLLLxkwYABpaWl53ax/1et+DHNbgQIFqF69OgCxsbEcOHAg0+n++OMP5f/WrVv/K23LTXLchRD/BWZ53QAhhBCm1qxZg6ura6bjLC0tlf/PnDmjfPHq0KED/fr1Q6PRAHDq1Cll+qVLl2JhYYGnp+dLae+9e/fo1asXAN7e3i9lHYbtcXV15ddff0Wr1eLs7Jzt+Q8dOsQ777yjvH7ZWcbC1MqVK9Fqtcr5+Sro3bs3PXr0AECr1RITE8OcOXPYvn07t27dYsmSJXz44Yd53Mrc1bNnTzp27AiQo+vH2L9xveeVtLQ0Nm7caDIsKCiIkSNHYmdnl0etej2cP3+eRYsWARAQEMDgwYMpUqQI9+/fZ9q0aRw9epSzZ8+ycOFC5QmR3DgfX6agoCDGjh2b183IkUqVKvHTTz+h1+tJTEzk6tWrzJ49m3PnzrF3715mzJihPIGTV/7N4/46HsOXrXXr1hw6dAhI3z8NGjQwGX/37l3+/vtvAMqWLUupUqX+8TpHjhypnHdZfb7NTXLchRD/BZJZK4QQrxhXV1fc3d0z/TPOJjVk0QJUrVqVYsWKUbhwYQAle6lAgQL4+/vj7e2Nubn5S2mvXq9/Kcs1ZtgeT09PypQpQ9myZbM1n4eHB2CaSXvt2jXlMTzD/hIvl+Gc/je+pGWXnZ2dcl15eHhQtmxZxowZo4w/c+ZMHrbu5TDeZgsLixdaxr9xveeVvXv38uDBAwCKFy8OpN97Nm/enIetej0Yl8kYMGAAtWrVomjRolSuXJkpU6agVqd/5TC+F+fG+fgyvY7nuoWFBe7u7hQsWJCSJUvSuHFjFi1apNx7Fy1aRGxsbJ628d887q/jMXzZmjRpovzwv3v37gzlSf744w9lv+VWVq2jo6NyzP+NH23luAsh/gskWCuEEK+hBg0aMGLECOX18OHD8fLyYt26dXh5eREREQHArVu3MtS8/Pvvv/nggw+oXLky/v7+tG3blmXLlmVaz+706dMMGjSIGjVqKLVvx44dy71794D0L+h169ZVpl+/fj1eXl5Mnz79udsQEhJC//79qVmzJr6+vjRq1Ijx48eb1As11LYzOHz4MF5eXibb/izVqlVT1mX48G4IFlhaWlK+fPlM57t9+zZffvklDRo0wN/fn4oVK9KqVStmzJihfLG5cuUK5cuXx8vLi/Lly3Pz5k0gPbjTuHFjvLy8KFeuHCdOnMhWW40FBgbi5eVF+/btuXfvHsOGDaNatWqUL1+e9957L9NA4vOOlbGzZ8/y2Wef8dZbb+Hr60vdunUZNWoUt27dMpnOcD55eXlx+fJlfvrpJ+rUqUP58uUJDAzk8uXLxMfHM2HCBGrVqkWFChXo2rUrJ0+eNFlOZjVrjZd98eJFFi5cSNOmTfH19aVp06YsXLgwQ7vDw8P59NNPqVq1KgEBAfTt25dr164p++uf1nZVqVTK/09nfGXnnHjR7bp+/TqDBw+mSpUqBAQEMGjQoEzr7Bm2s02bNibDW7dujZeXF/7+/iZt+eijj/Dy8qJatWqkpaVlWStSr9ezePFimjdvrrRz2bJlGdafk+vd+LwoX748Xbt2zdHjqNu3b+f9999X6m63aNGCadOmERcXZzKd8TZFRUUxdepU6tevj5+fH61bt85RoNVQAkGtVvPjjz8qAcZVq1aZTNemTRu8vLyoUqVKhpqPWdX53bdvH4GBgQQEBBAQEECXLl3YsmWLybzG9R7nz5/P0KFD8ff3p1q1ahw8eBCA0NBQPv30U+rVq4evry+VK1emffv2LFq0KMM9PKfXy9WrV/n444+Vfd68eXNmz56dZV1LY8ZBt0mTJrFv3z7lyQ8XFxdCQkIICQlh5syZynTPql26cuVKWrdujZ+fHw0bNuTXX38lJCQkw7413mdLly4lODiYzp074+/vT61atRg3bhzx8fEmy87OtTx9+nQ+//xzZZ6RI0earDerOtzG179xlrZh2IQJExg/fjwBAQFUrFiRtWvXApCcnMyMGTOUe0XNmjX57LPPuH79+nP3/fPY29sr94yEhASTgHlmNWUN25/ZsTEMmzhxIvv27aNTp074+/tTp04dfvzxR5KSkp7bnmcd9wMHDtC7d2+qVKlC+fLladq0KZMnT+bx48cm0+XGMYTsXZfw/2ujdu3a+Pj4UKFCBdq0acP8+fOzFRg0fk+/fv06AwYMoGLFilSpUoVPP/00Q6kmyP5nteedW0+zs7Ojfv36QPp9Ojg42GS8oQSCWq2mVatWwP/Pz5YtW1KxYkX8/f1p0KABo0ePzvQzxtOyqlmbkpLCzz//TMOGDZV79vbt27NcTm4d9wcPHjB+/HiaNGmCn58f1apVo3///hneo7JzTxZCiJdFyiAIIcQrxpDZlZn8+fP/owzZXbt28dFHH5GamqoMu3DhAuPGjePvv//mhx9+UIbv2LGDTz75xGTaW7dusXz5cvbt28fy5ctfuB3z5s1THtU0XvaiRYsICgpi0aJFuVK2oWrVqqxbt46HDx9y6dIlvL29lRIIFSpUyDSrJzY2lsDAQJNgWXJyMqGhoYSGhnL79m3Gjx9PqVKlGDFiBGPHjiUpKYlRo0axePFifvjhByVw++GHH1KxYsUXbn90dDSdO3fmzp07yrDDhw/Tq1cvdu/ejb29PZC9Y+Xm5gbAxo0bGTVqlMm0d+/eZc2aNWzfvp25c+dSuXLlDG357LPPuHz5svL66NGj9OrVC3d3d5Pg8YkTJ+jduzfbt2+nQIEC2drOb775xuRLe1hYGBMmTMDJyYm2bdsC6TWaO3bsyKNHj5Tp9u3bx5kzZ5T98KK0Wi2RkZFMmjQJSA/atm/fXhmf3XPiRbYrLCyMTp06mdTI3bFjB6dOncrwpbxx48YcPXqUixcvcu/ePdzc3IiMjFSOS3JyMidOnKBGjRqkpaUpXyYbNGiAmVnWH/m++eYbk+BsWFgY48aNy/bxy8yHH35oEmgynBc7duzA3d39mfOOHTs2w/3l6tWrzJo1i+3bt7NkyRJcXFwyzDdo0CCT/X358mWGDh2Km5sbVatWfeY679+/z/79+wGU4Ei1atUICQnh/PnznDlzBj8/PwA6d+7M119/TUxMDDt37qRFixbKcgwBuuLFiys/Fv3++++MGzfO5H538uRJTp48ydWrV/noo48ytGfu3Lkm54S/vz/h4eF0796d6OhoZXhqairnzp3j3LlzxMXFKaU7cnq9nD59mvfff98ksHnt2jWmTp1KSEgIv/766zPPoUaNGvHjjz+SmJjI5cuX6du3L3Z2dlSpUoWaNWvStGlT5R70PD/88AMLFixQXoeHhzNx4sQsf1wzCAoK4sSJE8p+Tk5OZtmyZSQmJjJhwgTgxa/l3LJu3TqT4xoQEEBKSgq9evUyOXcfPnzIli1bCA4OZvHixZQrV+4frdfHx0f5//z58zRp0uQfLe/AgQP89ttvyr6+d+8e8+fP58yZM/z2228vlD25ZMkSvv32W5NhYWFhzJs3jwMHDrB06VJsbW1z7Rhm97qMiIigc+fOJhnJaWlpXLx4kYsXL3L37l1Gjx6drW18+PAhXbp0MbmGt27dytGjR1m7dq1yjeTks5pBZudWVoyDokFBQcr5cP/+feXH1ipVqijt+eyzz9ixY4fJMiIiIli9ejV//fUXQUFBOT7mer2eIUOGsGfPHmXY5cuX+eijjzJ978mt43758mXee+89k3tjSkoKe/bsYe/evYwYMSLDjxeQ+T1ZCCFeJsmsFUKIV8w777xD3bp1M/0z9L6+cuVKRo4cqcwzevRogoODady4McHBwUowxMPDg+DgYKZNm0ZiYiKjR48mNTWV4sWL8+uvv7Jt2zalfuDGjRvZvXs3kJ5tYZjW0dGRn376ie3btyvZChEREcyePZuAgACTDnmaNWtGcHAwPXv2zHL7Tp06xZQpU9Dr9RQpUoTZs2ezdetWPvnkE8zMzHjw4AFDhgxBq9XSs2dPk6yPSpUqERwcbLLtz1K+fHnlcb9Dhw6h0+mUzAlDIOVpO3fuVIKjY8eOZefOnSxbtoxChQoBKPsIoGvXrjRq1AhID16OGDFCCTJVqVKF/v37Z6udWYmIiMDJyYlly5axevVqJcvYECSC7B8rw/9jxowhNTUVZ2dnJk2aRFBQEF999RU2NjbExcUxePDgDNmLkJ7R8vPPP7Nx40YlaPLgwQMuX77MxIkTCQoKMsnWMQS+suP06dN88803BAUFmZw7xplBP/30k/Llqm3btmzcuJGFCxfi4uKiBMdzYtq0aUrGTLly5ahTpw6bNm3CwsKCb7/91iRgnZNzIqfbNWnSJOULYPv27dm4cSMLFizA2to6Q8aWcRbfvn37AJTagwaGHyOOHz+uBBeeFZi5ePGiEqh1cXFh+vTpbN26lT59+nD//n2TaXNyvaelpfHrr7+yceNG5bxISUnJUBP2aUFBQco15OPjw8KFC9m0aZPy5fnatWsMHz4803lDQ0OZNm0amzdvVjLCID0D+HnWr1+vZIIa5n377beV8cbZtW+//TY2NjYAbNiwQRl+4sQJwsLCgPSALqQHscaPH49er8ff35/ff/+drVu3KjU7Z8+ezcWLFzO0JyYmhqFDh7Jt2zamTJmCvb09GzZs4PHjx1hYWDBt2jR27tzJ/Pnzlc4jjc/DnFwver2eUaNGER8fT/78+Zk5cybbt2/nyy+/RK1Wc+TIkef+OOfm5sakSZOwtrZWhsXFxbFnzx6+++47GjRowHfffWcSfMrMtWvX+PXXX4H07PZp06axdetWBg8erNTRzMrx48cJDAwkKCiIiRMnKsGjzZs3K+vN7rXcs2dPkwDcyJEjCQ4OfmYALDtiYmIIDAxk+/btTJs2jZIlS7J48WIlUPvBBx8QFBTEwoULKVmyJLGxsdkOBD6Lg4OD8v/TWaov4vLly9SpU4e1a9eybNkypTTRkSNHsnW9Pe327dtMnDgRgEKFCjF37ly2b9+u3FvOnz/P77//DuTOMczJdfnHH38o99LJkyezc+dO1q5dS9WqVVGr1ezfvz/T98zM3L17FycnJxYsWMDGjRuVe82DBw+YPHkyQI4+qxnL7NzKSp06dXBycgLSy78YSk39+eefyo+EhhIIYWFhyvtNp06d2L59Oxs3bqR27drK+GvXrmVr+43t3r1bCdQWL15c2Sft2rXL8N4DuXPc9Xo9n376KY8ePcLMzIyPP/6YrVu3Mnv2bIoUKYJer+f777/P9ImozO7JQgjxMkmwVgghXkOurq4mX74cHBxwd3fH3t7epCaYRqPB3d0dZ2dnDh48qHx57969O56entjY2NC5c2eKFSsG/D/wcOjQISXzo0+fPrRs2ZISJUrQu3dvRo4cyY8//khgYCAWFhYmdUitra1xd3d/Zmc8xo/xTZs2jQYNGlCqVCn69+9Ply5dgPQSAyEhIUptOwNDPT5HR8ds7ScLCwsqVKgApPdgf/78eWW7sgrWtmvXjpMnTxIUFETXrl0pUqQI+fLlU9rx9Bfdb7/9Vsk+Mew/R0dHfvzxx1ypzWYIHPr7+5sEfw0Z2Nk9VgCrV69WHlP9+uuvad26NZ6ennTr1o3BgwcD8OjRI7Zu3ZqhHZ06daJp06Z4e3ubPIbftm1b2rZti6enp/JFF9IziLKrU6dOdOrUCU9PTz7//HMl4GMoiaHT6ZQvdR4eHnz33Xd4e3tTo0YNJRs2t6SkpLBmzRpu3LihDMvpOZHd7dJqtUpv3EWLFuXbb7/F29ub2rVrZ9o5SsGCBfH19QVQfsQwBGsNATvDo5579+5VhteqVSvL7TX+MWTo0KE0adKEUqVKMWzYsAyBqZxc78OGDaNWrVp4e3sr5xZg8ghsZpYuXQqklymZPXs2NWrUwMvLi5EjRypB3wMHDmT6eHj//v1p1qwZZcqUMflB51lPKxisW7cOAHNzc5o2bQqkB7mtrKwA2LJli5J1amdnpwQyDhw4oCzfcP2bm5srmdPbt29XAoX9+vXDw8MDOzs7Bg4cqATkMwtgFy1alL59+1KyZEkaNmwIpGcOHz9+nM2bN9OsWTM8PDxwcXFRjonhPMzp9XLp0iUlO7tdu3b4+vpibW1No0aNqFKlCpC9gHejRo34448/6N+/f4ZAUVpaGosXL+b7779/5jJ2796t/Ejx6aef0qxZM0qVKsWgQYMylBx4WpkyZRg1ahSenp60bduWmjVrAunZx4Z9k91r2c7OLtP32H9aY9XGxoZhw4ZRokQJmjVrBqA8du/h4cG7776Lra0tJUqUUO7b586dM3mq4UUY//Cj1Wr/0bIg/T1uypQpSikOQ6ARUH5IzIk///xTuU6GDRtGvXr1KFGiBJ9//jlDhgxhypQpyv7KjWOYk+vSENSE9PvrzZs3KVGiBHPnzuXkyZP88ccfOeqAcPz48dSuXRtvb28mTJigtNtw7ufks5qxzM6trFhYWCj3ucTEROX9wlACwcLCQllG8eLFOXnyJNu2bWP06NGUKFECZ2dnpS3wYj8AGL/3fPPNN8o++fbbb5X+BozlxnE/fPgwoaGhQPqP7QMGDKBUqVI0aNCAqVOnAunXSmZlgDK7JwshxMskZRCEEOIVY5wZm5sMGV+QHgB8+nFDSK9l+vS0T3fmldnjYTlhyFZxdHQ0eTQToGbNmkqw5tKlS0rmxj9RtWpVjhw5wvHjx5UvB1ZWVvj7+5tkCRp78OAB27Zt4+jRo1y4cMHk0benH03Ply8f33//vUl24ciRIylYsOA/bjukByCM12VgyALMybEyzuAzBDIye33p0qUM7ShRooTyvyEwCJjUFDYebmhfdhhvo1qtxtHRkcTERGUZjx49UgJlfn5+Jo9je3t7Y2dnl+3MJoPevXvTo0cPID14ERsby9GjR/nxxx85efIkPXv2ZPv27UpwJifnRE62y9BRoK+vr0lwP6tHvps0acLZs2c5dOgQKSkpSv3JXr16MX36dM6cOWNSh7B+/frPDDAZ6ltDxsc6K1SokKH+cHYZnxfGX5yfl1l54cIFIL0zwacfm69Zs6YShLx06ZLJOQnPv1aycvToUeU6KlGiBKdPn1bGlS5dmjNnzpCQkMCWLVuUjNmuXbuycuVKtFotmzZtonv37mzbtg2Apk2bKjWPja9PQ4mCpxnuu8ZKly6d6bQRERFs3ryZY8eOcfHiRSUjDv5/Hub0ejEOfM+fP5/58+dnWO/ly5dJS0t7ZikESM+w/eSTT/jkk0+4d+8ehw4dYuvWrUqm/cqVK/noo49MzgljxnWzn/6xoHLlyhkexTZmfPwh63PgRa7l7Hpe/dKiRYsqT3sYGM6RiIgIk5rQxs6dO5dh+3LC+BH+7PzY+bzt8PLyMrnfe3p64uDgQExMjMk9JbuMrxNvb2/lf7Vanel180+PYU6uy1atWrF161YOHDjAqlWrWLVqFRqNBm9vbxo0aECXLl0yLcuSGY1GY3Jvt7CwwNfXl7t37xIbG0t0dHSOPqsZy+zcepa3336blStXAulPNFSrVk3J8K5fv75J5mhiYiIhISEcOnSIM2fOZKhT+yI/ABifJ8b7xMzMDB8fn0zPo3963A3vLwA1atQwGefr64uTkxPR0dGZfgbK6p4shBAvi2TWCiHEG+J5X7IBoqKiANMvajkJumWHISBl3JmTgfF6Mxv/IgwZtImJiSxZsgTIul4tpHdA1qJFC6ZPn05kZCSdO3dmxowZSrmDzDz9xcmQnfJPaTQak3YaOjwylpNjld1M38z2vfGXQOPxxo89v+gxM2QvGjzdTuM6zZkFEV5kvcY9knt4eODt7U2PHj2UrOGIiAilZMaLnBPZ2S7jdj/9RTOrY2XILoyPj2f16tXcvXsXtVrNu+++S4ECBUhLS2PDhg1cvXrVZPqsGLfh6X2b2fmWXcbb/qx1PM1wn3qR+4PxOnOS1W78o42h3qrhz7gesyGwAek/jBiC21u2bGH37t1K4KBTp045aofhvmsss0dsN27cSNu2bZk3bx6pqan07NmTefPmZQiy5/R6yc57Q2pqqklg5Gk//PADgwYNYtCgQcowNzc32rVrx/z585XHvVNTUzN0ZJiTtj/L8643ePFrOStPB6mMO/jLTGbHNTvniHF9zRdhHHx6+kc9yPl2ZNbpXE6PV1bzPu99LDeOYU6uSwsLCxYsWMCiRYsIDAykTJky6PV6zp07x/Tp02ndunW2A9RarTbDvn76vpaTz2rGcvpYfqVKlZQSAvv27WP9+vUZSiBAeoC0devWjBs3jhMnTlC/fn0mTpxo8sTEi3jW+19m7z25fdyf9R6T2TgpeyCE+LdJZq0QQrwhihYtqvw/ZcoUk05x/v77b4oVK6Y87le8eHFl3NmzZ5XHjwGGDx/O48eP8fX1ZdCgQTkKxEB6Bs6FCxeIjo7m/PnzJh2nGPdSndkXyhdRvnx5rKysSEpKUr7gZFUCAWDmzJkkJyfj6OjIhg0blGDp6tWrM53+/Pnz/Pzzz0D6B3y9Xs+ePXtYvnw5Xbt2zZVteJacHCtPT0/lEdWQkBCTQJ5x7VPjzKZXgaOjo5K1dfbsWZMMv3Pnzplkjf1Txl+UDdmJOT0nssvZ2VnJcjx79ix6vV65njKrmQdQsmRJPD09uXr1KjNmzADSr5V8+fJRs2ZNNmzYoAy3srKiTp06z2yD8X3h9OnTlCpVSnmdWRtyer3nlKenJydPnuTKlStKJ2oGL+P+EBsbm+0fVwwdeRmeCOjSpQunT5/m/PnzSp1V447FAJNHhVetWqVkkKWmpnL+/Hk8PT0zfYQ6s4DN1KlT0Wq1lClThtWrVyvH4unOhnJ6vRifA5999hkffPCByTa7ubk9N3Pw/PnzyvH566+/lPIJmXlWZmeRIkWU/0+dOmWSzWaox/xP5ORafta5bggqG3fIBph0BpmZzI5rsWLFOHfuHCVLllSysyG9jmtSUhJFixbNVgAvKykpKQQFBQHpj8obl0UxNzcnNTU1x9tx+fJloqOjlc8MYWFhynllfM5n19PvY8ZZxL1798ba2prq1avTvXv3XDmGObku7969y5UrV7hz545SCzUuLo41a9YwYcIEHj16xObNm7Ndo/6vv/5SnhpKS0tTsj2dnJxwdHTM0Wc1Yzk9R1QqFa1atWLevHkkJyczc+ZMIP1JCOMM7+XLl3P79m0gvZMtw49DmWXg58TT7z2G+2ZqaqrJj2QGuXHcjTuuPXToEA0aNFBenz17VimlkNlnoH9yDQohxIuQzFohhHjFPHjwgLt372b69/SjZzlRs2ZNpbbhpEmT2Lt3L1evXmX27Nl06tSJatWqKR181KpVS/lCvXDhQjZs2EBYWBiLFy9m48aN7NmzR/nwbpz5aehowvgxvqe98847yv8ff/wxe/bs4erVq8ybN48VK1YA6Y+zPiugmhPGdWsNntUzvOFLa2xsLFu3buX69evMmTPHpMMsQ+ZPUlISQ4cOJTU1FXNzc+bMmaNkX0ycOPGFOt3IqZwcqzZt2ihfOMaOHcvWrVu5evUqK1asYPr06QDkz5+f5s2bv/R251TLli2B9IzX0aNHc+nSJQ4cOMBnn332QsuLi4szubbCwsJYs2aNUgtQo9Eo501OzomcUKvVSlZQeHg4n3/+ORcuXGD//v2MGTMmy/kMQXZDtp3hcU5DKQvD8LfeekvpCOtZyzJkMU2cOJFt27Zx5coVJk6cmGkJhJxe7znVoUMHID2zb+DAgRw+fFjpxM5QAqFOnTomX/T/iS1btih1nN9//30uXbqU4W/IkCHK9MbZtS1btlQe5zeUTjCUSTBo0qSJkpU+duxYk+3p1KkTlSpVUjL+n8dwHt66dYu9e/dy5coVvvvuO6XjSeNzMCfXS5kyZZTgxIIFCwgKCuLatWusWrWKjh07UqtWLZN9kBlDvXGATz75hPXr13Pt2jXOnz/PTz/9pNTB9vHxoXDhwlkup2nTpkog9KeffuLPP//kypUr/PTTTya9xr+onFzLxk8TnD9/nsuXLyvXluFHhOjoaNauXYtOp+PIkSMm50d2GbIYr127xrfffktoaChHjx6lX79+NG/enCpVqmTa4VJmUlJSlHvarVu3OHjwIAMGDFA6lXv33XdNguWG7bh48SIHDx5Eq9Wyfft2/vzzz2euJyEhgY8++ojTp09z6tQppUNLeH42f2aaNGmivDdNmTKFnTt3cv36dX766ScOHDjAjh07lEBabhzDnFyXM2bMoHfv3owePZrJkydz9epV7t27Z1J/OyeBvDFjxrB3714uX77MmDFjlPfnRo0aoVKpcvRZ7Z8yzqA1lFRp2rSpyX3eOJC/adMmwsLC2Lp1q0mw9kXKIBh3fDly5Ej27dvHpUuX+OKLLzLNVM6N416jRg2lHu7y5cuZN28eV69eZe/evXz66adAeqC3e/fuOd4eIYTIbfITkRBCvGKMg5lPs7e3V2qK5ZSVlRUjR45k6NChRERE0K9fP5PxhQsXVuqu2traMm7cOD777DPi4uIy9L5esGBBPvroIyA9G6RgwYLcuXOHU6dO0bx5c7p168ZXX32VaTtq1KhB//79mTNnDjdu3MiQjeLq6srUqVP/0SPYT6tataqSlWWoV5uVJk2acP78eXQ6HSNGjMh0msjISNzd3Zk4caLyuPmAAQOoV68eI0aMYNSoUSQmJjJ06FBWrlxp8mhvbsvJsfL09GT06NF88803REZGKl9ODOzs7Pj5559z1FnKv2XAgAHs2LGDyMhI1q9fr3R4VKhQIWxsbExqd2bHggULWLBgQZbj+/TpowQycnJO5NSnn37KoUOHuH//Pps2bWLTpk1Aer3NQoUKKV/kjTVu3Jg5c+Yorw1B2qfrEBt/Gc5K0aJFGThwIDNmzCA6OpqPP/5YGefj48O5c+dMps/p9Z5T77zzDkePHmXTpk2cPXuW9957z2R8yZIlmTBhQq6sC0xLILRv3z7TaTp27MisWbNIS0tjy5YtjBgxAhsbG6ysrGjTpo0S1DHuWMzAzc2NwYMHM2nSJM6fP59he3x8fJQA9fM0adKE1atXk5iYmGkWX1RUlJJFm5PrRaVSMWrUKPr06UN0dDSffPKJyXKdnJye+8hzs2bN6NSpE6tWreLBgweZXieOjo7PPXbu7u707t2bOXPm8OjRI5P1GjLKDW1+ETm5lo2zt5cuXcrSpUuZOnUqzZs3p1WrVkpnfl988QWjRo1Cr9dToUIFTp06laM2de3alc2bN3Pu3DmWLFmSIXg/YMAAChQokK1lHT9+PMu6t7Vr11beCwxatWrFnDlz0Gq19OrVS3k65Hnb4eLiwvHjx006lTSswzgAmF0eHh4MGzaMCRMmcP/+/Qx1ZL29vZVrJ7eOYXavy8GDB3P48GFu3brFvHnzmDdvnsm0hQoVyvLe8TSVSkVaWlqGz1/u7u7KdZeTz2r/VJkyZfDy8jIpk/H08WvcuDGLFy9Gp9Nlen5C9jpxfFr16tVp164d69evJyIigr59+yrjMnvvya3jPnXqVPr06cPjx4+ZPHmySed4KpWKESNGZFkzXggh/k2SWSuEEG+Qli1bsmjRIurVq4eTkxPm5uYULlyYwMBAVqxYYfKFsFmzZixdupT69evj5OSEhYUFxYoV491332XlypVKIEulUjFu3Dh8fHywtLTE2dmZ/PnzP7Mdn3zyCb/99hsNGzYkf/78mJub4+HhQY8ePdiwYYPJo2q5wThLNyAg4JkdLn3wwQd8+umnSmcdHh4etG3bVil1ALBr1y6Cg4P5/fffgfQvFoYvVO+8847yiOO5c+eUHoZfpuweK/h/x0itWrWiQIECmJub4+bmRocOHdiwYQOVK1d+6e19EW5ubixfvpzGjRtjZ2eHra0tTZs2ZdmyZcrx/Cc9tZuZmWFnZ0f58uX55ptvTALZ2T0nXnS7Vq1aRatWrbC3t8fW1pYmTZqwcuVKJbvqab6+vkp2kIWFBZUqVQLSf+gwPD5sbm5uUhLjWQYPHsx3331HqVKlMDc3p3jx4nz55ZcZAjvwYtd7TqhUKn788UemTp1KrVq1lPtUiRIlGDhwIKtXr852Zz7Pc/HiRaXetI+Pj0mnaMYKFCig9P4dHx+vZIkCJqVOmjRponQsZqxv377MnDmTatWq4eDggKWlJcWLF6d///4sXrz4udnPBqNGjaJXr14UKlQIS0tLihYtSmBgIGPHjgXSsyoPHjwI5Px6qVq1KqtWraJ58+a4uLhgbm5OwYIFad++PatWrcpW5zrffPMNM2bMoG7duuTPn1+5psqUKUOvXr3YunVrlvvY2Mcff8yXX35J8eLFlfNx3LhxdOvWTZnmRa/1nFzLRYsWZdiwYRQrVkx5jzJk7HXs2JGRI0dSrFgxLCwsKFGiBCNHjuTrr7/OcZusrKxYvHgxAwcOxNPTE0tLSxwdHalcuTI///yzSVmKnNBoNDg5OVG1alUmTJjAL7/8kuGHw0GDBjFgwAAKFiyIhYUFZcuWZeLEic99pL906dIsXLgQf39/zM3NcXd3p1+/fsyePfuFf2h9//33mTdvHjVq1MDOzg5ra2s8PT2V68TwI2JuHcPsXpeGe3S/fv0oVaoUtra2mJubU7RoUbp3787q1aszve4zo1arWblyJY0bN8bGxgYHBwdatWrFypUrTe5rOfms9k8ZB2fd3d0zlDAxnIc+Pj5YW1vj4uJC7dq1Wbp0qdLJ3O7du19o3ePHj2fo0KEUKVIEc3NzvL29+emnnzL8CAC5d9z9/f3ZsmUL7733HsWLF8fCwgJHR0fq1avHokWL/nEnukIIkVtU+pdRcEwIIYQQIhcdPHgQCwsL3N3dKViwoPLYqU6no0KFCiQnJ9OyZUt++umnPG6pEHnvdb1e7t27x7lz5yhYsCAFCxY0qc05d+5cpb3btm2jZMmSedTKN5ch2F6jRg0WLlyYt415jQQGBnL06FE0Gg3nz5/P6+YIIYR4DUgZBCGEEEK88pYsWaLUrOzYsSN9+/YlJSWFdevWKT2X+/n55WUThXhlvK7Xy4MHDxgwYACQXvZn1qxZFCxYkBs3brBq1SogvQOkF+nESgghhBDidSHBWiGEEEK88rp3705wcDA6nY7Vq1dn6AHa8Mi2EOL1vV58fHyoXLkyx44dIzY2lsDAwAzT9O/fH41GkwetE0IIIYT4d0jNWiGEEEK88mrXrs1vv/1G/fr1cXV1xczMDAsLC4oWLUqXLl1YuXKlSS/nQrzJXtfrRaVSMXfuXPr370+ZMmWwtrZGrVbj4OBA1apVmTx5Mr17987rZgohhBBCvFRSs1YIIYQQQgghhBBCCCFeAZJZK4QQQgghhBBCCCGEEK8ACdYKIYQQQgghhBBCCCHEK0A6GMslOp2OtLQ01Go1KpUqr5sjhBBCCCGEEEIIIYR4Bej1enQ6HWZmZqjVz86dlWBtLklLS+PMmTN53QwhhBBCCCGEEEIIIcQryM/PDwsLi2dOI8HaXGKIivv5+aHRaPK4NS+XXq8nJiYGBwcHySIWQrwS5L4khHjVyH1JCPGqkfuSEOJV8ybdl7RaLWfOnHluVi1IsDbXGE4qjUbzRgRr1Wo1Go3mP38xCSFeD3JfEkK8auS+JIR41ch9SQjxqnkT70vZ2U7pYEwIIYQQQgghhBBCCCFeAZJZ+xrRp6aCToder8/rpmBnYYE+OZm8b4nICyqVClQqMDd/Y379EkIIIYQQQgghhHjZJFj7GtCnpqJ79Ii0a9fQxcSATpe37QF0Oh1qtRoJ072hVCpUtraYFS+Oxs0N1XOKYwshhBBCCCGEEEKI55Ng7WtAGxlJ8o4d6JOS8ropQHqwVqvVptcUyevGiDyVdvkylnXrYlaiBKr/eK1mIYQQQgghhBBCiJdNgrWvOH1KCmlXr74ygVohTGi1pIWGoilcWIK1QgjxEqSlpZGSkpLXzRAvQK/Xk5ycTEJCgpQMek1ZWFhgZiZfl4QQQgjx75JPH684vU6HPjo6r5shMnEzKoqi+fLldTPynC46GtLS8roZQgjxn6LX67l58yaRkZF53RQh3mguLi4ULVpUAu5CCCGE+NdIsPZVp9ejz6RGbaXJkwFY27MnxZ2dTcYtPXaMKcHBfFCjBv1q1mT8jh0AfNG48ctvby5q9csvfFCjBm/7+v6j5Ww6e5Z5ISFs6duXk+HhDF63jgNDhvyjZV68d4/3fv+dI5988o+Wkx03Hj1iwq5dnLtzBxsLCzoHBNCrWrXnznc4LIzB69axsXdvCjk6Zhg/68ABgi5cYEvfvgAEXbignCsGqVotKpWKwx9/nPWKtNocbY8QQojnMwRqPTw8sLOzQ61W53WThHij6HQ64uLiiIiIIC4ujiJFiuDg4JDXzRJCCCHEG0CCta8xJ2trNp87x+C33jIZvuncOWyNOnx63YK0L1NA4cL/OFALEJeSQtq/0NFbqlbLxxs2UL9UKaa3b8/VyEg+3rCBIk5ONPbyynK+yPh4vtq+HZ1en+n4ozdusOivv3C1s1OGtShblhZlyyqv78fGErhsGR/VqZN7GySEEOK50tLSlECtu7t7XjdHiDeW3ZPPSREREaxevZrGjRtTtGjRPG6VEEIIIf7rJFj7GmtetixB58/zYe3aqJ88mnX2zh3StFq8CxRQpvtq+3YAvm7WjLmHDnE1MhILMzP2X7uGjbk5LcqVyxDwNbj+8CFT9+0j9MEDohMTKeTgwJA6dahZvDhjtm1Dq9MxvmVLZfoRmzfjZG3NiEaNuHjvHj/s3k3ogwcUdnKiUZkyrD9zRsnkNKbX6/nt6FFWnjxJUloabX190RkFQz9YuZJKRYrQr2ZNAG4/fkzr+fPZ3KcPhRwdqTR5Mh/VqcOKkyeJTUqiYpEijG7c2CQYCXDs1i36rVrF8c8+A+DCvXtM2buXC/fuYWNhQVs/P/rXrIlKpWLjmTOsOnWKOzExpGq1VCxShLFNmxKfksKQdesAqP3zz8x65x38ChZkxcmTrD51iocJCZRycWFo/fqUdXMDYNfly8w5dIh7sbG42tnRvGxZ+lSvDsD4HTu4ExPD9A4dMuyXE+HhRMbFMaBWLcw1Grzd3OgSEMCqU6eyDNbq9HpGBwXR1s+P+YcPZxj/MD6eb3fsoGvFiuy8fDnTZej1er7cto3aJUvSoly5TKcRQgjxchhq1No99R4mhPj3Ga7D5ORktm3bRuvWrSlUqFAet0oIIYQQ/2XyTN1rrHaJEqRqtRy5cUMZtunsWdo8p2zA7tBQqhcrxu6BAxnVuDGLjh7lzO3bmU47bNMmSrm4sLF3b4IHDaJG8eJ8v3MnAO38/Nh75QpxyckAxCYlse/aNdr4+RGXnMzgdeuoUrQouwYOZFzz5qw7fTrLNm06e5bfjx9nart27OjfH3ONhntxcTnaH1vOneOXzp0J6tcPjUrFiC1bnjn948REPlyzhspFirBr4EDmd+nC5rNnWXf6NGfv3OGH3bsZ2agRuz/8kDU9e3IrKorlJ09S2MmJn9u3B+DAkCH4FyrE6lOnWHrsGBNbt2bngAG87ePDgNWreRgfT1JqKl9u28bwhg3ZN3gw37VowaKjRzl39y6QnvmcWaAW4OrDhxTNlw9zo867SubPz+UHD7LcrvkhIThbW2d6HhgCue9VqULJ/PmzXEbQhQtce/iQT+vVe+Y+FEII8fK8aOkDfUwcunsPs/2nj8nZ+60QbxLDdVigQAEiIyO5detWHrdICCGEEP91kln7GjPTaGhetiybz52jRvHiJKWmsvPyZVa9/z4Hr1/Pcr6i+fLRyscHgNolS+JiZ8eNqCj8MskSmNa+Pa62tuj1eu7ExGBvZcX9J0HUgMKFcbe3Z+fly7T182P7xYsUz5ePsm5uBF24gEatpl/NmqhVKkq7uvJe1aos/uuvTNu09cIF2vn7K5moA2rVYv2ZMznaH/1r1cLjSW3Wj+rUof1vv3H78eMsp9937RqWZmb0rVEDlUpFEScnZnXsiLW5OY5WVqx+/30KOToSk5TEg7g4nKyteRAbm+myVp06Ra9q1Sjt6gpAGz8/Npw5Q9CFC3QsXx5LMzM2njmDTqejvIcHwYMHK9nQz5KQkoK1ubnJMCszMxKz6Bn8+K1bBF24wNLu3YlJSsowfsHhw9hZWtKhfHk2nT2b6TJ0ej3zDx+mV7VqJuU0hBBCvPr0MXGkzFuNPjE52/OorC2x+KAjKgfJ5BUiKyqVCo1GQ1wOkwmEEEIIkU4fE5fhM6per0cVF4cuKS1DZ54qa8s39vOpBGtfc2/7+vLe778Tl5xM8NWrVPDwwMXW9pnzPD3eTK3Osrbppfv3+eTQIR7Gx1PC2Zl8NjYYT9nWz4+t58/T1s+PzefO0dbPD4B7MTG429ubBCQLZ9LJlcGDuDjc7e2V1xq1moI57MShaL58yv/uT+aNjI/PcvrIuDjc7O1NbgiGztpStVqWnzjBtgsXsLGwoJSLC/EpKWRVpfZ2TAxTgoP5ef9+ZViaVktZd3eszM35tUsX5h8+zKigIOJTUmhYujTDGjTAwcrqmdtkbW5OUlqaybCktDRsMgmiRiUk8NX27Uxo1Qo7S8sMwdoT4eFsPneOpd27P3Odx27eJDIuTjmWQgghXh/6xOT0D8FqNZhpnj9DmlaZ52V9GNbr9axfv57169cTGhpKXFwc7u7u1KlTh379+uH25Ifaly08PJyGDRuyePFiqmWjo86saLVaunbtypgxY/D19cXLy4sJEybQ/slTN08bMWIEERERLFmy5IXX+bTQ0FAiIiKol0dPwNy+fZuTJ0/S0qgU1vOMGDGC9evXZzquYcOGzJo167nLyK1jaHDmzBm+/vprVqxYgZlZ9r4W6bP4zCyEEEKIrD0rocBcpyM1kyfK3uSEAgnWvuZKu7pS3NmZHZcusf3iRbpVrJhry34QF8eIzZuZ1KYNdTw9gfTaq7tDQ5VpWvv4MPvgQY7cuMGVyEiaPemgqqCDA3djY9N/JXkSDL0TE5Plutzs7YkwyoLV6/U8MMpcUKvVpGq1yuvoxMQMy7gfF0cpFxcAJaPW3d6esEePMl+ngwP3nmrj3itXiE9J4UFcHIdv3GDle++R/0lw++MsvmAY2t+/Zk2aensrw25FR+NkZUVccjIP4uL47skXmkv37/PF1q38euQIH9etm+UyATzz5+dmVBRpOh1mT25e1x4+xPPJdhoLCQvjUUICg9auBf7/ZaLL4sX0rFqViMePeZSQQOv584H0gHRKWhp1Z8xgatu2BBQuDMCu0FDqly6dIaNXCCHEa8RMg8r8+R/z9AApL6/DTK1Wy4cffsiJEyfo378/Y8aMwdbWltDQUGbNmkWHDh3YsGEDLpm8r+W2ggULcuDAARyf8eNxdixYsIBixYrh+6Tc0IEDB7A3+sH539CvXz/atWuXZ8Ha4cOH4+HhkaNgLUBAQADTp0/PMNzS0jK3mpYjfn5+lCxZkl9++YUBAwbkSRuEEEKIN8EzEwp0WlA/NexfSCh4lUnN2v+At318+P3ECW5ERVGrZMlcW258SgpavR6rJ0G7aw8f8suTDqsMgdN8Nja85enJN3/+SYPSpZVM0bqlSqHT6/n1yBFStVrCHj1i8bFjWa6rra8v606f5vTt26RqtSw4csQkK7aEszOHwsKITUoiNjmZhZmUU/jl0CEi4+OJTUpiSnAwNYsXp8Azvjy9VaIEaTqd0sZb0dFM3rOH5LQ04pKTMVOrMddoSNPpCDp/nkNhYcp2Wz6pIRv7pF5vOz8/Fhw+zPWHDwE4FBZGp4ULOREeTmJqKkPWr2fbhQvo9Xpc7exQq1Q4WVs/9xhULloUJ2trpu/bR3JaGpfv32fFyZOZ1qNtUa4chz76iOBBgwgeNIgVPXoAsKJHD3pWq8boJk04MGSIMn5Ew4a4OzgQPGiQEqgFOBURQYCHx3PbJoQQ4t+l1+nRJyQ9+y8pGXT6HP/pk5KfvVzdi2UT/vbbb+zfv5/ffvuNXr16Ubp0aQoVKkTdunVZuHAh5ubm/Prrr7m8pzKn0WhwdXXF4h+U+ImNjWXu3Ln07t1bGebq6orVc56UEenMzc1xdXXN8OeQw6epclOvXr345ZdfePyM0llCCCGEyCVPEgqM/zAzy2RYNp4Q+w+TzNr/gGZlyzJ13z66VayoZF/mhuLOznxUpw6jg4JISk3Fzd6edv7+TAsO5kpkJL5Paty28/Nj1+XLfNW0qTKvtbk5U9q2ZeKuXfx65AjF8uWjerFiHL15M8ttiE5MZMSWLcQmJdGwTBml/itAr2rVGPfHH7SePx97S0v616rFrsuXTZZR1s2N3itWEJ2YyFslSzKsfv1nbp+9lRUzOnTgp717WXr8ONZmZnSsUIH2/v48TkzkSmQkrX75BQuNBm83NzpVqKC0v5SrKxU8PGg2Zw4TW7fm3UqVAPh040Yi4+JwtbPj8wYNqFuqFAA/tG7NrIMHGb9jB5ZmZjTx8lLmGb9jB3diYjLtZMxMrWZmhw58v2sXTebMwcbcnC4BAbz9JFh7JyaGjgsXMr19e5OA6z8R8fjxM4PcQggh/n3ay2Fodx9Fn5DxyRJj+tQ0iIsHlQp9Nmqjo9eDXk/qim3PzMRV2VijaVAVTZni2W6zXq9n2bJlvP322/g8qZVvzNramqVLl+Jq9H5/584dJk+eTEhICPHx8VSqVInPP/8cLy8vAB4+fMjXX3/NkSNHSExMpFy5cnz66adUrVoVgNOnT/P9999z4cIFzMzMqF69OiNHjqRQoUIZHqEPDAykbNmyREdH8+eff+Lg4ED37t3p27dvhpppBitXrsTNzQ1voydpjMsg6PV6Zs+ezYoVK4iJiaFly5YkJ5s+7ve8bRwxYgRarRYXFxc2bNhAQkICtWrV4uuvv8bV1ZUGDRoQERHBjBkzOHr0KHFxcVSqVInRo0cDsHPnTj788EN++uknJfP1hx9+4NSpU/z++++EhoYyZcoUjh8/Tnx8PAULFqR79+689957AEyfPp2jR49Sp04dlixZQlRUFAEBAYwdO5aSJUsSGBjI0aNHATh69Ci7d+9W2p6ZnJQsSElJYfr06Wzbto27d+9ia2tLrVq1+PLLL8lnVO7K4HnnQ0pKCtOmTWPTpk3ExcVRunRphgwZQu3atZVleHt74+bmxsqVK/nggw+y1U4hhBBCiJdJgrWvqeOffab872RtzeGPPzYZP69zZ+X/r5s1U/7vV7NmhmVt6ds3y/X0qFKFHlWqmAzrWrEiWqOSBDWKFzdpD6SXKUjValn87rvKsBUnThD64EGW6+pSsSJdsijj4GpnlyGY2bJcOZPXDcqU4fOGDTPM+7avrxLcrFykiElbvQoUYG6nThnmcbS2Zmq7dlm21drcnAVdupgMy2xfGdTx9FRKSTzti8aNs1wPQJF8+Zj5zjuZjivo4MCBIUMyHVfI0THDcTFmvF+MZbU8IYQQeSdtRwgkZ9655L9Bn5BI2o6QHAVrw8PDuX37NjUz+exh4GH0JEdcXBxdu3alSJEizJ49GwsLC2bOnEn37t3ZuHEjhQoVYuzYsSQnJ7N06VIsLCyYM2cOAwcOZN++fVhZWdGvXz86derExIkTiYmJYcyYMXzxxRcsXLgw0/X//vvvdOjQgbVr13L69GnGjh0LkGXQbufOndR/xo/B8+bNY/78+YwbN45y5cqxcuVK1qxZowQPs7ONANu2baN169YsXbqU27dvM3ToUKZMmcL48eNZs2YN7dq1o0WLFvTr148lS5YQFBSktCEkJASVSsXhw4eVYG1wcDDt27cnMTGRnj17Ur16dX7//XfMzMxYu3Yt48ePp2rVqpR9Us7q5MmTWFtbM2/ePOLj4xk+fDhff/01ixYtYvr06fTv3x93d3fGjBkDpJeCyEpOyk788MMP7Nq1i++//57ChQsTGhrK8OHDmT17Nl988UWG6Z91PtjY2DBy5EhCQ0P58ccfcXd3Z8+ePfTv358ZM2aYlJCoV68eu3fvlmCtEEII8W/S6tDHJaDSasHWBiylFKOBBGvFS6HV6ei/ejWT27ShVokS3H78mNV//50hwCqEEEKI/6bIyEgAnJ903mnQv39/jhw5orwuVKgQW7duZdOmTURFRbFu3TplnkmTJtGoUSOWLVvGsGHDuHnzJmXKlKFo0aJYWloyatQoWrdujUajITY2lqioKAoUKEDhwoVRqVRMnTqVh09KFGWmZMmSjB07FpVKhaenJ1evXmXx4sWZZtfqdDrOnj1L165dM12WXq9nyZIl9OjRg1atWgEwcuRIk23NzjYC2NnZMW7cOMzNzfH09KRNmzYEBwcr+1Oj0WBjY4OTkxP169dnxowZ3Llzh4IFC3Lo0CEaN26srDc8PJwrV67QqFEjEhMT6dGjB926dcPOLr3+26BBg5g7dy6XLl1SgrVpaWn88MMPODk5ARAYGMiPP/4IgJOTE+bm5lhZWSnbYJwd/SzHjh0jICDAZFiBAgX4448/gPQask2aNFGC2x4eHtSuXZtLly5lurxnnQ83btxgy5YtrFmzBr8nnab27NmTixcvsmDBApNgrZeXF4sXL0an06HOxafUhBBCCJGFNC36qBjQpfedoH8ci8o1H2TnybA3gARrxUuR39aW71u14ud9+xixeTP2lpa08vXNMvNUCCGEEFkza1wjW2UQXhZDGYScMDy2Hh0dbTL866+/JikpCYAlS5awe/duAC5fvkzx4sVNgruWlpb4+/srwbpBgwYxbNgwduzYQeXKlalduzYtWrTA0tISS0tL+vTpwzfffMOMGTOoWbMmderUoalRmaanVa1a1SQoW6FCBX755ReioqIyBJmjo6NJTU3NMNwgKiqKBw8eKIFB42VevXo129sIUKxYMcyNOvq0t7cnNTU10/X6+vri5ubGwYMHeeutt7h58yaTJk2iffv23Llzh+DgYEqVKkWxYsUA6NatG0FBQVy8eJEbN25w4cIFID0YbeDi4qIEap+3fiBDANbYL7/8QuXKlZW2Tpo0yWS8RvP/mnRt2rQhJCSEn376ibCwMK5evcq1a9eU+Z/2rPPh/PnzAPR4UsPfIDU1NUONXGdnZ9LS0oiOjs7y+AohhBAilzwVqAXSS3PpdKB5s2vVGkiwVrw09UqVot6Tmq0v27Me9xdCCCFed5oyxVGXKgZJyc+cTvfgEakLN4KF+TNr0BroU9MgJRXzLs1Ruz4jSGVliUqds0yHIkWK4OrqytGjR5XH8QHc3NyU/40fkdfr9ZnWitVqtZiZpW9L48aN2b9/P/v37+fQoUPMnz+fadOmsWrVKkqXLs3QoUPp1q0bwcHBhISEMHbsWObOncuGDRsybaNhucZtANMA4tOMg5qZMSwjs3VkZxuBHHeCVq9ePQ4ePIhGo8HX1xcfHx88PDw4cuQIe/fupVGjRkB6tnOnTp3Ily8fDRs2pEaNGvj5+VG3bl2T5eV0/VntXzA93lZWVkrQODNjx44lKCiItm3bUq9ePQYMGMCCBQu4d+9eptM/63wwHIdly5Zha2trMt/T2bOGYypZtUIIIcRLptWij00wDdQCWJhLoNaIBGuFEEIIIV4DKrUKbKyePY2VJahV//97nifTqawsUT1n2Tml0Wjo0aMHM2fOpGvXriadchncuXNH+b9MmTJs2LCBhw8fkj9/fgCSk5M5e/Ysbdu2JSUlhcmTJ9OmTRtatGhBixYtSExMpHbt2uzduxeNRsOiRYv44osv6Nq1K127duX48eN069aNixcvZpoxeebMGZPXJ06coHDhwpnWWXV2dsbCwoKoqKhMt9fZ2ZmCBQty/PhxJTgKcPbsWSVL9nnb+KIaNmzI8OHD0Wg0VK9eHYDq1auzd+9ejhw5wuDBgwHYvHkz0dHR/PHHH0qbDBm9TweZc+JZAdjsioqKYvny5UyZMoUWLVoow69du4aNjU2G6Z93PhjKHNy/f9+k5MGUKVNQqVR8bNTfw6NHj7CwsDDJJhZCCCFELtNqIS4ReOozh5kGlZN0cm5Mfj4WIpfczOLLmxBCCPGm6tOnD/Xr16dbt27MmTOHixcvEh4ezu7du+nVqxdr165VgoutW7fGwcGBjz/+mNOnT3Px4kWGDRtGQkICnTt3xsLCgr///psvv/ySU6dOER4ezrp164iPjycgIAAnJye2bNnCmDFjuHr1KtevX2ft2rU4OjpSsmTJTNt37Ngxfv75Z65fv86aNWtYtmwZffr0yXJ7/P39OXv2bJbj+/bty7Jly1i9ejXXr19n6tSpnD59Whn/vG3MLltbW8LCwpS6wNWrVyc5OZk//vhD2Z81atTgjz/+wNHRUSnN4O7uTmJiItu2beP27dscOHCATz/9FEgPfuZk/REREdy9ezfb8zyPvb099vb27Nq1ixs3bnDp0iW+/PJLzp07l2nbnnc+lC5dmvr16/PVV1+xa9cubt26xYIFC5g7dy5FihQxWdb58+cpX758rm2LEEIIIUzpHzyChCTQZ8yo1TvaSa3ap0iw9jVVafJkKk2eTNijRxnGLT12jEqTJzP30KE8aNnLU2nyZI7duvWPlzP30CE+WLkSgKALF+iYRQ/RObHv6lUGrV37j5eTE6dv36bG1KnZnn796dNUmjzZZFh4dDRD1q2j/syZNJo1izHbthH7pI4gwI5Ll+i0aBFv/fwzLebNY87Bg+j+QeaNEEKIf0maFn1q2nP/SNO+1Gao1WqmTp3Kd999x7Fjx+jVqxfNmjVj3LhxODs7s3TpUsaPHw+Ag4MDS5cuxd7envfff59u3bqRmJjI8uXLleDatGnTKFKkCAMGDKBZs2asXLmSyZMnU7lyZZydnZk/fz4RERF06tSJdu3acfv2bX777TelM62nNWzYkNDQUNq0acOcOXMYMWJElh2IATRq1Mikw7CnvfvuuwwbNozZs2fTpk0bQkNDeeedd5Tx2dnG7AgMDGTv3r306tULSK97W7NmTQAqVqwIpAdr9Xo9DRo0UEovNGvWjN69ezNx4kSaN2/O+PHjeeedd6hSpYpJUPl5unTpwuXLl3n77bfRanPnHDIzM2PatGlcvnyZ1q1b06dPHxITE/n0008JDQ0lISEhwzzPOh8gPYu2adOmfPXVV7Ro0YK1a9fyzTff0KFDB5PlHD58mIYNG+bKdgghhBDClO72fVL/PJRel9aYhXl6Rq0EajNQ6f/JM09CodVqOXXqFBUqVHhmnbOc0iUmkrRjB7qnMhcqTZ6Mk7U1bf38GPzWWybjOi1axN2YGN6tVIl+Tz645yY96dur0Wj4Ny+pSpMnM7dTJyrn4MtMZuYeOsTxW7eYl4MMlufZdPYs80JC2NK3b64tMyt6vZ5NZ88yac8eElJTs1Wv92pkJO///nuG6XssW0bFwoX5sHZtElJSGLppE0WcnBjTtCmhDx4QuGwZU9q2pUbx4tyMiqLPypUMql2bt319lWWobGywbtsWdRZfhIX4N+j1eh4/foyjo2Om9SCFeJ0kJCRw4cIFypYtm+nj38+ij4kjZd5q9InPrm1rTGVticUHHVE5vFn38cDAQDw8PPj++++zPc/jx49p0KABCxcuzNCRmHg9nT59mp49e7J79+5My18YrsewsDBCQ0OpXLmySZkLIV4n8nlJCPFv04XfI3XDLvTxiRD55GlklQrMzcDeDlSg02lRq5+Ko6VpQafD4oOOqN3y//sNfwlyEjeUmrWvseZlyxJ0/jwf1q6N+smb7dk7d0jTavEuUECZLi45mSnBwRy/dYsHcXHYW1nRqUIFelWrxq2oKLotWcLgOnXoVKEC8SkpdFuyhEZlymQIAgP8HRHBrIMHCXv0iJikJDxdXBjeoAF+hQrRZ8UKKnh4MMhovh7LltGoTBl6VKnCkRs3mBYcTPjjx5RycaGChwdn79zJNGiaqtUyff9+tpw7h0ql4r0qVUzGt/rlFz6oUUMJGh67dYt+q1Zx/LPPuP34Ma3nz2dY/fr8euQISWlp1PX0ZHjDhthZWpos5+kg6+GwMGYdPMi1hw/JZ21N98qV6RwQgF6vZ9FffxF04QL3YmNRAbVKlODLJk04e/cuE3buJFWrpfbPP7O+Vy+crK2Zf/gw2y5cIDY5Gb+CBRlWvz5FnvSMvfrUKZYcO8bjpCTc7e3pEhBAO39/AAavXUtBBwe+aNw40+P+9R9/EPboEf1q1mRKcPAzzxGAxNRURm7dSteKFVnwVDZQ2KNHVPDwQK/XowdUKhVWTzo4Ke3qyq6BA7G1sECn1xOdmEiaVouTtfVz1ymEECJvqBzssPigY46DtW9aoPZFOTo60rt3bxYuXMjkp55WEa+nhQsX0qtXr0wDtUIIIYR4cbpbd0ndsAtS0570k6BO71hMowFLC0hNfTKhDtQZO3BVWVuisrbMMPxNIMHa11jtEiXYfuECR27coEbx4kB68LGNry8Hr19Xppu+fz+3Hz9mybvvYmdpye7QUD7fvJnGZcpQJF8+hjdsyPe7dlGzeHFmHTyIq60tA2vVyrC+pNRUPtmwgX41a9LOz480vZ5x27czdd8+FnTpQjt/f2YeOMDAJ8Hj6w8fcun+faa0bcvtx4/5ZMMGhtavz9u+vpy5fZuPN2zAy9U1022bf/gw+69dY/G775Lf1pYJO3fmeP/sDg1l5XvvodXr+WzjRibu2sU3Rh1WPO3Go0d8smEDIxo2pKWPD6EPHtBv1SqK5MtHXHIyv584wfzOnSmaLx/XHz6k94oVbL94kbZ+foxs1Mgk6Ds1OJijN28yu2NHXGxtWfTXX3y4di2r33+fB3Fx/LR3L8t79KC4szOHwsIYunEjtUuWxNXOjulPPZr3tAG1auFmb5/tkhATd+3irZIlqVqsWIZg7Qc1ajB9/35WnDiBVq/Hr2BBBtepo4y3tbAgKTWVujNmkKbT0bhMGWqWKJGt9QohhMgbKgc7Cb6+RH379qVr166cPn0a/yc/tIrX0+nTpwkLC2PixIl53RQhhBDiP0V34w6pG3dDWhoAKo0GvYsT6kJuaOpXQfUks1Sv1xMXF4ednV2GjP83OaFAata+xsw0GpqXLcvmc+eA9GDqzsuXaenjYzJdv5o1+b5VK2wtLbkXG4vFk8zJB/HxALTy8aF+qVL0X72aozduML5lSzTqjKeGuUbDwm7d6FihAilaLbcfP8bR2poHcXEANCxdmoSUFI7dvAnA5nPnqF2yJPltbdl24QJlXF1p7++PmVpNQOHCtH/G44NB588TWLkyhZ2csDY3Z1j9+jkuufBpvXrks7HBxdaW/jVrsvPyZVKe3Cgy88fFi3gXKEAbPz/M1GrKurmxoEsXyhYoQK0SJVjy7rsUzZePqIQEohMTcbK25v6TbTem1+tZ8/ffDHrrLTwcHbE0M6Nv9eqkarUcuHYNjVqNHlj799+cioigatGiHBgyBNdslhFws89+L4lB589z/dEjBmQSfAdQq1T0qV6d4MGDlUDz+B07TKaxMDPjwJAhrOvZk2sPH/LD7t3ZXr8QQgjxqlqyZEmOSiAYmJubs2bNGgnU/gf4+/uzbt06zM3N87opQgghxH+GLiyC1I27lECtgaZMccy7NENTqABqt/zKn97FyeS14e9NDdSCZNa+9t729eW9338nLjmZ4KtXqeDhgYutrck0jxISmLRnDxfv3aOQoyPl3NwATDqK6hwQQNCFC7QsV44CWQQDNWo1x27dYvC6dSSkpODp4oKZWq0sx8rcnOZly7Ll/HkqFSlC0IULjHryKP+92FgKOTiYLM/DyYlzWfQifD8uDnej6e2trHCwssrRvin6pOQAgLu9PSlaLY+NOs96WmR8PAWfamPpJ5m/scnJzDxwgP3XrpHP2hqvAgVI0WrJrORzVGIiiampjNi82eSXoVStltsxMTQsU4Z5nTqx6K+/+Hj9enR6Pa19fBhSpw6WZrl3SYY9esT0/fuZ36ULZpkE3y/cu8esgwfZO2gQZmo11ubmfFy3Ln1WrDApGaFWqVBrNBRzdqZPjRp8++effCG12oQQQgghhBBCCGFEdy2c1M174akOSNWli2HWog4qjeSMZocEa19zpV1dKe7szI5Ll9h+8SLdnvQAbGz45s3U9fRkRocOmKnVRCcmsv7MGWV8qlbL+B07aObtza7Ll2ni5UXtkiUzLOfMnTv8sHs3v3btShkXFzQaDUuPHSPs0SNlmnZ+fvResYIGpUujAmo+Kc/g7uDA/qtXTZZ3JyYmy+1ys7cnIjpaeZ2Ymkpc8v/r76lVKtJ0/69pEp2YmGEZ9+PiKO7sDMDtmBiszMyeWW/Vzd6eK5GRJsM2nT1LPhsb9l+7xt3YWDb36aMEMTstWpTpcpysrbE0M2Nmhw74FSqkDA979IgCdnY8SkhAq9MxuU0bdHo9f0dE8PnmzRTLl49OAQFZti+ndl2+TExSEt2WLAFA+2R/1Z0xgxENG2JpZoZOr0en06XXjgHM1GpUKhUatZodly6x/MQJfjXqFTtVq8Uxh0FzIYQQQgghhBBC/LfprtwkdUtweg1aI+oyxTFr/pYEanNA9tR/wNs+Pvx+4gQ3oqKolUmQNS45GUszMzQqFVEJCcpj7KlPfun4ed8+0vR6vmralEFvvcXY7duJfFIi4enlqFUqJfvzzO3bLD9xQlkOQJkCBSju7MykPXto7eOjlFNoWa4clx48YMu5c2h1Os7cucP606ez3Ka2fn4s/usvrj98SHJaGlP27kVrlMVaIn9+9l65QlJqKpHx8Sw/cSLDMqbv309ccjIP4uKYc/AgLX18MH9Gj3tNvL25eP++0sYL9+7x0969mKnV6ftQo0GjVpOclsaSY8e4GhmpbLulmRlJqamk6XSoVSra+Poyff9+7sXGotPr2XzuHJ0WLuRmVBR3Y2L4cO1ajt68iVqlUsof5HbHXb2rV+fgRx8RPGgQwYMGMbVdOwCCBw2iedmyBHh4YGVmxuS9e0lOS+NRQgIzDhygfunSWJub41ewIFciI1l67BhanY6rkZHMCwnhnfLlc7WdQgghhBBCCCGEeH1pQ29kHqj1LolZCwnU5pRk1v4HNCtblqn79tGtYsVMH3f/qlkzJu/Zw9Jjx7C3sqKplxdeBQpwJTISvV7P6r//ZmHXrliYmdElIIC9V67w1bZtzOjQweQx/urFivFO+fL0XbECnV5PIUdHugQEMGP/fh7Gx5P/SfmFdv7+jN+xg7d9fZV53ezt+fHtt5kaHMz3u3bhVaAANYoXJyqTjFiA96tWJSktjb4rV5Km09He398ko3PIW28xYedOmsyZg6udHd0qVuRURITJMoo4OdFp0SKSUlNpVrYsHxl1nJWZIk5OTGvXjun79/PD7t0429jwab161ChenCJOTnz9xx80nj0bG3NzKhQuTMty5ZRM3IqFC+NsY0O9GTP4rWtXPq5bl7mHDtFnxQoeJyXh4ejID2+/jfeTEhTDGzRgws6dPIiLw97Sko7ly9PYywuAwWvXUtDBgS+elJDIiZPh4Qxet47V77+foaTD0/LZ2DDznXf4ed8+ms2di6WZGXU8PRny1ltAejb09PbtmRoczLyQEPLb2tK5QgW6ZJK9LYQQQgghhBBCiDeP9tJ10oL2w1NlItXlPDFrUguVOqc9EAmVPrOimyLHtFotp06dokKFCmiekb2ZU7rERJJ27ECXRW3XvKAnfXs1Gk22O/26GxNDdGKiEqwE+GnvXh7Gx/Ndy5a52r7bjx/Tev58NvfpQyFHx1xdtshIZWODddu2qLMm078xAAEAAElEQVTZQZoQL4Ner+fx48c4Ojpm6EVUiNdNQkICFy5coGzZstjY2OR1c4R4oxmux7CwMEJDQ6lcuTKNpHa/eE3J5yUhRG7TXrhG2vYDGQK1Gt/SaBrVeG6g9k26L+UkbiiZteJfEZ2YSO8VK5jfpQtl3dwIffCAbRcu8Fm9enndNCGEEOI/JSopkvjU2GxPb2tuTz4rl5fYIiGEEEII8V+jPXeFtD8PZQzU+nuhaVBNMmr/AQnWin+Ft5sbQ+vXZ+SWLUQ+KZnQs2pVmpUtm9dNE0IIIf4zopIiGXd4EPGpWXfi+TRbcwfGVJ/x0gK2er2e9evXs379ekJDQ4mLi8Pd3Z06derQr18/3IyeunmZwsPDadiwIYsXL6ZatWovvBytVkvXrl0ZM2YMvr6+eHl5MWHCBNq3b5/p9CNGjCAiIoIlTzr8zA2hoaFERERQL49+9L59+zYnT56kZTafjpo+fTozZsx45jS7du2icOHCudE8Ezqdjo4dOzJ27Fj8/PxyfflCCCHEm0h7NpS0HSEZA7UVvNHUr/qfz5J92SRYK/417fz9aefv/9LXU8jRkeOfffbS1yOEEEK8auJTY4lPjUGjMsdcbf7c6VN1qcSnxhCfGvtSgrVarZYPP/yQEydO0L9/f8aMGYOtrS2hoaHMmjWLDh06sGHDBlxcXn5mb8GCBTlw4ACO/7BE0oIFCyhWrBi+T2rzHzhwAHt7+9xoYrb169ePdu3a5Vmwdvjw4Xh4eGQ7WNurVy+6dOmivH7nnXdo0aIFvXr1UoY5OzvnejsB1Go1Q4cOZeTIkaxbtw4LC4uXsh4hhBDiTaH9+xJpuw5nGK6pWA5N3coSqM0FEqx9jV24d4/fjhzheHg4yWlp5Le1pZ6nJ72qVcPR2vpfb8+xW7fot2oVxz/77JWtG6vV6Zi+fz9bz58nKTWVKkWLMrJRI1yzqLd65MYNft63j1vR0dhbWtLGz4++1aujUqkYvHYtJ5/q1CwxNZX2/v6MetI52KKjR1lx8iQxSUn4uLvzRePGFH9JX0aEEEIIA3O1ORYay2xNq9WmvrR2/Pbbb+zfv59Vq1bh4+OjDC9UqBBVq1alRYsW/Prrr3z++ecvrQ0GGo0GV1fXf7SM2NhY5s6dy7Jly5Rh/3SZbwJbW1tsn3REC+nHwsbG5l/bdzVq1MDc3JyNGzfSsWPHf2WdQgghxH+R9tRF0nYfyTBcU9kXzVsVJVCbS9R53QDxYvZdvUrvFSso5uzMih492D94MFPbtiXi8WO6LlnCg7i4vG7iK2nB4cMcvnGDJe++y7Z+/bA0M+ObP//MdNroxEQ+3bCBPtWrs2/wYGZ06MCqkycJunABgOkdOnBgyBDlb1j9+rjZ2/NBjRoAbD53jhUnTzKjQwd2f/gh3m5ufL5pE9KnnxBCiBeh0+uIS4l55l9Cahw6vR6dXodOr83Gnw6dXk9Catwzl6vT63LcXr1ez7Jly3j77bdNArUG1tbWLF26lI8//lgZdufOHYYOHUqtWrWoUKECvXv35tKlS8r4hw8fMmTIEKpVq4a/vz9dunTh6NGjyvjTp0/TrVs3AgICqFKlCoMHD+b27dtAehkELy8vjhxJ/4IRGBjI+PHj+fzzz6lQoQJ16tRh3rx5z3yfXrlyJW5ubnh7eyvDvLy8WLdunbLNs2bNok6dOlSoUIFRo0aRnJxssoznbeOIESMYNmwYEydOpEaNGpQvX56BAwfy4MEDABo0aEBERAQzZswgMDCQdu3a8e233yrz79y5Ey8vL7Zu3aoM++GHH+jWrRuQXkJh4MCBVKtWDV9fXxo3bsyiRYuUaadPn05gYCC//PILderUwc/Pjx49enDt2jVlvx09epT169fToEEDZR9k9WfY389z5MgRvLy8+OWXX6hWrRrt2rXj5s2bmS7DeJ8D7Nmzh/bt2+Pv70/jxo2ZOnUqKSkpJvM0b96cBQsWZKstQgghhMhIe/x85oHaav4SqM1lkln7GkpJS+PbP/+kV7Vq9KleXRleIn9+fnj7bfqsWMHkPXsY36oVbebPp2e1arR/Un5Aq9PR8pdf+KxePRp7eXHkxg1mHjjAjagoCtjZ0bNaNVo8qSP71fbtJKamcjUykujERBZ268aj+HhmHTxI2KNHxCQl4eniwvAGDfArVChH27Dv6lV+O3KEW9HRJKSm4uPuzpdNmlDYyem5bf7j4kXmHjrEw4QE/AoWxN3enlSdjq+bNeNkeDiD161j9fvvU9DBIcN6N5w5w+A6dXB/Mm5o/fo0nTOH8OhoCjs5mUx7JyaGpLQ09KB8cVOpVFiZZbxswh49YuLu3czs0EHJ0l1/+jQdK1TA88mjnYPfeosNZ85w7NYtqhQtmqP9JYQQ4s3294MjrL+yiLiUx8+cLkWbzOPkh8So1KhVz/9NXqfXodfrmHHq62dm4tpZONKu1HuUd81+rdfw8HBu375NzZo1s5zGw8ND+T8uLo6uXbtSpEgRZs+ejYWFBTNnzqR79+5s3LiRQoUKMXbsWJKTk1m6dCkWFhbMmTOHgQMHsm/fPqysrOjXrx+dOnVi4sSJxMTEMGbMGL744gsWLlyY6fp///13OnTowNq1azl9+jRjx44F4IMPPsh0+p07d1K/fv0st2fevHnMnz+fcePGUa5cOVauXMmaNWuoWrVqtrcRYNu2bbRu3ZqlS5dy+/Zthg4dypQpUxg/fjxr1qyhXbt2tGjRgn79+rFkyRKCgoKUNoSEhKBSqTh8+LBSpiA4OJj27duTmJhIz549qV69Or///jtmZmasXbuW8ePHU7VqVco++Qx48uRJrK2tmTdvHvHx8QwfPpyvv/6aRYsWMX36dPr374+7uztjxowB0ktBZCWnZSf27t3LypUrSUxMRK1+/jm8b98+PvroI0aOHEmtWrW4efMm33zzDdevX2fatGnKdPXr12fy5Mlcv36dEiVK5KhNQgghxJtO+9dZ0vYfzzBcU6M8murlJVCbyySz9jV0+s4dHiYk0LJcuQzj1CoVbXx92XPlCjq9nrd9fdly7pwy/vCNG6SkpVGvVCku37/PJxs28H7VquweOJDRjRszec8eDoWFKdOHXL/OxNat2dCrF662tnyyYQMNSpdmc58+7PrwQwo7OjJ1374ctf9ebCzDN2+mZ7Vq7Bw4kKAPPkCv1/NLSAhqleqZbT59+zZfbd/Ox3XrsmvgQNr7+7PJaNqAwoU5MGRIpoHa2ORk7sXFUcqoLl5+W1scrKwIfZKtYsy7QAEalSnDsE2bqDZlCu8sXEhjLy8alimTYdrvd+2ilY8PAUYdY1x7+NBkXeYaDUWcnDJdlxBCCPEsqy/Pf26g9mWKS3nM6svzczRPZGQkkLEWaf/+/QkICFD+DAHFTZs2ERUVxbRp0/D398fb25tJkyZhZWWllB24efMmjo6OFC1alGLFijFq1Ch+/vlnNBoNsbGxREVFUaBAAQoXLoyPjw9Tp041ydx9WsmSJRk7diyenp60a9eOwMBAFi9enGl2rU6n4+zZs5TJ5HMApP+wu2TJEnr06EGrVq0oWbIkI0eOVAKg2d1GADs7O8aNG4enpydvvfUWbdq04fjx48r+NJQRcHJyon79+ly7do07d+4AcOjQIRo3bqxko4aHh3PlyhUaNWpEYmIiPXr0ULa5WLFiDBo0CMAkuzctLY0ffvgBb29vKlWqRGBgoLJ+JycnzM3NsbKyUo6tq6trln85rRHbq1cvihcvbrLfnmXOnDm88847dO3alaJFi1K7dm2+/vprtm/fTnh4uDJdyZIlMTc35++//85Re4QQQog3XdqR05kHamsFYFajggRqXwLJrH0NGUocuBjV/jLmamdHmk5HdGIibXx9+SUkhFvR0RRxcmLz2bO0LFcOc42GtadPU8/TkwalSwNQ3sODdn5+rDp5kprFiwPgV7CgEnDU6nQs7NaNwk5OJKSkcDc2Fkdra87fu5ej9jvb2LDq/fcp4uREfEoK92JjcbK25v6T7XpWmzeePUuDUqWo4+kJQIPSpalfqlS21pvw5HE4a3PTDleszMxITM1Yry9Fq8XR2pqJrVtT19OT83fv8tnGjZRxdaWtUW/CJ8PDOXP7Nt+2aJFhfVZPr8vcnIRM1iWEEEL81+TLlw+A6Ohok+Fff/01SUlJACxZsoTdu3cDcPnyZYoXL24S3LW0tMTf318JJA4aNIhhw4axY8cOKleuTO3atWnRogWWlpZYWlrSp08fvvnmG2bMmEHNmjWpU6cOTZs2zbKNVaua9lZcoUIFfvnlF6KiojIEmaOjo0lNTc2yI6yoqCgePHiAn9FnBMMyr169mu1tBChWrBjmRp8h7O3tSc3i84Ovry9ubm4cPHiQt956i5s3bzJp0iTat2/PnTt3CA4OplSpUhQrVgyAbt26ERQUxMWLF7lx4wYXnpR30un+X+rCxcUFJ6Mnjp61foCAgIAsx/3yyy9Urlw5y/FPK/7kM2h2nT9/ntOnT7N+/XplmCHYfvXqVQo/+SFdo9Hg6Oio/IgghBBCiOdLC/kbbcipDMPN3qqEporvv9+gN4QEa19DhiDtnZgYij75ImQs4vFjzNRqnKytMVOrqVGiBFvPnePdSpXYd+0aS959V5n/r5s3qTtjhjKvTqczKQfgYtTxlkat5titWwxet46ElBQ8XVwwU6vR5bAGq5lazR8XL7L2779RAaVcXYlLTsbsyaNuBezts2zzvdhYvAoUMFmeh6MjDxMSnrteQ5A2KS3NZHhSWho2mWR9rDp1ituPH9PoSQZNeQ8PulasyOpTp0yCtetOn6axl1eG4LmVuTlJT32xSUpNzXRdQgghxLN0LNMnW2UQXhZDGYScKFKkCK6urhw9elTJngVwc3NT/jd+RF6v12eamaHVajF7UoKocePG7N+/n/3793Po0CHmz5/PtGnTWLVqFaVLl2bo0KF069aN4OBgQkJCGDt2LHPnzmXDhg2ZttHsqdJGhiCfRqPJcruMg5qZeTor13gd2dlGIMfZqPXq1ePgwYNoNBp8fX3x8fHBw8ODI0eOsHfvXho1agSkZzt36tSJfPny0bBhQ2rUqIGfnx9169Y1WV5O15/V/gXT450dlpYZy3EY79Ong8Y6nY4+ffrQrl27DPM93YGZVqt95rEVQgghRDq9Xo/20Cm0R05nGGdWtwqaShmf9Ba5R4K1r6EKHh7kt7Vlw5kzDKlTx2ScVqdj87lz1PX0VIKfbX19mbZvH652dpR2dVVqqBaws6O1jw9fNG6szP90x2TGXyjO3LnDD7t382vXrpRxcUGj0bD02DHCHj3KUft3XLrEypMn+bVLF4o8CTb/sGsXV4wyHbJqc0EHB+7ExJgs725MDOaZ1JF9moOVFQXs7LgWGalkC0fGx/P4Se3dp92NiSFFqzUZZqZWY270IT9NpyP46lUmtWmTYf5SLi5ce/hQyQJO1Wq5FR1Nqfz5n9tWIUTWopIiiU+NNRmm1+uJS4gjVm2XIRBia25PPquM17gQr5PyrtXwc6lCQuqzOxC9HXeDH459jpXGGgvN8wNuKdoUkrSJDKrwFYXsimU5nY25XbZq4BrTaDT06NGDmTNn0rVrV5NOuQwMj+4DlClThg0bNvDw4UPyP3mvTE5O5uzZs7Rt25aUlBQmT55MmzZtaNGiBS1atCAxMZHatWuzd+9eNBoNixYt4osvvqBr16507dqV48eP061bNy5evJhpRuyZM2dMXp84cYLChQtnWmfV2dkZCwsLoqKiMt1eZ2dnChYsyPHjx5XgKMDZs2eVLNnnbeOLatiwIcOHD0ej0VD9SX8G1atXZ+/evRw5coTBgwcDsHnzZqKjo/njjz+UNhkyev9JB6iGrN3cZmhjnNHn05s3b5pMU7p0aa5du2bShqNHj7Jo0SLGjh2LjY0NkB6ojYmJyRDAFUIIIYQpvV6P9sAJtH+dzTDOrH5VNAHZK1UkXpwEa19D5hoNY5s1Y9jGjZip1XSsUIH8traEPXrEjP37uRcbyw+tWyvTv+Xpyfe7dvHb0aP0rvb/jkHa+Pnx4Zo11C9dmmrFihEeHc2Qdeuo4+nJp/XqZVhvXHIyapUKyyeB0TO3b7P8xAm0z8kwybCclBRlOXq9npCwMLacP4+nURAzqza38/Ojz8qVHAoLo1rRohy+cYPdV67QNJMvgJlp7evL/CNH8ClYECdraybv2UOlwoUp8lTnYgB1PD1ZfeoUm8+do1W5coQ+eMCKkyfp+aSTEIDQBw9ISkujfCYdrL3t68vcQ4eoWbw4xZydmXngAM42NiZ1bYUQOROVFMm4w4OIT43JME6n06NWZ8xYszV3YEz1GRKwFa89tUqNnUXGmuzG0oOqKtQqNWrV8zMI06dTYWNu99xlv4g+ffpw/vx5unXrxgcffEC9evWws7Pj8uXLLF26lIMHD9KhQwcAWrduzZw5c/j4448ZNmwYFhYWzJo1i4SEBDp37oyFhQV///03x44d48svv8TFxYXg4GDi4+MJCAjAycmJLVu2kJSUxAcffIBarWbt2rU4OjpSsmTJDOUYAI4dO8bPP/9M69atOX78OMuWLWPkyJFZbo+/v/8zA6t9+/Zl4sSJlCxZksqVK7Nx40ZOnz5NpUqVsrWN2WVra0tYWBiRkZG4uLhQvXp1kpOT+eOPP5g3bx4ANWrU4PPPP8fFxUUpzeDu7k5iYiLbtm2jcuXKXLt2jQkTJgCQ8qRcVHbXHxERwd27d3F3d8/2fDlVoEABihQpwm+//Ubx4sVJTExkwoQJJpm/ffv25eOPP2b69Om0atWKu3fvMnr0aAoVKmQSmL148SJarZby5cu/tPYKIYQQrzu9Xo923zG0x89nGGfWsDqa8l550Ko3jwRrX1M1ixfnt65d+e3oUd5dupT45GTy29pSr1QpvmzShHxPsgggPRu0tY8PK06epIlRUNOvYEG+a9mSmQcOMHzzZqzNzWnq7c3gt97KdJ3VixXjnfLl6btiBTq9nkKOjnQJCGDG/v08jI/PdttblSvHqYgIOi5ahEalorizM90qVmTVqVOkarWYazRZtrmcuzsjGzXi+507iU5MpIKHB1WLFsX8SRbxyfBwBq9bx+r338+0k7G+1auTptXSZ8UK4lNSqFykCN8bBbYHr11LQQcHvmjcmGrFivFtixb8evQoP+7ejbONDd0rV6ZjhQrK9BGPH+NoZaUEsI218fUlNjmZoZs2EZWQQDl3d6a1a2eSmSuEyJn41FjiU2PQqMwxV5vWhNaqdGie6jk8VZdKfGoM8amxEqwVIg+o1WqmTp3Ktm3bWLt2LYsXLyYmJgYXFxcqV67M0qVLqVKlCgAODg4sXbqUiRMn8v777wNQqVIlli9fTpEiRQCYNm0aEyZMYMCAAcTGxlKyZEkmT56s1ESdP38+kydPplOnTmi1WipUqMBvv/2GnZ1dpsHahg0bEhoaSps2bShQoAAjRoyga9euWW5Po0aNWLduXZbj3333XXQ6HbNnzyYyMpK33nqLd955h+vXr2d7G7MjMDCQiRMnEhoayqZNm7C0tKRmzZrs27ePihUrAunBWr1eT4MGDZQnDpo1a8a5c+eYOHEicXFxeHh40LFjR3bt2sXp06efue3GunTpwvDhw3n77bcJCQl5aaUFVCoVP/74I9999x1t27alUKFCDBkyhGnTpinTNGvWjClTpjB37lzmzp2Lo6Mj9evXZ9iwYSbLOnz4MGXKlMnRfhZCCCHeJHq9Hu3ev9CevGA6QqXCrFENNH6l86ZhbyCV/p888yQUWq2WU6dOUaFChVz9wKpLTCRpxw50d+/m2jL/KT3/r/n1b/f5d+PRI3R6PSWMsnCHbdpEcWdnPqxd+19ujQBQ2dhg3bYtaqP6xkK8LOGx1xl3+EOsNDZYaEzrGmZWizBFm0ySNoEx1WdS2L7Ev9lUIV5YQkICFy5coGzZssoj3NlluEYy+0EjM6m6VLT61DfyGgkMDMTDw4Pvv/8+2/M8fvyYBg0asHDhwgwdiYlXW8uWLenZsyfvvPNOjuYzXI9hYWGEhoZSuXJlkzIXQrxO9Ho9jx8/xtHRUXpvF0KY0Ov0aPccQfv3JdMRKhVmTWqi8clex+45Xu8bdF/KSdwwZ8XHXlOzZs0iMDAw29Nv3rwZLy8vwsPDX2KrxIu4+vAh/Vev5taT7Jhjt25x6Pp1apd4s75gCiFMpenS0OlzVpJFiP8iW3N7bM0d0OpTSdImPPdPq0/F1twBW3P7vG76a8HR0ZHevXuzcOHCvG6KyIH9+/ej1Wr/UV1gIYQQ4r9Kr9Oj3RWSeaC2aa2XFqgVWfvPl0FYuHAhP//8s/KI3fNERETw9ddfv+RWiRfVoHRprj98SL9Vq4hJSqKQgwOjmzShvIdHXjdNCJEHUnQpRCc/5H/s3Xd0HNeVJ/7vq6pupAYaOWeCOQcwRzCAmZRISpasNGvJ8ng1s7bX8s9ykMN41tZ4Rx7LkmV7djyWSEkWSQnMmWAEmBOYQeScYyN1V9X7/dEManaDJEigq8P9nKNzxHoXjQuy8brq1qv7zEo3OOcI0AUiyCcEEvP4jzdCHArxDcfbU9+324TvQWgTvr557bXX8NxzzyEvLw9jxozROh3yEKqq4t1338U777wD6RE2pCWEEEK8CVc5lP25UK4W2A4wBmnpLIhDaWGcFjz2jKW2thY//vGPce7cOaQ84qpLVVXx5ptvYuTIkTh58uQAZ/iIGPP4peB99Y2pU/GN2zsdExcgeMUCfeJiVK6iuafRbqOxTtmETrkDBl0gAvXB2iRHiMZCfMOp+PoI1q9f/1hfp9PpsHnz5n7OhgwUQRCQlZWldRqEEEKIy+GqCnlvDtTrRbYDggBp6WyIQ5K0SYx4bhuEq1evwmg0Ytu2bY+86+uf/vQnWCwWvP766wOc3aNjggAWSI8mEtfFAgMB2jSNOInKOXqUbjR019gVau/hMFnaUNNRjnZzK1RqzU4IIYQQQgghd3FVhbz7uONC7fI5VKjVmMeurM3IyEBGRsYjx+fl5eGvf/0rNm/ejNra2gHMrI90OkgpKZALCwFF0TobQuxIKSlguodvYkPIkyppzccn1z9Ap8UExgQI7MH3Gzk4OmTro+A5lfuwKu0l+Ep+zkiVEEIIIYQQQlwSV1TIu45CvVVqOyCK0K2YAyE1QZvEyF0eW6zti87OTnz/+9/H97//fSQnJz9RsZZzDt7Pq7jEmBj4zJsHubAQamsroGq7iQ6D9S6MQI+/ey/GwAwG6JKTIaakAKLY7+97Qu5oN7dgZ/HnOFd7DGalx0EEQ5DeCFmR0al0ALB9L3KuIqdqP642ncfc+OWYEbsQetHHKbkT8jhoPiXEdQ3EuT4hznLn/UvvYUK8F1cUKDuPQi0stx0QRUgr5oKlxDl1jvCmeakvP6NLFGvXr1+PsWPHarZJw69+9SskJyfja1/72hO/VltbW78XMQVBgE9MDHTR0dZCrQu8iTnn1EvXmzEGCAJUxtBhsUDp7tY6I+KBFK7gdN0hHK7eDrNqLdIqqgoOgHEODg5f0R9GfQgEJkFlKgJ0QTBZWtEpm6wvwjn47a9r727F9oJPkF26HbOjl2JC2AxIAq0KJ66np8fRTQlCiJbMZjMsFgu6urrQ2tqqdTqEPBbOOTo7OwGAruUI8UaKAunAKQhlNbbHRRGW+ZPBQw2Akz/jvGleUvuw8NIlirXvvfceuru7cfToUYSEhDj9+3/xxRfQ6/UYP348AEC53W5g+fLlWLlyJX75y18+8msFBQVB9PD+nZxztLe3I9Bg8PhfJvJgIgAqdZGBcKv5CrYUfoy6ziqA4e68KkIAAyCJOoT6RsJXvNfWQL593EeKhFENQZu5BSZLGxjnEAXh7mt0qx3YV7UJZ5oOYUHiU5gYNRMi8+x5m7iXOyeshBDXodfrodPp4OfnB6PRqHU6hDyWO6u6jEYjXccR4mW4LEPZfgRqZb3tnjOSBGl1BvwSorXJy4vmJaUPrU1dolgbHR2NyspKBAQEaPL99+3bZ/PnS5cu4c0338Rf/vIXDBo0qE+vxRjz+DcYcG9lrTf8rIQQ52nubsD2ok+QV3/a4bhe8oWfLgABUiAECDZtERRVhfqVfTMNuiBIggSTpb3X77Up/z9xqHw7FievxZiIKQ/tg0uIM9BnKyGui85/ibu78x6m9zEh3oNbZChbD0Etq7Yd0OmgeyoDQrw2hdo7vGVe6svP5xLF2pdffhm/+MUvsG7dOixduhQRERHw9fW1iVm6dGm/fT9FUdDU1ITAwED4+voiKcl2l7uaGuuS8NjYWISFhfXb9yWEEOKYRbXgSPlOHCzbCotqdhiTHj0b02IX4nfnfoQOSxsURbYZV1UOgdt/AEb5x+HVUW8it/oAbjbl2Y03dNVgw/X3EVO+DYuT12JE6ASPP1Egnq2xS4XJ/Ogtkwx6hjA/ulFBCCGEEOJpuNkCeWs21PL7Wh/oddA9vQBCbKQ2iZEHcoli7U9+8hMwxpCfn4/8/Hy7ccZYvxZrq6urMX/+fPz617/G008/3W+vSwghpG8457jWdB5bCzegqavOYUycIRlPpb2MZOMQAMDbU99Hx32rZTnnMJlMMDhozxKgC0SIbzhGhk9EUesN7C7ehOLWG3bfp9pUhv++8i4SAgdhScozGBw8koq2xO00dqn439ltaO9DsTZQz/DvGUEDVrDlnCMrKwtZWVm4desWTCYToqOjMXv2bLz++uuIiorq9WuHDh36wPO1H/7wh6isrMT69esHJHdCCCGEEHfFzRbIWw5Crai1HfDRWwu1MRHaJEYeyiWKtcCDd0V70l3hfvOb39j8OT4+Hjdv3uw1fsqUKQ8cJ4QQ8uTqO6uxtXA9bjRdcjjurzNgSfIzmBIzz6Y9QYhvOEJ8w21iOedoVVthDHxwr6NU4zB8e+xPcLM5D3tLNqO8vcgupry9EH/J+zVSg4dhSfKzSLldJCbEHZjMHO1mDokBukdoxWxRgHYzh8nMEeb38Pi+UhQF//N//k+cP38e3/rWt/D2228jICAAt27dwh//+EesWbMGW7ZsQXh4uMOvP378OAIDA/s/MUIIIYQQD8Z7zJCzDkKtsl0Qw3x9ID29AEK043Mv4hpcolh744b9CidCCCGeqUfuwsHyrThSsRuKKtuNMyZgWsx8LE5eC3+dod+/P2MMw0LHYmjIGFxtPIc9JZtQ01FhF1fUcgMfXPwFhoWOxeLkdYgPTOn3XAgZKDoR8BEfZWU4h2z/a9hv/vu//xvHjh3Dxo0bMXLkyLvHY2NjMXnyZCxduhR//etf8YMf/MDh10dE0IoPQgghhJC+4N09sGQdBK+utznO/HwgrVkIIZLafbo6lyjWflV5eTkaGxsRERGBuLg4rdMhhBDSTzjnuFR/EtuLPkVrT5PDmGTjEDyV9griDEkOx/sTYwyjwidhRNgEXKw/gX0lX6Khq8Yu7kbTJdxouoTR4enITF6L6ID4Ac+NEEdUzh/ai9ZkVsE5oHJAeYQHk1QOcG79urae3ou7Bj2D0Me2IJxzfPLJJ1i5cqVNofYOPz8/bNiwAREREaioqMD8+fPxv/7X/8Inn3wCHx8fbNmyBenp6XfbIHDO8eGHH+Lvf/872trasGzZMvT09Dj4zoQQQggh3ol398Dy5QHwmgab48zPF9LahRAiQjXKjPSFyxRr8/Ly8NOf/tSmZ+2IESPwr//6rxg2bJiGmRFCCHlS1aYyZBV+hKIWx09SBOmDsSz1eUyInO70PrECEzAhcgbGhk/B2dpj2F+ahZaeRru4yw1ncKXxHMZHTkdm0hqE+VEzfuI8Z6rN+PRaN9p61AfG9SgcTd0qGADhEX6VVA5wAL8+aXrgStwgHwHPj/BFeoz+kXOuqKhAVVUVpk+f3mvM/Tfmt23bho8++ghdXV0ICgqyGfvLX/6C//f//h9++ctfYsSIEfj888+xefNmTJ48+ZFzIoQQQgjxVLyrB5bN+8DrbRfGMH8/SOsWQQgL1iYx0mcuUay9desWXn75ZXR1ddkcv3r1Kl544QVs3LgRqampGmVHCCHkcXXJHdhTshm5VQfAuX2RSWAiZscvwcLE1fCRBqBhZh+IgoQpMfMwIWomTlZn42DZVpjMrTYxnKs4X3scF+tOYHL0HCxIegrBPnR3mgy8jy53oUt+sh7+T6KtR8VHl7v6VKxtaLCu6AgNtf0d+da3voVTp07d/XNsbCz+/Oc/AwCef/55pKWl2b0W5xzr16/HSy+9hOXLlwMA3nrrLZvXIYQQQgjxVryz21qobWi2Oc4C/CCtpUKtu3GJYu17772Hrq4ujB07Ft/97ncRHx+P8vJy/O53v0NeXh5+//vf4/e//73WaRJCCHlEKldxpuYodhd/DpOlzWHM4JBReCrtZUT6xzo5uwfTCTrMisvE5Og5yKnch0MVO9Bl6bCJUbmCk9XZOFt7DNNiFyAjYQUC9UaNMibENYWEhAAAWlpabI7/4he/QHd3NwBg/fr1yM7OvjuWlOS4BUpzczPq6+sxevRom+Pjxo1DYWFhP2ZNCCGEEOJeeEeXtVDb2GJznBkCoFu3CCwkyPEXEpflEsXa06dPQ5Ik/OlPf7p7Yh8fH4+hQ4di1qxZOHnypMYZEkIIeVRlbYXIKvgbytuLHI6H+IZj5aAXMCpsktNbHvSFj+iLjMSVmBY7H0cqduNYxW70KN02MbJqwbGK3ThVnY1ZcYsxJ37pgGyKRsjLo/0eqQ3CQLnTBqEvEhISEBERgdOnT2PZsmV3j0dFRd39f6PR9iaHr++DvwfntquLJcklTmUJIYQQQjTBTZ3WQm2T7ROBLDAAunWZYMGBGmVGnoRLnOGazWbo9fq7hdo7QkJCoNfrYTabNcqMEELIo2o3t2J38UacrjnscFwSdMhIWIF5CSugEx/9UWqt+UkBWJy8FjNjF+FQxQ7kVO6DrFpsYsxKDw6WbUVu1QHMSViKWbGZmrd1IJ4lPUaPidG6h24wVt6m4KfHTPCVAP0DetDeYVY4umXgrakGJASJvcY9zgZjoijipZdewgcffIDnnnvO4R4E1dXVj/RaoaGhiImJwblz57BgwYK7x69cuQKdTtenvAghhBBCPAFv77AWapttn2RkRgN0axeBGalQ665colg7aNAgXL16FX/5y1/wzW9+8+7xP//5z+jq6rJ75I0QQojrULiC3KoD2FuyGd1yp8OYUeGTsHLQCwj1jXBydv3HoA/CitTnMTtuCQ6WbcWpmmwoqmIT0yV3YE/xJhyv2Ht7Ve4C6AQqJJH+ITCGIJ8HF0wNeg7GrJuLPUKtFgIDGAMMegFBPkI/ZXrPq6++imvXruH555/HN7/5TcydOxcGgwH5+fnYsGEDcnJysGbNmkd6rddeew3vvPMOUlNTMWnSJGzduhV5eXmYOHFiv+dNCCGEEOLKeJsJlk37wFvbbY4zY6C19UEQPe3nzlyiWPvcc8/hxz/+MX73u9/h73//O+Lj41FZWYmqqiowxvDss89qnSIhhBAHCluuY0vBR6juKHc4Hu4XjdVpL2FY6FgnZzZwjD4heHrwK5ibsAz7S7/E2drjdpunmSxt2Fa4AUcqdmFB4mpMjp4DUXCJj1xCnEoQBPzHf/wHdu/ejS+++AIff/wx2traEB4ejkmTJmHDhg1IT09HRUXFQ1/r61//OlRVxYcffoiGhgbMmjULa9euRXFxsRN+EkIIIYQQ18Bb260raltNNsdZSJB1RW1ggEaZkf7iEleOa9aswc2bN/Hxxx+jqqoKVVVVd8eeeeYZrF27VsPsCCGE3K+lpwk7ij7BxTrHPcV9RF8sSHoKs+IyIXnoytJQ3wg8O/R1zEtYgb0lX+BSvf3fRWtPE7649VccqtiBzKQ1GB85HQLr/9WLhNzPogDAg1sm3IsbeEuWLMGSJUt6HY+Pj8fNmzftjt9/7MUXX8SLL77Y7/kRQgghhLgD3tIOy6a94O22GyCzUKO1UGvw1ygz0p9colgLAD/60Y/w9NNPY//+/aivr0dERATmzJmDMWPGaJ0aIYSQ2yy3N9Q6ULYFZqXHYcyEqBlYlvIcjD4hDsc9TaR/LF4c8U/IMK3E3pJNuNZ4wS6mqasOn934EAfLtmFx8hqMCk+noi0ZEAY9Q6Ceod3MIcuP9jWBegaD3nU3+yOEEEIIIQBvbrO2PjDdV6gNC7YWagNozwxP4RLF2i1btsDPzw+ZmZk2m08oioL169fDz8+PVtcSQojGbjRdwpaCj9HQVeNwPNaQhNVpLyHVaL+JkDeIMyThf4z6PkrbbmFPyWbcar5iF1PXWYmPr72HOEMyFievw7DQsWB93LSJkAcJ8xPw7xlBD92I7KsMeoYwP7p5QAghhBDiqtSmVsib9oF32O4RwsJDrIVaf1+NMiMDwSWKtT/84Q8RExODzMxMm+OCIOD3v/899Ho9FWsJIUQjDV212Fa4Adcazzsc99MFYHHyOkyNyYDIet9N3lskBQ3G62PeQkHLNewu3ojStlt2MZWmEvzXld8i2TgES5LXYVDwCA0yJZ4qzE9AGC2sIIQQQgjxCGpji7VQ29llc5xFhEK3diGYHxVqPY0mxVrOOf7hH/4B5eX3NqSpr6/H/PnzbeK6u7thMplgMNAudoQQ4mxmpQfZZdtwuGInZNViN84Yw5ToeViS8gwCdIEaZOja0oJH4I1xP8P1povYU7IJVaZSu5iS1nx8eOlfMThkFJYkP4PEoEEaZEoIIYQQQghxRWp9E+TN+8G7um2Os6gw6NYsBPP10SgzMpA0KdYyxvDCCy/gjTfeuPtnRVFQWVnpMH7OnDnOTI8QQrwa5xyXG05jW9EnaOludBiTFJSG1WkvIyEw1cnZuRfGGEaEjcew0LG43HAGe0s2o66zyi7uVvMV3Gq+ghFhE7A4eR1iDYkaZEsIIYQQQghxFWpdo7VQ2227VwiLiYDuqflUqPVgmrVBWLBgAd5++22YTCa8++67CAwMxGuvvXZ3nDEGSZKQkJCA2bNna5UmIYR4lZqOCmwtXO+w3yoAGPRGLEt5FhOjZtEGWX0gMAFjI6ZgVPgknK/Nwf7SL9HUXW8Xd63xPK43XcDYiClYlLQGkf6xGmRLXIWqqlqnQIjXo99DQgghWlBrGyF/YV+oFWIjIT01H8xHr1FmxBk07Vn7/PPPAwDMZjMMBgNeeeUVLdMhhBCv1SV3Yl/pl8ip3AeVK3bjjAmYGZeJRUlPw0/y1yBDzyAyEenRszE+chpO1xzBgbItaOtptonhnONi3Ulcqj+NSVGzsDDpKYT6RmiUMdGCXm89+aZWUIRoz2QyAQAsFvt2QIQQQshAUKvrYfnyANBjtjkuxEVZC7V6nUaZEWdxiQ3G7rRDaG9vR0dHx9072Kqqoq2tDbm5uXj11Ve1TJEQQjySylWcr8vBjqLPYDK3OowZFDwCT6W9jOiAeCdn57kkQYfpsQuQHjUbudUHkF22DR2WdpsYzlWcqTmC83XHMTU6A/MTVyHIJ0SjjIkzSZKE8PDwu+2hDAYDBIFWshPiTKqqwmQyobKyEi0tLXevTxhjGmdGCCHEk6lVddZCrdn2JqGQEA1pVQYVar2ESxRri4uL8cYbb6CoqKjXGCrWEkJI/6poL0ZWwUcobbvlcDzYJwwrBn0dY8In08XpANGJesyJX4qp0fNwrHIvDlfsRLfcaROjqApyqvbjdM0RzIhbhHkJy2lDNy+QmJiInp6eXvv5E0Kco6WlBbW1teCcQ1VVBAQEaJ0SIYQQD6VW1MKy5aB9oTYpFtLKeWA6lyjhESdwiX/p3/72tygsLOx1fOTIkU7MhhBCPFuHpR27izfiVM0hcM7txkVBwtz4ZchIXAkf0VeDDL2Pj+SHBUmrMT12AQ5X7MSxyr2wKLb9qSyqGYfLd+BE1QHMiV+K2fFL4Sv5aZQxGWiMMaSmpmL79u2oqKhAREQEdDpaSeFuzGbz3bYWxP1YLBaoqgrOOWpqahAYGIiYmBit0yKEEOKB1PJqWLZkAxbZ5riQHAdp5VwwySXKd8RJXOJf+/z58xAEAR9++CE2btyIzs5OvP322/j000+xYcMGrFixQusUCSHE7alcxcnqbOwu2YguS4fDmBFh47Fy0AsI94t2cnYEAPx1BixNeRaz4hYju2wbcqsPQFFtT9h6lG7sK/0Sx6r2IiNhJWbELoRepJ1gPZEkScjMzMTu3btRUFDg8OYKcV2cc1gsFuh0Ono6wc1xzhEUFIRFixYhKSlJ63QIIYR4GLW0Gpat2YB8X6E2JR7SirlgkqhRZkQrjLvAmf+oUaNgNBqRk5ODzz77DH/4wx+Qm5sLWZYxefJkxMTEYOfOnVqn+UCKouDixYsYN24cRNGzf5E452htbYXRaKSLD0LcRHFrPrIK/oYqU6nD8XC/aKwc9AJGhI13cmb9w1PnpZbuRuwvy8LpmiPg3PGO5IF6IxYkrsbkmHnQCbTy0hN1dXWhpqYGHR0dVLB1I5xzdHR0ICAgwKPmJW+k1+sRGhqKiAja7JG4N089XyLEnanFlbBsPwTItps8C4MSIC2fA0b1JY/Rl7qhS6ysDQsLQ2NjI6qqqjBu3Dg0NTXh8uXLiI6OhsViQVVVldYpEkKIW2rracaO4r/jfO1xh+M60QcLEldhdvxSKvS5oGDfMKwb8irmJSzHvtIvcaEu165Y125uRVbBRzhUsQMLE5/GpOhZEJlnn9R5Gz8/P6SkpGidBukjb7r4IIQQQkjfqUXlsGw/Aij3FWoHJ0FaOhtMpA1mvZVLFGunT5+OrKwsvP7669i6dStCQ0Px0ksvQRRFyLKM2NhYrVMkhBC3IqsWHK/ci/2lWehRuh3GjIuciuUpzyPYN8zJ2ZG+CveLxvPDvo2MhJXYW7IZlxvO2MW0dDdiU/5/4lD5dmQmr8HYiKkQGJ3gEUIIIYQQ4mqUgjLIO44Aqu3Tc8LQFEiLZ1Kh1su5RLH2zTffRHFxMcLCwiAIAl577TW88847d8dfe+01DbMjhBD3kt98GVsKPkZdp+OnEqID4rE67WWkBY9wcmbkSUUHxOPlkd9BeXsR9pZsxo2mS3YxDV01+OT6B8gu24bM5HUYGTaBVvURQgghhBDiIpT8Usi7jtoXaoenQsqcASZQodbbuUTP2juam5sREhICADh+/Dhu3ryJ8ePHY8KECRpn9nDUs5YQorWm7npsL/zE4apLAPCV/JGZvBbTYxd43GPy3jovFbXewJ6STShqudFrTELgICxJWYfBwaO86u+GEK1567xECHFdNC8Roj3lZjHkXceA+0px4sg0iAungwne9bvpTfNSX+qGLlWsdWdUrCWEaMWimHGoYgeyy7ZBVi0OY9Kj52BpyrMI1BudnJ1zePO8xDlHfvNl7CnZhPL2ol7jUoOHYUnyM0gxDnVidoR4L2+elwghronmJUK0pVwrhLw3x75QO3owxPnTvK5QC3jXvOQWG4wtXbr0kWMZY9i5c+cAZkMIIe6Hc46rjeexrXA9mrrrHcYkBKZiddrLSApKc3J2xFkYYxgaOgZDQkbjauM57CnZhJqOCru4opYb+ODiLzEsdCwyk9ciITBVg2wJIYQQQgjxPsrVAsj7cu0LtWOHQpw3xSsLtaR3mhVri4rsV/8wxmx2ub7zZ0+vrhNCSF/VdVZha+F63GzKczgeoAvE0pRnkR49hzaZ8hKMMYwKn4QRYRNwqf4k9pZ8gYauGru4G02XcKPpEkaHpyMzeS2iA+I1yJYQQgghhBDvoFy+BfnACftC7bhhEOdNppoXsaNZsfaNN964+/8WiwUff/wxAGDhwoWIjo5GbW0t9u3bh6CgIHz/+9/XKk1CCHEpPXIX9pdtwbHK3VBUxW6cMQHTY+YjM3kt/HUGDTIkWhOYgPGR0zEmYgrO1hzD/tIv0dLTaBd3ueEMrjSexfjIGViU9DTC/aI0yJYQQgghhBDPpVy6CfngSbvj4sQREGdPokItccglirW/+c1v0N3djaysLAwbNuzu8RdffBFr167FtWvXsGLFCi3SJIQQl8A5x4X6XOwo+gxtPc0OY1KMw7A67SXEGZKcnB1xRSITMSVmLiZEzcCp6mwcKNsKk7nVJoZzjvO1x3Gx7gQmR8/BgqSnEOwTqlHGhBBCCCGEeA7lwnXIh07bHRfTR0GcOYEKtaRXmhVrvyorKwsGg8GmUAsAo0aNQkBAALZs2YL/7//7/zTKjhBCtFVpKsWWgo9R3HrD4XiQTwhWpD6PcRHT6AOf2NEJOsyMy0R69BzkVO7HoYrt6LJ02MSoXMHJ6mycrT2GabELkJGwwmM3oyOEEEIIIWSgKeeuQT5yxu64OGUMxOnj6LqNPJBLFGsVRUFHRwe2bNmC1atX3z2+ZcsWdHR0QBCo3yIhxPt0WkzYW7IZudUHwblqNy4KImbHLcWCxFXwkfw0yJC4Ex/RFxmJKzAtdj6OVuzC0Yrd6FG6bWJk1YJjFbtxqjobs+IWY078UmqnQQghhBBCSB8oZ65APnbO7rg4bRykaWM1yIi4G5co1s6ZMwc7d+7EW2+9hf/8z/9EREQEamtrUVJSAsYYFi5cqHWKhBDiNCpXcbrmMHYXb0SHpd1hzLDQsVg56AVE+sc6OTvi7vwkf2Qmr8XMuExkl29HTuU+yKrFJsas9OBg2VbkVO3H3PhlmBWXSTcECCGEEEIIeQj5VB6UnAt2x8UZ4yFNGaNBRsQduUSx9sc//jEKCgpw8+ZNFBYWorCw8O7YhAkT8KMf/UjD7AghxHlK2wqwpeAjlLcXORwP9Y3AqrQXMSKUehyRJxOgC8SK1OcxO24Jssu24mRNtt2mdd1yJ/aUbMKxyj3ISFyJ6TELoBP1GmVMCCGEEEKIa+KcQzl5CcqJS3Zj0qyJENNHaZAVcVcuUawNDQ3FF198gYMHD+LixYtob2+H0WjE5MmTMXv2bCpIEEI8Xru5FbuKP8eZmiMOxyVBh/mJqzA3fhkVy0i/MvqE4KnBr2BOwjLsL83C2dpjdm03Oizt2F74CY5W7MaCxNVIj54NSdBplDEhhBBCCCGug3MOJfcilFN5dmPSnHSIE0dokBVxZ4xzzrVOwhMoioKLFy9i3LhxEEVR63QGFOccra2tMBqNVEgn5AkpqozcqgPYU7oZPXKXw5jR4elYMejrCPWNcHJ27oPmpf5T11mFfaVf4GLdyV5jQn0jsCh5DSZEzoDAqK88IY7QvEQIcTU0LxHS/zjnUI6dh3L2it2YNG8yxPHDNcjKfXjTvNSXuqFmK2t//vOfw2g04rvf/S5+/vOfPzCWMYaf/exnzkmMEEKcpKDlGrIKPkJtR4XD8Uj/WKxOexlDQuiRGeI8kf6xeGH4P2FewkrsLdmMa43n7WKauuvx9xt/QnbZNmQmr8Xo8HQq2hJCCCGEEK/COYdy5CyU89fsxqT5UyGOHapBVsQTaLaydtiwYYiJicGhQ4cwbNiwXivonHMwxnD9+nUnZ9g3tLKWEPKoWrobsb3oU1yqd7xy0Uf0xcKkpzEzbhE9av6IaF4aOKVtt7CnZDNuNduvFrgjzpCMzOS1GB46jv7+iVfibSbwrh7bY5zDZDLBYDDY/V4wPx+wIIMzUySEEDpfIqQfcc6hHDoN5eIN2wHGIC2YBnH0YG0SczPeNC+5xcra9PR0hIWF3f1/QgjxdBbVgiMVO3GwbBssSo/DmAlRM7E85WsI8glxcnaEOJYUNBivj3kLBS3XsLt4I0rbbtnFVJpK8Ncr/xdJQYOxJOUZpAVTXy7iPXibCea/bLIr1gKATlVhEexXnTM/H+i/uY4KtoQQQogb4iqHkn0KSt5N2wHGIC2aDnFkmjaJEY+hWbF2/fr1Dv+fEEI80bXGC9hauB6NXbUOx2MNSXgq7RWkGIc4OTNCHk1a8Ai8Me5nuNF0CXtKNqHSVGIXU9p2C3+69K8YHDIKi5PXISmITlSJ5+NdPdZCrSAA0n2rJFQFEO47Jit3v4aKtYQQQoh74SqHcvAElMv3LWBgDNLimRCHp2qTGPEomhVrCSHEGzR01WBr4Xpcb7zocNxPF4Clyc9iSsw86vlJXB5jDMPDxmFo6BhcaTiDPSVfoK6z0i7uVvMV3Gq+ghFhE5CZvBZxhiQNsiXEySQRTHffqbXCwO57zI0DgFl1WlqEEEII6R9c5ZD35UC9Vmg7wBikpbMgDk3RJjHicTQr1i5duvSRYxlj2Llz5wBmQwgh/atH6UZ22TYcrtgJRZXtxhljmBqTgcXJ6xCgC9QgQ0Ien8AEjImYglHh6Thfl4N9JV+gqbveLu5a43lcazyPcZFTsShpDSL9YzXIlhBCCCGEkCfDVRXy3hyo14tsBwQB0rLZEAfT4gTSfzQr1hYVFT086DZPbzJMCPEcnHNcqj+F7UWfoLWnyWFMUtBgPJX2MuID6c4rcW8CEzApahbGRUzFmZqj2F+WhbaeZru4i3Uncan+NCZFzcLCpKcQ6huhQbaEDCDOAUWxtjiwyIAsA7ICBoAb/MH8fbXOkBBCCCGPiSsq5D3Hod4sth0QBOiWz4GQlqhNYsRjaVasfeONN7T61oQQMiCqO8qxpeBjFLZcczhu0BuxIvV5TIicQTehiEeRBB2mxc7HpKhZyK0+gOyybeiwtNvEcK7iTM0RnK87jqnRGZifuIo20iNuiascvLkVvLYRvKYBamkV0N4JMIA7mtvbO8DNFrCgAGtfW0IIIYS4Da4okHcdg3qr1HZAFKFbMQdCaoI2iRGPRsVaQgh5Ql1yJ/aVfonjlXvBuX0fQoGJmBm3CIuS1sBX8tMgQ0KcQyfqMSd+KaZGz8Oxyr04XLET3XKnTYyiKsip2o9TNYcxI24RMhJWUCsQ4rI450CrCWptA3hNI3htA9S6JsBsuRdjkWHtRPuAm3A9ZvBGmQq2hBBCiBvhsgJ55xGoheW2A5II3Yp5EFLitEmMeDyX2mCsvb0dHR0dUFVrsUNVVbS1tSE3NxevvvqqxtkRQogtlas4W3sMu4o/h8nc6jBmcMgorB70EqIC6IOceA8fyQ8LklZjeuwCHKnYhWOVe2BWemxiZNWCI+U7cbLqIGbHL8Hs+KXwk/w1ypiQ24XZ9g6otY13V83y2kbwHnP/fANVBW9pB3Q6QO9Sp+CEEEIIuQ+XFcjbD0MtrrAdkCToVmVASIrRJC/iHVziTLG4uBhvvPHGA/vYUrGWEOJKytuLkFXwEcraChyOB/uGYWXqCxgdnk4tD4jX8tcZsCTlGcyMy0R2+XacqDoAWbXYxPQo3dhfmoXjVfswL34FZsQthI9I/T3JwOMdXdaVsjW3i7O1jeCdXU/2oqII6CQwnQjOBMDUAajcNsZsBiwW8JoGICrsyb4fIYQQQvodl2XI2w5DLam0HdBJ0K2eDyEhWpvEiNdwiWLtb3/7WxQWFvY6PnLkSCdmQwghveuwtGNX8ec4XXPYugrrPpKgw9yE5chIWAG96KNBhoS4nkC9EasGvYA5cUtwoGwLTtccgcoVm5guSwd2Ff8dRyt3Y0HiKkyJyYBO0GmUMfE0vKvHWpi9u2q2EdzU8USvyQwBYNFhgJ8PlOMXAF8fMJ9771kGQJVEsM4uoPu+1bmqCsveHPCWdogzxoNJ4hPlQgghhJD+wS0y5K3ZUMuqbQf0OmuhNj5Km8SIV3GJYu358+chCAI+/PBDbNy4EZ2dnXj77bfx6aefYsOGDVixYoXWKRJCvJzCFZysOog9JZvRJTu+wB8RNgGrBr2IML9IJ2dHiHsI9g3D2iHfwNyE5dhX+iUu1OXY3fQwmVuxpeBjHC7fiYVJT2FS9GyIjApZ5NHxHjN4nbUgay3ONoC3mp7oNZm/L1hUOFh0GISoMLDIMDCDtW2HWtsI5WQeIDh4ikJgYMZAwMcM3m6yXWXLOZRzV6GWVkFaMhNCROgT5UgIIYSQJ8PNFmuhtrzGdkCvg+7pBRBi6TqPOAfjjpaGOdmoUaNgNBqRk5ODzz77DH/4wx+Qm5sLWZYxefJkxMTEYOfOnVqn+UCKouDixYsYN24cRNGzLyo552htbYXRaKTHu4lXKGq9gayCj1BtKnM4Hu4XjdVpL2FY6FgnZ0buoHnJPdV0VGBvyWZcbjjTa0y4XzQWJT+NcRHTIDDamInY4mYLeH3zvVWzNY3gzY57iD8q5qMHiwoDiw4Hi7IWZxEY0OvcotY2wvyXTdaNw+5bIauqCgRBvPMHwNR5b3Oy8BAw3e11E6IIafo4CBNHgjkq+hJCSD+g8yVCesfNFshZB6FW1toO+OihW7MQQnS4Nol5OG+al/pSN3SJlbVhYWFobGxEVVUVxo0bh6amJly+fBnR0dGwWCyoqqrSOkVCiBdq7WnGjqJPcaEu1+G4XvTBgsSnMCt+MT2uTchjiA6Ix8sjv4Py9iLsLdmMG02X7GIaumrw6fU/IrtsGxYnr8PIsIkefyJHHOOyAt7QfHfjL7W2EbyxBXiSdQd6HYTI0K+smg0HjIY+vceYnw+Ynw94Vw9gVm0HVRUQvnLM1wdgAmCx2K7EVRTIx85BKK6AlDnDuhqXEEIIIU7Be8zWQm1Vnc1x5usDac1C641bQpzIJYq106dPR1ZWFl5//XVs3boVoaGheOmllyCKImRZRmxsrNYpEkK8iKxacKxyLw6UZqFH6XYYMy5yGpanPo9gH3pslZAnlRCYildH/wDFrTexu2Qjilpu2MXUdFTgb1d/h4TAVCxOXochIaOpaOvBuKKCN7bc3vjr9iZgDc3W4ufjkkQIkWFgkaF3V82yEOMTr2RlQQbov7nOWqz96s/AOUwmEwwG++Iv7+qGcuwceH2zzXG1ohbm9dshZUyBMDyV3uOEEELIAOPdPbB8ecC68edXML/bhdpIKtQS53OJYu2bb76J4uJihIWFQRAEvPbaa3jnnXfujr/22msaZkcI8SY3mi5hS8HHaOiqcTgeE5CA1WkvY1DwcCdnRojnSzEOxT+O+QlutVzB7uKNKG8vsospby/Cf15+B6nBw7Ak+RmkGIdqkCnpT1zl4M2ttzf+ur1qtr4JkJWHf3FvBAEsIgTC7RWzLDIMLDwYTBiYVhosyAAWZLA5xjkH95Ug9PJYnxAfDSX3IpRzV21XB5stkPcch1BYDmnBVDA/3wHJmRBCCPF2vLsHli/2g9c22hxnfr6Q1i6kfvJEM5r1rP33f/93rFy5EoMHD757rLm5GSEhIQCAnJwc3LhxA+PHj8eECRO0SLFPqGctIe6tqbse2wo34ErDWYfjflIAMpPXYFrsAtrsyAXRvOR5OOe42ngee0s2obqjvNe4YaFjkZm8FgmBqU7MjjwuzjnQ0n5v46/aRqh1Tff6uD4OxsDCg62rZu+smA0PAZO0nasfdV5SK2og78kBb7PfBI0F+EFaNANCStxApkoI8RJ0vkTIPbyrG5bN+8Hrm2yOM38/SOsWQQgL1iYxL+NN81Jf6oaaFWuHDRsGxhjS0tKwatUqLFu2DDExMVqk0i+oWEuIezIrPThUvh2HyndAVu2LBYwxTI6eiyXJz8CgD9IgQ/IoaF7yXCpXcan+JPaWfNHrincAGB2ejszktYgOiHdiduRBOOdAe8e9jb9uF2d5j/nxX5QxsJAg68ZfdwqzEaH3NupyIX2Zl3iPGcrhM1CuFjgcF8cOgzhrApie+qMTQh4fnS8RYsU7uqwrahts2xGxAH9roTbUqFFm3seb5iW3KNaOHz8eXV1d1iQYA2MMEydOxMqVK5GZmYmgIPcqilCxlhD3wjnH5YYz2F70CZq7GxzGJAQOwtODX6EVe26A5iXPp3AFZ2uOYX/Zl2jpbnQYwxjD+MjpWJT0NML9op2cIeGmznsbf9U0gNc1gnc67vv9qJgx0LYwGxkK5qPvp4wH1uPMS8qtUigHTtj1vwUAFhIEacks2o2aEPLY6HyJkNuF2s37rJuUfgUzBEC3bhFYiHvVotydN81LblGs7enpwZEjR7B3714cPnwYHR0d1oQYgyRJmD17NlasWIGMjAzo9a5/Uk7FWkLcR11nFbIKPsKt5isOxw26ICxN/RomRc2CwAamvyHpXzQveQ+LasHp6kPYX7YFJnOrwxjGBEyOnoOFiU8h2Jc2hRgIvKvbWpi9u2K2CdzU8USvyQwB1v6yUWH3es36+vRTxs73uPMSN3VC3pcLtaTSfpAxiFPHQJwyZsD67xJCPBedLxFvx02dsGzaB95sew7JggKgW5sJFhyoUWbey5vmJbco1n6V2WzG0aNHsXfvXhw6dAgmk7VnF2MMAQEBWLhwIX79619rnOWDUbGWENfXLXdhf1kWjlXsgcrtN65hTMCM2IXITF4DPylAgwzJ46J5yfuYlR7kVO1Hdvk2dFkcFwlFQcL0mAXISFyJQD09zva4eI/Z2r7gzqrZ2gbwVvv+qn3B/P2sK2Wjbxdmo8LAAvz6KWPX8CTzEuccal4+5KNnAYtsN86iw6FbMotW/xBC+oTOl4g34+0d1hW1zW02x5nRAN3aRWBGKtRqwZvmJbcr1n6VxWJBTk4O/vrXv+L06dMArEXb69eva5zZg1GxlhDXxTnH+boc7Cj6FO29rMRLDR6Gpwa9jBhDopOzI/2B5iXv1SV34ljFbhyp2IUexfEj9zrRB7PiMjE3fhn8dQYnZ+heuNkCXt8EXvOVwux9FzV9xXx9rMXY2/8J0eGAwd/jf1f7Y17izW2w7D4GXuOgXY9OgjR7EoQxQzz+75IQ0j/ofIl4K95msq6obW23Oc6CA62F2iA6P9SKN81LfakbutRuDHV1ddizZw927dqFS5cugTEGF6slE0LcTKWpFFkFf0NJa77DcaNPKFakPo+xEVM9/sOBEE/kJ/ljUfIazIhbhEPlO5BTuQ8W1XYDK4vSg+yybcitOoA58UsxO24xfCTPWsX5OLisgDc0W/vL1jZCrW0Ab2wFnuTcS6+DEBkKdrvHrBAVDhgNNL8+JhYSBN3XlkA5lQflZJ7tv41FhnzwJITCckiLpoMZ/LVLlBBCCHFRvLXdWqhts30qiIUEWQu1gfREJXE9mhdrm5qasGfPHuzevRvnzp0D5/xugdbX1xfz5s3DihUrNM6SEOJuOi0m7C7ZhJPV2eBctRsXBQlz4pdifsJKKtoQ4gECdIFYnvocZsctxsGyrThZkw1FtW130i13Ym/JZhyv3It5CSswI3YhdKLr98XvD1xRwRubwWsawesaodY0gDe0AKr9/PjIJMlamL2zajY6HCw4CEygwmx/YoIAado4CCnxkHcfs1vprJZUwrJ+G8QF0yAOTtIoS0IIIcT18OY2a+uDdtuWWSzUaC3U0o1O4qI0K9Zu2rQJu3btwunTp6HevlDgnEMURUydOhUrVqzAwoULERBAdzkIIY9O5SpOVR/C7pKN6LQ47qk4LHQsVg16ERH+MU7OjhAy0IJ8QvDU4FcwJ2EZ9pdm4WztMbsbNh2Wduwo+hRHK3djQeJqTI6eA0nQaZRx/+MqB29u/cqK2Ubw+iZAtu/V/cgEASwyFEJk2N1NwFhYMG1y5URCdDh0X18O5dh5KJdu2Izxrh7I2w+Dj0yDODcdzMc7bkIQQgghveHNbdYVtfdtgMrCgq2FWg/rlU88i2Y9a4cNG2bT5mDUqFFYsWIFli1bhvDwcC1SeiLUs5YQ7ZW05iOr4CNUmkocjof6RWLVoBcwInQCvXc9DM1LpDf1ndXYW7oZF+tO9hoT6huBhUlPY2LUTAjMvYqPXOVAa7u1IHunOFvXBFgsj/+ijIGFB98uzN7e/Cs8BEzy7POb/jaQ85JaXAl5Xw54R5fdGAsyQFo8A0J8dL9+T0KI+6PzJeIt1KZWyJv2gXd02hxnESHQrVkE5u+rUWbkft40L7lNz9rExEQsX74cK1asQHJyspapEELcWJu5BbuK/o6ztcccjusEPeYnrcKc+GXQedDqOULIw0X4x+CF4f+EjIRV2FOyCdcaz9vFNHXX4/Obf8ah8u3ITF6L0eHpLlm05ZwD7R1Qa25v/HV71Sx6zA//4t4wBhYSdHfjLxYVBhYRCqbTvFMWeQAhJQ66l1ZCPnAS6q1Sm7E7m6iIE0dCnD6OiuyEEEK8itrYYi3Udtre0GSRodZCrZ+PRpkR8ug0OxPfuHEjxowZo9W3J4R4AEWVcbxqH/aVfNHrLvBjIqZgRerzCPF1vxX7hJD+E2tIxP8Y9b9R2laAPSWbcKv5il1MXWcV1l97D7GGJCxOXofhoeM0vcPPTZ33Nv6qaQSvbQTvcjzXPSoWHAgWFQ4h6nY7g4hQemTeTTE/X0jL50C9XgQ5+xRg/spqas6hnL0CtbQK0pKZEMJDtEuUEEIIcRK1vgny5v1250ssOhy6pxeA+VKhlrgHzdogeBpqg0CIc+U3X8GWgo9R11npcDwqIB6rBr2IISGjnJwZ0QLNS6SvCluuYVfxRpS23eo1JiloMBYnr8PgkJEDng/v6gavuV2Yrb1dmDV1PvwLH4AFBtzd+Eu4swkYXaQ4jTPnJd7aDnlvDtSKWvtBUYQ0czyE8SNo8zdCvBydLxFPptY1Wgu13T02x1lMBHRPzadzIBflTfOS27RBcJY//vGPOHHiBNavX99rzK1bt/Db3/4Wly5dgiAISE9Pxw9/+EPExsY6MVNCyMM0dzdge9EnyKs/7XDcR/JDZtIazIhdCFHwiimOEPIYBgWPwBvjfoYbTZewp2STw17XpW238Oe8/4O04JFYkrIOSUGD++V78+4e8Nom8LpGqLf7zPI2xxsiPirm73d34y8h6nY7A9o4w2swYyCktZlQz1+DnHMBUL6ymZyiQD5yFkJRBaTMGWBBBu0SJYQQQgaAWtMA+Yv94Pe1hhJiIyE9NZ+eIiJux+MrGX/729/w3nvvIT09vdeY5uZm/MM//APS09OxYcMG9PT04J133sGrr76KrKws+PjQHRhCtGZRLThSvhMHy7bCojruzzgpahaWpn4NQfpg5yZHCHFLjDEMDxuHoaFjcKXhDPaUfOFwtX5By1X84cJVjAgbj8zkdYgzJD3y9+BmC3hd093+sry2Aby57cny9vW5u2LWWpwNAwz+Hr8agTwYExjESSPBkmIg7z4O3tBsM66W18D88TZIGVMgDE+l9wshhBCPoFbXw/LlAbse/kJclLVQq6c9S4j7cYlirdlshl7fv3c6amtr8eMf/xjnzp1DSkrKA2MPHDiArq4u/OY3v7lbmP3tb3+LOXPm4Pz585g2bVq/5kYIeXScc1xrOo+thRvQ1FXnMCbOkIyn0l5GsnGIk7MjhHgCgQkYEzEFo8LTcaEuF3tLv3A431xrvIBrjRcwNmIqMpPXINLf9ukbLivg9bcLs3dWzDa1Ak/ScUqvgxB5u7/s7V6zMBqo0EZ6JUSEQvf8Mii5F6Ccu2b7/jNbIO85bl1lu2AqPRJKCCHEramVdbBkHbDt2w5ASIiGtCqDCrXEbblEsXbVqlVISEjAb37zG4SGhvbLa169ehVGoxHbtm3DBx98gMpKx30tAWDatGn44IMPHK6gbW1t7Zd8CCF9V99Zja2F63Gj6ZLDcX+dAUuSn8GUmHkuuXM7IcS9CEzAxKiZGBcxFadrjuBA2Ra09jTZxV2qP4m8+lOYGDgJ8zEVIY3c2mu2oQVQ1cdPQJIgRIZaC7ORt1fOBgdRn1HSZ0wSIc2eBCElHvLe4+BtHTbjan4JLJV1kDJnQEimll+EEELcj1pRA0tWNmC5r1CbFAtp5TwwnUuUuwh5LC7x7m1oaEBjY2O/FWoBICMjAxkZGY8UGx8fj/j4eJtjf/7zn+Hj4/PA9gmOcM7h6Xu23fkZPf3nJNrpkbtwsHwbjlbuhqLKduOMCZgak4HFSWvhr7P23qP3o3ejeYn0J4GJmBqTgYmRM3Gi+iCyy7eho6sF3CIDsgxYZHBZwZnaPTiHfUg3DcK8thEIUv0f/ZuIAlh4CNjt/rJCdBgQagQT7G880fvaPbnCvMTioyC9sALKodNQrxfZjPGOTli+3A9h7FCIsybSRS0hXsAV5iVC+oNaVg156yHredlXCMlxEFfMBSSR3uduwpvmpb78jC5xVrZ8+XJ8/vnn2LFjB5YtW6b5o30ff/wxPv30U7z11lsICwvr09e2tbVBcHCh5Uk45+jstO5QrfW/FfEsnHNcbT6LfZVfoN3S4jAmIWAQliZ8DdH+CbB0KmgFrX4nNC+RfsQ50NYBob4ZrL4ZExssGNM4CSf8buC48Qa6BdvVGwoUnDTk42xAIaa0p2F263AEqPc9qcMYeGgQ1PAQ8IgQ8PBg8NAg4P5dYNvbB/iHI87kUvPStNEQokIgHr8Idl9PP+X8NZiLyiHPnQQeEaJRgoQQZ3CpeYmQx8Qq6qDbd8J2M00AamI05DnjgY4n27SVOJc3zUtqH57Ac4libUNDA0RRxJtvvomf/OQnCA0NhY+Pz91/KMYYdu7cOeB5cM7x+9//Hh9++CFef/11vPLKK31+jaCgIIj3X3x5mDt3A4xGo8f/MhHnqe4ox5aCj1DUegMA7H6PAvXBWJ7yHMZHTqf3HbFD8xJ5HPx2Yda6+dftHrN1TXYbVOigw/yO0ZjWOQTHA28gJzAfFma7kkNhKnKD8nE2sBgz1bGYbZwLv+g4sKhQsMhQMMklTrmIE7ncvDTeCD44BfK+XPDSKtux9k5IO49DnDoGQvoohyu8CSHuz+XmJUL6SC2uhHzwtPUPX7leFAYlQFw2G8zDazGeyJvmJeW+GwwP4hJXDvv377/7/93d3aiqsj2BdMY/mMViwVtvvYUdO3bgBz/4Ab7xjW881uswxjz+DQbc+zm94WclA6tL7sCeks3IrToAzu3vNAlMxOz4JViYuBo+kp8GGRJ3QfMSeRhu6gSvaYBa22gtzNY2gnd1P/LX+3MfLGobi+mmoTgSdA0nAwqgSAB0EqCTwHQiLJKEQ6wYJ3V1mBe+HDOiF8FHpM0tvJWrzUssMAC6pxdAvXQT8tFzto+PqiqU3IvgxZWQFs8ECwnSLlFCyIBxtXmJkEelFpZD3nHEbkWtMDgJ0tLZYCLdaHRX3jIv9eXnc4li7RtvvKF1CvjBD36A/fv349///d+xbNkyrdMhxOOpXMXZ2mPYVfR3mCxtDmMGh4zCU2kv2+24TgghD8M7u21XzNY0gnd0PtFrsqAAsKhwGKPCsDpqJeYFAwdrd+F0zRGo3PbCocvSgV3Fn+No5R7MT1yFqTEZ0AlUtCXaY4xBHDcMLDEG8p7j4DUNNuNqdT3MG3ZAmjMJwujBHn/hRAghxPUpt0oh7zxqt5GrMDQF0pKZ9EQI8TheWaxVFAVNTU0IDAyEr68vvvzyS+zatQs/+MEPMHnyZNTX19+NvRNDCOk/ZW2FyCr4COXthQ7HQ3zDsXLQCxgVNokuEgkhD8W7e8Brm8DrGqHW3C7Otj1ZvzLm7wcWHQYWFQ4hOgwsMgwswHZ1fwiAtcZvYG7Ccuwr/RIX6nLsNg4wmVuxteBjHCnfiQVJq5EeNRui4BKnX8TLCaFG6J5dAuVUHpRTedZ+zXdYLJAPnIBQVA5p4XS79z4hhBDiLEp+KeRdDgq1w1MhZc6gQi3xSC5ztaCqKvbu3Yvc3FzU1tbiL3/5C3bt2oXZs2fDYDD06/eqrq7G/Pnz8etf/xpPP/00duzYAQD4t3/7N/zbv/2bTeydGELIk2s3t2J38UacrjnscFwSdMhIWIF5CSugE/XOTY4Q4ha42QJe1wRe+5V2Bs2OV+c/KubrAxYdDhYVBhYVBiEqDDD4P/LNonC/KDw/7B+RkbACe0s243LDGbuYlp5GbM7/Lxwu34mFSU9jfOQ0CIwuLoi2mChAmj4OQnKcdZVti+3vklpUAcvH2yAunAYxLVGjLAkhhHgr5WYx5F3HbG8oAhBHpkFcOB1MoIU9xDMxfv8SEA2YTCa8+uqruHTpEjjnYIzh+vXrmDZtGoKCgvDxxx8jKipK6zQfSFEUXLx4EePGjfOKDcZaW1u9ogE06R8KV3Ci6gD2lGxGt+z4MeRR4ZOwctALCPWNcHJ2xBPQvOSZuKxYC7NfXTHb1Gp3wt4neh2EKOuKWRZ9uzAbZOjX901FezH2lGzCjaZLvcZEBcRjcfJaeoLAg7nbvMTNFihHz0LJy3c4Lo5MgzhvMpie2nkQ4q7cbV4i3k25Vgh5b459oXb0EIjzp1Kh1kN407zUl7qhS6ys/Y//+A9cvHgRQ4YMQXl5Obq7u9HV1QVFUVBWVoZ3330X77zzjtZpEkIeQ2HLdWwp+AjVHeUOx8P9orE67SUMCx3r5MwIIa6EKwp4Q8vtjb8aoNY0gje22D3y1ieSBCEy9O6qWSEqDAgOGvCT+/jAFLw6+gcobs3H7pLPUdRywy6mtqMCH139DyQEpiIzeS2Ghozx+BNU4tqYXgdpwTQIqQmQ9+WCd3bZjCtXC6BW1EBaPAtCXKRGWRJCCPEGytUCyPty7Qu1Y4dCnDeFCrXE47nEytrZs2ejubkZx48fx8qVK1FXV4fr16+juroaCxcuRHBwMI4fP651mg9EK2sJsdXS04QdRZ/gYt1Jh+M+oi8WJD2FWXGZkGjTHfKEaF5yL1zl4E0t4DUN4LVN1k3AGpoBWXn4F/dGFMEiQiBEhYNF3S7Qhho172PGOcetlivYXbyp1z7dAJBiHIYlKeuQahzmxOzIQHLneYl3dkM+cAJqQZn9IGMQ00dBnDYWzMPPeQnxNO48LxHvoVy+BfnACftC7fjhEOem03vXw3jTvOR2K2ubm5sREBAAo9Foczw6Ohp6vR7t7e0aZUYI6SuLasGxit04ULYFZqXHYcyEqBlYlvIcjD4hTs6OEOJsXOVAa/u9NgY1DVDrmwCL/PgvyhhYeIh146+o271mw4NdsnDEGMOQkNEYHDwK15rOY0/xJodPGhS33sAfL/4LhoaOweLkdUgITNUgW0KsmL8vpBVzoV4rhHzoNGC23BvkHMrpy1CLKyEtnQUhLFizPAkhhHgW5dJNyAftF/uIE0dCnD3R44t5hNzhEsXaxMREFBUV4dChQ3ePdXV14YMPPkBnZyeGDh2qYXaEkEd1o+kSthR8jIauGofjsYYkrE57iVaOEeKhOOdAm8m68VdN491NwGwKPX3FmHWFbFQYhOhwsMgwsMgQMMklTmEeGWMMI8MmYnjoeOTVn8Keks0O58qbTXm42ZSHUeGTkJm8FjEBCRpkS4j1PSuOTIMQHwV5z3GolXU247y+CZZPdkCaMQHC+OH0SCohhJAnoly4br1BeB8xfTTEmeOpUEu8iktc6XzjG9/Aj370I3z729++e2zChAkArCeKzz33nFapEUIeQUNXLbYVbsC1xvMOx/10AVicvA5TYzIgMtdb+UYI6TvOOWDqBK9ttBZnb/ea5V2OV9Q/KhYcdHfjLxYVZi3OetCGRgITMC5yGkZHTMa52uPYV/oFWrob7eKuNJzF1cZzGBcxDZnJaxDuF61BtoQAzBgIad1iqOeuQs65YNtHWlYgHzkDobgCUuYMsMAA7RIlhBDitpRzVyEfOWt3XJw6BuK0cVSoJV7HJYq1Tz/9NFpbW/Hee++hq+veZgYBAQF47bXX8LWvfU3D7AghvTErPcgu24bDFTshq/Yr5xhjmBI9D0tSnkGALlCDDAkh/YV3dIHXNVo3/qqztjPgHV0P/8IHYEEGa0E2Kuxer1lfn37K2LWJTMTk6DkYHzkdp6sP4UDZFrSbW21iOOe4UJeLi/UnMTl6DhYmPoVg3zCNMibejAnWPrUsKRby7mPWzf++Qi2rhuXjbRDnT4U4LEWbJAkhhLgl5cwVyMfO2R0Xp42DNI02oSbeySU2GLvDZDLh0qVLaG5uRkREBEaOHAmDwaB1Wo+ENhgj3oRzjssNp7Gt6BOHK8IAICkoDavTXqa+i8QpaF7qX7y7597GX3dWzLZ1PNFrsgA/66ZfdwqzkaFgAX79lLH7Mys9yKnaj+zybeiyOP67FgUJ02LmY37iKgTqjQ5jiOvw1HmJywqUnPNQzl1zOC4MTYE0f4rX3HghxJ146rxE3Jd8Mg9K7gW74+KM8ZCmjNEgI+Js3jQvud0GY3c0NDSgpqYG7e3tkGUZcXFxblOsJcRb1HRUYGvhetxqvuJw3KA3YlnKs5gYNQsC03YXdkLIw3Gz5fZK2a+0M2hpe6LXZH4+dzf+EqLCrEVag38/ZeyZ9KIP5iUsx7SY+ThasQtHKnahR+m2iVFUGccr9+JUzWHMiluEufHL4a+j8yTiXEwSIc1Jh5ASD3lPDrjJ9uaCerMYlso6SJkzICTFaJQlIYQQV8Y5h3LyEpQTl+zGpFkTIaaP0iArQlyHSxRrZVnGT3/6U2zZssXmOGMM69atw89+9jMIAhV9CNFSl9yJfaVfIqdyH1Su2I0zJmBmXCYWJT0NP4mKMoS4Ii7L4HXNdzf+4rWN4E2twJM8ZKPX3dv463avWQQZPP7O+EDxlfywKHkNZsQtwqHyHcip3AeLaraJsSg9yC7bjpyqA5gTvxRz4pbAR6JVysS5hMQY6F5aAfnQaajXi2zGuKkDli/2QZwwHOLMCW63ISAhhJCBwzmHknsRyqk8uzFpTjrEiSM0yIoQ1+ISZ07vvvsusrKyAACSJCE4OBgtLS2QZRkbN25EcHAwvvvd72qcJSHeSeUqztflYEfRZzDd10/xjkHBI/BU2suIDoh3cnaEkN5wRQFvaLnbxkCtaQRvaH6ywqxOghAZem/VbHQ4YAykXeAHQIAuEMtTn8PsuMU4WLYVJ2uyoai2N8p65C7sK/kCxyv3IiNhBWbELoJO1GuUMfFGzNcHuiWzoKTGQzlwErzH9saCcv461NJqSItnWm/kEEII8WqccyjHzkM5a/+UppQxBeK4YRpkRYjrcYmetdOnT0dzczO+8Y1v4J//+Z+h1+thNpvxpz/9CX/84x8RFhaGnJwcrdN8IOpZSzxRRXsxsgo+QmnbLYfjwT5hWDHo6xgTPpneC0RT3j4vcVUFb2y19patvd3OoL4ZUOxXwT8yUQSLCLGumr29CRgLDabCrEaauuuxvzQLZ2uPgXPVYUyQPhjzk1ZjSvRcSILOyRmS+3nbvMTbOyDvy4VaWmU/KAgQp42FmD6a5hBCNORt8xJxLZxzKEfOQjlv3/NcWjAN4pghGmRFtOZN81Jf6oYuUaydMGECGGM4d85+B8CJEyeCc47z589rkNmjo2It8SQdlnbsLt6IUzWH4GiKEAUJc+OXISNxJXxEXw0yJMSWN81LXOVASxvUmoZ7vWbrmwCL/PgvKghg4cHWjb+irO0MWFgwmId/nrmj+s5q7C3djIt1J3uNCfWNwMKkpzAhaiZERv+GWvGmeekOrnKol25Yd/WW7W8WCbGRkBbPBAsO1CA7Qog3zkvENXDOoRw6DeXiDdsBxiAtnAZx1GBtEiOa86Z5ye02GJszZw727t2L6upqxMTc24igpKQEnZ2dWL16tXbJEeJFVK7iZHU2dpds7HU38hFh47Fy0AsI94t2cnaEeB/OOdBqutdftqYBal0jYLY8/osyBhZqvNvGgEWFgUWEUE9JNxHhH4MXhv8TMhJWYU/JJlxrtL+Z3dRdj89v/gXZ5duRmbQWYyIm04aPxCmYwCCOHw6WGAN593HwukabcbWqDuYN2yHNTYcwMs3jL8oIIYRYb+Qp2Seh5OXbDjAGadF0iCPTtEmMEBfmEldma9euxZkzZ/D1r38dzz33HCIiIlBRUYHPP/8c/v7+mDBhAnbt2nU3funSpRpmS4hnKm7NR1bB31BlKnU4Hu4XjZWDXsCIsPFOzowQ78A5B0ydNoVZXtsI3t3zRK/LQoKshdk7q2YjQ8H09Ii8u4s1JOJ/jPrfKGsrxO6SjbjVbN/7rb6zGhuu/wGx5UlYnLwWw0PHU3GMOIUQFgzdc0ugnMyDcvqyba9sswXyvlwIheWQFkwDC6DN8QghxFNxlUM5cALKlfva6jEGafFMiMNTtUmMEBfnEm0Qhg8f/sixjDFcu2bf40Rr1AaBuKu2nmbsKP47ztcedziuE32wIHEVZscvhY56IBIX5Y7zEu/oAq9rtLYzuFOg7eh6otdkQYZ7K2Yjw8CiQsF8ffopY+LKCluuY3fJRpS05vcakxSUhsXJz2BwyEgnZua93HFeGghqVZ11lW1ru90Y8/eDtHAahEEJGmRGiPeheYk4E1c55H05UK8V2g4wBmnpbIhDkzXJi7gWb5qX3K4NQl/qxS5QWybEI8iqBccr92J/aRZ6lG6HMeMip2J5yvMI9qUdnAl5Ery7597GX3dWzbY7bjXyqJjB/+7GX3dXzfpTD2lvNSh4OP7n2LdxszkPu4s3otJUYhdT2laAP+f9H6QFj8Ti5LVINtJGHmTgCbGR0L24wrqpzGXbmwm8swuWrdkQRw+BOGcSrfonhBAPwVUV8p4cqDeKbAcEAdKy2RAHJ2mTGCFuwiWKtTdu3Hh4ECGk3+Q3X8aWgo9R1+lgx2YA0QHxWJ32MtKCRzg5M0LcHzdb7m38VdsIXtsA3mK/oqwvmJ/v3Y2/7hZmDf79lDHxFIwxDAsdi6EhY3C54Qz2ln6B2o4Ku7iClqt4/+JVDA8bh8XJzyDOQBdMZGAxvc66gjY1HvL+XPBO25vEyuV8qGXVkJbMhBAbqVGWhBBC+gNXVMi7j0HNL7EdEATols+BkJaoSV6EuBOXKNYSQpyjqbse2ws/weWGMw7HfSQ/LE5eh+mxC2gHcUIeAbfI4PVN1lWzNQ3gdU3gTa22/Rn7ykcP4faKWRYVDiE6DAgM8PjHgkj/YYxhTMRkjAqfhAt1udhb+gWauurs4q43XsT1xosYEzEFi5PXItI/VoNsiTcRBiVAF70S8oETUAvLbcZ4azssn++BOHk0xKljwUTaFI8QQtwNVxTIu45BvXXfPiiiCN2KuRBS47VJjBA3Q8VaQryARTHjUMUOZJdtg6w63kU+PXoOlqY8i0C90cnZEeIeuKKA1zff7S+r1jaAN7Q8WWFWp4MQGXp71Ww4hKgwwBgIJlBhljw5gQmYGDUT4yKm4nTNERwo24LWnia7uLz6U7jccAYTI2dgUfIahPpGaJAt8RYswA/SynlQrxZAPnQGsHzlvIRzKKfyoJZUQlo8E0JYsGZ5EkII6RsuK5B3HrG7GQdJhG7lPAjJcdokRogbomItIR6Mc46rjeexrXA9mrrrHcYkBKZiddrLSApKc3J2hDwe3mYC7+qxPcY5mMkEtVu2W4HK/HzAggx9+x6qCt7Y8pXCbCN4fTOgKI+fuCSCRYTeWzUbHQ4WYqTCLBlwoiBhWux8TIqejRNVB5Bdtg0mS5tNDOcqztYew/m6XEyJmYv5iasR7BOqUcbE0zHGII4aDCE+GvKe41CrbFd+89pGWD7ZAWnWRAhjh9E8SQghLo7LCuTth6EW39d+SZKgW5UBISlGk7wIcVdUrCXEQ9V1VmFr4XrcbMpzOB6gC8TSlGeRHj0HAqNHDYl74G0mmP+yya5YCwA6VYVFsH8vMz8f6L+5rteCLVc5eEubddOvO8XZuiZAlh8/UUEACw+GEB0OFmntNcvCQuixXqIpnaDD7PglmBI9F8eq9uJI+S50ybYb3alcwYmqgzhTcxTTYxcgI2ElDPogjTImno4FB0J6ZjGUs1eg5F4EVPXeoKxAPnQaQlEFpEXTwQIDNMuTEEJI77gsQ952GGpJpe2ATgfd6gwICdHaJEaIG6NiLSEepkfuwv6yLThWuRuKar8KkDEB02PmIzN5Lfx1fVttSIjWeFePtVArCIB0X19lVQGE+47Jyt2vYUEGcM6BVpO1hUHt7U3A6hoBs+P2II+EMbAw472Nv6LDwcJDwO7PjxAX4SP5YUHiasyIXYjD5TtxrHIPzIrtDRBZteBoxW6cqj6EWXGLMSdhKfwkKpaR/scEBmnyaAhJsZD3HAdvbLEZV0urYFm/HeL8KRCHpmiTJCGEEIe4RYa8NRtqWbXtgF4H3er5EOKjtEmMEDfnUsXazs5O+Ptbd7fes2cPGhsbsWDBAkRF0S84IQ/DOceF+lzsKPoMbT3NDmNSjMOwOu0l2vmbuD9JBNPd9xGmMDDRtkDKVRXokaGcvw6ls8taoO22X5XbFywkyLrxV9TtFbMRoWB63RO9JiFa8JMCsCTlGcyMy0R2+XacqDpg19e8R+nGgbItyKnej7nxyzAzLhM+oq9GGRNPJkSFQff1ZVCOn4dy/rrNGO/ugbzzKNSiCkjzJoP5+miUJSGEkDu42QJ5SzbUihrbAb0OuqcXQIiN1CYxQjwA4/xJdkbpH62trfinf/onDBo0CD/72c/wq1/9Cp988gkAICQkBBs2bEBqaqrGWT6Yoii4ePEixo0bB1H07NVUnHO0trbCaDTS7uQuotJUii0FH6O49YbD8SCfEKxIfR7jIqbRvxlxa2ptI8x/2QTodXbFWsUiQ1Q5uCwDltv/KYp1A7DwEPvi7iNgRsO9wuyd/3z0/fXjEOJSWnqacKA0C6drjkDljvszG/RGzE9Yiamx86ET6CbFg9D50uNTS6sh780BN3XYjTFDAKTFMyAkUv9DQvqK5iXSX7jZAjnrANRK257j8NFDt2YhhOhwbRIjbseb5qW+1A1dYmXtu+++i9OnT0NVVbS1teHzzz+HKIoICQlBfX093n//fbz77rtap0mIy+m0mLC3ZDNyqw+Cc9VuXBREzI5bigWJq+Aj+WmQISEDTFHBu7qBbjOYouBJ7j4yQwBYVKi1OBt9uzDrRysIifcI9gnF2iHfwLyEFdhX+gXO1+XafbaYzK3YWrgehyt2YmHSU0iPmg1RcInTSeJBhKQY6F5aAfngKag3i23GuKkDls37IE4YAXHmBGo5QwghTsZ7zJCzDtptDsl8fSCtWQghKkyjzAjxHC5xdn306FEIgoC33noLp06dgsViwYsvvog33ngDM2bMwIULF7ROkRCXonIVp2sOY3fxRnRY2h3GDAsdi5WDXkCkf6yTsyNkoHHAbAHv6AJ6zI/1CszP93Z/2bB7vWYN/v2cJyHuKcwvEs8N+0dkJKzE3tLNyKs/bRfT2tOEzfn/hUPlO7AoaQ3GR06jzSpJv2K+PtAtmw1lUALkgyft5nvl/DWopVWQlsyCEBmqUZaEEOJdeHcPLF8eAK9psDnO/HwgrVlE8zEh/cQlirWNjY0ICQnByJEjsXXrVjDGMHnyZBiNRgQFBaGpqUnrFAlxGaVtBdhS8BHK24scjof6RmBV2osYETrB4x8jIN6Ft3dAuXADaO+0HnjU9zdjEGIiIKTE3y7OhgGBAfT7QchDRAXE4aUR/wuVphLsLt6EG00X7WIau2rx2Y0/Irt8GxYnr8WosEn0u0X6lTgsBUJcJOS9OXYb2PDGFlg+3QlpxngIE0eCCfTeI4SQgcK7e2DZvB+8rtHmOPP3tRZqI0I0yowQz+MSxdrg4GC0tLSgvb0dR48eBWMMkyZNQmFhIZqbmxEbSysDCWk3t2JX8ec4U3PE4bgk6JCRuBLz4pdDJ1JPTeIZuMrBS6ug5N2EWlQBbrZYe9D2VgxiDNBJgCSB6SRwBkBWIGXOoEeyCHlMcYZkvDr6TZS05mN3yUYUtly3i6ntqMBHV/8D8YEpWJy8DkNDxlDRlvQbFhgA6emFUC9ch5xzHpC/0lNZVSEfOwehqBzS4plgxkDtEiWEEA/Fu7qthdp624V0zN8P0rpFEMKCtUmMEA/lEsXa8ePHY+/evZg5cybMZjMmTZoEvV6PZ599FgAwd+5cbRMkREOKKiO36gD2lG5Gj9zlMGZ0eDpWDPo6Qn0jnJwdIQODd3RBuVoA9XI+eKvpwcGCAPjqwfU6CPdv/mWRATjeKIkQ0jfJxiH41pgf41bLVewp2YSytgK7mIr2Yvy/y/+GFONQLE5eh0HBwzXIlHgiJjCIE0eAJcdC3nXMrmCgVtbBvH47pLnpEEam0c0CQgjpJ7yjC5Yv9oM3NNscZwH+1kJtqFGjzAjxXC5RrP3e976HS5cuoaamBgEBAfj+97+PgIAAAEBycjK+/e1va5whIdooaLmGrIKPUNtR4XA80j8Wq9NewpCQ0U7OjJD+xzkHr6iBcikfakEZoNpvmmdDpwPz9wF8fAAGQKGiLCEDjTGGISGjMDh4JK41nceeks2oNpXZxRW33sSHl36FISGjsSTlGSQEpmqQLfFEQlgwdM8vhXLiEpQzV6xPW9xhtkDelwuhqALSgmlg/rRJJCGEPAne0QXL5n3gjS02x5khALp1i8BCgrRJjBAP5xLF2qSkJOzbtw/5+flITExEUJD1F/5Xv/oVZs6cCYPBoHGGhDhXS3cjthd9ikv1Jx2O+4i+WJj0NGbGLYIk6JycHSH9i3f3QL1aCCXvJnhz24ODdRKg1wEBfmC+Ps5JkBBihzGGkWETMTx0PPLqT2FPyWY0dNXYxeU3X0Z+82WMCp+EzKQ1iDEkapAt8TRMFCHNnAAhJQ7ynuN2T2CoBWWwVNVDWjQdQmq8RlkSQoh746ZOWDbtA29utTnOggKgW5sJFkxtZwgZKC5RrAUAvV6PIUOG4MqVK6ipqcHSpUupUEu8jkW14EjFThws2waL0uMwZkLUTCxP+RqCfKiBO3FfnHPw6nooeflQ80ts+w86wCJCIY4dCoQaYfnvLIAD3CLbBqkKuMptjz3kdQkhT0ZgAsZFTsPoiMk4V3sc+0u/RHN3g13clYazuNp4DmMjpiIzaQ0i/GM0yJZ4GiEuCroXVkA5fAbKVdu2HLyzC5YtByGOGQpx9kQwPd3cJoSQR8XbO6yF2hbbhRTMaIBu7SLqD04eS3N3Azos7TbHOOcwdZrQLhjsWhgF6AIR4hvuzBRdhssUaz/55BO89957aGtrA2MMS5cuxbPPPou5c+fizTff1Do9QgbctcYL2Fq4Ho1dtQ7HYw1JeCrtFaQYhzg5M0L6D+8xQ71RbF1FW9/84GBJgjg0GcLYoWBRYWCMgbeZwPx8wLt6APN9bRJUFRDsWycwPx8wP1qFS8hAEpmIydFzMD5yOk5XH8KBsi1oN9uuxOGc42LdCVyqP4X0qNlYmPSU156Ak/7DfPSQMmeADUqAsv8EeFe3zbiSdxNqWTWkJTMhxFBvf0IIeRjeZoJl0167pxZYcCB06zLBAgM0yoy4s+buBvzy5BvosNg/SamqHIJg32s+QBeEt6e+75Xniy5RrN22bRv+5V/+xeaY2WxGUVERioqKEBERgVdeeUWb5AgZYA1dNdhauB7XGy86HPfTBWBp8rOYEjMPAhOcmxwh/UStbYSalw/lRjFgsTwwloUFQxwzBMLwVLtWByzIAP0311mLtV/BOYfJZILBYH9Hlvn5gAXRUxqEOINO0GFG3CKkR89BTtV+ZJdvQ5elwyaGcxWnaw7jXN1xTI3JwPzEVQjSB2uTMPEYYloihJgIyPtzoRbZ9vrnLW2w/H03xCljIE4ZAybS+RQhhDjCW9utK2rb7ivUhgRZV9RSoZY8pg5LOzosbRCZDrr7WjkqTIUo2H42W1QLOixt6LC0U7FWK3/961/BGMNf//pX/PCHP0RdXR10Oh1+8pOf4F/+5V/w+eefU7GWeJwepRvZZdtwuGInFFW2G2eMYWpMBhYnr0OAjh4zIe6HW2SoN4uh5OWD19g/Fm1DECAMSYI4ZghYXNQDd/FmQQa74ivnHNxXgmA00g7ghLgAveiDeQnLMS1mPo5W7MKRil3oUe5b8ajKyKnch9M1RzAzdhHmJSyHv45urJDHxwL8IK3KgHr5FuQjZ4CvtsvhHMrJS1BLKqFbPBOMdi8nhBAbvLnNuplYu+1NVhYWDN2ahWAGf40yI55EJ+igF20X5ChQIIqiXayiPHiRjydziWJtUVERgoODMW3atLvHGGP4+te/jvfeew+VlZUaZkdI/+Kc41L9KWwv+gStPU0OY5KCBuOptJcRH5ji5OwIeXJqYwvUSzehXC8CeswPjGXBgRBHD4EwYhBYgJ+TMiSEOIuv5IdFyWswI24RDpfvxPHKvbCotvOCRenBofLtyK0+gDnxSzE7bgl8JZoPyONhjFmfzkiIhrznONTqeptxXtMA84YdkGZPtLbZoRt8hBBiLdRu2gtu6rQ5zsKDoVuziM7TyYAxKz2wKBb4iwbQJ/I9LlGsNRgMaGtrQ3Ozbf/Cy5cvo7W1FRER1F+KeIaajgpkFXyEwpZrDscNeiOWpz6HCZEzqOUBcStcVqDeKoWalw+10nHf5bsYg5CWaF1FmxAD5qA/ESHEswToArEs9WuYFb8YB8u24mR1tt1TJT1yF/aVfIHjlXuRkbACM2IXQSfqNcqYuDsWEgTp2cVQTl+BcvKSta/5HbIMOfsUhKIKSIum02oxQohXUxtbIG/eB97RZXOcRYRYC7X+vhplRjwVB9Alm9BuboVFNYNzjg6lHZF+tAHtHS5RrF24cCE+//xzfP3rX0dbm7XZ8He+8x0cOXIEjDHMmzdP4wwJeTJdcif2lX6J45V7wbn9BkgCEzEzbhEWJa2h1UTErfDmNiiXb0G9WmC3qcv9mCEAwpjBEEcNpgtjQrxUkD4YT6W9jLnxy7C/NAtnao/afS52WkzYUfQZjlbsxvzEVZgSMw/Sfb3NCHkUTBAgTR0DITkW8u7j4M22m96pJZWwfLwN4oJpEIckaZQlIYRoR21ohrx5P3jnfYXayFBroZY26SX9iAPolE3o6q6Dwm1v2puVblhUi10/W2/lEsXa73//+7h8+TKuXbu32nDPnj0AgLS0NHznO9/RKDNCnozKVZytPYZdxZ/DdN+u2HcMDhmFVYNeRHRAvJOzI+TxcEWFWlRuXUVbWvXgYMYgJMdZV9GmxIEJtGKcEAKE+IbjmaGvYV7Ccuwt/QKX6k+Cc24T02ZuQVbBRzhcsRMLk57GxKiZEJl9PzNCHkaIDofuheVQjp2DcvGGzRjv7oG84zDU4amQMqaA+dBqbkKId1DrmiB/sd9uwQWLDofu6QV2G/0S8ri65E6crM6+2wbS0VPEDAwSnefd5RLF2sDAQHz++efYunUrTpw4gZaWFkRERCA9PR0rV66ETkeVdeJ+ytuLkFXwEcraChyOB/uGYWXqCxgdnk790ohb4G0mKFduQb1cAN7R+cBY5u8HYfRgiKPSwIy0QR4hxLEI/xi8MPwNzE9Yib2lX+BKw1m7mObuBmy8+RccKt+OzKQ1GBMxhVoFkT5jOglSxhQIqfGQ9+bafY6p14tgqayFtHgmhPhojbIkhBDnUGsbrYXa7h6b4ywmArqn5lOhlvSLdnMrjlXuRk7VAbT3tIBzFczBOZwk6BDqG+lwzFu5RLF2y5Yt8PPzw9q1a7F27dq7xxVFwaeffnp3jBB30GFpx67iz3G65rDdKiHAOhHNTViOjIQVdrsgEuJquMrBSyuh5OVDLaoAHLynv0pIjIEwZgiEQQlgDnb0JIQQR2IMiXhl5HdR3l6E3cUbkd982S6mvrMaG66/j9jy7chMXoMRoRPoZifpMyE5DrqXVkI+eBJqfonNGG/rgGXTPogTR0CcPh5Mos8xQojnUWsarIXa+zYCFmIjIT01n54wIE+sqbseh8p34EzNEciqpdc4neCDIL0ROuYLia4dbbhEsfaHP/whYmJikJmZaXNcFEX8/ve/h16vp2ItcXkKV3Cy6iD2lGxGl9zhMGZE2ASsGvQiwvwinZwdIX3DO7pur6K9Bd5memAs8/WBMHIQxNFDwEKNTsqQEOKJEgJT8c0xP0Rhy3XsKdmE4tabdjFVplL895V3kRiUhsXJ6zAkZJQGmRJ3xvx8IC2bDXVQAuTsU8BXCxacQzl7FWpJFaQlMyFEhGqXKCGE9DO1qh6WL/cDZtsCmhAfBWn1fDA9PdVMHl+1qQzZ5dtxsf6kw7167vAR/RCkD4aPaN28TlEUZ6XoNjQp1nLO8Q//8A8oLy+/e6y+vh7z58+3ievu7obJZILBYHB2ioT0SVHrDWQVfIRqU5nD8XC/aKxOewnDQsc6OTNCHh1XOXh5DZS8m1ALy213znZAiI20rqIdkgQmucS9P0KIhxgUPBzfHvtT3GzOw56STahoL7aLKWsrwF/yfo1BwSOwJHkdko1DNMiUuCvGGMThqRDiIiHvyYFaUWMzzhuaYfl0F6Tp4yBMHAkm0CpuQoh7UyvrYMk6YF+oTYyBtHIeFWrJYytuvYns8m243nix1xjGGHSiD4z6EAToqE3ew2hydc0YwwsvvIA33njj7p8VRUFlZaXD+Dlz5jgzPUIeWWtPM3YUfYoLdbkOx/WiDxYkPoVZ8YtpV0PisnhXD9SrBVAu54M3tz04WK+DOHwQhDGDabURIWRAMcYwLHQshoaMweWGM9hb+gVqOyrs4gpbruH9i7/AsNBxWJKyDnGGZOcnS9wWCzJAWrsI6oVrkI9fAL66ukdRIB87B6G4AtLimWBBtICEEOKe1IoaWLKyAct9hdqkWGuhVkcLL0jfcM5xo+kSssu3OXwS6g5REDExchaGhY7F+xd/DoDBrNj2SlZUFSJs+9VaHtA+wRto9hu5YMECvP322zCZTHj33XcRGBiI11577e44YwySJCEhIQGzZ8/WKk1CHJJVC45V7sWB0iz0KN0OY8ZFTsPy1OcR7EMFLeJ6OOfgVfXWVbS3SgH5wY+esMgwiGOGQBiWQnfdCSFOxRjDmIjJGBU+CRfqcrG39As0ddXZxd1ouogbTRcxJmIyMpPWIiogToNsiTtiAoM4cSRYYizkPcfA65ttxtWKWpg/3mbdoGx4KvVKJoS4FbWsGpYt2YAs2xwXkuOshVrqz036QOEK8upPIbt8e69PFgPWhWtTYzIwO34pgn1C0dzdgABdEDosbVAU20KsqnII3P6zNUAX5LWrcBl3tAOSk73//vswGAx45ZVXtE7lsSmKgosXL2LcuHEQPbwxMuccra2tMBqNXnmyeqPpErYUfIyGrhqH4zEBCVid9jIGBQ93cmaEPBzvMUO9XgQl7yZ4Q8uDgyUJ4rAUa6uD6HCn5Pe4vH1eIsSbKKqM0zVHcKBsC1p7mhzGMCZgQuR0LEpao1mfeJqX3BOXFSi5F6Gcu+pwU01hcBKkBVPB/Hw1yI6QJ0PzkvdRS6pg2ZZttzBDGJQAadkcKtSSR2ZRLThbcxSHKnY4vGl+h7/OgJlxmZgZuwj+OtsnUpq7G9Bhabc5xjm/2/70/nkpQBeIEF/Xvg7ti77UDV2iWHtHe3s7Ojo6oN7uk6iqKtra2pCbm4tXX31V4+wejIq1nq+pux7bCjfgSsNZh+N+UgAyk9dgWuwCiMyz3wPE/ai1jVDzbkK5UQxY5AfGsrBgiGOHWlfR+vo4KcMn463zEiHezKJacLLqIA6Wb4PJ3OowRmAipsTMxfzE1U5/0oXmJfemVtRA3pPjcJNNFuAHadEMCCm0epu4F5qXvItaXAHL9sP2hdq0REjLZoN5eN2C9I9uuQu5VQdwtHJ3r+dbAGD0CcXc+GWYHDP37sZhj8Kb5iW3K9YWFxfjjTfeQFFRUa8x169fd2JGfUfFWs9lVnpwqHw7DpXvgOygbwpjDOlRc7Ak5RkE6o0aZEiIY9xsgZpfAiUvH7ym4cHBoghhSBLEMUPAYiPd7nfb2+YlQsg9PXIXjlftw+HyneiSOxzGSIIO02MXICNhJQz6IKfkRfOS++M9ZsiHTkO9VuhwXBw7DOLsidTrkbgNmpe8h1pYDsuOI7Z9uAEIQ5IhLZkFJgq9fCUhVu3mVhyr3IPcqgPoljt7jYv0j8W8hOUYHzkd0mPs0+NN81Jf6oYucWbx29/+FoWFjk+CAGDkyJFOzIYQK845LjecwfaiT9Dc7bjQlRCYiqfSXkFi0CAnZ0dI79SGZqh5+VCuFdrt9no/Fhxk7UU7chA90kkIcUs+kh/mJ67C9NgFOFK+C8cq99j1k5dVC45W7MbJ6mzMiluMuQnL4CcFaJQxcRfMRw/d4plQBiVAOXACvOu+DVEu3YBaVgVpySyXbxdECPEeyq1SyDuPArefWL5DGJZi3SxRoEIt6V1Tdz0Ol+/E6ZrDDher3ZEQmIqMxJUYGTYRAqP3VH9ziWLt+fPnIQgCPvzwQ2zcuBGdnZ14++238emnn2LDhg1YsWKF1ikSL1PXWYWsgo9wq/mKw3GDLghLU7+GSVGzaGIiLoHLCtT8Eqh5+VCreu8hBABgDEJaIsQxQ8ESosEEz76DSQjxDn5SABanrMPMuExkl29DbtUBu4sMs9KDg2VbkVt1AHMSlmJWbCZ8JD+NMibuQhycBCEmAvK+XKgllTZjvLkNls92QZw6FuKU0VQEIYRoSskvhbzLQaF2eCqkzJl03k96Vd1RjkPl23Gh7gQ4V3uNGxwyChkJK5EWPMLjV8JqySXaIIwaNQpGoxE5OTn47LPP8Ic//AG5ubmQZRmTJ09GTEwMdu7cqXWaD0RtEDxDt9yF/WVZOFaxBypX7MYZEzAjdiEyk9fQihziEnhzG5TL+VCvFtit+LkfCwyAMHoIxFFpYAZ/J2XoHJ48LxFCHk9LTxMOlm3BqerDDj/TAcCgNyIjYQWmxS6A7jEe3XsQmpc8D+ccal4+5KNnHfZ/Z9Hh0C2ZBRbinFYbhPQVzUueTblZDHnXMbvNEcWRaRAXTqdCLXGopDUf2eXbcK3xQq8xjDGMCpuEjMSVSAhM7dfv703zktu1QQgLC0NjYyOqqqowbtw4NDU14fLly4iOjobFYkFVVZXWKRIPxznH+boc7Cj6FO29NM1ODR6Gpwa9jBhDopOzI8QWV1SoheVQ825CLat+cDBjEJLjII4dApYcTydphBCvEewTijWD/wfmJazAvpIvcK4ux26liMncim2FG3CkYhcWJK7G5Og5EAWXOD0mLogxZt2AMzEGlt3H7PrB85oGmDdshzR7EoQxQzz+opMQ4jqUa4WQ9+bYF2rHDIGYMZWuAYgNzjluNufhYNk2FLfe6DVOFERMiJyJeQnLEekf68QMiUucjU6fPh1ZWVl4/fXXsXXrVoSGhuKll16CKIqQZRmxsfSmIAOn0lSKrIK/oaQ13+G40ScUK1Kfx9iIqXTSTTTF20xQLt+CeuUWeEfXA2NZgB+EUYMhjh4MFmRwUoaEEOJ6Qn0j8LVh38K8hBXYW/oF8upP2cW09jThi1t/xeGKnViU9DTGR06nNkekVywkCLpnl0A5nQflZJ5tccQiQz54EkJRBaRF08ECqM0GIWRgKVduQd5/wr5QO3YYxHmTqVBL7lK4gsv1p5Fdvh1VptJe4/SiD6bEZGBO/FIE+4Q6MUNyh0sUa998800UFxcjLCwMgiDgtddewzvvvHN3/LXXXtMwO+KpOi0m7C7ZhJPV2Q57soiChDnxSzE/YSX1syOa4SoHL6mAcinf2ifvIZ1rhMQYCGOHQkhNoF1eCSHkK6IC4vDSiH9GpakEe0o24XrjRbuYxq5afHbjQ2SXb0dm0hqMDk+nG7XEISYKkKaNg5ASD3n3MfDmNptxtbgClo+3QlwwDeLgJI2yJIR4OiUvH/KBE3bHxQnDIc6hzzBiZVEtOFtzFIcqdqCpq/f9Tfx0AZgVm4kZcYsQoAt0Yobkfi7Rs/aO5uZmhISEAABycnJw48YNjB8/HhMmTNA4s4ejnrXuQ+UqTlUfwu6Sjei0mBzGDAsdi1WDXkSEf4yTsyPEips6oVwpgHo5H7y944GxzM8Hwsg0iKOHeG2fPHeflwghzlfSmo/dJZtQ2HKt15g4QzKWpDyDoSFj+jy30LzkPbjZAuXYeSiXHD9KKo5Mgzg3HcxH7+TMCLFF85JnUS7egJxt/7SIOHEkxNkT6d+YoFvuwonqgzhasavXdo+A9WniOfFLMSVmHnxEXydm6F3zktv1rL1D/cqOhePGjUNMTAxSU/u3eTHxbiWt+cgq+AiVphKH46F+kVg16AWMCJ3g8RMFcT1c5eDlNVDybkItLLfbxfV+QlwkhDFDIQxOApM8+yYRIYT0t2TjEPzj2B8jv/kK9pRsQllbgV1MpakE/+/yvyHFOBSLk9dhUPBwDTIlro7pdZDmT4GQGg95X45dqyLlagHU8hpIi2dCiI/SKEtCiCdRLlyHfOi03XExfTTEmePpWtbLtZtbcbxyL3Kq9qNb7uw1LsI/BvMSVmBC5HRI/bzRKnkyLlGstVgs+OlPf4pDhw7h1CnrnaErV67glVdewfLly/Gv//qv0OvpTjR5fG3mFuwq+jvO1h5zOK4T9JiftApz4pf1+27QhDwM7+qGerUQSl4+eEvbg4P1OogjBkEYMwRCeIhzEiSEEA82JGQUBgePxLWm89hTshnVpjK7mOLWm/jw0q8wOGQUlqY82+87IRPPIKTEQffSSsgHTkK9ZdsLkLeZYNm0F+KkkRCnjaObrISQx6acvQr56Fm74+LUMdb5hQq1Xqupux5HynfiVM1hyKql17iEwFTMS1iBUeGTqEe/i3KJYu2f/vQnbNmyBYwxVFZWIi4uDhUVFeCcY8eOHUhJScG3v/1trdMkbkhRZRyv2od9JV+gR+l2GDMmYgpWpD6PEN9wJ2dHvBnnHLyyDsrlfKj5pYCiPDCeRYdDHDMEwpBkMD3dUCCEkP7EGMPIsIkYHjoeefWnsbd0M+o7q+3ibjVfwe+br2Bk2EQsTl6LGEOiBtkSV8b8fCEtnwP1epH18WTzVy6WOYdy5grUkipIS2bSTVdCSJ/Jpy9DOX7e7rg4bRykaWM1yIi4guqOchwq34ELdbkO9+O5Y3DIKMxLWIHBwSOpqO/iXKJYu23bNjDG8Pvf/x5xcXEAgDVr1iA0NBT/+I//iG3btlGxlvRZfvMVbCn4GHWdlQ7HowLisWrQixgSMsrJmRFvxrt7oF4vsq6ibWx5cLBOgjgsBcLoIRCi6WYCIYQMNIEJGBc5FaMj0nG+9jj2l2ahqbveLu5q4zlcazqPsRFTkJm0FpKgQ4el3SaGcw5TpwntgsHugihAF0g3iT0YY8z6FExcJOS9OVAram3GeX0TLJ/shDRzPITxI2indkLII5FPXoKSe9HuuDhzAqTJo52fENFcSWs+ssu341qjfQH/DsYYRoVNQkbiSnoyyI24RLG2trYWQUFBWLRokc3xefPmwWg0orrafmUDIb1p7m7A9qJPkFdv38MHAHwkP2QmrcGM2IUQBZf4FSAejnMOXtsI9dJNKDdLAFl+YDwLD4Y4ZiiE4am0GQkhhGhAZCLSo+dgfOR0nKo5jIOlW9BmbrGJ4ZzjYt1JnKvNQUtPI0Qm2j1KqKocgoNCXIAuCG9PfZ8Kth6OGQMhrc2Eev4a5JwLtk/RKArkI2chFFVAypwBFmTQLlFCiEvjnEM5cQnKyUt2Y9LsSRAnjdQgK6IVzjluNuchu3wbilocb2wJAAITMTFqJuYlLEekf6wTMyT9wSUqVSEhIairq8PVq1cxcuS9ieb8+fNobW1FRESEhtkRd2FRLThSvhMHy7bCopodxkyKmoWlqV9DkD7YuckRr8TNFqg3iq2raOsaHxwsiRAGJ0EcOxQsJoIeSyGEEBcgCTrMiF2I9KjZyK3aj+zy7ei0mGxiFFWGydwKMAEGyQB/XRDE20VbhakQBdsCrkW1oMPShg5LOxVrvQATGMRJI8GSYiDvPgbe0GIzrpbXwLx+O6SMKRCGpdDnPyHEBuccSs4FKKcv241Jc9IhThyhQVZECypXkVd/Ctnl21FlKu01Tif6YGpMBubELUGwb5gTMyT9ySWKtQsWLMAnn3yC559/HjNmzEBISAhqa2tx8uRJMMawYMECrVMkLoxzjmtN57G1cAOauuocxsQZkvFU2stINg5xcnbEG6n1TVDzbkG5Xmjbq84BFhJk7UU7Ig3Mz8dJGRJCCOkLveiDuQnLMTVmPo5W7saRil3okbtsYhiALqUT3UoXDLogBOqNEAGIov1GUory4M8G4nmEiFDonl8OJfcClHPXAM7vDfaYIe8+BqGwHNKCqWC+dD5ACLldqD12DsrZq3ZjUsYUiOOGaZAVcTaLasHZmqM4XLETjV21vcb56QIwKzYTM+IWIUAX6MQMyUBwiWLtd77zHZw/fx7Xr19HdnY2GGPgt09ghg0bhu9973saZ0hcVX1nNbYWrseNJvtHQgDAX2fAkuRnMCVmHu1ySAYUl2Wo+aVQ8/KhVjm+aXCXIEBIS4Q4ZghYQjStoiGEEDfhK/lhUdLTmBm7CIcrduBY5T6YlR6bGA6OdksrTJZ2BEiBCBSMEJl9wZZ4HyaJkGZPgpASD3nvcfC2DptxNb8Elqo6SItmQEimR1YJ8WaccyhHzkA5f91uTFowDeIYWoTk6brlLpyoPohjFbvtWjF9ldEnFHPil2JK9Fz4SH7OS5AMKJco1gYGBuLzzz/Hli1bcPLkSbS0tMBoNGLatGlYvXo19Hrq2Uhs9chdOFi+FUcqdkNR7ft/MiZgWsx8LE5eC38d9QAjA4c3tUK5nA/1aiF4d88DY1mQAcLowRBHDQYLoA9SQghxV/46A5amfA0z4xYj69bfsKP4M7sYDhXtlhaY5Fb4iv4I0BngK/lrkC1xNUJCNHQvroScfQrq9SKbMW7qhOXL/RDHDYM4ayKYziUu1wghTsRVDuXwaSgX7+tHyhikhdMgjhqsTWLEKUzmNhyr3IPcqgPokjt6jQv3i0ZG4kqMj5wOnaBzYobEGVzm01+v1+OZZ57BM888o3UqxIVxznGp/iS2F32K1p4mhzHJxiF4Ku0VxBmSnJwd8RZcUaAWlltX0ZY9ZANExiCkxltX0SbF0Y7PhBDiQYL0wZifuArHKvdAVi3oVrocxnUrnehWOiEwAT6CHz3tQ8B89NAtmQVlUAKUAyftbvgqF29ALauGtGQWhCjqOUiIt+Aqh5J9Ekpevu0AY5AyZ0AcMUibxMiAa+qux5HynThdc6TXPXgAID4wBRkJKzEqfBKdT3gwzYq1u3btgp+fH+bNm4ddu3Y9NH7p0qVOyIq4smpTGbIKP+p1x8MgfTCWpT6PCZHT6bFyMiB4azuUKwVQL98C73R8QX4HC/CHMDrNuoqWdngmhBCPJjABQfoQBLMwtJlb0CmbHMapXEWH3A7OVXx09T8wN2EZxkdOp6eAvJg4JBlCbCTkvTlQS6tsxnhTKyyf7YI4dSzEyaPABLooJ8STcZVDOXACypVbtgOMQVo8E+LwVG0SIwOqpqMC2eXbcaEuF5yrvcalBY9ERuJKDA4eSfUOL6BZsfZ73/seYmJiMG/ePHzve9974JuNMfZExdo//vGPOHHiBNavX99rTHNzM371q1/h6NGjAIDFixfjrbfegr8/Pa6mtS65A3tKNiO36oDDyUtgImbHL8HCxNXUo4X0O66q4MWVUC7dtF5EfXVDEAeEpFgIY4ZASE0AE+miihBCvIkk6BDqG4FA1Yh2cys6LY6LtgBQ21mJrIKPsK3oE4wKm4T06NkYEjKaVsl4IWbwh/T0AqiXbkI+eg6Qv9LiS1Wh5F4AL6mElDkDLCRIu0QJIQOGqxzyvhyo1wptBxiDtGw2xCHJmuRFBk5p2y0cLNuGa43nHxg3KnwSMhJWIjGIVlV7E03bIPCvFD34AwogDxp7mL/97W947733kJ6e/sC4f/7nf0ZPTw/+9re/oa2tDT/+8Y/xi1/8Au+8885jf2/yZFSu4mztMewq+jtMljaHMYNDRuGptJcR6U+bMJD+xds77q2iNfXeKwgAmJ8PhJGDIY4eTBdRhBBCoBP01qKtFAwz70aHbIJZ6XYYq6gyLtWfxKX6kzD6hGJi1EykR81GhH+Mk7MmWmKMQRw3DCwxBvKe4+A1DTbjalUdzBt2QJozCcLowbSqihAPwlUV8p4cqDdse1hDEKyF2sHU3s9TcM5xszkP2eXben1iGLAuSJsYNQNz45cjKiDOiRkSV6FZsfbGjRsO/7+/1NbW4sc//jHOnTuHlJSUB8ZeuHABp0+fxq5duzBokPVuxS9/+Uu8+uqr+N73voeoqKh+z488WFlbIbIKPkJ5e6HD8RDfcKwc9AJGhU2ik1XSb7jKwcuqoeTdhFpY/vBVtPFREEYPgTA4CUyinb4JIYTYEpiAACkQAbpAyKoFHbIJJnMr5F4ec2ztaUJ22TZkl21DinEo0qPnYGz4ZHpyyIsIoUbonl0C5dQlKKcu256LWCyQD5yAUFQOaeF02qyUEA/AFRXy7mNQ80tsBwQBuhVzIQxK0CQv0r9UriKv/jQOlW9Hpamk1zid6IOp0fMwJ34pgn2pX7k3c5kNxvrb1atXYTQasW3bNnzwwQeorKzsNfbs2bOIiIi4W6gFgMmTJ4MxhnPnzlG/XCdqN7did/FGnK457HBcEnTISFiBeQkroBP1zk2OeCze2Q31agGUvHzw1vYHB/voIY4YZG11EBbslPwIIYS4P0nQwagPgZ/oj3ZLK4aFjkVpewEUVXYYX9x6E8WtN7Gl4COMCZ+M9Og5SDUOo5vUXoCJAqTp4yEkx1tX2bbYPmGmFlXAsn4bpAXTIKQlapQlIeRJcUWBvOsY1FultgOSaC3UpsRrkxjpNxbVgnO1x3C4fCcaump6jfPTBWBm7CLMjMtEgC7QiRkSV6VZsfbnP//5I8cyxvCzn/2sT6+fkZGBjIyMR4qtra1FTIzto2Z6vR7BwcGorn7ITu+kXyhcwYmqA9hTshndcqfDmFHhk7By0AsI9Y1wcnbEE3HOwStroeTlQ71VBijKA+NZdDjEMUMgDE0B03nsfS5CCCGPyaJa7I4pqgoRgl2cTtDdPae5UJeL0zVHel1pY1Z6cLb2GM7WHkOoXyTSo2ZjUtQshPiGD8SPQVyIEBsB3QvLoRw9a7czPO/shmXbIYijBkOcmw6m12mUJSHkcXBZgbzziPVpvq+SROhWzoOQTI++u7MeuQsnqg/iaMVutJlbeo0L8gnBnPilmBo9j56iITY0qzj8/e9/f6SVAZzzxyrW9kVXVxf0evtVmj4+Pujp6enTa3HOn6jHrju48zP2189Z2HIdWwo/Rk1HucPxcL9orB70EoaGjrn7/Ql5XLy7B+r1Iqh5+eBNrQ8O1kkQhqVCGD0YQtS9x1DoPeh6+nteIoSQR+UvGRCgC0KHpQ2Kcq9gy2HtQ8i4gPvPeAN0QfCXDPCTAjA9diGmxy5ElakMZ2uP4nxdDjosjp/yaOqqw96Szdhb8gUGh4xEetRsjAqbRE8beTKdBHH+VLCUeMj7c4FO297HypVbUMuqIS6ZCSE2UqMkibug8yXXwGUFyo7DUIvve/pXEiGtygBLjKF/IzdlMrfheNVe5FbtR1cvi9AAa41jXsJyjI+cAZ1gvdnmrf/m3jQv9eVn1KxY+7ANv5zJ19cXZrPZ7nhPTw/8/f379FptbW0QBM/exZdzjs5O68TzJI/itZmbsa/yC1xtPutwXC/4YHbMMkyJyIAkSGhtfUhhjZDecA5W3wzhejHEwoqHrqLloUFQhqdCTUsA7qxUofefS+uveYkQQvpKgA7fGfF/0CmbbI5zztHV3QU/Xz+7eclfMkDo0aG1595nSwCMmBO+AjNCl+BW22VcbDyBW22Xez2xv9FwCTcaLsFH9MOokHSMD5uGWP9kmgM9VVggsGoupGMXIJRW2Y41t0L+bBeUsUOgTBgOiJ59LUIeH50vuQBZgbT/BISKOtvjkgTLgingRn+67nBDreYm5Nbuw/nGHMgOnrS5I9o/EbOiFmNY8DgITEBne+8FXW/hTfOSqjres8ARzYq169ev1+pb24mOjsaBAwdsjpnNZrS0tPR5c7GgoCCIomdvNHTnosFoND7WL5NFteBY5W4cLNsKs9Lj8O9rfOR0LEt5DkafkCfOl3gvbrZAvVFsXUVb33RvwNHvqChCGJIEYcwQsJgIj/+g8DRPOi8RQsiTMMJod4xzjtbW1seal8JC5mJq0ly0m1twrjYHZ2qPoK6zymGsDDMuNufgYnMOovzjkB49BxMiZyBQb58TcXNGgK9dBPVqIZQjZwCzbUFAvFwAVtMEaclMMOqrTxyg8yVtcYsMedsh8OpG2+sRvQ7S6gz4xdHG5u6mpqMChyt24EJdLlSuAgwO6xuDgkcgI2EFBgePot+9+3jTvKQ8ZNHYV7lU40WTyYQrV66gvb0dwcHBGDVqFPz8Br5vR3p6Ov7v//2/KC0tRVJSEgDg1KlTAIAJEyb06bUYYx7/BgPu/Zx9/VlvNF3CloKPe22uHWtIwuq0l5BqHNYfaRIvpdY1Qc3Lh3KjyO5C5n4sJAjimKEQRg4C8/VxUoZkIDzuvEQIIQPlSeelIJ8QzEtcjrkJy1DWXogzNUdwof4EeuQuh/G1nZXYUfQpdhV/jmGhYzE5eg6Gh46DKLjUKT95AowxCKMHQ0yMhrznONRK29V5vL4Jlk93Qpo5AcK44WACfSYSW3S+pA1utkDZchC8otZ2QK+D7ukF1MbEzZS2FeBQ+XZcaXD8lPAdo8InYV7CCiQFpTkpM/fkLfNSX34+lzlze//99/Ff//Vf6O6+14fJz88P3/rWt/DNb36zX7+XoihoampCYGAgfH19MXbsWEyYMAHf/e538fOf/xydnZ342c9+htWrV/d5ZS1xrKGrFtsKN+Ba43mH435SABanrMPUmAyIzLNXJpOBwWUZ6s0SqHn5UKvrHxwsCBDSEiGOHQIWH+3xHwqEEELcG2MMSUFpSApKw6pBL+Jy4xmcqTmKgparDtskqFzBtcbzuNZ4HgZdEMZHzcDkqNmIMSRqkD0ZCMwYCGndYqjnrkLOuQB89dFKWYF8+AyEogpImTPAAgO0S5QQAm62QM46YHdzhfnoIa1ZCCGaNox0B5xz5DdfRnb5dhS2XOs1TmAiJkROx7yEFYgKoI3iyONxiWLtf/7nf+L999+3O97Z2Ynf/e530Ov1eOWVV/rt+1VXV2P+/Pn49a9/jaeffhqMMbz//vv4xS9+gZdffhk+Pj5YvHgx3nrrrX77nt7KrPQgu2wbDlfsdNi7hTGGydFzsST5GRj0QRpkSNyd2tRqLdBeKwTvfvCGgMxogDB6CMSRaWABtNsmIYQQ96MT9ZgQOQMTImegqbseZ2uP4WzNUTR1O75RabK04VjFbhyr2I2EwFRMip6N8RHT4K8zODlz0t+YwCCmjwJLioW8+xh4Y4vNuFpWDcvH2yDOnwpxWIo2SRLi5XiPGfKXB+wWkzBfH2uh9iubGBPXpHIVlxvOILtsGypNJb3G6QQ9psTMw+z4JQj1jXBegsQjMe4CW67NnTsXtbW1WLp0Kb7zne8gKioKdXV1+OCDD5CVlYXY2FhkZ2drneYDKYqCixcvYty4cV7Rs/ZhPdg457jccBrbij5BS3ejw5ikoDSsTnsZCYGpA5ku8UBcUaAWlEG9lA+1wnFLjbsYg5AaD3HMULCkWHoc8P9n777jm7rv/fG/zjmSbHnjPVlmmGUM2IRtMARIGEmz29KkzWjube5tkzTJ7fo2Hbm9bZOUX9skNGlWm6ZNswMJhBHAZmMDZhuzsTG28d6WdM7n94ewsSzJYMDSkfx6Ph4J+JyPpbeM/bH00ue8P37qenpDEhH1BU/OS5rQcLq+CLvLc3GgKh9Wtec3Lw2yEWOjJyEzbhZGDBgHWeKGVL5O2FSoW/dC3et6tZecNgSGnJvY8qmf4/MlzxJt7bB+vAGivMrhuGQOgOHO+ZBjI71UGV0Nq2bF3oqt2FTyuds2joD9KuHpSfMxI3E+F6Bdg/40L/UmN9RFWJuRkQFJklBQUOBQsKZpmDRpEoQQKCws9F6BV4Fh7WXlzaX47OQ7OF57yOXnh5jCsWjIvZgUN5MvDqhXRF0j1IPHoR0+AdHiul9fBykkyN7TbexwXv7XD/SnX/JE5Bu8NS+12Vqx/+Iu7C7fjLMNx684PjwgEplxM5EVPwvR5ngPVEh9STt7Aba12yCamp3OSSHBMCyYDnlQghcqIz3g8yXPEa3tsH60HqLSceGSFBRoD2pjuJG2XrXbWrHjwkbknV+DhvZat+PCAgZgVtItmJqQgwADr9q8Vv1pXupNbqiLNgiTJk3Crl270NTUhPDwyzvX1tTUwGKxIDs724vV9W+1bVVotjY6HBNCoKmlCY1yiMMPU5vahvzyPOyr3AZNOO9yJ0kyZiQtwPxBd8BsCOrz2sk/CE2DOFUK9UAxtLNlwBXeX5IHJ0FOHwF5aDIkmW8GEBFR/xJoMOOmhNm4KWE2KlvKUFCRh4KKrW5fcNa31+Crc5/hq3OfYUh4GrLiZ2F89GS+8PRR8qAEGO9fAtum3dCOnnI4J5qaYf1oHZSJo6DMmAjJoIuXgkR+R7S02YPaizUOx6UgMwx3z4ccFeGdwqhHzdZGbDm/FtvK1qHV6vyGV4doczzmpCzGxLgZMMpGD1ZI/YkuVtYePnwYjz76KOLi4vDQQw8hNjYWJSUlePPNN1FWVobf/e53iI29vDtienq6F6t1zR9X1ta2VeFXO/8LzdYGp3OaJiBfupxcwN6bttXWDAkSEoIHwtBt1+HUiNH42rAHEB+c7InSyQ+Ixmaoh45DO3jC5eqQrqSgQMhjhkEZNwJSRKiHKiQ96U/vyBKRb9DTvKQKFcdrD2F3eS4OV++Bqtl6HG9SAjA+5iZkxs3C0PA0r9dP10Y9dhrqhp0Q7Ranc1JUBAwLZ7BfZj+jp3nJX4nmVlg/WgdRVedwXAoJgvGu+ZAiw11/InlNbVsVcktXY9eFTbBqzvNlh6SQwcgZuBTjorN4hfAN1J/mJZ9rgzBq1KirHitJEo4ccb/znrf4Y1hb2ngav9r5GBTJ6PSOkappUGQZVs2KBkstrJoFAgIQAgnBA2FS7P2wwgMisTR1GdKjJ/v9Dx5dP6EJiLNlUA8WQztZcuVVtMlxkMePhJw6EJLBP37u6Nr0p1/yROQb9DovNVsbsa9yO/LL83rcKKVDtDkemfEzkRk7ExGBDPZ8jWhshm3tNmjnLjiflGUo0zKgZI5lT/9+Qq/zkr8Qza2wfrjOabM/KSQYxrvnQxrAfqZ6UtF8HptLP8eeCtdXBndIjRiFnJSlGDFgHH9u+kB/mpd8rg1Cb/JiHWTL/Y5RNnaGrx2swoomW31niwRZkqEJzR7YAlBkA2YnL0LOwKUIUAI9XjP5FtHcCvXwCWgHiyHqm3ocKwWYII9JhTxuBC8hIiIi6qVgYyhmJC3AjKQFON90FgXledhTuRUtVte/f6tay/Hl6Q+w9syHGB4xFpPjszEmOpOXfvoIKTQYhjtuhra/CLYtewBbl0BC06Bu3QtxqhSGhTN4dRLRdRBNLbB+sA6itt7huBQWDONdC/jzpSPnGk5iY8lKHK7e02O+NCZqEnIGLsGgsOEerI7IThdh7VdffeXtEqgXmqwNqG+v6Qxmu0uNGIVvjnqMm1RQj4QQEKUV9l60x88CmtbjeCkhBkr6CMgjBkMy6mLqIiIi8mlJIYOQNOxbWDT0Phyp3of8ilwU1RyAEM6/k4UQKK49iOLagzAbgpEROxWT47ORHDLE71fC+DpJlqBMGAVpYAJsa7Y6bXiklVXC8o9VMMzOgjxmGP89iXpJNDbbg9o6x/aBUngIjHcvgBQW4qXKqIMQAsfrDmHjuVU4UXfY7ThJkjExdhrmpCxhC0fyKl0kHklJSd4uga6CAFDdWoE2tQVCCKcncopkQIDRjDuHP8igltwSbe3QDp+EeqDY6Z1nJyYjlLSh9g3DYiM9UyAREVE/Y5CNSI+ZjPSYyWhor8Weym3IL89FZUuZy/GttmbsKNuAHWUbEB+cjKz4bEyMnY5QE3sx6pkcFQHj12+BuvMA1N0HHdtNWaywrdsO+WQJDPOmQgrmBnNEV0M0NMH6wVqnqwOliDB764PQYC9VRgCgCQ2HqvKxsWQVShtPux1nlE2YnDAb2cm3IjIwxoMVErmmi7D2xz/+cY/nJUnCb37zGw9VQ+5Y1Da0qS1OxyVICDVFIEAJRLva6oXKSO+EEBAXqqAeOAat+IzjJXguSDGR9lW0o4ZCMvEySyIiIk8JCxiAOSmLMTt5Ec41nkB+eR72XdyBdpvr53jlzaVYdfJdfHHqPYyKzEBWfDZGRY6HIuviZQZ1IykKDNMnQB6SZF9lW9/ocF47WQLrhSoYbp4KOTXFS1US+QZR12jvUdvQLagdEGbfTIxBrdfYNCv2VGzDppJVqGotdzvObAjG9MSbMSNpAUJM7ClM+qGLZ1GffPKJ28ttOlZwMqz1Plf/RmZDMCICIqFIBljUdi9URXomLFZoR0/ZV9FerOl5sEGBMnII5HEjICVE8xI8IiIiL5IkCYPChmNQ2HAsTV2Gg1UFyC/PdXv5qCZUHK7eg8PVexBiCsek2OnIis/mZaQ6JSfGwvitJVBz86EePO5wTrS0wvrZRijjRkDJzuQb50QuiNoGe+uDpmaH41JUBIx33gwpJMhLlfVv7bZW7CzfhLzSNahvd//6M8wUgVnJt2BKwlwEGnglAemPLsLa6dOnOwQzqqqisbERRUVFiI2NxcKFC71YHXUwyQEIN0WiyVoPRTYgLCASgdw8jFzQKquhHSiGWnQasFh7HCtFhttX0Y5OhRQY0ONYIiIi8jyTEoBJcdMxKW46atouoqA8DwUVW1DTdtHl+CZLPXJLVyO3dDVSQociKz4bE2KnwmzgKjM9kUxGGG6eBnloCmzrt0O0tDmcVw8WQyu5AMPCGZATY71UJZH+iJp6+4raJserTqXoCBjvnM82Il7QbG3E1vNrsbVsHVqtzW7HRZvjMTtlESbFzeRGmaRrughr33jjDZfHjxw5gnvuuQepqakerojcCTWFI9QUDlVVoSiKt8shHRFWG7TiM/ZVtBdcv3jrJMuQhw+CMn4EpKQ4rqIlIiLyEZGBMZg/+E7MG/Q1nKovwu7yXBy8uBtWzeJyfEnjKZQ0nsLKk//A2OhJyIrLxvABYyFLsocrJ3fk1BQY45fCtmEHtJMlDudEXSOs//4SyuRxUKaMh6Tw3436N626DrYP10E0O7aGkWIG2IPaIC5m8qS6tmrknl+DnRc2wtrDlb6JIYOQk7IU6TGT+fuHfIIuwlp3Ro8ejcGDB+ONN97AnXfe6e1yiMgFrboO2oFiaEdOQrS7fqHWQQoPgZI+0r6Klu84ExER+SxZkjEsYjSGRYxG27Bvo/DiDuSX5+Fsw3GX422aFYWVO1FYuRMRAVHIjJuJzPhZiDbHebhyckUKNsOwdA60wydg25QPWLtcGSUE1F0HoJ05b19lGxXhtTqJvEmrqrUHtd1WoUuxkfag1syrBD2lsqUMm0o+x97KrVA19/uhDI1IQ07KUowckM4FQuRTdBHWVldXO3wshIDFYkFBQQFOnz4Ng0EXZRLRJcKmQjtxDtqBY9BKK3oeLEmQU1OgpI+ANDARksxfkkRERP4k0GDGlIQcTEnIQWVLGfLL87CnYgsaLHUux9e1V2PDuU+x4dynGBqRhqy4WUiPnowA9g30KkmSoIwdDjk5HrYvt0Irq3Q4LyqqYX33cxhmZUJOH8nndNSvaJU1sH20DqLVcfWmFB8N4x3z2M7NQ0oaT2HjuZU4VF0AIYTbcaOjJiInZQkGh4/wYHVEN44uUtAZM2b0eH7UqFEeqoRcsWrOPUdVTYMC+YrjyL+IukaoB4qhHT4B0drW41gpJBjyuGFQxg7nTqhERET9RGxQIhYNvQ8Lh9yN4pqD2F2+GUdq9rpd+XSqrgin6orw6Ym/Iz3mJkyOz8bgsBFcAeVFUkQoDPcsgJp/COqO/YCmXT5pU2HbuAvyyRIY5k/jczzqF7SKatg+Wg/R5hjUygkxMNwxD1KAyUuV9Q9CCByvO4xNJatwvPaQ23GSJGNC7DTMSVmMhOAUD1ZIdOPpIqzt6R2R2NhY/PznP/dgNdQh2BiKYGMYmq0NUFXHIFbTBGTh/CQ62BiGYGOop0okDxCaBu1kib3VwdmyngdLEuRBifZVtEOTIcnsB0RERNQfKZKCUVEZGBWVgWZrI/ZWbkd+eS7Kms66HN+utiG/PBf55bmINscjM34mMuNmISIg0sOVEwBIsgzDTemQByfB9uVWiOo6h/Pa2TJY31kFZe4UKCMHe6VGIk/QyqvsQW23dm9yYiwMX5vLoLYPaULDoaoCbCpZhZLGU27HGWQjboqfjeyURYgMjPFghUR9RxI9JaUesnv3bqdjsiwjLCwMw4YNg+wDgY+qqigsLERGRoZfbbxV21aFZmujwzEhBJqamhASEuK06iHYGIoBgdGeLJH6iGhshnrwOLRDx512Ou1OCjJDHjsMyrjhkMIZ1pPnCSFQX1+P8PBwrsYiIl3gvOTa+aazyC/Pxd7KbWixNvU4VpJkjBgwFllxszAmOpM7d3uJsNmgbt0Lde9Rl+flUUNhmDOZl4H7AM5LvaOVVcL68QbA4rhwSU6Og+H2uZBMnJP6gk2zYm/ldmwqWYWLLRfcjgs0BGF64s2YkbQAoaZwD1ZIN1J/mpd6kxvqIqz1B/4a1rrSn36Y+huhCYizZVAPHIN2qhS4wvQgp8RDTh8JeVgKJD//vid947xERHrDealnVs2Ko9X7sLs8F8dqD0AIrcfxZmMwJsZMQ2b8LCSHDOHX1Au0s2Wwrd3m8k18KTQYhoXTIackeKEyulqcl66edr4C1k++cg5qBybAsHQOg9o+0G5rxa7yzcgtXY369hq340JN4ZiVfCumJsxFIHud+7z+NC/1Jjf0ehuEpqYmrFmzBoWFhaiqqoKqqoiKikJGRgaWLFmCkJAQb5dI5PdEcyvUwyegHSyGqL/CKpfAAMijUyGnj4AcyXcwiYiIqPeMshHpMZORHjMZ9e212FOxFfkVuW5XUbVam7GtbD22la1HQnAKsuKzMTF2OkJMYR6uvP+SByXCeP9S2L7aBe3YaYdzorEZ1g/WQZk0Gsr0iZAMfBOffJdWWg7rJxsBa7egdlAiDLfNgcQN0G+oZmsjtp1fhy1la9FqbXY7Lsoch9nJi5AZP4tXWpDf8+rK2vXr1+OnP/0pGhsbXZ4PCQnBc889hwULFni4st7jylryNUIIiNJyqPuLoZ0457h5hAtyYqw9oB0xiE9QSHc4LxGR3nBe6j0hBM42HEd+RR4KK3egXe15M1NZUjA6agKy4mchbcB4KDKfn3iKWnQatq92At36eAKAFBUBwy0zIcey37DecF66Mu3sBVg/2wjYbA7H5SHJMCyZzTcibqC69hrklq7GrgsbYVHb3Y5LDBmEnJQlGBczGYrEr7+/6U/zkk+0Qdi7dy/uv/9+2C5NgsnJyYiOtvc6ra2txblz5yCEgKIoePfdd5GRkeGNMq8aw1ryFaKtHdrhk1APHIOobeh5sMkIZdRQyONG8Ak36RrnJSLSG85L18eituNgVT52l+fiZN2RK44PMYVjUtwMZMXNQnxwsgcqJNHYDNvabdDOuVgNLcswTJ8AedIYSDK///WC81LPtDNlsK7cCNhUh+NyagoMi7IZ1N4glS1l2FTyOfZWboWqqW7HDY1IQ07KUowckM7vVz/Wn+Yln2iD8Nprr8Fms2HChAn43e9+h4EDBzqcr6iowM9//nPk5ubir3/9K15++WUvVUrk+4QQEBcuQt1/DNrxs05PQLqTYiKhjB8JOW0I+zERERGRx5mUAEyKm4FJcTNQ03YRBeV5yK/IQ21blcvxTZZ65JZ8gdySL5ASmorJ8dnIiJ0CsyHYw5X3H1JoMAx33Axt31HYtu11fH6pabBt2QP5VCkMC6dzA1rSPe10KayrNjsHtcMHwXDrTO7PcQOUNJ7CxnMrcai6AD2tGRwdNRE5KUswOHyEB6sj0hevraydOnUq6urqsH79eiQnu373u7KyErNnz0ZERAS2b9/u4Qp7hytrSY9EuwXa0VNQDxRDVNX2PNhggDJyMOTxIyHFRfHflnwK5yUi0hvOSzeeJjScrDuK/IpcHLi4GzbN2uN4g2zEuOgsZMVnY1jEaMiS7KFK+x+tug621VsgLrrYFMhkhGHOZMijU/mz4GWcl1zTTpbA+nkuoHYLakcMhuGWmZAUzh3XSgiB43WHsalkFY7XHnI7TpJkTIidhjnJi5AQMtDtOPI//Wle8omVtY2NjQgNDXUb1AJAbGwsIiMjUVdX57nCiPyAVlEN7UAx1KLTTo3xu5OiIqCkj4A8aiikwAAPVUhERETUO7IkY/iAMRg+YAy+NuzbKKzcgYKKPJxtOOFyvE2zYl/lduyr3I6IwChkxs1CVtwsRJljPVy5/5OjImD8xq1Qt++HWnAI6LoeyGKFbe02yCdLYJg3FVJQoPcKJepGPX4Wti/ynPbvkNOG2leFywxqr4UmNByqKsCmklUoaTzldpxBNuKm+NnITlmEyMAYD1ZIpG9eC2ttNhsCA6/8i1pRFKhqz5dsExEgLFZoxWfsq2jLXV8i2ElRIA8fCCV9BKSkOL9/B4uIiIj8i9kQhKmJczE1cS4qms8jvyIPeyq2oNFS73J8XVs1Npz9BBvOfoKhEWnIistGesxkBCgMDm8USVFgmDkR8tAk2L7cClHf5HBeO3EO1rKLMMyfBnko+wqT96nFZ+xBbbeLjeXRqTDMn85+y9fAplmxt3I7NpWswsUWF/2sLwk0BGF64s2YkbQAoaZwD1ZI5Bu8vmVqTU1Nj/1KtCvsUE/U32nVddD2H4N69JTLHXm7kiJCoYwbAXnMMK5qICIiIr8QF5yExUO/jluG3INjNQeQX56LIzV73W5cc6quCKfqivDpib9hfMwUZMVnY3DYcL55fYPISXEwLlsCdXM+1MOOq55FSyusn34FJX0klFmTuDcCeY1adBq2NVucglplzDAoN09jUNtL7Wobdl/YjNzS1ahrr3Y7LsQUjuzkWzElIQdmQ5AHKyTyLV4Nay9evIjp06f3OEYIwSdORN0Imwrt+FloB4qhna/oebAkQR52aRVtSgKfeBAREZFfUiQFo6MmYHTUBDRbG7G3YhvyK/JQ1nTW5fh2tQ27yzdjd/lmRJvjkRU/C5PiZiIiINLDlfsfKcAEw4LpkFJToK7fAdHa5nBePXAMWskFGBbOgJzAS5/Js9QjJ2Fbu805qE0fASVnCl8v9UKLtQlby9Zh6/m1aLE2uR0XaY7FnOTFyIyfBaPMN2mIrsSrYa2X9jYj8lmitgHqwWJoh086PentTgoJhpw+HMrY4ZBC+K4lERER9R/BxlDMTF6ImckLcb7pDHaX52Jv5Ta0Wptdjq9qLcea0+/jyzMfYuSAcciKz8boqIkMFa6TMmwg5IQY2NZth3a61OGcqG2A9b01UG5Kh3JTOjdxIo9QDx2Hbf0O56B2fBqUOZMZ1F6luvYa5JWuxs4LG2FR292OSwgZiJyUJUiPuQmK5N8bsRPdSF4La//+9797666JfIpQNWinSqDtPwbtnPu+PwDsq2gHJ9lX0Q5JYkN8IiIi6veSQgbja8MGY/HQb+BI9V7kl+fiWO1BCOHcbk0IDUU1+1FUsx9mYzAmxkxDVnw2kkIG82q/ayQFm2G4PQfaweOw5eYDVtvlk0JA3bkf2pnzMC6cASmSvSup76gHimHbsMPpuDJxFJTsLP6MX4WLLRewqeRz7Knc4rbVDAAMCU9DTsoSpEWO59eV6Bp4LaydPHmyt+6ayCeIhiaoB49DO3Qcorm1x7FSkBnyuOFQxg6DFB7qoQqJiIiIfIdRNmJ8zE0YH3MT6tprsLdiK3aX56Kqtdzl+FZrM7aVrce2svVICBmIrLhZmBg7HSGmMA9X7vskSYKSPgJySjxsX26FduGiw3lRXgXLPz6HYdYkyONHMtyhG04tLIJt4y6n40rmGCgzJ/F77gpKGk9hU8kqHKzK7/EK6dFREzAnZSmGhI/wYHVE/kcS7EVwQ6iqisLCQmRkZEBR/Ht5vxAC9fX1CA8P5y+1G0xoAuLMeXsfr9PnnS7P6U4emAA5fQTk1BRIfv59R9QTzktEpDecl3yDEAJnG45jd3ku9l/ciXa15zZTiqxgdOREZMXPwsjI8bys9xoITYO6+xDUnfsBF5tJy4OTYJg/jW28+kB/nZfUvUdg25zvdFyZPA7K9An96mvRG0IInKg7go0lK3G89pDbcZIkY0LsVMxOXozEkIEerJD8QX+al3qTG3q1Zy0R2YmmFqiHT0A7WAzR4LqXWgcpMADymFQo40bwUjEiIiKi6yBJEgaHj8Dg8BG4bdi3cLAqH/nluThZd9TleFVTcbAqHwer8hFqCsekuJnIipuFuOAkD1fuuyRZhmFKOuTBibCt2QpRW+9wXjtzHta/r4Ry81Qowwd5qUryF2rBYdjyCpyOK1PGQ5nKS/Rd0YSGw9V7sPHcKpQ0nnQ7ziAbMTl+NrKTb0WUOdaDFRL5P4a1RF4iNAFRUm5fRXuyxOXKgq7kxFj7KtoRgyAZ+KNLREREdCMFKIHIjJuJzLiZqG6tREFFHvIr8lDXVu1yfKOlHptLPsfmks8xMGwYsuJmISN2KswGrgi9GnJ8NIzLFkPdsgdqYZHDOdHWDtuqzdBGp8IwZzKkAJN3iiSfZtt9EOrWvU7HlWkZMEwZ74WK9E3VbNhbuR2bSj5HZct5t+MCDGZMT5yHmUm3INTExUNEfYGJD5GHidY2aIdPQj1YDFHb0PNgkxHK6FTI40ZAjhngmQKJiIiI+rkocywWDL4LNw+6AyfqjiC/PBcHq/Jh06wux59rOIFzDSew8uQ/MC4mC5lxszAsYjRkiZu99kQyGmDIuQny0GTY1m6HaG5xOK8dOQlraTkMC2dATo73UpXki2w79kPdUeh0XJkxEYbJ4zxfkI61q23YXZ6L3JIvUNfu+s0pAAgxhWNW0kJMTZzHN6WI+pjuwtqKigpUVFQgPT0dQghelkB+QQgBUXbRvor2+FnA5n7nTACQYqOgjB8JeeRgSCajh6okIiIioq5kScaIAWMxYsBYtNqaUVi5E/kVeTjXcMLleKtmwd6KbdhbsQ0DAqORGTcTWfHZiAyM8XDlvkUenATj/Uth+2ontOIzDudEQzOsH6yDMmk0lGkTIBnYJ5jcE0JA3VEIdecBp3OGWZlQMsd4oSp9arE2YVvZemw5/yVarE1ux0UGxmB2ymJkxc2CUeEqdyJP0E1Yu2nTJrzwwgs4deoUJEnCkSNHsGzZMtx666345je/6e3yiK6JaLdAO3oK6oFjEFV1PQ82GKCkDbG3OoiP9kh9RERERHR1zIZgTE2ci6mJc1HeXIr8ijzsqdiKJku9y/G1bVVYf/YTrD/7CVIjRmNyfDbGRWfBpAR4uHLfIJkDYFg0C9rQZNg27gIsXVYxCwG14DC0M2Uw3DIDckyk9wol3RJCQN26D2r+QadzhtlZUCaO9kJV+lPXXoMtpWuw88LGHjdVTAhOwZyBSzA+Zgo3UyTyMF2EtVu2bMFjjz0GrUvPTpvNhsLCQuzduxchISG47bbbvFghUe9o5VXQDhRDPXYasNp6HCtFRdhX0aYNgRTIJ+9EREREehcfnIwlQ7+BWwffg6La/cgvz8OR6n3QhOurp07WHcHJuiP4WHkLGbFTkRU3C4PChvMqwm4kSbK3AEuOg+3LbdBKyx3Oi6paWP+5GobpEyBPHA1J5teP7IQQ9v7HBYedzhlyboKSkeaFqvTlYssFbC79AgUVW6Bq7l+jDg4fgZyUpRgVmcE5ishLdBHWvvzyyxBC4Ne//jX++Mc/orra3ifl/vvvx1tvvYW3336bYS3pnrBYoR07Y19FW+G+1w8AQFEgjxgEJX0EpMRY/hIkIiIi8kGKbMCYqEkYEzUJTZYG7K3chvyKPFxoOudyfLvahl0XNmHXhU2ICUpAVlw2JsXNQHgA9yboSgoLgeGu+dD2HYFt6z5A7RKCqypseQWQT5XAsHAGpLAQ7xVKuiCEgJqbD3XvUadzhnlToaSP8EJV+lHaeBobS1bhYNVuCCHcjhsVlYGclKUYEj7Sg9URkSuS6Omn1UMyMjIQEBCAXbt2ITs7G5WVlTh61D7RTp48GRaLBYWFhd4t8gpUVUVhYSEyMjKgKP59iYAQAvX19QgPD2fICEC7WAvtYDHUIycdL9dyQYoIg5I+AvKYVEjmQA9VSOT/OC8Rkd5wXuq/hBA433QG+eW52HtxO1qtzT2OlyQZIwekY3L8LIyKmgijzP0KutIu1sL25RaIi7XOJ01G+wZlo4by5+wq+OO8JDQBdfNuqIVFjickCYabp0IZO9w7hXmZEAKn6o/iq3MrUVzr3BaigyTJyIiZgjkpS5AYMtCDFRLZ+eO85E5vckNdrKw1mUxobW1Fa2urw/Fz586hsbERERER3imMyA1hU6EVn4F2oBhaWWXPg2UZcmoKlPSRkFLiebkWERERkR+TJAnJoUOQHDoEi1O/icNVe1BQkYdjtQchhOY0XggNRTWFKKophNkYjImx0zE5PhtJIYM9X7wOyTEDYPz6IqjbC6HuOQx0XWtkscL25VbIJ0tgmDcVkpktxfoToQmoG3dCPVDseEKSYFgwHcroVO8U5kWa0HCkeh82lqx0uxEiABhkI7LiZ2F28mJEmWM9WCERXQ1dhLUzZ87E6tWr8d3vfhdNTfZdCJ9//nmsXLkSADBt2jRvlkfUSdQ2QD1QDO3wCYi29h7HSmHBkMeNgDJmGKSQIA9VSERERER6YZSNyIidgozYKahrr8Geii3IL89DVWu5y/Gt1mZsO78O286vQ2LIIGTFZ2Ni7DQEG0M9XLm+SAYFhlmTIA9Ngu3LbRANjjvXa8fPwlp2EYb50yAPSfJSleRJQhNQ12+HerhbIClJMNwyE0raEO8U5iWqZsO+izuwqeRzVDSXuh0XoARiWuLNmJm8EGGmCM8VSES9oos2CBUVFfj617+OsrIyAOhc+iyEQHR0NN577z0kJyd7s8QrYhsE/yVUDdrJEmgHjkE7d6HnwZIEeXASlPEjIA1O5ipaIg/pb/MSEekf5yVyRwiBMw3F2F2eiwMXd/W4GzsAKLKC0ZETkRWfjZGR6f1+V3bRboFt025oR066PK+MT4MyaxIkoy7WJemKv8xLQhOwrd0K7egpxxOSBMOiWVBGDPZKXd5gUduxu3wzNpd+gbo29/umhJjCMTNpAaYlzoPZEOzBCol65i/z0tXoTW6oi7AWAOrr6/HWW29h586dqK2tRWxsLLKysnD//ff7RBsEhrX+RzQ0QT14HNqh4xDNrT2OlYLNkMcOhzJuODc5IPKC/jIvEZHv4LxEV6Pd1ooDVfnIr8jFqbqiK44PM0VgYtwMTI7PRmxQogcq1C/1+FmoG3ZAtDpf7SYNCIPhlpmQ46O9UJl++cO8JDQNti+3Qis67XhClu1B7fBB3inMw1qsTdhetgFbzn+JZmuj23GRgTHITlmEyXHZMComD1ZIdHX8YV66Wj4X1j7//PMYO3Ys5s6dC5PJNycQhrX+QWgC4kwp1P3F0M6cd+yJ5YI8MAHy+JGQh6ZAUmQPVUlE3fnzvEREvonzEvVWVWsFCsrzUFCxBXXt7lfIdRgUNhxZ8bOQETMVgQazByrUH9HUAtu67fbn7d1JEpQp46HcNA6SzOfpgO/PS0LVYFuzBVrxGccTsgzjktmQU1O8Upcn1bfXIu/8Guws+6rHVfnxwcmYk7IUGbFT+v1qfNI3X5+XesPnwtpJkyZB0zRs3boVwcG+uSSfYa1vE00tUA8dh3bwOETjFXbsNQdAHjMMyrgRkAaEeahCIuqJP85LROTbOC/RtdKEhhN1h7G7PBeHqgpg06w9jjfKJoyLmYysuFlIjRgFWepfwaQQAtqBYthyCwCbzem8lBAD48IZfN4O356XhKrC9kUetBPnHE8YFHtQO0TfbROvV1VrOTaVfI6Cii1QNefv8w6DwoZj7sClSIvM6HdzAfkmX56Xeqs3uaEuGvmkpqaiuLgYNhe/XIn6itAERMkF+4ZhJ85deRVtUizk9JGQhw+CZPDvQJ6IiIiIvEOWZIwYMA4jBoxDq60ZhZU7sbs8FyWNrnu0WjUL9lZsxd6KrYgMjEFm3Exkxs9CZGCMhyv3DkmSoIwfCXlgAqxrtkCUVzmcFxcuwvKPVTBkZ0EeN9zvwwB/JGwqbF/kQjtZ4njCoMC4NAfyYP9tCXK+6Qw2nluFA1W7IYTmdlxaZAZyBi7B0PA0D1ZHRH1FF2HtokWLcPToUSxevBhz5sxBTEwMAgICHH6RPvLII16skPyJaGmDdvgE1IPFEHXu+/sAAExGKKNTIaePgBw9wDMFEhEREREBMBuCMTVxLqYmzkV5cynyy3Oxp3Ibmiz1LsfXtF3EurMfY93ZjzEsYgyy4mdhXHQWTEqAhyv3PGlAGIz33gJ19wGoOw84LsSw2mDbsAPyyRIY5k+DFNw/20b4ImFTYVu1GdrpUscTBgOMt+VAHpTglbr6khACp+qLsLFkJY7VHHA7TpJkjI+ZjDkpS5EU0j969RL1F7pog5CWlgZJkiCEcPtO59GjRz1cVe+wDYK+CSEgzlfaV9EePwuoao/jpfhoKOkjII8YDMlk9FCVRHStfHFeIiL/xnmJ+oqq2VBUux/55Xk4Ur0Pmuj5eW2AwYyMmCnIipuFQWH9Y2WpVl4F25otELUNTuckcwCUeVP7zUZUXfnavCRsNtg+2wTtbJnjCaMRxq/lQE6O905hfUQTGo7W7MPGcytxtuGE23GKbEBW3CzMTlmMaHOcByskuvF8bV66Hj7XBiEx0X8vWyDvEm3t0I6egnqgGKK6rufBRgOUtCGQx43gzrFEREREpEuKbMCYqEkYEzUJjZZ67KvcjvzyXFxoLnE5vt3Wil0XNmHXhU2IDUpEVnw2JsVOR1iA/141JsdHw/jNxVC37IG6/5jDOdHaDtuqzRBjhkGZnQUpwDc3uPZ3wmKFbeUmaOcuOJ4wGWH82lzISf4TUqqaDYUXd2JjySpUNJe6HRegBGJq4jzMSlro1z+/RKSTlbX+gCtr9UMIAVFRDW3/MajHzrjcaKArKToCSvpIyKOG8skakY/S+7xERP0P5yXyJCEESptOI788D/sqt6PVdoUNcyUZaZHpyIrLxuioCTDI/nslmXb6PGzrtkE0tzqdk8JDYFgwA3Ky/wR/PfGVeUlYrLB9+hW00grHEyYjjHfcDDnRP/oxW9R25JfnYnPpF6htq3I7LsQYhhnJCzA98WaYDb65ITuRO74yL90IPreyluhGEBYrtKLT9lW0ldU9DzYokIcPgjJ+JKSEGL+fFIiIiIjIf0mShJTQoUgJHYolqd/E4aoC5Ffkobj2IFytzRFCw9HqQhytLkSQMQSTYmcgM36WX/a9lIckwXj/Utg27LS3Q+tC1DfB+sFaKJljoEzN4CbCOiDaLbB98hW0skqH41KACYY7b/aLKyBbrE3YfmEDtpauRZPVuVVHhwGB0ZidvAiT42fDqHBREVF/oouwdu7cuT2elyQJGzZs8FA15Gu0izXQDhyHevQkYLH2OFYaEGbvRTt6GCSz/2+0QERERET9i1E2IiN2KjJip6KurRoFlVtQUL4FVa3lLse3WJuw5fyX2HL+SySFDEZW/CxMiJ2GYGOohyvvO5I5EIbF2dCOnoJt4y7H1wxCQM0/BO1MGQy3zOCmwl4k2i2wfbwB2oWLDselwAB7UBsX5aXKboyG9lrknf8SO8o2oF1tczsuLjgZOSlLkBEzBYqsi8iGiDxMFz/558+f7/E8Vz1Sd8Jmg1Z8FtqBYqd3XZ3IMuRhA6Gkj4CUEs/vJyIiIiLqFyICozBv4O2Ym3IbTjccQ355HvZf3AmL2u5y/PmmMzh/4gxWnfonxkRNRFZcNkZEjoMi+f6KU0mSoIxOhZwUC9uX26Cdd7zEXlysgfWfX8AwfSLkCaMgyXzN4EmirR3WjzdAlDu2A5DMgfagNjbSS5Vdv6rWcmwu+QL5FXlQNfct+gaFDUfOwCUYFTkBsiR7sEIi0htdhLVPPvmkw8eqqqKxsRFfffUVrFYrfvSjH3mpMtIbUVMP9UAxtCMnIdpcP8nsIIWFQB43HMrY4ZCCzR6qkIiIiIhIXyRJwtDwNAwNT8Ptqd/CgardyK/Iw6m6IpfjVc2GAxd348DF3QgLGIDMuBnIistGTFCChyu/8aTwUBjuXgBtz2HYtu0DNO3ySZsKW24+5FMlMCyYDiksxHuF9iOitR3Wj9Y7tbKTgsww3HWzz652Pt90FptKVmL/xd0QQnM7Li1yPOakLMHQ8DQuLCIiADrfYKy+vh7z5s3Dfffdhx/+8IfeLqdH3GCsD+9PVaGdKIF24Bi0EteXb3WSJMhDk+2raAcl8R1xon6iPzWmJyLfwHmJfEFVaznyy/NQULEF9e01Vxw/KGw4JsdnY3zMFAQafH8xhFZZA9uXWyCq6pxPBphgyLkJctoQv/kZ1uO8JFra7EHtRcfvPynYDMNd8yFHRXinsGskhMCp+iJsKlmFopr9bsdJkozxMZMxJ2WpX/aKJrpaepyX+kpvckNdh7UAMH/+fLS0tGDr1q3eLqVHDGv74H7qG6EePA7t0AmIFufdW7uSgoMgjxtmX0XLd8CJ+p3+9EueiHwD5yXyJZrQcLz2EPIrcnGoag9sWs/7QBiVAIyLzsJN8dkYEp7m05dsC5sKdfs+qHuOAC5eGssjBsMwbwqkQN/f70Jv85JoboX1o3VOYbkUEgTjXfMhRYZ7p7BroAkNR2v2YeO5VTjbcNztOEU2ICtuFmanLEK0Od6DFRLpk97mpb7Um9xQF20QVq9e7XTMYrGgoKAA586dQ1BQkBeqIm8QmgZx+jzU/cegnS1z+YSpK3lQIuT0EZCHpkBSfPdJIhERERGRt8iSjJGR6RgZmY4WaxMKL+5EfnkuShpPuRxvVduxt2Ir9lZsRWRgDDLjZyEzbiYiA2M8XPn1kwwKDLMyIQ9Jhm3tVoiGZofzWvEZWMsqYVgwHfKgRC9V6X9EU4t9RW11ncNxKTTYHtQOCPNOYb2kajYUXtyJTSWrUN5c6nZcgBKIqYnzMCtpIcICfLOtAxF5ji7C2ieffLLHBH3mzJkerIa8QTQ2Qz10AtrB4xBNzT2OlcyBkMcMgzJuuM/8EiciIiIi8gVBxhBMS5yHaYnzcKG5BPnludhbsQ1N1gaX42vaLmLdmY+w/uzHGBYxBplxs5AenQWjYvJw5ddHTomH8VtLYdu4C9pRx5C6I1hUMtKgzJwEyaiLl9E+SzQ2w/rhOohax+8pKSwExrvnQwoP9VJlV8+qWrC7fDNyS1ejpu2i23HBxlDMTF6IaQnzEGTkFaBEdHV081umezcGSZIQFhaGadOm4f/9v//npaqoLwlNQJy7APXAMWgnS668ijY5DnL6SMjDBkIy+HerCSIiIiIib0sITsHS1GVYNOQ+HK3Zj/zyXBytKYQmVKexQggcrz2E47WH8LHBjAkxU5EVn42Boak+c2mrFGCC8ZaZUFNToG7Y6bShsVpYBO3cBRhumQk5LspLVfo20dgM6wdrIeoaHY5L4SEw3r1A9y3tWm3N2Fa2HltL17p9AwMAIgKjMCd5MbLis2FSfL+FBhF5li7C2qIi17uQkn8Sza3QjpyEeqAYor6x58EBJiijU+2tDnysuTwRERERkT9QZAPGRk/C2OhJaLTUY0/FVuRX5KHCzWXf7bZW7LywETsvbERsUBKy4mdhUtwMhJkiPFv4NVJGDIacGAvb2m321mxdiJp6WP+1GsqU8VAmj4UksxXb1RL1jfYVtfVNDseliDD7itrQYC9VdmUNljrkla7BjrINaFfb3I6LC05GTsoSZMRMgSLrIm4hIh+kiw3GXnrpJYSGhuKBBx5wOK6qKl544QWEhITgscce81J1V4cbjF35c8T5Cqj7i6EdPwtoWo/jpfhoKOkjII8cwsuMiOiK+lNjeiLyDZyXyN8JIVDadBq7y3NRWLkDrbYrtDKTZIyKHI/MuFkYHTUBBtnooUqvnRAC2v5jsOXtAWw2p/NyYiwMC2dAitD/ZfuAd+clUdcI64drnXoCSwPC7D1qdRrUVrVWYHPJ5yio2NLjxnuDwoYhZ+BSjIqc4NMb7hF5Wn96vtSb3FAXYW1aWhoSEhKwadMmh+MtLS2YOXMmZFlGfn6+l6q7Ogxr3Yxta7+8iramvucbNhqhjBoCedwIXlZERL3Sn37JE5Fv4LxE/YlVs+JwVQF2l+fieN0hpxZ33QUbQzExbgay4mYhMWSgh6q8dlpNPWxfboUor3I+aTTCkJ0Jedxw3f+se2teErUNsH6wzmlvEikqwh7UBps9VsvVOt90FptKVmL/xd0Qwv1Co5GR6chJWYqh4Wm6//cn0qP+9HypN7mhV5YsCiFwxx13OLQ/KC8vx6hRo1yOjYiI8GB11JVoaIJodezVJISA1NQErc3m9MMkmQOA0GCI8ipoB4qhHjsN2Jx7Wjl8TvQAKONHQk4bAinAtzYiICIiIiLq74yyERmxU5EROxW1bVWdbRKqWytcjm+2NmJL6RpsKV2DpJDBmByfjQmx03S7AZMcGQ7jvbdA3bUf6q6DjnttWK2wbdgB+VQJDDdP02Xw6E2ipt4e1Da3OByXoiNgvFN/Qe2p+iJsPLcKRTWFbsdIkoz06MnIGbgESSGDPVYbEfUfXglrJUnCT3/6UyxbtqzzY8B5k7EOixcv9lhtdJloaILltQ+cwloAMGoarN37MwkBSBKkpDigzn2zdQCAQYE8YjCU9BGQEmL8/h0UIiIiIqL+YEBgNOYNuh1zB96GU/VFKKjIw/6Lu2BRnV9TAMD5pjP45MQZrDz1LsZETcLk+GyMGDBOd5eSS4oMw7QJkAcn21fZdnu9o50qhfWdlTDMmwp5mP5XC3uCVl0H2wfrIFpaHY5LMZEw3nUzJHOglypzJITA0Zp92FiyCmfqi92OU2QDMuNmYnbyIsQEJXiwQiLqb7zaBiE3NxdNTU344Q9/iIiICPz85z93OG8wGJCSkuJyxa3e+GMbBK2iGpbXPgBkGTA4PiZNUyHLl46pKtBqAdrb7YFt9AC3fWalAWFQ0kdCHpMKKZC7YhLRjdGfLp8hIt/AeYnosnZbK/ZX7UZ+eS5O1x+74vjwgEhMutQmQY+hmLBYoeYVQD3gOthTxg6HMjsLkklffXk9OS9pF2th+2gdRIvjZlxSbJQ9qNXBa0FVqCis3IlNJStR7mazPAAIUAIxJXEuZiXdgvCAAR6skMj/9afnS7pvg9AhOzsbAGCxWGA2m7Fw4UJvlkPuGBTn8NUm2Zvst7QBVudm+w5kGfKwgVDGj4CUHO/3P4BERERERHRZgMGMyfHZmByfjYstF1BQsQUFFVtQ317jcnx9ew02nluJjedWYnD4CGTFZSMj5iYEGPRxybxkMtpX0A5NgW3ddqeVo+qh49BKymFYOANyUqyXqvQerbLGHtR2u0JTio+G8Y55Xg9qraoFuytykVvyBWraLrodF2wMxcykhZiWOE+3LTqIyD/pYoMxwB7Ynjp1Ck1NTZ3tEDRNQ0NDA7Zv345nn33WyxX2zK9X1pqMl8NaTUA0t0C0tkPq/q0jhMPKWik8BPK4EVDGDNNdLyIi8i/96R1ZIvINnJeIeqYJDcW1B1FQkYdDVXtg06w9jjcqARgfPRlZ8dm62sxJtLTBtmEHtBPnnE9KEpTJ46BMSYekg9eInpiXtIpq2D5aD9HmGNTKibEwfG2uV/coabW1YHvZemw5vxZNFvebX0cERmF28iJMjp8Nk+L9FcBE/qw/PV/ymZW1HQ4cOIBHHnkEDQ3u+5zqPaztF4SAqKkDVPe7YQKAPDAehikZkAYlQpL9+4eNiIiIiIh6T5ZkpEWOR1rkeLRYm7CvcjvyK/JQ2nja5Xir2t65IjfSHIusuFnIjJuJAYHRHq7ckRQUCMOS2dAOn4Btcz5g6RI6CwF11wFop0thuGUm5KgIr9XpCVp5FawfrQfaLQ7H5aRYGL42z2ttIRosddhS+iW2X9iAdlur23GxQUnIGbgEE2KmQpF1EZUQUT+lixlo+fLlqK93/87W3Llze32bmqbhpZdewgcffICGhgZMmjQJzz77LAYNGuRy/MWLF/F///d/2LZtGwBgypQp+PGPf4z4+Phe37ffstrcB7WKDJiMgCTBkDMFclyUZ2sjIiIiIiKfFGQMwfSk+ZieNB8Xms5hd0Ue9lVsQ5PV9WKemtZKrD3zIdad/QjDIsZgcnw2xkZlwqh4Z9WmJElQxg6HnBIP25dboZ2vdDgvKmtgffdzGGZMhJwxyi8XtGhllbB+vMExrAYgJ8fDcHuOV4La6tZKbC79HPnleT2u3B4YNgw5KUsxOmqC7ja2I6L+SRdh7eHDh2EwGPDpp5/ijTfeQFVVFV5++WW88847eP755zFs2LBe3+Yrr7yC9957D//3f/+HuLg4PP/883jkkUfw+eefw2Ry/iX+xBNPQFVVvPXWWwCAX/7yl/je976Hjz/++Lofn98wGABJsrc66BBggmQOAAJMEFab0y9nIiIiIiKiq5UQMhC3hSzDoiH3oqhmP3aX5+JoTSGEcF40IoTA8dpDOF57CIGGIEyInYqsuGykhA71yuW0UngoDHcvhLbnMGzb9gFal5ptKmyb8yGfKoVhwXRIocEer6+vaOcrYP3kK+egdmACDLfluN18uq+UNZ3DppJVKLy40+X3TYcRA8Zh7sClGBo+yu8vvyYi36KLsLa1tRXh4eEYNmwYMjMz8dvf/hYmkwkPPfQQVqxYgTVr1uCJJ5646tuzWCx488038fTTT3duYrZ8+XLMnDkT69evx6JFixzGNzQ0ID8/HytWrMDo0aMBAN/97nfxve99D7W1tRgwgDs+AgBkCdKAMIjWdggJkIPM9hW1REREREREN5BBNmJsdCbGRmeiwVKHvRVbkV+xBRXNpS7Ht9lasKPsK+wo+wpxwcnIipuJSXEzEWoK92jdkixByRoLaVACbGu2QlTXOZzXzl2A9e8rocybAmXkEI/W1he00nJYP9kIWLsFtYOTYFg6G5LBc5HD6fpj2FiyEkerC92OkSQJ46InIydlCZJDff/rT0T+SRdhbUxMDCoqKnDo0CFkZGSgsbEReXl5iI+PR2trKyorK698I10UFRWhubkZU6ZM6TwWFhaG0aNHIz8/3ymsDQgIQFBQED799FNMnjwZAPDZZ59h8ODBCA/37C933TMa7O+MqiqDWiIiIiIi6nNhpgjMTlmM7ORFKGk8hfyKXOyr3IE2W4vL8RXNpfj81L/wxel/Y1RkBibHZ2NUZIZH+5DKsVEwfnMx1K17oe494nBOtFtg+yIP2skSGHJughTom5tYaWcvwPrZRsBmczguD0mGYclsSIa+31RNCIGjNYXYWLISZ+qL3Y5TZAWZcbMwO3kRYoIS+rwuIqLroYuwdu7cuXjnnXfwzDPPYPXq1YiPj8ejjz7aeT4lJaVXt1deXg4ASEhwnIRjY2Nx4cIFp/EBAQH43//9X/zqV79CZmYmJElCTEwM/vGPf0CWexdICiEgurYJ8GHX+jj86WtARL6hY97h3ENEesF5iahvpIQORUroUCwZ8k0crC5AfnkuTtQdAeD8syaEhiPVe3Gkei+CjWGYGDsNWfHZSAju3evLa6bIULIzIQ1Jgrp2G0STY7isFZ2GtbQCyoLpkAf2fYB4I+cl7cx52FZuti/i6UJOTYFy6yxAkft0/lOFiv0Xd2FTySqUN5e4HWdSAjAlYS5mJi1EREAkgGt/nUtEN15/er7Um8eoi7D2hz/8IWpqajo/fvLJJ/GjH/0ImqbBaDT2qgUCYG+rAMCpN21AQIDLjcyEEDh27BgmTJiAhx9+GKqqYvny5Xjsscfwr3/9CyEhIVd93w0NDb0OePVKamqCUdMATQVUxx4+muai94+mApqGpqYmiEBdfGsRUT8hhEBLi/0FEHuOEZEecF4i6nupAWOQOmgM6hNqUFi9A4U1O1DXXuVybINai83nvsDmc18gIWggJkRNw9gBWTAbPNA7NjwIuC0bhu37IZ/oFizWN8L2/pdQxw6DmjUG6MPVqDdqXpLOlcO4fqdjT14A2uBE2GZkAM1N11Nmj2yaFfuqt2N7xTrUWardjjMbgnFTTA4mx8y2/xu3AfVt7jc1JyLv6E/Pl1zmaG7oIlELDAzEiy++CNulyyeWLl2KMWPG4Pjx4xg7diySk5N7fXuAvXdtx98BoL29HWaz2Wn8F198gX/+85/YtGlTZzD7l7/8BXPmzMFHH32EBx544KrvOywsDIrS95d7eILWZoNVlgENgNbtHQBNg4xuP0gaAFlGSEgIZLaPICIP6niXMjw83O9/yRORb+C8ROQ54QjHwJghWCzuw+n6Y8ivyMOBi7tg1Swux1e2n8fasg/wVfmnGBM1CVlxszB8wFjIUh8vurl9HrRjp2H7ahfQ7libcvQ0pMpaKAtnQI6N7JO7vxHzknayBLaN+faNp7u87pVHDIaycAakPmqV12prwY4LG7Cl9Es0WRsAwOXr7vCASMxOXoSs+GwEKIFO54lIX/rT8yW125UIPdFFWNvB0KX5eGpqKlJTU6/pdjraH1RWVmLgwIGdxysrK5GWluY0fs+ePRgyZIjDCtrw8HAMGTIEZ86c6dV9S5LkN99gclAgJHMARGs7YOn2DoCmAbLzuwKSOcD+eX7yNSAi39Ex/3L+ISK94LxE5FmKpGDYgNEYNmA07hj2AAov7kJ+Ra7bXqY2zYr9F3di/8WdCA+IRGbcTGTGzezTnqZK2lDISXGwrd0G7Zxjiz5RXQfbv1ZDmZYBJXMsJPnGzx3XMy+px8/C9kWe04paOW0oDAunQ+qDK0wbLfXYcn4NtpVtQLut1e242KAkzElZjAmxU2GQjTe8DiLqO/3l+VJvHp8uwtq2tjasWLECubm5aG5udloaLEkSNmzYcNW3l5aWhpCQEOzataszrG1oaMCRI0ewbNkyp/EJCQlYvXo12tvbERBgb+7e2tqK0tJSLFmy5DoemW+TwkJg+u7d9rC2CyEEmpqaEBIS4vTNJpkDIIVdfdsIIiIiIiKiGy3AYMZNCbNxU8JsXGy5gPyKPBRUbEFDe63L8fXtNfjq3Gf46txnGBI+Elnx2RgfPRkBBucrM6+XFBoMwx03Q9tfBNuWPYCty2orTYO6dS/EqVIYFs6AFBF6w+//WqjHzsC2Og/o1nNRHp0Kw/zpNzxYrmm7iM0lX2B3+WbYNKvbcSmhqZg7cClGR03s+5XRREQeIgkddPH9yU9+gk8++cRts11JknD06NFe3eby5cvx3nvv4Te/+Q2SkpLw/PPPo7S0FKtWrYKiKKipqUFoaCgCAwNRWVmJJUuWYOLEifjBD34AAPj//r//D4cPH8YXX3yBsLCwK96fqqooLCxERkaG37RBcEcIgfr6+n6xTJ2IfAPnJSLSG85LRPqjCQ3FtQeRX56HQ9UFUDVbj+NNSgDGx9yEzLhZGBqe1ic/y1p1HWxrtkJUuui/ajLCMDsL8phhN+S+r3VeUo+egu3LrU5BrTJmGJSbp93QoPZC0zlsKv0c+yp3QAj3/R2HDxiLuQNvQ2r4KM6xRD6sPz1f6k1uqIuVtevWrQMAjBkzBrNmzXLZV7a3vv/978Nms+FnP/sZ2trakJWVhTfeeAMmkwmlpaWYO3cu/u///g933HEHYmNj8c9//hPPP/88HnjgAciyjMzMTPzrX/+6qqCWiIiIiIiI9E2WZKRFjkda5Hi0WJuwr3I7dpfn4nzTGZfjLWo78svzkF+ehyhzHLLiZiEzbiYiAqNuXE1RETB+/RaoOw9A3X3QMRC1WGFbtx3yyRIY5k2FFHzjV/leiXrkJGxrtzkHtekjoORMuWFB7en6Ymws+QxHqwvdjpEkCeOiszAnZQlSQofekPslItIjXaysnTx5MqxWK3bu3NnZhsDXcGUtEZH3cF4iIr3hvETkO8qaziG/Ig97K7ai2drY41hJkjA8Yiwmx2djTHQmjDewP6p2vhK2L7dC1DvXIAWZYbh5KuTUlGu+/d7OS+qh47Ct3+Ec1GakQZkz+brnNiEEimr2Y2PJKpyuL3I7TpEVTIqdidkpixAblHhd90lE+tKfni/53MraBQsW4NNPP0VLS4vPhrVERERERETkexJDBuK2kGVYNOReHKneh4KKPByt2e/yMnwhBIprD6K49iDMhmBkxE7F5PhsJIcMue6gQU6KhfFbS6Dm5kM9eNzxfltaYf1sI5RxI6BkZ0Iy9e0mWuqBYtg27HA6rkwcbb//63isqlBx4OIubCxZhQtN59yOMykBmJKQg1nJtyIiIPKa74+IyNfoIqy94447sGPHDtx///248847ERUV5ZQy33rrrV6qjoiIiIiIiPydQTYiPWYy0mMmo6G9FnsqtyG/PA+VLeddjm+1NWNH2QbsKNuAuOBkTI7PxsTY6Qg1hV9zDZLJCMPN0yAPTYFt/XaIljaH8+rBYmglF2BYOANyYuw1309P1MIi2DbucjquZI6FMnPiNQe1Vs2KgvI8bCr9HDWtlW7HBRlDMCNpAaYn3oxgoz42WCMi8iRdtEEYNWpUj+clScKRI0c8VM21YRsEIiLv4bxERHrDeYnIPwghcK7xJPLLc7Hv4g6021p7HC9LCkZFZiArPhujIsdDka99fZRoboVtww5oJ0ucT0oSlMnjoEwZD0mRr+72rmJeUvccgS033+m4clM6lGkZ1zSftdlasb1sA/LOr0GTpd7tuPCASMxOXoTJCbMRoAT2+n6IyPf0p+dLPtcG4Up5sQ7yZCIiIiIiIupnJEnCoLBhGBQ2DEtTl+FgVQEKKvJwvPaQy/GaUHG4eg8OV+9BiCkcE2OnISs+GwnBve81KwWbYVg6B9qhE7Btzges1ssnhYC66wC0M+dhuGUm5MhrX83bQc0/BNuWPU7Hlanj7aFwL4OURks9tp5fi21l69Fma3E7LjYoEXNSFmNC7DQYbmAPYCIiX6WLsLaoyH0zcSIiIiIiIiJvMykBmBQ3HZPipqOm7SIKKragoDwPNW0XXY5vstQjr3QN8krXICV0KLLis5ERMwVBxpCrvk9JkqCMGw45JR62L7dCK3NsHyAqqmH9xyoYZmVCTh8JSb62lWm2XQegbtvndFyZNgGGKem9uq2atovILfkCu8o3w6ZZ3Y5LCR2KnIFLMSZqEmTp6lYHExH1B7oIa4mIiIiIiIh8RWRgDOYPugPzBt6O0/VF2FWei4MXd8OqWVyOL2k8hZLGU1h58h8YGz0JWXHZGD5g7FWHlFJEKAz3LICafwjqjv2A1mXzM5sK28ZdkE+WwDB/GqTQ4F49FtuO/VB3FDodN8ycBCVr7FXfzoXmEmwq+Rz7Kre73Jytw/ABYzEnZQmGR4zx+8ueiYiuhS7C2vvvv9/tOUmSYDabkZSUhNtuuw3p6b17V4+IiIiIiIioL8iSjNSI0UiNGI22Yd/G/os7sbs8F2cbjrscb9OsKKzcicLKnQgPiERm3Exkxc9CtDn+ivclyTIMN6VDHpwE25dbIarrHM5rZ8tgfWcVlHlToIwYfMXbE0JA3VEIdecBp3OG7Ewok8Zc8TYA4Ex9MTaWrMKR6r3ua5ckjI3KRM7ApUgJHXpVt0tE1F/pYoOxtLS0znfUupYjSZLDx4qiYMWKFZg1a5bHa7wSbjBGROQ9nJeISG84LxH1b5UtZSioyENBxVY0tNdecfzQiDRkxc1CevRkBBjMVxwvbDaoW/ZC3XfU5XlpaDKUiaMhBZguf44QaGpqQkiIvQ2Dtvco1IPF9pOyBOnS61jDnMlQJvS8CbgQAsdqD2BjyUqcqnPf1lCRFUyMnYE5KYsRG5R4xcdFRP1Lf3q+1JvcUBdh7erVq/H73/8ezc3NuO2225CYmIiysjJ8+umnCAgIwLJly7B//35s3rwZWVlZeOedd7xdshOGtURE3sN5iYj0hvMSEQGAKlQU1xxEfkUuDlfvgaqpPY43KQEYHzMFWfGzMCRs5BXnD+1sGWxrt0E0Xd7AS6gqUFUHCADmAMBw+fWppmmQZQloswCWLv1kZRmIjoBx/nQo40f2+HgOXtyNjSWrUNZ01u04oxKAKQk5yE66BRGBUT0+BiLqv/rT86Xe5Ia6aIOwd+9eVFRU4NNPP8XIkZd/Mdx+++2466670N7ejj//+c/IzMzEkSNHvFgpERERERER0dVRJAWjojIwKioDzdZG7KvcjvzyPJxvOuNyvEVtR355LvLLcxFtjkdm/Exkxs1CRECky/HyoEQY718K21e7oB07bT+oics9bVvbgMAAIMgMSAA0FWi1AFYb0BGMCPt4w03j3Qa1Vs2KgvI8bC79AtWtFW4fr9kYjJmJCzA9aT6CjaFX8yUiIqJudBHWrly5EsHBwQ5BLQCMHTsWISEh+OCDD/D4448jNDQUtbVXvoSEiIiIiIiISE+CjaGYkbQAM5IW4HzTWRSU52FP5Va0WJtcjq9qLceXpz/A2jMfYcSAsciKm4Ux0ZkwykaHcVJgAIyLZkFNTYHtq532IBawh7GSBLRbAFWFFB5qX1Hbbrkc1HYIMEEeOdiphjZbK3Zc+Ap5pavRaKl3+9jCAyKRnXwrboqffVVtHIiIyD1dhLVCCDQ3N+PTTz/F7bff3nn8008/RVOT/RfXoUOHUFNTg9BQvjtHREREREREvispZBCShn0Li4behyPV+5BfkYuimgMQQnMaK4SGYzUHcKzmAMzGYEyImYas+FlIDhnicNmwkjYEclIsrJ98Ba2q2yInmwpRXQeXFxmHBDmFt42Wemw9vxbbyzag1dbs9nHEBCVgTsoSTIydBkO3EJmIiK6NLsLauXPn4tNPP8WPf/xjvPrqq4iNjUV5eTnOnTsHSZIwe/ZsbN68GZqmYcyYq9uRkoiIiIiIiEjPDLIR6TGTkR4zGQ3ttdhTuQ355bmobClzOb7V2oztZeuxvWw9EoJTkBWfjYmx0xFiCgMASKHBUOZPQ83po2gWLU6fLwCHwFYKCYZQmhHcJiMWQE3bReSWfIFd5Zth06xOn98hOXQIclKWYmx0JmRJvo6vABERdaeLsPbHP/4xTp48iYMHD+L06dM4ffp057kJEybgpz/9KV5++WUEBQXhv/7rv7xYKREREREREdGNFxYwAHNSFmN28iKcazyB3eW5KKzcgXa1zeX4C80lWHnyH/j81L8wOmoCsuJnIW3AeNRZa/HbtPVoViz2frTuthSXL7VJEAImzYCJZ1tQ1HbM5ereDsMHjMWclCUYHjHG7zcDIiLyFkkI4W7q9ihN07B582bs2bMHjY2NiI6ORmZmJqZNmwYAKCoqQlRUFGJiYrxcqWu92dXN1/Wn3fqIyDdwXiIiveG8REQ3gkVtx8GqfOSX5+FE3eErjg8xhWOoYTA2n10JkzDACAOEptk3HetCUmRAkmCRVDQqrbBINiQGp8BkCnK6TUmSMDYqEzkDlyIldOgNe2xERP3p+VJvckNdrKwFAFmWkZOTg5ycHJfn09LSPFwRERERERERkfeYlABMipuBSXEzUNN2EQXleSio2IKatosuxzdZ6lHQtAMNhjYEaApCNDOCpADIMuyhLQDIMtplGxrlFrTLNgg3S29lScGkuBmYnbwIccFJffUQiYioG6+Ftb/4xS8QHh6OJ554Ar/4xS96HCtJEp599lnPFEZERERERESkM5GBMZg/+E7MG/Q1nKw7ivyKPBy8uBtWzeJyvFXWUCe3oB6tMGtGBGkB0KChUWmDVVLd3o9RCcCUhBxkJ92CiMCovno4RETkhtfC2vfeew8JCQl44okn8N5777ld7iyEYFhLREREREREBECWZAwfMAbDB4xB67AHsP/iTuSX5+Fsw3GX4wUEWmQLWmTXoW6HQNmMeYPuwPSk+Qg2hvZF6UREdBW8FtZmZWUhKiqq8+9EREREREREdPXMhiBMScjBlIQcVLaUIb88D1vOfNGr25CFjAAh47uDv49hg6f0UaVERHS1vBbWvvPOOy7/TkRERERERES9ExuUiEVD78MYaTh+sff7UKHBqqhuOtICBiEjVA2EQbP3sDUpAR6tl4iIXNPNBmNd2Ww2NDQ0IDIy0tulEBEREREREfkMJTAQRhgQYlNgsCpoVSxoViydfWpNQkGILRBmzQgAsEg2QJIgBZi8WTYREV3i1bC2pKQEb775JkaMGIGvf/3rsNls+N3vfof3338fFosF8fHx+J//+R8sXLjQm2USERERERER+QQpJAhSSBBkORAG2YRQAKEArJoNqqYiQAlA1y1jZM0CSWuDFBLkrZKJiKgLr4W1JSUluOuuu9DQ0ID7778fAPCXv/zFoSXChQsX8OSTTyIqKop9bYmIiIiIiIiuhiwBigIol1/yG2GArKqQFMVxrKoCcL3hNxEReZ7srTt+6aWXUF9fj7CwMIwePRoWiwXvvPMOJElCRkYGXn31VcycOROapuGtt97yVplEREREREREREREHuG1lbW7du2CJEn4+9//jpEjR2LHjh2or6+HJEl48sknMXnyZIwbNw7Tp0/HgQMHvFUmERERERERkc+xalanY6qmQem2ZsvVOCIi8h6vhbVVVVUIDw/HyJEjAQDbt28HAJjNZkyaNAkAEBkZifDwcNTV1XmrTCIiIiIiIiKfEWwMRbAxDM3WBqiqYxCraQKycG55EGwMQ7Ax1FMlEhFRD7wW1prNZrS2tkLTNMiyjM2bN0OSJEyaNAnKpR46DQ0NaGhoQHBwsLfKJCIiIiIiIvIZAwKj8fMpL6HZ2uhwXAiBpqYmhISEQJIcA9tgYygGBEZ7skwiInLDa2HtyJEjsWfPHvzxj3/EgAEDcPz4cUiShLlz5wIAmpub8fOf/xyapiEtLc1bZRIRERERERH5lAGB0U7hqxAC9Vo9wkPDncJaIiLSD6+Ftffccw8KCgrw2muvdR6Ljo7GbbfdhpqaGsyePRtWqxWSJOHee+/1VplEREREREREREREHiFfeUjfWLp0KR5//HEEBgZCCIHU1FS8+uqrMJvNCAsLg8VigSzLeOKJJ7B48WJvlUlERERERERERETkEV5bWQsA//Ef/4GHHnoIDQ0NiIqK6jxuMBjw29/+FlOmTEF8fLwXKyQiIiIiIiIiIiLyDK+GtQBgNBodgtoOt99+u+eLISIiIiIiIiIiIvISr7VBICIiIiIiIiIiIqLLGNYSERERERERERER6QDDWiIiIiIiIiIiIiIdYFhLREREREREREREpAO6CmsPHDiAv/zlL/jlL38JANizZw+EEF6uioiIiIiIiIiIiKjvGbxdAABYrVY89dRTWLduXeexZ599Fo8//jiSkpLw17/+FaGhoV6skIiIiIiIiIiIiKhv6WJl7SuvvIK1a9ciKioKRqMRANDa2oqamhrs378ff/zjH71cIREREREREREREVHf0kVYu3LlShgMBnz44YcYMGAAAMBsNuPDDz+ELMtYv369lyskIiIiIiIiIiIi6lu6CGsrKioQGhqK+Ph4h+OjRo1CUFAQamtrvVQZERERERERERERkWfoIqxNSEhAXV0djhw54nD83XffRWNjIxITE71UGREREREREREREZFn6GKDsXvvvRcvvPAC7r33XgghAADTp09HTU0NJEnC1772NS9XSERERERERERERNS3dLGy9uGHH8ayZctgs9lgs9kghEB1dTUkScJdd92Fhx9+2NslEhEREREREREREfUpXaysBYCf/exnuP/++7Fz507U1tYiJiYGkyZNwqBBg7xdGhEREREREREREVGf001YCwADBw7EwIEDvV0GERERERERERERkcfpIqydO3eu23OSJMFsNiMpKQl33HEH5s+f78HKiIiIiIiIiIiIiDxDF2Ht+fPnrzjm+PHjyM3NxW9/+1vcdtttHqiKiIiIiIiIiIiIyHN0scHY3/72N8THxyMxMRE/+tGP8Mc//hE/+tGPkJiYiKioKDz33HO47777IITAO++84+1yiYiIiIiIiIiIiG44Xays/eCDD1BZWYkNGzYgMTGx83hOTg4WLFiAQ4cO4dlnn8Vnn32GkydPerFSIiIiIiIiIiIior6hi5W1GzduhNlsdghqAfuGY2azGatXr4YkSQgKCoLFYvFSlURERERERERERER9RxdhbWBgIFpaWvDKK69A0zQAgKqqePnll9HS0gJJkrBjxw5UV1cjIiLCu8USERERERERERER9QFdtEFYtGgR3nnnHfz5z3/G66+/jsjISFRXV6OtrQ2SJGHx4sXIz88HAGRkZHi3WCIiIiIiIiIiIqI+oIuVtU8//TTmz58PIQRaWlpQWlqK1tZWAMCtt96Kp59+GnV1dYiJicGTTz7p5WqJiIiIiIiIiIiIbjxdrKw1mUz405/+hGPHjmHPnj1obGxEdHQ0Jk6ciCFDhgAAHn30Ufz4xz+G0Wj0crVEREREREREREREN54uwtoOI0eOxMiRI52OX7x4EXFxcV6oiIiIiIiIiIiIiMgzdBHWqqqKt956C/v27UNzc3PnJmNCCNTX1+PUqVM4dOiQl6skIiIiIiIiIiIi6ju6CGv/9Kc/4bXXXgNgD2g7SJIEIQQkSfJWaUREREREREREREQeoYsNxlavXg0AWLhwIQYNGoThw4fju9/9LgYNGgRJkvC///u/Xq6QiIiIiIiIiIiIqG/pIqytqKhAcHAw/vCHP2Dp0qUQQuDJJ5/E22+/DVmW8dlnn3m7RCIiIiIiIiIiIqI+pYuwNjAwEIC97cH48eNx6tQp1NXVIS4uDkFBQSgqKvJyhURERERERERERER9Sxdh7bBhw9Dc3IxnnnkGGRkZkCQJTz31FJ544gk0NjayZy0RERERERERERH5PV2EtY899hgMBgPKysoQEhKCuXPnYuvWrVi7di0AYM6cOV6ukIiIiIiIiIiIiKhvGbxdAABMnz4dH3/8Mc6ePQsA+OUvfwmDwYDi4mJMnDgRzzzzjJcrJCIiIiIiIiIiIupbughr33nnHYwfPx7z5s0DAAwYMAB/+MMfvFwVERERERERERERkefoIqz905/+hLa2NuTl5WHAgAHeLoeIiIiIiIiIiIjI43TRszY+Ph5GoxHBwcE37DY1TcOf/vQnzJw5E+PHj8eDDz7Y2WbBFavVihdffBEzZ85ERkYGli1bhqNHj96weoiIiIiIiIiIiIh6oouw9oEHHoDVasXdd9+NV199FR9//DFWr17t8F9vvfLKK3jvvffw3HPP4d///jckScIjjzwCi8XicvwvfvELfPjhh/j1r3+Njz76CBEREXjkkUfQ2Nh4vQ+PiIiIiIiIiIiI6Ip00QbhZz/7GSRJQnFxMYqLi53OS5KEW2+99apvz2Kx4M0338TTTz+N7OxsAMDy5csxc+ZMrF+/HosWLXIYX1JSgg8//BCvvvoqZs+eDQD4zW9+g9tvvx2HDh3C1KlTr/3BEREREREREREREV0FXaysBQAhhNv/NE3r1W0VFRWhubkZU6ZM6TwWFhaG0aNHIz8/32n81q1bERYWhlmzZjmM37hxI4NaIiIiIiIiIiIi8ghdrKwtKiq6obdXXl4OAEhISHA4HhsbiwsXLjiNP3PmDFJSUrBu3Tq89tprqKiowOjRo/GjH/0IqampN7Q2IiIiIiIiIiIiIld0EdZ2VVFRgYqKCqSnp0MIAUmSen0bra2tAACTyeRwPCAgAPX19U7jm5qacO7cObzyyit45plnEBYWhhUrVuAb3/gGVq9ejaioqKu+747VwP6s66pnIiI94LxERHrDeYmI9IbzEhHpTX+al3rzGHUT1m7atAkvvPACTp06BUmScOTIESxbtgy33norvvnNb/bqtgIDAwHYe9d2/B0A2tvbYTabncYbjUY0NjZi+fLlnStply9fjuzsbHzyySd4+OGHr/q+GxoaIMu66S7RJ4QQaGlpAYBrCtOJiG40zktEpDecl4hIbzgvEZHe9Kd5qTctXnUR1m7ZsgWPPfaYQ+E2mw2FhYXYu3cvQkJCcNttt1317XW0P6isrMTAgQM7j1dWViItLc1pfHx8PAwGg0PLg8DAQKSkpKC0tLRXjyUsLAyKovTqc3xNx7sB4eHhfv/DRES+gfMSEekN5yUi0hvOS0SkN/1pXlJV9arH6iKsffnllyGEwK9//Wv88Y9/RHV1NQDg/vvvx1tvvYW33367V2FtWloaQkJCsGvXrs6wtqGhoXO1bneZmZmw2Ww4ePAgxo0bBwBoa2tDSUkJFi1a1KvHIkmS33+DAZcfZ394rETkGzgvEZHecF4iIr3hvEREetNf5qXePD5dXK9fVFSEsLAw3H333Z2rUg0GA/7nf/4HYWFhOH36dK9uz2QyYdmyZXjhhRfw1VdfoaioCE888QTi4+Nx8803Q1VVXLx4EW1tbQDsYe20adPwP//zPygoKMCJEyfwzDPPQFGUXoXERERERERERERERNdKF2GtyWRCa2tr58ZgHc6dO4fGxkaXfWav5Pvf/z7uuusu/OxnP8PXv/51KIqCN954AyaTCRcuXMCMGTOwevXqzvF//vOfMXnyZPzXf/0X7rrrLjQ1NeHvf/87IiMjr/vxEREREREREREREV2JJHSw5doPf/hDrF69GpmZmThy5AhaWlrw4IMPYuXKlaiqqsKtt96KF1980dtl9khVVRQWFiIjI6Nf9Kytr6/vFz1FiMg3cF4iIr3hvEREesN5iYj0pj/NS73JDXXRs/aZZ57Bvn37kJ+fD8Dex+HNN9+EEALR0dF44oknvFwhERERERERERERUd/SRVgbFxeHTz75BG+99RZ27tyJ2tpaxMbGIisrC/fffz8iIiK8XSIRERERERERERFRn9JFWFtQUIDMzEw8/vjj3i6FiIiIiIiIiIiIyCt0scHYsmXLsGDBArz22muoqKjwdjlEREREREREREREHqeLsFaWZZw9exbLly9HTk4OHn30UaxduxZWq9XbpRERERERERERERF5hC7aIOTl5eHzzz/HypUrceTIEeTm5iIvLw/h4eFYunQp7rjjDqSlpXm7TCIiIiIiIiIiIqI+o4uVtdHR0fj2t7+Njz/+GKtXr8b3vvc9DB06FHV1dXjnnXdwxx13eLtEIiIiIiIiIiIioj6li7C2q+DgYISEhCA0NBSyLEMIASGEt8siIiIiIiIiIiIi6lO6aIPQ1NSEL7/8EitXrkRBQUFnQGs2m7FgwQLcdddd3i6RiIiIiIiIiIiIqE/pIqydPn06LBZL5wracePG4a677sKiRYsQEhLi5eqIiIiIiIiIiIjoWlW3amiyOF45L4RAY5NAHVRIkuRwLsQkIcqsu4YAHqGLsLa9vR0RERFYunQp7rrrLowYMcLbJREREREREREREdF1qm7V8MONDWjsFtZCAJrQIEuNgGNWi1CThBdzwvplYKuLsPYPf/gDbr75ZhiNRofjFosFa9aswfvvv493333XS9URERERERERERHRtWiyCDRaBAwSYFQcz2kqIHc7ZlWBRotAk0Ugyuy5OvVCF2Htrbfe6vDxiRMn8O9//xsrV65EQ0ODl6oiIiIiIiIiIiKiG8GoAAGK4xJaFYDS7RggYLN5rCzd0UVYC9hbIaxZswb//ve/UVhYCACdPWyHDx/uxcqIiIiIiIiIiIjoeqkCsKmATQjYNEAIIFQClP7X7cAtr4e1xcXFeP/997Fy5Uo0NjZ2BrSSJOHBBx/EbbfdhpEjR3q5SiIiIiIiIiIiInJHEwJ1bQJVrRqqWzVUtWioatVwpt6GujYNtQKQui+iBdBs1ZAYKndvW9tveS2s/fjjj/H+++9j//79AOyraE0mE+bOnYs1a9YAAP77v/8bZnM/bE5BRERERERERESkI5oQqG0TqGrRUNN2OYytbu34U0ATwunz2lUBVdj3EHMVyFo1AZvq3M+2v/JaWPuTn/wEkiRBCIHRo0fjjjvuwJIlSxAeHt4Z1hIREREREREREVHfUzWBunZ7GHs5gLX/aQ9oXYex18sgSzAwqO3k9TYIgYGBGD9+PNLT0xEeHu7tcoiIiIiIiIiIiPyOqtlXxnYGsJfC2Oo+DmO7kyVAkSUYJMAgCYQHsgVCV14Lax944AGsWrUKNTU1eO+99/Dee+8hNTUVt99+u7dKIiIiIiIiIiIi8knuwtiOlbI1bRq0vs9iYVIkRJllRJtlRJntO4e9X9QKs0FCkFGC0iWZVVWVm4t147Ww9sc//jGefvppbNiwAR9++CG2b9+OEydO4MUXX4R0qdvwZ599hoULFyIiIsJbZRIREREREREREXldRxjbPYitatVQ4+EwtiOIjQ669Kf58rFQk9SZ7QHA2XoVnx5vg0mBQ1BLrnm1DYLBYMDChQuxcOFCVFRU4MMPP8Qnn3yC0tJSAMAvf/lLPPfcc5gyZQpef/11b5ZKRERERERERETUZ2yaQJ2bMLa6VUOtTsNYurG83rO2Q1xcHB577DE89thj2LFjBz788ENs2LAB7e3t2LZtm7fLIyIiIiIiIiIiumYOYWyL4wZengxjAzraFARdblVg/1NCdJCMEGPfhLFWFQAcH6CmAnK3Y/Zx/Zduwtqupk6diqlTp6KhoQErV67ERx995O2SiIiIiIiIiIiI3LJpArVtGqpahEMI640wtmsQ66kw1p0Qk4RQk4RGi4DN1uWEADQByBrQfYexUJOEEFP/XL2ry7C2Q1hYGJYtW4Zly5Z5uxQiIiIiIiIiIurHXIWxXdsV1LV7JowNNDhu4BXd2a7A3qog2MNh7JVEmWW8mBOGJovjF0cIgcamRoSGhDrVG2KSOjcn6290HdYSERERERERERF5gk0TqOkMYIVDEFvd6tkwNtrcbWWsjsPYq2F/HI7HhBCoh4TwcMXnHk9fYlhLRERERERERER+r6cwtqpVQ12bBg9ksU5h7OVNvOwbeQX5YBhLNw7DWiIiIiIiIiIi8nlWVaCmraNPrOhcEdsRynoljA2SO//e0TeWYSz1hGEtERERERERERHpnlUVqG7r2ppAeCWMNXftGcswlm4whrVEREREREREROR1rsLYrpt41XswjO3amqDrJl7RZhlBRgax1HcY1hIRERERERERUZ/rCGMvtye43De2Y2WsJwQZJYcglmEs6QnDWiIi8inVrRqaLI7vpwsh0NgkUAfV6XKjEJP9iRgREREREfWtnsLYqhYN9e2eD2NdbeLFMJb0jGEtERH5jOpWDT/c2IDGbmEtBKAJDbLUCHR73hVqkvBiThgDWyIiIiKi62RRBWq6tCWoatVQ1XK5b6ynwthgVytjGcaSn2BYS0REPqPJItBoETBIgFFxPKepgNztmFUFGi0CTRaBKLPn6iQiIiIi8kUWVXS2JNBTGNvRnqAjmGUYS/6MYS0REfkcowIEKI5P0FQAitL9SZuAzeaxsoiIiIiIdK0jjO3amqDrJl4NHgxjo7utho1iGEsEgGEtERH5KAFAH1yVwgAARxRJREFUEx3/Caiq/ZeaBPv/JACaZj/fYtXQapNhkABFBmSJT/6IiIiIyP+0d1kZW9Widdm8S+gijO342Gzg83EidxjWEhGRR2lCoF0F2mwCLVaBVtul/y79vcWGzr93HG+59PfqFg21rRpqAbjOW9Vu92UPdf93R5PDSlwJgCJLUCTAIF/+uyJ1+bvs+LFBBhRJcjhu6BxnP971Y8NVfL7D/XTcRvdxHbfldBxOm6kRERERkX9zF8ZWtdqPeyqMDTFJlwNYs4yoIMfNvAIZxhJdM4a1RER01TTREarCHqB2DVUdQtfL59u6nGu59LG48l251K4KaLCHrdfz9E8AsGkCNgDtascR39M9ZL4cEF8KdruH0TJgkCTHMZc+x+AipO4eRjuP6xowuw+jDT3cDwNn8gfVrRqaum18KIRAY5NAHVSn7/MQk8RND4mIyKV2m3DYvOty31gNNW3Cg2GsjGizxDCWyAsY1hIR9RM27fJK1jYbOsPT7itbL/8Hh1WtbZf+I/1QNdFlLbFv/tvIrgJgNyueu69W7gx/XYTUVxVGuwiZu95eZ8jcLXDuHkazrUb/Vt2q4YcbG9DYLayFADShQZYand5dCjVJeDEnjIEtEVE/1GYTDpt3dQ1jq1sFGi1eCGO7tCpgGEvkfQxriYh0TggBqwanlgCtVrhY0drRSuDyCteOc1bNN8O8qyFJsGeVEiD892H6JU3YN7q4zPf+AWV3q4qdwuSux7u3wnARRncPiR2Ouw+Z3bfUcF2PgYHzdWmyCDRaBAySffPDrjQVkLsds6pAo0WgySIQZfZcnURE5BkdYWyV0yZe9lYFTR4KY0NNMqLMUmcQyzCWyHcwrCUi6kPiUn9Wd6tYu/ZnbXMIWR1XuKp+HLQGGiSYO/4zSggySAg0wOHjjvP1Fg0r9rbAbJAQaJAgS/agVgKgqioU5XIqImC/jKzVBvzPTSFIDFXsK1EFoAr7SmNVs//d/qeArfNj4Xi88+/2c53jxOXbcLg9t8e7fX6Xerrfpx//k/udjk3urJ2vvXzvH69rH2d70HvlPs6uwuTe9HHuKYzuacVzT2G0N9tqGBU49MYG7F20FaV7TQI2m8fKIiKiG0yPYaxD79hLfwYwjCXyWQxriYjc6NqftWt42tIlXLV/DLetBNps/hu6yVK3oPVSuNrx9yCj4/kgY7exBsBslHq1ou9svQqjIsGo2IOanki4FORKQFiA7HOXG2tCOATE7kJmW/dguIfw2V0Y3T1ktjkd736/XW/P/ef76/e+P+raxxl+1Mf58irm3vdxdhcmdw+Jq9s0tNvsuxmql16fd0xrQgMUADIASPY/NWG/AsCf34QjIvJlTmFsi2O7gu49yvtKx/NXh76xDGOJ+gWGtUTkl2ya42ZXPbcKsPdw7b6q1Z/7s8qSPUx1F7ReXtUKFyGs/c8AhZtD9SVZkiArgBHA9W2n5j3apcDWHuB2XUXsGDJ3DY8dj7tf8ezq853C424fd35O99t1CJkdb09jXw2f4o0+zu2qQJNVoNkKyJKr+1QdPtLsuS5+vrURZoMEo2x/A8rhT9n+p0EBTC6Ouxvv8rhy+bxJsa9SNl5amcw5nIj6o7ZLG3hdXg3bZXVsm3fD2M6WBYEMY4n6M4a1RKQrDv1ZHcJTdOvX6r4/a5tNdOuB6V+MctfwFE6tApxDV3vgGtTlnNHHX6RbXaz801RA7nbM6piRkIfJknRpAzEgwEcDZyG6hczdVyV3hMQujl85jHYOmTtbbnScu4rPv1JobeMKTt3ShD3sbffSama3wa6bgNfl8S6fb1Ls7S7cjTXJgOHScfZJJqK+0tqxMtZFGFvVqqHZ6rkw9nKPWMlhE69Is+zUOoeIqAPDWiK6Ya7Un7XrZlddQ9bOdgKXzvvzpaEByuXA9HJ4am8XEOQibA0ydunfeuljg9x/n9iFmCSEmiQ0Wrr1fBT20EPW4HLX9RBT//2a0fWRJHsfVgNgv57dB0Nn0bHCWbgIdbuveL7KMLp7H+ferXjuuqq5p3rYx7mvWbWOXsue/+Iql8LbjlC3eyDcEfya5EsBcJdVxp3B76UguGvobOiyyrj7bXR83J9/jxL5g1abcAhiu4eyngpjwwO69ollGEtENw7DWiICYL/Ut80Gh36srlaxtnbZEKt7KOvP/VklXApULwWpgQ6tAi6vcHXsyep4PtAgQeELxOsSZZbxYk6Y0+VpQgg0NjUiNCTUacVwiEnyuX61RDeS1NGT9fIRL1Zz7dz1ce4eMtu6rGy+Uh/ny6uZe+7j7G6zQFUAdW0ayps0yB2rRS+1ORAQEBogJHQeo8tUTaD10pU0niZLzquKuwa/He0nOgLe7m0m3B13137C8X58+8oWIk9osYrO4NXVCllPhrGdG3YFSQ6bd0WaZZgYxhJRH2FYS+QHbNrl1amtVjiGrGq3sPXSZlj9qz8rnFoEBHVvF+CmP2vHxwEKL9nUC/vGCo7HhBCoh4TwcIUvgon8lF77OJ+tV1Fc2wCzAU6rqFRVhaLYY3IB+8Zi7ar9d/ETmcGICVZg0wSsqn2Vq0W1/063XAqaOz9WL6+C7Rhv0QRsHX9qgEW99Gfn7V3+XPZeduQL7Seu2JbCZb9i17fB9hP9U7WLjbDsb24L1EH16pvbXcNYhxWyl461eDKMDbrcN5ZhLBHpBcNaIi+zqs6bXfXUn9XV6tZ+1Z/VTasA+2pXOHzcMc7EVSxERORlEgBJsr+BKMtAdJCCgWHKFT/vRlAvBb3W7sGuevl4R2DseNz+PMXhTxdjHUPiy+Ntl8aTI2+3nzB2WRl8Ne0nnPoOd/3YRfuJzjYU3dpPKBKfj3lKdauGH25sQGP3jbIEoAkNstTosm3UizlhNySw7QhjO3rEdq6Q9WoY22UjryD7Bl5GhrFEpFMMa6lHen5H1tu69md12vDq0mZXbS5WsHbv3+rPG78EKJJD64CurQKCXLYSuLwZVsd/fBJFRER0fRRZgiIDgV5Ykaxdaj/REfbaNPuqVlu34NfaLfi1dQt+nQLjSx9bNMDm4njHn/77LOvaqJfaeXjjiqretp/oCI27t5/ofvyK7Sn6YfuJJotAo0XAINkD9640FZC7HbOqQKNFoMkinK5ecsVVGNt1payn2ptEBHYNYu19YxnGEpE/YFhLbnn7Hdm+1NGftWuA2mLr2krg8mZXHRtguVrl6q85a0d/VtctAQDnfqzsz0pERP2b1cUl9ZoKyN2O2cf1H7JkD+O8cTmxuNS/uDPY7dZmoqf2E92DZLafuH6+0n7CoDhufudwvBftJ7r+6a32E0bFRXsWAIrTz+PljVuFsC88qW4Vna0Jqlo1VHcJZr0ZxnaslGUYS0T+jGEtudXX78heK1XrYbMrp1Wszv1Z2y79569Pn6+qP2v3zbC6hK6Bl9oJsKcZERHRlYWYJISaJDRaLocdAC69uQ3IGly+uR1i4u/ZviZJEgySfVWl2eD5r3dft5/ofrzreH++cuta6aH9hPuguKPdhGP7CYe+w117FrvbxO7Sn00WDT29V6AJ+yp326XvpzZVoN0m8Oc9zZ2LV/qaBMcwtmNFbEergkiGsUTUjzGspSu6lndk3XHbn9VFq4COlawdK2BbrP7fn9UgX1692nXFaqBTqwDX/VuDDPYncf3pMi8iIiJvijLLeDEnzE3bqEaEhoT267ZR/RnbT1CHzvYTHvrKtKsCNW0aats6egV39M2WoGqAgOMSf03YI+zyZtXpdd+1YhhLRHTtGNZSr6ka0K4CkrC3ARCXVo5YVIF2DfjoWCsCFKnbalf/789qUi5vdhXYZTOsrqtaAx0+htOqVj5hISIi8j1RZtnpqiIhBOohITxc4Zuo5HF6bz/R0TaC7Sf6ngAur7K9gV+bjjA22uy4iVeUWUK0WUakWYaBLdGIiK4Jw1rqlYstGpo7d+/UHM51vCO7t8J6w96R9ZRAg+uWAD32Z+1yPtAg8ckIEREREfV7bD/hHyQAAwIvB7EMY4mIPIdhLV21Nhu6BLX64Ko/q3NrAHt/1o5Atnv/VvZnJSIiIiLyD/7YfsJhdbKL49fSfkKC/WtlkAEJAqqQcMeIQIyKMiI6SMKAQIaxRETewrCWrtqN/l2tyF3C1B7CVrMBCHIIV6XOjwPYn5WIiIiIiHRAL+0nTtXa8LO8JgQY7BuOdbRCEBDQNA0BBgWKfHnvw3bVvo/IpHgTBoUrPd0NERF5AMNaumomxX4pTEO7Zt/dWAZkSJAle5ArhIBNSJieZEJiqNJtFSv7sxIREREREfWFru0nQkwyZNn+d5ND9ipBVQGF+xsSEekaw1rqlfAACeEBClRVhaI4vuva8Y7sramBfEeWiIiIiIiIiIiolxjWEhEREREREfkZqwqgWydbTQXkbsfs44iISC8Y1hIRERERERH5iRCThFCThEaLgM3W5YSAvZ2dBnTffy3UJCHExDZ1RER6wLCWrojvyBIREREREfmGKLOMF3PC0GRxfL0mhEBjUyNCQ0KdNmkOMUmIMrOZLRGRHjCsJbf4jiwREREREZHviTLLiDI7HhNCoB4SwsMVp7CWiIj0g2EtucV3ZImIiIiIiIiIiDyHYS31iO/IEhEREREREREReQaXQBIRERERERERERHpAMNaIiIiIiIiIiIiIh1gWEtERERERERERESkAwxriYiIiIiIiIiIiHTAb8NaTdPwpz/9CTNnzsT48ePx4IMP4uzZs1f1uatWrcLIkSNRWlrax1USERERERERERER2fltWPvKK6/gvffew3PPPYd///vfkCQJjzzyCCwWS4+fd/78efzyl7/0UJVEREREREREREREdn4Z1losFrz55pv47//+b2RnZyMtLQ3Lly9HRUUF1q9f7/bzNE3D008/jTFjxniwWiIiIiIiIiIiIiI/DWuLiorQ3NyMKVOmdB4LCwvD6NGjkZ+f7/bz/vKXv8BqteLRRx/1RJlEREREREREREREnQzeLqAvlJeXAwASEhIcjsfGxuLChQsuP+fAgQN488038eGHH6KiouKa71sIASHENX++L+h4jP7+OInId3BeIiK94bxERHrDeYmI9KY/zUu9eYx+Gda2trYCAEwmk8PxgIAA1NfXO41vaWnBU089haeeegqDBw++rrC2oaEBsuyXC5Y7CSHQ0tICAJAkycvVEBFxXiIi/eG8RER6w3mJiPSmP81LmqZd9Vi/DGsDAwMB2HvXdvwdANrb22E2m53GP/fccxg8eDDuu+++a77PjoQ8ODgYiqJc8+34AiEENE1DSEiI3/8wEZFv4LxERHrDeYmI9IbzEhHpTX+al1RVBXB1K2z9MqztaH9QWVmJgQMHdh6vrKxEWlqa0/iPPvoIJpMJEyZMAHD5C7h48WIsXboUv/rVr654nx0J+aFDh667fiIiIiIiIiIiIvIvV7PC1i/D2rS0NISEhGDXrl2dYW1DQwOOHDmCZcuWOY1ft26dw8f79+/H008/jddeew2pqalXdZ8GgwHjxo2DLMt+/24AERERERERERERXZ2OVcQGw5WjWL8Ma00mE5YtW4YXXngBkZGRSEpKwvPPP4/4+HjcfPPNUFUVNTU1CA0NRWBgIAYNGuTw+R0blCUmJiIqKuqq7lOWZaceuURERERERERERERXy293wvr+97+Pu+66Cz/72c/w9a9/HYqi4I033oDJZMKFCxcwY8YMrF692ttlEhEREREREREREQEAJHE1nW2JiIiIiIiIiIiIqE/57cpaIiIiIiIiIiIiIl/CsJaIiIiIiIiIiIhIBxjWEhEREREREREREekAw1oiIiIiIiIiIiIiHWBYS0RERERERERERKQDDGuJiIiIiIiIiIiIdIBhLREREREREREREZEOMKwlIiIiIiIiIiIi0gGGtdQnNE1zeVwI4eFKiIicuZujiIi8hfMSEeld19dyfF1HRN7mz7mTwdsFkP/RNA2ybH8fYP369SgrK4PVasXDDz8MSZK8XB0R9Xdd56gNGzbg2LFjSElJwcKFC2EymbxcHRH1R5yXiEjvus5TANDa2oqgoCAvVkRE/VnXOenLL79EWVkZ2tvb8Z//+Z9+kTsxrKUbruMH5ne/+x1WrVqF2NhYTJ06FRaLhS84iMjrus9RCQkJGDVqFBYuXOjlyoiov+K8RER61jUU+dvf/obdu3ejpqYGzz77LNLS0rxcHRH1R92fO8XHx2PKlCl+kzsxrKU+8c9//hMrV67E22+/jdTUVNTX16O8vBy7d+9GTk4OIiMjIYTwi3c8iMj3fPDBB/jiiy/wyiuvID09HXV1dTh//jyKioqQlJSE9PR0b5dIRP0M5yUi0quOUOT555/Hp59+isWLFyMrKwspKSleroyI+rP33nsPq1atwttvv41hw4ahpqYG58+fx86dO5GTk4O4uDifzZ0Y1lKfuHDhAu655x4MHz4cBw8exAcffICvvvoKdXV1eOONN/Dhhx8iODjY22USUT9VXFyM+fPnIz09HXv27MEnn3yCjRs3or29HYMGDcKvfvUrjB071ttlElE/wnmJiPRsx44dWLNmDf7yl79g3LhxuHDhAnbv3o1PPvkEY8aMwbe+9S22RSAij6qoqMAdd9yBYcOG4cCBA/jggw+wceNGNDQ04PXXX8cnn3yCsLAwb5d5TRjW0nXr+k5FxyUyFy5cQF5eHurr6/Hxxx9jypQp+M///E9MmzYNd955J7Zu3YoFCxZ4uXIi6g9cvZsaHh6Ojz/+GE1NTVi3bh0mT56MJ598EgMHDsR///d/o6amxkvVElF/wHmJiHxNa2srkpKSkJSUhK1bt+Ltt9/G2bNnERUVhfXr10NRFDz88MPeLpOI/JSr3KmiogJr1qxBfX09Pv30U0ybNg3f+973MGvWLNx+++3YsmULFi1a5OXKrw3DWrouXfsXCSHQ3t4Os9mM//3f/8UzzzyD4uJiPPPMM5g3bx5iY2NRUVGBwYMHIzo62suVE1F/0HWOamtrg6IoMBqNWLhwIaqrq3HgwAE888wzyMnJQWxsLNra2pCUlOQXO4gSkT5xXiIiveu+mRgAxMbGIj8/Hw8++CCKioqwdOlS3H333ViwYAF+8IMfoLy83EvVEpG/6zonqaqKtrY2BAcH47nnnoPNZsOZM2fwk5/8BPPmzUNUVBSqqqowcOBAxMTEeLnyaycJPvOjG+DNN9/Erl27UFpaiqysLHznO9/BoEGDAAD19fUwGo2oq6vDr3/9a1RXV+Nf//oXFEXxctVE5M+6vvv6+uuvY9++fSgpKUFmZia+9a1vYciQIQAAi8XSuTLk6aefRkNDA9577z3OUUR0w3FeIiK96xqKnDlzBqqqIjg4GPHx8SgsLMTOnTsxfvx4TJ06tfNz7rnnHsydOxePPvqot8omon7g9ddfx44dO3D+/HlMmDABDz/8MFJTUwEAtbW1MBqNqK2txW9+8xtUVVX59HMnhrV0Tbr+En/55Zfxt7/9Dffddx80TcNHH32ExMRE/OAHP8D48ePxwgsvYO3atYiNjUVISAjeeecdGI1GqKrqsz84RKRvXeeo1157DX/961/xyCOP4PTp0zh16hROnz6Nv/zlL5g4cWLnZhlRUVEIDAzEu+++yzmKiG44zktE5EuWL1+OL774Ao2NjbBYLHjwwQdx7733IjY2FidPnkRxcTEMBgM++OADXLhwAZ988gkMBl64S0Q3TtfnTitWrMBbb72FZcuWAbBvzBoZGYnHH38cEydOxPLly7Fy5UokJib6Re7EsJauy4EDB/Dll19i8uTJmD17NgCgrKwMDz/8MGJiYvDSSy/BarViw4YNSE5Oxk033QRFUWCz2fjLnIj63IkTJ7B8+XIsXbq0s0/2wYMH8fLLL+PkyZP497//jcrKSpw+fRoBAQHIzs7mHEVEfYrzEhHpUdeV/5s2bcKPfvQj/P73v0doaCgKCgqwYsUKLFmyBP/xH/+BoqIiPPXUUxg8eDBiY2Px5z//2adDESLSt8LCQmzYsAEZGRmYN28eAKCqqgoPPfQQgoKCsGLFChgMBqxduxbJycnIzMz0+edODGvpmu3evRsPP/wwbDYbVqxYgezsbFgsFphMJpw9exaLFy/GL37xC9x5550On8df4kTkCWvXrsWvf/1r2Gw2vPDCC5gxY0bnuV27duHZZ5/FU0891fkLvwPnKCLqK5yXiEjvPvroI5w+fRpGoxE/+MEPOo9/8MEH+OUvf4nf/va3WLx4MUpKShASEoKIiAhIkuTToQgR6VdBQQEeeughtLe345VXXkFOTk5n7lReXo6FCxfimWeewTe+8Q2Hz/P1507ylYcQ2XXP9ePj4/Gd73wHiqLg1KlTAACj0QibzYaEhAQMHToUTU1NTrfjyz8wRKRf3eeoBQsWYPr06airq0NBQQFaW1s7z910002wWq04ceKE0+1wjiKiG4XzEhH5ko52Bq+//joaGxsB2HtoA8Ddd9+NW265Bf/4xz9gtVqRnJyMAQMGQJIkaJrGoJaIbghXudMjjzyCgIAAHDt2DABgMplgs9kQFRWFoUOHOjyf6uDrz504o9JVsVqtMBqNnX83GAwYOHAgHnnkEbS1teGPf/wjBgwYgNtvvx0GgwEWiwWSJCEsLMzLlRNRf9B1jgKAlpYWBAUF4Xe/+x0kScKXX36JESNGYP78+TAYDGhsbERUVBRSUlK8WDUR+TPOS0Skd137QQL2UOSJJ57An//8Z6xduxb/8R//gejo6M75LCoqCq2trQ5zGwCH2yAiulZdnztZLBYoioLk5OTOlbWvvvoqIiMjce+993bmTkIIv8yd2AaBerRlyxZMmDABISEhAOy77x09ehQlJSWYNGkSvvGNbyA5ORm///3v8e677+Kee+5BeHg49u/fj7KyMqxatcrn39EgIv3atm0bpk+f3vnxm2++iT179qC0tBSTJk3Cww8/jMTERDz11FMoLCxEVlYWUlNTUVBQgNLSUnz66adcCUJENxTnJSLyNWVlZWhubkZUVBQiIyNRXFyM//f//h9aWlrw5ptvIioqCqqq4pFHHsGQIUPw7LPPertkIvIjubm5yMjIQHh4OAD7RqyHDx/GuXPnkJmZifvuuw+pqalYvnw53nrrLdx+++2IiIjozKY+//xzv3vuxLfAyK3XXnsNjz/+OD7//HMA9hcbK1aswMiRIzFo0CDs3bsX3/zmN3H69Gk89dRT+MY3voH3338f69atw913343PPvsMiqJAVVUvPxIi8kcfffQRHnroIbz//vsAgJdeegmvvPIKhg8fjtmzZ2PNmjX4wQ9+gIMHD+KFF15AZmYmPvnkE6xduxZDhw7t/KXOOYqIbhTOS0SkdytWrEBeXl7nx7/73e/w6KOP4q677sJDDz2EX/3qVxgxYgR+/etfw2w245ZbbsE999yDZ555BhcuXMBPfvITAM6XKhMRXYs333wTjz/+OFatWgUAePvtt/Hqq68iPT0do0aNwuHDh/Gtb30LRUVFeOKJJ/Cd73wHK1euxPr163Hvvff67XMn/4qe6YZ65JFHsH//frz11ltoa2vDzp078fzzzyMnJweAfUe+l19+GT/4wQ/wt7/9DQ899BACAgLw6quvora2FkajsbNlAhHRjWSxWDBv3jwcP34cP//5z9HU1ITm5ma8+OKLyM7OBgDce++9eOihh/D73/8e77zzDn77299C0zQcOnQI8fHxnbse89I9IroROC8Rkd6dPHkSr732GrKyshAaGopz587h888/x3PPPQeTyYR9+/bhn//8J+rq6vCHP/wBv/rVr/DCCy9g+/bteOSRR7B8+XIA4GZiRHTDPPjggzh48CD+9re/ob29Hbt378bvfve7zs1WDx48iBUrVuCJJ57A22+/jQceeABGoxEvvfQSSktLO4Naf3vu5F+Phm6Ihx56CP/4xz8gSRJeeuklDBkyBH//+99RWFiI0NDQznEZGRm4//77YbFYcOzYMcTExODrX/86vvOd7+BXv/oV3n77bRiNRkiS5MVHQ0T+5qc//Slef/11mEwm/Nd//RceeOABvPDCC/j73//e+cLBYrEgMTERK1aswP79+/Hxxx8DAH7/+99j1KhRePfdd/HXv/4Vzc3NnKOI6LpxXiIivautrUVqair++te/4syZM3jjjTeQl5eHb37zm8jOzsbUqVPx7W9/G08//TT27t2Ld999F2lpafjP//xPpKen47nnnkNNTQ0AcI4iouv27W9/G3/9618BAMuXL8eoUaPwzjvvoKCgAMHBwZ3jxo0bh29961sQQqC4uBiRkZG4++678eijj+L555/HihUroCiK381LDGvJwbp167Bt2zY899xz+Oc//wlJkvCXv/wFEydORENDAwoKCtDe3t45ftq0aWhtbcWhQ4cA2JvSP/jgg7j77rvx0ksvoaGhgZfIENEN8/nnn+Ojjz7CF198gX//+9+QZRnf+9738Mgjj0AIgePHjwMAjEYjbDYbEhMTMXjwYDQ1NXXexosvvojBgwdjzZo1sNls3nooROQnOC8Rkd7deeedmDNnDsrLy5GZmYnnnnsOx44dwxdffIGKiorOcUFBQVi4cCHS0tKwf/9+AMCkSZPw4x//GElJScjOzkZVVRX3JCGi67Jx40bs3LkTL774It5++238/+3deVhV1eL/8fc5zGM4IKgXM01BRQsFDS0rh3Kqrt0UJFFRTEnEUlMxb5Zj5ayYUliiTZKZX3OoLLs5hBlamZXDFfEKFolAKAIHOfz+8Hd2knWvFgTJ5/U8PXnO3nudtfd+zmKfz157LYClS5fSuXNnCgsLSUtLo6ioyFg/NDQUi8Vi5E4+Pj4MGTKEiIgIVq1aRX5+/nWXOymslQpCQkLo0qULjRo1YsaMGcadjvnz59OzZ0+2bt3Kxx9/bHwRzp8/T7169WjYsKFRhre3N2PHjuX999/H09PzurvDISLV55ZbbsHb25uTJ0+yZcsWUlJScHR0ZPjw4QwZMoQlS5awceNGTCYT9vb2lJeXY7VacXFxATBCkMTERFauXGkMYi8i8nupXRKRmqywsJCcnByKi4sZNGgQp06domPHjsyfP58mTZrwzTffcPDgQWN9JycnbrrpJvLy8rBYLMCldu6JJ56gQ4cOFW40iYj8HsHBwXTt2hU/Pz+effZZEhISAJgzZw59+vRh27Zt7Nixw7hGKigowMvLq0LuVK9ePWJiYvjggw/w8vK67nInU/n1Fj/LH2K1Wpk3bx5paWn07NmTxYsXM378eKKjowEYPXo0J06coGPHjjRp0oR9+/Zx+vRp/u///s/4AXK9fUlEpGawWq2YzWY2btzI5s2bKSkp4fTp00RGRhIeHo7FYmHFihW8+uqrhIWF4eLiwrfffktWVlaFGULLysrUI0REKoXaJRGpyWy/zRITE9m+fTtWq5WsrCzWr1+Pn58faWlpTJkyhaCgIB5++GFuvfVWCgoKGDVqFK1ateKpp56q8PuupKQEJyenat4rEbkeLFiwgD179tCvXz8WLlxITEwMY8aMAWDs2LEcOXKEDh060KRJEw4cOFDrcieFtWL80LD9/6effmLAgAH069cPs9lMQkICkyZNYvjw4QA89thjvPfee9x666107NiRuLg4Y1Bn/dAQkapga58ADh48SFJSElFRUWzevJnt27czfPjwCsHIm2++SYMGDYiJiaFfv35qo0Sk0qldEpG/im+//ZYRI0YwePBgvvnmG/bv328Etvv27WPq1KnApUeLnZycyM/PZ926dTg4ONSKUEREqp6tLbFdPxUWFjJgwAB69uyJm5sbCxcuZNy4ccTExADwxBNP8O6773LLLbcQGhpKbGxsrbp20hSOtVx+fj5eXl4AmM1mLBYLN9xwAxEREWRmZjJ06FAuXLjA888/j8lkIioqisWLFzNkyBBuuukmHn/8cUwmU635wojInys9PZ1mzZpVuKHUrl076tSpw8KFC1m7di2lpaUkJycDEB4ezqhRoygtLSUrK4sHHnhAbZSIVCq1SyLyV3B5n6zWrVszYsQI9u7dy8MPP8xPP/3EwIEDSUlJoWPHjjz//PNMnTqV9PR0Jk+ezH333YednR0XL140ngAQEfm9cnJyqF+/PvBz7uTm5kZ4eDgZGRk89NBDXLhwgSVLlgAQExPDvHnzyMvLo2HDhowbN67WXTupZ20tFhkZycGDB5k8eTIBAQG0b9/eWLZ//34mTpzIvHnz6NChA/Pnz2fVqlVMmTKFYcOGAT/3KNHdVhGpCqNHj+bkyZN07dqVsWPH4uLiYvxxzsvLY8KECQwePJhu3boxceJEDhw4wLBhwxgwYAAXL17E3d29wt1bEZE/Su2SiNR0GzZsoG/fvpjNZmNiQ3t7e7744gsSExN59NFHcXd3Z/LkyWRmZpKSkoKfnx+pqam8+eabLF68uNaFIiJSdYYMGWIMudKqVStCQkKMZQcPHmTcuHHMnj2bzp07s2TJElasWMHjjz/OqFGjgNqbOymsraX27dvH448/ztmzZwkJCaGkpISgoCCioqKoV68eDg4OLFmyhC+++IKlS5dy8eJFkpOTSUxMZMGCBfTt2xdAPzZEpErs3r2b6OhoHB0dMZvNNGrUiF69etGjRw9at25NaWkpCxcu5PTp08Yd2ClTprBlyxaee+45+vTpA1Dr/qiLSNVJTU0lKipK7ZKI1Fjjxo3j/fffJzQ0lJCQEPr160eTJk2M5ePHjycnJ4c1a9Zw+PBhnn76aTIzM3n11Vdp2rSpsZ5+44lIZUhLS+Oxxx4jJyeH4OBgSktLadWqFSNHjsTb2xtHR0dWrlzJnj17WLJkCXZ2dqxdu5aEhATmzp1L//79gdrZJtWuvRUAli5dislkYtKkSdx4442cOXOG4cOH89FHHxEXF8ecOXM4d+4cvXr1wsvLi+PHj1O3bl0GDhzI9OnTuffee42yatsXRkT+HLfffjszZ87E09OTBx54AH9/f44dO8bQoUNZsWIFp0+fZsyYMRw6dIi33noLgGeffZaYmJgKbZQCERGpLKGhoTzzzDNql0SkRsrJycHLywtHR0eOHz/OyZMnefDBB1m9ejWHDh0C4Omnn8bOzo4PP/yQgIAApk6dipubG3PmzAEuBSKg33giUjn8/f2Jj4/npptuIjs7m+joaPbt20dcXByzZs0iNzeXHj16UK9ePdLT07nhhht46KGHmDlzJvfdd59RTm1sk9SztpYZOHAgFy5cYPPmzRQVFfHBBx8we/ZsevbsycyZM1mzZg2bNm3ixx9/ZNSoUaSkpNCiRQsWLlxYoRyNXyQiVWHAgAF069bNGFh+9erVrF27lnvvvZeuXbuSnZ3NCy+8gJubGyEhIXh4ePDjjz8yZcoUXF1djXL06J6IVBaLxYKdnZ3RpqxatYrXXnuNXr16qV0SkRrlxIkTrFu3juTkZMaPH0/jxo1ZvHgxHh4edO7cmYcffpiEhATq1q3L+PHjATh+/DhNmzZV+yQilcpiseDo6IjFYuHDDz/kmWee4Y477mD+/Pm8/vrrbNy4kZMnTxITE8OGDRto0qQJCQkJFcqozbmTwtpaZNCgQVgsFtasWYObmxuAEdj+85//pE+fPjz77LMALFiwgBMnTnD48GEyMzN55ZVXCA0Nrc7qi8h1LiIigpKSEtauXVsh4Fi9ejWrVq2iZ8+eTJw4kXPnzpGamsrKlSs5efIk5eXlbNq0iZYtW1Zj7UXkejRr1izS09NxdXWlefPmPP7448CldikpKYl77rlH7ZKIVKvTp09z/vx5o705c+YMy5YtIyUlhTVr1hAQEMCmTZtYtmwZQUFBmM1m/vWvf5GUlETnzp2NcnRDSUQqwzPPPMP3339PdnY2YWFhdOnSBT8/P7Zu3crUqVPp1q2b0Rlw2bJlHD16lKNHj3Ly5ElWrVpFly5dqnkPagaFtbXEoEGDuHjxovFYHvzcU6SwsJAdO3Ywb948brnlFl544QUADh8+zLFjx3j33XdZsWKF/niLSJUJDw8HICkpCXd39yuWr169msTERHr16sXIkSNp1KgRZWVlvPLKKxw/fpxZs2apjRKRSjVy5EjOnj3L3XffTXZ2Np9++ileXl4sXryYJk2asHbtWlasWMG9996rdklEqsWjjz5Keno62dnZNGvWjEGDBtG7d2/Ky8uZPXs277zzDgkJCfTo0YP8/HySkpLIyspi27ZtxMbGEhsbW927ICLXkREjRhjXTrm5uXz00UcEBgYSGRlJly5d2Lp1K08++SSdOnVi5cqVABw7doz09HQ2btxIQkKCrp3+P4W1tUBJSQkDBgygXr16vPLKK8ClL0RiYiJHjx7Fx8eHG2+8kcDAQBYuXEjbtm1Zvnz5FeXobquIVAXbj4n33nuP+vXrA5dmVc/NzeWHH37gtttuw87Ojtdff52EhAR69+5NREQEzZs3r1BObX5MRkQq11dffUV8fDzLly/npptuAuC7775jypQpFBUVkZCQQMuWLUlOTubFF1+kV69eapdE5E81adIkTpw4wfjx4/Hy8mLFihVkZGTQrl07nnjiCezs7JgzZw4bNmzg+eef5/7776e0tJSSkhK2bdtG//791T6JSKVJS0tjxowZvPTSS/j4+ACwY8cO1q5dS0FBAXFxcdx5551s3bqVp556ig4dOpCYmHhFOcqdLql9o/TWQk5OTkydOpWcnBwSExPJzMw07qL27t2bevXqsW/fPnbt2sX48eNJS0tj6NChV5SjL4yIVAV3d3f8/Pw4evQoAEePHiUmJoZRo0YRGxtL3759+fTTT4mIiGD06NFs376dxMRETp8+XaEc/eAQkcpy/vx5zp49S4MGDYz3WrVqRVJSEp6enowbN46CggKGDh1KdHS02iUR+VPl5+eTkZHBqFGjCA0NpVWrVixZsoQ+ffpw6NAhZs6cidVqJT4+ngEDBjBp0iS2bNmCg4MD7u7uDBgwAHt7ey5evFjduyIi1wmTyUROTg75+fnGe926dWPMmDF4e3uTmJjIgQMH6NOnDzNmzOCrr74iLCzsinKUO12isLaWaNu2Ld27d2fnzp0899xz9OrVy5ih+Omnn+aee+4hMzOTDh06MH78eMxmszEbqIhIVRo3bhwNGjRg3rx5ZGRkMH36dIKCgpg5cybr16/Hx8eHSZMmkZuby5AhQxg0aBAFBQX4+vpWd9VF5DqzcOFCjh8/TqtWrXB0dCQlJcVYZrVa8fb2ZunSpVitVuLi4gCIiooiIiJC7ZKI/Gns7e0pLi4mOzsbgNLSUkwmE6NHj+aBBx7g+PHjJCYm4uTkRGxsLOHh4UyYMIHU1NQryhERqQwODg7ApYkO4VK7BBAcHExUVBRWq5X169djsVi46667mDRpEh4eHsqdfoOGQahFfvjhByZOnEhaWhrTp09n0KBBWK1WzGYzJ06coHfv3qxbt47WrVsbXzTbchGRypSUlMT3338PwIMPPkiTJk2IiIiguLiY7t27Exsba4xde/HiRe655x4GDBhATEwMAOXl5ZhMJrVRIlJpBg4cSFFREevXrzfGe8zIyGDkyJF07doV+Lnt+eSTT5gzZw6zZs0iJCSkwjK1SyJS1crKyoiOjqa0tJTVq1djb29vzLwOMH/+fLZv386CBQsIDAzk5MmTbN++nWHDhimgFZFKc3m7AxAfH8+OHTtYv349fn5+lJaWGtnSli1bmDJlCm+99RYBAQEVttW105V0NGoRX19f4uPjueuuu3jooYcAjC+ExWKhdevWuLu7G1+my5eLiFSWqKgoNm3aREFBAbt372bSpEns3LmTCRMmcOrUKX766acKQW1ZWRn169ev8EiMyWSivLxcbZSIVIpBgwZRVlbGunXrcHJywtnZmcGDB1NYWMirr75q9EYzmUwAtGjRgtzcXM6ePWuUoXZJRKrSiRMnOH36NDk5OdjZ2fHPf/6To0eP8tRTTwHg6OiIxWIBYOLEidjb2xuTS994441ER0dr6AMRqTSzZs1i9OjRxMbGsmjRIgAmT55My5YtiYiIIDs7GwcHB6PN6du3L/Xr1+fw4cMAFUJeXTtdSUeklmnTpg0rV67EwcGBgwcPkpmZSVZWFosWLcLZ2dmYRENEpCosX76coqIiXn/9debNm8emTZuws7Nj27ZttG/fnrlz5zJ9+nRjfXt7e2wPgHh6elYoyxaaiIj8EYMGDeLixYu8/fbbuLq6ApcmZ/X39yc+Pp6TJ0/yxhtvsHnzZmMbNzc3/Pz8cHFxqVCW2iURqQqPPvoocXFx9O/fn0cffZT169fTrFkzpk2bxubNmysEtrbrptatW/9qWepZKyJ/1MiRIzlw4ABBQUF4eXmxadMmBg4cSG5uLpMnT6Zx48b84x//4NtvvzXanLNnz+Ls7IyXl1f1Vv4vQi11LXXs2DEGDhyIh4cHvr6+eHp6kpycbIxVqzsbIlIVTp8+TcuWLXF3d8diseDk5ERERATz58/n4sWL9O/fH4CtW7dy5MgR2rZtyxtvvEFJSYnxRICISGUpKSmhsLCQevXqGe8dO3aMlStXcvToUfz9/fH19SUvL4/XX3+djz/+mDZt2vDxxx9jtVq5/fbbq7H2IlIbTJgwgR9//JEZM2bw/fff8/XXXzNt2jROnTpFREQE06ZNY86cOZw/f55p06bh6uqKnZ0dp06domPHjtVdfRG5zhw8eJCsrCyWL19udPb77rvvmDx5MnFxccybN49Zs2bx/PPPExERwaBBg3B2duarr77CxcWFO+64o5r34K9BYW0t1aJFCzZu3EhmZiaenp4EBwdjNpu5ePGi7raKSKUrLy+nvLyc7Oxso42xPfri4eFBcXGx0RMkPz+fjz76iN27d5OamoqPjw/r16/H3t6esrIyzRAqIpXGycmJqVOnMnv2bBITE+nbty+xsbG0bduW3r17k5GRQWlpKfb29tx3331s3LiR/Px8GjRowMsvv4ydnZ3aJRGpMhcuXCA7O5tHHnmEoKAggoKC6NGjB82bN2f69OmUlpYSExODt7c306ZNY8iQITg6OmJnZ0dxcbExEaKISGXJy8vj7NmzNGjQwHivVatWrFq1ilGjRjFlyhRWr17Niy++yMqVK9m/fz/FxcU0btyYxMREXTtdJaVytVhAQAABAQHG67KyMgW1IlIlTCYTJpOJ8PBwNmzYQG5uLnXr1gUuhSVwaXza8vJyvLy8mDlzJsXFxTg7O+Pi4oLJZNLNJBGpEm3btqV79+7s3LmTQ4cO0atXL8aOHWvMtp6UlMTu3bvp06ePMbat7QeG2iURqSpWq5Xi4mIOHz5MQUGB8b6joyMPPfQQTk5OTJ48mTp16jBy5Ejef/993nrrLQoLC3FzcyMyMlI3ukWk0rVt2xY3NzfeeOMNoqOjgUvtlbe3NwkJCURFRTFx4kRWrVrF6NGjKSkpwdHR0RgqStdOV0fPuotBf8RFpKr16NGD2bNnG0EtXJrg0BbI2ibomTt3Lnv27MHV1dV4T3/URaQquLm5ER4ejslkYvv27fj6+mJvb4/VasXZ2Zm+ffvy5Zdf8u233wI/Xy+pXRKRqmQ2m6lbty69e/fm7bffJj09vcLy++67j0mTJrFkyRJ27dqFu7s7UVFRxMbGEhUVpaBWRCpNUlISM2fOZPbs2Rw4cIDOnTuTmprKJ598Alxqr8rLy2nUqBFTp04lMzOTtLQ0ABwcHIygVtdOV09hrYiI/Knq1KkDXLoDC5CZmYmdnZ0xZuTIkSNJTU2ld+/exjaatEdEqpKvry/x8fHcddddxvjYtvH7LRYLrVu3rvC4H6hdEpGqsWjRIlatWmW8Dg0N5cKFC7z11ltkZ2dXWPeBBx6gY8eOHDx4ELj0pOTlFNSKyB8VFRXFpk2b+Omnn/jkk0945ZVX8PT0JDc3l1dffZW9e/cCP18XtWjRgtzcXHJycgAqzIeka6erp0hbRESqxeVBiJOTE6WlpYwZM4asrCy2bdumHiEi8qdq06YNK1euBC5NnlG3bl1MJhOLFi3C2dnZmERDRKSqWCwWvvrqK9LT03F3dycsLIw+ffrw73//m40bN+Lk5ERYWBgNGzYELt0Ad3R0JCsrC1A4KyKVa/ny5RQVFfH666/j7u5OcXExAwYMoKCggGeeeYZJkybx0ksvkZeXZ3S0cXNzw8/PDxcXl2qu/V+bwloREakW5eXlmEwmPDw8sFqtREREcO7cObZu3YqDg4PGMxKRanHs2DEGDhyIh4cHvr6+eHp6kpycjNlsxmq1VughIiJSWcrKynB0dMTZ2Rmr1cprr72GxWIhMjKSuLg4SkpK2LJlC7m5uQwbNoxmzZpRWFjI+fPnadeuXXVXX0SuQ6dPn6Zly5a4u7tjsVhwdnYmIiKC+fPnM336dObOncuiRYtYsWIFO3bsoFWrVnz88cdYrVZuv/326q7+X5p+BYuISLWwPQYTEBDAmTNn8Pb2VlArItWuRYsWbNy4kczMTDw9PQkODsZsNqtdEpEqZZsh/cSJE3Tv3p3i4mJSUlIAiIyM5IknnqBu3brs2LGDwYMH07x5cwoKCrBarTzyyCPVXHsRuZ6Ul5dTXl5Odna2ce3j6OgIgKenJyUlJeTl5REUFMSsWbP49NNPefvtt8nJyaFBgwa8/PLLRpumHv+/j644RUSkWrVu3ZqxY8cyatQo7O3tFYiISLULCAggICDAeF1WVqZ2SUSqXFZWFh4eHkRGRmI2m1m+fHmFwHbEiBF06dKF7777juPHj1O/fn0GDx6soaNEpFLZJn4ODw9nw4YN5ObmGhNEOzk5AZcCXavVSpMmTWjSpAnh4eEVytBvuj/GVF5eXl7dlRAREQH9URcREZHay2KxsG3bNnr06IGbmxvHjh0jMTGRI0eOEBYWxuDBg391OwW1IlJV8vLyjAmiAbZu3cr06dPZsmWLMfnqk08+SUhICH//+9+Bn4e7k99Pg26JiEiNoaBWREREaitHR0fuv/9+3NzcKCsro0WLFowePRp/f39SUlJ44403fnU7BbUiUlVsQa3VagUgMzMTOzs76tWrB0B0dDSfffYZ/fr1M7ZRUPvHKawVERERERERqQFsIYctgL355psZPXo0AQEBJCQksH379uqsnojUUrYJVi0WC05OTpSWljJ69GiysrLYtm2bMRyLVA51YRIRERERERGpoW6++WaGDx9OkyZN6NatW3VXR0RqIdvQBh4eHlitViIiIjh37pwmiK4iOpIiIiIiIiIiNdjlEx9qjFoR+bPZev0HBARw5swZvL29FdRWIU0wJiIiIiIiIiIiIv/VuXPnWLNmDaNGjcLe3l5BbRVRWCsiIiIiIiIiIiJXTUFt1VFYKyIiIiIiIiIiIlIDmKu7AiIiIiIiIiIiIiKisFZERERERERERESkRlBYKyIiIiIiIiIiIlIDKKwVERERERERERERqQEU1oqIiIiIiIiIiIjUAAprRURERETkL8dqtVZ3FUREREQqncJaERERketIt27d8Pf3x9/fnx49elRY9v333xvL/P39mTJlyp9apxdffPFP+byqEBkZib+/P0899dSf9pmZmZkVzpftv8DAQLp27cqTTz5JQUHBn1YfG1s9tmzZ8rvL2LBhA/7+/rRt2/a/rnf5Mfjyyy+N9z/88EOioqL+53oiIiIifzUKa0VERESuU6dOnSIzM9N4nZqaWo21+WurU6cOPj4+3HDDDdXy+XXr1sXHx4cGDRrg7OxMdnY269evZ+zYsdVSnz/KxcUFHx8ffH19r3nb1157jTFjxnDq1KkqqJmIiIhI9bKv7gqIiIiISOVzcHCgtLSU1NRUBgwYAMDevXsrLJOrt3Tp0mr9/BUrVnDrrbcar5OTk5kzZw579+4lPT2dZs2aVV/lfofevXvTu3fv37VtYWFhJddGREREpOZQz1oRERGR65Dt8fLLe9Pawtp27dpdsf7JkyeJi4ujS5cuBAYG0qVLFyZOnMiPP/4IwI4dO4zHzF955RUAsrOzCQ4Oxt/fn/j4+Kuum+0R+AcffJCvvvqK8PBw2rVrR48ePXjnnXcqrGuxWFi0aBHdu3cnMDCQu+66i1mzZnHu3LkK66WlpREdHU1ISAi33nor4eHh7Nixo8I6tuEY3nvvPZ566imCg4O57bbbSEhIwGKx8Nxzz9GpUyc6dOjAlClTKoSCvxwG4fLH7jMyMhg3bhxBQUGEhoby3HPPUVZWZmxbUlLC7NmzCQ0NJSgoiAkTJrB37178/f3p1q3bVR+3X+6LTXFxsfHv/3UeL9+XtWvXkpSUxF133UW7du0YNmwYGRkZFT5n8+bN9O7dm7Zt2/Lggw/yxRdfVFi+bt06/P396d+/f4VtbMcmOzsbgPz8fFq1aoW/vz9Hjx79zWEQkpOT6datG23btiUyMpL09PQKy5ctW8aCBQsAyMrKwt/fnw0bNlRYJy8vjwkTJhAUFETnzp1ZsGCBxrcVERGRvwz1rBURERG5DnXs2JEDBw6wd+9eysvLOXHiBNnZ2fj6+tKkSRP2799vrGuxWIiKiiIrKwtHR0fc3d3Jycnh3XffJT8/n6SkJLp168Y//vEP3n77bZYuXUqvXr145plnOHfuHA0bNmTq1KnXXMcffviBYcOGYTKZKCkp4dSpU8THx9OuXTuaN28OQGxsLJ988gkAnp6e/PDDD6xdu5YjR46wdu1aAD744AMee+wxysrKcHBwwM7Oji+++IKYmBimTZtGZGRkhc+dMWMGBQUFmM1mzp07x7Jly9iyZQsnTpzA1dWVwsJC3nnnHdzd3Zk2bdr/3I8RI0Zw5swZrFYrFy5c4OWXX+bGG28kPDwcgCeeeIL3338fAFdXV7Zs2UJaWto1Hy+bgoICkpOTAfDz88Pf3x+4uvN4udWrV5OVlYWrqyslJSWkpqYyefJk1q1bB8DWrVuZMGECAPb29qSnpzN8+PAKZdx9992YTCa+++47cnJyqF+/Pvv27TOWf/755/Tr1489e/ZgtVrx8/OjZcuWHDp06Ir9eumll5g/fz4Ajo6OfPHFF8TFxVVYx93dHXd3d86fP4+dnR3169fHxcWlwjpTpkyhuLiYsrIyLly4wIsvvkjz5s35+9//fq2HWkRERORPp561IiIiItehG2+8ER8fH86ePcuRI0eMHrYhISFXrHvq1CmaNWtGYGAgu3btYu/evUYP0st7Uk6dOpXGjRtz4cIFhgwZwscff4zJZGLu3Ll4eHhccx3Pnj1LREQEaWlprFu3DrPZTHl5Obt27QJgz549RlD7wgsv8Pnnn5OSkoLZbObrr7/m0KFDWCwWnn76acrKyrj77rv57LPPSEtLIywsDIDnn3/e6N1p4+zszL/+9S8+/fRT6tWrB1zqKbt+/Xr279/P7bffDlAhdPxvGjVqRGpqKjt37qRhw4YARr0PHz5sBLVjx47lwIEDfPjhh9jZ2V3TsQoLCzN6q4aEhLB27Vrq16/PCy+8YJR1tefRJicnh5SUFNLS0nj44YcB+PLLL/npp5+AS8ccoE2bNuzevZu0tDR69uxZoYwGDRoQGBhIeXk5e/bsAeCzzz4zln/++ecAxjnt3r37r+5faWmpMQFd165d2bdvH/v27SMoKKjCelFRUYwaNQoAX19fdu7cecVwCq1bt2bv3r2kpqbStGlTgCt6WYuIiIjUVAprRURERK5TtmB27969RoDWqVOnK9Zr3rw5SUlJvPnmm2RkZLBmzRree+89oOL4oO7u7sydOxeTycR//vMfAAYPHkxoaOjvrmN0dDRms5lbb72VBg0aAHD+/Hng5yEcWrZsaYR87dq1Y/v27Rw4cIDAwEAOHDjA2bNnAXjyySdxc3PDwcGB+Ph4HB0dsVgs7Ny5s8Jn3nPPPdSvXx93d3duvvlm41gFBgZiMpmMsWGvdmzUwYMH4+bmRt26dY1jbtvW1oPZ1dWV0aNHYzKZ+Nvf/nZFb9//5fIJxmzBeE5ODjNnziQvLw+4+vNoExoaSrt27TCbzRVC2MLCQs6fP8+xY8eAS+eoTp062NvbExsbe0U5tiEZ9uzZQ3Z2NhkZGTRt2hSz2WyEtbt3766w7i+lp6dTUFAAXOpN7eLigqurK4888sg1HSeAiIgIXFxc8PDwoH379gBGAC0iIiJS0ymsFREREblOdezYEbgUotnC2l/rWWu1Wpk3bx6dOnUiLCyMpKQkLl68CEB5efkVZdqGKACu6Gl5Lezs7KhTp47x2tnZucJn5ufnA1RYB+Bvf/sbZvOly9icnBwATCYTjRs3NtZxcXGhfv36AEaYa3PDDTcY/3ZwcAAwetgCODk5VajH/3L5trZH8m3b2sbWtYWdNrYeuFdrxYoV7Ny5k127dpGWlsb69eupW7cu+/btY+HChcC1ncdf1tt27G3l2AJzAG9vb+Pfvr6+V5RzeVhrGxe5W7dutGrViuPHj7Nnzx7OnDmDl5cXHTp0+NX9u3wM4ss/z8fH578clV93+X7Zzq/GrBUREZG/CoW1IiIiItcpW1i7e/du8vPzadCggfFY+OVSUlJISkrCzc2NrVu3snPnTh599NFfLfPVV1/l3//+t/H66aefpqSk5HfV75dDAZhMpgqvbaHqL4cx2Lp1K7t27SIvL88IZMvLy8nKyjLWKSoqMoLcy8O/X/vc33rval0ewv6SrX65ubmUlpYa73///fe/+/Pg0gRytl7SBw4cAK7tPELFff7lsff09DTeu/z4//JcAAQEBNC4cWNycnKMcYQ7derEbbfdBsCiRYsAuPPOO3/zWHl5ef3qZ/za5/0vtiBfRERE5K9IVzIiIiIi16mbbroJb29vo1ehLbz9pSNHjgCXeiH6+PhQVFTEW2+9ZSy3bX/y5EkWLFgAwAMPPICDgwPp6eksXry4SupvG14hIyODLVu2APDNN98wadIkoqOjOXjwIO3btzdC3Tlz5lBYWEhpaSlz587FYrHg7OzMnXfeWSX1uxrt27fHZDJRVFREYmIi5eXl/Oc//2HNmjV/qNysrCwjpLX1Pr3a83g1XF1dadOmDQAvv/wyeXl5lJaWsmTJkl9d/+677wbg66+/xs7OjuDgYCNM/vrrr4HfHgIBoFmzZkawvWLFCoqKiigsLGTlypVXrGsLfIuKirBarUbvYREREZHrgcJaERERkevY5QHtb4W1tnE9s7Ky6NKlC506dTImxYJL431arVbi4+MpKiri5ptvZtasWYwYMQKA1atXG2OzVqYuXboYk32NHz+e4OBgHnroIUpLS+nQoQO33347jo6OTJs2DZPJxI4dO+jUqRPBwcGsW7cOk8nE1KlTjRCwOjRr1ow+ffoAsGzZMtq3b88999xDcXHxNZUTExND165d6dq1K6GhoXTv3p3s7GxMJhNDhw4Fru48Xou4uDjMZjPffPMNXbp0ISQkhO3bt1cYRsLm8iC2TZs2uLu7ExwcbAxD4OjoaJzLX2M2m4mLiwMuTc4WEhLCbbfdxtGjR40ybPz8/IBLvZVDQkJ47bXXrmm/RERERGoyhbUiIiIi17HLx6j9tfFqAe677z7GjRuHr68vJpOJpk2b8uyzzxpjf6amppKcnMz+/fsxmUzMmDEDR0dHxowZQ9OmTSsEuZXJZDLxwgsvMHLkSBo1akRxcTENGzZk6NChrFy50niM//777yc5OZk77rjDGDM2KCiIxMREwsLCKrVOv8fs2bN5+OGHueGGGzCbzQwcOJDx48cDP49x+7/k5uaSnZ1NdnY2+fn5uLi40K5dO5YuXWr0HL6a83gt7rzzTpYtW0aLFi2ws7Pj5ptvZtWqVcZEcJfr2LEj7u7uwM+T2Lm5uREYGGi8Z1v+W8LCwpg1a5YxJnFQUBBr1qy5Iqzt2rUrffv2xc3NDXt7e1xdXa9pv0RERERqMlP51c6cICIiIiIi1+SHH34gMTERLy8vQkJC6Ny5M1arlRkzZvDGG29w55138uKLL1Z3NUVERESkhvjt2RBEREREROQPqVu3Ltu3b+fMmTMA1KtXj6KiIi5cuABA//79q7N6IiIiIlLDqGetiIiIiEgVOnbsGAsXLuTLL78kPz8fR0dHmjdvTmRkpMJaEREREalAYa2IiIiIiIiIiIhIDaAJxkRERERERERERERqAIW1IiIiIiIiIiIiIjWAwloRERERERERERGRGkBhrYiIiIiIiIiIiEgNoLBWREREREREREREpAZQWCsiIiIiIiIiIiJSAyisFREREREREREREakBFNaKiIiIiIiIiIiI1AAKa0VERERERERERERqgP8Hd3EcrTUDIH0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "MAX INCOMING BANDWIDTH EFFECT SUMMARY\n", + "============================================================\n", + "\n", + "Theoretical Minimum:\n", + " SNARK1 time range: 1029.6 - 5241.6 ms\n", + " Time difference: 4212.0 ms\n", + " 5Mbps: 5241.6 ms\n", + " 25Mbps: 1785.6 ms\n", + " 50Mbps: 1353.6 ms\n", + " 100Mbps: 1137.6 ms\n", + " 200Mbps: 1029.6 ms\n", + "\n", + "Gossip (idontwant=False):\n", + " SNARK1 time range: 2306.0 - 11678.0 ms\n", + " Time difference: 9372.0 ms\n", + " Avg duplicates per validator range: 0.748 - 1.483\n", + " Overall avg duplicates per validator: 1.086\n", + " Total signature duplicates range: 688 - 1366 messages\n", + " 5Mbps: 11678.0 ms (avg dups: 0.812)\n", + " 25Mbps: 4605.0 ms (avg dups: 1.116)\n", + " 50Mbps: 2980.0 ms (avg dups: 1.270)\n", + " 100Mbps: 2404.0 ms (avg dups: 0.748)\n", + " 200Mbps: 2306.0 ms (avg dups: 1.483)\n", + "\n", + "Gossip (idontwant=True):\n", + " SNARK1 time range: 2336.0 - 12496.0 ms\n", + " Time difference: 10160.0 ms\n", + " Avg duplicates per validator range: 0.734 - 1.408\n", + " Overall avg duplicates per validator: 1.042\n", + " Total signature duplicates range: 679 - 1295 messages\n", + " 5Mbps: 12496.0 ms (avg dups: 0.964)\n", + " 25Mbps: 4722.0 ms (avg dups: 1.408)\n", + " 50Mbps: 3070.0 ms (avg dups: 1.018)\n", + " 100Mbps: 2441.0 ms (avg dups: 0.734)\n", + " 200Mbps: 2336.0 ms (avg dups: 1.087)\n", + "\n", + "Grid:\n", + " SNARK1 time range: 1394.0 - 9055.0 ms\n", + " Time difference: 7661.0 ms\n", + " Avg duplicates per validator range: 0.447 - 0.545\n", + " Overall avg duplicates per validator: 0.482\n", + " Total signature duplicates range: 411 - 501 messages\n", + " 5Mbps: 9055.0 ms (avg dups: 0.447)\n", + " 25Mbps: 2838.0 ms (avg dups: 0.490)\n", + " 50Mbps: 2313.0 ms (avg dups: 0.475)\n", + " 100Mbps: 1830.0 ms (avg dups: 0.451)\n", + " 200Mbps: 1394.0 ms (avg dups: 0.545)\n" + ] + } + ], "source": [ - "# Analyze the effect of max incoming bandwidth on SNARK1 aggregation time\n", - "# Test different bandwidth limits to understand network bottlenecks\n", - "\n", - "bandwidth_limits = [\n", - " 5, # 5 Mbps - Low bandwidth\n", - " 10, # 10 Mbps - Medium-low bandwidth\n", - " 25, # 25 Mbps - Medium bandwidth\n", - " 50, # 50 Mbps - High bandwidth\n", - " 100, # 100 Mbps - Very high bandwidth\n", - " 200, # 200 Mbps - Extremely high bandwidth\n", - "]\n", - "\n", - "# Use fixed signature size of 3072 bytes (3KB) as requested\n", - "signature_size = 3072\n", - "\n", - "# Base configuration parameters\n", - "base_config = {\n", - " 'mpi': False, # Use MPI for faster simulations\n", - "}\n", - "\n", - "# Test on both gossip and grid topologies\n", - "topologies = [\"gossip\", \"grid\"]\n", - "\n", - "print(\"Analyzing the effect of max incoming bandwidth on SNARK1 aggregation time...\")\n", - "print(f\"Using fixed signature size: {signature_size} bytes ({signature_size/1024:.1f} KB)\")\n", - "print(\"Using the refactored analysis framework.\\n\")\n", - "\n", - "# Run the bandwidth effect analysis using the new framework\n", - "bandwidth_results_df = analyze_bandwidth_effect(bandwidth_limits, signature_size, topologies, max_workers=5, **base_config)" + "# Analyze bandwidth limits\n", + "bandwidth_limits = [5, 25, 50, 100, 200]\n", + "print(\"\\nAnalyzing the effect of max incoming bandwidth on SNARK1 aggregation time...\")\n", + "bandwidth_results = analyze_bandwidth_effect(\n", + " bandwidth_limits, signature_size=3072, topologies=topologies,\n", + " max_workers=5, idontwant=True, **base_config\n", + ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 140, "id": "3daf94de", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "EXAMPLE 1: Mesh N Analysis\n", + "============================================================\n", + "Testing Mesh N: [4, 6, 8, 10, 12]\n", + "Topologies: ['gossip']\n", + "Running simulations in parallel with 5 workers (ThreadPoolExecutor)...\n", + "\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/5c14aaf4d379d3b8c1b929ea1a146659 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/f3143095f5456f43f6e0cc632a9f631d -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/25cc047137e50092758e8806e1c69458 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/5f78b2d65ae2d4dc1e47774a76d64db3 -t gossip --local-aggregation-only --report\n", + " [1/10] Gossip - 8 peers (idontwant=True): 3070.0 ms\n", + " [2/10] Gossip - 8 peers (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/f54da0ba20a0a3caf92f124b2cbb8ec4 -t gossip --local-aggregation-only --report\n", + " [3/10] Gossip - 4 peers (idontwant=False): 2915.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/cb53d809b0c0b7456ddf0ab66e2c63c0 -t gossip --local-aggregation-only --report\n", + " [3/10] Gossip - 4 peers (idontwant=False): 2915.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/cb53d809b0c0b7456ddf0ab66e2c63c0 -t gossip --local-aggregation-only --report\n", + " [4/10] Gossip - 4 peers (idontwant=True): 2865.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/cd4533120a3668fef23333313a338308 -t gossip --local-aggregation-only --report\n", + "\n", + " [4/10] Gossip - 4 peers (idontwant=True): 2865.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/cd4533120a3668fef23333313a338308 -t gossip --local-aggregation-only --report\n", + "\n", + " [5/10] Gossip - 6 peers (idontwant=False): 3078.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/0028aa6d6b2df67e66f14bd2f5d5d4dd -t gossip --local-aggregation-only --report\n", + " [5/10] Gossip - 6 peers (idontwant=False): 3078.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/0028aa6d6b2df67e66f14bd2f5d5d4dd -t gossip --local-aggregation-only --report\n", + " [6/10] Gossip - 6 peers (idontwant=True): 2908.0 ms\n", + " [6/10] Gossip - 6 peers (idontwant=True): 2908.0 ms\n", + " [7/10] Gossip - 10 peers (idontwant=False): 3175.0 ms\n", + " [7/10] Gossip - 10 peers (idontwant=False): 3175.0 ms\n", + " [8/10] Gossip - 12 peers (idontwant=False): 3165.0 ms\n", + " [8/10] Gossip - 12 peers (idontwant=False): 3165.0 ms\n", + " [9/10] Gossip - 10 peers (idontwant=True): 3148.0 ms\n", + " [9/10] Gossip - 10 peers (idontwant=True): 3148.0 ms\n", + " [10/10] Gossip - 12 peers (idontwant=True): 3322.0 ms\n", + " [10/10] Gossip - 12 peers (idontwant=True): 3322.0 ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "MESH N EFFECT SUMMARY\n", + "============================================================\n", + "\n", + "Theoretical Minimum:\n", + " SNARK1 time range: 1353.6 - 1353.6 ms\n", + " Time difference: 0.0 ms\n", + " 4 peers: 1353.6 ms\n", + " 6 peers: 1353.6 ms\n", + " 8 peers: 1353.6 ms\n", + " 10 peers: 1353.6 ms\n", + " 12 peers: 1353.6 ms\n", + "\n", + "Gossip (idontwant=False):\n", + " SNARK1 time range: 2915.0 - 3175.0 ms\n", + " Time difference: 260.0 ms\n", + " Avg duplicates per validator range: 0.786 - 1.872\n", + " Overall avg duplicates per validator: 1.267\n", + " Total signature duplicates range: 723 - 1767 messages\n", + " 4 peers: 2915.0 ms (avg dups: 0.786)\n", + " 6 peers: 3078.0 ms (avg dups: 1.187)\n", + " 8 peers: 2980.0 ms (avg dups: 1.270)\n", + " 10 peers: 3175.0 ms (avg dups: 1.872)\n", + " 12 peers: 3165.0 ms (avg dups: 1.223)\n", + "\n", + "Gossip (idontwant=True):\n", + " SNARK1 time range: 2865.0 - 3322.0 ms\n", + " Time difference: 457.0 ms\n", + " Avg duplicates per validator range: 0.840 - 1.767\n", + " Overall avg duplicates per validator: 1.202\n", + " Total signature duplicates range: 773 - 1626 messages\n", + " 4 peers: 2865.0 ms (avg dups: 0.840)\n", + " 6 peers: 2908.0 ms (avg dups: 1.012)\n", + " 8 peers: 3070.0 ms (avg dups: 1.018)\n", + " 10 peers: 3148.0 ms (avg dups: 1.370)\n", + " 12 peers: 3322.0 ms (avg dups: 1.767)\n", + "\n", + "============================================================\n", + "EXAMPLE 3: Group Validator Count Analysis\n", + "============================================================\n", + "Testing Group Validator Count: [128, 256, 512, 768, 1024]\n", + "Topologies: ['gossip', 'grid']\n", + "Running simulations in parallel with 8 workers (ThreadPoolExecutor)...\n", + "\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/b36f6bd57f292e3517621a880749618b -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/1723a56cd8b682db7c3f79c5b33bd75b -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/ce1fe52d619e21e91946fea6f54e6a28 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/9cf90d4b28647a06658eb967c3836822 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/38c5cc59deac5b498d46c1713552095e -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/35272a53e3f3298b6a04797783920385 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/d509a5c90624c690acbdac5fc0e62ce2 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/39e7aeee835129913728c1bf6e492fd1 -t gossip --local-aggregation-only --report\n", + " [1/15] Gossip - 128 validators (idontwant=False): 658.0 ms\n", + " [2/15] Gossip - 1024 validators (idontwant=True): 3070.0 ms\n", + " [3/15] Gossip - 1024 validators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/be8e4379604fc7f09a7738c193affd6a -t grid --local-aggregation-only --report\n", + " [1/15] Gossip - 128 validators (idontwant=False): 658.0 ms\n", + " [2/15] Gossip - 1024 validators (idontwant=True): 3070.0 ms\n", + " [3/15] Gossip - 1024 validators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/be8e4379604fc7f09a7738c193affd6a -t grid --local-aggregation-only --report\n", + " [4/15] Gossip - 128 validators (idontwant=True): 610.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/75bf22407a2005d400c5e6939f27b576 -t grid --local-aggregation-only --report\n", + "\n", + " [4/15] Gossip - 128 validators (idontwant=True): 610.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/75bf22407a2005d400c5e6939f27b576 -t grid --local-aggregation-only --report\n", + "\n", + " [5/15] Grid - 128 validators: 548.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/9f06491a7caeccc6bd47f3467471fe84 -t grid --local-aggregation-only --report\n", + "\n", + " [5/15] Grid - 128 validators: 548.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/9f06491a7caeccc6bd47f3467471fe84 -t grid --local-aggregation-only --report\n", + "\n", + " [6/15] Grid - 256 validators: 677.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/40e1937468ff1104519607390f8aeb8e -t grid --local-aggregation-only --report\n", + "\n", + " [6/15] Grid - 256 validators: 677.0 msrun: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/40e1937468ff1104519607390f8aeb8e -t grid --local-aggregation-only --report\n", + "\n", + " [7/15] Gossip - 256 validators (idontwant=False): 1142.0 ms\n", + " [8/15] Grid - 1024 validators: 2313.0 ms\n", + " [7/15] Gossip - 256 validators (idontwant=False): 1142.0 ms\n", + " [8/15] Grid - 1024 validators: 2313.0 ms\n", + " [9/15] Gossip - 256 validators (idontwant=True): 1126.0 ms\n", + " [9/15] Gossip - 256 validators (idontwant=True): 1126.0 ms\n", + " [10/15] Grid - 512 validators: 1171.0 ms\n", + " [10/15] Grid - 512 validators: 1171.0 ms\n", + " [11/15] Gossip - 512 validators (idontwant=False): 1705.0 ms\n", + " [11/15] Gossip - 512 validators (idontwant=False): 1705.0 ms\n", + " [12/15] Gossip - 512 validators (idontwant=True): 1672.0 ms\n", + " [12/15] Gossip - 512 validators (idontwant=True): 1672.0 ms\n", + " [13/15] Grid - 768 validators: 1949.0 ms\n", + " [13/15] Grid - 768 validators: 1949.0 ms\n", + " [14/15] Gossip - 768 validators (idontwant=False): 2389.0 ms\n", + " [14/15] Gossip - 768 validators (idontwant=False): 2389.0 ms\n", + " [15/15] Gossip - 768 validators (idontwant=True): 2479.0 ms\n", + " [15/15] Gossip - 768 validators (idontwant=True): 2479.0 ms\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABWsAAASjCAYAAAAIHGiEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FFUXwOHfbhrpgSQkoQkECJAECC30jnQB6UoRBQQEFbAhiIiCAiog8IEKSJUSegmh9w4mAqGF0AKElt6z2d3vj3XHLCkkSkzE8z4Pj9mZO3fuzM5OzNkz56r0er0eIYQQQgghhBBCCCGEEIVKXdgDEEIIIYQQQgghhBBCCCHBWiGEEEIIIYQQQgghhCgSJFgrhBBCCCGEEEIIIYQQRYAEa4UQQgghhBBCCCGEEKIIkGCtEEIIIYQQQgghhBBCFAESrBVCCCGEEEIIIYQQQogiQIK1QgghhBBCCCGEEEIIUQRIsFYIIYQQQgghhBBCCCGKAAnWCiGEEEIIIYQQQgghRBEgwVohhBAvnE8++QQvL69n/hs5cqTJdrt37+aVV17B19eXevXq8f777wMQFxfHJ598gr+/P76+vrRp04aTJ08W6DHodDquX79eIH1HRkbyzjvvUKdOHWrUqEHHjh0JDw9/5nanT5/mww8/pHXr1tSqVYsaNWrQtm1bxo8fT2hoaIGMtTB17NhRuVbOnz+fbZuLFy8qbfr27Zuv/lu1aoWXlxdt27ZVlm3cuFHpb8uWLc/sY8uWLUr7jRs35mv/mRXk9ZYXKSkpLF68mD59+lCvXj18fHxo2bIlH3zwARcuXCi0ceXXtWvXCnsIuYqIiGDSpEm0bduWmjVrKp/hiRMncuPGjSztjddW7dq1efjwYZb1me+1OTl69KjSxtvbO9t+AO7evZvjvdrHx4eGDRsyYMAAdu7cmeM433jjjSzr7ty5Q+PGjU3u+xkZGVnanTx5Umlz9uzZHI8nJ3379lW2nzx5cr63/y+6d+8eSUlJyuvM18CECRMKbVxz587N0/9DeHl5MXfu3CIzbiGEEC8OCdYKIYQQGP5oHDNmDFevXiU9PZ34+HhSUlIAmDlzJps2bSI2Npb09HQiIiKwtbUtsLEcO3aMV199lUWLFhVI/59++il79+4lMTGRtLQ0wsPDKV68eI7tMzIymDJlCgMGDGDr1q3cvXuXlJQU0tLSuHPnDhs3bqRnz56sXLmyQMZbWLp06aL8HBgYmG2bXbt2Zdv+36Sgr7dnCQ8Pp0uXLsyYMYOQkBDi4+PRaDTcv3+fbdu20bt3b1asWFEoY8ur8+fPM2DAAL788svCHkqOgoOD6dKlC2vXruXOnTukpqYqn+GAgAC6devGqVOnst02KSmJ6dOn/6X9rl+/Xvk5IyODDRs25LsPjUZDdHQ0p0+f5v3332f58uV52u7x48e8+eabPHnyBIAmTZowe/ZszM3Ns7T7/PPP8z0uo/DwcIKDg5XX27ZtIzk5+S/396KLi4tj+vTptG/fnpiYmMIejhBCCFHkmD+7iRBCCPHvtX79elxdXbNdZ2Vlpfx84cIFJduqR48evP3225iZmQEQEhKitF+5ciWWlpZ4enoWyHgfPnzIm2++CUDVqlULZB/G43F1dWXJkiVotVpKlCiRY/sZM2awatUqAKpUqcKIESOoXr06iYmJbN26leXLl6PT6Zg6dSo+Pj7UqlWrQMb9T+vcuTOzZ88GYOfOnXz88ceoVCqTNrt37wbA3NycDh06/O19dujQgUaNGgHg6Oj4t/t7ln/iestNXFwcQ4cO5d69e5iZmTFkyBA6duyIWq1m//79zJs3D41Gw7Rp0/Dx8cHPz+8fH2Ne9OvXj4yMDOrXr1/YQ8nR559/TkpKCra2tnzyySfUqVMHnU5HUFAQ8+bNIy0tjc8++0y5pp+2Y8cOevfuTYMGDfK8z5iYGPbt22eybP369QwfPhy1Oueckc6dO/Phhx8CoNfrycjI4PDhw3z11VfodDp++OEHevXqhbW1dY59JCQkMGTIECIiIgCoX78+8+fPx9LS0qTd+fPn+eCDD7h9+3aej+tpmQPSAImJiQQGBtKzZ8+/3OeLbObMmQQEBGRZ7uHhwaFDhwByfW8L2uDBg+nVq5fyOigoiK+//hqAiRMnmjwNYWdnh7W1dZEYtxBCiBeHBGuFEEK80FxdXXF3d39mO2MWLRj+qH/ppZeU18YMqZIlS1KjRo3nP8hM9Hp9gfYPfx6Pp6cnVapUybXt+fPnWbZsGQDe3t6sWrXK5I9RHx8fbGxsWLBgATqdjmXLlr0wwdqyZcvi5+dHcHAwDx484LfffqNOnTrK+itXrnDr1i3AkLGXW8A7r6ytrf/RP/b/iestN4sXL+bevXuA4ZH6gQMHKuuqVKmCg4MDX3zxBTqdjk2bNhXZYG1hn8dniY2N5erVqwA0bdqU3r17K+sqV67MhQsXOHToELdv3+bu3buUKVMm236+/PJLNm/ejIWFRZ72u3XrVtLT0wEoX748t27d4t69exw9epRmzZrluF2xYsWy3Ldff/11Dhw4wJEjR0hISODmzZtUr1492+3T0tIYOXIkV65cAaBWrVosXLiQYsWKmbT78MMP2b59OzqdDpVK9ZfeR41Go5QsKVOmDJGRkWi1WtatWyfB2hzkdJ7NzMzy9Pu6oNnZ2WFnZ6e8dnBwMPk5uzEWhXELIYR4cUgZBCGEEP95rVq14pNPPlFef/zxx0oNUC8vLyWYFBERgZeXFwMGDFDa/v777wwbNoy6detSo0YNunXrxqpVq9DpdFn2c/78eUaNGkXDhg2V2reTJ09WajieOnWK5s2bK+03bdqk1MR7lhMnTjB8+HAaNWqEj48Pbdq0Ydq0acrjv/BnHT4jY43GzMf+tMzZTx988EG2gcQ33niDMWPGsGTJEpNajcZ6lv7+/hw5coTWrVvj4+PDW2+9pbR5/Pgx06ZN4+WXX8bX1xd/f3+GDx/O6dOns+wnp7qUmesLZq41aVw2ffp0Dh8+TO/evalRowbNmjVj5syZpKam5njcRplLGzxdKzMoKCjbdps3b6Zv3774+/vj4+NDo0aNGD58uJLRnJvcatZu27aNbt264evrS4sWLZg/f3621xkYglXz5s2jU6dO1K5dmxo1atCqVSsmTpyYr+stPT2dxYsX0717d/z8/PDz86NPnz6sX78+S8DFWIP33Xff5aeffqJ+/frUqlWL+fPn53i8mzdvBgxZxP369cuyvkePHnzzzTfs3buXKVOmmKxLTExkzpw5dOrUiZo1a1K3bl0GDRrEnj17svSTXX1gyPl8Zz6WGzduMGLECOrUqUPt2rUZOXKkEqQ31qrUarWAoa7zsz5TRhcvXmTcuHE0bdoUHx8fmjdvzoQJE5RMUKNTp04pYzxw4ACbN29Wamu3aNGC2bNnZ1uDNTNzc3Mlk3X//v0sWbKE6OhoZf2cOXM4ceIEJ06cwMPDI8v2xozy69evK1/e5IUx49TOzs7k/Vu3bl2e+3j6OIyeDrwaabVaxo4dq9xDqlevzs8//5xt6ZoDBw6g0+lo166dyRcF+XHgwAGioqIA6N27Nw0bNgQMvxuMweKnXblyhbfffpvatWtTp04dxo4dy6NHj5Tr7unr5/Tp0wwYMICaNWvi7+/PpEmTSExMNKmbamRc9vXXXzNt2jT8/PyoXbu2Un7CeG9o166dcn8aN24cN2/ezDLO6OhoJk2aROPGjalZsyavv/46ISEhyr29VatWJu3PnTvH8OHDlWu6fv369OvXT/mcAwwYMMAkE7l169bK76Xcar/m5140YMAAvLy8ePXVV3n48CEffvgh/v7+1KxZk0GDBj33Otg5jds4jn79+hEeHs7bb7+Nn58fDRo0YOrUqaSlpREaGsrgwYOpWbMmDRo04LPPPiMxMdGk//y8Z0IIIV4MklkrhBDihfb48eMc1zk7O+c5Qyw7+/bt47333kOj0SjLLl++zJQpU/j999+ZMWOGsnzPnj2MGTPGpG1ERASrV6/m8OHDrF69+i+P46effuL77783+YM1IiKCZcuWERgYyLJly/5y2YZz584BYGFhQb169bJt4+TkxPDhw3PsIykpiVGjRinBUWM23LVr1xg0aJBJ0Cg9PZ0DBw5w8OBBPvnkk2wnDMqvo0eP8ssvvyjn5+HDhyxatIgLFy7wyy+/KOUustOhQwe+/vprNBoNQUFBfPrpp0rQy/i4uI2NDa1btwZg+fLlTJ061aSPqKgoDhw4wPHjx9m6dSvly5fP9zEsXrzY5HqKjIzkhx9+oGTJktm2HzduXJag5b179wgICODMmTM51uDNLDk5mQEDBnDx4kWT5SEhIYSEhHD48GFmzZqV5fydOHHCpJZvTtnokZGRSuDYx8cn28+ilZUV3bt3z7L80aNHvPbaayaBzdTUVE6ePMnJkycZNGgQn3766TOP8Vlu3rxJ7969SUhIUJbt27eP69evZzvRVV5t2bKFCRMmmNwPHjx4wPr16wkKCuLHH3+kbt26WbZbtGiRyRcSkZGRLFiwAHNzc0aNGpXj/uzs7GjRogX79+8nPT2d6dOnM3PmTKpVq0bDhg1p3bo1tWvXznH7Fi1aEBISQkxMDPPnz6dLly64ubnleoznz59XJlxr27Yt/v7+vPTSS9y+fZsDBw7w+PHjHEvUZKbT6UhMTGTXrl0cPXoUMDwuX65cuWzbf/755+zdu1d5/f3335tkRmZWt25devfuTatWrfL0pVh2MgceO3bsiLu7uzLOdevWMWnSJJP2Fy5cYMCAASZPc+zYsYMLFy5kW+d2//79jBo1SvlCIDU1lbVr1yqZ0jnZuHEj8fHxyms/Pz/S09N58803Ta6hqKgotm/fzqFDh1i+fLlyf05ISKBfv37KFxMAZ8+eZeDAgVSoUCHL/s6fP8/gwYNJS0tTlsXFxfHbb7/x22+/AdCtW7dcx5yTv3ovio2NpU+fPkRGRirLTp48yZtvvsn+/fuxt7f/S+PJr/v379OnTx/lPpKcnMzy5cu5fv06v/32m/K7MTU1lXXr1hEXF8cPP/wAkK/3TAghxItDMmuFEEK80Hr27Enz5s2z/Xf9+nUA1q5dy/jx45VtJk6cyKFDh2jbti2HDh1SHm8sXbo0hw4dYs6cOaSkpDBx4kQ0Gg3ly5dnyZIl7Ny5k5EjRwKGYMz+/fsBQ7DS2NbR0ZHvv/+eoKAgPvroI8AQRFuwYAF+fn4mf/i3b9+eQ4cOMXjw4ByPLyQkhFmzZqHX6ylbtiwLFixgx44djBkzBnNzcx4/fsy7776LVqtl8ODBSl09gDp16nDo0CGTY3+a8Y/c4sWLmwTTdDodDx48yPbf0zQaDWXKlGHjxo0sXbqU3r17o9frGTt2LNHR0Zibm/P++++zY8cOFixYQNmyZdHr9XzzzTfKH/l/x7Vr12jWrBkbNmxg1apVVKtWDTBkLG7atCnXbUuUKEHjxo0BQ+D/zJkzSp/h4eEAtGnTBmtra3Q6nVLbt1atWmzatIldu3YxdOhQwJAddezYsXyPPzo6Wqmda2Njw9SpUwkMDOTjjz9WMvoyu3XrFocPHwYMmX5BQUFs2bKFJk2aKOtv3LjxzOttxowZSnCkc+fObNy4kTVr1ijnY9euXSxevDjL/uPj42nfvj07d+5k1qxZSg3ep2X+IiW3Ce6ykzkD9Y033mDr1q0sXboUb29vAJYtW8aOHTvy1Wd2rl27ho+PD+vXr2fFihVKcPz27ducO3dOqbFpDBLVqlXrmZ+pe/fuMWnSJDQaDSVKlODbb78lMDCQzz//HBsbGxITExk9enSW7DowfHkyduxYAgMDlZquYAjMPctXX32lXPtg+AyHhoayaNEi+vXrR8+ePblx40a22zo5OTFu3DjAEGgy1u/MTeZrq3PnzsCfGejPmmhs/fr1SqZitWrVqFevnnIPtbGx4csvv8wySRgYgolP10L98ccfc9zPwoULs2SH5sfDhw+VwKyfnx9ly5albdu22NjYAIYyEJmDsgBTp05Vlg0ZMoTt27czf/580tPTs0y2pdVqmTJlClqtFjMzMz766CMCAwOZMWNGju+VUXx8PAMGDCAoKIg5c+ZQsWJFli9frgT9hg0bRmBgIEuXLqVixYokJCQwceJEZfuff/7ZpMzLhg0bWLNmDb6+vtlmDK9du5a0tDSKFy/OkiVL2Lt3L7NmzTLJ6AZDFrfxejBul/n3Unb+6r3o3r17ODk5sWrVKgICApQM3vj4eJOAfkF78OAB1apVY9OmTcyfP1/5XXr8+HEqVapEQEAAS5cuVeqUG79UAfL1ngkhhHhxSLBWCCHEf56rq2u2Nens7e1xd3dXAjHGenolSpTg2LFjSkZo//798fT0xMbGhj59+ij1bo2Pfh4/fpzY2FjA8Md5p06dqFChAm+99Rbjx49n5syZDBgwAEtLS5NMM2tra9zd3U1q5z0tc8mFOXPm0KpVKypVqsTw4cPp27cvYHh0+cSJE9jZ2ZnU1bO0tMTd3T3XiayMf2gbs7qMYmNjcwyCZ2fYsGF4e3vTsGFDypYty8mTJwkLCwMMkzONGDGCSpUq0apVKyUwqdfrleDn3+Ho6MisWbPw8fGhbt26fPfdd8q6vPzBnrnEgTEjNXPm6CuvvAIYztWuXbs4dOgQCxYsoHr16ri4uFCxYkWlrfE6yI/jx48rf7i/9dZb9OzZE09PT958881sJzUrX748wcHB7Ny5k4kTJ1KhQgVKlChhUoc5Li4u1+stKSlJCWR7eXkxc+ZMvL298fPzY968ecp2K1asyHbM48ePp2LFinTs2DHHzOXMJRzyUyv09u3bSjC6ZcuWjB8/Hi8vLxo2bMiCBQuUiQNzGlt+qNVqvv/+e3x9falfv75JCZQnT55kqbGZl89UQECAkkn3xRdf0KVLFzw9PXnttdcYPXo0YAjQZxdsbtGiBW+//Taenp4MGTJEubYylzvJibOzMwEBAUyfPp1GjRplyWS+cOECgwcPNskizqxnz55KzeCdO3dy4sSJHPeVkpKijN/Z2VkpDWD8rBjPQ37e9+LFizN06FC2bNlC06ZNs21jzFQuX768co1u2rRJCag+bxs2bFDujcYAZOZM+4SEBJMM7OjoaIKDgwHDl2UffvghlStXpk2bNlkycAFCQ0OVL8w6derEW2+9haenJ127dlWulZzY2Njw4YcfUqFCBdq3bw/A9u3bAcMXj6+//jq2trZUqFBBua5DQ0OVbGjjxHA2NjbK/dPPz485c+aYTM5pNHXqVM6cOUNAQACNGzfG3d0dDw8P5fdXXFwcYPgCLHMJCxcXl1zrvf7de9FXX32llCnK/ARIbk/dFITPPvuM6tWr06ZNG5NyRJ999hk1atSgYcOGygSFGo1GyYrOz3smhBDixSFlEIQQQrzQMmfGPk+ZHw396quv+Oqrr7K0MWYCZW6bObMN+NuP+RsznBwdHZWsQqNGjRqxcuVKAK5evapkVuaHh4cHYWFhxMTEkJSUlG3dx7x4eiKzy5cvKz8bAzlGPj4+ODk5mUyKlJtnBXy8vLxMxu3p6YmDgwPx8fFKPeLctG7dGhsbG5KTk9m9ezeTJk1SgrXOzs4mmaM6nY7ff/+dAwcOEBISwu3bt02CkjnVmM3N/fv3lZ+fLilQq1Yt5Y/5zFJSUjhx4gTHjx/nwoULSrkBo6eD70+7efOmElBs2LChErQHQ/CmVq1a7Nmzh0ePHhEdHW0yuZrxS45nybxNdhnCRnq9XqmZCphk9T2dtevm5oanpyeXLl16LteOs7OzyTgzZwBnLmGQH7mNP/Pr7Mb/9OfIOJ5n1aw1srCwoFu3bnTr1o3U1FTOnTvHwYMH2bBhA0lJSTx48IBt27bx2muvZdlWpVIxefJkXn31VSXjM6fHr4OCgpTMYC8vL5OM8lKlSnH//n3u3r3LsWPHsr0vde7cmTFjxhAREcG0adO4du0asbGxyhMEuSlbtizLli3j5MmTfPzxxwBMmjSJ7du3Kxmvz4NerzfJaLa1tVW+RChdurSyfN26dbz66qsAJmU7np6IMbuyF3fv3s1X+8zKlSuXJahq/F107969HL9YCw0NpUqVKspYjfdLIxcXF8qXL5/t9Xnjxg127NjBb7/9RlhYmElJhL9y74O/dy8C089M5s9vXj8zz0vm0hGZfx9lHl/m5cbx5ec9E0II8eKQYK0QQgjxF2T3CO7TjI+0Zg4IPe8/EI1Zi5mDWUaZ95vd+rxo2LAhYWFh6HQ6jh49Srt27QBDoC3zH+utWrXKNfD5dHZw5mzL3Mae3bqnA42ZAwLZMWalZtd/XlhbW9O2bVu2bNlCdHQ0q1evVrKCM2eO6vV6hg0bxpEjR7CwsKBNmzb0798fNze3XOuJ5sfT484cuDB6/PgxvXv35v79+5QoUYKXX34ZPz8/7t69m+e6nJmv7/xeW3mtA1m2bFmKFy9OTEwMoaGhpKenY2lpadImKiqKzp0706hRIzp16kSrVq3yfO1kJ7/XztMT6uVW3ziv8tpHdsf29KRaee1r79697Ny5k6ioKMaOHUuNGjUoVqwYjRs3pnHjxjRv3lyZ+C+3x+urVq3Ka6+9xooVK7hx44bJFwmZZS6BcPz4cY4fP55tu3Xr1mUbrC1WrBhlypShTJkyLF68mG7duhEVFcWiRYuws7NjxIgR2fbn6urK8uXLcXd3p2vXrqxevZqQkBDu3bvHrFmzskxa9XecPHnSJPia06RywcHBXLt2jSpVqphkM+flHvR3aqpn9znMy/VifGLEwsKCtLS0PN8rFy5cyKxZswDw9/dn5MiR1KxZk48//jjLl0X58XfuRWZmZib3lOzul/8EMzMzk/fy6YCzUXbHl5/3TAghxItDyiAIIYQQf0HmyW1mzZrF1atXlX/r1q3j1KlTyuOumSeUenqClI8//pjhw4czb948wPSPtbz8kWycOCw2NpZLly6ZrMv8mPLTGb151aNHD+UPy1mzZplMWGOUmpqabUA0s6eDDpknPHs6kHPx4kXlkdmqVatm6SMpKcmkfebJY7JjzMozunXrlvKod+bSALnJXAohcxmFzI91nzp1iiNHjgDw/vvvM3v2bCVY+3dkvtbOnz9vsi67mr6rV69Wgmg//vgjX3zxBd26dcsS6IOcr7cyZcooQY4TJ06YZMUlJyfz+++/A+Du7p6l3mxevsgw7tt4/hISErKdZG/JkiVER0ezfft25dzmdu08fPhQCTZmvub/6rWTV8bzmJ/PLJCllEDm48l87f9dSUlJbN++nRMnTmR7njNfB7mVcADDtW189NyY8ZjZrVu3TCZDys3+/fufWcKhZMmSfPnll8rrefPmZbmPGlWqVIlSpUoBhmOaOHGicmwrV64kJCQkT+PKi8wB6WdZt24dgElW8NNjOXXqVJbtMrc3/j7JrX1m2X0Ojfe7ihUrmvzOOnDgADt37iQ0NFQJ2hv3fePGDZP7/qNHj7h586ZJv6mpqcyfPx+A5s2bs3z5coYPH069evWyfOYgf7/n/s696EWQn/dMCCHEi0OCtUIIIV5ojx8/znEirL+T7dOoUSMlYPHtt99y8OBBwsPDWbBgAb1798bf35/p06cD0LhxYyUAsnTpUjZv3sytW7dYvnw5W7Zs4cCBA0pwLXMWkHEiqMxlFJ7Ws2dP5ef333+fAwcOEB4ezk8//cSaNWsAw2OW/v7+f+k4q1atqvwhePPmTXr37s327du5ffs2V69eZfny5bz88sv5rv/XsGFD5VHh1atX89NPPxEeHs7BgwcZO3YsYPiDvn///so2xqDnlStXOHbsGFqtlqCgIHbv3p3rvpKTk3nvvfc4f/48ISEhysRuYJilPi8aNWqEi4uL0h8Y/ojOXJYgc1Di4MGDXLt2jZMnTzJ58mRl+V/JrG7SpInyeOyiRYsICAggPDycn3/+Wamhm1nmcWzdupVbt26xY8cOFi1apCw3ZpjmdL3Z2dkpdS6vXLnCxx9/zKVLlwgJCWH06NHK+535/fkrhg8frryv06dPZ9asWVy7do3Lly8zY8YMZdIgGxsbhgwZAhgeJ65Tpw5gCPZNnz6dq1evcurUKUaOHKlky2Z37cTGxrJhwwZ0Oh2nTp1i7dq1f2v8RsbzeP/+fcLDw5XM6+x07dpVCaRNnjyZHTt2EB4ezpo1a5TMZ2dn52zrEf9Vbdu2Va7fjRs3Mm3aNC5evMjNmzfZvn27Scbpyy+/nGtfdnZ2OWaRgmkQc8KECSYBJuO/Hj16AIZSEnmZHK1169Z07doVMHyGJkyYkKfPkq+vL927dwcMj+FPnDjxmV8s5UV8fDx79uwBDO/VxYsXsxzj/v37lS+6tmzZQmpqKvb29jRr1gwwfNHy7bffcv36dXbt2sWUKVOy7MfLy4vKlSsDhnrZS5YsITw8nA0bNuQ5Sz4z45dON27c4KuvviIsLIzTp0/z9ttv06FDB+rVq8ejR48AQ41cMNzvxo4dS2hoKGfPnmX06NFZzqFGo1GWXbp0iTNnzij3DWM5jMzvV+byDMHBwVkC0Zn9U/eioio/75kQQogXh5RBEEII8ULLHMx8mr29fZ4zwJ5WrFgxxo8fzwcffMC9e/d4++23TdaXKVOGwYMHA4Y6dFOmTGHcuHEkJiYqdRSNPDw8eO+99wDDrOseHh5ERkYSEhJChw4deO211/j888+zHUfDhg0ZPnw4Cxcu5Pbt2yYTqIDhseDZs2f/rcc/x4wZg06nY8mSJdy8eVOZFf5pdnZ2z5z0xsjMzIzZs2czZMgQ4uLi+O6770wyVlUqFZ988gk1a9ZUlnXu3JmFCxei1Wp58803UalU6PV6atWqlWvGnIuLC+fOnaNXr14my5s0aWKSMfus8Xbo0MFkEpunt61Tpw7Ozs5ERUVx5syZbPvOy0RQT7Ozs2PChAlMmDCB1NRUk9m/vb29CQ0NNWnftm1bli9fjk6nY8WKFdlOvGMMcOR2vU2cOJErV65w7do1tm7dytatW036aNeuHW+++Wa+jyezEiVK8PPPP/P2228TGRnJwoULWbhwoUmbYsWK8f3335vUAZ0+fTr9+/fnwYMHLFmyhCVLlphsM2jQIDp27Ki87ty5s5KJ+OmnnzJhwoQ8XTt5Va1aNc6dO8e9e/fo2LEjzZs356effsq2raenJxMnTuTLL7/kyZMnypcTRnZ2dvzwww+5TiyYXzY2NsycOZMRI0aQmprKsmXLWLZsWZZ27733nsnkRznp3LkzAQEBnDx50mR5RkaGMrGihYVFjp+vfv36sWHDBsAw0djQoUOfuc8JEyZw/PhxHj9+zJUrV1i+fHmerr9x48axe/duEhMTCQsL46effvrbZUm2bdumfCnwyiuvZFuuoHTp0jRt2pRDhw4RHx9PUFAQ3bp1Y9y4cZw5c4aUlBR+/vlnfv75Z8BwXRg/l8bMU5VKxccff8zbb7+NVqtl+vTpypeAnp6ehIeHm7R/ln79+rFt2zZCQ0OzvTeMGDGCkiVLAvDaa6+xceNGbty4wZEjR5TMdgcHB1xdXU2+oLO3t6dRo0bK+5Nd4DTzvS9z1viHH34IZM0yz+yfuBcVVfl5z4QQQrw4JLNWCCGE+Is6derEsmXLaNGiBU5OTlhYWFCmTBkGDBjAmjVrTP6Aat++PStXrqRly5Y4OTlhaWnJSy+9xOuvv87atWuVzD+VSsWUKVPw9vbGysqKEiVK4OzsnOs4xowZwy+//ELr1q1xdnbGwsKC0qVLM3DgQDZv3mzy2PVfYWZmxkcffcSGDRt47bXXqFy5MnZ2dlhZWVG6dGlefvllvvzySw4fPpyvCdNq1KjB9u3bGTRoEOXLl8fS0hJHR0datGjBsmXLsvQ1atQoRowYgYeHB5aWllSrVo3p06dnCVA/rXLlyixdupQaNWpgYWGBu7s7b7/9NgsWLMhXEDtzyQPIGqx1cnJiyZIlNGnSBAcHB+zt7fH19WXGjBk0btwYMEx496zJvbLTo0cP5s+fj4+PD5aWlpQqVYrRo0czbdq0LG3r1q3LDz/8gLe3N9bW1ri4uNCkSRNWrlypZOju378fyP16c3R0ZMOGDXz00Ud4e3tjY2ODtbU1NWvW5KuvvmLOnDnPpYarl5cX27dv57333qN69erY2NhgYWFB2bJl6dOnD9u2baNly5Ym25QtW5bt27czcuRIKleuTLFixbC1tcXf35958+bx6aefmrTv1asX48eP56WXXsLS0pIKFSowfvx4vvjii789foDx48dTu3ZtbGxscHR0fGbpi379+rF27Vo6d+5MyZIlsbCwwM3NjR49erB58+ZnTh71VzRq1IitW7fSt29fypcvj5WVFZaWlri7u9OuXTuWLl3KyJEj89zfpEmTsgQpDx06pATxWrVqleNj6b6+vsqEiHfu3Mk1UGfk6Ohokn06d+7cPJWxcHFx4Z133lFeL1y4MNfM57zInD1snDwsO/369VN+NmZxV61alVWrVtGoUSPleunZs6dJ5nvm89q0aVMWLVqEn58fVlZWuLi48Oabb/LNN98obZ6u9ZyTYsWKsXz5ckaOHImnpydWVlY4Ojoq94xhw4YpbW1tbVm5ciWvvvoqTk5OSo3jVatWKb/bMu/3u+++o2fPnri6umJtbU3FihUZOXKkEhi/c+cO169fBwz3zldffRVXV1esrKyoUqVKtiU1jP6pe1FRlJ/3TAghxItDpc/PDBtCCCGEEP8SxgzBhg0bsnTp0sIdjBBCAPv27VMy2t3d3ZUvjB49ekTTpk0BGDZsGOPGjUOr1bJnzx6lbeYvAYKDg+nbty8AX3zxhfLz83Lu3DnS09Px8PCgVKlSJoHZdu3acevWLWrVqvXcSokIIYQQ4k9SBkEIIYQQQggh/gGzZ8/m2rVrALzzzjt0796dxMREfvnlF6WNr68vYHiq4dNPP1XqUH/xxRc0btyYmJgYZUKvzO2fp8DAQFauXAlAy5Yt+fDDD1GpVBw8eFCpo14Q+xVCCCGEZNYKIYQQ4gUlmbVCiKImICDApO7006pVq8b69euVSehmz57NggULcmzfokULfvzxx+c+zqtXr9K7d+8cyxPY2dmxefNmypYt+9z3LYQQQvzXSWatEEIIIYQQQvwDevXqhYODA6tXr+bKlSvEx8djbm5O6dKladmyJSNGjFACtWCY9K1UqVJs2rSJ69evk5SUhJWVFeXKlaNDhw4FNrGWl5cXq1ev5qeffiI4OJioqCjAUAO4fv36DB8+XAK1QgghRAGRzFohhBBCCCGEEEIIIYQoAvI+BbIQQgghhBBCCCGEEEKIAiPBWiGEEEIIIYQQQgghhCgCJFgrhBBCCFFEzZ07Fy8vL7y8vJg+fXqW9Xfv3lXWz50792/tyzhDfVE0YMAAvLy8qF69+t/qZ8+ePQwbNoxGjRrh7e1NnTp16NWrF4sWLSItLe05jTZ3rVq1wsvLi7Zt2xZI/wkJCdSsWVO5LgIDAwtkP7nJfF1OmDChwPdX0OdUCCGEEOKfJMFaIYQQQoh/geXLlxMWFvbc+3348CGffvopXbt2fe59FyXTpk1j1KhRHDp0iKioKDIyMkhMTOT8+fPMnDmT1157jeTk5MIe5t+2bds2UlNTldfr1q0rxNEIIYQQQoj8kmCtEEIIIcS/QEZGBlOmTHnu/X7yySds2LABnU733PsuKi5dusSyZcsA8PPzY8mSJezZs4dVq1ZRv359AC5evMjSpUsLcZTPx/r1601enzx5kjt37hTSaP4Za9eu5dChQ/z666+FPRQhhBBCiL9NgrVCCCGEEP8Sp0+fZuvWrc+1T71e/1z7K4pOnTql/DxixAgaN25MuXLlqFu3LrNmzUKtNvwv8YkTJwpriM/FlStXCA0NBaB8+fKA4f190bNrXV1dcXd3x9XVtbCHIoQQQgjxt0mwVgghhBDiX0ClUgEwY8YMEhMTn9k+PDyc999/H39/f3x9fenQoQMLFiwgPT1dadOqVSuTAKWXlxetWrVi48aNSs3Ry5cvK+uXLFmiLN+4caOy/NChQ8ry3bt3K8svXrzIuHHjaNq0KT4+PjRv3pwJEyYQERFhMtbM+9u3bx99+/bFx8eHFi1aEBsbm+3xBQYGUrVqVby8vOjYsSPR0dE5ngtLS0vl52+//ZbDhw+TkZEBgIuLCydOnODEiRPMnz/fZLv4+HhmzpxJu3bt8PX1pVGjRgwePJijR49m2cfmzZvp27cv/v7++Pj40KhRI4YPH05ISEiO43p6X19//TUtW7bEx8eHZs2aMWnSJB49epSn7cE0q/aLL77AwcEBgE2bNqHRaLK0N9Z6fffdd7lx4wYjRoygTp061K5dm5EjR3Lr1i2T9mlpacybN49OnTpRu3ZtatSoQatWrZg4cSIPHz7MdWzvvvuu8h4/nem7bNkyZd3evXsBiIuL4+uvv6Zt27b4+vri4+ND69at+fLLL4mLi8v2OJ6uWWt8T+rUqUP16tXx9/fnrbfe4ty5c7mfSCGEEEKIQiTBWiGEEEKIf4Hu3bsD8PjxY3744Ydc254/f55evXqxc+dOYmNjSU9P58aNG8yePZshQ4YogcqctGrVCnNzc8AQiDU6fvy48vPJkyeVnw8ePAiAtbU1TZs2BWDLli307duX7du38+jRIzQaDQ8ePGD9+vV069aNs2fPZrvvTz75hODgYDQaDW5ubjg5OWVpc+rUKT766CP0ej2lS5fml19+oUSJEjkeT5s2bbC2tgYME6kNHToUf39/hg8fzvLly0lLS6NEiRJKcBMgJiZGmXzs1q1bpKenExUVxfHjxxkyZAhbtmxR2i5fvpyPP/6Y4OBgYmNj0Wg0REVFceDAAQYOHJgl6Pm0uLg4+vTpw9KlS7l//z4ajYaHDx+ydu1aevbsSWRkZK7bA6Snp7Nt2zYASpcuTYMGDXj55ZcBePLkCfv27ctx25s3b9K7d2/2799PYmIiSUlJ7Nu3j2HDhqHVapV248aNY+7cuVy/fp2kpCTS0tK4d+8eAQEBDBw40KTt03r06KH8/PSkZ7t27QKgePHiNG/eHJ1Ox+DBg1m6dCl37twhPT0djUbD3bt3WblyJYMHD37mNbxs2TLlPUlMTESr1RIbG8vRo0cZPHgwwcHBuW4vhBBCCFFYJFgrhBBCCPEvMHToUF566SUAVq1axdWrV7Ntp9frmTBhAklJSTg7OzN//nyCgoL47LPPUKvVnDp1itWrVwOGWp916tRRtj106BBr167FycmJevXqKcvAEAzMnJGYOVhrbNOsWTOsra25d+8ekyZNQqPRUKJECb799lsCAwP5/PPPsbGxITExkdGjR2ebIazRaPjxxx/ZvHkzH330UZb1165d45133kGj0eDq6srSpUtxc3PL9dy5ubnx7bffKgFbgMTERA4cOMDUqVNp1aoVU6dONck+nTVrlhJkHTBgANu3b2fp0qWUKlUKvV7PtGnTSElJQafTsWrVKgBq1arFpk2b2LVrF0OHDgUM2ajHjh3LdXyzZ8/mxo0bqNVqxo8fT1BQEAsWLMDV1ZWHDx8ybdq0XLcH2L17t5KF3LlzZwBeeeUVZX1upRCuXbuGj48P69evZ8WKFZQsWRKA27dvK+/5rVu3OHz4MAC9e/cmKCiILVu20KRJE2X9jRs3ctxHkyZNlPdpx44dyvJHjx4pgdPOnTtjYWHBpUuXlHIOgwcPZufOnQQGBtK/f3/AMCnes4KtxizjqlWrsnbtWvbu3csPP/yAra0tarU6S8BYCCGEEKKokGCtEEIIIcS/gKWlJRMnTgRyn2zs6tWrXLt2DTBk4/r4+GBtbU2bNm2UAOymTZsAQ63PzCUCMtf9ND5S/vvvvxMXF0dwcDDJyclYW1ujVqt5+PAhN2/eJCwsjHv37gEomZwBAQGkpqYChsfxu3TpgqenJ6+99hqjR48GIDo62iRoZ9SpUydatGhBtWrVTALJYAhEDx06lISEBAB++uknypUrl6fz16ZNG3bt2sXw4cOpWLGiybqMjAyWL1/ON998A4BOp2Pnzp0AeHp6MmHCBCpXrkzDhg2ZNm0an332GXPnzsXMzAy1Ws2uXbs4dOgQCxYsoHr16ri4uJjsI6dSDsZjMgYOa9euTfv27bG2tqZ69epKNuq+ffuIj4/P9fgyl0AwBmvr16+Ph4cHYMiKfrr8hJFareb777/H19eX+vXrM2DAAGXdkydPAEMN3ODgYHbu3MnEiROpUKECJUqUUL5AALKUJ8jMzMyMbt26AYbgcHh4OGAIMhsntzNmjzs6OirbXb58mStXruDo6Minn37K6dOnOXbsmHIt58SYkf348WPl2m3bti379u0jODiYCRMm5Lq9EEIIIURhMS/sAQghhBBCiLxp1qwZ7dq1Y9euXZw9e9bkUXyjmzdvKj8vWrSIRYsWZWlz7do1MjIylFIH2WnTpg1ffvklWq2Wo0ePKgFgf39/njx5wsWLFzl58qSSHWtpaUmLFi0Aw0RXRo0aNTLpN/Pr7LKDK1eunOOYdDodDx48UF6fPn2a6tWr59j+aW5ubowZM4YxY8bw8OFDjh8/zo4dOzhy5AhgyDR+77330Gg0SnC0atWqSr1ggIYNG9KwYcMs4/r99985cOAAISEh3L59WwlAGtfnJCYmRgnmnj17lubNm2dpo9VquXLlCvXr18+2j7t37yqZzs7Ozjx48EA5T1WrViUyMhK9Xk9AQABjx47Nsr2zs7NJGYnixYsrP2fONk5JSeHEiRMcP36cCxcuZKlTm1sZBDCUQvjxxx8BQ3btu+++S1BQEABVqlTB29sbgLJlyzJy5EgWLFjAyZMnlWMrV64cTZo0oU+fPlStWjXXfX344YcMGzaMqKgoJQhvb29P3bp16dSpE506dVImlhNCCCGEKErk/1CEEEIIIf5FPv30U2xsbABDZunTcgvAGmUORubEzc2NGjVqAIYyB8Z6tQ0bNqRx48aAoRSCsQRCo0aNsLOzAwxZlHmROQhqZG9vn+s2lpaWlC9fHoB58+blOrGY0YwZMxg1ahSjRo1Slrm5udG9e3cWLVqkZKJqNBoiIiLQ6/VKu2fVRtXr9QwbNox3332X7du3U7VqVSZMmMC8efOeOS7I+7nK7Tg3bNigjDkqKoqhQ4cq/w4cOKC027hxY7bHk7k8RE5jevz4MV26dGHKlCn89ttvtGzZkunTpyuZ0nnx0ksvUbduXcBQt/bx48dKmQVjVq3Re++9x44dOxg1ahS1a9fGysqKO3fu8Ouvv9K9e3eT48pOjRo12Lt3L1OnTqVdu3a4uLiQkJDAgQMH+OCDDxgzZkyexy2EEEII8U+SYK0QQgghxL+Iu7s777zzDoBSaiCzzGUBxo0bx9WrV5V/Gzdu5NixY1y9elXJpMwcMM0cpIQ/SyEcOnRIqSHaqFEjJTv2xIkTSu1QYwkEMJQOMDpx4oRJn5knKcsuO/JZweYffviBGTNmoFKpSEhIYNasWbm2B7h06RJ79uxhz549nDlzJte2jo6OlChRQgkah4aGmmTG7tq1i9dff53PPvuM27dvc+rUKSUz9/3332f27Nn079//mXV0M+/P+Mh+06ZNTd6voKAg9u7dy+XLl2nfvn222+t0OqWsxbM8fvyY/fv356nt01avXs39+/cB+PHHH/niiy/o1q0bxYoVy1c/xtION2/e5IcffkCn02FmZkaXLl2UNvHx8Zw9e5Zz587x+uuvs3r1as6dO8eyZcuwtLREp9OxYsWKHPeRkZHB1atXOXLkCOXKleOHH37g2LFj7N27V8mKDgoKypIZLIQQQghRFEiwVgghhBDiX+aNN97IsVxAlSpVlCDo4sWLCQwM5MaNG6xbt45evXrRuHFj3n33XaW9lZWV8vOZM2c4f/688toYgI2NjUWr1eLi4kKVKlWoXbs21tbWxMXFKeUUWrVqpWzXtWtXJeg6efJkduzYQXh4OGvWrGHu3LmA4dH7Dh065Ou4zczMaNmyJTVr1qRTp06AoVarMZCck759+yo/jxkzhk2bNnHjxg0uXbrE999/r9TO9fb2pkyZMqjVaiU4evfuXSZPnsy1a9c4ffo0M2fO5OzZs+zYsQNXV1eSkpKUvg8ePMi1a9c4efIkkydPVpY/KzvXGKg8evQoCxcuJDw8nEOHDjFw4EDatGlDy5Ytsw3MG7eJjIwEDMH1zMFe47/p06cr7deuXZvrWHKS+Ti3bt3KrVu32LFjh0mZjWeVQQBo3769khlunPSsSZMmSq1kMJxHY0B8/PjxXLhwgcjISCIjI5XAeW5B/bS0NPr378/777/Pe++9x969e4mIiODhw4dKRrlKpcpzVrMQQgghxD9JatYKIYQQQvzLmJub8/nnn9O/f/8s61QqFRMmTGDIkCHExsZmedzbycnJ5NH1qlWrKo+UDxgwAGtra0JCQgDDY+tVqlRR6tU2aNAAMJQiqFu3rpJRWr9+fZM6p56enkycOJEvv/ySJ0+eZKmTamdnxw8//KCUTfgrxo0bx969e0lNTWXq1Kn8+uuvObZt3749vXv3Zt26dTx+/JhPPvkkSxtHR0e+/vpr5fXYsWM5ffo0t2/fZu3atVmCnJ999hk2NjbUqVMHZ2dnoqKiOHPmjEmGqJFxkq6cDB8+nP3793Pv3j1mzZplki2sVqsZN25cjhmsmScWe/XVV7Nt07FjR77++mtiY2M5fvw4d+/epUyZMrmO6Wlt27Zl+fLlSlZrdpmtjx8/fmY/NjY2dOjQgQ0bNijLjBOPZR7vjh07OHjwoPIvM0tLS4YNG5bjPmxtbfnss8/4+OOPiY6OVjLRM+vXrx8uLi7PHK8QQgghxD9NMmuFEEIIIf6F6tWrR9euXbNdV79+fdatW0eHDh1wcXHBwsICDw8PXn31VdatW2eSlTtw4EDatm2Lk5MTNjY2VKpUySSL01gKAUwnBzPWrX26jVG/fv1Yu3YtnTt3pmTJklhYWODm5kaPHj3YvHmzUrv0rypVqhRvvPEGAOfOnWP79u25tv/yyy+ZN28ezZs3x9nZGXNzc+zs7KhSpQpvvvkmO3bswMvLS2lfokQJ1q1bx+DBgylbtiwWFha4urrSpEkTfvnlF6XGqpOTE0uWLKFJkyY4ODhgb2+Pr68vM2bMUM7RoUOHcs06dXFxISAggIEDByr7KlGihLKvV155JdvtoqOjlbIGLi4uNGvWLNt2lpaWSiBXp9MREBCQ67nKTt26dfnhhx/w9vbG2toaFxcXmjRpwsqVK7G1tQXIc4kFYykEAAcHB9q0aWOy3tzcnLlz5zJp0iRq1KiBk5MT5ubmuLq60q5dO9asWfPM6+eVV15h1apVvPzyy5QqVQoLCwtsbW2pVasWU6ZM4bPPPsvnGRBCCCGE+Geo9E8XJxNCCCGEEEKIAhIcHKyUpujduzdffvllIY9ICCGEEKLokDIIQgghhBBCiAKVmppKXFwcMTExfPHFF8ryzFm2QgghhBBCgrVCCCGEEEKIAvbw4UNlwjqjVq1aUatWrcIZkBBCCCFEESXBWiGEEEIIIUSB8vDwwM3NjejoaJydnWnbti3jxo0r7GEJIYQQQhQ5UrNWCCGEEEIIIYQQQgghigB1YQ9ACCGEEEIIIYQQQgghhARrhRBCCCGEEEIIIYQQokiQYK0QQgghRDa2bduGl5cXX331FQB3797Fy8sLLy8vJkyYUMijy7tWrVrh5eVF27Zt87yNTqejefPmyvH+/PPPBTjCF8e1a9dMXp86dUo5h//73/8KaVSmNBoNAQEBvPXWWzRu3BgfHx/8/f3p168fixcvJikp6W/v45NPPlGO+8GDB89h1AbGa9n478cff8zSZuDAgSZtPvnkk+e2f6OzZ88q/c+dOzff20+bNg0vLy+2bt363McmhBBCiH8/CdYKIYQQQjwlMTGR6dOnA/Daa68V8mj+eUeOHDEJsgUEBCDTHOTs4cOHfPrpp3Tt2rWwh5KrJ0+e0LdvXyZOnMjRo0d58uQJGo2G2NhYfvvtN2bMmEGnTp0IDQ0t7KHmybFjx0xep6WlERwcXEijybvXXnsNlUrF119/TWxsbGEPRwghhBBFjARrhRBCCCGesnr1ah4/fkyDBg2oWLFiYQ/nH7dhwwaT17dv3+bkyZOFNJqi75NPPmHDhg3odDqT5X5+fhw6dIhDhw4xcODAQhqdQUZGBiNGjODixYsA1K9fn59//pm9e/eydu1aJYAYGRnJkCFDiIyMLNTx5kVwcDCpqanK63PnzpGenl6II8qb8uXL07BhQ6Kjo1m8eHFhD0cIIYQQRYwEa4UQQgghMtFoNKxYsQKADh06FPJo/nnR0dHs378fMASVjNatW1dIIyr6cso6trS0xN3dHXd3d+zs7P7hUZlav34958+fB6BFixYsXbqUZs2aUbZsWWrVqsXnn3/Ohx9+CBiugVmzZhXmcHNVpkwZANLT0zl79qyy/MSJEybri7L27dsDsHbtWlJSUgp5NEIIIYQoSiRYK4QQQgiRydmzZ3n48CEqlYrWrVv/7f6CgoJ444038Pf3x9fXl44dOzJnzhwSExOztI2Pj2fmzJm0a9cOX19fGjVqxODBgzl69GiWtps3b6Zv3774+/vj4+NDo0aNGD58OCEhIX9rvFu2bEGj0QAwevRoJbN4z549REdHZ7vN6dOnGTBgADVr1sTf359JkyaRmJiYY13P3bt306NHD2rUqEHTpk35/vvvuXnzptJ+48aNgGmd4EWLFvHBBx9Qo0YN/P39lUfg4+Pj+frrr2nZsiU+Pj40a9aMSZMm8ejRoyzjvHv3LmPHjqV+/fr4+fkxdOhQbty4wYABA/Dy8mLAgAEm7Q8ePMigQYNo1KiRUtt18ODBHDp0SGnTqlUrJUgI4OXlRatWrYDca9YmJiYyZ84cOnXqRM2aNalbty6DBg1iz549WcZtrNX67rvvcuPGDUaMGEGdOnWoXbs2I0eO5NatW9m+L5lt27ZN+fmjjz7CzMwsS5vBgwfj4eEBQGBgoBJEnDt3rnIcMTExzJ49m5YtW+Lr60uXLl1M+s5OWFiYsr0xIGyk1Wpp0KABXl5edOvW7ZnHAVCqVClKly4NmJZCML4P9evXz3Hb9PR0Fi9eTPfu3fHz88PPz48+ffqwfv36bIPuR48epW/fvtSsWZNGjRrx9ddfm2TzPu3w4cMMGDBA6btv375s3749S7tWrVqhUqmIi4tj165deTpuIYQQQvw3mBf2AIQQQgghihJjYLRMmTK4urr+rb4mT57M6tWrTZaFh4fzv//9j6CgIFasWIGLiwsAMTEx9O3b1yTwFhUVxfHjxzlx4gTTp09XaqIuX76cqVOnmvQbFRXFgQMHOH78OFu3bjXJis2P9evXA2BjY0OrVq24c+cOc+bMQaPRsGnTJt566y2T9vv372fUqFFotVoAUlNTWbt2LVevXs22/1WrVjFlyhTl9aNHj/jxxx+fWWbhxx9/JD4+Xnldo0YN4uLi6Nu3Lzdu3FCWP3z4kLVr13Lw4EHWrl2rBB/v3btHr169TALOhw8f5sKFC9jb22fZ3969exk9erRJaYPY2Fjl/VixYgX16tXLdcw5efToEa+99hoRERHKstTUVE6ePMnJkycZNGgQn376aZbtbt68Se/evUlISFCW7du3j+vXr7Nz585sA7BgyPw1BvE9PDzw9PTMtp1arcbf35/Nmzej0WgIDQ2lbt26Jm1GjRplks167do1PvjgA9zc3HIMklauXBlfX18uXLjAvn37SEtLw8rKCjAE+mNiYgDyHKwF8Pf3Z+PGjUqANj4+nkuXLpmse1pycjIDBgxQSkEYhYSEEBISwuHDh5k1a5ZyHgMDAxk3bpxyDaSmprJ06VICAwOzHdOvv/7KlClTTIK+wcHBBAcHEx4eznvvvacsd3V1pXTp0ty9e5ejR4/m69iFEEII8WKTzFohhBBCiEzOnTsHQJUqVf5WP4GBgUqg1tvbm6VLl7J161beeOMNAG7cuMHHH3+stJ81a5YSqB0wYADbt29n6dKllCpVCr1ez7Rp00hJSUGn07Fq1SoAatWqxaZNm9i1axdDhw4FDJMsPT3xUl4FBwdz/fp1wJD5Z2NjQ5cuXVCpVEDWUgharZYpU6ag1WoxMzPjo48+IjAwkBkzZpgEUI3i4uKYOXMmYAgGf/XVVwQGBjJx4kQl0JaT+Ph4PvjgA3bu3MmsWbOwt7dn9uzZ3LhxA7Vazfjx4wkKCmLBggW4urry8OFDpk2bpmz//fffK4Habt26sWXLFpYuXYqLiwt37tzJsr+VK1ei0+l46aWXWLNmDXv27GHChAmAIfhpLBWxdu1a6tSpo2x36NAh1q5dm+uxTJgwQQnUvvHGG2zdupWlS5fi7e0NwLJly9ixY0eW7a5du4aPjw/r169nxYoVlCxZEjDUFDZet9mJjY0lIyMDAHd391zHZuwT4PHjx1nWh4WFMWfOHLZt20bnzp2V5Zs2bcq13x49egCQlJRkkpm8c+dOAMzNzenSpUuufWTm7+8PwJUrV4iOjub06dPKFwY5BY1nzJihBGo7d+7Mxo0bWbNmDY0bNwZg165dSg1ZjUbD1KlT0el0mJmZ8fHHHxMYGMjUqVNNguVGxutNr9dTo0YNfv31V3bs2EGvXr0AWLBgAVeuXDHZxsvLCzAErIUQQgghjCSzVgghhBAiE+Pj825ubn+rn5UrVwJgZWXFggULlP7Gjx/P7du3OXDgAEePHuXmzZu89NJLStDK09OTCRMmoFKpqFy5MtOmTSM8PJwqVapgZmaGWq1m165dPHjwAEtLS0qUKEFiYqLJRGh/dYZ5Y1YtoATiypYti5+fH7/99hu3bt3i1KlTSqAsNDRUmYiqU6dOStatp6cncXFxWbJ/jx8/rjxaP2jQICWQ5enpyd27d1m6dGmOYytXrpwSkK5YsSJ6vV7JcKxdu7ZSA7R69er06NGDhQsXsm/fPuLj47Gzs+PAgQMAlC5dmqlTp2Jubvjf4G+//VbJWM5s6dKlREVFkZGRgZubG2lpaSYZqXFxcYAhQ9LS0lJZ/qxg6O3btzl8+DAALVu2ZPz48cq6BQsW0LZtW9LS0lixYgWdOnUy2VatVvP9999TokQJwBDU/+677wB48uRJjvs0Bmoh5/q6RpkzibNrO3z4cOVcjx8/XnnEP7vAbmadO3fmm2++ITU1lcDAQF5++WW0Wi179+4FoGnTpjg7O+faR2bGa1Cv13PixAl+++03wHC9lipVKkv7pKQkJaDs5eXFzJkzUasNeSvz5s3j5Zdf5vHjx6xYsYJhw4Zx8eJF5Zx27dqVN998EzBcqxERESxcuNCk/6CgIKV8yNtvv62UaRg5ciTbt28nJSWFLVu2ULVqVWUbY2D88ePHyhceQgghhBASrBVCCCGEyMSYffl3J4S6fPkyYAjuPB34bdSokRI8vHr1Kg4ODsoj/lWrVlUyWQEaNmxIw4YNTbbX6XT8/vvvHDhwgJCQEG7fvm0SZMv8c14lJycrwU8LCwv0er0SVKxYsaISDFu3bp0SKLt7966yfa1atUz6e/rxecDksX8/P78s7XML1lauXNnkdUxMjBKUPnv2LM2bN8+yjVar5cqVK1SsWJGkpCQAfH19lUAtGM63nZ1dtjWEL1++zO7duwkODubmzZtKMA7+2jkGTLIrGzVqZLLOzc0NT09PLl26lG0ZCWdnZyVQC1C8eHHl58xje5qTkxNmZmZotVru37+f6/iMwXdAKdGRWeaM88z7zxwQzo69vT1t27Zl27ZtHDx4kOTkZM6fP09UVBQA3bt3z3X7p3l4eFCmTBnu3r3L8ePHCQ4OBnLOqr1586ZSa7Zhw4ZKoBYMWd61atViz549PHr0iOjoaJPzVKNGDZO+atasmaX/zOVL3nnnnWzH8HT5BeM9RqfTERMTk+35FkIIIcR/jwRrhRBCCCGykTmY81cYA4KZA69GmTMWVSqVyetnBb30ej3Dhg3jyJEjWFhY0KZNG/r374+bmxujRo36y+MNDAwkOTkZMAT+RowYkW273bt3ExMTQ/HixbGwsMjXPjJnoD4rw/NpT9eVzWsWYnR0tPK4eU77ze49mjRpEmvXrkWtVtO8eXO6d+9OjRo1eP311/M17qdlHvezro2nWVtb59hXbiwsLPD29ub8+fM8evSIK1eumGR4Gmk0GqV2sLm5OT4+PlnaFCtWLN/7N+rRowfbtm0jJSWFAwcOKLVvnZycaNmyZb76AkNg9u7du+zdu1cJ3OcUrM0coM/LZzJzm6cD89kdd17OhbE277PGJ4QQQoj/NqlZK4QQQgiRiTFz0ZiJ+VcZH5m/fv06Dx8+NFlnnBQJoFq1apQoUUIJRoaGhpoEh3bt2sXrr7/OZ599xu3btzl16hRHjhwB4P3332f27NlKsPbvyFwCITfp6els3rwZMDxybmTMbDQ6depUlm3LlCmTr/aZPR3McnR0xMnJCTA8Qn/16lXlX1BQEHv37uXy5cu0b98eR0dHHBwcAEN2Y+aAeGhoaJYapBEREUrd2b59+7Jw4ULefPNNk1ITmWUO7D0rCJ25lMLx48dN1j18+FCp9VutWrVc+8mvzBNYTZs2jfT09Cxt/ve//ymZru3bt8fGxua5jqFBgwZKeYDt27ezZ88ewFBCI3MgP6+MGd6Zy34Ylz2tTJkyyj5OnDhh8hlLTk7m999/BwxlLIoXL25ybV+4cMGkL2OWeWYvvfSS8vO6deuUa/HixYusW7eOc+fOKSUjjIzZ9GZmZjg6Oj7zeIUQQgjx3yDBWiGEEEKITMqVKweQ6+Pijx494vjx49n+Mz7mbpxQKS0tjZEjR3Ly5EmuXbvG9OnTlRIIzZo1o1y5cqjVaqUO6N27d5k8eTLXrl3j9OnTzJw5k7Nnz7Jjxw5cXV1NgsgHDx7k2rVrnDx5ksmTJyvLn5Wd+7Tw8HAleFq9enWTwKfxn3FSM/hzojEvLy+lPEFgYCBLliwhPDycDRs2MHfu3Cz7ady4sfLo/PLly9mwYQPh4eH88ssvrFmzJl9jBpQJqY4ePcrChQsJDw/n0KFDDBw4kDZt2tCyZUvl0Xdj/dd79+4xceJErl69ytGjRxk3blyWfjOf49OnT3PhwgV+//13PvjgA2V55nNsZWWl/HzmzBnOnz+f45grVKigTEi2f/9+pk+fztWrVzl16hQjR44kLS0NgP79++f7fOSmV69e+Pr6AobA+IABAzhw4AAREREEBwczfvx4/ve//wGGQPiYMWOe6/7BENR+9dVXAcOxG+vcZg4k50eDBg1MXpcrVw4PD49s29rZ2SmfsStXrvDxxx9z6dIlQkJCGD16tDIW43n39vZWvlzYsmULP/30E9evXycgICDbch0vv/yych1MnjzZ5PPeu3dv6tSpw4oVK0y2MdbH9vT0zDbbVwghhBD/TfK8jRBCCCFEJnXr1uXEiRNcu3YtxzaHDx9W6rk+rXXr1vzvf/+jZ8+enD59mq1bt3Lx4kUGDRpk0q5ixYp8/fXXyuuxY8dy+vRpbt++zdq1a5XMTqPPPvsMGxsb6tSpg7OzM1FRUZw5c0YJWGaW22RT2cmcVWsMpj2tbt26VK5cmbCwMG7cuMGZM2eoV68eH3/8MW+//TZarZbp06czffp0wBCACg8PB/7MPLW2tmbcuHFMnDiR5ORkPv30U6X/7No/y/Dhw9m/fz/37t1j1qxZzJo1S1mnVqsZN26c8tj+iBEj2LNnD0+ePGHTpk3KZFOlSpXCxsZGKQEBUKlSJWU8169fp2fPnln2nfkcV61aVQnADxgwAGtra0JCQnIc9/Tp0+nfvz8PHjxgyZIlLFmyxGT9oEGD6NixY57OQV5ZWlqycOFCRo0aRXBwMCEhIQwfPjxLO1dXV+bPn2+SBf08vfrqq8yfP1/JbPX09MxSEzav3N3dKVu2rFILOacSCEYTJ07kypUrXLt2ja1bt7J161aT9e3atVMmElOr1UyZMoW3334bjUbDd999p0zm5u3tTWhoqMm2bm5ujB49mm+//ZZLly5l+bx7e3srX+AYGb/Yebp+sxBCCCH+2ySzVgghhBAiE+NkXhEREdy7d+8v96NSqZg5cyazZ8+mcePGODk5YWFhQYUKFRg5ciQBAQEmEwqVKFGCdevWMXjwYMqWLYuFhQWurq40adKEX375RZmAycnJiSVLltCkSRMcHBywt7fH19eXGTNm0LhxYwAOHTqEVqvN0zg1Gg1btmwBDLVNO3funGPbvn37Kj8bg8lNmzZl0aJF+Pn5YWVlhYuLC2+++SbffPON0jbzI+69evXi+++/p2rVqlhaWlKqVCnGjBnD2LFjs22fGxcXFwICAhg4cKByzkqUKKGcs1deeUVp6+bmxurVq2nbti12dnbY2trSrl07Vq1apezP+F9zc3N+/vln2rdvT4kSJbCxscHLy4vx48crgdtz584RFxcHwMCBA2nbti1OTk7Y2NhQqVIlJaM3O2XLlmX79u2MHDmSypUrU6xYMWxtbfH392fevHkmQeznycXFhVWrVjFz5kyaNWuGs7MzFhYWODg4UKtWLcaOHcvOnTuznUDreSlVqpRJRuxfzao1ylz24FnBWkdHRzZs2MBHH32Et7c3NjY2WFtbU7NmTb766ivmzJljUnu2cePGLFu2jPr162NlZYWrqyuDBg1i0aJF2fY/dOhQ5s+fj7+/Pw4ODlhZWVG+fHmGDx/O8uXLTcpKREdHK5O5ZTc5nhBCCCH+u1T6/M7uIIQQQgjxgmvXrh23bt1i2rRpWbLhxJ+0Wi179uzBw8MDd3d3k7q5wcHBSnD3iy++oG/fviQkJHDq1Cnc3NwoVaoUzs7OSvvt27crJQkWLVpE06ZNn+tYjx07hqWlJe7u7nh4eCg1cHU6HbVq1SItLY1OnTrx/fffP9f9iqzeeustjh49ilqt5sCBA7i7uxf2kP5xgYGBjBkzBldXVw4ePCgTjAkhhBBCIf9XIIQQQgjxlL59+/LNN99w4MABCdbmwszMjE8//VSp8frFF1/QuHFjYmJimD9/vtLOWCtVo9EwatQo9Ho9arWaefPmUaVKFR4+fMgvv/yi9Ont7f3cx7pixQqlVEGvXr0YOnQo6enpbNy4UakTaxyneP4ePnyISqVi586dHD16FIBGjRr9JwO1AEFBQYChtrUEaoUQQgiRmWTWCiGEEEI8JSUlhXbt2hEVFcX+/ftNMkaFqdmzZ7NgwYIc17do0YIff/xRef3hhx9mqRWa2euvv86kSZOe6xjBMAnZ0KFDlVqpT/Pw8GDLli04Ojo+930L+OCDD9i2bZvy2sLCglWrVhVoyYWi6tGjR7Rq1QpHR0d27dqFnZ1dYQ9JCCGEEEWI1KwVQgghhHiKtbU1Y8eOJSMjg1WrVhX2cIq09957jy+//JLatWvj4OCAmZkZNjY2VK1alTFjxjB37lyT9tOmTePDDz/Ex8cHW1tb1Go1tra21KhRg0mTJjFx4sQCGaexjm3Lli1xdXXF3NwcS0tLypUrR9++fVm7dq0EaguQl5cXtra22Nra4ufnx48//vifDNQCrFy5Eo1Gw5gxYyRQK4QQQogsJLNWCCGEEEIIIYQQQgghigDJrBVCCCGEEEIIIYQQQogiQIK1QgghhBBCCCGEEEIIUQTI1KN5oNPpyMjIQK1Wo1KpCns4QgghhBBCCCGEEEKIfwm9Xo9Op8Pc3By1OvfcWQnW5kFGRgYXLlwo7GEIIYQQQgghhBBCCCH+pXx9fbG0tMy1jQRr88AY8fb19cXMzKyQR1Pw9Ho98fHxODg4SCaxEKJIkfuTEKKokvuTEKKokvuTEKKo+i/dn7RaLRcuXHhmVi1IsDZPjBeMmZnZfyZYq1arMTMze+E/LEKIfxe5Pwkhiiq5Pwkhiiq5Pwkhiqr/4v0pL8cpE4yJbFlZWRX2EIQQQgghhBBCCCGE+E+RzNoiQKvXkq5PJ0WfQpo+Db1eX6jj0aNHb6ZHlaFCxX/jmw3x4lGpVFiprLBWWWOpssRM9eJnxQshhBBCCCGEEOLfTYK1hUyr1xKri+W31N94on1S2MNRaLXa/0TJB/HiczFzoXax2jipnSRgK4QQQgghhBBCiCJNyiAUMo1ew4XUC0UqUCvEi+SJ9gkXUi+g0WsKeyhCCCGEEEIIIYQQuZJgbSHLIINH2keFPQwAdFodMfdiCnsYQjx3j7SPyCCjsIchhBBCCCGEEEIIkSspg1DItHotWrQmyybXmwzAqIBRuJR3MVl3fNVxds/eTfOhzWk5rOVzHcv6CetxrehKy2EtiXsQx4J+C3hn3Ts4uTs91/08y81zN1k2fBmTz0wm9kEs83vPV8Zx67dbbJy0kdSEVNqObktGegaHFh0C4I2Fb+Bexf0fHWtBibkfw65Zu7gTcge9Xk+5WuVoP6Y9xUsXB+DosqPsX7AfM8s/H+tv0LcBrUe2BuDMhjOc/PUkCU8SsHOxo0HfBtTvVR8ATZqGvfP2cmn/JdKT0nEp70KbUW2oULdCtmNJjE5k27Rt3Dp3C7WZmhodavDyey9jZv7vKSmgRYtWr312QyGEEEIIIYQQQohCJMHaIsrGyYaQ7SG0GdXGZHnIthCsbK0KZJ9JMUm44gqAo7sjEw5PKJD95IeTu5PJOM4HnsfDy4N+3/UD4IdXf6DZW81o9HqjwhpigVjzwRpKVS/F+1vfR6/XE/RdEKvHrWbkmpEA3Lt0j2ZvNaPF0BZZtr188DL75u/j9TmvU8anDHcv3GXV+6uwc7ajeqvq7J23l4jfIxiyeAj2rvYEbw3m1zG/8k5A9oH59Z+ux97VnnE7x5H4JJHV41ZzcvVJGg9oXMBnQQghhBBCCCGEEOK/RYK1RZRve19+3/k7rUa2Qq02VKu4G3oXrUaLu9ef2aOpiansnr2bW7/dIuFxAsXsi1GvVz2aDW5GVEQUP/b/kTaj2lC/V33SktJY2H8h3q29swSBt3y1hTshd4g4H0Hk5UjajW3H3Ffn8t6W9yheqjiT602m8/jOHF91nPiH8VSsV5EWw1qw89udPAh7gGt5V3pM7YFzWWcALuy+wJFfjhAXGUeJsiVo/U5rKjWolO2xJjxJMGRu/nYLG0cbfF72UdbF3I9hTtc5vLflPfb8sIcrB68AMLXZVMzMzUhNTGXf//Zx7eg13ljwBvev3Gf37N08uPYAGycb6vWsR4N+DVCpVBz46QAR5yNIjU8l+l40fWf2xcPLg73z93L10FUyNBlUqFuBDuM6YOdsp+z7lYmvcGjxIVLjUyntXZquk7ri6OYIwPmg8xz55QixkbE4ujnSYlgLfNr6PPMcnN95nm1fb8s2IJ4Sn4Kdsx2thrfC0toSAP++/ix8bSEp8SlYO1hz/9J9/Lr4ZX8+HyfQZFATyvqWBaBsjbKUr1Oe27/dpnqr6mSkZdDy7ZY4uhuOoU73OuyZt4fIy5FZgrVREVHcOneLsYFjsSxmSYkyJWj+VnP2zN1D4wGNCd4WTPDWYEp7lyZ4WzBqtZrmQ5pjbmnO4SWHSU1IxaedD13GdwHg0v5LHFh4gPhH8di72uPb3pfmbzXP9jiEEEIIIYQQQggh/mskWFtEVWlShQu7LnDj9A0lwBe8NRi/rn6EHQtT2u2dt5eY+zEMXTaUYnbFuHzgMus+Xod3G2+cyzrT8aOO7Ji+g0oNK7F/4X7sXe1pNaJVlv11ndiV6IhoytcpT8thLYmKiMrS5kLQBYYsGYJWo2V+7/ms/mA1A+cPxNHNkRWjV3DklyN0m9SNa8eusf3r7fT7rh/lapYj7HgY6z5ex5AlQyjpWTJLvwGfBmDjaMO4HeNITUhl9bjV2Z6T3t/0ZtPkTQB0n9wdgFmvzKLF0Bb4dfEj/nE8y0Yso/WI1gyYN4CoO1Gs+WANFsUsqPtqXQBunrnJgHkDKO1dGnNLczZM3EBaUhrDVgzDopgFu2btYs2Ha3hr8VvKfq8dvcbwVcPRpmtZPmo5h5ccpsv4Ltw8d5MtX26hz4w+VGpYifCT4awet5qSniWJjYzN9RzU6FCDGh1qZHuc1g7WDJg7wGTZpX2XcCrlhLWDNYnRicQ9iOPc5nNsnboVc0tzqreuTsu3W2JhZaGUOzBKjE7kdvBt2o1pB0CXT7uYrL9x5gZpiWnZlpB4fOMx1o7WOLg6KMtcK7oS9yCOlIQUAO6E3KFay2p8tOcjzm08R+C3gfi08eGdgHd4fOMxi95chG87X0pXL83GSRt5fc7rVKhTgcirkfwy7BcqNahEae/S2Z4LIYQQQgghhBBCiP8SmWCsiFKbq6nRvgYh20MA0KRquLTvEjU71jRp12JYC3p93QsrWyviH8ZjbmmIvyc8TgCgVqdaVGtRjWUjl3Hj9A16ftUTtdlfe9vr96mPjaMN9i72lPQsSfWW1XEt74qltSUV6lYgNjIWgNPrTlOvRz3K1y6P2kyNV1MvqjStwtmNZ7P0GRsZy53gO7Qd3RYrWysc3Q3ZqX/F+Z3nca3gSv3e9TEzN6NkxZI06t+I0+tOK22Kly5OxXoVsbKxIiU+hUv7LhkyaUvYYWVjRftx7bl/6T6RVyKVbRoPbIy1vTV2znZ4NfUi6o4hkP379t+p1rIaVRpXQa1WU7lRZd5a9BYOJR3ydQ6e5cyGMxxfeVwJsiZGJVLOrxx+Xfx4f8v7vD77da4fv87u2buzbJvwJIFV762iVLVS+LbzzbI+4kIEAeMDaDG0hVIPN7O0pDQsilmYLDO+Tk9OB8DSxpIG/RqgVqvxbOCJXqun0YBGWBazpHT10ti72CvXhrmVOcFbgrlx+gYu5V345MAnEqgVQgghhBBCCCGE+INk1hZhtbrUYtHgRaQmpnL18FXK1SyHvYu9SZuk6CSCvgsi8mokTqWcKFWtFAB6vV5pU79Pfc7vPE/NTjVxKOnAX2XjaKP8rFKrKOZQzOS1XmfYZ2xkLLfO3eLMhjPKep1WR8V6FbP0Gf8oHkB5JB/INmiYF7H3Y7l/+T5ft/xaWabX65UyEoDJ+TMGEH8e/LNJP2pzNTH3Y7B2tAbAztnOZJ3xOBOeJODh5WGyrTHwmJ9zkJMMTQa7vt/FxT0XeX3268oEYO6V3XnzpzeVdq4VXGk+pDnbv9lOp487KcsjLkQQ8EkA5fzK0W1StywTgp3bfI6g74No+XbLHGv+WlpboknVmCwzvjbWTrZ2sEalUgGG6wCgmH3Wa8OimAVvLXqLw4sPs+EzQ0Zz9VbV6fBBB6wdrPN8XoQQQgghhBBCCPHvpdFpOP/4FBefnCUmKYrits74uNSlhqs/FmqLZ3fwgpNgbRHmXtkdl/IuhO4N5cKuCzTo2yBLm4DxAXg186L/3P6YmZuRHJvMb5t/U9ZnaDLYPm07vu18ubTvEt5tvanSuMpfG5Aqb80cSjpQs2NNmr7RVFkW+yAWC6usHzgHN0PwOOZeDK4VDJObGQO4+eXg5kCFuhVMSggkxyaTlpz2Z6NMx2AMXI8KGGUSxH104xHFSxcnMSox1/05ujkS9yDOZNnxlccp41smX+cgO0mxSaweu5qM9AyGLRtmEsC+de4WEecjaDr4z74z0jNM+v5t62/snLnTEIjtbxqI1Wl17Ji+g8sHLtN3Zl88/T1zHEdJz5KkxKWQGJWoBK0f33iMQ0kHitn9EZDN43WRmphKwuMEenzVA4DIq5FsmLiBI78c4eX3Xs5bJ0IIIYQQQgghhPjXCo06x4pLc3mcHIkWLeiAGDh8dyeuNh4MqD4ab+c6hT3MQiVlEIo4vy5+nPz1JFG3o6jcuHKW9amJqZhbmaM2U5MUk0Tgt4EAaDVaAPbO3YtOq6PrpK60fqc1m7/YTMKThGz3ZW5pTlpiWrbr8qNO9zqcWnuKe6H3ALh36R4/DfiJC7suZGnr5O6EZwNPds3aRUp8CglPEjj488G/tN8a7Wtw98Jdzu88jzZDS8KTBH4d+yu7Zu3Ktr2DqwOVm1Qm6LsgkmOT0WZoObzkMD8P+pnUhNRn7q9Wl1pcPniZ6yevo9PpuH7iOgd+OkAxu2L5OgdP02ZoWTl6JVa2Vry16K0smcYW1hYc+OkA54POo9PpeBT+iEOLD1HnVcPN7NL+S+z4Zgd9ZvTJEqgFCJoVRNjxMIYtH5ZroBbAuZwz5WqVI+j7INKS0oi5F8OhxYfw65r95Ga5SU9JZ9X7qzgfdB69Xo+9qz0qlQobJ5tnbyyEEEIIIYQQQoh/tdCoc/wv5CseJd/DztIRl2JuFLdywaWYG3aWjjxKvsf/Qr4iNOpcYQ+1UElmbRHn286X3XN206BfgyyPsQN0m9SNoO+DOLHqBMXsi+Hzsg/uXu48uv4IvU7PmfVnGPLLEMwtzfHv48+VQ1fY/MVm+v/QX3l03ahmp5rs+GYH9y/fp+ukrn95zN6tvUlPTmfzlM3EPYzD2sGaBq81wL+Pf7bte3zVgx3TdzDrlVlY2Vrh19mPexfv5Xu/Th5O9P+hP3vm7SHw20DUZmqqNKlC+7Htc9zm1S9eZe+8vSx8fSFpSWm4VnSl/9z+2LvYE3M/Jtf9latZju6Tu7N7zm5iI2Nxcnei59SelPQsSUnPkrmeg/M7z7Pt621MODwhS79XD18l8kok5lbmzHh5hsm6d9a9Q+nqpek5tSeHFh1i27RtFLMvRp1udZRM24M/H0Sn1bH247Um29boUINWI1pxJuAMKrWK+X3mm6zvMr4LNTrUYNvX24iLjKP/D/0Bw8RugTMDmd11Niq1ipoda9L8rea5npvsOLg60Pub3uxfuJ/tX2/H3Mocn7Y+NHgta8a4EEIIIYQQQgghXhwanYYVl+aSkpFIcStXVCoVer0eYxFPC7UFxa1ciUl7zIpLc/my8c//2ZIIKn3m4qYiW1qtlpCQEGrVqoWZWdaA6d8Rp40jMCnwufb5PGi12ud+rEIUpo62HXE0c3x2Q1Gk6fV64uLicHR0zPKFkxBCFCa5Pwkhiiq5PwkhioJzD48yL+QLLNVWZOg1pGakoNVnoEKNi7U7VmaGeXE0Og2JmjhG1vyMOm5NCnnUz09+YouSWSuEEEIIIYQQQgghhHiu0jJSCI+7TFjsJfbc2khCeizmT2XL6vRa4tNjcLV2BwwZtlqdlotPzr5Qwdr8kGCtEEIIIYQQQgghhBDib9HoNNyJDyMsJpSw2FDuJISj1+sAiE/PudSk6qmZy1UqFUma7Odb+i+QYK0QQgghhBBCCCGEECJfdHod9xJv/RGcvcituGtodOnZtjVTZf/ov7naAkcr04nV9Xo9thb2z328/xYSrBVCCCGEEEIIIYQQQuRKr9fzOCWSsJiLhMWGEh53mRRNUp62LWZuS4ImHvR6ipnbYmVeDCsza9R6M8zVfwZyNToNZmozfFzqFtRhFHkSrBVCmNCkaUiOTcbRTSbjEkIIIYQQQggh/sti06L/DM7GXiIuLTpf25upzXjJoTIVHKqy+/Z6YtOiKWHlqkx4qNVqlbZ6vZ6E9BhK2pSmhqv/cz2Of5NCD9ZGRUXxzTffcOTIEdLS0qhXrx4fffQRlSpVAuDy5ctMnTqVixcv4uTkxIABA3jrrbeU7XU6HfPmzSMgIID4+Hjq1KnD559/zksvvaS0eVYfRc2sV2aRGJWI2kyNSqVCr9NjZWdFjfY1aDO6DWq1+i/1u3vObs5uPIuZhRmjN4zGxtHmOY+86Dn8y2HuBN+h/w/9C3so/xq/DP2Fer3q4dfFL0/tT64+yck1J0mOS8bJw4kWQ1tQvVV1wBD43TtvL5f2XyI9KR2X8i60GdWGCnUr5NpnUkwSi95cxCsTX6FCHUPbtOQ0AsYHcCfkDs7lnHn1y1dxLe8KwJ3f77B/wX7eWPjGXz9wIYQQQgghhBDiPy5Zk8j12Etcj71EWOxFHidH5mt7lUpFKduXqFzch0pO1ang6IWVWTEAyjlU5H8hXxGT9hh7y+JYZJpsTKPTkJAeg7W5HQOqjzZZ919T6MHaESNGoFar+fnnn7GxsWHOnDm88cYb7Nmzh9TUVAYPHkybNm344osvCAkJ4YsvvsDJyYkePXoA8L///Y81a9bw9ddf4+bmxsyZMxk6dCjbt2/H0tKSmJiYZ/ZRFHX+pLNJsOzh9YcsG7kMi2IWtHy75V/q8+Tqk/Sc1lMJpP0XNBvcDAYX9ij+XZJi8/YIA0DYsTCOLD3C4B8H41LehUv7LxEwPoB3N71L8VLF2TtvLxG/RzBk8RDsXe0J3hrMr2N+5Z2Ad3Byd8q2zzu/32HT5E3E3DUtPv77jt9JS0pj3M5xHPzpIAd/Okivab3QaXUEfRdEt8nd/sZRCyGEEEIIIYQQ/z3p2jRuxl0lLDaU67Gh3Eu8hV6vz1cfLtbuVC7uQ2UnbzydquVYb9bbuQ4ja01kxaW5PE6JRKvTgl4PKhVmajNK2pRmQPXReDvXeR6H9q9VqMHamJgYypQpw4gRI6hcuTIAI0eOpGvXroSFhXHixAksLS2ZPHky5ubmeHp6cvv2bX7++Wd69OhBeno6S5Ys4cMPP6R58+YAzJo1i6ZNm7Jnzx46derEunXrcu3j38Ktkhsv+b1E5BXDNxoZmgwOLz7M+Z3nSU1MpYxPGTp80AHnss4ATK43mfp96nMh6AJlfcty89xNdFodGydt5Orhq3Sf3J3LBy9zePFhoiKisHe2p26Puvj39UetVrNlyhYy0jJ4FP6I5NhkhvwyhB+6/0Dn8Z05vuo48Q/jqVivIi2GtWDntzt5EPYA1/Ku9JjaA+eyzmRoMtj/v/1cO3qN+EfxmFuZ49PWhw4fdEClUvHL279Q1rcsd87fIfJKJI5ujrQY1gKftj4ARN+NJui7IG4H38bM0ozqrarTfmx7zC3NlXURFyKwtLakRocaNB/aHHOLrJfzgZ8OcOvcLQb/OJjgbcEEbw2mtHdpgrcFo1araT6kOeaW5hxecpjUhFR82vnQZXwXwJDh7NfFjwtBF4h/HI9HVQ86f9KZkhVLcvPcTTZN2kQ5v3KEHQuj6RtNaTSgEceWH+O3zb+RHJuM80vOtBreikoNK/Hb1t848OMBxmwbo2RGn1l/htPrTvPOundIS0pj7/y9XD10lQxNBhXqVqDDuA7YOdsRcz+GOV3n0G1yNw4sPEBybDLebbzx6+pH4IxAou9GU8a7DD2/7omtky16vZ5Ta09xJuAMidGJuFVyo/3Y9pSqVko5rrrd6xK6N5SoiCicyzrTbkw7KtStwPJRy4l7EMf2b7Zz//J9On3Uifm95+PbwdcQ+H7K41uP0ev1yj+VWoWZhRlqM8MxZqRl0PLtlji6G0oq1Olehz3z9hB5OTLbYG3I9hAO/HiAtqPbsn7CepN1xj7543eG8TyeWnuKCvUqULJiybx9mIQQQgghhBBCiP8orS6DiIQbhMUaJgW7HX8drS4jX304WBWnkpM3lZ28qVzcByerEnne1tu5DlP8F/L779u4GHmC+LR4HKwc8PFoSM2aXbC0LJbfQ3rhFGqwtnjx4nz//ffK6ydPnrB48WLc3d2pVKkSc+fOpV69epib/znMBg0a8OOPPxIVFcW9e/dISkqiQYMGynoHBweqV6/OmTNn6NSpE2fPns21D2dn53/mYP8GbYaWO7/f4ebZm7QcZsiq3f+//dw4c4NB/xuEnYsdx5YfY8WoFbyz7h0srAyp4jF3YxizfQxajRZre2sm15vM63Nep0KdCtw8e5OA8QG8OuVVqrWsxsPrD1kzbg0ADV9rCMD1E9d5a/FbOLg5YG1vDcCFoAsMWTIErUbL/N7zWf3BagbOH4ijmyMrRq/gyC9H6DapGydXnyTseBiDFgzC3sWeiPMR/DLsF6o2r0rF+hUBOLf5HAPnD8S1oiuHFh1i27RteDXzQm2mZuW7KylfpzxjA8eiSdWwcvRKDv50kGZvNWPZyGX4vuxLr296kRyTzLpP1qHX6Wkzqs0zz+WdkDtUa1mNj/Z8xLmN5wj8NhCfNj68E/AOj288ZtGbi/Bt50v52uUNY9x0jtdmvYbLSy4EzQpi9djVjFo/CoD4R/G4lnel++TuZKRlcGjRIYK3BNP3u764VXLj8oHLrP5gNW/+9CY+bX0I+j6Im2du4unvCRgCk35dDdnTW77cQlpSGsNWDMOimAW7Zu1izYdreGvxn+U6wo6F8U7AO8TcjWFh/4VEXo3k9dmvY2ZpxuI3F3Mm4AwthrbgTMAZTqw6Qb/v++FawZXfA39n+TvLGRUwCjtnOwCCtwXz+pzXsXe1Z8c3O9j+zXZGrx/NwHkDmfXKLFoMbaFkdr+z7p0cz6dvO19CtoUwv/d8VGYqVKh4dcqrSr3bLp92MWl/48wN0hLTcK/inm1/ng088W3vi5m5WZZgbY2ONQg/Gc7srrNxKe9C98ndSXiSQPDWYIb8MuSZ770QQgghhBBCCPFfo9PreJB0l+t/BGdvxF4hTZuarz6szW3xdKqmBGddrT2UmrP5Hk94BPodh/CNjsdXV9GQ+KVSgfox+hPr0XVqjtqz7F/q+0VR6GUQjD777DMlC3bBggXY2Njw4MEDqlSpYtKuZElD9tz9+/d58OABAB4eHlnaREYaMlCf1Ud+grXG7MF/wo7pOwj6Pkh57VDSgUavN6J+7/ro9XrObDhDn+l9KF66OADNhzTn3OZzhB0LU8oc+LbzxbKYJWTzpUTwtmCqtqiqZLKWqlqKJm804dTaU0qwtoxPGdwquZlsV79PfaXWbUnPknh4eSh1QyvUrcCd3+8AUKdbHWp1qoVtCVsSniSgSdNgaWtJ/ON4pa/qravj4WV472p1qsWRJUdIikki9l4ssfdjaf9reyyLWWJlY0WfmX3Q6/RcO3oNrUZL63dao1KpcHR3pOXwlqz7ZF2egrWWNpY06NcAlUqFZwNP9Fo9jQY0wrKYJaWrl8bexZ7YyFilfaP+jZQxthvTjm9afKMcI4DfK36YmZthZm5G8NZgmrzRhFJVDRmsPm19uLT/Er9t/Y0u47vg+7Ivv+/4HU9/Tx7fesyDaw94bdZrJEYncmnfJUMwtYQhmNp+XHu+afENkVcisXa0VsZiWcwSt0pu2DvbU6tzLRxKOhjeK98yyrhPrz9N08FNca9sCIjWfqU2v23+jfM7z9OofyNl3MYs7BodavB74O/PPHfZ0Wq0uFdxp+tnXXGr4saFnRfY8tUWXCu6Zrl2Ii5EEDA+gBZDWyjX7dPsXbJ/VALAspglfWb0MVm2fuJ6Wr7dkrsX77Jv/j70Oj1NBzelWstq2fbxT31+RcHJnMkthBBFidyfhBBFldyfhPjviUp5RFjsRaX2bJIm/tkbZWKutqSCYxUqO3lTycmb0nblUatM50/6K/cUXXgEGQG70Kemg601KnMzdFotajMz9Bla9FFxaNYFYd6r3QsXsM3P+SoywdpBgwbRp08fVq9ezTvvvMOvv/5KamoqlpaWJu2srKwASEtLIyUlBSDbNnFxcQDP7CM/4uPj//LkXtmxsLBAZ6UzmfkOAD10/LAjNTvXzLKNTqcjKToJTYqGdZ+sQ6X+85sMrUZL9N1opT9bZ9ssfeu0hv0lRiXiXsXdZL2juyOxkbGGZXqwc7HLsn0x+2LKMpVKhZWdlenMfVo9Wq2W1KRUdn67kzvBd7AvaW8IeOpBl6FT+rctnml8qj+PIe5xHDZONphZmCnrHdwMQcnQvaEkxSTxTatvTM6XVqMl/nE8tiVsTU+lTm9Yr9Wi1+mxdrBGp9MZ1v3xQbG0sTQ5psxjdCrtpKwzszDD2tGa+EfxSoaqTQkbZX1SdBKOHo5Zzumj64/QarXUeqUWy0cuJyUhhd+2/EaVplUo5lCMe6H3APh58M8mY1ebq4m6G0UpO0Pw18r+z3OtUquwsjU998b3NvZ+LLtm72LP3D1/rsvQ4VHVI+dzr880A6PecN6yXJfZ2DF9B2VrlsW9qiEwXKNTDc4HnSd4azBt32urtAveEsyu2btoMbQFDV5rkKe+Mx9Tdm6du0VqQiqVm1RmVudZ9J7eGzsXO37q/xNla5ZVgtxKX3odycnJaDSaPO1bFE16vZ7k5GSAv/xNrhBCFAS5Pwkhiiq5Pwnx4kvUxHMz4So3E65wM+EKselR+dpepVJR2qYCFey9qGhfjTK2FTA3TvClg4T4hL8/SK0Wy60HUKWkorezAfSQmoZOGQRgWwxVYjJpWw+QPqgzmJn9/f0WEcZYVF4UmWBtpUqVAPjyyy8JCQlh5cqVFCtWjPT0dJN2xgCrjY0NxYoZUkbT09OVn41trK0NgZpn9ZEfDg4OmD3nCyVDl5G1T5UhGJfTvuyc7TC3MmfAvAGU9f3zm4Ynt55gX9Je2U5tps7Sh3FZ8VLFib0fa7I+NjIWe5c/tlcZPqw5bZ/dOFVqFajAzMyMHV/vwNrBmnE7x2FhZYFOp2N6q+l/tn9qW2M9UrWZmuIexUmOTUar0Royg4Hbwbe5f/k+ju6OlChTgtHrRytjSktKIzE6EXsX+yz/85F5TJl/fnqf2R6TCpKikpR1aclpJMclU7xUcbQZhgBi5vIaTh5OxN2PMz2n9/88p2V9yuJc1plrR65xcfdFXpnwCmZmZjh5OAEwKmCUSWbpoxuPKF66OIlRiYBh3Dme+z+O28zMDAc3B1q+3RLfl32VvqLvRmPtaJ3ruc+p79zEP4pHl6EzaWtmYYa5pTlmZmbotDp2TN/B5QOX6Tuzr1ICIq+yu4bBUBpk79y99Pq6F6nxqSRFJ1HauzTmFuZYWFsQFxmnZCkrfanU+f7Mi6LH+CWLo6Oj/LEhhChS5P4khCiq5P4kxIsnNSOF8LjLf5Q2COVh0l2T9Xn5e97dtqySOVvRsSrFzK2fuc3fob1wjYyYeDBTo4pPAo2hTq4KUDnao/oj/qO3s0UVn4Tdw1jMqlUs0DH9k/KatAaFHKyNiorixIkTdOjQ4c/AkVqNp6cnjx49wt3dnUePHplsY3zt5uZGRkaGsqxcuXImbapWrQrwzD7yQ6VSFYlfbmq1Gr9X/Ng7by+vTnkVe1d7zgeeZ8tXWxi2bJjy2H5u/F7xY8nQJYTuDVVq1h5bdow63Z/PjHupianYu9qjNlOTlpTGwZ8OkpaUhlbz7IuztHdpnMs5s3v2bl5+/2XSk9LZNWsXFf0r4veKH3t+2MOxFcfw7+OPJk3DlilbiHsQx9sr3n4uY8/s+KrjVKhXAXtXe3Z9vwuXl1wo41uG28G3s7St3a02R5cdpUyNMrhXdufygctcPXyVgfMG/tmma232L9yvlGEAcHB1oHKTygR9F0SnjzthZWfFseXHOPLLEd7d9G6+x1ynWx0OLz6MexV3XMu7cv3EdVZ/sJpe03pRtXnVZ25vbmlOWmLess69mnpxet1pqjStgnsVwzHfOneL1iNbAxA0K4iw42EMWz5MCUo/DydWnaBq86qUKFMCnU5HMftiRJyPwKGkA6kJqTh6OGa7XVH4/Iq/z3gvlvdTCFHUyP1JCFFUyf1JiH83jU7D7fgwwmIucj02lDsJN9Dr856pCVCimCuVi/tQ2ckbT6fq2Ftm/3fz86LX6tA/eILuTiT6iEi0oeGQkpp9tmxyKvwRrFWZm6HX6dCHR6Cqnr+Er6IsP/ffQg3WPnr0iHHjxuHs7EzDhoY6qRqNhkuXLtGqVStcXFxYs2YNWq1WCeaeOHGCChUq4OzsjL29PXZ2dpw6dUoJ1sbHx3Pp0iX69+8PQL169XLt49/q5fde5uBPB/ll2C9Ktmef6X3yFKgFQz3a3t/05tCiQ2z5cgvWjtbU7VmXJgObPJfxdfywI9umbeObVt9gZWtFlcZVqNSwEo/CHz1zWzNzM16b9RpB3wcxq/Ms1GZqarSvQcu3W2JmbsbA+QPZNXsXx5YfQ6fTUaFOBfp91++5jPtpL9V6iTUfrCHuYRwv+b3E63Nez7EURsPXGqLT6lj/6XoSniTgXNaZnlN7Ur5OeaWNbwdfdv+wm8YDGpv08+oXr7J33l4Wvr6QtKQ0XCu60n9uf+xd7Im5H5OvMRtrDq8et5rEJ4nYu9rT8cOOeQrUgiGgvO9/+7h36R49vuzB/N7z8e3gS7PBzbK0bT60OSozFes+XkdKXAolypWg78y+eHh5kBSbxJmAM6jUKub3mW+yXZfxXajRoQbbvt5GXGQc/X/on+fji3sQx8XdF5VJxdRqNa9MfIWNkzai1+rpMK5DlqxaIYQQQgghhBDi30Kn13Ev8RZhMRcJiw3lZtxVMnT5K+lnZ+FApeLVqeTkTWUnH5ytSxbQaA30Oj36JzHoIyLR3XmA7t5DSM805tzKAJg/FWdRgT4lf5OgvUhU+kKsMq7X6xkyZAj37t3jq6++wsHBgYULF3L06FE2b96MlZUVHTp0oFWrVgwZMoTz588zefJkvvjiC7p37w7ArFmzWLNmDdOmTaN06dLMnDmTu3fvsm3bNiwtLYmKinpmH8+i1WoJCQmhVq1az70MQpw2jsCkwOfa5/OQObj9XzXrlVm0GNoCvy5+hT0U8Rx0tO2Io1nBfnMoCp5erycuLk4e4xNCFDlyfxJCFFVyfxKi6NPr9TxKvq+UNQiPvUxKRlK++rAyK0ZFp6pUdvKhkpM37rZlskwK9jzp9XqIS0R3J9KQPXv3AfrknAOs+tgESE4xzaxVqdBbWqB2sIVMCW362ATM6vlg0aVFgY3/n5af2GKhZtaqVCpmz57Nd999x/vvv09CQgJ169Zl1apVlCplmFRp0aJFTJ06le7du+Pq6spHH31kEmR99913ycjIYOLEiaSmplKvXj0WL16sTCrm7Oz8zD6EEEIIIYQQQgghhPinxKZGERZ7kbDYS1yPDSU+LX9P1ZqpzXnJoRKVnQylDcraV8RMXbBhPn1SiiEweycSXcQD9PGJed/YytJQ7sDMDIpZorK0BAtzdDqtaaA2w/Ba7Vk2l85ebIWaWftvUZCZtfHaeHYk7XiufT4PklkrmbUvGsmsfTFIZogQoqiS+5MQoqiS+5MQRUOyJpHrsZcIiw0lLOYiT1Ie5Gt7lUpFabvyf5Q18KaCoxeWZlYFNFoDfVo6+rsP/8yejYrNdx8ql+Koy3mgKu1Kxo4j6GPiwcFWuR9ljj/p9XqIT0Ll7IjlyH6ozF+cuNS/JrNWGGaot8ACDfmrPSIK3pitYwp7COI5McccM9WLc5MXQgghhBBCCFG0pWlTuRl31RCgjbnI/aTb5Ddf0tXG44+yBtWp5FQdG4uCnZ9Fn6FFH/nIUHP2TiT6B08gn2NWOdoZgrPlPFCXcUdla/3nui5maNYFoY9PQm9rbRKM1WdoISkFVTFLLDo1f6ECtfklwdpCZoEFbuZu3M24W9hDEeKF5W7ujgUWhT0MIYQQQgghhBAvKK0ugzsJNwiLvcj12FBux4eh1Wnz1YejVQkqOVWncnFD3VknqxIFNFoDvU6P/lHUn6UN7j+CjPyNWWVjjaqsO+pyHqjLuaNytM+xrdqzLBa926PZcQh9dDx6nQ6VXo9epQK1GpWzIxadmv+nSyCABGsLnYXKAl8rX/ToeZjxkAwyCntIQrwwzDHHzdwNXytfLFQSrBVCCCGEEEII8Xzo9DoikyIMk4LFhHIz7gpp2pwn2MqOtYUtlRyrU6m4obSBq7VHgZYr0ev16KPj0Ef8kTkb8QB9Wnr+OrG0QF3GDXVZQ/asysUpX2NWe5bFcmQ/dNduobt+h7S4BKwc7VFXKoe6Svn/dEatkQRrC5lapcZB7YB/MX/S9elFJlir0+lQqwtu1kAh/gnmmGOpssRCZVGgs2AKIYQQQgghhHix6fV6olIfERZzket/TAqWpEnIVx8WaksqOHr9kTlbndJ25Qv8b1V9QtKfNWfvPECflJy/DszMUHu4GsoalHNH5eaCyuzvjVllboZZdU/U1SqSFBeHrdTUNiHB2iJArVJjpbLCioItDJ1Xer2e5NRkbGxs5MMihBBCCCGEEEKI/6T49Fglc/Z6bCgxqU/ytb1KpaacvSeVi/tQ2cmbcg6VsFAX7FOf+pQ0dBEPDGUNIiINE3rlh0qFys0Z9R+lDVSlSqKykPDhP0nOtsiWRiMTngkhhBBCCCGEEOK/IyUjmRtxlwmLCSUsNpSHSfmfX8jDrhyVnAxlDTwdq2Jlbv3sjf4GfboG/b1H6CL+yJ59HJP/ScFKOBoCs2XdUZd1R1WsaCQT/ldJsFYIIYQQQgghhBBC/OdodBpuxV0zZM/GhhKRcAO9XpevPkpYl6SyMTjrVB17S8cCGq2BXqtD/+CxUtZAF/kYdPkbs8rOFlW5PyYFK+uOyt62gEYr/goJ1gohhBBCCCGEEEKIF55Or+Nuwk3CYg11Z2/GXSVDl78ni+0sHankVJ3KTj5ULu5NiWKuBTRaA71Oj/5JjKGswZ1IdPceQT6fhlYVszJkzZbzQF3OA5zspexlESbBWiGEEEIIIYQQQgjxwtHr9TxMvqfUnQ2Pu0xqRv4m2LIyK4anUzVDaYPiPrjblCnQQKder4fYBHQRDwzZsxEP0Kek5q8Tc3PUpUsaShuU80DlWgKVWoKz/xYSrBVCCCGEEEIIIYQQL4SY1CeExRomBLseE0p8emy+tjdTm1PeoTKVnXyo5FSdsg6emKnMCmawf9AnpfxR1uCPScHik/LXgVqN2t1FKW2gcndFZV6wYxYFR4K1QgghhBBCCCGEEOJfKUmTQHjsJa7FGEobPEl5kK/tVSoVZewq/JE56015hypYmhXsBFv6tHT0f2TO6iIeoI+KzXcfKtfiqMsayhqoyrihsrR4/gMVhUKCtUIIIYQQQgghhBDiXyFNm8rNuKuG7NmYUO4n3TaUDsiHkjalqOzkTaXi3ng6VsPGwq6ARmugz9Civ/cIXYSh7qz+YRTkc8wqR/s/yhq4oy7jjsrWuoBGKwqbBGuFEEIIIYQQQgghRJGUodMQkXCDsJiLhMVe4k5CGFqdNl99OFqVoPIfNWc9narjZFWigEZroNfp0D+MUmrO6u4/goz8jVllY62UNVCXdUflaF9AoxVFjQRrhRBCCCGEEEIIIUSRoNPriEyKICzmItdjQ7kRd4V0bVq++rC2sKWSY3UqF/ehspM3LtbuBT4pmD46zlBz9k4kursPIS09f51YWqAu624IzJbzQOXsVKBjFkWXBGuFEEIIIYQQQgghRKHQ6/VEpT4kLCaUsNhQwmMvkaRJyFcfFmZWVHT0MtSddfKmlN1LqFXqAhqxgT4+8c+as3ceoE9Kzl8HZmaoS7miKueBuqwHKndnVOqCHbP4d5BgrRBCCCGEEEIIIYT4x8SnxRAWe4nrsaGExV4kNjUqX9urVWaUc/A01J118uYlh0qYqwt2gi19SuofgdlIdHceoI+Nz18HKhUqN+c/JwUr7YrKXMJyIiu5KoQQQgghhBBCCCFEgUnJSCY89jJhsRe5HnuJh0l3891HKbuXqORUncpOPlR09MLKvGAn2NKnawyTgv1R2kD/ODrffaicnZSyBuoybqiKWRXASMWLRoK1QgghhBBCCCGEEOK50eg03Iy7asicjQnlbuJN9HpdvvpwtnZTMmcrOVXHztKhgEZroNdq0Uc+QRcRaciejXwCuvyNWWVva8iaLWuYGExlZ1NAoxUvMgnWCiGEEEIIIYQQQoi/TKvXcjfhpiFzNuYSt+KvkaHT5KsPO0tHKjt5U7m4D5WcqlOimGsBjdZAr9OjfxKN/s4DQ/bsvUegyd+YVcWslMCsupwHONnLpGDib5NgrRBCCCGEEEIIIYTIM71ez8Pke4TFhhIWc5HwuMukZaTkqw8rc2s8HatRubgPlZ28cbMpXaCBTr1eD7EJf5Y1uPsAfUpa/jqxMEdd2s2QNVvOHZVLCVRqCc6K50uCtUIIIYQQQgghhBAiV9Gpj7kee4mwmItcjw0lIT0uX9ubqy14yaEylYt7U9nJmzL2FTFTmRXQaA30icmGwGyEIXtWn5CUvw7UatTuLoaas+XcUXm4ojIr2DELIcFaIYQQQgghhBBCCGEiSZNAWEyooe5sbChRKQ/ztb1KpaaMXXkqF/emkpMPFRyqYGFmWUCjNdCnpqG7+9BQczbiAfqo2Hz3oXItgbrcHzVnS7uhsrR4/gMVIhcSrBVCCCGEEEIIIYT4j0vLSOFG3FVD3dnYS9xPvJ3vPkralKayU3UqF/fB06ka1ua2BTDSP+kzMtDfe2wobRARif5hFOj1+epD5WT/x6RgHqjLuqOyKVZAoxUibyRYK4QQQgghhBBCCPEfk6HTcCchnOsxhszZ2/HX0em1+erDycr5j8xZwz9Hq+IFNFoDvU6H/kGUITB7JxJd5GPIyN+YVbbWhsCsMXvWwa6ARivEXyPBWiGEEEIIIYQQQogXnE6vIzLpzh81Zy8RHncFjTZ/E2zZWNhRyak6lZ18qORUHRdr9wKfFEwfFauUNdBFPIB0Tf46sbRAXfaPwGw5D1QlHAt0zEL8XRKsFUIIIYQQQgghhHjB6PV6nqQ8MEwK9kdpg2RNYr76sDCzwtOxqiFAW9wHD9tyqFXqAhqxgT4uwRCYvROJ/s4D9Mkp+evA3Ax1qZKojAFaN2dU6oIdsxDPkwRrhRBCCCGEEEIIIV4A8WkxhMX+MSlYTCixaVH52l6tMuMlh0pUdvKmUnFvytl7Yq4u2Am29MmphsnAIiLR3Y5EH5eQvw5UKlRuzqjLeaAu64GqtCsqcwl3iX8vuXqFEEIIIYQQQggh/oVSMpIIj71MWMxFwmIv8Sj5Xr77KGX3EpWdvKlc3IcKDlWwMrcugJH+SZ+uQX/voWFSsDsP0D+OzncfKmenP0sblHFDVcyqAEYqROGQYK0QQgghhBBCCCHEv4BGm87N+Gtcj71IWEwodxNvodfr8tWHi7W7UtagklN1bC3sC2i0BnqtFn3kY0Ng9k4kugdPQJe/MascbA1Zs+U8UJd1R2VnU0CjFaLwSbBWCCGEEEIIIYQQogjS6rXcTbhB2B9lDW7Hh5Ghy98EW/aWjn8EZr2p5FSdEsVcC2i0BnqdHv3j6D8nBbv3EDQZ+epDZW2FqqzHH6UN3MHJXiYFE/8ZEqwVQgghhBBCCCGEKAL0ej0Pku9yPSaUsNhQwuMuk5aRvwm2ipnb4OlYjcrFvank5I2bTekCDXTq9XqITfijrEEk+ogH6FPT8teJhQXq0iUNZQ3KeaByKY5KLcFZ8d8kwVohhBBCCCGEEEKIQhKd+piwmFDCYi9yPfYSielx+dreXG1BeYcqVCpenSpOvpS2L4+ZyqyARmugT0z+Mzh75wH6xKT8daBWo/ZwRVXuj7qz7i6ozAp2zEL8W0iwVgghhBBCCCGEEOIfkpgez/VYQ+ZsWGwo0SmP8rW9SqWmjF0FJXO2gkMVLMwsC2i0BvrUNHQRD9BHPDAEaKPzF1AGULmWMJQ1KOeBqnRJVJYWBTBSIf79JFgrhBBCCCGEEEIIUUDSMlIIj7tCWGwo12NDiUy8k+8+3GzLGCYFc/LB06kq1ua2BTDSP+kzMtD/n707j2+rPNPGfz3n6EiWLUvybtmxHdvZSEL2jcDAFMq809LpFJhuvwFaXuAtXei0pbSUwrS0Q6Evfem0tAw0QEk7QykMnZkOpdPSUkhJQjYnZCOEJN4tWV5lW7alo3Oe3x9Hlm3sRFKwEi/X9/NJ4+gseg6NT6TLt+67NWhVzzYHINu7ACnTOofwuqFUlo4OBXNmZWi1RLMLw1oiIiIiIiIioimimzqa+k7Eh4IdRnP/KZjSSOsc3qwCLPRaQ8EWepfC7cjL0Got0jQhA50wmwLWYDB/B2Ckt2aR40wEs0qlD8LtytBqiWY3hrVERERERERERGfJlCbaBhoTlbOnQm9BN9IbsJWtueLB7DIszFuGgqySjA8Fk529VjDb7IfZ0g5E9fRO4rBDmVcyOhQs35PRNRPNFQxriYiIiIiIiIhSJKVE51AgUTl7InQUQ3p6A7bsqgM1niVWQJu3HL6cCihCydCKLTLUD7Mp3nO2OQA5OJTeCWwqlLJiq3q20gdRnA+hZHbNRHMRw1oiIiIiIiIiojMIRXqsoWA9h/F27xGEIt1pHa8qKipzF2KhdykW5i1HRW4NbEpmB2zJ8BDMlnhbgyY/ZGggvRMIAVFaaA0FqyiFKCuGsKmZWSwRJTCsJSIiIiIiIiIaY1AfwMnQmzjRcwRv9x5BcLAtreOFECjLqcKCPKu1QbVnMRxqZgdsyagO2dJuDQVr8kN29qR9DlHgtcLZSh/EvBIIhz0DKyWiM2FYS0RERERERERzWtSIoKHvON7usfrOtgw0QEozrXMUOkuxMB7O1nqXIkfLzdBqLTJmQAY6rGC2KQAz0AmY6a1ZuF1W1exIQJvjzNBqiShVDGuJiIiIiIiIaE4xpIHmvpM40XsUb/ceRkPf2zDMWFrncNu9WJC3HAu9S7HAuwx5WYUZWq1FmhKyozvR1sBsDQKx9NYsnFkQFaWJ6ll4XBwKRjTNMKwlIiIiIiIiollNSolAuBlv91qVsyd730TEGE7rHFm2bNR6LsCivOVY4F2G4uyyjAadUkqgp88KZpsD1lCw4Uh6J9E0KPNKoFSWQlT4IArzIBSGs0TTGcNaIiIiIiIiIpp1uoc74gPBDuNE75sYiIbSOt6maKj2LMYC71Is9C5Hee58qCKzA7ZkfxhmcyDR2kAOhNM7gaJAKSuCqIi3NSgthFCVzCyWiDKCYS0RERERERERzXj90RBO9h7F271H8HbPYXQPd6R1vBAKKnJrsNC7DAu8yzDfswiaomVotRY5HLGqZpviAW1PeoEyhIAoyo+3NSiFKCuGsGd2zUSUWQxriYiIiIiIiGjGicSGcDL0Jt7uPYoTPYfhDzenfY6SnHlY6F2GhXnLUOO5AE5bdgZWOkrqMcjWYLy1gR8y2A1ImdY5RJ4bSoUPosoHZV4phNORodUS0fnAsJaIiIiIiIiIpj3d1NHU9zbe7jmCt3uPoKn/JKQ00zpHXlYhFsTD2QXeZXDbvZlZbJw0TMj2znhbAz9MfydgGGmdQ+RkQ1SODgUTuTkZWi0RTQcMa4mIiIiIiIho2jGlidaBBpzoPYq3ew6jPvQWdDOa1jlytFws8C6z+s7mLUdBVnFmh4KZErKrJ9HWwGxtB6J6WucQDjtEhRXOiopSiHxPRtdMRNMLw1oiIiIiIiIiOu+klOgY8uPt3iM40XMEJ0JHMaSnN2DLrjpQ47kgUTnry6mAIjI7YEv29sfbGgQgm/2Qg8PpncCmQikrhhipnC0ugFAYzhLNVWcd1g4MDKC9vR39/f3weDwoLy+H3W6fyrURERERERER0SzWG+nGifhAsBO9RxGKdKd1vKqoqHIvtFobeJejMrcGqpLZujQZHooPBYv3nQ0NpHcCIaCUFsbD2VIIXzGETc3MYoloxknrDtbV1YVf/OIXePnll3Hs2DHIMU2wbTYbli5dive973340Ic+BK/XO9VrJSIiIiIiIqIZbFAfwIneo1Zrg97D6Bj0p3W8EAJlOVVYmLccC7xLUe1ZDIealaHVWmQkCtnSDrPZb/We7exN+xyi0Gv1nK3wQcwrgXCw2I2IJpdSWDs0NIR//ud/xjPPPINoNDoupB2h6zreeOMNHDx4EA899BCuv/56fPazn0V2dmYnKRIRERERERHR9BQ1IqgPvWW1Nug9gtaBhkkzhTMpdJZiYd5yLPQuQ633AuRouRlarUXGDEh/EGZTvHo20AmkuWbhcVnBbKUPSkUpRI4zQ6slotkmpbD2qquuQltbG4qKinDFFVdg06ZNWLx4MQoLC5GdnY2BgQF0dnbi2LFj2L9/P/70pz/hiSeewAsvvIBXX30109dARERERERERNOAYcbQ3H8Kb/cewdu9h9HYdwKGGUvrHG5HXrytgfXLm1WQodVapCkhg12QzWOGgsWMtM4hsrMgKqxgVqn0QXgzGygT0eyVUlhbXV2Ne+65B3/5l3856QRCj8cDj8eD2tpaXHXVVbj77ruxZ88ePPXUU1O9XiIiIiIiIiKaJkxpIhBusfrO9h7Gqd5jiBjpDdhy2nJQ673ACmfzlqPI6Zs0e5gqUkrInj6rarbJD9kcgIxE0zuJXYNSXmIFs5WlEAV5HApGRFMipbD2iSeeSPvE69evx/r165Pu19vbi4ceegivvPIKBgYGsHjxYtx+++1Yt24dAOBrX/safvWrX407pqSkBNu2bQMAmKaJH/3oR3juuefQ19eHtWvX4hvf+AaqqqoS+7/55pu47777cPjwYXi9Xlx//fW46aab0r4mIiIiIiIiormuayiIt3sP40TvEZzoOYoBvS+t422KhmrP4kQ4W+6aD0UoGVqtRfaHrarZkXB2YDC9E6gqFN/IUDAfREkhhJrZNRPR3HRWIxJDoRACgQAWL16M3t5e/PCHP0RXVxeuvfZaXHrppWmd60tf+hK6urrw0EMPIT8/H08//TRuuukm/OpXv0JtbS3eeust3HrrrbjuuusSx6jq6JTERx55BM888wzuv/9+lJSU4MEHH8Qtt9yCF154AXa7HT09Pbjxxhvx3ve+F/feey8OHDiAe++9F16vF9dee+3ZXD4RERERERHRnNEfDVmVsz1W39nu4Y60jhdCQWVujdXaIG85qtwLoSlahlZrkcMRmM2B0erZnvQCZQgBUZwPpSIezpYXQ2hnFaEQEaUl7TvNW2+9hU9+8pO47LLL8MADD+D222/Hjh07IKXESy+9hC1btuDiiy9O6VyNjY3Yvn07fvGLX2DNmjUAgK9//evYtm0bXnjhBXzuc5/DiRMn8JnPfAZFRUUTjo9Go3jyySdxxx134LLLLgMAfP/738df/MVf4KWXXsJVV12FZ599Fna7Hd/85jdhs9lQW1uLxsZGbNmyhWEtERERERERzUq6qeNgxy4c7tyLnnAX8nIKsLxwHVYUbUwalA7HhnAydBQneo7i7d7DCIRb0n7+0px5WOhdjgV5S1HrWYosW2YHbMmoDtlmDQUzm/yQHd3pDwXL8yTaGigVpRBZjgytlojo9NIOa7///e+jp6cHPT09aGtrw/bt21FYWIjly5fjlVdewWOPPZZyWJuXl4ef/OQnWL58eeIxIQSklAiFQmhoaEAkEkFtbe2kxx87dgzhcBibNm1KPOZ2u7F06VLs2bMHV111Ffbu3Yv169fDZhu91E2bNuGxxx5DV1cXCgoy26iciIiIiIiI6Fw60rUPPz/6MDoG/TBgACaAHmBby29RlO3D9Utvw7KCtYn9dVNHY9/beLvHam3Q1H8KUpppPWd+VlG8cnYZFniXIdfumeKrGk8aJmSgM97WwA+zrQMw01uzcGVDVJRCqSqzwtncnAytlogodWmHtYcOHYKmafjud7+LP/7xjwCAj33sY7j11luxbt06nDhxIuVzud3uREXsiN/+9rdoamrCJZdcguPHj0MIga1bt2Lbtm1QFAWXXXYZvvCFLyA3NxeBQAAA4PP5xp2juLgYfr8fABAIBLBo0aIJ2wGgra2NYS0RERERERHNGke69uGRA/+EodgAcu150BQNhmFAVVXopo7gYCseOfBP+LtFN0FKibd7D6M+9BZipp7W87g0NxbkLbUCWu9yFDiLM3RFFmlKyM4eK5htCsBsbQei6a1ZOOxWOFvpg6j0QeS5MzrIjIjobKQd1g4MDMDtdsPr9WLv3r0QQmDt2rWw2WxwOBwYGho668Xs27cPd911F6644gpcfvnl+OEPfwhFUVBeXo5HH30UjY2N+O53v4vjx49j69atieey2+3jzuNwOBAKhQAAw8PDk24HgEgkktb6pJSQaX6MYiYauc65cK1ENLPw/kRE0xXvT0Q0Heimjp8ffRiDsQHkO4oSQaSMb4sYQzCkieBgKx47eD/Kc6pSDisdahaqPUuw0GtVzpbmzBs3FGyq739SSiA0kBgIZjYHgKHh9E5iUyHKiq1wtqIUorgAQhl/vbxvE50/c+n1UzrXmHZYW1xcjLa2Nmzbtg2vvvoqHA4H1qxZg//+7/9GKBTCwoUL0z0lAOAPf/gDvvzlL2PlypV46KGHAAC33XYbPvnJT8LtdgMAFi1ahKKiInz0ox/FoUOHkJWVBcDqXTvyNWCFsE6n1Q8nKysL0Wh03HONhLTZ2dlprbGvrw+KMvunPUopMThoTcbkTxmJaDrh/YmIpiven4hoOnij+3W0h1vhsrlhmAYixhCGYoOIGMMwYST2E1AQM6MYiPYh2+aa9FyqsGFeTjWqc5egJncJynLmQxXxYd8G0N/XP/UXMDgMpa0DojVo/T4wmN7xQsAszoMsK4ZZVgRZkg+MGVCO/jSHjBFRRs2l109mGm1a0g5rr7jiCjz11FP41Kc+BQB4//vfj1gshjvuuANCCPzt3/5tuqfEv/7rv+K+++7DlVdeie9973uJSlghRCKoHTHS0iAQCCTaHwSDQVRWVib2CQaDWLJkCQCgtLQUwWBw3DlG/lxSUpLWOt1uN9SxN/pZaiTt93g8s/6bhYhmFt6fiGi64v2JiKaD+pY3EZMxDJoDGIyEIWGFAxJy3L1JCAHTNBA1h5GrjvSWFZjnmo8F3qVYkLcc1e5FsKuZHbAlI1HIlvZE9azs6h2/Qwrvv0VhXnwgmA+ivBjCYU96DBFND3Pp9ZNhGMl3iks7rP3c5z4Hv9+Pbdu2YenSpbjzzjuRk5ODwsJCbNy4ETfeeGNa53v66afx7W9/G9dffz3uuuuucZWrt99+O3p7e/HEE08kHjt06BAAYMGCBaioqIDL5cKuXbsSYW1fXx+OHj2K6667DgCwfv16PPPMM4kePQCwc+dOVFdXp92vVggx6//yjBi51rlyvUQ0c/D+RETTFe9PRHS+BMItqAtux3b/7zEUG4BuaikdZ1ezsLnsSiug9S5FtjZ5le1UkTEDsi0IszlgBbSBTiDNjz8LjyvRc1aZVwqR48zQaonoXJgrr5/Sub60w1qXy4Uf/OAHEx5/7rnnJgz6Sqa+vh7f+c53cOWVV+JTn/oUurq6EtuysrLwgQ98AJ/+9KfxL//yL7jqqqtQX1+Pb33rW/jABz6A2tpaAMB1112H733ve8jPz0d5eTkefPBBlJaW4sorrwQAXHvttXj88cfx9a9/HTfffDMOHjyIrVu34t5770330omIiIiIiIimhd5INw4Ed6AuuANtA40AgJhx5oFbqlDhUJ1w2JwY1Puxuey9uGbhJzO2RmlKyGCXFcw2+WG2BYFY6tVlACCynYmhYEplKYQnN0OrJSKaHtIOa0f09/cjHA6P67nQ1tYGACgrK0vpHL/73e+g6zpeeuklvPTSS+O2XX311XjggQfwgx/8AI8++igeffRR5Obm4m/+5m/whS98IbHf5z//ecRiMdx9990YHh7G+vXr8cQTTyRaKRQUFODxxx/Hfffdh6uvvhpFRUX4yle+gquvvvpsL52IiIiIiIjonBuKDeJQ5x7sD+7Aid4jEwbWZNly0K/3QcrRtgd2NQtZihNOLQeaYlXc6qaOqDKM5YXrpnR9UkrI7pAVzDb5Yba0A5Fo8gPHsmtQ5pVYbQ0qfRCF3llfcUdENJaQaY5ca2howD/8wz/g+PHjk59QCBw9enRKFjddGIaBAwcOYNWqVXOmZ20oFJoTPUOIaGbh/YmIpiven4goU2Kmjrd6DmJf+3Yc7apDzDx99ayUEq3hRpjSgMeejxx7LmzCNq4toJQSPZEOFGeX49sXb0kEuGdL9oetYLbJD9kUgAynORRMVaH4iqy2BpWlECWFEOrsH+xNRHPr9VM62WLalbX/+I//iLfeeuusF0dEREREREREp2dKE419b6MuuB0HOl7HkB5OeozbkYfVRRfBbc/Ds8e3YCg2YFXejsk/dFNHf7QHTpsL1y+97ayCWjkUgdkcsKpnm/2QPX3pnUAIiJICKPHWBqKsGEI76w/9EhHNOmnfEQ8ePAghBL7whS9g9erVcDgyOx2SiIiIiIiIaC4IhFuwP7gD+4M70D3ckXR/h5qFFUUbsbp4MxZ4l0IRVkVqYXYJfn70YXQM+WGYhjXESwioiori7HJcv/Q2LCtYm9KaZFSHbA3CbI5Xz3b0pD8ULN9jBbMVpVAqSiGymCMQEZ1O2mFtYWEh+vr68KlPfSoT6yEiIiIiIiKaM0KRHhzo2Im69u1oHWhIur+qqFictxJrSy7B0vzV0FT7hH2WFazFtzY+ijfe+G8c9u9EX6QPbocby30XYeXKv4HdnnXa80vDhAx0JNoamP4OYMysmlQIVw5EZXwoWEUpRG5OWscTEc1laYe1n/rUp3DPPffg6aefxsc//vFZ31OCiIiIiIiIaCoNx4ZwqHM36k4zKGwy1Z7FWFN8MVYUbUCOlnvGfc2TzZC/eRUXdvfhQrNmdOCY0gG5899hXnUZlNoKAIA0JWRnz+hQsNYgoJ++L+5kRJbDqpqt9EGp9AHeXGYFRERnKe0BY+FwGB/+8IdRX18Ph8OBvLw8KMpo828hBP7whz9M+ULPJw4YIyKaHnh/IqLpivcnIkpmZFBYXfsOHOnad8ZBYSOKs8uxpmQz1hRfjPysopSexzzZDP3Z/4EcjgI5TgibmhgwJmMGEB6C0GxQNlwIRHXI5gDk0HB6F2OzQSkvtlobVPogivIhFN77iCg9c+n1U8YHjNXX10NKieHhYfj9/nHbZ/t/XCIiIiIiIqJUSCnRkBgUtjO1QWF2L1YVX4S1JZegLKcqrffYMmZA/82rVlDrzhk91pSQegSI6kA0ChkegvHyLqAoL7XzKwqU0sJEawNRWgRhm/2FTERE50PaYe3LL78MALj00kuxcuVKaFr60yOJiIiIiIiIZqvgYBv2tb+W1qCwCwvXY03JJeMGhaXLPN4A2d1nVdTGDMhIFIhEIWLG+B0VAcQMYDgKOCcf9iWK8qBUWG0NxLwSCDvf+xMRnQtph7VutxuqquInP/lJJtZDRERERERENOP0RXpwoON17Gt/LaVBYYpQsSR/JdYUb8bSgjWwq5OHpqmSUR3GniPAcASIRCHPNBRMCAAmEBkNa4UnN97WoBTKvFKIHOe7Wg8REZ2dtMPaT37yk3jwwQfxxhtvYOXKlZlYExEREREREdG0F4kN4VDXXuxrfw0neo9CyjMEpHFV7oVYW3IJVhZtTDooLBnZNwDzVAvMk80wW9ohO3uAWAxIZdaKEIDHBdtfbYZSUQrheXdrISKiqZF2WNvd3Y28vDz8/d//PRYvXgyv1zthwBirbomIiIiIiGg2MsyYNSgsuB1HOuugm9GkxxRl+7C2+BKsLt6MAmfxWT+3NCVksMsKZ0+1QHZ0j9/hTP1nhQDsmtXOwK5BDgxCXTQf6vKFZ70eIiKaemmHtVu2bIEQAlJKHDlyZMJ2DhgjIiIiIiKi2URKica+t1EX3IE3Ol5HWO9Pekyu3YNVxZuxpngz5rmqz/q9sozFIJv8ME+2wDzVDBkeOv3ODjswOAxIaYWzNhvg0CBtKpQsx5hzGtbQsNqKs1oTERFlTtph7Yc+9CEGskRERERERDTrBQfbUBfcgbrgdnQPBZPu71CzsLxwHdaWXIJa71KoIoV2BJOQ4SGrvcGpZpiNfqu1QSqys4BoFNANwJsLYYs/vzE6YExKCYSHIAo8UBbNP6v1ERFR5qQd1j7wwAOZWAcRERERERHRedcX7cWB4E7sD+5Ac/+ppPtbg8JWYE3xxWc9KExKCdnZk+g/KwOdKR8rshwQ1eVQaiugVJVBtrRDf/Z/IMNDkDnO0cAW8Yra8BBElh3aVZeN20ZEdK7ohsTegI66gI7uAQP5rkGsKdWwrlSDprJANKWw9p577sF1112HxYsXp3zilpYW/OxnP8Ndd9111osjIiIiIiIiyrRIbAiHu/ZhX/treLv3SMqDwtaUXIxVRZvOalCYNAzIlvbR/rN9AykfK/LcVjhbMw+irBhi7ByZ2gpoH/lr6L95FbK7D9I0IaSEFAJQFIgCD7SrLmMLBCI6Lw6063h0/yACYQOGBCABdETwUkMEpTkqbl2djVUl2vle5nklpJQy2U5r1qzB0NAQLrzwQvzVX/0VNm3ahEWLFsFutyf2GRgYQH19PXbu3Int27dj7969cDgcqKury+gFnAuGYeDAgQNYtWoV1FSmas5wUkqEQiF4PB62vCCiaYX3JyKarnh/Ipp5rEFhh+KDwvalNCis0FmKtSXWoLBCZ0nazymHIjDrW6wK2oZWIKqndqAQUMqLodTEA9p8T/LnihkwjzfAPNGESKgfDk8ulAWVUBbNZ0UtEZ0XB9p1fPf1AYR1Ca9DQFMFDMOAqqrQDYneiESOJvDVTa5ZF9imky2mVFn74osv4lvf+hZefvllHDp0CACgKApcLhecTidCoRCGh4cT+0spceWVV7KqloiIiIiIiKYNKSWa+k+grn07DqQ4KMxl92D1uxgUJnv64tWzzTBbg9bwr1TYNSjzy6HUzINSPQ/CmV57BWFToS6thXJBDcKhEHL4wyQiOo90Q+LR/YMI6xKFTjHhfqSpAoVOoHPI2u/hK91ztiVCSmFtaWkpHnnkERw5cgQ///nP8eqrr6KnpwehUAihUCixX2FhId7znvek3TKBiIiIiIiIKFM6Bv2oC25HXXAHuobak+5vVx1YXrgea4o3Y2He8rQGhUnThGzrsMLZky2QPaHkB8UJt8sKZ2srIOaVQMyBT3YS0dywsy2K1n4DDhsQigC6aSJmAqoACrMBRQBCCHgdQCBsYG9Ax0Xl9uQnnoXSGjC2bNkyPPDAA5BS4vjx42hvb0dfXx/cbjfKy8tRW1ubqXUSERERERERpaw/GsKBjtdR1/5aSoPChFCwOG8F1pZYg8IcalbKzyUjUZiNfpgnmyAbWiGHIikfK0oLR/vPFuax+pWIZrRBXaJtwEBgwETbgIG2ARP+AQNvdsXQF5WwxQCrUe2oriETRdlW721NFTCkxP52hrVpEUJg8eLFrJ4lIiIiIiKiaWNkUNj+4A681XMoxUFhC7Cm+GKsKNqIXHvyXrAjZN+A1Xv2ZDPM5gBgJn8uAIDNBqXKZ/WfrS6HcGWn/JxERNOBlBJ9UQn/gInWeDDrjwezocjk90LDPH0LmNg7DhEA+qMptoyZhc4qrCUiIiIiIiKaDgxp4O2ew9jX/hoOd+2DbiSvai10lmJNycVYU7wZhc7SlJ5HmhIy2JXoPys7elJeo8hxjg4Hq/RBaHwrTkTTnykluoesSln/SCAbtn4f1NMLUxVF4J0VtSPcjvGfKJAAcu1z91MG/BeCiIiIiIiIZhRrUNhJ1AW3443g6xjQ+5Ie47J7sKpoE9aWXJLyoDCpxyCb/FYF7almyPBQymsURXlWQFtbAVFcAKHM3eCBiKa3mCkRHDQTgaw/3sIgEDYRNaamwjXbJtAXkVAEkKUKaKqApgB2YcKujd4fdUNCFcDqEm1KnncmYlhLREREREREM0LHoB/7gztQF9yBzqFA0v011YEL0xwUJsNDiXDWbPQDsVhqi1MUKBWlo/1n3a7UjiMiOkcihkT7gIm2sIG2fhOBsNW6oD1swpRT13ZAEQIlOQp8OQp8LhU+l4LibAXffX0AgbCJQqdI/MDMMEaPk1KiNyJR5lKxrpRhLREREREREdG00x8N4Y2O17GvfTua+08m3d8aFHYh1pRcjGUFa5MOCpNSQnb2JPrPykBnymsTWQ6I6nIroK0qg3DMzWE4RDS9jAz58o/pJesfMNA1ZJ6mEcHZsatWKFvmUlHmGh/M2ib5NMFn1uTgu68PoHNIwuuwhomN0A0rqM3RBG5dnT1u21xz1mFtMBjErl27EAgEcMstt6C5uRkVFRVTuTYiIiIiIiKagyLGMA537sP+4PaUB4VVuhdgTfFmrCzalHRQmDQMyJb2eP/ZFsi+gZTXJvI8UGrnQampgCgrglCUlI8lIpoqI0O+2vqtStlUhnydLadNoCxXTVTKlrmsgDbfKaCk0FJmxKoSDV/d5MKj+wcRCBswpISUgBAmVAGUuVTcujobq+ZwCwTgLMPa//t//y9+9rOfwTAMCCFwyy234BOf+ARWrFiBBx98EJo2t/+jEhERERERUXpGBoXVBbfjcOdeRFMdFFa8GauLN6Mo23fGfeVQBGZ9i1VB29AKRPXUFiYElPLi0f6zee7UjiMimgLvHPLVNmDAf5ZDvpLxOBT4xlTIluVYv3scIqU+36lYVaLh4Svd2BvQURfQ0T0wjHyXA2tKNawr1eZ0Re2ItMPap556Ck8++SQcDgeklDBNE4ODg2hra4Pf70d1dTX+4R/+IRNrJSIiIiIiollESonm/lOoC27HgY7XMRANJT3GpbmxsngT1hZfgorcmjMGCLKnL1492wyzNQik2pPRrkGZXw6lZh6U6nkQTkeql0REdFbeOeRrpHXBVA75GlHoHK2QHQlmfTkKcuzn5pMCmipwUbkdm8o0hEI6PJ7sKQuDZ4O0w9pf/vKXUBQFzz33HG655RYEg0FkZ2fj0Ucfxac//Wn8+te/ZlhLREREREREp9U5FEBd+/a0BoUtL1iLtSWXYKF3GVRl8rey0jQh2zqscPZkC2RP8vB3hHC7rHC2tgJiXgmEmnwYGRFRukaGfLXGK2UzPeSrzKWgNF4hW+5SUeJS4GD16rSWdljb0tICj8eDRYsWjXv8L//yL+F2u9HR0TFliyMiIiIiIqLZYSDaZw0KC25HU9+JpPuPDApbXbwZywvWwmFzTrqfjERhNrZZw8HqWyGHk7dPSDxHaaE1HKymAqLQy8ouIpoy4agZb1eQ+SFfpTkTK2VPN+SLpr+0w9qCggJ0dHSgpaVl3ON/+tOfEAqFUFZWNmWLIyIiIiIiopkrYgzjaFcd9rVvx1s9B1MaFFaRW4M1JZdg1RkGhcm+Aav37MlmmM0BwExxmI7NBqXKZ/WfrS6HcGWnczlERONIKRGKSKuXbNhIBLP+DAz5ytaEFcTmWMO9fGc55Iumv7TD2g984AN4/PHH8ZGPfAQDA9bEzA9/+MM4cuQIhBB43/veN+WLJCIiIiIioplhdFDYDhzu3JPSoLACZwnWFG/GmuKLJx0UJk0JGexK9J+VHT0pr0fkOK1wtmYeRKUPQjurOdtENIeNHfI1UiHrD5to6zcwFMvMkK8yl4rS+JCvslwFbvvUDfmi6S3tf6U+//nP48SJE3jllVcSjx06dAgAcPHFF+Nzn/vclC2OiIiIiIiIpj8pJVoG6lHXvh37O3amNCgsR8vFqqJNWFNyMSpzF0wIIaQeg2zyW/1nT7VAhodSXo8oyh/tP1tcAMGPAhNRCiYb8tU2YKB9iod8CQAF53nIF01faYe1drsdjz76KHbu3InXX38dPT09KCoqwvr167Fp06ZMrJGIiIiIiIimoa6hIOqC27Gv/bXUBoUpdiwrXIu1xZdgUd7yCYPCZHjIam9wqhlmox+IxVJbiKJAqSiN95+dB+F2nc3lENEcETEkAvEg1j+mUjbTQ77Kcq1KWQ75ojM5689/XHTRRbjoooumci1EREREREQ0zY0MCqsL7kBj39tJ9xdCwaK85VhTfPGEQWFSSsjOHpgnrYBWBjpTXofIckBUl0OprYRS5YNw2M/qeoho9ho75GtsMNs5NLX9ZDnki6ZS2mGtYRj4+c9/jj179iAcDsN8RyN3IQS2bt06ZQskIiIiIiKi8ytqRKxBYcHX8Fb3IZjSSHpMRW4N1hRfjJXFm+C2exOPS8OAbGmP959tgewbSHkdIs8zWj1bVgSh8OPCRHPd6YZ8tQ2Y6MvQkK+ynNFAlkO+aKqlHdZ+73vfw1NPPQXA+oZ4JzY7JiIiIiIimvkMaeBEzxHUBbfjcOdeRIzhpMfkO4uxpvhirCnejOLsssTjcigCs77FanHQ0ApE9dQWIQSU8mJrQFhtBUSe+2wvh4hmOFNKdA2Z8QFf8dYF8YrZTAz5GqmQLXUpKI8HsxzyRedC2mHtf/7nfwIAFixYgOXLl8Nu50dNiIiIiIiIZoPEoLDgDhwI7kB/CoPCsjUXVhddhNXFm1HlXpgIMmRPX7x6thlmaxBItQ+kXYMyv9waEFY9D8LpeDeXREQzTMyUaA+bCIStQLY1HsxmeshXWTyYLXOpyNYYyNL5k3ZYG41G4XQ68atf/QqapmViTURERERERHQOdQ0FsT+4A/uCr6Fj0J90f2tQ2BqsKb4Yi/NWQFVskKYJ2doO41QLzJPNkD19KT+/cLuscLa2AmJeCYSqvpvLIaIZIBKTCITP7ZCvROsCDvmiaSztsPav/uqv8N///d8IBoMoLy/PxJqIiIiIiIgow8J6P97o2IV97a+lPChsgXcp1pZcggsL1sFhc0JGojBPtEA/2QxZ3wo5HEn5+UVpYbz/bAVEoZcfLSaapcJRE23hia0LujIw5Ms3ppfsSMVsEYd80QyTdlh711134cCBA/jIRz6CK664AoWFhVDe0dT9c5/73JQtkIiIiIiIiKbGyKCwuuAOHOt+I6VBYfNyq7Gm+GKsKtoEtyMPsm8A5uFG6CebYTYHADPFwMVmg1Lls/rPVpdDuLLf5dUQ0XQhpURvRCaqY/0DJtr6ra8zPeSrLFeBL4dDvmj2SDusffHFF9HQ0AAAeO655ybdh2EtERERERHR9GBKEyd6j6Ku/TUc6tyT2qCwrCJrUFjJxSjK8kEGu2DubUD01J8hO3pSfm6Rkx1vbzAPosIHoaX9FpSIppGxQ77aBkwEztGQL1+8lyyHfNFckPa/lI888ggAQFVVlJaWsm8tERERERHRNCOlROtAA+qC23EguBN90d6kx2RrLqws2oS1xRej0lkNNAdgbm+Afuo1yPBQys8tivJH+88WF0Dw48dEM87IkK+R1gVt8WFfgQETujn1Q77Kckd7yXLIF811aYe1fX19sNls+P3vfw+fz5eJNREREREREdFZ6B7uQF1wO+radyA42Jp0f5uiYXnhWqwu3oxF9kVQGgIwX2mG3rgHiMVSe1JFgVJRGu8/Ow/C7XqXV0FE50okJuEPjwz4igezAyaCgwamMJOFIgRKc5REL9mRStmSHA75InqntMPayy67DK+++iq8Xm8GlkNERERERETpCOv9ONixG/uCr6EhdDzp/iODwtYUb8YyLIC9oQvm/maYgcNItbOkcDog5pdDqa2EUuWDcNjf3UUQUUaNHfLV1m8gED43Q75GWhdwyBdR6tIOa6+77jrs2bMHn/jEJ/C3f/u38Hg8EwaMvf/975+yBRIREREREdF4uhHFka461AW3462eN2CYyQeFlbvmY3XRRVip1yK3sQ/m7mbIvgYkP9Ii8jyj1bNlRRDveB9IROfXuCFf8Z6yIwO/pnrIV44mUOpSUTYmkOWQL6KpkXZYe/311wMAuru7cejQoQnbhRAMa4mIiIiIiKbYyKCw/cHtONixO+VBYavyNmDV0HwUNeswd7YC0d2pBbRCQCkvhlJTYfWfzXO/62sgonfvnA/5yrWC2JFK2TKXglwO+SLKmLTDWinP/I2fbDsRERERERGlRkqJtnAj6tq3Y3/HTvRFepIe49RysDJnFVYPzkdFg4Dc0QHIt1NrcWDXoMwvtwaEVc+DcDre9TUQ0dmZMORrwIQ/nJkhX4XZY1oXxINZH4d8EZ0XaYe1x44dy8Q6iIiIiIiIKG5kUNj+4E60h1uS7m9TNFxgX4zV4SosOGWH2hMG0IFU4hzhdlnhbG0lxLxiCFV91+snotSNHfKVaF2QgSFfqiJQkq2M6yXrc6kozVFg55Avomkj7bCWiIiIiIiIpt6gPoA3OnahLrgd9aG3kh8ggQVKJVb2V2BZkwuOIQlAj/86M+ErsgLamgqIQi8/zkx0DowM+Wrrt8LYTA/5Ksu1glgO+SKaWVIKa9///vejqKgIW7duTdqPVgiB3/zmN1OyOCIiIiIiotlMN3W82VWHfe3bcaznQPJBYYYJn1mAVX0VuLDFC08sK74hSfmdzQalymcNCKueB5HjnJL1E9F4kw35ahswEMjQkK9E6wIO+SKaNVIKa0+dOoXBwcHE12fCn8gSERERERGdnilNnOx9E3XB7TjYuRuR2NCZD9Bj8OrZWNlXjpXtxSiJeVJ6HpGTHW9vMA+i0gdh4wcriaaKKSU6B034w+NbF/gzMOTLm6UkgtiyeOsCDvkimr1S+tf6s5/9LHJzcwEAn/vc5zK6ICIiIiIiotnGGhTWhLrgdhwI7kQo0n2mnYGojqyoigt7S7GytxxV0SIoSB7KiKJ8KLXx9gbFBRD8yDPRuzJ2yFfbSCCb4SFfZfFglkO+iOamlMLaa6+9Fmq8yTzDWiIiIiIiotT0DHdif3AH9gW3n3lQmGlCRnTYIgYW9xVhdX8VFg37YEOSYV+KAqWi1GpvUDMPwu2a2gsgmiMmG/LVNmCig0O+iOgcSymsvfzyy+Hz+fCnP/0p0+shIiIiIiKa0UYGhe3v2IFTvcdOv2PMgIxEgYiOmoF8rAovwvKheciS9jOeXzgdEPPLodRWQqnyQTjOvD8RjRqIvrNK1gpmMzHkq2xMEFsWr5gt5JAvIkoi5aZFUk5tzxUiIiIiIqLZwhoUth91we14s/sADDM2cScJQNfjAW0UpcNurBpchJWDVfAY2Wc8v8jzjFbPlhVBKEpmLoRoFuCQLyKayc57h/ne3l489NBDeOWVVzAwMIDFixfj9ttvx7p16wAAb775Ju677z4cPnwYXq8X119/PW666abE8aZp4kc/+hGee+459PX1Ye3atfjGN76BqqqqxD7JzkFERERERJQuU5o4FTqGunZrUNhwbHCynSCjVjiLiA5PzImVgzVYFa5Cacx7+pMLAaW8GEpNBZTaCog8d8aug2imOh9DvsrG9JLlkC8iyoSUw9pwOIwtW7aktO8tt9yS8gK+9KUvoaurCw899BDy8/Px9NNP46abbsKvfvUr5Ofn48Ybb8R73/te3HvvvThw4ADuvfdeeL1eXHvttQCARx55BM888wzuv/9+lJSU4MEHH8Qtt9yCF154AXa7HT09PUnPQURERERElKq2AWtQ2P7gjskHhRkGZES3AtqojizTjguHKrBqcD6qImcYFGbXoMwvh1IzD0r1PAinI7MXQjRD6IZEcHBM64J4pWx7ODNDvsZWyJblKijN4ZAvIjp3Ug5rBwYG8NBDD6W0b6phbWNjI7Zv345f/OIXWLNmDQDg61//OrZt24YXXngBWVlZsNvt+OY3vwmbzYba2lo0NjZiy5YtuPbaaxGNRvHkk0/ijjvuwGWXXQYA+P73v4+/+Iu/wEsvvYSrrroKzz777BnPQURERERElEzvcBfqgjtQF3wNgckGhen6aEAbM6BCwZKhcqwarMLiobLTDgoTHheU6nlQaish5hVDqEkGihHNYsMxq3VBIDzausB/DoZ8lbkUlHLIFxFNEymHtaqqori4eEqfPC8vDz/5yU+wfPnyxGNCCEgpEQqFcPjwYaxfvx422+gyN23ahMceewxdXV1obW1FOBzGpk2bEtvdbjeWLl2KPXv24KqrrsLevXvPeI6CgoIpvSYiIiIiIpodhmJhHOzYjX3B1yYOCpMSMhoPZyNRjCRJ1ZFirB6cj2WDFXCeZlCY8BVZ1bM1FRCFXn6EmuacczXky6GKRMuCRKUsh3wR0TSXclhbWFiIl19+eUqf3O12JypiR/z2t79FU1MTLrnkEnz/+9/HokWLxm0fCYzb2toQCAQAAD6fb8I+fr8fABAIBM54jnTCWinlnBi0NnKdc+FaiWhm4f2JiKYr3p9mD93Ucax7P/YHd+Jo9/7xg8IMMzEcDLpuDQwDUKp7sWpwPlYMVsJr5Ew8qU2FUumDqK2w2hvkOMdt5t8byqTzdX8aGfI1rpdsPJTtj07tWqwhX/H2BTkKSuNf52WdfsgXv++Izr+59PopnWs87wPGxtq3bx/uuusuXHHFFbj88stx//33w24f/9Noh8Pq2xSJRDA0NAQAk+4TCoUAAMPDw2c8Rzr6+vqgzIGpq1JKDA5awxH4U34imk54fyKi6Yr3p5nNlCaaBk7gYPcuvNm7H8PGmEFhsRgQ0SGiOmAYiYfdsWysDFdiZbgKpbo38bgBax+ZnQWz0gezshSyvBiwxdsbxKJAKHouLosIQObvT6aU6BoG2geB9iGJ9kEgMAgEByWGjeTHp8NjB0qyBUqygRKnQGkOUOIEXJqEEBLAmCeMAv38ViOa1ubS6yfTTP2TA9MmrP3DH/6AL3/5y1i5cmWiN25WVhai0fF315GANTs7G1lZWQCAaDSa+HpkH6fTmdI50uF2u6HOgR5SI2m/x+OZ9d8sRDSz8P5ERNMV708zkz/cPHFQmJRQYka8vYEOjHlz5ZB2XDhYidXvHBQWf4sgivKh1MyDqJkHUVwAwY9Z03mkGxJ7Azr2t+voGshCgUvD6hIN60o1aGfRl3VkyJd/wERbeHTQ1/ghX+PPezZvn0eGfPlcCspy4u0LXBzyRTQbzaXXT4aR+k+vUgpr77///kT4mQn/+q//ivvuuw9XXnklvve97yUqYUtLSxEMBsftO/LnkpISxGKxxGOVlZXj9lmyZElK50iHEGLW/+UZMXKtc+V6iWjm4P2JiKYr3p9mht5IN/YHd6AuuB3+gSbrQdMcHQ4W1YExH1UcGRS2crAKS945KExRoFSUQqmtsEJat+scXw3R5A6063h0/yACYQOGhNWyoyOKlxqiKM1RcevqbKwq0SY9dmTIl9W2wIi3MeCQLyLKjLny+imd60sprL366qvPejHJPP300/j2t7+N66+/Hnfddde4NgPr16/HM888A8MwEhWtO3fuRHV1NQoKCpCbmwuXy4Vdu3Ylwtq+vj4cPXoU1113XUrnICIiIiKi2c0aFLYHdcHXcCp0zKrkiRlj+s/GJhwzPzEobB6ypSPxuHA6IKqt4WBKlQ/CMfkQMaLz5UC7ju++PoCwLuF1CGiqiL8fVqAbEm0DBr77+gA+vy4bBU51XD/Ztn4D3cPnYMhXroIipwKV1edERBOc1zYI9fX1+M53voMrr7wSn/rUp9DV1ZXYlpWVhWuvvRaPP/44vv71r+Pmm2/GwYMHsXXrVtx7770ArF611113Hb73ve8hPz8f5eXlePDBB1FaWoorr7wSAJKeg4iIiIiIZh/d1PFW9xvY1/4a3uw+gJihA7o+GtAaEwOpYt2D1YPzsXKwatygMJHvscLZ2nkQvmK2N6BpSzckHt0/iLAuUei0KtUMExiOAUZMQjeBmCnhD0vcs20AlW5lyqrZcjRhDfiKB7Nl8d/PNOSLiIgmOq9h7e9+9zvouo6XXnoJL7300rhtV199NR544AE8/vjjuO+++3D11VejqKgIX/nKV8ZV+n7+859HLBbD3XffjeHhYaxfvx5PPPFEopVCQUFB0nMQEREREdHMZ0oT9aG3UBfcjoMduzEUHYCMRkf7z04yidltOLFycD5WDVbBp+dZDwoBZV5xPKCtgMhzn+MrITo7ewM6AmEDLrtAXxQI6yaixsjf+9EfUCgAYiYQ1gFXmsXheVkKSuP9ZMtyrUpZn0tBrn32f4yZiOhcEFJO8oqFxjEMAwcOHMCqVavmzICxUCg0Jxo8E9HMwvsTEU1XvD+dX/5wM/YHt6MuuAO94WC8ela3+s9OwiE1LB+swOrB+ZgfKbYGhdk1KPPLrf6z1eUQWY5JjyWarnqHTXxn5wD2BnSkcheKmYDbIVCcrUzYJgAUZY9pXTDSU5ZDvohoCs2l10/pZIvntbKWiIiIiIjobIwMCtvfvh1tvSdHB4TFJp+2rEDB4qEyrB6cnxgUJjwuKEsroNRUQMwrhpgDhRk0uwxETewL6Njt1/FWVwz+AQOGCdgm5q+TkhLWcK94hexI64LSHAUah3wREZ0XZxXWnjp1Cn/+858RDodhmhN7PX3uc5971wsjIiIiIiIaayg2iEOde7CvbRtOdh4c7T97hhH18yPFWDVYheWDFciWDghfEZQ11oAwUeid9ZU8NPsMxSQOtOvY1abjSGcM5pgPyyqKADDx+0EAsKsCmgpoioCmAH1Rib+uceBza3Mm7E9EROdP2mHtf/7nf+Kuu+7CmbonMKwlIiIiIqKpEDN1HOs+iH3NL+No+17EhgcBXZ8sj0oo1j1YFR8Ulic8UKp88fYG8yBynOdu8URTJGpIHAzGsNsfxcFgDPppfkCRbRPoi0hIaVXXZmsCOZqAJkyo6mi5rW5IaAqwtlQ7V5dAREQpSjus/fGPfwzTNKEoCoqLi5GVlcWfRhMRERER0ZQxpYn63rdQd+olvNH+OoaGQ6dtbzAi13Bi5WAVVg3OR5m9DGptBZSaeRCVPggbu7/RzBMzJY50xrC7TceBoI7hWPJxM/lOgagpEIkBJTkCSvy9ujHm20dKid6IRJlLxTqGtURE007ar1qCwSCEEPjFL36BlStXZmJNREREREQ0B/lDjah767fYH9yBnuFOYJKWa2ONDApbNViFGvcS2C6otNobFBdAKCwooZnHlBLHumLY7ddRF9AR1pMHtJoisLLEhg0+Oy4ssuFoZwzffX0AXUMSXgfG9Z7VDSuozdEEbl2dzb60RETTUNph7QUXXIATJ04wqCUiIiIionett7sV+4/9D/Z1bIc/6rcmHp2BNSjMh1VDNVhavBaO1fOtClq36xytmGhqmVLiVK+B3W069gR09EXO/EMKAFAVgeWFNqz3aVhdoiHLNhq6rirR8NVNLjy6fxCBsAFDWm0RhDChCmug2K2rs7GqhFW1RETTUdph7V133YVPfOITeOihh3DTTTfB4/FkYl1ERERERDQLSSkxFGjDG8dfwv7O13HSaEjpuPmRIqyKLcSK0ovgWr0ISlUZhJ1hE81MUko09ZnY7Y9ij19H11DygFYRwOICGzb67FhTYkOOXTntvqtKNDx8pRt7A1aFbvfAMPJdDqwp1bCuVGNFLRHRNJZ2WPutb30LOTk52LJlC7Zs2QJVVaGqamK7EAIHDhyYyjUSEREREdEMJmMG9OZWHDuxDXWdO3FUaYAhztyDFogPChMXYHXZX6Bw4XIIXzHbG9CM1jZgVdDu9utoDyf/HgCABXk2bCizQlaP4/QB7TtpqsBF5XZsKtMQCunweLI5b4aIaAZIO6w9fPjwuD/HYjHEYrHEn3nzJyIiIiIiORRB7FQTGk7uRl3vbhyy12NIiQLqmY/LNZ1YpS3H2vLLUL5oPZR8fpKPZrbOQRO7/FHsbtPR0p9aQFvlVrG+zI71pRoKs1MPaImIaOZLO6y9//77M7EOIiIiIiKa4WR3CObJZgTqD6Kufx/eyG5AjxoGss58nB12rHAux+p5l2HhkkuhOp3nZsFEGdIzbGKPX8cev45TvbHkBwDwuVRs9GlYX6ahNCfJTzWIiGjWSjusvfrqqzOxDiIiIiIimmGkaUK2BWGebEFv/TG8ET2C/TkN8Gs9QO6Zj1VUGxZnX4C1Fe/BskXvgd3OgJZmtv6oibqAjl1tOo53x3DmUXmWQqeCDWV2bPBpmJer8JOqRESUflgLALqu49/+7d/whz/8AZ2dnSgqKsJf//Vf42Mf+9i4/rVERERERDS7yEgUZkMbzFPNGGqox2FxEgdyGnAqOwiZnSSe0myoyqnF2srLsbLmPXDZ3edm0UQZMqhLHGi3etAe6dRhppDQehwKNvg0bCjTUO1RGdASEdE4aYe1kUgEN954I/bv3w8prX+JGhoasHfvXrz00kv4yU9+ArvdPuULJSIiIiKi80OG+mGeaoF5shnRlja8bW/DgewGHM1vPfOgMCEAu4ZiVznWVl6ONRV/ifysonO3cKIMiBgSB4M6drfpONQRg55CQuuyC6wt1bDRZ8fCfBUKA1oiIjqNtMPaRx55BHV1ddA0De9///sxb948NDc347e//S127dqFxx57DLfddlsm1kpEREREROeANCVke2cioDU7u9Fk78SB7AYcLG2yBoWdjqIAWXbkZhdgTcVlWFP6Fyh3zWf1IM1ouiFxpDOG3X4dB9p1RIzkAa3TJrC6xKqgvaDABpvC7wEiIkou7bD2xRdfhBACW7ZswaZNmxKPX3311bjxxhvx61//mmEtEREREdEMI/UYZJPfCmdPtUAODiFo68OB7Aa84YsPCjsdmw3I0uBw5uLC0s1YW3oJFniXQhGcYk8zl2FKvNUdw642HXXtOgb15AGtXRVYWWzDBp8dFxbZoKkMaImIKD1ph7WBQAAul2tcUAsAF110EVwuF9rb26dscURERERElDlyYNCqnj3VDLPJD8QM9ClDOJjdiAPFjWizd09+oBCA3QY47FAdWVhStAZrijdjacEa2FXHub0IoilkSomTPQZ2+3XsDejoi5hJj1EVgQsLbdhQpmFlsYYsGwNaIiI6e2mHtUVFRfD7/Th27BiWLFmSePzNN9/EwMAAysrKpnSBREREREQ0NaSUkB09Vjh7qgUy0AkAiAgdR5wtOOBtwMmsdsjJ5tgrAnDYAYcdwq6hyrMIa0suwcqijcjRcs/xlRBNHSklGvusgHZPm47u4eQBrSKAJQU2bPTZsbrEhhw7q8iJiGhqpB3WXn755fjXf/1X3Hjjjfj//r//DxUVFWhubsbTTz8NIQQuv/zyTKyTiIiIiIjOgowZkC3t8YC2GbLPamdgwMTbWX7sz27Am85WxCYbFGZTrXDWYQc0G4qyfVhbfAlWF29GgbP4HF8J0dRq7Tewx69jt19He/gMg/LGWJhnw/oyDetLNbgdDGiJiGjqpR3W3nbbbXjllVfQ0tKCRx55JPG4lBI+nw+f/exnp3SBRERERESUHjk0DLO+1eo/29gGRHXrcUg02TvxRnYjDmY3YVCJTDzYrsUDWg1QVeTaPVhVvBlrijdjnquag8JoRguG4xW0fh0t/akFtPM9Kjb47Fjv05DvZEBLRESZlXZY6/F48Ktf/Qo/+tGP8Ic//AEdHR0oKirCZZddhttuuw15eXmZWCcREREREZ2B7A7Fh4M1w2zrAORoK4OO+KCwA9mN6LENjD9QjLQ30KwKWiHgULOwvHAd1pZcglrvUqhCPcdXQzR1eobNRAVtfW8spWPKXCo2lmlY59NQmsO//0REdO6kHdYCgNvtxl133YW77rprqtdDREREREQpkKYJ2RaEedIaECZ7+sZt71eG8EZ2I97IbkTrOweFqcpoewO7BgBQhIrF+RdibfElHBRGM15fxMS+gBXQvt0dm6wL8wRF2Qo2+OzYWKahPJcBLRERnR8phbUHDx6E3W7HkiVLcPDgwaT7r1ix4l0vjIiIiIiIxpORKMyGNiucrW+FHB7fxiAidBx1tmB/9iSDwjTbaEBrGw2iqtwLsaZ4M1YWbYLL7j5Xl0I05QZ1ibp2q8XB0U4dZgoJbV6WgvU+DRt8GuZ7VLb5ICKi8y6lsPYjH/kIfD4f/vSnP+EjH/nIGf8BE0Lg6NGjU7ZAIiIiIqK5TIb6YZ5qsVoctLQD5vhJ9QZMnMgKxAeFtUAfGRQmBGC3j/afVUZ7bRY6S7G2xBoUVugsOZeXQzSlIjGJN4JWBe2hjhhiKSS0LruCdaVWQLswX4XCgJaIiKaRlNsgyDE9r8Z+fab9iIiIiIgoPdKUkO2diYBWdvZM3AcSzfYuHMhuGD8oTFGArCwIux2w26zANs5l92B10UVYU3IxB4XRjKYbEkc6Y9jVpuNAUEfUSP4e1GkTWBMPaC8osEFV+PefiIimp5TC2j/+8Y+w2WyJr4mIiIiIaOpIPQbZ5I8PCGuBHByadL9OWx8OZDfiQHYDukcGhdlsQJbTCmi18S/v7aoDywvXY03xZizMW85BYTRjGabEm10x7PHr2BfQMRRLHtDaVYFVxRo2lGlYXmiDpjKgJSKi6S+lsLa8vDzxdVtbG+x2O1auXDluH8Mw8Morr8Bms43bn4iIiIiIJpIDg1b17KlmmE1+IGZMut+AMoyD2Y3Yn91gDQoTwqqadeRYAa2qjNtfCAWL81ZgbcnFWFqwBg4161xcDtGUM6XEiR4Du/069vp19EfNpMfYFIHlRTZs9GlYWazBYWNAS0REM0vKbRBGXH/99Yn+tWOpqoqvfvWryM7OxrZt26ZsgURERERE05WMGTCPN8A80QRbqB8xTy6UBZVQFs2HsI2vYpVSQnb0WOHsqRbIQOdpzzsyKOyN7Ea8nRWAVAA47IAjF8KujWtvMKLKvQBrii/GiqKNyLV7pvpSic4JKSUaQgb2+K0+tD3DyQNaRQAXFNiwwWfHmlIN2RoDWiIimrmShrVSStx+++3o7Bx9MdnV1YUbbrhh3H6Dg4MYGBiAYUxeEUBERERENJuYJ5uh/+ZVyO4+wDShSglDCBh1b0Lku6FddRlEVRlkS2C0/2x/+PTng4m3swI4kN2Io85m6Briw8HcENrkL9sLnaVYU3Ix1hRvRqGzNENXSpR5rf0GdrXp2OOPIjiYPKAFgEX5NmzwaVhbqsHtUJIfQERENAMkDWuFENi8eTPuvvvuxJ91Xcfu3bsn3X/9+vVTu0IiIiIiomnGPNkM/dn/gRyOAjlOCJsK0zCgqCpkNAbZ3o3ok/8BeHMh1NOHSBISLfbuxKCwcJYRD2hzIdTJ+8u67B6sKtqEtSWXcFAYzWjt4dEK2tb+1Ip+5ntUbCyzY71PQ14WA1oiIpp9UmqD8Hd/93eor6/HwMAAfvnLXyI7Oxt/8zd/k9guhIDNZsO8efPwoQ99KFNrJSIiIiI672TMsCpqh6OAO8cKS2MGMDQMqRuArgNSAqYEunohi/ImBKojg8LecDWhKzsCODQIR/Zpg1dNdeBCDgqjWaBn2MTuNh27/VE0hFILaMtzVWzwadjg01Ccw7/7REQ0u6Xcs/aOO+4AAEQiEXi9Xtx5550ZWxQRERER0XRlHG+A7OwFbDbE+vtwKLsJR10BhL1R5MTsWNpXggt7S2GDYoW4w1HA6YgPCmvCAW8LWrJDEA47YNcgoE36PNagsAuxuvhiLC9YA4fNeW4vlGiK9EVM7A3o2OPXcbw7ltIxxdkKNpTZscGnoTyXAS0REc0daQ8Ye+CBB067LRQKYceOHXjf+973rhZFRERERDRdSCmB3n6YLe0wWwIw9h0FBofwZl4nflGzH52OMEwhE/tvL6pHYSQHH29cjdqQF0ez6vFGVQhvO9sBhwbYVAjknPb5KnJrsbbkYqws2sRBYTRjDeoSdQEdu/xRHOuKwZTJj8nLUrDBp2G9T8N8j8oWH0RENCelHdZ2dnbirrvuwv79+xEOh60Xr2MIIRjWEhEREdGM9c5wVja3Qw6MGQwWieJNTxBbandjyKYjV3fAJkcr/2LCgN/Zh4cu2Ia8iBNaVjZEvgdA1mmfs9BZijXFm7G6eDOKsn0ZvDqizInEJN4I6tjVpuNwZwyxFBLaXLuCdfEWBwvyVCgMaImIaI5LO6z97ne/i23btp12e0FBwbtaEBERERHRuZQIZ5sDMFvaIVsCkAODp90/ppj4xfw3MGTT4Y06IWCFS1HFwJBNx5CqIyZMmMKEnmWgTM3BZPGTS3NjZfEmrCm+GJW5tawipBlJNyQOdcSwx6/jQFBH1Ege0DptAmtLNWwo07Ak3wZV4d99IiKiEWmHtTt37oQQAnfffTd+97vfwTAMfPrTn8azzz6Ll156CV/+8pczsU4iIiIioimRbjj7TocKgujMCiNHd2DYZiCqGBiOB7QjBAQUqSAmTAzZjETTA011YHnBWqwtuQQLvcugKmm/HCc672KmxLGuGHb7ddQFdAzFkge0dlVgVYmGjT4Nywpt0FQGtERERJNJ+9Vhb28v8vLy8Pd///cwDANPPvkkLrnkEqxduxavvvoqtm7dig996EMZWCoRERERUfrGh7Pxtgbh1MPZEX0uEw1lUfzadgoDw1GEbTomLZmNE1IAiolhRcfa/JVYXbwZywvWclAYzUimlHi728Buv469AR0DUTPpMTZF4MIiGzaWaVhRpMFhY0BLRESUTNphrdfrRX9/P/r7+7FixQq0t7ejoaEBhYWFEEKgoaEhA8skIiIiIkqNlBLo6bN6zjYHIFvSD2clJLpzdTT6dNTn9qBe9aPH6AEABAcDMBVANQFITB7YSsAuVZiqHauKN+HmC7/yrq+L6FyTUqI+ZGB3m449AR29w8kDWkUASwutHrSrSzRkawxoiYiI0pF2WLtmzRr8/ve/x0033YSnn34a2dnZ+MQnPgFN0zA8PAyfjwMRiIiIiOjcmRjOBiDDQ2mdw4REhzuC+pJhNLp7US9a0S/HDBUzRr9UhQoIQKgqpGFYga31P7BJFdmGBqdwwu72oNPsgdfBmQ40c0gp0TpgYnebjt3+KDoGkwe0AsDCfKuCdk2JBrdDyfxCiYiIZqm0w9ovf/nLOHz4MLxeL2w2Gz72sY/hiSeeSGz/6Ec/OqULJCIiIiIaS0oJ2dMHOdJztjkAOZhuOGvC7xlCffEwGnK70SD8GMLwmCc5/bFZthz0632QAlA0DXZocBgq7IYNDpsDyLFDOBzQpQ5VV7G8cN1ZXinRuRMIG9jTpmO3X0fbgJH8AADVXhs2+DSs92nIy2JAS0RENBXSDmsrKyvxu9/9Ds3NzQCs8LaiogLHjx/HmjVr8IEPfGDKF0lEREREc5eUErI7BNnSftbhbAwGmj1hNJYMoSGnG43Cj6iIpb0Wp5aDJfkrsa99O8KxfhRmlUARVkhlGAaEqibW3B/tQXF2OVYUbUz7eYjOha4hE3v8Ovb4o2gIpRbQzstVsaHManNQlK1meIVERERzz1mNn9U0DTU1NQAAIQQ+9rGPTemiiIiIiGjuGhfOjvScTTOcjQgdTZ4BNBQPoiG7G80iAENJPrH+nXLtHtR4LkCNZzFqPEtQkjMPilBwUdk+PHLgn9Ab6USuPQ+aoiWO0U0d/dEeOG0uXL/0tnHbiM63voiJPQEdu9t0nOhJ7QcWxTkKNvrsWO/TUJ7LgJaIiCiT0g5rv/a1r512mxACTqcT5eXleN/73sf+tURERESUVCKcHWlrcBbh7KCIoNHbj4aiQdQ7O9EmOiDV9Acb5WcVodqzOBHQFjpLIcTE8ywrWIvPrLobPz/6MDqG/DBMA5ASEAKqoqI4uxzXL70NywrWpr0GoqkWjpqoa49hlz+Kt7piMFP4uUV+loL18QraKrc66fcBERERTb20w9r/+I//GPcPtZRy0j8//PDD2Lp1K1asWDE1KyUiIiKiWWFiOBuAHBxOfuAYfcqQFc4WhlHv7EC76ALUsRV/qQVLxdnlVtWsdwlq3EvgzUp9GNiygrX49sVbcLBjFw537kVPuAt5OQVYXrgOK4o2sqKWzqvhmMSBoI49bToOdcZgpJDQuh0K1pVq2FCmodarQmFAS0REdM6lHdbeeeedeOqpp9DR0YFLL70UZWVlaGtrw7Zt2+D1enHFFVfgyJEjOHLkCB5++GFs2bIlE+smIiIiohliXDjbHIBsbU8rnJWQ6FHDaPD2oaFgAA1ZnehSQu8IZ5N/NFsIgbKcKtR4lqDasxjVnsXItXvO4opGaYqGtSWXYE3xxQiFQvB4PKxApPNGNyQOdcSw2x/FG8EYokbygDZbE1hbYgW0i/NtUBX+/SUiIjqf0g5rBwYG0N7ejieffBIXXXRR4vFt27bh//yf/4MFCxbgzjvvxMaNG3Hw4MEpXSwRERERTX/SlJDdvaM9Z88inO2w9aHBY4Wz9Y4g+tQhQB07bT55OKsIFRW5NajxLEGNZwnmexbCacs5iysimr5ipsSbXTHsbtNR165jOJY8oHWoAqtKNGws07Cs0AYbA1oiIqJpI+2w9plnnoHL5RoX1ALApZdeCpfLhZ/+9Ke44YYb4PF40NPTM2ULJSIiIqLpaUI429IOOZR6OGtCwq/1oMHTh8b8ftQ7ghhU9XeEs8ppjx+hKXZUuReixrMY1Z4lqHIvgF11nMUVEU1vppQ43m1gtz+KfQEdA9HkAa2mCFxYZMOGMg0rijU4zqKnMxEREWVe2mFtOBzG8PAwXn/9dWzatCnx+Ouvv46BgQEYhoHGxkb09vYiOzt7ShdLREREROefNCVkVy9ky5iBYGmEszEYaLV3o8HTh/q8PjTZOxCxmWmHsw6bE9XuxfHK2cWYl1sNG/vE0iwlpUR9yMCuNh17/DpCETPpMYoAlhVaQ8JWlWjI1hjQEhERTXdph7WbN2/GH//4R9x8883YtGkTiouL0d7ejtdffx1CCGzYsAEvvvgiYrEYFi5cmIk1ExEREdE5NDGcDUAORVI+PipiaLZ3WuGstw/NWgdimkg7nM3RchMtDWq8S+DLqYQikh9HNFNJKdHcb2KPP4rdbTo6h5IHtALAonwbNpZpWFOqIdfO7xEiIqKZJO2w9u6778axY8fQ2tqK1157DUIISGl97KaiogL33HMPtm7dClVVcfPNN0/5gomIiIgos6xwtmd8W4Ph1MPZIRFFo6MDDZ4QGjx9aNG6IDV1TDibvN8sAHgc+aj1XoBq92LUei9AkdPH4V00JwTCBna36djt1+EfMFI6ptZrw3qfhnU+DXlZDGiJiIhmqrTDWp/Ph1//+td4/vnnUVdXh/7+fhQWFmLdunX44Ac/CIfDgcsvvxzXXHMNLrjggkysmYiIiIimkDQlZGfP+LYGaYSzA8owGhwdaHCHUO/pRUDrBTTbmHA2tdYEhc7SRNVsjWcJ8hyFDGdpzugcNLEnoGN3WxRNfakFtBVuFRt8Gjb47CjMZkBLREQ0G6Qd1gJATk4ObrjhBtxwww2Tbn/n8DEiIiIimj7ebTjbq4ZR7+hAoyeE+txedGh9EJo2Jpy1p3QeX04FajxLUB3vOet25J3F1RDNXKGIib1+Hbv8Ok72xFI6piQnHtCWaShzpValTkRERDPHWYW1gUAAjz32GHbs2IH29nYcOHAADzzwAK666ipceOGFU71GIiIiInoXEuFscwBmSwCyNZhyOCsh0WXrR4OjA/XuXjTk9qJHGxwXzgo4kp5HCAXzXNXxqtnFqHYvRrbmelfXRTQThaMm9rXHsNsfxVtdMZgy+TEFTgXrfRo2+uyocCusOCciIprF0g5r6+vr8fGPfxyhUAhSysQLhV/+8pf45S9/iaeeegorV66c8oUSERERUWreTThrQqJd6423NehFfU4PBuzRtMNZm6Kh0l2LGrfV1qAqdwEcNue7ui6imWo4JrG/3epBe7gjBlMmT2jdDgXrS60K2hqvCoUBLRER0ZyQdlj70EMPIRQK4UMf+hBefvll9PX1IRKJ4IILLkBdXR3++Z//GT/96U/PajGPPPIIdu7ciZ///OeJx772ta/hV7/61bj9SkpKsG3bNgCAaZr40Y9+hOeeew59fX1Yu3YtvvGNb6Cqqiqx/5tvvon77rsPhw8fhtfrxfXXX4+bbrrprNZIRERENN1Y4Ww3ZHO7Fc62tENGoikda8BEm70H9Y4gGnNDaMjpxpDdGBPOipTCWbvqwHz3okS/2YrcWmhKar1qiWajqCFxqCOGXW1RHAzGoKdQQpujCawptSpoFxcwoCUiIpqL0g5rd+3aBafTiW9/+9vYsWMH+vr64HA48NOf/hSbNm3C4cOHz2ohTz31FH74wx9i/fr14x5/6623cOutt+K6665LPKaqo72ZHnnkETzzzDO4//77UVJSggcffBC33HILXnjhBdjtdvT09ODGG2/Ee9/7Xtx77704cOAA7r33Xni9Xlx77bVntVYiIiKi80maErKje3zP2RTDWR0xtDi6Ue8IoiG3F03ZPYjaMSactUGk8BLRqeUkqmZrPEtQ5qqCKtg/k+a2mClxtDOG3X4d+9t1DMeSB7RZNoHVJRrW+zQsK7TBpjCgJSIimsvSDmsjkQg0TYPNNv7QWCyGWCwGRUlvCml7ezu+/vWvY9++faiurh63zTAMnDhxAp/5zGdQVFQ04dhoNIonn3wSd9xxBy677DIAwPe//338xV/8BV566SVcddVVePbZZ2G32/HNb34TNpsNtbW1aGxsxJYtWxjWEhER0YzwznDWbGkHUgxnI0JHo6MTDfYg6t29aHH2wrArEHYNUBQADqQSDbntXtR4R4aBLUFJdjkUwenzRKaUON5tYFdbFPsCOsJ68oBWUwRWFNuwwWfHhcU2OFQGtERERGRJO6xdsWIF9u7diwcffBDRqPUm4dVXX8VPf/pTxGIxrF69Oq3zHTlyBB6PB7/+9a/x4x//GK2trYltDQ0NiEQiqK2tnfTYY8eOIRwOY9OmTYnH3G43li5dij179uCqq67C3r17sX79+nHh8qZNm/DYY4+hq6sLBQUFaa2XiIiIKNMS4Wy856zZGkw5nB1UImiwdyQqZ9ucfZB2dUw460wpnM3PKkKNZwlqvBegxrMYBVklHGpEFCelxMleA7v9Ovb6dYQiZtJjFCGwrNCGjWUaVpVocNr4/UREREQTpR3WfvGLX8QnPvEJPPnkk4nHbr31VkgpYbPZ8NnPfjat811++eW4/PLLJ912/PhxCCGwdetWbNu2DYqi4LLLLsMXvvAF5ObmIhAIAAB8Pt+444qLi+H3+wEAgUAAixYtmrAdANra2hjWEhER0XknTRMy2A3ZYvWcNVvagaie0rF9yiDqHR1ocARRn9uDYNYAYNfGhLPZKYWzJTnzUONZjBqPVT3rdeS/q2simm2klGjuN7G7LYrdfh1dQ8kDWgFgSYEN630a1pZqcNlZjU5ERERnlnZYu2bNGvzsZz/Dgw8+iDfeeAOGYUBVVaxevRr/8A//MKHn7Lvx9ttvQ1EUlJeX49FHH0VjYyO++93v4vjx49i6dSuGhoYAAHa7fdxxDocDoVAIADA8PDzpdsBq6ZAOKSVkCpNbZ7qR65wL10pEMwvvTzRbjA1nZUs7zNbUwlkJiR41bFXNOjpQn9uNbseQFc7Ge84KuJKeRwgFZTmV8WB2Mardi+Gyu8c/F7/P0sL70+zlHzCwx69jt19HIJw8oAWAWq+K9T4N60o1eLNGA1r+/aDzgfcnIpqu5tL9KZ1rTDusfemll7Bq1So8/fTTiEQiCIVCKCgoGDf0a6rcdttt+OQnPwm323rzsGjRIhQVFeGjH/0oDh06hKysLABW79qRrwErhHU6nQCArKysRLuGsdsBIDs7O6319PX1pd2TdyaSUmJwcBAA+HFHIppWeH+iGcs0IbpCEG0dUAKdUPxdgJ5aONuh9aHB0YGGrA40uHoQckQBzWb9irc1GNkbhjHpeRShoiy7ClWuhahyLUSFqxZZqjOx3RiSCA2FpuBC5y7en2aXrmGJAx0SdR1Aazi1N1flOQJrioFVhQIFWQYAA4gMI5RefQjRlOP9iYimq7l0fzLN1H7gC5xFWHvPPfcgHA7j1VdfRX5+fqKlQCYIIRJB7YiRlgaBQCDR/iAYDKKysjKxTzAYxJIlSwAApaWlCAaD484x8ueSkpK01uN2uzMSSk83I2m/x+OZ9d8sRDSz8P5EM8Vo5WwgXjkbnFg5O8lrChMm/Fov6h1B1Ds60JjTg0GHAdht8bYGDqhwJH1+m2LHfPdC1HgWo9qzBJW5tbCryY+js8f708zXO2xib0DHHr+Ok70GEG8gcqaX/6U5Cjb4NKz3afC5Zv/7BJqZeH8ioulqLt2fjNMUVUwm7bDW5XLBMAx4vd50D03b7bffjt7eXjzxxBOJxw4dOgQAWLBgASoqKuByubBr165EWNvX14ejR4/iuuuuAwCsX78ezzzzTKJdAwDs3LkT1dXVaferFULM+r88I0auda5cLxHNHLw/0XSUCGebAzCbAzDbJglnJxGDgVZ7d6KtQUNOD6IOAJoGYbcBSlZK/WazbNmo9ixCjccaBlbumg+bor3r66L08P408wxETewLWC0O3uqKIZUa2gKnFdBuKLOjIlfh/980I/D+RETT1Vy5P6VzfWmHtV/60pfw1a9+Fbfeeis++MEPoqioCFlZWeOedMWKFemedlIf+MAH8OlPfxr/8i//gquuugr19fX41re+hQ984AOora0FAFx33XX43ve+h/z8fJSXl+PBBx9EaWkprrzySgDAtddei8cffxxf//rXcfPNN+PgwYPYunUr7r333ilZIxEREc090jQh27usqtk0wtmoiKHJ3mn1m3UE0Zzdi5hDGRPO5qQUzro0N6o9i1HjvQA1niXw5VRAEbO/VRPRVBiKSRxo17GrTceRzhjMFHrIeRwK1vk0bPRpqPGqs/4NJREREZ0/aYe1t99+OwDgz3/+M/785z9P2C6EwNGjR9/9ygC85z3vwQ9+8AM8+uijePTRR5Gbm4u/+Zu/wRe+8IXEPp///OcRi8Vw9913Y3h4GOvXr8cTTzyRGCpWUFCAxx9/HPfddx+uvvpqFBUV4Stf+QquvvrqKVkjERERzX7SMCGD6YezgyKCRsdoONuWHYJpt40JZ3NTCme9joJ4MLsYNZ4lKHL6GBYRpSFqSBwMxrDbH8XBYAy6mTygzdEE1vk0bPDZsShfhcLvOSIiIjoHhExz5NpIL9gzOXbs2FkvaDoyDAMHDhzAqlWr5kzP2lAoNCd6hhDRzML7E50r0rAqZ82RnrMphrMDynCipUG9I4iAcwAYF86mVv1a6CxFbbxqttqzGPlZRe/2kijDeH+afmKmxJHOGHa36TgQ1DEcS/62J8smsLpEwwafhqWFNtgU/n9JMx/vT0Q0Xc2l+1M62WLalbV//OMfz3phRERERNPRhHC2NQjoycPZHjWMhjHhbGfWIGDXEuGsUDxJzyGEQGlOBWrcVluDas9iuO3eKbgqornHlBLHumLY7ddRF9AR1pMHtJoisKLYho1ldlxYZINdnd1vFomIiGh6SzusLS8vz8Q6iIiIiM4ZK5zthNnSbg0Fa+tIGs5KSHTa+sdVzoYckXeEs96kzy2EgorcGtR4lqDGsxjz3YuQrbmm6MqI5h5TSpzqNbC7TceegI6+iJn0GEUIXFhkw3qfhtUlGrJsDGiJiIhoekg7rP3a17522m1CCDidTpSXl+N973sffD7fu1ocERER0VSQhhGvnE09nDUhEdB6E8Fsg6MDYbtuhbN2DUJzQCjOpM9tUzRUumtR47HaGlTl1sJhS34cEZ2elBJNfSZ2+6PY49fRNZRKQAssLrBhg8+OtSU25Ng5lI+IiIimn7TD2v/4j/8Y10dCSjnpnx9++GFs3boVK1asmJqVEhEREaUoEc42j+k5q8fOeIwBE232btTHw9lGeyeG7caYcNYJoeQkfW6HmoX5nkWo9ixGrecCzMutgaZoU3VpRHNa24BVQbvbr6M9bKR0TG2eDRvLNKwr1eBxMKAlIiKi6S3tsPbOO+/EU089hY6ODlx66aUoKytDW1sbtm3bBq/XiyuuuAJHjhzBkSNH8PDDD2PLli2ZWDcRERFRgjQMyEC852xzAKa/I2k4qyOGZkcX6h0daHAE0WTvhK5hTDibA5HCQDCnloNaz+gwsDJXFVQx+weSEp0rnYMmdvmj2N2mo6U/tYC2yq1ifZkd60s1FGYzoCUiIqKZI+2wdmBgAO3t7XjyySdx0UUXJR7ftm0b/s//+T9YsGAB7rzzTmzcuBEHDx6c0sUSERERAZOEs20dQOzM4eyw0NHo6Ei0NWixd8O0iTHhrAcihcnvbrsXNd4libYGxdllUATDIKKp1DNsYo9fxx6/jlO9Z/7eHuFzqdjg07DBp6HUxR+YEBER0cyUdlj7zDPPwOVyjQtqAeDSSy+Fy+XCT3/6U9xwww3weDzo6emZsoUSERHR3CVjhjUQrLkdsiW1cDasRNAwMgzM3gG/vQfSpowJZ70phbP5zmLUepag2rMENZ4lKMgqHtcCioimRn/URF1Ax642Hce7Y5ApHFPoVLChTMMGnx3zchV+bxIREdGMl3ZYGw6HMTw8jNdffx2bNm1KPP76669jYGAAhmGgsbERvb29yM7OntLFEhER0dwgYwZkoNMaCJZiOBtSB0eHgdk7ENRCgE0dE87mpRTOluTMQ41nCWo8i1HtWQKvI3+qLouI3mFQlzjQbvWgPdKpw0whofU4FKuCtkxDtUdlQEtERESzStph7ebNm/HHP/4RN998MzZt2oTi4mK0t7fj9ddfhxACGzZswIsvvohYLIaFCxdmYs1EREQ0y4yGs2MGgsVO35tSQqJbHUj0m613dKDHNvCOcDbfGv9+BkIoKHdVodqzJF49uxg5Wu5UXx4RjRExJA4Gdexu03GoIwY9hYTWZRdYW2pV0C7KV6EwoCUiIqJZKu2w9u6778axY8fQ2tqK1157DUIISGm9wKqoqMA999yDrVu3QlVV3HzzzVO+YCIiIpr5rHC2Y7Stgb/jjOGsCYmgLTRaOevoQL86BNhsgN2WcjirKjZU5NbEK2eXYL57EbJszqm+PCJ6B92QONIZw26/jgPtOiJG8oA2yyawpsSqoL2gwAZbCpXxRERERDNd2mGtz+fDr3/9azz//POoq6tDf38/CgsLsW7dOnzwgx+Ew+HA5ZdfjmuuuQYXXHBBJtZMREREM0z64ayJNq1nXDg7pETTDmc11YH57oWJcLYytxaaap/qyyOiSRimxFvdMexq01HXrmNQTx7Q2lWBlcU2bPDZcWGRDZrKgJaIiIjmlrTDWgDIycnBDTfcgBtuuGHS7e8cPkZERERzy2g4G4BsbocZOHM4G4OBFnt3IphtdHQgKmKJcFbYHRB2F5Dko89ZtuxEr9kazxLMc82HqpzVyx0iOgumlDjZY2C3X8fegI6+iJn0GFURuLDQhvVlGlYVa8iyMaAlIiKa1aJRoLUVMAygsPB8r2baSfvdy49+9KPTbhNCwOl0ory8HJdeeimcTn6skIiIaC6QMQPS32H1nE0hnI0IHU32rkS/2WZ7FwxhAJoN0GwQdieEXUsazrrsHtR4FqPGswTVniXw5VRAEcpUXx4RnYGUEo19VkC7p01H93DygFYRwOICGzb57FhdYkOOnd+3REREs4ppAh0dQE8PsGTJ+G2f/jTwxhvA5s3At751ftY3jZ1VWJvKxNXCwkJs3boVNTU1Z7UwIiIimr7Gh7MBmIHOM4azgyKCRkdnonK21d4NCTkmnM1OKZzNyypMDAOr8SxBobOUk+CJzpPWfgN7/Dp2+3W0h0///T/WwjyrgnZ9qQa3gwEtERHRjNffDzQ2Ak1NQEOD9fvIr+FhoLgYePHF8cdUVlphbXPzeVnydJd2WHv99dfjpZdeQiAQwKJFi1BWVoa2tjYcP34ceXl5WLp0KU6dOgW/349//ud/xg9/+MNMrJuIiIjOIRmLWeHsSM/ZJOFsvzI0rt9sQOu1NmjxtgaaK6Vwtijbl+g3W+1ZjPysoim8KiJKVzAcr6D162jpTy2gne9Rsd5nx3qfhgInA1oiIqIZJxq1Xrdr2uhjO3cC//iPVuXsmQSDwNAQMPbT92vXWuesrs7Meme4tMPa6upqtLe344EHHsCHPvShxOPPPfccvvGNb+Caa67Bxo0bcdlll2Hv3r1TuVYiIiI6RyaEs/5Oq6fUZPtCokcNjwtnu2z91sZEOJsLJAlnhRDw5VSi2rMYtfG2Brl2TyYuj4jS0DNsJipo63tjKR3jc6nY6NOwvkxDaY6a4RUSERHRuzbStqCxcbRSduRrvx/43veASy8d3d/jOX1Qq6rAvHlAVZVVRavr48PaD3zA+iUlEApl9rpmoLTD2scffxw5OTnjgloA+PCHP4wHHngAP/zhD/G73/0OeXl56O3tnaJlEhERUSbJWAyybWzP2TOHsx22/kS/2QZHECF10Nqo2QC7llI4qwgVFbnV8WFgizHfvQjZmisTl0dEaeqLmNgXsALat7tjkCkcU5StYIPPjg1lGspdCluUEBERzQTf+hbw5ptWOBuJnH6/pqbxf66stIaDVVWN/qqstH4vK7MGBdNZSfu/XFdXF6LRKI4fP45FixYlHj9+/DjC4TAMw0BXVxdCoRDsdvuULpaIiIimhtTHhLMtZw5nTUgEtN5x4WxYib+QSyOctSkaqtwLEsPAqtwL4FCzMnF5RHQWBnWJunarxcHRTh1mCgmtN0vB+lING8o0VHtUBrRERETTQTQKtLRMrJAtKwO+/e3x+779tvXrdLKzrQDW9Y6iCpcL+J//mfq1U/ph7apVq7Br1y78/d//Pd7//vejuLgY7e3tePHFFyGEwLJly/D8889D13UsXrw4E2smIiKiNI0PZ+NtDczJJ7bHYKDV3h1va9CBRkcHIkK3NibCWTdgt50xnHWoWaj2LEa1ZzFqPBdgXm41NEU77f5EdO5FYhJvBK0K2kMdMcRSSGhddgXrSjVs8GlYmK9CYUBLRER0fh08CPz+96PBrN8/+Wv9zs6Jj1VVAcePj29bMLZaNj8/6ZwJmlpph7V33XUXrr/+evT19eHZZ59NPC6lhMfjwT333IP//M//BAB8/OMfn7KFEhERUerGhbPN8YFgpwlnoyKGZntXot9sk70TMRGvsh0JZ+1O6+szvFDL1lzjhoGVuaqgCvaqJJpudEPiSGcMu9p0HAjqiBrJA1qnTWBNPKBdUmCDTeGbNiIionOir29ihezttwPFxaP7NDQAzzyT/FyxmPVpOnXMa/SvfhX45jfZtmAaSfv/icWLF+PXv/41nnrqKezbtw99fX0oKirC2rVrcd1116GoqAgrV67Ev/zLv+A973lPJtZMRERE7yCjOqS/M6VwdlhE0ejoTLQ0aLF3w0R8X80G2O0Qdi1pOOt25KHGswS1ngtQ7VmM4uwyKIKT3ommI8OUeLMrhj1+HfsCOoZiyQNauyqwqljDep+GC4ts0FQGtERERBljGMCrr1qhbFOTFcA2NQGTzYO6+urxYW1V1ejX2dnA/PlWhWxl5fivs7Mnnis3d2qvg961s4rNS0tLceedd066befOnXjf+973rhZFREREZ2aFsx0wW9qThrMDyjAaHB3xX0H4tV7IkXFBmg2wO1IKZwucJfHKWautQX5WEftTEk1jppQ40WNgt1/HXr+O/ujk94ixVEXgwkIbNpZpWFGsIcvG73EiIqIpYZpAMDhaHVtSAlx22eh2IYC777b6zSbT2Ahs2jT650WLgJ/8hG0LZokpqXHu7u7G888/j3//939Hc3Mzjh49OhWnJSIiojgZ1ScOBDtNOBtSB1HvCCbaGnTY+kY3ajbAnpVSOFuaMw81ngtQ41mMas8SeBx5U31ZRDTFpJRoCFkB7R6/jp7h5AGtIoALCmzY4LNjdYkNOXZWyBMREZ21/n6rKvadrQuamsYHsZdeOj6sVRSr+vXEidHHioom9pGtrLQGhY3ldAJr1mT0sujceVdh7Y4dO/DLX/4SL7/8MmKxGKSUrLAhIiKaAqmGsxISXbYBNNg7UJ8VRIMjiB41PLqDZgPszqThrBAK5rnmJ4aBVXsWIUfjR6KIZorWfgO72nTs8UcRHEwe0ALAonwb1vs0rCvV4HYwoCUiIkpZNAq0tFgh7F/+5fjX2Fu2AE8/nfwcTU0TH7v5Zus1/5naFtCsl3ZY29XVheeffx7PPfccWlpaAFg/wbfb7bjssstw1VVXTfkiiYiIZjsrnA3CbG6HbAnAbO+aNJw1IRHUQomq2QZ7B/rVodEdUgxnVcWGytzaxDCw+e5FyLI5M3V5RJQB7WEDe/w6dvt1tPYbKR0z36NiY5kd60o15DsZ0BIREZ2WaQLt7ROrYxsbAb8fkPG2Yi++OL5/7Pz5E89lswHz5o3vIVtdPXG/9743E1dCM0zKYe1rr72GZ599Fi+//DIMw4CUo0MJhBD405/+hIKCgowskoiIaLaRUR2yNWj1nG2J95yVEwf+mDDRpvWg3mFVzjbaOzCkxD8+JWC98EshnLWrDlS5FyaGgVW6F0BTtAxeIRFlQs+wid1tOnb7o2gIpRbQlrlUbCyzBoWV5KjJDyAiIppL+vqs1+Eez+hjgQBwzTWp9Y9tahof1i5bBlx77cS2BSr/DabUpBTWXnHFFWhrawNgVdEWFhbigx/8IK699tpEJW02S7OJiIhOazScDVgB7WnC2RgMNNu70ODoQL0jiCZHJ6IiZm1MI5x12nLiLQ2stgblriqoypS0qieic6wvYmJvwOpBe7w7ltIxxdkK1vvs2FimoTyXbw6JiGiOi0aB5ubJ+8j29gL/+38Dn/nM6P5FRYBxmh+K5uSMD2JLSsZvX7wY+NrXMnYpNPul9K6ttbUVQgg4HA587Wtfw9/93d9B5U8EiIiITisRzjYHYLaePpyNCB1N9s5EW4NmRxcMxNsfpBHOuuwe1HiWoNazBNWeJSjNmQdF8CPORDPVoC5RF9Cxyx/Fsa4YzIm3jwnyshSs92nY4NMw36NylgQREc0tUk58rfzjHwO/+934tgWTaWwc/2dVBTZtsn4faVswEtDm5Z1xSC/Ru5VSWGuz2RCLxRCJRPDtb38bL7/8Mq6++mpcfvnlmV4fERHRjCAjUWsgWHPAGgrW3jXpC8JBEUGjwwpn6x1BtNl7IBHfLxHOOpKGs/lZRYlhYDWexSh0ljKYIZrhIjGJN4I6drXpONwZQyyFhDbXrmBdPKBdkKdC4X2AiIhmu1BoYg/ZxkarncGLL45//RwOA/FPik+quNgKYBcvnrjtBz+Y+rUTpSClsPbPf/4z/uu//gvPP/883n77bbz66qvYtm0b3G53Yh++QSQiornECmetgWBnCmf7lCE0xKtm6x0daNd6RzcmwlktaThbnF0WHwa2BDWexcjLKszMhRHROaUbEoc6Ytjj13EgqCNqJA9onTaBtaVWD9oLCmxQFb4OJyKiWaypCXjySev3hgYrlD2dUAjwekf/XFk5vm3BSOuCqiqgogJgS0+ahlIKa/Py8vDJT34Sn/zkJ3Hw4EE899xz+O1vf4tQKJTY533vex/+1//6X/jrv/5rrFq1KlPrJSIiOi9kJJoYCHa6cFZCokcNJ1oaNDg60GXrH91BwApktTOHs0II+HIqUeNZEg9oFyPX7pmwHxHNTDFT4lhXDLv9OuoCOoZiyQNauyqwqljDxjINywpt0FQGtERENMOZpjXI6509ZD/2MeCSS0b3i8WAF14487lsNmDePKv/7Niw9sMfBj76UbYtoBkl7UkjK1aswIoVK/D1r38dL774Ip5//nns27cPfr8fW7duxc9+9jMcPXo0E2slIiI6Z0bD2fhAsNOEsx22vsQwsHpHEH3q0OgOKYazilBRkVuTCGfnexbCacvJ8BUS0VTQDYm9ASt07R4wkO8axJpSDetKtXGBqikl3u42sNuvY29Ax0DUTHpumyJwYZENG3waVhZrcNj4RpOIiGawP/4ROHZsNJhtbrYGf73TypXjw9p586zX0FKOti0Y20O2shIoK7P6y74T5y3RDHTWY6GzsrJwzTXX4JprrkFDQwOee+45/Nd//Re6urqmcn1ERETnhBXOtlttDVonD2dNSAS03kTlbL0jiEElMrqDAKBpgN0GoZ0+nLUpGqrcCxPDwCrdtXCoWRm+QiKaagfadTy6fxCBsAFDApAAOiJ4qSGC0hwVn1rlhCdLwe42HXsCOnqHkwe0igCWFlotDtaUaMjWGNASEdEMEIlY4etIlayUwP/+3+P3+eUvgbq65Ofy+8f/2W4HnnkG8PnYtoDmhLMOa8eaP38+7rjjDnzpS1/CK6+8MhWnJCIiyig5HBnfczbYPSGcjcFAq70b9Y4ONDiCaHR0IiL00R2ESCmcdahZ8WFgVuXsvNxq2BQt05dIRBl0oF3Hd18fQFiX8DoENFXAMAyoqoIhXeJUbwxfeaUfhU4laeAqACzMt2FjmRXQuh3KubkIIiKidPX1AUePThzwFQiMfy2dnz8xrK2qGg1rbTarZ+xIZez8+dbvlZVAXt7E562tzdglEU03UxLWjlBVFVdcccVUnpKIiGhKyOHIaFuD5nbIjonhbFTE0GzvTISzTfYuxIQxukOK4WyOljuu32yZqwqKYPhCNFvohsSj+wcR1iUKnQJCCOgmMBAFhgwTUUNCSsCQQMegiUq3Mukw3mqv1eJgvU9DXhbvEURENE2EQqNh7EUXAYVjBtvu2gV87WvJz9HdDQwMAC7X6GPXXAO85z1WQFtayhYFRKcxpWEtERFRJsiYAfN4A8wTTbCF+hHz5EJZUAll0XwI2+Qv8lIJZ4dEFI3xQWANjg4027sgMWafFMNZjyM/Ec7WeJagOLts0mCGiGaH19uiaOk3YFeAziGJiCERM0fuHdbvQgAqgJgJhHXAZbe2zstVsd5nDQoryuabVCIiOk/Gti1oaBg/5Kuvb3S/Bx+0AtYRVVUTz+VyjfaPHdtP1ukcv98FF2TkUohmG4a1REQ0rZknm6H/5lXI7j7ANKFKCUMIGHVvQuS7oV11GZTaitFwtjlgtTXo6JkQzg4ow+OGgQW03vFPlmI4W+gsTbQ1qPVegDxHIcNZollKSomuIautwcleA6d6Dez2R9EflbAlKYYdmYUiBPCBBVnY4NNQnsuAloiIzhHTtNoTRCJAdfX4bVddBfT2Jj9HY+P4P1dUADfcMLFtAV8LE00ZhrVERDRtmSeboT/7P9AjQzhU1Ik3XX4MiCG4pBMX9JfiwvYI5FP/CVFWDAxHJoSzvWo40dKg3tGBTlvf+CcQwgpk7TYIuwbYNKt55Dv4ciriLQ2WoMazGG7HJH20iGhWGI5JNISMceFsX2T8YLCYIU9z9CibIpCjCUQMidUlNly9iEMEiYgoA6Qc37ZgbB/ZlhYgGgU2bAAeeWT8cRUVk4e1JSXjq2PXrRu/3ekEPv/5jF0OETGsJSKiaUrGDOi/eRVHbY34RU0dOm39MGHGP2Es8Vr2URR6c/Dx+lW4oDEGWeRFtzaQqJxtcHSgRw2PP2kK4awQCua55lstDbxLMN+9CDla7rm6bCI6h0wp0R4246FsDKd6DbT2GzCTZLGKIgBM3EkRgEsTyNEUOOKvsoODErl29qMlIqJ3KRKxPgGmjPk35fnngR//eHzbgsk0NU187JJLxg/4qqqy/vzO1gVEdM4xrCUiomlHxmIwXj+Io4NHsKV6J4bUKHKjDtjk6MeHY8JAIKsfP1yyHct6i9GXbSCsRcefKBHOahB226ThrKrYUJm7ADXxtgbz3QvhsPFFKtFsFI6aOBWyqmVPxQPaQT15lew7ZdsE+iNWGwSnTcChWr8UGFDV0TfRuiGhCmB1iTaVl0FERLPVSNuCkR6yY/vJBgLAr35lBasjnM7TB7WaZoWvlZVWy4KRvjwjbropgxdCRO9GSmHt+9///pRPKITAb37zm7NeEBERzS3SlJC9fZD+DshAJ0x/J2RnD/SebvxiwT4MqVF4o04ICESFgagaQ0QxEFViMIQJU0jsLWiBL+KBIrQx4awG2GwTwlm76sB89yLUeK1hYBW5tdAUBilEs41hSrQOmFY7gx4rnA2EjbM+n8suUOO1odarotKt4Ef7BhEIm8jPEome1caY00sp0RuRKHOpWFfKewwREZ3G0BDwj/84vm3B6TQ1jQ9rq6pG2xaMrZCtqgJ8vvFVuEQ0Y6QU1p46dQpCCEiZvPKAA1aIiOhMZHgIsj0eygY6YQY6gcjEF6V73Y3wO/tgMxV0OQYRVQzId3zsWEBAkUBMMTGcJZGTlz8hnHVqOah2jw4DK8uphKrwgyVEs00oYsZDWavXbEPIQDSF3rKTUQRQkauiJs8KZ2u8KoqzlXGvcz+zRuC7rw+gc0jC6wA0dXSbblhBbY4mcOvq7HHbiIhojhgeBpqbR/vHjvSS3bgRuPXW0f2ysoBdu4DBwdOfKzfXCmDfGb4uWwawWI5o1knp3epDDz2Ef/qnf0JPTw9WrVqFiy++ONPrIiKiWUDGYpDBbki/FcrKQAdkaGDifpDotPWj0d6JRkcHmhydOGZvwaBNh01OVhEgEqGsgICEgSFVR44Acu0e1HguSLQ1KMmZB0WwqoBoNtENiaY+Ayd7DdT3GjjZG0PXkJn8wNPwOBQsyFNRHa+crfKocCQJWFeVaPjqJhce3T+IQNiAIWX8E6YmVAGUuVTcujobq9gCgYhobnjtNWD79tFQNhCYfD+3e/yfhbAqYk+eHO0h+84qWY9nfAsDIprVUm6DsHDhQnz0ox/FW2+9he985zuorq7O9NqIiGgGSbQzCHTGw9kOyI4eq/fWO+iIocXejSZHJxodnWi0d2BIGV9da4zLV8WEitkRNqlAAJjvrMFn19+PQmcpP+VBNItIKdE1JBMVs6d6DTT1GYglmwJ2GpoiUOlRExWztV4b8sa0MkjHqhIND1/pxt6AjrqAju6BYeS7HFhTqmFdqcaKWiKi2UBKoLd3NIRtaABaW4H77x9f6VpXBzz3XPLzDQ1NfOxHP7JCXLYtICKkMWBs4cKF+OIXv4j77rsPDz30EB5++OFMrouIiKY5OTgMGehItDOQgU7ISdoZAEC/MpQIZRsdnWiz98DEO0JcVbH6zWo2CJsNtlgMIhoB5Pig1iZVOKQNDtMGu9SgxoBuxyCqfStRlO3L4BUT0bkQiUk0hIxx4WwocvZVs0XZSqLXbI1XRYVbhU2ZuhBVUwUuKrdjU5mGUEiHx5PNHxgREc1U4TCwc+f4wV6NjUB//8R929utvrAjqqpGv3a7J1bHVlZalbNZWRPP5fVO9ZUQ0QyWVtO+j370o5BSQlEUSCn5QpSIaI6QMQMy2JW0nQEAmJBo13rRaO+MV852oEcNj99JCGtC7Ug4q9kmVBJkiRz06yFoUkVWzAY7NNihQZHx1gdSAqZETDWhZmVhedH6TF0+EWWIKSWCYTMRyp7sjaG138BZFs0iyyZQ7VFR47WhJh7Ouh2sUiIiojjTBPz+0R6yy5YBK1aMbg+FgDvvTO1cTU3jw9pLLgGeeIJtC4joXUsrrLXb7bjhhhvOuE8sFoPNxsEtREQzlTQl0NtnhbJJ2hkAQEToaLZ3JSpnmx1diAh9/E42NR7MalYwa1MnPVeu3YP57kWo9ixGuasaPzl4P4IDLXCHNSBmAvFqXCvHEYBNQX+OgZLcCqwo2jhl/w2IKDPCURP1odFes6d6YwjrZ5nMwuoLOxLK1ubZUOZSoPDNMRER9fSMBrIj7QsaG4GWFkAf8zr1hhvGh7WlpYDdDkSj4x+rrATmz7d+H/m6tHT8cxYUWL+IiN6llFLVLVu24JZbbkm634EDB3D33XfjhRdeeNcLIyKicyPRziAezp6pnYGERK86aA0Bs3eiwdGBdi0EiTFhi6oAmj3RzgCabdLKAiEEfDmVqHIvjAe0i5DnKBz3qY0bln0ejxz4J/SoA3DLHNiiJmTMgLCp0O0C/WIQ2TY3rl96GzSFQ3yIphPDlGgdMFE/pp2Bf8A46/PlaGK0nUGeimqPDdkag1kiojlraAhobga6u4FNm8Zv+8Y3gB07kp+jqWn8nxUF+PKXrcrYM7UtICLKoJTC2v/3//4fIpEIPve5z026fWhoCA899BCefvppmKepvCIiovMvnXYGAGDAhF/rQYOjw2ppYO9EvzpmKIIQiVYGp2tnMMKhZqHSvQDV7kWY71mEytwFyLI5z7jeZQVr8ZlVd+PnRx9Gx5Afhr22FYsAAQAASURBVN0ANAkIAVVRUeIsx/VLb8OygrVn9d+DiKZOX2SknUEMJ3sMNIQMRIyzq5pVBFCRq6Imzwpnq70qSrIVtuAiIpprTBNoaxutjB075CsYtPbJzgZefXV8cUBV1cSw1m4H5s0brZCtqgIWLZr4nNdck6mrISJKScr9Cn784x9jeHgYX/7yl8c9vn37dvzjP/4j2traEv1siYjo/JvQzqC9EzLYfdp2BgAwKCLxPrNWMNti70JMjKmEs6mA5kjazgAA8rOKMN+zKFE568upgCLS/zdiWcFafPviLTjYsQuHO/eiJ9yFvJwCLC9chxVFG1lRS3Qe6IZEc7+Bkz1Wxeyp3hg6h87+B/Yeh4IFeSqq45WzVR4VDpXBLBHRnCCl1bYgK8sKXkfs3Qvcdtv4tgWTGRy0qmvHtiBYvx4wjPFDvkpLT1tUQEQ0naQU1m7evBk7duzAE088geHhYdx9993o6+vDd77zHfzXf/0XAEBKiQsvvBB33313RhdMRESTs9oZxHvMJmlnAFgtDbps/WgYMwisw9Y3uoOiAHYbYHNYwexp2hkAgCJUlLvmY75nEardC1HlXgSPI2/Krk1TNKwtuQRrii9GKBSCx+NhhR3ROSKlRNeQxKneWDyYNdDYZyB2llPANEWg0qNa7Qy8Kmq9NuRlCX5PExHNdiNtC8b2kB35ur8f+Na3gPe/f3T/4uLTB7Vu9/gesuo7CgguvdT6RUQ0A6UU1j722GP4yle+gt/+9rf4t3/7N7S2tuLQoUPo6uqClBKFhYX44he/iGuvvTbT6yUiIqTfzgAAdMTQau9Bo6MDjY5ONNk7MahErI2JdgbOpO0MAMCp5VjtDNxW5Wxlbi001T6Vl0hE50kkJtEQircziIezocjZV80WOhXU5NmwIB7OVrhV2BQGs0REs5KUE3+4f889wL59o20LTued/WPLyqw2BfPmja+QraqyesoSEc1SKYW1mqbh+9//PvLz8/Fv//ZveOWVVyClhM1mw/XXX4/PfvazcLlcmV4rEdGcJE0JhPph+jvilbPJ2xkAQL8yFG9nYPWbbbX3wET8GJsaD2ddSdsZAEBRtg/z4+FstWcRipw+VsERzQJSSrSHzUQoe7I3htZ+A2dZNAuHKlDtVUcHgXlVuB38yCkR0awy0rZgbGXsyNf5+cBPfjJ+/66u0we1QljtCaqqrHB2LJsNePrpzFwDEdE0lnLPWgC45557kJ+fj4cffhhCCGzevBl33HEH+9QSEU0hOTQcr5hNrZ0BAJiQaNd60WQf7TfbY4tX2ibaGWQlbWcAADZFQ0VuLao9CxP9ZnO03Km8RCI6Twb18e0MTvXGENbPMpkF4HONtjOo8dpQnqtA4Q9yiIhmnzfeAP7930fD2YHTfKKrp2fiY5WVwFtvTayOrawEKioAhyOzaycimmHSCmsB4LOf/SwKCwtx77334s9//jO++MUv4qGHHoL6zh4xZ+GRRx7Bzp078fOf/zzx2Jtvvon77rsPhw8fhtfrxfXXX4+bbropsd00TfzoRz/Cc889h76+Pqxduxbf+MY3UFVVlfI5iIjOF6udQTdkoCMxCEyG+pMeFxE6mu1dicrZZkcXIkIf087ABmi5SdsZAECu3ROvmF2MKvdClLuqYOPQLqIZz5QSrf1mIpw92WvAP2AkP/A0cjSBGq8tHsxa4Wy2xmCWiGhGMwygrW1iD9k77gBqakb36+oCfvvbM5/LbgcKC63etE7n6ONf/jJw552ZWT8R0SyUUlj7/rFNvuPsdjuGh4fx+9//Hu9973vhjN+MhRD4zW9+k/ZCnnrqKfzwhz/E+vXrE4/19PTgxhtvxHvf+17ce++9OHDgAO699154vd5Ef9xHHnkEzzzzDO6//36UlJTgwQcfxC233IIXXngBdrs9pXMQEZ0LUkqgN/12BhISveogGh0daLJ3osHRgXYtBAk5pp2BA0LLSdrOQAgBX05lomK22rMIeY5CtjT4/9m787io6v2P468zwwz7KgiICrhgmZrlkla2qN1Ks25alpb1a9X25ZpZtmibmtpmq9mtXCq9aVa3bNO0XbMyb1rugOKKsu/MnN8fIwMDKEsig7yfjwcPmTPnnPkehC/Dez7z+YocB7KLnO5QdltmKdszHRQ56lc1azGgdXCFdgbhVqIDLJorRESaMtOEDz90hbHJya5/d+6E0tKq+27d6hnWlhVDVWxbULlKNiam+iIBnzrXiImINGu1mjW3bdt22PtM02T37t3u23V9Er93714mTJjAL7/8QmJiosd9CxcuxG63M3HiRHx8fGjfvj0pKSm8/vrrDBs2jOLiYv79739z3333cfbZZwPw7LPP0q9fP7788ksGDx5c4zlERBqKWVDoCmXLWhnsSccsLKrxOAdOdtsySPZ19ZpNsaeTYy1wPfk9VDVrlFXN1jDn+lr9aBvSwbUYWGgSbYM74Ofjf8RjRMT7lTpNUrMd5eFsRinpBfVfBCzU13IolPWhXaiVhFArvj4KZkVEmpSCgvIK2dRUaNkSLr64/H7DgJdfhoMHaz7Xrl2et+PjYcEC12JfalsgItKgahXW3n777Q02gPXr1xMaGspHH33ESy+9RFpamvu+NWvW0KtXL3wqvBLXp08fXnvtNQ4cOEBaWhp5eXn06dPHfX9ISAidO3fm559/ZvDgwTWeo0WLFg12bSLSfNS3nQFAvlHkCmUPBbM77QcotTgrtDPwwbCF19jOACDCL4qE0CR35WxsYBsshvqKizRlpmlysNDVa3ZrhoNtWQ5SsxyU1HMVMB+LQXyolXahVtqHu6pnI/wMVc2KiDQV+/fDpk3lbQvKwtnKi3ideqpnWAuu0LUsrLXbq1bHlv0bGup5nI8PtG/fcNckIiJuRz2sLS4+8iI4lfXv35/+/ftXe9+ePXtISkry2NayZUsAdu3axZ49ewCIjY2tsk9ZtW9N56hLWGuaputtzMe5sutsDtcqUh/udgZ70jEPtTQw92fU2M4AXC0NDvjkkGxPPxTQ7me/T3aFdgY+YAvCqMXbxSyGhbigBBJCkkgIcQW0ob7h1Y/3OKH5SZqDolKT5GwH290tDRxkFdW/ajbS3+LuM9s+zErrYCs2a9VgVj9Xf4/mJxE5akzTtVBXWRA7aJArWC2zeDG8/nrN50lNhQpzk2macNNNruesbdtCdPThiwE0l4nIMdCcnj/V5Rrr1Dxm9+7dHDx4kMTERAICAqrcv3LlSh5//HG++uqrupz2sAoLC7FX/KUE+B56y0VRUREFBQUA1e6TlZVVq3PURXZ2NpZaVLY1daZpkp+fD9S9rYXIcamwCGNfBpb9BzH2ZWDsz8Aoqt0LUyWGgzT7QVJ90w99HCDfpwRsVkyfQ+GsT2jVdgaOqosA+VkDaBvUnjaB7Wkd2I64wARslgrzWyFkFWb9nSv1epqf5Hhjmib7CyElG5JzTJKzYVeeSX2frtqt0DbIICEEEoIN4oMh2O4EnEAJAPmHWcBb/h7NTyJSZwUFWHbuxLJjh+uj7POdOyEvz71bfmIizoQE922fqCj8Kj1XNENDcbZujbNtW8zWrd2fO7OyPOenioVMObV7F5iISENpTs+fnLUo7ipTq7A2NzeXcePG8fXXXwPg7+/Pww8/zKWXXgrAgQMHmDRpEl9++WU9hnt4fn5+VSp1ywLWgIAA/Pz8AFc1b9nnZfuULXhW0znqIiQkBKv1yIv3HA/K0v7Q0NDj/odFpDKz1IG5/6CrjcHeI7QzOMxckGMpONTOwNVvNs03A6fNCjYr+NgwbIFYrLV70SfKP5aE0I7uytko/9hm/zOp+UmauvwSk+1ZDrZmlrIt01U9m1dSFs26vqctdXiqERtkoV2Yq89suzArrYIsWC362WgMmp9EpFqlpa7+rzYbVHxHaFYWDBly+OMqPNcMzsiAk08uv69XL7jxRs/WBSEhhz2V5icR8VbNaX5yVFOQdTi1CmtfeOEFli9f7r6dn5/Pww8/TLdu3cjIyOCOO+4gMzMT0zSJiIio+4gPIyYmhn2V+u6U3Y6Ojqb00KqV+/bto23bth77nHDCCbU6R10YRvPp51Z2rc3leqV5crczONTKwLknHXPfwVq1MwBwYrLXlkmq/VC/Wd90MnwLDrUysLkWAPMJpzY/RT4WG22C25MY2tHdbzbQFvz3LvA4pflJmgqnaZKW42TboWB2a6aD3bm1f5JWWaDNcAWzh1oaJIZaCbQf/+/4aUo0P4k0U6YJBw6UL+5V1kM2JQV27nS9Y2r4cBg3rvyY0FAIDq5a3WoYrlC3YhDbqZPnu7DatIHbbqvTEDU/iYi3ai7zU12ur1Zh7ddff41hGFxxxRX069ePd999l++//57Zs2fzxRdfkHfoLRqDBg3ioYceqt+oq9GrVy/ee+89HA6Hu6L1xx9/JDExkRYtWhAcHExQUBCrVq1yh7XZ2dls2LCBq6++ulbnEJHmwywoci0Atjvd1Wd2TzpmYe3boRQZJeywH3BXzu7wz6DIbh5aAMwHbHYMo3ar4wbbQ0kISSIxtBPxIR2JC4rHx2Kr76WJiBfILnK6Q9ltmaUkZzkoLK1fQwOLAa2DXYt/tQ+z0i7cSnSA5bh/Eisi4tWKisC30nO9F16A99+HQ2/jPayUFM/bhgEDB7qC3LZtXR8JCdC6tWd/WhERaXZqFdbu27ePgIAAHn30UQzDoFu3bvTr148lS5ZgmiaRkZFMmjSJAQMGHNXBDRs2jNmzZzNhwgRuvPFG1q1bx9tvv82kSZMAV6/aq6++munTpxMREUFcXBzTpk0jJiaG8847r1bnEJHjk7udwZ70Q+HsfszM2vflMjHJtOaT4rufVHs6yX4H2BuQg3loETDDxwesQbWqmjUMg9jAtu6K2cTQJMJ9IxW6iDRhpU6THdkOj3B2f379FwEL9bW4FwBrF+ZDQqgVXx/NESIix1xZ24KK1bFln2dmwnffebbD8vE5fFBrt5dXx3brVvX+CRMa5BJERKRpq1VYW1RURFhYmDtYqFiR2qdPH5599lnCw6uuQP53tWjRgtmzZ/Pkk09y6aWXEhUVxbhx49y9cgHuvPNOSktLeeihhygsLKRXr1688cYb7kXFanMOEWnaqm1nsD+j2kW6DseBk922DJJ995Pqe4DUoEyy7UWH2hlYXU/ECalVOOtr9aNtSAcSQ5JICE2ibXAH/Hz86319ItK4TNMko9B095ndmukgNctBibN+VbM+FoP4EKu7nUG7MB9a+B//b/0SEfFaO3fCM894ti04nF27XG0IyiQkQKtWrkC2YuuC+Hho2RKawQLVIiJydBlmWTffIzjhhBOIiYlhxYoVHtt8fHz47rvvCAsLa8AhNj6Hw8HatWvp3r17s1lgLCsrq1k0eJamydXOIB3nnv2uBcDq2M4AIN8oIvVQn9nUgAx2BmRRYuNQOwMfz75gNYjwiyIhNMldORsb2AaLoSfmDUHzkxwLRQ6TlCxXKLs9s5StmQ4yC+tfNRvpb3H3mm0fbqVNsBWbVd+/xxvNTyJeKD/fVRGbmgrJyeWfX3EFDB5cvt++fTBo0JHPFR7uCmLHj4eOHRt02Eeb5icR8VbNaX6qS7ZYq8raw4mIiDjug1oRaVxV2xmkY2Zm1+0cmBzwySHZnk6q/0FSQ7LYZ8+p0M7AAvjXqmrWYliJC0ogITSJxJCOxIckEep79N9ZICLHhmma7M13sr2snUFGKTtyHNSzaBZfq0FCqCuULQtoQ3314o2IyDHxySfw++/lbQv2769+v02bPMPaqCjw93ctMltWHVvWQ7bs85CQY3IJIiIitQ5r09PTGVTp1caDBw9W2WYYBp988snRGZ2INCvudgZ70jF3769XOwOAEkpJs2eQ4pdOakg2qf4HybOVuKpmfVzTnkFArc7lbwt0tTMIcVXOtg1uj82qRR9Emqr8EpPtWaVsyyjvNZtXUs9kFogNsrp7zSaG+RAXZMFqOb6rAkREjjnThIMHy/vHpqRASQncd5/nfsuWwTffHPlcFgvkVFrHwDBgyRJX9azaFoiISCOrdVhbWlrKtm3batx2vJcti8jRczTaGQDkWApc7QyCMkkNySbNfhCnj6VCOwMrBrVrYRIVEEvCoXA2MTSJKP9YzWsiTZTTNNmV62RrhqvX7LZMB7tzHdQ3mg2wGbQP8yGxLJwNtRJo1x/1IiJH1cGD8PPPVRf4qryIl68v/OtfnuFqfHz55+HhVXvItm0LrVu7Fv6qrMK6LCIiIo2pVmHt7bff3tDjEJHjnFnqwEzPKK+Y3V33dgYATkz22jJJ9c8gNTyXFP+DHLTmuqpmrWVP1n1rdS4fi402we1JDO3o7jcbaAuu85hExDtkFzndoey2zFK2ZzkoLK1fNGsxIC7YSvuyXrNhVloGWrDoxRsRkb+ntNS1SFdZD9mzznKFqGU2boQJE2o+T1GRq81BdHT5tksvhQED1LZARESatKMe1ubm5tZ7MCJyfDha7QwAiowSdtgPkBqRR0pwFjts+ynycbjbGQAY1K4tQbA99FDFbCfiQzoSFxSPj8VW5zGJSOMrdZrsyHYFs2XtDPbn138RsBBfC+0PhbLtwnyID7Xi56NgVkSk3vbv96yMLft8505Xb9gyoaGeYW3F6lhwVc7GxnpWx5Z9HhXluW/F84iIiDRRf2uBsYrWrVvHggULWLp0Kb/++uvROq2INAFV2hnsTccsqHs7AxOTTGu+q89sRB4p/gfYYxzEtFkOtTMAMKjN1GUYBrGBbd0Vs4mhSYT7RqqlgUgTdbDAydbMUnc4m5rloKSeq4D5WAziQ1y9ZtsdCmdb+BuaH0RE6iovzxXClpRAt26e991wg6uCtiYpKZ63Y2LgzjvLF/Y6XNsCERGR49TfCmtzc3P58MMPWbhwIZs2bTpaYxIRL3a02hkAOHCy2z+b1MgCUkKySPXZT7aRV6GdAVDLXrO+Vj/ahnRwLQYWmkTb4A74+fjXa1wi0riKHCapWeUVs9syHWQU1r9qtoW/xaPXbNsQKzarglkRkVopLYW0tKo9ZFNTIT3dtU/nzjBnjudx8fFVw1pf36rVsSed5LmPxQLXXNNw1yMiIuLl6hXWrl27lgULFvDZZ59RWFjoesszEBERwQUXXHBUBygijcejncGedNe/+w7Wq50BQL5RxI6oInZE5JLsd4Ad7KHUWrkyrnaL9UT4RZEQmuSunI0NbIPF0EI/Ik2NaZrsy/fsNZua7cRp1q9q1m41SAgtb2fQLsxKmJ/mBhGRIzJNV/AaFga2Ci2iPvgAJk/2bFtQnZQU1zkqvkPh3HMhIaFq2wKL5mQREZEjqXVYm5OTw4cffsiCBQvYsmULgDukNQyDl19+mbPOOgurtXZVcCLifczCIszdf7+dAbhaGhwMLiGlZSGpQVmk+Oxln3nA80l8LVkMK3FBCSSEJpEY0pH4kCRCfcPrNS4RaVz5JSbJWaUevWZzi+sXzALEBLpaGbQPd4WzcUEWrBZVzYqIVKusbUFZZWzZIl+pqZCf76qO7dy5fP8WLQ4f1EZEeFbJOjzXFGDo0Aa9FBERkeNVrcLa8ePH89lnn1FUVOQOaLt06cKwYcOYNGkSAH369FFQK9KEmA4H5v4K7Qz2pGNm1K+dAUCpD+yKLiUlIo8Uv3RSzd3kmfmeO9UyqPW3BbraGYS4KmfbBrfHZlWvMpGmxmma7M51ukLZjFK2ZjrYneugvtFsgM1wV8u2C7PSLtRKoF0VWiIiHipXuDoccOutrmD2wIEjH5ua6hnWJiRAUlLVxb3atoXg4IYYvYiISLNXq7B2yZIlAPj5+TFixAiGDh1Kx44dAdxhrYh4L9M0ISsX5+79R6WdAUBuCxupUYWkBGeRat3LztJdOM1D56tja8mogFgSDoWziaFJRPnHaqEfkSYou8jJ9iwHWzMcbMsqZXumg8LS+kWzFgPigssXAGsfZiU60IJFc4OISHnbgso9ZFNSoEcPmDChfF+rFXbsOHxQa7FAq1auEDYkxPO+tm3hnXca7jpERESkilq3QTAMg6KiIr755hsiIyMJDw8nMjKyIccmIvXk0c5gzwFX1WxBYf3PF+DHvlhIDcslxe8AKc40DhYfWlDCSZ3CWR+LjTbB7UkM7ejuNxtoU2WGSFNT6jTZke1gW5aDbRmudgb78uu/CFiIr8XVzuBQOJsQasXPR8GsiIjbihXwxReebQuqE15Nq6i2bV0LhVVe3KttW2jd2rNPrYiIiDSqWoW1L730EosWLeKbb75h69atTJ8+nWeffZbTTz+9occnIjVwtzPYk+6unP077QzwsVLSMpgdUUWkBGWSat1LSmEKRY4C1/11zHyD7aGHKmY7ER/SkbigeHws+oNApKnJKHS6KmYzXe0MUrIclDjrVzVrtRjEh1g9wtkW/oYq6kWkeSopgbS0qj1kZ84EX9/y/bZtc4W1R+Ln53lMmZkzFciKiIg0EbUKawcMGMCAAQNIT09n8eLFLF68mOTkZL755hv3H1YPP/wwgwYN4swzz8RuV29JkYZQuZ2BuScd5/6DUFr/dgZEhJAVbWdHeB4pvukkO3ayO38HpumsczBrGAaxgW3dFbOJoUmE+0YqgBFpYoodJilZ5QuAbct0kFFY/6rZFv4W2of5kHgonG0bYsVm1bwgIs1QXh589pln64K0tOoX8UpNhUOt5wBXJSx4ti2o3Es2Kqr6NQIU1IqIiDQZhlm2YlgdrVmzhvfff5/PP/+cgoICdxgTFBTEzz//fFQH2dgcDgdr166le/fuzWIRNdM0ycrKIjQ0VCFbIzMLiw5VzKa7w9m/087ACPDDGRPO7kgHqUGZpFj2kJK/jayig/U6n6/Vj7YhHVyLgYUm0Ta4A34+/vUen0hNND8dfaZpsi/fybZMx6GPUlKznTjr9/QAu9UgIbS8YrZdmJUwPy0CJsc/zU8CQG5uee/Y1FTo0gXOOKP8/uxs6N+/dueaPh3OOcfz3OnpEBen8FXqRPOTiHir5jQ/1SVbrHXP2sp69uxJz549efjhh/nvf//LokWLWLduHbm5ufU9pUiz1hDtDCwtW1AQHUhqWC6pvukkF29iR842ShzFkFX3U0b4RbmqZkNdi4HFBrbBYiiEEWlKCkpNth+qlt2W6aqezS2uf9VsTOChdgbhrnA2LsiC1XJ8P9ESEWHXLtiypbxtQVml7MFKL4APHeoZ1oaEuHrKZmS4bvv5uapiExJc/5Z93qYNBFfq6R8U5PoQERGR41q9w9oygYGBXHHFFVxxxRVs2rSJRYsWHY1xiRzX3O0M9qRj7tnvWgzsb7YzMMJDIaYFB6MMUoIySGE3yTnr2JefBvXIfC2GlbigBBJCk0gM6Uh8SBKhvtUsWCEiXstpmuzOdR4KZV0B7a4cB/WrmQV/H4P24a5q2XZhVtqFWgm06wUbETkOmSbs3+8KYvfvhwsv9Lz/xRdr7h8LruMre/BBV+h6pLYFIiIi0mz97bC2oqSkJB544IGjeUqR40JDtDMwYiIpjQ5nV3g+KbZ9JBdsJSX7M/LyciCv7uf0twWSGJLk7jfbJrgddms1C1SIiNfKKXZWqJgtJTnTQUFp/aJZiwFxwYdC2TAf2odZiQ60YFGoICLHk4ptC8paF5T9W3BocVWLBQYO9Gw9kJBQ9VwtWnj2j42Ph8TEqvude26DXIqIiIgcH2q9wFhtGYbBV199Ve8BiTR1DdXOwIiJJLelL6kBGSSX7iAl5xt25m7Hsbd+1bhRAbEkhCS5FwKL9I9RSwORJqTUabIzx9XGYPuhcHZfXv3bGYT4WmgXaqVduJX2YT4khFrx81EwKyLHgZIS2LkTQkMhIqJ8+7p1cP31NR/vdLraHpQt8AVw2mmu6tuyYLZtW7UoEBERkaOiVmFtWlparU94vDcEFqmoodoZGLGREB3B3ogSUq37SM7dQnL2Fxzcv69e5/Sx2GgT3J7E0I7uytlAW3DNB4qI18gorNDOIMNBcpaDEmf9qmatFoO2IYd6zYa5wtkW/oZ+h4tI01XWtqByhWxKiitodTph3DgYPrz8mNatqz+XxeK6r2IP2dBQz31OPtn1ISIiInKU1SqsnTx58mHvW7ZsGV999RWGYWCaJh06dDhqgxPxNq52BgdwHgpmzb3pmPl/o52Bv6udgREbSUnLYHYEZpJcmExy1nek5GyhKLugXucNtoceqpjtRHxIR+KC4vGxaNVgkaai2GGSku1gW0Z5r9mMwvpXzbbwt7jbGbQLsxIfYsVmVTArIk1QcTHY7Z7bxo+H778vb1twOJX7x4aHw+mnQ3S0Z+uCVq08Wx6IiIiIHEO1CmsvvfTSKtt27drFY489xsqVKwHw9fXl1ltv5fravJVIpAloyHYGxLQgK8JCiplGSvZmkrOXs2tnKqZZ9zDGMAxiA9u6K2YTQ5MI941UhZxIE2GaJvvznWw91Gt2W2YpqdlOnGb9qmbtVoOE0LKqWR8Sw6yE+6nFiYg0IcXFkJZWtUI2NRXCwmDhQs/9nc7DB7X+/uVBbOfOnvcZBrzwQoNcgoiIiEh91XmBsdLSUv7973/zyiuvUFhYiGmanHPOOTz88MPExcU1xBhFGpy7ncHedFfF7J50nPsO/P12BjEtsMRG4YwOZ7d/Nim5W9me/SMpmZvJ2nuwXuf1tfrRNqQDiSFJJIQm0Ta4A34+/vUep4gcWwWlJtsPVcu62ho4yC2uf9VsdKCrlUFZONsq2IKPRS/WiEgTs3Yt/PvfrlB2925XAFudnBzXfZYKL0K1awdbtni2LSgLaCMjXaGsiMhxrrS0lOLi4sYehkidmKZJUVER+fn5TbrgzG634+NT54j1sOp0plWrVvHYY4+xbds2TNMkJiaGBx98kH/84x9HbUAix0JDtjOwxERREOlHSlEKKdmb2Z69gh1btlHirN8vzgi/KFfVbKhrMbDYwDZaCEykiXCaJrtzK/SazXSwK8dB/Wpmwd/HcLczaB9uJTHUSpBd84GIeLGcnKrVsSkpcP/9nj1fi4vhhx+OfK7ISFcIm5Pj2UN2zBjXh4hIM2SaJqmpqaSnpzf2UESatcjISNq2bXtUQudahbUHDhxg8uTJfPLJJ5imidVqZdSoUdx11134+6uiT7ybRzuDPYcqZzOy6n9CdzuDFhgxURjRLUi355Kcs5mU7J/Zvn8T+1JqvyhfRRbDSlxQAgmhSSSGdCQ+JIlQ3/D6j1VEjqncYmeFitlStmc6KCitXzRrMaBVkJX24VbahfrQLtxKTKAFSxN+xVlEmoF33nFVuaamuj4OHuadRNu2eYa18fGufwMCqq+QbdsWAgMbfPgiIk1NWVAbFxdHUFAQFoteyBc5lpxOJ7m5uaSlpVFQUEB8fPzfzkprFdZecMEF5ObmYpomhmFwwgknkJWVxWOPPVZlX8MweOqpp/7WoETqyzRNyM4tD2WPSjuDEIyYSCyxURgxkZS2CGJnfgrbszaRnP0tKX9uJq8kp17n9rcFkhiS5O432ya4HXarb73HKiLHTqnTJC3H6a6Y3ZbpYG9e/eeaYLvF1c4g3NXOICHUip+PglkR8RJOJ6SnQ3JyeXVsZCRce63nfu+/X3Uhr8qsVsjM9NzWsiUsXaq2BSIidVBaWuoOamNiYhp7OCLNVlBQEABpaWm89957DBgwgLZt29b7fLUKa3NyyoMo0zTZsGEDGzZscAVjhxiG4Q5zFdbKsdJg7QxiIrHEuv7NsRSQnLWJ5Ow1pOzezM7N23E46xfIRAXEkhCS5F4ILNI/Ri0NRJqIjEKnewGwbZkOkrMcFDvqVzVrtRi0DSnrM+sKZ1v4G026T5OIHEd27XL1kK3YtiA1FQorPcdKSqoa1sbHl4e1ZW0LKlbIxsdDq1ZQua+bYUBUVENdkYjIcamsR21ZUCQijafs57CgoIBPP/2Uiy66iNatW9frXLUKay+99NJ6nVzkaDIdTsz0DMzd+49eO4OoCIzYSIyYKCwxkThDAtiXn0Zy9ma2Z/9A8rpNHCzYV7/TW2y0CW5PYmhHd+VsoC24/uMVkWOmxGGSkl3ezmBbhoODhfVfBCzCz+KumG0XZiU+xIrNqmBWRBpJcTHs3Fkewg4bBhX/0F+xAp55pubzpKaCaXpWwo4ZAzff7AplAwKO+tBFRKQqtT4QaXxlP4ctW7Zk48aNbN68uWHD2smTJ9fr5CL1dSzaGRhR4RSbxaTkbCU5+zdSdmwmOXszRaUF9Tp/sD30UMVsJ+JDOhIXFI+PxVbv8YrIsWGaJukFTrZmOtiW4Qpnd+Q4cTjrVzVrtxokhFrdC4G1C7MS7qcn0CJyjJkm7N1bdXGv5GTYs8fV1qDMKadAt27ltxMSPM9ltUJcXHllbMUq2co6dWqIqxERkQZmljpwbkrGuXUHZkEhhr8flvZtsCQlYPhYG3t4Ik2GYRj4+vqSWbnlUx3UKqw9kt27d5Oenk5iYqJK76XezMIizL0HcO5Ox9yzH3PP321n4Ota/KtCOwN87WQUpZOSvZnkrJ9ITtvMrrxUTLPu1XKGYRAb2NZdMZsYmkS4b6TewizSBBSWmmyvsADY1kwHOcX1r5qNDiwLZl2Vs3HBFnwsmgtE5BjJznaFsH5+0KFD+fbiYhgyxBXa1iQ11TOs7dQJ7r77yG0LRETkuOHcuoOST1ZiHsx2vZhnACY4ftmAERGCbfDZWNq3afBxmKbJBx98wAcffMDmzZvJzc0lJiaGs846i9GjRxMdHd3gYwDYuXMnAwYMYM6cOZx22mn1Po/D4WDEiBE88sgjdOnShU6dOjF58mSGDh1a7f7jx48nLS2NuXPn1vsxK9u8eTNpaWmcc845R+2cdbFr1y5+++03Bg8eXOtjxo8fzwcffFDtfQMGDODll1+u8RxH6/+wzP/+9z8mTZrEe++9h08tnhMZhoHTWf+/MWv9rGvdunW8+OKLnHrqqYwZM4b8/HzGjh3L119/DYCfnx933HEH119/fb0HI83DUW9nYLViaXmonUG0q3KW0CCcpoNdeakkZ/2P7ds2kZK9mayiw6xIXANfqx9tQzqQGJJEQmgSbYM74Ofz91b3E5HaK3GYrNlTwq97SjiY6yAiKJ9TY2z0jLEdsZ2A0zTZnet0h7PbMh2k5TioX80s+PsYJIaVtzNoF2YlyK6qWRFpYJXbFlSslM3IcO0zaBBUXPzX1xdiY139ZysKCKhaHdu9u+c+LVrA1Vc36CWJiIh3cG7dQcnCzzALiyHQ36OK1ix1YB7IomThZ9iGX9Cgga3D4eC2227j119/ZcyYMTzyyCMEBgayefNmXn75ZYYNG8aSJUuIjIxssDGUiY2N5bvvviM0NPRvneeNN94gPj6eLl26APDdd98RHHxsWyOOHj2aSy+9tNHC2vvvv5+4uLg6hbUAp5xyCjNnzqyy3de3cRZk79q1K+3ateP111/nlltuafDHq1VYu2HDBq6++mpKSkpITEwE4JlnnmH58uXufQoKCpg2bRpt2rThvPPOa5jRSpNzrNoZGFYr+SW5JGdvJiVjDdtTNrIjexslzuJ6PUaEX5SrajbUtRhYbGAbLQQm0kjW7i3h1d/y2ZPnwGECJrC/iC+Ti4gJtDLmlAC6R7tajuQWly0CVl45W1Bav2jWAOKCyytmE8OsxAZZsKiCXkQagtMJ6enQsqXn9hdegHnzPNsWVCclpeq2wYOhoMBzka8WLTx7zIqIyHHHdJpQWFTzfqUOSj76GrOgCIIDXe8UrdAKzLBYMIMCMHPyKPnoa2w3DKu5JYKfL0Y93mX25ptv8u2337Jw4UJOOukk9/ZWrVrRu3dvBg0axL///W/GjRtX53PXldVqJepvLnqZk5PDa6+9xvz5893b/u45mxObzeZ1X6/rr7+ekSNHMnLkyL8d5NekVmHtq6++SnFxMa1bt+b0008nPz+fRYsWYRgGZ599NmPHjuWNN97ggw8+4J133lFY20S5e9RsScUnK4fS0GAsHdrWqUdN1XYGBzDz69cDFiq1M4iJdFXP+vke6jG5h+3Z60nZupntWZvYl59Wr8ewGFbighJICE0iMaQj8SFJhPqG13vMInL0rN1bwtSfcskrMQnzNbBZDRwOB1arhWKHyY4cB49+l0OvWBv5JbA3r/4vBAXbLbQPs7orZxPDrPj5KNAQkaOsrG1BWXVsWYVsaioUFcE333guzBUWdvigNiqqvEq2ul6xo0c3yCWIiIj3cmxKxrF8da3+DjcLiiAjGywGFBUf/t1npomZto/imfMx/I9c2WgE+GPt3xtrUkKtx2yaJvPnz+fiiy/2CGrL+Pv7M2/ePI/wbvfu3cyYMYMff/yRvLw8evTowbhx4+h06PfhgQMHmDRpEqtWraKgoIDOnTtz77330rt3b8D17vEpU6bw559/4uPjQ58+fXjggQdo1apVlbfQjxo1ihNPPJHMzEy++OILQkJCuPrqq7npppsO2wpxwYIFREdHc8IJJ7i3VWyDYJomr7zyCu+99x7Z2dkMHjyYoiLPgL2maxw/fjwOh4PIyEiWLFlCfn4+Z5xxBpMmTSIqKor+/fuTlpbGiy++yOrVq8nNzaVHjx489NBDAHz11VfcdtttPPPMM+7K16effpq1a9fyzjvvsHnzZp599ll++eUX8vLyiI2N5eqrr+baa68FYObMmaxevZqzzjqLuXPnkpGRwSmnnMLEiRNp164do0aNYvXq1QCsXr2a5cuXu8denbq0LCguLmbmzJksXbqUPXv2EBgYyBlnnMHDDz9MeHjVPKem74fi4mKef/55PvroI3Jzc+nYsSN33nknZ555pvscJ5xwAtHR0SxYsICbb765VuOsr1qFtb/++isWi4W5c+cSGxvL119/TUFBAYZhcNttt9GhQwcefvhhPvroI/78888GHbA0jMo9aqymicMwcPz652F71LjbGexJx7n7UJ/Zg3+vnYHRMsIVysaUtzMwDIMSZwkpOdtI3v8b27M2kpK9mbySnHo9jL8tkMSQJHe/2TbB7bBbG6eUXkQOr7DEyUu/5pFbbBLqa+AwDYpLTApLoMR0UuwwcTjBYcKKlGLahlhq3TfaYhi0DbG42hmEW2kfZiXSv/bHi4jUyZ49MGGCK5itabGJlBQ48cTy2x06QOfOnm0L4uOhTRvPUFdERAQo/fJHKKrlO0yLigETanoXqWEATtf+NYS1Zn4BpV/+WKewdufOnezatYvTTz/9sPvExcW5P8/NzWXEiBG0adOGV155BbvdzksvvcTVV1/Nhx9+SKtWrZg4cSJFRUXMmzcPu93Oq6++yq233so333yDn58fo0ePZvjw4UydOpXs7GweeeQRHnzwQd56661qH/+dd95h2LBhLFq0iHXr1jFx4kSAw4Z2X331Feeee+5hr2fWrFnMnj2bxx57jM6dO7NgwQLef/99d3hYm2sEWLp0KUOGDGHevHns2rWLsWPH8uyzz/LUU0/x/vvvc+mllzJo0CBGjx7N3Llz+fTTT91j+PHHHzEMg59++skd1q5cuZKhQ4dSUFDAddddR58+fXjnnXfw8fFh0aJFPPXUU/Tu3ZsTDz1X+e233/D392fWrFnk5eVx//33M2nSJN5++21mzpzJmDFjiImJ4ZFHHgFcrSAOpy7Vqk8//TTLli1jypQptG7dms2bN3P//ffzyiuv8OCDD1bZ/0jfDwEBATzwwANs3ryZadOmERMTw9dff82YMWN48cUXPVpInHPOOSxfvtw7wtrMzEzCwsKIjY0F4IcffgAgJCSErl27AhAQEEBwcDC5ubkNNFRpKNX1qHE6HFisVo8eNT6DzwJfe8O1M4gMd1fwZhdnkpz1JynbNpOcvYmdudtxOOv3WFEBsSSEJLkXAov0j1FLA5EGZJomxU4oKDEpLDXJLzUpKDUpLHVtK7td7f0V7jtQ4GRPnhOrAflVWhm4bhsGWIFSJ+SVQJC9+jFF+FkOhbKuXrNtQ6zYj9DrVkSkRk4n7NvnqohNToaUFPy3bIHdu2H4cM+eryEh8Pvvhz+X1QqtW7tCWEul5yinn+76EBEROdpqswjl39m/ltLT0wGIiIjw2D5mzBhWrVrlvt2qVSs++eQTPvroIzIyMli8eLH7mOnTpzNw4EDmz5/PfffdR2pqKklJSbRt2xZfX18mTJjAkCFDsFqt5OTkkJGRQcuWLWndujWGYfDcc89x4MCBw46xXbt2TJw4EcMwaN++PVu3bmXOnDnVVtc6nU7++OMPRowYUe25TNNk7ty5XHPNNVx00UUAPPDAAx7XWptrBAgKCuKxxx7DZrPRvn17LrnkElauXOn+elqtVgICAggLC+Pcc8/lxRdfZPfu3cTGxvLDDz9w3nnnuR93586dbNmyhYEDB1JQUMA111zDyJEjCQoKAuD222/ntddeY+PGje6wtrS0lKeffpqwsDAARo0axbRp0wAICwvDZrPh5+fnvobatjZYs2YNp5xyise2li1b8vnnnwOuHrL/+Mc/3OF2XFwcZ555Jhs3bqz2fEf6fkhJSeG///0v77//vjvjvO666/jrr7944403PMLaTp06MWfOHJxOJ5bKz9mOolqFtYGBgeTk5FBcXIzdbmfFihUYhuH+ogDs27ePrKysBu/bIEeXWepwVdQWFkNIYPkkY5pQXAIlpeB0Yh7MouSdTyEqvF6VZ4a/L0a0q42BJSbK3c4AwGk62Zu3k+R9v7M9exPJ2Zs4WLCvXtfjY7HRJrg9iaEd3ZWzgbZj28BbpClzOF0BakGpKyAtPBSe5peUf15QFqpWClsLSsrvdx6FJ3JlAW1NU45huKas/FKTILuB3WqQEGo9tACYK5wN99MLNCJyFCxeDKtWebYtqMDqcLiC1+3bPY8LCHC1LIDytgVlPWTbtoW4ONdxIiIif5PPeX1r3Qahzj3Ma7F/WRuEuih723pmpXefTJo0icLCQgDmzp3rXjdp06ZNJCQkeIS7vr6+dOvWzR3W3X777dx33318+eWX9OzZkzPPPJNBgwbh6+uLr68vN954I48//jgvvvgip59+OmeddRbnn3/+YcfYu3dvjyyke/fuvP7662RkZFQJmTMzMykpKamyvUxGRgb79+93B4MVz7l169ZaXyNAfHw8NpvNfTs4OJiSkpJqH7dLly5ER0fz/fff069fP1JTU5k+fTpDhw5l9+7drFy5kg4dOhAfHw/AyJEj+fTTT/nrr79ISUlxv5PeWaE9U2RkpDuorenxgSoBbEWvv/46PXv2dI91+vTpHvdbKzxXuuSSS/jxxx955plnSE5OZuvWrWzbts19fGVH+n7YsGEDANdcc43HMSUlJYSEhHhsi4iIoLS0lMzMzMP+/x4NtQpru3Tpwg8//MCjjz5KcHAwO3bswDAMd2/a7du38+ijjwJU+WYT7+bclOxqfRDo75p4Coow8wswSiutlm4Yrirawprf9lClnUFMJIQFuye2otICUnI2k7x3EynZm0nO3kxRaf362gbbQw9VzHYiPqQjcUHx+FhsNR8ocpz5u9WsZWFskaNhXi2vD6ezdmOxWQwMw6RdmJV7ewURF2zBpx6LGohIM1ZcDDt2lPePTUmBvDx4+mnP/dauhWXLjnyugIDq/5j98EOwH6b8X0RE5CixJiVg6RBfqwXGHBuTKV2yDPz9jrhOjVnqgIJCfP45AGunhCOftB4LjLVp04aoqChWr17tfjs+QHR0tPvzioWBpmlWW0TmcDjw8XHFXOeddx7ffvst3377LT/88AOzZ8/m+eefZ+HChXTs2JGxY8cycuRIVq5cyY8//sjEiRN57bXXWLJkSbVjLDtvxTGAZ4BYmbOGxUHNSgUuFR+jNtcIYK/jc4tzzjmH77//HqvVSpcuXTjppJOIi4tj1apVrFixgoEDBwKuaufhw4cTHh7OgAED6Nu3L127duXss8/2OF9dH/9wX1/w/P/28/Nzh8bVmThxIp9++in//Oc/Oeecc7jlllt444032Lt3b7X7H+n7oez/Yf78+QQGBnocV7l6tuz/tCGraqGWYe21117L999/7/FFjY+PZ9CgQaSnpzNo0CD39spJtHg359Yd4HS6JuaSUszsw7SxOEKPGiMs5FDFbCRGbJRHOwPTNMkoSidl/x8kZ20iOXszu/JSMc0aVjSudggGsYFt3RWziaFJhPtGqsekNHneVM3qTSwWA3e7A1zTkMUwsBom/j4WfH3A12pgMWBfvpNOET7Eh6oyTURqsH8/fP215+Jeu3dXfWunYbgqZ30rPO8p+6OhYtuCCj1k88LDCUlIqNrKABTUiojIMWNYDAjwq3E/a9eOOL5dg3kgC7PiO20rME0TCgoxWoRi7dqx1ouP14XVauWaa67hpZdeYsSIER6LcpXZvXu3+/OkpCSWLFnCgQMHaNGiBQBFRUX88ccf/POf/6S4uJgZM2ZwySWXMGjQIAYNGkRBQQFnnnkmK1aswGq18vbbb/Pggw8yYsQIRowYwS+//MLIkSP566+/qq2Y/N///udx+9dff6V169bVvrs8IiICu91ORkZGtdcbERFBbGwsv/zyizscBfjjjz/cVbI1XWN9DRgwgPvvvx+r1UqfPn0A6NOnDytWrGDVqlXccccdAHz88cdkZmby+eefu8dUVtFbOWSuiyMFsLWVkZHBu+++y7PPPuuRR27bto2Aavr51/T9UNbmYN++fR4tD5599lkMw+Duu+92bzt48CB2u92jmrgh1CqsPeuss5g2bRozZ85k7969nHbaaUycOBEfHx/3N3FAQACPP/44/fr1a9ABy9FlFhS6UhCoXf9Zi4ElIa68nUFMpMdqkA5nKWl5KSRnbWJ7tqtyNqvoYL3G5mv1o21IBxJDkkgITaJtcAf8fPzrdS6RhnA8VrM2BJvFwN9m4O9j4O8D/jaDAB8DP5+ybYc+bIfuP3T7zwOlzFqbT6iv4dFf1uFwYK1wu8RhYjXglGhV1YsIkJ3tGcT27w8V/+jbs6dqxWx1TBPS0qBdu/Jtl1wC//gHtGpVtW2BaWJmZdX9LaUiIiKNxPCxYht8tmsNm+w8zENr2JQxSx2QV4DhZ8c2+OwGCWrL3HjjjWzYsIGRI0dy8803c8455xAUFMSmTZuYN28e33//PcOGDQNgyJAhvPrqq9x9993cd9992O12Xn75ZfLz87niiiuw2+38/vvvrFmzhocffpjIyEhWrlxJXl4ep5xyCmFhYfz3v/+lsLCQm2++GYvFwqJFiwgNDaVdu3ZV2jGAq4fqCy+8wJAhQ/jll1+YP38+DzzwwGGvp1u3bkcMVm+66SamTp1Ku3bt6NmzJx9++CHr1q2jR48etbrG2goMDCQ5OZn09HQiIyPp06cPRUVFfP7558yaNQuAvn37Mm7cOCIjI93vlo+JiaGgoIClS5fSs2dPtm3bxuTJkwFX+FmXx09LS2PPnj3ExMTU+rgjCQ4OJjg4mGXLlnHSSSdRWFjIvHnzWL9+PSeffHKV/Wv6fujYsSPnnnsujz76KI888ghJSUl88cUXvPbaazz55JMe59qwYUO1j3G01SqsBdc3ypAhQ6pst1gszJkzh5NPPrnO5c/S+Ax/v7LCNUp9LaxrsZsNQbvJ8ykm0GGnc24ruha0webjh1lQiPXUztguLl/RML8kl+QDG0jJ3sz27I3syN5GibP2P7gVRfhFuapmQ12LgcUGttFCYNJgalfNeqiitRlVs1ZkMagSqPpVE6qWha9l97uCWNwBbX1bErQNsfLfLUXsynUQ6c9hX+nPLDJpFWSlZ4zCWpFmZft210fF1gUpKZCV5blfWJhnWFu5oiMgwNU/tqyXbIVKWSpXZ0RGNsSViIiINBpL+zbYhl/gWsvmYDam0+kq6DIBiwWjRSi2wWdjad+mYcdhsfDcc8+xdOlSFi1axJw5c8jOziYyMpKePXsyb948evXqBbgWu583bx5Tp07l//7v/wDo0aMH7777Lm3auMb5/PPPM3nyZG655RZycnJo164dM2bMcPc0nT17NjNmzGD48OE4HA66d+/Om2++SVBQULVh7YABA9i8eTOXXHIJLVu2ZPz48YddQAxg4MCBLF68+LD3X3XVVTidTl555RXS09Pp168fl112GdsP9b2vzTXWxqhRo5g6dSqbN2/mo48+wtfXl9NPP51vvvmGU089FXCFtaZp0r9/f/ffXBdccAHr169n6tSp5ObmEhcXx+WXX86yZctYt27dEa+9oiuvvJL777+fiy++mB9//PGIbSNqy8fHh+eff54pU6YwZMgQQkNDOe2007j33nt59dVXyc/Pr3JMTd8Pzz77LM8++yyPPvooWVlZtGnThscff9z9AkGZn376qcq2hmCYf6d+uZlwOBysXbuW7t27H5VvLG/i2LCVkoWf82eLA7zb8kfSbTk4cbomZsPAgkFkSTAj9vXlhAMRZF3ag9ToIlc4m7WJfflp9Xpci2ElLiiBhNAkEkM6Eh+SRKhv+NG9ODkuqZq1dqqrZvW3VtxWfTWrn49BwKF9fK3VB6TH0tq9JUz9KZe8EpMwXwOb1ThUWWulxOEKagNtBvf3CaK7KmtFji9OJ+zd6wpii4uh8ru3rroKDrPir4fLLoPx4z23ffyxa1Gv+HiIiDgq1bCmaboX223suVNEpCLNT8ev/Px8/vzzT0488cRq3/5dF2apA+emZJxbd2AWFGL4+2Fp3wZLUkKDVtQ2BaNGjSIuLo4pU6bU+pisrCz69+/PW2+9pbWdjhPr1q3juuuuY/ny5dW2vyj7eUxOTiY5OZmEhASPYLcu2WKtK2vl+GRJSuCv2GxeD19GgbWUkFJ/fLBiHiq3zTeK2Wk/yIy4T2gZE4Yl4wfIrPvj+NsCSQxJcvebbRPcDru1hoXK5LijataaNXY1q7fpHm3j/j5BvPpbPnvyHDhME9MEw3BiNaBVkJUxpwQoqBVpyrKyqlbHpqaWh7TgqnitHNbGx1cNa1u2rFoh26FD1ces5t1iIiIizZnhY8XauT3Wzu0beyjHhdDQUG644QbeeustZsyY0djDkaPgrbfe4vrrr682qD3aFNY2c6UWJ++2+52C7BLCigNwWiHLmk+RUUqJpRQT1yuxTquTXbYs4ojAoOYQKCogloSQJPdCYJH+MWpp0ITVpZq1oELoqmrWmqtZy4JZb6pm9Tbdo23MPC+ENXtK+HVPCQdzC4kI8uXUGBs9Y2zYrPp6iXi94mLYsQNiYz1bC3z0ETz2WM3Hp6VBaSlUXIl54EBXP9m2bV1tDFq3rtq2QERERKSR3HTTTYwYMYJ169bRrVu3xh6O/A3r1q0jOTmZqVOnHpPHU1jbzK3bv4p050FCgqJw5uSz15rprqp1/WNgGAZWw0YpDvJL8wi0BXmcw8dio01wexJDO7orZwNtwcf8WqR6qmatmapZvZ/NatA3zk6fVjayskoIDQ1QqC3ibcraFlRXJbt7t2vBrpdfht69y49p3br6c/n4uO4rq45t29Z1/or693d9iIiIiDSguXPn1us4m83G+++/f5RHI42hW7duR+xBfLQprG3m/khfgwMHNr9Aci0OzEKL648pE1dTccPAMCyuz50OCkvziAmMO1Qx24n4kI7EBcXjY9FbkI+2itWsVapVVc3qpmpWEZFjrLgYKi4qa5pw7bWwZUt524LDSU31DGsTEqBXr6qtC2Jj4ThbJ0BEREREpDYU1jZzeSU57rYGdh8/DIurVYFpmu7wymaxY7f6UeQooFvUadx96hMKtmpQ12rWimFrc61m9asmVFU1q4hIIykqcrUtSE2F5GTPStmePeHpp8v3NQwoLDx8UBsY6ApgExJci3pVFBEBr7zSUFchIiIiItLkKKxt5gJtwe62B3aLnSj/WApK88E08bMFYLf4unvNphfsJcIv6rgOalXNWjuqZhUROQ4tWwaLF7uC2T17XBWz1UlJqbqtfXvX/hWrY8s+Dw93BboiIiIiIlIjhbXNXJfInnyzcyklzhKshh/5xaeSXdSBEocfNmshIb5bCPXbiMMsxGqx0iWyZ2MP+bAqV7MWlJgUOlTNWlFdq1ndAauqWUVEmq7MzKo9ZFNSXBWtERHl+x04AKtWHflcLVtCTEzV7U89pUBWREREROQoUFjbzHWLOo2ogFiSM4PJLLiGotIIwIKJiYFBel5PfH0OEuY/h4SwALpFnXbUx1DfataCUlyLYamaVdWsIiLiUlAA777rGc5mZ1e/b0qKZ1gbH+/6NyioanVsfDy0aQP+/tWfS79bRERERESOCoW1zZzNYuO0mLH8vNOg1OmLzZqL1XC6w1qHaaGgJJwSxxiuOMHEVmkhMVWz1kzVrCIiclQ4na72BBWrY7t0gUGDyvfx8YFXX3XteyQ2m6uStqLu3eGLL9S2QERERESkESmsbeZKHCafb22Dr7UQH8tuSs1Sih1+mFjg0IfFsGDSkjd/t/K/fTkUO1A1a6VqVj8f3NWrqmYVEZG/betWWL/eFcqWLfK1c2fVRbwyMz3DWpvNtYjXjh2u29HR1VfJxsbCoUVF3Xx9XR8iIiLS7JQ4S1i3fxV/pK8hrySHQFswXSJ70i3qtCpFWw3FNE0++OADPvjgAzZv3kxubi4xMTGcddZZjB49mujo6GMyjp07dzJgwADmzJnDaafV/93FDoeDESNG8Mgjj9ClSxc6derE5MmTGTp0aLX7jx8/nrS0NObOnVvvx6xs8+bNpKWlcc455xy1c9bFrl27+O233xg8eHCt9p85cyYvvvjiEfdZtmwZrVu3PhrD8+B0Orn88suZOHEiXbt2PernrwuFtc3cmj0l7MlzEOlvx2KJZ0d2CaZpuitrDeNQWGtCdpHJ+v2lBNm9P3hUNauIiHi1oiJXoJqSArt3w9VXe96/YIFrsa+apKZW3fbIIxAY6Apn/fyOznhFRETkuLX+wC/M3TCT/fm7ceDAwMDE5JudS4kKiGVU5zs4qUWPBh2Dw+Hgtttu49dff2XMmDE88sgjBAYGsnnzZl5++WWGDRvGkiVLiIyMbNBxAMTGxvLdd98RGhr6t87zxhtvEB8fT5cuXQD47rvvCA4OPhpDrLXRo0dz6aWXNlpYe//99xMXF1frsPb666/nyiuvdN++7LLLGDRoENdff717W0TFNl5HkcViYezYsTzwwAMsXrwYu93eII9TGwprm7nf9pbgMMFmNcgtNgErVkvV/QzDtchzfqnZ4GGtqllFROS4UF3bgrKPvXtdv1jLXHwxhISU305I8DyXzebqGVuxOrbs88pOOaVBLkdERESOP+sP/MLLa5+goDSXYHu4RxVtibOEfflpvLz2CW7t/lCDBrZvvvkm3377LQsXLuSkk05yb2/VqhW9e/dm0KBB/Pvf/2bcuHENNoYyVquVqKiov3WOnJwcXnvtNebPn+/e9nfP2RwEBgYSGBjovm21WgkICDhmX7u+fftis9n48MMPufzyy4/JY1anSYS1aWlp9O/fv8r2J554gssvv5w///yTJ598kj/++IOwsDBGjRrFDTfc4N7P6XTy4osv8p///Ifs7Gx69OjBo48+Snx1f+A0MznFJmWRZm2qSJ3Ow7c9UDWriIg0O6bpakWQmgpRUdCqVfl9W7fCiBG1O09qqqv/bJneveFf/zpy2wIRERGRajhNJ/kluTXuV+os4a31z5FXkkO4bwsMw8BpOtz3Ww0LofYIMooO8Pb653iw93P41NASIcAWhMWo23MW0zSZP38+F198sUdQW8bf35958+Z5BHa7d+9mxowZ/Pjjj+Tl5dGjRw/GjRtHp06dADhw4ACTJk1i1apVFBQU0LlzZ+6991569+4NwLp165gyZQp//vknPj4+9OnThwceeIBWrVpVaYMwatQoTjzxRDIzM/niiy8ICQnh6quv5qabbjpskdiCBQuIjo7mhBNOcG+r2AbBNE1eeeUV3nvvPbKzsxk8eDBFRUUe56jpGsePH4/D4SAyMpIlS5aQn5/PGWecwaRJk4iKiqJ///6kpaXx4osvsnr1anJzc+nRowcPPfQQAF999RW33XYbzzzzjLvy9emnn2bt2rW88847bN68mWeffZZffvmFvLw8YmNjufrqq7n22msBV8uC1atXc9ZZZzF37lwyMjI45ZRTmDhxIu3atWPUqFGsXr0agNWrV7N8+XL32KtT27YTq1at4pprrmHs2LHMnj2bVq1a8fzzz3PeeedVOUfl1hNff/01M2fOZMuWLURHRzN48GBuvfVWjyraCy+8kDfeeENhbU02btyIr68vX331lccPQnBwMBkZGVx33XUMHDiQSZMmsXbtWiZNmkRYWBjDhg0D4OWXX+a9995j8uTJREdHM23aNG666Sb++9//NmpZszcIthuUxa9+PhAVYCG32MRpmlgtBhYDLIaBBcgtcdKtpY2hnfxUzSoiIs1LYWF5/9iyHrJln2dnu/a59Vao8BYt2rSp/lzBwVV7yFbet0MH14eIiIhIHfy+fxUfbHmb3OKsGvfNK8llf8FurIaVQkf+YfczTZNtWRt54LvrCbQFHfGcQfZQLu1wLSdH1b7X686dO9m1axenn376YfeJi4tzf56bm8uIESNo06YNr7zyCna7nZdeeomrr76aDz/8kFatWjFx4kSKioqYN28edrudV199lVtvvZVvvvkGPz8/Ro8ezfDhw5k6dSrZ2dk88sgjPPjgg7z11lvVPv4777zDsGHDWLRoEevWrWPixIkA3HzzzdXu/9VXX3Huuece9npmzZrF7Nmzeeyxx+jcuTMLFizg/fffd4fJtblGgKVLlzJkyBDmzZvHrl27GDt2LM8++yxPPfUU77//PpdeeimDBg1i9OjRzJ07l08//dQ9hh9//BHDMPjpp5/cYe3KlSsZOnQoBQUFXHfddfTp04d33nkHHx8fFi1axFNPPUXv3r058cQTAfjtt9/w9/dn1qxZ5OXlcf/99zNp0iTefvttZs6cyZgxY4iJieGRRx4BXK0gDqeubSdWrFjBggULKCgowFKLooZvvvmGu+66iwceeIAzzjiD1NRUHn/8cbZv387zzz/v3u/cc89lxowZbN++ncTExDqN6WhpEmHtpk2bSExMpGXLllXue/vtt7Hb7UycOBEfHx/at29PSkoKr7/+OsOGDaO4uJh///vf3HfffZx99tkAPPvss/Tr148vv/yy1n0zjlenRNv4YnsRJQ4Tm9Ug0Ob6cDgcWCv0QyhxmDhMg4s7+tErtnkH3CIicpxyOiEjA1q08Nx+333w9dc1H1+5f6yfH1xyCYSFebYuCAtz9RcSEREROcr+s2k2haWHD14rKizNA8wai66MQ30RC0vzagxrc4uz+M+m2XUKa9PT04GqvUjHjBnDqlWr3LdbtWrFJ598wkcffURGRgaLFy92HzN9+nQGDhzI/Pnzue+++0hNTSUpKYm2bdvi6+vLhAkTGDJkCFarlZycHDIyMmjZsiWtW7fGMAyee+45Dhw4cNgxtmvXjokTJ2IYBu3bt2fr1q3MmTOn2upap9PJH3/8wYjDvMPKNE3mzp3LNddcw0UXXQTAAw884HGttblGgKCgIB577DFsNhvt27fnkksuYeXKle6vZ1kbgbCwMM4991xefPFFdu/eTWxsLD/88APnnXee+3F37tzJli1bGDhwIAUFBVxzzTWMHDmSoCDX//ntt9/Oa6+9xsaNG91hbWlpKU8//TRhYWEAjBo1imnTpgEQFhaGzWbDz8/PfQ1Hs53B9ddfT8Kh1mE7d+6scf9XX32Vyy67zP3/0rZtWyZNmsS1117Lzp073YuWtWvXDpvNxu+//66w9kg2btxIh8NUl6xZs4ZevXrh41N+KX369OG1117jwIEDpKWlkZeXR58+fdz3h4SE0LlzZ37++edmH9b2jLERE2hlV66DSP/qK2NN0ySzyKRVkJWeMcdmFUgREZEGUbFtQVn/2LLPd+yA8HCoUHEAuCphDyc6ujyI7VFNH7eHHz6qwxcRERE5WhwVWh40xP61FR4eDkBmZqbH9kmTJlFYWAjA3LlzWb58OeAq6EtISPAId319fenWrRsbN24EXMHifffdx5dffknPnj0588wzGTRoEL6+vvj6+nLjjTfy+OOP8+KLL3L66adz1llncf755x92jL179/bIS7p3787rr79ORkZGlZA5MzOTkpKSwy6ElZGRwf79++natavH9u7du7N169ZaXyNAfHw8Nlt5ThMcHExJSUm1j9ulSxeio6P5/vvv6devH6mpqUyfPp2hQ4eye/duVq5cSYcOHdwtQ0eOHMmnn37KX3/9RUpKCn/++SfgCqPLREZGuoPamh4f4JQjrK3w+uuv07Nnz8PeX1lC5TUearBhwwbWrVvHBx984N5mHlpDYuvWre6w1mq1Ehoa6n4RoTE0ibB206ZNREVFMXLkSJKTk4mPj+fWW2+lX79+7Nmzh6SkJI/9yypwd+3axZ49ewDXan6V99m9e/exuQAvZrMajDklgKk/5ZJeYBLm69pWpsThCmoDba79Kt4nIiLSZKxbB8884wplc3IOv9++fZCfDwEB5dtOOAG2bXNVxSYklLcvaNPGVT0rIiIi4iUuT7qx1m0QrIa1Tueuzf5lbRDqok2bNkRFRbF69WqPgrro6Gj35xXfIm+a1VcDOxwOdyHfeeedx7fffsu3337LDz/8wOzZs3n++edZuHAhHTt2ZOzYsYwcOZKVK1fy448/MnHiRF577TWWLFlS7RgrFgiWjQFcwd7hVAw1q2OanmsCVXyM2lwjUOfWnueccw7ff/89VquVLl26cNJJJxEXF8eqVatYsWIFAwcOBFzVzsOHDyc8PJwBAwbQt29funbt6n7Hen0f/3BfX/D8/64NX1/fKtsqfk0rh8ZOp5Mbb7yRSy+9tMpxlSt+Xe82r9vPx9Hk9WFtcXExycnJ+Pv7M27cOAICAvjoo4+46aabePPNNyksLKzyzVH2H1ZUVERBQQFQ9RvI19eXrKyaJ6+KTNOs8sN0PDi5pQ/jTgvktbX57Mlz4jBNTBMMw4nVgFZBFkZ3D+Dklj7H5fWLSNNRNg9rLhLA1bZg9+6qFbKpqTBuHJx1Vvm+Viv88cfhz2W3Q+vWriA2Lw/8/cvvu/xy10d19L0oh2h+EhFvpfnp+FXd/+nJUafRNbJXrRYYW7v/J974YxrBtpAjLhxW4iwhtySbG7rcR/eoPofdD+q3wJjVauWaa67hpZdeYsSIER6LcpWpWGyXlJTEkiVLOHDgAC0Ota8qKirijz/+4J///CfFxcXMmDGDSy65hEGDBjFo0CAKCgo488wzWbFiBVarlbfffpsHH3yQESNGMGLECH755RdGjhzJX3/9VW1F7P/+9z+P27/++iutW7euts9qREQEdrudjIyMaq83IiKC2NhYfvnlF3c4CvDHH3+4q2Rrusb6GjBgAPfffz9Wq9X9DvQ+ffqwYsUKVq1axR133AHAxx9/TGZmJp9//rl7TGUVvX9nLimr2j3aysaYm1v+fZ9aqUVZx44d2bZtm8cYVq9ezdtvv83EiRMJOFSs4XA4yM7OPiotGyp+rerydfP6sNZut/Pzzz/j4+PjDly7dOnC1q1beeONN/Dz86O4uNjjmLIV9AICAvA7VPFSXFzs/rxsH/+Kf4jVQnZ2dq2aFjdFiX7weG+TtfsN/nfASVZBKaH+PnRtYaF7lInNkk8ds20RkaPONE3y8109uLSgYfNknzsXy6ZNWHbuxJKWBod5m1XRn39ScvLJ5RvCwghyOjGjonC2aVP+0bo1zjZtMKOjoeLveP3SkzrS/CQi3krz0/GrLPuozGJYCLKH1Hj8abHn8t9t77AvP41w36jDtkXMK8kmOiCO02LPxXaEUPfvuPHGG9mwYQMjR47k5ptv5pxzziEoKIhNmzYxb948vv/+e/ci8kOGDOHVV1/l7rvv5r777sNut/Pyyy+Tn5/PFVdcgd1u5/fff2fNmjU8/PDDREZGsnLlSvLy8jjllFMICwvjv//9L4WFhdx8881YLBYWLVpEaGgo7dq1q9KOAVwtOF944QWGDBnCL7/8wvz583nggQcOez3dunU7YrB60003MXXqVNq1a0fPnj358MMPWbduHT0OtdWq6RprKzAwkOTkZNLT04mMjKRPnz4UFRXx+eefM2vWLAD69u3LuHHjiIyMdLdmiImJoaCggKVLl9KzZ0+2bdvG5MmTAapkcDU9flpaGnv27CEmJqbWx9VVy5YtadOmDW+++SYJCQkUFBQwefJkj8LNm266ibvvvpuZM2dy0UUXsWfPHh566CFatWrlEcz+9ddfOBwOTq74t0QdFBcXU1xcTGFhoUeRaE2V1hV5fVgLuNPtipKSkvjuu++IiYlh3759HveV3Y6Ojqa0tNS9rW3bth77VPdqzZGEhIQ0ahn0sTAwHAaYJllZWYSGhuqXuYh4lbJXIzU/HYcKCz0rY1NSIDQU/vUvz/1+/hk2bCi/Xd3v5ZAQAmw21/FlQkPhhx+gmrdLiRwNmp9ExFtpfjp+lYXw9WWz2BjV+Q5eXvsEGUX7CbaHe4SxJc4Scooz8PcJYlTnOxosqAWwWCw899xzLF26lEWLFjFnzhyys7OJjIykZ8+ezJs3j169egGubGbevHlMnTqV//u//wOgR48evPvuu7Rp0waA559/nsmTJ3PLLbeQk5NDu3btmDFjhrsn6uzZs5kxYwbDhw/H4XDQvXt33nzzTYKCgqoNawcMGMDmzZu55JJLaNmyJePHjz/sAmIAAwcOZPHixYe9/6qrrsLpdPLKK6+Qnp5Ov379uOyyy9i+fXutr7E2Ro0axdSpU9m8eTMfffQRvr6+nH766XzzzTeceuqpgCusNU2T/v37u+eICy64gPXr1zN16lRyc3OJi4vj8ssvZ9myZaxbt+6I117RlVdeyf3338/FF1/Mjz/+2GCZmmEYTJs2jSeffJJ//vOftGrVijvvvJPnn3/evc8FF1zAs88+y2uvvcZrr71GaGgo5557rnuxtjI//fQTSUlJdfo6V2S327Hb7fj5+XlUXjscte/5bJhe/l6Iv/76ixEjRlRpNDxq1CgiIyM58cQTee+99/jyyy/d/+kzZszgyy+/5LPPPqO4uJi+ffsyfvx4Lj/0Fsbs7Gz69evHU089VasFxhwOB2vXrqV79+7HfVgLrl/mCmtFxBtpfjpOpKS4gtOKi3zt3Vt1v1at4KOPPLc9/DAsXVretqCsh2zFfrKhoaDvDznGND+JiLfS/HT8ys/P588//+TEE0+stsitttYf+IW5G2ayv2A3DqcDwzAwTROrxUqUfyyjOt/BSS2qWUi1mRg1ahRxcXFMmTKl1sdkZWXRv39/3nrrrSoLiYl3Gzx4MNdddx2XXXZZnY4r+3lMTk4mOTmZhIQEdzU41C1b9PrK2qSkJDp27MikSZN49NFHCQ8PZ+HChaxdu5b333+fyMhIZs+ezYQJE7jxxhtZt24db7/9NpMmTQJcifbVV1/N9OnTiYiIIC4ujmnTphETE8N5553XyFcnIiJynDFNyMjwDGJHjICKPZ9+/x1mzKj5XHv2QHGxK5gtM2YM3HILxMR4ti0QERERkXo5qUUPHj/jddbtX8Uf6WvIK8kh0BZMl8iedIs6rUErao9XoaGh3HDDDbz11lvMqM3zXvEK3377LQ6H42/1BT4avD6stVgsvPrqq0yfPp27776b7OxsOnfuzJtvvkmnTp0AV/n6k08+yaWXXkpUVBTjxo3zWN3tzjvvpLS0lIceeojCwkJ69erFG2+8UedV60REROQQpxO2bKm6uFdKCuRWWtCiZ0/PsDYhwfP+kBCIj3dVxcbHl3+0aeMZ1ALExTXI5YiIiIg0ZzaLjR7RZ9Ij+szGHspx46abbmLEiBGsW7eObt26NfZwpAZOp5NnnnmGqVOn4uPTuHGp17dB8AZqgyAi4h00Px1jTifs2uUKYv394ZRTPO/r1w8Os7CFh7Fj4cory2/n5cHy5eUBbVjYUR+6yLGm+UlEvJXmp+PX0WqDICJ/X7NqgyAiIiINqKxtQeXq2NRU2LkTSkpc+511lmdYa7G4wtZNm8q3GYarPUHlKtmkJM/HDAyEIUMa/tpERERERESaGIW1IiIizUFBAezYAR07ei6+9dJL8NZbNR+fklJ12z//6Wp5ULawV5s24Ot7lAYsIiIiIiLS/CisFREROV44HLB7d/V9ZPftc+3z6afQsmX5Ma1aVX8uu90VvpZVxyYmVt1n+PCjfw0iIiIiIiLNmMJaERGRpsQ0obQUbBVW5T14EG6+2dW2oLT0yMenpHiGtUlJ0KdPeShb1r4gOtrV6kBERERERESOGYW1IiIi3ig/39W2oLoq2SuugFtvLd83NPTIQW1oaHkYGxzseV+XLvDiiw13HSIiIiIiIlJrCmtFRES8xYIF8PXXrmC2rG1BdZKTPW9brdC+vasNQsWFvco+Dw1t0GGLiIiIiIjI0aGwVkREpCGZJmRkuALWitWx6enw9tuei32lpMCaNYc/l2FAbCyEh1e9b948z3OJiIiIiIhIk6OwVkRE5Gjatw8+/NAzmM3Lq37fzEzP4DU+3vVvxbYFFStlW7cGX9/qz6WgVkRERETqqcRhsmZPCb/tLSGn2CTYbnBKtI2eMTZs1mPzPNM0TT744AM++OADNm/eTG5uLjExMZx11lmMHj2a6Ojowx7bqVMnJk+ezNChQ6u9f/z48aSlpTF37tyGGr7IUaOwVkREpLYcDti1y7OH7MCB0KtX+T55efDaazWfy26HvXs9w9rBg+GCC9S2QERERESOmbV7S3j1t3z25DlwmGAAJvDF9iJiAq2MOSWA7tG2mk7ztzgcDm677TZ+/fVXxowZwyOPPEJgYCCbN2/m5ZdfZtiwYSxZsoTIyMhqj//uu+8Irrw2g0gTpbBWRESkOn/8AVu2lFfHpqS4FvFyODz3a9HCM6yNiwOLBZzO8rYFFatkExJc/7Zs6dqvoqCgBr8sEREREZEya/eWMPWnXPJKTMJ8DY8q2hKHya5cB1N/yuX+PkENGti++eabfPvttyxcuJCTTjrJvb1Vq1b07t2bQYMG8e9//5tx48ZVe3xUVFSDjU3kWFNYKyIizVN+PuzY4QphCwvh4os97585E375pebzpKZ63rbb4bnnICbG1bbAbj9qQxYRERERqYnTNMktNmvcr8Rp8tKveeSWmET4GRiGgaPCYRaLQbgfHCx07TflnGBsliO3RAiyG1jq2J7LNE3mz5/PxRdf7BHUlvH392fevHlERUWxc+dOBgwYwF133cX8+fPx9fVlyZIl9OrVy90GwTRNXnnlFd577z2ys7MZPHgwRUVFdRqTSGNSWCsiIscvhwPS0lyBamqq5yJf+/eX7xcRUTWsjY/3DGvt9qo9ZMs+r+z00xvkckREREREjuTn3cW8s6GQ7CJnjfvmFpvsyXNiNSC/5PDhrmnC5iIHt36eTZD9yEFsiK+FkZ396BVb+4KFnTt3smvXLk4/wnPouLg4j9sfffQRb7/9NgUFBYSEhHjcN2vWLGbPns1jjz1G586dWbBgAe+//z69e/eu9ZhEGpPCWhERadpMEw4ccIWw7dt79ntdvhweeKDmcxw8CLm5nm0I/vEP6NDhyG0LRERERES8yNv/K6CgtOaqWoD8Q/vVVAhrGK6n3PmlZo1hbXaRk7f/V1CnsDY9PR2AiIgIj+1jxoxh1apV7tutWrXitUNrQ4wcOZIOHTpUOZdpmsydO5drrrmGiy66CIAHHnjA4zwi3k5hrYiIeL+CAsjMhIMH8fnrL0hPL29hkJLiamkA8PTT0L9/+XHVVb0ChIVVrY61VerB1bOn60NERERE5DjkdNYu1K3v/rUVfmjB3czMTI/tkyZNorCwEIC5c+eyfPly933xh3men5GRwf79++natavH9u7du7N169ajOGqRhqOwVkREjh2n01XBmpnp+sjK8vzIzHQt0HXttZ7HXXWVuzesn8MBVmv1509J8bzdpg0MGFAezJaFs5XeKiUiIiIicjy4tqt/rdsgWCwGUPsA1lJDv1oob4NQF23atCEqKorVq1czePBg9/bo6Gj356EV3z0H+Pkd+TFM0/O6fHwUf0nToe9WERGpn5KSqkFrxQD2jjs8Q9VZs2D2bFdgeyTdulUNays9OXMzDIiNLW9VUHlBAn9/mDq1jhcmIiIiItI09Yq10yPGVqsFxn7eXcLza/II9jWOuHBYicMkp9jkrp6B9Iq1HXY/qN8CY1arlWuuuYaXXnqJESNGcMIJJ1TZZ/fu3bU6V0REBLGxsfzyyy8MHDjQvf2PP/7AVvmddCJeSmGtiEhzZ5quNgMVQ9eyz3v1gsTE8n03bYKxY137lLUeOJxrr4VDb2kCwNe35qAWXOeurFcvV8/YkBCKIiII6NTJFdC2bu1a+EtERERERACwGAYhvjUHpme1sfOfvwrZlesg0h+MakJW03QFta2CrJzVxo7NWrcgtrZuvPFGNmzYwMiRI7n55ps555xzCAoKYtOmTcybN4/vv/+eYcOG1epcN910E1OnTqVdu3b07NmTDz/8kHXr1tGjR48GGbvI0aawVkTkeOJ0Qk6OZ+gaHAzdu3vuN26cq61A2T4lJdWfb8IEz7DW1xd27ardWLKyPMPauDjo3NnVLzY01POj4rZKCwsAcOutrn9Nk5KsLNd+dXzFXkREREREytmsBmNOCWDqT7mkF5iE+eIRxpY4TDKLTAJtrv0aKqgFsFgsPPfccyxdupRFixYxZ84csrOziYyMpGfPnsybN49evXqxc+fOGs911VVX4XQ6eeWVV0hPT6dfv35cdtllbN++vcHGL3I0KawVEfFWFdsMZGfDKad43v/xx7B8uWcLgpwcV6VsRWecAc8/77lt69aq/V2rk5XleTssrPyjuqC14rYKPaYAGDjQ9SEiIiIiIl6he7SN+/sE8epv+ezJc+AwTco62VoNaBVkZcwpAXSPPjYtBC688EIuvPDCw97funVrNm7cWGV75W2jRo1i1KhRR318IseCwloRkYZW1mYgM9MVYgYElN+XmgrvvVe192tWVtU2Az/9BBUb4ycnw7ff1vz4lQNXcAWqdvvhQ9eyzzt3rnrcV1/V4qJFRERERKQp6B5tY+Z5IazZU8Jve0vIKTYJthucEm2jZ4ytQStqRaQqhbUiInXhdLoqXn19Pbe/9x4cOFD9QlsV2wxMnQoDBpQfl5UFCxfW7rGzsz1bBFRcdCswsDxkrVzp2qZN1XO99por+FUrARERERGRZs9mNegbZ6dvnNaDEGlsCmtFRMr873+weXPVRbYqtxm48EJ47DHPY//9bzh4sObHqFzlWjFwBbBYDt/P1Wr13PfSS2HwYAgJgbqubKqVUEVERERERES8jsJaETm+ZGXBhg3VB62VK10/+8zz2I8/hsWLa36MzMyq28LCqoa1ZW0GKla6xsR47hMTA2+9VX5/UJArsK2N4ODa7SciIiIiIiIiTYLCWhHxPqbp6uVascL1cJWuDz4I3buXH7t+Pdx5Z+0ep6TEs8I0LOzw+wYFlQeq8fFV77/vPte4Kwazfn41j8Fuhy5dajdeERERERERETmuKawVkYZTXFz9wlkVg9fMTOjdG0aO9Dz2yivL+7weyf79nrePFLiCZ5uB/HzPNgTnnAOtWlVdaCskxHNhr+r06lXzWEVEREREREREjkBhrYjUzDRdwWZ1QWvZ5wDjxnke9+ij8OWXNZ8/MNDztmG4gtL09CMf5+sLRUWe22Jj4YYbPHu9VgxfAwMP32agc2fXh4iIiIiIiIhII1BYK9LcOJ2QnV196JqZCcOGuapLyyxf7mo1UFp65PP6+VUNaysvnnU4lRfdArjoIlcQWzlsrdgD1te36nHh4XDLLbV7XBERERERERERL6KwVqQpKy6uvpdrYiKceqrnfldc4bo/J8dVKXs4vXp5hrX+/jUHtQCFha5wtWKAeuKJcPbZVUPWisFr2eeV3X57zY8pIiIiIiIiInIcUVgr4g0qtxnIzHRVwJ55pud+L74IP/5YHswWFFR/vssv9wxr7XbYu9cV2takcpVrVBQkJR0+aK24veJiXQCXXOL6EBERERERERGRGimsFTnaytoMlAWvSUmu6tQya9bAe+95VsJmZ1etXo2KgqVLPbft2gUbN9Y8huraCrRu7QprjxS2hoZCx46ex3XoAO+8U/NjioiIiIiIiNTR+PHj+eCDD464z8aNGxk1ahRxcXFMmTLlGI2s9kpKSpg/fz7/93//B8DMmTP54IMPWL58+VE5f6dOnZg8eTJDhw6tct/OnTsZMGAAAIsXL+akk06qss+FF17Itm3bmDNnDqeddhrjx48nLS2NuXPn1urxvflrfzxSWCtyJGVtBux2V6hZJj8fXn21aguC6toMzJnjuWjVwYOwYkXNj52V5TqPYZRvCwtzLY51uKC1rNVAQkLV8y1cWNurFhERERERETkmJkyYwL/+9S/37TPPPJMHH3yQQYMGNeKo6ua///0vkydPdoe1119/PVddddUxHYPNZuOzzz6rEtb+9ddfbN++3WPbhAkTcDgctT73zJkzsVqtR2WcUjOFtdI8mKarn6qfn+f2L76AbduqX2grK8vVhxXg+uvh1lvLj/PxqX21aWam5+2K/Vl9fasPXss+rxzW3nMP3Hef5zYRERERERGRJio4OJjg4OAq26KiohppRHVnVloXJjAwkMDAwGM6hr59+/LZZ595BN8An376KT179uTnn392b6v89a5JWMXiNWlwCmul6UtNhbVrq19oq+K/8fFVq0s//tjVA7YmldsK2O2u4LcszAUIDq6+yjU62vPY7t3h009d+1RcjKs2KveEFREREREREWkm8vLyePDBB/niiy8wTZPzzjuPRx55hICAAAC2bt3KlClTWLNmDYGBge63/JcFvw6Hg7lz5/Luu++ya9cuWrVqxQ033MDw4cMBWLVqFddccw1jx45l9uzZtGrVivfff5/09HSmTJnCt99+i9Vq5ZRTTmH8+PEkJCSwePFiHnjgAcDVrmDOnDmsXr3aow3CwYMHmTp1KitWrKC0tJRTTz2VCRMmkJCQgGmavPHGGyxatIgdO3bg6+tLz549eeihh2jTpk2tvzYXXnghDzzwAOvXr/eorl26dCnXXXedR1hbsQ1C2TXPmjWLadOmkZycTHx8PGPHjuXcc88FPNsgLF68mFdeeYV77rmH6dOnk56eTq9evXjqqaeYPXs2S5YswWazce211zJ69Ogqj1emcquITp06MWPGDBYuXMjatWuJjo52f12nTp3K3r176dmzJ08//TQRERF1+K5pehTWincoLobff/cMVyt/XvYxZ46r/2qZ1auhNn1TquvjWt2rQ1Zr1Z6uSUlV95s1CwICXPuEhLiOqw1fX2jZsnb7ioiIiIiIiNTV/Pmuj5qccAI884zntnvvhb/+qvnYq65yfZTJz4cPPvDcdpR98cUXjB49msWLF7N582buueceYmNjueuuu9i7dy8jR45k8ODBjB8/noKCAmbOnMmVV17Jxx9/TEBAAFOmTOHDDz/k4YcfpmvXrnz//fc89thjFBUVMWrUKPfjrFixggULFlBQUOC+74QTTmDevHlYLBbefPNNhg8fzscff8ygQYPIycnhqaee4rvvviM0NJTVq1e7z1VaWsr111+PYRi89NJLhIeHM23aNK6//nq++OIL5s2bx2uvvcbUqVPp1KkTO3fu5OGHH2bKlCm89NJLtf7axMXF0a1bN49WCOvWrSM7O5szzjijxuOnTZvGhAkTaNGiBc888wxjx47lm2++qbZCePfu3bz77ru8/PLL5OXlccstt3DxxRczdOhQFi5cyMcff8wzzzzDueeeS1J1ecphPPHEE0yaNIknnniCyZMn869//YsOHTowbdo08vPzufPOO3n99de5//77a33OpkhhrRxde/fCgQOukPVIla7Dh8M//1l+XE4O3HJL7R4jM9MzrD1SOb6fX3mla2Rk1ftHjIALL/RsQRAYWLs2AxX70IqIiIiIiIh4i7w82Lev5v0qvxMUICOjdsfm5XneNs2q246yrl27cu+99wLQtm1bzjjjDP744w8A3n33XVq2bMkjjzzi3v+5556jT58+fPbZZ/zjH//g3XffZfz48QwZMgSAhIQEduzYwauvvsrVV1/tPu76668n4dBaMP/5z3/IyMhgxowZ2A692/XJJ59k1apVLFy4kDvuuMPdVqC61g0//fQTf/75J0uXLqVdu3YAPP7447zxxhtkZmbStm1bpkyZQv/+/QFX6HrhhRfyySef1Pnrc+GFF/Luu++6WyEsXbqU888/v1b9Zu+++2769u3r/vySSy5h06ZNnHLKKVX2LSkp4eGHH3YHsX379mXt2rWMGzcOwzAYPXo0L730Eps3b65TWHvppZdy/vnnA3DllVeyfPly7rnnHrp16wbAGWecwaZNm2p9vqZKYa1U5XBgZGa6JujKYWvFALZlSxg3zvPY+++HQxPlEaWled4OCan5mOBgV6hauQl2587wwAPVtyCw2498TgWuIiIiIiIicrwJDKzdOzrDw6vfVptjK1dcGkbVbUdZYmKix+3Q0FDSDuULGzZsYOvWrVXCxaKiIrZu3cq2bdsoKSmhR48eHvf37NmTN998kwMHDri3JVRYtHvDhg3k5ubSu3fvas9bk40bNxISEuIOasEV6o4fPx6A/v378/vvv/PCCy+QkpLC1q1b2bx5M9HVBek1uPDCC3n66adZv349nTt3ZunSpUydOrVWx1YcX1BQEOAKZQ+n4v+Fv78/rVu3xjhU+OZ7qOVjUVFRncZf8Zx+h9YcqtgKwtfXl+Li4jqdsylSWCtVzZlD4MyZNb+tv9IkCXgunnU4VitU/oG32eDGG10Te+XFtmpqM9CqFQwbVvPjioiIiIiIiDQHlVsU1EXltgi1FRDQoC0QgCNWiDqdTvr06cOjjz5a5b7g4GB27NgB4A4UKx4H4ONTHpH5Vlhfxul0kpiYyCuvvFLlvGW9co/Ex8enymNW9PrrrzNz5kyGDh1K7969GTVqFMuWLatXZW1sbCzdu3fns88+o6ioiNLSUnr16sWuXbtqPNZeTbFb5YXTKrJVWlPHYrEc8fyVz1VaWlpln4r/B2WO9LU7XimslapqE7iCq8q2sjPPhLi4qlWuFf8NCKi+zcCYMX9j0CIiIiIiIiLSXHXs2JFPP/2U2NhYd/CYmZnJ/fffz3XXXcdJJ52Ej48Pa9as4YQTTnAft2bNGqKiogg9TBaSlJTEhx9+SHBwsHthq9LSUu69914uuOACBg0adMRAsUOHDmRlZZGSkkJ8fDzgWnDs/PPP59VXX+WVV17h9ttv5+abb3Yf88YbbxwxKD2SCy64gHfffZfCwkIuvPDCGkPUY8Fms5GTk+OxLSUlpZFG4/0U1kpV8fE4+vTBGhVV3k6gumrX6nrFXn75sR2riIiIiIiIiDR7I0eOZMGCBdx7773cdtttGIbBtGnT2LBhAx07diQ4OJjhw4fzwgsvEBoaSrdu3fjuu+945513uPfeew8buF588cXMmjWL22+/nXHjxhEcHMyrr77KypUrueOOO4DyCts//viDDh06eBzft29funTpwrhx43jwwQcJCAhg+vTptGjRgq5duxIbG8v3339P//79sVgsfPjhh3zxxRdEVrfuTi1ceOGFTJkyhcWLF/PGG2/U6xxH26mnnsp//vMfFi9eTO/evVmxYgUrV64kvLo2HKKwVqrRowcFHTpgDw2t3UJbIiIiIiIiIiKNqE2bNsybN48ZM2YwcuRIrFYr3bt35+2336ZFixYATJgwgfDwcGbMmEF6ejrx8fE88sgjDB8+/LDnDQ4OZt68eTz99NPceOONOBwOTjzxRN544w06duwIQJ8+fTj55JO58sormTZtmsfxFouFl19+mSlTpnDDDTcAcNppp/HGG29gt9t5+umneeyxxxg2bBiBgYGcfPLJTJo0iYkTJ7Jz505aV1xgvRaio6M59dRT2bNnD927d6/TsQ1lyJAh/Pnnn0ydOpXi4mLOOuss7rrrLubMmdPYQ/NKhlnfuupmxOFwsHbtWrp3716rFfSaOtM0ycrKIjQ0tFn2BhER76X5SUS8leYnEfFWmp+OX/n5+fz555+ceOKJteqdKiINp+znMTk5meTkZBISEhhWYX2lumSLjd+4QkREREREREREREQU1oqIiIiIiIiIiIh4A4W1IiIiIiIiIiIiIl5AYa2IiIiIiIiIiIiIF1BYKyIiIiIiIiIiIuIFFNaKiIiIiIiIiDRRTqezsYcg0uwdzZ9DhbUiIiIiIiIiIk2M3W4HIDc3t5FHIiJlP4clJSV/+1w+f/sMIiIiIiIiIiJyTPn4+BAZGUlaWhoAQUFBWCyqyRM5lpxOJ7m5uaSlpZGZmYnT6cQ0zb/1s6iwVkRERERERESkCWrbti1Op9Md2IpI48jMzGTv3r04nU4KCwsJDw+v97kU1oqIiIiIiIiINEGGYZCYmMj+/fv55ZdfsNvt+Pv7q8JWmoyioiJ8fX0bexj1ZpomxcXFOJ1OSktLOXDgANHR0XTq1Kne51RYKyIiIiIiIiLShPXq1QuANWvWkJ2djWmajTwikdopLi52919u6qxWK9HR0Zx//vnExsbW+zwKa0VEREREREREmjDDMOjVqxddu3YlLy9PYa00CaZpkp2dTUhICIZhNPZw/jYfHx+CgoKw2Wx/7zxHaTwiIiIiIiIiItJIDMPA398ff3//xh6KSK2Ypondbic0NPS4CGuPFjUxEREREREREREREfECqqythbK3DzgcjkYeybFhmiZOpxOHw6FXNkTEq2h+EhFvpflJRLyV5icR8VbNaX4qyxRr06JEYW0tOJ1OAP73v/818khERERERERERESkKSrLGI/EMNV1ukZOp5PS0lIsFstxn/SLiIiIiIiIiIjI0VNWRezj44PFcuSutAprRURERERERERERLyAFhgTERERERERERER8QIKa0VERERERERERES8gMJaERERERERERERES+gsFZERERERERERETECyisFREREREREREREfECCmtFREREREREREREvIDCWhEREREREREREREvoLBWRERERERERERExAsorBURERERERERERHxAgprRURERERERERERLyAwlppVKZpApCTk8PevXsbeTQiIuU0P4mIt9L8JCLeSvOTiDQFZXPVwYMHycnJ4cCBA408Ik8Ka6XRmKaJYRgsW7aMMWPGMGjQIGbNmoXT6WzsoYlIM6f5SUS8leYnEfFWmp9EpCmoOFeNHj2aSy65hHfffZeSkhJ3iNvYDNNbRiLN0tdff81dd93FzTffTKdOnUhMTKRDhw4UFRXh6+vb2MMTkWZM85OIeCvNTyLirTQ/iUhTsHz5cu655x7uvvtuQkNDOe2004iLiyM3N5egoKDGHp7CWmk8OTk53HLLLQwcOJD/+7//o6CggO+++44PPviAoqIiBgwYwMiRIxt7mCLSDGl+EhFvpflJRLyV5icRaQry8vK4++676du3L9dffz15eXl88803fPzxx2zdupV7772X888/312B2xjUBkGOqbLXBvbu3YvNZiMkJISMjAy2bNnCLbfcwksvvURubi7FxcUsWLDA6/qGiMjxS/OTiHgrzU8i4q00P4lIU1A2V+3fvx+73c6uXbuwWCz89ddf3HLLLcyePZucnBy6dOnC+PHj2bt3b6MFtaCwVo4xwzD46quvuO2221i/fj3BwcF8+eWXXHTRRfj4+DB69GjmzJnD2LFjKS4upri4uLGHLCLNhOYnEfFWmp9ExFtpfhKRpsAwDJYuXcrQoUPJzMzk7LPPZsaMGQwfPhy73c5NN93E3LlzGTp0KImJidhstkYdr0+jPro0O1u2bGHOnDlcdNFF9OjRg8TERLZt24ZhGPTo0cO932effUZ4eLhX9AoRkeZB85OIeCvNTyLirTQ/iUhTsGvXLpYtW8Ztt91GWFgYd999N/369cPX15dTTz3Vvd/333+Pj48PPj6NG5cqrJVjZsuWLUyZMoWdO3fSt29fACIiIoiIiODAgQO89957pKSkUFBQwMcff8y8efMIDg5u5FGLSHOg+UlEvJXmJxHxVpqfRKQp2LZtG4MGDaJFixYMHTrUXTXbt29fcnJyeP755zEMwx3ozpkzh5CQkEYds9ogyDHj7+9PVFQUu3btYu7cuR73WSwWfvvtN9auXcvBgwd59913OfHEExtppCLS3Gh+EhFvpflJRLyV5icR8WZlfWrbtWvHddddx4EDB1i9ejX5+fnuffLz8ykqKmLZsmWUlJQwf/58r5irDLNs9CJHWcWV8xwOB1arlYMHD/LSSy+xfPlyhg4dyh133OHePz8/n4CAAIqKivD19W2sYYtIM6D5SUS8leYnEfFWmp9EpCmoOFdVNGXKFObMmcPEiRO59NJLPfrSFhYWYrVaG71XbRm1QZAGUfbDsXr1an766Sf+/PNPTjvtNM4880zGjh2LaZp8+umnGIbB7bffDoDdbvf4V0SkIWh+EhFvpflJRLyV5icRaQoqzlUrVqxg3759REREcPvttzN+/HgMw+Cxxx7DMAwuueQS9/zk5+fXyCP3pMpaaTBfffUV9913H6effjqFhYVs2rSJli1b8q9//Yvu3bszffp01qxZQ79+/bjvvvsae7gi0oxofhIRb6X5SUS8leYnEWkKvvzyS8aNG8eAAQPIzMxk69atGIbBs88+y8knn8wTTzzB+++/z3333cfw4cO9ppq2IoW10iB27NjBmDFjuO6667jssssAWL16NbNnzyY7O5unn34af39/pk2bRmpqKi+//DIRERGNPGoRaQ40P4mIt9L8JCLeSvOTiHirim0P0tLSuOmmm7jqqqu46qqr3NvGjx/Pnj17WLJkCYGBgTz00EMsX76czz//3CsXPtQCY/K3HThwgE2bNnlsy8rKorS0lFNOOYXS0lIAevfuzfXXX09ycjI//PADUVFR/Otf/2LmzJn6RS4iDULzk4h4K81PIuKtND+JSFOwfft20tPTMQwDh8MBuOavkpISzjjjDPd+cXFxPP744xQVFTFr1iwAnnjiCT7++GOvDGpBYa0cBT/99BMvvPACmZmZrF+/nj179pCZmUlKSgq+vr74+PhQXFwMQJ8+fWjTpg3r1q3DNE2io6OJiopq5CsQkeOV5icR8Vaan0TEW2l+EpGmYOPGjYwZM4aSkhJ2794NQEFBAbm5uezfv99j31atWhETE0NOTo57W4sWLY7peOtCYa38bQkJCXz11Vdcf/31XH/99ezbt4+ePXty4okn8sgjj3Dw4EHsdjsOh4OSkhICAgI44YQTql2dT0TkaNL8JCLeSvOTiHgrzU8i0hQEBARgtVq54IILGDhwIDt27CAuLg7DMHjvvfc8Alu73U5ERASxsbGAq3WCN1NYK3+L0+nkpJNO4vbbb2fDhg1ER0fTokUL/Pz8GDlyJPv37+fee+9l8+bNrF+/nhdffJFNmzZx9tlnN/bQReQ4p/lJRLyV5icR8Vaan0SkqTjrrLPo168faWlpREdHExAQQOvWrXn88cf5/PPPmTx5MitXruSvv/5i6tSp/Pbbb/zjH/8A8PoXl7TAmPwtTqcTi8XC888/T3FxMfPnz6dnz548+uijtG7dmkWLFvHee+/xxx9/0LZtW3x8fJg+fTqdO3du7KGLyHFO85OIeCvNTyLirTQ/iUhTUNaj9tVXXyU/P5/ff/+d7OxsXnjhBRISEli+fDmTJk2isLCQ4OBg/Pz8ePrpp5vMXKWwVuqlbLW9rKwsQkND3dt///13rrnmGnr27MnEiRNp06YNTqeT33//naCgICIiIry6L4iINH2an0TEW2l+EhFvpflJRJqCsrkqLy8Pm82G3W4H4KuvvmL27NkUFBTwwgsvEB8fz969e9m7dy82m43o6OgmtfChwlqps7IfjpUrV/Lvf/+boqIizjrrLIYNG0Z0dDTr1q3jmmuuoVevXtx9992kpqbStWtXWrdu3dhDF5HjnOYnEfFWmp9ExFtpfhKRpqDiXDVnzhz27dvHeeedx5133gnAsmXLmD17Nvn5+Tz33HPs27ePpKQkwsPDG3nkdaewVurliy++4N577+XKK69k3759bN68mTPPPJMbb7zR/Qt91KhRhISEUFxczPvvv0+bNm0ae9gi0gxofhIRb6X5SUS8leYnEWkKyuaqIUOGEBwczPz58xk9erQ7sF2+fDmvvPIKGzZswOFwsGzZMuLi4hp51HWnsFbqbPPmzdx6663ccsstDB06lIMHDzJgwAAiIyM5++yzufnmm2nZsiXbtm1jzZo1nHbaacTHxzf2sEWkGdD8JCLeSvOTiHgrzU8i4o0KCgrw9/d3V9Ru27aNm2++mZtvvpnhw4eTlpbGRRddREFBAVdffTUPPfQQAFu3bmX9+vV07dqVxMTERr6K+vFp7AGId3vttdc4ePAgDzzwgHvbnj178Pf35/zzzycjI4MnnniCYcOGERgYyPz587Hb7Vx55ZW0a9eOxMREr19lT0SaJs1PIuKtND+JiLfS/CQiTcHChQv5/fffuffee919sdPS0ggNDeWyyy4jKyuLZ555hmHDhtGtWzfGjRtHREQEl112Ge3bt6d9+/aNfAV/j6WxByDey+l04uPjw9tvv80LL7zg3r5nzx5CQ0PJy8vjo48+wt/fnxtuuIF77rkHm83GokWLGDduHMXFxY04ehE5nml+EhFvpflJRLyV5icRaSo2bdrEL7/8wuuvv056ejoARUVF5ObmsmfPHj744AN8fX0ZMWIEp512GgEBAbzwwgs8/vjjFBYWNvLo/z5V1sphWSwWrr76avz9/XnyyScxTZO77rqLyy67jFatWmGz2Vi2bBn9+/enZcuW7Nq1i/bt2/OPf/yDf/zjH+5V+UREjjbNTyLirTQ/iYi30vwkIk3FQw89xPPPP8/XX39NaWkpt956KwMHDiQyMpKQkBC+/fZb+vfvT7t27cjIyODMM89k8ODBdOrUCT8/v8Ye/t+mylqplmmamKaJr68vp512Gtdffz2vvPIKr776KoZhcMYZZ7Bjxw42btzIgAEDsFqtLF68GKfTyUUXXURMTExjX4KIHKc0P4mIt9L8JCLeSvOTiDQVJSUlAFx22WXEx8fz+eefM2vWLDIzM+nevTtpaWmsWrWKjh07YhgGb7/9Ntu3b6dv374kJCQ07uCPElXWioeyxs1lfYi++OILnnrqKU4++WQiIyN57rnnKCgo4J577iExMZGAgACuueYa2rZty/r165k7dy4RERGNfBUicjzS/CQi3krzk4h4K81PItLU2Gw2PvnkE1599VXi4uKw2Wx88MEHOBwObr75ZuLi4ujUqRMPP/wwLVu2ZNOmTbz99tuEhIQ09tCPGsM0TbOxByHeITc3l6CgIPft5ORkrrrqKm6//XaGDRtGTk4Oy5cvZ9KkSfzf//0fY8eOZcuWLcyZM4eQkBAuvfTSJt/EWUS8k+YnEfFWmp9ExFtpfhKRpiA/P5+AgAD37W3btnHDDTdwyy23MGjQIIKCgnj++ef56aef6Nq1K2PHjmXNmjX8+OOPFBQUMGLEiONurlJlrQDwxhtvsGHDBqZOnYrFYsFisZCRkUFQUBD9+/fHbrfTokULLr/8ciwWCxMmTCAsLIwbb7yRxx57DKfTicWirhoicvRpfhIRb6X5SUS8leYnEWkKpk6dSkFBAQ8//DBWqxWAgwcPAtCjRw/3C0533nknVquVOXPm4Ovryw033MDpp5/ufvfA8UazrwAQFBTErbfeio+PD6WlpYBrtdCUlBSSk5MB11toAM4880zCw8OZPn06L774IoB+kYtIg9H8JCLeSvOTiHgrzU8i0hT07t2bK664AqvVSnFxMeDqWVtYWEh2djYApaWlGIbB7bffTlBQEO+//z6zZs1yz23HI83AzdxXX31FTk4OV1xxBe3bt2fNmjXcc8897Nmzhx49etC3b19mzZrFH3/84X61IiwsjL59+/LAAw9w4YUXNvIViMjxSvOTiHgrzU8i4q00P4lIU/Dpp5+yfft2zj33XE488US++eYbHnnkEXJycujduzeRkZHMmDGDzMxMfHxcTQGys7Pp0KEDgwcP5tprr8XHx+e4rKoFhbXN2o4dO7j99tt55JFHSE9PB+DPP/9ky5YtTJ06lZycHK677jr279/P1KlTWbZsGevWrWPmzJmsWbOGIUOGHHd9QUTEO2h+EhFvpflJRLyV5icRaQr+/PNPnnvuOZ544gl27NgBQHFxMUuWLOGpp57C4XAwZcoUduzYwZgxY1i+fDlr1qxh1qxZpKWlMXr0aKKjoxv5KhqWFhhr5r799lvuuecezj77bB577DECAwOZP38+CxYsoF27dkyePJlff/2VuXPnsmLFCtq1awfA9OnT6dy5cyOPXkSOZ5qfRMRbaX4SEW+l+UlEmoIFCxbwwQcfEBISwoQJE4iPj2f58uXcddddXHTRRdx3333s37+fCRMmsHfvXux2O4GBgUyePJmTTjqpsYff4BTWCt999x2333475557Lk888QSBgYHMmzePhQsX0q5dOx577DFCQkLYsmULAQEB+Pv7Ex4e3tjDFpFmQPOTiHgrzU8i4q00P4mIt6q4eOHChQtZuHAhERER7sD2q6++4p577uGiiy5i0qRJ2Gw2tm3bhtVqJTQ0tNnMVQprBYBvvvmGO++8k/79+/P444+7f6H/5z//ITExkfvvv5/Y2NjGHqaINEOan0TEW2l+EhFvpflJRLyVaZruXrMLFizgP//5T7WB7eDBgxk/fjxhYWGNO+BGoJ61zVBZPp+enk5OTg45OTmcddZZPP/88yxfvpyHH36YvLw8rr76aoYPH866det49tlncTgcjTxyETneaX4SEW+l+UlEvJXmJxFpCsrmqoyMDHev2iuuuIIrr7ySAwcO8OSTT5KSksLAgQN5/vnnWbJkCS+88EKznKtUWdvMlL2CsXz5cmbOnElRUREnnngit912G+3atWPlypXcddddHq/ALly4kL59+9KmTZvGHr6IHMc0P4mIt9L8JCLeSvOTiDQFFeeql19+mb1799K7d28mTJhAREQE77//Pu+++y4tWrTgoYceom3btqxcuZLWrVs3y4UPFdY2Q19++SX33HMPN954I6Zp8s033xAZGcmDDz5IYmIiK1eu5F//+hennnoqzz33HAEBAY09ZBFpJjQ/iYi30vwkIt5K85OINAVfffUVd999NyNGjKB9+/ZMnz6d/v37M378eHdg+5///AeLxcLTTz/drF9QUljbzOzYsYNbb72Va665hssvv5zMzEwGDRqEn58fiYmJPPzwwyQkJPDVV18xadIk3n//faKjoxt72CLSDGh+EhFvpflJRLyV5icRaQp27drFzTffzFVXXcWIESPIycnh/PPP5+DBg/Tr14+pU6cSERHBe++9xyeffMLTTz/drPtqq2dtM1Axj8/IyCAvL4/TTz+dnJwcJk+ezKBBg7jjjjvYsGEDU6ZMYd26dQwcOJDPP/9cv8hFpEFpfhIRb6X5SUS8leYnEWlqsrOzKSkp4bzzziM7O5snn3ySSy65hEWLFrFmzRqefvpp1q5dy5VXXskrr7zSrINaUFjbLBiGwc8//0xOTg6maZKYmEhRURFLly7FYrFw5ZVXcumllxIREcGqVau4++67yc/Px9/fv7GHLiLHOc1PIuKtND+JiLfS/CQiTcX//vc/1q1bh8ViwWKxkJ2dzdKlSzEMgwsvvJAOHToQHR3NkiVLePbZZ8nNzSUoKKixh93oFNY2A3l5eTz66KNMmzaNk08+mbvvvpuYmBiWLl1KXFwcHTp0IDs7m9jYWCZMmMCCBQsICAjAMIzGHrqIHOc0P4mIt9L8JCLeSvOTiHg7p9NJdnY2d911FytWrCApKYnnnnuONm3asGzZMhITE+natSsAnTt35tlnn+Wpp55SUHuIwtpmwM/Pj4EDB7Jt2zby8vLo2rUr6enpJCcnc/LJJwMwd+5c9u3bR79+/YiKimrkEYtIc6H5SUS8leYnEfFWmp9ExNtZLBZCQkIYPnw4CxcuZMeOHXTq1InMzEzWrFlDbGwshmHw8ssv87///Y/evXsTFxfX2MP2Glpg7DhkmmaVV03T0tIYMmQId9xxB9dddx2maXL55ZezceNGOnbsyM6dO3nrrbfo3LlzI41aRJoDzU8i4q00P4mIt9L8JCJNQcW5yuFwYLVa2bJlCw899BBDhgzhqquuIicnhwkTJvDtt9+SmJhIWloab731FieeeGIjj967KKw9Tq1bt47du3dz/vnnu7e9+OKL/Pjjj0ydOpXWrVtTUlLC7NmzCQwMpF+/fiQmJjbiiEWkudD8JCLeSvOTiHgrzU8i0hSsWrUKHx8fTjjhBAIDAwF48MEH+f333/nkk08A13y2ceNG0tPTufDCC0lISGjEEXsnhbXHGdM0KSgo4IorriAjI4PWrVtz5513cuKJJ3Lw4EGuvfZapkyZwplnntnYQxWRZkbzk4h4K81PIuKtND+JSFORlZXF2LFj+fbbbzn//PPp27cvV155Jfv27WP06NEMGjSIm266qbGH2SQorD1O7d+/n9TUVF5++WXS0tIICQlh3LhxzJ8/n127dvHWW29pNVARaRSan0TEW2l+EhFvpflJRLxJde1Zyixfvpwvv/ySzz77jFNPPZUzzzyTjRs3EhQUxIQJE7TYYS0orD0OVf6hWbFiBd999x2LFy8mMTGR9evX8+abb9K3b99GHKWINEean0TE2zidTiwWi+YnEfFamp9ExBuV9aWFqvNUYWEhaWlpPP/88xQVFbFy5UoAXn/9dfr169co421KfBp7AFI/X3zxBXv27KGkpIRBgwYRGxvrvq/sB6Tsj49zzjmHc845h4svvpgffviBkpISWrdu3VhDF5Hj3KJFi9iyZQslJSWcffbZnHnmme55SfOTiDSmzz77jN27d5OTk8PZZ59N165dqwS1mp9EpDHo7zsRaQrmz5/PqlWreOGFF7Bare7AtnK1rK+vL+3bt2f69Omkp6ezaNEivv76a9q0adNII29aVFnbBE2bNo0PP/yQDh068Msvv3Dqqafy5ptvYrFYanV8cXExdru9gUcpIs3RtGnTeP/99zn77LNZvXo1l112Gbfffnutj9f8JCINZfr06SxZsoQuXbqwfv16wsLCuPrqq7niiitqdbzmJxFpKPr7TkSaAqfTydixY/n0008ZPnw4jz32GOBZYVtR5Wrb/Px8AgICjtl4mzJV1jYxK1as4LPPPuONN96gU6dObNiwgSuvvJK0tDSPVygO98MC6Be5iDSI9evX8+WXX/Lyyy/To0cPj/sq/qLW/CQix9qnn37K0qVLmT17NieccAKlpaVcc801fPjhh1x66aW1mns0P4lIQ9DfdyLSFJimicVioW/fvvz666+sWrWKf/3rX8yYMQOr1equ/K+o7O+/sr8FFdTWnsLaJmbPnj2EhoaSkJAAgL+/Py1btmTWrFmUlJRwwgkncPXVV+Pj41PtD4uISENJT08nJyeHmJgYwPVHxdNPP83WrVuxWq2ccsop3HjjjZqfROSYS05OpkOHDnTs2JGSkhJsNhs333wzd9xxB5s2baJLly6NPUQRaab0952INAVlwWtZ4HrZZZexYMECd2BrsVhIT08nMjLysMdK7SmsbSLKXkm12+2UlJTw6aef0rNnT+69916sVitWq5W0tDR+/fVX1q5d6351Q0TkWAkMDMTf35/c3FxM0+Taa6/FMAxOPfVUtv0/e/cd1tT5BXD8m4SwQUQQFVHrQhTcde9VZ111Vq2z2latrW2dtXXUbdW69957W/deFfdWFAdOZO+Q5PcH5v4IIOKE1vN5Hh7x5s1737sScnLueW/fZtOmTVy7do3x48djYSFvP0KI98+UyREYGMjTp0+Vv5kA7O3t0el08gFCCJEuTJ/vtFqtfL4TQvxreHl5kT9/fpo3b45Wq2Xp0qUMGjQItVqNh4cHX331FVZWVuk9zH89+bT8L2F6Y65QoQIrVqxg5MiRWFlZ4ezszMqVK8mcOTMGg4GlS5eycuVKLl++TNGiRdN51EKI/7qZM2dSu3Zt8uXLR758+dDpdKxcuZJOnTrh5OTEb7/9hqurKwaDgSVLlrBq1SrOnTtH6dKl03voQoiPgCkQW7duXc6cOcO9e/fIlSsXAI6OjqjVamJiYsyek7S+mhBCvA+mz3cVK1Zk5cqV8vlOCPGv4Obmxp07dwgICKB169bY2toyduxYoqOj2bZtG1ZWVsTHx0tyzluSvZfB7d69mzt37hAZGUmtWrXw8fFh2rRp3Lt3j507dxITE4OTk5NyMTRr1oyJEydy9epVeTMXQrxXo0aNYsWKFdSpUweAzJkzM2TIEHr37s3Nmzext7cnU6ZMAKjVapo3b86UKVO4cuWKBGuFEO/V8ePH8fT0xNnZGYAyZcowa9Ys5f8A0dHRWFhYYG1trSxbtGgRRqORjh07fughCyE+EuvWrePmzZtERETQqFEjypYty4wZM/D395fPd0KIDGPnzp08evSI8PBwqlSpQtGiRVGr1ajVarJkyUJ4eDjW1tacOnUKjUaDq6srs2fPZuTIkRKofQdkD2Zg48ePZ+fOnWTPnp3IyEhmzZrFtGnTqFmzJlmzZiUgIIDDhw+jUqmUGkYA3t7eZsXohRDiXRs5ciQbNmxg9erV5M2bV6mhVqFCBXr37s3s2bPJly8fkZGRyqQXlpaWeHl5kTVr1nQevRDiv8pgMBAREUG3bt346quv6NKlixKgdXNzM2v7+PFj9Ho9jo6OAEyePJlZs2axcePGDz1sIcRHYty4cWzatAkfHx8CAwPR6/WUKVMGFxcXXFxcCAgI4NChQ/L5TgiRrsaPH8/GjRvx9vZWJpFu164drVq1wsbGhqJFi+Ln58eWLVs4d+4cc+bM4dKlS/z5559YWFgwbNiw9N6Efz0J1mZQ27dvZ9OmTcyYMYNChQoRERHBkCFDGD16NKVKlcLJyYmcOXOydetWChcuTJs2bYiKimLFihU8ePCATz75JL03QQjxHzVt2jSWLl3Ktm3blNca02QXtra2dO7cGbVazdSpUxk1ahQtWrQgc+bMbNmyhVu3bslEPkKI98rR0ZHMmTMzb9489Ho933zzjZLln5hOp0OtVuPg4MD06dOZP38+q1evpmDBgukwaiHEf9358+fZsWMHM2bMwNvb26zcSmxsLFZWVuTMmZNt27ZRuHBh2rZtK5/vhBAf3Pbt29mxYwdz586lUKFCxMfH06FDBzZt2kSTJk2wsrLC1taWP/74g/z58zNz5kzy589Pnjx5UKlUVKhQIb034T9BgrUZlL+/P2XLlsXb2xuj0YiTkxOVK1fmyJEjREVF4eTkhI+PD7169eLPP/9k4cKFODs7ExMTw/Tp08mePXt6b4IQ4j/o+fPnHD9+nFq1auHk5AQkZLL9+eef3Llzh8DAQNq0aUODBg3Imzcvw4YN4+jRo9jb26PVapk3bx45c+ZM340QQvxnmb44cnR0pGTJkixdupSYmBh++OEHJWBruhPA2tqaTJkyMWTIEPbt28eKFSvkyyQhxHsTFRWF0WjExcUFlUqFwWBgzJgx3L17l+fPn9OqVSuqVKnCDz/8wMSJE1m0aJF8vhNCfHD+/v7kz5+fAgUKoNPp0Gq1fP311/Tq1Yvr169TtGhRmjVrxsOHD+nevTv58+fHYDDg6OhI69atpe7/OyLB2gwqOjqaM2fOKN+yAnh6ehIbG0tQUBA5cuTA0tKSHj16ULNmTXx9fcmePTuFCxcmW7Zs6Tx6IcR/VZYsWejYsSO//vore/bsoUWLFrRr1w6tVkvOnDlxcHCgf//+9OjRgz59+lCyZEkePXqEVqvF1dXVrF6kEEK8D6dPnyYyMpJff/2VJk2a0LNnT1QqFX369CFTpkxKQDd37twEBgZy4MAB1q5dS6FChdJ55EKI/7LY2FiePn2qvAa1b98eKysr8ubNS5YsWRg8eDA9evTg22+/pVKlSpw7d44cOXLg5eUln++EEO+dXq9Ho9EQGBjI06dP0Wg0ykSI9vb26HQ65f8eHh788ccfWFlZYTQaldc1CdS+OxKszWBMheS9vLy4f/8+AQEB5M2bF0g48fV6PXq9Xmmv0WgoVKiQfMAQQnwwtWrV4tatWwwbNgw/Pz8KFCigZK2pVCqKFi3K8OHDqVWrFt7e3mTJkiW9hyyE+A9bu3YtBQoUoFixYgA4ODhQqFAhVCoV1atXZ9y4cfzyyy8ASsAWwNXVlQ4dOtC6dWvlby0hhHiXpkyZwv379xk7diwlSpSgWLFiTJo0ierVq+Ps7MywYcPInDkzAD4+PgwbNowqVapQsmRJihQpks6jF0J8TEyB2Nq1a+Pr68vdu3fJnTs3kHDHklqtJiYmRmmr0WgwGo0SoH1PJFibQezatYvSpUsrWWf169enaNGiZre7REREoNVqlYkwIKF2ZOHChalevfoHH7MQ4uOwe/duHj58SHR0NOXLl6dYsWL06NGDu3fvsnDhQr799lslUAvw+eefM3/+fPz9/eWWYiHEezVixAhWrVrFzp07lWWenp6MGjWKzJkzYzQaqV+/PkCygK2TkxN9+/ZV7mASQoh3acyYMSxYsEAJumbKlIkaNWrw999/ExoaitFoJHPmzMTHx6PRaGjWrBnz5s3j4sWLlCxZUoIgQogP4ujRozx58oQsWbKQL18+ypcvz+zZs83uiIyOjsbCwgJra2tl2aJFizAajXTs2DEdRv3fJ8HaDODJkydMmTKFQoUK8euvvyrB2KR1HYODg81mLZ4yZQrTpk1j/fr1H3zMQoiPg2km0EKFCnHlyhV27txJu3bt+OKLL/j88895/vw5n332mfJhwmg0Ehsbi42NDQ4ODuk8eiHEf9nIkSPZsmULa9aswd3d3Syw4eTkpNSmBZSA7cCBA4mKimLgwIFkypRJArVCiPdi5MiRbNq0icGDB7N06VICAgJwd3ena9eu3L59m/Xr15MnTx7CwsJwdHTEYDCg1+txcHDAxcUFkNuJhRDv39ixY9myZQtWVlZYWFgQERHB0KFDqVmzplm7x48fm8WiJk+ezKxZs9i4cWM6jPrjoE7vAQiws7MjJiaGw4cPM3ToUEJCQgDMyh2YqNVqLC0tmTRpErNnz2bdunUULlz4A49YCPEx2LZtGzt27GDOnDnMnTuXvXv3YmlpyaZNmwAoX748kydPxtPTk/v37xMYGEh0dDTLli0jMjIST0/PdN4CIcR/1ZgxY9i4caNZrdnEgQ2VSoVarTb7W6p+/fr8/vvvHDp0iLi4uA8+ZiHEx2H06NFs2LCBRYsWUblyZR4+fEhYWJjy+MiRI2nTpg1BQUEMGDCAW7ducevWLWbPns2TJ0+Uki5CCPE+HThwgM2bNzNlyhQ2btzI5MmTqVmzJj179mThwoVmfyvFxcWhVqtxcHBg+vTpzJ8/n9WrV1OwYMF03IL/NsmszQC0Wi06nQ4vLy9u377N8OHD+fXXX5NlhahUKqytrRk9ejSbNm1i5cqVUstICPHe3L59G09PTwoVKoROp8PGxoauXbvy008/ceXKFQoXLoyNjQ0PHz7kxx9/5OLFi5QqVYr79+8zc+ZMmQxDCPFexMfHc/bsWbJnz46HhwcAOp2OqVOn4ufnB0CxYsXo1q0bGo1GmTADoEmTJtSqVQt7e/t0G78Q4r9r3LhxLFq0iA0bNihfJBUqVIitW7fi5eVFXFwclpaW/Pbbb2TPnp29e/fSsGFD8ufPj16vZ/bs2cnurhRCiPchJCSEPHnyULx4cSChjNSvv/6Km5sbY8aMQavV8uWXXwJgbW1NpkyZGDJkCPv27WPFihVS7u49k2BtBnDu3Dm0Wi0jR45k9+7drF+/3ixga/qQkS1bNiIiIti7dy+rV6+WjFohxHthupX42bNnBAYGolKp0Gq1QEJx+bi4OCXwAZAjRw769OnDvXv3cHFxoUiRIuTIkSO9hi+E+I+zsLCgX79+/Prrr0yaNIk+ffrQvXt3oqKi8PLyIiAggLVr13L79m1GjRpl9noFSKBWCPFe6PV68uXLx6ZNmyhYsKCSdJMnTx7++ecfACwtLdHpdGi1Wr7++mvat2/P1atXcXFxwd7e3qxGpBBCvE8Gg4HLly8THBys1Pm3sLDg22+/xWAwMGLECHLnzk2lSpXIlSsXgYGBHDhwwOyuJvH+SBmEDCBr1qyUK1cOBwcH2rZtS8OGDfHz82P48OGEhIQoHzJKlChBvXr1WLhwoQRqhRDvjelW4tq1axMTE8P9+/eVx5ycnFCr1cTGxgL/L9dSsWJF2rRpQ+3atSVQK4R47woVKkTDhg05efIk/fv3J0uWLMyYMYPffvuNadOm0bx5cy5duqRk2gohxPum0Who2rQpBQsWNKuh3blzZ+7evcvmzZuBhLsqjUYjADY2NpQsWZJcuXJJoFYI8UHEx8cD8Omnn5I3b16mTp1KaGgoKpVKeW3q1q0bTZo0YcyYMQQFBZEjRw46dOigzGUi3j8J1mYA7u7u/PTTT9jb22NhYUHnzp2TBWxNJk6cKBeHEOKDqFy5MrNnzzYrZxAREYGFhQWWlpZAwgeTxYsXs3TpUgDlDV4IId4nGxsbmjZtip2dHZs3b8bd3Z3MmTNjMBjQarV88cUX+Pv7c/369fQeqhDiI2IK0KpUKuV3V1dXihQpwvHjxzEYDGaBXCGE+FB27dpFUFAQFhYJN9h7eHhQpUoVTp48yYYNG4iIiEClUmEwGLCysqJevXqEhYUREhKCg4MDP/74I3nz5k3nrfh4SLA2A7C0tCRTpkxAQpaaWq1WArb+/v7069eP0NDQdB6lEOJjlC1bNqUEAsCTJ08wGAzKa9bkyZMZPXo0ZcuWBWTmYiHEh+Pm5sZPP/1E7ty5adiwIZAwEavRaMRoNFKoUCFcXV3TeZRCiI9dlixZaNWqFRs2bODIkSNKMEQIIT6UJ0+eMGXKFEaNGmU24eH3339PkSJFWLFiBatWrSIoKEiZM8nDwwMrKyuio6OBhLq14sORYG0Go9FolPpGnTt3pnr16kRGRhITE5PeQxNCCHQ6HRqNBgcHB6ZNm6bMBFqgQIH0HpoQ4iNUqFAhNm7cSP78+Xn06BERERFERkaybNkynj17pkxAJoQQ6emzzz6jRYsWDB8+nMuXLyvBECGE+BDs7OyIiYnh8OHDDB061Ozu7TFjxlCyZEk2btzIuHHjuHfvHg8fPmT9+vWoVCqyZ8+efgP/iKmMcs9qhmQK2BoMBsLCwnByckrvIQkhPmKmW/Z27NjByJEjKVWqFHv27GHlypUyE6gQIt0FBgbSsGFDNBoNbm5uhISEMHXqVKnxL4TIMC5cuMDQoUNxdXXlr7/+QqvVyh1JQogPIjY2ls8++4xPPvmEkJAQ8ubNq0xobzJnzhwOHTrEP//8Q758+YiIiGDGjBnyt1Q6kWBtBmYK2AohREZx9epVmjZtipWVFStXrsTLyyu9hySEEACcPn2aS5cu4erqSvHixXF3d0/vIQkhhJndu3fj5eVFzpw503soQoiPyMmTJxk8eDCLFy9m9+7drF+/nnz58iUL2EZHR3Pu3Dns7e3JmjUrbm5u6Tfoj5wEa4UQQqRZTEwM48aNo23btuTLly+9hyOEEEIIkeHJpGJCiPR0584d5s+fT79+/bC2tmbhwoVs3brVLGAryYIZiwRrhRBCvBadTmc26ZgQQgghhBBCiIwpLi6O6OhoZZJog8HA/PnzkwVs9Xo9Go0mnUcrQIK1QgghhBBCCCGEEEL855kCsqaA7Y4dO3BxcWHs2LFKMFekP8lxFkIIIYQQQgghhBDiP84UqFWr1XTu3Jnq1asTGRlJTExMeg9NJCKZtUIIIYQQQgghhBBCfCRMAVuDwUBYWJjZRGMi/UmwVgghhBBCCCGEEEKIj4hMKpZxSbBWCCGEEEIIIYQQQgghMgAJoQshhBBCCCGEEEIIIUQGIMFaIYQQQgghhBBCCCGEyAAkWCuEEEIIIYQQQgghhBAZgARrhRBCCCGEEEIIIYQQIgOQYK0QQgghhBBCCCGEEEJkABKsFUIIIYQQQgghhBBCiAxAgrVCCCGEEEIIIYQQQgiRAUiwVgghhBBC/OcZDIb0HkKG9DHsl49hG4UQQgjx3yHBWiGEEEKId+TChQv8+OOPVKlSBW9vbypWrEjLli1ZtmwZsbGx6T2813L+/Hk8PT3x9PRk1apVyR6PiYmhRIkSeHp6Mm7cuDT1OWXKFDw9Palbt66yrH379nh6ejJkyJDXfm5a7dmzh06dOr32897UmTNn6NWrFxUrVsTb25tKlSrRt29fbt68+cHG8CrXr1+nQ4cOPHz48IOs72M59kIIIYQQb0uCtUIIIYQQ78CiRYto3bo127Zt48mTJ1hbWxMaGsr58+cZNmwYXbt2JTo6Or2HmWbFihUjd+7cAGzfvj3Z4wcPHiQqKgqARo0avfF6MmfOjJubG5kyZXrjPlKzbNkyvvvuO+7fv/9e+k9q4cKFtG3bll27dhEYGIiNjQ3Pnj1j69atNG/enBMnTnyQcaTm+vXrNG3alJMnT6brOP5rx14IIYQQ4l2QYK0QQgghxFs6evQoo0ePRq/XU7t2bfbt28fp06c5c+YMAwYMQK1Wc+rUKdasWZPeQ30tDRs2BODUqVMEBgaaPfb3338DUKBAAQoVKvTG6/jrr784dOgQffv2ffOBpiIyMvK99JuS06dPM3r0aIxGI02aNOHkyZP8888/bNq0iZw5cxIbG8uAAQPQ6/UfbEwpiY6OTvcxwH/r2AshhBBCvCsSrBVCCCGEeEvTpk3DYDBQoEABJk+ejLu7OwCWlpZ07NiRESNGMHbsWCpXrqw8x1RiYM2aNTRq1IjSpUuzaNEiIKHEwKRJk6hTpw7e3t5UqVKFYcOGERISojz/5MmTSh/Pnj1Tlnfp0gVPT0/69+8PwIMHD5R2ly5dokuXLhQrVoyqVasye/ZsjEbjS7fLlDFrMBiU4CxAbGwsBw4cAODzzz8H4Pnz5wwYMEApAVG2bFm++eYbbt++neq+S+lW+OfPn9O3b19KlSpF2bJlGTVqFPHx8cme+6p1TpkyhQkTJgAQEBCAp6cn69evV56/bt06mjdvTvHixSlTpgw9e/bkxo0bZutI7TglNWfOHIxGI4UKFWL06NE4OTkBUKhQIYYNG0bZsmVp0qQJERERynOuX79O7969KVeuHEWLFqVp06asW7fOrN/+/fvj6elJly5dlGXPnj1TxmbKkDWVC+jduzcHDhygcePG+Pj40KhRIw4ePAgknDetWrVS+qlZs6ZyriT25MkTChcujKenp/Jck/r16+Pp6cnUqVPTdBxe5t987JctW0ajRo0oUaIEpUuXpmXLluzevTvV7RVCCCGESAuL9B6AEEIIIcS/WXBwML6+vgC0aNECjUaTrE3z5s1f+vyhQ4ei1WqJi4ujWLFixMXF0aFDB86fPw+Avb09T548YdmyZRw9epRVq1YpQcDX1b17d4KDg7G0tOTx48dMmDCBmJgYevfunWL7Tz75BG9vby5dusT27dv58ssvATh8+DCRkZGoVCoaNGgAwHfffcfZs2exsLDA0dGR4OBg9u3bh7+/Pzt27EjzGHU6HZ07d+batWvK9i9cuBAbG5tkbV+1Tnt7e+zt7YmIiECj0eDi4qL0M3LkSCXwZmtrS0REBLt37+bo0aMsXLiQYsWKma0r6XFKSq/Xc+rUKQBq1KiBSqUye7xixYpUrFjRbNm5c+fo0KEDsbGxaDQarKysuHLlCgMHDuTWrVv069cvzfstsYsXL7Jnzx5sbGyIi4vjxo0b9OnTh3379mFpaYmzszNBQUEAuLq6pliGwM3NjSpVqrB//362bNlC1apVAbhy5Qp+fn6oVCqaNm0KfHzHftmyZQwbNgwAJycn4uLiOH/+PL1792b+/PmUL18+zdsshBBCCJGUZNYKIYQQQryFxBM05cqVS/n99OnTVKlSxewncUajySeffMLx48c5fPgwxYsXZ8WKFZw/fx6tVsuCBQvw9fVl48aNODk54e/vr2Qzvgk3NzeOHDnCP//8o5Q4mDdvHuHh4S99jim71tfXlydPngCwc+dOAEqVKoW7uztBQUFkzpyZfPnysXPnTo4fP87MmTMBuH37NqGhoWke4969e5Vg3ahRo/D19WXDhg3J2qVlnZ06daJ79+4AZMuWjUOHDlGvXj2uXr2qBOv69OmDr68vR44coVixYkRFRTF48OBk60t6nJIKCQlRavhmz549Tdv6+++/ExsbS7FixThy5Ai+vr706dMHgPnz53Pp0qU09ZPUw4cPGTRoEL6+vkycOBGAqKgoTp8+TYkSJZgxY4bSduXKlQwYMCDFfr744gsg4ZiYtm3z5s0AlC9f/qM99ocOHQISsthPnjzJqVOnaNu2LTVr1iQsLCzN2yuEEEIIkRIJ1gohhBBCvCNq9f//tIqLi+PJkydmP4nLFZjUr18fa2trnJ2dAZRbqevXr0+FChUA8PLyom3btmaPv4kuXbrg7OyMVqvl+++/BxJKLqQWFGzQoAEajQaj0ciOHTuIi4tj//79wP8Duc7OzsyYMYMtW7YQHh7OihUrWL16tdLH69QOPXfuHAB58+alWbNmABQuXJjatWubtXubdZr2YY4cOejRowdqtRpnZ2d++OEHAG7cuMG9e/fMnpP0OCVlMBiU31MrLWFy//59rl69CsAPP/yAs7MzarWaHj16kCNHDgD27Nnzyn5SYm9vr5wvderUUZa/bg3XatWq4eLiQlRUFHv27MFgMLBt2zbg/9niH+Ox9/LyAmDp0qV88803LFu2jBYtWjB16lQ+++yzNG+vEEIIIURKpAyCEEIIIcRbcHd3R6VSYTQauX37tnK7eIUKFbh+/TqQUD/zZRmxrq6uZv83BXQ9PDzMlufMmRNIqNWZVOLgYGoTRyVeV7Zs2ZTfU8sGdHV1pVy5chw9epQdO3aQO3duIiIi0Gq11K1bV2m3YMECZs+erWQ9enp6Ko8lDmS+iinLN+l+STzet12nabK0nDlzmpUrMO1jU5vEmdJJx5OUk5MTlpaWxMXF8ejRo2SPR0REcPHiRcqUKYNGozGbsC3xsVapVLi7u/Pw4cMUj7VJasfZ2dlZ2S4LCwu0Wi06ne61joPpuY0bN2bevHls3boVV1dXnj59iqOjo1kA9WM79t9++y3x8fGsXbuWffv2sW/fPiAhA3fs2LEULVr0ldsqhBBCCPEyklkrhBBCCPEWnJycKFWqFADr169PcTKk1AJr1tbWZv83BYbu379vttz0f9PjSbN4TVIraZC4T1NJA9M2pMaUQXvu3Dnmz58PQOXKlZXnHTlyhNGjRxMdHc3q1as5ceIEv/32W6p9voypfmri8aX0/7dZp4uLC5Aw8VTiQPeDBw+U35MG6JIep6S0Wq1yHuzfvz9Zdu2OHTvo2LEjFSpU4MmTJ8oYwPy4GI1GAgICzMZgCiqm9TgnrZuctH5u0v+nxlQK4dixY8oEXQ0aNMDKygr4OI+9paWlMonbmjVrGDBgAIULF+bOnTspTtYmhBBCCPE6JFgrhBBCCPGWevbsiUql4saNG/zwww9KcCkqKorZs2czb968lz43aeDMlJm7fft2jh07BsDVq1dZsWIF8P/b2h0dHZXnnD59GkiY/MmUzZuSBQsW8OzZM/R6PdOnTwcSJljy9vZOdftq166tBKxMk2iZAriAUmdUrVaTLVs24uPjlfFC2soCmJQpUwYAf39/pV7ppUuX2LVrl1m7tK7TwiLhRrLo6GgMBgPx8fFUq1YNSAjYzZw5E4PBQFBQkFLftXDhwskym9MS4OzWrZsytsGDBysZy6dPn2b8+PEA5MuXDzc3Nzw8PMifPz8AEydOJCgoCKPRyMyZM3n48CEqlUo51qYg5o0bN5Q+TYHTN5E4mBsVFZXiFwwmefPmpWTJkuh0OrZs2QKYT5j3sR17o9FIq1atKF68OKNHj6Zw4cJ07NiRevXqASlnvgshhBBCvA4pgyCEEEII8ZbKly9P//79GTt2LLt27WL37t1kzpyZ8PBwdDodkBDwadCgwSv7at++PVu3buXatWt06tRJmdEeIH/+/PTs2VP5PWvWrDx9+pSBAwcyZ84c7t69i4uLS4q34UNCgKpq1apYWVkpE0Z1794dOzu7VMdkb29P9erV2bFjBwB2dnbUqFFDebxEiRJAQq3QmjVrotVqlf4BQkNDkwXAXqZKlSqULFmSM2fO0L9/f4YPH05kZCRZs2YlOjr6tddpWm9QUBCffvopvXv35quvvqJVq1asWrWKSZMmMXv2bGJjY9Hr9djZ2TFixIg0jTWpihUr0rdvXyZMmMDatWtZt24d9vb2Shasi4sLo0aNUtoPGTKELl26cP78eSpVqpTsuBQqVAhIOL8WLFhASEgINWvWJFOmTISHh2NtbU1MTMxrjzNHjhyo1WoMBgOtWrWicuXK/PXXXy9t/8UXX3DmzBmMRiMFCxbEx8dHeexjO/YqlYomTZpw7tw5VqxYwaZNm7CwsFCC6KZMZCGEEEKINyWZtUIIIYQQ70DHjh1ZvXo1zZs3x8PDg8jISKysrChSpAhdunRhx44d9O3b95X9WFtbs2LFCnr06EHu3LmJjY3Fzc2N9u3bs3z5chwcHICE7MgZM2ZQrFgxNBoN8fHx/Pbbb0qGX0rGjBlDlSpV0Ov1ZM+enX79+tGjR480bV/iTNrEmbYApUqVYsSIEeTKlQuNRoObmxv9+/enSJEiAEqGcFqo1WpmzZpFs2bNsLe3R6vV0rFjR3766SezdmldZ5UqVWjQoAF2dnZYWFhga2sLwNChQxkxYgTe3t4YjUbs7OyoU6cOa9asUfp4E19//TWLFi2iWrVqZMqUibi4OPLkyUP79u1Zt24duXPnVtqWLVuWNWvW8Nlnn+Ho6Eh8fDyFCxdmzJgxyoRXkJBt3a9fP9zc3NDpdOTOnZtly5a9sjTDyzg7O9OnTx+yZMkCoJxTL1OvXj0loJ84qxY+zmPfpk0bJk+eTIkSJbCwsCA+Ph5PT08GDRrEjz/+mObtFUIIIYRIicr4OvcmCSGEEEKIf5UHDx5Qs2ZNAFatWkXx4sXTd0BCCCGEEEKIl5LMWiGEEEIIIYQQQgghhMgAJFgrhBBCCCGEEEIIIYQQGYCUQRBCCCGEEEIIIYQQQogMQDJrhRBCCCGEEEIIIYQQIgOQYK0QQgghhBBCCCGEEEJkABKsFUIIIYQQQgghhBBCiAxAgrVCCCGEEEIIIYQQQgiRAUiwVgghhBBCCCGEEEIIITIACdYKIYQQQgghhBBCCCFEBiDBWiGEEEIIIYQQQgghhMgAJFgrhBBCCCGEEEIIIYQQGYAEa4UQQgghhBBCCCGEECIDkGCtEEIIIYQQQgghhBBCZAASrBVCCCGEEEIIIYQQQogMQIK1QgghhBBCCCGEEEIIkQFIsFYIIYQQQgghhBBCCCEyAAnWCiGEEEIIIYQQQgghRAYgwVohhBBCCCGEEEIIIYTIACRYK4QQQgghhBBCCCGEEBmABGuFEOJfon///nh6er7y59tvvzV73q5du/j888/x8fHh008/pU+fPgCEhobSv39/ypYti4+PD7Vq1eLEiRPvdRsMBgO3bt16L30/evSI7777jlKlSlG0aFHq16+Pn5/fK5936tQpfv75Z2rWrEnx4sUpWrQotWvXZsCAAVy+fPm9jDU91a9fXzlXLly4kGKbS5cuKW1at279Wv3XqFEDT09PateurSxbv3690t+mTZte2cemTZuU9uvXr3+t9Sf2Ps+3tIiOjmbevHm0atWKTz/9FG9vb6pXr85PP/3ExYsX021cr+vGjRvpPYRXMhgMVK1aVTlv5syZk95D+le5evUqv/zyC9WrV8fHx4fixYtTv359/vjjD548eWLW9uTJk8p+nj59ejqN+NXS+/pPi/bt2yd7D/fy8qJkyZI0btyYv/76i9DQ0HQbV+HChZVl6XHc/w3H8EOR924hhPi4SLBWCCH+wwICAvjhhx+4fv06cXFxhIWFER0dDcC4cePYsGEDISEhxMXFcf/+fezs7N7bWI4ePUqzZs2YO3fue+l/4MCB7Nmzh4iICGJjY/Hz8yNz5swvbR8fH8+wYcNo3749mzdv5sGDB0RHRxMbG8u9e/dYv349X3zxBUuXLn0v400vjRo1Un7fvn17im3+/vvvFNv/m7zv8+1V/Pz8aNSoEWPHjuXcuXOEhYWh0+l4+PAhW7ZsoWXLlixZsiRdxpZWFy5coH379gwfPjy9h/JKhw8f5vHjx8r/16xZg9FoTMcR/Xvs3r2b5s2bs2nTJh4+fEhcXBzR0dH4+fmxePFiPv/8839d4CS9r/+3YTAYiIyM5Nq1a0ybNo0WLVrw6NGj9B7WB/dvPobvg7x3CyHEx8UivQcghBDi9a1duxZXV9cUH7OyslJ+v3jxIvHx8QA0b96c7t27o9FoADh37pzSfunSpVhaWpIvX773Mt4nT57QuXNnAAoVKvRe1mHaHldXV+bPn49er8fZ2fml7ceOHcuyZcsAKFiwIN988w2FCxcmIiKCzZs3s3jxYgwGA3/88Qfe3t4UL178vYz7Q2vYsCGTJk0CYMeOHfTr1w+VSmXWZteuXQBYWFhQr169t15nvXr1qFChAgCZMmV66/5e5UOcb6kJDQ2lW7duBAQEoNFo6Nq1K/Xr10etVrNv3z6mTp2KTqdj5MiReHt7U6JEiQ8+xrRo06YN8fHxlClTJr2H8krr1q0z+//du3c5ceIE5cuXT6cR/TvExcXx22+/odfryZo1K/369aNIkSLExMSwcuVKVq5cSUhICCNGjGDhwoUAlChRgoMHDwJgb2+fjqNPWXpf/29Co9Gwb98+jEYjOp2OR48esWLFCnbs2MHdu3fp27cvy5cvT9cxfsjj/m88hu+bvHcLIcTHRYK1QgjxL+Tq6kq2bNle2c6URQtQpkwZcufOrfw/KioKgKxZs1K0aNF3P8hEPkSGm2l78uXLR8GCBVNte+HCBRYtWgRAkSJFWLZsGTY2Nsrj3t7e2NraMmPGDAwGA4sWLfrPBGs9PDwoUaIEZ8+e5fHjx5w5c4ZSpUopj1+7dg1/f38AKlWqlGrAO61sbGzM9u/7lt4ZlfPmzSMgIABIKF/SoUMH5bGCBQvi6OjI0KFDMRgMbNiwIcMGa9N7P6ZVUFAQ+/btAyBPnjzK+bt69WoJ1r7CzZs3ef78OZCQidewYUPlsaFDh+Lr68vNmzc5deoUer0ejUaDpaVlmt5/0su/5bxNKvE+zZUrF2XLliUqKoqDBw/i6+vL8ePH0/V8/pDH/d96DN8nee8WQoiPi5RBEEKI/6gaNWrQv39/5f/9+vVT6oh5enoqwaT79+/j6elJ+/btlbbnz5/n66+/pnTp0hQtWpQmTZqwbNkyDAZDsvVcuHCBnj17Ur58eaX27e+//67UOTx58iRVq1ZV2m/YsAFPT0+mTJnyym04fvw4PXr0oEKFCnh7e1OrVi1GjhxJYGCg0mbKlCl4enoq/z9x4gSenp5m257UmjVrlN9/+umnFD+MdOzYkR9++IH58+fz+++/K8tNtYPLli3L4cOHqVmzJt7e3nTp0kVp8+zZM0aOHEmdOnXw8fGhbNmy9OjRg1OnTiVbj6m+W8eOHc2Wm7bL09OT06dPJ2s/ZswYDh06RMuWLSlatChVqlRh3LhxxMTEvHS7TRLfHrljxw6zx3bu3Jliu40bN9K6dWvKli2Lt7c3FSpUoEePHkpGc2pSq3u3ZcsWmjRpgo+PD9WqVWPatGkpnmcAsbGxTJ06lQYNGlCyZEmKFi1KjRo1GDx48Gudb3FxccybN4+mTZtSokQJSpQoQatWrVi7dm2yD4umOn69e/dm9uzZlClThuLFizNt2rSXbu/GjRuBhEykNm3aJHu8efPmjB49mj179jBs2DCzxyIiIpg8eTINGjSgWLFilC5dmq+++ordu3cn6yelGoPw8v2deFtu377NN998Q6lSpShZsiTffvut8kH/wYMHeHp6otfrgYS6zq+6pkwuXbpE3759qVy5Mt7e3lStWpVBgwZx//59s3aJ61/u37+fjRs3KrW1q1WrxqRJk5S7Al5l06ZN6HQ6AHr16kXevHmBhNv7g4KClHYjRoxQ1nn+/HmzPk6fPq08lvhc8fPzo0+fPkpt73r16jFjxgzi4uLMnv+q8yQkJITRo0dTp04dihcvTvHixalTpw6jRo0iLCzMrK+oqCjGjh1LtWrV8PHxoVmzZhw4cMDsNSGxsLAwRo0aRfXq1fH29qZKlSoMGTKEp0+fvnLfWVpaKr+vXbuWNWvWEBERoSxbuXIlx48f58iRI6jVCR8bUqtdeurUKdq3b0+xYsUoW7YsQ4YMISIiIsV9m9bz0eRdXP+Ja78nLpthOuc9PT0ZNGiQstxUu7VZs2Zs2LCBSpUqUbRoUQYPHqy02bx5M82bN6dYsWKUKlWKr776iqNHj75y36fFl19+qfy+d+/eZONKXFPWtP0pHZvE23Hnzh2++eYbSpYsyaeffsqPP/7Iw4cPXzmW1I777du3+fnnn6lUqZJSm/vnn3/m9u3bZu3e1Wt4Wq/L0NBQRo0aRe3atfHx8cHb25uaNWsyfPjwNNUCTnzNPXnyhBEjRlCxYkWKFStGu3btzN6bTZ48ecKgQYOUfVGrVi3GjBlDeHi4Wbu0nFtJyXv3+33vFkKIjEQya4UQ4l/o2bNnL30sS5YsaLXaN+577969fP/990rwAxImnxk2bBjnz59n7NixyvLdu3fzww8/mLW9f/8+K1as4NChQ6xYseKNxzF79mz+/PNPsz/A79+/z6JFi9i+fTuLFi1647INvr6+AGi1Wj799NMU2zg5OdGjR4+X9hEZGUnPnj2V4KjpQ/ONGzf46quvzIJEcXFx7N+/nwMHDtC/f/9kgdk3ceTIERYsWKDsnydPnjB37lwuXrzIggULlHIXKalXrx6jRo1Cp9Oxc+dOBg4cqARiTLdR2traUrNmTQAWL17MH3/8YdbH8+fP2b9/P8eOHWPz5s3kyZPntbdh3rx5ZufTo0eP+Ouvv8iaNWuK7fv27ZssaBkQEMCaNWv4559/XlrHL7GoqCjat2/PpUuXzJafO3eOc+fOcejQISZOnJhs/x0/ftysHuDLstEfPXqkfPj09vZO8Vq0srKiadOmyZY/ffqUtm3bmgU2Y2JiOHHiBCdOnOCrr75i4MCBr9zGV7lz5w4tW7Y0Cx7s3buXW7duJQsAvI5NmzYxaNAgs9eDx48fs3btWnbu3MmsWbMoXbp0sufNnTvXLOjx6NEjZsyYgYWFBT179nzleteuXQsknLM1atTg3r17TJ48GZ1Ox4YNG5QvUtq0aaPUCd6wYQPFihVT+jAF2NVqNV988QWQ8EVUx44diYyMVNrdvn2bSZMmcfz4cebPn4+Fhfmf0imdJ3q9ni5duiQ75+7evcvChQu5du2akumv0+no0qULZ86cUdpdvnyZb775hiJFiiTb9tDQUFq3bm0WFHvy5AmrVq3iwIEDrFq1iuzZs7903xUoUIBChQpx7do1QkNDGTx4MEOHDqVo0aKUL1+e2rVrp/l25H379tGzZ08lyB8TE8OqVau4fv16qs971flouhbfxfX/pu7evcvAgQOVYJS3tzcA48ePTzaZ3YkTJzh58iTDhw+nRYsWb7XexMf8ypUrb9UXJLxut27dmpCQEGXZtm3bOHXqFOvWrcPNze21+zx79iydO3dW7m4BePjwIZs3b+bgwYMsXbpUudvlXRzDtF6XBoOBTp06JZso9MGDByxdupSzZ8+yevXqZNfwy3Tr1s3sXP7nn3/o2LEjM2bMoHLlykDC3yht2rQx+xvt/v37zJ8/n8OHD7Ny5cpkJSRedm6lRN673997txBCZDSSWSuEEP9CX3zxBVWrVk3xxzQRzKpVqxgwYIDynMGDB3Pw4EFq167NwYMHldsZ3d3dOXjwIJMnTyY6OprBgwej0+nIkycP8+fPZ8eOHXz77bdAQjDGdLtxZGSk0jZTpkz8+eef7Ny5k19++QVI+EN8xowZlChRQgmmANStW5eDBw/SqVOnl27fuXPnmDhxIkajEQ8PD2bMmMG2bdv44YcfsLCw4NmzZ/Tu3Ru9Xk+nTp2UOnoApUqV4uDBg2bbnpRpspbMmTObBdMMBgOPHz9O8ScpnU5Hzpw5Wb9+PQsXLqRly5YYjUZ+/PFHgoKCsLCwoE+fPmzbto0ZM2bg4eGB0Whk9OjRZoGYN3Xjxg2qVKnCunXrWLZsGV5eXkBCdsqGDRtSfa6zszMVK1YEEgL///zzj9Knn58fALVq1cLGxgaDwaDU9i1evDgbNmzg77//plu3bkBCxsybZJEFBQUp9fdsbW35448/2L59O/369VNuy07M39+fQ4cOAdCyZUt27tzJpk2bqFSpkvL47du3X3m+jR07Vvmw17BhQ9avX8/KlSuV/fH3338zb968ZOsPCwujbt267Nixg4kTJyp1/JJK/CE9tQnuUpI4A7Vjx45s3ryZhQsXKgGbRYsWsW3bttfqMyU3btzA29ubtWvXsmTJEuUD9t27d/H19SV79uwcPHhQ+dBbvHjxV15TAQEBDBkyBJ1Oh7OzM+PHj2f79u389ttv2NraEhERQa9evcyyNk18fX358ccf2b59Oz///LOyPC2ziZ89e1Z5zatRowa2trY0atRIqeW4evVqpW2+fPmUL2e2b9+uZOHFxMQoWWlVq1Yle/bsGI1GBg0aRGRkJFmyZGHatGns3LmTX3/9FbVazcmTJ1P8Miql8+TUqVNKkOe7775j9+7drF27VjmuJ0+eVAJP69evV14fvL29WbZsGRs2bKBWrVpcvHgx2fomTZrE7du3UavVDBgwgJ07dzJjxgxcXV158uQJI0eOfOU+nDRpEu7u7sr/dTodvr6+TJ06lcaNG9OlS5dXZunq9XqGDRumlEr45Zdf2L59O2PHjk2WXZnUq85HeHfX/5uKiIigdOnSbN26lenTp1OvXj0uXLigBGqrVq3K+vXr2bhxIzVq1MBoNDJixIgUX8teh6Ojo/J7WjJBX+Xx48c4OTkxb948Nm3apJS9ePbsGRMmTHjt/oxGIwMHDiQqKgpLS0uGDh3Kzp07GT16NFqtltDQUMaNGwe8m2P4OtfllStXlEBtp06d2LFjB9u3b6ddu3ZAwpcaZ8+eTfO23r9/X3mf6tu3LyqVCp1Op9R8Bhg+fDjPnj3D2tqaMWPG8PfffzN+/HhsbW25efMmU6dOTdZvSufWy8h79/t77xZCiIxGMmuFEOI/ytXV1eyDnqOjoxKgdXBwUAIxGo1GWb5nzx4lI7Rdu3ZK5mqrVq3Ytm0bd+/eVT6MHjt2TMnO6dq1Kw0aNACgS5cuaDQanJ2dKVKkCJaWlmaTodnY2Lyy7l3ikguTJ09Wghr58+fn2bNnLF26lFu3bnH8+HEqVapklqmSlrp6pkwU0wcsk5CQELPb8BJLKTvs66+/Nst8On78ODdv3gQSsvi++eYbZdxZs2alefPmGI1Gli1bRsmSJVMd46tkypSJiRMnYmdnB8CECROoX78+kHAcTdmBL9OoUSMOHDgAJASuypYta5Z98vnnnwMJ++rvv//m8ePHWFpa4uzsTEREhHKrOWCWpZVWx44dU4JlXbp0UcabL18+Ll++zNatW83a58mTh7Nnz3L37l3c3d2xsrLi6dOn5M6dmyNHjgAJwYzUzrfIyEglkO3p6cm4ceOUc2Hq1KnUqVOHZ8+esWTJEr7++utkYx4wYADZsmUz2/akEt8G+jr19+7evat8oK1evbpZYHTGjBnUrl2b2NhYlixZolxrb0qtVvPnn38qNQ3bt2+vBGoCAwPNXhMgbdfUmjVrlCzzoUOHUqdOHSDheMbExDBmzBiCgoLYtm0brVq1MntutWrV6N69u9J+3bp13L5926zcycsk/nBvCjyZajueOXMGf39/Tp48SdmyZQFo3bo1//zzD6Ghoezbt4+6deuyZ88eJauzZcuWQML1fuPGDQCaNm2qZLvVqlWLXbt2KV+KJC4fY5L0PClfvjxnz57F39+f/Pnzo1KpePDgAe7u7ly+fBmj0UhYWBh2dnZmt7r/+eefSp3x8ePHU7NmTbMvA4xGo5KRVrJkSerWrQskZPk3b96cmTNnsnfvXsLCwszeC5L65JNP2LZtG+vWrWPr1q1cuHDB7LXxyJEjfP3116xbt+6lGfuXL19WvgRr0KCBks2cL18+QkNDk2X3Jfaq8xHezfX/tr7//nsKFChAgQIFAMxeo3r16kWWLFkA6N27N/v27SMmJoYdO3YowcG3ldayIK8ycuRIpdbpqFGjOH36NI8fP1YmOEs6aVVqrl69qgTjmzVrRuvWrYGEc0qv16NSqZTM7HdxDK9du5bm6zLxhFhXr17l2rVrlClThoEDB9K7d+/XnjDr66+/NnufunLlCjt27CAgIIBr167h4eHB4cOHlfGUK1cOgE8//ZTatWuzadMmNm7cmGI5maTnVmrkvfv9vHcLIURGI8FaIYT4F0qcGfsuJa4ROGLECEaMGJGsjSmzIXFbU1anydve5n/t2jUgISCZ9NbfChUqsHTpUiAhoGLKzngd2bNn5+bNmwQHBxMZGakEPF9X0onMrl69qvyedCIYb29vnJycCAkJeeVtwfDqQJ+np6fZuPPly4ejoyNhYWFKPeLU1KxZE1tbW6Kioti1axdDhgxRPvBlyZLFLPvEYDBw/vx59u/fz7lz57h7965ZUPJldepSk7hGYtLbEosXL57sAx8kTJh3/Phxjh07xsWLF5VyAyZJg+9J3blzRwkoli9fXvmwBwkZQsWLF2f37t08ffqUoKAgswlaHBwc0nTNJX5Oall1SYMipnMeSJb54+bmpgQH3sW5kyVLFrNxJs4ATlzC4HWkNv7E/09p/EmvI9N4XhWcioqKUoKVWq0Wo9GoBLzz5s2rZKiuXr1aCdbWqVMHZ2dngoKC2LBhA3Xr1lWCANmyZVO+rLlz546ynrlz5zJ37txk679x4wbx8fFmt1G/7DwJDQ3l4MGDSnZY4jIp8P9z15RZ7ezsbDYhpJWVFT4+PsqdDQDBwcFKsOX06dMpftGk1+uVIFVqbGxsaNeuHe3atSM8PJx//vmHvXv3KvWAr169ypEjR176ZdaDBw+U35NOxphS6YvE0no+vu31n5q0fLGS9DxN/B74si/Hkt6C/7oSl4ZwcnJ6ZftXbYdGozEr/2FpaYm3tzePHz8mPDyckJCQ17ojILW/A1LaJ+/iNdzkVdelh4cH3377LTNmzFBKyUDC5G2VKlWiVatWaS7xAST7grVEiRJK2ZgHDx6g1+uV98KtW7em+B4WHBxMQECAWSY7JD+3UiPv3e/nvVsIITIaCdYKIYRQpKV2W3BwMGD+ofBdZfyYmLK3UsrwSbze18kASqx8+fLcvHkTg8HAkSNH+Oyzz4CEAEniYFKNGjVSDXwmrT2XOOsstbGn9FjSDyuxsbGpbkPSiVQS958WNjY2SrZPUFAQK1asULKC69evr2yL0Wjk66+/5vDhw2i1WmrVqkW7du1wc3NLUz3RtEg67sQfxEyePXtGy5YtefjwIc7OztSpU4cSJUrw4MGDNE1WB+bn9+ueWw4ODmlah4eHB5kzZyY4OJjLly8TFxdnNokTJARxGzZsSIUKFWjQoAE1atRI87mTktc9d5JOqJdafeO0SmsfKW2btbX1G/W1fft2pU6mTqdTMtmT2rVrF8HBwWTOnBlLS0uaNWvG3LlzOXLkCDdv3uT48eNAQnDJtO60vBbqdDrCwsKSBQaSunnzJl9++SWhoaHkyJGDRo0aUbx4cU6dOpWslIKpLEtaruW07qekgeHE1q5dy9GjRwkMDGTcuHFky5YNBwcHatSoQY0aNShatChDhgwBEuqCvixY+zZ10tNyPr6L6z+pxNdNSq+nSaX2ev8yqe37tEj8fpRSYDFpsO1V175er0ev15ud3+/iPRVe/XfAu34Nf5nE1+X3339Pw4YN2b59O8eOHePy5cvcu3eP5cuXs3LlSqZPn0716tXTtO6k50jS/ZbW2rdBQUHJgrVJz63UyHv3+3nvFkKIjEZq1gohhFDkypVL+X3ixIlcv35d+Vm9ejUnT55UarwlnpQi6YQP/fr1o0ePHkp9tsR/PKclCGEqvxASEpJsUhVTYAWSZ/KkVfPmzZUPFRMnTkw2Gzsk1LF81Qf4pAGKxBOeHTt2zOyxS5cuKTUHE3/oNvWReLIU+H9d3Ze5ceOG2S2M/v7+ShZW4oy81CSeMTpxvULTbZSQUE/TdGtnnz59mDRpkvKB720kPtcuXLhg9lhKNX1XrFihZPTMmjWLoUOH0qRJk2SBPnj5+ZYzZ04lcHr8+HGzQEdUVBTnz58HEjIsk2aXpfWDuEqlUvZfeHh4inVN58+fT1BQEFu3blX2bWrnzpMnT5RbjROf82967qSVaT++zjUL5tcomG/P62SyvUriEgipiYuLUyYQg4RSCCqVivj4eAYNGoRerzebWAzMz8++ffuavRauX7+eo0ePcv36dbNALaR8nsydO1e59tetW8fAgQOpX79+ikEHDw8PIOFLscRZi9HR0clq1mbKlEnJtqxcubLZGHfu3MmePXu4evWqUh4hJU+fPmX79u2cOnUqxf2ZeIyp3TZuGjeQrA7oyZMnX/q8tHoX1z9g9sVJ4vrJibMFU6LRaJIFohK/zprOh+vXr+Pr68uGDRs4d+4cs2bNSsPWvVzi+uO1a9dWfjdth9FoNNuOtFz7pjqnkBBgNd0R4uTk9NqlARLvg6R/B0yYMIEuXbooE2K9i2P4OtdlWFgYp0+fxtfXly+//JIVK1bg6+vLokWLsLS0xGAwKBMOpkXi/QaYXY+5cuUyG1vr1q3NxrZlyxYOHjzI9evX8fHxMesnpXPrVeS9+92/dwshREYjwVohhPgXevbs2Usnwkp6e9nrqFChglIzbPz48Rw4cAA/Pz9mzJhBy5YtKVu2LGPGjAGgYsWKyge7hQsXsnHjRvz9/Vm8eDGbNm1i//79yh/oiT8gmyaTSByISCpx0KRPnz7s378fPz8/Zs+ezcqVK4GE2wZNtza/rkKFCik1FU0zkW/dupW7d+9y/fp1Fi9erNRAex3ly5dXMmZWrFjB7Nmz8fPz48CBA/z4449AwoeRxDUMTR+crl27xtGjR9Hr9ezcuVOZ2flloqKi+P7777lw4QLnzp1TJnYD8w/1qalQoQIuLi5Kf5Dw4TvxrY2JA4EHDhzgxo0bnDhxgt9//11Z/iaZ1ZUqVVLKOMydO5c1a9bg5+fHnDlzUpwZOvE4Nm/ejL+/P9u2bTO7DdaUKfey883e3l4JXF27do1+/fpx5coVzp07R69evZTj/bY1Jnv06KEc1zFjxjBx4kRu3LjB1atXGTt2rDIJiq2tLV27dgUSajya6kju27ePMWPGcP36dU6ePMm3336rZMyldO6EhISwbt06DAYDJ0+eZNWqVW81fhPTfnz48CF+fn5K9lZKGjdurHwo/v3339m2bRt+fn6sXLlSyZ7KkiVLqpPnvA4/Pz8lKFi4cGGzwIjpxzS5DphPNObh4aFMSmP6kG+aWMykYMGCSmB53rx5bN++ndu3b7N69WpatGhBxYoV6d27d5rGmvjcXbt2Lf7+/qxYscJsAjXTuZu4HnHfvn05c+YMFy9e5Icffkjx9cgUtDly5AgzZ87Ez8+PgwcP0qFDB2rVqkX16tWV24dT0rRpUyVoMnPmTKZPn861a9e4desWq1evZvz48UBCGYZq1aq9tB9PT0+l3ub27duZP38+fn5+rFu37o0zXxN7F9c/YDZb/eLFi9HpdNy7d4+JEye+9pgSB8x++uknzp07x5UrVxg8eDBNmzalRIkSZjWIX8X0Hh4QEMCFCxcYMWIEmzdvBqBYsWJmJX8Sb8fChQsxGAxcvXqV2bNnv3I9Q4YMUV7LhwwZorxP16pV67Uza728vJQvbrdu3cqSJUu4c+cOW7ZsYeHChRw5coRr166h1WrfyTF8nevywIEDfPnll/z6668MGDCAixcv8ujRIx49eqQE+14nkLdo0SJWrFiBn58fCxcuVEog5MmTB09PT+zt7ZUs3fXr17Nq1Sru3LnDjh07aNWqFVWrVlXq1r8tee9+P+/dQgiRkchXTUII8S+U2uRRDg4OnD59+o36tba2ZsCAAfz0008EBAQok/6Y5MyZU5mZ187OjmHDhtG3b18iIiLo16+fWdvs2bPz/fffAwkZO9mzZ+fRo0ecO3eOevXq0bZtW3777bcUx1G+fHl69OjBzJkzuXv3Lj169DB73NXVlUmTJr12NkpiP/zwAwaDgfnz53Pnzh369u2bYjt7e3t69eqVpj41Gg2TJk2ia9euhIaGMmHCBLOsF5VKRf/+/c1qBjZs2JCZM2ei1+vp3LkzKpUKo9FI8eLFOXfu3EvX5eLigq+vLy1atDBbXqlSJbMgwqvGW69ePbPsoqTPLVWqFFmyZOH58+f8888/KfadlomgkrK3t2fQoEEMGjSImJgYBg8erDxWpEiRZLUea9euzeLFi5VsqJQyokwf2FI73wYPHqxMUrN582YlGGLy2Wef0blz59fensScnZ2ZM2cO3bt359GjR8ycOZOZM2eatbG2tubPP/80ux12zJgxtGvXjsePHzN//nzmz59v9pyvvvpKmUQOEs4dU9biwIEDGTRoUJrOnbTy8vLC19eXgIAA6tevT9WqVV8aDMqXLx+DBw9m+PDhBAYGKl9OmNjb2/PXX3+91u2+qUmcBdqsWbMU25QuXZoCBQpw8+ZNbt++zT///MOnn34KJGS+mSa3gf9PLGaiUqkYNGgQXbt2JSQkhB9++MHscScnpzS/LtSpU4fdu3cDJHtNMHn27Bm5c+embt26LF++nH/++YdLly7Rpk0bICGL2sPDQ6lpa9KjRw/27dtHQEAAEydONAs6qtVq+vbtm2IGm0n27NkZOnQoAwcORKfTMXnyZCZPnmzWRq1WM2zYsGRZxImpVCr69etH9+7d0ev1jBkzRvliL1++fMpM9W96m/27uv7r1q3LzJkz0el0rF27lnXr1mE0GilQoIBSBzStihQpQps2bVixYgXHjx9PllFeuXLlNN9ir9frX1piwt3dnUmTJpkta9iwoRLsnzJlClOnTlWu/dRK95gyypO+t2fLli3ZOZ4WarWakSNH0qVLF6Kjo5PVuXdwcFAmS3xXxzCt12X9+vXZtm0bBw4cUH4Ss7S0THEyqpfJnDmzWaATEq7LoUOHKuf1zz//zNmzZwkJCVHKh5hYW1vz888/v1WpCRN5734/791CCJGRSGatEEIIMw0aNGDRokVUq1YNJycntFotOXPmpH379qxcudIso6du3bosXbqU6tWr4+TkhKWlJblz5+bLL79k1apVSuafSqVi2LBhFClSBCsrK5ydnZWZs1/mhx9+YMGCBdSsWZMsWbKg1Wpxd3enQ4cObNy40ey26zeh0Wj45ZdfWLduHW3btqVAgQLY29tjZWWFu7s7derUYfjw4Rw6dOi1JkwrWrQoW7du5auvviJPnjxYWlqSKVMmqlWrxqJFi5L11bNnT7755huyZ8+OpaUlXl5ejBkzJlmAOqkCBQqwcOFCihYtilarJVu2bHTv3p0ZM2a8VhA78W2TkPwDn5OTE/Pnz6dSpUo4Ojri4OCAj48PY8eOVbITDx48+EaT+zRv3pxp06bh7e2NpaUlOXLkoFevXowcOTJZ29KlS/PXX39RpEgRbGxscHFxoVKlSixdulTJ8jFNvpTa+ZYpUybWrVvHL7/8QpEiRbC1tcXGxoZixYoxYsQIJk+e/E5quHp6erJ161a+//57ChcujK2trRJwa9WqFVu2bEkWyPHw8GDr1q18++23FChQAGtra+zs7ChbtixTp05l4MCBZu1btGjBgAEDyJ07N5aWlnzyyScMGDCAoUOHvvX4IWEG7ZIlS2Jra0umTJleeftsmzZtWLVqFQ0bNiRr1qxotVrc3Nxo3rw5GzdufOVEU2ml0+nYtGkTkBAsadiw4UvbmmanB8wyjmvUqKFsT+KJxRIrU6YMq1evpl69eri4uKDVasmePTvNmjVj9erVaZq5HRKuseHDh5M/f36srKxwc3Ojdu3aLFy4UAncmM5dtVrNrFmz+Oqrr3B1dcXKyooSJUqwcOFCChcuDJhnn7m4uLBmzRo6dOiAh4cHWq0WZ2dnKlWqxIIFC5Jd3ylp0qQJa9asoUmTJri7u6PVarG2tsbd3Z0mTZqwdu1amjRp8sp+KleuzNy5cylRogRWVla4uLjQuXNnRo8erbRJWr85rd7V9Z8/f35mzJiBj4+PMsb27duzfPnyNxrbb7/9xogRIyhevDh2dnbY2NhQsGBBfv75Z6ZPn/5GXyiqVCrs7Ozw8vKid+/ebNq0iRw5cpi1qVixIuPGjaNgwYLKa+d3333HjBkzUu1brVazatUqateuja2tLY6OjjRs2JBVq1YpmZqvq1SpUqxdu5YGDRoo14m7uzuNGzdm9erVSibsuzqGab0uLSwsmDJlCkOGDKFo0aI4OTlhYWGBq6srn332GStXrnyt16SRI0fSqVMnnJ2dsba2pkyZMixZsoRy5copbfLly8fatWtp1qwZ2bJlQ6vVKutbvny5Wdu3Je/d7+e9WwghMgqV8V3ciyGEEEKID8LT0xNIyD5euHBh+g5GCPFOXb16laCgILJly0aOHDnMJt/q0qULR44cwdXV1SwrOCPQ6/Xs3r2b7Nmzky1bNrPA/tmzZ5Wg+dChQ80C6OLDaN++PadOnUKj0SSrAy9ezpS1DLBs2bJ39oWTEEII8SpSBkEIIYQQQogM4Pjx40r5AB8fH0aMGIGNjQ2+vr5KyQtvb+/0HGKKNBoNAwcOVOpTDh06lIoVKxIcHMy0adOUdkknVxJCCCGEEMlJsFYIIYQQQogMoFGjRsyePZvg4GAuXrxI48aNzR7XarXJ6o1mFB06dFBuw0+pHnm1atUoUqTIhx6WEEIIIcS/jgRrhRBCCCGEyABcXV1Zs2YN06dP59SpUzx9+hSDwUDmzJkpUaIE3bp1M5vxPSP5/vvvyZEjBxs2bODWrVtERkZiZWVFrly5qFevnkz+I4QQQgiRRlKzVgghhBBCCCGEEEIIITKA15+iVAghhBBCCCGEEEIIIcQ7J8FaIYQQQgghhBBCCCGEyACkZm0aGAwG4uPjUavVqFSq9B6OEEIIIYQQQgghhBDiX8JoNGIwGLCwsECtTj13VoK1aRAfH8/FixfTexhCCCGEEEIIIYQQQoh/KR8fHywtLVNtI8HaNDBFvH18fNBoNOk8mvfPaDQSFhaGo6OjZBILITIUeX0SQmRU8vokhMio5PVJCJFRfUyvT3q9nosXL74yqxYkWJsmphNGo9F8NMFatVqNRqP5z18sQoh/F3l9EkJkVPL6JITIqOT1SQiRUX2Mr09p2U6ZYEykyMrKKr2HIIQQQgghhBBCCCHER0UyazMAY3w8xthYjOHhGCIj03s4YDSiMRqJV6ngI/lmQ5hTaTSonZxQ2digksC9EEIIIYQQQgghxAchwdp0ZtTr0QcGEnfkCIagoPQeDgBGEmppaDQaJFT7EdNq0Xp5oS1WDLWNTXqPRgghhBBCCCGEEOI/T8ogpDNjXBw6X98ME6gVQqHTobtwAcPTpxiNxvQejRBCCCGEEEIIIcR/nmTWpjedDv3jx+k9CiFeSv/gAZrs2cHSMr2HIoQQQgghhBAiBfHx8cTFxaX3MIR4LUajkdjYWKKiov7VE4xZWlpiYfHuQqwSrE1ven3Cj8hQ7gUHkytz5vQeRoZg1OnSewhCCCGEEEIIIVJgNBq5d+8egYGB6T0UIT5qLi4u5MqV650EnSVYm85Surm81IQJAKzr1Ik8zs5mjy09fZqJBw/ydfnydK9QgZG7dwMwsHbt9z3Ud6rhnDl8Xb48n3t7v1U/my9dYvbx42zt1o2zDx7Qa/16jvTu/VZ9XnvyhK+WL+fkDz+8VT9pcTcoiFF793L50SNsLS1pVaIEncuWfeXzTvj702v9ejZ16UKOTJkA0BsMTDl8mG1XrhCj0/FprlwMqFULV3t7tl+9qpwrJjq9HpVKxYk+fVJfmdGY8COEEEIIIYQQIkMxBWrd3d2xt7dHrZZql0J8SAaDgYiICAICAggPD8fd3Z3Mb5n8J8HaDMrJxoYtly/Tq3Jls+WbL1/GLtHt6P+2IO37VCJnzrcO1AJExMURbzC8gxGlTqfX02fjRqrnz8+UZs3wCwykz8aNeDg5UdvT86XPC4yM5LedOzEkCaDOO3GCE3fvsuTLL7G3suKP3bsZvmsXfzVrRn0vL+p7eSltn4aH037ZMr6vUuW9bZ8QQgghhBBCiPcnPj5eCdRmy5YtvYcjxEfL3t4egICAAFavXk316tUpWLDgG/cnwdoMqp6XF9uvXOG7SpVQv0ihvvToEfF6PYWyZlXa/bZzJwBD69Zl1rFj+AUGYmlhweHbt7HVaqlfuHCygK/JnefPmXToEDefPSMkOpocjo70rlKFyvny8fvff2MwGhnZoIHSvv+WLTjZ2NC/Vi2uPXnC2H37uPnsGTmdnKhVsCAbLl5ka7duydZjNBpZcOoUq86eJSY+nibe3hgSBUO/XrWKUh4edK9QAYCHoaE0mjuXLV27kiNTJkpNmMD3Vaqw8uxZwmNiKOnhweDatXF9cTGYnL5/n+6rV+Pbty8AV588YeKBA1x98gRbS0ua+PjQo0IFVCoVmy5eZPW5czwKC0On11PSw4PfP/uMyLg4eq9fD0Clv/5i+hdf4JM9OyvPnmXNuXM8j4oiv4sLP1WvjpebGwB7b9xg5rFjPAkPx9XennpeXnQtVw6Akbt38ygsjCnNmyfbL2cePCAwIoJvKlZEq9FQyM2N1iVKsPrcuZcGaw1GI4O3b6eJjw9zT5wwe2zjxYv0qlKFbI6OAPxUvTqfzZzJg5AQcjo5mR2PX3fsoFLevNQvXDjF9QghhBBCCCGEyNhMNWrtk3w2FkJ8eKbr0Gg08vfff2NhYUHevHnfqC/Jj8+gKn3yCTq9npN37yrLNl+6RONXlA3Yd/Mm5XLnZt+33zKodm0WnTrFxYcPU2z78+bN5HdxYVOXLhzs2ZPyefIwes8eABp7e3Pg1i0iYmMBCI+J4dDt2zT28SEiNpZe69fzaa5c7P32W4bVq8f6CxdeOqbNly6x3NeXSU2bsrtHD7QaDU8iIl5rf2y9fJk5rVqxvXt3NCoV/bduTbV9aHQ0361dS2kPD/Z++y1zW7dmy6VLrL9wgUuPHjF23z4G1KrFvu++Y22nTtwPDmbF2bPkdHLir2bNADjSuzdFc+RgzblzLD19mjGNGrHnm2/4vEgRvlmzhueRkcTodPy6Ywf9atbkUK9e/FG/PotOneLyi0njBtaunWKgFsDv+XNyZc6MVqNRluXNkoUbz569dLvmHj+Os41NsvMgPDaWJxER5HdxUZZlsbPD0dqam0n62371KrefP+fHatVS3YdCpLfgmEAehN9J9vMo6l6Ky4NjpE6XEEIIIYT4+Lxp6QNjWASGJ8/T/GMMe73P8UJ8TEzXoYuLC2FhYdy5c+eN+5LM2gzKQqOhnpcXWy5fpnyePMTodOy5cYPVHTtyNJUDnitzZhoWKQJApbx5cbG3525wMD45ciRrO7lZM1zt7DAajTwKC8PB2pqnL4KoJdzdyebgwJ4bN2ji48POa9fIkzkzXm5ubL96FY1aTfcKFVCrVBRwdeWrMmVY/M8/KY5p29WrNC1aVMlE/aZiRTZcvPha+6NHxYq4v6jN+n2VKjRbsICHoaEvbX/o9m2sLCzoVr48KpUKDycnprdogY1WSyZra9Z07EiOTJkIi4nhWUQETjY2PAsPT7Gv1efO0blsWQq4ugLQ2MeHjRcvsv3qVVoUK4aVhQWbLl7EYDBQzN2dg716KdnQqYmKi8NGqzVbZm1hQfRLZvD0vX+f7VevsrRdO8JiYpL1BaTcX6IJwgxGI3NPnKBz2bJm5TSEyGiCYwIZdqInkbqwZI8ZDEbU6uTXmJ3WkSHlppLZ2iXZY0IIIYQQQoj/M4ZFEDd7Dcbo2DQ/R2VjheXXLVA5SiavEC+jUqmwsrIiLCz5Z9m0kszaDOzzRNmte2/epLi7Oy52dqk+J+njFmp1stqmJtefPqXdsmXUmz2b4bt2cfPZM7MJz5r4+LDtyhUAtly+TBMfHwCehIWRzcHBLCCZ80UgNSXPIiLI5uCg/F+jVpP9xa36aZUrUXFm023+gZGRL20fGBGBm4OD2Sx8eZydcXNwQKNWs+LMGWpNn067pUuZf/IkkXFxvKxK7cOwMCYePEjVqVOVnxvPnvEoLAxrrZb5rVtjMBoZtH071adN47cdO5IFU1Nio9USEx9vtiwmPh7bFIKowVFR/LZzJ8Pr18feyirFvkzPT62/0/fuERgRoRxLITKqSF04kbowNCot1hpbsx8rjU2yZRqVlkhdGJG6lL90EUIIIYQQQvyfMTo2IVCrVoOl9tU/avX/n/O+xmQ0sn79etq3b0+5cuXw9vamVq1aDBs2jCdPnry39Sb14MEDPD09OXny5Fv1o9fradmyJZcuXQLA09OT9S/KLqakf//+tG/f/q3WmdTNmzc5cODAO+3zdTx8+JBt27a91nP69++Pp6dnij/ffvttmvp4V8fQ5OLFi3zxxRfEJ4m5vIxKpTIr//m6JLM2Ayvg6koeZ2d2X7/OzmvXaFuy5Dvr+1lEBP23bGF848ZUyZcPSKi9uu/mTaVNwyJFmHH0KCfv3uVWYCB1X0xQld3Rkcfh4RiNRiUY+iiVbwzcHBwISJQFazQaeZaoDIJarUan1yv/D4mOTtbH00S3+JsyarM5OOAfFJTyOh0deZJkjAdu3SIyLo5nERGcuHuXVV99RZYXwe0+GzakOv4eFSrwWaFCyrL7ISE4WVsTERvLs4gI/nhR2/f606cM3LaN+SdP0qdq1Zf2CZAvSxbuBQcTbzBg8SJd/vbz5+RzSZ4VeNzfn6CoKHquWwck7EOA1osX06lMGTqVLUtWe3tuBwYq+ykwMpLQmBiz/vbevEn1AgWSZeAKkVFp1VosNeZfUOjRo0lUPkRZrtclWyaEEEIIIYRIhYUGlfbVoSEjQNz7m4hbr9fz3XffcebMGXr06MGQIUOws7Pj5s2bTJ8+nebNm7Nx40ZcUvi8/K5lz56dI0eOkCmVpLS0mDdvHrlz58b7RRnDI0eO4JAoke1D6N69O02bNqVaOpVB7NevH+7u7jRINB9SWpQoUYIpU6YkW26VQvLah+Dj40PevHmZM2cO33zzzXtfn2TWZnCfFynC8jNnuBscTMU3LEycksi4OPRGI9Yvgna3nz9nzosJq0yB08y2tlTOl4/hu3ZRo0ABHK2tAaiaPz8Go5H5J0+i0+vxDwpi8enTL11XE29v1l+4wIWHD9Hp9cw7edIsK/YTZ2eO+fsTHhNDeGwsC1MopzDn2DECIyMJj4lh4sGDVMiTh6ypvMhV/uQT4g0GZYz3Q0KYsH8/sfHxRMTGYqFWo9VoiDcY2H7lCsf8/ZXttnoRBAp/Ua+3qY8P806c4M7z5wAc8/en5cKFnHnwgGidjt4bNrDj6lWMRiOu9vaoVSqcbGxeeQxK58qFk40NUw4dIjY+nhtPn7Ly7NkU6xLXL1yYY99/z8GePTnYsycrO3QAYGWHDnQqWxaARt7ezD15koDQUCLj4piwfz+lcubEI9HkYucCAijh7v7KsQmRERkxEm+Ix0jKdwsIIYQQQgghwGgwYoyKSf0nJhYMxtf+McbEpt6v4c3+Vl+wYAGHDx9mwYIFdO7cmQIFCpAjRw6qVq3KwoUL0Wq1zJ8//x3vqZRpNBpcXV2xfIvSgeHh4cyaNYsuXbooy1xdXbF+EVcRqdNqtbi6uib7cXzNu7Tfpc6dOzNnzhxCUynJ+a5IZm0GV9fLi0mHDtG2ZEkl+/JdyOPszPdVqjB4+3ZidDrcHBxoWrQokw8e5FZgIAVffFvV1MeHvTdu8NtnnynPtdFqmdikCWP27mX+yZPkzpyZcrlzc+revZduQ0h0NP23biU8JoaaBQsq9V8BOpcty7C//6bR3Lk4WFnRo2JF9t64YdaHl5sbXVauJCQ6msp58/Jz9eqpbp+DtTVTmzfnzwMHWOrri42FBS2KF6dZ0aKERkdzKzCQhnPmYKnRUMjNjZbFiyvjz+/qSnF3d+rOnMmYRo34slQpAH7ctInAiAhc7e35pUYNqubPD8DYRo2YfvQoI3fvxsrCgjqenspzRu7ezaOwsBQnGbNQq5nWvDmj9+6lzsyZ2Gq1tC5Rgs9fBGsfhYXRYuFCpjRrRomcOVPdXoBu5coRr9fTdeVKIuPiKO3hwehGjczaBISGphrkFiKjMBqN6I16YvRRRMVHEKePJc4QBxhRoyaLjRtWGvlDRwghhBBCiMT0N/zR7zuFMSr5HauJGXXxEBEJKhXGNMy5gtEIRiO6lTtSzcRV2dqgqVEGTcE8aR6z0Whk2bJlfP755xR5MQdPYjY2NixduhTXRHGER48eMWHCBI4fP05kZCSlSpXil19+wdPTE4Dnz58zdOhQTp48SXR0NIULF+bHH3+kTJkyAFy4cIHRo0dz9epVLCwsKFeuHAMGDCBHjhw8ePCAmjVrsnjxYsqWLUv79u3x8vIiJCSEXbt24ejoSLt27ejWrZtZ6cXEVq1ahZubG4US3aHr6enJqFGjaNasGUajkRkzZrBy5UrCwsJo0KABsbHmJSZetY39+/dHr9fj4uLCxo0biYqKomLFigwdOhRXV1dq1KhBQEAAU6dO5dSpU0RERFCqVCkGDx4MwJ49e/juu+/4888/lczXsWPHcu7cOZYvX87NmzeZOHEivr6+REZGkj17dtq1a8dXX30FwJQpUzh16hRVqlRhyZIlBAcHU6JECX7//Xfy5s1L+/btOXXqFACnTp1i3759ythTYtrfaREXF8eUKVPYsWMHjx8/xs7OjooVK/Lrr7+SOVEZTZNXnQ9xcXFMnjyZzZs3ExERQYECBejduzeVKlVS+ihUqBBubm6sWrWKr7/+Ok3jfFMSrM2AfPv2VX53srHhRJ8+Zo/PbtVK+X1o3brK790rVEjW19Zu3V66ng6ffkqHTz81W9a2ZEmMJNyCAFA+Tx6z8UBCmQKdXs/iL79Ulq08c4abz569dF2tS5ak9UvKOLja2ycLZjYoXNjs/zUKFuSXmjWTPfdzb28luFnaw8NsrJ5ZszKrZctkz8lkY8Okpk1fOlYbrZZ5rVubLUtpX5lUyZdPKSWR1MDatV+6HgCPzJmZ9sUXKT6W3dGRI717p/hYjkyZkh0XrUZD7ypV6F2lykvX97L+hEhvYbHB3I+4zb0wP+6F++EXcoWw2GBUKjVqlfkXVXqjnsDox7jYZJOArRBCCCGEEInE7z4OsSlPWv0hGKOiid99/LWCtQ8ePODhw4dUSCGmYeKe6A7RiIgI2rRpg4eHBzNmzMDS0pJp06bRrl07Nm3aRI4cOfj999+JjY1l6dKlWFpaMnPmTL799lsOHTqEtbU13bt3p2XLlowZM4awsDCGDBnCwIEDWbhwYYrrX758Oc2bN2fdunVcuHCB33//HeClQbs9e/ZQPZUks9mzZzN37lyGDRtG4cKFWbVqFWvXrlWCh2nZRoAdO3bQqFEjli5dysOHD/npp5+YOHEiI0eOZO3atTRt2pT69evTvXt3lixZwvbt25UxHD9+HJVKxYkTJ5Rg7cGDB2nWrBnR0dF06tSJcuXKsXz5ciwsLFi3bh0jR46kTJkyeL0ok3n27FlsbGyYPXs2kZGR9OvXj6FDh7Jo0SKmTJlCjx49yJYtG0OGDAESSkG8zOuUnRg7dix79+5l9OjR5MyZk5s3b9KvXz9mzJjBwIEDk7VP7XywtbVlwIAB3Lx5k3HjxpEtWzb2799Pjx49mDp1qlkJiWrVqrFv376PL1gbEhLCn3/+yYEDB4iIiMDT05O+fftSunTpFNubdub58+dRq9V8+umn9O/fXzlxAeXbhMQaNWrE+PHj3+u2/FfpDQZ6rFnDhMaNqfjJJzwMDWXN+fPJAqxCCJGSmPho7offfvGTEJwNjTWvPx2nT33iAiNGAqMfk8UmG9YSsBVCCCGEEOJfKzAwEABnZ2ez5T169DCbICpHjhxs27aNzZs3ExwczPr165XnjB8/nlq1arFs2TJ+/vln7t27R8GCBcmVKxdWVlYMGjSIRo0aodFoCA8PJzg4mKxZs5IzZ05UKhWTJk3i+YvShynJmzcvv//+OyqVinz58uHn58fixYtTzK41GAxcunSJNm3apNiX0WhkyZIldOjQgYYNGwIwYMAAs21NyzYC2NvbM2zYMLRaLfny5aNx48YcPHhQ2Z8ajQZbW1ucnJyoXr06U6dO5dGjR2TPnp1jx45Ru3ZtZb0PHjzg1q1b1KpVi+joaDp06EDbtm2xt7cHoGfPnsyaNYvr168rwdr4+HjGjh2L04vyi+3bt2fcuHEAODk5odVqsba2VrYhcXZ0ak6fPk2JEiXMlmXNmpW///4bSKghW6dOHSW47e7uTqVKlbh+/XqK/aV2Pty9e5etW7eydu1afF5Mxt6pUyeuXbvGvHnzzIK1np6eLF68GIPBgPod3v2eVIYL1v744488f/6cP//8E2dnZ5YvX06XLl1Yv349+ZJkLwYHB9OpUyc+/fRTli5dSmxsLGPGjKFr165s2LABKysrIiIiePjwIbNmzTJLp5c6IW8ui50doxs25K9Dh+i/ZQsOVlY09PZ+aeapEOLjpTPoeBx5n3tht7gffpt74bd5Fv1QmSTvbZgCti42bqilBLsQQgghhBBY1C6fpjII74upDMLrMN22HhISYrZ86NChxMTEALBkyRL27dsHwI0bN8iTJ49ZcNfKyoqiRYsqwbqePXvy888/s3v3bkqXLk2lSpWoX78+VlZWWFlZ0bVrV4YPH87UqVOpUKECVapU4bNE5R+TKlOmjFlQtnjx4syZM4fg4OBkQeaQkBB0Ol2y5SbBwcE8e/ZMCQwm7tPPzy/N2wiQO3dutIkmEHdwcECnS3niZW9vb9zc3Dh69CiVK1fm3r17jB8/nmbNmvHo0SMOHjxI/vz5yZ07NwBt27Zl+/btXLt2jbt373L16lUgIRht4uLiogRqX7V+IFkANrE5c+YoiZre3t7JEiwTTzLduHFjjh8/zp9//om/vz9+fn7cvn37pYmeqZ0PV65cAaDDi7mBTHQ6XbIauc7OzsTHxxMSEvLS4/suZKhg7d27dzl69CgrVqyg5Itb5gcNGsShQ4fYunUr33//vVn7PXv2EB0dzejRo5UZ4caNG0fVqlU5c+YM5cuX58aNGxiNRkqWLJmuhYj/a6rlz0+1FzVb37ekt/sLITImg9FAYPRj7oX7cT/Mj3vht3kYeRe9If6N+1SrNFhrbLDUWGGpsSJSF06ULiJRCyOB0U/IZJW8LpEQQgghhBAfG03BPKjz54aY1O9UMzwLQrdwE1hqU61Ba2LUxUOcDm3reqhdUwlSWVuhUqehBm4iHh4euLq6curUKeV2fAA3Nzfl98S3yBuNxhRrxer1eiwsEraldu3aHD58mMOHD3Ps2DHmzp3L5MmTWb16NQUKFOCnn36ibdu2HDx4kOPHj/P7778za9YsNm7cmOIYTf0mHgOYBxCTShzUTEnSBJbE60jLNgKvPQlatWrVOHr0KBqNBm9vb4oUKYK7uzsnT57kwIED1KpVC0jIdm7ZsiWZM2emZs2alC9fHh8fH6pWrWrW3+uu/2X7F8yPt7W1tRI0Tsnvv//O9u3badKkCdWqVeObb75h3rx5PHnyJMX2qZ0PpuOwbNky7OzszJ6XNHvWdEzfZ1YtZLBgbebMmZk9ezbeL2qQAqhUKoxGY4qzrZUvX55p06YpgdrETO2vX7+e7jPGiX+/e8HB5EqhSLUQH7OQ2CDuh/sllDIIu839iNvExr/5N/hWGms8HPKRyzEvVhpbVlybjq2FPZYaK7M2BoOBWEPi9RgJjnmOndb+LbZGCCGEEEKI/waVWgW2qd9NrLK2ArXq/z+v8qKdytoK1Sv6fl0ajYYOHTowbdo02rRpYzYpl8mjR4+U3wsWLMjGjRt5/vw5WbJkASA2NpZLly7RpEkT4uLimDBhAo0bN6Z+/frUr1+f6OhoKlWqxIEDB9BoNCxatIiBAwfSpk0b2rRpg6+vL23btuXatWspZkxevHjR7P9nzpwhZ86cKdZZdXZ2xtLSkuDg4BS319nZmezZs+Pr66sERwEuXbqkZMm+ahvfVM2aNenXrx8ajYZy5coBUK5cOQ4cOMDJkyfp1asXAFu2bCEkJIS///5bGZMpo/dt7pJMLQCbVsHBwaxYsYKJEydSv359Zfnt27extbVN1v5V54OpzMHTp0/NSh5MnDgRlUpFn0TzSAUFBWFpaWmWTfw+ZKhgraOjY7Io/Y4dO7h3757ZDGwmOXPmJGfOnGbLZs2ahZWVFZ++uCX/xo0b2Nra0qtXL86ePYuzszPNmjWjQ4cO7z0S/qZKTZgAwLpOnciT5EVi6enTTDx4kK/Ll09xQrF/q1ITJjCrZUtKe3i8VT+zjh3D9/59ZrdqxfarV1lw8iRrOnZ8qz4P+fkxfv9+Nnft+lb9pMXeGzeYe+IEAaGhOFpb83mRInQtXx51Ct+oxcbHM+XwYfbeuEFkXBx5nJ3pVbkyn+bKxdkHD+i1fr1Z+3iDAZ1ez87u3XG1t+fiw4dMPHiQW4GBZLGzo33p0jQrWvS9b6P4d4rSRfAg4s6LrNmEWrNhcSFv3J9GrSGHXW5yOeTDwzEfHvZ5cbXNrkwm9iD8TrKJxQBUqMhs5UKoLojo+MhEjxiJ0IXhF3KFnA6fvPG4hBBCCCGEEB9e165duXLlCm3btuXrr7+mWrVq2Nvbc+PGDZYuXcrRo0dp/mJi8kaNGjFz5kz69OnDzz//jKWlJdOnTycqKopWrVphaWnJ+fPnOX36NL/++isuLi4cPHiQyMhISpQogZOTE1u3biUmJoavv/4atVrNunXryJQpE3nz5k1WjgESaqj+9ddfNGrUCF9fX5YtW8aAAQNeuj1FixZNNbDarVs3xowZQ968eSldujSbNm3iwoULlCpVKk3bmFZ2dnb4+/sTGBiIi4sL5cqVIzY2lr///pvZs2cDCYmQv/zyCy4uLkpphmzZshEdHc2OHTsoXbo0t2/fZtSoUUBC8PN11h8QEMDjx4/Jli1bmp+XGgcHBxwcHNi7dy9FihQhJiaGpUuXcvnyZYoVK5as/avOhwIFClC9enV+++03hgwZQsGCBdm1axezZs3ijz/+MOvrypUrKa7jXctQwdqkfH19GThwIDVr1qRGjRqvbL948WKWL1/OgAEDlG8ebt68SXh4OPXr16dnz56cPn2a8ePHExoamqyswqsYjcZ3UmcxWb8pLHOysWHL5cv0rFzZbPnmy5exs7TE+JLnfYixvc91ve36jIl+6nl5Uc/L6637DImOxmA0vvd9cfXJE37dsYPRDRtSMW9e7gYF8f369dhYWtIuhborUw4f5nxAAPPbtMHV3p7Nly7RZ8MG1nbqRPGcOTncu7fSNjIujk7Ll1OnUCFc7O15HB7Od+vW0bZUKWa2bMnd4GB6r1uHVqOhYaLazpDouLyHc19kTDqDjocR/sokYPfC/QiMfvxWfbra5iCXQ148HPKSyyE/2ew80Kq1ydqZXmNN/+oMyesd6Q0G7LWOGAx6ovVRCe0xgtHIhluLyWKTjSJZSr7VeIUQ4nWZ/k58H38rCiHE25DXp/+ud3JM4/Vp+6wbr3/7daVCrVYzadIkduzYwbp161i8eDFhYWG4uLhQunRpli5dqiTlOTo6snTpUsaMGUPHF8lZpUqVYsWKFXi8SACbPHkyo0aN4ptvviE8PJy8efMyYcIEpabp3LlzmTBhAi1btkSv11O8eHEWLFiAvb19isHamjVrcvPmTRo3bkzWrFnp37//SycQA6hVqxbrkyRQJfbll19iMBiYMWMGgYGBVK5cmS+++II7d+6keRvTon379owZM4abN2+yefNmrKysqFChAocOHVLKj5YvXx6j0UiNGjWU0gt169bl8uXLjBkzhoiICNzd3WnRogV79+7lwoULqW57Yq1bt6Zfv358/vnnHD9+PNWyEWllYWHB5MmTGT16NI0aNSJTpkyULVuWH3/8kZkzZxIVFZXsOa86HyZOnMjEiRP57bffCA0NxcPDg+HDhytfEJicOHEi2bLUJL5GX+d6VRkz6Cv2nj17+OmnnyhWrBizZs1KdUIwo9HI5MmTmTFjBt27d+fHH39UHtPpdMTGxiqz1wHMnj2bGTNm4Ovrm6bsWr1ez7lz5/jkk0/eaTauVqvFKiaGiNWrzZaXnTSJVsWLs+/WLTZ36aJkVV5+/Jjf//4bF1tbSubMSbfy5YmIjeWvw4fxffCAwIgIHKys+KJYMTqWKcP9kBA6LFvGd5Uq8UWxYkTGxdFh2TJqFCjAdylkKl94+JCZx45xNziYsJgY8mbJwk/Vq+OTPTvd16yhWI4cfFuxotK+84oVVC9QgPalS3Pq3j2mHD7Mg9BQ8mfJQrEcObj8+DEzWrRItp54vZ6pR46w/epVVCoV7UqVYuqRI0xv3pxSHh40mTePruXKKUFD3/v3+XbdOk726cPD0FCaLlhA32rVWHDqFLHx8VTOm5efq1fH3sqKOcePc+bBA2a0aMHWy5eZe+IEG7t0AeDk3bvMPHaMO0FBONnY8GXJkrQoXjxhJsbTp9l57RpPwsNRqVRUyJOHgbVrc/nRI/ps3IhOr8daq2XNV1/hZGPD/FOn2Hn1KhGxsRTJnp2+1arh8SINft358yw7c4bQ6GiyOTrSsnhxGr8o7dFnwwayOTrSv2bNZPtl382bXHj4kD6JsssnHTzIg9BQxn/+ebL2o/bsoWq+fFT45P9ZhLVnzGBQ7drJ6gkP+/tvnkVGMqVZMwDWX7jAUl9f1nfqpLRZ/M8/HLh1i/lJXnS1np5YlitH5Gt8eyb+PQxGA4ExjwmIukNA5F0Covx5Gv0AgzH1+kqpcdA64W6XB3fbPOSwy0MO29xYa2xeq4/QuCAmXOxHVHxEkkeMGIxG5XUxKj6SOENCPS61SoObtTuWGitafNKNQk7F33gbhBDidRmNRqKiorC1tU2xxpwQQqQXeX3674qNjeXBgwd4eXmlePt3aoxhEcTNXoMxOvXatompbKyw/LoFKsePq/xY+/btcXd3Z/To0Wl+TmhoKDVq1GDhwoXJJhIT/04XLlygU6dO7Nu3L8XyF1FRUVy9epUbN27g7+9Prly5zGowGwwG7ty5Q/HixV8ZtM6QmbVLly7ljz/+oHbt2owfPz7VgsU6nY4BAwawdetWfvnlF7q8CMyZaLVas5nxIKH2R1RUFKGhocqsg2nh6Oj4Tr4FSMwQF5din5Xz5WPX9ev4PnhAuTx5ANh65QqNvb05eucOKrUajUbDjGPHeBQWxpIvv8Teyop9N2/Sb8sW6hQqRJ4sWfilZk3G7N1Lxbx5mXH0KK729nxXuTKaJEHnGJ2OnzZvpnuFCnxRvDhRsbH8sXs3U48cYW7r1jQtWpTpR47wXeXKqFUq/J8/5/qzZ/zZtClPIiL4afNm+lavzufe3lx8+JAfNm6koKtrits258QJjvr7s+jLL8liZ8eoPXsAUGs0Ce1VKtQvts+0HBLq2JiW7b91i1VffYXeaOSnTZsYf+AAw+vXR6VWg0qFRqNJCKy/+P1uUBA/bd5Mv5o1aVCkCDefPaPH6tXkzpKFiNhYVp47x5xWrciVOTP+z5/TZeVKdt+4QRMfHwbUqsXs48fZ0q0bAJMPHuTUvXvMaNkSFzs7Fv/zD99v2MDqjh15FhHBpEOHWN6hA3mcnTnu789PmzZRJV8+XOztmfLFFy89F2oXKkTtRLV5YnQ6jvr7U8/LK8X9ODjJTJX/3LtHRFwchbJlM2t/9sED9ty8ydpOnZTlRsBaqzVrp9Fo8A8OTrYu9Yt9mNKLkfh3MRqNBMcG8iD8TkKd2XA/AiL8idXHmLVTqVVoSNtrnY2FLTlNGbP2+cjpkPedTPaViUz8XmE6kbpw820AIsLDsXdwQEVCRu1O/zVcCjyNWqXBQp3wtrb+3jza2fXEx+X1ZqIVQog3Zcp/yJQpkwRDhBAZirw+/XellEGYVipHeyy/bvHawdqPLVD7pjJlykSXLl1YuHAhE16UuhT/bgsXLqRz586vjI1YWlpiaWmJtbW1WVu9Pu3Z6RkuWLt8+XKGDx9O+/btGThw4CszWX/55Rd2797NhAkTzCLWkBC1rlWrFi1atOCbb75Rll+8eBEXF5fXCtRCwmRn7+PNLaUetRoN9by82HL5MuXz5CFGp2PvjRus7tiRY3fuoHrxvO4VKqBRqbC3suJpeDhWL2YFDIyMJFfmzDQqUoRTd+/yzZo1xOh0LG/fHosU9qmlRsPCtm3xcHIiJj6eR2FhZLKx4cqTJ6iAWgUKMH7fPnzv3aNM7txsuXyZSnnz4mJnx7wTJyjo6krzF/VOS+bMSTMfHy4/fpzitm2/coVOZcsqmai/VK/OjitXlG1Kul8S/2v6vW+1aji/+OawR4UK/LhxI0Pq1FHaJO1n17VrFMqalSYvvtEq7ObGvNatcbGzw9LCgmI5cuDm4EBwVBQh0dE42djwLCIiWT9Go5G1588z9vPPyfnioutWrhwbLlzg6O3bFM6WDSOw/vx5ahYsSJlcuTjSu3eKNWdTExkXxy+bN2NtYcGXpUqluB8Tu/jwIf23bOHr8uWVcZnMPn6cL4oVI0eiSfYqfvIJkw8dYvXZszQrWpS7wcGsO3+e2Pj4ZOtS9qn8YfevE6kLV0oZJARnbxMRl3yyxrSyUGtxt8+Nh0O+hInAHPKSxcYtxdqy74KzjSvONq5my4xGI6GGUDI5/P/DRlefX1h7Yx6nHh9Q2hmMBpZcncqXhb6jeNZy72V8QgiRlOlvRXnPFEJkNPL69N/0tsdT5Wgvwdf3qFu3brRp04YLFy5QVOaH+Ve7cOEC/v7+jBkz5rWel/gafZ3rNUMFa+/cucNmd6dhAAEAAElEQVTIkSOpXbs23bt35/nz58pj1tbW2NraEhQUhIODA9bW1qxfv57t27fzyy+/UKZMGZ49e6a0N7X57LPPmDt3Lnny5KFIkSIcP36cuXPnMmjQoPTYxNfyubc3Xy1fTkRsLAf9/Cju7o6LnZ1Zm6CoKMbv38+1J0/IkSkThd3cADAkqm7RqkQJtl+9SoPChcnq4JDiujRqNafv36fX+vVEx8XxSZYsaDUapR9rrZZ6Xl5svXKFUh4ebL96lUG1awPwJDzcLBAI4O7kxOXHKde4fBoRQbZE7R2srXFMpcxFSnIlCrRnc3AgTq8nNCbmpe0DIyPJnmSMBVwTgkDhsbFMO3KEw7dvk9nGBs+sWYnT61OsJxIcHU20Tkf/LVvMLjSdXs/DsDBqFizI7JYtWfTPP/TZsAGD0UijIkXoXaWKEkh/Ff+gIH7ZvBlnOztmtWyJXSqZ5QAbLlxgwoED9KhQIVlt2/shIfjev8+QOnXMlud0cmJS06ZMPXyYmceOUdDVlSY+Pqw4cyZNYxQZT5w+loCIu0rG7P3w2zyPfvLG/alUKrLaupPLIV/CJGAOeclmlxOLFOrMpje1Ss0XBbugVqk58WifstxoNLDs2jTASPGs5dNvgEIIIYQQQoh/rSVLlrzR87RaLWvXrn3HoxHpoWjRoqnWIH7XMlSw9u+//0an07F79252795t9ljTpk3p2bMnNWvWZNSoUTRr1oytW7cCMHbsWMaOHWvW3tSmb9++ODo6MmHCBB4/fkzOnDkZNGgQLVu2/GDb9aYKuLqSx9mZ3devs/PaNdqWTD5hTr8tW6iaLx9TmzfHQq0mJDqaDRcvKo/r9HpG7t5N3UKF2HvjBnU8PamUN2+yfi4+esTYfftY0KYNhdzc0Ov1rDh7Fv+gIKVNUx8fuqxcSY0CBVABFV6UZ8jm6MhhPz+z/h6Fhb10u9wcHAhIVLA7WqcjIvb/t16oVSriDf+vlxkSHZ2sj6cREeRxdgbgYVgY1hYWONm8vCamm4MDtwIDzZZtvnSJzLa2HL59m8fh4Wzp2hV7KysAWi5alGI/TjY2WFlYMK15c3xy5FCW+wcFkdXenqCoKPQGAxMaN8ZgNHI+IIBftmwhd+bMtCxR4qXjMzly+zYDt22jqY8PvapUSTEL2kRvMDB671723bzJhMaNKZs7d7I2+27coFiOHORIkm0bFReHg5UVi7/8Uln216FDeL0I9ouMTW/U8yQywCww+yjyPsa3qDOb2drlRcZsXnI55COnfR6sLF6vzuy7ZgyLSHZbltFoRBURgSEmPtk3k03dWqBSqTn+cE+i9gaWXZuO3miglFtFhBBCCCGEEEKIjCxDBWt79OhBjx49Um1z/fp15ff58+e/sk8LCwu++eYbszII/yafFynC8jNnCI+NpWIKQdaI2FisLCzQqFQER0Uxbv9+ICFICwkBuHijkd8++wzv7Nn5fedOVn71VbIM3YjYWNQqlZL9efHRI1acOYM+UdC0YNas5HF2Zvz+/TQqUkSpe9ugcGHmnjjB1suXqeflxZUnT9hw4QL5XVxS3KYmPj4s/ucfSnt4kCNTJiYeOIA+URbrJ1mycODWLep7eRERF5ditueUw4cZWrcu0TodM48epUGRImhTqSdcp1Ah5p08qYzxxrNn/HngAKMaNkzYhxoNGrWa2Ph4Vp87h19gIFVe7G8rCwtidDriDQYs1Goae3sz5fBhhtevj6u9PduuXGH433+z+MsvMRiNfLduHZOaNqVMrly4vpjYLrVAssnFhw/5afNmBtSsSeM0FCCfcOAAR+/cYWm7dsmyhk3OBQRQMmfOZMvDY2PptGIFk5o0oUzu3Pxz7x7rLlxgdMOGr1yv+LCMRiNBMc/MArMPIvzR6dNeWyopG60duR3y4/Gi1qyHQz4cLDNWTeLUJjzQGgzoUvgiQ2VjRdNuX6BGxdGH///Cz2g0sPL6DIwYKO1W+b2OWwghhBBCCCGEeBsZKlgrkqvr5cWkQ4doW7JkilmWv9Wty4T9+1l6+jQO1tZ85umJZ9as3AoMxGg0sub8eRa2aYOlhQWtS5TgwK1b/LZjB1ObNzfLSiuXOzdfFCtG15UrMRiN5HB0pHWJEkw9fJjnkZFkeRHcbVq0KCN37+Zzb2/luW4ODoz7/HMmHTzI6L178cyalfJ58hCcQkYsQMcyZYiJj6fbqlXEGww0K1qUTInKIPSuXJlRe/ZQZ+ZMXO3taVuyJOcCAsz68HByouWiRcTodNT18uL7KlVS3Y8eTk5MbtqUKYcPM3bfPpxtbfmxWjXK58mDh5MTQ//+m9ozZmCr1VI8Z04aFC6sZOKWzJkTZ1tbqk2dyoI2behTtSqzjh2j68qVhMbE4J4pE2M//5xCL7JS+9Wowag9e3gWEYGDlRUtihWjtqcnAL3WrSO7oyMDX5SQSGz+yZPE6/WM279fCboDlHB3Z0rz5px98IBe69ezpmNHrC0sWHPuHGqVihYLF5r1M7B2bep7eQEQEBpKhU8+SbYuNwcHRjZowLj9+5UyFoNq1aL8i2xpkX7C40ITArLht7n3IkAbpYt44/60akvcHfLg4ZCP3A4JE4Blsc6a4euVGaNjEwK1ajVYJPkixqAHdZJl8fqE9jFxNMn/FWqVhsMBO//fn9HIquuzMBgNlMlW9QNsgRBCCCGEEEII8fpUxpQKcwozer2ec+fOUbx4cTSpZG++Ud/BwUSvWfNO+3xbRhK2WaPRvHJiK4DHYWGEREcrwUqAPw8c4HlkJH8kmfTtbT0MDaXR3Lls6do12a394v2wKFAAqwoVUL0oESHendj4aB5E+CuTfz0Iv01QzLNXP/ElVCo12e08zDJms9nlRKN6t69bH4LhyXPiZq8BSy0qrfn3iqbXp8SMuniI02H5dQvUblkwGo1sub2MQw92mLVTqVR8UaArZbNXe9+bIIT4yBiNRkJDQ2W2dSFEhiOvT/9dUVFRXL16FS8vL2xfTMAthEgfpuvR398ff39/8uTJQ/PmzZXHXye2KJm14q2FREfTZeVK5rZujZebGzefPWPH1av0rVYtvYcmRIahN8TzOOoB98JM5Qz8eBL18K3qzDrbZCXXi6BsLod85LDPjZXm9Sbr+1cxAjodqIBXvLmpVCoa5f0StUrDgftb/9+F0ciaG3MwGPWUz1Hz/Y5XCCGEEEIIIYR4TRKsFW+tkJsbP1WvzoCtWwl8UTKhU5ky1H1xK74QHxuj0Uhg9GPuR9zmflhCOYOACH/iDbo37tNe64iH4/8Dsx4OebHTOrzDUWdwcTqMoRFgMKACjFaWqOxsQPvytzGVSkWDT1qjVqnYd2+L2WPrbs7HgIGKOZKXJBFCCCGEEOJjEBwTSKQuPM3t7bQOZLZOeW4aIcS7I8Fa8U40LVqUpkWLvvf15MiUCd++fd/7eoR4HWFxIQmlDMISJgC7H3GbaF3kG/dnqbEip8MnZoHZzFYuH+dta0YwhkdCVIz58tg4jLFxCWUSbG1AnfK+UalU1MvTCjUa9tzbaPbYhpsLwWikonud9zN2IYQQQgghMqjgmECGnehJpC4szc+x0zoypNzU9xawNRqNbNiwgQ0bNnDz5k0iIiLIli0bVapUoXv37rglKr34Pj148ICaNWuyePFiypYt+8b96PV62rRpw5AhQ/D29sbT05NRo0bRrFmzFNv379+fgIAAlixZ8sbrTOrmzZsEBARQLZ3ufH748CFnz56lQRpLZE6ZMoWpU6em2mbv3r3kTGEi9bdlMBho0aIFv//+Oz5pmPT9fZJgrRBCvIaY+GgeRNx5EZhNCM6GxD5/4/7UKo1SZzaXY348HPLiZuuOWpV8QsGPjl4PUdFgSKW0epwOY5wuIVhrYYFRr0/WRKVS8VmeL1Cr1Oy6u97ssQ23FmEwGqics+67Hr0QQgghhBAZVqQunEhdGBqVFq1a+8r2OoOOSF0Ykbrw9xKs1ev1fPfdd5w5c4YePXowZMgQ7OzsuHnzJtOnT6d58+Zs3LgRF5f3n9mbPXt2jhw5Qqa3nCdn3rx55M6dG+8XE7QfOXIEB4cPe3dk9+7dadq0aboFa/v164e7u3uag7WdO3emdevWyv+/+OIL6tevT+fOnZVlzs7O73ycAGq1mp9++okBAwawfv16LC0t38t60kKCtRnU1SdPWHDyJL4PHhAbH08WOzuq5ctH57JlyWRj88HHc/r+fbqvXo1v374ZfpIvvcFAvy1bKODqSvcKFV7a7vT9+0w9fJg7QUHYarVUL1CAXpUrY6PVYjAamXP8OJsuXiQsNpYcmTLRtVw56nh6Jutnw4ULjNi9WzJ+/4PiDToeRd5PqDEbljAJ2LPoh7zNvIwuNtnI5ZgPD/uEScDc7fOg1aTfm0BGZDQY0V+4DpExCfVp05JRrDdAfCzxa3dD+WKoixZEZfX//apSqaiTpzmoVOzyX2f21E1+SzBgoGrO+u94S4QQQgghhMjYtGotlpq0TSat1795WbdXWbBgAYcPH2b16tUUKVJEWZ4jRw7KlClD/fr1mT9/Pr/88st7G4OJRqPB1dX1rfoIDw9n1qxZLFu2TFn2tn1+DOzs7LCzs1P+r9FosLW1/WD7rnz58mi1WjZt2kSLFi0+yDpT8tbB2iVLllCsWDGKfoBb4D8Wh/z86L91K1+WKsXPNWrgYmeHf1AQ044coc2SJSxq2xZXe/v0HmaG9CgsjBG7dnHi7l0KpHIxPw0P54cNG/ihWjUae3vzLCKCnzdvZsqhQ/xSsyarz55l25UrzGrVCg8nJw75+dF30ya83NzwcHJS+vELDOTPAwfe/4aJ985gNCTUmQ2/zb2wW9wLv83DyLvoDfFv3Ke9ZSZyOeQzC87aauXaTY0xNJz4HUfQ331IwoxiiQK1KhXY22I0GFDFxCYEaJM+PzqG+MO+cPICmqIF0ZTwQuXw/zf7OrmboVap2Xlnjdnztvgtw2A0UN2j4XvaMiGEEEIIIT4Mg9FAlC4i1TZRuggMRiMGowGDMfndaSn1aTAaidJFEBH38tIJtlr7175L0Gg0smzZMj7//HOzQK2JjY0NS5cuNQvYPXr0iAkTJnD8+HEiIyMpVaoUv/zyC54vEqyeP3/O0KFDOXnyJNHR0RQuXJgff/yRMmXKAHDhwgVGjx7N1atXsbCwoFy5cgwYMIAcOXIkK4PQvn17vLy8CAkJYdeuXTg6OtKuXTu6dev20lJ1q1atws3NjUKFCinLEpdBMBqNzJgxg5UrVxIWFkaDBg2IjY016+NV29i/f3/0ej0uLi5s3LiRqKgoKlasyNChQ3F1daVGjRoEBAQwdepUTp06RUREBKVKlWLw4MEA7Nmzh++++44///xTyXwdO3Ys586dY/ny5dy8eZOJEyfi6+tLZGQk2bNnp127dnz11VdAQsmCU6dOUaVKFZYsWUJwcDAlSpTg999/J2/evLRv355Tp04BcOrUKfbt26eMPSVpLTtx8uRJOnTowE8//cTcuXPJkSMHkydPpnbt2sn6SFp6Yv/+/UyZMoVbt27h5uZGgwYN+Pbbb82yaOvVq8e8efP+3cHav/76i5iYGA4dOkTmzJnfxZg+anHx8YzYtYvOZcvStVw5ZfknWbIw9vPP6bpyJRP272dkw4Y0njuXTmXL0uxFoFxvMNBgzhz6VqtGbU9PTt69y7QjR7gbHPw/9u47PI7qXPz498zsqjfLli2rFxcVW5Z7N800gyEhkAAJEG5oyY8kN/eG0FJIJSSB9FDCJQQMCYSegOnNHSwX2SouKlZ1k9X7zpzfH2sLy7uyJKtL7+d58sTMnJ15V9KenXnnnPcwMSiIGxcuZNXxRb9+9OabNLe3U3D0KDXNzTx57bUca2zkLxs2UHzsGHUtLSRPmMCd557LzKioXr2HjwsK+NuWLZTW1NDU3k56ZCQ/uOACYsLCuo35rfx8Ht24kaqmJmZOnkxkcDDtts2PL7qI7WVlfPOll/jXV7/K5JAQj/MeOHaMG//xD76YmUlz++mf+JXX1rIiObkjjsiQEFalpfHq7t0AfHH2bC6fORN/p5M2l4ua5mb8nU78HJ99ZJrb27n79de5Zs4c/m/Lll79jMTQq2k9dryMQQGl9UWU1BfQ6mo+4+P5mn7EBCd11JiNC04m1Dd8bNaZPQNaa+zcAlwffAJtXj6/TgcqNAhMEywLFRgAra3oxmZwebm4bGvH2pqDtS0PIyURc146xgT3d9TKuM9hYPJG0T87veT1wn9ga4vz4i4fiLcohBBCCCHEgNt5ZAsv7/87DW21p23XZrVS21pFnTJ6lFy1tY3WNn/a8ePTjsQN8gnl81NuYFZEz2u9lpWVUVFRwZLTzIyNjo7u+HdDQwPXXHMNsbGxPPzww/j4+PDnP/+Zr3zlK7z66qtERUVx33330draypo1a/Dx8eGRRx7hG9/4Bh9//DF+fn7ceuutfPGLX+SBBx6grq6OH/7wh9xzzz08+eSTXs//7LPP8oUvfIEXX3yR7Oxs7rvvPgBuueUWr+3fffddzjnnnC7fz2OPPcbjjz/OT37yE9LS0njuued44YUXOpLJPXmPAGvXrmX16tWsWbOGiooKvvvd7/Lb3/6WX/ziF7zwwgt8/vOfZ9WqVdx66608/fTTvPHGGx0xbNq0CaUUmzdv7kjWfvTRR1xxxRU0Nzdz4403smjRIp599lkcDgcvvvgiv/jFL1iwYAGpx3NL27dvx9/fn8cee4zGxkbuvPNOfvzjH/P3v/+dP/7xj9x2221ERkbywx/+EHCXguhKb8tOfPjhhzz33HM0NzdjGN3/DX/88cd8+9vf5u6772bp0qWUlJTw05/+lKKiIn7/+993tDvnnHN48MEHKSoqIjExsVcx9Zc+J2sjIyMpLy/vNExZnLnsykqqmpq4JC3NY5+hFJfPmMEv3n0XW2sumzGD/+TkdCQcNx84QJvLxdlTprD38GG+88or/GzVKs5KTmZ3ZSX/8+qrhPn7syQhAYBNRUX87dprmRQUhNM0ueGZZ7htyRK+kJlJU2srP3/nHX738cf830n1QrpzqL6eO//9bx5YvZoVycnUNDfz3Vdf5a+bNvHTVatOG3N2RQU/evNNfrV6NUsSEztGGF98vBOYHRPD+m99q8tzTwgK4tWbbiLY15dtZWWnjXN2TAyzTypIbWvNB/v2kTpxYsfP2t/pZFNxMd966SW01vzPOed0GtH8wHvvsTwpiQXx8ZKsHeaaXY3HE7L7Ka1zLwBW11p9xsczDZOowHhiT0rMRgRMljqzZ0g3t+J6dxP2vgPeGwT6o4ICOm9TgJ8vys/XXbe2vtF7kte2sXMLsHMLMBJjMOeno6IncW7cagyl+E/hPzo1X1v0PFprVsZ/rl/emxBCCCGEEIPpX3sfp8XVNGTnb2ir5V97H+9Vsvbo0aOAZy3S2267jS0n3WtHRUXx+uuv89prr1FdXc1LL73U8Zrf/OY3rFy5kmeeeYY77riDkpISpk2bRlxcHL6+vtx7772sXr0a0zSpr6+nurqaiRMnEhMTg1KK3/3ud1RVdb0WSVJSEvfddx9KKZKTkykoKOCpp57yOrrWtm12797NNddc4/VYWmuefvpprr/+ei691D2z7+677+70XnvyHgGCgoL4yU9+gtPpJDk5mcsvv5yPPvqo4+d5ooxAWFgY55xzDn/605+orKxk8uTJbNy4kfPPP7/jvGVlZezfv5+VK1fS3NzM9ddfz7XXXkvQ8TzI7bffzqOPPsqePXs6krUul4tf/epXhB2fgXzdddfx61//GoCwsDCcTid+fn4d76E/yxn813/9FwnH81tl3eSAAB555BGuvPLKjt9LXFwcP/7xj7nhhhsoKyvrWLQsKSkJp9PJzp07R26y9oYbbuDHP/4xV111FatWrSIiIgI/P79ObVatkjqAPXWkwT1VYUIXye+IoCBctk1NczOXz5jBXzdtorSmhtiwMP69ezeXpKXhNE1ezM7m7ORkzp06FYBZ0dF8fuZMnt++vSNZO3PyZKYcL85t2TZPXnstsWFhtLhcVNbVEervT+6hQ72KPzwggOe/+lViw8JobGvjUH09Yf7+HD7+vk4X86u7d3PulCmsSE4G4NypUzlnypQenzvwDIs/t1sWP3vnHcpqa/n5KUWv58bEsOm//5ttpaX876uvMiEggAtSUngjN5eiY8f4/gUXsKO8/IzOKwZGu91ORcMBSuvdNWZL6vZztPlgn445MSCqIykbG5zM5KC4HhXhF92zi8txvbUR3ejlgtIwINAffH3Q7SeVo7At9MmLjikFAf7gdGAkRKMrDoOXusJ2URl2URkqcgLmvBmcNeUSDGXyWsGaTu3eLP4XtrbcNW6FEEIIIYQQA+rELO2amppO23/84x/T0tICuEtwvv/++wDs3buXhISETsldX19fMjIy2LNnD+BOLN5xxx288847zJs3j2XLlrFq1Sp8fX3x9fXlpptu4qc//Sl/+tOfWLJkCStWrODCCy/sMsYFCxZ0SspmZmby17/+lerqao8kc01NDe3t7V0uhFVdXc2RI0eYOXNmp+2ZmZkUFBT0+D0CxMfH43R+dm8aHBxMexczjWfMmMGkSZPYsGEDy5cvp6SkhN/85jdcccUVVFZW8tFHHzFlyhTi4+MBuPbaa3njjTfIz8/nwIED5OXlAe5k9AkTJkzoSNR2d36A2bNnd7nvr3/9K/Pmzety/6lOJGp7Kjc3l+zsbF5++eWObSfWoykoKOhI1pqmSWhoaMdDhKHQ52Tt97//fZRS7N27l71793rsV0pJsrYXTiRpK+vqiPNSVqK8thaHYRDm74/DMFicmMjrOTl8ee5cPi4s5Okvf7nj9Z+WlHDWn/7U8Vrbtok56UM04aRRoqZhsLW0lG++9BLNbW0kjh+P0zSxe7mQksMweCs/nxd37kQBUyIiaGhtxXF8SPrE4OAuYz5UX8/04yNbT4gODaWqaeCeCh5paODu//yHxrY2nrj6ao9awD7Hyx4siI9nVVoab+bnM23iRP64bh2PX311x/sSQ8PWNoebKtwLgNUXUlpfQGVjCZbdfc2lroT6hnckZmOC3XVm/R0B3b9Q9Ip2ubA+zsLake91v5mahL2nGN3S6jli1rbB8KxXq4ICcF68DGyNlZWLlbPPa4kEffAorv98iAoLZuncdFTil3m16JlObd4+8BI2mgvjvyClLIQQQgghxIhx1bSbelQGYaCcKIPQG7GxsURERPDJJ590TMcHmDRpUse/T54ir7X2eo1uWRaO4/fw559/PuvWrWPdunVs3LiRxx9/nN///vc8//zzTJ06le9+97tce+21fPTRR2zatIn77ruPRx99lFdeecVrjA5H5/TZiSSfaZpdvq+Tk5renLpw9cnn6Ml7BDrVWu2Js88+mw0bNmCaJjNmzCA9PZ3o6Gi2bNnChx9+yMqVKwH3aOcvfvGLjBs3jvPOO4/Fixczc+ZMzjrrrE7H6+35u/r5Quffd0/4+nqW4zj5Z3pq0ti2bW666SY+//nPe7zu1BG/lmWd9nc70PqcrAXPP7Ce7hOeMqOjGR8YyCu7dvGtFSs67bNsm3/n5HBWcnJHkvBzM2bw+48/JiIoiKkRESQfHyk7MSiI1enp3HP++R2vPzFq94STP/i7Kiv51fvv87drriFl0iQsy+If27dTfOxYr+J/Z88entu+nSeuvprY48nmX733HvtPeiLRVcyTQ0KorOtcqPxgXR1OR7/8mXrIOXiQ77zyCgvi4rj3/PPxP+lp1IlFw/7n7LM7trVbFiF+fry3dy91LS1c+/TTgPv3AnDWn/7EXeed11G2QfQvrTU1rVUdI2ZL6wsoqy+i1Wo542P6OQI6jZiNDU4i1Fdqbw80+1AVrjfXo6tqPPYpf1/MlYsxp8aj6xrQzZ2L7GutaWhoICgoyOPiRfn7okLcD1wc5y3EXDwLa2c+9o58j+MA6Jp6XO9tZmGAH3r62bzGB2B8dsx3D7yM1jYXJVwlCVshhBBCCDEizIpYyMwJ87tdYKyi4QC/2vo9/Ex/fMzuE25tVhstVjO3Z/6IqKD4LtudyQJjpmly/fXX8+c//5lrrrmm06JcJ1RWVnb8e9q0abzyyitUVVUxfvx4AFpbW9m9ezef+9znaGtr48EHH+Tyyy9n1apVrFq1iubmZpYtW8aHH36IaZr8/e9/55577uGaa67hmmuuISsri2uvvZb8/HyvI2J37drV6b+3bdtGTEyM1zqr4eHh+Pj4UF3tvfReeHg4kydPJisrqyM5CrB79+6OUbLdvcczdd5553HnnXdimiaLjq+TtGjRIj788EO2bNnCN7/5TQD+/e9/U1NTw1tvvdUR04kRvX3J850YtdvfTsTYcFLeq6SkpFObqVOnUlhY2CmGTz75hL///e/cd999BAS4B2lZlkVdXV2/lmzorT5nwfLzvY+KEmfGaZrcd9FF3PHqqzgMg6syMxkfGEjxsWP8ad06DtXX86vVqzvaL09O5pfvvcffPvmEr5204t3lM2fy/154gXOmTmVhfDxlNTV866WXWJGc3CkBeUJDayuGUvgeT4zuqqzkH9u2dSQie6qhra3jOFprNhUX85/cXJKPdy6ni/nzM2dy03PPsbG4mIVxcWw+cID39+/nQi8ddV+V1dTwjRde4OrZs/n60qUe++fExHDv669z9pQpZEZHs76wkLfy8/nLlVcyKzqar520+NvW0lJuff55Prr99n6Pcyxram/oNGK2pL6wT0+HHYaT6KD4jkXA4oKTGe8/SerMDiJta6ytu7E27nCPjj2FkRCN44IlHfVpVUhQR/K14xhao/0cGKGh3SZQVYAfjsWZ6Lnp2LkFWFk56FrPi1bd1MLC7T4QOpVXJ+1EBfiD6f67eK/kVWxtsyrxS5KwFUIIIYQQI4KhDIJ8PBflPpk7qaowlIGhuh9B6G6nCHAGdXvsM3HTTTeRm5vLtddeyy233MLZZ59NUFAQe/fuZc2aNWzYsIEvfMFdpmz16tU88sgj/Pd//zd33HEHPj4+/OUvf6GpqYkvfelL+Pj4sHPnTrZu3coPfvADJkyYwEcffURjYyOzZ88mLCyM//znP7S0tHDLLbdgGAYvvvgioaGhJCUleZRjANi6dSt/+MMfWL16NVlZWTzzzDPcfffdXb6fjIyM0yZWb775Zh544AGSkpKYN28er776KtnZ2cydO7dH77GnAgMDKS4u5ujRo0yYMIFFixbR2trKW2+9xWOPPQbA4sWL+d73vseECRM6SjNERkbS3NzM2rVrmTdvHoWFhdx///0AtLW19er85eXlHDx4kMjIyB6/rrcmTpxIbGwsf/vb30hISKC5uZn777+/08jfm2++mf/+7//mj3/8I5deeikHDx7k+9//PlFRUZ0Ss/n5+ViWxaxZswYs3u7065DF0tJSqqqqiIiI6LRSn+idJQkJ/O2aa/jbJ5/w5TVraGxtZXxgIGdPmcIPLriAcQGfTcl2GAar09P55/btXHBSUnPm5Mn8/JJL+PP69dz573/j73RyYUoK31y+3Os5F8XHc+WsWdz0z39ia01USAhXz57Nn9ato6qxscexX5qWxo7ycq76+98xlSIhPJxr58zh+R07aLcsnKbZZcxpkZHcvXIlv3z3XWqam8mMjmZBXBzO46OIt5eV8c2XXuJfX/0qk0N6/+XwzRdfZHJICPecfz7PbttGQ2srz2Rl8UxWVkebySEh/OurX+XsKVP43rnn8tO336aqsZH4ceP49eWXM0v+rgdEm9VKeUedWXeCtqq5d/WST6aUYmJA9PERs+5SBpMDY3FIndkho2vrcb25Abvcy+/VYeJYMQ9j1vQBSYgqHydmZgpGxjTsfQewPs1BH/ZcPGBhbRLKZfPKuE/di5cF+oHDwQel/8bG5tLEayRhK4QQQgghxAAwDIPf/e53rF27lhdffJGnnnqKuro6JkyYwLx581izZg3z588HICQkhDVr1vDAAw/w1a9+FYC5c+fyj3/8g9jYWAB+//vfc//99/P1r3+d+vp6kpKSePDBBztqoj7++OM8+OCDfPGLX8SyLDIzM/nb3/5GUFCQ12Tteeedx759+7j88suZOHEid911V5cLiAGsXLmSl156qcv9X/7yl7Ftm4cffpijR4+yfPlyrrzySoqKinr8Hnviuuuu44EHHmDfvn289tpr+Pr6smTJEj7++GPmzJkDuJO1WmvOPffcjvudiy66iJycHB544AEaGhqIjo7mqquu4r333iM7O/u07/1kV199NXfeeSeXXXYZmzZtGrDSAkopfv3rX/Pzn/+cz33uc0RFRfGtb32L3//+9x1tLrroIn7729/y6KOP8uijjxIaGso555zTsVjbCZs3b2batGm9+jn3N6X7oU5BdnY2P/jBDzrVrE1LS+PnP/+51+HrI41lWezYsYPMzMx+/8Oyqqtp/te/+vWYfaX5rD7HYKYlDhw7hq01iSeNwr3jtddICA/n/y1bNoiRiJM5pk7Fd8kSlJd6MGfC0haHGsspPZ6ULakvoLKxFK17N4r7ZGF+4ztKGcQFJxMTlICvw79f4hV9o7XGzivE9f4Wz9qzgJo4HsfFyzDGh/X4eLW1tYT2YGTt6Y6hSw9ibc3BLvZcIHBrQCEvhR9fidXHiQr0Bx8ny2Mu5rKkL0vCVgjhVX/0T0IIMRCkfxq9mpqayMvLIzU1tWMKd0+V1Rfxk83/D1M5e7R4crvdjqXb+eGiPxMTnHimIY9I1113HdHR0fzyl7/s8Wtqa2s599xzefLJJz0WEhPD2yWXXMKNN97IlVde2avXnfg8FhcXU1xcTEJCQsdocOhdbrHPI2v37dvHDTfcQHNzc6ftOTk5fOUrX+H5558nKSmpr6cRY0BBVRUPvPcej199NbFhYWwtLWVjURFfOT4NQIw8WmuqW49SUrf/+IjZIsoaimi3POuH9pS/M/CkxGwSscHJBPt41gkSQ0+3tOJ6dzP23mLPnUphLpiJuSgDNciF25VSqLjJGHGTsQ8fw8rKwd5T3FGaYV5TEgp4MdydYNZt7eBw8HHLK9iWxeemXi83OkIIIYQQYkQLdAYT6Ayhsb0Oy/IcVOH9NSEEOoMHOLLRITQ0lK997Ws8+eSTPPjgg0MdjuihdevWYVlWn+oC94c+J2v/8Ic/0NzczKxZs/jOd75DTEwMpaWl/Pa3vyU7O5vf//73nYYdi87kdv8z506dSlFVFbc+/zx1LS1EhYTw/QsukNIDQ00p9/96oKGt7qQas+6Rs43t9Wd8aofhJCY4sVNidrzfREmUjQD2gQpcb21ANzR57FOhQTguWoYR3bvVPgeCMTEc4+Ll6KWzsbblYe3aB+3tzG1KwkDxQvgWNBpcLqhtYP2u57AqDvL5xf+N2U+jzYUQQgghhBhs4/wm8MNFf+rV/VqgM5hxfhMGMKrR5eabb+aaa64hOzubjIyMoQ5HdMO2bR566CEeeOABHAO00H1P9fnsn3zyCQ6Hg0ceeYRx49yrqMfExDB9+nSWL1/O5s2b+xzkqGaa7v9Z1lBHMix8bdGiTot3iaGnnN6nxLS6milrKD6enHUnaI+1HDnz8yiDyMCYk+rMJhMZEI1pDG0nKXpHu1xY67dhbcvzut9IS8ZxzgKUb/crzg4mFRKE4+z5mIsysLL3Ym/LY3ZTIgrFv8I3uxO2AJbNpsMfYD1fwecTr8c5O81dJkEIIYQQQogRZpzfBEm+9sDTTz99Rq9zOp288MIL/RyNGCiGYfDyyy8PdRhAPyRr29ra8PHx6UjUnjBu3Dh8fHx6tUrcmOR0YkZGYpV71k0UYjgwY2LQDpOKhmJK6go6ErMHm8r7VGc23C+CuJDP6sxGBcXja/r1Y+RisNmHj+Fauw5dVeOxT/n5Yp6/GHNq/OAH1gvKzxfHgpnoOWnYuQXMzgpBVSmeH7/ps4Qt8InvHux9T/C5bYtwpk7BnJuGCpdyHEIIIYQQQggh+qbPydrk5GRycnJ47LHHuOWWWzq2P/roozQ3N0sh5W4oHx+cc+eiW1qwqzxXJxdisGnAZbfTbmp80tJoCHXyTPYvKKrNP+NjBjlDiAlOIi44ibiQKcQGJ0mto1FE2xo7KwfXhu0ddV9PZsRH4bhwKSqod4seDCXlMDEzpmHMmMrcwrmY28bxD97olLDdGliARvP5XRbW7n0YybGY89IxoiYOYeRCCCGEEEIIIUayPidrr7nmGu69915++9vf8s9//pOYmBjKy8upqKhAKcWXvvSl/ohz1FKmiTlhAn4XXYSur8dubBzqkEBrtNbuuqBSG3TU09rG0i4s23L/v7bQpoFP2DhanZq3K17oVaLWafoSe7zObGxQEnEhyYzznSB1ZkcpXdeA68312GWHPHc6TBzL52LMSkEZI/P3rwyFOSWOuVO+iSNvOmv2/hm79bMF8rICC7GV5gvHFsL+Euz9JRjREzHnzUAlxozY9y2EEEIIIYQQYmj0OVn7hS98gT179vDUU09RUVFBRUVFx74vfvGLXHnllX09xainHA6UwwGBgQzumujeaa1paWnBz89PEmyjTLvVTl1bNbVt1dS2VlHbWk2Ly3MBKEu7OHb0KPtrck5bcF4pg6jAOGJPjJgNSmRiYDSmGg5/yWIgaa2x84twvbcZ2jxXj1UR4ThWLccYHzb4wQ2QWakXYEaM56nsh7AaG6ClDbRme0ARGs2VxxZhoLDLD2OXv48KD3WPtE1JQjnkMyGEEEIIIYQQonv9snLPPffcwxVXXME777zDkSNHiIiI4KyzzpLV7kaw1tZW/PykfuhI5rLbqWwspaS+gLL6QkrqCzncVI7WuvsXd2GCf6Q7MXt8EbDooASc5vBaKEoMPN3Siuu9Ldh7ijx3KoU5bwbmklkoc/QlKGdMmMsNs/6Hp3L/gOVqQze1QHMLOwKKsdF88dgiDAwA9LFaXG9vRG3YgTknFWPmVJSf7xC/AyGEEEIIIYQQw1mfk7WvvPIK/v7+XHjhhaSkpHRstyyLp59+Gn9/fxldK8QAs7XN0eaDlNYXUlK3n5L6QioaD2DZrjM+ZpBPKHHHF/+KDU4iNjiJAGdQP0YtRiL7QCWutzagGzxLtqiQIBwXLcWIiRyCyAZP+vi5fDXtOzyZ+1usIAMC/dHNrWSbpWg0Xzq2uCNhC6Abm3Cty4It2Zgzp2HOSUUFBw7hOxBCCCGEEEIIMVz1OVl71113MXnyZC688MJO2w3D4Pe//z0+Pj6SrBWin9W0Hjs+WraA0vpCSusLvZYz6Clf0+/4AmDJHSNnQ33DpQyG6KBdFtb6bVjbcr3uN1KTcJy7EOU7NkZap47P5Mb0/+HJnN/isttRAX4Q4MeuoGPogCy+VDYX86SELQBt7VhZOVjb8zBSEt0lEiaMG5o3IIQQQohRSdc1oJtbO2/TGtXQgN3i8ri+V/6+qBAZkDFWVTXbNLT1fOZlkI9ivL/RfUMhRJ/0OlmrtebGG2+ktLS0Y9uRI0c477zzOrVraWmhoaGBoCDp+IXoi2ZXI6X1RZTU76esvoiS+gLqWqvP+HimYRIVGO9eAOz4iNmJAVEYSr50hXf2kWO41q5DH63x2Kf8fDFXLsKcljDocQ21lPBZ3Jj+P/wt5yFctrtur/LzJcevmudiyri6fC5G6RHPF9o2dm4Bdm4BRmIM5rx0VMwkeTgihBBCiD7RdQ20PfYvj2QtgNO2aTc8r/eVvy8+t1wlCdsxqKrZ5n/fr6O+F8naYB/Fg+eGDFjCVmvNyy+/zMsvv8y+fftoaGggMjKSFStWcOuttzJp0qQuXzt9+nTuv/9+rrjiCq/777rrLsrLy3n66acHJHYh+lOvk7VKKb7yla9w++23d/y3ZVmUl5d7bX/WWWf1LUIhxpB2u52KhgOU1hdQUl9IaX0BR5oq+3TMiIDJxAYnEx+cTGxwMpOD4nAazn6KWIxm2tbY23JxbdgOluWx34ibjOPCpWN6Sv/08Az+a8Z3+dvuB2m32zq257Tn88/UQL689FrUtj3Y+w6Al3rRdlEZdlEZKnKCe6TtlHiUIUlbIYQQQvSebm51J2oNA05d3NS2wDhlm8vqeI0ka8eehjZNfZvGocDZg6Um2i2ob9M0tGnG+/d/PJZl8f/+3/9j27Zt3Hbbbfzwhz8kMDCQffv28Ze//IUvfOELvPLKK0yYMMHr69evX09wcHD/BybEEDijMggrV67khz/8IQ0NDTz00EMEBwdz8803d+xXSuFwOIiNjWXFihX9FqwQo4mtbQ43VXRKzFY2lmDZnkmxngr1De8YLeseOZuIv2PsJtLEmdP1jbjeXI9detBzp8PEsWwORmaqJBaBaeNm8LWZd/B/u39Du/XZSJacqizWYHPdqm/jUzcHKysXK2c/uDxrSeuDR3H95yNUWDDm3HSM9GSUo1/WABVCCCHEWOMwUc5TriMs5bH4qwZoswctLDE8OU3wNXtyTa+9Xcb2m7/97W+sW7eO559/nvT09I7tUVFRLFiwgFWrVvHEE0/wve99z+vrIyIiBi44IQbZGd8JXnvttQC0tbURFBTEV7/61f6KSYhRR2tNTWtVp8RsWX0RrVbLGR/TzxHQUV82NjiJmOAkwnzD+zFqMVZZ+UW43tsMrW0e+1REOI6Ll0mt1VNMCUvjphl38H+7f03bSQnb3Krt/D3nd9yQ/t84z1uIuXgW1s587B35Xqco6pp6XO9tRm3cgZGZgpmZgvL3Hcy3IoQQQgghRjhb625r0Ta02WgNtgarB5UQbO2eKNbQZlPX2nVyN8hHYfSyvJfWmmeeeYbLLrusU6L2BH9/f9asWUNERARlZWWcd955fPvb3+aZZ57B19eXV155hfnz53eUQdBa8/DDD/PPf/6Turo6LrnkElpbPa+9hRiu+jxs50Q5hPr6ehobG7Ft95M527apq6tj48aN3HTTTX09jRAjSlN7Q6fFv0rqC2hoqz3j45mGg+ighE7J2Qn+kVJnVvQr3dKK6/0t2PlFnjuVwpybjrkkE3XqtDoBQHJYKjfN/B7/t+vXnR7E5B/bwZM5D/HVtO/gDPDDsTgTPW8Gds5+rKwcdG2Dx7F0cwvWph1YW3djpk/BnJuGCpVpXUIIIYToIa2htc39cLjdvbCYDgqQh8BjwKeVbTyb20Jd6+lHTbdammMtNgroyWQ5W7tHY9+/ueG0I3FDfA2uTfNj/uSeLzxcVlZGRUUFS5Ys6bJNdHR0p/9+7bXX+Pvf/05zczMhISGd9j322GM8/vjj/OQnPyEtLY3nnnuOF154gQULFvQ4JiGGUp+TtUVFRdx+++0UFhZ22UaStWI0a7faKG8opqS+gJLjI2aPNnuZOt5DSikmBkQT11HKIInJgbE4pM6sGEB2aSWuNzeg6xs99qmQQBwXLcOIiRyCyEaWpNAUbp55J3/d9UCnhO2eY9k8kfMgN6b/Dz6mL8rpwMxMwciYhr2vBGvrbvShKs8DtruwduRj7dyDMS3BXdd20vhBfEdCCCGEGCm01uCyoK0d3e7qXC9fa6hrQDc1o4ICwVfuLUarv+9qptnV80XD+ltdq83fdzX3Kll79OhRAMLDO88Uve2229iyZUvHf0dFRfHoo48C7tneU6ZM8TiW1pqnn36a66+/nksvvRSAu+++u9NxhBju+pys/fWvf01BQUGX+70NYRdipLK1zaHGso5SBiX1BVQ2lqL1mdd6CvMbf3y0bDJxwUnEBCXi6xiAiu1CeKFdFtaG7Vjbcr0ugGWkJuE4ZwHKT0Zh9FRC6DRuybiLx3Y9QKuruWP7vurdPLH7Qf5rxv/iY7p/nsowMKcnYEyLR5cdxPo0B7vYy4KdWmPvKcLeU4QRNxlzXjoqPgrVyylmQgghhBh97Koa7NxCrB350NQMSrn/543LQtfUgY8T5PpODBPjxrlLrNXU1HTa/uMf/5iWFvcAiKeffpr333+/Y198fLzXY1VXV3PkyBFmzpzZaXtmZuZpc1dCDCd9TtZu27YNwzB4+OGHef7552lqauKHP/whzz77LGvWrGH16tX9EacQg05rTXXrUUrqCjpqzZY1FHVaQKi3/J2BHYnZ2OBEYoOTCfEJ67+ghegF+0g1rjfXoY9Ue+xTvj6YKxdhTk8cgshGvviQqdw6824e2/VLWlxNHdv31+Twf7t/zX/N+C6+pl/HdqUUKnYyRuxk7CPHsLbmYO8pBtvzQZBdUoldUomKGOdejGx6IsqUkihCCCHEWKKbWrD3FGHlFaIPukcl6vZerP7U1u5en8A00XUNIDN3Ro0bZvr3qAzCQDlRBqE3YmNjiYiI4JNPPuGSSy7p2D5p0qSOf4eGhnZ6jZ/f6c+hTxmI4pDFe8UI0ue/1oaGBsaNG8dZZ51FRUUFf/zjH0lMTOTOO+/kxRdf5F//+pcsPiZGhIa2uuM1Zj9bBKyxvf6Mj+cwnEQHJRAXMuV4SYMkxvtNkpFwYshpW2Nvz8O1YZt7qtwpjLjJOC5cigoOHILoRo+4kGRuzbibx7J/SbPrs/ISBTV5PL7r19w047teR9EbEeEYFy9HL52NtS0Pa/c+9w3VKfSRalxvrkdt2I45Jw1j5lSUj0xpFEIIIUYr7bKwi8qwcwuwi8q9PtT14OvjHkXb1AKW53UfLhftr7yPnpuGuTADFSgz/Ea6+ZN9mBvp7HaBsdI6ix+sa8DPAT6nqUF7QpulaXHB3YuCiA3peg2LM1lgzDRNrr/+ev785z9zzTXXkJKS4tGmsrKyR8cKDw9n8uTJZGVlsXLlyo7tu3fvxumUa2UxMvQ5WTt+/HiqqqqoqKggMzOTY8eOsWvXLiIjI2lvb6eioqI/4hSiX7VaLe46s3UFHQnaYy1Hzvh4ShlEBsYQG+ROysaFTCEyIBrTkKd3YnjR9Y243tqAXeLlYsc0cSybgzE7FdWTVQZEt2KDk7g1424e3XU/ze2fJWyLavP56+5fcfOM73VZ9kSFBOE4ez7mogys7L3Y2/LQTc0e7XR9I66PPkVt3omRmYKZmSI3WkIIIcQoobVGVx7Bzi3E3luMbunBLD+HiQrwd5c5OH5NZ/s6Ue0uaGgC65Qkr227a+TnFmDOS8eckyYPgEc4QylCfE9/PR/ko1HK/SfSg1wtxvHqGkE+BiG+/T+r66abbiI3N5drr72WW265hbPPPpugoCD27t3LmjVr2LBhA1/4whd6dKybb76ZBx54gKSkJObNm8err75KdnY2c+fO7fe4hRgIfc4kLVmyhJdffplbb72VV199lfDwcK6//npM08TlchEVFdUfcQpxxizbxcGmckrq9nckZg82lfepzmy4XwRxIcnEBCURF5JMdFBCpynNQgxH1p4irHc3o1vbPPapCeNwXLwcI2LcEEQ2usUEJ3Jbxr08mv0LmtobOrYX1+7lsV0PcPPMO/E7TZ1q5eeLY8FM9Jw07LxC92Jk1XUe7XRrG9aWbKytOZhpyZhz01DhoV6OKIQQQojhTtfWY+UVYucWumvMdkMFBmDETML6dDf4+4LT81Zf+fmCry80t6Abmz1H2ra1Y23cgb1zD+biTIwZU1CGlFoSg8MwDH73u9+xdu1aXnzxRZ566inq6uqYMGEC8+bNY82aNcyfP5+ysrJuj/XlL38Z27Z5+OGHOXr0KMuXL+fKK6+kqKhoEN6JEH3X52TtHXfcQVFREePHj8cwjI4nGCfcfPPNfT2FED2mtaaq5RAl9QWU1hdRUref8oZiXLbnFOKeCnQGdyz+5a41m0SQT0g/Ri3EwNKtbbje34KdV+h1vzk3HXPpbJSj6+lMom+ig+I7ErYnl1c5ULePx3b9kptn3om/I+C0x1AOE3PmVIz0KejCUndd24rDng0tC2vXXqzd+zCSYzHnpWNETezvtySEEEKIfqZb27D3HXCXOSg71P0LHA6MqXGYqcmouMnoI8fci8a6LDwmwNsW2j6+1emA0CBobIYWz4f4urEZ17ubUNtyMZfNwUiOlVJuo1i7BXj+xXTRbuBdfPHFXHzxxV3uj4mJYc+ePR7bT9123XXXcd111/V7fEIMhj4na8PDw/nnP/9JdbV7gZobb7yRqVOnsmfPHmbPns2cOXP6HKQQXalvq6Wkfj+ldYWUNhRSUl/QaapxbzlNX2KCEjsSs3EhyYzznSAXJ2LEsssO4npzPbrO83OhggJxXLQUI27yEEQ29kQFxXHbrHt5dOcvaGj/bIRMSd1+Hsu+n1sy7sLf0X2dYGUo1JQ4jClx2OWHsbbuxi4o9WyoNfb+Euz9JRhREzHnz0AlxkiJCyGEEGIY0baNPlCJlVuAXVDidT2BUxkxkRjpyRhT4lC+Pp/t8PdF+fuim1uhzbPUAcYp23ycqKAAVEoiurAMTlmQSR+rxfXaB+7riBVz5eHvKBPkowj2UdS3aVw9XJsu2EcR5CPXkkIMNKVPXSJviNXU1PDQQw/x4Ycf0tDQwPTp0/nf//1f5s2b57V9dXU1P/vZz/j4448BuOiii7j77rsJCPhshNLatWv54x//SGlpKQkJCdxxxx2sWLGixzFZlsWOHTvIzMzENEf/yDOtNbW1tYSGhg6rJGWrq5myhiJK6gvdJQ0aCqlpqTrj4yllEBUYR+yJxGxwEhMDozHV6P8di9FPuyysjTuwsnI8LrwBjJREHOcudE+HG0GGa//UGwcby3gk+xc0tNV22h4TnMgtM+8iwBnU62Pax2qxs3Kwcgu9Lx5ynAoPdY+0TUmSkdRC9LPR0D8JIQaPffgYdl4Bdl6R15r0p1LjQjDSkjFTk1AhXV8r6LoGd7L25G1a09DQQFBQkEf/pPx9USFB2EeOYa3bhl1c3uWxjanxOJbOljJLw0hTUxN5eXmkpqZ2yoH0VFWz3e1CZCcL8lGM95fSGEJ4c+LzWFxcTHFxMQkJCZ3qLPcmt3hGI2tXrVrV47ZKKV5//fUet/+f//kfqqqqeOihhwgPD+fZZ5/la1/7Gi+99BLJycke7b/1rW/R2trKk08+SV1dHffeey8//vGPO0oxbN68mTvuuIO77rqLxYsX88ILL/D//t//45VXXvF6PDE8uOx2KhtLO2rMltQXcripnL48W5jgH3k8MZtEXHAyUUHx+JgjK1ElRE/YVTW43liHPnLMc6evD45zF2KmJg1+YAKAyMAYvjHr+zy882fUn5SwLasv4tHjI2wDncG9OqYRHopx/hLMxZnuBUJ27gEvtYn1sVpcb29EbdiOMTsVM2PaiEvYCyGEECOVbmjCzi/CyitAH6nutr3y88WYnoiRloSK7NlsPxUS5JHM1Vqj/RwYp3mYZESEY1yxErukEte6LPQhz0Ex9r4DtO0vwZw5DXPxLFnQdBQY728wXn6NQgw7ZzSyNiUlxfNASnVKpJ34b6UUeXl5PTrugQMHuOCCC/jHP/7RUT5Ba82FF17IJZdcwre//e1O7bdv387VV1/NG2+80ZF4Xb9+PTfddBMfffQRkyZN4mtf+xohISH89re/7Xjd1VdfzbRp0/jJT37So7hkZO3AsrXN0eaDlNYXHq81W0h5QzGW3cO5GF4E+YQSF5xMXHAyMcGJxAYn9Tr5IcRIo22NvSMP1/ptXqfQGTGROC5aetrRGMPdaBq5dripgkeyf0Fda+ebtaigeG7NuLtPfZZua8fetRcrKw/dcJrSMD5O9w3XnFRUcPclGIQQXRtN/ZMQov/odhd2Qam7Du2BCq8znjoxDIykGIzUJIzEmH6ZCdPb/knbGntvMdaGbejaBu+NnE7MeWmYc9NRPs4+xyjOTF9H1goh+s+Qj6y9/fbbO/7d3t7OU089BcD5559PZGQkhw4d4u233yYkJITvfve7PT7uuHHjeOyxx5gxY0bHthNJ39raWo/2W7duJSIiotMI2QULFqCUIisri4suuoht27Zx1113dXrdwoULeeedd3ocl+hfta3Vx0fLFhwfOVtIi6vpjI/na/odT8gmdyRoQ33D5UZJjCm6vhHX2xvdNwGnMk0cS2djzEmTeqXDyMSAKL6ecS+PZP+C2tbPRkFXNBzgkZ0/59aMe854MUPl48Scm46RmYq9pwhraw76qJcRPG3tWFk5WNvzMFIS3a+JGHemb0kIIYQQuJOduuIQdk4B1r4D0Nb9YscqcgJmWjLG9ASUv98gRHmaWAyFmZLoro+fvQdrS7ZHaQXa27E27cTeuRdzUQbGzGkoU6bHCyFEf+hzsvaXv/wlLS0tvPzyy51G3F533XVceeWV5Obmsnr16h4dNyQkhLPOOqvTtrVr11JSUsKyZcs82h86dIjJkzsvjOPj40NYWBiVlZXU1dXR1NREZGRkpzYTJ06ksrKyRzGNdtUtRzutTA7Haxo1NVBveNY0CnQGM85vQo+P3+xq6ihlcCIxe3JSordMwyQqMJ6Y4KSORcAmBkRhKLkwEGOXtbcY693N6JZWj31qfBiOi5djTAwfgshEdyICJvP1Wd/nkZ0/p6b1s+mGlY2lPJz9c27LuIdgnzOvC6dMw33jl5qELq7AysrBLvHy/Wfb7hE/uQUYCdGY89NRMZHy0EsIIYToBV1d514oLK8QXdfFiNSTqOBAjOPf08YwrAOrHCbmnDSM9ClYn+7G2pbrMXtLNzXjen8Lanse5rI57kXP5Pph0Nm23X0jIcSA6s/P4Rkla0/28ssvExQU5FEaYcaMGQQGBvLKK69w5513ntGxs7KyuOeeezjvvPM499xzPfY3Nzfj4+Pjsd3X15fW1lZaWloAPNqc2N9bWus+1UwdbqpbjvLTLd+k8aRVyQE07lVJlWFw6tdsoDOEHyz8o9eEbbvdTkXDAcoaCimpcydnjzT3LSke4T+5YwGw2OAkooLicRqe02xG0+9FiJ7SrW1YH3yCnVfodb8xJxVz6RyUwxw1n5ET/fBoeT8A4/0mclvGvTyS3Tlhe6ixjId3/ux4wjasz+dRCVE4EqKwDx7FzsrF3nfA61RMu7gcu7gcNWk85rx01JR4GZEtRA+Mxv5JCNE93dKKvbcYO7cQXXmk+xf4ODGmxGGkJaOiJ3V8xw5k39Hn/snHibl0NkbGNPdo2twCj2sIXV2H698foiZHuJO2MZP6HrjoltPpvjc+sYCcEGLoNDS4H9K1t382m+Lkfrc3fXCfk7WWZdHY2Mgrr7zC5z73uY7tr7zyCo2NjRjGmY14fPfdd/nud7/LrFmzeOihh7y28fPzo63NcwGV1tZWAgIC8PV1L5pyapvW1lb8/XtfRbuuru6M389wdKipkvrWWkzlwHFKAtRWtsdoVZfdTn1rLYeqK8Hf5GjLQSqaiilvOkBFYzEHm8uwdderkHcn2BlGVGA80QEJRAckMDkgHn/HSXV3NDTVn3m5BCFGE1V5FMeHW1ENnp8JHeiP66y56OiJ0Nj9qI6RRGtNU5P7PY+mURsOfPly4rd4at9vqWk7aYRtfSl/yLqP66d8h5B+SNgC4O+EZbMgYwrmrn2Yew6A5aXvrjiM67XD6OBArIyp2NPiwNHnywYhRq3R2j8JIbywbFTZIcy9BzBKDkJ3o6mUwo6OwJ4Sh50QBc7j36f1dad/XT/p1/5pYTpqaizmp7vd7/1UZQdx/fMN7LjJWAvS0ePOrKST6Lng4GDKy8sBCAoKGlU5CyFGAtu2aWhooLy8nKqqKpqammhra6OlpaVTSdfejLzt813XWWedxeuvv87dd9/NX//6VyIiIjh06BDFxcUopTj//PN7fcw1a9bw85//nPPPP5/f/OY3XkfPAkRGRvLuu+922tbW1kZNTQ2TJk0iLCyMgIAADh8+3KnN4cOHPUoj9ERISMioWmCs3gjCMBS+pi8+ZufVwF2WheOk9+rSLtrbW2mxmni94hmqW47SarV0eo0ywKRnPx8/RwAxQYnEHR8xGxOcRJivTNMWojvasrA37cTamuMe0XBKn2RMS8A8byHKz7eLI4xsJ55GjsYFfEIJ5Zsh9/FI9i841vLZ91ZN+1GeLf4jt2bc07/9ZGgoxEahz2nB3rEHa0c+eCmlQVMLjs27YOdezFkpGJnTh7yWnhDD0Wjun4QQx0enHqrCzivE3lMEJ2q4KuVxPXaCGh+GkZaEMT1xSBfy7Pf+KTQUEmOxyw5hfbwVfajKo4lZfhjnK0cw0qdgLp6FCpLFrwZKSEgIRUVFHQlbIcTQqKmp4ejRo/j5ue+VJk6cSGjoZyVuLG8DZLrQ52Ttvffey/79+9mzZw8FBQUUFBR07JszZw733HNPr4737LPP8tOf/pTrrruOe+6557RPhebPn89vfvMbDhw4QHx8PABbtmzpOLdSijlz5vDJJ59w1VVXdbxuy5YtzJ07t1dxgfsp5Gi6+O7qvdjaps1qpsly0Wa10ma3YmsLW9tobVNSV+CR3D0d03AQHZRAbFAicSFTiA1OYoJ/pNSZFaKX7KoaXGvXoQ97qfvs48Rx7kKM1KRR1U95c6IvHo3vM9w/gm/M+j4PZ/+cquZDHduPNh/k0exfcNuse/v9wZYK8MdYkok5fwZ2zn6srFx0bb1nw+ZWrM3uBwXmjCmYc9JQYcH9GosQI91o7p+EGKt0fSNWXqG7Dm1VTbftVYAfRkoSRloSKmL4LHo8EP2TGRuJce0l2PsOYK3fjq45ZaSw1ti792HnF2HOTXOXV/L1PhBLnDmlFElJSaxdu5aCggLGjx/fMctYiJGgra2ty0GaI0V7ezu2baO15ujRo/j6+hIbG9upz+1N/6t0PxTHcblcvPfee+zYsYP6+npCQ0NZsGABK1as6FUwRUVFrF69mrPPPpsf/ehHnfb5+fkREBDAsWPHCA4Oxs/PD6011157La2trdx33300NTVxzz33sHDhQu6//34A1q9fzy233MIdd9zBihUrePHFF3nmmWd46aWXSE5O7lFclmWxY8cOMjMzR9XI2rL6In6y+f/hZwbgY/qigZqWozS66tFae/zuTiRrJwfGdZmsVUoxMSC6Y/Gv2OAkJgfGepRZEEL0nNYae0c+rnVZHos6ABgxk3BctAwVMvrrVGmtqa2tHfUj12paj/HIzp9ztLnz9MJw/4l8PePeXi302FvatrH3lWBt3e11pEwHpdwjueelY0waP2DxCDFSjJX+SYixQLe1Y+8vcS++WXrQa433ThwmRlIsZloyKj4KZQ6vQSmD0T9py8LetQ9r8050U4vXNsrfD3NRBkbGNNQouq8eLlpbW3nnnXfIzc3Fsiz5LhIjgtaa9vZ2nE7nqPib1VoTGBjIWWedRUZGRqf31JvcYr8ka/vLI488wm9/+1uv+z7/+c9z++23c95553H//fdzxRVXAFBVVcWPf/xj1q1bh6+vLxdddBF33313pydJr7zyCn/5y184ePAgU6ZM4Y477mDx4sU9jmusJGubXY1UHZ9629NkbZjveGKDk4gLmUJccBLRQYn4OXpfD1gI4Z1uaML19kbsYi/TmgwDx9LZGHPTx8wCUGMpGVLbWs0j2T/nSFPnhRrD/SK4bda9hPtFDOj5tdbosoNYn+Z4//s7iRE32T1aJj5q1P9ehOjKWOqfhBiNtK3RpQexcvdj7y+Bdle3rzGiJ2KkJmNMix/WJagGs3/SrW1YWTlYWbld/gxVWLB7wbJpCdJf9rO2tjYqKipoaGiQBS/FiKC1prGxkcDAwFHRHzidTkJDQ4mMjPR4PwOerL3vvvsIDQ3lO9/5Dvfdd9/pT6CUxyjZkWasJGubXI0ddRK9JWs1YGBwWdJXyJg4n9jg5P5b8EYI4cHadwDrnU1oL3VE1fgwHBcvw5g4tkY0jrVkSF1bDY/s/AWHmzonS8P8xvONWT8Y8ITtCfaRY1hbc7D3FJ92ERUVMQ5zbrq7Nt8wG1UkxEAba/2TEKOFXVXjHkGbV4RuaOy2vQoNxkhLwkxNHjHlgIaif9INTe7ySbv2dTkyWUVOwLF8LkZs79eTEUKMDmPp+mnAk7UpKSlMnjyZDz74gJSUlC5/oCcSfnl5eb09xbAyVpK1Gk1V82FarCbQ4GP64mP64WP64GP4YmubFquJHy76MzHBiUMdvhCjlm5tw/rwU6yc/V73m3NSMZfNQTn6XHZ8xBlLX+Yn1LfV8kj2LzjUWNZpe5jveG6bdS8T/CcNWiy6vhFrW677xqutvct2KjgQc04axsypKB8pgyPGhrHYPwkxUummFuw9RVi5Bacv+XOCrw/m9ASM1GRUVMSI+4wPZf9kV9Vgrd+GXVDaZRsjMQZz2RyMiHGDGJkQYjgYS9dPvcktntGd/vz58xk/fnzHv8XooFBM8J+ERmNZFg6z859Hm+VllXAhRL+yyw/henM9urbBY58KCsBx4VKM+KghiEwMlWCfUG7LuIfHsu+nsvGzG52a1ioe3vkzbsu4h4iAyYMSiwoOxHHWfMyFGVjZe7G356Ebmz3a6fpGXB99itq8E2PWdMzZqahAKZEjhBBi6GiXhV1Yhp1XgF1UftqZIoC7NntiNEZaMkZSLMoxegbtDCZjfBjG5edilx/CWrcNu+KwRxu7qAy7uBwzLRlzSSYqOHAIIhVCiOFjWNWsHa7Gysjak1mW5fFe26xWGVkrxADRloW1ORvrk11ep4oZU+NxrFyM8h++9dAGw1h68nqqxvZ6Hs2+n4qGA522h/iO47aMe5gYMPhJfO2ysPMLsT7NQVfXdt3QNDHTkjDnpqPCQwcvQCEG0Vjun4QYrrTW6Moj7jIHe4rRrW3dvkZNDMdMTcZISRw1DxqHS/+ktcbeX4K1fhu6us57I4eJOTsVc/6MYV0HWAjRP4ZL/zQYBnxkrRBCiP5jH6vFtXad92l4Pk4c5y7ESE0a9V9e4vQCncHcmnE3j2X/kvKG4o7tda3VPLzzZ3x91vcHPWGrHCbmjKkYaVPQhaXuurZeRsxgWVi79mHt3o+RHIs5Lx0jauKgxiqEEGLs0LX1WLmF2HkF6Jr6bturwACM1CT3/2Qq/oBRSmFOjcdIisXevQ9r00500ykzdFwW1qe7sXftw1yYgTFruoxqFkKMOWeUrF21alWP2yqleP3118/kNGKQtNuedQct28bE6LadEOLMaa2xd+7B9XEWuDxXyzWiJ+K4aBkqdGQsXiEGXkfCdtcvKasv6the31bLX46XRIgMjBn0uJShUFPiMKbEYVccdidtC0o9R4kfH1Fj7y/BiJqIOS8dlRSLMuRBhBBCiL7RrW3Yew+4R9GWH+r+BQ4HxtQ490JhcZPlu2gQKdPAnDUdIzUJKysHa2sutHe+19Qtre6SSjvyMJfMdi9eKr8jIcQYcUbJ2sLCwh63lZFgw1egM5hAZwiN7XVYVucvR9vWGNrzdxfoDCHQKYkjIfpKNzbjemsDdnG5507DwFySiTlvhlyUCg8BziBumXkXf931AKX1n30fNxxfiOzWjLuZHBg7ZPEZURMxLpuIfawWOysHK7cQLMujnV1xGPu1w6hxoZjz0zFSkmTkjBBCiF7Rto0+UOEeRVtQAi7P75tTGbGR7jq0U+NlEcwhpnycOBZnYmZMd5cDy97j8aBX1zbgWrsOlZWDY/k8jPjBqdMvhBBD6Yxq1v7pT3/qVfvbb7+9t6cYVkZrzVqA6pajNLZ3nhqktaahoYGgoCCPZHugM5hxfhMGM0QhRh1r3wGsdzehmz0X7VPhoTguXo4xafwQRDb8jaWaRt1pdjXy112/oqRuf6ft7tG39xAVFDdEkXWmG5qwduRj7dwDp6kVqAL9MWanYmZMkxp1YkSS/kmIwWMfPuYeQZtf5DmN3gs1LhQjLQkzNQkVEjQIEQ4vI6V/0tV1uNZvw953oMs2RkI05rI5GBPDBzEyIcRAGSn9U3/oTW5RFhjrgdGcrPVmLH1YhBhMuq0d68NPsXbv87rfzEzBXD4X5ZRy4l2R/qmzFlczf931AAfqOv9NBTiDuDXjHqKD4ocoMk+6rR171z6sbbno+sauG/o4MWdOxZyTJqtBixFF+ichBpZuaMLOL8LKK0Afqe62vfLzxUhJxEhLRk0aP6Y/lyOtf7IrDmOty8Iu91IHH0ApjJREHEtnj8nkuxCjyUjrn/piSJK19fX1NDY2Yts2ALZtU1dXx8aNG7npppv64xRDRpK1Qoi+sisO41q7Hl3ruciFCvTHceFSjIToIYhsZJH+yVOrq5m/7v4VxbV7O233dwZy68y7iQlOHKLIvNOWjb2nCGtrDvroaW62DQNjegLmvBmy2IsYEaR/EqL/6XYXdkGpexTtgQrPWuinMgyMpBh3mYPEaNQYuHfriZHYP2mt0YVluNZvQ1fVeG/kMN2DHRbMlFk5QoxQI7F/OlODmqwtKiri9ttvP20d27y8vL6cYshJslYIcaa0ZWNt2Ym1ZZfXGwxjajyOlYtQ/n5DEN3II/2Td62uZv4v5zcU1uR32u7vCOSWjLuIDU4aosi6prV21xncmoNdUnnatkZCNOb8dFRMpPzexbAl/ZMQ/UPbGl1xCDunAGvfAWjrfpFjNTkCMzXJvQiVvyTtTjWS+ydt29i792Nt2olubPLaRvn6YC6YiTE7VerfCzHCjOT+qbd6k1vs81zbX//61xQUFHS5Pz09va+nEEKIEUlX19G+dh364FHPnT5OHGfPx0ifMuq/lMTA83X487UZd/DE7t9QUPPZA9JmVyOPZt/PLTPvIi4keQgj9KSUQiVEYyREYx+qcidt9xZ7fahhF5djF5ejIidgzk3HmBqHMozBD1oIIcSA0dV1WLkF2HmF6LqGbturkECM1GR3Hdrw0EGIUAwFZRiYGdMwUhKxtudhfbrbI4GvW9twrctC7czHXDLbvWipLNIrhBjB+pys3bZtG4Zh8PDDD/P888/T1NTED3/4Q5599lnWrFnD6tWr+yNOIYQYMbTW2Nl7cX20FVwuj/1G1EQcFy1DhQUPQXRitPI1/Y4nbB9kf01Ox/YWVxOP7rqfW2beSXzI1CGMsGvGpPEYl6xAL52NtS0Xa/d+r58dffAortc/QoUGY85Ncz/skBrPQggxYumWVuw9xe4yB5VHun+BjxNzary7Dm30JEnIjSHKx4ljYQbmzGlYm3diZe+F4yUYT9B1jbjeXI/KysGxbC4qIUoGRQghRqQ+l0GYMWMGoaGhbNiwgX/84x/88Y9/ZOPGjbhcLhYsWMDkyZN5/fXX+yveISFlEIQQPaUbm3G9vRG7qMxzp2FgLp6FOX+m3FycIemfutdmtfK3nIfYV72703Zf04+bZ95JQui0IYqs53RzC9aOfOwde9DNLV22U/5+GJnTMTNTpJSIGHLSPwnRM9qy0EXlWHmF2AWlHgk3D0phxEdhpCZhTImTh3RnYDT2T7qmHteG7dh7irpsY8RNxlw+F2PS+EGMTAjRG6Oxf+rKoJZBGD9+PFVVVVRUVJCZmcmxY8fYtWsXkZGRtLe3U1FR0ddTCCHEiGAXlOJ6ZyO6yTO5pMaF4rh4GUbkhCGITIwlPqYv/5X+vzyZ+1v2HMvu2N5qtfDXXQ9w08zvkRg6fQgj7J7y98OxOBM9bwZ2zn6srFyvi/Pp5hasTTuxPs3BnDEFc06ajFgXQohhSGuNPlTlHkG7pwjd3Nrta9SEMMy0KRgpiaiggEGIUowkKiwY5yUrsOemYX2chV120KONXVKJ/cx/MFIScSydjQqVawQhxMjQ55G1d999Ny+//DJTp07l1VdfZdmyZTQ3N2OaJo2NjcTFxfHWW2/1V7xDQkbWCiFOR7e1Y320FWvXXq/7zVkpmCvmykiQfiD9U8+12+38Ped35B/b0Wm7j+nL12bcQXJY6tAEdga0rbH3H8DamuO9BvQJSmFMjcecly4PRsSgk/5JCE+6vtE9gja3AH2sttv2KsAfIyXRXeYgYpx8lvrJaO+ftNbo4nJc67LQR2u8NzIMzMwUzIUZsgidEMPIaO+fTjaoI2vvuOMOioqKGD9+PIZhcPPNN/PAAw907L/55pv7egohhBi27IojuN5cj66p89inAvxxXLgEIzFmCCITY53TcHJD+n/zdO7vya3a3rG9zWrl8d2/5qYZ3yU5LG0II+w5ZSjMaQkYU+PRZYewPt2NXVzu2VBr7L3F2HuLMWIjMefNkHp1QggxyHRbO/a+A9h5hdilB70uHNmJw8RIjsNMS0LFRaFMWUBS9I5SCpUYgzM+Gjt3P9bGneiGxs6NbPt4Xfx9mAtmYs5OlYEUQohh64xG1j744INcdtllTJ362UIl1dXVjBs3DoANGzaQn5/P7NmzmTNnTv9FO0RkZK0Q4lTasrE+ycbanO31JsSYEodj5WJUgNTR7E/SP/Veu93O07l/ILdqW6ftTsOHG2f8L9PGzRiiyPrGPlKNlZWDnV902nqHasI490jb6YmSABADSvonMZZpW6NLK7FyC7D3l0C75yKRpzKiJ2KkJmNMi0f5yUjHgTTW+iftcmFty8P6dDe0tnlto4ICMZfMwkibImtJCDGExlL/1Jvc4hkla1NSUlBKMWXKFC6//HIuueQSJk+efMYBD3eSrBVCnExX19G+dp336dhOJ45z5rtXqZfPT7+T/unMuOx21uT9id1Ht3ba7jCc3Jj+P0wPzxiiyPpO1ze6b8h27YW29i7bqeBAzDmpGDOnoXycgxihGCukfxJjkV1Vg51TgJ1fiG5o6ra9Cg3GSEvCTE2WGuODaKz2T7q5FWtLNtbOPWBZXtuoCWE4ls1FJUaPqZ+NEMPFWOqfBjxZO3v2bJqbm90HUAqlFHPnzuWyyy7jwgsvJCQk5MwiH6YkWSuEAPdnw961D9dHn3odMWJETcRx0TK5+RhA0j+dOct28Uz+n8k+8kmn7Q7DyVfTv0NK+Kwhiqx/6JZWrOy92Nvz0I3NXTf09cGcNd09/THQf/ACFKOe9E9irNCNzdh7irByC9GHq7p/ga8P5vQEjNRkVFSEfD6GwFjvn3RtPa4NO7DzC7tsY8RMwlwxT2reCzHIxlL/NODJ2tbWVj766CPeeustPvzwQxob3fVglFI4HA5WrFjB6tWrOffcc/Hx8TmzdzGMSLJWCKEbm3G9uwm7oNRzp1KYi2dhLpiJMmSa9UCS/qlvLNvFs/kPs/PI5k7bTcPBV9O+Q+r4zKEJrB9pl4WdX+hejOx0i9mYJmZaEubcdFR46OAFKEYt6Z/EaKZdFnZhKXZuAXZRefd1aJXCSIzGSEvGSIpFOUb/PdRwJv2Tm32oCmtdFnZJZZdtjGkJOJbNkcEXQgySsdQ/DXiy9mRtbW18/PHHvPXWW3zwwQc0NDS4D6wUgYGBnH/++dx///19OcWQk2StEGObXViK6+1N6CbP0XpqXAiOi5fLU/hBIv1T31na4h/5D7Pj8KZO203DwfVp3yJ9/Nwhiqx/aVuji8qwtu7GLj/cdUOlMJJiMOfNwIieOHgBilFH+icx2mit0RVHsPMKsPYUd1n782Rq4njMtCR3nXCZvTBsSP/0Ga01+kAFrnXb0EeOeW9kGJgZ0zAXZsjfsRADbCz1T4OarD1Ze3s7GzZs4IknnuCTT9zTLJVS5OXl9dcphoQka4UYm3RbO9bHW7Gy93rdb2ZMx1wxV+pfDiLpn/qHpS2e2/MY2w6t77TdNEyuS/02MyaMjoTtCXbFYaytOe6R8ae57DGiJmLOS0clxcpiI6LXpH8So4WuqcfKK8TOK0DX1HfbXgUFYKQkYaQlYUwYNwgRit6S/smTtrV7Js7G7ei6Ru+NfJyY82ZgzkmV630hBshY6p96k1t09NdJDx8+zJtvvskbb7zBzp07UUrRj3lgIYQYVPbBo7jWrkNX13nsUwH+OC5YjJEUOwSRCdF3pjK5evqtGCi2HlrXsd2yLZ7K/T1fSb2djIgFQxhh/zKiJmJcNhF9rBYrKxcrt8DrQiN2xWHs1w6jxoVizkvHSE2SqbtCiDFBt7Zh7z3gLnNQfqj7FzgdGFPiMNOSUbGT5QGXGHGUoTDTkjGmJWDvyMfako0+dfR4WzvWxu3YO/dgLp6FMWOKlDwTQgyKPiVrjx07xptvvsnatWvJyspyTyk4nqD18/PjnHPOYfXq1f0SqBBCDAZt21hbdmFt3ul1BJ6RHItj5WKZEiVGPEMZfHH6LShl8OnBjzq229ri6bw/ch23kxGxcAgj7H8qPBTH+Ysxl2Ri7cjH3pHveWMG6OpaXO9sRG3cjjE7FTNjGsrPdwgiFkKIgaNtG32gAiu3ELugBFyeD7E6UQojNhIjNQljaryMNBSjgnKY7ge0M6ZgfbILa0e+x2dBNzbhencTaluuu55tcuyoHwEohBhaZ5Ss/de//sUbb7zBJ598gm3bgHvosmmaLFq0iNWrV3P++ecTGBjYr8EKIcRA0tV1uN5cj115xHOn04HjrPkYM6fKxZkYNQxlcNW0mzCUwZbKDzq2a23zdN6f+LK2yZy4eAgjHBgq0B/H0tno+TOwd+3D2paLrvecAqkbm7HWb8P6ZBfmjKnuaZAhQUMQsRBC9A+tNfpItXsEbX6R13r8p1LjQjHSkzFTEqUPFKOW8vPFsWIeZmYKro07sPMKPQZu6GO1tL/2AUb0RMzlczGipNa9EGJgnFGy9gc/+EGnMgczZsxg9erVXHLJJUyYIIvsCCFGFq019u79uD78FNrbPfaryRE4L1qGGhcyBNEJMbAMZfCFqf+FQrG58v2O7VrbPJP/F2xs5kxcOoQRDhzl48Scm4aRmYK9pwgrKwd9pNqzYVs71rZcrB35GNMT3CNwIsIHP2AhhDhDuqEJO78IK7cAfdRLP3cK5e+LMT0RIy0ZNWm8PKgWY4YKCcJ50TLsOWlY67dhF5d7tLHLD2P/cy3G1Hj3SFu5RxBC9LMzLoMQFxfHpZdeyurVq0lISOjHkIQQYvDophZc72x0Lzx0KqUwF2W4V4KV+lRiFDuRsDWUycaKdzq2a23zj/xH0Fozd9KyIYxwYCnTcNetS01yTwnemoNdUunZ0Lax8wqx8woxEqIx56ejYiIliSGEGJZ0uwt7f4l7FG1J5WkXWATAMDCSYzFTk1CJ0agxsLCyEF0xJoZjXLES+0AlrnVZ6MNVHm3sfQdo21+CmTENc9EsKZMmhOg3Z5Ssff7558nIyOjvWIQQYlDZRWW43trodQqgCgvBcfEyjMkRQxCZEINPKcXnp9yAUooN5W93bNfa5p97HsHWNvMjVwxhhANPKYVKiMZIiMY+VOVO2u4t9prgsIvLsYvLUZPGY86bgTE1Th7qCCGGnLY1uvwQdm4B1r4D0OY5Y+hUxuQIjOMLLSl/qc8txMmM+Mk4Yy9xz8DZuB1d29C5gdZYO/dg5RZizkvDnJsu9ZyFEH12RslaSdQKIUYy3e7C+ngr1s49XvebGdMwV8yTCy0x5iil+Fzy9RjKZF3Z2o7tWmue3/sYGs2CyLOGMMLBY0waj3HJCvSy2VhZuVi794PL5dFOH6rC9fpHqNAgzLnpGOlTUM4+rd8qhBC9po/VYuUVYucVoOs8a3CfSoUEYqQmY6YlyxRuIbqhDIV5fGE9e+cerC3Z6JbWzo3a27E27cTeuRdz8SyMGVNRpjzEFUKcGbmbEEKMKfbBo7jWrkNX13nsUwF+OM5fgpEcOwSRCTE8KKW4LOnLGMrgo9LXO7ZrrXl+z2PY2mLR5HOHMMLBpUKDcZy7EHPxLKwde7B35KObWzza6doGXO9vQW3agZGZgjkrBRXgNwQRCyHGCt3c6h7tl1eI9rY46ql8nJhT4zHSk1FRk1CGlHARojeUw3TXuk9Pxvo0B2t7LrisTm10UzOu9zajtuViLpuDMSVOyiUJIXpNkrVCiDFB2zbWp7uxNu0E2/bYbyTG4LhgidSaEgJ3wvbSxGswMPig9N+d9r2w9//QWrM46rwhim5oKH8/HItnoeelu6cXb81B19Z7tNPNrVibdmJ9moOZPgVzbhoqLHgIIhZCjEbasrCLyt11aAvLvF7TdKIURnyUu8xBcqyM/BeiHyg/XxzL52BmTsfauAMrt8CjZJKursP17w8xoiZiLp+DET1paIIVQoxIff62bmtrw8fHpz9iEUKIAaFr6nG9uR674rDnTqcDx1nzMWZOlafeQpxEKcWqxC9hKIP3Sl7ttO/FfU9ga4ul0RcMUXRDRzkdmLOmY8ychr3/gDtpe/CoZ0OXC2tnPlb2Hoyp8Zjz0jEiJwx+wEKIEU9rjT5U5U7Q5hd5Tr/2Qk0Iw0ybgpGSiAoKGIQohRh7VHAgjguXYsxNw1q3DbuozKONXXEY+7k33Yv3LZuDMT5s8AMVQow4fU7WXn755cTGxvLLX/6S8PDw/ohJCCH6hdYaO2c/rg8/9brAhoqcgPPi5VKrTYguKKW4KOEqlDJ498DLnfa9vP/v2GiWR184RNENLWUozGkJGFPj0WWH3IuReblJQ2vsvcXYe4sxYiMx581AJUTJwyEhRLd0XYO7Dm1uIbq6ttv2KsAfIyURIy0ZFTFO+hkhBokxYRzG58/DLj2Ia12W14e4dkEpdmEZ5oypmItnyUMUIcRp9TlZe/ToUaqqqiRRK4QYVnRzC653NmHvL/HcqRTmwgzMhRlS+F+IbrgTtldioHj7wEud9r26/ym0tlkRc/EQRTf0lFKo2EiM2EjsI9VYWTnY+UVepybbpQexSw+iJoxzj7SdnoAyzSGIWggxXOm2dux9B9yjaEsPdv8Ch4mRHIeZloSKj0IZcl0jxFAxYiNxXrMKe+8BrA3b0DWnlEvSGmvXXqz8Qsw5aZjz0lG+MktZCOGpz8naSy+9lOeee47//Oc/XHLJJfIEVwgx5Oyiclxvb0A3NnvsU2HBOC5ahhE1cQgiE2LkuiDhCxjK5M3if3Xa/lrBGmxtcXbspUMU2fBhRIzDuGgZeulsrG15WLv2eh3Vr49W43pzPWr9dsy5qRgzp6F8nEMQsRBiONC2RpdUYuUVYO8rAZer29cY0ZPcdWinxqH8fAchSiFETyilMKcnYEyJxc7ei7U523Nh0nYX1pZs7Oy9mIsyMDKmycNbIUQn/TKy1jRN7rjjDr7//e8THh6Or69vR9JWKcXrr7/ezVGEEKLvdLsLa10W1o58r/vNmVMxz5ovSREhztDK+M+hlGJt0fOdtv+n8B/YWnNu3Oohimx4UcGBOM6ah7lwJvaufVjbcr0+PNINjbg+2gqbszEzpmPOTpFpkUKMIfbRauzcQuz8QnRDU7ftVVgwRmoyZmqSLFwoxDCnTBNzdipGWjLW1hysbbnQ3vlBjG5uwfXBJ6jteZhL52BMi5fBb0IIoB+Ste+8807Hv1taWqioqOi0XzobIcRgsA9V4Vq7Dn3Ms6ab8vfDPH8x5pS4IYhMiNHlvLjLMZTJ64X/6LT9jaJ/YmOxMu5zQxPYMKT8fDHnz8CYnYqdX+hejMxLH0VrG9anu7C25WKmJmHMS8cIDx38gIUQA043NmPnF2HlFaAPH+u2vfL1wZie4K5DOzlC7q2EGGGUrw+OpbMxZ03H2rQTa/c+0LpTG11Tj+v1j1BZE3Asn4sRGzlE0Qohhos+J2tvv/32/ohDCCHOiLY11tbdWBt3eK0RaSRE47hwKSrQf/CDE2KUOif2Ugxl8O+CZzptf7PoX9ja5oL4K4YosuFJOUzMGVMx0qagi8qwtu7GLj/s2dCysHbvw9q9z71q9LwZGNFSskWIkU67LPfiQrkF2MXlHokaD4aBkRiNkZqMkRSDcsj0aCFGOhUUgOP8xRhzUrHWb8MuKPVoow8epf1fb2EkxmAun4MxYdwQRCqEGA4kWSuEGLF0bT2uN9d7T3o4HDhWzMWYNV1GoQgxAM6KWYVC8VrBmk7b3y5+EbTm/Pgr5LN3CmUoVHIsRnIsdsVhrK057ps1L4kbu6AUu6AUI2qie6RtUizKkJ+nECOF1hpdcRg7txBrbzG0tnX7GjVpPGZaMsa0BHnILMQoZYwPw7j8XOzyQ1gfZ2FXHvFoYxeVYReXY6YlYy7JRAUHDkGkQoih1OdkLYBt27z11lts3LiRQ4cO8dhjj/HGG2+wYsUKgoKC+nTsv/zlL2zatImnn37a6/4//vGP/OlPf/K674orruD+++8H4Nxzz6W8vLzT/tWrV/Ob3/ymT/EJIQaf1ho7twDXB594XbxHTRqP8+LlKJlGLMSAWhFzMYYyeGX/U522v33gJWxtc2HClZKw7YIRNRHjsonoY7VY23KxcgvAZXm0sysOY792GDUuFHNeOkZqkoyyE2IY0zX17oXCcgvRtfXdtldBgRipie7FwsaHDXyAQohhwYiehLr6Yuz9JVjrt6Gr6zo30BorZz/WniLM2WmYC2agfH2GJlghxKDrc7K2oaGBm266iZ07d6K17rgp++lPf0pISAhPPfUUkyZNOqNjP/nkk/zhD39g/vz5Xbb5r//6L66++upO21544QUeeeQRbrjhho4YKyoqePTRR0lPT+9o5+fnd0ZxCSGGjm5uxfXuJux9Bzx3KoW5YCbmolko0xj84IQYg5ZFX4hSBi/ve7LT9ndLXsHG4uKEL0nC9jRUeCiOlYsxF2di7cjH3pGP9jICT1fX4npnI2rDdow5qZgZ02QFeCGGCd3Sir33gLvMQYWX2T6ncjowpsRhpk1BxUbKqHkhxiilFObUeIykWOzd+7A27UQ3nbIgqcvC+nQX9u69mAsy3LMG5aGtEKNen5O1v/vd79ixYwfTpk2jtLSUlpYWmpubsSyLkpISHnroIR544IFeHfPQoUPce++9ZGVlkZiYeNq2gYGBBAZ+Ni2gpKSERx99lLvuuouUlBQA9u7di9aaOXPmEBIS0vs3KYQYFuziClxvbUA3eq6YrEKDcFy0XOo7CjEElkadj4HBi/ue6LT9/ZJ/Y2vNJYlXS8K2GyrQH8fS2ej5M7B37cPanouua/Rop5uasdZvw9qyC3PmVMw5qaiQvs1iEkL0nrZs9IEKrNwC7MJSryPjO1EKIzbSPYJ2ShzKxzk4gQohhj1lGpizpmOkJmFl5WBtzYX2zrMHdXMrro8+Re3Iw1wyG2N6ojzoEWIU63Oy9u2338bpdPL0009z2WWX0dLSgr+/P6+++irnn38+GzZs6PUxc3JyCA0N5bXXXuPPf/6zR/mC0/nlL3/J1KlT+dKXvtSxbc+ePUREREiiVogRSrtcWOu2YW3P87rfTJ+CefZ8mRokxBBaHHUehjJ4Yd//oU+qwfph6X+wtcXqpC9LwrYHlI8Tc24aRmYK9t5irK270UeqPRu2t7vLJ+zIx5ie4C6REBE++AELMYZordFHjmHnFmLnF3mOgPNChYdipCVjpiZJ3UkhxGkpHyeOxZmYGdOxNu/Eyt7rUdde1zbgWrsOlZWLY/lcjPjJQxStEGIg9TlZW11dTWBgIKGhnWtDRkZG4uPjQ31997WaTnXuuedy7rnn9vp1u3bt4r333uPvf/87hvHZFOi9e/cSEBDAN7/5TbZv3054eDhXXHEF119/fad2Qojhxz5chWvtenRVjcc+5e+LuXIx5tT4wQ9MCOFh4eRzUMrgX3v/2ilh+3HZWrTWXJb8FUnY9pAyDczUJIyURPSBSqytu7FLKj0b2jZ2XiF2XiFGQjTmvHT3tGr5OQvRb3RDE3ZeIVZeAfpoTbftlb8vxnR3HVo1abx8HoUQvaIC/XGctwhzdiquDdu9ln/Th6tof/Ft93f/sjkYE+WBrRCjSZ+TtXFxcRQWFvLBBx90bGtububPf/4zTU1NTJ8+va+n6LEnn3ySWbNmsWjRok7b9+3bR319PatWreL2229n69at/OY3v6G2tpZvf/vbPT6+1rrTzedodeJ9joX3KoYvbWvsrBysjTvAtj32q/goHBcsQQUFyN/qGCL90/A3f9IKFIrn9jwGfPZ7Wlf+Jpa2+Fzy9ZK46CUVPxlH/GTsQ1XYWTnYew94jLQBsIvLsYvL3SvKz01DTY1HyUPpQSP90+ii29ux95di5xWiSyq9fuY6MQyMpBh3gjYhCmV+VlNS/ibEUJP+aYQaF4Lj0rOwKw5jrduG9lIT2y4uxz5QgZGSiLkkU0ojiRFnLPVPvXmPfU7Wfu1rX+Oee+7hG9/4Rse2OXPmAO6C2ddcc01fT9EjTU1NvPPOO/zoRz/y2Pe3v/2N1tZWgoLcHdf06dNpbGzk4Ycf5pvf/GaPR9fW1dWNiZG4Wmuamtw1QeWGWgyJ+kYcH2ZhHDzquc80cS2cgZ2WBFY71NYOfnxiyEj/NDJM9cvgstjreOXAk50uStaVvklzcxMXx16NoUb/92m/83PA0lmQMQVz137M/GKwvNTJrDiMq+IwOjgAa+ZU7Gnx4OzzJZ/ohvRPo4DWqMqjGPtKMIvKod3V7UvsieHYU+Owk2PgRDmmhoYBDlSI3pH+aYQL9IULF6EOVOL4NAdV4zl72dq9j/a8Qqz0ZKzMaZ/1R0IMc2Opf7K9DELrSp+v3K+44gpqa2v5wx/+QHPzZ3WbAgMDufnmm7n66qv7eooeWbduHbZtc/7553vsczqdOJ2di/hPmzaNpqYmamtrGTduXI/OERISgmmO/pUXT9xYh4aGjvoPixhetNbY+UVY72+BtnY45fOmIsJxXLwMNT5saAIUQ076p5FjeegFBAUG8Y89j6D1Zxcm26s34OPnyxVTvioJ2zMVGgoxUeizF2Dv3IO1Ix+aWz3bNbXi2LIbdu7DzExxryAd4Df48Y4R0j+NXPpYbUc5EV1/0sJ+XVz3q5AgjNREjNRk1DhZE0MMf9I/jRJhYeiZ07F378fatBO81M02cwqgoAxz/gyMzBSUY/TnL8TINpb6J8vbIIsu9MswixtvvJGrrrqKnTt3Ul1dTUREBOnp6R0jWQdDVlYW6enpHouI2bbNypUrueqqq/j617/esX3Xrl1MmDChx4lacGf5R/sfzwkn3utYeb9i6OmWVqx3N2PvLfbcqRTm/BmYi2d1mlYoxibpn0aOOZOWYiiTZ/L/3Clhu6XyfbS2uXLa1yRh2wcqwB9jcSbmvBnYuQVYWTloL6NtaGl1L1SydTdm+lR3iYSw4MEPeAyQ/mnk0M2t2HuKsHIL0N5m8pzKx4k5NR4jPRkVNUlWYRcjjvRPo4MyTYxZ0zFTk7C25WFt3e0e5HKyllasdVnYO/Mxl8zGSEmSPksMa2Olf+rN++u3OXFHjx7l4MGD1NfX43K5iI6OHpBkrWVZHDt2jODgYPz8Phsdkp+fz7Rp0zzaG4bBhRdeyOOPP05CQgLp6els2rSJxx9/nHvvvbff4xNC9J59oBLXW+vRDU0e+1RIEI6LlmHETBqCyIQQfZU5cRGGMliT9yds/dnT5E8OfojG5qppN0vCto+U04E5azrGzGnY+0uwtu72nnxyWVg787Gy92BMjcecl44ROWHwAxZiiGiXhV1U5h5FW1jmtSZ+J0phxEdhpCVjJMeipJyIEGKYUD5OHIsyMGdOxdqSjZW916NP03WNuN5cj8rKxbF8LkZC1BBFK4TorT5fcbhcLn7wgx/wyiuvdNqulOKqq67iRz/6Ub/Wea2srOS8887j/vvv54orrujYfvToUWbNmuX1Nf/7v/9LSEgIDz74IAcPHiQmJoZ7772XL37xi/0WlxCi97TLwlq/DWtbrtf9RloyjnMWoKTmkhAjWkbEAq5T3+Tp3D92Sth+evBjLG1z9fRbJWHbD5ShMKfFY0yNQ5cfwvo0B7uozLOh1th7i7H3FmPERGLOn+FeEGmUj2YQY5PWGn3wKHZuIfaeInSLl5Ihp1ATxmGmJWOkJKKCAgYhSiGEODMq0B/HuQsxZ6fi2rDd6yxFfeQY7S+9gxE3GXP5XIxJ4wc/UCFEryjdxyXXfvWrX/HEE08A4HA4CAsLo6amBpfLhVKKW265he985zv9EuxQsSyLHTt2kJmZOWZq1tbW1o6JmiFi6NiHj+Fauw5dVeOxT/n5Yq5cjDktfvADE8Oa9E8jW05VFk/l/h7L7lyvafbEJVydchumGv3fsYPNPlqNtTUHO7/otKMI1YQwzHkzMKYnSLmZMyT90/Ci6xqw8gqxcwvQ1XXdtlcB/h11aI2J4YMQoRCDR/qnscM+eBTr463YZYe6bGOkJOFYmokKlZJIYuiNpf6pN7nFPidrlyxZQnV1NV/72tf41re+hY+PD21tbTzyyCP85S9/Yfz48WzYsKEvpxhykqwVov9oW2Nn5eDasN1r4sCIj8Jx4VIZySK8kv5p5Mut2sbfc3+PZXdeZT1z4iKuSfmGJGwHiK5vxNqe554meWptu5OooEDMOakYM6fKrIZekv5p6OnWNux9B9yjaMsOdv8Ch4mRHIeZloyKn4zqx9mAQgwn0j+NLVprdFE5rnVZXgfGAGCamLOmYy7MQPn7Dmp8QpxsLPVPg5qsnTNnDkopsrKyPPbNnTsXrTXbtm3ryymGnCRrhegfuq4B15vrvT/pdZjuWkqzUqQAvuiS9E+jQ/6xnTyZ81tcduekYUbEQr6c8g1MQ+pCDhTd2oadvRdrWx660bNOeAdfH8yMaZizU+XhWQ9J/zQ0tK3RJRVYuYXY+0vA5er2NUbMJHcd2qnx8lBCjAnSP41N2tbYufuxNu5ENzR6b+Tr417IeU4qyiHXX2LwjaX+qTe5xT5/Gs866yzeeustKisrmTx5csf24uJimpqa+NznPtfXUwghRgErrxDX+1ugtc1jn4oIx7FqOcb4sMEPTAgx6FLCZ/HV9O94JGyzj2xBa5uvpN4uCdsBoo7flBmzU7HzC7Gycr2Pumltw/p0N9a2PMzUJIx56RjhoYMerxBdsY9UY+cVYOcVnf7Bw3EqLAQjLQkzNUmm/gohxgRlKMwZUzGmJ7pn13yyy3N2TWsb1vpt2Dv2YC6ZhZE2RQbOCDEM9Hlk7YYNG7jzzjvx8fHhmmuuISIigrKyMp577jmampq46667CAwM7Gi/atWqPgc92GRkrRBnTre04npvC/aeIs+dSmHOS8dcnIlyjP7Plug76Z9Gl73Vu3li9288RtjOmDCPr6TejsNwDlFkY4e2NbqozF3Xtrzr+nYARnKsu65t9MRBim5kkf5p4OnGZuz8IqzcAvSRY922V74+GNMTMdKSUJMj5PcixoTqlqM0ttd32qa1pqGhgaCgII/PQaAzmHF+EwYzRDFEdHML1pZdWDvyu6xjryaE4Vg+F5UQLX2mGBRj6fppUMsgpKam9ritUorcXO+rvg9nkqwV4szYJZW43tzgddqNCgnEcdEyjJjIIYhMjFTSP40++6pzeGL3b2i3O4+6Txs/h+vSvoVTEraDxq44gpWV455KfprLQyNqonukbVKsjL45ifRPA0O7XNgFZdi5BdjF5af92wTAMDASo91lDhJj5GGwGFOqW47yk82309juuaiebWsML312oDOEHy76kyRsxxBdU49r43b34qNdMGIiMVfMxYiUvwsxsMbS9dOglkHoTa63j3lhIcQIoV0W1oZtWFneH84YqUk4zl0odeKEEEwdl85NM7/H47t/TbvV2rE9t2obT+X+juvT/lsStoPEiIrAiDobXV2HlZWDlVsALsujnV1xGPu1w6hxIZhz0zHSkiUhJvqV1hpdcRg7txBrb7HXEkqnUpET3CU7pieiAvwGPkghhqHG9noa2+swldPju9NSNuYpi+i12+00ttfR2F4vydoxRIUF41y1AntuOta6LOySSo82dtlB7Gdfx5ieiGPpbFSYlI8RYjD1OVmbn5/fH3EIIUYJ+0g1rrXr0EerPfYpP1/M8xZhTk8Y/MCEEMNWclgqN8/8Ho/v+hVtJyVs86p28Pec33JD+nckYTuI1LgQHCsXYy7OxNqRj70jH+0lWaar63C9uwm1cQfG7BTMWdNRfrKitDhzuqYeK68AO7cAXdvQbXsVFIiRmoSRliR174U4idNw4mN27o8tLK8juSyr3WObGBuMSeNRXzgfXVyBa30W+ojn/Zu9p4i2fQfci44umiUPw4QYJLJ6hxCiX2hbY2/LxbVhO1ieI7GMuMk4LlyKCg708mohxFiXFJrCzTPv4vFdD9BqtXRszz+2k7/tfpAb0/8Hpymj8QeTCvTHsXQ2ev4M7N37sLblous8y9ropmasDduxPtmNOXOqe0XpkKAhiFiMRLqlFXvvAXeZg4rD3b/A6cSYGoeZmoyKjZRSHEII0QdKKVRiNM74KPfCoxu2o+tP+a63bawd+Vi5BZjzZ2DOTkX5yEN0IQaSJGuFEH2m6xtxvbkeu/Sg506HiWPpHIzZqXJDJYQ4rcTQadw8807+ekrCdm/1Lp7IcSdsTx0pJAae8nFizknDmJWCvbcYa2uO98Wd2tuxtuVibc/DSEnEnJeOERE++AGLYU9bNvpAOVZuIXZhqddyG50ohREb6a5DOyVOkgRC9JCtberaamh2NWJgEOQTSoAzEIVck4vOlKEw05IxpiVgb8/D+mSX56yatnasDduxd+zBXJKJkZ6MOqW0hhCif0iyVgjRJ9aeIqx3N3udIqsixuG4eDnGhHFDEJkQYiRKCJ3GLRl389iuX9Lqau7Yvq96N/+3+zf814z/xdeUKXhDQZmGuyZoSiL6QCXW1t1e69yhNXZeIXZeIUZCNObcdFRc5KhfNEKcntYaffgYdl4Bdn4Ruqml29eo8WEYqUmYqUkyM0eIXtBAQ3sddW3V2NoGwKU11a1HqGs7RpAzlECn1CAVnpTDxJw/A2PmVKxPdmFtz/eYNakbm3C9sxG1LRfHsjmopBj5jhein0myVghxRnRLK673P8HOL/TcqRTm3HTMJZmy6IwQotfiQ6ZwW8Y9PJb9S5pdn03FK6jJ5f92/5qvpX8XX4f/EEY4timlUAlRGAlR2IeqsLbmYO8tBi8LydrF5djF5aiJ4zHnp2NMjZdROGOMrm/Ezi/Cyi1AV9V02175+2FMT3AvXDdpvCQAhOildrudhvaDHUnaU1naorbtGHVt1fiZ/hiGpASEJ+Xni2PFPMzMFFwbtmPnF3l8z+uqGtpffR8jeiLm8nkYURFDFK0Qo4/S2suVtejEsix27NhBZmam16Lso43WmtraWkJDQ+UCWXhll1bienODZz0jQAUH4rhoGUZs5BBEJkY76Z/GltL6Qh7b9Uua2zv3NYmhKdw0QxK2w4murcfKysXK2Q/tri7bqdAgzLnp7kTcKJvKLv3TZ3RbO/b+EvcI65JKr4n8TkwTIykGMy0ZlRCFGgPX20L0t4ONZfwz/xE2VLyNUgaG6vxgTGvt0TfZ2kZrzYqYi7k06RoSQqaN+f5LeGcfPoa1fht2cXmXbYyp8e6RtuNCBjEyMdKNpeun3uQW+y1Z29TUREBAAABvvvkmVVVVrFy5kkmTJvXH4YeUJGuFcNMuC2vjdqysXK83XkZKEo5zF8hq4GLASP809pQ3FPNI9i88ErbxIVO5eead+EnCdljRza1YO/Oxd+Sfdpq78vPFyEzBzEwZNStLj/X+SdsaXXYQK7cAe18JtHe/wrwRNREjNQljeoJcOwhxhhrb63m7+EU2Vr5Hq6uZysYSj2StnxmAZbto153LlrmTtTaTA+PwMX2JDU7irJhVzJwwH1NG3Aov7AOVuNZtRR/2Urse3DMsM6ZjLspABco1mujeWLp+GtRkbW1tLd/85jdJTk7mRz/6ET/72c945plnABg3bhxr1qwhKSmpL6cYcpKsFQLso9W41q5DH6n23Onrg+O8RZgpiYMfmBhTpH8am8obDvBo9i9oam/otD0+ZAo3zbwTf0fAEEUmuqJdLuycAqysHHRNfdcNHSZm+hTMOWkjfiTOWO2f7GO12LkF2HmFXmfcnEqFBh2vQ5s84n/nQgwll93Ohop3eOfAy7S4mgBos1o7JWudhg9hvuPxNf2wLAsLF/XttR0lhk5N1p4Q5jueZdEXsHDyufIdKzxoW2PvKcLauB1d2+C9kY8Tc26au279KJtJI/rXWLp+GtRk7Y9+9COee+455s2bx1/+8heWLl2K1ppx48Zx5MgRVq1axUMPPdSXUww5SdaKsUzbGnt7Hq4N27yu1mzERuK4aJks/CEGhfRPY1dlQwmPZt9PQ3tdp+2xwcncknEn/g7pg4YjbWvsghKsT3ejDx7tuqFSGFPi3IuaRE4YvAD70Vjqn3RzC/aeYncd2tP9Xk/wcWJOS8BIS0JFTUIZo/vnI8RA0lqTU7WN/xQ+y9Hmg532nUjWmoaTcb7jOy0iZllWx72sS7toaKujvq0WW7s8krUn+Jp+LJh8DsujLyTcT+qRis60y8LeuQdrSza6pdVrGxXgj7l4FsaMqShTatYLT2Pp+mlQk7XnnHMOhw4d4l//+hcVFRV885vf5LrrruP2229n6dKlRERE8MEHH/TlFENOkrVirNL1jbje2uB9tW/TxLFsNsbsNLnpEoNG+qex7WBjGY9k/4KGttpO22ODk7h55p0EOIOGKDLRHa01uvwQ1qc52EVlp21rxERizk9HJUSPqM/5aO+ftMvCLipzj6ItKgfb++JFHZTCiI/CSE/GSIpFOWVKtRB9Vd5wgNcK1lBQk+t1v6UtjjYfJMgRjPOU5Ktl25inLPDYbrXSaDUSHzyl04Kep1LKYOaEeayIvpiE0Gl9fyNiVNEtrVif7sbanud1cA+AGheCuWwOxpS4UfkdKc7caL9+Ollvcot9vmqqqqpi3LhxpKen8+qrr6KUYsGCBYSGhhISEsKxY13UMhFCDGvWnmKsdzehW9s89qkJ43BcvAwjInwIIhNCjFWRgTF8PeNeHsn+OfUnJWxL6wt5NPt+bs24WxK2w5RSChUTiRETiV1Vg701Byuv0GvCzy47iF12EDUhDHPeDHc90zHwsHw40lqjK49i5xVg7ynucuTUyVREOGZaEsb0RFSQTJ8Woj/UtdXwVvELfHLwQ7oaa5U5cTHLoi7g99t/SGN7HZbV1Gm/bWsM7ZkIGe83kW/P+SkVDQf4qOwNDtTt82ijtU32kU/IPvIJ8SFTWBGzihkT5mEq6ZuFuw69Y/lczMwUrI07sHILPNY30dV1uP79IUbURMzlczGiJw5NsEKMEH0eWbtixQpqamrYsGEDV111FSUlJWzYsIFjx45x6aWXEhUVxXvvvddf8Q4JGVkrxhLd2obr/S3YeYVe95tz0zCXzkE5Rv9nQQw/0j8JgMNNFTyy8+fUtdV02h4VFM+tGXd3mvYphi9d34i1PR8rew+0db0YlQoKxJyTijFzKsrXZxAj7J3R1D/p2nqsvCLsvAJ0dV237VWgP0ZKknuxsInyIFeI/tJut7OubC3vlbxKq+V90ca4kClcnvwV4kOmAlDdcpTG9s61wrXWNDQ0EBQU5NE/BTqDGef3WfmZ4tq9fFz+JruOforWXY+gH+c3geXRF7Eg8mxZ7FN0Yh+pxlq/7bQzaYzkWHfSNjx0ECMTw9Foun7qzqCWQfj2t7/NW2+9ha+vL21tbcybN49HHnmEs846i8bGRq699lp+8IMf9OUUQ06StWKssMsO4npzPbrOcxqUCgrEcdFSjLjJQxCZEG7SP4kTjjRV8nD2z6lr7bzo4eSgOG6deTdBPrJw0UihW9uws/dibctDNzZ13dDHiTlrOubs1GE5YnOk90+6tQ173wF3mYOyQ92/wGG66wynJqPiJ6MMqUUoRH/RWpN99BNeL/wHx1qOeG0T5jueVUlfYnbEkm77nDPpn461HGFd+Vt8UvlBl4liAF+HP4siz2FZ9IWdkr5C2KUHca3L6rq2uVKYM6diLpo1LL/XxeAY6ddPvTGoydoDBw5www03cPDgQQIDA3niiSeYNWsW8+bNIyIigjVr1jB+/Pi+nGLISbJWjHbaZbmnrGTleExZATCmJ+I4byHKz3PhASEGk/RP4mRHmw/y8M6fU9vaueRSZGAMt2bcQ7CPjNYYSbTLws4vxMrKRVfVdN3QMDBTkzDmpWOMDxus8Lo1Evsnbdvokkqs3ELs/SXgcnX7GiNmEkZaMsbU+GE90lmIkaq0vpDXCtZQVLvH634f05dzYy9jRczFXhcF86Yv/VOzq4ktlR+wvvwtalqrumynlMGsiAWsiF5FXEhyr84hRi9ta+x9xVjrt6Nr6703cjrcszfnzUD5OAc3QDHkRuL105ka1GQtQFtbG3v37iUuLo6QEPdIljfffJNly5YRFDTya8dJslaMZnZVDa431qGPeKkv7euD49yFmKlJgx+YEF5I/yROVdV8mIezf0ZNS+cbyEmBMdwmCdsRSdsaXVzmXoys/PQjPI3kWMx56aioiUPeJ4yk/sk+Uu2uQ5tXdPrRzMepcSEYqcmYqYmoUCkzIsRAqGk9xtqi58g6tL7LNvMjV3BRwhcJ9R3Xq2P3R/9kaYtdRz7ho7I3KK33Xi7thMTQ6ayIuZj08XMxlIy6F6Atyz2LZnM2utn7SG0V4Ie5aJa77NEYyLsIt5F0/dRXg56sBXfCdvfu3Rw8eJBVq1Z11MQZDSRZK0YjbWvsnfm41mV5XbXTiJmE46JlqJDR8TkWo4P0T8KbYy1HeHjnz6hu6TzNbmJAFLdl3ENIL29qxfBhVxzByspxj/o8zSWrMTnCPdI2OQ5lDE3fMNz7J93YjJ1fhJVb4P0B7SmUny/G9ASM1GTU5AnD8j0JMRq0Wa18WPofPih7nXbL+yJ+iaEpXJb8ZWKDz2wARX/2T1priuv28VHZ6+RUZXW54BlAuP9EVkRfxPxJK/CVurYCd8kda2sOVlZul7M5VFgw5rI57hkc8t0z6g3366f+NOjJ2meeeYY//OEP1NXVoZQiNzeXSy65hLPPPps77rijr4cfcpKsFaONbmjC9dYG7AMVnjsNA8fS2Rhz04fshleIrkj/JLpyrOUIj+z8uUdtvwn+kdw2617CfGXRo5FMV9dhZeW4V5j28oDxBDUuBHNuOkZa8qAvhDkc+yftcmEXlGLnFmIXl5824Q2AYWAkRrvLHCTGyGKiQgwgW9tsP7yRN4qe8yjnc0K4XwSXJl3LzAnz+9SvDFT/dLT5EOvK3+TTgx/R1kWiGcDfEcjCye66tvJ9LOD4IqObd2Lt3t/ld5OKnIBjxVyMmMhBjk4MpuF4/TRQBjVZ+9prr/G9733vswMqxc6dO5k1axYAd955J1/96lf7coohJ8laMZpYew9gvbsJ3eJ5QaXGh+G4eLms5CyGLemfxOlUtxzlkexfUNXceeq8JGxHD93YjLUjH3vnHq/fYyeoAH+M2SmYs6YPWr314dI/aVujKw5j5xVg7SmGtvZuX6MiJ7jrAE9PRAX4DXyQQoxxxbV7ebXg6S7LCfiafqyM/zzLoi/EafS9hudA909N7Q1sOfgh68vf6jLxDGAok8yJi1gRfTExwYn9HocYeeyqGqz127ALSrtsYyTFYC6fO6zq1Iv+M1yunwbDoCZrP/e5z7Fnzx6eeOIJ7rrrLg4fPkxubi7PPvssP/3pT0lMTGTt2rV9OcWQk2StGA10axuuDz7Bzi3wut+ck4a5bI6MohHDmvRPojs1rcd4ZOfPOdp8sNP28f6T+HrGvYT5jexFT4WbbmvHztmPlZWDrmvsuqHT6V5pek7qgJf1Ger+SVfXYeUVYucVoGsbum2vggIxUpMw0pLkBliIQXKs5QhvFP2THYc3e92vlMHCyLO5MOHKfq25Plj9k2W72Hl0Cx+VvkF5Q/Fp2yaFpXBWzCpSw2dLXVuBXXYI17osdOUR7w2UwkxLxlySiQoOHNzgxIAa6uunwTSoydqMjAwCAwPZtGkTZ511FocPHyYvLw+AhQsX0tzcTHZ2dl9OMeQkWStGOrvsEK631nu9eVNBATguXIYRP3kIIhOid6R/Ej1R21rNwzt/5pGwDfeL4LZZ9xLuFzFEkYn+pi0be28x1tac09dhVQojJdFdImGAZo8MRf+kW1qx9x7Azi3Arjjc/QucToypcZipyajYSCl3JMQgaXU1817pa3xcthaX7X20+9RxM7gs6ctMDorr9/MPdv+ktaawNp+Pyt4g79j209a1neAfyfKYi5g3aTm+pozsH8u01tj7S7DWb0NX13lv5HBgzknFnD8D5eszuAGKATGW7u96k1t09PVkQUFB1NXVUV1d3Wn7rl27qK2tJSJCboiEGCrasrA27cT6dLfXWkDGtAQcKxcN2hRRIYQYDKG+4/jGrO/zSPYvONz0WW3uEwuRfX3W9yVhO0oo03BP309JRJdUYn26G7uk0rOh1th5hdh5hRjxUZjzZqDiIkfkTYG2bHRxOVZuAXZhGVhd1/AF3Inq2Eh3HdopcSifvk+pFkL0jK1tPj34MWuLn6ehrdZrmwn+kVyW/GVSw2ePyD7JG6UUyWGpJIelcqSpknXlb/HpwY9ot9s82h5tPsjL+57kzeJ/sWTySpZEnU+oLAw6JimlMKfGYyTFYu/ai7U5G93U3LmRy4X1yS7sXXsxF2ZgZEyXmaFiVOrzyNof/ehHPPfccyQlJVFZWUlLSwsXXnghH330ES0tLVx11VX85Cc/6a94h4SMrBUjkV1Vg2vtevThKs+dPk4c5y7ESE2S37EYUaR/Er1R11bDo9n3c6ixrNP2ML/xfD3j+4z3nzhEkYmBZB+uwtqag72n+LQLaqmJ4ZjzZ7hXmzb6PgV3IPsnrTX68DH3CNo9Reimlm5fo8aHYaYlY6QkypRRIYZAQU0urxasoaLhgNf9/s5ALoi7gsVR5+Hoh7q0pzMcrp8a2+vZXPk+G8rfpq6tpst2pmGSGbGYFTGriA6KH7wAxbCj29rdi4tuzYV27yPSVWgQ5tI5GNMSZLbICDUc+qfBMqhlEOrr67nhhhvIzc312DdlyhSeeuopwsNH9oIekqwVI4nWGnvnHlwfb/W6YrYRMwnHRcsGvHafEANB+ifRW/VttTya/QsOnpKwDfUN5+uz7mWCv6wwPFrp2nqsbXlYu/dBu6vLdio0CHNOGkb6lD6NOh2I/knXN2LnF2HlFqCrarptr/z9MFISMdKSURPDpZ8UYggcbT7Ifwr/we6jW73uV8pgSdRKLoi/gkBn8KDENJyun1x2OzuObObjsrVdJrJPmBKWzoqYi0kJnyV1bccw3djsni26a2+XD2HVpPE4ls/FiJPSfiPNcOqfBtqgJmsB2tvbefXVV9m0aRM1NTVEREQwf/58LrvsMpzOkT/VSpK1YqTQDU243t6IXVzuudMwcCydjTE3XZ46ihFL+idxJhra6nh01/1UNpR02h7qG85tGfcQESAX9qOZbm7F2rkHe0feaUekKj9fjMzpmLNSUIH+vT9PP/VPuq0de3+JexRt6cHTjg4GwDTdK2WnJaMSolGmJDSEGArNrkbePfAK6yvewrK9lydJCc9kddK1TAqMHtTYhuP1k9aa/TW5fFz+BnlVO07bdmJAFMuj3XVtnabUKR2r9LFaXOu3Ye8v6bKNkRCNuXwORsTIHjA4lgzH/mmgDGqy9pVXXsHf358LL7zQI4hnn30Wf39/rrzyyr6cYshJslaMBNa+A1jvbkI3t3rsU+PDcFy8DGOirIIuRjbpn8SZamyv59Hs+z1G8YT4hHHbrHuZGBA1RJGJwaJdLuycAqysXHRNFwuXADhMzLQpmHPTUONCen78PvRP2tbo0oNYeQXY+0q6nO55MiNqorsO7bR4qT0vxBCytMWWyg94q/gFGtvrvbaZFBjD6qRrSQmfNcjRuQ3366fDTRV8XLaWrYfWdbkAG0CgM5jFUStZErWSEJ+wwQtQDCt2xWGsj7O6XlhTKYzUJBxLMmU26Qgw3Pun/jSoydqUlBQmT57MBx984LFv3rx5+Pj4sHHjxr6cYshJslYMZ7q1DevDT7Fy9nvdb85OxVw+B+Xo83qCQgw56Z9EXzS1N/Bo9v2UNxR32h7kE8rXM+4d9JFOYmhoW2MXlGB9uht98GjXDZXCmBLnrmsbOaH7455B/2RX1WDnuhc+0w2N3bZXoUEYqcmYqUm9SiQLIQZG/rGd/LvwWY/a6CcEOoO5MOFKFk4+B1MN3X3kSLl+amirY1Ple2yoeKfLBdkATMPBnIlLWRFzMZMDYwcxQjFcaK2xC0qx1m1DV3fxt+IwMTNTMRfMkIeaw9hI6Z/6w4Ama7XW3HjjjZSWlgJQXl6Ow+Fg0qRJndq1tLRQVVVFUFAQW7d6r9czUkiyVgxXdvlhXG+uQ9c2eOxTgQE4LlyKkSCjxcToIf2T6Kum9gb+uusBSusLO20P8gnltox7iAyMGaLIxGDTWqPLD7kXIyv0nmg5wYiZhDl/hrvMgFLougaPmSxaaxoaGggKCvLon5S/b8foHt3cgr2n2F2H9nTJ4hN8nJjTEzBSk1FRE6WUkRDDwKHGcv5d+Cz5x3Z43W8aJsuiL2Jl3OX4O4Z+gb+Rdv3Ubrez/fBGPi57w6Pm/KmmjZvJipiLmT4uY0S8N9G/tG1j796PtWkHurHZaxvl54u5YCZGZgrKMfrzOSPNSOuf+mLAR9a+++673H777e4DHP9hdnWYSy65hAcffLC3pxhWJFkrhhtt2Vibd2J9sstrLTtjajyOlYtR/vIEUYwu0j+J/tDsauSx7AcorS/otD3IGcKtGXczOShuiCITQ8WuqsHemoOVVwi23WU7NT4MIy0Z68NP0S2eZYds28YwPGvGKj9fzAsWo4srsIvKT3sO9wsURkI0RloSRnKszI4RYphobK/n7eIX2Vj5Hlp7/xzPmDCPS5OuGVYLWI7U6yetNXurd/Fx+Vr2HMs+bdtJgTGsiL6YOZOW4jRG/ro5ond0WzvWtlysrTnQ5r2UhgoJxFwyGyMlSR58DiMjtX86E4NSBuHZZ5+loaGBhx56iODgYG6++ebPDqoUDoeD2NhYVqxYgY/PyC4CLslaMZzYx2pxrV2HPlTludPHieOcBe5VoOV3J0Yh6Z9Ef2l2NfH4rgc4UNe5hEygM5hbMu4mOih+iCITQ0nXN2Jtz8fK3tPlzZ7+/+zdd3xUVfo/8M+509J7T6ihhJpIr0GKNAFd7Mra235dd1ddXVz2u+7ub20rq19XxV6xi8oiUgRReu8tgPQUEkiflCn3nt8fISGTmQDJJDPJzOf9kpfJuWfufQaSJ5Nnzn2OzQ4UlgIBRiAoAKiXizRNhaLUe61oV4Gq6ppzRUdAGC5edBWxUdD1ToWS1qVZm5wRUeuwazZsyF2JFSe/RZXddcuSpJBOuCZ1FlIjens4ukvzhddPeRWnsTZ7GXYUrL9oX9sQQxhGJE3A8KQJCDWGezBCagtkRRXUzXug7jnc6BujIjYK+tEDeQdqG+EL+elyebRn7auvvoqQkBDceeed7pymTWOxltoCKSW03YdgX7MdsNudjitJcdBPGQURHuqF6Ig8g/mJWlK1vQpv730eJ8uOOIwHGoLxYP8/Izmks3cCI6+TFiu0PYeh7jwIaa50PGazA+eKa4q0igIEBUAEBQCKAlVVoYOoWXVbbakp1kpZ8ycm0mWxVgQHQunVteYPd68malOklDhQtAPfHf0U56rOuJwTagzHlC43YVD8aCjCeWV9W+BLr5/KraXYmLsS63NXNLqhGwDoFQMGxo/C6OTJbHHkh2RxGezrd0I7fKLROUrHROgyB3ITbi/zpfx0KR4t1tYqLy9HRUUFtPPvXmiahrKyMmzYsAH33ntvS1zCa1isJW+TFVWwL18P7USO80FFgW5EBnSD+vJ2DvJ5zE/U0iz2Kryz7wUcLz3kMB5oCMb9/WajQ2hXL0VGbYFUVWhZx6Fu2w9ZWFIzVr9YW5uHhABMRkhVhbA1eEPVVbFWr6vZvKxXKkSnRAgXrROIyLtyzafw3bFPcKR4n8vjesWAMSlTMa7DdJj0bXslvC++frKpVuwoWI/V2UtRUOnid6R60qLSkZkyFd0j+vjM86fLo+Wdhbp2O7Ts/EbnKL26Qj8ig4uevMQX81NjPFqsPX78OH7729/i2LFjjc45ePCgO5fwOhZryZvUX05BXbERsqra6ZiICod+ymgo8Xw3kPwD8xO1Bou9Cu/un4tjJVkO44H6YNzfnwVbAqQmIU9kQ922H+rxHOdibe08AE6ZqV6xVtclGUrvVCjdO0GY2nebMCJfVW4txfITC7D5zM+N9qXNiBuGqV1uRlRArIejax5ffv2kSQ2Hi/didfaSRgvrtRKDOyAzZQoy4kawr60fkVJCHs+Gfe2Oujdeneh00GX0hG5If+774mG+nJ8a8mix9n/+53+watWqRo/36dMHX3/9tTuX8DoWa8kbpNUG9eetUPcdcXlcl5EG3eiBl+x/R+RLmJ+otVjUary37984WnLAYdykD8T9/WajU1g3L0VGbY267whsn3wPqOrlFWsVAeh0MNx1LXSp3LyOqK2yaTasy1mOlSe/hUV1XiQBAB1CU3FN6ix0Du/h4ejc4y+vn3LNp7A2Zyl2FKyHqqmNzgs1hmNk8kQMTxyPYANXU/oLqWnQDhyFumGXU4ujOiYj9EP6QbkijZt7eoi/5CegabVFt++52rFjBxRFwZtvvonx48dj+PDhWLp0KX79619DCIHp06e7df558+bh17/+9UXnfPvtt+jZs6fTn5MnT9bNWbp0KaZOnYp+/fph+vTpWLNmjVtxEbUmLbcAtvnfuSzUiuBAGH41AfpxQ1moJSJqISZdAO7p+0d0j+zrMG6xV+GtPc/iROlhL0VGbY2IjarZWCwyDAgMcCrYArjQyzYqHIgIA0xGiJBgzwdLRJckpcSes5vxwtbH8f2xz1wWasNNUbgl7Td4+Iq/tbtCrT9JCumIm3o+gDlDXsb4jtcg0OA675ZbS7Hs+Ff456bf4esj76GgMtfDkZI3CEWBrm93GO76FXSjBgBGF6urLVbY126H7b2FUPf/Aqm1SNdQoiZzu1hrNpsRGRmJMWPGYNSoUTh06BC6dOmCP/3pTwgMDMRXX33V7HN/8MEH+M9//nPJeYcOHcKQIUOwbt06hz8pKTWNxDdt2oTHH38ct956KxYuXIhRo0bhoYcewtGjR5sdG1FrkKoG+4adsH2xDLLUuWG+0q0jDLfPgNIl2QvRERH5NqPOhLv7PIYekf0cxi1qNd7e+zyOs2BL9SkKRFgwREwkEBIIGPSA0QAREQoREwkRGlwzRkRt1unyY5i3+5/46MB/UFR91um4QWfCxM7X4U+D52Jg/Kg2u4EYOQozRWJKlxvxv0NfwXXd70ZMYILLeTbNio25P+JfWx/He/vm4mjJAbTQlj7UhgmDHvoh/WC8ZyZ0A3rVvMHagDRXwL58PWwffwfteDa/Lsjj3H4FGR0djcLCQuTm5iIjIwNFRUXYu3cvEhISYLPZkJvb9Hep8vPzMWfOHGzfvh1dunS55PzDhw8jLS0NsbGuewa9/fbbuOqqqzBr1iwAwJ/+9Cfs3LkTH374If7xj380OT6i1iCLy2BbuhbyzDnng0YD9FcOhtKnm8/fGkBE5E0GnRF39X0MH+5/CVlFu+vGawq2z+Gevo8jNaKXFyOkNkcREMFBQDCgqSrgBy2ziNq7Uksxlh7/AtsL1jVahBkYPwpTutyECFOUh6OjlmLUmTA8aTyGJo5FVtEurM5e6tTuqNaBwp04ULgTySGdkZkyBemxQ6FnX1ufJgIDoL9yCHQZvWDfsBNa1nGnOfJcMWzf/gilQwJ0owdCSYjxQqTkj9x+a3DEiBGw2+144IEH0LNnT0RFReH222/HlClTYLfbERcX1+Rz7t+/H+Hh4Vi0aBHS09MvOf/QoUPo1s11LzlN07Bjxw4MGzbMYXzo0KHYtm1bk2MjamlSSqi7D8H68XcuC7VKUhyMs6ZD17c7C7VERB5gUAy4o88j6BWd4TBuVS14Z98Ljf6iR0REbZtVtWDFyW/x3NbHsC1/rctCbefwHvj9gP+HW9J+w0Ktj1CEgt7RA/Cb9Dn4w4B/YkD8KCjC9RtrOeYT+CzrdTyz5RGsOrUIlTazh6MlTxMRoTBMzYTh1quhdEx0OUc7fQa2T7+H7fs1kCXOd8AStTS3V9Y+/vjjOH78OKKjo6EoCu677z48//zzdcfvu+++Jp9z3LhxGDdu3GXNLSoqwrlz57B161bMnz8fJSUlSE9Pxx//+Ed06dIFZWVlqKysREKC460PcXFxyMvLa1JcUkq/WP5e+zz94bl6m6ysgvrDRmjHs50PKgp0w9KhDO4DKAr/PYjA/ESeoxd6/LrX7/HxwVdwoHBH3bhNteDtvS/g7r6PoXtEHy9GSN7S3PzD3EXkPZrUsKtgI5ac+AKlliKXcyIDYnF1l5vRP2YIhBA+9f3K108XJId0xi09H8SUzjdiQ+4KbMr7EVV2582myizFWHL8C6w4+S0GJ4zB6ORJjbZTIN8g4qOhmzkByolcqOt2QJ4rdpqjHToO65GTUPr3gG5of4igAC9E6lv8KT815Tm6XayNiorC559/juLimi/ku+66Cz169EBWVhauuOIKDBgwwN1LXNThwzX943Q6HZ5//nlUVlZi3rx5uPXWW/Hdd9/BbrcDAIxGo8PjTCYTLBZLk65VVlYGxUU/E18jpURlZc0PLK7kbD3iZB70a3ZAVDt/HcrwENjHDoaMjQTK+c4dUS3mJ/K0GUl3wGq14lDJhZYIqlqFt3Y/h1u7PoSuYWyJ4G+E2QyDpgFWG9Bgt3FNk4Bid3yAXQM0DWazGTKAPWyJPO20+SiW5yxAToXzLc4AYFRMGJ0wBcPixkOvGFBWVubhCFsfXz85E9BhZNRkDAq/EruLNmFTwY8otjj3LVbVKqw9vQxrTy9Hz4j+GB43AR2D2ZrOp0WFANNHQzlyCrptByAqqhyPqyrU7fth23MIanoPqP26AXr+fG8uf8pPmqZd9twW+4qqf9GMjAwkJiaia9euLXX6Rg0bNgxbtmxBeHh43dhrr72GsWPH4ptvvsENN9wAALBarQ6Ps1gsCAwMbNK1wsLCoPODPmS11f7w8HCf/2bxBmm1QV2zDdreIzUDDb6mlP49ocscAGFgjySihpifyBvuDf8jPsl6DXvPba03KvHlyTdxZ+9H0DOqv9diI8+TQgdbcCBklaWmEHvhCKBJKIoA4JifRHAgAmKjIcJCPBorkT8rrj6HJce/wK6zGwHAxe9xAkMTrsSkztcj1BjufAIfwtdPFxOOq6KuwfjU6ThYuBOrc5bgeOkhlzN/Kd+HX8r3ISW0KzKTJ6N/zBDoFBbpfNbgCMgrekPblQV1yz7A4lhTgiah23kIOHK65o7YPqkQfrC4r6X5U35SVfXSk85zO7PYbDb87//+L3766Sds3rwZALBv3z7ceeedmDZtGp5++mmnVa0trX6hFgCCgoKQkpKC/Px8REREICgoCAUFBQ5zCgoKnFojXIoQwue/eGrVPld/eb6eouWdhX3pOsgS53fsRVAg9JNGQOmS4oXIiNoP5ifyNL3OgFm9fotPsuZhz9nNdeN2zYYPDryEO/s8grSoS/fYJ98gwkNhvP+GmmJtPVJKmM1mhISEOOUnEWhioZbIQyz2Kvx0ejF+zv4eds3mck63iD6YnnobkkM6eTg67+Hrp4vTCR36xg5C39hBOF1+DKuzl2D32c2Q0nklXHb5MXyaNQ/fmz7HqORJGJY4FoH6YC9ETa1NGAxQBveDrl8PqJv3Qt2VBTQsuJkroa7cCG3nQehHDYDomsLvsybyl/zUlOfndtn/jTfewMKFC1FWVoacnBwAQHZ2NqSUWLx4Md555x13L3FRn376KYYOHYrq6uq6MbPZjBMnTqBbt5rbEwYMGIAtW7Y4PG7z5s0YOHBgq8ZGVEtqGuwbd8H2+VKXhVoltQMMt89goZaIqI3SKXrc1ushZMQ5blhq12x4f/+LDn1tyfeJsBAo8dFOf2RMhMtxFmqJWp8mNWw5sxrPb/0jVp5a6LJQGxOYgLv6PooH+j/pV4VaapoOoV0xq9dvMWfI/+HKDtMQoA9yOa/UUoTvj32Gf276Hf77y3wUVTu3USDfIAJM0I8ZBOOd10Dp1RVwUXSThSWw/XcV7F8uh5bHrwVyj9vF2kWLFkEIgZdffhnJyckAgOuuuw6vv/46pJRYtGiR20HWp6oqzp49W1ecHTt2LKSUeOKJJ3DkyBHs3bsXDz/8MKKiovCrX/0KQE0f3e+//x7vv/8+jh49in/96184ePAg7rjjjhaNjcgVWVwG2xfLoG7cDTRsKG0wQD9xBPQzxrI5ORFRG6cTOtyS9j+4Im6Ew7iq2fHhgf/D/sLtXoqMiMi/HS05iJd3/C++PPQWyqwlTscD9EGYkToLfxz0HPpED/T51VvUMiICojGt6y3436H/wTWpv0ZUQKzLeRa1GmtzluHZLY/iw/3/hxOlhz0cKXmKCA+FYcpoGG67GkqnJJdztJx82D5bAtt3P0MW+14PbPIMId3ccq1///4IDAysa4FQX+2K1927d7t45OWZPXs2cnJyMH/+fAA1q3bHjx+PZ599FjNnzgQAHDx4EHPnzsXu3bshpcTIkSPx5JNPIjExse48CxcuxLx583DmzBl069YNjz/+OIYPH35ZMaiqil27diEjI8NvetaWlpb6Rc+Q1iSlhLb3COyrtwI2u9NxJTEW+smjICLDvBAdUfvE/ERtgSY1fH7oTezIX+cwrlN0mNXrYfSLGeylyMibmJ+IPO9cVT6+P/ZZg57iFwihYETieEzsfB2CDaEejq7tYH5qGZrUsO/cNqzOXoKTZUcuOrdTWDdkpkxF35hB0AnfryH4K+1kLuxrtkOeLXI9QVGg69cDumH9IYKbtmeSv/Cn/NSU2qLbxdoxY8agoKAACxYsQJ8+ferGd+zYgVtvvRWxsbFYu3atO5fwOhZrqalkRRXsKzdCO3ra+aAQ0A1Lh25oPzYgJ2oi5idqKzSp4avDb2PrmTUO44rQYVav36J/7BAvRUbewvxE5DlV9kr8eOq/WJuzDKrmvCgCANKi0jGt661ICGabMeanlney7AhWZy/F3nNbXfa1rRUZEIPRyZMxJOFKBOhZrPNFUpPQDh2Hun4nZJnZ9SSjAbqBfaAb2BvCyI3E6/On/NSU2qLbG4xNmDABn3zyCW699VaMHDkSkZGRyM/Px6ZNmyCEwIQJE9y9BFG7oh07DfsPGyErq5yOicgw6KeMhpIQ44XIiIiopShCwQ097oOAgi1nfq4b16SK+QdfwW3Sub8tERG5R5UqtuT9jOUnFsBsc317cVxQMmak3saNH6lVdQrrjtt7d0dR9VmszVmOLXk/waJWO80rrj6HRUc/xvITCzA0cSxGJU9qtJ0CtU9CEdD16gqleydou7Ogbt4LWe24CSmsNqgbd0HbfQi6ERlQ+nbjwi26KLdX1paXl+P222/HwYMHa04oBGpPmZaWhvnz5yM0tH3fcsKVtXQ5pNUGdc02qHtc9yjS9e8BXeYgvpNG5AbmJ2prNKnhmyPvY1PeKodxIRTclvY/yIi7vJZL1P4xPxG1rsPFe7Ho6Mc4U5Ht8niQIQSTOl2HYUnjedt5A8xPra/KXoktZ37G2pxlKKkubHSeEArSY4cgM3kqOoalejBC8hRZbYG6dR/UnQcBu+pyjogMh27UFVC6dfT770l/yk8ebYMAAFarFQsXLsSmTZtQUlKC8PBwDB8+HNdeey2MRqO7p/c6FmvpUrQz52BfutZlA3ERFAj9VcOhpHbwQmREvoX5idoiTWr49pcPsTF3pcO4EApu7vkgBsaP9FJk5EnMT0Sto6AyF98d+wQHC3e5PK5TdBiZNBETOl6LIEOIZ4NrJ5ifPEeVKvae3YrV2UtwuvzoRed2Du+BzOQp6BszCIrgKktfI8sroG7YBfXAUeeNxs9TkuKgyxwIJSnOw9G1Hf6UnzxerPV1LNZSY6SmQd2yF+rG3S4TsJLaAfoJw9lMnKiFMD9RWyWlxMJfPsT63BUO40II3NTzAQyKH+2lyMhTmJ+IWlalzYwfTn6DDbkroUnXq9P6RA/EtK63IDYo0eVxqsH85HlSyvN9bZdgX+E2XKzsEhUQi9EpUzAkPhMm9rX1OdrZIqhrd0A7kdPoHKVbR+hGDYASFe7ByNoGf8pPrd6zdsmSJQgMDMTYsWOxZMmSS86fOnVqcy5D1KbJknLYl66FlnfW+aBBD/2YwVD6dff5hENERDVF2Wu73QFF6LA2Z1nduJQSXxx6E5rUMCRhjBcjJCJqH1TNjg15P+KHk1+jylbhck5SSCdM73obukf2cXmcyNuEEOgc3gOdw3vgXFU+1uUsx5YzP8OqWpzmFlWfxX9/+QjLTyzAsMRxGJU8CRGmKC9ETa1BiY2CMnMCtFN5sK/dDpnv3CZD++UUtKOnoevXHbph6RAhQV6IlNqSZq2sTUtLQ2JiIn766SekpaVdtBglhMCBAwfcCtLbuLKW6pNSQtv/C+w/bQVsNqfjIiEGhimjISLDvBAdkW9jfqK2TkqJ7459gjXZSx3GhRC4vvu9GJp4pXcCo1bH/ETkHiklDhbtwnfHPsHZyjyXc0KM4ZjS+QYMThjD28abgPmpbaiyV2BT3k9Yl7McpZaiRucpQof02KHITJmCDqFdPRghtTapSWhHTkBdtwOy1Ox6kkEP3cDe0A3q6xf73fhTfmr1lbUAHJbxX6zeyy4L5EtkZTXsKzdC++WU80EhoBvWH7oh/SF0fPFIROSPhBCY3vU2KEKHn08vrhuXUuKrw29DkyqGJ433YoRERG1PXsVpLDr6MY4U73N5XK8YkJkyGeM6XIMA3iZO7VSgPhhjO0xDZvJk7D63GatPL0GO+YTTPE2q2FmwATsLNqBrRBoyk6eid/QVfIPCBwhFQNezC5RuHaHtOQx1027IqgarrW12qJv2QNtzGLph6VD69WB9wQ81q1iblZXl8mMiX6Ydz4Z9+QbIyiqnYyIiDPopo6AkxnohMiIiakuEELi6y81QhMCqU985HPv6yHvQoGFk0lVeio6IqO0wW8uw/OQCbMr7CVJqLuf0jx2KaV1vQVQAX2eTb9ApegyIG4krYkfgWGkW1mQvxYGiHS4Xuh0rycKxkizEBCZgdMpkDIofDZMuwAtRU0sSOh10V/SC0jsV6rb9ULcfAOx2hzmyshr2VZshdhyEbtQVULp38vmVp3RBs1fWEvkLabNDXbMd6m7Xb0zo+vWAbswgv7hFgYiILo8QAlM63wQFOqw8tdDh2LdHPgCkxMjkiV6JjYjI22yaDetylmPlqYWw2J0XQgBAh9CumJE6C13Ce3o4OiLPEEIgNaIXUiN64WxlHtbmLMfWM6th06xOc89VncG3Rz7AshNfYXjieIxMmohwU6QXoqaWJExG6EdeAV3/HlA37oa6/xenjctlSRnsi1dDJMZCP3oAlJQEL0VLntSsnrV/+9vfLv8CQuCpp55q6iXaFPas9V/amXOwL10HWVzqdEwEBkA/cQSU1A5eiIzIPzE/UXsjpcSKk9/gh5PfOB2bkToLmSlTvBAVtQbmJ6JLk1Ji77mtWHz8MxRVFbicE2aKxNQuN2FA3Eje9t1CmJ/aj0qbGRvzfsT6nB9QZi1pdJ5O0SE9djjGpExFckgnzwVIrUorLIG6bge0o6cbnaOkdoBu1AAo0RGeC6wV+VN+akptsdkbjF3OX6KUEkIIHDx4sKmXaFNYrPU/UpNQt+6FunE3oDnfkqV0SYF+4giIYPbMIvIk5idqr344+Q1+OPG10/i0rrfiyg5XeyEiamnMT0QXl11+HIuOfYxjJa7vVjMoRoztMA1jOlzN27xbGPNT+2PXbNh9djNWZy9BrvnkRed2i+iDzJQpSItK5xscPkLLPgP7mu2QZ865niAEdH26QTc8HSI02LPBtTB/yk+tvsHY4MGDmxUYUXsgS8phX7YOWq6Ld/v1eujHDILSv4fPJxIiImo5EzvNhCIULDv+lcP44mOfQkJibIdpXoqMiKh1lVmKsfTEV9iWv6bRzacHxI/C1C43IcIU5eHoiNomvWLAwPhRGBA3EkdLD2JN9hIcKNzpcu4vJfvxS8l+xAYlIjN5CgbGj4JRZ/JwxNSSlJQEGG6ZCu3IKajrdkCWlDlOkBLqviNQs45DN7A3dIP6QJiM3gmWWkWzVtb6G66s9Q9SSmj7f4H9562A1eZ0XCTEwDB5FERUuBeiIyLAf/MT+Y5Vp77DkuOfO41P6XIjxne8xgsRUUthfiJyZFOtWJ2zBKtOLYJVtbic0ymsO65J/TU6hqV6ODr/wvzkGwoqc7Emeym25a+FXXP+fbVWkCEEIxInYETyVQgzRnguQGoVUtWg7T0MddNuyMpql3NEoAm6of2hpPeEaGc1K3/KT63eBsEVs9mMffv2oby8HBEREejbty8CA33jFnEWa32frKqGfeUmaEdc3GIiBHRD+0E3NB1Cx9tKiLzJH/MT+Z6fTy/G4mOfOY1P7nwDJnS61vMBUYtgfiKqIaXE7rObsPj4ZyipLnQ5JzIgBld3uRnpscP4/eIBzE++pcJWjo25P2Jd7g8wW533VqmlU/QYEDcSmcmTkRjS0YMRUmuQVhvUbfuhbt8P2Owu54jwUOhGXQGle2cIpX18r/tTfmr1NggNvfrqq3j33XdRXX2hyh8YGIgHH3wQ999/f0tcgqjVaMdzYP9hPWSF8060IjwU+imjoCTFeSEyIiLyRVd2mAZF6LDo6McO48tOfAVNqpjY+TovRUZE5J6TZb9g0dGPcbLsiMvjJl0AxnWcgczkKTDoeMsuUXMEG0IxodO1GNPhauwq2IA12UuRV+G8IZWq2bH1zGpsPbMa3SP7YkzKVPSM7O/zBTFfJYwG6EdkQNe/B9RNu6HuPQI0WHspS8th/34NRPx+6EcPhNIx0UvRkrvcLta+/fbbePXVV53GKysr8dJLL8FoNOLOO+909zJELU7a7FDXboe6y/UmB7q+3aG7cjCE0eDhyIiIyNdlpkyBEAr++8tHDuM/nPwGGiQmdbqOv0wRUbtRUl2IJSe+wI789S6PCyEwKD4TUzrfgDBTpIejI/JNBsWAwQljMCg+E0dK9mFN9lJkFe12OfdI8T4cKd6H+OAUZCZPxoD4UTAo/D23PRIhQdBPGA5lQG+o63ZA++WU0xyZXwjbgh+gdE6GbvRAKLHMu+2N220QrrzySuTn52Pq1Kn4wx/+gPj4eBQUFOC1117Dt99+i6SkJKxataql4vUKtkHwPVp+IexL10IWOd82IgJN0F01ArpuvFWEqK3xh/xE/mV9zg/49pcPncbHd7wGkzvfwK/zdoT5ifyRxV6Fn7K/x+rT38OmWV3OSY3ohRmps5Ac0tmzwVEd5if/caYiG2tzlmF7/rqL9rUNMYRhRNIEDE+agFAj92Rpz7ScAqhrt7veIB0AhIDSqyv0I6+ACA32bHCXwZ/yk0d71mZkZEAIgW3btjlcTNM0DBw4EFJK7Nq1y51LeB2Ltb5DahLqtn1QN+wCNM3puNI5GfqJIyBCgjwfHBFdki/nJ/JfG3N/xNdH3nMaH9thOqZ2uYlf6+0E8xP5E01q2J6/DktPfIkyS7HLOdGB8Zje9Vb0iR7I7wkvY37yP+XWUmzMXYkNuSthtpU1Ok+vGDAwfhRGJ09GQnCKByOkliSlhHb0NNS1OyCLG+ljrNdBl9ELuiF9IQJMng3wIvwpP3m0Z+3AgQOxefNmmM1mhIdfeEemqKgIVqsVY8aMcfcSRC1ClpbDvmwdtBwX7zjp9dBnDqzZPdHHEwQREbUtw5PGQwiBBYffdRj/6fR30KSKaV1v5c8mImozjpVmYdHRj5Fdftzl8QB9ECZ0vBYjkyfyNmsiLwk1hmNi5+swtsN07ChYj9XZS1FQmeM0z67ZsDnvJ2zO+wlpUenITJmK7hF9+LqjnRFCQNetI5SuKdD2/QJ14y7nPXnsKtRt+6DtOwLd0H5Q0tMg9L6/GLG9cntl7f79+/HAAw8gPj4e99xzD+Li4nD69Gm89957yM3NxfPPP4+4uAubM/Xv39/toD2NK2vbNykltANHYf9pC2B1vhVExEdDP2U0lCje/kHU1vlafiKqb8uZ1fjq8Nto+NJsdMoUzOh6G7/m2zjmJ/J1RdVnsfjYp9hzdovL40IoGJY4DpM6XYcQY5iHo6OLYX4iTWo4XLwXq7OX4EjxvovOTQzugMyUKciIG8E3XNopabVB3X4A6vb9LmsgACDCQqAbkQElrSuE4r284E/5yaNtEHr16nXZc4UQOHDggDuX8woWa9svWWWBfeVGaEdOOh8UAroh/aAb1h/CD/5diXyBL+UnIle2nlmDLw+/5VSwHZU8Cdek/ppf920Y8xP5qmp7FVaeWoi1OcuganaXc3pE9sOM1Fm8jbqNYn6i+nLNp7A2Zyl2FKyHqqmNzgsxhmNU0kQMTxqPYEOoByOkliIrqqBu3gN1z2GXbSABQMRFQT96IJROSR6OroY/5SePtkFoSq3XzbowUZNoJ3JhX74esqLS6ZgID4F+8mgoyXEuHklEROQdgxMyoQgFnx96E1JeeFG9Lmc5NKnh2m63QxGKFyMkIn+hSQ1bzvyMZScWwGx13QMxLigJ07vehrSodJ//JZvIVySFdMRNPR/AlM43YkPuSmzIW4lKm9lpntlaimUnvsLKUwsxKH40MlOmIC7IOwU9ah4RHAj9uKHQXdEL9nU7XC5ikwVFsH29AkqnJOhGD4ASF+2FSKkht4u1P/74Y0vEQdRipN0Ode0OqDsPujyu69MNuisHQ5iMHo6MiIjo0gbGj4IQAp9lveFQsN2QuwKaVDGz+10s2BJRqzpcvA/fHfsEeeZTLo8HGoIxudP1GJY4DjrF7V8picgLwkyRmNzlBozrOAPb89dhTc5SnK3Mc5pn12zYlLcKm/JWoXf0FchMmYrU8F58g6YdEZFhMEy/ElruWahrt0PLyXeao53MhXYyF0qvrtCPvAIiLMQLkVItt3+yJicnt0QcRC1CKyiEfek6yMISp2MiwATdVcOh697J84ERERE1wYC4kVCg4JOseQ4F2015qyAhcV33u1mwJaIWd7YyD98d+xQHCne4PK4IHUYmT8RVHa9FkIG/yBP5AqPOhOFJ4zE0cSyyinZjdfYSHC1x3b7yQOFOHCjciaSQThiTMhXpsUOhZ1/bdkNJioW4cRLksWzY1+1wWTfRDh6D9fBJ6DJ6Qje0P0SAyfOBkvvF2ieffPKix4UQeOaZZ9y9DNFFSU1C274f9vU7XfZiUTonQz9xBERIkBeiIyIiarqMuOEQQsHHB191KNhuzvsJmtRwQ497WbAlohZRaTNjxamFWJ/zAzTpuodl7+gBmNb1Ft4GTeSjFKGgd/QV6B19BXLMJ7A6eyl2FWx0mRNyzSfxWdbr+P7YZxiZPBHDE8fzDZx2QggBkdoBhi7J0A4chbphF6S5QetIVYW6/QC0fb9AN6QflCvSIPS8i8KT3N5gLC0trdHl71JKCCFw8KDr29HbC24w1rbJMjPsy9ZBy3Zeyg+9DvrMQVDSe7aL50JEF9fe8hNRS9hzdgs+Pviq0y9Lg+JH48ae97Ng20YwP1F7pGp2bMpbhWUnF6DKVuFyTmJwB0xPnYUekX09HB21FOYnaq4SSxE25K7AxrwfG80RAGDQmTAkPhOjkichNijRgxGSu6TNDnXHAahb9wFWm8s5IjQYuhEZUHqlQigtm0P8KT95dIOxkSNHOvyFqqqK8vJyZGVlIS4uDpMnT3b3EkQuSSmhHTwG+6rNLpOKiIuCfspoKNERng+OiIiohfSPHYLbxe8x/+DLDrs2b8tfCw0SN/d8gAVbImqyrKLdWHT0YxRU5ro8HmIIw6TO12No4ljmGCI/FWGKwtQuN2F8x2uw7cwarM1ZjnNVZ5zm2VQL1ueuwIa8legdNQCZKVPQNbzxhX3UdgiDHvqh/aHr1wPq5j1Qdx9yultZllfAvnw9xPYD0I8eCNE5if+2rcztYu27777rcvzAgQO48cYbkZqa6u4liJzIagvsKzdBO3zC+aAQ0A3uC93wdAg/WAlNRES+r2/MQNze+/f46MB/oGr2uvEd+eugSRW3pP0GOsGfeUR0aWcqsvHdsU9wqGiPy+M6RY/RyZMxvuM1CNSzhRgRASZdQE27g6QJOFC4E2tyluBYSZbTPCkl9hdux/7C7egQ2hWZKVPQP2YINyJsB0RQAPRjh0B3RS/Y1++Edui40xx5rhi2b1dC6ZAA3eiBUBJivBCpf3C7DcLFTJs2DZqmYcmSJa11CY9gG4S2RTuZB/vy9ZBm59swRFgI9JNHQUmJ90JkRNTa2np+ImptBwt34YMDLzkUbAEgPXYYbk37DX8Z8iLmJ2rrzNYyLD/5dc1GhdJ5jwegZiX/1V1uQXRgnIejo9bE/ESt4XT5MazJXopdZzc1mlMAINwUhVHJkzAscSwC9cEejJDcoZ05B3XtdminnVdS11J6doF+5BUQEaHNvo4/5SePtkEoLCx0+FxKCavVim3btuH48ePQswkxtRBpV6Gu2wF1h+udKZXeqdCPHQJhMno4MiIiIs/oFZ2Bu/o8ig/2vwS7dqEF0O6zm6BJFbN6/ZYFWyJyYNdsWJfzA1aeWohqe6XLOckhnTEjdRZSI3p5ODoiaq86hHbFbb0ewtVdbsa63B+wKW+VyxxTainC98c+w4qT32BIwpUYnTyZbwi1A0pCDMT1EyFP5MK+djvkuWKnOdqh47AeOQldRk/ohvaHCAzwQqS+ye2Vtb16XfwHenp6Oj7//HN3LuF1XFnrfVpBEezL1kKeK3E6JgJM0E0YBl2Pzh6Pi4g8qy3mJyJvOFy8F+/t+7dDwRYA+sYMwqxev4VeMXgpMv/F/ERtTe3tyN8d+xSFVS424gUQZozAlC43YWD8KPal9WHMT+QJFnsVtuSvwdrspSiqPtvoPCEU9I0eiMyUqegc1p1fk+2A1CS0g0ehrt/l8g5nAIDRUNOOckBvCMPlLxzwp/zUlNqi28XatLS0Ro/FxcXhjTfeQO/evd25hNexWOvFWDQJbccB2NfvBFTV6bjSKQn6iSMgQnk7BZE/aEv5icjbDhfvw/v7/g2bZnUY7xM9EL/u/TALth7G/ERtSY75JBYdnY+jJQddHtcrBlzZYRrGplwNkz7Qw9GRpzE/kSdpUsO+c9uwJmcpTpQevujcjmHdkJk8Bf1iB7P3fjsg7XZoO7Ng37IXsFhdzhEhQdCNyIDSuxuEcul840/5yaPF2i1btjiNKYqCsLAwdOvWDYrS/t+hZbHWS3GUmWFfth5atoseKXod9KMGQMnodVkJgIh8Q1vJT0RtxS8lB/DuvrmwqRaH8d7RV+DXvX8PAwu2HsP8RG1BmbUEy45/ha35q9HYr3lXxI3A1C43ITKAG8P4C+Yn8paTZb9gTfZS7Dm35aJ9bSMCojE6eTKGJFzJjQ3bAVllgbplD9Rdh1wuqgMAER0B/egBEF1SLpp3/Ck/ebRY6w9YrPU89eAx2FdtdvlujYiNgn7qaCjREZ4PjIi8qi3kJ6K25mjJQby77wVYGxRs06LScUefR1iw9RDmJ/Imm2bDmuwlWHVqESxqtcs5ncK6YUbqLHQK6+7h6MjbmJ/I24qqz2JdznJszvup0RwFACZdAIYkjsXo5EmICoj1YITUHLK0HPYNu6AdPNboHCUlHrrRA6EkxkKWmSGrHF+vSilhNpsREhLilJ9EoAkiLKRVYvcGjxVrzWYzli5dil27duHcuXNQVRXR0dHIyMjA9OnTERLiG3+pLNZ68NrVFth/3Azt0HHng0JAN7APdCMyIPS+/+9ARM74ywaRa8dLD+Gdvf9y+gWoZ1R/3Nn7ERh03HyztTE/kTdIKbH77CZ8f/xzFFefczknwhSNq7vejIzY4fza9FPMT9RWVNursOXMz1ibs6zRnAXU9LXtHzMEmSlT0CmsmwcjpObQCgqhrt0B7WRuo3NEx0TIo6chrTanY5qmubwrXwSaYLz/Bp8p2HqkWLtixQrMmTMH5eXlLo+HhITgn//8JyZNmtSc07cpLNZ6hnYqD/Zl6102rBZhwdBPHgUlJcFj8RBR28NfNogad6L0MN7e+7xTwbZ7ZF/c1edRGHUmL0XmH5ifyNNOlx/Df4/Ob7QnpFFnwrgOMzAmZSrfsPFzzE/U1qhSxd6zW7E6ewlOlx+96NxOYd0xJmUq+sYM4kaIbZx2Ihf2tdshzxY5HZM2O3CuBDAZgOAgoF47S01ToSgNam12FdA0GO+/AUp8dCtH7hmtXqzdsWMHbr/9dtjtdgBASkoKYmJqeh4VFxfj1KlTkFJCp9Phk08+QUZGRtOfRRvCYm0rX8+uQl2/E+r2/S6PK726Qj9uKISJLzKJ/B1/2SC6uJNlR/DW3udhsVc5jHeL6IO7+z7Ggm0rYn4iTymxFGHJ8S+wI3+dy+NCCAyKz8Tkzjcg3BTp4eioLWJ+orZKSomTZUewOnsJ9hVuv2hf26iAWIxOmYIh8ZncGLENk5qElnUM6oZdkGXmC+M2O3CuGBACUBQgOBAiKAAQAqqqOtXapM0OWG1+W6zVN+cCb731Fux2O6644go8//zz6Nixo8Px/Px8/PWvf8Xq1avx9ttv47XXXmvOZcgPaGeLYV+6FvJcsdMxYTJCN2EYdD27eCEyIiKi9qdTWHc80O9JvLX3OVTbK+vGfynZj3f3vYC7+/4RJl2AFyMkouayqNVYffp7/HR6MWya6124u0akYUbXWUgJ5etnImr7hBDoHN4DncN7oLCqAGtzlmHLmZ+d+vADNX1v//vLR1h+YgGGJY7DqKSJiAjwjSKeLxGKgK53KpQenaHtyoK6ZS9kdYN/TykBcyVkZTUQEggYub9CQ81aWTt8+HCUlJRgxYoVSElJcTmnoKAAV155JSIiIrBhwwa3A/UmrqxthWtoEtrOA7Cv2+ly90ClYyL0k0ZChAa3yvWJqH3iyhCiy3O6/Bje2vMcquyOrYW6hKfh3r5/5IqUVsD8RK1Fkxp2FmzAkuNfoNTifGspAEQFxmFal1vQL2Ywv/7ICfMTtSdV9gpsyvsJ63KWN5rzgJq+tumxQzEmZSo6hHb1YITUFLLaAnXLPti37AHyC2tW1jbIQ1KnQIkMB3QX2lxwZW0zlJeXIzQ0tNFCLQDExcUhKioKJSUlzblEnXnz5mHjxo2YP39+o3OOHDmCF154Abt374aiKBg8eDBmz56NpKSkujnjxo1DTk6Ow+OmT5+OuXPnuhUfNZ0sr4B9+Xpop/KcD+p10I8cAOWKXhAKX0gQERE1R4fQrnig/5N4c++zqLJdKNgeL83C2/v+hfv6PsGCLVE7cLz0MBYdnY/T5a532jbpAzGh47UYlTwJBoUrk4io/QvUB2Nsh2nITJ6MPee2YHX2EmSXO29ALqWGXQUbsatgI7qEp2FMyhT0jh7AvrZtjAgwQZ85ECI5DrZ3v67pRduQqkGWV0BEhHo+wDaqWcVau92OgIBL30Kn0+mgulg1ebk++OAD/Oc//8HgwYMbnVNcXIy77roLgwcPxscffwyLxYLnn38e9957L7799luYTCaYzWbk5ubizTffRJ8+feoeeznPgVqWeug41JWbIC3Ot26JmEjop4yGEsveWkRERO5KCe2CB/vPwZt7nkGl7ULPsBOlh/HW3udxX78/IYAFW6I2qaj6LL4/9jl2n93k8rgQCoYljsXETtch1Bju4eiIiFqfTtHjirgRyIgdjuNlh7Ameyn2F26Hq5vDj5dm4XhpFmICEzA6eRIGJWSy7VMbI0KCgMCAmtWz1VagYU2o6Tf9+7RmFWtrFRUVufxGqaVpjTeHvpj8/HzMmTMH27dvR5cuF++3tHLlSlRVVeG5556DyVSzacYLL7yAMWPGYMeOHRg+fDgOHz4MKSUGDBiAsLCwZsVE7pHVFth/2gLtoItVAUJAN7A3dCOugND7fpsJIiIiT0kO6VRXsK2wldeN12xE9hzu6/cnBOqDvBghEdVnsVfhx9OLsCZ7KeyazeWc7pF9MaPrbUgM6ejyOBGRLxFCoGt4GrqGp+Fc1RmszV6GLflrYHPR1/Zc1Rl8+8uHWHZyAYYnjsOIpImIMEV5IWpqlE5Xs4LWaoM0VwI2OyAERDAXENTX7GLt2bNnMXLkyIvOkVI2qyfO/v37ER4ejkWLFuG1115zal9Q3/Dhw/Haa6/VFWrrKy0tBQAcOnQIsbGxLNR6iXb6DOzL1kGWVzgdE6HB0E8eCaVDohciIyIi8n1JIR3xYPocvLn7GZhtZXXjp8p+wVt7nsX9/WcjUM8e8UTepEkNW8+sxtITX8FsLXU5JyYwATNSb0OvqCvYd5SI/FJMYAJ+1f1OTOp8PTblrcK63B9QZnHerLzKVoFVp77Dz6eXICNuOMakTEFySGfPB0yNMxogosIBTatZ6Kl3ay2pz2n230Yz9iW7bOPGjcO4ceMua25KSopT79w333wTJpOprn3C4cOHERQUhIcffhg7d+5EVFQUZs6cidtvvx2Kcvn9TKSUrfq824ra5+nuc5V2FerGXdC2H3C5pF1J6wLd2KEQAUa/+HslIve1VH4i8jcJQSl4oP+f8eYex4Lt6fJjeHP3s7iv358QZAjxYoTtH/MTNdcvJQfw3bGPkWs+5fJ4oD4YV3X6FUYkToBOqfn1jV9n1BTMT+RravraTsfo5MnYfXYz1uQscZlDNaliR/467Mhfh9SI3shMnoK0qHT2tfWCRvOPoly0BYIv5a6mPI9mFWs/+uij5jzMIz766CN8+umnePLJJxEdXbNj3JEjR1BeXo6pU6fit7/9LbZt24a5c+eitLQUv//97y/73GVlZU0q7rZXUkpUVlYCQLPftRdFZdD/vBWi0MXKAKMB9pEZ0Lp1ACxVNX+IiC5DS+QnIn8ViFDM6vp7fHDkRVTUK9ieLP0Fr27/B37d/fcI0rNg21zMT9RUhdX5WJHzDQ6V7nZ5XBEKBsWMwZWJ0xCoD4bZxV1qRJeD+Yl8WbeAfkjt2hcnzIexqWAlDpfudTnvcOFeHC7ciyhTHIbHTUB69DAYFKOHo/VfwmyGQdMATQVUxzzksoWqpgKaBrPZDBngG6tum9IqtlnPeMiQIc15WKuSUuLll1/G66+/jgceeAB33nln3bH3338fFosFISE1v4D07NkTFRUVeP311/Hwww9fdgE2LCwMOp3v91StrfaHh4c3+Ye51CS0XQehrtsJqCrQ4O9LdEiAfuIIiDD+MkhETedOfiKimu+dh0P/hjf3PIMy64XbBs9ac/H5yddwf78nEWzgTrzNwfxEl6vKXoGVJxdiXe4P0KTq8veLtKgMTO96K+KCkrwQIfka5ifyBxkRQ5CRMgQFlXlYm7MU2/LXuuz9XWovxLLcL7Dm7PcYnjgeI5OuQqgxwvMB+xmt2g6bogAaAK3BClNNg4IGuUkDoCgICQmBEu4bG2mqqnrZc32iPG2z2fDkk09i8eLFeOKJJ3DPPfc4HDcYDDAYDA5jPXr0QGVlJUpLSxEZGXlZ1xFC+M0Pt9rn2pTnK8sroC5fD+1UnvNBnQ76kVdAGdAbQvGPv0Miah3NyU9EdEF8cBJ+kz4Hb+x5BqWWorrxXPMpvLnnGTzQ/88IMbLPf3MwP9HFqFLFprxVWH5iASptZpdzEoJTMCN1FnpE9vNwdOTrmJ/IX8QHJ+H6HvdgSpcbsTH3R6zL/cFlL/BKmxk/nvovfs7+HgPiRmB08hQkcePGVqMEBUAEmiCrLIC1wQpTTQMU51WnItBU8zgfyVtNeR4+Uax94oknsGLFCvz73//G1Vdf7XBM0zRMmDABN9xwA37zm9/Uje/duxcxMTGXXaili1MPnYD64ybIaucdGUVMBPRTRkOJ5S6MREREbUFsUCJ+k/4XvLH7aZRYCuvG8ypO4/U9T+PB/n9GqNE3VjEQtQVZRbvx3bFPkV+R7fJ4sCEUkzvfgCGJV0InfP9OPiKi1hZsCMWETtdiTIersatgA9ZkL0VexWmneapmx9Yza7D1zBp0j+yLMSlT0SOyH/vatjARFgLj/TfUFGvrkVLCbDYjJCTEqZgpAk1+e1d2uyvWqqqKoqIihIaGIiAgAN988w2WLFmCJ554AkOGDMHZs2fr5tbOmTRpEt555x107twZffr0wcaNG/HOO+9gzpw5XnwmvkFarLCv2gzt4DGXx3UDe0M3cgCEni86iYiI2pKYwHj8Jv0veH3PP1FSfaFgm1+Rjdd3P40H0/+MMN4WSOSW/IocfHfsE2QVue5Lq1N0GJ08BeM7XoNAfZCHoyMi8n0GxYDBCWMwKD4TR0r2Y032kkZz8pHifThSvA9xQckYkzIFA+JGwqBjX9uWIsJCnIqvUkrIAD0UtmlxIGQb31Zt9uzZyMnJwfz58wEA2dnZGD9+PJ599lnMnDkTd999N9avX+/ysbVz7HY73n77bXz99dc4c+YMUlJScPfdd+PGG2+8rBhUVcWuXbuQkZHhNz1rS0tLL9nTSMs+A/uy9ZBlzrdxiZBg6CeNhNIpsTVDJSI/c7n5iYguX1H1Wbyx+2kUVZ91GI8NSsSD/ecg3MS7kC4H8xPVV2Erxw8nvsaGvB8hpesNRfrFDMbVXW9BTGC8h6Mjf8P8ROToTEU21uYsw/b8dS772tYKMYRhRNIEDE+awDuOWok/5aem1BZbtFibn5+P/Px89O/fH1JKn/mLZrG2wXFVhbphF9Rt+wEXXz5Kzy7Qjx8KEWDyRLhE5Ef86Yc5kScVV5/D63ueRlFVgcN4TGACHkyfgwgTWxldCvMTAYBds2FD7kqsOPktquwVLuckh3TGjNRZSI3o5eHoyF8xPxG5Vm4txcbcldiQuxJmW1mj8/SKAQPiRiIzZQoSglM8GKHv86f85PFi7U8//YS5c+fi2LFjEELgwIEDuO222zB16lTcdttt7p7e61isvUArLIF9yVrIs0XODzQaoB8/DEpaF5//JiMi7/CnH+ZEnlZSXYjX9zyNwqp8h/HowHj8pv8cRAREeymy9oH5yb9JKXGgaAe+O/opzlWdcTkn1BiOKV1uwqD40eyFSB7F/ER0cTbNhh3567EmZ2mjvcVrpUWlIzNlCrpH9OX3Uwvwp/zUlNqi2z1r165di4ceegiaduH2Hrvdjl27dmHHjh0ICQnBNddc4+5lqJXIMrPLBs/CbIZWba/7ZpFSQmYdg33HQbj69lFS4qGfPMpvmz8TERG1dxEB0XWbjtUvNhVW5WPenn/iN/3nIDIgxosRErVNueZTWHT0Y/xSst/lcb1iwJiUqRjXYTpM+kAPR0dERJdiUAwYmnglhiSMwaHiPVidvQRHive5nJtVtBtZRbuREJyCzJSpuCJuBAyKwcMRk69ze2XtzTffjN27d+Mf//gHXn75ZRQWFmLv3r3497//jffffx+9evXCt99+21LxeoWvrqyVZWZY3/rKqVgLAJqmQVGU2k+AagtgVwFFAWIiIGr/HhQF+pFXQBnYB0Lx7XdBiMj7/OmdVyJvKbMU4/U9T+NsZZ7DeFRALB5Mn4OogFgvRda2MT/5n3JrKZad+ApbzqxutC9tRtwwTO1yM79vyKuYn4iaLs98CmtylmFHwXqomr3ReSHGcIxMugojkiYg2BDqwQh9gz/lJ4+2QcjIyIDJZMLmzZsxZswYFBQU4ODBgwCAIUOGwGq1YteuXe5cwut8tVir5RfC+tZXNQVYvePz0jQViqIDrDbAXAVI7UJ/2phICIMeIjoC+imjocSxjx0ReYY//TAn8qYyawne2P0MCipzHMYjAqLxP+n/y8KTC8xP/sOm2bA2exl+PLUQFrXa5ZyOYd0wo+tt6Bzew8PRETljfiJqvjJrCTbkrsSG3BWotDlvrl5LrxgwKH40MlOmIC4oyYMRtm/+lJ882gbBaDSiqqoKVVVVDuOnTp1CeXk5IiIi3L0EtTa9DsLQ4EvBDqCyGqhddVv7TXO+YKsb0Au6UQMg9G5/CREREVEbE2aMwG/S5+CNPc849G4rqS7EvF3/Dw+mz+EO9uR3pJTYc24Lvj/2GYqqz7qcE26KwtQuN+OKuOHsS0tE5APCjBGY3Pl6jOswHdvz12FNzlKnu4+Amg0mN+Wtwqa8VegVnYHM5KnoFtHb5wuQ1DrcrrSNHj0aS5Yswf333w+zueZdhhdeeAGLFi0CAIwYMcLdS5Cn2ewQJeU17Q8aEgKGiSOgu4K71xIREfmyUGM4Huz/Z7y151nkVZyuGy+xFOL13f/Eg/3/jNigRC9GSOQ5p8uPYdHRj3G89JDL4wadCeM6TMeYlKkw6kwejo6IiFqbUWfC8KTxGJo4FllFu7Eme2mjvcoPFu7CwcJdSArphMyUKciIHQY9+9pSE7jdBiE/Px+33HILcnNza05Yb0OqmJgYfP7550hJSXE/Ui/y+TYIRkPdylpZUQWYKyEB543EDAbAqIfxgRuhxHNHaCLyPH+6TYaoraiwlePNPc8i13zSYTzMFIkH+/+Zt/qdx/zkm0osRVh6/Atsz1/X6JxB8aMxucuNiDCxNRi1TcxPRK0jx3wSa7KXYNfZjVA1tdF5YcYIjEyeiOGJ4xFk4Kbs9flTfvJoz1oAKC0txfvvv49NmzahuLgYcXFxGDx4MG6//XafaIPgN8Vaqw2yuAwAHIu1QkCEBUPqanrYGu+/gcVaIvIKf/phTtSWVNjK8dae55BjPuEwHmoMx2/S/8KCLZiffI1VteDn7O/x0+nFsKnOm/ECQJfwnpiROgsdQrt6ODqipmF+ImpdJZYibMhdgY15P6LKVtHoPIPOhMHxmRidPIl3J53nT/nJo8XaF154AX379sX48eNhNBrdOVWb5TfF2ioLZFlNK4u6Yq3RABEWAugUSJudxVoi8ip/+mFO1NZU2sx4a+9zyC4/7jAecr5dQkJw+76Tyl3MT75Bkxp2FmzEkuOfo9RS5HJOVEAspnW9Bf1ihvDfmtoF5iciz7Co1diWvxZrs5fhXNWZRucJIdAr6gqMSZmKruFpfv196U/5yaMbjH3++efQNA3r1q3z2WKt3wgwAhUKoJ7vVRsSBBEc6N2YiIiIqE0IMoTg/n6z8fbe53G6/FjduNlaijd2P40H0v+MxOAOXoyQyD0nSg/jv0c/xunyoy6Pm3QBGN/xWoxOmQwDew8SEVEDJl0ARiZdheGJ43GwaCdWZy/BsZIsp3lSShwo3IEDhTuQEtoFmSlTkB4zFDqFG7hTDbe/ElJTU3H48GHY7faWiIe8SQiI6EjAZoOmCCh6JgoiIiK6IMgQgvv7P4m39z6PU2W/1I2bbWU1Bdv+f0ZSSEcvRkjUdEXVZ7Hk+OfYVbDJ5XEhFAxJGIPJnW9AqDHcw9EREVF7owgFfaIHok/0QJwuP4Y12Uux++xmaNK5r212+XF8enAevjd9jlHJkzA04Ur2tSX3i7VXX301Dh48iGnTpmHs2LGIjY2FyWRyWL583333uXsZ8hQBwGgA1MabYxMREZH/CtQH1a2wPVl2pG68wlaON/bUFGyTQzp5MUKiy2OxV2HV6e+wOnsJ7JrN5ZzukX0xvettfBOCiIiapUNoV9zW6yFc3eVmrMv9AZvyVqHaXuk0r9RShO+PfYYVJ7/B4IQxyEyegujAOC9ETG2B2z1r09Jq+mtIKRvtL3Hw4EF3LuF1ftOzth5VVZ2eK3vWEpG3+VNPI6K2zmKvwtv7/oUTpYcdxgMNwXig35NICe3ipci8g/mp/dCkhm35a7H0+Bcot5a6nBMTmIDpqbeid9QA/ntSu8f8RNR2WOxV2Jq/BmtylqGoqqDReUII9I0ehMyUqegc1t1nv3f9KT95tGdtUhJ3/2337CqcKvaaCqlJp3lEREREAGDSB+K+vk/g3f1zHfqxVdkq8OaeZ3F//9noENrVixESOTtacgD/Pfoxcs0nXR4P1Afjqk6/woikCdCzLy0REbUwkz4Qo5InYUTSVdh3bhvW5Cx1euMbqCli7j23FXvPbUWH0FSMSZmCfrFDoBO+s4CQGud2sXbVqlUtEQd5gQg0QQSaIKssgFVzPKhpgKI1+hgiIiIikz4Q9/R9HO/tm4ujJRfupKqyny/Y9puNjmGpXoyQqMa5qnwsPvYp9p3b5vK4EApGJI7HxM7XIdgQ6uHoiIjI3yhCQf/YIegfOwQny37B2pyl2H12C6R0rsOcLj+Kjw++iojj0RidPBlDEq5EoD7IC1GTp7jdBsEf+GobBACQZeaaYm39MSlhNpsREhLitAxdBJogwtjsmoi8w59ukyFqT6yqBe/t+zd+KdnvMG7SB+L+fn9Cp7DuXorMc5if2qYqeyVWnlqIdTnLoGqu7xJLi8rA9K63Ij442cPREXkG8xNR+1BUfRbrcpZjc95PsKjVjc4z6QIwJHEsRidPQlRArAcjbHn+lJ+aUlt0u1g7fvz4i19ACKxcudKdS3idLxdrXfGnbxYial+Yn4jaLqtqwfv7X8SR4n0O4yZdAO7r9yd0Du/hpcg8g/mpbVGlii15P2PZia9QYSt3OSc+OAXTu96KtKh0D0dH5FnMT0TtS7W9ClvO/Iy1OctQXH2u0XlCKOgXMxhjUqa02zfG/Sk/ebRnbU5OzkWP+/pfNhEREREBRp0Jd/d5DB8ceAmHivbUjVvUary993nc2+8JdAnv6cUIyV8cKtqDRcc+QX5FtsvjQYYQTO58A4YmjmXvPyIianMC9IHITJmCkckTse/cNqzOXoJTZb84zZNSw56zm7Hn7GZ0CuuOMSlT0DdmMBSheCFqakluF2sfffRRh89VVUV5eTl+/PFH2Gw2zJ49291LEBEREVE7YNAZcWefR/Hh/v9DVtGuuvHagu09fR9HakQv7wVIPq2gMhffHfsEBwt3uTyuU3QYmTQRV3X6FQL1wZ4NjoiIqIl0Qof02KFIjx2KE6WHsSZnKfae2+ayr+3JsiP46MARRAXEnu9rOwYmfaAXoqaW0Go9a0tLSzFhwgTcfPPNeOyxx1rjEh7DNghERG0D8xNR+2DTbJh/4GUcKNzpMG7QmXBP3z+iW0RvL0XWepifvKfCVo4fTn6Djbk/QpOu+9L2jRmEq7vcjNigRA9HR+R9zE9EvqOo+izWZi/DljM/X7yvrT4QwxLHYVTSREQGxHgwwqbxp/zk0Z61FzNx4kRUVlZi3bp1rXUJj2CxloiobWB+Imo/bJoNHx94BfsLtzuMGxQj7ur7GHpE9vVSZK2D+cnzVM2ODbkr8cOpb1Blq3A5JymkE2akzvLJNwiILhfzE5HvqbJXYHPeT1ibsxyllqJG5wmhID12KMakTEWH0K4ejPDy+FN+8mjP2iVLljiNWa1WbNu2DadOnUJQUJC7lyAiIiKidsagGPDr3g/j44OvYt+5bXXjNs2K9/bNxV19HkXPqP5ejJDaKyklDhbtxKKjn+Bc1RmXc0KM4ZjS+UYMTshk7z4iIvI5gfpgXNlhGkYnT8bec1uxOnsJTpcfc5onpYZdBRuxq2AjuoSnYUzKFPSOHsCfjW1ci/SsvVj1e/To0e5egoiIiIjaIb1iwK97PYxPsl7DnrNb6sbtmg3v738Rd/Z5BGlR6V6MkNqbPPMpLDr2CY4U73N5XK8YkJkyBeM7zGCvPiIi8nk6RY+MuOFIjx2G42WHsCZ7KfYXboerm+iPl2bheGkWogPjkZk8GYMSMmHSBXgharoUt4u1AJy+CIQQCAsLw4gRI/C///u/LXEJIiIiImqHdIoet6U9BAEFu89uqhuvK9j2fgS9ojO8FyC1C+XWUiw/sQCbz/zscmMVAMiIG4apXW5GVECsh6MjIiLyLiEEuoanoWt4Gs5Vnanpa5u/BjbV4jS3sCof3/7yIZadXIDhieMwImkiIkxRXoiaGtOqPWt9BXvWEhG1DcxPRO2XKlV8lvU6dhVsdBjXKTrc3vv36BM90EuRtQzmp9Zh02xYl7McK08thMVe5XJOh9CumJH6a3QJ7+Hh6IjaB+YnIv9UaTNjU94qrMv9AWWW4kbnKUKHjLjhyEyejJTQLh6M0L/yk0d71r766qsIDQ3FHXfc4RTE3LlzERISgoceesjdyxARERFRO6YTOtya9j9QhA478i9sPqtqKj468DJ+3ev36BvTvgu21HKklNh7bisWH/8MRVUFLueEm6IwtctNuCJuBHvvERERNRBkCMG4jjOQmTIFu89uxursJcg1n3Sap0kVO/LXYUf+OqRG9EJmyhT0irqCP1u9yO2VtWlpaUhMTMRPP/3kMF5ZWYnRo0dDURRs3brVrSC9jStriYjaBuYnovZPkxq+PPQWtuWvdRhXhA6zev0W/WOHeCky9zA/tZzs8uNYdOxjHCvJcnncoDNhbMrVGNPhavbaI7oMzE9EBNTkgmOlB7E6eykOFO646NyYwARkpkzBoPjRMOpMrRqTv+SnVl1ZK6XEzJkzkZV14cXTmTNn0KtXL5dzIyIimnoJIiIiIvJRilBwY8/7IYSCrWdW141rUsX8g69gFn6L9NihXoyQvKXUUoxlJ77Etvy1LjdGAYAB8aMwtctN7K1HRETUREIIpEb0RmpEbxRU5mJtznJsO7MGNs3qNPdc1Rl8c+R9LD3xJUYkTsDIpKsQZor0QtT+qcnFWiEE5syZg1mzZtV9DjhvMlZr2rRpboRHRERERL5GEQpu6HEvFKFgc96Fu7Ok1PDxwVchpYaMuOFejJA8yaZasTp7CVadXgSri41QAKBTWHdck/prdAxL9XB0REREvicuKAnXdb8Lkztfj415P2J9zg8ot5Y6zauyVeDHU//Fz9mLcUXsCIxOmYLkkE5eiNi/NKtn7aBBg/Dmm2/CbDbjscceQ0REBP761786nlivR4cOHVyuuCUiIiIi/6YIBdd1vxuKULAx98e6cSk1fJI1Dxo0DIgb6cUIqbVJKbHr7EZ8f+xzlFgKXc6JDIjB1V1uQXrsUJ+/PZKIiMjTgg2hmNDxWoxJuRq7CjZiTc5S5JlPOc1TNRXb8tdiW/5adI/sizEpU9Ejsh/72raSZm8wNmbMGACA1WpFYGAgJk+e3GJBEREREZHvU4SCmd3ugoCCDbkr6sal1PBZ1huQUmJg/CgvRkit5WTZESw6+jFOlv3i8rhJF3B+U5SpMCgGD0dHRETkXwyKAYMTMjEofjSOlOzHmuwlyCra7XLukeJ9OFK8D3FBychMmYyBcaNg0Bk9HLFva3axttavfvUrWK1WZGVlwWw217VD0DQNZWVl2LBhA5566im3AyUiIiIi3yOEwK+63QEhBNbn/FA3LqWGzw+9AU1qGJyQ6cUIqSUVV5/DkuNfYGfBBpfHhRAYknAlJnW+HmHGCM8GR0RE5OeEEOgR2Rc9IvviTEU21uYsw/b8dbBrNqe5BZU5WHD4XSw9/iVGJE3AiKSrEGoM90LUvsftYu2ePXtw3333oaysrNE5LNYSERERUWOEELg29XYoQoe12UvrxqWU+PLwW5CQGJIwxosRkrss9ir8dHoxfs7+3uUvfACQGtEbM1JnsRceERFRG5AQnIIbetyLyZ1vwMa8H7EhdyXMLvraVtjKseLkt/jp9GIMiBuJzJQpSAhO8ULEvsPtYu1LL72E0lLnf6xa48ePd/cSREREROTjhBCY0fU2KELB6tPf141LKfHlobegSRXDEsd5MUJqDk1q2J6/FkuPf4kya4nLOTGBCZjW9Vb0iR7AvrRERERtTKgxHBM7zcTYDtOxI3891uQsRX5FttM8u2bDljM/Y8uZn9Ezqj8yk6egR2S/up/txdXnUGErd3iMlBLmSjPKlRCn1wDBhlBEBsS03hNrw9wu1u7fvx96vR4LFy7Eu+++i3PnzuG1117D/Pnz8cILL6Bbt24tEScRERER+TghBKZ1uQUKFPx0+juHYwsOvwspJYYncSFAe3G05CAWHf0YOeYTLo8H6INwVadfYWTSVdCzLy0REVGbZlAMGJp4JYYkjMGh4j1Yk70Uh4v3upx7qGgPDhXtQXxwCsakTEWXsJ54ZssfUGFzvitf0yQUxfnN2mBDGP467FW/LNi6XaytqqpCeHg4unXrhkGDBuG5556D0WjEPffcg9dffx1Lly7FI4880hKxEhEREZGPE0JgapeboAgFP576r8Oxr4+8B02qGJk80UvR0eUorCrA4mOfYu+5rS6PC6FgeOJ4TOp8HYINoR6OjoiIiNwhhEBaVDrSotKRZz6FNTnLsKNgPVTN7jQ3vyIbXx56C3rFiHNV+QjWh8CoMznMUYUGnaI4jNk0GypsZaiwlbNY2xyxsbHIz8/Hvn37kJGRgfLycqxZswYJCQmoqqpCQUFBS8RJRERERH5CCIHJnW+AEApWnvzW4di3v3wIDRKjkyd5KTpqTLW9CitPLcTanGUuf2EDgJ5R/TG9623sZUdEROQDEkM64qae92NKlxuxIXclNuaudGp1AACVtnJU2ytgUasRagxDiCEchvN31ahQodPpnB6jqq573PsDt4u148ePx/z58/HEE09gyZIlSEhIwAMPPFB3vEOHDu5egoiIiIj8TE3B9nooEPjh5DcOx/77y0eQUkNmyhQvRUf1aVLD5ryfsPzEAphd3N4IAHFByZiRehvSotI9HB0RERG1tjBjBCZ3vh7jO8zAtvy1WJuzDAWVuS5mSlTYylFhK0eALgghxjDoYfR4vG2d28Xaxx57DEVFRXWfP/roo5g9ezY0TYPBYHC7BcK8efOwceNGzJ8/v9E5xcXF+Oc//4k1a9YAACZPnownn3wSQUFBdXOWLl2KV155BadPn0bnzp3x+OOPIzMz063YiIiIiKh1Tex8HRShw7ITXzmMLzr6MTSp4soO07wUGQHA4eJ9+O7ox8irOO3yeKAhGJM7XY9hieOgU9z+1YOIiIjaMIPOiOFJ4zE0cSwOFe3BmpylOFK8z+XcarUS1VWV0AsjYoMSoBPOq2v9lduvmAICAvDvf/8bdnvNrU4zZsxAnz59cOTIEfTt2xcpKc2/xemDDz7Af/7zHwwePPii8373u9/BYrHggw8+QFlZGebMmYO///3veP755wEAmzZtwuOPP47Zs2dj+PDhWLBgAR566CEsXLgQqampzY6PiIiIiFrfhE7XQgiBpce/dBhffOwzaFLDuI4zvBSZ/yqozMXiY5/iQOFOl8cVocPI5Im4quO1CDKEeDg6IiIi8iZFKOgVnYFe0RnIMZ/E4mOfIq/S9Ru7Ns2CEkshogPiPBxl29Vib2/r9RdOlZqa6lYRND8/H3PmzMH27dvRpUuXi87duXMntmzZgiVLltRd8x//+AfuvfdePProo4iPj8fbb7+Nq666CrNmzQIA/OlPf8LOnTvx4Ycf4h//+Eez4yQiIiIizxjf8RooQofvj33mML7k+BfQoGFCx2u9E5ifqbSZseLkt1ifuwKaVF3O6R09ANO73orYoEQPR0dERERtTXJIJ1zd5WZsPbMaqtRQrVZCSs1hjipd97r3V24Xa6urq/H6669j9erVqKiogKY5/oULIbBy5comnXP//v0IDw/HokWL8NprryEnJ6fRudu2bUNsbKxDcXjIkCEQQmD79u2YPHkyduzYgdmzZzs8bujQoVixYkWT4iIiIiIi7xnbYRoUoeC7o584jC87/hU0qWFip5leisz3qZodG/N+xPKTX6PKVuFyTmJIR0zveht6RPb1cHRERETU1ilCQZA+BFEBMaiwlcNsLYNd2iCEgjBDhLfDa1PcLtb+4x//wLfffgsppcvjQogmn3PcuHEYN27cZc3Nz89HYqLju/ZGoxERERHIy8tDWVkZKisrkZCQ4DAnLi4OeXl5TY6NiIiIiLxnTMpUCAgsOvqxw/gPJ76GlBomdrquWa8/yTUpJQ4W7cLiY582slEIEGIMx+TO12NIwpVQhOLhCImIiKg9ERAIMYQhxBAGu7RDqhIGvcHbYbUpbhdrf/jhBwBAnz59kJmZicDAQLeDaoqqqioYjc47x5lMJlgsFlRXVwOA05za400hpWy0KO1Lap+nPzxXImpfmJ+ICABGJ0+GIhQs/OUjh/EVJ7+FKlVM7nSDxwu2vpifzlScxnfHPsXh4r0uj+sUPUYnT8b4DtcgQF/zO4AvPX8iX+GL+YmI2pfG8o9e6GEXrtsq1T7OV3JXU56H28VaRVEQEBCATz/9FCaTyd3TNVlAQACsVqvTuMViQVBQUF1MDedYLJYmF5bLysqgKL6/WkBKicrKSgDNWxlNRNRamJ+IqFbf4KGoSqrGktOOPWxXHP8WlZWVGJ90rUfzhC/lpwpbOX7O+w7bC9c2+otF78gBmJA0E5GmGFgqrLDA+fU4EbUNvpSfiKh9MleaoWkSqtCg4kJxVgLQNA12APWzk6pp0DQJs9mMUq3U0+G2ioZtYy/G7WLtpEmTsHDhQlRWVnqlWJuQkODUE9dqtaKkpATx8fGIiIhAUFAQCgoKHOYUFBQ4tUa4lLCwMOh0OrdjbutqX5SHh4fzhzkRtSnMT0RU34TwGQgJDsHXR95zGN90biUCAkyY2uVmj+UKX8hPNs2G9Tk/4MfT/0W1vdLlIoWUkC6YnnobuoaneSFCImoOX8hPRNS+lSshUBSBmlKt42ZiKjQAjq85NKhQFIGQkBCEh4Z7MNLWo6qNryBuyO1i7cyZM7Fx40bcfvvtuO666xAdHe1U0Jw6daq7l2nU4MGDMXfuXJw8eRKdOnUCAGzevBkAMGDAAAghMGDAAGzZsgU33HBD3eM2b96MgQMHNulaQgi/+eFW+1z95fkSUfvB/ERE9Q1PGg9FKFhw5F2HVaA/Z38PDRqmd73NY/miveYnKSX2FW7D4mOfobAq3+WcMFMkpnS+EQPjR7EvLVE71F7zExH5hhBjGIINYaiwlUFVbQ7HNE1Ckc65KdgQhhBjmM/kraY8D7eLtbfeemvdx88//7zLYFqyWKuqKoqKihAaGoqAgACkp6djwIABeOSRR/C3v/0NlZWVeOqpp3DttdciPj4eAHDXXXfh/vvvR+/evZGZmYmvv/4aBw8exNNPP91icRERERGRdwxNHAshFHx1+G2Hgu2a7KWQUmJG6iyfeaHf0nLMJ7Do6Mc4WnLQ5XGDYsSVHa7GlR2mwaQL8HB0RERE5AsiA2Lw12GvosJW7jAuZU2rg5CQEKfXasGGUEQGxHgyzDbD7WLtpRrktnQj4Ly8PIwfPx7PPvssZs6cCSEEXn31Vfz973/HHXfcAZPJhMmTJ+PJJ5+se8yoUaPwzDPPYN68eXjppZfQrVs3vPHGG0hNTW3R2IiIiIjIO4YkjIEiFHxx6E2H159rc5ZBkyqu7XYHC7b1lFmKsfTEV9iWv6bR1+sD4kdiauebEBEQ7eHoiIiIyNdEBsQ4FV+llCjVShEeyjYt9QnpK9uqtSJVVbFr1y5kZGT4Tc/a0tJS9jQiojaH+YmILmV7/np8fugNSOm4icPwpAn4Vbc7Wu0W/vaSn2yqFatzlmDVqUWwqhaXczqFdceM1FnoFNbNw9ERUWtoL/mJiPyPP+WnptQW3V5ZS0RERETUVgyMHwlFCHya9bpDwXZj7kpIqWFm97v8sueqlBK7z27C4uOfoaS60OWciIBoTOtyC9Jjh/n8L0xEREREbZXbxdrbb7+90WNCCAQGBiI5ORnXXHMN+vfv7+7liIiIiIgu6oq4ERBQ8EnWaw4F2015q6BJDdf3uMevCranyo7iv0fn42TZEZfHjToTxnWcgTHJU2HQGT0cHRERERHV53axdsuWLXXvvNfvqCCEcPj8888/x+uvv47MzEx3L0lEREREdFEZccOgCAUfH3wVmlTrxrec+RkSGm7ocZ/PF2xLqgux5MQX2JG/3uVxIQQGxWdiSucbEGaK9HB0REREROSK28XaF198Ef/6179QUVGBa665BklJScjNzcXChQthMpkwa9Ys7N69Gz///DPefvttFmuJiIiIyCP6xw7Br8XDmH/gFYeC7dYza6BKDTf3fMAnC7YWtRo/n16Mn09/D5tmdTmna0Qarkn9NZJDOns2OCIiIiK6KLeLtTt27EB+fj4WLlyInj171o1fe+21uP7662GxWPDKK69g0KBBOHDggLuXIyIiIiK6bP1iBuOOPr/HRwdehqpdKNjuyF8HKTXcnPYgdMI3NpDVpIYdBeux5PgXKLMUu5wTFRiH6V1vRd/oQexLS0RERNQGub2UYNGiRQgODnYo1AJA3759ERISgq+++goGgwGhoaGorq5293JERERERE3SJ3og7uj9B+gUx3UKOws24LOseVDrrbptr46XHsIrO5/C51lvuCzUmvSBmNb1Fjw+6F/oFzOYhVoiIiKiNsrtlbVSSlRUVGDhwoW49tpr68YXLlwIs9kMANi3bx+KiooQGhrq7uWIiIiIiJqsd/QA3NXnUXyw/yXYNVvd+K6CTdCkxG1p/+NUzG0PiqrPYvGxz7Dn7GaXx4VQMCxxLCZ2ug6hxnAPR0dERERETeX2K9Lx48dj4cKFePLJJ/Hmm28iLi4OZ86cwalTpyCEwJVXXomff/4ZmqahT58+LREzEREREVGTpUWl484+jzgVbPec3QwpNczq9dt2U7Cttldh1en/Yk32MofnUl/3yL6YkToLicEdPBwdERERETWX220QnnzySfTr1w9SShw/fhybN2/GyZMnIaVERkYG5syZg5KSEgQFBeG3v/1tS8RMRERERNQsaVHpuLvvH6FXDA7je89txfyDrzRa+GwrNKlhU94qPLf1Maw69Z3LeGODEnF33z/i/n6zWaglIiIiameElFK6exJN0/Dzzz9j+/btKC8vR0xMDAYNGoQRI0YAALKyshAdHY3Y2Fi3A/YGVVWxa9cuZGRkQKfzjQ0oLkZKidLSUoSHh7OfGRG1KcxPRNRSjhTvx3v75sKmWR3Ge0cPwK97/w6GBsXcS/FEfjpSvB+Ljn2MPPMpl8cDDcGY1Ok6DE8c325WCBNR6+PrJyJqq/wpPzWlttgir+IURcG4ceMwbtw4l8fT0tJa4jJERERERC2ie2Qf3NvvCbyz7wXYVEvd+IHCHfjowP/h9t5/aHLBtrWcrczDd8c+xYHCHS6PK0KHkUlX4apOv0KQIcTD0RERERFRS2pWsfZvf/sbwsPD8cgjj+Bvf/vbRecKIfDUU0815zJERERERK0mNaIX7uv3BN7Z+y9Y6xVsDxbuwof7X8IdfR7xasG20mbGilMLsSH3B6ia6nJO7+grMK3rrYgLSvJwdERERETUGprVBiEtLQ2JiYn46aefkJaW1uhSZSklhBA4ePCg24F6E9sgEBG1DcxPRNQajpcexjt7n4dFrXYY7x7ZF3f3eQwGnfGS52jJ/KRKFZtyf8Tyk1+j0mZ2OSchOAUzUn+NHpF93boWEfk+vn4iorbKn/JTq7dBGDx4MKKjo+s+JiIiIiJqr7qE98B9/f6EtxsUbI8U78N7+/+Nu/o8CqPO5JFYsop2Y9HRT1BQmePyeIghDJM6X48hiVdCJ3x/EQERERGRv2lWsXb+/PkuPyYiIiIiao86h/fA/f2fxFt7n4PFXlU3fqR4H97dNxd3930MJl1Aq13/TEU2Fh/7FFlFu10e1yl6jE6ejPEdr0GgPqjV4iAiIiIi71Ja+oR2ux1FRUUtfVoiIiIiolbVKawbHuz/ZwTqgx3Gj5YcwLv7XnAo4raUCls5vj3yAf69/clGC7X9Ygbj8UH/wrSut7BQS0REROTjml2sPX36NP7+97/js88+A1BTpH366acxcOBAjBw5EmPHjsWyZctaLFAiIiIiotbWIbQr7u8/G4EGx4LtsZIsvNOCBVu7ZsPq7CV4dsujWJ+7AlJqTnOSQzrjN+l/wR19/oCYwPgWuS4RERERtW3NaoNw+vRpXH/99SgrK8Ptt98OAHjjjTccWiLk5eXh0UcfRXR0NPvaEhEREVG70SG0Kx7s/2e8secZVNkq6saPlx7CW3ufx339/oQAfWCzzi2lxP7CHVh87FOcqzrjck6oMRxTu9yEgfGjoYgWvxGOiIiIiNqwZr36e/XVV1FaWoqwsDD07t0bVqsV8+fPhxACGRkZePPNNzF69Ghomob333+/pWMmIiIiImpVySGd8WD/OQgyhDiMnyw7grf3Pocqe2WTz5ljPok39jyDD/a/6LJQq1cMmNDxWswe/G8MThjDQi0RERGRH2rWytrNmzdDCIGPPvoIPXv2xMaNG1FaWgohBB599FEMGTIE/fr1w8iRI7Fnz56WjpmIiIiIqNUlh3TCb/rPwZt7noXZVlY3frQkCy9t/wtu7HkvAnQ1K2yllDBXmlGuhEAI4XAeDRKb81Zhy5mfIaV0ea2MuOG4usvNiAyIab0nRERERERtXrOKtefOnUN4eDh69uwJANiwYQMAIDAwEAMHDgQAREVFITw8HCUlJS0TKRERERGRhyWGdMSD6XPwxp5nYLaWwq7ZkVdxCjnm49hzbjNCDWF1xVlNk1CUC4VaCaDaXgWbZkVCUAr0ivNL745h3XBN6ix0CuvuqadERERERG1Ys4q1gYGBqKqqgqZpUBQFP//8M4QQGDhwIHQ6HQCgrKwMZWVlCA4OvsTZiIiIiIjaroTgFPym/xy8sedpFFYVQJMqIAQ0qaLSbkakKRaKUKAKDTqlpnVBtVpVU9yVNkDKmsfUe+kdYYrG1K434YrYEU4rcYmIiIjIfzWrWNuzZ09s374dL7/8MiIjI3HkyBEIITB+/HgAQEVFBf76179C0zSkpaW1aMBERERERJ4WH5yM36T/Bf+3/S8AAAFRU6CVKkqtRYgNTIAOgAo7SqyFsKqWunkSF1ofGHQmjO8wA5kpU2DUmbzxVIiIiIioDWtWsfbGG2/Etm3b8NZbb9WNxcTE4JprrkFRURGuvPJK2Gw2CCFw0003tViwRERERETeEheUhJvTHsQ/N//OYdymWXG26gx0Qo9qtfGNxwYnZGJy5xsRbops7VCJiIiIqJ1qVrF2xowZyM3NxZtvvomqqiqkpqbihRdeQGBgIAwGA6xWK3Q6HX7/+99j2rRpLR0zEREREZFXRAXEItQYgUpbucOKWZtmhVVaXLY00CsG3N779xiUMNqToRIRERFRO9SsYi0APPjgg7jnnntQVlaG6OjoCyfU6/Hcc89h2LBhSEhIaJEgiYiIiIjaCp1QEGWKQ4m1EKq0X2SeHmHGUAASCcEpnguQiIiIiNqtZhdrAcBgMDgUamtde+217pyWiIiIiKhN0yk6xAYl4mxlnlPBVkAgzBiJEGMYbKr1oq0RiIiIiIjqc6tYS0RERETkr/RCj9igRJyrOgO7ZgMABBtCEWaMhE7ovBwdEREREbVHLNYSERERETWTXuiREJQCi2qBkAJGvdHbIRERERFRO6Z4OwAiIiIiovbOpDNxNS0RERERuY3FWiIiIiIiIiIiIqI2oMXaIOzZswcbNmxAfn4+nnrqKWzfvh0DBgyAEKKlLkFERERE1CbYzveorU/VNOgarIVwNY+IiIiIqDFuF2ttNhv++Mc/4ocffqgbe+qpp/CHP/wBycnJePvttxEaGuruZYiIiIiIvC7YEIpgQxgqbGVQVcdCrKZJKNJ5oUKwIQzBBr4eJiIiIqJLc7tYO2/ePCxfvhwxMTEoKyuDzWZDVVUVioqKcO7cObz88sv4y1/+0hKxEhERERF5VWRADP467FVU2ModxqWUMJvNCAkJcbqzLNgQisiAGE+GSURERETtlNs9axctWgS9Xo8FCxYgMjISABAYGIgFCxZAURSsWLHC7SCJiIiIiNqKyIAYpIR2cfqTGNTR5TgLtURERER0udwu1ubn5yM0NBQJCQkO47169UJQUBCKi4vdvQQRERERERERERGRz3O7WJuYmIiSkhIcOHDAYfyTTz5BeXk5kpKS3L0EERERERERERERkc9zu2ftTTfdhLlz5+Kmm26ClBIAMHLkSBQVFUEIgV/96lduB0lERERERERERETk69xeWXvvvfdi1qxZsNvtsNvtkFKisLAQQghcf/31uPfee1siTiIiIiIiIiIiIiKf5vbKWgD4y1/+gttvvx2bNm1CcXExYmNjMXDgQHTq1KlZ59M0Da+++iq++uorlJWVYeDAgXjqqadcnu+VV17Bq6++6vI8M2fOxLPPPgsAGDduHHJychyOT58+HXPnzm1WjEREREREREREREQtqUWKtQDQsWNHdOzYsUXONW/ePHz++ed49tlnER8fjxdeeAH33XcfFi9eDKPR6DD37rvvxs033+wwtmDBArzxxhu44447AABmsxm5ubl488030adPn7p5AQEBLRIvERERERERERERkbvcLtaOHz++0WNCCAQGBiI5ORkzZ87ExIkTL3k+q9WK9957D48//jjGjBkDAHjppZcwevRorFixAldffbXD/ODgYAQHB9d9furUKbz55puYPXs20tLSAACHDx+GlBIDBgxAWFhYc54mERERERERERERUatyu1jbsLWAK0eOHMHq1avx3HPP4Zprrrno3KysLFRUVGDYsGF1Y2FhYejduze2bt3qVKxt6LnnnkP37t1x00031Y0dOnQIsbGxLNQSERERERERERFRm+X2BmMffvghEhISkJSUhNmzZ+Pll1/G7NmzkZSUhOjoaPzzn//EzTffDCkl5s+ff8nznTlzBgCQmJjoMB4XF4e8vLyLPnbv3r348ccf8dhjj0FRLjy1w4cPIygoCA8//DBGjRqFGTNm4IMPPoCmac14xkREREREREREREQtz+2VtV999RUKCgqwcuVKJCUl1Y2PGzcOkyZNwr59+/DUU0/hv//9L44ePXrJ81VVVQGAU29ak8mE0tLSiz72gw8+QHp6usOqXKBmZW95eTmmTp2K3/72t9i2bRvmzp2L0tJS/P73v7/cpwopJaSUlz2/vap9nv7wXImofWF+IqK2ivmJiNoq5iciaqv8KT815Tm6XaxdtWoVAgMDHQq1QM2GY4GBgViyZAn+9re/ISgoCCUlJZc8X+2mX1ar1WEDMIvFgsDAwEYfV1lZiRUrVuCpp55yOvb+++/DYrEgJCQEANCzZ09UVFTg9ddfx8MPP+ywCvdiysrKLntueyalRGVlJYCavsNERG0F8xMRtVXMT0TUVjE/EVFb5U/5qSl397tdrA0ICEBxcTHmzZuHBx98EIqiQFVVvPHGG6isrER4eDg2btyIwsJCREdHX/J8te0PCgoK0LFjx7rxgoKCug3DXFm7di00TcNVV13ldMxgMMBgMDiM9ejRA5WVlSgtLUVkZORlPdewsDDodLrLmtue1Vb7w8PDff6bhYjaF+YnImqrmJ+IqK1ifiKitsqf8pOqqpc91+1i7dVXX4358+fjlVdewTvvvIOoqCgUFhaiuroaQghMmzYNW7duBQBkZGRc8nxpaWkICQnB5s2b64q1ZWVlOHDgAGbNmtXo47Zv344+ffo4bSKmaRomTJiAG264Ab/5zW/qxvfu3YuYmJjLLtQCNVV+X//iqVX7XP3l+RJR+8H8RERtFfMTEbVVzE9E1Fb5S35qyvNz+57+xx9/HBMnTqxbupydnV3Xd3bq1Kl4/PHHUVJSgtjYWDz66KOXPJ/RaMSsyzohTgAAXVlJREFUWbMwd+5c/Pjjj8jKysIjjzyChIQEXHXVVVBVFWfPnkV1dbXD47KystCjRw/nJ6gomDRpEt555x0sXboUp06dwhdffIF33nmnSf1qiYiIiIiIiIiIiFqT2ytrjUYj/vOf/+DQoUPYvn07ysvLERMTgwEDBqBLly4AgAceeABPPvmkUyuCxvzud7+D3W7HX/7yF1RXV2Pw4MF49913YTQakZ2djfHjx+PZZ5/FzJkz6x5z7tw5pKenuzzfY489hrCwMPz73//GmTNnkJKSgjlz5uDGG2909+kTERERERERERERtQghW3nLtbNnzyI2NrY1L9HqVFXFrl27kJGR4Tc9a0tLS/2iZwgRtS/MT0TUVjE/EVFbxfxERG2VP+WnptQW3V5Zq6oq3n//fezcuRMVFRV1u5vV/oUfO3YM+/btc/cyRERERERERERERD7N7WLtf/7zH7z11lsALuziBtQ0zpVS+nxlnIiIiIiIiIiIiKgluL3B2JIlSwAAkydPRqdOndC9e3fcf//96NSpE4QQePrpp90OkoiIiIiIiIiIiMjXuV2szc/PR3BwMF588UXMmDEDUko8+uij+OCDD6AoCv773/+2RJxEREREREREREREPs3tYm1AQACAmrYH6enpOHbsGEpKShAfH4+goCBkZWW5HSQRERERERERERGRr3O7WNutWzdUVFTgiSeeQEZGBoQQ+OMf/4hHHnkE5eXl7FlLREREREREREREdBncLtY+9NBD0Ov1yM3NRUhICMaPH49169Zh+fLlAICxY8e6HSQRERERERERERGRr9O7e4KRI0fim2++wcmTJwEAf//736HX63H48GEMGDAATzzxhNtBEhEREREREREREfk6t4u18+fPR3p6OiZMmAAAiIyMxIsvvuh2YERERERERERERET+xO1i7X/+8x9UV1djzZo1iIyMbImYiIiIiIiIiIiIiPyO2z1rExISYDAYEBwc3BLxEBEREREREREREfklt1fW3nHHHfj73/+OG264AVOnTkVsbCwCAgIc5kydOtXdyxARERERERERERH5NLeLtX/5y18ghMDhw4dx+PBhp+NCCBZriYiIiIiIiIiIiC7B7WItAEgpm3WMiIiIiIiIiIiIiGq4XazNyspqiTiIiIiIiIiIiIiI/JrbG4zVl5+fjz179gDgiloiIiIiIiIiIiKipmiRYu1PP/2Eq6++GldeeSVuvvlmAMCsWbPwySeftMTpiYiIiIiIiIiIiHye220Q1q5di4ceegiaptWN2e127Nq1Czt27EBISAiuueYady9DRERERERERERE5NPcXln72muvQUqJ//f//h9iYmLqxm+//XZIKfHBBx+4ewkiIiIiIiIiIiIin+d2sTYrKwthYWG44YYboNPpAAB6vR5/+tOfEBYWhuPHj7sdJBEREREREREREZGvc7tYazQaUVVVhaqqKofxU6dOoby8HIGBge5egoiIiIiIiIiIiMjnud2zdvTo0ViyZAnuv/9+mM1mAMALL7yARYsWAQBGjBjh7iWoFRVWaTBbpcOYlBLlZokSqBBCOBwLMQpEB7bIvnRERERERERERERUj9vF2ieeeAI7d+7E1q1bAQBCCLz33nuQUiImJgaPPPKI20FS6yis0vDYqjKUNyjWQgKa1KCIcsCxVotQo8C/x4WxYEtERERERERERNTC3C7WxsfH49tvv8X777+PTZs2obi4GHFxcRg8eDBuv/12REREtECY1BrMVolyq4ReAAad4zFNBZQGYzYVKLdKmK0S0exuQURERERERERE1KLcLtZu27YNgwYNwh/+8IcWCIe8waADTDrHJbQqAF2DMUDCbvdYWERERERERERERH7F7XvZZ82ahUmTJuGtt95Cfn5+S8RERERERERERERE5HfcXlmrKApOnjyJl156CS+//DJGjRqFmTNnYty4cTAYDC0RI3mQRQUqbBpUFVAUDQIC5/+DXZOwacDKExbEBCnQCUARgCIEFIF6nwM6ISDqPr4wp+EfXYNx58fVPFan1MRQN64IKHA8V8PN0IiofeMGiERERERERORv3C7WrlmzBosXL8aiRYtw4MABrF69GmvWrEF4eDhmzJiBmTNnIi0trSVipVZmU4EzFSpkXW1Env9TQ5M1n/10yuLUNqEtUFwWhZ0LyfXHhIti8oVx14VkV+e6+ONqCsmuCtpKYzGcL07XnUtBXXFaJwSU2uN14zUFbUXUPu58QVvUHK89Hwva1F5wA0QiIiIiIiLyR24Xa2NiYnDnnXfizjvvxLFjx7B48WIsX74cR48exfz58/Hxxx/jwIEDLRErtTKLKusVatsfTQKa0xNox0+oFbguMIsGBejzxV8Xq6Bdrno+X3B2tVL6UgVzxeF854vhDQvTLgratYXpmmL0hYK2rrZYrbgomEM0eFzNvPoFeBa02w5ugEhERERERET+yO1ibX3BwcEICQlBaGgoFEWBpmkteXpqZSZ9TYFLY33TZ7GgfWmuV1G7Xi3tqqBdV1yuv+q5rlWHi5XXyvlCcu1Yvcc5rNiu3/qjfmG6weprnSIurLpuUNB2GHMqtLtade66+O5J3ACRiIiIiIiI/InbxVqz2Yxly5Zh0aJF2LZtG6SUkFIiMDAQkyZNwvXXX98ScZIHGBQgMViHCpuEXdOgCFFXxpMAVE3Cpgn0jdUjzKhA1QANNQVAVUpo2vl58nxRUJPQAKh14zVzNHnhcZqUF47Xnk+TLB+S17CgfWmuVl43XLHtui2Jc0FbJ8SF1h11RWeBcmtNv1qLXUKviJr+2QAgJIQEDDoJ/fnH69j1gIiIiIiIiHyE28XakSNHwmq1Qp4vbvTr1w/XX389rr76aoSEhLgdIHmWQQdE6ARUFdA1qIBYVIkqO3BLryB0Ctc1coaWoUl5vmhW/488Xxg+3z9XAnZZ07rhwrjrx6mNnMvxfBL28+etfz5Zb07duRyKzjVFaFXWLzpfKEzXjTcoVqtaw3M38jjN8TnVxkXkLbXfP45a9mvSokpYVAmrCijCsX/2+ShcPu6d3RXoEKZHZIBAhElBRIBAZIBS97FeYZsLIiIiIiIiarvcLtZaLBZERERgxowZuP7669GjR4+WiIv8XO2KPEcsstTnqjCtNlZcPl+EbljQdlj13EiRW8p6q57rFasvrKK+UKyuK4QDDYrONSuoXcXqUGjH+ZjqzblU0b5h8b3+48h/1G6AeLxURa658RY8ocaaom2ESakp6AYoiDCdL+ie/zjEKDze7oGIiIiIiIgIaIFi7YsvvoirrroKBoPBYdxqtWLp0qX48ssv8cknn7h7GWpFNhVouGpNUwGlwVjNPGorWNC+OClr2mnUFYzl+VXKqFfU1c4XkhsWvc+34nBcRe2iyK01LEy7epzz6mhXK7sbK767KrQ7FuCdV17Li6wmb3g9f1Nu1VBuBU6j8YSmUwQiTK4LuTUfC0SaFJj0/H4jIiIiIiKiluV2sXbq1KkOn//yyy/44osvsGjRIpSVlbl7empFIUaBUKNAubXBxjznizmKBqfaX6ixZtUZUVsnzvdCVUT9RMev3fpqC9r1+09rmqxrwVFbmHZY9QycX0ktL7QCaVis1hyLxLXFcofV0qi/itq5uHy2UsXCIxboFUBf1z+75vx2VUKDgHo+1pamahKFVRKFVRffJDNQf76ge7546/hxTWE3zCigY+sFIiIiIiIiukxuF2uBmlYIS5cuxRdffIFdu3YBQF0P2+7du7fEJagVRAcq+Pe4MJitjtUOKSXKzeUIDQmFaHArcIhRIDqQu/kQ+YK6grZDC+q2UVg8WarihxNWBOoBk642ppr/q6pa11O7tjhcZZOosktM7RoAnQKUVEuUWDQUV2soqZawtcIy4iq7RJVZRZ658TmKqGm9cKGHruKin65AkEE45VsiIiIiIiLyP24Vaw8fPowvv/wSixYtQnl5eV2BVgiBu+++G9dccw169uzZIoFS64gOVBAd6DgmpUQpBMLDdSweEFGbJgDoFcCoB1QIjEwxOm2AKKVEpU2i2CJRcr54W1ytoaT2c4uG4mqJMovWwtuk1awSLrVoKLUAuEjrBaOuXuuFAAWR5z+OrOuvqyDcJGDQMScTERERERH5smYVa7/55ht8+eWX2L17N4CaX4SNRiPGjx+PpUuXAgAefvhhBAYGXuw0RERErU4IgWCjQLARSAnVNTrPrkmUW2sKucXnV+bWFXctNf8vqdZQZW/5VbpWVaKgUqKg8uKtF0KMF4q3EfULugFKXfsFbpBGRERERETUfjWrWPvnP/8ZQghIKdG7d2/MnDkT06dPR3h4eF2xloiIyF2e3ABRrwhEnm9NcDHV9toVuedX6FZrF1btnv9/cbWEJlu+qGu2SpitKrLLG3/CihAOm6HVFHdrN0y78HEAN0gjIiIiIiJqc9xqgxAQEID09HT0798f4eHhLRUTNE3Dq6++iq+++gplZWUYOHAgnnrqKXTq1Mnl/G+//RazZ892Gv/hhx/qHrN06VK88sorOH36NDp37ozHH38cmZmZLRYzERG1nLa8AWKAXiAhRIeEkMbnaFLCbJX1VuXWX617oQ2D2XrxlbTNoUmJomqJouqLnztAL5xX6NZulHa+2BtmEtBzgzQiIiIiIiKPaVax9o477sB3332HoqIifP755/j888+RmpqKa6+9tkWCmjdvHj7//HM8++yziI+PxwsvvID77rsPixcvhtFodJp/6NAhDBkyBC+++KLDeFRUFABg06ZNePzxxzF79mwMHz4cCxYswEMPPYSFCxciNTW1RWImIqKW0943QFSEQJhJIMwEdETjrRdsqkSpxbmgW1x9oZ9uSbWEVW35VbrVdom8S2yQJgCEmmp66EYGKAgPEIis7aFbb4O0YG6QRkRERERE1CKElM27T9Nut2PlypVYsGABNmzYAE3THH5Re+qppzB58mREREQ06bxWqxXDhg3D448/jltuuQUAUFZWhtGjR+OZZ57B1Vdf7fSYu+++G6mpqZgzZ47Lc95zzz0ICwvDSy+9VDd28803o0ePHvjHP/5xyZhUVcWuXbuQkZEBna7xX7p9hZQSpaWlCA8P5y/fRNSm+GN+klKiyo7zvXTrb4x2oQ1DiaVmgzSt5Wu6l8WgiHotF1y1X6j5v5EbpJEP88f8RETtA/MTEbVV/pSfmlJbbHYbBL1ej8mTJ2Py5MnIz8/HggUL8O233yI7OxsA8Pe//x3//Oc/MWzYMLzzzjuXfd6srCxUVFRg2LBhdWNhYWHo3bs3tm7d6rJYe+jQIUyaNMnl+TRNw44dO5zaJAwdOhQrVqy47LiIiIi8QQiBIAMQZNAh+SIbpKmaRJlVNtJy4cLHrbFBmk2TOFspcfYSG6QFG2pbLrhqv1Dz/zATN0gjIiJqrsIqrZE7kyRKoLbpO5OIiKiGWz1ra8XHx+Ohhx7CQw89hI0bN2LBggVYuXIlLBYL1q9f36RznTlzBgCQmJjoMB4XF4e8vDyn+UVFRTh37hy2bt2K+fPno6SkBOnp6fjjH/+ILl26oKysDJWVlUhISLis8xEREbVHunobpHW5yDyLvabtQun5frrF1RKl1ZrDxyUWCXsrLNOtsElU2FTkXHSDNCD8fO/cyPMF3Yjz7RciAi4UewN08Pl334mIiJqisErDY6vKUN6gWFvT81+DIspd9vz/97gwFmyJqNXxzaTL1yLF2vqGDx+O4cOHo6ysDIsWLcLXX3/dpMdXVVUBgFNvWpPJhNLSUqf5hw8fBgDodDo8//zzqKysxLx583Drrbfiu+++g/38zjSuzmexWJoUm5QSzewa0a7UPk9/eK5E1L4wP7nPqAPigxTEBwFopJ+uPL9BWnG9lgv1/1+7ctfpl8EWoMkLLR+OX2SeSScci7j1irm1q3YjuEEaeRDzExF5W7lFQ7lFQq8AhgY/4jUVUBqM2VSg3CJRbtEQFcCfl0TUegqrNPxxVbnL3x/q3kxqINQoMHdcqM8UbJvyGrHFi7W1wsLCMGvWLMyaNatJjwsICABQ07u29mMAsFgsCAwMdJo/bNgwbNmyBeHh4XVjr732GsaOHYtvvvkGN9xwQ9356mvsfBdTVlYGRfGNL5KLkVKisrISAFctEVHbwvzkWeEAwk1AJxOAMOfjdk2izAqU1v6xyHofA6XWms+tjS+kbbZKFai0ArmXmBdqAMKMAuEmIMIIhBmBcJNAuBE1f0xAsJ5fT+Q+5ici8rZys4QmNejg/Iu+JjQ0/E1WA2CVQLm5HKUNl9wSEbWgPLNEqUWDXgCGBslI0zQ0LLXZtJrfJ/KKyqAP8Y38pGkXbxlXX6sVa5urtv1BQUEBOnbsWDdeUFCAtLQ0l4+pX6gFgKCgIKSkpCA/Px8REREICgpCQUGBw5yCggKn1giXEhYW5jcbjAHwiwbPRNS+MD+1PdGXOC6lRLWK85uh1azILa52XrFb2kobpFVqQGU1cKa68Tl6BQ59cxvbIM3EDdLoIpifiMgbpJSwqoBFlbBW2SFRAbsEoAloqLljRUpA0+C08MiuSVg1YH+ZCQX2mmMCAuf/cyjf1qY1cbmf1xurOS4ujNeb2Oj8eudtLI76udbV/IbXaRiry8fVi/Ny4hINDggXj8H5WBv+ndb/e3aa3+C51H8+l/PcneY7xNL4c+PPL2otJVChiHKYDHB6Ta2qcKq1KaqEZgNCQ0IRHu4bdThVvfwVLG2uWJuWloaQkBBs3ry5rlhbVlaGAwcOuFyl++mnn+Lll1/G6tWr61bims1mnDhxAtdffz2EEBgwYAC2bNlSt8oWADZv3oyBAwc2KTYhhN8kr9rn6i/Pl4jaD+an9kUIgSAFCDIoSA5tfJ4mJcosDTdGq227cOHjClvLV3TtGnCuSsO5KgBo/EVUkOFCMbdmk7T6H9cUdMO5QZpfY34iokvRzhdXq+0S1apEtV3CYkfdx9V2CYsKVNklLHVzanrOV9klLOc/r1ZrjltUWfdmp0WVKLFICACKcPXz0nFVlyYBCWDxUQvfkCQHzoVt4VwIh2Ph19XntWOOx+sV7i81H84F5YZzagrSwul4kz5veJ0mvrlQf6z+/PrnqC3YOzzGRTH9okX8umPikvMvq4jvMF9ccr7L8zb6d+P4b1JUraHSLmHXgCrF8XF6AQS7qscK36rDNeV5tLlirdFoxKxZszB37lxERUUhOTkZL7zwAhISEnDVVVdBVVUUFRUhNDQUAQEBGDt2LP7v//4PTzzxBB5++GFUV1fjxRdfRFRUFH71q18BAO666y7cf//96N27NzIzM/H111/j4MGDePrpp738bImIiAgAFCHqes4ivPF5VvVC39zS86t0i6s1lFpqC7w1xV5bKyzTrbRJVNpU5Jov9jyAMNOF4m39Qm5k3YpdBYFsvUBE1C5o8nyxtEExtfp88dSqSlTZUe/YhWJqdV3BFfWOsa81tX21X6UXWmzKC4MtdnbyJxa1JmdWw/WbSaqUCDPxtXGtNlesBYDf/e53sNvt+Mtf/oLq6moMHjwY7777LoxGI7KzszF+/Hg8++yzmDlzJhITE/Hhhx9i7ty5uOWWWyClxMiRI/HRRx/VrbQdNWoUnnnmGcybNw8vvfQSunXrhjfeeAOpqalefqZERETUFEadQFywDnHBjc+RUqLCVrO6qK79QrWGYkv9j2s2VGnpXxc0iZrWDtUAShtfpWs8v0FabfG2YeuFSFPNKl0DVzoRETWJqjkWUy8UWesVXGuLp3ZZb4XrhWJC/QKrVWVhiYiotVXYWKytT0huWXtJqqpi165dyMjI8JuetaWlpey5RkRtDvMTtSS7VtN6obGWC7XFXm+uggoxXliR27DlQuT5sRAjWy+0BcxPRM1j1+T5W/zrF1PPr049/7HF7njrf1W91a0NV7u2xp0V7YVFlcgur9nAR6cIKOdvU1ZETY5qmJtUTcIugeHJBoQYFKc3MOX5xZT1F1fW/k/CeWfzhvPrH5YuPq//mAvjsm4R5+XNvzDPYbxunmw0DtfzXcRdNyZdzieiS6vNT7U5qaEwk0BUgOIwv8oOvDguDJ18qGft5dYW2+TKWiIiIqLWplcEogIFogIb7o/tqNp+ofVCTZuF+h9fKPZqrfD+t9mqwWwFTl+kl65OEXUF3IbtF+qv2g3Qs4BIRO6RsqbfYE3RFE4rVx2LqRcKrg1XtNZvF2D34+IqUPOzKEBfs+FOgL7mj0kHBOpFvbGa405jeoGA2nE9UFCh4YmfyhHocgMfFTqd48+72mLIPf2DfaYY4g21RetGC8oNity1n0jUG69fIK53vksVvhu9jsN86RBX48X3Bs+r4XNxmO9cBEfD+bXjlyy+S4fxJhfTG50vXc939Vzr/924nN/gjYmGMdU7cFnPod5go//OLr5uLv7cHf+d60ZcfF1c9tdig79D6WK+03FX15FAqUXD2UpL3ZtJ9RmERLjp4q/H/Q2LtUREREQXEaAXSAjRISGk8TmalDBbpXNBt94K3RKLBrO15YsSqiZRWCVRWKVddF6g/nxBN0CcX5Vb/+Oawm6YUTi9gCai9ktKCZtWbwWqinqbVrkouNZfrXq+IFu/2FplR6u8MdWeGBRxvkiKuuJqowXW88VU1wXXmsfrWzDnFlXJBjsVkSfU34zK8YNmn9HdExC1OSdLVWzOsyFQ7/rNJN6U5IjFWiIiIiI3KUIgzCQQZgI6ofHVSTZVOmyGVlyvh25Nr9uasda4jbfKLlFlVpF3kQ3SBGo2SLvQesF1G4Ygg+/szEvUlkgpYVVrVqhW2SWs54upda0AXKxMrd8qoGF7AIsq4ecLV2GsLZbqnIunAbrzhVeXBVecH6stsNY8viWLq0RERK6wWEtERETkIQadQEyQQExQ47d6SSlR2XCDNEv9lbo1H5dbtRYvwkjU3KZWagFwkdYLBkXUbYZWf2O0C20Yagq83CCNfJ12vrh6YVMqF7f+12sPUH3+tnNrvVYB9Xu1Wuz/v737Dm+6Xt84/k7SdC9KoUBZZdgWGQIeOGxlyJFxlKGAAxEUUBFZR1GGhyHbwx5WRUD4sZfIUKAi4FEQOIAMQUCGRQqllO6V5PdHTWxZ4ihJ2/t1XV6mmU8a+rS58/k+HxtFPFvNMw7AEbD+ErJ6/BKw/rqi9darVT1zfV0UZ3pnWeDGiapWC9w4lTbr9m1eREScSGGtiIiIiAsxGAz4uBvwcYdQv9uv0rVYbSRm/hroXvtlhm7OSt1fT6flwwZpWVYbl1NtXE698+gFH3POatxinkYCPOynDQR4GB3zdP20QZrcQ1ZbTnia8cvK1dwbV6XnDk9vHAXgCF5vXrlalBnIG6bmCU9vXL16mzA19+pVd1PRDFf/Kr7uOT01KdNGdnauC2xgtYHRyk1H2Pu552xUKSJyL+jDpLujsFZERESkADL9srq1mOedN2TIyP41yLVvhpYzbuHX0wkZNiz5cKx0SpaNlCwLPyXd/i9uo8Fw04pc+8iFXwNe19og7WrazfOHbTYbSck2ErDcNCLC191A8d/YyE5uzWLNO0s192rVPIHrbWat3jg+ILOIh6tGw202srrTeADTzRtZ2cNZdxMaieJCinsZebe5/236UxJ+vn7qTyLiFPow6fdRWCsiIiJSiHm4GSjlZqKUz+2vY98g7VZB7q+bpuWMXvirWW024tNtxKff+b493Qy3Gbnw6+kAj/yfJ3k1zcrg6ESSbtwszgZWmxWjIemWbzbebe5fJAKRbOvNYWqe1ai5NrbK83XuUQK5NsLKj/nNBYnRYMAr1+pTz1/CUq8bwtQ8s1Vzhak3boRlNipcLeyKexkp7pX3PJvNxnUMBASY9PqLiFPow6TfR2GtiIiISBGXe4O08v6/vUFaztzcW83TzVm9mx+rF9OzbVzKtnAp5fbXMQB+HjnhrX3MQmCukQv2sNfnT2yQlpxpIynThpsBzDd8q6wWMN5wXpYFkjJzwvAbAxRns9lsZFtxzE7NMw7gpjA17yzWtOybxwOkW8iXFdoFiZvx1itTc4ett17R+mugmns2q5vCVRERKST0YdLdU1grIiIiInflbjdIS8uGa+lWrv8S5Oaczvm//fT1jPzZIC0xw0piBpxPvPMGaQE3BLq3GsPgfocN0symnMPJc7MApptuc8Phfn+CzWYj00qe1ae5Z6emZ+cEr5mOFa2/blxl3/gq9yzW9Oyclc1Fmdn4a3hqD0vts1NvDFM93Ay5VrT+utFVzorWnMvze2W3iIiIFH4Ka0VERETkL2MwGPA2g7fZdMcN0qw2G4kZN87RtY9cyDl9PcNKSlb+bJAWl2YjLu23N0gLyDN6wUi2NScMdTPkrHq8Q56b45dZbHFpOeFx7jmqaXc5HiB3IFvEF67ibso7R9Ur90ZVjjEBt1rRmndUgD2gNSlcFRERERejsFZERERE7jmjwZCzqvW3Nkiz/DJi4aaRC79umnY9I39mm9o3SLuYnLce+1gDoyFn9ILJaMBkAJsNbFixkrMK1mYDiy1nxe/Ub1NuWolbFOQ5/N++UVXu1aq5RgN4ueWEsbnDVMdogF++NuoQSRERESnkFNaKiIiIiMvyMBkI8TERcocN0mw2GylZtjyboV27IdBNyLCRlGHlr450beRsqpWd55yCyQC/rkzNPUf1hkP/f13Reos5q47b5owSULgqIiIi8vsorBURERGRAs1gMODrbsDXHcpx+9EL2dZfNkjLtRlawi3GMKRnF4zA1Wi4eeOq240HuNVogJyZrDiu627SZlYiIiIizqawVkRERESKBDejgeJeBop73Xn0Qnp23s3QruUaw3Ah0cLFZOsfWkBrNOQc6p87LHV3A6/cs1bvsFrV45dRAfZw1mxUuCoiIiJS2CisFRERERHJxdPNQGlfE6V9b16le+66hZPXEvFyywl/LdacFbsWG9isVtxMRgyGnGDWSM5mZhkWGNXYj8rF9Ke3iIiIiNyZ/mIUEREREfkDTAYwmXI2xQKwWMB0wyZiVsBgzQl2RURERER+y52PARMRERERERERERGRe0Ira0VEREREfqcsC9w4uNZqAeMN5+VcT0RERETk7iisFRERERG5S77uBvzcDSRl2sjOznWBDaw2MFqBGyYe+Lkb8HXXGAQRERER+W0Ka0VERERE7lJxLyPvNvcnOTPvClqbzUZSchJ+vn4YDHmDWV93A8W9NH1MRERERH6bwloRERERkd+huJeR4l55z7PZbFzHQECA6aawVkRERETkbukjfhEREREREREREREXoLBWRERERERERERExAUorBURERERERERERFxAQprRURERERERERERFyAwloRERERERERERERF6CwVkRERERERERERMQFKKwVERERERERERERcQEKa0VERERERERERERcgMJaERERERERERERERfg5uwCCgKbzQaAxWJxciX3hs1mw2q1YrFYMBgMzi5HRMRB/UlEXJX6k4i4KvUnEXFVRak/2TNFe8Z4Jwpr74LVagXgu+++c3IlIiIiIiIiIiIiUhDZM8Y7MdjuJtIt4qxWK9nZ2RiNxkKf9IuIiIiIiIiIiMhfx76K2M3NDaPxzlNpFdaKiIiIiIiIiIiIuABtMCYiIiIiIiIiIiLiAhTWioiIiIiIiIiIiLgAhbUiIiIiIiIiIiIiLkBhrYiIiIiIiIiIiIgLUFgrIiIiIiIiIiIi4gIU1oqIiIiIiIiIiIi4AIW1IiIiIiIiIiIiIi5AYa2IiIiIiIiIiIiIC1BYKyIiIiIiIiIiIuICFNaKiIiIiIiIiIiIuACFteJUNpsNgKSkJGJjY51cjYjIr9SfRMRVqT+JiKtSfxKRgsDeq+Lj40lKSuLq1atOrigvhbXiNDabDYPBwPbt2+nbty9t2rQhKioKq9Xq7NJEpIhTfxIRV6X+JCKuSv1JRAqC3L2qT58+PPbYYyxdupSsrCxHiOtsBpurVCJF0hdffMFrr71G7969CQ8PJywsjCpVqpCRkYGHh4ezyxORIkz9SURclfqTiLgq9ScRKQiio6MZOHAgAwYMICAggPr16xMaGkpycjK+vr7OLk9hrThPUlISL730Ei1btqRHjx6kpaWxe/du1q5dS0ZGBi1atOCpp55ydpkiUgSpP4mIq1J/EhFXpf4kIgVBSkoKAwYMoEGDBvTs2ZOUlBR27tzJhg0bOH36NIMGDaJ169aOFbjOoDEIck/ZPxuIjY3FbDbj7+/PtWvXOHXqFC+99BKzZ88mOTmZzMxMli9f7nJzQ0Sk8FJ/EhFXpf4kIq5K/UlECgJ7r7py5Qru7u5cvHgRo9HI999/z0svvcQHH3xAUlIS1atXZ+jQocTGxjotqAWFtXKPGQwGtm3bxiuvvMLRo0fx8/Nj69attGvXDjc3N/r06cOiRYsYMmQImZmZZGZmOrtkESki1J9ExFWpP4mIq1J/EpGCwGAwsHnzZjp27EhCQgLNmjXj3Xff5cknn8Td3Z0XX3yRjz/+mI4dOxIWFobZbHZqvW5OfXQpck6dOsWiRYto164ddevWJSwsjDNnzmAwGKhbt67jelu2bKFYsWIuMStERIoG9ScRcVXqTyLiqtSfRKQguHjxItu3b+eVV14hMDCQAQMG0KRJEzw8PKhTp47jel999RVubm64uTk3LlVYK/fMqVOnmDBhAj/99BMNGjQAICgoiKCgIK5evcqyZcs4d+4caWlpbNiwgcWLF+Pn5+fkqkWkKFB/EhFXpf4kIq5K/UlECoIzZ87Qpk0bihcvTseOHR2rZhs0aEBSUhLTp0/HYDA4At1Fixbh7+/v1Jo1BkHuGS8vL0qUKMHFixf5+OOP81xmNBr53//+x8GDB4mPj2fp0qVERkY6qVIRKWrUn0TEVak/iYirUn8SEVdmn1NbqVIlnn/+ea5evcrevXtJTU11XCc1NZWMjAy2b99OVlYWS5YscYleZbDZqxf5i+XeOc9isWAymYiPj2f27NlER0fTsWNHXn31Vcf1U1NT8fb2JiMjAw8PD2eVLSJFgPqTiLgq9ScRcVXqTyJSEOTuVblNmDCBRYsW8e9//5sOHTrkmUubnp6OyWRy+qxaO41BkHxh/+HYu3cv33zzDcePH6d+/fo0btyYIUOGYLPZ2LRpEwaDgX79+gHg7u6e5/8iIvlB/UlEXJX6k4i4KvUnESkIcveqHTt2cPnyZYKCgujXrx9Dhw7FYDAwevRoDAYDjz32mKM/eXp6OrnyvLSyVvLNtm3b+Ne//kXDhg1JT0/n5MmTlCxZksGDB/PAAw8wZcoU9u3bR5MmTfjXv/7l7HJFpAhRfxIRV6X+JCKuSv1JRAqCrVu38vrrr9OiRQsSEhI4ffo0BoOBqVOnUqtWLcaOHcuqVav417/+xZNPPukyq2lzU1gr+eLChQv07duX559/ns6dOwOwd+9ePvjgAxITE5k0aRJeXl5MnjyZ8+fPM2fOHIKCgpxctYgUBepPIuKq1J9ExFWpP4mIq8o99iAmJoYXX3yRp59+mqefftpx3tChQ7l06RLr1q3Dx8eH4cOHEx0dzWeffeaSGx9qgzH5065evcrJkyfznHf9+nWys7OpXbs22dnZANSrV4+ePXty9uxZ/vvf/1KiRAkGDx7MzJkz9YtcRPKF+pOIuCr1JxFxVepPIlIQ/Pjjj8TFxWEwGLBYLEBO/8rKyqJRo0aO64WGhjJmzBgyMjKIiooCYOzYsWzYsMElg1pQWCt/gW+++YYZM2aQkJDA0aNHuXTpEgkJCZw7dw4PDw/c3NzIzMwE4O9//zvlypXj8OHD2Gw2QkJCKFGihJOfgYgUVupPIuKq1J9ExFWpP4lIQXDixAn69u1LVlYWP//8MwBpaWkkJydz5cqVPNctU6YMpUqVIikpyXFe8eLF72m9v4fCWvnTKlasyLZt2+jZsyc9e/bk8uXLPPjgg0RGRjJy5Eji4+Nxd3fHYrGQlZWFt7c3ERERt9ydT0Tkr6T+JCKuSv1JRFyV+pOIFATe3t6YTCb+8Y9/0LJlSy5cuEBoaCgGg4Fly5blCWzd3d0JCgqidOnSQM7oBFemsFb+FKvVyv3330+/fv04duwYISEhFC9eHE9PT5566imuXLnCoEGD+OGHHzh69CizZs3i5MmTNGvWzNmli0ghp/4kIq5K/UlEXJX6k4gUFE2bNqVJkybExMQQEhKCt7c3ZcuWZcyYMXz22WeMHz+eL7/8ku+//56JEyfyv//9j0ceeQTA5T9c0gZj8qdYrVaMRiPTp08nMzOTJUuW8OCDD/L2229TtmxZVq9ezbJlyzhy5Ajly5fHzc2NKVOmUK1aNWeXLiKFnPqTiLgq9ScRcVXqTyJSENhn1M6bN4/U1FQOHTpEYmIiM2bMoGLFikRHRzNq1CjS09Px8/PD09OTSZMmFZhepbBW/hD7bnvXr18nICDAcf6hQ4fo3r07Dz74IP/+978pV64cVquVQ4cO4evrS1BQkEvPBRGRgk/9SURclfqTiLgq9ScRKQjsvSolJQWz2Yy7uzsA27Zt44MPPiAtLY0ZM2ZQoUIFYmNjiY2NxWw2ExISUqA2PlRYK7+b/Yfjyy+/ZP78+WRkZNC0aVM6depESEgIhw8fpnv37vztb39jwIABnD9/nho1alC2bFlnly4ihZz6k4i4KvUnEXFV6k8iUhDk7lWLFi3i8uXLtGrViv79+wOwfft2PvjgA1JTU5k2bRqXL1/mvvvuo1ixYk6u/PdTWCt/yOeff86gQYPo2rUrly9f5ocffqBx48a88MILjl/ozz77LP7+/mRmZrJq1SrKlSvn7LJFpAhQfxIRV6X+JCKuSv1JRAoCe69q3749fn5+LFmyhD59+jgC2+joaObOncuxY8ewWCxs376d0NBQJ1f9+ymsld/thx9+4OWXX+all16iY8eOxMfH06JFC4KDg2nWrBm9e/emZMmSnDlzhn379lG/fn0qVKjg7LJFpAhQfxIRV6X+JCKuSv1JRFxRWloaXl5ejhW1Z86coXfv3vTu3Zsnn3ySmJgY2rVrR1paGs888wzDhw8H4PTp0xw9epQaNWoQFhbm5Gfxx7g5uwBxbe+99x7x8fG8+eabjvMuXbqEl5cXrVu35tq1a4wdO5ZOnTrh4+PDkiVLcHd3p2vXrlSqVImwsDCX32VPRAom9ScRcVXqTyLiqtSfRKQgWLFiBYcOHWLQoEGOudgxMTEEBATQuXNnrl+/zn/+8x86depEzZo1ef311wkKCqJz585UrlyZypUrO/kZ/DlGZxcgrstqteLm5sbChQuZMWOG4/xLly4REBBASkoKn3zyCV5eXvTq1YuBAwdiNptZvXo1r7/+OpmZmU6sXkQKM/UnEXFV6k8i4qrUn0SkoDh58iT79+/n/fffJy4uDoCMjAySk5O5dOkSa9euxcPDg27dulG/fn28vb2ZMWMGY8aMIT093cnV/3laWSu3ZTQaeeaZZ/Dy8uKdd97BZrPx2muv0blzZ8qUKYPZbGb79u00b96ckiVLcvHiRSpXrswjjzzCI4884tiVT0Tkr6b+JCKuSv1JRFyV+pOIFBTDhw9n+vTpfPHFF2RnZ/Pyyy/TsmVLgoOD8ff3Z9euXTRv3pxKlSpx7do1GjduTNu2bQkPD8fT09PZ5f9pWlkrt2Sz2bDZbHh4eFC/fn169uzJ3LlzmTdvHgaDgUaNGnHhwgVOnDhBixYtMJlMrFmzBqvVSrt27ShVqpSzn4KIFFLqTyLiqtSfRMRVqT+JSEGRlZUFQOfOnalQoQKfffYZUVFRJCQk8MADDxATE8OePXuoWrUqBoOBhQsX8uOPP9KgQQMqVqzo3OL/IlpZK3nYBzfb5xB9/vnnjBs3jlq1ahEcHMy0adNIS0tj4MCBhIWF4e3tTffu3SlfvjxHjx7l448/JigoyMnPQkQKI/UnEXFV6k8i4qrUn0SkoDGbzWzcuJF58+YRGhqK2Wxm7dq1WCwWevfuTWhoKOHh4YwYMYKSJUty8uRJFi5ciL+/v7NL/8sYbDabzdlFiGtITk7G19fX8fXZs2d5+umn6devH506dSIpKYno6GhGjRpFjx49GDJkCKdOnWLRokX4+/vToUOHAj/EWURck/qTiLgq9ScRcVXqTyJSEKSmpuLt7e34+syZM/Tq1YuXXnqJNm3a4Ovry/Tp0/nmm2+oUaMGQ4YMYd++fXz99dekpaXRrVu3QtertLJWAPjwww85duwYEydOxGg0YjQauXbtGr6+vjRv3hx3d3eKFy/OE088gdFoZNiwYQQGBvLCCy8wevRorFYrRqOmaojIX0/9SURclfqTiLgq9ScRKQgmTpxIWloaI0aMwGQyARAfHw9A3bp1HR849e/fH5PJxKJFi/Dw8KBXr140bNjQcfRAYaPuKwD4+vry8ssv4+bmRnZ2NpCzW+i5c+c4e/YskHMIDUDjxo0pVqwYU6ZMYdasWQD6RS4i+Ub9SURclfqTiLgq9ScRKQjq1atHly5dMJlMZGZmAjkza9PT00lMTAQgOzsbg8FAv3798PX1ZdWqVURFRTl6W2GkDlzEbdu2jaSkJLp06ULlypXZt28fAwcO5NKlS9StW5cGDRoQFRXFkSNHHJ9WBAYG0qBBA958800effRRJz8DESms1J9ExFWpP4mIq1J/EpGCYNOmTfz44488/PDDREZGsnPnTkaOHElSUhL16tUjODiYd999l4SEBNzccoYCJCYmUqVKFdq2bctzzz2Hm5tboVxVCwpri7QLFy7Qr18/Ro4cSVxcHADHjx/n1KlTTJw4kaSkJJ5//nmuXLnCxIkT2b59O4cPH2bmzJns27eP9u3bF7q5ICLiGtSfRMRVqT+JiKtSfxKRguD48eNMmzaNsWPHcuHCBQAyMzNZt24d48aNw2KxMGHCBC5cuEDfvn2Jjo5m3759REVFERMTQ58+fQgJCXHys8hf2mCsiNu1axcDBw6kWbNmjB49Gh8fH5YsWcLy5cupVKkS48eP58CBA3z88cfs2LGDSpUqATBlyhSqVavm5OpFpDBTfxIRV6X+JCKuSv1JRAqC5cuXs3btWvz9/Rk2bBgVKlQgOjqa1157jXbt2vGvf/2LK1euMGzYMGJjY3F3d8fHx4fx48dz//33O7v8fKewVti9ezf9+vXj4YcfZuzYsfj4+LB48WJWrFhBpUqVGD16NP7+/pw6dQpvb2+8vLwoVqyYs8sWkSJA/UlEXJX6k4i4KvUnEXFVuTcvXLFiBStWrCAoKMgR2G7bto2BAwfSrl07Ro0ahdls5syZM5hMJgICAopMr1JYKwDs3LmT/v3707x5c8aMGeP4hb5y5UrCwsJ44403KF26tLPLFJEiSP1JRFyV+pOIuCr1JxFxVTabzTFrdvny5axcufKWgW3btm0ZOnQogYGBzi3YCTSztgiy5/NxcXEkJSWRlJRE06ZNmT59OtHR0YwYMYKUlBSeeeYZnnzySQ4fPszUqVOxWCxOrlxECjv1JxFxVepPIuKq1J9EpCCw96pr1645ZtV26dKFrl27cvXqVd555x3OnTtHy5YtmT59OuvWrWPGjBlFsldpZW0RY/8EIzo6mpkzZ5KRkUFkZCSvvPIKlSpV4ssvv+S1117L8wnsihUraNCgAeXKlXN2+SJSiKk/iYirUn8SEVel/iQiBUHuXjVnzhxiY2OpV68ew4YNIygoiFWrVrF06VKKFy/O8OHDKV++PF9++SVly5YtkhsfKqwtgrZu3crAgQN54YUXsNls7Ny5k+DgYN566y3CwsL48ssvGTx4MHXq1GHatGl4e3s7u2QRKSLUn0TEVak/iYirUn8SkYJg27ZtDBgwgG7dulG5cmWmTJlC8+bNGTp0qCOwXblyJUajkUmTJhXpD5QU1hYxFy5c4OWXX6Z79+488cQTJCQk0KZNGzw9PQkLC2PEiBFUrFiRbdu2MWrUKFatWkVISIizyxaRIkD9SURclfqTiLgq9ScRKQguXrxI7969efrpp+nWrRtJSUm0bt2a+Ph4mjRpwsSJEwkKCmLZsmVs3LiRSZMmFem52ppZWwTkzuOvXbtGSkoKDRs2JCkpifHjx9OmTRteffVVjh07xoQJEzh8+DAtW7bks88+0y9yEclX6k8i4qrUn0TEVak/iUhBk5iYSFZWFq1atSIxMZF33nmHxx57jNWrV7Nv3z4mTZrEwYMH6dq1K3Pnzi3SQS0orC0SDAYD3377LUlJSdhsNsLCwsjIyGDz5s0YjUa6du1Khw4dCAoKYs+ePQwYMIDU1FS8vLycXbqIFHLqTyLiqtSfRMRVqT+JSEHx3XffcfjwYYxGI0ajkcTERDZv3ozBYODRRx+lSpUqhISEsG7dOqZOnUpycjK+vr7OLtvpFNYWASkpKbz99ttMnjyZWrVqMWDAAEqVKsXmzZsJDQ2lSpUqJCYmUrp0aYYNG8by5cvx9vbGYDA4u3QRKeTUn0TEVak/iYirUn8SEVdntVpJTEzktddeY8eOHdx3331MmzaNcuXKsX37dsLCwqhRowYA1apVY+rUqYwbN05B7S8U1hYBnp6etGzZkjNnzpCSkkKNGjWIi4vj7Nmz1KpVC4CPP/6Yy5cv06RJE0qUKOHkikWkqFB/EhFXpf4kIq5K/UlEXJ3RaMTf358nn3ySFStWcOHCBcLDw0lISGDfvn2ULl0ag8HAnDlz+O6776hXrx6hoaHOLttlaIOxQshms930qWlMTAzt27fn1Vdf5fnnn8dms/HEE09w4sQJqlatyk8//cSCBQuoVq2ak6oWkaJA/UlEXJX6k4i4KvUnESkIcvcqi8WCyWTi1KlTDB8+nPbt2/P000+TlJTEsGHD2LVrF2FhYcTExLBgwQIiIyOdXL1rUVhbSB0+fJiff/6Z1q1bO86bNWsWX3/9NRMnTqRs2bJkZWXxwQcf4OPjQ5MmTQgLC3NixSJSVKg/iYirUn8SEVel/iQiBcGePXtwc3MjIiICHx8fAN566y0OHTrExo0bgZx+duLECeLi4nj00UepWLGiEyt2TQprCxmbzUZaWhpdunTh2rVrlC1blv79+xMZGUl8fDzPPfccEyZMoHHjxs4uVUSKGPUnEXFV6k8i4qrUn0SkoLh+/TpDhgxh165dtG7dmgYNGtC1a1cuX75Mnz59aNOmDS+++KKzyywQFNYWUleuXOH8+fPMmTOHmJgY/P39ef3111myZAkXL15kwYIF2g1URJxC/UlEXJX6k4i4KvUnEXEltxrPYhcdHc3WrVvZsmULderUoXHjxpw4cQJfX1+GDRumzQ7vgsLaQujGH5odO3awe/du1qxZQ1hYGEePHuWjjz6iQYMGTqxSRIoi9ScRcTVWqxWj0aj+JCIuS/1JRFyRfS4t3Nyn0tPTiYmJYfr06WRkZPDll18C8P7779OkSROn1FuQuDm7APljPv/8cy5dukRWVhZt2rShdOnSjsvsPyD2Nx8PPfQQDz30EP/85z/573//S1ZWFmXLlnVW6SJSyK1evZpTp06RlZVFs2bNaNy4saMvqT+JiDNt2bKFn3/+maSkJJo1a0aNGjVuCmrVn0TEGfT+TkQKgiVLlrBnzx5mzJiByWRyBLY3rpb18PCgcuXKTJkyhbi4OFavXs0XX3xBuXLlnFR5waKVtQXQ5MmTWb9+PVWqVGH//v3UqVOHjz76CKPReFe3z8zMxN3dPZ+rFJGiaPLkyaxatYpmzZqxd+9eOnfuTL9+/e769upPIpJfpkyZwrp166hevTpHjx4lMDCQZ555hi5dutzV7dWfRCS/6P2diBQEVquVIUOGsGnTJp588klGjx4N5F1hm9uNq21TU1Px9va+Z/UWZFpZW8Ds2LGDLVu28OGHHxIeHs6xY8fo2rUrMTExeT6huN0PC6Bf5CKSL44ePcrWrVuZM2cOdevWzXNZ7l/U6k8icq9t2rSJzZs388EHHxAREUF2djbdu3dn/fr1dOjQ4a56j/qTiOQHvb8TkYLAZrNhNBpp0KABBw4cYM+ePQwePJh3330Xk8nkWPmfm/39n/29oILau6ewtoC5dOkSAQEBVKxYEQAvLy9KlixJVFQUWVlZRERE8Mwzz+Dm5nbLHxYRkfwSFxdHUlISpUqVAnLeVEyaNInTp09jMpmoXbs2L7zwgvqTiNxzZ8+epUqVKlStWpWsrCzMZjO9e/fm1Vdf5eTJk1SvXt3ZJYpIEaX3dyJSENiDV3vg2rlzZ5YvX+4IbI1GI3FxcQQHB9/2tnL3FNYWEPZPUt3d3cnKymLTpk08+OCDDBo0CJPJhMlkIiYmhgMHDnDw4EHHpxsiIveKj48PXl5eJCcnY7PZeO655zAYDNSpU4czZ86wfv16vv/+e6ZMmYKbm379iEj+s6/kiIuL4/Lly46/mQB8fX3JysrSGwgRcQr7+zuz2az3dyJSYERGRlKlShU6deqE2Wxm8eLFDBs2DKPRSLly5Xjuuefw8PBwdpkFnt4tFxD2X8wNGzZk6dKljBs3Dg8PD4KCgli2bBnFihXDarWyePFili1bxtGjR6lZs6aTqxaRwm7evHm0atWKypUrU7lyZbKysli2bBnPP/88gYGBvP3225QoUQKr1crHH3/M8uXLOXjwIA8++KCzSxeRIsAexP7jH//gwIEDnD9/nvLlywPg7++P0WgkPT09z21unK8mIpIf7O/vGjVqxLJly/T+TkQKhJCQEH788UdiYmLo2rUr3t7eTJo0ibS0NDZu3IiHhwfZ2dlanPMn6bvn4rZu3cqPP/5ISkoKLVu2pEaNGsyePZvz58+zZcsW0tPTCQwMdPwwdOzYkalTp3L8+HH9MheRfDV+/HiWLl3KI488AkCxYsUYOXIk/fv354cffsDX15eAgAAAjEYjnTp1YubMmRw7dkxhrYjkq6+//prw8HCCgoIAqFevHu+9957ja4C0tDTc3Nzw9PR0nLdw4UJsNhs9evS41yWLSBGxevVqfvjhB5KTk2nfvj3169dn7ty5nD17Vu/vRMRlbNmyhZ9//pmkpCSaNm1KzZo1MRqNGI1GihcvTlJSEp6enuzduxeTyUSJEiWIiopi3LhxCmr/AvoOurApU6awZcsWSpcuTUpKCu+99x6zZ8+mRYsWlCxZkpiYGHbt2oXBYHDMMAKoXr16nmH0IiJ/tXHjxrF27VpWrFhBpUqVHDPUGjZsSP/+/YmKiqJy5cqkpKQ4Nr1wd3cnMjKSkiVLOrl6ESmsrFYrycnJvPjiizz33HP06tXLEdCGhITkue6lS5ewWCz4+/sDMH36dN577z3WrVt3r8sWkSJi8uTJrF+/nho1ahAXF4fFYqFevXoEBwcTHBxMTEwMO3fu1Ps7EXGqKVOmsG7dOqpXr+7YRPqZZ56hS5cueHl5UbNmTU6fPs2GDRs4ePAg77//PkeOHOE///kPbm5ujB492tlPocBTWOuiNm3axPr165k7dy4REREkJyczcuRIJkyYQN26dQkMDKRs2bJ8+umnVKtWjW7dupGamsrSpUv56aefCAsLc/ZTEJFCavbs2SxevJiNGzc6eo19swtvb2969uyJ0Whk1qxZjB8/nieeeIJixYqxYcMGTp06pY18RCRf+fv7U6xYMT788EMsFgsvvfSSY5V/bllZWRiNRvz8/JgzZw7z589nxYoV3HfffU6oWkQKu0OHDrF582bmzp1L9erV84xbycjIwMPDg7Jly7Jx40aqVavGU089pfd3InLPbdq0ic2bN/PBBx8QERFBdnY23bt3Z/369Tz++ON4eHjg7e3NO++8Q5UqVZg3bx5VqlShYsWKGAwGGjZs6OynUCgorHVRZ8+epX79+lSvXh2bzUZgYCBNmjRh9+7dpKamEhgYSI0aNXj11Vf5z3/+w4IFCwgKCiI9PZ05c+ZQunRpZz8FESmErl69ytdff03Lli0JDAwEclay/ec//+HHH38kLi6Obt260bZtWypVqsTo0aP56quv8PX1xWw28+GHH1K2bFnnPgkRKbTsHxz5+/tTp04dFi9eTHp6OgMHDnQEtvYjATw9PQkICGDkyJFER0ezdOlSfZgkIvkmNTUVm81GcHAwBoMBq9XKxIkTOXfuHFevXqVLly40bdqUgQMHMnXqVBYuXKj3dyJyz509e5YqVapQtWpVsrKyMJvN9O7dm1dffZUTJ05Qs2ZNOnbsyMWLF+nTpw9VqlTBarXi7+9P165dNff/L6Kw1kWlpaVx4MABx6esAOHh4WRkZBAfH0+ZMmVwd3enb9++tGjRgv3791O6dGmqVatGqVKlnFy9iBRWxYsXp0ePHowYMYJt27bxxBNP8Mwzz2A2mylbtix+fn4MHTqUvn37MmDAAOrUqcPPP/+M2WymRIkSeeZFiojkh3379pGSksKIESN4/PHH6devHwaDgQEDBhAQEOAIdCtUqEBcXBw7duxg1apVREREOLlyESnMMjIyuHz5sqMHPfvss3h4eFCpUiWKFy/O8OHD6du3Ly+//DKNGzfm4MGDlClThsjISL2/E5F8Z7FYMJlMxMXFcfnyZUwmk2MjRF9fX7KyshxflytXjnfeeQcPDw9sNpujrymo/esorHUx9kHykZGRXLhwgZiYGCpVqgTk/MO3WCxYLBbH9U0mExEREXqDISL3TMuWLTl16hSjR4/m9OnTVK1a1bFqzWAwULNmTcaMGUPLli2pXr06xYsXd3bJIlKIrVq1iqpVq1KrVi0A/Pz8iIiIwGAw8PDDDzN58mRef/11AEdgC1CiRAm6d+9O165dHX9riYj8lWbOnMmFCxeYNGkStWvXplatWkybNo2HH36YoKAgRo8eTbFixQCoUaMGo0ePpmnTptSpU4f777/fydWLSFFiD2JbtWrF/v37OXfuHBUqVAByjlgyGo2kp6c7rmsymbDZbApo84nCWhfx+eef8+CDDzpWnbVp04aaNWvmOdwlOTkZs9ns2AgDcmZHVqtWjYcffvie1ywiRcPWrVu5ePEiaWlpNGjQgFq1atG3b1/OnTvHggULePnllx1BLcA///lP5s+fz9mzZ3VIsYjkq7Fjx7J8+XK2bNniOC88PJzx48dTrFgxbDYbbdq0AbgpsA0MDGTw4MGOI5hERP5KEydO5KOPPnKErgEBATRv3pzPPvuM69evY7PZKFasGNnZ2ZhMJjp27MiHH37Id999R506dRSCiMg98dVXXxEbG0vx4sWpXLkyDRo0ICoqKs8RkWlpabi5ueHp6ek4b+HChdhsNnr06OGEqgs/hbUuIDY2lpkzZxIREcGIESMcYeyNcx2vXbuWZ9fimTNnMnv2bNasWXPPaxaRosG+E2hERATHjh1jy5YtPPPMM3Tu3Jl//vOfXL16ldatWzveTNhsNjIyMvDy8sLPz8/J1YtIYTZu3Dg2bNjAypUrCQ0NzRNsBAYGOmbTAo7A9q233iI1NZW33nqLgIAABbUiki/GjRvH+vXrGT58OIsXLyYmJobQ0FBeeOEFzpw5w5o1a6hYsSKJiYn4+/tjtVqxWCz4+fkRHBwM6HBiEcl/kyZNYsOGDXh4eODm5kZycjKjRo2iRYsWea536dKlPFnU9OnTee+991i3bp0Tqi4ajM4uQMDHx4f09HR27drFqFGjSEhIAMgz7sDOaDTi7u7OtGnTiIqKYvXq1VSrVu0eVywiRcHGjRvZvHkz77//Ph988AHbt2/H3d2d9evXA9CgQQOmT59OeHg4Fy5cIC4ujrS0NJYsWUJKSgrh4eFOfgYiUlhNnDiRdevW5Zk1mzvYMBgMGI3GPH9LtWnThn//+9/s3LmTzMzMe16ziBQNEyZMYO3atSxcuJAmTZpw8eJFEhMTHZePGzeObt26ER8fz5tvvsmpU6c4deoUUVFRxMbGOka6iIjkpx07dvDJJ58wc+ZM1q1bx/Tp02nRogX9+vVjwYIFef5WyszMxGg04ufnx5w5c5g/fz4rVqzgvvvuc+IzKNy0stYFmM1msrKyiIyM5MyZM4wZM4YRI0bctCrEYDDg6enJhAkTWL9+PcuWLdMsIxHJN2fOnCE8PJyIiAiysrLw8vLihRdeYMiQIRw7doxq1arh5eXFxYsXGTRoEN999x1169blwoULzJs3T5thiEi+yM7O5n//+x+lS5emXLlyAGRlZTFr1ixOnz4NQK1atXjxxRcxmUyODTMAHn/8cVq2bImvr6/T6heRwmvy5MksXLiQtWvXOj5IioiI4NNPPyUyMpLMzEzc3d15++23KV26NNu3b6ddu3ZUqVIFi8VCVFTUTUdXiojkh4SEBCpWrMgDDzwA5IyRGjFiBCEhIUycOBGz2czTTz8NgKenJwEBAYwcOZLo6GiWLl2qcXf5TGGtCzh48CBms5lx48axdetW1qxZkyewtb/JKFWqFMnJyWzfvp0VK1ZoRa2I5Av7ocRXrlwhLi4Og8GA2WwGcobLZ2ZmOoIPgDJlyjBgwADOnz9PcHAw999/P2XKlHFW+SJSyLm5ufHGG28wYsQIpk2bxoABA+jTpw+pqalERkYSExPDqlWrOHPmDOPHj8/TrwAFtSKSLywWC5UrV2b9+vXcd999jkU3FStW5NtvvwXA3d2drKwszGYzvXv35tlnn+X48eMEBwfj6+ubZ0akiEh+slqtHD16lGvXrjnm/Lu5ufHyyy9jtVoZO3YsFSpUoHHjxpQvX564uDh27NiR56gmyT8ag+ACSpYsyd///nf8/Px46qmnaNeuHadPn2bMmDEkJCQ43mTUrl2bRx99lAULFiioFZF8Yz+UuFWrVqSnp3PhwgXHZYGBgRiNRjIyMoBfx7U0atSIbt260apVKwW1IpLvIiIiaNeuHXv27GHo0KEUL16cuXPn8vbbbzN79mw6derEkSNHHCttRUTym8lkokOHDtx33315Zmj37NmTc+fO8cknnwA5R1XabDYAvLy8qFOnDuXLl1dQKyL3RHZ2NgB/+9vfqFSpErNmzeL69esYDAZHb3rxxRd5/PHHmThxIvHx8ZQpU4bu3bs79jKR/Kew1gWEhoYyZMgQfH19cXNzo2fPnjcFtnZTp07VD4eI3BNNmjQhKioqzziD5ORk3NzccHd3B3LemCxatIjFixcDOH7Bi4jkJy8vLzp06ICPjw+ffPIJoaGhFCtWDKvVitlspnPnzpw9e5YTJ044u1QRKULsAa3BYHCcLlGiBPfffz9ff/01Vqs1T5ArInKvfP7558THx+PmlnOAfbly5WjatCl79uxh7dq1JCcnYzAYsFqteHh48Oijj5KYmEhCQgJ+fn4MGjSISpUqOflZFB0Ka12Au7s7AQEBQM4qNaPR6Ahsz549yxtvvMH169edXKWIFEWlSpVyjEAAiI2NxWq1OnrW9OnTmTBhAvXr1we0c7GI3DshISEMGTKEChUq0K5dOyBnI1abzYbNZiMiIoISJUo4uUoRKeqKFy9Oly5dWLt2Lbt373aEISIi90psbCwzZ85k/PjxeTY8fO2117j//vtZunQpy5cvJz4+3rFnUrly5fDw8CAtLQ3ImVsr947CWhdjMpkc84169uzJww8/TEpKCunp6c4uTUSErKwsTCYTfn5+zJ4927ETaNWqVZ1dmogUQREREaxbt44qVarw888/k5ycTEpKCkuWLOHKlSuODchERJypdevWPPHEE4wZM4ajR486whARkXvBx8eH9PR0du3axahRo/IcvT1x4kTq1KnDunXrmDx5MufPn+fixYusWbMGg8FA6dKlnVd4EWaw6ZhVl2QPbK1WK4mJiQQGBjq7JBEpwuyH7G3evJlx48ZRt25dtm3bxrJly7QTqIg4XVxcHO3atcNkMhESEkJCQgKzZs3SjH8RcRmHDx9m1KhRlChRghkzZmA2m3VEkojcExkZGbRu3ZqwsDASEhKoVKmSY0N7u/fff5+dO3fy7bffUrlyZZKTk5k7d67+lnIShbUuzB7Yioi4iuPHj9OhQwc8PDxYtmwZkZGRzi5JRASAffv2ceTIEUqUKMEDDzxAaGios0sSEclj69atREZGUrZsWWeXIiJFyJ49exg+fDiLFi1i69atrFmzhsqVK98U2KalpXHw4EF8fX0pWbIkISEhziu6iFNYKyIidy09PZ3Jkyfz1FNPUblyZWeXIyIiIuLytKmYiDjTjz/+yPz583njjTfw9PRkwYIFfPrpp3kCWy0WdC0Ka0VE5HfJysrKs+mYiIiIiIiIuKbMzEzS0tIcm0RbrVbmz59/U2BrsVgwmUxOrlZAYa2IiIiIiIiIiEihZw9k7YHt5s2bCQ4OZtKkSY4wV5xPa5xFREREREREREQKOXtQazQa6dmzJw8//DApKSmkp6c7uzTJRStrRUREREREREREigh7YGu1WklMTMyz0Zg4n8JaERERERERERGRIkSbirkuhbUiIiIiIiIiIiIiLkARuoiIiIiIiIiIiIgLUFgrIiIiIiIiIiIi4gIU1oqIiIiIiIiIiIi4AIW1IiIiIiIiIiIiIi5AYa2IiIiIiIiIiIiIC1BYKyIiIiIiIiIiIuICFNaKiIiIiIiIiIiIuACFtSIiIiJS6FmtVmeX4JKKwvelKDxHERERKTwU1oqIiIj8RQ4fPsygQYNo2rQp1atXp1GjRjz55JMsWbKEjIwMZ5f3uxw6dIjw8HDCw8NZvnz5TZenp6dTu3ZtwsPDmTx58l3d58yZMwkPD+cf//iH47xnn32W8PBwRo4c+btve7e2bdvG888//7tv90cdOHCAV199lUaNGlG9enUaN27M4MGD+eGHH+5ZDb/lxIkTdO/enYsXL96Txysqr72IiIjIn6WwVkREROQvsHDhQrp27crGjRuJjY3F09OT69evc+jQIUaPHs0LL7xAWlqas8u8a7Vq1aJChQoAbNq06abLv/zyS1JTUwFo3779H36cYsWKERISQkBAwB++jztZsmQJr7zyChcuXMiX+7/RggULeOqpp/j888+Ji4vDy8uLK1eu8Omnn9KpUye++eabe1LHnZw4cYIOHTqwZ88ep9ZR2F57ERERkb+CwloRERGRP+mrr75iwoQJWCwWWrVqRXR0NPv27ePAgQO8+eabGI1G9u7dy8qVK51d6u/Srl07APbu3UtcXFyeyz777DMAqlatSkRExB9+jBkzZrBz504GDx78xwu9g5SUlHy531vZt28fEyZMwGaz8fjjj7Nnzx6+/fZb1q9fT9myZcnIyODNN9/EYrHcs5puJS0tzek1QOF67UVERET+KgprRURERP6k2bNnY7VaqVq1KtOnTyc0NBQAd3d3evTowdixY5k0aRJNmjRx3MY+YmDlypW0b9+eBx98kIULFwI5IwamTZvGI488QvXq1WnatCmjR48mISHBcfs9e/Y47uPKlSuO83v16kV4eDhDhw4F4KeffnJc78iRI/Tq1YtatWrRrFkzoqKisNlst31e9hWzVqvVEc4CZGRksGPHDgD++c9/AnD16lXefPNNxwiI+vXr89JLL3HmzJk7fu9udSj81atXGTx4MHXr1qV+/fqMHz+e7Ozsm277W485c+ZM3n33XQBiYmIIDw9nzZo1jtuvXr2aTp068cADD1CvXj369evHyZMn8zzGnV6nG73//vvYbDYiIiKYMGECgYGBAERERDB69Gjq16/P448/TnJysuM2J06coH///vz973+nZs2adOjQgdWrV+e536FDhxIeHk6vXr0c5125csVRm32FrH1cQP/+/dmxYwePPfYYNWrUoH379nz55ZdAzr+bLl26OO6nRYsWjn8rucXGxlKtWjXCw8Mdt7Vr06YN4eHhzJo1665eh9spyK/9kiVLaN++PbVr1+bBBx/kySefZOvWrXd8viIiIiJ3w83ZBYiIiIgUZNeuXWP//v0APPHEE5hMppuu06lTp9veftSoUZjNZjIzM6lVqxaZmZl0796dQ4cOAeDr60tsbCxLlizhq6++Yvny5Y4Q8Pfq06cP165dw93dnUuXLvHuu++Snp5O//79b3n9sLAwqlevzpEjR9i0aRNPP/00ALt27SIlJQWDwUDbtm0BeOWVV/jf//6Hm5sb/v7+XLt2jejoaM6ePcvmzZvvusasrCx69uzJ999/73j+CxYswMvL66br/tZj+vr64uvrS3JyMiaTieDgYMf9jBs3zhG8eXt7k5yczNatW/nqq69YsGABtWrVyvNYN75ON7JYLOzduxeA5s2bYzAY8lzeqFEjGjVqlOe8gwcP0r17dzIyMjCZTHh4eHDs2DHeeustTp06xRtvvHHX37fcvvvuO7Zt24aXlxeZmZmcPHmSAQMGEB0djbu7O0FBQcTHxwNQokSJW44hCAkJoWnTpnzxxRds2LCBZs2aAXDs2DFOnz6NwWCgQ4cOQNF77ZcsWcLo0aMBCAwMJDMzk0OHDtG/f3/mz59PgwYN7vo5i4iIiNxIK2tFRERE/oTcGzSVL1/ecXrfvn00bdo0z3+5VzTahYWF8fXXX7Nr1y4eeOABli5dyqFDhzCbzXz00Ufs37+fdevWERgYyNmzZx2rGf+IkJAQdu/ezbfffusYcfDhhx+SlJR029vYV9fu37+f2NhYALZs2QJA3bp1CQ0NJT4+nmLFilG5cmW2bNnC119/zbx58wA4c+YM169fv+sat2/f7gjrxo8fz/79+1m7du1N17ubx3z++efp06cPAKVKlWLnzp08+uijHD9+3BHWDRgwgP3797N7925q1apFamoqw4cPv+nxbnydbpSQkOCY4Vu6dOm7eq7//ve/ycjIoFatWuzevZv9+/czYMAAAObPn8+RI0fu6n5udPHiRYYNG8b+/fuZOnUqAKmpqezbt4/atWszd+5cx3WXLVvGm2++ecv76dy5M5Dzmtif2yeffAJAgwYNiuxrv3PnTiBnFfuePXvYu3cvTz31FC1atCAxMfGun6+IiIjIrSisFREREfmLGI2//mmVmZlJbGxsnv9yjyuwa9OmDZ6engQFBQE4DqVu06YNDRs2BCAyMpKnnnoqz+V/RK9evQgKCsJsNvPaa68BOSMX7hQKtm3bFpPJhM1mY/PmzWRmZvLFF18Avwa5QUFBzJ07lw0bNpCUlMTSpUtZsWKF4z5+z+zQgwcPAlCpUiU6duwIQLVq1WjVqlWe6/2Zx7R/D8uUKUPfvn0xGo0EBQUxcOBAAE6ePMn58+fz3ObG1+lGVqvVcfpOoyXsLly4wPHjxwEYOHAgQUFBGI1G+vbtS5kyZQDYtm3bb97Prfj6+jr+vTzyyCOO83/vDNeHHnqI4OBgUlNT2bZtG1arlY0bNwK/rhYviq99ZGQkAIsXL+all15iyZIlPPHEE8yaNYvWrVvf9fMVERERuRWNQRARERH5E0JDQzEYDNhsNs6cOeM4XLxhw4acOHECyJmfebsVsSVKlMjztT3QLVeuXJ7zy5YtC+TM6rxR7nDwThtH5X6sUqVKOU7faTVgiRIl+Pvf/85XX33F5s2bqVChAsnJyZjNZv7xj384rvfRRx8RFRXlWPUYHh7uuCx3kPlb7Kt8b/y+5K73zz6mfbO0smXL5hlXYP8e26+Te6X0jfXcKDAwEHd3dzIzM/n5559vujw5OZnvvvuOevXqYTKZ8mzYlvu1NhgMhIaGcvHixVu+1nZ3ep2DgoIcz8vNzQ2z2UxWVtbveh3st33sscf48MMP+fTTTylRogSXL1/G398/T4Ba1F77l19+mezsbFatWkV0dDTR0dFAzgrcSZMmUbNmzd98riIiIiK3o5W1IiIiIn9CYGAgdevWBWDNmjW33AzpTsGap6dnnq/twdCFCxfynG//2n75jat47e400iD3fdpHGtifw53YV9AePHiQ+fPnA9CkSRPH7Xbv3s2ECRNIS0tjxYoVfPPNN7z99tt3vM/bsc9PzV3frb7+M48ZHBwM5Gw8lTvo/umnnxynbwzobnydbmQ2mx3/Dr744oubVtdu3ryZHj160LBhQ2JjYx01QN7XxWazERMTk6cGe6h4t6/zjXOTb5yfe+PXd2IfhfDf//7XsUFX27Zt8fDwAIrma+/u7u7YxG3lypW8+eabVKtWjR9//PGWm7WJiIiI/B4Ka0VERET+pH79+mEwGDh58iQDBw50hEupqalERUXx4Ycf3va2NwZn9pW5mzZt4r///S8Ax48fZ+nSpcCvh7X7+/s7brNv3z4gZ/Mn+2reW/noo4+4cuUKFouFOXPmADkbLFWvXv2Oz69Vq1aOwMq+iZY9wAUcc0aNRiOlSpUiOzvbUS/c3VgAu3r16gFw9uxZx7zSI0eO8Pnnn+e53t0+pptbzoFkaWlpWK1WsrOzeeihh4CcwG7evHlYrVbi4+Md812rVat208rmuwk4X3zxRUdtw4cPd6xY3rdvH1OmTAGgcuXKhISEUK5cOapUqQLA1KlTiY+Px2azMW/ePC5evIjBYHC81vYQ8+TJk477tAenf0TuMDc1NfWWHzDYVapUiTp16pCVlcWGDRuAvBvmFbXX3maz0aVLFx544AEmTJhAtWrV6NGjB48++ihw65XvIiIiIr+HxiCIiIiI/EkNGjRg6NChTJo0ic8//5ytW7dSrFgxkpKSyMrKAnICn7Zt2/7mfT377LN8+umnfP/99zz//POOHe0BqlSpQr9+/RynS5YsyeXLl3nrrbd4//33OXfuHMHBwbc8DB9yAqpmzZrh4eHh2DCqT58++Pj43LEmX19fHn74YTZv3gyAj48PzZs3d1xeu3ZtIGdWaIsWLTCbzY77B7h+/fpNAdjtNG3alDp16nDgwAGGDh3KmDFjSElJoWTJkqSlpf3ux7Q/bnx8PH/729/o378/zz33HF26dGH58uVMmzaNqKgoMjIysFgs+Pj4MHbs2Luq9UaNGjVi8ODBvPvuu6xatYrVq1fj6+vrWAUbHBzM+PHjHdcfOXIkvXr14tChQzRu3Pim1yUiIgLI+ff10UcfkZCQQIsWLQgICCApKQlPT0/S09N/d51lypTBaDRitVrp0qULTZo0YcaMGbe9fufOnTlw4AA2m4377ruPGjVqOC4raq+9wWDg8ccf5+DBgyxdupT169fj5ubmCNHtK5FFRERE/iitrBURERH5C/To0YMVK1bQqVMnypUrR0pKCh4eHtx///306tWLzZs3M3jw4N+8H09PT5YuXUrfvn2pUKECGRkZhISE8Oyzz/J///d/+Pn5ATmrI+fOnUutWrUwmUxkZ2fz9ttvO1b43crEiRNp2rQpFouF0qVL88Ybb9C3b9+7en65V9LmXmkLULduXcaOHUv58uUxmUyEhIQwdOhQ7r//fgDHCuG7YTQaee+99+jYsSO+vr6YzWZ69OjBkCFD8lzvbh+zadOmtG3bFh8fH9zc3PD29gZg1KhRjB07lurVq2Oz2fDx8eGRRx5h5cqVjvv4I3r37s3ChQt56KGHCAgIIDMzk4oVK/Lss8+yevVqKlSo4Lhu/fr1WblyJa1bt8bf35/s7GyqVavGxIkTHRteQc5q6zfeeIOQkBCysrKoUKECS5Ys+c3RDLcTFBTEgAEDKF68OIDj39TtPProo45AP/eqWiiar323bt2YPn06tWvXxs3NjezsbMLDwxk2bBiDBg266+crIiIicisG2+85NklERERECpSffvqJFi1aALB8+XIeeOAB5xYkIiIiIiK3pZW1IiIiIiIiIiIiIi5AYa2IiIiIiIiIiIiIC9AYBBEREREREREREREXoJW1IiIiIiIiIiIiIi5AYa2IiIiIiIiIiIiIC1BYKyIiIiIiIiIiIuICFNaKiIiIiIiIiIiIuACFtSIiIiIiIiIiIiIuQGGtiIiIiIiIiIiIiAtQWCsiIiIiIiIiIiLiAhTWioiIiIiIiIiIiLgAhbUiIiIiIiIiIiIiLuD/AXSLIU5UzWTDAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "GROUP VALIDATOR COUNT EFFECT SUMMARY\n", + "============================================================\n", + "\n", + "Theoretical Minimum:\n", + " SNARK1 time range: 169.2 - 1353.6 ms\n", + " Time difference: 1184.4 ms\n", + " 128 validators: 169.2 ms\n", + " 256 validators: 338.4 ms\n", + " 512 validators: 676.8 ms\n", + " 768 validators: 1015.2 ms\n", + " 1024 validators: 1353.6 ms\n", + "\n", + "Gossip (idontwant=False):\n", + " SNARK1 time range: 658.0 - 2980.0 ms\n", + " Time difference: 2322.0 ms\n", + " Avg duplicates per validator range: 1.175 - 2.197\n", + " Overall avg duplicates per validator: 1.646\n", + " Total signature duplicates range: 134 - 1423 messages\n", + " 128 validators: 658.0 ms (avg dups: 1.175)\n", + " 256 validators: 1142.0 ms (avg dups: 2.197)\n", + " 512 validators: 1705.0 ms (avg dups: 1.527)\n", + " 768 validators: 2389.0 ms (avg dups: 2.062)\n", + " 1024 validators: 2980.0 ms (avg dups: 1.270)\n", + "\n", + "Gossip (idontwant=True):\n", + " SNARK1 time range: 610.0 - 3070.0 ms\n", + " Time difference: 2460.0 ms\n", + " Avg duplicates per validator range: 0.841 - 2.279\n", + " Overall avg duplicates per validator: 1.556\n", + " Total signature duplicates range: 225 - 1151 messages\n", + " 128 validators: 610.0 ms (avg dups: 1.974)\n", + " 256 validators: 1126.0 ms (avg dups: 2.279)\n", + " 512 validators: 1672.0 ms (avg dups: 0.841)\n", + " 768 validators: 2479.0 ms (avg dups: 1.668)\n", + " 1024 validators: 3070.0 ms (avg dups: 1.018)\n", + "\n", + "Grid:\n", + " SNARK1 time range: 548.0 - 2313.0 ms\n", + " Time difference: 1765.0 ms\n", + " Avg duplicates per validator range: 0.407 - 0.579\n", + " Overall avg duplicates per validator: 0.500\n", + " Total signature duplicates range: 66 - 437 messages\n", + " 128 validators: 548.0 ms (avg dups: 0.579)\n", + " 256 validators: 677.0 ms (avg dups: 0.559)\n", + " 512 validators: 1171.0 ms (avg dups: 0.407)\n", + " 768 validators: 1949.0 ms (avg dups: 0.480)\n", + " 1024 validators: 2313.0 ms (avg dups: 0.475)\n", + "\n", + "============================================================\n", + "EXAMPLE 4: Local Aggregator Count Analysis\n", + "============================================================\n", + "Testing Local Aggregator Count: [10, 102, 256, 512]\n", + "Topologies: ['gossip', 'grid']\n", + "Running simulations in parallel with 5 workers (ThreadPoolExecutor)...\n", + "\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/cae71f452a88a77b322300762f11d38a -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/8ff96d8dd3f6138cdafa2090344e6f75 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/6250869bdad7c53d45cf73f75cb2ed53 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/034cc318dd408caee56e55c2d230ffe5 -t gossip --local-aggregation-only --report\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/cfc37bb991c74840b9749a604f6188ca -t gossip --local-aggregation-only --report\n", + " [1/12] Gossip - 102 aggregators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/86e56681c2d045acce3b6bb4077e2dd2 -t gossip --local-aggregation-only --report\n", + " [1/12] Gossip - 102 aggregators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/86e56681c2d045acce3b6bb4077e2dd2 -t gossip --local-aggregation-only --report\n", + " [2/12] Gossip - 10 aggregators (idontwant=False): 3550.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/9b2a3e84657e53d586abb0aca87bd7a9 -t gossip --local-aggregation-only --report\n", + " [2/12] Gossip - 10 aggregators (idontwant=False): 3550.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/9b2a3e84657e53d586abb0aca87bd7a9 -t gossip --local-aggregation-only --report\n", + " [3/12] Gossip - 256 aggregators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/50f67ca98081197783189324e3a7c264 -t gossip --local-aggregation-only --report\n", + " [3/12] Gossip - 256 aggregators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/50f67ca98081197783189324e3a7c264 -t gossip --local-aggregation-only --report\n", + " [4/12] Gossip - 512 aggregators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/3a25d6f1f0706059e166dae876f05d78 -t grid --local-aggregation-only --report\n", + " [4/12] Gossip - 512 aggregators (idontwant=False): 2980.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/3a25d6f1f0706059e166dae876f05d78 -t grid --local-aggregation-only --report\n", + " [5/12] Grid - 10 aggregators: 2436.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/ea20dcfce43e639041b36f24d00d5c9f -t grid --local-aggregation-only --report\n", + " [5/12] Grid - 10 aggregators: 2436.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/ea20dcfce43e639041b36f24d00d5c9f -t grid --local-aggregation-only --report\n", + " [6/12] Grid - 102 aggregators: 2313.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/0b83cc6b049e414fecb0ca5726357460 -t grid --local-aggregation-only --report\n", + " [6/12] Grid - 102 aggregators: 2313.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/0b83cc6b049e414fecb0ca5726357460 -t grid --local-aggregation-only --report\n", + " [7/12] Grid - 256 aggregators: 2313.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/20603534d7be05ed71db9d8ea7390546 -t grid --local-aggregation-only --report\n", + " [7/12] Grid - 256 aggregators: 2313.0 ms\n", + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/20603534d7be05ed71db9d8ea7390546 -t grid --local-aggregation-only --report\n", + " [8/12] Grid - 512 aggregators: 2307.0 ms\n", + " [8/12] Grid - 512 aggregators: 2307.0 ms\n", + " [9/12] Gossip - 256 aggregators (idontwant=True): 2884.0 ms\n", + " [9/12] Gossip - 256 aggregators (idontwant=True): 2884.0 ms\n", + " [10/12] Gossip - 512 aggregators (idontwant=True): 2826.0 ms\n", + " [10/12] Gossip - 512 aggregators (idontwant=True): 2826.0 ms\n", + " [11/12] Gossip - 102 aggregators (idontwant=True): 3070.0 ms\n", + " [11/12] Gossip - 102 aggregators (idontwant=True): 3070.0 ms\n", + " [12/12] Gossip - 10 aggregators (idontwant=True): 3248.0 ms\n", + " [12/12] Gossip - 10 aggregators (idontwant=True): 3248.0 ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "LOCAL AGGREGATOR COUNT EFFECT SUMMARY\n", + "============================================================\n", + "\n", + "Theoretical Minimum:\n", + " SNARK1 time range: 1353.6 - 1353.6 ms\n", + " Time difference: 0.0 ms\n", + " 10 aggregators: 1353.6 ms\n", + " 102 aggregators: 1353.6 ms\n", + " 256 aggregators: 1353.6 ms\n", + " 512 aggregators: 1353.6 ms\n", + "\n", + "Gossip (idontwant=False):\n", + " SNARK1 time range: 2980.0 - 3550.0 ms\n", + " Time difference: 570.0 ms\n", + " Avg duplicates per validator range: 1.270 - 2.023\n", + " Overall avg duplicates per validator: 1.458\n", + " Total signature duplicates range: 1168 - 1875 messages\n", + " 10 aggregators: 3550.0 ms (avg dups: 2.023)\n", + " 102 aggregators: 2980.0 ms (avg dups: 1.270)\n", + " 256 aggregators: 2980.0 ms (avg dups: 1.270)\n", + " 512 aggregators: 2980.0 ms (avg dups: 1.270)\n", + "\n", + "Gossip (idontwant=True):\n", + " SNARK1 time range: 2826.0 - 3248.0 ms\n", + " Time difference: 422.0 ms\n", + " Avg duplicates per validator range: 0.868 - 1.636\n", + " Overall avg duplicates per validator: 1.139\n", + " Total signature duplicates range: 799 - 1507 messages\n", + " 10 aggregators: 3248.0 ms (avg dups: 1.636)\n", + " 102 aggregators: 3070.0 ms (avg dups: 1.018)\n", + " 256 aggregators: 2884.0 ms (avg dups: 1.033)\n", + " 512 aggregators: 2826.0 ms (avg dups: 0.868)\n", + "\n", + "Grid:\n", + " SNARK1 time range: 2307.0 - 2436.0 ms\n", + " Time difference: 129.0 ms\n", + " Avg duplicates per validator range: 0.475 - 0.497\n", + " Overall avg duplicates per validator: 0.484\n", + " Total signature duplicates range: 437 - 457 messages\n", + " 10 aggregators: 2436.0 ms (avg dups: 0.490)\n", + " 102 aggregators: 2313.0 ms (avg dups: 0.475)\n", + " 256 aggregators: 2313.0 ms (avg dups: 0.475)\n", + " 512 aggregators: 2307.0 ms (avg dups: 0.497)\n" + ] + } + ], "source": [ "# Example analyses for new parameters using the refactored framework\n", "# These demonstrate how easy it is to analyze different parameters\n", @@ -906,7 +1457,7 @@ "mesh_n_values = [4, 6, 8, 10, 12] # Different mesh sizes\n", "base_config = {'mpi': False, 'signature_size': 3072}\n", "\n", - "mesh_n_results = analyze_mesh_n_effect(mesh_n_values, topologies=[\"gossip\"], max_workers=5, **base_config)\n", + "mesh_n_results = analyze_mesh_n_effect(mesh_n_values, topologies=[\"gossip\"], max_workers=5, idontwant=True, **base_config)\n", "\n", "\n", "# Example 2: Analyze non_mesh_n effect (gossip non-mesh connections)\n", @@ -928,7 +1479,7 @@ "validator_counts = [128, 256, 512, 768, 1024] # Different validator counts per group\n", "base_config = {'mpi': False, 'signature_size': 3072}\n", "\n", - "validator_count_results = analyze_group_validator_count_effect(validator_counts, topologies=[\"gossip\", \"grid\"], **base_config)\n", + "validator_count_results = analyze_group_validator_count_effect(validator_counts, topologies=[\"gossip\", \"grid\"], idontwant=True, **base_config)\n", "\n", "\n", "# Example 4: Analyze local aggregator count effect\n", @@ -936,10 +1487,10 @@ "print(\"EXAMPLE 4: Local Aggregator Count Analysis\")\n", "print(\"=\"*60)\n", "\n", - "aggregator_counts = [\"1%\", \"10%\", \"25%\", \"50%\"] # Different local aggregator counts\n", + "aggregator_counts = [10, 102, 256, 512] # Different local aggregator counts\n", "base_config = {'mpi': False, 'signature_size': 3072}\n", "\n", - "aggregator_count_results = analyze_local_aggregator_count_effect(aggregator_counts, topologies=[\"gossip\", \"grid\"], max_workers=5, **base_config)" + "aggregator_count_results = analyze_local_aggregator_count_effect(aggregator_counts, topologies=[\"gossip\", \"grid\"], max_workers=5, idontwant=True, **base_config)" ] } ], diff --git a/beamsim.py b/beamsim.py index 9067a19..a16cb55 100644 --- a/beamsim.py +++ b/beamsim.py @@ -52,6 +52,12 @@ def get_snark1_received(items): return rows2 +def get_signature_duplicates(items): + _, _, duplicates, signatures = filter_report(items, "signature-duplicates")[0] + avg_duplicates = duplicates / signatures + return duplicates, avg_duplicates + + class Metrics: def __init__(self, items): rows = filter_report(items, "metrics") @@ -87,7 +93,7 @@ def __init__(self, items): ] exe = "build/beamsim" -if not os.path.exists(exe): # for docker build +if not os.path.exists(exe): # for docker build exe = "/usr/local/bin/beamsim" if not os.path.exists(exe): raise FileNotFoundError( diff --git a/main.cpp b/main.cpp index dde3e84..9201ed0 100644 --- a/main.cpp +++ b/main.cpp @@ -167,6 +167,7 @@ namespace beamsim::example { bool stop_on_create_snark1; PeerIndex snark2_received = 0; bool done = false; + std::optional> signature_duplicates; PeerIndex snark1_threshold(const Roles::Group &group) const { return group.validators.size() * consts().snark1_threshold; @@ -242,6 +243,12 @@ namespace beamsim::example { } thread_.run(simulator_, consts().signature_time, [this] { MessageSignature signature{peer_index_}; + + // For idontwant mode, attach our current signature knowledge + if (shared_state_.gossip_config.idontwant) { + signature.seen_signatures = signatures_seen; + } + _onMessageSignature(signature); sendSignature(std::make_shared(std::move(signature))); }); @@ -347,6 +354,13 @@ namespace beamsim::example { if (not aggregating_snark1.has_value()) { return; } + + // For gossip topology with idontwant, track signature for optimization + if (shared_state_.gossip_config.idontwant) { + // Update our knowledge of signatures we've seen + signatures_seen.set(message.peer_index); + } + aggregating_snark1->peer_indices.set(message.peer_index); PeerIndex threshold = shared_state_.snark1_threshold(group_); auto received = aggregating_snark1->peer_indices.ones(); @@ -355,6 +369,10 @@ namespace beamsim::example { } auto snark1 = std::move(aggregating_snark1.value()); aggregating_snark1.reset(); + if (not shared_state_.signature_duplicates) { + shared_state_.signature_duplicates.emplace(signature_duplicates, + signatures_seen.ones()); + } thread_.run(simulator_, timeSeconds(received / consts().aggregation_rate_per_sec), [this, snark1{std::move(snark1)}]() mutable { @@ -509,11 +527,42 @@ namespace beamsim::example { }; } + void checkSignatureDuplicates(const MessagePtr &any_message) { + if (not aggregating_snark1.has_value()) { + return; + } + if (auto *message = dynamic_cast(any_message.get())) { + if (auto *signature = + std::get_if(&message->variant)) { + if (signatures_seen.get(signature->peer_index)) { + ++signature_duplicates; + } else { + signatures_seen.set(signature->peer_index); + assert2(signatures_seen.get(signature->peer_index)); + } + } + return; + } + if (auto *message = dynamic_cast(any_message.get())) { + for (auto &publish : message->publish) { + checkSignatureDuplicates(publish.message); + } + return; + } + if (auto *message = dynamic_cast(any_message.get())) { + checkSignatureDuplicates(message->message); + return; + } + abort(); + } + SharedState &shared_state_; GroupIndex group_index_; const Roles::Group &group_; bool snark2_received = false; std::optional aggregating_snark1; + BitSet signatures_seen; + uint32_t signature_duplicates = 0; // TODO: remove when aggregating multiple times size_t snark1_received = 0; std::optional aggregating_snark2; @@ -551,6 +600,7 @@ namespace beamsim::example { // IPeer void onMessage(PeerIndex from_peer, MessagePtr any_message) override { + checkSignatureDuplicates(any_message); auto forward_snark1 = [this, from_peer, any_message] { // global aggregator forwards snark1 from local aggregator to global aggregators if (shared_state_.roles.roles.at(from_peer) == Role::LocalAggregator @@ -621,7 +671,8 @@ namespace beamsim::example { PeerIndex index, SharedState &shared_state, Random &random) - : PeerBase{simulator, index, shared_state}, gossip_{*this, random,shared_state_.gossip_config} {} + : PeerBase{simulator, index, shared_state}, + gossip_{*this, random, shared_state_.gossip_config} {} // IPeer void onStart() override { @@ -629,6 +680,7 @@ namespace beamsim::example { gossip_.start(); } void onMessage(PeerIndex from_peer, MessagePtr any_message) override { + checkSignatureDuplicates(any_message); if (onMessagePull(from_peer, any_message, nullptr)) { return; } @@ -639,6 +691,10 @@ namespace beamsim::example { auto &message = dynamic_cast(*any_message); if (auto *signature = std::get_if(&message.variant)) { + // For idontwant mode, update our signature tracking + if (shared_state_.gossip_config.idontwant) { + gossip_.updateOwnSignature(signature->peer_index); + } onMessageSignature(*signature, std::move(forward)); } else if (std::holds_alternative( message.variant)) { @@ -658,6 +714,16 @@ namespace beamsim::example { if (signatureHalfDirect(message) or signatureDirect(message)) { return; } + + // For idontwant mode, update our signature tracking before sending + if (shared_state_.gossip_config.idontwant) { + if (auto example_msg = dynamic_cast(message.get())) { + if (auto *signature = std::get_if(&example_msg->variant)) { + gossip_.updateOwnSignature(signature->peer_index); + } + } + } + gossip_.gossip(topicSignature(shared_state_.roles.group_of_validator.at( peer_index_)), std::move(message)); @@ -681,6 +747,7 @@ namespace beamsim::example { // IPeer void onMessage(PeerIndex from_peer, MessagePtr any_message) override { + checkSignatureDuplicates(any_message); if (onMessagePull(from_peer, any_message, nullptr)) { return; } @@ -899,6 +966,12 @@ void run_simulation(const SimulationConfig &config) { done ? "SUCCESS" : "FAILURE"); } metrics.end(simulator_time); + if (shared_state.signature_duplicates) { + auto [signature_duplicates, signatures] = + shared_state.signature_duplicates.value(); + beamsim::example::report( + simulator, "signature-duplicates", signature_duplicates, signatures); + } beamsim::example::report_flush(); }; diff --git a/src/beamsim/example/message.hpp b/src/beamsim/example/message.hpp index 2bf2789..3c4cca0 100644 --- a/src/beamsim/example/message.hpp +++ b/src/beamsim/example/message.hpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include @@ -17,12 +18,16 @@ namespace beamsim::example { decodeFrom(from, v.limbs_); } + static auto split(PeerIndex i) { + return std::make_pair(i / limb_bits, Limb{1} << (i % limb_bits)); + } + void set(PeerIndex i) { - size_t i1 = i / limb_bits, i2 = i % limb_bits; + auto [i1, mask] = split(i); if (limbs_.size() <= i1) { limbs_.resize(i1 + 1); } - limbs_[i1] |= Limb{1} << i2; + limbs_.at(i1) |= mask; } void set(const BitSet &other) { if (limbs_.size() < other.limbs_.size()) { @@ -34,8 +39,8 @@ namespace beamsim::example { } bool get(PeerIndex i) const { - size_t i1 = i / limb_bits, i2 = i % limb_bits; - return i1 < limbs_.size() and (limbs_[i1] >> i2) == 1; + auto [i1, mask] = split(i); + return i1 < limbs_.size() and (limbs_.at(i1) & mask) != 0; } std::optional findOne(PeerIndex begin) const { @@ -67,8 +72,33 @@ namespace beamsim::example { std::vector limbs_; }; + // Forward declarations for template specializations + void encodeTo(beamsim::MessageEncodeTo &to, const std::optional &v); + void decodeFrom(beamsim::MessageDecodeFrom &from, std::optional &v); + + // Implementations + inline void encodeTo(beamsim::MessageEncodeTo &to, const std::optional &v) { + beamsim::encodeTo(to, v.has_value()); + if (v.has_value()) { + encodeTo(to, v.value()); + } + } + + inline void decodeFrom(beamsim::MessageDecodeFrom &from, std::optional &v) { + bool has_value; + beamsim::decodeFrom(from, has_value); + if (has_value) { + BitSet bitset; + decodeFrom(from, bitset); + v = std::move(bitset); + } else { + v = std::nullopt; + } + } + struct MessageSignature { PeerIndex peer_index; + std::optional seen_signatures; // Bitfield of signatures this peer has seen (for idontwant mode) }; struct MessageIhaveSnark1 { BitSet peer_indices; @@ -113,6 +143,7 @@ namespace beamsim::example { encodeTo(to, (uint8_t)variant.index()); if (auto *signature = std::get_if(&variant)) { encodeTo(to, signature->peer_index); + encodeTo(to, signature->seen_signatures); } else if (auto *snark1 = std::get_if(&variant)) { encodeTo(to, snark1->peer_indices); } else if (auto *snark1 = std::get_if(&variant)) { @@ -130,6 +161,7 @@ namespace beamsim::example { case 0: { MessageSignature signature; decodeFrom(from, signature.peer_index); + decodeFrom(from, signature.seen_signatures); return std::make_shared(std::move(signature)); } case 1: { diff --git a/src/beamsim/gossip/peer.hpp b/src/beamsim/gossip/peer.hpp index 60d036c..8cc69ee 100644 --- a/src/beamsim/gossip/peer.hpp +++ b/src/beamsim/gossip/peer.hpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -60,6 +61,21 @@ namespace beamsim::gossip { void subscribe(TopicIndex topic_index, View &&view) { views_.emplace(topic_index, std::move(view)); } + + // Get the current signature bitfield for this peer (for idontwant mode) + const beamsim::example::BitSet& getSignatureBitfield() const { + auto it = peer_signatures_.find(peer_.peer_index_); + if (it != peer_signatures_.end()) { + return it->second; + } + static const beamsim::example::BitSet empty_bitset; + return empty_bitset; + } + + // Update our own signature bitfield when we see a new signature + void updateOwnSignature(PeerIndex signature_peer_index) { + peer_signatures_[peer_.peer_index_].set(signature_peer_index); + } void onMessage(PeerIndex from_peer, const MessagePtr &any_message, @@ -77,6 +93,29 @@ namespace beamsim::gossip { } getBatch(to_peer).idontwant.emplace_back(message_hash); } + + // For signature messages, extract signature information and update peer knowledge + if (isSignatureMessage(publish.message)) { + try { + auto &example_message = dynamic_cast(*publish.message); + if (auto *signature = std::get_if(&example_message.variant)) { + // Update our knowledge that the sender has this signature + peer_signatures_[from_peer].set(signature->peer_index); + + // If the message contains piggybacked signature information, update our knowledge + if (signature->seen_signatures.has_value()) { + // Update our knowledge of what signatures the sender has + updatePeerSignatureKnowledge(from_peer, signature->seen_signatures.value()); + } + + // When forwarding, add our own signature bitfield to help others know what we have + // This is the "piggybacking" part - we attach our signature knowledge when forwarding + attachSignatureBitfieldToForward(publish.topic_index); + } + } catch (const std::bad_cast&) { + // Not an example message, ignore + } + } } promises_.erase(message_hash); if (not duplicate_cache_.emplace(message_hash).second) { @@ -117,19 +156,96 @@ namespace beamsim::gossip { if (not duplicate_cache_.emplace(message_hash).second) { return; } + + // Check if this is a signature message and handle bitfield piggybacking + if (config_.idontwant && isSignatureMessage(any_message)) { + handleSignaturePiggybacking(topic_index, any_message); + } + _gossip({topic_index, peer_.peer_index_, any_message}, message_hash); } private: + bool isSignatureMessage(const MessagePtr &message) { + // Check if the message is a signature message from beamsim::example + // We need to cast to check the variant + try { + auto &example_message = dynamic_cast(*message); + return std::holds_alternative(example_message.variant); + } catch (const std::bad_cast&) { + return false; + } + } + + void handleSignaturePiggybacking(TopicIndex /*topic_index*/, const MessagePtr &message) { + // Update our knowledge of signatures when we see a signature message + try { + auto &example_message = dynamic_cast(*message); + if (auto *signature = std::get_if(&example_message.variant)) { + // Track which signatures this peer has seen + auto peer_index = signature->peer_index; + peer_signatures_[peer_.peer_index_].set(peer_index); + + // If the message has signature bitfield information, update our knowledge + if (signature->seen_signatures.has_value()) { + peer_signatures_[peer_.peer_index_].set(signature->seen_signatures.value()); + } + } + } catch (const std::bad_cast&) { + // Not an example message, ignore + } + } + + void updatePeerSignatureKnowledge(PeerIndex from_peer, const beamsim::example::BitSet &signature_bitfield) { + // Update our knowledge of what signatures the sending peer has + peer_signatures_[from_peer] = signature_bitfield; + } + + bool shouldSendSignatureToPeer(PeerIndex to_peer, PeerIndex signature_peer_index) { + // Check if the target peer already has this signature + auto it = peer_signatures_.find(to_peer); + if (it != peer_signatures_.end()) { + return !it->second.get(signature_peer_index); + } + // If we don't know what signatures they have, send it + return true; + } + void _gossip(const Publish &publish, MessageHash message_hash) { mcache_.emplace(message_hash, publish); history_[publish.topic_index].add(message_hash); + + // size_t total_peers = views_.at(publish.topic_index).publishTo().size(); + size_t skipped_peers = 0; + for (auto &to_peer : views_.at(publish.topic_index).publishTo()) { if (dontwant_.contains({to_peer, message_hash})) { continue; } + + // For signature messages with idontwant enabled, check if peer already has the signature + if (config_.idontwant && isSignatureMessage(publish.message)) { + try { + auto &example_message = dynamic_cast(*publish.message); + if (auto *signature = std::get_if(&example_message.variant)) { + if (!shouldSendSignatureToPeer(to_peer, signature->peer_index)) { + skipped_peers++; + continue; // Skip sending this signature to this peer + } + } + } catch (const std::bad_cast&) { + // Not an example message, proceed normally + } + } + getBatch(to_peer).publish.emplace_back(publish); } + + // Report on idontwant efficiency for signature messages + if (config_.idontwant && isSignatureMessage(publish.message) && skipped_peers > 0) { + // This would be reported if we had access to the reporting mechanism + // report("signature_idontwant_skipped", skipped_peers, total_peers); + } } Message &getBatch(PeerIndex to_peer) { @@ -168,13 +284,23 @@ namespace beamsim::gossip { } } } - for (auto &history : history_ | std::views::values) { + for (auto &[topic, history] : history_) { history.shift([this](const MessageHash &message_hash) { mcache_.erase(message_hash); }); } } + void attachSignatureBitfieldToForward(TopicIndex /*topic_index*/) { + // When forwarding signature messages, we can piggyback our own signature bitfield + // to inform other peers about which signatures we have + // This helps with the idontwant optimization for signatures + + // For now, we rely on the existing peer_signatures_ tracking + // In a full implementation, we would add this to the gossip message + // but for this approach we track it separately + } + IPeer &peer_; Random &random_; Config &config_; @@ -185,5 +311,7 @@ namespace beamsim::gossip { std::unordered_set promises_; std::unordered_map mcache_; std::unordered_map history_; + // Track which signatures each peer has for idontwant mode + std::unordered_map peer_signatures_; }; } // namespace beamsim::gossip diff --git a/src/beamsim/ns3/mpi.hpp b/src/beamsim/ns3/mpi.hpp index 85dec01..9014ba9 100644 --- a/src/beamsim/ns3/mpi.hpp +++ b/src/beamsim/ns3/mpi.hpp @@ -5,6 +5,7 @@ #endif #include +#include namespace beamsim { using MpiIndex = uint32_t;